From aabe95dc9b26e6b900748bb9443d2d746d5dd22d Mon Sep 17 00:00:00 2001
From: "github-classroom[bot]"
 <66690702+github-classroom[bot]@users.noreply.github.com>
Date: Fri, 8 Nov 2024 10:00:23 +0000
Subject: [PATCH 001/106] Setting up GitHub Classroom Feedback


From ea4ca7a4c86cfb49d7dd6ff62715b8265a6e995f Mon Sep 17 00:00:00 2001
From: Soy17 <thdudlee0617@naver.com>
Date: Mon, 11 Nov 2024 12:59:38 +0900
Subject: [PATCH 002/106] Create README.md

---
 README.md | 101 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 101 insertions(+)
 create mode 100644 README.md

diff --git a/README.md b/README.md
new file mode 100644
index 0000000..cbec1bf
--- /dev/null
+++ b/README.md
@@ -0,0 +1,101 @@
+# 📋 Project Overview
+
+
+![project_image](https://github.com/user-attachments/assets/15a67fec-8077-492e-a517-f4a0cee5acbf)
+
+뼈는 우리 몸의 구조와 기능에 중요한 영향을 미치기 때문에, 정확한 뼈 분할은 의료 진단 및 치료 계획을 개발하는 데 필수적입니다.
+
+Bone Segmentation은 인공지능 분야에서 중요한 응용 분야 중 하나로, 특히, 딥러닝 기술을 이용한 뼈 Segmentation은 많은 연구가 이루어지고 있으며, 다양한 목적으로 도움을 줄 수 있습니다.
+
+- 질병 진단의 목적으로 뼈의 형태나 위치가 변형되거나 부러지거나 골절 등이 있을 경우, 그 부위에서 발생하는 문제를 정확하게 파악하여 적절한 치료를 시행할 수 있습니다.
+
+- 수술 계획을 세우는데 도움이 됩니다. 의사들은 뼈 구조를 분석하여 어떤 종류의 수술이 필요한지, 어떤 종류의 재료가 사용될 수 있는지 등을 결정할 수 있습니다.
+
+- 의료장비 제작에 필요한 정보를 제공합니다. 예를 들어, 인공 관절이나 치아 임플란트를 제작할 때 뼈 구조를 분석하여 적절한 크기와 모양을 결정할 수 있습니다.
+
+- 의료 교육에서도 활용될 수 있습니다. 의사들은 병태 및 부상에 대한 이해를 높이고 수술 계획을 개발하는 데 필요한 기술을 연습할 수 있습니다.
+
+<br/>
+
+# 🗃️ Dataset
+
+추후수정예정
+<br/>
+<br/>
+<br/>
+
+# 😄 Team Member
+
+<table align="center">
+    <tr align="center">
+        <td><img src="" width="140" height="140"></td>
+        <td><img src="" width="140" height="140"></td>
+        <td><img src="" width="140" height="140"></td>
+        <td><img src="" width="140" height="140"></td>
+        <td><img src="" width="140" height="140"></td>
+        <td><img src="" width="140" height="140"></td>
+    </tr>
+    <tr align="center">
+        <td><a href="https://github.com/minrongtic" target="_blank">김민영</a></td>
+        <td><a href="https://github.com/june21a" target="_blank">박준일</a></td>
+        <td><a href="https://github.com/sejongmin" target="_blank">오종민</a></td>
+        <td><a href="https://github.com/Soy17" target="_blank">이소영</a></td>
+        <td><a href="https://github.com/wonjeongjeong" target="_blank">정원정</a></td>
+        <td><a href="https://github.com/Yoon0717" target="_blank">한승윤</a></td>
+    </tr>
+    <tr align="center">
+        <td>T7173</td>
+        <td>T7154</td>
+        <td>T7207</td>
+        <td>T7222</td>
+        <td>T7272</td>
+        <td>T7261</td>
+    </tr>
+</table>
+
+<br/>
+
+
+
+## 🔗 Reference
+
+### [📎 Segmentation Notion](https://www.notion.so/Hand-Bone-Image-Segmentation-13bcb8c4237680f0baeef241f0f6856b)
+
+<br>
+
+## Commit Convention
+
+1. `Feature` : **새로운 기능 추가**
+2. `Fix` : **버그 수정**
+3. `Docs` : **문서 수정**
+4. `Style` : **코드 포맷팅 → Code Convention**
+5. `Refactor` : **코드 리팩토링**
+6. `Test` : **테스트 코드**
+7. `Comment` : **주석 추가 및 수정**
+
+커밋할 때 헤더에 위 내용을 작성하고 전반적인 내용을 간단하게 작성합니다.
+
+### 예시
+
+- `git commit -m "[#issue] Feature : message content"`
+
+커밋할 때 상세 내용을 작성해야 한다면 아래와 같이 진행합니다.
+
+### 예시
+
+> `git commit`  
+> 어떠한 에디터로 진입하게 된 후 아래와 같이 작성합니다.  
+> `[header]: 전반적인 내용`  
+> . **(한 줄 비워야 함)**  
+> 상세 내용
+
+<br/>
+
+## Branch Naming Convention
+
+브랜치를 새롭게 만들 때, 브랜치 이름은 항상 위 `Commit Convention`의 Header와 함께 작성되어야 합니다.
+
+### 예시
+
+- `Feature/~~~`
+- `Refactor/~~~`

From 130e8b9b30e9fd044158ee4d53762e88e5cd895b Mon Sep 17 00:00:00 2001
From: Soy17 <thdudlee0617@naver.com>
Date: Mon, 11 Nov 2024 17:26:48 +0900
Subject: [PATCH 003/106] Update README.md

---
 README.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index cbec1bf..6a902e3 100644
--- a/README.md
+++ b/README.md
@@ -28,12 +28,12 @@ Bone Segmentation은 인공지능 분야에서 중요한 응용 분야 중 하
 
 <table align="center">
     <tr align="center">
-        <td><img src="" width="140" height="140"></td>
-        <td><img src="" width="140" height="140"></td>
-        <td><img src="" width="140" height="140"></td>
-        <td><img src="" width="140" height="140"></td>
-        <td><img src="" width="140" height="140"></td>
-        <td><img src="" width="140" height="140"></td>
+        <td><img src="" width="200" height="120"></td>
+        <td><img src="" width="200" height="120"></td>
+        <td><img src="https://github.com/user-attachments/assets/dcd46b40-5117-437c-a8a0-8217cffcb487" width="200" height="120"></td>
+        <td><img src="https://github.com/user-attachments/assets/9b936eca-2463-48d2-b01b-3196761e738e" width="200" height="120"></td>
+        <td><img src="https://github.com/user-attachments/assets/4a8f05bf-9635-47f7-b90e-39bb7c6f6824" width="200" height="120"></td>
+        <td><img src="https://github.com/user-attachments/assets/78c78353-ba3b-494d-ba94-429c4f838cd1" width="200" height="120"></td>
     </tr>
     <tr align="center">
         <td><a href="https://github.com/minrongtic" target="_blank">김민영</a></td>

From 4646554192d1f5c2748e1ab295f38427f7e416c0 Mon Sep 17 00:00:00 2001
From: Soy17 <thdudlee0617@naver.com>
Date: Tue, 12 Nov 2024 11:54:02 +0900
Subject: [PATCH 004/106] Update README.md

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 6a902e3..61841ab 100644
--- a/README.md
+++ b/README.md
@@ -28,8 +28,8 @@ Bone Segmentation은 인공지능 분야에서 중요한 응용 분야 중 하
 
 <table align="center">
     <tr align="center">
-        <td><img src="" width="200" height="120"></td>
-        <td><img src="" width="200" height="120"></td>
+        <td><img src="https://github.com/user-attachments/assets/337d06ce-6a68-4ff9-9638-b54b2d17e9e9" width="200" height="120"></td>
+        <td><img src="https://github.com/user-attachments/assets/f962dbc4-1ac0-49c1-bc1a-b999e01fa67f" width="200" height="120"></td>
         <td><img src="https://github.com/user-attachments/assets/dcd46b40-5117-437c-a8a0-8217cffcb487" width="200" height="120"></td>
         <td><img src="https://github.com/user-attachments/assets/9b936eca-2463-48d2-b01b-3196761e738e" width="200" height="120"></td>
         <td><img src="https://github.com/user-attachments/assets/4a8f05bf-9635-47f7-b90e-39bb7c6f6824" width="200" height="120"></td>

From 7f095f1091073e004f323b86d10c97b6281f9c73 Mon Sep 17 00:00:00 2001
From: Soy17 <thdudlee0617@naver.com>
Date: Tue, 12 Nov 2024 14:36:21 +0000
Subject: [PATCH 005/106] [#2] pull request template update

---
 .github/pull_request_template.md | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 .github/pull_request_template.md

diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
new file mode 100644
index 0000000..4760075
--- /dev/null
+++ b/.github/pull_request_template.md
@@ -0,0 +1,21 @@
+## 🤔 Motivation 🤔
+- 
+
+<br/>
+
+## 💡Content 💡
+- 
+
+<br/>
+
+## 🅾️ Metric ❎
+- 
+
+<br/>
+
+## 👩🏻‍💻 How To Apply 🧑🏻‍💻
+-
+
+---
+
+- close 
\ No newline at end of file

From 638a6eb3ccfac5e8503c55d426680884bff22fe7 Mon Sep 17 00:00:00 2001
From: Soy17 <thdudlee0617@naver.com>
Date: Wed, 13 Nov 2024 10:49:23 +0900
Subject: [PATCH 006/106] Update Dataset info in README.md

---
 README.md | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 61841ab..1571da5 100644
--- a/README.md
+++ b/README.md
@@ -14,12 +14,31 @@ Bone Segmentation은 인공지능 분야에서 중요한 응용 분야 중 하
 - 의료장비 제작에 필요한 정보를 제공합니다. 예를 들어, 인공 관절이나 치아 임플란트를 제작할 때 뼈 구조를 분석하여 적절한 크기와 모양을 결정할 수 있습니다.
 
 - 의료 교육에서도 활용될 수 있습니다. 의사들은 병태 및 부상에 대한 이해를 높이고 수술 계획을 개발하는 데 필요한 기술을 연습할 수 있습니다.
+<br/>
+
+
+- Input :
+
+hand bone x-ray 객체가 담긴 이미지가 모델의 인풋으로 사용됩니다. segmentation annotation은 json file로 제공됩니다.
+
+- Output :
 
+모델은 각 클래스(29개)에 대한 확률 맵을 갖는 멀티채널 예측을 수행하고, 이를 기반으로 각 픽셀을 해당 클래스에 할당합니다.
+최종적으로 예측된 결과를 Run-Length Encoding(RLE) 형식으로 변환하여 csv 파일로 제출합니다.
+
+<br/>
 <br/>
 
 # 🗃️ Dataset
 
-추후수정예정
+- 이미지 크기 : (2048 x 2048), 3 channel
+
+![image](https://github.com/user-attachments/assets/7a596f2c-e7e2-415f-872a-d812a7b47825)
+
+-  image, target 시각화 및 pixel 별로 예측해야할 29개의 classes
+  
+![image](https://github.com/user-attachments/assets/3474aac7-4542-4437-ad49-514a9dd72212)
+
 <br/>
 <br/>
 <br/>

From 1ceed5f1f49218d39113b875b366fb1711732660 Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Wed, 13 Nov 2024 05:01:07 +0000
Subject: [PATCH 007/106] [#5] add basecode

---
 baseline_code.ipynb | 1538 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1538 insertions(+)
 create mode 100644 baseline_code.ipynb

diff --git a/baseline_code.ipynb b/baseline_code.ipynb
new file mode 100644
index 0000000..aa12b9b
--- /dev/null
+++ b/baseline_code.ipynb
@@ -0,0 +1,1538 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "fe5f1ca7",
+   "metadata": {},
+   "source": [
+    "# Table of Contents\n",
+    "\n",
+    "1. [Imports & Global Constants](#Imports-&-Global-Constants)\n",
+    "<br>&emsp;- 학습에 필요한 라이브러리들을 임포트 하고 미션 안에서 이루어지는 학습 전반을 컨트롤 하기 위한 파라미터들을 설정합니다.\n",
+    "<br>\n",
+    "\n",
+    "2. [Check the Size of the Dataset](#Check-the-Size-of-the-Dataset)\n",
+    "<br>&emsp;- 학습에 사용될 데이터가 잘 준비되어있는지 확인합니다.\n",
+    "<br>\n",
+    "\n",
+    "3. [Define Dataset Class](#Define-Dataset-Class)\n",
+    "<br>&emsp;- 데이터를 원하는 형태로 불러오기 위한 Dataset 클래스를 정의하고, validation을 위한 데이터 스플릿을 진행합니다.\n",
+    "<br>\n",
+    "\n",
+    "4. [Check Data Sample](#Check-Data-Sample)\n",
+    "<br>&emsp;- 제공된 데이터가 어떤 모습인지 확인합니다.\n",
+    "<br>\n",
+    "\n",
+    "5. [Setup Dataloader](#Setup-Dataloader)\n",
+    "<br>&emsp;- 학습을 위해 데이터를 배치로 불러오기 위한 Dataloader를 만듭니다.\n",
+    "<br>\n",
+    "\n",
+    "6. [Define Functions for Training](#Define-Functions-for-Training)\n",
+    "<br>&emsp;- 학습을 도와주는 함수들을 정의합니다.\n",
+    "<br>\n",
+    "\n",
+    "7. [Training](#Training)\n",
+    "<br>&emsp;- 학습을 진행합니다.\n",
+    "<br>\n",
+    "\n",
+    "8. [Inference](#Inference)\n",
+    "<br>&emsp;- 인퍼런스에 필요한 함수들을 정의하고, 인퍼런스를 진행합니다.\n",
+    "<br>\n",
+    "\n",
+    "9. [Result Visualization](#Result-Visualization)\n",
+    "<br>&emsp;- 인퍼런스 결과를 확인해봅니다.\n",
+    "<br>\n",
+    "\n",
+    "10. [To CSV](#To-CSV)\n",
+    "<br>&emsp;- 인퍼런스 결과를 제출을 위한 포맷으로 변경합니다."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2c2d2121",
+   "metadata": {},
+   "source": [
+    "# Imports & Global Constants"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "id": "a3907598-e3f4-4c30-b1fe-759870903ecf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 노트북 실행에 필요한 라이브러리를 설치합니다\n",
+    "\n",
+    "# !pip install opencv-python-headless==4.10.0.84\n",
+    "# !pip install pandas==2.2.3\n",
+    "# !pip install -U scikit-learn==1.5.2\n",
+    "# !pip install albumentations==1.4.18\n",
+    "# !pip install matplotlib==3.9.2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "id": "c8295cb6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# python native\n",
+    "import os\n",
+    "import json\n",
+    "import random\n",
+    "import datetime\n",
+    "from functools import partial\n",
+    "\n",
+    "# external library\n",
+    "import cv2\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from tqdm.auto import tqdm\n",
+    "from sklearn.model_selection import GroupKFold\n",
+    "import albumentations as A\n",
+    "\n",
+    "# torch\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "import torch.optim as optim\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "from torchvision import models\n",
+    "\n",
+    "# visualization\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 79,
+   "id": "1d6746cc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 데이터 경로를 입력하세요\n",
+    "\n",
+    "IMAGE_ROOT = \"/data/ephemeral/home/data/train/DCM\"\n",
+    "LABEL_ROOT = \"/data/ephemeral/home/data/train/outputs_json\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 80,
+   "id": "819e163c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "CLASSES = [\n",
+    "    'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',\n",
+    "    'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',\n",
+    "    'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',\n",
+    "    'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',\n",
+    "    'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',\n",
+    "    'Triquetrum', 'Pisiform', 'Radius', 'Ulna',\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 81,
+   "id": "3192cd81",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "CLASS2IND = {v: i for i, v in enumerate(CLASSES)}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 82,
+   "id": "1aef86f9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "IND2CLASS = {v: k for k, v in CLASS2IND.items()}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cb199e3d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "BATCH_SIZE = 8\n",
+    "LR = 1e-4\n",
+    "RANDOM_SEED = 21\n",
+    "\n",
+    "NUM_EPOCHS = 5\n",
+    "VAL_EVERY = 5\n",
+    "\n",
+    "SAVED_DIR = \"checkpoints\"\n",
+    "\n",
+    "if not os.path.exists(SAVED_DIR):                                                           \n",
+    "    os.makedirs(SAVED_DIR)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "52cc2a79",
+   "metadata": {},
+   "source": [
+    "# Check the Size of the Dataset"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "93533655",
+   "metadata": {},
+   "source": [
+    "`IMAGE_ROOT` 아래에 있는 모든 폴더를 재귀적으로 순회하면서 확장자가 `.png`인 파일들을 찾습니다."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 84,
+   "id": "a0782493",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pngs = {\n",
+    "    os.path.relpath(os.path.join(root, fname), start=IMAGE_ROOT)\n",
+    "    for root, _dirs, files in os.walk(IMAGE_ROOT)\n",
+    "    for fname in files\n",
+    "    if os.path.splitext(fname)[1].lower() == \".png\"\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 85,
+   "id": "91a88b61",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "800"
+      ]
+     },
+     "execution_count": 85,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(pngs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d2247d10",
+   "metadata": {},
+   "source": [
+    "마찬가지로 `LABEL_ROOT` 아래에 있는 모든 폴더를 재귀적으로 순회하면서 확장자가 `.json`인 파일들을 찾습니다."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 86,
+   "id": "be21a515",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "jsons = {\n",
+    "    os.path.relpath(os.path.join(root, fname), start=LABEL_ROOT)\n",
+    "    for root, _dirs, files in os.walk(LABEL_ROOT)\n",
+    "    for fname in files\n",
+    "    if os.path.splitext(fname)[1].lower() == \".json\"\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 87,
+   "id": "eb99fd10",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "800"
+      ]
+     },
+     "execution_count": 87,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(jsons)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "653c3526",
+   "metadata": {},
+   "source": [
+    "모든 `.png` 파일에 대해 `.json` pair가 존재하는지 체크합니다. 파일명에서 확장자를 제거한 set을 생성하고 두 집합의 차집합의 크기가 0인지 확인합니다."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 88,
+   "id": "51eba0f1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "jsons_fn_prefix = {os.path.splitext(fname)[0] for fname in jsons}\n",
+    "pngs_fn_prefix = {os.path.splitext(fname)[0] for fname in pngs}\n",
+    "\n",
+    "assert len(jsons_fn_prefix - pngs_fn_prefix) == 0\n",
+    "assert len(pngs_fn_prefix - jsons_fn_prefix) == 0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b13ee425",
+   "metadata": {},
+   "source": [
+    "모든 `.png` 파일에 대해 label이 존재하는 것을 확인했습니다. 이름 순으로 정렬해서 짝이 맞도록 합니다."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 89,
+   "id": "f589a513",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pngs = sorted(pngs)\n",
+    "jsons = sorted(jsons)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "662f69ee",
+   "metadata": {},
+   "source": [
+    "# Define Dataset Class"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 90,
+   "id": "7b0d5bf7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class XRayDataset(Dataset):\n",
+    "    def __init__(self, is_train=True, transforms=None):\n",
+    "        _filenames = np.array(pngs)\n",
+    "        _labelnames = np.array(jsons)\n",
+    "        \n",
+    "        # split train-valid\n",
+    "        # 한 폴더 안에 한 인물의 양손에 대한 `.dcm` 파일이 존재하기 때문에\n",
+    "        # 폴더 이름을 그룹으로 해서 GroupKFold를 수행합니다.\n",
+    "        # 동일 인물의 손이 train, valid에 따로 들어가는 것을 방지합니다.\n",
+    "        groups = [os.path.dirname(fname) for fname in _filenames]\n",
+    "        \n",
+    "        # dummy label\n",
+    "        ys = [0 for fname in _filenames]\n",
+    "        \n",
+    "        # 전체 데이터의 20%를 validation data로 쓰기 위해 `n_splits`를\n",
+    "        # 5으로 설정하여 KFold를 수행합니다.\n",
+    "        gkf = GroupKFold(n_splits=5)\n",
+    "        \n",
+    "        filenames = []\n",
+    "        labelnames = []\n",
+    "        for i, (x, y) in enumerate(gkf.split(_filenames, ys, groups)):\n",
+    "            if is_train:\n",
+    "                # 0번을 validation dataset으로 사용합니다.\n",
+    "                if i == 0:\n",
+    "                    continue\n",
+    "                    \n",
+    "                filenames += list(_filenames[y])\n",
+    "                labelnames += list(_labelnames[y])\n",
+    "            \n",
+    "            else:\n",
+    "                filenames = list(_filenames[y])\n",
+    "                labelnames = list(_labelnames[y])\n",
+    "                \n",
+    "                # skip i > 0\n",
+    "                break\n",
+    "        \n",
+    "        self.filenames = filenames\n",
+    "        self.labelnames = labelnames\n",
+    "        self.is_train = is_train\n",
+    "        self.transforms = transforms\n",
+    "    \n",
+    "    def __len__(self):\n",
+    "        return len(self.filenames)\n",
+    "    \n",
+    "    def __getitem__(self, item):\n",
+    "        image_name = self.filenames[item]\n",
+    "        image_path = os.path.join(IMAGE_ROOT, image_name)\n",
+    "        \n",
+    "        image = cv2.imread(image_path)\n",
+    "        image = image / 255.\n",
+    "        \n",
+    "        label_name = self.labelnames[item]\n",
+    "        label_path = os.path.join(LABEL_ROOT, label_name)\n",
+    "        \n",
+    "        # (H, W, NC) 모양의 label을 생성합니다.\n",
+    "        label_shape = tuple(image.shape[:2]) + (len(CLASSES), )\n",
+    "        label = np.zeros(label_shape, dtype=np.uint8)\n",
+    "        \n",
+    "        # label 파일을 읽습니다.\n",
+    "        with open(label_path, \"r\") as f:\n",
+    "            annotations = json.load(f)\n",
+    "        annotations = annotations[\"annotations\"]\n",
+    "        \n",
+    "        # 클래스 별로 처리합니다.\n",
+    "        for ann in annotations:\n",
+    "            c = ann[\"label\"]\n",
+    "            class_ind = CLASS2IND[c]\n",
+    "            points = np.array(ann[\"points\"])\n",
+    "            \n",
+    "            # polygon 포맷을 dense한 mask 포맷으로 바꿉니다.\n",
+    "            class_label = np.zeros(image.shape[:2], dtype=np.uint8)\n",
+    "            cv2.fillPoly(class_label, [points], 1)\n",
+    "            label[..., class_ind] = class_label\n",
+    "        \n",
+    "        if self.transforms is not None:\n",
+    "            inputs = {\"image\": image, \"mask\": label} if self.is_train else {\"image\": image}\n",
+    "            result = self.transforms(**inputs)\n",
+    "            \n",
+    "            image = result[\"image\"]\n",
+    "            label = result[\"mask\"] if self.is_train else label\n",
+    "\n",
+    "        # to tenser will be done later\n",
+    "        image = image.transpose(2, 0, 1)    # channel first 포맷으로 변경합니다.\n",
+    "        label = label.transpose(2, 0, 1)\n",
+    "        \n",
+    "        image = torch.from_numpy(image).float()\n",
+    "        label = torch.from_numpy(label).float()\n",
+    "            \n",
+    "        return image, label"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "302e7742",
+   "metadata": {},
+   "source": [
+    "# Check Data Sample"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 91,
+   "id": "89defc8c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 시각화를 위한 팔레트를 설정합니다.\n",
+    "PALETTE = [\n",
+    "    (220, 20, 60), (119, 11, 32), (0, 0, 142), (0, 0, 230), (106, 0, 228),\n",
+    "    (0, 60, 100), (0, 80, 100), (0, 0, 70), (0, 0, 192), (250, 170, 30),\n",
+    "    (100, 170, 30), (220, 220, 0), (175, 116, 175), (250, 0, 30), (165, 42, 42),\n",
+    "    (255, 77, 255), (0, 226, 252), (182, 182, 255), (0, 82, 0), (120, 166, 157),\n",
+    "    (110, 76, 0), (174, 57, 255), (199, 100, 0), (72, 0, 118), (255, 179, 240),\n",
+    "    (0, 125, 92), (209, 0, 151), (188, 208, 182), (0, 220, 176),\n",
+    "]\n",
+    "\n",
+    "# 시각화 함수입니다. 클래스가 2개 이상인 픽셀을 고려하지는 않습니다.\n",
+    "def label2rgb(label):\n",
+    "    image_size = label.shape[1:] + (3, )\n",
+    "    image = np.zeros(image_size, dtype=np.uint8)\n",
+    "    \n",
+    "    for i, class_label in enumerate(label):\n",
+    "        image[class_label == 1] = PALETTE[i]\n",
+    "        \n",
+    "    return image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 92,
+   "id": "e1f1eb8a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tf = A.Resize(512, 512)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 93,
+   "id": "f17abc75",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_dataset = XRayDataset(is_train=True, transforms=tf)\n",
+    "valid_dataset = XRayDataset(is_train=False, transforms=tf)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 94,
+   "id": "c193e92b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image, label = train_dataset[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 95,
+   "id": "5dd474b2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([3, 512, 512]) torch.Size([29, 512, 512])\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(image.shape, label.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 96,
+   "id": "bc100cf6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "640"
+      ]
+     },
+     "execution_count": 96,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(train_dataset)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 97,
+   "id": "f9845fe3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2400x1200 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(1, 2, figsize=(24, 12))\n",
+    "ax[0].imshow(image[0])    # color map 적용을 위해 channel 차원을 생략합니다.\n",
+    "ax[1].imshow(label2rgb(label))\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "22480ad8",
+   "metadata": {},
+   "source": [
+    "# Setup Dataloader"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 98,
+   "id": "d5b43501",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_loader = DataLoader(\n",
+    "    dataset=train_dataset, \n",
+    "    batch_size=BATCH_SIZE,\n",
+    "    shuffle=True,\n",
+    "    num_workers=8,\n",
+    "    drop_last=True,\n",
+    ")\n",
+    "\n",
+    "# 주의: validation data는 이미지 크기가 크기 때문에 `num_wokers`는 커지면 메모리 에러가 발생할 수 있습니다.\n",
+    "valid_loader = DataLoader(\n",
+    "    dataset=valid_dataset, \n",
+    "    batch_size=8,\n",
+    "    shuffle=False,\n",
+    "    num_workers=0,\n",
+    "    drop_last=False\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "75925001",
+   "metadata": {},
+   "source": [
+    "# Define Functions for Training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 99,
+   "id": "687f29a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def dice_coef(y_true, y_pred):\n",
+    "    y_true_f = y_true.flatten(2)\n",
+    "    y_pred_f = y_pred.flatten(2)\n",
+    "    intersection = torch.sum(y_true_f * y_pred_f, -1)\n",
+    "    \n",
+    "    eps = 0.0001\n",
+    "    return (2. * intersection + eps) / (torch.sum(y_true_f, -1) + torch.sum(y_pred_f, -1) + eps)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 100,
+   "id": "19be0316",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def save_model(model, file_name='fcn_resnet50_best_model.pt'):\n",
+    "    output_path = os.path.join(SAVED_DIR, file_name)\n",
+    "    torch.save(model, output_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 101,
+   "id": "dd22e901",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def set_seed():\n",
+    "    torch.manual_seed(RANDOM_SEED)\n",
+    "    torch.cuda.manual_seed(RANDOM_SEED)\n",
+    "    torch.cuda.manual_seed_all(RANDOM_SEED) # if use multi-GPU\n",
+    "    torch.backends.cudnn.deterministic = True\n",
+    "    torch.backends.cudnn.benchmark = False\n",
+    "    np.random.seed(RANDOM_SEED)\n",
+    "    random.seed(RANDOM_SEED)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 102,
+   "id": "40c3a306",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def validation(epoch, model, data_loader, criterion, thr=0.5):\n",
+    "    print(f'Start validation #{epoch:2d}')\n",
+    "    model.eval()\n",
+    "\n",
+    "    dices = []\n",
+    "    with torch.no_grad():\n",
+    "        n_class = len(CLASSES)\n",
+    "        total_loss = 0\n",
+    "        cnt = 0\n",
+    "\n",
+    "        for step, (images, masks) in tqdm(enumerate(data_loader), total=len(data_loader)):\n",
+    "            images, masks = images.cuda(), masks.cuda()         \n",
+    "            model = model.cuda()\n",
+    "            \n",
+    "            outputs = model(images)['out']\n",
+    "            \n",
+    "            output_h, output_w = outputs.size(-2), outputs.size(-1)\n",
+    "            mask_h, mask_w = masks.size(-2), masks.size(-1)\n",
+    "            \n",
+    "            # gt와 prediction의 크기가 다른 경우 prediction을 gt에 맞춰 interpolation 합니다.\n",
+    "            if output_h != mask_h or output_w != mask_w:\n",
+    "                outputs = F.interpolate(outputs, size=(mask_h, mask_w), mode=\"bilinear\")\n",
+    "            \n",
+    "            loss = criterion(outputs, masks)\n",
+    "            total_loss += loss\n",
+    "            cnt += 1\n",
+    "            \n",
+    "            outputs = torch.sigmoid(outputs)\n",
+    "            outputs = (outputs > thr).detach().cpu()\n",
+    "            masks = masks.detach().cpu()\n",
+    "            \n",
+    "            dice = dice_coef(outputs, masks)\n",
+    "            dices.append(dice)\n",
+    "                \n",
+    "    dices = torch.cat(dices, 0)\n",
+    "    dices_per_class = torch.mean(dices, 0)\n",
+    "    dice_str = [\n",
+    "        f\"{c:<12}: {d.item():.4f}\"\n",
+    "        for c, d in zip(CLASSES, dices_per_class)\n",
+    "    ]\n",
+    "    dice_str = \"\\n\".join(dice_str)\n",
+    "    print(dice_str)\n",
+    "    \n",
+    "    avg_dice = torch.mean(dices_per_class).item()\n",
+    "    \n",
+    "    return avg_dice"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 103,
+   "id": "3acde59b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def train(model, data_loader, val_loader, criterion, optimizer):\n",
+    "    print(f'Start training..')\n",
+    "    \n",
+    "    n_class = len(CLASSES)\n",
+    "    best_dice = 0.\n",
+    "    \n",
+    "    for epoch in range(NUM_EPOCHS):\n",
+    "        model.train()\n",
+    "\n",
+    "        for step, (images, masks) in enumerate(data_loader):            \n",
+    "            # gpu 연산을 위해 device 할당합니다.\n",
+    "            images, masks = images.cuda(), masks.cuda()\n",
+    "            model = model.cuda()\n",
+    "            \n",
+    "            outputs = model(images)['out']\n",
+    "            \n",
+    "            # loss를 계산합니다.\n",
+    "            loss = criterion(outputs, masks)\n",
+    "            optimizer.zero_grad()\n",
+    "            loss.backward()\n",
+    "            optimizer.step()\n",
+    "            \n",
+    "            # step 주기에 따라 loss를 출력합니다.\n",
+    "            if (step + 1) % 25 == 0:\n",
+    "                print(\n",
+    "                    f'{datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")} | '\n",
+    "                    f'Epoch [{epoch+1}/{NUM_EPOCHS}], '\n",
+    "                    f'Step [{step+1}/{len(train_loader)}], '\n",
+    "                    f'Loss: {round(loss.item(),4)}'\n",
+    "                )\n",
+    "             \n",
+    "        # validation 주기에 따라 loss를 출력하고 best model을 저장합니다.\n",
+    "        if (epoch + 1) % VAL_EVERY == 0:\n",
+    "            dice = validation(epoch + 1, model, val_loader, criterion)\n",
+    "            \n",
+    "            if best_dice < dice:\n",
+    "                print(f\"Best performance at epoch: {epoch + 1}, {best_dice:.4f} -> {dice:.4f}\")\n",
+    "                print(f\"Save model in {SAVED_DIR}\")\n",
+    "                best_dice = dice\n",
+    "                save_model(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c10b856b",
+   "metadata": {},
+   "source": [
+    "# Training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 104,
+   "id": "73b106ab",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/conda/lib/python3.10/site-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
+      "  warnings.warn(\n",
+      "/opt/conda/lib/python3.10/site-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=FCN_ResNet50_Weights.COCO_WITH_VOC_LABELS_V1`. You can also use `weights=FCN_ResNet50_Weights.DEFAULT` to get the most up-to-date weights.\n",
+      "  warnings.warn(msg)\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = models.segmentation.fcn_resnet50(pretrained=True)\n",
+    "\n",
+    "# output class 개수를 dataset에 맞도록 수정합니다.\n",
+    "model.classifier[4] = nn.Conv2d(512, len(CLASSES), kernel_size=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 105,
+   "id": "801e9a3a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Loss function을 정의합니다.\n",
+    "criterion = nn.BCEWithLogitsLoss()\n",
+    "\n",
+    "# Optimizer를 정의합니다.\n",
+    "optimizer = optim.Adam(params=model.parameters(), lr=LR, weight_decay=1e-6)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 106,
+   "id": "a11d1b92",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 시드를 설정합니다.\n",
+    "set_seed()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 107,
+   "id": "7564c751",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Start training..\n",
+      "2024-11-11 10:25:33 | Epoch [1/25], Step [25/80], Loss: 0.5416\n",
+      "2024-11-11 10:26:00 | Epoch [1/25], Step [50/80], Loss: 0.4473\n",
+      "2024-11-11 10:26:27 | Epoch [1/25], Step [75/80], Loss: 0.3589\n",
+      "2024-11-11 10:27:12 | Epoch [2/25], Step [25/80], Loss: 0.2706\n",
+      "2024-11-11 10:27:41 | Epoch [2/25], Step [50/80], Loss: 0.2141\n",
+      "2024-11-11 10:28:07 | Epoch [2/25], Step [75/80], Loss: 0.1718\n",
+      "2024-11-11 10:28:49 | Epoch [3/25], Step [25/80], Loss: 0.1351\n",
+      "2024-11-11 10:29:16 | Epoch [3/25], Step [50/80], Loss: 0.1124\n",
+      "2024-11-11 10:29:45 | Epoch [3/25], Step [75/80], Loss: 0.0954\n",
+      "2024-11-11 10:30:26 | Epoch [4/25], Step [25/80], Loss: 0.0794\n",
+      "2024-11-11 10:30:55 | Epoch [4/25], Step [50/80], Loss: 0.0699\n",
+      "2024-11-11 10:31:22 | Epoch [4/25], Step [75/80], Loss: 0.0611\n",
+      "2024-11-11 10:32:04 | Epoch [5/25], Step [25/80], Loss: 0.0525\n",
+      "2024-11-11 10:32:32 | Epoch [5/25], Step [50/80], Loss: 0.0474\n",
+      "2024-11-11 10:33:00 | Epoch [5/25], Step [75/80], Loss: 0.0431\n",
+      "Start validation # 5\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/20 [00:08<?, ?it/s]\n"
+     ]
+    },
+    {
+     "ename": "OutOfMemoryError",
+     "evalue": "CUDA out of memory. Tried to allocate 3.62 GiB. GPU 0 has a total capacty of 31.74 GiB of which 3.53 GiB is free. Process 3519779 has 28.20 GiB memory in use. Of the allocated memory 19.15 GiB is allocated by PyTorch, and 8.66 GiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting max_split_size_mb to avoid fragmentation.  See documentation for Memory Management and PYTORCH_CUDA_ALLOC_CONF",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mOutOfMemoryError\u001b[0m                          Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[107], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mtrain\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrain_loader\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvalid_loader\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcriterion\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moptimizer\u001b[49m\u001b[43m)\u001b[49m\n",
+      "Cell \u001b[0;32mIn[103], line 34\u001b[0m, in \u001b[0;36mtrain\u001b[0;34m(model, data_loader, val_loader, criterion, optimizer)\u001b[0m\n\u001b[1;32m     32\u001b[0m \u001b[38;5;66;03m# validation 주기에 따라 loss를 출력하고 best model을 저장합니다.\u001b[39;00m\n\u001b[1;32m     33\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (epoch \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m) \u001b[38;5;241m%\u001b[39m VAL_EVERY \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m---> 34\u001b[0m     dice \u001b[38;5;241m=\u001b[39m \u001b[43mvalidation\u001b[49m\u001b[43m(\u001b[49m\u001b[43mepoch\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mval_loader\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcriterion\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     36\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m best_dice \u001b[38;5;241m<\u001b[39m dice:\n\u001b[1;32m     37\u001b[0m         \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mBest performance at epoch: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mepoch\u001b[38;5;250m \u001b[39m\u001b[38;5;241m+\u001b[39m\u001b[38;5;250m \u001b[39m\u001b[38;5;241m1\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m, \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mbest_dice\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m.4f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m -> \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mdice\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m.4f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n",
+      "Cell \u001b[0;32mIn[102], line 24\u001b[0m, in \u001b[0;36mvalidation\u001b[0;34m(epoch, model, data_loader, criterion, thr)\u001b[0m\n\u001b[1;32m     21\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m output_h \u001b[38;5;241m!=\u001b[39m mask_h \u001b[38;5;129;01mor\u001b[39;00m output_w \u001b[38;5;241m!=\u001b[39m mask_w:\n\u001b[1;32m     22\u001b[0m     outputs \u001b[38;5;241m=\u001b[39m F\u001b[38;5;241m.\u001b[39minterpolate(outputs, size\u001b[38;5;241m=\u001b[39m(mask_h, mask_w), mode\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbilinear\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m---> 24\u001b[0m loss \u001b[38;5;241m=\u001b[39m \u001b[43mcriterion\u001b[49m\u001b[43m(\u001b[49m\u001b[43moutputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmasks\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     25\u001b[0m total_loss \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m loss\n\u001b[1;32m     26\u001b[0m cnt \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n",
+      "File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/torch/nn/modules/module.py:1518\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1516\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1517\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1518\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/torch/nn/modules/module.py:1527\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1522\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1523\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1524\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1525\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1526\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1527\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1529\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m   1530\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n",
+      "File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/torch/nn/modules/loss.py:725\u001b[0m, in \u001b[0;36mBCEWithLogitsLoss.forward\u001b[0;34m(self, input, target)\u001b[0m\n\u001b[1;32m    724\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m: Tensor, target: Tensor) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Tensor:\n\u001b[0;32m--> 725\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mF\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbinary_cross_entropy_with_logits\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    726\u001b[0m \u001b[43m                                              \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mweight\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    727\u001b[0m \u001b[43m                                              \u001b[49m\u001b[43mpos_weight\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpos_weight\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    728\u001b[0m \u001b[43m                                              \u001b[49m\u001b[43mreduction\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreduction\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/torch/nn/functional.py:3195\u001b[0m, in \u001b[0;36mbinary_cross_entropy_with_logits\u001b[0;34m(input, target, weight, size_average, reduce, reduction, pos_weight)\u001b[0m\n\u001b[1;32m   3192\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (target\u001b[38;5;241m.\u001b[39msize() \u001b[38;5;241m==\u001b[39m \u001b[38;5;28minput\u001b[39m\u001b[38;5;241m.\u001b[39msize()):\n\u001b[1;32m   3193\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mTarget size (\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mtarget\u001b[38;5;241m.\u001b[39msize()\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m) must be the same as input size (\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28minput\u001b[39m\u001b[38;5;241m.\u001b[39msize()\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m)\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m-> 3195\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbinary_cross_entropy_with_logits\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mweight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpos_weight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mreduction_enum\u001b[49m\u001b[43m)\u001b[49m\n",
+      "\u001b[0;31mOutOfMemoryError\u001b[0m: CUDA out of memory. Tried to allocate 3.62 GiB. GPU 0 has a total capacty of 31.74 GiB of which 3.53 GiB is free. Process 3519779 has 28.20 GiB memory in use. Of the allocated memory 19.15 GiB is allocated by PyTorch, and 8.66 GiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting max_split_size_mb to avoid fragmentation.  See documentation for Memory Management and PYTORCH_CUDA_ALLOC_CONF"
+     ]
+    }
+   ],
+   "source": [
+    "train(model, train_loader, valid_loader, criterion, optimizer)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "85f36ce9",
+   "metadata": {},
+   "source": [
+    "# Inference"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8b438c65",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = torch.load(os.path.join(SAVED_DIR, \"fcn_resnet50_best_model.pt\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "da6dd353",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 테스트 데이터 경로를 입력하세요\n",
+    "\n",
+    "IMAGE_ROOT = \"/data/ephemeral/home/data/test/DCM\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "463d5c19",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pngs = {\n",
+    "    os.path.relpath(os.path.join(root, fname), start=IMAGE_ROOT)\n",
+    "    for root, _dirs, files in os.walk(IMAGE_ROOT)\n",
+    "    for fname in files\n",
+    "    if os.path.splitext(fname)[1].lower() == \".png\"\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ecb5c065-b44b-4f82-ba6d-b41e3e7f6ad2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "288"
+      ]
+     },
+     "execution_count": 59,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(pngs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3b2794ea",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# mask map으로 나오는 인퍼런스 결과를 RLE로 인코딩 합니다.\n",
+    "\n",
+    "def encode_mask_to_rle(mask):\n",
+    "    '''\n",
+    "    mask: numpy array binary mask \n",
+    "    1 - mask \n",
+    "    0 - background\n",
+    "    Returns encoded run length \n",
+    "    '''\n",
+    "    pixels = mask.flatten()\n",
+    "    pixels = np.concatenate([[0], pixels, [0]])\n",
+    "    runs = np.where(pixels[1:] != pixels[:-1])[0] + 1\n",
+    "    runs[1::2] -= runs[::2]\n",
+    "    return ' '.join(str(x) for x in runs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1db55005",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# RLE로 인코딩된 결과를 mask map으로 복원합니다.\n",
+    "\n",
+    "def decode_rle_to_mask(rle, height, width):\n",
+    "    s = rle.split()\n",
+    "    starts, lengths = [np.asarray(x, dtype=int) for x in (s[0:][::2], s[1:][::2])]\n",
+    "    starts -= 1\n",
+    "    ends = starts + lengths\n",
+    "    img = np.zeros(height * width, dtype=np.uint8)\n",
+    "    \n",
+    "    for lo, hi in zip(starts, ends):\n",
+    "        img[lo:hi] = 1\n",
+    "    \n",
+    "    return img.reshape(height, width)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8e98506f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class XRayInferenceDataset(Dataset):\n",
+    "    def __init__(self, transforms=None):\n",
+    "        _filenames = pngs\n",
+    "        _filenames = np.array(sorted(_filenames))\n",
+    "        \n",
+    "        self.filenames = _filenames\n",
+    "        self.transforms = transforms\n",
+    "    \n",
+    "    def __len__(self):\n",
+    "        return len(self.filenames)\n",
+    "    \n",
+    "    def __getitem__(self, item):\n",
+    "        image_name = self.filenames[item]\n",
+    "        image_path = os.path.join(IMAGE_ROOT, image_name)\n",
+    "        \n",
+    "        image = cv2.imread(image_path)\n",
+    "        image = image / 255.\n",
+    "        \n",
+    "        if self.transforms is not None:\n",
+    "            inputs = {\"image\": image}\n",
+    "            result = self.transforms(**inputs)\n",
+    "            image = result[\"image\"]\n",
+    "\n",
+    "        # to tenser will be done later\n",
+    "        image = image.transpose(2, 0, 1)  \n",
+    "        \n",
+    "        image = torch.from_numpy(image).float()\n",
+    "            \n",
+    "        return image, image_name"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "112a73a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def test(model, data_loader, thr=0.5):\n",
+    "    model = model.cuda()\n",
+    "    model.eval()\n",
+    "\n",
+    "    rles = []\n",
+    "    filename_and_class = []\n",
+    "    with torch.no_grad():\n",
+    "        n_class = len(CLASSES)\n",
+    "\n",
+    "        for step, (images, image_names) in tqdm(enumerate(data_loader), total=len(data_loader)):\n",
+    "            images = images.cuda()    \n",
+    "            outputs = model(images)['out']\n",
+    "            \n",
+    "            outputs = F.interpolate(outputs, size=(2048, 2048), mode=\"bilinear\")\n",
+    "            outputs = torch.sigmoid(outputs)\n",
+    "            outputs = (outputs > thr).detach().cpu().numpy()\n",
+    "            \n",
+    "            for output, image_name in zip(outputs, image_names):\n",
+    "                for c, segm in enumerate(output):\n",
+    "                    rle = encode_mask_to_rle(segm)\n",
+    "                    rles.append(rle)\n",
+    "                    filename_and_class.append(f\"{IND2CLASS[c]}_{image_name}\")\n",
+    "                    \n",
+    "    return rles, filename_and_class"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8011f0cd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tf = A.Resize(512, 512)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bcb091af",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_dataset = XRayInferenceDataset(transforms=tf)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "62aff8c2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_loader = DataLoader(\n",
+    "    dataset=test_dataset, \n",
+    "    batch_size=2,\n",
+    "    shuffle=False,\n",
+    "    num_workers=2,\n",
+    "    drop_last=False\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fa7c963b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 144/144 [03:00<00:00,  1.25s/it]\n"
+     ]
+    }
+   ],
+   "source": [
+    "rles, filename_and_class = test(model, test_loader)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "28e9e8a2",
+   "metadata": {},
+   "source": [
+    "# Result Visualization"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eeedc485",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'finger-1_ID040/image1661319116107.png'"
+      ]
+     },
+     "execution_count": 68,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "filename_and_class[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "faa6b4a2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image = cv2.imread(os.path.join(IMAGE_ROOT, filename_and_class[0].split(\"_\")[1]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5997f748",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "preds = []\n",
+    "for rle in rles[:len(CLASSES)]:\n",
+    "    pred = decode_rle_to_mask(rle, height=2048, width=2048)\n",
+    "    preds.append(pred)\n",
+    "\n",
+    "preds = np.stack(preds, 0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "679f5401",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2400x1200 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(1, 2, figsize=(24, 12))\n",
+    "ax[0].imshow(image)    # remove channel dimension\n",
+    "ax[1].imshow(label2rgb(preds))\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "65f9b574",
+   "metadata": {},
+   "source": [
+    "# To CSV"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e6c58f80",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "classes, filename = zip(*[x.split(\"_\") for x in filename_and_class])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4f489c54",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image_name = [os.path.basename(f) for f in filename]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a33cd628",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.DataFrame({\n",
+    "    \"image_name\": image_name,\n",
+    "    \"class\": classes,\n",
+    "    \"rle\": rles,\n",
+    "})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9b8ddbe2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>image_name</th>\n",
+       "      <th>class</th>\n",
+       "      <th>rle</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>finger-1</td>\n",
+       "      <td>1954318 1 1956365 3 1958412 5 1960459 7 196250...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>finger-2</td>\n",
+       "      <td>2169391 5 2171439 5 2173486 7 2175534 8 217758...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>finger-3</td>\n",
+       "      <td>2587244 6 2589288 12 2591331 19 2593376 23 259...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>finger-4</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>finger-5</td>\n",
+       "      <td>1141486 4 1143533 6 1145580 7 1147628 8 114967...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>finger-6</td>\n",
+       "      <td>1450764 6 1452807 14 1454849 22 1456892 29 145...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>finger-7</td>\n",
+       "      <td>2050885 12 2052919 27 2054959 37 2057005 39 20...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>finger-8</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>finger-9</td>\n",
+       "      <td>979923 1 981971 2 984018 5 986066 7 988114 8 9...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>finger-10</td>\n",
+       "      <td>1344463 32 1346509 35 1348556 37 1350604 37 13...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>finger-11</td>\n",
+       "      <td>2032592 32 2034637 36 2036683 38 2038728 42 20...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>finger-12</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>finger-13</td>\n",
+       "      <td>1127599 4 1129646 6 1131693 8 1133741 8 113578...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>finger-14</td>\n",
+       "      <td>1526924 4 1528963 15 1531003 25 1533044 33 153...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>finger-15</td>\n",
+       "      <td>2143311 3 2145357 7 2147403 11 2149449 15 2151...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>finger-16</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>finger-17</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>17</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>finger-18</td>\n",
+       "      <td>1852717 5 1854764 7 1856810 10 1858856 12 1860...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>18</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>finger-19</td>\n",
+       "      <td>2286769 3 2288815 6 2290862 8 2292910 10 22949...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>19</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>Trapezium</td>\n",
+       "      <td>3033906 1 3035951 6 3037998 8 3040045 11 30420...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>20</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>Trapezoid</td>\n",
+       "      <td>3046254 2 3048301 4 3050349 5 3052397 4 3054446 2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>Capitate</td>\n",
+       "      <td>2982860 6 2984902 14 2986947 18 2988993 20 299...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>22</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>Hamate</td>\n",
+       "      <td>2991150 2 2993196 6 2995242 9 2997287 13 29993...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>23</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>Scaphoid</td>\n",
+       "      <td>3203951 4 3205998 6 3208045 8 3210093 9 321214...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>24</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>Lunate</td>\n",
+       "      <td>3308496 15 3310542 29 3312588 36 3314635 38 33...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>25</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>Triquetrum</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>26</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>Pisiform</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>27</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>Radius</td>\n",
+       "      <td>3320627 1 3322674 3 3324721 6 3326769 8 332881...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>28</th>\n",
+       "      <td>image1661319116107.png</td>\n",
+       "      <td>Ulna</td>\n",
+       "      <td>3523631 7 3525676 15 3527721 22 3529767 28 353...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>29</th>\n",
+       "      <td>image1661319145363.png</td>\n",
+       "      <td>finger-1</td>\n",
+       "      <td>1799602 1 1801649 2 1803695 5 1805743 5 180779...</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                image_name       class  \\\n",
+       "0   image1661319116107.png    finger-1   \n",
+       "1   image1661319116107.png    finger-2   \n",
+       "2   image1661319116107.png    finger-3   \n",
+       "3   image1661319116107.png    finger-4   \n",
+       "4   image1661319116107.png    finger-5   \n",
+       "5   image1661319116107.png    finger-6   \n",
+       "6   image1661319116107.png    finger-7   \n",
+       "7   image1661319116107.png    finger-8   \n",
+       "8   image1661319116107.png    finger-9   \n",
+       "9   image1661319116107.png   finger-10   \n",
+       "10  image1661319116107.png   finger-11   \n",
+       "11  image1661319116107.png   finger-12   \n",
+       "12  image1661319116107.png   finger-13   \n",
+       "13  image1661319116107.png   finger-14   \n",
+       "14  image1661319116107.png   finger-15   \n",
+       "15  image1661319116107.png   finger-16   \n",
+       "16  image1661319116107.png   finger-17   \n",
+       "17  image1661319116107.png   finger-18   \n",
+       "18  image1661319116107.png   finger-19   \n",
+       "19  image1661319116107.png   Trapezium   \n",
+       "20  image1661319116107.png   Trapezoid   \n",
+       "21  image1661319116107.png    Capitate   \n",
+       "22  image1661319116107.png      Hamate   \n",
+       "23  image1661319116107.png    Scaphoid   \n",
+       "24  image1661319116107.png      Lunate   \n",
+       "25  image1661319116107.png  Triquetrum   \n",
+       "26  image1661319116107.png    Pisiform   \n",
+       "27  image1661319116107.png      Radius   \n",
+       "28  image1661319116107.png        Ulna   \n",
+       "29  image1661319145363.png    finger-1   \n",
+       "\n",
+       "                                                  rle  \n",
+       "0   1954318 1 1956365 3 1958412 5 1960459 7 196250...  \n",
+       "1   2169391 5 2171439 5 2173486 7 2175534 8 217758...  \n",
+       "2   2587244 6 2589288 12 2591331 19 2593376 23 259...  \n",
+       "3                                                      \n",
+       "4   1141486 4 1143533 6 1145580 7 1147628 8 114967...  \n",
+       "5   1450764 6 1452807 14 1454849 22 1456892 29 145...  \n",
+       "6   2050885 12 2052919 27 2054959 37 2057005 39 20...  \n",
+       "7                                                      \n",
+       "8   979923 1 981971 2 984018 5 986066 7 988114 8 9...  \n",
+       "9   1344463 32 1346509 35 1348556 37 1350604 37 13...  \n",
+       "10  2032592 32 2034637 36 2036683 38 2038728 42 20...  \n",
+       "11                                                     \n",
+       "12  1127599 4 1129646 6 1131693 8 1133741 8 113578...  \n",
+       "13  1526924 4 1528963 15 1531003 25 1533044 33 153...  \n",
+       "14  2143311 3 2145357 7 2147403 11 2149449 15 2151...  \n",
+       "15                                                     \n",
+       "16                                                     \n",
+       "17  1852717 5 1854764 7 1856810 10 1858856 12 1860...  \n",
+       "18  2286769 3 2288815 6 2290862 8 2292910 10 22949...  \n",
+       "19  3033906 1 3035951 6 3037998 8 3040045 11 30420...  \n",
+       "20  3046254 2 3048301 4 3050349 5 3052397 4 3054446 2  \n",
+       "21  2982860 6 2984902 14 2986947 18 2988993 20 299...  \n",
+       "22  2991150 2 2993196 6 2995242 9 2997287 13 29993...  \n",
+       "23  3203951 4 3205998 6 3208045 8 3210093 9 321214...  \n",
+       "24  3308496 15 3310542 29 3312588 36 3314635 38 33...  \n",
+       "25                                                     \n",
+       "26                                                     \n",
+       "27  3320627 1 3322674 3 3324721 6 3326769 8 332881...  \n",
+       "28  3523631 7 3525676 15 3527721 22 3529767 28 353...  \n",
+       "29  1799602 1 1801649 2 1803695 5 1805743 5 180779...  "
+      ]
+     },
+     "execution_count": 75,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df.head(30)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4e3829b6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df.to_csv(\"output.csv\", index=False)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "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.10.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From 8d5eaa4909da315f9b8a88a80d906887551062bc Mon Sep 17 00:00:00 2001
From: wonjeongjeong <wj3714@naver.com>
Date: Wed, 13 Nov 2024 09:19:11 +0000
Subject: [PATCH 008/106] [#8] Issue Template/gitignore update

---
 .github/ISSUE_TEMPLATE/-title----body.md | 22 ++++++++++++++++++++++
 .gitignore                               | 23 +++++++++++++++++++++++
 2 files changed, 45 insertions(+)
 create mode 100644 .github/ISSUE_TEMPLATE/-title----body.md
 create mode 100644 .gitignore

diff --git a/.github/ISSUE_TEMPLATE/-title----body.md b/.github/ISSUE_TEMPLATE/-title----body.md
new file mode 100644
index 0000000..83791a1
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/-title----body.md
@@ -0,0 +1,22 @@
+---
+name: "title/ body"
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+### Issue 타입(하나 이상의 Issue 타입을 선택해주세요)
+- [ ] Feat : 새로운 기능 추가
+- [ ] Remove : 파일 및 기능 삭제
+- [ ] Test : 테스트 코드 추가
+- [ ] Fix : 버그 수정
+- [ ] Docs : 문서 수정
+- [ ] Refactor : 코드 리펙토링
+- [ ] Style : 코드 포맷팅, 세미콜론 누락, 코드 변경이 없는 경우, 주석 추가
+
+### 상세 내용
+- [ ] ex) Github 소셜 로그인 기능이 필요합니다.
+
+### 추가사항
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..29e4376
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,23 @@
+# 모델 checkpoint 제외
+*.pt
+*.pkl
+*.pth
+
+
+# 결과 파일 제외
+*.csv
+
+# python cache 제외
+__pycache__
+*.pyc
+*.pyd
+
+# dataset 제외
+*.jpg
+*.png
+*.json
+*.tar.gz
+*.xlsx
+
+#wandb
+wandb/
\ No newline at end of file

From f9277d3030e9041797504d5ff380789909d688e6 Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Wed, 13 Nov 2024 09:26:28 +0000
Subject: [PATCH 009/106] =?UTF-8?q?[Feature]=20:=20streamlit=20=EC=8B=9C?=
 =?UTF-8?q?=EA=B0=81=ED=99=94?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 streamlit/load.py         | 24 ++++++++++
 streamlit/main.py         | 58 ++++++++++++++++++++++++
 streamlit/visualize_v1.py | 87 +++++++++++++++++++++++++++++++++++
 streamlit/visualize_v2.py | 95 +++++++++++++++++++++++++++++++++++++++
 4 files changed, 264 insertions(+)
 create mode 100644 streamlit/load.py
 create mode 100644 streamlit/main.py
 create mode 100644 streamlit/visualize_v1.py
 create mode 100644 streamlit/visualize_v2.py

diff --git a/streamlit/load.py b/streamlit/load.py
new file mode 100644
index 0000000..a29bbc8
--- /dev/null
+++ b/streamlit/load.py
@@ -0,0 +1,24 @@
+import os
+import numpy as np
+
+def load(info):
+    images = {
+        os.path.relpath(os.path.join(root, fname), start=info['image_root'])
+        for root, _dirs, files in os.walk(info['image_root'])
+        for fname in files
+        if os.path.splitext(fname)[1].lower() == ".png"
+    }
+
+    labels = {
+        os.path.relpath(os.path.join(root, fname), start=info['label_root'])
+        for root, _dirs, files in os.walk(info['label_root'])
+        for fname in files
+        if os.path.splitext(fname)[1].lower() == ".json"
+    }
+
+    images = sorted(images)
+    labels = sorted(labels)
+    images = np.array(images)
+    labels = np.array(labels)
+
+    return images, labels
\ No newline at end of file
diff --git a/streamlit/main.py b/streamlit/main.py
new file mode 100644
index 0000000..200201d
--- /dev/null
+++ b/streamlit/main.py
@@ -0,0 +1,58 @@
+import streamlit as st
+import load, visualize_v1, visualize_v2
+
+info = {
+    'image_root': "../../data/train/DCM",
+    'label_root': "../../data/train/outputs_json",
+    'classes': [
+        'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
+        'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
+        'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
+        'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
+        'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
+        'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
+    ],
+    'palette': [
+        (220, 20, 60), (119, 11, 32), (0, 0, 142), (0, 0, 230), (106, 0, 228),
+        (0, 60, 100), (0, 80, 100), (0, 0, 70), (0, 0, 192), (250, 170, 30),
+        (100, 170, 30), (220, 220, 0), (175, 116, 175), (250, 0, 30), (165, 42, 42),
+        (255, 77, 255), (0, 226, 252), (182, 182, 255), (0, 82, 0), (120, 166, 157),
+        (110, 76, 0), (174, 57, 255), (199, 100, 0), (72, 0, 118), (255, 179, 240),
+        (0, 125, 92), (209, 0, 151), (188, 208, 182), (0, 220, 176),
+    ]
+}
+
+COLOR = {
+    'finger': (120,203,228),
+    'Trapezoid': (145,42,177),
+    'Pisiform': (145,42,177),
+    'Radius': (210,71,77),
+    'Ulna': (210,71,77),
+    'wrist': (193,223,159)
+}
+
+st.sidebar.success("CV19 영원한종이박")
+st.markdown("<h2 style='text-align: center;'>Segmentation</h2>", unsafe_allow_html=True)
+
+if "images" not in st.session_state:
+    st.session_state.images = []
+if "labels" not in st.session_state:
+    st.session_state.labels = []
+
+option = st.sidebar.radio("option", ["train", "validation", "test"])
+if option == "train":
+    st.session_state.images, st.session_state.labels = load.load(info)
+    with st.sidebar.form(key="form"):
+        st.session_state.text = st.selectbox("select text", ["None", "Text"])
+        st.session_state.anno = st.selectbox("select annotation", ['All'] + info['classes'])
+        submit_button = st.form_submit_button("OK")
+    image_index = st.sidebar.slider('Select image index', 0, len(st.session_state.images)-2, 0)
+    image_index_input = st.sidebar.number_input('Enter image index', min_value=0, max_value=len(st.session_state.images)-2, value=image_index, step=2)
+    if image_index != image_index_input:
+        image_index = image_index_input
+    visualize_v2.show(info, st.session_state.images, st.session_state.labels, image_index, st.session_state.text, st.session_state.anno)
+
+if option == "validation":
+    st.write("개발중입니다...")
+if option == "test":
+    st.write("개발중입니다...")
\ No newline at end of file
diff --git a/streamlit/visualize_v1.py b/streamlit/visualize_v1.py
new file mode 100644
index 0000000..30cd9ac
--- /dev/null
+++ b/streamlit/visualize_v1.py
@@ -0,0 +1,87 @@
+import os
+import cv2
+import json
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+import streamlit as st
+
+def label2rgb(label, palette):
+    image_size = label.shape[1:] + (3, )
+    image = np.zeros(image_size, dtype=np.uint8)
+
+    for i, class_label in enumerate(label):
+        image[class_label == 1] = palette[i]
+
+    return image
+
+def show(info, images, labels, id):
+    try:
+        cols = st.columns(2)
+        CLASS2IND = {v: i for i, v in enumerate(info['classes'])}
+        IND2CLASS = {v: k for k, v in CLASS2IND.items()}
+
+        image_path = os.path.join(info['image_root'], images[id])
+        image_left = cv2.imread(image_path)
+        image_left = cv2.cvtColor(image_left, cv2.COLOR_BGR2RGB)
+        image_left = image_left / 255.
+
+        image_path = os.path.join(info['image_root'], images[id + 1])
+        image_right = cv2.imread(image_path)
+        image_right = cv2.cvtColor(image_right, cv2.COLOR_BGR2RGB)
+        image_right = image_right / 255.
+
+        label_path_left = os.path.join(info['label_root'], labels[id])
+        label_shape = tuple(image_left.shape[:2]) + (len(info['classes']), )
+        label_left = np.zeros(label_shape, dtype=np.uint8)
+
+        label_path_right = os.path.join(info['label_root'], labels[id + 1])
+        label_shape = tuple(image_right.shape[:2]) + (len(info['classes']), )
+        label_right = np.zeros(label_shape, dtype=np.uint8)
+
+        with open(label_path_left, "r") as f:
+            annotations_left = json.load(f)
+        annotations_left = annotations_left["annotations"]
+
+        with open(label_path_right, "r") as f:
+            annotations_right = json.load(f)
+        annotations_right = annotations_right["annotations"]
+
+        for ann in annotations_left:
+            c = ann["label"]
+            class_ind = CLASS2IND[c]
+            points = np.array(ann["points"])
+
+            class_label_left = np.zeros(image_left.shape[:2], dtype=np.uint8)
+            cv2.fillPoly(class_label_left, [points], 1)
+            label_left[..., class_ind] = class_label_left
+        
+        for ann in annotations_right:
+            c = ann["label"]
+            class_ind = CLASS2IND[c]
+            points = np.array(ann["points"])
+            
+            class_label_right = np.zeros(image_right.shape[:2], dtype=np.uint8)
+            cv2.fillPoly(class_label_right, [points], 1)
+            label_right[..., class_ind] = class_label_right
+        
+        label_left = label_left.transpose(2, 0, 1)
+        label_right = label_right.transpose(2, 0, 1)
+
+        label_left = torch.from_numpy(label_left).float()
+        label_right = torch.from_numpy(label_right).float()
+
+        fig_left, ax_left = plt.subplots()
+        ax_left.imshow(label2rgb(label_left, info['palette']))
+        ax_left.set_axis_off()
+
+        fig_right, ax_right = plt.subplots()
+        ax_right.imshow(label2rgb(label_right, info['palette']))
+        ax_right.set_axis_off()
+
+        with cols[0]:
+            st.pyplot(fig_left)
+        with cols[1]:
+            st.pyplot(fig_right)
+    except Exception as e:
+        st.write(e)
diff --git a/streamlit/visualize_v2.py b/streamlit/visualize_v2.py
new file mode 100644
index 0000000..fcc8be5
--- /dev/null
+++ b/streamlit/visualize_v2.py
@@ -0,0 +1,95 @@
+import os
+import json
+import streamlit as st
+from PIL import Image
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+
+COLOR = {
+    'finger': (120,203,228),
+    'Trapezoid': (145,42,177),
+    'Pisiform': (145,42,177),
+    'Radius': (210,71,77),
+    'Ulna': (210,71,77),
+    'wrist': (193,223,159)
+}
+
+def get_poly(points, label):
+    if label.startswith('finger'):
+        label = 'finger'
+    elif label not in COLOR:
+        label = 'wrist'
+        
+    poly = patches.Polygon(
+        points, 
+        closed=True, 
+        facecolor=[ck/255 for ck in COLOR[label]], 
+        edgecolor='black',
+        alpha=0.7
+    )
+    return poly
+
+def show(info, images, labels, id, text='None', anno='All'):
+    cols = st.columns(2)
+
+    image_path_right = os.path.join(info['image_root'], images[id])
+    label_path_right = os.path.join(info['label_root'], labels[id])
+
+    image_path_left = os.path.join(info['image_root'], images[id + 1])
+    label_path_left = os.path.join(info['label_root'], labels[id + 1])
+        
+    image_right = Image.open(image_path_right).convert("RGB")
+    label_right = json.load(open(label_path_right))
+
+    image_left = Image.open(image_path_left).convert("RGB")
+    label_left = json.load(open(label_path_left))
+    
+    fig_left, ax_left = plt.subplots()
+    
+    ax_left.imshow(image_left)
+    ax_left.set_title(images[id + 1])
+    ax_left.axis('off')
+    for annot in label_left['annotations']:
+        points = [tuple(pts) for pts in annot['points']]
+        orin_label = annot['label'] 
+        label = orin_label
+        if anno == 'All':
+            poly = get_poly(points, label)
+            ax_left.add_patch(poly)
+            cx, cy = sum([p[0] for p in points]) / len(points), sum([p[1] for p in points]) / len(points)
+            if text == 'Text':
+                ax_left.text(cx, cy, orin_label, fontsize=5, color='white')
+        else:
+            if label == anno:
+                poly = get_poly(points, label)
+                ax_left.add_patch(poly)
+                cx, cy = sum([p[0] for p in points]) / len(points), sum([p[1] for p in points]) / len(points)
+                if text == 'Text':
+                    ax_left.text(cx, cy, orin_label, fontsize=5, color='white')
+    with cols[0]:
+        st.pyplot(fig_left)
+
+    fig_right, ax_right = plt.subplots()
+
+    ax_right.imshow(image_right)
+    ax_right.set_title(images[id])
+    ax_right.axis('off')
+    for annot in label_right['annotations']:
+        points = [tuple(pts) for pts in annot['points']]
+        orin_label = annot['label'] 
+        label = orin_label
+        if anno == 'All':
+            poly = get_poly(points, label)
+            ax_right.add_patch(poly)
+            cx, cy = sum([p[0] for p in points]) / len(points), sum([p[1] for p in points]) / len(points)
+            if text == 'Text':
+                ax_right.text(cx, cy, orin_label, fontsize=5, color='white')
+        else:
+            if label == anno:
+                poly = get_poly(points, label)
+                ax_right.add_patch(poly)
+                cx, cy = sum([p[0] for p in points]) / len(points), sum([p[1] for p in points]) / len(points)
+                if text == 'Text':
+                    ax_right.text(cx, cy, orin_label, fontsize=5, color='white')
+    with cols[1]:
+        st.pyplot(fig_right)
\ No newline at end of file

From c72f06a48195b83ee643779e05ecce2c28bc97ae Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Wed, 13 Nov 2024 09:54:39 +0000
Subject: [PATCH 010/106] =?UTF-8?q?[Refactor]=20:=20=EC=BD=94=EB=93=9C=20?=
 =?UTF-8?q?=EB=A6=AC=ED=8E=99=ED=86=A0=EB=A7=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 streamlit/main.py         | 19 +++++++++----------
 streamlit/visualize_v2.py | 23 +++++++----------------
 2 files changed, 16 insertions(+), 26 deletions(-)

diff --git a/streamlit/main.py b/streamlit/main.py
index 200201d..89beb52 100644
--- a/streamlit/main.py
+++ b/streamlit/main.py
@@ -19,16 +19,15 @@
         (255, 77, 255), (0, 226, 252), (182, 182, 255), (0, 82, 0), (120, 166, 157),
         (110, 76, 0), (174, 57, 255), (199, 100, 0), (72, 0, 118), (255, 179, 240),
         (0, 125, 92), (209, 0, 151), (188, 208, 182), (0, 220, 176),
-    ]
-}
-
-COLOR = {
-    'finger': (120,203,228),
-    'Trapezoid': (145,42,177),
-    'Pisiform': (145,42,177),
-    'Radius': (210,71,77),
-    'Ulna': (210,71,77),
-    'wrist': (193,223,159)
+    ],
+    'color': {
+        'finger': (120,203,228),
+        'Trapezoid': (145,42,177),
+        'Pisiform': (145,42,177),
+        'Radius': (210,71,77),
+        'Ulna': (210,71,77),
+        'wrist': (193,223,159)
+    }
 }
 
 st.sidebar.success("CV19 영원한종이박")
diff --git a/streamlit/visualize_v2.py b/streamlit/visualize_v2.py
index fcc8be5..19f1197 100644
--- a/streamlit/visualize_v2.py
+++ b/streamlit/visualize_v2.py
@@ -5,25 +5,16 @@
 import matplotlib.pyplot as plt
 import matplotlib.patches as patches
 
-COLOR = {
-    'finger': (120,203,228),
-    'Trapezoid': (145,42,177),
-    'Pisiform': (145,42,177),
-    'Radius': (210,71,77),
-    'Ulna': (210,71,77),
-    'wrist': (193,223,159)
-}
-
-def get_poly(points, label):
+def get_poly(points, label, color):
     if label.startswith('finger'):
         label = 'finger'
-    elif label not in COLOR:
+    elif label not in color:
         label = 'wrist'
         
     poly = patches.Polygon(
         points, 
         closed=True, 
-        facecolor=[ck/255 for ck in COLOR[label]], 
+        facecolor=[ck/255 for ck in color[label]], 
         edgecolor='black',
         alpha=0.7
     )
@@ -54,14 +45,14 @@ def show(info, images, labels, id, text='None', anno='All'):
         orin_label = annot['label'] 
         label = orin_label
         if anno == 'All':
-            poly = get_poly(points, label)
+            poly = get_poly(points, label, info['color'])
             ax_left.add_patch(poly)
             cx, cy = sum([p[0] for p in points]) / len(points), sum([p[1] for p in points]) / len(points)
             if text == 'Text':
                 ax_left.text(cx, cy, orin_label, fontsize=5, color='white')
         else:
             if label == anno:
-                poly = get_poly(points, label)
+                poly = get_poly(points, label, info['color'])
                 ax_left.add_patch(poly)
                 cx, cy = sum([p[0] for p in points]) / len(points), sum([p[1] for p in points]) / len(points)
                 if text == 'Text':
@@ -79,14 +70,14 @@ def show(info, images, labels, id, text='None', anno='All'):
         orin_label = annot['label'] 
         label = orin_label
         if anno == 'All':
-            poly = get_poly(points, label)
+            poly = get_poly(points, label, info['color'])
             ax_right.add_patch(poly)
             cx, cy = sum([p[0] for p in points]) / len(points), sum([p[1] for p in points]) / len(points)
             if text == 'Text':
                 ax_right.text(cx, cy, orin_label, fontsize=5, color='white')
         else:
             if label == anno:
-                poly = get_poly(points, label)
+                poly = get_poly(points, label, info['color'])
                 ax_right.add_patch(poly)
                 cx, cy = sum([p[0] for p in points]) / len(points), sum([p[1] for p in points]) / len(points)
                 if text == 'Text':

From 8baf87586170a26f4b1f3a89e32febd74062d622 Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Wed, 13 Nov 2024 18:59:16 +0900
Subject: [PATCH 011/106] [Feature]:add module base

---
 module_base/dataset.py | 136 +++++++++++++++++++++++++
 module_base/train.py   | 221 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 357 insertions(+)
 create mode 100644 module_base/dataset.py
 create mode 100644 module_base/train.py

diff --git a/module_base/dataset.py b/module_base/dataset.py
new file mode 100644
index 0000000..ffcfba4
--- /dev/null
+++ b/module_base/dataset.py
@@ -0,0 +1,136 @@
+# python native
+import os
+import json
+import cv2
+import numpy as np
+import torch
+from torch.utils.data import Dataset
+from sklearn.model_selection import GroupKFold
+
+class XRayDataset(Dataset):
+    def __init__(self, pngs, jsons, class2ind, classes, image_root, label_root, is_train=True, transforms=None):
+        self.pngs = pngs
+        self.jsons = jsons
+        _filenames = np.array(self.pngs)
+        _labelnames = np.array(self.jsons)
+        
+        # split train-valid
+        # 한 폴더 안에 한 인물의 양손에 대한 `.dcm` 파일이 존재하기 때문에
+        # 폴더 이름을 그룹으로 해서 GroupKFold를 수행합니다.
+        # 동일 인물의 손이 train, valid에 따로 들어가는 것을 방지합니다.
+        groups = [os.path.dirname(fname) for fname in _filenames]
+        
+        # dummy label
+        ys = [0 for fname in _filenames]
+        
+        # 전체 데이터의 20%를 validation data로 쓰기 위해 `n_splits`를
+        # 5으로 설정하여 KFold를 수행합니다.
+        gkf = GroupKFold(n_splits=5)
+        
+        filenames = []
+        labelnames = []
+        for i, (x, y) in enumerate(gkf.split(_filenames, ys, groups)):
+            if is_train:
+                # 0번을 validation dataset으로 사용합니다.
+                if i == 0:
+                    continue
+                    
+                filenames += list(_filenames[y])
+                labelnames += list(_labelnames[y])
+            
+            else:
+                filenames = list(_filenames[y])
+                labelnames = list(_labelnames[y])
+                
+                # skip i > 0
+                break
+        
+        self.filenames = filenames
+        self.labelnames = labelnames
+        self.is_train = is_train
+        self.transforms = transforms
+        self.class2ind = class2ind
+        self.classes = classes
+        self.image_root = image_root
+        self.label_root = label_root
+    
+    def __len__(self):
+        return len(self.filenames)
+    
+    def __getitem__(self, item):
+        image_name = self.filenames[item]
+        image_path = os.path.join(self.image_root, image_name)
+        
+        image = cv2.imread(image_path)
+        image = image / 255.
+        
+        label_name = self.labelnames[item]
+        label_path = os.path.join(self.label_root, label_name)
+        
+        # (H, W, NC) 모양의 label을 생성합니다.
+        label_shape = tuple(image.shape[:2]) + (len(self.classes), )
+        label = np.zeros(label_shape, dtype=np.uint8)
+        
+        # label 파일을 읽습니다.
+        with open(label_path, "r") as f:
+            annotations = json.load(f)
+        annotations = annotations["annotations"]
+        
+        # 클래스 별로 처리합니다.
+        for ann in annotations:
+            c = ann["label"]
+            class_ind = self.class2ind[c]
+            points = np.array(ann["points"])
+            
+            # polygon 포맷을 dense한 mask 포맷으로 바꿉니다.
+            class_label = np.zeros(image.shape[:2], dtype=np.uint8)
+            cv2.fillPoly(class_label, [points], 1)
+            label[..., class_ind] = class_label
+        
+        if self.transforms is not None:
+            inputs = {"image": image, "mask": label} if self.is_train else {"image": image}
+            result = self.transforms(**inputs)
+            
+            image = result["image"]
+            label = result["mask"] if self.is_train else label
+
+        # to tenser will be done later
+        image = image.transpose(2, 0, 1)    # channel first 포맷으로 변경합니다.
+        label = label.transpose(2, 0, 1)
+        
+        image = torch.from_numpy(image).float()
+        label = torch.from_numpy(label).float()
+            
+        return image, label
+
+class XRayInferenceDataset(Dataset):
+    def __init__(self, pngs, image_root, transforms=None):
+        self.pngs = pngs
+        self.image_root = image_root
+        _filenames = self.pngs
+        _filenames = np.array(sorted(_filenames))
+
+        self.filenames = _filenames
+        self.transforms = transforms
+
+    def __len__(self):
+        return len(self.filenames)
+
+    def __getitem__(self, item):
+        image_name = self.filenames[item]
+        image_path = os.path.join(self.image_root, image_name)
+
+        image = cv2.imread(image_path)
+        image = image / 255.
+
+        if self.transforms is not None:
+            inputs = {"image": image}
+            result = self.transforms(**inputs)
+            image = result["image"]
+
+        # to tenser will be done later
+        image = image.transpose(2, 0, 1)    # make channel first
+
+        image = torch.from_numpy(image).float()
+
+        return image, image_name
\ No newline at end of file
diff --git a/module_base/train.py b/module_base/train.py
new file mode 100644
index 0000000..9b654dd
--- /dev/null
+++ b/module_base/train.py
@@ -0,0 +1,221 @@
+# python native
+import os
+import random
+import datetime
+import numpy as np
+from tqdm.auto import tqdm
+import albumentations as A
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from torch.utils.data import DataLoader
+from torchvision import models
+from dataset import XRayDataset
+
+from argparse import ArgumentParser
+
+def parse_args():
+    parser = ArgumentParser()
+
+    # Conventional args
+    parser.add_argument('--image_root', type=str, default='/data/ephemeral/home/data/train/DCM',
+                        help='Path to the root directory containing images')
+    parser.add_argument('--label_root', type=str, default='/data/ephemeral/home/data/train/outputs_json',
+                        help='Path to the root directory containing labels')
+    parser.add_argument('--save_dir', type=str, default="/data/ephemeral/home/data/result",
+                        help='Path to the root directory containing save direction')
+    parser.add_argument('--batch_size', type=int, default=8)
+    parser.add_argument('--learning_rate', type=float, default=1e-4)
+    parser.add_argument('--max_epoch', type=int, default=30)
+    parser.add_argument('--val_every', type=int, default=5)
+    parser.add_argument('--random_seed', type=int, default=21)
+    args = parser.parse_args()
+    
+    return args
+
+
+CLASSES = [
+    'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
+    'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
+    'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
+    'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
+    'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
+    'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
+]
+
+CLASS2IND = {v: i for i, v in enumerate(CLASSES)}
+IND2CLASS = {v: k for k, v in CLASS2IND.items()}
+
+def dice_coef(y_true, y_pred):
+    y_true_f = y_true.flatten(2)
+    y_pred_f = y_pred.flatten(2)
+    intersection = torch.sum(y_true_f * y_pred_f, -1)
+    eps = 0.0001
+    return (2. * intersection + eps) / (torch.sum(y_true_f, -1) + torch.sum(y_pred_f, -1) + eps)
+
+def set_seed(random_seed):
+    torch.manual_seed(random_seed)
+    torch.cuda.manual_seed(random_seed)
+    torch.cuda.manual_seed_all(random_seed) # if use multi-GPU
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+    np.random.seed(random_seed)
+    random.seed(random_seed)
+
+def save_model(model, save_dir, file_name='fcn_resnet50_best_model.pt'):
+    output_path = os.path.join(save_dir, file_name)
+    torch.save(model, output_path)
+
+def validation(epoch, model, data_loader, criterion, thr=0.5):
+    print(f'Start validation #{epoch:2d}')
+    model.eval()
+
+    dices = []
+    with torch.no_grad():
+        n_class = len(CLASSES)
+        total_loss = 0
+        cnt = 0
+
+        for step, (images, masks) in tqdm(enumerate(data_loader), total=len(data_loader)):
+            images, masks = images.cuda(), masks.cuda()         
+            model = model.cuda()
+            
+            outputs = model(images)['out']
+            
+            output_h, output_w = outputs.size(-2), outputs.size(-1)
+            mask_h, mask_w = masks.size(-2), masks.size(-1)
+            
+            # gt와 prediction의 크기가 다른 경우 prediction을 gt에 맞춰 interpolation 합니다.
+            if output_h != mask_h or output_w != mask_w:
+                outputs = F.interpolate(outputs, size=(mask_h, mask_w), mode="bilinear")
+            
+            loss = criterion(outputs, masks)
+            total_loss += loss
+            cnt += 1
+            
+            outputs = torch.sigmoid(outputs)
+            outputs = (outputs > thr).detach().cpu()
+            masks = masks.detach().cpu()
+            
+            dice = dice_coef(outputs, masks)
+            dices.append(dice)
+                
+    dices = torch.cat(dices, 0)
+    dices_per_class = torch.mean(dices, 0)
+    dice_str = [
+        f"{c:<12}: {d.item():.4f}"
+        for c, d in zip(CLASSES, dices_per_class)
+    ]
+    dice_str = "\n".join(dice_str)
+    print(dice_str)
+    
+    avg_dice = torch.mean(dices_per_class).item()
+    
+    return avg_dice
+
+def train(model, train_loader, valid_loader, criterion, optimizer, save_dir, random_seed, max_epoch, val_every):
+    print(f'Start training..')
+    
+    n_class = len(CLASSES)
+    best_dice = 0.
+    
+    for epoch in range(max_epoch):
+        model.train()
+
+        for step, (images, masks) in enumerate(train_loader):            
+            # gpu 연산을 위해 device 할당합니다.
+            images, masks = images.cuda(), masks.cuda()
+            model = model.cuda()
+            
+            outputs = model(images)['out']
+            
+            # loss를 계산합니다.
+            loss = criterion(outputs, masks)
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+            
+            # step 주기에 따라 loss를 출력합니다.
+            if (step + 1) % 25 == 0:
+                print(
+                    f'{datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")} | '
+                    f'Epoch [{epoch+1}/{max_epoch}], '
+                    f'Step [{step+1}/{len(train_loader)}], '
+                    f'Loss: {round(loss.item(),4)}'
+                )
+                
+        # validation 주기에 따라 loss를 출력하고 best model을 저장합니다.
+        if (epoch + 1) % val_every == 0:
+            dice = validation(epoch + 1, model, valid_loader, criterion)
+            
+            if best_dice < dice:
+                print(f"Best performance at epoch: {epoch + 1}, {best_dice:.4f} -> {dice:.4f}")
+                print(f"Save model in {save_dir}")
+                best_dice = dice
+                save_model(model, save_dir)
+
+def do_training(image_root, label_root, save_dir, batch_size, learning_rate, max_epoch, val_every, random_seed):
+    pngs = {
+        os.path.relpath(os.path.join(root, fname), start=image_root)
+        for root, _dirs, files in os.walk(image_root)
+        for fname in files
+        if os.path.splitext(fname)[1].lower() == ".png"
+    }
+
+    jsons = {
+        os.path.relpath(os.path.join(root, fname), start=label_root)
+        for root, _dirs, files in os.walk(label_root)
+        for fname in files
+        if os.path.splitext(fname)[1].lower() == ".json"
+    }
+    
+    pngs = sorted(pngs)
+    jsons = sorted(jsons)
+    
+    if not os.path.exists(save_dir):
+        os.makedirs(save_dir)
+    
+    tf = A.Resize(512, 512)
+    
+    train_dataset = XRayDataset(pngs, jsons, CLASS2IND, CLASSES, image_root, label_root, is_train=True, transforms=tf)
+    valid_dataset = XRayDataset(pngs, jsons, CLASS2IND, CLASSES, image_root, label_root, is_train=False, transforms=tf)
+    
+    train_loader = DataLoader(
+        dataset=train_dataset, 
+        batch_size=batch_size,
+        shuffle=True,
+        num_workers=8,
+        drop_last=True,
+    )
+    
+    valid_loader = DataLoader(
+        dataset=valid_dataset, 
+        batch_size=8,
+        shuffle=False,
+        num_workers=0,
+        drop_last=False
+    )
+    
+    model = models.segmentation.fcn_resnet50(pretrained=True)
+
+    # output class 개수를 dataset에 맞도록 수정합니다.
+    model.classifier[4] = nn.Conv2d(512, len(CLASSES), kernel_size=1)
+
+    # Loss function을 정의합니다.
+    criterion = nn.BCEWithLogitsLoss()
+
+    # Optimizer를 정의합니다.
+    optimizer = optim.Adam(params=model.parameters(), lr=learning_rate, weight_decay=1e-6)
+
+    # 시드를 설정합니다.
+    set_seed(random_seed)
+
+    train(model, train_loader, valid_loader, criterion, optimizer, save_dir, random_seed, max_epoch, val_every)
+
+def main(args):
+    do_training(**args.__dict__)
+
+if __name__ == '__main__':
+    args = parse_args()
+    main(args)
\ No newline at end of file

From a95a7271ae3e40be99b9b585d4a3e6ca2e6afab9 Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Wed, 13 Nov 2024 22:29:57 +0900
Subject: [PATCH 012/106] [Feature]:add module base2

---
 module_base/dataset.py   |   2 +-
 module_base/inference.py | 136 +++++++++++++++++++++++++++++++++++++++
 module_base/train.py     |   1 -
 3 files changed, 137 insertions(+), 2 deletions(-)
 create mode 100644 module_base/inference.py

diff --git a/module_base/dataset.py b/module_base/dataset.py
index ffcfba4..ce0a90c 100644
--- a/module_base/dataset.py
+++ b/module_base/dataset.py
@@ -100,7 +100,7 @@ def __getitem__(self, item):
         
         image = torch.from_numpy(image).float()
         label = torch.from_numpy(label).float()
-            
+        
         return image, label
 
 class XRayInferenceDataset(Dataset):
diff --git a/module_base/inference.py b/module_base/inference.py
new file mode 100644
index 0000000..77b6191
--- /dev/null
+++ b/module_base/inference.py
@@ -0,0 +1,136 @@
+import os
+import random
+import numpy as np
+import pandas as pd
+import albumentations as A
+import torch
+from tqdm.auto import tqdm
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+from argparse import ArgumentParser
+from dataset import XRayInferenceDataset
+
+def parse_args():
+    parser = ArgumentParser()
+    
+    parser.add_argument('--image_root', type=str, default='//data/ephemeral/home/data/test/DCM',
+                        help='Path to the root directory containing images')
+    parser.add_argument('--save_dir', type=str, default="/data/ephemeral/home/data/train/result",
+                        help='Path to the root directory containing save direction')
+    parser.add_argument('--random_seed', type=int, default=21)
+    args = parser.parse_args()
+    
+    return args
+
+CLASSES = [
+    'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
+    'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
+    'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
+    'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
+    'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
+    'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
+]
+
+CLASS2IND = {v: i for i, v in enumerate(CLASSES)}
+IND2CLASS = {v: k for k, v in CLASS2IND.items()}
+
+def set_seed(random_seed):
+    torch.manual_seed(random_seed)
+    torch.cuda.manual_seed(random_seed)
+    torch.cuda.manual_seed_all(random_seed) # if use multi-GPU
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+    np.random.seed(random_seed)
+    random.seed(random_seed)
+
+def encode_mask_to_rle(mask):
+    '''
+    mask: numpy array binary mask 
+    1 - mask 
+    0 - background
+    Returns encoded run length 
+    '''
+    pixels = mask.flatten()
+    pixels = np.concatenate([[0], pixels, [0]])
+    runs = np.where(pixels[1:] != pixels[:-1])[0] + 1
+    runs[1::2] -= runs[::2]
+    return ' '.join(str(x) for x in runs)
+
+def decode_rle_to_mask(rle, height, width):
+    s = rle.split()
+    starts, lengths = [np.asarray(x, dtype=int) for x in (s[0:][::2], s[1:][::2])]
+    starts -= 1
+    ends = starts + lengths
+    img = np.zeros(height * width, dtype=np.uint8)
+    
+    for lo, hi in zip(starts, ends):
+        img[lo:hi] = 1
+    
+    return img.reshape(height, width)
+
+def test(model, data_loader, thr=0.5):
+    model = model.cuda()
+    model.eval()
+
+    rles = []
+    filename_and_class = []
+    with torch.no_grad():
+        n_class = len(CLASSES)
+
+        for step, (images, image_names) in tqdm(enumerate(data_loader), total=len(data_loader)):
+            images = images.cuda()    
+            outputs = model(images)['out']
+            
+            outputs = F.interpolate(outputs, size=(2048, 2048), mode="bilinear")
+            outputs = torch.sigmoid(outputs)
+            outputs = (outputs > thr).detach().cpu().numpy()
+            
+            for output, image_name in zip(outputs, image_names):
+                for c, segm in enumerate(output):
+                    rle = encode_mask_to_rle(segm)
+                    rles.append(rle)
+                    filename_and_class.append(f"{IND2CLASS[c]}_{image_name}")
+                    
+    return rles, filename_and_class
+
+def do_inference(image_root, save_dir, random_seed):
+    set_seed(random_seed)
+    pngs = {
+        os.path.relpath(os.path.join(root, fname), start=image_root)
+        for root, _dirs, files in os.walk(image_root)
+        for fname in files
+        if os.path.splitext(fname)[1].lower() == ".png"
+    }
+    model = torch.load(os.path.join(save_dir, "best_model.pt"))
+    
+    tf = A.Resize(512, 512)
+    test_dataset = XRayInferenceDataset(pngs, image_root,transforms=tf)
+    
+    test_loader = DataLoader(
+        dataset=test_dataset, 
+        batch_size=2,
+        shuffle=False,
+        num_workers=2,
+        drop_last=False
+    )
+    
+    rles, filename_and_class = test(model, test_loader)
+    
+    classes, filename = zip(*[x.split("_") for x in filename_and_class])
+    
+    image_name = [os.path.basename(f) for f in filename]
+    
+    df = pd.DataFrame({
+        "image_name": image_name,
+        "class": classes,
+        "rle": rles,
+    })
+    
+    df.to_csv("output.csv", index=False)
+
+def main(args):
+    do_inference(**args.__dict__)
+
+if __name__ == '__main__':
+    args = parse_args()
+    main(args)
\ No newline at end of file
diff --git a/module_base/train.py b/module_base/train.py
index 9b654dd..8d6434b 100644
--- a/module_base/train.py
+++ b/module_base/train.py
@@ -12,7 +12,6 @@
 from torch.utils.data import DataLoader
 from torchvision import models
 from dataset import XRayDataset
-
 from argparse import ArgumentParser
 
 def parse_args():

From 5676b6c2388381149f8214c44410f56b38ee754c Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Thu, 14 Nov 2024 18:23:31 +0900
Subject: [PATCH 013/106] [Feature] : modularize base code3

---
 baseline_code.ipynb  | 545 +++++++++----------------------------------
 module_base/train.py |  25 +-
 2 files changed, 130 insertions(+), 440 deletions(-)

diff --git a/baseline_code.ipynb b/baseline_code.ipynb
index aa12b9b..4378ae4 100644
--- a/baseline_code.ipynb
+++ b/baseline_code.ipynb
@@ -57,7 +57,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 77,
+   "execution_count": null,
    "id": "a3907598-e3f4-4c30-b1fe-759870903ecf",
    "metadata": {},
    "outputs": [],
@@ -73,10 +73,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 78,
+   "execution_count": 1,
    "id": "c8295cb6",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/conda/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n",
+      "/opt/conda/lib/python3.10/site-packages/albumentations/__init__.py:13: UserWarning: A new version of Albumentations is available: 1.4.21 (you have 1.4.18). Upgrade using: pip install -U albumentations. To disable automatic update checks, set the environment variable NO_ALBUMENTATIONS_UPDATE to 1.\n",
+      "  check_for_updates()\n"
+     ]
+    }
+   ],
    "source": [
     "# python native\n",
     "import os\n",
@@ -107,7 +118,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 79,
+   "execution_count": 2,
    "id": "1d6746cc",
    "metadata": {},
    "outputs": [],
@@ -120,7 +131,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 80,
+   "execution_count": 3,
    "id": "819e163c",
    "metadata": {},
    "outputs": [],
@@ -137,7 +148,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 81,
+   "execution_count": 4,
    "id": "3192cd81",
    "metadata": {},
    "outputs": [],
@@ -147,7 +158,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 82,
+   "execution_count": 5,
    "id": "1aef86f9",
    "metadata": {},
    "outputs": [],
@@ -157,19 +168,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "id": "cb199e3d",
    "metadata": {},
    "outputs": [],
    "source": [
     "BATCH_SIZE = 8\n",
     "LR = 1e-4\n",
-    "RANDOM_SEED = 21\n",
+    "RANDOM_SEED = 2024\n",
     "\n",
-    "NUM_EPOCHS = 5\n",
-    "VAL_EVERY = 5\n",
+    "NUM_EPOCHS = 24\n",
+    "VAL_EVERY = 3\n",
     "\n",
-    "SAVED_DIR = \"checkpoints\"\n",
+    "SAVED_DIR = \"/data/ephemeral/home/data/result\"\n",
     "\n",
     "if not os.path.exists(SAVED_DIR):                                                           \n",
     "    os.makedirs(SAVED_DIR)"
@@ -193,7 +204,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 84,
+   "execution_count": 7,
    "id": "a0782493",
    "metadata": {},
    "outputs": [],
@@ -208,7 +219,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 85,
+   "execution_count": 8,
    "id": "91a88b61",
    "metadata": {},
    "outputs": [
@@ -218,7 +229,7 @@
        "800"
       ]
      },
-     "execution_count": 85,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -237,7 +248,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 86,
+   "execution_count": 9,
    "id": "be21a515",
    "metadata": {},
    "outputs": [],
@@ -252,7 +263,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 87,
+   "execution_count": 10,
    "id": "eb99fd10",
    "metadata": {},
    "outputs": [
@@ -262,7 +273,7 @@
        "800"
       ]
      },
-     "execution_count": 87,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -281,7 +292,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 88,
+   "execution_count": 11,
    "id": "51eba0f1",
    "metadata": {},
    "outputs": [],
@@ -303,7 +314,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 89,
+   "execution_count": 12,
    "id": "f589a513",
    "metadata": {},
    "outputs": [],
@@ -322,7 +333,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 90,
+   "execution_count": 13,
    "id": "7b0d5bf7",
    "metadata": {},
    "outputs": [],
@@ -428,7 +439,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 91,
+   "execution_count": 14,
    "id": "89defc8c",
    "metadata": {},
    "outputs": [],
@@ -456,7 +467,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 92,
+   "execution_count": 15,
    "id": "e1f1eb8a",
    "metadata": {},
    "outputs": [],
@@ -466,7 +477,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 93,
+   "execution_count": 16,
    "id": "f17abc75",
    "metadata": {},
    "outputs": [],
@@ -477,17 +488,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 94,
+   "execution_count": 17,
    "id": "c193e92b",
    "metadata": {},
    "outputs": [],
    "source": [
-    "image, label = train_dataset[0]"
+    "image, label = train_dataset[146]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 95,
+   "execution_count": 18,
    "id": "5dd474b2",
    "metadata": {},
    "outputs": [
@@ -505,7 +516,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 96,
+   "execution_count": 19,
    "id": "bc100cf6",
    "metadata": {},
    "outputs": [
@@ -515,7 +526,7 @@
        "640"
       ]
      },
-     "execution_count": 96,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -526,13 +537,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 97,
+   "execution_count": 20,
    "id": "f9845fe3",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 2400x1200 with 2 Axes>"
       ]
@@ -559,7 +570,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 98,
+   "execution_count": 21,
    "id": "d5b43501",
    "metadata": {},
    "outputs": [],
@@ -575,7 +586,7 @@
     "# 주의: validation data는 이미지 크기가 크기 때문에 `num_wokers`는 커지면 메모리 에러가 발생할 수 있습니다.\n",
     "valid_loader = DataLoader(\n",
     "    dataset=valid_dataset, \n",
-    "    batch_size=8,\n",
+    "    batch_size=4,\n",
     "    shuffle=False,\n",
     "    num_workers=0,\n",
     "    drop_last=False\n",
@@ -592,7 +603,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 99,
+   "execution_count": 22,
    "id": "687f29a3",
    "metadata": {},
    "outputs": [],
@@ -608,19 +619,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 100,
+   "execution_count": 23,
    "id": "19be0316",
    "metadata": {},
    "outputs": [],
    "source": [
-    "def save_model(model, file_name='fcn_resnet50_best_model.pt'):\n",
+    "def save_model(model, file_name='best_model.pt'):\n",
     "    output_path = os.path.join(SAVED_DIR, file_name)\n",
     "    torch.save(model, output_path)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 101,
+   "execution_count": 24,
    "id": "dd22e901",
    "metadata": {},
    "outputs": [],
@@ -637,15 +648,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 102,
+   "execution_count": 25,
    "id": "40c3a306",
    "metadata": {},
    "outputs": [],
    "source": [
     "def validation(epoch, model, data_loader, criterion, thr=0.5):\n",
     "    print(f'Start validation #{epoch:2d}')\n",
+    "    set_seed()\n",
     "    model.eval()\n",
-    "\n",
     "    dices = []\n",
     "    with torch.no_grad():\n",
     "        n_class = len(CLASSES)\n",
@@ -656,7 +667,8 @@
     "            images, masks = images.cuda(), masks.cuda()         \n",
     "            model = model.cuda()\n",
     "            \n",
-    "            outputs = model(images)['out']\n",
+    "            # outputs = model(images)['out']\n",
+    "            outputs = model(images)\n",
     "            \n",
     "            output_h, output_w = outputs.size(-2), outputs.size(-1)\n",
     "            mask_h, mask_w = masks.size(-2), masks.size(-1)\n",
@@ -692,17 +704,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 103,
+   "execution_count": 26,
    "id": "3acde59b",
    "metadata": {},
    "outputs": [],
    "source": [
     "def train(model, data_loader, val_loader, criterion, optimizer):\n",
     "    print(f'Start training..')\n",
-    "    \n",
+    "    set_seed()\n",
     "    n_class = len(CLASSES)\n",
     "    best_dice = 0.\n",
-    "    \n",
+    "\n",
+    "    # GradScaler를 사용해 Mixed Precision Training을 설정\n",
+    "    scaler = torch.cuda.amp.GradScaler()\n",
+    "\n",
     "    for epoch in range(NUM_EPOCHS):\n",
     "        model.train()\n",
     "\n",
@@ -711,13 +726,25 @@
     "            images, masks = images.cuda(), masks.cuda()\n",
     "            model = model.cuda()\n",
     "            \n",
-    "            outputs = model(images)['out']\n",
+    "            # outputs = model(images)['out']\n",
+    "            # outputs = model(images)\n",
     "            \n",
     "            # loss를 계산합니다.\n",
-    "            loss = criterion(outputs, masks)\n",
+    "            # loss = criterion(outputs, masks)\n",
+    "            # optimizer.zero_grad()\n",
+    "            # loss.backward()\n",
+    "            # optimizer.step()\n",
+    "\n",
+    "            # Mixed Precision Training 적용\n",
+    "            with torch.cuda.amp.autocast():\n",
+    "                outputs = model(images)\n",
+    "                loss = criterion(outputs, masks)\n",
+    "            \n",
+    "            # 스케일된 loss를 사용해 backward 및 optimizer step\n",
     "            optimizer.zero_grad()\n",
-    "            loss.backward()\n",
-    "            optimizer.step()\n",
+    "            scaler.scale(loss).backward()\n",
+    "            scaler.step(optimizer)\n",
+    "            scaler.update()\n",
     "            \n",
     "            # step 주기에 따라 loss를 출력합니다.\n",
     "            if (step + 1) % 25 == 0:\n",
@@ -727,9 +754,11 @@
     "                    f'Step [{step+1}/{len(train_loader)}], '\n",
     "                    f'Loss: {round(loss.item(),4)}'\n",
     "                )\n",
-    "             \n",
+    "                \n",
     "        # validation 주기에 따라 loss를 출력하고 best model을 저장합니다.\n",
     "        if (epoch + 1) % VAL_EVERY == 0:\n",
+    "            # 캐시된 메모리를 해제하여 PyTorch의 메모리 누수를 방지\n",
+    "            torch.cuda.empty_cache()\n",
     "            dice = validation(epoch + 1, model, val_loader, criterion)\n",
     "            \n",
     "            if best_dice < dice:\n",
@@ -749,21 +778,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 104,
+   "execution_count": null,
    "id": "73b106ab",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/opt/conda/lib/python3.10/site-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
-      "  warnings.warn(\n",
-      "/opt/conda/lib/python3.10/site-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=FCN_ResNet50_Weights.COCO_WITH_VOC_LABELS_V1`. You can also use `weights=FCN_ResNet50_Weights.DEFAULT` to get the most up-to-date weights.\n",
-      "  warnings.warn(msg)\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "model = models.segmentation.fcn_resnet50(pretrained=True)\n",
     "\n",
@@ -773,7 +791,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 105,
+   "execution_count": 27,
+   "id": "063b93e9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import segmentation_models_pytorch as smp\n",
+    "\n",
+    "model = smp.Unet(\n",
+    "    encoder_name = \"efficientnet-b0\",\n",
+    "    encoder_weights = \"imagenet\",\n",
+    "    in_channels = 3,\n",
+    "    classes=29\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
    "id": "801e9a3a",
    "metadata": {},
    "outputs": [],
@@ -787,7 +822,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 106,
+   "execution_count": 29,
    "id": "a11d1b92",
    "metadata": {},
    "outputs": [],
@@ -798,7 +833,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 107,
+   "execution_count": null,
    "id": "7564c751",
    "metadata": {},
    "outputs": [
@@ -806,47 +841,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Start training..\n",
-      "2024-11-11 10:25:33 | Epoch [1/25], Step [25/80], Loss: 0.5416\n",
-      "2024-11-11 10:26:00 | Epoch [1/25], Step [50/80], Loss: 0.4473\n",
-      "2024-11-11 10:26:27 | Epoch [1/25], Step [75/80], Loss: 0.3589\n",
-      "2024-11-11 10:27:12 | Epoch [2/25], Step [25/80], Loss: 0.2706\n",
-      "2024-11-11 10:27:41 | Epoch [2/25], Step [50/80], Loss: 0.2141\n",
-      "2024-11-11 10:28:07 | Epoch [2/25], Step [75/80], Loss: 0.1718\n",
-      "2024-11-11 10:28:49 | Epoch [3/25], Step [25/80], Loss: 0.1351\n",
-      "2024-11-11 10:29:16 | Epoch [3/25], Step [50/80], Loss: 0.1124\n",
-      "2024-11-11 10:29:45 | Epoch [3/25], Step [75/80], Loss: 0.0954\n",
-      "2024-11-11 10:30:26 | Epoch [4/25], Step [25/80], Loss: 0.0794\n",
-      "2024-11-11 10:30:55 | Epoch [4/25], Step [50/80], Loss: 0.0699\n",
-      "2024-11-11 10:31:22 | Epoch [4/25], Step [75/80], Loss: 0.0611\n",
-      "2024-11-11 10:32:04 | Epoch [5/25], Step [25/80], Loss: 0.0525\n",
-      "2024-11-11 10:32:32 | Epoch [5/25], Step [50/80], Loss: 0.0474\n",
-      "2024-11-11 10:33:00 | Epoch [5/25], Step [75/80], Loss: 0.0431\n",
-      "Start validation # 5\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  0%|          | 0/20 [00:08<?, ?it/s]\n"
-     ]
-    },
-    {
-     "ename": "OutOfMemoryError",
-     "evalue": "CUDA out of memory. Tried to allocate 3.62 GiB. GPU 0 has a total capacty of 31.74 GiB of which 3.53 GiB is free. Process 3519779 has 28.20 GiB memory in use. Of the allocated memory 19.15 GiB is allocated by PyTorch, and 8.66 GiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting max_split_size_mb to avoid fragmentation.  See documentation for Memory Management and PYTORCH_CUDA_ALLOC_CONF",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mOutOfMemoryError\u001b[0m                          Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[107], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mtrain\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrain_loader\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvalid_loader\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcriterion\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moptimizer\u001b[49m\u001b[43m)\u001b[49m\n",
-      "Cell \u001b[0;32mIn[103], line 34\u001b[0m, in \u001b[0;36mtrain\u001b[0;34m(model, data_loader, val_loader, criterion, optimizer)\u001b[0m\n\u001b[1;32m     32\u001b[0m \u001b[38;5;66;03m# validation 주기에 따라 loss를 출력하고 best model을 저장합니다.\u001b[39;00m\n\u001b[1;32m     33\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (epoch \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m) \u001b[38;5;241m%\u001b[39m VAL_EVERY \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m---> 34\u001b[0m     dice \u001b[38;5;241m=\u001b[39m \u001b[43mvalidation\u001b[49m\u001b[43m(\u001b[49m\u001b[43mepoch\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mval_loader\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcriterion\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     36\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m best_dice \u001b[38;5;241m<\u001b[39m dice:\n\u001b[1;32m     37\u001b[0m         \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mBest performance at epoch: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mepoch\u001b[38;5;250m \u001b[39m\u001b[38;5;241m+\u001b[39m\u001b[38;5;250m \u001b[39m\u001b[38;5;241m1\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m, \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mbest_dice\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m.4f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m -> \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mdice\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m.4f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n",
-      "Cell \u001b[0;32mIn[102], line 24\u001b[0m, in \u001b[0;36mvalidation\u001b[0;34m(epoch, model, data_loader, criterion, thr)\u001b[0m\n\u001b[1;32m     21\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m output_h \u001b[38;5;241m!=\u001b[39m mask_h \u001b[38;5;129;01mor\u001b[39;00m output_w \u001b[38;5;241m!=\u001b[39m mask_w:\n\u001b[1;32m     22\u001b[0m     outputs \u001b[38;5;241m=\u001b[39m F\u001b[38;5;241m.\u001b[39minterpolate(outputs, size\u001b[38;5;241m=\u001b[39m(mask_h, mask_w), mode\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbilinear\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m---> 24\u001b[0m loss \u001b[38;5;241m=\u001b[39m \u001b[43mcriterion\u001b[49m\u001b[43m(\u001b[49m\u001b[43moutputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmasks\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     25\u001b[0m total_loss \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m loss\n\u001b[1;32m     26\u001b[0m cnt \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n",
-      "File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/torch/nn/modules/module.py:1518\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1516\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1517\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1518\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/torch/nn/modules/module.py:1527\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1522\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1523\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1524\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1525\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1526\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1527\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1529\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m   1530\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n",
-      "File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/torch/nn/modules/loss.py:725\u001b[0m, in \u001b[0;36mBCEWithLogitsLoss.forward\u001b[0;34m(self, input, target)\u001b[0m\n\u001b[1;32m    724\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m: Tensor, target: Tensor) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Tensor:\n\u001b[0;32m--> 725\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mF\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbinary_cross_entropy_with_logits\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    726\u001b[0m \u001b[43m                                              \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mweight\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    727\u001b[0m \u001b[43m                                              \u001b[49m\u001b[43mpos_weight\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpos_weight\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    728\u001b[0m \u001b[43m                                              \u001b[49m\u001b[43mreduction\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreduction\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/torch/nn/functional.py:3195\u001b[0m, in \u001b[0;36mbinary_cross_entropy_with_logits\u001b[0;34m(input, target, weight, size_average, reduce, reduction, pos_weight)\u001b[0m\n\u001b[1;32m   3192\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (target\u001b[38;5;241m.\u001b[39msize() \u001b[38;5;241m==\u001b[39m \u001b[38;5;28minput\u001b[39m\u001b[38;5;241m.\u001b[39msize()):\n\u001b[1;32m   3193\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mTarget size (\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mtarget\u001b[38;5;241m.\u001b[39msize()\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m) must be the same as input size (\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28minput\u001b[39m\u001b[38;5;241m.\u001b[39msize()\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m)\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m-> 3195\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbinary_cross_entropy_with_logits\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mweight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpos_weight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mreduction_enum\u001b[49m\u001b[43m)\u001b[49m\n",
-      "\u001b[0;31mOutOfMemoryError\u001b[0m: CUDA out of memory. Tried to allocate 3.62 GiB. GPU 0 has a total capacty of 31.74 GiB of which 3.53 GiB is free. Process 3519779 has 28.20 GiB memory in use. Of the allocated memory 19.15 GiB is allocated by PyTorch, and 8.66 GiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting max_split_size_mb to avoid fragmentation.  See documentation for Memory Management and PYTORCH_CUDA_ALLOC_CONF"
+      "Start training..\n"
      ]
     }
    ],
@@ -869,7 +864,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "model = torch.load(os.path.join(SAVED_DIR, \"fcn_resnet50_best_model.pt\"))"
+    "model = torch.load(os.path.join(SAVED_DIR, \"best_model.pt\"))"
    ]
   },
   {
@@ -904,18 +899,7 @@
    "execution_count": null,
    "id": "ecb5c065-b44b-4f82-ba6d-b41e3e7f6ad2",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "288"
-      ]
-     },
-     "execution_count": 59,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "len(pngs)"
    ]
@@ -1021,7 +1005,8 @@
     "\n",
     "        for step, (images, image_names) in tqdm(enumerate(data_loader), total=len(data_loader)):\n",
     "            images = images.cuda()    \n",
-    "            outputs = model(images)['out']\n",
+    "            # outputs = model(images)['out']\n",
+    "            outputs = model(images)\n",
     "            \n",
     "            outputs = F.interpolate(outputs, size=(2048, 2048), mode=\"bilinear\")\n",
     "            outputs = torch.sigmoid(outputs)\n",
@@ -1077,15 +1062,7 @@
    "execution_count": null,
    "id": "fa7c963b",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 144/144 [03:00<00:00,  1.25s/it]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "rles, filename_and_class = test(model, test_loader)"
    ]
@@ -1103,18 +1080,7 @@
    "execution_count": null,
    "id": "eeedc485",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'finger-1_ID040/image1661319116107.png'"
-      ]
-     },
-     "execution_count": 68,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "filename_and_class[0]"
    ]
@@ -1149,18 +1115,7 @@
    "execution_count": null,
    "id": "679f5401",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 2400x1200 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "fig, ax = plt.subplots(1, 2, figsize=(24, 12))\n",
     "ax[0].imshow(image)    # remove channel dimension\n",
@@ -1216,289 +1171,7 @@
    "execution_count": null,
    "id": "9b8ddbe2",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>image_name</th>\n",
-       "      <th>class</th>\n",
-       "      <th>rle</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>finger-1</td>\n",
-       "      <td>1954318 1 1956365 3 1958412 5 1960459 7 196250...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>finger-2</td>\n",
-       "      <td>2169391 5 2171439 5 2173486 7 2175534 8 217758...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>finger-3</td>\n",
-       "      <td>2587244 6 2589288 12 2591331 19 2593376 23 259...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>finger-4</td>\n",
-       "      <td></td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>finger-5</td>\n",
-       "      <td>1141486 4 1143533 6 1145580 7 1147628 8 114967...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>5</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>finger-6</td>\n",
-       "      <td>1450764 6 1452807 14 1454849 22 1456892 29 145...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>6</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>finger-7</td>\n",
-       "      <td>2050885 12 2052919 27 2054959 37 2057005 39 20...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>7</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>finger-8</td>\n",
-       "      <td></td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>8</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>finger-9</td>\n",
-       "      <td>979923 1 981971 2 984018 5 986066 7 988114 8 9...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>9</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>finger-10</td>\n",
-       "      <td>1344463 32 1346509 35 1348556 37 1350604 37 13...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>10</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>finger-11</td>\n",
-       "      <td>2032592 32 2034637 36 2036683 38 2038728 42 20...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>11</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>finger-12</td>\n",
-       "      <td></td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>12</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>finger-13</td>\n",
-       "      <td>1127599 4 1129646 6 1131693 8 1133741 8 113578...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>13</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>finger-14</td>\n",
-       "      <td>1526924 4 1528963 15 1531003 25 1533044 33 153...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>14</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>finger-15</td>\n",
-       "      <td>2143311 3 2145357 7 2147403 11 2149449 15 2151...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>15</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>finger-16</td>\n",
-       "      <td></td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>16</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>finger-17</td>\n",
-       "      <td></td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>17</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>finger-18</td>\n",
-       "      <td>1852717 5 1854764 7 1856810 10 1858856 12 1860...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>18</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>finger-19</td>\n",
-       "      <td>2286769 3 2288815 6 2290862 8 2292910 10 22949...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>19</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>Trapezium</td>\n",
-       "      <td>3033906 1 3035951 6 3037998 8 3040045 11 30420...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>20</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>Trapezoid</td>\n",
-       "      <td>3046254 2 3048301 4 3050349 5 3052397 4 3054446 2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>21</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>Capitate</td>\n",
-       "      <td>2982860 6 2984902 14 2986947 18 2988993 20 299...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>22</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>Hamate</td>\n",
-       "      <td>2991150 2 2993196 6 2995242 9 2997287 13 29993...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>23</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>Scaphoid</td>\n",
-       "      <td>3203951 4 3205998 6 3208045 8 3210093 9 321214...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>24</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>Lunate</td>\n",
-       "      <td>3308496 15 3310542 29 3312588 36 3314635 38 33...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>25</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>Triquetrum</td>\n",
-       "      <td></td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>26</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>Pisiform</td>\n",
-       "      <td></td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>27</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>Radius</td>\n",
-       "      <td>3320627 1 3322674 3 3324721 6 3326769 8 332881...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>28</th>\n",
-       "      <td>image1661319116107.png</td>\n",
-       "      <td>Ulna</td>\n",
-       "      <td>3523631 7 3525676 15 3527721 22 3529767 28 353...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>29</th>\n",
-       "      <td>image1661319145363.png</td>\n",
-       "      <td>finger-1</td>\n",
-       "      <td>1799602 1 1801649 2 1803695 5 1805743 5 180779...</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "                image_name       class  \\\n",
-       "0   image1661319116107.png    finger-1   \n",
-       "1   image1661319116107.png    finger-2   \n",
-       "2   image1661319116107.png    finger-3   \n",
-       "3   image1661319116107.png    finger-4   \n",
-       "4   image1661319116107.png    finger-5   \n",
-       "5   image1661319116107.png    finger-6   \n",
-       "6   image1661319116107.png    finger-7   \n",
-       "7   image1661319116107.png    finger-8   \n",
-       "8   image1661319116107.png    finger-9   \n",
-       "9   image1661319116107.png   finger-10   \n",
-       "10  image1661319116107.png   finger-11   \n",
-       "11  image1661319116107.png   finger-12   \n",
-       "12  image1661319116107.png   finger-13   \n",
-       "13  image1661319116107.png   finger-14   \n",
-       "14  image1661319116107.png   finger-15   \n",
-       "15  image1661319116107.png   finger-16   \n",
-       "16  image1661319116107.png   finger-17   \n",
-       "17  image1661319116107.png   finger-18   \n",
-       "18  image1661319116107.png   finger-19   \n",
-       "19  image1661319116107.png   Trapezium   \n",
-       "20  image1661319116107.png   Trapezoid   \n",
-       "21  image1661319116107.png    Capitate   \n",
-       "22  image1661319116107.png      Hamate   \n",
-       "23  image1661319116107.png    Scaphoid   \n",
-       "24  image1661319116107.png      Lunate   \n",
-       "25  image1661319116107.png  Triquetrum   \n",
-       "26  image1661319116107.png    Pisiform   \n",
-       "27  image1661319116107.png      Radius   \n",
-       "28  image1661319116107.png        Ulna   \n",
-       "29  image1661319145363.png    finger-1   \n",
-       "\n",
-       "                                                  rle  \n",
-       "0   1954318 1 1956365 3 1958412 5 1960459 7 196250...  \n",
-       "1   2169391 5 2171439 5 2173486 7 2175534 8 217758...  \n",
-       "2   2587244 6 2589288 12 2591331 19 2593376 23 259...  \n",
-       "3                                                      \n",
-       "4   1141486 4 1143533 6 1145580 7 1147628 8 114967...  \n",
-       "5   1450764 6 1452807 14 1454849 22 1456892 29 145...  \n",
-       "6   2050885 12 2052919 27 2054959 37 2057005 39 20...  \n",
-       "7                                                      \n",
-       "8   979923 1 981971 2 984018 5 986066 7 988114 8 9...  \n",
-       "9   1344463 32 1346509 35 1348556 37 1350604 37 13...  \n",
-       "10  2032592 32 2034637 36 2036683 38 2038728 42 20...  \n",
-       "11                                                     \n",
-       "12  1127599 4 1129646 6 1131693 8 1133741 8 113578...  \n",
-       "13  1526924 4 1528963 15 1531003 25 1533044 33 153...  \n",
-       "14  2143311 3 2145357 7 2147403 11 2149449 15 2151...  \n",
-       "15                                                     \n",
-       "16                                                     \n",
-       "17  1852717 5 1854764 7 1856810 10 1858856 12 1860...  \n",
-       "18  2286769 3 2288815 6 2290862 8 2292910 10 22949...  \n",
-       "19  3033906 1 3035951 6 3037998 8 3040045 11 30420...  \n",
-       "20  3046254 2 3048301 4 3050349 5 3052397 4 3054446 2  \n",
-       "21  2982860 6 2984902 14 2986947 18 2988993 20 299...  \n",
-       "22  2991150 2 2993196 6 2995242 9 2997287 13 29993...  \n",
-       "23  3203951 4 3205998 6 3208045 8 3210093 9 321214...  \n",
-       "24  3308496 15 3310542 29 3312588 36 3314635 38 33...  \n",
-       "25                                                     \n",
-       "26                                                     \n",
-       "27  3320627 1 3322674 3 3324721 6 3326769 8 332881...  \n",
-       "28  3523631 7 3525676 15 3527721 22 3529767 28 353...  \n",
-       "29  1799602 1 1801649 2 1803695 5 1805743 5 180779...  "
-      ]
-     },
-     "execution_count": 75,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "df.head(30)"
    ]
@@ -1510,7 +1183,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df.to_csv(\"output.csv\", index=False)"
+    "df.to_csv(\"smp_Unet_efficient-b0.csv\", index=False)"
    ]
   }
  ],
diff --git a/module_base/train.py b/module_base/train.py
index 8d6434b..5a5760d 100644
--- a/module_base/train.py
+++ b/module_base/train.py
@@ -118,6 +118,9 @@ def train(model, train_loader, valid_loader, criterion, optimizer, save_dir, ran
     
     n_class = len(CLASSES)
     best_dice = 0.
+
+    # GradScaler를 사용해 Mixed Precision Training을 설정
+    scaler = torch.cuda.amp.GradScaler()
     
     for epoch in range(max_epoch):
         model.train()
@@ -127,13 +130,25 @@ def train(model, train_loader, valid_loader, criterion, optimizer, save_dir, ran
             images, masks = images.cuda(), masks.cuda()
             model = model.cuda()
             
-            outputs = model(images)['out']
+            # outputs = model(images)['out']
+            # outputs = model(images)
             
             # loss를 계산합니다.
-            loss = criterion(outputs, masks)
+            # loss = criterion(outputs, masks)
+            # optimizer.zero_grad()
+            # loss.backward()
+            # optimizer.step()
+
+            # Mixed Precision Training 적용
+            with torch.cuda.amp.autocast():
+                outputs = model(images)
+                loss = criterion(outputs, masks)
+            
+            # 스케일된 loss를 사용해 backward 및 optimizer step
             optimizer.zero_grad()
-            loss.backward()
-            optimizer.step()
+            scaler.scale(loss).backward()
+            scaler.step(optimizer)
+            scaler.update()
             
             # step 주기에 따라 loss를 출력합니다.
             if (step + 1) % 25 == 0:
@@ -146,6 +161,8 @@ def train(model, train_loader, valid_loader, criterion, optimizer, save_dir, ran
                 
         # validation 주기에 따라 loss를 출력하고 best model을 저장합니다.
         if (epoch + 1) % val_every == 0:
+            # 캐시된 메모리를 해제하여 PyTorch의 메모리 누수를 방지
+            torch.cuda.empty_cache()
             dice = validation(epoch + 1, model, valid_loader, criterion)
             
             if best_dice < dice:

From a7b662cbb76f6ed1b30b830b501f3060d8045da4 Mon Sep 17 00:00:00 2001
From: wonjeongjeong <wj3714@naver.com>
Date: Thu, 14 Nov 2024 12:39:09 +0000
Subject: [PATCH 014/106] =?UTF-8?q?[Feature]=20:=20streamlit=20CSV=20?=
 =?UTF-8?q?=EC=8B=9C=EA=B0=81=ED=99=94=20=EC=98=B5=EC=85=98=20=EC=B6=94?=
 =?UTF-8?q?=EA=B0=80?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 copy_all_png.py            | 25 +++++++++++++++
 streamlit/main.py          | 51 ++++++++++++++++++++++++++++--
 streamlit/visualize_rle.py | 64 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 137 insertions(+), 3 deletions(-)
 create mode 100644 copy_all_png.py
 create mode 100644 streamlit/visualize_rle.py

diff --git a/copy_all_png.py b/copy_all_png.py
new file mode 100644
index 0000000..864fce4
--- /dev/null
+++ b/copy_all_png.py
@@ -0,0 +1,25 @@
+import os
+import shutil
+
+# 기본 디렉토리와 새 폴더 정의
+base_dir = 'data/test/DCM'
+new_folder = os.path.join(base_dir, 'all_pngs')
+
+# 새 폴더가 없으면 생성
+if not os.path.exists(new_folder):
+    os.makedirs(new_folder)
+
+# ID*** 폴더를 순회하며 PNG 파일을 새 폴더로 복사
+for subdir, dirs, files in os.walk(base_dir):
+    if os.path.basename(subdir) == 'all_pngs':
+        continue  # 새 폴더는 건너뛰기
+    for file in files:
+        if file.endswith('.png'):
+            src_path = os.path.join(subdir, file)
+            dst_path = os.path.join(new_folder, file)
+            shutil.copy(src_path, dst_path)
+            print(f'복사됨: {src_path} -> {dst_path}')
+
+# 결과 확인
+png_files = [f for f in os.listdir(new_folder) if f.endswith('.png')]
+print(f'복사된 PNG 파일 수: {len(png_files)}')
\ No newline at end of file
diff --git a/streamlit/main.py b/streamlit/main.py
index 89beb52..c915f8c 100644
--- a/streamlit/main.py
+++ b/streamlit/main.py
@@ -1,8 +1,14 @@
 import streamlit as st
-import load, visualize_v1, visualize_v2
+import load, visualize_v1, visualize_v2, visualize_rle
+import pandas as pd
+
+'''
+streamlit 실행하기 전에 del_ID_dir.py 실행 !!
+'''
 
 info = {
     'image_root': "../../data/train/DCM",
+    'all_image_root': "../../data/test/DCM/all_pngs",
     'label_root': "../../data/train/outputs_json",
     'classes': [
         'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
@@ -26,6 +32,12 @@
         'Pisiform': (145,42,177),
         'Radius': (210,71,77),
         'Ulna': (210,71,77),
+        'Trapezium': (0,85,0),
+        'Capitate': (230,114,61),
+        'Hamate': (196,183,59),
+        'Scaphoid': (120,240,50),
+        'Lunate': (107,102,255),
+        'Triquetrum': (116,116,116),
         'wrist': (193,223,159)
     }
 }
@@ -38,7 +50,7 @@
 if "labels" not in st.session_state:
     st.session_state.labels = []
 
-option = st.sidebar.radio("option", ["train", "validation", "test"])
+option = st.sidebar.radio("option", ["train", "validation", "test", "RLE Visualization"])
 if option == "train":
     st.session_state.images, st.session_state.labels = load.load(info)
     with st.sidebar.form(key="form"):
@@ -54,4 +66,37 @@
 if option == "validation":
     st.write("개발중입니다...")
 if option == "test":
-    st.write("개발중입니다...")
\ No newline at end of file
+    st.write("개발중입니다...")
+if option == "RLE Visualization":
+    csv_file = st.sidebar.file_uploader("Upload RLE CSV file", type="csv")
+    if csv_file is not None:
+        df = pd.read_csv(csv_file)
+        df['rle'] = df['rle'].fillna('')  # NaN 값을 빈 문자열로 대체
+        # 이미지 이름 목록 생성
+        image_names = df['image_name'].unique()
+        
+        # 현재 이미지 인덱스를 세션 상태로 관리
+        if 'current_image_index' not in st.session_state:
+            st.session_state.current_image_index = 0
+        
+        # 이전 버튼
+        if st.sidebar.button('Previous Image'):
+            st.session_state.current_image_index = max(0, st.session_state.current_image_index - 1)
+        
+        # 다음 버튼
+        if st.sidebar.button('Next Image'):
+            st.session_state.current_image_index = min(len(image_names) - 1, st.session_state.current_image_index + 1)
+        
+        # 현재 이미지 이름 표시
+        current_image = image_names[st.session_state.current_image_index]
+        st.sidebar.write(f"Current Image: {current_image}")
+        
+        # 이미지 인덱스 슬라이더 (옵션)
+        image_index = st.sidebar.slider('Select image index', 0, len(image_names)-1, st.session_state.current_image_index)
+        st.session_state.current_image_index = image_index
+        
+        # 현재 선택된 이미지에 대한 데이터프레임 생성
+        current_df = df[df['image_name'] == current_image]
+        
+        # 시각화 함수 호출
+        visualize_rle.show(info, current_df, 0)
\ No newline at end of file
diff --git a/streamlit/visualize_rle.py b/streamlit/visualize_rle.py
new file mode 100644
index 0000000..e582f65
--- /dev/null
+++ b/streamlit/visualize_rle.py
@@ -0,0 +1,64 @@
+import streamlit as st
+import numpy as np
+import cv2
+import matplotlib.pyplot as plt
+from PIL import Image
+import os
+import pandas as pd
+
+def rle2mask(rle, shape):
+    if pd.isna(rle):
+        return np.zeros(shape, dtype=np.uint8)
+    try:
+        s = np.array(rle.split(), dtype=int)
+        starts, lengths = s[0::2] - 1, s[1::2]
+        ends = starts + lengths
+        img = np.zeros(shape[0]*shape[1], dtype=np.uint8)
+        for lo, hi in zip(starts, ends):
+            img[lo:hi] = 1
+        return img.reshape(shape)
+    except AttributeError:
+        # RLE가 예상치 못한 형식일 경우 빈 마스크 반환
+        return np.zeros(shape, dtype=np.uint8)
+
+def show(info, df, image_index):
+    if image_index >= len(df):
+        st.error("Index out of bounds for the current DataFrame.")
+        return
+    
+    image_name = df.iloc[image_index]['image_name']
+    image_path = os.path.join(info['all_image_root'], image_name)
+    image = Image.open(image_path).convert("RGB")
+    image_np = np.array(image)
+    
+    # Create a mask for the segmentation
+    mask = np.zeros((*image.size[::-1], 3), dtype=np.uint8)
+    contour_mask = np.zeros((*image.size[::-1], 3), dtype=np.uint8)
+    
+    for _, row in df[df['image_name'] == image_name].iterrows():
+        class_mask = rle2mask(row['rle'], image.size[::-1])
+        class_name = row['class']
+        
+        # 색상 선택 로직
+        if class_name.startswith('finger'):
+            color = info['color']['finger']
+        elif class_name in ['Trapezoid', 'Pisiform', 'Radius', 'Ulna', 'Trapezium', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate', 'Triquetrum']:
+            color = info['color'][class_name]  # 특정 클래스의 경우 개별 색상 적용
+
+        mask[class_mask == 1] = color
+        
+        # Find contours
+        contours, _ = cv2.findContours(class_mask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        
+        # Draw contours on the contour mask
+        cv2.drawContours(contour_mask, contours, -1, color, 2)
+        
+    # Overlay the mask on the original image
+    overlay_image = cv2.addWeighted(np.array(image), 0.5, mask, 0.5, 0)
+
+    # Add contours to the overlayed image
+    final_image = cv2.addWeighted(overlay_image, 1, contour_mask, 1, 0)
+
+    # Display the overlayed image
+    st.image(final_image, caption=image_name, use_container_width=True)
+

From 0ed75567cf1fd46ac575be6760b21051f13e79d3 Mon Sep 17 00:00:00 2001
From: wonjeongjeong <wj3714@naver.com>
Date: Thu, 14 Nov 2024 12:43:04 +0000
Subject: [PATCH 015/106] =?UTF-8?q?[Comment]=20:=20=EC=A3=BC=EC=84=9D=20?=
 =?UTF-8?q?=EC=88=98=EC=A0=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 streamlit/main.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/streamlit/main.py b/streamlit/main.py
index c915f8c..d1b8c61 100644
--- a/streamlit/main.py
+++ b/streamlit/main.py
@@ -2,9 +2,9 @@
 import load, visualize_v1, visualize_v2, visualize_rle
 import pandas as pd
 
-'''
-streamlit 실행하기 전에 del_ID_dir.py 실행 !!
-'''
+
+#streamlit 실행하기 전에 del_ID_dir.py 실행 !!
+
 
 info = {
     'image_root': "../../data/train/DCM",

From bed0e9c736b9f7c139485041ff151849fcd53a72 Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Thu, 14 Nov 2024 21:55:14 +0900
Subject: [PATCH 016/106] [Feature]:add code for mmsegmentation and util
 function for mmseg dataset

---
 mmsegmentation/.circleci/config.yml           |   34 +
 mmsegmentation/.circleci/docker/Dockerfile    |   12 +
 mmsegmentation/.circleci/test.yml             |  196 ++
 .../.dev_scripts/batch_test_list.py           |  133 +
 .../.dev_scripts/batch_train_list.txt         |   19 +
 .../.dev_scripts/benchmark_evaluation.sh      |   41 +
 .../.dev_scripts/benchmark_full_models.txt    |   57 +
 .../.dev_scripts/benchmark_inference.py       |  149 +
 .../.dev_scripts/benchmark_options.py         |   10 +
 .../.dev_scripts/benchmark_train.sh           |   40 +
 .../.dev_scripts/benchmark_train_models.txt   |   26 +
 mmsegmentation/.dev_scripts/check_urls.py     |  100 +
 .../gather_benchmark_evaluation_results.py    |   91 +
 .../gather_benchmark_train_results.py         |  100 +
 mmsegmentation/.dev_scripts/gather_models.py  |  213 ++
 .../generate_benchmark_evaluation_script.py   |  114 +
 .../generate_benchmark_train_script.py        |   91 +
 .../log_collector/example_config.py           |   18 +
 .../log_collector/log_collector.py            |  143 +
 .../.dev_scripts/log_collector/readme.md      |  144 +
 .../.dev_scripts/log_collector/utils.py       |   20 +
 .../.dev_scripts/update_model_index.py        |  301 ++
 .../.dev_scripts/upload_modelzoo.py           |   45 +
 mmsegmentation/.github/CODE_OF_CONDUCT.md     |   76 +
 mmsegmentation/.github/CONTRIBUTING.md        |   59 +
 .../.github/ISSUE_TEMPLATE/config.yml         |    6 +
 .../.github/ISSUE_TEMPLATE/error-report.md    |   48 +
 .../.github/ISSUE_TEMPLATE/feature_request.md |   21 +
 .../ISSUE_TEMPLATE/general_questions.md       |    7 +
 .../reimplementation_questions.md             |   69 +
 .../.github/pull_request_template.md          |   25 +
 mmsegmentation/.github/workflows/deploy.yml   |   26 +
 mmsegmentation/.gitignore                     |  120 +
 mmsegmentation/.owners.yml                    |    7 +
 mmsegmentation/.pre-commit-config.yaml        |   67 +
 mmsegmentation/CITATION.cff                   |    8 +
 mmsegmentation/LICENSE                        |  203 ++
 mmsegmentation/MANIFEST.in                    |    5 +
 mmsegmentation/README.md                      |  420 +++
 mmsegmentation/README_zh-CN.md                |  426 +++
 .../configs/_base_/datasets/ade20k.py         |   68 +
 .../configs/_base_/datasets/ade20k_640x640.py |   68 +
 .../configs/_base_/datasets/bdd100k.py        |   70 +
 .../configs/_base_/datasets/chase_db1.py      |   75 +
 .../configs/_base_/datasets/cityscapes.py     |   67 +
 .../_base_/datasets/cityscapes_1024x1024.py   |   29 +
 .../_base_/datasets/cityscapes_768x768.py     |   29 +
 .../_base_/datasets/cityscapes_769x769.py     |   29 +
 .../_base_/datasets/cityscapes_832x832.py     |   29 +
 .../configs/_base_/datasets/coco-stuff10k.py  |   69 +
 .../configs/_base_/datasets/coco-stuff164k.py |   67 +
 .../configs/_base_/datasets/drive.py          |   73 +
 mmsegmentation/configs/_base_/datasets/hrf.py |   73 +
 .../configs/_base_/datasets/hsi_drive.py      |   53 +
 .../configs/_base_/datasets/isaid.py          |   73 +
 .../configs/_base_/datasets/levir_256x256.py  |   68 +
 .../configs/_base_/datasets/loveda.py         |   66 +
 .../configs/_base_/datasets/mapillary_v1.py   |   68 +
 .../_base_/datasets/mapillary_v1_65.py        |   37 +
 .../configs/_base_/datasets/mapillary_v2.py   |   68 +
 mmsegmentation/configs/_base_/datasets/nyu.py |   67 +
 .../configs/_base_/datasets/nyu_512x512.py    |   72 +
 .../configs/_base_/datasets/pascal_context.py |   56 +
 .../_base_/datasets/pascal_context_59.py      |   72 +
 .../configs/_base_/datasets/pascal_voc12.py   |   69 +
 .../_base_/datasets/pascal_voc12_aug.py       |   81 +
 .../configs/_base_/datasets/potsdam.py        |   66 +
 .../configs/_base_/datasets/refuge.py         |   90 +
 .../configs/_base_/datasets/stare.py          |   73 +
 .../configs/_base_/datasets/synapse.py        |   41 +
 .../configs/_base_/datasets/vaihingen.py      |   66 +
 .../configs/_base_/default_runtime.py         |   15 +
 .../configs/_base_/models/ann_r50-d8.py       |   54 +
 .../configs/_base_/models/apcnet_r50-d8.py    |   52 +
 .../_base_/models/bisenetv1_r18-d32.py        |   76 +
 .../configs/_base_/models/bisenetv2.py        |   88 +
 .../configs/_base_/models/ccnet_r50-d8.py     |   52 +
 mmsegmentation/configs/_base_/models/cgnet.py |   43 +
 .../configs/_base_/models/danet_r50-d8.py     |   52 +
 .../configs/_base_/models/deeplabv3_r50-d8.py |   52 +
 .../_base_/models/deeplabv3_unet_s5-d16.py    |   58 +
 .../_base_/models/deeplabv3plus_r50-d8.py     |   54 +
 .../configs/_base_/models/dmnet_r50-d8.py     |   52 +
 .../configs/_base_/models/dnl_r50-d8.py       |   54 +
 .../configs/_base_/models/dpt_vit-b16.py      |   39 +
 .../configs/_base_/models/emanet_r50-d8.py    |   55 +
 .../configs/_base_/models/encnet_r50-d8.py    |   56 +
 .../configs/_base_/models/erfnet_fcn.py       |   40 +
 .../configs/_base_/models/fast_scnn.py        |   65 +
 .../_base_/models/fastfcn_r50-d32_jpu_psp.py  |   61 +
 .../configs/_base_/models/fcn_hr18.py         |   60 +
 .../configs/_base_/models/fcn_r50-d8.py       |   53 +
 .../configs/_base_/models/fcn_unet_s5-d16.py  |   59 +
 .../_base_/models/fpn_poolformer_s12.py       |   54 +
 .../configs/_base_/models/fpn_r50.py          |   44 +
 .../configs/_base_/models/gcnet_r50-d8.py     |   54 +
 .../configs/_base_/models/icnet_r50-d8.py     |   82 +
 .../configs/_base_/models/isanet_r50-d8.py    |   53 +
 .../configs/_base_/models/lraspp_m-v3-d8.py   |   33 +
 .../configs/_base_/models/nonlocal_r50-d8.py  |   54 +
 .../configs/_base_/models/ocrnet_hr18.py      |   76 +
 .../configs/_base_/models/ocrnet_r50-d8.py    |   55 +
 .../configs/_base_/models/pointrend_r50.py    |   64 +
 .../configs/_base_/models/psanet_r50-d8.py    |   57 +
 .../configs/_base_/models/pspnet_r50-d8.py    |   52 +
 .../_base_/models/pspnet_unet_s5-d16.py       |   58 +
 .../configs/_base_/models/san_vit-b16.py      |  137 +
 .../configs/_base_/models/segformer_mit-b0.py |   42 +
 .../_base_/models/segmenter_vit-b16_mask.py   |   44 +
 .../configs/_base_/models/setr_mla.py         |  103 +
 .../configs/_base_/models/setr_naive.py       |   88 +
 .../configs/_base_/models/setr_pup.py         |   88 +
 mmsegmentation/configs/_base_/models/stdc.py  |   91 +
 .../_base_/models/twins_pcpvt-s_fpn.py        |   53 +
 .../_base_/models/twins_pcpvt-s_upernet.py    |   61 +
 .../configs/_base_/models/upernet_beit.py     |   58 +
 .../configs/_base_/models/upernet_convnext.py |   52 +
 .../configs/_base_/models/upernet_mae.py      |   57 +
 .../configs/_base_/models/upernet_r50.py      |   52 +
 .../configs/_base_/models/upernet_swin.py     |   62 +
 .../_base_/models/upernet_vit-b16_ln_mln.py   |   65 +
 .../configs/_base_/models/vpd_sd.py           |   86 +
 .../configs/_base_/schedules/schedule_160k.py |   25 +
 .../configs/_base_/schedules/schedule_20k.py  |   24 +
 .../configs/_base_/schedules/schedule_240k.py |   25 +
 .../configs/_base_/schedules/schedule_25k.py  |   28 +
 .../configs/_base_/schedules/schedule_320k.py |   25 +
 .../configs/_base_/schedules/schedule_40k.py  |   24 +
 .../configs/_base_/schedules/schedule_80k.py  |   24 +
 mmsegmentation/configs/ann/README.md          |   68 +
 ...nn_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 +
 ...ann_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 +
 ...nn_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...ann_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 +
 .../ann_r101-d8_4xb4-160k_ade20k-512x512.py   |    2 +
 .../ann_r101-d8_4xb4-20k_voc12aug-512x512.py  |    2 +
 .../ann_r101-d8_4xb4-40k_voc12aug-512x512.py  |    2 +
 .../ann_r101-d8_4xb4-80k_ade20k-512x512.py    |    2 +
 ...ann_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 +
 .../ann_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 +
 ...ann_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 +
 .../ann_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 +
 .../ann_r50-d8_4xb4-160k_ade20k-512x512.py    |   10 +
 .../ann_r50-d8_4xb4-20k_voc12aug-512x512.py   |   10 +
 .../ann_r50-d8_4xb4-40k_voc12aug-512x512.py   |   10 +
 .../ann/ann_r50-d8_4xb4-80k_ade20k-512x512.py |   10 +
 mmsegmentation/configs/ann/metafile.yaml      |  391 +++
 mmsegmentation/configs/apcnet/README.md       |   59 +
 ...et_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 +
 ...net_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 +
 ...et_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...net_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 +
 ...apcnet_r101-d8_4xb4-160k_ade20k-512x512.py |    2 +
 .../apcnet_r101-d8_4xb4-80k_ade20k-512x512.py |    2 +
 ...net_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 +
 ...cnet_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 +
 ...net_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 +
 ...cnet_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 +
 .../apcnet_r50-d8_4xb4-160k_ade20k-512x512.py |   10 +
 .../apcnet_r50-d8_4xb4-80k_ade20k-512x512.py  |   10 +
 mmsegmentation/configs/apcnet/metafile.yaml   |  296 ++
 mmsegmentation/configs/beit/README.md         |   85 +
 ...t-base_upernet_8xb2-160k_ade20k-640x640.py |   36 +
 ...ase_upernet_8xb2-160k_ade20k-640x640_ms.py |   16 +
 ...ge_upernet_8xb1-amp-160k_ade20k-640x640.py |   50 +
 ...upernet_8xb1-amp-160k_ade20k-640x640_ms.py |   16 +
 mmsegmentation/configs/beit/metafile.yaml     |   49 +
 mmsegmentation/configs/bisenetv1/README.md    |   64 +
 ...1k-pre_4xb4-160k_coco-stuff164k-512x512.py |    6 +
 ...01-d32_4xb4-160k_coco-stuff164k-512x512.py |   58 +
 ...in1k-pre_4xb4-160k_cityscapes-1024x1024.py |   29 +
 ...1k-pre_4xb4-160k_coco-stuff164k-512x512.py |   10 +
 ...in1k-pre_4xb8-160k_cityscapes-1024x1024.py |    4 +
 ..._r18-d32_4xb4-160k_cityscapes-1024x1024.py |   24 +
 ...18-d32_4xb4-160k_coco-stuff164k-512x512.py |   53 +
 ...in1k-pre_4xb4-160k_cityscapes-1024x1024.py |    7 +
 ...1k-pre_4xb4-160k_coco-stuff164k-512x512.py |    7 +
 ..._r50-d32_4xb4-160k_cityscapes-1024x1024.py |   55 +
 ...50-d32_4xb4-160k_coco-stuff164k-512x512.py |   58 +
 .../configs/bisenetv1/metafile.yaml           |  275 ++
 mmsegmentation/configs/bisenetv2/README.md    |   53 +
 ...etv2_fcn_4xb4-160k_cityscapes-1024x1024.py |   24 +
 ..._fcn_4xb4-amp-160k_cityscapes-1024x1024.py |    6 +
 ...fcn_4xb4-ohem-160k_cityscapes-1024x1024.py |   83 +
 ...etv2_fcn_4xb8-160k_cityscapes-1024x1024.py |   24 +
 .../configs/bisenetv2/metafile.yaml           |  114 +
 mmsegmentation/configs/ccnet/README.md        |   67 +
 ...et_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 +
 ...net_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 +
 ...et_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...net_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 +
 .../ccnet_r101-d8_4xb4-160k_ade20k-512x512.py |    2 +
 ...ccnet_r101-d8_4xb4-20k_voc12aug-512x512.py |    2 +
 ...ccnet_r101-d8_4xb4-40k_voc12aug-512x512.py |    2 +
 .../ccnet_r101-d8_4xb4-80k_ade20k-512x512.py  |    2 +
 ...net_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 +
 ...cnet_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 +
 ...net_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 +
 ...cnet_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 +
 .../ccnet_r50-d8_4xb4-160k_ade20k-512x512.py  |   10 +
 .../ccnet_r50-d8_4xb4-20k_voc12aug-512x512.py |   11 +
 .../ccnet_r50-d8_4xb4-40k_voc12aug-512x512.py |   11 +
 .../ccnet_r50-d8_4xb4-80k_ade20k-512x512.py   |   10 +
 mmsegmentation/configs/ccnet/metafile.yaml    |  391 +++
 mmsegmentation/configs/cgnet/README.md        |   46 +
 .../cgnet_fcn_4xb4-60k_cityscapes-680x680.py  |   59 +
 .../cgnet_fcn_4xb8-60k_cityscapes-512x1024.py |   38 +
 mmsegmentation/configs/cgnet/metafile.yaml    |   61 +
 mmsegmentation/configs/convnext/README.md     |   74 +
 ...se_upernet_8xb2-amp-160k_ade20k-512x512.py |   43 +
 ...se_upernet_8xb2-amp-160k_ade20k-640x640.py |   58 +
 ...ge_upernet_8xb2-amp-160k_ade20k-640x640.py |   58 +
 ...ll_upernet_8xb2-amp-160k_ade20k-512x512.py |   57 +
 ...ny_upernet_8xb2-amp-160k_ade20k-512x512.py |   57 +
 ...ge_upernet_8xb2-amp-160k_ade20k-640x640.py |   58 +
 mmsegmentation/configs/convnext/metafile.yaml |  145 +
 mmsegmentation/configs/danet/README.md        |   67 +
 ...et_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 +
 ...net_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 +
 ...et_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...net_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 +
 .../danet_r101-d8_4xb4-160k_ade20k-512x512.py |    2 +
 ...danet_r101-d8_4xb4-20k_voc12aug-512x512.py |    2 +
 ...danet_r101-d8_4xb4-40k_voc12aug-512x512.py |    2 +
 .../danet_r101-d8_4xb4-80k_ade20k-512x512.py  |    2 +
 ...net_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 +
 ...anet_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 +
 ...net_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 +
 ...anet_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 +
 .../danet_r50-d8_4xb4-160k_ade20k-512x512.py  |   10 +
 .../danet_r50-d8_4xb4-20k_voc12aug-512x512.py |   11 +
 .../danet_r50-d8_4xb4-40k_voc12aug-512x512.py |   11 +
 .../danet_r50-d8_4xb4-80k_ade20k-512x512.py   |   10 +
 mmsegmentation/configs/danet/metafile.yaml    |  387 +++
 mmsegmentation/configs/ddrnet/README.md       |   46 +
 ...in1k-pre_2xb6-120k_cityscapes-1024x1024.py |   93 +
 ...in1k-pre_2xb6-120k_cityscapes-1024x1024.py |   93 +
 mmsegmentation/configs/ddrnet/metafile.yaml   |   64 +
 mmsegmentation/configs/deeplabv3/README.md    |  118 +
 ...-d16-mg124_4xb2-40k_cityscapes-512x1024.py |   11 +
 ...-d16-mg124_4xb2-80k_cityscapes-512x1024.py |   11 +
 ...v3_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 +
 ...bv3_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 +
 ...v3_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...bv3_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 +
 ...101-d8_4xb2-amp-80k_cityscapes-512x1024.py |    7 +
 ...plabv3_r101-d8_4xb4-160k_ade20k-512x512.py |    2 +
 ...101-d8_4xb4-160k_coco-stuff164k-512x512.py |    2 +
 ..._r101-d8_4xb4-20k_coco-stuff10k-512x512.py |    2 +
 ...labv3_r101-d8_4xb4-20k_voc12aug-512x512.py |    2 +
 ...101-d8_4xb4-320k_coco-stuff164k-512x512.py |    2 +
 ..._r101-d8_4xb4-40k_coco-stuff10k-512x512.py |    2 +
 ...r101-d8_4xb4-40k_pascal-context-480x480.py |    2 +
 ...1-d8_4xb4-40k_pascal-context-59-480x480.py |    2 +
 ...labv3_r101-d8_4xb4-40k_voc12aug-512x512.py |    2 +
 ...eplabv3_r101-d8_4xb4-80k_ade20k-512x512.py |    2 +
 ...r101-d8_4xb4-80k_coco-stuff164k-512x512.py |    2 +
 ...r101-d8_4xb4-80k_pascal-context-480x480.py |    2 +
 ...1-d8_4xb4-80k_pascal-context-59-480x480.py |    2 +
 ...3_r101b-d8_4xb2-80k_cityscapes-512x1024.py |    4 +
 ...v3_r101b-d8_4xb2-80k_cityscapes-769x769.py |    4 +
 ...bv3_r18-d8_4xb2-80k_cityscapes-512x1024.py |    9 +
 ...abv3_r18-d8_4xb2-80k_cityscapes-769x769.py |    9 +
 ...v3_r18b-d8_4xb2-80k_cityscapes-512x1024.py |    9 +
 ...bv3_r18b-d8_4xb2-80k_cityscapes-769x769.py |    9 +
 ...bv3_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 +
 ...abv3_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 +
 ...bv3_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 +
 ...abv3_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 +
 ...eplabv3_r50-d8_4xb4-160k_ade20k-512x512.py |   10 +
 ...r50-d8_4xb4-160k_coco-stuff164k-512x512.py |   11 +
 ...3_r50-d8_4xb4-20k_coco-stuff10k-512x512.py |   11 +
 ...plabv3_r50-d8_4xb4-20k_voc12aug-512x512.py |   11 +
 ...r50-d8_4xb4-320k_coco-stuff164k-512x512.py |   11 +
 ...3_r50-d8_4xb4-40k_coco-stuff10k-512x512.py |   11 +
 ..._r50-d8_4xb4-40k_pascal-context-480x480.py |   14 +
 ...0-d8_4xb4-40k_pascal-context-59-480x480.py |   14 +
 ...plabv3_r50-d8_4xb4-40k_voc12aug-512x512.py |   11 +
 ...eeplabv3_r50-d8_4xb4-80k_ade20k-512x512.py |   10 +
 ..._r50-d8_4xb4-80k_coco-stuff164k-512x512.py |   11 +
 ..._r50-d8_4xb4-80k_pascal-context-480x480.py |   14 +
 ...0-d8_4xb4-80k_pascal-context-59-480x480.py |   14 +
 ...v3_r50b-d8_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...bv3_r50b-d8_4xb2-80k_cityscapes-769x769.py |    2 +
 .../configs/deeplabv3/metafile.yaml           |  985 +++++++
 .../configs/deeplabv3plus/README.md           |  138 +
 ...-d16-mg124_4xb2-40k_cityscapes-512x1024.py |   11 +
 ...-d16-mg124_4xb2-80k_cityscapes-512x1024.py |   11 +
 ...us_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 +
 ...lus_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 +
 ...us_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...lus_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 +
 ...101-d8_4xb2-amp-80k_cityscapes-512x1024.py |    7 +
 ...v3plus_r101-d8_4xb4-160k_ade20k-512x512.py |    2 +
 ...3plus_r101-d8_4xb4-20k_voc12aug-512x512.py |    2 +
 ...r101-d8_4xb4-40k_pascal-context-480x480.py |    2 +
 ...1-d8_4xb4-40k_pascal-context-59-480x480.py |    2 +
 ...3plus_r101-d8_4xb4-40k_voc12aug-512x512.py |    2 +
 ...bv3plus_r101-d8_4xb4-80k_ade20k-512x512.py |    2 +
 ...bv3plus_r101-d8_4xb4-80k_loveda-512x512.py |    2 +
 ...r101-d8_4xb4-80k_pascal-context-480x480.py |    2 +
 ...1-d8_4xb4-80k_pascal-context-59-480x480.py |    2 +
 ...v3plus_r101-d8_4xb4-80k_potsdam-512x512.py |    2 +
 ...plus_r101-d8_4xb4-80k_vaihingen-512x512.py |    2 +
 ...s_r101b-d8_4xb2-80k_cityscapes-512x1024.py |    4 +
 ...us_r101b-d8_4xb2-80k_cityscapes-769x769.py |    4 +
 ...lus_r18-d8_4xb2-80k_cityscapes-512x1024.py |   11 +
 ...plus_r18-d8_4xb2-80k_cityscapes-769x769.py |   11 +
 ...labv3plus_r18-d8_4xb4-80k_isaid-896x896.py |   11 +
 ...abv3plus_r18-d8_4xb4-80k_loveda-512x512.py |   11 +
 ...bv3plus_r18-d8_4xb4-80k_potsdam-512x512.py |   11 +
 ...3plus_r18-d8_4xb4-80k_vaihingen-512x512.py |   11 +
 ...us_r18b-d8_4xb2-80k_cityscapes-512x1024.py |   11 +
 ...lus_r18b-d8_4xb2-80k_cityscapes-769x769.py |   11 +
 ...0-d8_4xb2-300k_mapillay_v1_65-1280x1280.py |   58 +
 ...lus_r50-d8_4xb2-40k_cityscapes-512x1024.py |    8 +
 ...plus_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 +
 ...lus_r50-d8_4xb2-80k_cityscapes-512x1024.py |    8 +
 ...plus_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 +
 ...bv3plus_r50-d8_4xb4-160k_ade20k-512x512.py |   10 +
 ...v3plus_r50-d8_4xb4-20k_voc12aug-512x512.py |   11 +
 ..._r50-d8_4xb4-40k_pascal-context-480x480.py |   14 +
 ...0-d8_4xb4-40k_pascal-context-59-480x480.py |   14 +
 ...v3plus_r50-d8_4xb4-40k_voc12aug-512x512.py |   11 +
 ...abv3plus_r50-d8_4xb4-80k_ade20k-512x512.py |   10 +
 ...labv3plus_r50-d8_4xb4-80k_isaid-896x896.py |   10 +
 ...abv3plus_r50-d8_4xb4-80k_loveda-512x512.py |   10 +
 ..._r50-d8_4xb4-80k_pascal-context-480x480.py |   14 +
 ...0-d8_4xb4-80k_pascal-context-59-480x480.py |   14 +
 ...bv3plus_r50-d8_4xb4-80k_potsdam-512x512.py |   11 +
 ...3plus_r50-d8_4xb4-80k_vaihingen-512x512.py |   11 +
 ...us_r50b-d8_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...lus_r50b-d8_4xb2-80k_cityscapes-769x769.py |    2 +
 .../configs/deeplabv3plus/metafile.yaml       | 1041 +++++++
 mmsegmentation/configs/dmnet/README.md        |   59 +
 ...et_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 +
 ...net_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 +
 ...et_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...net_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 +
 .../dmnet_r101-d8_4xb4-160k_ade20k-512x512.py |    2 +
 .../dmnet_r101-d8_4xb4-80k_ade20k-512x512.py  |    2 +
 ...net_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 +
 ...mnet_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 +
 ...net_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 +
 ...mnet_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 +
 .../dmnet_r50-d8_4xb4-160k_ade20k-512x512.py  |   10 +
 .../dmnet_r50-d8_4xb4-80k_ade20k-512x512.py   |   10 +
 mmsegmentation/configs/dmnet/metafile.yaml    |  296 ++
 mmsegmentation/configs/dnlnet/README.md       |   62 +
 ...nl_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 +
 ...dnl_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 +
 ...nl_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...dnl_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 +
 .../dnl_r101-d8_4xb4-160k_ade20k-512x512.py   |    2 +
 .../dnl_r101-d8_4xb4-80k_ade20k-512x512.py    |    2 +
 ...dnl_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 +
 .../dnl_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 +
 ...dnl_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 +
 .../dnl_r50-d8_4xb2-80k_cityscapes-769x769.py |   16 +
 .../dnl_r50-d8_4xb4-160k_ade20k-512x512.py    |   10 +
 .../dnl_r50-d8_4xb4-80k_ade20k-512x512.py     |   10 +
 mmsegmentation/configs/dnlnet/metafile.yaml   |  292 ++
 mmsegmentation/configs/dpt/README.md          |   67 +
 .../dpt_vit-b16_8xb2-160k_ade20k-512x512.py   |   39 +
 mmsegmentation/configs/dpt/metafile.yaml      |   37 +
 mmsegmentation/configs/dsdl/README.md         |  103 +
 mmsegmentation/configs/dsdl/cityscapes.py     |   70 +
 mmsegmentation/configs/dsdl/voc.py            |   65 +
 mmsegmentation/configs/emanet/README.md       |   46 +
 ...et_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...net_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 +
 ...net_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 +
 ...anet_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 +
 mmsegmentation/configs/emanet/metafile.yaml   |  109 +
 mmsegmentation/configs/encnet/README.md       |   59 +
 ...et_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 +
 ...net_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 +
 ...et_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...net_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 +
 ...encnet_r101-d8_4xb4-160k_ade20k-512x512.py |    2 +
 ...ncnet_r101-d8_4xb4-20k_voc12aug-512x512.py |    2 +
 ...ncnet_r101-d8_4xb4-40k_voc12aug-512x512.py |    2 +
 .../encnet_r101-d8_4xb4-80k_ade20k-512x512.py |    2 +
 ...net_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 +
 ...cnet_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 +
 ...net_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 +
 ...cnet_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 +
 .../encnet_r50-d8_4xb4-160k_ade20k-512x512.py |   10 +
 ...encnet_r50-d8_4xb4-20k_voc12aug-512x512.py |   11 +
 ...encnet_r50-d8_4xb4-40k_voc12aug-512x512.py |   11 +
 .../encnet_r50-d8_4xb4-80k_ade20k-512x512.py  |   10 +
 .../encnet_r50s-d8_4xb4-80k_ade20k-512x512.py |   11 +
 mmsegmentation/configs/encnet/metafile.yaml   |  296 ++
 mmsegmentation/configs/erfnet/README.md       |   54 +
 ...rfnet_fcn_4xb4-160k_cityscapes-512x1024.py |   10 +
 mmsegmentation/configs/erfnet/metafile.yaml   |   37 +
 mmsegmentation/configs/fastfcn/README.md      |   63 +
 ...2_jpu_aspp_4xb2-80k_cityscapes-512x1024.py |   20 +
 ...0-d32_jpu_aspp_4xb4-160k_ade20k-512x512.py |   20 +
 ...50-d32_jpu_aspp_4xb4-80k_ade20k-512x512.py |   20 +
 ...2_jpu_aspp_4xb4-80k_cityscapes-512x1024.py |    5 +
 ...32_jpu_enc_4xb2-80k_cityscapes-512x1024.py |   24 +
 ...50-d32_jpu_enc_4xb4-160k_ade20k-512x512.py |   24 +
 ...r50-d32_jpu_enc_4xb4-80k_ade20k-512x512.py |   24 +
 ...32_jpu_enc_4xb4-80k_cityscapes-512x1024.py |    5 +
 ...32_jpu_psp_4xb2-80k_cityscapes-512x1024.py |    8 +
 ...50-d32_jpu_psp_4xb4-160k_ade20k-512x512.py |   11 +
 ...r50-d32_jpu_psp_4xb4-80k_ade20k-512x512.py |   11 +
 ...32_jpu_psp_4xb4-80k_cityscapes-512x1024.py |   11 +
 mmsegmentation/configs/fastfcn/metafile.yaml  |  311 ++
 mmsegmentation/configs/fastscnn/README.md     |   42 +
 ...fast_scnn_8xb4-160k_cityscapes-512x1024.py |   15 +
 mmsegmentation/configs/fastscnn/metafile.yaml |   37 +
 mmsegmentation/configs/fcn/README.md          |  111 +
 ...6_r101-d16_4xb2-40k_cityscapes-512x1024.py |    2 +
 ...d6_r101-d16_4xb2-40k_cityscapes-769x769.py |    2 +
 ...6_r101-d16_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...d6_r101-d16_4xb2-80k_cityscapes-769x769.py |    2 +
 ..._r101b-d16_4xb2-80k_cityscapes-512x1024.py |    4 +
 ...6_r101b-d16_4xb2-80k_cityscapes-769x769.py |    4 +
 ...d6_r50-d16_4xb2-40k_cityscapes-512x1024.py |   11 +
 ...-d6_r50-d16_4xb2-40k_cityscapes-769x769.py |   13 +
 ...d6_r50-d16_4xb2-80k_cityscapes-512x1024.py |   11 +
 ...-d6_r50-d16_4xb2-80k_cityscapes-769x769.py |   13 +
 ...6_r50b-d16_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...d6_r50b-d16_4xb2-80k_cityscapes-769x769.py |    2 +
 ...cn_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 +
 ...fcn_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 +
 ...cn_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...fcn_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 +
 ...101-d8_4xb2-amp-80k_cityscapes-512x1024.py |    6 +
 .../fcn_r101-d8_4xb4-160k_ade20k-512x512.py   |    2 +
 .../fcn_r101-d8_4xb4-20k_voc12aug-512x512.py  |    2 +
 ...r101-d8_4xb4-40k_pascal-context-480x480.py |    2 +
 ...1-d8_4xb4-40k_pascal-context-59-480x480.py |    2 +
 .../fcn_r101-d8_4xb4-40k_voc12aug-512x512.py  |    2 +
 .../fcn_r101-d8_4xb4-80k_ade20k-512x512.py    |    2 +
 ...r101-d8_4xb4-80k_pascal-context-480x480.py |    2 +
 ...1-d8_4xb4-80k_pascal-context-59-480x480.py |    2 +
 ...n_r101b-d8_4xb2-80k_cityscapes-512x1024.py |    4 +
 ...cn_r101b-d8_4xb2-80k_cityscapes-769x769.py |    4 +
 ...fcn_r18-d8_4xb2-80k_cityscapes-512x1024.py |    9 +
 .../fcn_r18-d8_4xb2-80k_cityscapes-769x769.py |    9 +
 ...cn_r18b-d8_4xb2-80k_cityscapes-512x1024.py |    9 +
 ...fcn_r18b-d8_4xb2-80k_cityscapes-769x769.py |    9 +
 ...fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 +
 .../fcn_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 +
 ...fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 +
 .../fcn_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 +
 .../fcn_r50-d8_4xb4-160k_ade20k-512x512.py    |   10 +
 .../fcn_r50-d8_4xb4-20k_voc12aug-512x512.py   |   10 +
 ..._r50-d8_4xb4-40k_pascal-context-480x480.py |   13 +
 ...0-d8_4xb4-40k_pascal-context-59-480x480.py |   14 +
 .../fcn_r50-d8_4xb4-40k_voc12aug-512x512.py   |   10 +
 .../fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py |   10 +
 ..._r50-d8_4xb4-80k_pascal-context-480x480.py |   13 +
 ...0-d8_4xb4-80k_pascal-context-59-480x480.py |   14 +
 ...cn_r50b-d8_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...fcn_r50b-d8_4xb2-80k_cityscapes-769x769.py |    2 +
 mmsegmentation/configs/fcn/metafile.yaml      |  997 +++++++
 mmsegmentation/configs/gcnet/README.md        |   68 +
 ...et_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 +
 ...net_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 +
 ...et_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...net_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 +
 .../gcnet_r101-d8_4xb4-160k_ade20k-512x512.py |    2 +
 ...gcnet_r101-d8_4xb4-20k_voc12aug-512x512.py |    2 +
 ...gcnet_r101-d8_4xb4-40k_voc12aug-512x512.py |    2 +
 .../gcnet_r101-d8_4xb4-80k_ade20k-512x512.py  |    2 +
 ...net_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 +
 ...cnet_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 +
 ...net_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 +
 ...cnet_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 +
 .../gcnet_r50-d8_4xb4-160k_ade20k-512x512.py  |   10 +
 .../gcnet_r50-d8_4xb4-20k_voc12aug-512x512.py |   11 +
 .../gcnet_r50-d8_4xb4-40k_voc12aug-512x512.py |   11 +
 .../gcnet_r50-d8_4xb4-80k_ade20k-512x512.py   |   10 +
 mmsegmentation/configs/gcnet/metafile.yaml    |  391 +++
 mmsegmentation/configs/hrnet/README.md        |  122 +
 .../fcn_hr18_4xb2-160k_cityscapes-512x1024.py |    7 +
 .../fcn_hr18_4xb2-40k_cityscapes-512x1024.py  |    7 +
 .../fcn_hr18_4xb2-80k_cityscapes-512x1024.py  |    7 +
 .../fcn_hr18_4xb4-160k_ade20k-512x512.py      |    8 +
 .../fcn_hr18_4xb4-20k_voc12aug-512x512.py     |    8 +
 ...cn_hr18_4xb4-40k_pascal-context-480x480.py |   12 +
 ...hr18_4xb4-40k_pascal-context-59-480x480.py |   12 +
 .../fcn_hr18_4xb4-40k_voc12aug-512x512.py     |    8 +
 .../hrnet/fcn_hr18_4xb4-80k_ade20k-512x512.py |    8 +
 .../hrnet/fcn_hr18_4xb4-80k_isaid-896x896.py  |    8 +
 .../hrnet/fcn_hr18_4xb4-80k_loveda-512x512.py |    8 +
 ...cn_hr18_4xb4-80k_pascal-context-480x480.py |   12 +
 ...hr18_4xb4-80k_pascal-context-59-480x480.py |   12 +
 .../fcn_hr18_4xb4-80k_potsdam-512x512.py      |    8 +
 .../fcn_hr18_4xb4-80k_vaihingen-512x512.py    |    8 +
 ...fcn_hr18s_4xb2-160k_cityscapes-512x1024.py |    9 +
 .../fcn_hr18s_4xb2-40k_cityscapes-512x1024.py |    9 +
 .../fcn_hr18s_4xb2-80k_cityscapes-512x1024.py |    9 +
 .../fcn_hr18s_4xb4-160k_ade20k-512x512.py     |    9 +
 .../fcn_hr18s_4xb4-20k_voc12aug-512x512.py    |    9 +
 ...n_hr18s_4xb4-40k_pascal-context-480x480.py |    9 +
 ...r18s_4xb4-40k_pascal-context-59-480x480.py |    9 +
 .../fcn_hr18s_4xb4-40k_voc12aug-512x512.py    |    9 +
 .../fcn_hr18s_4xb4-80k_ade20k-512x512.py      |    9 +
 .../hrnet/fcn_hr18s_4xb4-80k_isaid-896x896.py |    9 +
 .../fcn_hr18s_4xb4-80k_loveda-512x512.py      |    9 +
 ...n_hr18s_4xb4-80k_pascal-context-480x480.py |    9 +
 ...r18s_4xb4-80k_pascal-context-59-480x480.py |    9 +
 .../fcn_hr18s_4xb4-80k_potsdam-512x512.py     |    9 +
 .../fcn_hr18s_4xb4-80k_vaihingen-512x512.py   |    9 +
 .../fcn_hr48_4xb2-160k_cityscapes-512x1024.py |   10 +
 .../fcn_hr48_4xb2-40k_cityscapes-512x1024.py  |   10 +
 .../fcn_hr48_4xb2-80k_cityscapes-512x1024.py  |   10 +
 .../fcn_hr48_4xb4-160k_ade20k-512x512.py      |   10 +
 .../fcn_hr48_4xb4-20k_voc12aug-512x512.py     |   10 +
 ...cn_hr48_4xb4-40k_pascal-context-480x480.py |   10 +
 ...hr48_4xb4-40k_pascal-context-59-480x480.py |   10 +
 .../fcn_hr48_4xb4-40k_voc12aug-512x512.py     |   10 +
 .../hrnet/fcn_hr48_4xb4-80k_ade20k-512x512.py |   10 +
 .../hrnet/fcn_hr48_4xb4-80k_isaid-896x896.py  |   10 +
 .../hrnet/fcn_hr48_4xb4-80k_loveda-512x512.py |   10 +
 ...cn_hr48_4xb4-80k_pascal-context-480x480.py |   10 +
 ...hr48_4xb4-80k_pascal-context-59-480x480.py |   10 +
 .../fcn_hr48_4xb4-80k_potsdam-512x512.py      |   10 +
 .../fcn_hr48_4xb4-80k_vaihingen-512x512.py    |   10 +
 mmsegmentation/configs/hrnet/metafile.yaml    |  874 ++++++
 mmsegmentation/configs/icnet/README.md        |   56 +
 ...8-in1k-pre_4xb2-160k_cityscapes-832x832.py |    7 +
 ...d8-in1k-pre_4xb2-80k_cityscapes-832x832.py |    7 +
 ...et_r101-d8_4xb2-160k_cityscapes-832x832.py |    2 +
 ...net_r101-d8_4xb2-80k_cityscapes-832x832.py |    2 +
 ...8-in1k-pre_4xb2-160k_cityscapes-832x832.py |    8 +
 ...d8-in1k-pre_4xb2-80k_cityscapes-832x832.py |    8 +
 ...net_r18-d8_4xb2-160k_cityscapes-832x832.py |    3 +
 ...cnet_r18-d8_4xb2-80k_cityscapes-832x832.py |    3 +
 ...8-in1k-pre_4xb2-160k_cityscapes-832x832.py |    6 +
 ...d8-in1k-pre_4xb2-80k_cityscapes-832x832.py |    6 +
 ...net_r50-d8_4xb2-160k_cityscapes-832x832.py |    8 +
 ...cnet_r50-d8_4xb2-80k_cityscapes-832x832.py |    8 +
 mmsegmentation/configs/icnet/metafile.yaml    |  298 ++
 mmsegmentation/configs/isanet/README.md       |   80 +
 ...et_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 +
 ...net_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 +
 ...et_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...net_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 +
 ...isanet_r101-d8_4xb4-160k_ade20k-512x512.py |    2 +
 ...sanet_r101-d8_4xb4-20k_voc12aug-512x512.py |    2 +
 ...sanet_r101-d8_4xb4-40k_voc12aug-512x512.py |    2 +
 .../isanet_r101-d8_4xb4-80k_ade20k-512x512.py |    2 +
 ...net_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 +
 ...anet_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 +
 ...net_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 +
 ...anet_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 +
 .../isanet_r50-d8_4xb4-160k_ade20k-512x512.py |   10 +
 ...isanet_r50-d8_4xb4-20k_voc12aug-512x512.py |   11 +
 ...isanet_r50-d8_4xb4-40k_voc12aug-512x512.py |   11 +
 .../isanet_r50-d8_4xb4-80k_ade20k-512x512.py  |   10 +
 mmsegmentation/configs/isanet/metafile.yaml   |  399 +++
 mmsegmentation/configs/knet/README.md         |   52 +
 ...deeplabv3_8xb2-adamw-80k_ade20k-512x512.py |  111 +
 ...50-d8_fcn_8xb2-adamw-80k_ade20k-512x512.py |  112 +
 ...d8_pspnet_8xb2-adamw-80k_ade20k-512x512.py |  110 +
 ...8_upernet_8xb2-adamw-80k_ade20k-512x512.py |  111 +
 ...l_upernet_8xb2-adamw-80k_ade20k-512x512.py |   21 +
 ...l_upernet_8xb2-adamw-80k_ade20k-640x640.py |   57 +
 ...t_upernet_8xb2-adamw-80k_ade20k-512x512.py |   63 +
 mmsegmentation/configs/knet/metafile.yaml     |  188 ++
 mmsegmentation/configs/mae/README.md          |   82 +
 ...upernet_8xb2-amp-160k_ade20k-512x512-ms.py |   16 +
 ...se_upernet_8xb2-amp-160k_ade20k-512x512.py |   54 +
 mmsegmentation/configs/mae/metafile.yaml      |   25 +
 mmsegmentation/configs/mask2former/README.md  |   74 +
 ...sk2former_r101_8xb2-160k_ade20k-512x512.py |    7 +
 ...ormer_r101_8xb2-90k_cityscapes-512x1024.py |    7 +
 ...ask2former_r50_8xb2-160k_ade20k-512x512.py |  200 ++
 ...former_r50_8xb2-90k_cityscapes-512x1024.py |  197 ++
 ...1k-384x384-pre_8xb2-160k_ade20k-640x640.py |  229 ++
 ...2k-384x384-pre_8xb2-160k_ade20k-640x640.py |    5 +
 ...84x384-pre_8xb2-90k_cityscapes-512x1024.py |   42 +
 ...2k-384x384-pre_8xb2-160k_ade20k-640x640.py |    9 +
 ...84x384-pre_8xb2-90k_cityscapes-512x1024.py |   42 +
 ...2former_swin-s_8xb2-160k_ade20k-512x512.py |   37 +
 ...mer_swin-s_8xb2-90k_cityscapes-512x1024.py |   37 +
 ...2former_swin-t_8xb2-160k_ade20k-512x512.py |   52 +
 ...mer_swin-t_8xb2-90k_cityscapes-512x1024.py |   52 +
 .../configs/mask2former/metafile.yaml         |  314 ++
 mmsegmentation/configs/maskformer/README.md   |   62 +
 ...ormer_r101-d32_8xb2-160k_ade20k-512x512.py |    7 +
 ...former_r50-d32_8xb2-160k_ade20k-512x512.py |  141 +
 ...swin-s_upernet_8xb2-160k_ade20k-512x512.py |   79 +
 ...swin-t_upernet_8xb2-160k_ade20k-512x512.py |   81 +
 .../configs/maskformer/metafile.yaml          |  111 +
 mmsegmentation/configs/mobilenet_v2/README.md |   56 +
 .../configs/mobilenet_v2/metafile.yaml        |  186 ++
 ..._deeplabv3_4xb2-80k_cityscapes-512x1024.py |   13 +
 ...2-d8_deeplabv3_4xb4-160k_ade20k-512x512.py |   13 +
 ...plabv3plus_4xb2-80k_cityscapes-512x1024.py |   15 +
 ..._deeplabv3plus_4xb4-160k_ade20k-512x512.py |   13 +
 ...-v2-d8_fcn_4xb2-80k_cityscapes-512x1024.py |   13 +
 ...enet-v2-d8_fcn_4xb4-160k_ade20k-512x512.py |   13 +
 ...-d8_pspnet_4xb2-80k_cityscapes-512x1024.py |   13 +
 ...t-v2-d8_pspnet_4xb4-160k_ade20k-512x512.py |   13 +
 mmsegmentation/configs/mobilenet_v3/README.md |   50 +
 .../configs/mobilenet_v3/metafile.yaml        |  109 +
 ...-s_lraspp_4xb4-320k_cityscapes-512x1024.py |   23 +
 ...-s_lraspp_4xb4-320k_cityscapes-512x1024.py |   22 +
 ...ch_lraspp_4xb4-320k_cityscapes-512x1024.py |   13 +
 ...d8_lraspp_4xb4-320k_cityscapes-512x1024.py |   16 +
 mmsegmentation/configs/nonlocal_net/README.md |   68 +
 .../configs/nonlocal_net/metafile.yaml        |  387 +++
 ...al_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 +
 ...cal_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 +
 ...al_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...cal_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 +
 ...nlocal_r101-d8_4xb4-160k_ade20k-512x512.py |    2 +
 ...local_r101-d8_4xb4-20k_voc12aug-512x512.py |    2 +
 ...local_r101-d8_4xb4-40k_voc12aug-512x512.py |    2 +
 ...onlocal_r101-d8_4xb4-80k_ade20k-512x512.py |    2 +
 ...cal_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 +
 ...ocal_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 +
 ...cal_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 +
 ...ocal_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 +
 ...onlocal_r50-d8_4xb4-160k_ade20k-512x512.py |   10 +
 ...nlocal_r50-d8_4xb4-20k_voc12aug-512x512.py |   11 +
 ...nlocal_r50-d8_4xb4-40k_voc12aug-512x512.py |   11 +
 ...nonlocal_r50-d8_4xb4-80k_ade20k-512x512.py |   10 +
 mmsegmentation/configs/ocrnet/README.md       |   89 +
 mmsegmentation/configs/ocrnet/metafile.yaml   |  577 ++++
 ...rnet_hr18_4xb2-160k_cityscapes-512x1024.py |    7 +
 ...crnet_hr18_4xb2-40k_cityscapes-512x1024.py |    7 +
 ...crnet_hr18_4xb2-80k_cityscapes-512x1024.py |    7 +
 .../ocrnet_hr18_4xb4-160k_ade20k-512x512.py   |   39 +
 .../ocrnet_hr18_4xb4-20k_voc12aug-512x512.py  |   40 +
 .../ocrnet_hr18_4xb4-40k_voc12aug-512x512.py  |   40 +
 .../ocrnet_hr18_4xb4-80k_ade20k-512x512.py    |   39 +
 ...net_hr18s_4xb2-160k_cityscapes-512x1024.py |    9 +
 ...rnet_hr18s_4xb2-40k_cityscapes-512x1024.py |    9 +
 ...rnet_hr18s_4xb2-80k_cityscapes-512x1024.py |    9 +
 .../ocrnet_hr18s_4xb4-160k_ade20k-512x512.py  |    9 +
 .../ocrnet_hr18s_4xb4-20k_voc12aug-512x512.py |    9 +
 .../ocrnet_hr18s_4xb4-40k_voc12aug-512x512.py |    9 +
 .../ocrnet_hr18s_4xb4-80k_ade20k-512x512.py   |    9 +
 ...rnet_hr48_4xb2-160k_cityscapes-512x1024.py |   39 +
 ...crnet_hr48_4xb2-40k_cityscapes-512x1024.py |   39 +
 ...crnet_hr48_4xb2-80k_cityscapes-512x1024.py |   39 +
 .../ocrnet_hr48_4xb4-160k_ade20k-512x512.py   |   39 +
 .../ocrnet_hr48_4xb4-20k_voc12aug-512x512.py  |   39 +
 .../ocrnet_hr48_4xb4-40k_voc12aug-512x512.py  |   39 +
 .../ocrnet_hr48_4xb4-80k_ade20k-512x512.py    |   39 +
 ...et_r101-d8_4xb2-40k_cityscapes-512x1024.py |   10 +
 ...et_r101-d8_8xb2-40k_cityscapes-512x1024.py |   21 +
 ...et_r101-d8_8xb2-80k_cityscapes-512x1024.py |   21 +
 mmsegmentation/configs/pidnet/README.md       |   50 +
 mmsegmentation/configs/pidnet/metafile.yaml   |   85 +
 ...pidnet-l_2xb6-120k_1024x1024-cityscapes.py |   10 +
 ...pidnet-m_2xb6-120k_1024x1024-cityscapes.py |    5 +
 ...pidnet-s_2xb6-120k_1024x1024-cityscapes.py |  113 +
 mmsegmentation/configs/point_rend/README.md   |   51 +
 .../configs/point_rend/metafile.yaml          |  110 +
 ...trend_r101_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...pointrend_r101_4xb4-160k_ade20k-512x512.py |    2 +
 ...ntrend_r50_4xb2-80k_cityscapes-512x1024.py |   18 +
 .../pointrend_r50_4xb4-160k_ade20k-512x512.py |   46 +
 mmsegmentation/configs/poolformer/README.md   |   65 +
 ..._poolformer_m36_8xb4-40k_ade20k-512x512.py |   11 +
 ..._poolformer_m48_8xb4-40k_ade20k-512x512.py |   11 +
 ..._poolformer_s12_8xb4-40k_ade20k-512x512.py |   91 +
 ..._poolformer_s24_8xb4-40k_ade20k-512x512.py |    9 +
 ...n_poolformer_s36_8x4_512x512_40k_ade20k.py |   10 +
 .../configs/poolformer/metafile.yaml          |  116 +
 mmsegmentation/configs/psanet/README.md       |   68 +
 mmsegmentation/configs/psanet/metafile.yaml   |  391 +++
 ...et_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 +
 ...net_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 +
 ...et_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...net_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 +
 ...psanet_r101-d8_4xb4-160k_ade20k-512x512.py |    2 +
 ...sanet_r101-d8_4xb4-20k_voc12aug-512x512.py |    2 +
 ...sanet_r101-d8_4xb4-40k_voc12aug-512x512.py |    2 +
 .../psanet_r101-d8_4xb4-80k_ade20k-512x512.py |    2 +
 ...net_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 +
 ...anet_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 +
 ...net_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 +
 ...anet_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 +
 .../psanet_r50-d8_4xb4-160k_ade20k-512x512.py |   10 +
 ...psanet_r50-d8_4xb4-20k_voc12aug-512x512.py |   11 +
 ...psanet_r50-d8_4xb4-40k_voc12aug-512x512.py |   11 +
 .../psanet_r50-d8_4xb4-80k_ade20k-512x512.py  |   10 +
 mmsegmentation/configs/pspnet/README.md       |  182 ++
 mmsegmentation/configs/pspnet/metafile.yaml   | 1303 +++++++++
 ...et_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 +
 ...tyscapes-512x1024_dark-zurich-1920x1080.py |    2 +
 ...scapes-512x1024_night-driving-1920x1080.py |    2 +
 ...net_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 +
 ...et_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...net_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 +
 ...101-d8_4xb2-amp-80k_cityscapes-512x1024.py |    6 +
 ...pspnet_r101-d8_4xb4-160k_ade20k-512x512.py |    2 +
 ...101-d8_4xb4-160k_coco-stuff164k-512x512.py |    2 +
 ..._r101-d8_4xb4-20k_coco-stuff10k-512x512.py |    2 +
 ...spnet_r101-d8_4xb4-20k_voc12aug-512x512.py |    2 +
 ...101-d8_4xb4-320k_coco-stuff164k-512x512.py |    2 +
 ..._r101-d8_4xb4-40k_coco-stuff10k-512x512.py |    2 +
 ...r101-d8_4xb4-40k_pascal-context-480x480.py |    2 +
 ...1-d8_4xb4-40k_pascal-context-59-480x480.py |    2 +
 ...spnet_r101-d8_4xb4-40k_voc12aug-512x512.py |    2 +
 .../pspnet_r101-d8_4xb4-80k_ade20k-512x512.py |    2 +
 ...r101-d8_4xb4-80k_coco-stuff164k-512x512.py |    2 +
 .../pspnet_r101-d8_4xb4-80k_loveda-512x512.py |    2 +
 ...r101-d8_4xb4-80k_pascal-context-480x480.py |    2 +
 ...1-d8_4xb4-80k_pascal-context-59-480x480.py |    2 +
 ...pspnet_r101-d8_4xb4-80k_potsdam-512x512.py |    2 +
 ...pnet_r101-d8_4xb4-80k_vaihingen-512x512.py |    2 +
 ...t_r101b-d8_4xb2-80k_cityscapes-512x1024.py |    4 +
 ...tyscapes-512x1024_dark-zurich-1920x1080.py |    4 +
 ...scapes-512x1024_night-driving-1920x1080.py |    4 +
 ...et_r101b-d8_4xb2-80k_cityscapes-769x769.py |    4 +
 ...net_r18-d8_4xb2-80k_cityscapes-512x1024.py |    9 +
 ...pnet_r18-d8_4xb2-80k_cityscapes-769x769.py |    9 +
 .../pspnet_r18-d8_4xb4-80k_isaid-896x896.py   |    9 +
 .../pspnet_r18-d8_4xb4-80k_loveda-512x512.py  |    9 +
 .../pspnet_r18-d8_4xb4-80k_potsdam-512x512.py |    9 +
 ...spnet_r18-d8_4xb4-80k_vaihingen-512x512.py |    9 +
 ...et_r18b-d8_4xb2-80k_cityscapes-512x1024.py |    9 +
 ...net_r18b-d8_4xb2-80k_cityscapes-769x769.py |    9 +
 ...et_r50-d32_4xb2-80k_cityscapes-512x1024.py |    9 +
 ..._rsb_4xb2-adamw-80k_cityscapes-512x1024.py |   35 +
 ...-rsb_4xb2-adamw-80k_cityscapes-512x1024.py |   33 +
 ...net_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 +
 ...tyscapes-512x1024_dark-zurich-1920x1080.py |   24 +
 ...scapes-512x1024_night-driving-1920x1080.py |   25 +
 ...pnet_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 +
 ...net_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 +
 ...tyscapes-512x1024_dark-zurich-1920x1080.py |   25 +
 ...scapes-512x1024_night-driving-1920x1080.py |   25 +
 ...pnet_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 +
 .../pspnet_r50-d8_4xb4-160k_ade20k-512x512.py |   10 +
 ...r50-d8_4xb4-160k_coco-stuff164k-512x512.py |   11 +
 ...t_r50-d8_4xb4-20k_coco-stuff10k-512x512.py |   10 +
 ...pspnet_r50-d8_4xb4-20k_voc12aug-512x512.py |   11 +
 ...r50-d8_4xb4-320k_coco-stuff164k-512x512.py |   11 +
 ...t_r50-d8_4xb4-40k_coco-stuff10k-512x512.py |   10 +
 ..._r50-d8_4xb4-40k_pascal-context-480x480.py |   14 +
 ...0-d8_4xb4-40k_pascal-context-59-480x480.py |   14 +
 ...pspnet_r50-d8_4xb4-40k_voc12aug-512x512.py |   11 +
 .../pspnet_r50-d8_4xb4-80k_ade20k-512x512.py  |   10 +
 ..._r50-d8_4xb4-80k_coco-stuff164k-512x512.py |   11 +
 .../pspnet_r50-d8_4xb4-80k_isaid-896x896.py   |   10 +
 .../pspnet_r50-d8_4xb4-80k_loveda-512x512.py  |   10 +
 ..._r50-d8_4xb4-80k_pascal-context-480x480.py |   14 +
 ...0-d8_4xb4-80k_pascal-context-59-480x480.py |   14 +
 .../pspnet_r50-d8_4xb4-80k_potsdam-512x512.py |   10 +
 ...spnet_r50-d8_4xb4-80k_vaihingen-512x512.py |   10 +
 ...t_r50b-d32_4xb2-80k_cityscapes-512x1024.py |   10 +
 ...et_r50b-d8_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...net_r50b-d8_4xb2-80k_cityscapes-769x769.py |    2 +
 mmsegmentation/configs/resnest/README.md      |   54 +
 mmsegmentation/configs/resnest/metafile.yaml  |  193 ++
 ..._deeplabv3_4xb2-80k_cityscapes-512x1024.py |    9 +
 ...1-d8_deeplabv3_4xb4-160k_ade20k-512x512.py |    9 +
 ...plabv3plus_4xb2-80k_cityscapes-512x1024.py |    9 +
 ..._deeplabv3plus_4xb4-160k_ade20k-512x512.py |    9 +
 ...101-d8_fcn_4xb2-80k_cityscapes-512x1024.py |    9 +
 ...st_s101-d8_fcn_4xb4-160k_ade20k-512x512.py |    9 +
 ...1-d8_pspnet_4xb2-80k_cityscapes512x1024.py |    9 +
 ...s101-d8_pspnet_4xb4-160k_ade20k-512x512.py |    9 +
 mmsegmentation/configs/san/README.md          |   47 +
 mmsegmentation/configs/san/metafile.yaml      |   61 +
 .../san/san-vit-b16_coco-stuff164k-640x640.py |   82 +
 .../san/san-vit-b16_pascal_context-640x640.py |   56 +
 .../san/san-vit-b16_voc12aug-640x640.py       |   65 +
 .../san/san-vit-l14_coco-stuff164k-640x640.py |   36 +
 .../san/san-vit-l14_pascal_context-640x640.py |   32 +
 .../san/san-vit-l14_voc12aug-640x640.py       |   32 +
 mmsegmentation/configs/segformer/README.md    |  101 +
 .../configs/segformer/metafile.yaml           |  340 +++
 ...r_mit-b0_8xb1-160k_cityscapes-1024x1024.py |   41 +
 ...gformer_mit-b0_8xb2-160k_ade20k-512x512.py |   39 +
 ...r_mit-b1_8xb1-160k_cityscapes-1024x1024.py |    9 +
 ...gformer_mit-b1_8xb2-160k_ade20k-512x512.py |   12 +
 ...r_mit-b2_8xb1-160k_cityscapes-1024x1024.py |   10 +
 ...gformer_mit-b2_8xb2-160k_ade20k-512x512.py |   12 +
 ...r_mit-b3_8xb1-160k_cityscapes-1024x1024.py |   10 +
 ...gformer_mit-b3_8xb2-160k_ade20k-512x512.py |   12 +
 ...r_mit-b4_8xb1-160k_cityscapes-1024x1024.py |   10 +
 ...gformer_mit-b4_8xb2-160k_ade20k-512x512.py |   12 +
 ...r_mit-b5_8xb1-160k_cityscapes-1024x1024.py |   10 +
 ...gformer_mit-b5_8xb2-160k_ade20k-512x512.py |   12 +
 ...gformer_mit-b5_8xb2-160k_ade20k-640x640.py |   41 +
 mmsegmentation/configs/segmenter/README.md    |   76 +
 .../configs/segmenter/metafile.yaml           |  138 +
 ...ter_vit-b_mask_8xb1-160k_ade20k-512x512.py |   14 +
 ...ter_vit-l_mask_8xb1-160k_ade20k-512x512.py |   32 +
 ...nter_vit-s_fcn_8xb1-160k_ade20k-512x512.py |   14 +
 ...ter_vit-s_mask_8xb1-160k_ade20k-512x512.py |   36 +
 ...ter_vit-t_mask_8xb1-160k_ade20k-512x512.py |   26 +
 mmsegmentation/configs/segnext/README.md      |   63 +
 mmsegmentation/configs/segnext/metafile.yaml  |  109 +
 ...mscan-b_1xb16-adamw-160k_ade20k-512x512.py |   28 +
 ...mscan-l_1xb16-adamw-160k_ade20k-512x512.py |   27 +
 ...mscan-s_1xb16-adamw-160k_ade20k-512x512.py |   27 +
 ...mscan-t_1xb16-adamw-160k_ade20k-512x512.py |   84 +
 mmsegmentation/configs/sem_fpn/README.md      |   51 +
 .../fpn_r101_4xb2-80k_cityscapes-512x1024.py  |    2 +
 .../fpn_r101_4xb4-160k_ade20k-512x512.py      |    5 +
 .../fpn_r50_4xb2-80k_cityscapes-512x1024.py   |    7 +
 .../fpn_r50_4xb4-160k_ade20k-512x512.py       |    8 +
 mmsegmentation/configs/sem_fpn/metafile.yaml  |  110 +
 mmsegmentation/configs/setr/README.md         |   74 +
 mmsegmentation/configs/setr/metafile.yaml     |  197 ++
 ...setr_vit-l-mla_8xb1-160k_ade20k-512x512.py |   90 +
 ...r_vit-l_mla_8xb1-80k_cityscapes-768x768.py |   23 +
 ...setr_vit-l_mla_8xb2-160k_ade20k-512x512.py |    6 +
 ...vit-l_naive_8xb1-80k_cityscapes-768x768.py |   24 +
 ...tr_vit-l_naive_8xb2-160k_ade20k-512x512.py |   72 +
 ...r_vit-l_pup_8xb1-80k_cityscapes-768x768.py |   70 +
 ...setr_vit-l_pup_8xb2-160k_ade20k-512x512.py |   72 +
 mmsegmentation/configs/stdc/README.md         |   73 +
 mmsegmentation/configs/stdc/metafile.yaml     |  107 +
 .../stdc1_4xb12-80k_cityscapes-512x1024.py    |   21 +
 ..._in1k-pre_4xb12-80k_cityscapes-512x1024.py |    6 +
 .../stdc2_4xb12-80k_cityscapes-512x1024.py    |    2 +
 ..._in1k-pre_4xb12-80k_cityscapes-512x1024.py |    6 +
 mmsegmentation/configs/swin/README.md         |   76 +
 mmsegmentation/configs/swin/metafile.yaml     |  143 +
 ...84-pre_upernet_8xb2-160k_ade20k-512x512.py |   14 +
 ...84-pre_upernet_8xb2-160k_ade20k-512x512.py |    7 +
 ...1k-pre_upernet_8xb2-160k_ade20k-512x512.py |   12 +
 ...2k-pre_upernet_8xb2-160k_ade20k-512x512.py |    7 +
 ...84-pre_upernet_8xb2-160k_ade20k-512x512.py |   10 +
 ...2k-pre_upernet_8xb2-160k_ade20k-512x512.py |   15 +
 ...1k-pre_upernet_8xb2-160k_ade20k-512x512.py |   10 +
 ...1k-pre_upernet_8xb2-160k_ade20k-512x512.py |   52 +
 ...-window7_upernet_1xb8-20k_levir-256x256.py |   57 +
 mmsegmentation/configs/twins/README.md        |   76 +
 mmsegmentation/configs/twins/metafile.yaml    |  289 ++
 ...t-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py |    8 +
 ...pvt-b_uperhead_8xb2-160k_ade20k-512x512.py |   13 +
 ...t-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py |    8 +
 ...pvt-l_uperhead_8xb2-160k_ade20k-512x512.py |   13 +
 ...t-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py |   12 +
 ...pvt-s_uperhead_8xb4-160k_ade20k-512x512.py |   31 +
 ...t-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py |   12 +
 ...svt-b_uperhead_8xb2-160k_ade20k-512x512.py |   12 +
 ...t-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py |   13 +
 ...svt-l_uperhead_8xb2-160k_ade20k-512x512.py |   13 +
 ...t-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py |   28 +
 ...svt-s_uperhead_8xb2-160k_ade20k-512x512.py |   49 +
 mmsegmentation/configs/unet/README.md         |   92 +
 mmsegmentation/configs/unet/metafile.yaml     |  642 +++++
 ...t-s5-d16_deeplabv3_4xb4-40k_drive-64x64.py |    9 +
 ...t-s5-d16_deeplabv3_4xb4-40k_hrf-256x256.py |    9 +
 ...s5-d16_deeplabv3_4xb4-40k_stare-128x128.py |    9 +
 ...4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py |    6 +
 ...v3_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py |    6 +
 ...v3_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py |    6 +
 ..._4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py |    6 +
 ...5-d16_fcn_4xb4-160k_cityscapes-512x1024.py |   16 +
 ...t-s5-d16_fcn_4xb4-160k_hsidrive-192x384.py |   36 +
 ...t-s5-d16_fcn_4xb4-40k_chase-db1-128x128.py |    9 +
 .../unet-s5-d16_fcn_4xb4-40k_drive-64x64.py   |    9 +
 .../unet-s5-d16_fcn_4xb4-40k_hrf-256x256.py   |    9 +
 .../unet-s5-d16_fcn_4xb4-40k_stare-128x128.py |    9 +
 ...4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py |    6 +
 ...cn_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py |    6 +
 ...cn_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py |    6 +
 ..._4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py |    6 +
 ...5-d16_pspnet_4xb4-40k_chase-db1-128x128.py |   10 +
 ...unet-s5-d16_pspnet_4xb4-40k_drive-64x64.py |    9 +
 ...unet-s5-d16_pspnet_4xb4-40k_hrf-256x256.py |    9 +
 ...et-s5-d16_pspnet_4xb4-40k_stare-128x128.py |    9 +
 ...4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py |    6 +
 ...et_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py |    6 +
 ...et_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py |    6 +
 ..._4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py |    6 +
 ...16_deeplabv3_4xb4-40k_chase-db1-128x128.py |   10 +
 mmsegmentation/configs/upernet/README.md      |   68 +
 mmsegmentation/configs/upernet/metafile.yaml  |  391 +++
 ...ernet_r101_4xb2-40k_cityscapes-512x1024.py |    2 +
 ...pernet_r101_4xb2-40k_cityscapes-769x769.py |    2 +
 ...ernet_r101_4xb2-80k_cityscapes-512x1024.py |    2 +
 ...pernet_r101_4xb2-80k_cityscapes-769x769.py |    2 +
 .../upernet_r101_4xb4-160k_ade20k-512x512.py  |    2 +
 .../upernet_r101_4xb4-20k_voc12aug-512x512.py |    2 +
 .../upernet_r101_4xb4-40k_voc12aug-512x512.py |    2 +
 .../upernet_r101_4xb4-80k_ade20k-512x512.py   |    2 +
 ...pernet_r18_4xb2-40k_cityscapes-512x1024.py |    6 +
 ...pernet_r18_4xb2-80k_cityscapes-512x1024.py |    6 +
 .../upernet_r18_4xb4-160k_ade20k-512x512.py   |    9 +
 .../upernet_r18_4xb4-20k_voc12aug-512x512.py  |   10 +
 .../upernet_r18_4xb4-40k_voc12aug-512x512.py  |   10 +
 .../upernet_r18_4xb4-80k_ade20k-512x512.py    |    9 +
 ...pernet_r50_4xb2-40k_cityscapes-512x1024.py |    7 +
 ...upernet_r50_4xb2-40k_cityscapes-769x769.py |   12 +
 ...pernet_r50_4xb2-80k_cityscapes-512x1024.py |    7 +
 ...upernet_r50_4xb2-80k_cityscapes-769x769.py |   12 +
 .../upernet_r50_4xb4-160k_ade20k-512x512.py   |   10 +
 .../upernet_r50_4xb4-20k_voc12aug-512x512.py  |   11 +
 .../upernet_r50_4xb4-40k_voc12aug-512x512.py  |   11 +
 .../upernet_r50_4xb4-80k_ade20k-512x512.py    |   10 +
 mmsegmentation/configs/vit/README.md          |   70 +
 mmsegmentation/configs/vit/metafile.yaml      |  265 ++
 ...ln_mln_upernet_8xb2-160k_ade20k-512x512.py |    5 +
 ...16_mln_upernet_8xb2-160k_ade20k-512x512.py |    6 +
 ...it-b16_upernet_8xb2-160k_ade20k-512x512.py |    6 +
 ...eit-b16_upernet_8xb2-80k_ade20k-512x512.py |    6 +
 ...ln_mln_upernet_8xb2-160k_ade20k-512x512.py |    9 +
 ...16_mln_upernet_8xb2-160k_ade20k-512x512.py |    8 +
 ...it-s16_upernet_8xb2-160k_ade20k-512x512.py |    8 +
 ...eit-s16_upernet_8xb2-80k_ade20k-512x512.py |    8 +
 ...ln_mln_upernet_8xb2-160k_ade20k-512x512.py |   45 +
 ...16_mln_upernet_8xb2-160k_ade20k-512x512.py |   44 +
 ...b16_mln_upernet_8xb2-80k_ade20k-512x512.py |   44 +
 mmsegmentation/configs/vpd/README.md          |   50 +
 mmsegmentation/configs/vpd/metafile.yaml      |   56 +
 .../vpd/vpd_sd_4xb8-25k_nyu-480x480.py        |   38 +
 .../vpd/vpd_sd_4xb8-25k_nyu-512x512.py        |   37 +
 mmsegmentation/dataset-index.yml              |   80 +
 .../demo/MMSegmentation_Tutorial.ipynb        |  555 ++++
 mmsegmentation/demo/image_demo.py             |   51 +
 .../demo/image_demo_with_inferencer.py        |   54 +
 mmsegmentation/demo/inference_demo.ipynb      |  120 +
 mmsegmentation/demo/rs_image_inference.py     |   50 +
 mmsegmentation/demo/video_demo.py             |  112 +
 mmsegmentation/docker/Dockerfile              |   35 +
 mmsegmentation/docker/serve/Dockerfile        |   51 +
 mmsegmentation/docker/serve/config.properties |    5 +
 mmsegmentation/docker/serve/entrypoint.sh     |   12 +
 mmsegmentation/docs/en/.readthedocs.yaml      |   17 +
 mmsegmentation/docs/en/Makefile               |   20 +
 .../docs/en/_static/css/readthedocs.css       |    6 +
 .../docs/en/advanced_guides/add_datasets.md   |  199 ++
 .../docs/en/advanced_guides/add_metrics.md    |   81 +
 .../docs/en/advanced_guides/add_models.md     |  260 ++
 .../docs/en/advanced_guides/add_transforms.md |   52 +
 .../en/advanced_guides/customize_runtime.md   |  168 ++
 .../docs/en/advanced_guides/data_flow.md      |   87 +
 .../docs/en/advanced_guides/datasets.md       |  386 +++
 .../docs/en/advanced_guides/engine.md         |  279 ++
 .../docs/en/advanced_guides/evaluation.md     |  155 +
 .../docs/en/advanced_guides/index.rst         |   26 +
 .../docs/en/advanced_guides/models.md         |  164 ++
 .../docs/en/advanced_guides/structures.md     |  104 +
 .../en/advanced_guides/training_tricks.md     |   75 +
 .../docs/en/advanced_guides/transforms.md     |  119 +
 mmsegmentation/docs/en/api.rst                |   95 +
 mmsegmentation/docs/en/conf.py                |  133 +
 mmsegmentation/docs/en/device/npu.md          |   39 +
 mmsegmentation/docs/en/get_started.md         |  211 ++
 mmsegmentation/docs/en/index.rst              |   63 +
 mmsegmentation/docs/en/make.bat               |   35 +
 mmsegmentation/docs/en/migration/index.rst    |    8 +
 mmsegmentation/docs/en/migration/interface.md |  525 ++++
 mmsegmentation/docs/en/migration/package.md   |  113 +
 mmsegmentation/docs/en/model_zoo.md           |  186 ++
 mmsegmentation/docs/en/modelzoo_statistics.md |  102 +
 mmsegmentation/docs/en/notes/changelog.md     |  506 ++++
 .../docs/en/notes/changelog_v0.x.md           |  720 +++++
 mmsegmentation/docs/en/notes/faq.md           |  132 +
 mmsegmentation/docs/en/overview.md            |   85 +
 mmsegmentation/docs/en/stat.py                |   67 +
 mmsegmentation/docs/en/switch_language.md     |    3 +
 .../docs/en/user_guides/1_config.md           |  588 ++++
 .../docs/en/user_guides/2_dataset_prepare.md  |  806 ++++++
 .../docs/en/user_guides/3_inference.md        |  244 ++
 .../docs/en/user_guides/4_train_test.md       |  315 ++
 .../docs/en/user_guides/5_deployment.md       |  255 ++
 mmsegmentation/docs/en/user_guides/index.rst  |   21 +
 .../docs/en/user_guides/useful_tools.md       |  245 ++
 .../docs/en/user_guides/visualization.md      |  174 ++
 .../user_guides/visualization_feature_map.md  |  201 ++
 mmsegmentation/docs/zh_cn/.readthedocs.yaml   |   17 +
 mmsegmentation/docs/zh_cn/Makefile            |   20 +
 .../docs/zh_cn/_static/css/readthedocs.css    |    6 +
 .../zh_cn/advanced_guides/add_datasets.md     |  199 ++
 .../docs/zh_cn/advanced_guides/add_metrics.md |   81 +
 .../docs/zh_cn/advanced_guides/add_models.md  |  260 ++
 .../zh_cn/advanced_guides/add_transforms.md   |   51 +
 .../advanced_guides/contribute_dataset.md     |  461 +++
 .../advanced_guides/customize_runtime.md      |  162 ++
 .../docs/zh_cn/advanced_guides/data_flow.md   |   90 +
 .../docs/zh_cn/advanced_guides/datasets.md    |  363 +++
 .../docs/zh_cn/advanced_guides/engine.md      |  281 ++
 .../docs/zh_cn/advanced_guides/evaluation.md  |  158 +
 .../docs/zh_cn/advanced_guides/index.rst      |   26 +
 .../docs/zh_cn/advanced_guides/models.md      |  177 ++
 .../docs/zh_cn/advanced_guides/structures.md  |  102 +
 .../zh_cn/advanced_guides/training_tricks.md  |   74 +
 .../docs/zh_cn/advanced_guides/transforms.md  |  119 +
 mmsegmentation/docs/zh_cn/api.rst             |   95 +
 mmsegmentation/docs/zh_cn/conf.py             |  133 +
 mmsegmentation/docs/zh_cn/device/npu.md       |   39 +
 mmsegmentation/docs/zh_cn/get_started.md      |  209 ++
 mmsegmentation/docs/zh_cn/index.rst           |   57 +
 mmsegmentation/docs/zh_cn/make.bat            |   35 +
 mmsegmentation/docs/zh_cn/migration/index.rst |    8 +
 .../docs/zh_cn/migration/interface.md         |  523 ++++
 .../docs/zh_cn/migration/package.md           |  113 +
 mmsegmentation/docs/zh_cn/model_zoo.md        |  152 +
 .../docs/zh_cn/modelzoo_statistics.md         |  102 +
 mmsegmentation/docs/zh_cn/notes/faq.md        |  125 +
 mmsegmentation/docs/zh_cn/overview.md         |   75 +
 mmsegmentation/docs/zh_cn/stat.py             |   67 +
 mmsegmentation/docs/zh_cn/switch_language.md  |    3 +
 .../docs/zh_cn/user_guides/1_config.md        |  577 ++++
 .../zh_cn/user_guides/2_dataset_prepare.md    |  802 ++++++
 .../docs/zh_cn/user_guides/3_inference.md     |  244 ++
 .../docs/zh_cn/user_guides/4_train_test.md    |  317 ++
 .../docs/zh_cn/user_guides/5_deployment.md    |  243 ++
 .../docs/zh_cn/user_guides/deploy_jetson.md   |  372 +++
 .../docs/zh_cn/user_guides/index.rst          |   21 +
 .../docs/zh_cn/user_guides/useful_tools.md    |  368 +++
 .../docs/zh_cn/user_guides/visualization.md   |  173 ++
 .../user_guides/visualization_feature_map.md  |  201 ++
 mmsegmentation/mmseg/__init__.py              |   74 +
 mmsegmentation/mmseg/apis/__init__.py         |    9 +
 mmsegmentation/mmseg/apis/inference.py        |  189 ++
 mmsegmentation/mmseg/apis/mmseg_inferencer.py |  382 +++
 .../mmseg/apis/remote_sense_inferencer.py     |  279 ++
 mmsegmentation/mmseg/apis/utils.py            |   41 +
 .../mmseg/configs/_base_/datasets/loveda.py   |   79 +
 .../mmseg/configs/_base_/datasets/potsdam.py  |   81 +
 .../mmseg/configs/_base_/default_runtime.py   |   22 +
 .../configs/_base_/schedules/schedule_160k.py |   43 +
 .../configs/_base_/schedules/schedule_20k.py  |   36 +
 .../configs/_base_/schedules/schedule_240k.py |   34 +
 .../configs/_base_/schedules/schedule_25k.py  |   43 +
 .../configs/_base_/schedules/schedule_320k.py |   36 +
 .../configs/_base_/schedules/schedule_40k.py  |   34 +
 .../configs/_base_/schedules/schedule_80k.py  |   42 +
 mmsegmentation/mmseg/datasets/__init__.py     |   69 +
 mmsegmentation/mmseg/datasets/ade.py          |   92 +
 .../mmseg/datasets/basesegdataset.py          |  552 ++++
 mmsegmentation/mmseg/datasets/bdd100k.py      |   30 +
 mmsegmentation/mmseg/datasets/chase_db1.py    |   32 +
 mmsegmentation/mmseg/datasets/cityscapes.py   |   30 +
 mmsegmentation/mmseg/datasets/coco_stuff.py   |   99 +
 mmsegmentation/mmseg/datasets/dark_zurich.py  |   15 +
 .../mmseg/datasets/dataset_wrappers.py        |  136 +
 mmsegmentation/mmseg/datasets/decathlon.py    |   96 +
 mmsegmentation/mmseg/datasets/drive.py        |   32 +
 mmsegmentation/mmseg/datasets/dsdl.py         |  116 +
 mmsegmentation/mmseg/datasets/hrf.py          |   32 +
 mmsegmentation/mmseg/datasets/hsi_drive.py    |   42 +
 mmsegmentation/mmseg/datasets/isaid.py        |   39 +
 mmsegmentation/mmseg/datasets/isprs.py        |   29 +
 mmsegmentation/mmseg/datasets/levir.py        |   31 +
 mmsegmentation/mmseg/datasets/lip.py          |   47 +
 mmsegmentation/mmseg/datasets/loveda.py       |   29 +
 mmsegmentation/mmseg/datasets/mapillary.py    |  176 ++
 .../mmseg/datasets/night_driving.py           |   15 +
 mmsegmentation/mmseg/datasets/nyu.py          |  123 +
 .../mmseg/datasets/pascal_context.py          |  116 +
 mmsegmentation/mmseg/datasets/potsdam.py      |   29 +
 mmsegmentation/mmseg/datasets/refuge.py       |   28 +
 mmsegmentation/mmseg/datasets/stare.py        |   32 +
 mmsegmentation/mmseg/datasets/synapse.py      |   28 +
 .../mmseg/datasets/transforms/__init__.py     |   30 +
 .../mmseg/datasets/transforms/formatting.py   |  112 +
 .../mmseg/datasets/transforms/loading.py      |  771 +++++
 .../mmseg/datasets/transforms/transforms.py   | 2537 +++++++++++++++++
 mmsegmentation/mmseg/datasets/voc.py          |   40 +
 mmsegmentation/mmseg/datasets/xray.py         |   29 +
 mmsegmentation/mmseg/datasets/xray2.py        |  141 +
 mmsegmentation/mmseg/engine/__init__.py       |   12 +
 mmsegmentation/mmseg/engine/hooks/__init__.py |    4 +
 .../mmseg/engine/hooks/visualization_hook.py  |  129 +
 .../mmseg/engine/optimizers/__init__.py       |    9 +
 .../optimizers/force_default_constructor.py   |  255 ++
 .../layer_decay_optimizer_constructor.py      |  207 ++
 .../mmseg/engine/schedulers/__init__.py       |    4 +
 .../engine/schedulers/poly_ratio_scheduler.py |   62 +
 mmsegmentation/mmseg/evaluation/__init__.py   |    4 +
 .../mmseg/evaluation/metrics/__init__.py      |    8 +
 .../mmseg/evaluation/metrics/citys_metric.py  |  158 +
 .../mmseg/evaluation/metrics/depth_metric.py  |  212 ++
 .../mmseg/evaluation/metrics/dice_metric.py   |  119 +
 .../mmseg/evaluation/metrics/iou_metric.py    |  286 ++
 .../evaluation/metrics/submission_metric.py   |  131 +
 mmsegmentation/mmseg/models/__init__.py       |   16 +
 .../mmseg/models/assigners/__init__.py        |   12 +
 .../mmseg/models/assigners/base_assigner.py   |   18 +
 .../models/assigners/hungarian_assigner.py    |   86 +
 .../mmseg/models/assigners/match_cost.py      |  231 ++
 .../mmseg/models/backbones/__init__.py        |   35 +
 mmsegmentation/mmseg/models/backbones/beit.py |  554 ++++
 .../mmseg/models/backbones/bisenetv1.py       |  332 +++
 .../mmseg/models/backbones/bisenetv2.py       |  622 ++++
 .../mmseg/models/backbones/cgnet.py           |  372 +++
 .../mmseg/models/backbones/ddrnet.py          |  222 ++
 .../mmseg/models/backbones/erfnet.py          |  329 +++
 .../mmseg/models/backbones/fast_scnn.py       |  408 +++
 .../mmseg/models/backbones/hrnet.py           |  642 +++++
 .../mmseg/models/backbones/icnet.py           |  166 ++
 mmsegmentation/mmseg/models/backbones/mae.py  |  260 ++
 mmsegmentation/mmseg/models/backbones/mit.py  |  450 +++
 .../mmseg/models/backbones/mobilenet_v2.py    |  197 ++
 .../mmseg/models/backbones/mobilenet_v3.py    |  267 ++
 .../mmseg/models/backbones/mscan.py           |  467 +++
 .../mmseg/models/backbones/pidnet.py          |  522 ++++
 .../mmseg/models/backbones/resnest.py         |  318 +++
 .../mmseg/models/backbones/resnet.py          |  712 +++++
 .../mmseg/models/backbones/resnext.py         |  150 +
 mmsegmentation/mmseg/models/backbones/stdc.py |  422 +++
 mmsegmentation/mmseg/models/backbones/swin.py |  757 +++++
 .../mmseg/models/backbones/timm_backbone.py   |   63 +
 .../mmseg/models/backbones/twins.py           |  588 ++++
 mmsegmentation/mmseg/models/backbones/unet.py |  436 +++
 mmsegmentation/mmseg/models/backbones/vit.py  |  501 ++++
 mmsegmentation/mmseg/models/backbones/vpd.py  |  395 +++
 mmsegmentation/mmseg/models/builder.py        |   52 +
 .../mmseg/models/data_preprocessor.py         |  151 +
 .../mmseg/models/decode_heads/__init__.py     |   57 +
 .../mmseg/models/decode_heads/ann_head.py     |  245 ++
 .../mmseg/models/decode_heads/apc_head.py     |  159 ++
 .../mmseg/models/decode_heads/aspp_head.py    |  122 +
 .../decode_heads/cascade_decode_head.py       |   62 +
 .../mmseg/models/decode_heads/cc_head.py      |   43 +
 .../mmseg/models/decode_heads/custom.py       |   74 +
 .../mmseg/models/decode_heads/da_head.py      |  184 ++
 .../mmseg/models/decode_heads/ddr_head.py     |  116 +
 .../mmseg/models/decode_heads/decode_head.py  |  366 +++
 .../mmseg/models/decode_heads/dm_head.py      |  141 +
 .../mmseg/models/decode_heads/dnl_head.py     |  137 +
 .../mmseg/models/decode_heads/dpt_head.py     |  294 ++
 .../mmseg/models/decode_heads/ema_head.py     |  169 ++
 .../mmseg/models/decode_heads/enc_head.py     |  196 ++
 .../mmseg/models/decode_heads/fcn_head.py     |   96 +
 .../mmseg/models/decode_heads/fpn_head.py     |   68 +
 .../mmseg/models/decode_heads/gc_head.py      |   48 +
 .../mmseg/models/decode_heads/ham_head.py     |  255 ++
 .../mmseg/models/decode_heads/isa_head.py     |  143 +
 .../mmseg/models/decode_heads/knet_head.py    |  461 +++
 .../mmseg/models/decode_heads/lraspp_head.py  |   91 +
 .../models/decode_heads/mask2former_head.py   |  163 ++
 .../models/decode_heads/maskformer_head.py    |  174 ++
 .../mmseg/models/decode_heads/nl_head.py      |   50 +
 .../mmseg/models/decode_heads/ocr_head.py     |  127 +
 .../mmseg/models/decode_heads/pid_head.py     |  183 ++
 .../mmseg/models/decode_heads/point_head.py   |  367 +++
 .../mmseg/models/decode_heads/psa_head.py     |  197 ++
 .../mmseg/models/decode_heads/psp_head.py     |  117 +
 .../mmseg/models/decode_heads/san_head.py     |  736 +++++
 .../models/decode_heads/segformer_head.py     |   66 +
 .../decode_heads/segmenter_mask_head.py       |  132 +
 .../models/decode_heads/sep_aspp_head.py      |  102 +
 .../mmseg/models/decode_heads/sep_fcn_head.py |   60 +
 .../models/decode_heads/setr_mla_head.py      |   62 +
 .../mmseg/models/decode_heads/setr_up_head.py |   81 +
 .../mmseg/models/decode_heads/stdc_head.py    |   97 +
 .../mmseg/models/decode_heads/uper_head.py    |  139 +
 .../models/decode_heads/vpd_depth_head.py     |  253 ++
 .../mmseg/models/losses/__init__.py           |   21 +
 .../mmseg/models/losses/accuracy.py           |   92 +
 .../mmseg/models/losses/boundary_loss.py      |   62 +
 .../mmseg/models/losses/cross_entropy_loss.py |  311 ++
 .../mmseg/models/losses/dice_loss.py          |  202 ++
 .../mmseg/models/losses/focal_loss.py         |  337 +++
 .../models/losses/huasdorff_distance_loss.py  |  160 ++
 .../mmseg/models/losses/kldiv_loss.py         |   99 +
 .../mmseg/models/losses/lovasz_loss.py        |  323 +++
 .../models/losses/ohem_cross_entropy_loss.py  |   94 +
 .../mmseg/models/losses/silog_loss.py         |  122 +
 .../mmseg/models/losses/tversky_loss.py       |  137 +
 mmsegmentation/mmseg/models/losses/utils.py   |  129 +
 mmsegmentation/mmseg/models/necks/__init__.py |   11 +
 .../mmseg/models/necks/featurepyramid.py      |   67 +
 mmsegmentation/mmseg/models/necks/fpn.py      |  212 ++
 mmsegmentation/mmseg/models/necks/ic_neck.py  |  148 +
 mmsegmentation/mmseg/models/necks/jpu.py      |  131 +
 mmsegmentation/mmseg/models/necks/mla_neck.py |  118 +
 .../mmseg/models/necks/multilevel_neck.py     |   79 +
 .../mmseg/models/segmentors/__init__.py       |   13 +
 .../mmseg/models/segmentors/base.py           |  200 ++
 .../segmentors/cascade_encoder_decoder.py     |  138 +
 .../mmseg/models/segmentors/custom.py         |   86 +
 .../models/segmentors/depth_estimator.py      |  392 +++
 .../models/segmentors/encoder_decoder.py      |  364 +++
 .../segmentors/multimodal_encoder_decoder.py  |  350 +++
 .../mmseg/models/segmentors/seg_tta.py        |   47 +
 .../mmseg/models/text_encoder/__init__.py     |    4 +
 .../models/text_encoder/clip_text_encoder.py  |  229 ++
 mmsegmentation/mmseg/models/utils/__init__.py |   27 +
 .../mmseg/models/utils/basic_block.py         |  143 +
 mmsegmentation/mmseg/models/utils/embed.py    |  330 +++
 mmsegmentation/mmseg/models/utils/encoding.py |   75 +
 .../mmseg/models/utils/inverted_residual.py   |  213 ++
 .../mmseg/models/utils/make_divisible.py      |   28 +
 .../mmseg/models/utils/point_sample.py        |   88 +
 mmsegmentation/mmseg/models/utils/ppm.py      |  193 ++
 .../mmseg/models/utils/res_layer.py           |   96 +
 .../mmseg/models/utils/san_layers.py          |  418 +++
 mmsegmentation/mmseg/models/utils/se_layer.py |   58 +
 .../models/utils/self_attention_block.py      |  161 ++
 .../mmseg/models/utils/shape_convert.py       |  107 +
 .../mmseg/models/utils/up_conv_block.py       |  102 +
 mmsegmentation/mmseg/models/utils/wrappers.py |   51 +
 mmsegmentation/mmseg/registry/__init__.py     |   15 +
 mmsegmentation/mmseg/registry/registry.py     |  118 +
 mmsegmentation/mmseg/structures/__init__.py   |    8 +
 .../mmseg/structures/sampler/__init__.py      |    6 +
 .../structures/sampler/base_pixel_sampler.py  |   13 +
 .../mmseg/structures/sampler/builder.py       |   14 +
 .../structures/sampler/ohem_pixel_sampler.py  |   85 +
 .../mmseg/structures/seg_data_sample.py       |   92 +
 mmsegmentation/mmseg/utils/__init__.py        |   72 +
 .../mmseg/utils/bpe_simple_vocab_16e6.txt.gz  |  Bin 0 -> 1356917 bytes
 mmsegmentation/mmseg/utils/class_names.py     |  570 ++++
 mmsegmentation/mmseg/utils/collect_env.py     |   18 +
 mmsegmentation/mmseg/utils/get_templates.py   |  109 +
 mmsegmentation/mmseg/utils/io.py              |   42 +
 .../mmseg/utils/mask_classification.py        |  205 ++
 mmsegmentation/mmseg/utils/misc.py            |  128 +
 mmsegmentation/mmseg/utils/set_env.py         |   40 +
 mmsegmentation/mmseg/utils/tokenizer.py       |  240 ++
 mmsegmentation/mmseg/utils/typing_utils.py    |   25 +
 mmsegmentation/mmseg/version.py               |   18 +
 .../mmseg/visualization/__init__.py           |    4 +
 .../mmseg/visualization/local_visualizer.py   |  349 +++
 mmsegmentation/model-index.yml                |   53 +
 mmsegmentation/nohup.out                      | 2216 ++++++++++++++
 mmsegmentation/projects/Adabins/README.md     |   46 +
 .../projects/Adabins/backbones/__init__.py    |    4 +
 .../Adabins/backbones/adabins_backbone.py     |  141 +
 .../Adabins/configs/_base_/datasets/nyu.py    |   32 +
 .../Adabins/configs/_base_/default_runtime.py |   15 +
 .../Adabins/configs/_base_/models/Adabins.py  |   35 +
 ...abins_efficient_b5_4x16_25e_NYU_416x544.py |   15 +
 ...ins_efficient_b5_4x16_25e_kitti_352x704.py |   12 +
 .../projects/Adabins/decode_head/__init__.py  |    4 +
 .../Adabins/decode_head/adabins_head.py       |  179 ++
 mmsegmentation/projects/CAT-Seg/README.md     |   92 +
 .../projects/CAT-Seg/cat_seg/__init__.py      |    2 +
 .../CAT-Seg/cat_seg/models/__init__.py        |   10 +
 .../CAT-Seg/cat_seg/models/cat_aggregator.py  |  763 +++++
 .../CAT-Seg/cat_seg/models/cat_head.py        |  116 +
 .../CAT-Seg/cat_seg/models/clip_ovseg.py      |  293 ++
 .../CAT-Seg/cat_seg/utils/__init__.py         |   10 +
 .../bpe_vocab/bpe_simple_vocab_16e6.txt.gz    |  Bin 0 -> 1356917 bytes
 .../CAT-Seg/cat_seg/utils/clip_model.py       |  651 +++++
 .../CAT-Seg/cat_seg/utils/clip_templates.py   |  204 ++
 .../CAT-Seg/cat_seg/utils/clip_wrapper.py     |  275 ++
 .../cat_seg/utils/self_attention_block.py     |   79 +
 .../CAT-Seg/cat_seg/utils/tokenizer.py        |  160 ++
 .../configs/_base_/datasets/ade20k_384x384.py |   68 +
 .../_base_/datasets/coco-stuff164k_384x384.py |   62 +
 .../datasets/pascal_context_59_384x384.py     |   72 +
 .../CAT-Seg/configs/_base_/default_runtime.py |   15 +
 .../configs/_base_/schedules/schedule_80k.py  |   24 +
 ...-warmcoslr2e-4-adamw-80k_ade20k-384x384.py |  103 +
 ...e-4-adamw-80k_pascal-context-59-384x384.py |  103 +
 ...lr2e-4-adamw-80k_coco-stuff164k-384x384.py |  102 +
 ...lr2e-4_adamw-80k_coco-stuff164k_384x384.py |   11 +
 ...lr2e-4_adamw-80k_coco-stuff164k_384x384.py |   11 +
 ...lr2e-4_adamw-80k_coco-stuff164k_384x384.py |   72 +
 .../projects/CAT-Seg/utils/__init__.py        |    7 +
 mmsegmentation/projects/README.md             |   19 +
 mmsegmentation/projects/XDecoder/README.md    |   17 +
 .../projects/bdd100k_dataset/README.md        |   50 +
 .../configs/_base_/datasets/bdd100k.py        |   70 +
 ...pspnet_r50-d8_4xb2-80k_bdd100k-512x1024.py |   11 +
 .../docs/en/user_guides/2_dataset_prepare.md  |   40 +
 .../zh_cn/user_guides/2_dataset_prepare.md    |   42 +
 .../bdd100k_dataset/mmseg/datasets/bdd100k.py |   31 +
 .../projects/example_project/README.md        |  134 +
 ...mmy-r50-d8_4xb2-40k_cityscapes-512x1024.py |    8 +
 .../example_project/dummy/__init__.py         |    3 +
 .../example_project/dummy/dummy_resnet.py     |   14 +
 mmsegmentation/projects/faq.md                |   19 +
 .../configs/_base_/datasets/gid.py            |   67 +
 ...labv3plus_r101-d8_4xb2-240k_gid-256x256.py |   15 +
 .../gid_dataset/mmseg/datasets/gid.py         |   55 +
 .../tools/dataset_converters/gid.py           |  181 ++
 .../gid_select15imgFromAll.py                 |   75 +
 .../user_guides/2_dataset_prepare.md          |   53 +
 .../projects/hsidrive20_dataset/README.md     |   34 +
 .../configs/_base_/datasets/hsi_drive.py      |   50 +
 ...t-s5-d16_fcn_4xb4-160k_hsidrive-192x384.py |   58 +
 .../docs/en/user_guides/2_dataset_prepare.md  |   42 +
 .../zh_cn/user_guides/2_dataset_prepare.md    |   42 +
 .../mmseg/datasets/hsi_drive.py               |   23 +
 mmsegmentation/projects/hssn/README.md        |   91 +
 .../configs/_base_/datasets/cityscapes.py     |   67 +
 .../hssn/configs/_base_/default_runtime.py    |   15 +
 .../deeplabv3plus_r50-d8_vd_contrast.py       |   55 +
 .../configs/_base_/schedules/schedule_80k.py  |   24 +
 ...us_r101-d8_4xb2-80l_cityscapes-512x1024.py |   21 +
 .../projects/hssn/decode_head/__init__.py     |    4 +
 .../decode_head/sep_aspp_contrast_head.py     |  193 ++
 .../projects/hssn/losses/__init__.py          |    4 +
 .../losses/hiera_triplet_loss_cityscape.py    |  218 ++
 .../projects/hssn/losses/tree_triplet_loss.py |   86 +
 mmsegmentation/projects/isnet/README.md       |  117 +
 ...et_r50-d8_8xb2-160k_cityscapes-512x1024.py |   80 +
 .../projects/isnet/decode_heads/__init__.py   |    3 +
 .../projects/isnet/decode_heads/isnet_head.py |  337 +++
 .../projects/mapillary_dataset/README.md      |   86 +
 .../configs/_base_/datasets/mapillary_v1.py   |   68 +
 .../_base_/datasets/mapillary_v1_65.py        |   37 +
 .../configs/_base_/datasets/mapillary_v2.py   |   68 +
 ..._r101-d8_4xb2-240k_mapillay_v1-512x1024.py |   17 +
 ..._r101-d8_4xb2-240k_mapillay_v2-512x1024.py |   16 +
 ..._r101-d8_4xb2-240k_mapillay_v1-512x1024.py |   16 +
 ..._r101-d8_4xb2-240k_mapillay_v2-512x1024.py |   16 +
 .../docs/en/user_guides/2_dataset_prepare.md  |  255 ++
 .../mmseg/datasets/mapillary.py               |  177 ++
 .../medical/2d_image/ct/cranium/README.md     |  142 +
 .../ct/cranium/configs/cranium_512x512.py     |   42 +
 ...sigmoid}_1xb16-0.01-20k_cranium-512x512.py |   18 +
 ...6_unet_1xb16-0.0001-20k_cranium-512x512.py |   17 +
 ...16_unet_1xb16-0.001-20k_cranium-512x512.py |   17 +
 ...d16_unet_1xb16-0.01-20k_cranium-512x512.py |   17 +
 .../ct/cranium/datasets/cranium_dataset.py    |   31 +
 .../ct/cranium/tools/prepare_dataset.py       |   66 +
 .../dermoscopy/isic2016_task1/README.md       |  149 +
 ...1xb16-0.0001-20k_isic2016-task1-512x512.py |   17 +
 ..._1xb16-0.001-20k_isic2016-task1-512x512.py |   17 +
 ...t_1xb16-0.01-20k_isic2016-task1-512x512.py |   17 +
 .../configs/isic2016-task1_512x512.py         |   42 +
 .../datasets/isic2016-task1_dataset.py        |   30 +
 .../isic2016_task1/tools/prepare_dataset.py   |  120 +
 .../dermoscopy/isic2017_task1/README.md       |  158 +
 ...1xb16-0.0001-20k_isic2017-task1-512x512.py |   17 +
 ..._1xb16-0.001-20k_isic2017-task1-512x512.py |   17 +
 ...t_1xb16-0.01-20k_isic2017-task1-512x512.py |   17 +
 .../configs/isic2017-task1_512x512.py         |   41 +
 .../datasets/isic2017-task1_dataset.py        |   30 +
 .../isic2017_task1/tools/prepare_dataset.py   |  127 +
 .../2d_image/endoscopy/kvasir_seg/README.md   |  145 +
 ...moid}_1xb16-0.01-20k_kvasir-seg-512x512.py |   18 +
 ...net_1xb16-0.0001-20k_kvasir-seg-512x512.py |   17 +
 ...unet_1xb16-0.001-20k_kvasir-seg-512x512.py |   17 +
 ..._unet_1xb16-0.01-20k_kvasir-seg-512x512.py |   17 +
 .../kvasir_seg/configs/kvasir-seg_512x512.py  |   42 +
 .../kvasir_seg/datasets/kvasir-seg_dataset.py |   30 +
 .../kvasir_seg/tools/prepare_dataset.py       |   87 +
 .../endoscopy/kvasir_seg_aliyun/README.md     |  145 +
 ...16-0.0001-20k_kvasir-seg-aliyun-512x512.py |   17 +
 ...b16-0.001-20k_kvasir-seg-aliyun-512x512.py |   17 +
 ...xb16-0.01-20k_kvasir-seg-aliyun-512x512.py |   17 +
 ...r-sigmoid-20k_kvasir-seg-aliyun-512x512.py |   18 +
 .../configs/kvasir-seg-aliyun_512x512.py      |   42 +
 .../datasets/kvasir-seg-aliyun_dataset.py     |   30 +
 .../tools/prepare_dataset.py                  |   86 +
 .../fluorescein_angriogram/vampire/README.md  |  158 +
 ...6_unet_1xb16-0.0001-20k_vampire-512x512.py |   19 +
 ...16_unet_1xb16-0.001-20k_vampire-512x512.py |   19 +
 ...d16_unet_1xb16-0.01-20k_vampire-512x512.py |   22 +
 .../vampire/configs/vampire_512x512.py        |   42 +
 .../vampire/datasets/__init__.py              |    3 +
 .../vampire/datasets/vampire_dataset.py       |   28 +
 .../vampire/tools/prepare_dataset.py          |   44 +
 .../fundus_photography/dr_hagis/README.md     |  155 +
 .../dr_hagis/configs/dr-hagis_512x512.py      |   42 +
 ..._unet_1xb16-0.0001-20k_dr-hagis-512x512.py |   17 +
 ...6_unet_1xb16-0.001-20k_dr-hagis-512x512.py |   17 +
 ...16_unet_1xb16-0.01-20k_dr-hagis-512x512.py |   17 +
 .../dr_hagis/datasets/dr-hagis_dataset.py     |   27 +
 .../dr_hagis/tools/prepare_dataset.py         |   41 +
 .../fundus_photography/gamma3/README.md       |  167 ++
 ...16_unet_1xb16-0.0001-20k_gamma3-512x512.py |   17 +
 ...d16_unet_1xb16-0.001-20k_gamma3-512x512.py |   17 +
 ...-d16_unet_1xb16-0.01-20k_gamma3-512x512.py |   17 +
 .../gamma3/configs/gamma3_512x512.py          |   42 +
 .../gamma3/datasets/gamma3_dataset.py         |   30 +
 .../gamma3/tools/prepare_dataset.py           |  107 +
 .../fundus_photography/orvs/README.md         |  140 +
 ...-d16_unet_1xb16-0.0001-20k_orvs-512x512.py |   17 +
 ...5-d16_unet_1xb16-0.001-20k_orvs-512x512.py |   17 +
 ...s5-d16_unet_1xb16-0.01-20k_orvs-512x512.py |   17 +
 .../orvs/configs/orvs_512x512.py              |   42 +
 .../orvs/datasets/orvs_dataset.py             |   27 +
 .../orvs/tools/prepare_dataset.py             |   55 +
 .../fundus_photography/rite/README.md         |  135 +
 ...-d16_unet_1xb16-0.0001-20k_rite-512x512.py |   17 +
 ...5-d16_unet_1xb16-0.001-20k_rite-512x512.py |   17 +
 ...s5-d16_unet_1xb16-0.01-20k_rite-512x512.py |   17 +
 ...t_1xb16-0.01lr-sigmoid-20k_rite-512x512.py |   18 +
 .../rite/configs/rite_512x512.py              |   42 +
 .../rite/datasets/rite_dataset.py             |   31 +
 .../rite/tools/prepare_dataset.py             |   98 +
 .../breastCancerCellSegmentation/README.md    |  123 +
 .../breastCancerCellSegmentation_512x512.py   |   42 +
 ...0k_breastCancerCellSegmentation-512x512.py |   18 +
 ...0k_breastCancerCellSegmentation-512x512.py |   18 +
 ...0k_breastCancerCellSegmentation-512x512.py |   18 +
 .../breastCancerCellSegmentation_dataset.py   |   30 +
 .../tools/prepare_dataset.py                  |   36 +
 .../breast_cancer_cell_seg/README.md          |  147 +
 .../configs/breast-cancer-cell-seg_512x512.py |   42 +
 ...0001-20k_breast-cancer-cell-seg-512x512.py |   18 +
 ....001-20k_breast-cancer-cell-seg-512x512.py |   18 +
 ...0.01-20k_breast-cancer-cell-seg-512x512.py |   18 +
 .../breast-cancer-cell-seg_dataset.py         |   29 +
 .../tools/prepare_dataset.py                  |   47 +
 .../histopathology/conic2022_seg/README.md    |  207 ++
 .../configs/conic2022-seg_512x512.py          |   42 +
 ...unet_1xb16-0.0001-20k_conic2022-512x512.py |   17 +
 ..._unet_1xb16-0.001-20k_conic2022-512x512.py |   17 +
 ...6_unet_1xb16-0.01-20k_conic2022-512x512.py |   17 +
 .../datasets/conic2022-seg_dataset.py         |   29 +
 .../conic2022_seg/tools/prepare_dataset.py    |   65 +
 .../2d_image/histopathology/consep/README.md  |  147 +
 .../consep/configs/consep_512x512.py          |   42 +
 ...16_unet_1xb16-0.0001-20k_consep-512x512.py |   17 +
 ...d16_unet_1xb16-0.001-20k_consep-512x512.py |   17 +
 ...-d16_unet_1xb16-0.01-20k_consep-512x512.py |   17 +
 .../consep/datasets/consep_dataset.py         |   30 +
 .../consep/tools/prepare_dataset.py           |   54 +
 .../histopathology/fusc2021/README.md         |  136 +
 ..._unet_1xb16-0.0001-20k_fusc2021-512x512.py |   17 +
 ...6_unet_1xb16-0.001-20k_fusc2021-512x512.py |   17 +
 ...16_unet_1xb16-0.01-20k_fusc2021-512x512.py |   17 +
 ...b16-0.01lr-sigmoid-20k_fusc2021-512x512.py |   18 +
 .../fusc2021/configs/fusc2021_512x512.py      |   42 +
 .../fusc2021/datasets/fusc2021_dataset.py     |   30 +
 .../fusc2021/tools/prepare_dataset.py         |  114 +
 .../2d_image/histopathology/pannuke/README.md |  146 +
 ...16-0.01-20k_bactteria-detection-512x512.py |   18 +
 ...6_unet_1xb16-0.0001-20k_pannuke-512x512.py |   17 +
 ...16_unet_1xb16-0.001-20k_pannuke-512x512.py |   17 +
 ...d16_unet_1xb16-0.01-20k_pannuke-512x512.py |   17 +
 .../pannuke/configs/pannuke_512x512.py        |   42 +
 .../pannuke/datasets/pannuke_dataset.py       |   33 +
 .../pannuke/tools/prepare_dataset.py          |   49 +
 .../2d_image/histopathology/pcam/README.md    |  153 +
 ...-d16_unet_1xb16-0.0001-20k_pcam-512x512.py |   17 +
 ...5-d16_unet_1xb16-0.001-20k_pcam-512x512.py |   17 +
 ...s5-d16_unet_1xb16-0.01-20k_pcam-512x512.py |   17 +
 ...t_1xb16-0.01lr-sigmoid-20k_pcam-512x512.py |   18 +
 .../pcam/configs/pcam_512x512.py              |   42 +
 .../pcam/datasets/pcam_dataset.py             |   31 +
 .../pcam/tools/prepare_dataset.py             |   49 +
 .../ravir/README.md                           |  167 ++
 ...d16_unet_1xb16-0.0001-20k_ravir-512x512.py |   19 +
 ...-d16_unet_1xb16-0.001-20k_ravir-512x512.py |   19 +
 ...5-d16_unet_1xb16-0.01-20k_ravir-512x512.py |   19 +
 .../ravir/configs/ravir_512x512.py            |   42 +
 .../ravir/datasets/__init__.py                |    3 +
 .../ravir/datasets/ravir_dataset.py           |   28 +
 .../ravir/tools/prepare_dataset.py            |   33 +
 .../microscopy_images/2pm_vessel/README.md    |  153 +
 .../2pm_vessel/configs/2pm-vessel_512x512.py  |   42 +
 ...net_1xb16-0.0001-20k_2pm-vessel-512x512.py |   17 +
 ...unet_1xb16-0.001-20k_2pm-vessel-512x512.py |   17 +
 ..._unet_1xb16-0.01-20k_2pm-vessel-512x512.py |   17 +
 ...sigmoid-20k_bactteria-detection-512x512.py |   18 +
 .../2pm_vessel/datasets/2pm-vessel_dataset.py |   31 +
 .../2pm_vessel/tools/prepare_dataset.py       |   46 +
 .../bactteria_detection/README.md             |  160 ++
 .../configs/bactteria-detection_512x512.py    |   42 +
 ...-0.0001-20k_bactteria-detection-512x512.py |   18 +
 ...6-0.001-20k_bactteria-detection-512x512.py |   18 +
 ...16-0.01-20k_bactteria-detection-512x512.py |   18 +
 .../datasets/bactteria-detection_dataset.py   |   27 +
 .../tools/prepare_dataset.py                  |   33 +
 .../2d_image/tools/split_seg_dataset.py       |   42 +
 .../x_ray/chest_image_pneum/README.md         |  147 +
 .../configs/chest-image-pneum_512x512.py      |   42 +
 ...16-0.0001-20k_chest-image-pneum-512x512.py |   18 +
 ...b16-0.001-20k_chest-image-pneum-512x512.py |   18 +
 ...xb16-0.01-20k_chest-image-pneum-512x512.py |   18 +
 .../datasets/chest-image-pneum_dataset.py     |   27 +
 .../tools/prepare_dataset.py                  |   73 +
 .../README.md                                 |  119 +
 ...-images-with-pneumothorax-masks_512x512.py |   42 +
 ...-images-with-pneumothorax-masks-512x512.py |   20 +
 ...-images-with-pneumothorax-masks-512x512.py |   19 +
 ...-images-with-pneumothorax-masks-512x512.py |   19 +
 ...-images-with-pneumothorax-masks-512x512.py |   19 +
 ...-images-with-pneumothorax-masks_dataset.py |   31 +
 .../tools/prepare_dataset.py                  |   36 +
 .../2d_image/x_ray/covid_19_ct_cxr/README.md  |  158 +
 .../configs/covid-19-ct-cxr_512x512.py        |   42 +
 ..._1xb16-0.01-20k_covid-19-ct-cxr-512x512.py |   18 +
 ...xb16-0.0001-20k_covid-19-ct-cxr-512x512.py |   17 +
 ...1xb16-0.001-20k_covid-19-ct-cxr-512x512.py |   17 +
 ..._1xb16-0.01-20k_covid-19-ct-cxr-512x512.py |   17 +
 .../datasets/covid-19-ct-cxr_dataset.py       |   31 +
 .../covid_19_ct_cxr/tools/prepare_dataset.py  |   52 +
 .../medical/2d_image/x_ray/crass/README.md    |  144 +
 .../x_ray/crass/configs/crass_512x512.py      |   42 +
 ...d16_unet_1xb16-0.0001-20k_crass-512x512.py |   17 +
 ...-d16_unet_1xb16-0.001-20k_crass-512x512.py |   17 +
 ...5-d16_unet_1xb16-0.01-20k_crass-512x512.py |   17 +
 ..._1xb16-lr0.01-sigmoid-20k_crass-512x512.py |   18 +
 .../x_ray/crass/datasets/crass_dataset.py     |   30 +
 .../x_ray/crass/tools/prepare_dataset.py      |   84 +
 .../projects/nvidia_jetson/README.md          |  372 +++
 .../projects/pp_mobileseg/README.md           |  123 +
 .../pp_mobileseg/backbones/__init__.py        |    4 +
 .../pp_mobileseg/backbones/strideformer.py    |  958 +++++++
 .../configs/_base_/datasets/ade20k.py         |   68 +
 .../configs/_base_/default_runtime.py         |   15 +
 .../configs/_base_/models/pp_mobile.py        |   47 +
 .../configs/_base_/schedules/schedule_80k.py  |   24 +
 ...obilenetv3_2x16_80k_ade20k_512x512_base.py |   18 +
 ...obilenetv3_2x16_80k_ade20k_512x512_tiny.py |   45 +
 .../pp_mobileseg/decode_head/__init__.py      |    6 +
 .../decode_head/pp_mobileseg_head.py          |   94 +
 .../projects/pp_mobileseg/inference_onnx.py   |  203 ++
 .../projects/sam_inference_demo/README.md     |   40 +
 .../sam_inference_demo/sam/__init__.py        |    2 +
 .../sam/modeling/__init__.py                  |   12 +
 .../sam_inference_demo/sam/modeling/common.py |   45 +
 .../sam/modeling/mask_decoder.py              |  196 ++
 .../sam/modeling/prompt_encoder.py            |  227 ++
 .../sam_inference_demo/sam/modeling/sam.py    |  188 ++
 .../sam/modeling/transformer.py               |  241 ++
 .../sam_inference_demo/sam/sam_inferencer.py  |  688 +++++
 .../sam_inference_demo/sam/utils/__init__.py  |    2 +
 .../sam_inference_demo/sam/utils/amg.py       |  355 +++
 .../sam/utils/transforms.py                   |  110 +
 .../sam_inference_demo/sam_image_demo.ipynb   |  122 +
 mmsegmentation/projects/van/README.md         |  101 +
 .../projects/van/backbones/__init__.py        |    4 +
 mmsegmentation/projects/van/backbones/van.py  |  124 +
 .../van/configs/_base_/datasets/ade20k.py     |   14 +
 .../van/configs/_base_/models/van_fpn.py      |   43 +
 .../van/configs/_base_/models/van_upernet.py  |   51 +
 .../van/van-b0_fpn_8xb4-40k_ade20k-512x512.py |    8 +
 .../van/van-b1_fpn_8xb4-40k_ade20k-512x512.py |    6 +
 .../van/van-b2_fpn_8xb4-40k_ade20k-512x512.py |   53 +
 ...van-b2_upernet_4xb2-160k_ade20k-512x512.py |   46 +
 .../van/van-b3_fpn_8xb4-40k_ade20k-512x512.py |   11 +
 ...van-b3_upernet_4xb2-160k_ade20k-512x512.py |    8 +
 ...22kpre_upernet_4xb4-160k_ade20k-512x512.py |   10 +
 ...van-b4_upernet_4xb4-160k_ade20k-512x512.py |   10 +
 ...22kpre_upernet_4xb2-160k_ade20k-512x512.py |   10 +
 ...22kpre_upernet_4xb2-160k_ade20k-512x512.py |   10 +
 ...net_r50-d8_4xb2-40k_cityscapes-512x1024.py |  292 ++
 mmsegmentation/requirements.txt               |    4 +
 mmsegmentation/requirements/albu.txt          |    1 +
 mmsegmentation/requirements/docs.txt          |    7 +
 mmsegmentation/requirements/mminstall.txt     |    2 +
 mmsegmentation/requirements/multimodal.txt    |    2 +
 mmsegmentation/requirements/optional.txt      |   22 +
 mmsegmentation/requirements/readthedocs.txt   |    6 +
 mmsegmentation/requirements/runtime.txt       |    5 +
 mmsegmentation/requirements/tests.txt         |    8 +
 mmsegmentation/resources/seg_demo.gif         |  Bin 0 -> 951973 bytes
 mmsegmentation/setup.cfg                      |   19 +
 mmsegmentation/setup.py                       |  200 ++
 mmsegmentation/test.ipynb                     |  194 ++
 mmsegmentation/tests/__init__.py              |    1 +
 .../tests/test_apis/test_inferencer.py        |   60 +
 .../tests/test_apis/test_rs_inferencer.py     |   73 +
 mmsegmentation/tests/test_apis/utils.py       |   38 +
 mmsegmentation/tests/test_config.py           |  175 ++
 .../tests/test_datasets/test_dataset.py       |  475 +++
 .../test_datasets/test_dataset_builder.py     |  152 +
 .../tests/test_datasets/test_formatting.py    |   61 +
 .../tests/test_datasets/test_loading.py       |  295 ++
 .../tests/test_datasets/test_transform.py     | 1273 +++++++++
 .../tests/test_datasets/test_tta.py           |  131 +
 mmsegmentation/tests/test_digit_version.py    |   21 +
 .../test_layer_decay_optimizer_constructor.py |  300 ++
 .../tests/test_engine/test_optimizer.py       |   33 +
 .../test_engine/test_visualization_hook.py    |   64 +
 .../test_metrics/test_citys_metric.py         |  119 +
 .../test_metrics/test_depth_metric.py         |   85 +
 .../test_metrics/test_iou_metric.py           |  104 +
 mmsegmentation/tests/test_models/__init__.py  |    1 +
 .../test_assigners/test_hungarian_assigner.py |   77 +
 .../test_models/test_backbones/__init__.py    |    1 +
 .../test_models/test_backbones/test_beit.py   |  185 ++
 .../test_backbones/test_bisenetv1.py          |  109 +
 .../test_backbones/test_bisenetv2.py          |   57 +
 .../test_models/test_backbones/test_blocks.py |  187 ++
 .../test_models/test_backbones/test_cgnet.py  |  151 +
 .../test_backbones/test_clip_text_encoder.py  |   43 +
 .../test_models/test_backbones/test_erfnet.py |  146 +
 .../test_backbones/test_fast_scnn.py          |   42 +
 .../test_models/test_backbones/test_hrnet.py  |  144 +
 .../test_models/test_backbones/test_icnet.py  |   50 +
 .../test_models/test_backbones/test_mae.py    |  186 ++
 .../test_models/test_backbones/test_mit.py    |  122 +
 .../test_backbones/test_mobilenet_v3.py       |   67 +
 .../test_models/test_backbones/test_mscan.py  |   69 +
 .../test_models/test_backbones/test_pidnet.py |   87 +
 .../test_backbones/test_resnest.py            |   44 +
 .../test_models/test_backbones/test_resnet.py |  575 ++++
 .../test_backbones/test_resnext.py            |   62 +
 .../test_models/test_backbones/test_stdc.py   |  131 +
 .../test_models/test_backbones/test_swin.py   |  100 +
 .../test_backbones/test_timm_backbone.py      |  133 +
 .../test_models/test_backbones/test_twins.py  |  171 ++
 .../test_models/test_backbones/test_unet.py   |  825 ++++++
 .../test_models/test_backbones/test_vit.py    |  185 ++
 .../test_models/test_backbones/test_vpd.py    |   51 +
 .../tests/test_models/test_backbones/utils.py |   43 +
 .../test_models/test_data_preprocessor.py     |   64 +
 .../tests/test_models/test_forward.py         |  229 ++
 .../tests/test_models/test_heads/__init__.py  |    1 +
 .../test_models/test_heads/test_ann_head.py   |   20 +
 .../test_models/test_heads/test_apc_head.py   |   59 +
 .../test_models/test_heads/test_aspp_head.py  |   76 +
 .../test_models/test_heads/test_cc_head.py    |   18 +
 .../test_heads/test_decode_head.py            |  193 ++
 .../test_models/test_heads/test_dm_head.py    |   59 +
 .../test_models/test_heads/test_dnl_head.py   |   44 +
 .../test_models/test_heads/test_dpt_head.py   |   49 +
 .../test_models/test_heads/test_ema_head.py   |   23 +
 .../test_models/test_heads/test_fcn_head.py   |  131 +
 .../test_models/test_heads/test_gc_head.py    |   16 +
 .../test_models/test_heads/test_ham_head.py   |   44 +
 .../test_models/test_heads/test_isa_head.py   |   20 +
 .../test_heads/test_lraspp_head.py            |   68 +
 .../test_heads/test_mask2former_head.py       |  153 +
 .../test_heads/test_maskformer_head.py        |   54 +
 .../test_models/test_heads/test_nl_head.py    |   16 +
 .../test_models/test_heads/test_ocr_head.py   |   19 +
 .../test_heads/test_pidnet_head.py            |   89 +
 .../test_models/test_heads/test_psa_head.py   |  122 +
 .../test_models/test_heads/test_psp_head.py   |   36 +
 .../test_models/test_heads/test_san_head.py   |  126 +
 .../test_heads/test_segformer_head.py         |   40 +
 .../test_heads/test_segmenter_mask_head.py    |   24 +
 .../test_heads/test_setr_mla_head.py          |   63 +
 .../test_heads/test_setr_up_head.py           |   56 +
 .../test_models/test_heads/test_uper_head.py  |   35 +
 .../test_heads/test_vpd_depth_head.py         |   50 +
 .../tests/test_models/test_heads/utils.py     |   31 +
 .../test_losses/test_cross_entropy_loss.py    |   28 +
 .../test_models/test_losses/test_dice_loss.py |   96 +
 .../test_huasdorff_distance_loss.py           |   29 +
 .../test_losses/test_kldiv_loss.py            |   40 +
 .../test_losses/test_silog_loss.py            |   20 +
 .../test_losses/test_tversky_loss.py          |   77 +
 .../tests/test_models/test_necks/__init__.py  |    1 +
 .../test_necks/test_feature2pyramid.py        |   38 +
 .../tests/test_models/test_necks/test_fpn.py  |   30 +
 .../test_models/test_necks/test_ic_neck.py    |   53 +
 .../tests/test_models/test_necks/test_jpu.py  |   46 +
 .../test_models/test_necks/test_mla_neck.py   |   16 +
 .../test_necks/test_multilevel_neck.py        |   32 +
 .../test_models/test_segmentors/__init__.py   |    1 +
 .../test_cascade_encoder_decoder.py           |   57 +
 .../test_segmentors/test_depth_estimator.py   |   64 +
 .../test_segmentors/test_encoder_decoder.py   |  100 +
 .../test_multimodal_encoder_decoder.py        |   24 +
 .../test_segmentors/test_seg_tta_model.py     |   63 +
 .../test_models/test_segmentors/utils.py      |  182 ++
 .../tests/test_models/test_utils/__init__.py  |    1 +
 .../test_models/test_utils/test_embed.py      |  461 +++
 .../test_utils/test_shape_convert.py          |   89 +
 mmsegmentation/tests/test_sampler.py          |   78 +
 .../test_structures/test_seg_data_sample.py   |   77 +
 mmsegmentation/tests/test_utils/test_io.py    |   33 +
 .../tests/test_utils/test_set_env.py          |   39 +
 .../test_local_visualizer.py                  |  213 ++
 .../tools/analysis_tools/analyze_logs.py      |  130 +
 .../tools/analysis_tools/benchmark.py         |  121 +
 .../tools/analysis_tools/browse_dataset.py    |   77 +
 .../tools/analysis_tools/confusion_matrix.py  |  197 ++
 .../tools/analysis_tools/get_flops.py         |  124 +
 .../tools/analysis_tools/visualization_cam.py |  127 +
 .../tools/dataset_converters/chase_db1.py     |   89 +
 .../tools/dataset_converters/cityscapes.py    |   56 +
 .../tools/dataset_converters/coco_stuff10k.py |  308 ++
 .../dataset_converters/coco_stuff164k.py      |  265 ++
 .../tools/dataset_converters/drive.py         |  114 +
 .../tools/dataset_converters/hrf.py           |  112 +
 .../tools/dataset_converters/isaid.py         |  246 ++
 .../tools/dataset_converters/levircd.py       |   99 +
 .../tools/dataset_converters/loveda.py        |   73 +
 .../tools/dataset_converters/nyu.py           |   89 +
 .../dataset_converters/pascal_context.py      |   87 +
 .../tools/dataset_converters/potsdam.py       |  158 +
 .../tools/dataset_converters/refuge.py        |  110 +
 .../tools/dataset_converters/stare.py         |  167 ++
 .../tools/dataset_converters/synapse.py       |  155 +
 .../tools/dataset_converters/vaihingen.py     |  156 +
 .../tools/dataset_converters/voc_aug.py       |   92 +
 .../tools/deployment/pytorch2torchscript.py   |  185 ++
 mmsegmentation/tools/dist_test.sh             |   20 +
 mmsegmentation/tools/dist_train.sh            |   17 +
 mmsegmentation/tools/misc/browse_dataset.py   |   73 +
 mmsegmentation/tools/misc/print_config.py     |   69 +
 mmsegmentation/tools/misc/publish_model.py    |   50 +
 .../tools/model_converters/beit2mmseg.py      |   56 +
 .../tools/model_converters/clip2mmseg.py      |  163 ++
 .../tools/model_converters/mit2mmseg.py       |   82 +
 .../tools/model_converters/san2mmseg.py       |  220 ++
 .../tools/model_converters/stdc2mmseg.py      |   71 +
 .../tools/model_converters/swin2mmseg.py      |   87 +
 .../tools/model_converters/twins2mmseg.py     |   87 +
 .../tools/model_converters/vit2mmseg.py       |   70 +
 .../tools/model_converters/vitjax2mmseg.py    |  123 +
 mmsegmentation/tools/slurm_test.sh            |   24 +
 mmsegmentation/tools/slurm_train.sh           |   23 +
 mmsegmentation/tools/test.py                  |  123 +
 .../tools/torchserve/mmseg2torchserve.py      |  112 +
 .../tools/torchserve/mmseg_handler.py         |   56 +
 .../tools/torchserve/test_torchserve.py       |   58 +
 mmsegmentation/tools/train.py                 |  104 +
 utils/ufo_to_cityscapes.py                    |  168 ++
 1696 files changed, 129968 insertions(+)
 create mode 100644 mmsegmentation/.circleci/config.yml
 create mode 100644 mmsegmentation/.circleci/docker/Dockerfile
 create mode 100644 mmsegmentation/.circleci/test.yml
 create mode 100644 mmsegmentation/.dev_scripts/batch_test_list.py
 create mode 100644 mmsegmentation/.dev_scripts/batch_train_list.txt
 create mode 100755 mmsegmentation/.dev_scripts/benchmark_evaluation.sh
 create mode 100644 mmsegmentation/.dev_scripts/benchmark_full_models.txt
 create mode 100644 mmsegmentation/.dev_scripts/benchmark_inference.py
 create mode 100644 mmsegmentation/.dev_scripts/benchmark_options.py
 create mode 100755 mmsegmentation/.dev_scripts/benchmark_train.sh
 create mode 100644 mmsegmentation/.dev_scripts/benchmark_train_models.txt
 create mode 100644 mmsegmentation/.dev_scripts/check_urls.py
 create mode 100644 mmsegmentation/.dev_scripts/gather_benchmark_evaluation_results.py
 create mode 100644 mmsegmentation/.dev_scripts/gather_benchmark_train_results.py
 create mode 100644 mmsegmentation/.dev_scripts/gather_models.py
 create mode 100644 mmsegmentation/.dev_scripts/generate_benchmark_evaluation_script.py
 create mode 100644 mmsegmentation/.dev_scripts/generate_benchmark_train_script.py
 create mode 100644 mmsegmentation/.dev_scripts/log_collector/example_config.py
 create mode 100644 mmsegmentation/.dev_scripts/log_collector/log_collector.py
 create mode 100644 mmsegmentation/.dev_scripts/log_collector/readme.md
 create mode 100644 mmsegmentation/.dev_scripts/log_collector/utils.py
 create mode 100755 mmsegmentation/.dev_scripts/update_model_index.py
 create mode 100644 mmsegmentation/.dev_scripts/upload_modelzoo.py
 create mode 100644 mmsegmentation/.github/CODE_OF_CONDUCT.md
 create mode 100644 mmsegmentation/.github/CONTRIBUTING.md
 create mode 100644 mmsegmentation/.github/ISSUE_TEMPLATE/config.yml
 create mode 100644 mmsegmentation/.github/ISSUE_TEMPLATE/error-report.md
 create mode 100644 mmsegmentation/.github/ISSUE_TEMPLATE/feature_request.md
 create mode 100644 mmsegmentation/.github/ISSUE_TEMPLATE/general_questions.md
 create mode 100644 mmsegmentation/.github/ISSUE_TEMPLATE/reimplementation_questions.md
 create mode 100644 mmsegmentation/.github/pull_request_template.md
 create mode 100644 mmsegmentation/.github/workflows/deploy.yml
 create mode 100644 mmsegmentation/.gitignore
 create mode 100644 mmsegmentation/.owners.yml
 create mode 100644 mmsegmentation/.pre-commit-config.yaml
 create mode 100644 mmsegmentation/CITATION.cff
 create mode 100644 mmsegmentation/LICENSE
 create mode 100644 mmsegmentation/MANIFEST.in
 create mode 100644 mmsegmentation/README.md
 create mode 100644 mmsegmentation/README_zh-CN.md
 create mode 100644 mmsegmentation/configs/_base_/datasets/ade20k.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/ade20k_640x640.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/bdd100k.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/chase_db1.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/cityscapes.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/cityscapes_1024x1024.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/cityscapes_768x768.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/cityscapes_769x769.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/cityscapes_832x832.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/coco-stuff10k.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/coco-stuff164k.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/drive.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/hrf.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/hsi_drive.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/isaid.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/levir_256x256.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/loveda.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/mapillary_v1.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/mapillary_v1_65.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/mapillary_v2.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/nyu.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/nyu_512x512.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/pascal_context.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/pascal_context_59.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/pascal_voc12.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/pascal_voc12_aug.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/potsdam.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/refuge.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/stare.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/synapse.py
 create mode 100644 mmsegmentation/configs/_base_/datasets/vaihingen.py
 create mode 100644 mmsegmentation/configs/_base_/default_runtime.py
 create mode 100644 mmsegmentation/configs/_base_/models/ann_r50-d8.py
 create mode 100644 mmsegmentation/configs/_base_/models/apcnet_r50-d8.py
 create mode 100644 mmsegmentation/configs/_base_/models/bisenetv1_r18-d32.py
 create mode 100644 mmsegmentation/configs/_base_/models/bisenetv2.py
 create mode 100644 mmsegmentation/configs/_base_/models/ccnet_r50-d8.py
 create mode 100644 mmsegmentation/configs/_base_/models/cgnet.py
 create mode 100644 mmsegmentation/configs/_base_/models/danet_r50-d8.py
 create mode 100644 mmsegmentation/configs/_base_/models/deeplabv3_r50-d8.py
 create mode 100644 mmsegmentation/configs/_base_/models/deeplabv3_unet_s5-d16.py
 create mode 100644 mmsegmentation/configs/_base_/models/deeplabv3plus_r50-d8.py
 create mode 100644 mmsegmentation/configs/_base_/models/dmnet_r50-d8.py
 create mode 100644 mmsegmentation/configs/_base_/models/dnl_r50-d8.py
 create mode 100644 mmsegmentation/configs/_base_/models/dpt_vit-b16.py
 create mode 100644 mmsegmentation/configs/_base_/models/emanet_r50-d8.py
 create mode 100644 mmsegmentation/configs/_base_/models/encnet_r50-d8.py
 create mode 100644 mmsegmentation/configs/_base_/models/erfnet_fcn.py
 create mode 100644 mmsegmentation/configs/_base_/models/fast_scnn.py
 create mode 100644 mmsegmentation/configs/_base_/models/fastfcn_r50-d32_jpu_psp.py
 create mode 100644 mmsegmentation/configs/_base_/models/fcn_hr18.py
 create mode 100644 mmsegmentation/configs/_base_/models/fcn_r50-d8.py
 create mode 100644 mmsegmentation/configs/_base_/models/fcn_unet_s5-d16.py
 create mode 100644 mmsegmentation/configs/_base_/models/fpn_poolformer_s12.py
 create mode 100644 mmsegmentation/configs/_base_/models/fpn_r50.py
 create mode 100644 mmsegmentation/configs/_base_/models/gcnet_r50-d8.py
 create mode 100644 mmsegmentation/configs/_base_/models/icnet_r50-d8.py
 create mode 100644 mmsegmentation/configs/_base_/models/isanet_r50-d8.py
 create mode 100644 mmsegmentation/configs/_base_/models/lraspp_m-v3-d8.py
 create mode 100644 mmsegmentation/configs/_base_/models/nonlocal_r50-d8.py
 create mode 100644 mmsegmentation/configs/_base_/models/ocrnet_hr18.py
 create mode 100644 mmsegmentation/configs/_base_/models/ocrnet_r50-d8.py
 create mode 100644 mmsegmentation/configs/_base_/models/pointrend_r50.py
 create mode 100644 mmsegmentation/configs/_base_/models/psanet_r50-d8.py
 create mode 100644 mmsegmentation/configs/_base_/models/pspnet_r50-d8.py
 create mode 100644 mmsegmentation/configs/_base_/models/pspnet_unet_s5-d16.py
 create mode 100644 mmsegmentation/configs/_base_/models/san_vit-b16.py
 create mode 100644 mmsegmentation/configs/_base_/models/segformer_mit-b0.py
 create mode 100644 mmsegmentation/configs/_base_/models/segmenter_vit-b16_mask.py
 create mode 100644 mmsegmentation/configs/_base_/models/setr_mla.py
 create mode 100644 mmsegmentation/configs/_base_/models/setr_naive.py
 create mode 100644 mmsegmentation/configs/_base_/models/setr_pup.py
 create mode 100644 mmsegmentation/configs/_base_/models/stdc.py
 create mode 100644 mmsegmentation/configs/_base_/models/twins_pcpvt-s_fpn.py
 create mode 100644 mmsegmentation/configs/_base_/models/twins_pcpvt-s_upernet.py
 create mode 100644 mmsegmentation/configs/_base_/models/upernet_beit.py
 create mode 100644 mmsegmentation/configs/_base_/models/upernet_convnext.py
 create mode 100644 mmsegmentation/configs/_base_/models/upernet_mae.py
 create mode 100644 mmsegmentation/configs/_base_/models/upernet_r50.py
 create mode 100644 mmsegmentation/configs/_base_/models/upernet_swin.py
 create mode 100644 mmsegmentation/configs/_base_/models/upernet_vit-b16_ln_mln.py
 create mode 100644 mmsegmentation/configs/_base_/models/vpd_sd.py
 create mode 100644 mmsegmentation/configs/_base_/schedules/schedule_160k.py
 create mode 100644 mmsegmentation/configs/_base_/schedules/schedule_20k.py
 create mode 100644 mmsegmentation/configs/_base_/schedules/schedule_240k.py
 create mode 100644 mmsegmentation/configs/_base_/schedules/schedule_25k.py
 create mode 100644 mmsegmentation/configs/_base_/schedules/schedule_320k.py
 create mode 100644 mmsegmentation/configs/_base_/schedules/schedule_40k.py
 create mode 100644 mmsegmentation/configs/_base_/schedules/schedule_80k.py
 create mode 100644 mmsegmentation/configs/ann/README.md
 create mode 100644 mmsegmentation/configs/ann/ann_r101-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/ann/ann_r101-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/ann/ann_r101-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/ann/ann_r101-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/ann/ann_r101-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/ann/ann_r101-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/ann/ann_r101-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/ann/ann_r101-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/ann/ann_r50-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/ann/ann_r50-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/ann/ann_r50-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/ann/ann_r50-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/ann/ann_r50-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/ann/ann_r50-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/ann/ann_r50-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/ann/ann_r50-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/ann/metafile.yaml
 create mode 100644 mmsegmentation/configs/apcnet/README.md
 create mode 100644 mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/apcnet/metafile.yaml
 create mode 100644 mmsegmentation/configs/beit/README.md
 create mode 100644 mmsegmentation/configs/beit/beit-base_upernet_8xb2-160k_ade20k-640x640.py
 create mode 100644 mmsegmentation/configs/beit/beit-base_upernet_8xb2-160k_ade20k-640x640_ms.py
 create mode 100644 mmsegmentation/configs/beit/beit-large_upernet_8xb1-amp-160k_ade20k-640x640.py
 create mode 100644 mmsegmentation/configs/beit/beit-large_upernet_8xb1-amp-160k_ade20k-640x640_ms.py
 create mode 100644 mmsegmentation/configs/beit/metafile.yaml
 create mode 100644 mmsegmentation/configs/bisenetv1/README.md
 create mode 100644 mmsegmentation/configs/bisenetv1/bisenetv1_r101-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
 create mode 100644 mmsegmentation/configs/bisenetv1/bisenetv1_r101-d32_4xb4-160k_coco-stuff164k-512x512.py
 create mode 100644 mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py
 create mode 100644 mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
 create mode 100644 mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb8-160k_cityscapes-1024x1024.py
 create mode 100644 mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_cityscapes-1024x1024.py
 create mode 100644 mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_coco-stuff164k-512x512.py
 create mode 100644 mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py
 create mode 100644 mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
 create mode 100644 mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024.py
 create mode 100644 mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_coco-stuff164k-512x512.py
 create mode 100644 mmsegmentation/configs/bisenetv1/metafile.yaml
 create mode 100644 mmsegmentation/configs/bisenetv2/README.md
 create mode 100644 mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-160k_cityscapes-1024x1024.py
 create mode 100644 mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024.py
 create mode 100644 mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-ohem-160k_cityscapes-1024x1024.py
 create mode 100644 mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb8-160k_cityscapes-1024x1024.py
 create mode 100644 mmsegmentation/configs/bisenetv2/metafile.yaml
 create mode 100644 mmsegmentation/configs/ccnet/README.md
 create mode 100644 mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/ccnet/metafile.yaml
 create mode 100644 mmsegmentation/configs/cgnet/README.md
 create mode 100644 mmsegmentation/configs/cgnet/cgnet_fcn_4xb4-60k_cityscapes-680x680.py
 create mode 100644 mmsegmentation/configs/cgnet/cgnet_fcn_4xb8-60k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/cgnet/metafile.yaml
 create mode 100644 mmsegmentation/configs/convnext/README.md
 create mode 100644 mmsegmentation/configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-640x640.py
 create mode 100644 mmsegmentation/configs/convnext/convnext-large_upernet_8xb2-amp-160k_ade20k-640x640.py
 create mode 100644 mmsegmentation/configs/convnext/convnext-small_upernet_8xb2-amp-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/convnext/convnext-tiny_upernet_8xb2-amp-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/convnext/convnext-xlarge_upernet_8xb2-amp-160k_ade20k-640x640.py
 create mode 100644 mmsegmentation/configs/convnext/metafile.yaml
 create mode 100644 mmsegmentation/configs/danet/README.md
 create mode 100644 mmsegmentation/configs/danet/danet_r101-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/danet/danet_r101-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/danet/danet_r101-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/danet/danet_r101-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/danet/danet_r101-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/danet/danet_r101-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/danet/danet_r101-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/danet/danet_r101-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/danet/danet_r50-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/danet/danet_r50-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/danet/danet_r50-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/danet/danet_r50-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/danet/danet_r50-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/danet/danet_r50-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/danet/danet_r50-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/danet/danet_r50-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/danet/metafile.yaml
 create mode 100644 mmsegmentation/configs/ddrnet/README.md
 create mode 100644 mmsegmentation/configs/ddrnet/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024.py
 create mode 100644 mmsegmentation/configs/ddrnet/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024.py
 create mode 100644 mmsegmentation/configs/ddrnet/metafile.yaml
 create mode 100644 mmsegmentation/configs/deeplabv3/README.md
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_coco-stuff164k-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_coco-stuff10k-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-320k_coco-stuff164k-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_coco-stuff10k-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-480x480.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-59-480x480.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_coco-stuff164k-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-480x480.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-59-480x480.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_coco-stuff164k-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_coco-stuff10k-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-320k_coco-stuff164k-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_coco-stuff10k-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_pascal-context-480x480.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_pascal-context-59-480x480.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_coco-stuff164k-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_pascal-context-480x480.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_pascal-context-59-480x480.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/deeplabv3/metafile.yaml
 create mode 100644 mmsegmentation/configs/deeplabv3plus/README.md
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_pascal-context-480x480.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_pascal-context-59-480x480.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_loveda-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_pascal-context-480x480.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_pascal-context-59-480x480.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_vaihingen-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_isaid-896x896.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_loveda-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_potsdam-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_vaihingen-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_pascal-context-480x480.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_pascal-context-59-480x480.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_isaid-896x896.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_loveda-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_pascal-context-480x480.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_pascal-context-59-480x480.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_potsdam-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_vaihingen-512x512.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/deeplabv3plus/metafile.yaml
 create mode 100644 mmsegmentation/configs/dmnet/README.md
 create mode 100644 mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/dmnet/metafile.yaml
 create mode 100644 mmsegmentation/configs/dnlnet/README.md
 create mode 100644 mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/dnlnet/metafile.yaml
 create mode 100644 mmsegmentation/configs/dpt/README.md
 create mode 100644 mmsegmentation/configs/dpt/dpt_vit-b16_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/dpt/metafile.yaml
 create mode 100644 mmsegmentation/configs/dsdl/README.md
 create mode 100644 mmsegmentation/configs/dsdl/cityscapes.py
 create mode 100644 mmsegmentation/configs/dsdl/voc.py
 create mode 100644 mmsegmentation/configs/emanet/README.md
 create mode 100644 mmsegmentation/configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/emanet/emanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/emanet/emanet_r50-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/emanet/metafile.yaml
 create mode 100644 mmsegmentation/configs/encnet/README.md
 create mode 100644 mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/encnet/encnet_r50s-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/encnet/metafile.yaml
 create mode 100644 mmsegmentation/configs/erfnet/README.md
 create mode 100644 mmsegmentation/configs/erfnet/erfnet_fcn_4xb4-160k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/erfnet/metafile.yaml
 create mode 100644 mmsegmentation/configs/fastfcn/README.md
 create mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/fastfcn/metafile.yaml
 create mode 100644 mmsegmentation/configs/fastscnn/README.md
 create mode 100644 mmsegmentation/configs/fastscnn/fast_scnn_8xb4-160k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/fastscnn/metafile.yaml
 create mode 100644 mmsegmentation/configs/fcn/README.md
 create mode 100644 mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-480x480.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-59-480x480.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-480x480.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-59-480x480.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_pascal-context-480x480.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_pascal-context-59-480x480.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_pascal-context-480x480.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_pascal-context-59-480x480.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/fcn/metafile.yaml
 create mode 100644 mmsegmentation/configs/gcnet/README.md
 create mode 100644 mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/gcnet/metafile.yaml
 create mode 100644 mmsegmentation/configs/hrnet/README.md
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb2-160k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_pascal-context-480x480.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_pascal-context-59-480x480.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_isaid-896x896.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_loveda-512x512.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_pascal-context-480x480.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_pascal-context-59-480x480.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_potsdam-512x512.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_vaihingen-512x512.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-160k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_pascal-context-480x480.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_pascal-context-59-480x480.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_isaid-896x896.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_loveda-512x512.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_pascal-context-480x480.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_pascal-context-59-480x480.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_potsdam-512x512.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_vaihingen-512x512.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb2-160k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-480x480.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-59-480x480.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_isaid-896x896.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_loveda-512x512.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-480x480.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-59-480x480.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_potsdam-512x512.py
 create mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_vaihingen-512x512.py
 create mode 100644 mmsegmentation/configs/hrnet/metafile.yaml
 create mode 100644 mmsegmentation/configs/icnet/README.md
 create mode 100644 mmsegmentation/configs/icnet/icnet_r101-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
 create mode 100644 mmsegmentation/configs/icnet/icnet_r101-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
 create mode 100644 mmsegmentation/configs/icnet/icnet_r101-d8_4xb2-160k_cityscapes-832x832.py
 create mode 100644 mmsegmentation/configs/icnet/icnet_r101-d8_4xb2-80k_cityscapes-832x832.py
 create mode 100644 mmsegmentation/configs/icnet/icnet_r18-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
 create mode 100644 mmsegmentation/configs/icnet/icnet_r18-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
 create mode 100644 mmsegmentation/configs/icnet/icnet_r18-d8_4xb2-160k_cityscapes-832x832.py
 create mode 100644 mmsegmentation/configs/icnet/icnet_r18-d8_4xb2-80k_cityscapes-832x832.py
 create mode 100644 mmsegmentation/configs/icnet/icnet_r50-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
 create mode 100644 mmsegmentation/configs/icnet/icnet_r50-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
 create mode 100644 mmsegmentation/configs/icnet/icnet_r50-d8_4xb2-160k_cityscapes-832x832.py
 create mode 100644 mmsegmentation/configs/icnet/icnet_r50-d8_4xb2-80k_cityscapes-832x832.py
 create mode 100644 mmsegmentation/configs/icnet/metafile.yaml
 create mode 100644 mmsegmentation/configs/isanet/README.md
 create mode 100644 mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/isanet/metafile.yaml
 create mode 100644 mmsegmentation/configs/knet/README.md
 create mode 100644 mmsegmentation/configs/knet/knet-s3_r50-d8_deeplabv3_8xb2-adamw-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/knet/knet-s3_r50-d8_fcn_8xb2-adamw-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/knet/knet-s3_r50-d8_pspnet_8xb2-adamw-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/knet/knet-s3_r50-d8_upernet_8xb2-adamw-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-640x640.py
 create mode 100644 mmsegmentation/configs/knet/knet-s3_swin-t_upernet_8xb2-adamw-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/knet/metafile.yaml
 create mode 100644 mmsegmentation/configs/mae/README.md
 create mode 100644 mmsegmentation/configs/mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512-ms.py
 create mode 100644 mmsegmentation/configs/mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/mae/metafile.yaml
 create mode 100644 mmsegmentation/configs/mask2former/README.md
 create mode 100644 mmsegmentation/configs/mask2former/mask2former_r101_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/mask2former/mask2former_r101_8xb2-90k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/mask2former/mask2former_r50_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/mask2former/mask2former_r50_8xb2-90k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/mask2former/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640.py
 create mode 100644 mmsegmentation/configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py
 create mode 100644 mmsegmentation/configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py
 create mode 100644 mmsegmentation/configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/mask2former/mask2former_swin-s_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/mask2former/mask2former_swin-s_8xb2-90k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/mask2former/mask2former_swin-t_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/mask2former/mask2former_swin-t_8xb2-90k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/mask2former/metafile.yaml
 create mode 100644 mmsegmentation/configs/maskformer/README.md
 create mode 100644 mmsegmentation/configs/maskformer/maskformer_r101-d32_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/maskformer/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/maskformer/metafile.yaml
 create mode 100644 mmsegmentation/configs/mobilenet_v2/README.md
 create mode 100644 mmsegmentation/configs/mobilenet_v2/metafile.yaml
 create mode 100644 mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/mobilenet_v3/README.md
 create mode 100644 mmsegmentation/configs/mobilenet_v3/metafile.yaml
 create mode 100644 mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-s_lraspp_4xb4-320k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-scratch-s_lraspp_4xb4-320k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-scratch_lraspp_4xb4-320k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8_lraspp_4xb4-320k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/nonlocal_net/README.md
 create mode 100644 mmsegmentation/configs/nonlocal_net/metafile.yaml
 create mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/ocrnet/README.md
 create mode 100644 mmsegmentation/configs/ocrnet/metafile.yaml
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-160k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-160k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-160k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_r101-d8_8xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/ocrnet/ocrnet_r101-d8_8xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/pidnet/README.md
 create mode 100644 mmsegmentation/configs/pidnet/metafile.yaml
 create mode 100644 mmsegmentation/configs/pidnet/pidnet-l_2xb6-120k_1024x1024-cityscapes.py
 create mode 100644 mmsegmentation/configs/pidnet/pidnet-m_2xb6-120k_1024x1024-cityscapes.py
 create mode 100644 mmsegmentation/configs/pidnet/pidnet-s_2xb6-120k_1024x1024-cityscapes.py
 create mode 100644 mmsegmentation/configs/point_rend/README.md
 create mode 100644 mmsegmentation/configs/point_rend/metafile.yaml
 create mode 100644 mmsegmentation/configs/point_rend/pointrend_r101_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/point_rend/pointrend_r101_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/point_rend/pointrend_r50_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/point_rend/pointrend_r50_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/poolformer/README.md
 create mode 100644 mmsegmentation/configs/poolformer/fpn_poolformer_m36_8xb4-40k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/poolformer/fpn_poolformer_m48_8xb4-40k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/poolformer/fpn_poolformer_s12_8xb4-40k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/poolformer/fpn_poolformer_s24_8xb4-40k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/poolformer/fpn_poolformer_s36_8x4_512x512_40k_ade20k.py
 create mode 100644 mmsegmentation/configs/poolformer/metafile.yaml
 create mode 100644 mmsegmentation/configs/psanet/README.md
 create mode 100644 mmsegmentation/configs/psanet/metafile.yaml
 create mode 100644 mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/README.md
 create mode 100644 mmsegmentation/configs/pspnet/metafile.yaml
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024_dark-zurich-1920x1080.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024_night-driving-1920x1080.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-160k_coco-stuff164k-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-20k_coco-stuff10k-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-320k_coco-stuff164k-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_coco-stuff10k-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-480x480.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-59-480x480.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_coco-stuff164k-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_loveda-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-480x480.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-59-480x480.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_potsdam-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_vaihingen-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024_dark-zurich-1920x1080.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024_night-driving-1920x1080.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_isaid-896x896.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_loveda-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_potsdam-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_vaihingen-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d32_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d32_rsb_4xb2-adamw-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8-rsb_4xb2-adamw-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_dark-zurich-1920x1080.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_night-driving-1920x1080.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024_dark-zurich-1920x1080.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024_night-driving-1920x1080.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-160k_coco-stuff164k-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-20k_coco-stuff10k-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-320k_coco-stuff164k-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_coco-stuff10k-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_pascal-context-480x480.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_pascal-context-59-480x480.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_coco-stuff164k-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_isaid-896x896.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_loveda-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_pascal-context-480x480.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_pascal-context-59-480x480.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_potsdam-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_vaihingen-512x512.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50b-d32_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/resnest/README.md
 create mode 100644 mmsegmentation/configs/resnest/metafile.yaml
 create mode 100644 mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/resnest/resnest_s101-d8_fcn_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/resnest/resnest_s101-d8_fcn_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/resnest/resnest_s101-d8_pspnet_4xb2-80k_cityscapes512x1024.py
 create mode 100644 mmsegmentation/configs/resnest/resnest_s101-d8_pspnet_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/san/README.md
 create mode 100644 mmsegmentation/configs/san/metafile.yaml
 create mode 100644 mmsegmentation/configs/san/san-vit-b16_coco-stuff164k-640x640.py
 create mode 100644 mmsegmentation/configs/san/san-vit-b16_pascal_context-640x640.py
 create mode 100644 mmsegmentation/configs/san/san-vit-b16_voc12aug-640x640.py
 create mode 100644 mmsegmentation/configs/san/san-vit-l14_coco-stuff164k-640x640.py
 create mode 100644 mmsegmentation/configs/san/san-vit-l14_pascal_context-640x640.py
 create mode 100644 mmsegmentation/configs/san/san-vit-l14_voc12aug-640x640.py
 create mode 100644 mmsegmentation/configs/segformer/README.md
 create mode 100644 mmsegmentation/configs/segformer/metafile.yaml
 create mode 100644 mmsegmentation/configs/segformer/segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py
 create mode 100644 mmsegmentation/configs/segformer/segformer_mit-b0_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/segformer/segformer_mit-b1_8xb1-160k_cityscapes-1024x1024.py
 create mode 100644 mmsegmentation/configs/segformer/segformer_mit-b1_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/segformer/segformer_mit-b2_8xb1-160k_cityscapes-1024x1024.py
 create mode 100644 mmsegmentation/configs/segformer/segformer_mit-b2_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/segformer/segformer_mit-b3_8xb1-160k_cityscapes-1024x1024.py
 create mode 100644 mmsegmentation/configs/segformer/segformer_mit-b3_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/segformer/segformer_mit-b4_8xb1-160k_cityscapes-1024x1024.py
 create mode 100644 mmsegmentation/configs/segformer/segformer_mit-b4_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/segformer/segformer_mit-b5_8xb1-160k_cityscapes-1024x1024.py
 create mode 100644 mmsegmentation/configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-640x640.py
 create mode 100644 mmsegmentation/configs/segmenter/README.md
 create mode 100644 mmsegmentation/configs/segmenter/metafile.yaml
 create mode 100644 mmsegmentation/configs/segmenter/segmenter_vit-b_mask_8xb1-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/segmenter/segmenter_vit-l_mask_8xb1-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/segmenter/segmenter_vit-s_fcn_8xb1-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/segmenter/segmenter_vit-s_mask_8xb1-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/segmenter/segmenter_vit-t_mask_8xb1-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/segnext/README.md
 create mode 100644 mmsegmentation/configs/segnext/metafile.yaml
 create mode 100644 mmsegmentation/configs/segnext/segnext_mscan-b_1xb16-adamw-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/segnext/segnext_mscan-l_1xb16-adamw-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/segnext/segnext_mscan-s_1xb16-adamw-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/segnext/segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/sem_fpn/README.md
 create mode 100644 mmsegmentation/configs/sem_fpn/fpn_r101_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/sem_fpn/fpn_r101_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/sem_fpn/fpn_r50_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/sem_fpn/fpn_r50_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/sem_fpn/metafile.yaml
 create mode 100644 mmsegmentation/configs/setr/README.md
 create mode 100644 mmsegmentation/configs/setr/metafile.yaml
 create mode 100644 mmsegmentation/configs/setr/setr_vit-l-mla_8xb1-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/setr/setr_vit-l_mla_8xb1-80k_cityscapes-768x768.py
 create mode 100644 mmsegmentation/configs/setr/setr_vit-l_mla_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/setr/setr_vit-l_naive_8xb1-80k_cityscapes-768x768.py
 create mode 100644 mmsegmentation/configs/setr/setr_vit-l_naive_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/setr/setr_vit-l_pup_8xb1-80k_cityscapes-768x768.py
 create mode 100644 mmsegmentation/configs/setr/setr_vit-l_pup_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/stdc/README.md
 create mode 100644 mmsegmentation/configs/stdc/metafile.yaml
 create mode 100644 mmsegmentation/configs/stdc/stdc1_4xb12-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/stdc/stdc1_in1k-pre_4xb12-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/stdc/stdc2_4xb12-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/stdc/stdc2_in1k-pre_4xb12-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/swin/README.md
 create mode 100644 mmsegmentation/configs/swin/metafile.yaml
 create mode 100644 mmsegmentation/configs/swin/swin-base-patch4-window12-in1k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/swin/swin-base-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/swin/swin-base-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/swin/swin-base-patch4-window7-in22k-pre_upernet_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/swin/swin-large-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/swin/swin-large-patch4-window7-in22k-pre_upernet_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/swin/swin-small-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/swin/swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/swin/swin-tiny-patch4-window7_upernet_1xb8-20k_levir-256x256.py
 create mode 100644 mmsegmentation/configs/twins/README.md
 create mode 100644 mmsegmentation/configs/twins/metafile.yaml
 create mode 100644 mmsegmentation/configs/twins/twins_pcpvt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/twins/twins_pcpvt-b_uperhead_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/twins/twins_pcpvt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/twins/twins_pcpvt-l_uperhead_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/twins/twins_pcpvt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/twins/twins_pcpvt-s_uperhead_8xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/twins/twins_svt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/twins/twins_svt-b_uperhead_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/twins/twins_svt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/twins/twins_svt-l_uperhead_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/twins/twins_svt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/twins/twins_svt-s_uperhead_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/unet/README.md
 create mode 100644 mmsegmentation/configs/unet/metafile.yaml
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_drive-64x64.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_hrf-256x256.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_stare-128x128.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-160k_hsidrive-192x384.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_chase-db1-128x128.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_drive-64x64.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_hrf-256x256.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_stare-128x128.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_chase-db1-128x128.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_drive-64x64.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_hrf-256x256.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_stare-128x128.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
 create mode 100644 mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
 create mode 100644 mmsegmentation/configs/unet/unet_s5-d16_deeplabv3_4xb4-40k_chase-db1-128x128.py
 create mode 100644 mmsegmentation/configs/upernet/README.md
 create mode 100644 mmsegmentation/configs/upernet/metafile.yaml
 create mode 100644 mmsegmentation/configs/upernet/upernet_r101_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/upernet/upernet_r101_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/upernet/upernet_r101_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/upernet/upernet_r101_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/upernet/upernet_r101_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/upernet/upernet_r101_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/upernet/upernet_r101_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/upernet/upernet_r101_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/upernet/upernet_r18_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/upernet/upernet_r18_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/upernet/upernet_r18_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/upernet/upernet_r18_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/upernet/upernet_r18_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/upernet/upernet_r18_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/upernet/upernet_r50_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/upernet/upernet_r50_4xb2-40k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/upernet/upernet_r50_4xb2-80k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/upernet/upernet_r50_4xb2-80k_cityscapes-769x769.py
 create mode 100644 mmsegmentation/configs/upernet/upernet_r50_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/upernet/upernet_r50_4xb4-20k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/upernet/upernet_r50_4xb4-40k_voc12aug-512x512.py
 create mode 100644 mmsegmentation/configs/upernet/upernet_r50_4xb4-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/vit/README.md
 create mode 100644 mmsegmentation/configs/vit/metafile.yaml
 create mode 100644 mmsegmentation/configs/vit/vit_deit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/vit/vit_deit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/vit/vit_deit-b16_upernet_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/vit/vit_deit-b16_upernet_8xb2-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/vit/vit_deit-s16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/vit/vit_deit-s16_mln_upernet_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/vit/vit_deit-s16_upernet_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/vit/vit_deit-s16_upernet_8xb2-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/vit/vit_vit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/vit/vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/vit/vit_vit-b16_mln_upernet_8xb2-80k_ade20k-512x512.py
 create mode 100644 mmsegmentation/configs/vpd/README.md
 create mode 100644 mmsegmentation/configs/vpd/metafile.yaml
 create mode 100644 mmsegmentation/configs/vpd/vpd_sd_4xb8-25k_nyu-480x480.py
 create mode 100644 mmsegmentation/configs/vpd/vpd_sd_4xb8-25k_nyu-512x512.py
 create mode 100644 mmsegmentation/dataset-index.yml
 create mode 100644 mmsegmentation/demo/MMSegmentation_Tutorial.ipynb
 create mode 100644 mmsegmentation/demo/image_demo.py
 create mode 100644 mmsegmentation/demo/image_demo_with_inferencer.py
 create mode 100644 mmsegmentation/demo/inference_demo.ipynb
 create mode 100644 mmsegmentation/demo/rs_image_inference.py
 create mode 100644 mmsegmentation/demo/video_demo.py
 create mode 100644 mmsegmentation/docker/Dockerfile
 create mode 100644 mmsegmentation/docker/serve/Dockerfile
 create mode 100644 mmsegmentation/docker/serve/config.properties
 create mode 100644 mmsegmentation/docker/serve/entrypoint.sh
 create mode 100644 mmsegmentation/docs/en/.readthedocs.yaml
 create mode 100644 mmsegmentation/docs/en/Makefile
 create mode 100644 mmsegmentation/docs/en/_static/css/readthedocs.css
 create mode 100644 mmsegmentation/docs/en/advanced_guides/add_datasets.md
 create mode 100644 mmsegmentation/docs/en/advanced_guides/add_metrics.md
 create mode 100644 mmsegmentation/docs/en/advanced_guides/add_models.md
 create mode 100644 mmsegmentation/docs/en/advanced_guides/add_transforms.md
 create mode 100644 mmsegmentation/docs/en/advanced_guides/customize_runtime.md
 create mode 100644 mmsegmentation/docs/en/advanced_guides/data_flow.md
 create mode 100644 mmsegmentation/docs/en/advanced_guides/datasets.md
 create mode 100644 mmsegmentation/docs/en/advanced_guides/engine.md
 create mode 100644 mmsegmentation/docs/en/advanced_guides/evaluation.md
 create mode 100644 mmsegmentation/docs/en/advanced_guides/index.rst
 create mode 100644 mmsegmentation/docs/en/advanced_guides/models.md
 create mode 100644 mmsegmentation/docs/en/advanced_guides/structures.md
 create mode 100644 mmsegmentation/docs/en/advanced_guides/training_tricks.md
 create mode 100644 mmsegmentation/docs/en/advanced_guides/transforms.md
 create mode 100644 mmsegmentation/docs/en/api.rst
 create mode 100644 mmsegmentation/docs/en/conf.py
 create mode 100644 mmsegmentation/docs/en/device/npu.md
 create mode 100644 mmsegmentation/docs/en/get_started.md
 create mode 100644 mmsegmentation/docs/en/index.rst
 create mode 100644 mmsegmentation/docs/en/make.bat
 create mode 100644 mmsegmentation/docs/en/migration/index.rst
 create mode 100644 mmsegmentation/docs/en/migration/interface.md
 create mode 100644 mmsegmentation/docs/en/migration/package.md
 create mode 100644 mmsegmentation/docs/en/model_zoo.md
 create mode 100644 mmsegmentation/docs/en/modelzoo_statistics.md
 create mode 100644 mmsegmentation/docs/en/notes/changelog.md
 create mode 100644 mmsegmentation/docs/en/notes/changelog_v0.x.md
 create mode 100644 mmsegmentation/docs/en/notes/faq.md
 create mode 100644 mmsegmentation/docs/en/overview.md
 create mode 100755 mmsegmentation/docs/en/stat.py
 create mode 100644 mmsegmentation/docs/en/switch_language.md
 create mode 100644 mmsegmentation/docs/en/user_guides/1_config.md
 create mode 100644 mmsegmentation/docs/en/user_guides/2_dataset_prepare.md
 create mode 100644 mmsegmentation/docs/en/user_guides/3_inference.md
 create mode 100644 mmsegmentation/docs/en/user_guides/4_train_test.md
 create mode 100644 mmsegmentation/docs/en/user_guides/5_deployment.md
 create mode 100644 mmsegmentation/docs/en/user_guides/index.rst
 create mode 100644 mmsegmentation/docs/en/user_guides/useful_tools.md
 create mode 100644 mmsegmentation/docs/en/user_guides/visualization.md
 create mode 100644 mmsegmentation/docs/en/user_guides/visualization_feature_map.md
 create mode 100644 mmsegmentation/docs/zh_cn/.readthedocs.yaml
 create mode 100644 mmsegmentation/docs/zh_cn/Makefile
 create mode 100644 mmsegmentation/docs/zh_cn/_static/css/readthedocs.css
 create mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/add_datasets.md
 create mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/add_metrics.md
 create mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/add_models.md
 create mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/add_transforms.md
 create mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/contribute_dataset.md
 create mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/customize_runtime.md
 create mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/data_flow.md
 create mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/datasets.md
 create mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/engine.md
 create mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/evaluation.md
 create mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/index.rst
 create mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/models.md
 create mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/structures.md
 create mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/training_tricks.md
 create mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/transforms.md
 create mode 100644 mmsegmentation/docs/zh_cn/api.rst
 create mode 100644 mmsegmentation/docs/zh_cn/conf.py
 create mode 100644 mmsegmentation/docs/zh_cn/device/npu.md
 create mode 100644 mmsegmentation/docs/zh_cn/get_started.md
 create mode 100644 mmsegmentation/docs/zh_cn/index.rst
 create mode 100644 mmsegmentation/docs/zh_cn/make.bat
 create mode 100644 mmsegmentation/docs/zh_cn/migration/index.rst
 create mode 100644 mmsegmentation/docs/zh_cn/migration/interface.md
 create mode 100644 mmsegmentation/docs/zh_cn/migration/package.md
 create mode 100644 mmsegmentation/docs/zh_cn/model_zoo.md
 create mode 100644 mmsegmentation/docs/zh_cn/modelzoo_statistics.md
 create mode 100644 mmsegmentation/docs/zh_cn/notes/faq.md
 create mode 100644 mmsegmentation/docs/zh_cn/overview.md
 create mode 100755 mmsegmentation/docs/zh_cn/stat.py
 create mode 100644 mmsegmentation/docs/zh_cn/switch_language.md
 create mode 100644 mmsegmentation/docs/zh_cn/user_guides/1_config.md
 create mode 100644 mmsegmentation/docs/zh_cn/user_guides/2_dataset_prepare.md
 create mode 100644 mmsegmentation/docs/zh_cn/user_guides/3_inference.md
 create mode 100644 mmsegmentation/docs/zh_cn/user_guides/4_train_test.md
 create mode 100644 mmsegmentation/docs/zh_cn/user_guides/5_deployment.md
 create mode 100644 mmsegmentation/docs/zh_cn/user_guides/deploy_jetson.md
 create mode 100644 mmsegmentation/docs/zh_cn/user_guides/index.rst
 create mode 100644 mmsegmentation/docs/zh_cn/user_guides/useful_tools.md
 create mode 100644 mmsegmentation/docs/zh_cn/user_guides/visualization.md
 create mode 100644 mmsegmentation/docs/zh_cn/user_guides/visualization_feature_map.md
 create mode 100644 mmsegmentation/mmseg/__init__.py
 create mode 100644 mmsegmentation/mmseg/apis/__init__.py
 create mode 100644 mmsegmentation/mmseg/apis/inference.py
 create mode 100644 mmsegmentation/mmseg/apis/mmseg_inferencer.py
 create mode 100644 mmsegmentation/mmseg/apis/remote_sense_inferencer.py
 create mode 100644 mmsegmentation/mmseg/apis/utils.py
 create mode 100644 mmsegmentation/mmseg/configs/_base_/datasets/loveda.py
 create mode 100644 mmsegmentation/mmseg/configs/_base_/datasets/potsdam.py
 create mode 100644 mmsegmentation/mmseg/configs/_base_/default_runtime.py
 create mode 100644 mmsegmentation/mmseg/configs/_base_/schedules/schedule_160k.py
 create mode 100644 mmsegmentation/mmseg/configs/_base_/schedules/schedule_20k.py
 create mode 100644 mmsegmentation/mmseg/configs/_base_/schedules/schedule_240k.py
 create mode 100644 mmsegmentation/mmseg/configs/_base_/schedules/schedule_25k.py
 create mode 100644 mmsegmentation/mmseg/configs/_base_/schedules/schedule_320k.py
 create mode 100644 mmsegmentation/mmseg/configs/_base_/schedules/schedule_40k.py
 create mode 100644 mmsegmentation/mmseg/configs/_base_/schedules/schedule_80k.py
 create mode 100644 mmsegmentation/mmseg/datasets/__init__.py
 create mode 100644 mmsegmentation/mmseg/datasets/ade.py
 create mode 100644 mmsegmentation/mmseg/datasets/basesegdataset.py
 create mode 100644 mmsegmentation/mmseg/datasets/bdd100k.py
 create mode 100644 mmsegmentation/mmseg/datasets/chase_db1.py
 create mode 100644 mmsegmentation/mmseg/datasets/cityscapes.py
 create mode 100644 mmsegmentation/mmseg/datasets/coco_stuff.py
 create mode 100644 mmsegmentation/mmseg/datasets/dark_zurich.py
 create mode 100644 mmsegmentation/mmseg/datasets/dataset_wrappers.py
 create mode 100644 mmsegmentation/mmseg/datasets/decathlon.py
 create mode 100644 mmsegmentation/mmseg/datasets/drive.py
 create mode 100644 mmsegmentation/mmseg/datasets/dsdl.py
 create mode 100644 mmsegmentation/mmseg/datasets/hrf.py
 create mode 100644 mmsegmentation/mmseg/datasets/hsi_drive.py
 create mode 100644 mmsegmentation/mmseg/datasets/isaid.py
 create mode 100644 mmsegmentation/mmseg/datasets/isprs.py
 create mode 100644 mmsegmentation/mmseg/datasets/levir.py
 create mode 100644 mmsegmentation/mmseg/datasets/lip.py
 create mode 100644 mmsegmentation/mmseg/datasets/loveda.py
 create mode 100644 mmsegmentation/mmseg/datasets/mapillary.py
 create mode 100644 mmsegmentation/mmseg/datasets/night_driving.py
 create mode 100644 mmsegmentation/mmseg/datasets/nyu.py
 create mode 100644 mmsegmentation/mmseg/datasets/pascal_context.py
 create mode 100644 mmsegmentation/mmseg/datasets/potsdam.py
 create mode 100644 mmsegmentation/mmseg/datasets/refuge.py
 create mode 100644 mmsegmentation/mmseg/datasets/stare.py
 create mode 100644 mmsegmentation/mmseg/datasets/synapse.py
 create mode 100644 mmsegmentation/mmseg/datasets/transforms/__init__.py
 create mode 100644 mmsegmentation/mmseg/datasets/transforms/formatting.py
 create mode 100644 mmsegmentation/mmseg/datasets/transforms/loading.py
 create mode 100644 mmsegmentation/mmseg/datasets/transforms/transforms.py
 create mode 100644 mmsegmentation/mmseg/datasets/voc.py
 create mode 100644 mmsegmentation/mmseg/datasets/xray.py
 create mode 100644 mmsegmentation/mmseg/datasets/xray2.py
 create mode 100644 mmsegmentation/mmseg/engine/__init__.py
 create mode 100644 mmsegmentation/mmseg/engine/hooks/__init__.py
 create mode 100644 mmsegmentation/mmseg/engine/hooks/visualization_hook.py
 create mode 100644 mmsegmentation/mmseg/engine/optimizers/__init__.py
 create mode 100644 mmsegmentation/mmseg/engine/optimizers/force_default_constructor.py
 create mode 100644 mmsegmentation/mmseg/engine/optimizers/layer_decay_optimizer_constructor.py
 create mode 100644 mmsegmentation/mmseg/engine/schedulers/__init__.py
 create mode 100644 mmsegmentation/mmseg/engine/schedulers/poly_ratio_scheduler.py
 create mode 100644 mmsegmentation/mmseg/evaluation/__init__.py
 create mode 100644 mmsegmentation/mmseg/evaluation/metrics/__init__.py
 create mode 100644 mmsegmentation/mmseg/evaluation/metrics/citys_metric.py
 create mode 100644 mmsegmentation/mmseg/evaluation/metrics/depth_metric.py
 create mode 100644 mmsegmentation/mmseg/evaluation/metrics/dice_metric.py
 create mode 100644 mmsegmentation/mmseg/evaluation/metrics/iou_metric.py
 create mode 100644 mmsegmentation/mmseg/evaluation/metrics/submission_metric.py
 create mode 100644 mmsegmentation/mmseg/models/__init__.py
 create mode 100644 mmsegmentation/mmseg/models/assigners/__init__.py
 create mode 100644 mmsegmentation/mmseg/models/assigners/base_assigner.py
 create mode 100644 mmsegmentation/mmseg/models/assigners/hungarian_assigner.py
 create mode 100644 mmsegmentation/mmseg/models/assigners/match_cost.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/__init__.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/beit.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/bisenetv1.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/bisenetv2.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/cgnet.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/ddrnet.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/erfnet.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/fast_scnn.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/hrnet.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/icnet.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/mae.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/mit.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/mobilenet_v2.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/mobilenet_v3.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/mscan.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/pidnet.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/resnest.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/resnet.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/resnext.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/stdc.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/swin.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/timm_backbone.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/twins.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/unet.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/vit.py
 create mode 100644 mmsegmentation/mmseg/models/backbones/vpd.py
 create mode 100644 mmsegmentation/mmseg/models/builder.py
 create mode 100644 mmsegmentation/mmseg/models/data_preprocessor.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/__init__.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/ann_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/apc_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/aspp_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/cascade_decode_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/cc_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/custom.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/da_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/ddr_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/decode_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/dm_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/dnl_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/dpt_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/ema_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/enc_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/fcn_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/fpn_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/gc_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/ham_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/isa_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/knet_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/lraspp_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/mask2former_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/maskformer_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/nl_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/ocr_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/pid_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/point_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/psa_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/psp_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/san_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/segformer_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/segmenter_mask_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/sep_aspp_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/sep_fcn_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/setr_mla_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/setr_up_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/stdc_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/uper_head.py
 create mode 100644 mmsegmentation/mmseg/models/decode_heads/vpd_depth_head.py
 create mode 100644 mmsegmentation/mmseg/models/losses/__init__.py
 create mode 100644 mmsegmentation/mmseg/models/losses/accuracy.py
 create mode 100644 mmsegmentation/mmseg/models/losses/boundary_loss.py
 create mode 100644 mmsegmentation/mmseg/models/losses/cross_entropy_loss.py
 create mode 100644 mmsegmentation/mmseg/models/losses/dice_loss.py
 create mode 100644 mmsegmentation/mmseg/models/losses/focal_loss.py
 create mode 100644 mmsegmentation/mmseg/models/losses/huasdorff_distance_loss.py
 create mode 100644 mmsegmentation/mmseg/models/losses/kldiv_loss.py
 create mode 100644 mmsegmentation/mmseg/models/losses/lovasz_loss.py
 create mode 100644 mmsegmentation/mmseg/models/losses/ohem_cross_entropy_loss.py
 create mode 100644 mmsegmentation/mmseg/models/losses/silog_loss.py
 create mode 100644 mmsegmentation/mmseg/models/losses/tversky_loss.py
 create mode 100644 mmsegmentation/mmseg/models/losses/utils.py
 create mode 100644 mmsegmentation/mmseg/models/necks/__init__.py
 create mode 100644 mmsegmentation/mmseg/models/necks/featurepyramid.py
 create mode 100644 mmsegmentation/mmseg/models/necks/fpn.py
 create mode 100644 mmsegmentation/mmseg/models/necks/ic_neck.py
 create mode 100644 mmsegmentation/mmseg/models/necks/jpu.py
 create mode 100644 mmsegmentation/mmseg/models/necks/mla_neck.py
 create mode 100644 mmsegmentation/mmseg/models/necks/multilevel_neck.py
 create mode 100644 mmsegmentation/mmseg/models/segmentors/__init__.py
 create mode 100644 mmsegmentation/mmseg/models/segmentors/base.py
 create mode 100644 mmsegmentation/mmseg/models/segmentors/cascade_encoder_decoder.py
 create mode 100644 mmsegmentation/mmseg/models/segmentors/custom.py
 create mode 100644 mmsegmentation/mmseg/models/segmentors/depth_estimator.py
 create mode 100644 mmsegmentation/mmseg/models/segmentors/encoder_decoder.py
 create mode 100644 mmsegmentation/mmseg/models/segmentors/multimodal_encoder_decoder.py
 create mode 100644 mmsegmentation/mmseg/models/segmentors/seg_tta.py
 create mode 100644 mmsegmentation/mmseg/models/text_encoder/__init__.py
 create mode 100644 mmsegmentation/mmseg/models/text_encoder/clip_text_encoder.py
 create mode 100644 mmsegmentation/mmseg/models/utils/__init__.py
 create mode 100644 mmsegmentation/mmseg/models/utils/basic_block.py
 create mode 100644 mmsegmentation/mmseg/models/utils/embed.py
 create mode 100644 mmsegmentation/mmseg/models/utils/encoding.py
 create mode 100644 mmsegmentation/mmseg/models/utils/inverted_residual.py
 create mode 100644 mmsegmentation/mmseg/models/utils/make_divisible.py
 create mode 100644 mmsegmentation/mmseg/models/utils/point_sample.py
 create mode 100644 mmsegmentation/mmseg/models/utils/ppm.py
 create mode 100644 mmsegmentation/mmseg/models/utils/res_layer.py
 create mode 100644 mmsegmentation/mmseg/models/utils/san_layers.py
 create mode 100644 mmsegmentation/mmseg/models/utils/se_layer.py
 create mode 100644 mmsegmentation/mmseg/models/utils/self_attention_block.py
 create mode 100644 mmsegmentation/mmseg/models/utils/shape_convert.py
 create mode 100644 mmsegmentation/mmseg/models/utils/up_conv_block.py
 create mode 100644 mmsegmentation/mmseg/models/utils/wrappers.py
 create mode 100644 mmsegmentation/mmseg/registry/__init__.py
 create mode 100644 mmsegmentation/mmseg/registry/registry.py
 create mode 100644 mmsegmentation/mmseg/structures/__init__.py
 create mode 100644 mmsegmentation/mmseg/structures/sampler/__init__.py
 create mode 100644 mmsegmentation/mmseg/structures/sampler/base_pixel_sampler.py
 create mode 100644 mmsegmentation/mmseg/structures/sampler/builder.py
 create mode 100644 mmsegmentation/mmseg/structures/sampler/ohem_pixel_sampler.py
 create mode 100644 mmsegmentation/mmseg/structures/seg_data_sample.py
 create mode 100644 mmsegmentation/mmseg/utils/__init__.py
 create mode 100644 mmsegmentation/mmseg/utils/bpe_simple_vocab_16e6.txt.gz
 create mode 100644 mmsegmentation/mmseg/utils/class_names.py
 create mode 100644 mmsegmentation/mmseg/utils/collect_env.py
 create mode 100644 mmsegmentation/mmseg/utils/get_templates.py
 create mode 100644 mmsegmentation/mmseg/utils/io.py
 create mode 100644 mmsegmentation/mmseg/utils/mask_classification.py
 create mode 100644 mmsegmentation/mmseg/utils/misc.py
 create mode 100644 mmsegmentation/mmseg/utils/set_env.py
 create mode 100644 mmsegmentation/mmseg/utils/tokenizer.py
 create mode 100644 mmsegmentation/mmseg/utils/typing_utils.py
 create mode 100644 mmsegmentation/mmseg/version.py
 create mode 100644 mmsegmentation/mmseg/visualization/__init__.py
 create mode 100644 mmsegmentation/mmseg/visualization/local_visualizer.py
 create mode 100644 mmsegmentation/model-index.yml
 create mode 100644 mmsegmentation/nohup.out
 create mode 100644 mmsegmentation/projects/Adabins/README.md
 create mode 100644 mmsegmentation/projects/Adabins/backbones/__init__.py
 create mode 100644 mmsegmentation/projects/Adabins/backbones/adabins_backbone.py
 create mode 100644 mmsegmentation/projects/Adabins/configs/_base_/datasets/nyu.py
 create mode 100644 mmsegmentation/projects/Adabins/configs/_base_/default_runtime.py
 create mode 100644 mmsegmentation/projects/Adabins/configs/_base_/models/Adabins.py
 create mode 100644 mmsegmentation/projects/Adabins/configs/adabins/adabins_efficient_b5_4x16_25e_NYU_416x544.py
 create mode 100644 mmsegmentation/projects/Adabins/configs/adabins/adabins_efficient_b5_4x16_25e_kitti_352x704.py
 create mode 100644 mmsegmentation/projects/Adabins/decode_head/__init__.py
 create mode 100644 mmsegmentation/projects/Adabins/decode_head/adabins_head.py
 create mode 100644 mmsegmentation/projects/CAT-Seg/README.md
 create mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/__init__.py
 create mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/models/__init__.py
 create mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/models/cat_aggregator.py
 create mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/models/cat_head.py
 create mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/models/clip_ovseg.py
 create mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/utils/__init__.py
 create mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/utils/bpe_vocab/bpe_simple_vocab_16e6.txt.gz
 create mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_model.py
 create mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_templates.py
 create mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_wrapper.py
 create mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/utils/self_attention_block.py
 create mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/utils/tokenizer.py
 create mode 100644 mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/ade20k_384x384.py
 create mode 100644 mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/coco-stuff164k_384x384.py
 create mode 100644 mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/pascal_context_59_384x384.py
 create mode 100644 mmsegmentation/projects/CAT-Seg/configs/_base_/default_runtime.py
 create mode 100644 mmsegmentation/projects/CAT-Seg/configs/_base_/schedules/schedule_80k.py
 create mode 100644 mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb1-warmcoslr2e-4-adamw-80k_ade20k-384x384.py
 create mode 100644 mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb1-warmcoslr2e-4-adamw-80k_pascal-context-59-384x384.py
 create mode 100644 mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb2-warmcoslr2e-4-adamw-80k_coco-stuff164k-384x384.py
 create mode 100644 mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitg-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py
 create mode 100644 mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vith-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py
 create mode 100644 mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitl-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py
 create mode 100644 mmsegmentation/projects/CAT-Seg/utils/__init__.py
 create mode 100644 mmsegmentation/projects/README.md
 create mode 100644 mmsegmentation/projects/XDecoder/README.md
 create mode 100644 mmsegmentation/projects/bdd100k_dataset/README.md
 create mode 100644 mmsegmentation/projects/bdd100k_dataset/configs/_base_/datasets/bdd100k.py
 create mode 100644 mmsegmentation/projects/bdd100k_dataset/configs/pspnet_r50-d8_4xb2-80k_bdd100k-512x1024.py
 create mode 100644 mmsegmentation/projects/bdd100k_dataset/docs/en/user_guides/2_dataset_prepare.md
 create mode 100644 mmsegmentation/projects/bdd100k_dataset/docs/zh_cn/user_guides/2_dataset_prepare.md
 create mode 100644 mmsegmentation/projects/bdd100k_dataset/mmseg/datasets/bdd100k.py
 create mode 100644 mmsegmentation/projects/example_project/README.md
 create mode 100644 mmsegmentation/projects/example_project/configs/fcn_dummy-r50-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/projects/example_project/dummy/__init__.py
 create mode 100644 mmsegmentation/projects/example_project/dummy/dummy_resnet.py
 create mode 100644 mmsegmentation/projects/faq.md
 create mode 100644 mmsegmentation/projects/gid_dataset/configs/_base_/datasets/gid.py
 create mode 100644 mmsegmentation/projects/gid_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_gid-256x256.py
 create mode 100644 mmsegmentation/projects/gid_dataset/mmseg/datasets/gid.py
 create mode 100644 mmsegmentation/projects/gid_dataset/tools/dataset_converters/gid.py
 create mode 100644 mmsegmentation/projects/gid_dataset/tools/dataset_converters/gid_select15imgFromAll.py
 create mode 100644 mmsegmentation/projects/gid_dataset/user_guides/2_dataset_prepare.md
 create mode 100644 mmsegmentation/projects/hsidrive20_dataset/README.md
 create mode 100644 mmsegmentation/projects/hsidrive20_dataset/configs/_base_/datasets/hsi_drive.py
 create mode 100644 mmsegmentation/projects/hsidrive20_dataset/configs/unet-s5-d16_fcn_4xb4-160k_hsidrive-192x384.py
 create mode 100644 mmsegmentation/projects/hsidrive20_dataset/docs/en/user_guides/2_dataset_prepare.md
 create mode 100644 mmsegmentation/projects/hsidrive20_dataset/docs/zh_cn/user_guides/2_dataset_prepare.md
 create mode 100644 mmsegmentation/projects/hsidrive20_dataset/mmseg/datasets/hsi_drive.py
 create mode 100644 mmsegmentation/projects/hssn/README.md
 create mode 100644 mmsegmentation/projects/hssn/configs/_base_/datasets/cityscapes.py
 create mode 100644 mmsegmentation/projects/hssn/configs/_base_/default_runtime.py
 create mode 100644 mmsegmentation/projects/hssn/configs/_base_/models/deeplabv3plus_r50-d8_vd_contrast.py
 create mode 100644 mmsegmentation/projects/hssn/configs/_base_/schedules/schedule_80k.py
 create mode 100644 mmsegmentation/projects/hssn/configs/hssn/hieraseg_deeplabv3plus_r101-d8_4xb2-80l_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/projects/hssn/decode_head/__init__.py
 create mode 100644 mmsegmentation/projects/hssn/decode_head/sep_aspp_contrast_head.py
 create mode 100644 mmsegmentation/projects/hssn/losses/__init__.py
 create mode 100644 mmsegmentation/projects/hssn/losses/hiera_triplet_loss_cityscape.py
 create mode 100644 mmsegmentation/projects/hssn/losses/tree_triplet_loss.py
 create mode 100644 mmsegmentation/projects/isnet/README.md
 create mode 100644 mmsegmentation/projects/isnet/configs/isnet_r50-d8_8xb2-160k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/projects/isnet/decode_heads/__init__.py
 create mode 100644 mmsegmentation/projects/isnet/decode_heads/isnet_head.py
 create mode 100644 mmsegmentation/projects/mapillary_dataset/README.md
 create mode 100644 mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v1.py
 create mode 100644 mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v1_65.py
 create mode 100644 mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v2.py
 create mode 100644 mmsegmentation/projects/mapillary_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_mapillay_v1-512x1024.py
 create mode 100644 mmsegmentation/projects/mapillary_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_mapillay_v2-512x1024.py
 create mode 100644 mmsegmentation/projects/mapillary_dataset/configs/pspnet_r101-d8_4xb2-240k_mapillay_v1-512x1024.py
 create mode 100644 mmsegmentation/projects/mapillary_dataset/configs/pspnet_r101-d8_4xb2-240k_mapillay_v2-512x1024.py
 create mode 100644 mmsegmentation/projects/mapillary_dataset/docs/en/user_guides/2_dataset_prepare.md
 create mode 100644 mmsegmentation/projects/mapillary_dataset/mmseg/datasets/mapillary.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/ct/cranium/README.md
 create mode 100644 mmsegmentation/projects/medical/2d_image/ct/cranium/configs/cranium_512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_cranium-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_cranium-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_cranium-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_cranium-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/ct/cranium/datasets/cranium_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/ct/cranium/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/README.md
 create mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_isic2016-task1-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_isic2016-task1-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_isic2016-task1-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/isic2016-task1_512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/datasets/isic2016-task1_dataset.py
 create mode 100755 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/README.md
 create mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_isic2017-task1-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_isic2017-task1-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_isic2017-task1-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/isic2017-task1_512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/datasets/isic2017-task1_dataset.py
 create mode 100755 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/README.md
 create mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_kvasir-seg-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_kvasir-seg-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_kvasir-seg-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_kvasir-seg-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/kvasir-seg_512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/datasets/kvasir-seg_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/README.md
 create mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_kvasir-seg-aliyun-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_kvasir-seg-aliyun-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_kvasir-seg-aliyun-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_kvasir-seg-aliyun-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/kvasir-seg-aliyun_512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/datasets/kvasir-seg-aliyun_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/README.md
 create mode 100755 mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_vampire-512x512.py
 create mode 100755 mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_vampire-512x512.py
 create mode 100755 mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_vampire-512x512.py
 create mode 100755 mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/vampire_512x512.py
 create mode 100755 mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/datasets/__init__.py
 create mode 100755 mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/datasets/vampire_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/README.md
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/dr-hagis_512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_dr-hagis-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_dr-hagis-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_dr-hagis-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/datasets/dr-hagis_dataset.py
 create mode 100755 mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/README.md
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_gamma3-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_gamma3-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_gamma3-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/gamma3_512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/datasets/gamma3_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/README.md
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_orvs-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_orvs-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_orvs-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/orvs_512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/datasets/orvs_dataset.py
 create mode 100755 mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/rite/README.md
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_rite-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_rite-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_rite-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_rite-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/rite_512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/rite/datasets/rite_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/rite/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/README.md
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/breastCancerCellSegmentation_512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_breastCancerCellSegmentation-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_breastCancerCellSegmentation-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_breastCancerCellSegmentation-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/datasets/breastCancerCellSegmentation_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/README.md
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/breast-cancer-cell-seg_512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_breast-cancer-cell-seg-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_breast-cancer-cell-seg-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_breast-cancer-cell-seg-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/datasets/breast-cancer-cell-seg_dataset.py
 create mode 100755 mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/README.md
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/conic2022-seg_512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_conic2022-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_conic2022-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_conic2022-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/datasets/conic2022-seg_dataset.py
 create mode 100755 mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/consep/README.md
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/consep_512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_consep-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_consep-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_consep-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/consep/datasets/consep_dataset.py
 create mode 100755 mmsegmentation/projects/medical/2d_image/histopathology/consep/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/README.md
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_fusc2021-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_fusc2021-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_fusc2021-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_fusc2021-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fusc2021_512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/datasets/fusc2021_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pannuke/README.md
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_bactteria-detection-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_pannuke-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_pannuke-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_pannuke-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/pannuke_512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pannuke/datasets/pannuke_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pannuke/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pcam/README.md
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_pcam-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_pcam-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_pcam-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_pcam-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/pcam_512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pcam/datasets/pcam_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pcam/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/README.md
 create mode 100755 mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_ravir-512x512.py
 create mode 100755 mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_ravir-512x512.py
 create mode 100755 mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_ravir-512x512.py
 create mode 100755 mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/ravir_512x512.py
 create mode 100755 mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/datasets/__init__.py
 create mode 100755 mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/datasets/ravir_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/README.md
 create mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/2pm-vessel_512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_2pm-vessel-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_2pm-vessel-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_2pm-vessel-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_bactteria-detection-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/datasets/2pm-vessel_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/README.md
 create mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/bactteria-detection_512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_bactteria-detection-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_bactteria-detection-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_bactteria-detection-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/datasets/bactteria-detection_dataset.py
 create mode 100755 mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/tools/split_seg_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/README.md
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/chest-image-pneum_512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_chest-image-pneum-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_chest-image-pneum-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_chest-image-pneum-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/datasets/chest-image-pneum_dataset.py
 create mode 100755 mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/README.md
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/chest-x-ray-images-with-pneumothorax-masks_512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/datasets/chest-x-ray-images-with-pneumothorax-masks_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/README.md
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/covid-19-ct-cxr_512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_covid-19-ct-cxr-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_covid-19-ct-cxr-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_covid-19-ct-cxr-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_covid-19-ct-cxr-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/datasets/covid-19-ct-cxr_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/crass/README.md
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/crass_512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_crass-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_crass-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_crass-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-lr0.01-sigmoid-20k_crass-512x512.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/crass/datasets/crass_dataset.py
 create mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/crass/tools/prepare_dataset.py
 create mode 100644 mmsegmentation/projects/nvidia_jetson/README.md
 create mode 100644 mmsegmentation/projects/pp_mobileseg/README.md
 create mode 100644 mmsegmentation/projects/pp_mobileseg/backbones/__init__.py
 create mode 100644 mmsegmentation/projects/pp_mobileseg/backbones/strideformer.py
 create mode 100644 mmsegmentation/projects/pp_mobileseg/configs/_base_/datasets/ade20k.py
 create mode 100644 mmsegmentation/projects/pp_mobileseg/configs/_base_/default_runtime.py
 create mode 100644 mmsegmentation/projects/pp_mobileseg/configs/_base_/models/pp_mobile.py
 create mode 100644 mmsegmentation/projects/pp_mobileseg/configs/_base_/schedules/schedule_80k.py
 create mode 100644 mmsegmentation/projects/pp_mobileseg/configs/pp_mobileseg/pp_mobileseg_mobilenetv3_2x16_80k_ade20k_512x512_base.py
 create mode 100644 mmsegmentation/projects/pp_mobileseg/configs/pp_mobileseg/pp_mobileseg_mobilenetv3_2x16_80k_ade20k_512x512_tiny.py
 create mode 100644 mmsegmentation/projects/pp_mobileseg/decode_head/__init__.py
 create mode 100644 mmsegmentation/projects/pp_mobileseg/decode_head/pp_mobileseg_head.py
 create mode 100644 mmsegmentation/projects/pp_mobileseg/inference_onnx.py
 create mode 100644 mmsegmentation/projects/sam_inference_demo/README.md
 create mode 100644 mmsegmentation/projects/sam_inference_demo/sam/__init__.py
 create mode 100644 mmsegmentation/projects/sam_inference_demo/sam/modeling/__init__.py
 create mode 100644 mmsegmentation/projects/sam_inference_demo/sam/modeling/common.py
 create mode 100644 mmsegmentation/projects/sam_inference_demo/sam/modeling/mask_decoder.py
 create mode 100644 mmsegmentation/projects/sam_inference_demo/sam/modeling/prompt_encoder.py
 create mode 100644 mmsegmentation/projects/sam_inference_demo/sam/modeling/sam.py
 create mode 100644 mmsegmentation/projects/sam_inference_demo/sam/modeling/transformer.py
 create mode 100644 mmsegmentation/projects/sam_inference_demo/sam/sam_inferencer.py
 create mode 100644 mmsegmentation/projects/sam_inference_demo/sam/utils/__init__.py
 create mode 100644 mmsegmentation/projects/sam_inference_demo/sam/utils/amg.py
 create mode 100644 mmsegmentation/projects/sam_inference_demo/sam/utils/transforms.py
 create mode 100644 mmsegmentation/projects/sam_inference_demo/sam_image_demo.ipynb
 create mode 100644 mmsegmentation/projects/van/README.md
 create mode 100644 mmsegmentation/projects/van/backbones/__init__.py
 create mode 100644 mmsegmentation/projects/van/backbones/van.py
 create mode 100644 mmsegmentation/projects/van/configs/_base_/datasets/ade20k.py
 create mode 100644 mmsegmentation/projects/van/configs/_base_/models/van_fpn.py
 create mode 100644 mmsegmentation/projects/van/configs/_base_/models/van_upernet.py
 create mode 100644 mmsegmentation/projects/van/configs/van/van-b0_fpn_8xb4-40k_ade20k-512x512.py
 create mode 100644 mmsegmentation/projects/van/configs/van/van-b1_fpn_8xb4-40k_ade20k-512x512.py
 create mode 100644 mmsegmentation/projects/van/configs/van/van-b2_fpn_8xb4-40k_ade20k-512x512.py
 create mode 100644 mmsegmentation/projects/van/configs/van/van-b2_upernet_4xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/projects/van/configs/van/van-b3_fpn_8xb4-40k_ade20k-512x512.py
 create mode 100644 mmsegmentation/projects/van/configs/van/van-b3_upernet_4xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/projects/van/configs/van/van-b4-in22kpre_upernet_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/projects/van/configs/van/van-b4_upernet_4xb4-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/projects/van/configs/van/van-b5-in22kpre_upernet_4xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/projects/van/configs/van/van-b6-in22kpre_upernet_4xb2-160k_ade20k-512x512.py
 create mode 100644 mmsegmentation/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/requirements.txt
 create mode 100644 mmsegmentation/requirements/albu.txt
 create mode 100644 mmsegmentation/requirements/docs.txt
 create mode 100644 mmsegmentation/requirements/mminstall.txt
 create mode 100644 mmsegmentation/requirements/multimodal.txt
 create mode 100644 mmsegmentation/requirements/optional.txt
 create mode 100644 mmsegmentation/requirements/readthedocs.txt
 create mode 100644 mmsegmentation/requirements/runtime.txt
 create mode 100644 mmsegmentation/requirements/tests.txt
 create mode 100644 mmsegmentation/resources/seg_demo.gif
 create mode 100644 mmsegmentation/setup.cfg
 create mode 100755 mmsegmentation/setup.py
 create mode 100644 mmsegmentation/test.ipynb
 create mode 100644 mmsegmentation/tests/__init__.py
 create mode 100644 mmsegmentation/tests/test_apis/test_inferencer.py
 create mode 100644 mmsegmentation/tests/test_apis/test_rs_inferencer.py
 create mode 100644 mmsegmentation/tests/test_apis/utils.py
 create mode 100644 mmsegmentation/tests/test_config.py
 create mode 100644 mmsegmentation/tests/test_datasets/test_dataset.py
 create mode 100644 mmsegmentation/tests/test_datasets/test_dataset_builder.py
 create mode 100644 mmsegmentation/tests/test_datasets/test_formatting.py
 create mode 100644 mmsegmentation/tests/test_datasets/test_loading.py
 create mode 100644 mmsegmentation/tests/test_datasets/test_transform.py
 create mode 100644 mmsegmentation/tests/test_datasets/test_tta.py
 create mode 100644 mmsegmentation/tests/test_digit_version.py
 create mode 100644 mmsegmentation/tests/test_engine/test_layer_decay_optimizer_constructor.py
 create mode 100644 mmsegmentation/tests/test_engine/test_optimizer.py
 create mode 100644 mmsegmentation/tests/test_engine/test_visualization_hook.py
 create mode 100644 mmsegmentation/tests/test_evaluation/test_metrics/test_citys_metric.py
 create mode 100644 mmsegmentation/tests/test_evaluation/test_metrics/test_depth_metric.py
 create mode 100644 mmsegmentation/tests/test_evaluation/test_metrics/test_iou_metric.py
 create mode 100644 mmsegmentation/tests/test_models/__init__.py
 create mode 100644 mmsegmentation/tests/test_models/test_assigners/test_hungarian_assigner.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/__init__.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_beit.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_bisenetv1.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_bisenetv2.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_blocks.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_cgnet.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_clip_text_encoder.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_erfnet.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_fast_scnn.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_hrnet.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_icnet.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_mae.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_mit.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_mobilenet_v3.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_mscan.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_pidnet.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_resnest.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_resnet.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_resnext.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_stdc.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_swin.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_timm_backbone.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_twins.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_unet.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_vit.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/test_vpd.py
 create mode 100644 mmsegmentation/tests/test_models/test_backbones/utils.py
 create mode 100644 mmsegmentation/tests/test_models/test_data_preprocessor.py
 create mode 100644 mmsegmentation/tests/test_models/test_forward.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/__init__.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_ann_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_apc_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_aspp_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_cc_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_decode_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_dm_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_dnl_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_dpt_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_ema_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_fcn_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_gc_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_ham_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_isa_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_lraspp_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_mask2former_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_maskformer_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_nl_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_ocr_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_pidnet_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_psa_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_psp_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_san_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_segformer_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_segmenter_mask_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_setr_mla_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_setr_up_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_uper_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/test_vpd_depth_head.py
 create mode 100644 mmsegmentation/tests/test_models/test_heads/utils.py
 create mode 100644 mmsegmentation/tests/test_models/test_losses/test_cross_entropy_loss.py
 create mode 100644 mmsegmentation/tests/test_models/test_losses/test_dice_loss.py
 create mode 100644 mmsegmentation/tests/test_models/test_losses/test_huasdorff_distance_loss.py
 create mode 100644 mmsegmentation/tests/test_models/test_losses/test_kldiv_loss.py
 create mode 100644 mmsegmentation/tests/test_models/test_losses/test_silog_loss.py
 create mode 100644 mmsegmentation/tests/test_models/test_losses/test_tversky_loss.py
 create mode 100644 mmsegmentation/tests/test_models/test_necks/__init__.py
 create mode 100644 mmsegmentation/tests/test_models/test_necks/test_feature2pyramid.py
 create mode 100644 mmsegmentation/tests/test_models/test_necks/test_fpn.py
 create mode 100644 mmsegmentation/tests/test_models/test_necks/test_ic_neck.py
 create mode 100644 mmsegmentation/tests/test_models/test_necks/test_jpu.py
 create mode 100644 mmsegmentation/tests/test_models/test_necks/test_mla_neck.py
 create mode 100644 mmsegmentation/tests/test_models/test_necks/test_multilevel_neck.py
 create mode 100644 mmsegmentation/tests/test_models/test_segmentors/__init__.py
 create mode 100644 mmsegmentation/tests/test_models/test_segmentors/test_cascade_encoder_decoder.py
 create mode 100644 mmsegmentation/tests/test_models/test_segmentors/test_depth_estimator.py
 create mode 100644 mmsegmentation/tests/test_models/test_segmentors/test_encoder_decoder.py
 create mode 100644 mmsegmentation/tests/test_models/test_segmentors/test_multimodal_encoder_decoder.py
 create mode 100644 mmsegmentation/tests/test_models/test_segmentors/test_seg_tta_model.py
 create mode 100644 mmsegmentation/tests/test_models/test_segmentors/utils.py
 create mode 100644 mmsegmentation/tests/test_models/test_utils/__init__.py
 create mode 100644 mmsegmentation/tests/test_models/test_utils/test_embed.py
 create mode 100644 mmsegmentation/tests/test_models/test_utils/test_shape_convert.py
 create mode 100644 mmsegmentation/tests/test_sampler.py
 create mode 100644 mmsegmentation/tests/test_structures/test_seg_data_sample.py
 create mode 100644 mmsegmentation/tests/test_utils/test_io.py
 create mode 100644 mmsegmentation/tests/test_utils/test_set_env.py
 create mode 100644 mmsegmentation/tests/test_visualization/test_local_visualizer.py
 create mode 100644 mmsegmentation/tools/analysis_tools/analyze_logs.py
 create mode 100644 mmsegmentation/tools/analysis_tools/benchmark.py
 create mode 100644 mmsegmentation/tools/analysis_tools/browse_dataset.py
 create mode 100644 mmsegmentation/tools/analysis_tools/confusion_matrix.py
 create mode 100644 mmsegmentation/tools/analysis_tools/get_flops.py
 create mode 100644 mmsegmentation/tools/analysis_tools/visualization_cam.py
 create mode 100644 mmsegmentation/tools/dataset_converters/chase_db1.py
 create mode 100644 mmsegmentation/tools/dataset_converters/cityscapes.py
 create mode 100644 mmsegmentation/tools/dataset_converters/coco_stuff10k.py
 create mode 100644 mmsegmentation/tools/dataset_converters/coco_stuff164k.py
 create mode 100644 mmsegmentation/tools/dataset_converters/drive.py
 create mode 100644 mmsegmentation/tools/dataset_converters/hrf.py
 create mode 100644 mmsegmentation/tools/dataset_converters/isaid.py
 create mode 100644 mmsegmentation/tools/dataset_converters/levircd.py
 create mode 100644 mmsegmentation/tools/dataset_converters/loveda.py
 create mode 100644 mmsegmentation/tools/dataset_converters/nyu.py
 create mode 100644 mmsegmentation/tools/dataset_converters/pascal_context.py
 create mode 100644 mmsegmentation/tools/dataset_converters/potsdam.py
 create mode 100644 mmsegmentation/tools/dataset_converters/refuge.py
 create mode 100644 mmsegmentation/tools/dataset_converters/stare.py
 create mode 100644 mmsegmentation/tools/dataset_converters/synapse.py
 create mode 100644 mmsegmentation/tools/dataset_converters/vaihingen.py
 create mode 100644 mmsegmentation/tools/dataset_converters/voc_aug.py
 create mode 100644 mmsegmentation/tools/deployment/pytorch2torchscript.py
 create mode 100755 mmsegmentation/tools/dist_test.sh
 create mode 100755 mmsegmentation/tools/dist_train.sh
 create mode 100644 mmsegmentation/tools/misc/browse_dataset.py
 create mode 100644 mmsegmentation/tools/misc/print_config.py
 create mode 100644 mmsegmentation/tools/misc/publish_model.py
 create mode 100644 mmsegmentation/tools/model_converters/beit2mmseg.py
 create mode 100644 mmsegmentation/tools/model_converters/clip2mmseg.py
 create mode 100644 mmsegmentation/tools/model_converters/mit2mmseg.py
 create mode 100644 mmsegmentation/tools/model_converters/san2mmseg.py
 create mode 100644 mmsegmentation/tools/model_converters/stdc2mmseg.py
 create mode 100644 mmsegmentation/tools/model_converters/swin2mmseg.py
 create mode 100644 mmsegmentation/tools/model_converters/twins2mmseg.py
 create mode 100644 mmsegmentation/tools/model_converters/vit2mmseg.py
 create mode 100644 mmsegmentation/tools/model_converters/vitjax2mmseg.py
 create mode 100755 mmsegmentation/tools/slurm_test.sh
 create mode 100755 mmsegmentation/tools/slurm_train.sh
 create mode 100644 mmsegmentation/tools/test.py
 create mode 100644 mmsegmentation/tools/torchserve/mmseg2torchserve.py
 create mode 100644 mmsegmentation/tools/torchserve/mmseg_handler.py
 create mode 100644 mmsegmentation/tools/torchserve/test_torchserve.py
 create mode 100644 mmsegmentation/tools/train.py
 create mode 100644 utils/ufo_to_cityscapes.py

diff --git a/mmsegmentation/.circleci/config.yml b/mmsegmentation/.circleci/config.yml
new file mode 100644
index 0000000..635a984
--- /dev/null
+++ b/mmsegmentation/.circleci/config.yml
@@ -0,0 +1,34 @@
+version: 2.1
+
+# this allows you to use CircleCI's dynamic configuration feature
+setup: true
+
+# the path-filtering orb is required to continue a pipeline based on
+# the path of an updated fileset
+orbs:
+  path-filtering: circleci/path-filtering@0.1.2
+
+workflows:
+  # the always-run workflow is always triggered, regardless of the pipeline parameters.
+  always-run:
+    jobs:
+      # the path-filtering/filter job determines which pipeline
+      # parameters to update.
+      - path-filtering/filter:
+          name: check-updated-files
+          # 3-column, whitespace-delimited mapping. One mapping per
+          # line:
+          # <regex path-to-test> <parameter-to-set> <value-of-pipeline-parameter>
+          mapping: |
+            mmseg/.* lint_only false
+            requirements/.* lint_only false
+            tests/.* lint_only false
+            tools/.* lint_only false
+            configs/.* lint_only false
+            .circleci/.* lint_only false
+          base-revision: main
+          # this is the path of the configuration we should trigger once
+          # path filtering and pipeline parameter value updates are
+          # complete. In this case, we are using the parent dynamic
+          # configuration itself.
+          config-path: .circleci/test.yml
diff --git a/mmsegmentation/.circleci/docker/Dockerfile b/mmsegmentation/.circleci/docker/Dockerfile
new file mode 100644
index 0000000..b1d40e0
--- /dev/null
+++ b/mmsegmentation/.circleci/docker/Dockerfile
@@ -0,0 +1,12 @@
+
+ARG PYTORCH="1.8.1"
+ARG CUDA="10.2"
+ARG CUDNN="7"
+
+FROM pytorch/pytorch:${PYTORCH}-cuda${CUDA}-cudnn${CUDNN}-devel
+
+# To fix GPG key error when running apt-get update
+RUN apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/3bf863cc.pub
+RUN apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64/7fa2af80.pub
+
+RUN apt-get update && apt-get install -y ninja-build libglib2.0-0 libsm6 libxrender-dev libxext6 libgl1-mesa-glx
diff --git a/mmsegmentation/.circleci/test.yml b/mmsegmentation/.circleci/test.yml
new file mode 100644
index 0000000..622cdf9
--- /dev/null
+++ b/mmsegmentation/.circleci/test.yml
@@ -0,0 +1,196 @@
+version: 2.1
+
+# the default pipeline parameters, which will be updated according to
+# the results of the path-filtering orb
+parameters:
+  lint_only:
+    type: boolean
+    default: true
+
+jobs:
+  lint:
+    docker:
+      - image: cimg/python:3.7.4
+    steps:
+      - checkout
+      - run:
+          name: Install pre-commit hook
+          command: |
+            pip install pre-commit
+            pre-commit install
+      - run:
+          name: Linting
+          command: pre-commit run --all-files
+      - run:
+          name: Check docstring coverage
+          command: |
+            pip install interrogate
+            interrogate -v --ignore-init-method --ignore-module --ignore-nested-functions --ignore-magic --ignore-regex "__repr__" --fail-under 75 mmseg
+  build_cpu:
+    parameters:
+      # The python version must match available image tags in
+      # https://circleci.com/developer/images/image/cimg/python
+      python:
+        type: string
+      torch:
+        type: string
+      torchvision:
+        type: string
+    docker:
+      - image: cimg/python:<< parameters.python >>
+    resource_class: large
+    steps:
+      - checkout
+      - run:
+          name: Install Libraries
+          command: |
+            sudo apt-get update
+            sudo apt-get install -y ninja-build libglib2.0-0 libsm6 libxrender-dev libxext6 libgl1-mesa-glx libjpeg-dev zlib1g-dev libtinfo-dev libncurses5
+      - run:
+          name: Configure Python & pip
+          command: |
+            pip install --upgrade pip
+            pip install wheel
+      - run:
+          name: Install PyTorch
+          command: |
+            python -V
+            pip install torch==<< parameters.torch >>+cpu torchvision==<< parameters.torchvision >>+cpu -f https://download.pytorch.org/whl/torch_stable.html
+      - run:
+          name: Install mmseg dependencies
+          command: |
+            pip install git+https://github.com/open-mmlab/mmengine.git@main
+            pip install -U openmim
+            mim install mmcv>=2.0.0
+            pip install mmpretrain>=1.0.0rc7
+            pip install mmdet>=3.0.0
+            pip install -r requirements/tests.txt -r requirements/optional.txt
+            python -m pip install albumentations>=0.3.2 --no-binary qudida,albumentations
+      - run:
+          name: Build and install
+          command: |
+            pip install -e .
+      - run:
+          name: Skip timm unittests and generate coverage report
+          command: |
+            python -m coverage run --branch --source mmseg -m pytest tests/ --ignore tests/test_models/test_backbones/test_timm_backbone.py --ignore tests/test_apis/test_rs_inferencer.py
+            python -m coverage xml
+            python -m coverage report -m
+  build_cuda:
+    parameters:
+      torch:
+        type: string
+      cuda:
+        type: enum
+        enum: ["10.1", "10.2", "11.1"]
+      cudnn:
+        type: integer
+        default: 7
+    machine:
+      image: linux-cuda-11:default
+      docker_layer_caching: true
+    resource_class: gpu.nvidia.small.multi
+    steps:
+      - checkout
+      - run:
+          name: Install nvidia-container-toolkit and Restart Docker
+          command: |
+            sudo apt-get update
+            sudo apt-get install -y nvidia-container-toolkit
+            sudo systemctl restart docker
+      - run:
+          # Cloning repos in VM since Docker doesn't have access to the private key
+          name: Clone Repos
+          command: |
+            git clone -b main --depth 1 https://github.com/open-mmlab/mmengine.git /home/circleci/mmengine
+      - run:
+          name: Build Docker image
+          command: |
+            docker build .circleci/docker -t mmseg:gpu --build-arg PYTORCH=<< parameters.torch >> --build-arg CUDA=<< parameters.cuda >> --build-arg CUDNN=<< parameters.cudnn >>
+            docker run --gpus all -t -d -v /home/circleci/project:/mmseg -v /home/circleci/mmengine:/mmengine -v /home/circleci/mmpretrain:/mmpretrain -v /home/circleci/mmdetection:/mmdetection -w /mmseg --name mmseg mmseg:gpu
+      - run:
+          name: Install mmseg dependencies
+          command: |
+            docker exec mmseg pip install -e /mmengine
+            docker exec mmseg pip install -U openmim
+            docker exec mmseg mim install mmcv>=2.0.0
+            docker exec mmseg pip install mmpretrain>=1.0.0rc7
+            docker exec mmseg mim install mmdet>=3.0.0
+            docker exec mmseg apt-get update
+            docker exec mmseg apt-get install -y git
+            docker exec mmseg pip install -r requirements/tests.txt -r requirements/optional.txt
+            docker exec mmseg python -m pip install albumentations>=0.3.2 --no-binary qudida,albumentations
+      - run:
+          name: Build and install
+          command: |
+            docker exec mmseg pip install -e .
+      - run:
+          name: Run unittests but skip timm unittests
+          command: |
+            docker exec mmseg pytest tests/ --ignore tests/test_models/test_backbones/test_timm_backbone.py --ignore tests/test_models/test_backbones/test_timm_backbone.py --ignore tests/test_apis/test_rs_inferencer.py
+workflows:
+  pr_stage_lint:
+    when: << pipeline.parameters.lint_only >>
+    jobs:
+      - lint:
+          name: lint
+          filters:
+            branches:
+              ignore:
+                - dev-1.x
+                - main
+  pr_stage_test:
+    when:
+      not:
+        << pipeline.parameters.lint_only >>
+    jobs:
+      - lint:
+          name: lint
+          filters:
+            branches:
+              ignore:
+                - dev-1.x
+                - main
+      - build_cpu:
+          name: minimum_version_cpu
+          torch: 1.8.1
+          torchvision: 0.9.1
+          python: "3.7"
+          requires:
+            - lint
+      - build_cpu:
+          name: maximum_version_cpu
+          # TODO: Fix torch 1.13 forward crush
+          torch: 1.12.0
+          torchvision: 0.13.0
+          python: 3.9.0
+          requires:
+            - minimum_version_cpu
+      - hold:
+          type: approval
+          requires:
+            - maximum_version_cpu
+      - build_cuda:
+          name: mainstream_version_gpu
+          torch: 1.8.1
+          # Use double quotation mark to explicitly specify its type
+          # as string instead of number
+          cuda: "10.2"
+          requires:
+            - hold
+  merge_stage_test:
+    when:
+      not:
+        << pipeline.parameters.lint_only >>
+    jobs:
+      - build_cuda:
+          name: minimum_version_gpu
+          torch: 1.8.1
+          # Use double quotation mark to explicitly specify its type
+          # as string instead of number
+          cuda: "10.2"
+          filters:
+            branches:
+              only:
+                - dev-1.x
+                - main
diff --git a/mmsegmentation/.dev_scripts/batch_test_list.py b/mmsegmentation/.dev_scripts/batch_test_list.py
new file mode 100644
index 0000000..0d096ed
--- /dev/null
+++ b/mmsegmentation/.dev_scripts/batch_test_list.py
@@ -0,0 +1,133 @@
+# yapf: disable
+# Inference Speed is tested on NVIDIA V100
+hrnet = [
+    dict(
+        config='configs/hrnet/fcn_hr18s_4xb4-160k_ade20k-512x512.py',
+        checkpoint='fcn_hr18s_512x512_160k_ade20k_20200614_214413-870f65ac.pth', # noqa
+        eval='mIoU',
+        metric=dict(mIoU=33.0),
+    ),
+    dict(
+        config='configs/hrnet/fcn_hr18s_4xb2-160k_cityscapes-512x1024.py',
+        checkpoint='fcn_hr18s_512x1024_160k_cityscapes_20200602_190901-4a0797ea.pth', # noqa
+        eval='mIoU',
+        metric=dict(mIoU=76.31),
+    ),
+    dict(
+        config='configs/hrnet/fcn_hr48_4xb4-160k_ade20k-512x512.py',
+        checkpoint='fcn_hr48_512x512_160k_ade20k_20200614_214407-a52fc02c.pth',
+        eval='mIoU',
+        metric=dict(mIoU=42.02),
+    ),
+    dict(
+        config='configs/hrnet/fcn_hr48_4xb2-160k_cityscapes-512x1024.py',
+        checkpoint='fcn_hr48_512x1024_160k_cityscapes_20200602_190946-59b7973e.pth', # noqa
+        eval='mIoU',
+        metric=dict(mIoU=80.65),
+    ),
+]
+pspnet = [
+    dict(
+        config='configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py',
+        checkpoint='pspnet_r50-d8_512x1024_80k_cityscapes_20200606_112131-2376f12b.pth', # noqa
+        eval='mIoU',
+        metric=dict(mIoU=78.55),
+    ),
+    dict(
+        config='configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-512x1024.py',
+        checkpoint='pspnet_r101-d8_512x1024_80k_cityscapes_20200606_112211-e1e1100f.pth', # noqa
+        eval='mIoU',
+        metric=dict(mIoU=79.76),
+    ),
+    dict(
+        config='configs/pspnet/pspnet_r101-d8_4xb4-160k_ade20k-512x512.py',
+        checkpoint='pspnet_r101-d8_512x512_160k_ade20k_20200615_100650-967c316f.pth', # noqa
+        eval='mIoU',
+        metric=dict(mIoU=44.39),
+    ),
+    dict(
+        config='configs/pspnet/pspnet_r50-d8_4xb4-160k_ade20k-512x512.py',
+        checkpoint='pspnet_r50-d8_512x512_160k_ade20k_20200615_184358-1890b0bd.pth', # noqa
+        eval='mIoU',
+        metric=dict(mIoU=42.48),
+    ),
+]
+resnest = [
+    dict(
+        config='configs/resnest/resnest_s101-d8_pspnet_4xb4-160k_ade20k-512x512.py', # noqa
+        checkpoint='pspnet_s101-d8_512x512_160k_ade20k_20200807_145416-a6daa92a.pth', # noqa
+        eval='mIoU',
+        metric=dict(mIoU=45.44),
+    ),
+    dict(
+        config='configs/resnest/resnest_s101-d8_pspnet_4xb2-80k_cityscapes512x1024.py', # noqa
+        checkpoint='pspnet_s101-d8_512x1024_80k_cityscapes_20200807_140631-c75f3b99.pth', # noqa
+        eval='mIoU',
+        metric=dict(mIoU=78.57),
+    ),
+]
+fastscnn = [
+    dict(
+        config='configs/fastscnn/fast_scnn_8xb4-160k_cityscapes-512x1024.py',
+        checkpoint='fast_scnn_8x4_160k_lr0.12_cityscapes-0cec9937.pth',
+        eval='mIoU',
+        metric=dict(mIoU=70.96),
+    )
+]
+deeplabv3plus = [
+    dict(
+        config='configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-769x769.py', # noqa
+        checkpoint='deeplabv3plus_r101-d8_769x769_80k_cityscapes_20200607_000405-a7573d20.pth', # noqa
+        eval='mIoU',
+        metric=dict(mIoU=80.98),
+    ),
+    dict(
+        config='configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024.py', # noqa
+        checkpoint='deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143-068fcfe9.pth', # noqa
+        eval='mIoU',
+        metric=dict(mIoU=80.97),
+    ),
+    dict(
+        config='configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py', # noqa
+        checkpoint='deeplabv3plus_r50-d8_512x1024_80k_cityscapes_20200606_114049-f9fb496d.pth', # noqa
+        eval='mIoU',
+        metric=dict(mIoU=80.09),
+    ),
+    dict(
+        config='configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py', # noqa
+        checkpoint='deeplabv3plus_r50-d8_769x769_80k_cityscapes_20200606_210233-0e9dfdc4.pth', # noqa
+        eval='mIoU',
+        metric=dict(mIoU=79.83),
+    ),
+]
+vit = [
+    dict(
+        config='configs/vit/vit_vit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py', # noqa
+        checkpoint='upernet_vit-b16_ln_mln_512x512_160k_ade20k-f444c077.pth',
+        eval='mIoU',
+        metric=dict(mIoU=47.73),
+    ),
+    dict(
+        config='configs/vit/vit_deit-s16-ln_mln_upernet_512x512_160k_ade20k-512x512.py', # noqa
+        checkpoint='upernet_deit-s16_ln_mln_512x512_160k_ade20k-c0cd652f.pth',
+        eval='mIoU',
+        metric=dict(mIoU=43.52),
+    ),
+]
+fp16 = [
+    dict(
+        config='configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py', # noqa
+        checkpoint='deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230920-f1104f4b.pth', # noqa
+        eval='mIoU',
+        metric=dict(mIoU=80.46),
+    )
+]
+swin = [
+    dict(
+        config='configs/swin/swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py', # noqa
+        checkpoint='upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210531_112542-e380ad3e.pth', # noqa
+        eval='mIoU',
+        metric=dict(mIoU=44.41),
+    )
+]
+# yapf: enable
diff --git a/mmsegmentation/.dev_scripts/batch_train_list.txt b/mmsegmentation/.dev_scripts/batch_train_list.txt
new file mode 100644
index 0000000..6c1a122
--- /dev/null
+++ b/mmsegmentation/.dev_scripts/batch_train_list.txt
@@ -0,0 +1,19 @@
+configs/hrnet/fcn_hr18s_4xb4-160k_ade20k-512x512.py
+configs/hrnet/fcn_hr18s_4xb2-160k_cityscapes-512x1024.py
+configs/hrnet/fcn_hr48_4xb4-160k_ade20k-512x512.py
+configs/hrnet/fcn_hr48_4xb2-160k_cityscapes-512x1024.py
+configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
+configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
+configs/pspnet/pspnet_r101-d8_4xb4-160k_ade20k-512x512.py
+configs/pspnet/pspnet_r50-d8_4xb4-160k_ade20k-512x512.py
+configs/resnest/resnest_s101-d8_pspnet_4xb4-160k_ade20k-512x512.py
+configs/resnest/resnest_s101-d8_pspnet_4xb2-80k_cityscapes512x1024.py
+configs/fastscnn/fast_scnn_8xb4-160k_cityscapes-512x1024.py
+configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-769x769.py
+configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024.py
+configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py
+configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py
+configs/vit/vit_vit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
+configs/vit/vit_deit-s16-ln_mln_upernet_512x512_160k_ade20k-512x512.py
+configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
+configs/swin/swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
diff --git a/mmsegmentation/.dev_scripts/benchmark_evaluation.sh b/mmsegmentation/.dev_scripts/benchmark_evaluation.sh
new file mode 100755
index 0000000..68dc272
--- /dev/null
+++ b/mmsegmentation/.dev_scripts/benchmark_evaluation.sh
@@ -0,0 +1,41 @@
+PARTITION=$1
+CHECKPOINT_DIR=$2
+
+echo 'configs/hrnet/fcn_hr18s_512x512_160k_ade20k.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION fcn_hr18s_512x512_160k_ade20k configs/hrnet/fcn_hr18s_512x512_160k_ade20k.py $CHECKPOINT_DIR/fcn_hr18s_512x512_160k_ade20k_20200614_214413-870f65ac.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/fcn_hr18s_512x512_160k_ade20k --cfg-options dist_params.port=28171 &
+echo 'configs/hrnet/fcn_hr18s_512x1024_160k_cityscapes.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION fcn_hr18s_512x1024_160k_cityscapes configs/hrnet/fcn_hr18s_512x1024_160k_cityscapes.py $CHECKPOINT_DIR/fcn_hr18s_512x1024_160k_cityscapes_20200602_190901-4a0797ea.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/fcn_hr18s_512x1024_160k_cityscapes --cfg-options dist_params.port=28172 &
+echo 'configs/hrnet/fcn_hr48_512x512_160k_ade20k.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION fcn_hr48_512x512_160k_ade20k configs/hrnet/fcn_hr48_512x512_160k_ade20k.py $CHECKPOINT_DIR/fcn_hr48_512x512_160k_ade20k_20200614_214407-a52fc02c.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/fcn_hr48_512x512_160k_ade20k --cfg-options dist_params.port=28173 &
+echo 'configs/hrnet/fcn_hr48_512x1024_160k_cityscapes.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION fcn_hr48_512x1024_160k_cityscapes configs/hrnet/fcn_hr48_512x1024_160k_cityscapes.py $CHECKPOINT_DIR/fcn_hr48_512x1024_160k_cityscapes_20200602_190946-59b7973e.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/fcn_hr48_512x1024_160k_cityscapes --cfg-options dist_params.port=28174 &
+echo 'configs/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION pspnet_r50-d8_512x1024_80k_cityscapes configs/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes.py $CHECKPOINT_DIR/pspnet_r50-d8_512x1024_80k_cityscapes_20200606_112131-2376f12b.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/pspnet_r50-d8_512x1024_80k_cityscapes --cfg-options dist_params.port=28175 &
+echo 'configs/pspnet/pspnet_r101-d8_512x1024_80k_cityscapes.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION pspnet_r101-d8_512x1024_80k_cityscapes configs/pspnet/pspnet_r101-d8_512x1024_80k_cityscapes.py $CHECKPOINT_DIR/pspnet_r101-d8_512x1024_80k_cityscapes_20200606_112211-e1e1100f.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/pspnet_r101-d8_512x1024_80k_cityscapes --cfg-options dist_params.port=28176 &
+echo 'configs/pspnet/pspnet_r101-d8_512x512_160k_ade20k.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION pspnet_r101-d8_512x512_160k_ade20k configs/pspnet/pspnet_r101-d8_512x512_160k_ade20k.py $CHECKPOINT_DIR/pspnet_r101-d8_512x512_160k_ade20k_20200615_100650-967c316f.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/pspnet_r101-d8_512x512_160k_ade20k --cfg-options dist_params.port=28177 &
+echo 'configs/pspnet/pspnet_r50-d8_512x512_160k_ade20k.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION pspnet_r50-d8_512x512_160k_ade20k configs/pspnet/pspnet_r50-d8_512x512_160k_ade20k.py $CHECKPOINT_DIR/pspnet_r50-d8_512x512_160k_ade20k_20200615_184358-1890b0bd.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/pspnet_r50-d8_512x512_160k_ade20k --cfg-options dist_params.port=28178 &
+echo 'configs/resnest/pspnet_s101-d8_512x512_160k_ade20k.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION pspnet_s101-d8_512x512_160k_ade20k configs/resnest/pspnet_s101-d8_512x512_160k_ade20k.py $CHECKPOINT_DIR/pspnet_s101-d8_512x512_160k_ade20k_20200807_145416-a6daa92a.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/pspnet_s101-d8_512x512_160k_ade20k --cfg-options dist_params.port=28179 &
+echo 'configs/resnest/pspnet_s101-d8_512x1024_80k_cityscapes.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION pspnet_s101-d8_512x1024_80k_cityscapes configs/resnest/pspnet_s101-d8_512x1024_80k_cityscapes.py $CHECKPOINT_DIR/pspnet_s101-d8_512x1024_80k_cityscapes_20200807_140631-c75f3b99.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/pspnet_s101-d8_512x1024_80k_cityscapes --cfg-options dist_params.port=28180 &
+echo 'configs/fastscnn/fast_scnn_lr0.12_8x4_160k_cityscapes.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION fast_scnn_lr0.12_8x4_160k_cityscapes configs/fastscnn/fast_scnn_lr0.12_8x4_160k_cityscapes.py $CHECKPOINT_DIR/fast_scnn_8x4_160k_lr0.12_cityscapes-0cec9937.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/fast_scnn_lr0.12_8x4_160k_cityscapes --cfg-options dist_params.port=28181 &
+echo 'configs/deeplabv3plus/deeplabv3plus_r101-d8_769x769_80k_cityscapes.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION deeplabv3plus_r101-d8_769x769_80k_cityscapes configs/deeplabv3plus/deeplabv3plus_r101-d8_769x769_80k_cityscapes.py $CHECKPOINT_DIR/deeplabv3plus_r101-d8_769x769_80k_cityscapes_20200607_000405-a7573d20.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/deeplabv3plus_r101-d8_769x769_80k_cityscapes --cfg-options dist_params.port=28182 &
+echo 'configs/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_80k_cityscapes.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION deeplabv3plus_r101-d8_512x1024_80k_cityscapes configs/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_80k_cityscapes.py $CHECKPOINT_DIR/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143-068fcfe9.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/deeplabv3plus_r101-d8_512x1024_80k_cityscapes --cfg-options dist_params.port=28183 &
+echo 'configs/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_80k_cityscapes.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION deeplabv3plus_r50-d8_512x1024_80k_cityscapes configs/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_80k_cityscapes.py $CHECKPOINT_DIR/deeplabv3plus_r50-d8_512x1024_80k_cityscapes_20200606_114049-f9fb496d.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/deeplabv3plus_r50-d8_512x1024_80k_cityscapes --cfg-options dist_params.port=28184 &
+echo 'configs/deeplabv3plus/deeplabv3plus_r50-d8_769x769_80k_cityscapes.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION deeplabv3plus_r50-d8_769x769_80k_cityscapes configs/deeplabv3plus/deeplabv3plus_r50-d8_769x769_80k_cityscapes.py $CHECKPOINT_DIR/deeplabv3plus_r50-d8_769x769_80k_cityscapes_20200606_210233-0e9dfdc4.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/deeplabv3plus_r50-d8_769x769_80k_cityscapes --cfg-options dist_params.port=28185 &
+echo 'configs/vit/upernet_vit-b16_ln_mln_512x512_160k_ade20k.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION upernet_vit-b16_ln_mln_512x512_160k_ade20k configs/vit/upernet_vit-b16_ln_mln_512x512_160k_ade20k.py $CHECKPOINT_DIR/upernet_vit-b16_ln_mln_512x512_160k_ade20k-f444c077.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/upernet_vit-b16_ln_mln_512x512_160k_ade20k --cfg-options dist_params.port=28186 &
+echo 'configs/vit/upernet_deit-s16_ln_mln_512x512_160k_ade20k.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION upernet_deit-s16_ln_mln_512x512_160k_ade20k configs/vit/upernet_deit-s16_ln_mln_512x512_160k_ade20k.py $CHECKPOINT_DIR/upernet_deit-s16_ln_mln_512x512_160k_ade20k-c0cd652f.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/upernet_deit-s16_ln_mln_512x512_160k_ade20k --cfg-options dist_params.port=28187 &
+echo 'configs/deeplabv3plus/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes configs/deeplabv3plus/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes.py $CHECKPOINT_DIR/deeplabv3plus_r101-d8_512x1024_80k_fp16_cityscapes-cc58bc8d.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/deeplabv3plus_r101-d8_512x1024_80k_fp16_cityscapes --cfg-options dist_params.port=28188 &
+echo 'configs/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K configs/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K.py $CHECKPOINT_DIR/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210531_112542-e380ad3e.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K --cfg-options dist_params.port=28189 &
diff --git a/mmsegmentation/.dev_scripts/benchmark_full_models.txt b/mmsegmentation/.dev_scripts/benchmark_full_models.txt
new file mode 100644
index 0000000..64b968d
--- /dev/null
+++ b/mmsegmentation/.dev_scripts/benchmark_full_models.txt
@@ -0,0 +1,57 @@
+ann/ann_r50-d8_4xb2-40k_cityscapes-512x1024.py
+apcnet/apcnet_r50-d8_4xb4-80k_ade20k-512x512.py
+beit/beit-large_upernet_8xb1-amp-160k_ade20k-640x640.py
+bisenetv1/bisenetv1_r18-d32_4xb4-160k_coco-stuff164k-512x512.py
+bisenetv2/bisenetv2_fcn_4xb4-ohem-160k_cityscapes-1024x1024.py
+ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
+cgnet/cgnet_fcn_4xb4-60k_cityscapes-680x680.py
+convnext/convnext-tiny_upernet_8xb2-amp-160k_ade20k-512x512.py
+danet/danet_r50-d8_4xb2-40k_cityscapes-512x1024.py
+deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py
+deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-769x769.py
+dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
+dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-512x1024.py
+dpt/dpt_vit-b16_8xb2-160k_ade20k-512x512.py
+emanet/eemanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
+encnet/encnet_r50-d8_4xb4-80k_ade20k-512x512.py
+erfnet/erfnet_fcn_4xb4-160k_cityscapes-512x1024.py
+fastfcn/fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024.py
+fastscnn/fast_scnn_8xb4-160k_cityscapes-512x1024.py
+fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py
+gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-769x769.py
+hrnet/fcn_hr18s_4xb4-80k_ade20k-512x512.py
+icnet/icnet_r50-d8_4xb2-80k_cityscapes-832x832.py
+isanet/isanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
+knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-640x640.py
+mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512.py
+mask2former/mask2former_r50_8xb2-90k_cityscapes-512x1024.py
+mask2former/mask2former_swin-t_8xb2-90k_cityscapes-512x1024.py
+mask2former/mask2former_swin-s_8xb2-160k_ade20k-512x512.py
+mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py
+maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512.py
+maskformer/maskformer_r101-d32_8xb2-160k_ade20k-512x512.py
+maskformer/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512.py
+maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512.py
+mobilenet_v2/mobilenet-v2-d8_pspnet_4xb2-80k_cityscapes-512x1024.py
+mobilenet_v3/mobilenet-v3-d8-scratch_lraspp_4xb4-320k_cityscapes-512x1024.py
+nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-512x1024.py
+ocrnet/ocrnet_hr18_4xb4-80k_ade20k-512x512.py
+pidnet/pidnet-l_2xb6-120k_1024x1024-cityscapes.py
+point_rend/pointrend_r50_4xb2-80k_cityscapes-512x1024.py
+poolformer/fpn_poolformer_m48_8xb4-40k_ade20k-512x512.py
+psanet/psanet_r101-d8_4xb4-80k_ade20k-512x512.py
+pspnet/pspnet_r50-d8-rsb_4xb2-adamw-80k_cityscapes-512x1024.py
+resnest/resnest_s101-d8_deeplabv3_4xb4-160k_ade20k-512x512.py
+segformer/segformer_mit-b5_8xb1-160k_cityscapes-1024x1024.py
+segformer/segformer_mit-b5_8xb2-160k_ade20k-512x512.py
+segmenter/segmenter_vit-t_mask_8xb1-160k_ade20k-512x512.py
+segnext/segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512.py
+sem_fpn/fpn_r101_4xb2-80k_cityscapes-512x1024.py
+setr/setr_vit-l-mla_8xb1-160k_ade20k-512x512.py
+stdc/stdc1_in1k-pre_4xb12-80k_cityscapes-512x1024.py
+swin/swin-small-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
+twins/twins_pcpvt-s_uperhead_8xb4-160k_ade20k-512x512.py
+unet/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py
+upernet/upernet_r50_4xb2-40k_cityscapes-769x769.py
+vit/vit_deit-s16_upernet_8xb2-80k_ade20k-512x512.py
+san/san-vit-b16_coco-stuff164k-640x640.py
diff --git a/mmsegmentation/.dev_scripts/benchmark_inference.py b/mmsegmentation/.dev_scripts/benchmark_inference.py
new file mode 100644
index 0000000..b17c144
--- /dev/null
+++ b/mmsegmentation/.dev_scripts/benchmark_inference.py
@@ -0,0 +1,149 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import hashlib
+import logging
+import os
+import os.path as osp
+import warnings
+from argparse import ArgumentParser
+
+import requests
+from mmengine import Config
+
+from mmseg.apis import inference_model, init_model, show_result_pyplot
+from mmseg.utils import get_root_logger
+
+# ignore warnings when segmentors inference
+warnings.filterwarnings('ignore')
+
+
+def download_checkpoint(checkpoint_name, model_name, config_name, collect_dir):
+    """Download checkpoint and check if hash code is true."""
+    url = f'https://download.openmmlab.com/mmsegmentation/v0.5/{model_name}/{config_name}/{checkpoint_name}'  # noqa
+
+    r = requests.get(url)
+    assert r.status_code != 403, f'{url} Access denied.'
+
+    with open(osp.join(collect_dir, checkpoint_name), 'wb') as code:
+        code.write(r.content)
+
+    true_hash_code = osp.splitext(checkpoint_name)[0].split('-')[1]
+
+    # check hash code
+    with open(osp.join(collect_dir, checkpoint_name), 'rb') as fp:
+        sha256_cal = hashlib.sha256()
+        sha256_cal.update(fp.read())
+        cur_hash_code = sha256_cal.hexdigest()[:8]
+
+    assert true_hash_code == cur_hash_code, f'{url} download failed, '
+    'incomplete downloaded file or url invalid.'
+
+    if cur_hash_code != true_hash_code:
+        os.remove(osp.join(collect_dir, checkpoint_name))
+
+
+def parse_args():
+    parser = ArgumentParser()
+    parser.add_argument('config', help='test config file path')
+    parser.add_argument('checkpoint_root', help='Checkpoint file root path')
+    parser.add_argument(
+        '-i', '--img', default='demo/demo.png', help='Image file')
+    parser.add_argument('-a', '--aug', action='store_true', help='aug test')
+    parser.add_argument('-m', '--model-name', help='model name to inference')
+    parser.add_argument(
+        '-s', '--show', action='store_true', help='show results')
+    parser.add_argument(
+        '-d', '--device', default='cuda:0', help='Device used for inference')
+    args = parser.parse_args()
+    return args
+
+
+def inference(config_name, checkpoint, args, logger=None):
+    cfg = Config.fromfile(config_name)
+    if args.aug:
+        if 'flip' in cfg.data.test.pipeline[
+                1] and 'img_scale' in cfg.data.test.pipeline[1]:
+            cfg.data.test.pipeline[1].img_ratios = [
+                0.5, 0.75, 1.0, 1.25, 1.5, 1.75
+            ]
+            cfg.data.test.pipeline[1].flip = True
+        else:
+            if logger is not None:
+                logger.error(f'{config_name}: unable to start aug test')
+            else:
+                print(f'{config_name}: unable to start aug test', flush=True)
+
+    model = init_model(cfg, checkpoint, device=args.device)
+    # test a single image
+    result = inference_model(model, args.img)
+
+    # show the results
+    if args.show:
+        show_result_pyplot(model, args.img, result)
+    return result
+
+
+# Sample test whether the inference code is correct
+def main(args):
+    config = Config.fromfile(args.config)
+
+    if not os.path.exists(args.checkpoint_root):
+        os.makedirs(args.checkpoint_root, 0o775)
+
+    # test single model
+    if args.model_name:
+        if args.model_name in config:
+            model_infos = config[args.model_name]
+            if not isinstance(model_infos, list):
+                model_infos = [model_infos]
+            for model_info in model_infos:
+                config_name = model_info['config'].strip()
+                print(f'processing: {config_name}', flush=True)
+                checkpoint = osp.join(args.checkpoint_root,
+                                      model_info['checkpoint'].strip())
+                try:
+                    # build the model from a config file and a checkpoint file
+                    inference(config_name, checkpoint, args)
+                except Exception:
+                    print(f'{config_name} test failed!')
+                    continue
+                return
+        else:
+            raise RuntimeError('model name input error.')
+
+    # test all model
+    logger = get_root_logger(
+        log_file='benchmark_inference_image.log', log_level=logging.ERROR)
+
+    for model_name in config:
+        model_infos = config[model_name]
+
+        if not isinstance(model_infos, list):
+            model_infos = [model_infos]
+        for model_info in model_infos:
+            print('processing: ', model_info['config'], flush=True)
+            config_path = model_info['config'].strip()
+            config_name = osp.splitext(osp.basename(config_path))[0]
+            checkpoint_name = model_info['checkpoint'].strip()
+            checkpoint = osp.join(args.checkpoint_root, checkpoint_name)
+
+            # ensure checkpoint exists
+            try:
+                if not osp.exists(checkpoint):
+                    download_checkpoint(checkpoint_name, model_name,
+                                        config_name.rstrip('.py'),
+                                        args.checkpoint_root)
+            except Exception:
+                logger.error(f'{checkpoint_name} download error')
+                continue
+
+            # test model inference with checkpoint
+            try:
+                # build the model from a config file and a checkpoint file
+                inference(config_path, checkpoint, args, logger)
+            except Exception as e:
+                logger.error(f'{config_path} " : {repr(e)}')
+
+
+if __name__ == '__main__':
+    args = parse_args()
+    main(args)
diff --git a/mmsegmentation/.dev_scripts/benchmark_options.py b/mmsegmentation/.dev_scripts/benchmark_options.py
new file mode 100644
index 0000000..51909a0
--- /dev/null
+++ b/mmsegmentation/.dev_scripts/benchmark_options.py
@@ -0,0 +1,10 @@
+third_part_libs = [
+    'pip install mmengine',
+    'pip install mmcv>=2.0.0',
+    'pip install mmcls==1.0.0rc6',
+    'pip install mmdet==3.0.0',
+    'pip install -r requirements.txt',
+    'pip install timm',
+]
+
+default_floating_range = 0.5
diff --git a/mmsegmentation/.dev_scripts/benchmark_train.sh b/mmsegmentation/.dev_scripts/benchmark_train.sh
new file mode 100755
index 0000000..cde47a0
--- /dev/null
+++ b/mmsegmentation/.dev_scripts/benchmark_train.sh
@@ -0,0 +1,40 @@
+PARTITION=$1
+
+echo 'configs/hrnet/fcn_hr18s_512x512_160k_ade20k.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION fcn_hr18s_512x512_160k_ade20k configs/hrnet/fcn_hr18s_512x512_160k_ade20k.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24727 --work-dir work_dirs/hrnet/fcn_hr18s_512x512_160k_ade20k >/dev/null &
+echo 'configs/hrnet/fcn_hr18s_512x1024_160k_cityscapes.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION fcn_hr18s_512x1024_160k_cityscapes configs/hrnet/fcn_hr18s_512x1024_160k_cityscapes.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24728 --work-dir work_dirs/hrnet/fcn_hr18s_512x1024_160k_cityscapes >/dev/null &
+echo 'configs/hrnet/fcn_hr48_512x512_160k_ade20k.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION fcn_hr48_512x512_160k_ade20k configs/hrnet/fcn_hr48_512x512_160k_ade20k.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24729 --work-dir work_dirs/hrnet/fcn_hr48_512x512_160k_ade20k >/dev/null &
+echo 'configs/hrnet/fcn_hr48_512x1024_160k_cityscapes.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION fcn_hr48_512x1024_160k_cityscapes configs/hrnet/fcn_hr48_512x1024_160k_cityscapes.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24730 --work-dir work_dirs/hrnet/fcn_hr48_512x1024_160k_cityscapes >/dev/null &
+echo 'configs/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION pspnet_r50-d8_512x1024_80k_cityscapes configs/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24731 --work-dir work_dirs/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes >/dev/null &
+echo 'configs/pspnet/pspnet_r101-d8_512x1024_80k_cityscapes.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION pspnet_r101-d8_512x1024_80k_cityscapes configs/pspnet/pspnet_r101-d8_512x1024_80k_cityscapes.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24732 --work-dir work_dirs/pspnet/pspnet_r101-d8_512x1024_80k_cityscapes >/dev/null &
+echo 'configs/pspnet/pspnet_r101-d8_512x512_160k_ade20k.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION pspnet_r101-d8_512x512_160k_ade20k configs/pspnet/pspnet_r101-d8_512x512_160k_ade20k.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24733 --work-dir work_dirs/pspnet/pspnet_r101-d8_512x512_160k_ade20k >/dev/null &
+echo 'configs/pspnet/pspnet_r50-d8_512x512_160k_ade20k.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION pspnet_r50-d8_512x512_160k_ade20k configs/pspnet/pspnet_r50-d8_512x512_160k_ade20k.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24734 --work-dir work_dirs/pspnet/pspnet_r50-d8_512x512_160k_ade20k >/dev/null &
+echo 'configs/resnest/pspnet_s101-d8_512x512_160k_ade20k.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION pspnet_s101-d8_512x512_160k_ade20k configs/resnest/pspnet_s101-d8_512x512_160k_ade20k.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24735 --work-dir work_dirs/resnest/pspnet_s101-d8_512x512_160k_ade20k >/dev/null &
+echo 'configs/resnest/pspnet_s101-d8_512x1024_80k_cityscapes.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION pspnet_s101-d8_512x1024_80k_cityscapes configs/resnest/pspnet_s101-d8_512x1024_80k_cityscapes.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24736 --work-dir work_dirs/resnest/pspnet_s101-d8_512x1024_80k_cityscapes >/dev/null &
+echo 'configs/fastscnn/fast_scnn_lr0.12_8x4_160k_cityscapes.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION fast_scnn_lr0.12_8x4_160k_cityscapes configs/fastscnn/fast_scnn_lr0.12_8x4_160k_cityscapes.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24737 --work-dir work_dirs/fastscnn/fast_scnn_lr0.12_8x4_160k_cityscapes >/dev/null &
+echo 'configs/deeplabv3plus/deeplabv3plus_r101-d8_769x769_80k_cityscapes.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION deeplabv3plus_r101-d8_769x769_80k_cityscapes configs/deeplabv3plus/deeplabv3plus_r101-d8_769x769_80k_cityscapes.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24738 --work-dir work_dirs/deeplabv3plus/deeplabv3plus_r101-d8_769x769_80k_cityscapes >/dev/null &
+echo 'configs/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_80k_cityscapes.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION deeplabv3plus_r101-d8_512x1024_80k_cityscapes configs/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_80k_cityscapes.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24739 --work-dir work_dirs/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_80k_cityscapes >/dev/null &
+echo 'configs/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_80k_cityscapes.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION deeplabv3plus_r50-d8_512x1024_80k_cityscapes configs/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_80k_cityscapes.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24740 --work-dir work_dirs/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_80k_cityscapes >/dev/null &
+echo 'configs/deeplabv3plus/deeplabv3plus_r50-d8_769x769_80k_cityscapes.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION deeplabv3plus_r50-d8_769x769_80k_cityscapes configs/deeplabv3plus/deeplabv3plus_r50-d8_769x769_80k_cityscapes.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24741 --work-dir work_dirs/deeplabv3plus/deeplabv3plus_r50-d8_769x769_80k_cityscapes >/dev/null &
+echo 'configs/vit/upernet_vit-b16_ln_mln_512x512_160k_ade20k.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION upernet_vit-b16_ln_mln_512x512_160k_ade20k configs/vit/upernet_vit-b16_ln_mln_512x512_160k_ade20k.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24742 --work-dir work_dirs/vit/upernet_vit-b16_ln_mln_512x512_160k_ade20k >/dev/null &
+echo 'configs/vit/upernet_deit-s16_ln_mln_512x512_160k_ade20k.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION upernet_deit-s16_ln_mln_512x512_160k_ade20k configs/vit/upernet_deit-s16_ln_mln_512x512_160k_ade20k.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24743 --work-dir work_dirs/vit/upernet_deit-s16_ln_mln_512x512_160k_ade20k >/dev/null &
+echo 'configs/deeplabv3plus/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION deeplabv3plus_r101-d8_512x1024_80k_fp16_cityscapes configs/deeplabv3plus/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24744 --work-dir work_dirs/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_80k_fp16_cityscapes >/dev/null &
+echo 'configs/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K configs/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24745 --work-dir work_dirs/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K >/dev/null &
diff --git a/mmsegmentation/.dev_scripts/benchmark_train_models.txt b/mmsegmentation/.dev_scripts/benchmark_train_models.txt
new file mode 100644
index 0000000..01f279d
--- /dev/null
+++ b/mmsegmentation/.dev_scripts/benchmark_train_models.txt
@@ -0,0 +1,26 @@
+bisenetv1/bisenetv1_r18-d32_4xb4-160k_coco-stuff164k-512x512.py
+bisenetv2/bisenetv2_fcn_4xb4-ohem-160k_cityscapes-1024x1024.py
+deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py
+deeplabv3/deeplabv3_r101-d8_4xb4-160k_ade20k-512x512.py
+deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-769x769.py
+deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_ade20k-512x512.py
+hrnet/fcn_hr18s_4xb4-80k_ade20k-512x512.py
+hrnet/fcn_hr18_4xb2-160k_cityscapes-512x1024.py
+knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-512x512.py
+knet/knet-s3_r50-d8_pspnet_8xb2-adamw-80k_ade20k-512x512.py
+mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512.py
+mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py
+maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512.py
+mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py
+ocrnet/ocrnet_hr48_4xb4-80k_ade20k-512x512.py
+pidnet/pidnet-m_2xb6-120k_1024x1024-cityscapes.py
+pspnet/pspnet_r50-d8-rsb_4xb2-adamw-80k_cityscapes-512x1024.py
+pspnet/pspnet_r101-d8_4xb4-80k_ade20k-512x512.py
+segformer/segformer_mit-b5_8xb2-160k_ade20k-512x512.py
+segmenter/segmenter_vit-t_mask_8xb1-160k_ade20k-512x512.py
+segnext/segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512.py
+swin/swin-base-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
+twins/twins_pcpvt-l_uperhead_8xb2-160k_ade20k-512x512.py
+unet/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py
+upernet/upernet_r101_4xb2-40k_cityscapes-512x1024.py
+san/san-vit-b16_coco-stuff164k-640x640.py
diff --git a/mmsegmentation/.dev_scripts/check_urls.py b/mmsegmentation/.dev_scripts/check_urls.py
new file mode 100644
index 0000000..58a1354
--- /dev/null
+++ b/mmsegmentation/.dev_scripts/check_urls.py
@@ -0,0 +1,100 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import logging
+import os
+from argparse import ArgumentParser
+
+import requests
+import yaml as yml
+
+from mmseg.utils import get_root_logger
+
+
+def check_url(url):
+    """Check url response status.
+
+    Args:
+        url (str): url needed to check.
+
+    Returns:
+        int, bool: status code and check flag.
+    """
+    flag = True
+    r = requests.head(url)
+    status_code = r.status_code
+    if status_code == 403 or status_code == 404:
+        flag = False
+
+    return status_code, flag
+
+
+def parse_args():
+    parser = ArgumentParser('url valid check.')
+    parser.add_argument(
+        '-m',
+        '--model-name',
+        type=str,
+        help='Select the model needed to check')
+
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    model_name = args.model_name
+
+    # yml path generate.
+    # If model_name is not set, script will check all of the models.
+    if model_name is not None:
+        yml_list = [(model_name, f'configs/{model_name}/{model_name}.yml')]
+    else:
+        # check all
+        yml_list = [(x, f'configs/{x}/{x}.yml') for x in os.listdir('configs/')
+                    if x != '_base_']
+
+    logger = get_root_logger(log_file='url_check.log', log_level=logging.ERROR)
+
+    for model_name, yml_path in yml_list:
+        # Default yaml loader unsafe.
+        model_infos = yml.load(open(yml_path), Loader=yml.CLoader)['Models']
+        for model_info in model_infos:
+            config_name = model_info['Name']
+            checkpoint_url = model_info['Weights']
+            # checkpoint url check
+            status_code, flag = check_url(checkpoint_url)
+            if flag:
+                logger.info(f'checkpoint | {config_name} | {checkpoint_url} | '
+                            f'{status_code} valid')
+            else:
+                logger.error(
+                    f'checkpoint | {config_name} | {checkpoint_url} | '
+                    f'{status_code} | error')
+            # log_json check
+            checkpoint_name = checkpoint_url.split('/')[-1]
+            model_time = '-'.join(checkpoint_name.split('-')[:-1]).replace(
+                f'{config_name}_', '')
+            # two style of log_json name
+            # use '_' to link model_time (will be deprecated)
+            log_json_url_1 = f'https://download.openmmlab.com/mmsegmentation/v0.5/{model_name}/{config_name}/{config_name}_{model_time}.log.json'  # noqa
+            status_code_1, flag_1 = check_url(log_json_url_1)
+            # use '-' to link model_time
+            log_json_url_2 = f'https://download.openmmlab.com/mmsegmentation/v0.5/{model_name}/{config_name}/{config_name}-{model_time}.log.json'  # noqa
+            status_code_2, flag_2 = check_url(log_json_url_2)
+            if flag_1 or flag_2:
+                if flag_1:
+                    logger.info(
+                        f'log.json | {config_name} | {log_json_url_1} | '
+                        f'{status_code_1} | valid')
+                else:
+                    logger.info(
+                        f'log.json | {config_name} | {log_json_url_2} | '
+                        f'{status_code_2} | valid')
+            else:
+                logger.error(
+                    f'log.json | {config_name} | {log_json_url_1} & '
+                    f'{log_json_url_2} | {status_code_1} & {status_code_2} | '
+                    'error')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/.dev_scripts/gather_benchmark_evaluation_results.py b/mmsegmentation/.dev_scripts/gather_benchmark_evaluation_results.py
new file mode 100644
index 0000000..fec83f1
--- /dev/null
+++ b/mmsegmentation/.dev_scripts/gather_benchmark_evaluation_results.py
@@ -0,0 +1,91 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import glob
+import os.path as osp
+
+from mmengine import Config
+from mmengine.fileio import dump, load
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Gather benchmarked model evaluation results')
+    parser.add_argument('config', help='test config file path')
+    parser.add_argument(
+        'root',
+        type=str,
+        help='root path of benchmarked models to be gathered')
+    parser.add_argument(
+        '--out',
+        type=str,
+        default='benchmark_evaluation_info.json',
+        help='output path of gathered metrics and compared '
+        'results to be stored')
+
+    args = parser.parse_args()
+    return args
+
+
+if __name__ == '__main__':
+    args = parse_args()
+
+    root_path = args.root
+    metrics_out = args.out
+    result_dict = {}
+
+    cfg = Config.fromfile(args.config)
+
+    for model_key in cfg:
+        model_infos = cfg[model_key]
+        if not isinstance(model_infos, list):
+            model_infos = [model_infos]
+        for model_info in model_infos:
+            previous_metrics = model_info['metric']
+            config = model_info['config'].strip()
+            fname, _ = osp.splitext(osp.basename(config))
+
+            # Load benchmark evaluation json
+            metric_json_dir = osp.join(root_path, fname)
+            if not osp.exists(metric_json_dir):
+                print(f'{metric_json_dir} not existed.')
+                continue
+
+            json_list = glob.glob(osp.join(metric_json_dir, '*.json'))
+            if len(json_list) == 0:
+                print(f'There is no eval json in {metric_json_dir}.')
+                continue
+
+            log_json_path = list(sorted(json_list))[-1]
+            metric = load(log_json_path)
+            if config not in metric.get('config', {}):
+                print(f'{config} not included in {log_json_path}')
+                continue
+
+            # Compare between new benchmark results and previous metrics
+            differential_results = dict()
+            new_metrics = dict()
+            for record_metric_key in previous_metrics:
+                if record_metric_key not in metric['metric']:
+                    raise KeyError('record_metric_key not exist, please '
+                                   'check your config')
+                old_metric = previous_metrics[record_metric_key]
+                new_metric = round(metric['metric'][record_metric_key] * 100,
+                                   2)
+
+                differential = new_metric - old_metric
+                flag = '+' if differential > 0 else '-'
+                differential_results[
+                    record_metric_key] = f'{flag}{abs(differential):.2f}'
+                new_metrics[record_metric_key] = new_metric
+
+            result_dict[config] = dict(
+                differential=differential_results,
+                previous=previous_metrics,
+                new=new_metrics)
+
+    if metrics_out:
+        dump(result_dict, metrics_out, indent=4)
+    print('===================================')
+    for config_name, metrics in result_dict.items():
+        print(config_name, metrics)
+    print('===================================')
diff --git a/mmsegmentation/.dev_scripts/gather_benchmark_train_results.py b/mmsegmentation/.dev_scripts/gather_benchmark_train_results.py
new file mode 100644
index 0000000..f801a0d
--- /dev/null
+++ b/mmsegmentation/.dev_scripts/gather_benchmark_train_results.py
@@ -0,0 +1,100 @@
+import argparse
+import glob
+import os.path as osp
+
+from gather_models import get_final_results
+from mmengine import Config
+from mmengine.fileio import dump
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Gather benchmarked models train results')
+    parser.add_argument('config', help='test config file path')
+    parser.add_argument(
+        'root',
+        type=str,
+        help='root path of benchmarked models to be gathered')
+    parser.add_argument(
+        '--out',
+        type=str,
+        default='benchmark_train_info.json',
+        help='output path of gathered metrics to be stored')
+
+    args = parser.parse_args()
+    return args
+
+
+if __name__ == '__main__':
+    args = parse_args()
+
+    root_path = args.root
+    metrics_out = args.out
+
+    evaluation_cfg = Config.fromfile(args.config)
+
+    result_dict = {}
+    for model_key in evaluation_cfg:
+        model_infos = evaluation_cfg[model_key]
+        if not isinstance(model_infos, list):
+            model_infos = [model_infos]
+        for model_info in model_infos:
+            config = model_info['config']
+
+            # benchmark train dir
+            model_name = osp.split(osp.dirname(config))[1]
+            config_name = osp.splitext(osp.basename(config))[0]
+            exp_dir = osp.join(root_path, model_name, config_name)
+            if not osp.exists(exp_dir):
+                print(f'{config} hasn\'t {exp_dir}')
+                continue
+
+            # parse config
+            cfg = Config.fromfile(config)
+            total_iters = cfg.runner.max_iters
+            exp_metric = cfg.evaluation.metric
+            if not isinstance(exp_metric, list):
+                exp_metrics = [exp_metric]
+
+            # determine whether total_iters ckpt exists
+            ckpt_path = f'iter_{total_iters}.pth'
+            if not osp.exists(osp.join(exp_dir, ckpt_path)):
+                print(f'{config} hasn\'t {ckpt_path}')
+                continue
+
+            # only the last log json counts
+            log_json_path = list(
+                sorted(glob.glob(osp.join(exp_dir, '*.log.json'))))[-1]
+
+            # extract metric value
+            model_performance = get_final_results(log_json_path, total_iters)
+            if model_performance is None:
+                print(f'log file error: {log_json_path}')
+                continue
+
+            differential_results = dict()
+            old_results = dict()
+            new_results = dict()
+            for metric_key in model_performance:
+                if metric_key in ['mIoU']:
+                    metric = round(model_performance[metric_key] * 100, 2)
+                    old_metric = model_info['metric'][metric_key]
+                    old_results[metric_key] = old_metric
+                    new_results[metric_key] = metric
+                    differential = metric - old_metric
+                    flag = '+' if differential > 0 else '-'
+                    differential_results[
+                        metric_key] = f'{flag}{abs(differential):.2f}'
+            result_dict[config] = dict(
+                differential_results=differential_results,
+                old_results=old_results,
+                new_results=new_results,
+            )
+
+    # 4 save or print results
+    if metrics_out:
+        dump(result_dict, metrics_out, indent=4)
+    print('===================================')
+    for config_name, metrics in result_dict.items():
+        print(config_name, metrics)
+    print('===================================')
diff --git a/mmsegmentation/.dev_scripts/gather_models.py b/mmsegmentation/.dev_scripts/gather_models.py
new file mode 100644
index 0000000..fe6c390
--- /dev/null
+++ b/mmsegmentation/.dev_scripts/gather_models.py
@@ -0,0 +1,213 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import glob
+import hashlib
+import json
+import os
+import os.path as osp
+import shutil
+
+import torch
+from mmengine import Config
+from mmengine.fileio import dump
+from mmengine.utils import mkdir_or_exist, scandir
+
+# build schedule look-up table to automatically find the final model
+RESULTS_LUT = ['mIoU', 'mAcc', 'aAcc']
+
+
+def calculate_file_sha256(file_path):
+    """calculate file sha256 hash code."""
+    with open(file_path, 'rb') as fp:
+        sha256_cal = hashlib.sha256()
+        sha256_cal.update(fp.read())
+        return sha256_cal.hexdigest()
+
+
+def process_checkpoint(in_file, out_file):
+    checkpoint = torch.load(in_file, map_location='cpu')
+    # remove optimizer for smaller file size
+    if 'optimizer' in checkpoint:
+        del checkpoint['optimizer']
+    # if it is necessary to remove some sensitive data in checkpoint['meta'],
+    # add the code here.
+    torch.save(checkpoint, out_file)
+    # The hash code calculation and rename command differ on different system
+    # platform.
+    sha = calculate_file_sha256(out_file)
+    final_file = out_file.rstrip('.pth') + f'-{sha[:8]}.pth'
+    os.rename(out_file, final_file)
+
+    # Remove prefix and suffix
+    final_file_name = osp.split(final_file)[1]
+    final_file_name = osp.splitext(final_file_name)[0]
+
+    return final_file_name
+
+
+def get_final_iter(config):
+    iter_num = config.split('_')[-2]
+    assert iter_num.endswith('k')
+    return int(iter_num[:-1]) * 1000
+
+
+def get_final_results(log_json_path, iter_num):
+    result_dict = dict()
+    last_iter = 0
+    with open(log_json_path) as f:
+        for line in f.readlines():
+            log_line = json.loads(line)
+            if 'mode' not in log_line.keys():
+                continue
+
+            # When evaluation, the 'iter' of new log json is the evaluation
+            # steps on single gpu.
+            flag1 = ('aAcc' in log_line) or (log_line['mode'] == 'val')
+            flag2 = (last_iter == iter_num - 50) or (last_iter == iter_num)
+            if flag1 and flag2:
+                result_dict.update({
+                    key: log_line[key]
+                    for key in RESULTS_LUT if key in log_line
+                })
+                return result_dict
+
+            last_iter = log_line['iter']
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Gather benchmarked models')
+    parser.add_argument(
+        '-f', '--config-name', type=str, help='Process the selected config.')
+    parser.add_argument(
+        '-w',
+        '--work-dir',
+        default='work_dirs/',
+        type=str,
+        help='Ckpt storage root folder of benchmarked models to be gathered.')
+    parser.add_argument(
+        '-c',
+        '--collect-dir',
+        default='work_dirs/gather',
+        type=str,
+        help='Ckpt collect root folder of gathered models.')
+    parser.add_argument(
+        '--all', action='store_true', help='whether include .py and .log')
+
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    work_dir = args.work_dir
+    collect_dir = args.collect_dir
+    selected_config_name = args.config_name
+    mkdir_or_exist(collect_dir)
+
+    # find all models in the root directory to be gathered
+    raw_configs = list(scandir('./configs', '.py', recursive=True))
+
+    # filter configs that is not trained in the experiments dir
+    used_configs = []
+    for raw_config in raw_configs:
+        config_name = osp.splitext(osp.basename(raw_config))[0]
+        if osp.exists(osp.join(work_dir, config_name)):
+            if (selected_config_name is None
+                    or selected_config_name == config_name):
+                used_configs.append(raw_config)
+    print(f'Find {len(used_configs)} models to be gathered')
+
+    # find final_ckpt and log file for trained each config
+    # and parse the best performance
+    model_infos = []
+    for used_config in used_configs:
+        config_name = osp.splitext(osp.basename(used_config))[0]
+        exp_dir = osp.join(work_dir, config_name)
+        # check whether the exps is finished
+        final_iter = get_final_iter(used_config)
+        final_model = f'iter_{final_iter}.pth'
+        model_path = osp.join(exp_dir, final_model)
+
+        # skip if the model is still training
+        if not osp.exists(model_path):
+            print(f'{used_config} train not finished yet')
+            continue
+
+        # get logs
+        log_json_paths = glob.glob(osp.join(exp_dir, '*.log.json'))
+        log_json_path = log_json_paths[0]
+        model_performance = None
+        for idx, _log_json_path in enumerate(log_json_paths):
+            model_performance = get_final_results(_log_json_path, final_iter)
+            if model_performance is not None:
+                log_json_path = _log_json_path
+                break
+
+        if model_performance is None:
+            print(f'{used_config} model_performance is None')
+            continue
+
+        model_time = osp.split(log_json_path)[-1].split('.')[0]
+        model_infos.append(
+            dict(
+                config_name=config_name,
+                results=model_performance,
+                iters=final_iter,
+                model_time=model_time,
+                log_json_path=osp.split(log_json_path)[-1]))
+
+    # publish model for each checkpoint
+    publish_model_infos = []
+    for model in model_infos:
+        config_name = model['config_name']
+        model_publish_dir = osp.join(collect_dir, config_name)
+
+        publish_model_path = osp.join(model_publish_dir,
+                                      config_name + '_' + model['model_time'])
+        trained_model_path = osp.join(work_dir, config_name,
+                                      'iter_{}.pth'.format(model['iters']))
+        if osp.exists(model_publish_dir):
+            for file in os.listdir(model_publish_dir):
+                if file.endswith('.pth'):
+                    print(f'model {file} found')
+                    model['model_path'] = osp.abspath(
+                        osp.join(model_publish_dir, file))
+                    break
+            if 'model_path' not in model:
+                print(f'dir {model_publish_dir} exists, no model found')
+
+        else:
+            mkdir_or_exist(model_publish_dir)
+
+            # convert model
+            final_model_path = process_checkpoint(trained_model_path,
+                                                  publish_model_path)
+            model['model_path'] = final_model_path
+
+        new_json_path = f'{config_name}_{model["log_json_path"]}'
+        # copy log
+        shutil.copy(
+            osp.join(work_dir, config_name, model['log_json_path']),
+            osp.join(model_publish_dir, new_json_path))
+
+        if args.all:
+            new_txt_path = new_json_path.rstrip('.json')
+            shutil.copy(
+                osp.join(work_dir, config_name,
+                         model['log_json_path'].rstrip('.json')),
+                osp.join(model_publish_dir, new_txt_path))
+
+        if args.all:
+            # copy config to guarantee reproducibility
+            raw_config = osp.join('./configs', f'{config_name}.py')
+            Config.fromfile(raw_config).dump(
+                osp.join(model_publish_dir, osp.basename(raw_config)))
+
+        publish_model_infos.append(model)
+
+    models = dict(models=publish_model_infos)
+    dump(models, osp.join(collect_dir, 'model_infos.json'), indent=4)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/.dev_scripts/generate_benchmark_evaluation_script.py b/mmsegmentation/.dev_scripts/generate_benchmark_evaluation_script.py
new file mode 100644
index 0000000..4c48f85
--- /dev/null
+++ b/mmsegmentation/.dev_scripts/generate_benchmark_evaluation_script.py
@@ -0,0 +1,114 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os.path as osp
+
+from mmengine import Config
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Convert benchmark test model list to script')
+    parser.add_argument('config', help='test config file path')
+    parser.add_argument('--port', type=int, default=28171, help='dist port')
+    parser.add_argument(
+        '--work-dir',
+        default='work_dirs/benchmark_evaluation',
+        help='the dir to save metric')
+    parser.add_argument(
+        '--out',
+        type=str,
+        default='.dev_scripts/benchmark_evaluation.sh',
+        help='path to save model benchmark script')
+
+    args = parser.parse_args()
+    return args
+
+
+def process_model_info(model_info, work_dir):
+    config = model_info['config'].strip()
+    fname, _ = osp.splitext(osp.basename(config))
+    job_name = fname
+    checkpoint = model_info['checkpoint'].strip()
+    work_dir = osp.join(work_dir, fname)
+    if not isinstance(model_info['eval'], list):
+        evals = [model_info['eval']]
+    else:
+        evals = model_info['eval']
+    eval = ' '.join(evals)
+    return dict(
+        config=config,
+        job_name=job_name,
+        checkpoint=checkpoint,
+        work_dir=work_dir,
+        eval=eval)
+
+
+def create_test_bash_info(commands, model_test_dict, port, script_name,
+                          partition):
+    config = model_test_dict['config']
+    job_name = model_test_dict['job_name']
+    checkpoint = model_test_dict['checkpoint']
+    work_dir = model_test_dict['work_dir']
+    eval = model_test_dict['eval']
+
+    echo_info = f'\necho \'{config}\' &'
+    commands.append(echo_info)
+    commands.append('\n')
+
+    command_info = f'GPUS=4  GPUS_PER_NODE=4  ' \
+                   f'CPUS_PER_TASK=2 {script_name} '
+
+    command_info += f'{partition} '
+    command_info += f'{job_name} '
+    command_info += f'{config} '
+    command_info += f'$CHECKPOINT_DIR/{checkpoint} '
+
+    command_info += f'--eval {eval} '
+    command_info += f'--work-dir {work_dir} '
+    command_info += f'--cfg-options dist_params.port={port} '
+    command_info += '&'
+
+    commands.append(command_info)
+
+
+def main():
+    args = parse_args()
+    if args.out:
+        out_suffix = args.out.split('.')[-1]
+        assert args.out.endswith('.sh'), \
+            f'Expected out file path suffix is .sh, but get .{out_suffix}'
+
+    commands = []
+    partition_name = 'PARTITION=$1'
+    commands.append(partition_name)
+    commands.append('\n')
+
+    checkpoint_root = 'CHECKPOINT_DIR=$2'
+    commands.append(checkpoint_root)
+    commands.append('\n')
+
+    script_name = osp.join('tools', 'slurm_test.sh')
+    port = args.port
+    work_dir = args.work_dir
+
+    cfg = Config.fromfile(args.config)
+
+    for model_key in cfg:
+        model_infos = cfg[model_key]
+        if not isinstance(model_infos, list):
+            model_infos = [model_infos]
+        for model_info in model_infos:
+            print('processing: ', model_info['config'])
+            model_test_dict = process_model_info(model_info, work_dir)
+            create_test_bash_info(commands, model_test_dict, port, script_name,
+                                  '$PARTITION')
+            port += 1
+
+    command_str = ''.join(commands)
+    if args.out:
+        with open(args.out, 'w') as f:
+            f.write(command_str + '\n')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/.dev_scripts/generate_benchmark_train_script.py b/mmsegmentation/.dev_scripts/generate_benchmark_train_script.py
new file mode 100644
index 0000000..4bfdfbf
--- /dev/null
+++ b/mmsegmentation/.dev_scripts/generate_benchmark_train_script.py
@@ -0,0 +1,91 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os.path as osp
+
+# Default using 4 gpu when training
+config_8gpu_list = [
+    'configs/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K.py',  # noqa
+    'configs/vit/upernet_vit-b16_ln_mln_512x512_160k_ade20k.py',
+    'configs/vit/upernet_deit-s16_ln_mln_512x512_160k_ade20k.py',
+]
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Convert benchmark model json to script')
+    parser.add_argument(
+        'txt_path', type=str, help='txt path output by benchmark_filter')
+    parser.add_argument('--port', type=int, default=24727, help='dist port')
+    parser.add_argument(
+        '--out',
+        type=str,
+        default='.dev_scripts/benchmark_train.sh',
+        help='path to save model benchmark script')
+
+    args = parser.parse_args()
+    return args
+
+
+def create_train_bash_info(commands, config, script_name, partition, port):
+    cfg = config.strip()
+
+    # print cfg name
+    echo_info = f'echo \'{cfg}\' &'
+    commands.append(echo_info)
+    commands.append('\n')
+
+    _, model_name = osp.split(osp.dirname(cfg))
+    config_name, _ = osp.splitext(osp.basename(cfg))
+    # default setting
+    if cfg in config_8gpu_list:
+        command_info = f'GPUS=8  GPUS_PER_NODE=8  ' \
+                        f'CPUS_PER_TASK=2 {script_name} '
+    else:
+        command_info = f'GPUS=4  GPUS_PER_NODE=4  ' \
+                        f'CPUS_PER_TASK=2 {script_name} '
+    command_info += f'{partition} '
+    command_info += f'{config_name} '
+    command_info += f'{cfg} '
+    command_info += f'--cfg-options ' \
+                    f'checkpoint_config.max_keep_ckpts=1 ' \
+                    f'dist_params.port={port} '
+    command_info += f'--work-dir work_dirs/{model_name}/{config_name} '
+    # Let the script shut up
+    command_info += '>/dev/null &'
+
+    commands.append(command_info)
+    commands.append('\n')
+
+
+def main():
+    args = parse_args()
+    if args.out:
+        out_suffix = args.out.split('.')[-1]
+        assert args.out.endswith('.sh'), \
+            f'Expected out file path suffix is .sh, but get .{out_suffix}'
+
+    root_name = './tools'
+    script_name = osp.join(root_name, 'slurm_train.sh')
+    port = args.port
+    partition_name = 'PARTITION=$1'
+
+    commands = []
+    commands.append(partition_name)
+    commands.append('\n')
+    commands.append('\n')
+
+    with open(args.txt_path) as f:
+        model_cfgs = f.readlines()
+        for i, cfg in enumerate(model_cfgs):
+            create_train_bash_info(commands, cfg, script_name, '$PARTITION',
+                                   port)
+            port += 1
+
+        command_str = ''.join(commands)
+        if args.out:
+            with open(args.out, 'w') as f:
+                f.write(command_str)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/.dev_scripts/log_collector/example_config.py b/mmsegmentation/.dev_scripts/log_collector/example_config.py
new file mode 100644
index 0000000..bc2b4d6
--- /dev/null
+++ b/mmsegmentation/.dev_scripts/log_collector/example_config.py
@@ -0,0 +1,18 @@
+work_dir = '../../work_dirs'
+metric = 'mIoU'
+
+# specify the log files we would like to collect in `log_items`
+log_items = [
+    'segformer_mit-b5_512x512_160k_ade20k_cnn_lr_with_warmup',
+    'segformer_mit-b5_512x512_160k_ade20k_cnn_no_warmup_lr',
+    'segformer_mit-b5_512x512_160k_ade20k_mit_trans_lr',
+    'segformer_mit-b5_512x512_160k_ade20k_swin_trans_lr'
+]
+# or specify ignore_keywords, then the folders whose name contain
+# `'segformer'` won't be collected
+# ignore_keywords = ['segformer']
+
+# should not include metric
+other_info_keys = ['mAcc']
+markdown_file = 'markdowns/lr_in_trans.json.md'
+json_file = 'jsons/trans_in_cnn.json'
diff --git a/mmsegmentation/.dev_scripts/log_collector/log_collector.py b/mmsegmentation/.dev_scripts/log_collector/log_collector.py
new file mode 100644
index 0000000..0c2ff61
--- /dev/null
+++ b/mmsegmentation/.dev_scripts/log_collector/log_collector.py
@@ -0,0 +1,143 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import datetime
+import json
+import os
+import os.path as osp
+from collections import OrderedDict
+
+from utils import load_config
+
+# automatically collect all the results
+
+# The structure of the directory:
+#     ├── work-dir
+#     │   ├── config_1
+#     │   │   ├── time1.log.json
+#     │   │   ├── time2.log.json
+#     │   │   ├── time3.log.json
+#     │   │   ├── time4.log.json
+#     │   ├── config_2
+#     │   │   ├── time5.log.json
+#     │   │   ├── time6.log.json
+#     │   │   ├── time7.log.json
+#     │   │   ├── time8.log.json
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='extract info from log.json')
+    parser.add_argument('config_dir')
+    args = parser.parse_args()
+    return args
+
+
+def has_keyword(name: str, keywords: list):
+    for a_keyword in keywords:
+        if a_keyword in name:
+            return True
+    return False
+
+
+def main():
+    args = parse_args()
+    cfg = load_config(args.config_dir)
+    work_dir = cfg['work_dir']
+    metric = cfg['metric']
+    log_items = cfg.get('log_items', [])
+    ignore_keywords = cfg.get('ignore_keywords', [])
+    other_info_keys = cfg.get('other_info_keys', [])
+    markdown_file = cfg.get('markdown_file', None)
+    json_file = cfg.get('json_file', None)
+
+    if json_file and osp.split(json_file)[0] != '':
+        os.makedirs(osp.split(json_file)[0], exist_ok=True)
+    if markdown_file and osp.split(markdown_file)[0] != '':
+        os.makedirs(osp.split(markdown_file)[0], exist_ok=True)
+
+    assert not (log_items and ignore_keywords), \
+        'log_items and ignore_keywords cannot be specified at the same time'
+    assert metric not in other_info_keys, \
+        'other_info_keys should not contain metric'
+
+    if ignore_keywords and isinstance(ignore_keywords, str):
+        ignore_keywords = [ignore_keywords]
+    if other_info_keys and isinstance(other_info_keys, str):
+        other_info_keys = [other_info_keys]
+    if log_items and isinstance(log_items, str):
+        log_items = [log_items]
+
+    if not log_items:
+        log_items = [
+            item for item in sorted(os.listdir(work_dir))
+            if not has_keyword(item, ignore_keywords)
+        ]
+
+    experiment_info_list = []
+    for config_dir in log_items:
+        preceding_path = os.path.join(work_dir, config_dir)
+        log_list = [
+            item for item in os.listdir(preceding_path)
+            if item.endswith('.log.json')
+        ]
+        log_list = sorted(
+            log_list,
+            key=lambda time_str: datetime.datetime.strptime(
+                time_str, '%Y%m%d_%H%M%S.log.json'))
+        val_list = []
+        last_iter = 0
+        for log_name in log_list:
+            with open(os.path.join(preceding_path, log_name)) as f:
+                # ignore the info line
+                f.readline()
+                all_lines = f.readlines()
+                val_list.extend([
+                    json.loads(line) for line in all_lines
+                    if json.loads(line)['mode'] == 'val'
+                ])
+                for index in range(len(all_lines) - 1, -1, -1):
+                    line_dict = json.loads(all_lines[index])
+                    if line_dict['mode'] == 'train':
+                        last_iter = max(last_iter, line_dict['iter'])
+                        break
+
+        new_log_dict = dict(
+            method=config_dir, metric_used=metric, last_iter=last_iter)
+        for index, log in enumerate(val_list, 1):
+            new_ordered_dict = OrderedDict()
+            new_ordered_dict['eval_index'] = index
+            new_ordered_dict[metric] = log[metric]
+            for key in other_info_keys:
+                if key in log:
+                    new_ordered_dict[key] = log[key]
+            val_list[index - 1] = new_ordered_dict
+
+        assert len(val_list) >= 1, \
+            f"work dir {config_dir} doesn't contain any evaluation."
+        new_log_dict['last eval'] = val_list[-1]
+        new_log_dict['best eval'] = max(val_list, key=lambda x: x[metric])
+        experiment_info_list.append(new_log_dict)
+        print(f'{config_dir} is processed')
+
+    if json_file:
+        with open(json_file, 'w') as f:
+            json.dump(experiment_info_list, f, indent=4)
+
+    if markdown_file:
+        lines_to_write = []
+        for index, log in enumerate(experiment_info_list, 1):
+            lines_to_write.append(
+                f"|{index}|{log['method']}|{log['best eval'][metric]}"
+                f"|{log['best eval']['eval_index']}|"
+                f"{log['last eval'][metric]}|"
+                f"{log['last eval']['eval_index']}|{log['last_iter']}|\n")
+        with open(markdown_file, 'w') as f:
+            f.write(f'|exp_num|method|{metric} best|best index|'
+                    f'{metric} last|last index|last iter num|\n')
+            f.write('|:---:|:---:|:---:|:---:|:---:|:---:|:---:|\n')
+            f.writelines(lines_to_write)
+
+    print('processed successfully')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/.dev_scripts/log_collector/readme.md b/mmsegmentation/.dev_scripts/log_collector/readme.md
new file mode 100644
index 0000000..4a8b9b6
--- /dev/null
+++ b/mmsegmentation/.dev_scripts/log_collector/readme.md
@@ -0,0 +1,144 @@
+# Log Collector
+
+## Function
+
+Automatically collect logs and write the result in a json file or markdown file.
+
+If there are several `.log.json` files in one folder, Log Collector assumes that the `.log.json` files other than the first one are resume from the preceding `.log.json` file. Log Collector returns the result considering all `.log.json` files.
+
+## Usage:
+
+To use log collector, you need to write a config file to configure the log collector first.
+
+For example:
+
+example_config.py:
+
+```python
+# The work directory that contains folders that contains .log.json files.
+work_dir = '../../work_dirs'
+# The metric used to find the best evaluation.
+metric = 'mIoU'
+
+# **Don't specify the log_items and ignore_keywords at the same time.**
+# Specify the log files we would like to collect in `log_items`.
+# The folders specified should be the subdirectories of `work_dir`.
+log_items = [
+    'segformer_mit-b5_512x512_160k_ade20k_cnn_lr_with_warmup',
+    'segformer_mit-b5_512x512_160k_ade20k_cnn_no_warmup_lr',
+    'segformer_mit-b5_512x512_160k_ade20k_mit_trans_lr',
+    'segformer_mit-b5_512x512_160k_ade20k_swin_trans_lr'
+]
+# Or specify `ignore_keywords`. The folders whose name contain one
+# of the keywords in the `ignore_keywords` list(e.g., `'segformer'`)
+# won't be collected.
+# ignore_keywords = ['segformer']
+
+# Other log items in .log.json that you want to collect.
+# should not include metric.
+other_info_keys = ["mAcc"]
+# The output markdown file's name.
+markdown_file ='markdowns/lr_in_trans.json.md'
+# The output json file's name. (optional)
+json_file = 'jsons/trans_in_cnn.json'
+```
+
+The structure of the work-dir directory should be like：
+
+```text
+├── work-dir
+│   ├── folder1
+│   │   ├── time1.log.json
+│   │   ├── time2.log.json
+│   │   ├── time3.log.json
+│   │   ├── time4.log.json
+│   ├── folder2
+│   │   ├── time5.log.json
+│   │   ├── time6.log.json
+│   │   ├── time7.log.json
+│   │   ├── time8.log.json
+```
+
+Then , cd to the log collector folder.
+
+Now you can run log_collector.py by using command:
+
+```bash
+python log_collector.py ./example_config.py
+```
+
+The output markdown file is like:
+
+| exp_num |                         method                          | mIoU best | best index | mIoU last | last index | last iter num |
+| :-----: | :-----------------------------------------------------: | :-------: | :--------: | :-------: | :--------: | :-----------: |
+|    1    | segformer_mit-b5_512x512_160k_ade20k_cnn_lr_with_warmup |  0.2776   |     10     |  0.2776   |     10     |    160000     |
+|    2    |  segformer_mit-b5_512x512_160k_ade20k_cnn_no_warmup_lr  |  0.2802   |     10     |  0.2802   |     10     |    160000     |
+|    3    |    segformer_mit-b5_512x512_160k_ade20k_mit_trans_lr    |  0.4943   |     11     |  0.4943   |     11     |    160000     |
+|    4    |   segformer_mit-b5_512x512_160k_ade20k_swin_trans_lr    |  0.4883   |     11     |  0.4883   |     11     |    160000     |
+
+The output json file is like:
+
+```json
+[
+    {
+        "method": "segformer_mit-b5_512x512_160k_ade20k_cnn_lr_with_warmup",
+        "metric_used": "mIoU",
+        "last_iter": 160000,
+        "last eval": {
+            "eval_index": 10,
+            "mIoU": 0.2776,
+            "mAcc": 0.3779
+        },
+        "best eval": {
+            "eval_index": 10,
+            "mIoU": 0.2776,
+            "mAcc": 0.3779
+        }
+    },
+    {
+        "method": "segformer_mit-b5_512x512_160k_ade20k_cnn_no_warmup_lr",
+        "metric_used": "mIoU",
+        "last_iter": 160000,
+        "last eval": {
+            "eval_index": 10,
+            "mIoU": 0.2802,
+            "mAcc": 0.3764
+        },
+        "best eval": {
+            "eval_index": 10,
+            "mIoU": 0.2802,
+            "mAcc": 0.3764
+        }
+    },
+    {
+        "method": "segformer_mit-b5_512x512_160k_ade20k_mit_trans_lr",
+        "metric_used": "mIoU",
+        "last_iter": 160000,
+        "last eval": {
+            "eval_index": 11,
+            "mIoU": 0.4943,
+            "mAcc": 0.6097
+        },
+        "best eval": {
+            "eval_index": 11,
+            "mIoU": 0.4943,
+            "mAcc": 0.6097
+        }
+    },
+    {
+        "method": "segformer_mit-b5_512x512_160k_ade20k_swin_trans_lr",
+        "metric_used": "mIoU",
+        "last_iter": 160000,
+        "last eval": {
+            "eval_index": 11,
+            "mIoU": 0.4883,
+            "mAcc": 0.6061
+        },
+        "best eval": {
+            "eval_index": 11,
+            "mIoU": 0.4883,
+            "mAcc": 0.6061
+        }
+    }
+]
+```
diff --git a/mmsegmentation/.dev_scripts/log_collector/utils.py b/mmsegmentation/.dev_scripts/log_collector/utils.py
new file mode 100644
index 0000000..848516a
--- /dev/null
+++ b/mmsegmentation/.dev_scripts/log_collector/utils.py
@@ -0,0 +1,20 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# modified from https://github.dev/open-mmlab/mmcv
+import os.path as osp
+import sys
+from importlib import import_module
+
+
+def load_config(cfg_dir: str) -> dict:
+    assert cfg_dir.endswith('.py')
+    root_path, file_name = osp.split(cfg_dir)
+    temp_module = osp.splitext(file_name)[0]
+    sys.path.insert(0, root_path)
+    mod = import_module(temp_module)
+    sys.path.pop(0)
+    cfg_dict = {
+        k: v
+        for k, v in mod.__dict__.items() if not k.startswith('__')
+    }
+    del sys.modules[temp_module]
+    return cfg_dict
diff --git a/mmsegmentation/.dev_scripts/update_model_index.py b/mmsegmentation/.dev_scripts/update_model_index.py
new file mode 100755
index 0000000..eb87c02
--- /dev/null
+++ b/mmsegmentation/.dev_scripts/update_model_index.py
@@ -0,0 +1,301 @@
+#!/usr/bin/env python
+
+# Copyright (c) OpenMMLab. All rights reserved.
+# This tool is used to update model-index.yml which is required by MIM, and
+# will be automatically called as a pre-commit hook. The updating will be
+# triggered if any change of model information (.md files in configs/) has been
+# detected before a commit.
+
+import os
+import os.path as osp
+import re
+import sys
+from typing import List, Tuple
+
+import yaml
+
+MMSEG_ROOT = osp.abspath(osp.join(osp.dirname(__file__), '..'))
+
+
+def get_collection_name_list(md_file_list: List[str]) -> List[str]:
+    """Get the list of collection names."""
+    collection_name_list: List[str] = []
+    for md_file in md_file_list:
+        with open(md_file) as f:
+            lines = f.readlines()
+            collection_name = lines[0].split('#')[1].strip()
+            collection_name_list.append(collection_name)
+    return collection_name_list
+
+
+def get_md_file_list() -> Tuple[List[str], List[str]]:
+    """Get the list of md files."""
+    md_file_list: List[str] = []
+    md_dir_list: List[str] = []
+    for root, _, files in os.walk(osp.join(MMSEG_ROOT, 'configs')):
+        for file in files:
+            if file.endswith('.md'):
+                md_file_list.append(osp.join(root, file))
+                md_dir_list.append(root)
+                break
+    return md_file_list, md_dir_list
+
+
+def get_model_info(md_file: str, config_dir: str,
+                   collection_name_list: List[str]) -> Tuple[dict, str]:
+    """Get model information from md file."""
+    datasets: List[str] = []
+    models: List[dict] = []
+    current_dataset: str = ''
+    paper_name: str = ''
+    paper_url: str = ''
+    code_url: str = ''
+    is_backbone: bool = False
+    is_dataset: bool = False
+    collection_name: str = ''
+    with open(md_file) as f:
+        lines: List[str] = f.readlines()
+        i: int = 0
+
+        while i < len(lines):
+            line: str = lines[i].strip()
+            if len(line) == 0:
+                i += 1
+                continue
+            # get paper name and url
+            if re.match(r'> \[.*\]+\([a-zA-Z]+://[^\s]*\)', line):
+                paper_info = line.split('](')
+                paper_name = paper_info[0][paper_info[0].index('[') + 1:]
+                paper_url = paper_info[1][:len(paper_info[1]) - 1]
+
+            # get code info
+            if 'Code Snippet' in line:
+                code_url = line.split('"')[1].split('"')[0]
+
+            if line.startswith('<!-- [BACKBONE]'):
+                is_backbone = True
+
+            if line.startswith('<!-- [DATASET]'):
+                is_dataset = True
+
+            if '<!-- [SKIP DEV CHECK] -->' in line:
+                return None, None
+
+            # get dataset names
+            if line.startswith('###'):
+                current_dataset = line.split('###')[1].strip()
+                datasets.append(current_dataset)
+
+            # get model info key id
+            if (line[0] == '|' and (i + 1) < len(lines)
+                    and lines[i + 1][:3] == '| -' and 'Method' in line
+                    and 'Crop Size' in line and 'Mem (GB)' in line):
+                keys: List[str] = [key.strip() for key in line.split('|')]
+                crop_size_idx: int = keys.index('Crop Size')
+                mem_idx: int = keys.index('Mem (GB)')
+                assert 'Device' in keys, f'No Device in {md_file}'
+                device_idx: int = keys.index('Device')
+
+                if 'mIoU' in keys:
+                    ss_idx = keys.index('mIoU')
+                elif 'mDice' in keys:
+                    ss_idx = keys.index('mDice')
+                else:
+                    raise ValueError(f'No mIoU or mDice in {md_file}')
+                if 'mIoU(ms+flip)' in keys:
+                    ms_idx = keys.index('mIoU(ms+flip)')
+                elif 'Dice' in keys:
+                    ms_idx = keys.index('Dice')
+                else:
+                    ms_idx = -1
+                config_idx = keys.index('config')
+                download_idx = keys.index('download')
+                j: int = i + 2
+                while j < len(lines) and lines[j][0] == '|':
+                    values = [value.strip() for value in lines[j].split('|')]
+                    # get config name
+                    try:
+                        config_url = re.findall(r'[a-zA-Z]+://[^\s]*py',
+                                                values[config_idx])[0]
+                        config_name = config_url.split('/')[-1]
+                        model_name = config_name.replace('.py', '')
+                    except IndexError:
+                        raise ValueError(
+                            f'config url is not found in {md_file}')
+
+                    # get model name
+                    try:
+                        weight_url = re.findall(r'[a-zA-Z]+://[^\s]*pth',
+                                                values[download_idx])[0]
+                        log_url = re.findall(r'[a-zA-Z]+://[^\s]*.json',
+                                             values[download_idx + 1])[0]
+                    except IndexError:
+                        raise ValueError(
+                            f'url is not found in {values[download_idx]}')
+
+                    # get batch size
+                    bs = re.findall(r'[0-9]*xb[0-9]*',
+                                    config_name)[0].split('xb')
+                    batch_size = int(bs[0]) * int(bs[1])
+
+                    # get crop size
+                    crop_size = values[crop_size_idx].split('x')
+                    crop_size = [int(crop_size[0]), int(crop_size[1])]
+
+                    mem = values[mem_idx].split('\\')[0] if values[
+                        mem_idx] != '-' and values[mem_idx] != '' else -1
+
+                    method = values[keys.index('Method')].strip()
+                    # method = [method.strip()] if '+' not in method else [
+                    #     m.strip() for m in method.split('+')
+                    # ]
+                    # split method name:
+                    if ' + ' in method:
+                        method = [m.strip() for m in method.split(' + ')]
+                    elif ' ' in method:
+                        method = [m for m in method.split(' ')]
+                    else:
+                        method = [method]
+                    backone: str = re.findall(
+                        r'[^\s]*', values[keys.index('Backbone')].strip())[0]
+                    archs = [backone] + method
+                    collection_name = method[0]
+                    config_path = osp.join('configs',
+                                           config_dir.split('/')[-1],
+                                           config_name)
+                    model = {
+                        'Name': model_name,
+                        'In Collection': collection_name,
+                        'Results': {
+                            'Task': 'Semantic Segmentation',
+                            'Dataset': current_dataset,
+                            'Metrics': {
+                                keys[ss_idx]: float(values[ss_idx])
+                            }
+                        },
+                        'Config': config_path,
+                        'Metadata': {
+                            'Training Data':
+                            current_dataset,
+                            'Batch Size':
+                            batch_size,
+                            'Architecture':
+                            archs,
+                            'Training Resources':
+                            f'{bs[0]}x {values[device_idx]} GPUS',
+                        },
+                        'Weights': weight_url,
+                        'Training log': log_url,
+                        'Paper': {
+                            'Title': paper_name,
+                            'URL': paper_url
+                        },
+                        'Code': code_url,
+                        'Framework': 'PyTorch'
+                    }
+                    if ms_idx != -1 and values[ms_idx] != '-' and values[
+                            ms_idx] != '':
+                        model['Results']['Metrics'].update(
+                            {keys[ms_idx]: float(values[ms_idx])})
+                    if mem != -1:
+                        model['Metadata']['Memory (GB)'] = float(mem)
+                    models.append(model)
+                    j += 1
+                i = j
+            i += 1
+
+    if not (is_dataset
+            or is_backbone) or collection_name not in collection_name_list:
+        collection = {
+            'Name': collection_name,
+            'License': 'Apache License 2.0',
+            'Metadata': {
+                'Training Data': datasets
+            },
+            'Paper': {
+                'Title': paper_name,
+                'URL': paper_url,
+            },
+            'README': osp.join('configs',
+                               config_dir.split('/')[-1], 'README.md'),
+            'Frameworks': ['PyTorch'],
+        }
+        results = {
+            'Collections': [collection],
+            'Models': models
+        }, collection_name
+    else:
+        results = {'Models': models}, ''
+
+    return results
+
+
+def dump_yaml_and_check_difference(model_info: dict, filename: str) -> bool:
+    """dump yaml file and check difference with the original file.
+
+    Args:
+        model_info (dict): model info dict.
+        filename (str): filename to save.
+    """
+    str_dump = yaml.dump(model_info, sort_keys=False)
+    if osp.isfile(filename):
+        file_exist = True
+        with open(filename, encoding='utf-8') as f:
+            str_orig = f.read()
+    else:
+        str_orig = None
+        file_exist = False
+
+    if file_exist and str_orig == str_dump:
+        is_different = False
+    else:
+        is_different = True
+        with open(filename, 'w', encoding='utf-8') as f:
+            f.write(str_dump)
+
+    return is_different
+
+
+def update_model_index(config_dir_list: List[str]) -> bool:
+    """update model index."""
+    yml_files = [
+        osp.join('configs',
+                 dir_name.split('/')[-1], 'metafile.yaml')
+        for dir_name in config_dir_list
+    ]
+    yml_files.sort()
+
+    model_index = {
+        'Import': [
+            osp.relpath(yml_file, MMSEG_ROOT).replace('\\', '/')
+            for yml_file in yml_files
+        ]
+    }
+    model_index_file = osp.join(MMSEG_ROOT, 'model-index.yml')
+    return dump_yaml_and_check_difference(model_index, model_index_file)
+
+
+if __name__ == '__main__':
+    # get md file list
+    md_file_list, config_dir_list = get_md_file_list()
+    file_modified = False
+    collection_name_list: List[str] = get_collection_name_list(md_file_list)
+    # hard code to add 'FPN'
+    collection_name_list.append('FPN')
+    remove_config_dir_list = []
+    # parse md file
+    for md_file, config_dir in zip(md_file_list, config_dir_list):
+        results, collection_name = get_model_info(md_file, config_dir,
+                                                  collection_name_list)
+        if results is None:
+            remove_config_dir_list.append(config_dir)
+            continue
+        filename = osp.join(config_dir, 'metafile.yaml')
+        file_modified |= dump_yaml_and_check_difference(results, filename)
+        if collection_name != '':
+            collection_name_list.append(collection_name)
+    # remove config dir
+    for config_dir in remove_config_dir_list:
+        config_dir_list.remove(config_dir)
+    file_modified |= update_model_index(config_dir_list)
+    sys.exit(1 if file_modified else 0)
diff --git a/mmsegmentation/.dev_scripts/upload_modelzoo.py b/mmsegmentation/.dev_scripts/upload_modelzoo.py
new file mode 100644
index 0000000..303c80d
--- /dev/null
+++ b/mmsegmentation/.dev_scripts/upload_modelzoo.py
@@ -0,0 +1,45 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os
+import os.path as osp
+
+import oss2
+
+ACCESS_KEY_ID = os.getenv('OSS_ACCESS_KEY_ID', None)
+ACCESS_KEY_SECRET = os.getenv('OSS_ACCESS_KEY_SECRET', None)
+BUCKET_NAME = 'openmmlab'
+ENDPOINT = 'https://oss-accelerate.aliyuncs.com'
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Upload models to OSS')
+    parser.add_argument('model_zoo', type=str, help='model_zoo input')
+    parser.add_argument(
+        '--dst-folder',
+        type=str,
+        default='mmsegmentation/v0.5',
+        help='destination folder')
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    model_zoo = args.model_zoo
+    dst_folder = args.dst_folder
+    bucket = oss2.Bucket(
+        oss2.Auth(ACCESS_KEY_ID, ACCESS_KEY_SECRET), ENDPOINT, BUCKET_NAME)
+
+    for root, dirs, files in os.walk(model_zoo):
+        for file in files:
+            file_path = osp.relpath(osp.join(root, file), model_zoo)
+            print(f'Uploading {file_path}')
+
+            oss2.resumable_upload(bucket, osp.join(dst_folder, file_path),
+                                  osp.join(model_zoo, file_path))
+            bucket.put_object_acl(
+                osp.join(dst_folder, file_path), oss2.OBJECT_ACL_PUBLIC_READ)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/.github/CODE_OF_CONDUCT.md b/mmsegmentation/.github/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000..92afad1
--- /dev/null
+++ b/mmsegmentation/.github/CODE_OF_CONDUCT.md
@@ -0,0 +1,76 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+- Using welcoming and inclusive language
+- Being respectful of differing viewpoints and experiences
+- Gracefully accepting constructive criticism
+- Focusing on what is best for the community
+- Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+- The use of sexualized language or imagery and unwelcome sexual attention or
+  advances
+- Trolling, insulting/derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+- Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at chenkaidev@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq
+
+[homepage]: https://www.contributor-covenant.org
diff --git a/mmsegmentation/.github/CONTRIBUTING.md b/mmsegmentation/.github/CONTRIBUTING.md
new file mode 100644
index 0000000..8865fa8
--- /dev/null
+++ b/mmsegmentation/.github/CONTRIBUTING.md
@@ -0,0 +1,59 @@
+# Contributing to MMSegmentation 1.x
+
+All kinds of contributions are welcome, including but not limited to the following.
+
+- Fix typo or bugs
+- Add documentation or translate the documentation into other languages
+- Add new features and components
+
+## Workflow
+
+1. fork and pull the latest MMSegmentation repository
+2. checkout a new branch from 'dev-1.x' (do not use master branch for PRs)
+3. commit your changes
+4. create a PR
+
+```{note}
+If you plan to add some new features that involve large changes, it is encouraged to open an issue for discussion first.
+```
+
+## Code style
+
+### Python
+
+We adopt [PEP8](https://www.python.org/dev/peps/pep-0008/) as the preferred code style.
+
+We use the following tools for linting and formatting:
+
+- [flake8](https://github.com/PyCQA/flake8): A wrapper around some linter tools.
+- [isort](https://github.com/timothycrosley/isort): A Python utility to sort imports.
+- [yapf](https://github.com/google/yapf): A formatter for Python files.
+- [codespell](https://github.com/codespell-project/codespell): A Python utility to fix common misspellings in text files.
+- [mdformat](https://github.com/executablebooks/mdformat): Mdformat is an opinionated Markdown formatter that can be used to enforce a consistent style in Markdown files.
+- [docformatter](https://github.com/myint/docformatter): A formatter to format docstring.
+
+Style configurations of yapf and isort can be found in [setup.cfg](./setup.cfg).
+
+We use [pre-commit hook](https://pre-commit.com/) that checks and formats for `flake8`, `yapf`, `isort`, `trailing whitespaces`, `markdown files`,
+fixes `end-of-files`, `double-quoted-strings`, `python-encoding-pragma`, `mixed-line-ending`, sorts `requirments.txt` automatically on every commit.
+The config for a pre-commit hook is stored in [.pre-commit-config](./.pre-commit-config.yaml).
+
+After you clone the repository, you will need to install initialize pre-commit hook.
+
+```shell
+pip install -U pre-commit
+```
+
+From the repository folder
+
+```shell
+pre-commit install
+```
+
+After this on every commit check code linters and formatter will be enforced.
+
+> Before you create a PR, make sure that your code lints and is formatted by yapf.
+
+### C++ and CUDA
+
+We follow the [Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html).
diff --git a/mmsegmentation/.github/ISSUE_TEMPLATE/config.yml b/mmsegmentation/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 0000000..aa982e5
--- /dev/null
+++ b/mmsegmentation/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,6 @@
+blank_issues_enabled: false
+
+contact_links:
+  - name: MMSegmentation Documentation
+    url: https://mmsegmentation.readthedocs.io
+    about: Check the docs and FAQ to see if you question is already answered.
diff --git a/mmsegmentation/.github/ISSUE_TEMPLATE/error-report.md b/mmsegmentation/.github/ISSUE_TEMPLATE/error-report.md
new file mode 100644
index 0000000..807781c
--- /dev/null
+++ b/mmsegmentation/.github/ISSUE_TEMPLATE/error-report.md
@@ -0,0 +1,48 @@
+---
+name: Error report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+---
+
+Thanks for your error report and we appreciate it a lot.
+
+**Checklist**
+
+1. I have searched related issues but cannot get the expected help.
+2. The bug has not been fixed in the latest version.
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**Reproduction**
+
+1. What command or script did you run?
+
+   ```none
+   A placeholder for the command.
+   ```
+
+2. Did you make any modifications on the code or config? Did you understand what you have modified?
+
+3. What dataset did you use?
+
+**Environment**
+
+1. Please run `python mmseg/utils/collect_env.py` to collect necessary environment information and paste it here.
+2. You may add addition that may be helpful for locating the problem, such as
+   - How you installed PyTorch \[e.g., pip, conda, source\]
+   - Other environment variables that may be related (such as `$PATH`, `$LD_LIBRARY_PATH`, `$PYTHONPATH`, etc.)
+
+**Error traceback**
+
+If applicable, paste the error trackback here.
+
+```none
+A placeholder for trackback.
+```
+
+**Bug fix**
+
+If you have already identified the reason, you can provide the information here. If you are willing to create a PR to fix it, please also leave a comment here and that would be much appreciated!
diff --git a/mmsegmentation/.github/ISSUE_TEMPLATE/feature_request.md b/mmsegmentation/.github/ISSUE_TEMPLATE/feature_request.md
new file mode 100644
index 0000000..7e3b855
--- /dev/null
+++ b/mmsegmentation/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,21 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+---
+
+# Describe the feature
+
+**Motivation**
+A clear and concise description of the motivation of the feature.
+Ex1. It is inconvenient when \[....\].
+Ex2. There is a recent paper \[....\], which is very helpful for \[....\].
+
+**Related resources**
+If there is an official code release or third-party implementations, please also provide the information here, which would be very helpful.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.
+If you would like to implement the feature and create a PR, please leave a comment here and that would be much appreciated.
diff --git a/mmsegmentation/.github/ISSUE_TEMPLATE/general_questions.md b/mmsegmentation/.github/ISSUE_TEMPLATE/general_questions.md
new file mode 100644
index 0000000..f02dd63
--- /dev/null
+++ b/mmsegmentation/.github/ISSUE_TEMPLATE/general_questions.md
@@ -0,0 +1,7 @@
+---
+name: General questions
+about: Ask general questions to get help
+title: ''
+labels: ''
+assignees: ''
+---
diff --git a/mmsegmentation/.github/ISSUE_TEMPLATE/reimplementation_questions.md b/mmsegmentation/.github/ISSUE_TEMPLATE/reimplementation_questions.md
new file mode 100644
index 0000000..63e4c3b
--- /dev/null
+++ b/mmsegmentation/.github/ISSUE_TEMPLATE/reimplementation_questions.md
@@ -0,0 +1,69 @@
+---
+name: Reimplementation Questions
+about: Ask about questions during model reimplementation
+title: ''
+labels: reimplementation
+assignees: ''
+---
+
+If you feel we have helped you, give us a STAR! :satisfied:
+
+**Notice**
+
+There are several common situations in the reimplementation issues as below
+
+1. Reimplement a model in the model zoo using the provided configs
+2. Reimplement a model in the model zoo on other datasets (e.g., custom datasets)
+3. Reimplement a custom model but all the components are implemented in MMSegmentation
+4. Reimplement a custom model with new modules implemented by yourself
+
+There are several things to do for different cases as below.
+
+- For cases 1 & 3, please follow the steps in the following sections thus we could help to quickly identify the issue.
+- For cases 2 & 4, please understand that we are not able to do much help here because we usually do not know the full code, and the users should be responsible for the code they write.
+- One suggestion for cases 2 & 4 is that the users should first check whether the bug lies in the self-implemented code or the original code. For example, users can first make sure that the same model runs well on supported datasets. If you still need help, please describe what you have done and what you obtain in the issue, and follow the steps in the following sections, and try as clear as possible so that we can better help you.
+
+**Checklist**
+
+1. I have searched related issues but cannot get the expected help.
+2. The issue has not been fixed in the latest version.
+
+**Describe the issue**
+
+A clear and concise description of the problem you meet and what you have done.
+
+**Reproduction**
+
+1. What command or script did you run?
+
+```
+A placeholder for the command.
+```
+
+2. What config dir you run?
+
+```
+A placeholder for the config.
+```
+
+3. Did you make any modifications to the code or config? Did you understand what you have modified?
+4. What dataset did you use?
+
+**Environment**
+
+1. Please run `PYTHONPATH=${PWD}:$PYTHONPATH python mmseg/utils/collect_env.py` to collect the necessary environment information and paste it here.
+2. You may add an addition that may be helpful for locating the problem, such as
+   1. How you installed PyTorch \[e.g., pip, conda, source\]
+   2. Other environment variables that may be related (such as `$PATH`, `$LD_LIBRARY_PATH`, `$PYTHONPATH`, etc.)
+
+**Results**
+
+If applicable, paste the related results here, e.g., what you expect and what you get.
+
+```
+A placeholder for results comparison
+```
+
+**Issue fix**
+
+If you have already identified the reason, you can provide the information here. If you are willing to create a PR to fix it, please also leave a comment here and that would be much appreciated!
diff --git a/mmsegmentation/.github/pull_request_template.md b/mmsegmentation/.github/pull_request_template.md
new file mode 100644
index 0000000..09d5305
--- /dev/null
+++ b/mmsegmentation/.github/pull_request_template.md
@@ -0,0 +1,25 @@
+Thanks for your contribution and we appreciate it a lot. The following instructions would make your pull request more healthy and more easily get feedback. If you do not understand some items, don't worry, just make the pull request and seek help from maintainers.
+
+## Motivation
+
+Please describe the motivation of this PR and the goal you want to achieve through this PR.
+
+## Modification
+
+Please briefly describe what modification is made in this PR.
+
+## BC-breaking (Optional)
+
+Does the modification introduce changes that break the backward-compatibility of the downstream repos?
+If so, please describe how it breaks the compatibility and how the downstream projects should modify their code to keep compatibility with this PR.
+
+## Use cases (Optional)
+
+If this PR introduces a new feature, it is better to list some use cases here, and update the documentation.
+
+## Checklist
+
+1. Pre-commit or other linting tools are used to fix the potential lint issues.
+2. The modification is covered by complete unit tests. If not, please add more unit test to ensure the correctness.
+3. If the modification has potential influence on downstream projects, this PR should be tested with downstream projects, like MMDet or MMDet3D.
+4. The documentation has been modified accordingly, like docstring or example tutorials.
diff --git a/mmsegmentation/.github/workflows/deploy.yml b/mmsegmentation/.github/workflows/deploy.yml
new file mode 100644
index 0000000..0e0c6c9
--- /dev/null
+++ b/mmsegmentation/.github/workflows/deploy.yml
@@ -0,0 +1,26 @@
+name: deploy
+
+on: push
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build-n-publish:
+    runs-on: ubuntu-22.04
+    if: startsWith(github.event.ref, 'refs/tags')
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Python 3.7
+        uses: actions/setup-python@v4
+        with:
+          python-version: 3.7
+      - name: Build MMSegmentation
+        run: |
+          pip install wheel
+          python setup.py sdist bdist_wheel
+      - name: Publish distribution to PyPI
+        run: |
+          pip install twine
+          twine upload dist/* -u __token__ -p ${{ secrets.pypi_password }}
diff --git a/mmsegmentation/.gitignore b/mmsegmentation/.gitignore
new file mode 100644
index 0000000..787d13e
--- /dev/null
+++ b/mmsegmentation/.gitignore
@@ -0,0 +1,120 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/en/_build/
+docs/zh_cn/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+.DS_Store
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+data
+.vscode
+.idea
+
+# custom
+*.pkl
+*.pkl.json
+*.log.json
+work_dirs/
+mmseg/.mim
+
+# Pytorch
+*.pth
diff --git a/mmsegmentation/.owners.yml b/mmsegmentation/.owners.yml
new file mode 100644
index 0000000..20f2070
--- /dev/null
+++ b/mmsegmentation/.owners.yml
@@ -0,0 +1,7 @@
+assign:
+  strategy:
+    # random
+    # round-robin
+    daily-shift-based
+  assignees:
+    - xiexinch
diff --git a/mmsegmentation/.pre-commit-config.yaml b/mmsegmentation/.pre-commit-config.yaml
new file mode 100644
index 0000000..337e90c
--- /dev/null
+++ b/mmsegmentation/.pre-commit-config.yaml
@@ -0,0 +1,67 @@
+repos:
+  - repo: https://github.com/PyCQA/flake8
+    rev: 5.0.4
+    hooks:
+      - id: flake8
+  - repo: https://github.com/zhouzaida/isort
+    rev: 5.12.1
+    hooks:
+      - id: isort
+  - repo: https://github.com/pre-commit/mirrors-yapf
+    rev: v0.32.0
+    hooks:
+      - id: yapf
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.3.0
+    hooks:
+      - id: trailing-whitespace
+      - id: check-yaml
+      - id: end-of-file-fixer
+      - id: requirements-txt-fixer
+      - id: double-quote-string-fixer
+      - id: check-merge-conflict
+      - id: fix-encoding-pragma
+        args: ["--remove"]
+      - id: mixed-line-ending
+        args: ["--fix=lf"]
+  - repo: https://github.com/executablebooks/mdformat
+    rev: 0.7.9
+    hooks:
+      - id: mdformat
+        args: ["--number"]
+        additional_dependencies:
+          - mdformat-openmmlab
+          - mdformat_frontmatter
+          - linkify-it-py
+  - repo: https://github.com/codespell-project/codespell
+    rev: v2.2.1
+    hooks:
+      - id: codespell
+        args: [--ignore-words-list=hsi]
+  - repo: https://github.com/myint/docformatter
+    rev: v1.3.1
+    hooks:
+      - id: docformatter
+        args: ["--in-place", "--wrap-descriptions", "79"]
+  # temporarily remove update-model-index to avoid conflict raised
+  # by depth estimator models
+  # - repo: local
+  #   hooks:
+  #     - id: update-model-index
+  #       name: update-model-index
+  #       description: Collect model information and update model-index.yml
+  #       entry: .dev_scripts/update_model_index.py
+  #       additional_dependencies: [pyyaml]
+  #       language: python
+  #       require_serial: true
+  - repo: https://github.com/asottile/pyupgrade
+    rev: v3.0.0
+    hooks:
+      - id: pyupgrade
+        args: ["--py36-plus"]
+  - repo: https://github.com/open-mmlab/pre-commit-hooks
+    rev: v0.2.0  # Use the rev to fix revision
+    hooks:
+      - id: check-algo-readme
+      - id: check-copyright
+        args: ["mmseg", "tools", "tests", "demo"]  # the dir_to_check with expected directory to check
diff --git a/mmsegmentation/CITATION.cff b/mmsegmentation/CITATION.cff
new file mode 100644
index 0000000..cfd7cab
--- /dev/null
+++ b/mmsegmentation/CITATION.cff
@@ -0,0 +1,8 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it as below."
+authors:
+  - name: "MMSegmentation Contributors"
+title: "OpenMMLab Semantic Segmentation Toolbox and Benchmark"
+date-released: 2020-07-10
+url: "https://github.com/open-mmlab/mmsegmentation"
+license: Apache-2.0
diff --git a/mmsegmentation/LICENSE b/mmsegmentation/LICENSE
new file mode 100644
index 0000000..38e625b
--- /dev/null
+++ b/mmsegmentation/LICENSE
@@ -0,0 +1,203 @@
+Copyright 2020 The MMSegmentation Authors. All rights reserved.
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2020 The MMSegmentation Authors.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/mmsegmentation/MANIFEST.in b/mmsegmentation/MANIFEST.in
new file mode 100644
index 0000000..94a0fc1
--- /dev/null
+++ b/mmsegmentation/MANIFEST.in
@@ -0,0 +1,5 @@
+include requirements/*.txt
+include mmseg/.mim/model-index.yml
+include mmseg/utils/bpe_simple_vocab_16e6.txt.gz
+recursive-include mmseg/.mim/configs *.py *.yaml
+recursive-include mmseg/.mim/tools *.py *.sh
diff --git a/mmsegmentation/README.md b/mmsegmentation/README.md
new file mode 100644
index 0000000..79ecdb7
--- /dev/null
+++ b/mmsegmentation/README.md
@@ -0,0 +1,420 @@
+<div align="center">
+  <img src="resources/mmseg-logo.png" width="600"/>
+  <div>&nbsp;</div>
+  <div align="center">
+    <b><font size="5">OpenMMLab website</font></b>
+    <sup>
+      <a href="https://openmmlab.com">
+        <i><font size="4">HOT</font></i>
+      </a>
+    </sup>
+    &nbsp;&nbsp;&nbsp;&nbsp;
+    <b><font size="5">OpenMMLab platform</font></b>
+    <sup>
+      <a href="https://platform.openmmlab.com">
+        <i><font size="4">TRY IT OUT</font></i>
+      </a>
+    </sup>
+  </div>
+  <div>&nbsp;</div>
+
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mmsegmentation)](https://pypi.org/project/mmsegmentation/)
+[![PyPI](https://img.shields.io/pypi/v/mmsegmentation)](https://pypi.org/project/mmsegmentation)
+[![docs](https://img.shields.io/badge/docs-latest-blue)](https://mmsegmentation.readthedocs.io/en/latest/)
+[![badge](https://github.com/open-mmlab/mmsegmentation/workflows/build/badge.svg)](https://github.com/open-mmlab/mmsegmentation/actions)
+[![codecov](https://codecov.io/gh/open-mmlab/mmsegmentation/branch/master/graph/badge.svg)](https://codecov.io/gh/open-mmlab/mmsegmentation)
+[![license](https://img.shields.io/github/license/open-mmlab/mmsegmentation.svg)](https://github.com/open-mmlab/mmsegmentation/blob/main/LICENSE)
+[![issue resolution](https://isitmaintained.com/badge/resolution/open-mmlab/mmsegmentation.svg)](https://github.com/open-mmlab/mmsegmentation/issues)
+[![open issues](https://isitmaintained.com/badge/open/open-mmlab/mmsegmentation.svg)](https://github.com/open-mmlab/mmsegmentation/issues)
+[![Open in OpenXLab](https://cdn-static.openxlab.org.cn/app-center/openxlab_demo.svg)](https://openxlab.org.cn/apps?search=mmseg)
+
+Documentation: <https://mmsegmentation.readthedocs.io/en/latest/>
+
+English | [简体中文](README_zh-CN.md)
+
+</div>
+
+<div align="center">
+  <a href="https://openmmlab.medium.com/" style="text-decoration:none;">
+    <img src="https://user-images.githubusercontent.com/25839884/219255827-67c1a27f-f8c5-46a9-811d-5e57448c61d1.png" width="3%" alt="" /></a>
+  <img src="https://user-images.githubusercontent.com/25839884/218346358-56cc8e2f-a2b8-487f-9088-32480cceabcf.png" width="3%" alt="" />
+  <a href="https://discord.gg/raweFPmdzG" style="text-decoration:none;">
+    <img src="https://user-images.githubusercontent.com/25839884/218347213-c080267f-cbb6-443e-8532-8e1ed9a58ea9.png" width="3%" alt="" /></a>
+  <img src="https://user-images.githubusercontent.com/25839884/218346358-56cc8e2f-a2b8-487f-9088-32480cceabcf.png" width="3%" alt="" />
+  <a href="https://twitter.com/OpenMMLab" style="text-decoration:none;">
+    <img src="https://user-images.githubusercontent.com/25839884/218346637-d30c8a0f-3eba-4699-8131-512fb06d46db.png" width="3%" alt="" /></a>
+  <img src="https://user-images.githubusercontent.com/25839884/218346358-56cc8e2f-a2b8-487f-9088-32480cceabcf.png" width="3%" alt="" />
+  <a href="https://www.youtube.com/openmmlab" style="text-decoration:none;">
+    <img src="https://user-images.githubusercontent.com/25839884/218346691-ceb2116a-465a-40af-8424-9f30d2348ca9.png" width="3%" alt="" /></a>
+  <img src="https://user-images.githubusercontent.com/25839884/218346358-56cc8e2f-a2b8-487f-9088-32480cceabcf.png" width="3%" alt="" />
+  <a href="https://space.bilibili.com/1293512903" style="text-decoration:none;">
+    <img src="https://user-images.githubusercontent.com/25839884/219026751-d7d14cce-a7c9-4e82-9942-8375fca65b99.png" width="3%" alt="" /></a>
+  <img src="https://user-images.githubusercontent.com/25839884/218346358-56cc8e2f-a2b8-487f-9088-32480cceabcf.png" width="3%" alt="" />
+  <a href="https://www.zhihu.com/people/openmmlab" style="text-decoration:none;">
+    <img src="https://user-images.githubusercontent.com/25839884/219026120-ba71e48b-6e94-4bd4-b4e9-b7d175b5e362.png" width="3%" alt="" /></a>
+</div>
+
+## Introduction
+
+MMSegmentation is an open source semantic segmentation toolbox based on PyTorch.
+It is a part of the OpenMMLab project.
+
+The [main](https://github.com/open-mmlab/mmsegmentation/tree/main) branch works with PyTorch 1.6+.
+
+### 🎉 Introducing MMSegmentation v1.0.0 🎉
+
+We are thrilled to announce the official release of MMSegmentation's latest version! For this new release, the [main](https://github.com/open-mmlab/mmsegmentation/tree/main) branch serves as the primary branch, while the development branch is [dev-1.x](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x). The stable branch for the previous release remains as the [0.x](https://github.com/open-mmlab/mmsegmentation/tree/0.x) branch. Please note that the [master](https://github.com/open-mmlab/mmsegmentation/tree/master) branch will only be maintained for a limited time before being removed. We encourage you to be mindful of branch selection and updates during use. Thank you for your unwavering support and enthusiasm, and let's work together to make MMSegmentation even more robust and powerful! 💪
+
+MMSegmentation v1.x brings remarkable improvements over the 0.x release, offering a more flexible and feature-packed experience. To utilize the new features in v1.x, we kindly invite you to consult our detailed [📚 migration guide](https://mmsegmentation.readthedocs.io/en/latest/migration/interface.html), which will help you seamlessly transition your projects. Your support is invaluable, and we eagerly await your feedback!
+
+![demo image](resources/seg_demo.gif)
+
+### Major features
+
+- **Unified Benchmark**
+
+  We provide a unified benchmark toolbox for various semantic segmentation methods.
+
+- **Modular Design**
+
+  We decompose the semantic segmentation framework into different components and one can easily construct a customized semantic segmentation framework by combining different modules.
+
+- **Support of multiple methods out of box**
+
+  The toolbox directly supports popular and contemporary semantic segmentation frameworks, *e.g.* PSPNet, DeepLabV3, PSANet, DeepLabV3+, etc.
+
+- **High efficiency**
+
+  The training speed is faster than or comparable to other codebases.
+
+## What's New
+
+v1.2.0 was released on 10/12/2023, from 1.1.0 to 1.2.0, we have added or updated the following features:
+
+### Highlights
+
+- Support for the open-vocabulary semantic segmentation algorithm [SAN](configs/san/README.md)
+
+- Support monocular depth estimation task, please refer to [VPD](configs/vpd/README.md) and [Adabins](projects/Adabins/README.md) for more details.
+
+  ![depth estimation](https://github.com/open-mmlab/mmsegmentation/assets/15952744/07afd0e9-8ace-4a00-aa1e-5bf0ca92dcbc)
+
+- Add new projects: open-vocabulary semantic segmentation algorithm [CAT-Seg](projects/CAT-Seg/README.md), real-time semantic segmentation algofithm [PP-MobileSeg](projects/pp_mobileseg/README.md)
+
+## Installation
+
+Please refer to [get_started.md](docs/en/get_started.md#installation) for installation and [dataset_prepare.md](docs/en/user_guides/2_dataset_prepare.md#prepare-datasets) for dataset preparation.
+
+## Get Started
+
+Please see [Overview](docs/en/overview.md) for the general introduction of MMSegmentation.
+
+Please see [user guides](https://mmsegmentation.readthedocs.io/en/latest/user_guides/index.html#) for the basic usage of MMSegmentation.
+There are also [advanced tutorials](https://mmsegmentation.readthedocs.io/en/latest/advanced_guides/index.html) for in-depth understanding of mmseg design and implementation .
+
+A Colab tutorial is also provided. You may preview the notebook [here](demo/MMSegmentation_Tutorial.ipynb) or directly [run](https://colab.research.google.com/github/open-mmlab/mmsegmentation/blob/main/demo/MMSegmentation_Tutorial.ipynb) on Colab.
+
+To migrate from MMSegmentation 0.x, please refer to [migration](docs/en/migration).
+
+## Tutorial
+
+<div align="center">
+  <b>MMSegmentation Tutorials</b>
+</div>
+<table align="center">
+  <tbody>
+    <tr align="center" valign="center">
+      <td>
+        <b>Get Started</b>
+      </td>
+      <td>
+        <b>MMSeg Basic Tutorial</b>
+      </td>
+      <td>
+        <b>MMSeg Detail Tutorial</b>
+      </td>
+      <td>
+        <b>MMSeg Development Tutorial</b>
+      </td>
+    </tr>
+    <tr valign="top">
+      <td>
+        <ul>
+          <li><a href="docs/en/overview.md">MMSeg overview</a></li>
+          <li><a href="docs/en/get_started.md">MMSeg Installation</a></li>
+          <li><a href="docs/en/notes/faq.md">FAQ</a></li>
+        </ul>
+      </td>
+      <td>
+        <ul>
+          <li><a href="docs/en/user_guides/1_config.md">Tutorial 1: Learn about Configs</a></li>
+          <li><a href="docs/en/user_guides/2_dataset_prepare.md">Tutorial 2: Prepare datasets</a></li>
+          <li><a href="docs/en/user_guides/3_inference.md">Tutorial 3: Inference with existing models</a></li>
+          <li><a href="docs/en/user_guides/4_train_test.md">Tutorial 4: Train and test with existing models</a></li>
+          <li><a href="docs/en/user_guides/5_deployment.md">Tutorial 5: Model deployment</a></li>
+          <li><a href="docs/zh_cn/user_guides/deploy_jetson.md">Deploy mmsegmentation on Jetson platform</a></li>
+          <li><a href="docs/en/user_guides/useful_tools.md">Useful Tools</a></li>
+          <li><a href="docs/en/user_guides/visualization_feature_map.md">Feature Map Visualization</a></li>
+          <li><a href="docs/en/user_guides/visualization.md">Visualization</a></li>
+        </ul>
+      </td>
+      <td>
+        <ul>
+          <li><a href="docs/en/advanced_guides/datasets.md">MMSeg Dataset</a></li>
+          <li><a href="docs/en/advanced_guides/models.md">MMSeg Models</a></li>
+          <li><a href="docs/en/advanced_guides/structures.md">MMSeg Dataset Structures</a></li>
+          <li><a href="docs/en/advanced_guides/transforms.md">MMSeg Data Transforms</a></li>
+          <li><a href="docs/en/advanced_guides/data_flow.md">MMSeg Dataflow</a></li>
+          <li><a href="docs/en/advanced_guides/engine.md">MMSeg Training Engine</a></li>
+          <li><a href="docs/en/advanced_guides/evaluation.md">MMSeg Evaluation</a></li>
+        </ul>
+      </td>
+      <td>
+        <ul>
+          <li><a href="docs/en/advanced_guides/add_datasets.md">Add New Datasets</a></li>
+          <li><a href="docs/en/advanced_guides/add_metrics.md">Add New Metrics</a></li>
+          <li><a href="docs/en/advanced_guides/add_models.md">Add New Modules</a></li>
+          <li><a href="docs/en/advanced_guides/add_transforms.md">Add New Data Transforms</a></li>
+          <li><a href="docs/en/advanced_guides/customize_runtime.md">Customize Runtime Settings</a></li>
+          <li><a href="docs/en/advanced_guides/training_tricks.md">Training Tricks</a></li>
+          <li><a href=".github/CONTRIBUTING.md">Contribute code to MMSeg</a></li>
+          <li><a href="docs/zh_cn/advanced_guides/contribute_dataset.md">Contribute a standard dataset in projects</a></li>
+          <li><a href="docs/en/device/npu.md">NPU (HUAWEI Ascend)</a></li>
+          <li><a href="docs/en/migration/interface.md">0.x → 1.x migration</a></li>
+          <li><a href="docs/en/migration/package.md">0.x → 1.x package</a></li>
+        </ul>
+      </td>
+    </tr>
+  </tbody>
+</table>
+
+## Benchmark and model zoo
+
+Results and models are available in the [model zoo](docs/en/model_zoo.md).
+
+<div align="center">
+  <b>Overview</b>
+</div>
+<table align="center">
+  <tbody>
+    <tr align="center" valign="center">
+      <td>
+        <b>Supported backbones</b>
+      </td>
+      <td>
+        <b>Supported methods</b>
+      </td>
+      <td>
+        <b>Supported Head</b>
+      </td>
+      <td>
+        <b>Supported datasets</b>
+      </td>
+      <td>
+        <b>Other</b>
+      </td>
+    </tr>
+    <tr valign="top">
+      <td>
+        <ul>
+        <li><a href="mmseg/models/backbones/resnet.py">ResNet(CVPR'2016)</a></li>
+        <li><a href="mmseg/models/backbones/resnext.py">ResNeXt (CVPR'2017)</a></li>
+        <li><a href="configs/hrnet">HRNet (CVPR'2019)</a></li>
+        <li><a href="configs/resnest">ResNeSt (ArXiv'2020)</a></li>
+        <li><a href="configs/mobilenet_v2">MobileNetV2 (CVPR'2018)</a></li>
+        <li><a href="configs/mobilenet_v3">MobileNetV3 (ICCV'2019)</a></li>
+        <li><a href="configs/vit">Vision Transformer (ICLR'2021)</a></li>
+        <li><a href="configs/swin">Swin Transformer (ICCV'2021)</a></li>
+        <li><a href="configs/twins">Twins (NeurIPS'2021)</a></li>
+        <li><a href="configs/beit">BEiT (ICLR'2022)</a></li>
+        <li><a href="configs/convnext">ConvNeXt (CVPR'2022)</a></li>
+        <li><a href="configs/mae">MAE (CVPR'2022)</a></li>
+        <li><a href="configs/poolformer">PoolFormer (CVPR'2022)</a></li>
+        <li><a href="configs/segnext">SegNeXt (NeurIPS'2022)</a></li>
+        </ul>
+      </td>
+      <td>
+        <ul>
+          <li><a href="configs/san/">SAN (CVPR'2023)</a></li>
+          <li><a href="configs/vpd">VPD (ICCV'2023)</a></li>
+          <li><a href="configs/ddrnet">DDRNet (T-ITS'2022)</a></li>
+          <li><a href="configs/pidnet">PIDNet (ArXiv'2022)</a></li>
+          <li><a href="configs/mask2former">Mask2Former (CVPR'2022)</a></li>
+          <li><a href="configs/maskformer">MaskFormer (NeurIPS'2021)</a></li>
+          <li><a href="configs/knet">K-Net (NeurIPS'2021)</a></li>
+          <li><a href="configs/segformer">SegFormer (NeurIPS'2021)</a></li>
+          <li><a href="configs/segmenter">Segmenter (ICCV'2021)</a></li>
+          <li><a href="configs/dpt">DPT (ArXiv'2021)</a></li>
+          <li><a href="configs/setr">SETR (CVPR'2021)</a></li>
+          <li><a href="configs/stdc">STDC (CVPR'2021)</a></li>
+          <li><a href="configs/bisenetv2">BiSeNetV2 (IJCV'2021)</a></li>
+          <li><a href="configs/cgnet">CGNet (TIP'2020)</a></li>
+          <li><a href="configs/point_rend">PointRend (CVPR'2020)</a></li>
+          <li><a href="configs/dnlnet">DNLNet (ECCV'2020)</a></li>
+          <li><a href="configs/ocrnet">OCRNet (ECCV'2020)</a></li>
+          <li><a href="configs/isanet">ISANet (ArXiv'2019/IJCV'2021)</a></li>
+          <li><a href="configs/fastscnn">Fast-SCNN (ArXiv'2019)</a></li>
+          <li><a href="configs/fastfcn">FastFCN (ArXiv'2019)</a></li>
+          <li><a href="configs/gcnet">GCNet (ICCVW'2019/TPAMI'2020)</a></li>
+          <li><a href="configs/ann">ANN (ICCV'2019)</a></li>
+          <li><a href="configs/emanet">EMANet (ICCV'2019)</a></li>
+          <li><a href="configs/ccnet">CCNet (ICCV'2019)</a></li>
+          <li><a href="configs/dmnet">DMNet (ICCV'2019)</a></li>
+          <li><a href="configs/sem_fpn">Semantic FPN (CVPR'2019)</a></li>
+          <li><a href="configs/danet">DANet (CVPR'2019)</a></li>
+          <li><a href="configs/apcnet">APCNet (CVPR'2019)</a></li>
+          <li><a href="configs/nonlocal_net">NonLocal Net (CVPR'2018)</a></li>
+          <li><a href="configs/encnet">EncNet (CVPR'2018)</a></li>
+          <li><a href="configs/deeplabv3plus">DeepLabV3+ (CVPR'2018)</a></li>
+          <li><a href="configs/upernet">UPerNet (ECCV'2018)</a></li>
+          <li><a href="configs/icnet">ICNet (ECCV'2018)</a></li>
+          <li><a href="configs/psanet">PSANet (ECCV'2018)</a></li>
+          <li><a href="configs/bisenetv1">BiSeNetV1 (ECCV'2018)</a></li>
+          <li><a href="configs/deeplabv3">DeepLabV3 (ArXiv'2017)</a></li>
+          <li><a href="configs/pspnet">PSPNet (CVPR'2017)</a></li>
+          <li><a href="configs/erfnet">ERFNet (T-ITS'2017)</a></li>
+          <li><a href="configs/unet">UNet (MICCAI'2016/Nat. Methods'2019)</a></li>
+          <li><a href="configs/fcn">FCN (CVPR'2015/TPAMI'2017)</a></li>
+        </ul>
+      </td>
+      <td>
+        <ul>
+          <li><a href="mmseg/models/decode_heads/ann_head.py">ANN_Head</li>
+          <li><a href="mmseg/models/decode_heads/apc_head.py">APC_Head</li>
+          <li><a href="mmseg/models/decode_heads/aspp_head.py">ASPP_Head</li>
+          <li><a href="mmseg/models/decode_heads/cc_head.py">CC_Head</li>
+          <li><a href="mmseg/models/decode_heads/da_head.py">DA_Head</li>
+          <li><a href="mmseg/models/decode_heads/ddr_head.py">DDR_Head</li>
+          <li><a href="mmseg/models/decode_heads/dm_head.py">DM_Head</li>
+          <li><a href="mmseg/models/decode_heads/dnl_head.py">DNL_Head</li>
+          <li><a href="mmseg/models/decode_heads/dpt_head.py">DPT_HEAD</li>
+          <li><a href="mmseg/models/decode_heads/ema_head.py">EMA_Head</li>
+          <li><a href="mmseg/models/decode_heads/enc_head.py">ENC_Head</li>
+          <li><a href="mmseg/models/decode_heads/fcn_head.py">FCN_Head</li>
+          <li><a href="mmseg/models/decode_heads/fpn_head.py">FPN_Head</li>
+          <li><a href="mmseg/models/decode_heads/gc_head.py">GC_Head</li>
+          <li><a href="mmseg/models/decode_heads/ham_head.py">LightHam_Head</li>
+          <li><a href="mmseg/models/decode_heads/isa_head.py">ISA_Head</li>
+          <li><a href="mmseg/models/decode_heads/knet_head.py">Knet_Head</li>
+          <li><a href="mmseg/models/decode_heads/lraspp_head.py">LRASPP_Head</li>
+          <li><a href="mmseg/models/decode_heads/mask2former_head.py">mask2former_Head</li>
+          <li><a href="mmseg/models/decode_heads/maskformer_head.py">maskformer_Head</li>
+          <li><a href="mmseg/models/decode_heads/nl_head.py">NL_Head</li>
+          <li><a href="mmseg/models/decode_heads/ocr_head.py">OCR_Head</li>
+          <li><a href="mmseg/models/decode_heads/pid_head.py">PID_Head</li>
+          <li><a href="mmseg/models/decode_heads/point_head.py">point_Head</li>
+          <li><a href="mmseg/models/decode_heads/psa_head.py">PSA_Head</li>
+          <li><a href="mmseg/models/decode_heads/psp_head.py">PSP_Head</li>
+          <li><a href="mmseg/models/decode_heads/san_head.py">SAN_Head</li>
+          <li><a href="mmseg/models/decode_heads/segformer_head.py">segformer_Head</li>
+          <li><a href="mmseg/models/decode_heads/segmenter_mask_head.py">segmenter_mask_Head</li>
+          <li><a href="mmseg/models/decode_heads/sep_aspp_head.py">SepASPP_Head</li>
+          <li><a href="mmseg/models/decode_heads/sep_fcn_head.py">SepFCN_Head</li>
+          <li><a href="mmseg/models/decode_heads/setr_mla_head.py">SETRMLAHead_Head</li>
+          <li><a href="mmseg/models/decode_heads/setr_up_head.py">SETRUP_Head</li>
+          <li><a href="mmseg/models/decode_heads/stdc_head.py">STDC_Head</li>
+          <li><a href="mmseg/models/decode_heads/uper_head.py">Uper_Head</li>
+          <li><a href="mmseg/models/decode_heads/vpd_depth_head.py">VPDDepth_Head</li>
+        </ul>
+      </td>
+      <td>
+        <ul>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#cityscapes">Cityscapes</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#pascal-voc">PASCAL VOC</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#ade20k">ADE20K</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#pascal-context">Pascal Context</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#coco-stuff-10k">COCO-Stuff 10k</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#coco-stuff-164k">COCO-Stuff 164k</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#chase-db1">CHASE_DB1</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#drive">DRIVE</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#hrf">HRF</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#stare">STARE</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#dark-zurich">Dark Zurich</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#nighttime-driving">Nighttime Driving</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#loveda">LoveDA</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#isprs-potsdam">Potsdam</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#isprs-vaihingen">Vaihingen</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#isaid">iSAID</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#mapillary-vistas-datasets">Mapillary Vistas</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#levir-cd">LEVIR-CD</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#bdd100K">BDD100K</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#nyu">NYU</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#hsi-drive-2.0">HSIDrive20</a></li>
+        </ul>
+      </td>
+      <td>
+        <ul>
+          <li><b>Supported loss</b></li>
+        <ul>
+          <li><a href="mmseg/models/losses/boundary_loss.py">boundary_loss</a></li>
+          <li><a href="mmseg/models/losses/cross_entropy_loss.py">cross_entropy_loss</a></li>
+          <li><a href="mmseg/models/losses/dice_loss.py">dice_loss</a></li>
+          <li><a href="mmseg/models/losses/focal_loss.py">focal_loss</a></li>
+          <li><a href="mmseg/models/losses/huasdorff_distance_loss.py">huasdorff_distance_loss</a></li>
+          <li><a href="mmseg/models/losses/kldiv_loss.py">kldiv_loss</a></li>
+          <li><a href="mmseg/models/losses/lovasz_loss.py">lovasz_loss</a></li>
+          <li><a href="mmseg/models/losses/ohem_cross_entropy_loss.py">ohem_cross_entropy_loss</a></li>
+          <li><a href="mmseg/models/losses/silog_loss.py">silog_loss</a></li>
+          <li><a href="mmseg/models/losses/tversky_loss.py">tversky_loss</a></li>
+        </ul>
+        </ul>
+      </td>
+  </tbody>
+</table>
+
+Please refer to [FAQ](docs/en/notes/faq.md) for frequently asked questions.
+
+## Projects
+
+[Here](projects/README.md) are some implementations of SOTA models and solutions built on MMSegmentation, which are supported and maintained by community users. These projects demonstrate the best practices based on MMSegmentation for research and product development. We welcome and appreciate all the contributions to OpenMMLab ecosystem.
+
+## Contributing
+
+We appreciate all contributions to improve MMSegmentation. Please refer to [CONTRIBUTING.md](.github/CONTRIBUTING.md) for the contributing guideline.
+
+## Acknowledgement
+
+MMSegmentation is an open source project that welcome any contribution and feedback.
+We wish that the toolbox and benchmark could serve the growing research
+community by providing a flexible as well as standardized toolkit to reimplement existing methods
+and develop their own new semantic segmentation methods.
+
+## Citation
+
+If you find this project useful in your research, please consider cite:
+
+```bibtex
+@misc{mmseg2020,
+    title={{MMSegmentation}: OpenMMLab Semantic Segmentation Toolbox and Benchmark},
+    author={MMSegmentation Contributors},
+    howpublished = {\url{https://github.com/open-mmlab/mmsegmentation}},
+    year={2020}
+}
+```
+
+## License
+
+This project is released under the [Apache 2.0 license](LICENSE).
+
+## OpenMMLab Family
+
+- [MMEngine](https://github.com/open-mmlab/mmengine): OpenMMLab foundational library for training deep learning models.
+- [MMCV](https://github.com/open-mmlab/mmcv): OpenMMLab foundational library for computer vision.
+- [MMPreTrain](https://github.com/open-mmlab/mmpretrain): OpenMMLab pre-training toolbox and benchmark.
+- [MMagic](https://github.com/open-mmlab/mmagic): Open**MM**Lab **A**dvanced, **G**enerative and **I**ntelligent **C**reation toolbox.
+- [MMDetection](https://github.com/open-mmlab/mmdetection): OpenMMLab detection toolbox and benchmark.
+- [MMYOLO](https://github.com/open-mmlab/mmyolo): OpenMMLab YOLO series toolbox and benchmark.
+- [MMDetection3D](https://github.com/open-mmlab/mmdetection3d): OpenMMLab's next-generation platform for general 3D object detection.
+- [MMRotate](https://github.com/open-mmlab/mmrotate): OpenMMLab rotated object detection toolbox and benchmark.
+- [MMTracking](https://github.com/open-mmlab/mmtracking): OpenMMLab video perception toolbox and benchmark.
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation): OpenMMLab semantic segmentation toolbox and benchmark.
+- [MMOCR](https://github.com/open-mmlab/mmocr): OpenMMLab text detection, recognition, and understanding toolbox.
+- [MMPose](https://github.com/open-mmlab/mmpose): OpenMMLab pose estimation toolbox and benchmark.
+- [MMHuman3D](https://github.com/open-mmlab/mmhuman3d): OpenMMLab 3D human parametric model toolbox and benchmark.
+- [MMFewShot](https://github.com/open-mmlab/mmfewshot): OpenMMLab fewshot learning toolbox and benchmark.
+- [MMAction2](https://github.com/open-mmlab/mmaction2): OpenMMLab's next-generation action understanding toolbox and benchmark.
+- [MMFlow](https://github.com/open-mmlab/mmflow): OpenMMLab optical flow toolbox and benchmark.
+- [MMDeploy](https://github.com/open-mmlab/mmdeploy): OpenMMLab Model Deployment Framework.
+- [MMRazor](https://github.com/open-mmlab/mmrazor): OpenMMLab model compression toolbox and benchmark.
+- [MIM](https://github.com/open-mmlab/mim): MIM installs OpenMMLab packages.
+- [Playground](https://github.com/open-mmlab/playground): A central hub for gathering and showcasing amazing projects built upon OpenMMLab.
diff --git a/mmsegmentation/README_zh-CN.md b/mmsegmentation/README_zh-CN.md
new file mode 100644
index 0000000..e047759
--- /dev/null
+++ b/mmsegmentation/README_zh-CN.md
@@ -0,0 +1,426 @@
+<div align="center">
+  <img src="resources/mmseg-logo.png" width="600"/>
+  <div>&nbsp;</div>
+  <div align="center">
+    <b><font size="5">OpenMMLab 官网</font></b>
+    <sup>
+      <a href="https://openmmlab.com">
+        <i><font size="4">HOT</font></i>
+      </a>
+    </sup>
+    &nbsp;&nbsp;&nbsp;&nbsp;
+    <b><font size="5">OpenMMLab 开放平台</font></b>
+    <sup>
+      <a href="https://platform.openmmlab.com">
+        <i><font size="4">TRY IT OUT</font></i>
+      </a>
+    </sup>
+  </div>
+  <div>&nbsp;</div>
+
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mmsegmentation)](https://pypi.org/project/mmsegmentation/)
+[![PyPI](https://img.shields.io/pypi/v/mmsegmentation)](https://pypi.org/project/mmsegmentation)
+[![docs](https://img.shields.io/badge/docs-latest-blue)](https://mmsegmentation.readthedocs.io/zh_CN/latest/)
+[![badge](https://github.com/open-mmlab/mmsegmentation/workflows/build/badge.svg)](https://github.com/open-mmlab/mmsegmentation/actions)
+[![codecov](https://codecov.io/gh/open-mmlab/mmsegmentation/branch/master/graph/badge.svg)](https://codecov.io/gh/open-mmlab/mmsegmentation)
+[![license](https://img.shields.io/github/license/open-mmlab/mmsegmentation.svg)](https://github.com/open-mmlab/mmsegmentation/blob/main/LICENSE)
+[![issue resolution](https://isitmaintained.com/badge/resolution/open-mmlab/mmsegmentation.svg)](https://github.com/open-mmlab/mmsegmentation/issues)
+[![open issues](https://isitmaintained.com/badge/open/open-mmlab/mmsegmentation.svg)](https://github.com/open-mmlab/mmsegmentation/issues)
+[![Open in OpenXLab](https://cdn-static.openxlab.org.cn/app-center/openxlab_demo.svg)](https://openxlab.org.cn/apps?search=mmseg)
+
+文档: <https://mmsegmentation.readthedocs.io/zh_CN/latest>
+
+[English](README.md) | 简体中文
+
+</div>
+
+<div align="center">
+  <a href="https://openmmlab.medium.com/" style="text-decoration:none;">
+    <img src="https://user-images.githubusercontent.com/25839884/219255827-67c1a27f-f8c5-46a9-811d-5e57448c61d1.png" width="3%" alt="" /></a>
+  <img src="https://user-images.githubusercontent.com/25839884/218346358-56cc8e2f-a2b8-487f-9088-32480cceabcf.png" width="3%" alt="" />
+  <a href="https://discord.gg/raweFPmdzG" style="text-decoration:none;">
+    <img src="https://user-images.githubusercontent.com/25839884/218347213-c080267f-cbb6-443e-8532-8e1ed9a58ea9.png" width="3%" alt="" /></a>
+  <img src="https://user-images.githubusercontent.com/25839884/218346358-56cc8e2f-a2b8-487f-9088-32480cceabcf.png" width="3%" alt="" />
+  <a href="https://twitter.com/OpenMMLab" style="text-decoration:none;">
+    <img src="https://user-images.githubusercontent.com/25839884/218346637-d30c8a0f-3eba-4699-8131-512fb06d46db.png" width="3%" alt="" /></a>
+  <img src="https://user-images.githubusercontent.com/25839884/218346358-56cc8e2f-a2b8-487f-9088-32480cceabcf.png" width="3%" alt="" />
+  <a href="https://www.youtube.com/openmmlab" style="text-decoration:none;">
+    <img src="https://user-images.githubusercontent.com/25839884/218346691-ceb2116a-465a-40af-8424-9f30d2348ca9.png" width="3%" alt="" /></a>
+  <img src="https://user-images.githubusercontent.com/25839884/218346358-56cc8e2f-a2b8-487f-9088-32480cceabcf.png" width="3%" alt="" />
+  <a href="https://space.bilibili.com/1293512903" style="text-decoration:none;">
+    <img src="https://user-images.githubusercontent.com/25839884/219026751-d7d14cce-a7c9-4e82-9942-8375fca65b99.png" width="3%" alt="" /></a>
+  <img src="https://user-images.githubusercontent.com/25839884/218346358-56cc8e2f-a2b8-487f-9088-32480cceabcf.png" width="3%" alt="" />
+  <a href="https://www.zhihu.com/people/openmmlab" style="text-decoration:none;">
+    <img src="https://user-images.githubusercontent.com/25839884/219026120-ba71e48b-6e94-4bd4-b4e9-b7d175b5e362.png" width="3%" alt="" /></a>
+</div>
+
+## 简介
+
+MMSegmentation 是一个基于 PyTorch 的语义分割开源工具箱。它是 OpenMMLab 项目的一部分。
+
+[main](https://github.com/open-mmlab/mmsegmentation/tree/main) 分支代码目前支持 PyTorch 1.6 以上的版本。
+
+### 🎉 MMSegmentation v1.0.0 简介 🎉
+
+我们非常高兴地宣布 MMSegmentation 最新版本的正式发布！在这个新版本中，主要分支是 [main](https://github.com/open-mmlab/mmsegmentation/tree/main) 分支，开发分支是 [dev-1.x](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x)。而之前版本的稳定分支保留为 [0.x](https://github.com/open-mmlab/mmsegmentation/tree/0.x) 分支。请注意，[master](https://github.com/open-mmlab/mmsegmentation/tree/master) 分支将只在有限的时间内维护，然后将被删除。我们鼓励您在使用过程中注意分支选择和更新。感谢您一如既往的支持和热情，让我们共同努力，使 MMSegmentation 变得更加健壮和强大！💪
+
+MMSegmentation v1.x 在 0.x 版本的基础上有了显著的提升，提供了更加灵活和功能丰富的体验。为了更好使用 v1.x 中的新功能，我们诚挚邀请您查阅我们详细的 [📚 迁移指南](https://mmsegmentation.readthedocs.io/zh_CN/latest/migration/interface.html)，以帮助您无缝地过渡您的项目。您的支持对我们来说非常宝贵，我们热切期待您的反馈！
+
+![示例图片](resources/seg_demo.gif)
+
+### 主要特性
+
+- **统一的基准平台**
+
+  我们将各种各样的语义分割算法集成到了一个统一的工具箱，进行基准测试。
+
+- **模块化设计**
+
+  MMSegmentation 将分割框架解耦成不同的模块组件，通过组合不同的模块组件，用户可以便捷地构建自定义的分割模型。
+
+- **丰富的即插即用的算法和模型**
+
+  MMSegmentation 支持了众多主流的和最新的检测算法，例如 PSPNet，DeepLabV3，PSANet，DeepLabV3+ 等.
+
+- **速度快**
+
+  训练速度比其他语义分割代码库更快或者相当。
+
+## 更新日志
+
+最新版本 v1.2.0 在 2023.10.12 发布。
+如果想了解更多版本更新细节和历史信息，请阅读[更新日志](docs/en/notes/changelog.md)。
+
+## 安装
+
+请参考[快速入门文档](docs/zh_cn/get_started.md#installation)进行安装，参考[数据集准备](docs/zh_cn/user_guides/2_dataset_prepare.md)处理数据。
+
+## 快速入门
+
+请参考[概述](docs/zh_cn/overview.md)对 MMSegmetation 进行初步了解
+
+请参考[用户指南](https://mmsegmentation.readthedocs.io/zh_CN/latest/user_guides/index.html)了解 mmseg 的基本使用，以及[进阶指南](https://mmsegmentation.readthedocs.io/zh_CN/latest/advanced_guides/index.html)深入了解 mmseg 设计和代码实现。
+
+同时，我们提供了 Colab 教程。你可以在[这里](demo/MMSegmentation_Tutorial.ipynb)浏览教程，或者直接在 Colab 上[运行](https://colab.research.google.com/github/open-mmlab/mmsegmentation/blob/main/demo/MMSegmentation_Tutorial.ipynb)。
+
+若需要将 0.x 版本的代码迁移至新版，请参考[迁移文档](docs/zh_cn/migration)。
+
+## 教程文档
+
+<div align="center">
+  <b>mmsegmentation 教程文档</b>
+</div>
+<table align="center">
+  <tbody>
+    <tr align="center" valign="center">
+      <td>
+        <b>开启 MMSeg 之旅</b>
+      </td>
+      <td>
+        <b>MMSeg 快速入门教程</b>
+      </td>
+      <td>
+        <b>MMSeg 细节介绍</b>
+      </td>
+      <td>
+        <b>MMSeg 开发教程</b>
+      </td>
+    </tr>
+    <tr valign="top">
+      <td>
+        <ul>
+        <li><a href="docs/zh_cn/overview.md">MMSeg 概述</a></li>
+        <li><a href="docs/zh_cn/get_started.md">安装和验证</a></li>
+        <li><a href="docs/zh_cn/notes/faq.md">常见问题解答</a></li>
+        </ul>
+      </td>
+      <td>
+        <ul>
+          <li><a href="docs/zh_cn/user_guides/1_config.md">教程1：了解配置文件</a></li>
+          <li><a href="docs/zh_cn/user_guides/2_dataset_prepare.md">教程2：准备数据集</a></li>
+          <li><a href="docs/zh_cn/user_guides/3_inference.md">教程3：使用预训练模型推理</a></li>
+          <li><a href="docs/zh_cn/user_guides/4_train_test.md">教程4：模型训练和测试</a></li>
+          <li><a href="docs/zh_cn/user_guides/5_deployment.md">教程5：模型部署</a></li>
+          <li><a href="docs/zh_cn/user_guides/deploy_jetson.md">在 Jetson 平台部署 MMSeg</a></li>
+          <li><a href="docs/zh_cn/user_guides/useful_tools.md">常用工具</a></li>
+          <li><a href="docs/zh_cn/user_guides/visualization_feature_map.md">特征图可视化</a></li>
+          <li><a href="docs/zh_cn/user_guides/visualization.md">可视化</a></li>
+        </ul>
+      </td>
+      <td>
+        <ul>
+          <li><a href="docs/zh_cn/advanced_guides/datasets.md">MMSeg 数据集介绍</a></li>
+          <li><a href="docs/zh_cn/advanced_guides/models.md">MMSeg 模型介绍</a></li>
+          <li><a href="docs/zh_cn/advanced_guides/structures.md">MMSeg 数据结构介绍</a></li>
+          <li><a href="docs/zh_cn/advanced_guides/transforms.md">MMSeg 数据增强介绍</a></li>
+          <li><a href="docs/zh_cn/advanced_guides/data_flow.md">MMSeg 数据流介绍</a></li>
+          <li><a href="docs/zh_cn/advanced_guides/engine.md">MMSeg 训练引擎介绍</a></li>
+          <li><a href="docs/zh_cn/advanced_guides/evaluation.md">MMSeg 模型评测介绍</a></li>
+        </ul>
+      </td>
+      <td>
+        <ul>
+          <li><a href="docs/zh_cn/advanced_guides/add_datasets.md">新增自定义数据集</a></li>
+          <li><a href="docs/zh_cn/advanced_guides/add_metrics.md">新增评测指标</a></li>
+          <li><a href="docs/zh_cn/advanced_guides/add_models.md">新增自定义模型</a></li>
+          <li><a href="docs/zh_cn/advanced_guides/add_transforms.md">新增自定义数据增强</a></li>
+          <li><a href="docs/zh_cn/advanced_guides/customize_runtime.md">自定义运行设定</a></li>
+          <li><a href="docs/zh_cn/advanced_guides/training_tricks.md">训练技巧</a></li>
+          <li><a href=".github/CONTRIBUTING.md">如何给 MMSeg 贡献代码</a></li>
+          <li><a href="docs/zh_cn/advanced_guides/contribute_dataset.md">给 MMSeg 贡献数据集教程</a></li>
+          <li><a href="docs/zh_cn/device/npu.md">NPU (华为 昇腾)</a></li>
+          <li><a href="docs/zh_cn/migration/interface.md">0.x → 1.x 迁移文档</a></li>
+          <li><a href="docs/zh_cn/migration/package.md">0.x → 1.x 库变更文档</a></li>
+        </ul>
+      </td>
+    </tr>
+  </tbody>
+</table>
+
+## 基准测试和模型库
+
+测试结果和模型可以在[模型库](docs/zh_cn/model_zoo.md)中找到。
+
+<div align="center">
+  <b>概览</b>
+</div>
+<table align="center">
+  <tbody>
+    <tr align="center" valign="bottom">
+      <td>
+        <b>已支持的主干网络</b>
+      </td>
+      <td>
+        <b>已支持的算法架构</b>
+      </td>
+      <td>
+        <b>已支持的分割头</b>
+      </td>
+      <td>
+        <b>已支持的数据集</b>
+      </td>
+      <td>
+        <b>其他</b>
+      </td>
+    </tr>
+    <tr valign="top">
+      <td>
+        <ul>
+        <li><a href="mmseg/models/backbones/resnet.py">ResNet(CVPR'2016)</a></li>
+        <li><a href="mmseg/models/backbones/resnext.py">ResNeXt (CVPR'2017)</a></li>
+        <li><a href="configs/hrnet">HRNet (CVPR'2019)</a></li>
+        <li><a href="configs/resnest">ResNeSt (ArXiv'2020)</a></li>
+        <li><a href="configs/mobilenet_v2">MobileNetV2 (CVPR'2018)</a></li>
+        <li><a href="configs/mobilenet_v3">MobileNetV3 (ICCV'2019)</a></li>
+        <li><a href="configs/vit">Vision Transformer (ICLR'2021)</a></li>
+        <li><a href="configs/swin">Swin Transformer (ICCV'2021)</a></li>
+        <li><a href="configs/twins">Twins (NeurIPS'2021)</a></li>
+        <li><a href="configs/beit">BEiT (ICLR'2022)</a></li>
+        <li><a href="configs/convnext">ConvNeXt (CVPR'2022)</a></li>
+        <li><a href="configs/mae">MAE (CVPR'2022)</a></li>
+        <li><a href="configs/poolformer">PoolFormer (CVPR'2022)</a></li>
+        <li><a href="configs/segnext">SegNeXt (NeurIPS'2022)</a></li>
+        </ul>
+      </td>
+      <td>
+        <ul>
+          <li><a href="configs/san/">SAN (CVPR'2023)</a></li>
+          <li><a href="configs/vpd">VPD (ICCV'2023)</a></li>
+          <li><a href="configs/ddrnet">DDRNet (T-ITS'2022)</a></li>
+          <li><a href="configs/pidnet">PIDNet (ArXiv'2022)</a></li>
+          <li><a href="configs/mask2former">Mask2Former (CVPR'2022)</a></li>
+          <li><a href="configs/maskformer">MaskFormer (NeurIPS'2021)</a></li>
+          <li><a href="configs/knet">K-Net (NeurIPS'2021)</a></li>
+          <li><a href="configs/segformer">SegFormer (NeurIPS'2021)</a></li>
+          <li><a href="configs/segmenter">Segmenter (ICCV'2021)</a></li>
+          <li><a href="configs/dpt">DPT (ArXiv'2021)</a></li>
+          <li><a href="configs/setr">SETR (CVPR'2021)</a></li>
+          <li><a href="configs/stdc">STDC (CVPR'2021)</a></li>
+          <li><a href="configs/bisenetv2">BiSeNetV2 (IJCV'2021)</a></li>
+          <li><a href="configs/cgnet">CGNet (TIP'2020)</a></li>
+          <li><a href="configs/point_rend">PointRend (CVPR'2020)</a></li>
+          <li><a href="configs/dnlnet">DNLNet (ECCV'2020)</a></li>
+          <li><a href="configs/ocrnet">OCRNet (ECCV'2020)</a></li>
+          <li><a href="configs/isanet">ISANet (ArXiv'2019/IJCV'2021)</a></li>
+          <li><a href="configs/fastscnn">Fast-SCNN (ArXiv'2019)</a></li>
+          <li><a href="configs/fastfcn">FastFCN (ArXiv'2019)</a></li>
+          <li><a href="configs/gcnet">GCNet (ICCVW'2019/TPAMI'2020)</a></li>
+          <li><a href="configs/ann">ANN (ICCV'2019)</a></li>
+          <li><a href="configs/emanet">EMANet (ICCV'2019)</a></li>
+          <li><a href="configs/ccnet">CCNet (ICCV'2019)</a></li>
+          <li><a href="configs/dmnet">DMNet (ICCV'2019)</a></li>
+          <li><a href="configs/sem_fpn">Semantic FPN (CVPR'2019)</a></li>
+          <li><a href="configs/danet">DANet (CVPR'2019)</a></li>
+          <li><a href="configs/apcnet">APCNet (CVPR'2019)</a></li>
+          <li><a href="configs/nonlocal_net">NonLocal Net (CVPR'2018)</a></li>
+          <li><a href="configs/encnet">EncNet (CVPR'2018)</a></li>
+          <li><a href="configs/deeplabv3plus">DeepLabV3+ (CVPR'2018)</a></li>
+          <li><a href="configs/upernet">UPerNet (ECCV'2018)</a></li>
+          <li><a href="configs/icnet">ICNet (ECCV'2018)</a></li>
+          <li><a href="configs/psanet">PSANet (ECCV'2018)</a></li>
+          <li><a href="configs/bisenetv1">BiSeNetV1 (ECCV'2018)</a></li>
+          <li><a href="configs/deeplabv3">DeepLabV3 (ArXiv'2017)</a></li>
+          <li><a href="configs/pspnet">PSPNet (CVPR'2017)</a></li>
+          <li><a href="configs/erfnet">ERFNet (T-ITS'2017)</a></li>
+          <li><a href="configs/unet">UNet (MICCAI'2016/Nat. Methods'2019)</a></li>
+          <li><a href="configs/fcn">FCN (CVPR'2015/TPAMI'2017)</a></li>
+        </ul>
+      </td>
+      <td>
+        <ul>
+          <li><a href="mmseg/models/decode_heads/ann_head.py">ANN_Head</li>
+          <li><a href="mmseg/models/decode_heads/apc_head.py">APC_Head</li>
+          <li><a href="mmseg/models/decode_heads/aspp_head.py">ASPP_Head</li>
+          <li><a href="mmseg/models/decode_heads/cc_head.py">CC_Head</li>
+          <li><a href="mmseg/models/decode_heads/da_head.py">DA_Head</li>
+          <li><a href="mmseg/models/decode_heads/ddr_head.py">DDR_Head</li>
+          <li><a href="mmseg/models/decode_heads/dm_head.py">DM_Head</li>
+          <li><a href="mmseg/models/decode_heads/dnl_head.py">DNL_Head</li>
+          <li><a href="mmseg/models/decode_heads/dpt_head.py">DPT_HEAD</li>
+          <li><a href="mmseg/models/decode_heads/ema_head.py">EMA_Head</li>
+          <li><a href="mmseg/models/decode_heads/enc_head.py">ENC_Head</li>
+          <li><a href="mmseg/models/decode_heads/fcn_head.py">FCN_Head</li>
+          <li><a href="mmseg/models/decode_heads/fpn_head.py">FPN_Head</li>
+          <li><a href="mmseg/models/decode_heads/gc_head.py">GC_Head</li>
+          <li><a href="mmseg/models/decode_heads/ham_head.py">LightHam_Head</li>
+          <li><a href="mmseg/models/decode_heads/isa_head.py">ISA_Head</li>
+          <li><a href="mmseg/models/decode_heads/knet_head.py">Knet_Head</li>
+          <li><a href="mmseg/models/decode_heads/lraspp_head.py">LRASPP_Head</li>
+          <li><a href="mmseg/models/decode_heads/mask2former_head.py">mask2former_Head</li>
+          <li><a href="mmseg/models/decode_heads/maskformer_head.py">maskformer_Head</li>
+          <li><a href="mmseg/models/decode_heads/nl_head.py">NL_Head</li>
+          <li><a href="mmseg/models/decode_heads/ocr_head.py">OCR_Head</li>
+          <li><a href="mmseg/models/decode_heads/pid_head.py">PID_Head</li>
+          <li><a href="mmseg/models/decode_heads/point_head.py">point_Head</li>
+          <li><a href="mmseg/models/decode_heads/psa_head.py">PSA_Head</li>
+          <li><a href="mmseg/models/decode_heads/psp_head.py">PSP_Head</li>
+          <li><a href="mmseg/models/decode_heads/san_head.py">SAN_Head</li>
+          <li><a href="mmseg/models/decode_heads/segformer_head.py">segformer_Head</li>
+          <li><a href="mmseg/models/decode_heads/segmenter_mask_head.py">segmenter_mask_Head</li>
+          <li><a href="mmseg/models/decode_heads/sep_aspp_head.py">SepASPP_Head</li>
+          <li><a href="mmseg/models/decode_heads/sep_fcn_head.py">SepFCN_Head</li>
+          <li><a href="mmseg/models/decode_heads/setr_mla_head.py">SETRMLAHead_Head</li>
+          <li><a href="mmseg/models/decode_heads/setr_up_head.py">SETRUP_Head</li>
+          <li><a href="mmseg/models/decode_heads/stdc_head.py">STDC_Head</li>
+          <li><a href="mmseg/models/decode_heads/uper_head.py">Uper_Head</li>
+          <li><a href="mmseg/models/decode_heads/vpd_depth_head.py">VPDDepth_Head</li>
+        </ul>
+      </td>
+      <td>
+        <ul>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#cityscapes">Cityscapes</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#pascal-voc">PASCAL VOC</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#ade20k">ADE20K</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#pascal-context">Pascal Context</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#coco-stuff-10k">COCO-Stuff 10k</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#coco-stuff-164k">COCO-Stuff 164k</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#chase-db1">CHASE_DB1</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#drive">DRIVE</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#hrf">HRF</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#stare">STARE</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#dark-zurich">Dark Zurich</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#nighttime-driving">Nighttime Driving</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#loveda">LoveDA</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#isprs-potsdam">Potsdam</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#isprs-vaihingen">Vaihingen</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#isaid">iSAID</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#mapillary-vistas-datasets">Mapillary Vistas</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#levir-cd">LEVIR-CD</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#bdd100K">BDD100K</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#nyu">NYU</a></li>
+          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#hsi-drive-2.0">HSIDrive20</a></li>
+        </ul>
+      </td>
+      <td>
+        <ul>
+          <li><b>已支持的 loss</b></li>
+        <ul>
+          <li><a href="mmseg/models/losses/boundary_loss.py">boundary_loss</a></li>
+          <li><a href="mmseg/models/losses/cross_entropy_loss.py">cross_entropy_loss</a></li>
+          <li><a href="mmseg/models/losses/dice_loss.py">dice_loss</a></li>
+          <li><a href="mmseg/models/losses/focal_loss.py">focal_loss</a></li>
+          <li><a href="mmseg/models/losses/huasdorff_distance_loss.py">huasdorff_distance_loss</a></li>
+          <li><a href="mmseg/models/losses/kldiv_loss.py">kldiv_loss</a></li>
+          <li><a href="mmseg/models/losses/lovasz_loss.py">lovasz_loss</a></li>
+          <li><a href="mmseg/models/losses/ohem_cross_entropy_loss.py">ohem_cross_entropy_loss</a></li>
+          <li><a href="mmseg/models/losses/silog_loss.py">silog_loss</a></li>
+          <li><a href="mmseg/models/losses/tversky_loss.py">tversky_loss</a></li>
+        </ul>
+        </ul>
+      </td>
+  </tbody>
+</table>
+
+如果遇到问题，请参考 [常见问题解答](docs/zh_cn/notes/faq.md)。
+
+## 社区项目
+
+[这里](projects/README.md)有一些由社区用户支持和维护的基于 MMSegmentation 的 SOTA 模型和解决方案的实现。这些项目展示了基于 MMSegmentation 的研究和产品开发的最佳实践。
+我们欢迎并感谢对 OpenMMLab 生态系统的所有贡献。
+
+## 贡献指南
+
+我们感谢所有的贡献者为改进和提升 MMSegmentation 所作出的努力。请参考[贡献指南](.github/CONTRIBUTING.md)来了解参与项目贡献的相关指引。
+
+## 致谢
+
+MMSegmentation 是一个由来自不同高校和企业的研发人员共同参与贡献的开源项目。我们感谢所有为项目提供算法复现和新功能支持的贡献者，以及提供宝贵反馈的用户。我们希望这个工具箱和基准测试可以为社区提供灵活的代码工具，供用户复现已有算法并开发自己的新模型，从而不断为开源社区提供贡献。
+
+## 引用
+
+如果你觉得本项目对你的研究工作有所帮助，请参考如下 bibtex 引用 MMSegmentation。
+
+```bibtex
+@misc{mmseg2020,
+    title={{MMSegmentation}: OpenMMLab Semantic Segmentation Toolbox and Benchmark},
+    author={MMSegmentation Contributors},
+    howpublished = {\url{https://github.com/open-mmlab/mmsegmentation}},
+    year={2020}
+}
+```
+
+## 开源许可证
+
+该项目采用 [Apache 2.0 开源许可证](LICENSE)。
+
+## OpenMMLab 的其他项目
+
+- [MMEngine](https://github.com/open-mmlab/mmengine): OpenMMLab 深度学习模型训练基础库
+- [MMCV](https://github.com/open-mmlab/mmcv): OpenMMLab 计算机视觉基础库
+- [MMPreTrain](https://github.com/open-mmlab/mmpretrain): OpenMMLab 深度学习预训练工具箱
+- [MMagic](https://github.com/open-mmlab/mmagic): OpenMMLab 新一代人工智能内容生成（AIGC）工具箱
+- [MMDetection](https://github.com/open-mmlab/mmdetection): OpenMMLab 目标检测工具箱
+- [MMYOLO](https://github.com/open-mmlab/mmyolo): OpenMMLab YOLO 系列工具箱与测试基准
+- [MMDetection3D](https://github.com/open-mmlab/mmdetection3d): OpenMMLab 新一代通用 3D 目标检测平台
+- [MMRotate](https://github.com/open-mmlab/mmrotate): OpenMMLab 旋转框检测工具箱与测试基准
+- [MMTracking](https://github.com/open-mmlab/mmtracking): OpenMMLab 一体化视频目标感知平台
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation): OpenMMLab 语义分割工具箱
+- [MMOCR](https://github.com/open-mmlab/mmocr): OpenMMLab 全流程文字检测识别理解工具包
+- [MMPose](https://github.com/open-mmlab/mmpose): OpenMMLab 姿态估计工具箱
+- [MMHuman3D](https://github.com/open-mmlab/mmhuman3d): OpenMMLab 人体参数化模型工具箱与测试基准
+- [MMFewShot](https://github.com/open-mmlab/mmfewshot): OpenMMLab 少样本学习工具箱与测试基准
+- [MMAction2](https://github.com/open-mmlab/mmaction2): OpenMMLab 新一代视频理解工具箱
+- [MMFlow](https://github.com/open-mmlab/mmflow): OpenMMLab 光流估计工具箱与测试基准
+- [MMDeploy](https://github.com/open-mmlab/mmdeploy): OpenMMLab 模型部署框架
+- [MMRazor](https://github.com/open-mmlab/mmrazor): OpenMMLab 模型压缩工具箱与测试基准
+- [MIM](https://github.com/open-mmlab/mim): OpenMMLab 项目、算法、模型的统一入口
+- [Playground](https://github.com/open-mmlab/playground): 收集和展示 OpenMMLab 相关的前沿、有趣的社区项目
+
+## 欢迎加入 OpenMMLab 社区
+
+扫描下方的二维码可关注 OpenMMLab 团队的 [知乎官方账号](https://www.zhihu.com/people/openmmlab)，扫描下方微信二维码添加喵喵好友，进入 MMSegmentation 微信交流社群。【加好友申请格式：研究方向+地区+学校/公司+姓名】
+
+<div align="center">
+<img src="docs/zh_cn/imgs/zhihu_qrcode.jpg" height="400" />  <img src="resources/miaomiao_qrcode.jpg" height="400" />
+</div>
+
+我们会在 OpenMMLab 社区为大家
+
+- 📢 分享 AI 框架的前沿核心技术
+- 💻 解读 PyTorch 常用模块源码
+- 📰 发布 OpenMMLab 的相关新闻
+- 🚀 介绍 OpenMMLab 开发的前沿算法
+- 🏃 获取更高效的问题答疑和意见反馈
+- 🔥 提供与各行各业开发者充分交流的平台
+
+干货满满 📘，等你来撩 💗，OpenMMLab 社区期待您的加入 👬
diff --git a/mmsegmentation/configs/_base_/datasets/ade20k.py b/mmsegmentation/configs/_base_/datasets/ade20k.py
new file mode 100644
index 0000000..48340d1
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/ade20k.py
@@ -0,0 +1,68 @@
+# dataset settings
+dataset_type = 'ADE20KDataset'
+data_root = 'data/ade/ADEChallengeData2016'
+crop_size = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(
+        type='RandomResize',
+        scale=(2048, 512),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/training', seg_map_path='annotations/training'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/ade20k_640x640.py b/mmsegmentation/configs/_base_/datasets/ade20k_640x640.py
new file mode 100644
index 0000000..c1f642d
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/ade20k_640x640.py
@@ -0,0 +1,68 @@
+# dataset settings
+dataset_type = 'ADE20KDataset'
+data_root = 'data/ade/ADEChallengeData2016'
+crop_size = (640, 640)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(
+        type='RandomResize',
+        scale=(2560, 640),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2560, 640), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/training', seg_map_path='annotations/training'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/bdd100k.py b/mmsegmentation/configs/_base_/datasets/bdd100k.py
new file mode 100644
index 0000000..24cec69
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/bdd100k.py
@@ -0,0 +1,70 @@
+# dataset settings
+dataset_type = 'BDD100KDataset'
+data_root = 'data/bdd100k/'
+
+crop_size = (512, 1024)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=(2048, 1024),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/10k/train',
+            seg_map_path='labels/sem_seg/masks/train'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/10k/val',
+            seg_map_path='labels/sem_seg/masks/val'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/chase_db1.py b/mmsegmentation/configs/_base_/datasets/chase_db1.py
new file mode 100644
index 0000000..ed47c2d
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/chase_db1.py
@@ -0,0 +1,75 @@
+# dataset settings
+dataset_type = 'ChaseDB1Dataset'
+data_root = 'data/CHASE_DB1'
+img_scale = (960, 999)
+crop_size = (128, 128)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=img_scale,
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type='RepeatDataset',
+        times=40000,
+        dataset=dict(
+            type=dataset_type,
+            data_root=data_root,
+            data_prefix=dict(
+                img_path='images/training',
+                seg_map_path='annotations/training'),
+            pipeline=train_pipeline)))
+
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mDice'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/cityscapes.py b/mmsegmentation/configs/_base_/datasets/cityscapes.py
new file mode 100644
index 0000000..b63a4cd
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/cityscapes.py
@@ -0,0 +1,67 @@
+# dataset settings
+dataset_type = 'CityscapesDataset'
+data_root = 'data/cityscapes/'
+crop_size = (512, 1024)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=(2048, 1024),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='leftImg8bit/train', seg_map_path='gtFine/train'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='leftImg8bit/val', seg_map_path='gtFine/val'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/cityscapes_1024x1024.py b/mmsegmentation/configs/_base_/datasets/cityscapes_1024x1024.py
new file mode 100644
index 0000000..72be307
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/cityscapes_1024x1024.py
@@ -0,0 +1,29 @@
+_base_ = './cityscapes.py'
+crop_size = (1024, 1024)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=(2048, 1024),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
+val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/cityscapes_768x768.py b/mmsegmentation/configs/_base_/datasets/cityscapes_768x768.py
new file mode 100644
index 0000000..fcee014
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/cityscapes_768x768.py
@@ -0,0 +1,29 @@
+_base_ = './cityscapes.py'
+crop_size = (768, 768)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=(2049, 1025),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2049, 1025), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
+val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/cityscapes_769x769.py b/mmsegmentation/configs/_base_/datasets/cityscapes_769x769.py
new file mode 100644
index 0000000..ae40ac8
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/cityscapes_769x769.py
@@ -0,0 +1,29 @@
+_base_ = './cityscapes.py'
+crop_size = (769, 769)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=(2049, 1025),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2049, 1025), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
+val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/cityscapes_832x832.py b/mmsegmentation/configs/_base_/datasets/cityscapes_832x832.py
new file mode 100644
index 0000000..0254580
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/cityscapes_832x832.py
@@ -0,0 +1,29 @@
+_base_ = './cityscapes.py'
+crop_size = (832, 832)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=(2048, 1024),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
+val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/coco-stuff10k.py b/mmsegmentation/configs/_base_/datasets/coco-stuff10k.py
new file mode 100644
index 0000000..5d6bb12
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/coco-stuff10k.py
@@ -0,0 +1,69 @@
+# dataset settings
+dataset_type = 'COCOStuffDataset'
+data_root = 'data/coco_stuff10k'
+crop_size = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(
+        type='RandomResize',
+        scale=(2048, 512),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        reduce_zero_label=True,
+        data_prefix=dict(
+            img_path='images/train2014', seg_map_path='annotations/train2014'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        reduce_zero_label=True,
+        data_prefix=dict(
+            img_path='images/test2014', seg_map_path='annotations/test2014'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/coco-stuff164k.py b/mmsegmentation/configs/_base_/datasets/coco-stuff164k.py
new file mode 100644
index 0000000..a9b9d90
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/coco-stuff164k.py
@@ -0,0 +1,67 @@
+# dataset settings
+dataset_type = 'COCOStuffDataset'
+data_root = 'data/coco_stuff164k'
+crop_size = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=(2048, 512),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/train2017', seg_map_path='annotations/train2017'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/val2017', seg_map_path='annotations/val2017'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/drive.py b/mmsegmentation/configs/_base_/datasets/drive.py
new file mode 100644
index 0000000..6a3dd82
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/drive.py
@@ -0,0 +1,73 @@
+# dataset settings
+dataset_type = 'DRIVEDataset'
+data_root = 'data/DRIVE'
+img_scale = (584, 565)
+crop_size = (64, 64)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=img_scale,
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type='RepeatDataset',
+        times=40000,
+        dataset=dict(
+            type=dataset_type,
+            data_root=data_root,
+            data_prefix=dict(
+                img_path='images/training',
+                seg_map_path='annotations/training'),
+            pipeline=train_pipeline)))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mDice'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/hrf.py b/mmsegmentation/configs/_base_/datasets/hrf.py
new file mode 100644
index 0000000..353d070
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/hrf.py
@@ -0,0 +1,73 @@
+# dataset settings
+dataset_type = 'HRFDataset'
+data_root = 'data/HRF'
+img_scale = (2336, 3504)
+crop_size = (256, 256)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=img_scale,
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type='RepeatDataset',
+        times=40000,
+        dataset=dict(
+            type=dataset_type,
+            data_root=data_root,
+            data_prefix=dict(
+                img_path='images/training',
+                seg_map_path='annotations/training'),
+            pipeline=train_pipeline)))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mDice'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/hsi_drive.py b/mmsegmentation/configs/_base_/datasets/hsi_drive.py
new file mode 100644
index 0000000..2d08e2d
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/hsi_drive.py
@@ -0,0 +1,53 @@
+train_pipeline = [
+    dict(type='LoadImageFromNpyFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='RandomCrop', crop_size=(192, 384)),
+    dict(type='PackSegInputs')
+]
+
+test_pipeline = [
+    dict(type='LoadImageFromNpyFile'),
+    dict(type='RandomCrop', crop_size=(192, 384)),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=1,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type='HSIDrive20Dataset',
+        data_root='data/HSIDrive20',
+        data_prefix=dict(
+            img_path='images/training', seg_map_path='annotations/training'),
+        pipeline=train_pipeline))
+
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=1,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='HSIDrive20Dataset',
+        data_root='data/HSIDrive20',
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
+        pipeline=test_pipeline))
+
+test_dataloader = dict(
+    batch_size=1,
+    num_workers=1,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='HSIDrive20Dataset',
+        data_root='data/HSIDrive20',
+        data_prefix=dict(
+            img_path='images/test', seg_map_path='annotations/test'),
+        pipeline=test_pipeline))
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'], ignore_index=0)
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/isaid.py b/mmsegmentation/configs/_base_/datasets/isaid.py
new file mode 100644
index 0000000..5cd4309
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/isaid.py
@@ -0,0 +1,73 @@
+# dataset settings
+dataset_type = 'iSAIDDataset'
+data_root = 'data/iSAID'
+"""
+This crop_size setting is followed by the implementation of
+`PointFlow: Flowing Semantics Through Points for Aerial Image
+Segmentation <https://arxiv.org/pdf/2103.06564.pdf>`_.
+"""
+
+crop_size = (896, 896)
+
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=(896, 896),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(896, 896), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='img_dir/train', seg_map_path='ann_dir/train'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(img_path='img_dir/val', seg_map_path='ann_dir/val'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/levir_256x256.py b/mmsegmentation/configs/_base_/datasets/levir_256x256.py
new file mode 100644
index 0000000..6e018a5
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/levir_256x256.py
@@ -0,0 +1,68 @@
+# dataset settings
+dataset_type = 'LEVIRCDDataset'
+data_root = r'data/LEVIRCD'
+
+albu_train_transforms = [
+    dict(type='RandomBrightnessContrast', p=0.2),
+    dict(type='HorizontalFlip', p=0.5),
+    dict(type='VerticalFlip', p=0.5)
+]
+
+train_pipeline = [
+    dict(type='LoadMultipleRSImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='Albu',
+        keymap={
+            'img': 'image',
+            'img2': 'image2',
+            'gt_seg_map': 'mask'
+        },
+        transforms=albu_train_transforms,
+        additional_targets={'image2': 'image'},
+        bgr_to_rgb=False),
+    dict(type='ConcatCDInput'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadMultipleRSImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='ConcatCDInput'),
+    dict(type='PackSegInputs')
+]
+
+tta_pipeline = [
+    dict(type='LoadMultipleRSImageFromFile'),
+    dict(
+        type='TestTimeAug',
+        transforms=[[dict(type='LoadAnnotations')],
+                    [dict(type='ConcatCDInput')],
+                    [dict(type='PackSegInputs')]])
+]
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='train/A',
+            img_path2='train/B',
+            seg_map_path='train/label'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='test/A', img_path2='test/B', seg_map_path='test/label'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/loveda.py b/mmsegmentation/configs/_base_/datasets/loveda.py
new file mode 100644
index 0000000..b93bc74
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/loveda.py
@@ -0,0 +1,66 @@
+# dataset settings
+dataset_type = 'LoveDADataset'
+data_root = 'data/loveDA'
+crop_size = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(
+        type='RandomResize',
+        scale=(2048, 512),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(1024, 1024), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='img_dir/train', seg_map_path='ann_dir/train'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(img_path='img_dir/val', seg_map_path='ann_dir/val'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/mapillary_v1.py b/mmsegmentation/configs/_base_/datasets/mapillary_v1.py
new file mode 100644
index 0000000..611aa47
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/mapillary_v1.py
@@ -0,0 +1,68 @@
+# dataset settings
+dataset_type = 'MapillaryDataset_v1'
+data_root = 'data/mapillary/'
+crop_size = (512, 1024)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=(2048, 1024),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', file_client_args=dict(backend='disk')),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='training/images', seg_map_path='training/v1.2/labels'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='validation/images',
+            seg_map_path='validation/v1.2/labels'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/mapillary_v1_65.py b/mmsegmentation/configs/_base_/datasets/mapillary_v1_65.py
new file mode 100644
index 0000000..f594f37
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/mapillary_v1_65.py
@@ -0,0 +1,37 @@
+# dataset settings
+_base_ = './mapillary_v1.py'
+metainfo = dict(
+    classes=('Bird', 'Ground Animal', 'Curb', 'Fence', 'Guard Rail', 'Barrier',
+             'Wall', 'Bike Lane', 'Crosswalk - Plain', 'Curb Cut', 'Parking',
+             'Pedestrian Area', 'Rail Track', 'Road', 'Service Lane',
+             'Sidewalk', 'Bridge', 'Building', 'Tunnel', 'Person', 'Bicyclist',
+             'Motorcyclist', 'Other Rider', 'Lane Marking - Crosswalk',
+             'Lane Marking - General', 'Mountain', 'Sand', 'Sky', 'Snow',
+             'Terrain', 'Vegetation', 'Water', 'Banner', 'Bench', 'Bike Rack',
+             'Billboard', 'Catch Basin', 'CCTV Camera', 'Fire Hydrant',
+             'Junction Box', 'Mailbox', 'Manhole', 'Phone Booth', 'Pothole',
+             'Street Light', 'Pole', 'Traffic Sign Frame', 'Utility Pole',
+             'Traffic Light', 'Traffic Sign (Back)', 'Traffic Sign (Front)',
+             'Trash Can', 'Bicycle', 'Boat', 'Bus', 'Car', 'Caravan',
+             'Motorcycle', 'On Rails', 'Other Vehicle', 'Trailer', 'Truck',
+             'Wheeled Slow', 'Car Mount', 'Ego Vehicle'),
+    palette=[[165, 42, 42], [0, 192, 0], [196, 196, 196], [190, 153, 153],
+             [180, 165, 180], [90, 120, 150], [102, 102, 156], [128, 64, 255],
+             [140, 140, 200], [170, 170, 170], [250, 170, 160], [96, 96, 96],
+             [230, 150, 140], [128, 64, 128], [110, 110, 110], [244, 35, 232],
+             [150, 100, 100], [70, 70, 70], [150, 120, 90], [220, 20, 60],
+             [255, 0, 0], [255, 0, 100], [255, 0, 200], [200, 128, 128],
+             [255, 255, 255], [64, 170, 64], [230, 160, 50], [70, 130, 180],
+             [190, 255, 255], [152, 251, 152], [107, 142, 35], [0, 170, 30],
+             [255, 255, 128], [250, 0, 30], [100, 140, 180], [220, 220, 220],
+             [220, 128, 128], [222, 40, 40], [100, 170, 30], [40, 40, 40],
+             [33, 33, 33], [100, 128, 160], [142, 0, 0], [70, 100, 150],
+             [210, 170, 100], [153, 153, 153], [128, 128, 128], [0, 0, 80],
+             [250, 170, 30], [192, 192, 192], [220, 220, 0], [140, 140, 20],
+             [119, 11, 32], [150, 0, 255], [0, 60, 100], [0, 0, 142],
+             [0, 0, 90], [0, 0, 230], [0, 80, 100], [128, 64, 64], [0, 0, 110],
+             [0, 0, 70], [0, 0, 192], [32, 32, 32], [120, 10, 10]])
+
+train_dataloader = dict(dataset=dict(metainfo=metainfo))
+val_dataloader = dict(dataset=dict(metainfo=metainfo))
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/_base_/datasets/mapillary_v2.py b/mmsegmentation/configs/_base_/datasets/mapillary_v2.py
new file mode 100644
index 0000000..7cb7a95
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/mapillary_v2.py
@@ -0,0 +1,68 @@
+# dataset settings
+dataset_type = 'MapillaryDataset_v2'
+data_root = 'data/mapillary/'
+crop_size = (512, 1024)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=(2048, 1024),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', file_client_args=dict(backend='disk')),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='training/images', seg_map_path='training/v2.0/labels'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='validation/images',
+            seg_map_path='validation/v2.0/labels'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/nyu.py b/mmsegmentation/configs/_base_/datasets/nyu.py
new file mode 100644
index 0000000..74d57c5
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/nyu.py
@@ -0,0 +1,67 @@
+# dataset settings
+dataset_type = 'NYUDataset'
+data_root = 'data/nyu'
+
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadDepthAnnotation', depth_rescale_factor=1e-3),
+    dict(type='RandomDepthMix', prob=0.25),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='RandomCrop', crop_size=(480, 480)),
+    dict(
+        type='Albu',
+        transforms=[
+            dict(type='RandomBrightnessContrast'),
+            dict(type='RandomGamma'),
+            dict(type='HueSaturationValue'),
+        ]),
+    dict(
+        type='PackSegInputs',
+        meta_keys=('img_path', 'depth_map_path', 'ori_shape', 'img_shape',
+                   'pad_shape', 'scale_factor', 'flip', 'flip_direction',
+                   'category_id')),
+]
+
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2000, 480), keep_ratio=True),
+    dict(dict(type='LoadDepthAnnotation', depth_rescale_factor=1e-3)),
+    dict(
+        type='PackSegInputs',
+        meta_keys=('img_path', 'depth_map_path', 'ori_shape', 'img_shape',
+                   'pad_shape', 'scale_factor', 'flip', 'flip_direction',
+                   'category_id'))
+]
+
+train_dataloader = dict(
+    batch_size=8,
+    num_workers=8,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/train', depth_map_path='annotations/train'),
+        pipeline=train_pipeline))
+
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        test_mode=True,
+        data_prefix=dict(
+            img_path='images/test', depth_map_path='annotations/test'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(
+    type='DepthMetric',
+    min_depth_eval=0.001,
+    max_depth_eval=10.0,
+    crop_type='nyu_crop')
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/nyu_512x512.py b/mmsegmentation/configs/_base_/datasets/nyu_512x512.py
new file mode 100644
index 0000000..88e3878
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/nyu_512x512.py
@@ -0,0 +1,72 @@
+# dataset settings
+dataset_type = 'NYUDataset'
+data_root = 'data/nyu'
+
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadDepthAnnotation', depth_rescale_factor=1e-3),
+    dict(type='RandomDepthMix', prob=0.25),
+    dict(type='RandomFlip', prob=0.5),
+    dict(
+        type='RandomResize',
+        scale=(768, 512),
+        ratio_range=(0.8, 1.5),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=(512, 512)),
+    dict(
+        type='Albu',
+        transforms=[
+            dict(type='RandomBrightnessContrast'),
+            dict(type='RandomGamma'),
+            dict(type='HueSaturationValue'),
+        ]),
+    dict(
+        type='PackSegInputs',
+        meta_keys=('img_path', 'depth_map_path', 'ori_shape', 'img_shape',
+                   'pad_shape', 'scale_factor', 'flip', 'flip_direction',
+                   'category_id')),
+]
+
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+    dict(dict(type='LoadDepthAnnotation', depth_rescale_factor=1e-3)),
+    dict(
+        type='PackSegInputs',
+        meta_keys=('img_path', 'depth_map_path', 'ori_shape', 'img_shape',
+                   'pad_shape', 'scale_factor', 'flip', 'flip_direction',
+                   'category_id'))
+]
+
+train_dataloader = dict(
+    batch_size=8,
+    num_workers=8,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/train', depth_map_path='annotations/train'),
+        pipeline=train_pipeline))
+
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        test_mode=True,
+        data_prefix=dict(
+            img_path='images/test', depth_map_path='annotations/test'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(
+    type='DepthMetric',
+    min_depth_eval=0.001,
+    max_depth_eval=10.0,
+    crop_type='nyu_crop')
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/pascal_context.py b/mmsegmentation/configs/_base_/datasets/pascal_context.py
new file mode 100644
index 0000000..dfb1f85
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/pascal_context.py
@@ -0,0 +1,56 @@
+# dataset settings
+dataset_type = 'PascalContextDataset'
+data_root = 'data/VOCdevkit/VOC2010/'
+
+img_scale = (520, 520)
+crop_size = (480, 480)
+
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=img_scale,
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='JPEGImages', seg_map_path='SegmentationClassContext'),
+        ann_file='ImageSets/SegmentationContext/train.txt',
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='JPEGImages', seg_map_path='SegmentationClassContext'),
+        ann_file='ImageSets/SegmentationContext/val.txt',
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/pascal_context_59.py b/mmsegmentation/configs/_base_/datasets/pascal_context_59.py
new file mode 100644
index 0000000..7f31043
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/pascal_context_59.py
@@ -0,0 +1,72 @@
+# dataset settings
+dataset_type = 'PascalContextDataset59'
+data_root = 'data/VOCdevkit/VOC2010/'
+
+img_scale = (520, 520)
+crop_size = (480, 480)
+
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(
+        type='RandomResize',
+        scale=img_scale,
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='JPEGImages', seg_map_path='SegmentationClassContext'),
+        ann_file='ImageSets/SegmentationContext/train.txt',
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='JPEGImages', seg_map_path='SegmentationClassContext'),
+        ann_file='ImageSets/SegmentationContext/val.txt',
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/pascal_voc12.py b/mmsegmentation/configs/_base_/datasets/pascal_voc12.py
new file mode 100644
index 0000000..5235ca9
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/pascal_voc12.py
@@ -0,0 +1,69 @@
+# dataset settings
+dataset_type = 'PascalVOCDataset'
+data_root = 'data/VOCdevkit/VOC2012'
+crop_size = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=(2048, 512),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='JPEGImages', seg_map_path='SegmentationClass'),
+        ann_file='ImageSets/Segmentation/train.txt',
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='JPEGImages', seg_map_path='SegmentationClass'),
+        ann_file='ImageSets/Segmentation/val.txt',
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/pascal_voc12_aug.py b/mmsegmentation/configs/_base_/datasets/pascal_voc12_aug.py
new file mode 100644
index 0000000..69c3654
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/pascal_voc12_aug.py
@@ -0,0 +1,81 @@
+# dataset settings
+dataset_type = 'PascalVOCDataset'
+data_root = 'data/VOCdevkit/VOC2012'
+crop_size = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=(2048, 512),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
+]
+
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+dataset_train = dict(
+    type=dataset_type,
+    data_root=data_root,
+    data_prefix=dict(img_path='JPEGImages', seg_map_path='SegmentationClass'),
+    ann_file='ImageSets/Segmentation/train.txt',
+    pipeline=train_pipeline)
+
+dataset_aug = dict(
+    type=dataset_type,
+    data_root=data_root,
+    data_prefix=dict(
+        img_path='JPEGImages', seg_map_path='SegmentationClassAug'),
+    ann_file='ImageSets/Segmentation/aug.txt',
+    pipeline=train_pipeline)
+
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(type='ConcatDataset', datasets=[dataset_train, dataset_aug]))
+
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='JPEGImages', seg_map_path='SegmentationClass'),
+        ann_file='ImageSets/Segmentation/val.txt',
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/potsdam.py b/mmsegmentation/configs/_base_/datasets/potsdam.py
new file mode 100644
index 0000000..95f6039
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/potsdam.py
@@ -0,0 +1,66 @@
+# dataset settings
+dataset_type = 'PotsdamDataset'
+data_root = 'data/potsdam'
+crop_size = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(
+        type='RandomResize',
+        scale=(512, 512),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(512, 512), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='img_dir/train', seg_map_path='ann_dir/train'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(img_path='img_dir/val', seg_map_path='ann_dir/val'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/refuge.py b/mmsegmentation/configs/_base_/datasets/refuge.py
new file mode 100644
index 0000000..79bb4d4
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/refuge.py
@@ -0,0 +1,90 @@
+# dataset settings
+dataset_type = 'REFUGEDataset'
+data_root = 'data/REFUGE'
+train_img_scale = (2056, 2124)
+val_img_scale = (1634, 1634)
+test_img_scale = (1634, 1634)
+crop_size = (512, 512)
+
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=False),
+    dict(
+        type='RandomResize',
+        scale=train_img_scale,
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+val_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=val_img_scale, keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations', reduce_zero_label=False),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=test_img_scale, keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations', reduce_zero_label=False),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=dict(backend='local')),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/training', seg_map_path='annotations/training'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
+        pipeline=val_pipeline))
+test_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/test', seg_map_path='annotations/test'),
+        pipeline=val_pipeline))
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mDice'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/stare.py b/mmsegmentation/configs/_base_/datasets/stare.py
new file mode 100644
index 0000000..b7545dc
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/stare.py
@@ -0,0 +1,73 @@
+# dataset settings
+dataset_type = 'STAREDataset'
+data_root = 'data/STARE'
+img_scale = (605, 700)
+crop_size = (128, 128)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=img_scale,
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type='RepeatDataset',
+        times=40000,
+        dataset=dict(
+            type=dataset_type,
+            data_root=data_root,
+            data_prefix=dict(
+                img_path='images/training',
+                seg_map_path='annotations/training'),
+            pipeline=train_pipeline)))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mDice'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/synapse.py b/mmsegmentation/configs/_base_/datasets/synapse.py
new file mode 100644
index 0000000..8685291
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/synapse.py
@@ -0,0 +1,41 @@
+dataset_type = 'SynapseDataset'
+data_root = 'data/synapse/'
+img_scale = (224, 224)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=True),
+    dict(type='RandomRotFlip', rotate_prob=0.5, flip_prob=0.5, degree=20),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=True),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=6,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='img_dir/train', seg_map_path='ann_dir/train'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(img_path='img_dir/val', seg_map_path='ann_dir/val'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mDice'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/datasets/vaihingen.py b/mmsegmentation/configs/_base_/datasets/vaihingen.py
new file mode 100644
index 0000000..6c78994
--- /dev/null
+++ b/mmsegmentation/configs/_base_/datasets/vaihingen.py
@@ -0,0 +1,66 @@
+# dataset settings
+dataset_type = 'ISPRSDataset'
+data_root = 'data/vaihingen'
+crop_size = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(
+        type='RandomResize',
+        scale=(512, 512),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(512, 512), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='img_dir/train', seg_map_path='ann_dir/train'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(img_path='img_dir/val', seg_map_path='ann_dir/val'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/_base_/default_runtime.py b/mmsegmentation/configs/_base_/default_runtime.py
new file mode 100644
index 0000000..272b4d2
--- /dev/null
+++ b/mmsegmentation/configs/_base_/default_runtime.py
@@ -0,0 +1,15 @@
+default_scope = 'mmseg'
+env_cfg = dict(
+    cudnn_benchmark=True,
+    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+    dist_cfg=dict(backend='nccl'),
+)
+vis_backends = [dict(type='LocalVisBackend')]
+visualizer = dict(
+    type='SegLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+log_processor = dict(by_epoch=False)
+log_level = 'INFO'
+load_from = None
+resume = False
+
+tta_model = dict(type='SegTTAModel')
diff --git a/mmsegmentation/configs/_base_/models/ann_r50-d8.py b/mmsegmentation/configs/_base_/models/ann_r50-d8.py
new file mode 100644
index 0000000..a1ef956
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/ann_r50-d8.py
@@ -0,0 +1,54 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='ANNHead',
+        in_channels=[1024, 2048],
+        in_index=[2, 3],
+        channels=512,
+        project_channels=256,
+        query_scales=(1, ),
+        key_pool_scales=(1, 3, 6, 8),
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/apcnet_r50-d8.py b/mmsegmentation/configs/_base_/models/apcnet_r50-d8.py
new file mode 100644
index 0000000..63269f9
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/apcnet_r50-d8.py
@@ -0,0 +1,52 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='APCHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        pool_scales=(1, 2, 3, 6),
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/bisenetv1_r18-d32.py b/mmsegmentation/configs/_base_/models/bisenetv1_r18-d32.py
new file mode 100644
index 0000000..2aecb9e
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/bisenetv1_r18-d32.py
@@ -0,0 +1,76 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='BiSeNetV1',
+        in_channels=3,
+        context_channels=(128, 256, 512),
+        spatial_channels=(64, 64, 64, 128),
+        out_indices=(0, 1, 2),
+        out_channels=256,
+        backbone_cfg=dict(
+            type='ResNet',
+            in_channels=3,
+            depth=18,
+            num_stages=4,
+            out_indices=(0, 1, 2, 3),
+            dilations=(1, 1, 1, 1),
+            strides=(1, 2, 2, 2),
+            norm_cfg=norm_cfg,
+            norm_eval=False,
+            style='pytorch',
+            contract_dilation=True),
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        init_cfg=None),
+    decode_head=dict(
+        type='FCNHead',
+        in_channels=256,
+        in_index=0,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=[
+        dict(
+            type='FCNHead',
+            in_channels=128,
+            channels=64,
+            num_convs=1,
+            num_classes=19,
+            in_index=1,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+        dict(
+            type='FCNHead',
+            in_channels=128,
+            channels=64,
+            num_convs=1,
+            num_classes=19,
+            in_index=2,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    ],
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/bisenetv2.py b/mmsegmentation/configs/_base_/models/bisenetv2.py
new file mode 100644
index 0000000..ae84512
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/bisenetv2.py
@@ -0,0 +1,88 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        type='BiSeNetV2',
+        detail_channels=(64, 64, 128),
+        semantic_channels=(16, 32, 64, 128),
+        semantic_expansion_ratio=6,
+        bga_channels=128,
+        out_indices=(0, 1, 2, 3, 4),
+        init_cfg=None,
+        align_corners=False),
+    decode_head=dict(
+        type='FCNHead',
+        in_channels=128,
+        in_index=0,
+        channels=1024,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=[
+        dict(
+            type='FCNHead',
+            in_channels=16,
+            channels=16,
+            num_convs=2,
+            num_classes=19,
+            in_index=1,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+        dict(
+            type='FCNHead',
+            in_channels=32,
+            channels=64,
+            num_convs=2,
+            num_classes=19,
+            in_index=2,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+        dict(
+            type='FCNHead',
+            in_channels=64,
+            channels=256,
+            num_convs=2,
+            num_classes=19,
+            in_index=3,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+        dict(
+            type='FCNHead',
+            in_channels=128,
+            channels=1024,
+            num_convs=2,
+            num_classes=19,
+            in_index=4,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    ],
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/ccnet_r50-d8.py b/mmsegmentation/configs/_base_/models/ccnet_r50-d8.py
new file mode 100644
index 0000000..575d8eb
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/ccnet_r50-d8.py
@@ -0,0 +1,52 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='CCHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        recurrence=2,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/cgnet.py b/mmsegmentation/configs/_base_/models/cgnet.py
new file mode 100644
index 0000000..93c6f5b
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/cgnet.py
@@ -0,0 +1,43 @@
+# model settings
+norm_cfg = dict(type='SyncBN', eps=1e-03, requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[72.39239876, 82.90891754, 73.15835921],
+    std=[1, 1, 1],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='CGNet',
+        norm_cfg=norm_cfg,
+        in_channels=3,
+        num_channels=(32, 64, 128),
+        num_blocks=(3, 21),
+        dilations=(2, 4),
+        reductions=(8, 16)),
+    decode_head=dict(
+        type='FCNHead',
+        in_channels=256,
+        in_index=2,
+        channels=256,
+        num_convs=0,
+        concat_input=False,
+        dropout_ratio=0,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        loss_decode=dict(
+            type='CrossEntropyLoss',
+            use_sigmoid=False,
+            loss_weight=1.0,
+            class_weight=[
+                2.5959933, 6.7415504, 3.5354059, 9.8663225, 9.690899, 9.369352,
+                10.289121, 9.953208, 4.3097677, 9.490387, 7.674431, 9.396905,
+                10.347791, 6.3927646, 10.226669, 10.241062, 10.280587,
+                10.396974, 10.055647
+            ])),
+    # model training and testing settings
+    train_cfg=dict(sampler=None),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/danet_r50-d8.py b/mmsegmentation/configs/_base_/models/danet_r50-d8.py
new file mode 100644
index 0000000..8163b3d
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/danet_r50-d8.py
@@ -0,0 +1,52 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='DAHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        pam_channels=64,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/deeplabv3_r50-d8.py b/mmsegmentation/configs/_base_/models/deeplabv3_r50-d8.py
new file mode 100644
index 0000000..22efe9a
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/deeplabv3_r50-d8.py
@@ -0,0 +1,52 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='ASPPHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        dilations=(1, 12, 24, 36),
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/deeplabv3_unet_s5-d16.py b/mmsegmentation/configs/_base_/models/deeplabv3_unet_s5-d16.py
new file mode 100644
index 0000000..92df52c
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/deeplabv3_unet_s5-d16.py
@@ -0,0 +1,58 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        type='UNet',
+        in_channels=3,
+        base_channels=64,
+        num_stages=5,
+        strides=(1, 1, 1, 1, 1),
+        enc_num_convs=(2, 2, 2, 2, 2),
+        dec_num_convs=(2, 2, 2, 2),
+        downsamples=(True, True, True, True),
+        enc_dilations=(1, 1, 1, 1, 1),
+        dec_dilations=(1, 1, 1, 1),
+        with_cp=False,
+        conv_cfg=None,
+        norm_cfg=norm_cfg,
+        act_cfg=dict(type='ReLU'),
+        upsample_cfg=dict(type='InterpConv'),
+        norm_eval=False),
+    decode_head=dict(
+        type='ASPPHead',
+        in_channels=64,
+        in_index=4,
+        channels=16,
+        dilations=(1, 12, 24, 36),
+        dropout_ratio=0.1,
+        num_classes=2,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=128,
+        in_index=3,
+        channels=64,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=2,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='slide', crop_size=256, stride=170))
diff --git a/mmsegmentation/configs/_base_/models/deeplabv3plus_r50-d8.py b/mmsegmentation/configs/_base_/models/deeplabv3plus_r50-d8.py
new file mode 100644
index 0000000..74dbed5
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/deeplabv3plus_r50-d8.py
@@ -0,0 +1,54 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='DepthwiseSeparableASPPHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        dilations=(1, 12, 24, 36),
+        c1_in_channels=256,
+        c1_channels=48,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/dmnet_r50-d8.py b/mmsegmentation/configs/_base_/models/dmnet_r50-d8.py
new file mode 100644
index 0000000..f66a042
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/dmnet_r50-d8.py
@@ -0,0 +1,52 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='DMHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        filter_sizes=(1, 3, 5, 7),
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/dnl_r50-d8.py b/mmsegmentation/configs/_base_/models/dnl_r50-d8.py
new file mode 100644
index 0000000..ee64056
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/dnl_r50-d8.py
@@ -0,0 +1,54 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='DNLHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        dropout_ratio=0.1,
+        reduction=2,
+        use_scale=True,
+        mode='embedded_gaussian',
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/dpt_vit-b16.py b/mmsegmentation/configs/_base_/models/dpt_vit-b16.py
new file mode 100644
index 0000000..90845b3
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/dpt_vit-b16.py
@@ -0,0 +1,39 @@
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='pretrain/vit-b16_p16_224-80ecf9dd.pth', # noqa
+    backbone=dict(
+        type='VisionTransformer',
+        img_size=224,
+        embed_dims=768,
+        num_layers=12,
+        num_heads=12,
+        out_indices=(2, 5, 8, 11),
+        final_norm=False,
+        with_cls_token=True,
+        output_cls_token=True),
+    decode_head=dict(
+        type='DPTHead',
+        in_channels=(768, 768, 768, 768),
+        channels=256,
+        embed_dims=768,
+        post_process_channels=[96, 192, 384, 768],
+        num_classes=150,
+        readout_type='project',
+        input_transform='multiple_select',
+        in_index=(0, 1, 2, 3),
+        norm_cfg=norm_cfg,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=None,
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))  # yapf: disable
diff --git a/mmsegmentation/configs/_base_/models/emanet_r50-d8.py b/mmsegmentation/configs/_base_/models/emanet_r50-d8.py
new file mode 100644
index 0000000..c55af4f
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/emanet_r50-d8.py
@@ -0,0 +1,55 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='EMAHead',
+        in_channels=2048,
+        in_index=3,
+        channels=256,
+        ema_channels=512,
+        num_bases=64,
+        num_stages=3,
+        momentum=0.1,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/encnet_r50-d8.py b/mmsegmentation/configs/_base_/models/encnet_r50-d8.py
new file mode 100644
index 0000000..63cec9e
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/encnet_r50-d8.py
@@ -0,0 +1,56 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='EncHead',
+        in_channels=[512, 1024, 2048],
+        in_index=(1, 2, 3),
+        channels=512,
+        num_codes=32,
+        use_se_loss=True,
+        add_lateral=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
+        loss_se_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.2)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/erfnet_fcn.py b/mmsegmentation/configs/_base_/models/erfnet_fcn.py
new file mode 100644
index 0000000..4d68a72
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/erfnet_fcn.py
@@ -0,0 +1,40 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        type='ERFNet',
+        in_channels=3,
+        enc_downsample_channels=(16, 64, 128),
+        enc_stage_non_bottlenecks=(5, 8),
+        enc_non_bottleneck_dilations=(2, 4, 8, 16),
+        enc_non_bottleneck_channels=(64, 128),
+        dec_upsample_channels=(64, 16),
+        dec_stages_non_bottleneck=(2, 2),
+        dec_non_bottleneck_channels=(64, 16),
+        dropout_ratio=0.1,
+        init_cfg=None),
+    decode_head=dict(
+        type='FCNHead',
+        in_channels=16,
+        channels=128,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/fast_scnn.py b/mmsegmentation/configs/_base_/models/fast_scnn.py
new file mode 100644
index 0000000..11127b0
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/fast_scnn.py
@@ -0,0 +1,65 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True, momentum=0.01)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='FastSCNN',
+        downsample_dw_channels=(32, 48),
+        global_in_channels=64,
+        global_block_channels=(64, 96, 128),
+        global_block_strides=(2, 2, 1),
+        global_out_channels=128,
+        higher_in_channels=64,
+        lower_in_channels=128,
+        fusion_out_channels=128,
+        out_indices=(0, 1, 2),
+        norm_cfg=norm_cfg,
+        align_corners=False),
+    decode_head=dict(
+        type='DepthwiseSeparableFCNHead',
+        in_channels=128,
+        channels=128,
+        concat_input=False,
+        num_classes=19,
+        in_index=-1,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1)),
+    auxiliary_head=[
+        dict(
+            type='FCNHead',
+            in_channels=128,
+            channels=32,
+            num_convs=1,
+            num_classes=19,
+            in_index=-2,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.4)),
+        dict(
+            type='FCNHead',
+            in_channels=64,
+            channels=32,
+            num_convs=1,
+            num_classes=19,
+            in_index=-3,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.4)),
+    ],
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/fastfcn_r50-d32_jpu_psp.py b/mmsegmentation/configs/_base_/models/fastfcn_r50-d32_jpu_psp.py
new file mode 100644
index 0000000..a200b4b
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/fastfcn_r50-d32_jpu_psp.py
@@ -0,0 +1,61 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 2, 2),
+        out_indices=(1, 2, 3),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    neck=dict(
+        type='JPU',
+        in_channels=(512, 1024, 2048),
+        mid_channels=512,
+        start_level=0,
+        end_level=-1,
+        dilations=(1, 2, 4, 8),
+        align_corners=False,
+        norm_cfg=norm_cfg),
+    decode_head=dict(
+        type='PSPHead',
+        in_channels=2048,
+        in_index=2,
+        channels=512,
+        pool_scales=(1, 2, 3, 6),
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=1,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/fcn_hr18.py b/mmsegmentation/configs/_base_/models/fcn_hr18.py
new file mode 100644
index 0000000..01a447a
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/fcn_hr18.py
@@ -0,0 +1,60 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://msra/hrnetv2_w18',
+    backbone=dict(
+        type='HRNet',
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        extra=dict(
+            stage1=dict(
+                num_modules=1,
+                num_branches=1,
+                block='BOTTLENECK',
+                num_blocks=(4, ),
+                num_channels=(64, )),
+            stage2=dict(
+                num_modules=1,
+                num_branches=2,
+                block='BASIC',
+                num_blocks=(4, 4),
+                num_channels=(18, 36)),
+            stage3=dict(
+                num_modules=4,
+                num_branches=3,
+                block='BASIC',
+                num_blocks=(4, 4, 4),
+                num_channels=(18, 36, 72)),
+            stage4=dict(
+                num_modules=3,
+                num_branches=4,
+                block='BASIC',
+                num_blocks=(4, 4, 4, 4),
+                num_channels=(18, 36, 72, 144)))),
+    decode_head=dict(
+        type='FCNHead',
+        in_channels=[18, 36, 72, 144],
+        in_index=(0, 1, 2, 3),
+        channels=sum([18, 36, 72, 144]),
+        input_transform='resize_concat',
+        kernel_size=1,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=-1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/fcn_r50-d8.py b/mmsegmentation/configs/_base_/models/fcn_r50-d8.py
new file mode 100644
index 0000000..9a76a6c
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/fcn_r50-d8.py
@@ -0,0 +1,53 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='FCNHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        num_convs=2,
+        concat_input=True,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/fcn_unet_s5-d16.py b/mmsegmentation/configs/_base_/models/fcn_unet_s5-d16.py
new file mode 100644
index 0000000..9f880d2
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/fcn_unet_s5-d16.py
@@ -0,0 +1,59 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        type='UNet',
+        in_channels=3,
+        base_channels=64,
+        num_stages=5,
+        strides=(1, 1, 1, 1, 1),
+        enc_num_convs=(2, 2, 2, 2, 2),
+        dec_num_convs=(2, 2, 2, 2),
+        downsamples=(True, True, True, True),
+        enc_dilations=(1, 1, 1, 1, 1),
+        dec_dilations=(1, 1, 1, 1),
+        with_cp=False,
+        conv_cfg=None,
+        norm_cfg=norm_cfg,
+        act_cfg=dict(type='ReLU'),
+        upsample_cfg=dict(type='InterpConv'),
+        norm_eval=False),
+    decode_head=dict(
+        type='FCNHead',
+        in_channels=64,
+        in_index=4,
+        channels=64,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=2,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=128,
+        in_index=3,
+        channels=64,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=2,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='slide', crop_size=256, stride=170))
diff --git a/mmsegmentation/configs/_base_/models/fpn_poolformer_s12.py b/mmsegmentation/configs/_base_/models/fpn_poolformer_s12.py
new file mode 100644
index 0000000..086c804
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/fpn_poolformer_s12.py
@@ -0,0 +1,54 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/poolformer/poolformer-s12_3rdparty_32xb128_in1k_20220414-f8d83051.pth'  # noqa
+# TODO: delete custom_imports after mmpretrain supports auto import
+# please install mmpretrain >= 1.0.0rc7
+# import mmpretrain.models to trigger register_module in mmpretrain
+custom_imports = dict(
+    imports=['mmpretrain.models'], allow_failed_imports=False)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='mmpretrain.PoolFormer',
+        arch='s12',
+        init_cfg=dict(
+            type='Pretrained', checkpoint=checkpoint_file, prefix='backbone.'),
+        in_patch_size=7,
+        in_stride=4,
+        in_pad=2,
+        down_patch_size=3,
+        down_stride=2,
+        down_pad=1,
+        drop_rate=0.,
+        drop_path_rate=0.,
+        out_indices=(0, 2, 4, 6),
+        frozen_stages=0,
+    ),
+    neck=dict(
+        type='FPN',
+        in_channels=[256, 512, 1024, 2048],
+        out_channels=256,
+        num_outs=4),
+    decode_head=dict(
+        type='FPNHead',
+        in_channels=[256, 256, 256, 256],
+        in_index=[0, 1, 2, 3],
+        feature_strides=[4, 8, 16, 32],
+        channels=128,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/fpn_r50.py b/mmsegmentation/configs/_base_/models/fpn_r50.py
new file mode 100644
index 0000000..3baa097
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/fpn_r50.py
@@ -0,0 +1,44 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 1, 1),
+        strides=(1, 2, 2, 2),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    neck=dict(
+        type='FPN',
+        in_channels=[256, 512, 1024, 2048],
+        out_channels=256,
+        num_outs=4),
+    decode_head=dict(
+        type='FPNHead',
+        in_channels=[256, 256, 256, 256],
+        in_index=[0, 1, 2, 3],
+        feature_strides=[4, 8, 16, 32],
+        channels=128,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/gcnet_r50-d8.py b/mmsegmentation/configs/_base_/models/gcnet_r50-d8.py
new file mode 100644
index 0000000..8238d4b
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/gcnet_r50-d8.py
@@ -0,0 +1,54 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='GCHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        ratio=1 / 4.,
+        pooling_type='att',
+        fusion_types=('channel_add', ),
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/icnet_r50-d8.py b/mmsegmentation/configs/_base_/models/icnet_r50-d8.py
new file mode 100644
index 0000000..4377053
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/icnet_r50-d8.py
@@ -0,0 +1,82 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='ICNet',
+        backbone_cfg=dict(
+            type='ResNetV1c',
+            in_channels=3,
+            depth=50,
+            num_stages=4,
+            out_indices=(0, 1, 2, 3),
+            dilations=(1, 1, 2, 4),
+            strides=(1, 2, 1, 1),
+            norm_cfg=norm_cfg,
+            norm_eval=False,
+            style='pytorch',
+            contract_dilation=True),
+        in_channels=3,
+        layer_channels=(512, 2048),
+        light_branch_middle_channels=32,
+        psp_out_channels=512,
+        out_channels=(64, 256, 256),
+        norm_cfg=norm_cfg,
+        align_corners=False,
+    ),
+    neck=dict(
+        type='ICNeck',
+        in_channels=(64, 256, 256),
+        out_channels=128,
+        norm_cfg=norm_cfg,
+        align_corners=False),
+    decode_head=dict(
+        type='FCNHead',
+        in_channels=128,
+        channels=128,
+        num_convs=1,
+        in_index=2,
+        dropout_ratio=0,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        concat_input=False,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=[
+        dict(
+            type='FCNHead',
+            in_channels=128,
+            channels=128,
+            num_convs=1,
+            num_classes=19,
+            in_index=0,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='FCNHead',
+            in_channels=128,
+            channels=128,
+            num_convs=1,
+            num_classes=19,
+            in_index=1,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    ],
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/isanet_r50-d8.py b/mmsegmentation/configs/_base_/models/isanet_r50-d8.py
new file mode 100644
index 0000000..e028ba8
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/isanet_r50-d8.py
@@ -0,0 +1,53 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='ISAHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        isa_channels=256,
+        down_factor=(8, 8),
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/lraspp_m-v3-d8.py b/mmsegmentation/configs/_base_/models/lraspp_m-v3-d8.py
new file mode 100644
index 0000000..acf70e7
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/lraspp_m-v3-d8.py
@@ -0,0 +1,33 @@
+# model settings
+norm_cfg = dict(type='SyncBN', eps=0.001, requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='MobileNetV3',
+        arch='large',
+        out_indices=(1, 3, 16),
+        norm_cfg=norm_cfg),
+    decode_head=dict(
+        type='LRASPPHead',
+        in_channels=(16, 24, 960),
+        in_index=(0, 1, 2),
+        channels=128,
+        input_transform='multiple_select',
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        act_cfg=dict(type='ReLU'),
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/nonlocal_r50-d8.py b/mmsegmentation/configs/_base_/models/nonlocal_r50-d8.py
new file mode 100644
index 0000000..7d73a84
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/nonlocal_r50-d8.py
@@ -0,0 +1,54 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='NLHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        dropout_ratio=0.1,
+        reduction=2,
+        use_scale=True,
+        mode='embedded_gaussian',
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/ocrnet_hr18.py b/mmsegmentation/configs/_base_/models/ocrnet_hr18.py
new file mode 100644
index 0000000..6c7fcfe
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/ocrnet_hr18.py
@@ -0,0 +1,76 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='CascadeEncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    num_stages=2,
+    pretrained='open-mmlab://msra/hrnetv2_w18',
+    backbone=dict(
+        type='HRNet',
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        extra=dict(
+            stage1=dict(
+                num_modules=1,
+                num_branches=1,
+                block='BOTTLENECK',
+                num_blocks=(4, ),
+                num_channels=(64, )),
+            stage2=dict(
+                num_modules=1,
+                num_branches=2,
+                block='BASIC',
+                num_blocks=(4, 4),
+                num_channels=(18, 36)),
+            stage3=dict(
+                num_modules=4,
+                num_branches=3,
+                block='BASIC',
+                num_blocks=(4, 4, 4),
+                num_channels=(18, 36, 72)),
+            stage4=dict(
+                num_modules=3,
+                num_branches=4,
+                block='BASIC',
+                num_blocks=(4, 4, 4, 4),
+                num_channels=(18, 36, 72, 144)))),
+    decode_head=[
+        dict(
+            type='FCNHead',
+            in_channels=[18, 36, 72, 144],
+            channels=sum([18, 36, 72, 144]),
+            in_index=(0, 1, 2, 3),
+            input_transform='resize_concat',
+            kernel_size=1,
+            num_convs=1,
+            concat_input=False,
+            dropout_ratio=-1,
+            num_classes=19,
+            norm_cfg=norm_cfg,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='OCRHead',
+            in_channels=[18, 36, 72, 144],
+            in_index=(0, 1, 2, 3),
+            input_transform='resize_concat',
+            channels=512,
+            ocr_channels=256,
+            dropout_ratio=-1,
+            num_classes=19,
+            norm_cfg=norm_cfg,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    ],
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/ocrnet_r50-d8.py b/mmsegmentation/configs/_base_/models/ocrnet_r50-d8.py
new file mode 100644
index 0000000..0a2588f
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/ocrnet_r50-d8.py
@@ -0,0 +1,55 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='CascadeEncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    num_stages=2,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=[
+        dict(
+            type='FCNHead',
+            in_channels=1024,
+            in_index=2,
+            channels=256,
+            num_convs=1,
+            concat_input=False,
+            dropout_ratio=0.1,
+            num_classes=19,
+            norm_cfg=norm_cfg,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='OCRHead',
+            in_channels=2048,
+            in_index=3,
+            channels=512,
+            ocr_channels=256,
+            dropout_ratio=0.1,
+            num_classes=19,
+            norm_cfg=norm_cfg,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
+    ],
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/pointrend_r50.py b/mmsegmentation/configs/_base_/models/pointrend_r50.py
new file mode 100644
index 0000000..8a27e85
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/pointrend_r50.py
@@ -0,0 +1,64 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='CascadeEncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    num_stages=2,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 1, 1),
+        strides=(1, 2, 2, 2),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    neck=dict(
+        type='FPN',
+        in_channels=[256, 512, 1024, 2048],
+        out_channels=256,
+        num_outs=4),
+    decode_head=[
+        dict(
+            type='FPNHead',
+            in_channels=[256, 256, 256, 256],
+            in_index=[0, 1, 2, 3],
+            feature_strides=[4, 8, 16, 32],
+            channels=128,
+            dropout_ratio=-1,
+            num_classes=19,
+            norm_cfg=norm_cfg,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+        dict(
+            type='PointHead',
+            in_channels=[256],
+            in_index=[0],
+            channels=256,
+            num_fcs=3,
+            coarse_pred_each_layer=True,
+            dropout_ratio=-1,
+            num_classes=19,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
+    ],
+    # model training and testing settings
+    train_cfg=dict(
+        num_points=2048, oversample_ratio=3, importance_sample_ratio=0.75),
+    test_cfg=dict(
+        mode='whole',
+        subdivision_steps=2,
+        subdivision_num_points=8196,
+        scale_factor=2))
diff --git a/mmsegmentation/configs/_base_/models/psanet_r50-d8.py b/mmsegmentation/configs/_base_/models/psanet_r50-d8.py
new file mode 100644
index 0000000..40fd5a9
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/psanet_r50-d8.py
@@ -0,0 +1,57 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='PSAHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        mask_size=(97, 97),
+        psa_type='bi-direction',
+        compact=False,
+        shrink_factor=2,
+        normalization_factor=1.0,
+        psa_softmax=True,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/pspnet_r50-d8.py b/mmsegmentation/configs/_base_/models/pspnet_r50-d8.py
new file mode 100644
index 0000000..c257b8b
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/pspnet_r50-d8.py
@@ -0,0 +1,52 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='PSPHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        pool_scales=(1, 2, 3, 6),
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/pspnet_unet_s5-d16.py b/mmsegmentation/configs/_base_/models/pspnet_unet_s5-d16.py
new file mode 100644
index 0000000..834a22a
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/pspnet_unet_s5-d16.py
@@ -0,0 +1,58 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        type='UNet',
+        in_channels=3,
+        base_channels=64,
+        num_stages=5,
+        strides=(1, 1, 1, 1, 1),
+        enc_num_convs=(2, 2, 2, 2, 2),
+        dec_num_convs=(2, 2, 2, 2),
+        downsamples=(True, True, True, True),
+        enc_dilations=(1, 1, 1, 1, 1),
+        dec_dilations=(1, 1, 1, 1),
+        with_cp=False,
+        conv_cfg=None,
+        norm_cfg=norm_cfg,
+        act_cfg=dict(type='ReLU'),
+        upsample_cfg=dict(type='InterpConv'),
+        norm_eval=False),
+    decode_head=dict(
+        type='PSPHead',
+        in_channels=64,
+        in_index=4,
+        channels=16,
+        pool_scales=(1, 2, 3, 6),
+        dropout_ratio=0.1,
+        num_classes=2,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=128,
+        in_index=3,
+        channels=64,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=2,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='slide', crop_size=256, stride=170))
diff --git a/mmsegmentation/configs/_base_/models/san_vit-b16.py b/mmsegmentation/configs/_base_/models/san_vit-b16.py
new file mode 100644
index 0000000..96ac41b
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/san_vit-b16.py
@@ -0,0 +1,137 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[122.7709, 116.7460, 104.0937],
+    std=[68.5005, 66.6322, 70.3232],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255,
+    size_divisor=640,
+    test_cfg=dict(size_divisor=32))
+
+num_classes = 171
+model = dict(
+    type='MultimodalEncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='pretrain/clip_vit_base_patch16_224.pth',
+    asymetric_input=True,
+    encoder_resolution=0.5,
+    image_encoder=dict(
+        type='VisionTransformer',
+        img_size=(224, 224),
+        patch_size=16,
+        patch_pad=0,
+        in_channels=3,
+        embed_dims=768,
+        num_layers=9,
+        num_heads=12,
+        mlp_ratio=4,
+        out_origin=True,
+        out_indices=(2, 5, 8),
+        qkv_bias=True,
+        drop_rate=0.0,
+        attn_drop_rate=0.0,
+        drop_path_rate=0.0,
+        with_cls_token=True,
+        output_cls_token=True,
+        patch_bias=False,
+        pre_norm=True,
+        norm_cfg=dict(type='LN', eps=1e-5),
+        act_cfg=dict(type='QuickGELU'),
+        norm_eval=False,
+        interpolate_mode='bicubic',
+        frozen_exclude=['pos_embed']),
+    text_encoder=dict(
+        type='CLIPTextEncoder',
+        dataset_name=None,
+        templates='vild',
+        embed_dims=512,
+        num_layers=12,
+        num_heads=8,
+        mlp_ratio=4,
+        output_dims=512,
+        cache_feature=True,
+        cat_bg=True,
+        norm_cfg=dict(type='LN', eps=1e-5)
+        ),
+    decode_head=dict(
+        type='SideAdapterCLIPHead',
+        num_classes=num_classes,
+        deep_supervision_idxs=[7],
+        san_cfg=dict(
+            in_channels=3,
+            clip_channels=768,
+            embed_dims=240,
+            patch_size=16,
+            patch_bias=True,
+            num_queries=100,
+            cfg_encoder=dict(
+                num_encode_layer=8,
+                num_heads=6,
+                mlp_ratio=4
+            ),
+            fusion_index=[0, 1, 2, 3],
+            cfg_decoder=dict(
+                num_heads=12,
+                num_layers=1,
+                embed_channels=256,
+                mlp_channels=256,
+                num_mlp=3,
+                rescale=True),
+            norm_cfg=dict(type='LN', eps=1e-6),
+        ),
+        maskgen_cfg=dict(
+            sos_token_format='cls_token',
+            sos_token_num=100,
+            cross_attn=False,
+            num_layers=3,
+            embed_dims=768,
+            num_heads=12,
+            mlp_ratio=4,
+            qkv_bias=True,
+            out_dims=512,
+            final_norm=True,
+            act_cfg=dict(type='QuickGELU'),
+            norm_cfg=dict(type='LN', eps=1e-5),
+            frozen_exclude=[]
+        ),
+        align_corners=False,
+        train_cfg=dict(
+            num_points=12544,
+            oversample_ratio=3.0,
+            importance_sample_ratio=0.75,
+            assigner=dict(
+                type='HungarianAssigner',
+                match_costs=[
+                    dict(type='ClassificationCost', weight=2.0),
+                    dict(
+                        type='CrossEntropyLossCost',
+                        weight=5.0,
+                        use_sigmoid=True),
+                    dict(
+                        type='DiceCost',
+                        weight=5.0,
+                        pred_act=True,
+                        eps=1.0)
+                ])),
+        loss_decode=[dict(type='CrossEntropyLoss',
+                          loss_name='loss_cls_ce',
+                          loss_weight=2.0,
+                          class_weight=[1.0] * num_classes + [0.1]),
+                     dict(type='CrossEntropyLoss',
+                          use_sigmoid=True,
+                          loss_name='loss_mask_ce',
+                          loss_weight=5.0),
+                     dict(type='DiceLoss',
+                          ignore_index=None,
+                          naive_dice=True,
+                          eps=1,
+                          loss_name='loss_mask_dice',
+                          loss_weight=5.0)
+                     ]),
+
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))  # yapf: disable
diff --git a/mmsegmentation/configs/_base_/models/segformer_mit-b0.py b/mmsegmentation/configs/_base_/models/segformer_mit-b0.py
new file mode 100644
index 0000000..46841ad
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/segformer_mit-b0.py
@@ -0,0 +1,42 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        type='MixVisionTransformer',
+        in_channels=3,
+        embed_dims=32,
+        num_stages=4,
+        num_layers=[2, 2, 2, 2],
+        num_heads=[1, 2, 5, 8],
+        patch_sizes=[7, 3, 3, 3],
+        sr_ratios=[8, 4, 2, 1],
+        out_indices=(0, 1, 2, 3),
+        mlp_ratio=4,
+        qkv_bias=True,
+        drop_rate=0.0,
+        attn_drop_rate=0.0,
+        drop_path_rate=0.1),
+    decode_head=dict(
+        type='SegformerHead',
+        in_channels=[32, 64, 160, 256],
+        in_index=[0, 1, 2, 3],
+        channels=256,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/segmenter_vit-b16_mask.py b/mmsegmentation/configs/_base_/models/segmenter_vit-b16_mask.py
new file mode 100644
index 0000000..8f3dad1
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/segmenter_vit-b16_mask.py
@@ -0,0 +1,44 @@
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segmenter/vit_base_p16_384_20220308-96dfe169.pth'  # noqa
+# model settings
+backbone_norm_cfg = dict(type='LN', eps=1e-6, requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[127.5, 127.5, 127.5],
+    std=[127.5, 127.5, 127.5],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained=checkpoint,
+    backbone=dict(
+        type='VisionTransformer',
+        img_size=(512, 512),
+        patch_size=16,
+        in_channels=3,
+        embed_dims=768,
+        num_layers=12,
+        num_heads=12,
+        drop_path_rate=0.1,
+        attn_drop_rate=0.0,
+        drop_rate=0.0,
+        final_norm=True,
+        norm_cfg=backbone_norm_cfg,
+        with_cls_token=True,
+        interpolate_mode='bicubic',
+    ),
+    decode_head=dict(
+        type='SegmenterMaskTransformerHead',
+        in_channels=768,
+        channels=768,
+        num_classes=150,
+        num_layers=2,
+        num_heads=12,
+        embed_dims=768,
+        dropout_ratio=0.0,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
+    ),
+    test_cfg=dict(mode='slide', crop_size=(512, 512), stride=(480, 480)),
+)
diff --git a/mmsegmentation/configs/_base_/models/setr_mla.py b/mmsegmentation/configs/_base_/models/setr_mla.py
new file mode 100644
index 0000000..dedf169
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/setr_mla.py
@@ -0,0 +1,103 @@
+# model settings
+backbone_norm_cfg = dict(type='LN', eps=1e-6, requires_grad=True)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='pretrain/jx_vit_large_p16_384-b3be5167.pth',
+    backbone=dict(
+        type='VisionTransformer',
+        img_size=(768, 768),
+        patch_size=16,
+        in_channels=3,
+        embed_dims=1024,
+        num_layers=24,
+        num_heads=16,
+        out_indices=(5, 11, 17, 23),
+        drop_rate=0.1,
+        norm_cfg=backbone_norm_cfg,
+        with_cls_token=False,
+        interpolate_mode='bilinear',
+    ),
+    neck=dict(
+        type='MLANeck',
+        in_channels=[1024, 1024, 1024, 1024],
+        out_channels=256,
+        norm_cfg=norm_cfg,
+        act_cfg=dict(type='ReLU'),
+    ),
+    decode_head=dict(
+        type='SETRMLAHead',
+        in_channels=(256, 256, 256, 256),
+        channels=512,
+        in_index=(0, 1, 2, 3),
+        dropout_ratio=0,
+        mla_channels=128,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=[
+        dict(
+            type='FCNHead',
+            in_channels=256,
+            channels=256,
+            in_index=0,
+            dropout_ratio=0,
+            num_convs=0,
+            kernel_size=1,
+            concat_input=False,
+            num_classes=19,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='FCNHead',
+            in_channels=256,
+            channels=256,
+            in_index=1,
+            dropout_ratio=0,
+            num_convs=0,
+            kernel_size=1,
+            concat_input=False,
+            num_classes=19,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='FCNHead',
+            in_channels=256,
+            channels=256,
+            in_index=2,
+            dropout_ratio=0,
+            num_convs=0,
+            kernel_size=1,
+            concat_input=False,
+            num_classes=19,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='FCNHead',
+            in_channels=256,
+            channels=256,
+            in_index=3,
+            dropout_ratio=0,
+            num_convs=0,
+            kernel_size=1,
+            concat_input=False,
+            num_classes=19,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    ],
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/setr_naive.py b/mmsegmentation/configs/_base_/models/setr_naive.py
new file mode 100644
index 0000000..ccf5b33
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/setr_naive.py
@@ -0,0 +1,88 @@
+# model settings
+backbone_norm_cfg = dict(type='LN', eps=1e-6, requires_grad=True)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='pretrain/jx_vit_large_p16_384-b3be5167.pth',
+    backbone=dict(
+        type='VisionTransformer',
+        img_size=(768, 768),
+        patch_size=16,
+        in_channels=3,
+        embed_dims=1024,
+        num_layers=24,
+        num_heads=16,
+        out_indices=(9, 14, 19, 23),
+        drop_rate=0.1,
+        norm_cfg=backbone_norm_cfg,
+        with_cls_token=True,
+        interpolate_mode='bilinear',
+    ),
+    decode_head=dict(
+        type='SETRUPHead',
+        in_channels=1024,
+        channels=256,
+        in_index=3,
+        num_classes=19,
+        dropout_ratio=0,
+        norm_cfg=norm_cfg,
+        num_convs=1,
+        up_scale=4,
+        kernel_size=1,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=[
+        dict(
+            type='SETRUPHead',
+            in_channels=1024,
+            channels=256,
+            in_index=0,
+            num_classes=19,
+            dropout_ratio=0,
+            norm_cfg=norm_cfg,
+            num_convs=1,
+            up_scale=4,
+            kernel_size=1,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='SETRUPHead',
+            in_channels=1024,
+            channels=256,
+            in_index=1,
+            num_classes=19,
+            dropout_ratio=0,
+            norm_cfg=norm_cfg,
+            num_convs=1,
+            up_scale=4,
+            kernel_size=1,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='SETRUPHead',
+            in_channels=1024,
+            channels=256,
+            in_index=2,
+            num_classes=19,
+            dropout_ratio=0,
+            norm_cfg=norm_cfg,
+            num_convs=1,
+            up_scale=4,
+            kernel_size=1,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4))
+    ],
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/setr_pup.py b/mmsegmentation/configs/_base_/models/setr_pup.py
new file mode 100644
index 0000000..df1bc18
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/setr_pup.py
@@ -0,0 +1,88 @@
+# model settings
+backbone_norm_cfg = dict(type='LN', eps=1e-6, requires_grad=True)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='pretrain/jx_vit_large_p16_384-b3be5167.pth',
+    backbone=dict(
+        type='VisionTransformer',
+        img_size=(768, 768),
+        patch_size=16,
+        in_channels=3,
+        embed_dims=1024,
+        num_layers=24,
+        num_heads=16,
+        out_indices=(9, 14, 19, 23),
+        drop_rate=0.1,
+        norm_cfg=backbone_norm_cfg,
+        with_cls_token=True,
+        interpolate_mode='bilinear',
+    ),
+    decode_head=dict(
+        type='SETRUPHead',
+        in_channels=1024,
+        channels=256,
+        in_index=3,
+        num_classes=19,
+        dropout_ratio=0,
+        norm_cfg=norm_cfg,
+        num_convs=4,
+        up_scale=2,
+        kernel_size=3,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=[
+        dict(
+            type='SETRUPHead',
+            in_channels=1024,
+            channels=256,
+            in_index=0,
+            num_classes=19,
+            dropout_ratio=0,
+            norm_cfg=norm_cfg,
+            num_convs=1,
+            up_scale=4,
+            kernel_size=3,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='SETRUPHead',
+            in_channels=1024,
+            channels=256,
+            in_index=1,
+            num_classes=19,
+            dropout_ratio=0,
+            norm_cfg=norm_cfg,
+            num_convs=1,
+            up_scale=4,
+            kernel_size=3,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='SETRUPHead',
+            in_channels=1024,
+            channels=256,
+            in_index=2,
+            num_classes=19,
+            dropout_ratio=0,
+            norm_cfg=norm_cfg,
+            num_convs=1,
+            up_scale=4,
+            kernel_size=3,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    ],
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/stdc.py b/mmsegmentation/configs/_base_/models/stdc.py
new file mode 100644
index 0000000..01bf2b9
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/stdc.py
@@ -0,0 +1,91 @@
+norm_cfg = dict(type='BN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        type='STDCContextPathNet',
+        backbone_cfg=dict(
+            type='STDCNet',
+            stdc_type='STDCNet1',
+            in_channels=3,
+            channels=(32, 64, 256, 512, 1024),
+            bottleneck_type='cat',
+            num_convs=4,
+            norm_cfg=norm_cfg,
+            act_cfg=dict(type='ReLU'),
+            with_final_conv=False),
+        last_in_channels=(1024, 512),
+        out_channels=128,
+        ffm_cfg=dict(in_channels=384, out_channels=256, scale_factor=4)),
+    decode_head=dict(
+        type='FCNHead',
+        in_channels=256,
+        channels=256,
+        num_convs=1,
+        num_classes=19,
+        in_index=3,
+        concat_input=False,
+        dropout_ratio=0.1,
+        norm_cfg=norm_cfg,
+        align_corners=True,
+        sampler=dict(type='OHEMPixelSampler', thresh=0.7, min_kept=10000),
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=[
+        dict(
+            type='FCNHead',
+            in_channels=128,
+            channels=64,
+            num_convs=1,
+            num_classes=19,
+            in_index=2,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            align_corners=False,
+            sampler=dict(type='OHEMPixelSampler', thresh=0.7, min_kept=10000),
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+        dict(
+            type='FCNHead',
+            in_channels=128,
+            channels=64,
+            num_convs=1,
+            num_classes=19,
+            in_index=1,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            align_corners=False,
+            sampler=dict(type='OHEMPixelSampler', thresh=0.7, min_kept=10000),
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+        dict(
+            type='STDCHead',
+            in_channels=256,
+            channels=64,
+            num_convs=1,
+            num_classes=2,
+            boundary_threshold=0.1,
+            in_index=0,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            align_corners=True,
+            loss_decode=[
+                dict(
+                    type='CrossEntropyLoss',
+                    loss_name='loss_ce',
+                    use_sigmoid=True,
+                    loss_weight=1.0),
+                dict(type='DiceLoss', loss_name='loss_dice', loss_weight=1.0)
+            ]),
+    ],
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/twins_pcpvt-s_fpn.py b/mmsegmentation/configs/_base_/models/twins_pcpvt-s_fpn.py
new file mode 100644
index 0000000..059210b
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/twins_pcpvt-s_fpn.py
@@ -0,0 +1,53 @@
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/twins/pcpvt_small_20220308-e638c41c.pth'  # noqa
+
+# model settings
+backbone_norm_cfg = dict(type='LN')
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='PCPVT',
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        in_channels=3,
+        embed_dims=[64, 128, 320, 512],
+        num_heads=[1, 2, 5, 8],
+        patch_sizes=[4, 2, 2, 2],
+        strides=[4, 2, 2, 2],
+        mlp_ratios=[8, 8, 4, 4],
+        out_indices=(0, 1, 2, 3),
+        qkv_bias=True,
+        norm_cfg=backbone_norm_cfg,
+        depths=[3, 4, 6, 3],
+        sr_ratios=[8, 4, 2, 1],
+        norm_after_stage=False,
+        drop_rate=0.0,
+        attn_drop_rate=0.,
+        drop_path_rate=0.2),
+    neck=dict(
+        type='FPN',
+        in_channels=[64, 128, 320, 512],
+        out_channels=256,
+        num_outs=4),
+    decode_head=dict(
+        type='FPNHead',
+        in_channels=[256, 256, 256, 256],
+        in_index=[0, 1, 2, 3],
+        feature_strides=[4, 8, 16, 32],
+        channels=128,
+        dropout_ratio=0.1,
+        num_classes=150,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/twins_pcpvt-s_upernet.py b/mmsegmentation/configs/_base_/models/twins_pcpvt-s_upernet.py
new file mode 100644
index 0000000..585a76f
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/twins_pcpvt-s_upernet.py
@@ -0,0 +1,61 @@
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/twins/pcpvt_small_20220308-e638c41c.pth'  # noqa
+
+# model settings
+backbone_norm_cfg = dict(type='LN')
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='PCPVT',
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        in_channels=3,
+        embed_dims=[64, 128, 320, 512],
+        num_heads=[1, 2, 5, 8],
+        patch_sizes=[4, 2, 2, 2],
+        strides=[4, 2, 2, 2],
+        mlp_ratios=[8, 8, 4, 4],
+        out_indices=(0, 1, 2, 3),
+        qkv_bias=True,
+        norm_cfg=backbone_norm_cfg,
+        depths=[3, 4, 6, 3],
+        sr_ratios=[8, 4, 2, 1],
+        norm_after_stage=False,
+        drop_rate=0.0,
+        attn_drop_rate=0.,
+        drop_path_rate=0.2),
+    decode_head=dict(
+        type='UPerHead',
+        in_channels=[64, 128, 320, 512],
+        in_index=[0, 1, 2, 3],
+        pool_scales=(1, 2, 3, 6),
+        channels=512,
+        dropout_ratio=0.1,
+        num_classes=150,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=320,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=150,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/upernet_beit.py b/mmsegmentation/configs/_base_/models/upernet_beit.py
new file mode 100644
index 0000000..691e288
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/upernet_beit.py
@@ -0,0 +1,58 @@
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        type='BEiT',
+        img_size=(640, 640),
+        patch_size=16,
+        in_channels=3,
+        embed_dims=768,
+        num_layers=12,
+        num_heads=12,
+        mlp_ratio=4,
+        out_indices=(3, 5, 7, 11),
+        qv_bias=True,
+        attn_drop_rate=0.0,
+        drop_path_rate=0.1,
+        norm_cfg=dict(type='LN', eps=1e-6),
+        act_cfg=dict(type='GELU'),
+        norm_eval=False,
+        init_values=0.1),
+    neck=dict(type='Feature2Pyramid', embed_dim=768, rescales=[4, 2, 1, 0.5]),
+    decode_head=dict(
+        type='UPerHead',
+        in_channels=[768, 768, 768, 768],
+        in_index=[0, 1, 2, 3],
+        pool_scales=(1, 2, 3, 6),
+        channels=768,
+        dropout_ratio=0.1,
+        num_classes=150,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=768,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=150,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/upernet_convnext.py b/mmsegmentation/configs/_base_/models/upernet_convnext.py
new file mode 100644
index 0000000..958994c
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/upernet_convnext.py
@@ -0,0 +1,52 @@
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+custom_imports = dict(imports='mmpretrain.models', allow_failed_imports=False)
+checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-base_3rdparty_32xb128-noema_in1k_20220301-2a0ee547.pth'  # noqa
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        type='mmpretrain.ConvNeXt',
+        arch='base',
+        out_indices=[0, 1, 2, 3],
+        drop_path_rate=0.4,
+        layer_scale_init_value=1.0,
+        gap_before_final_norm=False,
+        init_cfg=dict(
+            type='Pretrained', checkpoint=checkpoint_file,
+            prefix='backbone.')),
+    decode_head=dict(
+        type='UPerHead',
+        in_channels=[128, 256, 512, 1024],
+        in_index=[0, 1, 2, 3],
+        pool_scales=(1, 2, 3, 6),
+        channels=512,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=384,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/upernet_mae.py b/mmsegmentation/configs/_base_/models/upernet_mae.py
new file mode 100644
index 0000000..b833b67
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/upernet_mae.py
@@ -0,0 +1,57 @@
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        type='MAE',
+        img_size=(640, 640),
+        patch_size=16,
+        in_channels=3,
+        embed_dims=768,
+        num_layers=12,
+        num_heads=12,
+        mlp_ratio=4,
+        out_indices=(3, 5, 7, 11),
+        attn_drop_rate=0.0,
+        drop_path_rate=0.1,
+        norm_cfg=dict(type='LN', eps=1e-6),
+        act_cfg=dict(type='GELU'),
+        norm_eval=False,
+        init_values=0.1),
+    neck=dict(type='Feature2Pyramid', embed_dim=768, rescales=[4, 2, 1, 0.5]),
+    decode_head=dict(
+        type='UPerHead',
+        in_channels=[384, 384, 384, 384],
+        in_index=[0, 1, 2, 3],
+        pool_scales=(1, 2, 3, 6),
+        channels=512,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=384,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/upernet_r50.py b/mmsegmentation/configs/_base_/models/upernet_r50.py
new file mode 100644
index 0000000..97f2eb8
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/upernet_r50.py
@@ -0,0 +1,52 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 1, 1),
+        strides=(1, 2, 2, 2),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='UPerHead',
+        in_channels=[256, 512, 1024, 2048],
+        in_index=[0, 1, 2, 3],
+        pool_scales=(1, 2, 3, 6),
+        channels=512,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/upernet_swin.py b/mmsegmentation/configs/_base_/models/upernet_swin.py
new file mode 100644
index 0000000..61cfce0
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/upernet_swin.py
@@ -0,0 +1,62 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+backbone_norm_cfg = dict(type='LN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        type='SwinTransformer',
+        pretrain_img_size=224,
+        embed_dims=96,
+        patch_size=4,
+        window_size=7,
+        mlp_ratio=4,
+        depths=[2, 2, 6, 2],
+        num_heads=[3, 6, 12, 24],
+        strides=(4, 2, 2, 2),
+        out_indices=(0, 1, 2, 3),
+        qkv_bias=True,
+        qk_scale=None,
+        patch_norm=True,
+        drop_rate=0.,
+        attn_drop_rate=0.,
+        drop_path_rate=0.3,
+        use_abs_pos_embed=False,
+        act_cfg=dict(type='GELU'),
+        norm_cfg=backbone_norm_cfg),
+    decode_head=dict(
+        type='UPerHead',
+        in_channels=[96, 192, 384, 768],
+        in_index=[0, 1, 2, 3],
+        pool_scales=(1, 2, 3, 6),
+        channels=512,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=384,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/_base_/models/upernet_vit-b16_ln_mln.py b/mmsegmentation/configs/_base_/models/upernet_vit-b16_ln_mln.py
new file mode 100644
index 0000000..776525a
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/upernet_vit-b16_ln_mln.py
@@ -0,0 +1,65 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='pretrain/jx_vit_base_p16_224-80ecf9dd.pth',
+    backbone=dict(
+        type='VisionTransformer',
+        img_size=(512, 512),
+        patch_size=16,
+        in_channels=3,
+        embed_dims=768,
+        num_layers=12,
+        num_heads=12,
+        mlp_ratio=4,
+        out_indices=(2, 5, 8, 11),
+        qkv_bias=True,
+        drop_rate=0.0,
+        attn_drop_rate=0.0,
+        drop_path_rate=0.0,
+        with_cls_token=True,
+        norm_cfg=dict(type='LN', eps=1e-6),
+        act_cfg=dict(type='GELU'),
+        norm_eval=False,
+        interpolate_mode='bicubic'),
+    neck=dict(
+        type='MultiLevelNeck',
+        in_channels=[768, 768, 768, 768],
+        out_channels=768,
+        scales=[4, 2, 1, 0.5]),
+    decode_head=dict(
+        type='UPerHead',
+        in_channels=[768, 768, 768, 768],
+        in_index=[0, 1, 2, 3],
+        pool_scales=(1, 2, 3, 6),
+        channels=512,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=768,
+        in_index=3,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))  # yapf: disable
diff --git a/mmsegmentation/configs/_base_/models/vpd_sd.py b/mmsegmentation/configs/_base_/models/vpd_sd.py
new file mode 100644
index 0000000..87321e7
--- /dev/null
+++ b/mmsegmentation/configs/_base_/models/vpd_sd.py
@@ -0,0 +1,86 @@
+# model settings
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[127.5, 127.5, 127.5],
+    std=[127.5, 127.5, 127.5],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=0)
+
+# adapted from stable-diffusion/configs/stable-diffusion/v1-inference.yaml
+stable_diffusion_cfg = dict(
+    base_learning_rate=0.0001,
+    target='ldm.models.diffusion.ddpm.LatentDiffusion',
+    checkpoint='https://download.openmmlab.com/mmsegmentation/v0.5/'
+    'vpd/stable_diffusion_v1-5_pretrain_third_party.pth',
+    params=dict(
+        linear_start=0.00085,
+        linear_end=0.012,
+        num_timesteps_cond=1,
+        log_every_t=200,
+        timesteps=1000,
+        first_stage_key='jpg',
+        cond_stage_key='txt',
+        image_size=64,
+        channels=4,
+        cond_stage_trainable=False,
+        conditioning_key='crossattn',
+        monitor='val/loss_simple_ema',
+        scale_factor=0.18215,
+        use_ema=False,
+        scheduler_config=dict(
+            target='ldm.lr_scheduler.LambdaLinearScheduler',
+            params=dict(
+                warm_up_steps=[10000],
+                cycle_lengths=[10000000000000],
+                f_start=[1e-06],
+                f_max=[1.0],
+                f_min=[1.0])),
+        unet_config=dict(
+            target='ldm.modules.diffusionmodules.openaimodel.UNetModel',
+            params=dict(
+                image_size=32,
+                in_channels=4,
+                out_channels=4,
+                model_channels=320,
+                attention_resolutions=[4, 2, 1],
+                num_res_blocks=2,
+                channel_mult=[1, 2, 4, 4],
+                num_heads=8,
+                use_spatial_transformer=True,
+                transformer_depth=1,
+                context_dim=768,
+                use_checkpoint=True,
+                legacy=False)),
+        first_stage_config=dict(
+            target='ldm.models.autoencoder.AutoencoderKL',
+            params=dict(
+                embed_dim=4,
+                monitor='val/rec_loss',
+                ddconfig=dict(
+                    double_z=True,
+                    z_channels=4,
+                    resolution=256,
+                    in_channels=3,
+                    out_ch=3,
+                    ch=128,
+                    ch_mult=[1, 2, 4, 4],
+                    num_res_blocks=2,
+                    attn_resolutions=[],
+                    dropout=0.0),
+                lossconfig=dict(target='torch.nn.Identity'))),
+        cond_stage_config=dict(
+            target='ldm.modules.encoders.modules.AbstractEncoder')))
+
+model = dict(
+    type='DepthEstimator',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='VPD',
+        diffusion_cfg=stable_diffusion_cfg,
+    ),
+)
+
+# some of the parameters in stable-diffusion model will not be updated
+# during training
+find_unused_parameters = True
diff --git a/mmsegmentation/configs/_base_/schedules/schedule_160k.py b/mmsegmentation/configs/_base_/schedules/schedule_160k.py
new file mode 100644
index 0000000..60d7bec
--- /dev/null
+++ b/mmsegmentation/configs/_base_/schedules/schedule_160k.py
@@ -0,0 +1,25 @@
+# optimizer
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=0,
+        end=160000,
+        by_epoch=False)
+]
+# training schedule for 160k
+train_cfg = dict(
+    type='IterBasedTrainLoop', max_iters=160000, val_interval=16000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=16000),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))
diff --git a/mmsegmentation/configs/_base_/schedules/schedule_20k.py b/mmsegmentation/configs/_base_/schedules/schedule_20k.py
new file mode 100644
index 0000000..e809e3e
--- /dev/null
+++ b/mmsegmentation/configs/_base_/schedules/schedule_20k.py
@@ -0,0 +1,24 @@
+# optimizer
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=0,
+        end=20000,
+        by_epoch=False)
+]
+# training schedule for 20k
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=20000, val_interval=2000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=2000),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))
diff --git a/mmsegmentation/configs/_base_/schedules/schedule_240k.py b/mmsegmentation/configs/_base_/schedules/schedule_240k.py
new file mode 100644
index 0000000..feb2ce9
--- /dev/null
+++ b/mmsegmentation/configs/_base_/schedules/schedule_240k.py
@@ -0,0 +1,25 @@
+# optimizer
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=0,
+        end=240000,
+        by_epoch=False)
+]
+# training schedule for 240k
+train_cfg = dict(
+    type='IterBasedTrainLoop', max_iters=240000, val_interval=24000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=24000),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))
diff --git a/mmsegmentation/configs/_base_/schedules/schedule_25k.py b/mmsegmentation/configs/_base_/schedules/schedule_25k.py
new file mode 100644
index 0000000..825e141
--- /dev/null
+++ b/mmsegmentation/configs/_base_/schedules/schedule_25k.py
@@ -0,0 +1,28 @@
+# optimizer
+optimizer = dict(type='AdamW', lr=0.001, weight_decay=0.1)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
+# learning policy
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=3e-2, begin=0, end=12000,
+        by_epoch=False),
+    dict(
+        type='PolyLRRatio',
+        eta_min_ratio=3e-2,
+        power=0.9,
+        begin=12000,
+        end=24000,
+        by_epoch=False),
+    dict(type='ConstantLR', by_epoch=False, factor=1, begin=24000, end=25000)
+]
+# training schedule for 25k
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=25000, val_interval=1000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=2000),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))
diff --git a/mmsegmentation/configs/_base_/schedules/schedule_320k.py b/mmsegmentation/configs/_base_/schedules/schedule_320k.py
new file mode 100644
index 0000000..70b063a
--- /dev/null
+++ b/mmsegmentation/configs/_base_/schedules/schedule_320k.py
@@ -0,0 +1,25 @@
+# optimizer
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=0,
+        end=320000,
+        by_epoch=False)
+]
+# training schedule for 320k
+train_cfg = dict(
+    type='IterBasedTrainLoop', max_iters=320000, val_interval=32000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=32000),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))
diff --git a/mmsegmentation/configs/_base_/schedules/schedule_40k.py b/mmsegmentation/configs/_base_/schedules/schedule_40k.py
new file mode 100644
index 0000000..4b82333
--- /dev/null
+++ b/mmsegmentation/configs/_base_/schedules/schedule_40k.py
@@ -0,0 +1,24 @@
+# optimizer
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=0,
+        end=40000,
+        by_epoch=False)
+]
+# training schedule for 40k
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=40000, val_interval=4000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=4000),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))
diff --git a/mmsegmentation/configs/_base_/schedules/schedule_80k.py b/mmsegmentation/configs/_base_/schedules/schedule_80k.py
new file mode 100644
index 0000000..0dcd6c4
--- /dev/null
+++ b/mmsegmentation/configs/_base_/schedules/schedule_80k.py
@@ -0,0 +1,24 @@
+# optimizer
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=0,
+        end=80000,
+        by_epoch=False)
+]
+# training schedule for 80k
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=80000, val_interval=8000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=8000),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))
diff --git a/mmsegmentation/configs/ann/README.md b/mmsegmentation/configs/ann/README.md
new file mode 100644
index 0000000..1281a9e
--- /dev/null
+++ b/mmsegmentation/configs/ann/README.md
@@ -0,0 +1,68 @@
+# ANN
+
+> [Asymmetric Non-local Neural Networks for Semantic Segmentation](https://arxiv.org/abs/1908.07678)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/MendelXu/ANN">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+The non-local module works as a particularly useful technique for semantic segmentation while criticized for its prohibitive computation and GPU memory occupation. In this paper, we present Asymmetric Non-local Neural Network to semantic segmentation, which has two prominent components: Asymmetric Pyramid Non-local Block (APNB) and Asymmetric Fusion Non-local Block (AFNB). APNB leverages a pyramid sampling module into the non-local block to largely reduce the computation and memory consumption without sacrificing the performance. AFNB is adapted from APNB to fuse the features of different levels under a sufficient consideration of long range dependencies and thus considerably improves the performance. Extensive experiments on semantic segmentation benchmarks demonstrate the effectiveness and efficiency of our work. In particular, we report the state-of-the-art performance of 81.3 mIoU on the Cityscapes test set. For a 256x128 input, APNB is around 6 times faster than a non-local block on GPU while 28 times smaller in GPU running memory occupation. Code is available at: [this https URL](https://github.com/MendelXu/ANN).
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142898322-3bbd578c-e488-4bae-9c14-7598adac5cbd.png" width="70%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                   | download                                                                                                                                                                                                                                                                                                                               |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ANN    | R-50-D8  | 512x1024  |   40000 | 6        | 3.71           | V100   | 77.40 |         78.57 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r50-d8_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x1024_40k_cityscapes/ann_r50-d8_512x1024_40k_cityscapes_20200605_095211-049fc292.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x1024_40k_cityscapes/ann_r50-d8_512x1024_40k_cityscapes_20200605_095211.log.json)     |
+| ANN    | R-101-D8 | 512x1024  |   40000 | 9.5      | 2.55           | V100   | 76.55 |         78.85 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r101-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x1024_40k_cityscapes/ann_r101-d8_512x1024_40k_cityscapes_20200605_095243-adf6eece.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x1024_40k_cityscapes/ann_r101-d8_512x1024_40k_cityscapes_20200605_095243.log.json) |
+| ANN    | R-50-D8  | 769x769   |   40000 | 6.8      | 1.70           | V100   | 78.89 |         80.46 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r50-d8_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_769x769_40k_cityscapes/ann_r50-d8_769x769_40k_cityscapes_20200530_025712-2b46b04d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_769x769_40k_cityscapes/ann_r50-d8_769x769_40k_cityscapes_20200530_025712.log.json)         |
+| ANN    | R-101-D8 | 769x769   |   40000 | 10.7     | 1.15           | V100   | 79.32 |         80.94 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r101-d8_4xb2-40k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_769x769_40k_cityscapes/ann_r101-d8_769x769_40k_cityscapes_20200530_025720-059bff28.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_769x769_40k_cityscapes/ann_r101-d8_769x769_40k_cityscapes_20200530_025720.log.json)     |
+| ANN    | R-50-D8  | 512x1024  |   80000 | -        | -              | V100   | 77.34 |         78.65 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r50-d8_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x1024_80k_cityscapes/ann_r50-d8_512x1024_80k_cityscapes_20200607_101911-5a9ad545.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x1024_80k_cityscapes/ann_r50-d8_512x1024_80k_cityscapes_20200607_101911.log.json)     |
+| ANN    | R-101-D8 | 512x1024  |   80000 | -        | -              | V100   | 77.14 |         78.81 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r101-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x1024_80k_cityscapes/ann_r101-d8_512x1024_80k_cityscapes_20200607_013728-aceccc6e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x1024_80k_cityscapes/ann_r101-d8_512x1024_80k_cityscapes_20200607_013728.log.json) |
+| ANN    | R-50-D8  | 769x769   |   80000 | -        | -              | V100   | 78.88 |         80.57 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r50-d8_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_769x769_80k_cityscapes/ann_r50-d8_769x769_80k_cityscapes_20200607_044426-cc7ff323.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_769x769_80k_cityscapes/ann_r50-d8_769x769_80k_cityscapes_20200607_044426.log.json)         |
+| ANN    | R-101-D8 | 769x769   |   80000 | -        | -              | V100   | 78.80 |         80.34 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r101-d8_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_769x769_80k_cityscapes/ann_r101-d8_769x769_80k_cityscapes_20200607_013713-a9d4be8d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_769x769_80k_cityscapes/ann_r101-d8_769x769_80k_cityscapes_20200607_013713.log.json)     |
+
+### ADE20K
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                               | download                                                                                                                                                                                                                                                                                                               |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ANN    | R-50-D8  | 512x512   |   80000 | 9.1      | 21.01          | V100   | 41.01 |         42.30 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_80k_ade20k/ann_r50-d8_512x512_80k_ade20k_20200615_014818-26f75e11.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_80k_ade20k/ann_r50-d8_512x512_80k_ade20k_20200615_014818.log.json)         |
+| ANN    | R-101-D8 | 512x512   |   80000 | 12.5     | 14.12          | V100   | 42.94 |         44.18 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_80k_ade20k/ann_r101-d8_512x512_80k_ade20k_20200615_014818-c0153543.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_80k_ade20k/ann_r101-d8_512x512_80k_ade20k_20200615_014818.log.json)     |
+| ANN    | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 41.74 |         42.62 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_160k_ade20k/ann_r50-d8_512x512_160k_ade20k_20200615_231733-892247bc.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_160k_ade20k/ann_r50-d8_512x512_160k_ade20k_20200615_231733.log.json)     |
+| ANN    | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 42.94 |         44.06 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_160k_ade20k/ann_r101-d8_512x512_160k_ade20k_20200615_231733-955eb1ec.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_160k_ade20k/ann_r101-d8_512x512_160k_ade20k_20200615_231733.log.json) |
+
+### Pascal VOC 2012 + Aug
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                | download                                                                                                                                                                                                                                                                                                                   |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | --------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ANN    | R-50-D8  | 512x512   |   20000 | 6        | 20.92          | V100   | 74.86 |         76.13 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r50-d8_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_20k_voc12aug/ann_r50-d8_512x512_20k_voc12aug_20200617_222246-dfcb1c62.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_20k_voc12aug/ann_r50-d8_512x512_20k_voc12aug_20200617_222246.log.json)     |
+| ANN    | R-101-D8 | 512x512   |   20000 | 9.5      | 13.94          | V100   | 77.47 |         78.70 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r101-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_20k_voc12aug/ann_r101-d8_512x512_20k_voc12aug_20200617_222246-2fad0042.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_20k_voc12aug/ann_r101-d8_512x512_20k_voc12aug_20200617_222246.log.json) |
+| ANN    | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 76.56 |         77.51 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r50-d8_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_40k_voc12aug/ann_r50-d8_512x512_40k_voc12aug_20200613_231314-b5dac322.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_40k_voc12aug/ann_r50-d8_512x512_40k_voc12aug_20200613_231314.log.json)     |
+| ANN    | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 76.70 |         78.06 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r101-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_40k_voc12aug/ann_r101-d8_512x512_40k_voc12aug_20200613_231314-bd205bbe.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_40k_voc12aug/ann_r101-d8_512x512_40k_voc12aug_20200613_231314.log.json) |
+
+## Citation
+
+```bibtex
+@inproceedings{zhu2019asymmetric,
+  title={Asymmetric non-local neural networks for semantic segmentation},
+  author={Zhu, Zhen and Xu, Mengde and Bai, Song and Huang, Tengteng and Bai, Xiang},
+  booktitle={Proceedings of the IEEE/CVF International Conference on Computer Vision},
+  pages={593--602},
+  year={2019}
+}
+```
diff --git a/mmsegmentation/configs/ann/ann_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/ann/ann_r101-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..0da7e0b
--- /dev/null
+++ b/mmsegmentation/configs/ann/ann_r101-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './ann_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ann/ann_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/ann/ann_r101-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..08459c0
--- /dev/null
+++ b/mmsegmentation/configs/ann/ann_r101-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './ann_r50-d8_4xb2-40k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ann/ann_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/ann/ann_r101-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..46781fa
--- /dev/null
+++ b/mmsegmentation/configs/ann/ann_r101-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './ann_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ann/ann_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/ann/ann_r101-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..c951d87
--- /dev/null
+++ b/mmsegmentation/configs/ann/ann_r101-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './ann_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ann/ann_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/ann/ann_r101-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..9f14327
--- /dev/null
+++ b/mmsegmentation/configs/ann/ann_r101-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './ann_r50-d8_4xb4-160k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ann/ann_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/ann/ann_r101-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..c3c1a3f
--- /dev/null
+++ b/mmsegmentation/configs/ann/ann_r101-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './ann_r50-d8_4xb4-20k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ann/ann_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/ann/ann_r101-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..c3c1a3f
--- /dev/null
+++ b/mmsegmentation/configs/ann/ann_r101-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './ann_r50-d8_4xb4-20k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ann/ann_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/ann/ann_r101-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..3cc5b8e
--- /dev/null
+++ b/mmsegmentation/configs/ann/ann_r101-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './ann_r50-d8_4xb4-80k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ann/ann_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/ann/ann_r50-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..119eb76
--- /dev/null
+++ b/mmsegmentation/configs/ann/ann_r50-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/ann_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/ann/ann_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/ann/ann_r50-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..3152b92
--- /dev/null
+++ b/mmsegmentation/configs/ann/ann_r50-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/ann_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/ann/ann_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/ann/ann_r50-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..793437f
--- /dev/null
+++ b/mmsegmentation/configs/ann/ann_r50-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/ann_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/ann/ann_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/ann/ann_r50-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..4e392ca
--- /dev/null
+++ b/mmsegmentation/configs/ann/ann_r50-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/ann_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/ann/ann_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/ann/ann_r50-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..900381d
--- /dev/null
+++ b/mmsegmentation/configs/ann/ann_r50-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/ann_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/ann/ann_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/ann/ann_r50-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..6921218
--- /dev/null
+++ b/mmsegmentation/configs/ann/ann_r50-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/ann_r50-d8.py', '../_base_/datasets/pascal_voc12_aug.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_20k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/ann/ann_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/ann/ann_r50-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..e1c2360
--- /dev/null
+++ b/mmsegmentation/configs/ann/ann_r50-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/ann_r50-d8.py', '../_base_/datasets/pascal_voc12_aug.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/ann/ann_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/ann/ann_r50-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..9fb26ef
--- /dev/null
+++ b/mmsegmentation/configs/ann/ann_r50-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/ann_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/ann/metafile.yaml b/mmsegmentation/configs/ann/metafile.yaml
new file mode 100644
index 0000000..0d11868
--- /dev/null
+++ b/mmsegmentation/configs/ann/metafile.yaml
@@ -0,0 +1,391 @@
+Collections:
+- Name: ANN
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+    - ADE20K
+    - Pascal VOC 2012 + Aug
+  Paper:
+    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1908.07678
+  README: configs/ann/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: ann_r50-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: ANN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.4
+      mIoU(ms+flip): 78.57
+  Config: configs/ann/ann_r50-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - ANN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x1024_40k_cityscapes/ann_r50-d8_512x1024_40k_cityscapes_20200605_095211-049fc292.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x1024_40k_cityscapes/ann_r50-d8_512x1024_40k_cityscapes_20200605_095211.log.json
+  Paper:
+    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1908.07678
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
+  Framework: PyTorch
+- Name: ann_r101-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: ANN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.55
+      mIoU(ms+flip): 78.85
+  Config: configs/ann/ann_r101-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - ANN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x1024_40k_cityscapes/ann_r101-d8_512x1024_40k_cityscapes_20200605_095243-adf6eece.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x1024_40k_cityscapes/ann_r101-d8_512x1024_40k_cityscapes_20200605_095243.log.json
+  Paper:
+    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1908.07678
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
+  Framework: PyTorch
+- Name: ann_r50-d8_4xb2-40k_cityscapes-769x769
+  In Collection: ANN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.89
+      mIoU(ms+flip): 80.46
+  Config: configs/ann/ann_r50-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - ANN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_769x769_40k_cityscapes/ann_r50-d8_769x769_40k_cityscapes_20200530_025712-2b46b04d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_769x769_40k_cityscapes/ann_r50-d8_769x769_40k_cityscapes_20200530_025712.log.json
+  Paper:
+    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1908.07678
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
+  Framework: PyTorch
+- Name: ann_r101-d8_4xb2-40k_cityscapes-769x769
+  In Collection: ANN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.32
+      mIoU(ms+flip): 80.94
+  Config: configs/ann/ann_r101-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - ANN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.7
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_769x769_40k_cityscapes/ann_r101-d8_769x769_40k_cityscapes_20200530_025720-059bff28.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_769x769_40k_cityscapes/ann_r101-d8_769x769_40k_cityscapes_20200530_025720.log.json
+  Paper:
+    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1908.07678
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
+  Framework: PyTorch
+- Name: ann_r50-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: ANN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.34
+      mIoU(ms+flip): 78.65
+  Config: configs/ann/ann_r50-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - ANN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x1024_80k_cityscapes/ann_r50-d8_512x1024_80k_cityscapes_20200607_101911-5a9ad545.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x1024_80k_cityscapes/ann_r50-d8_512x1024_80k_cityscapes_20200607_101911.log.json
+  Paper:
+    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1908.07678
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
+  Framework: PyTorch
+- Name: ann_r101-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: ANN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.14
+      mIoU(ms+flip): 78.81
+  Config: configs/ann/ann_r101-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - ANN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x1024_80k_cityscapes/ann_r101-d8_512x1024_80k_cityscapes_20200607_013728-aceccc6e.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x1024_80k_cityscapes/ann_r101-d8_512x1024_80k_cityscapes_20200607_013728.log.json
+  Paper:
+    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1908.07678
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
+  Framework: PyTorch
+- Name: ann_r50-d8_4xb2-80k_cityscapes-769x769
+  In Collection: ANN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.88
+      mIoU(ms+flip): 80.57
+  Config: configs/ann/ann_r50-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - ANN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_769x769_80k_cityscapes/ann_r50-d8_769x769_80k_cityscapes_20200607_044426-cc7ff323.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_769x769_80k_cityscapes/ann_r50-d8_769x769_80k_cityscapes_20200607_044426.log.json
+  Paper:
+    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1908.07678
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
+  Framework: PyTorch
+- Name: ann_r101-d8_4xb2-80k_cityscapes-769x769
+  In Collection: ANN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.8
+      mIoU(ms+flip): 80.34
+  Config: configs/ann/ann_r101-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - ANN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_769x769_80k_cityscapes/ann_r101-d8_769x769_80k_cityscapes_20200607_013713-a9d4be8d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_769x769_80k_cityscapes/ann_r101-d8_769x769_80k_cityscapes_20200607_013713.log.json
+  Paper:
+    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1908.07678
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
+  Framework: PyTorch
+- Name: ann_r50-d8_4xb4-80k_ade20k-512x512
+  In Collection: ANN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 41.01
+      mIoU(ms+flip): 42.3
+  Config: configs/ann/ann_r50-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - ANN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_80k_ade20k/ann_r50-d8_512x512_80k_ade20k_20200615_014818-26f75e11.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_80k_ade20k/ann_r50-d8_512x512_80k_ade20k_20200615_014818.log.json
+  Paper:
+    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1908.07678
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
+  Framework: PyTorch
+- Name: ann_r101-d8_4xb4-80k_ade20k-512x512
+  In Collection: ANN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.94
+      mIoU(ms+flip): 44.18
+  Config: configs/ann/ann_r101-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - ANN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 12.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_80k_ade20k/ann_r101-d8_512x512_80k_ade20k_20200615_014818-c0153543.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_80k_ade20k/ann_r101-d8_512x512_80k_ade20k_20200615_014818.log.json
+  Paper:
+    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1908.07678
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
+  Framework: PyTorch
+- Name: ann_r50-d8_4xb4-160k_ade20k-512x512
+  In Collection: ANN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 41.74
+      mIoU(ms+flip): 42.62
+  Config: configs/ann/ann_r50-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - ANN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_160k_ade20k/ann_r50-d8_512x512_160k_ade20k_20200615_231733-892247bc.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_160k_ade20k/ann_r50-d8_512x512_160k_ade20k_20200615_231733.log.json
+  Paper:
+    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1908.07678
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
+  Framework: PyTorch
+- Name: ann_r101-d8_4xb4-160k_ade20k-512x512
+  In Collection: ANN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.94
+      mIoU(ms+flip): 44.06
+  Config: configs/ann/ann_r101-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - ANN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_160k_ade20k/ann_r101-d8_512x512_160k_ade20k_20200615_231733-955eb1ec.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_160k_ade20k/ann_r101-d8_512x512_160k_ade20k_20200615_231733.log.json
+  Paper:
+    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1908.07678
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
+  Framework: PyTorch
+- Name: ann_r50-d8_4xb4-20k_voc12aug-512x512
+  In Collection: ANN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 74.86
+      mIoU(ms+flip): 76.13
+  Config: configs/ann/ann_r50-d8_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - ANN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_20k_voc12aug/ann_r50-d8_512x512_20k_voc12aug_20200617_222246-dfcb1c62.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_20k_voc12aug/ann_r50-d8_512x512_20k_voc12aug_20200617_222246.log.json
+  Paper:
+    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1908.07678
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
+  Framework: PyTorch
+- Name: ann_r101-d8_4xb4-20k_voc12aug-512x512
+  In Collection: ANN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 77.47
+      mIoU(ms+flip): 78.7
+  Config: configs/ann/ann_r101-d8_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - ANN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_20k_voc12aug/ann_r101-d8_512x512_20k_voc12aug_20200617_222246-2fad0042.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_20k_voc12aug/ann_r101-d8_512x512_20k_voc12aug_20200617_222246.log.json
+  Paper:
+    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1908.07678
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
+  Framework: PyTorch
+- Name: ann_r50-d8_4xb4-40k_voc12aug-512x512
+  In Collection: ANN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 76.56
+      mIoU(ms+flip): 77.51
+  Config: configs/ann/ann_r50-d8_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - ANN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_40k_voc12aug/ann_r50-d8_512x512_40k_voc12aug_20200613_231314-b5dac322.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_40k_voc12aug/ann_r50-d8_512x512_40k_voc12aug_20200613_231314.log.json
+  Paper:
+    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1908.07678
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
+  Framework: PyTorch
+- Name: ann_r101-d8_4xb4-40k_voc12aug-512x512
+  In Collection: ANN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 76.7
+      mIoU(ms+flip): 78.06
+  Config: configs/ann/ann_r101-d8_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - ANN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_40k_voc12aug/ann_r101-d8_512x512_40k_voc12aug_20200613_231314-bd205bbe.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_40k_voc12aug/ann_r101-d8_512x512_40k_voc12aug_20200613_231314.log.json
+  Paper:
+    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1908.07678
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/apcnet/README.md b/mmsegmentation/configs/apcnet/README.md
new file mode 100644
index 0000000..9104f3c
--- /dev/null
+++ b/mmsegmentation/configs/apcnet/README.md
@@ -0,0 +1,59 @@
+# APCNet
+
+> [Adaptive Pyramid Context Network for Semantic Segmentation](https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/Junjun2016/APCNet">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Recent studies witnessed that context features can significantly improve the performance of deep semantic segmentation networks. Current context based segmentation methods differ with each other in how to construct context features and perform differently in practice. This paper firstly introduces three desirable properties of context features in segmentation task. Specially, we find that Global-guided Local Affinity (GLA) can play a vital role in constructing effective context features, while this property has been largely ignored in previous works. Based on this analysis, this paper proposes Adaptive Pyramid Context Network (APCNet)for semantic segmentation. APCNet adaptively constructs multi-scale contextual representations with multiple welldesigned Adaptive Context Modules (ACMs). Specifically, each ACM leverages a global image representation as a guidance to estimate the local affinity coefficients for each sub-region, and then calculates a context vector with these affinities. We empirically evaluate our APCNet on three semantic segmentation and scene parsing datasets, including PASCAL VOC 2012, Pascal-Context, and ADE20K dataset. Experimental results show that APCNet achieves state-ofthe-art performance on all three benchmarks, and obtains a new record 84.2% on PASCAL VOC 2012 test set without MS COCO pre-trained and any post-processing.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142898638-e1c0c6ae-9270-448e-aa01-bbac3a236db5.png" width="70%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                         | download                                                                                                                                                                                                                                                                                                                                                 |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| APCNet | R-50-D8  | 512x1024  |   40000 | 7.7      | 3.57           | V100   | 78.02 |         79.26 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x1024_40k_cityscapes/apcnet_r50-d8_512x1024_40k_cityscapes_20201214_115717-5e88fa33.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x1024_40k_cityscapes/apcnet_r50-d8_512x1024_40k_cityscapes-20201214_115717.log.json)     |
+| APCNet | R-101-D8 | 512x1024  |   40000 | 11.2     | 2.15           | V100   | 79.08 |         80.34 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x1024_40k_cityscapes/apcnet_r101-d8_512x1024_40k_cityscapes_20201214_115716-abc9d111.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x1024_40k_cityscapes/apcnet_r101-d8_512x1024_40k_cityscapes-20201214_115716.log.json) |
+| APCNet | R-50-D8  | 769x769   |   40000 | 8.7      | 1.52           | V100   | 77.89 |         79.75 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_769x769_40k_cityscapes/apcnet_r50-d8_769x769_40k_cityscapes_20201214_115717-2a2628d7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_769x769_40k_cityscapes/apcnet_r50-d8_769x769_40k_cityscapes-20201214_115717.log.json)         |
+| APCNet | R-101-D8 | 769x769   |   40000 | 12.7     | 1.03           | V100   | 77.96 |         79.24 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_769x769_40k_cityscapes/apcnet_r101-d8_769x769_40k_cityscapes_20201214_115718-b650de90.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_769x769_40k_cityscapes/apcnet_r101-d8_769x769_40k_cityscapes-20201214_115718.log.json)     |
+| APCNet | R-50-D8  | 512x1024  |   80000 | -        | -              | V100   | 78.96 |         79.94 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x1024_80k_cityscapes/apcnet_r50-d8_512x1024_80k_cityscapes_20201214_115716-987f51e3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x1024_80k_cityscapes/apcnet_r50-d8_512x1024_80k_cityscapes-20201214_115716.log.json)     |
+| APCNet | R-101-D8 | 512x1024  |   80000 | -        | -              | V100   | 79.64 |         80.61 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x1024_80k_cityscapes/apcnet_r101-d8_512x1024_80k_cityscapes_20201214_115705-b1ff208a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x1024_80k_cityscapes/apcnet_r101-d8_512x1024_80k_cityscapes-20201214_115705.log.json) |
+| APCNet | R-50-D8  | 769x769   |   80000 | -        | -              | V100   | 78.79 |         80.35 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_769x769_80k_cityscapes/apcnet_r50-d8_769x769_80k_cityscapes_20201214_115718-7ea9fa12.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_769x769_80k_cityscapes/apcnet_r50-d8_769x769_80k_cityscapes-20201214_115718.log.json)         |
+| APCNet | R-101-D8 | 769x769   |   80000 | -        | -              | V100   | 78.45 |         79.91 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_769x769_80k_cityscapes/apcnet_r101-d8_769x769_80k_cityscapes_20201214_115716-a7fbc2ab.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_769x769_80k_cityscapes/apcnet_r101-d8_769x769_80k_cityscapes-20201214_115716.log.json)     |
+
+### ADE20K
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                     | download                                                                                                                                                                                                                                                                                                                                 |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| APCNet | R-50-D8  | 512x512   |   80000 | 10.1     | 19.61          | V100   | 42.20 |         43.30 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x512_80k_ade20k/apcnet_r50-d8_512x512_80k_ade20k_20201214_115705-a8626293.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x512_80k_ade20k/apcnet_r50-d8_512x512_80k_ade20k-20201214_115705.log.json)         |
+| APCNet | R-101-D8 | 512x512   |   80000 | 13.6     | 13.10          | V100   | 45.54 |         46.65 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x512_80k_ade20k/apcnet_r101-d8_512x512_80k_ade20k_20201214_115704-c656c3fb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x512_80k_ade20k/apcnet_r101-d8_512x512_80k_ade20k-20201214_115704.log.json)     |
+| APCNet | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 43.40 |         43.94 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x512_160k_ade20k/apcnet_r50-d8_512x512_160k_ade20k_20201214_115706-25fb92c2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x512_160k_ade20k/apcnet_r50-d8_512x512_160k_ade20k-20201214_115706.log.json)     |
+| APCNet | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 45.41 |         46.63 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x512_160k_ade20k/apcnet_r101-d8_512x512_160k_ade20k_20201214_115705-73f9a8d7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x512_160k_ade20k/apcnet_r101-d8_512x512_160k_ade20k-20201214_115705.log.json) |
+
+## Citation
+
+```bibtex
+@InProceedings{He_2019_CVPR,
+author = {He, Junjun and Deng, Zhongying and Zhou, Lei and Wang, Yali and Qiao, Yu},
+title = {Adaptive Pyramid Context Network for Semantic Segmentation},
+booktitle = {Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
+month = {June},
+year = {2019}
+}
+```
diff --git a/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..754b2d1
--- /dev/null
+++ b/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './apcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..d2b5fe1
--- /dev/null
+++ b/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './apcnet_r50-d8_4xb2-40k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..03b018d
--- /dev/null
+++ b/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './apcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..0cbbfad
--- /dev/null
+++ b/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './apcnet_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..f0aacc0
--- /dev/null
+++ b/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './apcnet_r50-d8_4xb4-160k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..219d07a
--- /dev/null
+++ b/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './apcnet_r50-d8_4xb4-80k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..b440771
--- /dev/null
+++ b/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/apcnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..9ff897c
--- /dev/null
+++ b/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/apcnet_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..6de1033
--- /dev/null
+++ b/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/apcnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..d6ec898
--- /dev/null
+++ b/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/apcnet_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..37b23d1
--- /dev/null
+++ b/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/apcnet_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..b0fbe27
--- /dev/null
+++ b/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/apcnet_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/apcnet/metafile.yaml b/mmsegmentation/configs/apcnet/metafile.yaml
new file mode 100644
index 0000000..3f4072c
--- /dev/null
+++ b/mmsegmentation/configs/apcnet/metafile.yaml
@@ -0,0 +1,296 @@
+Collections:
+- Name: APCNet
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+    - ADE20K
+  Paper:
+    Title: Adaptive Pyramid Context Network for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
+  README: configs/apcnet/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: apcnet_r50-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: APCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.02
+      mIoU(ms+flip): 79.26
+  Config: configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - APCNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 7.7
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x1024_40k_cityscapes/apcnet_r50-d8_512x1024_40k_cityscapes_20201214_115717-5e88fa33.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x1024_40k_cityscapes/apcnet_r50-d8_512x1024_40k_cityscapes-20201214_115717.log.json
+  Paper:
+    Title: Adaptive Pyramid Context Network for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: apcnet_r101-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: APCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.08
+      mIoU(ms+flip): 80.34
+  Config: configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - APCNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 11.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x1024_40k_cityscapes/apcnet_r101-d8_512x1024_40k_cityscapes_20201214_115716-abc9d111.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x1024_40k_cityscapes/apcnet_r101-d8_512x1024_40k_cityscapes-20201214_115716.log.json
+  Paper:
+    Title: Adaptive Pyramid Context Network for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: apcnet_r50-d8_4xb2-40k_cityscapes-769x769
+  In Collection: APCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.89
+      mIoU(ms+flip): 79.75
+  Config: configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - APCNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.7
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_769x769_40k_cityscapes/apcnet_r50-d8_769x769_40k_cityscapes_20201214_115717-2a2628d7.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_769x769_40k_cityscapes/apcnet_r50-d8_769x769_40k_cityscapes-20201214_115717.log.json
+  Paper:
+    Title: Adaptive Pyramid Context Network for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: apcnet_r101-d8_4xb2-40k_cityscapes-769x769
+  In Collection: APCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.96
+      mIoU(ms+flip): 79.24
+  Config: configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - APCNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 12.7
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_769x769_40k_cityscapes/apcnet_r101-d8_769x769_40k_cityscapes_20201214_115718-b650de90.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_769x769_40k_cityscapes/apcnet_r101-d8_769x769_40k_cityscapes-20201214_115718.log.json
+  Paper:
+    Title: Adaptive Pyramid Context Network for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: apcnet_r50-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: APCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.96
+      mIoU(ms+flip): 79.94
+  Config: configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - APCNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x1024_80k_cityscapes/apcnet_r50-d8_512x1024_80k_cityscapes_20201214_115716-987f51e3.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x1024_80k_cityscapes/apcnet_r50-d8_512x1024_80k_cityscapes-20201214_115716.log.json
+  Paper:
+    Title: Adaptive Pyramid Context Network for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: apcnet_r101-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: APCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.64
+      mIoU(ms+flip): 80.61
+  Config: configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - APCNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x1024_80k_cityscapes/apcnet_r101-d8_512x1024_80k_cityscapes_20201214_115705-b1ff208a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x1024_80k_cityscapes/apcnet_r101-d8_512x1024_80k_cityscapes-20201214_115705.log.json
+  Paper:
+    Title: Adaptive Pyramid Context Network for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: apcnet_r50-d8_4xb2-80k_cityscapes-769x769
+  In Collection: APCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.79
+      mIoU(ms+flip): 80.35
+  Config: configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - APCNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_769x769_80k_cityscapes/apcnet_r50-d8_769x769_80k_cityscapes_20201214_115718-7ea9fa12.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_769x769_80k_cityscapes/apcnet_r50-d8_769x769_80k_cityscapes-20201214_115718.log.json
+  Paper:
+    Title: Adaptive Pyramid Context Network for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: apcnet_r101-d8_4xb2-80k_cityscapes-769x769
+  In Collection: APCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.45
+      mIoU(ms+flip): 79.91
+  Config: configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - APCNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_769x769_80k_cityscapes/apcnet_r101-d8_769x769_80k_cityscapes_20201214_115716-a7fbc2ab.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_769x769_80k_cityscapes/apcnet_r101-d8_769x769_80k_cityscapes-20201214_115716.log.json
+  Paper:
+    Title: Adaptive Pyramid Context Network for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: apcnet_r50-d8_4xb4-80k_ade20k-512x512
+  In Collection: APCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.2
+      mIoU(ms+flip): 43.3
+  Config: configs/apcnet/apcnet_r50-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - APCNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x512_80k_ade20k/apcnet_r50-d8_512x512_80k_ade20k_20201214_115705-a8626293.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x512_80k_ade20k/apcnet_r50-d8_512x512_80k_ade20k-20201214_115705.log.json
+  Paper:
+    Title: Adaptive Pyramid Context Network for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: apcnet_r101-d8_4xb4-80k_ade20k-512x512
+  In Collection: APCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 45.54
+      mIoU(ms+flip): 46.65
+  Config: configs/apcnet/apcnet_r101-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - APCNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 13.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x512_80k_ade20k/apcnet_r101-d8_512x512_80k_ade20k_20201214_115704-c656c3fb.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x512_80k_ade20k/apcnet_r101-d8_512x512_80k_ade20k-20201214_115704.log.json
+  Paper:
+    Title: Adaptive Pyramid Context Network for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: apcnet_r50-d8_4xb4-160k_ade20k-512x512
+  In Collection: APCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 43.4
+      mIoU(ms+flip): 43.94
+  Config: configs/apcnet/apcnet_r50-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - APCNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x512_160k_ade20k/apcnet_r50-d8_512x512_160k_ade20k_20201214_115706-25fb92c2.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x512_160k_ade20k/apcnet_r50-d8_512x512_160k_ade20k-20201214_115706.log.json
+  Paper:
+    Title: Adaptive Pyramid Context Network for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: apcnet_r101-d8_4xb4-160k_ade20k-512x512
+  In Collection: APCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 45.41
+      mIoU(ms+flip): 46.63
+  Config: configs/apcnet/apcnet_r101-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - APCNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x512_160k_ade20k/apcnet_r101-d8_512x512_160k_ade20k_20201214_115705-73f9a8d7.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x512_160k_ade20k/apcnet_r101-d8_512x512_160k_ade20k-20201214_115705.log.json
+  Paper:
+    Title: Adaptive Pyramid Context Network for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/beit/README.md b/mmsegmentation/configs/beit/README.md
new file mode 100644
index 0000000..b005c88
--- /dev/null
+++ b/mmsegmentation/configs/beit/README.md
@@ -0,0 +1,85 @@
+# BEiT
+
+> [BEiT: BERT Pre-Training of Image Transformers](https://arxiv.org/abs/2106.08254)
+
+## Introduction
+
+<!-- [BACKBONE] -->
+
+<a href="https://github.com/microsoft/unilm/tree/master/beit">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.23.0/mmseg/models/backbones/beit.py#1404">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+We introduce a self-supervised vision representation model BEiT, which stands for Bidirectional Encoder representation from Image Transformers. Following BERT developed in the natural language processing area, we propose a masked image modeling task to pretrain vision Transformers. Specifically, each image has two views in our pre-training, i.e, image patches (such as 16x16 pixels), and visual tokens (i.e., discrete tokens). We first "tokenize" the original image into visual tokens. Then we randomly mask some image patches and fed them into the backbone Transformer. The pre-training objective is to recover the original visual tokens based on the corrupted image patches. After pre-training BEiT, we directly fine-tune the model parameters on downstream tasks by appending task layers upon the pretrained encoder. Experimental results on image classification and semantic segmentation show that our model achieves competitive results with previous pre-training methods. For example, base-size BEiT achieves 83.2% top-1 accuracy on ImageNet-1K, significantly outperforming from-scratch DeiT training (81.8%) with the same setup. Moreover, large-size BEiT obtains 86.3% only using ImageNet-1K, even outperforming ViT-L with supervised pre-training on ImageNet-22K (85.2%). The code and pretrained models are available at [this https URL](https://github.com/microsoft/unilm/tree/master/beit).
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/93248678/160155758-781c9a45-b1d7-4530-9015-88eca6645006.png" width="70%"/>
+</div>
+
+## Usage
+
+To use other repositories' pre-trained models, it is necessary to convert keys.
+
+We provide a script [`beit2mmseg.py`](../../tools/model_converters/beit2mmseg.py) in the tools directory to convert the key of models from [the official repo](https://github.com/microsoft/unilm/tree/master/beit/semantic_segmentation) to MMSegmentation style.
+
+```shell
+python tools/model_converters/beit2mmseg.py ${PRETRAIN_PATH} ${STORE_PATH}
+```
+
+E.g.
+
+```shell
+python tools/model_converters/beit2mmseg.py https://conversationhub.blob.core.windows.net/beit-share-public/beit/beit_base_patch16_224_pt22k_ft22k.pth pretrain/beit_base_patch16_224_pt22k_ft22k.pth
+```
+
+This script convert model from `PRETRAIN_PATH` and store the converted model in `STORE_PATH`.
+
+In our default setting, pretrained models could be defined below:
+
+| pretrained models | original models                                                                                                             |
+| ----------------- | --------------------------------------------------------------------------------------------------------------------------- |
+| BEiT_base.pth     | ['BEiT_base'](https://conversationhub.blob.core.windows.net/beit-share-public/beit/beit_base_patch16_224_pt22k_ft22k.pth)   |
+| BEiT_large.pth    | ['BEiT_large'](https://conversationhub.blob.core.windows.net/beit-share-public/beit/beit_large_patch16_224_pt22k_ft22k.pth) |
+
+Verify the single-scale results of the model:
+
+```shell
+sh tools/dist_test.sh \
+configs/beit/upernet_beit-large_fp16_8x1_640x640_160k_ade20k.py \
+upernet_beit-large_fp16_8x1_640x640_160k_ade20k-8fc0dd5d.pth $GPUS --eval mIoU
+```
+
+Since relative position embedding requires the input length and width to be equal, the sliding window is adopted for multi-scale inference. So we set min_size=640, that is, the shortest edge is 640. So the multi-scale inference of config is performed separately, instead of '--aug-test'. For multi-scale inference:
+
+```shell
+sh tools/dist_test.sh \
+configs/beit/upernet_beit-large_fp16_640x640_160k_ade20k_ms.py \
+upernet_beit-large_fp16_8x1_640x640_160k_ade20k-8fc0dd5d.pth $GPUS --eval mIoU
+```
+
+## Results and models
+
+### ADE20K
+
+| Method  | Backbone | Crop Size | pretrain     | pretrain img size | Batch Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                           | download                                                                                                                                                                                                                                                                                                                                                 |
+| ------- | -------- | --------- | ------------ | ----------------- | ---------- | ------- | -------- | -------------- | ------ | ----- | ------------: | -------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UPerNet | BEiT-B   | 640x640   | ImageNet-22K | 224x224           | 16         | 160000  | 15.88    | 2.00           | V100   | 53.08 |         53.84 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/beit/beit-base_upernet_8xb2-160k_ade20k-640x640.py)      | [model](https://download.openmmlab.com/mmsegmentation/v0.5/beit/upernet_beit-base_8x2_640x640_160k_ade20k/upernet_beit-base_8x2_640x640_160k_ade20k-eead221d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/beit/upernet_beit-base_8x2_640x640_160k_ade20k/upernet_beit-base_8x2_640x640_160k_ade20k.log.json)                         |
+| UPerNet | BEiT-L   | 640x640   | ImageNet-22K | 224x224           | 8          | 320000  | 22.64    | 0.96           | V100   | 56.33 |         56.84 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/beit/beit-large_upernet_8xb1-amp-160k_ade20k-640x640.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/beit/upernet_beit-large_fp16_8x1_640x640_160k_ade20k/upernet_beit-large_fp16_8x1_640x640_160k_ade20k-8fc0dd5d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/beit/upernet_beit-large_fp16_8x1_640x640_160k_ade20k/upernet_beit-large_fp16_8x1_640x640_160k_ade20k.log.json) |
+
+## Citation
+
+```bibtex
+@inproceedings{beit,
+      title={{BEiT}: {BERT} Pre-Training of Image Transformers},
+      author={Hangbo Bao and Li Dong and Songhao Piao and Furu Wei},
+      booktitle={International Conference on Learning Representations},
+      year={2022},
+      url={https://openreview.net/forum?id=p-BhZSz59o4}
+}
+```
diff --git a/mmsegmentation/configs/beit/beit-base_upernet_8xb2-160k_ade20k-640x640.py b/mmsegmentation/configs/beit/beit-base_upernet_8xb2-160k_ade20k-640x640.py
new file mode 100644
index 0000000..1cd7d0e
--- /dev/null
+++ b/mmsegmentation/configs/beit/beit-base_upernet_8xb2-160k_ade20k-640x640.py
@@ -0,0 +1,36 @@
+_base_ = [
+    '../_base_/models/upernet_beit.py', '../_base_/datasets/ade20k_640x640.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (640, 640)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained='pretrain/beit_base_patch16_224_pt22k_ft22k.pth',
+    test_cfg=dict(mode='slide', crop_size=(640, 640), stride=(426, 426)))
+
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=3e-5, betas=(0.9, 0.999), weight_decay=0.05),
+    constructor='LayerDecayOptimizerConstructor',
+    paramwise_cfg=dict(num_layers=12, layer_decay_rate=0.9))
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        power=1.0,
+        begin=1500,
+        end=160000,
+        eta_min=0.0,
+        by_epoch=False,
+    )
+]
+
+# By default, models are trained on 8 GPUs with 2 images per GPU
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/beit/beit-base_upernet_8xb2-160k_ade20k-640x640_ms.py b/mmsegmentation/configs/beit/beit-base_upernet_8xb2-160k_ade20k-640x640_ms.py
new file mode 100644
index 0000000..0248022
--- /dev/null
+++ b/mmsegmentation/configs/beit/beit-base_upernet_8xb2-160k_ade20k-640x640_ms.py
@@ -0,0 +1,16 @@
+_base_ = './beit-base_upernet_8xb2-160k_ade20k-640x640.py'
+
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    # TODO: Refactor 'MultiScaleFlipAug' which supports
+    # `min_size` feature in `Resize` class
+    # img_ratios is [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+    # original image scale is (2560, 640)
+    dict(type='Resize', scale=(2560, 640), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='PackSegInputs'),
+]
+val_dataloader = dict(batch_size=1, dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/beit/beit-large_upernet_8xb1-amp-160k_ade20k-640x640.py b/mmsegmentation/configs/beit/beit-large_upernet_8xb1-amp-160k_ade20k-640x640.py
new file mode 100644
index 0000000..4fd5cd2
--- /dev/null
+++ b/mmsegmentation/configs/beit/beit-large_upernet_8xb1-amp-160k_ade20k-640x640.py
@@ -0,0 +1,50 @@
+_base_ = [
+    '../_base_/models/upernet_beit.py', '../_base_/datasets/ade20k_640x640.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_320k.py'
+]
+crop_size = (640, 640)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained='pretrain/beit_large_patch16_224_pt22k_ft22k.pth',
+    backbone=dict(
+        type='BEiT',
+        embed_dims=1024,
+        num_layers=24,
+        num_heads=16,
+        mlp_ratio=4,
+        qv_bias=True,
+        init_values=1e-6,
+        drop_path_rate=0.2,
+        out_indices=[7, 11, 15, 23]),
+    neck=dict(embed_dim=1024, rescales=[4, 2, 1, 0.5]),
+    decode_head=dict(
+        in_channels=[1024, 1024, 1024, 1024], num_classes=150, channels=1024),
+    auxiliary_head=dict(in_channels=1024, num_classes=150),
+    test_cfg=dict(mode='slide', crop_size=(640, 640), stride=(426, 426)))
+
+optim_wrapper = dict(
+    _delete_=True,
+    type='AmpOptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=2e-5, betas=(0.9, 0.999), weight_decay=0.05),
+    constructor='LayerDecayOptimizerConstructor',
+    paramwise_cfg=dict(num_layers=24, layer_decay_rate=0.95),
+    accumulative_counts=2)
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=3000),
+    dict(
+        type='PolyLR',
+        power=1.0,
+        begin=3000,
+        end=160000,
+        eta_min=0.0,
+        by_epoch=False,
+    )
+]
+
+train_dataloader = dict(batch_size=1)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/beit/beit-large_upernet_8xb1-amp-160k_ade20k-640x640_ms.py b/mmsegmentation/configs/beit/beit-large_upernet_8xb1-amp-160k_ade20k-640x640_ms.py
new file mode 100644
index 0000000..fc6f049
--- /dev/null
+++ b/mmsegmentation/configs/beit/beit-large_upernet_8xb1-amp-160k_ade20k-640x640_ms.py
@@ -0,0 +1,16 @@
+_base_ = './beit-large_upernet_8xb1-amp-160k_ade20k-640x640.py'
+
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    # TODO: Refactor 'MultiScaleFlipAug' which supports
+    # `min_size` feature in `Resize` class
+    # img_ratios is [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+    # original image scale is (2560, 640)
+    dict(type='Resize', scale=(2560, 640), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='PackSegInputs'),
+]
+val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/beit/metafile.yaml b/mmsegmentation/configs/beit/metafile.yaml
new file mode 100644
index 0000000..ef6124e
--- /dev/null
+++ b/mmsegmentation/configs/beit/metafile.yaml
@@ -0,0 +1,49 @@
+Models:
+- Name: beit-base_upernet_8xb2-160k_ade20k-640x640
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 53.08
+      mIoU(ms+flip): 53.84
+  Config: configs/beit/beit-base_upernet_8xb2-160k_ade20k-640x640.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - BEiT-B
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 15.88
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/beit/upernet_beit-base_8x2_640x640_160k_ade20k/upernet_beit-base_8x2_640x640_160k_ade20k-eead221d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/beit/upernet_beit-base_8x2_640x640_160k_ade20k/upernet_beit-base_8x2_640x640_160k_ade20k.log.json
+  Paper:
+    Title: 'BEiT: BERT Pre-Training of Image Transformers'
+    URL: https://arxiv.org/abs/2106.08254
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.23.0/mmseg/models/backbones/beit.py#1404
+  Framework: PyTorch
+- Name: beit-large_upernet_8xb1-amp-160k_ade20k-640x640
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 56.33
+      mIoU(ms+flip): 56.84
+  Config: configs/beit/beit-large_upernet_8xb1-amp-160k_ade20k-640x640.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 8
+    Architecture:
+    - BEiT-L
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 22.64
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/beit/upernet_beit-large_fp16_8x1_640x640_160k_ade20k/upernet_beit-large_fp16_8x1_640x640_160k_ade20k-8fc0dd5d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/beit/upernet_beit-large_fp16_8x1_640x640_160k_ade20k/upernet_beit-large_fp16_8x1_640x640_160k_ade20k.log.json
+  Paper:
+    Title: 'BEiT: BERT Pre-Training of Image Transformers'
+    URL: https://arxiv.org/abs/2106.08254
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.23.0/mmseg/models/backbones/beit.py#1404
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/bisenetv1/README.md b/mmsegmentation/configs/bisenetv1/README.md
new file mode 100644
index 0000000..a505895
--- /dev/null
+++ b/mmsegmentation/configs/bisenetv1/README.md
@@ -0,0 +1,64 @@
+# BiSeNetV1
+
+> [BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation](https://arxiv.org/abs/1808.00897)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/ycszen/TorchSeg/tree/master/model/bisenet">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Semantic segmentation requires both rich spatial information and sizeable receptive field. However, modern approaches usually compromise spatial resolution to achieve real-time inference speed, which leads to poor performance. In this paper, we address this dilemma with a novel Bilateral Segmentation Network (BiSeNet). We first design a Spatial Path with a small stride to preserve the spatial information and generate high-resolution features. Meanwhile, a Context Path with a fast downsampling strategy is employed to obtain sufficient receptive field. On top of the two paths, we introduce a new Feature Fusion Module to combine features efficiently. The proposed architecture makes a right balance between the speed and segmentation performance on Cityscapes, CamVid, and COCO-Stuff datasets. Specifically, for a 2048x1024 input, we achieve 68.4% Mean IOU on the Cityscapes test dataset with speed of 105 FPS on one NVIDIA Titan XP card, which is significantly faster than the existing methods with comparable performance.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142898839-a0a78148-848a-41b2-8682-b1f61ac004ba.png" width="70%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method    | Backbone               | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                          | download                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| --------- | ---------------------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BiSeNetV1 | R-18-D32 (No Pretrain) | 1024x1024 |  160000 | 5.69     | 31.77          | V100   | 74.44 | 77.05         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_cityscapes-1024x1024.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_4x4_1024x1024_160k_cityscapes/bisenetv1_r18-d32_4x4_1024x1024_160k_cityscapes_20210922_172239-c55e78e2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_4x4_1024x1024_160k_cityscapes/bisenetv1_r18-d32_4x4_1024x1024_160k_cityscapes_20210922_172239.log.json)                                     |
+| BiSeNetV1 | R-18-D32               | 1024x1024 |  160000 | 5.69     | 31.77          | V100   | 74.37 | 76.91         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_4x4_1024x1024_160k_cityscapes/bisenetv1_r18-d32_in1k-pre_4x4_1024x1024_160k_cityscapes_20210905_220251-8ba80eff.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_4x4_1024x1024_160k_cityscapes/bisenetv1_r18-d32_in1k-pre_4x4_1024x1024_160k_cityscapes_20210905_220251.log.json) |
+| BiSeNetV1 | R-18-D32 (4x8)         | 1024x1024 |  160000 | 11.17    | 31.77          | V100   | 75.16 | 77.24         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb8-160k_cityscapes-1024x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_4x8_1024x1024_160k_cityscapes/bisenetv1_r18-d32_in1k-pre_4x8_1024x1024_160k_cityscapes_20210905_220322-bb8db75f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_4x8_1024x1024_160k_cityscapes/bisenetv1_r18-d32_in1k-pre_4x8_1024x1024_160k_cityscapes_20210905_220322.log.json) |
+| BiSeNetV1 | R-50-D32 (No Pretrain) | 1024x1024 |  160000 | 15.39    | 7.71           | V100   | 76.92 | 78.87         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_4x4_1024x1024_160k_cityscapes/bisenetv1_r50-d32_4x4_1024x1024_160k_cityscapes_20210923_222639-7b28a2a6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_4x4_1024x1024_160k_cityscapes/bisenetv1_r50-d32_4x4_1024x1024_160k_cityscapes_20210923_222639.log.json)                                     |
+| BiSeNetV1 | R-50-D32               | 1024x1024 |  160000 | 15.39    | 7.71           | V100   | 77.68 | 79.57         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_in1k-pre_4x4_1024x1024_160k_cityscapes/bisenetv1_r50-d32_in1k-pre_4x4_1024x1024_160k_cityscapes_20210917_234628-8b304447.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_in1k-pre_4x4_1024x1024_160k_cityscapes/bisenetv1_r50-d32_in1k-pre_4x4_1024x1024_160k_cityscapes_20210917_234628.log.json) |
+
+### COCO-Stuff 164k
+
+| Method    | Backbone                | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                             | download                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| --------- | ----------------------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| BiSeNetV1 | R-18-D32 (No Pretrain)  | 512x512   |  160000 | -        | -              | V100   | 25.45 | 26.15         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_coco-stuff164k-512x512.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r18-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211022_054328-046aa2f2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r18-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211022_054328.log.json)                                         |
+| BiSeNetV1 | R-18-D32                | 512x512   |  160000 | 6.33     | 74.24          | V100   | 28.55 | 29.26         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r18-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211023_013100-f700dbf7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r18-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211023_013100.log.json)     |
+| BiSeNetV1 | R-50-D32 (No Pretrain)  | 512x512   |  160000 | -        | -              | V100   | 29.82 | 30.33         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_coco-stuff164k-512x512.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r50-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_040616-d2bb0df4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r50-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_040616.log.json)                                         |
+| BiSeNetV1 | R-50-D32                | 512x512   |  160000 | 9.28     | 32.60          | V100   | 34.88 | 35.37         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r50-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_181932-66747911.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r50-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_181932.log.json)     |
+| BiSeNetV1 | R-101-D32 (No Pretrain) | 512x512   |  160000 | -        | -              | V100   | 31.14 | 31.76         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r101-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r101-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211102_164147-c6b32c3b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r101-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r101-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211102_164147.log.json)                                     |
+| BiSeNetV1 | R-101-D32               | 512x512   |  160000 | 10.36    | 25.25          | V100   | 37.38 | 37.99         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1/bisenetv1_r101-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r101-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r101-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_225220-28c8f092.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r101-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r101-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_225220.log.json) |
+
+Note:
+
+- `4x8`: Using 4 GPUs with 8 samples per GPU in training.
+- For BiSeNetV1 on Cityscapes dataset, default setting is 4 GPUs with 4 samples per GPU in training.
+- `No Pretrain` means the model is trained from scratch.
+
+## Citation
+
+```bibtex
+@inproceedings{yu2018bisenet,
+  title={Bisenet: Bilateral segmentation network for real-time semantic segmentation},
+  author={Yu, Changqian and Wang, Jingbo and Peng, Chao and Gao, Changxin and Yu, Gang and Sang, Nong},
+  booktitle={Proceedings of the European conference on computer vision (ECCV)},
+  pages={325--341},
+  year={2018}
+}
+```
diff --git a/mmsegmentation/configs/bisenetv1/bisenetv1_r101-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py b/mmsegmentation/configs/bisenetv1/bisenetv1_r101-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
new file mode 100644
index 0000000..ac63447
--- /dev/null
+++ b/mmsegmentation/configs/bisenetv1/bisenetv1_r101-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
@@ -0,0 +1,6 @@
+_base_ = './bisenetv1_r101-d32_4xb4-160k_coco-stuff164k-512x512.py'
+model = dict(
+    backbone=dict(
+        backbone_cfg=dict(
+            init_cfg=dict(
+                type='Pretrained', checkpoint='open-mmlab://resnet101_v1c'))))
diff --git a/mmsegmentation/configs/bisenetv1/bisenetv1_r101-d32_4xb4-160k_coco-stuff164k-512x512.py b/mmsegmentation/configs/bisenetv1/bisenetv1_r101-d32_4xb4-160k_coco-stuff164k-512x512.py
new file mode 100644
index 0000000..02e4e9b
--- /dev/null
+++ b/mmsegmentation/configs/bisenetv1/bisenetv1_r101-d32_4xb4-160k_coco-stuff164k-512x512.py
@@ -0,0 +1,58 @@
+_base_ = [
+    '../_base_/models/bisenetv1_r18-d32.py',
+    '../_base_/datasets/coco-stuff164k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        context_channels=(512, 1024, 2048),
+        spatial_channels=(256, 256, 256, 512),
+        out_channels=1024,
+        backbone_cfg=dict(type='ResNet', depth=101)),
+    decode_head=dict(in_channels=1024, channels=1024, num_classes=171),
+    auxiliary_head=[
+        dict(
+            type='FCNHead',
+            in_channels=512,
+            channels=256,
+            num_convs=1,
+            num_classes=171,
+            in_index=1,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+        dict(
+            type='FCNHead',
+            in_channels=512,
+            channels=256,
+            num_convs=1,
+            num_classes=171,
+            in_index=2,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    ])
+param_scheduler = [
+    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=1000,
+        end=160000,
+        by_epoch=False,
+    )
+]
+optimizer = dict(type='SGD', lr=0.005, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py
new file mode 100644
index 0000000..da3e598
--- /dev/null
+++ b/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py
@@ -0,0 +1,29 @@
+_base_ = [
+    '../_base_/models/bisenetv1_r18-d32.py',
+    '../_base_/datasets/cityscapes_1024x1024.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (1024, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        backbone_cfg=dict(
+            init_cfg=dict(
+                type='Pretrained', checkpoint='open-mmlab://resnet18_v1c'))))
+param_scheduler = [
+    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=1000,
+        end=160000,
+        by_epoch=False,
+    )
+]
+optimizer = dict(type='SGD', lr=0.025, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py b/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
new file mode 100644
index 0000000..9de889f
--- /dev/null
+++ b/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = './bisenetv1_r18-d32_4xb4-160k_coco-stuff164k-512x512.py'
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        backbone_cfg=dict(
+            init_cfg=dict(
+                type='Pretrained', checkpoint='open-mmlab://resnet18_v1c'))),
+)
diff --git a/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb8-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb8-160k_cityscapes-1024x1024.py
new file mode 100644
index 0000000..0580ce1
--- /dev/null
+++ b/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb8-160k_cityscapes-1024x1024.py
@@ -0,0 +1,4 @@
+_base_ = './bisenetv1_r18-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py'
+train_dataloader = dict(batch_size=8, num_workers=4)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_cityscapes-1024x1024.py
new file mode 100644
index 0000000..6c3e12b
--- /dev/null
+++ b/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_cityscapes-1024x1024.py
@@ -0,0 +1,24 @@
+_base_ = [
+    '../_base_/models/bisenetv1_r18-d32.py',
+    '../_base_/datasets/cityscapes_1024x1024.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (1024, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
+param_scheduler = [
+    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=1000,
+        end=160000,
+        by_epoch=False,
+    )
+]
+optimizer = dict(type='SGD', lr=0.025, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_coco-stuff164k-512x512.py b/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_coco-stuff164k-512x512.py
new file mode 100644
index 0000000..2109d68
--- /dev/null
+++ b/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_coco-stuff164k-512x512.py
@@ -0,0 +1,53 @@
+_base_ = [
+    '../_base_/models/bisenetv1_r18-d32.py',
+    '../_base_/datasets/coco-stuff164k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=171),
+    auxiliary_head=[
+        dict(
+            type='FCNHead',
+            in_channels=128,
+            channels=64,
+            num_convs=1,
+            num_classes=171,
+            in_index=1,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+        dict(
+            type='FCNHead',
+            in_channels=128,
+            channels=64,
+            num_convs=1,
+            num_classes=171,
+            in_index=2,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    ])
+param_scheduler = [
+    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=1000,
+        end=160000,
+        by_epoch=False,
+    )
+]
+optimizer = dict(type='SGD', lr=0.005, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py
new file mode 100644
index 0000000..013c4ff
--- /dev/null
+++ b/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py
@@ -0,0 +1,7 @@
+_base_ = './bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024.py'
+model = dict(
+    type='EncoderDecoder',
+    backbone=dict(
+        backbone_cfg=dict(
+            init_cfg=dict(
+                type='Pretrained', checkpoint='open-mmlab://resnet50_v1c'))))
diff --git a/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py b/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
new file mode 100644
index 0000000..b35259c
--- /dev/null
+++ b/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
@@ -0,0 +1,7 @@
+_base_ = './bisenetv1_r50-d32_4xb4-160k_coco-stuff164k-512x512.py'
+
+model = dict(
+    backbone=dict(
+        backbone_cfg=dict(
+            init_cfg=dict(
+                type='Pretrained', checkpoint='open-mmlab://resnet50_v1c'))))
diff --git a/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024.py
new file mode 100644
index 0000000..9753c10
--- /dev/null
+++ b/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024.py
@@ -0,0 +1,55 @@
+_base_ = [
+    '../_base_/models/bisenetv1_r18-d32.py',
+    '../_base_/datasets/cityscapes_1024x1024.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+crop_size = (1024, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='BiSeNetV1',
+        context_channels=(512, 1024, 2048),
+        spatial_channels=(256, 256, 256, 512),
+        out_channels=1024,
+        backbone_cfg=dict(type='ResNet', depth=50)),
+    decode_head=dict(
+        type='FCNHead', in_channels=1024, in_index=0, channels=1024),
+    auxiliary_head=[
+        dict(
+            type='FCNHead',
+            in_channels=512,
+            channels=256,
+            num_convs=1,
+            num_classes=19,
+            in_index=1,
+            norm_cfg=norm_cfg,
+            concat_input=False),
+        dict(
+            type='FCNHead',
+            in_channels=512,
+            channels=256,
+            num_convs=1,
+            num_classes=19,
+            in_index=2,
+            norm_cfg=norm_cfg,
+            concat_input=False),
+    ])
+param_scheduler = [
+    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=1000,
+        end=160000,
+        by_epoch=False,
+    )
+]
+optimizer = dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_coco-stuff164k-512x512.py b/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_coco-stuff164k-512x512.py
new file mode 100644
index 0000000..8b6ef74
--- /dev/null
+++ b/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_coco-stuff164k-512x512.py
@@ -0,0 +1,58 @@
+_base_ = [
+    '../_base_/models/bisenetv1_r18-d32.py',
+    '../_base_/datasets/coco-stuff164k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        context_channels=(512, 1024, 2048),
+        spatial_channels=(256, 256, 256, 512),
+        out_channels=1024,
+        backbone_cfg=dict(type='ResNet', depth=50)),
+    decode_head=dict(in_channels=1024, channels=1024, num_classes=171),
+    auxiliary_head=[
+        dict(
+            type='FCNHead',
+            in_channels=512,
+            channels=256,
+            num_convs=1,
+            num_classes=171,
+            in_index=1,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+        dict(
+            type='FCNHead',
+            in_channels=512,
+            channels=256,
+            num_convs=1,
+            num_classes=171,
+            in_index=2,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    ])
+param_scheduler = [
+    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=1000,
+        end=160000,
+        by_epoch=False,
+    )
+]
+optimizer = dict(type='SGD', lr=0.005, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/bisenetv1/metafile.yaml b/mmsegmentation/configs/bisenetv1/metafile.yaml
new file mode 100644
index 0000000..e37f632
--- /dev/null
+++ b/mmsegmentation/configs/bisenetv1/metafile.yaml
@@ -0,0 +1,275 @@
+Collections:
+- Name: BiSeNetV1
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+    - COCO-Stuff 164k
+  Paper:
+    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
+    URL: https://arxiv.org/abs/1808.00897
+  README: configs/bisenetv1/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: bisenetv1_r18-d32_4xb4-160k_cityscapes-1024x1024
+  In Collection: BiSeNetV1
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 74.44
+      mIoU(ms+flip): 77.05
+  Config: configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_cityscapes-1024x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 16
+    Architecture:
+    - R-18-D32
+    - BiSeNetV1
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.69
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_4x4_1024x1024_160k_cityscapes/bisenetv1_r18-d32_4x4_1024x1024_160k_cityscapes_20210922_172239-c55e78e2.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_4x4_1024x1024_160k_cityscapes/bisenetv1_r18-d32_4x4_1024x1024_160k_cityscapes_20210922_172239.log.json
+  Paper:
+    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
+    URL: https://arxiv.org/abs/1808.00897
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266
+  Framework: PyTorch
+- Name: bisenetv1_r18-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024
+  In Collection: BiSeNetV1
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 74.37
+      mIoU(ms+flip): 76.91
+  Config: configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 16
+    Architecture:
+    - R-18-D32
+    - BiSeNetV1
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.69
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_4x4_1024x1024_160k_cityscapes/bisenetv1_r18-d32_in1k-pre_4x4_1024x1024_160k_cityscapes_20210905_220251-8ba80eff.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_4x4_1024x1024_160k_cityscapes/bisenetv1_r18-d32_in1k-pre_4x4_1024x1024_160k_cityscapes_20210905_220251.log.json
+  Paper:
+    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
+    URL: https://arxiv.org/abs/1808.00897
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266
+  Framework: PyTorch
+- Name: bisenetv1_r18-d32-in1k-pre_4xb8-160k_cityscapes-1024x1024
+  In Collection: BiSeNetV1
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 75.16
+      mIoU(ms+flip): 77.24
+  Config: configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb8-160k_cityscapes-1024x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 32
+    Architecture:
+    - R-18-D32
+    - BiSeNetV1
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 11.17
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_4x8_1024x1024_160k_cityscapes/bisenetv1_r18-d32_in1k-pre_4x8_1024x1024_160k_cityscapes_20210905_220322-bb8db75f.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_4x8_1024x1024_160k_cityscapes/bisenetv1_r18-d32_in1k-pre_4x8_1024x1024_160k_cityscapes_20210905_220322.log.json
+  Paper:
+    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
+    URL: https://arxiv.org/abs/1808.00897
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266
+  Framework: PyTorch
+- Name: bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024
+  In Collection: BiSeNetV1
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.92
+      mIoU(ms+flip): 78.87
+  Config: configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 16
+    Architecture:
+    - R-50-D32
+    - BiSeNetV1
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 15.39
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_4x4_1024x1024_160k_cityscapes/bisenetv1_r50-d32_4x4_1024x1024_160k_cityscapes_20210923_222639-7b28a2a6.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_4x4_1024x1024_160k_cityscapes/bisenetv1_r50-d32_4x4_1024x1024_160k_cityscapes_20210923_222639.log.json
+  Paper:
+    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
+    URL: https://arxiv.org/abs/1808.00897
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266
+  Framework: PyTorch
+- Name: bisenetv1_r50-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024
+  In Collection: BiSeNetV1
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.68
+      mIoU(ms+flip): 79.57
+  Config: configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 16
+    Architecture:
+    - R-50-D32
+    - BiSeNetV1
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 15.39
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_in1k-pre_4x4_1024x1024_160k_cityscapes/bisenetv1_r50-d32_in1k-pre_4x4_1024x1024_160k_cityscapes_20210917_234628-8b304447.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_in1k-pre_4x4_1024x1024_160k_cityscapes/bisenetv1_r50-d32_in1k-pre_4x4_1024x1024_160k_cityscapes_20210917_234628.log.json
+  Paper:
+    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
+    URL: https://arxiv.org/abs/1808.00897
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266
+  Framework: PyTorch
+- Name: bisenetv1_r18-d32_4xb4-160k_coco-stuff164k-512x512
+  In Collection: BiSeNetV1
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 164k
+    Metrics:
+      mIoU: 25.45
+      mIoU(ms+flip): 26.15
+  Config: configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_coco-stuff164k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 164k
+    Batch Size: 16
+    Architecture:
+    - R-18-D32
+    - BiSeNetV1
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r18-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211022_054328-046aa2f2.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r18-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211022_054328.log.json
+  Paper:
+    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
+    URL: https://arxiv.org/abs/1808.00897
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266
+  Framework: PyTorch
+- Name: bisenetv1_r18-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512
+  In Collection: BiSeNetV1
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 164k
+    Metrics:
+      mIoU: 28.55
+      mIoU(ms+flip): 29.26
+  Config: configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 164k
+    Batch Size: 16
+    Architecture:
+    - R-18-D32
+    - BiSeNetV1
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.33
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r18-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211023_013100-f700dbf7.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r18-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211023_013100.log.json
+  Paper:
+    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
+    URL: https://arxiv.org/abs/1808.00897
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266
+  Framework: PyTorch
+- Name: bisenetv1_r50-d32_4xb4-160k_coco-stuff164k-512x512
+  In Collection: BiSeNetV1
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 164k
+    Metrics:
+      mIoU: 29.82
+      mIoU(ms+flip): 30.33
+  Config: configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_coco-stuff164k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 164k
+    Batch Size: 16
+    Architecture:
+    - R-50-D32
+    - BiSeNetV1
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r50-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_040616-d2bb0df4.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r50-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_040616.log.json
+  Paper:
+    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
+    URL: https://arxiv.org/abs/1808.00897
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266
+  Framework: PyTorch
+- Name: bisenetv1_r50-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512
+  In Collection: BiSeNetV1
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 164k
+    Metrics:
+      mIoU: 34.88
+      mIoU(ms+flip): 35.37
+  Config: configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 164k
+    Batch Size: 16
+    Architecture:
+    - R-50-D32
+    - BiSeNetV1
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.28
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r50-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_181932-66747911.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r50-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_181932.log.json
+  Paper:
+    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
+    URL: https://arxiv.org/abs/1808.00897
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266
+  Framework: PyTorch
+- Name: bisenetv1_r50-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512
+  In Collection: BiSeNetV1
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 164k
+    Metrics:
+      mIoU: 31.14
+      mIoU(ms+flip): 31.76
+  Config: configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 164k
+    Batch Size: 16
+    Architecture:
+    - R-101-D32
+    - BiSeNetV1
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r101-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r101-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211102_164147-c6b32c3b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r101-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r101-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211102_164147.log.json
+  Paper:
+    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
+    URL: https://arxiv.org/abs/1808.00897
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266
+  Framework: PyTorch
+- Name: bisenetv1_r101-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512
+  In Collection: BiSeNetV1
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 164k
+    Metrics:
+      mIoU: 37.38
+      mIoU(ms+flip): 37.99
+  Config: configs/bisenetv1/bisenetv1_r101-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 164k
+    Batch Size: 16
+    Architecture:
+    - R-101-D32
+    - BiSeNetV1
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.36
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r101-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r101-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_225220-28c8f092.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r101-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r101-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_225220.log.json
+  Paper:
+    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
+    URL: https://arxiv.org/abs/1808.00897
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/bisenetv2/README.md b/mmsegmentation/configs/bisenetv2/README.md
new file mode 100644
index 0000000..a5871df
--- /dev/null
+++ b/mmsegmentation/configs/bisenetv2/README.md
@@ -0,0 +1,53 @@
+# BiSeNetV2
+
+> [Bisenet v2: Bilateral Network with Guided Aggregation for Real-time Semantic Segmentation](https://arxiv.org/abs/2004.02147)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv2.py#L545">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+The low-level details and high-level semantics are both essential to the semantic segmentation task. However, to speed up the model inference, current approaches almost always sacrifice the low-level details, which leads to a considerable accuracy decrease. We propose to treat these spatial details and categorical semantics separately to achieve high accuracy and high efficiency for realtime semantic segmentation. To this end, we propose an efficient and effective architecture with a good trade-off between speed and accuracy, termed Bilateral Segmentation Network (BiSeNet V2). This architecture involves: (i) a Detail Branch, with wide channels and shallow layers to capture low-level details and generate high-resolution feature representation; (ii) a Semantic Branch, with narrow channels and deep layers to obtain high-level semantic context. The Semantic Branch is lightweight due to reducing the channel capacity and a fast-downsampling strategy. Furthermore, we design a Guided Aggregation Layer to enhance mutual connections and fuse both types of feature representation. Besides, a booster training strategy is designed to improve the segmentation performance without any extra inference cost. Extensive quantitative and qualitative evaluations demonstrate that the proposed architecture performs favourably against a few state-of-the-art real-time semantic segmentation approaches. Specifically, for a 2,048x1,024 input, we achieve 72.6% Mean IoU on the Cityscapes test set with a speed of 156 FPS on one NVIDIA GeForce GTX 1080 Ti card, which is significantly faster than existing methods, yet we achieve better segmentation accuracy.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142898966-ec4a81da-b4b0-41ee-b083-1d964582c18a.png" width="70%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method    | Backbone         | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                  | download                                                                                                                                                                                                                                                                                                                                                                                               |
+| --------- | ---------------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | --------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| BiSeNetV2 | BiSeNetV2        | 1024x1024 |  160000 | 7.64     | 31.77          | V100   | 73.21 |         75.74 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv2/bisenetv2_fcn_4xb4-160k_cityscapes-1024x1024.py)      | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_4x4_1024x1024_160k_cityscapes_20210902_015551-bcf10f09.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_4x4_1024x1024_160k_cityscapes_20210902_015551.log.json)                     |
+| BiSeNetV2 | BiSeNetV2 (OHEM) | 1024x1024 |  160000 | 7.64     | -              | V100   | 73.57 |         75.80 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv2/bisenetv2_fcn_4xb4-ohem-160k_cityscapes-1024x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_ohem_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_ohem_4x4_1024x1024_160k_cityscapes_20210902_112947-5f8103b4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_ohem_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_ohem_4x4_1024x1024_160k_cityscapes_20210902_112947.log.json) |
+| BiSeNetV2 | BiSeNetV2 (4x8)  | 1024x1024 |  160000 | 15.05    | -              | V100   | 75.76 |         77.79 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv2/bisenetv2_fcn_4xb8-160k_cityscapes-1024x1024.py)      | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_4x8_1024x1024_160k_cityscapes/bisenetv2_fcn_4x8_1024x1024_160k_cityscapes_20210903_000032-e1a2eed6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_4x8_1024x1024_160k_cityscapes/bisenetv2_fcn_4x8_1024x1024_160k_cityscapes_20210903_000032.log.json)                     |
+| BiSeNetV2 | BiSeNetV2 (FP16) | 1024x1024 |  160000 | 5.77     | 36.65          | V100   | 73.07 |         75.13 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv2/bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_fp16_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_fp16_4x4_1024x1024_160k_cityscapes_20210902_045942-b979777b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_fp16_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_fp16_4x4_1024x1024_160k_cityscapes_20210902_045942.log.json) |
+
+Note:
+
+- `OHEM` means Online Hard Example Mining (OHEM) is adopted in training.
+- `FP16` means Mixed Precision (FP16) is adopted in training.
+- `4x8` means 4 GPUs with 8 samples per GPU in training.
+
+## Citation
+
+```bibtex
+@article{yu2021bisenet,
+  title={Bisenet v2: Bilateral network with guided aggregation for real-time semantic segmentation},
+  author={Yu, Changqian and Gao, Changxin and Wang, Jingbo and Yu, Gang and Shen, Chunhua and Sang, Nong},
+  journal={International Journal of Computer Vision},
+  pages={1--18},
+  year={2021},
+  publisher={Springer}
+}
+```
diff --git a/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-160k_cityscapes-1024x1024.py
new file mode 100644
index 0000000..6462ce7
--- /dev/null
+++ b/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-160k_cityscapes-1024x1024.py
@@ -0,0 +1,24 @@
+_base_ = [
+    '../_base_/models/bisenetv2.py',
+    '../_base_/datasets/cityscapes_1024x1024.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (1024, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
+param_scheduler = [
+    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=1000,
+        end=160000,
+        by_epoch=False,
+    )
+]
+optimizer = dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024.py
new file mode 100644
index 0000000..8ed338c
--- /dev/null
+++ b/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024.py
@@ -0,0 +1,6 @@
+_base_ = './bisenetv2_fcn_4xb4-160k_cityscapes-1024x1024.py'
+optim_wrapper = dict(
+    _delete_=True,
+    type='AmpOptimWrapper',
+    optimizer=dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005),
+    loss_scale=512.)
diff --git a/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-ohem-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-ohem-160k_cityscapes-1024x1024.py
new file mode 100644
index 0000000..8d5cbcb
--- /dev/null
+++ b/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-ohem-160k_cityscapes-1024x1024.py
@@ -0,0 +1,83 @@
+_base_ = [
+    '../_base_/models/bisenetv2.py',
+    '../_base_/datasets/cityscapes_1024x1024.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (1024, 1024)
+data_preprocessor = dict(size=crop_size)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+models = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(
+        sampler=dict(type='OHEMPixelSampler', thresh=0.7, min_kept=10000)),
+    auxiliary_head=[
+        dict(
+            type='FCNHead',
+            in_channels=16,
+            channels=16,
+            num_convs=2,
+            num_classes=19,
+            in_index=1,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            align_corners=False,
+            sampler=dict(type='OHEMPixelSampler', thresh=0.7, min_kept=10000),
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+        dict(
+            type='FCNHead',
+            in_channels=32,
+            channels=64,
+            num_convs=2,
+            num_classes=19,
+            in_index=2,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            align_corners=False,
+            sampler=dict(type='OHEMPixelSampler', thresh=0.7, min_kept=10000),
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+        dict(
+            type='FCNHead',
+            in_channels=64,
+            channels=256,
+            num_convs=2,
+            num_classes=19,
+            in_index=3,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            align_corners=False,
+            sampler=dict(type='OHEMPixelSampler', thresh=0.7, min_kept=10000),
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+        dict(
+            type='FCNHead',
+            in_channels=128,
+            channels=1024,
+            num_convs=2,
+            num_classes=19,
+            in_index=4,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            align_corners=False,
+            sampler=dict(type='OHEMPixelSampler', thresh=0.7, min_kept=10000),
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    ],
+)
+param_scheduler = [
+    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=1000,
+        end=160000,
+        by_epoch=False,
+    )
+]
+optimizer = dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb8-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb8-160k_cityscapes-1024x1024.py
new file mode 100644
index 0000000..8fcba64
--- /dev/null
+++ b/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb8-160k_cityscapes-1024x1024.py
@@ -0,0 +1,24 @@
+_base_ = [
+    '../_base_/models/bisenetv2.py',
+    '../_base_/datasets/cityscapes_1024x1024.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (1024, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
+param_scheduler = [
+    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=1000,
+        end=160000,
+        by_epoch=False,
+    )
+]
+optimizer = dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
+train_dataloader = dict(batch_size=8, num_workers=4)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/bisenetv2/metafile.yaml b/mmsegmentation/configs/bisenetv2/metafile.yaml
new file mode 100644
index 0000000..5430ec3
--- /dev/null
+++ b/mmsegmentation/configs/bisenetv2/metafile.yaml
@@ -0,0 +1,114 @@
+Collections:
+- Name: BiSeNetV2
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+  Paper:
+    Title: 'Bisenet v2: Bilateral Network with Guided Aggregation for Real-time Semantic
+      Segmentation'
+    URL: https://arxiv.org/abs/2004.02147
+  README: configs/bisenetv2/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: bisenetv2_fcn_4xb4-160k_cityscapes-1024x1024
+  In Collection: BiSeNetV2
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 73.21
+      mIoU(ms+flip): 75.74
+  Config: configs/bisenetv2/bisenetv2_fcn_4xb4-160k_cityscapes-1024x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 16
+    Architecture:
+    - BiSeNetV2
+    - BiSeNetV2
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 7.64
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_4x4_1024x1024_160k_cityscapes_20210902_015551-bcf10f09.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_4x4_1024x1024_160k_cityscapes_20210902_015551.log.json
+  Paper:
+    Title: 'Bisenet v2: Bilateral Network with Guided Aggregation for Real-time Semantic
+      Segmentation'
+    URL: https://arxiv.org/abs/2004.02147
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv2.py#L545
+  Framework: PyTorch
+- Name: bisenetv2_fcn_4xb4-ohem-160k_cityscapes-1024x1024
+  In Collection: BiSeNetV2
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 73.57
+      mIoU(ms+flip): 75.8
+  Config: configs/bisenetv2/bisenetv2_fcn_4xb4-ohem-160k_cityscapes-1024x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 16
+    Architecture:
+    - BiSeNetV2
+    - BiSeNetV2
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 7.64
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_ohem_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_ohem_4x4_1024x1024_160k_cityscapes_20210902_112947-5f8103b4.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_ohem_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_ohem_4x4_1024x1024_160k_cityscapes_20210902_112947.log.json
+  Paper:
+    Title: 'Bisenet v2: Bilateral Network with Guided Aggregation for Real-time Semantic
+      Segmentation'
+    URL: https://arxiv.org/abs/2004.02147
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv2.py#L545
+  Framework: PyTorch
+- Name: bisenetv2_fcn_4xb8-160k_cityscapes-1024x1024
+  In Collection: BiSeNetV2
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 75.76
+      mIoU(ms+flip): 77.79
+  Config: configs/bisenetv2/bisenetv2_fcn_4xb8-160k_cityscapes-1024x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 32
+    Architecture:
+    - BiSeNetV2
+    - BiSeNetV2
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 15.05
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_4x8_1024x1024_160k_cityscapes/bisenetv2_fcn_4x8_1024x1024_160k_cityscapes_20210903_000032-e1a2eed6.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_4x8_1024x1024_160k_cityscapes/bisenetv2_fcn_4x8_1024x1024_160k_cityscapes_20210903_000032.log.json
+  Paper:
+    Title: 'Bisenet v2: Bilateral Network with Guided Aggregation for Real-time Semantic
+      Segmentation'
+    URL: https://arxiv.org/abs/2004.02147
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv2.py#L545
+  Framework: PyTorch
+- Name: bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024
+  In Collection: BiSeNetV2
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 73.07
+      mIoU(ms+flip): 75.13
+  Config: configs/bisenetv2/bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 16
+    Architecture:
+    - BiSeNetV2
+    - BiSeNetV2
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.77
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_fp16_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_fp16_4x4_1024x1024_160k_cityscapes_20210902_045942-b979777b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_fp16_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_fp16_4x4_1024x1024_160k_cityscapes_20210902_045942.log.json
+  Paper:
+    Title: 'Bisenet v2: Bilateral Network with Guided Aggregation for Real-time Semantic
+      Segmentation'
+    URL: https://arxiv.org/abs/2004.02147
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv2.py#L545
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/ccnet/README.md b/mmsegmentation/configs/ccnet/README.md
new file mode 100644
index 0000000..64dd5f0
--- /dev/null
+++ b/mmsegmentation/configs/ccnet/README.md
@@ -0,0 +1,67 @@
+# CCNet
+
+> [CCNet: Criss-Cross Attention for Semantic Segmentation](https://arxiv.org/abs/1811.11721)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/speedinghzl/CCNet">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Contextual information is vital in visual understanding problems, such as semantic segmentation and object detection. We propose a Criss-Cross Network (CCNet) for obtaining full-image contextual information in a very effective and efficient way. Concretely, for each pixel, a novel criss-cross attention module harvests the contextual information of all the pixels on its criss-cross path. By taking a further recurrent operation, each pixel can finally capture the full-image dependencies. Besides, a category consistent loss is proposed to enforce the criss-cross attention module to produce more discriminative features. Overall, CCNet is with the following merits: 1) GPU memory friendly. Compared with the non-local block, the proposed recurrent criss-cross attention module requires 11x less GPU memory usage. 2) High computational efficiency. The recurrent criss-cross attention significantly reduces FLOPs by about 85% of the non-local block. 3) The state-of-the-art performance. We conduct extensive experiments on semantic segmentation benchmarks including Cityscapes, ADE20K, human parsing benchmark LIP, instance segmentation benchmark COCO, video segmentation benchmark CamVid. In particular, our CCNet achieves the mIoU scores of 81.9%, 45.76% and 55.47% on the Cityscapes test set, the ADE20K validation set and the LIP validation set respectively, which are the new state-of-the-art results. The source codes are available at [this https URL](https://github.com/speedinghzl/CCNet).
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142899159-b329c12a-0fde-44df-8718-def6cfb004e4.png" width="70%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                       | download                                                                                                                                                                                                                                                                                                                                           |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ---------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CCNet  | R-50-D8  | 512x1024  |   40000 | 6        | 3.32           | V100   | 77.76 |         78.87 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x1024_40k_cityscapes/ccnet_r50-d8_512x1024_40k_cityscapes_20200616_142517-4123f401.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x1024_40k_cityscapes/ccnet_r50-d8_512x1024_40k_cityscapes_20200616_142517.log.json)     |
+| CCNet  | R-101-D8 | 512x1024  |   40000 | 9.5      | 2.31           | V100   | 76.35 |         78.19 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x1024_40k_cityscapes/ccnet_r101-d8_512x1024_40k_cityscapes_20200616_142540-a3b84ba6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x1024_40k_cityscapes/ccnet_r101-d8_512x1024_40k_cityscapes_20200616_142540.log.json) |
+| CCNet  | R-50-D8  | 769x769   |   40000 | 6.8      | 1.43           | V100   | 78.46 |         79.93 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_769x769_40k_cityscapes/ccnet_r50-d8_769x769_40k_cityscapes_20200616_145125-76d11884.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_769x769_40k_cityscapes/ccnet_r50-d8_769x769_40k_cityscapes_20200616_145125.log.json)         |
+| CCNet  | R-101-D8 | 769x769   |   40000 | 10.7     | 1.01           | V100   | 76.94 |         78.62 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_769x769_40k_cityscapes/ccnet_r101-d8_769x769_40k_cityscapes_20200617_101428-4f57c8d0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_769x769_40k_cityscapes/ccnet_r101-d8_769x769_40k_cityscapes_20200617_101428.log.json)     |
+| CCNet  | R-50-D8  | 512x1024  |   80000 | -        | -              | V100   | 79.03 |         80.16 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x1024_80k_cityscapes/ccnet_r50-d8_512x1024_80k_cityscapes_20200617_010421-869a3423.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x1024_80k_cityscapes/ccnet_r50-d8_512x1024_80k_cityscapes_20200617_010421.log.json)     |
+| CCNet  | R-101-D8 | 512x1024  |   80000 | -        | -              | V100   | 78.87 |         79.90 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x1024_80k_cityscapes/ccnet_r101-d8_512x1024_80k_cityscapes_20200617_203935-ffae8917.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x1024_80k_cityscapes/ccnet_r101-d8_512x1024_80k_cityscapes_20200617_203935.log.json) |
+| CCNet  | R-50-D8  | 769x769   |   80000 | -        | -              | V100   | 79.29 |         81.08 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_769x769_80k_cityscapes/ccnet_r50-d8_769x769_80k_cityscapes_20200617_010421-73eed8ca.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_769x769_80k_cityscapes/ccnet_r50-d8_769x769_80k_cityscapes_20200617_010421.log.json)         |
+| CCNet  | R-101-D8 | 769x769   |   80000 | -        | -              | V100   | 79.45 |         80.66 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_769x769_80k_cityscapes/ccnet_r101-d8_769x769_80k_cityscapes_20200618_011502-ad3cd481.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_769x769_80k_cityscapes/ccnet_r101-d8_769x769_80k_cityscapes_20200618_011502.log.json)     |
+
+### ADE20K
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                   | download                                                                                                                                                                                                                                                                                                                           |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CCNet  | R-50-D8  | 512x512   |   80000 | 8.8      | 20.89          | V100   | 41.78 |         42.98 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_80k_ade20k/ccnet_r50-d8_512x512_80k_ade20k_20200615_014848-aa37f61e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_80k_ade20k/ccnet_r50-d8_512x512_80k_ade20k_20200615_014848.log.json)         |
+| CCNet  | R-101-D8 | 512x512   |   80000 | 12.2     | 14.11          | V100   | 43.97 |         45.13 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_80k_ade20k/ccnet_r101-d8_512x512_80k_ade20k_20200615_014848-1f4929a3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_80k_ade20k/ccnet_r101-d8_512x512_80k_ade20k_20200615_014848.log.json)     |
+| CCNet  | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 42.08 |         43.13 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_160k_ade20k/ccnet_r50-d8_512x512_160k_ade20k_20200616_084435-7c97193b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_160k_ade20k/ccnet_r50-d8_512x512_160k_ade20k_20200616_084435.log.json)     |
+| CCNet  | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 43.71 |         45.04 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_160k_ade20k/ccnet_r101-d8_512x512_160k_ade20k_20200616_000644-e849e007.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_160k_ade20k/ccnet_r101-d8_512x512_160k_ade20k_20200616_000644.log.json) |
+
+### Pascal VOC 2012 + Aug
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                    | download                                                                                                                                                                                                                                                                                                                               |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CCNet  | R-50-D8  | 512x512   |   20000 | 6        | 20.45          | V100   | 76.17 |         77.51 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r50-d8_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_20k_voc12aug/ccnet_r50-d8_512x512_20k_voc12aug_20200617_193212-fad81784.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_20k_voc12aug/ccnet_r50-d8_512x512_20k_voc12aug_20200617_193212.log.json)     |
+| CCNet  | R-101-D8 | 512x512   |   20000 | 9.5      | 13.64          | V100   | 77.27 |         79.02 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r101-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_20k_voc12aug/ccnet_r101-d8_512x512_20k_voc12aug_20200617_193212-0007b61d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_20k_voc12aug/ccnet_r101-d8_512x512_20k_voc12aug_20200617_193212.log.json) |
+| CCNet  | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 75.96 |         77.04 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r50-d8_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_40k_voc12aug/ccnet_r50-d8_512x512_40k_voc12aug_20200613_232127-c2a15f02.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_40k_voc12aug/ccnet_r50-d8_512x512_40k_voc12aug_20200613_232127.log.json)     |
+| CCNet  | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 77.87 |         78.90 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r101-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_40k_voc12aug/ccnet_r101-d8_512x512_40k_voc12aug_20200613_232127-c30da577.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_40k_voc12aug/ccnet_r101-d8_512x512_40k_voc12aug_20200613_232127.log.json) |
+
+## Citation
+
+```bibtex
+@article{huang2018ccnet,
+    title={CCNet: Criss-Cross Attention for Semantic Segmentation},
+    author={Huang, Zilong and Wang, Xinggang and Huang, Lichao and Huang, Chang and Wei, Yunchao and Liu, Wenyu},
+    booktitle={ICCV},
+    year={2019}
+}
+```
diff --git a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..0c49e1e
--- /dev/null
+++ b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './ccnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..f24f5a7
--- /dev/null
+++ b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './ccnet_r50-d8_4xb2-40k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..b358e12
--- /dev/null
+++ b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './ccnet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..7575076
--- /dev/null
+++ b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './ccnet_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..a29d118
--- /dev/null
+++ b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './ccnet_r50-d8_4xb4-160k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..fd421a2
--- /dev/null
+++ b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './ccnet_r50-d8_4xb4-20k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..425dfcf
--- /dev/null
+++ b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './ccnet_r50-d8_4xb4-40k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..f6dcb9c
--- /dev/null
+++ b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './ccnet_r50-d8_4xb4-80k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..84fc51a
--- /dev/null
+++ b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/ccnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..a930794
--- /dev/null
+++ b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/ccnet_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..89bfe81
--- /dev/null
+++ b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/ccnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..5f7c954
--- /dev/null
+++ b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/ccnet_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..cee810c
--- /dev/null
+++ b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/ccnet_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..76a90d9
--- /dev/null
+++ b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/ccnet_r50-d8.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_20k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..a8aeb85
--- /dev/null
+++ b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/ccnet_r50-d8.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..f7fced0
--- /dev/null
+++ b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/ccnet_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/ccnet/metafile.yaml b/mmsegmentation/configs/ccnet/metafile.yaml
new file mode 100644
index 0000000..62e5694
--- /dev/null
+++ b/mmsegmentation/configs/ccnet/metafile.yaml
@@ -0,0 +1,391 @@
+Collections:
+- Name: CCNet
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+    - ADE20K
+    - Pascal VOC 2012 + Aug
+  Paper:
+    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1811.11721
+  README: configs/ccnet/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: ccnet_r50-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: CCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.76
+      mIoU(ms+flip): 78.87
+  Config: configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - CCNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x1024_40k_cityscapes/ccnet_r50-d8_512x1024_40k_cityscapes_20200616_142517-4123f401.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x1024_40k_cityscapes/ccnet_r50-d8_512x1024_40k_cityscapes_20200616_142517.log.json
+  Paper:
+    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1811.11721
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: ccnet_r101-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: CCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.35
+      mIoU(ms+flip): 78.19
+  Config: configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - CCNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x1024_40k_cityscapes/ccnet_r101-d8_512x1024_40k_cityscapes_20200616_142540-a3b84ba6.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x1024_40k_cityscapes/ccnet_r101-d8_512x1024_40k_cityscapes_20200616_142540.log.json
+  Paper:
+    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1811.11721
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: ccnet_r50-d8_4xb2-40k_cityscapes-769x769
+  In Collection: CCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.46
+      mIoU(ms+flip): 79.93
+  Config: configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - CCNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_769x769_40k_cityscapes/ccnet_r50-d8_769x769_40k_cityscapes_20200616_145125-76d11884.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_769x769_40k_cityscapes/ccnet_r50-d8_769x769_40k_cityscapes_20200616_145125.log.json
+  Paper:
+    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1811.11721
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: ccnet_r101-d8_4xb2-40k_cityscapes-769x769
+  In Collection: CCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.94
+      mIoU(ms+flip): 78.62
+  Config: configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - CCNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.7
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_769x769_40k_cityscapes/ccnet_r101-d8_769x769_40k_cityscapes_20200617_101428-4f57c8d0.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_769x769_40k_cityscapes/ccnet_r101-d8_769x769_40k_cityscapes_20200617_101428.log.json
+  Paper:
+    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1811.11721
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: ccnet_r50-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: CCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.03
+      mIoU(ms+flip): 80.16
+  Config: configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - CCNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x1024_80k_cityscapes/ccnet_r50-d8_512x1024_80k_cityscapes_20200617_010421-869a3423.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x1024_80k_cityscapes/ccnet_r50-d8_512x1024_80k_cityscapes_20200617_010421.log.json
+  Paper:
+    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1811.11721
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: ccnet_r101-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: CCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.87
+      mIoU(ms+flip): 79.9
+  Config: configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - CCNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x1024_80k_cityscapes/ccnet_r101-d8_512x1024_80k_cityscapes_20200617_203935-ffae8917.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x1024_80k_cityscapes/ccnet_r101-d8_512x1024_80k_cityscapes_20200617_203935.log.json
+  Paper:
+    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1811.11721
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: ccnet_r50-d8_4xb2-80k_cityscapes-769x769
+  In Collection: CCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.29
+      mIoU(ms+flip): 81.08
+  Config: configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - CCNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_769x769_80k_cityscapes/ccnet_r50-d8_769x769_80k_cityscapes_20200617_010421-73eed8ca.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_769x769_80k_cityscapes/ccnet_r50-d8_769x769_80k_cityscapes_20200617_010421.log.json
+  Paper:
+    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1811.11721
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: ccnet_r101-d8_4xb2-80k_cityscapes-769x769
+  In Collection: CCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.45
+      mIoU(ms+flip): 80.66
+  Config: configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - CCNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_769x769_80k_cityscapes/ccnet_r101-d8_769x769_80k_cityscapes_20200618_011502-ad3cd481.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_769x769_80k_cityscapes/ccnet_r101-d8_769x769_80k_cityscapes_20200618_011502.log.json
+  Paper:
+    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1811.11721
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: ccnet_r50-d8_4xb4-80k_ade20k-512x512
+  In Collection: CCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 41.78
+      mIoU(ms+flip): 42.98
+  Config: configs/ccnet/ccnet_r50-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - CCNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_80k_ade20k/ccnet_r50-d8_512x512_80k_ade20k_20200615_014848-aa37f61e.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_80k_ade20k/ccnet_r50-d8_512x512_80k_ade20k_20200615_014848.log.json
+  Paper:
+    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1811.11721
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: ccnet_r101-d8_4xb4-80k_ade20k-512x512
+  In Collection: CCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 43.97
+      mIoU(ms+flip): 45.13
+  Config: configs/ccnet/ccnet_r101-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - CCNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 12.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_80k_ade20k/ccnet_r101-d8_512x512_80k_ade20k_20200615_014848-1f4929a3.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_80k_ade20k/ccnet_r101-d8_512x512_80k_ade20k_20200615_014848.log.json
+  Paper:
+    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1811.11721
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: ccnet_r50-d8_4xb4-160k_ade20k-512x512
+  In Collection: CCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.08
+      mIoU(ms+flip): 43.13
+  Config: configs/ccnet/ccnet_r50-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - CCNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_160k_ade20k/ccnet_r50-d8_512x512_160k_ade20k_20200616_084435-7c97193b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_160k_ade20k/ccnet_r50-d8_512x512_160k_ade20k_20200616_084435.log.json
+  Paper:
+    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1811.11721
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: ccnet_r101-d8_4xb4-160k_ade20k-512x512
+  In Collection: CCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 43.71
+      mIoU(ms+flip): 45.04
+  Config: configs/ccnet/ccnet_r101-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - CCNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_160k_ade20k/ccnet_r101-d8_512x512_160k_ade20k_20200616_000644-e849e007.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_160k_ade20k/ccnet_r101-d8_512x512_160k_ade20k_20200616_000644.log.json
+  Paper:
+    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1811.11721
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: ccnet_r50-d8_4xb4-20k_voc12aug-512x512
+  In Collection: CCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 76.17
+      mIoU(ms+flip): 77.51
+  Config: configs/ccnet/ccnet_r50-d8_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - CCNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_20k_voc12aug/ccnet_r50-d8_512x512_20k_voc12aug_20200617_193212-fad81784.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_20k_voc12aug/ccnet_r50-d8_512x512_20k_voc12aug_20200617_193212.log.json
+  Paper:
+    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1811.11721
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: ccnet_r101-d8_4xb4-20k_voc12aug-512x512
+  In Collection: CCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 77.27
+      mIoU(ms+flip): 79.02
+  Config: configs/ccnet/ccnet_r101-d8_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - CCNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_20k_voc12aug/ccnet_r101-d8_512x512_20k_voc12aug_20200617_193212-0007b61d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_20k_voc12aug/ccnet_r101-d8_512x512_20k_voc12aug_20200617_193212.log.json
+  Paper:
+    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1811.11721
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: ccnet_r50-d8_4xb4-40k_voc12aug-512x512
+  In Collection: CCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 75.96
+      mIoU(ms+flip): 77.04
+  Config: configs/ccnet/ccnet_r50-d8_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - CCNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_40k_voc12aug/ccnet_r50-d8_512x512_40k_voc12aug_20200613_232127-c2a15f02.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_40k_voc12aug/ccnet_r50-d8_512x512_40k_voc12aug_20200613_232127.log.json
+  Paper:
+    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1811.11721
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
+- Name: ccnet_r101-d8_4xb4-40k_voc12aug-512x512
+  In Collection: CCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 77.87
+      mIoU(ms+flip): 78.9
+  Config: configs/ccnet/ccnet_r101-d8_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - CCNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_40k_voc12aug/ccnet_r101-d8_512x512_40k_voc12aug_20200613_232127-c30da577.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_40k_voc12aug/ccnet_r101-d8_512x512_40k_voc12aug_20200613_232127.log.json
+  Paper:
+    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1811.11721
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/cgnet/README.md b/mmsegmentation/configs/cgnet/README.md
new file mode 100644
index 0000000..96c9fcf
--- /dev/null
+++ b/mmsegmentation/configs/cgnet/README.md
@@ -0,0 +1,46 @@
+# CGNet
+
+> [CGNet: A Light-weight Context Guided Network for Semantic Segmentation](https://arxiv.org/abs/1811.08201)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/wutianyiRosun/CGNet">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/cgnet.py#L187">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+The demand of applying semantic segmentation model on mobile devices has been increasing rapidly. Current state-of-the-art networks have enormous amount of parameters hence unsuitable for mobile devices, while other small memory footprint models follow the spirit of classification network and ignore the inherent characteristic of semantic segmentation. To tackle this problem, we propose a novel Context Guided Network (CGNet), which is a light-weight and efficient network for semantic segmentation. We first propose the Context Guided (CG) block, which learns the joint feature of both local feature and surrounding context, and further improves the joint feature with the global context. Based on the CG block, we develop CGNet which captures contextual information in all stages of the network and is specially tailored for increasing segmentation accuracy. CGNet is also elaborately designed to reduce the number of parameters and save memory footprint. Under an equivalent number of parameters, the proposed CGNet significantly outperforms existing segmentation networks. Extensive experiments on Cityscapes and CamVid datasets verify the effectiveness of the proposed approach. Specifically, without any post-processing and multi-scale testing, the proposed CGNet achieves 64.8% mean IoU on Cityscapes with less than 0.5 M parameters. The source code for the complete system can be found at [this https URL](https://github.com/wutianyiRosun/CGNet).
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142900351-89559574-79cc-4f57-8f69-5d88765ec38d.png" width="80%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                   | download                                                                                                                                                                                                                                                                                                           |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| CGNet  | M3N21    | 680x680   |   60000 | 7.5      | 30.51          | V100   | 65.63 |         68.04 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/cgnet/cgnet_fcn_4xb4-60k_cityscapes-680x680.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/cgnet/cgnet_680x680_60k_cityscapes/cgnet_680x680_60k_cityscapes_20201101_110253-4c0b2f2d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/cgnet/cgnet_680x680_60k_cityscapes/cgnet_680x680_60k_cityscapes-20201101_110253.log.json)     |
+| CGNet  | M3N21    | 512x1024  |   60000 | 8.3      | 31.14          | V100   | 68.27 |         70.33 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/cgnet/cgnet_fcn_4xb8-60k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/cgnet/cgnet_512x1024_60k_cityscapes/cgnet_512x1024_60k_cityscapes_20201101_110254-124ea03b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/cgnet/cgnet_512x1024_60k_cityscapes/cgnet_512x1024_60k_cityscapes-20201101_110254.log.json) |
+
+## Citation
+
+```bibtext
+@article{wu2020cgnet,
+  title={Cgnet: A light-weight context guided network for semantic segmentation},
+  author={Wu, Tianyi and Tang, Sheng and Zhang, Rui and Cao, Juan and Zhang, Yongdong},
+  journal={IEEE Transactions on Image Processing},
+  volume={30},
+  pages={1169--1179},
+  year={2020},
+  publisher={IEEE}
+}
+```
diff --git a/mmsegmentation/configs/cgnet/cgnet_fcn_4xb4-60k_cityscapes-680x680.py b/mmsegmentation/configs/cgnet/cgnet_fcn_4xb4-60k_cityscapes-680x680.py
new file mode 100644
index 0000000..6a2c0ed
--- /dev/null
+++ b/mmsegmentation/configs/cgnet/cgnet_fcn_4xb4-60k_cityscapes-680x680.py
@@ -0,0 +1,59 @@
+_base_ = [
+    '../_base_/models/cgnet.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py'
+]
+
+# optimizer
+optimizer = dict(type='Adam', lr=0.001, eps=1e-08, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        by_epoch=False,
+        begin=0,
+        end=60000)
+]
+# runtime settings
+total_iters = 60000
+train_cfg = dict(
+    type='IterBasedTrainLoop', max_iters=total_iters, val_interval=4000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=4000),
+    sampler_seed=dict(type='DistSamplerSeedHook'))
+
+crop_size = (680, 680)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=(2048, 1024),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=8, num_workers=4, dataset=dict(pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1, num_workers=4, dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/cgnet/cgnet_fcn_4xb8-60k_cityscapes-512x1024.py b/mmsegmentation/configs/cgnet/cgnet_fcn_4xb8-60k_cityscapes-512x1024.py
new file mode 100644
index 0000000..8be29de
--- /dev/null
+++ b/mmsegmentation/configs/cgnet/cgnet_fcn_4xb8-60k_cityscapes-512x1024.py
@@ -0,0 +1,38 @@
+_base_ = [
+    '../_base_/models/cgnet.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py'
+]
+
+# optimizer
+optimizer = dict(type='Adam', lr=0.001, eps=1e-08, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        by_epoch=False,
+        begin=0,
+        end=60000)
+]
+# runtime settings
+total_iters = 60000
+train_cfg = dict(
+    type='IterBasedTrainLoop', max_iters=total_iters, val_interval=4000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=4000),
+    sampler_seed=dict(type='DistSamplerSeedHook'))
+
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
+
+train_dataloader = dict(batch_size=8)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/cgnet/metafile.yaml b/mmsegmentation/configs/cgnet/metafile.yaml
new file mode 100644
index 0000000..063fc8b
--- /dev/null
+++ b/mmsegmentation/configs/cgnet/metafile.yaml
@@ -0,0 +1,61 @@
+Collections:
+- Name: CGNet
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+  Paper:
+    Title: 'CGNet: A Light-weight Context Guided Network for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1811.08201
+  README: configs/cgnet/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: cgnet_fcn_4xb4-60k_cityscapes-680x680
+  In Collection: CGNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 65.63
+      mIoU(ms+flip): 68.04
+  Config: configs/cgnet/cgnet_fcn_4xb4-60k_cityscapes-680x680.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 16
+    Architecture:
+    - M3N21
+    - CGNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 7.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/cgnet/cgnet_680x680_60k_cityscapes/cgnet_680x680_60k_cityscapes_20201101_110253-4c0b2f2d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/cgnet/cgnet_680x680_60k_cityscapes/cgnet_680x680_60k_cityscapes-20201101_110253.log.json
+  Paper:
+    Title: 'CGNet: A Light-weight Context Guided Network for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1811.08201
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/cgnet.py#L187
+  Framework: PyTorch
+- Name: cgnet_fcn_4xb8-60k_cityscapes-512x1024
+  In Collection: CGNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 68.27
+      mIoU(ms+flip): 70.33
+  Config: configs/cgnet/cgnet_fcn_4xb8-60k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 32
+    Architecture:
+    - M3N21
+    - CGNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.3
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/cgnet/cgnet_512x1024_60k_cityscapes/cgnet_512x1024_60k_cityscapes_20201101_110254-124ea03b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/cgnet/cgnet_512x1024_60k_cityscapes/cgnet_512x1024_60k_cityscapes-20201101_110254.log.json
+  Paper:
+    Title: 'CGNet: A Light-weight Context Guided Network for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1811.08201
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/cgnet.py#L187
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/convnext/README.md b/mmsegmentation/configs/convnext/README.md
new file mode 100644
index 0000000..d78fe6e
--- /dev/null
+++ b/mmsegmentation/configs/convnext/README.md
@@ -0,0 +1,74 @@
+# ConvNeXt
+
+> [A ConvNet for the 2020s](https://arxiv.org/abs/2201.03545)
+
+## Introduction
+
+<!-- [BACKBONE] -->
+
+<a href="https://github.com/facebookresearch/ConvNeXt">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmclassification/blob/v0.20.1/mmcls/models/backbones/convnext.py#L133">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+The "Roaring 20s" of visual recognition began with the introduction of Vision Transformers (ViTs), which quickly superseded ConvNets as the state-of-the-art image classification model. A vanilla ViT, on the other hand, faces difficulties when applied to general computer vision tasks such as object detection and semantic segmentation. It is the hierarchical Transformers (e.g., Swin Transformers) that reintroduced several ConvNet priors, making Transformers practically viable as a generic vision backbone and demonstrating remarkable performance on a wide variety of vision tasks. However, the effectiveness of such hybrid approaches is still largely credited to the intrinsic superiority of Transformers, rather than the inherent inductive biases of convolutions. In this work, we reexamine the design spaces and test the limits of what a pure ConvNet can achieve. We gradually "modernize" a standard ResNet toward the design of a vision Transformer, and discover several key components that contribute to the performance difference along the way. The outcome of this exploration is a family of pure ConvNet models dubbed ConvNeXt. Constructed entirely from standard ConvNet modules, ConvNeXts compete favorably with Transformers in terms of accuracy and scalability, achieving 87.8% ImageNet top-1 accuracy and outperforming Swin Transformers on COCO detection and ADE20K segmentation, while maintaining the simplicity and efficiency of standard ConvNets.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/8370623/148624004-e9581042-ea4d-4e10-b3bd-42c92b02053b.png" width="90%"/>
+</div>
+
+### Usage
+
+- ConvNeXt backbone needs to install [MMClassification](https://github.com/open-mmlab/mmclassification) first, which has abundant backbones for downstream tasks.
+
+```shell
+pip install mmpretrain>=1.0.0rc7
+```
+
+### Pre-trained Models
+
+The pre-trained models on ImageNet-1k or ImageNet-21k are used to fine-tune on the downstream tasks.
+
+|     Model     | Training Data | Params(M) | Flops(G) |                                                                     Download                                                                     |
+| :-----------: | :-----------: | :-------: | :------: | :----------------------------------------------------------------------------------------------------------------------------------------------: |
+| ConvNeXt-T\*  |  ImageNet-1k  |   28.59   |   4.46   | [model](https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-tiny_3rdparty_32xb128-noema_in1k_20220301-795e9634.pth)  |
+| ConvNeXt-S\*  |  ImageNet-1k  |   50.22   |   8.69   | [model](https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-small_3rdparty_32xb128-noema_in1k_20220301-303e75e3.pth) |
+| ConvNeXt-B\*  |  ImageNet-1k  |   88.59   |  15.36   | [model](https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-base_3rdparty_32xb128-noema_in1k_20220301-2a0ee547.pth)  |
+| ConvNeXt-B\*  | ImageNet-21k  |   88.59   |  15.36   |        [model](https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-base_3rdparty_in21k_20220301-262fd037.pth)        |
+| ConvNeXt-L\*  | ImageNet-21k  |  197.77   |  34.37   |       [model](https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-large_3rdparty_in21k_20220301-e6e0ea0a.pth)        |
+| ConvNeXt-XL\* | ImageNet-21k  |  350.20   |  60.93   |       [model](https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-xlarge_3rdparty_in21k_20220301-08aa5ddc.pth)       |
+
+*Models with* are converted from the [official repo](https://github.com/facebookresearch/ConvNeXt/tree/main/semantic_segmentation#results-and-fine-tuned-models).\*
+
+## Results and models
+
+### ADE20K
+
+| Method  | Backbone    | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                                    | download                                                                                                                                                                                                                                                                                                                                                                                             |
+| ------- | ----------- | --------- | ------- | -------- | -------------- | ------ | ----- | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UPerNet | ConvNeXt-T  | 512x512   | 160000  | 4.23     | 19.90          | V100   | 46.11 | 46.62         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/convnext/convnext-tiny_upernet_8xb2-amp-160k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_tiny_fp16_512x512_160k_ade20k/upernet_convnext_tiny_fp16_512x512_160k_ade20k_20220227_124553-cad485de.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_tiny_fp16_512x512_160k_ade20k/upernet_convnext_tiny_fp16_512x512_160k_ade20k_20220227_124553.log.json)         |
+| UPerNet | ConvNeXt-S  | 512x512   | 160000  | 5.16     | 15.18          | V100   | 48.56 | 49.02         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/convnext/convnext-small_upernet_8xb2-amp-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_small_fp16_512x512_160k_ade20k/upernet_convnext_small_fp16_512x512_160k_ade20k_20220227_131208-1b1e394f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_small_fp16_512x512_160k_ade20k/upernet_convnext_small_fp16_512x512_160k_ade20k_20220227_131208.log.json)     |
+| UPerNet | ConvNeXt-B  | 512x512   | 160000  | 6.33     | 14.41          | V100   | 48.71 | 49.54         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_base_fp16_512x512_160k_ade20k/upernet_convnext_base_fp16_512x512_160k_ade20k_20220227_181227-02a24fc6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_base_fp16_512x512_160k_ade20k/upernet_convnext_base_fp16_512x512_160k_ade20k_20220227_181227.log.json)         |
+| UPerNet | ConvNeXt-B  | 640x640   | 160000  | 8.53     | 10.88          | V100   | 52.13 | 52.66         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-640x640.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_base_fp16_640x640_160k_ade20k/upernet_convnext_base_fp16_640x640_160k_ade20k_20220227_182859-9280e39b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_base_fp16_640x640_160k_ade20k/upernet_convnext_base_fp16_640x640_160k_ade20k_20220227_182859.log.json)         |
+| UPerNet | ConvNeXt-L  | 640x640   | 160000  | 12.08    | 7.69           | V100   | 53.16 | 53.38         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/convnext/convnext-large_upernet_8xb2-amp-160k_ade20k-640x640.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_large_fp16_640x640_160k_ade20k/upernet_convnext_large_fp16_640x640_160k_ade20k_20220226_040532-e57aa54d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_large_fp16_640x640_160k_ade20k/upernet_convnext_large_fp16_640x640_160k_ade20k_20220226_040532.log.json)     |
+| UPerNet | ConvNeXt-XL | 640x640   | 160000  | 26.16\*  | 6.33           | V100   | 53.58 | 54.11         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/convnext/convnext-xlarge_upernet_8xb2-amp-160k_ade20k-640x640.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_xlarge_fp16_640x640_160k_ade20k/upernet_convnext_xlarge_fp16_640x640_160k_ade20k_20220226_080344-95fc38c2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_xlarge_fp16_640x640_160k_ade20k/upernet_convnext_xlarge_fp16_640x640_160k_ade20k_20220226_080344.log.json) |
+
+Note:
+
+- `Mem (GB)` with * is collected when `cudnn_benchmark=True`, and hardware is V100.
+
+## Citation
+
+```bibtex
+@article{liu2022convnet,
+  title={A ConvNet for the 2020s},
+  author={Liu, Zhuang and Mao, Hanzi and Wu, Chao-Yuan and Feichtenhofer, Christoph and Darrell, Trevor and Xie, Saining},
+  journal={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
+  year={2022}
+}
+```
diff --git a/mmsegmentation/configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-512x512.py b/mmsegmentation/configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-512x512.py
new file mode 100644
index 0000000..09c2aa6
--- /dev/null
+++ b/mmsegmentation/configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-512x512.py
@@ -0,0 +1,43 @@
+_base_ = [
+    '../_base_/models/upernet_convnext.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(in_channels=[128, 256, 512, 1024], num_classes=150),
+    auxiliary_head=dict(in_channels=512, num_classes=150),
+    test_cfg=dict(mode='slide', crop_size=crop_size, stride=(341, 341)),
+)
+
+optim_wrapper = dict(
+    _delete_=True,
+    type='AmpOptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.05),
+    paramwise_cfg={
+        'decay_rate': 0.9,
+        'decay_type': 'stage_wise',
+        'num_layers': 12
+    },
+    constructor='LearningRateDecayOptimizerConstructor',
+    loss_scale='dynamic')
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        power=1.0,
+        begin=1500,
+        end=160000,
+        eta_min=0.0,
+        by_epoch=False,
+    )
+]
+
+# By default, models are trained on 8 GPUs with 2 images per GPU
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-640x640.py b/mmsegmentation/configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-640x640.py
new file mode 100644
index 0000000..06a8643
--- /dev/null
+++ b/mmsegmentation/configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-640x640.py
@@ -0,0 +1,58 @@
+_base_ = [
+    '../_base_/models/upernet_convnext.py',
+    '../_base_/datasets/ade20k_640x640.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (640, 640)
+data_preprocessor = dict(size=crop_size)
+checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-base_3rdparty_in21k_20220301-262fd037.pth'  # noqa
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='mmpretrain.ConvNeXt',
+        arch='base',
+        out_indices=[0, 1, 2, 3],
+        drop_path_rate=0.4,
+        layer_scale_init_value=1.0,
+        gap_before_final_norm=False,
+        init_cfg=dict(
+            type='Pretrained', checkpoint=checkpoint_file,
+            prefix='backbone.')),
+    decode_head=dict(
+        in_channels=[128, 256, 512, 1024],
+        num_classes=150,
+    ),
+    auxiliary_head=dict(in_channels=512, num_classes=150),
+    test_cfg=dict(mode='slide', crop_size=crop_size, stride=(426, 426)),
+)
+
+optim_wrapper = dict(
+    _delete_=True,
+    type='AmpOptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.05),
+    paramwise_cfg={
+        'decay_rate': 0.9,
+        'decay_type': 'stage_wise',
+        'num_layers': 12
+    },
+    constructor='LearningRateDecayOptimizerConstructor',
+    loss_scale='dynamic')
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        power=1.0,
+        begin=1500,
+        end=160000,
+        eta_min=0.0,
+        by_epoch=False,
+    )
+]
+
+# By default, models are trained on 8 GPUs with 2 images per GPU
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/convnext/convnext-large_upernet_8xb2-amp-160k_ade20k-640x640.py b/mmsegmentation/configs/convnext/convnext-large_upernet_8xb2-amp-160k_ade20k-640x640.py
new file mode 100644
index 0000000..2956e86
--- /dev/null
+++ b/mmsegmentation/configs/convnext/convnext-large_upernet_8xb2-amp-160k_ade20k-640x640.py
@@ -0,0 +1,58 @@
+_base_ = [
+    '../_base_/models/upernet_convnext.py',
+    '../_base_/datasets/ade20k_640x640.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (640, 640)
+data_preprocessor = dict(size=crop_size)
+checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-large_3rdparty_in21k_20220301-e6e0ea0a.pth'  # noqa
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='mmpretrain.ConvNeXt',
+        arch='large',
+        out_indices=[0, 1, 2, 3],
+        drop_path_rate=0.4,
+        layer_scale_init_value=1.0,
+        gap_before_final_norm=False,
+        init_cfg=dict(
+            type='Pretrained', checkpoint=checkpoint_file,
+            prefix='backbone.')),
+    decode_head=dict(
+        in_channels=[192, 384, 768, 1536],
+        num_classes=150,
+    ),
+    auxiliary_head=dict(in_channels=768, num_classes=150),
+    test_cfg=dict(mode='slide', crop_size=crop_size, stride=(426, 426)),
+)
+
+optim_wrapper = dict(
+    _delete_=True,
+    type='AmpOptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.05),
+    paramwise_cfg={
+        'decay_rate': 0.9,
+        'decay_type': 'stage_wise',
+        'num_layers': 12
+    },
+    constructor='LearningRateDecayOptimizerConstructor',
+    loss_scale='dynamic')
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        power=1.0,
+        begin=1500,
+        end=160000,
+        eta_min=0.0,
+        by_epoch=False,
+    )
+]
+
+# By default, models are trained on 8 GPUs with 2 images per GPU
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/convnext/convnext-small_upernet_8xb2-amp-160k_ade20k-512x512.py b/mmsegmentation/configs/convnext/convnext-small_upernet_8xb2-amp-160k_ade20k-512x512.py
new file mode 100644
index 0000000..dbe45f1
--- /dev/null
+++ b/mmsegmentation/configs/convnext/convnext-small_upernet_8xb2-amp-160k_ade20k-512x512.py
@@ -0,0 +1,57 @@
+_base_ = [
+    '../_base_/models/upernet_convnext.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-small_3rdparty_32xb128-noema_in1k_20220301-303e75e3.pth'  # noqa
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='mmpretrain.ConvNeXt',
+        arch='small',
+        out_indices=[0, 1, 2, 3],
+        drop_path_rate=0.3,
+        layer_scale_init_value=1.0,
+        gap_before_final_norm=False,
+        init_cfg=dict(
+            type='Pretrained', checkpoint=checkpoint_file,
+            prefix='backbone.')),
+    decode_head=dict(
+        in_channels=[96, 192, 384, 768],
+        num_classes=150,
+    ),
+    auxiliary_head=dict(in_channels=384, num_classes=150),
+    test_cfg=dict(mode='slide', crop_size=crop_size, stride=(341, 341)),
+)
+
+optim_wrapper = dict(
+    _delete_=True,
+    type='AmpOptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.05),
+    paramwise_cfg={
+        'decay_rate': 0.9,
+        'decay_type': 'stage_wise',
+        'num_layers': 12
+    },
+    constructor='LearningRateDecayOptimizerConstructor',
+    loss_scale='dynamic')
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        power=1.0,
+        begin=1500,
+        end=160000,
+        eta_min=0.0,
+        by_epoch=False,
+    )
+]
+
+# By default, models are trained on 8 GPUs with 2 images per GPU
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/convnext/convnext-tiny_upernet_8xb2-amp-160k_ade20k-512x512.py b/mmsegmentation/configs/convnext/convnext-tiny_upernet_8xb2-amp-160k_ade20k-512x512.py
new file mode 100644
index 0000000..d2e545a
--- /dev/null
+++ b/mmsegmentation/configs/convnext/convnext-tiny_upernet_8xb2-amp-160k_ade20k-512x512.py
@@ -0,0 +1,57 @@
+_base_ = [
+    '../_base_/models/upernet_convnext.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-tiny_3rdparty_32xb128-noema_in1k_20220301-795e9634.pth'  # noqa
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='mmpretrain.ConvNeXt',
+        arch='tiny',
+        out_indices=[0, 1, 2, 3],
+        drop_path_rate=0.4,
+        layer_scale_init_value=1.0,
+        gap_before_final_norm=False,
+        init_cfg=dict(
+            type='Pretrained', checkpoint=checkpoint_file,
+            prefix='backbone.')),
+    decode_head=dict(
+        in_channels=[96, 192, 384, 768],
+        num_classes=150,
+    ),
+    auxiliary_head=dict(in_channels=384, num_classes=150),
+    test_cfg=dict(mode='slide', crop_size=crop_size, stride=(341, 341)),
+)
+
+optim_wrapper = dict(
+    _delete_=True,
+    type='AmpOptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.05),
+    paramwise_cfg={
+        'decay_rate': 0.9,
+        'decay_type': 'stage_wise',
+        'num_layers': 6
+    },
+    constructor='LearningRateDecayOptimizerConstructor',
+    loss_scale='dynamic')
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        power=1.0,
+        begin=1500,
+        end=160000,
+        eta_min=0.0,
+        by_epoch=False,
+    )
+]
+
+# By default, models are trained on 8 GPUs with 2 images per GPU
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/convnext/convnext-xlarge_upernet_8xb2-amp-160k_ade20k-640x640.py b/mmsegmentation/configs/convnext/convnext-xlarge_upernet_8xb2-amp-160k_ade20k-640x640.py
new file mode 100644
index 0000000..dfad734
--- /dev/null
+++ b/mmsegmentation/configs/convnext/convnext-xlarge_upernet_8xb2-amp-160k_ade20k-640x640.py
@@ -0,0 +1,58 @@
+_base_ = [
+    '../_base_/models/upernet_convnext.py',
+    '../_base_/datasets/ade20k_640x640.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (640, 640)
+data_preprocessor = dict(size=crop_size)
+checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-xlarge_3rdparty_in21k_20220301-08aa5ddc.pth'  # noqa
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='mmpretrain.ConvNeXt',
+        arch='xlarge',
+        out_indices=[0, 1, 2, 3],
+        drop_path_rate=0.4,
+        layer_scale_init_value=1.0,
+        gap_before_final_norm=False,
+        init_cfg=dict(
+            type='Pretrained', checkpoint=checkpoint_file,
+            prefix='backbone.')),
+    decode_head=dict(
+        in_channels=[256, 512, 1024, 2048],
+        num_classes=150,
+    ),
+    auxiliary_head=dict(in_channels=1024, num_classes=150),
+    test_cfg=dict(mode='slide', crop_size=crop_size, stride=(426, 426)),
+)
+
+optim_wrapper = dict(
+    _delete_=True,
+    type='AmpOptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.00008, betas=(0.9, 0.999), weight_decay=0.05),
+    paramwise_cfg={
+        'decay_rate': 0.9,
+        'decay_type': 'stage_wise',
+        'num_layers': 12
+    },
+    constructor='LearningRateDecayOptimizerConstructor',
+    loss_scale='dynamic')
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        power=1.0,
+        begin=1500,
+        end=160000,
+        eta_min=0.0,
+        by_epoch=False,
+    )
+]
+
+# By default, models are trained on 8 GPUs with 2 images per GPU
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/convnext/metafile.yaml b/mmsegmentation/configs/convnext/metafile.yaml
new file mode 100644
index 0000000..8340a37
--- /dev/null
+++ b/mmsegmentation/configs/convnext/metafile.yaml
@@ -0,0 +1,145 @@
+Models:
+- Name: convnext-tiny_upernet_8xb2-amp-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 46.11
+      mIoU(ms+flip): 46.62
+  Config: configs/convnext/convnext-tiny_upernet_8xb2-amp-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - ConvNeXt-T
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 4.23
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_tiny_fp16_512x512_160k_ade20k/upernet_convnext_tiny_fp16_512x512_160k_ade20k_20220227_124553-cad485de.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_tiny_fp16_512x512_160k_ade20k/upernet_convnext_tiny_fp16_512x512_160k_ade20k_20220227_124553.log.json
+  Paper:
+    Title: A ConvNet for the 2020s
+    URL: https://arxiv.org/abs/2201.03545
+  Code: https://github.com/open-mmlab/mmclassification/blob/v0.20.1/mmcls/models/backbones/convnext.py#L133
+  Framework: PyTorch
+- Name: convnext-small_upernet_8xb2-amp-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 48.56
+      mIoU(ms+flip): 49.02
+  Config: configs/convnext/convnext-small_upernet_8xb2-amp-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - ConvNeXt-S
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 5.16
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_small_fp16_512x512_160k_ade20k/upernet_convnext_small_fp16_512x512_160k_ade20k_20220227_131208-1b1e394f.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_small_fp16_512x512_160k_ade20k/upernet_convnext_small_fp16_512x512_160k_ade20k_20220227_131208.log.json
+  Paper:
+    Title: A ConvNet for the 2020s
+    URL: https://arxiv.org/abs/2201.03545
+  Code: https://github.com/open-mmlab/mmclassification/blob/v0.20.1/mmcls/models/backbones/convnext.py#L133
+  Framework: PyTorch
+- Name: convnext-base_upernet_8xb2-amp-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 48.71
+      mIoU(ms+flip): 49.54
+  Config: configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - ConvNeXt-B
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 6.33
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_base_fp16_512x512_160k_ade20k/upernet_convnext_base_fp16_512x512_160k_ade20k_20220227_181227-02a24fc6.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_base_fp16_512x512_160k_ade20k/upernet_convnext_base_fp16_512x512_160k_ade20k_20220227_181227.log.json
+  Paper:
+    Title: A ConvNet for the 2020s
+    URL: https://arxiv.org/abs/2201.03545
+  Code: https://github.com/open-mmlab/mmclassification/blob/v0.20.1/mmcls/models/backbones/convnext.py#L133
+  Framework: PyTorch
+- Name: convnext-base_upernet_8xb2-amp-160k_ade20k-640x640
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 52.13
+      mIoU(ms+flip): 52.66
+  Config: configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-640x640.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - ConvNeXt-B
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 8.53
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_base_fp16_640x640_160k_ade20k/upernet_convnext_base_fp16_640x640_160k_ade20k_20220227_182859-9280e39b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_base_fp16_640x640_160k_ade20k/upernet_convnext_base_fp16_640x640_160k_ade20k_20220227_182859.log.json
+  Paper:
+    Title: A ConvNet for the 2020s
+    URL: https://arxiv.org/abs/2201.03545
+  Code: https://github.com/open-mmlab/mmclassification/blob/v0.20.1/mmcls/models/backbones/convnext.py#L133
+  Framework: PyTorch
+- Name: convnext-large_upernet_8xb2-amp-160k_ade20k-640x640
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 53.16
+      mIoU(ms+flip): 53.38
+  Config: configs/convnext/convnext-large_upernet_8xb2-amp-160k_ade20k-640x640.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - ConvNeXt-L
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 12.08
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_large_fp16_640x640_160k_ade20k/upernet_convnext_large_fp16_640x640_160k_ade20k_20220226_040532-e57aa54d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_large_fp16_640x640_160k_ade20k/upernet_convnext_large_fp16_640x640_160k_ade20k_20220226_040532.log.json
+  Paper:
+    Title: A ConvNet for the 2020s
+    URL: https://arxiv.org/abs/2201.03545
+  Code: https://github.com/open-mmlab/mmclassification/blob/v0.20.1/mmcls/models/backbones/convnext.py#L133
+  Framework: PyTorch
+- Name: convnext-xlarge_upernet_8xb2-amp-160k_ade20k-640x640
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 53.58
+      mIoU(ms+flip): 54.11
+  Config: configs/convnext/convnext-xlarge_upernet_8xb2-amp-160k_ade20k-640x640.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - ConvNeXt-XL
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 26.16
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_xlarge_fp16_640x640_160k_ade20k/upernet_convnext_xlarge_fp16_640x640_160k_ade20k_20220226_080344-95fc38c2.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_xlarge_fp16_640x640_160k_ade20k/upernet_convnext_xlarge_fp16_640x640_160k_ade20k_20220226_080344.log.json
+  Paper:
+    Title: A ConvNet for the 2020s
+    URL: https://arxiv.org/abs/2201.03545
+  Code: https://github.com/open-mmlab/mmclassification/blob/v0.20.1/mmcls/models/backbones/convnext.py#L133
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/danet/README.md b/mmsegmentation/configs/danet/README.md
new file mode 100644
index 0000000..90194f3
--- /dev/null
+++ b/mmsegmentation/configs/danet/README.md
@@ -0,0 +1,67 @@
+# DANet
+
+> [Dual Attention Network for Scene Segmentation](https://arxiv.org/abs/1809.02983)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/junfu1115/DANet/">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+In this paper, we address the scene segmentation task by capturing rich contextual dependencies based on the selfattention mechanism. Unlike previous works that capture contexts by multi-scale features fusion, we propose a Dual Attention Networks (DANet) to adaptively integrate local features with their global dependencies. Specifically, we append two types of attention modules on top of traditional dilated FCN, which model the semantic interdependencies in spatial and channel dimensions respectively. The position attention module selectively aggregates the features at each position by a weighted sum of the features at all positions. Similar features would be related to each other regardless of their distances. Meanwhile, the channel attention module selectively emphasizes interdependent channel maps by integrating associated features among all channel maps. We sum the outputs of the two attention modules to further improve feature representation which contributes to more precise segmentation results. We achieve new state-of-the-art segmentation performance on three challenging scene segmentation datasets, i.e., Cityscapes, PASCAL Context and COCO Stuff dataset. In particular, a Mean IoU score of 81.5% on Cityscapes test set is achieved without using coarse data. We make the code and trained model publicly available at [this https URL](https://github.com/junfu1115/DANet).
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142900467-f832fdb9-3b7d-47d3-8e80-e6ee9303bdfb.png" width="70%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                       | download                                                                                                                                                                                                                                                                                                                                           |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------- | ---------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DANet  | R-50-D8  | 512x1024  |   40000 | 7.4      | 2.66           | V100   | 78.74 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r50-d8_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x1024_40k_cityscapes/danet_r50-d8_512x1024_40k_cityscapes_20200605_191324-c0dbfa5f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x1024_40k_cityscapes/danet_r50-d8_512x1024_40k_cityscapes_20200605_191324.log.json)     |
+| DANet  | R-101-D8 | 512x1024  |   40000 | 10.9     | 1.99           | V100   | 80.52 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r101-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x1024_40k_cityscapes/danet_r101-d8_512x1024_40k_cityscapes_20200605_200831-c57a7157.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x1024_40k_cityscapes/danet_r101-d8_512x1024_40k_cityscapes_20200605_200831.log.json) |
+| DANet  | R-50-D8  | 769x769   |   40000 | 8.8      | 1.56           | V100   | 78.88 | 80.62         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r50-d8_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_769x769_40k_cityscapes/danet_r50-d8_769x769_40k_cityscapes_20200530_025703-76681c60.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_769x769_40k_cityscapes/danet_r50-d8_769x769_40k_cityscapes_20200530_025703.log.json)         |
+| DANet  | R-101-D8 | 769x769   |   40000 | 12.8     | 1.07           | V100   | 79.88 | 81.47         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r101-d8_4xb2-40k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_769x769_40k_cityscapes/danet_r101-d8_769x769_40k_cityscapes_20200530_025717-dcb7fd4e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_769x769_40k_cityscapes/danet_r101-d8_769x769_40k_cityscapes_20200530_025717.log.json)     |
+| DANet  | R-50-D8  | 512x1024  |   80000 | -        | -              | V100   | 79.34 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r50-d8_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x1024_80k_cityscapes/danet_r50-d8_512x1024_80k_cityscapes_20200607_133029-2bfa2293.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x1024_80k_cityscapes/danet_r50-d8_512x1024_80k_cityscapes_20200607_133029.log.json)     |
+| DANet  | R-101-D8 | 512x1024  |   80000 | -        | -              | V100   | 80.41 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r101-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x1024_80k_cityscapes/danet_r101-d8_512x1024_80k_cityscapes_20200607_132918-955e6350.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x1024_80k_cityscapes/danet_r101-d8_512x1024_80k_cityscapes_20200607_132918.log.json) |
+| DANet  | R-50-D8  | 769x769   |   80000 | -        | -              | V100   | 79.27 | 80.96         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r50-d8_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_769x769_80k_cityscapes/danet_r50-d8_769x769_80k_cityscapes_20200607_132954-495689b4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_769x769_80k_cityscapes/danet_r50-d8_769x769_80k_cityscapes_20200607_132954.log.json)         |
+| DANet  | R-101-D8 | 769x769   |   80000 | -        | -              | V100   | 80.47 | 82.02         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r101-d8_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_769x769_80k_cityscapes/danet_r101-d8_769x769_80k_cityscapes_20200607_132918-f3a929e7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_769x769_80k_cityscapes/danet_r101-d8_769x769_80k_cityscapes_20200607_132918.log.json)     |
+
+### ADE20K
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                   | download                                                                                                                                                                                                                                                                                                                           |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DANet  | R-50-D8  | 512x512   |   80000 | 11.5     | 21.20          | V100   | 41.66 |         42.90 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_80k_ade20k/danet_r50-d8_512x512_80k_ade20k_20200615_015125-edb18e08.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_80k_ade20k/danet_r50-d8_512x512_80k_ade20k_20200615_015125.log.json)         |
+| DANet  | R-101-D8 | 512x512   |   80000 | 15       | 14.18          | V100   | 43.64 |         45.19 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_80k_ade20k/danet_r101-d8_512x512_80k_ade20k_20200615_015126-d0357c73.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_80k_ade20k/danet_r101-d8_512x512_80k_ade20k_20200615_015126.log.json)     |
+| DANet  | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 42.45 |         43.25 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_160k_ade20k/danet_r50-d8_512x512_160k_ade20k_20200616_082340-9cb35dcd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_160k_ade20k/danet_r50-d8_512x512_160k_ade20k_20200616_082340.log.json)     |
+| DANet  | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 44.17 |         45.02 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_160k_ade20k/danet_r101-d8_512x512_160k_ade20k_20200616_082348-23bf12f9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_160k_ade20k/danet_r101-d8_512x512_160k_ade20k_20200616_082348.log.json) |
+
+### Pascal VOC 2012 + Aug
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                    | download                                                                                                                                                                                                                                                                                                                               |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DANet  | R-50-D8  | 512x512   |   20000 | 6.5      | 20.94          | V100   | 74.45 |         75.69 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r50-d8_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_20k_voc12aug/danet_r50-d8_512x512_20k_voc12aug_20200618_070026-9e9e3ab3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_20k_voc12aug/danet_r50-d8_512x512_20k_voc12aug_20200618_070026.log.json)     |
+| DANet  | R-101-D8 | 512x512   |   20000 | 9.9      | 13.76          | V100   | 76.02 |         77.23 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r101-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_20k_voc12aug/danet_r101-d8_512x512_20k_voc12aug_20200618_070026-d48d23b2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_20k_voc12aug/danet_r101-d8_512x512_20k_voc12aug_20200618_070026.log.json) |
+| DANet  | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 76.37 |         77.29 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r50-d8_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_40k_voc12aug/danet_r50-d8_512x512_40k_voc12aug_20200613_235526-426e3a64.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_40k_voc12aug/danet_r50-d8_512x512_40k_voc12aug_20200613_235526.log.json)     |
+| DANet  | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 76.51 |         77.32 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r101-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_40k_voc12aug/danet_r101-d8_512x512_40k_voc12aug_20200613_223031-788e232a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_40k_voc12aug/danet_r101-d8_512x512_40k_voc12aug_20200613_223031.log.json) |
+
+## Citation
+
+```bibtex
+@article{fu2018dual,
+  title={Dual Attention Network for Scene Segmentation},
+  author={Jun Fu, Jing Liu, Haijie Tian, Yong Li, Yongjun Bao, Zhiwei Fang,and Hanqing Lu},
+  booktitle={The IEEE Conference on Computer Vision and Pattern Recognition (CVPR)},
+  year={2019}
+}
+```
diff --git a/mmsegmentation/configs/danet/danet_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/danet/danet_r101-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..4602f33
--- /dev/null
+++ b/mmsegmentation/configs/danet/danet_r101-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './danet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/danet/danet_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/danet/danet_r101-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..a08c18e
--- /dev/null
+++ b/mmsegmentation/configs/danet/danet_r101-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './danet_r50-d8_4xb2-40k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/danet/danet_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/danet/danet_r101-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..98b1c64
--- /dev/null
+++ b/mmsegmentation/configs/danet/danet_r101-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './danet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/danet/danet_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/danet/danet_r101-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..9affe30
--- /dev/null
+++ b/mmsegmentation/configs/danet/danet_r101-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './danet_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/danet/danet_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/danet/danet_r101-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..0079ad6
--- /dev/null
+++ b/mmsegmentation/configs/danet/danet_r101-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './danet_r50-d8_4xb4-160k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/danet/danet_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/danet/danet_r101-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..4844451
--- /dev/null
+++ b/mmsegmentation/configs/danet/danet_r101-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './danet_r50-d8_4xb4-20k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/danet/danet_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/danet/danet_r101-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..2f2df7a
--- /dev/null
+++ b/mmsegmentation/configs/danet/danet_r101-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './danet_r50-d8_4xb4-40k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/danet/danet_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/danet/danet_r101-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..dd75bc1
--- /dev/null
+++ b/mmsegmentation/configs/danet/danet_r101-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './danet_r50-d8_4xb4-80k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/danet/danet_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/danet/danet_r50-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..3bc2a77
--- /dev/null
+++ b/mmsegmentation/configs/danet/danet_r50-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/danet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/danet/danet_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/danet/danet_r50-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..3a01fb9
--- /dev/null
+++ b/mmsegmentation/configs/danet/danet_r50-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/danet_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/danet/danet_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/danet/danet_r50-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..95d5df0
--- /dev/null
+++ b/mmsegmentation/configs/danet/danet_r50-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/danet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/danet/danet_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/danet/danet_r50-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..4255716
--- /dev/null
+++ b/mmsegmentation/configs/danet/danet_r50-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/danet_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/danet/danet_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/danet/danet_r50-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..a8f082d
--- /dev/null
+++ b/mmsegmentation/configs/danet/danet_r50-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/danet_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/danet/danet_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/danet/danet_r50-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..fab574f
--- /dev/null
+++ b/mmsegmentation/configs/danet/danet_r50-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/danet_r50-d8.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_20k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/danet/danet_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/danet/danet_r50-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..148fa39
--- /dev/null
+++ b/mmsegmentation/configs/danet/danet_r50-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/danet_r50-d8.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/danet/danet_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/danet/danet_r50-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..efbd908
--- /dev/null
+++ b/mmsegmentation/configs/danet/danet_r50-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/danet_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/danet/metafile.yaml b/mmsegmentation/configs/danet/metafile.yaml
new file mode 100644
index 0000000..daff925
--- /dev/null
+++ b/mmsegmentation/configs/danet/metafile.yaml
@@ -0,0 +1,387 @@
+Collections:
+- Name: DANet
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+    - ADE20K
+    - Pascal VOC 2012 + Aug
+  Paper:
+    Title: Dual Attention Network for Scene Segmentation
+    URL: https://arxiv.org/abs/1809.02983
+  README: configs/danet/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: danet_r50-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: DANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.74
+  Config: configs/danet/danet_r50-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - DANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 7.4
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x1024_40k_cityscapes/danet_r50-d8_512x1024_40k_cityscapes_20200605_191324-c0dbfa5f.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x1024_40k_cityscapes/danet_r50-d8_512x1024_40k_cityscapes_20200605_191324.log.json
+  Paper:
+    Title: Dual Attention Network for Scene Segmentation
+    URL: https://arxiv.org/abs/1809.02983
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
+  Framework: PyTorch
+- Name: danet_r101-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: DANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 80.52
+  Config: configs/danet/danet_r101-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - DANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x1024_40k_cityscapes/danet_r101-d8_512x1024_40k_cityscapes_20200605_200831-c57a7157.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x1024_40k_cityscapes/danet_r101-d8_512x1024_40k_cityscapes_20200605_200831.log.json
+  Paper:
+    Title: Dual Attention Network for Scene Segmentation
+    URL: https://arxiv.org/abs/1809.02983
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
+  Framework: PyTorch
+- Name: danet_r50-d8_4xb2-40k_cityscapes-769x769
+  In Collection: DANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.88
+      mIoU(ms+flip): 80.62
+  Config: configs/danet/danet_r50-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - DANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_769x769_40k_cityscapes/danet_r50-d8_769x769_40k_cityscapes_20200530_025703-76681c60.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_769x769_40k_cityscapes/danet_r50-d8_769x769_40k_cityscapes_20200530_025703.log.json
+  Paper:
+    Title: Dual Attention Network for Scene Segmentation
+    URL: https://arxiv.org/abs/1809.02983
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
+  Framework: PyTorch
+- Name: danet_r101-d8_4xb2-40k_cityscapes-769x769
+  In Collection: DANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.88
+      mIoU(ms+flip): 81.47
+  Config: configs/danet/danet_r101-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - DANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 12.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_769x769_40k_cityscapes/danet_r101-d8_769x769_40k_cityscapes_20200530_025717-dcb7fd4e.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_769x769_40k_cityscapes/danet_r101-d8_769x769_40k_cityscapes_20200530_025717.log.json
+  Paper:
+    Title: Dual Attention Network for Scene Segmentation
+    URL: https://arxiv.org/abs/1809.02983
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
+  Framework: PyTorch
+- Name: danet_r50-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: DANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.34
+  Config: configs/danet/danet_r50-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - DANet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x1024_80k_cityscapes/danet_r50-d8_512x1024_80k_cityscapes_20200607_133029-2bfa2293.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x1024_80k_cityscapes/danet_r50-d8_512x1024_80k_cityscapes_20200607_133029.log.json
+  Paper:
+    Title: Dual Attention Network for Scene Segmentation
+    URL: https://arxiv.org/abs/1809.02983
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
+  Framework: PyTorch
+- Name: danet_r101-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: DANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 80.41
+  Config: configs/danet/danet_r101-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - DANet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x1024_80k_cityscapes/danet_r101-d8_512x1024_80k_cityscapes_20200607_132918-955e6350.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x1024_80k_cityscapes/danet_r101-d8_512x1024_80k_cityscapes_20200607_132918.log.json
+  Paper:
+    Title: Dual Attention Network for Scene Segmentation
+    URL: https://arxiv.org/abs/1809.02983
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
+  Framework: PyTorch
+- Name: danet_r50-d8_4xb2-80k_cityscapes-769x769
+  In Collection: DANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.27
+      mIoU(ms+flip): 80.96
+  Config: configs/danet/danet_r50-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - DANet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_769x769_80k_cityscapes/danet_r50-d8_769x769_80k_cityscapes_20200607_132954-495689b4.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_769x769_80k_cityscapes/danet_r50-d8_769x769_80k_cityscapes_20200607_132954.log.json
+  Paper:
+    Title: Dual Attention Network for Scene Segmentation
+    URL: https://arxiv.org/abs/1809.02983
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
+  Framework: PyTorch
+- Name: danet_r101-d8_4xb2-80k_cityscapes-769x769
+  In Collection: DANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 80.47
+      mIoU(ms+flip): 82.02
+  Config: configs/danet/danet_r101-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - DANet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_769x769_80k_cityscapes/danet_r101-d8_769x769_80k_cityscapes_20200607_132918-f3a929e7.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_769x769_80k_cityscapes/danet_r101-d8_769x769_80k_cityscapes_20200607_132918.log.json
+  Paper:
+    Title: Dual Attention Network for Scene Segmentation
+    URL: https://arxiv.org/abs/1809.02983
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
+  Framework: PyTorch
+- Name: danet_r50-d8_4xb4-80k_ade20k-512x512
+  In Collection: DANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 41.66
+      mIoU(ms+flip): 42.9
+  Config: configs/danet/danet_r50-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 11.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_80k_ade20k/danet_r50-d8_512x512_80k_ade20k_20200615_015125-edb18e08.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_80k_ade20k/danet_r50-d8_512x512_80k_ade20k_20200615_015125.log.json
+  Paper:
+    Title: Dual Attention Network for Scene Segmentation
+    URL: https://arxiv.org/abs/1809.02983
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
+  Framework: PyTorch
+- Name: danet_r101-d8_4xb4-80k_ade20k-512x512
+  In Collection: DANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 43.64
+      mIoU(ms+flip): 45.19
+  Config: configs/danet/danet_r101-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 15.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_80k_ade20k/danet_r101-d8_512x512_80k_ade20k_20200615_015126-d0357c73.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_80k_ade20k/danet_r101-d8_512x512_80k_ade20k_20200615_015126.log.json
+  Paper:
+    Title: Dual Attention Network for Scene Segmentation
+    URL: https://arxiv.org/abs/1809.02983
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
+  Framework: PyTorch
+- Name: danet_r50-d8_4xb4-160k_ade20k-512x512
+  In Collection: DANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.45
+      mIoU(ms+flip): 43.25
+  Config: configs/danet/danet_r50-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DANet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_160k_ade20k/danet_r50-d8_512x512_160k_ade20k_20200616_082340-9cb35dcd.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_160k_ade20k/danet_r50-d8_512x512_160k_ade20k_20200616_082340.log.json
+  Paper:
+    Title: Dual Attention Network for Scene Segmentation
+    URL: https://arxiv.org/abs/1809.02983
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
+  Framework: PyTorch
+- Name: danet_r101-d8_4xb4-160k_ade20k-512x512
+  In Collection: DANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 44.17
+      mIoU(ms+flip): 45.02
+  Config: configs/danet/danet_r101-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DANet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_160k_ade20k/danet_r101-d8_512x512_160k_ade20k_20200616_082348-23bf12f9.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_160k_ade20k/danet_r101-d8_512x512_160k_ade20k_20200616_082348.log.json
+  Paper:
+    Title: Dual Attention Network for Scene Segmentation
+    URL: https://arxiv.org/abs/1809.02983
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
+  Framework: PyTorch
+- Name: danet_r50-d8_4xb4-20k_voc12aug-512x512
+  In Collection: DANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 74.45
+      mIoU(ms+flip): 75.69
+  Config: configs/danet/danet_r50-d8_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_20k_voc12aug/danet_r50-d8_512x512_20k_voc12aug_20200618_070026-9e9e3ab3.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_20k_voc12aug/danet_r50-d8_512x512_20k_voc12aug_20200618_070026.log.json
+  Paper:
+    Title: Dual Attention Network for Scene Segmentation
+    URL: https://arxiv.org/abs/1809.02983
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
+  Framework: PyTorch
+- Name: danet_r101-d8_4xb4-20k_voc12aug-512x512
+  In Collection: DANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 76.02
+      mIoU(ms+flip): 77.23
+  Config: configs/danet/danet_r101-d8_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_20k_voc12aug/danet_r101-d8_512x512_20k_voc12aug_20200618_070026-d48d23b2.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_20k_voc12aug/danet_r101-d8_512x512_20k_voc12aug_20200618_070026.log.json
+  Paper:
+    Title: Dual Attention Network for Scene Segmentation
+    URL: https://arxiv.org/abs/1809.02983
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
+  Framework: PyTorch
+- Name: danet_r50-d8_4xb4-40k_voc12aug-512x512
+  In Collection: DANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 76.37
+      mIoU(ms+flip): 77.29
+  Config: configs/danet/danet_r50-d8_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DANet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_40k_voc12aug/danet_r50-d8_512x512_40k_voc12aug_20200613_235526-426e3a64.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_40k_voc12aug/danet_r50-d8_512x512_40k_voc12aug_20200613_235526.log.json
+  Paper:
+    Title: Dual Attention Network for Scene Segmentation
+    URL: https://arxiv.org/abs/1809.02983
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
+  Framework: PyTorch
+- Name: danet_r101-d8_4xb4-40k_voc12aug-512x512
+  In Collection: DANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 76.51
+      mIoU(ms+flip): 77.32
+  Config: configs/danet/danet_r101-d8_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DANet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_40k_voc12aug/danet_r101-d8_512x512_40k_voc12aug_20200613_223031-788e232a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_40k_voc12aug/danet_r101-d8_512x512_40k_voc12aug_20200613_223031.log.json
+  Paper:
+    Title: Dual Attention Network for Scene Segmentation
+    URL: https://arxiv.org/abs/1809.02983
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/ddrnet/README.md b/mmsegmentation/configs/ddrnet/README.md
new file mode 100644
index 0000000..ccbfcdf
--- /dev/null
+++ b/mmsegmentation/configs/ddrnet/README.md
@@ -0,0 +1,46 @@
+# DDRNet
+
+> [Deep Dual-resolution Networks for Real-time and Accurate Semantic Segmentation of Road Scenes](http://arxiv.org/abs/2101.06085)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/ydhongHIT/DDRNet">Official Repo</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Semantic segmentation is a key technology for autonomous vehicles to understand the surrounding scenes. The appealing performances of contemporary models usually come at the expense of heavy computations and lengthy inference time, which is intolerable for self-driving. Using light-weight architectures (encoder-decoder or two-pathway) or reasoning on low-resolution images, recent methods realize very fast scene parsing, even running at more than 100 FPS on a single 1080Ti GPU. However, there is still a significant gap in performance between these real-time methods and the models based on dilation backbones. To tackle this problem, we proposed a family of efficient backbones specially designed for real-time semantic segmentation. The proposed deep dual-resolution networks (DDRNets) are composed of two deep branches between which multiple bilateral fusions are performed. Additionally, we design a new contextual information extractor named Deep Aggregation Pyramid Pooling Module (DAPPM) to enlarge effective receptive fields and fuse multi-scale context based on low-resolution feature maps. Our method achieves a new state-of-the-art trade-off between accuracy and speed on both Cityscapes and CamVid dataset. In particular, on a single 2080Ti GPU, DDRNet-23-slim yields 77.4% mIoU at 102 FPS on Cityscapes test set and 74.7% mIoU at 230 FPS on CamVid test set. With widely used test augmentation, our method is superior to most state-of-the-art models and requires much less computation. Codes and trained models are available online.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://raw.githubusercontent.com/ydhongHIT/DDRNet/main/figs/DDRNet_seg.png" width="80%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method | Backbone      | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                                    | download                                                                                                                                                                                                                                                                                                                                                                                                             |
+| ------ | ------------- | --------- | ------- | -------- | -------------- | ------ | ----- | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DDRNet | DDRNet23-slim | 1024x1024 | 120000  | 1.70     | 85.85          | A100   | 77.84 | 80.15         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ddrnet/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ddrnet/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024_20230426_145312-6a5e5174.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ddrnet/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024_20230426_145312.json) |
+| DDRNet | DDRNet23      | 1024x1024 | 120000  | 7.26     | 33.41          | A100   | 79.99 | 81.71         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ddrnet/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024.py)      | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ddrnet/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024_20230425_162633-81601db0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ddrnet/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024_20230425_162633.json)                     |
+
+## Notes
+
+The pretrained weights in config files are converted from [the official repo](https://github.com/ydhongHIT/DDRNet#pretrained-models).
+
+## Citation
+
+```bibtex
+@article{pan2022deep,
+  title={Deep Dual-Resolution Networks for Real-Time and Accurate Semantic Segmentation of Traffic Scenes},
+  author={Pan, Huihui and Hong, Yuanduo and Sun, Weichao and Jia, Yisong},
+  journal={IEEE Transactions on Intelligent Transportation Systems},
+  year={2022},
+  publisher={IEEE}
+}
+```
diff --git a/mmsegmentation/configs/ddrnet/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024.py b/mmsegmentation/configs/ddrnet/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024.py
new file mode 100644
index 0000000..65b0ead
--- /dev/null
+++ b/mmsegmentation/configs/ddrnet/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024.py
@@ -0,0 +1,93 @@
+_base_ = [
+    '../_base_/datasets/cityscapes_1024x1024.py',
+    '../_base_/default_runtime.py',
+]
+
+# The class_weight is borrowed from https://github.com/openseg-group/OCNet.pytorch/issues/14 # noqa
+# Licensed under the MIT License
+class_weight = [
+    0.8373, 0.918, 0.866, 1.0345, 1.0166, 0.9969, 0.9754, 1.0489, 0.8786,
+    1.0023, 0.9539, 0.9843, 1.1116, 0.9037, 1.0865, 1.0955, 1.0865, 1.1529,
+    1.0507
+]
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/ddrnet/pretrain/ddrnet23s-in1kpre_3rdparty-1ccac5b1.pth'  # noqa
+crop_size = (1024, 1024)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    size=crop_size,
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='DDRNet',
+        in_channels=3,
+        channels=32,
+        ppm_channels=128,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint)),
+    decode_head=dict(
+        type='DDRHead',
+        in_channels=32 * 4,
+        channels=64,
+        dropout_ratio=0.,
+        num_classes=19,
+        align_corners=False,
+        norm_cfg=norm_cfg,
+        loss_decode=[
+            dict(
+                type='OhemCrossEntropy',
+                thres=0.9,
+                min_kept=131072,
+                class_weight=class_weight,
+                loss_weight=1.0),
+            dict(
+                type='OhemCrossEntropy',
+                thres=0.9,
+                min_kept=131072,
+                class_weight=class_weight,
+                loss_weight=0.4),
+        ]),
+
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+
+train_dataloader = dict(batch_size=6, num_workers=4)
+
+iters = 120000
+# optimizer
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=0,
+        power=0.9,
+        begin=0,
+        end=iters,
+        by_epoch=False)
+]
+
+# training schedule for 120k
+train_cfg = dict(
+    type='IterBasedTrainLoop', max_iters=iters, val_interval=iters // 10)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(
+        type='CheckpointHook', by_epoch=False, interval=iters // 10),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))
+
+randomness = dict(seed=304)
diff --git a/mmsegmentation/configs/ddrnet/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024.py b/mmsegmentation/configs/ddrnet/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024.py
new file mode 100644
index 0000000..444efe2
--- /dev/null
+++ b/mmsegmentation/configs/ddrnet/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024.py
@@ -0,0 +1,93 @@
+_base_ = [
+    '../_base_/datasets/cityscapes_1024x1024.py',
+    '../_base_/default_runtime.py',
+]
+
+# The class_weight is borrowed from https://github.com/openseg-group/OCNet.pytorch/issues/14 # noqa
+# Licensed under the MIT License
+class_weight = [
+    0.8373, 0.918, 0.866, 1.0345, 1.0166, 0.9969, 0.9754, 1.0489, 0.8786,
+    1.0023, 0.9539, 0.9843, 1.1116, 0.9037, 1.0865, 1.0955, 1.0865, 1.1529,
+    1.0507
+]
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/ddrnet/pretrain/ddrnet23-in1kpre_3rdparty-9ca29f62.pth'  # noqa
+crop_size = (1024, 1024)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    size=crop_size,
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='DDRNet',
+        in_channels=3,
+        channels=64,
+        ppm_channels=128,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint)),
+    decode_head=dict(
+        type='DDRHead',
+        in_channels=64 * 4,
+        channels=128,
+        dropout_ratio=0.,
+        num_classes=19,
+        align_corners=False,
+        norm_cfg=norm_cfg,
+        loss_decode=[
+            dict(
+                type='OhemCrossEntropy',
+                thres=0.9,
+                min_kept=131072,
+                class_weight=class_weight,
+                loss_weight=1.0),
+            dict(
+                type='OhemCrossEntropy',
+                thres=0.9,
+                min_kept=131072,
+                class_weight=class_weight,
+                loss_weight=0.4),
+        ]),
+
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+
+train_dataloader = dict(batch_size=6, num_workers=4)
+
+iters = 120000
+# optimizer
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=0,
+        power=0.9,
+        begin=0,
+        end=iters,
+        by_epoch=False)
+]
+
+# training schedule for 120k
+train_cfg = dict(
+    type='IterBasedTrainLoop', max_iters=iters, val_interval=iters // 10)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(
+        type='CheckpointHook', by_epoch=False, interval=iters // 10),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))
+
+randomness = dict(seed=304)
diff --git a/mmsegmentation/configs/ddrnet/metafile.yaml b/mmsegmentation/configs/ddrnet/metafile.yaml
new file mode 100644
index 0000000..0707470
--- /dev/null
+++ b/mmsegmentation/configs/ddrnet/metafile.yaml
@@ -0,0 +1,64 @@
+Collections:
+- Name: DDRNet
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+  Paper:
+    Title: Deep Dual-resolution Networks for Real-time and Accurate Semantic Segmentation
+      of Road Scenes
+    URL: http://arxiv.org/abs/2101.06085
+  README: configs/ddrnet/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024
+  In Collection: DDRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.84
+      mIoU(ms+flip): 80.15
+  Config: configs/ddrnet/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 12
+    Architecture:
+    - DDRNet23-slim
+    - DDRNet
+    Training Resources: 2x A100 GPUS
+    Memory (GB): 1.7
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ddrnet/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024_20230426_145312-6a5e5174.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ddrnet/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024_20230426_145312.json
+  Paper:
+    Title: Deep Dual-resolution Networks for Real-time and Accurate Semantic Segmentation
+      of Road Scenes
+    URL: http://arxiv.org/abs/2101.06085
+  Code: ''
+  Framework: PyTorch
+- Name: ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024
+  In Collection: DDRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.99
+      mIoU(ms+flip): 81.71
+  Config: configs/ddrnet/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 12
+    Architecture:
+    - DDRNet23
+    - DDRNet
+    Training Resources: 2x A100 GPUS
+    Memory (GB): 7.26
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ddrnet/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024_20230425_162633-81601db0.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ddrnet/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024_20230425_162633.json
+  Paper:
+    Title: Deep Dual-resolution Networks for Real-time and Accurate Semantic Segmentation
+      of Road Scenes
+    URL: http://arxiv.org/abs/2101.06085
+  Code: ''
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/deeplabv3/README.md b/mmsegmentation/configs/deeplabv3/README.md
new file mode 100644
index 0000000..df50b7f
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/README.md
@@ -0,0 +1,118 @@
+# DeepLabV3
+
+> [Rethinking atrous convolution for semantic image segmentation](https://arxiv.org/abs/1706.05587)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/tensorflow/models/tree/master/research/deeplab">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+In this work, we revisit atrous convolution, a powerful tool to explicitly adjust filter's field-of-view as well as control the resolution of feature responses computed by Deep Convolutional Neural Networks, in the application of semantic image segmentation. To handle the problem of segmenting objects at multiple scales, we design modules which employ atrous convolution in cascade or in parallel to capture multi-scale context by adopting multiple atrous rates. Furthermore, we propose to augment our previously proposed Atrous Spatial Pyramid Pooling module, which probes convolutional features at multiple scales, with image-level features encoding global context and further boost performance. We also elaborate on implementation details and share our experience on training our system. The proposed \`DeepLabv3' system significantly improves over our previous DeepLab versions without DenseCRF post-processing and attains comparable performance with other state-of-art models on the PASCAL VOC 2012 semantic image segmentation benchmark.
+
+<!-- [IMAGE] -->
+
+<div align=center >
+<img alt="DEEPLABv3_ResNet-D8" src="https://user-images.githubusercontent.com/61172629/209305311-87ff9e36-b7cd-46d7-8b4c-9e26e10c27d0.jpg"/>
+DEEPLABv3_ResNet-D8 model structure
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method           | Backbone        | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                      | download                                                                                                                                                                                                                                                                                                                                                                                               |
+| ---------------- | --------------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DeepLabV3        | R-50-D8         | 512x1024  |   40000 | 6.1      | 2.57           | V100   | 79.09 |         80.45 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x1024_40k_cityscapes/deeplabv3_r50-d8_512x1024_40k_cityscapes_20200605_022449-acadc2f8.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x1024_40k_cityscapes/deeplabv3_r50-d8_512x1024_40k_cityscapes_20200605_022449.log.json)                                 |
+| DeepLabV3        | R-101-D8        | 512x1024  |   40000 | 9.6      | 1.92           | V100   | 77.12 |         79.61 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-512x1024.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x1024_40k_cityscapes/deeplabv3_r101-d8_512x1024_40k_cityscapes_20200605_012241-7fd3f799.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x1024_40k_cityscapes/deeplabv3_r101-d8_512x1024_40k_cityscapes_20200605_012241.log.json)                             |
+| DeepLabV3        | R-50-D8         | 769x769   |   40000 | 6.9      | 1.11           | V100   | 78.58 |         79.89 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-769x769.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_769x769_40k_cityscapes/deeplabv3_r50-d8_769x769_40k_cityscapes_20200606_113723-7eda553c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_769x769_40k_cityscapes/deeplabv3_r50-d8_769x769_40k_cityscapes_20200606_113723.log.json)                                     |
+| DeepLabV3        | R-101-D8        | 769x769   |   40000 | 10.9     | 0.83           | V100   | 79.27 |         80.11 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-769x769.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_769x769_40k_cityscapes/deeplabv3_r101-d8_769x769_40k_cityscapes_20200606_113809-c64f889f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_769x769_40k_cityscapes/deeplabv3_r101-d8_769x769_40k_cityscapes_20200606_113809.log.json)                                 |
+| DeepLabV3        | R-18-D8         | 512x1024  |   80000 | 1.7      | 13.78          | V100   | 76.70 |         78.27 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-512x1024.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18-d8_512x1024_80k_cityscapes/deeplabv3_r18-d8_512x1024_80k_cityscapes_20201225_021506-23dffbe2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18-d8_512x1024_80k_cityscapes/deeplabv3_r18-d8_512x1024_80k_cityscapes-20201225_021506.log.json)                                 |
+| DeepLabV3        | R-50-D8         | 512x1024  |   80000 | -        | -              | V100   | 79.32 |         80.57 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x1024_80k_cityscapes/deeplabv3_r50-d8_512x1024_80k_cityscapes_20200606_113404-b92cfdd4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x1024_80k_cityscapes/deeplabv3_r50-d8_512x1024_80k_cityscapes_20200606_113404.log.json)                                 |
+| DeepLabV3        | R-101-D8        | 512x1024  |   80000 | -        | -              | V100   | 80.20 |         81.21 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-512x1024.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x1024_80k_cityscapes/deeplabv3_r101-d8_512x1024_80k_cityscapes_20200606_113503-9e428899.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x1024_80k_cityscapes/deeplabv3_r101-d8_512x1024_80k_cityscapes_20200606_113503.log.json)                             |
+| DeepLabV3 (FP16) | R-101-D8        | 512x1024  |   80000 | 5.75     | 3.86           | V100   | 80.48 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_fp16_512x1024_80k_cityscapes/deeplabv3_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230920-774d9cec.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_fp16_512x1024_80k_cityscapes/deeplabv3_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230920.log.json)         |
+| DeepLabV3        | R-18-D8         | 769x769   |   80000 | 1.9      | 5.55           | V100   | 76.60 |         78.26 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-769x769.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18-d8_769x769_80k_cityscapes/deeplabv3_r18-d8_769x769_80k_cityscapes_20201225_021506-6452126a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18-d8_769x769_80k_cityscapes/deeplabv3_r18-d8_769x769_80k_cityscapes-20201225_021506.log.json)                                     |
+| DeepLabV3        | R-50-D8         | 769x769   |   80000 | -        | -              | V100   | 79.89 |         81.06 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_769x769_80k_cityscapes/deeplabv3_r50-d8_769x769_80k_cityscapes_20200606_221338-788d6228.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_769x769_80k_cityscapes/deeplabv3_r50-d8_769x769_80k_cityscapes_20200606_221338.log.json)                                     |
+| DeepLabV3        | R-101-D8        | 769x769   |   80000 | -        | -              | V100   | 79.67 |         80.81 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-769x769.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_769x769_80k_cityscapes/deeplabv3_r101-d8_769x769_80k_cityscapes_20200607_013353-60e95418.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_769x769_80k_cityscapes/deeplabv3_r101-d8_769x769_80k_cityscapes_20200607_013353.log.json)                                 |
+| DeepLabV3        | R-101-D16-MG124 | 512x1024  |   40000 | 4.7      | 6.96           | V100   | 76.71 |         78.63 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d16-mg124_512x1024_40k_cityscapes/deeplabv3_r101-d16-mg124_512x1024_40k_cityscapes_20200908_005644-67b0c992.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d16-mg124_512x1024_40k_cityscapes/deeplabv3_r101-d16-mg124_512x1024_40k_cityscapes-20200908_005644.log.json) |
+| DeepLabV3        | R-101-D16-MG124 | 512x1024  |   80000 | -        | -              | V100   | 78.36 |         79.84 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d16-mg124_512x1024_80k_cityscapes/deeplabv3_r101-d16-mg124_512x1024_80k_cityscapes_20200908_005644-57bb8425.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d16-mg124_512x1024_80k_cityscapes/deeplabv3_r101-d16-mg124_512x1024_80k_cityscapes-20200908_005644.log.json) |
+| DeepLabV3        | R-18b-D8        | 512x1024  |   80000 | 1.6      | 13.93          | V100   | 76.26 |         77.88 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-512x1024.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18b-d8_512x1024_80k_cityscapes/deeplabv3_r18b-d8_512x1024_80k_cityscapes_20201225_094144-46040cef.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18b-d8_512x1024_80k_cityscapes/deeplabv3_r18b-d8_512x1024_80k_cityscapes-20201225_094144.log.json)                             |
+| DeepLabV3        | R-50b-D8        | 512x1024  |   80000 | 6.0      | 2.74           | V100   | 79.63 |         80.98 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-512x1024.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50b-d8_512x1024_80k_cityscapes/deeplabv3_r50b-d8_512x1024_80k_cityscapes_20201225_155148-ec368954.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50b-d8_512x1024_80k_cityscapes/deeplabv3_r50b-d8_512x1024_80k_cityscapes-20201225_155148.log.json)                             |
+| DeepLabV3        | R-101b-D8       | 512x1024  |   80000 | 9.5      | 1.81           | V100   | 80.01 |         81.21 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-512x1024.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101b-d8_512x1024_80k_cityscapes/deeplabv3_r101b-d8_512x1024_80k_cityscapes_20201226_171821-8fd49503.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101b-d8_512x1024_80k_cityscapes/deeplabv3_r101b-d8_512x1024_80k_cityscapes-20201226_171821.log.json)                         |
+| DeepLabV3        | R-18b-D8        | 769x769   |   80000 | 1.8      | 5.79           | V100   | 75.63 |         77.51 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-769x769.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18b-d8_769x769_80k_cityscapes/deeplabv3_r18b-d8_769x769_80k_cityscapes_20201225_094144-fdc985d9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18b-d8_769x769_80k_cityscapes/deeplabv3_r18b-d8_769x769_80k_cityscapes-20201225_094144.log.json)                                 |
+| DeepLabV3        | R-50b-D8        | 769x769   |   80000 | 6.8      | 1.16           | V100   | 78.80 |         80.27 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-769x769.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50b-d8_769x769_80k_cityscapes/deeplabv3_r50b-d8_769x769_80k_cityscapes_20201225_155404-87fb0cf4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50b-d8_769x769_80k_cityscapes/deeplabv3_r50b-d8_769x769_80k_cityscapes-20201225_155404.log.json)                                 |
+| DeepLabV3        | R-101b-D8       | 769x769   |   80000 | 10.7     | 0.82           | V100   | 79.41 |         80.73 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-769x769.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101b-d8_769x769_80k_cityscapes/deeplabv3_r101b-d8_769x769_80k_cityscapes_20201226_190843-9142ee57.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101b-d8_769x769_80k_cityscapes/deeplabv3_r101b-d8_769x769_80k_cityscapes-20201226_190843.log.json)                             |
+
+### ADE20K
+
+| Method    | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                           | download                                                                                                                                                                                                                                                                                                                                                   |
+| --------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DeepLabV3 | R-50-D8  | 512x512   |   80000 | 8.9      | 14.76          | V100   | 42.42 |         43.28 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_80k_ade20k/deeplabv3_r50-d8_512x512_80k_ade20k_20200614_185028-0bb3f844.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_80k_ade20k/deeplabv3_r50-d8_512x512_80k_ade20k_20200614_185028.log.json)         |
+| DeepLabV3 | R-101-D8 | 512x512   |   80000 | 12.4     | 10.14          | V100   | 44.08 |         45.19 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_80k_ade20k/deeplabv3_r101-d8_512x512_80k_ade20k_20200615_021256-d89c7fa4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_80k_ade20k/deeplabv3_r101-d8_512x512_80k_ade20k_20200615_021256.log.json)     |
+| DeepLabV3 | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 42.66 |         44.09 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_160k_ade20k/deeplabv3_r50-d8_512x512_160k_ade20k_20200615_123227-5d0ee427.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_160k_ade20k/deeplabv3_r50-d8_512x512_160k_ade20k_20200615_123227.log.json)     |
+| DeepLabV3 | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 45.00 |         46.66 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_160k_ade20k/deeplabv3_r101-d8_512x512_160k_ade20k_20200615_105816-b1f72b3b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_160k_ade20k/deeplabv3_r101-d8_512x512_160k_ade20k_20200615_105816.log.json) |
+
+### Pascal VOC 2012 + Aug
+
+| Method    | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                            | download                                                                                                                                                                                                                                                                                                                                                       |
+| --------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | --------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DeepLabV3 | R-50-D8  | 512x512   |   20000 | 6.1      | 13.88          | V100   | 76.17 |         77.42 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_20k_voc12aug/deeplabv3_r50-d8_512x512_20k_voc12aug_20200617_010906-596905ef.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_20k_voc12aug/deeplabv3_r50-d8_512x512_20k_voc12aug_20200617_010906.log.json)     |
+| DeepLabV3 | R-101-D8 | 512x512   |   20000 | 9.6      | 9.81           | V100   | 78.70 |         79.95 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_20k_voc12aug/deeplabv3_r101-d8_512x512_20k_voc12aug_20200617_010932-8d13832f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_20k_voc12aug/deeplabv3_r101-d8_512x512_20k_voc12aug_20200617_010932.log.json) |
+| DeepLabV3 | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 77.68 |         78.78 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_40k_voc12aug/deeplabv3_r50-d8_512x512_40k_voc12aug_20200613_161546-2ae96e7e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_40k_voc12aug/deeplabv3_r50-d8_512x512_40k_voc12aug_20200613_161546.log.json)     |
+| DeepLabV3 | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 77.92 |         79.18 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_40k_voc12aug/deeplabv3_r101-d8_512x512_40k_voc12aug_20200613_161432-0017d784.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_40k_voc12aug/deeplabv3_r101-d8_512x512_40k_voc12aug_20200613_161432.log.json) |
+
+### Pascal Context
+
+| Method    | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                  | download                                                                                                                                                                                                                                                                                                                                                                               |
+| --------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | --------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DeepLabV3 | R-101-D8 | 480x480   |   40000 | 9.2      | 7.09           | V100   | 46.55 |         47.81 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_40k_pascal_context/deeplabv3_r101-d8_480x480_40k_pascal_context_20200911_204118-1aa27336.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_40k_pascal_context/deeplabv3_r101-d8_480x480_40k_pascal_context-20200911_204118.log.json) |
+| DeepLabV3 | R-101-D8 | 480x480   |   80000 | -        | -              | V100   | 46.42 |         47.53 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_80k_pascal_context/deeplabv3_r101-d8_480x480_80k_pascal_context_20200911_170155-2a21fff3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_80k_pascal_context/deeplabv3_r101-d8_480x480_80k_pascal_context-20200911_170155.log.json) |
+
+### Pascal Context 59
+
+| Method    | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                     | download                                                                                                                                                                                                                                                                                                                                                                                           |
+| --------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DeepLabV3 | R-101-D8 | 480x480   |   40000 | -        | -              | V100   | 52.61 |         54.28 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-59-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_40k_pascal_context_59/deeplabv3_r101-d8_480x480_40k_pascal_context_59_20210416_110332-cb08ea46.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_40k_pascal_context_59/deeplabv3_r101-d8_480x480_40k_pascal_context_59-20210416_110332.log.json) |
+| DeepLabV3 | R-101-D8 | 480x480   |   80000 | -        | -              | V100   | 52.46 |         54.09 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-59-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_80k_pascal_context_59/deeplabv3_r101-d8_480x480_80k_pascal_context_59_20210416_113002-26303993.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_80k_pascal_context_59/deeplabv3_r101-d8_480x480_80k_pascal_context_59-20210416_113002.log.json) |
+
+### COCO-Stuff 10k
+
+| Method    | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                 | download                                                                                                                                                                                                                                                                                                                                                                                           |
+| --------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DeepLabV3 | R-50-D8  | 512x512   |   20000 | 9.6      | 10.8           | V100   | 34.66 |         36.08 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_coco-stuff10k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_20k_coco-stuff10k/deeplabv3_r50-d8_512x512_4x4_20k_coco-stuff10k_20210821_043025-b35f789d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_20k_coco-stuff10k/deeplabv3_r50-d8_512x512_4x4_20k_coco-stuff10k_20210821_043025.log.json)     |
+| DeepLabV3 | R-101-D8 | 512x512   |   20000 | 13.2     | 8.7            | V100   | 37.30 |         38.42 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_coco-stuff10k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_20k_coco-stuff10k/deeplabv3_r101-d8_512x512_4x4_20k_coco-stuff10k_20210821_043025-c49752cb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_20k_coco-stuff10k/deeplabv3_r101-d8_512x512_4x4_20k_coco-stuff10k_20210821_043025.log.json) |
+| DeepLabV3 | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 35.73 |         37.09 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_coco-stuff10k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_40k_coco-stuff10k/deeplabv3_r50-d8_512x512_4x4_40k_coco-stuff10k_20210821_043305-dc76f3ff.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_40k_coco-stuff10k/deeplabv3_r50-d8_512x512_4x4_40k_coco-stuff10k_20210821_043305.log.json)     |
+| DeepLabV3 | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 37.81 |         38.80 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_coco-stuff10k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_40k_coco-stuff10k/deeplabv3_r101-d8_512x512_4x4_40k_coco-stuff10k_20210821_043305-636cb433.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_40k_coco-stuff10k/deeplabv3_r101-d8_512x512_4x4_40k_coco-stuff10k_20210821_043305.log.json) |
+
+### COCO-Stuff 164k
+
+| Method    | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                   | download                                                                                                                                                                                                                                                                                                                                                                                                   |
+| --------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DeepLabV3 | R-50-D8  | 512x512   |   80000 | 9.6      | 10.8           | V100   | 39.38 |         40.03 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_coco-stuff164k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_80k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_80k_coco-stuff164k_20210709_163016-88675c24.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_80k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_80k_coco-stuff164k_20210709_163016.log.json)         |
+| DeepLabV3 | R-101-D8 | 512x512   |   80000 | 13.2     | 8.7            | V100   | 40.87 |         41.50 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_coco-stuff164k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_80k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_80k_coco-stuff164k_20210709_201252-13600dc2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_80k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_80k_coco-stuff164k_20210709_201252.log.json)     |
+| DeepLabV3 | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 41.09 |         41.69 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_coco-stuff164k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_160k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_160k_coco-stuff164k_20210709_163016-49f2812b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_160k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_160k_coco-stuff164k_20210709_163016.log.json)     |
+| DeepLabV3 | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 41.82 |         42.49 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_coco-stuff164k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_160k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_160k_coco-stuff164k_20210709_155402-f035acfd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_160k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_160k_coco-stuff164k_20210709_155402.log.json) |
+| DeepLabV3 | R-50-D8  | 512x512   |  320000 | -        | -              | V100   | 41.37 |         42.22 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb4-320k_coco-stuff164k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_320k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_320k_coco-stuff164k_20210709_155403-51b21115.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_320k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_320k_coco-stuff164k_20210709_155403.log.json)     |
+| DeepLabV3 | R-101-D8 | 512x512   |  320000 | -        | -              | V100   | 42.61 |         43.42 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-320k_coco-stuff164k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_320k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_320k_coco-stuff164k_20210709_155402-3cbca14d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_320k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_320k_coco-stuff164k_20210709_155402.log.json) |
+
+Note:
+
+- `D-8` here corresponding to the output stride 8 setting for DeepLab series.
+- `FP16` means Mixed Precision (FP16) is adopted in training.
+
+## Citation
+
+```bibtext
+@article{chen2017rethinking,
+  title={Rethinking atrous convolution for semantic image segmentation},
+  author={Chen, Liang-Chieh and Papandreou, George and Schroff, Florian and Adam, Hartwig},
+  journal={arXiv preprint arXiv:1706.05587},
+  year={2017}
+}
+```
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..b9f3c17
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,11 @@
+_base_ = './deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='open-mmlab://resnet101_v1c',
+    backbone=dict(
+        depth=101,
+        dilations=(1, 1, 1, 2),
+        strides=(1, 2, 2, 1),
+        multi_grid=(1, 2, 4)),
+    decode_head=dict(
+        dilations=(1, 6, 12, 18),
+        sampler=dict(type='OHEMPixelSampler', min_kept=100000)))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..da3a88f
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,11 @@
+_base_ = './deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='open-mmlab://resnet101_v1c',
+    backbone=dict(
+        depth=101,
+        dilations=(1, 1, 1, 2),
+        strides=(1, 2, 2, 1),
+        multi_grid=(1, 2, 4)),
+    decode_head=dict(
+        dilations=(1, 6, 12, 18),
+        sampler=dict(type='OHEMPixelSampler', min_kept=100000)))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..d01803c
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..7964b51
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3_r50-d8_4xb2-40k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..1d1a620
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..7820546
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..8417416
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = './deeplabv3_r101-d8_4xb2-40k_cityscapes-512x1024.py'
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(
+    _delete_=True,
+    type='AmpOptimWrapper',
+    optimizer=optimizer,
+    loss_scale=512.)
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..0ed6eee
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3_r50-d8_4xb4-160k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_coco-stuff164k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_coco-stuff164k-512x512.py
new file mode 100644
index 0000000..add0083
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_coco-stuff164k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3_r50-d8_4xb4-160k_coco-stuff164k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_coco-stuff10k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_coco-stuff10k-512x512.py
new file mode 100644
index 0000000..349cc88
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_coco-stuff10k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3_r50-d8_4xb4-20k_coco-stuff10k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..1c527e0
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3_r50-d8_4xb4-20k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-320k_coco-stuff164k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-320k_coco-stuff164k-512x512.py
new file mode 100644
index 0000000..ea27bed
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-320k_coco-stuff164k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3_r50-d8_4xb4-320k_coco-stuff164k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_coco-stuff10k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_coco-stuff10k-512x512.py
new file mode 100644
index 0000000..a43a786
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_coco-stuff10k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3_r50-d8_4xb4-40k_coco-stuff10k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-480x480.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-480x480.py
new file mode 100644
index 0000000..8879d53
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-480x480.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3_r50-d8_4xb4-40k_pascal-context-480x480.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-59-480x480.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-59-480x480.py
new file mode 100644
index 0000000..54671d4
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-59-480x480.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3_r50-d8_4xb4-40k_pascal-context-59-480x480.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..1b2635d
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3_r50-d8_4xb4-40k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..b7bb0b6
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3_r50-d8_4xb4-80k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_coco-stuff164k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_coco-stuff164k-512x512.py
new file mode 100644
index 0000000..2d4f6f7
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_coco-stuff164k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3_r50-d8_4xb4-80k_coco-stuff164k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-480x480.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-480x480.py
new file mode 100644
index 0000000..9d64ca2
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-480x480.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3_r50-d8_4xb4-80k_pascal-context-480x480.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-59-480x480.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-59-480x480.py
new file mode 100644
index 0000000..54671d4
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-59-480x480.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3_r50-d8_4xb4-40k_pascal-context-59-480x480.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..708932d
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,4 @@
+_base_ = './deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='torchvision://resnet101',
+    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..a0f634d
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,4 @@
+_base_ = './deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(
+    pretrained='torchvision://resnet101',
+    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..bc353bb
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,9 @@
+_base_ = './deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='open-mmlab://resnet18_v1c',
+    backbone=dict(depth=18),
+    decode_head=dict(
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..021c98c
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,9 @@
+_base_ = './deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(
+    pretrained='open-mmlab://resnet18_v1c',
+    backbone=dict(depth=18),
+    decode_head=dict(
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..c747cd7
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,9 @@
+_base_ = './deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='torchvision://resnet18',
+    backbone=dict(type='ResNet', depth=18),
+    decode_head=dict(
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..6506abf
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,9 @@
+_base_ = './deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(
+    pretrained='torchvision://resnet18',
+    backbone=dict(type='ResNet', depth=18),
+    decode_head=dict(
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..4a2a971
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/deeplabv3_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..a52f29e
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/deeplabv3_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..1bd29b9
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/deeplabv3_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..27f0fc4
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/deeplabv3_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..04e15f0
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/deeplabv3_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_coco-stuff164k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_coco-stuff164k-512x512.py
new file mode 100644
index 0000000..ba76a59
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_coco-stuff164k-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/deeplabv3_r50-d8.py',
+    '../_base_/datasets/coco-stuff164k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=171),
+    auxiliary_head=dict(num_classes=171))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_coco-stuff10k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_coco-stuff10k-512x512.py
new file mode 100644
index 0000000..d0559c8
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_coco-stuff10k-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/deeplabv3_r50-d8.py',
+    '../_base_/datasets/coco-stuff10k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_20k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=171),
+    auxiliary_head=dict(num_classes=171))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..c5458d9
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/deeplabv3_r50-d8.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_20k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-320k_coco-stuff164k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-320k_coco-stuff164k-512x512.py
new file mode 100644
index 0000000..c3b4f94
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-320k_coco-stuff164k-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/deeplabv3_r50-d8.py',
+    '../_base_/datasets/coco-stuff164k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_320k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=171),
+    auxiliary_head=dict(num_classes=171))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_coco-stuff10k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_coco-stuff10k-512x512.py
new file mode 100644
index 0000000..40dbffa
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_coco-stuff10k-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/deeplabv3_r50-d8.py',
+    '../_base_/datasets/coco-stuff10k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=171),
+    auxiliary_head=dict(num_classes=171))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_pascal-context-480x480.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_pascal-context-480x480.py
new file mode 100644
index 0000000..3c4e753
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_pascal-context-480x480.py
@@ -0,0 +1,14 @@
+_base_ = [
+    '../_base_/models/deeplabv3_r50-d8.py',
+    '../_base_/datasets/pascal_context.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (480, 480)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=60),
+    auxiliary_head=dict(num_classes=60),
+    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
+optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_pascal-context-59-480x480.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_pascal-context-59-480x480.py
new file mode 100644
index 0000000..e3b6c36
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_pascal-context-59-480x480.py
@@ -0,0 +1,14 @@
+_base_ = [
+    '../_base_/models/deeplabv3_r50-d8.py',
+    '../_base_/datasets/pascal_context_59.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (480, 480)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=59),
+    auxiliary_head=dict(num_classes=59),
+    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
+optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..8333cc6
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/deeplabv3_r50-d8.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..0bcdab5
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/deeplabv3_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_coco-stuff164k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_coco-stuff164k-512x512.py
new file mode 100644
index 0000000..519df5a
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_coco-stuff164k-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/deeplabv3_r50-d8.py',
+    '../_base_/datasets/coco-stuff164k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=171),
+    auxiliary_head=dict(num_classes=171))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_pascal-context-480x480.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_pascal-context-480x480.py
new file mode 100644
index 0000000..ba8c7de
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_pascal-context-480x480.py
@@ -0,0 +1,14 @@
+_base_ = [
+    '../_base_/models/deeplabv3_r50-d8.py',
+    '../_base_/datasets/pascal_context.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (480, 480)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=60),
+    auxiliary_head=dict(num_classes=60),
+    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
+optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_pascal-context-59-480x480.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_pascal-context-59-480x480.py
new file mode 100644
index 0000000..d34bd89
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_pascal-context-59-480x480.py
@@ -0,0 +1,14 @@
+_base_ = [
+    '../_base_/models/deeplabv3_r50-d8.py',
+    '../_base_/datasets/pascal_context_59.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (480, 480)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=59),
+    auxiliary_head=dict(num_classes=59),
+    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
+optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..818519f
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='torchvision://resnet50', backbone=dict(type='ResNet'))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..07a234b
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(pretrained='torchvision://resnet50', backbone=dict(type='ResNet'))
diff --git a/mmsegmentation/configs/deeplabv3/metafile.yaml b/mmsegmentation/configs/deeplabv3/metafile.yaml
new file mode 100644
index 0000000..650f7d6
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3/metafile.yaml
@@ -0,0 +1,985 @@
+Collections:
+- Name: DeepLabV3
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+    - ADE20K
+    - Pascal VOC 2012 + Aug
+    - Pascal Context
+    - Pascal Context 59
+    - COCO-Stuff 10k
+    - COCO-Stuff 164k
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  README: configs/deeplabv3/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.09
+      mIoU(ms+flip): 80.45
+  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x1024_40k_cityscapes/deeplabv3_r50-d8_512x1024_40k_cityscapes_20200605_022449-acadc2f8.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x1024_40k_cityscapes/deeplabv3_r50-d8_512x1024_40k_cityscapes_20200605_022449.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r101-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.12
+      mIoU(ms+flip): 79.61
+  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x1024_40k_cityscapes/deeplabv3_r101-d8_512x1024_40k_cityscapes_20200605_012241-7fd3f799.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x1024_40k_cityscapes/deeplabv3_r101-d8_512x1024_40k_cityscapes_20200605_012241.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r50-d8_4xb2-40k_cityscapes-769x769
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.58
+      mIoU(ms+flip): 79.89
+  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_769x769_40k_cityscapes/deeplabv3_r50-d8_769x769_40k_cityscapes_20200606_113723-7eda553c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_769x769_40k_cityscapes/deeplabv3_r50-d8_769x769_40k_cityscapes_20200606_113723.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r101-d8_4xb2-40k_cityscapes-769x769
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.27
+      mIoU(ms+flip): 80.11
+  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_769x769_40k_cityscapes/deeplabv3_r101-d8_769x769_40k_cityscapes_20200606_113809-c64f889f.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_769x769_40k_cityscapes/deeplabv3_r101-d8_769x769_40k_cityscapes_20200606_113809.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r18-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.7
+      mIoU(ms+flip): 78.27
+  Config: configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-18-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.7
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18-d8_512x1024_80k_cityscapes/deeplabv3_r18-d8_512x1024_80k_cityscapes_20201225_021506-23dffbe2.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18-d8_512x1024_80k_cityscapes/deeplabv3_r18-d8_512x1024_80k_cityscapes-20201225_021506.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.32
+      mIoU(ms+flip): 80.57
+  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x1024_80k_cityscapes/deeplabv3_r50-d8_512x1024_80k_cityscapes_20200606_113404-b92cfdd4.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x1024_80k_cityscapes/deeplabv3_r50-d8_512x1024_80k_cityscapes_20200606_113404.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r101-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 80.2
+      mIoU(ms+flip): 81.21
+  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x1024_80k_cityscapes/deeplabv3_r101-d8_512x1024_80k_cityscapes_20200606_113503-9e428899.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x1024_80k_cityscapes/deeplabv3_r101-d8_512x1024_80k_cityscapes_20200606_113503.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r101-d8_4xb2-amp-80k_cityscapes-512x1024
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 80.48
+  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - DeepLabV3
+    - (FP16)
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.75
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_fp16_512x1024_80k_cityscapes/deeplabv3_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230920-774d9cec.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_fp16_512x1024_80k_cityscapes/deeplabv3_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230920.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r18-d8_4xb2-80k_cityscapes-769x769
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.6
+      mIoU(ms+flip): 78.26
+  Config: configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-18-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18-d8_769x769_80k_cityscapes/deeplabv3_r18-d8_769x769_80k_cityscapes_20201225_021506-6452126a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18-d8_769x769_80k_cityscapes/deeplabv3_r18-d8_769x769_80k_cityscapes-20201225_021506.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.89
+      mIoU(ms+flip): 81.06
+  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_769x769_80k_cityscapes/deeplabv3_r50-d8_769x769_80k_cityscapes_20200606_221338-788d6228.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_769x769_80k_cityscapes/deeplabv3_r50-d8_769x769_80k_cityscapes_20200606_221338.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r101-d8_4xb2-80k_cityscapes-769x769
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.67
+      mIoU(ms+flip): 80.81
+  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_769x769_80k_cityscapes/deeplabv3_r101-d8_769x769_80k_cityscapes_20200607_013353-60e95418.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_769x769_80k_cityscapes/deeplabv3_r101-d8_769x769_80k_cityscapes_20200607_013353.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r101-d16-mg124_4xb2-40k_cityscapes-512x1024
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.71
+      mIoU(ms+flip): 78.63
+  Config: configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D16-MG124
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 4.7
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d16-mg124_512x1024_40k_cityscapes/deeplabv3_r101-d16-mg124_512x1024_40k_cityscapes_20200908_005644-67b0c992.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d16-mg124_512x1024_40k_cityscapes/deeplabv3_r101-d16-mg124_512x1024_40k_cityscapes-20200908_005644.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r101-d16-mg124_4xb2-80k_cityscapes-512x1024
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.36
+      mIoU(ms+flip): 79.84
+  Config: configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D16-MG124
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d16-mg124_512x1024_80k_cityscapes/deeplabv3_r101-d16-mg124_512x1024_80k_cityscapes_20200908_005644-57bb8425.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d16-mg124_512x1024_80k_cityscapes/deeplabv3_r101-d16-mg124_512x1024_80k_cityscapes-20200908_005644.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r18b-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.26
+      mIoU(ms+flip): 77.88
+  Config: configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-18b-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18b-d8_512x1024_80k_cityscapes/deeplabv3_r18b-d8_512x1024_80k_cityscapes_20201225_094144-46040cef.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18b-d8_512x1024_80k_cityscapes/deeplabv3_r18b-d8_512x1024_80k_cityscapes-20201225_094144.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r50b-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.63
+      mIoU(ms+flip): 80.98
+  Config: configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50b-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50b-d8_512x1024_80k_cityscapes/deeplabv3_r50b-d8_512x1024_80k_cityscapes_20201225_155148-ec368954.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50b-d8_512x1024_80k_cityscapes/deeplabv3_r50b-d8_512x1024_80k_cityscapes-20201225_155148.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r101b-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 80.01
+      mIoU(ms+flip): 81.21
+  Config: configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101b-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101b-d8_512x1024_80k_cityscapes/deeplabv3_r101b-d8_512x1024_80k_cityscapes_20201226_171821-8fd49503.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101b-d8_512x1024_80k_cityscapes/deeplabv3_r101b-d8_512x1024_80k_cityscapes-20201226_171821.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r18b-d8_4xb2-80k_cityscapes-769x769
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 75.63
+      mIoU(ms+flip): 77.51
+  Config: configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-18b-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18b-d8_769x769_80k_cityscapes/deeplabv3_r18b-d8_769x769_80k_cityscapes_20201225_094144-fdc985d9.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18b-d8_769x769_80k_cityscapes/deeplabv3_r18b-d8_769x769_80k_cityscapes-20201225_094144.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r50b-d8_4xb2-80k_cityscapes-769x769
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.8
+      mIoU(ms+flip): 80.27
+  Config: configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50b-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50b-d8_769x769_80k_cityscapes/deeplabv3_r50b-d8_769x769_80k_cityscapes_20201225_155404-87fb0cf4.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50b-d8_769x769_80k_cityscapes/deeplabv3_r50b-d8_769x769_80k_cityscapes-20201225_155404.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r101b-d8_4xb2-80k_cityscapes-769x769
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.41
+      mIoU(ms+flip): 80.73
+  Config: configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101b-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.7
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101b-d8_769x769_80k_cityscapes/deeplabv3_r101b-d8_769x769_80k_cityscapes_20201226_190843-9142ee57.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101b-d8_769x769_80k_cityscapes/deeplabv3_r101b-d8_769x769_80k_cityscapes-20201226_190843.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r50-d8_4xb4-80k_ade20k-512x512
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.42
+      mIoU(ms+flip): 43.28
+  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_80k_ade20k/deeplabv3_r50-d8_512x512_80k_ade20k_20200614_185028-0bb3f844.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_80k_ade20k/deeplabv3_r50-d8_512x512_80k_ade20k_20200614_185028.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r101-d8_4xb4-80k_ade20k-512x512
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 44.08
+      mIoU(ms+flip): 45.19
+  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 12.4
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_80k_ade20k/deeplabv3_r101-d8_512x512_80k_ade20k_20200615_021256-d89c7fa4.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_80k_ade20k/deeplabv3_r101-d8_512x512_80k_ade20k_20200615_021256.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r50-d8_4xb4-160k_ade20k-512x512
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.66
+      mIoU(ms+flip): 44.09
+  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_160k_ade20k/deeplabv3_r50-d8_512x512_160k_ade20k_20200615_123227-5d0ee427.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_160k_ade20k/deeplabv3_r50-d8_512x512_160k_ade20k_20200615_123227.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r101-d8_4xb4-160k_ade20k-512x512
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 45.0
+      mIoU(ms+flip): 46.66
+  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_160k_ade20k/deeplabv3_r101-d8_512x512_160k_ade20k_20200615_105816-b1f72b3b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_160k_ade20k/deeplabv3_r101-d8_512x512_160k_ade20k_20200615_105816.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r50-d8_4xb4-20k_voc12aug-512x512
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 76.17
+      mIoU(ms+flip): 77.42
+  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_20k_voc12aug/deeplabv3_r50-d8_512x512_20k_voc12aug_20200617_010906-596905ef.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_20k_voc12aug/deeplabv3_r50-d8_512x512_20k_voc12aug_20200617_010906.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r101-d8_4xb4-20k_voc12aug-512x512
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 78.7
+      mIoU(ms+flip): 79.95
+  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_20k_voc12aug/deeplabv3_r101-d8_512x512_20k_voc12aug_20200617_010932-8d13832f.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_20k_voc12aug/deeplabv3_r101-d8_512x512_20k_voc12aug_20200617_010932.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r50-d8_4xb4-40k_voc12aug-512x512
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 77.68
+      mIoU(ms+flip): 78.78
+  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_40k_voc12aug/deeplabv3_r50-d8_512x512_40k_voc12aug_20200613_161546-2ae96e7e.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_40k_voc12aug/deeplabv3_r50-d8_512x512_40k_voc12aug_20200613_161546.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r101-d8_4xb4-40k_voc12aug-512x512
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 77.92
+      mIoU(ms+flip): 79.18
+  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_40k_voc12aug/deeplabv3_r101-d8_512x512_40k_voc12aug_20200613_161432-0017d784.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_40k_voc12aug/deeplabv3_r101-d8_512x512_40k_voc12aug_20200613_161432.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r101-d8_4xb4-40k_pascal-context-480x480
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal Context
+    Metrics:
+      mIoU: 46.55
+      mIoU(ms+flip): 47.81
+  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-480x480.py
+  Metadata:
+    Training Data: Pascal Context
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_40k_pascal_context/deeplabv3_r101-d8_480x480_40k_pascal_context_20200911_204118-1aa27336.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_40k_pascal_context/deeplabv3_r101-d8_480x480_40k_pascal_context-20200911_204118.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r101-d8_4xb4-80k_pascal-context-480x480
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal Context
+    Metrics:
+      mIoU: 46.42
+      mIoU(ms+flip): 47.53
+  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-480x480.py
+  Metadata:
+    Training Data: Pascal Context
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_80k_pascal_context/deeplabv3_r101-d8_480x480_80k_pascal_context_20200911_170155-2a21fff3.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_80k_pascal_context/deeplabv3_r101-d8_480x480_80k_pascal_context-20200911_170155.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r101-d8_4xb4-40k_pascal-context-59-480x480
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal Context 59
+    Metrics:
+      mIoU: 52.61
+      mIoU(ms+flip): 54.28
+  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-59-480x480.py
+  Metadata:
+    Training Data: Pascal Context 59
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_40k_pascal_context_59/deeplabv3_r101-d8_480x480_40k_pascal_context_59_20210416_110332-cb08ea46.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_40k_pascal_context_59/deeplabv3_r101-d8_480x480_40k_pascal_context_59-20210416_110332.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r101-d8_4xb4-80k_pascal-context-59-480x480
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal Context 59
+    Metrics:
+      mIoU: 52.46
+      mIoU(ms+flip): 54.09
+  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-59-480x480.py
+  Metadata:
+    Training Data: Pascal Context 59
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_80k_pascal_context_59/deeplabv3_r101-d8_480x480_80k_pascal_context_59_20210416_113002-26303993.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_80k_pascal_context_59/deeplabv3_r101-d8_480x480_80k_pascal_context_59-20210416_113002.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r50-d8_4xb4-20k_coco-stuff10k-512x512
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 10k
+    Metrics:
+      mIoU: 34.66
+      mIoU(ms+flip): 36.08
+  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_coco-stuff10k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 10k
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_20k_coco-stuff10k/deeplabv3_r50-d8_512x512_4x4_20k_coco-stuff10k_20210821_043025-b35f789d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_20k_coco-stuff10k/deeplabv3_r50-d8_512x512_4x4_20k_coco-stuff10k_20210821_043025.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r101-d8_4xb4-20k_coco-stuff10k-512x512
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 10k
+    Metrics:
+      mIoU: 37.3
+      mIoU(ms+flip): 38.42
+  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_coco-stuff10k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 10k
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 13.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_20k_coco-stuff10k/deeplabv3_r101-d8_512x512_4x4_20k_coco-stuff10k_20210821_043025-c49752cb.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_20k_coco-stuff10k/deeplabv3_r101-d8_512x512_4x4_20k_coco-stuff10k_20210821_043025.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r50-d8_4xb4-40k_coco-stuff10k-512x512
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 10k
+    Metrics:
+      mIoU: 35.73
+      mIoU(ms+flip): 37.09
+  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_coco-stuff10k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 10k
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_40k_coco-stuff10k/deeplabv3_r50-d8_512x512_4x4_40k_coco-stuff10k_20210821_043305-dc76f3ff.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_40k_coco-stuff10k/deeplabv3_r50-d8_512x512_4x4_40k_coco-stuff10k_20210821_043305.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r101-d8_4xb4-40k_coco-stuff10k-512x512
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 10k
+    Metrics:
+      mIoU: 37.81
+      mIoU(ms+flip): 38.8
+  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_coco-stuff10k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 10k
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_40k_coco-stuff10k/deeplabv3_r101-d8_512x512_4x4_40k_coco-stuff10k_20210821_043305-636cb433.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_40k_coco-stuff10k/deeplabv3_r101-d8_512x512_4x4_40k_coco-stuff10k_20210821_043305.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r50-d8_4xb4-80k_coco-stuff164k-512x512
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 164k
+    Metrics:
+      mIoU: 39.38
+      mIoU(ms+flip): 40.03
+  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_coco-stuff164k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 164k
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_80k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_80k_coco-stuff164k_20210709_163016-88675c24.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_80k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_80k_coco-stuff164k_20210709_163016.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r101-d8_4xb4-80k_coco-stuff164k-512x512
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 164k
+    Metrics:
+      mIoU: 40.87
+      mIoU(ms+flip): 41.5
+  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_coco-stuff164k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 164k
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 13.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_80k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_80k_coco-stuff164k_20210709_201252-13600dc2.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_80k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_80k_coco-stuff164k_20210709_201252.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r50-d8_4xb4-160k_coco-stuff164k-512x512
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 164k
+    Metrics:
+      mIoU: 41.09
+      mIoU(ms+flip): 41.69
+  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_coco-stuff164k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 164k
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_160k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_160k_coco-stuff164k_20210709_163016-49f2812b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_160k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_160k_coco-stuff164k_20210709_163016.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r101-d8_4xb4-160k_coco-stuff164k-512x512
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 164k
+    Metrics:
+      mIoU: 41.82
+      mIoU(ms+flip): 42.49
+  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_coco-stuff164k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 164k
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_160k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_160k_coco-stuff164k_20210709_155402-f035acfd.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_160k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_160k_coco-stuff164k_20210709_155402.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r50-d8_4xb4-320k_coco-stuff164k-512x512
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 164k
+    Metrics:
+      mIoU: 41.37
+      mIoU(ms+flip): 42.22
+  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb4-320k_coco-stuff164k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 164k
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_320k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_320k_coco-stuff164k_20210709_155403-51b21115.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_320k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_320k_coco-stuff164k_20210709_155403.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
+- Name: deeplabv3_r101-d8_4xb4-320k_coco-stuff164k-512x512
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 164k
+    Metrics:
+      mIoU: 42.61
+      mIoU(ms+flip): 43.42
+  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-320k_coco-stuff164k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 164k
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_320k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_320k_coco-stuff164k_20210709_155402-3cbca14d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_320k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_320k_coco-stuff164k_20210709_155402.log.json
+  Paper:
+    Title: Rethinking atrous convolution for semantic image segmentation
+    URL: https://arxiv.org/abs/1706.05587
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/deeplabv3plus/README.md b/mmsegmentation/configs/deeplabv3plus/README.md
new file mode 100644
index 0000000..04d01fa
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/README.md
@@ -0,0 +1,138 @@
+# DeepLabV3+
+
+> [Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation](https://arxiv.org/abs/1802.02611)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/tensorflow/models/tree/master/research/deeplab">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Spatial pyramid pooling module or encode-decoder structure are used in deep neural networks for semantic segmentation task. The former networks are able to encode multi-scale contextual information by probing the incoming features with filters or pooling operations at multiple rates and multiple effective fields-of-view, while the latter networks can capture sharper object boundaries by gradually recovering the spatial information. In this work, we propose to combine the advantages from both methods. Specifically, our proposed model, DeepLabv3+, extends DeepLabv3 by adding a simple yet effective decoder module to refine the segmentation results especially along object boundaries. We further explore the Xception model and apply the depthwise separable convolution to both Atrous Spatial Pyramid Pooling and decoder modules, resulting in a faster and stronger encoder-decoder network. We demonstrate the effectiveness of the proposed model on PASCAL VOC 2012 and Cityscapes datasets, achieving the test set performance of 89.0% and 82.1% without any post-processing. Our paper is accompanied with a publicly available reference implementation of the proposed models in Tensorflow at [this https URL](https://github.com/tensorflow/models/tree/master/research/deeplab).
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142900680-3e2c3098-8341-4760-bbfd-b1d7d29968ea.png" width="70%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method            | Backbone        | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                                      | download                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| ----------------- | --------------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DeepLabV3+        | R-50-D8         | 512x1024  |   40000 | 7.5      | 3.94           | V100   | 79.61 |         81.01 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024.py)                 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_40k_cityscapes/deeplabv3plus_r50-d8_512x1024_40k_cityscapes_20200605_094610-d222ffcd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_40k_cityscapes/deeplabv3plus_r50-d8_512x1024_40k_cityscapes_20200605_094610.log.json)                                 |
+| DeepLabV3+        | R-101-D8        | 512x1024  |   40000 | 11       | 2.60           | V100   | 80.21 |         81.82 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-512x1024.py)                | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_40k_cityscapes/deeplabv3plus_r101-d8_512x1024_40k_cityscapes_20200605_094614-3769eecf.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_40k_cityscapes/deeplabv3plus_r101-d8_512x1024_40k_cityscapes_20200605_094614.log.json)                             |
+| DeepLabV3+        | R-50-D8         | 769x769   |   40000 | 8.5      | 1.72           | V100   | 78.97 |         80.46 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-769x769.py)                  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_769x769_40k_cityscapes/deeplabv3plus_r50-d8_769x769_40k_cityscapes_20200606_114143-1dcb0e3c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_769x769_40k_cityscapes/deeplabv3plus_r50-d8_769x769_40k_cityscapes_20200606_114143.log.json)                                     |
+| DeepLabV3+        | R-101-D8        | 769x769   |   40000 | 12.5     | 1.15           | V100   | 79.46 |         80.50 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-769x769.py)                 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_769x769_40k_cityscapes/deeplabv3plus_r101-d8_769x769_40k_cityscapes_20200606_114304-ff414b9e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_769x769_40k_cityscapes/deeplabv3plus_r101-d8_769x769_40k_cityscapes_20200606_114304.log.json)                                 |
+| DeepLabV3+        | R-18-D8         | 512x1024  |   80000 | 2.2      | 14.27          | V100   | 76.89 |         78.76 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-512x1024.py)                 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x1024_80k_cityscapes/deeplabv3plus_r18-d8_512x1024_80k_cityscapes_20201226_080942-cff257fe.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x1024_80k_cityscapes/deeplabv3plus_r18-d8_512x1024_80k_cityscapes-20201226_080942.log.json)                                 |
+| DeepLabV3+        | R-50-D8         | 512x1024  |   80000 | -        | -              | V100   | 80.09 |         81.13 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py)                 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_80k_cityscapes/deeplabv3plus_r50-d8_512x1024_80k_cityscapes_20200606_114049-f9fb496d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_80k_cityscapes/deeplabv3plus_r50-d8_512x1024_80k_cityscapes_20200606_114049.log.json)                                 |
+| DeepLabV3+        | R-101-D8        | 512x1024  |   80000 | -        | -              | V100   | 80.97 |         82.03 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024.py)                | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_80k_cityscapes/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143-068fcfe9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_80k_cityscapes/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143.log.json)                             |
+| DeepLabV3+ (FP16) | R-101-D8        | 512x1024  |   80000 | 6.35     | 7.87           | V100   | 80.46 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py)            | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230920-f1104f4b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230920.log.json)         |
+| DeepLabV3+        | R-18-D8         | 769x769   |   80000 | 2.5      | 5.74           | V100   | 76.26 |         77.91 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-769x769.py)                  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_769x769_80k_cityscapes/deeplabv3plus_r18-d8_769x769_80k_cityscapes_20201226_083346-f326e06a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_769x769_80k_cityscapes/deeplabv3plus_r18-d8_769x769_80k_cityscapes-20201226_083346.log.json)                                     |
+| DeepLabV3+        | R-50-D8         | 769x769   |   80000 | -        | -              | V100   | 79.83 |         81.48 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py)                  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_769x769_80k_cityscapes/deeplabv3plus_r50-d8_769x769_80k_cityscapes_20200606_210233-0e9dfdc4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_769x769_80k_cityscapes/deeplabv3plus_r50-d8_769x769_80k_cityscapes_20200606_210233.log.json)                                     |
+| DeepLabV3+        | R-101-D8        | 769x769   |   80000 | -        | -              | V100   | 80.65 |         81.47 | [config<sup>\[1\]</sup>](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-769x769.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_769x769_80k_cityscapes/deeplabv3plus_r101-d8_769x769_80k_cityscapes_20220406_154720-dfcc0b68.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_769x769_80k_cityscapes/deeplabv3plus_r101-d8_769x769_80k_cityscapes_20220406_154720.log.json)                                 |
+| DeepLabV3+        | R-101-D16-MG124 | 512x1024  |   40000 | 5.8      | 7.48           | V100   | 79.09 |         80.36 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/ddeeplabv3plus_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d16-mg124_512x1024_40k_cityscapes/deeplabv3plus_r101-d16-mg124_512x1024_40k_cityscapes_20200908_005644-cf9ce186.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d16-mg124_512x1024_40k_cityscapes/deeplabv3plus_r101-d16-mg124_512x1024_40k_cityscapes-20200908_005644.log.json) |
+| DeepLabV3+        | R-101-D16-MG124 | 512x1024  |   80000 | 9.9      | -              | V100   | 79.90 |         81.33 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d16-mg124_512x1024_80k_cityscapes/deeplabv3plus_r101-d16-mg124_512x1024_80k_cityscapes_20200908_005644-ee6158e0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d16-mg124_512x1024_80k_cityscapes/deeplabv3plus_r101-d16-mg124_512x1024_80k_cityscapes-20200908_005644.log.json) |
+| DeepLabV3+        | R-18b-D8        | 512x1024  |   80000 | 2.1      | 14.95          | V100   | 75.87 |         77.52 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-512x1024.py)                | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18b-d8_512x1024_80k_cityscapes/deeplabv3plus_r18b-d8_512x1024_80k_cityscapes_20201226_090828-e451abd9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18b-d8_512x1024_80k_cityscapes/deeplabv3plus_r18b-d8_512x1024_80k_cityscapes-20201226_090828.log.json)                             |
+| DeepLabV3+        | R-50b-D8        | 512x1024  |   80000 | 7.4      | 3.94           | V100   | 80.28 |         81.44 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-512x1024.py)                | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50b-d8_512x1024_80k_cityscapes/deeplabv3plus_r50b-d8_512x1024_80k_cityscapes_20201225_213645-a97e4e43.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50b-d8_512x1024_80k_cityscapes/deeplabv3plus_r50b-d8_512x1024_80k_cityscapes-20201225_213645.log.json)                             |
+| DeepLabV3+        | R-101b-D8       | 512x1024  |   80000 | 10.9     | 2.60           | V100   | 80.16 |         81.41 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-512x1024.py)               | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101b-d8_512x1024_80k_cityscapes/deeplabv3plus_r101b-d8_512x1024_80k_cityscapes_20201226_190843-9c3c93a4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101b-d8_512x1024_80k_cityscapes/deeplabv3plus_r101b-d8_512x1024_80k_cityscapes-20201226_190843.log.json)                         |
+| DeepLabV3+        | R-18b-D8        | 769x769   |   80000 | 2.4      | 5.96           | V100   | 76.36 |         78.24 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-769x769.py)                 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18b-d8_769x769_80k_cityscapes/deeplabv3plus_r18b-d8_769x769_80k_cityscapes_20201226_151312-2c868aff.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18b-d8_769x769_80k_cityscapes/deeplabv3plus_r18b-d8_769x769_80k_cityscapes-20201226_151312.log.json)                                 |
+| DeepLabV3+        | R-50b-D8        | 769x769   |   80000 | 8.4      | 1.72           | V100   | 79.41 |         80.56 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-769x769.py)                 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50b-d8_769x769_80k_cityscapes/deeplabv3plus_r50b-d8_769x769_80k_cityscapes_20201225_224655-8b596d1c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50b-d8_769x769_80k_cityscapes/deeplabv3plus_r50b-d8_769x769_80k_cityscapes-20201225_224655.log.json)                                 |
+| DeepLabV3+        | R-101b-D8       | 769x769   |   80000 | 12.3     | 1.10           | V100   | 79.88 |         81.46 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-769x769.py)                | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101b-d8_769x769_80k_cityscapes/deeplabv3plus_r101b-d8_769x769_80k_cityscapes_20201226_205041-227cdf7c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101b-d8_769x769_80k_cityscapes/deeplabv3plus_r101b-d8_769x769_80k_cityscapes-20201226_205041.log.json)                             |
+
+\[1\] The training of the model is sensitive to random seed, and the seed to train it is 1111.
+
+### ADE20K
+
+| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                   | download                                                                                                                                                                                                                                                                                                                                                                           |
+| ---------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DeepLabV3+ | R-50-D8  | 512x512   |   80000 | 10.6     | 21.01          | V100   | 42.72 |         43.75 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_ade20k/deeplabv3plus_r50-d8_512x512_80k_ade20k_20200614_185028-bf1400d8.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_ade20k/deeplabv3plus_r50-d8_512x512_80k_ade20k_20200614_185028.log.json)         |
+| DeepLabV3+ | R-101-D8 | 512x512   |   80000 | 14.1     | 14.16          | V100   | 44.60 |         46.06 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_ade20k/deeplabv3plus_r101-d8_512x512_80k_ade20k_20200615_014139-d5730af7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_ade20k/deeplabv3plus_r101-d8_512x512_80k_ade20k_20200615_014139.log.json)     |
+| DeepLabV3+ | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 43.95 |         44.93 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_160k_ade20k/deeplabv3plus_r50-d8_512x512_160k_ade20k_20200615_124504-6135c7e0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_160k_ade20k/deeplabv3plus_r50-d8_512x512_160k_ade20k_20200615_124504.log.json)     |
+| DeepLabV3+ | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 45.47 |         46.35 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_160k_ade20k/deeplabv3plus_r101-d8_512x512_160k_ade20k_20200615_123232-38ed86bb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_160k_ade20k/deeplabv3plus_r101-d8_512x512_160k_ade20k_20200615_123232.log.json) |
+
+### Pascal VOC 2012 + Aug
+
+| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                    | download                                                                                                                                                                                                                                                                                                                                                                               |
+| ---------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ----------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DeepLabV3+ | R-50-D8  | 512x512   |   20000 | 7.6      | 21             | V100   | 75.93 |         77.50 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_20k_voc12aug/deeplabv3plus_r50-d8_512x512_20k_voc12aug_20200617_102323-aad58ef1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_20k_voc12aug/deeplabv3plus_r50-d8_512x512_20k_voc12aug_20200617_102323.log.json)     |
+| DeepLabV3+ | R-101-D8 | 512x512   |   20000 | 11       | 13.88          | V100   | 77.22 |         78.59 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_20k_voc12aug/deeplabv3plus_r101-d8_512x512_20k_voc12aug_20200617_102345-c7ff3d56.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_20k_voc12aug/deeplabv3plus_r101-d8_512x512_20k_voc12aug_20200617_102345.log.json) |
+| DeepLabV3+ | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 76.81 |         77.57 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_40k_voc12aug/deeplabv3plus_r50-d8_512x512_40k_voc12aug_20200613_161759-e1b43aa9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_40k_voc12aug/deeplabv3plus_r50-d8_512x512_40k_voc12aug_20200613_161759.log.json)     |
+| DeepLabV3+ | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 78.62 |         79.53 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_40k_voc12aug/deeplabv3plus_r101-d8_512x512_40k_voc12aug_20200613_205333-faf03387.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_40k_voc12aug/deeplabv3plus_r101-d8_512x512_40k_voc12aug_20200613_205333.log.json) |
+
+### Pascal Context
+
+| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                         | download                                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ---------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DeepLabV3+ | R-101-D8 | 480x480   |   40000 | -        | 9.09           | V100   | 47.30 |         48.47 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_pascal-context-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_40k_pascal_context/deeplabv3plus_r101-d8_480x480_40k_pascal_context_20200911_165459-d3c8a29e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_40k_pascal_context/deeplabv3plus_r101-d8_480x480_40k_pascal_context-20200911_165459.log.json) |
+| DeepLabV3+ | R-101-D8 | 480x480   |   80000 | -        | -              | V100   | 47.23 |         48.26 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_pascal-context-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_80k_pascal_context/deeplabv3plus_r101-d8_480x480_80k_pascal_context_20200911_155322-145d3ee8.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_80k_pascal_context/deeplabv3plus_r101-d8_480x480_80k_pascal_context-20200911_155322.log.json) |
+
+### Pascal Context 59
+
+| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                             | download                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| ---------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DeepLabV3+ | R-101-D8 | 480x480   |   40000 | -        | -              | V100   | 52.86 |         54.54 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_pascal-context-59-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_40k_pascal_context_59/deeplabv3plus_r101-d8_480x480_40k_pascal_context_59_20210416_111233-ed937f15.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_40k_pascal_context_59/deeplabv3plus_r101-d8_480x480_40k_pascal_context_59-20210416_111233.log.json) |
+| DeepLabV3+ | R-101-D8 | 480x480   |   80000 | -        | -              | V100   |  53.2 |         54.67 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_pascal-context-59-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_80k_pascal_context_59/deeplabv3plus_r101-d8_480x480_80k_pascal_context_59_20210416_111127-7ca0331d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_80k_pascal_context_59/deeplabv3plus_r101-d8_480x480_80k_pascal_context_59-20210416_111127.log.json) |
+
+### LoveDA
+
+| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                  | download                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | --------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DeepLabV3+ | R-18-D8  | 512x512   |   80000 | 1.93     | 25.57          | V100   | 50.28 |         50.47 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_loveda-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x512_80k_loveda/deeplabv3plus_r18-d8_512x512_80k_loveda_20211104_132800-ce0fa0ca.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x512_80k_loveda/deeplabv3plus_r18-d8_512x512_80k_loveda_20211104_132800.log.json)     |
+| DeepLabV3+ | R-50-D8  | 512x512   |   80000 | 7.37     | 6.00           | V100   | 50.99 |         50.65 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_loveda-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_loveda/deeplabv3plus_r50-d8_512x512_80k_loveda_20211105_080442-f0720392.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_loveda/deeplabv3plus_r50-d8_512x512_80k_loveda_20211105_080442.log.json)     |
+| DeepLabV3+ | R-101-D8 | 512x512   |   80000 | 10.84    | 4.33           | V100   | 51.47 |         51.32 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_loveda-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_loveda/deeplabv3plus_r101-d8_512x512_80k_loveda_20211105_110759-4c1f297e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_loveda/deeplabv3plus_r101-d8_512x512_80k_loveda_20211105_110759.log.json) |
+
+### Potsdam
+
+| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                   | download                                                                                                                                                                                                                                                                                                                                                                           |
+| ---------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DeepLabV3+ | R-18-D8  | 512x512   |   80000 | 1.91     | 81.68          | V100   | 77.09 |         78.44 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_potsdam-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x512_80k_potsdam/deeplabv3plus_r18-d8_512x512_80k_potsdam_20211219_020601-75fd5bc3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x512_80k_potsdam/deeplabv3plus_r18-d8_512x512_80k_potsdam_20211219_020601.log.json)     |
+| DeepLabV3+ | R-50-D8  | 512x512   |   80000 | 7.36     | 26.44          | V100   | 78.33 |         79.27 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_potsdam-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_potsdam/deeplabv3plus_r50-d8_512x512_80k_potsdam_20211219_031508-7e7a2b24.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_potsdam/deeplabv3plus_r50-d8_512x512_80k_potsdam_20211219_031508.log.json)     |
+| DeepLabV3+ | R-101-D8 | 512x512   |   80000 | 10.83    | 17.56          | V100   |  78.7 |         79.47 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_potsdam/deeplabv3plus_r101-d8_512x512_80k_potsdam_20211219_031508-8b112708.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_potsdam/deeplabv3plus_r101-d8_512x512_80k_potsdam_20211219_031508.log.json) |
+
+### Vaihingen
+
+| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                     | download                                                                                                                                                                                                                                                                                                                                                                                                   |
+| ---------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DeepLabV3+ | R-18-D8  | 512x512   |   80000 | 1.91     | 72.79          | V100   | 72.50 |         74.13 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_vaihingen-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r18-d8_4x4_512x512_80k_vaihingen_20211231_230805-7626a263.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r18-d8_4x4_512x512_80k_vaihingen_20211231_230805.log.json)     |
+| DeepLabV3+ | R-50-D8  | 512x512   |   80000 | 7.36     | 26.91          | V100   | 73.97 |         75.05 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_vaihingen-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r50-d8_4x4_512x512_80k_vaihingen_20211231_230816-5040938d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r50-d8_4x4_512x512_80k_vaihingen_20211231_230816.log.json)     |
+| DeepLabV3+ | R-101-D8 | 512x512   |   80000 | 10.83    | 18.59          | V100   | 73.06 |         74.14 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_vaihingen-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r101-d8_4x4_512x512_80k_vaihingen_20211231_230816-8a095afa.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r101-d8_4x4_512x512_80k_vaihingen_20211231_230816.log.json) |
+
+### iSAID
+
+| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                | download                                                                                                                                                                                                                                                                                                                                                                               |
+| ---------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DeepLabV3+ | R-18-D8  | 896x896   |   80000 | 6.19     | 24.81          | V100   | 61.35 |         62.61 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_isaid-896x896.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_4x4_896x896_80k_isaid/deeplabv3plus_r18-d8_4x4_896x896_80k_isaid_20220110_180526-7059991d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_4x4_896x896_80k_isaid/deeplabv3plus_r18-d8_4x4_896x896_80k_isaid_20220110_180526.log.json) |
+| DeepLabV3+ | R-50-D8  | 896x896   |   80000 | 21.45    | 8.42           | V100   | 67.06 |         68.02 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_isaid-896x896.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4x4_896x896_80k_isaid/deeplabv3plus_r50-d8_4x4_896x896_80k_isaid_20220110_180526-598be439.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4x4_896x896_80k_isaid/deeplabv3plus_r50-d8_4x4_896x896_80k_isaid_20220110_180526.log.json) |
+
+### Mapillary Vistas v1.2
+
+| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                            | download                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| ---------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DeepLabV3+ | R-50-D8  | 1280x1280 |  300000 | 24.04    | 17.92          | A100   | 47.35 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280_20230301_110504-655f8e43.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280_20230301_110504.json) |
+
+Note:
+
+- `D-8`/`D-16` here corresponding to the output stride 8/16 setting for DeepLab series.
+- `MG-124` stands for multi-grid dilation in the last stage of ResNet.
+- `FP16` means Mixed Precision (FP16) is adopted in training.
+- `896x896` is the Crop Size of iSAID dataset, which is followed by the implementation of [PointFlow: Flowing Semantics Through Points for Aerial Image Segmentation](https://arxiv.org/pdf/2103.06564.pdf)
+
+## Citation
+
+```bibtex
+@inproceedings{deeplabv3plus2018,
+  title={Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation},
+  author={Liang-Chieh Chen and Yukun Zhu and George Papandreou and Florian Schroff and Hartwig Adam},
+  booktitle={ECCV},
+  year={2018}
+}
+```
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..71c9118
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,11 @@
+_base_ = './deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='open-mmlab://resnet101_v1c',
+    backbone=dict(
+        depth=101,
+        dilations=(1, 1, 1, 2),
+        strides=(1, 2, 2, 1),
+        multi_grid=(1, 2, 4)),
+    decode_head=dict(
+        dilations=(1, 6, 12, 18),
+        sampler=dict(type='OHEMPixelSampler', min_kept=100000)))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..7d1ccf0
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,11 @@
+_base_ = './deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='open-mmlab://resnet101_v1c',
+    backbone=dict(
+        depth=101,
+        dilations=(1, 1, 1, 2),
+        strides=(1, 2, 2, 1),
+        multi_grid=(1, 2, 4)),
+    decode_head=dict(
+        dilations=(1, 6, 12, 18),
+        sampler=dict(type='OHEMPixelSampler', min_kept=100000)))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..884b526
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..debb025
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3plus_r50-d8_4xb2-40k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..bc9334e
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..4af9aa2
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..9c9883d
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = './deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024.py'
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(
+    _delete_=True,
+    type='AmpOptimWrapper',
+    optimizer=optimizer,
+    loss_scale=512.)
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..c38a802
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3plus_r50-d8_4xb4-160k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..97bb827
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3plus_r50-d8_4xb4-20k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_pascal-context-480x480.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_pascal-context-480x480.py
new file mode 100644
index 0000000..e4b4011
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_pascal-context-480x480.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3plus_r50-d8_4xb4-40k_pascal-context-480x480.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_pascal-context-59-480x480.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_pascal-context-59-480x480.py
new file mode 100644
index 0000000..eeefae4
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_pascal-context-59-480x480.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3plus_r50-d8_4xb4-40k_pascal-context-59-480x480.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..0755c53
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3plus_r50-d8_4xb4-40k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..844ac96
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3plus_r50-d8_4xb4-80k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_loveda-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_loveda-512x512.py
new file mode 100644
index 0000000..87c6da9
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_loveda-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3plus_r50-d8_4xb4-80k_loveda-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_pascal-context-480x480.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_pascal-context-480x480.py
new file mode 100644
index 0000000..115b1c9
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_pascal-context-480x480.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3plus_r50-d8_4xb4-80k_pascal-context-480x480.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_pascal-context-59-480x480.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_pascal-context-59-480x480.py
new file mode 100644
index 0000000..9aaa653
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_pascal-context-59-480x480.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3plus_r50-d8_4xb4-80k_pascal-context-59-480x480.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py
new file mode 100644
index 0000000..5063b13
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3plus_r50-d8_4xb4-80k_potsdam-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_vaihingen-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_vaihingen-512x512.py
new file mode 100644
index 0000000..b99c2c7
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_vaihingen-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3plus_r50-d8_4xb4-80k_vaihingen-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..d1bcb09
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,4 @@
+_base_ = './deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='torchvision://resnet101',
+    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..c78fc1e
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,4 @@
+_base_ = './deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(
+    pretrained='torchvision://resnet101',
+    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..5f54913
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,11 @@
+_base_ = './deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='open-mmlab://resnet18_v1c',
+    backbone=dict(depth=18),
+    decode_head=dict(
+        c1_in_channels=64,
+        c1_channels=12,
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..1b361d6
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,11 @@
+_base_ = './deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(
+    pretrained='open-mmlab://resnet18_v1c',
+    backbone=dict(depth=18),
+    decode_head=dict(
+        c1_in_channels=64,
+        c1_channels=12,
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_isaid-896x896.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_isaid-896x896.py
new file mode 100644
index 0000000..3a1a753
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_isaid-896x896.py
@@ -0,0 +1,11 @@
+_base_ = './deeplabv3plus_r50-d8_4xb4-80k_isaid-896x896.py'
+model = dict(
+    pretrained='open-mmlab://resnet18_v1c',
+    backbone=dict(depth=18),
+    decode_head=dict(
+        c1_in_channels=64,
+        c1_channels=12,
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_loveda-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_loveda-512x512.py
new file mode 100644
index 0000000..01bbf9b
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_loveda-512x512.py
@@ -0,0 +1,11 @@
+_base_ = './deeplabv3plus_r50-d8_4xb4-80k_loveda-512x512.py'
+model = dict(
+    pretrained='open-mmlab://resnet18_v1c',
+    backbone=dict(depth=18),
+    decode_head=dict(
+        c1_in_channels=64,
+        c1_channels=12,
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_potsdam-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_potsdam-512x512.py
new file mode 100644
index 0000000..134f2cf
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_potsdam-512x512.py
@@ -0,0 +1,11 @@
+_base_ = './deeplabv3plus_r50-d8_4xb4-80k_potsdam-512x512.py'
+model = dict(
+    pretrained='open-mmlab://resnet18_v1c',
+    backbone=dict(depth=18),
+    decode_head=dict(
+        c1_in_channels=64,
+        c1_channels=12,
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_vaihingen-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_vaihingen-512x512.py
new file mode 100644
index 0000000..2194838
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_vaihingen-512x512.py
@@ -0,0 +1,11 @@
+_base_ = './deeplabv3plus_r50-d8_4xb4-80k_vaihingen-512x512.py'
+model = dict(
+    pretrained='open-mmlab://resnet18_v1c',
+    backbone=dict(depth=18),
+    decode_head=dict(
+        c1_in_channels=64,
+        c1_channels=12,
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..ea86219
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,11 @@
+_base_ = './deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='torchvision://resnet18',
+    backbone=dict(type='ResNet', depth=18),
+    decode_head=dict(
+        c1_in_channels=64,
+        c1_channels=12,
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..34ee7ed
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,11 @@
+_base_ = './deeplabv3plus_r50-d8_4xb2-40k_cityscapes-769x769.py'
+model = dict(
+    pretrained='torchvision://resnet18',
+    backbone=dict(type='ResNet', depth=18),
+    decode_head=dict(
+        c1_in_channels=64,
+        c1_channels=12,
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280.py
new file mode 100644
index 0000000..133c45a
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280.py
@@ -0,0 +1,58 @@
+_base_ = [
+    '../_base_/models/deeplabv3plus_r50-d8.py',
+    '../_base_/datasets/mapillary_v1_65.py',
+    '../_base_/default_runtime.py',
+]
+
+crop_size = (1280, 1280)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(depth=50),
+    decode_head=dict(num_classes=65),
+    auxiliary_head=dict(num_classes=65))
+
+iters = 300000
+# optimizer
+optimizer = dict(
+    type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.0001)
+# optimizer
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=optimizer,
+    clip_grad=dict(max_norm=0.01, norm_type=2),
+    paramwise_cfg=dict(
+        custom_keys={'backbone': dict(lr_mult=0.1, decay_mult=1.0)}))
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=0,
+        power=0.9,
+        begin=0,
+        end=iters,
+        by_epoch=False)
+]
+
+# training schedule for 300k
+train_cfg = dict(
+    type='IterBasedTrainLoop', max_iters=iters, val_interval=iters // 10)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(
+        type='CheckpointHook', by_epoch=False, interval=iters // 10),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))
+
+train_dataloader = dict(batch_size=2)
+
+# Default setting for scaling LR automatically
+#   - `enable` means enable scaling LR automatically
+#       or not by default.
+#   - `base_batch_size` = (4 GPUs) x (2 samples per GPU).
+auto_scale_lr = dict(enable=False, base_batch_size=8)
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..32f994d
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,8 @@
+_base_ = [
+    '../_base_/models/deeplabv3plus_r50-d8.py',
+    '../_base_/datasets/cityscapes.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..8cdf534
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/deeplabv3plus_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..0d249b0
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,8 @@
+_base_ = [
+    '../_base_/models/deeplabv3plus_r50-d8.py',
+    '../_base_/datasets/cityscapes.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..863a46e
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/deeplabv3plus_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..9a899fb
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/deeplabv3plus_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..1876d0c
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/deeplabv3plus_r50-d8.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_20k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_pascal-context-480x480.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_pascal-context-480x480.py
new file mode 100644
index 0000000..95b56d0
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_pascal-context-480x480.py
@@ -0,0 +1,14 @@
+_base_ = [
+    '../_base_/models/deeplabv3plus_r50-d8.py',
+    '../_base_/datasets/pascal_context.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (480, 480)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=60),
+    auxiliary_head=dict(num_classes=60),
+    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
+optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_pascal-context-59-480x480.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_pascal-context-59-480x480.py
new file mode 100644
index 0000000..459c62d
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_pascal-context-59-480x480.py
@@ -0,0 +1,14 @@
+_base_ = [
+    '../_base_/models/deeplabv3plus_r50-d8.py',
+    '../_base_/datasets/pascal_context_59.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (480, 480)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=59),
+    auxiliary_head=dict(num_classes=59),
+    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
+optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..0d61b50
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/deeplabv3plus_r50-d8.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..6f872ca
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/deeplabv3plus_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_isaid-896x896.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_isaid-896x896.py
new file mode 100644
index 0000000..7edec14
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_isaid-896x896.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/deeplabv3plus_r50-d8.py', '../_base_/datasets/isaid.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (896, 896)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=16),
+    auxiliary_head=dict(num_classes=16))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_loveda-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_loveda-512x512.py
new file mode 100644
index 0000000..64e262c
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_loveda-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/deeplabv3plus_r50-d8.py', '../_base_/datasets/loveda.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=7),
+    auxiliary_head=dict(num_classes=7))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_pascal-context-480x480.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_pascal-context-480x480.py
new file mode 100644
index 0000000..5ff7fcb
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_pascal-context-480x480.py
@@ -0,0 +1,14 @@
+_base_ = [
+    '../_base_/models/deeplabv3plus_r50-d8.py',
+    '../_base_/datasets/pascal_context.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (480, 480)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=60),
+    auxiliary_head=dict(num_classes=60),
+    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
+optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_pascal-context-59-480x480.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_pascal-context-59-480x480.py
new file mode 100644
index 0000000..84aaf25
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_pascal-context-59-480x480.py
@@ -0,0 +1,14 @@
+_base_ = [
+    '../_base_/models/deeplabv3plus_r50-d8.py',
+    '../_base_/datasets/pascal_context_59.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (480, 480)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=59),
+    auxiliary_head=dict(num_classes=59),
+    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
+optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_potsdam-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_potsdam-512x512.py
new file mode 100644
index 0000000..5810d6b
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_potsdam-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/deeplabv3plus_r50-d8.py',
+    '../_base_/datasets/potsdam.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=6),
+    auxiliary_head=dict(num_classes=6))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_vaihingen-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_vaihingen-512x512.py
new file mode 100644
index 0000000..a7f4b2d
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_vaihingen-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/deeplabv3plus_r50-d8.py',
+    '../_base_/datasets/vaihingen.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=6),
+    auxiliary_head=dict(num_classes=6))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..3e28135
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='torchvision://resnet50', backbone=dict(type='ResNet'))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..6366bd4
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(pretrained='torchvision://resnet50', backbone=dict(type='ResNet'))
diff --git a/mmsegmentation/configs/deeplabv3plus/metafile.yaml b/mmsegmentation/configs/deeplabv3plus/metafile.yaml
new file mode 100644
index 0000000..b41de4d
--- /dev/null
+++ b/mmsegmentation/configs/deeplabv3plus/metafile.yaml
@@ -0,0 +1,1041 @@
+Collections:
+- Name: DeepLabV3+
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+    - ADE20K
+    - Pascal VOC 2012 + Aug
+    - Pascal Context
+    - Pascal Context 59
+    - LoveDA
+    - Potsdam
+    - Vaihingen
+    - iSAID
+    - Mapillary Vistas v1.2
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  README: configs/deeplabv3plus/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.61
+      mIoU(ms+flip): 81.01
+  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 7.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_40k_cityscapes/deeplabv3plus_r50-d8_512x1024_40k_cityscapes_20200605_094610-d222ffcd.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_40k_cityscapes/deeplabv3plus_r50-d8_512x1024_40k_cityscapes_20200605_094610.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r101-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 80.21
+      mIoU(ms+flip): 81.82
+  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 11.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_40k_cityscapes/deeplabv3plus_r101-d8_512x1024_40k_cityscapes_20200605_094614-3769eecf.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_40k_cityscapes/deeplabv3plus_r101-d8_512x1024_40k_cityscapes_20200605_094614.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r50-d8_4xb2-40k_cityscapes-769x769
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.97
+      mIoU(ms+flip): 80.46
+  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_769x769_40k_cityscapes/deeplabv3plus_r50-d8_769x769_40k_cityscapes_20200606_114143-1dcb0e3c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_769x769_40k_cityscapes/deeplabv3plus_r50-d8_769x769_40k_cityscapes_20200606_114143.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r101-d8_4xb2-40k_cityscapes-769x769
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.46
+      mIoU(ms+flip): 80.5
+  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 12.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_769x769_40k_cityscapes/deeplabv3plus_r101-d8_769x769_40k_cityscapes_20200606_114304-ff414b9e.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_769x769_40k_cityscapes/deeplabv3plus_r101-d8_769x769_40k_cityscapes_20200606_114304.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r18-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.89
+      mIoU(ms+flip): 78.76
+  Config: configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-18-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 2.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x1024_80k_cityscapes/deeplabv3plus_r18-d8_512x1024_80k_cityscapes_20201226_080942-cff257fe.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x1024_80k_cityscapes/deeplabv3plus_r18-d8_512x1024_80k_cityscapes-20201226_080942.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 80.09
+      mIoU(ms+flip): 81.13
+  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_80k_cityscapes/deeplabv3plus_r50-d8_512x1024_80k_cityscapes_20200606_114049-f9fb496d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_80k_cityscapes/deeplabv3plus_r50-d8_512x1024_80k_cityscapes_20200606_114049.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 80.97
+      mIoU(ms+flip): 82.03
+  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_80k_cityscapes/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143-068fcfe9.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_80k_cityscapes/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r101-d8_4xb2-amp-80k_cityscapes-512x1024
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 80.46
+  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - DeepLabV3+
+    - (FP16)
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.35
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230920-f1104f4b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230920.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r18-d8_4xb2-80k_cityscapes-769x769
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.26
+      mIoU(ms+flip): 77.91
+  Config: configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-18-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 2.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_769x769_80k_cityscapes/deeplabv3plus_r18-d8_769x769_80k_cityscapes_20201226_083346-f326e06a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_769x769_80k_cityscapes/deeplabv3plus_r18-d8_769x769_80k_cityscapes-20201226_083346.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.83
+      mIoU(ms+flip): 81.48
+  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_769x769_80k_cityscapes/deeplabv3plus_r50-d8_769x769_80k_cityscapes_20200606_210233-0e9dfdc4.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_769x769_80k_cityscapes/deeplabv3plus_r50-d8_769x769_80k_cityscapes_20200606_210233.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r101-d8_4xb2-80k_cityscapes-769x769
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 80.65
+      mIoU(ms+flip): 81.47
+  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_769x769_80k_cityscapes/deeplabv3plus_r101-d8_769x769_80k_cityscapes_20220406_154720-dfcc0b68.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_769x769_80k_cityscapes/deeplabv3plus_r101-d8_769x769_80k_cityscapes_20220406_154720.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: ddeeplabv3plus_r101-d16-mg124_4xb2-40k_cityscapes-512x1024
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.09
+      mIoU(ms+flip): 80.36
+  Config: configs/deeplabv3plus/ddeeplabv3plus_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D16-MG124
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d16-mg124_512x1024_40k_cityscapes/deeplabv3plus_r101-d16-mg124_512x1024_40k_cityscapes_20200908_005644-cf9ce186.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d16-mg124_512x1024_40k_cityscapes/deeplabv3plus_r101-d16-mg124_512x1024_40k_cityscapes-20200908_005644.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r101-d16-mg124_4xb2-80k_cityscapes-512x1024
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.9
+      mIoU(ms+flip): 81.33
+  Config: configs/deeplabv3plus/deeplabv3plus_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D16-MG124
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d16-mg124_512x1024_80k_cityscapes/deeplabv3plus_r101-d16-mg124_512x1024_80k_cityscapes_20200908_005644-ee6158e0.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d16-mg124_512x1024_80k_cityscapes/deeplabv3plus_r101-d16-mg124_512x1024_80k_cityscapes-20200908_005644.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 75.87
+      mIoU(ms+flip): 77.52
+  Config: configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-18b-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 2.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18b-d8_512x1024_80k_cityscapes/deeplabv3plus_r18b-d8_512x1024_80k_cityscapes_20201226_090828-e451abd9.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18b-d8_512x1024_80k_cityscapes/deeplabv3plus_r18b-d8_512x1024_80k_cityscapes-20201226_090828.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 80.28
+      mIoU(ms+flip): 81.44
+  Config: configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50b-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 7.4
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50b-d8_512x1024_80k_cityscapes/deeplabv3plus_r50b-d8_512x1024_80k_cityscapes_20201225_213645-a97e4e43.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50b-d8_512x1024_80k_cityscapes/deeplabv3plus_r50b-d8_512x1024_80k_cityscapes-20201225_213645.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 80.16
+      mIoU(ms+flip): 81.41
+  Config: configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101b-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101b-d8_512x1024_80k_cityscapes/deeplabv3plus_r101b-d8_512x1024_80k_cityscapes_20201226_190843-9c3c93a4.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101b-d8_512x1024_80k_cityscapes/deeplabv3plus_r101b-d8_512x1024_80k_cityscapes-20201226_190843.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-769x769
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.36
+      mIoU(ms+flip): 78.24
+  Config: configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-18b-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 2.4
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18b-d8_769x769_80k_cityscapes/deeplabv3plus_r18b-d8_769x769_80k_cityscapes_20201226_151312-2c868aff.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18b-d8_769x769_80k_cityscapes/deeplabv3plus_r18b-d8_769x769_80k_cityscapes-20201226_151312.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-769x769
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.41
+      mIoU(ms+flip): 80.56
+  Config: configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50b-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.4
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50b-d8_769x769_80k_cityscapes/deeplabv3plus_r50b-d8_769x769_80k_cityscapes_20201225_224655-8b596d1c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50b-d8_769x769_80k_cityscapes/deeplabv3plus_r50b-d8_769x769_80k_cityscapes-20201225_224655.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-769x769
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.88
+      mIoU(ms+flip): 81.46
+  Config: configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101b-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 12.3
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101b-d8_769x769_80k_cityscapes/deeplabv3plus_r101b-d8_769x769_80k_cityscapes_20201226_205041-227cdf7c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101b-d8_769x769_80k_cityscapes/deeplabv3plus_r101b-d8_769x769_80k_cityscapes-20201226_205041.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r50-d8_4xb4-80k_ade20k-512x512
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.72
+      mIoU(ms+flip): 43.75
+  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_ade20k/deeplabv3plus_r50-d8_512x512_80k_ade20k_20200614_185028-bf1400d8.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_ade20k/deeplabv3plus_r50-d8_512x512_80k_ade20k_20200614_185028.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 44.6
+      mIoU(ms+flip): 46.06
+  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 14.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_ade20k/deeplabv3plus_r101-d8_512x512_80k_ade20k_20200615_014139-d5730af7.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_ade20k/deeplabv3plus_r101-d8_512x512_80k_ade20k_20200615_014139.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r50-d8_4xb4-160k_ade20k-512x512
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 43.95
+      mIoU(ms+flip): 44.93
+  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_160k_ade20k/deeplabv3plus_r50-d8_512x512_160k_ade20k_20200615_124504-6135c7e0.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_160k_ade20k/deeplabv3plus_r50-d8_512x512_160k_ade20k_20200615_124504.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 45.47
+      mIoU(ms+flip): 46.35
+  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_160k_ade20k/deeplabv3plus_r101-d8_512x512_160k_ade20k_20200615_123232-38ed86bb.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_160k_ade20k/deeplabv3plus_r101-d8_512x512_160k_ade20k_20200615_123232.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r50-d8_4xb4-20k_voc12aug-512x512
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 75.93
+      mIoU(ms+flip): 77.5
+  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 7.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_20k_voc12aug/deeplabv3plus_r50-d8_512x512_20k_voc12aug_20200617_102323-aad58ef1.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_20k_voc12aug/deeplabv3plus_r50-d8_512x512_20k_voc12aug_20200617_102323.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r101-d8_4xb4-20k_voc12aug-512x512
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 77.22
+      mIoU(ms+flip): 78.59
+  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 11.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_20k_voc12aug/deeplabv3plus_r101-d8_512x512_20k_voc12aug_20200617_102345-c7ff3d56.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_20k_voc12aug/deeplabv3plus_r101-d8_512x512_20k_voc12aug_20200617_102345.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r50-d8_4xb4-40k_voc12aug-512x512
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 76.81
+      mIoU(ms+flip): 77.57
+  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_40k_voc12aug/deeplabv3plus_r50-d8_512x512_40k_voc12aug_20200613_161759-e1b43aa9.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_40k_voc12aug/deeplabv3plus_r50-d8_512x512_40k_voc12aug_20200613_161759.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r101-d8_4xb4-40k_voc12aug-512x512
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 78.62
+      mIoU(ms+flip): 79.53
+  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_40k_voc12aug/deeplabv3plus_r101-d8_512x512_40k_voc12aug_20200613_205333-faf03387.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_40k_voc12aug/deeplabv3plus_r101-d8_512x512_40k_voc12aug_20200613_205333.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r50-d8_4xb4-40k_pascal-context-480x480
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal Context
+    Metrics:
+      mIoU: 47.3
+      mIoU(ms+flip): 48.47
+  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_pascal-context-480x480.py
+  Metadata:
+    Training Data: Pascal Context
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_40k_pascal_context/deeplabv3plus_r101-d8_480x480_40k_pascal_context_20200911_165459-d3c8a29e.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_40k_pascal_context/deeplabv3plus_r101-d8_480x480_40k_pascal_context-20200911_165459.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r50-d8_4xb4-80k_pascal-context-480x480
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal Context
+    Metrics:
+      mIoU: 47.23
+      mIoU(ms+flip): 48.26
+  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_pascal-context-480x480.py
+  Metadata:
+    Training Data: Pascal Context
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_80k_pascal_context/deeplabv3plus_r101-d8_480x480_80k_pascal_context_20200911_155322-145d3ee8.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_80k_pascal_context/deeplabv3plus_r101-d8_480x480_80k_pascal_context-20200911_155322.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r101-d8_4xb4-40k_pascal-context-59-480x480
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal Context 59
+    Metrics:
+      mIoU: 52.86
+      mIoU(ms+flip): 54.54
+  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_pascal-context-59-480x480.py
+  Metadata:
+    Training Data: Pascal Context 59
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_40k_pascal_context_59/deeplabv3plus_r101-d8_480x480_40k_pascal_context_59_20210416_111233-ed937f15.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_40k_pascal_context_59/deeplabv3plus_r101-d8_480x480_40k_pascal_context_59-20210416_111233.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r101-d8_4xb4-80k_pascal-context-59-480x480
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal Context 59
+    Metrics:
+      mIoU: 53.2
+      mIoU(ms+flip): 54.67
+  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_pascal-context-59-480x480.py
+  Metadata:
+    Training Data: Pascal Context 59
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_80k_pascal_context_59/deeplabv3plus_r101-d8_480x480_80k_pascal_context_59_20210416_111127-7ca0331d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_80k_pascal_context_59/deeplabv3plus_r101-d8_480x480_80k_pascal_context_59-20210416_111127.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r18-d8_4xb4-80k_loveda-512x512
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: LoveDA
+    Metrics:
+      mIoU: 50.28
+      mIoU(ms+flip): 50.47
+  Config: configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_loveda-512x512.py
+  Metadata:
+    Training Data: LoveDA
+    Batch Size: 16
+    Architecture:
+    - R-18-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.93
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x512_80k_loveda/deeplabv3plus_r18-d8_512x512_80k_loveda_20211104_132800-ce0fa0ca.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x512_80k_loveda/deeplabv3plus_r18-d8_512x512_80k_loveda_20211104_132800.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r50-d8_4xb4-80k_loveda-512x512
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: LoveDA
+    Metrics:
+      mIoU: 50.99
+      mIoU(ms+flip): 50.65
+  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_loveda-512x512.py
+  Metadata:
+    Training Data: LoveDA
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 7.37
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_loveda/deeplabv3plus_r50-d8_512x512_80k_loveda_20211105_080442-f0720392.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_loveda/deeplabv3plus_r50-d8_512x512_80k_loveda_20211105_080442.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r101-d8_4xb4-80k_loveda-512x512
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: LoveDA
+    Metrics:
+      mIoU: 51.47
+      mIoU(ms+flip): 51.32
+  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_loveda-512x512.py
+  Metadata:
+    Training Data: LoveDA
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.84
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_loveda/deeplabv3plus_r101-d8_512x512_80k_loveda_20211105_110759-4c1f297e.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_loveda/deeplabv3plus_r101-d8_512x512_80k_loveda_20211105_110759.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r18-d8_4xb4-80k_potsdam-512x512
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Potsdam
+    Metrics:
+      mIoU: 77.09
+      mIoU(ms+flip): 78.44
+  Config: configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_potsdam-512x512.py
+  Metadata:
+    Training Data: Potsdam
+    Batch Size: 16
+    Architecture:
+    - R-18-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.91
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x512_80k_potsdam/deeplabv3plus_r18-d8_512x512_80k_potsdam_20211219_020601-75fd5bc3.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x512_80k_potsdam/deeplabv3plus_r18-d8_512x512_80k_potsdam_20211219_020601.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r50-d8_4xb4-80k_potsdam-512x512
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Potsdam
+    Metrics:
+      mIoU: 78.33
+      mIoU(ms+flip): 79.27
+  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_potsdam-512x512.py
+  Metadata:
+    Training Data: Potsdam
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 7.36
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_potsdam/deeplabv3plus_r50-d8_512x512_80k_potsdam_20211219_031508-7e7a2b24.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_potsdam/deeplabv3plus_r50-d8_512x512_80k_potsdam_20211219_031508.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Potsdam
+    Metrics:
+      mIoU: 78.7
+      mIoU(ms+flip): 79.47
+  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py
+  Metadata:
+    Training Data: Potsdam
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.83
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_potsdam/deeplabv3plus_r101-d8_512x512_80k_potsdam_20211219_031508-8b112708.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_potsdam/deeplabv3plus_r101-d8_512x512_80k_potsdam_20211219_031508.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r18-d8_4xb4-80k_vaihingen-512x512
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Vaihingen
+    Metrics:
+      mIoU: 72.5
+      mIoU(ms+flip): 74.13
+  Config: configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_vaihingen-512x512.py
+  Metadata:
+    Training Data: Vaihingen
+    Batch Size: 16
+    Architecture:
+    - R-18-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.91
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r18-d8_4x4_512x512_80k_vaihingen_20211231_230805-7626a263.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r18-d8_4x4_512x512_80k_vaihingen_20211231_230805.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r50-d8_4xb4-80k_vaihingen-512x512
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Vaihingen
+    Metrics:
+      mIoU: 73.97
+      mIoU(ms+flip): 75.05
+  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_vaihingen-512x512.py
+  Metadata:
+    Training Data: Vaihingen
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 7.36
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r50-d8_4x4_512x512_80k_vaihingen_20211231_230816-5040938d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r50-d8_4x4_512x512_80k_vaihingen_20211231_230816.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r101-d8_4xb4-80k_vaihingen-512x512
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Vaihingen
+    Metrics:
+      mIoU: 73.06
+      mIoU(ms+flip): 74.14
+  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_vaihingen-512x512.py
+  Metadata:
+    Training Data: Vaihingen
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.83
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r101-d8_4x4_512x512_80k_vaihingen_20211231_230816-8a095afa.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r101-d8_4x4_512x512_80k_vaihingen_20211231_230816.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r18-d8_4xb4-80k_isaid-896x896
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: iSAID
+    Metrics:
+      mIoU: 61.35
+      mIoU(ms+flip): 62.61
+  Config: configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_isaid-896x896.py
+  Metadata:
+    Training Data: iSAID
+    Batch Size: 16
+    Architecture:
+    - R-18-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.19
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_4x4_896x896_80k_isaid/deeplabv3plus_r18-d8_4x4_896x896_80k_isaid_20220110_180526-7059991d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_4x4_896x896_80k_isaid/deeplabv3plus_r18-d8_4x4_896x896_80k_isaid_20220110_180526.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r50-d8_4xb4-80k_isaid-896x896
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: iSAID
+    Metrics:
+      mIoU: 67.06
+      mIoU(ms+flip): 68.02
+  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_isaid-896x896.py
+  Metadata:
+    Training Data: iSAID
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 21.45
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4x4_896x896_80k_isaid/deeplabv3plus_r50-d8_4x4_896x896_80k_isaid_20220110_180526-598be439.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4x4_896x896_80k_isaid/deeplabv3plus_r50-d8_4x4_896x896_80k_isaid_20220110_180526.log.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
+- Name: deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Mapillary Vistas v1.2
+    Metrics:
+      mIoU: 47.35
+  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280.py
+  Metadata:
+    Training Data: Mapillary Vistas v1.2
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - DeepLabV3+
+    Training Resources: 4x A100 GPUS
+    Memory (GB): 24.04
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280_20230301_110504-655f8e43.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280_20230301_110504.json
+  Paper:
+    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
+    URL: https://arxiv.org/abs/1802.02611
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/dmnet/README.md b/mmsegmentation/configs/dmnet/README.md
new file mode 100644
index 0000000..b0cf944
--- /dev/null
+++ b/mmsegmentation/configs/dmnet/README.md
@@ -0,0 +1,59 @@
+# DMNet
+
+> [Dynamic Multi-scale Filters for Semantic Segmentation](https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/Junjun2016/DMNet">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Multi-scale representation provides an effective way toaddress scale variation of objects and stuff in semantic seg-mentation. Previous works construct multi-scale represen-tation by utilizing different filter sizes, expanding filter sizeswith dilated filters or pooling grids, and the parameters ofthese filters are fixed after training. These methods oftensuffer from heavy computational cost or have more param-eters, and are not adaptive to the input image during in-ference. To address these problems, this paper proposes aDynamic Multi-scale Network (DMNet) to adaptively cap-ture multi-scale contents for predicting pixel-level semanticlabels. DMNet is composed of multiple Dynamic Convolu-tional Modules (DCMs) arranged in parallel, each of whichexploits context-aware filters to estimate semantic represen-tation for a specific scale. The outputs of multiple DCMsare further integrated for final segmentation. We conductextensive experiments to evaluate our DMNet on three chal-lenging semantic segmentation and scene parsing datasets,PASCAL VOC 2012, Pascal-Context, and ADE20K. DMNetachieves a new record 84.4% mIoU on PASCAL VOC 2012test set without MS COCO pre-trained and post-processing,and also obtains state-of-the-art performance on Pascal-Context and ADE20K.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142900781-6215763f-8b71-4e0b-a6b1-c41372db2aa0.png" width="70%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                       | download                                                                                                                                                                                                                                                                                                                                           |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ---------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DMNet  | R-50-D8  | 512x1024  |   40000 | 7.0      | 3.66           | V100   | 77.78 |         79.14 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x1024_40k_cityscapes/dmnet_r50-d8_512x1024_40k_cityscapes_20201215_042326-615373cf.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x1024_40k_cityscapes/dmnet_r50-d8_512x1024_40k_cityscapes-20201215_042326.log.json)     |
+| DMNet  | R-101-D8 | 512x1024  |   40000 | 10.6     | 2.54           | V100   | 78.37 |         79.72 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x1024_40k_cityscapes/dmnet_r101-d8_512x1024_40k_cityscapes_20201215_043100-8291e976.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x1024_40k_cityscapes/dmnet_r101-d8_512x1024_40k_cityscapes-20201215_043100.log.json) |
+| DMNet  | R-50-D8  | 769x769   |   40000 | 7.9      | 1.57           | V100   | 78.49 |         80.27 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_769x769_40k_cityscapes/dmnet_r50-d8_769x769_40k_cityscapes_20201215_093706-e7f0e23e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_769x769_40k_cityscapes/dmnet_r50-d8_769x769_40k_cityscapes-20201215_093706.log.json)         |
+| DMNet  | R-101-D8 | 769x769   |   40000 | 12.0     | 1.01           | V100   | 77.62 |         78.94 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_769x769_40k_cityscapes/dmnet_r101-d8_769x769_40k_cityscapes_20201215_081348-a74261f6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_769x769_40k_cityscapes/dmnet_r101-d8_769x769_40k_cityscapes-20201215_081348.log.json)     |
+| DMNet  | R-50-D8  | 512x1024  |   80000 | -        | -              | V100   | 79.07 |         80.22 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x1024_80k_cityscapes/dmnet_r50-d8_512x1024_80k_cityscapes_20201215_053728-3c8893b9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x1024_80k_cityscapes/dmnet_r50-d8_512x1024_80k_cityscapes-20201215_053728.log.json)     |
+| DMNet  | R-101-D8 | 512x1024  |   80000 | -        | -              | V100   | 79.64 |         80.67 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x1024_80k_cityscapes/dmnet_r101-d8_512x1024_80k_cityscapes_20201215_031718-fa081cb8.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x1024_80k_cityscapes/dmnet_r101-d8_512x1024_80k_cityscapes-20201215_031718.log.json) |
+| DMNet  | R-50-D8  | 769x769   |   80000 | -        | -              | V100   | 79.22 |         80.55 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_769x769_80k_cityscapes/dmnet_r50-d8_769x769_80k_cityscapes_20201215_034006-6060840e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_769x769_80k_cityscapes/dmnet_r50-d8_769x769_80k_cityscapes-20201215_034006.log.json)         |
+| DMNet  | R-101-D8 | 769x769   |   80000 | -        | -              | V100   | 79.19 |         80.65 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_769x769_80k_cityscapes/dmnet_r101-d8_769x769_80k_cityscapes_20201215_082810-7f0de59a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_769x769_80k_cityscapes/dmnet_r101-d8_769x769_80k_cityscapes-20201215_082810.log.json)     |
+
+### ADE20K
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                   | download                                                                                                                                                                                                                                                                                                                           |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DMNet  | R-50-D8  | 512x512   |   80000 | 9.4      | 20.95          | V100   | 42.37 |         43.62 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x512_80k_ade20k/dmnet_r50-d8_512x512_80k_ade20k_20201215_144744-f89092a6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x512_80k_ade20k/dmnet_r50-d8_512x512_80k_ade20k-20201215_144744.log.json)         |
+| DMNet  | R-101-D8 | 512x512   |   80000 | 13.0     | 13.88          | V100   | 45.34 |         46.13 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x512_80k_ade20k/dmnet_r101-d8_512x512_80k_ade20k_20201215_104812-bfa45311.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x512_80k_ade20k/dmnet_r101-d8_512x512_80k_ade20k-20201215_104812.log.json)     |
+| DMNet  | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 43.15 |         44.17 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x512_160k_ade20k/dmnet_r50-d8_512x512_160k_ade20k_20201215_115313-025ab3f9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x512_160k_ade20k/dmnet_r50-d8_512x512_160k_ade20k-20201215_115313.log.json)     |
+| DMNet  | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 45.42 |         46.76 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x512_160k_ade20k/dmnet_r101-d8_512x512_160k_ade20k_20201215_111145-a0bc02ef.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x512_160k_ade20k/dmnet_r101-d8_512x512_160k_ade20k-20201215_111145.log.json) |
+
+## Citation
+
+```bibtex
+@InProceedings{He_2019_ICCV,
+author = {He, Junjun and Deng, Zhongying and Qiao, Yu},
+title = {Dynamic Multi-Scale Filters for Semantic Segmentation},
+booktitle = {Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV)},
+month = {October},
+year = {2019}
+}
+```
diff --git a/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..9832b62
--- /dev/null
+++ b/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './dmnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..03346c5
--- /dev/null
+++ b/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './dmnet_r50-d8_4xb2-40k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..fd7e9ac
--- /dev/null
+++ b/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './dmnet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..2205e60
--- /dev/null
+++ b/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './dmnet_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..23e215b
--- /dev/null
+++ b/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './dmnet_r50-d8_4xb4-160k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..5c25587
--- /dev/null
+++ b/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './dmnet_r50-d8_4xb4-80k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..aa86b01
--- /dev/null
+++ b/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/dmnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..8c2dbf3
--- /dev/null
+++ b/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/dmnet_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..bc21606
--- /dev/null
+++ b/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/dmnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..e32ae71
--- /dev/null
+++ b/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/dmnet_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..71d0a04
--- /dev/null
+++ b/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/dmnet_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..727bed0
--- /dev/null
+++ b/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/dmnet_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/dmnet/metafile.yaml b/mmsegmentation/configs/dmnet/metafile.yaml
new file mode 100644
index 0000000..7f5e536
--- /dev/null
+++ b/mmsegmentation/configs/dmnet/metafile.yaml
@@ -0,0 +1,296 @@
+Collections:
+- Name: DMNet
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+    - ADE20K
+  Paper:
+    Title: Dynamic Multi-scale Filters for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
+  README: configs/dmnet/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: dmnet_r50-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: DMNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.78
+      mIoU(ms+flip): 79.14
+  Config: configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - DMNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 7.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x1024_40k_cityscapes/dmnet_r50-d8_512x1024_40k_cityscapes_20201215_042326-615373cf.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x1024_40k_cityscapes/dmnet_r50-d8_512x1024_40k_cityscapes-20201215_042326.log.json
+  Paper:
+    Title: Dynamic Multi-scale Filters for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
+  Framework: PyTorch
+- Name: dmnet_r101-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: DMNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.37
+      mIoU(ms+flip): 79.72
+  Config: configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - DMNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x1024_40k_cityscapes/dmnet_r101-d8_512x1024_40k_cityscapes_20201215_043100-8291e976.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x1024_40k_cityscapes/dmnet_r101-d8_512x1024_40k_cityscapes-20201215_043100.log.json
+  Paper:
+    Title: Dynamic Multi-scale Filters for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
+  Framework: PyTorch
+- Name: dmnet_r50-d8_4xb2-40k_cityscapes-769x769
+  In Collection: DMNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.49
+      mIoU(ms+flip): 80.27
+  Config: configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - DMNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 7.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_769x769_40k_cityscapes/dmnet_r50-d8_769x769_40k_cityscapes_20201215_093706-e7f0e23e.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_769x769_40k_cityscapes/dmnet_r50-d8_769x769_40k_cityscapes-20201215_093706.log.json
+  Paper:
+    Title: Dynamic Multi-scale Filters for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
+  Framework: PyTorch
+- Name: dmnet_r101-d8_4xb2-40k_cityscapes-769x769
+  In Collection: DMNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.62
+      mIoU(ms+flip): 78.94
+  Config: configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - DMNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 12.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_769x769_40k_cityscapes/dmnet_r101-d8_769x769_40k_cityscapes_20201215_081348-a74261f6.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_769x769_40k_cityscapes/dmnet_r101-d8_769x769_40k_cityscapes-20201215_081348.log.json
+  Paper:
+    Title: Dynamic Multi-scale Filters for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
+  Framework: PyTorch
+- Name: dmnet_r50-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: DMNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.07
+      mIoU(ms+flip): 80.22
+  Config: configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - DMNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x1024_80k_cityscapes/dmnet_r50-d8_512x1024_80k_cityscapes_20201215_053728-3c8893b9.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x1024_80k_cityscapes/dmnet_r50-d8_512x1024_80k_cityscapes-20201215_053728.log.json
+  Paper:
+    Title: Dynamic Multi-scale Filters for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
+  Framework: PyTorch
+- Name: dmnet_r101-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: DMNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.64
+      mIoU(ms+flip): 80.67
+  Config: configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - DMNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x1024_80k_cityscapes/dmnet_r101-d8_512x1024_80k_cityscapes_20201215_031718-fa081cb8.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x1024_80k_cityscapes/dmnet_r101-d8_512x1024_80k_cityscapes-20201215_031718.log.json
+  Paper:
+    Title: Dynamic Multi-scale Filters for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
+  Framework: PyTorch
+- Name: dmnet_r50-d8_4xb2-80k_cityscapes-769x769
+  In Collection: DMNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.22
+      mIoU(ms+flip): 80.55
+  Config: configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - DMNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_769x769_80k_cityscapes/dmnet_r50-d8_769x769_80k_cityscapes_20201215_034006-6060840e.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_769x769_80k_cityscapes/dmnet_r50-d8_769x769_80k_cityscapes-20201215_034006.log.json
+  Paper:
+    Title: Dynamic Multi-scale Filters for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
+  Framework: PyTorch
+- Name: dmnet_r101-d8_4xb2-80k_cityscapes-769x769
+  In Collection: DMNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.19
+      mIoU(ms+flip): 80.65
+  Config: configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - DMNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_769x769_80k_cityscapes/dmnet_r101-d8_769x769_80k_cityscapes_20201215_082810-7f0de59a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_769x769_80k_cityscapes/dmnet_r101-d8_769x769_80k_cityscapes-20201215_082810.log.json
+  Paper:
+    Title: Dynamic Multi-scale Filters for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
+  Framework: PyTorch
+- Name: dmnet_r50-d8_4xb4-80k_ade20k-512x512
+  In Collection: DMNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.37
+      mIoU(ms+flip): 43.62
+  Config: configs/dmnet/dmnet_r50-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DMNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.4
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x512_80k_ade20k/dmnet_r50-d8_512x512_80k_ade20k_20201215_144744-f89092a6.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x512_80k_ade20k/dmnet_r50-d8_512x512_80k_ade20k-20201215_144744.log.json
+  Paper:
+    Title: Dynamic Multi-scale Filters for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
+  Framework: PyTorch
+- Name: dmnet_r101-d8_4xb4-80k_ade20k-512x512
+  In Collection: DMNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 45.34
+      mIoU(ms+flip): 46.13
+  Config: configs/dmnet/dmnet_r101-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DMNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 13.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x512_80k_ade20k/dmnet_r101-d8_512x512_80k_ade20k_20201215_104812-bfa45311.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x512_80k_ade20k/dmnet_r101-d8_512x512_80k_ade20k-20201215_104812.log.json
+  Paper:
+    Title: Dynamic Multi-scale Filters for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
+  Framework: PyTorch
+- Name: dmnet_r50-d8_4xb4-160k_ade20k-512x512
+  In Collection: DMNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 43.15
+      mIoU(ms+flip): 44.17
+  Config: configs/dmnet/dmnet_r50-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DMNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x512_160k_ade20k/dmnet_r50-d8_512x512_160k_ade20k_20201215_115313-025ab3f9.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x512_160k_ade20k/dmnet_r50-d8_512x512_160k_ade20k-20201215_115313.log.json
+  Paper:
+    Title: Dynamic Multi-scale Filters for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
+  Framework: PyTorch
+- Name: dmnet_r101-d8_4xb4-160k_ade20k-512x512
+  In Collection: DMNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 45.42
+      mIoU(ms+flip): 46.76
+  Config: configs/dmnet/dmnet_r101-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DMNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x512_160k_ade20k/dmnet_r101-d8_512x512_160k_ade20k_20201215_111145-a0bc02ef.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x512_160k_ade20k/dmnet_r101-d8_512x512_160k_ade20k-20201215_111145.log.json
+  Paper:
+    Title: Dynamic Multi-scale Filters for Semantic Segmentation
+    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/dnlnet/README.md b/mmsegmentation/configs/dnlnet/README.md
new file mode 100644
index 0000000..6835ffd
--- /dev/null
+++ b/mmsegmentation/configs/dnlnet/README.md
@@ -0,0 +1,62 @@
+# DNLNet
+
+> [Disentangled Non-Local Neural Networks](https://arxiv.org/abs/2006.06668)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/yinmh17/DNL-Semantic-Segmentation">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+The non-local block is a popular module for strengthening the context modeling ability of a regular convolutional neural network. This paper first studies the non-local block in depth, where we find that its attention computation can be split into two terms, a whitened pairwise term accounting for the relationship between two pixels and a unary term representing the saliency of every pixel. We also observe that the two terms trained alone tend to model different visual clues, e.g. the whitened pairwise term learns within-region relationships while the unary term learns salient boundaries. However, the two terms are tightly coupled in the non-local block, which hinders the learning of each. Based on these findings, we present the disentangled non-local block, where the two terms are decoupled to facilitate learning for both terms. We demonstrate the effectiveness of the decoupled design on various tasks, such as semantic segmentation on Cityscapes, ADE20K and PASCAL Context, object detection on COCO, and action recognition on Kinetics.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142900944-b8d93301-d2ce-488e-a461-b0813f96be49.png" width="70%"/>
+</div>
+
+## Results and models (in progress)
+
+### Cityscapes
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                      | download                                                                                                                                                                                                                                                                                                                                     |
+| ------ | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | --------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DNLNet | R-50-D8  | 512x1024  |   40000 |      7.3 | 2.56           | V100   | 78.61 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x1024_40k_cityscapes/dnl_r50-d8_512x1024_40k_cityscapes_20200904_233629-53d4ea93.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x1024_40k_cityscapes/dnl_r50-d8_512x1024_40k_cityscapes-20200904_233629.log.json)     |
+| DNLNet | R-101-D8 | 512x1024  |   40000 |     10.9 | 1.96           | V100   | 78.31 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x1024_40k_cityscapes/dnl_r101-d8_512x1024_40k_cityscapes_20200904_233629-9928ffef.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x1024_40k_cityscapes/dnl_r101-d8_512x1024_40k_cityscapes-20200904_233629.log.json) |
+| DNLNet | R-50-D8  | 769x769   |   40000 |      9.2 | 1.50           | V100   | 78.44 | 80.27         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_769x769_40k_cityscapes/dnl_r50-d8_769x769_40k_cityscapes_20200820_232206-0f283785.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_769x769_40k_cityscapes/dnl_r50-d8_769x769_40k_cityscapes-20200820_232206.log.json)         |
+| DNLNet | R-101-D8 | 769x769   |   40000 |     12.6 | 1.02           | V100   | 76.39 | 77.77         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_769x769_40k_cityscapes/dnl_r101-d8_769x769_40k_cityscapes_20200820_171256-76c596df.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_769x769_40k_cityscapes/dnl_r101-d8_769x769_40k_cityscapes-20200820_171256.log.json)     |
+| DNLNet | R-50-D8  | 512x1024  |   80000 |        - | -              | V100   | 79.33 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x1024_80k_cityscapes/dnl_r50-d8_512x1024_80k_cityscapes_20200904_233629-58b2f778.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x1024_80k_cityscapes/dnl_r50-d8_512x1024_80k_cityscapes-20200904_233629.log.json)     |
+| DNLNet | R-101-D8 | 512x1024  |   80000 |        - | -              | V100   | 80.41 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x1024_80k_cityscapes/dnl_r101-d8_512x1024_80k_cityscapes_20200904_233629-758e2dd4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x1024_80k_cityscapes/dnl_r101-d8_512x1024_80k_cityscapes-20200904_233629.log.json) |
+| DNLNet | R-50-D8  | 769x769   |   80000 |        - | -              | V100   | 79.36 | 80.70         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_769x769_80k_cityscapes/dnl_r50-d8_769x769_80k_cityscapes_20200820_011925-366bc4c7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_769x769_80k_cityscapes/dnl_r50-d8_769x769_80k_cityscapes-20200820_011925.log.json)         |
+| DNLNet | R-101-D8 | 769x769   |   80000 |        - | -              | V100   | 79.41 | 80.68         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_769x769_80k_cityscapes/dnl_r101-d8_769x769_80k_cityscapes_20200821_051111-95ff84ab.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_769x769_80k_cityscapes/dnl_r101-d8_769x769_80k_cityscapes-20200821_051111.log.json)     |
+
+### ADE20K
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                  | download                                                                                                                                                                                                                                                                                                                     |
+| ------ | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | ----------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DNLNet | R-50-D8  | 512x512   |   80000 |      8.8 | 20.66          | V100   | 41.76 | 42.99         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x512_80k_ade20k/dnl_r50-d8_512x512_80k_ade20k_20200826_183354-1cf6e0c1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x512_80k_ade20k/dnl_r50-d8_512x512_80k_ade20k-20200826_183354.log.json)         |
+| DNLNet | R-101-D8 | 512x512   |   80000 |     12.8 | 12.54          | V100   | 43.76 | 44.91         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x512_80k_ade20k/dnl_r101-d8_512x512_80k_ade20k_20200826_183354-d820d6ea.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x512_80k_ade20k/dnl_r101-d8_512x512_80k_ade20k-20200826_183354.log.json)     |
+| DNLNet | R-50-D8  | 512x512   |  160000 |        - | -              | V100   | 41.87 | 43.01         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x512_160k_ade20k/dnl_r50-d8_512x512_160k_ade20k_20200826_183350-37837798.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x512_160k_ade20k/dnl_r50-d8_512x512_160k_ade20k-20200826_183350.log.json)     |
+| DNLNet | R-101-D8 | 512x512   |  160000 |        - | -              | V100   | 44.25 | 45.78         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x512_160k_ade20k/dnl_r101-d8_512x512_160k_ade20k_20200826_183350-ed522c61.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x512_160k_ade20k/dnl_r101-d8_512x512_160k_ade20k-20200826_183350.log.json) |
+
+## Notes
+
+This example is to reproduce ["Disentangled Non-Local Neural Networks"](https://arxiv.org/abs/2006.06668) for semantic segmentation. It is still in progress.
+
+## Citation
+
+```bibtex
+@misc{yin2020disentangled,
+    title={Disentangled Non-Local Neural Networks},
+    author={Minghao Yin and Zhuliang Yao and Yue Cao and Xiu Li and Zheng Zhang and Stephen Lin and Han Hu},
+    year={2020},
+    booktitle={ECCV}
+}
+```
diff --git a/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..310d84e
--- /dev/null
+++ b/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './dnl_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..a94dbb8
--- /dev/null
+++ b/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './dnl_r50-d8_4xb2-40k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..f9b6d5e
--- /dev/null
+++ b/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './dnl_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..9c7d557
--- /dev/null
+++ b/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './dnl_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..1edc26f
--- /dev/null
+++ b/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './dnl_r50-d8_4xb4-160k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..d29c17e
--- /dev/null
+++ b/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './dnl_r50-d8_4xb4-80k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..be38992
--- /dev/null
+++ b/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/dnl_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..9eaaa63
--- /dev/null
+++ b/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/dnl_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..2e43178
--- /dev/null
+++ b/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/dnl_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..cb379c1
--- /dev/null
+++ b/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,16 @@
+_base_ = [
+    '../_base_/models/dnl_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
+
+optim_wrapper = dict(
+    paramwise_cfg=dict(
+        custom_keys=dict(theta=dict(wd_mult=0.), phi=dict(wd_mult=0.))))
diff --git a/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..b2ae2a8
--- /dev/null
+++ b/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/dnl_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..f310a4e
--- /dev/null
+++ b/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/dnl_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/dnlnet/metafile.yaml b/mmsegmentation/configs/dnlnet/metafile.yaml
new file mode 100644
index 0000000..22e48d3
--- /dev/null
+++ b/mmsegmentation/configs/dnlnet/metafile.yaml
@@ -0,0 +1,292 @@
+Collections:
+- Name: DNLNet
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+    - ADE20K
+  Paper:
+    Title: Disentangled Non-Local Neural Networks
+    URL: https://arxiv.org/abs/2006.06668
+  README: configs/dnlnet/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: dnl_r50-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: DNLNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.61
+  Config: configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - DNLNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 7.3
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x1024_40k_cityscapes/dnl_r50-d8_512x1024_40k_cityscapes_20200904_233629-53d4ea93.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x1024_40k_cityscapes/dnl_r50-d8_512x1024_40k_cityscapes-20200904_233629.log.json
+  Paper:
+    Title: Disentangled Non-Local Neural Networks
+    URL: https://arxiv.org/abs/2006.06668
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
+  Framework: PyTorch
+- Name: dnl_r101-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: DNLNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.31
+  Config: configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - DNLNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x1024_40k_cityscapes/dnl_r101-d8_512x1024_40k_cityscapes_20200904_233629-9928ffef.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x1024_40k_cityscapes/dnl_r101-d8_512x1024_40k_cityscapes-20200904_233629.log.json
+  Paper:
+    Title: Disentangled Non-Local Neural Networks
+    URL: https://arxiv.org/abs/2006.06668
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
+  Framework: PyTorch
+- Name: dnl_r50-d8_4xb2-40k_cityscapes-769x769
+  In Collection: DNLNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.44
+      mIoU(ms+flip): 80.27
+  Config: configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - DNLNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_769x769_40k_cityscapes/dnl_r50-d8_769x769_40k_cityscapes_20200820_232206-0f283785.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_769x769_40k_cityscapes/dnl_r50-d8_769x769_40k_cityscapes-20200820_232206.log.json
+  Paper:
+    Title: Disentangled Non-Local Neural Networks
+    URL: https://arxiv.org/abs/2006.06668
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
+  Framework: PyTorch
+- Name: dnl_r101-d8_4xb2-40k_cityscapes-769x769
+  In Collection: DNLNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.39
+      mIoU(ms+flip): 77.77
+  Config: configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - DNLNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 12.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_769x769_40k_cityscapes/dnl_r101-d8_769x769_40k_cityscapes_20200820_171256-76c596df.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_769x769_40k_cityscapes/dnl_r101-d8_769x769_40k_cityscapes-20200820_171256.log.json
+  Paper:
+    Title: Disentangled Non-Local Neural Networks
+    URL: https://arxiv.org/abs/2006.06668
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
+  Framework: PyTorch
+- Name: dnl_r50-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: DNLNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.33
+  Config: configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - DNLNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x1024_80k_cityscapes/dnl_r50-d8_512x1024_80k_cityscapes_20200904_233629-58b2f778.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x1024_80k_cityscapes/dnl_r50-d8_512x1024_80k_cityscapes-20200904_233629.log.json
+  Paper:
+    Title: Disentangled Non-Local Neural Networks
+    URL: https://arxiv.org/abs/2006.06668
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
+  Framework: PyTorch
+- Name: dnl_r101-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: DNLNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 80.41
+  Config: configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - DNLNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x1024_80k_cityscapes/dnl_r101-d8_512x1024_80k_cityscapes_20200904_233629-758e2dd4.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x1024_80k_cityscapes/dnl_r101-d8_512x1024_80k_cityscapes-20200904_233629.log.json
+  Paper:
+    Title: Disentangled Non-Local Neural Networks
+    URL: https://arxiv.org/abs/2006.06668
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
+  Framework: PyTorch
+- Name: dnl_r50-d8_4xb2-80k_cityscapes-769x769
+  In Collection: DNLNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.36
+      mIoU(ms+flip): 80.7
+  Config: configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - DNLNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_769x769_80k_cityscapes/dnl_r50-d8_769x769_80k_cityscapes_20200820_011925-366bc4c7.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_769x769_80k_cityscapes/dnl_r50-d8_769x769_80k_cityscapes-20200820_011925.log.json
+  Paper:
+    Title: Disentangled Non-Local Neural Networks
+    URL: https://arxiv.org/abs/2006.06668
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
+  Framework: PyTorch
+- Name: dnl_r101-d8_4xb2-80k_cityscapes-769x769
+  In Collection: DNLNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.41
+      mIoU(ms+flip): 80.68
+  Config: configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - DNLNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_769x769_80k_cityscapes/dnl_r101-d8_769x769_80k_cityscapes_20200821_051111-95ff84ab.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_769x769_80k_cityscapes/dnl_r101-d8_769x769_80k_cityscapes-20200821_051111.log.json
+  Paper:
+    Title: Disentangled Non-Local Neural Networks
+    URL: https://arxiv.org/abs/2006.06668
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
+  Framework: PyTorch
+- Name: dnl_r50-d8_4xb4-80k_ade20k-512x512
+  In Collection: DNLNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 41.76
+      mIoU(ms+flip): 42.99
+  Config: configs/dnlnet/dnl_r50-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DNLNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x512_80k_ade20k/dnl_r50-d8_512x512_80k_ade20k_20200826_183354-1cf6e0c1.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x512_80k_ade20k/dnl_r50-d8_512x512_80k_ade20k-20200826_183354.log.json
+  Paper:
+    Title: Disentangled Non-Local Neural Networks
+    URL: https://arxiv.org/abs/2006.06668
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
+  Framework: PyTorch
+- Name: dnl_r101-d8_4xb4-80k_ade20k-512x512
+  In Collection: DNLNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 43.76
+      mIoU(ms+flip): 44.91
+  Config: configs/dnlnet/dnl_r101-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DNLNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 12.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x512_80k_ade20k/dnl_r101-d8_512x512_80k_ade20k_20200826_183354-d820d6ea.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x512_80k_ade20k/dnl_r101-d8_512x512_80k_ade20k-20200826_183354.log.json
+  Paper:
+    Title: Disentangled Non-Local Neural Networks
+    URL: https://arxiv.org/abs/2006.06668
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
+  Framework: PyTorch
+- Name: dnl_r50-d8_4xb4-160k_ade20k-512x512
+  In Collection: DNLNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 41.87
+      mIoU(ms+flip): 43.01
+  Config: configs/dnlnet/dnl_r50-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - DNLNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x512_160k_ade20k/dnl_r50-d8_512x512_160k_ade20k_20200826_183350-37837798.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x512_160k_ade20k/dnl_r50-d8_512x512_160k_ade20k-20200826_183350.log.json
+  Paper:
+    Title: Disentangled Non-Local Neural Networks
+    URL: https://arxiv.org/abs/2006.06668
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
+  Framework: PyTorch
+- Name: dnl_r101-d8_4xb4-160k_ade20k-512x512
+  In Collection: DNLNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 44.25
+      mIoU(ms+flip): 45.78
+  Config: configs/dnlnet/dnl_r101-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - DNLNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x512_160k_ade20k/dnl_r101-d8_512x512_160k_ade20k_20200826_183350-ed522c61.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x512_160k_ade20k/dnl_r101-d8_512x512_160k_ade20k-20200826_183350.log.json
+  Paper:
+    Title: Disentangled Non-Local Neural Networks
+    URL: https://arxiv.org/abs/2006.06668
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/dpt/README.md b/mmsegmentation/configs/dpt/README.md
new file mode 100644
index 0000000..b3a5573
--- /dev/null
+++ b/mmsegmentation/configs/dpt/README.md
@@ -0,0 +1,67 @@
+# DPT
+
+> [Vision Transformer for Dense Prediction](https://arxiv.org/abs/2103.13413)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/isl-org/DPT">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dpt_head.py#L215">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+We introduce dense vision transformers, an architecture that leverages vision transformers in place of convolutional networks as a backbone for dense prediction tasks. We assemble tokens from various stages of the vision transformer into image-like representations at various resolutions and progressively combine them into full-resolution predictions using a convolutional decoder. The transformer backbone processes representations at a constant and relatively high resolution and has a global receptive field at every stage. These properties allow the dense vision transformer to provide finer-grained and more globally coherent predictions when compared to fully-convolutional networks. Our experiments show that this architecture yields substantial improvements on dense prediction tasks, especially when a large amount of training data is available. For monocular depth estimation, we observe an improvement of up to 28% in relative performance when compared to a state-of-the-art fully-convolutional network. When applied to semantic segmentation, dense vision transformers set a new state of the art on ADE20K with 49.02% mIoU. We further show that the architecture can be fine-tuned on smaller datasets such as NYUv2, KITTI, and Pascal Context where it also sets the new state of the art. Our models are available at [this https URL](https://github.com/isl-org/DPT).
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142901057-00aabea5-dab4-43d3-a14a-5f73eb5dd9b9.png" width="80%"/>
+</div>
+
+## Usage
+
+To use other repositories' pre-trained models, it is necessary to convert keys.
+
+We provide a script [`vit2mmseg.py`](../../tools/model_converters/vit2mmseg.py) in the tools directory to convert the key of models from [timm](https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/vision_transformer.py) to MMSegmentation style.
+
+```shell
+python tools/model_converters/vit2mmseg.py ${PRETRAIN_PATH} ${STORE_PATH}
+```
+
+E.g.
+
+```shell
+python tools/model_converters/vit2mmseg.py https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-vitjx/jx_vit_base_p16_224-80ecf9dd.pth pretrain/jx_vit_base_p16_224-80ecf9dd.pth
+```
+
+This script convert model from `PRETRAIN_PATH` and store the converted model in `STORE_PATH`.
+
+## Results and models
+
+### ADE20K
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                               | download                                                                                                                                                                                                                                                                                               |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DPT    | ViT-B    | 512x512   |  160000 | 8.09     | 10.41          | V100   | 46.97 |         48.34 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dpt/dpt_vit-b16_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dpt/dpt_vit-b16_512x512_160k_ade20k/dpt_vit-b16_512x512_160k_ade20k-db31cf52.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dpt/dpt_vit-b16_512x512_160k_ade20k/dpt_vit-b16_512x512_160k_ade20k-20210809_172025.log.json) |
+
+## Citation
+
+```bibtex
+@article{dosoViTskiy2020,
+  title={An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale},
+  author={DosoViTskiy, Alexey and Beyer, Lucas and Kolesnikov, Alexander and Weissenborn, Dirk and Zhai, Xiaohua and Unterthiner, Thomas and  Dehghani, Mostafa and Minderer, Matthias and Heigold, Georg and Gelly, Sylvain and Uszkoreit, Jakob and Houlsby, Neil},
+  journal={arXiv preprint arXiv:2010.11929},
+  year={2020}
+}
+
+@article{Ranftl2021,
+  author    = {Ren\'{e} Ranftl and Alexey Bochkovskiy and Vladlen Koltun},
+  title     = {Vision Transformers for Dense Prediction},
+  journal   = {ArXiv preprint},
+  year      = {2021},
+}
+```
diff --git a/mmsegmentation/configs/dpt/dpt_vit-b16_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/dpt/dpt_vit-b16_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..56b33d9
--- /dev/null
+++ b/mmsegmentation/configs/dpt/dpt_vit-b16_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,39 @@
+_base_ = [
+    '../_base_/models/dpt_vit-b16.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
+# AdamW optimizer, no weight decay for position embedding & layer norm
+# in backbone
+
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
+    paramwise_cfg=dict(
+        custom_keys={
+            'pos_embed': dict(decay_mult=0.),
+            'cls_token': dict(decay_mult=0.),
+            'norm': dict(decay_mult=0.)
+        }))
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        eta_min=0.0,
+        power=1.0,
+        begin=1500,
+        end=160000,
+        by_epoch=False,
+    )
+]
+
+# By default, models are trained on 8 GPUs with 2 images per GPU
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/dpt/metafile.yaml b/mmsegmentation/configs/dpt/metafile.yaml
new file mode 100644
index 0000000..b721e04
--- /dev/null
+++ b/mmsegmentation/configs/dpt/metafile.yaml
@@ -0,0 +1,37 @@
+Collections:
+- Name: DPT
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - ADE20K
+  Paper:
+    Title: Vision Transformer for Dense Prediction
+    URL: https://arxiv.org/abs/2103.13413
+  README: configs/dpt/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: dpt_vit-b16_8xb2-160k_ade20k-512x512
+  In Collection: DPT
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 46.97
+      mIoU(ms+flip): 48.34
+  Config: configs/dpt/dpt_vit-b16_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - ViT-B
+    - DPT
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 8.09
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dpt/dpt_vit-b16_512x512_160k_ade20k/dpt_vit-b16_512x512_160k_ade20k-db31cf52.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dpt/dpt_vit-b16_512x512_160k_ade20k/dpt_vit-b16_512x512_160k_ade20k-20210809_172025.log.json
+  Paper:
+    Title: Vision Transformer for Dense Prediction
+    URL: https://arxiv.org/abs/2103.13413
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dpt_head.py#L215
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/dsdl/README.md b/mmsegmentation/configs/dsdl/README.md
new file mode 100644
index 0000000..e564cff
--- /dev/null
+++ b/mmsegmentation/configs/dsdl/README.md
@@ -0,0 +1,103 @@
+# DSDL: Standard Description Language for DataSet
+
+<!-- [SKIP DEV CHECK] -->
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Data is the cornerstone of artificial intelligence. The efficiency of data acquisition, exchange, and application directly impacts the advances in technologies and applications. Over the long history of AI, a vast quantity of data sets have been developed and distributed. However, these datasets are defined in very different forms, which incurs significant overhead when it comes to exchange, integration, and utilization -- it is often the case that one needs to develop a new customized tool or script in order to incorporate a new dataset into a workflow.
+
+To overcome such difficulties, we develop **Data Set Description Language (DSDL)**. More details please visit our [official documents](https://opendatalab.github.io/dsdl-docs/getting_started/overview/), dsdl datasets can be downloaded from our platform [OpenDataLab](https://opendatalab.com/).
+
+<!-- [IMAGE] -->
+
+## Steps
+
+- install dsdl and opendatalab:
+
+  ```
+  pip install dsdl
+  pip install opendatalab
+  ```
+
+- install mmseg and pytorch:
+  please refer this [installation documents](https://mmsegmentation.readthedocs.io/en/latest/get_started.html).
+
+- prepare dsdl dataset (take voc2012 as an example)
+
+  - dowaload dsdl dataset (you will need an opendatalab account to do so. [register one now](https://opendatalab.com/))
+
+    ```
+    cd data
+
+    odl login
+    odl get PASCAL_VOC2012
+    ```
+
+    usually, dataset is compressed on opendatalab platform, the downloaded voc 2012 dataset should be like this:
+
+    ```
+    data/
+    ├── PASCAL_VOC2012
+    │   ├── dsdl
+    │   │   ├── dsdl_Det_full.zip
+    │   │   └── dsdl_SemSeg_full.zip
+    │   ├── raw
+    │   │   ├── VOC2012test.tar
+    │   │   ├── VOCdevkit_18-May-2011.tar
+    │   │   └── VOCtrainval_11-May-2012.tar
+    │   └── README.md
+    └── ...
+    ```
+
+  - decompress dataset
+
+    ```
+    cd dsdl
+    unzip dsdl_SemSeg_full.zip
+    ```
+
+    as we do not need detection dsdl files, we only decompress the semantic segmentation files here.
+
+    ```
+    cd ../raw
+    tar -xvf VOCtrainval_11-May-2012.tar
+    tar -xvf VOC2012test.tar
+
+    cd ../../
+    ```
+
+- change traning config
+
+  open the [voc config file](voc.py) and set some file paths as below:
+
+  ```
+  data_root = 'data/PASCAL_VOC2012'
+  img_prefix = 'raw/VOCdevkit/VOC2012'
+  train_ann = 'dsdl/dsdl_SemSeg_full/set-train/train.yaml'
+  val_ann = 'dsdl/dsdl_SemSeg_full/set-val/val.yaml'
+  ```
+
+  as dsdl datasets with one task using one dataloader, we can simplly change these file paths to train a model on a different dataset.
+
+- train:
+
+  - using single gpu:
+
+  ```
+  python tools/train.py {config_file}
+  ```
+
+  - using slrum:
+
+  ```
+  ./tools/slurm_train.sh {partition} {job_name} {config_file} {work_dir} {gpu_nums}
+  ```
+
+## Test Results
+
+|  Datasets  |                                                                                        Model                                                                                         | mIoU(%) |          Config           |
+| :--------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :-----: | :-----------------------: |
+|  voc2012   |    [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_20k_voc12aug/deeplabv3_r50-d8_512x512_20k_voc12aug_20200617_010906-596905ef.pth)    |  76.73  |    [config](./voc.py)     |
+| cityscapes | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x1024_40k_cityscapes/deeplabv3_r50-d8_512x1024_40k_cityscapes_20200605_022449-acadc2f8.pth) |  79.01  | [config](./cityscapes.py) |
diff --git a/mmsegmentation/configs/dsdl/cityscapes.py b/mmsegmentation/configs/dsdl/cityscapes.py
new file mode 100644
index 0000000..94ccc06
--- /dev/null
+++ b/mmsegmentation/configs/dsdl/cityscapes.py
@@ -0,0 +1,70 @@
+_base_ = [
+    '../_base_/models/deeplabv3_r50-d8.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
+# dataset settings
+dataset_type = 'DSDLSegDataset'
+data_root = 'data/CityScapes'
+img_prefix = 'raw/CityScapes'
+train_ann = 'dsdl/dsdl_SemSeg_full/set-train/train.yaml'
+val_ann = 'dsdl/dsdl_SemSeg_full/set-val/val.yaml'
+
+used_labels = [
+    'road', 'sidewalk', 'building', 'wall', 'fence', 'pole', 'traffic_light',
+    'traffic_sign', 'vegetation', 'terrain', 'sky', 'person', 'rider', 'car',
+    'truck', 'bus', 'train', 'motorcycle', 'bicycle'
+]
+
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=(2048, 1024),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(img_path=img_prefix, seg_map_path=img_prefix),
+        ann_file=train_ann,
+        used_labels=used_labels,
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(img_path=img_prefix, seg_map_path=img_prefix),
+        ann_file=val_ann,
+        used_labels=used_labels,
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/dsdl/voc.py b/mmsegmentation/configs/dsdl/voc.py
new file mode 100644
index 0000000..c1895f7
--- /dev/null
+++ b/mmsegmentation/configs/dsdl/voc.py
@@ -0,0 +1,65 @@
+_base_ = [
+    '../_base_/models/deeplabv3_r50-d8.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_20k.py'
+]
+
+# dataset settings
+dataset_type = 'DSDLSegDataset'
+data_root = 'data/PASCAL_VOC2012'
+img_prefix = 'raw/VOCdevkit/VOC2012'
+train_ann = 'dsdl/dsdl_SemSeg_full/set-train/train.yaml'
+val_ann = 'dsdl/dsdl_SemSeg_full/set-val/val.yaml'
+crop_size = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=(2048, 512),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(img_path=img_prefix, seg_map_path=img_prefix),
+        ann_file=train_ann,
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(img_path=img_prefix, seg_map_path=img_prefix),
+        ann_file=val_ann,
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
+
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/emanet/README.md b/mmsegmentation/configs/emanet/README.md
new file mode 100644
index 0000000..8ffaf47
--- /dev/null
+++ b/mmsegmentation/configs/emanet/README.md
@@ -0,0 +1,46 @@
+# EMANet
+
+> [Expectation-Maximization Attention Networks for Semantic Segmentation](https://arxiv.org/abs/1907.13426)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://xialipku.github.io/EMANet">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ema_head.py#L80">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Self-attention mechanism has been widely used for various tasks. It is designed to compute the representation of each position by a weighted sum of the features at all positions. Thus, it can capture long-range relations for computer vision tasks. However, it is computationally consuming. Since the attention maps are computed w.r.t all other positions. In this paper, we formulate the attention mechanism into an expectation-maximization manner and iteratively estimate a much more compact set of bases upon which the attention maps are computed. By a weighted summation upon these bases, the resulting representation is low-rank and deprecates noisy information from the input. The proposed Expectation-Maximization Attention (EMA) module is robust to the variance of input and is also friendly in memory and computation. Moreover, we set up the bases maintenance and normalization methods to stabilize its training procedure. We conduct extensive experiments on popular semantic segmentation benchmarks including PASCAL VOC, PASCAL Context and COCO Stuff, on which we set new records.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142901186-7bfe15e2-805a-420e-81b0-74f214f20a36.png" width="80%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                           | download                                                                                                                                                                                                                                                                                                                                                 |
+| ------ | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | -------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EMANet | R-50-D8  | 512x1024  |   80000 |      5.4 | 4.58           | V100   | 77.59 | 79.44         | [config](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/emanet/eemanet_r50-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r50-d8_512x1024_80k_cityscapes/emanet_r50-d8_512x1024_80k_cityscapes_20200901_100301-c43fcef1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r50-d8_512x1024_80k_cityscapes/emanet_r50-d8_512x1024_80k_cityscapes-20200901_100301.log.json)     |
+| EMANet | R-101-D8 | 512x1024  |   80000 |      6.2 | 2.87           | V100   | 79.10 | 81.21         | [config](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r101-d8_512x1024_80k_cityscapes/emanet_r101-d8_512x1024_80k_cityscapes_20200901_100301-2d970745.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r101-d8_512x1024_80k_cityscapes/emanet_r101-d8_512x1024_80k_cityscapes-20200901_100301.log.json) |
+| EMANet | R-50-D8  | 769x769   |   80000 |      8.9 | 1.97           | V100   | 79.33 | 80.49         | [config](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/emanet/emanet_r50-d8_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r50-d8_769x769_80k_cityscapes/emanet_r50-d8_769x769_80k_cityscapes_20200901_100301-16f8de52.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r50-d8_769x769_80k_cityscapes/emanet_r50-d8_769x769_80k_cityscapes-20200901_100301.log.json)         |
+| EMANet | R-101-D8 | 769x769   |   80000 |     10.1 | 1.22           | V100   | 79.62 | 81.00         | [config](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r101-d8_769x769_80k_cityscapes/emanet_r101-d8_769x769_80k_cityscapes_20200901_100301-47a324ce.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r101-d8_769x769_80k_cityscapes/emanet_r101-d8_769x769_80k_cityscapes-20200901_100301.log.json)     |
+
+## Citation
+
+```bibtex
+@inproceedings{li2019expectation,
+  title={Expectation-maximization attention networks for semantic segmentation},
+  author={Li, Xia and Zhong, Zhisheng and Wu, Jianlong and Yang, Yibo and Lin, Zhouchen and Liu, Hong},
+  booktitle={Proceedings of the IEEE International Conference on Computer Vision},
+  pages={9167--9176},
+  year={2019}
+}
+```
diff --git a/mmsegmentation/configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..ee3a3b5
--- /dev/null
+++ b/mmsegmentation/configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './emanet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..7319a3e
--- /dev/null
+++ b/mmsegmentation/configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './emanet_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/emanet/emanet_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/emanet/emanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..6198e1f
--- /dev/null
+++ b/mmsegmentation/configs/emanet/emanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/emanet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/emanet/emanet_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/emanet/emanet_r50-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..a8e4521
--- /dev/null
+++ b/mmsegmentation/configs/emanet/emanet_r50-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/emanet_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/emanet/metafile.yaml b/mmsegmentation/configs/emanet/metafile.yaml
new file mode 100644
index 0000000..b2a6b09
--- /dev/null
+++ b/mmsegmentation/configs/emanet/metafile.yaml
@@ -0,0 +1,109 @@
+Collections:
+- Name: EMANet
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+  Paper:
+    Title: Expectation-Maximization Attention Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1907.13426
+  README: configs/emanet/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: eemanet_r50-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: EMANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.59
+      mIoU(ms+flip): 79.44
+  Config: configs/emanet/eemanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - EMANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.4
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r50-d8_512x1024_80k_cityscapes/emanet_r50-d8_512x1024_80k_cityscapes_20200901_100301-c43fcef1.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r50-d8_512x1024_80k_cityscapes/emanet_r50-d8_512x1024_80k_cityscapes-20200901_100301.log.json
+  Paper:
+    Title: Expectation-Maximization Attention Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1907.13426
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ema_head.py#L80
+  Framework: PyTorch
+- Name: emanet_r101-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: EMANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.1
+      mIoU(ms+flip): 81.21
+  Config: configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - EMANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r101-d8_512x1024_80k_cityscapes/emanet_r101-d8_512x1024_80k_cityscapes_20200901_100301-2d970745.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r101-d8_512x1024_80k_cityscapes/emanet_r101-d8_512x1024_80k_cityscapes-20200901_100301.log.json
+  Paper:
+    Title: Expectation-Maximization Attention Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1907.13426
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ema_head.py#L80
+  Framework: PyTorch
+- Name: emanet_r50-d8_4xb2-80k_cityscapes-769x769
+  In Collection: EMANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.33
+      mIoU(ms+flip): 80.49
+  Config: configs/emanet/emanet_r50-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - EMANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r50-d8_769x769_80k_cityscapes/emanet_r50-d8_769x769_80k_cityscapes_20200901_100301-16f8de52.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r50-d8_769x769_80k_cityscapes/emanet_r50-d8_769x769_80k_cityscapes-20200901_100301.log.json
+  Paper:
+    Title: Expectation-Maximization Attention Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1907.13426
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ema_head.py#L80
+  Framework: PyTorch
+- Name: emanet_r101-d8_4xb2-80k_cityscapes-769x769
+  In Collection: EMANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.62
+      mIoU(ms+flip): 81.0
+  Config: configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - EMANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r101-d8_769x769_80k_cityscapes/emanet_r101-d8_769x769_80k_cityscapes_20200901_100301-47a324ce.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r101-d8_769x769_80k_cityscapes/emanet_r101-d8_769x769_80k_cityscapes-20200901_100301.log.json
+  Paper:
+    Title: Expectation-Maximization Attention Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1907.13426
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ema_head.py#L80
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/encnet/README.md b/mmsegmentation/configs/encnet/README.md
new file mode 100644
index 0000000..ff09bc3
--- /dev/null
+++ b/mmsegmentation/configs/encnet/README.md
@@ -0,0 +1,59 @@
+# EncNet
+
+> [Context Encoding for Semantic Segmentation](https://arxiv.org/abs/1803.08904)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/zhanghang1989/PyTorch-Encoding">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Recent work has made significant progress in improving spatial resolution for pixelwise labeling with Fully Convolutional Network (FCN) framework by employing Dilated/Atrous convolution, utilizing multi-scale features and refining boundaries. In this paper, we explore the impact of global contextual information in semantic segmentation by introducing the Context Encoding Module, which captures the semantic context of scenes and selectively highlights class-dependent featuremaps. The proposed Context Encoding Module significantly improves semantic segmentation results with only marginal extra computation cost over FCN. Our approach has achieved new state-of-the-art results 51.7% mIoU on PASCAL-Context, 85.9% mIoU on PASCAL VOC 2012. Our single model achieves a final score of 0.5567 on ADE20K test set, which surpass the winning entry of COCO-Place Challenge in 2017. In addition, we also explore how the Context Encoding Module can improve the feature representation of relatively shallow networks for the image classification on CIFAR-10 dataset. Our 14 layer network has achieved an error rate of 3.45%, which is comparable with state-of-the-art approaches with over 10 times more layers. The source code for the complete system are publicly available.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142901276-b364fbbf-3bdb-4000-9d31-b9a135e30935.png" width="70%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                         | download                                                                                                                                                                                                                                                                                                                                                 |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EncNet | R-50-D8  | 512x1024  |   40000 | 8.6      | 4.58           | V100   | 75.67 |         77.08 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x1024_40k_cityscapes/encnet_r50-d8_512x1024_40k_cityscapes_20200621_220958-68638a47.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x1024_40k_cityscapes/encnet_r50-d8_512x1024_40k_cityscapes-20200621_220958.log.json)     |
+| EncNet | R-101-D8 | 512x1024  |   40000 | 12.1     | 2.66           | V100   | 75.81 |         77.21 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x1024_40k_cityscapes/encnet_r101-d8_512x1024_40k_cityscapes_20200621_220933-35e0a3e8.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x1024_40k_cityscapes/encnet_r101-d8_512x1024_40k_cityscapes-20200621_220933.log.json) |
+| EncNet | R-50-D8  | 769x769   |   40000 | 9.8      | 1.82           | V100   | 76.24 |         77.85 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_769x769_40k_cityscapes/encnet_r50-d8_769x769_40k_cityscapes_20200621_220958-3bcd2884.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_769x769_40k_cityscapes/encnet_r50-d8_769x769_40k_cityscapes-20200621_220958.log.json)         |
+| EncNet | R-101-D8 | 769x769   |   40000 | 13.7     | 1.26           | V100   | 74.25 |         76.25 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_769x769_40k_cityscapes/encnet_r101-d8_769x769_40k_cityscapes_20200621_220933-2fafed55.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_769x769_40k_cityscapes/encnet_r101-d8_769x769_40k_cityscapes-20200621_220933.log.json)     |
+| EncNet | R-50-D8  | 512x1024  |   80000 | -        | -              | V100   | 77.94 |         79.13 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x1024_80k_cityscapes/encnet_r50-d8_512x1024_80k_cityscapes_20200622_003554-fc5c5624.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x1024_80k_cityscapes/encnet_r50-d8_512x1024_80k_cityscapes-20200622_003554.log.json)     |
+| EncNet | R-101-D8 | 512x1024  |   80000 | -        | -              | V100   | 78.55 |         79.47 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x1024_80k_cityscapes/encnet_r101-d8_512x1024_80k_cityscapes_20200622_003555-1de64bec.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x1024_80k_cityscapes/encnet_r101-d8_512x1024_80k_cityscapes-20200622_003555.log.json) |
+| EncNet | R-50-D8  | 769x769   |   80000 | -        | -              | V100   | 77.44 |         78.72 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_769x769_80k_cityscapes/encnet_r50-d8_769x769_80k_cityscapes_20200622_003554-55096dcb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_769x769_80k_cityscapes/encnet_r50-d8_769x769_80k_cityscapes-20200622_003554.log.json)         |
+| EncNet | R-101-D8 | 769x769   |   80000 | -        | -              | V100   | 76.10 |         76.97 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_769x769_80k_cityscapes/encnet_r101-d8_769x769_80k_cityscapes_20200622_003555-470ef79d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_769x769_80k_cityscapes/encnet_r101-d8_769x769_80k_cityscapes-20200622_003555.log.json)     |
+
+### ADE20K
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                     | download                                                                                                                                                                                                                                                                                                                                 |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EncNet | R-50-D8  | 512x512   |   80000 | 10.1     | 22.81          | V100   | 39.53 |         41.17 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x512_80k_ade20k/encnet_r50-d8_512x512_80k_ade20k_20200622_042412-44b46b04.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x512_80k_ade20k/encnet_r50-d8_512x512_80k_ade20k-20200622_042412.log.json)         |
+| EncNet | R-101-D8 | 512x512   |   80000 | 13.6     | 14.87          | V100   | 42.11 |         43.61 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x512_80k_ade20k/encnet_r101-d8_512x512_80k_ade20k_20200622_101128-dd35e237.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x512_80k_ade20k/encnet_r101-d8_512x512_80k_ade20k-20200622_101128.log.json)     |
+| EncNet | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 40.10 |         41.71 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x512_160k_ade20k/encnet_r50-d8_512x512_160k_ade20k_20200622_101059-b2db95e0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x512_160k_ade20k/encnet_r50-d8_512x512_160k_ade20k-20200622_101059.log.json)     |
+| EncNet | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 42.61 |         44.01 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x512_160k_ade20k/encnet_r101-d8_512x512_160k_ade20k_20200622_073348-7989641f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x512_160k_ade20k/encnet_r101-d8_512x512_160k_ade20k-20200622_073348.log.json) |
+
+## Citation
+
+```bibtex
+@InProceedings{Zhang_2018_CVPR,
+author = {Zhang, Hang and Dana, Kristin and Shi, Jianping and Zhang, Zhongyue and Wang, Xiaogang and Tyagi, Ambrish and Agrawal, Amit},
+title = {Context Encoding for Semantic Segmentation},
+booktitle = {The IEEE Conference on Computer Vision and Pattern Recognition (CVPR)},
+month = {June},
+year = {2018}
+}
+```
diff --git a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..13ab367
--- /dev/null
+++ b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './encnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..7810ac4
--- /dev/null
+++ b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './encnet_r50-d8_4xb2-40k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..bec6bd9
--- /dev/null
+++ b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './encnet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..e1f6409
--- /dev/null
+++ b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './encnet_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..9599f9c
--- /dev/null
+++ b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './encnet_r50-d8_4xb4-160k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..a9edfc2
--- /dev/null
+++ b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './encnet_r50-d8_4xb4-20k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..d2fbab5
--- /dev/null
+++ b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './encnet_r50-d8_4xb4-40k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..debe8c8
--- /dev/null
+++ b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './encnet_r50-d8_4xb4-80k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..d5c3027
--- /dev/null
+++ b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/encnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..045d0fe
--- /dev/null
+++ b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/encnet_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..4dafcd5
--- /dev/null
+++ b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/encnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..e4d0b80
--- /dev/null
+++ b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/encnet_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..b916798
--- /dev/null
+++ b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/encnet_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..e5c9171
--- /dev/null
+++ b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/encnet_r50-d8.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_20k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..8ca126a
--- /dev/null
+++ b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/encnet_r50-d8.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..931d6c0
--- /dev/null
+++ b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/encnet_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/encnet/encnet_r50s-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/encnet/encnet_r50s-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..e98104d
--- /dev/null
+++ b/mmsegmentation/configs/encnet/encnet_r50s-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/encnet_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(stem_channels=128),
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/encnet/metafile.yaml b/mmsegmentation/configs/encnet/metafile.yaml
new file mode 100644
index 0000000..0dbdcfa
--- /dev/null
+++ b/mmsegmentation/configs/encnet/metafile.yaml
@@ -0,0 +1,296 @@
+Collections:
+- Name: EncNet
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+    - ADE20K
+  Paper:
+    Title: Context Encoding for Semantic Segmentation
+    URL: https://arxiv.org/abs/1803.08904
+  README: configs/encnet/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: encnet_r50-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: EncNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 75.67
+      mIoU(ms+flip): 77.08
+  Config: configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - EncNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x1024_40k_cityscapes/encnet_r50-d8_512x1024_40k_cityscapes_20200621_220958-68638a47.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x1024_40k_cityscapes/encnet_r50-d8_512x1024_40k_cityscapes-20200621_220958.log.json
+  Paper:
+    Title: Context Encoding for Semantic Segmentation
+    URL: https://arxiv.org/abs/1803.08904
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
+  Framework: PyTorch
+- Name: encnet_r101-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: EncNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 75.81
+      mIoU(ms+flip): 77.21
+  Config: configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - EncNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 12.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x1024_40k_cityscapes/encnet_r101-d8_512x1024_40k_cityscapes_20200621_220933-35e0a3e8.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x1024_40k_cityscapes/encnet_r101-d8_512x1024_40k_cityscapes-20200621_220933.log.json
+  Paper:
+    Title: Context Encoding for Semantic Segmentation
+    URL: https://arxiv.org/abs/1803.08904
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
+  Framework: PyTorch
+- Name: encnet_r50-d8_4xb2-40k_cityscapes-769x769
+  In Collection: EncNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.24
+      mIoU(ms+flip): 77.85
+  Config: configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - EncNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_769x769_40k_cityscapes/encnet_r50-d8_769x769_40k_cityscapes_20200621_220958-3bcd2884.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_769x769_40k_cityscapes/encnet_r50-d8_769x769_40k_cityscapes-20200621_220958.log.json
+  Paper:
+    Title: Context Encoding for Semantic Segmentation
+    URL: https://arxiv.org/abs/1803.08904
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
+  Framework: PyTorch
+- Name: encnet_r101-d8_4xb2-40k_cityscapes-769x769
+  In Collection: EncNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 74.25
+      mIoU(ms+flip): 76.25
+  Config: configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - EncNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 13.7
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_769x769_40k_cityscapes/encnet_r101-d8_769x769_40k_cityscapes_20200621_220933-2fafed55.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_769x769_40k_cityscapes/encnet_r101-d8_769x769_40k_cityscapes-20200621_220933.log.json
+  Paper:
+    Title: Context Encoding for Semantic Segmentation
+    URL: https://arxiv.org/abs/1803.08904
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
+  Framework: PyTorch
+- Name: encnet_r50-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: EncNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.94
+      mIoU(ms+flip): 79.13
+  Config: configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - EncNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x1024_80k_cityscapes/encnet_r50-d8_512x1024_80k_cityscapes_20200622_003554-fc5c5624.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x1024_80k_cityscapes/encnet_r50-d8_512x1024_80k_cityscapes-20200622_003554.log.json
+  Paper:
+    Title: Context Encoding for Semantic Segmentation
+    URL: https://arxiv.org/abs/1803.08904
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
+  Framework: PyTorch
+- Name: encnet_r101-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: EncNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.55
+      mIoU(ms+flip): 79.47
+  Config: configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - EncNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x1024_80k_cityscapes/encnet_r101-d8_512x1024_80k_cityscapes_20200622_003555-1de64bec.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x1024_80k_cityscapes/encnet_r101-d8_512x1024_80k_cityscapes-20200622_003555.log.json
+  Paper:
+    Title: Context Encoding for Semantic Segmentation
+    URL: https://arxiv.org/abs/1803.08904
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
+  Framework: PyTorch
+- Name: encnet_r50-d8_4xb2-80k_cityscapes-769x769
+  In Collection: EncNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.44
+      mIoU(ms+flip): 78.72
+  Config: configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - EncNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_769x769_80k_cityscapes/encnet_r50-d8_769x769_80k_cityscapes_20200622_003554-55096dcb.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_769x769_80k_cityscapes/encnet_r50-d8_769x769_80k_cityscapes-20200622_003554.log.json
+  Paper:
+    Title: Context Encoding for Semantic Segmentation
+    URL: https://arxiv.org/abs/1803.08904
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
+  Framework: PyTorch
+- Name: encnet_r101-d8_4xb2-80k_cityscapes-769x769
+  In Collection: EncNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.1
+      mIoU(ms+flip): 76.97
+  Config: configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - EncNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_769x769_80k_cityscapes/encnet_r101-d8_769x769_80k_cityscapes_20200622_003555-470ef79d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_769x769_80k_cityscapes/encnet_r101-d8_769x769_80k_cityscapes-20200622_003555.log.json
+  Paper:
+    Title: Context Encoding for Semantic Segmentation
+    URL: https://arxiv.org/abs/1803.08904
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
+  Framework: PyTorch
+- Name: encnet_r50-d8_4xb4-80k_ade20k-512x512
+  In Collection: EncNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 39.53
+      mIoU(ms+flip): 41.17
+  Config: configs/encnet/encnet_r50-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - EncNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x512_80k_ade20k/encnet_r50-d8_512x512_80k_ade20k_20200622_042412-44b46b04.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x512_80k_ade20k/encnet_r50-d8_512x512_80k_ade20k-20200622_042412.log.json
+  Paper:
+    Title: Context Encoding for Semantic Segmentation
+    URL: https://arxiv.org/abs/1803.08904
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
+  Framework: PyTorch
+- Name: encnet_r101-d8_4xb4-80k_ade20k-512x512
+  In Collection: EncNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.11
+      mIoU(ms+flip): 43.61
+  Config: configs/encnet/encnet_r101-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - EncNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 13.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x512_80k_ade20k/encnet_r101-d8_512x512_80k_ade20k_20200622_101128-dd35e237.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x512_80k_ade20k/encnet_r101-d8_512x512_80k_ade20k-20200622_101128.log.json
+  Paper:
+    Title: Context Encoding for Semantic Segmentation
+    URL: https://arxiv.org/abs/1803.08904
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
+  Framework: PyTorch
+- Name: encnet_r50-d8_4xb4-160k_ade20k-512x512
+  In Collection: EncNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 40.1
+      mIoU(ms+flip): 41.71
+  Config: configs/encnet/encnet_r50-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - EncNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x512_160k_ade20k/encnet_r50-d8_512x512_160k_ade20k_20200622_101059-b2db95e0.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x512_160k_ade20k/encnet_r50-d8_512x512_160k_ade20k-20200622_101059.log.json
+  Paper:
+    Title: Context Encoding for Semantic Segmentation
+    URL: https://arxiv.org/abs/1803.08904
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
+  Framework: PyTorch
+- Name: encnet_r101-d8_4xb4-160k_ade20k-512x512
+  In Collection: EncNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.61
+      mIoU(ms+flip): 44.01
+  Config: configs/encnet/encnet_r101-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - EncNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x512_160k_ade20k/encnet_r101-d8_512x512_160k_ade20k_20200622_073348-7989641f.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x512_160k_ade20k/encnet_r101-d8_512x512_160k_ade20k-20200622_073348.log.json
+  Paper:
+    Title: Context Encoding for Semantic Segmentation
+    URL: https://arxiv.org/abs/1803.08904
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/erfnet/README.md b/mmsegmentation/configs/erfnet/README.md
new file mode 100644
index 0000000..55d7197
--- /dev/null
+++ b/mmsegmentation/configs/erfnet/README.md
@@ -0,0 +1,54 @@
+# ERFNet
+
+> [ERFNet: Efficient Residual Factorized ConvNet for Real-time Semantic Segmentation](http://www.robesafe.uah.es/personal/eduardo.romera/pdfs/Romera17tits.pdf)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/Eromera/erfnet_pytorch">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/erfnet.py#L321">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Semantic segmentation is a challenging task that addresses most of the perception needs of intelligent vehicles (IVs) in an unified way. Deep neural networks excel at this task, as they can be trained end-to-end to accurately classify multiple object categories in an image at pixel level. However, a good tradeoff between high quality and computational resources is yet not present in the state-of-the-art semantic segmentation approaches, limiting their application in real vehicles. In this paper, we propose a deep architecture that is able to run in real time while providing accurate semantic segmentation. The core of our architecture is a novel layer that uses residual connections and factorized convolutions in order to remain efficient while retaining remarkable accuracy. Our approach is able to run at over 83 FPS in a single Titan X, and 7 FPS in a Jetson TX1 (embedded device). A comprehensive set of experiments on the publicly available Cityscapes data set demonstrates that our system achieves an accuracy that is similar to the state of the art, while being orders of magnitude faster to compute than other architectures that achieve top precision. The resulting tradeoff makes our model an ideal approach for scene understanding in IV applications. The code is publicly available at: https://github.com/Eromera/erfnet.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/143479729-ea7951f6-1a3c-47d6-aaee-62c5759c0638.png" width="60%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU | mIoU(ms+flip) | config                                                                                                                      | download                                                                                                                                                                                                                                                                                                                                                     |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ---: | ------------- | --------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ERFNet | ERFNet   | 512x1024  |  160000 | 6.04     | 15.26          | V100   | 72.5 | 74.75         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/erfnet/erfnet_fcn_4xb4-160k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/erfnet/erfnet_fcn_4x4_512x1024_160k_cityscapes/erfnet_fcn_4x4_512x1024_160k_cityscapes_20220704_162145-dc90157a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/erfnet/erfnet_fcn_4x4_512x1024_160k_cityscapes/erfnet_fcn_4x4_512x1024_160k_cityscapes_20220704_162145.log.json) |
+
+Note:
+
+- The model is trained from scratch.
+
+- Last deconvolution layer in the [original paper](https://github.com/Eromera/erfnet_pytorch/blob/master/train/erfnet.py#L123) is replaced by a naive `FCNHead` decoder head and a bilinear upsampling layer, found more effective and efficient.
+
+- This model performance is sensitive to the seed values used, please refer to the log file for the specific settings of the seed. If you choose a different seed, the results might differ from the table results.
+
+## Citation
+
+```bibtex
+@article{romera2017erfnet,
+  title={Erfnet: Efficient residual factorized convnet for real-time semantic segmentation},
+  author={Romera, Eduardo and Alvarez, Jos{\'e} M and Bergasa, Luis M and Arroyo, Roberto},
+  journal={IEEE Transactions on Intelligent Transportation Systems},
+  volume={19},
+  number={1},
+  pages={263--272},
+  year={2017},
+  publisher={IEEE}
+}
+```
diff --git a/mmsegmentation/configs/erfnet/erfnet_fcn_4xb4-160k_cityscapes-512x1024.py b/mmsegmentation/configs/erfnet/erfnet_fcn_4xb4-160k_cityscapes-512x1024.py
new file mode 100644
index 0000000..7d65582
--- /dev/null
+++ b/mmsegmentation/configs/erfnet/erfnet_fcn_4xb4-160k_cityscapes-512x1024.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/erfnet_fcn.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/erfnet/metafile.yaml b/mmsegmentation/configs/erfnet/metafile.yaml
new file mode 100644
index 0000000..bf51412
--- /dev/null
+++ b/mmsegmentation/configs/erfnet/metafile.yaml
@@ -0,0 +1,37 @@
+Collections:
+- Name: ERFNet
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+  Paper:
+    Title: 'ERFNet: Efficient Residual Factorized ConvNet for Real-time Semantic Segmentation'
+    URL: http://www.robesafe.uah.es/personal/eduardo.romera/pdfs/Romera17tits.pdf
+  README: configs/erfnet/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: erfnet_fcn_4xb4-160k_cityscapes-512x1024
+  In Collection: ERFNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 72.5
+      mIoU(ms+flip): 74.75
+  Config: configs/erfnet/erfnet_fcn_4xb4-160k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 16
+    Architecture:
+    - ERFNet
+    - ERFNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.04
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/erfnet/erfnet_fcn_4x4_512x1024_160k_cityscapes/erfnet_fcn_4x4_512x1024_160k_cityscapes_20220704_162145-dc90157a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/erfnet/erfnet_fcn_4x4_512x1024_160k_cityscapes/erfnet_fcn_4x4_512x1024_160k_cityscapes_20220704_162145.log.json
+  Paper:
+    Title: 'ERFNet: Efficient Residual Factorized ConvNet for Real-time Semantic Segmentation'
+    URL: http://www.robesafe.uah.es/personal/eduardo.romera/pdfs/Romera17tits.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/erfnet.py#L321
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/fastfcn/README.md b/mmsegmentation/configs/fastfcn/README.md
new file mode 100644
index 0000000..48644e5
--- /dev/null
+++ b/mmsegmentation/configs/fastfcn/README.md
@@ -0,0 +1,63 @@
+# FastFCN
+
+> [FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation](https://arxiv.org/abs/1903.11816)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/wuhuikai/FastFCN">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Modern approaches for semantic segmentation usually employ dilated convolutions in the backbone to extract high-resolution feature maps, which brings heavy computation complexity and memory footprint. To replace the time and memory consuming dilated convolutions, we propose a novel joint upsampling module named Joint Pyramid Upsampling (JPU) by formulating the task of extracting high-resolution feature maps into a joint upsampling problem. With the proposed JPU, our method reduces the computation complexity by more than three times without performance loss. Experiments show that JPU is superior to other upsampling modules, which can be plugged into many existing approaches to reduce computation complexity and improve performance. By replacing dilated convolutions with the proposed JPU module, our method achieves the state-of-the-art performance in Pascal Context dataset (mIoU of 53.13%) and ADE20K dataset (final score of 0.5584) while running 3 times faster.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142901374-6e0252ab-6e0f-4acd-86ad-1e9f49be3185.png" width="70%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method              | Backbone       | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                    | download                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------- | -------------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| FastFCN + DeepLabV3 | R-50-D32       | 512x1024  |   80000 | 5.67     | 2.64           | V100   | 79.12 | 80.58         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_aspp_512x1024_80k_cityscapes_20210928_053722-5d1a2648.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_aspp_512x1024_80k_cityscapes_20210928_053722.log.json)                 |
+| FastFCN + DeepLabV3 | R-50-D32 (4x4) | 512x1024  |   80000 | 9.79     | -              | V100   | 79.52 | 80.91         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_aspp_4x4_512x1024_80k_cityscapes_20210924_214357-72220849.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_aspp_4x4_512x1024_80k_cityscapes_20210924_214357.log.json) |
+| FastFCN + PSPNet    | R-50-D32       | 512x1024  |   80000 | 5.67     | 4.40           | V100   | 79.26 | 80.86         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_psp_512x1024_80k_cityscapes_20210928_053722-57749bed.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_psp_512x1024_80k_cityscapes_20210928_053722.log.json)                     |
+| FastFCN + PSPNet    | R-50-D32 (4x4) | 512x1024  |   80000 | 9.94     | -              | V100   | 78.76 | 80.03         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_psp_4x4_512x1024_80k_cityscapes_20210925_061841-77e87b0a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_psp_4x4_512x1024_80k_cityscapes_20210925_061841.log.json)     |
+| FastFCN + EncNet    | R-50-D32       | 512x1024  |   80000 | 8.15     | 4.77           | V100   | 77.97 | 79.92         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_enc_512x1024_80k_cityscapes_20210928_030036-78da5046.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_enc_512x1024_80k_cityscapes_20210928_030036.log.json)                     |
+| FastFCN + EncNet    | R-50-D32 (4x4) | 512x1024  |   80000 | 15.45    | -              | V100   |  78.6 | 80.25         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_enc_4x4_512x1024_80k_cityscapes_20210926_093217-e1eb6dbb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_enc_4x4_512x1024_80k_cityscapes_20210926_093217.log.json)     |
+
+### ADE20K
+
+| Method              | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                | download                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------- | ------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FastFCN + DeepLabV3 | R-50-D32 | 512x1024  |   80000 | 8.46     | 12.06          | V100   | 41.88 | 42.91         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x512_80k_ade20k/fastfcn_r50-d32_jpu_aspp_512x512_80k_ade20k_20211013_190619-3aa40f2d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x512_80k_ade20k/fastfcn_r50-d32_jpu_aspp_512x512_80k_ade20k_20211013_190619.log.json)     |
+| FastFCN + DeepLabV3 | R-50-D32 | 512x1024  |  160000 | -        | -              | V100   | 43.58 | 44.92         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x512_160k_ade20k/fastfcn_r50-d32_jpu_aspp_512x512_160k_ade20k_20211008_152246-27036aee.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x512_160k_ade20k/fastfcn_r50-d32_jpu_aspp_512x512_160k_ade20k_20211008_152246.log.json) |
+| FastFCN + PSPNet    | R-50-D32 | 512x1024  |   80000 | 8.02     | 19.21          | V100   | 41.40 | 42.12         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x512_80k_ade20k/fastfcn_r50-d32_jpu_psp_512x512_80k_ade20k_20210930_225137-993d07c8.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x512_80k_ade20k/fastfcn_r50-d32_jpu_psp_512x512_80k_ade20k_20210930_225137.log.json)         |
+| FastFCN + PSPNet    | R-50-D32 | 512x1024  |  160000 | -        | -              | V100   | 42.63 | 43.71         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x512_160k_ade20k/fastfcn_r50-d32_jpu_psp_512x512_160k_ade20k_20211008_105455-e8f5a2fd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x512_160k_ade20k/fastfcn_r50-d32_jpu_psp_512x512_160k_ade20k_20211008_105455.log.json)     |
+| FastFCN + EncNet    | R-50-D32 | 512x1024  |   80000 | 9.67     | 17.23          | V100   | 40.88 | 42.36         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x512_80k_ade20k/fastfcn_r50-d32_jpu_enc_512x512_80k_ade20k_20210930_225214-65aef6dd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x512_80k_ade20k/fastfcn_r50-d32_jpu_enc_512x512_80k_ade20k_20210930_225214.log.json)         |
+| FastFCN + EncNet    | R-50-D32 | 512x1024  |  160000 | -        | -              | V100   | 42.50 | 44.21         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x512_160k_ade20k/fastfcn_r50-d32_jpu_enc_512x512_160k_ade20k_20211008_105456-d875ce3c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x512_160k_ade20k/fastfcn_r50-d32_jpu_enc_512x512_160k_ade20k_20211008_105456.log.json)     |
+
+Note:
+
+- `4x4` means 4 GPUs with 4 samples per GPU in training, default setting is 4 GPUs with 2 samples per GPU in training.
+- Results of [DeepLabV3 (mIoU: 79.32)](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3), [PSPNet (mIoU: 78.55)](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet) and [ENCNet (mIoU: 77.94)](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet) can be found in each original repository.
+
+## Citation
+
+```bibtex
+@article{wu2019fastfcn,
+title={Fastfcn: Rethinking dilated convolution in the backbone for semantic segmentation},
+author={Wu, Huikai and Zhang, Junge and Huang, Kaiqi and Liang, Kongming and Yu, Yizhou},
+journal={arXiv preprint arXiv:1903.11816},
+year={2019}
+}
+```
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..39e6e23
--- /dev/null
+++ b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,20 @@
+# model settings
+_base_ = './fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024.py'
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    decode_head=dict(
+        _delete_=True,
+        type='ASPPHead',
+        in_channels=2048,
+        in_index=2,
+        channels=512,
+        dilations=(1, 12, 24, 36),
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..1913544
--- /dev/null
+++ b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,20 @@
+# model settings
+_base_ = './fastfcn_r50-d32_jpu_psp_4xb4-160k_ade20k-512x512.py'
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    decode_head=dict(
+        _delete_=True,
+        type='ASPPHead',
+        in_channels=2048,
+        in_index=2,
+        channels=512,
+        dilations=(1, 12, 24, 36),
+        dropout_ratio=0.1,
+        num_classes=150,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..7516895
--- /dev/null
+++ b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,20 @@
+# model settings
+_base_ = './fastfcn_r50-d32_jpu_psp_4xb4-80k_ade20k-512x512.py'
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    decode_head=dict(
+        _delete_=True,
+        type='ASPPHead',
+        in_channels=2048,
+        in_index=2,
+        channels=512,
+        dilations=(1, 12, 24, 36),
+        dropout_ratio=0.1,
+        num_classes=150,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..a8c5dc3
--- /dev/null
+++ b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-80k_cityscapes-512x1024.py
@@ -0,0 +1,5 @@
+# model settings
+_base_ = './fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024.py'
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..4840dd0
--- /dev/null
+++ b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,24 @@
+# model settings
+_base_ = './fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024.py'
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    decode_head=dict(
+        _delete_=True,
+        type='EncHead',
+        in_channels=[512, 1024, 2048],
+        in_index=(0, 1, 2),
+        channels=512,
+        num_codes=32,
+        use_se_loss=True,
+        add_lateral=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
+        loss_se_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.2)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..619d086
--- /dev/null
+++ b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,24 @@
+# model settings
+_base_ = './fastfcn_r50-d32_jpu_psp_4xb4-160k_ade20k-512x512.py'
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    decode_head=dict(
+        _delete_=True,
+        type='EncHead',
+        in_channels=[512, 1024, 2048],
+        in_index=(0, 1, 2),
+        channels=512,
+        num_codes=32,
+        use_se_loss=True,
+        add_lateral=False,
+        dropout_ratio=0.1,
+        num_classes=150,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
+        loss_se_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.2)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..a76b026
--- /dev/null
+++ b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,24 @@
+# model settings
+_base_ = './fastfcn_r50-d32_jpu_psp_4xb4-80k_ade20k-512x512.py'
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    decode_head=dict(
+        _delete_=True,
+        type='EncHead',
+        in_channels=[512, 1024, 2048],
+        in_index=(0, 1, 2),
+        channels=512,
+        num_codes=32,
+        use_se_loss=True,
+        add_lateral=False,
+        dropout_ratio=0.1,
+        num_classes=150,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
+        loss_se_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.2)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..6df1527
--- /dev/null
+++ b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-80k_cityscapes-512x1024.py
@@ -0,0 +1,5 @@
+# model settings
+_base_ = './fastfcn_r50-d32_jpu_enc_4xb2-80k_cityscapes-512x1024.py'
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..dc5c54d
--- /dev/null
+++ b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,8 @@
+_base_ = [
+    '../_base_/models/fastfcn_r50-d32_jpu_psp.py',
+    '../_base_/datasets/cityscapes.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..887ace1
--- /dev/null
+++ b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/fastfcn_r50-d32_jpu_psp.py',
+    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..3981e20
--- /dev/null
+++ b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/fastfcn_r50-d32_jpu_psp.py',
+    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..2c7d504
--- /dev/null
+++ b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-80k_cityscapes-512x1024.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/fastfcn_r50-d32_jpu_psp.py',
+    '../_base_/datasets/cityscapes.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/fastfcn/metafile.yaml b/mmsegmentation/configs/fastfcn/metafile.yaml
new file mode 100644
index 0000000..f5fe03c
--- /dev/null
+++ b/mmsegmentation/configs/fastfcn/metafile.yaml
@@ -0,0 +1,311 @@
+Collections:
+- Name: FastFCN
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+    - ADE20K
+  Paper:
+    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1903.11816
+  README: configs/fastfcn/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024
+  In Collection: FastFCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.12
+      mIoU(ms+flip): 80.58
+  Config: configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D32
+    - FastFCN
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.67
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_aspp_512x1024_80k_cityscapes_20210928_053722-5d1a2648.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_aspp_512x1024_80k_cityscapes_20210928_053722.log.json
+  Paper:
+    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1903.11816
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
+  Framework: PyTorch
+- Name: fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024
+  In Collection: FastFCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.52
+      mIoU(ms+flip): 80.91
+  Config: configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D32
+    - FastFCN
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.79
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_aspp_4x4_512x1024_80k_cityscapes_20210924_214357-72220849.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_aspp_4x4_512x1024_80k_cityscapes_20210924_214357.log.json
+  Paper:
+    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1903.11816
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
+  Framework: PyTorch
+- Name: fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024
+  In Collection: FastFCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.26
+      mIoU(ms+flip): 80.86
+  Config: configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D32
+    - FastFCN
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.67
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_psp_512x1024_80k_cityscapes_20210928_053722-57749bed.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_psp_512x1024_80k_cityscapes_20210928_053722.log.json
+  Paper:
+    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1903.11816
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
+  Framework: PyTorch
+- Name: fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024
+  In Collection: FastFCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.76
+      mIoU(ms+flip): 80.03
+  Config: configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D32
+    - FastFCN
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.94
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_psp_4x4_512x1024_80k_cityscapes_20210925_061841-77e87b0a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_psp_4x4_512x1024_80k_cityscapes_20210925_061841.log.json
+  Paper:
+    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1903.11816
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
+  Framework: PyTorch
+- Name: fastfcn_r50-d32_jpu_enc_4xb2-80k_cityscapes-512x1024
+  In Collection: FastFCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.97
+      mIoU(ms+flip): 79.92
+  Config: configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D32
+    - FastFCN
+    - EncNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.15
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_enc_512x1024_80k_cityscapes_20210928_030036-78da5046.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_enc_512x1024_80k_cityscapes_20210928_030036.log.json
+  Paper:
+    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1903.11816
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
+  Framework: PyTorch
+- Name: fastfcn_r50-d32_jpu_enc_4xb2-80k_cityscapes-512x1024
+  In Collection: FastFCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.6
+      mIoU(ms+flip): 80.25
+  Config: configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D32
+    - FastFCN
+    - EncNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 15.45
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_enc_4x4_512x1024_80k_cityscapes_20210926_093217-e1eb6dbb.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_enc_4x4_512x1024_80k_cityscapes_20210926_093217.log.json
+  Paper:
+    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1903.11816
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
+  Framework: PyTorch
+- Name: fastfcn_r50-d32_jpu_aspp_4xb4-80k_ade20k-512x512
+  In Collection: FastFCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 41.88
+      mIoU(ms+flip): 42.91
+  Config: configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D32
+    - FastFCN
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.46
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x512_80k_ade20k/fastfcn_r50-d32_jpu_aspp_512x512_80k_ade20k_20211013_190619-3aa40f2d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x512_80k_ade20k/fastfcn_r50-d32_jpu_aspp_512x512_80k_ade20k_20211013_190619.log.json
+  Paper:
+    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1903.11816
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
+  Framework: PyTorch
+- Name: fastfcn_r50-d32_jpu_aspp_4xb4-160k_ade20k-512x512
+  In Collection: FastFCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 43.58
+      mIoU(ms+flip): 44.92
+  Config: configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D32
+    - FastFCN
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x512_160k_ade20k/fastfcn_r50-d32_jpu_aspp_512x512_160k_ade20k_20211008_152246-27036aee.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x512_160k_ade20k/fastfcn_r50-d32_jpu_aspp_512x512_160k_ade20k_20211008_152246.log.json
+  Paper:
+    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1903.11816
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
+  Framework: PyTorch
+- Name: fastfcn_r50-d32_jpu_psp_4xb4-80k_ade20k-512x512
+  In Collection: FastFCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 41.4
+      mIoU(ms+flip): 42.12
+  Config: configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D32
+    - FastFCN
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.02
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x512_80k_ade20k/fastfcn_r50-d32_jpu_psp_512x512_80k_ade20k_20210930_225137-993d07c8.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x512_80k_ade20k/fastfcn_r50-d32_jpu_psp_512x512_80k_ade20k_20210930_225137.log.json
+  Paper:
+    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1903.11816
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
+  Framework: PyTorch
+- Name: fastfcn_r50-d32_jpu_psp_4xb4-160k_ade20k-512x512
+  In Collection: FastFCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.63
+      mIoU(ms+flip): 43.71
+  Config: configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D32
+    - FastFCN
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x512_160k_ade20k/fastfcn_r50-d32_jpu_psp_512x512_160k_ade20k_20211008_105455-e8f5a2fd.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x512_160k_ade20k/fastfcn_r50-d32_jpu_psp_512x512_160k_ade20k_20211008_105455.log.json
+  Paper:
+    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1903.11816
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
+  Framework: PyTorch
+- Name: fastfcn_r50-d32_jpu_enc_4xb4-80k_ade20k-512x512
+  In Collection: FastFCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 40.88
+      mIoU(ms+flip): 42.36
+  Config: configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D32
+    - FastFCN
+    - EncNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.67
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x512_80k_ade20k/fastfcn_r50-d32_jpu_enc_512x512_80k_ade20k_20210930_225214-65aef6dd.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x512_80k_ade20k/fastfcn_r50-d32_jpu_enc_512x512_80k_ade20k_20210930_225214.log.json
+  Paper:
+    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1903.11816
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
+  Framework: PyTorch
+- Name: fastfcn_r50-d32_jpu_enc_4xb4-160k_ade20k-512x512
+  In Collection: FastFCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.5
+      mIoU(ms+flip): 44.21
+  Config: configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D32
+    - FastFCN
+    - EncNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x512_160k_ade20k/fastfcn_r50-d32_jpu_enc_512x512_160k_ade20k_20211008_105456-d875ce3c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x512_160k_ade20k/fastfcn_r50-d32_jpu_enc_512x512_160k_ade20k_20211008_105456.log.json
+  Paper:
+    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
+    URL: https://arxiv.org/abs/1903.11816
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/fastscnn/README.md b/mmsegmentation/configs/fastscnn/README.md
new file mode 100644
index 0000000..6be9814
--- /dev/null
+++ b/mmsegmentation/configs/fastscnn/README.md
@@ -0,0 +1,42 @@
+# Fast-SCNN
+
+> [Fast-SCNN for Semantic Segmentation](https://arxiv.org/abs/1902.04502)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/fast_scnn.py#L272">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+The encoder-decoder framework is state-of-the-art for offline semantic image segmentation. Since the rise in autonomous systems, real-time computation is increasingly desirable. In this paper, we introduce fast segmentation convolutional neural network (Fast-SCNN), an above real-time semantic segmentation model on high resolution image data (1024x2048px) suited to efficient computation on embedded devices with low memory. Building on existing two-branch methods for fast segmentation, we introduce our \`learning to downsample' module which computes low-level features for multiple resolution branches simultaneously. Our network combines spatial detail at high resolution with deep features extracted at lower resolution, yielding an accuracy of 68.0% mean intersection over union at 123.5 frames per second on Cityscapes. We also show that large scale pre-training is unnecessary. We thoroughly validate our metric in experiments with ImageNet pre-training and the coarse labeled data of Cityscapes. Finally, we show even faster computation with competitive results on subsampled inputs, without any network modifications.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142901444-705b4ff4-6d1e-409b-899a-37bf3a6b69ce.png" width="80%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method   | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                       | download                                                                                                                                                                                                                                                                                                                                               |
+| -------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------- | ---------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| FastSCNN | FastSCNN | 512x1024  |  160000 | 3.3      | 56.45          | V100   | 70.96 | 72.65         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastscnn/fast_scnn_8xb4-160k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fast_scnn/fast_scnn_lr0.12_8x4_160k_cityscapes/fast_scnn_lr0.12_8x4_160k_cityscapes_20210630_164853-0cec9937.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fast_scnn/fast_scnn_lr0.12_8x4_160k_cityscapes/fast_scnn_lr0.12_8x4_160k_cityscapes_20210630_164853.log.json) |
+
+## Citation
+
+```bibtex
+@article{poudel2019fast,
+  title={Fast-scnn: Fast semantic segmentation network},
+  author={Poudel, Rudra PK and Liwicki, Stephan and Cipolla, Roberto},
+  journal={arXiv preprint arXiv:1902.04502},
+  year={2019}
+}
+```
diff --git a/mmsegmentation/configs/fastscnn/fast_scnn_8xb4-160k_cityscapes-512x1024.py b/mmsegmentation/configs/fastscnn/fast_scnn_8xb4-160k_cityscapes-512x1024.py
new file mode 100644
index 0000000..e7f68bf
--- /dev/null
+++ b/mmsegmentation/configs/fastscnn/fast_scnn_8xb4-160k_cityscapes-512x1024.py
@@ -0,0 +1,15 @@
+_base_ = [
+    '../_base_/models/fast_scnn.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
+# Re-config the data sampler.
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
+
+# Re-config the optimizer.
+optimizer = dict(type='SGD', lr=0.12, momentum=0.9, weight_decay=4e-5)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/fastscnn/metafile.yaml b/mmsegmentation/configs/fastscnn/metafile.yaml
new file mode 100644
index 0000000..9e33c90
--- /dev/null
+++ b/mmsegmentation/configs/fastscnn/metafile.yaml
@@ -0,0 +1,37 @@
+Collections:
+- Name: FastSCNN
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+  Paper:
+    Title: Fast-SCNN for Semantic Segmentation
+    URL: https://arxiv.org/abs/1902.04502
+  README: configs/fastscnn/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: fast_scnn_8xb4-160k_cityscapes-512x1024
+  In Collection: FastSCNN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 70.96
+      mIoU(ms+flip): 72.65
+  Config: configs/fastscnn/fast_scnn_8xb4-160k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 32
+    Architecture:
+    - FastSCNN
+    - FastSCNN
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 3.3
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fast_scnn/fast_scnn_lr0.12_8x4_160k_cityscapes/fast_scnn_lr0.12_8x4_160k_cityscapes_20210630_164853-0cec9937.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fast_scnn/fast_scnn_lr0.12_8x4_160k_cityscapes/fast_scnn_lr0.12_8x4_160k_cityscapes_20210630_164853.log.json
+  Paper:
+    Title: Fast-SCNN for Semantic Segmentation
+    URL: https://arxiv.org/abs/1902.04502
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/fast_scnn.py#L272
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/fcn/README.md b/mmsegmentation/configs/fcn/README.md
new file mode 100644
index 0000000..cf7379f
--- /dev/null
+++ b/mmsegmentation/configs/fcn/README.md
@@ -0,0 +1,111 @@
+# FCN
+
+> [Fully Convolutional Networks for Semantic Segmentation](https://arxiv.org/abs/1411.4038)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/BVLC/caffe/wiki/Model-Zoo#fcn">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Convolutional networks are powerful visual models that yield hierarchies of features. We show that convolutional networks by themselves, trained end-to-end, pixels-to-pixels, exceed the state-of-the-art in semantic segmentation. Our key insight is to build "fully convolutional" networks that take input of arbitrary size and produce correspondingly-sized output with efficient inference and learning. We define and detail the space of fully convolutional networks, explain their application to spatially dense prediction tasks, and draw connections to prior models. We adapt contemporary classification networks (AlexNet, the VGG net, and GoogLeNet) into fully convolutional networks and transfer their learned representations by fine-tuning to the segmentation task. We then define a novel architecture that combines semantic information from a deep, coarse layer with appearance information from a shallow, fine layer to produce accurate and detailed segmentations. Our fully convolutional network achieves state-of-the-art segmentation of PASCAL VOC (20% relative improvement to 62.2% mean IU on 2012), NYUDv2, and SIFT Flow, while inference takes one third of a second for a typical image.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142901525-fd0d2bf4-9a47-4143-85f5-3cee8849eaa4.png" width="70%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method     | Backbone   | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device   |  mIoU | mIoU(ms+flip) | config                                                                                                                        | download                                                                                                                                                                                                                                                                                                                                                   |
+| ---------- | ---------- | --------- | ------: | -------- | -------------- | -------- | ----: | ------------: | ----------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FCN        | R-50-D8    | 512x1024  |   40000 | 5.7      | 4.17           | V100     | 72.25 |         73.36 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x1024_40k_cityscapes/fcn_r50-d8_512x1024_40k_cityscapes_20200604_192608-efe53f0d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x1024_40k_cityscapes/fcn_r50-d8_512x1024_40k_cityscapes_20200604_192608.log.json)                         |
+| FCN        | R-101-D8   | 512x1024  |   40000 | 9.2      | 2.66           | V100     | 75.45 |         76.58 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-512x1024.py)      | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x1024_40k_cityscapes/fcn_r101-d8_512x1024_40k_cityscapes_20200604_181852-a883d3a1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x1024_40k_cityscapes/fcn_r101-d8_512x1024_40k_cityscapes_20200604_181852.log.json)                     |
+| FCN        | R-50-D8    | 769x769   |   40000 | 6.5      | 1.80           | V100     | 71.47 |         72.54 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-769x769.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_769x769_40k_cityscapes/fcn_r50-d8_769x769_40k_cityscapes_20200606_113104-977b5d02.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_769x769_40k_cityscapes/fcn_r50-d8_769x769_40k_cityscapes_20200606_113104.log.json)                             |
+| FCN        | R-101-D8   | 769x769   |   40000 | 10.4     | 1.19           | V100     | 73.93 |         75.14 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-769x769.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_769x769_40k_cityscapes/fcn_r101-d8_769x769_40k_cityscapes_20200606_113208-7d4ab69c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_769x769_40k_cityscapes/fcn_r101-d8_769x769_40k_cityscapes_20200606_113208.log.json)                         |
+| FCN        | R-18-D8    | 512x1024  |   80000 | 1.7      | 14.65          | V100     | 71.11 |         72.91 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-512x1024.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18-d8_512x1024_80k_cityscapes/fcn_r18-d8_512x1024_80k_cityscapes_20201225_021327-6c50f8b4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18-d8_512x1024_80k_cityscapes/fcn_r18-d8_512x1024_80k_cityscapes-20201225_021327.log.json)                         |
+| FCN        | R-50-D8    | 512x1024  |   80000 | -        |                | V100     | 73.61 |         74.24 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x1024_80k_cityscapes/fcn_r50-d8_512x1024_80k_cityscapes_20200606_113019-03aa804d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x1024_80k_cityscapes/fcn_r50-d8_512x1024_80k_cityscapes_20200606_113019.log.json)                         |
+| FCN        | R-101-D8   | 512x1024  |   80000 | -        | -              | V100     | 75.13 |         75.94 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-512x1024.py)      | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x1024_80k_cityscapes/fcn_r101-d8_512x1024_80k_cityscapes_20200606_113038-3fb937eb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x1024_80k_cityscapes/fcn_r101-d8_512x1024_80k_cityscapes_20200606_113038.log.json)                     |
+| FCN (FP16) | R-101-D8   | 512x1024  |   80000 | 5.37     | 8.64           | V100     | 76.80 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_fp16_512x1024_80k_cityscapes/fcn_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230921-fb13e883.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_fp16_512x1024_80k_cityscapes/fcn_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230921.log.json) |
+| FCN        | R-18-D8    | 769x769   |   80000 | 1.9      | 6.40           | V100     | 70.80 |         73.16 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-769x769.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18-d8_769x769_80k_cityscapes/fcn_r18-d8_769x769_80k_cityscapes_20201225_021451-9739d1b8.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18-d8_769x769_80k_cityscapes/fcn_r18-d8_769x769_80k_cityscapes-20201225_021451.log.json)                             |
+| FCN        | R-50-D8    | 769x769   |   80000 | -        | -              | V100     | 72.64 |         73.32 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-769x769.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_769x769_80k_cityscapes/fcn_r50-d8_769x769_80k_cityscapes_20200606_195749-f5caeabc.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_769x769_80k_cityscapes/fcn_r50-d8_769x769_80k_cityscapes_20200606_195749.log.json)                             |
+| FCN        | R-101-D8   | 769x769   |   80000 | -        | -              | V100     | 75.52 |         76.61 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-769x769.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_769x769_80k_cityscapes/fcn_r101-d8_769x769_80k_cityscapes_20200606_214354-45cbac68.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_769x769_80k_cityscapes/fcn_r101-d8_769x769_80k_cityscapes_20200606_214354.log.json)                         |
+| FCN        | R-18b-D8   | 512x1024  |   80000 | 1.6      | 16.74          | V100     | 70.24 |         72.77 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-512x1024.py)      | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18b-d8_512x1024_80k_cityscapes/fcn_r18b-d8_512x1024_80k_cityscapes_20201225_230143-92c0f445.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18b-d8_512x1024_80k_cityscapes/fcn_r18b-d8_512x1024_80k_cityscapes-20201225_230143.log.json)                     |
+| FCN        | R-50b-D8   | 512x1024  |   80000 | 5.6      | 4.20           | V100     | 75.65 |         77.59 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-512x1024.py)      | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50b-d8_512x1024_80k_cityscapes/fcn_r50b-d8_512x1024_80k_cityscapes_20201225_094221-82957416.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50b-d8_512x1024_80k_cityscapes/fcn_r50b-d8_512x1024_80k_cityscapes-20201225_094221.log.json)                     |
+| FCN        | R-101b-D8  | 512x1024  |   80000 | 9.1      | 2.73           | V100     | 77.37 |         78.77 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-512x1024.py)     | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101b-d8_512x1024_80k_cityscapes/fcn_r101b-d8_512x1024_80k_cityscapes_20201226_160213-4543858f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101b-d8_512x1024_80k_cityscapes/fcn_r101b-d8_512x1024_80k_cityscapes-20201226_160213.log.json)                 |
+| FCN        | R-18b-D8   | 769x769   |   80000 | 1.7      | 6.70           | V100     | 69.66 |         72.07 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-769x769.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18b-d8_769x769_80k_cityscapes/fcn_r18b-d8_769x769_80k_cityscapes_20201226_004430-32d504e5.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18b-d8_769x769_80k_cityscapes/fcn_r18b-d8_769x769_80k_cityscapes-20201226_004430.log.json)                         |
+| FCN        | R-50b-D8   | 769x769   |   80000 | 6.3      | 1.82           | V100     | 73.83 |         76.60 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-769x769.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50b-d8_769x769_80k_cityscapes/fcn_r50b-d8_769x769_80k_cityscapes_20201225_094223-94552d38.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50b-d8_769x769_80k_cityscapes/fcn_r50b-d8_769x769_80k_cityscapes-20201225_094223.log.json)                         |
+| FCN        | R-101b-D8  | 769x769   |   80000 | 10.3     | 1.15           | V100     | 77.02 |         78.67 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-769x769.py)      | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101b-d8_769x769_80k_cityscapes/fcn_r101b-d8_769x769_80k_cityscapes_20201226_170012-82be37e2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101b-d8_769x769_80k_cityscapes/fcn_r101b-d8_769x769_80k_cityscapes-20201226_170012.log.json)                     |
+| FCN (D6)   | R-50-D16   | 512x1024  |   40000 | 3.4      | 10.22          | TITAN Xp | 77.06 |         78.85 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_512x1024_40k_cityscapes/fcn_d6_r50-d16_512x1024_40k_cityscapes_20210305_130133-98d5d1bc.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_512x1024_40k_cityscapes/fcn_d6_r50-d16_512x1024_40k_cityscapes-20210305_130133.log.json)         |
+| FCN (D6)   | R-50-D16   | 512x1024  |   80000 | -        | 10.35          | TITAN Xp | 77.27 |         78.88 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_512x1024_80k_cityscapes/fcn_d6_r50-d16_512x1024_80k_cityscapes_20210306_115604-133c292f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_512x1024_80k_cityscapes/fcn_d6_r50-d16_512x1024_80k_cityscapes-20210306_115604.log.json)         |
+| FCN (D6)   | R-50-D16   | 769x769   |   40000 | 3.7      | 4.17           | TITAN Xp | 76.82 |         78.22 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-769x769.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_769x769_40k_cityscapes/fcn_d6_r50-d16_769x769_40k_cityscapes_20210305_185744-1aab18ed.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_769x769_40k_cityscapes/fcn_d6_r50-d16_769x769_40k_cityscapes-20210305_185744.log.json)             |
+| FCN (D6)   | R-50-D16   | 769x769   |   80000 | -        | 4.15           | TITAN Xp | 77.04 |         78.40 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-769x769.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_769x769_80k_cityscapes/fcn_d6_r50-d16_769x769_80k_cityscapes_20210305_200413-109d88eb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_769x769_80k_cityscapes/fcn_d6_r50-d16_769x769_80k_cityscapes-20210305_200413.log.json)             |
+| FCN (D6)   | R-101-D16  | 512x1024  |   40000 | 4.5      | 8.04           | TITAN Xp | 77.36 |         79.18 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_512x1024_40k_cityscapes/fcn_d6_r101-d16_512x1024_40k_cityscapes_20210305_130337-9cf2b450.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_512x1024_40k_cityscapes/fcn_d6_r101-d16_512x1024_40k_cityscapes-20210305_130337.log.json)     |
+| FCN (D6)   | R-101-D16  | 512x1024  |   80000 | -        | 8.26           | TITAN Xp | 78.46 |         80.42 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_512x1024_80k_cityscapes/fcn_d6_r101-d16_512x1024_80k_cityscapes_20210308_102747-cb336445.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_512x1024_80k_cityscapes/fcn_d6_r101-d16_512x1024_80k_cityscapes-20210308_102747.log.json)     |
+| FCN (D6)   | R-101-D16  | 769x769   |   40000 | 5.0      | 3.12           | TITAN Xp | 77.28 |         78.95 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_769x769_40k_cityscapes/fcn_d6_r101-d16_769x769_40k_cityscapes_20210308_102453-60b114e9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_769x769_40k_cityscapes/fcn_d6_r101-d16_769x769_40k_cityscapes-20210308_102453.log.json)         |
+| FCN (D6)   | R-101-D16  | 769x769   |   80000 | -        | 3.21           | TITAN Xp | 78.06 |         79.58 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_769x769_80k_cityscapes/fcn_d6_r101-d16_769x769_80k_cityscapes_20210306_120016-e33adc4f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_769x769_80k_cityscapes/fcn_d6_r101-d16_769x769_80k_cityscapes-20210306_120016.log.json)         |
+| FCN (D6)   | R-50b-D16  | 512x1024  |   80000 | 3.2      | 10.16          | TITAN Xp | 76.99 |         79.03 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50b-d16_512x1024_80k_cityscapes/fcn_d6_r50b-d16_512x1024_80k_cityscapes_20210311_125550-6a0b62e9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50b_d16_512x1024_80k_cityscapes/fcn_d6_r50b_d16_512x1024_80k_cityscapes-20210311_125550.log.json)     |
+| FCN (D6)   | R-50b-D16  | 769x769   |   80000 | 3.6      | 4.17           | TITAN Xp | 76.86 |         78.52 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50b-d16_769x769_80k_cityscapes/fcn_d6_r50b-d16_769x769_80k_cityscapes_20210311_131012-d665f231.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50b_d16_769x769_80k_cityscapes/fcn_d6_r50b_d16_769x769_80k_cityscapes-20210311_131012.log.json)         |
+| FCN (D6)   | R-101b-D16 | 512x1024  |   80000 | 4.3      | 8.46           | TITAN Xp | 77.72 |         79.53 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101b-d16_512x1024_80k_cityscapes/fcn_d6_r101b-d16_512x1024_80k_cityscapes_20210311_144305-3f2eb5b4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101b_d16_512x1024_80k_cityscapes/fcn_d6_r101b_d16_512x1024_80k_cityscapes-20210311_144305.log.json) |
+| FCN (D6)   | R-101b-D16 | 769x769   |   80000 | 4.8      | 3.32           | TITAN Xp | 77.34 |         78.91 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101b-d16_769x769_80k_cityscapes/fcn_d6_r101b-d16_769x769_80k_cityscapes_20210311_154527-c4d8bfbc.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101b_d16_769x769_80k_cityscapes/fcn_d6_r101b_d16_769x769_80k_cityscapes-20210311_154527.log.json)     |
+
+### ADE20K
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                               | download                                                                                                                                                                                                                                                                                                               |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FCN    | R-50-D8  | 512x512   |   80000 | 8.5      | 23.49          | V100   | 35.94 |         37.94 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_80k_ade20k/fcn_r50-d8_512x512_80k_ade20k_20200614_144016-f8ac5082.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_80k_ade20k/fcn_r50-d8_512x512_80k_ade20k_20200614_144016.log.json)         |
+| FCN    | R-101-D8 | 512x512   |   80000 | 12       | 14.78          | V100   | 39.61 |         40.83 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb4-80k_ade20k-512x512.pyy) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_80k_ade20k/fcn_r101-d8_512x512_80k_ade20k_20200615_014143-bc1809f7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_80k_ade20k/fcn_r101-d8_512x512_80k_ade20k_20200615_014143.log.json)     |
+| FCN    | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 36.10 |         38.08 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_160k_ade20k/fcn_r50-d8_512x512_160k_ade20k_20200615_100713-4edbc3b4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_160k_ade20k/fcn_r50-d8_512x512_160k_ade20k_20200615_100713.log.json)     |
+| FCN    | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 39.91 |         41.40 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_160k_ade20k/fcn_r101-d8_512x512_160k_ade20k_20200615_105816-fd192bd5.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_160k_ade20k/fcn_r101-d8_512x512_160k_ade20k_20200615_105816.log.json) |
+
+### Pascal VOC 2012 + Aug
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                | download                                                                                                                                                                                                                                                                                                                   |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | --------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FCN    | R-50-D8  | 512x512   |   20000 | 5.7      | 23.28          | V100   | 67.08 |         69.94 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r50-d8_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_20k_voc12aug/fcn_r50-d8_512x512_20k_voc12aug_20200617_010715-52dc5306.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_20k_voc12aug/fcn_r50-d8_512x512_20k_voc12aug_20200617_010715.log.json)     |
+| FCN    | R-101-D8 | 512x512   |   20000 | 9.2      | 14.81          | V100   | 71.16 |         73.57 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_20k_voc12aug/fcn_r101-d8_512x512_20k_voc12aug_20200617_010842-0bb4e798.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_20k_voc12aug/fcn_r101-d8_512x512_20k_voc12aug_20200617_010842.log.json) |
+| FCN    | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 66.97 |         69.04 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r50-d8_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_40k_voc12aug/fcn_r50-d8_512x512_40k_voc12aug_20200613_161222-5e2dbf40.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_40k_voc12aug/fcn_r50-d8_512x512_40k_voc12aug_20200613_161222.log.json)     |
+| FCN    | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 69.91 |         72.38 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_40k_voc12aug/fcn_r101-d8_512x512_40k_voc12aug_20200613_161240-4c8bcefd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_40k_voc12aug/fcn_r101-d8_512x512_40k_voc12aug_20200613_161240.log.json) |
+
+### Pascal Context
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                      | download                                                                                                                                                                                                                                                                                                                                           |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | --------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FCN    | R-101-D8 | 480x480   |   40000 | -        | 9.93           | V100   | 44.43 |         45.63 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_40k_pascal_context/fcn_r101-d8_480x480_40k_pascal_context_20210421_154757-b5e97937.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_40k_pascal_context/fcn_r101-d8_480x480_40k_pascal_context-20210421_154757.log.json) |
+| FCN    | R-101-D8 | 480x480   |   80000 | -        | -              | V100   | 44.13 |         45.26 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_80k_pascal_context/fcn_r101-d8_480x480_80k_pascal_context_20210421_163310-4711813f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_80k_pascal_context/fcn_r101-d8_480x480_80k_pascal_context-20210421_163310.log.json) |
+
+### Pascal Context 59
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                         | download                                                                                                                                                                                                                                                                                                                                                       |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FCN    | R-101-D8 | 480x480   |   40000 | -        | -              | V100   | 48.42 |          50.4 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-59-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_40k_pascal_context_59/fcn_r101-d8_480x480_40k_pascal_context_59_20210415_230724-8cf83682.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_40k_pascal_context_59/fcn_r101-d8_480x480_40k_pascal_context_59-20210415_230724.log.json) |
+| FCN    | R-101-D8 | 480x480   |   80000 | -        | -              | V100   | 49.35 |         51.38 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-59-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_80k_pascal_context_59/fcn_r101-d8_480x480_80k_pascal_context_59_20210416_110804-9a6f2c94.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_80k_pascal_context_59/fcn_r101-d8_480x480_80k_pascal_context_59-20210416_110804.log.json) |
+
+Note:
+
+- `FP16` means Mixed Precision (FP16) is adopted in training.
+- `FCN D6` means dilation rate of convolution operator in FCN is 6.
+
+## Citation
+
+```bibtex
+@article{shelhamer2017fully,
+  title={Fully convolutional networks for semantic segmentation},
+  author={Shelhamer, Evan and Long, Jonathan and Darrell, Trevor},
+  journal={IEEE transactions on pattern analysis and machine intelligence},
+  volume={39},
+  number={4},
+  pages={640--651},
+  year={2017},
+  publisher={IEEE Trans Pattern Anal Mach Intell}
+}
+```
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..8f2cd02
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './fcn-d6_r50-d16_4xb2-40k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..4782b30
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './fcn-d6_r50-d16_4xb2-40k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..5f654b4
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './fcn-d6_r50-d16_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..91eca1c
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './fcn-d6_r50-d16_4xb2-80k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..62e6127
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,4 @@
+_base_ = './fcn-d6_r50-d16_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='torchvision://resnet101',
+    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..1b8d247
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,4 @@
+_base_ = './fcn-d6_r50b-d16_4xb2-80k_cityscapes-769x769.py'
+model = dict(
+    pretrained='torchvision://resnet101',
+    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..9a1efb4
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/fcn_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(dilations=(1, 1, 1, 2), strides=(1, 2, 2, 1)),
+    decode_head=dict(dilation=6),
+    auxiliary_head=dict(dilation=6))
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..2b2a6f4
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,13 @@
+_base_ = [
+    '../_base_/models/fcn_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(dilations=(1, 1, 1, 2), strides=(1, 2, 2, 1)),
+    decode_head=dict(align_corners=True, dilation=6),
+    auxiliary_head=dict(align_corners=True, dilation=6),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..e6cca00
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/fcn_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(dilations=(1, 1, 1, 2), strides=(1, 2, 2, 1)),
+    decode_head=dict(dilation=6),
+    auxiliary_head=dict(dilation=6))
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..990ff9c
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,13 @@
+_base_ = [
+    '../_base_/models/fcn_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(dilations=(1, 1, 1, 2), strides=(1, 2, 2, 1)),
+    decode_head=dict(align_corners=True, dilation=6),
+    auxiliary_head=dict(align_corners=True, dilation=6),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..7d470a5
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './fcn-d6_r50-d16_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='torchvision://resnet50', backbone=dict(type='ResNet'))
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..e9093ea
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './fcn-d6_r50-d16_4xb2-80k_cityscapes-769x769.py'
+model = dict(pretrained='torchvision://resnet50', backbone=dict(type='ResNet'))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..b3ec0a7
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..1f83fe2
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './fcn_r50-d8_4xb2-40k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..4527b3b
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..6ce1124
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './fcn_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..b4d9487
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
@@ -0,0 +1,6 @@
+_base_ = './fcn_r101-d8_4xb2-80k_cityscapes-512x1024.py'
+optim_wrapper = dict(
+    _delete_=True,
+    type='AmpOptimWrapper',
+    optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005),
+    loss_scale=512.)
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..b1f5c5c
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './fcn_r50-d8_4xb4-160k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..61ee96f
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './fcn_r50-d8_4xb4-20k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-480x480.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-480x480.py
new file mode 100644
index 0000000..1161193
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-480x480.py
@@ -0,0 +1,2 @@
+_base_ = './fcn_r50-d8_4xb4-40k_pascal-context-480x480.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-59-480x480.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-59-480x480.py
new file mode 100644
index 0000000..f3a6dbc
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-59-480x480.py
@@ -0,0 +1,2 @@
+_base_ = './fcn_r50-d8_4xb4-40k_pascal-context-59-480x480.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..b68b6e0
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './fcn_r50-d8_4xb4-40k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..3facce3
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './fcn_r50-d8_4xb4-80k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-480x480.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-480x480.py
new file mode 100644
index 0000000..1161193
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-480x480.py
@@ -0,0 +1,2 @@
+_base_ = './fcn_r50-d8_4xb4-40k_pascal-context-480x480.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-59-480x480.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-59-480x480.py
new file mode 100644
index 0000000..cebe330
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-59-480x480.py
@@ -0,0 +1,2 @@
+_base_ = './fcn_r50-d8_4xb4-80k_pascal-context-59-480x480.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..e53751b
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,4 @@
+_base_ = './fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='torchvision://resnet101',
+    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..daa6502
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,4 @@
+_base_ = './fcn_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(
+    pretrained='torchvision://resnet101',
+    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..4073148
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,9 @@
+_base_ = './fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='open-mmlab://resnet18_v1c',
+    backbone=dict(depth=18),
+    decode_head=dict(
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..2c1d2b6
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,9 @@
+_base_ = './fcn_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(
+    pretrained='open-mmlab://resnet18_v1c',
+    backbone=dict(depth=18),
+    decode_head=dict(
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..08ab467
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,9 @@
+_base_ = './fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='torchvision://resnet18',
+    backbone=dict(type='ResNet', depth=18),
+    decode_head=dict(
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..c591ebe
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,9 @@
+_base_ = './fcn_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(
+    pretrained='torchvision://resnet18',
+    backbone=dict(type='ResNet', depth=18),
+    decode_head=dict(
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..4fba723
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/fcn_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..d57afe1
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/fcn_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..6b1fdae
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/fcn_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..8a713fd
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/fcn_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..258b9fb
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/fcn_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..eac86d5
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/fcn_r50-d8.py', '../_base_/datasets/pascal_voc12_aug.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_20k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_pascal-context-480x480.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_pascal-context-480x480.py
new file mode 100644
index 0000000..d99cb0d
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_pascal-context-480x480.py
@@ -0,0 +1,13 @@
+_base_ = [
+    '../_base_/models/fcn_r50-d8.py', '../_base_/datasets/pascal_context.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (480, 480)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=60),
+    auxiliary_head=dict(num_classes=60),
+    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
+optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_pascal-context-59-480x480.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_pascal-context-59-480x480.py
new file mode 100644
index 0000000..64c9410
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_pascal-context-59-480x480.py
@@ -0,0 +1,14 @@
+_base_ = [
+    '../_base_/models/fcn_r50-d8.py',
+    '../_base_/datasets/pascal_context_59.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (480, 480)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=59),
+    auxiliary_head=dict(num_classes=59),
+    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
+optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..42edb46
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/fcn_r50-d8.py', '../_base_/datasets/pascal_voc12_aug.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..099f6af
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/fcn_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_pascal-context-480x480.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_pascal-context-480x480.py
new file mode 100644
index 0000000..1eeafb8
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_pascal-context-480x480.py
@@ -0,0 +1,13 @@
+_base_ = [
+    '../_base_/models/fcn_r50-d8.py', '../_base_/datasets/pascal_context.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (480, 480)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=60),
+    auxiliary_head=dict(num_classes=60),
+    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
+optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_pascal-context-59-480x480.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_pascal-context-59-480x480.py
new file mode 100644
index 0000000..c11a9bb
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_pascal-context-59-480x480.py
@@ -0,0 +1,14 @@
+_base_ = [
+    '../_base_/models/fcn_r50-d8.py',
+    '../_base_/datasets/pascal_context_59.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (480, 480)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=59),
+    auxiliary_head=dict(num_classes=59),
+    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
+optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..44821fd
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='torchvision://resnet50', backbone=dict(type='ResNet'))
diff --git a/mmsegmentation/configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..a85b391
--- /dev/null
+++ b/mmsegmentation/configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './fcn_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(pretrained='torchvision://resnet50', backbone=dict(type='ResNet'))
diff --git a/mmsegmentation/configs/fcn/metafile.yaml b/mmsegmentation/configs/fcn/metafile.yaml
new file mode 100644
index 0000000..f3d80f6
--- /dev/null
+++ b/mmsegmentation/configs/fcn/metafile.yaml
@@ -0,0 +1,997 @@
+Collections:
+- Name: FCN
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+    - ADE20K
+    - Pascal VOC 2012 + Aug
+    - Pascal Context
+    - Pascal Context 59
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  README: configs/fcn/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: fcn_r50-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 72.25
+      mIoU(ms+flip): 73.36
+  Config: configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.7
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x1024_40k_cityscapes/fcn_r50-d8_512x1024_40k_cityscapes_20200604_192608-efe53f0d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x1024_40k_cityscapes/fcn_r50-d8_512x1024_40k_cityscapes_20200604_192608.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r101-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 75.45
+      mIoU(ms+flip): 76.58
+  Config: configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x1024_40k_cityscapes/fcn_r101-d8_512x1024_40k_cityscapes_20200604_181852-a883d3a1.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x1024_40k_cityscapes/fcn_r101-d8_512x1024_40k_cityscapes_20200604_181852.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r50-d8_4xb2-40k_cityscapes-769x769
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 71.47
+      mIoU(ms+flip): 72.54
+  Config: configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_769x769_40k_cityscapes/fcn_r50-d8_769x769_40k_cityscapes_20200606_113104-977b5d02.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_769x769_40k_cityscapes/fcn_r50-d8_769x769_40k_cityscapes_20200606_113104.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r101-d8_4xb2-40k_cityscapes-769x769
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 73.93
+      mIoU(ms+flip): 75.14
+  Config: configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.4
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_769x769_40k_cityscapes/fcn_r101-d8_769x769_40k_cityscapes_20200606_113208-7d4ab69c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_769x769_40k_cityscapes/fcn_r101-d8_769x769_40k_cityscapes_20200606_113208.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r18-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 71.11
+      mIoU(ms+flip): 72.91
+  Config: configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-18-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.7
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18-d8_512x1024_80k_cityscapes/fcn_r18-d8_512x1024_80k_cityscapes_20201225_021327-6c50f8b4.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18-d8_512x1024_80k_cityscapes/fcn_r18-d8_512x1024_80k_cityscapes-20201225_021327.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r50-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 73.61
+      mIoU(ms+flip): 74.24
+  Config: configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x1024_80k_cityscapes/fcn_r50-d8_512x1024_80k_cityscapes_20200606_113019-03aa804d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x1024_80k_cityscapes/fcn_r50-d8_512x1024_80k_cityscapes_20200606_113019.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r101-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 75.13
+      mIoU(ms+flip): 75.94
+  Config: configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x1024_80k_cityscapes/fcn_r101-d8_512x1024_80k_cityscapes_20200606_113038-3fb937eb.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x1024_80k_cityscapes/fcn_r101-d8_512x1024_80k_cityscapes_20200606_113038.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r101-d8_4xb2-amp-80k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.8
+  Config: configs/fcn/fcn_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - FCN
+    - (FP16)
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.37
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_fp16_512x1024_80k_cityscapes/fcn_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230921-fb13e883.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_fp16_512x1024_80k_cityscapes/fcn_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230921.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r18-d8_4xb2-80k_cityscapes-769x769
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 70.8
+      mIoU(ms+flip): 73.16
+  Config: configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-18-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18-d8_769x769_80k_cityscapes/fcn_r18-d8_769x769_80k_cityscapes_20201225_021451-9739d1b8.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18-d8_769x769_80k_cityscapes/fcn_r18-d8_769x769_80k_cityscapes-20201225_021451.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r50-d8_4xb2-80k_cityscapes-769x769
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 72.64
+      mIoU(ms+flip): 73.32
+  Config: configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_769x769_80k_cityscapes/fcn_r50-d8_769x769_80k_cityscapes_20200606_195749-f5caeabc.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_769x769_80k_cityscapes/fcn_r50-d8_769x769_80k_cityscapes_20200606_195749.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r101-d8_4xb2-80k_cityscapes-769x769
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 75.52
+      mIoU(ms+flip): 76.61
+  Config: configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_769x769_80k_cityscapes/fcn_r101-d8_769x769_80k_cityscapes_20200606_214354-45cbac68.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_769x769_80k_cityscapes/fcn_r101-d8_769x769_80k_cityscapes_20200606_214354.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r18b-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 70.24
+      mIoU(ms+flip): 72.77
+  Config: configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-18b-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18b-d8_512x1024_80k_cityscapes/fcn_r18b-d8_512x1024_80k_cityscapes_20201225_230143-92c0f445.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18b-d8_512x1024_80k_cityscapes/fcn_r18b-d8_512x1024_80k_cityscapes-20201225_230143.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r50b-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 75.65
+      mIoU(ms+flip): 77.59
+  Config: configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50b-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50b-d8_512x1024_80k_cityscapes/fcn_r50b-d8_512x1024_80k_cityscapes_20201225_094221-82957416.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50b-d8_512x1024_80k_cityscapes/fcn_r50b-d8_512x1024_80k_cityscapes-20201225_094221.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r101b-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.37
+      mIoU(ms+flip): 78.77
+  Config: configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101b-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101b-d8_512x1024_80k_cityscapes/fcn_r101b-d8_512x1024_80k_cityscapes_20201226_160213-4543858f.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101b-d8_512x1024_80k_cityscapes/fcn_r101b-d8_512x1024_80k_cityscapes-20201226_160213.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r18b-d8_4xb2-80k_cityscapes-769x769
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 69.66
+      mIoU(ms+flip): 72.07
+  Config: configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-18b-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.7
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18b-d8_769x769_80k_cityscapes/fcn_r18b-d8_769x769_80k_cityscapes_20201226_004430-32d504e5.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18b-d8_769x769_80k_cityscapes/fcn_r18b-d8_769x769_80k_cityscapes-20201226_004430.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r50b-d8_4xb2-80k_cityscapes-769x769
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 73.83
+      mIoU(ms+flip): 76.6
+  Config: configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50b-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.3
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50b-d8_769x769_80k_cityscapes/fcn_r50b-d8_769x769_80k_cityscapes_20201225_094223-94552d38.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50b-d8_769x769_80k_cityscapes/fcn_r50b-d8_769x769_80k_cityscapes-20201225_094223.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r101b-d8_4xb2-80k_cityscapes-769x769
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.02
+      mIoU(ms+flip): 78.67
+  Config: configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101b-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.3
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101b-d8_769x769_80k_cityscapes/fcn_r101b-d8_769x769_80k_cityscapes_20201226_170012-82be37e2.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101b-d8_769x769_80k_cityscapes/fcn_r101b-d8_769x769_80k_cityscapes-20201226_170012.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn-d6_r50-d16_4xb2-40k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.06
+      mIoU(ms+flip): 78.85
+  Config: configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D16
+    - FCN
+    - (D6)
+    Training Resources: 4x TITAN Xp GPUS
+    Memory (GB): 3.4
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_512x1024_40k_cityscapes/fcn_d6_r50-d16_512x1024_40k_cityscapes_20210305_130133-98d5d1bc.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_512x1024_40k_cityscapes/fcn_d6_r50-d16_512x1024_40k_cityscapes-20210305_130133.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn-d6_r50-d16_4xb2-80k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.27
+      mIoU(ms+flip): 78.88
+  Config: configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D16
+    - FCN
+    - (D6)
+    Training Resources: 4x TITAN Xp GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_512x1024_80k_cityscapes/fcn_d6_r50-d16_512x1024_80k_cityscapes_20210306_115604-133c292f.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_512x1024_80k_cityscapes/fcn_d6_r50-d16_512x1024_80k_cityscapes-20210306_115604.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn-d6_r50-d16_4xb2-40k_cityscapes-769x769
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.82
+      mIoU(ms+flip): 78.22
+  Config: configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D16
+    - FCN
+    - (D6)
+    Training Resources: 4x TITAN Xp GPUS
+    Memory (GB): 3.7
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_769x769_40k_cityscapes/fcn_d6_r50-d16_769x769_40k_cityscapes_20210305_185744-1aab18ed.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_769x769_40k_cityscapes/fcn_d6_r50-d16_769x769_40k_cityscapes-20210305_185744.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn-d6_r50-d16_4xb2-80k_cityscapes-769x769
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.04
+      mIoU(ms+flip): 78.4
+  Config: configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D16
+    - FCN
+    - (D6)
+    Training Resources: 4x TITAN Xp GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_769x769_80k_cityscapes/fcn_d6_r50-d16_769x769_80k_cityscapes_20210305_200413-109d88eb.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_769x769_80k_cityscapes/fcn_d6_r50-d16_769x769_80k_cityscapes-20210305_200413.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn-d6_r101-d16_4xb2-40k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.36
+      mIoU(ms+flip): 79.18
+  Config: configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D16
+    - FCN
+    - (D6)
+    Training Resources: 4x TITAN Xp GPUS
+    Memory (GB): 4.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_512x1024_40k_cityscapes/fcn_d6_r101-d16_512x1024_40k_cityscapes_20210305_130337-9cf2b450.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_512x1024_40k_cityscapes/fcn_d6_r101-d16_512x1024_40k_cityscapes-20210305_130337.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn-d6_r101-d16_4xb2-80k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.46
+      mIoU(ms+flip): 80.42
+  Config: configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D16
+    - FCN
+    - (D6)
+    Training Resources: 4x TITAN Xp GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_512x1024_80k_cityscapes/fcn_d6_r101-d16_512x1024_80k_cityscapes_20210308_102747-cb336445.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_512x1024_80k_cityscapes/fcn_d6_r101-d16_512x1024_80k_cityscapes-20210308_102747.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn-d6_r101-d16_4xb2-40k_cityscapes-769x769
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.28
+      mIoU(ms+flip): 78.95
+  Config: configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D16
+    - FCN
+    - (D6)
+    Training Resources: 4x TITAN Xp GPUS
+    Memory (GB): 5.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_769x769_40k_cityscapes/fcn_d6_r101-d16_769x769_40k_cityscapes_20210308_102453-60b114e9.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_769x769_40k_cityscapes/fcn_d6_r101-d16_769x769_40k_cityscapes-20210308_102453.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn-d6_r101-d16_4xb2-80k_cityscapes-769x769
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.06
+      mIoU(ms+flip): 79.58
+  Config: configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D16
+    - FCN
+    - (D6)
+    Training Resources: 4x TITAN Xp GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_769x769_80k_cityscapes/fcn_d6_r101-d16_769x769_80k_cityscapes_20210306_120016-e33adc4f.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_769x769_80k_cityscapes/fcn_d6_r101-d16_769x769_80k_cityscapes-20210306_120016.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn-d6_r50b-d16_4xb2-80k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.99
+      mIoU(ms+flip): 79.03
+  Config: configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50b-D16
+    - FCN
+    - (D6)
+    Training Resources: 4x TITAN Xp GPUS
+    Memory (GB): 3.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50b-d16_512x1024_80k_cityscapes/fcn_d6_r50b-d16_512x1024_80k_cityscapes_20210311_125550-6a0b62e9.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50b_d16_512x1024_80k_cityscapes/fcn_d6_r50b_d16_512x1024_80k_cityscapes-20210311_125550.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn-d6_r50b-d16_4xb2-80k_cityscapes-769x769
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.86
+      mIoU(ms+flip): 78.52
+  Config: configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50b-D16
+    - FCN
+    - (D6)
+    Training Resources: 4x TITAN Xp GPUS
+    Memory (GB): 3.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50b-d16_769x769_80k_cityscapes/fcn_d6_r50b-d16_769x769_80k_cityscapes_20210311_131012-d665f231.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50b_d16_769x769_80k_cityscapes/fcn_d6_r50b_d16_769x769_80k_cityscapes-20210311_131012.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn-d6_r101b-d16_4xb2-80k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.72
+      mIoU(ms+flip): 79.53
+  Config: configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101b-D16
+    - FCN
+    - (D6)
+    Training Resources: 4x TITAN Xp GPUS
+    Memory (GB): 4.3
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101b-d16_512x1024_80k_cityscapes/fcn_d6_r101b-d16_512x1024_80k_cityscapes_20210311_144305-3f2eb5b4.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101b_d16_512x1024_80k_cityscapes/fcn_d6_r101b_d16_512x1024_80k_cityscapes-20210311_144305.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn-d6_r101b-d16_4xb2-80k_cityscapes-769x769
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.34
+      mIoU(ms+flip): 78.91
+  Config: configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101b-D16
+    - FCN
+    - (D6)
+    Training Resources: 4x TITAN Xp GPUS
+    Memory (GB): 4.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101b-d16_769x769_80k_cityscapes/fcn_d6_r101b-d16_769x769_80k_cityscapes_20210311_154527-c4d8bfbc.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101b_d16_769x769_80k_cityscapes/fcn_d6_r101b_d16_769x769_80k_cityscapes-20210311_154527.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r50-d8_4xb4-80k_ade20k-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 35.94
+      mIoU(ms+flip): 37.94
+  Config: configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_80k_ade20k/fcn_r50-d8_512x512_80k_ade20k_20200614_144016-f8ac5082.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_80k_ade20k/fcn_r50-d8_512x512_80k_ade20k_20200614_144016.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r101-d8_4xb4-80k_ade20k-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 39.61
+      mIoU(ms+flip): 40.83
+  Config: configs/fcn/fcn_r101-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 12.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_80k_ade20k/fcn_r101-d8_512x512_80k_ade20k_20200615_014143-bc1809f7.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_80k_ade20k/fcn_r101-d8_512x512_80k_ade20k_20200615_014143.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r50-d8_4xb4-160k_ade20k-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 36.1
+      mIoU(ms+flip): 38.08
+  Config: configs/fcn/fcn_r50-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_160k_ade20k/fcn_r50-d8_512x512_160k_ade20k_20200615_100713-4edbc3b4.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_160k_ade20k/fcn_r50-d8_512x512_160k_ade20k_20200615_100713.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r101-d8_4xb4-160k_ade20k-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 39.91
+      mIoU(ms+flip): 41.4
+  Config: configs/fcn/fcn_r101-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_160k_ade20k/fcn_r101-d8_512x512_160k_ade20k_20200615_105816-fd192bd5.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_160k_ade20k/fcn_r101-d8_512x512_160k_ade20k_20200615_105816.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r50-d8_4xb4-20k_voc12aug-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 67.08
+      mIoU(ms+flip): 69.94
+  Config: configs/fcn/fcn_r50-d8_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.7
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_20k_voc12aug/fcn_r50-d8_512x512_20k_voc12aug_20200617_010715-52dc5306.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_20k_voc12aug/fcn_r50-d8_512x512_20k_voc12aug_20200617_010715.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r101-d8_4xb4-20k_voc12aug-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 71.16
+      mIoU(ms+flip): 73.57
+  Config: configs/fcn/fcn_r101-d8_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_20k_voc12aug/fcn_r101-d8_512x512_20k_voc12aug_20200617_010842-0bb4e798.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_20k_voc12aug/fcn_r101-d8_512x512_20k_voc12aug_20200617_010842.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r50-d8_4xb4-40k_voc12aug-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 66.97
+      mIoU(ms+flip): 69.04
+  Config: configs/fcn/fcn_r50-d8_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_40k_voc12aug/fcn_r50-d8_512x512_40k_voc12aug_20200613_161222-5e2dbf40.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_40k_voc12aug/fcn_r50-d8_512x512_40k_voc12aug_20200613_161222.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r101-d8_4xb4-40k_voc12aug-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 69.91
+      mIoU(ms+flip): 72.38
+  Config: configs/fcn/fcn_r101-d8_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_40k_voc12aug/fcn_r101-d8_512x512_40k_voc12aug_20200613_161240-4c8bcefd.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_40k_voc12aug/fcn_r101-d8_512x512_40k_voc12aug_20200613_161240.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r101-d8_4xb4-40k_pascal-context-480x480
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal Context
+    Metrics:
+      mIoU: 44.43
+      mIoU(ms+flip): 45.63
+  Config: configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-480x480.py
+  Metadata:
+    Training Data: Pascal Context
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_40k_pascal_context/fcn_r101-d8_480x480_40k_pascal_context_20210421_154757-b5e97937.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_40k_pascal_context/fcn_r101-d8_480x480_40k_pascal_context-20210421_154757.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r101-d8_4xb4-80k_pascal-context-480x480
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal Context
+    Metrics:
+      mIoU: 44.13
+      mIoU(ms+flip): 45.26
+  Config: configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-480x480.py
+  Metadata:
+    Training Data: Pascal Context
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_80k_pascal_context/fcn_r101-d8_480x480_80k_pascal_context_20210421_163310-4711813f.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_80k_pascal_context/fcn_r101-d8_480x480_80k_pascal_context-20210421_163310.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r101-d8_4xb4-40k_pascal-context-59-480x480
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal Context 59
+    Metrics:
+      mIoU: 48.42
+      mIoU(ms+flip): 50.4
+  Config: configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-59-480x480.py
+  Metadata:
+    Training Data: Pascal Context 59
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_40k_pascal_context_59/fcn_r101-d8_480x480_40k_pascal_context_59_20210415_230724-8cf83682.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_40k_pascal_context_59/fcn_r101-d8_480x480_40k_pascal_context_59-20210415_230724.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
+- Name: fcn_r101-d8_4xb4-80k_pascal-context-59-480x480
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal Context 59
+    Metrics:
+      mIoU: 49.35
+      mIoU(ms+flip): 51.38
+  Config: configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-59-480x480.py
+  Metadata:
+    Training Data: Pascal Context 59
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_80k_pascal_context_59/fcn_r101-d8_480x480_80k_pascal_context_59_20210416_110804-9a6f2c94.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_80k_pascal_context_59/fcn_r101-d8_480x480_80k_pascal_context_59-20210416_110804.log.json
+  Paper:
+    Title: Fully Convolutional Networks for Semantic Segmentation
+    URL: https://arxiv.org/abs/1411.4038
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/gcnet/README.md b/mmsegmentation/configs/gcnet/README.md
new file mode 100644
index 0000000..ba1a21e
--- /dev/null
+++ b/mmsegmentation/configs/gcnet/README.md
@@ -0,0 +1,68 @@
+# GCNet
+
+> [GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond](https://arxiv.org/abs/1904.11492)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/xvjiarui/GCNet">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+The Non-Local Network (NLNet) presents a pioneering approach for capturing long-range dependencies, via aggregating query-specific global context to each query position. However, through a rigorous empirical analysis, we have found that the global contexts modeled by non-local network are almost the same for different query positions within an image. In this paper, we take advantage of this finding to create a simplified network based on a query-independent formulation, which maintains the accuracy of NLNet but with significantly less computation. We further observe that this simplified design shares similar structure with Squeeze-Excitation Network (SENet). Hence we unify them into a three-step general framework for global context modeling. Within the general framework, we design a better instantiation, called the global context (GC) block, which is lightweight and can effectively model the global context. The lightweight property allows us to apply it for multiple layers in a backbone network to construct a global context network (GCNet), which generally outperforms both simplified NLNet and SENet on major benchmarks for various recognition tasks. The code and configurations are released at [this https URL](https://github.com/xvjiarui/GCNet).
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142901601-ad17922e-2538-4b48-9f51-84a57d44b12b.png" width="80%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                        | download                                                                                                                                                                                                                                                                                                                                           |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ----------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GCNet  | R-50-D8  | 512x1024  |   40000 | 5.8      | 3.93           | V100   | 77.69 |         78.56 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x1024_40k_cityscapes/gcnet_r50-d8_512x1024_40k_cityscapes_20200618_074436-4b0fd17b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x1024_40k_cityscapes/gcnet_r50-d8_512x1024_40k_cityscapes_20200618_074436.log.json)     |
+| GCNet  | R-101-D8 | 512x1024  |   40000 | 9.2      | 2.61           | V100   | 78.28 |         79.34 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x1024_40k_cityscapes/gcnet_r101-d8_512x1024_40k_cityscapes_20200618_074436-5e62567f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x1024_40k_cityscapes/gcnet_r101-d8_512x1024_40k_cityscapes_20200618_074436.log.json) |
+| GCNet  | R-50-D8  | 769x769   |   40000 | 6.5      | 1.67           | V100   | 78.12 |         80.09 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-769x769.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_769x769_40k_cityscapes/gcnet_r50-d8_769x769_40k_cityscapes_20200618_182814-a26f4471.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_769x769_40k_cityscapes/gcnet_r50-d8_769x769_40k_cityscapes_20200618_182814.log.json)         |
+| GCNet  | R-101-D8 | 769x769   |   40000 | 10.5     | 1.13           | V100   | 78.95 |         80.71 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_769x769_40k_cityscapes/gcnet_r101-d8_769x769_40k_cityscapes_20200619_092550-ca4f0a84.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_769x769_40k_cityscapes/gcnet_r101-d8_769x769_40k_cityscapes_20200619_092550.log.json)     |
+| GCNet  | R-50-D8  | 512x1024  |   80000 | -        | -              | V100   | 78.48 |         80.01 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x1024_80k_cityscapes/gcnet_r50-d8_512x1024_80k_cityscapes_20200618_074450-ef8f069b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x1024_80k_cityscapes/gcnet_r50-d8_512x1024_80k_cityscapes_20200618_074450.log.json)     |
+| GCNet  | R-101-D8 | 512x1024  |   80000 | -        | -              | V100   | 79.03 |         79.84 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-512x1024.pyy) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x1024_80k_cityscapes/gcnet_r101-d8_512x1024_80k_cityscapes_20200618_074450-778ebf69.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x1024_80k_cityscapes/gcnet_r101-d8_512x1024_80k_cityscapes_20200618_074450.log.json) |
+| GCNet  | R-50-D8  | 769x769   |   80000 | -        | -              | V100   | 78.68 |         80.66 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-769x769.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_769x769_80k_cityscapes/gcnet_r50-d8_769x769_80k_cityscapes_20200619_092516-4839565b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_769x769_80k_cityscapes/gcnet_r50-d8_769x769_80k_cityscapes_20200619_092516.log.json)         |
+| GCNet  | R-101-D8 | 769x769   |   80000 | -        | -              | V100   | 79.18 |         80.71 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_769x769_80k_cityscapes/gcnet_r101-d8_769x769_80k_cityscapes_20200619_092628-8e043423.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_769x769_80k_cityscapes/gcnet_r101-d8_769x769_80k_cityscapes_20200619_092628.log.json)     |
+
+### ADE20K
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                   | download                                                                                                                                                                                                                                                                                                                           |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GCNet  | R-50-D8  | 512x512   |   80000 | 8.5      | 23.38          | V100   | 41.47 |         42.85 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_80k_ade20k/gcnet_r50-d8_512x512_80k_ade20k_20200614_185146-91a6da41.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_80k_ade20k/gcnet_r50-d8_512x512_80k_ade20k_20200614_185146.log.json)         |
+| GCNet  | R-101-D8 | 512x512   |   80000 | 12       | 15.20          | V100   | 42.82 |         44.54 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_80k_ade20k/gcnet_r101-d8_512x512_80k_ade20k_20200615_020811-c3fcb6dd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_80k_ade20k/gcnet_r101-d8_512x512_80k_ade20k_20200615_020811.log.json)     |
+| GCNet  | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 42.37 |         43.52 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_160k_ade20k/gcnet_r50-d8_512x512_160k_ade20k_20200615_224122-d95f3e1f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_160k_ade20k/gcnet_r50-d8_512x512_160k_ade20k_20200615_224122.log.json)     |
+| GCNet  | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 43.69 |         45.21 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_160k_ade20k/gcnet_r101-d8_512x512_160k_ade20k_20200615_225406-615528d7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_160k_ade20k/gcnet_r101-d8_512x512_160k_ade20k_20200615_225406.log.json) |
+
+### Pascal VOC 2012 + Aug
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                    | download                                                                                                                                                                                                                                                                                                                               |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GCNet  | R-50-D8  | 512x512   |   20000 | 5.8      | 23.35          | V100   | 76.42 |         77.51 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r50-d8_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_20k_voc12aug/gcnet_r50-d8_512x512_20k_voc12aug_20200617_165701-3cbfdab1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_20k_voc12aug/gcnet_r50-d8_512x512_20k_voc12aug_20200617_165701.log.json)     |
+| GCNet  | R-101-D8 | 512x512   |   20000 | 9.2      | 14.80          | V100   | 77.41 |         78.56 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r101-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_20k_voc12aug/gcnet_r101-d8_512x512_20k_voc12aug_20200617_165713-6c720aa9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_20k_voc12aug/gcnet_r101-d8_512x512_20k_voc12aug_20200617_165713.log.json) |
+| GCNet  | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 76.24 |         77.63 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r50-d8_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_40k_voc12aug/gcnet_r50-d8_512x512_40k_voc12aug_20200613_195105-9797336d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_40k_voc12aug/gcnet_r50-d8_512x512_40k_voc12aug_20200613_195105.log.json)     |
+| GCNet  | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 77.84 |         78.59 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r101-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_40k_voc12aug/gcnet_r101-d8_512x512_40k_voc12aug_20200613_185806-1e38208d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_40k_voc12aug/gcnet_r101-d8_512x512_40k_voc12aug_20200613_185806.log.json) |
+
+## Citation
+
+```bibtex
+@inproceedings{cao2019gcnet,
+  title={Gcnet: Non-local networks meet squeeze-excitation networks and beyond},
+  author={Cao, Yue and Xu, Jiarui and Lin, Stephen and Wei, Fangyun and Hu, Han},
+  booktitle={Proceedings of the IEEE International Conference on Computer Vision Workshops},
+  pages={0--0},
+  year={2019}
+}
+```
diff --git a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..e8f7c55
--- /dev/null
+++ b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './gcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..887d17b
--- /dev/null
+++ b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './gcnet_r50-d8_4xb2-40k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..aa47578
--- /dev/null
+++ b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './gcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..ddf4ad7
--- /dev/null
+++ b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './gcnet_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..45285c0
--- /dev/null
+++ b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './gcnet_r50-d8_4xb4-160k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..b466c40
--- /dev/null
+++ b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './gcnet_r50-d8_4xb4-20k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..9c7f741
--- /dev/null
+++ b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './gcnet_r50-d8_4xb4-40k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..61337db
--- /dev/null
+++ b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './gcnet_r50-d8_4xb4-80k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..f976bd9
--- /dev/null
+++ b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/gcnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..34ce822
--- /dev/null
+++ b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/gcnet_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..5088929
--- /dev/null
+++ b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/gcnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..f886f17
--- /dev/null
+++ b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/gcnet_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..d3f5631
--- /dev/null
+++ b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/gcnet_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..356b088
--- /dev/null
+++ b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/gcnet_r50-d8.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_20k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..802b766
--- /dev/null
+++ b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/gcnet_r50-d8.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..7327934
--- /dev/null
+++ b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/gcnet_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/gcnet/metafile.yaml b/mmsegmentation/configs/gcnet/metafile.yaml
new file mode 100644
index 0000000..1f3c462
--- /dev/null
+++ b/mmsegmentation/configs/gcnet/metafile.yaml
@@ -0,0 +1,391 @@
+Collections:
+- Name: GCNet
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+    - ADE20K
+    - Pascal VOC 2012 + Aug
+  Paper:
+    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
+    URL: https://arxiv.org/abs/1904.11492
+  README: configs/gcnet/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: gcnet_r50-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: GCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.69
+      mIoU(ms+flip): 78.56
+  Config: configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - GCNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x1024_40k_cityscapes/gcnet_r50-d8_512x1024_40k_cityscapes_20200618_074436-4b0fd17b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x1024_40k_cityscapes/gcnet_r50-d8_512x1024_40k_cityscapes_20200618_074436.log.json
+  Paper:
+    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
+    URL: https://arxiv.org/abs/1904.11492
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
+  Framework: PyTorch
+- Name: gcnet_r101-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: GCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.28
+      mIoU(ms+flip): 79.34
+  Config: configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - GCNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x1024_40k_cityscapes/gcnet_r101-d8_512x1024_40k_cityscapes_20200618_074436-5e62567f.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x1024_40k_cityscapes/gcnet_r101-d8_512x1024_40k_cityscapes_20200618_074436.log.json
+  Paper:
+    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
+    URL: https://arxiv.org/abs/1904.11492
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
+  Framework: PyTorch
+- Name: gcnet_r50-d8_4xb2-40k_cityscapes-769x769
+  In Collection: GCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.12
+      mIoU(ms+flip): 80.09
+  Config: configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - GCNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_769x769_40k_cityscapes/gcnet_r50-d8_769x769_40k_cityscapes_20200618_182814-a26f4471.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_769x769_40k_cityscapes/gcnet_r50-d8_769x769_40k_cityscapes_20200618_182814.log.json
+  Paper:
+    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
+    URL: https://arxiv.org/abs/1904.11492
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
+  Framework: PyTorch
+- Name: gcnet_r101-d8_4xb2-40k_cityscapes-769x769
+  In Collection: GCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.95
+      mIoU(ms+flip): 80.71
+  Config: configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - GCNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_769x769_40k_cityscapes/gcnet_r101-d8_769x769_40k_cityscapes_20200619_092550-ca4f0a84.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_769x769_40k_cityscapes/gcnet_r101-d8_769x769_40k_cityscapes_20200619_092550.log.json
+  Paper:
+    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
+    URL: https://arxiv.org/abs/1904.11492
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
+  Framework: PyTorch
+- Name: gcnet_r50-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: GCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.48
+      mIoU(ms+flip): 80.01
+  Config: configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - GCNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x1024_80k_cityscapes/gcnet_r50-d8_512x1024_80k_cityscapes_20200618_074450-ef8f069b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x1024_80k_cityscapes/gcnet_r50-d8_512x1024_80k_cityscapes_20200618_074450.log.json
+  Paper:
+    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
+    URL: https://arxiv.org/abs/1904.11492
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
+  Framework: PyTorch
+- Name: gcnet_r101-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: GCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.03
+      mIoU(ms+flip): 79.84
+  Config: configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - GCNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x1024_80k_cityscapes/gcnet_r101-d8_512x1024_80k_cityscapes_20200618_074450-778ebf69.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x1024_80k_cityscapes/gcnet_r101-d8_512x1024_80k_cityscapes_20200618_074450.log.json
+  Paper:
+    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
+    URL: https://arxiv.org/abs/1904.11492
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
+  Framework: PyTorch
+- Name: gcnet_r50-d8_4xb2-80k_cityscapes-769x769
+  In Collection: GCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.68
+      mIoU(ms+flip): 80.66
+  Config: configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - GCNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_769x769_80k_cityscapes/gcnet_r50-d8_769x769_80k_cityscapes_20200619_092516-4839565b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_769x769_80k_cityscapes/gcnet_r50-d8_769x769_80k_cityscapes_20200619_092516.log.json
+  Paper:
+    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
+    URL: https://arxiv.org/abs/1904.11492
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
+  Framework: PyTorch
+- Name: gcnet_r101-d8_4xb2-80k_cityscapes-769x769
+  In Collection: GCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.18
+      mIoU(ms+flip): 80.71
+  Config: configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - GCNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_769x769_80k_cityscapes/gcnet_r101-d8_769x769_80k_cityscapes_20200619_092628-8e043423.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_769x769_80k_cityscapes/gcnet_r101-d8_769x769_80k_cityscapes_20200619_092628.log.json
+  Paper:
+    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
+    URL: https://arxiv.org/abs/1904.11492
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
+  Framework: PyTorch
+- Name: gcnet_r50-d8_4xb4-80k_ade20k-512x512
+  In Collection: GCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 41.47
+      mIoU(ms+flip): 42.85
+  Config: configs/gcnet/gcnet_r50-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - GCNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_80k_ade20k/gcnet_r50-d8_512x512_80k_ade20k_20200614_185146-91a6da41.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_80k_ade20k/gcnet_r50-d8_512x512_80k_ade20k_20200614_185146.log.json
+  Paper:
+    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
+    URL: https://arxiv.org/abs/1904.11492
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
+  Framework: PyTorch
+- Name: gcnet_r101-d8_4xb4-80k_ade20k-512x512
+  In Collection: GCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.82
+      mIoU(ms+flip): 44.54
+  Config: configs/gcnet/gcnet_r101-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - GCNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 12.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_80k_ade20k/gcnet_r101-d8_512x512_80k_ade20k_20200615_020811-c3fcb6dd.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_80k_ade20k/gcnet_r101-d8_512x512_80k_ade20k_20200615_020811.log.json
+  Paper:
+    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
+    URL: https://arxiv.org/abs/1904.11492
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
+  Framework: PyTorch
+- Name: gcnet_r50-d8_4xb4-160k_ade20k-512x512
+  In Collection: GCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.37
+      mIoU(ms+flip): 43.52
+  Config: configs/gcnet/gcnet_r50-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - GCNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_160k_ade20k/gcnet_r50-d8_512x512_160k_ade20k_20200615_224122-d95f3e1f.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_160k_ade20k/gcnet_r50-d8_512x512_160k_ade20k_20200615_224122.log.json
+  Paper:
+    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
+    URL: https://arxiv.org/abs/1904.11492
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
+  Framework: PyTorch
+- Name: gcnet_r101-d8_4xb4-160k_ade20k-512x512
+  In Collection: GCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 43.69
+      mIoU(ms+flip): 45.21
+  Config: configs/gcnet/gcnet_r101-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - GCNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_160k_ade20k/gcnet_r101-d8_512x512_160k_ade20k_20200615_225406-615528d7.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_160k_ade20k/gcnet_r101-d8_512x512_160k_ade20k_20200615_225406.log.json
+  Paper:
+    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
+    URL: https://arxiv.org/abs/1904.11492
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
+  Framework: PyTorch
+- Name: gcnet_r50-d8_4xb4-20k_voc12aug-512x512
+  In Collection: GCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 76.42
+      mIoU(ms+flip): 77.51
+  Config: configs/gcnet/gcnet_r50-d8_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - GCNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_20k_voc12aug/gcnet_r50-d8_512x512_20k_voc12aug_20200617_165701-3cbfdab1.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_20k_voc12aug/gcnet_r50-d8_512x512_20k_voc12aug_20200617_165701.log.json
+  Paper:
+    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
+    URL: https://arxiv.org/abs/1904.11492
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
+  Framework: PyTorch
+- Name: gcnet_r101-d8_4xb4-20k_voc12aug-512x512
+  In Collection: GCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 77.41
+      mIoU(ms+flip): 78.56
+  Config: configs/gcnet/gcnet_r101-d8_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - GCNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_20k_voc12aug/gcnet_r101-d8_512x512_20k_voc12aug_20200617_165713-6c720aa9.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_20k_voc12aug/gcnet_r101-d8_512x512_20k_voc12aug_20200617_165713.log.json
+  Paper:
+    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
+    URL: https://arxiv.org/abs/1904.11492
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
+  Framework: PyTorch
+- Name: gcnet_r50-d8_4xb4-40k_voc12aug-512x512
+  In Collection: GCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 76.24
+      mIoU(ms+flip): 77.63
+  Config: configs/gcnet/gcnet_r50-d8_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - GCNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_40k_voc12aug/gcnet_r50-d8_512x512_40k_voc12aug_20200613_195105-9797336d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_40k_voc12aug/gcnet_r50-d8_512x512_40k_voc12aug_20200613_195105.log.json
+  Paper:
+    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
+    URL: https://arxiv.org/abs/1904.11492
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
+  Framework: PyTorch
+- Name: gcnet_r101-d8_4xb4-40k_voc12aug-512x512
+  In Collection: GCNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 77.84
+      mIoU(ms+flip): 78.59
+  Config: configs/gcnet/gcnet_r101-d8_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - GCNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_40k_voc12aug/gcnet_r101-d8_512x512_40k_voc12aug_20200613_185806-1e38208d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_40k_voc12aug/gcnet_r101-d8_512x512_40k_voc12aug_20200613_185806.log.json
+  Paper:
+    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
+    URL: https://arxiv.org/abs/1904.11492
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/hrnet/README.md b/mmsegmentation/configs/hrnet/README.md
new file mode 100644
index 0000000..b529fc8
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/README.md
@@ -0,0 +1,122 @@
+# HRNet
+
+> [Deep High-Resolution Representation Learning for Human Pose Estimation](https://arxiv.org/abs/1908.07919)
+
+## Introduction
+
+<!-- [BACKBONE] -->
+
+<a href="https://github.com/HRNet/HRNet-Semantic-Segmentation">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+High-resolution representations are essential for position-sensitive vision problems, such as human pose estimation, semantic segmentation, and object detection. Existing state-of-the-art frameworks first encode the input image as a low-resolution representation through a subnetwork that is formed by connecting high-to-low resolution convolutions \\emph{in series} (e.g., ResNet, VGGNet), and then recover the high-resolution representation from the encoded low-resolution representation. Instead, our proposed network, named as High-Resolution Network (HRNet), maintains high-resolution representations through the whole process. There are two key characteristics: (i) Connect the high-to-low resolution convolution streams \\emph{in parallel}; (ii) Repeatedly exchange the information across resolutions. The benefit is that the resulting representation is semantically richer and spatially more precise. We show the superiority of the proposed HRNet in a wide range of applications, including human pose estimation, semantic segmentation, and object detection, suggesting that the HRNet is a stronger backbone for computer vision problems. All the codes are available at [this https URL](https://github.com/HRNet).
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142901680-64c285bc-669f-4924-b054-46a2f07c5427.png" width="80%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method | Backbone           | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                    | download                                                                                                                                                                                                                                                                                                                               |
+| ------ | ------------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FCN    | HRNetV2p-W18-Small | 512x1024  |   40000 | 1.7      | 23.74          | V100   | 73.86 |         75.91 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18s_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_40k_cityscapes/fcn_hr18s_512x1024_40k_cityscapes_20200601_014216-93db27d0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_40k_cityscapes/fcn_hr18s_512x1024_40k_cityscapes_20200601_014216.log.json)     |
+| FCN    | HRNetV2p-W18       | 512x1024  |   40000 | 2.9      | 12.97          | V100   | 77.19 |         78.92 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18_4xb2-40k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_40k_cityscapes/fcn_hr18_512x1024_40k_cityscapes_20200601_014216-f196fb4e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_40k_cityscapes/fcn_hr18_512x1024_40k_cityscapes_20200601_014216.log.json)         |
+| FCN    | HRNetV2p-W48       | 512x1024  |   40000 | 6.2      | 6.42           | V100   | 78.48 |         79.69 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb2-40k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_40k_cityscapes/fcn_hr48_512x1024_40k_cityscapes_20200601_014240-a989b146.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_40k_cityscapes/fcn_hr48_512x1024_40k_cityscapes_20200601_014240.log.json)         |
+| FCN    | HRNetV2p-W18-Small | 512x1024  |   80000 | -        | -              | V100   | 75.31 |         77.48 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18s_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_80k_cityscapes/fcn_hr18s_512x1024_80k_cityscapes_20200601_202700-1462b75d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_80k_cityscapes/fcn_hr18s_512x1024_80k_cityscapes_20200601_202700.log.json)     |
+| FCN    | HRNetV2p-W18       | 512x1024  |   80000 | -        | -              | V100   | 78.65 |         80.35 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18_4xb2-80k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_80k_cityscapes/fcn_hr18_512x1024_80k_cityscapes_20200601_223255-4e7b345e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_80k_cityscapes/fcn_hr18_512x1024_80k_cityscapes_20200601_223255.log.json)         |
+| FCN    | HRNetV2p-W48       | 512x1024  |   80000 | -        | -              | V100   | 79.93 |         80.72 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb2-80k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_80k_cityscapes/fcn_hr48_512x1024_80k_cityscapes_20200601_202606-58ea95d6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_80k_cityscapes/fcn_hr48_512x1024_80k_cityscapes_20200601_202606.log.json)         |
+| FCN    | HRNetV2p-W18-Small | 512x1024  |  160000 | -        | -              | V100   | 76.31 |         78.31 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18s_4xb2-160k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_160k_cityscapes/fcn_hr18s_512x1024_160k_cityscapes_20200602_190901-4a0797ea.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_160k_cityscapes/fcn_hr18s_512x1024_160k_cityscapes_20200602_190901.log.json) |
+| FCN    | HRNetV2p-W18       | 512x1024  |  160000 | -        | -              | V100   | 78.80 |         80.74 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18_4xb2-160k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_160k_cityscapes/fcn_hr18_512x1024_160k_cityscapes_20200602_190822-221e4a4f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_160k_cityscapes/fcn_hr18_512x1024_160k_cityscapes_20200602_190822.log.json)     |
+| FCN    | HRNetV2p-W48       | 512x1024  |  160000 | -        | -              | V100   | 80.65 |         81.92 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb2-160k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_160k_cityscapes/fcn_hr48_512x1024_160k_cityscapes_20200602_190946-59b7973e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_160k_cityscapes/fcn_hr48_512x1024_160k_cityscapes_20200602_190946.log.json)     |
+
+### ADE20K
+
+| Method | Backbone           | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                               | download                                                                                                                                                                                                                                                                                                           |
+| ------ | ------------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| FCN    | HRNetV2p-W18-Small | 512x512   |   80000 | 3.8      | 38.66          | V100   | 31.38 |         32.45 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18s_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_ade20k/fcn_hr18s_512x512_80k_ade20k_20200614_144345-77fc814a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_ade20k/fcn_hr18s_512x512_80k_ade20k_20200614_144345.log.json)     |
+| FCN    | HRNetV2p-W18       | 512x512   |   80000 | 4.9      | 22.57          | V100   | 36.27 |         37.28 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_ade20k/fcn_hr18_512x512_80k_ade20k_20210827_114910-6c9382c0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_ade20k/fcn_hr18_512x512_80k_ade20k_20210827_114910.log.json)         |
+| FCN    | HRNetV2p-W48       | 512x512   |   80000 | 8.2      | 21.23          | V100   | 41.90 |         43.27 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_ade20k/fcn_hr48_512x512_80k_ade20k_20200614_193946-7ba5258d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_ade20k/fcn_hr48_512x512_80k_ade20k_20200614_193946.log.json)         |
+| FCN    | HRNetV2p-W18-Small | 512x512   |  160000 | -        | -              | V100   | 33.07 |         34.56 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18s_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_160k_ade20k/fcn_hr18s_512x512_160k_ade20k_20210829_174739-f1e7c2e7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_160k_ade20k/fcn_hr18s_512x512_160k_ade20k_20210829_174739.log.json) |
+| FCN    | HRNetV2p-W18       | 512x512   |  160000 | -        | -              | V100   | 36.79 |         38.58 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_160k_ade20k/fcn_hr18_512x512_160k_ade20k_20200614_214426-ca961836.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_160k_ade20k/fcn_hr18_512x512_160k_ade20k_20200614_214426.log.json)     |
+| FCN    | HRNetV2p-W48       | 512x512   |  160000 | -        | -              | V100   | 42.02 |         43.86 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_160k_ade20k/fcn_hr48_512x512_160k_ade20k_20200614_214407-a52fc02c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_160k_ade20k/fcn_hr48_512x512_160k_ade20k_20200614_214407.log.json)     |
+
+### Pascal VOC 2012 + Aug
+
+| Method | Backbone           | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                | download                                                                                                                                                                                                                                                                                                               |
+| ------ | ------------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | --------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FCN    | HRNetV2p-W18-Small | 512x512   |   20000 | 1.8      | 43.36          | V100   |  65.5 |         68.89 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18s_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_20k_voc12aug/fcn_hr18s_512x512_20k_voc12aug_20210829_174910-0aceadb4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_20k_voc12aug/fcn_hr18s_512x512_20k_voc12aug_20210829_174910.log.json) |
+| FCN    | HRNetV2p-W18       | 512x512   |   20000 | 2.9      | 23.48          | V100   | 72.30 |         74.71 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_20k_voc12aug/fcn_hr18_512x512_20k_voc12aug_20200617_224503-488d45f7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_20k_voc12aug/fcn_hr18_512x512_20k_voc12aug_20200617_224503.log.json)     |
+| FCN    | HRNetV2p-W48       | 512x512   |   20000 | 6.2      | 22.05          | V100   | 75.87 |         78.58 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_20k_voc12aug/fcn_hr48_512x512_20k_voc12aug_20200617_224419-89de05cd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_20k_voc12aug/fcn_hr48_512x512_20k_voc12aug_20200617_224419.log.json)     |
+| FCN    | HRNetV2p-W18-Small | 512x512   |   40000 | -        | -              | V100   | 66.61 |         70.00 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18s_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_40k_voc12aug/fcn_hr18s_512x512_40k_voc12aug_20200614_000648-4f8d6e7f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_40k_voc12aug/fcn_hr18s_512x512_40k_voc12aug_20200614_000648.log.json) |
+| FCN    | HRNetV2p-W18       | 512x512   |   40000 | -        | -              | V100   | 72.90 |         75.59 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_40k_voc12aug/fcn_hr18_512x512_40k_voc12aug_20200613_224401-1b4b76cd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_40k_voc12aug/fcn_hr18_512x512_40k_voc12aug_20200613_224401.log.json)     |
+| FCN    | HRNetV2p-W48       | 512x512   |   40000 | -        | -              | V100   | 76.24 |         78.49 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_40k_voc12aug/fcn_hr48_512x512_40k_voc12aug_20200613_222111-1b0f18bc.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_40k_voc12aug/fcn_hr48_512x512_40k_voc12aug_20200613_222111.log.json)     |
+
+### Pascal Context
+
+| Method | Backbone     | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                     | download                                                                                                                                                                                                                                                                                                                                   |
+| ------ | ------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| FCN    | HRNetV2p-W48 | 480x480   |   40000 | 6.1      | 8.86           | V100   | 45.14 |         47.42 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_40k_pascal_context/fcn_hr48_480x480_40k_pascal_context_20200911_164852-667d00b0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_40k_pascal_context/fcn_hr48_480x480_40k_pascal_context-20200911_164852.log.json) |
+| FCN    | HRNetV2p-W48 | 480x480   |   80000 | -        | -              | V100   | 45.84 |         47.84 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_80k_pascal_context/fcn_hr48_480x480_80k_pascal_context_20200911_155322-847a6711.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_80k_pascal_context/fcn_hr48_480x480_80k_pascal_context-20200911_155322.log.json) |
+
+### Pascal Context 59
+
+| Method | Backbone     | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                        | download                                                                                                                                                                                                                                                                                                                                               |
+| ------ | ------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ----------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| FCN    | HRNetV2p-W48 | 480x480   |   40000 | -        | -              | V100   | 50.33 |         52.83 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-59-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_40k_pascal_context_59/fcn_hr48_480x480_40k_pascal_context_59_20210410_122738-b808b8b2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_40k_pascal_context_59/fcn_hr48_480x480_40k_pascal_context_59-20210410_122738.log.json) |
+| FCN    | HRNetV2p-W48 | 480x480   |   80000 | -        | -              | V100   | 51.12 |         53.56 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-59-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_80k_pascal_context_59/fcn_hr48_480x480_80k_pascal_context_59_20210411_003240-3ae7081e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_80k_pascal_context_59/fcn_hr48_480x480_80k_pascal_context_59-20210411_003240.log.json) |
+
+### LoveDA
+
+| Method | Backbone           | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                               | download                                                                                                                                                                                                                                                                                                       |
+| ------ | ------------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FCN    | HRNetV2p-W18-Small | 512x512   |   80000 | 1.59     | 24.87          | V100   | 49.28 |         49.42 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18s_4xb4-80k_loveda-512x512.pyy) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_loveda/fcn_hr18s_512x512_80k_loveda_20211210_203228-60a86a7a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_loveda/fcn_hr18s_512x512_80k_loveda_20211210_203228.log.json) |
+| FCN    | HRNetV2p-W18       | 512x512   |   80000 | 2.76     | 12.92          | V100   | 50.81 |         50.95 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18_4xb4-80k_loveda-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_loveda/fcn_hr18_512x512_80k_loveda_20211210_203952-93d9c3b3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_loveda/fcn_hr18_512x512_80k_loveda_20211210_203952.log.json)     |
+| FCN    | HRNetV2p-W48       | 512x512   |   80000 | 6.20     | 9.61           | V100   | 51.42 |         51.64 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-80k_loveda-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_loveda/fcn_hr48_512x512_80k_loveda_20211211_044756-67072f55.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_loveda/fcn_hr48_512x512_80k_loveda_20211211_044756.log.json)     |
+
+### Potsdam
+
+| Method | Backbone           | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                               | download                                                                                                                                                                                                                                                                                                           |
+| ------ | ------------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| FCN    | HRNetV2p-W18-Small | 512x512   |   80000 | 1.58     | 36.00          | V100   | 77.64 |          78.8 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18s_4xb4-80k_potsdam-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_potsdam/fcn_hr18s_512x512_80k_potsdam_20211218_205517-ba32af63.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_potsdam/fcn_hr18s_512x512_80k_potsdam_20211218_205517.log.json) |
+| FCN    | HRNetV2p-W18       | 512x512   |   80000 | 2.76     | 19.25          | V100   | 78.26 |         79.24 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18_4xb4-80k_potsdam-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_potsdam/fcn_hr18_512x512_80k_potsdam_20211218_205517-5d0387ad.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_potsdam/fcn_hr18_512x512_80k_potsdam_20211218_205517.log.json)     |
+| FCN    | HRNetV2p-W48       | 512x512   |   80000 | 6.20     | 16.42          | V100   | 78.39 |         79.34 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-80k_potsdam-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_potsdam/fcn_hr48_512x512_80k_potsdam_20211219_020601-97434c78.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_potsdam/fcn_hr48_512x512_80k_potsdam_20211219_020601.log.json)     |
+
+### Vaihingen
+
+| Method | Backbone           | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                 | download                                                                                                                                                                                                                                                                                                                                   |
+| ------ | ------------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ---------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| FCN    | HRNetV2p-W18-Small | 512x512   |   80000 | 1.58     | 38.11          | V100   | 71.81 |          73.1 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18s_4xb4-80k_vaihingen-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_4x4_512x512_80k_vaihingen/fcn_hr18s_4x4_512x512_80k_vaihingen_20211231_230909-b23aae02.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_4x4_512x512_80k_vaihingen/fcn_hr18s_4x4_512x512_80k_vaihingen_20211231_230909.log.json) |
+| FCN    | HRNetV2p-W18       | 512x512   |   80000 | 2.76     | 19.55          | V100   | 72.57 |         74.09 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18_4xb4-80k_vaihingen-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_4x4_512x512_80k_vaihingen/fcn_hr18_4x4_512x512_80k_vaihingen_20211231_231216-2ec3ae8a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_4x4_512x512_80k_vaihingen/fcn_hr18_4x4_512x512_80k_vaihingen_20211231_231216.log.json)     |
+| FCN    | HRNetV2p-W48       | 512x512   |   80000 | 6.20     | 17.25          | V100   | 72.50 |         73.52 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-80k_vaihingen-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_4x4_512x512_80k_vaihingen/fcn_hr48_4x4_512x512_80k_vaihingen_20211231_231244-7133cb22.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_4x4_512x512_80k_vaihingen/fcn_hr48_4x4_512x512_80k_vaihingen_20211231_231244.log.json)     |
+
+### iSAID
+
+| Method | Backbone           | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                             | download                                                                                                                                                                                                                                                                                                                   |
+| ------ | ------------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FCN    | HRNetV2p-W18-Small | 896x896   |   80000 | 4.95     | 13.84          | V100   | 62.30 |         62.97 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18s_4xb4-80k_isaid-896x896.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_4x4_896x896_80k_isaid/fcn_hr18s_4x4_896x896_80k_isaid_20220118_001603-3cc0769b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_4x4_896x896_80k_isaid/fcn_hr18s_4x4_896x896_80k_isaid_20220118_001603.log.json) |
+| FCN    | HRNetV2p-W18       | 896x896   |   80000 | 8.30     | 7.71           | V100   | 65.06 |         65.60 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18_4xb4-80k_isaid-896x896.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_4x4_896x896_80k_isaid/fcn_hr18_4x4_896x896_80k_isaid_20220110_182230-49bf752e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_4x4_896x896_80k_isaid/fcn_hr18_4x4_896x896_80k_isaid_20220110_182230.log.json)     |
+| FCN    | HRNetV2p-W48       | 896x896   |   80000 | 16.89    | 7.34           | V100   | 67.80 |         68.53 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-80k_isaid-896x896.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_4x4_896x896_80k_isaid/fcn_hr48_4x4_896x896_80k_isaid_20220114_174643-547fc420.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_4x4_896x896_80k_isaid/fcn_hr48_4x4_896x896_80k_isaid_20220114_174643.log.json)     |
+
+Note:
+
+- `896x896` is the Crop Size of iSAID dataset, which is followed by the implementation of [PointFlow: Flowing Semantics Through Points for Aerial Image Segmentation](https://arxiv.org/pdf/2103.06564.pdf)
+
+## Citation
+
+```bibtext
+@inproceedings{SunXLW19,
+  title={Deep High-Resolution Representation Learning for Human Pose Estimation},
+  author={Ke Sun and Bin Xiao and Dong Liu and Jingdong Wang},
+  booktitle={CVPR},
+  year={2019}
+}
+```
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb2-160k_cityscapes-512x1024.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb2-160k_cityscapes-512x1024.py
new file mode 100644
index 0000000..0b37463
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18_4xb2-160k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/fcn_hr18.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..598b938
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/fcn_hr18.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..eb7da49
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/fcn_hr18.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..c4f732c
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,8 @@
+_base_ = [
+    '../_base_/models/fcn_hr18.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor, decode_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..107df6b
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,8 @@
+_base_ = [
+    '../_base_/models/fcn_hr18.py', '../_base_/datasets/pascal_voc12_aug.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_20k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor, decode_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_pascal-context-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_pascal-context-480x480.py
new file mode 100644
index 0000000..f744bae
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_pascal-context-480x480.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/fcn_hr18.py', '../_base_/datasets/pascal_context.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (480, 480)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=60),
+    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
+optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_pascal-context-59-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_pascal-context-59-480x480.py
new file mode 100644
index 0000000..0daaa35
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_pascal-context-59-480x480.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/fcn_hr18.py', '../_base_/datasets/pascal_context_59.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (480, 480)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=59),
+    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
+optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..2aa16b1
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,8 @@
+_base_ = [
+    '../_base_/models/fcn_hr18.py', '../_base_/datasets/pascal_voc12_aug.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor, decode_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..029b7d0
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,8 @@
+_base_ = [
+    '../_base_/models/fcn_hr18.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor, decode_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_isaid-896x896.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_isaid-896x896.py
new file mode 100644
index 0000000..33a6ac7
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_isaid-896x896.py
@@ -0,0 +1,8 @@
+_base_ = [
+    '../_base_/models/fcn_hr18.py', '../_base_/datasets/isaid.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (896, 896)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor, decode_head=dict(num_classes=16))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_loveda-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_loveda-512x512.py
new file mode 100644
index 0000000..1a918b2
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_loveda-512x512.py
@@ -0,0 +1,8 @@
+_base_ = [
+    '../_base_/models/fcn_hr18.py', '../_base_/datasets/loveda.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor, decode_head=dict(num_classes=7))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_pascal-context-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_pascal-context-480x480.py
new file mode 100644
index 0000000..4f37e8a
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_pascal-context-480x480.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/fcn_hr18.py', '../_base_/datasets/pascal_context.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (480, 480)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=60),
+    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
+optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_pascal-context-59-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_pascal-context-59-480x480.py
new file mode 100644
index 0000000..2c35cb9
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_pascal-context-59-480x480.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/fcn_hr18.py', '../_base_/datasets/pascal_context_59.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (480, 480)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=59),
+    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
+optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_potsdam-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_potsdam-512x512.py
new file mode 100644
index 0000000..181c03d
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_potsdam-512x512.py
@@ -0,0 +1,8 @@
+_base_ = [
+    '../_base_/models/fcn_hr18.py', '../_base_/datasets/potsdam.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor, decode_head=dict(num_classes=6))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_vaihingen-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_vaihingen-512x512.py
new file mode 100644
index 0000000..6303bb6
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_vaihingen-512x512.py
@@ -0,0 +1,8 @@
+_base_ = [
+    '../_base_/models/fcn_hr18.py', '../_base_/datasets/vaihingen.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor, decode_head=dict(num_classes=6))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-160k_cityscapes-512x1024.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-160k_cityscapes-512x1024.py
new file mode 100644
index 0000000..6ca631c
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-160k_cityscapes-512x1024.py
@@ -0,0 +1,9 @@
+_base_ = './fcn_hr18_4xb2-160k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w18_small',
+    backbone=dict(
+        extra=dict(
+            stage1=dict(num_blocks=(2, )),
+            stage2=dict(num_blocks=(2, 2)),
+            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
+            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..ba7e9c6
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,9 @@
+_base_ = './fcn_hr18_4xb2-40k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w18_small',
+    backbone=dict(
+        extra=dict(
+            stage1=dict(num_blocks=(2, )),
+            stage2=dict(num_blocks=(2, 2)),
+            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
+            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..26ab621
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,9 @@
+_base_ = './fcn_hr18_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w18_small',
+    backbone=dict(
+        extra=dict(
+            stage1=dict(num_blocks=(2, )),
+            stage2=dict(num_blocks=(2, 2)),
+            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
+            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..29cbd10
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,9 @@
+_base_ = './fcn_hr18_4xb4-160k_ade20k-512x512.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w18_small',
+    backbone=dict(
+        extra=dict(
+            stage1=dict(num_blocks=(2, )),
+            stage2=dict(num_blocks=(2, 2)),
+            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
+            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..9dd1933
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,9 @@
+_base_ = './fcn_hr18_4xb4-20k_voc12aug-512x512.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w18_small',
+    backbone=dict(
+        extra=dict(
+            stage1=dict(num_blocks=(2, )),
+            stage2=dict(num_blocks=(2, 2)),
+            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
+            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_pascal-context-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_pascal-context-480x480.py
new file mode 100644
index 0000000..5f88f53
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_pascal-context-480x480.py
@@ -0,0 +1,9 @@
+_base_ = './fcn_hr18_4xb4-40k_pascal-context-480x480.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w18_small',
+    backbone=dict(
+        extra=dict(
+            stage1=dict(num_blocks=(2, )),
+            stage2=dict(num_blocks=(2, 2)),
+            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
+            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_pascal-context-59-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_pascal-context-59-480x480.py
new file mode 100644
index 0000000..b616fad
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_pascal-context-59-480x480.py
@@ -0,0 +1,9 @@
+_base_ = './fcn_hr18_4xb4-40k_pascal-context-59-480x480.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w18_small',
+    backbone=dict(
+        extra=dict(
+            stage1=dict(num_blocks=(2, )),
+            stage2=dict(num_blocks=(2, 2)),
+            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
+            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..b10b282
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,9 @@
+_base_ = './fcn_hr18_4xb4-40k_voc12aug-512x512.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w18_small',
+    backbone=dict(
+        extra=dict(
+            stage1=dict(num_blocks=(2, )),
+            stage2=dict(num_blocks=(2, 2)),
+            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
+            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..f9f4936
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,9 @@
+_base_ = './fcn_hr18_4xb4-80k_ade20k-512x512.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w18_small',
+    backbone=dict(
+        extra=dict(
+            stage1=dict(num_blocks=(2, )),
+            stage2=dict(num_blocks=(2, 2)),
+            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
+            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_isaid-896x896.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_isaid-896x896.py
new file mode 100644
index 0000000..ab2d241
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_isaid-896x896.py
@@ -0,0 +1,9 @@
+_base_ = './fcn_hr18_4xb4-80k_isaid-896x896.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w18_small',
+    backbone=dict(
+        extra=dict(
+            stage1=dict(num_blocks=(2, )),
+            stage2=dict(num_blocks=(2, 2)),
+            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
+            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_loveda-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_loveda-512x512.py
new file mode 100644
index 0000000..dd17076
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_loveda-512x512.py
@@ -0,0 +1,9 @@
+_base_ = './fcn_hr18_4xb4-80k_loveda-512x512.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w18_small',
+    backbone=dict(
+        extra=dict(
+            stage1=dict(num_blocks=(2, )),
+            stage2=dict(num_blocks=(2, 2)),
+            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
+            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_pascal-context-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_pascal-context-480x480.py
new file mode 100644
index 0000000..b7b5233
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_pascal-context-480x480.py
@@ -0,0 +1,9 @@
+_base_ = './fcn_hr18_4xb4-80k_pascal-context-480x480.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w18_small',
+    backbone=dict(
+        extra=dict(
+            stage1=dict(num_blocks=(2, )),
+            stage2=dict(num_blocks=(2, 2)),
+            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
+            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_pascal-context-59-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_pascal-context-59-480x480.py
new file mode 100644
index 0000000..ccf1040
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_pascal-context-59-480x480.py
@@ -0,0 +1,9 @@
+_base_ = './fcn_hr18_4xb4-80k_pascal-context-59-480x480.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w18_small',
+    backbone=dict(
+        extra=dict(
+            stage1=dict(num_blocks=(2, )),
+            stage2=dict(num_blocks=(2, 2)),
+            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
+            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_potsdam-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_potsdam-512x512.py
new file mode 100644
index 0000000..3a5726f
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_potsdam-512x512.py
@@ -0,0 +1,9 @@
+_base_ = './fcn_hr18_4xb4-80k_potsdam-512x512.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w18_small',
+    backbone=dict(
+        extra=dict(
+            stage1=dict(num_blocks=(2, )),
+            stage2=dict(num_blocks=(2, 2)),
+            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
+            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_vaihingen-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_vaihingen-512x512.py
new file mode 100644
index 0000000..720c173
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_vaihingen-512x512.py
@@ -0,0 +1,9 @@
+_base_ = './fcn_hr18_4xb4-80k_vaihingen-512x512.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w18_small',
+    backbone=dict(
+        extra=dict(
+            stage1=dict(num_blocks=(2, )),
+            stage2=dict(num_blocks=(2, 2)),
+            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
+            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb2-160k_cityscapes-512x1024.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb2-160k_cityscapes-512x1024.py
new file mode 100644
index 0000000..4aa5d94
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr48_4xb2-160k_cityscapes-512x1024.py
@@ -0,0 +1,10 @@
+_base_ = './fcn_hr18_4xb2-160k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        extra=dict(
+            stage2=dict(num_channels=(48, 96)),
+            stage3=dict(num_channels=(48, 96, 192)),
+            stage4=dict(num_channels=(48, 96, 192, 384)))),
+    decode_head=dict(
+        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..7cb7952
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr48_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,10 @@
+_base_ = './fcn_hr18_4xb2-40k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        extra=dict(
+            stage2=dict(num_channels=(48, 96)),
+            stage3=dict(num_channels=(48, 96, 192)),
+            stage4=dict(num_channels=(48, 96, 192, 384)))),
+    decode_head=dict(
+        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..3e2ce03
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr48_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,10 @@
+_base_ = './fcn_hr18_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        extra=dict(
+            stage2=dict(num_channels=(48, 96)),
+            stage3=dict(num_channels=(48, 96, 192)),
+            stage4=dict(num_channels=(48, 96, 192, 384)))),
+    decode_head=dict(
+        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..89b1f04
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = './fcn_hr18_4xb4-160k_ade20k-512x512.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        extra=dict(
+            stage2=dict(num_channels=(48, 96)),
+            stage3=dict(num_channels=(48, 96, 192)),
+            stage4=dict(num_channels=(48, 96, 192, 384)))),
+    decode_head=dict(
+        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..7ca38a9
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,10 @@
+_base_ = './fcn_hr18_4xb4-20k_voc12aug-512x512.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        extra=dict(
+            stage2=dict(num_channels=(48, 96)),
+            stage3=dict(num_channels=(48, 96, 192)),
+            stage4=dict(num_channels=(48, 96, 192, 384)))),
+    decode_head=dict(
+        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-480x480.py
new file mode 100644
index 0000000..379be1d
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-480x480.py
@@ -0,0 +1,10 @@
+_base_ = './fcn_hr18_4xb4-40k_pascal-context-480x480.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        extra=dict(
+            stage2=dict(num_channels=(48, 96)),
+            stage3=dict(num_channels=(48, 96, 192)),
+            stage4=dict(num_channels=(48, 96, 192, 384)))),
+    decode_head=dict(
+        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-59-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-59-480x480.py
new file mode 100644
index 0000000..12730dd
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-59-480x480.py
@@ -0,0 +1,10 @@
+_base_ = './fcn_hr18_4xb4-40k_pascal-context-59-480x480.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        extra=dict(
+            stage2=dict(num_channels=(48, 96)),
+            stage3=dict(num_channels=(48, 96, 192)),
+            stage4=dict(num_channels=(48, 96, 192, 384)))),
+    decode_head=dict(
+        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..3e1b920
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,10 @@
+_base_ = './fcn_hr18_4xb4-40k_voc12aug-512x512.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        extra=dict(
+            stage2=dict(num_channels=(48, 96)),
+            stage3=dict(num_channels=(48, 96, 192)),
+            stage4=dict(num_channels=(48, 96, 192, 384)))),
+    decode_head=dict(
+        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..14fd663
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = './fcn_hr18_4xb4-80k_ade20k-512x512.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        extra=dict(
+            stage2=dict(num_channels=(48, 96)),
+            stage3=dict(num_channels=(48, 96, 192)),
+            stage4=dict(num_channels=(48, 96, 192, 384)))),
+    decode_head=dict(
+        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_isaid-896x896.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_isaid-896x896.py
new file mode 100644
index 0000000..81815ef
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_isaid-896x896.py
@@ -0,0 +1,10 @@
+_base_ = './fcn_hr18_4xb4-80k_isaid-896x896.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        extra=dict(
+            stage2=dict(num_channels=(48, 96)),
+            stage3=dict(num_channels=(48, 96, 192)),
+            stage4=dict(num_channels=(48, 96, 192, 384)))),
+    decode_head=dict(
+        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_loveda-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_loveda-512x512.py
new file mode 100644
index 0000000..34d23af
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_loveda-512x512.py
@@ -0,0 +1,10 @@
+_base_ = './fcn_hr18_4xb4-80k_loveda-512x512.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        extra=dict(
+            stage2=dict(num_channels=(48, 96)),
+            stage3=dict(num_channels=(48, 96, 192)),
+            stage4=dict(num_channels=(48, 96, 192, 384)))),
+    decode_head=dict(
+        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-480x480.py
new file mode 100644
index 0000000..4d193d9
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-480x480.py
@@ -0,0 +1,10 @@
+_base_ = './fcn_hr18_4xb4-80k_pascal-context-480x480.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        extra=dict(
+            stage2=dict(num_channels=(48, 96)),
+            stage3=dict(num_channels=(48, 96, 192)),
+            stage4=dict(num_channels=(48, 96, 192, 384)))),
+    decode_head=dict(
+        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-59-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-59-480x480.py
new file mode 100644
index 0000000..d8b4c4a
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-59-480x480.py
@@ -0,0 +1,10 @@
+_base_ = './fcn_hr18_4xb4-80k_pascal-context-59-480x480.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        extra=dict(
+            stage2=dict(num_channels=(48, 96)),
+            stage3=dict(num_channels=(48, 96, 192)),
+            stage4=dict(num_channels=(48, 96, 192, 384)))),
+    decode_head=dict(
+        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_potsdam-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_potsdam-512x512.py
new file mode 100644
index 0000000..58a6500
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_potsdam-512x512.py
@@ -0,0 +1,10 @@
+_base_ = './fcn_hr18_4xb4-80k_potsdam-512x512.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        extra=dict(
+            stage2=dict(num_channels=(48, 96)),
+            stage3=dict(num_channels=(48, 96, 192)),
+            stage4=dict(num_channels=(48, 96, 192, 384)))),
+    decode_head=dict(
+        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_vaihingen-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_vaihingen-512x512.py
new file mode 100644
index 0000000..db91ed8
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_vaihingen-512x512.py
@@ -0,0 +1,10 @@
+_base_ = './fcn_hr18_4xb4-80k_vaihingen-512x512.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        extra=dict(
+            stage2=dict(num_channels=(48, 96)),
+            stage3=dict(num_channels=(48, 96, 192)),
+            stage4=dict(num_channels=(48, 96, 192, 384)))),
+    decode_head=dict(
+        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/metafile.yaml b/mmsegmentation/configs/hrnet/metafile.yaml
new file mode 100644
index 0000000..11c3016
--- /dev/null
+++ b/mmsegmentation/configs/hrnet/metafile.yaml
@@ -0,0 +1,874 @@
+Models:
+- Name: fcn_hr18s_4xb2-40k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 73.86
+      mIoU(ms+flip): 75.91
+  Config: configs/hrnet/fcn_hr18s_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - HRNetV2p-W18-Small
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.7
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_40k_cityscapes/fcn_hr18s_512x1024_40k_cityscapes_20200601_014216-93db27d0.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_40k_cityscapes/fcn_hr18s_512x1024_40k_cityscapes_20200601_014216.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr18_4xb2-40k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.19
+      mIoU(ms+flip): 78.92
+  Config: configs/hrnet/fcn_hr18_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - HRNetV2p-W18
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 2.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_40k_cityscapes/fcn_hr18_512x1024_40k_cityscapes_20200601_014216-f196fb4e.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_40k_cityscapes/fcn_hr18_512x1024_40k_cityscapes_20200601_014216.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr48_4xb2-40k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.48
+      mIoU(ms+flip): 79.69
+  Config: configs/hrnet/fcn_hr48_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - HRNetV2p-W48
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_40k_cityscapes/fcn_hr48_512x1024_40k_cityscapes_20200601_014240-a989b146.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_40k_cityscapes/fcn_hr48_512x1024_40k_cityscapes_20200601_014240.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr18s_4xb2-80k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 75.31
+      mIoU(ms+flip): 77.48
+  Config: configs/hrnet/fcn_hr18s_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - HRNetV2p-W18-Small
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_80k_cityscapes/fcn_hr18s_512x1024_80k_cityscapes_20200601_202700-1462b75d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_80k_cityscapes/fcn_hr18s_512x1024_80k_cityscapes_20200601_202700.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr18_4xb2-80k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.65
+      mIoU(ms+flip): 80.35
+  Config: configs/hrnet/fcn_hr18_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - HRNetV2p-W18
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_80k_cityscapes/fcn_hr18_512x1024_80k_cityscapes_20200601_223255-4e7b345e.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_80k_cityscapes/fcn_hr18_512x1024_80k_cityscapes_20200601_223255.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr48_4xb2-80k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.93
+      mIoU(ms+flip): 80.72
+  Config: configs/hrnet/fcn_hr48_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - HRNetV2p-W48
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_80k_cityscapes/fcn_hr48_512x1024_80k_cityscapes_20200601_202606-58ea95d6.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_80k_cityscapes/fcn_hr48_512x1024_80k_cityscapes_20200601_202606.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr18s_4xb2-160k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.31
+      mIoU(ms+flip): 78.31
+  Config: configs/hrnet/fcn_hr18s_4xb2-160k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - HRNetV2p-W18-Small
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_160k_cityscapes/fcn_hr18s_512x1024_160k_cityscapes_20200602_190901-4a0797ea.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_160k_cityscapes/fcn_hr18s_512x1024_160k_cityscapes_20200602_190901.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr18_4xb2-160k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.8
+      mIoU(ms+flip): 80.74
+  Config: configs/hrnet/fcn_hr18_4xb2-160k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - HRNetV2p-W18
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_160k_cityscapes/fcn_hr18_512x1024_160k_cityscapes_20200602_190822-221e4a4f.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_160k_cityscapes/fcn_hr18_512x1024_160k_cityscapes_20200602_190822.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr48_4xb2-160k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 80.65
+      mIoU(ms+flip): 81.92
+  Config: configs/hrnet/fcn_hr48_4xb2-160k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - HRNetV2p-W48
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_160k_cityscapes/fcn_hr48_512x1024_160k_cityscapes_20200602_190946-59b7973e.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_160k_cityscapes/fcn_hr48_512x1024_160k_cityscapes_20200602_190946.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr18s_4xb4-80k_ade20k-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 31.38
+      mIoU(ms+flip): 32.45
+  Config: configs/hrnet/fcn_hr18s_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18-Small
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 3.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_ade20k/fcn_hr18s_512x512_80k_ade20k_20200614_144345-77fc814a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_ade20k/fcn_hr18s_512x512_80k_ade20k_20200614_144345.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr18_4xb4-80k_ade20k-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 36.27
+      mIoU(ms+flip): 37.28
+  Config: configs/hrnet/fcn_hr18_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 4.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_ade20k/fcn_hr18_512x512_80k_ade20k_20210827_114910-6c9382c0.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_ade20k/fcn_hr18_512x512_80k_ade20k_20210827_114910.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr48_4xb4-80k_ade20k-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 41.9
+      mIoU(ms+flip): 43.27
+  Config: configs/hrnet/fcn_hr48_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W48
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_ade20k/fcn_hr48_512x512_80k_ade20k_20200614_193946-7ba5258d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_ade20k/fcn_hr48_512x512_80k_ade20k_20200614_193946.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr18s_4xb4-160k_ade20k-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 33.07
+      mIoU(ms+flip): 34.56
+  Config: configs/hrnet/fcn_hr18s_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18-Small
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_160k_ade20k/fcn_hr18s_512x512_160k_ade20k_20210829_174739-f1e7c2e7.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_160k_ade20k/fcn_hr18s_512x512_160k_ade20k_20210829_174739.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr18_4xb4-160k_ade20k-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 36.79
+      mIoU(ms+flip): 38.58
+  Config: configs/hrnet/fcn_hr18_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_160k_ade20k/fcn_hr18_512x512_160k_ade20k_20200614_214426-ca961836.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_160k_ade20k/fcn_hr18_512x512_160k_ade20k_20200614_214426.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr48_4xb4-160k_ade20k-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.02
+      mIoU(ms+flip): 43.86
+  Config: configs/hrnet/fcn_hr48_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W48
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_160k_ade20k/fcn_hr48_512x512_160k_ade20k_20200614_214407-a52fc02c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_160k_ade20k/fcn_hr48_512x512_160k_ade20k_20200614_214407.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr18s_4xb4-20k_voc12aug-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 65.5
+      mIoU(ms+flip): 68.89
+  Config: configs/hrnet/fcn_hr18s_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18-Small
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_20k_voc12aug/fcn_hr18s_512x512_20k_voc12aug_20210829_174910-0aceadb4.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_20k_voc12aug/fcn_hr18s_512x512_20k_voc12aug_20210829_174910.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr18_4xb4-20k_voc12aug-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 72.3
+      mIoU(ms+flip): 74.71
+  Config: configs/hrnet/fcn_hr18_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 2.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_20k_voc12aug/fcn_hr18_512x512_20k_voc12aug_20200617_224503-488d45f7.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_20k_voc12aug/fcn_hr18_512x512_20k_voc12aug_20200617_224503.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr48_4xb4-20k_voc12aug-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 75.87
+      mIoU(ms+flip): 78.58
+  Config: configs/hrnet/fcn_hr48_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W48
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_20k_voc12aug/fcn_hr48_512x512_20k_voc12aug_20200617_224419-89de05cd.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_20k_voc12aug/fcn_hr48_512x512_20k_voc12aug_20200617_224419.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr18s_4xb4-40k_voc12aug-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 66.61
+      mIoU(ms+flip): 70.0
+  Config: configs/hrnet/fcn_hr18s_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18-Small
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_40k_voc12aug/fcn_hr18s_512x512_40k_voc12aug_20200614_000648-4f8d6e7f.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_40k_voc12aug/fcn_hr18s_512x512_40k_voc12aug_20200614_000648.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr18_4xb4-40k_voc12aug-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 72.9
+      mIoU(ms+flip): 75.59
+  Config: configs/hrnet/fcn_hr18_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_40k_voc12aug/fcn_hr18_512x512_40k_voc12aug_20200613_224401-1b4b76cd.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_40k_voc12aug/fcn_hr18_512x512_40k_voc12aug_20200613_224401.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr48_4xb4-40k_voc12aug-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 76.24
+      mIoU(ms+flip): 78.49
+  Config: configs/hrnet/fcn_hr48_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W48
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_40k_voc12aug/fcn_hr48_512x512_40k_voc12aug_20200613_222111-1b0f18bc.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_40k_voc12aug/fcn_hr48_512x512_40k_voc12aug_20200613_222111.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr48_4xb4-40k_pascal-context-480x480
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal Context
+    Metrics:
+      mIoU: 45.14
+      mIoU(ms+flip): 47.42
+  Config: configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-480x480.py
+  Metadata:
+    Training Data: Pascal Context
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W48
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_40k_pascal_context/fcn_hr48_480x480_40k_pascal_context_20200911_164852-667d00b0.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_40k_pascal_context/fcn_hr48_480x480_40k_pascal_context-20200911_164852.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr48_4xb4-80k_pascal-context-480x480
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal Context
+    Metrics:
+      mIoU: 45.84
+      mIoU(ms+flip): 47.84
+  Config: configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-480x480.py
+  Metadata:
+    Training Data: Pascal Context
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W48
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_80k_pascal_context/fcn_hr48_480x480_80k_pascal_context_20200911_155322-847a6711.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_80k_pascal_context/fcn_hr48_480x480_80k_pascal_context-20200911_155322.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr48_4xb4-40k_pascal-context-59-480x480
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal Context 59
+    Metrics:
+      mIoU: 50.33
+      mIoU(ms+flip): 52.83
+  Config: configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-59-480x480.py
+  Metadata:
+    Training Data: Pascal Context 59
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W48
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_40k_pascal_context_59/fcn_hr48_480x480_40k_pascal_context_59_20210410_122738-b808b8b2.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_40k_pascal_context_59/fcn_hr48_480x480_40k_pascal_context_59-20210410_122738.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr48_4xb4-80k_pascal-context-59-480x480
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal Context 59
+    Metrics:
+      mIoU: 51.12
+      mIoU(ms+flip): 53.56
+  Config: configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-59-480x480.py
+  Metadata:
+    Training Data: Pascal Context 59
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W48
+    - FCN
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_80k_pascal_context_59/fcn_hr48_480x480_80k_pascal_context_59_20210411_003240-3ae7081e.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_80k_pascal_context_59/fcn_hr48_480x480_80k_pascal_context_59-20210411_003240.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr18s_4xb4-80k_loveda-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: LoveDA
+    Metrics:
+      mIoU: 49.28
+      mIoU(ms+flip): 49.42
+  Config: configs/hrnet/fcn_hr18s_4xb4-80k_loveda-512x512.py
+  Metadata:
+    Training Data: LoveDA
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18-Small
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.59
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_loveda/fcn_hr18s_512x512_80k_loveda_20211210_203228-60a86a7a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_loveda/fcn_hr18s_512x512_80k_loveda_20211210_203228.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr18_4xb4-80k_loveda-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: LoveDA
+    Metrics:
+      mIoU: 50.81
+      mIoU(ms+flip): 50.95
+  Config: configs/hrnet/fcn_hr18_4xb4-80k_loveda-512x512.py
+  Metadata:
+    Training Data: LoveDA
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 2.76
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_loveda/fcn_hr18_512x512_80k_loveda_20211210_203952-93d9c3b3.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_loveda/fcn_hr18_512x512_80k_loveda_20211210_203952.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr48_4xb4-80k_loveda-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: LoveDA
+    Metrics:
+      mIoU: 51.42
+      mIoU(ms+flip): 51.64
+  Config: configs/hrnet/fcn_hr48_4xb4-80k_loveda-512x512.py
+  Metadata:
+    Training Data: LoveDA
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W48
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_loveda/fcn_hr48_512x512_80k_loveda_20211211_044756-67072f55.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_loveda/fcn_hr48_512x512_80k_loveda_20211211_044756.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr18s_4xb4-80k_potsdam-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Potsdam
+    Metrics:
+      mIoU: 77.64
+      mIoU(ms+flip): 78.8
+  Config: configs/hrnet/fcn_hr18s_4xb4-80k_potsdam-512x512.py
+  Metadata:
+    Training Data: Potsdam
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18-Small
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.58
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_potsdam/fcn_hr18s_512x512_80k_potsdam_20211218_205517-ba32af63.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_potsdam/fcn_hr18s_512x512_80k_potsdam_20211218_205517.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr18_4xb4-80k_potsdam-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Potsdam
+    Metrics:
+      mIoU: 78.26
+      mIoU(ms+flip): 79.24
+  Config: configs/hrnet/fcn_hr18_4xb4-80k_potsdam-512x512.py
+  Metadata:
+    Training Data: Potsdam
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 2.76
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_potsdam/fcn_hr18_512x512_80k_potsdam_20211218_205517-5d0387ad.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_potsdam/fcn_hr18_512x512_80k_potsdam_20211218_205517.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr48_4xb4-80k_potsdam-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Potsdam
+    Metrics:
+      mIoU: 78.39
+      mIoU(ms+flip): 79.34
+  Config: configs/hrnet/fcn_hr48_4xb4-80k_potsdam-512x512.py
+  Metadata:
+    Training Data: Potsdam
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W48
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_potsdam/fcn_hr48_512x512_80k_potsdam_20211219_020601-97434c78.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_potsdam/fcn_hr48_512x512_80k_potsdam_20211219_020601.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr18s_4xb4-80k_vaihingen-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Vaihingen
+    Metrics:
+      mIoU: 71.81
+      mIoU(ms+flip): 73.1
+  Config: configs/hrnet/fcn_hr18s_4xb4-80k_vaihingen-512x512.py
+  Metadata:
+    Training Data: Vaihingen
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18-Small
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.58
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_4x4_512x512_80k_vaihingen/fcn_hr18s_4x4_512x512_80k_vaihingen_20211231_230909-b23aae02.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_4x4_512x512_80k_vaihingen/fcn_hr18s_4x4_512x512_80k_vaihingen_20211231_230909.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr18_4xb4-80k_vaihingen-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Vaihingen
+    Metrics:
+      mIoU: 72.57
+      mIoU(ms+flip): 74.09
+  Config: configs/hrnet/fcn_hr18_4xb4-80k_vaihingen-512x512.py
+  Metadata:
+    Training Data: Vaihingen
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 2.76
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_4x4_512x512_80k_vaihingen/fcn_hr18_4x4_512x512_80k_vaihingen_20211231_231216-2ec3ae8a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_4x4_512x512_80k_vaihingen/fcn_hr18_4x4_512x512_80k_vaihingen_20211231_231216.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr48_4xb4-80k_vaihingen-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Vaihingen
+    Metrics:
+      mIoU: 72.5
+      mIoU(ms+flip): 73.52
+  Config: configs/hrnet/fcn_hr48_4xb4-80k_vaihingen-512x512.py
+  Metadata:
+    Training Data: Vaihingen
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W48
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_4x4_512x512_80k_vaihingen/fcn_hr48_4x4_512x512_80k_vaihingen_20211231_231244-7133cb22.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_4x4_512x512_80k_vaihingen/fcn_hr48_4x4_512x512_80k_vaihingen_20211231_231244.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr18s_4xb4-80k_isaid-896x896
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: iSAID
+    Metrics:
+      mIoU: 62.3
+      mIoU(ms+flip): 62.97
+  Config: configs/hrnet/fcn_hr18s_4xb4-80k_isaid-896x896.py
+  Metadata:
+    Training Data: iSAID
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18-Small
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 4.95
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_4x4_896x896_80k_isaid/fcn_hr18s_4x4_896x896_80k_isaid_20220118_001603-3cc0769b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_4x4_896x896_80k_isaid/fcn_hr18s_4x4_896x896_80k_isaid_20220118_001603.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr18_4xb4-80k_isaid-896x896
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: iSAID
+    Metrics:
+      mIoU: 65.06
+      mIoU(ms+flip): 65.6
+  Config: configs/hrnet/fcn_hr18_4xb4-80k_isaid-896x896.py
+  Metadata:
+    Training Data: iSAID
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.3
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_4x4_896x896_80k_isaid/fcn_hr18_4x4_896x896_80k_isaid_20220110_182230-49bf752e.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_4x4_896x896_80k_isaid/fcn_hr18_4x4_896x896_80k_isaid_20220110_182230.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
+- Name: fcn_hr48_4xb4-80k_isaid-896x896
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: iSAID
+    Metrics:
+      mIoU: 67.8
+      mIoU(ms+flip): 68.53
+  Config: configs/hrnet/fcn_hr48_4xb4-80k_isaid-896x896.py
+  Metadata:
+    Training Data: iSAID
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W48
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 16.89
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_4x4_896x896_80k_isaid/fcn_hr48_4x4_896x896_80k_isaid_20220114_174643-547fc420.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_4x4_896x896_80k_isaid/fcn_hr48_4x4_896x896_80k_isaid_20220114_174643.log.json
+  Paper:
+    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
+    URL: https://arxiv.org/abs/1908.07919
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/icnet/README.md b/mmsegmentation/configs/icnet/README.md
new file mode 100644
index 0000000..fa2327f
--- /dev/null
+++ b/mmsegmentation/configs/icnet/README.md
@@ -0,0 +1,56 @@
+# ICNet
+
+> [ICNet for Real-time Semantic Segmentation on High-resolution Images](https://arxiv.org/abs/1704.08545)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/hszhao/ICNet">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+We focus on the challenging task of real-time semantic segmentation in this paper. It finds many practical applications and yet is with fundamental difficulty of reducing a large portion of computation for pixel-wise label inference. We propose an image cascade network (ICNet) that incorporates multi-resolution branches under proper label guidance to address this challenge. We provide in-depth analysis of our framework and introduce the cascade feature fusion unit to quickly achieve high-quality segmentation. Our system yields real-time inference on a single GPU card with decent quality results evaluated on challenging datasets like Cityscapes, CamVid and COCO-Stuff.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142901772-4570455d-7b27-44ae-a690-47dd9fde8445.png" width="70%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method           | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                | download                                                                                                                                                                                                                                                                                                                                                                               |
+| ---------------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ICNet            | R-18-D8  | 832x832   |   80000 | 1.70     | 27.12          | V100   | 68.14 |         70.16 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r18-d8_4xb2-80k_cityscapes-832x832.py)            | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_832x832_80k_cityscapes/icnet_r18-d8_832x832_80k_cityscapes_20210925_225521-2e36638d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_832x832_80k_cityscapes/icnet_r18-d8_832x832_80k_cityscapes_20210925_225521.log.json)                                             |
+| ICNet            | R-18-D8  | 832x832   |  160000 | -        | -              | V100   | 71.64 |         74.18 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r18-d8_4xb2-160k_cityscapes-832x832.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_832x832_160k_cityscapes/icnet_r18-d8_832x832_160k_cityscapes_20210925_230153-2c6eb6e0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_832x832_160k_cityscapes/icnet_r18-d8_832x832_160k_cityscapes_20210925_230153.log.json)                                         |
+| ICNet (in1k-pre) | R-18-D8  | 832x832   |   80000 | -        | -              | V100   | 72.51 |         74.78 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r18-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_in1k-pre_832x832_80k_cityscapes/icnet_r18-d8_in1k-pre_832x832_80k_cityscapes_20210925_230354-1cbe3022.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_in1k-pre_832x832_80k_cityscapes/icnet_r18-d8_in1k-pre_832x832_80k_cityscapes_20210925_230354.log.json)         |
+| ICNet (in1k-pre) | R-18-D8  | 832x832   |  160000 | -        | -              | V100   | 74.43 |         76.72 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r18-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_in1k-pre_832x832_160k_cityscapes/icnet_r18-d8_in1k-pre_832x832_160k_cityscapes_20210926_052702-619c8ae1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_in1k-pre_832x832_160k_cityscapes/icnet_r18-d8_in1k-pre_832x832_160k_cityscapes_20210926_052702.log.json)     |
+| ICNet            | R-50-D8  | 832x832   |   80000 | 2.53     | 20.08          | V100   | 68.91 |         69.72 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r50-d8_4xb2-80k_cityscapes-832x832.py)            | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_832x832_80k_cityscapes/icnet_r50-d8_832x832_80k_cityscapes_20210926_044625-c6407341.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_832x832_80k_cityscapes/icnet_r50-d8_832x832_80k_cityscapes_20210926_044625.log.json)                                             |
+| ICNet            | R-50-D8  | 832x832   |  160000 | -        | -              | V100   | 73.82 |         75.67 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r50-d8_4xb2-160k_cityscapes-832x832.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_832x832_160k_cityscapes/icnet_r50-d8_832x832_160k_cityscapes_20210925_232612-a95f0d4e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_832x832_160k_cityscapes/icnet_r50-d8_832x832_160k_cityscapes_20210925_232612.log.json)                                         |
+| ICNet (in1k-pre) | R-50-D8  | 832x832   |   80000 | -        | -              | V100   | 74.58 |         76.41 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r50-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_in1k-pre_832x832_80k_cityscapes/icnet_r50-d8_in1k-pre_832x832_80k_cityscapes_20210926_032943-1743dc7b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_in1k-pre_832x832_80k_cityscapes/icnet_r50-d8_in1k-pre_832x832_80k_cityscapes_20210926_032943.log.json)         |
+| ICNet (in1k-pre) | R-50-D8  | 832x832   |  160000 | -        | -              | V100   | 76.29 |         78.09 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r50-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_in1k-pre_832x832_160k_cityscapes/icnet_r50-d8_in1k-pre_832x832_160k_cityscapes_20210926_042715-ce310aea.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_in1k-pre_832x832_160k_cityscapes/icnet_r50-d8_in1k-pre_832x832_160k_cityscapes_20210926_042715.log.json)     |
+| ICNet            | R-101-D8 | 832x832   |   80000 | 3.08     | 16.95          | V100   | 70.28 |         71.95 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r101-d8_4xb2-80k_cityscapes-832x832.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_832x832_80k_cityscapes/icnet_r101-d8_832x832_80k_cityscapes_20210926_072447-b52f936e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_832x832_80k_cityscapes/icnet_r101-d8_832x832_80k_cityscapes_20210926_072447.log.json)                                         |
+| ICNet            | R-101-D8 | 832x832   |  160000 | -        | -              | V100   | 73.80 |         76.10 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r101-d8_4xb2-160k_cityscapes-832x832.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_832x832_160k_cityscapes/icnet_r101-d8_832x832_160k_cityscapes_20210926_092350-3a1ebf1a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_832x832_160k_cityscapes/icnet_r101-d8_832x832_160k_cityscapes_20210926_092350.log.json)                                     |
+| ICNet (in1k-pre) | R-101-D8 | 832x832   |   80000 | -        | -              | V100   | 75.57 |         77.86 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r101-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_in1k-pre_832x832_80k_cityscapes/icnet_r101-d8_in1k-pre_832x832_80k_cityscapes_20210926_020414-7ceb12c5.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_in1k-pre_832x832_80k_cityscapes/icnet_r101-d8_in1k-pre_832x832_80k_cityscapes_20210926_020414.log.json)     |
+| ICNet (in1k-pre) | R-101-D8 | 832x832   |  160000 | -        | -              | V100   | 76.15 |         77.98 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r101-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_in1k-pre_832x832_160k_cityscapes/icnet_r101-d8_in1k-pre_832x832_160k_cityscapes_20210925_232612-9484ae8a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_in1k-pre_832x832_160k_cityscapes/icnet_r101-d8_in1k-pre_832x832_160k_cityscapes_20210925_232612.log.json) |
+
+Note: `in1k-pre` means pretrained model is used.
+
+## Citation
+
+```bibtext
+@inproceedings{zhao2018icnet,
+  title={Icnet for real-time semantic segmentation on high-resolution images},
+  author={Zhao, Hengshuang and Qi, Xiaojuan and Shen, Xiaoyong and Shi, Jianping and Jia, Jiaya},
+  booktitle={Proceedings of the European conference on computer vision (ECCV)},
+  pages={405--420},
+  year={2018}
+}
+```
diff --git a/mmsegmentation/configs/icnet/icnet_r101-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r101-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
new file mode 100644
index 0000000..a6840a1
--- /dev/null
+++ b/mmsegmentation/configs/icnet/icnet_r101-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
@@ -0,0 +1,7 @@
+_base_ = './icnet_r50-d8_4xb2-160k_cityscapes-832x832.py'
+model = dict(
+    backbone=dict(
+        backbone_cfg=dict(
+            depth=101,
+            init_cfg=dict(
+                type='Pretrained', checkpoint='open-mmlab://resnet101_v1c'))))
diff --git a/mmsegmentation/configs/icnet/icnet_r101-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r101-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
new file mode 100644
index 0000000..ca81df8
--- /dev/null
+++ b/mmsegmentation/configs/icnet/icnet_r101-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
@@ -0,0 +1,7 @@
+_base_ = './icnet_r50-d8_4xb2-80k_cityscapes-832x832.py'
+model = dict(
+    backbone=dict(
+        backbone_cfg=dict(
+            depth=101,
+            init_cfg=dict(
+                type='Pretrained', checkpoint='open-mmlab://resnet101_v1c'))))
diff --git a/mmsegmentation/configs/icnet/icnet_r101-d8_4xb2-160k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r101-d8_4xb2-160k_cityscapes-832x832.py
new file mode 100644
index 0000000..ef60446
--- /dev/null
+++ b/mmsegmentation/configs/icnet/icnet_r101-d8_4xb2-160k_cityscapes-832x832.py
@@ -0,0 +1,2 @@
+_base_ = './icnet_r50-d8_4xb2-160k_cityscapes-832x832.py'
+model = dict(backbone=dict(backbone_cfg=dict(depth=101)))
diff --git a/mmsegmentation/configs/icnet/icnet_r101-d8_4xb2-80k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r101-d8_4xb2-80k_cityscapes-832x832.py
new file mode 100644
index 0000000..5173d2d
--- /dev/null
+++ b/mmsegmentation/configs/icnet/icnet_r101-d8_4xb2-80k_cityscapes-832x832.py
@@ -0,0 +1,2 @@
+_base_ = './icnet_r50-d8_4xb2-80k_cityscapes-832x832.py'
+model = dict(backbone=dict(backbone_cfg=dict(depth=101)))
diff --git a/mmsegmentation/configs/icnet/icnet_r18-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r18-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
new file mode 100644
index 0000000..5f72daa
--- /dev/null
+++ b/mmsegmentation/configs/icnet/icnet_r18-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
@@ -0,0 +1,8 @@
+_base_ = './icnet_r50-d8_4xb2-160k_cityscapes-832x832.py'
+model = dict(
+    backbone=dict(
+        layer_channels=(128, 512),
+        backbone_cfg=dict(
+            depth=18,
+            init_cfg=dict(
+                type='Pretrained', checkpoint='open-mmlab://resnet18_v1c'))))
diff --git a/mmsegmentation/configs/icnet/icnet_r18-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r18-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
new file mode 100644
index 0000000..2fc79ab
--- /dev/null
+++ b/mmsegmentation/configs/icnet/icnet_r18-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
@@ -0,0 +1,8 @@
+_base_ = './icnet_r50-d8_4xb2-80k_cityscapes-832x832.py'
+model = dict(
+    backbone=dict(
+        layer_channels=(128, 512),
+        backbone_cfg=dict(
+            depth=18,
+            init_cfg=dict(
+                type='Pretrained', checkpoint='open-mmlab://resnet18_v1c'))))
diff --git a/mmsegmentation/configs/icnet/icnet_r18-d8_4xb2-160k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r18-d8_4xb2-160k_cityscapes-832x832.py
new file mode 100644
index 0000000..2c70e94
--- /dev/null
+++ b/mmsegmentation/configs/icnet/icnet_r18-d8_4xb2-160k_cityscapes-832x832.py
@@ -0,0 +1,3 @@
+_base_ = './icnet_r50-d8_4xb2-160k_cityscapes-832x832.py'
+model = dict(
+    backbone=dict(layer_channels=(128, 512), backbone_cfg=dict(depth=18)))
diff --git a/mmsegmentation/configs/icnet/icnet_r18-d8_4xb2-80k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r18-d8_4xb2-80k_cityscapes-832x832.py
new file mode 100644
index 0000000..23c7ac2
--- /dev/null
+++ b/mmsegmentation/configs/icnet/icnet_r18-d8_4xb2-80k_cityscapes-832x832.py
@@ -0,0 +1,3 @@
+_base_ = './icnet_r50-d8_4xb2-80k_cityscapes-832x832.py'
+model = dict(
+    backbone=dict(layer_channels=(128, 512), backbone_cfg=dict(depth=18)))
diff --git a/mmsegmentation/configs/icnet/icnet_r50-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r50-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
new file mode 100644
index 0000000..f9ab863
--- /dev/null
+++ b/mmsegmentation/configs/icnet/icnet_r50-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
@@ -0,0 +1,6 @@
+_base_ = './icnet_r50-d8_4xb2-160k_cityscapes-832x832.py'
+model = dict(
+    backbone=dict(
+        backbone_cfg=dict(
+            init_cfg=dict(
+                type='Pretrained', checkpoint='open-mmlab://resnet50_v1c'))))
diff --git a/mmsegmentation/configs/icnet/icnet_r50-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r50-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
new file mode 100644
index 0000000..9a085d4
--- /dev/null
+++ b/mmsegmentation/configs/icnet/icnet_r50-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
@@ -0,0 +1,6 @@
+_base_ = './icnet_r50-d8_4xb2-80k_cityscapes-832x832.py'
+model = dict(
+    backbone=dict(
+        backbone_cfg=dict(
+            init_cfg=dict(
+                type='Pretrained', checkpoint='open-mmlab://resnet50_v1c'))))
diff --git a/mmsegmentation/configs/icnet/icnet_r50-d8_4xb2-160k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r50-d8_4xb2-160k_cityscapes-832x832.py
new file mode 100644
index 0000000..1b7b188
--- /dev/null
+++ b/mmsegmentation/configs/icnet/icnet_r50-d8_4xb2-160k_cityscapes-832x832.py
@@ -0,0 +1,8 @@
+_base_ = [
+    '../_base_/models/icnet_r50-d8.py',
+    '../_base_/datasets/cityscapes_832x832.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (832, 832)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/icnet/icnet_r50-d8_4xb2-80k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r50-d8_4xb2-80k_cityscapes-832x832.py
new file mode 100644
index 0000000..001dbca
--- /dev/null
+++ b/mmsegmentation/configs/icnet/icnet_r50-d8_4xb2-80k_cityscapes-832x832.py
@@ -0,0 +1,8 @@
+_base_ = [
+    '../_base_/models/icnet_r50-d8.py',
+    '../_base_/datasets/cityscapes_832x832.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (832, 832)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/icnet/metafile.yaml b/mmsegmentation/configs/icnet/metafile.yaml
new file mode 100644
index 0000000..1d843ee
--- /dev/null
+++ b/mmsegmentation/configs/icnet/metafile.yaml
@@ -0,0 +1,298 @@
+Collections:
+- Name: ICNet
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+  Paper:
+    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
+    URL: https://arxiv.org/abs/1704.08545
+  README: configs/icnet/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: icnet_r18-d8_4xb2-80k_cityscapes-832x832
+  In Collection: ICNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 68.14
+      mIoU(ms+flip): 70.16
+  Config: configs/icnet/icnet_r18-d8_4xb2-80k_cityscapes-832x832.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-18-D8
+    - ICNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.7
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_832x832_80k_cityscapes/icnet_r18-d8_832x832_80k_cityscapes_20210925_225521-2e36638d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_832x832_80k_cityscapes/icnet_r18-d8_832x832_80k_cityscapes_20210925_225521.log.json
+  Paper:
+    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
+    URL: https://arxiv.org/abs/1704.08545
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
+  Framework: PyTorch
+- Name: icnet_r18-d8_4xb2-160k_cityscapes-832x832
+  In Collection: ICNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 71.64
+      mIoU(ms+flip): 74.18
+  Config: configs/icnet/icnet_r18-d8_4xb2-160k_cityscapes-832x832.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-18-D8
+    - ICNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_832x832_160k_cityscapes/icnet_r18-d8_832x832_160k_cityscapes_20210925_230153-2c6eb6e0.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_832x832_160k_cityscapes/icnet_r18-d8_832x832_160k_cityscapes_20210925_230153.log.json
+  Paper:
+    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
+    URL: https://arxiv.org/abs/1704.08545
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
+  Framework: PyTorch
+- Name: icnet_r18-d8-in1k-pre_4xb2-80k_cityscapes-832x832
+  In Collection: ICNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 72.51
+      mIoU(ms+flip): 74.78
+  Config: configs/icnet/icnet_r18-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-18-D8
+    - ICNet
+    - (in1k-pre)
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_in1k-pre_832x832_80k_cityscapes/icnet_r18-d8_in1k-pre_832x832_80k_cityscapes_20210925_230354-1cbe3022.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_in1k-pre_832x832_80k_cityscapes/icnet_r18-d8_in1k-pre_832x832_80k_cityscapes_20210925_230354.log.json
+  Paper:
+    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
+    URL: https://arxiv.org/abs/1704.08545
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
+  Framework: PyTorch
+- Name: icnet_r18-d8-in1k-pre_4xb2-160k_cityscapes-832x832
+  In Collection: ICNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 74.43
+      mIoU(ms+flip): 76.72
+  Config: configs/icnet/icnet_r18-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-18-D8
+    - ICNet
+    - (in1k-pre)
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_in1k-pre_832x832_160k_cityscapes/icnet_r18-d8_in1k-pre_832x832_160k_cityscapes_20210926_052702-619c8ae1.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_in1k-pre_832x832_160k_cityscapes/icnet_r18-d8_in1k-pre_832x832_160k_cityscapes_20210926_052702.log.json
+  Paper:
+    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
+    URL: https://arxiv.org/abs/1704.08545
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
+  Framework: PyTorch
+- Name: icnet_r50-d8_4xb2-80k_cityscapes-832x832
+  In Collection: ICNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 68.91
+      mIoU(ms+flip): 69.72
+  Config: configs/icnet/icnet_r50-d8_4xb2-80k_cityscapes-832x832.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - ICNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 2.53
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_832x832_80k_cityscapes/icnet_r50-d8_832x832_80k_cityscapes_20210926_044625-c6407341.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_832x832_80k_cityscapes/icnet_r50-d8_832x832_80k_cityscapes_20210926_044625.log.json
+  Paper:
+    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
+    URL: https://arxiv.org/abs/1704.08545
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
+  Framework: PyTorch
+- Name: icnet_r50-d8_4xb2-160k_cityscapes-832x832
+  In Collection: ICNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 73.82
+      mIoU(ms+flip): 75.67
+  Config: configs/icnet/icnet_r50-d8_4xb2-160k_cityscapes-832x832.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - ICNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_832x832_160k_cityscapes/icnet_r50-d8_832x832_160k_cityscapes_20210925_232612-a95f0d4e.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_832x832_160k_cityscapes/icnet_r50-d8_832x832_160k_cityscapes_20210925_232612.log.json
+  Paper:
+    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
+    URL: https://arxiv.org/abs/1704.08545
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
+  Framework: PyTorch
+- Name: icnet_r50-d8-in1k-pre_4xb2-80k_cityscapes-832x832
+  In Collection: ICNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 74.58
+      mIoU(ms+flip): 76.41
+  Config: configs/icnet/icnet_r50-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - ICNet
+    - (in1k-pre)
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_in1k-pre_832x832_80k_cityscapes/icnet_r50-d8_in1k-pre_832x832_80k_cityscapes_20210926_032943-1743dc7b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_in1k-pre_832x832_80k_cityscapes/icnet_r50-d8_in1k-pre_832x832_80k_cityscapes_20210926_032943.log.json
+  Paper:
+    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
+    URL: https://arxiv.org/abs/1704.08545
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
+  Framework: PyTorch
+- Name: icnet_r50-d8-in1k-pre_4xb2-160k_cityscapes-832x832
+  In Collection: ICNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.29
+      mIoU(ms+flip): 78.09
+  Config: configs/icnet/icnet_r50-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - ICNet
+    - (in1k-pre)
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_in1k-pre_832x832_160k_cityscapes/icnet_r50-d8_in1k-pre_832x832_160k_cityscapes_20210926_042715-ce310aea.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_in1k-pre_832x832_160k_cityscapes/icnet_r50-d8_in1k-pre_832x832_160k_cityscapes_20210926_042715.log.json
+  Paper:
+    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
+    URL: https://arxiv.org/abs/1704.08545
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
+  Framework: PyTorch
+- Name: icnet_r101-d8_4xb2-80k_cityscapes-832x832
+  In Collection: ICNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 70.28
+      mIoU(ms+flip): 71.95
+  Config: configs/icnet/icnet_r101-d8_4xb2-80k_cityscapes-832x832.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - ICNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 3.08
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_832x832_80k_cityscapes/icnet_r101-d8_832x832_80k_cityscapes_20210926_072447-b52f936e.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_832x832_80k_cityscapes/icnet_r101-d8_832x832_80k_cityscapes_20210926_072447.log.json
+  Paper:
+    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
+    URL: https://arxiv.org/abs/1704.08545
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
+  Framework: PyTorch
+- Name: icnet_r101-d8_4xb2-160k_cityscapes-832x832
+  In Collection: ICNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 73.8
+      mIoU(ms+flip): 76.1
+  Config: configs/icnet/icnet_r101-d8_4xb2-160k_cityscapes-832x832.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - ICNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_832x832_160k_cityscapes/icnet_r101-d8_832x832_160k_cityscapes_20210926_092350-3a1ebf1a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_832x832_160k_cityscapes/icnet_r101-d8_832x832_160k_cityscapes_20210926_092350.log.json
+  Paper:
+    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
+    URL: https://arxiv.org/abs/1704.08545
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
+  Framework: PyTorch
+- Name: icnet_r101-d8-in1k-pre_4xb2-80k_cityscapes-832x832
+  In Collection: ICNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 75.57
+      mIoU(ms+flip): 77.86
+  Config: configs/icnet/icnet_r101-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - ICNet
+    - (in1k-pre)
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_in1k-pre_832x832_80k_cityscapes/icnet_r101-d8_in1k-pre_832x832_80k_cityscapes_20210926_020414-7ceb12c5.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_in1k-pre_832x832_80k_cityscapes/icnet_r101-d8_in1k-pre_832x832_80k_cityscapes_20210926_020414.log.json
+  Paper:
+    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
+    URL: https://arxiv.org/abs/1704.08545
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
+  Framework: PyTorch
+- Name: icnet_r101-d8-in1k-pre_4xb2-160k_cityscapes-832x832
+  In Collection: ICNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.15
+      mIoU(ms+flip): 77.98
+  Config: configs/icnet/icnet_r101-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - ICNet
+    - (in1k-pre)
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_in1k-pre_832x832_160k_cityscapes/icnet_r101-d8_in1k-pre_832x832_160k_cityscapes_20210925_232612-9484ae8a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_in1k-pre_832x832_160k_cityscapes/icnet_r101-d8_in1k-pre_832x832_160k_cityscapes_20210925_232612.log.json
+  Paper:
+    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
+    URL: https://arxiv.org/abs/1704.08545
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/isanet/README.md b/mmsegmentation/configs/isanet/README.md
new file mode 100644
index 0000000..c11744f
--- /dev/null
+++ b/mmsegmentation/configs/isanet/README.md
@@ -0,0 +1,80 @@
+# ISANet
+
+> [Interlaced Sparse Self-Attention for Semantic Segmentation](https://arxiv.org/abs/1907.12273)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/openseg-group/openseg.pytorch">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+In this paper, we present a so-called interlaced sparse self-attention approach to improve the efficiency of the \\emph{self-attention} mechanism for semantic segmentation. The main idea is that we factorize the dense affinity matrix as the product of two sparse affinity matrices. There are two successive attention modules each estimating a sparse affinity matrix. The first attention module is used to estimate the affinities within a subset of positions that have long spatial interval distances and the second attention module is used to estimate the affinities within a subset of positions that have short spatial interval distances. These two attention modules are designed so that each position is able to receive the information from all the other positions. In contrast to the original self-attention module, our approach decreases the computation and memory complexity substantially especially when processing high-resolution feature maps. We empirically verify the effectiveness of our approach on six challenging semantic segmentation benchmarks.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142901868-03d80da4-b9c0-4df9-8509-5f684ba9dadc.png" width="80%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) |                                                                                                                         config | download                                                                                                                                                                                                                                                                                                                                                 |
+| ------ | -------- | --------- | ------- | -------: | -------------- | ------ | ----- | ------------: | -----------------------------------------------------------------------------------------------------------------------------: | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ISANet | R-50-D8  | 512x1024  | 40000   |    5.869 | 2.91           | V100   | 78.49 |         79.44 |  [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x1024_40k_cityscapes/isanet_r50-d8_512x1024_40k_cityscapes_20210901_054739-981bd763.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x1024_40k_cityscapes/isanet_r50-d8_512x1024_40k_cityscapes_20210901_054739.log.json)     |
+| ISANet | R-50-D8  | 512x1024  | 80000   |    5.869 | 2.91           | V100   | 78.68 |         80.25 |  [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x1024_80k_cityscapes/isanet_r50-d8_512x1024_80k_cityscapes_20210901_074202-89384497.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x1024_80k_cityscapes/isanet_r50-d8_512x1024_80k_cityscapes_20210901_074202.log.json)     |
+| ISANet | R-50-D8  | 769x769   | 40000   |    6.759 | 1.54           | V100   | 78.70 |         80.28 |   [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-769x769.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_769x769_40k_cityscapes/isanet_r50-d8_769x769_40k_cityscapes_20210903_050200-4ae7e65b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_769x769_40k_cityscapes/isanet_r50-d8_769x769_40k_cityscapes_20210903_050200.log.json)         |
+| ISANet | R-50-D8  | 769x769   | 80000   |    6.759 | 1.54           | V100   | 79.29 |         80.53 |   [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-769x769.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_769x769_80k_cityscapes/isanet_r50-d8_769x769_80k_cityscapes_20210903_101126-99b54519.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_769x769_80k_cityscapes/isanet_r50-d8_769x769_80k_cityscapes_20210903_101126.log.json)         |
+| ISANet | R-101-D8 | 512x1024  | 40000   |    9.425 | 2.35           | V100   | 79.58 |         81.05 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x1024_40k_cityscapes/isanet_r101-d8_512x1024_40k_cityscapes_20210901_145553-293e6bd6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x1024_40k_cityscapes/isanet_r101-d8_512x1024_40k_cityscapes_20210901_145553.log.json) |
+| ISANet | R-101-D8 | 512x1024  | 80000   |    9.425 | 2.35           | V100   | 80.32 |         81.58 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x1024_80k_cityscapes/isanet_r101-d8_512x1024_80k_cityscapes_20210901_145243-5b99c9b2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x1024_80k_cityscapes/isanet_r101-d8_512x1024_80k_cityscapes_20210901_145243.log.json) |
+| ISANet | R-101-D8 | 769x769   | 40000   |   10.815 | 0.92           | V100   | 79.68 |         80.95 |  [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-769x769.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_769x769_40k_cityscapes/isanet_r101-d8_769x769_40k_cityscapes_20210903_111320-509e7224.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_769x769_40k_cityscapes/isanet_r101-d8_769x769_40k_cityscapes_20210903_111320.log.json)     |
+| ISANet | R-101-D8 | 769x769   | 80000   |   10.815 | 0.92           | V100   | 80.61 |         81.59 |  [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-769x769.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_769x769_80k_cityscapes/isanet_r101-d8_769x769_80k_cityscapes_20210903_111319-24f71dfa.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_769x769_80k_cityscapes/isanet_r101-d8_769x769_80k_cityscapes_20210903_111319.log.json)     |
+
+### ADE20K
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) |                                                                                                                     config | download                                                                                                                                                                                                                                                                                                                                 |
+| ------ | -------- | --------- | ------- | -------: | -------------- | ------ | ----- | ------------: | -------------------------------------------------------------------------------------------------------------------------: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ISANet | R-50-D8  | 512x512   | 80000   |      9.0 | 22.55          | V100   | 41.12 |         42.35 |   [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r50-d8_4xb4-80k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_80k_ade20k/isanet_r50-d8_512x512_80k_ade20k_20210903_124557-6ed83a0c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_80k_ade20k/isanet_r50-d8_512x512_80k_ade20k_20210903_124557.log.json)         |
+| ISANet | R-50-D8  | 512x512   | 160000  |      9.0 | 22.55          | V100   | 42.59 |         43.07 |  [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r50-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_160k_ade20k/isanet_r50-d8_512x512_160k_ade20k_20210903_104850-f752d0a3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_160k_ade20k/isanet_r50-d8_512x512_160k_ade20k_20210903_104850.log.json)     |
+| ISANet | R-101-D8 | 512x512   | 80000   |   12.562 | 10.56          | V100   | 43.51 |         44.38 |  [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r101-d8_4xb4-80k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_80k_ade20k/isanet_r101-d8_512x512_80k_ade20k_20210903_162056-68b235c2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_80k_ade20k/isanet_r101-d8_512x512_80k_ade20k_20210903_162056.log.json)     |
+| ISANet | R-101-D8 | 512x512   | 160000  |   12.562 | 10.56          | V100   | 43.80 |          45.4 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_160k_ade20k/isanet_r101-d8_512x512_160k_ade20k_20210903_211431-a7879dcd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_160k_ade20k/isanet_r101-d8_512x512_160k_ade20k_20210903_211431.log.json) |
+
+### Pascal VOC 2012 + Aug
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) |                                                                                                                      config | download                                                                                                                                                                                                                                                                                                                                     |
+| ------ | -------- | --------- | ------- | -------: | -------------- | ------ | ----- | ------------: | --------------------------------------------------------------------------------------------------------------------------: | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ISANet | R-50-D8  | 512x512   | 20000   |      5.9 | 23.08          | V100   | 76.78 |         77.79 |  [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r50-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_20k_voc12aug/isanet_r50-d8_512x512_20k_voc12aug_20210901_164838-79d59b80.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_20k_voc12aug/isanet_r50-d8_512x512_20k_voc12aug_20210901_164838.log.json)     |
+| ISANet | R-50-D8  | 512x512   | 40000   |      5.9 | 23.08          | V100   | 76.20 |         77.22 |  [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r50-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_40k_voc12aug/isanet_r50-d8_512x512_40k_voc12aug_20210901_151349-7d08a54e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_40k_voc12aug/isanet_r50-d8_512x512_40k_voc12aug_20210901_151349.log.json)     |
+| ISANet | R-101-D8 | 512x512   | 20000   |    9.465 | 7.42           | V100   | 78.46 |         79.16 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r101-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_20k_voc12aug/isanet_r101-d8_512x512_20k_voc12aug_20210901_115805-3ccbf355.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_20k_voc12aug/isanet_r101-d8_512x512_20k_voc12aug_20210901_115805.log.json) |
+| ISANet | R-101-D8 | 512x512   | 40000   |    9.465 | 7.42           | V100   | 78.12 |         79.04 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r101-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_40k_voc12aug/isanet_r101-d8_512x512_40k_voc12aug_20210901_145814-bc71233b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_40k_voc12aug/isanet_r101-d8_512x512_40k_voc12aug_20210901_145814.log.json) |
+
+## Citation
+
+```bibetex
+@article{huang2019isa,
+  title={Interlaced Sparse Self-Attention for Semantic Segmentation},
+  author={Huang, Lang and Yuan, Yuhui and Guo, Jianyuan and Zhang, Chao and Chen, Xilin and Wang, Jingdong},
+  journal={arXiv preprint arXiv:1907.12273},
+  year={2019}
+}
+```
+
+The technical report above is also presented at:
+
+```bibetex
+@article{yuan2021ocnet,
+  title={OCNet: Object Context for Semantic Segmentation},
+  author={Yuan, Yuhui and Huang, Lang and Guo, Jianyuan and Zhang, Chao and Chen, Xilin and Wang, Jingdong},
+  journal={International Journal of Computer Vision},
+  pages={1--24},
+  year={2021},
+  publisher={Springer}
+}
+```
diff --git a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..6093aeb
--- /dev/null
+++ b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './isanet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..dc14c76
--- /dev/null
+++ b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './isanet_r50-d8_4xb2-40k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..1735f89
--- /dev/null
+++ b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './isanet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..b1a6371
--- /dev/null
+++ b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './isanet_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..c2fb09e
--- /dev/null
+++ b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './isanet_r50-d8_4xb4-160k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..7c225cf
--- /dev/null
+++ b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './isanet_r50-d8_4xb4-20k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..5e86ee5
--- /dev/null
+++ b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './isanet_r50-d8_4xb4-40k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..090e86f
--- /dev/null
+++ b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './isanet_r50-d8_4xb4-80k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..f03365e
--- /dev/null
+++ b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/isanet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..f073a7b
--- /dev/null
+++ b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/isanet_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..4be445d
--- /dev/null
+++ b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/isanet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..0278ad8
--- /dev/null
+++ b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/isanet_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..1f4af8d
--- /dev/null
+++ b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/isanet_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..591df42
--- /dev/null
+++ b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/isanet_r50-d8.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_20k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..a59879b
--- /dev/null
+++ b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/isanet_r50-d8.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..7df05c3
--- /dev/null
+++ b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/isanet_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/isanet/metafile.yaml b/mmsegmentation/configs/isanet/metafile.yaml
new file mode 100644
index 0000000..ad394ea
--- /dev/null
+++ b/mmsegmentation/configs/isanet/metafile.yaml
@@ -0,0 +1,399 @@
+Collections:
+- Name: ISANet
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+    - ADE20K
+    - Pascal VOC 2012 + Aug
+  Paper:
+    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
+    URL: https://arxiv.org/abs/1907.12273
+  README: configs/isanet/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: isanet_r50-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: ISANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.49
+      mIoU(ms+flip): 79.44
+  Config: configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - ISANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.869
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x1024_40k_cityscapes/isanet_r50-d8_512x1024_40k_cityscapes_20210901_054739-981bd763.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x1024_40k_cityscapes/isanet_r50-d8_512x1024_40k_cityscapes_20210901_054739.log.json
+  Paper:
+    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
+    URL: https://arxiv.org/abs/1907.12273
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
+  Framework: PyTorch
+- Name: isanet_r50-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: ISANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.68
+      mIoU(ms+flip): 80.25
+  Config: configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - ISANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.869
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x1024_80k_cityscapes/isanet_r50-d8_512x1024_80k_cityscapes_20210901_074202-89384497.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x1024_80k_cityscapes/isanet_r50-d8_512x1024_80k_cityscapes_20210901_074202.log.json
+  Paper:
+    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
+    URL: https://arxiv.org/abs/1907.12273
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
+  Framework: PyTorch
+- Name: isanet_r50-d8_4xb2-40k_cityscapes-769x769
+  In Collection: ISANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.7
+      mIoU(ms+flip): 80.28
+  Config: configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - ISANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.759
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_769x769_40k_cityscapes/isanet_r50-d8_769x769_40k_cityscapes_20210903_050200-4ae7e65b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_769x769_40k_cityscapes/isanet_r50-d8_769x769_40k_cityscapes_20210903_050200.log.json
+  Paper:
+    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
+    URL: https://arxiv.org/abs/1907.12273
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
+  Framework: PyTorch
+- Name: isanet_r50-d8_4xb2-80k_cityscapes-769x769
+  In Collection: ISANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.29
+      mIoU(ms+flip): 80.53
+  Config: configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - ISANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.759
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_769x769_80k_cityscapes/isanet_r50-d8_769x769_80k_cityscapes_20210903_101126-99b54519.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_769x769_80k_cityscapes/isanet_r50-d8_769x769_80k_cityscapes_20210903_101126.log.json
+  Paper:
+    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
+    URL: https://arxiv.org/abs/1907.12273
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
+  Framework: PyTorch
+- Name: isanet_r101-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: ISANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.58
+      mIoU(ms+flip): 81.05
+  Config: configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - ISANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.425
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x1024_40k_cityscapes/isanet_r101-d8_512x1024_40k_cityscapes_20210901_145553-293e6bd6.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x1024_40k_cityscapes/isanet_r101-d8_512x1024_40k_cityscapes_20210901_145553.log.json
+  Paper:
+    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
+    URL: https://arxiv.org/abs/1907.12273
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
+  Framework: PyTorch
+- Name: isanet_r101-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: ISANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 80.32
+      mIoU(ms+flip): 81.58
+  Config: configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - ISANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.425
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x1024_80k_cityscapes/isanet_r101-d8_512x1024_80k_cityscapes_20210901_145243-5b99c9b2.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x1024_80k_cityscapes/isanet_r101-d8_512x1024_80k_cityscapes_20210901_145243.log.json
+  Paper:
+    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
+    URL: https://arxiv.org/abs/1907.12273
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
+  Framework: PyTorch
+- Name: isanet_r101-d8_4xb2-40k_cityscapes-769x769
+  In Collection: ISANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.68
+      mIoU(ms+flip): 80.95
+  Config: configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - ISANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.815
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_769x769_40k_cityscapes/isanet_r101-d8_769x769_40k_cityscapes_20210903_111320-509e7224.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_769x769_40k_cityscapes/isanet_r101-d8_769x769_40k_cityscapes_20210903_111320.log.json
+  Paper:
+    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
+    URL: https://arxiv.org/abs/1907.12273
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
+  Framework: PyTorch
+- Name: isanet_r101-d8_4xb2-80k_cityscapes-769x769
+  In Collection: ISANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 80.61
+      mIoU(ms+flip): 81.59
+  Config: configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - ISANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.815
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_769x769_80k_cityscapes/isanet_r101-d8_769x769_80k_cityscapes_20210903_111319-24f71dfa.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_769x769_80k_cityscapes/isanet_r101-d8_769x769_80k_cityscapes_20210903_111319.log.json
+  Paper:
+    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
+    URL: https://arxiv.org/abs/1907.12273
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
+  Framework: PyTorch
+- Name: isanet_r50-d8_4xb4-80k_ade20k-512x512
+  In Collection: ISANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 41.12
+      mIoU(ms+flip): 42.35
+  Config: configs/isanet/isanet_r50-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - ISANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_80k_ade20k/isanet_r50-d8_512x512_80k_ade20k_20210903_124557-6ed83a0c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_80k_ade20k/isanet_r50-d8_512x512_80k_ade20k_20210903_124557.log.json
+  Paper:
+    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
+    URL: https://arxiv.org/abs/1907.12273
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
+  Framework: PyTorch
+- Name: isanet_r50-d8_4xb4-160k_ade20k-512x512
+  In Collection: ISANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.59
+      mIoU(ms+flip): 43.07
+  Config: configs/isanet/isanet_r50-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - ISANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_160k_ade20k/isanet_r50-d8_512x512_160k_ade20k_20210903_104850-f752d0a3.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_160k_ade20k/isanet_r50-d8_512x512_160k_ade20k_20210903_104850.log.json
+  Paper:
+    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
+    URL: https://arxiv.org/abs/1907.12273
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
+  Framework: PyTorch
+- Name: isanet_r101-d8_4xb4-80k_ade20k-512x512
+  In Collection: ISANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 43.51
+      mIoU(ms+flip): 44.38
+  Config: configs/isanet/isanet_r101-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - ISANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 12.562
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_80k_ade20k/isanet_r101-d8_512x512_80k_ade20k_20210903_162056-68b235c2.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_80k_ade20k/isanet_r101-d8_512x512_80k_ade20k_20210903_162056.log.json
+  Paper:
+    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
+    URL: https://arxiv.org/abs/1907.12273
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
+  Framework: PyTorch
+- Name: isanet_r101-d8_4xb4-160k_ade20k-512x512
+  In Collection: ISANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 43.8
+      mIoU(ms+flip): 45.4
+  Config: configs/isanet/isanet_r101-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - ISANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 12.562
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_160k_ade20k/isanet_r101-d8_512x512_160k_ade20k_20210903_211431-a7879dcd.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_160k_ade20k/isanet_r101-d8_512x512_160k_ade20k_20210903_211431.log.json
+  Paper:
+    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
+    URL: https://arxiv.org/abs/1907.12273
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
+  Framework: PyTorch
+- Name: isanet_r50-d8_4xb4-20k_voc12aug-512x512
+  In Collection: ISANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 76.78
+      mIoU(ms+flip): 77.79
+  Config: configs/isanet/isanet_r50-d8_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - ISANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_20k_voc12aug/isanet_r50-d8_512x512_20k_voc12aug_20210901_164838-79d59b80.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_20k_voc12aug/isanet_r50-d8_512x512_20k_voc12aug_20210901_164838.log.json
+  Paper:
+    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
+    URL: https://arxiv.org/abs/1907.12273
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
+  Framework: PyTorch
+- Name: isanet_r50-d8_4xb4-40k_voc12aug-512x512
+  In Collection: ISANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 76.2
+      mIoU(ms+flip): 77.22
+  Config: configs/isanet/isanet_r50-d8_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - ISANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_40k_voc12aug/isanet_r50-d8_512x512_40k_voc12aug_20210901_151349-7d08a54e.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_40k_voc12aug/isanet_r50-d8_512x512_40k_voc12aug_20210901_151349.log.json
+  Paper:
+    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
+    URL: https://arxiv.org/abs/1907.12273
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
+  Framework: PyTorch
+- Name: isanet_r101-d8_4xb4-20k_voc12aug-512x512
+  In Collection: ISANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 78.46
+      mIoU(ms+flip): 79.16
+  Config: configs/isanet/isanet_r101-d8_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - ISANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.465
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_20k_voc12aug/isanet_r101-d8_512x512_20k_voc12aug_20210901_115805-3ccbf355.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_20k_voc12aug/isanet_r101-d8_512x512_20k_voc12aug_20210901_115805.log.json
+  Paper:
+    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
+    URL: https://arxiv.org/abs/1907.12273
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
+  Framework: PyTorch
+- Name: isanet_r101-d8_4xb4-40k_voc12aug-512x512
+  In Collection: ISANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 78.12
+      mIoU(ms+flip): 79.04
+  Config: configs/isanet/isanet_r101-d8_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - ISANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.465
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_40k_voc12aug/isanet_r101-d8_512x512_40k_voc12aug_20210901_145814-bc71233b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_40k_voc12aug/isanet_r101-d8_512x512_40k_voc12aug_20210901_145814.log.json
+  Paper:
+    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
+    URL: https://arxiv.org/abs/1907.12273
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/knet/README.md b/mmsegmentation/configs/knet/README.md
new file mode 100644
index 0000000..1f3f2ae
--- /dev/null
+++ b/mmsegmentation/configs/knet/README.md
@@ -0,0 +1,52 @@
+# K-Net
+
+> [K-Net: Towards Unified Image Segmentation](https://arxiv.org/abs/2106.14855)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/ZwwWayne/K-Net/">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.23.0/mmseg/models/decode_heads/knet_head.py#L392">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Semantic, instance, and panoptic segmentations have been addressed using different and specialized frameworks despite their underlying connections. This paper presents a unified, simple, and effective framework for these essentially similar tasks. The framework, named K-Net, segments both instances and semantic categories consistently by a group of learnable kernels, where each kernel is responsible for generating a mask for either a potential instance or a stuff class. To remedy the difficulties of distinguishing various instances, we propose a kernel update strategy that enables each kernel dynamic and conditional on its meaningful group in the input image. K-Net can be trained in an end-to-end manner with bipartite matching, and its training and inference are naturally NMS-free and box-free. Without bells and whistles, K-Net surpasses all previous published state-of-the-art single-model results of panoptic segmentation on MS COCO test-dev split and semantic segmentation on ADE20K val split with 55.2% PQ and 54.3% mIoU, respectively. Its instance segmentation performance is also on par with Cascade Mask R-CNN on MS COCO with 60%-90% faster inference speeds. Code and models will be released at [this https URL](https://github.com/ZwwWayne/K-Net/).
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/157008300-9f40905c-b8e8-4a2a-9593-c1177fa35b2c.png" width="90%"/>
+</div>
+
+## Results and models
+
+### ADE20K
+
+| Method           | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                                  | download                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | -------- | --------- | ------- | -------- | -------------- | ------ | ----- | ------------- | --------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| KNet + FCN       | R-50-D8  | 512x512   | 80000   | 7.01     | 19.24          | V100   | 43.60 | 45.12         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/knet/knet-s3_r50-d8_fcn_8xb2-adamw-80k_ade20k-512x512.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_fcn_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_fcn_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_043751-abcab920.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_fcn_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_fcn_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_043751.log.json)                         |
+| KNet + PSPNet    | R-50-D8  | 512x512   | 80000   | 6.98     | 20.04          | V100   | 44.18 | 45.58         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/knet/knet-s3_r50-d8_pspnet_8xb2-adamw-80k_ade20k-512x512.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_pspnet_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_pspnet_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_054634-d2c72240.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_pspnet_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_pspnet_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_054634.log.json)             |
+| KNet + DeepLabV3 | R-50-D8  | 512x512   | 80000   | 7.42     | 12.10          | V100   | 45.06 | 46.11         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/knet/knet-s3_r50-d8_deeplabv3_8xb2-adamw-80k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_deeplabv3_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_deeplabv3_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_041642-00c8fbeb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_deeplabv3_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_deeplabv3_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_041642.log.json) |
+| KNet + UperNet   | R-50-D8  | 512x512   | 80000   | 7.34     | 17.11          | V100   | 43.45 | 44.07         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/knet/knet-s3_r50-d8_upernet_8xb2-adamw-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_r50-d8_8x2_512x512_adamw_80k_ade20k_20220304_125657-215753b0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_r50-d8_8x2_512x512_adamw_80k_ade20k_20220304_125657.log.json)         |
+| KNet + UperNet   | Swin-T   | 512x512   | 80000   | 7.57     | 15.56          | V100   | 45.84 | 46.27         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/knet/knet-s3_swin-t_upernet_8xb2-adamw-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-t_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_swin-t_8x2_512x512_adamw_80k_ade20k_20220303_133059-7545e1dc.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-t_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_swin-t_8x2_512x512_adamw_80k_ade20k_20220303_133059.log.json)         |
+| KNet + UperNet   | Swin-L   | 512x512   | 80000   | 13.5     | 8.29           | V100   | 52.05 | 53.24         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-l_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_swin-l_8x2_512x512_adamw_80k_ade20k_20220303_154559-d8da9a90.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-l_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_swin-l_8x2_512x512_adamw_80k_ade20k_20220303_154559.log.json)         |
+| KNet + UperNet   | Swin-L   | 640x640   | 80000   | 13.54    | 8.29           | V100   | 52.21 | 53.34         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-640x640.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-l_8x2_640x640_adamw_80k_ade20k/knet_s3_upernet_swin-l_8x2_640x640_adamw_80k_ade20k_20220301_220747-8787fc71.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-l_8x2_640x640_adamw_80k_ade20k/knet_s3_upernet_swin-l_8x2_640x640_adamw_80k_ade20k_20220301_220747.log.json)         |
+
+Note:
+
+- All experiments of K-Net are implemented with 8 V100 (32G) GPUs with 2 samplers per GPU.
+
+# Citation
+
+```bibtex
+@inproceedings{zhang2021knet,
+    title={{K-Net: Towards} Unified Image Segmentation},
+    author={Wenwei Zhang and Jiangmiao Pang and Kai Chen and Chen Change Loy},
+    year={2021},
+    booktitle={NeurIPS},
+}
+```
diff --git a/mmsegmentation/configs/knet/knet-s3_r50-d8_deeplabv3_8xb2-adamw-80k_ade20k-512x512.py b/mmsegmentation/configs/knet/knet-s3_r50-d8_deeplabv3_8xb2-adamw-80k_ade20k-512x512.py
new file mode 100644
index 0000000..7946cca
--- /dev/null
+++ b/mmsegmentation/configs/knet/knet-s3_r50-d8_deeplabv3_8xb2-adamw-80k_ade20k-512x512.py
@@ -0,0 +1,111 @@
+_base_ = [
+    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    size=crop_size,
+    seg_pad_val=255)
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+num_stages = 3
+conv_kernel_size = 1
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='IterativeDecodeHead',
+        num_stages=num_stages,
+        kernel_update_head=[
+            dict(
+                type='KernelUpdateHead',
+                num_classes=150,
+                num_ffn_fcs=2,
+                num_heads=8,
+                num_mask_fcs=1,
+                feedforward_channels=2048,
+                in_channels=512,
+                out_channels=512,
+                dropout=0.0,
+                conv_kernel_size=conv_kernel_size,
+                ffn_act_cfg=dict(type='ReLU', inplace=True),
+                with_ffn=True,
+                feat_transform_cfg=dict(
+                    conv_cfg=dict(type='Conv2d'), act_cfg=None),
+                kernel_updator_cfg=dict(
+                    type='KernelUpdator',
+                    in_channels=256,
+                    feat_channels=256,
+                    out_channels=256,
+                    act_cfg=dict(type='ReLU', inplace=True),
+                    norm_cfg=dict(type='LN'))) for _ in range(num_stages)
+        ],
+        kernel_generate_head=dict(
+            type='ASPPHead',
+            in_channels=2048,
+            in_index=3,
+            channels=512,
+            dilations=(1, 12, 24, 36),
+            dropout_ratio=0.1,
+            num_classes=150,
+            norm_cfg=norm_cfg,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=150,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+
+# optimizer
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0005),
+    clip_grad=dict(max_norm=1, norm_type=2))
+# learning policy
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0,
+        end=1000),
+    dict(
+        type='MultiStepLR',
+        begin=1000,
+        end=80000,
+        milestones=[60000, 72000],
+        by_epoch=False,
+    )
+]
+# In K-Net implementation we use batch size 2 per GPU as default
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/knet/knet-s3_r50-d8_fcn_8xb2-adamw-80k_ade20k-512x512.py b/mmsegmentation/configs/knet/knet-s3_r50-d8_fcn_8xb2-adamw-80k_ade20k-512x512.py
new file mode 100644
index 0000000..497cd04
--- /dev/null
+++ b/mmsegmentation/configs/knet/knet-s3_r50-d8_fcn_8xb2-adamw-80k_ade20k-512x512.py
@@ -0,0 +1,112 @@
+_base_ = [
+    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    size=crop_size,
+    seg_pad_val=255)
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+num_stages = 3
+conv_kernel_size = 1
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='IterativeDecodeHead',
+        num_stages=num_stages,
+        kernel_update_head=[
+            dict(
+                type='KernelUpdateHead',
+                num_classes=150,
+                num_ffn_fcs=2,
+                num_heads=8,
+                num_mask_fcs=1,
+                feedforward_channels=2048,
+                in_channels=512,
+                out_channels=512,
+                dropout=0.0,
+                conv_kernel_size=conv_kernel_size,
+                ffn_act_cfg=dict(type='ReLU', inplace=True),
+                with_ffn=True,
+                feat_transform_cfg=dict(
+                    conv_cfg=dict(type='Conv2d'), act_cfg=None),
+                kernel_updator_cfg=dict(
+                    type='KernelUpdator',
+                    in_channels=256,
+                    feat_channels=256,
+                    out_channels=256,
+                    act_cfg=dict(type='ReLU', inplace=True),
+                    norm_cfg=dict(type='LN'))) for _ in range(num_stages)
+        ],
+        kernel_generate_head=dict(
+            type='FCNHead',
+            in_channels=2048,
+            in_index=3,
+            channels=512,
+            num_convs=2,
+            concat_input=True,
+            dropout_ratio=0.1,
+            num_classes=150,
+            norm_cfg=norm_cfg,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=150,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+# optimizer
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0005),
+    clip_grad=dict(max_norm=1, norm_type=2))
+
+# learning policy
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0,
+        end=1000),
+    dict(
+        type='MultiStepLR',
+        begin=1000,
+        end=80000,
+        milestones=[60000, 72000],
+        by_epoch=False,
+    )
+]
+# In K-Net implementation we use batch size 2 per GPU as default
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/knet/knet-s3_r50-d8_pspnet_8xb2-adamw-80k_ade20k-512x512.py b/mmsegmentation/configs/knet/knet-s3_r50-d8_pspnet_8xb2-adamw-80k_ade20k-512x512.py
new file mode 100644
index 0000000..b918671
--- /dev/null
+++ b/mmsegmentation/configs/knet/knet-s3_r50-d8_pspnet_8xb2-adamw-80k_ade20k-512x512.py
@@ -0,0 +1,110 @@
+_base_ = [
+    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    size=crop_size,
+    seg_pad_val=255)
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+num_stages = 3
+conv_kernel_size = 1
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='IterativeDecodeHead',
+        num_stages=num_stages,
+        kernel_update_head=[
+            dict(
+                type='KernelUpdateHead',
+                num_classes=150,
+                num_ffn_fcs=2,
+                num_heads=8,
+                num_mask_fcs=1,
+                feedforward_channels=2048,
+                in_channels=512,
+                out_channels=512,
+                dropout=0.0,
+                conv_kernel_size=conv_kernel_size,
+                ffn_act_cfg=dict(type='ReLU', inplace=True),
+                with_ffn=True,
+                feat_transform_cfg=dict(
+                    conv_cfg=dict(type='Conv2d'), act_cfg=None),
+                kernel_updator_cfg=dict(
+                    type='KernelUpdator',
+                    in_channels=256,
+                    feat_channels=256,
+                    out_channels=256,
+                    act_cfg=dict(type='ReLU', inplace=True),
+                    norm_cfg=dict(type='LN'))) for _ in range(num_stages)
+        ],
+        kernel_generate_head=dict(
+            type='PSPHead',
+            in_channels=2048,
+            in_index=3,
+            channels=512,
+            pool_scales=(1, 2, 3, 6),
+            dropout_ratio=0.1,
+            num_classes=150,
+            norm_cfg=norm_cfg,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=150,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+# optimizer
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0005),
+    clip_grad=dict(max_norm=1, norm_type=2))
+# learning policy
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0,
+        end=1000),
+    dict(
+        type='MultiStepLR',
+        begin=1000,
+        end=80000,
+        milestones=[60000, 72000],
+        by_epoch=False,
+    )
+]
+# In K-Net implementation we use batch size 2 per GPU as default
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/knet/knet-s3_r50-d8_upernet_8xb2-adamw-80k_ade20k-512x512.py b/mmsegmentation/configs/knet/knet-s3_r50-d8_upernet_8xb2-adamw-80k_ade20k-512x512.py
new file mode 100644
index 0000000..a0a66c5
--- /dev/null
+++ b/mmsegmentation/configs/knet/knet-s3_r50-d8_upernet_8xb2-adamw-80k_ade20k-512x512.py
@@ -0,0 +1,111 @@
+_base_ = [
+    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    size=crop_size,
+    seg_pad_val=255)
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+num_stages = 3
+conv_kernel_size = 1
+
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 1, 1),
+        strides=(1, 2, 2, 2),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='IterativeDecodeHead',
+        num_stages=num_stages,
+        kernel_update_head=[
+            dict(
+                type='KernelUpdateHead',
+                num_classes=150,
+                num_ffn_fcs=2,
+                num_heads=8,
+                num_mask_fcs=1,
+                feedforward_channels=2048,
+                in_channels=512,
+                out_channels=512,
+                dropout=0.0,
+                conv_kernel_size=conv_kernel_size,
+                ffn_act_cfg=dict(type='ReLU', inplace=True),
+                with_ffn=True,
+                feat_transform_cfg=dict(
+                    conv_cfg=dict(type='Conv2d'), act_cfg=None),
+                kernel_updator_cfg=dict(
+                    type='KernelUpdator',
+                    in_channels=256,
+                    feat_channels=256,
+                    out_channels=256,
+                    act_cfg=dict(type='ReLU', inplace=True),
+                    norm_cfg=dict(type='LN'))) for _ in range(num_stages)
+        ],
+        kernel_generate_head=dict(
+            type='UPerHead',
+            in_channels=[256, 512, 1024, 2048],
+            in_index=[0, 1, 2, 3],
+            pool_scales=(1, 2, 3, 6),
+            channels=512,
+            dropout_ratio=0.1,
+            num_classes=150,
+            norm_cfg=norm_cfg,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=150,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+# optimizer
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0005),
+    clip_grad=dict(max_norm=1, norm_type=2))
+# learning policy
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0,
+        end=1000),
+    dict(
+        type='MultiStepLR',
+        begin=1000,
+        end=80000,
+        milestones=[60000, 72000],
+        by_epoch=False,
+    )
+]
+# In K-Net implementation we use batch size 2 per GPU as default
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-512x512.py b/mmsegmentation/configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-512x512.py
new file mode 100644
index 0000000..c6f4eb6
--- /dev/null
+++ b/mmsegmentation/configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-512x512.py
@@ -0,0 +1,21 @@
+_base_ = 'knet-s3_swin-t_upernet_8xb2-adamw-80k_ade20k-512x512.py'
+
+checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_large_patch4_window7_224_22k_20220308-d5bdebaf.pth'  # noqa
+# model settings
+model = dict(
+    pretrained=checkpoint_file,
+    backbone=dict(
+        embed_dims=192,
+        depths=[2, 2, 18, 2],
+        num_heads=[6, 12, 24, 48],
+        window_size=7,
+        use_abs_pos_embed=False,
+        drop_path_rate=0.3,
+        patch_norm=True),
+    decode_head=dict(
+        kernel_generate_head=dict(in_channels=[192, 384, 768, 1536])),
+    auxiliary_head=dict(in_channels=768))
+# In K-Net implementation we use batch size 2 per GPU as default
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-640x640.py b/mmsegmentation/configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-640x640.py
new file mode 100644
index 0000000..84c3d8c
--- /dev/null
+++ b/mmsegmentation/configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-640x640.py
@@ -0,0 +1,57 @@
+_base_ = 'knet-s3_swin-t_upernet_8xb2-adamw-80k_ade20k-512x512.py'
+
+checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_large_patch4_window7_224_22k_20220308-d5bdebaf.pth'  # noqa
+# model settings
+crop_size = (640, 640)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    size=crop_size,
+    seg_pad_val=255)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained=checkpoint_file,
+    backbone=dict(
+        embed_dims=192,
+        depths=[2, 2, 18, 2],
+        num_heads=[6, 12, 24, 48],
+        window_size=7,
+        use_abs_pos_embed=False,
+        drop_path_rate=0.4,
+        patch_norm=True),
+    decode_head=dict(
+        kernel_generate_head=dict(in_channels=[192, 384, 768, 1536])),
+    auxiliary_head=dict(in_channels=768))
+
+crop_size = (640, 640)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(
+        type='RandomResize',
+        scale=(2048, 640),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 640), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
+val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader
+# In K-Net implementation we use batch size 2 per GPU as default
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/knet/knet-s3_swin-t_upernet_8xb2-adamw-80k_ade20k-512x512.py b/mmsegmentation/configs/knet/knet-s3_swin-t_upernet_8xb2-adamw-80k_ade20k-512x512.py
new file mode 100644
index 0000000..a7acec4
--- /dev/null
+++ b/mmsegmentation/configs/knet/knet-s3_swin-t_upernet_8xb2-adamw-80k_ade20k-512x512.py
@@ -0,0 +1,63 @@
+_base_ = 'knet-s3_r50-d8_upernet_8xb2-adamw-80k_ade20k-512x512.py'
+
+checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_tiny_patch4_window7_224_20220308-f41b89d3.pth'  # noqa
+
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+num_stages = 3
+conv_kernel_size = 1
+
+model = dict(
+    type='EncoderDecoder',
+    pretrained=checkpoint_file,
+    backbone=dict(
+        _delete_=True,
+        type='SwinTransformer',
+        embed_dims=96,
+        depths=[2, 2, 6, 2],
+        num_heads=[3, 6, 12, 24],
+        window_size=7,
+        mlp_ratio=4,
+        qkv_bias=True,
+        qk_scale=None,
+        drop_rate=0.,
+        attn_drop_rate=0.,
+        drop_path_rate=0.3,
+        use_abs_pos_embed=False,
+        patch_norm=True,
+        out_indices=(0, 1, 2, 3)),
+    decode_head=dict(
+        kernel_generate_head=dict(in_channels=[96, 192, 384, 768])),
+    auxiliary_head=dict(in_channels=384))
+
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    # modify learning rate following the official implementation of Swin Transformer # noqa
+    optimizer=dict(
+        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.0005),
+    paramwise_cfg=dict(
+        custom_keys={
+            'absolute_pos_embed': dict(decay_mult=0.),
+            'relative_position_bias_table': dict(decay_mult=0.),
+            'norm': dict(decay_mult=0.)
+        }),
+    clip_grad=dict(max_norm=1, norm_type=2))
+
+# learning policy
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0,
+        end=1000),
+    dict(
+        type='MultiStepLR',
+        begin=1000,
+        end=80000,
+        milestones=[60000, 72000],
+        by_epoch=False,
+    )
+]
+# In K-Net implementation we use batch size 2 per GPU as default
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/knet/metafile.yaml b/mmsegmentation/configs/knet/metafile.yaml
new file mode 100644
index 0000000..0f4ab79
--- /dev/null
+++ b/mmsegmentation/configs/knet/metafile.yaml
@@ -0,0 +1,188 @@
+Collections:
+- Name: KNet
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - ADE20K
+  Paper:
+    Title: 'K-Net: Towards Unified Image Segmentation'
+    URL: https://arxiv.org/abs/2106.14855
+  README: configs/knet/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: knet-s3_r50-d8_fcn_8xb2-adamw-80k_ade20k-512x512
+  In Collection: KNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 43.6
+      mIoU(ms+flip): 45.12
+  Config: configs/knet/knet-s3_r50-d8_fcn_8xb2-adamw-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - KNet
+    - FCN
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 7.01
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_fcn_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_fcn_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_043751-abcab920.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_fcn_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_fcn_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_043751.log.json
+  Paper:
+    Title: 'K-Net: Towards Unified Image Segmentation'
+    URL: https://arxiv.org/abs/2106.14855
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.23.0/mmseg/models/decode_heads/knet_head.py#L392
+  Framework: PyTorch
+- Name: knet-s3_r50-d8_pspnet_8xb2-adamw-80k_ade20k-512x512
+  In Collection: KNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 44.18
+      mIoU(ms+flip): 45.58
+  Config: configs/knet/knet-s3_r50-d8_pspnet_8xb2-adamw-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - KNet
+    - PSPNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 6.98
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_pspnet_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_pspnet_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_054634-d2c72240.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_pspnet_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_pspnet_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_054634.log.json
+  Paper:
+    Title: 'K-Net: Towards Unified Image Segmentation'
+    URL: https://arxiv.org/abs/2106.14855
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.23.0/mmseg/models/decode_heads/knet_head.py#L392
+  Framework: PyTorch
+- Name: knet-s3_r50-d8_deeplabv3_8xb2-adamw-80k_ade20k-512x512
+  In Collection: KNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 45.06
+      mIoU(ms+flip): 46.11
+  Config: configs/knet/knet-s3_r50-d8_deeplabv3_8xb2-adamw-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - KNet
+    - DeepLabV3
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 7.42
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_deeplabv3_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_deeplabv3_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_041642-00c8fbeb.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_deeplabv3_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_deeplabv3_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_041642.log.json
+  Paper:
+    Title: 'K-Net: Towards Unified Image Segmentation'
+    URL: https://arxiv.org/abs/2106.14855
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.23.0/mmseg/models/decode_heads/knet_head.py#L392
+  Framework: PyTorch
+- Name: knet-s3_r50-d8_upernet_8xb2-adamw-80k_ade20k-512x512
+  In Collection: KNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 43.45
+      mIoU(ms+flip): 44.07
+  Config: configs/knet/knet-s3_r50-d8_upernet_8xb2-adamw-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - KNet
+    - UperNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 7.34
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_r50-d8_8x2_512x512_adamw_80k_ade20k_20220304_125657-215753b0.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_r50-d8_8x2_512x512_adamw_80k_ade20k_20220304_125657.log.json
+  Paper:
+    Title: 'K-Net: Towards Unified Image Segmentation'
+    URL: https://arxiv.org/abs/2106.14855
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.23.0/mmseg/models/decode_heads/knet_head.py#L392
+  Framework: PyTorch
+- Name: knet-s3_swin-t_upernet_8xb2-adamw-80k_ade20k-512x512
+  In Collection: KNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 45.84
+      mIoU(ms+flip): 46.27
+  Config: configs/knet/knet-s3_swin-t_upernet_8xb2-adamw-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - Swin-T
+    - KNet
+    - UperNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 7.57
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-t_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_swin-t_8x2_512x512_adamw_80k_ade20k_20220303_133059-7545e1dc.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-t_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_swin-t_8x2_512x512_adamw_80k_ade20k_20220303_133059.log.json
+  Paper:
+    Title: 'K-Net: Towards Unified Image Segmentation'
+    URL: https://arxiv.org/abs/2106.14855
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.23.0/mmseg/models/decode_heads/knet_head.py#L392
+  Framework: PyTorch
+- Name: knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-512x512
+  In Collection: KNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 52.05
+      mIoU(ms+flip): 53.24
+  Config: configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - Swin-L
+    - KNet
+    - UperNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 13.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-l_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_swin-l_8x2_512x512_adamw_80k_ade20k_20220303_154559-d8da9a90.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-l_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_swin-l_8x2_512x512_adamw_80k_ade20k_20220303_154559.log.json
+  Paper:
+    Title: 'K-Net: Towards Unified Image Segmentation'
+    URL: https://arxiv.org/abs/2106.14855
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.23.0/mmseg/models/decode_heads/knet_head.py#L392
+  Framework: PyTorch
+- Name: knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-640x640
+  In Collection: KNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 52.21
+      mIoU(ms+flip): 53.34
+  Config: configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-640x640.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - Swin-L
+    - KNet
+    - UperNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 13.54
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-l_8x2_640x640_adamw_80k_ade20k/knet_s3_upernet_swin-l_8x2_640x640_adamw_80k_ade20k_20220301_220747-8787fc71.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-l_8x2_640x640_adamw_80k_ade20k/knet_s3_upernet_swin-l_8x2_640x640_adamw_80k_ade20k_20220301_220747.log.json
+  Paper:
+    Title: 'K-Net: Towards Unified Image Segmentation'
+    URL: https://arxiv.org/abs/2106.14855
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.23.0/mmseg/models/decode_heads/knet_head.py#L392
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/mae/README.md b/mmsegmentation/configs/mae/README.md
new file mode 100644
index 0000000..d14e383
--- /dev/null
+++ b/mmsegmentation/configs/mae/README.md
@@ -0,0 +1,82 @@
+# MAE
+
+> [Masked Autoencoders Are Scalable Vision Learners](https://arxiv.org/abs/2111.06377)
+
+## Introduction
+
+<!-- [BACKBONE] -->
+
+<a href="https://github.com/facebookresearch/mae">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.24.0/mmseg/models/backbones/mae.py#L46">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+This paper shows that masked autoencoders (MAE) are scalable self-supervised learners for computer vision. Our MAE approach is simple: we mask random patches of the input image and reconstruct the missing pixels. It is based on two core designs. First, we develop an asymmetric encoder-decoder architecture, with an encoder that operates only on the visible subset of patches (without mask tokens), along with a lightweight decoder that reconstructs the original image from the latent representation and mask tokens. Second, we find that masking a high proportion of the input image, e.g., 75%, yields a nontrivial and meaningful self-supervisory task. Coupling these two designs enables us to train large models efficiently and effectively: we accelerate training (by 3x or more) and improve accuracy. Our scalable approach allows for learning high-capacity models that generalize well: e.g., a vanilla ViT-Huge model achieves the best accuracy (87.8%) among methods that use only ImageNet-1K data. Transfer performance in downstream tasks outperforms supervised pre-training and shows promising scaling behavior.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/165456416-1cba54bf-b1b5-4bdf-ad86-d6390de7f342.png" width="70%"/>
+</div>
+
+## Usage
+
+To use other repositories' pre-trained models, it is necessary to convert keys.
+
+We provide a script [`beit2mmseg.py`](../../tools/model_converters/beit2mmseg.py) in the tools directory to convert the key of MAE model from [the official repo](https://github.com/facebookresearch/mae) to MMSegmentation style.
+
+```shell
+python tools/model_converters/beit2mmseg.py ${PRETRAIN_PATH} ${STORE_PATH}
+```
+
+E.g.
+
+```shell
+python tools/model_converters/beit2mmseg.py https://dl.fbaipublicfiles.com/mae/pretrain/mae_pretrain_vit_base.pth pretrain/mae_pretrain_vit_base_mmcls.pth
+```
+
+This script convert model from `PRETRAIN_PATH` and store the converted model in `STORE_PATH`.
+
+In our default setting, pretrained models could be defined below:
+
+| pretrained models               | original models                                                                                  |
+| ------------------------------- | ------------------------------------------------------------------------------------------------ |
+| mae_pretrain_vit_base_mmcls.pth | ['mae_pretrain_vit_base'](https://dl.fbaipublicfiles.com/mae/pretrain/mae_pretrain_vit_base.pth) |
+
+Verify the single-scale results of the model:
+
+```shell
+sh tools/dist_test.sh \
+configs/mae/upernet_mae-base_fp16_8x2_512x512_160k_ade20k.py \
+upernet_mae-base_fp16_8x2_512x512_160k_ade20k_20220426_174752-f92a2975.pth $GPUS --eval mIoU
+```
+
+Since relative position embedding requires the input length and width to be equal, the sliding window is adopted for multi-scale inference. So we set min_size=512, that is, the shortest edge is 512. So the multi-scale inference of config is performed separately, instead of '--aug-test'. For multi-scale inference:
+
+```shell
+sh tools/dist_test.sh \
+configs/mae/upernet_mae-base_fp16_512x512_160k_ade20k_ms.py \
+upernet_mae-base_fp16_8x2_512x512_160k_ade20k_20220426_174752-f92a2975.pth $GPUS --eval mIoU
+```
+
+## Results and models
+
+### ADE20K
+
+| Method  | Backbone | Crop Size | pretrain    | pretrain img size | Batch Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                        | download                                                                                                                                                                                                                                                                                                                                                                       |
+| ------- | -------- | --------- | ----------- | ----------------- | ---------- | ------- | -------- | -------------- | ------ | ----- | ------------: | ----------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UPerNet | ViT-B    | 512x512   | ImageNet-1K | 224x224           | 16         | 160000  | 9.96     | 7.14           | V100   | 48.13 |         48.70 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mae/upernet_mae-base_fp16_8x2_512x512_160k_ade20k/upernet_mae-base_fp16_8x2_512x512_160k_ade20k_20220426_174752-f92a2975.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mae/upernet_mae-base_fp16_8x2_512x512_160k_ade20k/upernet_mae-base_fp16_8x2_512x512_160k_ade20k_20220426_174752.log.json) |
+
+## Citation
+
+```bibtex
+@article{he2021masked,
+  title={Masked autoencoders are scalable vision learners},
+  author={He, Kaiming and Chen, Xinlei and Xie, Saining and Li, Yanghao and Doll{\'a}r, Piotr and Girshick, Ross},
+  journal={arXiv preprint arXiv:2111.06377},
+  year={2021}
+}
+```
diff --git a/mmsegmentation/configs/mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512-ms.py b/mmsegmentation/configs/mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512-ms.py
new file mode 100644
index 0000000..ec32fea
--- /dev/null
+++ b/mmsegmentation/configs/mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512-ms.py
@@ -0,0 +1,16 @@
+_base_ = './mae-base_upernet_8xb2-amp-160k_ade20k-512x512.py'
+
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    # TODO: Refactor 'MultiScaleFlipAug' which supports
+    # `min_size` feature in `Resize` class
+    # img_ratios is [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+    # original image scale is (2048, 512)
+    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='PackSegInputs')
+]
+val_dataloader = dict(batch_size=1, dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512.py b/mmsegmentation/configs/mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512.py
new file mode 100644
index 0000000..b8eae17
--- /dev/null
+++ b/mmsegmentation/configs/mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512.py
@@ -0,0 +1,54 @@
+_base_ = [
+    '../_base_/models/upernet_mae.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained='./pretrain/mae_pretrain_vit_base_mmcls.pth',
+    backbone=dict(
+        type='MAE',
+        img_size=(512, 512),
+        patch_size=16,
+        embed_dims=768,
+        num_layers=12,
+        num_heads=12,
+        mlp_ratio=4,
+        init_values=1.0,
+        drop_path_rate=0.1,
+        out_indices=[3, 5, 7, 11]),
+    neck=dict(embed_dim=768, rescales=[4, 2, 1, 0.5]),
+    decode_head=dict(
+        in_channels=[768, 768, 768, 768], num_classes=150, channels=768),
+    auxiliary_head=dict(in_channels=768, num_classes=150),
+    test_cfg=dict(mode='slide', crop_size=(512, 512), stride=(341, 341)))
+
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=1e-4, betas=(0.9, 0.999), weight_decay=0.05),
+    paramwise_cfg=dict(num_layers=12, layer_decay_rate=0.65),
+    constructor='LayerDecayOptimizerConstructor')
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        eta_min=0.0,
+        power=1.0,
+        begin=1500,
+        end=160000,
+        by_epoch=False,
+    )
+]
+
+# mixed precision
+fp16 = dict(loss_scale='dynamic')
+
+# By default, models are trained on 8 GPUs with 2 images per GPU
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/mae/metafile.yaml b/mmsegmentation/configs/mae/metafile.yaml
new file mode 100644
index 0000000..567eafe
--- /dev/null
+++ b/mmsegmentation/configs/mae/metafile.yaml
@@ -0,0 +1,25 @@
+Models:
+- Name: mae-base_upernet_8xb2-amp-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 48.13
+      mIoU(ms+flip): 48.7
+  Config: configs/mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - ViT-B
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 9.96
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mae/upernet_mae-base_fp16_8x2_512x512_160k_ade20k/upernet_mae-base_fp16_8x2_512x512_160k_ade20k_20220426_174752-f92a2975.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mae/upernet_mae-base_fp16_8x2_512x512_160k_ade20k/upernet_mae-base_fp16_8x2_512x512_160k_ade20k_20220426_174752.log.json
+  Paper:
+    Title: Masked Autoencoders Are Scalable Vision Learners
+    URL: https://arxiv.org/abs/2111.06377
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.24.0/mmseg/models/backbones/mae.py#L46
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/mask2former/README.md b/mmsegmentation/configs/mask2former/README.md
new file mode 100644
index 0000000..c21ab0d
--- /dev/null
+++ b/mmsegmentation/configs/mask2former/README.md
@@ -0,0 +1,74 @@
+# Mask2Former
+
+> [Masked-attention Mask Transformer for Universal Image Segmentation](https://arxiv.org/abs/2112.01527)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/facebookresearch/Mask2Former">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Image segmentation is about grouping pixels with different semantics, e.g., category or instance membership, where each choice of semantics defines a task. While only the semantics of each task differ, current research focuses on designing specialized architectures for each task. We present Masked-attention Mask Transformer (Mask2Former), a new architecture capable of addressing any image segmentation task (panoptic, instance or semantic). Its key components include masked attention, which extracts localized features by constraining cross-attention within predicted mask regions. In addition to reducing the research effort by at least three times, it outperforms the best specialized architectures by a significant margin on four popular datasets. Most notably, Mask2Former sets a new state-of-the-art for panoptic segmentation (57.8 PQ on COCO), instance segmentation (50.1 AP on COCO) and semantic segmentation (57.7 mIoU on ADE20K).
+
+### Usage
+
+- Mask2Former model needs to install [MMDetection](https://github.com/open-mmlab/mmdetection) first.
+
+```shell
+pip install "mmdet>=3.0.0rc4"
+```
+
+## Results and models
+
+### Cityscapes
+
+| Method      | Backbone       | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) |                                                                                                                                                    config | download                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| ----------- | -------------- | --------- | ------- | -------: | -------------- | ------ | ----- | ------------: | --------------------------------------------------------------------------------------------------------------------------------------------------------: | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Mask2Former | R-50-D32       | 512x1024  | 90000   |     5.67 | 9.17           | A100   | 80.44 |             - |                      [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_r50_8xb2-90k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r50_8xb2-90k_cityscapes-512x1024/mask2former_r50_8xb2-90k_cityscapes-512x1024_20221202_140802-ffd9d750.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r50_8xb2-90k_cityscapes-512x1024/mask2former_r50_8xb2-90k_cityscapes-512x1024_20221202_140802.json)                                                                                      |
+| Mask2Former | R-101-D32      | 512x1024  | 90000   |     6.81 | 7.11           | A100   | 80.80 |             - |                     [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_r101_8xb2-90k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r101_8xb2-90k_cityscapes-512x1024/mask2former_r101_8xb2-90k_cityscapes-512x1024_20221130_031628-43e68666.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r101_8xb2-90k_cityscapes-512x1024/mask2former_r101_8xb2-90k_cityscapes-512x1024_20221130_031628.json))                                                                                 |
+| Mask2Former | Swin-T         | 512x1024  | 90000   |     6.36 | 7.18           | A100   | 81.71 |             - |                   [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_swin-t_8xb2-90k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-t_8xb2-90k_cityscapes-512x1024/mask2former_swin-t_8xb2-90k_cityscapes-512x1024_20221127_144501-36c59341.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-t_8xb2-90k_cityscapes-512x1024/mask2former_swin-t_8xb2-90k_cityscapes-512x1024_20221127_144501.json))                                                                         |
+| Mask2Former | Swin-S         | 512x1024  | 90000   |     8.09 | 5.57           | A100   | 82.57 |             - |                   [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_swin-s_8xb2-90k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-s_8xb2-90k_cityscapes-512x1024/mask2former_swin-s_8xb2-90k_cityscapes-512x1024_20221127_143802-9ab177f6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-s_8xb2-90k_cityscapes-512x1024/mask2former_swin-s_8xb2-90k_cityscapes-512x1024_20221127_143802.json))                                                                         |
+| Mask2Former | Swin-B (in22k) | 512x1024  | 90000   |    10.89 | 4.32           | A100   | 83.52 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221203_045030-9a86a225.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221203_045030.json)) |
+| Mask2Former | Swin-L (in22k) | 512x1024  | 90000   |    15.83 | 2.86           | A100   | 83.65 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221202_141901-28ad20f1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221202_141901.json)) |
+
+### ADE20K
+
+| Method      | Backbone       | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) |                                                                                                                                                config | download                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| ----------- | -------------- | --------- | ------- | -------: | -------------- | ------ | ----- | ------------: | ----------------------------------------------------------------------------------------------------------------------------------------------------: | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Mask2Former | R-50-D32       | 512x512   | 160000  |     3.31 | 26.59          | A100   | 47.87 |             - |                      [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_r50_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r50_8xb2-160k_ade20k-512x512/mask2former_r50_8xb2-160k_ade20k-512x512_20221204_000055-2d1f55f1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r50_8xb2-160k_ade20k-512x512/mask2former_r50_8xb2-160k_ade20k-512x512_20221204_000055.json))                                                                                     |
+| Mask2Former | R-101-D32      | 512x512   | 160000  |     4.09 | 22.97          | A100   | 48.60 |             - |                     [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_r101_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r101_8xb2-160k_ade20k-512x512/mask2former_r101_8xb2-160k_ade20k-512x512_20221203_233905-b7135890.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r101_8xb2-160k_ade20k-512x512/mask2former_r101_8xb2-160k_ade20k-512x512_20221203_233905.json))                                                                                 |
+| Mask2Former | Swin-T         | 512x512   | 160000  |     3826 | 23.82          | A100   | 48.66 |             - |                   [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_swin-t_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-t_8xb2-160k_ade20k-512x512/mask2former_swin-t_8xb2-160k_ade20k-512x512_20221203_234230-7d64e5dd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-t_8xb2-160k_ade20k-512x512/mask2former_swin-t_8xb2-160k_ade20k-512x512_20221203_234230.json))                                                                         |
+| Mask2Former | Swin-S         | 512x512   | 160000  |     3.74 | 19.69          | A100   | 51.24 |             - |                   [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_swin-s_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-s_8xb2-160k_ade20k-512x512/mask2former_swin-s_8xb2-160k_ade20k-512x512_20221204_143905-e715144e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-s_8xb2-160k_ade20k-512x512/mask2former_swin-s_8xb2-160k_ade20k-512x512_20221204_143905.json))                                                                         |
+| Mask2Former | Swin-B         | 640x640   | 160000  |     5.66 | 12.48          | A100   | 52.44 |             - |  [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640_20221129_125118-a4a086d2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640_20221129_125118.json))     |
+| Mask2Former | Swin-B (in22k) | 640x640   | 160000  |     5.66 | 12.43          | A100   | 53.90 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640_20221203_235230-7ec0f569.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640_20221203_235230.json)) |
+| Mask2Former | Swin-L (in22k) | 640x640   | 160000  |     8.86 | 8.81           | A100   | 56.01 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640_20221203_235933-7120c214.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640_20221203_235933.json)) |
+
+Note:
+
+- All experiments of Mask2Former are implemented with 8 A100 GPUs with 2 samplers per GPU.
+- As mentioned at [the official repo](https://github.com/facebookresearch/Mask2Former/issues/5), the results of Mask2Former are relatively not stable, the result of Mask2Former(swin-s) on ADE20K dataset in the table is the medium result obtained by training 5 times following the suggestion of the author.
+- The ResNet backbones utilized in MaskFormer models are standard `ResNet` rather than `ResNetV1c`.
+- Test time augmentation is not supported in MMSegmentation 1.x version yet, we would add "ms+flip" results as soon as possible.
+
+## Citation
+
+```bibtex
+@inproceedings{cheng2021mask2former,
+  title={Masked-attention Mask Transformer for Universal Image Segmentation},
+  author={Bowen Cheng and Ishan Misra and Alexander G. Schwing and Alexander Kirillov and Rohit Girdhar},
+  journal={CVPR},
+  year={2022}
+}
+@inproceedings{cheng2021maskformer,
+  title={Per-Pixel Classification is Not All You Need for Semantic Segmentation},
+  author={Bowen Cheng and Alexander G. Schwing and Alexander Kirillov},
+  journal={NeurIPS},
+  year={2021}
+}
+```
diff --git a/mmsegmentation/configs/mask2former/mask2former_r101_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/mask2former/mask2former_r101_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..48f6c12
--- /dev/null
+++ b/mmsegmentation/configs/mask2former/mask2former_r101_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,7 @@
+_base_ = ['./mask2former_r50_8xb2-160k_ade20k-512x512.py']
+
+model = dict(
+    backbone=dict(
+        depth=101,
+        init_cfg=dict(type='Pretrained',
+                      checkpoint='torchvision://resnet101')))
diff --git a/mmsegmentation/configs/mask2former/mask2former_r101_8xb2-90k_cityscapes-512x1024.py b/mmsegmentation/configs/mask2former/mask2former_r101_8xb2-90k_cityscapes-512x1024.py
new file mode 100644
index 0000000..275a7da
--- /dev/null
+++ b/mmsegmentation/configs/mask2former/mask2former_r101_8xb2-90k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = ['./mask2former_r50_8xb2-90k_cityscapes-512x1024.py']
+
+model = dict(
+    backbone=dict(
+        depth=101,
+        init_cfg=dict(type='Pretrained',
+                      checkpoint='torchvision://resnet101')))
diff --git a/mmsegmentation/configs/mask2former/mask2former_r50_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/mask2former/mask2former_r50_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..78cf605
--- /dev/null
+++ b/mmsegmentation/configs/mask2former/mask2former_r50_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,200 @@
+_base_ = ['../_base_/default_runtime.py', '../_base_/datasets/ade20k.py']
+
+custom_imports = dict(imports='mmdet.models', allow_failed_imports=False)
+
+crop_size = (512, 512)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255,
+    size=crop_size,
+    test_cfg=dict(size_divisor=32))
+num_classes = 150
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='ResNet',
+        depth=50,
+        deep_stem=False,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=-1,
+        norm_cfg=dict(type='SyncBN', requires_grad=False),
+        style='pytorch',
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
+    decode_head=dict(
+        type='Mask2FormerHead',
+        in_channels=[256, 512, 1024, 2048],
+        strides=[4, 8, 16, 32],
+        feat_channels=256,
+        out_channels=256,
+        num_classes=num_classes,
+        num_queries=100,
+        num_transformer_feat_level=3,
+        align_corners=False,
+        pixel_decoder=dict(
+            type='mmdet.MSDeformAttnPixelDecoder',
+            num_outs=3,
+            norm_cfg=dict(type='GN', num_groups=32),
+            act_cfg=dict(type='ReLU'),
+            encoder=dict(  # DeformableDetrTransformerEncoder
+                num_layers=6,
+                layer_cfg=dict(  # DeformableDetrTransformerEncoderLayer
+                    self_attn_cfg=dict(  # MultiScaleDeformableAttention
+                        embed_dims=256,
+                        num_heads=8,
+                        num_levels=3,
+                        num_points=4,
+                        im2col_step=64,
+                        dropout=0.0,
+                        batch_first=True,
+                        norm_cfg=None,
+                        init_cfg=None),
+                    ffn_cfg=dict(
+                        embed_dims=256,
+                        feedforward_channels=1024,
+                        num_fcs=2,
+                        ffn_drop=0.0,
+                        act_cfg=dict(type='ReLU', inplace=True))),
+                init_cfg=None),
+            positional_encoding=dict(  # SinePositionalEncoding
+                num_feats=128, normalize=True),
+            init_cfg=None),
+        enforce_decoder_input_project=False,
+        positional_encoding=dict(  # SinePositionalEncoding
+            num_feats=128, normalize=True),
+        transformer_decoder=dict(  # Mask2FormerTransformerDecoder
+            return_intermediate=True,
+            num_layers=9,
+            layer_cfg=dict(  # Mask2FormerTransformerDecoderLayer
+                self_attn_cfg=dict(  # MultiheadAttention
+                    embed_dims=256,
+                    num_heads=8,
+                    attn_drop=0.0,
+                    proj_drop=0.0,
+                    dropout_layer=None,
+                    batch_first=True),
+                cross_attn_cfg=dict(  # MultiheadAttention
+                    embed_dims=256,
+                    num_heads=8,
+                    attn_drop=0.0,
+                    proj_drop=0.0,
+                    dropout_layer=None,
+                    batch_first=True),
+                ffn_cfg=dict(
+                    embed_dims=256,
+                    feedforward_channels=2048,
+                    num_fcs=2,
+                    act_cfg=dict(type='ReLU', inplace=True),
+                    ffn_drop=0.0,
+                    dropout_layer=None,
+                    add_identity=True)),
+            init_cfg=None),
+        loss_cls=dict(
+            type='mmdet.CrossEntropyLoss',
+            use_sigmoid=False,
+            loss_weight=2.0,
+            reduction='mean',
+            class_weight=[1.0] * num_classes + [0.1]),
+        loss_mask=dict(
+            type='mmdet.CrossEntropyLoss',
+            use_sigmoid=True,
+            reduction='mean',
+            loss_weight=5.0),
+        loss_dice=dict(
+            type='mmdet.DiceLoss',
+            use_sigmoid=True,
+            activate=True,
+            reduction='mean',
+            naive_dice=True,
+            eps=1.0,
+            loss_weight=5.0),
+        train_cfg=dict(
+            num_points=12544,
+            oversample_ratio=3.0,
+            importance_sample_ratio=0.75,
+            assigner=dict(
+                type='mmdet.HungarianAssigner',
+                match_costs=[
+                    dict(type='mmdet.ClassificationCost', weight=2.0),
+                    dict(
+                        type='mmdet.CrossEntropyLossCost',
+                        weight=5.0,
+                        use_sigmoid=True),
+                    dict(
+                        type='mmdet.DiceCost',
+                        weight=5.0,
+                        pred_act=True,
+                        eps=1.0)
+                ]),
+            sampler=dict(type='mmdet.MaskPseudoSampler'))),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+
+# dataset config
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(
+        type='RandomChoiceResize',
+        scales=[int(512 * x * 0.1) for x in range(5, 21)],
+        resize_type='ResizeShortestEdge',
+        max_size=2048),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(batch_size=2, dataset=dict(pipeline=train_pipeline))
+
+# optimizer
+embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
+optimizer = dict(
+    type='AdamW', lr=0.0001, weight_decay=0.05, eps=1e-8, betas=(0.9, 0.999))
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=optimizer,
+    clip_grad=dict(max_norm=0.01, norm_type=2),
+    paramwise_cfg=dict(
+        custom_keys={
+            'backbone': dict(lr_mult=0.1, decay_mult=1.0),
+            'query_embed': embed_multi,
+            'query_feat': embed_multi,
+            'level_embed': embed_multi,
+        },
+        norm_decay_mult=0.0))
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=0,
+        power=0.9,
+        begin=0,
+        end=160000,
+        by_epoch=False)
+]
+
+# training schedule for 160k
+train_cfg = dict(
+    type='IterBasedTrainLoop', max_iters=160000, val_interval=5000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(
+        type='CheckpointHook', by_epoch=False, interval=5000,
+        save_best='mIoU'),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))
+
+# Default setting for scaling LR automatically
+#   - `enable` means enable scaling LR automatically
+#       or not by default.
+#   - `base_batch_size` = (8 GPUs) x (2 samples per GPU).
+auto_scale_lr = dict(enable=False, base_batch_size=16)
diff --git a/mmsegmentation/configs/mask2former/mask2former_r50_8xb2-90k_cityscapes-512x1024.py b/mmsegmentation/configs/mask2former/mask2former_r50_8xb2-90k_cityscapes-512x1024.py
new file mode 100644
index 0000000..d2211b6
--- /dev/null
+++ b/mmsegmentation/configs/mask2former/mask2former_r50_8xb2-90k_cityscapes-512x1024.py
@@ -0,0 +1,197 @@
+_base_ = ['../_base_/default_runtime.py', '../_base_/datasets/cityscapes.py']
+
+crop_size = (512, 1024)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255,
+    size=crop_size,
+    test_cfg=dict(size_divisor=32))
+num_classes = 19
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='ResNet',
+        depth=50,
+        deep_stem=False,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=-1,
+        norm_cfg=dict(type='SyncBN', requires_grad=False),
+        style='pytorch',
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
+    decode_head=dict(
+        type='Mask2FormerHead',
+        in_channels=[256, 512, 1024, 2048],
+        strides=[4, 8, 16, 32],
+        feat_channels=256,
+        out_channels=256,
+        num_classes=num_classes,
+        num_queries=100,
+        num_transformer_feat_level=3,
+        align_corners=False,
+        pixel_decoder=dict(
+            type='mmdet.MSDeformAttnPixelDecoder',
+            num_outs=3,
+            norm_cfg=dict(type='GN', num_groups=32),
+            act_cfg=dict(type='ReLU'),
+            encoder=dict(  # DeformableDetrTransformerEncoder
+                num_layers=6,
+                layer_cfg=dict(  # DeformableDetrTransformerEncoderLayer
+                    self_attn_cfg=dict(  # MultiScaleDeformableAttention
+                        embed_dims=256,
+                        num_heads=8,
+                        num_levels=3,
+                        num_points=4,
+                        im2col_step=64,
+                        dropout=0.0,
+                        batch_first=True,
+                        norm_cfg=None,
+                        init_cfg=None),
+                    ffn_cfg=dict(
+                        embed_dims=256,
+                        feedforward_channels=1024,
+                        num_fcs=2,
+                        ffn_drop=0.0,
+                        act_cfg=dict(type='ReLU', inplace=True))),
+                init_cfg=None),
+            positional_encoding=dict(  # SinePositionalEncoding
+                num_feats=128, normalize=True),
+            init_cfg=None),
+        enforce_decoder_input_project=False,
+        positional_encoding=dict(  # SinePositionalEncoding
+            num_feats=128, normalize=True),
+        transformer_decoder=dict(  # Mask2FormerTransformerDecoder
+            return_intermediate=True,
+            num_layers=9,
+            layer_cfg=dict(  # Mask2FormerTransformerDecoderLayer
+                self_attn_cfg=dict(  # MultiheadAttention
+                    embed_dims=256,
+                    num_heads=8,
+                    attn_drop=0.0,
+                    proj_drop=0.0,
+                    dropout_layer=None,
+                    batch_first=True),
+                cross_attn_cfg=dict(  # MultiheadAttention
+                    embed_dims=256,
+                    num_heads=8,
+                    attn_drop=0.0,
+                    proj_drop=0.0,
+                    dropout_layer=None,
+                    batch_first=True),
+                ffn_cfg=dict(
+                    embed_dims=256,
+                    feedforward_channels=2048,
+                    num_fcs=2,
+                    act_cfg=dict(type='ReLU', inplace=True),
+                    ffn_drop=0.0,
+                    dropout_layer=None,
+                    add_identity=True)),
+            init_cfg=None),
+        loss_cls=dict(
+            type='mmdet.CrossEntropyLoss',
+            use_sigmoid=False,
+            loss_weight=2.0,
+            reduction='mean',
+            class_weight=[1.0] * num_classes + [0.1]),
+        loss_mask=dict(
+            type='mmdet.CrossEntropyLoss',
+            use_sigmoid=True,
+            reduction='mean',
+            loss_weight=5.0),
+        loss_dice=dict(
+            type='mmdet.DiceLoss',
+            use_sigmoid=True,
+            activate=True,
+            reduction='mean',
+            naive_dice=True,
+            eps=1.0,
+            loss_weight=5.0),
+        train_cfg=dict(
+            num_points=12544,
+            oversample_ratio=3.0,
+            importance_sample_ratio=0.75,
+            assigner=dict(
+                type='mmdet.HungarianAssigner',
+                match_costs=[
+                    dict(type='mmdet.ClassificationCost', weight=2.0),
+                    dict(
+                        type='mmdet.CrossEntropyLossCost',
+                        weight=5.0,
+                        use_sigmoid=True),
+                    dict(
+                        type='mmdet.DiceCost',
+                        weight=5.0,
+                        pred_act=True,
+                        eps=1.0)
+                ]),
+            sampler=dict(type='mmdet.MaskPseudoSampler'))),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+
+# dataset config
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomChoiceResize',
+        scales=[int(1024 * x * 0.1) for x in range(5, 21)],
+        resize_type='ResizeShortestEdge',
+        max_size=4096),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
+
+# optimizer
+embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
+optimizer = dict(
+    type='AdamW', lr=0.0001, weight_decay=0.05, eps=1e-8, betas=(0.9, 0.999))
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=optimizer,
+    clip_grad=dict(max_norm=0.01, norm_type=2),
+    paramwise_cfg=dict(
+        custom_keys={
+            'backbone': dict(lr_mult=0.1, decay_mult=1.0),
+            'query_embed': embed_multi,
+            'query_feat': embed_multi,
+            'level_embed': embed_multi,
+        },
+        norm_decay_mult=0.0))
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=0,
+        power=0.9,
+        begin=0,
+        end=90000,
+        by_epoch=False)
+]
+
+# training schedule for 90k
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=90000, val_interval=5000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(
+        type='CheckpointHook', by_epoch=False, interval=5000,
+        save_best='mIoU'),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))
+
+# Default setting for scaling LR automatically
+#   - `enable` means enable scaling LR automatically
+#       or not by default.
+#   - `base_batch_size` = (8 GPUs) x (2 samples per GPU).
+auto_scale_lr = dict(enable=False, base_batch_size=16)
diff --git a/mmsegmentation/configs/mask2former/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640.py b/mmsegmentation/configs/mask2former/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640.py
new file mode 100644
index 0000000..b8b1d6c
--- /dev/null
+++ b/mmsegmentation/configs/mask2former/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640.py
@@ -0,0 +1,229 @@
+_base_ = [
+    '../_base_/default_runtime.py', '../_base_/datasets/ade20k_640x640.py'
+]
+
+pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_base_patch4_window12_384_20220317-55b0104a.pth'  # noqa
+
+crop_size = (640, 640)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255,
+    size=crop_size)
+num_classes = 150
+
+depths = [2, 2, 18, 2]
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='SwinTransformer',
+        pretrain_img_size=384,
+        embed_dims=128,
+        depths=depths,
+        num_heads=[4, 8, 16, 32],
+        window_size=12,
+        mlp_ratio=4,
+        qkv_bias=True,
+        qk_scale=None,
+        drop_rate=0.,
+        attn_drop_rate=0.,
+        drop_path_rate=0.3,
+        patch_norm=True,
+        out_indices=(0, 1, 2, 3),
+        with_cp=False,
+        frozen_stages=-1,
+        init_cfg=dict(type='Pretrained', checkpoint=pretrained)),
+    decode_head=dict(
+        type='Mask2FormerHead',
+        in_channels=[128, 256, 512, 1024],
+        strides=[4, 8, 16, 32],
+        feat_channels=256,
+        out_channels=256,
+        num_classes=num_classes,
+        num_queries=100,
+        num_transformer_feat_level=3,
+        align_corners=False,
+        pixel_decoder=dict(
+            type='mmdet.MSDeformAttnPixelDecoder',
+            num_outs=3,
+            norm_cfg=dict(type='GN', num_groups=32),
+            act_cfg=dict(type='ReLU'),
+            encoder=dict(  # DeformableDetrTransformerEncoder
+                num_layers=6,
+                layer_cfg=dict(  # DeformableDetrTransformerEncoderLayer
+                    self_attn_cfg=dict(  # MultiScaleDeformableAttention
+                        embed_dims=256,
+                        num_heads=8,
+                        num_levels=3,
+                        num_points=4,
+                        im2col_step=64,
+                        dropout=0.0,
+                        batch_first=True,
+                        norm_cfg=None,
+                        init_cfg=None),
+                    ffn_cfg=dict(
+                        embed_dims=256,
+                        feedforward_channels=1024,
+                        num_fcs=2,
+                        ffn_drop=0.0,
+                        act_cfg=dict(type='ReLU', inplace=True))),
+                init_cfg=None),
+            positional_encoding=dict(  # SinePositionalEncoding
+                num_feats=128, normalize=True),
+            init_cfg=None),
+        enforce_decoder_input_project=False,
+        positional_encoding=dict(  # SinePositionalEncoding
+            num_feats=128, normalize=True),
+        transformer_decoder=dict(  # Mask2FormerTransformerDecoder
+            return_intermediate=True,
+            num_layers=9,
+            layer_cfg=dict(  # Mask2FormerTransformerDecoderLayer
+                self_attn_cfg=dict(  # MultiheadAttention
+                    embed_dims=256,
+                    num_heads=8,
+                    attn_drop=0.0,
+                    proj_drop=0.0,
+                    dropout_layer=None,
+                    batch_first=True),
+                cross_attn_cfg=dict(  # MultiheadAttention
+                    embed_dims=256,
+                    num_heads=8,
+                    attn_drop=0.0,
+                    proj_drop=0.0,
+                    dropout_layer=None,
+                    batch_first=True),
+                ffn_cfg=dict(
+                    embed_dims=256,
+                    feedforward_channels=2048,
+                    num_fcs=2,
+                    act_cfg=dict(type='ReLU', inplace=True),
+                    ffn_drop=0.0,
+                    dropout_layer=None,
+                    add_identity=True)),
+            init_cfg=None),
+        loss_cls=dict(
+            type='mmdet.CrossEntropyLoss',
+            use_sigmoid=False,
+            loss_weight=2.0,
+            reduction='mean',
+            class_weight=[1.0] * num_classes + [0.1]),
+        loss_mask=dict(
+            type='mmdet.CrossEntropyLoss',
+            use_sigmoid=True,
+            reduction='mean',
+            loss_weight=5.0),
+        loss_dice=dict(
+            type='mmdet.DiceLoss',
+            use_sigmoid=True,
+            activate=True,
+            reduction='mean',
+            naive_dice=True,
+            eps=1.0,
+            loss_weight=5.0),
+        train_cfg=dict(
+            num_points=12544,
+            oversample_ratio=3.0,
+            importance_sample_ratio=0.75,
+            assigner=dict(
+                type='mmdet.HungarianAssigner',
+                match_costs=[
+                    dict(type='mmdet.ClassificationCost', weight=2.0),
+                    dict(
+                        type='mmdet.CrossEntropyLossCost',
+                        weight=5.0,
+                        use_sigmoid=True),
+                    dict(
+                        type='mmdet.DiceCost',
+                        weight=5.0,
+                        pred_act=True,
+                        eps=1.0)
+                ]),
+            sampler=dict(type='mmdet.MaskPseudoSampler'))),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+
+# dataset config
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(
+        type='RandomChoiceResize',
+        scales=[int(x * 0.1 * 640) for x in range(5, 21)],
+        resize_type='ResizeShortestEdge',
+        max_size=2560),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(batch_size=2, dataset=dict(pipeline=train_pipeline))
+
+# set all layers in backbone to lr_mult=0.1
+# set all norm layers, position_embeding,
+# query_embeding, level_embeding to decay_multi=0.0
+backbone_norm_multi = dict(lr_mult=0.1, decay_mult=0.0)
+backbone_embed_multi = dict(lr_mult=0.1, decay_mult=0.0)
+embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
+custom_keys = {
+    'backbone': dict(lr_mult=0.1, decay_mult=1.0),
+    'backbone.patch_embed.norm': backbone_norm_multi,
+    'backbone.norm': backbone_norm_multi,
+    'absolute_pos_embed': backbone_embed_multi,
+    'relative_position_bias_table': backbone_embed_multi,
+    'query_embed': embed_multi,
+    'query_feat': embed_multi,
+    'level_embed': embed_multi
+}
+custom_keys.update({
+    f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi
+    for stage_id, num_blocks in enumerate(depths)
+    for block_id in range(num_blocks)
+})
+custom_keys.update({
+    f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi
+    for stage_id in range(len(depths) - 1)
+})
+# optimizer
+optimizer = dict(
+    type='AdamW', lr=0.0001, weight_decay=0.05, eps=1e-8, betas=(0.9, 0.999))
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=optimizer,
+    clip_grad=dict(max_norm=0.01, norm_type=2),
+    paramwise_cfg=dict(custom_keys=custom_keys, norm_decay_mult=0.0))
+
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=0,
+        power=0.9,
+        begin=0,
+        end=160000,
+        by_epoch=False)
+]
+
+# training schedule for 160k
+train_cfg = dict(
+    type='IterBasedTrainLoop', max_iters=160000, val_interval=5000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(
+        type='CheckpointHook', by_epoch=False, interval=5000,
+        save_best='mIoU'),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))
+
+# Default setting for scaling LR automatically
+#   - `enable` means enable scaling LR automatically
+#       or not by default.
+#   - `base_batch_size` = (8 GPUs) x (2 samples per GPU).
+auto_scale_lr = dict(enable=False, base_batch_size=16)
diff --git a/mmsegmentation/configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py b/mmsegmentation/configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py
new file mode 100644
index 0000000..f39a3c5
--- /dev/null
+++ b/mmsegmentation/configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py
@@ -0,0 +1,5 @@
+_base_ = ['./mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640.py']
+
+pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_base_patch4_window12_384_22k_20220317-e5c09f74.pth'  # noqa
+model = dict(
+    backbone=dict(init_cfg=dict(type='Pretrained', checkpoint=pretrained)))
diff --git a/mmsegmentation/configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py b/mmsegmentation/configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py
new file mode 100644
index 0000000..0c229c1
--- /dev/null
+++ b/mmsegmentation/configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py
@@ -0,0 +1,42 @@
+_base_ = ['./mask2former_swin-t_8xb2-90k_cityscapes-512x1024.py']
+pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_base_patch4_window12_384_22k_20220317-e5c09f74.pth'  # noqa
+
+depths = [2, 2, 18, 2]
+model = dict(
+    backbone=dict(
+        pretrain_img_size=384,
+        embed_dims=128,
+        depths=depths,
+        num_heads=[4, 8, 16, 32],
+        window_size=12,
+        init_cfg=dict(type='Pretrained', checkpoint=pretrained)),
+    decode_head=dict(in_channels=[128, 256, 512, 1024]))
+
+# set all layers in backbone to lr_mult=0.1
+# set all norm layers, position_embeding,
+# query_embeding, level_embeding to decay_multi=0.0
+backbone_norm_multi = dict(lr_mult=0.1, decay_mult=0.0)
+backbone_embed_multi = dict(lr_mult=0.1, decay_mult=0.0)
+embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
+custom_keys = {
+    'backbone': dict(lr_mult=0.1, decay_mult=1.0),
+    'backbone.patch_embed.norm': backbone_norm_multi,
+    'backbone.norm': backbone_norm_multi,
+    'absolute_pos_embed': backbone_embed_multi,
+    'relative_position_bias_table': backbone_embed_multi,
+    'query_embed': embed_multi,
+    'query_feat': embed_multi,
+    'level_embed': embed_multi
+}
+custom_keys.update({
+    f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi
+    for stage_id, num_blocks in enumerate(depths)
+    for block_id in range(num_blocks)
+})
+custom_keys.update({
+    f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi
+    for stage_id in range(len(depths) - 1)
+})
+# optimizer
+optim_wrapper = dict(
+    paramwise_cfg=dict(custom_keys=custom_keys, norm_decay_mult=0.0))
diff --git a/mmsegmentation/configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py b/mmsegmentation/configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py
new file mode 100644
index 0000000..f2657e8
--- /dev/null
+++ b/mmsegmentation/configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py
@@ -0,0 +1,9 @@
+_base_ = ['./mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640.py']
+pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_large_patch4_window12_384_22k_20220412-6580f57d.pth'  # noqa
+
+model = dict(
+    backbone=dict(
+        embed_dims=192,
+        num_heads=[6, 12, 24, 48],
+        init_cfg=dict(type='Pretrained', checkpoint=pretrained)),
+    decode_head=dict(num_queries=100, in_channels=[192, 384, 768, 1536]))
diff --git a/mmsegmentation/configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py b/mmsegmentation/configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py
new file mode 100644
index 0000000..01a7b99
--- /dev/null
+++ b/mmsegmentation/configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py
@@ -0,0 +1,42 @@
+_base_ = ['./mask2former_swin-t_8xb2-90k_cityscapes-512x1024.py']
+pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_large_patch4_window12_384_22k_20220412-6580f57d.pth'  # noqa
+
+depths = [2, 2, 18, 2]
+model = dict(
+    backbone=dict(
+        pretrain_img_size=384,
+        embed_dims=192,
+        depths=depths,
+        num_heads=[6, 12, 24, 48],
+        window_size=12,
+        init_cfg=dict(type='Pretrained', checkpoint=pretrained)),
+    decode_head=dict(in_channels=[192, 384, 768, 1536]))
+
+# set all layers in backbone to lr_mult=0.1
+# set all norm layers, position_embeding,
+# query_embeding, level_embeding to decay_multi=0.0
+backbone_norm_multi = dict(lr_mult=0.1, decay_mult=0.0)
+backbone_embed_multi = dict(lr_mult=0.1, decay_mult=0.0)
+embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
+custom_keys = {
+    'backbone': dict(lr_mult=0.1, decay_mult=1.0),
+    'backbone.patch_embed.norm': backbone_norm_multi,
+    'backbone.norm': backbone_norm_multi,
+    'absolute_pos_embed': backbone_embed_multi,
+    'relative_position_bias_table': backbone_embed_multi,
+    'query_embed': embed_multi,
+    'query_feat': embed_multi,
+    'level_embed': embed_multi
+}
+custom_keys.update({
+    f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi
+    for stage_id, num_blocks in enumerate(depths)
+    for block_id in range(num_blocks)
+})
+custom_keys.update({
+    f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi
+    for stage_id in range(len(depths) - 1)
+})
+# optimizer
+optim_wrapper = dict(
+    paramwise_cfg=dict(custom_keys=custom_keys, norm_decay_mult=0.0))
diff --git a/mmsegmentation/configs/mask2former/mask2former_swin-s_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/mask2former/mask2former_swin-s_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..a7796d5
--- /dev/null
+++ b/mmsegmentation/configs/mask2former/mask2former_swin-s_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,37 @@
+_base_ = ['./mask2former_swin-t_8xb2-160k_ade20k-512x512.py']
+pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_small_patch4_window7_224_20220317-7ba6d6dd.pth'  # noqa
+
+depths = [2, 2, 18, 2]
+model = dict(
+    backbone=dict(
+        depths=depths, init_cfg=dict(type='Pretrained',
+                                     checkpoint=pretrained)))
+
+# set all layers in backbone to lr_mult=0.1
+# set all norm layers, position_embeding,
+# query_embeding, level_embeding to decay_multi=0.0
+backbone_norm_multi = dict(lr_mult=0.1, decay_mult=0.0)
+backbone_embed_multi = dict(lr_mult=0.1, decay_mult=0.0)
+embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
+custom_keys = {
+    'backbone': dict(lr_mult=0.1, decay_mult=1.0),
+    'backbone.patch_embed.norm': backbone_norm_multi,
+    'backbone.norm': backbone_norm_multi,
+    'absolute_pos_embed': backbone_embed_multi,
+    'relative_position_bias_table': backbone_embed_multi,
+    'query_embed': embed_multi,
+    'query_feat': embed_multi,
+    'level_embed': embed_multi
+}
+custom_keys.update({
+    f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi
+    for stage_id, num_blocks in enumerate(depths)
+    for block_id in range(num_blocks)
+})
+custom_keys.update({
+    f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi
+    for stage_id in range(len(depths) - 1)
+})
+# optimizer
+optim_wrapper = dict(
+    paramwise_cfg=dict(custom_keys=custom_keys, norm_decay_mult=0.0))
diff --git a/mmsegmentation/configs/mask2former/mask2former_swin-s_8xb2-90k_cityscapes-512x1024.py b/mmsegmentation/configs/mask2former/mask2former_swin-s_8xb2-90k_cityscapes-512x1024.py
new file mode 100644
index 0000000..5f75544
--- /dev/null
+++ b/mmsegmentation/configs/mask2former/mask2former_swin-s_8xb2-90k_cityscapes-512x1024.py
@@ -0,0 +1,37 @@
+_base_ = ['./mask2former_swin-t_8xb2-90k_cityscapes-512x1024.py']
+pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_small_patch4_window7_224_20220317-7ba6d6dd.pth'  # noqa
+
+depths = [2, 2, 18, 2]
+model = dict(
+    backbone=dict(
+        depths=depths, init_cfg=dict(type='Pretrained',
+                                     checkpoint=pretrained)))
+
+# set all layers in backbone to lr_mult=0.1
+# set all norm layers, position_embeding,
+# query_embeding, level_embeding to decay_multi=0.0
+backbone_norm_multi = dict(lr_mult=0.1, decay_mult=0.0)
+backbone_embed_multi = dict(lr_mult=0.1, decay_mult=0.0)
+embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
+custom_keys = {
+    'backbone': dict(lr_mult=0.1, decay_mult=1.0),
+    'backbone.patch_embed.norm': backbone_norm_multi,
+    'backbone.norm': backbone_norm_multi,
+    'absolute_pos_embed': backbone_embed_multi,
+    'relative_position_bias_table': backbone_embed_multi,
+    'query_embed': embed_multi,
+    'query_feat': embed_multi,
+    'level_embed': embed_multi
+}
+custom_keys.update({
+    f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi
+    for stage_id, num_blocks in enumerate(depths)
+    for block_id in range(num_blocks)
+})
+custom_keys.update({
+    f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi
+    for stage_id in range(len(depths) - 1)
+})
+# optimizer
+optim_wrapper = dict(
+    paramwise_cfg=dict(custom_keys=custom_keys, norm_decay_mult=0.0))
diff --git a/mmsegmentation/configs/mask2former/mask2former_swin-t_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/mask2former/mask2former_swin-t_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..9de3d24
--- /dev/null
+++ b/mmsegmentation/configs/mask2former/mask2former_swin-t_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,52 @@
+_base_ = ['./mask2former_r50_8xb2-160k_ade20k-512x512.py']
+pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_tiny_patch4_window7_224_20220317-1cdeb081.pth'  # noqa
+depths = [2, 2, 6, 2]
+model = dict(
+    backbone=dict(
+        _delete_=True,
+        type='SwinTransformer',
+        embed_dims=96,
+        depths=depths,
+        num_heads=[3, 6, 12, 24],
+        window_size=7,
+        mlp_ratio=4,
+        qkv_bias=True,
+        qk_scale=None,
+        drop_rate=0.,
+        attn_drop_rate=0.,
+        drop_path_rate=0.3,
+        patch_norm=True,
+        out_indices=(0, 1, 2, 3),
+        with_cp=False,
+        frozen_stages=-1,
+        init_cfg=dict(type='Pretrained', checkpoint=pretrained)),
+    decode_head=dict(in_channels=[96, 192, 384, 768]))
+
+# set all layers in backbone to lr_mult=0.1
+# set all norm layers, position_embeding,
+# query_embeding, level_embeding to decay_multi=0.0
+backbone_norm_multi = dict(lr_mult=0.1, decay_mult=0.0)
+backbone_embed_multi = dict(lr_mult=0.1, decay_mult=0.0)
+embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
+custom_keys = {
+    'backbone': dict(lr_mult=0.1, decay_mult=1.0),
+    'backbone.patch_embed.norm': backbone_norm_multi,
+    'backbone.norm': backbone_norm_multi,
+    'absolute_pos_embed': backbone_embed_multi,
+    'relative_position_bias_table': backbone_embed_multi,
+    'query_embed': embed_multi,
+    'query_feat': embed_multi,
+    'level_embed': embed_multi
+}
+custom_keys.update({
+    f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi
+    for stage_id, num_blocks in enumerate(depths)
+    for block_id in range(num_blocks)
+})
+custom_keys.update({
+    f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi
+    for stage_id in range(len(depths) - 1)
+})
+# optimizer
+optim_wrapper = dict(
+    paramwise_cfg=dict(custom_keys=custom_keys, norm_decay_mult=0.0))
diff --git a/mmsegmentation/configs/mask2former/mask2former_swin-t_8xb2-90k_cityscapes-512x1024.py b/mmsegmentation/configs/mask2former/mask2former_swin-t_8xb2-90k_cityscapes-512x1024.py
new file mode 100644
index 0000000..0abda64
--- /dev/null
+++ b/mmsegmentation/configs/mask2former/mask2former_swin-t_8xb2-90k_cityscapes-512x1024.py
@@ -0,0 +1,52 @@
+_base_ = ['./mask2former_r50_8xb2-90k_cityscapes-512x1024.py']
+pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_tiny_patch4_window7_224_20220317-1cdeb081.pth'  # noqa
+depths = [2, 2, 6, 2]
+model = dict(
+    backbone=dict(
+        _delete_=True,
+        type='SwinTransformer',
+        embed_dims=96,
+        depths=depths,
+        num_heads=[3, 6, 12, 24],
+        window_size=7,
+        mlp_ratio=4,
+        qkv_bias=True,
+        qk_scale=None,
+        drop_rate=0.,
+        attn_drop_rate=0.,
+        drop_path_rate=0.3,
+        patch_norm=True,
+        out_indices=(0, 1, 2, 3),
+        with_cp=False,
+        frozen_stages=-1,
+        init_cfg=dict(type='Pretrained', checkpoint=pretrained)),
+    decode_head=dict(in_channels=[96, 192, 384, 768]))
+
+# set all layers in backbone to lr_mult=0.1
+# set all norm layers, position_embeding,
+# query_embeding, level_embeding to decay_multi=0.0
+backbone_norm_multi = dict(lr_mult=0.1, decay_mult=0.0)
+backbone_embed_multi = dict(lr_mult=0.1, decay_mult=0.0)
+embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
+custom_keys = {
+    'backbone': dict(lr_mult=0.1, decay_mult=1.0),
+    'backbone.patch_embed.norm': backbone_norm_multi,
+    'backbone.norm': backbone_norm_multi,
+    'absolute_pos_embed': backbone_embed_multi,
+    'relative_position_bias_table': backbone_embed_multi,
+    'query_embed': embed_multi,
+    'query_feat': embed_multi,
+    'level_embed': embed_multi
+}
+custom_keys.update({
+    f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi
+    for stage_id, num_blocks in enumerate(depths)
+    for block_id in range(num_blocks)
+})
+custom_keys.update({
+    f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi
+    for stage_id in range(len(depths) - 1)
+})
+# optimizer
+optim_wrapper = dict(
+    paramwise_cfg=dict(custom_keys=custom_keys, norm_decay_mult=0.0))
diff --git a/mmsegmentation/configs/mask2former/metafile.yaml b/mmsegmentation/configs/mask2former/metafile.yaml
new file mode 100644
index 0000000..090c95e
--- /dev/null
+++ b/mmsegmentation/configs/mask2former/metafile.yaml
@@ -0,0 +1,314 @@
+Collections:
+- Name: Mask2Former
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Usage
+    - Cityscapes
+    - ADE20K
+  Paper:
+    Title: Masked-attention Mask Transformer for Universal Image Segmentation
+    URL: https://arxiv.org/abs/2112.01527
+  README: configs/mask2former/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: mask2former_r50_8xb2-90k_cityscapes-512x1024
+  In Collection: Mask2Former
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 80.44
+  Config: configs/mask2former/mask2former_r50_8xb2-90k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 16
+    Architecture:
+    - R-50-D32
+    - Mask2Former
+    Training Resources: 8x A100 GPUS
+    Memory (GB): 5.67
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r50_8xb2-90k_cityscapes-512x1024/mask2former_r50_8xb2-90k_cityscapes-512x1024_20221202_140802-ffd9d750.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r50_8xb2-90k_cityscapes-512x1024/mask2former_r50_8xb2-90k_cityscapes-512x1024_20221202_140802.json
+  Paper:
+    Title: Masked-attention Mask Transformer for Universal Image Segmentation
+    URL: https://arxiv.org/abs/2112.01527
+  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
+  Framework: PyTorch
+- Name: mask2former_r101_8xb2-90k_cityscapes-512x1024
+  In Collection: Mask2Former
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 80.8
+  Config: configs/mask2former/mask2former_r101_8xb2-90k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 16
+    Architecture:
+    - R-101-D32
+    - Mask2Former
+    Training Resources: 8x A100 GPUS
+    Memory (GB): 6.81
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r101_8xb2-90k_cityscapes-512x1024/mask2former_r101_8xb2-90k_cityscapes-512x1024_20221130_031628-43e68666.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r101_8xb2-90k_cityscapes-512x1024/mask2former_r101_8xb2-90k_cityscapes-512x1024_20221130_031628.json
+  Paper:
+    Title: Masked-attention Mask Transformer for Universal Image Segmentation
+    URL: https://arxiv.org/abs/2112.01527
+  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
+  Framework: PyTorch
+- Name: mask2former_swin-t_8xb2-90k_cityscapes-512x1024
+  In Collection: Mask2Former
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 81.71
+  Config: configs/mask2former/mask2former_swin-t_8xb2-90k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 16
+    Architecture:
+    - Swin-T
+    - Mask2Former
+    Training Resources: 8x A100 GPUS
+    Memory (GB): 6.36
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-t_8xb2-90k_cityscapes-512x1024/mask2former_swin-t_8xb2-90k_cityscapes-512x1024_20221127_144501-36c59341.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-t_8xb2-90k_cityscapes-512x1024/mask2former_swin-t_8xb2-90k_cityscapes-512x1024_20221127_144501.json
+  Paper:
+    Title: Masked-attention Mask Transformer for Universal Image Segmentation
+    URL: https://arxiv.org/abs/2112.01527
+  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
+  Framework: PyTorch
+- Name: mask2former_swin-s_8xb2-90k_cityscapes-512x1024
+  In Collection: Mask2Former
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 82.57
+  Config: configs/mask2former/mask2former_swin-s_8xb2-90k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 16
+    Architecture:
+    - Swin-S
+    - Mask2Former
+    Training Resources: 8x A100 GPUS
+    Memory (GB): 8.09
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-s_8xb2-90k_cityscapes-512x1024/mask2former_swin-s_8xb2-90k_cityscapes-512x1024_20221127_143802-9ab177f6.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-s_8xb2-90k_cityscapes-512x1024/mask2former_swin-s_8xb2-90k_cityscapes-512x1024_20221127_143802.json
+  Paper:
+    Title: Masked-attention Mask Transformer for Universal Image Segmentation
+    URL: https://arxiv.org/abs/2112.01527
+  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
+  Framework: PyTorch
+- Name: mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024
+  In Collection: Mask2Former
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 83.52
+  Config: configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 16
+    Architecture:
+    - Swin-B
+    - Mask2Former
+    Training Resources: 8x A100 GPUS
+    Memory (GB): 10.89
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221203_045030-9a86a225.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221203_045030.json
+  Paper:
+    Title: Masked-attention Mask Transformer for Universal Image Segmentation
+    URL: https://arxiv.org/abs/2112.01527
+  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
+  Framework: PyTorch
+- Name: mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024
+  In Collection: Mask2Former
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 83.65
+  Config: configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 16
+    Architecture:
+    - Swin-L
+    - Mask2Former
+    Training Resources: 8x A100 GPUS
+    Memory (GB): 15.83
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221202_141901-28ad20f1.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221202_141901.json
+  Paper:
+    Title: Masked-attention Mask Transformer for Universal Image Segmentation
+    URL: https://arxiv.org/abs/2112.01527
+  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
+  Framework: PyTorch
+- Name: mask2former_r50_8xb2-160k_ade20k-512x512
+  In Collection: Mask2Former
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 47.87
+  Config: configs/mask2former/mask2former_r50_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D32
+    - Mask2Former
+    Training Resources: 8x A100 GPUS
+    Memory (GB): 3.31
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r50_8xb2-160k_ade20k-512x512/mask2former_r50_8xb2-160k_ade20k-512x512_20221204_000055-2d1f55f1.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r50_8xb2-160k_ade20k-512x512/mask2former_r50_8xb2-160k_ade20k-512x512_20221204_000055.json
+  Paper:
+    Title: Masked-attention Mask Transformer for Universal Image Segmentation
+    URL: https://arxiv.org/abs/2112.01527
+  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
+  Framework: PyTorch
+- Name: mask2former_r101_8xb2-160k_ade20k-512x512
+  In Collection: Mask2Former
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 48.6
+  Config: configs/mask2former/mask2former_r101_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D32
+    - Mask2Former
+    Training Resources: 8x A100 GPUS
+    Memory (GB): 4.09
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r101_8xb2-160k_ade20k-512x512/mask2former_r101_8xb2-160k_ade20k-512x512_20221203_233905-b7135890.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r101_8xb2-160k_ade20k-512x512/mask2former_r101_8xb2-160k_ade20k-512x512_20221203_233905.json
+  Paper:
+    Title: Masked-attention Mask Transformer for Universal Image Segmentation
+    URL: https://arxiv.org/abs/2112.01527
+  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
+  Framework: PyTorch
+- Name: mask2former_swin-t_8xb2-160k_ade20k-512x512
+  In Collection: Mask2Former
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 48.66
+  Config: configs/mask2former/mask2former_swin-t_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - Swin-T
+    - Mask2Former
+    Training Resources: 8x A100 GPUS
+    Memory (GB): 3826.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-t_8xb2-160k_ade20k-512x512/mask2former_swin-t_8xb2-160k_ade20k-512x512_20221203_234230-7d64e5dd.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-t_8xb2-160k_ade20k-512x512/mask2former_swin-t_8xb2-160k_ade20k-512x512_20221203_234230.json
+  Paper:
+    Title: Masked-attention Mask Transformer for Universal Image Segmentation
+    URL: https://arxiv.org/abs/2112.01527
+  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
+  Framework: PyTorch
+- Name: mask2former_swin-s_8xb2-160k_ade20k-512x512
+  In Collection: Mask2Former
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 51.24
+  Config: configs/mask2former/mask2former_swin-s_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - Swin-S
+    - Mask2Former
+    Training Resources: 8x A100 GPUS
+    Memory (GB): 3.74
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-s_8xb2-160k_ade20k-512x512/mask2former_swin-s_8xb2-160k_ade20k-512x512_20221204_143905-e715144e.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-s_8xb2-160k_ade20k-512x512/mask2former_swin-s_8xb2-160k_ade20k-512x512_20221204_143905.json
+  Paper:
+    Title: Masked-attention Mask Transformer for Universal Image Segmentation
+    URL: https://arxiv.org/abs/2112.01527
+  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
+  Framework: PyTorch
+- Name: mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640
+  In Collection: Mask2Former
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 52.44
+  Config: configs/mask2former/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - Swin-B
+    - Mask2Former
+    Training Resources: 8x A100 GPUS
+    Memory (GB): 5.66
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640_20221129_125118-a4a086d2.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640_20221129_125118.json
+  Paper:
+    Title: Masked-attention Mask Transformer for Universal Image Segmentation
+    URL: https://arxiv.org/abs/2112.01527
+  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
+  Framework: PyTorch
+- Name: mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640
+  In Collection: Mask2Former
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 53.9
+  Config: configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - Swin-B
+    - Mask2Former
+    Training Resources: 8x A100 GPUS
+    Memory (GB): 5.66
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640_20221203_235230-7ec0f569.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640_20221203_235230.json
+  Paper:
+    Title: Masked-attention Mask Transformer for Universal Image Segmentation
+    URL: https://arxiv.org/abs/2112.01527
+  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
+  Framework: PyTorch
+- Name: mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640
+  In Collection: Mask2Former
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 56.01
+  Config: configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - Swin-L
+    - Mask2Former
+    Training Resources: 8x A100 GPUS
+    Memory (GB): 8.86
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640_20221203_235933-7120c214.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640_20221203_235933.json
+  Paper:
+    Title: Masked-attention Mask Transformer for Universal Image Segmentation
+    URL: https://arxiv.org/abs/2112.01527
+  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/maskformer/README.md b/mmsegmentation/configs/maskformer/README.md
new file mode 100644
index 0000000..a899bac
--- /dev/null
+++ b/mmsegmentation/configs/maskformer/README.md
@@ -0,0 +1,62 @@
+# MaskFormer
+
+> [MaskFormer: Per-Pixel Classification is Not All You Need for Semantic Segmentation](https://arxiv.org/abs/2107.06278)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/facebookresearch/MaskFormer/">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmdetection/blob/dev-3.x/mmdet/models/dense_heads/maskformer_head.py#L21">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Modern approaches typically formulate semantic segmentation as a per-pixel classification task, while instance-level segmentation is handled with an alternative mask classification. Our key insight: mask classification is sufficiently general to solve both semantic- and instance-level segmentation tasks in a unified manner using the exact same model, loss, and training procedure. Following this observation, we propose MaskFormer, a simple mask classification model which predicts a set of binary masks, each associated with a single global class label prediction. Overall, the proposed mask classification-based method simplifies the landscape of effective approaches to semantic and panoptic segmentation tasks and shows excellent empirical results. In particular, we observe that MaskFormer outperforms per-pixel classification baselines when the number of classes is large. Our mask classification-based method outperforms both current state-of-the-art semantic (55.6 mIoU on ADE20K) and panoptic segmentation (52.7 PQ on COCO) models.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/199215459-ea507126-aafe-4823-8eb1-ae6487509d5c.png" width="90%"/>
+</div>
+
+### Usage
+
+- MaskFormer model needs to install [MMDetection](https://github.com/open-mmlab/mmdetection) first.
+
+```shell
+pip install "mmdet>=3.0.0rc4"
+```
+
+## Results and models
+
+### ADE20K
+
+| Method     | Backbone  | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                                    | download                                                                                                                                                                                                                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | ------- | -------- | -------------- | ------ | ----- | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| MaskFormer | R-50-D32  | 512x512   | 160000  | 3.29     | A100           | 42.20  | 44.29 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512/maskformer_r50-d32_8xb2-160k_ade20k-512x512_20221030_182724-3a9cfe45.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512/maskformer_r50-d32_8xb2-160k_ade20k-512x512_20221030_182724.json)                             |
+| MaskFormer | R-101-D32 | 512x512   | 160000  | 4.12     | A100           | 34.90  | 45.11 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/maskformer/maskformer_r101-d32_8xb2-160k_ade20k-512x512.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_r101-d32_8xb2-160k_ade20k-512x512/maskformer_r101-d32_8xb2-160k_ade20k-512x512_20221031_223053-84adbfcb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_r101-d32_8xb2-160k_ade20k-512x512/maskformer_r101-d32_8xb2-160k_ade20k-512x512_20221031_223053.json)                         |
+| MaskFormer | Swin-T    | 512x512   | 160000  | 3.73     | A100           | 40.53  | 46.69 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/maskformer/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512_20221114_232813-f14e7ce0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512_20221114_232813.json) |
+| MaskFormer | Swin-S    | 512x512   | 160000  | 5.33     | A100           | 26.98  | 49.36 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512_20221115_114710-723512c7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512_20221115_114710.json) |
+
+Note:
+
+- All experiments of MaskFormer are implemented with 8 V100 (32G) GPUs with 2 samplers per GPU.
+- The results of MaskFormer are relatively not stable.  The accuracy (mIoU) of model with `R-101-D32` is from 44.7 to 46.0, and with `Swin-S` is from 49.0 to 49.8.
+- The ResNet backbones utilized in MaskFormer models are standard `ResNet` rather than `ResNetV1c`.
+- Test time augmentation is not supported in MMSegmentation 1.x version yet, we would add "ms+flip" results as soon as possible.
+
+## Citation
+
+```bibtex
+@article{cheng2021per,
+  title={Per-pixel classification is not all you need for semantic segmentation},
+  author={Cheng, Bowen and Schwing, Alex and Kirillov, Alexander},
+  journal={Advances in Neural Information Processing Systems},
+  volume={34},
+  pages={17864--17875},
+  year={2021}
+}
+```
diff --git a/mmsegmentation/configs/maskformer/maskformer_r101-d32_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/maskformer/maskformer_r101-d32_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..04bd375
--- /dev/null
+++ b/mmsegmentation/configs/maskformer/maskformer_r101-d32_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,7 @@
+_base_ = './maskformer_r50-d32_8xb2-160k_ade20k-512x512.py'
+
+model = dict(
+    backbone=dict(
+        depth=101,
+        init_cfg=dict(type='Pretrained',
+                      checkpoint='torchvision://resnet101')))
diff --git a/mmsegmentation/configs/maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..2a83746
--- /dev/null
+++ b/mmsegmentation/configs/maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,141 @@
+_base_ = [
+    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_160k.py'
+]
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+crop_size = (512, 512)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    size=crop_size,
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+# model_cfg
+num_classes = 150
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 1, 1),
+        strides=(1, 2, 2, 2),
+        norm_cfg=norm_cfg,
+        norm_eval=True,
+        style='pytorch',
+        contract_dilation=True,
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
+    decode_head=dict(
+        type='MaskFormerHead',
+        in_channels=[256, 512, 1024,
+                     2048],  # input channels of pixel_decoder modules
+        feat_channels=256,
+        in_index=[0, 1, 2, 3],
+        num_classes=150,
+        out_channels=256,
+        num_queries=100,
+        pixel_decoder=dict(
+            type='mmdet.PixelDecoder',
+            norm_cfg=dict(type='GN', num_groups=32),
+            act_cfg=dict(type='ReLU')),
+        enforce_decoder_input_project=False,
+        positional_encoding=dict(  # SinePositionalEncoding
+            num_feats=128, normalize=True),
+        transformer_decoder=dict(  # DetrTransformerDecoder
+            return_intermediate=True,
+            num_layers=6,
+            layer_cfg=dict(  # DetrTransformerDecoderLayer
+                self_attn_cfg=dict(  # MultiheadAttention
+                    embed_dims=256,
+                    num_heads=8,
+                    attn_drop=0.1,
+                    proj_drop=0.1,
+                    dropout_layer=None,
+                    batch_first=True),
+                cross_attn_cfg=dict(  # MultiheadAttention
+                    embed_dims=256,
+                    num_heads=8,
+                    attn_drop=0.1,
+                    proj_drop=0.1,
+                    dropout_layer=None,
+                    batch_first=True),
+                ffn_cfg=dict(
+                    embed_dims=256,
+                    feedforward_channels=2048,
+                    num_fcs=2,
+                    act_cfg=dict(type='ReLU', inplace=True),
+                    ffn_drop=0.1,
+                    dropout_layer=None,
+                    add_identity=True)),
+            init_cfg=None),
+        loss_cls=dict(
+            type='mmdet.CrossEntropyLoss',
+            use_sigmoid=False,
+            loss_weight=1.0,
+            reduction='mean',
+            class_weight=[1.0] * num_classes + [0.1]),
+        loss_mask=dict(
+            type='mmdet.FocalLoss',
+            use_sigmoid=True,
+            gamma=2.0,
+            alpha=0.25,
+            reduction='mean',
+            loss_weight=20.0),
+        loss_dice=dict(
+            type='mmdet.DiceLoss',
+            use_sigmoid=True,
+            activate=True,
+            reduction='mean',
+            naive_dice=True,
+            eps=1.0,
+            loss_weight=1.0),
+        train_cfg=dict(
+            assigner=dict(
+                type='mmdet.HungarianAssigner',
+                match_costs=[
+                    dict(type='mmdet.ClassificationCost', weight=1.0),
+                    dict(
+                        type='mmdet.FocalLossCost',
+                        weight=20.0,
+                        binary_input=True),
+                    dict(
+                        type='mmdet.DiceCost',
+                        weight=1.0,
+                        pred_act=True,
+                        eps=1.0)
+                ]),
+            sampler=dict(type='mmdet.MaskPseudoSampler'))),
+    # training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'),
+)
+# optimizer
+optimizer = dict(
+    type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.0001)
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=optimizer,
+    clip_grad=dict(max_norm=0.01, norm_type=2),
+    paramwise_cfg=dict(custom_keys={
+        'backbone': dict(lr_mult=0.1),
+    }))
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=0,
+        power=0.9,
+        begin=0,
+        end=160000,
+        by_epoch=False)
+]
+
+# In MaskFormer implementation we use batch size 2 per GPU as default
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..2cbc038
--- /dev/null
+++ b/mmsegmentation/configs/maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,79 @@
+checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_small_patch4_window7_224_20220317-7ba6d6dd.pth'  # noqa
+_base_ = './maskformer_r50-d32_8xb2-160k_ade20k-512x512.py'
+backbone_norm_cfg = dict(type='LN', requires_grad=True)
+depths = [2, 2, 18, 2]
+model = dict(
+    backbone=dict(
+        _delete_=True,
+        type='SwinTransformer',
+        pretrain_img_size=224,
+        embed_dims=96,
+        patch_size=4,
+        window_size=7,
+        mlp_ratio=4,
+        depths=depths,
+        num_heads=[3, 6, 12, 24],
+        strides=(4, 2, 2, 2),
+        out_indices=(0, 1, 2, 3),
+        qkv_bias=True,
+        qk_scale=None,
+        patch_norm=True,
+        drop_rate=0.,
+        attn_drop_rate=0.,
+        drop_path_rate=0.3,
+        use_abs_pos_embed=False,
+        act_cfg=dict(type='GELU'),
+        norm_cfg=backbone_norm_cfg,
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file)),
+    decode_head=dict(
+        type='MaskFormerHead',
+        in_channels=[96, 192, 384,
+                     768],  # input channels of pixel_decoder modules
+    ))
+
+# optimizer
+optimizer = dict(
+    type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01)
+# set all layers in backbone to lr_mult=1.0
+# set all norm layers, position_embeding,
+# query_embeding to decay_multi=0.0
+backbone_norm_multi = dict(lr_mult=1.0, decay_mult=0.0)
+backbone_embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
+embed_multi = dict(decay_mult=0.0)
+custom_keys = {
+    'backbone': dict(lr_mult=1.0),
+    'backbone.patch_embed.norm': backbone_norm_multi,
+    'backbone.norm': backbone_norm_multi,
+    'relative_position_bias_table': backbone_embed_multi,
+    'query_embed': embed_multi,
+}
+custom_keys.update({
+    f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi
+    for stage_id, num_blocks in enumerate(depths)
+    for block_id in range(num_blocks)
+})
+custom_keys.update({
+    f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi
+    for stage_id in range(len(depths) - 1)
+})
+# optimizer
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=optimizer,
+    clip_grad=dict(max_norm=0.01, norm_type=2),
+    paramwise_cfg=dict(custom_keys=custom_keys))
+
+# learning policy
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        eta_min=0.0,
+        power=1.0,
+        begin=1500,
+        end=160000,
+        by_epoch=False,
+    )
+]
diff --git a/mmsegmentation/configs/maskformer/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/maskformer/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..aa242db
--- /dev/null
+++ b/mmsegmentation/configs/maskformer/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,81 @@
+_base_ = './maskformer_r50-d32_8xb2-160k_ade20k-512x512.py'
+
+checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_tiny_patch4_window7_224_20220317-1cdeb081.pth'  # noqa
+backbone_norm_cfg = dict(type='LN', requires_grad=True)
+depths = [2, 2, 6, 2]
+model = dict(
+    backbone=dict(
+        _delete_=True,
+        type='SwinTransformer',
+        pretrain_img_size=224,
+        embed_dims=96,
+        patch_size=4,
+        window_size=7,
+        mlp_ratio=4,
+        depths=depths,
+        num_heads=[3, 6, 12, 24],
+        strides=(4, 2, 2, 2),
+        out_indices=(0, 1, 2, 3),
+        qkv_bias=True,
+        qk_scale=None,
+        patch_norm=True,
+        drop_rate=0.,
+        attn_drop_rate=0.,
+        drop_path_rate=0.3,
+        use_abs_pos_embed=False,
+        act_cfg=dict(type='GELU'),
+        norm_cfg=backbone_norm_cfg,
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file)),
+    decode_head=dict(
+        type='MaskFormerHead',
+        in_channels=[96, 192, 384,
+                     768],  # input channels of pixel_decoder modules
+    ))
+
+# optimizer
+optimizer = dict(
+    type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01)
+
+# set all layers in backbone to lr_mult=1.0
+# set all norm layers, position_embeding,
+# query_embeding to decay_multi=0.0
+backbone_norm_multi = dict(lr_mult=1.0, decay_mult=0.0)
+backbone_embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
+embed_multi = dict(decay_mult=0.0)
+custom_keys = {
+    'backbone': dict(lr_mult=1.0),
+    'backbone.patch_embed.norm': backbone_norm_multi,
+    'backbone.norm': backbone_norm_multi,
+    'relative_position_bias_table': backbone_embed_multi,
+    'query_embed': embed_multi,
+}
+custom_keys.update({
+    f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi
+    for stage_id, num_blocks in enumerate(depths)
+    for block_id in range(num_blocks)
+})
+custom_keys.update({
+    f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi
+    for stage_id in range(len(depths) - 1)
+})
+# optimizer
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=optimizer,
+    clip_grad=dict(max_norm=0.01, norm_type=2),
+    paramwise_cfg=dict(custom_keys=custom_keys))
+
+# learning policy
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        eta_min=0.0,
+        power=1.0,
+        begin=1500,
+        end=160000,
+        by_epoch=False,
+    )
+]
diff --git a/mmsegmentation/configs/maskformer/metafile.yaml b/mmsegmentation/configs/maskformer/metafile.yaml
new file mode 100644
index 0000000..c9853e1
--- /dev/null
+++ b/mmsegmentation/configs/maskformer/metafile.yaml
@@ -0,0 +1,111 @@
+Collections:
+- Name: MaskFormer
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Usage
+    - ADE20K
+  Paper:
+    Title: 'MaskFormer: Per-Pixel Classification is Not All You Need for Semantic
+      Segmentation'
+    URL: https://arxiv.org/abs/2107.06278
+  README: configs/maskformer/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: maskformer_r50-d32_8xb2-160k_ade20k-512x512
+  In Collection: MaskFormer
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 44.29
+  Config: configs/maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D32
+    - MaskFormer
+    Training Resources: 8x 42.20 GPUS
+    Memory (GB): 3.29
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512/maskformer_r50-d32_8xb2-160k_ade20k-512x512_20221030_182724-3a9cfe45.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512/maskformer_r50-d32_8xb2-160k_ade20k-512x512_20221030_182724.json
+  Paper:
+    Title: 'MaskFormer: Per-Pixel Classification is Not All You Need for Semantic
+      Segmentation'
+    URL: https://arxiv.org/abs/2107.06278
+  Code: https://github.com/open-mmlab/mmdetection/blob/dev-3.x/mmdet/models/dense_heads/maskformer_head.py#L21
+  Framework: PyTorch
+- Name: maskformer_r101-d32_8xb2-160k_ade20k-512x512
+  In Collection: MaskFormer
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 45.11
+  Config: configs/maskformer/maskformer_r101-d32_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D32
+    - MaskFormer
+    Training Resources: 8x 34.90 GPUS
+    Memory (GB): 4.12
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_r101-d32_8xb2-160k_ade20k-512x512/maskformer_r101-d32_8xb2-160k_ade20k-512x512_20221031_223053-84adbfcb.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_r101-d32_8xb2-160k_ade20k-512x512/maskformer_r101-d32_8xb2-160k_ade20k-512x512_20221031_223053.json
+  Paper:
+    Title: 'MaskFormer: Per-Pixel Classification is Not All You Need for Semantic
+      Segmentation'
+    URL: https://arxiv.org/abs/2107.06278
+  Code: https://github.com/open-mmlab/mmdetection/blob/dev-3.x/mmdet/models/dense_heads/maskformer_head.py#L21
+  Framework: PyTorch
+- Name: maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512
+  In Collection: MaskFormer
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 46.69
+  Config: configs/maskformer/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - Swin-T
+    - MaskFormer
+    Training Resources: 8x 40.53 GPUS
+    Memory (GB): 3.73
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512_20221114_232813-f14e7ce0.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512_20221114_232813.json
+  Paper:
+    Title: 'MaskFormer: Per-Pixel Classification is Not All You Need for Semantic
+      Segmentation'
+    URL: https://arxiv.org/abs/2107.06278
+  Code: https://github.com/open-mmlab/mmdetection/blob/dev-3.x/mmdet/models/dense_heads/maskformer_head.py#L21
+  Framework: PyTorch
+- Name: maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512
+  In Collection: MaskFormer
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 49.36
+  Config: configs/maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - Swin-S
+    - MaskFormer
+    Training Resources: 8x 26.98 GPUS
+    Memory (GB): 5.33
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512_20221115_114710-723512c7.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512_20221115_114710.json
+  Paper:
+    Title: 'MaskFormer: Per-Pixel Classification is Not All You Need for Semantic
+      Segmentation'
+    URL: https://arxiv.org/abs/2107.06278
+  Code: https://github.com/open-mmlab/mmdetection/blob/dev-3.x/mmdet/models/dense_heads/maskformer_head.py#L21
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/mobilenet_v2/README.md b/mmsegmentation/configs/mobilenet_v2/README.md
new file mode 100644
index 0000000..bff5259
--- /dev/null
+++ b/mmsegmentation/configs/mobilenet_v2/README.md
@@ -0,0 +1,56 @@
+# MobileNetV2
+
+> [MobileNetV2: Inverted Residuals and Linear Bottlenecks](https://arxiv.org/abs/1801.04381)
+
+## Introduction
+
+<!-- [BACKBONE] -->
+
+<a href="https://github.com/tensorflow/models/tree/master/research/deeplab">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v2.py#L14">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+In this paper we describe a new mobile architecture, MobileNetV2, that improves the state of the art performance of mobile models on multiple tasks and benchmarks as well as across a spectrum of different model sizes. We also describe efficient ways of applying these mobile models to object detection in a novel framework we call SSDLite. Additionally, we demonstrate how to build mobile semantic segmentation models through a reduced form of DeepLabv3 which we call Mobile DeepLabv3.
+The MobileNetV2 architecture is based on an inverted residual structure where the input and output of the residual block are thin bottleneck layers opposite to traditional residual models which use expanded representations in the input an MobileNetV2 uses lightweight depthwise convolutions to filter features in the intermediate expansion layer. Additionally, we find that it is important to remove non-linearities in the narrow layers in order to maintain representational power. We demonstrate that this improves performance and provide an intuition that led to this design. Finally, our approach allows decoupling of the input/output domains from the expressiveness of the transformation, which provides a convenient framework for further analysis. We measure our performance on Imagenet classification, COCO object detection, VOC image segmentation. We evaluate the trade-offs between accuracy, and number of operations measured by multiply-adds (MAdd), as well as the number of parameters.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142901935-fa22700e-4b77-477f-90b9-334a4197506f.png" width="50%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                              | download                                                                                                                                                                                                                                                                                                                                                                                                 |
+| ---------- | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FCN        | M-V2-D8  | 512x1024  |   80000 |      3.4 | 14.2           | A100   | 71.19 | 73.34         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024-20230224_185436-13fef4ea.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024_20230224_185436.json) |
+| PSPNet     | M-V2-D8  | 512x1024  |   80000 |      3.6 | 11.2           | V100   | 70.23 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb2-80k_cityscapes-512x1024.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/pspnet_m-v2-d8_512x1024_80k_cityscapes/pspnet_m-v2-d8_512x1024_80k_cityscapes_20200825_124817-19e81d51.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/pspnet_m-v2-d8_512x1024_80k_cityscapes/pspnet_m-v2-d8_512x1024_80k_cityscapes-20200825_124817.log.json)                                     |
+| DeepLabV3  | M-V2-D8  | 512x1024  |   80000 |      3.9 | 8.4            | V100   | 73.84 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py)     | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3_m-v2-d8_512x1024_80k_cityscapes/deeplabv3_m-v2-d8_512x1024_80k_cityscapes_20200825_124836-bef03590.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3_m-v2-d8_512x1024_80k_cityscapes/deeplabv3_m-v2-d8_512x1024_80k_cityscapes-20200825_124836.log.json)                         |
+| DeepLabV3+ | M-V2-D8  | 512x1024  |   80000 |      5.1 | 8.4            | V100   | 75.20 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3plus_m-v2-d8_512x1024_80k_cityscapes/deeplabv3plus_m-v2-d8_512x1024_80k_cityscapes_20200825_124836-d256dd4b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3plus_m-v2-d8_512x1024_80k_cityscapes/deeplabv3plus_m-v2-d8_512x1024_80k_cityscapes-20200825_124836.log.json)         |
+
+### ADE20K
+
+| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                          | download                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FCN        | M-V2-D8  | 512x512   |  160000 |      6.5 | 64.4           | V100   | 19.71 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb4-160k_ade20k-512x512.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/fcn_m-v2-d8_512x512_160k_ade20k/fcn_m-v2-d8_512x512_160k_ade20k_20200825_214953-c40e1095.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/fcn_m-v2-d8_512x512_160k_ade20k/fcn_m-v2-d8_512x512_160k_ade20k-20200825_214953.log.json)                                         |
+| PSPNet     | M-V2-D8  | 512x512   |  160000 |      6.5 | 57.7           | V100   | 29.68 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb4-160k_ade20k-512x512.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/pspnet_m-v2-d8_512x512_160k_ade20k/pspnet_m-v2-d8_512x512_160k_ade20k_20200825_214953-f5942f7a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/pspnet_m-v2-d8_512x512_160k_ade20k/pspnet_m-v2-d8_512x512_160k_ade20k-20200825_214953.log.json)                             |
+| DeepLabV3  | M-V2-D8  | 512x512   |  160000 |      6.8 | 39.9           | V100   | 34.08 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb4-160k_ade20k-512x512.py)     | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3_m-v2-d8_512x512_160k_ade20k/deeplabv3_m-v2-d8_512x512_160k_ade20k_20200825_223255-63986343.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3_m-v2-d8_512x512_160k_ade20k/deeplabv3_m-v2-d8_512x512_160k_ade20k-20200825_223255.log.json)                 |
+| DeepLabV3+ | M-V2-D8  | 512x512   |  160000 |      8.2 | 43.1           | V100   | 34.02 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3plus_m-v2-d8_512x512_160k_ade20k/deeplabv3plus_m-v2-d8_512x512_160k_ade20k_20200825_223255-465a01d4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3plus_m-v2-d8_512x512_160k_ade20k/deeplabv3plus_m-v2-d8_512x512_160k_ade20k-20200825_223255.log.json) |
+
+## Citation
+
+```bibtex
+@inproceedings{sandler2018mobilenetv2,
+  title={Mobilenetv2: Inverted residuals and linear bottlenecks},
+  author={Sandler, Mark and Howard, Andrew and Zhu, Menglong and Zhmoginov, Andrey and Chen, Liang-Chieh},
+  booktitle={Proceedings of the IEEE conference on computer vision and pattern recognition},
+  pages={4510--4520},
+  year={2018}
+}
+```
diff --git a/mmsegmentation/configs/mobilenet_v2/metafile.yaml b/mmsegmentation/configs/mobilenet_v2/metafile.yaml
new file mode 100644
index 0000000..119c9ae
--- /dev/null
+++ b/mmsegmentation/configs/mobilenet_v2/metafile.yaml
@@ -0,0 +1,186 @@
+Models:
+- Name: mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 71.19
+      mIoU(ms+flip): 73.34
+  Config: configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - M-V2-D8
+    - FCN
+    Training Resources: 4x A100 GPUS
+    Memory (GB): 3.4
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024-20230224_185436-13fef4ea.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024_20230224_185436.json
+  Paper:
+    Title: 'MobileNetV2: Inverted Residuals and Linear Bottlenecks'
+    URL: https://arxiv.org/abs/1801.04381
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v2.py#L14
+  Framework: PyTorch
+- Name: mobilenet-v2-d8_pspnet_4xb2-80k_cityscapes-512x1024
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 70.23
+  Config: configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - M-V2-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 3.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/pspnet_m-v2-d8_512x1024_80k_cityscapes/pspnet_m-v2-d8_512x1024_80k_cityscapes_20200825_124817-19e81d51.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/pspnet_m-v2-d8_512x1024_80k_cityscapes/pspnet_m-v2-d8_512x1024_80k_cityscapes-20200825_124817.log.json
+  Paper:
+    Title: 'MobileNetV2: Inverted Residuals and Linear Bottlenecks'
+    URL: https://arxiv.org/abs/1801.04381
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v2.py#L14
+  Framework: PyTorch
+- Name: mobilenet-v2-d8_deeplabv3_4xb2-80k_cityscapes-512x1024
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 73.84
+  Config: configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - M-V2-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 3.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3_m-v2-d8_512x1024_80k_cityscapes/deeplabv3_m-v2-d8_512x1024_80k_cityscapes_20200825_124836-bef03590.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3_m-v2-d8_512x1024_80k_cityscapes/deeplabv3_m-v2-d8_512x1024_80k_cityscapes-20200825_124836.log.json
+  Paper:
+    Title: 'MobileNetV2: Inverted Residuals and Linear Bottlenecks'
+    URL: https://arxiv.org/abs/1801.04381
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v2.py#L14
+  Framework: PyTorch
+- Name: mobilenet-v2-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 75.2
+  Config: configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - M-V2-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3plus_m-v2-d8_512x1024_80k_cityscapes/deeplabv3plus_m-v2-d8_512x1024_80k_cityscapes_20200825_124836-d256dd4b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3plus_m-v2-d8_512x1024_80k_cityscapes/deeplabv3plus_m-v2-d8_512x1024_80k_cityscapes-20200825_124836.log.json
+  Paper:
+    Title: 'MobileNetV2: Inverted Residuals and Linear Bottlenecks'
+    URL: https://arxiv.org/abs/1801.04381
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v2.py#L14
+  Framework: PyTorch
+- Name: mobilenet-v2-d8_fcn_4xb4-160k_ade20k-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 19.71
+  Config: configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - M-V2-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/fcn_m-v2-d8_512x512_160k_ade20k/fcn_m-v2-d8_512x512_160k_ade20k_20200825_214953-c40e1095.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/fcn_m-v2-d8_512x512_160k_ade20k/fcn_m-v2-d8_512x512_160k_ade20k-20200825_214953.log.json
+  Paper:
+    Title: 'MobileNetV2: Inverted Residuals and Linear Bottlenecks'
+    URL: https://arxiv.org/abs/1801.04381
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v2.py#L14
+  Framework: PyTorch
+- Name: mobilenet-v2-d8_pspnet_4xb4-160k_ade20k-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 29.68
+  Config: configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - M-V2-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/pspnet_m-v2-d8_512x512_160k_ade20k/pspnet_m-v2-d8_512x512_160k_ade20k_20200825_214953-f5942f7a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/pspnet_m-v2-d8_512x512_160k_ade20k/pspnet_m-v2-d8_512x512_160k_ade20k-20200825_214953.log.json
+  Paper:
+    Title: 'MobileNetV2: Inverted Residuals and Linear Bottlenecks'
+    URL: https://arxiv.org/abs/1801.04381
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v2.py#L14
+  Framework: PyTorch
+- Name: mobilenet-v2-d8_deeplabv3_4xb4-160k_ade20k-512x512
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 34.08
+  Config: configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - M-V2-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3_m-v2-d8_512x512_160k_ade20k/deeplabv3_m-v2-d8_512x512_160k_ade20k_20200825_223255-63986343.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3_m-v2-d8_512x512_160k_ade20k/deeplabv3_m-v2-d8_512x512_160k_ade20k-20200825_223255.log.json
+  Paper:
+    Title: 'MobileNetV2: Inverted Residuals and Linear Bottlenecks'
+    URL: https://arxiv.org/abs/1801.04381
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v2.py#L14
+  Framework: PyTorch
+- Name: mobilenet-v2-d8_deeplabv3plus_4xb4-160k_ade20k-512x512
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 34.02
+  Config: configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - M-V2-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3plus_m-v2-d8_512x512_160k_ade20k/deeplabv3plus_m-v2-d8_512x512_160k_ade20k_20200825_223255-465a01d4.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3plus_m-v2-d8_512x512_160k_ade20k/deeplabv3plus_m-v2-d8_512x512_160k_ade20k-20200825_223255.log.json
+  Paper:
+    Title: 'MobileNetV2: Inverted Residuals and Linear Bottlenecks'
+    URL: https://arxiv.org/abs/1801.04381
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v2.py#L14
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..ece9b0b
--- /dev/null
+++ b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,13 @@
+_base_ = '../deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='mmcls://mobilenet_v2',
+    backbone=dict(
+        _delete_=True,
+        type='MobileNetV2',
+        widen_factor=1.,
+        strides=(1, 2, 2, 1, 1, 1, 1),
+        dilations=(1, 1, 1, 2, 2, 4, 4),
+        out_indices=(1, 2, 4, 6),
+        norm_cfg=dict(type='SyncBN', requires_grad=True)),
+    decode_head=dict(in_channels=320),
+    auxiliary_head=dict(in_channels=96))
diff --git a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..86eec0d
--- /dev/null
+++ b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,13 @@
+_base_ = '../deeplabv3/deeplabv3_r101-d8_4xb4-160k_ade20k-512x512.py'
+model = dict(
+    pretrained='mmcls://mobilenet_v2',
+    backbone=dict(
+        _delete_=True,
+        type='MobileNetV2',
+        widen_factor=1.,
+        strides=(1, 2, 2, 1, 1, 1, 1),
+        dilations=(1, 1, 1, 2, 2, 4, 4),
+        out_indices=(1, 2, 4, 6),
+        norm_cfg=dict(type='SyncBN', requires_grad=True)),
+    decode_head=dict(in_channels=320),
+    auxiliary_head=dict(in_channels=96))
diff --git a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..195046e
--- /dev/null
+++ b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,15 @@
+_base_ = [
+    '../deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024.py'
+]
+model = dict(
+    pretrained='mmcls://mobilenet_v2',
+    backbone=dict(
+        _delete_=True,
+        type='MobileNetV2',
+        widen_factor=1.,
+        strides=(1, 2, 2, 1, 1, 1, 1),
+        dilations=(1, 1, 1, 2, 2, 4, 4),
+        out_indices=(1, 2, 4, 6),
+        norm_cfg=dict(type='SyncBN', requires_grad=True)),
+    decode_head=dict(in_channels=320, c1_in_channels=24),
+    auxiliary_head=dict(in_channels=96))
diff --git a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..d4f669f
--- /dev/null
+++ b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,13 @@
+_base_ = '../deeplabv3plus/deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512.py'
+model = dict(
+    pretrained='mmcls://mobilenet_v2',
+    backbone=dict(
+        _delete_=True,
+        type='MobileNetV2',
+        widen_factor=1.,
+        strides=(1, 2, 2, 1, 1, 1, 1),
+        dilations=(1, 1, 1, 2, 2, 4, 4),
+        out_indices=(1, 2, 4, 6),
+        norm_cfg=dict(type='SyncBN', requires_grad=True)),
+    decode_head=dict(in_channels=320, c1_in_channels=24),
+    auxiliary_head=dict(in_channels=96))
diff --git a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..0829f43
--- /dev/null
+++ b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,13 @@
+_base_ = '../fcn/fcn_r101-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='mmcls://mobilenet_v2',
+    backbone=dict(
+        _delete_=True,
+        type='MobileNetV2',
+        widen_factor=1.,
+        strides=(1, 2, 2, 1, 1, 1, 1),
+        dilations=(1, 1, 1, 2, 2, 4, 4),
+        out_indices=(1, 2, 4, 6),
+        norm_cfg=dict(type='SyncBN', requires_grad=True)),
+    decode_head=dict(in_channels=320),
+    auxiliary_head=dict(in_channels=96))
diff --git a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..015fa6f
--- /dev/null
+++ b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,13 @@
+_base_ = '../fcn/fcn_r101-d8_4xb4-160k_ade20k-512x512.py'
+model = dict(
+    pretrained='mmcls://mobilenet_v2',
+    backbone=dict(
+        _delete_=True,
+        type='MobileNetV2',
+        widen_factor=1.,
+        strides=(1, 2, 2, 1, 1, 1, 1),
+        dilations=(1, 1, 1, 2, 2, 4, 4),
+        out_indices=(1, 2, 4, 6),
+        norm_cfg=dict(type='SyncBN', requires_grad=True)),
+    decode_head=dict(in_channels=320),
+    auxiliary_head=dict(in_channels=96))
diff --git a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..8542e02
--- /dev/null
+++ b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,13 @@
+_base_ = '../pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='mmcls://mobilenet_v2',
+    backbone=dict(
+        _delete_=True,
+        type='MobileNetV2',
+        widen_factor=1.,
+        strides=(1, 2, 2, 1, 1, 1, 1),
+        dilations=(1, 1, 1, 2, 2, 4, 4),
+        out_indices=(1, 2, 4, 6),
+        norm_cfg=dict(type='SyncBN', requires_grad=True)),
+    decode_head=dict(in_channels=320),
+    auxiliary_head=dict(in_channels=96))
diff --git a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..73db59b
--- /dev/null
+++ b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,13 @@
+_base_ = '../pspnet/pspnet_r101-d8_4xb4-160k_ade20k-512x512.py'
+model = dict(
+    pretrained='mmcls://mobilenet_v2',
+    backbone=dict(
+        _delete_=True,
+        type='MobileNetV2',
+        widen_factor=1.,
+        strides=(1, 2, 2, 1, 1, 1, 1),
+        dilations=(1, 1, 1, 2, 2, 4, 4),
+        out_indices=(1, 2, 4, 6),
+        norm_cfg=dict(type='SyncBN', requires_grad=True)),
+    decode_head=dict(in_channels=320),
+    auxiliary_head=dict(in_channels=96))
diff --git a/mmsegmentation/configs/mobilenet_v3/README.md b/mmsegmentation/configs/mobilenet_v3/README.md
new file mode 100644
index 0000000..8ed0a56
--- /dev/null
+++ b/mmsegmentation/configs/mobilenet_v3/README.md
@@ -0,0 +1,50 @@
+# MobileNetV3
+
+> [Searching for MobileNetV3](https://arxiv.org/abs/1905.02244)
+
+## Introduction
+
+<!-- [BACKBONE] -->
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/tensorflow/models/tree/master/research/deeplab">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v3.py#L15">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+We present the next generation of MobileNets based on a combination of complementary search techniques as well as a novel architecture design. MobileNetV3 is tuned to mobile phone CPUs through a combination of hardware-aware network architecture search (NAS) complemented by the NetAdapt algorithm and then subsequently improved through novel architecture advances. This paper starts the exploration of how automated search algorithms and network design can work together to harness complementary approaches improving the overall state of the art. Through this process we create two new MobileNet models for release: MobileNetV3-Large and MobileNetV3-Small which are targeted for high and low resource use cases. These models are then adapted and applied to the tasks of object detection and semantic segmentation. For the task of semantic segmentation (or any dense pixel prediction), we propose a new efficient segmentation decoder Lite Reduced Atrous Spatial Pyramid Pooling (LR-ASPP). We achieve new state of the art results for mobile classification, detection and segmentation. MobileNetV3-Large is 3.2% more accurate on ImageNet classification while reducing latency by 15% compared to MobileNetV2. MobileNetV3-Small is 4.6% more accurate while reducing latency by 5% compared to MobileNetV2. MobileNetV3-Large detection is 25% faster at roughly the same accuracy as MobileNetV2 on COCO detection. MobileNetV3-Large LR-ASPP is 30% faster than MobileNetV2 R-ASPP at similar accuracy for Cityscapes segmentation.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142902036-3dc2e0c0-d475-4816-b1ac-961836b41f5c.png" width="60%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method | Backbone           | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                                  | download                                                                                                                                                                                                                                                                                                                                                                                                     |
+| ------ | ------------------ | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| LRASPP | M-V3-D8            | 512x1024  |  320000 |      8.9 | 15.22          | V100   | 69.54 | 70.89         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v3/mobilenet-v3-d8_lraspp_4xb4-320k_cityscapes-512x1024.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3-d8_512x1024_320k_cityscapes/lraspp_m-v3-d8_512x1024_320k_cityscapes_20201224_220337-cfe8fb07.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3-d8_512x1024_320k_cityscapes/lraspp_m-v3-d8_512x1024_320k_cityscapes-20201224_220337.log.json)                                     |
+| LRASPP | M-V3-D8 (scratch)  | 512x1024  |  320000 |      8.9 | 14.77          | V100   | 67.87 | 69.78         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v3/mobilenet-v3-d8-scratch_lraspp_4xb4-320k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3-d8_scratch_512x1024_320k_cityscapes/lraspp_m-v3-d8_scratch_512x1024_320k_cityscapes_20201224_220337-9f29cd72.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3-d8_scratch_512x1024_320k_cityscapes/lraspp_m-v3-d8_scratch_512x1024_320k_cityscapes-20201224_220337.log.json)     |
+| LRASPP | M-V3s-D8           | 512x1024  |  320000 |      5.3 | 23.64          | V100   | 64.11 | 66.42         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v3/mobilenet-v3-d8-s_lraspp_4xb4-320k_cityscapes-512x1024.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3s-d8_512x1024_320k_cityscapes/lraspp_m-v3s-d8_512x1024_320k_cityscapes_20201224_223935-61565b34.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3s-d8_512x1024_320k_cityscapes/lraspp_m-v3s-d8_512x1024_320k_cityscapes-20201224_223935.log.json)                                 |
+| LRASPP | M-V3s-D8 (scratch) | 512x1024  |  320000 |      5.3 | 24.50          | V100   | 62.74 | 65.01         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v3/mobilenet-v3-d8-scratch-s_lraspp_4xb4-320k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3s-d8_scratch_512x1024_320k_cityscapes/lraspp_m-v3s-d8_scratch_512x1024_320k_cityscapes_20201224_223935-03daeabb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3s-d8_scratch_512x1024_320k_cityscapes/lraspp_m-v3s-d8_scratch_512x1024_320k_cityscapes-20201224_223935.log.json) |
+
+## Citation
+
+```bibtex
+@inproceedings{Howard_2019_ICCV,
+  title={Searching for MobileNetV3},
+  author={Howard, Andrew and Sandler, Mark and Chu, Grace and Chen, Liang-Chieh and Chen, Bo and Tan, Mingxing and Wang, Weijun and Zhu, Yukun and Pang, Ruoming and Vasudevan, Vijay and Le, Quoc V. and Adam, Hartwig},
+  booktitle={The IEEE International Conference on Computer Vision (ICCV)},
+  pages={1314-1324},
+  month={October},
+  year={2019},
+  doi={10.1109/ICCV.2019.00140}}
+}
+```
diff --git a/mmsegmentation/configs/mobilenet_v3/metafile.yaml b/mmsegmentation/configs/mobilenet_v3/metafile.yaml
new file mode 100644
index 0000000..0351d3b
--- /dev/null
+++ b/mmsegmentation/configs/mobilenet_v3/metafile.yaml
@@ -0,0 +1,109 @@
+Collections:
+- Name: LRASPP
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+  Paper:
+    Title: Searching for MobileNetV3
+    URL: https://arxiv.org/abs/1905.02244
+  README: configs/mobilenet_v3/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: mobilenet-v3-d8_lraspp_4xb4-320k_cityscapes-512x1024
+  In Collection: LRASPP
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 69.54
+      mIoU(ms+flip): 70.89
+  Config: configs/mobilenet_v3/mobilenet-v3-d8_lraspp_4xb4-320k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 16
+    Architecture:
+    - M-V3-D8
+    - LRASPP
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3-d8_512x1024_320k_cityscapes/lraspp_m-v3-d8_512x1024_320k_cityscapes_20201224_220337-cfe8fb07.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3-d8_512x1024_320k_cityscapes/lraspp_m-v3-d8_512x1024_320k_cityscapes-20201224_220337.log.json
+  Paper:
+    Title: Searching for MobileNetV3
+    URL: https://arxiv.org/abs/1905.02244
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v3.py#L15
+  Framework: PyTorch
+- Name: mobilenet-v3-d8-scratch_lraspp_4xb4-320k_cityscapes-512x1024
+  In Collection: LRASPP
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 67.87
+      mIoU(ms+flip): 69.78
+  Config: configs/mobilenet_v3/mobilenet-v3-d8-scratch_lraspp_4xb4-320k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 16
+    Architecture:
+    - M-V3-D8
+    - LRASPP
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3-d8_scratch_512x1024_320k_cityscapes/lraspp_m-v3-d8_scratch_512x1024_320k_cityscapes_20201224_220337-9f29cd72.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3-d8_scratch_512x1024_320k_cityscapes/lraspp_m-v3-d8_scratch_512x1024_320k_cityscapes-20201224_220337.log.json
+  Paper:
+    Title: Searching for MobileNetV3
+    URL: https://arxiv.org/abs/1905.02244
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v3.py#L15
+  Framework: PyTorch
+- Name: mobilenet-v3-d8-s_lraspp_4xb4-320k_cityscapes-512x1024
+  In Collection: LRASPP
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 64.11
+      mIoU(ms+flip): 66.42
+  Config: configs/mobilenet_v3/mobilenet-v3-d8-s_lraspp_4xb4-320k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 16
+    Architecture:
+    - M-V3s-D8
+    - LRASPP
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.3
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3s-d8_512x1024_320k_cityscapes/lraspp_m-v3s-d8_512x1024_320k_cityscapes_20201224_223935-61565b34.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3s-d8_512x1024_320k_cityscapes/lraspp_m-v3s-d8_512x1024_320k_cityscapes-20201224_223935.log.json
+  Paper:
+    Title: Searching for MobileNetV3
+    URL: https://arxiv.org/abs/1905.02244
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v3.py#L15
+  Framework: PyTorch
+- Name: mobilenet-v3-d8-scratch-s_lraspp_4xb4-320k_cityscapes-512x1024
+  In Collection: LRASPP
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 62.74
+      mIoU(ms+flip): 65.01
+  Config: configs/mobilenet_v3/mobilenet-v3-d8-scratch-s_lraspp_4xb4-320k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 16
+    Architecture:
+    - M-V3s-D8
+    - LRASPP
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.3
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3s-d8_scratch_512x1024_320k_cityscapes/lraspp_m-v3s-d8_scratch_512x1024_320k_cityscapes_20201224_223935-03daeabb.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3s-d8_scratch_512x1024_320k_cityscapes/lraspp_m-v3s-d8_scratch_512x1024_320k_cityscapes-20201224_223935.log.json
+  Paper:
+    Title: Searching for MobileNetV3
+    URL: https://arxiv.org/abs/1905.02244
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v3.py#L15
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-s_lraspp_4xb4-320k_cityscapes-512x1024.py b/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-s_lraspp_4xb4-320k_cityscapes-512x1024.py
new file mode 100644
index 0000000..bc6322f
--- /dev/null
+++ b/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-s_lraspp_4xb4-320k_cityscapes-512x1024.py
@@ -0,0 +1,23 @@
+_base_ = './mobilenet-v3-d8_lraspp_4xb4-320k_cityscapes-512x1024.py'
+norm_cfg = dict(type='SyncBN', eps=0.001, requires_grad=True)
+model = dict(
+    type='EncoderDecoder',
+    pretrained='open-mmlab://contrib/mobilenet_v3_small',
+    backbone=dict(
+        type='MobileNetV3',
+        arch='small',
+        out_indices=(0, 1, 12),
+        norm_cfg=norm_cfg),
+    decode_head=dict(
+        type='LRASPPHead',
+        in_channels=(16, 16, 576),
+        in_index=(0, 1, 2),
+        channels=128,
+        input_transform='multiple_select',
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        act_cfg=dict(type='ReLU'),
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)))
diff --git a/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-scratch-s_lraspp_4xb4-320k_cityscapes-512x1024.py b/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-scratch-s_lraspp_4xb4-320k_cityscapes-512x1024.py
new file mode 100644
index 0000000..7260936
--- /dev/null
+++ b/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-scratch-s_lraspp_4xb4-320k_cityscapes-512x1024.py
@@ -0,0 +1,22 @@
+_base_ = './mobilenet-v3-d8-scratch_lraspp_4xb4-320k_cityscapes-512x1024.py'
+norm_cfg = dict(type='SyncBN', eps=0.001, requires_grad=True)
+model = dict(
+    type='EncoderDecoder',
+    backbone=dict(
+        type='MobileNetV3',
+        arch='small',
+        out_indices=(0, 1, 12),
+        norm_cfg=norm_cfg),
+    decode_head=dict(
+        type='LRASPPHead',
+        in_channels=(16, 16, 576),
+        in_index=(0, 1, 2),
+        channels=128,
+        input_transform='multiple_select',
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        act_cfg=dict(type='ReLU'),
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)))
diff --git a/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-scratch_lraspp_4xb4-320k_cityscapes-512x1024.py b/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-scratch_lraspp_4xb4-320k_cityscapes-512x1024.py
new file mode 100644
index 0000000..8dcbc33
--- /dev/null
+++ b/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-scratch_lraspp_4xb4-320k_cityscapes-512x1024.py
@@ -0,0 +1,13 @@
+_base_ = [
+    '../_base_/models/lraspp_m-v3-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+# Re-config the data sampler.
+model = dict(data_preprocessor=data_preprocessor)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
+
+runner = dict(type='IterBasedRunner', max_iters=320000)
diff --git a/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8_lraspp_4xb4-320k_cityscapes-512x1024.py b/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8_lraspp_4xb4-320k_cityscapes-512x1024.py
new file mode 100644
index 0000000..cd84265
--- /dev/null
+++ b/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8_lraspp_4xb4-320k_cityscapes-512x1024.py
@@ -0,0 +1,16 @@
+_base_ = [
+    '../_base_/models/lraspp_m-v3-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://contrib/mobilenet_v3_large')
+
+# Re-config the data sampler.
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
+
+runner = dict(type='IterBasedRunner', max_iters=320000)
diff --git a/mmsegmentation/configs/nonlocal_net/README.md b/mmsegmentation/configs/nonlocal_net/README.md
new file mode 100644
index 0000000..4c3f49f
--- /dev/null
+++ b/mmsegmentation/configs/nonlocal_net/README.md
@@ -0,0 +1,68 @@
+# NonLocal Net
+
+> [Non-local Neural Networks](https://arxiv.org/abs/1711.07971)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/facebookresearch/video-nonlocal-net">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Both convolutional and recurrent operations are building blocks that process one local neighborhood at a time. In this paper, we present non-local operations as a generic family of building blocks for capturing long-range dependencies. Inspired by the classical non-local means method in computer vision, our non-local operation computes the response at a position as a weighted sum of the features at all positions. This building block can be plugged into many computer vision architectures. On the task of video classification, even without any bells and whistles, our non-local models can compete or outperform current competition winners on both Kinetics and Charades datasets. In static image recognition, our non-local models improve object detection/segmentation and pose estimation on the COCO suite of tasks. Code is available at [this https URL](https://github.com/facebookresearch/video-nonlocal-net).
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142902128-17e29678-bf12-4ff4-b3d6-a39b47dfd253.png" width="50%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method      | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                 | download                                                                                                                                                                                                                                                                                                                                                                     |
+| ----------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------- | -------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| NonLocalNet | R-50-D8  | 512x1024  |   40000 | 7.4      | 2.72           | V100   | 78.24 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x1024_40k_cityscapes/nonlocal_r50-d8_512x1024_40k_cityscapes_20200605_210748-c75e81e3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x1024_40k_cityscapes/nonlocal_r50-d8_512x1024_40k_cityscapes_20200605_210748.log.json)     |
+| NonLocalNet | R-101-D8 | 512x1024  |   40000 | 10.9     | 1.95           | V100   | 78.66 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x1024_40k_cityscapes/nonlocal_r101-d8_512x1024_40k_cityscapes_20200605_210748-d63729fa.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x1024_40k_cityscapes/nonlocal_r101-d8_512x1024_40k_cityscapes_20200605_210748.log.json) |
+| NonLocalNet | R-50-D8  | 769x769   |   40000 | 8.9      | 1.52           | V100   | 78.33 | 79.92         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_769x769_40k_cityscapes/nonlocal_r50-d8_769x769_40k_cityscapes_20200530_045243-82ef6749.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_769x769_40k_cityscapes/nonlocal_r50-d8_769x769_40k_cityscapes_20200530_045243.log.json)         |
+| NonLocalNet | R-101-D8 | 769x769   |   40000 | 12.8     | 1.05           | V100   | 78.57 | 80.29         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_769x769_40k_cityscapes/nonlocal_r101-d8_769x769_40k_cityscapes_20200530_045348-8fe9a9dc.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_769x769_40k_cityscapes/nonlocal_r101-d8_769x769_40k_cityscapes_20200530_045348.log.json)     |
+| NonLocalNet | R-50-D8  | 512x1024  |   80000 | -        | -              | V100   | 78.01 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x1024_80k_cityscapes/nonlocal_r50-d8_512x1024_80k_cityscapes_20200607_193518-d6839fae.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x1024_80k_cityscapes/nonlocal_r50-d8_512x1024_80k_cityscapes_20200607_193518.log.json)     |
+| NonLocalNet | R-101-D8 | 512x1024  |   80000 | -        | -              | V100   | 78.93 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x1024_80k_cityscapes/nonlocal_r101-d8_512x1024_80k_cityscapes_20200607_183411-32700183.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x1024_80k_cityscapes/nonlocal_r101-d8_512x1024_80k_cityscapes_20200607_183411.log.json) |
+| NonLocalNet | R-50-D8  | 769x769   |   80000 | -        | -              | V100   | 79.05 | 80.68         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_769x769_80k_cityscapes/nonlocal_r50-d8_769x769_80k_cityscapes_20200607_193506-1f9792f6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_769x769_80k_cityscapes/nonlocal_r50-d8_769x769_80k_cityscapes_20200607_193506.log.json)         |
+| NonLocalNet | R-101-D8 | 769x769   |   80000 | -        | -              | V100   | 79.40 | 80.85         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_769x769_80k_cityscapes/nonlocal_r101-d8_769x769_80k_cityscapes_20200607_183428-0e1fa4f9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_769x769_80k_cityscapes/nonlocal_r101-d8_769x769_80k_cityscapes_20200607_183428.log.json)     |
+
+### ADE20K
+
+| Method      | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                             | download                                                                                                                                                                                                                                                                                                                                                     |
+| ----------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ---------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| NonLocalNet | R-50-D8  | 512x512   |   80000 | 9.1      | 21.37          | V100   | 40.75 |         42.05 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_80k_ade20k/nonlocal_r50-d8_512x512_80k_ade20k_20200615_015801-5ae0aa33.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_80k_ade20k/nonlocal_r50-d8_512x512_80k_ade20k_20200615_015801.log.json)         |
+| NonLocalNet | R-101-D8 | 512x512   |   80000 | 12.6     | 13.97          | V100   | 42.90 |         44.27 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_80k_ade20k/nonlocal_r101-d8_512x512_80k_ade20k_20200615_015758-24105919.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_80k_ade20k/nonlocal_r101-d8_512x512_80k_ade20k_20200615_015758.log.json)     |
+| NonLocalNet | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 42.03 |         43.04 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_160k_ade20k/nonlocal_r50-d8_512x512_160k_ade20k_20200616_005410-baef45e3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_160k_ade20k/nonlocal_r50-d8_512x512_160k_ade20k_20200616_005410.log.json)     |
+| NonLocalNet | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 44.63 |         45.79 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_160k_ade20k/nonlocal_r101-d8_512x512_160k_ade20k_20210827_221502-7881aa1a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_160k_ade20k/nonlocal_r101-d8_512x512_160k_ade20k_20210827_221502.log.json) |
+
+### Pascal VOC 2012 + Aug
+
+| Method      | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                              | download                                                                                                                                                                                                                                                                                                                                                         |
+| ----------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ----------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| NonLocalNet | R-50-D8  | 512x512   |   20000 | 6.4      | 21.21          | V100   | 76.20 |         77.12 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r50-d8_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_20k_voc12aug/nonlocal_r50-d8_512x512_20k_voc12aug_20200617_222613-07f2a57c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_20k_voc12aug/nonlocal_r50-d8_512x512_20k_voc12aug_20200617_222613.log.json)     |
+| NonLocalNet | R-101-D8 | 512x512   |   20000 | 9.8      | 14.01          | V100   | 78.15 |         78.86 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r101-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_20k_voc12aug/nonlocal_r101-d8_512x512_20k_voc12aug_20200617_222615-948c68ab.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_20k_voc12aug/nonlocal_r101-d8_512x512_20k_voc12aug_20200617_222615.log.json) |
+| NonLocalNet | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 76.65 |         77.47 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r50-d8_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_40k_voc12aug/nonlocal_r50-d8_512x512_40k_voc12aug_20200614_000028-0139d4a9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_40k_voc12aug/nonlocal_r50-d8_512x512_40k_voc12aug_20200614_000028.log.json)     |
+| NonLocalNet | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 78.27 |         79.12 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r101-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_40k_voc12aug/nonlocal_r101-d8_512x512_40k_voc12aug_20200614_000028-7e5ff470.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_40k_voc12aug/nonlocal_r101-d8_512x512_40k_voc12aug_20200614_000028.log.json) |
+
+## Citation
+
+```bibtex
+@inproceedings{wang2018non,
+  title={Non-local neural networks},
+  author={Wang, Xiaolong and Girshick, Ross and Gupta, Abhinav and He, Kaiming},
+  booktitle={Proceedings of the IEEE conference on computer vision and pattern recognition},
+  pages={7794--7803},
+  year={2018}
+}
+```
diff --git a/mmsegmentation/configs/nonlocal_net/metafile.yaml b/mmsegmentation/configs/nonlocal_net/metafile.yaml
new file mode 100644
index 0000000..69bd725
--- /dev/null
+++ b/mmsegmentation/configs/nonlocal_net/metafile.yaml
@@ -0,0 +1,387 @@
+Collections:
+- Name: NonLocalNet
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+    - ADE20K
+    - Pascal VOC 2012 + Aug
+  Paper:
+    Title: Non-local Neural Networks
+    URL: https://arxiv.org/abs/1711.07971
+  README: configs/nonlocal_net/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: nonlocal_r50-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: NonLocalNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.24
+  Config: configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - NonLocalNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 7.4
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x1024_40k_cityscapes/nonlocal_r50-d8_512x1024_40k_cityscapes_20200605_210748-c75e81e3.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x1024_40k_cityscapes/nonlocal_r50-d8_512x1024_40k_cityscapes_20200605_210748.log.json
+  Paper:
+    Title: Non-local Neural Networks
+    URL: https://arxiv.org/abs/1711.07971
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
+  Framework: PyTorch
+- Name: nonlocal_r101-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: NonLocalNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.66
+  Config: configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - NonLocalNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x1024_40k_cityscapes/nonlocal_r101-d8_512x1024_40k_cityscapes_20200605_210748-d63729fa.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x1024_40k_cityscapes/nonlocal_r101-d8_512x1024_40k_cityscapes_20200605_210748.log.json
+  Paper:
+    Title: Non-local Neural Networks
+    URL: https://arxiv.org/abs/1711.07971
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
+  Framework: PyTorch
+- Name: nonlocal_r50-d8_4xb2-40k_cityscapes-769x769
+  In Collection: NonLocalNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.33
+      mIoU(ms+flip): 79.92
+  Config: configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - NonLocalNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_769x769_40k_cityscapes/nonlocal_r50-d8_769x769_40k_cityscapes_20200530_045243-82ef6749.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_769x769_40k_cityscapes/nonlocal_r50-d8_769x769_40k_cityscapes_20200530_045243.log.json
+  Paper:
+    Title: Non-local Neural Networks
+    URL: https://arxiv.org/abs/1711.07971
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
+  Framework: PyTorch
+- Name: nonlocal_r101-d8_4xb2-40k_cityscapes-769x769
+  In Collection: NonLocalNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.57
+      mIoU(ms+flip): 80.29
+  Config: configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - NonLocalNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 12.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_769x769_40k_cityscapes/nonlocal_r101-d8_769x769_40k_cityscapes_20200530_045348-8fe9a9dc.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_769x769_40k_cityscapes/nonlocal_r101-d8_769x769_40k_cityscapes_20200530_045348.log.json
+  Paper:
+    Title: Non-local Neural Networks
+    URL: https://arxiv.org/abs/1711.07971
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
+  Framework: PyTorch
+- Name: nonlocal_r50-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: NonLocalNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.01
+  Config: configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - NonLocalNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x1024_80k_cityscapes/nonlocal_r50-d8_512x1024_80k_cityscapes_20200607_193518-d6839fae.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x1024_80k_cityscapes/nonlocal_r50-d8_512x1024_80k_cityscapes_20200607_193518.log.json
+  Paper:
+    Title: Non-local Neural Networks
+    URL: https://arxiv.org/abs/1711.07971
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
+  Framework: PyTorch
+- Name: nonlocal_r101-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: NonLocalNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.93
+  Config: configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - NonLocalNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x1024_80k_cityscapes/nonlocal_r101-d8_512x1024_80k_cityscapes_20200607_183411-32700183.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x1024_80k_cityscapes/nonlocal_r101-d8_512x1024_80k_cityscapes_20200607_183411.log.json
+  Paper:
+    Title: Non-local Neural Networks
+    URL: https://arxiv.org/abs/1711.07971
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
+  Framework: PyTorch
+- Name: nonlocal_r50-d8_4xb2-80k_cityscapes-769x769
+  In Collection: NonLocalNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.05
+      mIoU(ms+flip): 80.68
+  Config: configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - NonLocalNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_769x769_80k_cityscapes/nonlocal_r50-d8_769x769_80k_cityscapes_20200607_193506-1f9792f6.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_769x769_80k_cityscapes/nonlocal_r50-d8_769x769_80k_cityscapes_20200607_193506.log.json
+  Paper:
+    Title: Non-local Neural Networks
+    URL: https://arxiv.org/abs/1711.07971
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
+  Framework: PyTorch
+- Name: nonlocal_r101-d8_4xb2-80k_cityscapes-769x769
+  In Collection: NonLocalNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.4
+      mIoU(ms+flip): 80.85
+  Config: configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - NonLocalNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_769x769_80k_cityscapes/nonlocal_r101-d8_769x769_80k_cityscapes_20200607_183428-0e1fa4f9.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_769x769_80k_cityscapes/nonlocal_r101-d8_769x769_80k_cityscapes_20200607_183428.log.json
+  Paper:
+    Title: Non-local Neural Networks
+    URL: https://arxiv.org/abs/1711.07971
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
+  Framework: PyTorch
+- Name: nonlocal_r50-d8_4xb4-80k_ade20k-512x512
+  In Collection: NonLocalNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 40.75
+      mIoU(ms+flip): 42.05
+  Config: configs/nonlocal_net/nonlocal_r50-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - NonLocalNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_80k_ade20k/nonlocal_r50-d8_512x512_80k_ade20k_20200615_015801-5ae0aa33.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_80k_ade20k/nonlocal_r50-d8_512x512_80k_ade20k_20200615_015801.log.json
+  Paper:
+    Title: Non-local Neural Networks
+    URL: https://arxiv.org/abs/1711.07971
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
+  Framework: PyTorch
+- Name: nonlocal_r101-d8_4xb4-80k_ade20k-512x512
+  In Collection: NonLocalNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.9
+      mIoU(ms+flip): 44.27
+  Config: configs/nonlocal_net/nonlocal_r101-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - NonLocalNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 12.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_80k_ade20k/nonlocal_r101-d8_512x512_80k_ade20k_20200615_015758-24105919.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_80k_ade20k/nonlocal_r101-d8_512x512_80k_ade20k_20200615_015758.log.json
+  Paper:
+    Title: Non-local Neural Networks
+    URL: https://arxiv.org/abs/1711.07971
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
+  Framework: PyTorch
+- Name: nonlocal_r50-d8_4xb4-160k_ade20k-512x512
+  In Collection: NonLocalNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.03
+      mIoU(ms+flip): 43.04
+  Config: configs/nonlocal_net/nonlocal_r50-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - NonLocalNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_160k_ade20k/nonlocal_r50-d8_512x512_160k_ade20k_20200616_005410-baef45e3.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_160k_ade20k/nonlocal_r50-d8_512x512_160k_ade20k_20200616_005410.log.json
+  Paper:
+    Title: Non-local Neural Networks
+    URL: https://arxiv.org/abs/1711.07971
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
+  Framework: PyTorch
+- Name: nonlocal_r101-d8_4xb4-160k_ade20k-512x512
+  In Collection: NonLocalNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 44.63
+      mIoU(ms+flip): 45.79
+  Config: configs/nonlocal_net/nonlocal_r101-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - NonLocalNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_160k_ade20k/nonlocal_r101-d8_512x512_160k_ade20k_20210827_221502-7881aa1a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_160k_ade20k/nonlocal_r101-d8_512x512_160k_ade20k_20210827_221502.log.json
+  Paper:
+    Title: Non-local Neural Networks
+    URL: https://arxiv.org/abs/1711.07971
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
+  Framework: PyTorch
+- Name: nonlocal_r50-d8_4xb4-20k_voc12aug-512x512
+  In Collection: NonLocalNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 76.2
+      mIoU(ms+flip): 77.12
+  Config: configs/nonlocal_net/nonlocal_r50-d8_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - NonLocalNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.4
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_20k_voc12aug/nonlocal_r50-d8_512x512_20k_voc12aug_20200617_222613-07f2a57c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_20k_voc12aug/nonlocal_r50-d8_512x512_20k_voc12aug_20200617_222613.log.json
+  Paper:
+    Title: Non-local Neural Networks
+    URL: https://arxiv.org/abs/1711.07971
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
+  Framework: PyTorch
+- Name: nonlocal_r101-d8_4xb4-20k_voc12aug-512x512
+  In Collection: NonLocalNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 78.15
+      mIoU(ms+flip): 78.86
+  Config: configs/nonlocal_net/nonlocal_r101-d8_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - NonLocalNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_20k_voc12aug/nonlocal_r101-d8_512x512_20k_voc12aug_20200617_222615-948c68ab.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_20k_voc12aug/nonlocal_r101-d8_512x512_20k_voc12aug_20200617_222615.log.json
+  Paper:
+    Title: Non-local Neural Networks
+    URL: https://arxiv.org/abs/1711.07971
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
+  Framework: PyTorch
+- Name: nonlocal_r50-d8_4xb4-40k_voc12aug-512x512
+  In Collection: NonLocalNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 76.65
+      mIoU(ms+flip): 77.47
+  Config: configs/nonlocal_net/nonlocal_r50-d8_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - NonLocalNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_40k_voc12aug/nonlocal_r50-d8_512x512_40k_voc12aug_20200614_000028-0139d4a9.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_40k_voc12aug/nonlocal_r50-d8_512x512_40k_voc12aug_20200614_000028.log.json
+  Paper:
+    Title: Non-local Neural Networks
+    URL: https://arxiv.org/abs/1711.07971
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
+  Framework: PyTorch
+- Name: nonlocal_r101-d8_4xb4-40k_voc12aug-512x512
+  In Collection: NonLocalNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 78.27
+      mIoU(ms+flip): 79.12
+  Config: configs/nonlocal_net/nonlocal_r101-d8_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - NonLocalNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_40k_voc12aug/nonlocal_r101-d8_512x512_40k_voc12aug_20200614_000028-7e5ff470.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_40k_voc12aug/nonlocal_r101-d8_512x512_40k_voc12aug_20200614_000028.log.json
+  Paper:
+    Title: Non-local Neural Networks
+    URL: https://arxiv.org/abs/1711.07971
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..5fcf7bc
--- /dev/null
+++ b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './nonlocal_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..ee984c2
--- /dev/null
+++ b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './nonlocal_r50-d8_4xb2-40k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..aca80d6
--- /dev/null
+++ b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './nonlocal_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..8a7aeea
--- /dev/null
+++ b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './nonlocal_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..0cdb3ca
--- /dev/null
+++ b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './nonlocal_r50-d8_4xb4-160k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..a7cacea
--- /dev/null
+++ b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './nonlocal_r50-d8_4xb4-20k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..ec47544
--- /dev/null
+++ b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './nonlocal_r50-d8_4xb4-40k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..ca79f6f
--- /dev/null
+++ b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './nonlocal_r50-d8_4xb4-80k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..f4d5fd2
--- /dev/null
+++ b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/nonlocal_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..17423f2
--- /dev/null
+++ b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/nonlocal_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..7cc752c
--- /dev/null
+++ b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/nonlocal_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..f855a81
--- /dev/null
+++ b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/nonlocal_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..848be4a
--- /dev/null
+++ b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/nonlocal_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..cd840a0
--- /dev/null
+++ b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/nonlocal_r50-d8.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_20k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..0efb9d0
--- /dev/null
+++ b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/nonlocal_r50-d8.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..52783bc
--- /dev/null
+++ b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/nonlocal_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/ocrnet/README.md b/mmsegmentation/configs/ocrnet/README.md
new file mode 100644
index 0000000..628a3b1
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/README.md
@@ -0,0 +1,89 @@
+# OCRNet
+
+> [Object-Contextual Representations for Semantic Segmentation](https://arxiv.org/abs/1909.11065)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/openseg-group/OCNet.pytorch">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+In this paper, we address the problem of semantic segmentation and focus on the context aggregation strategy for robust segmentation. Our motivation is that the label of a pixel is the category of the object that the pixel belongs to. We present a simple yet effective approach, object-contextual representations, characterizing a pixel by exploiting the representation of the corresponding object class. First, we construct object regions based on a feature map supervised by the ground-truth segmentation, and then compute the object region representations. Second, we compute the representation similarity between each pixel and each object region, and augment the representation of each pixel with an object contextual representation, which is a weighted aggregation of all the object region representations according to their similarities with the pixel. We empirically demonstrate that the proposed approach achieves competitive performance on six challenging semantic segmentation benchmarks: Cityscapes, ADE20K, LIP, PASCAL VOC 2012, PASCAL-Context and COCO-Stuff. Notably, we achieved the \\nth{2} place on the Cityscapes leader-board with a single model.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142902197-b06b1e04-57ab-44ac-adc8-cea6695bb236.png" width="70%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+#### HRNet backbone
+
+| Method | Backbone           | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                        | download                                                                                                                                                                                                                                                                                                                                                         |
+| ------ | ------------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ----------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| OCRNet | HRNetV2p-W18-Small | 512x1024  |   40000 | 3.5      | 10.45          | A100   | 76.61 |         78.01 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024_20230227_145026-6c052a14.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024_20230227_145026.json) |
+| OCRNet | HRNetV2p-W18       | 512x1024  |   40000 | 4.7      | 7.50           | V100   | 77.72 |         79.49 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18_4xb2-40k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_40k_cityscapes/ocrnet_hr18_512x1024_40k_cityscapes_20200601_033320-401c5bdd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_40k_cityscapes/ocrnet_hr18_512x1024_40k_cityscapes_20200601_033320.log.json)                     |
+| OCRNet | HRNetV2p-W48       | 512x1024  |   40000 | 8        | 4.22           | V100   | 80.58 |         81.79 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr48_4xb2-40k_cityscapes-512x1024.pyy)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_40k_cityscapes/ocrnet_hr48_512x1024_40k_cityscapes_20200601_033336-55b32491.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_40k_cityscapes/ocrnet_hr48_512x1024_40k_cityscapes_20200601_033336.log.json)                     |
+| OCRNet | HRNetV2p-W18-Small | 512x1024  |   80000 | -        | -              | V100   | 77.16 |         78.66 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18s_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x1024_80k_cityscapes/ocrnet_hr18s_512x1024_80k_cityscapes_20200601_222735-55979e63.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x1024_80k_cityscapes/ocrnet_hr18s_512x1024_80k_cityscapes_20200601_222735.log.json)                 |
+| OCRNet | HRNetV2p-W18       | 512x1024  |   80000 | -        | -              | V100   | 78.57 |         80.46 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18_4xb2-80k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_80k_cityscapes/ocrnet_hr18_512x1024_80k_cityscapes_20200614_230521-c2e1dd4a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_80k_cityscapes/ocrnet_hr18_512x1024_80k_cityscapes_20200614_230521.log.json)                     |
+| OCRNet | HRNetV2p-W48       | 512x1024  |   80000 | -        | -              | V100   | 80.70 |         81.87 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr48_4xb2-80k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_80k_cityscapes/ocrnet_hr48_512x1024_80k_cityscapes_20200601_222752-9076bcdf.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_80k_cityscapes/ocrnet_hr48_512x1024_80k_cityscapes_20200601_222752.log.json)                     |
+| OCRNet | HRNetV2p-W18-Small | 512x1024  |  160000 | -        | -              | V100   | 78.45 |         79.97 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18s_4xb2-160k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x1024_160k_cityscapes/ocrnet_hr18s_512x1024_160k_cityscapes_20200602_191005-f4a7af28.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x1024_160k_cityscapes/ocrnet_hr18s_512x1024_160k_cityscapes_20200602_191005.log.json)             |
+| OCRNet | HRNetV2p-W18       | 512x1024  |  160000 | -        | -              | V100   | 79.47 |         80.91 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18_4xb2-160k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_160k_cityscapes/ocrnet_hr18_512x1024_160k_cityscapes_20200602_191001-b9172d0c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_160k_cityscapes/ocrnet_hr18_512x1024_160k_cityscapes_20200602_191001.log.json)                 |
+| OCRNet | HRNetV2p-W48       | 512x1024  |  160000 | -        | -              | V100   | 81.35 |         82.70 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr48_4xb2-160k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_160k_cityscapes/ocrnet_hr48_512x1024_160k_cityscapes_20200602_191037-dfbf1b0c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_160k_cityscapes/ocrnet_hr48_512x1024_160k_cityscapes_20200602_191037.log.json)                 |
+
+#### ResNet backbone
+
+| Method | Backbone | Crop Size | Batch Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                         | download                                                                                                                                                                                                                                                                                                                                                                 |
+| ------ | -------- | --------- | ---------- | ------- | -------- | -------------- | ------ | ----- | ------------: | ------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| OCRNet | R-101-D8 | 512x1024  | 8          | 40000   | -        | -              | V100   | 80.09 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_r101-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_40k_b8_cityscapes/ocrnet_r101-d8_512x1024_40k_b8_cityscapes_20200717_110721-02ac0f13.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_40k_b8_cityscapes/ocrnet_r101-d8_512x1024_40k_b8_cityscapes_20200717_110721.log.json)     |
+| OCRNet | R-101-D8 | 512x1024  | 16         | 40000   | 8.8      | 3.02           | V100   | 80.30 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_r101-d8_8xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_40k_b16_cityscapes/ocrnet_r101-d8_512x1024_40k_b16_cityscapes_20200723_193726-db500f80.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_40k_b16_cityscapes/ocrnet_r101-d8_512x1024_40k_b16_cityscapes_20200723_193726.log.json) |
+| OCRNet | R-101-D8 | 512x1024  | 16         | 80000   | 8.8      | 3.02           | V100   | 80.81 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_r101-d8_8xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_80k_b16_cityscapes/ocrnet_r101-d8_512x1024_80k_b16_cityscapes_20200723_192421-78688424.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_80k_b16_cityscapes/ocrnet_r101-d8_512x1024_80k_b16_cityscapes_20200723_192421.log.json) |
+
+### ADE20K
+
+| Method | Backbone           | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                  | download                                                                                                                                                                                                                                                                                                                         |
+| ------ | ------------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ----------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| OCRNet | HRNetV2p-W18-Small | 512x512   |   80000 | 6.7      | 28.98          | V100   | 35.06 |         35.80 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18s_4xb4-80k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_80k_ade20k/ocrnet_hr18s_512x512_80k_ade20k_20200615_055600-e80b62af.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_80k_ade20k/ocrnet_hr18s_512x512_80k_ade20k_20200615_055600.log.json)     |
+| OCRNet | HRNetV2p-W18       | 512x512   |   80000 | 7.9      | 18.93          | V100   | 37.79 |         39.16 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_80k_ade20k/ocrnet_hr18_512x512_80k_ade20k_20200615_053157-d173d83b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_80k_ade20k/ocrnet_hr18_512x512_80k_ade20k_20200615_053157.log.json)         |
+| OCRNet | HRNetV2p-W48       | 512x512   |   80000 | 11.2     | 16.99          | V100   | 43.00 |         44.30 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr48_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_80k_ade20k/ocrnet_hr48_512x512_80k_ade20k_20200615_021518-d168c2d1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_80k_ade20k/ocrnet_hr48_512x512_80k_ade20k_20200615_021518.log.json)         |
+| OCRNet | HRNetV2p-W18-Small | 512x512   |  160000 | -        | -              | V100   | 37.19 |         38.40 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18s_4xb4-80k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_160k_ade20k/ocrnet_hr18s_512x512_160k_ade20k_20200615_184505-8e913058.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_160k_ade20k/ocrnet_hr18s_512x512_160k_ade20k_20200615_184505.log.json) |
+| OCRNet | HRNetV2p-W18       | 512x512   |  160000 | -        | -              | V100   | 39.32 |         40.80 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_160k_ade20k/ocrnet_hr18_512x512_160k_ade20k_20200615_200940-d8fcd9d1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_160k_ade20k/ocrnet_hr18_512x512_160k_ade20k_20200615_200940.log.json)     |
+| OCRNet | HRNetV2p-W48       | 512x512   |  160000 | -        | -              | V100   | 43.25 |         44.88 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr48_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_160k_ade20k/ocrnet_hr48_512x512_160k_ade20k_20200615_184705-a073726d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_160k_ade20k/ocrnet_hr48_512x512_160k_ade20k_20200615_184705.log.json)     |
+
+### Pascal VOC 2012 + Aug
+
+| Method | Backbone           | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                    | download                                                                                                                                                                                                                                                                                                                             |
+| ------ | ------------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| OCRNet | HRNetV2p-W18-Small | 512x512   |   20000 | 3.5      | 31.55          | V100   | 71.70 |         73.84 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18s_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_20k_voc12aug/ocrnet_hr18s_512x512_20k_voc12aug_20200617_233913-02b04fcb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_20k_voc12aug/ocrnet_hr18s_512x512_20k_voc12aug_20200617_233913.log.json) |
+| OCRNet | HRNetV2p-W18       | 512x512   |   20000 | 4.7      | 19.91          | V100   | 74.75 |         77.11 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_20k_voc12aug/ocrnet_hr18_512x512_20k_voc12aug_20200617_233932-8954cbb7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_20k_voc12aug/ocrnet_hr18_512x512_20k_voc12aug_20200617_233932.log.json)     |
+| OCRNet | HRNetV2p-W48       | 512x512   |   20000 | 8.1      | 17.83          | V100   | 77.72 |         79.87 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr48_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_20k_voc12aug/ocrnet_hr48_512x512_20k_voc12aug_20200617_233932-9e82080a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_20k_voc12aug/ocrnet_hr48_512x512_20k_voc12aug_20200617_233932.log.json)     |
+| OCRNet | HRNetV2p-W18-Small | 512x512   |   40000 | -        | -              | V100   | 72.76 |         74.60 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18s_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_40k_voc12aug/ocrnet_hr18s_512x512_40k_voc12aug_20200614_002025-42b587ac.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_40k_voc12aug/ocrnet_hr18s_512x512_40k_voc12aug_20200614_002025.log.json) |
+| OCRNet | HRNetV2p-W18       | 512x512   |   40000 | -        | -              | V100   | 74.98 |         77.40 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_40k_voc12aug/ocrnet_hr18_512x512_40k_voc12aug_20200614_015958-714302be.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_40k_voc12aug/ocrnet_hr18_512x512_40k_voc12aug_20200614_015958.log.json)     |
+| OCRNet | HRNetV2p-W48       | 512x512   |   40000 | -        | -              | V100   | 77.14 |         79.71 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr48_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_40k_voc12aug/ocrnet_hr48_512x512_40k_voc12aug_20200614_015958-255bc5ce.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_40k_voc12aug/ocrnet_hr48_512x512_40k_voc12aug_20200614_015958.log.json)     |
+
+## Citation
+
+```bibtex
+@article{YuanW18,
+  title={Ocnet: Object context network for scene parsing},
+  author={Yuhui Yuan and Jingdong Wang},
+  booktitle={arXiv preprint arXiv:1809.00916},
+  year={2018}
+}
+
+@article{YuanCW20,
+  title={Object-Contextual Representations for Semantic Segmentation},
+  author={Yuhui Yuan and Xilin Chen and Jingdong Wang},
+  booktitle={ECCV},
+  year={2020}
+}
+```
diff --git a/mmsegmentation/configs/ocrnet/metafile.yaml b/mmsegmentation/configs/ocrnet/metafile.yaml
new file mode 100644
index 0000000..5467feb
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/metafile.yaml
@@ -0,0 +1,577 @@
+Collections:
+- Name: OCRNet
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+    - '# HRNet backbone'
+    - '# ResNet backbone'
+    - ADE20K
+    - Pascal VOC 2012 + Aug
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  README: configs/ocrnet/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: ocrnet_hr18s_4xb2-40k_cityscapes-512x1024
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: '# HRNet backbone'
+    Metrics:
+      mIoU: 76.61
+      mIoU(ms+flip): 78.01
+  Config: configs/ocrnet/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: '# HRNet backbone'
+    Batch Size: 8
+    Architecture:
+    - HRNetV2p-W18-Small
+    - OCRNet
+    Training Resources: 4x A100 GPUS
+    Memory (GB): 3.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024_20230227_145026-6c052a14.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024_20230227_145026.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
+- Name: ocrnet_hr18_4xb2-40k_cityscapes-512x1024
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: '# HRNet backbone'
+    Metrics:
+      mIoU: 77.72
+      mIoU(ms+flip): 79.49
+  Config: configs/ocrnet/ocrnet_hr18_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: '# HRNet backbone'
+    Batch Size: 8
+    Architecture:
+    - HRNetV2p-W18
+    - OCRNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 4.7
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_40k_cityscapes/ocrnet_hr18_512x1024_40k_cityscapes_20200601_033320-401c5bdd.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_40k_cityscapes/ocrnet_hr18_512x1024_40k_cityscapes_20200601_033320.log.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
+- Name: ocrnet_hr48_4xb2-40k_cityscapes-512x1024
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: '# HRNet backbone'
+    Metrics:
+      mIoU: 80.58
+      mIoU(ms+flip): 81.79
+  Config: configs/ocrnet/ocrnet_hr48_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: '# HRNet backbone'
+    Batch Size: 8
+    Architecture:
+    - HRNetV2p-W48
+    - OCRNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_40k_cityscapes/ocrnet_hr48_512x1024_40k_cityscapes_20200601_033336-55b32491.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_40k_cityscapes/ocrnet_hr48_512x1024_40k_cityscapes_20200601_033336.log.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
+- Name: ocrnet_hr18s_4xb2-80k_cityscapes-512x1024
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: '# HRNet backbone'
+    Metrics:
+      mIoU: 77.16
+      mIoU(ms+flip): 78.66
+  Config: configs/ocrnet/ocrnet_hr18s_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: '# HRNet backbone'
+    Batch Size: 8
+    Architecture:
+    - HRNetV2p-W18-Small
+    - OCRNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x1024_80k_cityscapes/ocrnet_hr18s_512x1024_80k_cityscapes_20200601_222735-55979e63.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x1024_80k_cityscapes/ocrnet_hr18s_512x1024_80k_cityscapes_20200601_222735.log.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
+- Name: ocrnet_hr18_4xb2-80k_cityscapes-512x1024
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: '# HRNet backbone'
+    Metrics:
+      mIoU: 78.57
+      mIoU(ms+flip): 80.46
+  Config: configs/ocrnet/ocrnet_hr18_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: '# HRNet backbone'
+    Batch Size: 8
+    Architecture:
+    - HRNetV2p-W18
+    - OCRNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_80k_cityscapes/ocrnet_hr18_512x1024_80k_cityscapes_20200614_230521-c2e1dd4a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_80k_cityscapes/ocrnet_hr18_512x1024_80k_cityscapes_20200614_230521.log.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
+- Name: ocrnet_hr48_4xb2-80k_cityscapes-512x1024
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: '# HRNet backbone'
+    Metrics:
+      mIoU: 80.7
+      mIoU(ms+flip): 81.87
+  Config: configs/ocrnet/ocrnet_hr48_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: '# HRNet backbone'
+    Batch Size: 8
+    Architecture:
+    - HRNetV2p-W48
+    - OCRNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_80k_cityscapes/ocrnet_hr48_512x1024_80k_cityscapes_20200601_222752-9076bcdf.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_80k_cityscapes/ocrnet_hr48_512x1024_80k_cityscapes_20200601_222752.log.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
+- Name: ocrnet_hr18s_4xb2-160k_cityscapes-512x1024
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: '# HRNet backbone'
+    Metrics:
+      mIoU: 78.45
+      mIoU(ms+flip): 79.97
+  Config: configs/ocrnet/ocrnet_hr18s_4xb2-160k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: '# HRNet backbone'
+    Batch Size: 8
+    Architecture:
+    - HRNetV2p-W18-Small
+    - OCRNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x1024_160k_cityscapes/ocrnet_hr18s_512x1024_160k_cityscapes_20200602_191005-f4a7af28.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x1024_160k_cityscapes/ocrnet_hr18s_512x1024_160k_cityscapes_20200602_191005.log.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
+- Name: ocrnet_hr18_4xb2-160k_cityscapes-512x1024
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: '# HRNet backbone'
+    Metrics:
+      mIoU: 79.47
+      mIoU(ms+flip): 80.91
+  Config: configs/ocrnet/ocrnet_hr18_4xb2-160k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: '# HRNet backbone'
+    Batch Size: 8
+    Architecture:
+    - HRNetV2p-W18
+    - OCRNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_160k_cityscapes/ocrnet_hr18_512x1024_160k_cityscapes_20200602_191001-b9172d0c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_160k_cityscapes/ocrnet_hr18_512x1024_160k_cityscapes_20200602_191001.log.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
+- Name: ocrnet_hr48_4xb2-160k_cityscapes-512x1024
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: '# HRNet backbone'
+    Metrics:
+      mIoU: 81.35
+      mIoU(ms+flip): 82.7
+  Config: configs/ocrnet/ocrnet_hr48_4xb2-160k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: '# HRNet backbone'
+    Batch Size: 8
+    Architecture:
+    - HRNetV2p-W48
+    - OCRNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_160k_cityscapes/ocrnet_hr48_512x1024_160k_cityscapes_20200602_191037-dfbf1b0c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_160k_cityscapes/ocrnet_hr48_512x1024_160k_cityscapes_20200602_191037.log.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
+- Name: ocrnet_r101-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: '# ResNet backbone'
+    Metrics:
+      mIoU: 80.09
+  Config: configs/ocrnet/ocrnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: '# ResNet backbone'
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - OCRNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_40k_b8_cityscapes/ocrnet_r101-d8_512x1024_40k_b8_cityscapes_20200717_110721-02ac0f13.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_40k_b8_cityscapes/ocrnet_r101-d8_512x1024_40k_b8_cityscapes_20200717_110721.log.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
+- Name: ocrnet_r101-d8_8xb2-40k_cityscapes-512x1024
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: '# ResNet backbone'
+    Metrics:
+      mIoU: 80.3
+  Config: configs/ocrnet/ocrnet_r101-d8_8xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: '# ResNet backbone'
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - OCRNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 8.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_40k_b16_cityscapes/ocrnet_r101-d8_512x1024_40k_b16_cityscapes_20200723_193726-db500f80.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_40k_b16_cityscapes/ocrnet_r101-d8_512x1024_40k_b16_cityscapes_20200723_193726.log.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
+- Name: ocrnet_r101-d8_8xb2-80k_cityscapes-512x1024
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: '# ResNet backbone'
+    Metrics:
+      mIoU: 80.81
+  Config: configs/ocrnet/ocrnet_r101-d8_8xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: '# ResNet backbone'
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - OCRNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 8.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_80k_b16_cityscapes/ocrnet_r101-d8_512x1024_80k_b16_cityscapes_20200723_192421-78688424.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_80k_b16_cityscapes/ocrnet_r101-d8_512x1024_80k_b16_cityscapes_20200723_192421.log.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
+- Name: ocrnet_hr18s_4xb4-80k_ade20k-512x512
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 35.06
+      mIoU(ms+flip): 35.8
+  Config: configs/ocrnet/ocrnet_hr18s_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18-Small
+    - OCRNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.7
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_80k_ade20k/ocrnet_hr18s_512x512_80k_ade20k_20200615_055600-e80b62af.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_80k_ade20k/ocrnet_hr18s_512x512_80k_ade20k_20200615_055600.log.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
+- Name: ocrnet_hr18_4xb4-80k_ade20k-512x512
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 37.79
+      mIoU(ms+flip): 39.16
+  Config: configs/ocrnet/ocrnet_hr18_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18
+    - OCRNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 7.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_80k_ade20k/ocrnet_hr18_512x512_80k_ade20k_20200615_053157-d173d83b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_80k_ade20k/ocrnet_hr18_512x512_80k_ade20k_20200615_053157.log.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
+- Name: ocrnet_hr48_4xb4-80k_ade20k-512x512
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 43.0
+      mIoU(ms+flip): 44.3
+  Config: configs/ocrnet/ocrnet_hr48_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W48
+    - OCRNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 11.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_80k_ade20k/ocrnet_hr48_512x512_80k_ade20k_20200615_021518-d168c2d1.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_80k_ade20k/ocrnet_hr48_512x512_80k_ade20k_20200615_021518.log.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
+- Name: ocrnet_hr18s_4xb4-80k_ade20k-512x512
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 37.19
+      mIoU(ms+flip): 38.4
+  Config: configs/ocrnet/ocrnet_hr18s_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18-Small
+    - OCRNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_160k_ade20k/ocrnet_hr18s_512x512_160k_ade20k_20200615_184505-8e913058.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_160k_ade20k/ocrnet_hr18s_512x512_160k_ade20k_20200615_184505.log.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
+- Name: ocrnet_hr18_4xb4-80k_ade20k-512x512
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 39.32
+      mIoU(ms+flip): 40.8
+  Config: configs/ocrnet/ocrnet_hr18_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18
+    - OCRNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_160k_ade20k/ocrnet_hr18_512x512_160k_ade20k_20200615_200940-d8fcd9d1.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_160k_ade20k/ocrnet_hr18_512x512_160k_ade20k_20200615_200940.log.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
+- Name: ocrnet_hr48_4xb4-160k_ade20k-512x512
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 43.25
+      mIoU(ms+flip): 44.88
+  Config: configs/ocrnet/ocrnet_hr48_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W48
+    - OCRNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_160k_ade20k/ocrnet_hr48_512x512_160k_ade20k_20200615_184705-a073726d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_160k_ade20k/ocrnet_hr48_512x512_160k_ade20k_20200615_184705.log.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
+- Name: ocrnet_hr18s_4xb4-20k_voc12aug-512x512
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 71.7
+      mIoU(ms+flip): 73.84
+  Config: configs/ocrnet/ocrnet_hr18s_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18-Small
+    - OCRNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 3.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_20k_voc12aug/ocrnet_hr18s_512x512_20k_voc12aug_20200617_233913-02b04fcb.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_20k_voc12aug/ocrnet_hr18s_512x512_20k_voc12aug_20200617_233913.log.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
+- Name: ocrnet_hr18_4xb4-20k_voc12aug-512x512
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 74.75
+      mIoU(ms+flip): 77.11
+  Config: configs/ocrnet/ocrnet_hr18_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18
+    - OCRNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 4.7
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_20k_voc12aug/ocrnet_hr18_512x512_20k_voc12aug_20200617_233932-8954cbb7.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_20k_voc12aug/ocrnet_hr18_512x512_20k_voc12aug_20200617_233932.log.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
+- Name: ocrnet_hr48_4xb4-20k_voc12aug-512x512
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 77.72
+      mIoU(ms+flip): 79.87
+  Config: configs/ocrnet/ocrnet_hr48_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W48
+    - OCRNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_20k_voc12aug/ocrnet_hr48_512x512_20k_voc12aug_20200617_233932-9e82080a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_20k_voc12aug/ocrnet_hr48_512x512_20k_voc12aug_20200617_233932.log.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
+- Name: ocrnet_hr18s_4xb4-40k_voc12aug-512x512
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 72.76
+      mIoU(ms+flip): 74.6
+  Config: configs/ocrnet/ocrnet_hr18s_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18-Small
+    - OCRNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_40k_voc12aug/ocrnet_hr18s_512x512_40k_voc12aug_20200614_002025-42b587ac.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_40k_voc12aug/ocrnet_hr18s_512x512_40k_voc12aug_20200614_002025.log.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
+- Name: ocrnet_hr18_4xb4-40k_voc12aug-512x512
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 74.98
+      mIoU(ms+flip): 77.4
+  Config: configs/ocrnet/ocrnet_hr18_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W18
+    - OCRNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_40k_voc12aug/ocrnet_hr18_512x512_40k_voc12aug_20200614_015958-714302be.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_40k_voc12aug/ocrnet_hr18_512x512_40k_voc12aug_20200614_015958.log.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
+- Name: ocrnet_hr48_4xb4-40k_voc12aug-512x512
+  In Collection: OCRNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 77.14
+      mIoU(ms+flip): 79.71
+  Config: configs/ocrnet/ocrnet_hr48_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - HRNetV2p-W48
+    - OCRNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_40k_voc12aug/ocrnet_hr48_512x512_40k_voc12aug_20200614_015958-255bc5ce.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_40k_voc12aug/ocrnet_hr48_512x512_40k_voc12aug_20200614_015958.log.json
+  Paper:
+    Title: Object-Contextual Representations for Semantic Segmentation
+    URL: https://arxiv.org/abs/1909.11065
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-160k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-160k_cityscapes-512x1024.py
new file mode 100644
index 0000000..659217c
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-160k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/ocrnet_hr18.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..d401c4b
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/ocrnet_hr18.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..44426a2
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/ocrnet_hr18.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..353005b
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,39 @@
+_base_ = [
+    '../_base_/models/ocrnet_hr18.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=[
+        dict(
+            type='FCNHead',
+            in_channels=[18, 36, 72, 144],
+            channels=sum([18, 36, 72, 144]),
+            in_index=(0, 1, 2, 3),
+            input_transform='resize_concat',
+            kernel_size=1,
+            num_convs=1,
+            concat_input=False,
+            dropout_ratio=-1,
+            num_classes=150,
+            norm_cfg=norm_cfg,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='OCRHead',
+            in_channels=[18, 36, 72, 144],
+            in_index=(0, 1, 2, 3),
+            input_transform='resize_concat',
+            channels=512,
+            ocr_channels=256,
+            dropout_ratio=-1,
+            num_classes=150,
+            norm_cfg=norm_cfg,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    ])
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..c696c21
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,40 @@
+_base_ = [
+    '../_base_/models/ocrnet_hr18.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_20k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=[
+        dict(
+            type='FCNHead',
+            in_channels=[18, 36, 72, 144],
+            channels=sum([18, 36, 72, 144]),
+            in_index=(0, 1, 2, 3),
+            input_transform='resize_concat',
+            kernel_size=1,
+            num_convs=1,
+            concat_input=False,
+            dropout_ratio=-1,
+            num_classes=21,
+            norm_cfg=norm_cfg,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='OCRHead',
+            in_channels=[18, 36, 72, 144],
+            in_index=(0, 1, 2, 3),
+            input_transform='resize_concat',
+            channels=512,
+            ocr_channels=256,
+            dropout_ratio=-1,
+            num_classes=21,
+            norm_cfg=norm_cfg,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    ])
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..c6b69ea
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,40 @@
+_base_ = [
+    '../_base_/models/ocrnet_hr18.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=[
+        dict(
+            type='FCNHead',
+            in_channels=[18, 36, 72, 144],
+            channels=sum([18, 36, 72, 144]),
+            in_index=(0, 1, 2, 3),
+            input_transform='resize_concat',
+            kernel_size=1,
+            num_convs=1,
+            concat_input=False,
+            dropout_ratio=-1,
+            num_classes=21,
+            norm_cfg=norm_cfg,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='OCRHead',
+            in_channels=[18, 36, 72, 144],
+            in_index=(0, 1, 2, 3),
+            input_transform='resize_concat',
+            channels=512,
+            ocr_channels=256,
+            dropout_ratio=-1,
+            num_classes=21,
+            norm_cfg=norm_cfg,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    ])
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..ceca8df
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,39 @@
+_base_ = [
+    '../_base_/models/ocrnet_hr18.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=[
+        dict(
+            type='FCNHead',
+            in_channels=[18, 36, 72, 144],
+            channels=sum([18, 36, 72, 144]),
+            in_index=(0, 1, 2, 3),
+            input_transform='resize_concat',
+            kernel_size=1,
+            num_convs=1,
+            concat_input=False,
+            dropout_ratio=-1,
+            num_classes=150,
+            norm_cfg=norm_cfg,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='OCRHead',
+            in_channels=[18, 36, 72, 144],
+            in_index=(0, 1, 2, 3),
+            input_transform='resize_concat',
+            channels=512,
+            ocr_channels=256,
+            dropout_ratio=-1,
+            num_classes=150,
+            norm_cfg=norm_cfg,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    ])
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-160k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-160k_cityscapes-512x1024.py
new file mode 100644
index 0000000..c5388fb
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-160k_cityscapes-512x1024.py
@@ -0,0 +1,9 @@
+_base_ = './ocrnet_hr18_4xb2-160k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w18_small',
+    backbone=dict(
+        extra=dict(
+            stage1=dict(num_blocks=(2, )),
+            stage2=dict(num_blocks=(2, 2)),
+            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
+            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..2335f3b
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,9 @@
+_base_ = './ocrnet_hr18_4xb2-40k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w18_small',
+    backbone=dict(
+        extra=dict(
+            stage1=dict(num_blocks=(2, )),
+            stage2=dict(num_blocks=(2, 2)),
+            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
+            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..b2d1a8f
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,9 @@
+_base_ = './ocrnet_hr18_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w18_small',
+    backbone=dict(
+        extra=dict(
+            stage1=dict(num_blocks=(2, )),
+            stage2=dict(num_blocks=(2, 2)),
+            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
+            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..fabf582
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,9 @@
+_base_ = './ocrnet_hr18_4xb4-160k_ade20k-512x512.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w18_small',
+    backbone=dict(
+        extra=dict(
+            stage1=dict(num_blocks=(2, )),
+            stage2=dict(num_blocks=(2, 2)),
+            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
+            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..0eca655
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,9 @@
+_base_ = './ocrnet_hr18_4xb4-20k_voc12aug-512x512.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w18_small',
+    backbone=dict(
+        extra=dict(
+            stage1=dict(num_blocks=(2, )),
+            stage2=dict(num_blocks=(2, 2)),
+            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
+            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..13b02b9
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,9 @@
+_base_ = './ocrnet_hr18_4xb4-40k_voc12aug-512x512.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w18_small',
+    backbone=dict(
+        extra=dict(
+            stage1=dict(num_blocks=(2, )),
+            stage2=dict(num_blocks=(2, 2)),
+            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
+            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..60c79c2
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,9 @@
+_base_ = './ocrnet_hr18_4xb4-80k_ade20k-512x512.py'
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w18_small',
+    backbone=dict(
+        extra=dict(
+            stage1=dict(num_blocks=(2, )),
+            stage2=dict(num_blocks=(2, 2)),
+            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
+            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-160k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-160k_cityscapes-512x1024.py
new file mode 100644
index 0000000..184d38d
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-160k_cityscapes-512x1024.py
@@ -0,0 +1,39 @@
+_base_ = './ocrnet_hr18_4xb2-160k_cityscapes-512x1024.py'
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        extra=dict(
+            stage2=dict(num_channels=(48, 96)),
+            stage3=dict(num_channels=(48, 96, 192)),
+            stage4=dict(num_channels=(48, 96, 192, 384)))),
+    decode_head=[
+        dict(
+            type='FCNHead',
+            in_channels=[48, 96, 192, 384],
+            channels=sum([48, 96, 192, 384]),
+            input_transform='resize_concat',
+            in_index=(0, 1, 2, 3),
+            kernel_size=1,
+            num_convs=1,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            dropout_ratio=-1,
+            num_classes=19,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='OCRHead',
+            in_channels=[48, 96, 192, 384],
+            channels=512,
+            ocr_channels=256,
+            input_transform='resize_concat',
+            in_index=(0, 1, 2, 3),
+            norm_cfg=norm_cfg,
+            dropout_ratio=-1,
+            num_classes=19,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
+    ])
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..7025ee9
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,39 @@
+_base_ = './ocrnet_hr18_4xb2-40k_cityscapes-512x1024.py'
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        extra=dict(
+            stage2=dict(num_channels=(48, 96)),
+            stage3=dict(num_channels=(48, 96, 192)),
+            stage4=dict(num_channels=(48, 96, 192, 384)))),
+    decode_head=[
+        dict(
+            type='FCNHead',
+            in_channels=[48, 96, 192, 384],
+            channels=sum([48, 96, 192, 384]),
+            input_transform='resize_concat',
+            in_index=(0, 1, 2, 3),
+            kernel_size=1,
+            num_convs=1,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            dropout_ratio=-1,
+            num_classes=19,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='OCRHead',
+            in_channels=[48, 96, 192, 384],
+            channels=512,
+            ocr_channels=256,
+            input_transform='resize_concat',
+            in_index=(0, 1, 2, 3),
+            norm_cfg=norm_cfg,
+            dropout_ratio=-1,
+            num_classes=19,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
+    ])
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..9c68a15
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,39 @@
+_base_ = './ocrnet_hr18_4xb2-80k_cityscapes-512x1024.py'
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        extra=dict(
+            stage2=dict(num_channels=(48, 96)),
+            stage3=dict(num_channels=(48, 96, 192)),
+            stage4=dict(num_channels=(48, 96, 192, 384)))),
+    decode_head=[
+        dict(
+            type='FCNHead',
+            in_channels=[48, 96, 192, 384],
+            channels=sum([48, 96, 192, 384]),
+            input_transform='resize_concat',
+            in_index=(0, 1, 2, 3),
+            kernel_size=1,
+            num_convs=1,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            dropout_ratio=-1,
+            num_classes=19,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='OCRHead',
+            in_channels=[48, 96, 192, 384],
+            channels=512,
+            ocr_channels=256,
+            input_transform='resize_concat',
+            in_index=(0, 1, 2, 3),
+            norm_cfg=norm_cfg,
+            dropout_ratio=-1,
+            num_classes=19,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
+    ])
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..e74976c
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,39 @@
+_base_ = './ocrnet_hr18_4xb4-160k_ade20k-512x512.py'
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        extra=dict(
+            stage2=dict(num_channels=(48, 96)),
+            stage3=dict(num_channels=(48, 96, 192)),
+            stage4=dict(num_channels=(48, 96, 192, 384)))),
+    decode_head=[
+        dict(
+            type='FCNHead',
+            in_channels=[48, 96, 192, 384],
+            channels=sum([48, 96, 192, 384]),
+            input_transform='resize_concat',
+            in_index=(0, 1, 2, 3),
+            kernel_size=1,
+            num_convs=1,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            dropout_ratio=-1,
+            num_classes=150,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='OCRHead',
+            in_channels=[48, 96, 192, 384],
+            channels=512,
+            ocr_channels=256,
+            input_transform='resize_concat',
+            in_index=(0, 1, 2, 3),
+            norm_cfg=norm_cfg,
+            dropout_ratio=-1,
+            num_classes=150,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
+    ])
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..f015b92
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,39 @@
+_base_ = './ocrnet_hr18_4xb4-20k_voc12aug-512x512.py'
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        extra=dict(
+            stage2=dict(num_channels=(48, 96)),
+            stage3=dict(num_channels=(48, 96, 192)),
+            stage4=dict(num_channels=(48, 96, 192, 384)))),
+    decode_head=[
+        dict(
+            type='FCNHead',
+            in_channels=[48, 96, 192, 384],
+            channels=sum([48, 96, 192, 384]),
+            input_transform='resize_concat',
+            in_index=(0, 1, 2, 3),
+            kernel_size=1,
+            num_convs=1,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            dropout_ratio=-1,
+            num_classes=21,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='OCRHead',
+            in_channels=[48, 96, 192, 384],
+            channels=512,
+            ocr_channels=256,
+            input_transform='resize_concat',
+            in_index=(0, 1, 2, 3),
+            norm_cfg=norm_cfg,
+            dropout_ratio=-1,
+            num_classes=21,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
+    ])
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..baafa38
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,39 @@
+_base_ = './ocrnet_hr18_4xb4-40k_voc12aug-512x512.py'
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        extra=dict(
+            stage2=dict(num_channels=(48, 96)),
+            stage3=dict(num_channels=(48, 96, 192)),
+            stage4=dict(num_channels=(48, 96, 192, 384)))),
+    decode_head=[
+        dict(
+            type='FCNHead',
+            in_channels=[48, 96, 192, 384],
+            channels=sum([48, 96, 192, 384]),
+            input_transform='resize_concat',
+            in_index=(0, 1, 2, 3),
+            kernel_size=1,
+            num_convs=1,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            dropout_ratio=-1,
+            num_classes=21,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='OCRHead',
+            in_channels=[48, 96, 192, 384],
+            channels=512,
+            ocr_channels=256,
+            input_transform='resize_concat',
+            in_index=(0, 1, 2, 3),
+            norm_cfg=norm_cfg,
+            dropout_ratio=-1,
+            num_classes=21,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
+    ])
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..85514b9
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,39 @@
+_base_ = './ocrnet_hr18_4xb4-80k_ade20k-512x512.py'
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        extra=dict(
+            stage2=dict(num_channels=(48, 96)),
+            stage3=dict(num_channels=(48, 96, 192)),
+            stage4=dict(num_channels=(48, 96, 192, 384)))),
+    decode_head=[
+        dict(
+            type='FCNHead',
+            in_channels=[48, 96, 192, 384],
+            channels=sum([48, 96, 192, 384]),
+            input_transform='resize_concat',
+            in_index=(0, 1, 2, 3),
+            kernel_size=1,
+            num_convs=1,
+            norm_cfg=norm_cfg,
+            concat_input=False,
+            dropout_ratio=-1,
+            num_classes=150,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='OCRHead',
+            in_channels=[48, 96, 192, 384],
+            channels=512,
+            ocr_channels=256,
+            input_transform='resize_concat',
+            in_index=(0, 1, 2, 3),
+            norm_cfg=norm_cfg,
+            dropout_ratio=-1,
+            num_classes=150,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
+    ])
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..a94597b
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/ocrnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet101_v1c',
+    backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_r101-d8_8xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_r101-d8_8xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..88e5ad0
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_r101-d8_8xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,21 @@
+_base_ = [
+    '../_base_/models/ocrnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet101_v1c',
+    backbone=dict(depth=101))
+optimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=2e-4,
+        power=0.9,
+        begin=0,
+        end=40000,
+        by_epoch=False)
+]
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_r101-d8_8xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_r101-d8_8xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..a3b4209
--- /dev/null
+++ b/mmsegmentation/configs/ocrnet/ocrnet_r101-d8_8xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,21 @@
+_base_ = [
+    '../_base_/models/ocrnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet101_v1c',
+    backbone=dict(depth=101))
+optimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=2e-4,
+        power=0.9,
+        begin=0,
+        end=40000,
+        by_epoch=False)
+]
diff --git a/mmsegmentation/configs/pidnet/README.md b/mmsegmentation/configs/pidnet/README.md
new file mode 100644
index 0000000..e23efbd
--- /dev/null
+++ b/mmsegmentation/configs/pidnet/README.md
@@ -0,0 +1,50 @@
+# PIDNet
+
+> [PIDNet: A Real-time Semantic Segmentation Network Inspired from PID Controller](https://arxiv.org/pdf/2206.02066.pdf)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/XuJiacong/PIDNet">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/backbones/pidnet.py">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Two-branch network architecture has shown its efficiency and effectiveness for real-time semantic segmentation tasks. However, direct fusion of low-level details and high-level semantics will lead to a phenomenon that the detailed features are easily overwhelmed by surrounding contextual information, namely overshoot in this paper, which limits the improvement of the accuracy of existed two-branch models. In this paper, we bridge a connection between Convolutional Neural Network (CNN) and Proportional-IntegralDerivative (PID) controller and reveal that the two-branch network is nothing but a Proportional-Integral (PI) controller, which inherently suffers from the similar overshoot issue. To alleviate this issue, we propose a novel threebranch network architecture: PIDNet, which possesses three branches to parse the detailed, context and boundary information (derivative of semantics), respectively, and employs boundary attention to guide the fusion of detailed and context branches in final stage. The family of PIDNets achieve the best trade-off between inference speed and accuracy and their test accuracy surpasses all the existed models with similar inference speed on Cityscapes, CamVid and COCO-Stuff datasets. Especially, PIDNet-S achieves 78.6% mIOU with inference speed of 93.2 FPS on Cityscapes test set and 80.1% mIOU with speed of 153.7 FPS on CamVid test set.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://raw.githubusercontent.com/XuJiacong/PIDNet/main/figs/pidnet.jpg" width="800"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                     | download                                                                                                                                                                                                                                                                                                                                                 |
+| ------ | -------- | --------- | ------- | -------- | -------------- | ------ | ----- | ------------- | -------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| PIDNet | PIDNet-S | 1024x1024 | 120000  | 3.38     | 80.82          | A100   | 78.74 | 80.87         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pidnet/pidnet-s_2xb6-120k_1024x1024-cityscapes.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-s_2xb6-120k_1024x1024-cityscapes/pidnet-s_2xb6-120k_1024x1024-cityscapes_20230302_191700-bb8e3bcc.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-s_2xb6-120k_1024x1024-cityscapes/pidnet-s_2xb6-120k_1024x1024-cityscapes_20230302_191700.json) |
+| PIDNet | PIDNet-M | 1024x1024 | 120000  | 5.14     | 71.98          | A100   | 80.22 | 82.05         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pidnet/pidnet-m_2xb6-120k_1024x1024-cityscapes.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-m_2xb6-120k_1024x1024-cityscapes/pidnet-m_2xb6-120k_1024x1024-cityscapes_20230301_143452-f9bcdbf3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-m_2xb6-120k_1024x1024-cityscapes/pidnet-m_2xb6-120k_1024x1024-cityscapes_20230301_143452.json) |
+| PIDNet | PIDNet-L | 1024x1024 | 120000  | 5.83     | 60.06          | A100   | 80.89 | 82.37         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pidnet/pidnet-l_2xb6-120k_1024x1024-cityscapes.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-l_2xb6-120k_1024x1024-cityscapes/pidnet-l_2xb6-120k_1024x1024-cityscapes_20230303_114514-0783ca6b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-l_2xb6-120k_1024x1024-cityscapes/pidnet-l_2xb6-120k_1024x1024-cityscapes_20230303_114514.json) |
+
+## Notes
+
+The pretrained weights in config files are converted from [the official repo](https://github.com/XuJiacong/PIDNet#models).
+
+## Citation
+
+```bibtex
+@misc{xu2022pidnet,
+      title={PIDNet: A Real-time Semantic Segmentation Network Inspired from PID Controller},
+      author={Jiacong Xu and Zixiang Xiong and Shankar P. Bhattacharyya},
+      year={2022},
+      eprint={2206.02066},
+      archivePrefix={arXiv},
+      primaryClass={cs.CV}
+}
+```
diff --git a/mmsegmentation/configs/pidnet/metafile.yaml b/mmsegmentation/configs/pidnet/metafile.yaml
new file mode 100644
index 0000000..51b514a
--- /dev/null
+++ b/mmsegmentation/configs/pidnet/metafile.yaml
@@ -0,0 +1,85 @@
+Collections:
+- Name: PIDNet
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+  Paper:
+    Title: 'PIDNet: A Real-time Semantic Segmentation Network Inspired from PID Controller'
+    URL: https://arxiv.org/pdf/2206.02066.pdf
+  README: configs/pidnet/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: pidnet-s_2xb6-120k_1024x1024-cityscapes
+  In Collection: PIDNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.74
+      mIoU(ms+flip): 80.87
+  Config: configs/pidnet/pidnet-s_2xb6-120k_1024x1024-cityscapes.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 12
+    Architecture:
+    - PIDNet-S
+    - PIDNet
+    Training Resources: 2x A100 GPUS
+    Memory (GB): 3.38
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-s_2xb6-120k_1024x1024-cityscapes/pidnet-s_2xb6-120k_1024x1024-cityscapes_20230302_191700-bb8e3bcc.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-s_2xb6-120k_1024x1024-cityscapes/pidnet-s_2xb6-120k_1024x1024-cityscapes_20230302_191700.json
+  Paper:
+    Title: 'PIDNet: A Real-time Semantic Segmentation Network Inspired from PID Controller'
+    URL: https://arxiv.org/pdf/2206.02066.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/backbones/pidnet.py
+  Framework: PyTorch
+- Name: pidnet-m_2xb6-120k_1024x1024-cityscapes
+  In Collection: PIDNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 80.22
+      mIoU(ms+flip): 82.05
+  Config: configs/pidnet/pidnet-m_2xb6-120k_1024x1024-cityscapes.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 12
+    Architecture:
+    - PIDNet-M
+    - PIDNet
+    Training Resources: 2x A100 GPUS
+    Memory (GB): 5.14
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-m_2xb6-120k_1024x1024-cityscapes/pidnet-m_2xb6-120k_1024x1024-cityscapes_20230301_143452-f9bcdbf3.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-m_2xb6-120k_1024x1024-cityscapes/pidnet-m_2xb6-120k_1024x1024-cityscapes_20230301_143452.json
+  Paper:
+    Title: 'PIDNet: A Real-time Semantic Segmentation Network Inspired from PID Controller'
+    URL: https://arxiv.org/pdf/2206.02066.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/backbones/pidnet.py
+  Framework: PyTorch
+- Name: pidnet-l_2xb6-120k_1024x1024-cityscapes
+  In Collection: PIDNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 80.89
+      mIoU(ms+flip): 82.37
+  Config: configs/pidnet/pidnet-l_2xb6-120k_1024x1024-cityscapes.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 12
+    Architecture:
+    - PIDNet-L
+    - PIDNet
+    Training Resources: 2x A100 GPUS
+    Memory (GB): 5.83
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-l_2xb6-120k_1024x1024-cityscapes/pidnet-l_2xb6-120k_1024x1024-cityscapes_20230303_114514-0783ca6b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-l_2xb6-120k_1024x1024-cityscapes/pidnet-l_2xb6-120k_1024x1024-cityscapes_20230303_114514.json
+  Paper:
+    Title: 'PIDNet: A Real-time Semantic Segmentation Network Inspired from PID Controller'
+    URL: https://arxiv.org/pdf/2206.02066.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/backbones/pidnet.py
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/pidnet/pidnet-l_2xb6-120k_1024x1024-cityscapes.py b/mmsegmentation/configs/pidnet/pidnet-l_2xb6-120k_1024x1024-cityscapes.py
new file mode 100644
index 0000000..1955c91
--- /dev/null
+++ b/mmsegmentation/configs/pidnet/pidnet-l_2xb6-120k_1024x1024-cityscapes.py
@@ -0,0 +1,10 @@
+_base_ = './pidnet-s_2xb6-120k_1024x1024-cityscapes.py'
+checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/pidnet/pidnet-l_imagenet1k_20230306-67889109.pth'  # noqa
+model = dict(
+    backbone=dict(
+        channels=64,
+        ppm_channels=112,
+        num_stem_blocks=3,
+        num_branch_blocks=4,
+        init_cfg=dict(checkpoint=checkpoint_file)),
+    decode_head=dict(in_channels=256, channels=256))
diff --git a/mmsegmentation/configs/pidnet/pidnet-m_2xb6-120k_1024x1024-cityscapes.py b/mmsegmentation/configs/pidnet/pidnet-m_2xb6-120k_1024x1024-cityscapes.py
new file mode 100644
index 0000000..38a69c1
--- /dev/null
+++ b/mmsegmentation/configs/pidnet/pidnet-m_2xb6-120k_1024x1024-cityscapes.py
@@ -0,0 +1,5 @@
+_base_ = './pidnet-s_2xb6-120k_1024x1024-cityscapes.py'
+checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/pidnet/pidnet-m_imagenet1k_20230306-39893c52.pth'  # noqa
+model = dict(
+    backbone=dict(channels=64, init_cfg=dict(checkpoint=checkpoint_file)),
+    decode_head=dict(in_channels=256))
diff --git a/mmsegmentation/configs/pidnet/pidnet-s_2xb6-120k_1024x1024-cityscapes.py b/mmsegmentation/configs/pidnet/pidnet-s_2xb6-120k_1024x1024-cityscapes.py
new file mode 100644
index 0000000..f70ca42
--- /dev/null
+++ b/mmsegmentation/configs/pidnet/pidnet-s_2xb6-120k_1024x1024-cityscapes.py
@@ -0,0 +1,113 @@
+_base_ = [
+    '../_base_/datasets/cityscapes_1024x1024.py',
+    '../_base_/default_runtime.py'
+]
+
+# The class_weight is borrowed from https://github.com/openseg-group/OCNet.pytorch/issues/14 # noqa
+# Licensed under the MIT License
+class_weight = [
+    0.8373, 0.918, 0.866, 1.0345, 1.0166, 0.9969, 0.9754, 1.0489, 0.8786,
+    1.0023, 0.9539, 0.9843, 1.1116, 0.9037, 1.0865, 1.0955, 1.0865, 1.1529,
+    1.0507
+]
+checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/pidnet/pidnet-s_imagenet1k_20230306-715e6273.pth'  # noqa
+crop_size = (1024, 1024)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255,
+    size=crop_size)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='PIDNet',
+        in_channels=3,
+        channels=32,
+        ppm_channels=96,
+        num_stem_blocks=2,
+        num_branch_blocks=3,
+        align_corners=False,
+        norm_cfg=norm_cfg,
+        act_cfg=dict(type='ReLU', inplace=True),
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file)),
+    decode_head=dict(
+        type='PIDHead',
+        in_channels=128,
+        channels=128,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        act_cfg=dict(type='ReLU', inplace=True),
+        align_corners=True,
+        loss_decode=[
+            dict(
+                type='CrossEntropyLoss',
+                use_sigmoid=False,
+                class_weight=class_weight,
+                loss_weight=0.4),
+            dict(
+                type='OhemCrossEntropy',
+                thres=0.9,
+                min_kept=131072,
+                class_weight=class_weight,
+                loss_weight=1.0),
+            dict(type='BoundaryLoss', loss_weight=20.0),
+            dict(
+                type='OhemCrossEntropy',
+                thres=0.9,
+                min_kept=131072,
+                class_weight=class_weight,
+                loss_weight=1.0)
+        ]),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=(2048, 1024),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='GenerateEdge', edge_width=4),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(batch_size=6, dataset=dict(pipeline=train_pipeline))
+
+iters = 120000
+# optimizer
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=0,
+        power=0.9,
+        begin=0,
+        end=iters,
+        by_epoch=False)
+]
+# training schedule for 120k
+train_cfg = dict(
+    type='IterBasedTrainLoop', max_iters=iters, val_interval=iters // 10)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(
+        type='CheckpointHook', by_epoch=False, interval=iters // 10),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))
+
+randomness = dict(seed=304)
diff --git a/mmsegmentation/configs/point_rend/README.md b/mmsegmentation/configs/point_rend/README.md
new file mode 100644
index 0000000..487d3bc
--- /dev/null
+++ b/mmsegmentation/configs/point_rend/README.md
@@ -0,0 +1,51 @@
+# PointRend
+
+> [PointRend: Image Segmentation as Rendering](https://arxiv.org/abs/1912.08193)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/facebookresearch/detectron2/tree/master/projects/PointRend">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/point_head.py#L36">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+We present a new method for efficient high-quality image segmentation of objects and scenes. By analogizing classical computer graphics methods for efficient rendering with over- and undersampling challenges faced in pixel labeling tasks, we develop a unique perspective of image segmentation as a rendering problem. From this vantage, we present the PointRend (Point-based Rendering) neural network module: a module that performs point-based segmentation predictions at adaptively selected locations based on an iterative subdivision algorithm. PointRend can be flexibly applied to both instance and semantic segmentation tasks by building on top of existing state-of-the-art models. While many concrete implementations of the general idea are possible, we show that a simple design already achieves excellent results. Qualitatively, PointRend outputs crisp object boundaries in regions that are over-smoothed by previous methods. Quantitatively, PointRend yields significant gains on COCO and Cityscapes, for both instance and semantic segmentation. PointRend's efficiency enables output resolutions that are otherwise impractical in terms of memory or computation compared to existing approaches. Code has been made available at [this https URL](https://github.com/facebookresearch/detectron2/tree/main/projects/PointRend).
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142902293-5db49cdd-4b1b-4940-9067-2acd6196c700.png" width="60%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method    | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                             | download                                                                                                                                                                                                                                                                                                                                                         |
+| --------- | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | ---------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| PointRend | R-50     | 512x1024  |   80000 |      3.1 | 8.48           | V100   | 76.47 | 78.13         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/point_rend/pointrend_r50_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r50_512x1024_80k_cityscapes/pointrend_r50_512x1024_80k_cityscapes_20200711_015821-bb1ff523.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r50_512x1024_80k_cityscapes/pointrend_r50_512x1024_80k_cityscapes-20200715_214714.log.json)     |
+| PointRend | R-101    | 512x1024  |   80000 |      4.2 | 7.00           | V100   | 78.30 | 79.97         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/point_rend/pointrend_r101_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r101_512x1024_80k_cityscapes/pointrend_r101_512x1024_80k_cityscapes_20200711_170850-d0ca84be.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r101_512x1024_80k_cityscapes/pointrend_r101_512x1024_80k_cityscapes-20200715_214824.log.json) |
+
+### ADE20K
+
+| Method    | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                         | download                                                                                                                                                                                                                                                                                                                                         |
+| --------- | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | ------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| PointRend | R-50     | 512x512   |  160000 |      5.1 | 17.31          | V100   | 37.64 | 39.17         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/point_rend/pointrend_r50_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r50_512x512_160k_ade20k/pointrend_r50_512x512_160k_ade20k_20200807_232644-ac3febf2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r50_512x512_160k_ade20k/pointrend_r50_512x512_160k_ade20k-20200807_232644.log.json)     |
+| PointRend | R-101    | 512x512   |  160000 |      6.1 | 15.50          | V100   | 40.02 | 41.60         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/point_rend/pointrend_r101_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r101_512x512_160k_ade20k/pointrend_r101_512x512_160k_ade20k_20200808_030852-8834902a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r101_512x512_160k_ade20k/pointrend_r101_512x512_160k_ade20k-20200808_030852.log.json) |
+
+## Citation
+
+```bibtex
+@inproceedings{kirillov2020pointrend,
+  title={Pointrend: Image segmentation as rendering},
+  author={Kirillov, Alexander and Wu, Yuxin and He, Kaiming and Girshick, Ross},
+  booktitle={Proceedings of the IEEE/CVF conference on computer vision and pattern recognition},
+  pages={9799--9808},
+  year={2020}
+}
+```
diff --git a/mmsegmentation/configs/point_rend/metafile.yaml b/mmsegmentation/configs/point_rend/metafile.yaml
new file mode 100644
index 0000000..064717c
--- /dev/null
+++ b/mmsegmentation/configs/point_rend/metafile.yaml
@@ -0,0 +1,110 @@
+Collections:
+- Name: PointRend
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+    - ADE20K
+  Paper:
+    Title: 'PointRend: Image Segmentation as Rendering'
+    URL: https://arxiv.org/abs/1912.08193
+  README: configs/point_rend/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: pointrend_r50_4xb2-80k_cityscapes-512x1024
+  In Collection: PointRend
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.47
+      mIoU(ms+flip): 78.13
+  Config: configs/point_rend/pointrend_r50_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50
+    - PointRend
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 3.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r50_512x1024_80k_cityscapes/pointrend_r50_512x1024_80k_cityscapes_20200711_015821-bb1ff523.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r50_512x1024_80k_cityscapes/pointrend_r50_512x1024_80k_cityscapes-20200715_214714.log.json
+  Paper:
+    Title: 'PointRend: Image Segmentation as Rendering'
+    URL: https://arxiv.org/abs/1912.08193
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/point_head.py#L36
+  Framework: PyTorch
+- Name: pointrend_r101_4xb2-80k_cityscapes-512x1024
+  In Collection: PointRend
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.3
+      mIoU(ms+flip): 79.97
+  Config: configs/point_rend/pointrend_r101_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101
+    - PointRend
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 4.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r101_512x1024_80k_cityscapes/pointrend_r101_512x1024_80k_cityscapes_20200711_170850-d0ca84be.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r101_512x1024_80k_cityscapes/pointrend_r101_512x1024_80k_cityscapes-20200715_214824.log.json
+  Paper:
+    Title: 'PointRend: Image Segmentation as Rendering'
+    URL: https://arxiv.org/abs/1912.08193
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/point_head.py#L36
+  Framework: PyTorch
+- Name: pointrend_r50_4xb4-160k_ade20k-512x512
+  In Collection: PointRend
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 37.64
+      mIoU(ms+flip): 39.17
+  Config: configs/point_rend/pointrend_r50_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50
+    - PointRend
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r50_512x512_160k_ade20k/pointrend_r50_512x512_160k_ade20k_20200807_232644-ac3febf2.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r50_512x512_160k_ade20k/pointrend_r50_512x512_160k_ade20k-20200807_232644.log.json
+  Paper:
+    Title: 'PointRend: Image Segmentation as Rendering'
+    URL: https://arxiv.org/abs/1912.08193
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/point_head.py#L36
+  Framework: PyTorch
+- Name: pointrend_r101_4xb4-160k_ade20k-512x512
+  In Collection: PointRend
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 40.02
+      mIoU(ms+flip): 41.6
+  Config: configs/point_rend/pointrend_r101_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101
+    - PointRend
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r101_512x512_160k_ade20k/pointrend_r101_512x512_160k_ade20k_20200808_030852-8834902a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r101_512x512_160k_ade20k/pointrend_r101_512x512_160k_ade20k-20200808_030852.log.json
+  Paper:
+    Title: 'PointRend: Image Segmentation as Rendering'
+    URL: https://arxiv.org/abs/1912.08193
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/point_head.py#L36
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/point_rend/pointrend_r101_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/point_rend/pointrend_r101_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..ca2a19a
--- /dev/null
+++ b/mmsegmentation/configs/point_rend/pointrend_r101_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './pointrend_r50_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/point_rend/pointrend_r101_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/point_rend/pointrend_r101_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..6729d3b
--- /dev/null
+++ b/mmsegmentation/configs/point_rend/pointrend_r101_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './pointrend_r50_4xb4-160k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/point_rend/pointrend_r50_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/point_rend/pointrend_r50_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..fb005d8
--- /dev/null
+++ b/mmsegmentation/configs/point_rend/pointrend_r50_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,18 @@
+_base_ = [
+    '../_base_/models/pointrend_r50.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
+param_scheduler = [
+    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=200),
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=200,
+        end=80000,
+        by_epoch=False,
+    )
+]
diff --git a/mmsegmentation/configs/point_rend/pointrend_r50_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/point_rend/pointrend_r50_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..d350fa6
--- /dev/null
+++ b/mmsegmentation/configs/point_rend/pointrend_r50_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,46 @@
+_base_ = [
+    '../_base_/models/pointrend_r50.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=[
+        dict(
+            type='FPNHead',
+            in_channels=[256, 256, 256, 256],
+            in_index=[0, 1, 2, 3],
+            feature_strides=[4, 8, 16, 32],
+            channels=128,
+            dropout_ratio=-1,
+            num_classes=150,
+            norm_cfg=norm_cfg,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+        dict(
+            type='PointHead',
+            in_channels=[256],
+            in_index=[0],
+            channels=256,
+            num_fcs=3,
+            coarse_pred_each_layer=True,
+            dropout_ratio=-1,
+            num_classes=150,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
+    ])
+param_scheduler = [
+    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=200),
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=200,
+        end=160000,
+        by_epoch=False,
+    )
+]
diff --git a/mmsegmentation/configs/poolformer/README.md b/mmsegmentation/configs/poolformer/README.md
new file mode 100644
index 0000000..e6e2eac
--- /dev/null
+++ b/mmsegmentation/configs/poolformer/README.md
@@ -0,0 +1,65 @@
+# PoolFormer
+
+> [MetaFormer is Actually What You Need for Vision](https://arxiv.org/abs/2111.11418)
+
+## Introduction
+
+<!-- [BACKBONE] -->
+
+<a href="https://github.com/sail-sg/poolformer/tree/main/segmentation">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmclassification/blob/v0.23.0/mmcls/models/backbones/poolformer.py#L198">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Transformers have shown great potential in computer vision tasks. A common belief is their attention-based token mixer module contributes most to their competence. However, recent works show the attention-based module in transformers can be replaced by spatial MLPs and the resulted models still perform quite well. Based on this observation, we hypothesize that the general architecture of the transformers, instead of the specific token mixer module, is more essential to the model's performance. To verify this, we deliberately replace the attention module in transformers with an embarrassingly simple spatial pooling operator to conduct only the most basic token mixing. Surprisingly, we observe that the derived model, termed as PoolFormer, achieves competitive performance on multiple computer vision tasks. For example, on ImageNet-1K, PoolFormer achieves 82.1% top-1 accuracy, surpassing well-tuned vision transformer/MLP-like baselines DeiT-B/ResMLP-B24 by 0.3%/1.1% accuracy with 35%/52% fewer parameters and 48%/60% fewer MACs. The effectiveness of PoolFormer verifies our hypothesis and urges us to initiate the concept of "MetaFormer", a general architecture abstracted from transformers without specifying the token mixer. Based on the extensive experiments, we argue that MetaFormer is the key player in achieving superior results for recent transformer and MLP-like models on vision tasks. This work calls for more future research dedicated to improving MetaFormer instead of focusing on the token mixer modules. Additionally, our proposed PoolFormer could serve as a starting baseline for future MetaFormer architecture design. Code is available at [this https URL](https://github.com/sail-sg/poolformer)
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/15921929/144710761-1635f59a-abde-4946-984c-a2c3f22a19d2.png" width="70%"/>
+</div>
+
+## Citation
+
+```bibtex
+@inproceedings{yu2022metaformer,
+  title={Metaformer is actually what you need for vision},
+  author={Yu, Weihao and Luo, Mi and Zhou, Pan and Si, Chenyang and Zhou, Yichen and Wang, Xinchao and Feng, Jiashi and Yan, Shuicheng},
+  booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
+  pages={10819--10829},
+  year={2022}
+}
+```
+
+### Usage
+
+- PoolFormer backbone needs to install [MMClassification](https://github.com/open-mmlab/mmclassification) first, which has abundant backbones for downstream tasks.
+
+```shell
+pip install "mmpretrain>=1.0.0rc7"
+```
+
+- The pretrained models could also be downloaded from [PoolFormer config of MMClassification](https://github.com/open-mmlab/mmclassification/tree/master/configs/poolformer).
+
+## Results and models
+
+### ADE20K
+
+| Method | Backbone       | Crop Size | pretrain    | Batch Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | mIoU\* | mIoU\*(ms+flip) | config                                                                                                                            | download                                                                                                                                                                                                                                                                                                                                                                     |
+| ------ | -------------- | --------- | ----------- | ---------- | ------- | -------- | -------------- | ------ | ----- | ------------: | ------ | --------------: | --------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FPN    | PoolFormer-S12 | 512x512   | ImageNet-1K | 32         | 40000   | 4.17     | 23.48          | V100   | 36.68 |             - | 37.07  |               - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/poolformer/fpn_poolformer_s12_8xb4-40k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s12_8x4_512x512_40k_ade20k/fpn_poolformer_s12_8x4_512x512_40k_ade20k_20220501_115154-b5aa2f49.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s12_8x4_512x512_40k_ade20k/fpn_poolformer_s12_8x4_512x512_40k_ade20k_20220501_115154.log.json) |
+| FPN    | PoolFormer-S24 | 512x512   | ImageNet-1K | 32         | 40000   | 5.47     | 15.74          | V100   | 40.12 |             - | 40.36  |               - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/poolformer/fpn_poolformer_s24_8xb4-40k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s24_8x4_512x512_40k_ade20k/fpn_poolformer_s24_8x4_512x512_40k_ade20k_20220503_222049-394a7cf7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s24_8x4_512x512_40k_ade20k/fpn_poolformer_s24_8x4_512x512_40k_ade20k_20220503_222049.log.json) |
+| FPN    | PoolFormer-S36 | 512x512   | ImageNet-1K | 32         | 40000   | 6.77     | 11.34          | V100   | 41.61 |             - | 41.81  |               - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/poolformer/fpn_poolformer_s36_8xb4-40k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s36_8x4_512x512_40k_ade20k/fpn_poolformer_s36_8x4_512x512_40k_ade20k_20220501_151122-b47e607d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s36_8x4_512x512_40k_ade20k/fpn_poolformer_s36_8x4_512x512_40k_ade20k_20220501_151122.log.json) |
+| FPN    | PoolFormer-M36 | 512x512   | ImageNet-1K | 32         | 40000   | 8.59     | 8.97           | V100   | 41.95 |             - | 42.35  |               - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/poolformer/fpn_poolformer_m36_8xb4-40k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_m36_8x4_512x512_40k_ade20k/fpn_poolformer_m36_8x4_512x512_40k_ade20k_20220501_164230-3dc83921.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_m36_8x4_512x512_40k_ade20k/fpn_poolformer_m36_8x4_512x512_40k_ade20k_20220501_164230.log.json) |
+| FPN    | PoolFormer-M48 | 512x512   | ImageNet-1K | 32         | 40000   | 10.48    | 6.69           | V100   | 42.43 |             - | 42.76  |               - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/poolformer/fpn_poolformer_m48_8xb4-40k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_m48_8x4_512x512_40k_ade20k/fpn_poolformer_m48_8x4_512x512_40k_ade20k_20220504_003923-64168d3b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_m48_8x4_512x512_40k_ade20k/fpn_poolformer_m48_8x4_512x512_40k_ade20k_20220504_003923.log.json) |
+
+Note:
+
+- We replace `AlignedResize` in original PoolFormer implementation to `Resize + ResizeToMultiple`.
+
+- `mIoU` with * is collected when `Resize + ResizeToMultiple` is adopted in `test_pipeline`, so do `mIoU` in logs.
+
+- The Test Time Augmentation i.e., "ms+flip" in MMSegmentation v1.x is developing, stay tuned!
diff --git a/mmsegmentation/configs/poolformer/fpn_poolformer_m36_8xb4-40k_ade20k-512x512.py b/mmsegmentation/configs/poolformer/fpn_poolformer_m36_8xb4-40k_ade20k-512x512.py
new file mode 100644
index 0000000..4100eb9
--- /dev/null
+++ b/mmsegmentation/configs/poolformer/fpn_poolformer_m36_8xb4-40k_ade20k-512x512.py
@@ -0,0 +1,11 @@
+_base_ = './fpn_poolformer_s12_8xb4-40k_ade20k-512x512.py'
+checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/poolformer/poolformer-m36_3rdparty_32xb128_in1k_20220414-c55e0949.pth'  # noqa
+
+# model settings
+model = dict(
+    backbone=dict(
+        arch='m36',
+        init_cfg=dict(
+            type='Pretrained', checkpoint=checkpoint_file,
+            prefix='backbone.')),
+    neck=dict(in_channels=[96, 192, 384, 768]))
diff --git a/mmsegmentation/configs/poolformer/fpn_poolformer_m48_8xb4-40k_ade20k-512x512.py b/mmsegmentation/configs/poolformer/fpn_poolformer_m48_8xb4-40k_ade20k-512x512.py
new file mode 100644
index 0000000..cfc49cc
--- /dev/null
+++ b/mmsegmentation/configs/poolformer/fpn_poolformer_m48_8xb4-40k_ade20k-512x512.py
@@ -0,0 +1,11 @@
+_base_ = './fpn_poolformer_s12_8xb4-40k_ade20k-512x512.py'
+checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/poolformer/poolformer-m48_3rdparty_32xb128_in1k_20220414-9378f3eb.pth'  # noqa
+
+# model settings
+model = dict(
+    backbone=dict(
+        arch='m48',
+        init_cfg=dict(
+            type='Pretrained', checkpoint=checkpoint_file,
+            prefix='backbone.')),
+    neck=dict(in_channels=[96, 192, 384, 768]))
diff --git a/mmsegmentation/configs/poolformer/fpn_poolformer_s12_8xb4-40k_ade20k-512x512.py b/mmsegmentation/configs/poolformer/fpn_poolformer_s12_8xb4-40k_ade20k-512x512.py
new file mode 100644
index 0000000..c0b1531
--- /dev/null
+++ b/mmsegmentation/configs/poolformer/fpn_poolformer_s12_8xb4-40k_ade20k-512x512.py
@@ -0,0 +1,91 @@
+_base_ = [
+    '../_base_/models/fpn_poolformer_s12.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+
+# dataset settings
+dataset_type = 'ADE20KDataset'
+data_root = 'data/ade/ADEChallengeData2016'
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(
+        type='RandomResize',
+        scale=(2048, 512),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+    dict(type='ResizeToMultiple', size_divisor=32),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='PackSegInputs')
+]
+
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type='RepeatDataset',
+        times=50,
+        dataset=dict(
+            type=dataset_type,
+            data_root=data_root,
+            data_prefix=dict(
+                img_path='images/training',
+                seg_map_path='annotations/training'),
+            pipeline=train_pipeline)))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
+
+# model settings
+model = dict(
+    data_preprocessor=data_preprocessor,
+    neck=dict(in_channels=[64, 128, 320, 512]),
+    decode_head=dict(num_classes=150))
+
+# optimizer
+# optimizer = dict(_delete_=True, type='AdamW', lr=0.0002, weight_decay=0.0001)
+# optimizer_config = dict()
+# # learning policy
+# lr_config = dict(policy='poly', power=0.9, min_lr=0.0, by_epoch=False)
+optim_wrapper = dict(
+    _delete_=True,
+    type='AmpOptimWrapper',
+    optimizer=dict(type='AdamW', lr=0.0002, weight_decay=0.0001))
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        power=0.9,
+        begin=0,
+        end=40000,
+        eta_min=0.0,
+        by_epoch=False,
+    )
+]
diff --git a/mmsegmentation/configs/poolformer/fpn_poolformer_s24_8xb4-40k_ade20k-512x512.py b/mmsegmentation/configs/poolformer/fpn_poolformer_s24_8xb4-40k_ade20k-512x512.py
new file mode 100644
index 0000000..1f9d24c
--- /dev/null
+++ b/mmsegmentation/configs/poolformer/fpn_poolformer_s24_8xb4-40k_ade20k-512x512.py
@@ -0,0 +1,9 @@
+_base_ = './fpn_poolformer_s12_8xb4-40k_ade20k-512x512.py'
+checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/poolformer/poolformer-s24_3rdparty_32xb128_in1k_20220414-d7055904.pth'  # noqa
+# model settings
+model = dict(
+    backbone=dict(
+        arch='s24',
+        init_cfg=dict(
+            type='Pretrained', checkpoint=checkpoint_file,
+            prefix='backbone.')))
diff --git a/mmsegmentation/configs/poolformer/fpn_poolformer_s36_8x4_512x512_40k_ade20k.py b/mmsegmentation/configs/poolformer/fpn_poolformer_s36_8x4_512x512_40k_ade20k.py
new file mode 100644
index 0000000..231dcf6
--- /dev/null
+++ b/mmsegmentation/configs/poolformer/fpn_poolformer_s36_8x4_512x512_40k_ade20k.py
@@ -0,0 +1,10 @@
+_base_ = './fpn_poolformer_s12_8xb4-40k_ade20k-512x512.py'
+checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/poolformer/poolformer-s36_3rdparty_32xb128_in1k_20220414-d78ff3e8.pth'  # noqa
+
+# model settings
+model = dict(
+    backbone=dict(
+        arch='s36',
+        init_cfg=dict(
+            type='Pretrained', checkpoint=checkpoint_file,
+            prefix='backbone.')))
diff --git a/mmsegmentation/configs/poolformer/metafile.yaml b/mmsegmentation/configs/poolformer/metafile.yaml
new file mode 100644
index 0000000..12f402b
--- /dev/null
+++ b/mmsegmentation/configs/poolformer/metafile.yaml
@@ -0,0 +1,116 @@
+Models:
+- Name: fpn_poolformer_s12_8xb4-40k_ade20k-512x512
+  In Collection: FPN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 36.68
+  Config: configs/poolformer/fpn_poolformer_s12_8xb4-40k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 32
+    Architecture:
+    - PoolFormer-S12
+    - FPN
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 4.17
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s12_8x4_512x512_40k_ade20k/fpn_poolformer_s12_8x4_512x512_40k_ade20k_20220501_115154-b5aa2f49.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s12_8x4_512x512_40k_ade20k/fpn_poolformer_s12_8x4_512x512_40k_ade20k_20220501_115154.log.json
+  Paper:
+    Title: MetaFormer is Actually What You Need for Vision
+    URL: https://arxiv.org/abs/2111.11418
+  Code: https://github.com/open-mmlab/mmclassification/blob/v0.23.0/mmcls/models/backbones/poolformer.py#L198
+  Framework: PyTorch
+- Name: fpn_poolformer_s24_8xb4-40k_ade20k-512x512
+  In Collection: FPN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 40.12
+  Config: configs/poolformer/fpn_poolformer_s24_8xb4-40k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 32
+    Architecture:
+    - PoolFormer-S24
+    - FPN
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 5.47
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s24_8x4_512x512_40k_ade20k/fpn_poolformer_s24_8x4_512x512_40k_ade20k_20220503_222049-394a7cf7.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s24_8x4_512x512_40k_ade20k/fpn_poolformer_s24_8x4_512x512_40k_ade20k_20220503_222049.log.json
+  Paper:
+    Title: MetaFormer is Actually What You Need for Vision
+    URL: https://arxiv.org/abs/2111.11418
+  Code: https://github.com/open-mmlab/mmclassification/blob/v0.23.0/mmcls/models/backbones/poolformer.py#L198
+  Framework: PyTorch
+- Name: fpn_poolformer_s36_8xb4-40k_ade20k-512x512
+  In Collection: FPN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 41.61
+  Config: configs/poolformer/fpn_poolformer_s36_8xb4-40k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 32
+    Architecture:
+    - PoolFormer-S36
+    - FPN
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 6.77
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s36_8x4_512x512_40k_ade20k/fpn_poolformer_s36_8x4_512x512_40k_ade20k_20220501_151122-b47e607d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s36_8x4_512x512_40k_ade20k/fpn_poolformer_s36_8x4_512x512_40k_ade20k_20220501_151122.log.json
+  Paper:
+    Title: MetaFormer is Actually What You Need for Vision
+    URL: https://arxiv.org/abs/2111.11418
+  Code: https://github.com/open-mmlab/mmclassification/blob/v0.23.0/mmcls/models/backbones/poolformer.py#L198
+  Framework: PyTorch
+- Name: fpn_poolformer_m36_8xb4-40k_ade20k-512x512
+  In Collection: FPN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 41.95
+  Config: configs/poolformer/fpn_poolformer_m36_8xb4-40k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 32
+    Architecture:
+    - PoolFormer-M36
+    - FPN
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 8.59
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_m36_8x4_512x512_40k_ade20k/fpn_poolformer_m36_8x4_512x512_40k_ade20k_20220501_164230-3dc83921.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_m36_8x4_512x512_40k_ade20k/fpn_poolformer_m36_8x4_512x512_40k_ade20k_20220501_164230.log.json
+  Paper:
+    Title: MetaFormer is Actually What You Need for Vision
+    URL: https://arxiv.org/abs/2111.11418
+  Code: https://github.com/open-mmlab/mmclassification/blob/v0.23.0/mmcls/models/backbones/poolformer.py#L198
+  Framework: PyTorch
+- Name: fpn_poolformer_m48_8xb4-40k_ade20k-512x512
+  In Collection: FPN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.43
+  Config: configs/poolformer/fpn_poolformer_m48_8xb4-40k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 32
+    Architecture:
+    - PoolFormer-M48
+    - FPN
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 10.48
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_m48_8x4_512x512_40k_ade20k/fpn_poolformer_m48_8x4_512x512_40k_ade20k_20220504_003923-64168d3b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_m48_8x4_512x512_40k_ade20k/fpn_poolformer_m48_8x4_512x512_40k_ade20k_20220504_003923.log.json
+  Paper:
+    Title: MetaFormer is Actually What You Need for Vision
+    URL: https://arxiv.org/abs/2111.11418
+  Code: https://github.com/open-mmlab/mmclassification/blob/v0.23.0/mmcls/models/backbones/poolformer.py#L198
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/psanet/README.md b/mmsegmentation/configs/psanet/README.md
new file mode 100644
index 0000000..1f5680f
--- /dev/null
+++ b/mmsegmentation/configs/psanet/README.md
@@ -0,0 +1,68 @@
+# PSANet
+
+> [PSANet: Point-wise Spatial Attention Network for Scene Parsing](https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/hszhao/PSANet">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+We notice information flow in convolutional neural networksis  restricted  inside  local  neighborhood  regions  due  to  the  physical  de-sign  of  convolutional  filters,  which  limits  the  overall  understanding  ofcomplex scenes. In this paper, we propose thepoint-wise  spatial  atten-tion network(PSANet) to relax the local neighborhood constraint. Eachposition on the feature map is connected to all the other ones througha self-adaptively learned attention mask. Moreover, information propa-gation in bi-direction for scene parsing is enabled. Information at otherpositions can be collected to help the prediction of the current positionand  vice  versa,  information  at  the  current  position  can  be  distributedto assist the prediction of other ones. Our proposed approach achievestop performance on various competitive scene parsing datasets, includ-ing  ADE20K,  PASCAL  VOC  2012  and  Cityscapes,  demonstrating  itseffectiveness and generality.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142902367-0f29e8cb-5ac0-434b-98c4-b2af7c9c2e58.png" width="70%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                         | download                                                                                                                                                                                                                                                                                                                                                 |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| PSANet | R-50-D8  | 512x1024  |   40000 | 7        | 3.17           | V100   | 77.63 |         79.04 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x1024_40k_cityscapes/psanet_r50-d8_512x1024_40k_cityscapes_20200606_103117-99fac37c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x1024_40k_cityscapes/psanet_r50-d8_512x1024_40k_cityscapes_20200606_103117.log.json)     |
+| PSANet | R-101-D8 | 512x1024  |   40000 | 10.5     | 2.20           | V100   | 79.14 |         80.19 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x1024_40k_cityscapes/psanet_r101-d8_512x1024_40k_cityscapes_20200606_001418-27b9cfa7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x1024_40k_cityscapes/psanet_r101-d8_512x1024_40k_cityscapes_20200606_001418.log.json) |
+| PSANet | R-50-D8  | 769x769   |   40000 | 7.9      | 1.40           | V100   | 77.99 |         79.64 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_769x769_40k_cityscapes/psanet_r50-d8_769x769_40k_cityscapes_20200530_033717-d5365506.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_769x769_40k_cityscapes/psanet_r50-d8_769x769_40k_cityscapes_20200530_033717.log.json)         |
+| PSANet | R-101-D8 | 769x769   |   40000 | 11.9     | 0.98           | V100   | 78.43 |         80.26 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_769x769_40k_cityscapes/psanet_r101-d8_769x769_40k_cityscapes_20200530_035107-997da1e6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_769x769_40k_cityscapes/psanet_r101-d8_769x769_40k_cityscapes_20200530_035107.log.json)     |
+| PSANet | R-50-D8  | 512x1024  |   80000 | -        | -              | V100   | 77.24 |         78.69 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x1024_80k_cityscapes/psanet_r50-d8_512x1024_80k_cityscapes_20200606_161842-ab60a24f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x1024_80k_cityscapes/psanet_r50-d8_512x1024_80k_cityscapes_20200606_161842.log.json)     |
+| PSANet | R-101-D8 | 512x1024  |   80000 | -        | -              | V100   | 79.31 |         80.53 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x1024_80k_cityscapes/psanet_r101-d8_512x1024_80k_cityscapes_20200606_161823-0f73a169.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x1024_80k_cityscapes/psanet_r101-d8_512x1024_80k_cityscapes_20200606_161823.log.json) |
+| PSANet | R-50-D8  | 769x769   |   80000 | -        | -              | V100   | 79.31 |         80.91 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_769x769_80k_cityscapes/psanet_r50-d8_769x769_80k_cityscapes_20200606_225134-fe42f49e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_769x769_80k_cityscapes/psanet_r50-d8_769x769_80k_cityscapes_20200606_225134.log.json)         |
+| PSANet | R-101-D8 | 769x769   |   80000 | -        | -              | V100   | 79.69 |         80.89 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_769x769_80k_cityscapes/psanet_r101-d8_769x769_80k_cityscapes_20200606_214550-7665827b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_769x769_80k_cityscapes/psanet_r101-d8_769x769_80k_cityscapes_20200606_214550.log.json)     |
+
+### ADE20K
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                     | download                                                                                                                                                                                                                                                                                                                                 |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| PSANet | R-50-D8  | 512x512   |   80000 | 9        | 18.91          | V100   | 41.14 |         41.91 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_80k_ade20k/psanet_r50-d8_512x512_80k_ade20k_20200614_144141-835e4b97.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_80k_ade20k/psanet_r50-d8_512x512_80k_ade20k_20200614_144141.log.json)         |
+| PSANet | R-101-D8 | 512x512   |   80000 | 12.5     | 13.13          | V100   | 43.80 |         44.75 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_80k_ade20k/psanet_r101-d8_512x512_80k_ade20k_20200614_185117-1fab60d4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_80k_ade20k/psanet_r101-d8_512x512_80k_ade20k_20200614_185117.log.json)     |
+| PSANet | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 41.67 |         42.95 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_160k_ade20k/psanet_r50-d8_512x512_160k_ade20k_20200615_161258-148077dd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_160k_ade20k/psanet_r50-d8_512x512_160k_ade20k_20200615_161258.log.json)     |
+| PSANet | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 43.74 |         45.38 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_160k_ade20k/psanet_r101-d8_512x512_160k_ade20k_20200615_161537-dbfa564c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_160k_ade20k/psanet_r101-d8_512x512_160k_ade20k_20200615_161537.log.json) |
+
+### Pascal VOC 2012 + Aug
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                      | download                                                                                                                                                                                                                                                                                                                                     |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | --------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| PSANet | R-50-D8  | 512x512   |   20000 | 6.9      | 18.24          | V100   | 76.39 |         77.34 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r50-d8_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_20k_voc12aug/psanet_r50-d8_512x512_20k_voc12aug_20200617_102413-2f1bbaa1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_20k_voc12aug/psanet_r50-d8_512x512_20k_voc12aug_20200617_102413.log.json)     |
+| PSANet | R-101-D8 | 512x512   |   20000 | 10.4     | 12.63          | V100   | 77.91 |         79.30 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r101-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_20k_voc12aug/psanet_r101-d8_512x512_20k_voc12aug_20200617_110624-946fef11.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_20k_voc12aug/psanet_r101-d8_512x512_20k_voc12aug_20200617_110624.log.json) |
+| PSANet | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 76.30 |         77.35 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r50-d8_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_40k_voc12aug/psanet_r50-d8_512x512_40k_voc12aug_20200613_161946-f596afb5.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_40k_voc12aug/psanet_r50-d8_512x512_40k_voc12aug_20200613_161946.log.json)     |
+| PSANet | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 77.73 |         79.05 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r101-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_40k_voc12aug/psanet_r101-d8_512x512_40k_voc12aug_20200613_161946-1f560f9e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_40k_voc12aug/psanet_r101-d8_512x512_40k_voc12aug_20200613_161946.log.json) |
+
+## Citation
+
+```bibtex
+@inproceedings{zhao2018psanet,
+  title={Psanet: Point-wise spatial attention network for scene parsing},
+  author={Zhao, Hengshuang and Zhang, Yi and Liu, Shu and Shi, Jianping and Change Loy, Chen and Lin, Dahua and Jia, Jiaya},
+  booktitle={Proceedings of the European Conference on Computer Vision (ECCV)},
+  pages={267--283},
+  year={2018}
+}
+```
diff --git a/mmsegmentation/configs/psanet/metafile.yaml b/mmsegmentation/configs/psanet/metafile.yaml
new file mode 100644
index 0000000..3fbe6f6
--- /dev/null
+++ b/mmsegmentation/configs/psanet/metafile.yaml
@@ -0,0 +1,391 @@
+Collections:
+- Name: PSANet
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+    - ADE20K
+    - Pascal VOC 2012 + Aug
+  Paper:
+    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
+    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
+  README: configs/psanet/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: psanet_r50-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: PSANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.63
+      mIoU(ms+flip): 79.04
+  Config: configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - PSANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 7.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x1024_40k_cityscapes/psanet_r50-d8_512x1024_40k_cityscapes_20200606_103117-99fac37c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x1024_40k_cityscapes/psanet_r50-d8_512x1024_40k_cityscapes_20200606_103117.log.json
+  Paper:
+    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
+    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
+  Framework: PyTorch
+- Name: psanet_r101-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: PSANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.14
+      mIoU(ms+flip): 80.19
+  Config: configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - PSANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x1024_40k_cityscapes/psanet_r101-d8_512x1024_40k_cityscapes_20200606_001418-27b9cfa7.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x1024_40k_cityscapes/psanet_r101-d8_512x1024_40k_cityscapes_20200606_001418.log.json
+  Paper:
+    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
+    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
+  Framework: PyTorch
+- Name: psanet_r50-d8_4xb2-40k_cityscapes-769x769
+  In Collection: PSANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.99
+      mIoU(ms+flip): 79.64
+  Config: configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - PSANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 7.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_769x769_40k_cityscapes/psanet_r50-d8_769x769_40k_cityscapes_20200530_033717-d5365506.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_769x769_40k_cityscapes/psanet_r50-d8_769x769_40k_cityscapes_20200530_033717.log.json
+  Paper:
+    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
+    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
+  Framework: PyTorch
+- Name: psanet_r101-d8_4xb2-40k_cityscapes-769x769
+  In Collection: PSANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.43
+      mIoU(ms+flip): 80.26
+  Config: configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - PSANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 11.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_769x769_40k_cityscapes/psanet_r101-d8_769x769_40k_cityscapes_20200530_035107-997da1e6.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_769x769_40k_cityscapes/psanet_r101-d8_769x769_40k_cityscapes_20200530_035107.log.json
+  Paper:
+    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
+    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
+  Framework: PyTorch
+- Name: psanet_r50-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: PSANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.24
+      mIoU(ms+flip): 78.69
+  Config: configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - PSANet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x1024_80k_cityscapes/psanet_r50-d8_512x1024_80k_cityscapes_20200606_161842-ab60a24f.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x1024_80k_cityscapes/psanet_r50-d8_512x1024_80k_cityscapes_20200606_161842.log.json
+  Paper:
+    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
+    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
+  Framework: PyTorch
+- Name: psanet_r101-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: PSANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.31
+      mIoU(ms+flip): 80.53
+  Config: configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - PSANet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x1024_80k_cityscapes/psanet_r101-d8_512x1024_80k_cityscapes_20200606_161823-0f73a169.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x1024_80k_cityscapes/psanet_r101-d8_512x1024_80k_cityscapes_20200606_161823.log.json
+  Paper:
+    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
+    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
+  Framework: PyTorch
+- Name: psanet_r50-d8_4xb2-80k_cityscapes-769x769
+  In Collection: PSANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.31
+      mIoU(ms+flip): 80.91
+  Config: configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - PSANet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_769x769_80k_cityscapes/psanet_r50-d8_769x769_80k_cityscapes_20200606_225134-fe42f49e.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_769x769_80k_cityscapes/psanet_r50-d8_769x769_80k_cityscapes_20200606_225134.log.json
+  Paper:
+    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
+    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
+  Framework: PyTorch
+- Name: psanet_r101-d8_4xb2-80k_cityscapes-769x769
+  In Collection: PSANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.69
+      mIoU(ms+flip): 80.89
+  Config: configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - PSANet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_769x769_80k_cityscapes/psanet_r101-d8_769x769_80k_cityscapes_20200606_214550-7665827b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_769x769_80k_cityscapes/psanet_r101-d8_769x769_80k_cityscapes_20200606_214550.log.json
+  Paper:
+    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
+    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
+  Framework: PyTorch
+- Name: psanet_r50-d8_4xb4-80k_ade20k-512x512
+  In Collection: PSANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 41.14
+      mIoU(ms+flip): 41.91
+  Config: configs/psanet/psanet_r50-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - PSANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_80k_ade20k/psanet_r50-d8_512x512_80k_ade20k_20200614_144141-835e4b97.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_80k_ade20k/psanet_r50-d8_512x512_80k_ade20k_20200614_144141.log.json
+  Paper:
+    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
+    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
+  Framework: PyTorch
+- Name: psanet_r101-d8_4xb4-80k_ade20k-512x512
+  In Collection: PSANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 43.8
+      mIoU(ms+flip): 44.75
+  Config: configs/psanet/psanet_r101-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - PSANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 12.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_80k_ade20k/psanet_r101-d8_512x512_80k_ade20k_20200614_185117-1fab60d4.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_80k_ade20k/psanet_r101-d8_512x512_80k_ade20k_20200614_185117.log.json
+  Paper:
+    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
+    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
+  Framework: PyTorch
+- Name: psanet_r50-d8_4xb4-160k_ade20k-512x512
+  In Collection: PSANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 41.67
+      mIoU(ms+flip): 42.95
+  Config: configs/psanet/psanet_r50-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - PSANet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_160k_ade20k/psanet_r50-d8_512x512_160k_ade20k_20200615_161258-148077dd.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_160k_ade20k/psanet_r50-d8_512x512_160k_ade20k_20200615_161258.log.json
+  Paper:
+    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
+    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
+  Framework: PyTorch
+- Name: psanet_r101-d8_4xb4-160k_ade20k-512x512
+  In Collection: PSANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 43.74
+      mIoU(ms+flip): 45.38
+  Config: configs/psanet/psanet_r101-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - PSANet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_160k_ade20k/psanet_r101-d8_512x512_160k_ade20k_20200615_161537-dbfa564c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_160k_ade20k/psanet_r101-d8_512x512_160k_ade20k_20200615_161537.log.json
+  Paper:
+    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
+    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
+  Framework: PyTorch
+- Name: psanet_r50-d8_4xb4-20k_voc12aug-512x512
+  In Collection: PSANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 76.39
+      mIoU(ms+flip): 77.34
+  Config: configs/psanet/psanet_r50-d8_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - PSANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_20k_voc12aug/psanet_r50-d8_512x512_20k_voc12aug_20200617_102413-2f1bbaa1.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_20k_voc12aug/psanet_r50-d8_512x512_20k_voc12aug_20200617_102413.log.json
+  Paper:
+    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
+    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
+  Framework: PyTorch
+- Name: psanet_r101-d8_4xb4-20k_voc12aug-512x512
+  In Collection: PSANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 77.91
+      mIoU(ms+flip): 79.3
+  Config: configs/psanet/psanet_r101-d8_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - PSANet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.4
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_20k_voc12aug/psanet_r101-d8_512x512_20k_voc12aug_20200617_110624-946fef11.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_20k_voc12aug/psanet_r101-d8_512x512_20k_voc12aug_20200617_110624.log.json
+  Paper:
+    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
+    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
+  Framework: PyTorch
+- Name: psanet_r50-d8_4xb4-40k_voc12aug-512x512
+  In Collection: PSANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 76.3
+      mIoU(ms+flip): 77.35
+  Config: configs/psanet/psanet_r50-d8_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - PSANet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_40k_voc12aug/psanet_r50-d8_512x512_40k_voc12aug_20200613_161946-f596afb5.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_40k_voc12aug/psanet_r50-d8_512x512_40k_voc12aug_20200613_161946.log.json
+  Paper:
+    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
+    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
+  Framework: PyTorch
+- Name: psanet_r101-d8_4xb4-40k_voc12aug-512x512
+  In Collection: PSANet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 77.73
+      mIoU(ms+flip): 79.05
+  Config: configs/psanet/psanet_r101-d8_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - PSANet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_40k_voc12aug/psanet_r101-d8_512x512_40k_voc12aug_20200613_161946-1f560f9e.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_40k_voc12aug/psanet_r101-d8_512x512_40k_voc12aug_20200613_161946.log.json
+  Paper:
+    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
+    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..e69cf42
--- /dev/null
+++ b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './psanet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..e543099
--- /dev/null
+++ b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './psanet_r50-d8_4xb2-40k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..b863638
--- /dev/null
+++ b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './psanet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..097b1c5
--- /dev/null
+++ b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './psanet_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..ac86306
--- /dev/null
+++ b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './psanet_r50-d8_4xb4-160k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..abd8e56
--- /dev/null
+++ b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './psanet_r50-d8_4xb4-20k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..d3154a8
--- /dev/null
+++ b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './psanet_r50-d8_4xb4-40k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..b34d424
--- /dev/null
+++ b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './psanet_r50-d8_4xb4-80k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..82463aa
--- /dev/null
+++ b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/psanet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..af44b30
--- /dev/null
+++ b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/psanet_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..5e5052f
--- /dev/null
+++ b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/psanet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..0eaf830
--- /dev/null
+++ b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/psanet_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..de13296
--- /dev/null
+++ b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/psanet_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(mask_size=(66, 66), num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..45d8762
--- /dev/null
+++ b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/psanet_r50-d8.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_20k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..b5d99d1
--- /dev/null
+++ b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/psanet_r50-d8.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..c3b6528
--- /dev/null
+++ b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/psanet_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(mask_size=(66, 66), num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/pspnet/README.md b/mmsegmentation/configs/pspnet/README.md
new file mode 100644
index 0000000..4209d25
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/README.md
@@ -0,0 +1,182 @@
+# PSPNet
+
+> [Pyramid Scene Parsing Network](https://arxiv.org/abs/1612.01105)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/hszhao/PSPNet">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Scene parsing is challenging for unrestricted open vocabulary and diverse scenes. In this paper, we exploit the capability of global context information by different-region-based context aggregation through our pyramid pooling module together with the proposed pyramid scene parsing network (PSPNet). Our global prior representation is effective to produce good quality results on the scene parsing task, while PSPNet provides a superior framework for pixel-level prediction tasks. The proposed approach achieves state-of-the-art performance on various datasets. It came first in ImageNet scene parsing challenge 2016, PASCAL VOC 2012 benchmark and Cityscapes benchmark. A single PSPNet yields new record of mIoU accuracy 85.4% on PASCAL VOC 2012 and accuracy 80.2% on Cityscapes.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142902444-9f93b99e-9261-443b-a0a4-17e78eefb525.png" width="70%"/>
+</div>
+
+<div align=center >
+<img alt="PSPNet-R50-D8" src="https://user-images.githubusercontent.com/47882088/209554973-66804b14-de5a-4f83-b54e-26683a91818a.jpg"/>
+PSPNet-R50 D8 model structure
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method        | Backbone      | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                   | download                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| ------------- | ------------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ---------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| PSPNet        | R-50-D8       | 512x1024  |   40000 | 6.1      | 4.07           | V100   | 77.85 |         79.18 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py)            | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338.log.json)                                                                                 |
+| PSPNet        | R-101-D8      | 512x1024  |   40000 | 9.6      | 2.68           | V100   | 78.34 |         79.74 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_40k_cityscapes/pspnet_r101-d8_512x1024_40k_cityscapes_20200604_232751-467e7cf4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_40k_cityscapes/pspnet_r101-d8_512x1024_40k_cityscapes_20200604_232751.log.json)                                                                             |
+| PSPNet        | R-50-D8       | 769x769   |   40000 | 6.9      | 1.76           | V100   | 78.26 |         79.88 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-769x769.py)             | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_769x769_40k_cityscapes/pspnet_r50-d8_769x769_40k_cityscapes_20200606_112725-86638686.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_769x769_40k_cityscapes/pspnet_r50-d8_769x769_40k_cityscapes_20200606_112725.log.json)                                                                                     |
+| PSPNet        | R-101-D8      | 769x769   |   40000 | 10.9     | 1.15           | V100   | 79.08 |         80.28 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-769x769.py)            | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_769x769_40k_cityscapes/pspnet_r101-d8_769x769_40k_cityscapes_20200606_112753-61c6f5be.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_769x769_40k_cityscapes/pspnet_r101-d8_769x769_40k_cityscapes_20200606_112753.log.json)                                                                                 |
+| PSPNet        | R-18-D8       | 512x1024  |   80000 | 1.7      | 15.71          | V100   | 74.87 |         76.04 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-512x1024.py)            | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_512x1024_80k_cityscapes/pspnet_r18-d8_512x1024_80k_cityscapes_20201225_021458-09ffa746.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_512x1024_80k_cityscapes/pspnet_r18-d8_512x1024_80k_cityscapes-20201225_021458.log.json)                                                                                 |
+| PSPNet        | R-50-D8       | 512x1024  |   80000 | -        | -              | V100   | 78.55 |         79.79 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py)            | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes/pspnet_r50-d8_512x1024_80k_cityscapes_20200606_112131-2376f12b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes/pspnet_r50-d8_512x1024_80k_cityscapes_20200606_112131.log.json)                                                                                 |
+| PSPNet        | R-50b-D8 rsb  | 512x1024  |   80000 | 6.2      | 3.82           | V100   | 78.47 |         79.45 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8-rsb_4xb2-adamw-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes/pspnet_r50-d8_rsb-pretrain_512x1024_adamw_80k_cityscapes_20220315_123238-588c30be.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes/pspnet_r50-d8_rsb-pretrain_512x1024_adamw_80k_cityscapes_20220315_123238.log.json)                                           |
+| PSPNet        | R-101-D8      | 512x1024  |   80000 | -        | -              | V100   | 79.76 |         81.01 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-512x1024.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_80k_cityscapes/pspnet_r101-d8_512x1024_80k_cityscapes_20200606_112211-e1e1100f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_80k_cityscapes/pspnet_r101-d8_512x1024_80k_cityscapes_20200606_112211.log.json)                                                                             |
+| PSPNet (FP16) | R-101-D8      | 512x1024  |   80000 | 5.34     | 8.77           | V100   | 79.46 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_fp16_512x1024_80k_cityscapes/pspnet_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230919-a0875e5c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_fp16_512x1024_80k_cityscapes/pspnet_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230919.log.json)                                                         |
+| PSPNet        | R-18-D8       | 769x769   |   80000 | 1.9      | 6.20           | V100   | 75.90 |         77.86 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-769x769.py)             | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_769x769_80k_cityscapes/pspnet_r18-d8_769x769_80k_cityscapes_20201225_021458-3deefc62.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_769x769_80k_cityscapes/pspnet_r18-d8_769x769_80k_cityscapes-20201225_021458.log.json)                                                                                     |
+| PSPNet        | R-50-D8       | 769x769   |   80000 | -        | -              | V100   | 79.59 |         80.69 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-769x769.py)             | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_769x769_80k_cityscapes/pspnet_r50-d8_769x769_80k_cityscapes_20200606_210121-5ccf03dd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_769x769_80k_cityscapes/pspnet_r50-d8_769x769_80k_cityscapes_20200606_210121.log.json)                                                                                     |
+| PSPNet        | R-101-D8      | 769x769   |   80000 | -        | -              | V100   | 79.77 |         81.06 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-769x769.py)            | [model](https://download.oz1z1penmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_769x769_80k_cityscapes/pspnet_r101-d8_769x769_80k_cityscapes_20200606_225055-dba412fa.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_769x769_80k_cityscapes/pspnet_r101-d8_769x769_80k_cityscapes_20200606_225055.log.json)                                                                             |
+| PSPNet        | R-18b-D8      | 512x1024  |   80000 | 1.5      | 16.28          | V100   | 74.23 |         75.79 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-512x1024.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18b-d8_512x1024_80k_cityscapes/pspnet_r18b-d8_512x1024_80k_cityscapes_20201226_063116-26928a60.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18b-d8_512x1024_80k_cityscapes/pspnet_r18b-d8_512x1024_80k_cityscapes-20201226_063116.log.json)                                                                             |
+| PSPNet        | R-50b-D8      | 512x1024  |   80000 | 6.0      | 4.30           | V100   | 78.22 |         79.46 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d8_512x1024_80k_cityscapes/pspnet_r50b-d8_512x1024_80k_cityscapes_20201225_094315-6344287a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d8_512x1024_80k_cityscapes/pspnet_r50b-d8_512x1024_80k_cityscapes-20201225_094315.log.json)                                                                             |
+| PSPNet        | R-101b-D8     | 512x1024  |   80000 | 9.5      | 2.76           | V100   | 79.69 |         80.79 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_512x1024_80k_cityscapes/pspnet_r101b-d8_512x1024_80k_cityscapes_20201226_170012-3a4d38ab.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_512x1024_80k_cityscapes/pspnet_r101b-d8_512x1024_80k_cityscapes-20201226_170012.log.json)                                                                         |
+| PSPNet        | R-18b-D8      | 769x769   |   80000 | 1.7      | 6.41           | V100   | 74.92 |         76.90 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-769x769.py)            | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18b-d8_769x769_80k_cityscapes/pspnet_r18b-d8_769x769_80k_cityscapes_20201226_080942-bf98d186.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18b-d8_769x769_80k_cityscapes/pspnet_r18b-d8_769x769_80k_cityscapes-20201226_080942.log.json)                                                                                 |
+| PSPNet        | R-50b-D8      | 769x769   |   80000 | 6.8      | 1.88           | V100   | 78.50 |         79.96 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-769x769.py)            | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d8_769x769_80k_cityscapes/pspnet_r50b-d8_769x769_80k_cityscapes_20201225_094316-4c643cf6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d8_769x769_80k_cityscapes/pspnet_r50b-d8_769x769_80k_cityscapes-20201225_094316.log.json)                                                                                 |
+| PSPNet        | R-101b-D8     | 769x769   |   80000 | 10.8     | 1.17           | V100   | 78.87 |         80.04 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-769x769.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_769x769_80k_cityscapes/pspnet_r101b-d8_769x769_80k_cityscapes_20201226_171823-f0e7c293.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_769x769_80k_cityscapes/pspnet_r101b-d8_769x769_80k_cityscapes-20201226_171823.log.json)                                                                             |
+| PSPNet        | R-50-D32      | 512x1024  |   80000 | 3.0      | 15.21          | V100   | 73.88 |         76.85 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50b-d32_4xb2-80k_cityscapes-512x1024.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d32_512x1024_80k_cityscapes/pspnet_r50-d32_512x1024_80k_cityscapes_20220316_224840-9092b254.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d32_512x1024_80k_cityscapes/pspnet_r50-d32_512x1024_80k_cityscapes_20220316_224840.log.json)                                                                             |
+| PSPNet        | R-50b-D32 rsb | 512x1024  |   80000 | 3.1      | 16.08          | V100   | 74.09 |         77.18 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d32_rsb_4xb2-adamw-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d32_rsb-pretrain_512x1024_adamw_80k_cityscapes/pspnet_r50-d32_rsb-pretrain_512x1024_adamw_80k_cityscapes_20220316_141229-dd9c9610.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d32_rsb-pretrain_512x1024_adamw_80k_cityscapes/pspnet_r50-d32_rsb-pretrain_512x1024_adamw_80k_cityscapes_20220316_141229.log.json) |
+| PSPNet        | R-50b-D32     | 512x1024  |   80000 | 2.9      | 15.41          | V100   | 72.61 |         75.51 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50b-d32_4xb2-80k_cityscapes-512x1024.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d32_512x1024_80k_cityscapes/pspnet_r50b-d32_512x1024_80k_cityscapes_20220311_152152-23bcaf8c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d32_512x1024_80k_cityscapes/pspnet_r50b-d32_512x1024_80k_cityscapes_20220311_152152.log.json)                                                                         |
+
+### ADE20K
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                     | download                                                                                                                                                                                                                                                                                                                                 |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| PSPNet | R-50-D8  | 512x512   |   80000 | 8.5      | 23.53          | V100   | 41.13 |         41.94 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_80k_ade20k/pspnet_r50-d8_512x512_80k_ade20k_20200615_014128-15a8b914.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_80k_ade20k/pspnet_r50-d8_512x512_80k_ade20k_20200615_014128.log.json)         |
+| PSPNet | R-101-D8 | 512x512   |   80000 | 12       | 15.30          | V100   | 43.57 |         44.35 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_80k_ade20k/pspnet_r101-d8_512x512_80k_ade20k_20200614_031423-b6e782f0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_80k_ade20k/pspnet_r101-d8_512x512_80k_ade20k_20200614_031423.log.json)     |
+| PSPNet | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 42.48 |         43.44 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_160k_ade20k/pspnet_r50-d8_512x512_160k_ade20k_20200615_184358-1890b0bd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_160k_ade20k/pspnet_r50-d8_512x512_160k_ade20k_20200615_184358.log.json)     |
+| PSPNet | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 44.39 |         45.35 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_160k_ade20k/pspnet_r101-d8_512x512_160k_ade20k_20200615_100650-967c316f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_160k_ade20k/pspnet_r101-d8_512x512_160k_ade20k_20200615_100650.log.json) |
+
+### Pascal VOC 2012 + Aug
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                      | download                                                                                                                                                                                                                                                                                                                                     |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | --------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| PSPNet | R-50-D8  | 512x512   |   20000 | 6.1      | 23.59          | V100   | 76.78 |         77.61 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_20k_voc12aug/pspnet_r50-d8_512x512_20k_voc12aug_20200617_101958-ed5dfbd9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_20k_voc12aug/pspnet_r50-d8_512x512_20k_voc12aug_20200617_101958.log.json)     |
+| PSPNet | R-101-D8 | 512x512   |   20000 | 9.6      | 15.02          | V100   | 78.47 |         79.25 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_20k_voc12aug/pspnet_r101-d8_512x512_20k_voc12aug_20200617_102003-4aef3c9a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_20k_voc12aug/pspnet_r101-d8_512x512_20k_voc12aug_20200617_102003.log.json) |
+| PSPNet | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 77.29 |         78.48 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_40k_voc12aug/pspnet_r50-d8_512x512_40k_voc12aug_20200613_161222-ae9c1b8c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_40k_voc12aug/pspnet_r50-d8_512x512_40k_voc12aug_20200613_161222.log.json)     |
+| PSPNet | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 78.52 |         79.57 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_40k_voc12aug/pspnet_r101-d8_512x512_40k_voc12aug_20200613_161222-bc933b18.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_40k_voc12aug/pspnet_r101-d8_512x512_40k_voc12aug_20200613_161222.log.json) |
+
+### Pascal Context
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                            | download                                                                                                                                                                                                                                                                                                                                                             |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | --------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| PSPNet | R-101-D8 | 480x480   |   40000 | 8.8      | 9.68           | V100   | 46.60 |         47.78 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_40k_pascal_context/pspnet_r101-d8_480x480_40k_pascal_context_20200911_211210-bf0f5d7c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_40k_pascal_context/pspnet_r101-d8_480x480_40k_pascal_context-20200911_211210.log.json) |
+| PSPNet | R-101-D8 | 480x480   |   80000 | -        | -              | V100   | 46.03 |         47.15 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_80k_pascal_context/pspnet_r101-d8_480x480_80k_pascal_context_20200911_190530-c86d6233.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_80k_pascal_context/pspnet_r101-d8_480x480_80k_pascal_context-20200911_190530.log.json) |
+
+### Pascal Context 59
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                               | download                                                                                                                                                                                                                                                                                                                                                                         |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| PSPNet | R-101-D8 | 480x480   |   40000 | -        | -              | V100   | 52.02 |         53.54 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-59-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_40k_pascal_context_59/pspnet_r101-d8_480x480_40k_pascal_context_59_20210416_114524-86d44cd4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_40k_pascal_context_59/pspnet_r101-d8_480x480_40k_pascal_context_59-20210416_114524.log.json) |
+| PSPNet | R-101-D8 | 480x480   |   80000 | -        | -              | V100   | 52.47 |         53.99 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-59-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_80k_pascal_context_59/pspnet_r101-d8_480x480_80k_pascal_context_59_20210416_114418-fa6caaa2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_80k_pascal_context_59/pspnet_r101-d8_480x480_80k_pascal_context_59-20210416_114418.log.json) |
+
+### Dark Zurich and Nighttime Driving
+
+We support evaluation results on these two datasets using models above trained on Cityscapes training set.
+
+| Method | Backbone  | Training Dataset        | Test Dataset              | mIoU  | config                                                                                                                                                  | evaluation checkpoint                                                                                                                                                                                                                                                                                                                                        |
+| ------ | --------- | ----------------------- | ------------------------- | ----- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| PSPNet | R-50-D8   | Cityscapes Training set | Dark Zurich               | 10.91 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_dark-zurich-1920x1080.py)     | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338.log.json)         |
+| PSPNet | R-50-D8   | Cityscapes Training set | Nighttime Driving         | 23.02 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_night-driving-1920x1080.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338.log.json)         |
+| PSPNet | R-50-D8   | Cityscapes Training set | Cityscapes Validation set | 77.85 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py)                           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338.log.json)         |
+| PSPNet | R-101-D8  | Cityscapes Training set | Dark Zurich               | 10.16 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024_dark-zurich-1920x1080.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_40k_cityscapes/pspnet_r101-d8_512x1024_40k_cityscapes_20200604_232751-467e7cf4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_40k_cityscapes/pspnet_r101-d8_512x1024_40k_cityscapes_20200604_232751.log.json)     |
+| PSPNet | R-101-D8  | Cityscapes Training set | Nighttime Driving         | 20.25 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024_night-driving-1920x1080.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_40k_cityscapes/pspnet_r101-d8_512x1024_40k_cityscapes_20200604_232751-467e7cf4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_40k_cityscapes/pspnet_r101-d8_512x1024_40k_cityscapes_20200604_232751.log.json)     |
+| PSPNet | R-101-D8  | Cityscapes Training set | Cityscapes Validation set | 78.34 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024.py)                          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_40k_cityscapes/pspnet_r101-d8_512x1024_40k_cityscapes_20200604_232751-467e7cf4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_40k_cityscapes/pspnet_r101-d8_512x1024_40k_cityscapes_20200604_232751.log.json)     |
+| PSPNet | R-101b-D8 | Cityscapes Training set | Dark Zurich               | 15.54 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024_dark-zurich-1920x1080.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_512x1024_80k_cityscapes/pspnet_r101b-d8_512x1024_80k_cityscapes_20201226_170012-3a4d38ab.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_512x1024_80k_cityscapes/pspnet_r101b-d8_512x1024_80k_cityscapes-20201226_170012.log.json) |
+| PSPNet | R-101b-D8 | Cityscapes Training set | Nighttime Driving         | 22.25 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024_night-driving-1920x1080.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_512x1024_80k_cityscapes/pspnet_r101b-d8_512x1024_80k_cityscapes_20201226_170012-3a4d38ab.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_512x1024_80k_cityscapes/pspnet_r101b-d8_512x1024_80k_cityscapes-20201226_170012.log.json) |
+| PSPNet | R-101b-D8 | Cityscapes Training set | Cityscapes Validation set | 79.69 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024.py)                         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_512x1024_80k_cityscapes/pspnet_r101b-d8_512x1024_80k_cityscapes_20201226_170012-3a4d38ab.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_512x1024_80k_cityscapes/pspnet_r101b-d8_512x1024_80k_cityscapes-20201226_170012.log.json) |
+
+### COCO-Stuff 10k
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                           | download                                                                                                                                                                                                                                                                                                                                                                         |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| PSPNet | R-50-D8  | 512x512   |   20000 | 9.6      | 20.5           | V100   | 35.69 |         36.62 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-20k_coco-stuff10k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_20k_coco-stuff10k/pspnet_r50-d8_512x512_4x4_20k_coco-stuff10k_20210820_203258-b88df27f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_20k_coco-stuff10k/pspnet_r50-d8_512x512_4x4_20k_coco-stuff10k_20210820_203258.log.json)     |
+| PSPNet | R-101-D8 | 512x512   |   20000 | 13.2     | 11.1           | V100   | 37.26 |         38.52 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-20k_coco-stuff10k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_20k_coco-stuff10k/pspnet_r101-d8_512x512_4x4_20k_coco-stuff10k_20210820_232135-76aae482.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_20k_coco-stuff10k/pspnet_r101-d8_512x512_4x4_20k_coco-stuff10k_20210820_232135.log.json) |
+| PSPNet | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 36.33 |         37.24 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-40k_coco-stuff10k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_40k_coco-stuff10k/pspnet_r50-d8_512x512_4x4_40k_coco-stuff10k_20210821_030857-92e2902b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_40k_coco-stuff10k/pspnet_r50-d8_512x512_4x4_40k_coco-stuff10k_20210821_030857.log.json)     |
+| PSPNet | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 37.76 |         38.86 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-40k_coco-stuff10k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_40k_coco-stuff10k/pspnet_r101-d8_512x512_4x4_40k_coco-stuff10k_20210821_014022-831aec95.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_40k_coco-stuff10k/pspnet_r101-d8_512x512_4x4_40k_coco-stuff10k_20210821_014022.log.json) |
+
+### COCO-Stuff 164k
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                             | download                                                                                                                                                                                                                                                                                                                                                                                 |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ---------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| PSPNet | R-50-D8  | 512x512   |   80000 | 9.6      | 20.5           | V100   | 38.80 |         39.19 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-80k_coco-stuff164k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_80k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_80k_coco-stuff164k_20210707_152034-0e41b2db.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_80k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_80k_coco-stuff164k_20210707_152034.log.json)         |
+| PSPNet | R-101-D8 | 512x512   |   80000 | 13.2     | 11.1           | V100   | 40.34 |         40.79 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-80k_coco-stuff164k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_80k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_80k_coco-stuff164k_20210707_152034-7eb41789.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_80k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_80k_coco-stuff164k_20210707_152034.log.json)     |
+| PSPNet | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 39.64 |         39.97 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-160k_coco-stuff164k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_160k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_160k_coco-stuff164k_20210707_152004-51276a57.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_160k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_160k_coco-stuff164k_20210707_152004.log.json)     |
+| PSPNet | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 41.28 |         41.66 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-160k_coco-stuff164k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_160k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_160k_coco-stuff164k_20210707_152004-4af9621b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_160k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_160k_coco-stuff164k_20210707_152004.log.json) |
+| PSPNet | R-50-D8  | 512x512   |  320000 | -        | -              | V100   | 40.53 |         40.75 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-320k_coco-stuff164k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_320k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_320k_coco-stuff164k_20210707_152004-be9610cc.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_320k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_320k_coco-stuff164k_20210707_152004.log.json)     |
+| PSPNet | R-101-D8 | 512x512   |  320000 | -        | -              | V100   | 41.95 |         42.42 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-320k_coco-stuff164k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_320k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_320k_coco-stuff164k_20210707_152004-72220c60.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_320k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_320k_coco-stuff164k_20210707_152004.log.json) |
+
+### LoveDA
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                    | download                                                                                                                                                                                                                                                                                                                             |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| PSPNet | R-18-D8  | 512x512   |   80000 | 1.45     | 26.87          | V100   | 48.62 |         47.57 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r18-d8_4xb4-80k_loveda-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_512x512_80k_loveda/pspnet_r18-d8_512x512_80k_loveda_20211105_052100-b97697f1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_512x512_80k_loveda/pspnet_r18-d8_512x512_80k_loveda_20211105_052100.log.json)     |
+| PSPNet | R-50-D8  | 512x512   |   80000 | 6.14     | 6.60           | V100   | 50.46 |         50.19 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-80k_loveda-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_80k_loveda/pspnet_r50-d8_512x512_80k_loveda_20211104_155728-88610f9f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_80k_loveda/pspnet_r50-d8_512x512_80k_loveda_20211104_155728.log.json)     |
+| PSPNet | R-101-D8 | 512x512   |   80000 | 9.61     | 4.58           | V100   | 51.86 |         51.34 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-80k_loveda-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_80k_loveda/pspnet_r101-d8_512x512_80k_loveda_20211104_153212-1c06c6a8.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_80k_loveda/pspnet_r101-d8_512x512_80k_loveda_20211104_153212.log.json) |
+
+### Potsdam
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                     | download                                                                                                                                                                                                                                                                                                                                                 |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| PSPNet | R-18-D8  | 512x512   |   80000 | 1.50     | 85.12          | V100   | 77.09 |         78.30 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r18-d8_4xb4-80k_potsdam-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_512x512_80k_potsdam/pspnet_r18-d8_4x4_512x512_80k_potsdam_20211220_125612-7cd046e1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_512x512_80k_potsdam/pspnet_r18-d8_4x4_512x512_80k_potsdam_20211220_125612.log.json)     |
+| PSPNet | R-50-D8  | 512x512   |   80000 | 6.14     | 30.21          | V100   | 78.12 |         78.98 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-80k_potsdam-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_512x512_80k_potsdam/pspnet_r50-d8_4x4_512x512_80k_potsdam_20211219_043541-2dd5fe67.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_512x512_80k_potsdam/pspnet_r50-d8_4x4_512x512_80k_potsdam_20211219_043541.log.json)     |
+| PSPNet | R-101-D8 | 512x512   |   80000 | 9.61     | 19.40          | V100   | 78.62 |         79.47 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-80k_potsdam-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_4x4_512x512_80k_potsdam/pspnet_r101-d8_4x4_512x512_80k_potsdam_20211220_125612-aed036c4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_4x4_512x512_80k_potsdam/pspnet_r101-d8_4x4_512x512_80k_potsdam_20211220_125612.log.json) |
+
+### Vaihingen
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                       | download                                                                                                                                                                                                                                                                                                                                                         |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| PSPNet | R-18-D8  | 512x512   |   80000 | 1.45     | 85.06          | V100   | 71.46 |         73.36 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r18-d8_4xb4-80k_vaihingen-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_512x512_80k_vaihingen/pspnet_r18-d8_4x4_512x512_80k_vaihingen_20211228_160355-52a8a6f6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_512x512_80k_vaihingen/pspnet_r18-d8_4x4_512x512_80k_vaihingen_20211228_160355.log.json)     |
+| PSPNet | R-50-D8  | 512x512   |   80000 | 6.14     | 30.29          | V100   | 72.36 |         73.75 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-80k_vaihingen-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_512x512_80k_vaihingen/pspnet_r50-d8_4x4_512x512_80k_vaihingen_20211228_160355-382f8f5b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_512x512_80k_vaihingen/pspnet_r50-d8_4x4_512x512_80k_vaihingen_20211228_160355.log.json)     |
+| PSPNet | R-101-D8 | 512x512   |   80000 | 9.61     | 19.97          | V100   | 72.61 |         74.18 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-80k_vaihingen-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_4x4_512x512_80k_vaihingen/pspnet_r101-d8_4x4_512x512_80k_vaihingen_20211231_230806-8eba0a09.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_4x4_512x512_80k_vaihingen/pspnet_r101-d8_4x4_512x512_80k_vaihingen_20211231_230806.log.json) |
+
+### iSAID
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                  | download                                                                                                                                                                                                                                                                                                                                     |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ----------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| PSPNet | R-18-D8  | 896x896   |   80000 | 4.52     | 26.91          | V100   | 60.22 |         61.25 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r18-d8_4xb4-80k_isaid-896x896.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_896x896_80k_isaid/pspnet_r18-d8_4x4_896x896_80k_isaid_20220110_180526-e84c0b6a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_896x896_80k_isaid/pspnet_r18-d8_4x4_896x896_80k_isaid_20220110_180526.log.json) |
+| PSPNet | R-50-D8  | 896x896   |   80000 | 16.58    | 8.88           | V100   | 65.36 |         66.48 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-80k_isaid-896x896.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_896x896_80k_isaid/pspnet_r50-d8_4x4_896x896_80k_isaid_20220110_180629-1f21dc32.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_896x896_80k_isaid/pspnet_r50-d8_4x4_896x896_80k_isaid_20220110_180629.log.json) |
+
+Note:
+
+- `FP16` means Mixed Precision (FP16) is adopted in training.
+- `896x896` is the Crop Size of iSAID dataset, which is followed by the implementation of [PointFlow: Flowing Semantics Through Points for Aerial Image Segmentation](https://arxiv.org/pdf/2103.06564.pdf)
+- `rsb` is short for 'Resnet strikes back'.
+- The `b` in `R-50b` means ResNetV1b, which is a standard ResNet backbone. In MMSegmentation, default backbone is ResNetV1c, which usually performs better in semantic segmentation task.
+
+## Citation
+
+```bibtex
+@inproceedings{zhao2017pspnet,
+  title={Pyramid Scene Parsing Network},
+  author={Zhao, Hengshuang and Shi, Jianping and Qi, Xiaojuan and Wang, Xiaogang and Jia, Jiaya},
+  booktitle={CVPR},
+  year={2017}
+}
+```
+
+```bibtex
+@article{wightman2021resnet,
+  title={Resnet strikes back: An improved training procedure in timm},
+  author={Wightman, Ross and Touvron, Hugo and J{\'e}gou, Herv{\'e}},
+  journal={arXiv preprint arXiv:2110.00476},
+  year={2021}
+}
+```
diff --git a/mmsegmentation/configs/pspnet/metafile.yaml b/mmsegmentation/configs/pspnet/metafile.yaml
new file mode 100644
index 0000000..d00b89d
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/metafile.yaml
@@ -0,0 +1,1303 @@
+Collections:
+- Name: PSPNet
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+    - ADE20K
+    - Pascal VOC 2012 + Aug
+    - Pascal Context
+    - Pascal Context 59
+    - Dark Zurich and Nighttime Driving
+    - COCO-Stuff 10k
+    - COCO-Stuff 164k
+    - LoveDA
+    - Potsdam
+    - Vaihingen
+    - iSAID
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  README: configs/pspnet/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: pspnet_r50-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.85
+      mIoU(ms+flip): 79.18
+  Config: configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r101-d8_4xb2-40k_cityscapes-512x1024
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.34
+      mIoU(ms+flip): 79.74
+  Config: configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_40k_cityscapes/pspnet_r101-d8_512x1024_40k_cityscapes_20200604_232751-467e7cf4.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_40k_cityscapes/pspnet_r101-d8_512x1024_40k_cityscapes_20200604_232751.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r50-d8_4xb2-40k_cityscapes-769x769
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.26
+      mIoU(ms+flip): 79.88
+  Config: configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_769x769_40k_cityscapes/pspnet_r50-d8_769x769_40k_cityscapes_20200606_112725-86638686.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_769x769_40k_cityscapes/pspnet_r50-d8_769x769_40k_cityscapes_20200606_112725.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r101-d8_4xb2-40k_cityscapes-769x769
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.08
+      mIoU(ms+flip): 80.28
+  Config: configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_769x769_40k_cityscapes/pspnet_r101-d8_769x769_40k_cityscapes_20200606_112753-61c6f5be.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_769x769_40k_cityscapes/pspnet_r101-d8_769x769_40k_cityscapes_20200606_112753.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r18-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 74.87
+      mIoU(ms+flip): 76.04
+  Config: configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-18-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.7
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_512x1024_80k_cityscapes/pspnet_r18-d8_512x1024_80k_cityscapes_20201225_021458-09ffa746.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_512x1024_80k_cityscapes/pspnet_r18-d8_512x1024_80k_cityscapes-20201225_021458.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r50-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.55
+      mIoU(ms+flip): 79.79
+  Config: configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes/pspnet_r50-d8_512x1024_80k_cityscapes_20200606_112131-2376f12b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes/pspnet_r50-d8_512x1024_80k_cityscapes_20200606_112131.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r50-d8-rsb_4xb2-adamw-80k_cityscapes-512x1024
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.47
+      mIoU(ms+flip): 79.45
+  Config: configs/pspnet/pspnet_r50-d8-rsb_4xb2-adamw-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50b-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes/pspnet_r50-d8_rsb-pretrain_512x1024_adamw_80k_cityscapes_20220315_123238-588c30be.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes/pspnet_r50-d8_rsb-pretrain_512x1024_adamw_80k_cityscapes_20220315_123238.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r101-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.76
+      mIoU(ms+flip): 81.01
+  Config: configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_80k_cityscapes/pspnet_r101-d8_512x1024_80k_cityscapes_20200606_112211-e1e1100f.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_80k_cityscapes/pspnet_r101-d8_512x1024_80k_cityscapes_20200606_112211.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r101-d8_4xb2-amp-80k_cityscapes-512x1024
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.46
+  Config: configs/pspnet/pspnet_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - PSPNet
+    - (FP16)
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.34
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_fp16_512x1024_80k_cityscapes/pspnet_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230919-a0875e5c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_fp16_512x1024_80k_cityscapes/pspnet_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230919.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r18-d8_4xb2-80k_cityscapes-769x769
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 75.9
+      mIoU(ms+flip): 77.86
+  Config: configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-18-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_769x769_80k_cityscapes/pspnet_r18-d8_769x769_80k_cityscapes_20201225_021458-3deefc62.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_769x769_80k_cityscapes/pspnet_r18-d8_769x769_80k_cityscapes-20201225_021458.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r50-d8_4xb2-80k_cityscapes-769x769
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.59
+      mIoU(ms+flip): 80.69
+  Config: configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_769x769_80k_cityscapes/pspnet_r50-d8_769x769_80k_cityscapes_20200606_210121-5ccf03dd.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_769x769_80k_cityscapes/pspnet_r50-d8_769x769_80k_cityscapes_20200606_210121.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r101-d8_4xb2-80k_cityscapes-769x769
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.77
+      mIoU(ms+flip): 81.06
+  Config: configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.oz1z1penmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_769x769_80k_cityscapes/pspnet_r101-d8_769x769_80k_cityscapes_20200606_225055-dba412fa.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_769x769_80k_cityscapes/pspnet_r101-d8_769x769_80k_cityscapes_20200606_225055.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r18b-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 74.23
+      mIoU(ms+flip): 75.79
+  Config: configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-18b-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18b-d8_512x1024_80k_cityscapes/pspnet_r18b-d8_512x1024_80k_cityscapes_20201226_063116-26928a60.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18b-d8_512x1024_80k_cityscapes/pspnet_r18b-d8_512x1024_80k_cityscapes-20201226_063116.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.22
+      mIoU(ms+flip): 79.46
+  Config: configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50b-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d8_512x1024_80k_cityscapes/pspnet_r50b-d8_512x1024_80k_cityscapes_20201225_094315-6344287a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d8_512x1024_80k_cityscapes/pspnet_r50b-d8_512x1024_80k_cityscapes-20201225_094315.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.69
+      mIoU(ms+flip): 80.79
+  Config: configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101b-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_512x1024_80k_cityscapes/pspnet_r101b-d8_512x1024_80k_cityscapes_20201226_170012-3a4d38ab.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_512x1024_80k_cityscapes/pspnet_r101b-d8_512x1024_80k_cityscapes-20201226_170012.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r18b-d8_4xb2-80k_cityscapes-769x769
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 74.92
+      mIoU(ms+flip): 76.9
+  Config: configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-18b-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.7
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18b-d8_769x769_80k_cityscapes/pspnet_r18b-d8_769x769_80k_cityscapes_20201226_080942-bf98d186.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18b-d8_769x769_80k_cityscapes/pspnet_r18b-d8_769x769_80k_cityscapes-20201226_080942.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r50b-d8_4xb2-80k_cityscapes-769x769
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.5
+      mIoU(ms+flip): 79.96
+  Config: configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50b-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d8_769x769_80k_cityscapes/pspnet_r50b-d8_769x769_80k_cityscapes_20201225_094316-4c643cf6.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d8_769x769_80k_cityscapes/pspnet_r50b-d8_769x769_80k_cityscapes-20201225_094316.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r101b-d8_4xb2-80k_cityscapes-769x769
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.87
+      mIoU(ms+flip): 80.04
+  Config: configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101b-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 10.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_769x769_80k_cityscapes/pspnet_r101b-d8_769x769_80k_cityscapes_20201226_171823-f0e7c293.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_769x769_80k_cityscapes/pspnet_r101b-d8_769x769_80k_cityscapes-20201226_171823.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r50b-d32_4xb2-80k_cityscapes-512x1024
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 73.88
+      mIoU(ms+flip): 76.85
+  Config: configs/pspnet/pspnet_r50b-d32_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50-D32
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 3.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d32_512x1024_80k_cityscapes/pspnet_r50-d32_512x1024_80k_cityscapes_20220316_224840-9092b254.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d32_512x1024_80k_cityscapes/pspnet_r50-d32_512x1024_80k_cityscapes_20220316_224840.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r50-d32_rsb_4xb2-adamw-80k_cityscapes-512x1024
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 74.09
+      mIoU(ms+flip): 77.18
+  Config: configs/pspnet/pspnet_r50-d32_rsb_4xb2-adamw-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50b-D32
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 3.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d32_rsb-pretrain_512x1024_adamw_80k_cityscapes/pspnet_r50-d32_rsb-pretrain_512x1024_adamw_80k_cityscapes_20220316_141229-dd9c9610.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d32_rsb-pretrain_512x1024_adamw_80k_cityscapes/pspnet_r50-d32_rsb-pretrain_512x1024_adamw_80k_cityscapes_20220316_141229.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r50b-d32_4xb2-80k_cityscapes-512x1024
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 72.61
+      mIoU(ms+flip): 75.51
+  Config: configs/pspnet/pspnet_r50b-d32_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50b-D32
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 2.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d32_512x1024_80k_cityscapes/pspnet_r50b-d32_512x1024_80k_cityscapes_20220311_152152-23bcaf8c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d32_512x1024_80k_cityscapes/pspnet_r50b-d32_512x1024_80k_cityscapes_20220311_152152.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r50-d8_4xb4-80k_ade20k-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 41.13
+      mIoU(ms+flip): 41.94
+  Config: configs/pspnet/pspnet_r50-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_80k_ade20k/pspnet_r50-d8_512x512_80k_ade20k_20200615_014128-15a8b914.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_80k_ade20k/pspnet_r50-d8_512x512_80k_ade20k_20200615_014128.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r101-d8_4xb4-80k_ade20k-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 43.57
+      mIoU(ms+flip): 44.35
+  Config: configs/pspnet/pspnet_r101-d8_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 12.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_80k_ade20k/pspnet_r101-d8_512x512_80k_ade20k_20200614_031423-b6e782f0.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_80k_ade20k/pspnet_r101-d8_512x512_80k_ade20k_20200614_031423.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r50-d8_4xb4-160k_ade20k-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.48
+      mIoU(ms+flip): 43.44
+  Config: configs/pspnet/pspnet_r50-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_160k_ade20k/pspnet_r50-d8_512x512_160k_ade20k_20200615_184358-1890b0bd.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_160k_ade20k/pspnet_r50-d8_512x512_160k_ade20k_20200615_184358.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r101-d8_4xb4-160k_ade20k-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 44.39
+      mIoU(ms+flip): 45.35
+  Config: configs/pspnet/pspnet_r101-d8_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_160k_ade20k/pspnet_r101-d8_512x512_160k_ade20k_20200615_100650-967c316f.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_160k_ade20k/pspnet_r101-d8_512x512_160k_ade20k_20200615_100650.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r50-d8_4xb4-20k_voc12aug-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 76.78
+      mIoU(ms+flip): 77.61
+  Config: configs/pspnet/pspnet_r50-d8_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_20k_voc12aug/pspnet_r50-d8_512x512_20k_voc12aug_20200617_101958-ed5dfbd9.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_20k_voc12aug/pspnet_r50-d8_512x512_20k_voc12aug_20200617_101958.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r101-d8_4xb4-20k_voc12aug-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 78.47
+      mIoU(ms+flip): 79.25
+  Config: configs/pspnet/pspnet_r101-d8_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_20k_voc12aug/pspnet_r101-d8_512x512_20k_voc12aug_20200617_102003-4aef3c9a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_20k_voc12aug/pspnet_r101-d8_512x512_20k_voc12aug_20200617_102003.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r50-d8_4xb4-40k_voc12aug-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 77.29
+      mIoU(ms+flip): 78.48
+  Config: configs/pspnet/pspnet_r50-d8_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_40k_voc12aug/pspnet_r50-d8_512x512_40k_voc12aug_20200613_161222-ae9c1b8c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_40k_voc12aug/pspnet_r50-d8_512x512_40k_voc12aug_20200613_161222.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r101-d8_4xb4-40k_voc12aug-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 78.52
+      mIoU(ms+flip): 79.57
+  Config: configs/pspnet/pspnet_r101-d8_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_40k_voc12aug/pspnet_r101-d8_512x512_40k_voc12aug_20200613_161222-bc933b18.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_40k_voc12aug/pspnet_r101-d8_512x512_40k_voc12aug_20200613_161222.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r101-d8_4xb4-40k_pascal-context-480x480
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal Context
+    Metrics:
+      mIoU: 46.6
+      mIoU(ms+flip): 47.78
+  Config: configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-480x480.py
+  Metadata:
+    Training Data: Pascal Context
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_40k_pascal_context/pspnet_r101-d8_480x480_40k_pascal_context_20200911_211210-bf0f5d7c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_40k_pascal_context/pspnet_r101-d8_480x480_40k_pascal_context-20200911_211210.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r101-d8_4xb4-80k_pascal-context-480x480
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal Context
+    Metrics:
+      mIoU: 46.03
+      mIoU(ms+flip): 47.15
+  Config: configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-480x480.py
+  Metadata:
+    Training Data: Pascal Context
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_80k_pascal_context/pspnet_r101-d8_480x480_80k_pascal_context_20200911_190530-c86d6233.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_80k_pascal_context/pspnet_r101-d8_480x480_80k_pascal_context-20200911_190530.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r101-d8_4xb4-40k_pascal-context-59-480x480
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal Context 59
+    Metrics:
+      mIoU: 52.02
+      mIoU(ms+flip): 53.54
+  Config: configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-59-480x480.py
+  Metadata:
+    Training Data: Pascal Context 59
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_40k_pascal_context_59/pspnet_r101-d8_480x480_40k_pascal_context_59_20210416_114524-86d44cd4.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_40k_pascal_context_59/pspnet_r101-d8_480x480_40k_pascal_context_59-20210416_114524.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r101-d8_4xb4-80k_pascal-context-59-480x480
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal Context 59
+    Metrics:
+      mIoU: 52.47
+      mIoU(ms+flip): 53.99
+  Config: configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-59-480x480.py
+  Metadata:
+    Training Data: Pascal Context 59
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_80k_pascal_context_59/pspnet_r101-d8_480x480_80k_pascal_context_59_20210416_114418-fa6caaa2.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_80k_pascal_context_59/pspnet_r101-d8_480x480_80k_pascal_context_59-20210416_114418.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r50-d8_4xb4-20k_coco-stuff10k-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 10k
+    Metrics:
+      mIoU: 35.69
+      mIoU(ms+flip): 36.62
+  Config: configs/pspnet/pspnet_r50-d8_4xb4-20k_coco-stuff10k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 10k
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_20k_coco-stuff10k/pspnet_r50-d8_512x512_4x4_20k_coco-stuff10k_20210820_203258-b88df27f.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_20k_coco-stuff10k/pspnet_r50-d8_512x512_4x4_20k_coco-stuff10k_20210820_203258.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r101-d8_4xb4-20k_coco-stuff10k-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 10k
+    Metrics:
+      mIoU: 37.26
+      mIoU(ms+flip): 38.52
+  Config: configs/pspnet/pspnet_r101-d8_4xb4-20k_coco-stuff10k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 10k
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 13.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_20k_coco-stuff10k/pspnet_r101-d8_512x512_4x4_20k_coco-stuff10k_20210820_232135-76aae482.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_20k_coco-stuff10k/pspnet_r101-d8_512x512_4x4_20k_coco-stuff10k_20210820_232135.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r50-d8_4xb4-40k_coco-stuff10k-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 10k
+    Metrics:
+      mIoU: 36.33
+      mIoU(ms+flip): 37.24
+  Config: configs/pspnet/pspnet_r50-d8_4xb4-40k_coco-stuff10k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 10k
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_40k_coco-stuff10k/pspnet_r50-d8_512x512_4x4_40k_coco-stuff10k_20210821_030857-92e2902b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_40k_coco-stuff10k/pspnet_r50-d8_512x512_4x4_40k_coco-stuff10k_20210821_030857.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r101-d8_4xb4-40k_coco-stuff10k-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 10k
+    Metrics:
+      mIoU: 37.76
+      mIoU(ms+flip): 38.86
+  Config: configs/pspnet/pspnet_r101-d8_4xb4-40k_coco-stuff10k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 10k
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_40k_coco-stuff10k/pspnet_r101-d8_512x512_4x4_40k_coco-stuff10k_20210821_014022-831aec95.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_40k_coco-stuff10k/pspnet_r101-d8_512x512_4x4_40k_coco-stuff10k_20210821_014022.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r50-d8_4xb4-80k_coco-stuff164k-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 164k
+    Metrics:
+      mIoU: 38.8
+      mIoU(ms+flip): 39.19
+  Config: configs/pspnet/pspnet_r50-d8_4xb4-80k_coco-stuff164k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 164k
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_80k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_80k_coco-stuff164k_20210707_152034-0e41b2db.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_80k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_80k_coco-stuff164k_20210707_152034.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r101-d8_4xb4-80k_coco-stuff164k-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 164k
+    Metrics:
+      mIoU: 40.34
+      mIoU(ms+flip): 40.79
+  Config: configs/pspnet/pspnet_r101-d8_4xb4-80k_coco-stuff164k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 164k
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 13.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_80k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_80k_coco-stuff164k_20210707_152034-7eb41789.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_80k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_80k_coco-stuff164k_20210707_152034.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r50-d8_4xb4-160k_coco-stuff164k-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 164k
+    Metrics:
+      mIoU: 39.64
+      mIoU(ms+flip): 39.97
+  Config: configs/pspnet/pspnet_r50-d8_4xb4-160k_coco-stuff164k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 164k
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_160k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_160k_coco-stuff164k_20210707_152004-51276a57.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_160k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_160k_coco-stuff164k_20210707_152004.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r101-d8_4xb4-160k_coco-stuff164k-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 164k
+    Metrics:
+      mIoU: 41.28
+      mIoU(ms+flip): 41.66
+  Config: configs/pspnet/pspnet_r101-d8_4xb4-160k_coco-stuff164k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 164k
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_160k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_160k_coco-stuff164k_20210707_152004-4af9621b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_160k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_160k_coco-stuff164k_20210707_152004.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r50-d8_4xb4-320k_coco-stuff164k-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 164k
+    Metrics:
+      mIoU: 40.53
+      mIoU(ms+flip): 40.75
+  Config: configs/pspnet/pspnet_r50-d8_4xb4-320k_coco-stuff164k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 164k
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_320k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_320k_coco-stuff164k_20210707_152004-be9610cc.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_320k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_320k_coco-stuff164k_20210707_152004.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r101-d8_4xb4-320k_coco-stuff164k-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 164k
+    Metrics:
+      mIoU: 41.95
+      mIoU(ms+flip): 42.42
+  Config: configs/pspnet/pspnet_r101-d8_4xb4-320k_coco-stuff164k-512x512.py
+  Metadata:
+    Training Data: COCO-Stuff 164k
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_320k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_320k_coco-stuff164k_20210707_152004-72220c60.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_320k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_320k_coco-stuff164k_20210707_152004.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r18-d8_4xb4-80k_loveda-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: LoveDA
+    Metrics:
+      mIoU: 48.62
+      mIoU(ms+flip): 47.57
+  Config: configs/pspnet/pspnet_r18-d8_4xb4-80k_loveda-512x512.py
+  Metadata:
+    Training Data: LoveDA
+    Batch Size: 16
+    Architecture:
+    - R-18-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.45
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_512x512_80k_loveda/pspnet_r18-d8_512x512_80k_loveda_20211105_052100-b97697f1.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_512x512_80k_loveda/pspnet_r18-d8_512x512_80k_loveda_20211105_052100.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r50-d8_4xb4-80k_loveda-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: LoveDA
+    Metrics:
+      mIoU: 50.46
+      mIoU(ms+flip): 50.19
+  Config: configs/pspnet/pspnet_r50-d8_4xb4-80k_loveda-512x512.py
+  Metadata:
+    Training Data: LoveDA
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.14
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_80k_loveda/pspnet_r50-d8_512x512_80k_loveda_20211104_155728-88610f9f.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_80k_loveda/pspnet_r50-d8_512x512_80k_loveda_20211104_155728.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r101-d8_4xb4-80k_loveda-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: LoveDA
+    Metrics:
+      mIoU: 51.86
+      mIoU(ms+flip): 51.34
+  Config: configs/pspnet/pspnet_r101-d8_4xb4-80k_loveda-512x512.py
+  Metadata:
+    Training Data: LoveDA
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.61
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_80k_loveda/pspnet_r101-d8_512x512_80k_loveda_20211104_153212-1c06c6a8.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_80k_loveda/pspnet_r101-d8_512x512_80k_loveda_20211104_153212.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r18-d8_4xb4-80k_potsdam-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Potsdam
+    Metrics:
+      mIoU: 77.09
+      mIoU(ms+flip): 78.3
+  Config: configs/pspnet/pspnet_r18-d8_4xb4-80k_potsdam-512x512.py
+  Metadata:
+    Training Data: Potsdam
+    Batch Size: 16
+    Architecture:
+    - R-18-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_512x512_80k_potsdam/pspnet_r18-d8_4x4_512x512_80k_potsdam_20211220_125612-7cd046e1.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_512x512_80k_potsdam/pspnet_r18-d8_4x4_512x512_80k_potsdam_20211220_125612.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r50-d8_4xb4-80k_potsdam-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Potsdam
+    Metrics:
+      mIoU: 78.12
+      mIoU(ms+flip): 78.98
+  Config: configs/pspnet/pspnet_r50-d8_4xb4-80k_potsdam-512x512.py
+  Metadata:
+    Training Data: Potsdam
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.14
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_512x512_80k_potsdam/pspnet_r50-d8_4x4_512x512_80k_potsdam_20211219_043541-2dd5fe67.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_512x512_80k_potsdam/pspnet_r50-d8_4x4_512x512_80k_potsdam_20211219_043541.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r101-d8_4xb4-80k_potsdam-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Potsdam
+    Metrics:
+      mIoU: 78.62
+      mIoU(ms+flip): 79.47
+  Config: configs/pspnet/pspnet_r101-d8_4xb4-80k_potsdam-512x512.py
+  Metadata:
+    Training Data: Potsdam
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.61
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_4x4_512x512_80k_potsdam/pspnet_r101-d8_4x4_512x512_80k_potsdam_20211220_125612-aed036c4.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_4x4_512x512_80k_potsdam/pspnet_r101-d8_4x4_512x512_80k_potsdam_20211220_125612.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r18-d8_4xb4-80k_vaihingen-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Vaihingen
+    Metrics:
+      mIoU: 71.46
+      mIoU(ms+flip): 73.36
+  Config: configs/pspnet/pspnet_r18-d8_4xb4-80k_vaihingen-512x512.py
+  Metadata:
+    Training Data: Vaihingen
+    Batch Size: 16
+    Architecture:
+    - R-18-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.45
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_512x512_80k_vaihingen/pspnet_r18-d8_4x4_512x512_80k_vaihingen_20211228_160355-52a8a6f6.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_512x512_80k_vaihingen/pspnet_r18-d8_4x4_512x512_80k_vaihingen_20211228_160355.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r50-d8_4xb4-80k_vaihingen-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Vaihingen
+    Metrics:
+      mIoU: 72.36
+      mIoU(ms+flip): 73.75
+  Config: configs/pspnet/pspnet_r50-d8_4xb4-80k_vaihingen-512x512.py
+  Metadata:
+    Training Data: Vaihingen
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.14
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_512x512_80k_vaihingen/pspnet_r50-d8_4x4_512x512_80k_vaihingen_20211228_160355-382f8f5b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_512x512_80k_vaihingen/pspnet_r50-d8_4x4_512x512_80k_vaihingen_20211228_160355.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r101-d8_4xb4-80k_vaihingen-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Vaihingen
+    Metrics:
+      mIoU: 72.61
+      mIoU(ms+flip): 74.18
+  Config: configs/pspnet/pspnet_r101-d8_4xb4-80k_vaihingen-512x512.py
+  Metadata:
+    Training Data: Vaihingen
+    Batch Size: 16
+    Architecture:
+    - R-101-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.61
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_4x4_512x512_80k_vaihingen/pspnet_r101-d8_4x4_512x512_80k_vaihingen_20211231_230806-8eba0a09.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_4x4_512x512_80k_vaihingen/pspnet_r101-d8_4x4_512x512_80k_vaihingen_20211231_230806.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r18-d8_4xb4-80k_isaid-896x896
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: iSAID
+    Metrics:
+      mIoU: 60.22
+      mIoU(ms+flip): 61.25
+  Config: configs/pspnet/pspnet_r18-d8_4xb4-80k_isaid-896x896.py
+  Metadata:
+    Training Data: iSAID
+    Batch Size: 16
+    Architecture:
+    - R-18-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 4.52
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_896x896_80k_isaid/pspnet_r18-d8_4x4_896x896_80k_isaid_20220110_180526-e84c0b6a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_896x896_80k_isaid/pspnet_r18-d8_4x4_896x896_80k_isaid_20220110_180526.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
+- Name: pspnet_r50-d8_4xb4-80k_isaid-896x896
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: iSAID
+    Metrics:
+      mIoU: 65.36
+      mIoU(ms+flip): 66.48
+  Config: configs/pspnet/pspnet_r50-d8_4xb4-80k_isaid-896x896.py
+  Metadata:
+    Training Data: iSAID
+    Batch Size: 16
+    Architecture:
+    - R-50-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 16.58
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_896x896_80k_isaid/pspnet_r50-d8_4x4_896x896_80k_isaid_20220110_180629-1f21dc32.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_896x896_80k_isaid/pspnet_r50-d8_4x4_896x896_80k_isaid_20220110_180629.log.json
+  Paper:
+    Title: Pyramid Scene Parsing Network
+    URL: https://arxiv.org/abs/1612.01105
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..f33d653
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024_dark-zurich-1920x1080.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024_dark-zurich-1920x1080.py
new file mode 100644
index 0000000..5babaa8
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024_dark-zurich-1920x1080.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_dark-zurich-1920x1080.py'  # noqa
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024_night-driving-1920x1080.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024_night-driving-1920x1080.py
new file mode 100644
index 0000000..a9480c5
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024_night-driving-1920x1080.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_night-driving-1920x1080.py'  # noqa
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..e05cff6
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb2-40k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..6704cdd
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..3733e69
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..52f86b5
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
@@ -0,0 +1,6 @@
+_base_ = './pspnet_r101-d8_4xb2-80k_cityscapes-512x1024.py'
+optim_wrapper = dict(
+    _delete_=True,
+    type='AmpOptimWrapper',
+    optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005),
+    loss_scale=512.)
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..2231049
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb4-160k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-160k_coco-stuff164k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-160k_coco-stuff164k-512x512.py
new file mode 100644
index 0000000..f5390f8
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-160k_coco-stuff164k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb4-160k_coco-stuff164k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-20k_coco-stuff10k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-20k_coco-stuff10k-512x512.py
new file mode 100644
index 0000000..84a986c
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-20k_coco-stuff10k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb4-20k_coco-stuff10k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..71897dd
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb4-20k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-320k_coco-stuff164k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-320k_coco-stuff164k-512x512.py
new file mode 100644
index 0000000..ebaea36
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-320k_coco-stuff164k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb4-320k_coco-stuff164k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_coco-stuff10k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_coco-stuff10k-512x512.py
new file mode 100644
index 0000000..2a55f53
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_coco-stuff10k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb4-40k_coco-stuff10k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-480x480.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-480x480.py
new file mode 100644
index 0000000..205d00b
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-480x480.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb4-40k_pascal-context-480x480.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-59-480x480.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-59-480x480.py
new file mode 100644
index 0000000..0d7c176
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-59-480x480.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb4-40k_pascal-context-59-480x480.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..0599f31
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb4-40k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..f955603
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb4-80k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_coco-stuff164k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_coco-stuff164k-512x512.py
new file mode 100644
index 0000000..4a34f97
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_coco-stuff164k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb4-80k_coco-stuff164k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_loveda-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_loveda-512x512.py
new file mode 100644
index 0000000..7076877
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_loveda-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb4-80k_loveda-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-480x480.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-480x480.py
new file mode 100644
index 0000000..0ac40dc
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-480x480.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb4-80k_pascal-context-480x480.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-59-480x480.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-59-480x480.py
new file mode 100644
index 0000000..307188c
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-59-480x480.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb4-80k_pascal-context-59-480x480.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_potsdam-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_potsdam-512x512.py
new file mode 100644
index 0000000..31ed2f2
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_potsdam-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb4-80k_potsdam-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_vaihingen-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_vaihingen-512x512.py
new file mode 100644
index 0000000..ac33ed7
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_vaihingen-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb4-80k_vaihingen-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..d2c0f69
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,4 @@
+_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='torchvision://resnet101',
+    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024_dark-zurich-1920x1080.py b/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024_dark-zurich-1920x1080.py
new file mode 100644
index 0000000..b181744
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024_dark-zurich-1920x1080.py
@@ -0,0 +1,4 @@
+_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-512x1024_dark-zurich-1920x1080.py'  # noqa
+model = dict(
+    pretrained='torchvision://resnet101',
+    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024_night-driving-1920x1080.py b/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024_night-driving-1920x1080.py
new file mode 100644
index 0000000..6a8994b
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024_night-driving-1920x1080.py
@@ -0,0 +1,4 @@
+_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-512x1024_night-driving-1920x1080.py'  # noqa
+model = dict(
+    pretrained='torchvision://resnet101',
+    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..891bfd5
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,4 @@
+_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(
+    pretrained='torchvision://resnet101',
+    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..a4b342e
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,9 @@
+_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='open-mmlab://resnet18_v1c',
+    backbone=dict(depth=18),
+    decode_head=dict(
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..0e7f3e9
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,9 @@
+_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(
+    pretrained='open-mmlab://resnet18_v1c',
+    backbone=dict(depth=18),
+    decode_head=dict(
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_isaid-896x896.py b/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_isaid-896x896.py
new file mode 100644
index 0000000..efce7a0
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_isaid-896x896.py
@@ -0,0 +1,9 @@
+_base_ = './pspnet_r50-d8_4xb4-80k_isaid-896x896.py'
+model = dict(
+    pretrained='open-mmlab://resnet18_v1c',
+    backbone=dict(depth=18),
+    decode_head=dict(
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_loveda-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_loveda-512x512.py
new file mode 100644
index 0000000..80e2d20
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_loveda-512x512.py
@@ -0,0 +1,9 @@
+_base_ = './pspnet_r50-d8_4xb4-80k_loveda-512x512.py'
+model = dict(
+    pretrained='open-mmlab://resnet18_v1c',
+    backbone=dict(depth=18),
+    decode_head=dict(
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_potsdam-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_potsdam-512x512.py
new file mode 100644
index 0000000..1ef0585
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_potsdam-512x512.py
@@ -0,0 +1,9 @@
+_base_ = './pspnet_r50-d8_4xb4-80k_potsdam-512x512.py'
+model = dict(
+    pretrained='open-mmlab://resnet18_v1c',
+    backbone=dict(depth=18),
+    decode_head=dict(
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_vaihingen-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_vaihingen-512x512.py
new file mode 100644
index 0000000..51e66d2
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_vaihingen-512x512.py
@@ -0,0 +1,9 @@
+_base_ = './pspnet_r50-d8_4xb4-80k_vaihingen-512x512.py'
+model = dict(
+    pretrained='open-mmlab://resnet18_v1c',
+    backbone=dict(depth=18),
+    decode_head=dict(
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..2e356c5
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,9 @@
+_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='torchvision://resnet18',
+    backbone=dict(type='ResNet', depth=18),
+    decode_head=dict(
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..831354d
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,9 @@
+_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(
+    pretrained='torchvision://resnet18',
+    backbone=dict(type='ResNet', depth=18),
+    decode_head=dict(
+        in_channels=512,
+        channels=128,
+    ),
+    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d32_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r50-d32_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..5700b5b
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d32_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,9 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(dilations=(1, 1, 2, 4), strides=(1, 2, 2, 2)))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d32_rsb_4xb2-adamw-80k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r50-d32_rsb_4xb2-adamw-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..1390329
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d32_rsb_4xb2-adamw-80k_cityscapes-512x1024.py
@@ -0,0 +1,35 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+checkpoint = 'https://download.openmmlab.com/mmclassification/v0/resnet/resnet50_8xb256-rsb-a1-600e_in1k_20211228-20e21305.pth'  # noqa
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        type='ResNet',
+        init_cfg=dict(
+            type='Pretrained', prefix='backbone.', checkpoint=checkpoint),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 2, 2)))
+
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(type='AdamW', lr=0.0005, weight_decay=0.05),
+    clip_grad=dict(max_norm=1, norm_type=2))
+# learning policy
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0,
+        end=1000),
+    dict(
+        type='MultiStepLR',
+        begin=1000,
+        end=80000,
+        by_epoch=False,
+        milestones=[60000, 72000],
+    )
+]
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8-rsb_4xb2-adamw-80k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8-rsb_4xb2-adamw-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..b83a0b4
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8-rsb_4xb2-adamw-80k_cityscapes-512x1024.py
@@ -0,0 +1,33 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+checkpoint = 'https://download.openmmlab.com/mmclassification/v0/resnet/resnet50_8xb256-rsb-a1-600e_in1k_20211228-20e21305.pth'  # noqa
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        type='ResNet',
+        init_cfg=dict(
+            type='Pretrained', prefix='backbone.', checkpoint=checkpoint)))
+
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(type='AdamW', lr=0.0005, weight_decay=0.05),
+    clip_grad=dict(max_norm=1, norm_type=2))
+# learning policy
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0,
+        end=1000),
+    dict(
+        type='MultiStepLR',
+        begin=1000,
+        end=80000,
+        by_epoch=False,
+        milestones=[60000, 72000],
+    )
+]
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..a9dcb52
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_dark-zurich-1920x1080.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_dark-zurich-1920x1080.py
new file mode 100644
index 0000000..1bf4a13
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_dark-zurich-1920x1080.py
@@ -0,0 +1,24 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
+
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(1920, 1080), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+test_dataloader = dict(
+    dataset=dict(
+        type='DarkZurichDataset',
+        data_root='data/dark_zurich/',
+        data_prefix=dict(
+            img_path='rgb_anon/val/night/GOPR0356',
+            seg_map_path='gt/val/night/GOPR0356'),
+        pipeline=test_pipeline))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_night-driving-1920x1080.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_night-driving-1920x1080.py
new file mode 100644
index 0000000..b912589
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_night-driving-1920x1080.py
@@ -0,0 +1,25 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
+
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(1920, 1080), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+test_dataloader = dict(
+    dataset=dict(
+        type='NightDrivingDataset',
+        data_root='data/NighttimeDrivingTest/',
+        data_prefix=dict(
+            img_path='leftImg8bit/test/night',
+            seg_map_path='gtCoarse_daytime_trainvaltest/test/night'),
+        pipeline=test_pipeline))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..6baa31b
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..6ea27de
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024_dark-zurich-1920x1080.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024_dark-zurich-1920x1080.py
new file mode 100644
index 0000000..200679f
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024_dark-zurich-1920x1080.py
@@ -0,0 +1,25 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
+
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(1920, 1080), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+test_dataloader = dict(
+    dataset=dict(
+        type='DarkZurichDataset',
+        data_root='data/dark_zurich/',
+        data_prefix=dict(
+            img_path='rgb_anon/val/night/GOPR0356',
+            seg_map_path='gt/val/night/GOPR0356'),
+        pipeline=test_pipeline))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024_night-driving-1920x1080.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024_night-driving-1920x1080.py
new file mode 100644
index 0000000..5173813
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024_night-driving-1920x1080.py
@@ -0,0 +1,25 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
+
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(1920, 1080), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+test_dataloader = dict(
+    dataset=dict(
+        type='NightDrivingDataset',
+        data_root='data/NighttimeDrivingTest/',
+        data_prefix=dict(
+            img_path='leftImg8bit/test/night',
+            seg_map_path='gtCoarse_daytime_trainvaltest/test/night'),
+        pipeline=test_pipeline))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..d43d30a
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..3d9164f
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-160k_coco-stuff164k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-160k_coco-stuff164k-512x512.py
new file mode 100644
index 0000000..6185c2e
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-160k_coco-stuff164k-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py',
+    '../_base_/datasets/coco-stuff164k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=171),
+    auxiliary_head=dict(num_classes=171))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-20k_coco-stuff10k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-20k_coco-stuff10k-512x512.py
new file mode 100644
index 0000000..8c1ba2d
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-20k_coco-stuff10k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/coco-stuff10k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_20k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=171),
+    auxiliary_head=dict(num_classes=171))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..0f60819
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_20k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-320k_coco-stuff164k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-320k_coco-stuff164k-512x512.py
new file mode 100644
index 0000000..2a9ce4c
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-320k_coco-stuff164k-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py',
+    '../_base_/datasets/coco-stuff164k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_320k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=171),
+    auxiliary_head=dict(num_classes=171))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_coco-stuff10k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_coco-stuff10k-512x512.py
new file mode 100644
index 0000000..fae57b0
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_coco-stuff10k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/coco-stuff10k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=171),
+    auxiliary_head=dict(num_classes=171))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_pascal-context-480x480.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_pascal-context-480x480.py
new file mode 100644
index 0000000..08a2144
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_pascal-context-480x480.py
@@ -0,0 +1,14 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py',
+    '../_base_/datasets/pascal_context.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (480, 480)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=60),
+    auxiliary_head=dict(num_classes=60),
+    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
+optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_pascal-context-59-480x480.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_pascal-context-59-480x480.py
new file mode 100644
index 0000000..b654495
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_pascal-context-59-480x480.py
@@ -0,0 +1,14 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py',
+    '../_base_/datasets/pascal_context_59.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (480, 480)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=59),
+    auxiliary_head=dict(num_classes=59),
+    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
+optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..c4a4611
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..bb12aed
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_coco-stuff164k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_coco-stuff164k-512x512.py
new file mode 100644
index 0000000..954a653
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_coco-stuff164k-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py',
+    '../_base_/datasets/coco-stuff164k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=171),
+    auxiliary_head=dict(num_classes=171))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_isaid-896x896.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_isaid-896x896.py
new file mode 100644
index 0000000..63165b6
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_isaid-896x896.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/isaid.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (896, 896)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=16),
+    auxiliary_head=dict(num_classes=16))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_loveda-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_loveda-512x512.py
new file mode 100644
index 0000000..920729d
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_loveda-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/loveda.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=7),
+    auxiliary_head=dict(num_classes=7))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_pascal-context-480x480.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_pascal-context-480x480.py
new file mode 100644
index 0000000..a7d8247
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_pascal-context-480x480.py
@@ -0,0 +1,14 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py',
+    '../_base_/datasets/pascal_context.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (480, 480)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=60),
+    auxiliary_head=dict(num_classes=60),
+    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
+optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_pascal-context-59-480x480.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_pascal-context-59-480x480.py
new file mode 100644
index 0000000..b7abc1b
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_pascal-context-59-480x480.py
@@ -0,0 +1,14 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py',
+    '../_base_/datasets/pascal_context_59.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (480, 480)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=59),
+    auxiliary_head=dict(num_classes=59),
+    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
+optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_potsdam-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_potsdam-512x512.py
new file mode 100644
index 0000000..afb3977
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_potsdam-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/potsdam.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=6),
+    auxiliary_head=dict(num_classes=6))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_vaihingen-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_vaihingen-512x512.py
new file mode 100644
index 0000000..35322d2
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_vaihingen-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/vaihingen.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=6),
+    auxiliary_head=dict(num_classes=6))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50b-d32_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r50b-d32_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..64e5509
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50b-d32_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained='torchvision://resnet50',
+    backbone=dict(type='ResNet', dilations=(1, 1, 2, 4), strides=(1, 2, 2, 2)))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..7dd64b3
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='torchvision://resnet50', backbone=dict(type='ResNet'))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..3875c09
--- /dev/null
+++ b/mmsegmentation/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-769x769.py'
+model = dict(pretrained='torchvision://resnet50', backbone=dict(type='ResNet'))
diff --git a/mmsegmentation/configs/resnest/README.md b/mmsegmentation/configs/resnest/README.md
new file mode 100644
index 0000000..304791a
--- /dev/null
+++ b/mmsegmentation/configs/resnest/README.md
@@ -0,0 +1,54 @@
+# ResNeSt
+
+> [ResNeSt: Split-Attention Networks](https://arxiv.org/abs/2004.08955)
+
+## Introduction
+
+<!-- [BACKBONE] -->
+
+<a href="https://github.com/zhanghang1989/ResNeSt">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/resnest.py#L271">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+It is well known that featuremap attention and multi-path representation are important for visual recognition. In this paper, we present a modularized architecture, which applies the channel-wise attention on different network branches to leverage their success in capturing cross-feature interactions and learning diverse representations. Our design results in a simple and unified computation block, which can be parameterized using only a few variables. Our model, named ResNeSt, outperforms EfficientNet in accuracy and latency trade-off on image classification. In addition, ResNeSt has achieved superior transfer learning results on several public benchmarks serving as the backbone, and has been adopted by the winning entries of COCO-LVIS challenge. The source code for complete system and pretrained models are publicly available.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142902526-3cf33345-7e40-47a6-985e-4381857e21df.png" width="60%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                         | download                                                                                                                                                                                                                                                                                                                                                                               |
+| ---------- | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FCN        | S-101-D8 | 512x1024  |   80000 |     11.4 | 2.39           | V100   | 77.56 | 78.98         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/resnest/resnest_s101-d8_fcn_4xb2-80k_cityscapes-512x1024.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/fcn_s101-d8_512x1024_80k_cityscapes/fcn_s101-d8_512x1024_80k_cityscapes_20200807_140631-f8d155b3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/fcn_s101-d8_512x1024_80k_cityscapes/fcn_s101-d8_512x1024_80k_cityscapes-20200807_140631.log.json)                                         |
+| PSPNet     | S-101-D8 | 512x1024  |   80000 |     11.8 | 2.52           | V100   | 78.57 | 79.19         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/resnest/resnest_s101-d8_pspnet_4xb2-80k_cityscapes512x1024.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/pspnet_s101-d8_512x1024_80k_cityscapes/pspnet_s101-d8_512x1024_80k_cityscapes_20200807_140631-c75f3b99.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/pspnet_s101-d8_512x1024_80k_cityscapes/pspnet_s101-d8_512x1024_80k_cityscapes-20200807_140631.log.json)                             |
+| DeepLabV3  | S-101-D8 | 512x1024  |   80000 |     11.9 | 1.88           | V100   | 79.67 | 80.51         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/resnest/resnest_s101-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py)     | [model](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3_s101-d8_512x1024_80k_cityscapes/deeplabv3_s101-d8_512x1024_80k_cityscapes_20200807_144429-b73c4270.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3_s101-d8_512x1024_80k_cityscapes/deeplabv3_s101-d8_512x1024_80k_cityscapes-20200807_144429.log.json)                 |
+| DeepLabV3+ | S-101-D8 | 512x1024  |   80000 |     13.2 | 2.36           | V100   | 79.62 | 80.27         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/resnest/resnest_s101-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3plus_s101-d8_512x1024_80k_cityscapes/deeplabv3plus_s101-d8_512x1024_80k_cityscapes_20200807_144429-1239eb43.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3plus_s101-d8_512x1024_80k_cityscapes/deeplabv3plus_s101-d8_512x1024_80k_cityscapes-20200807_144429.log.json) |
+
+### ADE20K
+
+| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                     | download                                                                                                                                                                                                                                                                                                                                                               |
+| ---------- | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FCN        | S-101-D8 | 512x512   |  160000 |     14.2 | 12.86          | V100   | 45.62 | 46.16         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/resnest/resnest_s101-d8_fcn_4xb4-160k_ade20k-512x512.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/fcn_s101-d8_512x512_160k_ade20k/fcn_s101-d8_512x512_160k_ade20k_20200807_145416-d3160329.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/fcn_s101-d8_512x512_160k_ade20k/fcn_s101-d8_512x512_160k_ade20k-20200807_145416.log.json)                                         |
+| PSPNet     | S-101-D8 | 512x512   |  160000 |     14.2 | 13.02          | V100   | 45.44 | 46.28         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/resnest/resnest_s101-d8_pspnet_4xb4-160k_ade20k-512x512.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/pspnet_s101-d8_512x512_160k_ade20k/pspnet_s101-d8_512x512_160k_ade20k_20200807_145416-a6daa92a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/pspnet_s101-d8_512x512_160k_ade20k/pspnet_s101-d8_512x512_160k_ade20k-20200807_145416.log.json)                             |
+| DeepLabV3  | S-101-D8 | 512x512   |  160000 |     14.6 | 9.28           | V100   | 45.71 | 46.59         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/resnest/resnest_s101-d8_deeplabv3_4xb4-160k_ade20k-512x512.py)     | [model](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3_s101-d8_512x512_160k_ade20k/deeplabv3_s101-d8_512x512_160k_ade20k_20200807_144503-17ecabe5.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3_s101-d8_512x512_160k_ade20k/deeplabv3_s101-d8_512x512_160k_ade20k-20200807_144503.log.json)                 |
+| DeepLabV3+ | S-101-D8 | 512x512   |  160000 |     16.2 | 11.96          | V100   | 46.47 | 47.27         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/resnest/resnest_s101-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3plus_s101-d8_512x512_160k_ade20k/deeplabv3plus_s101-d8_512x512_160k_ade20k_20200807_144503-27b26226.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3plus_s101-d8_512x512_160k_ade20k/deeplabv3plus_s101-d8_512x512_160k_ade20k-20200807_144503.log.json) |
+
+## Citation
+
+```bibtex
+@article{zhang2020resnest,
+title={ResNeSt: Split-Attention Networks},
+author={Zhang, Hang and Wu, Chongruo and Zhang, Zhongyue and Zhu, Yi and Zhang, Zhi and Lin, Haibin and Sun, Yue and He, Tong and Muller, Jonas and Manmatha, R. and Li, Mu and Smola, Alexander},
+journal={arXiv preprint arXiv:2004.08955},
+year={2020}
+}
+```
diff --git a/mmsegmentation/configs/resnest/metafile.yaml b/mmsegmentation/configs/resnest/metafile.yaml
new file mode 100644
index 0000000..0b8d41e
--- /dev/null
+++ b/mmsegmentation/configs/resnest/metafile.yaml
@@ -0,0 +1,193 @@
+Models:
+- Name: resnest_s101-d8_fcn_4xb2-80k_cityscapes-512x1024
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.56
+      mIoU(ms+flip): 78.98
+  Config: configs/resnest/resnest_s101-d8_fcn_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - S-101-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 11.4
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/fcn_s101-d8_512x1024_80k_cityscapes/fcn_s101-d8_512x1024_80k_cityscapes_20200807_140631-f8d155b3.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/fcn_s101-d8_512x1024_80k_cityscapes/fcn_s101-d8_512x1024_80k_cityscapes-20200807_140631.log.json
+  Paper:
+    Title: 'ResNeSt: Split-Attention Networks'
+    URL: https://arxiv.org/abs/2004.08955
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/resnest.py#L271
+  Framework: PyTorch
+- Name: resnest_s101-d8_pspnet_4xb2-80k_cityscapes512x1024
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.57
+      mIoU(ms+flip): 79.19
+  Config: configs/resnest/resnest_s101-d8_pspnet_4xb2-80k_cityscapes512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - S-101-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 11.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/pspnet_s101-d8_512x1024_80k_cityscapes/pspnet_s101-d8_512x1024_80k_cityscapes_20200807_140631-c75f3b99.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/pspnet_s101-d8_512x1024_80k_cityscapes/pspnet_s101-d8_512x1024_80k_cityscapes-20200807_140631.log.json
+  Paper:
+    Title: 'ResNeSt: Split-Attention Networks'
+    URL: https://arxiv.org/abs/2004.08955
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/resnest.py#L271
+  Framework: PyTorch
+- Name: resnest_s101-d8_deeplabv3_4xb2-80k_cityscapes-512x1024
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.67
+      mIoU(ms+flip): 80.51
+  Config: configs/resnest/resnest_s101-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - S-101-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 11.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3_s101-d8_512x1024_80k_cityscapes/deeplabv3_s101-d8_512x1024_80k_cityscapes_20200807_144429-b73c4270.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3_s101-d8_512x1024_80k_cityscapes/deeplabv3_s101-d8_512x1024_80k_cityscapes-20200807_144429.log.json
+  Paper:
+    Title: 'ResNeSt: Split-Attention Networks'
+    URL: https://arxiv.org/abs/2004.08955
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/resnest.py#L271
+  Framework: PyTorch
+- Name: resnest_s101-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.62
+      mIoU(ms+flip): 80.27
+  Config: configs/resnest/resnest_s101-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - S-101-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 13.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3plus_s101-d8_512x1024_80k_cityscapes/deeplabv3plus_s101-d8_512x1024_80k_cityscapes_20200807_144429-1239eb43.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3plus_s101-d8_512x1024_80k_cityscapes/deeplabv3plus_s101-d8_512x1024_80k_cityscapes-20200807_144429.log.json
+  Paper:
+    Title: 'ResNeSt: Split-Attention Networks'
+    URL: https://arxiv.org/abs/2004.08955
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/resnest.py#L271
+  Framework: PyTorch
+- Name: resnest_s101-d8_fcn_4xb4-160k_ade20k-512x512
+  In Collection: FCN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 45.62
+      mIoU(ms+flip): 46.16
+  Config: configs/resnest/resnest_s101-d8_fcn_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - S-101-D8
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 14.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/fcn_s101-d8_512x512_160k_ade20k/fcn_s101-d8_512x512_160k_ade20k_20200807_145416-d3160329.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/fcn_s101-d8_512x512_160k_ade20k/fcn_s101-d8_512x512_160k_ade20k-20200807_145416.log.json
+  Paper:
+    Title: 'ResNeSt: Split-Attention Networks'
+    URL: https://arxiv.org/abs/2004.08955
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/resnest.py#L271
+  Framework: PyTorch
+- Name: resnest_s101-d8_pspnet_4xb4-160k_ade20k-512x512
+  In Collection: PSPNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 45.44
+      mIoU(ms+flip): 46.28
+  Config: configs/resnest/resnest_s101-d8_pspnet_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - S-101-D8
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 14.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/pspnet_s101-d8_512x512_160k_ade20k/pspnet_s101-d8_512x512_160k_ade20k_20200807_145416-a6daa92a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/pspnet_s101-d8_512x512_160k_ade20k/pspnet_s101-d8_512x512_160k_ade20k-20200807_145416.log.json
+  Paper:
+    Title: 'ResNeSt: Split-Attention Networks'
+    URL: https://arxiv.org/abs/2004.08955
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/resnest.py#L271
+  Framework: PyTorch
+- Name: resnest_s101-d8_deeplabv3_4xb4-160k_ade20k-512x512
+  In Collection: DeepLabV3
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 45.71
+      mIoU(ms+flip): 46.59
+  Config: configs/resnest/resnest_s101-d8_deeplabv3_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - S-101-D8
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 14.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3_s101-d8_512x512_160k_ade20k/deeplabv3_s101-d8_512x512_160k_ade20k_20200807_144503-17ecabe5.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3_s101-d8_512x512_160k_ade20k/deeplabv3_s101-d8_512x512_160k_ade20k-20200807_144503.log.json
+  Paper:
+    Title: 'ResNeSt: Split-Attention Networks'
+    URL: https://arxiv.org/abs/2004.08955
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/resnest.py#L271
+  Framework: PyTorch
+- Name: resnest_s101-d8_deeplabv3plus_4xb4-160k_ade20k-512x512
+  In Collection: DeepLabV3+
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 46.47
+      mIoU(ms+flip): 47.27
+  Config: configs/resnest/resnest_s101-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - S-101-D8
+    - DeepLabV3+
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 16.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3plus_s101-d8_512x512_160k_ade20k/deeplabv3plus_s101-d8_512x512_160k_ade20k_20200807_144503-27b26226.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3plus_s101-d8_512x512_160k_ade20k/deeplabv3plus_s101-d8_512x512_160k_ade20k-20200807_144503.log.json
+  Paper:
+    Title: 'ResNeSt: Split-Attention Networks'
+    URL: https://arxiv.org/abs/2004.08955
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/resnest.py#L271
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..7ece894
--- /dev/null
+++ b/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,9 @@
+_base_ = '../deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='open-mmlab://resnest101',
+    backbone=dict(
+        type='ResNeSt',
+        stem_channels=128,
+        radix=2,
+        reduction_factor=4,
+        avg_down_stride=True))
diff --git a/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..c285230
--- /dev/null
+++ b/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,9 @@
+_base_ = '../deeplabv3/deeplabv3_r101-d8_4xb4-160k_ade20k-512x512.py'
+model = dict(
+    pretrained='open-mmlab://resnest101',
+    backbone=dict(
+        type='ResNeSt',
+        stem_channels=128,
+        radix=2,
+        reduction_factor=4,
+        avg_down_stride=True))
diff --git a/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..5c43a95
--- /dev/null
+++ b/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,9 @@
+_base_ = '../deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024.py'  # noqa
+model = dict(
+    pretrained='open-mmlab://resnest101',
+    backbone=dict(
+        type='ResNeSt',
+        stem_channels=128,
+        radix=2,
+        reduction_factor=4,
+        avg_down_stride=True))
diff --git a/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..ce39d37
--- /dev/null
+++ b/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,9 @@
+_base_ = '../deeplabv3plus/deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512.py'
+model = dict(
+    pretrained='open-mmlab://resnest101',
+    backbone=dict(
+        type='ResNeSt',
+        stem_channels=128,
+        radix=2,
+        reduction_factor=4,
+        avg_down_stride=True))
diff --git a/mmsegmentation/configs/resnest/resnest_s101-d8_fcn_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/resnest/resnest_s101-d8_fcn_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..fc333e4
--- /dev/null
+++ b/mmsegmentation/configs/resnest/resnest_s101-d8_fcn_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,9 @@
+_base_ = '../fcn/fcn_r101-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='open-mmlab://resnest101',
+    backbone=dict(
+        type='ResNeSt',
+        stem_channels=128,
+        radix=2,
+        reduction_factor=4,
+        avg_down_stride=True))
diff --git a/mmsegmentation/configs/resnest/resnest_s101-d8_fcn_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/resnest/resnest_s101-d8_fcn_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..af12733
--- /dev/null
+++ b/mmsegmentation/configs/resnest/resnest_s101-d8_fcn_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,9 @@
+_base_ = '../fcn/fcn_r101-d8_4xb4-160k_ade20k-512x512.py'
+model = dict(
+    pretrained='open-mmlab://resnest101',
+    backbone=dict(
+        type='ResNeSt',
+        stem_channels=128,
+        radix=2,
+        reduction_factor=4,
+        avg_down_stride=True))
diff --git a/mmsegmentation/configs/resnest/resnest_s101-d8_pspnet_4xb2-80k_cityscapes512x1024.py b/mmsegmentation/configs/resnest/resnest_s101-d8_pspnet_4xb2-80k_cityscapes512x1024.py
new file mode 100644
index 0000000..3aab524
--- /dev/null
+++ b/mmsegmentation/configs/resnest/resnest_s101-d8_pspnet_4xb2-80k_cityscapes512x1024.py
@@ -0,0 +1,9 @@
+_base_ = '../pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='open-mmlab://resnest101',
+    backbone=dict(
+        type='ResNeSt',
+        stem_channels=128,
+        radix=2,
+        reduction_factor=4,
+        avg_down_stride=True))
diff --git a/mmsegmentation/configs/resnest/resnest_s101-d8_pspnet_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/resnest/resnest_s101-d8_pspnet_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..66e6639
--- /dev/null
+++ b/mmsegmentation/configs/resnest/resnest_s101-d8_pspnet_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,9 @@
+_base_ = '../pspnet/pspnet_r101-d8_4xb4-160k_ade20k-512x512.py'
+model = dict(
+    pretrained='open-mmlab://resnest101',
+    backbone=dict(
+        type='ResNeSt',
+        stem_channels=128,
+        radix=2,
+        reduction_factor=4,
+        avg_down_stride=True))
diff --git a/mmsegmentation/configs/san/README.md b/mmsegmentation/configs/san/README.md
new file mode 100644
index 0000000..d9940eb
--- /dev/null
+++ b/mmsegmentation/configs/san/README.md
@@ -0,0 +1,47 @@
+# SAN
+
+> [Side Adapter Network for Open-Vocabulary Semantic Segmentation](https://arxiv.org/abs/2302.12242)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/MendelXu/SAN">Official Repo</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+This paper presents a new framework for open-vocabulary semantic segmentation with the pre-trained vision-language model, named Side Adapter Network (SAN). Our approach models the semantic segmentation task as a region recognition problem. A side network is attached to a frozen CLIP model with two branches: one for predicting mask proposals, and the other for predicting attention bias which is applied in the CLIP model to recognize the class of masks. This decoupled design has the benefit CLIP in recognizing the class of mask proposals. Since the attached side network can reuse CLIP features, it can be very light. In addition, the entire network can be trained end-to-end, allowing the side network to be adapted to the frozen CLIP model, which makes the predicted mask proposals CLIP-aware. Our approach is fast, accurate, and only adds a few additional trainable parameters. We evaluate our approach on multiple semantic segmentation benchmarks. Our method significantly outperforms other counterparts, with up to 18 times fewer trainable parameters and 19 times faster inference speed. We hope our approach will serve as a solid baseline and help ease future research in open-vocabulary semantic segmentation.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://github.com/MendelXu/SAN/blob/main/resources/arch.png" width="800"/>
+</div>
+
+## Results and models
+
+### COCO-Stuff164k
+
+| Method | Backbone | Pretrained   | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                   | download                                                                                                                                                                                    |
+| ------ | -------- | ------------ | --------- | ------- | -------- | -------------- | ------ | ----- | ------------- | -------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| SAN    | ViT-B_16 | CLIP_ViT-B16 | 640x640   | 60000   | 12.61    | -              | V100   | 41.93 | 41.77         | https://github.com/open-mmlab/mmsegmentation/blob/main/configs/san/san-vit-b16_coco-stuff164k-640x640.py | [model](https://download.openmmlab.com/mmsegmentation/v0.5/san/san-vit-b16_20230906-fd0a7684.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/san/san-vit-b16_20230906.log) |
+| SAN    | ViT-L_14 | CLIP_ViT-L14 | 640x640   | 60000   | 22.84    | -              | V100   | 45.78 | 43.99         | https://github.com/open-mmlab/mmsegmentation/blob/main/configs/san/san-vit-l14_coco-stuff164k-640x640.py | [model](https://download.openmmlab.com/mmsegmentation/v0.5/san/san-vit-l14_20230907-a11e098f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/san/san-vit-l14_20230907.log) |
+
+## Notes
+
+git push
+The pretrained weights in config files are converted from open_clip models using tools/model_converters/clip2mmseg.py.
+
+## Citation
+
+```bibtex
+@inproceedings{xu2023side,
+  title={Side adapter network for open-vocabulary semantic segmentation},
+  author={Xu, Mengde and Zhang, Zheng and Wei, Fangyun and Hu, Han and Bai, Xiang},
+  booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
+  pages={2945--2954},
+  year={2023}
+}
+```
diff --git a/mmsegmentation/configs/san/metafile.yaml b/mmsegmentation/configs/san/metafile.yaml
new file mode 100644
index 0000000..117d088
--- /dev/null
+++ b/mmsegmentation/configs/san/metafile.yaml
@@ -0,0 +1,61 @@
+Collections:
+- Name: SAN
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - COCO-Stuff 164k
+  Paper:
+    Title: 'Side Adapter Network for Open-Vocabulary Semantic Segmentation'
+    URL: https://arxiv.org/abs/2302.12242
+  README: configs/san/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: san-vit-b16_coco-stuff164k-640x640
+  In Collection: SAN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 164k
+    Metrics:
+      mIoU: 41.93
+      mIoU(ms+flip): 41.77
+  Config: configs/san/san-vit-b16_coco-stuff164k-640x640.py
+  Metadata:
+    Training Data: COCO-Stuff 164k
+    Batch Size: 16
+    Architecture:
+    - SAN
+    - ViT
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 12.61
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/san/san-vit-b16_20230906-fd0a7684.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/san/san-vit-b16_20230906.log
+  Paper:
+    Title: 'Side Adapter Network for Open-Vocabulary Semantic Segmentation'
+    URL: https://arxiv.org/abs/2302.12242
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/mmseg/models/decode_heads/san_head.py#L470
+  Framework: PyTorch
+- Name: san-vit-l14_coco-stuff164k-640x640
+  In Collection: SAN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: COCO-Stuff 164k
+    Metrics:
+      mIoU: 45.78
+      mIoU(ms+flip): 43.99
+  Config: configs/san/san-vit-l14_coco-stuff164k-640x640.py
+  Metadata:
+    Training Data: COCO-Stuff 164k
+    Batch Size: 16
+    Architecture:
+    - SAN
+    - ViT
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 12.61
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/san/san-vit-l14_20230907-a11e098f.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/san/san-vit-l14_20230907.log
+  Paper:
+    Title: 'Side Adapter Network for Open-Vocabulary Semantic Segmentation'
+    URL: https://arxiv.org/abs/2302.12242
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/mmseg/models/decode_heads/san_head.py#L470
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/san/san-vit-b16_coco-stuff164k-640x640.py b/mmsegmentation/configs/san/san-vit-b16_coco-stuff164k-640x640.py
new file mode 100644
index 0000000..4059248
--- /dev/null
+++ b/mmsegmentation/configs/san/san-vit-b16_coco-stuff164k-640x640.py
@@ -0,0 +1,82 @@
+_base_ = [
+    '../_base_/models/san_vit-b16.py', '../_base_/datasets/coco-stuff164k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (640, 640)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomChoiceResize',
+        scales=[int(640 * x * 0.1) for x in range(5, 16)],
+        resize_type='ResizeShortestEdge',
+        max_size=2560),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=1.0),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackSegInputs')
+]
+
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='ResizeShortestEdge', scale=crop_size, max_size=2560),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+
+# By default, models are trained on 4 GPUs with 8 images per GPU
+train_dataloader = dict(batch_size=8, dataset=dict(pipeline=train_pipeline))
+val_dataloader = dict(batch_size=1, dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/san/clip_vit-base-patch16-224_3rdparty-d08f8887.pth'  # noqa
+data_preprocessor = dict(
+    mean=[122.7709, 116.7460, 104.0937],
+    std=[68.5005, 66.6322, 70.3232],
+    size_divisor=640,
+    test_cfg=dict(size_divisor=32))
+model = dict(
+    pretrained=pretrained,
+    text_encoder=dict(dataset_name='coco-stuff164k'),
+    decode_head=dict(num_classes=171))
+
+# training schedule for 60k
+train_cfg = dict(
+    type='IterBasedTrainLoop',
+    max_iters=60000,
+    val_interval=500,
+    val_begin=55000)
+default_hooks = dict(
+    checkpoint=dict(
+        type='CheckpointHook',
+        by_epoch=False,
+        interval=10000,
+        save_best='mIoU'))
+
+# AdamW optimizer, no weight decay for position embedding & layer norm
+# in backbone
+optim_wrapper = dict(
+    _delete_=True,
+    type='AmpOptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.0001),
+    paramwise_cfg=dict(
+        custom_keys={
+            'img_encoder': dict(lr_mult=0.1, decay_mult=1.0),
+            'pos_embed': dict(decay_mult=0.),
+            'cls_token': dict(decay_mult=0.),
+            'norm': dict(decay_mult=0.)
+        }),
+    loss_scale='dynamic',
+    clip_grad=dict(max_norm=0.01, norm_type=2))
+
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=0.0,
+        power=1.0,
+        begin=0,
+        end=60000,
+        by_epoch=False,
+    )
+]
diff --git a/mmsegmentation/configs/san/san-vit-b16_pascal_context-640x640.py b/mmsegmentation/configs/san/san-vit-b16_pascal_context-640x640.py
new file mode 100644
index 0000000..b164fe4
--- /dev/null
+++ b/mmsegmentation/configs/san/san-vit-b16_pascal_context-640x640.py
@@ -0,0 +1,56 @@
+_base_ = [
+    '../_base_/models/san_vit-b16.py',
+    '../_base_/datasets/pascal_context_59.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (640, 640)
+
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='ResizeShortestEdge', scale=crop_size, max_size=2560),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+
+# By default, models are trained on 8 GPUs with 2 images per GPU
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=1, dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+data_preprocessor = dict(
+    mean=[122.7709, 116.7460, 104.0937],
+    std=[68.5005, 66.6322, 70.3232],
+    size_divisor=640,
+    test_cfg=dict(size_divisor=32))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained='pretrain/vit_base_patch16_224.pth',
+    text_encoder=dict(dataset_name='pascal_context'),
+    decode_head=dict(num_classes=59))
+
+# AdamW optimizer, no weight decay for position embedding & layer norm
+# in backbone
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
+    paramwise_cfg=dict(
+        custom_keys={
+            'pos_embed': dict(decay_mult=0.),
+            'cls_token': dict(decay_mult=0.),
+            'norm': dict(decay_mult=0.)
+        }))
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        eta_min=0.0,
+        power=1.0,
+        begin=1500,
+        end=160000,
+        by_epoch=False,
+    )
+]
diff --git a/mmsegmentation/configs/san/san-vit-b16_voc12aug-640x640.py b/mmsegmentation/configs/san/san-vit-b16_voc12aug-640x640.py
new file mode 100644
index 0000000..62e9b26
--- /dev/null
+++ b/mmsegmentation/configs/san/san-vit-b16_voc12aug-640x640.py
@@ -0,0 +1,65 @@
+_base_ = [
+    '../_base_/models/san_vit-b16.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (640, 640)
+
+metainfo = dict(
+    classes=('aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car',
+             'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike',
+             'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor'),
+    palette=[[128, 0, 0], [0, 128, 0], [128, 128, 0], [0, 0, 128],
+             [128, 0, 128], [0, 128, 128], [128, 128, 128], [64, 0, 0],
+             [192, 0, 0], [64, 128, 0], [192, 128, 0], [64, 0, 128],
+             [192, 0, 128], [64, 128, 128], [192, 128, 128], [0, 64, 0],
+             [128, 64, 0], [0, 192, 0], [128, 192, 0], [0, 64, 128]])
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='ResizeShortestEdge', scale=crop_size, max_size=2560),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+# By default, models are trained on 8 GPUs with 2 images per GPU
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(
+    batch_size=1, dataset=dict(metainfo=metainfo, pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+data_preprocessor = dict(
+    mean=[122.7709, 116.7460, 104.0937],
+    std=[68.5005, 66.6322, 70.3232],
+    size_divisor=640,
+    test_cfg=dict(size_divisor=32))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained='pretrain/vit_base_patch16_224.pth',
+    text_encoder=dict(dataset_name='voc'),
+    decode_head=dict(num_classes=20))
+
+# AdamW optimizer, no weight decay for position embedding & layer norm
+# in backbone
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
+    paramwise_cfg=dict(
+        custom_keys={
+            'pos_embed': dict(decay_mult=0.),
+            'cls_token': dict(decay_mult=0.),
+            'norm': dict(decay_mult=0.)
+        }))
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        eta_min=0.0,
+        power=1.0,
+        begin=1500,
+        end=160000,
+        by_epoch=False,
+    )
+]
diff --git a/mmsegmentation/configs/san/san-vit-l14_coco-stuff164k-640x640.py b/mmsegmentation/configs/san/san-vit-l14_coco-stuff164k-640x640.py
new file mode 100644
index 0000000..c34328d
--- /dev/null
+++ b/mmsegmentation/configs/san/san-vit-l14_coco-stuff164k-640x640.py
@@ -0,0 +1,36 @@
+_base_ = ['./san-vit-b16_coco-stuff164k-640x640.py']
+
+pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/san/clip_vit-large-patch14-336_3rdparty-0b5df9cb.pth'  # noqa
+model = dict(
+    type='MultimodalEncoderDecoder',
+    pretrained=pretrained,
+    encoder_resolution=0.7,
+    image_encoder=dict(
+        type='VisionTransformer',
+        img_size=(336, 336),
+        patch_size=14,
+        patch_pad=0,
+        embed_dims=1024,
+        num_layers=18,
+        num_heads=16,
+        out_indices=(5, 11, 17),
+    ),
+    text_encoder=dict(
+        type='CLIPTextEncoder',
+        embed_dims=768,
+        num_layers=12,
+        num_heads=12,
+        output_dims=768,
+    ),
+    decode_head=dict(
+        type='SideAdapterCLIPHead',
+        san_cfg=dict(clip_channels=1024, cfg_decoder=dict(num_heads=16)),
+        maskgen_cfg=dict(
+            num_layers=6,
+            embed_dims=1024,
+            num_heads=16,
+            out_dims=768,
+        )))
+
+# By default, models are trained on 8 GPUs with 4 images per GPU
+train_dataloader = dict(batch_size=4)
diff --git a/mmsegmentation/configs/san/san-vit-l14_pascal_context-640x640.py b/mmsegmentation/configs/san/san-vit-l14_pascal_context-640x640.py
new file mode 100644
index 0000000..a9545fa
--- /dev/null
+++ b/mmsegmentation/configs/san/san-vit-l14_pascal_context-640x640.py
@@ -0,0 +1,32 @@
+_base_ = ['./san-vit-b16_pascal_context-640x640.py']
+
+model = dict(
+    type='MultimodalEncoderDecoder',
+    pretrained='pretrain/jx_vit_base_p16_224-80ecf9dd.pth',
+    encoder_resolution=0.7,
+    image_encoder=dict(
+        type='VisionTransformer',
+        img_size=(336, 336),
+        patch_size=14,
+        patch_pad=0,
+        embed_dims=1024,
+        num_layers=18,
+        num_heads=16,
+        out_indices=(5, 11, 17),
+    ),
+    text_encoder=dict(
+        type='CLIPTextEncoder',
+        embed_dims=768,
+        num_layers=12,
+        num_heads=12,
+        output_dims=768,
+    ),
+    decode_head=dict(
+        type='SideAdapterCLIPHead',
+        san_cfg=dict(clip_channels=1024, cfg_decoder=dict(num_heads=16)),
+        maskgen_cfg=dict(
+            num_layers=6,
+            embed_dims=1024,
+            num_heads=16,
+            out_dims=768,
+        )))
diff --git a/mmsegmentation/configs/san/san-vit-l14_voc12aug-640x640.py b/mmsegmentation/configs/san/san-vit-l14_voc12aug-640x640.py
new file mode 100644
index 0000000..2f37715
--- /dev/null
+++ b/mmsegmentation/configs/san/san-vit-l14_voc12aug-640x640.py
@@ -0,0 +1,32 @@
+_base_ = ['./san-vit-b16_voc12aug-640x640.py']
+
+model = dict(
+    type='MultimodalEncoderDecoder',
+    pretrained='pretrain/jx_vit_base_p16_224-80ecf9dd.pth',
+    encoder_resolution=0.7,
+    image_encoder=dict(
+        type='VisionTransformer',
+        img_size=(336, 336),
+        patch_size=14,
+        patch_pad=0,
+        embed_dims=1024,
+        num_layers=18,
+        num_heads=16,
+        out_indices=(5, 11, 17),
+    ),
+    text_encoder=dict(
+        type='CLIPTextEncoder',
+        embed_dims=768,
+        num_layers=12,
+        num_heads=12,
+        output_dims=768,
+    ),
+    decode_head=dict(
+        type='SideAdapterCLIPHead',
+        san_cfg=dict(clip_channels=1024, cfg_decoder=dict(num_heads=16)),
+        maskgen_cfg=dict(
+            num_layers=6,
+            embed_dims=1024,
+            num_heads=16,
+            out_dims=768,
+        )))
diff --git a/mmsegmentation/configs/segformer/README.md b/mmsegmentation/configs/segformer/README.md
new file mode 100644
index 0000000..f8999b0
--- /dev/null
+++ b/mmsegmentation/configs/segformer/README.md
@@ -0,0 +1,101 @@
+# SegFormer
+
+> [SegFormer: Simple and Efficient Design for Semantic Segmentation with Transformers](https://arxiv.org/abs/2105.15203)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/NVlabs/SegFormer">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+We present SegFormer, a simple, efficient yet powerful semantic segmentation framework which unifies Transformers with lightweight multilayer perception (MLP) decoders. SegFormer has two appealing features: 1) SegFormer comprises a novel hierarchically structured Transformer encoder which outputs multiscale features. It does not need positional encoding, thereby avoiding the interpolation of positional codes which leads to decreased performance when the testing resolution differs from training. 2) SegFormer avoids complex decoders. The proposed MLP decoder aggregates information from different layers, and thus combining both local attention and global attention to render powerful representations. We show that this simple and lightweight design is the key to efficient segmentation on Transformers. We scale our approach up to obtain a series of models from SegFormer-B0 to SegFormer-B5, reaching significantly better performance and efficiency than previous counterparts. For example, SegFormer-B4 achieves 50.3% mIoU on ADE20K with 64M parameters, being 5x smaller and 2.2% better than the previous best method. Our best model, SegFormer-B5, achieves 84.0% mIoU on Cityscapes validation set and shows excellent zero-shot robustness on Cityscapes-C. Code will be released at: [this http URL](https://github.com/NVlabs/SegFormer).
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142902600-e188073e-5744-4ba9-8dbf-9316e55c74aa.png" width="70%"/>
+</div>
+
+## Usage
+
+To use other repositories' pre-trained models, it is necessary to convert keys.
+
+We provide a script [`mit2mmseg.py`](../../tools/model_converters/mit2mmseg.py) in the tools directory to convert the key of models from [the official repo](https://github.com/NVlabs/SegFormer) to MMSegmentation style.
+
+```shell
+python tools/model_converters/mit2mmseg.py ${PRETRAIN_PATH} ${STORE_PATH}
+```
+
+This script convert model from `PRETRAIN_PATH` and store the converted model in `STORE_PATH`.
+
+## Results and models
+
+### ADE20K
+
+| Method    | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device   |  mIoU | mIoU(ms+flip) | config                                                                                                                          | download                                                                                                                                                                                                                                                                                                                                               |
+| --------- | -------- | --------- | ------: | -------: | -------------- | -------- | ----: | ------------- | ------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Segformer | MIT-B0   | 512x512   |  160000 |      2.1 | 51.32          | 1080 Ti  | 37.41 | 38.34         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b0_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b0_512x512_160k_ade20k/segformer_mit-b0_512x512_160k_ade20k_20210726_101530-8ffa8fda.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b0_512x512_160k_ade20k/segformer_mit-b0_512x512_160k_ade20k_20210726_101530.log.json) |
+| Segformer | MIT-B1   | 512x512   |  160000 |      2.6 | 47.66          | TITAN Xp | 40.97 | 42.54         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b1_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b1_512x512_160k_ade20k/segformer_mit-b1_512x512_160k_ade20k_20210726_112106-d70e859d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b1_512x512_160k_ade20k/segformer_mit-b1_512x512_160k_ade20k_20210726_112106.log.json) |
+| Segformer | MIT-B2   | 512x512   |  160000 |      3.6 | 30.88          | TITAN Xp | 45.58 | 47.03         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b2_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b2_512x512_160k_ade20k/segformer_mit-b2_512x512_160k_ade20k_20210726_112103-cbd414ac.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b2_512x512_160k_ade20k/segformer_mit-b2_512x512_160k_ade20k_20210726_112103.log.json) |
+| Segformer | MIT-B3   | 512x512   |  160000 |      4.8 | 22.11          | V100     | 47.82 | 48.81         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b3_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b3_512x512_160k_ade20k/segformer_mit-b3_512x512_160k_ade20k_20210726_081410-962b98d2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b3_512x512_160k_ade20k/segformer_mit-b3_512x512_160k_ade20k_20210726_081410.log.json) |
+| Segformer | MIT-B4   | 512x512   |  160000 |      6.1 | 15.45          | V100     | 48.46 | 49.76         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b4_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b4_512x512_160k_ade20k/segformer_mit-b4_512x512_160k_ade20k_20210728_183055-7f509d7d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b4_512x512_160k_ade20k/segformer_mit-b4_512x512_160k_ade20k_20210728_183055.log.json) |
+| Segformer | MIT-B5   | 512x512   |  160000 |      7.2 | 11.89          | V100     | 49.13 | 50.22         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_512x512_160k_ade20k/segformer_mit-b5_512x512_160k_ade20k_20210726_145235-94cedf59.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_512x512_160k_ade20k/segformer_mit-b5_512x512_160k_ade20k_20210726_145235.log.json) |
+| Segformer | MIT-B5   | 640x640   |  160000 |     11.5 | 11.30          | V100     | 49.62 | 50.36         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-640x640.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_640x640_160k_ade20k/segformer_mit-b5_640x640_160k_ade20k_20210801_121243-41d2845b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_640x640_160k_ade20k/segformer_mit-b5_640x640_160k_ade20k_20210801_121243.log.json) |
+
+Evaluation with AlignedResize:
+
+| Method    | Backbone | Crop Size | Lr schd |  mIoU | mIoU(ms+flip) |
+| --------- | -------- | --------- | ------: | ----: | ------------- |
+| Segformer | MIT-B0   | 512x512   |  160000 |  38.1 | 38.57         |
+| Segformer | MIT-B1   | 512x512   |  160000 | 41.64 | 42.76         |
+| Segformer | MIT-B2   | 512x512   |  160000 | 46.53 | 47.49         |
+| Segformer | MIT-B3   | 512x512   |  160000 | 48.46 | 49.14         |
+| Segformer | MIT-B4   | 512x512   |  160000 | 49.34 | 50.29         |
+| Segformer | MIT-B5   | 512x512   |  160000 | 50.08 | 50.72         |
+| Segformer | MIT-B5   | 640x640   |  160000 | 50.58 | 50.8          |
+
+We replace `AlignedResize` in original implementatiuon to `Resize + ResizeToMultiple`. If you want to test by
+using `AlignedResize`, you can change the dataset pipeline like this:
+
+```python
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+    # resize image to multiple of 32, improve SegFormer by 0.5-1.0 mIoU.
+    dict(type='ResizeToMultiple', size_divisor=32),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='PackSegInputs')
+]
+```
+
+### Cityscapes
+
+The lower fps result is caused by the sliding window inference scheme (window size:1024x1024).
+
+| Method    | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                | download                                                                                                                                                                                                                                                                                                                                                                                       |
+| --------- | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | ------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Segformer | MIT-B0   | 1024x1024 |  160000 |     3.64 | 4.74           | V100   | 76.54 | 78.22         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b0_8x1_1024x1024_160k_cityscapes/segformer_mit-b0_8x1_1024x1024_160k_cityscapes_20211208_101857-e7f88502.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b0_8x1_1024x1024_160k_cityscapes/segformer_mit-b0_8x1_1024x1024_160k_cityscapes_20211208_101857.log.json) |
+| Segformer | MIT-B1   | 1024x1024 |  160000 |     4.49 | 4.3            | V100   | 78.56 | 79.73         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b1_8xb1-160k_cityscapes-1024x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b1_8x1_1024x1024_160k_cityscapes/segformer_mit-b1_8x1_1024x1024_160k_cityscapes_20211208_064213-655c7b3f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b1_8x1_1024x1024_160k_cityscapes/segformer_mit-b1_8x1_1024x1024_160k_cityscapes_20211208_064213.log.json) |
+| Segformer | MIT-B2   | 1024x1024 |  160000 |     7.42 | 3.36           | V100   | 81.08 | 82.18         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b2_8xb1-160k_cityscapes-1024x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b2_8x1_1024x1024_160k_cityscapes/segformer_mit-b2_8x1_1024x1024_160k_cityscapes_20211207_134205-6096669a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b2_8x1_1024x1024_160k_cityscapes/segformer_mit-b2_8x1_1024x1024_160k_cityscapes_20211207_134205.log.json) |
+| Segformer | MIT-B3   | 1024x1024 |  160000 |    10.86 | 2.53           | V100   | 81.94 | 83.14         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b3_8xb1-160k_cityscapes-1024x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b3_8x1_1024x1024_160k_cityscapes/segformer_mit-b3_8x1_1024x1024_160k_cityscapes_20211206_224823-a8f8a177.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b3_8x1_1024x1024_160k_cityscapes/segformer_mit-b3_8x1_1024x1024_160k_cityscapes_20211206_224823.log.json) |
+| Segformer | MIT-B4   | 1024x1024 |  160000 |    15.07 | 1.88           | V100   | 81.89 | 83.38         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b4_8xb1-160k_cityscapes-1024x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b4_8x1_1024x1024_160k_cityscapes/segformer_mit-b4_8x1_1024x1024_160k_cityscapes_20211207_080709-07f6c333.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b4_8x1_1024x1024_160k_cityscapes/segformer_mit-b4_8x1_1024x1024_160k_cityscapes_20211207_080709.log.json) |
+| Segformer | MIT-B5   | 1024x1024 |  160000 |    18.00 | 1.39           | V100   | 82.25 | 83.48         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b5_8xb1-160k_cityscapes-1024x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_8x1_1024x1024_160k_cityscapes/segformer_mit-b5_8x1_1024x1024_160k_cityscapes_20211206_072934-87a052ec.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_8x1_1024x1024_160k_cityscapes/segformer_mit-b5_8x1_1024x1024_160k_cityscapes_20211206_072934.log.json) |
+
+## Citation
+
+```bibtex
+@article{xie2021segformer,
+  title={SegFormer: Simple and Efficient Design for Semantic Segmentation with Transformers},
+  author={Xie, Enze and Wang, Wenhai and Yu, Zhiding and Anandkumar, Anima and Alvarez, Jose M and Luo, Ping},
+  journal={arXiv preprint arXiv:2105.15203},
+  year={2021}
+}
+```
diff --git a/mmsegmentation/configs/segformer/metafile.yaml b/mmsegmentation/configs/segformer/metafile.yaml
new file mode 100644
index 0000000..7fb38d7
--- /dev/null
+++ b/mmsegmentation/configs/segformer/metafile.yaml
@@ -0,0 +1,340 @@
+Collections:
+- Name: Segformer
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - ADE20K
+    - Cityscapes
+  Paper:
+    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
+      Transformers'
+    URL: https://arxiv.org/abs/2105.15203
+  README: configs/segformer/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: segformer_mit-b0_8xb2-160k_ade20k-512x512
+  In Collection: Segformer
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 37.41
+      mIoU(ms+flip): 38.34
+  Config: configs/segformer/segformer_mit-b0_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - MIT-B0
+    - Segformer
+    Training Resources: 8x 1080 Ti GPUS
+    Memory (GB): 2.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b0_512x512_160k_ade20k/segformer_mit-b0_512x512_160k_ade20k_20210726_101530-8ffa8fda.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b0_512x512_160k_ade20k/segformer_mit-b0_512x512_160k_ade20k_20210726_101530.log.json
+  Paper:
+    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
+      Transformers'
+    URL: https://arxiv.org/abs/2105.15203
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
+  Framework: PyTorch
+- Name: segformer_mit-b1_8xb2-160k_ade20k-512x512
+  In Collection: Segformer
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 40.97
+      mIoU(ms+flip): 42.54
+  Config: configs/segformer/segformer_mit-b1_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - MIT-B1
+    - Segformer
+    Training Resources: 8x TITAN Xp GPUS
+    Memory (GB): 2.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b1_512x512_160k_ade20k/segformer_mit-b1_512x512_160k_ade20k_20210726_112106-d70e859d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b1_512x512_160k_ade20k/segformer_mit-b1_512x512_160k_ade20k_20210726_112106.log.json
+  Paper:
+    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
+      Transformers'
+    URL: https://arxiv.org/abs/2105.15203
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
+  Framework: PyTorch
+- Name: segformer_mit-b2_8xb2-160k_ade20k-512x512
+  In Collection: Segformer
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 45.58
+      mIoU(ms+flip): 47.03
+  Config: configs/segformer/segformer_mit-b2_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - MIT-B2
+    - Segformer
+    Training Resources: 8x TITAN Xp GPUS
+    Memory (GB): 3.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b2_512x512_160k_ade20k/segformer_mit-b2_512x512_160k_ade20k_20210726_112103-cbd414ac.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b2_512x512_160k_ade20k/segformer_mit-b2_512x512_160k_ade20k_20210726_112103.log.json
+  Paper:
+    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
+      Transformers'
+    URL: https://arxiv.org/abs/2105.15203
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
+  Framework: PyTorch
+- Name: segformer_mit-b3_8xb2-160k_ade20k-512x512
+  In Collection: Segformer
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 47.82
+      mIoU(ms+flip): 48.81
+  Config: configs/segformer/segformer_mit-b3_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - MIT-B3
+    - Segformer
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 4.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b3_512x512_160k_ade20k/segformer_mit-b3_512x512_160k_ade20k_20210726_081410-962b98d2.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b3_512x512_160k_ade20k/segformer_mit-b3_512x512_160k_ade20k_20210726_081410.log.json
+  Paper:
+    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
+      Transformers'
+    URL: https://arxiv.org/abs/2105.15203
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
+  Framework: PyTorch
+- Name: segformer_mit-b4_8xb2-160k_ade20k-512x512
+  In Collection: Segformer
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 48.46
+      mIoU(ms+flip): 49.76
+  Config: configs/segformer/segformer_mit-b4_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - MIT-B4
+    - Segformer
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 6.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b4_512x512_160k_ade20k/segformer_mit-b4_512x512_160k_ade20k_20210728_183055-7f509d7d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b4_512x512_160k_ade20k/segformer_mit-b4_512x512_160k_ade20k_20210728_183055.log.json
+  Paper:
+    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
+      Transformers'
+    URL: https://arxiv.org/abs/2105.15203
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
+  Framework: PyTorch
+- Name: segformer_mit-b5_8xb2-160k_ade20k-512x512
+  In Collection: Segformer
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 49.13
+      mIoU(ms+flip): 50.22
+  Config: configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - MIT-B5
+    - Segformer
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 7.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_512x512_160k_ade20k/segformer_mit-b5_512x512_160k_ade20k_20210726_145235-94cedf59.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_512x512_160k_ade20k/segformer_mit-b5_512x512_160k_ade20k_20210726_145235.log.json
+  Paper:
+    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
+      Transformers'
+    URL: https://arxiv.org/abs/2105.15203
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
+  Framework: PyTorch
+- Name: segformer_mit-b5_8xb2-160k_ade20k-640x640
+  In Collection: Segformer
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 49.62
+      mIoU(ms+flip): 50.36
+  Config: configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-640x640.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - MIT-B5
+    - Segformer
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 11.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_640x640_160k_ade20k/segformer_mit-b5_640x640_160k_ade20k_20210801_121243-41d2845b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_640x640_160k_ade20k/segformer_mit-b5_640x640_160k_ade20k_20210801_121243.log.json
+  Paper:
+    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
+      Transformers'
+    URL: https://arxiv.org/abs/2105.15203
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
+  Framework: PyTorch
+- Name: segformer_mit-b0_8xb1-160k_cityscapes-1024x1024
+  In Collection: Segformer
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.54
+      mIoU(ms+flip): 78.22
+  Config: configs/segformer/segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - MIT-B0
+    - Segformer
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 3.64
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b0_8x1_1024x1024_160k_cityscapes/segformer_mit-b0_8x1_1024x1024_160k_cityscapes_20211208_101857-e7f88502.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b0_8x1_1024x1024_160k_cityscapes/segformer_mit-b0_8x1_1024x1024_160k_cityscapes_20211208_101857.log.json
+  Paper:
+    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
+      Transformers'
+    URL: https://arxiv.org/abs/2105.15203
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
+  Framework: PyTorch
+- Name: segformer_mit-b1_8xb1-160k_cityscapes-1024x1024
+  In Collection: Segformer
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.56
+      mIoU(ms+flip): 79.73
+  Config: configs/segformer/segformer_mit-b1_8xb1-160k_cityscapes-1024x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - MIT-B1
+    - Segformer
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 4.49
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b1_8x1_1024x1024_160k_cityscapes/segformer_mit-b1_8x1_1024x1024_160k_cityscapes_20211208_064213-655c7b3f.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b1_8x1_1024x1024_160k_cityscapes/segformer_mit-b1_8x1_1024x1024_160k_cityscapes_20211208_064213.log.json
+  Paper:
+    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
+      Transformers'
+    URL: https://arxiv.org/abs/2105.15203
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
+  Framework: PyTorch
+- Name: segformer_mit-b2_8xb1-160k_cityscapes-1024x1024
+  In Collection: Segformer
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 81.08
+      mIoU(ms+flip): 82.18
+  Config: configs/segformer/segformer_mit-b2_8xb1-160k_cityscapes-1024x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - MIT-B2
+    - Segformer
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 7.42
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b2_8x1_1024x1024_160k_cityscapes/segformer_mit-b2_8x1_1024x1024_160k_cityscapes_20211207_134205-6096669a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b2_8x1_1024x1024_160k_cityscapes/segformer_mit-b2_8x1_1024x1024_160k_cityscapes_20211207_134205.log.json
+  Paper:
+    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
+      Transformers'
+    URL: https://arxiv.org/abs/2105.15203
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
+  Framework: PyTorch
+- Name: segformer_mit-b3_8xb1-160k_cityscapes-1024x1024
+  In Collection: Segformer
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 81.94
+      mIoU(ms+flip): 83.14
+  Config: configs/segformer/segformer_mit-b3_8xb1-160k_cityscapes-1024x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - MIT-B3
+    - Segformer
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 10.86
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b3_8x1_1024x1024_160k_cityscapes/segformer_mit-b3_8x1_1024x1024_160k_cityscapes_20211206_224823-a8f8a177.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b3_8x1_1024x1024_160k_cityscapes/segformer_mit-b3_8x1_1024x1024_160k_cityscapes_20211206_224823.log.json
+  Paper:
+    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
+      Transformers'
+    URL: https://arxiv.org/abs/2105.15203
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
+  Framework: PyTorch
+- Name: segformer_mit-b4_8xb1-160k_cityscapes-1024x1024
+  In Collection: Segformer
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 81.89
+      mIoU(ms+flip): 83.38
+  Config: configs/segformer/segformer_mit-b4_8xb1-160k_cityscapes-1024x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - MIT-B4
+    - Segformer
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 15.07
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b4_8x1_1024x1024_160k_cityscapes/segformer_mit-b4_8x1_1024x1024_160k_cityscapes_20211207_080709-07f6c333.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b4_8x1_1024x1024_160k_cityscapes/segformer_mit-b4_8x1_1024x1024_160k_cityscapes_20211207_080709.log.json
+  Paper:
+    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
+      Transformers'
+    URL: https://arxiv.org/abs/2105.15203
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
+  Framework: PyTorch
+- Name: segformer_mit-b5_8xb1-160k_cityscapes-1024x1024
+  In Collection: Segformer
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 82.25
+      mIoU(ms+flip): 83.48
+  Config: configs/segformer/segformer_mit-b5_8xb1-160k_cityscapes-1024x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - MIT-B5
+    - Segformer
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 18.0
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_8x1_1024x1024_160k_cityscapes/segformer_mit-b5_8x1_1024x1024_160k_cityscapes_20211206_072934-87a052ec.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_8x1_1024x1024_160k_cityscapes/segformer_mit-b5_8x1_1024x1024_160k_cityscapes_20211206_072934.log.json
+  Paper:
+    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
+      Transformers'
+    URL: https://arxiv.org/abs/2105.15203
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/segformer/segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py
new file mode 100644
index 0000000..1280047
--- /dev/null
+++ b/mmsegmentation/configs/segformer/segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py
@@ -0,0 +1,41 @@
+_base_ = [
+    '../_base_/models/segformer_mit-b0.py',
+    '../_base_/datasets/cityscapes_1024x1024.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (1024, 1024)
+data_preprocessor = dict(size=crop_size)
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b0_20220624-7e0fe6dd.pth'  # noqa
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(init_cfg=dict(type='Pretrained', checkpoint=checkpoint)),
+    test_cfg=dict(mode='slide', crop_size=(1024, 1024), stride=(768, 768)))
+
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
+    paramwise_cfg=dict(
+        custom_keys={
+            'pos_block': dict(decay_mult=0.),
+            'norm': dict(decay_mult=0.),
+            'head': dict(lr_mult=10.)
+        }))
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        eta_min=0.0,
+        power=1.0,
+        begin=1500,
+        end=160000,
+        by_epoch=False,
+    )
+]
+
+train_dataloader = dict(batch_size=1, num_workers=4)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b0_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/segformer/segformer_mit-b0_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..4a9476d
--- /dev/null
+++ b/mmsegmentation/configs/segformer/segformer_mit-b0_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,39 @@
+_base_ = [
+    '../_base_/models/segformer_mit-b0.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b0_20220624-7e0fe6dd.pth'  # noqa
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(init_cfg=dict(type='Pretrained', checkpoint=checkpoint)),
+    decode_head=dict(num_classes=150))
+
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
+    paramwise_cfg=dict(
+        custom_keys={
+            'pos_block': dict(decay_mult=0.),
+            'norm': dict(decay_mult=0.),
+            'head': dict(lr_mult=10.)
+        }))
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        eta_min=0.0,
+        power=1.0,
+        begin=1500,
+        end=160000,
+        by_epoch=False,
+    )
+]
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b1_8xb1-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/segformer/segformer_mit-b1_8xb1-160k_cityscapes-1024x1024.py
new file mode 100644
index 0000000..85c126e
--- /dev/null
+++ b/mmsegmentation/configs/segformer/segformer_mit-b1_8xb1-160k_cityscapes-1024x1024.py
@@ -0,0 +1,9 @@
+_base_ = ['./segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py']
+
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b1_20220624-02e5a6a1.pth'  # noqa
+
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        embed_dims=64),
+    decode_head=dict(in_channels=[64, 128, 320, 512]))
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b1_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/segformer/segformer_mit-b1_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..1ff21b8
--- /dev/null
+++ b/mmsegmentation/configs/segformer/segformer_mit-b1_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,12 @@
+_base_ = ['./segformer_mit-b0_8xb2-160k_ade20k-512x512.py']
+
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b1_20220624-02e5a6a1.pth'  # noqa
+
+# model settings
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        embed_dims=64,
+        num_heads=[1, 2, 5, 8],
+        num_layers=[2, 2, 2, 2]),
+    decode_head=dict(in_channels=[64, 128, 320, 512]))
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b2_8xb1-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/segformer/segformer_mit-b2_8xb1-160k_cityscapes-1024x1024.py
new file mode 100644
index 0000000..c802f27
--- /dev/null
+++ b/mmsegmentation/configs/segformer/segformer_mit-b2_8xb1-160k_cityscapes-1024x1024.py
@@ -0,0 +1,10 @@
+_base_ = ['./segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py']
+
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b2_20220624-66e8bf70.pth'  # noqa
+
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        embed_dims=64,
+        num_layers=[3, 4, 6, 3]),
+    decode_head=dict(in_channels=[64, 128, 320, 512]))
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b2_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/segformer/segformer_mit-b2_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..0f4c1af
--- /dev/null
+++ b/mmsegmentation/configs/segformer/segformer_mit-b2_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,12 @@
+_base_ = ['./segformer_mit-b0_8xb2-160k_ade20k-512x512.py']
+
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b2_20220624-66e8bf70.pth'  # noqa
+
+# model settings
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        embed_dims=64,
+        num_heads=[1, 2, 5, 8],
+        num_layers=[3, 4, 6, 3]),
+    decode_head=dict(in_channels=[64, 128, 320, 512]))
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b3_8xb1-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/segformer/segformer_mit-b3_8xb1-160k_cityscapes-1024x1024.py
new file mode 100644
index 0000000..9b41ad0
--- /dev/null
+++ b/mmsegmentation/configs/segformer/segformer_mit-b3_8xb1-160k_cityscapes-1024x1024.py
@@ -0,0 +1,10 @@
+_base_ = ['./segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py']
+
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b3_20220624-13b1141c.pth'  # noqa
+
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        embed_dims=64,
+        num_layers=[3, 4, 18, 3]),
+    decode_head=dict(in_channels=[64, 128, 320, 512]))
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b3_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/segformer/segformer_mit-b3_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..a2cc13d
--- /dev/null
+++ b/mmsegmentation/configs/segformer/segformer_mit-b3_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,12 @@
+_base_ = ['./segformer_mit-b0_8xb2-160k_ade20k-512x512.py']
+
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b3_20220624-13b1141c.pth'  # noqa
+
+# model settings
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        embed_dims=64,
+        num_heads=[1, 2, 5, 8],
+        num_layers=[3, 4, 18, 3]),
+    decode_head=dict(in_channels=[64, 128, 320, 512]))
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b4_8xb1-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/segformer/segformer_mit-b4_8xb1-160k_cityscapes-1024x1024.py
new file mode 100644
index 0000000..5fb1608
--- /dev/null
+++ b/mmsegmentation/configs/segformer/segformer_mit-b4_8xb1-160k_cityscapes-1024x1024.py
@@ -0,0 +1,10 @@
+_base_ = ['./segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py']
+
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b4_20220624-d588d980.pth'  # noqa
+
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        embed_dims=64,
+        num_layers=[3, 8, 27, 3]),
+    decode_head=dict(in_channels=[64, 128, 320, 512]))
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b4_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/segformer/segformer_mit-b4_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..5f39c30
--- /dev/null
+++ b/mmsegmentation/configs/segformer/segformer_mit-b4_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,12 @@
+_base_ = ['./segformer_mit-b0_8xb2-160k_ade20k-512x512.py']
+
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b4_20220624-d588d980.pth'  # noqa
+
+# model settings
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        embed_dims=64,
+        num_heads=[1, 2, 5, 8],
+        num_layers=[3, 8, 27, 3]),
+    decode_head=dict(in_channels=[64, 128, 320, 512]))
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b5_8xb1-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/segformer/segformer_mit-b5_8xb1-160k_cityscapes-1024x1024.py
new file mode 100644
index 0000000..18c3c16
--- /dev/null
+++ b/mmsegmentation/configs/segformer/segformer_mit-b5_8xb1-160k_cityscapes-1024x1024.py
@@ -0,0 +1,10 @@
+_base_ = ['./segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py']
+
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b5_20220624-658746d9.pth'  # noqa
+
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        embed_dims=64,
+        num_layers=[3, 6, 40, 3]),
+    decode_head=dict(in_channels=[64, 128, 320, 512]))
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..1e9a209
--- /dev/null
+++ b/mmsegmentation/configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,12 @@
+_base_ = ['./segformer_mit-b0_8xb2-160k_ade20k-512x512.py']
+
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b5_20220624-658746d9.pth'  # noqa
+
+# model settings
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        embed_dims=64,
+        num_heads=[1, 2, 5, 8],
+        num_layers=[3, 6, 40, 3]),
+    decode_head=dict(in_channels=[64, 128, 320, 512]))
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-640x640.py b/mmsegmentation/configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-640x640.py
new file mode 100644
index 0000000..a32eb7c
--- /dev/null
+++ b/mmsegmentation/configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-640x640.py
@@ -0,0 +1,41 @@
+_base_ = ['./segformer_mit-b0_8xb2-160k_ade20k-512x512.py']
+
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b5_20220624-658746d9.pth'  # noqa
+
+# dataset settings
+crop_size = (640, 640)
+data_preprocessor = dict(size=crop_size)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(
+        type='RandomResize',
+        scale=(2048, 640),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 640), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
+val_dataloader = dict(batch_size=1, dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+# model settings
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        embed_dims=64,
+        num_heads=[1, 2, 5, 8],
+        num_layers=[3, 6, 40, 3]),
+    decode_head=dict(in_channels=[64, 128, 320, 512]))
diff --git a/mmsegmentation/configs/segmenter/README.md b/mmsegmentation/configs/segmenter/README.md
new file mode 100644
index 0000000..103b125
--- /dev/null
+++ b/mmsegmentation/configs/segmenter/README.md
@@ -0,0 +1,76 @@
+# Segmenter
+
+> [Segmenter: Transformer for Semantic Segmentation](https://arxiv.org/abs/2105.05633)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/rstrudel/segmenter">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.21.0/mmseg/models/decode_heads/segmenter_mask_head.py#L15">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Image segmentation is often ambiguous at the level of individual image patches and requires contextual information to reach label consensus. In this paper we introduce Segmenter, a transformer model for semantic segmentation. In contrast to convolution-based methods, our approach allows to model global context already at the first layer and throughout the network. We build on the recent Vision Transformer (ViT) and extend it to semantic segmentation. To do so, we rely on the output embeddings corresponding to image patches and obtain class labels from these embeddings with a point-wise linear decoder or a mask transformer decoder. We leverage models pre-trained for image classification and show that we can fine-tune them on moderate sized datasets available for semantic segmentation. The linear decoder allows to obtain excellent results already, but the performance can be further improved by a mask transformer generating class masks. We conduct an extensive ablation study to show the impact of the different parameters, in particular the performance is better for large models and small patch sizes. Segmenter attains excellent results for semantic segmentation. It outperforms the state of the art on both ADE20K and Pascal Context datasets and is competitive on Cityscapes.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/148507554-87eb80bd-02c7-4c31-b102-c6141e231ec8.png" width="70%"/>
+</div>
+
+## Usage
+
+We have provided pretrained models converted from [ViT-AugReg](https://github.com/rwightman/pytorch-image-models/blob/f55c22bebf9d8afc449d317a723231ef72e0d662/timm/models/vision_transformer.py#L54-L106).
+
+If you want to convert keys on your own to use the pre-trained ViT model from [Segmenter](https://github.com/rstrudel/segmenter), we also provide a script [`vitjax2mmseg.py`](../../tools/model_converters/vitjax2mmseg.py) in the tools directory to convert the key of models from [ViT-AugReg](https://github.com/rwightman/pytorch-image-models/blob/f55c22bebf9d8afc449d317a723231ef72e0d662/timm/models/vision_transformer.py#L54-L106) to MMSegmentation style.
+
+```shell
+python tools/model_converters/vitjax2mmseg.py ${PRETRAIN_PATH} ${STORE_PATH}
+```
+
+E.g.
+
+```shell
+python tools/model_converters/vitjax2mmseg.py \
+Ti_16-i21k-300ep-lr_0.001-aug_none-wd_0.03-do_0.0-sd_0.0--imagenet2012-steps_20k-lr_0.03-res_384.npz \
+pretrain/vit_tiny_p16_384.pth
+```
+
+This script convert model from `PRETRAIN_PATH` and store the converted model in `STORE_PATH`.
+
+In our default setting, pretrained models and their corresponding [ViT-AugReg](https://github.com/rwightman/pytorch-image-models/blob/f55c22bebf9d8afc449d317a723231ef72e0d662/timm/models/vision_transformer.py#L54-L106) models could be defined below:
+
+| pretrained models     | original models                                                                                                                                                                 |
+| --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| vit_tiny_p16_384.pth  | [vit_tiny_patch16_384](https://storage.googleapis.com/vit_models/augreg/Ti_16-i21k-300ep-lr_0.001-aug_none-wd_0.03-do_0.0-sd_0.0--imagenet2012-steps_20k-lr_0.03-res_384.npz)   |
+| vit_small_p16_384.pth | [vit_small_patch16_384](https://storage.googleapis.com/vit_models/augreg/S_16-i21k-300ep-lr_0.001-aug_light1-wd_0.03-do_0.0-sd_0.0--imagenet2012-steps_20k-lr_0.03-res_384.npz) |
+| vit_base_p16_384.pth  | [vit_base_patch16_384](https://storage.googleapis.com/vit_models/augreg/B_16-i21k-300ep-lr_0.001-aug_medium1-wd_0.1-do_0.0-sd_0.0--imagenet2012-steps_20k-lr_0.01-res_384.npz)  |
+| vit_large_p16_384.pth | [vit_large_patch16_384](https://storage.googleapis.com/vit_models/augreg/L_16-i21k-300ep-lr_0.001-aug_medium1-wd_0.1-do_0.1-sd_0.1--imagenet2012-steps_20k-lr_0.01-res_384.npz) |
+
+## Results and models
+
+### ADE20K
+
+| Method           | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                              | download                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------- | -------- | --------- | ------- | -------- | -------------- | ------ | ----- | ------------- | ----------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Segmenter Mask   | ViT-T_16 | 512x512   | 160000  | 1.21     | 27.98          | V100   | 39.99 | 40.83         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segmenter/segmenter_vit-t_mask_8xb1-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-t_mask_8x1_512x512_160k_ade20k/segmenter_vit-t_mask_8x1_512x512_160k_ade20k_20220105_151706-ffcf7509.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-t_mask_8x1_512x512_160k_ade20k/segmenter_vit-t_mask_8x1_512x512_160k_ade20k_20220105_151706.log.json)         |
+| Segmenter Linear | ViT-S_16 | 512x512   | 160000  | 1.78     | 28.07          | V100   | 45.75 | 46.82         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segmenter/segmenter_vit-s_fcn_8xb1-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-s_linear_8x1_512x512_160k_ade20k/segmenter_vit-s_linear_8x1_512x512_160k_ade20k_20220105_151713-39658c46.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-s_linear_8x1_512x512_160k_ade20k/segmenter_vit-s_linear_8x1_512x512_160k_ade20k_20220105_151713.log.json) |
+| Segmenter Mask   | ViT-S_16 | 512x512   | 160000  | 2.03     | 24.80          | V100   | 46.19 | 47.85         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segmenter/segmenter_vit-s_mask_8xb1-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-s_mask_8x1_512x512_160k_ade20k/segmenter_vit-s_mask_8x1_512x512_160k_ade20k_20220105_151706-511bb103.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-s_mask_8x1_512x512_160k_ade20k/segmenter_vit-s_mask_8x1_512x512_160k_ade20k_20220105_151706.log.json)         |
+| Segmenter Mask   | ViT-B_16 | 512x512   | 160000  | 4.20     | 13.20          | V100   | 49.60 | 51.07         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segmenter/segmenter_vit-b_mask_8xb1-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-b_mask_8x1_512x512_160k_ade20k/segmenter_vit-b_mask_8x1_512x512_160k_ade20k_20220105_151706-bc533b08.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-b_mask_8x1_512x512_160k_ade20k/segmenter_vit-b_mask_8x1_512x512_160k_ade20k_20220105_151706.log.json)         |
+| Segmenter Mask   | ViT-L_16 | 640x640   | 160000  | 16.56    | 2.62           | V100   | 52.16 | 53.65         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segmenter/segmenter_vit-l_mask_8xb1-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-l_mask_8x1_512x512_160k_ade20k/segmenter_vit-l_mask_8x1_512x512_160k_ade20k_20220105_162750-7ef345be.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-l_mask_8x1_512x512_160k_ade20k/segmenter_vit-l_mask_8x1_512x512_160k_ade20k_20220105_162750.log.json)         |
+
+## Citation
+
+```bibtex
+@inproceedings{strudel2021segmenter,
+  title={Segmenter: Transformer for semantic segmentation},
+  author={Strudel, Robin and Garcia, Ricardo and Laptev, Ivan and Schmid, Cordelia},
+  booktitle={Proceedings of the IEEE/CVF International Conference on Computer Vision},
+  pages={7262--7272},
+  year={2021}
+}
+```
diff --git a/mmsegmentation/configs/segmenter/metafile.yaml b/mmsegmentation/configs/segmenter/metafile.yaml
new file mode 100644
index 0000000..ff2aa44
--- /dev/null
+++ b/mmsegmentation/configs/segmenter/metafile.yaml
@@ -0,0 +1,138 @@
+Collections:
+- Name: Segmenter
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - ADE20K
+  Paper:
+    Title: 'Segmenter: Transformer for Semantic Segmentation'
+    URL: https://arxiv.org/abs/2105.05633
+  README: configs/segmenter/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: segmenter_vit-t_mask_8xb1-160k_ade20k-512x512
+  In Collection: Segmenter
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 39.99
+      mIoU(ms+flip): 40.83
+  Config: configs/segmenter/segmenter_vit-t_mask_8xb1-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 8
+    Architecture:
+    - ViT-T_16
+    - Segmenter
+    - Mask
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 1.21
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-t_mask_8x1_512x512_160k_ade20k/segmenter_vit-t_mask_8x1_512x512_160k_ade20k_20220105_151706-ffcf7509.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-t_mask_8x1_512x512_160k_ade20k/segmenter_vit-t_mask_8x1_512x512_160k_ade20k_20220105_151706.log.json
+  Paper:
+    Title: 'Segmenter: Transformer for Semantic Segmentation'
+    URL: https://arxiv.org/abs/2105.05633
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.21.0/mmseg/models/decode_heads/segmenter_mask_head.py#L15
+  Framework: PyTorch
+- Name: segmenter_vit-s_fcn_8xb1-160k_ade20k-512x512
+  In Collection: Segmenter
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 45.75
+      mIoU(ms+flip): 46.82
+  Config: configs/segmenter/segmenter_vit-s_fcn_8xb1-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 8
+    Architecture:
+    - ViT-S_16
+    - Segmenter
+    - Linear
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 1.78
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-s_linear_8x1_512x512_160k_ade20k/segmenter_vit-s_linear_8x1_512x512_160k_ade20k_20220105_151713-39658c46.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-s_linear_8x1_512x512_160k_ade20k/segmenter_vit-s_linear_8x1_512x512_160k_ade20k_20220105_151713.log.json
+  Paper:
+    Title: 'Segmenter: Transformer for Semantic Segmentation'
+    URL: https://arxiv.org/abs/2105.05633
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.21.0/mmseg/models/decode_heads/segmenter_mask_head.py#L15
+  Framework: PyTorch
+- Name: segmenter_vit-s_mask_8xb1-160k_ade20k-512x512
+  In Collection: Segmenter
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 46.19
+      mIoU(ms+flip): 47.85
+  Config: configs/segmenter/segmenter_vit-s_mask_8xb1-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 8
+    Architecture:
+    - ViT-S_16
+    - Segmenter
+    - Mask
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 2.03
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-s_mask_8x1_512x512_160k_ade20k/segmenter_vit-s_mask_8x1_512x512_160k_ade20k_20220105_151706-511bb103.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-s_mask_8x1_512x512_160k_ade20k/segmenter_vit-s_mask_8x1_512x512_160k_ade20k_20220105_151706.log.json
+  Paper:
+    Title: 'Segmenter: Transformer for Semantic Segmentation'
+    URL: https://arxiv.org/abs/2105.05633
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.21.0/mmseg/models/decode_heads/segmenter_mask_head.py#L15
+  Framework: PyTorch
+- Name: segmenter_vit-b_mask_8xb1-160k_ade20k-512x512
+  In Collection: Segmenter
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 49.6
+      mIoU(ms+flip): 51.07
+  Config: configs/segmenter/segmenter_vit-b_mask_8xb1-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 8
+    Architecture:
+    - ViT-B_16
+    - Segmenter
+    - Mask
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 4.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-b_mask_8x1_512x512_160k_ade20k/segmenter_vit-b_mask_8x1_512x512_160k_ade20k_20220105_151706-bc533b08.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-b_mask_8x1_512x512_160k_ade20k/segmenter_vit-b_mask_8x1_512x512_160k_ade20k_20220105_151706.log.json
+  Paper:
+    Title: 'Segmenter: Transformer for Semantic Segmentation'
+    URL: https://arxiv.org/abs/2105.05633
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.21.0/mmseg/models/decode_heads/segmenter_mask_head.py#L15
+  Framework: PyTorch
+- Name: segmenter_vit-l_mask_8xb1-160k_ade20k-512x512
+  In Collection: Segmenter
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 52.16
+      mIoU(ms+flip): 53.65
+  Config: configs/segmenter/segmenter_vit-l_mask_8xb1-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 8
+    Architecture:
+    - ViT-L_16
+    - Segmenter
+    - Mask
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 16.56
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-l_mask_8x1_512x512_160k_ade20k/segmenter_vit-l_mask_8x1_512x512_160k_ade20k_20220105_162750-7ef345be.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-l_mask_8x1_512x512_160k_ade20k/segmenter_vit-l_mask_8x1_512x512_160k_ade20k_20220105_162750.log.json
+  Paper:
+    Title: 'Segmenter: Transformer for Semantic Segmentation'
+    URL: https://arxiv.org/abs/2105.05633
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.21.0/mmseg/models/decode_heads/segmenter_mask_head.py#L15
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/segmenter/segmenter_vit-b_mask_8xb1-160k_ade20k-512x512.py b/mmsegmentation/configs/segmenter/segmenter_vit-b_mask_8xb1-160k_ade20k-512x512.py
new file mode 100644
index 0000000..a4bae50
--- /dev/null
+++ b/mmsegmentation/configs/segmenter/segmenter_vit-b_mask_8xb1-160k_ade20k-512x512.py
@@ -0,0 +1,14 @@
+_base_ = [
+    '../_base_/models/segmenter_vit-b16_mask.py',
+    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
+optimizer = dict(lr=0.001, weight_decay=0.0)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
+train_dataloader = dict(
+    # num_gpus: 8 -> batch_size: 8
+    batch_size=1)
+val_dataloader = dict(batch_size=1)
diff --git a/mmsegmentation/configs/segmenter/segmenter_vit-l_mask_8xb1-160k_ade20k-512x512.py b/mmsegmentation/configs/segmenter/segmenter_vit-l_mask_8xb1-160k_ade20k-512x512.py
new file mode 100644
index 0000000..302acde
--- /dev/null
+++ b/mmsegmentation/configs/segmenter/segmenter_vit-l_mask_8xb1-160k_ade20k-512x512.py
@@ -0,0 +1,32 @@
+_base_ = [
+    '../_base_/models/segmenter_vit-b16_mask.py',
+    '../_base_/datasets/ade20k_640x640.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (640, 640)
+data_preprocessor = dict(size=crop_size)
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segmenter/vit_large_p16_384_20220308-d4efb41d.pth'  # noqa
+
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained=checkpoint,
+    backbone=dict(
+        type='VisionTransformer',
+        img_size=(640, 640),
+        embed_dims=1024,
+        num_layers=24,
+        num_heads=16),
+    decode_head=dict(
+        type='SegmenterMaskTransformerHead',
+        in_channels=1024,
+        channels=1024,
+        num_heads=16,
+        embed_dims=1024),
+    test_cfg=dict(mode='slide', crop_size=(640, 640), stride=(608, 608)))
+
+optimizer = dict(lr=0.001, weight_decay=0.0)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
+train_dataloader = dict(
+    # num_gpus: 8 -> batch_size: 8
+    batch_size=1)
+val_dataloader = dict(batch_size=1)
diff --git a/mmsegmentation/configs/segmenter/segmenter_vit-s_fcn_8xb1-160k_ade20k-512x512.py b/mmsegmentation/configs/segmenter/segmenter_vit-s_fcn_8xb1-160k_ade20k-512x512.py
new file mode 100644
index 0000000..dc1e4c8
--- /dev/null
+++ b/mmsegmentation/configs/segmenter/segmenter_vit-s_fcn_8xb1-160k_ade20k-512x512.py
@@ -0,0 +1,14 @@
+_base_ = './segmenter_vit-s_mask_8xb1-160k_ade20k-512x512.py'
+
+model = dict(
+    decode_head=dict(
+        _delete_=True,
+        type='FCNHead',
+        in_channels=384,
+        channels=384,
+        num_convs=0,
+        dropout_ratio=0.0,
+        concat_input=False,
+        num_classes=150,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)))
diff --git a/mmsegmentation/configs/segmenter/segmenter_vit-s_mask_8xb1-160k_ade20k-512x512.py b/mmsegmentation/configs/segmenter/segmenter_vit-s_mask_8xb1-160k_ade20k-512x512.py
new file mode 100644
index 0000000..b19fd41
--- /dev/null
+++ b/mmsegmentation/configs/segmenter/segmenter_vit-s_mask_8xb1-160k_ade20k-512x512.py
@@ -0,0 +1,36 @@
+_base_ = [
+    '../_base_/models/segmenter_vit-b16_mask.py',
+    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segmenter/vit_small_p16_384_20220308-410f6037.pth'  # noqa
+
+backbone_norm_cfg = dict(type='LN', eps=1e-6, requires_grad=True)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained=checkpoint,
+    backbone=dict(
+        img_size=(512, 512),
+        embed_dims=384,
+        num_heads=6,
+    ),
+    decode_head=dict(
+        type='SegmenterMaskTransformerHead',
+        in_channels=384,
+        channels=384,
+        num_classes=150,
+        num_layers=2,
+        num_heads=6,
+        embed_dims=384,
+        dropout_ratio=0.0,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)))
+
+optimizer = dict(lr=0.001, weight_decay=0.0)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
+train_dataloader = dict(
+    # num_gpus: 8 -> batch_size: 8
+    batch_size=1)
+val_dataloader = dict(batch_size=1)
diff --git a/mmsegmentation/configs/segmenter/segmenter_vit-t_mask_8xb1-160k_ade20k-512x512.py b/mmsegmentation/configs/segmenter/segmenter_vit-t_mask_8xb1-160k_ade20k-512x512.py
new file mode 100644
index 0000000..221a9f9
--- /dev/null
+++ b/mmsegmentation/configs/segmenter/segmenter_vit-t_mask_8xb1-160k_ade20k-512x512.py
@@ -0,0 +1,26 @@
+_base_ = [
+    '../_base_/models/segmenter_vit-b16_mask.py',
+    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segmenter/vit_tiny_p16_384_20220308-cce8c795.pth'  # noqa
+
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained=checkpoint,
+    backbone=dict(embed_dims=192, num_heads=3),
+    decode_head=dict(
+        type='SegmenterMaskTransformerHead',
+        in_channels=192,
+        channels=192,
+        num_heads=3,
+        embed_dims=192))
+
+optimizer = dict(lr=0.001, weight_decay=0.0)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
+train_dataloader = dict(
+    # num_gpus: 8 -> batch_size: 8
+    batch_size=1)
+val_dataloader = dict(batch_size=1)
diff --git a/mmsegmentation/configs/segnext/README.md b/mmsegmentation/configs/segnext/README.md
new file mode 100644
index 0000000..d7434a0
--- /dev/null
+++ b/mmsegmentation/configs/segnext/README.md
@@ -0,0 +1,63 @@
+# SegNeXt
+
+> [SegNeXt: Rethinking Convolutional Attention Design for Semantic Segmentation](https://arxiv.org/abs/2209.08575)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/visual-attention-network/segnext">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/backbones/mscan.py#L328">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+We present SegNeXt, a simple convolutional network architecture for semantic segmentation. Recent transformer-based models have dominated the field of semantic segmentation due to the efficiency of self-attention in encoding spatial information. In this paper, we show that convolutional attention is a more efficient and effective way to encode contextual information than the self-attention mechanism in transformers. By re-examining the characteristics owned by successful segmentation models, we discover several key components leading to the performance improvement of segmentation models. This motivates us to design a novel convolutional attention network that uses cheap convolutional operations. Without bells and whistles, our SegNeXt significantly improves the performance of previous state-of-the-art methods on popular benchmarks, including ADE20K, Cityscapes, COCO-Stuff, Pascal VOC, Pascal Context, and iSAID. Notably, SegNeXt outperforms EfficientNet-L2 w/ NAS-FPN and achieves 90.6% mIoU on the Pascal VOC 2012 test leaderboard using only 1/10 parameters of it. On average, SegNeXt achieves about 2.0% mIoU improvements compared to the state-of-the-art methods on the ADE20K datasets with the same or fewer computations. Code is available at [this https URL](https://github.com/uyzhang/JSeg) (Jittor) and [this https URL](https://github.com/Visual-Attention-Network/SegNeXt) (Pytorch).
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/215688018-5d4c8366-7793-4fdf-9397-960a09fac951.png" width="70%"/>
+</div>
+
+## Results and models
+
+### ADE20K
+
+| Method  | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                              | download                                                                                                                                                                                                                                                                                                                                                                                   |
+| ------- | -------- | --------- | ------- | -------- | -------------- | ------ | ----- | ------------- | ----------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| SegNeXt | MSCAN-T  | 512x512   | 160000  | 17.88    | 52.38          | A100   | 41.50 | 42.59         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segnext/segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-t_1x16_512x512_adamw_160k_ade20k/segnext_mscan-t_1x16_512x512_adamw_160k_ade20k_20230210_140244-05bd8466.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-t_1x16_512x512_adamw_160k_ade20k/segnext_mscan-t_1x16_512x512_adamw_160k_ade20k_20230210_140244.log.json) |
+| SegNeXt | MSCAN-S  | 512x512   | 160000  | 21.47    | 42.27          | A100   | 44.16 | 45.81         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segnext/segnext_mscan-s_1xb16-adamw-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-s_1x16_512x512_adamw_160k_ade20k/segnext_mscan-s_1x16_512x512_adamw_160k_ade20k_20230214_113014-43013668.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-s_1x16_512x512_adamw_160k_ade20k/segnext_mscan-s_1x16_512x512_adamw_160k_ade20k_20230214_113014.log.json) |
+| SegNeXt | MSCAN-B  | 512x512   | 160000  | 31.03    | 35.15          | A100   | 48.03 | 49.68         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segnext/segnext_mscan-b_1xb16-adamw-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-b_1x16_512x512_adamw_160k_ade20k/segnext_mscan-b_1x16_512x512_adamw_160k_ade20k_20230209_172053-b6f6c70c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-b_1x16_512x512_adamw_160k_ade20k/segnext_mscan-b_1x16_512x512_adamw_160k_ade20k_20230209_172053.log.json) |
+| SegNeXt | MSCAN-L  | 512x512   | 160000  | 43.32    | 22.91          | A100   | 50.99 | 52.10         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segnext/segnext_mscan-l_1xb16-adamw-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-l_1x16_512x512_adamw_160k_ade20k/segnext_mscan-l_1x16_512x512_adamw_160k_ade20k_20230209_172055-19b14b63.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-l_1x16_512x512_adamw_160k_ade20k/segnext_mscan-l_1x16_512x512_adamw_160k_ade20k_20230209_172055.log.json) |
+
+Note:
+
+- When we integrated SegNeXt into MMSegmentation, we modified some layers' names to make them more precise and concise without changing the model architecture. Therefore, the keys of pre-trained weights are different from the [original weights](https://cloud.tsinghua.edu.cn/d/c15b25a6745946618462/), but don't worry about these changes. we have converted them and uploaded the checkpoints, you might find URL of pre-trained checkpoints in config files and can use them directly for training.
+
+- The total batch size is 16. We trained for SegNeXt with a single GPU as the performance degrades significantly when using`SyncBN` (mainly in `OverlapPatchEmbed` modules of `MSCAN`) of PyTorch 1.9.
+
+- There will be subtle differences when model testing as Non-negative Matrix Factorization (NMF) in `LightHamHead` will be initialized randomly. To control this randomness, please set the random seed when model testing. You can modify [`./tools/test.py`](https://github.com/open-mmlab/mmsegmentation/blob/main/tools/test.py) like:
+
+```python
+def main():
+    from mmengine.runner import seg_random_seed
+    random_seed = xxx # set random seed recorded in training log
+    set_random_seed(random_seed, deterministic=False)
+    ...
+```
+
+- This model performance is sensitive to the seed values used, please refer to the log file for the specific settings of the seed. If you choose a different seed, the results might differ from the table results. Take SegNeXt Large for example, its results range from 49.60 to 51.0.
+
+## Citation
+
+```bibtex
+@article{guo2022segnext,
+  title={SegNeXt: Rethinking Convolutional Attention Design for Semantic Segmentation},
+  author={Guo, Meng-Hao and Lu, Cheng-Ze and Hou, Qibin and Liu, Zhengning and Cheng, Ming-Ming and Hu, Shi-Min},
+  journal={arXiv preprint arXiv:2209.08575},
+  year={2022}
+}
+```
diff --git a/mmsegmentation/configs/segnext/metafile.yaml b/mmsegmentation/configs/segnext/metafile.yaml
new file mode 100644
index 0000000..3c8ff5b
--- /dev/null
+++ b/mmsegmentation/configs/segnext/metafile.yaml
@@ -0,0 +1,109 @@
+Collections:
+- Name: SegNeXt
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - ADE20K
+  Paper:
+    Title: 'SegNeXt: Rethinking Convolutional Attention Design for Semantic Segmentation'
+    URL: https://arxiv.org/abs/2209.08575
+  README: configs/segnext/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512
+  In Collection: SegNeXt
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 41.5
+      mIoU(ms+flip): 42.59
+  Config: configs/segnext/segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - MSCAN-T
+    - SegNeXt
+    Training Resources: 1x A100 GPUS
+    Memory (GB): 17.88
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-t_1x16_512x512_adamw_160k_ade20k/segnext_mscan-t_1x16_512x512_adamw_160k_ade20k_20230210_140244-05bd8466.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-t_1x16_512x512_adamw_160k_ade20k/segnext_mscan-t_1x16_512x512_adamw_160k_ade20k_20230210_140244.log.json
+  Paper:
+    Title: 'SegNeXt: Rethinking Convolutional Attention Design for Semantic Segmentation'
+    URL: https://arxiv.org/abs/2209.08575
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/backbones/mscan.py#L328
+  Framework: PyTorch
+- Name: segnext_mscan-s_1xb16-adamw-160k_ade20k-512x512
+  In Collection: SegNeXt
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 44.16
+      mIoU(ms+flip): 45.81
+  Config: configs/segnext/segnext_mscan-s_1xb16-adamw-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - MSCAN-S
+    - SegNeXt
+    Training Resources: 1x A100 GPUS
+    Memory (GB): 21.47
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-s_1x16_512x512_adamw_160k_ade20k/segnext_mscan-s_1x16_512x512_adamw_160k_ade20k_20230214_113014-43013668.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-s_1x16_512x512_adamw_160k_ade20k/segnext_mscan-s_1x16_512x512_adamw_160k_ade20k_20230214_113014.log.json
+  Paper:
+    Title: 'SegNeXt: Rethinking Convolutional Attention Design for Semantic Segmentation'
+    URL: https://arxiv.org/abs/2209.08575
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/backbones/mscan.py#L328
+  Framework: PyTorch
+- Name: segnext_mscan-b_1xb16-adamw-160k_ade20k-512x512
+  In Collection: SegNeXt
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 48.03
+      mIoU(ms+flip): 49.68
+  Config: configs/segnext/segnext_mscan-b_1xb16-adamw-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - MSCAN-B
+    - SegNeXt
+    Training Resources: 1x A100 GPUS
+    Memory (GB): 31.03
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-b_1x16_512x512_adamw_160k_ade20k/segnext_mscan-b_1x16_512x512_adamw_160k_ade20k_20230209_172053-b6f6c70c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-b_1x16_512x512_adamw_160k_ade20k/segnext_mscan-b_1x16_512x512_adamw_160k_ade20k_20230209_172053.log.json
+  Paper:
+    Title: 'SegNeXt: Rethinking Convolutional Attention Design for Semantic Segmentation'
+    URL: https://arxiv.org/abs/2209.08575
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/backbones/mscan.py#L328
+  Framework: PyTorch
+- Name: segnext_mscan-l_1xb16-adamw-160k_ade20k-512x512
+  In Collection: SegNeXt
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 50.99
+      mIoU(ms+flip): 52.1
+  Config: configs/segnext/segnext_mscan-l_1xb16-adamw-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - MSCAN-L
+    - SegNeXt
+    Training Resources: 1x A100 GPUS
+    Memory (GB): 43.32
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-l_1x16_512x512_adamw_160k_ade20k/segnext_mscan-l_1x16_512x512_adamw_160k_ade20k_20230209_172055-19b14b63.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-l_1x16_512x512_adamw_160k_ade20k/segnext_mscan-l_1x16_512x512_adamw_160k_ade20k_20230209_172055.log.json
+  Paper:
+    Title: 'SegNeXt: Rethinking Convolutional Attention Design for Semantic Segmentation'
+    URL: https://arxiv.org/abs/2209.08575
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/backbones/mscan.py#L328
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/segnext/segnext_mscan-b_1xb16-adamw-160k_ade20k-512x512.py b/mmsegmentation/configs/segnext/segnext_mscan-b_1xb16-adamw-160k_ade20k-512x512.py
new file mode 100644
index 0000000..000f448
--- /dev/null
+++ b/mmsegmentation/configs/segnext/segnext_mscan-b_1xb16-adamw-160k_ade20k-512x512.py
@@ -0,0 +1,28 @@
+_base_ = './segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512.py'
+
+# model settings
+checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segnext/mscan_b_20230227-3ab7d230.pth'  # noqa
+ham_norm_cfg = dict(type='GN', num_groups=32, requires_grad=True)
+model = dict(
+    type='EncoderDecoder',
+    backbone=dict(
+        embed_dims=[64, 128, 320, 512],
+        depths=[3, 3, 12, 3],
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file),
+        drop_path_rate=0.1,
+        norm_cfg=dict(type='BN', requires_grad=True)),
+    decode_head=dict(
+        type='LightHamHead',
+        in_channels=[128, 320, 512],
+        in_index=[1, 2, 3],
+        channels=512,
+        ham_channels=512,
+        dropout_ratio=0.1,
+        num_classes=150,
+        norm_cfg=ham_norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/segnext/segnext_mscan-l_1xb16-adamw-160k_ade20k-512x512.py b/mmsegmentation/configs/segnext/segnext_mscan-l_1xb16-adamw-160k_ade20k-512x512.py
new file mode 100644
index 0000000..212d0a8
--- /dev/null
+++ b/mmsegmentation/configs/segnext/segnext_mscan-l_1xb16-adamw-160k_ade20k-512x512.py
@@ -0,0 +1,27 @@
+_base_ = './segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512.py'
+# model settings
+checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segnext/mscan_l_20230227-cef260d4.pth'  # noqa
+ham_norm_cfg = dict(type='GN', num_groups=32, requires_grad=True)
+model = dict(
+    type='EncoderDecoder',
+    backbone=dict(
+        embed_dims=[64, 128, 320, 512],
+        depths=[3, 5, 27, 3],
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file),
+        drop_path_rate=0.3,
+        norm_cfg=dict(type='BN', requires_grad=True)),
+    decode_head=dict(
+        type='LightHamHead',
+        in_channels=[128, 320, 512],
+        in_index=[1, 2, 3],
+        channels=1024,
+        ham_channels=1024,
+        dropout_ratio=0.1,
+        num_classes=150,
+        norm_cfg=ham_norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/segnext/segnext_mscan-s_1xb16-adamw-160k_ade20k-512x512.py b/mmsegmentation/configs/segnext/segnext_mscan-s_1xb16-adamw-160k_ade20k-512x512.py
new file mode 100644
index 0000000..9a90779
--- /dev/null
+++ b/mmsegmentation/configs/segnext/segnext_mscan-s_1xb16-adamw-160k_ade20k-512x512.py
@@ -0,0 +1,27 @@
+_base_ = './segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512.py'
+# model settings
+checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segnext/mscan_s_20230227-f33ccdf2.pth'  # noqa
+ham_norm_cfg = dict(type='GN', num_groups=32, requires_grad=True)
+model = dict(
+    type='EncoderDecoder',
+    backbone=dict(
+        embed_dims=[64, 128, 320, 512],
+        depths=[2, 2, 4, 2],
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file),
+        norm_cfg=dict(type='BN', requires_grad=True)),
+    decode_head=dict(
+        type='LightHamHead',
+        in_channels=[128, 320, 512],
+        in_index=[1, 2, 3],
+        channels=256,
+        ham_channels=256,
+        ham_kwargs=dict(MD_R=16),
+        dropout_ratio=0.1,
+        num_classes=150,
+        norm_cfg=ham_norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/segnext/segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512.py b/mmsegmentation/configs/segnext/segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512.py
new file mode 100644
index 0000000..c8d6da8
--- /dev/null
+++ b/mmsegmentation/configs/segnext/segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512.py
@@ -0,0 +1,84 @@
+_base_ = [
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py',
+    '../_base_/datasets/ade20k.py'
+]
+# model settings
+checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segnext/mscan_t_20230227-119e8c9f.pth'  # noqa
+ham_norm_cfg = dict(type='GN', num_groups=32, requires_grad=True)
+crop_size = (512, 512)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255,
+    size=(512, 512),
+    test_cfg=dict(size_divisor=32))
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        type='MSCAN',
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file),
+        embed_dims=[32, 64, 160, 256],
+        mlp_ratios=[8, 8, 4, 4],
+        drop_rate=0.0,
+        drop_path_rate=0.1,
+        depths=[3, 3, 5, 2],
+        attention_kernel_sizes=[5, [1, 7], [1, 11], [1, 21]],
+        attention_kernel_paddings=[2, [0, 3], [0, 5], [0, 10]],
+        act_cfg=dict(type='GELU'),
+        norm_cfg=dict(type='BN', requires_grad=True)),
+    decode_head=dict(
+        type='LightHamHead',
+        in_channels=[64, 160, 256],
+        in_index=[1, 2, 3],
+        channels=256,
+        ham_channels=256,
+        dropout_ratio=0.1,
+        num_classes=150,
+        norm_cfg=ham_norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
+        ham_kwargs=dict(
+            MD_S=1,
+            MD_R=16,
+            train_steps=6,
+            eval_steps=7,
+            inv_t=100,
+            rand_init=True)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+
+# dataset settings
+train_dataloader = dict(batch_size=16)
+
+# optimizer
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
+    paramwise_cfg=dict(
+        custom_keys={
+            'pos_block': dict(decay_mult=0.),
+            'norm': dict(decay_mult=0.),
+            'head': dict(lr_mult=10.)
+        }))
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        power=1.0,
+        begin=1500,
+        end=160000,
+        eta_min=0.0,
+        by_epoch=False,
+    )
+]
diff --git a/mmsegmentation/configs/sem_fpn/README.md b/mmsegmentation/configs/sem_fpn/README.md
new file mode 100644
index 0000000..697cf50
--- /dev/null
+++ b/mmsegmentation/configs/sem_fpn/README.md
@@ -0,0 +1,51 @@
+# Semantic FPN
+
+> [Panoptic Feature Pyramid Networks](https://arxiv.org/abs/1901.02446)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/facebookresearch/detectron2">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fpn_head.py#L12">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+The recently introduced panoptic segmentation task has renewed our community's interest in unifying the tasks of instance segmentation (for thing classes) and semantic segmentation (for stuff classes). However, current state-of-the-art methods for this joint task use separate and dissimilar networks for instance and semantic segmentation, without performing any shared computation. In this work, we aim to unify these methods at the architectural level, designing a single network for both tasks. Our approach is to endow Mask R-CNN, a popular instance segmentation method, with a semantic segmentation branch using a shared Feature Pyramid Network (FPN) backbone. Surprisingly, this simple baseline not only remains effective for instance segmentation, but also yields a lightweight, top-performing method for semantic segmentation. In this work, we perform a detailed study of this minimally extended version of Mask R-CNN with FPN, which we refer to as Panoptic FPN, and show it is a robust and accurate baseline for both tasks. Given its effectiveness and conceptual simplicity, we hope our method can serve as a strong baseline and aid future research in panoptic segmentation.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142902694-03ed2131-9104-467b-ace1-c74c62fb7177.png" width="60%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                    | download                                                                                                                                                                                                                                                                                                                           |
+| ------ | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | ------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FPN    | R-50     | 512x1024  |   80000 |      2.8 | 13.54          | V100   | 74.52 | 76.08         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/sem_fpn/fpn_r50_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r50_512x1024_80k_cityscapes/fpn_r50_512x1024_80k_cityscapes_20200717_021437-94018a0d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r50_512x1024_80k_cityscapes/fpn_r50_512x1024_80k_cityscapes-20200717_021437.log.json)     |
+| FPN    | R-101    | 512x1024  |   80000 |      3.9 | 10.29          | V100   | 75.80 | 77.40         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/sem_fpn/fpn_r101_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r101_512x1024_80k_cityscapes/fpn_r101_512x1024_80k_cityscapes_20200717_012416-c5800d4c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r101_512x1024_80k_cityscapes/fpn_r101_512x1024_80k_cityscapes-20200717_012416.log.json) |
+
+### ADE20K
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                | download                                                                                                                                                                                                                                                                                                           |
+| ------ | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| FPN    | R-50     | 512x512   |  160000 |      4.9 | 55.77          | V100   | 37.49 | 39.09         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/sem_fpn/fpn_r50_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r50_512x512_160k_ade20k/fpn_r50_512x512_160k_ade20k_20200718_131734-5b5a6ab9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r50_512x512_160k_ade20k/fpn_r50_512x512_160k_ade20k-20200718_131734.log.json)     |
+| FPN    | R-101    | 512x512   |  160000 |      5.9 | 40.58          | V100   | 39.35 | 40.72         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/sem_fpn/fpn_r101_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r101_512x512_160k_ade20k/fpn_r101_512x512_160k_ade20k_20200718_131734-306b5004.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r101_512x512_160k_ade20k/fpn_r101_512x512_160k_ade20k-20200718_131734.log.json) |
+
+## Citation
+
+```bibtex
+@inproceedings{kirillov2019panoptic,
+  title={Panoptic feature pyramid networks},
+  author={Kirillov, Alexander and Girshick, Ross and He, Kaiming and Doll{\'a}r, Piotr},
+  booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
+  pages={6399--6408},
+  year={2019}
+}
+```
diff --git a/mmsegmentation/configs/sem_fpn/fpn_r101_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/sem_fpn/fpn_r101_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..1e9bcfb
--- /dev/null
+++ b/mmsegmentation/configs/sem_fpn/fpn_r101_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './fpn_r50_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/sem_fpn/fpn_r101_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/sem_fpn/fpn_r101_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..adad1a4
--- /dev/null
+++ b/mmsegmentation/configs/sem_fpn/fpn_r101_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,5 @@
+_base_ = './fpn_r50_4xb4-160k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/sem_fpn/fpn_r50_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/sem_fpn/fpn_r50_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..bf71d38
--- /dev/null
+++ b/mmsegmentation/configs/sem_fpn/fpn_r50_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/fpn_r50.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/sem_fpn/fpn_r50_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/sem_fpn/fpn_r50_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..4e4bc57
--- /dev/null
+++ b/mmsegmentation/configs/sem_fpn/fpn_r50_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,8 @@
+_base_ = [
+    '../_base_/models/fpn_r50.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor, decode_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/sem_fpn/metafile.yaml b/mmsegmentation/configs/sem_fpn/metafile.yaml
new file mode 100644
index 0000000..e734897
--- /dev/null
+++ b/mmsegmentation/configs/sem_fpn/metafile.yaml
@@ -0,0 +1,110 @@
+Collections:
+- Name: FPN
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+    - ADE20K
+  Paper:
+    Title: Panoptic Feature Pyramid Networks
+    URL: https://arxiv.org/abs/1901.02446
+  README: configs/sem_fpn/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: fpn_r50_4xb2-80k_cityscapes-512x1024
+  In Collection: FPN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 74.52
+      mIoU(ms+flip): 76.08
+  Config: configs/sem_fpn/fpn_r50_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50
+    - FPN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 2.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r50_512x1024_80k_cityscapes/fpn_r50_512x1024_80k_cityscapes_20200717_021437-94018a0d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r50_512x1024_80k_cityscapes/fpn_r50_512x1024_80k_cityscapes-20200717_021437.log.json
+  Paper:
+    Title: Panoptic Feature Pyramid Networks
+    URL: https://arxiv.org/abs/1901.02446
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fpn_head.py#L12
+  Framework: PyTorch
+- Name: fpn_r101_4xb2-80k_cityscapes-512x1024
+  In Collection: FPN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 75.8
+      mIoU(ms+flip): 77.4
+  Config: configs/sem_fpn/fpn_r101_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101
+    - FPN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 3.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r101_512x1024_80k_cityscapes/fpn_r101_512x1024_80k_cityscapes_20200717_012416-c5800d4c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r101_512x1024_80k_cityscapes/fpn_r101_512x1024_80k_cityscapes-20200717_012416.log.json
+  Paper:
+    Title: Panoptic Feature Pyramid Networks
+    URL: https://arxiv.org/abs/1901.02446
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fpn_head.py#L12
+  Framework: PyTorch
+- Name: fpn_r50_4xb4-160k_ade20k-512x512
+  In Collection: FPN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 37.49
+      mIoU(ms+flip): 39.09
+  Config: configs/sem_fpn/fpn_r50_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50
+    - FPN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 4.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r50_512x512_160k_ade20k/fpn_r50_512x512_160k_ade20k_20200718_131734-5b5a6ab9.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r50_512x512_160k_ade20k/fpn_r50_512x512_160k_ade20k-20200718_131734.log.json
+  Paper:
+    Title: Panoptic Feature Pyramid Networks
+    URL: https://arxiv.org/abs/1901.02446
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fpn_head.py#L12
+  Framework: PyTorch
+- Name: fpn_r101_4xb4-160k_ade20k-512x512
+  In Collection: FPN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 39.35
+      mIoU(ms+flip): 40.72
+  Config: configs/sem_fpn/fpn_r101_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101
+    - FPN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 5.9
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r101_512x512_160k_ade20k/fpn_r101_512x512_160k_ade20k_20200718_131734-306b5004.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r101_512x512_160k_ade20k/fpn_r101_512x512_160k_ade20k-20200718_131734.log.json
+  Paper:
+    Title: Panoptic Feature Pyramid Networks
+    URL: https://arxiv.org/abs/1901.02446
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fpn_head.py#L12
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/setr/README.md b/mmsegmentation/configs/setr/README.md
new file mode 100644
index 0000000..15be6ec
--- /dev/null
+++ b/mmsegmentation/configs/setr/README.md
@@ -0,0 +1,74 @@
+# SETR
+
+> [Rethinking Semantic Segmentation from a Sequence-to-Sequence Perspective with Transformers](https://arxiv.org/abs/2012.15840)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/fudan-zvg/SETR">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/setr_up_head.py#L11">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Most recent semantic segmentation methods adopt a fully-convolutional network (FCN) with an encoder-decoder architecture. The encoder progressively reduces the spatial resolution and learns more abstract/semantic visual concepts with larger receptive fields. Since context modeling is critical for segmentation, the latest efforts have been focused on increasing the receptive field, through either dilated/atrous convolutions or inserting attention modules. However, the encoder-decoder based FCN architecture remains unchanged. In this paper, we aim to provide an alternative perspective by treating semantic segmentation as a sequence-to-sequence prediction task. Specifically, we deploy a pure transformer (ie, without convolution and resolution reduction) to encode an image as a sequence of patches. With the global context modeled in every layer of the transformer, this encoder can be combined with a simple decoder to provide a powerful segmentation model, termed SEgmentation TRansformer (SETR). Extensive experiments show that SETR achieves new state of the art on ADE20K (50.28% mIoU), Pascal Context (55.83% mIoU) and competitive results on Cityscapes. Particularly, we achieve the first position in the highly competitive ADE20K test server leaderboard on the day of submission.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142902777-ee2d34b7-a631-4fa7-ad68-118ff5716afe.png" width="80%"/>
+</div>
+
+```None
+This head has two version head.
+```
+
+## Usage
+
+You can download the pretrain from [here](https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-vitjx/jx_vit_large_p16_384-b3be5167.pth). Then you can convert its keys with the script `vit2mmseg.py` in the tools directory.
+
+```shell
+python tools/model_converters/vit2mmseg.py ${PRETRAIN_PATH} ${STORE_PATH}
+```
+
+E.g.
+
+```shell
+python tools/model_converters/vit2mmseg.py \
+jx_vit_large_p16_384-b3be5167.pth pretrain/vit_large_p16.pth
+```
+
+This script convert the model from `PRETRAIN_PATH` and store the converted model in `STORE_PATH`.
+
+## Results and models
+
+### ADE20K
+
+| Method     | Backbone | Crop Size | Batch Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                     | download                                                                                                                                                                                                                                                                                                                             |
+| ---------- | -------- | --------- | ---------- | ------- | -------- | -------------- | ------ | ----- | ------------: | -------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| SETR Naive | ViT-L    | 512x512   | 16         | 160000  | 18.40    | 4.72           | V100   | 48.28 |         49.56 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/setr/setr_vit-l_naive_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_naive_512x512_160k_b16_ade20k/setr_naive_512x512_160k_b16_ade20k_20210619_191258-061f24f5.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_naive_512x512_160k_b16_ade20k/setr_naive_512x512_160k_b16_ade20k_20210619_191258.log.json) |
+| SETR PUP   | ViT-L    | 512x512   | 16         | 160000  | 19.54    | 4.50           | V100   | 48.24 |         49.99 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/setr/setr_vit-l_pup_8xb2-160k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_pup_512x512_160k_b16_ade20k/setr_pup_512x512_160k_b16_ade20k_20210619_191343-7e0ce826.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_pup_512x512_160k_b16_ade20k/setr_pup_512x512_160k_b16_ade20k_20210619_191343.log.json)         |
+| SETR MLA   | ViT-L    | 512x512   | 8          | 160000  | 10.96    | -              | V100   | 47.34 |         49.05 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/setr/setr_vit-l-mla_8xb1-160k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_512x512_160k_b8_ade20k/setr_mla_512x512_160k_b8_ade20k_20210619_191118-c6d21df0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_512x512_160k_b8_ade20k/setr_mla_512x512_160k_b8_ade20k_20210619_191118.log.json)             |
+| SETR MLA   | ViT-L    | 512x512   | 16         | 160000  | 17.30    | 5.25           | V100   | 47.39 |         49.37 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/setr/setr_vit-l_mla_8xb2-160k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_512x512_160k_b16_ade20k/setr_mla_512x512_160k_b16_ade20k_20210619_191057-f9741de7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_512x512_160k_b16_ade20k/setr_mla_512x512_160k_b16_ade20k_20210619_191057.log.json)         |
+
+### Cityscapes
+
+| Method     | Backbone | Crop Size | Batch Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                        | download                                                                                                                                                                                                                                                                                                                                                                                 |
+| ---------- | -------- | --------- | ---------- | ------- | -------- | -------------- | ------ | ----- | ------------: | ----------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| SETR Naive | ViT-L    | 768x768   | 8          | 80000   | 24.06    | 0.39           | V100   | 78.10 |         80.22 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/setr/setr_vit-l_naive_8xb1-80k_cityscapes-768x768.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_naive_vit-large_8x1_768x768_80k_cityscapes/setr_naive_vit-large_8x1_768x768_80k_cityscapes_20211123_000505-20728e80.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_naive_vit-large_8x1_768x768_80k_cityscapes/setr_naive_vit-large_8x1_768x768_80k_cityscapes_20211123_000505.log.json) |
+| SETR PUP   | ViT-L    | 768x768   | 8          | 80000   | 27.96    | 0.37           | V100   | 79.21 |         81.02 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/setr/setr_vit-l_pup_8xb1-80k_cityscapes-768x768.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_pup_vit-large_8x1_768x768_80k_cityscapes/setr_pup_vit-large_8x1_768x768_80k_cityscapes_20211122_155115-f6f37b8f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_pup_vit-large_8x1_768x768_80k_cityscapes/setr_pup_vit-large_8x1_768x768_80k_cityscapes_20211122_155115.log.json)         |
+| SETR MLA   | ViT-L    | 768x768   | 8          | 80000   | 24.10    | 0.41           | V100   | 77.00 |         79.59 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/setr/setr_vit-l_mla_8xb1-80k_cityscapes-768x768.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_vit-large_8x1_768x768_80k_cityscapes/setr_mla_vit-large_8x1_768x768_80k_cityscapes_20211119_101003-7f8dccbe.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_vit-large_8x1_768x768_80k_cityscapes/setr_mla_vit-large_8x1_768x768_80k_cityscapes_20211119_101003.log.json)         |
+
+## Citation
+
+```bibtex
+@article{zheng2020rethinking,
+  title={Rethinking Semantic Segmentation from a Sequence-to-Sequence Perspective with Transformers},
+  author={Zheng, Sixiao and Lu, Jiachen and Zhao, Hengshuang and Zhu, Xiatian and Luo, Zekun and Wang, Yabiao and Fu, Yanwei and Feng, Jianfeng and Xiang, Tao and Torr, Philip HS and others},
+  journal={arXiv preprint arXiv:2012.15840},
+  year={2020}
+}
+```
diff --git a/mmsegmentation/configs/setr/metafile.yaml b/mmsegmentation/configs/setr/metafile.yaml
new file mode 100644
index 0000000..8e6bc08
--- /dev/null
+++ b/mmsegmentation/configs/setr/metafile.yaml
@@ -0,0 +1,197 @@
+Collections:
+- Name: SETR
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - ADE20K
+    - Cityscapes
+  Paper:
+    Title: Rethinking Semantic Segmentation from a Sequence-to-Sequence Perspective
+      with Transformers
+    URL: https://arxiv.org/abs/2012.15840
+  README: configs/setr/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: setr_vit-l_naive_8xb2-160k_ade20k-512x512
+  In Collection: SETR
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 48.28
+      mIoU(ms+flip): 49.56
+  Config: configs/setr/setr_vit-l_naive_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - ViT-L
+    - SETR
+    - Naive
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 18.4
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_naive_512x512_160k_b16_ade20k/setr_naive_512x512_160k_b16_ade20k_20210619_191258-061f24f5.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_naive_512x512_160k_b16_ade20k/setr_naive_512x512_160k_b16_ade20k_20210619_191258.log.json
+  Paper:
+    Title: Rethinking Semantic Segmentation from a Sequence-to-Sequence Perspective
+      with Transformers
+    URL: https://arxiv.org/abs/2012.15840
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/setr_up_head.py#L11
+  Framework: PyTorch
+- Name: setr_vit-l_pup_8xb2-160k_ade20k-512x512
+  In Collection: SETR
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 48.24
+      mIoU(ms+flip): 49.99
+  Config: configs/setr/setr_vit-l_pup_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - ViT-L
+    - SETR
+    - PUP
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 19.54
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_pup_512x512_160k_b16_ade20k/setr_pup_512x512_160k_b16_ade20k_20210619_191343-7e0ce826.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_pup_512x512_160k_b16_ade20k/setr_pup_512x512_160k_b16_ade20k_20210619_191343.log.json
+  Paper:
+    Title: Rethinking Semantic Segmentation from a Sequence-to-Sequence Perspective
+      with Transformers
+    URL: https://arxiv.org/abs/2012.15840
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/setr_up_head.py#L11
+  Framework: PyTorch
+- Name: setr_vit-l-mla_8xb1-160k_ade20k-512x512
+  In Collection: SETR
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 47.34
+      mIoU(ms+flip): 49.05
+  Config: configs/setr/setr_vit-l-mla_8xb1-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 8
+    Architecture:
+    - ViT-L
+    - SETR
+    - MLA
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 10.96
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_512x512_160k_b8_ade20k/setr_mla_512x512_160k_b8_ade20k_20210619_191118-c6d21df0.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_512x512_160k_b8_ade20k/setr_mla_512x512_160k_b8_ade20k_20210619_191118.log.json
+  Paper:
+    Title: Rethinking Semantic Segmentation from a Sequence-to-Sequence Perspective
+      with Transformers
+    URL: https://arxiv.org/abs/2012.15840
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/setr_up_head.py#L11
+  Framework: PyTorch
+- Name: setr_vit-l_mla_8xb2-160k_ade20k-512x512
+  In Collection: SETR
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 47.39
+      mIoU(ms+flip): 49.37
+  Config: configs/setr/setr_vit-l_mla_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - ViT-L
+    - SETR
+    - MLA
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 17.3
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_512x512_160k_b16_ade20k/setr_mla_512x512_160k_b16_ade20k_20210619_191057-f9741de7.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_512x512_160k_b16_ade20k/setr_mla_512x512_160k_b16_ade20k_20210619_191057.log.json
+  Paper:
+    Title: Rethinking Semantic Segmentation from a Sequence-to-Sequence Perspective
+      with Transformers
+    URL: https://arxiv.org/abs/2012.15840
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/setr_up_head.py#L11
+  Framework: PyTorch
+- Name: setr_vit-l_naive_8xb1-80k_cityscapes-768x768
+  In Collection: SETR
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.1
+      mIoU(ms+flip): 80.22
+  Config: configs/setr/setr_vit-l_naive_8xb1-80k_cityscapes-768x768.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - ViT-L
+    - SETR
+    - Naive
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 24.06
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_naive_vit-large_8x1_768x768_80k_cityscapes/setr_naive_vit-large_8x1_768x768_80k_cityscapes_20211123_000505-20728e80.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_naive_vit-large_8x1_768x768_80k_cityscapes/setr_naive_vit-large_8x1_768x768_80k_cityscapes_20211123_000505.log.json
+  Paper:
+    Title: Rethinking Semantic Segmentation from a Sequence-to-Sequence Perspective
+      with Transformers
+    URL: https://arxiv.org/abs/2012.15840
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/setr_up_head.py#L11
+  Framework: PyTorch
+- Name: setr_vit-l_pup_8xb1-80k_cityscapes-768x768
+  In Collection: SETR
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.21
+      mIoU(ms+flip): 81.02
+  Config: configs/setr/setr_vit-l_pup_8xb1-80k_cityscapes-768x768.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - ViT-L
+    - SETR
+    - PUP
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 27.96
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_pup_vit-large_8x1_768x768_80k_cityscapes/setr_pup_vit-large_8x1_768x768_80k_cityscapes_20211122_155115-f6f37b8f.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_pup_vit-large_8x1_768x768_80k_cityscapes/setr_pup_vit-large_8x1_768x768_80k_cityscapes_20211122_155115.log.json
+  Paper:
+    Title: Rethinking Semantic Segmentation from a Sequence-to-Sequence Perspective
+      with Transformers
+    URL: https://arxiv.org/abs/2012.15840
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/setr_up_head.py#L11
+  Framework: PyTorch
+- Name: setr_vit-l_mla_8xb1-80k_cityscapes-768x768
+  In Collection: SETR
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.0
+      mIoU(ms+flip): 79.59
+  Config: configs/setr/setr_vit-l_mla_8xb1-80k_cityscapes-768x768.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - ViT-L
+    - SETR
+    - MLA
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 24.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_vit-large_8x1_768x768_80k_cityscapes/setr_mla_vit-large_8x1_768x768_80k_cityscapes_20211119_101003-7f8dccbe.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_vit-large_8x1_768x768_80k_cityscapes/setr_mla_vit-large_8x1_768x768_80k_cityscapes_20211119_101003.log.json
+  Paper:
+    Title: Rethinking Semantic Segmentation from a Sequence-to-Sequence Perspective
+      with Transformers
+    URL: https://arxiv.org/abs/2012.15840
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/setr_up_head.py#L11
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/setr/setr_vit-l-mla_8xb1-160k_ade20k-512x512.py b/mmsegmentation/configs/setr/setr_vit-l-mla_8xb1-160k_ade20k-512x512.py
new file mode 100644
index 0000000..1c6e284
--- /dev/null
+++ b/mmsegmentation/configs/setr/setr_vit-l-mla_8xb1-160k_ade20k-512x512.py
@@ -0,0 +1,90 @@
+_base_ = [
+    '../_base_/models/setr_mla.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        img_size=(512, 512),
+        drop_rate=0.,
+        init_cfg=dict(
+            type='Pretrained', checkpoint='pretrain/vit_large_p16.pth')),
+    decode_head=dict(num_classes=150),
+    auxiliary_head=[
+        dict(
+            type='FCNHead',
+            in_channels=256,
+            channels=256,
+            in_index=0,
+            dropout_ratio=0,
+            norm_cfg=norm_cfg,
+            act_cfg=dict(type='ReLU'),
+            num_convs=0,
+            kernel_size=1,
+            concat_input=False,
+            num_classes=150,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='FCNHead',
+            in_channels=256,
+            channels=256,
+            in_index=1,
+            dropout_ratio=0,
+            norm_cfg=norm_cfg,
+            act_cfg=dict(type='ReLU'),
+            num_convs=0,
+            kernel_size=1,
+            concat_input=False,
+            num_classes=150,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='FCNHead',
+            in_channels=256,
+            channels=256,
+            in_index=2,
+            dropout_ratio=0,
+            norm_cfg=norm_cfg,
+            act_cfg=dict(type='ReLU'),
+            num_convs=0,
+            kernel_size=1,
+            concat_input=False,
+            num_classes=150,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='FCNHead',
+            in_channels=256,
+            channels=256,
+            in_index=3,
+            dropout_ratio=0,
+            norm_cfg=norm_cfg,
+            act_cfg=dict(type='ReLU'),
+            num_convs=0,
+            kernel_size=1,
+            concat_input=False,
+            num_classes=150,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    ],
+    test_cfg=dict(mode='slide', crop_size=(512, 512), stride=(341, 341)),
+)
+
+optimizer = dict(lr=0.001, weight_decay=0.0)
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=optimizer,
+    paramwise_cfg=dict(custom_keys={'head': dict(lr_mult=10.)}))
+# num_gpus: 8 -> batch_size: 8
+train_dataloader = dict(batch_size=1)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/setr/setr_vit-l_mla_8xb1-80k_cityscapes-768x768.py b/mmsegmentation/configs/setr/setr_vit-l_mla_8xb1-80k_cityscapes-768x768.py
new file mode 100644
index 0000000..026557f
--- /dev/null
+++ b/mmsegmentation/configs/setr/setr_vit-l_mla_8xb1-80k_cityscapes-768x768.py
@@ -0,0 +1,23 @@
+_base_ = [
+    '../_base_/models/setr_mla.py', '../_base_/datasets/cityscapes_768x768.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (768, 768)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        drop_rate=0,
+        init_cfg=dict(
+            type='Pretrained', checkpoint='pretrain/vit_large_p16.pth')),
+    test_cfg=dict(mode='slide', crop_size=(768, 768), stride=(512, 512)))
+
+optimizer = dict(lr=0.002, weight_decay=0.0)
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=optimizer,
+    paramwise_cfg=dict(custom_keys={'head': dict(lr_mult=10.)}))
+train_dataloader = dict(batch_size=1)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/setr/setr_vit-l_mla_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/setr/setr_vit-l_mla_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..4d3fb7d
--- /dev/null
+++ b/mmsegmentation/configs/setr/setr_vit-l_mla_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,6 @@
+_base_ = ['./setr_vit-l-mla_8xb1-160k_ade20k-512x512.py']
+
+# num_gpus: 8 -> batch_size: 16
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/setr/setr_vit-l_naive_8xb1-80k_cityscapes-768x768.py b/mmsegmentation/configs/setr/setr_vit-l_naive_8xb1-80k_cityscapes-768x768.py
new file mode 100644
index 0000000..db49317
--- /dev/null
+++ b/mmsegmentation/configs/setr/setr_vit-l_naive_8xb1-80k_cityscapes-768x768.py
@@ -0,0 +1,24 @@
+_base_ = [
+    '../_base_/models/setr_naive.py',
+    '../_base_/datasets/cityscapes_768x768.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (768, 768)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        drop_rate=0.,
+        init_cfg=dict(
+            type='Pretrained', checkpoint='pretrain/vit_large_p16.pth')),
+    test_cfg=dict(mode='slide', crop_size=(768, 768), stride=(512, 512)))
+
+optimizer = dict(weight_decay=0.0)
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=optimizer,
+    paramwise_cfg=dict(custom_keys={'head': dict(lr_mult=10.)}))
+train_dataloader = dict(batch_size=1)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/setr/setr_vit-l_naive_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/setr/setr_vit-l_naive_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..109996c
--- /dev/null
+++ b/mmsegmentation/configs/setr/setr_vit-l_naive_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,72 @@
+_base_ = [
+    '../_base_/models/setr_naive.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        img_size=(512, 512),
+        drop_rate=0.,
+        init_cfg=dict(
+            type='Pretrained', checkpoint='pretrain/vit_large_p16.pth')),
+    decode_head=dict(num_classes=150),
+    auxiliary_head=[
+        dict(
+            type='SETRUPHead',
+            in_channels=1024,
+            channels=256,
+            in_index=0,
+            num_classes=150,
+            dropout_ratio=0,
+            norm_cfg=norm_cfg,
+            act_cfg=dict(type='ReLU'),
+            num_convs=2,
+            kernel_size=1,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='SETRUPHead',
+            in_channels=1024,
+            channels=256,
+            in_index=1,
+            num_classes=150,
+            dropout_ratio=0,
+            norm_cfg=norm_cfg,
+            act_cfg=dict(type='ReLU'),
+            num_convs=2,
+            kernel_size=1,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='SETRUPHead',
+            in_channels=1024,
+            channels=256,
+            in_index=2,
+            num_classes=150,
+            dropout_ratio=0,
+            norm_cfg=norm_cfg,
+            act_cfg=dict(type='ReLU'),
+            num_convs=2,
+            kernel_size=1,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4))
+    ],
+    test_cfg=dict(mode='slide', crop_size=(512, 512), stride=(341, 341)),
+)
+
+optimizer = dict(lr=0.01, weight_decay=0.0)
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=optimizer,
+    paramwise_cfg=dict(custom_keys={'head': dict(lr_mult=10.)}))
+# num_gpus: 8 -> batch_size: 16
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/setr/setr_vit-l_pup_8xb1-80k_cityscapes-768x768.py b/mmsegmentation/configs/setr/setr_vit-l_pup_8xb1-80k_cityscapes-768x768.py
new file mode 100644
index 0000000..999ab18
--- /dev/null
+++ b/mmsegmentation/configs/setr/setr_vit-l_pup_8xb1-80k_cityscapes-768x768.py
@@ -0,0 +1,70 @@
+_base_ = [
+    '../_base_/models/setr_pup.py', '../_base_/datasets/cityscapes_768x768.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (768, 768)
+data_preprocessor = dict(size=crop_size)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+crop_size = (768, 768)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        drop_rate=0.,
+        init_cfg=dict(
+            type='Pretrained', checkpoint='pretrain/vit_large_p16.pth')),
+    auxiliary_head=[
+        dict(
+            type='SETRUPHead',
+            in_channels=1024,
+            channels=256,
+            in_index=0,
+            num_classes=19,
+            dropout_ratio=0,
+            norm_cfg=norm_cfg,
+            num_convs=2,
+            up_scale=4,
+            kernel_size=3,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='SETRUPHead',
+            in_channels=1024,
+            channels=256,
+            in_index=1,
+            num_classes=19,
+            dropout_ratio=0,
+            norm_cfg=norm_cfg,
+            num_convs=2,
+            up_scale=4,
+            kernel_size=3,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='SETRUPHead',
+            in_channels=1024,
+            channels=256,
+            in_index=2,
+            num_classes=19,
+            dropout_ratio=0,
+            norm_cfg=norm_cfg,
+            num_convs=2,
+            up_scale=4,
+            kernel_size=3,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4))
+    ],
+    test_cfg=dict(mode='slide', crop_size=crop_size, stride=(512, 512)))
+
+optimizer = dict(weight_decay=0.0)
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=optimizer,
+    paramwise_cfg=dict(custom_keys={'head': dict(lr_mult=10.)}))
+
+train_dataloader = dict(batch_size=1)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/setr/setr_vit-l_pup_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/setr/setr_vit-l_pup_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..e9bfb22
--- /dev/null
+++ b/mmsegmentation/configs/setr/setr_vit-l_pup_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,72 @@
+_base_ = [
+    '../_base_/models/setr_pup.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        img_size=(512, 512),
+        drop_rate=0.,
+        init_cfg=dict(
+            type='Pretrained', checkpoint='pretrain/vit_large_p16.pth')),
+    decode_head=dict(num_classes=150),
+    auxiliary_head=[
+        dict(
+            type='SETRUPHead',
+            in_channels=1024,
+            channels=256,
+            in_index=0,
+            num_classes=150,
+            dropout_ratio=0,
+            norm_cfg=norm_cfg,
+            act_cfg=dict(type='ReLU'),
+            num_convs=2,
+            kernel_size=3,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='SETRUPHead',
+            in_channels=1024,
+            channels=256,
+            in_index=1,
+            num_classes=150,
+            dropout_ratio=0,
+            norm_cfg=norm_cfg,
+            act_cfg=dict(type='ReLU'),
+            num_convs=2,
+            kernel_size=3,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+        dict(
+            type='SETRUPHead',
+            in_channels=1024,
+            channels=256,
+            in_index=2,
+            num_classes=150,
+            dropout_ratio=0,
+            norm_cfg=norm_cfg,
+            act_cfg=dict(type='ReLU'),
+            num_convs=2,
+            kernel_size=3,
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    ],
+    test_cfg=dict(mode='slide', crop_size=(512, 512), stride=(341, 341)),
+)
+
+optimizer = dict(lr=0.001, weight_decay=0.0)
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=optimizer,
+    paramwise_cfg=dict(custom_keys={'head': dict(lr_mult=10.)}))
+# num_gpus: 8 -> batch_size: 16
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/stdc/README.md b/mmsegmentation/configs/stdc/README.md
new file mode 100644
index 0000000..3e8bf60
--- /dev/null
+++ b/mmsegmentation/configs/stdc/README.md
@@ -0,0 +1,73 @@
+# STDC
+
+> [Rethinking BiSeNet For Real-time Semantic Segmentation](https://arxiv.org/abs/2104.13188)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/MichaelFan01/STDC-Seg">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/stdc.py#L394">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+BiSeNet has been proved to be a popular two-stream network for real-time segmentation. However, its principle of adding an extra path to encode spatial information is time-consuming, and the backbones borrowed from pretrained tasks, e.g., image classification, may be inefficient for image segmentation due to the deficiency of task-specific design. To handle these problems, we propose a novel and efficient structure named Short-Term Dense Concatenate network (STDC network) by removing structure redundancy. Specifically, we gradually reduce the dimension of feature maps and use the aggregation of them for image representation, which forms the basic module of STDC network. In the decoder, we propose a Detail Aggregation module by integrating the learning of spatial information into low-level layers in single-stream manner. Finally, the low-level features and deep features are fused to predict the final segmentation results. Extensive experiments on Cityscapes and CamVid dataset demonstrate the effectiveness of our method by achieving promising trade-off between segmentation accuracy and inference speed. On Cityscapes, we achieve 71.9% mIoU on the test set with a speed of 250.4 FPS on NVIDIA GTX 1080Ti, which is 45.2% faster than the latest methods, and achieve 76.8% mIoU with 97.0 FPS while inferring on higher resolution images.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/143640374-d0709587-edb2-4821-bb60-340035f6ad8f.png" width="60%"/>
+</div>
+
+## Usage
+
+We have provided [ImageNet Pretrained STDCNet Weights](https://drive.google.com/drive/folders/1wROFwRt8qWHD4jSo8Zu1gp1d6oYJ3ns1) models converted from [official repo](https://github.com/MichaelFan01/STDC-Seg).
+
+If you want to convert keys on your own to use official repositories' pre-trained models, we also provide a script [`stdc2mmseg.py`](../../tools/model_converters/stdc2mmseg.py) in the tools directory to convert the key of models from [the official repo](https://github.com/MichaelFan01/STDC-Seg) to MMSegmentation style.
+
+```shell
+python tools/model_converters/stdc2mmseg.py ${PRETRAIN_PATH} ${STORE_PATH} ${STDC_TYPE}
+```
+
+E.g.
+
+```shell
+python tools/model_converters/stdc2mmseg.py ./STDCNet813M_73.91.tar ./pretrained/stdc1.pth STDC1
+
+python tools/model_converters/stdc2mmseg.py ./STDCNet1446_76.47.tar ./pretrained/stdc2.pth STDC2
+```
+
+This script convert model from `PRETRAIN_PATH` and store the converted model in `STORE_PATH`.
+
+## Results and models
+
+### Cityscapes
+
+| Method | Backbone             | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                        | download                                                                                                                                                                                                                                                                                                                                             |
+| ------ | -------------------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------- | ----------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| STDC   | STDC1 (No Pretrain)  | 512x1024  |   80000 | 7.15     | 23.06          | V100   | 71.82 | 73.89         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/stdc/stdc1_4xb12-80k_cityscapes-512x1024.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc1_512x1024_80k_cityscapes/stdc1_512x1024_80k_cityscapes_20220224_073048-74e6920a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc1_512x1024_80k_cityscapes/stdc1_512x1024_80k_cityscapes_20220224_073048.log.json)                                     |
+| STDC   | STDC1                | 512x1024  |   80000 | -        | -              | V100   | 74.94 | 76.97         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/stdc/stdc1_in1k-pre_4xb12-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc1_in1k-pre_512x1024_80k_cityscapes/stdc1_in1k-pre_512x1024_80k_cityscapes_20220224_141648-3d4c2981.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc1_in1k-pre_512x1024_80k_cityscapes/stdc1_in1k-pre_512x1024_80k_cityscapes_20220224_141648.log.json) |
+| STDC   | STDC2  (No Pretrain) | 512x1024  |   80000 | 8.27     | 23.71          | V100   | 73.15 | 76.13         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/stdc/stdc2_4xb12-80k_cityscapes-512x1024.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc2_512x1024_80k_cityscapes/stdc2_512x1024_80k_cityscapes_20220222_132015-fb1e3a1a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc2_512x1024_80k_cityscapes/stdc2_512x1024_80k_cityscapes_20220222_132015.log.json)                                     |
+| STDC   | STDC2                | 512x1024  |   80000 | -        | -              | V100   | 76.67 | 78.67         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/stdc/stdc2_in1k-pre_4xb12-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc2_in1k-pre_512x1024_80k_cityscapes/stdc2_in1k-pre_512x1024_80k_cityscapes_20220224_073048-1f8f0f6c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc2_in1k-pre_512x1024_80k_cityscapes/stdc2_in1k-pre_512x1024_80k_cityscapes_20220224_073048.log.json) |
+
+Note:
+
+- For STDC on Cityscapes dataset, default setting is 4 GPUs with 12 samples per GPU in training.
+- `No Pretrain` means the model is trained from scratch.
+- The FPS is for reference only. The environment is also different from paper setting, whose input size is `512x1024` and `768x1536`, i.e., 50% and 75% of our input size, respectively and using TensorRT.
+- The parameter `fusion_kernel` in `STDCHead` is not learnable. In official repo, `find_unused_parameters=True` is set [here](https://github.com/MichaelFan01/STDC-Seg/blob/59ff37fbd693b99972c76fcefe97caa14aeb619f/train.py#L220). You may check it by printing model parameters of original repo on your own.
+
+## Citation
+
+```bibtex
+@inproceedings{fan2021rethinking,
+  title={Rethinking BiSeNet For Real-time Semantic Segmentation},
+  author={Fan, Mingyuan and Lai, Shenqi and Huang, Junshi and Wei, Xiaoming and Chai, Zhenhua and Luo, Junfeng and Wei, Xiaolin},
+  booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
+  pages={9716--9725},
+  year={2021}
+}
+```
diff --git a/mmsegmentation/configs/stdc/metafile.yaml b/mmsegmentation/configs/stdc/metafile.yaml
new file mode 100644
index 0000000..93cb14f
--- /dev/null
+++ b/mmsegmentation/configs/stdc/metafile.yaml
@@ -0,0 +1,107 @@
+Collections:
+- Name: STDC
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+  Paper:
+    Title: Rethinking BiSeNet For Real-time Semantic Segmentation
+    URL: https://arxiv.org/abs/2104.13188
+  README: configs/stdc/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: stdc1_4xb12-80k_cityscapes-512x1024
+  In Collection: STDC
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 71.82
+      mIoU(ms+flip): 73.89
+  Config: configs/stdc/stdc1_4xb12-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 48
+    Architecture:
+    - STDC1
+    - STDC
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 7.15
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc1_512x1024_80k_cityscapes/stdc1_512x1024_80k_cityscapes_20220224_073048-74e6920a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc1_512x1024_80k_cityscapes/stdc1_512x1024_80k_cityscapes_20220224_073048.log.json
+  Paper:
+    Title: Rethinking BiSeNet For Real-time Semantic Segmentation
+    URL: https://arxiv.org/abs/2104.13188
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/stdc.py#L394
+  Framework: PyTorch
+- Name: stdc1_in1k-pre_4xb12-80k_cityscapes-512x1024
+  In Collection: STDC
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 74.94
+      mIoU(ms+flip): 76.97
+  Config: configs/stdc/stdc1_in1k-pre_4xb12-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 48
+    Architecture:
+    - STDC1
+    - STDC
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc1_in1k-pre_512x1024_80k_cityscapes/stdc1_in1k-pre_512x1024_80k_cityscapes_20220224_141648-3d4c2981.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc1_in1k-pre_512x1024_80k_cityscapes/stdc1_in1k-pre_512x1024_80k_cityscapes_20220224_141648.log.json
+  Paper:
+    Title: Rethinking BiSeNet For Real-time Semantic Segmentation
+    URL: https://arxiv.org/abs/2104.13188
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/stdc.py#L394
+  Framework: PyTorch
+- Name: stdc2_4xb12-80k_cityscapes-512x1024
+  In Collection: STDC
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 73.15
+      mIoU(ms+flip): 76.13
+  Config: configs/stdc/stdc2_4xb12-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 48
+    Architecture:
+    - STDC2
+    - STDC
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.27
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc2_512x1024_80k_cityscapes/stdc2_512x1024_80k_cityscapes_20220222_132015-fb1e3a1a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc2_512x1024_80k_cityscapes/stdc2_512x1024_80k_cityscapes_20220222_132015.log.json
+  Paper:
+    Title: Rethinking BiSeNet For Real-time Semantic Segmentation
+    URL: https://arxiv.org/abs/2104.13188
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/stdc.py#L394
+  Framework: PyTorch
+- Name: stdc2_in1k-pre_4xb12-80k_cityscapes-512x1024
+  In Collection: STDC
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 76.67
+      mIoU(ms+flip): 78.67
+  Config: configs/stdc/stdc2_in1k-pre_4xb12-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 48
+    Architecture:
+    - STDC2
+    - STDC
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc2_in1k-pre_512x1024_80k_cityscapes/stdc2_in1k-pre_512x1024_80k_cityscapes_20220224_073048-1f8f0f6c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc2_in1k-pre_512x1024_80k_cityscapes/stdc2_in1k-pre_512x1024_80k_cityscapes_20220224_073048.log.json
+  Paper:
+    Title: Rethinking BiSeNet For Real-time Semantic Segmentation
+    URL: https://arxiv.org/abs/2104.13188
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/stdc.py#L394
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/stdc/stdc1_4xb12-80k_cityscapes-512x1024.py b/mmsegmentation/configs/stdc/stdc1_4xb12-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..20aec3d
--- /dev/null
+++ b/mmsegmentation/configs/stdc/stdc1_4xb12-80k_cityscapes-512x1024.py
@@ -0,0 +1,21 @@
+_base_ = [
+    '../_base_/models/stdc.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
+param_scheduler = [
+    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=1000,
+        end=80000,
+        by_epoch=False,
+    )
+]
+train_dataloader = dict(batch_size=12, num_workers=4)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/stdc/stdc1_in1k-pre_4xb12-80k_cityscapes-512x1024.py b/mmsegmentation/configs/stdc/stdc1_in1k-pre_4xb12-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..15e807f
--- /dev/null
+++ b/mmsegmentation/configs/stdc/stdc1_in1k-pre_4xb12-80k_cityscapes-512x1024.py
@@ -0,0 +1,6 @@
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/stdc/stdc1_20220308-5368626c.pth'  # noqa
+_base_ = './stdc1_4xb12-80k_cityscapes-512x1024.py'
+model = dict(
+    backbone=dict(
+        backbone_cfg=dict(
+            init_cfg=dict(type='Pretrained', checkpoint=checkpoint))))
diff --git a/mmsegmentation/configs/stdc/stdc2_4xb12-80k_cityscapes-512x1024.py b/mmsegmentation/configs/stdc/stdc2_4xb12-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..5657351
--- /dev/null
+++ b/mmsegmentation/configs/stdc/stdc2_4xb12-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './stdc1_4xb12-80k_cityscapes-512x1024.py'
+model = dict(backbone=dict(backbone_cfg=dict(stdc_type='STDCNet2')))
diff --git a/mmsegmentation/configs/stdc/stdc2_in1k-pre_4xb12-80k_cityscapes-512x1024.py b/mmsegmentation/configs/stdc/stdc2_in1k-pre_4xb12-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..05a202b
--- /dev/null
+++ b/mmsegmentation/configs/stdc/stdc2_in1k-pre_4xb12-80k_cityscapes-512x1024.py
@@ -0,0 +1,6 @@
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/stdc/stdc2_20220308-7dbd9127.pth'  # noqa
+_base_ = './stdc2_4xb12-80k_cityscapes-512x1024.py'
+model = dict(
+    backbone=dict(
+        backbone_cfg=dict(
+            init_cfg=dict(type='Pretrained', checkpoint=checkpoint))))
diff --git a/mmsegmentation/configs/swin/README.md b/mmsegmentation/configs/swin/README.md
new file mode 100644
index 0000000..64f0d5f
--- /dev/null
+++ b/mmsegmentation/configs/swin/README.md
@@ -0,0 +1,76 @@
+# Swin Transformer
+
+> [Swin Transformer: Hierarchical Vision Transformer using Shifted Windows](https://arxiv.org/abs/2103.14030)
+
+## Introduction
+
+<!-- [BACKBONE] -->
+
+<a href="https://github.com/microsoft/Swin-Transformer">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/swin.py#L524">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+This paper presents a new vision Transformer, called Swin Transformer, that capably serves as a general-purpose backbone for computer vision. Challenges in adapting Transformer from language to vision arise from differences between the two domains, such as large variations in the scale of visual entities and the high resolution of pixels in images compared to words in text. To address these differences, we propose a hierarchical Transformer whose representation is computed with Shifted windows. The shifted windowing scheme brings greater efficiency by limiting self-attention computation to non-overlapping local windows while also allowing for cross-window connection. This hierarchical architecture has the flexibility to model at various scales and has linear computational complexity with respect to image size. These qualities of Swin Transformer make it compatible with a broad range of vision tasks, including image classification (87.3 top-1 accuracy on ImageNet-1K) and dense prediction tasks such as object detection (58.7 box AP and 51.1 mask AP on COCO test-dev) and semantic segmentation (53.5 mIoU on ADE20K val). Its performance surpasses the previous state-of-the-art by a large margin of +2.7 box AP and +2.6 mask AP on COCO, and +3.2 mIoU on ADE20K, demonstrating the potential of Transformer-based models as vision backbones. The hierarchical design and the shifted window approach also prove beneficial for all-MLP architectures. The code and models are publicly available at [this https URL](https://github.com/microsoft/Swin-Transformer).
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142902882-3fb9014c-11b6-47e9-aa14-500dfe7cbb1c.png" width="80%"/>
+</div>
+
+## Usage
+
+We have provided pretrained models converted from [official repo](https://github.com/microsoft/Swin-Transformer)．
+
+If you want to convert keys on your own to use official repositories' pre-trained models, we also provide a script [`swin2mmseg.py`](../../tools/model_converters/swin2mmseg.py) in the tools directory to convert the key of models from [the official repo](https://github.com/SwinTransformer/Swin-Transformer-Semantic-Segmentation) to MMSegmentation style.
+
+```shell
+python tools/model_converters/swin2mmseg.py ${PRETRAIN_PATH} ${STORE_PATH}
+```
+
+E.g.
+
+```shell
+python tools/model_converters/swin2mmseg.py https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_base_patch4_window7_224.pth pretrain/swin_base_patch4_window7_224.pth
+```
+
+This script convert model from `PRETRAIN_PATH` and store the converted model in `STORE_PATH`.
+
+In our default setting, pretrained models and their corresponding [original models](https://github.com/microsoft/Swin-Transforme) models could be defined below:
+
+| pretrained models                              | original models                                                                                                                                    |
+| ---------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
+| pretrain/swin_tiny_patch4_window7_224.pth      | [swin_tiny_patch4_window7_224.pth](https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_tiny_patch4_window7_224.pth)           |
+| pretrain/swin_small_patch4_window7_224.pth     | [swin_small_patch4_window7_224.pth](https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_small_patch4_window7_224.pth)         |
+| pretrain/swin_base_patch4_window7_224.pth      | [swin_base_patch4_window7_224.pth](https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_base_patch4_window7_224.pth)           |
+| pretrain/swin_base_patch4_window7_224_22k.pth  | [swin_base_patch4_window7_224_22k.pth](https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_base_patch4_window7_224_22k.pth)   |
+| pretrain/swin_base_patch4_window12_384.pth     | [swin_base_patch4_window12_384.pth](https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_base_patch4_window12_384.pth)         |
+| pretrain/swin_base_patch4_window12_384_22k.pth | [swin_base_patch4_window12_384_22k.pth](https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_base_patch4_window12_384_22k.pth) |
+
+## Results and models
+
+### ADE20K
+
+| Method  | Backbone | Crop Size | pretrain     | pretrain img size | Batch Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                                                        | download                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| ------- | -------- | --------- | ------------ | ----------------- | ---------- | ------- | -------- | -------------- | ------ | ----- | ------------: | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UPerNet | Swin-T   | 512x512   | ImageNet-1K  | 224x224           | 16         | 160000  | 5.02     | 21.06          | V100   | 44.41 |         45.79 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/swin/swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210531_112542-e380ad3e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210531_112542.log.json)         |
+| UPerNet | Swin-S   | 512x512   | ImageNet-1K  | 224x224           | 16         | 160000  | 6.17     | 14.72          | V100   | 47.72 |         49.24 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/swin/swin-small-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192015-ee2fff1c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192015.log.json)     |
+| UPerNet | Swin-B   | 512x512   | ImageNet-1K  | 224x224           | 16         | 160000  | 7.61     | 12.65          | V100   | 47.99 |         49.57 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/swin/swin-base-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192340-593b0e13.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192340.log.json)         |
+| UPerNet | Swin-B   | 512x512   | ImageNet-22K | 224x224           | 16         | 160000  | -        | -              | V100   | 50.13 |          51.9 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/swin/swin-base-patch4-window7-in22k-pre_upernet_8xb2-160k_ade20k-512x512.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_22K/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_22K_20210526_211650-762e2178.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_22K/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_22K_20210526_211650.log.json)     |
+| UPerNet | Swin-B   | 512x512   | ImageNet-1K  | 384x384           | 16         | 160000  | 8.52     | 12.10          | V100   | 48.35 |         49.65 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/swin/swin-base-patch4-window12-in1k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_1K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_1K_20210531_132020-05b22ea4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_1K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_1K_20210531_132020.log.json)     |
+| UPerNet | Swin-B   | 512x512   | ImageNet-22K | 384x384           | 16         | 160000  | -        | -              | V100   | 50.76 |          52.4 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/swin/swin-base-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K_20210531_125459-429057bf.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K_20210531_125459.log.json) |
+
+## Citation
+
+```bibtex
+@article{liu2021Swin,
+  title={Swin Transformer: Hierarchical Vision Transformer using Shifted Windows},
+  author={Liu, Ze and Lin, Yutong and Cao, Yue and Hu, Han and Wei, Yixuan and Zhang, Zheng and Lin, Stephen and Guo, Baining},
+  journal={arXiv preprint arXiv:2103.14030},
+  year={2021}
+}
+```
diff --git a/mmsegmentation/configs/swin/metafile.yaml b/mmsegmentation/configs/swin/metafile.yaml
new file mode 100644
index 0000000..67a4e07
--- /dev/null
+++ b/mmsegmentation/configs/swin/metafile.yaml
@@ -0,0 +1,143 @@
+Models:
+- Name: swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 44.41
+      mIoU(ms+flip): 45.79
+  Config: configs/swin/swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - Swin-T
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 5.02
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210531_112542-e380ad3e.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210531_112542.log.json
+  Paper:
+    Title: 'Swin Transformer: Hierarchical Vision Transformer using Shifted Windows'
+    URL: https://arxiv.org/abs/2103.14030
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/swin.py#L524
+  Framework: PyTorch
+- Name: swin-small-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 47.72
+      mIoU(ms+flip): 49.24
+  Config: configs/swin/swin-small-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - Swin-S
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 6.17
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192015-ee2fff1c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192015.log.json
+  Paper:
+    Title: 'Swin Transformer: Hierarchical Vision Transformer using Shifted Windows'
+    URL: https://arxiv.org/abs/2103.14030
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/swin.py#L524
+  Framework: PyTorch
+- Name: swin-base-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 47.99
+      mIoU(ms+flip): 49.57
+  Config: configs/swin/swin-base-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - Swin-B
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 7.61
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192340-593b0e13.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192340.log.json
+  Paper:
+    Title: 'Swin Transformer: Hierarchical Vision Transformer using Shifted Windows'
+    URL: https://arxiv.org/abs/2103.14030
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/swin.py#L524
+  Framework: PyTorch
+- Name: swin-base-patch4-window7-in22k-pre_upernet_8xb2-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 50.13
+      mIoU(ms+flip): 51.9
+  Config: configs/swin/swin-base-patch4-window7-in22k-pre_upernet_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - Swin-B
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_22K/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_22K_20210526_211650-762e2178.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_22K/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_22K_20210526_211650.log.json
+  Paper:
+    Title: 'Swin Transformer: Hierarchical Vision Transformer using Shifted Windows'
+    URL: https://arxiv.org/abs/2103.14030
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/swin.py#L524
+  Framework: PyTorch
+- Name: swin-base-patch4-window12-in1k-384x384-pre_upernet_8xb2-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 48.35
+      mIoU(ms+flip): 49.65
+  Config: configs/swin/swin-base-patch4-window12-in1k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - Swin-B
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 8.52
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_1K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_1K_20210531_132020-05b22ea4.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_1K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_1K_20210531_132020.log.json
+  Paper:
+    Title: 'Swin Transformer: Hierarchical Vision Transformer using Shifted Windows'
+    URL: https://arxiv.org/abs/2103.14030
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/swin.py#L524
+  Framework: PyTorch
+- Name: swin-base-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 50.76
+      mIoU(ms+flip): 52.4
+  Config: configs/swin/swin-base-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - Swin-B
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K_20210531_125459-429057bf.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K_20210531_125459.log.json
+  Paper:
+    Title: 'Swin Transformer: Hierarchical Vision Transformer using Shifted Windows'
+    URL: https://arxiv.org/abs/2103.14030
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/swin.py#L524
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/swin/swin-base-patch4-window12-in1k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/swin/swin-base-patch4-window12-in1k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..11cea36
--- /dev/null
+++ b/mmsegmentation/configs/swin/swin-base-patch4-window12-in1k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,14 @@
+_base_ = [
+    'swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py'
+]
+checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_base_patch4_window12_384_20220317-55b0104a.pth'  # noqa
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file),
+        pretrain_img_size=384,
+        embed_dims=128,
+        depths=[2, 2, 18, 2],
+        num_heads=[4, 8, 16, 32],
+        window_size=12),
+    decode_head=dict(in_channels=[128, 256, 512, 1024], num_classes=150),
+    auxiliary_head=dict(in_channels=512, num_classes=150))
diff --git a/mmsegmentation/configs/swin/swin-base-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/swin/swin-base-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..5c11716
--- /dev/null
+++ b/mmsegmentation/configs/swin/swin-base-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,7 @@
+_base_ = [
+    './swin-base-patch4-window12-in1k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py'  # noqa
+]
+checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_base_patch4_window12_384_22k_20220317-e5c09f74.pth'  # noqa
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file)))
diff --git a/mmsegmentation/configs/swin/swin-base-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/swin/swin-base-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..73bf616
--- /dev/null
+++ b/mmsegmentation/configs/swin/swin-base-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,12 @@
+_base_ = [
+    './swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py'
+]
+checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_base_patch4_window7_224_20220317-e9b98025.pth'  # noqa
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file),
+        embed_dims=128,
+        depths=[2, 2, 18, 2],
+        num_heads=[4, 8, 16, 32]),
+    decode_head=dict(in_channels=[128, 256, 512, 1024], num_classes=150),
+    auxiliary_head=dict(in_channels=512, num_classes=150))
diff --git a/mmsegmentation/configs/swin/swin-base-patch4-window7-in22k-pre_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/swin/swin-base-patch4-window7-in22k-pre_upernet_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..96148cd
--- /dev/null
+++ b/mmsegmentation/configs/swin/swin-base-patch4-window7-in22k-pre_upernet_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,7 @@
+_base_ = [
+    './swin-base-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py'
+]
+checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_base_patch4_window7_224_22k_20220317-4f79f7c0.pth'  # noqa
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file)))
diff --git a/mmsegmentation/configs/swin/swin-large-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/swin/swin-large-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..a0a654e
--- /dev/null
+++ b/mmsegmentation/configs/swin/swin-large-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    'swin-large-patch4-window7-in22k-pre_upernet_'
+    '8xb2-160k_ade20k-512x512.py'
+]
+checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_large_patch4_window12_384_22k_20220412-6580f57d.pth'  # noqa
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file),
+        pretrain_img_size=384,
+        window_size=12))
diff --git a/mmsegmentation/configs/swin/swin-large-patch4-window7-in22k-pre_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/swin/swin-large-patch4-window7-in22k-pre_upernet_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..c93cdfe
--- /dev/null
+++ b/mmsegmentation/configs/swin/swin-large-patch4-window7-in22k-pre_upernet_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,15 @@
+_base_ = [
+    'swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_'
+    'ade20k-512x512.py'
+]
+checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_large_patch4_window7_224_22k_20220412-aeecf2aa.pth'  # noqa
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file),
+        pretrain_img_size=224,
+        embed_dims=192,
+        depths=[2, 2, 18, 2],
+        num_heads=[6, 12, 24, 48],
+        window_size=7),
+    decode_head=dict(in_channels=[192, 384, 768, 1536], num_classes=150),
+    auxiliary_head=dict(in_channels=768, num_classes=150))
diff --git a/mmsegmentation/configs/swin/swin-small-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/swin/swin-small-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..19863df
--- /dev/null
+++ b/mmsegmentation/configs/swin/swin-small-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    './swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py'
+]
+checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_small_patch4_window7_224_20220317-7ba6d6dd.pth'  # noqa
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file),
+        depths=[2, 2, 18, 2]),
+    decode_head=dict(in_channels=[96, 192, 384, 768], num_classes=150),
+    auxiliary_head=dict(in_channels=384, num_classes=150))
diff --git a/mmsegmentation/configs/swin/swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/swin/swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..f61a276
--- /dev/null
+++ b/mmsegmentation/configs/swin/swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,52 @@
+_base_ = [
+    '../_base_/models/upernet_swin.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_tiny_patch4_window7_224_20220317-1cdeb081.pth'  # noqa
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file),
+        embed_dims=96,
+        depths=[2, 2, 6, 2],
+        num_heads=[3, 6, 12, 24],
+        window_size=7,
+        use_abs_pos_embed=False,
+        drop_path_rate=0.3,
+        patch_norm=True),
+    decode_head=dict(in_channels=[96, 192, 384, 768], num_classes=150),
+    auxiliary_head=dict(in_channels=384, num_classes=150))
+
+# AdamW optimizer, no weight decay for position embedding & layer norm
+# in backbone
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
+    paramwise_cfg=dict(
+        custom_keys={
+            'absolute_pos_embed': dict(decay_mult=0.),
+            'relative_position_bias_table': dict(decay_mult=0.),
+            'norm': dict(decay_mult=0.)
+        }))
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        eta_min=0.0,
+        power=1.0,
+        begin=1500,
+        end=160000,
+        by_epoch=False,
+    )
+]
+
+# By default, models are trained on 8 GPUs with 2 images per GPU
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/swin/swin-tiny-patch4-window7_upernet_1xb8-20k_levir-256x256.py b/mmsegmentation/configs/swin/swin-tiny-patch4-window7_upernet_1xb8-20k_levir-256x256.py
new file mode 100644
index 0000000..7b90686
--- /dev/null
+++ b/mmsegmentation/configs/swin/swin-tiny-patch4-window7_upernet_1xb8-20k_levir-256x256.py
@@ -0,0 +1,57 @@
+_base_ = [
+    '../_base_/models/upernet_swin.py', '../_base_/datasets/levir_256x256.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_20k.py'
+]
+crop_size = (256, 256)
+norm_cfg = dict(type='BN', requires_grad=True)
+data_preprocessor = dict(
+    size=crop_size,
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53, 123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375, 58.395, 57.12, 57.375],
+    bgr_to_rgb=False)
+
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        in_channels=6,
+        embed_dims=96,
+        depths=[2, 2, 6, 2],
+        num_heads=[3, 6, 12, 24],
+        window_size=7,
+        use_abs_pos_embed=False,
+        drop_path_rate=0.3,
+        patch_norm=True),
+    decode_head=dict(in_channels=[96, 192, 384, 768], num_classes=2),
+    auxiliary_head=dict(in_channels=384, num_classes=2))
+
+# AdamW optimizer, no weight decay for position embedding & layer norm
+# in backbone
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
+    paramwise_cfg=dict(
+        custom_keys={
+            'absolute_pos_embed': dict(decay_mult=0.),
+            'relative_position_bias_table': dict(decay_mult=0.),
+            'norm': dict(decay_mult=0.)
+        }))
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        eta_min=0.0,
+        power=1.0,
+        begin=1500,
+        end=20000,
+        by_epoch=False,
+    )
+]
+
+train_dataloader = dict(batch_size=4)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/twins/README.md b/mmsegmentation/configs/twins/README.md
new file mode 100644
index 0000000..e4b3735
--- /dev/null
+++ b/mmsegmentation/configs/twins/README.md
@@ -0,0 +1,76 @@
+# Twins
+
+> [Twins: Revisiting the Design of Spatial Attention in Vision Transformers](https://arxiv.org/pdf/2104.13840.pdf)
+
+## Introduction
+
+<!-- [BACKBONE] -->
+
+<a href = "https://github.com/Meituan-AutoML/Twins">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Very recently, a variety of vision transformer architectures for dense prediction tasks have been proposed and they show that the design of spatial attention is critical to their success in these tasks. In this work, we revisit the design of the spatial attention and demonstrate that a carefully-devised yet simple spatial attention mechanism performs favourably against the state-of-the-art schemes. As a result, we propose two vision transformer architectures, namely, Twins-PCPVT and Twins-SVT. Our proposed architectures are highly-efficient and easy to implement, only involving matrix multiplications that are highly optimized in modern deep learning frameworks. More importantly, the proposed architectures achieve excellent performance on a wide range of visual tasks, including image level classification as well as dense detection and segmentation. The simplicity and strong performance suggest that our proposed architectures may serve as stronger backbones for many vision tasks. Our code is released at [this https URL](https://github.com/Meituan-AutoML/Twins).
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/145021310-57826cf5-5e03-4c7c-9081-ffa744bdae27.png" width="80%"/>
+</div>
+
+## Usage
+
+We have provided pretrained models converted from [official repo](https://github.com/Meituan-AutoML/Twins).
+
+If you want to convert keys on your own to use official repositories' pre-trained models, we also provide a script [`twins2mmseg.py`](../../tools/model_converters/twins2mmseg.py) in the tools directory to convert the key of models from [the official repo](https://github.com/Meituan-AutoML/Twins) to MMSegmentation style.
+
+```shell
+python tools/model_converters/twins2mmseg.py ${PRETRAIN_PATH} ${STORE_PATH} ${MODEL_TYPE}
+```
+
+This script convert `pcpvt` or `svt` pretrained model from `PRETRAIN_PATH` and store the converted model in `STORE_PATH`.
+
+For example,
+
+```shell
+python tools/model_converters/twins2mmseg.py ./alt_gvt_base.pth ./pretrained/alt_gvt_base.pth svt
+```
+
+## Results and models
+
+### ADE20K
+
+| Method  | Backbone            | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                              | download                                                                                                                                                                                                                                                                                                                                                                                       |
+| ------- | ------------------- | --------- | ------- | -------- | -------------- | ------ | ----- | ------------- | ----------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FPN     | Twins-PCPVT-S       | 512x512   | 80000   | 6.60     | 27.15          | V100   | 43.26 | 44.11         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_pcpvt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-s_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-s_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_204132-41acd132.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-s_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-s_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_204132.log.json) |
+| UPerNet | Twins-PCPVT-S       | 512x512   | 160000  | 9.67     | 14.24          | V100   | 46.04 | 46.92         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_pcpvt-s_uperhead_8xb4-160k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-s_uperhead_8x4_512x512_160k_ade20k/twins_pcpvt-s_uperhead_8x4_512x512_160k_ade20k_20211201_233537-8e99c07a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-s_uperhead_8x4_512x512_160k_ade20k/twins_pcpvt-s_uperhead_8x4_512x512_160k_ade20k_20211201_233537.log.json)         |
+| FPN     | Twins-PCPVT-B       | 512x512   | 80000   | 8.41     | 19.67          | V100   | 45.66 | 46.48         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_pcpvt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-b_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-b_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141019-d396db72.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-b_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-b_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141019.log.json) |
+| UPerNet | Twins-PCPVT-B (8x2) | 512x512   | 160000  | 6.46     | 12.04          | V100   | 47.91 | 48.64         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_pcpvt-b_uperhead_8xb2-160k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-b_uperhead_8x2_512x512_160k_ade20k/twins_pcpvt-b_uperhead_8x2_512x512_160k_ade20k_20211130_141020-02094ea5.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-b_uperhead_8x2_512x512_160k_ade20k/twins_pcpvt-b_uperhead_8x2_512x512_160k_ade20k_20211130_141020.log.json)         |
+| FPN     | Twins-PCPVT-L       | 512x512   | 80000   | 10.78    | 14.32          | V100   | 45.94 | 46.70         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_pcpvt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-l_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-l_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_105226-bc6d61dc.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-l_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-l_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_105226.log.json) |
+| UPerNet | Twins-PCPVT-L (8x2) | 512x512   | 160000  | 7.82     | 10.70          | V100   | 49.35 | 50.08         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_pcpvt-l_uperhead_8xb2-160k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-l_uperhead_8x2_512x512_160k_ade20k/twins_pcpvt-l_uperhead_8x2_512x512_160k_ade20k_20211201_075053-c6095c07.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-l_uperhead_8x2_512x512_160k_ade20k/twins_pcpvt-l_uperhead_8x2_512x512_160k_ade20k_20211201_075053.log.json)         |
+| FPN     | Twins-SVT-S         | 512x512   | 80000   | 5.80     | 29.79          | V100   | 44.47 | 45.42         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_svt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-s_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-s_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141006-0a0d3317.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-s_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-s_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141006.log.json)         |
+| UPerNet | SVT-S  (8x2)        | 512x512   | 160000  | 4.93     | 15.09          | V100   | 46.08 | 46.96         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_svt-s_uperhead_8xb2-160k_ade20k-512x512.py)     | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-s_uperhead_8x2_512x512_160k_ade20k/twins_svt-s_uperhead_8x2_512x512_160k_ade20k_20211130_141005-e48a2d94.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-s_uperhead_8x2_512x512_160k_ade20k/twins_svt-s_uperhead_8x2_512x512_160k_ade20k_20211130_141005.log.json)                 |
+| FPN     | Twins-SVT-B         | 512x512   | 80000   | 8.75     | 21.10          | V100   | 46.77 | 47.47         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_svt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-b_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-b_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_113849-88b2907c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-b_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-b_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_113849.log.json)         |
+| UPerNet | Twins-SVT-B  (8x2)  | 512x512   | 160000  | 6.77     | 12.66          | V100   | 48.04 | 48.87         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_svt-b_uperhead_8xb2-160k_ade20k-512x512.py)     | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-b_uperhead_8x2_512x512_160k_ade20k/twins_svt-b_uperhead_8x2_512x512_160k_ade20k_20211202_040826-0943a1f1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-b_uperhead_8x2_512x512_160k_ade20k/twins_svt-b_uperhead_8x2_512x512_160k_ade20k_20211202_040826.log.json)                 |
+| FPN     | Twins-SVT-L         | 512x512   | 80000   | 11.20    | 17.80          | V100   | 46.55 | 47.74         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_svt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-l_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-l_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141005-1d59bee2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-l_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-l_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141005.log.json)         |
+| UPerNet | Twins-SVT-L  (8x2)  | 512x512   | 160000  | 8.41     | 10.73          | V100   | 49.65 | 50.63         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_pcpvt-l_uperhead_8xb2-160k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-l_uperhead_8x2_512x512_160k_ade20k/twins_svt-l_uperhead_8x2_512x512_160k_ade20k_20211130_141005-3e2cae61.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-l_uperhead_8x2_512x512_160k_ade20k/twins_svt-l_uperhead_8x2_512x512_160k_ade20k_20211130_141005.log.json)                 |
+
+Note:
+
+- `8x2` means 8 GPUs with 2 samples per GPU in training. Default setting of Twins on ADE20K is 8 GPUs with 4 samples per GPU in training.
+- `UPerNet` and `FPN` are decoder heads utilized in corresponding Twins model, which is `UPerHead` and `FPNHead`, respectively. Specifically, models in [official repo](https://github.com/Meituan-AutoML/Twins) all use `UPerHead`.
+
+## Citation
+
+```bibtex
+@article{chu2021twins,
+  title={Twins: Revisiting spatial attention design in vision transformers},
+  author={Chu, Xiangxiang and Tian, Zhi and Wang, Yuqing and Zhang, Bo and Ren, Haibing and Wei, Xiaolin and Xia, Huaxia and Shen, Chunhua},
+  journal={arXiv preprint arXiv:2104.13840},
+  year={2021}altgvt
+}
+```
diff --git a/mmsegmentation/configs/twins/metafile.yaml b/mmsegmentation/configs/twins/metafile.yaml
new file mode 100644
index 0000000..0de78d9
--- /dev/null
+++ b/mmsegmentation/configs/twins/metafile.yaml
@@ -0,0 +1,289 @@
+Models:
+- Name: twins_pcpvt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512
+  In Collection: FPN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 43.26
+      mIoU(ms+flip): 44.11
+  Config: configs/twins/twins_pcpvt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 32
+    Architecture:
+    - Twins-PCPVT-S
+    - FPN
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 6.6
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-s_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-s_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_204132-41acd132.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-s_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-s_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_204132.log.json
+  Paper:
+    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
+    URL: https://arxiv.org/pdf/2104.13840.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
+  Framework: PyTorch
+- Name: twins_pcpvt-s_uperhead_8xb4-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 46.04
+      mIoU(ms+flip): 46.92
+  Config: configs/twins/twins_pcpvt-s_uperhead_8xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 32
+    Architecture:
+    - Twins-PCPVT-S
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 9.67
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-s_uperhead_8x4_512x512_160k_ade20k/twins_pcpvt-s_uperhead_8x4_512x512_160k_ade20k_20211201_233537-8e99c07a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-s_uperhead_8x4_512x512_160k_ade20k/twins_pcpvt-s_uperhead_8x4_512x512_160k_ade20k_20211201_233537.log.json
+  Paper:
+    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
+    URL: https://arxiv.org/pdf/2104.13840.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
+  Framework: PyTorch
+- Name: twins_pcpvt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512
+  In Collection: FPN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 45.66
+      mIoU(ms+flip): 46.48
+  Config: configs/twins/twins_pcpvt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 32
+    Architecture:
+    - Twins-PCPVT-B
+    - FPN
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 8.41
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-b_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-b_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141019-d396db72.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-b_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-b_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141019.log.json
+  Paper:
+    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
+    URL: https://arxiv.org/pdf/2104.13840.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
+  Framework: PyTorch
+- Name: twins_pcpvt-b_uperhead_8xb2-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 47.91
+      mIoU(ms+flip): 48.64
+  Config: configs/twins/twins_pcpvt-b_uperhead_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - Twins-PCPVT-B
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 6.46
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-b_uperhead_8x2_512x512_160k_ade20k/twins_pcpvt-b_uperhead_8x2_512x512_160k_ade20k_20211130_141020-02094ea5.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-b_uperhead_8x2_512x512_160k_ade20k/twins_pcpvt-b_uperhead_8x2_512x512_160k_ade20k_20211130_141020.log.json
+  Paper:
+    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
+    URL: https://arxiv.org/pdf/2104.13840.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
+  Framework: PyTorch
+- Name: twins_pcpvt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512
+  In Collection: FPN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 45.94
+      mIoU(ms+flip): 46.7
+  Config: configs/twins/twins_pcpvt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 32
+    Architecture:
+    - Twins-PCPVT-L
+    - FPN
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 10.78
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-l_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-l_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_105226-bc6d61dc.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-l_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-l_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_105226.log.json
+  Paper:
+    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
+    URL: https://arxiv.org/pdf/2104.13840.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
+  Framework: PyTorch
+- Name: twins_pcpvt-l_uperhead_8xb2-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 49.35
+      mIoU(ms+flip): 50.08
+  Config: configs/twins/twins_pcpvt-l_uperhead_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - Twins-PCPVT-L
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 7.82
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-l_uperhead_8x2_512x512_160k_ade20k/twins_pcpvt-l_uperhead_8x2_512x512_160k_ade20k_20211201_075053-c6095c07.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-l_uperhead_8x2_512x512_160k_ade20k/twins_pcpvt-l_uperhead_8x2_512x512_160k_ade20k_20211201_075053.log.json
+  Paper:
+    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
+    URL: https://arxiv.org/pdf/2104.13840.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
+  Framework: PyTorch
+- Name: twins_svt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512
+  In Collection: FPN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 44.47
+      mIoU(ms+flip): 45.42
+  Config: configs/twins/twins_svt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 32
+    Architecture:
+    - Twins-SVT-S
+    - FPN
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 5.8
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-s_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-s_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141006-0a0d3317.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-s_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-s_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141006.log.json
+  Paper:
+    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
+    URL: https://arxiv.org/pdf/2104.13840.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
+  Framework: PyTorch
+- Name: twins_svt-s_uperhead_8xb2-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 46.08
+      mIoU(ms+flip): 46.96
+  Config: configs/twins/twins_svt-s_uperhead_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - SVT-S
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 4.93
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-s_uperhead_8x2_512x512_160k_ade20k/twins_svt-s_uperhead_8x2_512x512_160k_ade20k_20211130_141005-e48a2d94.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-s_uperhead_8x2_512x512_160k_ade20k/twins_svt-s_uperhead_8x2_512x512_160k_ade20k_20211130_141005.log.json
+  Paper:
+    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
+    URL: https://arxiv.org/pdf/2104.13840.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
+  Framework: PyTorch
+- Name: twins_svt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512
+  In Collection: FPN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 46.77
+      mIoU(ms+flip): 47.47
+  Config: configs/twins/twins_svt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 32
+    Architecture:
+    - Twins-SVT-B
+    - FPN
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 8.75
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-b_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-b_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_113849-88b2907c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-b_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-b_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_113849.log.json
+  Paper:
+    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
+    URL: https://arxiv.org/pdf/2104.13840.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
+  Framework: PyTorch
+- Name: twins_svt-b_uperhead_8xb2-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 48.04
+      mIoU(ms+flip): 48.87
+  Config: configs/twins/twins_svt-b_uperhead_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - Twins-SVT-B
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 6.77
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-b_uperhead_8x2_512x512_160k_ade20k/twins_svt-b_uperhead_8x2_512x512_160k_ade20k_20211202_040826-0943a1f1.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-b_uperhead_8x2_512x512_160k_ade20k/twins_svt-b_uperhead_8x2_512x512_160k_ade20k_20211202_040826.log.json
+  Paper:
+    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
+    URL: https://arxiv.org/pdf/2104.13840.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
+  Framework: PyTorch
+- Name: twins_svt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512
+  In Collection: FPN
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 46.55
+      mIoU(ms+flip): 47.74
+  Config: configs/twins/twins_svt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 32
+    Architecture:
+    - Twins-SVT-L
+    - FPN
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 11.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-l_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-l_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141005-1d59bee2.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-l_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-l_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141005.log.json
+  Paper:
+    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
+    URL: https://arxiv.org/pdf/2104.13840.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
+  Framework: PyTorch
+- Name: twins_pcpvt-l_uperhead_8xb2-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 49.65
+      mIoU(ms+flip): 50.63
+  Config: configs/twins/twins_pcpvt-l_uperhead_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - Twins-SVT-L
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 8.41
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-l_uperhead_8x2_512x512_160k_ade20k/twins_svt-l_uperhead_8x2_512x512_160k_ade20k_20211130_141005-3e2cae61.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-l_uperhead_8x2_512x512_160k_ade20k/twins_svt-l_uperhead_8x2_512x512_160k_ade20k_20211130_141005.log.json
+  Paper:
+    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
+    URL: https://arxiv.org/pdf/2104.13840.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/twins/twins_pcpvt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_pcpvt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..4739ad4
--- /dev/null
+++ b/mmsegmentation/configs/twins/twins_pcpvt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
@@ -0,0 +1,8 @@
+_base_ = ['./twins_pcpvt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py']
+
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/twins/pcpvt_base_20220308-0621964c.pth'  # noqa
+
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        depths=[3, 4, 18, 3]), )
diff --git a/mmsegmentation/configs/twins/twins_pcpvt-b_uperhead_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_pcpvt-b_uperhead_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..ba97485
--- /dev/null
+++ b/mmsegmentation/configs/twins/twins_pcpvt-b_uperhead_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,13 @@
+_base_ = ['./twins_pcpvt-s_uperhead_8xb4-160k_ade20k-512x512.py']
+
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/twins/pcpvt_base_20220308-0621964c.pth'  # noqa
+
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        depths=[3, 4, 18, 3],
+        drop_path_rate=0.3))
+
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/twins/twins_pcpvt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_pcpvt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..bff7c41
--- /dev/null
+++ b/mmsegmentation/configs/twins/twins_pcpvt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
@@ -0,0 +1,8 @@
+_base_ = ['./twins_pcpvt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py']
+
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/twins/pcpvt_large_20220308-37579dc6.pth'  # noqa
+
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        depths=[3, 8, 27, 3]))
diff --git a/mmsegmentation/configs/twins/twins_pcpvt-l_uperhead_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_pcpvt-l_uperhead_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..666ff5b
--- /dev/null
+++ b/mmsegmentation/configs/twins/twins_pcpvt-l_uperhead_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,13 @@
+_base_ = ['./twins_pcpvt-s_uperhead_8xb4-160k_ade20k-512x512.py']
+
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/twins/pcpvt_large_20220308-37579dc6.pth'  # noqa
+
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        depths=[3, 8, 27, 3],
+        drop_path_rate=0.3))
+
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/twins/twins_pcpvt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_pcpvt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..3b480b9
--- /dev/null
+++ b/mmsegmentation/configs/twins/twins_pcpvt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/twins_pcpvt-s_fpn.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0001),
+    clip_grad=None)
diff --git a/mmsegmentation/configs/twins/twins_pcpvt-s_uperhead_8xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_pcpvt-s_uperhead_8xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..387cf60
--- /dev/null
+++ b/mmsegmentation/configs/twins/twins_pcpvt-s_uperhead_8xb4-160k_ade20k-512x512.py
@@ -0,0 +1,31 @@
+_base_ = [
+    '../_base_/models/twins_pcpvt-s_upernet.py',
+    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
+
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
+    paramwise_cfg=dict(custom_keys={
+        'pos_block': dict(decay_mult=0.),
+        'norm': dict(decay_mult=0.)
+    }))
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        eta_min=0.0,
+        power=1.0,
+        begin=1500,
+        end=160000,
+        by_epoch=False,
+    )
+]
diff --git a/mmsegmentation/configs/twins/twins_svt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_svt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..5e9fa00
--- /dev/null
+++ b/mmsegmentation/configs/twins/twins_svt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
@@ -0,0 +1,12 @@
+_base_ = ['./twins_svt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py']
+
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/twins/alt_gvt_base_20220308-1b7eb711.pth'  # noqa
+
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        embed_dims=[96, 192, 384, 768],
+        num_heads=[3, 6, 12, 24],
+        depths=[2, 2, 18, 2]),
+    neck=dict(in_channels=[96, 192, 384, 768]),
+)
diff --git a/mmsegmentation/configs/twins/twins_svt-b_uperhead_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_svt-b_uperhead_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..6ce2361
--- /dev/null
+++ b/mmsegmentation/configs/twins/twins_svt-b_uperhead_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,12 @@
+_base_ = ['./twins_svt-s_uperhead_8xb2-160k_ade20k-512x512.py']
+
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/twins/alt_gvt_base_20220308-1b7eb711.pth'  # noqa
+
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        embed_dims=[96, 192, 384, 768],
+        num_heads=[3, 6, 12, 24],
+        depths=[2, 2, 18, 2]),
+    decode_head=dict(in_channels=[96, 192, 384, 768]),
+    auxiliary_head=dict(in_channels=384))
diff --git a/mmsegmentation/configs/twins/twins_svt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_svt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..b7e5f9c
--- /dev/null
+++ b/mmsegmentation/configs/twins/twins_svt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
@@ -0,0 +1,13 @@
+_base_ = ['./twins_svt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py']
+
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/twins/alt_gvt_large_20220308-fb5936f3.pth'  # noqa
+
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        embed_dims=[128, 256, 512, 1024],
+        num_heads=[4, 8, 16, 32],
+        depths=[2, 2, 18, 2],
+        drop_path_rate=0.3),
+    neck=dict(in_channels=[128, 256, 512, 1024]),
+)
diff --git a/mmsegmentation/configs/twins/twins_svt-l_uperhead_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_svt-l_uperhead_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..69c69df
--- /dev/null
+++ b/mmsegmentation/configs/twins/twins_svt-l_uperhead_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,13 @@
+_base_ = ['./twins_svt-s_uperhead_8xb2-160k_ade20k-512x512.py']
+
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/twins/alt_gvt_large_20220308-fb5936f3.pth'  # noqa
+
+model = dict(
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        embed_dims=[128, 256, 512, 1024],
+        num_heads=[4, 8, 16, 32],
+        depths=[2, 2, 18, 2],
+        drop_path_rate=0.3),
+    decode_head=dict(in_channels=[128, 256, 512, 1024]),
+    auxiliary_head=dict(in_channels=512))
diff --git a/mmsegmentation/configs/twins/twins_svt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_svt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..c1aad83
--- /dev/null
+++ b/mmsegmentation/configs/twins/twins_svt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
@@ -0,0 +1,28 @@
+_base_ = [
+    '../_base_/models/twins_pcpvt-s_fpn.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/twins/alt_gvt_small_20220308-7e1c3695.pth'  # noqa
+
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='SVT',
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        embed_dims=[64, 128, 256, 512],
+        num_heads=[2, 4, 8, 16],
+        mlp_ratios=[4, 4, 4, 4],
+        depths=[2, 2, 10, 4],
+        windiow_sizes=[7, 7, 7, 7],
+        norm_after_stage=True),
+    neck=dict(in_channels=[64, 128, 256, 512], out_channels=256, num_outs=4),
+    decode_head=dict(num_classes=150),
+)
+
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0001),
+    clip_grad=None)
diff --git a/mmsegmentation/configs/twins/twins_svt-s_uperhead_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_svt-s_uperhead_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..3846795
--- /dev/null
+++ b/mmsegmentation/configs/twins/twins_svt-s_uperhead_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,49 @@
+_base_ = [
+    '../_base_/models/twins_pcpvt-s_upernet.py',
+    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/twins/alt_gvt_small_20220308-7e1c3695.pth'  # noqa
+
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='SVT',
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        embed_dims=[64, 128, 256, 512],
+        num_heads=[2, 4, 8, 16],
+        mlp_ratios=[4, 4, 4, 4],
+        depths=[2, 2, 10, 4],
+        windiow_sizes=[7, 7, 7, 7],
+        norm_after_stage=True),
+    decode_head=dict(in_channels=[64, 128, 256, 512]),
+    auxiliary_head=dict(in_channels=256))
+
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
+    paramwise_cfg=dict(custom_keys={
+        'pos_block': dict(decay_mult=0.),
+        'norm': dict(decay_mult=0.)
+    }))
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        eta_min=0.0,
+        power=1.0,
+        begin=1500,
+        end=160000,
+        by_epoch=False,
+    )
+]
+
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/unet/README.md b/mmsegmentation/configs/unet/README.md
new file mode 100644
index 0000000..7225fbb
--- /dev/null
+++ b/mmsegmentation/configs/unet/README.md
@@ -0,0 +1,92 @@
+# UNet
+
+> [U-Net: Convolutional Networks for Biomedical Image Segmentation](https://arxiv.org/abs/1505.04597)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="http://lmb.informatik.uni-freiburg.de/people/ronneber/u-net">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+There is large consent that successful training of deep networks requires many thousand annotated training samples. In this paper, we present a network and training strategy that relies on the strong use of data augmentation to use the available annotated samples more efficiently. The architecture consists of a contracting path to capture context and a symmetric expanding path that enables precise localization. We show that such a network can be trained end-to-end from very few images and outperforms the prior best method (a sliding-window convolutional network) on the ISBI challenge for segmentation of neuronal structures in electron microscopic stacks. Using the same network trained on transmitted light microscopy images (phase contrast and DIC) we won the ISBI cell tracking challenge 2015 in these categories by a large margin. Moreover, the network is fast. Segmentation of a 512x512 image takes less than a second on a recent GPU. The full implementation (based on Caffe) and the trained networks are available at [this http URL](https://lmb.informatik.uni-freiburg.de/people/ronneber/u-net/).
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142902977-20fe689d-a147-4d92-9690-dbfde8b68dbe.png" width="70%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method     | Backbone    | Loss          | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                         | download                                                                                                                                                                                                                                                                                                                                                                     |
+| ---------- | ----------- | ------------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UNet + FCN | UNet-S5-D16 | Cross Entropy | 512x1024  |  160000 | 17.91    | 3.05           | V100   | 69.10 |         71.05 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_4x4_512x1024_160k_cityscapes/fcn_unet_s5-d16_4x4_512x1024_160k_cityscapes_20211210_145204-6860854e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_4x4_512x1024_160k_cityscapes/fcn_unet_s5-d16_4x4_512x1024_160k_cityscapes_20211210_145204.log.json) |
+
+### DRIVE
+
+| Method           | Backbone    | Loss                 | Image Size | Crop Size | Stride | Lr schd | Mem (GB) | Inf time (fps) | Device | mDice |  Dice | config                                                                                                                                      | download                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ----------- | -------------------- | ---------- | --------- | -----: | ------- | -------- | -------------: | ------ | ----: | ----: | ------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UNet + FCN       | UNet-S5-D16 | Cross Entropy        | 584x565    | 64x64     |  42x42 | 40000   | 0.680    |              - | V100   | 88.38 | 78.67 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_fcn_4xb4-40k_drive-64x64.py)                       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_64x64_40k_drive/fcn_unet_s5-d16_64x64_40k_drive_20201223_191051-5daf6d3b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/unet_s5-d16_64x64_40k_drive/unet_s5-d16_64x64_40k_drive-20201223_191051.log.json)                                                                                                 |
+| UNet + FCN       | UNet-S5-D16 | Cross Entropy + Dice | 584x565    | 64x64     |  42x42 | 40000   | 0.582    |              - | V100   | 88.71 | 79.32 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/fcn_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201820-785de5c2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/fcn_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201820.log.json)                         |
+| UNet + PSPNet    | UNet-S5-D16 | Cross Entropy        | 584x565    | 64x64     |  42x42 | 40000   | 0.599    |              - | V100   | 88.35 | 78.62 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_pspnet_4xb4-40k_drive-64x64.py)                    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_64x64_40k_drive/pspnet_unet_s5-d16_64x64_40k_drive_20201227_181818-aac73387.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_64x64_40k_drive/pspnet_unet_s5-d16_64x64_40k_drive-20201227_181818.log.json)                                                                             |
+| UNet + PSPNet    | UNet-S5-D16 | Cross Entropy + Dice | 584x565    | 64x64     |  42x42 | 40000   | 0.585    |              - | V100   | 88.76 | 79.42 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/pspnet_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201821-22b3e3ba.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/pspnet_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201821.log.json)             |
+| UNet + DeepLabV3 | UNet-S5-D16 | Cross Entropy        | 584x565    | 64x64     |  42x42 | 40000   | 0.596    |              - | V100   | 88.38 | 78.69 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_drive-64x64.py)                 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_64x64_40k_drive/deeplabv3_unet_s5-d16_64x64_40k_drive_20201226_094047-0671ff20.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_64x64_40k_drive/deeplabv3_unet_s5-d16_64x64_40k_drive-20201226_094047.log.json)                                                                 |
+| UNet + DeepLabV3 | UNet-S5-D16 | Cross Entropy + Dice | 584x565    | 64x64     |  42x42 | 40000   | 0.582    |              - | V100   | 88.84 | 79.56 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201825-6bf0efd7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201825.log.json) |
+
+### STARE
+
+| Method           | Backbone    | Loss                 | Image Size | Crop Size | Stride | Lr schd | Mem (GB) | Inf time (fps) | Device | mDice |  Dice | config                                                                                                                                        | download                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| ---------------- | ----------- | -------------------- | ---------- | --------- | -----: | ------- | -------- | -------------: | ------ | ----: | ----: | --------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UNet + FCN       | UNet-S5-D16 | Cross Entropy        | 605x700    | 128x128   |  85x85 | 40000   | 0.968    |              - | V100   | 89.78 | 81.02 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_fcn_4xb4-40k_stare-128x128.py)                       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_128x128_40k_stare/fcn_unet_s5-d16_128x128_40k_stare_20201223_191051-7d77e78b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/unet_s5-d16_128x128_40k_stare/unet_s5-d16_128x128_40k_stare-20201223_191051.log.json)                                                                                                 |
+| UNet + FCN       | UNet-S5-D16 | Cross Entropy + Dice | 605x700    | 128x128   |  85x85 | 40000   | 0.986    |              - | V100   | 90.65 | 82.70 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201821-f75705a9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201821.log.json)                         |
+| UNet + PSPNet    | UNet-S5-D16 | Cross Entropy        | 605x700    | 128x128   |  85x85 | 40000   | 0.982    |              - | V100   | 89.89 | 81.22 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_pspnet_4xb4-40k_stare-128x128.py)                    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_128x128_40k_stare/pspnet_unet_s5-d16_128x128_40k_stare_20201227_181818-3c2923c4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_128x128_40k_stare/pspnet_unet_s5-d16_128x128_40k_stare-20201227_181818.log.json)                                                                             |
+| UNet + PSPNet    | UNet-S5-D16 | Cross Entropy + Dice | 605x700    | 128x128   |  85x85 | 40000   | 1.028    |              - | V100   | 90.72 | 82.84 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201823-f1063ef7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201823.log.json)             |
+| UNet + DeepLabV3 | UNet-S5-D16 | Cross Entropy        | 605x700    | 128x128   |  85x85 | 40000   | 0.999    |              - | V100   | 89.73 | 80.93 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_stare-128x128.py)                 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_128x128_40k_stare/deeplabv3_unet_s5-d16_128x128_40k_stare_20201226_094047-93dcb93c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_128x128_40k_stare/deeplabv3_unet_s5-d16_128x128_40k_stare-20201226_094047.log.json)                                                                 |
+| UNet + DeepLabV3 | UNet-S5-D16 | Cross Entropy + Dice | 605x700    | 128x128   |  85x85 | 40000   | 1.010    |              - | V100   | 90.65 | 82.71 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201825-21db614c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201825.log.json) |
+
+### CHASE_DB1
+
+| Method           | Backbone    | Loss                 | Image Size | Crop Size | Stride | Lr schd | Mem (GB) | Inf time (fps) | Device | mDice |  Dice | config                                                                                                                                            | download                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| ---------------- | ----------- | -------------------- | ---------- | --------- | -----: | ------- | -------- | -------------: | ------ | ----: | ----: | ------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UNet + FCN       | UNet-S5-D16 | Cross Entropy        | 960x999    | 128x128   |  85x85 | 40000   | 0.968    |              - | V100   | 89.46 | 80.24 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_fcn_4xb4-40k_chase-db1-128x128.py)                       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_128x128_40k_chase_db1/fcn_unet_s5-d16_128x128_40k_chase_db1_20201223_191051-11543527.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/unet_s5-d16_128x128_40k_chase_db1/unet_s5-d16_128x128_40k_chase_db1-20201223_191051.log.json)                                                                                                 |
+| UNet + FCN       | UNet-S5-D16 | Cross Entropy + Dice | 960x999    | 128x128   |  85x85 | 40000   | 0.986    |              - | V100   | 89.52 | 80.40 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201821-1c4eb7cf.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201821.log.json)                         |
+| UNet + PSPNet    | UNet-S5-D16 | Cross Entropy        | 960x999    | 128x128   |  85x85 | 40000   | 0.982    |              - | V100   | 89.52 | 80.36 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_pspnet_4xb4-40k_chase-db1-128x128.py)                    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_128x128_40k_chase_db1/pspnet_unet_s5-d16_128x128_40k_chase_db1_20201227_181818-68d4e609.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_128x128_40k_chase_db1/pspnet_unet_s5-d16_128x128_40k_chase_db1-20201227_181818.log.json)                                                                             |
+| UNet + PSPNet    | UNet-S5-D16 | Cross Entropy + Dice | 960x999    | 128x128   |  85x85 | 40000   | 1.028    |              - | V100   | 89.45 | 80.28 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201823-c0802c4d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201823.log.json)             |
+| UNet + DeepLabV3 | UNet-S5-D16 | Cross Entropy        | 960x999    | 128x128   |  85x85 | 40000   | 0.999    |              - | V100   | 89.57 | 80.47 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet_s5-d16_deeplabv3_4xb4-40k_chase-db1-128x128.py)                 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_128x128_40k_chase_db1/deeplabv3_unet_s5-d16_128x128_40k_chase_db1_20201226_094047-4c5aefa3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_128x128_40k_chase_db1/deeplabv3_unet_s5-d16_128x128_40k_chase_db1-20201226_094047.log.json)                                                                 |
+| UNet + DeepLabV3 | UNet-S5-D16 | Cross Entropy + Dice | 960x999    | 128x128   |  85x85 | 40000   | 1.010    |              - | V100   | 89.49 | 80.37 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201825-4ef29df5.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201825.log.json) |
+
+### HRF
+
+| Method           | Backbone    | Loss                 | Image Size | Crop Size |  Stride | Lr schd | Mem (GB) | Inf time (fps) | Device | mDice |  Dice | config                                                                                                                                      | download                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ----------- | -------------------- | ---------- | --------- | ------: | ------- | -------- | -------------: | ------ | ----: | ----: | ------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UNet + FCN       | UNet-S5-D16 | Cross Entropy        | 2336x3504  | 256x256   | 170x170 | 40000   | 2.525    |              - | V100   | 88.92 | 79.45 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_fcn_4xb4-40k_hrf-256x256.py)                       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_256x256_40k_hrf/fcn_unet_s5-d16_256x256_40k_hrf_20201223_173724-d89cf1ed.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/unet_s5-d16_256x256_40k_hrf/unet_s5-d16_256x256_40k_hrf-20201223_173724.log.json)                                                                                                 |
+| UNet + FCN       | UNet-S5-D16 | Cross Entropy + Dice | 2336x3504  | 256x256   | 170x170 | 40000   | 2.623    |              - | V100   | 89.64 | 80.87 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/fcn_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_201821-c314da8a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/fcn_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_201821.log.json)                         |
+| UNet + PSPNet    | UNet-S5-D16 | Cross Entropy        | 2336x3504  | 256x256   | 170x170 | 40000   | 2.588    |              - | V100   | 89.24 | 80.07 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_pspnet_4xb4-40k_hrf-256x256.py)                    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_256x256_40k_hrf/pspnet_unet_s5-d16_256x256_40k_hrf_20201227_181818-fdb7e29b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_256x256_40k_hrf/pspnet_unet_s5-d16_256x256_40k_hrf-20201227_181818.log.json)                                                                             |
+| UNet + PSPNet    | UNet-S5-D16 | Cross Entropy + Dice | 2336x3504  | 256x256   | 170x170 | 40000   | 2.798    |              - | V100   | 89.69 | 80.96 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/pspnet_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_201823-53d492fa.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/pspnet_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_201823.log.json)             |
+| UNet + DeepLabV3 | UNet-S5-D16 | Cross Entropy        | 2336x3504  | 256x256   | 170x170 | 40000   | 2.604    |              - | V100   | 89.32 | 80.21 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_hrf-256x256.py)                 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_256x256_40k_hrf/deeplabv3_unet_s5-d16_256x256_40k_hrf_20201226_094047-3a1fdf85.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_256x256_40k_hrf/deeplabv3_unet_s5-d16_256x256_40k_hrf-20201226_094047.log.json)                                                                 |
+| UNet + DeepLabV3 | UNet-S5-D16 | Cross Entropy + Dice | 2336x3504  | 256x256   | 170x170 | 40000   | 2.607    |              - | V100   | 89.56 | 80.71 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_202032-59daf7a4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_202032.log.json) |
+
+Note:
+
+- In  `DRIVE`, `STARE`, `CHASE_DB1`, and `HRF` dataset, `mDice` is mean dice of background and vessel, while `Dice` is dice metric of vessel(foreground) only.
+
+## Citation
+
+```bibtex
+@inproceedings{ronneberger2015u,
+  title={U-net: Convolutional networks for biomedical image segmentation},
+  author={Ronneberger, Olaf and Fischer, Philipp and Brox, Thomas},
+  booktitle={International Conference on Medical image computing and computer-assisted intervention},
+  pages={234--241},
+  year={2015},
+  organization={Springer}
+}
+```
diff --git a/mmsegmentation/configs/unet/metafile.yaml b/mmsegmentation/configs/unet/metafile.yaml
new file mode 100644
index 0000000..1eafbc6
--- /dev/null
+++ b/mmsegmentation/configs/unet/metafile.yaml
@@ -0,0 +1,642 @@
+Collections:
+- Name: UNet
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+    - DRIVE
+    - STARE
+    - CHASE_DB1
+    - HRF
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  README: configs/unet/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 69.1
+      mIoU(ms+flip): 71.05
+  Config: configs/unet/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 17.91
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_4x4_512x1024_160k_cityscapes/fcn_unet_s5-d16_4x4_512x1024_160k_cityscapes_20211210_145204-6860854e.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_4x4_512x1024_160k_cityscapes/fcn_unet_s5-d16_4x4_512x1024_160k_cityscapes_20211210_145204.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet-s5-d16_fcn_4xb4-40k_drive-64x64
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: DRIVE
+    Metrics:
+      mDice: 88.38
+      Dice: 78.67
+  Config: configs/unet/unet-s5-d16_fcn_4xb4-40k_drive-64x64.py
+  Metadata:
+    Training Data: DRIVE
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 0.68
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_64x64_40k_drive/fcn_unet_s5-d16_64x64_40k_drive_20201223_191051-5daf6d3b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/unet_s5-d16_64x64_40k_drive/unet_s5-d16_64x64_40k_drive-20201223_191051.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_drive-64x64
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: DRIVE
+    Metrics:
+      mDice: 88.71
+      Dice: 79.32
+  Config: configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
+  Metadata:
+    Training Data: DRIVE
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 0.582
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/fcn_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201820-785de5c2.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/fcn_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201820.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet-s5-d16_pspnet_4xb4-40k_drive-64x64
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: DRIVE
+    Metrics:
+      mDice: 88.35
+      Dice: 78.62
+  Config: configs/unet/unet-s5-d16_pspnet_4xb4-40k_drive-64x64.py
+  Metadata:
+    Training Data: DRIVE
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 0.599
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_64x64_40k_drive/pspnet_unet_s5-d16_64x64_40k_drive_20201227_181818-aac73387.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_64x64_40k_drive/pspnet_unet_s5-d16_64x64_40k_drive-20201227_181818.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_drive-64x64
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: DRIVE
+    Metrics:
+      mDice: 88.76
+      Dice: 79.42
+  Config: configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
+  Metadata:
+    Training Data: DRIVE
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 0.585
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/pspnet_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201821-22b3e3ba.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/pspnet_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201821.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet-s5-d16_deeplabv3_4xb4-40k_drive-64x64
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: DRIVE
+    Metrics:
+      mDice: 88.38
+      Dice: 78.69
+  Config: configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_drive-64x64.py
+  Metadata:
+    Training Data: DRIVE
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 0.596
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_64x64_40k_drive/deeplabv3_unet_s5-d16_64x64_40k_drive_20201226_094047-0671ff20.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_64x64_40k_drive/deeplabv3_unet_s5-d16_64x64_40k_drive-20201226_094047.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_drive-64x64
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: DRIVE
+    Metrics:
+      mDice: 88.84
+      Dice: 79.56
+  Config: configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
+  Metadata:
+    Training Data: DRIVE
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 0.582
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201825-6bf0efd7.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201825.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet-s5-d16_fcn_4xb4-40k_stare-128x128
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: STARE
+    Metrics:
+      mDice: 89.78
+      Dice: 81.02
+  Config: configs/unet/unet-s5-d16_fcn_4xb4-40k_stare-128x128.py
+  Metadata:
+    Training Data: STARE
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 0.968
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_128x128_40k_stare/fcn_unet_s5-d16_128x128_40k_stare_20201223_191051-7d77e78b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/unet_s5-d16_128x128_40k_stare/unet_s5-d16_128x128_40k_stare-20201223_191051.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_stare-128x128
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: STARE
+    Metrics:
+      mDice: 90.65
+      Dice: 82.7
+  Config: configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
+  Metadata:
+    Training Data: STARE
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 0.986
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201821-f75705a9.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201821.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet-s5-d16_pspnet_4xb4-40k_stare-128x128
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: STARE
+    Metrics:
+      mDice: 89.89
+      Dice: 81.22
+  Config: configs/unet/unet-s5-d16_pspnet_4xb4-40k_stare-128x128.py
+  Metadata:
+    Training Data: STARE
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 0.982
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_128x128_40k_stare/pspnet_unet_s5-d16_128x128_40k_stare_20201227_181818-3c2923c4.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_128x128_40k_stare/pspnet_unet_s5-d16_128x128_40k_stare-20201227_181818.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_stare-128x128
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: STARE
+    Metrics:
+      mDice: 90.72
+      Dice: 82.84
+  Config: configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
+  Metadata:
+    Training Data: STARE
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.028
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201823-f1063ef7.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201823.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet-s5-d16_deeplabv3_4xb4-40k_stare-128x128
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: STARE
+    Metrics:
+      mDice: 89.73
+      Dice: 80.93
+  Config: configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_stare-128x128.py
+  Metadata:
+    Training Data: STARE
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 0.999
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_128x128_40k_stare/deeplabv3_unet_s5-d16_128x128_40k_stare_20201226_094047-93dcb93c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_128x128_40k_stare/deeplabv3_unet_s5-d16_128x128_40k_stare-20201226_094047.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_stare-128x128
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: STARE
+    Metrics:
+      mDice: 90.65
+      Dice: 82.71
+  Config: configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
+  Metadata:
+    Training Data: STARE
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.01
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201825-21db614c.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201825.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet-s5-d16_fcn_4xb4-40k_chase-db1-128x128
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: CHASE_DB1
+    Metrics:
+      mDice: 89.46
+      Dice: 80.24
+  Config: configs/unet/unet-s5-d16_fcn_4xb4-40k_chase-db1-128x128.py
+  Metadata:
+    Training Data: CHASE_DB1
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 0.968
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_128x128_40k_chase_db1/fcn_unet_s5-d16_128x128_40k_chase_db1_20201223_191051-11543527.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/unet_s5-d16_128x128_40k_chase_db1/unet_s5-d16_128x128_40k_chase_db1-20201223_191051.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: CHASE_DB1
+    Metrics:
+      mDice: 89.52
+      Dice: 80.4
+  Config: configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
+  Metadata:
+    Training Data: CHASE_DB1
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 0.986
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201821-1c4eb7cf.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201821.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet-s5-d16_pspnet_4xb4-40k_chase-db1-128x128
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: CHASE_DB1
+    Metrics:
+      mDice: 89.52
+      Dice: 80.36
+  Config: configs/unet/unet-s5-d16_pspnet_4xb4-40k_chase-db1-128x128.py
+  Metadata:
+    Training Data: CHASE_DB1
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 0.982
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_128x128_40k_chase_db1/pspnet_unet_s5-d16_128x128_40k_chase_db1_20201227_181818-68d4e609.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_128x128_40k_chase_db1/pspnet_unet_s5-d16_128x128_40k_chase_db1-20201227_181818.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: CHASE_DB1
+    Metrics:
+      mDice: 89.45
+      Dice: 80.28
+  Config: configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
+  Metadata:
+    Training Data: CHASE_DB1
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.028
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201823-c0802c4d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201823.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet_s5-d16_deeplabv3_4xb4-40k_chase-db1-128x128
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: CHASE_DB1
+    Metrics:
+      mDice: 89.57
+      Dice: 80.47
+  Config: configs/unet/unet_s5-d16_deeplabv3_4xb4-40k_chase-db1-128x128.py
+  Metadata:
+    Training Data: CHASE_DB1
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 0.999
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_128x128_40k_chase_db1/deeplabv3_unet_s5-d16_128x128_40k_chase_db1_20201226_094047-4c5aefa3.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_128x128_40k_chase_db1/deeplabv3_unet_s5-d16_128x128_40k_chase_db1-20201226_094047.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: CHASE_DB1
+    Metrics:
+      mDice: 89.49
+      Dice: 80.37
+  Config: configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
+  Metadata:
+    Training Data: CHASE_DB1
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 1.01
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201825-4ef29df5.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201825.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet-s5-d16_fcn_4xb4-40k_hrf-256x256
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: HRF
+    Metrics:
+      mDice: 88.92
+      Dice: 79.45
+  Config: configs/unet/unet-s5-d16_fcn_4xb4-40k_hrf-256x256.py
+  Metadata:
+    Training Data: HRF
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 2.525
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_256x256_40k_hrf/fcn_unet_s5-d16_256x256_40k_hrf_20201223_173724-d89cf1ed.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/unet_s5-d16_256x256_40k_hrf/unet_s5-d16_256x256_40k_hrf-20201223_173724.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: HRF
+    Metrics:
+      mDice: 89.64
+      Dice: 80.87
+  Config: configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
+  Metadata:
+    Training Data: HRF
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - FCN
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 2.623
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/fcn_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_201821-c314da8a.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/fcn_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_201821.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet-s5-d16_pspnet_4xb4-40k_hrf-256x256
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: HRF
+    Metrics:
+      mDice: 89.24
+      Dice: 80.07
+  Config: configs/unet/unet-s5-d16_pspnet_4xb4-40k_hrf-256x256.py
+  Metadata:
+    Training Data: HRF
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 2.588
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_256x256_40k_hrf/pspnet_unet_s5-d16_256x256_40k_hrf_20201227_181818-fdb7e29b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_256x256_40k_hrf/pspnet_unet_s5-d16_256x256_40k_hrf-20201227_181818.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: HRF
+    Metrics:
+      mDice: 89.69
+      Dice: 80.96
+  Config: configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
+  Metadata:
+    Training Data: HRF
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - PSPNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 2.798
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/pspnet_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_201823-53d492fa.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/pspnet_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_201823.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet-s5-d16_deeplabv3_4xb4-40k_hrf-256x256
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: HRF
+    Metrics:
+      mDice: 89.32
+      Dice: 80.21
+  Config: configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_hrf-256x256.py
+  Metadata:
+    Training Data: HRF
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 2.604
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_256x256_40k_hrf/deeplabv3_unet_s5-d16_256x256_40k_hrf_20201226_094047-3a1fdf85.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_256x256_40k_hrf/deeplabv3_unet_s5-d16_256x256_40k_hrf-20201226_094047.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
+- Name: unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256
+  In Collection: UNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: HRF
+    Metrics:
+      mDice: 89.56
+      Dice: 80.71
+  Config: configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
+  Metadata:
+    Training Data: HRF
+    Batch Size: 16
+    Architecture:
+    - UNet-S5-D16
+    - UNet
+    - DeepLabV3
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 2.607
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_202032-59daf7a4.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_202032.log.json
+  Paper:
+    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
+    URL: https://arxiv.org/abs/1505.04597
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_drive-64x64.py b/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_drive-64x64.py
new file mode 100644
index 0000000..e4af542
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_drive-64x64.py
@@ -0,0 +1,9 @@
+_base_ = [
+    '../_base_/models/deeplabv3_unet_s5-d16.py', '../_base_/datasets/drive.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (64, 64)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    test_cfg=dict(crop_size=(64, 64), stride=(42, 42)))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_hrf-256x256.py b/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_hrf-256x256.py
new file mode 100644
index 0000000..b45405f
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_hrf-256x256.py
@@ -0,0 +1,9 @@
+_base_ = [
+    '../_base_/models/deeplabv3_unet_s5-d16.py', '../_base_/datasets/hrf.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (256, 256)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    test_cfg=dict(crop_size=(256, 256), stride=(170, 170)))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_stare-128x128.py b/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_stare-128x128.py
new file mode 100644
index 0000000..554caca
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_stare-128x128.py
@@ -0,0 +1,9 @@
+_base_ = [
+    '../_base_/models/deeplabv3_unet_s5-d16.py', '../_base_/datasets/stare.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (128, 128)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    test_cfg=dict(crop_size=(128, 128), stride=(85, 85)))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py b/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
new file mode 100644
index 0000000..4f30bba
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
@@ -0,0 +1,6 @@
+_base_ = './unet_s5-d16_deeplabv3_4xb4-40k_chase-db1-128x128.py'
+model = dict(
+    decode_head=dict(loss_decode=[
+        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
+        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
+    ]))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py b/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
new file mode 100644
index 0000000..823fc6d
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
@@ -0,0 +1,6 @@
+_base_ = './unet-s5-d16_deeplabv3_4xb4-40k_drive-64x64.py'
+model = dict(
+    decode_head=dict(loss_decode=[
+        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
+        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
+    ]))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py b/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
new file mode 100644
index 0000000..174eaf8
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
@@ -0,0 +1,6 @@
+_base_ = './unet-s5-d16_deeplabv3_4xb4-40k_hrf-256x256.py'
+model = dict(
+    decode_head=dict(loss_decode=[
+        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
+        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
+    ]))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py b/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
new file mode 100644
index 0000000..35972be
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
@@ -0,0 +1,6 @@
+_base_ = './unet-s5-d16_deeplabv3_4xb4-40k_stare-128x128.py'
+model = dict(
+    decode_head=dict(loss_decode=[
+        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
+        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
+    ]))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py
new file mode 100644
index 0000000..c2e995d
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py
@@ -0,0 +1,16 @@
+_base_ = [
+    '../_base_/models/fcn_unet_s5-d16.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=19),
+    auxiliary_head=dict(num_classes=19),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=1, num_workers=4)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-160k_hsidrive-192x384.py b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-160k_hsidrive-192x384.py
new file mode 100644
index 0000000..a5768ba
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-160k_hsidrive-192x384.py
@@ -0,0 +1,36 @@
+_base_ = [
+    '../_base_/models/fcn_unet_s5-d16.py', '../_base_/datasets/hsi_drive.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (192, 384)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    size=crop_size,
+    mean=None,
+    std=None,
+    bgr_to_rgb=None,
+    pad_val=0,
+    seg_pad_val=255)
+
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(in_channels=25),
+    decode_head=dict(
+        ignore_index=0,
+        num_classes=11,
+        loss_decode=dict(
+            type='CrossEntropyLoss',
+            use_sigmoid=False,
+            loss_weight=1.0,
+            avg_non_ignore=True)),
+    auxiliary_head=dict(
+        ignore_index=0,
+        num_classes=11,
+        loss_decode=dict(
+            type='CrossEntropyLoss',
+            use_sigmoid=False,
+            loss_weight=1.0,
+            avg_non_ignore=True)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_chase-db1-128x128.py b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_chase-db1-128x128.py
new file mode 100644
index 0000000..bfc2109
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_chase-db1-128x128.py
@@ -0,0 +1,9 @@
+_base_ = [
+    '../_base_/models/fcn_unet_s5-d16.py', '../_base_/datasets/chase_db1.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (128, 128)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    test_cfg=dict(crop_size=(128, 128), stride=(85, 85)))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_drive-64x64.py b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_drive-64x64.py
new file mode 100644
index 0000000..10a45d1
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_drive-64x64.py
@@ -0,0 +1,9 @@
+_base_ = [
+    '../_base_/models/fcn_unet_s5-d16.py', '../_base_/datasets/drive.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (64, 64)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    test_cfg=dict(crop_size=(64, 64), stride=(42, 42)))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_hrf-256x256.py b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_hrf-256x256.py
new file mode 100644
index 0000000..7de57f2
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_hrf-256x256.py
@@ -0,0 +1,9 @@
+_base_ = [
+    '../_base_/models/fcn_unet_s5-d16.py', '../_base_/datasets/hrf.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (256, 256)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    test_cfg=dict(crop_size=(256, 256), stride=(170, 170)))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_stare-128x128.py b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_stare-128x128.py
new file mode 100644
index 0000000..8eeef77
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_stare-128x128.py
@@ -0,0 +1,9 @@
+_base_ = [
+    '../_base_/models/fcn_unet_s5-d16.py', '../_base_/datasets/stare.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (128, 128)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    test_cfg=dict(crop_size=(128, 128), stride=(85, 85)))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
new file mode 100644
index 0000000..5a26ccb
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
@@ -0,0 +1,6 @@
+_base_ = './unet-s5-d16_fcn_4xb4-40k_chase-db1-128x128.py'
+model = dict(
+    decode_head=dict(loss_decode=[
+        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
+        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
+    ]))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
new file mode 100644
index 0000000..c3b1488
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
@@ -0,0 +1,6 @@
+_base_ = './unet-s5-d16_fcn_4xb4-40k_drive-64x64.py'
+model = dict(
+    decode_head=dict(loss_decode=[
+        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
+        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
+    ]))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
new file mode 100644
index 0000000..dd3a6af
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
@@ -0,0 +1,6 @@
+_base_ = './unet-s5-d16_fcn_4xb4-40k_hrf-256x256.py'
+model = dict(
+    decode_head=dict(loss_decode=[
+        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
+        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
+    ]))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
new file mode 100644
index 0000000..c8fecf3
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
@@ -0,0 +1,6 @@
+_base_ = './unet-s5-d16_fcn_4xb4-40k_stare-128x128.py'
+model = dict(
+    decode_head=dict(loss_decode=[
+        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
+        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
+    ]))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_chase-db1-128x128.py b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_chase-db1-128x128.py
new file mode 100644
index 0000000..ca6e513
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_chase-db1-128x128.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/pspnet_unet_s5-d16.py',
+    '../_base_/datasets/chase_db1.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (128, 128)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    test_cfg=dict(crop_size=(128, 128), stride=(85, 85)))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_drive-64x64.py b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_drive-64x64.py
new file mode 100644
index 0000000..503b901
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_drive-64x64.py
@@ -0,0 +1,9 @@
+_base_ = [
+    '../_base_/models/pspnet_unet_s5-d16.py', '../_base_/datasets/drive.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (64, 64)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    test_cfg=dict(crop_size=(64, 64), stride=(42, 42)))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_hrf-256x256.py b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_hrf-256x256.py
new file mode 100644
index 0000000..245365c
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_hrf-256x256.py
@@ -0,0 +1,9 @@
+_base_ = [
+    '../_base_/models/pspnet_unet_s5-d16.py', '../_base_/datasets/hrf.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (256, 256)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    test_cfg=dict(crop_size=(256, 256), stride=(170, 170)))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_stare-128x128.py b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_stare-128x128.py
new file mode 100644
index 0000000..c1eeeb9
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_stare-128x128.py
@@ -0,0 +1,9 @@
+_base_ = [
+    '../_base_/models/pspnet_unet_s5-d16.py', '../_base_/datasets/stare.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (128, 128)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    test_cfg=dict(crop_size=(128, 128), stride=(85, 85)))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
new file mode 100644
index 0000000..69a4bba
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
@@ -0,0 +1,6 @@
+_base_ = './unet-s5-d16_pspnet_4xb4-40k_chase-db1-128x128.py'
+model = dict(
+    decode_head=dict(loss_decode=[
+        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
+        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
+    ]))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
new file mode 100644
index 0000000..1abbd53
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
@@ -0,0 +1,6 @@
+_base_ = './unet-s5-d16_pspnet_4xb4-40k_drive-64x64.py'
+model = dict(
+    decode_head=dict(loss_decode=[
+        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
+        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
+    ]))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
new file mode 100644
index 0000000..b3256d7
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
@@ -0,0 +1,6 @@
+_base_ = './unet-s5-d16_pspnet_4xb4-40k_hrf-256x256.py'
+model = dict(
+    decode_head=dict(loss_decode=[
+        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
+        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
+    ]))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
new file mode 100644
index 0000000..82aa3da
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
@@ -0,0 +1,6 @@
+_base_ = './unet-s5-d16_pspnet_4xb4-40k_stare-128x128.py'
+model = dict(
+    decode_head=dict(loss_decode=[
+        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
+        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
+    ]))
diff --git a/mmsegmentation/configs/unet/unet_s5-d16_deeplabv3_4xb4-40k_chase-db1-128x128.py b/mmsegmentation/configs/unet/unet_s5-d16_deeplabv3_4xb4-40k_chase-db1-128x128.py
new file mode 100644
index 0000000..82494f3
--- /dev/null
+++ b/mmsegmentation/configs/unet/unet_s5-d16_deeplabv3_4xb4-40k_chase-db1-128x128.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/deeplabv3_unet_s5-d16.py',
+    '../_base_/datasets/chase_db1.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (128, 128)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    test_cfg=dict(crop_size=(128, 128), stride=(85, 85)))
diff --git a/mmsegmentation/configs/upernet/README.md b/mmsegmentation/configs/upernet/README.md
new file mode 100644
index 0000000..c2babbd
--- /dev/null
+++ b/mmsegmentation/configs/upernet/README.md
@@ -0,0 +1,68 @@
+# UPerNet
+
+> [Unified Perceptual Parsing for Scene Understanding](https://arxiv.org/pdf/1807.10221.pdf)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/CSAILVision/unifiedparsing">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Humans recognize the visual world at multiple levels: we effortlessly categorize scenes and detect objects inside, while also identifying the textures and surfaces of the objects along with their different compositional parts. In this paper, we study a new task called Unified Perceptual Parsing, which requires the machine vision systems to recognize as many visual concepts as possible from a given image. A multi-task framework called UPerNet and a training strategy are developed to learn from heterogeneous image annotations. We benchmark our framework on Unified Perceptual Parsing and show that it is able to effectively segment a wide range of concepts from images. The trained networks are further applied to discover visual knowledge in natural scenes. Models are available at [this https URL](https://github.com/CSAILVision/unifiedparsing).
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142903077-44e8e0da-7276-4bda-bd2b-0df1680ca845.png" width="70%"/>
+</div>
+
+## Results and models
+
+### Cityscapes
+
+| Method  | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                        | download                                                                                                                                                                                                                                                                                                                                           |
+| ------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ----------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UPerNet | R-50     | 512x1024  |   40000 | 6.4      | 4.25           | V100   | 77.10 |         78.37 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r50_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x1024_40k_cityscapes/upernet_r50_512x1024_40k_cityscapes_20200605_094827-aa54cb54.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x1024_40k_cityscapes/upernet_r50_512x1024_40k_cityscapes_20200605_094827.log.json)     |
+| UPerNet | R-101    | 512x1024  |   40000 | 7.4      | 3.79           | V100   | 78.69 |         80.11 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r101_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x1024_40k_cityscapes/upernet_r101_512x1024_40k_cityscapes_20200605_094933-ebce3b10.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x1024_40k_cityscapes/upernet_r101_512x1024_40k_cityscapes_20200605_094933.log.json) |
+| UPerNet | R-50     | 769x769   |   40000 | 7.2      | 1.76           | V100   | 77.98 |         79.70 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r50_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_769x769_40k_cityscapes/upernet_r50_769x769_40k_cityscapes_20200530_033048-92d21539.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_769x769_40k_cityscapes/upernet_r50_769x769_40k_cityscapes_20200530_033048.log.json)         |
+| UPerNet | R-101    | 769x769   |   40000 | 8.4      | 1.56           | V100   | 79.03 |         80.77 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r101_4xb2-40k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_769x769_40k_cityscapes/upernet_r101_769x769_40k_cityscapes_20200530_040819-83c95d01.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_769x769_40k_cityscapes/upernet_r101_769x769_40k_cityscapes_20200530_040819.log.json)     |
+| UPerNet | R-50     | 512x1024  |   80000 | -        | -              | V100   | 78.19 |         79.19 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r50_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x1024_80k_cityscapes/upernet_r50_512x1024_80k_cityscapes_20200607_052207-848beca8.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x1024_80k_cityscapes/upernet_r50_512x1024_80k_cityscapes_20200607_052207.log.json)     |
+| UPerNet | R-101    | 512x1024  |   80000 | -        | -              | V100   | 79.40 |         80.46 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r101_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x1024_80k_cityscapes/upernet_r101_512x1024_80k_cityscapes_20200607_002403-f05f2345.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x1024_80k_cityscapes/upernet_r101_512x1024_80k_cityscapes_20200607_002403.log.json) |
+| UPerNet | R-50     | 769x769   |   80000 | -        | -              | V100   | 79.39 |         80.92 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r50_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_769x769_80k_cityscapes/upernet_r50_769x769_80k_cityscapes_20200607_005107-82ae7d15.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_769x769_80k_cityscapes/upernet_r50_769x769_80k_cityscapes_20200607_005107.log.json)         |
+| UPerNet | R-101    | 769x769   |   80000 | -        | -              | V100   | 80.10 |         81.49 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r101_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_769x769_80k_cityscapes/upernet_r101_769x769_80k_cityscapes_20200607_001014-082fc334.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_769x769_80k_cityscapes/upernet_r101_769x769_80k_cityscapes_20200607_001014.log.json)     |
+
+### ADE20K
+
+| Method  | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                    | download                                                                                                                                                                                                                                                                                                                           |
+| ------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UPerNet | R-50     | 512x512   |   80000 | 8.1      | 23.40          | V100   | 40.70 |         41.81 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r50_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_80k_ade20k/upernet_r50_512x512_80k_ade20k_20200614_144127-ecc8377b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_80k_ade20k/upernet_r50_512x512_80k_ade20k_20200614_144127.log.json)         |
+| UPerNet | R-101    | 512x512   |   80000 | 9.1      | 20.34          | V100   | 42.91 |         43.96 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r101_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_80k_ade20k/upernet_r101_512x512_80k_ade20k_20200614_185117-32e4db94.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_80k_ade20k/upernet_r101_512x512_80k_ade20k_20200614_185117.log.json)     |
+| UPerNet | R-50     | 512x512   |  160000 | -        | -              | V100   | 42.05 |         42.78 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r50_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_160k_ade20k/upernet_r50_512x512_160k_ade20k_20200615_184328-8534de8d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_160k_ade20k/upernet_r50_512x512_160k_ade20k_20200615_184328.log.json)     |
+| UPerNet | R-101    | 512x512   |  160000 | -        | -              | V100   | 43.82 |         44.85 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r101_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_160k_ade20k/upernet_r101_512x512_160k_ade20k_20200615_161951-91b32684.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_160k_ade20k/upernet_r101_512x512_160k_ade20k_20200615_161951.log.json) |
+
+### Pascal VOC 2012 + Aug
+
+| Method  | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                     | download                                                                                                                                                                                                                                                                                                                               |
+| ------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UPerNet | R-50     | 512x512   |   20000 | 6.4      | 23.17          | V100   | 74.82 |         76.35 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r50_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_20k_voc12aug/upernet_r50_512x512_20k_voc12aug_20200617_165330-5b5890a7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_20k_voc12aug/upernet_r50_512x512_20k_voc12aug_20200617_165330.log.json)     |
+| UPerNet | R-101    | 512x512   |   20000 | 7.5      | 19.98          | V100   | 77.10 |         78.29 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r101_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_20k_voc12aug/upernet_r101_512x512_20k_voc12aug_20200617_165629-f14e7f27.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_20k_voc12aug/upernet_r101_512x512_20k_voc12aug_20200617_165629.log.json) |
+| UPerNet | R-50     | 512x512   |   40000 | -        | -              | V100   | 75.92 |         77.44 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r50_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_40k_voc12aug/upernet_r50_512x512_40k_voc12aug_20200613_162257-ca9bcc6b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_40k_voc12aug/upernet_r50_512x512_40k_voc12aug_20200613_162257.log.json)     |
+| UPerNet | R-101    | 512x512   |   40000 | -        | -              | V100   | 77.43 |         78.56 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r101_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_40k_voc12aug/upernet_r101_512x512_40k_voc12aug_20200613_163549-e26476ac.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_40k_voc12aug/upernet_r101_512x512_40k_voc12aug_20200613_163549.log.json) |
+
+## Citation
+
+```bibtex
+@inproceedings{xiao2018unified,
+  title={Unified perceptual parsing for scene understanding},
+  author={Xiao, Tete and Liu, Yingcheng and Zhou, Bolei and Jiang, Yuning and Sun, Jian},
+  booktitle={Proceedings of the European Conference on Computer Vision (ECCV)},
+  pages={418--434},
+  year={2018}
+}
+```
diff --git a/mmsegmentation/configs/upernet/metafile.yaml b/mmsegmentation/configs/upernet/metafile.yaml
new file mode 100644
index 0000000..f6ad818
--- /dev/null
+++ b/mmsegmentation/configs/upernet/metafile.yaml
@@ -0,0 +1,391 @@
+Collections:
+- Name: UPerNet
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - Cityscapes
+    - ADE20K
+    - Pascal VOC 2012 + Aug
+  Paper:
+    Title: Unified Perceptual Parsing for Scene Understanding
+    URL: https://arxiv.org/pdf/1807.10221.pdf
+  README: configs/upernet/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: upernet_r50_4xb2-40k_cityscapes-512x1024
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.1
+      mIoU(ms+flip): 78.37
+  Config: configs/upernet/upernet_r50_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50
+    - UPerNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.4
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x1024_40k_cityscapes/upernet_r50_512x1024_40k_cityscapes_20200605_094827-aa54cb54.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x1024_40k_cityscapes/upernet_r50_512x1024_40k_cityscapes_20200605_094827.log.json
+  Paper:
+    Title: Unified Perceptual Parsing for Scene Understanding
+    URL: https://arxiv.org/pdf/1807.10221.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
+  Framework: PyTorch
+- Name: upernet_r101_4xb2-40k_cityscapes-512x1024
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.69
+      mIoU(ms+flip): 80.11
+  Config: configs/upernet/upernet_r101_4xb2-40k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101
+    - UPerNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 7.4
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x1024_40k_cityscapes/upernet_r101_512x1024_40k_cityscapes_20200605_094933-ebce3b10.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x1024_40k_cityscapes/upernet_r101_512x1024_40k_cityscapes_20200605_094933.log.json
+  Paper:
+    Title: Unified Perceptual Parsing for Scene Understanding
+    URL: https://arxiv.org/pdf/1807.10221.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
+  Framework: PyTorch
+- Name: upernet_r50_4xb2-40k_cityscapes-769x769
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 77.98
+      mIoU(ms+flip): 79.7
+  Config: configs/upernet/upernet_r50_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50
+    - UPerNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 7.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_769x769_40k_cityscapes/upernet_r50_769x769_40k_cityscapes_20200530_033048-92d21539.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_769x769_40k_cityscapes/upernet_r50_769x769_40k_cityscapes_20200530_033048.log.json
+  Paper:
+    Title: Unified Perceptual Parsing for Scene Understanding
+    URL: https://arxiv.org/pdf/1807.10221.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
+  Framework: PyTorch
+- Name: upernet_r101_4xb2-40k_cityscapes-769x769
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.03
+      mIoU(ms+flip): 80.77
+  Config: configs/upernet/upernet_r101_4xb2-40k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101
+    - UPerNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.4
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_769x769_40k_cityscapes/upernet_r101_769x769_40k_cityscapes_20200530_040819-83c95d01.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_769x769_40k_cityscapes/upernet_r101_769x769_40k_cityscapes_20200530_040819.log.json
+  Paper:
+    Title: Unified Perceptual Parsing for Scene Understanding
+    URL: https://arxiv.org/pdf/1807.10221.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
+  Framework: PyTorch
+- Name: upernet_r50_4xb2-80k_cityscapes-512x1024
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 78.19
+      mIoU(ms+flip): 79.19
+  Config: configs/upernet/upernet_r50_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50
+    - UPerNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x1024_80k_cityscapes/upernet_r50_512x1024_80k_cityscapes_20200607_052207-848beca8.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x1024_80k_cityscapes/upernet_r50_512x1024_80k_cityscapes_20200607_052207.log.json
+  Paper:
+    Title: Unified Perceptual Parsing for Scene Understanding
+    URL: https://arxiv.org/pdf/1807.10221.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
+  Framework: PyTorch
+- Name: upernet_r101_4xb2-80k_cityscapes-512x1024
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.4
+      mIoU(ms+flip): 80.46
+  Config: configs/upernet/upernet_r101_4xb2-80k_cityscapes-512x1024.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101
+    - UPerNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x1024_80k_cityscapes/upernet_r101_512x1024_80k_cityscapes_20200607_002403-f05f2345.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x1024_80k_cityscapes/upernet_r101_512x1024_80k_cityscapes_20200607_002403.log.json
+  Paper:
+    Title: Unified Perceptual Parsing for Scene Understanding
+    URL: https://arxiv.org/pdf/1807.10221.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
+  Framework: PyTorch
+- Name: upernet_r50_4xb2-80k_cityscapes-769x769
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 79.39
+      mIoU(ms+flip): 80.92
+  Config: configs/upernet/upernet_r50_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-50
+    - UPerNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_769x769_80k_cityscapes/upernet_r50_769x769_80k_cityscapes_20200607_005107-82ae7d15.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_769x769_80k_cityscapes/upernet_r50_769x769_80k_cityscapes_20200607_005107.log.json
+  Paper:
+    Title: Unified Perceptual Parsing for Scene Understanding
+    URL: https://arxiv.org/pdf/1807.10221.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
+  Framework: PyTorch
+- Name: upernet_r101_4xb2-80k_cityscapes-769x769
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Cityscapes
+    Metrics:
+      mIoU: 80.1
+      mIoU(ms+flip): 81.49
+  Config: configs/upernet/upernet_r101_4xb2-80k_cityscapes-769x769.py
+  Metadata:
+    Training Data: Cityscapes
+    Batch Size: 8
+    Architecture:
+    - R-101
+    - UPerNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_769x769_80k_cityscapes/upernet_r101_769x769_80k_cityscapes_20200607_001014-082fc334.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_769x769_80k_cityscapes/upernet_r101_769x769_80k_cityscapes_20200607_001014.log.json
+  Paper:
+    Title: Unified Perceptual Parsing for Scene Understanding
+    URL: https://arxiv.org/pdf/1807.10221.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
+  Framework: PyTorch
+- Name: upernet_r50_4xb4-80k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 40.7
+      mIoU(ms+flip): 41.81
+  Config: configs/upernet/upernet_r50_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50
+    - UPerNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 8.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_80k_ade20k/upernet_r50_512x512_80k_ade20k_20200614_144127-ecc8377b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_80k_ade20k/upernet_r50_512x512_80k_ade20k_20200614_144127.log.json
+  Paper:
+    Title: Unified Perceptual Parsing for Scene Understanding
+    URL: https://arxiv.org/pdf/1807.10221.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
+  Framework: PyTorch
+- Name: upernet_r101_4xb4-80k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.91
+      mIoU(ms+flip): 43.96
+  Config: configs/upernet/upernet_r101_4xb4-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101
+    - UPerNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 9.1
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_80k_ade20k/upernet_r101_512x512_80k_ade20k_20200614_185117-32e4db94.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_80k_ade20k/upernet_r101_512x512_80k_ade20k_20200614_185117.log.json
+  Paper:
+    Title: Unified Perceptual Parsing for Scene Understanding
+    URL: https://arxiv.org/pdf/1807.10221.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
+  Framework: PyTorch
+- Name: upernet_r50_4xb4-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.05
+      mIoU(ms+flip): 42.78
+  Config: configs/upernet/upernet_r50_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-50
+    - UPerNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_160k_ade20k/upernet_r50_512x512_160k_ade20k_20200615_184328-8534de8d.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_160k_ade20k/upernet_r50_512x512_160k_ade20k_20200615_184328.log.json
+  Paper:
+    Title: Unified Perceptual Parsing for Scene Understanding
+    URL: https://arxiv.org/pdf/1807.10221.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
+  Framework: PyTorch
+- Name: upernet_r101_4xb4-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 43.82
+      mIoU(ms+flip): 44.85
+  Config: configs/upernet/upernet_r101_4xb4-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - R-101
+    - UPerNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_160k_ade20k/upernet_r101_512x512_160k_ade20k_20200615_161951-91b32684.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_160k_ade20k/upernet_r101_512x512_160k_ade20k_20200615_161951.log.json
+  Paper:
+    Title: Unified Perceptual Parsing for Scene Understanding
+    URL: https://arxiv.org/pdf/1807.10221.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
+  Framework: PyTorch
+- Name: upernet_r50_4xb4-20k_voc12aug-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 74.82
+      mIoU(ms+flip): 76.35
+  Config: configs/upernet/upernet_r50_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50
+    - UPerNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 6.4
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_20k_voc12aug/upernet_r50_512x512_20k_voc12aug_20200617_165330-5b5890a7.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_20k_voc12aug/upernet_r50_512x512_20k_voc12aug_20200617_165330.log.json
+  Paper:
+    Title: Unified Perceptual Parsing for Scene Understanding
+    URL: https://arxiv.org/pdf/1807.10221.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
+  Framework: PyTorch
+- Name: upernet_r101_4xb4-20k_voc12aug-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 77.1
+      mIoU(ms+flip): 78.29
+  Config: configs/upernet/upernet_r101_4xb4-20k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101
+    - UPerNet
+    Training Resources: 4x V100 GPUS
+    Memory (GB): 7.5
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_20k_voc12aug/upernet_r101_512x512_20k_voc12aug_20200617_165629-f14e7f27.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_20k_voc12aug/upernet_r101_512x512_20k_voc12aug_20200617_165629.log.json
+  Paper:
+    Title: Unified Perceptual Parsing for Scene Understanding
+    URL: https://arxiv.org/pdf/1807.10221.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
+  Framework: PyTorch
+- Name: upernet_r50_4xb4-40k_voc12aug-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 75.92
+      mIoU(ms+flip): 77.44
+  Config: configs/upernet/upernet_r50_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-50
+    - UPerNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_40k_voc12aug/upernet_r50_512x512_40k_voc12aug_20200613_162257-ca9bcc6b.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_40k_voc12aug/upernet_r50_512x512_40k_voc12aug_20200613_162257.log.json
+  Paper:
+    Title: Unified Perceptual Parsing for Scene Understanding
+    URL: https://arxiv.org/pdf/1807.10221.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
+  Framework: PyTorch
+- Name: upernet_r101_4xb4-40k_voc12aug-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: Pascal VOC 2012 + Aug
+    Metrics:
+      mIoU: 77.43
+      mIoU(ms+flip): 78.56
+  Config: configs/upernet/upernet_r101_4xb4-40k_voc12aug-512x512.py
+  Metadata:
+    Training Data: Pascal VOC 2012 + Aug
+    Batch Size: 16
+    Architecture:
+    - R-101
+    - UPerNet
+    Training Resources: 4x V100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_40k_voc12aug/upernet_r101_512x512_40k_voc12aug_20200613_163549-e26476ac.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_40k_voc12aug/upernet_r101_512x512_40k_voc12aug_20200613_163549.log.json
+  Paper:
+    Title: Unified Perceptual Parsing for Scene Understanding
+    URL: https://arxiv.org/pdf/1807.10221.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/upernet/upernet_r101_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/upernet/upernet_r101_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..8f5f6ae
--- /dev/null
+++ b/mmsegmentation/configs/upernet/upernet_r101_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './upernet_r50_4xb2-40k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/upernet/upernet_r101_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/upernet/upernet_r101_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..28b5d3e
--- /dev/null
+++ b/mmsegmentation/configs/upernet/upernet_r101_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './upernet_r50_4xb2-40k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/upernet/upernet_r101_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/upernet/upernet_r101_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..cafd8a2
--- /dev/null
+++ b/mmsegmentation/configs/upernet/upernet_r101_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,2 @@
+_base_ = './upernet_r50_4xb2-80k_cityscapes-512x1024.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/upernet/upernet_r101_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/upernet/upernet_r101_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..e175720
--- /dev/null
+++ b/mmsegmentation/configs/upernet/upernet_r101_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,2 @@
+_base_ = './upernet_r50_4xb2-80k_cityscapes-769x769.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/upernet/upernet_r101_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/upernet/upernet_r101_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..7a61527
--- /dev/null
+++ b/mmsegmentation/configs/upernet/upernet_r101_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './upernet_r50_4xb4-160k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/upernet/upernet_r101_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/upernet/upernet_r101_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..be8f084
--- /dev/null
+++ b/mmsegmentation/configs/upernet/upernet_r101_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './upernet_r50_4xb4-20k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/upernet/upernet_r101_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/upernet/upernet_r101_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..db1d976
--- /dev/null
+++ b/mmsegmentation/configs/upernet/upernet_r101_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './upernet_r50_4xb4-40k_voc12aug-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/upernet/upernet_r101_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/upernet/upernet_r101_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..84549a4
--- /dev/null
+++ b/mmsegmentation/configs/upernet/upernet_r101_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,2 @@
+_base_ = './upernet_r50_4xb4-80k_ade20k-512x512.py'
+model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/upernet/upernet_r18_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/upernet/upernet_r18_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..dbff0e7
--- /dev/null
+++ b/mmsegmentation/configs/upernet/upernet_r18_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,6 @@
+_base_ = './upernet_r50_4xb2-40k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='open-mmlab://resnet18_v1c',
+    backbone=dict(depth=18),
+    decode_head=dict(in_channels=[64, 128, 256, 512]),
+    auxiliary_head=dict(in_channels=256))
diff --git a/mmsegmentation/configs/upernet/upernet_r18_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/upernet/upernet_r18_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..dee6349
--- /dev/null
+++ b/mmsegmentation/configs/upernet/upernet_r18_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,6 @@
+_base_ = './upernet_r50_4xb2-80k_cityscapes-512x1024.py'
+model = dict(
+    pretrained='open-mmlab://resnet18_v1c',
+    backbone=dict(depth=18),
+    decode_head=dict(in_channels=[64, 128, 256, 512]),
+    auxiliary_head=dict(in_channels=256))
diff --git a/mmsegmentation/configs/upernet/upernet_r18_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/upernet/upernet_r18_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..9ac6c35
--- /dev/null
+++ b/mmsegmentation/configs/upernet/upernet_r18_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,9 @@
+_base_ = [
+    '../_base_/models/upernet_r50.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+model = dict(
+    pretrained='open-mmlab://resnet18_v1c',
+    backbone=dict(depth=18),
+    decode_head=dict(in_channels=[64, 128, 256, 512], num_classes=150),
+    auxiliary_head=dict(in_channels=256, num_classes=150))
diff --git a/mmsegmentation/configs/upernet/upernet_r18_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/upernet/upernet_r18_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..5cae4f5
--- /dev/null
+++ b/mmsegmentation/configs/upernet/upernet_r18_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/upernet_r50.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_20k.py'
+]
+model = dict(
+    pretrained='open-mmlab://resnet18_v1c',
+    backbone=dict(depth=18),
+    decode_head=dict(in_channels=[64, 128, 256, 512], num_classes=21),
+    auxiliary_head=dict(in_channels=256, num_classes=21))
diff --git a/mmsegmentation/configs/upernet/upernet_r18_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/upernet/upernet_r18_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..652ded7
--- /dev/null
+++ b/mmsegmentation/configs/upernet/upernet_r18_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/upernet_r50.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+model = dict(
+    pretrained='open-mmlab://resnet18_v1c',
+    backbone=dict(depth=18),
+    decode_head=dict(in_channels=[64, 128, 256, 512], num_classes=21),
+    auxiliary_head=dict(in_channels=256, num_classes=21))
diff --git a/mmsegmentation/configs/upernet/upernet_r18_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/upernet/upernet_r18_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..1a7956d
--- /dev/null
+++ b/mmsegmentation/configs/upernet/upernet_r18_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,9 @@
+_base_ = [
+    '../_base_/models/upernet_r50.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+model = dict(
+    pretrained='open-mmlab://resnet18_v1c',
+    backbone=dict(depth=18),
+    decode_head=dict(in_channels=[64, 128, 256, 512], num_classes=150),
+    auxiliary_head=dict(in_channels=256, num_classes=150))
diff --git a/mmsegmentation/configs/upernet/upernet_r50_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/upernet/upernet_r50_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..4751fc1
--- /dev/null
+++ b/mmsegmentation/configs/upernet/upernet_r50_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/upernet_r50.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/upernet/upernet_r50_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/upernet/upernet_r50_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..6f05b6c
--- /dev/null
+++ b/mmsegmentation/configs/upernet/upernet_r50_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/upernet_r50.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/upernet/upernet_r50_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/upernet/upernet_r50_4xb2-80k_cityscapes-512x1024.py
new file mode 100644
index 0000000..f3488c6
--- /dev/null
+++ b/mmsegmentation/configs/upernet/upernet_r50_4xb2-80k_cityscapes-512x1024.py
@@ -0,0 +1,7 @@
+_base_ = [
+    '../_base_/models/upernet_r50.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/upernet/upernet_r50_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/upernet/upernet_r50_4xb2-80k_cityscapes-769x769.py
new file mode 100644
index 0000000..6a8f48e
--- /dev/null
+++ b/mmsegmentation/configs/upernet/upernet_r50_4xb2-80k_cityscapes-769x769.py
@@ -0,0 +1,12 @@
+_base_ = [
+    '../_base_/models/upernet_r50.py',
+    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (769, 769)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(align_corners=True),
+    auxiliary_head=dict(align_corners=True),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/upernet/upernet_r50_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/upernet/upernet_r50_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..5d15b2a
--- /dev/null
+++ b/mmsegmentation/configs/upernet/upernet_r50_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/upernet_r50.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/upernet/upernet_r50_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/upernet/upernet_r50_4xb4-20k_voc12aug-512x512.py
new file mode 100644
index 0000000..9e96b4e
--- /dev/null
+++ b/mmsegmentation/configs/upernet/upernet_r50_4xb4-20k_voc12aug-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/upernet_r50.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_20k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/upernet/upernet_r50_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/upernet/upernet_r50_4xb4-40k_voc12aug-512x512.py
new file mode 100644
index 0000000..cada949
--- /dev/null
+++ b/mmsegmentation/configs/upernet/upernet_r50_4xb4-40k_voc12aug-512x512.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../_base_/models/upernet_r50.py',
+    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_40k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=21),
+    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/upernet/upernet_r50_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/upernet/upernet_r50_4xb4-80k_ade20k-512x512.py
new file mode 100644
index 0000000..322d5d8
--- /dev/null
+++ b/mmsegmentation/configs/upernet/upernet_r50_4xb4-80k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = [
+    '../_base_/models/upernet_r50.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/vit/README.md b/mmsegmentation/configs/vit/README.md
new file mode 100644
index 0000000..f75326e
--- /dev/null
+++ b/mmsegmentation/configs/vit/README.md
@@ -0,0 +1,70 @@
+# Vision Transformer
+
+> [An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale](https://arxiv.org/pdf/2010.11929.pdf)
+
+## Introduction
+
+<!-- [BACKBONE] -->
+
+<a href="https://github.com/google-research/vision_transformer">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+While the Transformer architecture has become the de-facto standard for natural language processing tasks, its applications to computer vision remain limited. In vision, attention is either applied in conjunction with convolutional networks, or used to replace certain components of convolutional networks while keeping their overall structure in place. We show that this reliance on CNNs is not necessary and a pure transformer applied directly to sequences of image patches can perform very well on image classification tasks. When pre-trained on large amounts of data and transferred to multiple mid-sized or small image recognition benchmarks (ImageNet, CIFAR-100, VTAB, etc.), Vision Transformer (ViT) attains excellent results compared to state-of-the-art convolutional networks while requiring substantially fewer computational resources to train.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/142903144-f80a12cc-8698-48ab-843c-49dedf558121.png" width="70%"/>
+</div>
+
+## Usage
+
+To use other repositories' pre-trained models, it is necessary to convert keys.
+
+We provide a script [`vit2mmseg.py`](../../tools/model_converters/vit2mmseg.py) in the tools directory to convert the key of models from [timm](https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/vision_transformer.py) to MMSegmentation style.
+
+```shell
+python tools/model_converters/vit2mmseg.py ${PRETRAIN_PATH} ${STORE_PATH}
+```
+
+E.g.
+
+```shell
+python tools/model_converters/vit2mmseg.py https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-vitjx/jx_vit_base_p16_224-80ecf9dd.pth pretrain/jx_vit_base_p16_224-80ecf9dd.pth
+```
+
+This script convert model from `PRETRAIN_PATH` and store the converted model in `STORE_PATH`.
+
+## Results and models
+
+### ADE20K
+
+| Method  | Backbone          | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                               | download                                                                                                                                                                                                                                                                                                                   |
+| ------- | ----------------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UPerNet | ViT-B + MLN       | 512x512   |   80000 | 9.20     | 6.94           | V100   | 47.71 |         49.51 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_vit-b16_mln_upernet_8xb2-80k_ade20k-512x512.py)      | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_mln_512x512_80k_ade20k/upernet_vit-b16_mln_512x512_80k_ade20k_20210624_130547-0403cee1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_mln_512x512_80k_ade20k/20210624_130547.log.json)                |
+| UPerNet | ViT-B + MLN       | 512x512   |  160000 | 9.20     | 7.58           | V100   | 46.75 |         48.46 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py)     | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_mln_512x512_160k_ade20k/upernet_vit-b16_mln_512x512_160k_ade20k_20210624_130547-852fa768.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_mln_512x512_160k_ade20k/20210623_192432.log.json)             |
+| UPerNet | ViT-B + LN + MLN  | 512x512   |  160000 | 9.21     | 6.82           | V100   | 47.73 |         49.95 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_vit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_ln_mln_512x512_160k_ade20k/upernet_vit-b16_ln_mln_512x512_160k_ade20k_20210621_172828-f444c077.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_ln_mln_512x512_160k_ade20k/20210621_172828.log.json)    |
+| UPerNet | DeiT-S            | 512x512   |   80000 | 4.68     | 29.85          | V100   | 42.96 |         43.79 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_deit-s16_upernet_8xb2-80k_ade20k-512x512.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_512x512_80k_ade20k/upernet_deit-s16_512x512_80k_ade20k_20210624_095228-afc93ec2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_512x512_80k_ade20k/20210624_095228.log.json)                         |
+| UPerNet | DeiT-S            | 512x512   |  160000 | 4.68     | 29.19          | V100   | 42.87 |         43.79 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_deit-s16_upernet_8xb2-160k_ade20k-512x512.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_512x512_160k_ade20k/upernet_deit-s16_512x512_160k_ade20k_20210621_160903-5110d916.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_512x512_160k_ade20k/20210621_160903.log.json)                      |
+| UPerNet | DeiT-S + MLN      | 512x512   |  160000 | 5.69     | 11.18          | V100   | 43.82 |         45.07 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_deit-s16_mln_upernet_8xb2-160k_ade20k-512x512.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_mln_512x512_160k_ade20k/upernet_deit-s16_mln_512x512_160k_ade20k_20210621_161021-fb9a5dfb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_mln_512x512_160k_ade20k/20210621_161021.log.json)          |
+| UPerNet | DeiT-S + LN + MLN | 512x512   |  160000 | 5.69     | 12.39          | V100   | 43.52 |         45.01 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_deit-s16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_ln_mln_512x512_160k_ade20k/upernet_deit-s16_ln_mln_512x512_160k_ade20k_20210621_161021-c0cd652f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_ln_mln_512x512_160k_ade20k/20210621_161021.log.json) |
+| UPerNet | DeiT-B            | 512x512   |   80000 | 7.75     | 9.69           | V100   | 45.24 |         46.73 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_deit-b16_upernet_8xb2-80k_ade20k-512x512.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_512x512_80k_ade20k/upernet_deit-b16_512x512_80k_ade20k_20210624_130529-1e090789.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_512x512_80k_ade20k/20210624_130529.log.json)                         |
+| UPerNet | DeiT-B            | 512x512   |  160000 | 7.75     | 10.39          | V100   | 45.36 |         47.16 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_deit-b16_upernet_8xb2-160k_ade20k-512x512.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_512x512_160k_ade20k/upernet_deit-b16_512x512_160k_ade20k_20210621_180100-828705d7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_512x512_160k_ade20k/20210621_180100.log.json)                      |
+| UPerNet | DeiT-B + MLN      | 512x512   |  160000 | 9.21     | 7.78           | V100   | 45.46 |         47.16 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_deit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_mln_512x512_160k_ade20k/upernet_deit-b16_mln_512x512_160k_ade20k_20210621_191949-4e1450f3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_mln_512x512_160k_ade20k/20210621_191949.log.json)          |
+| UPerNet | DeiT-B + LN + MLN | 512x512   |  160000 | 9.21     | 7.75           | V100   | 45.37 |         47.23 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_deit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_ln_mln_512x512_160k_ade20k/upernet_deit-b16_ln_mln_512x512_160k_ade20k_20210623_153535-8a959c14.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_ln_mln_512x512_160k_ade20k/20210623_153535.log.json) |
+
+## Citation
+
+```bibtex
+@article{dosoViTskiy2020,
+  title={An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale},
+  author={DosoViTskiy, Alexey and Beyer, Lucas and Kolesnikov, Alexander and Weissenborn, Dirk and Zhai, Xiaohua and Unterthiner, Thomas and  Dehghani, Mostafa and Minderer, Matthias and Heigold, Georg and Gelly, Sylvain and Uszkoreit, Jakob and Houlsby, Neil},
+  journal={arXiv preprint arXiv:2010.11929},
+  year={2020}
+}
+```
diff --git a/mmsegmentation/configs/vit/metafile.yaml b/mmsegmentation/configs/vit/metafile.yaml
new file mode 100644
index 0000000..68e254a
--- /dev/null
+++ b/mmsegmentation/configs/vit/metafile.yaml
@@ -0,0 +1,265 @@
+Models:
+- Name: vit_vit-b16_mln_upernet_8xb2-80k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 47.71
+      mIoU(ms+flip): 49.51
+  Config: configs/vit/vit_vit-b16_mln_upernet_8xb2-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - ViT-B
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 9.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_mln_512x512_80k_ade20k/upernet_vit-b16_mln_512x512_80k_ade20k_20210624_130547-0403cee1.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_mln_512x512_80k_ade20k/20210624_130547.log.json
+  Paper:
+    Title: 'An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale'
+    URL: https://arxiv.org/pdf/2010.11929.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98
+  Framework: PyTorch
+- Name: vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 46.75
+      mIoU(ms+flip): 48.46
+  Config: configs/vit/vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - ViT-B
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 9.2
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_mln_512x512_160k_ade20k/upernet_vit-b16_mln_512x512_160k_ade20k_20210624_130547-852fa768.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_mln_512x512_160k_ade20k/20210623_192432.log.json
+  Paper:
+    Title: 'An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale'
+    URL: https://arxiv.org/pdf/2010.11929.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98
+  Framework: PyTorch
+- Name: vit_vit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 47.73
+      mIoU(ms+flip): 49.95
+  Config: configs/vit/vit_vit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - ViT-B
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 9.21
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_ln_mln_512x512_160k_ade20k/upernet_vit-b16_ln_mln_512x512_160k_ade20k_20210621_172828-f444c077.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_ln_mln_512x512_160k_ade20k/20210621_172828.log.json
+  Paper:
+    Title: 'An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale'
+    URL: https://arxiv.org/pdf/2010.11929.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98
+  Framework: PyTorch
+- Name: vit_deit-s16_upernet_8xb2-80k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.96
+      mIoU(ms+flip): 43.79
+  Config: configs/vit/vit_deit-s16_upernet_8xb2-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - DeiT-S
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 4.68
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_512x512_80k_ade20k/upernet_deit-s16_512x512_80k_ade20k_20210624_095228-afc93ec2.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_512x512_80k_ade20k/20210624_095228.log.json
+  Paper:
+    Title: 'An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale'
+    URL: https://arxiv.org/pdf/2010.11929.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98
+  Framework: PyTorch
+- Name: vit_deit-s16_upernet_8xb2-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 42.87
+      mIoU(ms+flip): 43.79
+  Config: configs/vit/vit_deit-s16_upernet_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - DeiT-S
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 4.68
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_512x512_160k_ade20k/upernet_deit-s16_512x512_160k_ade20k_20210621_160903-5110d916.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_512x512_160k_ade20k/20210621_160903.log.json
+  Paper:
+    Title: 'An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale'
+    URL: https://arxiv.org/pdf/2010.11929.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98
+  Framework: PyTorch
+- Name: vit_deit-s16_mln_upernet_8xb2-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 43.82
+      mIoU(ms+flip): 45.07
+  Config: configs/vit/vit_deit-s16_mln_upernet_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - DeiT-S
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 5.69
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_mln_512x512_160k_ade20k/upernet_deit-s16_mln_512x512_160k_ade20k_20210621_161021-fb9a5dfb.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_mln_512x512_160k_ade20k/20210621_161021.log.json
+  Paper:
+    Title: 'An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale'
+    URL: https://arxiv.org/pdf/2010.11929.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98
+  Framework: PyTorch
+- Name: vit_deit-s16-ln_mln_upernet_8xb2-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 43.52
+      mIoU(ms+flip): 45.01
+  Config: configs/vit/vit_deit-s16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - DeiT-S
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 5.69
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_ln_mln_512x512_160k_ade20k/upernet_deit-s16_ln_mln_512x512_160k_ade20k_20210621_161021-c0cd652f.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_ln_mln_512x512_160k_ade20k/20210621_161021.log.json
+  Paper:
+    Title: 'An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale'
+    URL: https://arxiv.org/pdf/2010.11929.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98
+  Framework: PyTorch
+- Name: vit_deit-b16_upernet_8xb2-80k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 45.24
+      mIoU(ms+flip): 46.73
+  Config: configs/vit/vit_deit-b16_upernet_8xb2-80k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - DeiT-B
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 7.75
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_512x512_80k_ade20k/upernet_deit-b16_512x512_80k_ade20k_20210624_130529-1e090789.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_512x512_80k_ade20k/20210624_130529.log.json
+  Paper:
+    Title: 'An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale'
+    URL: https://arxiv.org/pdf/2010.11929.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98
+  Framework: PyTorch
+- Name: vit_deit-b16_upernet_8xb2-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 45.36
+      mIoU(ms+flip): 47.16
+  Config: configs/vit/vit_deit-b16_upernet_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - DeiT-B
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 7.75
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_512x512_160k_ade20k/upernet_deit-b16_512x512_160k_ade20k_20210621_180100-828705d7.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_512x512_160k_ade20k/20210621_180100.log.json
+  Paper:
+    Title: 'An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale'
+    URL: https://arxiv.org/pdf/2010.11929.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98
+  Framework: PyTorch
+- Name: vit_deit-b16_mln_upernet_8xb2-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 45.46
+      mIoU(ms+flip): 47.16
+  Config: configs/vit/vit_deit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - DeiT-B
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 9.21
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_mln_512x512_160k_ade20k/upernet_deit-b16_mln_512x512_160k_ade20k_20210621_191949-4e1450f3.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_mln_512x512_160k_ade20k/20210621_191949.log.json
+  Paper:
+    Title: 'An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale'
+    URL: https://arxiv.org/pdf/2010.11929.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98
+  Framework: PyTorch
+- Name: vit_deit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512
+  In Collection: UPerNet
+  Results:
+    Task: Semantic Segmentation
+    Dataset: ADE20K
+    Metrics:
+      mIoU: 45.37
+      mIoU(ms+flip): 47.23
+  Config: configs/vit/vit_deit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
+  Metadata:
+    Training Data: ADE20K
+    Batch Size: 16
+    Architecture:
+    - DeiT-B
+    - UPerNet
+    Training Resources: 8x V100 GPUS
+    Memory (GB): 9.21
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_ln_mln_512x512_160k_ade20k/upernet_deit-b16_ln_mln_512x512_160k_ade20k_20210623_153535-8a959c14.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_ln_mln_512x512_160k_ade20k/20210623_153535.log.json
+  Paper:
+    Title: 'An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale'
+    URL: https://arxiv.org/pdf/2010.11929.pdf
+  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/vit/vit_deit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/vit/vit_deit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..39d1c54
--- /dev/null
+++ b/mmsegmentation/configs/vit/vit_deit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,5 @@
+_base_ = './vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py'
+
+model = dict(
+    pretrained='pretrain/deit_base_patch16_224-b5f2ef4d.pth',
+    backbone=dict(drop_path_rate=0.1, final_norm=True))
diff --git a/mmsegmentation/configs/vit/vit_deit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/vit/vit_deit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..706673f
--- /dev/null
+++ b/mmsegmentation/configs/vit/vit_deit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,6 @@
+_base_ = './vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py'
+
+model = dict(
+    pretrained='pretrain/deit_base_patch16_224-b5f2ef4d.pth',
+    backbone=dict(drop_path_rate=0.1),
+)
diff --git a/mmsegmentation/configs/vit/vit_deit-b16_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/vit/vit_deit-b16_upernet_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..23a2358
--- /dev/null
+++ b/mmsegmentation/configs/vit/vit_deit-b16_upernet_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,6 @@
+_base_ = './vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py'
+
+model = dict(
+    pretrained='pretrain/deit_base_patch16_224-b5f2ef4d.pth',
+    backbone=dict(drop_path_rate=0.1),
+    neck=None)
diff --git a/mmsegmentation/configs/vit/vit_deit-b16_upernet_8xb2-80k_ade20k-512x512.py b/mmsegmentation/configs/vit/vit_deit-b16_upernet_8xb2-80k_ade20k-512x512.py
new file mode 100644
index 0000000..4c8bc93
--- /dev/null
+++ b/mmsegmentation/configs/vit/vit_deit-b16_upernet_8xb2-80k_ade20k-512x512.py
@@ -0,0 +1,6 @@
+_base_ = './vit_vit-b16_mln_upernet_8xb2-80k_ade20k-512x512.py'
+
+model = dict(
+    pretrained='pretrain/deit_base_patch16_224-b5f2ef4d.pth',
+    backbone=dict(drop_path_rate=0.1),
+    neck=None)
diff --git a/mmsegmentation/configs/vit/vit_deit-s16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/vit/vit_deit-s16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..8e626fe
--- /dev/null
+++ b/mmsegmentation/configs/vit/vit_deit-s16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,9 @@
+_base_ = './vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py'
+
+model = dict(
+    pretrained='pretrain/deit_small_patch16_224-cd65a155.pth',
+    backbone=dict(
+        num_heads=6, embed_dims=384, drop_path_rate=0.1, final_norm=True),
+    decode_head=dict(num_classes=150, in_channels=[384, 384, 384, 384]),
+    neck=dict(in_channels=[384, 384, 384, 384], out_channels=384),
+    auxiliary_head=dict(num_classes=150, in_channels=384))
diff --git a/mmsegmentation/configs/vit/vit_deit-s16_mln_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/vit/vit_deit-s16_mln_upernet_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..9a69a89
--- /dev/null
+++ b/mmsegmentation/configs/vit/vit_deit-s16_mln_upernet_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,8 @@
+_base_ = './vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py'
+
+model = dict(
+    pretrained='pretrain/deit_small_patch16_224-cd65a155.pth',
+    backbone=dict(num_heads=6, embed_dims=384, drop_path_rate=0.1),
+    decode_head=dict(num_classes=150, in_channels=[384, 384, 384, 384]),
+    neck=dict(in_channels=[384, 384, 384, 384], out_channels=384),
+    auxiliary_head=dict(num_classes=150, in_channels=384))
diff --git a/mmsegmentation/configs/vit/vit_deit-s16_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/vit/vit_deit-s16_upernet_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..9ef699d
--- /dev/null
+++ b/mmsegmentation/configs/vit/vit_deit-s16_upernet_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,8 @@
+_base_ = './vit_vit-b16_mln_upernet_8xb2-80k_ade20k-512x512.py'
+
+model = dict(
+    pretrained='pretrain/deit_small_patch16_224-cd65a155.pth',
+    backbone=dict(num_heads=6, embed_dims=384, drop_path_rate=0.1),
+    decode_head=dict(num_classes=150, in_channels=[384, 384, 384, 384]),
+    neck=None,
+    auxiliary_head=dict(num_classes=150, in_channels=384))
diff --git a/mmsegmentation/configs/vit/vit_deit-s16_upernet_8xb2-80k_ade20k-512x512.py b/mmsegmentation/configs/vit/vit_deit-s16_upernet_8xb2-80k_ade20k-512x512.py
new file mode 100644
index 0000000..9ef699d
--- /dev/null
+++ b/mmsegmentation/configs/vit/vit_deit-s16_upernet_8xb2-80k_ade20k-512x512.py
@@ -0,0 +1,8 @@
+_base_ = './vit_vit-b16_mln_upernet_8xb2-80k_ade20k-512x512.py'
+
+model = dict(
+    pretrained='pretrain/deit_small_patch16_224-cd65a155.pth',
+    backbone=dict(num_heads=6, embed_dims=384, drop_path_rate=0.1),
+    decode_head=dict(num_classes=150, in_channels=[384, 384, 384, 384]),
+    neck=None,
+    auxiliary_head=dict(num_classes=150, in_channels=384))
diff --git a/mmsegmentation/configs/vit/vit_vit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/vit/vit_vit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..2dd81b4
--- /dev/null
+++ b/mmsegmentation/configs/vit/vit_vit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,45 @@
+_base_ = [
+    '../_base_/models/upernet_vit-b16_ln_mln.py',
+    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained='pretrain/vit_base_patch16_224.pth',
+    backbone=dict(drop_path_rate=0.1, final_norm=True),
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
+
+# AdamW optimizer, no weight decay for position embedding & layer norm
+# in backbone
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
+    paramwise_cfg=dict(
+        custom_keys={
+            'pos_embed': dict(decay_mult=0.),
+            'cls_token': dict(decay_mult=0.),
+            'norm': dict(decay_mult=0.)
+        }))
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        eta_min=0.0,
+        power=1.0,
+        begin=1500,
+        end=160000,
+        by_epoch=False,
+    )
+]
+
+# By default, models are trained on 8 GPUs with 2 images per GPU
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/vit/vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/vit/vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..1a7ec16
--- /dev/null
+++ b/mmsegmentation/configs/vit/vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py
@@ -0,0 +1,44 @@
+_base_ = [
+    '../_base_/models/upernet_vit-b16_ln_mln.py',
+    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_160k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained='pretrain/vit_base_patch16_224.pth',
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
+
+# AdamW optimizer, no weight decay for position embedding & layer norm
+# in backbone
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
+    paramwise_cfg=dict(
+        custom_keys={
+            'pos_embed': dict(decay_mult=0.),
+            'cls_token': dict(decay_mult=0.),
+            'norm': dict(decay_mult=0.)
+        }))
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        eta_min=0.0,
+        power=1.0,
+        begin=1500,
+        end=160000,
+        by_epoch=False,
+    )
+]
+
+# By default, models are trained on 8 GPUs with 2 images per GPU
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/vit/vit_vit-b16_mln_upernet_8xb2-80k_ade20k-512x512.py b/mmsegmentation/configs/vit/vit_vit-b16_mln_upernet_8xb2-80k_ade20k-512x512.py
new file mode 100644
index 0000000..ef73450
--- /dev/null
+++ b/mmsegmentation/configs/vit/vit_vit-b16_mln_upernet_8xb2-80k_ade20k-512x512.py
@@ -0,0 +1,44 @@
+_base_ = [
+    '../_base_/models/upernet_vit-b16_ln_mln.py',
+    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained='pretrain/vit_base_patch16_224.pth',
+    decode_head=dict(num_classes=150),
+    auxiliary_head=dict(num_classes=150))
+
+# AdamW optimizer, no weight decay for position embedding & layer norm
+# in backbone
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
+    paramwise_cfg=dict(
+        custom_keys={
+            'pos_embed': dict(decay_mult=0.),
+            'cls_token': dict(decay_mult=0.),
+            'norm': dict(decay_mult=0.)
+        }))
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        eta_min=0.0,
+        power=1.0,
+        begin=1500,
+        end=80000,
+        by_epoch=False,
+    )
+]
+
+# By default, models are trained on 8 GPUs with 2 images per GPU
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/vpd/README.md b/mmsegmentation/configs/vpd/README.md
new file mode 100644
index 0000000..e90085b
--- /dev/null
+++ b/mmsegmentation/configs/vpd/README.md
@@ -0,0 +1,50 @@
+# VPD
+
+> [Unleashing Text-to-Image Diffusion Models for Visual Perception](https://arxiv.org/abs/2303.02153)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href = "https://github.com/wl-zhao/VPD">Official Repo</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Diffusion models (DMs) have become the new trend of generative models and have demonstrated a powerful ability of conditional synthesis. Among those, text-to-image diffusion models pre-trained on large-scale image-text pairs are highly controllable by customizable prompts. Unlike the unconditional generative models that focus on low-level attributes and details, text-to-image diffusion models contain more high-level knowledge thanks to the vision-language pre-training. In this paper, we propose VPD (Visual Perception with a pre-trained Diffusion model), a new framework that exploits the semantic information of a pre-trained text-to-image diffusion model in visual perception tasks. Instead of using the pre-trained denoising autoencoder in a diffusion-based pipeline, we simply use it as a backbone and aim to study how to take full advantage of the learned knowledge. Specifically, we prompt the denoising decoder with proper textual inputs and refine the text features with an adapter, leading to a better alignment to the pre-trained stage and making the visual contents interact with the text prompts. We also propose to utilize the cross-attention maps between the visual features and the text features to provide explicit guidance. Compared with other pre-training methods, we show that vision-language pre-trained diffusion models can be faster adapted to downstream visual perception tasks using the proposed VPD. Extensive experiments on semantic segmentation, referring image segmentation and depth estimation demonstrates the effectiveness of our method. Notably, VPD attains 0.254 RMSE on NYUv2 depth estimation and 73.3% oIoU on RefCOCO-val referring image segmentation, establishing new records on these two benchmarks.
+
+<!-- [IMAGE] -->
+
+<div align=center>
+<img src="https://github.com/open-mmlab/mmsegmentation/assets/26127467/88f5752d-7fe2-4cb0-a284-8ee0680e29cd" width="80%"/>
+</div>
+
+## Usage
+
+To run training or inference with VPD model, please install the required packages via
+
+```sh
+pip install -r requirements/albu.txt
+pip install -r requirements/optional.txt
+```
+
+## Results and models
+
+### NYU
+
+| Method | Backbone              | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | RMSE  | d1    | d2    | d3    | REL   | log_10 | config                                                                                                      | download                                                                                                                                                                                                                     |
+| ------ | --------------------- | --------- | ------- | -------- | -------------- | ------ | ----- | ----- | ----- | ----- | ----- | ------ | ----------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| VPD    | Stable-Diffusion-v1-5 | 480x480   | 25000   | -        | -              | A100   | 0.253 | 0.964 | 0.995 | 0.999 | 0.069 | 0.030  | [config](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/vpd/vpd_sd_4xb8-25k_nyu-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vpd/vpd_sd_4xb8-25k_nyu-480x480_20230908-66144bc4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vpd/vpd_sd_4xb8-25k_nyu-480x480_20230908.json) |
+| VPD    | Stable-Diffusion-v1-5 | 512x512   | 25000   | -        | -              | A100   | 0.258 | 0.963 | 0.995 | 0.999 | 0.072 | 0.031  | [config](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/vpd/vpd_sd_4xb8-25k_nyu-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vpd/vpd_sd_4xb8-25k_nyu-512x512_20230918-60cefcff.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vpd/vpd_sd_4xb8-25k_nyu-512x512_20230918.json) |
+
+## Citation
+
+```bibtex
+@article{zhao2023unleashing,
+  title={Unleashing Text-to-Image Diffusion Models for Visual Perception},
+  author={Zhao, Wenliang and Rao, Yongming and Liu, Zuyan and Liu, Benlin and Zhou, Jie and Lu, Jiwen},
+  journal={ICCV},
+  year={2023}
+}
+```
diff --git a/mmsegmentation/configs/vpd/metafile.yaml b/mmsegmentation/configs/vpd/metafile.yaml
new file mode 100644
index 0000000..ccdc0e8
--- /dev/null
+++ b/mmsegmentation/configs/vpd/metafile.yaml
@@ -0,0 +1,56 @@
+Collections:
+- Name: VPD
+  License: Apache License 2.0
+  Metadata:
+    Training Data:
+    - NYU
+  Paper:
+    Title: Unleashing Text-to-Image Diffusion Models for Visual Perception
+    URL: https://arxiv.org/abs/2303.02153
+  README: configs/vpd/README.md
+  Frameworks:
+  - PyTorch
+Models:
+- Name: vpd_sd_4xb8-25k_nyu-480x480
+  In Collection: VPD
+  Results:
+    Task: Depth Estimation
+    Dataset: NYU
+    Metrics:
+      RMSE: 0.253
+  Config: configs/vpd/vpd_sd_4xb8-25k_nyu-480x480.py
+  Metadata:
+    Training Data: NYU
+    Batch Size: 32
+    Architecture:
+    - Stable-Diffusion
+    Training Resources: 8x A100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vpd/vpd_sd_4xb8-25k_nyu-480x480_20230908-66144bc4.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vpd/vpd_sd_4xb8-25k_nyu-480x480_20230908.json
+  Paper:
+    Title: 'High-Resolution Image Synthesis with Latent Diffusion Models'
+    URL: https://arxiv.org/abs/2112.10752
+  Code: https://github.com/open-mmlab/mmsegmentation/tree/main/mmseg/models/backbones/vpd.py#L333
+  Framework: PyTorch
+- Name: vpd_sd_4xb8-25k_nyu-512x512
+  In Collection: VPD
+  Alias: vpd_depth
+  Results:
+    Task: Depth Estimation
+    Dataset: NYU
+    Metrics:
+      RMSE: 0.258
+  Config: configs/vpd/vpd_sd_4xb8-25k_nyu-512x512.py
+  Metadata:
+    Training Data: NYU
+    Batch Size: 32
+    Architecture:
+    - Stable-Diffusion
+    Training Resources: 8x A100 GPUS
+  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vpd/vpd_sd_4xb8-25k_nyu-512x512_20230918-60cefcff.pth
+  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vpd/vpd_sd_4xb8-25k_nyu-512x512_20230918.json
+  Paper:
+    Title: 'High-Resolution Image Synthesis with Latent Diffusion Models'
+    URL: https://arxiv.org/abs/2112.10752
+  Code: https://github.com/open-mmlab/mmsegmentation/tree/main/mmseg/models/backbones/vpd.py#L333
+  Framework: PyTorch
diff --git a/mmsegmentation/configs/vpd/vpd_sd_4xb8-25k_nyu-480x480.py b/mmsegmentation/configs/vpd/vpd_sd_4xb8-25k_nyu-480x480.py
new file mode 100644
index 0000000..0d14d8d
--- /dev/null
+++ b/mmsegmentation/configs/vpd/vpd_sd_4xb8-25k_nyu-480x480.py
@@ -0,0 +1,38 @@
+_base_ = [
+    '../_base_/models/vpd_sd.py', '../_base_/datasets/nyu.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_25k.py'
+]
+
+crop_size = (480, 480)
+
+model = dict(
+    type='DepthEstimator',
+    data_preprocessor=dict(size=crop_size),
+    backbone=dict(
+        class_embed_path='https://download.openmmlab.com/mmsegmentation/'
+        'v0.5/vpd/nyu_class_embeddings.pth',
+        class_embed_select=True,
+        pad_shape=512,
+        unet_cfg=dict(use_attn=False),
+    ),
+    decode_head=dict(
+        type='VPDDepthHead',
+        in_channels=[320, 640, 1280, 1280],
+        max_depth=10,
+        fmap_border=(1, 1),
+    ),
+    test_cfg=dict(mode='slide_flip', crop_size=crop_size, stride=(160, 160)))
+
+default_hooks = dict(
+    checkpoint=dict(save_best='rmse', rule='less', max_keep_ckpts=1))
+
+# custom optimizer
+optim_wrapper = dict(
+    constructor='ForceDefaultOptimWrapperConstructor',
+    paramwise_cfg=dict(
+        bias_decay_mult=0,
+        force_default_settings=True,
+        custom_keys={
+            'backbone.encoder_vq': dict(lr_mult=0),
+            'backbone.unet': dict(lr_mult=0.01),
+        }))
diff --git a/mmsegmentation/configs/vpd/vpd_sd_4xb8-25k_nyu-512x512.py b/mmsegmentation/configs/vpd/vpd_sd_4xb8-25k_nyu-512x512.py
new file mode 100644
index 0000000..e89eb9c
--- /dev/null
+++ b/mmsegmentation/configs/vpd/vpd_sd_4xb8-25k_nyu-512x512.py
@@ -0,0 +1,37 @@
+_base_ = [
+    '../_base_/models/vpd_sd.py', '../_base_/datasets/nyu_512x512.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_25k.py'
+]
+
+crop_size = (512, 512)
+
+model = dict(
+    type='DepthEstimator',
+    data_preprocessor=dict(size=crop_size),
+    backbone=dict(
+        class_embed_path='https://download.openmmlab.com/mmsegmentation/'
+        'v0.5/vpd/nyu_class_embeddings.pth',
+        class_embed_select=True,
+        pad_shape=512,
+        unet_cfg=dict(use_attn=False),
+    ),
+    decode_head=dict(
+        type='VPDDepthHead',
+        in_channels=[320, 640, 1280, 1280],
+        max_depth=10,
+    ),
+    test_cfg=dict(mode='slide_flip', crop_size=crop_size, stride=(128, 128)))
+
+default_hooks = dict(
+    checkpoint=dict(save_best='rmse', rule='less', max_keep_ckpts=1))
+
+# custom optimizer
+optim_wrapper = dict(
+    constructor='ForceDefaultOptimWrapperConstructor',
+    paramwise_cfg=dict(
+        bias_decay_mult=0,
+        force_default_settings=True,
+        custom_keys={
+            'backbone.encoder_vq': dict(lr_mult=0),
+            'backbone.unet': dict(lr_mult=0.01),
+        }))
diff --git a/mmsegmentation/dataset-index.yml b/mmsegmentation/dataset-index.yml
new file mode 100644
index 0000000..30ff0ee
--- /dev/null
+++ b/mmsegmentation/dataset-index.yml
@@ -0,0 +1,80 @@
+openxlab: true
+ade20k:
+  dataset: OpenDataLab/ADE20K_2016
+  download_root: data
+  data_root: data/ade
+
+cityscapes:
+  dataset: OpenDataLab/CityScapes
+  download_root: data
+  data_root: data/cityscapes
+
+voc2012:
+  dataset: OpenDataLab/PASCAL_VOC2012
+  download_root: data
+  data_root: data/VOCdevkit/VOC2012
+
+cocostuff:
+  dataset: OpenDataLab/COCO-Stuff
+  download_root: data
+  data_root: data/coco_stuff164k
+
+mapillary:
+  dataset: OpenDataLab/Mapillary
+  download_root: data
+  data_root: data/mapillary
+
+pascal_context:
+  dataset: OpenDataLab/VOC2010
+  download_root: data
+  data_root: data/VOCdevkit/VOC2010
+
+isaid:
+  dataset: OpenDataLab/iSAID
+  download_root: data
+  data_root: data/iSAID
+
+isprs_potsdam:
+  dataset: OpenDataLab/ISPRS_Potsdam
+  download_root: data
+  data_root: data/potsdam
+
+loveda:
+  dataset: OpenDataLab/LoveDA
+  download_root: data
+  data_root: data/loveDA
+
+chase_db1:
+  dataset: OpenDataLab/CHASE_DB1
+  download_root: data
+  data_root: data/CHASE_DB1
+
+drive:
+  dataset: OpenDataLab/DRIVE
+  download_root: data
+  data_root: data/DRIVE
+
+hrf:
+  dataset: OpenDataLab/HRF
+  download_root: data
+  data_root: data/HRF
+
+stare:
+  dataset: OpenDataLab/STARE
+  download_root: data
+  data_root: data/STARE
+
+synapse:
+  dataset: OpenDataLab/SurgVisDom
+  download_root: data
+  data_root: data/synapse
+
+refuge:
+  dataset: OpenDataLab/REFUGE_Challenge
+  download_root: data
+  data_root: data/REFUGE
+
+lip:
+  dataset: OpenDataLab/LIP
+  download_root: data
+  data_root: data/LIP
diff --git a/mmsegmentation/demo/MMSegmentation_Tutorial.ipynb b/mmsegmentation/demo/MMSegmentation_Tutorial.ipynb
new file mode 100644
index 0000000..ac8601b
--- /dev/null
+++ b/mmsegmentation/demo/MMSegmentation_Tutorial.ipynb
@@ -0,0 +1,555 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "view-in-github"
+   },
+   "source": [
+    "<a href=\"https://colab.research.google.com/github/open-mmlab/mmsegmentation/blob/main/demo/MMSegmentation_Tutorial.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "FVmnaxFJvsb8"
+   },
+   "source": [
+    "# MMSegmentation Tutorial\n",
+    "Welcome to MMSegmentation! \n",
+    "\n",
+    "In this tutorial, we demo\n",
+    "* How to do inference with MMSeg trained weight\n",
+    "* How to train on your own dataset and visualize the results. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "QS8YHrEhbpas"
+   },
+   "source": [
+    "## Install MMSegmentation\n",
+    "This step may take several minutes. \n",
+    "\n",
+    "We use PyTorch 1.12 and CUDA 11.3 for this tutorial. You may install other versions by change the version number in pip install command. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "UWyLrLYaNEaL",
+    "outputId": "32a47fe3-f10d-47a1-f6b9-b7c235abdab1"
+   },
+   "outputs": [],
+   "source": [
+    "# Check nvcc version\n",
+    "!nvcc -V\n",
+    "# Check GCC version\n",
+    "!gcc --version"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "Ki3WUBjKbutg",
+    "outputId": "14bd14b0-4d8c-4fa9-e3f9-da35c0efc0d5"
+   },
+   "outputs": [],
+   "source": [
+    "# Install PyTorch\n",
+    "!conda install pytorch==1.12.0 torchvision==0.13.0 torchaudio==0.12.0 cudatoolkit=11.3 -c pytorch\n",
+    "# Install mim\n",
+    "!pip install -U openmim\n",
+    "# Install mmengine\n",
+    "!mim install mmengine\n",
+    "# Install MMCV\n",
+    "!mim install 'mmcv >= 2.0.0rc1'\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "nR-hHRvbNJJZ",
+    "outputId": "10c3b131-d4db-458c-fc10-b94b1c6ed546"
+   },
+   "outputs": [],
+   "source": [
+    "!rm -rf mmsegmentation\n",
+    "!git clone -b main https://github.com/open-mmlab/mmsegmentation.git \n",
+    "%cd mmsegmentation\n",
+    "!pip install -e ."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "mAE_h7XhPT7d",
+    "outputId": "83bf0f8e-fc69-40b1-f9fe-0025724a217c"
+   },
+   "outputs": [],
+   "source": [
+    "# Check Pytorch installation\n",
+    "import torch, torchvision\n",
+    "print(torch.__version__, torch.cuda.is_available())\n",
+    "\n",
+    "# Check MMSegmentation installation\n",
+    "import mmseg\n",
+    "print(mmseg.__version__)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Ta51clKX4cwM"
+   },
+   "source": [
+    "## Finetune a semantic segmentation model on a new dataset\n",
+    "\n",
+    "To finetune on a customized dataset, the following steps are necessary. \n",
+    "1. Add a new dataset class. \n",
+    "2. Create a config file accordingly. \n",
+    "3. Perform training and evaluation. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "AcZg6x_K5Zs3"
+   },
+   "source": [
+    "### Add a new dataset\n",
+    "\n",
+    "Datasets in MMSegmentation require image and semantic segmentation maps to be placed in folders with the same prefix. To support a new dataset, we may need to modify the original file structure. \n",
+    "\n",
+    "In this tutorial, we give an example of converting the dataset. You may refer to [docs](https://github.com/open-mmlab/mmsegmentation/blob/master/docs/en/tutorials/customize_datasets.md#customize-datasets-by-reorganizing-data) for details about dataset reorganization. \n",
+    "\n",
+    "We use [Stanford Background Dataset](http://dags.stanford.edu/projects/scenedataset.html) as an example. The dataset contains 715 images chosen from existing public datasets [LabelMe](http://labelme.csail.mit.edu), [MSRC](http://research.microsoft.com/en-us/projects/objectclassrecognition), [PASCAL VOC](http://pascallin.ecs.soton.ac.uk/challenges/VOC) and [Geometric Context](http://www.cs.illinois.edu/homes/dhoiem/). Images from these datasets are mainly outdoor scenes, each containing approximately 320-by-240 pixels. \n",
+    "In this tutorial, we use the region annotations as labels. There are 8 classes in total, i.e. sky, tree, road, grass, water, building, mountain, and foreground object. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "TFIt7MHq5Wls",
+    "outputId": "74a126e4-c8a4-4d2f-a910-b58b71843a23"
+   },
+   "outputs": [],
+   "source": [
+    "# download and unzip\n",
+    "!wget http://dags.stanford.edu/data/iccv09Data.tar.gz -O stanford_background.tar.gz\n",
+    "!tar xf stanford_background.tar.gz"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 377
+    },
+    "id": "78LIci7F9WWI",
+    "outputId": "c432ddac-5a50-47b1-daac-5a26b07afea2"
+   },
+   "outputs": [],
+   "source": [
+    "# Let's take a look at the dataset\n",
+    "import mmcv\n",
+    "import mmengine\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "\n",
+    "img = mmcv.imread('iccv09Data/images/6000124.jpg')\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "plt.imshow(mmcv.bgr2rgb(img))\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "L5mNQuc2GsVE"
+   },
+   "source": [
+    "We need to convert the annotation into semantic map format as an image."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "WnGZfribFHCx"
+   },
+   "outputs": [],
+   "source": [
+    "# define dataset root and directory for images and annotations\n",
+    "data_root = 'iccv09Data'\n",
+    "img_dir = 'images'\n",
+    "ann_dir = 'labels'\n",
+    "# define class and palette for better visualization\n",
+    "classes = ('sky', 'tree', 'road', 'grass', 'water', 'bldg', 'mntn', 'fg obj')\n",
+    "palette = [[128, 128, 128], [129, 127, 38], [120, 69, 125], [53, 125, 34], \n",
+    "           [0, 11, 123], [118, 20, 12], [122, 81, 25], [241, 134, 51]]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "WnGZfribFHCx"
+   },
+   "outputs": [],
+   "source": [
+    "import os.path as osp\n",
+    "import numpy as np\n",
+    "from PIL import Image\n",
+    "\n",
+    "# convert dataset annotation to semantic segmentation map\n",
+    "for file in mmengine.scandir(osp.join(data_root, ann_dir), suffix='.regions.txt'):\n",
+    "  seg_map = np.loadtxt(osp.join(data_root, ann_dir, file)).astype(np.uint8)\n",
+    "  seg_img = Image.fromarray(seg_map).convert('P')\n",
+    "  seg_img.putpalette(np.array(palette, dtype=np.uint8))\n",
+    "  seg_img.save(osp.join(data_root, ann_dir, file.replace('.regions.txt', \n",
+    "                                                         '.png')))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 377
+    },
+    "id": "5MCSS9ABfSks",
+    "outputId": "92b9bafc-589e-48fc-c9e9-476f125d6522"
+   },
+   "outputs": [],
+   "source": [
+    "# Let's take a look at the segmentation map we got\n",
+    "import matplotlib.patches as mpatches\n",
+    "img = Image.open('iccv09Data/labels/6000124.png')\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "im = plt.imshow(np.array(img.convert('RGB')))\n",
+    "\n",
+    "# create a patch (proxy artist) for every color \n",
+    "patches = [mpatches.Patch(color=np.array(palette[i])/255., \n",
+    "                          label=classes[i]) for i in range(8)]\n",
+    "# put those patched as legend-handles into the legend\n",
+    "plt.legend(handles=patches, bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0., \n",
+    "           fontsize='large')\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "WbeLYCp2k5hl"
+   },
+   "outputs": [],
+   "source": [
+    "# split train/val set randomly\n",
+    "split_dir = 'splits'\n",
+    "mmengine.mkdir_or_exist(osp.join(data_root, split_dir))\n",
+    "filename_list = [osp.splitext(filename)[0] for filename in mmengine.scandir(\n",
+    "    osp.join(data_root, ann_dir), suffix='.png')]\n",
+    "with open(osp.join(data_root, split_dir, 'train.txt'), 'w') as f:\n",
+    "  # select first 4/5 as train set\n",
+    "  train_length = int(len(filename_list)*4/5)\n",
+    "  f.writelines(line + '\\n' for line in filename_list[:train_length])\n",
+    "with open(osp.join(data_root, split_dir, 'val.txt'), 'w') as f:\n",
+    "  # select last 1/5 as train set\n",
+    "  f.writelines(line + '\\n' for line in filename_list[train_length:])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "HchvmGYB_rrO"
+   },
+   "source": [
+    "After downloading the data, we need to implement `load_annotations` function in the new dataset class `StanfordBackgroundDataset`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "LbsWOw62_o-X"
+   },
+   "outputs": [],
+   "source": [
+    "from mmseg.registry import DATASETS\n",
+    "from mmseg.datasets import BaseSegDataset\n",
+    "\n",
+    "\n",
+    "@DATASETS.register_module()\n",
+    "class StanfordBackgroundDataset(BaseSegDataset):\n",
+    "  METAINFO = dict(classes = classes, palette = palette)\n",
+    "  def __init__(self, **kwargs):\n",
+    "    super().__init__(img_suffix='.jpg', seg_map_suffix='.png', **kwargs)\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "yUVtmn3Iq3WA"
+   },
+   "source": [
+    "### Create a config file\n",
+    "In the next step, we need to modify the config for the training. To accelerate the process, we finetune the model from trained weights."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Download config and checkpoint files\n",
+    "!mim download mmsegmentation --config pspnet_r50-d8_4xb2-40k_cityscapes-512x1024 --dest ."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Wwnj9tRzqX_A"
+   },
+   "outputs": [],
+   "source": [
+    "from mmengine import Config\n",
+    "cfg = Config.fromfile('configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py')\n",
+    "print(f'Config:\\n{cfg.pretty_text}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "1y2oV5w97jQo"
+   },
+   "source": [
+    "Since the given config is used to train PSPNet on the cityscapes dataset, we need to modify it accordingly for our new dataset.  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "eyKnYC1Z7iCV",
+    "outputId": "6195217b-187f-4675-994b-ba90d8bb3078"
+   },
+   "outputs": [],
+   "source": [
+    "# Since we use only one GPU, BN is used instead of SyncBN\n",
+    "cfg.norm_cfg = dict(type='BN', requires_grad=True)\n",
+    "cfg.crop_size = (256, 256)\n",
+    "cfg.model.data_preprocessor.size = cfg.crop_size\n",
+    "cfg.model.backbone.norm_cfg = cfg.norm_cfg\n",
+    "cfg.model.decode_head.norm_cfg = cfg.norm_cfg\n",
+    "cfg.model.auxiliary_head.norm_cfg = cfg.norm_cfg\n",
+    "# modify num classes of the model in decode/auxiliary head\n",
+    "cfg.model.decode_head.num_classes = 8\n",
+    "cfg.model.auxiliary_head.num_classes = 8\n",
+    "\n",
+    "# Modify dataset type and path\n",
+    "cfg.dataset_type = 'StanfordBackgroundDataset'\n",
+    "cfg.data_root = data_root\n",
+    "\n",
+    "cfg.train_dataloader.batch_size = 8\n",
+    "\n",
+    "cfg.train_pipeline = [\n",
+    "    dict(type='LoadImageFromFile'),\n",
+    "    dict(type='LoadAnnotations'),\n",
+    "    dict(type='RandomResize', scale=(320, 240), ratio_range=(0.5, 2.0), keep_ratio=True),\n",
+    "    dict(type='RandomCrop', crop_size=cfg.crop_size, cat_max_ratio=0.75),\n",
+    "    dict(type='RandomFlip', prob=0.5),\n",
+    "    dict(type='PackSegInputs')\n",
+    "]\n",
+    "\n",
+    "cfg.test_pipeline = [\n",
+    "    dict(type='LoadImageFromFile'),\n",
+    "    dict(type='Resize', scale=(320, 240), keep_ratio=True),\n",
+    "    # add loading annotation after ``Resize`` because ground truth\n",
+    "    # does not need to do resize data transform\n",
+    "    dict(type='LoadAnnotations'),\n",
+    "    dict(type='PackSegInputs')\n",
+    "]\n",
+    "\n",
+    "\n",
+    "cfg.train_dataloader.dataset.type = cfg.dataset_type\n",
+    "cfg.train_dataloader.dataset.data_root = cfg.data_root\n",
+    "cfg.train_dataloader.dataset.data_prefix = dict(img_path=img_dir, seg_map_path=ann_dir)\n",
+    "cfg.train_dataloader.dataset.pipeline = cfg.train_pipeline\n",
+    "cfg.train_dataloader.dataset.ann_file = 'splits/train.txt'\n",
+    "\n",
+    "cfg.val_dataloader.dataset.type = cfg.dataset_type\n",
+    "cfg.val_dataloader.dataset.data_root = cfg.data_root\n",
+    "cfg.val_dataloader.dataset.data_prefix = dict(img_path=img_dir, seg_map_path=ann_dir)\n",
+    "cfg.val_dataloader.dataset.pipeline = cfg.test_pipeline\n",
+    "cfg.val_dataloader.dataset.ann_file = 'splits/val.txt'\n",
+    "\n",
+    "cfg.test_dataloader = cfg.val_dataloader\n",
+    "\n",
+    "\n",
+    "# Load the pretrained weights\n",
+    "cfg.load_from = 'pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'\n",
+    "\n",
+    "# Set up working dir to save files and logs.\n",
+    "cfg.work_dir = './work_dirs/tutorial'\n",
+    "\n",
+    "cfg.train_cfg.max_iters = 200\n",
+    "cfg.train_cfg.val_interval = 200\n",
+    "cfg.default_hooks.logger.interval = 10\n",
+    "cfg.default_hooks.checkpoint.interval = 200\n",
+    "\n",
+    "# Set seed to facilitate reproducing the result\n",
+    "cfg['randomness'] = dict(seed=0)\n",
+    "\n",
+    "# Let's have a look at the final config used for training\n",
+    "print(f'Config:\\n{cfg.pretty_text}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "QWuH14LYF2gQ"
+   },
+   "source": [
+    "### Train and Evaluation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "jYKoSfdMF12B",
+    "outputId": "422219ca-d7a5-4890-f09f-88c959942e64"
+   },
+   "outputs": [],
+   "source": [
+    "from mmengine.runner import Runner\n",
+    "\n",
+    "runner = Runner.from_cfg(cfg)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# start training\n",
+    "runner.train()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "DEkWOP-NMbc_"
+   },
+   "source": [
+    "Inference with trained model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 645
+    },
+    "id": "ekG__UfaH_OU",
+    "outputId": "1437419c-869a-4902-df86-d4f6f8b2597a"
+   },
+   "outputs": [],
+   "source": [
+    "from mmseg.apis import init_model, inference_model, show_result_pyplot\n",
+    "\n",
+    "# Init the model from the config and the checkpoint\n",
+    "checkpoint_path = './work_dirs/tutorial/iter_200.pth'\n",
+    "model = init_model(cfg, checkpoint_path, 'cuda:0')\n",
+    "\n",
+    "img = mmcv.imread('iccv09Data/images/6000124.jpg')\n",
+    "result = inference_model(model, img)\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "vis_result = show_result_pyplot(model, img, result)\n",
+    "plt.imshow(mmcv.bgr2rgb(vis_result))\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "collapsed_sections": [],
+   "include_colab_link": true,
+   "name": "MMSegmentation Tutorial.ipynb",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3.10.6 ('pt1.12')",
+   "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.10.6"
+  },
+  "pycharm": {
+   "stem_cell": {
+    "cell_type": "raw",
+    "metadata": {
+     "collapsed": false
+    },
+    "source": []
+   }
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "0442e67aee3d9cbb788fa6e86d60c4ffa94ad7f1943c65abfecb99a6f4696c58"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/mmsegmentation/demo/image_demo.py b/mmsegmentation/demo/image_demo.py
new file mode 100644
index 0000000..ebc34c8
--- /dev/null
+++ b/mmsegmentation/demo/image_demo.py
@@ -0,0 +1,51 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from argparse import ArgumentParser
+
+from mmengine.model import revert_sync_batchnorm
+
+from mmseg.apis import inference_model, init_model, show_result_pyplot
+
+
+def main():
+    parser = ArgumentParser()
+    parser.add_argument('img', help='Image file')
+    parser.add_argument('config', help='Config file')
+    parser.add_argument('checkpoint', help='Checkpoint file')
+    parser.add_argument('--out-file', default=None, help='Path to output file')
+    parser.add_argument(
+        '--device', default='cuda:0', help='Device used for inference')
+    parser.add_argument(
+        '--opacity',
+        type=float,
+        default=0.5,
+        help='Opacity of painted segmentation map. In (0, 1] range.')
+    parser.add_argument(
+        '--with-labels',
+        action='store_true',
+        default=False,
+        help='Whether to display the class labels.')
+    parser.add_argument(
+        '--title', default='result', help='The image identifier.')
+    args = parser.parse_args()
+
+    # build the model from a config file and a checkpoint file
+    model = init_model(args.config, args.checkpoint, device=args.device)
+    if args.device == 'cpu':
+        model = revert_sync_batchnorm(model)
+    # test a single image
+    result = inference_model(model, args.img)
+    # show the results
+    show_result_pyplot(
+        model,
+        args.img,
+        result,
+        title=args.title,
+        opacity=args.opacity,
+        with_labels=args.with_labels,
+        draw_gt=False,
+        show=False if args.out_file is not None else True,
+        out_file=args.out_file)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/demo/image_demo_with_inferencer.py b/mmsegmentation/demo/image_demo_with_inferencer.py
new file mode 100644
index 0000000..d1fa9de
--- /dev/null
+++ b/mmsegmentation/demo/image_demo_with_inferencer.py
@@ -0,0 +1,54 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from argparse import ArgumentParser
+
+from mmseg.apis import MMSegInferencer
+
+
+def main():
+    parser = ArgumentParser()
+    parser.add_argument('img', help='Image file')
+    parser.add_argument('model', help='Config file')
+    parser.add_argument('--checkpoint', default=None, help='Checkpoint file')
+    parser.add_argument(
+        '--out-dir', default='', help='Path to save result file')
+    parser.add_argument(
+        '--show',
+        action='store_true',
+        default=False,
+        help='Whether to display the drawn image.')
+    parser.add_argument(
+        '--dataset-name',
+        default='cityscapes',
+        help='Color palette used for segmentation map')
+    parser.add_argument(
+        '--device', default='cuda:0', help='Device used for inference')
+    parser.add_argument(
+        '--opacity',
+        type=float,
+        default=0.5,
+        help='Opacity of painted segmentation map. In (0, 1] range.')
+    parser.add_argument(
+        '--with-labels',
+        action='store_true',
+        default=False,
+        help='Whether to display the class labels.')
+    args = parser.parse_args()
+
+    # build the model from a config file and a checkpoint file
+    mmseg_inferencer = MMSegInferencer(
+        args.model,
+        args.checkpoint,
+        dataset_name=args.dataset_name,
+        device=args.device)
+
+    # test a single image
+    mmseg_inferencer(
+        args.img,
+        show=args.show,
+        out_dir=args.out_dir,
+        opacity=args.opacity,
+        with_labels=args.with_labels)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/demo/inference_demo.ipynb b/mmsegmentation/demo/inference_demo.ipynb
new file mode 100644
index 0000000..455c5df
--- /dev/null
+++ b/mmsegmentation/demo/inference_demo.ipynb
@@ -0,0 +1,120 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!mkdir ../checkpoints\n",
+    "!wget https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth -P ../checkpoints"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": true
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import matplotlib.pyplot as plt\n",
+    "from mmengine.model.utils import revert_sync_batchnorm\n",
+    "from mmseg.apis import init_model, inference_model, show_result_pyplot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": true
+    }
+   },
+   "outputs": [],
+   "source": [
+    "config_file = '../configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'\n",
+    "checkpoint_file = '../checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# build the model from a config file and a checkpoint file\n",
+    "model = init_model(config_file, checkpoint_file, device='cpu')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# test a single image\n",
+    "img = 'demo.png'\n",
+    "if not torch.cuda.is_available():\n",
+    "    model = revert_sync_batchnorm(model)\n",
+    "result = inference_model(model, img)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# show the results\n",
+    "vis_result = show_result_pyplot(model, img, result, show=False)\n",
+    "plt.imshow(vis_result)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "pt1.13",
+   "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.10.11"
+  },
+  "pycharm": {
+   "stem_cell": {
+    "cell_type": "raw",
+    "metadata": {
+     "collapsed": false
+    },
+    "source": []
+   }
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "f61d5b8fecdd960739697f6c2860080d7b76a5be5d896cb034bdb275ab3ddda0"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/mmsegmentation/demo/rs_image_inference.py b/mmsegmentation/demo/rs_image_inference.py
new file mode 100644
index 0000000..799181f
--- /dev/null
+++ b/mmsegmentation/demo/rs_image_inference.py
@@ -0,0 +1,50 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from argparse import ArgumentParser
+
+from mmseg.apis import RSImage, RSInferencer
+
+
+def main():
+    parser = ArgumentParser()
+    parser.add_argument('image', help='Image file path')
+    parser.add_argument('config', help='Config file')
+    parser.add_argument('checkpoint', help='Checkpoint file')
+    parser.add_argument(
+        '--output-path',
+        help='Path to save result image',
+        default='result.png')
+    parser.add_argument(
+        '--batch-size',
+        type=int,
+        default=1,
+        help='maximum number of windows inferred simultaneously')
+    parser.add_argument(
+        '--window-size',
+        help='window xsize,ysize',
+        default=(224, 224),
+        type=int,
+        nargs=2)
+    parser.add_argument(
+        '--stride',
+        help='window xstride,ystride',
+        default=(224, 224),
+        type=int,
+        nargs=2)
+    parser.add_argument(
+        '--thread', default=1, type=int, help='number of inference threads')
+    parser.add_argument(
+        '--device', default='cuda:0', help='Device used for inference')
+    args = parser.parse_args()
+    inferencer = RSInferencer.from_config_path(
+        args.config,
+        args.checkpoint,
+        batch_size=args.batch_size,
+        thread=args.thread,
+        device=args.device)
+    image = RSImage(args.image)
+
+    inferencer.run(image, args.window_size, args.stride, args.output_path)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/demo/video_demo.py b/mmsegmentation/demo/video_demo.py
new file mode 100644
index 0000000..7e6f3d6
--- /dev/null
+++ b/mmsegmentation/demo/video_demo.py
@@ -0,0 +1,112 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from argparse import ArgumentParser
+
+import cv2
+from mmengine.model.utils import revert_sync_batchnorm
+
+from mmseg.apis import inference_model, init_model
+from mmseg.apis.inference import show_result_pyplot
+
+
+def main():
+    parser = ArgumentParser()
+    parser.add_argument('video', help='Video file or webcam id')
+    parser.add_argument('config', help='Config file')
+    parser.add_argument('checkpoint', help='Checkpoint file')
+    parser.add_argument(
+        '--device', default='cuda:0', help='Device used for inference')
+    parser.add_argument(
+        '--palette',
+        default='cityscapes',
+        help='Color palette used for segmentation map')
+    parser.add_argument(
+        '--show', action='store_true', help='Whether to show draw result')
+    parser.add_argument(
+        '--show-wait-time', default=1, type=int, help='Wait time after imshow')
+    parser.add_argument(
+        '--output-file', default=None, type=str, help='Output video file path')
+    parser.add_argument(
+        '--output-fourcc',
+        default='MJPG',
+        type=str,
+        help='Fourcc of the output video')
+    parser.add_argument(
+        '--output-fps', default=-1, type=int, help='FPS of the output video')
+    parser.add_argument(
+        '--output-height',
+        default=-1,
+        type=int,
+        help='Frame height of the output video')
+    parser.add_argument(
+        '--output-width',
+        default=-1,
+        type=int,
+        help='Frame width of the output video')
+    parser.add_argument(
+        '--opacity',
+        type=float,
+        default=0.5,
+        help='Opacity of painted segmentation map. In (0, 1] range.')
+    args = parser.parse_args()
+
+    assert args.show or args.output_file, \
+        'At least one output should be enabled.'
+
+    # build the model from a config file and a checkpoint file
+    model = init_model(args.config, args.checkpoint, device=args.device)
+    if args.device == 'cpu':
+        model = revert_sync_batchnorm(model)
+
+    # build input video
+    if args.video.isdigit():
+        args.video = int(args.video)
+    cap = cv2.VideoCapture(args.video)
+    assert (cap.isOpened())
+    input_height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT)
+    input_width = cap.get(cv2.CAP_PROP_FRAME_WIDTH)
+    input_fps = cap.get(cv2.CAP_PROP_FPS)
+
+    # init output video
+    writer = None
+    output_height = None
+    output_width = None
+    if args.output_file is not None:
+        fourcc = cv2.VideoWriter_fourcc(*args.output_fourcc)
+        output_fps = args.output_fps if args.output_fps > 0 else input_fps
+        output_height = args.output_height if args.output_height > 0 else int(
+            input_height)
+        output_width = args.output_width if args.output_width > 0 else int(
+            input_width)
+        writer = cv2.VideoWriter(args.output_file, fourcc, output_fps,
+                                 (output_width, output_height), True)
+
+    # start looping
+    try:
+        while True:
+            flag, frame = cap.read()
+            if not flag:
+                break
+
+            # test a single image
+            result = inference_model(model, frame)
+
+            # blend raw image and prediction
+            draw_img = show_result_pyplot(model, frame, result)
+
+            if args.show:
+                cv2.imshow('video_demo', draw_img)
+                cv2.waitKey(args.show_wait_time)
+            if writer:
+                if draw_img.shape[0] != output_height or draw_img.shape[
+                        1] != output_width:
+                    draw_img = cv2.resize(draw_img,
+                                          (output_width, output_height))
+                writer.write(draw_img)
+    finally:
+        if writer:
+            writer.release()
+        cap.release()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/docker/Dockerfile b/mmsegmentation/docker/Dockerfile
new file mode 100644
index 0000000..26420dd
--- /dev/null
+++ b/mmsegmentation/docker/Dockerfile
@@ -0,0 +1,35 @@
+ARG PYTORCH="1.11.0"
+ARG CUDA="11.3"
+ARG CUDNN="8"
+ARG MMCV="2.0.1"
+
+FROM pytorch/pytorch:${PYTORCH}-cuda${CUDA}-cudnn${CUDNN}-devel
+
+ENV TORCH_CUDA_ARCH_LIST="6.0 6.1 7.0+PTX"
+ENV TORCH_NVCC_FLAGS="-Xfatbin -compress-all"
+ENV CMAKE_PREFIX_PATH="$(dirname $(which conda))/../"
+
+# To fix GPG key error when running apt-get update
+RUN apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/3bf863cc.pub
+RUN apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64/7fa2af80.pub
+
+RUN apt-get update && apt-get install -y git ninja-build libglib2.0-0 libsm6 libxrender-dev libxext6 libgl1-mesa-dev  \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN conda clean --all
+
+# Install MMCV
+ARG PYTORCH
+ARG CUDA
+ARG MMCV
+RUN ["/bin/bash", "-c", "pip install openmim"]
+RUN ["/bin/bash", "-c", "mim install mmengine"]
+RUN ["/bin/bash", "-c", "mim install mmcv==${MMCV}"]
+
+# Install MMSegmentation
+RUN git clone -b main https://github.com/open-mmlab/mmsegmentation.git /mmsegmentation
+WORKDIR /mmsegmentation
+ENV FORCE_CUDA="1"
+RUN pip install -r requirements.txt
+RUN pip install --no-cache-dir -e .
diff --git a/mmsegmentation/docker/serve/Dockerfile b/mmsegmentation/docker/serve/Dockerfile
new file mode 100644
index 0000000..38f91ba
--- /dev/null
+++ b/mmsegmentation/docker/serve/Dockerfile
@@ -0,0 +1,51 @@
+ARG PYTORCH="1.11.0"
+ARG CUDA="11.3"
+ARG CUDNN="8"
+FROM pytorch/pytorch:${PYTORCH}-cuda${CUDA}-cudnn${CUDNN}-devel
+
+ARG MMCV="2.0.1"
+ARG MMSEG="1.2.2"
+
+ENV PYTHONUNBUFFERED TRUE
+
+RUN apt-get update && \
+    DEBIAN_FRONTEND=noninteractive apt-get install --no-install-recommends -y \
+    ca-certificates \
+    g++ \
+    openjdk-11-jre-headless \
+    # MMDet Requirements
+    ffmpeg libsm6 libxext6 git ninja-build libglib2.0-0 libsm6 libxrender-dev libxext6 \
+    && rm -rf /var/lib/apt/lists/*
+
+ENV PATH="/opt/conda/bin:$PATH"
+RUN export FORCE_CUDA=1
+
+# TORCHSEVER
+RUN pip install torchserve torch-model-archiver
+
+# MMLAB
+ARG PYTORCH
+ARG CUDA
+RUN ["/bin/bash", "-c", "pip install openmim"]
+RUN ["/bin/bash", "-c", "mim install mmengine"]
+RUN ["/bin/bash", "-c", "mim install mmcv==${MMCV}"]
+RUN pip install mmsegmentation==${MMSEG}
+
+RUN useradd -m model-server \
+    && mkdir -p /home/model-server/tmp
+
+COPY entrypoint.sh /usr/local/bin/entrypoint.sh
+
+RUN chmod +x /usr/local/bin/entrypoint.sh \
+    && chown -R model-server /home/model-server
+
+COPY config.properties /home/model-server/config.properties
+RUN mkdir /home/model-server/model-store && chown -R model-server /home/model-server/model-store
+
+EXPOSE 8080 8081 8082
+
+USER model-server
+WORKDIR /home/model-server
+ENV TEMP=/home/model-server/tmp
+ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]
+CMD ["serve"]
diff --git a/mmsegmentation/docker/serve/config.properties b/mmsegmentation/docker/serve/config.properties
new file mode 100644
index 0000000..efb9c47
--- /dev/null
+++ b/mmsegmentation/docker/serve/config.properties
@@ -0,0 +1,5 @@
+inference_address=http://0.0.0.0:8080
+management_address=http://0.0.0.0:8081
+metrics_address=http://0.0.0.0:8082
+model_store=/home/model-server/model-store
+load_models=all
diff --git a/mmsegmentation/docker/serve/entrypoint.sh b/mmsegmentation/docker/serve/entrypoint.sh
new file mode 100644
index 0000000..41ba00b
--- /dev/null
+++ b/mmsegmentation/docker/serve/entrypoint.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+set -e
+
+if [[ "$1" = "serve" ]]; then
+    shift 1
+    torchserve --start --ts-config /home/model-server/config.properties
+else
+    eval "$@"
+fi
+
+# prevent docker exit
+tail -f /dev/null
diff --git a/mmsegmentation/docs/en/.readthedocs.yaml b/mmsegmentation/docs/en/.readthedocs.yaml
new file mode 100644
index 0000000..9df9fdb
--- /dev/null
+++ b/mmsegmentation/docs/en/.readthedocs.yaml
@@ -0,0 +1,17 @@
+version: 2
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.8"
+
+formats:
+    - epub
+
+sphinx:
+  configuration: docs/en/conf.py
+
+python:
+  install:
+    - requirements: requirements/docs.txt
+    - requirements: requirements/readthedocs.txt
diff --git a/mmsegmentation/docs/en/Makefile b/mmsegmentation/docs/en/Makefile
new file mode 100644
index 0000000..d4bb2cb
--- /dev/null
+++ b/mmsegmentation/docs/en/Makefile
@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = .
+BUILDDIR      = _build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
diff --git a/mmsegmentation/docs/en/_static/css/readthedocs.css b/mmsegmentation/docs/en/_static/css/readthedocs.css
new file mode 100644
index 0000000..2e38d08
--- /dev/null
+++ b/mmsegmentation/docs/en/_static/css/readthedocs.css
@@ -0,0 +1,6 @@
+.header-logo {
+    background-image: url("../images/mmsegmentation.png");
+    background-size: 201px 40px;
+    height: 40px;
+    width: 201px;
+}
diff --git a/mmsegmentation/docs/en/advanced_guides/add_datasets.md b/mmsegmentation/docs/en/advanced_guides/add_datasets.md
new file mode 100644
index 0000000..a8e3503
--- /dev/null
+++ b/mmsegmentation/docs/en/advanced_guides/add_datasets.md
@@ -0,0 +1,199 @@
+# Add New Datasets
+
+## Add new custom dataset
+
+Here we show how to develop a new custom dataset.
+
+1. Create a new file `mmseg/datasets/example.py`
+
+   ```python
+   from mmseg.registry import DATASETS
+   from .basesegdataset import BaseSegDataset
+
+
+   @DATASETS.register_module()
+   class ExampleDataset(BaseSegDataset):
+
+       METAINFO = dict(
+           classes=('xxx', 'xxx', ...),
+           palette=[[x, x, x], [x, x, x], ...])
+
+       def __init__(self, arg1, arg2):
+           pass
+   ```
+
+2. Import the module in `mmseg/datasets/__init__.py`
+
+   ```python
+   from .example import ExampleDataset
+   ```
+
+3. Use it by creating a new new dataset config file `configs/_base_/datasets/example_dataset.py`
+
+   ```python
+   dataset_type = 'ExampleDataset'
+   data_root = 'data/example/'
+   ...
+   ```
+
+4. Add dataset meta information in `mmseg/utils/class_names.py`
+
+   ```python
+   def example_classes():
+       return [
+           'xxx', 'xxx',
+           ...
+       ]
+
+   def example_palette():
+       return [
+           [x, x, x], [x, x, x],
+           ...
+       ]
+   dataset_aliases ={
+       'example': ['example', ...],
+       ...
+   }
+   ```
+
+**Note:** If the new dataset does not satisfy the mmseg requirements, a data preprocessing script needs to be prepared in `tools/dataset_converters/`
+
+## Customize datasets by reorganizing data
+
+The simplest way is to convert your dataset to organize your data into folders.
+
+An example of file structure is as followed.
+
+```none
+├── data
+│   ├── my_dataset
+│   │   ├── img_dir
+│   │   │   ├── train
+│   │   │   │   ├── xxx{img_suffix}
+│   │   │   │   ├── yyy{img_suffix}
+│   │   │   │   ├── zzz{img_suffix}
+│   │   │   ├── val
+│   │   ├── ann_dir
+│   │   │   ├── train
+│   │   │   │   ├── xxx{seg_map_suffix}
+│   │   │   │   ├── yyy{seg_map_suffix}
+│   │   │   │   ├── zzz{seg_map_suffix}
+│   │   │   ├── val
+
+```
+
+A training pair will consist of the files with same suffix in img_dir/ann_dir.
+
+Some datasets don't release the test set or don't release the ground truth of the test set, and we cannot evaluate models locally without the ground truth of the test set, so we set the validation set as the default test set in config files.
+
+About how to build your own datasets or implement a new dataset class please refer to the [datasets guide](./datasets.md) for more detailed information.
+
+**Note:** The annotations are images of shape (H, W), the value pixel should fall in range `[0, num_classes - 1]`.
+You may use `'P'` mode of [pillow](https://pillow.readthedocs.io/en/stable/handbook/concepts.html#palette) to create your annotation image with color.
+
+## Customize datasets by mixing dataset
+
+MMSegmentation also supports to mix dataset for training.
+Currently it supports to concat, repeat and multi-image mix datasets.
+
+### Repeat dataset
+
+We use `RepeatDataset` as wrapper to repeat the dataset.
+For example, suppose the original dataset is `Dataset_A`, to repeat it, the config looks like the following
+
+```python
+dataset_A_train = dict(
+    type='RepeatDataset',
+    times=N,
+    dataset=dict(  # This is the original config of Dataset_A
+        type='Dataset_A',
+        ...
+        pipeline=train_pipeline
+    )
+)
+```
+
+### Concatenate dataset
+
+In case the dataset you want to concatenate is different, you can concatenate the dataset configs like the following.
+
+```python
+dataset_A_train = dict()
+dataset_B_train = dict()
+concatenate_dataset = dict(
+    type='ConcatDataset',
+    datasets=[dataset_A_train, dataset_B_train])
+```
+
+A more complex example that repeats `Dataset_A` and `Dataset_B` by N and M times, respectively, and then concatenates the repeated datasets is as the following.
+
+```python
+dataset_A_train = dict(
+    type='RepeatDataset',
+    times=N,
+    dataset=dict(
+        type='Dataset_A',
+        ...
+        pipeline=train_pipeline
+    )
+)
+dataset_A_val = dict(
+    ...
+    pipeline=test_pipeline
+)
+dataset_A_test = dict(
+    ...
+    pipeline=test_pipeline
+)
+dataset_B_train = dict(
+    type='RepeatDataset',
+    times=M,
+    dataset=dict(
+        type='Dataset_B',
+        ...
+        pipeline=train_pipeline
+    )
+)
+train_dataloader = dict(
+    dataset=dict(
+        type='ConcatDataset',
+        datasets=[dataset_A_train, dataset_B_train]))
+
+val_dataloader = dict(dataset=dataset_A_val)
+test_dataloader = dict(dataset=dataset_A_test)
+
+```
+
+You can refer base dataset [tutorial](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/basedataset.html) from mmengine for more details
+
+### Multi-image Mix Dataset
+
+We use `MultiImageMixDataset` as a wrapper to mix images from multiple datasets.
+`MultiImageMixDataset` can be used by multiple images mixed data augmentation like mosaic and mixup.
+
+An example of using `MultiImageMixDataset` with `Mosaic` data augmentation:
+
+```python
+train_pipeline = [
+    dict(type='RandomMosaic', prob=1),
+    dict(type='Resize', img_scale=(1024, 512), keep_ratio=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackSegInputs')
+]
+
+train_dataset = dict(
+    type='MultiImageMixDataset',
+    dataset=dict(
+        type=dataset_type,
+        reduce_zero_label=False,
+        img_dir=data_root + "images/train",
+        ann_dir=data_root + "annotations/train",
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations'),
+        ]
+    ),
+    pipeline=train_pipeline
+)
+
+```
diff --git a/mmsegmentation/docs/en/advanced_guides/add_metrics.md b/mmsegmentation/docs/en/advanced_guides/add_metrics.md
new file mode 100644
index 0000000..0298826
--- /dev/null
+++ b/mmsegmentation/docs/en/advanced_guides/add_metrics.md
@@ -0,0 +1,81 @@
+# Add New Metrics
+
+## Develop with the source code of MMSegmentation
+
+Here we show how to develop a new metric with an example of `CustomMetric` as the following.
+
+1. Create a new file `mmseg/evaluation/metrics/custom_metric.py`.
+
+   ```python
+   from typing import List, Sequence
+
+   from mmengine.evaluator import BaseMetric
+
+   from mmseg.registry import METRICS
+
+
+   @METRICS.register_module()
+   class CustomMetric(BaseMetric):
+
+       def __init__(self, arg1, arg2):
+           """
+           The metric first processes each batch of data_samples and predictions,
+           and appends the processed results to the results list. Then it
+           collects all results together from all ranks if distributed training
+           is used. Finally, it computes the metrics of the entire dataset.
+           """
+
+       def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+           pass
+
+       def compute_metrics(self, results: list) -> dict:
+           pass
+
+       def evaluate(self, size: int) -> dict:
+           pass
+   ```
+
+   In the above example, `CustomMetric` is a subclass of `BaseMetric`. It has three methods: `process`, `compute_metrics` and `evaluate`.
+
+   - `process()` process one batch of data samples and predictions. The processed results are stored in `self.results` which will be used to compute the metrics after all the data samples are processed. Please refer to [MMEngine documentation](https://github.com/open-mmlab/mmengine/blob/main/docs/en/design/evaluation.md) for more details.
+
+   - `compute_metrics()` is used to compute the metrics from the processed results.
+
+   - `evaluate()` is an interface to compute the metrics and return the results. It will be called by `ValLoop` or `TestLoop` in the `Runner`. In most cases, you don't need to override this method, but you can override it if you want to do some extra work.
+
+   **Note:** You might find the details of calling `evaluate()` method in the `Runner` [here](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py#L366). The `Runner` is the executor of the training and testing process, you can find more details about it at the [engine document](./engine.md).
+
+2. Import the new metric in `mmseg/evaluation/metrics/__init__.py`.
+
+   ```python
+   from .custom_metric import CustomMetric
+   __all__ = ['CustomMetric', ...]
+   ```
+
+3. Add the new metric to the config file.
+
+   ```python
+   val_evaluator = dict(type='CustomMetric', arg1=xxx, arg2=xxx)
+   test_evaluator = dict(type='CustomMetric', arg1=xxx, arg2=xxx)
+   ```
+
+## Develop with the released version of MMSegmentation
+
+The above example shows how to develop a new metric with the source code of MMSegmentation. If you want to develop a new metric with the released version of MMSegmentation, you can follow the following steps.
+
+1. Create a new file `/Path/to/metrics/custom_metric.py`, implement the `process`, `compute_metrics` and `evaluate` methods, `evaluate` method is optional.
+
+2. Import the new metric in your code or config file.
+
+   ```python
+   from path.to.metrics import CustomMetric
+   ```
+
+   or
+
+   ```python
+   custom_imports = dict(imports=['/Path/to/metrics'], allow_failed_imports=False)
+
+   val_evaluator = dict(type='CustomMetric', arg1=xxx, arg2=xxx)
+   test_evaluator = dict(type='CustomMetric', arg1=xxx, arg2=xxx)
+   ```
diff --git a/mmsegmentation/docs/en/advanced_guides/add_models.md b/mmsegmentation/docs/en/advanced_guides/add_models.md
new file mode 100644
index 0000000..ed5c9ce
--- /dev/null
+++ b/mmsegmentation/docs/en/advanced_guides/add_models.md
@@ -0,0 +1,260 @@
+# Add New Modules
+
+## Develop new components
+
+We can customize all the components introduced at [the model documentation](./models.md), such as **backbone**, **head**, **loss function** and **data preprocessor**.
+
+### Add new backbones
+
+Here we show how to develop a new backbone with an example of MobileNet.
+
+1. Create a new file `mmseg/models/backbones/mobilenet.py`.
+
+   ```python
+   import torch.nn as nn
+
+   from mmseg.registry import MODELS
+
+
+   @MODELS.register_module()
+   class MobileNet(nn.Module):
+
+       def __init__(self, arg1, arg2):
+           pass
+
+       def forward(self, x):  # should return a tuple
+           pass
+
+       def init_weights(self, pretrained=None):
+           pass
+   ```
+
+2. Import the module in `mmseg/models/backbones/__init__.py`.
+
+   ```python
+   from .mobilenet import MobileNet
+   ```
+
+3. Use it in your config file.
+
+   ```python
+   model = dict(
+       ...
+       backbone=dict(
+           type='MobileNet',
+           arg1=xxx,
+           arg2=xxx),
+       ...
+   ```
+
+### Add new heads
+
+In MMSegmentation, we provide a [BaseDecodeHead](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/decode_heads/decode_head.py#L17) for developing all segmentation heads.
+All newly implemented decode heads should be derived from it.
+Here we show how to develop a new head with the example of [PSPNet](https://arxiv.org/abs/1612.01105) as the following.
+
+First, add a new decode head in `mmseg/models/decode_heads/psp_head.py`.
+PSPNet implements a decode head for segmentation decode.
+To implement a decode head, we need to implement three functions of the new module as the following.
+
+```python
+from mmseg.registry import MODELS
+
+@MODELS.register_module()
+class PSPHead(BaseDecodeHead):
+
+    def __init__(self, pool_scales=(1, 2, 3, 6), **kwargs):
+        super(PSPHead, self).__init__(**kwargs)
+
+    def init_weights(self):
+        pass
+
+    def forward(self, inputs):
+        pass
+```
+
+Next, the users need to add the module in the `mmseg/models/decode_heads/__init__.py`, thus the corresponding registry could find and load them.
+
+To config file of PSPNet is as the following
+
+```python
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    type='EncoderDecoder',
+    pretrained='pretrain_model/resnet50_v1c_trick-2cccc1ad.pth',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='PSPHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        pool_scales=(1, 2, 3, 6),
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)))
+
+```
+
+### Add new loss
+
+Assume you want to add a new loss as `MyLoss` for segmentation decode.
+To add a new loss function, the users need to implement it in `mmseg/models/losses/my_loss.py`.
+The decorator `weighted_loss` enables the loss to be weighted for each element.
+
+```python
+import torch
+import torch.nn as nn
+
+from mmseg.registry import MODELS
+from .utils import weighted_loss
+
+@weighted_loss
+def my_loss(pred, target):
+    assert pred.size() == target.size() and target.numel() > 0
+    loss = torch.abs(pred - target)
+    return loss
+
+@MODELS.register_module()
+class MyLoss(nn.Module):
+
+    def __init__(self, reduction='mean', loss_weight=1.0):
+        super(MyLoss, self).__init__()
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+
+    def forward(self,
+                pred,
+                target,
+                weight=None,
+                avg_factor=None,
+                reduction_override=None):
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        loss = self.loss_weight * my_loss(
+            pred, target, weight, reduction=reduction, avg_factor=avg_factor)
+        return loss
+```
+
+Then the users need to add it in the `mmseg/models/losses/__init__.py`.
+
+```python
+from .my_loss import MyLoss, my_loss
+
+```
+
+To use it, modify the `loss_xxx` field.
+Then you need to modify the `loss_decode` field in the head.
+`loss_weight` could be used to balance multiple losses.
+
+```python
+loss_decode=dict(type='MyLoss', loss_weight=1.0))
+```
+
+### Add new data preprocessor
+
+In MMSegmentation 1.x versions, we use [SegDataPreProcessor](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/data_preprocessor.py#L13) to copy data to the target device and preprocess the data into the model input format as default. Here we show how to develop a new data preprocessor.
+
+1. Create a new file `mmseg/models/my_datapreprocessor.py`.
+
+   ```python
+   from mmengine.model import BaseDataPreprocessor
+
+   from mmseg.registry import MODELS
+
+   @MODELS.register_module()
+   class MyDataPreProcessor(BaseDataPreprocessor):
+       def __init__(self, **kwargs):
+           super().__init__(**kwargs)
+
+       def forward(self, data: dict, training: bool=False) -> Dict[str, Any]:
+           # TODO Define the logic for data pre-processing in the forward method
+           pass
+   ```
+
+2. Import your data preprocessor in `mmseg/models/__init__.py`
+
+   ```python
+   from .my_datapreprocessor import MyDataPreProcessor
+   ```
+
+3. Use it in your config file.
+
+   ```python
+   model = dict(
+       data_preprocessor=dict(type='MyDataPreProcessor)
+       ...
+   )
+   ```
+
+## Develop new segmentors
+
+The segmentor is an algorithmic architecture in which users can customize their algorithms by adding customized components and defining the logic of algorithm execution. Please refer to [the model document](./models.md) for more details.
+
+Since the [BaseSegmentor](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/segmentors/base.py#L15) in MMSegmentation unifies three modes for a forward process, to develop a new segmentor, users need to overwrite `loss`, `predict` and `_forward` methods corresponding to the `loss`, `predict` and `tensor` modes.
+
+Here we show how to develop a new segmentor.
+
+1. Create a new file `mmseg/models/segmentors/my_segmentor.py`.
+
+   ```python
+    from typing import Dict, Optional, Union
+
+    import torch
+
+    from mmseg.registry import MODELS
+    from mmseg.models import BaseSegmentor
+
+    @MODELS.register_module()
+    class MySegmentor(BaseSegmentor):
+        def __init__(self, **kwargs):
+            super().__init__(**kwargs)
+            # TODO users should build components of the network here
+
+        def loss(self, inputs: Tensor, data_samples: SampleList) -> dict:
+            """Calculate losses from a batch of inputs and data samples."""
+            pass
+
+        def predict(self, inputs: Tensor, data_samples: OptSampleList=None) -> SampleList:
+            """Predict results from a batch of inputs and data samples with post-
+            processing."""
+            pass
+
+       def _forward(self,
+                 inputs: Tensor,
+                 data_samples: OptSampleList = None) -> Tuple[List[Tensor]]:
+            """Network forward process.
+
+            Usually includes backbone, neck and head forward without any post-
+            processing.
+            """
+            pass
+   ```
+
+2. Import your segmentor in `mmseg/models/segmentors/__init__.py`.
+
+   ```python
+   from .my_segmentor import MySegmentor
+   ```
+
+3. Use it in your config file.
+
+   ```python
+   model = dict(
+       type='MySegmentor'
+       ...
+   )
+   ```
diff --git a/mmsegmentation/docs/en/advanced_guides/add_transforms.md b/mmsegmentation/docs/en/advanced_guides/add_transforms.md
new file mode 100644
index 0000000..ca336ce
--- /dev/null
+++ b/mmsegmentation/docs/en/advanced_guides/add_transforms.md
@@ -0,0 +1,52 @@
+# Adding New Data Transforms
+
+## Customization data transformation
+
+The customized data transformation must inherited from `BaseTransform` and implement `transform` function.
+Here we use a simple flipping transformation as example:
+
+```python
+import random
+import mmcv
+from mmcv.transforms import BaseTransform, TRANSFORMS
+
+@TRANSFORMS.register_module()
+class MyFlip(BaseTransform):
+    def __init__(self, direction: str):
+        super().__init__()
+        self.direction = direction
+
+    def transform(self, results: dict) -> dict:
+        img = results['img']
+        results['img'] = mmcv.imflip(img, direction=self.direction)
+        return results
+```
+
+Moreover, import the new class.
+
+```python
+from .my_pipeline import MyFlip
+```
+
+Thus, we can instantiate a `MyFlip` object and use it to process the data dict.
+
+```python
+import numpy as np
+
+transform = MyFlip(direction='horizontal')
+data_dict = {'img': np.random.rand(224, 224, 3)}
+data_dict = transform(data_dict)
+processed_img = data_dict['img']
+```
+
+Or, we can use `MyFlip` transformation in data pipeline in our config file.
+
+```python
+pipeline = [
+    ...
+    dict(type='MyFlip', direction='horizontal'),
+    ...
+]
+```
+
+Note that if you want to use `MyFlip` in config, you must ensure the file containing `MyFlip` is imported during runtime.
diff --git a/mmsegmentation/docs/en/advanced_guides/customize_runtime.md b/mmsegmentation/docs/en/advanced_guides/customize_runtime.md
new file mode 100644
index 0000000..33281bf
--- /dev/null
+++ b/mmsegmentation/docs/en/advanced_guides/customize_runtime.md
@@ -0,0 +1,168 @@
+# Customize Runtime Settings
+
+## Customize hooks
+
+### Step 1: Implement a new hook
+
+MMEngine has implemented commonly used [hooks](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/hook.md) for training and test,
+When users have requirements for customization, they can follow examples below.
+For example, if some hyper-parameter of the model needs to be changed when model training, we can implement a new hook for it:
+
+```python
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Sequence
+
+from mmengine.hooks import Hook
+from mmengine.model import is_model_wrapper
+
+from mmseg.registry import HOOKS
+
+
+@HOOKS.register_module()
+class NewHook(Hook):
+    """Docstring for NewHook.
+    """
+
+    def __init__(self, a: int, b: int) -> None:
+        self.a = a
+        self.b = b
+
+    def before_train_iter(self,
+                          runner,
+                          batch_idx: int,
+                          data_batch: Optional[Sequence[dict]] = None) -> None:
+        cur_iter = runner.iter
+        # acquire this model when it is in a wrapper
+        if is_model_wrapper(runner.model):
+          model = runner.model.module
+        model.hyper_parameter = self.a * cur_iter + self.b
+```
+
+### Step 2: Import a new hook
+
+The module which is defined above needs to be imported into main namespace first to ensure being registered.
+We assume `NewHook` is implemented in `mmseg/engine/hooks/new_hook.py`, there are two ways to import it:
+
+- Import it by modifying `mmseg/engine/hooks/__init__.py`.
+  Modules should be imported in `mmseg/engine/hooks/__init__.py` thus these new modules can be found and added by registry.
+
+```python
+from .new_hook import NewHook
+
+__all__ = [..., NewHook]
+```
+
+- Import it manually by `custom_imports` in config file.
+
+```python
+custom_imports = dict(imports=['mmseg.engine.hooks.new_hook'], allow_failed_imports=False)
+```
+
+### Step 3: Modify config file
+
+Users can set and use customized hooks in training and test followed methods below.
+The execution priority of hooks at the same place of `Runner` can be referred [here](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/hook.md#built-in-hooks),
+Default priority of customized hook is `NORMAL`.
+
+```python
+custom_hooks = [
+    dict(type='NewHook', a=a_value, b=b_value, priority='ABOVE_NORMAL')
+]
+```
+
+## Customize optimizer
+
+### Step 1: Implement a new optimizer
+
+We recommend the customized optimizer implemented in `mmseg/engine/optimizers/my_optimizer.py`. Here is an example of a new optimizer `MyOptimizer` which has parameters `a`, `b` and `c`:
+
+```python
+from mmseg.registry import OPTIMIZERS
+from torch.optim import Optimizer
+
+
+@OPTIMIZERS.register_module()
+class MyOptimizer(Optimizer):
+
+    def __init__(self, a, b, c)
+```
+
+### Step 2: Import a new optimizer
+
+The module which is defined above needs to be imported into main namespace first to ensure being registered.
+We assume `MyOptimizer` is implemented in `mmseg/engine/optimizers/my_optimizer.py`, there are two ways to import it:
+
+- Import it by modifying `mmseg/engine/optimizers/__init__.py`.
+  Modules should be imported in `mmseg/engine/optimizers/__init__.py` thus these new modules can be found and added by registry.
+
+```python
+from .my_optimizer import MyOptimizer
+```
+
+- Import it manually by `custom_imports` in config file.
+
+```python
+custom_imports = dict(imports=['mmseg.engine.optimizers.my_optimizer'], allow_failed_imports=False)
+```
+
+### Step 3: Modify config file
+
+Then it needs to modify `optimizer` in `optim_wrapper` of config file, if users want to use customized `MyOptimizer`, it can be modified as:
+
+```python
+optim_wrapper = dict(type='OptimWrapper',
+                     optimizer=dict(type='MyOptimizer',
+                                    a=a_value, b=b_value, c=c_value),
+                     clip_grad=None)
+```
+
+## Customize optimizer constructor
+
+### Step 1: Implement a new optimizer constructor
+
+Optimizer constructor is used to create optimizer and optimizer wrapper for model training, which has powerful functions like specifying learning rate and weight decay for different model layers.
+Here is an example for a customized optimizer constructor.
+
+```python
+from mmengine.optim import DefaultOptimWrapperConstructor
+from mmseg.registry import OPTIM_WRAPPER_CONSTRUCTORS
+
+@OPTIM_WRAPPER_CONSTRUCTORS.register_module()
+class LearningRateDecayOptimizerConstructor(DefaultOptimWrapperConstructor):
+    def __init__(self, optim_wrapper_cfg, paramwise_cfg=None):
+
+    def __call__(self, model):
+
+        return my_optimizer
+```
+
+Default optimizer constructor is implemented [here](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py#L19).
+It can also be used as base class of new optimizer constructor.
+
+### Step 2: Import a new optimizer constructor
+
+The module which is defined above needs to be imported into main namespace first to ensure being registered.
+We assume `MyOptimizerConstructor` is implemented in `mmseg/engine/optimizers/my_optimizer_constructor.py`, there are two ways to import it:
+
+- Import it by modifying `mmseg/engine/optimizers/__init__.py`.
+  Modules should be imported in `mmseg/engine/optimizers/__init__.py` thus these new modules can be found and added by registry.
+
+```python
+from .my_optimizer_constructor import MyOptimizerConstructor
+```
+
+- Import it manually by `custom_imports` in config file.
+
+```python
+custom_imports = dict(imports=['mmseg.engine.optimizers.my_optimizer_constructor'], allow_failed_imports=False)
+```
+
+### Step 3: Modify config file
+
+Then it needs to modify `constructor` in `optim_wrapper` of config file, if users want to use customized `MyOptimizerConstructor`, it can be modified as:
+
+```python
+optim_wrapper = dict(type='OptimWrapper',
+                     constructor='MyOptimizerConstructor',
+                     clip_grad=None)
+```
diff --git a/mmsegmentation/docs/en/advanced_guides/data_flow.md b/mmsegmentation/docs/en/advanced_guides/data_flow.md
new file mode 100644
index 0000000..404035a
--- /dev/null
+++ b/mmsegmentation/docs/en/advanced_guides/data_flow.md
@@ -0,0 +1,87 @@
+# Dataflow
+
+In this chapter, we will introduce the dataflow and data format convention between the internal modules managed by the [Runner](https://mmengine.readthedocs.io/en/latest/tutorials/runner.html).
+
+## Overview of dataflow
+
+The [Runner](https://github.com/open-mmlab/mmengine/blob/main/docs/en/design/runner.md) is an "integrator" in MMEngine. It covers all aspects of the framework and shoulders the responsibility of organizing and scheduling nearly all modules, that means the dataflow between all modules also controlled by the `Runner`. As illustrated in the [Runner document of MMEngine](https://mmengine.readthedocs.io/en/latest/tutorials/runner.html), the following diagram shows the basic dataflow.
+
+![Basic dataflow](https://user-images.githubusercontent.com/112053249/199228350-5f80699e-7fd2-4b4c-ac32-0b16b1922c2e.png)
+
+The dashed border, gray filled shapes represent different data formats, while solid boxes represent modules/methods. Due to the great flexibility and extensibility of MMEngine, some critical base classes can be inherited and their methods can be overridden. The diagram above only holds when users are not customizing `TrainLoop`, `ValLoop`, and `TestLoop` in `Runner`, and are not overriding `train_step`, `val_step` and `test_step` method in their custom model. The default setting of loops in MMSegmentation is as follows, it uses `IterBasedTrainLoop` to train models with 20000 iterations in total and do evaluation each 2000 iterations.
+
+```python
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=20000, val_interval=2000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+```
+
+In the above diagram, the red line indicates the [train_step](./models.md#train_step). At each training iteration, dataloader loads images from storage and transfer to data preprocessor, data preprocessor would put images to the specific device and stack data to batch, then model accepts the batch data as inputs, finally the outputs of the model would be sent to optimizer. The blue line indicates [val_step](./models.md#val_step) and [test_step](./models.md#test_step). The dataflow of these two process is similar to the `train_step` except the outputs of model, since model parameters are freezed when doing evaluation, the model output would be transferred to [Evaluator](./evaluation.md#ioumetric) to compute metrics.
+
+## Dataflow convention in MMSegmentation
+
+From the diagram above, we could see the basic dataflow. In this section, we would introduce format convention of data involved in this dataflow, respectively.
+
+### DataLoader to Data Preprocessor
+
+DataLoader is an essential component in training and testing pipelines of MMEngine. Conceptually, it is derived from and consistent with [PyTorch](https://pytorch.org/). DataLoader loads data from filesystem and the original data passes through data preparation pipeline, then it would be sent to Data Preprocessor.
+
+MMSegmentation defines the default data format at [PackSegInputs](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/transforms/formatting.py#L12), it's the last component of `train_pipeline` and `test_pipeline`. Please refer to [data transform documentation](./transforms.md) for more information about data transform `pipeline`.
+
+Without any modifications, the return value of PackSegInputs is usually a `dict` and has only two keys, `inputs` and `data_samples`. The following pseudo-code shows the data types of the data loader output in mmseg, which is a batch of fetched data samples from the dataset, and data loader packs them into a dictionary of the list. `inputs` is the list of input tensors to the model and `data_samples` contains a list of input images' meta information and corresponding ground truth.
+
+```python
+dict(
+    inputs=List[torch.Tensor],
+    data_samples=List[SegDataSample]
+)
+```
+
+**Note:** [SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py) is a data structure interface of MMSegmentation, it is used as an interface between different components. `SegDataSample` implements the abstract data element `mmengine.structures.BaseDataElement`, please refer to [the SegDataSample documentation](./structures.md) and [data element documentation](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/data_element.html) in [MMEngine](https://github.com/open-mmlab/mmengine) for more information.
+
+### Data Preprocessor to Model
+
+Though drawn separately in the diagram [above](#overview-of-dataflow), data_preprocessor is a part of the model and thus can be found in [Model tutorial](./models.md) at data preprocessor chapter.
+
+The return value of data preprocessor is a dictionary, containing `inputs` and `data_samples`, `inputs` is batched images, a 4D tensor, and some additional meta info used in data preprocesses would be added to the `data_samples`. When transferred to the network, the dictionary would be unpacked to two values. The following pseudo-codes show the return value of the data preprocessor and the input values of model.
+
+```python
+dict(
+    inputs=torch.Tensor,
+    data_samples=List[SegDataSample]
+)
+```
+
+```python
+class Network(BaseSegmentor):
+
+    def forward(self, inputs: torch.Tensor, data_samples: List[SegDataSample], mode: str):
+        pass
+```
+
+**Note:** Model forward has 3 kinds of mode, which is controlled by input argumentmode, please refer [model tutorial](./models.md) for more details.
+
+### Model output
+
+As [model tutorial](./models.md#forward) mentioned 3 kinds of mode forward with 3 kinds of output. `train_step`and `test_step`(or `val_step`) correspond to `'loss'` and `'predict'` respectively.
+
+In `test_step` or `val_step`, the inference results would be transferred to `Evaluator`. You might read the [evaluation document](./evaluation.md) for more information about `Evaluator`.
+
+After inference, the [BaseSegmentor](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/segmentors/base.py#L15) in MMSegmentation would do a simple post process to pack inference results, the segmentation logits produced by the neural network, segmentation mask after the `argmax` operation and ground truth(if exists) would be packed into a similar `SegDataSample` instance. The return value of [postprocess_result](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/segmentors/base.py#L132) is a **`List` of `SegDataSample`**. Following diagram shows the key properties of these `SegDataSample` instances.
+
+![SegDataSample](https://user-images.githubusercontent.com/15952744/209912225-ab46a8d9-904a-43cb-8bf1-8bec4938ed29.png)
+
+The same as Data Preprocessor, loss function is also a part of the model, it's a property of [decode head](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/decode_heads/decode_head.py#L142).
+
+In MMSegmentation, the method [loss_by_feat](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/decode_heads/decode_head.py#L291) of `decode_head` is an unified interface used to compute loss.
+
+Parameters:
+
+- seg_logits (Tensor): The output from decode head forward function.
+- batch_data_samples (List\[:obj:`SegDataSample`\]): The seg data samples. It usually includes information such as `metainfo` and `gt_sem_seg`.
+
+Returns:
+
+- dict\[str, Tensor\]: a dictionary of loss components
+
+**Note:** The `train_step` transfers the loss into OptimWrapper to update the weights in model, please refer [train_step](./models.md#train_step) for more details.
diff --git a/mmsegmentation/docs/en/advanced_guides/datasets.md b/mmsegmentation/docs/en/advanced_guides/datasets.md
new file mode 100644
index 0000000..1efc334
--- /dev/null
+++ b/mmsegmentation/docs/en/advanced_guides/datasets.md
@@ -0,0 +1,386 @@
+# Dataset
+
+Dataset classes in MMSegmentation have two functions: (1) load data information after [data preparation](../user_guides/2_dataset_prepare.md)
+and (2) send data into [dataset transform pipeline](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/basesegdataset.py#L141) to do [data augmentation](./transforms.md).
+There are 2 kinds of loaded information: (1) meta information which is original dataset information such as categories (classes) of dataset and their corresponding palette information, (2) data information which includes
+the path of dataset images and labels.
+The tutorial includes some main interfaces in MMSegmentation 1.x dataset class: methods of loading data information and modifying dataset classes in base dataset class, and the relationship between dataset and the data transform pipeline.
+
+## Main Interfaces
+
+Take Cityscapes as an example, if you want to run the example, please download and [preprocess](../user_guides/2_dataset_prepare.md#cityscapes)
+Cityscapes dataset in `data` directory, before running the demo code:
+
+Instantiate Cityscapes training dataset:
+
+```python
+from mmseg.datasets import CityscapesDataset
+from mmengine.registry import init_default_scope
+init_default_scope('mmseg')
+
+data_root = 'data/cityscapes/'
+data_prefix=dict(img_path='leftImg8bit/train', seg_map_path='gtFine/train')
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='RandomCrop', crop_size=(512, 1024), cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackSegInputs')
+]
+
+dataset = CityscapesDataset(data_root=data_root, data_prefix=data_prefix, test_mode=False, pipeline=train_pipeline)
+```
+
+Get the length of training set:
+
+```python
+print(len(dataset))
+
+2975
+```
+
+Get data information: The type of data information is `dict` which includes several keys:
+
+- `'img_path'`: path of images
+- `'seg_map_path'`: path of segmentation labels
+- `'seg_fields'`: saving label fields
+- `'sample_idx'`: the  index of the current sample
+
+There are also `'label_map'` and `'reduce_zero_label'` whose functions would be introduced in the next section.
+
+```python
+# Acquire data information of first sample in dataset
+print(dataset.get_data_info(0))
+
+{'img_path': 'data/cityscapes/leftImg8bit/train/aachen/aachen_000000_000019_leftImg8bit.png',
+ 'seg_map_path': 'data/cityscapes/gtFine/train/aachen/aachen_000000_000019_gtFine_labelTrainIds.png',
+ 'label_map': None,
+ 'reduce_zero_label': False,
+ 'seg_fields': [],
+ 'sample_idx': 0}
+```
+
+Get dataset meta information: the type of MMSegmentation meta information is also `dict`, which includes `'classes'` field for dataset classes and `'palette'` field for corresponding colors in visualization, and has `'label_map'` field and `'reduce_zero_label'` filed.
+
+```python
+print(dataset.metainfo)
+
+{'classes': ('road',
+  'sidewalk',
+  'building',
+  'wall',
+  'fence',
+  'pole',
+  'traffic light',
+  'traffic sign',
+  'vegetation',
+  'terrain',
+  'sky',
+  'person',
+  'rider',
+  'car',
+  'truck',
+  'bus',
+  'train',
+  'motorcycle',
+  'bicycle'),
+ 'palette': [[128, 64, 128],
+  [244, 35, 232],
+  [70, 70, 70],
+  [102, 102, 156],
+  [190, 153, 153],
+  [153, 153, 153],
+  [250, 170, 30],
+  [220, 220, 0],
+  [107, 142, 35],
+  [152, 251, 152],
+  [70, 130, 180],
+  [220, 20, 60],
+  [255, 0, 0],
+  [0, 0, 142],
+  [0, 0, 70],
+  [0, 60, 100],
+  [0, 80, 100],
+  [0, 0, 230],
+  [119, 11, 32]],
+ 'label_map': None,
+ 'reduce_zero_label': False}
+```
+
+The return value of dataset `__getitem__` method is the output of data samples after data augmentation, whose type is also `dict`. It has two fields: `'inputs'` corresponding to images after data augmentation,
+and `'data_samples'` corresponding to [`SegDataSample`](./structures.md) which is new data structures in MMSegmentation 1.x,
+and `gt_sem_seg` of `SegDataSample` has labels after data augmentation operations.
+
+```python
+print(dataset[0])
+
+{'inputs': tensor([[[131, 130, 130,  ...,  23,  23,  23],
+          [132, 132, 132,  ...,  23,  22,  23],
+          [134, 133, 133,  ...,  23,  23,  23],
+          ...,
+          [ 66,  67,  67,  ...,  71,  71,  71],
+          [ 66,  67,  66,  ...,  68,  68,  68],
+          [ 67,  67,  66,  ...,  70,  70,  70]],
+
+         [[143, 143, 142,  ...,  28,  28,  29],
+          [145, 145, 145,  ...,  28,  28,  29],
+          [145, 145, 145,  ...,  27,  28,  29],
+          ...,
+          [ 75,  75,  76,  ...,  80,  81,  81],
+          [ 75,  76,  75,  ...,  80,  80,  80],
+          [ 77,  76,  76,  ...,  82,  82,  82]],
+
+         [[126, 125, 126,  ...,  21,  21,  22],
+          [127, 127, 128,  ...,  21,  21,  22],
+          [127, 127, 126,  ...,  21,  21,  22],
+          ...,
+          [ 63,  63,  64,  ...,  69,  69,  70],
+          [ 64,  65,  64,  ...,  69,  69,  69],
+          [ 65,  66,  66,  ...,  72,  71,  71]]], dtype=torch.uint8),
+ 'data_samples': <SegDataSample(
+
+     META INFORMATION
+     img_path: 'data/cityscapes/leftImg8bit/train/aachen/aachen_000000_000019_leftImg8bit.png'
+     seg_map_path: 'data/cityscapes/gtFine/train/aachen/aachen_000000_000019_gtFine_labelTrainIds.png'
+     img_shape: (512, 1024, 3)
+     flip_direction: None
+     ori_shape: (1024, 2048)
+     flip: False
+
+     DATA FIELDS
+     gt_sem_seg: <PixelData(
+
+             META INFORMATION
+
+             DATA FIELDS
+             data: tensor([[[2, 2, 2,  ..., 8, 8, 8],
+                          [2, 2, 2,  ..., 8, 8, 8],
+                          [2, 2, 2,  ..., 8, 8, 8],
+                          ...,
+                          [0, 0, 0,  ..., 0, 0, 0],
+                          [0, 0, 0,  ..., 0, 0, 0],
+                          [0, 0, 0,  ..., 0, 0, 0]]])
+         )>
+     _gt_sem_seg: <PixelData(
+
+             META INFORMATION
+
+             DATA FIELDS
+             data: tensor([[[2, 2, 2,  ..., 8, 8, 8],
+                          [2, 2, 2,  ..., 8, 8, 8],
+                          [2, 2, 2,  ..., 8, 8, 8],
+                          ...,
+                          [0, 0, 0,  ..., 0, 0, 0],
+                          [0, 0, 0,  ..., 0, 0, 0],
+                          [0, 0, 0,  ..., 0, 0, 0]]])
+         )>
+ )}
+```
+
+## BaseSegDataset
+
+As mentioned above, dataset classes have the same functions, we implemented  [`BaseSegDataset`](https://mmsegmentation.readthedocs.io/en/latest/api.html?highlight=BaseSegDataset#mmseg.datasets.BaseSegDataset) to reues the common functions.
+It inherits [`BaseDataset` of MMEngine](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/basedataset.md) and follows unified initialization process of OpenMMLab. It supports the highly effective interior storing format, some functions like
+dataset concatenation and repeatedly sampling. In MMSegmentation `BaseSegDataset`, the **method of loading data information** (`load_data_list`) is redefined and adds new `get_label_map` method to **modify dataset classes information**.
+
+### Loading Dataset Information
+
+The loaded data information includes the path of images samples and annotations samples, the detailed implementation could be found in
+[`load_data_list`](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/basesegdataset.py#L231) of `BaseSegDataset` in MMSegmentation.
+There are two main methods to acquire the path of images and labels:
+
+1. Load file paths according to the dirictory and suffix of input images and annotations
+
+If the dataset directory structure is organized as below, the [`load_data_list`](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/basesegdataset.py#L231) can parse dataset directory Structure:
+
+```
+├── data
+│   ├── my_dataset
+│   │   ├── img_dir
+│   │   │   ├── train
+│   │   │   │   ├── xxx{img_suffix}
+│   │   │   │   ├── yyy{img_suffix}
+│   │   │   ├── val
+│   │   │   │   ├── zzz{img_suffix}
+│   │   ├── ann_dir
+│   │   │   ├── train
+│   │   │   │   ├── xxx{seg_map_suffix}
+│   │   │   │   ├── yyy{seg_map_suffix}
+│   │   │   ├── val
+│   │   │   │   ├── zzz{seg_map_suffix}
+```
+
+Here is an example pf ADE20K, and below the directory structure of the dataset:
+
+```
+├── ade
+│   ├── ADEChallengeData2016
+│   │   ├── annotations
+│   │   │   ├── training
+│   │   │   │   ├── ADE_train_00000001.png
+│   │   │   │   ├── ...
+│   │   │   │── validation
+│   │   │   │   ├── ADE_val_00000001.png
+│   │   │   │   ├── ...
+│   │   ├── images
+│   │   │   ├── training
+│   │   │   │   ├── ADE_train_00000001.jpg
+│   │   │   │   ├── ...
+│   │   │   ├── validation
+│   │   │   │   ├── ADE_val_00000001.jpg
+│   │   │   │   ├── ...
+```
+
+```python
+from mmseg.datasets import ADE20KDataset
+
+ADE20KDataset(data_root = 'data/ade/ADEChallengeData2016',
+    data_prefix=dict(img_path='images/training', seg_map_path='annotations/training'),
+    img_suffix='.jpg',
+    seg_map_suffix='.png',
+    reduce_zero_label=True)
+```
+
+2. Load file paths from annotation file
+
+Dataset also can load an annotation file which includes the data sample paths of dataset.
+Take PascalContext dataset instance as an example, its input annotation file is:
+
+```python
+2008_000008
+...
+```
+
+It needs to define `ann_file` when instantiation:
+
+```python
+PascalContextDataset(data_root='data/VOCdevkit/VOC2010/',
+    data_prefix=dict(img_path='JPEGImages', seg_map_path='SegmentationClassContext'),
+    ann_file='ImageSets/SegmentationContext/train.txt')
+```
+
+### Modification of Dataset Classes
+
+- Use `metainfo` input argument
+
+Meta information is defined as class variables, such as `METAINFO` variable of Cityscapes:
+
+```python
+class CityscapesDataset(BaseSegDataset):
+    """Cityscapes dataset.
+
+    The ``img_suffix`` is fixed to '_leftImg8bit.png' and ``seg_map_suffix`` is
+    fixed to '_gtFine_labelTrainIds.png' for Cityscapes dataset.
+    """
+    METAINFO = dict(
+        classes=('road', 'sidewalk', 'building', 'wall', 'fence', 'pole',
+                 'traffic light', 'traffic sign', 'vegetation', 'terrain',
+                 'sky', 'person', 'rider', 'car', 'truck', 'bus', 'train',
+                 'motorcycle', 'bicycle'),
+        palette=[[128, 64, 128], [244, 35, 232], [70, 70, 70], [102, 102, 156],
+                 [190, 153, 153], [153, 153, 153], [250, 170,
+                                                    30], [220, 220, 0],
+                 [107, 142, 35], [152, 251, 152], [70, 130, 180],
+                 [220, 20, 60], [255, 0, 0], [0, 0, 142], [0, 0, 70],
+                 [0, 60, 100], [0, 80, 100], [0, 0, 230], [119, 11, 32]])
+
+```
+
+Here `'classes'` defines class names of Cityscapes dataset annotations, if users only concern some classes about vehicles and **ignore other classes**,
+the meta information of dataset could be modified by defined input argument `metainfo` when instantiating Cityscapes dataset:
+
+```python
+from mmseg.datasets import CityscapesDataset
+
+data_root = 'data/cityscapes/'
+data_prefix=dict(img_path='leftImg8bit/train', seg_map_path='gtFine/train')
+# metainfo only keep classes below:
+metainfo=dict(classes=( 'car', 'truck', 'bus', 'train', 'motorcycle', 'bicycle'))
+dataset = CityscapesDataset(data_root=data_root, data_prefix=data_prefix, metainfo=metainfo)
+
+print(dataset.metainfo)
+
+{'classes': ('car', 'truck', 'bus', 'train', 'motorcycle', 'bicycle'),
+ 'palette': [[0, 0, 142],
+  [0, 0, 70],
+  [0, 60, 100],
+  [0, 80, 100],
+  [0, 0, 230],
+  [119, 11, 32],
+  [128, 64, 128],
+  [244, 35, 232],
+  [70, 70, 70],
+  [102, 102, 156],
+  [190, 153, 153],
+  [153, 153, 153],
+  [250, 170, 30],
+  [220, 220, 0],
+  [107, 142, 35],
+  [152, 251, 152],
+  [70, 130, 180],
+  [220, 20, 60],
+  [255, 0, 0]],
+ # pixels whose label index are 255 would be ignored when calculating loss
+ 'label_map': {0: 255,
+  1: 255,
+  2: 255,
+  3: 255,
+  4: 255,
+  5: 255,
+  6: 255,
+  7: 255,
+  8: 255,
+  9: 255,
+  10: 255,
+  11: 255,
+  12: 255,
+  13: 0,
+  14: 1,
+  15: 2,
+  16: 3,
+  17: 4,
+  18: 5},
+ 'reduce_zero_label': False}
+```
+
+Meta information is different from default setting of Cityscapes dataset. Moreover, `label_map` field is also defined, which is used for modifying label index of each pixel on segmentation mask.
+The segmentation label would re-map class information by `label_map`, [here](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/basesegdataset.py#L151) is detailed implementation:
+
+```python
+gt_semantic_seg_copy = gt_semantic_seg.copy()
+for old_id, new_id in results['label_map'].items():
+    gt_semantic_seg[gt_semantic_seg_copy == old_id] = new_id
+```
+
+- Using `reduce_zero_label` input argument
+
+To ignore label 0 (such as ADE20K dataset), we can use `reduce_zero_label` (default to `False`) argument of BaseSegDataset and its subclasses.
+When `reduce_zero_label` is `True`, label 0 in segmentation annotations would be set as 255 (models of MMSegmentation would ignore label 255 in calculating loss) and indices of other labels will minus 1:
+
+```python
+gt_semantic_seg[gt_semantic_seg == 0] = 255
+gt_semantic_seg = gt_semantic_seg - 1
+gt_semantic_seg[gt_semantic_seg == 254] = 255
+```
+
+## Dataset and Data Transform Pipeline
+
+If the argument `pipeline` is defined, the return value of `__getitem__` method is after data argument.
+If dataset input argument does not define pipeline, it is the same as return value of `get_data_info` method.
+
+```python
+from mmseg.datasets import CityscapesDataset
+
+data_root = 'data/cityscapes/'
+data_prefix=dict(img_path='leftImg8bit/train', seg_map_path='gtFine/train')
+dataset = CityscapesDataset(data_root=data_root, data_prefix=data_prefix, test_mode=False)
+
+print(dataset[0])
+
+{'img_path': 'data/cityscapes/leftImg8bit/train/aachen/aachen_000000_000019_leftImg8bit.png',
+ 'seg_map_path': 'data/cityscapes/gtFine/train/aachen/aachen_000000_000019_gtFine_labelTrainIds.png',
+ 'label_map': None,
+ 'reduce_zero_label': False,
+ 'seg_fields': [],
+ 'sample_idx': 0}
+```
diff --git a/mmsegmentation/docs/en/advanced_guides/engine.md b/mmsegmentation/docs/en/advanced_guides/engine.md
new file mode 100644
index 0000000..7acfe5a
--- /dev/null
+++ b/mmsegmentation/docs/en/advanced_guides/engine.md
@@ -0,0 +1,279 @@
+# Training Engine
+
+MMEngine defined some [basic loop controllers](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py) such as epoch-based training loop (`EpochBasedTrainLoop`), iteration-based training loop (`IterBasedTrainLoop`), standard validation loop (`ValLoop`), and standard testing loop (`TestLoop`).
+
+OpenMMLab's algorithm libraries like MMSegmentation abstract model training, testing, and inference as `Runner` to handle. Users can use the default `Runner` in MMEngine directly or modify the `Runner` to meet customized needs. This document mainly introduces how users can configure existing running settings, hooks, and optimizers' basic concepts and usage methods.
+
+## Configuring Runtime Settings
+
+### Configuring Training Iterations
+
+Loop controllers refer to the execution process during training, validation, and testing. `train_cfg`, `val_cfg`, and `test_cfg` are used to build these processes in the configuration file. MMSegmentation sets commonly used training iterations in `train_cfg` under the `configs/_base_/schedules` folder.
+For example, to train for 80,000 iterations using the iteration-based training loop (`IterBasedTrainLoop`) and perform validation every 8,000 iterations, you can set it as follows:
+
+```python
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=80000, val_interval=8000)
+```
+
+### Configuring Training Optimizers
+
+Here's an example of a SGD optimizer:
+
+```python
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005),
+    clip_grad=None)
+```
+
+OpenMMLab supports all optimizers in PyTorch. For more details, please refer to the [MMEngine optimizer documentation](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/optim_wrapper.md).
+
+It is worth emphasizing that `optim_wrapper` is a variable of `runner`, so when configuring the optimizer, the field to configure is the `optim_wrapper` field. For more information on using optimizers, see the [Optimizer](#Optimizer) section below.
+
+### Configuring Training Parameter Schedulers
+
+Before configuring the training parameter scheduler, it is recommended to first understand the basic concepts of parameter schedulers in the [MMEngine documentation](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/param_scheduler.md).
+
+Here's an example of a parameter scheduler. During training, a linearly changing learning rate strategy is used for warm-up in the first 1,000 iterations. After the first 1,000 iterations until the 16,000 iterations in the end, the default polynomial learning rate decay is used:
+
+```python
+param_scheduler = [
+    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=1000,
+        end=160000,
+        by_epoch=False,
+    )
+]
+```
+
+Note: When modifying the `max_iters` in `train_cfg`, make sure the parameters in the parameter scheduler `param_scheduler` are also modified accordingly.
+
+## Hook
+
+### Introduction
+
+OpenMMLab abstracts the model training and testing process as `Runner`. Inserting hooks can implement the corresponding functionality needed at different training and testing stages (such as "before and after each training iter", "before and after each validation iter", etc.) in `Runner`. For more introduction on hook mechanisms, please refer to [here](https://www.calltutors.com/blog/what-is-hook).
+
+Hooks used in `Runner` are divided into two categories:
+
+- Default hooks:
+
+They implement essential functions during training and are defined in the configuration file by `default_hooks` and passed to `Runner`. `Runner` registers them through the [`register_default_hooks`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py#L1780) method.
+
+Hooks have corresponding priorities; the higher the priority, the earlier the runner calls them. If the priorities are the same, the calling order is consistent with the hook registration order.
+
+It is not recommended for users to modify the default hook priorities. Please refer to the [MMEngine hooks documentation](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/hook.md) to understand the hook priority definitions.
+
+The following are the default hooks used in MMSegmentation:
+
+|                                                          Hook                                                          |                                                          Function                                                          |     Priority      |
+| :--------------------------------------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------: | :---------------: |
+|          [IterTimerHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/iter_timer_hook.py)           |                                          Record the time spent on each iteration.                                          |    NORMAL (50)    |
+|              [LoggerHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/logger_hook.py)              | Collect log records from different components in `Runner` and output them to terminal, JSON file, tensorboard, wandb, etc. | BELOW_NORMAL (60) |
+|     [ParamSchedulerHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/param_scheduler_hook.py)      |                       Update some hyperparameters in the optimizer, such as learning rate momentum.                        |     LOW (70)      |
+|          [CheckpointHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/checkpoint_hook.py)          |                                              Regularly save checkpoint files.                                              |   VERY_LOW (90)   |
+|      [DistSamplerSeedHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/sampler_seed_hook.py)       |                                     Ensure the distributed sampler shuffle is enabled.                                     |    NORMAL (50)    |
+| [SegVisualizationHook](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/visualization/local_visualizer.py) |                                Visualize prediction results during validation and testing.                                 |    NORMAL (50)    |
+
+MMSegmentation registers some hooks with essential training functions in `default_hooks`:
+
+```python
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=32000),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))
+```
+
+All the default hooks mentioned above, except for `SegVisualizationHook`, are implemented in MMEngine. The `SegVisualizationHook` is a hook implemented in MMSegmentation, which will be introduced later.
+
+- Modifying default hooks
+
+We will use the `logger` and `checkpoint` in `default_hooks` as examples to demonstrate how to modify the default hooks in `default_hooks`.
+
+(1) Model saving configuration
+
+`default_hooks` uses the `checkpoint` field to initialize the [model saving hook (CheckpointHook)](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/checkpoint_hook.py#L19).
+
+```python
+checkpoint = dict(type='CheckpointHook', interval=1)
+```
+
+Users can set `max_keep_ckpts` to save only a small number of checkpoints or use `save_optimizer` to determine whether to save optimizer information. More details on related parameters can be found [here](https://mmengine.readthedocs.io/en/latest/api/generated/mmengine.hooks.CheckpointHook.html#checkpointhook).
+
+(2) Logging configuration
+
+The `LoggerHook` is used to collect log information from different components in `Runner` and write it to terminal, JSON files, tensorboard, wandb, etc.
+
+```python
+logger=dict(type='LoggerHook', interval=10)
+```
+
+In the latest 1.x version of MMSegmentation, some logger hooks (LoggerHook) such as `TextLoggerHook`, `WandbLoggerHook`, and `TensorboardLoggerHook` will no longer be used. Instead, MMEngine uses `LogProcessor` to handle the information processed by the aforementioned hooks, which are now in [`MessageHub`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/logging/message_hub.py#L17), [`WandbVisBackend`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/visualization/vis_backend.py#L324), and [`TensorboardVisBackend`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/visualization/vis_backend.py#L472).
+
+Detailed usage is as follows, configuring the visualizer and specifying the visualization backend at the same time, here using Tensorboard as the visualizer's backend:
+
+```python
+# TensorboardVisBackend
+visualizer = dict(
+    type='SegLocalVisualizer', vis_backends=[dict(type='TensorboardVisBackend')], name='visualizer')
+```
+
+For more related usage, please refer to [MMEngine Visualization Backend User Tutorial](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/visualization.md).
+
+- Custom hooks
+
+Custom hooks are defined in the configuration through `custom_hooks`, and `Runner` registers them using the [`register_custom_hooks`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py#L1820) method.
+
+The priority of custom hooks needs to be set in the configuration file; if not, it will be set to `NORMAL` by default. The following are some custom hooks implemented in MMEngine:
+
+|                                                  Hook                                                  |                                                               Usage                                                                |
+| :----------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------: |
+|         [EMAHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/ema_hook.py)         |                                    Use Exponential Moving Average (EMA) during model training.                                     |
+| [EmptyCacheHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/empty_cache_hook.py)  |                                  Release all GPU memory not occupied by the cache during training                                  |
+| [SyncBuffersHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/sync_buffer_hook.py) | Synchronize the parameters in the model buffer, such as `running_mean` and `running_var` in BN, at the end of each training epoch. |
+
+The following is a use case for `EMAHook`, where the config file includes the configuration of the implemented custom hooks as members of the `custom_hooks` list.
+
+```python
+custom_hooks = [
+    dict(type='EMAHook', start_iters=500, priority='NORMAL')
+]
+```
+
+### SegVisualizationHook
+
+MMSegmentation implemented [`SegVisualizationHook`](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/engine/hooks/visualization_hook.py#L17), which is used to visualize prediction results during validation and testing.
+`SegVisualizationHook` overrides the `_after_iter` method in the base class `Hook`. During validation or testing, it calls the `add_datasample` method of `visualizer` to draw semantic segmentation results according to the specified iteration interval. The specific implementation is as follows:
+
+```python
+...
+@HOOKS.register_module()
+class SegVisualizationHook(Hook):
+...
+    def _after_iter(self,
+                    runner: Runner,
+                    batch_idx: int,
+                    data_batch: dict,
+                    outputs: Sequence[SegDataSample],
+                    mode: str = 'val') -> None:
+...
+        # If it's a training phase or self.draw is False, then skip it
+        if self.draw is False or mode == 'train':
+            return
+...
+        if self.every_n_inner_iters(batch_idx, self.interval):
+            for output in outputs:
+                img_path = output.img_path
+                img_bytes = self.file_client.get(img_path)
+                img = mmcv.imfrombytes(img_bytes, channel_order='rgb')
+                window_name = f'{mode}_{osp.basename(img_path)}'
+
+                self._visualizer.add_datasample(
+                    window_name,
+                    img,
+                    data_sample=output,
+                    show=self.show,
+                    wait_time=self.wait_time,
+                    step=runner.iter)
+
+```
+
+For more details about visualization, you can check [here](../user_guides/visualization.md).
+
+## Optimizer
+
+In the previous configuration and runtime settings, we provided a simple example of configuring the training optimizer. This section will further detailly introduce  how to configure optimizers in MMSegmentation.
+
+## Optimizer Wrapper
+
+OpenMMLab 2.0 introduces an optimizer wrapper that supports different training strategies, including mixed-precision training, gradient accumulation, and gradient clipping. Users can choose the appropriate training strategy according to their needs. The optimizer wrapper also defines a standard parameter update process, allowing users to switch between different training strategies within the same code. For more information, please refer to the [MMEngine optimizer wrapper documentation](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/optim_wrapper.md).
+
+Here are some common usage methods in MMSegmentation:
+
+#### Configuring PyTorch Supported Optimizers
+
+OpenMMLab 2.0 supports all native PyTorch optimizers, as referenced [here](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/optim_wrapper.md).
+
+To set the optimizer used by the `Runner` during training in the configuration file, you need to define `optim_wrapper` instead of `optimizer`. Below is an example of configuring an optimizer during training:
+
+```python
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005),
+    clip_grad=None)
+```
+
+#### Configuring Gradient Clipping
+
+When the model training requires gradient clipping, you can configure it as shown in the following example:
+
+```python
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer,
+                        clip_grad=dict(max_norm=0.01, norm_type=2))
+```
+
+Here, `max_norm` refers to the maximum value of the gradient after clipping, and `norm_type` refers to the norm used when clipping the gradient. Related methods can be found in [torch.nn.utils.clip_grad_norm\_](https://pytorch.org/docs/stable/generated/torch.nn.utils.clip_grad_norm_.html).
+
+#### Configuring Mixed Precision Training
+
+When mixed precision training is needed to reduce memory usage, you can use `AmpOptimWrapper`. The specific configuration is as follows:
+
+```python
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='AmpOptimWrapper', optimizer=optimizer)
+```
+
+The default setting for `loss_scale` in [`AmpOptimWrapper`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/amp_optimizer_wrapper.py#L20) is `dynamic`.
+
+#### Configuring Hyperparameters for Different Layers of the Model Network
+
+In model training, if you want to set different optimization strategies for different parameters in the optimizer, such as setting different learning rates, weight decay, and other hyperparameters, you can achieve this by setting `paramwise_cfg` in the `optim_wrapper` of the configuration file.
+
+The following config file uses the [ViT `optim_wrapper`](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_vit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py#L15-L27) as an example to introduce the use of `paramwise_cfg` parameters. During training, the weight decay parameter coefficients for the `pos_embed`, `mask_token`, and `norm` modules are set to 0. That is, during training, the weight decay for these modules will be changed to `weight_decay * decay_mult`=0.
+
+```python
+optimizer = dict(
+        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01)
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=optimizer,
+    paramwise_cfg=dict(
+        custom_keys={
+            'pos_embed': dict(decay_mult=0.),
+            'cls_token': dict(decay_mult=0.),
+            'norm': dict(decay_mult=0.)
+        }))
+```
+
+Here, `decay_mult` refers to the weight decay coefficient for the corresponding parameters. For more information on the usage of `paramwise_cfg`, please refer to the [MMEngine optimizer wrapper documentation](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/optim_wrapper.md).
+
+### Optimizer Wrapper Constructor
+
+The default optimizer wrapper constructor [`DefaultOptimWrapperConstructor`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py#L19) builds the optimizer used in training based on the input `optim_wrapper` and `paramwise_cfg` defined in the `optim_wrapper`. When the functionality of [`DefaultOptimWrapperConstructor`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py#L19) does not meet the requirements, you can customize the optimizer wrapper constructor to implement the configuration of hyperparameters.
+
+MMSegmentation has implemented the [`LearningRateDecayOptimizerConstructor`](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/engine/optimizers/layer_decay_optimizer_constructor.py#L104), which can decay the learning rate of model parameters in the backbone networks of ConvNeXt, BEiT, and MAE models during training according to the defined decay ratio (`decay_rate`). The configuration in the configuration file is as follows:
+
+```python
+optim_wrapper = dict(
+    _delete_=True,
+    type='AmpOptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.05),
+    paramwise_cfg={
+        'decay_rate': 0.9,
+        'decay_type': 'stage_wise',
+        'num_layers': 12
+    },
+    constructor='LearningRateDecayOptimizerConstructor',
+    loss_scale='dynamic')
+```
+
+The purpose of `_delete_=True` is to ignore the inherited configuration in the OpenMMLab Config. In this code snippet, the inherited `optim_wrapper` configuration is ignored. For more information on `_delete_` fields, please refer to the [MMEngine documentation](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/config.md#delete-key-in-dict).
diff --git a/mmsegmentation/docs/en/advanced_guides/evaluation.md b/mmsegmentation/docs/en/advanced_guides/evaluation.md
new file mode 100644
index 0000000..ca0beee
--- /dev/null
+++ b/mmsegmentation/docs/en/advanced_guides/evaluation.md
@@ -0,0 +1,155 @@
+# Evaluation
+
+The evaluation procedure would be executed at [ValLoop](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py#L300) and [TestLoop](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py#L373), users can evaluate model performance during training or using the test script with simple settings in the configuration file. The `ValLoop` and `TestLoop` are properties of [Runner](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py#L59), they will be built the first time they are called. To build the `ValLoop` successfully, the `val_dataloader` and `val_evaluator` must be set when building `Runner` since `dataloader` and `evaluator` are required parameters, and the same goes for `TestLoop`. For more information about the Runner's design, please refer to the [documentation](https://github.com/open-mmlab/mmengine/blob/main/docs/en/design/runner.md) of [MMEngine](https://github.com/open-mmlab/mmengine).
+
+![test_step/val_step dataflow](https://user-images.githubusercontent.com/15952744/228828179-3269baa3-bebd-4c9a-9787-59e7d785fbcf.png)
+
+In MMSegmentation, we write the settings of dataloader and metrics in the config files of datasets and the configuration of the evaluation loop in the `schedule_x` config files by default.
+
+For example, in the ADE20K config file `configs/_base_/dataset/ade20k.py`, on lines 37 to 48, we configured the `val_dataloader`, on line 51, we select `IoUMetric` as the evaluator and set `mIoU` as the metric:
+
+```python
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
+        pipeline=test_pipeline))
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+```
+
+To be able to evaluate the model during training, for example, we add the evaluation configuration to the file `configs/schedules/schedule_40k.py` on lines 15 to 16:
+
+```python
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=40000, val_interval=4000)
+val_cfg = dict(type='ValLoop')
+```
+
+With the above two settings, MMSegmentation evaluates the **mIoU** metric of the model once every 4000 iterations during the training of 40K iterations.
+
+If we would like to test the model after training, we need to add the `test_dataloader`, `test_evaluator` and `test_cfg` configs to the config file.
+
+```python
+test_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
+        pipeline=test_pipeline))
+
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_cfg = dict(type='TestLoop')
+```
+
+In MMSegmentation, the settings of `test_dataloader` and `test_evaluator` are the same as the `ValLoop`'s dataloader and evaluator by default, we can modify these settings to meet our needs.
+
+## IoUMetric
+
+MMSegmentation implements [IoUMetric](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/evaluation/metrics/iou_metric.py) and [CityscapesMetric](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/evaluation/metrics/citys_metric.py) for evaluating the performance of models, based on the [BaseMetric](https://github.com/open-mmlab/mmengine/blob/main/mmengine/evaluator/metric.py) provided by [MMEngine](https://github.com/open-mmlab/mmengine). Please refer to [the documentation](https://mmengine.readthedocs.io/en/latest/tutorials/evaluation.html) for more details about the unified evaluation interface.
+
+Here we briefly describe the arguments and the two main methods of `IoUMetric`.
+
+The constructor of `IoUMetric` has some additional parameters besides the base `collect_device` and `prefix`.
+
+The arguments of the constructor:
+
+- ignore_index (int) - Index that will be ignored in evaluation. Default: 255.
+- iou_metrics (list\[str\] | str) - Metrics to be calculated, the options includes 'mIoU', 'mDice' and 'mFscore'.
+- nan_to_num (int, optional) - If specified, NaN values will be replaced by the numbers defined by the user. Default: None.
+- beta (int) - Determines the weight of recall in the combined score. Default: 1.
+- collect_device (str) - Device name used for collecting results from different ranks during distributed training. Must be 'cpu' or 'gpu'. Defaults to 'cpu'.
+- prefix (str, optional) - The prefix that will be added in the metric names to disambiguate homonymous metrics of different evaluators. If the prefix is not provided in the argument, self.default_prefix will be used instead. Defaults to None.
+
+`IoUMetric` implements the IoU metric calculation, the core two methods of `IoUMetric` are `process` and `compute_metrics`.
+
+- `process` method processes one batch of data and data_samples.
+- `compute_metrics` method computes the metrics from processed results.
+
+### IoUMetric.process
+
+Parameters:
+
+- data_batch (Any) - A batch of data from the dataloader.
+- data_samples (Sequence\[dict\]) - A batch of outputs from the model.
+
+Returns:
+
+This method doesn't have returns since the processed results would be stored in `self.results`, which will be used to compute the metrics when all batches have been processed.
+
+### IoUMetric.compute_metrics
+
+Parameters:
+
+- results (list) - The processed results of each batch.
+
+Returns:
+
+- Dict\[str, float\] - The computed metrics. The keys are the names of the metrics, and the values are corresponding results. The key mainly includes **aAcc**, **mIoU**, **mAcc**, **mDice**, **mFscore**, **mPrecision**, **mRecall**.
+
+## CityscapesMetric
+
+`CityscapesMetric` uses the official [CityscapesScripts](https://github.com/mcordts/cityscapesScripts) provided by Cityscapes to evaluate model performance.
+
+### Usage
+
+Before using it, please install the `cityscapesscripts` package first:
+
+```shell
+pip install cityscapesscripts
+```
+
+Since the `IoUMetric` is used as the default evaluator in MMSegmentation, if you would like to use `CityscapesMetric`, customizing the config file is required. In your customized config file, you should overwrite the default evaluator as follows.
+
+```python
+val_evaluator = dict(type='CityscapesMetric', output_dir='tmp')
+test_evaluator = val_evaluator
+```
+
+### Interface
+
+The arguments of the constructor:
+
+- output_dir (str) - The directory for output prediction
+- ignore_index (int) - Index that will be ignored in evaluation. Default: 255.
+- format_only (bool) - Only format result for results commit without perform evaluation. It is useful when you want to format the result to a specific format and submit it to the test server. Defaults to False.
+- keep_results (bool) - Whether to keep the results. When `format_only` is True, `keep_results` must be True. Defaults to False.
+- collect_device (str) - Device name used for collecting results from different ranks during distributed training. Must be 'cpu' or 'gpu'. Defaults to 'cpu'.
+- prefix (str, optional) - The prefix that will be added in the metric names to disambiguate homonymous metrics of different evaluators. If prefix is not provided in the argument, self.default_prefix will be used instead. Defaults to None.
+
+#### CityscapesMetric.process
+
+This method would draw the masks on images and save the painted images to `work_dir`.
+
+Parameters:
+
+- data_batch (dict) - A batch of data from the dataloader.
+- data_samples (Sequence\[dict\]) - A batch of outputs from the model.
+
+Returns:
+
+This method doesn't have returns, the annotations' path would be stored in `self.results`, which will be used to compute the metrics when all batches have been processed.
+
+#### CityscapesMetric.compute_metrics
+
+This method would call `cityscapesscripts.evaluation.evalPixelLevelSemanticLabeling` tool to calculate metrics.
+
+Parameters:
+
+- results (list) - Testing results of the dataset.
+
+Returns:
+
+- dict\[str: float\] - Cityscapes evaluation results.
diff --git a/mmsegmentation/docs/en/advanced_guides/index.rst b/mmsegmentation/docs/en/advanced_guides/index.rst
new file mode 100644
index 0000000..53ef8c5
--- /dev/null
+++ b/mmsegmentation/docs/en/advanced_guides/index.rst
@@ -0,0 +1,26 @@
+Basic Concepts
+***************
+
+.. toctree::
+   :maxdepth: 1
+
+   data_flow.md
+   structures.md
+   models.md
+   datasets.md
+   transforms.md
+   evaluation.md
+   engine.md
+   training_tricks.md
+
+Component Customization
+************************
+
+.. toctree::
+   :maxdepth: 1
+
+   add_models.md
+   add_datasets.md
+   add_transforms.md
+   add_metrics.md
+   customize_runtime.md
diff --git a/mmsegmentation/docs/en/advanced_guides/models.md b/mmsegmentation/docs/en/advanced_guides/models.md
new file mode 100644
index 0000000..b008986
--- /dev/null
+++ b/mmsegmentation/docs/en/advanced_guides/models.md
@@ -0,0 +1,164 @@
+# Models
+
+We usually define a neural network in a deep learning task as a model, and this model is the core of an algorithm. [MMEngine](https://github.com/open-mmlab/mmengine) abstracts a unified model [BaseModel](https://github.com/open-mmlab/mmengine/blob/main/mmengine/model/base_model/base_model.py#L16) to standardize the interfaces for training, testing and other processes. All models implemented by MMSegmentation inherit from `BaseModel`, and in MMSegmentation we implemented forward and added some functions for the semantic segmentation algorithm.
+
+## Common components
+
+### Segmentor
+
+In MMSegmentation, we abstract the network architecture as a **Segmentor**, it is a model that contains all components of a network. We have already implemented **EncoderDecoder** and **CascadeEncoderDecoder**, which typically consist of **Data preprocessor**, **Backbone**, **Decode head** and **Auxiliary head**.
+
+### Data preprocessor
+
+**Data preprocessor** is the part that copies data to the target device and preprocesses the data into the model input format.
+
+### Backbone
+
+**Backbone** is the part that transforms an image to feature maps, such as a **ResNet-50** without the last fully connected layer.
+
+### Neck
+
+**Neck** is the part that connects the backbone and heads. It performs some refinements or reconfigurations on the raw feature maps produced by the backbone. An example is **Feature Pyramid Network (FPN)**.
+
+### Decode head
+
+**Decode head** is the part that transforms the feature maps into a segmentation mask, such as **PSPNet**.
+
+### Auxiliary head
+
+**Auxiliary head** is an optional component that transforms the feature maps into segmentation masks which only used for computing auxiliary losses.
+
+## Basic interfaces
+
+MMSegmentation wraps `BaseModel` and implements the [BaseSegmentor](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/models/segmentors/base.py#L15) class, which mainly provides the interfaces `forward`, `train_step`, `val_step` and `test_step`. The following will introduce these interfaces in detail.
+
+### forward
+
+![EncoderDecoder dataflow](https://user-images.githubusercontent.com/15952744/228827860-c0e34875-d370-4736-84f0-9560c26c9576.png)
+![CascadeEncoderDecoder dataflow](https://user-images.githubusercontent.com/15952744/228827987-aa214507-0c6d-4a08-8ce4-679b2b200b79.png)
+
+The `forward` method returns losses or predictions of training, validation, testing, and a simple inference process.
+
+The method should accept three modes: "tensor", "predict" and "loss":
+
+- "tensor": Forward the whole network and return the tensor or tuple of tensor without any post-processing, same as a common `nn.Module`.
+- "predict": Forward and return the predictions, which are fully processed to a list of `SegDataSample`.
+- "loss": Forward and return a `dict` of losses according to the given inputs and data samples.
+
+**Note:** [SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py) is a data structure interface of MMSegmentation, it is used as an interface between different components. `SegDataSample` implements the abstract data element `mmengine.structures.BaseDataElement`, please refer to [the SegDataSample documentation](https://mmsegmentation.readthedocs.io/en/1.x/advanced_guides/structures.html) and [data element documentation](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/data_element.html) in [MMEngine](https://github.com/open-mmlab/mmengine) for more information.
+
+Note that this method doesn't handle either backpropagation or optimizer updating, which are done in the method `train_step`.
+
+Parameters:
+
+- inputs (torch.Tensor) - The input tensor with shape (N, C, ...) in general.
+- data_sample (list\[[SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py)\]) - The seg data samples. It usually includes information such as `metainfo` and `gt_sem_seg`. Default to None.
+- mode (str) - Return what kind of value. Defaults to 'tensor'.
+
+Returns:
+
+- `dict` or `list`:
+  - If `mode == "loss"`, return a `dict` of loss tensor used for backward and logging.
+  - If `mode == "predict"`, return a `list` of `SegDataSample`, the inference results will be incrementally added to the `data_sample` parameter passed to the forward method, each `SegDataSample` contains the following keys:
+    - pred_sem_seg (`PixelData`): Prediction of semantic segmentation.
+    - seg_logits (`PixelData`): Predicted logits of semantic segmentation before normalization.
+  - If `mode == "tensor"`, return a `tensor` or `tuple of tensor` or `dict` of `tensor` for custom use.
+
+### prediction modes
+
+We briefly describe the fields of the model's configuration in [the config documentation](../user_guides/1_config.md), here we elaborate on the `model.test_cfg` field. `model.test_cfg` is used to control forward behavior, the `forward` method in `"predict"` mode can run in two modes:
+
+- `whole_inference`: If `cfg.model.test_cfg.mode == 'whole'`, model will inference with full images.
+
+  An `whole_inference` mode example config:
+
+  ```python
+  model = dict(
+    type='EncoderDecoder'
+    ...
+    test_cfg=dict(mode='whole')
+  )
+  ```
+
+- `slide_inference`: If `cfg.model.test_cfg.mode == 'slide'`, model will inference by sliding-window. **Note:** if you select the `slide` mode, `cfg.model.test_cfg.stride` and `cfg.model.test_cfg.crop_size` should also be specified.
+
+  An `slide_inference` mode example config:
+
+  ```python
+  model = dict(
+    type='EncoderDecoder'
+    ...
+    test_cfg=dict(mode='slide', crop_size=256, stride=170)
+  )
+  ```
+
+### train_step
+
+The `train_step` method calls the forward interface of the `loss` mode to get the loss `dict`. The `BaseModel` class implements the default model training process including preprocessing, model forward propagation, loss calculation, optimization, and back-propagation.
+
+Parameters:
+
+- data (dict or tuple or list) - Data sampled from the dataset. In MMSegmentation, the data dict contains `inputs` and `data_samples` two fields.
+- optim_wrapper (OptimWrapper) - OptimWrapper instance used to update model parameters.
+
+**Note:** [OptimWrapper](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/optimizer_wrapper.py#L17) provides a common interface for updating parameters, please refer to optimizer wrapper [documentation](https://mmengine.readthedocs.io/en/latest/tutorials/optim_wrapper.html) in [MMEngine](https://github.com/open-mmlab/mmengine) for more information.
+
+Returns:
+
+- Dict\[str, `torch.Tensor`\]: A `dict` of tensor for logging.
+
+![train_step dataflow](https://user-images.githubusercontent.com/15952744/228828089-a9ae1225-958d-4cf7-99af-9af8576f7ef7.png)
+
+### val_step
+
+The `val_step` method calls the forward interface of the `predict` mode and returns the prediction result, which is further passed to the process interface of the evaluator and the `after_val_iter` interface of the Hook.
+
+Parameters:
+
+- data (`dict` or `tuple` or `list`) - Data sampled from the dataset. In MMSegmentation, the data dict contains `inputs` and `data_samples` two fields.
+
+Returns:
+
+- `list` - The predictions of given data.
+
+![test_step/val_step dataflow](https://user-images.githubusercontent.com/15952744/228828179-3269baa3-bebd-4c9a-9787-59e7d785fbcf.png)
+
+### test_step
+
+The `BaseModel` implements `test_step` the same as `val_step`.
+
+## Data Preprocessor
+
+The [SegDataPreProcessor](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/models/data_preprocessor.py#L13) implemented by MMSegmentation inherits from the [BaseDataPreprocessor](https://github.com/open-mmlab/mmengine/blob/main/mmengine/model/base_model/data_preprocessor.py#L18) implemented by [MMEngine](https://github.com/open-mmlab/mmengine) and provides the functions of data preprocessing and copying data to the target device.
+
+The runner carries the model to the specified device during the construction stage, while the data is carried to the specified device by the [SegDataPreProcessor](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/models/data_preprocessor.py#L13) in `train_step`, `val_step`, and `test_step`, and the processed data is further passed to the model.
+
+The parameters of the `SegDataPreProcessor` constructor:
+
+- mean (Sequence\[Number\], optional) - The pixel mean of R, G, B channels. Defaults to None.
+- std (Sequence\[Number\], optional) - The pixel standard deviation of R, G, B channels. Defaults to None.
+- size (tuple, optional) - Fixed padding size.
+- size_divisor (int, optional) - The divisor of padded size.
+- pad_val (float, optional) - Padding value. Default: 0.
+- seg_pad_val (float, optional) - Padding value of segmentation map. Default: 255.
+- bgr_to_rgb (bool) - whether to convert image from BGR to RGB. Defaults to False.
+- rgb_to_bgr (bool) - whether to convert image from RGB to BGR. Defaults to False.
+- batch_augments (list\[dict\], optional) - Batch-level augmentations. Default to None.
+
+The data will be processed as follows:
+
+- Collate and move data to the target device.
+- Pad inputs to the input size with defined `pad_val`, and pad seg map with defined `seg_pad_val`.
+- Stack inputs to batch_inputs.
+- Convert inputs from bgr to rgb if the shape of input is (3, H, W).
+- Normalize image with defined std and mean.
+- Do batch augmentations like Mixup and Cutmix during training.
+
+The parameters of the `forward` method:
+
+- data (dict) - data sampled from dataloader.
+- training (bool) - Whether to enable training time augmentation.
+
+The returns of the `forward` method:
+
+- Dict: Data in the same format as the model input.
diff --git a/mmsegmentation/docs/en/advanced_guides/structures.md b/mmsegmentation/docs/en/advanced_guides/structures.md
new file mode 100644
index 0000000..2607242
--- /dev/null
+++ b/mmsegmentation/docs/en/advanced_guides/structures.md
@@ -0,0 +1,104 @@
+# Structures
+
+To unify input and output interfaces  between different models and modules, OpenMMLab 2.0 MMEngine defines an abstract data structure,
+it has implemented basic functions of `Create`, `Read`, `Update`, `Delete`, supported data transferring among different types of devices
+and tensor-like or dictionary-like operations such as `.cpu()`, `.cuda()`, `.get()` and `.detach()`.
+More details can be found [here](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/data_element.md).
+
+MMSegmentation also follows this interface protocol and defines `SegDataSample` which is used to encapsulate the data of semantic segmentation task.
+
+## Semantic Segmentation Data SegDataSample
+
+[SegDataSample](mmseg.structures.SegDataSample) includes three main fields `gt_sem_seg`, `pred_sem_seg` and `seg_logits`, which are used to store the annotation information and prediction results respectively.
+
+| Field          | Type                      | Description                                |
+| -------------- | ------------------------- | ------------------------------------------ |
+| gt_sem_seg     | [`PixelData`](#pixeldata) | Annotation information.                    |
+| pred_instances | [`PixelData`](#pixeldata) | The predicted result.                      |
+| seg_logits     | [`PixelData`](#pixeldata) | The raw (non-normalized) predicted result. |
+
+The following sample code demonstrates the use of `SegDataSample`.
+
+```python
+import torch
+from mmengine.structures import PixelData
+from mmseg.structures import SegDataSample
+
+img_meta = dict(img_shape=(4, 4, 3),
+                 pad_shape=(4, 4, 3))
+data_sample = SegDataSample()
+# defining gt_segmentations for encapsulate the ground truth data
+gt_segmentations = PixelData(metainfo=img_meta)
+gt_segmentations.data = torch.randint(0, 2, (1, 4, 4))
+
+# add and process property in SegDataSample
+data_sample.gt_sem_seg = gt_segmentations
+assert 'gt_sem_seg' in data_sample
+assert 'sem_seg' in data_sample.gt_sem_seg
+assert 'img_shape' in data_sample.gt_sem_seg.metainfo_keys()
+print(data_sample.gt_sem_seg.shape)
+'''
+(4, 4)
+'''
+print(data_sample)
+'''
+<SegDataSample(
+
+    META INFORMATION
+
+    DATA FIELDS
+    gt_sem_seg: <PixelData(
+
+            META INFORMATION
+            img_shape: (4, 4, 3)
+            pad_shape: (4, 4, 3)
+
+            DATA FIELDS
+            data: tensor([[[1, 1, 1, 0],
+                         [1, 0, 1, 1],
+                         [1, 1, 1, 1],
+                         [0, 1, 0, 1]]])
+        ) at 0x1c2b4156460>
+) at 0x1c2aae44d60>
+'''
+
+# delete and change property in SegDataSample
+data_sample = SegDataSample()
+gt_segmentations = PixelData(metainfo=img_meta)
+gt_segmentations.data = torch.randint(0, 2, (1, 4, 4))
+data_sample.gt_sem_seg = gt_segmentations
+data_sample.gt_sem_seg.set_metainfo(dict(img_shape=(4,4,9), pad_shape=(4,4,9)))
+del data_sample.gt_sem_seg.img_shape
+
+# Tensor-like operations
+data_sample = SegDataSample()
+gt_segmentations = PixelData(metainfo=img_meta)
+gt_segmentations.data = torch.randint(0, 2, (1, 4, 4))
+cuda_gt_segmentations = gt_segmentations.cuda()
+cuda_gt_segmentations = gt_segmentations.to('cuda:0')
+cpu_gt_segmentations = cuda_gt_segmentations.cpu()
+cpu_gt_segmentations = cuda_gt_segmentations.to('cpu')
+```
+
+## Customize New Property in SegDataSample
+
+If you want to customize new property in `SegDataSample`, you may follow [SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py) below:
+
+```python
+class SegDataSample(BaseDataElement):
+    ...
+
+    @property
+    def xxx_property(self) -> xxxData:
+        return self._xxx_property
+
+    @xxx_property.setter
+    def xxx_property(self, value: xxxData) -> None:
+        self.set_field(value, '_xxx_property', dtype=xxxData)
+
+    @xxx_property.deleter
+    def xxx_property(self) -> None:
+        del self._xxx_property
+```
+
+Then a new property would be added to `SegDataSample`.
diff --git a/mmsegmentation/docs/en/advanced_guides/training_tricks.md b/mmsegmentation/docs/en/advanced_guides/training_tricks.md
new file mode 100644
index 0000000..bc4f722
--- /dev/null
+++ b/mmsegmentation/docs/en/advanced_guides/training_tricks.md
@@ -0,0 +1,75 @@
+# Training Tricks
+
+MMSegmentation support following training tricks out of box.
+
+## Different Learning Rate(LR) for Backbone and Heads
+
+In semantic segmentation, some methods make the LR of heads larger than backbone to achieve better performance or faster convergence.
+
+In MMSegmentation, you may add following lines to config to make the LR of heads 10 times of backbone.
+
+```python
+optim_wrapper=dict(
+    paramwise_cfg = dict(
+        custom_keys={
+            'head': dict(lr_mult=10.)}))
+```
+
+With this modification, the LR of any parameter group with `'head'` in name will be multiplied by 10.
+You may refer to [MMEngine documentation](https://mmengine.readthedocs.io/en/latest/tutorials/optim_wrapper.html#advanced-usages) for further details.
+
+## Online Hard Example Mining (OHEM)
+
+We implement pixel sampler for training sampling, like OHEM (Online Hard Example Mining),
+which is used for remove the "easy" examples for model training.
+Here is an example config of training PSPNet with OHEM enabled.
+
+```python
+_base_ = './pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+model=dict(
+    decode_head=dict(
+        sampler=dict(type='OHEMPixelSampler', thresh=0.7, min_kept=100000)) )
+```
+
+In this way, only pixels with confidence score under 0.7 are used to train. And we keep at least 100000 pixels during training. If `thresh` is not specified, pixels of top `min_kept` loss will be selected.
+
+## Class Balanced Loss
+
+For dataset that is not balanced in classes distribution, you may change the loss weight of each class.
+Here is an example for cityscapes dataset.
+
+```python
+_base_ = './pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+model=dict(
+    decode_head=dict(
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0,
+            # DeepLab used this class weight for cityscapes
+            class_weight=[0.8373, 0.9180, 0.8660, 1.0345, 1.0166, 0.9969, 0.9754,
+                        1.0489, 0.8786, 1.0023, 0.9539, 0.9843, 1.1116, 0.9037,
+                        1.0865, 1.0955, 1.0865, 1.1529, 1.0507])))
+```
+
+`class_weight` will be passed into `CrossEntropyLoss` as `weight` argument. Please refer to [PyTorch Doc](https://pytorch.org/docs/stable/nn.html?highlight=crossentropy#torch.nn.CrossEntropyLoss) for details.
+
+## Multiple Losses
+
+For loss calculation, we support multiple losses training concurrently. Here is an example config of training `unet` on `DRIVE` dataset, whose loss function is `1:3` weighted sum of `CrossEntropyLoss` and `DiceLoss`:
+
+```python
+_base_ = './fcn_unet_s5-d16_64x64_40k_drive.py'
+model = dict(
+    decode_head=dict(loss_decode=[
+        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
+        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
+    ]),
+    auxiliary_head=dict(loss_decode=[
+        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
+        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
+    ]),
+)
+```
+
+In this way, `loss_weight` and `loss_name` will be weight and name in training log of corresponding loss, respectively.
+
+Note: If you want this loss item to be included into the backward graph, `loss_` must be the prefix of the name.
diff --git a/mmsegmentation/docs/en/advanced_guides/transforms.md b/mmsegmentation/docs/en/advanced_guides/transforms.md
new file mode 100644
index 0000000..68b1f44
--- /dev/null
+++ b/mmsegmentation/docs/en/advanced_guides/transforms.md
@@ -0,0 +1,119 @@
+# Data Transforms
+
+In this tutorial, we introduce the design of transforms pipeline in MMSegmentation.
+
+The structure of this guide is as follows:
+
+- [Data Transforms](#data-transforms)
+  - [Design of Data pipelines](#design-of-data-pipelines)
+    - [Data loading](#data-loading)
+    - [Pre-processing](#pre-processing)
+    - [Formatting](#formatting)
+
+## Design of Data pipelines
+
+Following typical conventions, we use `Dataset` and `DataLoader` for data loading with multiple workers. `Dataset` returns a dict of data items corresponding the arguments of models' forward method. Since the data in semantic segmentation may not be the same size, we introduce a new `DataContainer` type in MMCV to help collect and distribute data of different size. See [here](https://github.com/open-mmlab/mmcv/blob/master/mmcv/parallel/data_container.py) for more details.
+
+In 1.x version of MMSegmentation, all data transformations are inherited from [`BaseTransform`](https://github.com/open-mmlab/mmcv/blob/2.x/mmcv/transforms/base.py#L6).
+
+The input and output types of transformations are both dict. A simple example is as follows:
+
+```python
+>>> from mmseg.datasets.transforms import LoadAnnotations
+>>> transforms = LoadAnnotations()
+>>> img_path = './data/cityscapes/leftImg8bit/train/aachen/aachen_000000_000019_leftImg8bit.png.png'
+>>> gt_path = './data/cityscapes/gtFine/train/aachen/aachen_000015_000019_gtFine_instanceTrainIds.png'
+>>> results = dict(
+>>>     img_path=img_path,
+>>>     seg_map_path=gt_path,
+>>>     reduce_zero_label=False,
+>>>     seg_fields=[])
+>>> data_dict = transforms(results)
+>>> print(data_dict.keys())
+dict_keys(['img_path', 'seg_map_path', 'reduce_zero_label', 'seg_fields', 'gt_seg_map'])
+```
+
+The data preparation pipeline and the dataset are decomposed. Usually a dataset defines how to process the annotations and a data pipeline defines all the steps to prepare a data dict. A pipeline consists of a sequence of operations. Each operation takes a dict as input and also outputs a dict for the next transform.
+
+The operations are categorized into data loading, pre-processing, formatting and test-time augmentation.
+
+Here is a pipeline example for PSPNet:
+
+```python
+crop_size = (512, 1024)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=(2048, 1024),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+```
+
+For each operation, we list the related dict fields that are `added`/`updated`/`removed`. Before pipelines, the information we can directly obtain from the datasets are `img_path` and `seg_map_path`.
+
+### Data loading
+
+`LoadImageFromFile`: Load an image from file.
+
+- add: `img`, `img_shape`, `ori_shape`
+
+`LoadAnnotations`: Load semantic segmentation maps provided by dataset.
+
+- add: `seg_fields`, `gt_seg_map`
+
+### Pre-processing
+
+`RandomResize`: Random resize image & segmentation map.
+
+- add: `scale`, `scale_factor`, `keep_ratio`
+- update: `img`, `img_shape`, `gt_seg_map`
+
+`Resize`: Resize image & segmentation map.
+
+- add: `scale`, `scale_factor`, `keep_ratio`
+- update: `img`, `gt_seg_map`, `img_shape`
+
+`RandomCrop`: Random crop image & segmentation map.
+
+- update: `img`, `gt_seg_map`, `img_shape`
+
+`RandomFlip`: Flip the image & segmentation map.
+
+- add: `flip`, `flip_direction`
+- update: `img`, `gt_seg_map`
+
+`PhotoMetricDistortion`: Apply photometric distortion to image sequentially, every transformation is applied with a probability of 0.5. The position of random contrast is in second or second to last(mode 0 or 1 below, respectively).
+
+```
+1. random brightness
+2. random contrast (mode 0)
+3. convert color from BGR to HSV
+4. random saturation
+5. random hue
+6. convert color from HSV to BGR
+7. random contrast (mode 1)
+```
+
+- update: `img`
+
+### Formatting
+
+`PackSegInputs`: Pack the inputs data for the semantic segmentation.
+
+- add: `inputs`, `data_sample`
+- remove: keys specified by `meta_keys` (merged into the metainfo of data_sample), all other keys
diff --git a/mmsegmentation/docs/en/api.rst b/mmsegmentation/docs/en/api.rst
new file mode 100644
index 0000000..2f1a25e
--- /dev/null
+++ b/mmsegmentation/docs/en/api.rst
@@ -0,0 +1,95 @@
+mmseg.apis
+--------------
+.. automodule:: mmseg.apis
+    :members:
+
+mmseg.datasets
+--------------
+
+datasets
+^^^^^^^^^^
+.. automodule:: mmseg.datasets
+    :members:
+
+transforms
+^^^^^^^^^^^^
+.. automodule:: mmseg.datasets.transforms
+    :members:
+
+mmseg.engine
+--------------
+
+hooks
+^^^^^^^^^^
+.. automodule:: mmseg.engine.hooks
+    :members:
+
+optimizers
+^^^^^^^^^^^^^^^
+.. automodule:: mmseg.engine.optimizers
+    :members:
+
+mmseg.evaluation
+-----------------
+
+metrics
+^^^^^^^^^^
+.. automodule:: mmseg.evaluation.metrics
+    :members:
+
+mmseg.models
+--------------
+
+backbones
+^^^^^^^^^^^^^^^^^^
+.. automodule:: mmseg.models.backbones
+    :members:
+
+decode_heads
+^^^^^^^^^^^^^^^
+.. automodule:: mmseg.models.decode_heads
+    :members:
+
+segmentors
+^^^^^^^^^^
+.. automodule:: mmseg.models.segmentors
+    :members:
+
+losses
+^^^^^^^^^^
+.. automodule:: mmseg.models.losses
+    :members:
+
+necks
+^^^^^^^^^^^^
+.. automodule:: mmseg.models.necks
+    :members:
+
+utils
+^^^^^^^^^^
+.. automodule:: mmseg.models.utils
+    :members:
+
+
+mmseg.structures
+--------------------
+
+structures
+^^^^^^^^^^^^^^^^^
+.. automodule:: mmseg.structures
+    :members:
+
+sampler
+^^^^^^^^^^
+.. automodule:: mmseg.structures.sampler
+    :members:
+
+mmseg.visualization
+--------------------
+.. automodule:: mmseg.visualization
+    :members:
+
+mmseg.utils
+--------------
+.. automodule:: mmseg.utils
+    :members:
diff --git a/mmsegmentation/docs/en/conf.py b/mmsegmentation/docs/en/conf.py
new file mode 100644
index 0000000..e20aab1
--- /dev/null
+++ b/mmsegmentation/docs/en/conf.py
@@ -0,0 +1,133 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+import subprocess
+import sys
+
+import pytorch_sphinx_theme
+
+sys.path.insert(0, os.path.abspath('../../'))
+
+# -- Project information -----------------------------------------------------
+
+project = 'MMSegmentation'
+copyright = '2020-2021, OpenMMLab'
+author = 'MMSegmentation Authors'
+version_file = '../../mmseg/version.py'
+
+
+def get_version():
+    with open(version_file) as f:
+        exec(compile(f.read(), version_file, 'exec'))
+    return locals()['__version__']
+
+
+# The full version, including alpha/beta/rc tags
+release = get_version()
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    'sphinx.ext.autodoc', 'sphinx.ext.napoleon', 'sphinx.ext.viewcode',
+    'sphinx_markdown_tables', 'sphinx_copybutton', 'myst_parser'
+]
+
+autodoc_mock_imports = [
+    'matplotlib', 'pycocotools', 'mmseg.version', 'mmcv.ops'
+]
+
+# Ignore >>> when copying code
+copybutton_prompt_text = r'>>> |\.\.\. '
+copybutton_prompt_is_regexp = True
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+#
+source_suffix = {
+    '.rst': 'restructuredtext',
+    '.md': 'markdown',
+}
+
+# The master toctree document.
+master_doc = 'index'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+# html_theme = 'sphinx_rtd_theme'
+html_theme = 'pytorch_sphinx_theme'
+html_theme_path = [pytorch_sphinx_theme.get_html_theme_path()]
+html_theme_options = {
+    'logo_url':
+    'https://mmsegmentation.readthedocs.io/en/latest/',
+    'menu': [
+        {
+            'name':
+            'Tutorial',
+            'url':
+            'https://github.com/open-mmlab/mmsegmentation/blob/master/'
+            'demo/MMSegmentation_Tutorial.ipynb'
+        },
+        {
+            'name': 'GitHub',
+            'url': 'https://github.com/open-mmlab/mmsegmentation'
+        },
+        {
+            'name':
+            'Upstream',
+            'children': [
+                {
+                    'name': 'MMCV',
+                    'url': 'https://github.com/open-mmlab/mmcv',
+                    'description': 'Foundational library for computer vision'
+                },
+            ]
+        },
+    ],
+    # Specify the language of shared menu
+    'menu_lang':
+    'en'
+}
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+html_css_files = ['css/readthedocs.css']
+
+# Enable ::: for my_st
+myst_enable_extensions = ['colon_fence']
+
+language = 'en'
+
+
+def builder_inited_handler(app):
+    subprocess.run(['./stat.py'])
+
+
+def setup(app):
+    app.connect('builder-inited', builder_inited_handler)
diff --git a/mmsegmentation/docs/en/device/npu.md b/mmsegmentation/docs/en/device/npu.md
new file mode 100644
index 0000000..a90d6ac
--- /dev/null
+++ b/mmsegmentation/docs/en/device/npu.md
@@ -0,0 +1,39 @@
+# NPU (HUAWEI Ascend)
+
+## Usage
+
+Please refer to the [building documentation of MMCV](https://mmcv.readthedocs.io/en/latest/get_started/build.html#build-mmcv-full-on-ascend-npu-machine) to install MMCV on NPU devices
+
+Here we use 4 NPUs on your computer to train the model with the following command:
+
+```shell
+bash tools/dist_train.sh configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py 4
+```
+
+Also, you can use only one NPU to train the model with the following command:
+
+```shell
+python tools/train.py configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py
+```
+
+## Models Results
+
+|        Model        | mIoU  | Config                                                                                                                                     | Download                                                                                                                                    |
+| :-----------------: | :---: | :----------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------ |
+|   [deeplabv3](<>)   | 78.85 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py)         | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024_20230115_205626.json)     |
+| [deeplabv3plus](<>) | 79.23 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024.py) | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024_20230116_043450.json) |
+|     [hrnet](<>)     | 78.1  | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/hrnet/fcn_hr18_4xb2-40k_cityscapes-512x1024.py)                     | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/fcn_hr18_4xb2-40k_cityscapes-512x1024_20230116_215821.json)             |
+|      [fcn](<>)      | 74.15 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py)                     | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/fcn_r50-d8_4xb2-40k_cityscapes-512x1024_20230111_083014.json)           |
+|     [icnet](<>)     | 69.25 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/icnet/icnet_r50-d8_4xb2-80k_cityscapes-832x832.py)                  | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/icnet_r50-d8_4xb2-80k_cityscapes-832x832_20230119_002929.json)          |
+|    [pspnet](<>)     | 77.21 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024.py)              | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024_20230114_042721.json)       |
+|     [unet](<>)      | 68.86 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/unet/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py)              | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024_20230129_224750.json)     |
+|    [upernet](<>)    | 77.81 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/upernet/upernet_r50_4xb2-40k_cityscapes-512x1024.py)                | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/upernet_r50_4xb2-40k_cityscapes-512x1024_20230129_014634.json)          |
+|    [apcnet](<>)     | 78.02 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py)               | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/apcnet_r50-d8_4xb2-40k_cityscapes-512x1024_20230209_212545.json)        |
+|   [bisenetv1](<>)   | 76.04 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024.py)      | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024_20230201_023946.json)  |
+|   [bisenetv2](<>)   | 72.44 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/bisenetv2/bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024.py)      | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024_20230205_215606.json)  |
+
+**Notes:**
+
+- If not specially marked, the results on NPU with amp are the basically same as those on the GPU with FP32.
+
+**All above models are provided by Huawei Ascend group.**
diff --git a/mmsegmentation/docs/en/get_started.md b/mmsegmentation/docs/en/get_started.md
new file mode 100644
index 0000000..3f957eb
--- /dev/null
+++ b/mmsegmentation/docs/en/get_started.md
@@ -0,0 +1,211 @@
+# Get started: Install and Run MMSeg
+
+## Prerequisites
+
+In this section we demonstrate how to prepare an environment with PyTorch.
+
+MMSegmentation works on Linux, Windows and macOS. It requires Python 3.7+, CUDA 10.2+ and PyTorch 1.8+.
+
+**Note:**
+If you are experienced with PyTorch and have already installed it, just skip this part and jump to the [next section](##installation). Otherwise, you can follow these steps for the preparation.
+
+**Step 0.** Download and install Miniconda from the [official website](https://docs.conda.io/en/latest/miniconda.html).
+
+**Step 1.** Create a conda environment and activate it.
+
+```shell
+conda create --name openmmlab python=3.8 -y
+conda activate openmmlab
+```
+
+**Step 2.** Install PyTorch following [official instructions](https://pytorch.org/get-started/locally/), e.g.
+
+On GPU platforms:
+
+```shell
+conda install pytorch torchvision -c pytorch
+```
+
+On CPU platforms:
+
+```shell
+conda install pytorch torchvision cpuonly -c pytorch
+```
+
+## Installation
+
+We recommend that users follow our best practices to install MMSegmentation. However, the whole process is highly customizable. See [Customize Installation](#customize-installation) section for more information.
+
+### Best Practices
+
+**Step 0.** Install [MMCV](https://github.com/open-mmlab/mmcv) using [MIM](https://github.com/open-mmlab/mim).
+
+```shell
+pip install -U openmim
+mim install mmengine
+mim install "mmcv>=2.0.0"
+```
+
+**Step 1.** Install MMSegmentation.
+
+Case a: If you develop and run mmseg directly, install it from source:
+
+```shell
+git clone -b main https://github.com/open-mmlab/mmsegmentation.git
+cd mmsegmentation
+pip install -v -e .
+# '-v' means verbose, or more output
+# '-e' means installing a project in editable mode,
+# thus any local modifications made to the code will take effect without reinstallation.
+```
+
+Case b: If you use mmsegmentation as a dependency or third-party package, install it with pip:
+
+```shell
+pip install "mmsegmentation>=1.0.0"
+```
+
+### Verify the installation
+
+To verify whether MMSegmentation is installed correctly, we provide some sample codes to run an inference demo.
+
+**Step 1.** We need to download config and checkpoint files.
+
+```shell
+mim download mmsegmentation --config pspnet_r50-d8_4xb2-40k_cityscapes-512x1024 --dest .
+```
+
+The downloading will take several seconds or more, depending on your network environment. When it is done, you will find two files `pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py` and `pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth` in your current folder.
+
+**Step 2.** Verify the inference demo.
+
+Option (a). If you install mmsegmentation from source, just run the following command.
+
+```shell
+python demo/image_demo.py demo/demo.png configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth --device cuda:0 --out-file result.jpg
+```
+
+You will see a new image `result.jpg` on your current folder, where segmentation masks are covered on all objects.
+
+Option (b). If you install mmsegmentation with pip, open you python interpreter and copy&paste the following codes.
+
+```python
+from mmseg.apis import inference_model, init_model, show_result_pyplot
+import mmcv
+
+config_file = 'pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+checkpoint_file = 'pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
+
+# build the model from a config file and a checkpoint file
+model = init_model(config_file, checkpoint_file, device='cuda:0')
+
+# test a single image and show the results
+img = 'demo/demo.png'  # or img = mmcv.imread(img), which will only load it once
+result = inference_model(model, img)
+# visualize the results in a new window
+show_result_pyplot(model, img, result, show=True)
+# or save the visualization results to image files
+# you can change the opacity of the painted segmentation map in (0, 1].
+show_result_pyplot(model, img, result, show=True, out_file='result.jpg', opacity=0.5)
+# test a video and show the results
+video = mmcv.VideoReader('video.mp4')
+for frame in video:
+   result = inference_model(model, frame)
+   show_result_pyplot(model, frame, result, wait_time=1)
+```
+
+You can modify the code above to test a single image or a video, both of these options can verify that the installation was successful.
+
+### Customize Installation
+
+#### CUDA versions
+
+When installing PyTorch, you need to specify the version of CUDA. If you are not clear on which to choose, follow our recommendations:
+
+- For Ampere-based NVIDIA GPUs, such as GeForce 30 series and NVIDIA A100, CUDA 11 is a must.
+- For older NVIDIA GPUs, CUDA 11 is backward compatible, but CUDA 10.2 offers better compatibility and is more lightweight.
+
+Please make sure the GPU driver satisfies the minimum version requirements. See [this table](https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html#cuda-major-component-versions__table-cuda-toolkit-driver-versions) for more information.
+
+**Note:**
+Installing CUDA runtime libraries is enough if you follow our best practices, because no CUDA code will be compiled locally. However if you hope to compile MMCV from source or develop other CUDA operators, you need to install the complete CUDA toolkit from NVIDIA's [website](https://developer.nvidia.com/cuda-downloads), and its version should match the CUDA version of PyTorch. i.e., the specified version of cudatoolkit in `conda install` command.
+
+#### Install MMCV without MIM
+
+MMCV contains C++ and CUDA extensions, thus depending on PyTorch in a complex way. MIM solves such dependencies automatically and makes the installation easier. However, it is not a must.
+
+To install MMCV with pip instead of MIM, please follow [MMCV installation guides](https://mmcv.readthedocs.io/en/latest/get_started/installation.html). This requires manually specifying a find-url based on PyTorch version and its CUDA version.
+
+For example, the following command install mmcv==2.0.0 built for PyTorch 1.10.x and CUDA 11.3.
+
+```shell
+pip install mmcv==2.0.0 -f https://download.openmmlab.com/mmcv/dist/cu113/torch1.10/index.html
+```
+
+#### Install on CPU-only platforms
+
+MMSegmentation can be built for CPU only environment. In CPU mode you can train (requires MMCV version >= 2.0.0), test or inference a model.
+
+#### Install on Google Colab
+
+[Google Colab](https://research.google.com/) usually has PyTorch installed,
+thus we only need to install MMCV and MMSegmentation with the following commands.
+
+**Step 1.** Install [MMCV](https://github.com/open-mmlab/mmcv) using [MIM](https://github.com/open-mmlab/mim).
+
+```shell
+!pip3 install openmim
+!mim install mmengine
+!mim install "mmcv>=2.0.0"
+```
+
+**Step 2.** Install MMSegmentation from the source.
+
+```shell
+!git clone https://github.com/open-mmlab/mmsegmentation.git
+%cd mmsegmentation
+!git checkout main
+!pip install -e .
+```
+
+**Step 3.** Verification.
+
+```python
+import mmseg
+print(mmseg.__version__)
+# Example output: 1.0.0
+```
+
+**Note:**
+Within Jupyter, the exclamation mark `!` is used to call external executables and `%cd` is a [magic command](https://ipython.readthedocs.io/en/stable/interactive/magics.html#magic-cd) to change the current working directory of Python.
+
+### Using MMSegmentation with Docker
+
+We provide a [Dockerfile](https://github.com/open-mmlab/mmsegmentation/blob/main/docker/Dockerfile) to build an image. Ensure that your [docker version](https://docs.docker.com/engine/install/) >=19.03.
+
+```shell
+# build an image with PyTorch 1.11, CUDA 11.3
+# If you prefer other versions, just modified the Dockerfile
+docker build -t mmsegmentation docker/
+```
+
+Run it with
+
+```shell
+docker run --gpus all --shm-size=8g -it -v {DATA_DIR}:/mmsegmentation/data mmsegmentation
+```
+
+### Optional Dependencies
+
+#### Install GDAL
+
+[GDAL](https://gdal.org/) is a translator library for raster and vector geospatial data formats. Install GDAL to read complex formats and extremely large remote sensing images.
+
+```shell
+conda install GDAL
+```
+
+## Trouble shooting
+
+If you have some issues during the installation, please first view the [FAQ](notes/faq.md) page.
+You may [open an issue](https://github.com/open-mmlab/mmsegmentation/issues/new/choose) on GitHub if no solution is found.
diff --git a/mmsegmentation/docs/en/index.rst b/mmsegmentation/docs/en/index.rst
new file mode 100644
index 0000000..cdf8622
--- /dev/null
+++ b/mmsegmentation/docs/en/index.rst
@@ -0,0 +1,63 @@
+Welcome to MMSegmentation's documentation!
+===========================================
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Get Started
+
+   overview.md
+   get_started.md
+
+.. toctree::
+   :maxdepth: 2
+   :caption: User Guides
+
+   user_guides/index.rst
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Advanced Guides
+
+   advanced_guides/index.rst
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Migration
+
+   migration/index.rst
+
+.. toctree::
+   :caption: API Reference
+
+   api.rst
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Model Zoo
+
+   model_zoo.md
+   modelzoo_statistics.md
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Notes
+
+   notes/changelog.md
+   notes/faq.md
+
+.. toctree::
+   :caption: Device Support
+
+   device/npu.md
+
+.. toctree::
+   :caption: Switch Language
+
+   switch_language.md
+
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`search`
diff --git a/mmsegmentation/docs/en/make.bat b/mmsegmentation/docs/en/make.bat
new file mode 100644
index 0000000..922152e
--- /dev/null
+++ b/mmsegmentation/docs/en/make.bat
@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=.
+set BUILDDIR=_build
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.http://sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd
diff --git a/mmsegmentation/docs/en/migration/index.rst b/mmsegmentation/docs/en/migration/index.rst
new file mode 100644
index 0000000..2843bdb
--- /dev/null
+++ b/mmsegmentation/docs/en/migration/index.rst
@@ -0,0 +1,8 @@
+Migration
+***************
+
+.. toctree::
+   :maxdepth: 1
+
+   interface.md
+   package.md
diff --git a/mmsegmentation/docs/en/migration/interface.md b/mmsegmentation/docs/en/migration/interface.md
new file mode 100644
index 0000000..b83eeb9
--- /dev/null
+++ b/mmsegmentation/docs/en/migration/interface.md
@@ -0,0 +1,525 @@
+# Migration from MMSegmentation 0.x
+
+## Introduction
+
+This guide describes the fundamental differences between MMSegmentation 0.x and MMSegmentation 1.x in terms of behaviors and the APIs, and how these all relate to your migration journey.
+
+## New dependencies
+
+MMSegmentation 1.x depends on some new packages, you can prepare a new clean environment and install again according to the [installation tutorial](../get_started.md).
+
+Or install the below packages manually.
+
+1. [MMEngine](https://github.com/open-mmlab/mmengine): MMEngine is the core the OpenMMLab 2.0 architecture, and we splited many compentents unrelated to computer vision from MMCV to MMEngine.
+
+2. [MMCV](https://github.com/open-mmlab/mmcv): The computer vision package of OpenMMLab. This is not a new dependency, but you need to upgrade it to **2.0.0** version or above.
+
+3. [MMClassification](https://github.com/open-mmlab/mmclassification)(Optional): The image classification toolbox and benchmark of OpenMMLab. This is not a new dependency, but you need to upgrade it to **1.0.0rc6** version.
+
+4. [MMDetection](https://github.com/open-mmlab/mmdetection)(Optional): The object detection toolbox and benchmark of OpenMMLab. This is not a new dependency, but you need to upgrade it to **3.0.0** version or above.
+
+## Train launch
+
+The main improvement of OpenMMLab 2.0 is releasing MMEngine which provides universal and powerful runner for unified interfaces to launch training jobs.
+
+Compared with MMSeg0.x, MMSeg1.x provides fewer command line arguments in `tools/train.py`
+
+<table class="docutils">
+<tr>
+<td>Function</td>
+<td>Original</td>
+<td>New</td>
+</tr>
+<tr>
+<td>Loading pre-trained checkpoint</td>
+<td>--load_from=$CHECKPOINT</td>
+<td>--cfg-options load_from=$CHECKPOINT</td>
+</tr>
+<tr>
+<td>Resuming Train from specific checkpoint</td>
+<td>--resume-from=$CHECKPOINT</td>
+<td>--resume=$CHECKPOINT</td>
+</tr>
+<tr>
+<td>Resuming Train from the latest checkpoint</td>
+<td>--auto-resume</td>
+<td>--resume='auto'</td>
+</tr>
+<tr>
+<td>Whether not to evaluate the checkpoint during training</td>
+<td>--no-validate</td>
+<td>--cfg-options val_cfg=None val_dataloader=None val_evaluator=None</td>
+</tr>
+<tr>
+<td>Training device assignment</td>
+<td>--gpu-id=$DEVICE_ID</td>
+<td>-</td>
+</tr>
+<tr>
+<td>Whether or not set different seeds for different ranks</td>
+<td>--diff-seed</td>
+<td>--cfg-options randomness.diff_rank_seed=True</td>
+</tr>
+<td>Whether to set deterministic options for CUDNN backend</td>
+<td>--deterministic</td>
+<td>--cfg-options randomness.deterministic=True</td>
+</table>
+
+## Test launch
+
+Similar to training launch, there are only common arguments in tools/test.py of MMSegmentation 1.x.
+Below is the difference in test scripts,
+please refer to [this documentation](../user_guides/4_train_test.md) for more details about test launch.
+
+<table class="docutils">
+<tr>
+<td>Function</td>
+<td>0.x</td>
+<td>1.x</td>
+</tr>
+<tr>
+<td>Evaluation metrics</td>
+<td>--eval mIoU</td>
+<td>--cfg-options test_evaluator.type=IoUMetric</td>
+</tr>
+<tr>
+<td>Whether to use test time augmentation</td>
+<td>--aug-test</td>
+<td>--tta</td>
+</tr>
+<tr>
+<td>Whether save the output results without perform evaluation</td>
+<td>--format-only</td>
+<td>--cfg-options test_evaluator.format_only=True</td>
+</tr>
+</table>
+
+## Configuration file
+
+### Model settings
+
+No changes in `model.backbone`, `model.neck`, `model.decode_head` and `model.losses` fields.
+
+Add `model.data_preprocessor` field to configure the `DataPreProcessor`, including:
+
+- `mean` (Sequence, optional): The pixel mean of R, G, B channels. Defaults to None.
+
+- `std` (Sequence, optional): The pixel standard deviation of R, G, B channels. Defaults to None.
+
+- `size` (Sequence, optional): Fixed padding size.
+
+- `size_divisor` (int, optional): The divisor of padded size.
+
+- `seg_pad_val` (float, optional): Padding value of segmentation map. Default: 255.
+
+- `padding_mode` (str): Type of padding. Default: 'constant'.
+
+  - constant: pads with a constant value, this value is specified with pad_val.
+
+- `bgr_to_rgb` (bool): whether to convert image from BGR to RGB.Defaults to False.
+
+- `rgb_to_bgr` (bool): whether to convert image from RGB to BGR. Defaults to False.
+
+**Note:**
+Please refer [models documentation](../advanced_guides/models.md) for more details.
+
+### Dataset settings
+
+Changes in **data**:
+
+The original `data` field is split to `train_dataloader`, `val_dataloader` and `test_dataloader`. This allows us to configure them in fine-grained. For example, you can specify different sampler and batch size during training and test.
+The `samples_per_gpu` is renamed to `batch_size`.
+The `workers_per_gpu` is renamed to `num_workers`.
+
+<table class="docutils">
+<tr>
+<td>Original</td>
+<td>
+
+```python
+data = dict(
+    samples_per_gpu=4,
+    workers_per_gpu=4,
+    train=dict(...),
+    val=dict(...),
+    test=dict(...),
+)
+```
+
+</td>
+<tr>
+<td>New</td>
+<td>
+
+```python
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    dataset=dict(...),
+    sampler=dict(type='DefaultSampler', shuffle=True)  # necessary
+)
+
+val_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    dataset=dict(...),
+    sampler=dict(type='DefaultSampler', shuffle=False)  # necessary
+)
+
+test_dataloader = val_dataloader
+```
+
+</td>
+</tr>
+</table>
+
+Changes in **pipeline**
+
+- The original formatting transforms **`ToTensor`**、**`ImageToTensor`**、**`Collect`** are combined as [`PackSegInputs`](mmseg.datasets.transforms.PackSegInputs)
+- We don't recommend to do **`Normalize`** and **Pad** in the dataset pipeline. Please remove it from pipelines and set it in the `data_preprocessor` field.
+- The original **`Resize`** in MMSeg 1.x has been changed to **`RandomResize`** and the input arguments `img_scale` is renamed to `scale`, and the default value of `keep_ratio` is modified to False.
+- The original `test_pipeline` combines single-scale test and multi-scale test together, in MMSeg 1.x we separate it into `test_pipeline` and `tta_pipeline`.
+
+**Note:**
+We move some work of data transforms to the data preprocessor, like normalization, see [the documentation](package.md) for more details.
+
+train_pipeline
+
+<table class="docutils">
+<tr>
+<td>Original</td>
+<td>
+
+```python
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='Resize', img_scale=(2560, 640), ratio_range=(0.5, 2.0)),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='Normalize', **img_norm_cfg),
+    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
+]
+```
+
+</td>
+<tr>
+<td>New</td>
+<td>
+
+```python
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(
+        type='RandomResize',
+        scale=(2560, 640),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+```
+
+</td>
+</tr>
+</table>
+
+test_pipeline
+
+<table class="docutils">
+<tr>
+<td>Original</td>
+<td>
+
+```python
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(2560, 640),
+        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(type='Normalize', **img_norm_cfg),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img']),
+        ])
+]
+```
+
+</td>
+<tr>
+<td>New</td>
+<td>
+
+```python
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2560, 640), keep_ratio=True),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+```
+
+</td>
+</tr>
+</table>
+
+Changes in **`evaluation`**:
+
+- The **`evaluation`** field is split to `val_evaluator` and `test_evaluator`. And it won't support `interval` and `save_best` arguments.
+  The `interval` is moved to `train_cfg.val_interval`, and the `save_best` is moved to `default_hooks.checkpoint.save_best`. `pre_eval` has been removed.
+- `'mIoU'` has been changed to `'IoUMetric'`.
+
+<table class="docutils">
+<tr>
+<td>Original</td>
+<td>
+
+```python
+evaluation = dict(interval=2000, metric='mIoU', pre_eval=True)
+```
+
+</td>
+<tr>
+<td>New</td>
+<td>
+
+```python
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
+```
+
+</td>
+</tr>
+</table>
+
+### Optimizer and Schedule settings
+
+Changes in **`optimizer`** and **`optimizer_config`**:
+
+- Now we use `optim_wrapper` field to specify all configuration about the optimization process. And the `optimizer` is a sub field of `optim_wrapper` now.
+- `paramwise_cfg` is also a sub field of `optim_wrapper`, instead of `optimizer`.
+- `optimizer_config` is removed now, and all configurations of it are moved to `optim_wrapper`.
+- `grad_clip` is renamed to `clip_grad`.
+
+<table class="docutils">
+<tr>
+<td>Original</td>
+<td>
+
+```python
+optimizer = dict(type='AdamW', lr=0.0001, weight_decay=0.0005)
+optimizer_config = dict(grad_clip=dict(max_norm=1, norm_type=2))
+```
+
+</td>
+<tr>
+<td>New</td>
+<td>
+
+```python
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0005),
+    clip_grad=dict(max_norm=1, norm_type=2))
+```
+
+</td>
+</tr>
+</table>
+
+Changes in **`lr_config`**:
+
+- The `lr_config` field is removed and we use new `param_scheduler` to replace it.
+- The `warmup` related arguments are removed, since we use schedulers combination to implement this functionality.
+
+The new schedulers combination mechanism is very flexible, and you can use it to design many kinds of learning rate / momentum curves. See [the tutorial](TODO) for more details.
+
+<table class="docutils">
+<tr>
+<td>Original</td>
+<td>
+
+```python
+lr_config = dict(
+    policy='poly',
+    warmup='linear',
+    warmup_iters=1500,
+    warmup_ratio=1e-6,
+    power=1.0,
+    min_lr=0.0,
+    by_epoch=False)
+```
+
+</td>
+<tr>
+<td>New</td>
+<td>
+
+```python
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        power=1.0,
+        begin=1500,
+        end=160000,
+        eta_min=0.0,
+        by_epoch=False,
+    )
+]
+```
+
+</td>
+</tr>
+</table>
+
+Changes in **`runner`**:
+
+Most configuration in the original `runner` field is moved to `train_cfg`, `val_cfg` and `test_cfg`, which configure the loop in training, validation and test.
+
+<table class="docutils">
+<tr>
+<td>Original</td>
+<td>
+
+```python
+runner = dict(type='IterBasedRunner', max_iters=20000)
+```
+
+</td>
+<tr>
+<td>New</td>
+<td>
+
+```python
+# The `val_interval` is the original `evaluation.interval`.
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=20000, val_interval=2000)
+val_cfg = dict(type='ValLoop') # Use the default validation loop.
+test_cfg = dict(type='TestLoop') # Use the default test loop.
+```
+
+</td>
+</tr>
+</table>
+
+In fact, in OpenMMLab 2.0, we introduced `Loop` to control the behaviors in training, validation and test. The functionalities of `Runner` are also changed. You can find more details of [runner tutorial](https://github.com/open-mmlab/mmengine/blob/main/docs/en/design/runner.md) in [MMEngine](https://github.com/open-mmlab/mmengine/).
+
+### Runtime settings
+
+Changes in **`checkpoint_config`** and **`log_config`**:
+
+The `checkpoint_config` are moved to `default_hooks.checkpoint` and the `log_config` are moved to `default_hooks.logger`.
+And we move many hooks settings from the script code to the `default_hooks` field in the runtime configuration.
+
+```python
+default_hooks = dict(
+    # record the time of every iterations.
+    timer=dict(type='IterTimerHook'),
+
+    # print log every 50 iterations.
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+
+    # enable the parameter scheduler.
+    param_scheduler=dict(type='ParamSchedulerHook'),
+
+    # save checkpoint every 2000 iterations.
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=2000),
+
+    # set sampler seed in distributed environment.
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+
+    # validation results visualization.
+    visualization=dict(type='SegVisualizationHook'))
+```
+
+In addition, we split the original logger to logger and visualizer. The logger is used to record information and the visualizer is used to show the logger in different backends, like terminal and TensorBoard.
+
+<table class="docutils">
+<tr>
+<td>Original</td>
+<td>
+
+```python
+log_config = dict(
+    interval=100,
+    hooks=[
+        dict(type='TextLoggerHook'),
+        dict(type='TensorboardLoggerHook'),
+    ])
+```
+
+</td>
+<tr>
+<td>New</td>
+<td>
+
+```python
+default_hooks = dict(
+    ...
+    logger=dict(type='LoggerHook', interval=100),
+)
+vis_backends = [dict(type='LocalVisBackend'),
+                dict(type='TensorboardVisBackend')]
+visualizer = dict(
+    type='SegLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+```
+
+</td>
+</tr>
+</table>
+
+Changes in **`load_from`** and **`resume_from`**:
+
+- The `resume_from` is removed. And we use `resume` and `load_from` to replace it.
+  - If `resume=True` and `load_from` is **not None**, resume training from the checkpoint in `load_from`.
+  - If `resume=True` and `load_from` is **None**, try to resume from the latest checkpoint in the work directory.
+  - If `resume=False` and `load_from` is **not None**, only load the checkpoint, not resume training.
+  - If `resume=False` and `load_from` is **None**, do not load nor resume.
+
+Changes in **`dist_params`**: The `dist_params` field is a sub field of `env_cfg` now. And there are some new configurations in the `env_cfg`.
+
+```python
+env_cfg = dict(
+    # whether to enable cudnn benchmark
+    cudnn_benchmark=False,
+
+    # set multi process parameters
+    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+
+    # set distributed parameters
+    dist_cfg=dict(backend='nccl'),
+)
+```
+
+Changes in **`workflow`**: `workflow` related functionalities are removed.
+
+New field **`visualizer`**: The visualizer is a new design in OpenMMLab 2.0 architecture. We use a visualizer instance in the runner to handle results & log visualization and save to different backends. See the [visualization tutorial](../user_guides/visualization.md) for more details.
+
+New field **`default_scope`**: The start point to search module for all registries. The `default_scope` in MMSegmentation is `mmseg`. See [the registry tutorial](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/registry.md) for more details.
diff --git a/mmsegmentation/docs/en/migration/package.md b/mmsegmentation/docs/en/migration/package.md
new file mode 100644
index 0000000..728e9a9
--- /dev/null
+++ b/mmsegmentation/docs/en/migration/package.md
@@ -0,0 +1,113 @@
+# Package structures changes
+
+This section is included if you are curious about what has changed between MMSeg 0.x and 1.x.
+
+<table>
+<tr>
+<td>MMSegmentation 0.x</td>
+<td>MMSegmentation 1.x</td>
+</tr>
+<tr>
+<td>mmseg.api</td>
+<td>mmseg.api</td>
+</tr>
+<tr>
+<td bgcolor=#fcf7f7>- mmseg.core</td>
+<td bgcolor=#ecf4eb>+ mmseg.engine</td>
+</tr>
+<tr>
+<td>mmseg.datasets</td>
+<td>mmseg.datasets</td>
+</tr>
+<tr>
+<td>mmseg.models</td>
+<td>mmseg.models</td>
+</tr>
+<tr>
+<td bgcolor=#fcf7f7>- mmseg.ops</td>
+<td bgcolor=#ecf4eb>+ mmseg.structure</td>
+</tr>
+<tr>
+<td>mmseg.utils</td>
+<td>mmseg.utils</td>
+</tr>
+<tr>
+<td></td>
+<td bgcolor=#ecf4eb>+ mmseg.evaluation</td>
+</tr>
+<tr>
+<td></td>
+<td bgcolor=#ecf4eb>+ mmseg.registry</td>
+<tr>
+</table>
+
+## Removed packages
+
+### `mmseg.core`
+
+In OpenMMLab 2.0, `core` package has been removed. `hooks` and `optimizers` of `core` are moved in `mmseg.engine`, and `evaluation` in `core` is mmseg.evaluation currently.
+
+## `mmseg.ops`
+
+`ops` package included `encoding` and `wrappers`, which are moved in `mmseg.models.utils`.
+
+## Added packages
+
+### `mmseg.engine`
+
+OpenMMLab 2.0 adds a new foundational library for training deep learning, MMEngine. It servers as the training engine of all OpenMMLab codebases.
+`engine` package of mmseg is some customized modules for semantic segmentation task, like `SegVisualizationHook` which works for visualizing segmentation mask.
+
+### `mmseg.structure`
+
+In OpenMMLab 2.0, we designed data structure for computer vision task, and in mmseg, we implements `SegDataSample` in `structure` package.
+
+### `mmseg.evaluation`
+
+We move all evaluation metric in `mmseg.evaluation`.
+
+### `mmseg.registry`
+
+We moved registry implementations for all kinds of modules in MMSegmentation in `mmseg.registry`.
+
+## Modified packages
+
+### `mmseg.apis`
+
+OpenMMLab 2.0 tries to support unified interface for multitasking of Computer Vision, and releases much stronger [`Runner`](https://github.com/open-mmlab/mmengine/blob/main/docs/en/design/runner.md), so MMSeg 1.x removed modules in `train.py` and `test.py` renamed `init_segmentor` to `init_model` and `inference_segmentor` to `inference_model`.
+
+Here is the changes of `mmseg.apis`:
+
+|       Function        | Changes                                         |
+| :-------------------: | :---------------------------------------------- |
+|   `init_segmentor`    | Renamed to `init_model`                         |
+| `inference_segmentor` | Rename to `inference_model`                     |
+| `show_result_pyplot`  | Implemented based on `SegLocalVisualizer`       |
+|     `train_model`     | Removed, use `runner.train` to train.           |
+|   `multi_gpu_test`    | Removed, use `runner.test` to test.             |
+|   `single_gpu_test`   | Removed, use `runner.test` to test.             |
+|   `set_random_seed`   | Removed, use `mmengine.runner.set_random_seed`. |
+|  `init_random_seed`   | Removed, use `mmengine.dist.sync_random_seed`.  |
+
+### `mmseg.datasets`
+
+OpenMMLab 2.0 defines the `BaseDataset` to function and interface of dataset, and MMSegmentation 1.x also follow this protocol and defines the `BaseSegDataset` inherited from `BaseDataset`. MMCV 2.x collects general data transforms for multiple tasks e.g. classification, detection, segmentation, so MMSegmentation 1.x uses these data transforms and removes them from mmseg.datasets.
+
+|   Packages/Modules    | Changes                                                                                     |
+| :-------------------: | :------------------------------------------------------------------------------------------ |
+|   `mmseg.pipelines`   | Moved in `mmcv.transforms`                                                                  |
+|    `mmseg.sampler`    | Moved in `mmengine.dataset.sampler`                                                         |
+|    `CustomDataset`    | Renamed to `BaseSegDataset` and inherited from `BaseDataset` in MMEngine                    |
+| `DefaultFormatBundle` | Replaced with `PackSegInputs`                                                               |
+|  `LoadImageFromFile`  | Moved in `mmcv.transforms.LoadImageFromFile`                                                |
+|   `LoadAnnotations`   | Moved in `mmcv.transforms.LoadAnnotations`                                                  |
+|       `Resize`        | Moved in `mmcv.transforms` and split into `Resize`, `RandomResize` and `RandomChoiceResize` |
+|     `RandomFlip`      | Moved in `mmcv.transforms.RandomFlip`                                                       |
+|         `Pad`         | Moved in `mmcv.transforms.Pad`                                                              |
+|      `Normalize`      | Moved in `mmcv.transforms.Normalize`                                                        |
+|       `Compose`       | Moved in `mmcv.transforms.Compose`                                                          |
+|    `ImageToTensor`    | Moved in `mmcv.transforms.ImageToTensor`                                                    |
+
+### `mmseg.models`
+
+`models` has not changed a lot, just added the `encoding` and `wrappers` from previous `mmseg.ops`
diff --git a/mmsegmentation/docs/en/model_zoo.md b/mmsegmentation/docs/en/model_zoo.md
new file mode 100644
index 0000000..6717df6
--- /dev/null
+++ b/mmsegmentation/docs/en/model_zoo.md
@@ -0,0 +1,186 @@
+# Benchmark and Model Zoo
+
+## Common settings
+
+- We use distributed training with 4 GPUs by default.
+
+- All pytorch-style pretrained backbones on ImageNet are train by ourselves, with the same procedure in the [paper](https://arxiv.org/pdf/1812.01187.pdf).
+  Our ResNet style backbone are based on ResNetV1c variant, where the 7x7 conv in the input stem is replaced with three 3x3 convs.
+
+- For the consistency across different hardwares, we report the GPU memory as the maximum value of `torch.cuda.max_memory_allocated()` for all 4 GPUs with `torch.backends.cudnn.benchmark=False`.
+  Note that this value is usually less than what `nvidia-smi` shows.
+
+- We report the inference time as the total time of network forwarding and post-processing, excluding the data loading time.
+  Results are obtained with the script `tools/benchmark.py` which computes the average time on 200 images with `torch.backends.cudnn.benchmark=False`.
+
+- There are two inference modes in this framework.
+
+  - `slide` mode: The `test_cfg` will be like `dict(mode='slide', crop_size=(769, 769), stride=(513, 513))`.
+
+    In this mode, multiple patches will be cropped from input image, passed into network individually.
+    The crop size and stride between patches are specified by `crop_size` and `stride`.
+    The overlapping area will be merged by average
+
+  - `whole` mode: The `test_cfg` will be like `dict(mode='whole')`.
+
+    In this mode, the whole imaged will be passed into network directly.
+
+    By default, we use `slide` inference for 769x769 trained model, `whole` inference for the rest.
+
+- For input size of 8x+1 (e.g. 769), `align_corner=True` is adopted as a traditional practice.
+  Otherwise, for input size of 8x (e.g. 512, 1024), `align_corner=False` is adopted.
+
+## Baselines
+
+### FCN
+
+Please refer to [FCN](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn) for details.
+
+### PSPNet
+
+Please refer to [PSPNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet) for details.
+
+### DeepLabV3
+
+Please refer to [DeepLabV3](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3) for details.
+
+### PSANet
+
+Please refer to [PSANet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet) for details.
+
+### DeepLabV3+
+
+Please refer to [DeepLabV3+](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus) for details.
+
+### UPerNet
+
+Please refer to [UPerNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet) for details.
+
+### NonLocal Net
+
+Please refer to [NonLocal Net](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net) for details.
+
+### EncNet
+
+Please refer to [EncNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet) for details.
+
+### CCNet
+
+Please refer to [CCNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet) for details.
+
+### DANet
+
+Please refer to [DANet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet) for details.
+
+### APCNet
+
+Please refer to [APCNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet) for details.
+
+### HRNet
+
+Please refer to [HRNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet) for details.
+
+### GCNet
+
+Please refer to [GCNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet) for details.
+
+### DMNet
+
+Please refer to [DMNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet) for details.
+
+### ANN
+
+Please refer to [ANN](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann) for details.
+
+### OCRNet
+
+Please refer to [OCRNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet) for details.
+
+### Fast-SCNN
+
+Please refer to [Fast-SCNN](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastscnn) for details.
+
+### ResNeSt
+
+Please refer to [ResNeSt](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/resnest) for details.
+
+### Semantic FPN
+
+Please refer to [Semantic FPN](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/sem_fpn) for details.
+
+### PointRend
+
+Please refer to [PointRend](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/point_rend) for details.
+
+### MobileNetV2
+
+Please refer to [MobileNetV2](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v2) for details.
+
+### MobileNetV3
+
+Please refer to [MobileNetV3](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v3) for details.
+
+### EMANet
+
+Please refer to [EMANet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/emanet) for details.
+
+### DNLNet
+
+Please refer to [DNLNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet) for details.
+
+### CGNet
+
+Please refer to [CGNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/cgnet) for details.
+
+### Mixed Precision (FP16) Training
+
+Please refer [Mixed Precision (FP16) Training on BiSeNetV2](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv2/bisenetv2_fcn_4xb4-160k_cityscapes-1024x1024.py) for details.
+
+### U-Net
+
+Please refer to [U-Net](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/README.md) for details.
+
+### ViT
+
+Please refer to [ViT](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/README.md) for details.
+
+### Swin
+
+Please refer to [Swin](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/swin/README.md) for details.
+
+### SETR
+
+Please refer to [SETR](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/setr/README.md) for details.
+
+## Speed benchmark
+
+### Hardware
+
+- 8 NVIDIA Tesla V100 (32G) GPUs
+- Intel(R) Xeon(R) Gold 6148 CPU @ 2.40GHz
+
+### Software environment
+
+- Python 3.7
+- PyTorch 1.5
+- CUDA 10.1
+- CUDNN 7.6.03
+- NCCL 2.4.08
+
+### Training speed
+
+For fair comparison, we benchmark all implementations with ResNet-101V1c.
+The input size is fixed to 1024x512 with batch size 2.
+
+The training speed is reported as followed, in terms of second per iter (s/iter). The lower, the better.
+
+| Implementation                                                              | PSPNet (s/iter) | DeepLabV3+ (s/iter) |
+| --------------------------------------------------------------------------- | --------------- | ------------------- |
+| [MMSegmentation](https://github.com/open-mmlab/mmsegmentation)              | **0.83**        | **0.85**            |
+| [SegmenTron](https://github.com/LikeLy-Journey/SegmenTron)                  | 0.84            | 0.85                |
+| [CASILVision](https://github.com/CSAILVision/semantic-segmentation-pytorch) | 1.15            | N/A                 |
+| [vedaseg](https://github.com/Media-Smart/vedaseg)                           | 0.95            | 1.25                |
+
+:::{note}
+The output stride of DeepLabV3+ is 8.
+:::
diff --git a/mmsegmentation/docs/en/modelzoo_statistics.md b/mmsegmentation/docs/en/modelzoo_statistics.md
new file mode 100644
index 0000000..e5e21a1
--- /dev/null
+++ b/mmsegmentation/docs/en/modelzoo_statistics.md
@@ -0,0 +1,102 @@
+# Model Zoo Statistics
+
+- Number of papers: 47
+
+  - ALGORITHM: 36
+  - BACKBONE: 11
+
+- Number of checkpoints: 612
+
+  - \[ALGORITHM\] [ANN](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann) (16 ckpts)
+
+  - \[ALGORITHM\] [APCNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet) (12 ckpts)
+
+  - \[BACKBONE\] [BEiT](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/beit) (2 ckpts)
+
+  - \[ALGORITHM\] [BiSeNetV1](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1) (11 ckpts)
+
+  - \[ALGORITHM\] [BiSeNetV2](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv2) (4 ckpts)
+
+  - \[ALGORITHM\] [CCNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet) (16 ckpts)
+
+  - \[ALGORITHM\] [CGNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/cgnet) (2 ckpts)
+
+  - \[BACKBONE\] [ConvNeXt](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/convnext) (6 ckpts)
+
+  - \[ALGORITHM\] [DANet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet) (16 ckpts)
+
+  - \[ALGORITHM\] [DeepLabV3](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3) (41 ckpts)
+
+  - \[ALGORITHM\] [DeepLabV3+](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus) (42 ckpts)
+
+  - \[ALGORITHM\] [DMNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet) (12 ckpts)
+
+  - \[ALGORITHM\] [DNLNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet) (12 ckpts)
+
+  - \[ALGORITHM\] [DPT](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dpt) (1 ckpts)
+
+  - \[ALGORITHM\] [EMANet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/emanet) (4 ckpts)
+
+  - \[ALGORITHM\] [EncNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet) (12 ckpts)
+
+  - \[ALGORITHM\] [ERFNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/erfnet) (1 ckpts)
+
+  - \[ALGORITHM\] [FastFCN](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn) (12 ckpts)
+
+  - \[ALGORITHM\] [Fast-SCNN](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastscnn) (1 ckpts)
+
+  - \[ALGORITHM\] [FCN](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn) (41 ckpts)
+
+  - \[ALGORITHM\] [GCNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet) (16 ckpts)
+
+  - \[BACKBONE\] [HRNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet) (37 ckpts)
+
+  - \[ALGORITHM\] [ICNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet) (12 ckpts)
+
+  - \[ALGORITHM\] [ISANet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet) (16 ckpts)
+
+  - \[ALGORITHM\] [K-Net](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/knet) (7 ckpts)
+
+  - \[BACKBONE\] [MAE](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mae) (1 ckpts)
+
+  - \[ALGORITHM\] [Mask2Former](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former) (13 ckpts)
+
+  - \[ALGORITHM\] [MaskFormer](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/maskformer) (4 ckpts)
+
+  - \[BACKBONE\] [MobileNetV2](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v2) (8 ckpts)
+
+  - \[BACKBONE\] [MobileNetV3](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v3) (4 ckpts)
+
+  - \[ALGORITHM\] [NonLocal Net](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net) (16 ckpts)
+
+  - \[ALGORITHM\] [OCRNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet) (24 ckpts)
+
+  - \[ALGORITHM\] [PointRend](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/point_rend) (4 ckpts)
+
+  - \[BACKBONE\] [PoolFormer](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/poolformer) (5 ckpts)
+
+  - \[ALGORITHM\] [PSANet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet) (16 ckpts)
+
+  - \[ALGORITHM\] [PSPNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet) (54 ckpts)
+
+  - \[BACKBONE\] [ResNeSt](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/resnest) (8 ckpts)
+
+  - \[ALGORITHM\] [SegFormer](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer) (13 ckpts)
+
+  - \[ALGORITHM\] [Segmenter](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segmenter) (5 ckpts)
+
+  - \[ALGORITHM\] [Semantic FPN](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/sem_fpn) (4 ckpts)
+
+  - \[ALGORITHM\] [SETR](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/setr) (7 ckpts)
+
+  - \[ALGORITHM\] [STDC](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/stdc) (4 ckpts)
+
+  - \[BACKBONE\] [Swin Transformer](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/swin) (6 ckpts)
+
+  - \[BACKBONE\] [Twins](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins) (12 ckpts)
+
+  - \[ALGORITHM\] [UNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet) (25 ckpts)
+
+  - \[ALGORITHM\] [UPerNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet) (16 ckpts)
+
+  - \[BACKBONE\] [Vision Transformer](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit) (11 ckpts)
diff --git a/mmsegmentation/docs/en/notes/changelog.md b/mmsegmentation/docs/en/notes/changelog.md
new file mode 100644
index 0000000..8eaf332
--- /dev/null
+++ b/mmsegmentation/docs/en/notes/changelog.md
@@ -0,0 +1,506 @@
+# Changelog of v1.x
+
+## v1.2.2 (12/14/2023)
+
+### Bug Fixes
+
+- Fix bug in cross entropy loss ([#3457](https://github.com/open-mmlab/mmsegmentation/pull/3457))
+- Allow custom visualizer ([#3455](https://github.com/open-mmlab/mmsegmentation/pull/3455))
+- test resize with pad_shape ([#3421](https://github.com/open-mmlab/mmsegmentation/pull/3421))
+- add with-labels args to inferencer for visualization without labels ([#3466](https://github.com/open-mmlab/mmsegmentation/pull/3466))
+
+### New Contributors
+
+- @okotaku made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3421
+
+## v1.2.1 (10/17/2023)
+
+### Bug Fixes
+
+- Add bpe_simple_vocab_16e6.txt.gz to release ([#3386](https://github.com/open-mmlab/mmsegmentation/pull/3386))
+- Fix init api ([#3388](https://github.com/open-mmlab/mmsegmentation/pull/3388))
+
+## v1.2.0 (10/12/2023)
+
+### Features
+
+- Support Side Adapter Network ([#3232](https://github.com/open-mmlab/mmsegmentation/pull/3232))
+
+### Bug Fixes
+
+- fix wrong variables passing for `set_dataset_meta` ([#3348](https://github.com/open-mmlab/mmsegmentation/pull/3348))
+
+### Documentation
+
+- add documentation of Finetune ONNX Models (MMSegemetation) Inference for NVIDIA Jetson ([#3372](https://github.com/open-mmlab/mmsegmentation/pull/3372))
+
+## v1.1.2(09/20/2023)
+
+### Features
+
+- Add semantic label to the segmentation visualization results ([#3229](https://github.com/open-mmlab/mmsegmentation/pull/3229))
+- Support NYU depth estimation dataset ([#3269](https://github.com/open-mmlab/mmsegmentation/pull/3269))
+- Support Kullback-Leibler divergence Loss ([#3242](https://github.com/open-mmlab/mmsegmentation/pull/3242))
+- Support depth metrics ([#3297](https://github.com/open-mmlab/mmsegmentation/pull/3297))
+- Support Remote sensing inferencer ([#3131](https://github.com/open-mmlab/mmsegmentation/pull/3131))
+- Support VPD Depth Estimator ((#3321)(https://github.com/open-mmlab/mmsegmentation/pull/3321))
+- Support inference and visualization of VPD ([#3331](https://github.com/open-mmlab/mmsegmentation/pull/3331))
+- Support using the pytorch-grad-cam tool to visualize Class Activation Maps (CAM) ([#3324](https://github.com/open-mmlab/mmsegmentation/pull/3324))
+
+### New projects
+
+- Support PP-Mobileseg ([#3239](https://github.com/open-mmlab/mmsegmentation/pull/3239))
+- Support CAT-Seg (CVPR'2023) ([#3098](https://github.com/open-mmlab/mmsegmentation/pull/3098))
+- Support Adabins ([#3257](https://github.com/open-mmlab/mmsegmentation/pull/3257))
+- Add pp_mobileseg onnx inference script ([#3268](https://github.com/open-mmlab/mmsegmentation/pull/3268))
+
+### Bug Fixes
+
+- Fix module PascalContextDataset ([#3235](https://github.com/open-mmlab/mmsegmentation/pull/3235))
+- Fix one hot encoding for dice loss ([#3237](https://github.com/open-mmlab/mmsegmentation/pull/3237))
+- Fix confusion_matrix.py ([#3291](https://github.com/open-mmlab/mmsegmentation/pull/3291))
+- Fix inferencer visualization ([#3333](https://github.com/open-mmlab/mmsegmentation/pull/3333))
+
+### Documentation
+
+- Translate doc for docs/zh_cn/user_guides/5_deployment.md ([#3281](https://github.com/open-mmlab/mmsegmentation/pull/3281))
+
+### New Contributors
+
+- @angiecao made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3235
+- @yeedrag made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3237
+- @Yang-Changhui made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3239
+- @ooooo-create made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3261
+- @Ben-Louis made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3269
+- @crazysteeaam made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3284
+- @zen0no made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3242
+- @XiandongWang made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3291
+- @ZhaoQiiii made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3332
+- @zhen6618 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3324
+
+## v1.1.1(07/24/2023)
+
+### Features
+
+- Add bdd100K datasets ([#3158](https://github.com/open-mmlab/mmsegmentation/pull/3158))
+- Remove batch inference assertion ([#3210](https://github.com/open-mmlab/mmsegmentation/pull/3210))
+
+### Bug Fixes
+
+- Fix train map path for coco-stuff164k.py ([#3187](https://github.com/open-mmlab/mmsegmentation/pull/3187))
+- Fix mim search error ([#3194](https://github.com/open-mmlab/mmsegmentation/pull/3194))
+- Fix SegTTAModel with no attribute '\_gt_sem_seg' error ([#3152](https://github.com/open-mmlab/mmsegmentation/pull/3152))
+- Fix Albumentations default key mapping mismatch ([#3195](https://github.com/open-mmlab/mmsegmentation/pull/3195))
+
+### New Contributors
+
+- @OliverGrace made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3187
+- @ZiAn-Su made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3152
+- @CastleDream made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3158
+- @coding-famer made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3174
+- @Alias-z made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3195
+
+## v1.1.0(06/28/2023)
+
+## What's Changed
+
+### Features
+
+- Support albu transform ([#2943](https://github.com/open-mmlab/mmsegmentation/pull/2943))
+- Support DDRNet ([#2855](https://github.com/open-mmlab/mmsegmentation/pull/2855))
+- Add GDAL backend and Support LEVIR-CD Dataset ([#2903](https://github.com/open-mmlab/mmsegmentation/pull/2903))
+- Support DSDL Dataset ([#2925](https://github.com/open-mmlab/mmsegmentation/pull/2925))
+- huasdorff distance loss ([#2820](https://github.com/open-mmlab/mmsegmentation/pull/2820))
+
+### New Projects
+
+- Support SAM inferencer ([#2897](https://github.com/open-mmlab/mmsegmentation/pull/2897))
+- Added a supported for Visual Attention Network (VAN) ([#2987](https://github.com/open-mmlab/mmsegmentation/pull/2987))
+- add GID dataset ([#3038](https://github.com/open-mmlab/mmsegmentation/pull/3038))
+- add Medical semantic seg dataset: Bactteria ([#2568](https://github.com/open-mmlab/mmsegmentation/pull/2568))
+- add Medical semantic seg dataset: Vampire ([#2633](https://github.com/open-mmlab/mmsegmentation/pull/2633))
+- add Medical semantic seg dataset: Ravir ([#2635](https://github.com/open-mmlab/mmsegmentation/pull/2635))
+- add Medical semantic seg dataset: Cranium ([#2675](https://github.com/open-mmlab/mmsegmentation/pull/2675))
+- add Medical semantic seg dataset: bccs ([#2861](https://github.com/open-mmlab/mmsegmentation/pull/2861))
+- add Medical semantic seg dataset: Gamma Task3 dataset ([#2695](https://github.com/open-mmlab/mmsegmentation/pull/2695))
+- add Medical semantic seg dataset: consep ([#2724](https://github.com/open-mmlab/mmsegmentation/pull/2724))
+- add Medical semantic seg dataset: breast_cancer_cell_seg dataset ([#2726](https://github.com/open-mmlab/mmsegmentation/pull/2726))
+- add Medical semantic seg dataset: chest_image_pneum dataset ([#2727](https://github.com/open-mmlab/mmsegmentation/pull/2727))
+- add Medical semantic seg dataset: conic2022 ([#2725](https://github.com/open-mmlab/mmsegmentation/pull/2725))
+- add Medical semantic seg dataset: dr_hagis ([#2729](https://github.com/open-mmlab/mmsegmentation/pull/2729))
+- add Medical semantic seg dataset: orvs ([#2728](https://github.com/open-mmlab/mmsegmentation/pull/2728))
+- add Medical semantic seg dataset: ISIC-2016 Task1 ([#2708](https://github.com/open-mmlab/mmsegmentation/pull/2708))
+- add Medical semantic seg dataset: ISIC-2017 Task1 ([#2709](https://github.com/open-mmlab/mmsegmentation/pull/2709))
+- add Medical semantic seg dataset: Kvasir seg ([#2677](https://github.com/open-mmlab/mmsegmentation/pull/2677))
+- add Medical semantic seg dataset: Kvasir seg aliyun ([#2678](https://github.com/open-mmlab/mmsegmentation/pull/2678))
+- add Medical semantic seg dataset: Rite ([#2680](https://github.com/open-mmlab/mmsegmentation/pull/2680))
+- add Medical semantic seg dataset: Fusc2021 ([#2682](https://github.com/open-mmlab/mmsegmentation/pull/2682))
+- add Medical semantic seg dataset: 2pm vessel ([#2685](https://github.com/open-mmlab/mmsegmentation/pull/2685))
+- add Medical semantic seg dataset: Pcam ([#2684](https://github.com/open-mmlab/mmsegmentation/pull/2684))
+- add Medical semantic seg dataset: Pannuke ([#2683](https://github.com/open-mmlab/mmsegmentation/pull/2683))
+- add Medical semantic seg dataset: Covid 19 ct cxr ([#2688](https://github.com/open-mmlab/mmsegmentation/pull/2688))
+- add Medical semantic seg dataset: Crass ([#2690](https://github.com/open-mmlab/mmsegmentation/pull/2690))
+- add Medical semantic seg dataset: Chest x ray images with pneumothorax masks ([#2687](https://github.com/open-mmlab/mmsegmentation/pull/2687))
+
+### Enhancement
+
+- Robust mapping from image path to seg map path ([#3091](https://github.com/open-mmlab/mmsegmentation/pull/3091))
+- Change assertion logic inference cfg.model.test_cfg ([#3012](https://github.com/open-mmlab/mmsegmentation/pull/3012))
+- Refactor dice loss ([#3002](https://github.com/open-mmlab/mmsegmentation/pull/3002))
+- Update Dockerfile libgl1-mesa-dev ([#3095](https://github.com/open-mmlab/mmsegmentation/pull/3095))
+- Prevent passed `ann_file` from silently failing to load ([#2966](https://github.com/open-mmlab/mmsegmentation/pull/2966))
+- Update the translation of models documentation ([#2833](https://github.com/open-mmlab/mmsegmentation/pull/2833))
+- Add docs contents at README.md ([#3083](https://github.com/open-mmlab/mmsegmentation/pull/3083))
+- Enhance swin pretrained model loading ([#3097](https://github.com/open-mmlab/mmsegmentation/pull/3097))
+
+### Bug Fixes
+
+- Handle case where device is neither CPU nor CUDA in HamHead ([#2868](https://github.com/open-mmlab/mmsegmentation/pull/2868))
+- Fix bugs when out_channels==1 ([#2911](https://github.com/open-mmlab/mmsegmentation/pull/2911))
+- Fix binary C=1 focal loss & dataset fileio ([#2935](https://github.com/open-mmlab/mmsegmentation/pull/2935))
+- Fix isaid dataset pre-processing tool ([#3010](https://github.com/open-mmlab/mmsegmentation/pull/3010))
+- Fix bug cannot use both '--tta' and '--out' while testing ([#3067](https://github.com/open-mmlab/mmsegmentation/pull/3067))
+- Fix inferencer ut ([#3117](https://github.com/open-mmlab/mmsegmentation/pull/3117))
+- Fix document ([#2863](https://github.com/open-mmlab/mmsegmentation/pull/2863), [#2896](https://github.com/open-mmlab/mmsegmentation/pull/2896), [#2919](https://github.com/open-mmlab/mmsegmentation/pull/2919), [#2951](https://github.com/open-mmlab/mmsegmentation/pull/2951), [#2970](https://github.com/open-mmlab/mmsegmentation/pull/2970), [#2961](https://github.com/open-mmlab/mmsegmentation/pull/2961), [#3042](https://github.com/open-mmlab/mmsegmentation/pull/3042), )
+- Fix squeeze error when N=1 and C=1 ([#2933](https://github.com/open-mmlab/mmsegmentation/pull/2933))
+
+### New Contributors
+
+- @liu-mengyang made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2896
+- @likyoo made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2911
+- @1qh made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2902
+- @JoshuaChou2018 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2951
+- @jts250 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2833
+- @MGAMZ made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2970
+- @tianbinli made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2568
+- @Provable0816 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2633
+- @Zoulinx made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2903
+- @wufan-tb made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2925
+- @haruishi43 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2966
+- @Masaaki-75 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2675
+- @tang576225574 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2987
+- @Kedreamix made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3010
+- @nightrain01 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3067
+- @shigengtian made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3095
+- @SheffieldCao made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3097
+- @wangruohui made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3091
+- @LHamnett made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3012
+
+## v1.0.0(04/06/2023)
+
+### Highlights
+
+- Add Mapillary Vistas Datasets support to MMSegmentation Core Package ([#2576](https://github.com/open-mmlab/mmsegmentation/pull/2576))
+- Support PIDNet ([#2609](https://github.com/open-mmlab/mmsegmentation/pull/2609))
+- Support SegNeXt ([#2654](https://github.com/open-mmlab/mmsegmentation/pull/2654))
+
+### Features
+
+- Support calculating FLOPs of segmentors ([#2706](https://github.com/open-mmlab/mmsegmentation/pull/2706))
+- Support multi-band image for Mosaic ([#2748](https://github.com/open-mmlab/mmsegmentation/pull/2748))
+- Support dump segment prediction ([#2712](https://github.com/open-mmlab/mmsegmentation/pull/2712))
+
+### Bug fix
+
+- Fix format_result and fix prefix param in cityscape metric, and rename CitysMetric to CityscapesMetric ([#2660](https://github.com/open-mmlab/mmsegmentation/pull/2660))
+- Support input gt seg map is not 2D ([#2739](https://github.com/open-mmlab/mmsegmentation/pull/2739))
+- Fix accepting an unexpected argument `local-rank` in PyTorch 2.0 ([#2812](https://github.com/open-mmlab/mmsegmentation/pull/2812))
+
+### Documentation
+
+- Add Chinese version of various documentation ([#2673](https://github.com/open-mmlab/mmsegmentation/pull/2673), [#2702](https://github.com/open-mmlab/mmsegmentation/pull/2702), [#2703](https://github.com/open-mmlab/mmsegmentation/pull/2703), [#2701](https://github.com/open-mmlab/mmsegmentation/pull/2701), [#2722](https://github.com/open-mmlab/mmsegmentation/pull/2722), [#2733](https://github.com/open-mmlab/mmsegmentation/pull/2733), [#2769](https://github.com/open-mmlab/mmsegmentation/pull/2769), [#2790](https://github.com/open-mmlab/mmsegmentation/pull/2790), [#2798](https://github.com/open-mmlab/mmsegmentation/pull/2798))
+- Update and refine various English documentation ([#2715](https://github.com/open-mmlab/mmsegmentation/pull/2715), [#2755](https://github.com/open-mmlab/mmsegmentation/pull/2755), [#2745](https://github.com/open-mmlab/mmsegmentation/pull/2745), [#2797](https://github.com/open-mmlab/mmsegmentation/pull/2797), [#2799](https://github.com/open-mmlab/mmsegmentation/pull/2799), [#2821](https://github.com/open-mmlab/mmsegmentation/pull/2821), [#2827](https://github.com/open-mmlab/mmsegmentation/pull/2827), [#2831](https://github.com/open-mmlab/mmsegmentation/pull/2831))
+- Add deeplabv3 model structure documentation ([#2426](https://github.com/open-mmlab/mmsegmentation/pull/2426))
+- Add custom metrics documentation ([#2799](https://github.com/open-mmlab/mmsegmentation/pull/2799))
+- Add faq in dev-1.x branch ([#2765](https://github.com/open-mmlab/mmsegmentation/pull/2765))
+
+### New Contributors
+
+- @liuruiqiang made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2554
+- @wangjiangben-hw made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2569
+- @jinxianwei made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2557
+- @KKIEEK made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2747
+- @Renzhihan made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2765
+
+## v1.0.0rc6(03/03/2023)
+
+### Highlights
+
+- Support MMSegInferencer ([#2413](https://github.com/open-mmlab/mmsegmentation/pull/2413), [#2658](https://github.com/open-mmlab/mmsegmentation/pull/2658))
+- Support REFUGE dataset ([#2554](https://github.com/open-mmlab/mmsegmentation/pull/2554))
+
+### Features
+
+- Support auto import modules from registry ([#2481](https://github.com/open-mmlab/mmsegmentation/pull/2481))
+- Replace numpy ascontiguousarray with torch contiguous to speed-up ([#2604](https://github.com/open-mmlab/mmsegmentation/pull/2604))
+- Add browse_dataset.py tool ([#2649](https://github.com/open-mmlab/mmsegmentation/pull/2649))
+
+### Bug fix
+
+- Rename and Fix bug of projects HieraSeg ([#2565](https://github.com/open-mmlab/mmsegmentation/pull/2565))
+- Add out_channels  in `CascadeEncoderDecoder` and update OCRNet and MobileNet v2 results ([#2656](https://github.com/open-mmlab/mmsegmentation/pull/2656))
+
+### Documentation
+
+- Add dataflow documentation of Chinese version ([#2652](https://github.com/open-mmlab/mmsegmentation/pull/2652))
+- Add custmized runtime documentation of English version ([#2533](https://github.com/open-mmlab/mmsegmentation/pull/2533))
+- Add documentation for visualizing feature map using wandb backend ([#2557](https://github.com/open-mmlab/mmsegmentation/pull/2557))
+- Add documentation for benchmark results on NPU (HUAWEI Ascend) ([#2569](https://github.com/open-mmlab/mmsegmentation/pull/2569), [#2596](https://github.com/open-mmlab/mmsegmentation/pull/2596), [#2610](https://github.com/open-mmlab/mmsegmentation/pull/2610))
+- Fix api name error in the migration doc ([#2601](https://github.com/open-mmlab/mmsegmentation/pull/2601))
+- Refine projects documentation ([#2586](https://github.com/open-mmlab/mmsegmentation/pull/2586))
+- Refine MMSegmentation documentation ([#2668](https://github.com/open-mmlab/mmsegmentation/pull/2668), [#2659](https://github.com/open-mmlab/mmsegmentation/pull/2659))
+
+### New Contributors
+
+- @zccjjj made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2548
+- @liuruiqiang made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2554
+- @wangjiangben-hw made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2569
+- @jinxianwei made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2557
+
+## v1.0.0rc5(02/01/2023)
+
+### Bug fix
+
+- Fix MaskFormer and Mask2Former when install mmdet from source ([#2532](https://github.com/open-mmlab/mmsegmentation/pull/2532))
+- Support new fileio interface in `MMCV>=2.0.0rc4` ([#2543](https://github.com/open-mmlab/mmsegmentation/pull/2543))
+- Fix ERFNet URL in dev-1.x branch ([#2537](https://github.com/open-mmlab/mmsegmentation/pull/2537))
+- Fix misleading `List[Tensor]` types ([#2546](https://github.com/open-mmlab/mmsegmentation/pull/2546))
+- Rename typing.py to typing_utils.py ([#2548](https://github.com/open-mmlab/mmsegmentation/pull/2548))
+
+## v1.0.0rc4(01/30/2023)
+
+### Highlights
+
+- Support ISNet (ICCV'2021) in projects ([#2400](https://github.com/open-mmlab/mmsegmentation/pull/2400))
+- Support HSSN (CVPR'2022) in projects ([#2444](https://github.com/open-mmlab/mmsegmentation/pull/2444))
+
+### Features
+
+- Add Gaussian Noise and Blur for biomedical data ([#2373](https://github.com/open-mmlab/mmsegmentation/pull/2373))
+- Add BioMedicalRandomGamma ([#2406](https://github.com/open-mmlab/mmsegmentation/pull/2406))
+- Add BioMedical3DPad ([#2383](https://github.com/open-mmlab/mmsegmentation/pull/2383))
+- Add BioMedical3DRandomFlip ([#2404](https://github.com/open-mmlab/mmsegmentation/pull/2404))
+- Add `gt_edge_map` field to SegDataSample ([#2466](https://github.com/open-mmlab/mmsegmentation/pull/2466))
+- Support synapse dataset ([#2432](https://github.com/open-mmlab/mmsegmentation/pull/2432), [#2465](https://github.com/open-mmlab/mmsegmentation/pull/2465))
+- Support Mapillary Vistas Dataset in projects ([#2484](https://github.com/open-mmlab/mmsegmentation/pull/2484))
+- Switch order of `reduce_zero_label` and applying `label_map` ([#2517](https://github.com/open-mmlab/mmsegmentation/pull/2517))
+
+### Documentation
+
+- Add ZN Customized_runtime Doc ([#2502](https://github.com/open-mmlab/mmsegmentation/pull/2502))
+- Add EN datasets.md ([#2464](https://github.com/open-mmlab/mmsegmentation/pull/2464))
+- Fix minor typo in migration `package.md` ([#2518](https://github.com/open-mmlab/mmsegmentation/pull/2518))
+
+### Bug fix
+
+- Fix incorrect `img_shape` value assignment in RandomCrop ([#2469](https://github.com/open-mmlab/mmsegmentation/pull/2469))
+- Fix inference api and support setting palette to SegLocalVisualizer ([#2475](https://github.com/open-mmlab/mmsegmentation/pull/2475))
+- Unfinished label conversion from `-1` to `255` ([#2516](https://github.com/open-mmlab/mmsegmentation/pull/2516))
+
+### New Contributors
+
+- @blueyo0 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2373
+- @Fivethousand5k made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2406
+- @suyanzhou626 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2383
+- @unrealMJ made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2400
+- @Dominic23331 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2432
+- @AI-Tianlong made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2444
+- @morkovka1337 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2492
+- @Leeinsn made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2404
+- @siddancha made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2516
+
+## v1.0.0rc3(31/12/2022)
+
+### Highlights
+
+- Support test time augmentation ([#2184](https://github.com/open-mmlab/mmsegmentation/pull/2184))
+- Add 'Projects/' folder and the first example project ([#2412](https://github.com/open-mmlab/mmsegmentation/pull/2412))
+
+### Features
+
+- Add Biomedical 3D array random crop transform ([#2378](https://github.com/open-mmlab/mmsegmentation/pull/2378))
+
+### Documentation
+
+- Add Chinese version of config tutorial ([#2371](https://github.com/open-mmlab/mmsegmentation/pull/2371))
+- Add Chinese version of train & test tutorial  ([#2355](https://github.com/open-mmlab/mmsegmentation/pull/2355))
+- Add Chinese version of overview ([(#2397)](https://github.com/open-mmlab/mmsegmentation/pull/2397)))
+- Add Chinese version of get_started ([#2417](https://github.com/open-mmlab/mmsegmentation/pull/2417))
+- Add datasets in Chinese ([#2387](https://github.com/open-mmlab/mmsegmentation/pull/2387))
+- Add dataflow document ([#2403](https://github.com/open-mmlab/mmsegmentation/pull/2403))
+- Add pspnet model structure graph ([#2437](https://github.com/open-mmlab/mmsegmentation/pull/2437))
+- Update some content of engine Chinese documentation ([#2341](https://github.com/open-mmlab/mmsegmentation/pull/2341))
+- Update TTA to migration documentation ([#2335](https://github.com/open-mmlab/mmsegmentation/pull/2335))
+
+### Bug fix
+
+- Remove dependency mmdet when do not use MaskFormerHead and MMDET_Mask2FormerHead ([#2448](https://github.com/open-mmlab/mmsegmentation/pull/2448))
+
+### Enhancement
+
+- Add torch1.13 checking in CI ([#2402](https://github.com/open-mmlab/mmsegmentation/pull/2402))
+- Fix pytorch version for merge stage test  ([#2449](https://github.com/open-mmlab/mmsegmentation/pull/2449))
+
+## v1.0.0rc2(6/12/2022)
+
+### Highlights
+
+- Support MaskFormer ([#2215](https://github.com/open-mmlab/mmsegmentation/pull/2215))
+- Support Mask2Former ([#2255](https://github.com/open-mmlab/mmsegmentation/pull/2255))
+
+### Features
+
+- Add ResizeShortestEdge transform ([#2339](https://github.com/open-mmlab/mmsegmentation/pull/2339))
+- Support padding in data pre-processor for model testing([#2290](https://github.com/open-mmlab/mmsegmentation/pull/2290))
+- Fix the problem of post-processing not removing padding ([#2367](https://github.com/open-mmlab/mmsegmentation/pull/2367))
+
+### Bug fix
+
+- Fix links in README ([#2024](https://github.com/open-mmlab/mmsegmentation/pull/2024))
+- Fix swin load state_dict ([#2304](https://github.com/open-mmlab/mmsegmentation/pull/2304))
+- Fix typo of BaseSegDataset docstring ([#2322](https://github.com/open-mmlab/mmsegmentation/pull/2322))
+- Fix the bug in the visualization step ([#2326](https://github.com/open-mmlab/mmsegmentation/pull/2326))
+- Fix ignore class id from -1 to 255 in BaseSegDataset ([#2332](https://github.com/open-mmlab/mmsegmentation/pull/2332))
+- Fix KNet IterativeDecodeHead bug ([#2334](https://github.com/open-mmlab/mmsegmentation/pull/2334))
+- Add input argument for datasets ([#2379](https://github.com/open-mmlab/mmsegmentation/pull/2379))
+- Fix typo in warning on binary classification ([#2382](https://github.com/open-mmlab/mmsegmentation/pull/2382))
+
+### Enhancement
+
+- Fix ci for 1.x ([#2011](https://github.com/open-mmlab/mmsegmentation/pull/2011), [#2019](https://github.com/open-mmlab/mmsegmentation/pull/2019))
+- Fix lint and pre-commit hook ([#2308](https://github.com/open-mmlab/mmsegmentation/pull/2308))
+- Add `data` string in .gitignore file in dev-1.x branch ([#2336](https://github.com/open-mmlab/mmsegmentation/pull/2336))
+- Make scipy as a default dependency in runtime ([#2362](https://github.com/open-mmlab/mmsegmentation/pull/2362))
+- Delete mmcls in runtime.txt ([#2368](https://github.com/open-mmlab/mmsegmentation/pull/2368))
+
+### Documentation
+
+- Update configuration documentation ([#2048](https://github.com/open-mmlab/mmsegmentation/pull/2048))
+- Update inference documentation ([#2052](https://github.com/open-mmlab/mmsegmentation/pull/2052))
+- Update train test documentation ([#2061](https://github.com/open-mmlab/mmsegmentation/pull/2061))
+- Update get started documentatin ([#2148](https://github.com/open-mmlab/mmsegmentation/pull/2148))
+- Update transforms documentation ([#2088](https://github.com/open-mmlab/mmsegmentation/pull/2088))
+- Add MMEval projects like in README ([#2259](https://github.com/open-mmlab/mmsegmentation/pull/2259))
+- Translate the visualization.md ([#2298](https://github.com/open-mmlab/mmsegmentation/pull/2298))
+
+## v1.0.0rc1 (2/11/2022)
+
+### Highlights
+
+- Support PoolFormer ([#2191](https://github.com/open-mmlab/mmsegmentation/pull/2191))
+- Add Decathlon dataset ([#2227](https://github.com/open-mmlab/mmsegmentation/pull/2227))
+
+### Features
+
+- Add BioMedical data loading ([#2176](https://github.com/open-mmlab/mmsegmentation/pull/2176))
+- Add LIP dataset ([#2251](https://github.com/open-mmlab/mmsegmentation/pull/2251))
+- Add `GenerateEdge` data transform ([#2210](https://github.com/open-mmlab/mmsegmentation/pull/2210))
+
+### Bug fix
+
+- Fix segmenter-vit-s_fcn config ([#2037](https://github.com/open-mmlab/mmsegmentation/pull/2037))
+- Fix binary segmentation ([#2101](https://github.com/open-mmlab/mmsegmentation/pull/2101))
+- Fix MMSegmentation colab demo ([#2089](https://github.com/open-mmlab/mmsegmentation/pull/2089))
+- Fix ResizeToMultiple transform ([#2185](https://github.com/open-mmlab/mmsegmentation/pull/2185))
+- Use SyncBN in mobilenet_v2 ([#2198](https://github.com/open-mmlab/mmsegmentation/pull/2198))
+- Fix typo in installation ([#2175](https://github.com/open-mmlab/mmsegmentation/pull/2175))
+- Fix typo in visualization.md ([#2116](https://github.com/open-mmlab/mmsegmentation/pull/2116))
+
+### Enhancement
+
+- Add mim extras_requires in setup.py ([#2012](https://github.com/open-mmlab/mmsegmentation/pull/2012))
+- Fix CI ([#2029](https://github.com/open-mmlab/mmsegmentation/pull/2029))
+- Remove ops module ([#2063](https://github.com/open-mmlab/mmsegmentation/pull/2063))
+- Add pyupgrade pre-commit hook ([#2078](https://github.com/open-mmlab/mmsegmentation/pull/2078))
+- Add `out_file` in `add_datasample` of `SegLocalVisualizer` to directly save image ([#2090](https://github.com/open-mmlab/mmsegmentation/pull/2090))
+- Upgrade pre commit hooks ([#2154](https://github.com/open-mmlab/mmsegmentation/pull/2154))
+- Ignore test timm in CI when torch\<1.7 ([#2158](https://github.com/open-mmlab/mmsegmentation/pull/2158))
+- Update requirements ([#2186](https://github.com/open-mmlab/mmsegmentation/pull/2186))
+- Fix Windows platform CI ([#2202](https://github.com/open-mmlab/mmsegmentation/pull/2202))
+
+### Documentation
+
+- Add `Overview` documentation ([#2042](https://github.com/open-mmlab/mmsegmentation/pull/2042))
+- Add `Evaluation` documentation ([#2077](https://github.com/open-mmlab/mmsegmentation/pull/2077))
+- Add `Migration` documentation ([#2066](https://github.com/open-mmlab/mmsegmentation/pull/2066))
+- Add `Structures` documentation ([#2070](https://github.com/open-mmlab/mmsegmentation/pull/2070))
+- Add `Structures` ZN documentation ([#2129](https://github.com/open-mmlab/mmsegmentation/pull/2129))
+- Add `Engine` ZN documentation ([#2157](https://github.com/open-mmlab/mmsegmentation/pull/2157))
+- Update `Prepare datasets` and `Visualization` doc ([#2054](https://github.com/open-mmlab/mmsegmentation/pull/2054))
+- Update `Models` documentation ([#2160](https://github.com/open-mmlab/mmsegmentation/pull/2160))
+- Update `Add New Modules` documentation ([#2067](https://github.com/open-mmlab/mmsegmentation/pull/2067))
+- Fix the installation commands in get_started.md ([#2174](https://github.com/open-mmlab/mmsegmentation/pull/2174))
+- Add MMYOLO to README.md ([#2220](https://github.com/open-mmlab/mmsegmentation/pull/2220))
+
+## v1.0.0rc0 (31/8/2022)
+
+We are excited to announce the release of MMSegmentation 1.0.0rc0.
+MMSeg 1.0.0rc0 is the first version of MMSegmentation 1.x, a part of the OpenMMLab 2.0 projects.
+Built upon the new [training engine](https://github.com/open-mmlab/mmengine),
+MMSeg 1.x unifies the interfaces of dataset, models, evaluation, and visualization with faster training and testing speed.
+
+### Highlights
+
+1. **New engines** MMSeg 1.x is based on [MMEngine](https://github.com/open-mmlab/mmengine), which provides a general and powerful runner that allows more flexible customizations and significantly simplifies the entrypoints of high-level interfaces.
+
+2. **Unified interfaces** As a part of the OpenMMLab 2.0 projects, MMSeg 1.x unifies and refactors the interfaces and internal logics of train, testing, datasets, models, evaluation, and visualization. All the OpenMMLab 2.0 projects share the same design in those interfaces and logics to allow the emergence of multi-task/modality algorithms.
+
+3. **Faster speed** We optimize the training and inference speed for common models.
+
+4. **New features**:
+
+   - Support TverskyLoss function
+
+5. **More documentation and tutorials**. We add a bunch of documentation and tutorials to help users get started more smoothly. Read it [here](https://mmsegmentation.readthedocs.io/en/1.x/).
+
+### Breaking Changes
+
+We briefly list the major breaking changes here.
+We will update the [migration guide](../migration.md) to provide complete details and migration instructions.
+
+#### Training and testing
+
+- MMSeg 1.x runs on PyTorch>=1.6. We have deprecated the support of PyTorch 1.5 to embrace the mixed precision training and other new features since PyTorch 1.6. Some models can still run on PyTorch 1.5, but the full functionality of MMSeg 1.x is not guaranteed.
+
+- MMSeg 1.x uses Runner in [MMEngine](https://github.com/open-mmlab/mmengine) rather than that in MMCV. The new Runner implements and unifies the building logic of dataset, model, evaluation, and visualizer. Therefore, MMSeg 1.x no longer maintains the building logics of those modules in `mmseg.train.apis` and `tools/train.py`. Those code have been migrated into [MMEngine](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py). Please refer to the [migration guide of Runner in MMEngine](https://mmengine.readthedocs.io/en/latest/migration/runner.html) for more details.
+
+- The Runner in MMEngine also supports testing and validation. The testing scripts are also simplified, which has similar logic as that in training scripts to build the runner.
+
+- The execution points of hooks in the new Runner have been enriched to allow more flexible customization. Please refer to the [migration guide of Hook in MMEngine](https://mmengine.readthedocs.io/en/latest/migration/hook.html) for more details.
+
+- Learning rate and momentum scheduling has been migrated from `Hook` to `Parameter Scheduler` in MMEngine. Please refer to the [migration guide of Parameter Scheduler in MMEngine](https://mmengine.readthedocs.io/en/latest/migration/param_scheduler.html) for more details.
+
+#### Configs
+
+- The [Runner in MMEngine](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py) uses a different config structures to ease the understanding of the components in runner. Users can read the [config example of mmseg](../user_guides/config.md) or refer to the [migration guide in MMEngine](https://mmengine.readthedocs.io/en/latest/migration/runner.html) for migration details.
+- The file names of configs and models are also refactored to follow the new rules unified across OpenMMLab 2.0 projects. Please refer to the [user guides of config](../user_guides/1_config.md) for more details.
+
+#### Components
+
+- Dataset
+- Data Transforms
+- Model
+- Evaluation
+- Visualization
+
+### Improvements
+
+- Support mixed precision training of all the models. However, some models may got Nan results due to some numerical issues. We will update the documentation and list their results (accuracy of failure) of mixed precision training.
+
+### Bug Fixes
+
+- Fix several config file errors [#1994](https://github.com/open-mmlab/mmsegmentation/pull/1994)
+
+### New Features
+
+1. Support data structures and encapsulating `seg_logits` in data samples, which can be return from models to support more common evaluation metrics.
+
+### Ongoing changes
+
+1. Test-time augmentation: which is supported in MMSeg 0.x is not implemented in this version due to limited time slot. We will support it in the following releases with a new and simplified design.
+
+2. Inference interfaces: a unified inference interfaces will be supported in the future to ease the use of released models.
+
+3. Interfaces of useful tools that can be used in notebook: more useful tools that implemented in the `tools` directory will have their python interfaces so that they can be used through notebook and in downstream libraries.
+
+4. Documentation: we will add more design docs, tutorials, and migration guidance so that the community can deep dive into our new design, participate the future development, and smoothly migrate downstream libraries to MMSeg 1.x.
diff --git a/mmsegmentation/docs/en/notes/changelog_v0.x.md b/mmsegmentation/docs/en/notes/changelog_v0.x.md
new file mode 100644
index 0000000..d347a44
--- /dev/null
+++ b/mmsegmentation/docs/en/notes/changelog_v0.x.md
@@ -0,0 +1,720 @@
+## Changelog
+
+### V0.24.1 (5/1/2022)
+
+**Bug Fixes**
+
+- Fix `LayerDecayOptimizerConstructor` for MAE training ([#1539](https://github.com/open-mmlab/mmsegmentation/pull/1539), [#1540](https://github.com/open-mmlab/mmsegmentation/pull/1540))
+
+### V0.24.0 (4/29/2022)
+
+**Highlights**
+
+- Support MAE: Masked Autoencoders Are Scalable Vision Learners
+- Support Resnet strikes back
+
+**New Features**
+
+- Support MAE: Masked Autoencoders Are Scalable Vision Learners ([#1307](https://github.com/open-mmlab/mmsegmentation/pull/1307), [#1523](https://github.com/open-mmlab/mmsegmentation/pull/1523))
+- Support Resnet strikes back ([#1390](https://github.com/open-mmlab/mmsegmentation/pull/1390))
+- Support extra dataloader settings in configs ([#1435](https://github.com/open-mmlab/mmsegmentation/pull/1435))
+
+**Bug Fixes**
+
+- Fix input previous results for the last cascade_decode_head ([#1450](https://github.com/open-mmlab/mmsegmentation/pull/1450))
+- Fix validation loss logging ([#1494](https://github.com/open-mmlab/mmsegmentation/pull/1494))
+- Fix the bug in binary_cross_entropy ([1527](https://github.com/open-mmlab/mmsegmentation/pull/1527))
+- Support single channel prediction for Binary Cross Entropy Loss ([#1454](https://github.com/open-mmlab/mmsegmentation/pull/1454))
+- Fix potential bugs in accuracy.py ([1496](https://github.com/open-mmlab/mmsegmentation/pull/1496))
+- Avoid converting label ids twice by label map during evaluation ([1417](https://github.com/open-mmlab/mmsegmentation/pull/1417))
+- Fix bug about label_map ([1445](https://github.com/open-mmlab/mmsegmentation/pull/1445))
+- Fix image save path bug in Windows ([1423](https://github.com/open-mmlab/mmsegmentation/pull/1423))
+- Fix MMSegmentation Colab demo ([1501](https://github.com/open-mmlab/mmsegmentation/pull/1501), [1452](https://github.com/open-mmlab/mmsegmentation/pull/1452))
+- Migrate azure blob for beit checkpoints ([1503](https://github.com/open-mmlab/mmsegmentation/pull/1503))
+- Fix bug in `tools/analyse_logs.py` caused by wrong plot_iter in some cases ([1428](https://github.com/open-mmlab/mmsegmentation/pull/1428))
+
+**Improvements**
+
+- Merge BEiT and ConvNext's LR decay optimizer constructors ([#1438](https://github.com/open-mmlab/mmsegmentation/pull/1438))
+- Register optimizer constructor with mmseg ([#1456](https://github.com/open-mmlab/mmsegmentation/pull/1456))
+- Refactor transformer encode layer in ViT and BEiT backbone ([#1481](https://github.com/open-mmlab/mmsegmentation/pull/1481))
+- Add `build_pos_embed` and `build_layers` for BEiT ([1517](https://github.com/open-mmlab/mmsegmentation/pull/1517))
+- Add `with_cp` to mit and vit ([1431](https://github.com/open-mmlab/mmsegmentation/pull/1431))
+- Fix inconsistent dtype of `seg_label` in stdc decode ([1463](https://github.com/open-mmlab/mmsegmentation/pull/1463))
+- Delete random seed for training in `dist_train.sh` ([1519](https://github.com/open-mmlab/mmsegmentation/pull/1519))
+- Revise high `workers_per_gpus` in config file ([#1506](https://github.com/open-mmlab/mmsegmentation/pull/1506))
+- Add GPG keys and del mmcv version in Dockerfile ([1534](https://github.com/open-mmlab/mmsegmentation/pull/1534))
+- Update checkpoint for model in deeplabv3plus ([#1487](https://github.com/open-mmlab/mmsegmentation/pull/1487))
+- Add `DistSamplerSeedHook` to set epoch number to dataloader when runner is `EpochBasedRunner` ([1449](https://github.com/open-mmlab/mmsegmentation/pull/1449))
+- Provide URLs of Swin Transformer pretrained models ([1389](https://github.com/open-mmlab/mmsegmentation/pull/1389))
+- Updating Dockerfiles From Docker Directory and `get_started.md` to reach latest stable version of Python, PyTorch and MMCV ([1446](https://github.com/open-mmlab/mmsegmentation/pull/1446))
+
+**Documentation**
+
+- Add more clearly statement of CPU training/inference ([1518](https://github.com/open-mmlab/mmsegmentation/pull/1518))
+
+**Contributors**
+
+- @jiangyitong made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1431
+- @kahkeng made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1447
+- @Nourollah made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1446
+- @androbaza made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1452
+- @Yzichen made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1445
+- @whu-pzhang made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1423
+- @panfeng-hover made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1417
+- @Johnson-Wang made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1496
+- @jere357 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1460
+- @mfernezir made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1494
+- @donglixp made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1503
+- @YuanLiuuuuuu made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1307
+- @Dawn-bin made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1527
+
+### V0.23.0 (4/1/2022)
+
+**Highlights**
+
+- Support BEiT: BERT Pre-Training of Image Transformers
+- Support K-Net: Towards Unified Image Segmentation
+- Add `avg_non_ignore` of CELoss to support average loss over non-ignored elements
+- Support dataset initialization with file client
+
+**New Features**
+
+- Support BEiT: BERT Pre-Training of Image Transformers ([#1404](https://github.com/open-mmlab/mmsegmentation/pull/1404))
+- Support K-Net: Towards Unified Image Segmentation ([#1289](https://github.com/open-mmlab/mmsegmentation/pull/1289))
+- Support dataset initialization with file client ([#1402](https://github.com/open-mmlab/mmsegmentation/pull/1402))
+- Add class name function for STARE datasets ([#1376](https://github.com/open-mmlab/mmsegmentation/pull/1376))
+- Support different seeds on different ranks when distributed training ([#1362](https://github.com/open-mmlab/mmsegmentation/pull/1362))
+- Add `nlc2nchw2nlc` and `nchw2nlc2nchw` to simplify tensor with different dimension operation ([#1249](https://github.com/open-mmlab/mmsegmentation/pull/1249))
+
+**Improvements**
+
+- Synchronize random seed for distributed sampler ([#1411](https://github.com/open-mmlab/mmsegmentation/pull/1411))
+- Add script and documentation for multi-machine distributed training ([#1383](https://github.com/open-mmlab/mmsegmentation/pull/1383))
+
+**Bug Fixes**
+
+- Add `avg_non_ignore` of CELoss to support average loss over non-ignored elements ([#1409](https://github.com/open-mmlab/mmsegmentation/pull/1409))
+- Fix some wrong URLs of models or logs in `./configs` ([#1336](https://github.com/open-mmlab/mmsegmentation/pull/1433))
+- Add title and color theme arguments to plot function in `tools/confusion_matrix.py` ([#1401](https://github.com/open-mmlab/mmsegmentation/pull/1401))
+- Fix outdated link in Colab demo ([#1392](https://github.com/open-mmlab/mmsegmentation/pull/1392))
+- Fix typos ([#1424](https://github.com/open-mmlab/mmsegmentation/pull/1424), [#1405](https://github.com/open-mmlab/mmsegmentation/pull/1405), [#1371](https://github.com/open-mmlab/mmsegmentation/pull/1371), [#1366](https://github.com/open-mmlab/mmsegmentation/pull/1366), [#1363](https://github.com/open-mmlab/mmsegmentation/pull/1363))
+
+**Documentation**
+
+- Add FAQ document ([#1420](https://github.com/open-mmlab/mmsegmentation/pull/1420))
+- Fix the config name style description in official docs([#1414](https://github.com/open-mmlab/mmsegmentation/pull/1414))
+
+**Contributors**
+
+- @kinglintianxia made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1371
+- @CCODING04 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1376
+- @mob5566 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1401
+- @xiongnemo made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1392
+- @Xiangxu-0103 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1405
+
+### V0.22.1 (3/9/2022)
+
+**Bug Fixes**
+
+- Fix the ZeroDivisionError that all pixels in one image is ignored. ([#1336](https://github.com/open-mmlab/mmsegmentation/pull/1336))
+
+**Improvements**
+
+- Provide URLs of STDC, Segmenter and Twins pretrained models ([#1272](https://github.com/open-mmlab/mmsegmentation/pull/1357))
+
+### V0.22 (3/04/2022)
+
+**Highlights**
+
+- Support ConvNeXt: A ConvNet for the 2020s. Please use the latest MMClassification (0.21.0) to try it out.
+- Support iSAID aerial Dataset.
+- Officially Support inference on Windows OS.
+
+**New Features**
+
+- Support ConvNeXt: A ConvNet for the 2020s. ([#1216](https://github.com/open-mmlab/mmsegmentation/pull/1216))
+- Support iSAID aerial Dataset. ([#1115](https://github.com/open-mmlab/mmsegmentation/pull/1115)
+- Generating and plotting confusion matrix. ([#1301](https://github.com/open-mmlab/mmsegmentation/pull/1301))
+
+**Improvements**
+
+- Refactor 4 decoder heads (ASPP, FCN, PSP, UPer): Split forward function into `_forward_feature` and `cls_seg`. ([#1299](https://github.com/open-mmlab/mmsegmentation/pull/1299))
+- Add `min_size` arg in `Resize` to keep the shape after resize bigger than slide window. ([#1318](https://github.com/open-mmlab/mmsegmentation/pull/1318))
+- Revise pre-commit-hooks. ([#1315](https://github.com/open-mmlab/mmsegmentation/pull/1315))
+- Add win-ci. ([#1296](https://github.com/open-mmlab/mmsegmentation/pull/1296))
+
+**Bug Fixes**
+
+- Fix `mlp_ratio` type in Swin Transformer. ([#1274](https://github.com/open-mmlab/mmsegmentation/pull/1274))
+- Fix path errors in `./demo` . ([#1269](https://github.com/open-mmlab/mmsegmentation/pull/1269))
+- Fix bug in conversion of potsdam. ([#1279](https://github.com/open-mmlab/mmsegmentation/pull/1279))
+- Make accuracy take into account `ignore_index`. ([#1259](https://github.com/open-mmlab/mmsegmentation/pull/1259))
+- Add Pytorch HardSwish assertion in unit test. ([#1294](https://github.com/open-mmlab/mmsegmentation/pull/1294))
+- Fix wrong palette value in vaihingen. ([#1292](https://github.com/open-mmlab/mmsegmentation/pull/1292))
+- Fix the bug that SETR cannot load pretrain. ([#1293](https://github.com/open-mmlab/mmsegmentation/pull/1293))
+- Update correct `In Collection` in metafile of each configs. ([#1239](https://github.com/open-mmlab/mmsegmentation/pull/1239))
+- Upload completed STDC models. ([#1332](https://github.com/open-mmlab/mmsegmentation/pull/1332))
+- Fix `DNLHead` exports onnx inference difference type Cast error. ([#1161](https://github.com/open-mmlab/mmsegmentation/pull/1332))
+
+**Contributors**
+
+- @JiaYanhao made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1269
+- @andife made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1281
+- @SBCV made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1279
+- @HJoonKwon made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1259
+- @Tsingularity made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1290
+- @Waterman0524 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1115
+- @MeowZheng made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1315
+- @linfangjian01 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1318
+
+### V0.21.1 (2/9/2022)
+
+**Bug Fixes**
+
+- Fix typos in docs. ([#1263](https://github.com/open-mmlab/mmsegmentation/pull/1263))
+- Fix repeating log by `setup_multi_processes`. ([#1267](https://github.com/open-mmlab/mmsegmentation/pull/1267))
+- Upgrade isort in pre-commit hook. ([#1270](https://github.com/open-mmlab/mmsegmentation/pull/1270))
+
+**Improvements**
+
+- Use MMCV load_state_dict func in ViT/Swin. ([#1272](https://github.com/open-mmlab/mmsegmentation/pull/1272))
+- Add exception for PointRend for support CPU-only. ([#1271](https://github.com/open-mmlab/mmsegmentation/pull/1270))
+
+### V0.21 (1/29/2022)
+
+**Highlights**
+
+- Officially Support CPUs training and inference, please use the latest MMCV (1.4.4) to try it out.
+- Support Segmenter: Transformer for Semantic Segmentation (ICCV'2021).
+- Support ISPRS Potsdam and Vaihingen Dataset.
+- Add Mosaic transform and `MultiImageMixDataset` class in `dataset_wrappers`.
+
+**New Features**
+
+- Support Segmenter: Transformer for Semantic Segmentation (ICCV'2021) ([#955](https://github.com/open-mmlab/mmsegmentation/pull/955))
+- Support ISPRS Potsdam and Vaihingen Dataset ([#1097](https://github.com/open-mmlab/mmsegmentation/pull/1097), [#1171](https://github.com/open-mmlab/mmsegmentation/pull/1171))
+- Add segformer‘s benchmark on cityscapes ([#1155](https://github.com/open-mmlab/mmsegmentation/pull/1155))
+- Add auto resume ([#1172](https://github.com/open-mmlab/mmsegmentation/pull/1172))
+- Add Mosaic transform and `MultiImageMixDataset` class in `dataset_wrappers` ([#1093](https://github.com/open-mmlab/mmsegmentation/pull/1093), [#1105](https://github.com/open-mmlab/mmsegmentation/pull/1105))
+- Add log collector ([#1175](https://github.com/open-mmlab/mmsegmentation/pull/1175))
+
+**Improvements**
+
+- New-style CPU training and inference ([#1251](https://github.com/open-mmlab/mmsegmentation/pull/1251))
+- Add UNet benchmark with multiple losses supervision ([#1143](https://github.com/open-mmlab/mmsegmentation/pull/1143))
+
+**Bug Fixes**
+
+- Fix the model statistics in doc for readthedoc ([#1153](https://github.com/open-mmlab/mmsegmentation/pull/1153))
+- Set random seed for `palette` if not given ([#1152](https://github.com/open-mmlab/mmsegmentation/pull/1152))
+- Add `COCOStuffDataset` in `class_names.py` ([#1222](https://github.com/open-mmlab/mmsegmentation/pull/1222))
+- Fix bug in non-distributed multi-gpu training/testing ([#1247](https://github.com/open-mmlab/mmsegmentation/pull/1247))
+- Delete unnecessary lines of STDCHead ([#1231](https://github.com/open-mmlab/mmsegmentation/pull/1231))
+
+**Contributors**
+
+- @jbwang1997 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1152
+- @BeaverCC made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1206
+- @Echo-minn made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1214
+- @rstrudel made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/955
+
+### V0.20.2 (12/15/2021)
+
+**Bug Fixes**
+
+- Revise --option to --options to avoid BC-breaking. ([#1140](https://github.com/open-mmlab/mmsegmentation/pull/1140))
+
+### V0.20.1 (12/14/2021)
+
+**Improvements**
+
+- Change options to cfg-options ([#1129](https://github.com/open-mmlab/mmsegmentation/pull/1129))
+
+**Bug Fixes**
+
+- Fix `<!-- [ABSTRACT] -->` in metafile. ([#1127](https://github.com/open-mmlab/mmsegmentation/pull/1127))
+- Fix correct `num_classes` of HRNet in `LoveDA` dataset ([#1136](https://github.com/open-mmlab/mmsegmentation/pull/1136))
+
+### V0.20 (12/10/2021)
+
+**Highlights**
+
+- Support Twins ([#989](https://github.com/open-mmlab/mmsegmentation/pull/989))
+- Support a real-time segmentation model STDC ([#995](https://github.com/open-mmlab/mmsegmentation/pull/995))
+- Support a widely-used segmentation model in lane detection ERFNet ([#960](https://github.com/open-mmlab/mmsegmentation/pull/960))
+- Support A Remote Sensing Land-Cover Dataset LoveDA ([#1028](https://github.com/open-mmlab/mmsegmentation/pull/1028))
+- Support focal loss ([#1024](https://github.com/open-mmlab/mmsegmentation/pull/1024))
+
+**New Features**
+
+- Support Twins ([#989](https://github.com/open-mmlab/mmsegmentation/pull/989))
+- Support a real-time segmentation model STDC ([#995](https://github.com/open-mmlab/mmsegmentation/pull/995))
+- Support a widely-used segmentation model in lane detection ERFNet ([#960](https://github.com/open-mmlab/mmsegmentation/pull/960))
+- Add SETR cityscapes benchmark ([#1087](https://github.com/open-mmlab/mmsegmentation/pull/1087))
+- Add BiSeNetV1 COCO-Stuff 164k benchmark ([#1019](https://github.com/open-mmlab/mmsegmentation/pull/1019))
+- Support focal loss ([#1024](https://github.com/open-mmlab/mmsegmentation/pull/1024))
+- Add Cutout transform ([#1022](https://github.com/open-mmlab/mmsegmentation/pull/1022))
+
+**Improvements**
+
+- Set a random seed when the user does not set a seed ([#1039](https://github.com/open-mmlab/mmsegmentation/pull/1039))
+- Add CircleCI setup ([#1086](https://github.com/open-mmlab/mmsegmentation/pull/1086))
+- Skip CI on ignoring given paths ([#1078](https://github.com/open-mmlab/mmsegmentation/pull/1078))
+- Add abstract and image for every paper ([#1060](https://github.com/open-mmlab/mmsegmentation/pull/1060))
+- Create a symbolic link on windows ([#1090](https://github.com/open-mmlab/mmsegmentation/pull/1090))
+- Support video demo using trained model ([#1014](https://github.com/open-mmlab/mmsegmentation/pull/1014))
+
+**Bug Fixes**
+
+- Fix incorrectly loading init_cfg or pretrained models of several transformer models ([#999](https://github.com/open-mmlab/mmsegmentation/pull/999), [#1069](https://github.com/open-mmlab/mmsegmentation/pull/1069), [#1102](https://github.com/open-mmlab/mmsegmentation/pull/1102))
+- Fix EfficientMultiheadAttention in SegFormer ([#1037](https://github.com/open-mmlab/mmsegmentation/pull/1037))
+- Remove `fp16` folder in `configs` ([#1031](https://github.com/open-mmlab/mmsegmentation/pull/1031))
+- Fix several typos in .yml file (Dice Metric [#1041](https://github.com/open-mmlab/mmsegmentation/pull/1041), ADE20K dataset [#1120](https://github.com/open-mmlab/mmsegmentation/pull/1120), Training Memory (GB) [#1083](https://github.com/open-mmlab/mmsegmentation/pull/1083))
+- Fix test error when using `--show-dir` ([#1091](https://github.com/open-mmlab/mmsegmentation/pull/1091))
+- Fix dist training infinite waiting issue ([#1035](https://github.com/open-mmlab/mmsegmentation/pull/1035))
+- Change the upper version of mmcv to 1.5.0 ([#1096](https://github.com/open-mmlab/mmsegmentation/pull/1096))
+- Fix symlink failure on Windows ([#1038](https://github.com/open-mmlab/mmsegmentation/pull/1038))
+- Cancel previous runs that are not completed ([#1118](https://github.com/open-mmlab/mmsegmentation/pull/1118))
+- Unified links of readthedocs in docs ([#1119](https://github.com/open-mmlab/mmsegmentation/pull/1119))
+
+**Contributors**
+
+- @Junjue-Wang made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1028
+- @ddebby made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1066
+- @del-zhenwu made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1078
+- @KangBK0120 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1106
+- @zergzzlun made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1091
+- @fingertap made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1035
+- @irvingzhang0512 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1014
+- @littleSunlxy made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/989
+- @lkm2835
+- @RockeyCoss
+- @MengzhangLI
+- @Junjun2016
+- @xiexinch
+- @xvjiarui
+
+### V0.19 (11/02/2021)
+
+**Highlights**
+
+- Support TIMMBackbone wrapper ([#998](https://github.com/open-mmlab/mmsegmentation/pull/998))
+- Support custom hook ([#428](https://github.com/open-mmlab/mmsegmentation/pull/428))
+- Add codespell pre-commit hook ([#920](https://github.com/open-mmlab/mmsegmentation/pull/920))
+- Add FastFCN benchmark on ADE20K ([#972](https://github.com/open-mmlab/mmsegmentation/pull/972))
+
+**New Features**
+
+- Support TIMMBackbone wrapper ([#998](https://github.com/open-mmlab/mmsegmentation/pull/998))
+- Support custom hook ([#428](https://github.com/open-mmlab/mmsegmentation/pull/428))
+- Add FastFCN benchmark on ADE20K ([#972](https://github.com/open-mmlab/mmsegmentation/pull/972))
+- Add codespell pre-commit hook and fix typos ([#920](https://github.com/open-mmlab/mmsegmentation/pull/920))
+
+**Improvements**
+
+- Make inputs & channels smaller in unittests ([#1004](https://github.com/open-mmlab/mmsegmentation/pull/1004))
+- Change `self.loss_decode` back to `dict` in Single Loss situation ([#1002](https://github.com/open-mmlab/mmsegmentation/pull/1002))
+
+**Bug Fixes**
+
+- Fix typo in usage example ([#1003](https://github.com/open-mmlab/mmsegmentation/pull/1003))
+- Add contiguous after permutation in ViT ([#992](https://github.com/open-mmlab/mmsegmentation/pull/992))
+- Fix the invalid link ([#985](https://github.com/open-mmlab/mmsegmentation/pull/985))
+- Fix bug in CI with python 3.9 ([#994](https://github.com/open-mmlab/mmsegmentation/pull/994))
+- Fix bug when loading class name form file in custom dataset ([#923](https://github.com/open-mmlab/mmsegmentation/pull/923))
+
+**Contributors**
+
+- @ShoupingShan made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/923
+- @RockeyCoss made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/954
+- @HarborYuan made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/992
+- @lkm2835 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1003
+- @gszh made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/428
+- @VVsssssk
+- @MengzhangLI
+- @Junjun2016
+
+### V0.18 (10/07/2021)
+
+**Highlights**
+
+- Support three real-time segmentation models (ICNet [#884](https://github.com/open-mmlab/mmsegmentation/pull/884), BiSeNetV1 [#851](https://github.com/open-mmlab/mmsegmentation/pull/851), and BiSeNetV2 [#804](https://github.com/open-mmlab/mmsegmentation/pull/804))
+- Support one efficient segmentation model (FastFCN [#885](https://github.com/open-mmlab/mmsegmentation/pull/885))
+- Support one efficient non-local/self-attention based segmentation model (ISANet [#70](https://github.com/open-mmlab/mmsegmentation/pull/70))
+- Support COCO-Stuff 10k and 164k datasets ([#625](https://github.com/open-mmlab/mmsegmentation/pull/625))
+- Support evaluate concated dataset separately ([#833](https://github.com/open-mmlab/mmsegmentation/pull/833))
+- Support loading GT for evaluation from multi-file backend ([#867](https://github.com/open-mmlab/mmsegmentation/pull/867))
+
+**New Features**
+
+- Support three real-time segmentation models (ICNet [#884](https://github.com/open-mmlab/mmsegmentation/pull/884), BiSeNetV1 [#851](https://github.com/open-mmlab/mmsegmentation/pull/851), and BiSeNetV2 [#804](https://github.com/open-mmlab/mmsegmentation/pull/804))
+- Support one efficient segmentation model (FastFCN [#885](https://github.com/open-mmlab/mmsegmentation/pull/885))
+- Support one efficient non-local/self-attention based segmentation model (ISANet [#70](https://github.com/open-mmlab/mmsegmentation/pull/70))
+- Support COCO-Stuff 10k and 164k datasets ([#625](https://github.com/open-mmlab/mmsegmentation/pull/625))
+- Support evaluate concated dataset separately ([#833](https://github.com/open-mmlab/mmsegmentation/pull/833))
+
+**Improvements**
+
+- Support loading GT for evaluation from multi-file backend ([#867](https://github.com/open-mmlab/mmsegmentation/pull/867))
+- Auto-convert SyncBN to BN when training on DP automatly([#772](https://github.com/open-mmlab/mmsegmentation/pull/772))
+- Refactor Swin-Transformer ([#800](https://github.com/open-mmlab/mmsegmentation/pull/800))
+
+**Bug Fixes**
+
+- Update mmcv installation in dockerfile ([#860](https://github.com/open-mmlab/mmsegmentation/pull/860))
+- Fix number of iteration bug when resuming checkpoint in distributed train ([#866](https://github.com/open-mmlab/mmsegmentation/pull/866))
+- Fix parsing parse in val_step ([#906](https://github.com/open-mmlab/mmsegmentation/pull/906))
+
+### V0.17 (09/01/2021)
+
+**Highlights**
+
+- Support SegFormer
+- Support DPT
+- Support Dark Zurich and Nighttime Driving datasets
+- Support progressive evaluation
+
+**New Features**
+
+- Support SegFormer ([#599](https://github.com/open-mmlab/mmsegmentation/pull/599))
+- Support DPT ([#605](https://github.com/open-mmlab/mmsegmentation/pull/605))
+- Support Dark Zurich and Nighttime Driving datasets ([#815](https://github.com/open-mmlab/mmsegmentation/pull/815))
+- Support progressive evaluation ([#709](https://github.com/open-mmlab/mmsegmentation/pull/709))
+
+**Improvements**
+
+- Add multiscale_output interface and unittests for HRNet ([#830](https://github.com/open-mmlab/mmsegmentation/pull/830))
+- Support inherit cityscapes dataset ([#750](https://github.com/open-mmlab/mmsegmentation/pull/750))
+- Fix some typos in README.md ([#824](https://github.com/open-mmlab/mmsegmentation/pull/824))
+- Delete convert function and add instruction to ViT/Swin README.md ([#791](https://github.com/open-mmlab/mmsegmentation/pull/791))
+- Add vit/swin/mit convert weight scripts ([#783](https://github.com/open-mmlab/mmsegmentation/pull/783))
+- Add copyright files ([#796](https://github.com/open-mmlab/mmsegmentation/pull/796))
+
+**Bug Fixes**
+
+- Fix invalid checkpoint link in inference_demo.ipynb ([#814](https://github.com/open-mmlab/mmsegmentation/pull/814))
+- Ensure that items in dataset have the same order across multi machine ([#780](https://github.com/open-mmlab/mmsegmentation/pull/780))
+- Fix the log error ([#766](https://github.com/open-mmlab/mmsegmentation/pull/766))
+
+### V0.16 (08/04/2021)
+
+**Highlights**
+
+- Support PyTorch 1.9
+- Support SegFormer backbone MiT
+- Support md2yml pre-commit hook
+- Support frozen stage for HRNet
+
+**New Features**
+
+- Support SegFormer backbone MiT ([#594](https://github.com/open-mmlab/mmsegmentation/pull/594))
+- Support md2yml pre-commit hook ([#732](https://github.com/open-mmlab/mmsegmentation/pull/732))
+- Support mim ([#717](https://github.com/open-mmlab/mmsegmentation/pull/717))
+- Add mmseg2torchserve tool ([#552](https://github.com/open-mmlab/mmsegmentation/pull/552))
+
+**Improvements**
+
+- Support hrnet frozen stage ([#743](https://github.com/open-mmlab/mmsegmentation/pull/743))
+- Add template of reimplementation questions ([#741](https://github.com/open-mmlab/mmsegmentation/pull/741))
+- Output pdf and epub formats for readthedocs ([#742](https://github.com/open-mmlab/mmsegmentation/pull/742))
+- Refine the docstring of ResNet ([#723](https://github.com/open-mmlab/mmsegmentation/pull/723))
+- Replace interpolate with resize ([#731](https://github.com/open-mmlab/mmsegmentation/pull/731))
+- Update resource limit ([#700](https://github.com/open-mmlab/mmsegmentation/pull/700))
+- Update config.md ([#678](https://github.com/open-mmlab/mmsegmentation/pull/678))
+
+**Bug Fixes**
+
+- Fix ATTENTION registry ([#729](https://github.com/open-mmlab/mmsegmentation/pull/729))
+- Fix analyze log script ([#716](https://github.com/open-mmlab/mmsegmentation/pull/716))
+- Fix doc api display ([#725](https://github.com/open-mmlab/mmsegmentation/pull/725))
+- Fix patch_embed and pos_embed mismatch error ([#685](https://github.com/open-mmlab/mmsegmentation/pull/685))
+- Fix efficient test for multi-node ([#707](https://github.com/open-mmlab/mmsegmentation/pull/707))
+- Fix init_cfg in resnet backbone ([#697](https://github.com/open-mmlab/mmsegmentation/pull/697))
+- Fix efficient test bug ([#702](https://github.com/open-mmlab/mmsegmentation/pull/702))
+- Fix url error in config docs ([#680](https://github.com/open-mmlab/mmsegmentation/pull/680))
+- Fix mmcv installation ([#676](https://github.com/open-mmlab/mmsegmentation/pull/676))
+- Fix torch version ([#670](https://github.com/open-mmlab/mmsegmentation/pull/670))
+
+**Contributors**
+
+@sshuair @xiexinch @Junjun2016 @mmeendez8 @xvjiarui @sennnnn @puhsu @BIGWangYuDong @keke1u @daavoo
+
+### V0.15 (07/04/2021)
+
+**Highlights**
+
+- Support ViT, SETR, and Swin-Transformer
+- Add Chinese documentation
+- Unified parameter initialization
+
+**Bug Fixes**
+
+- Fix typo and links ([#608](https://github.com/open-mmlab/mmsegmentation/pull/608))
+- Fix Dockerfile ([#607](https://github.com/open-mmlab/mmsegmentation/pull/607))
+- Fix ViT init ([#609](https://github.com/open-mmlab/mmsegmentation/pull/609))
+- Fix mmcv version compatible table ([#658](https://github.com/open-mmlab/mmsegmentation/pull/658))
+- Fix model links of DMNEt ([#660](https://github.com/open-mmlab/mmsegmentation/pull/660))
+
+**New Features**
+
+- Support loading DeiT weights ([#538](https://github.com/open-mmlab/mmsegmentation/pull/538))
+- Support SETR ([#531](https://github.com/open-mmlab/mmsegmentation/pull/531), [#635](https://github.com/open-mmlab/mmsegmentation/pull/635))
+- Add config and models for ViT backbone with UperHead ([#520](https://github.com/open-mmlab/mmsegmentation/pull/531), [#635](https://github.com/open-mmlab/mmsegmentation/pull/520))
+- Support Swin-Transformer ([#511](https://github.com/open-mmlab/mmsegmentation/pull/511))
+- Add higher accuracy FastSCNN ([#606](https://github.com/open-mmlab/mmsegmentation/pull/606))
+- Add Chinese documentation ([#666](https://github.com/open-mmlab/mmsegmentation/pull/666))
+
+**Improvements**
+
+- Unified parameter initialization ([#567](https://github.com/open-mmlab/mmsegmentation/pull/567))
+- Separate CUDA and CPU in  github action CI ([#602](https://github.com/open-mmlab/mmsegmentation/pull/602))
+- Support persistent dataloader worker ([#646](https://github.com/open-mmlab/mmsegmentation/pull/646))
+- Update meta file fields ([#661](https://github.com/open-mmlab/mmsegmentation/pull/661), [#664](https://github.com/open-mmlab/mmsegmentation/pull/664))
+
+### V0.14 (06/02/2021)
+
+**Highlights**
+
+- Support ONNX to TensorRT
+- Support MIM
+
+**Bug Fixes**
+
+- Fix ONNX to TensorRT verify ([#547](https://github.com/open-mmlab/mmsegmentation/pull/547))
+- Fix save best for EvalHook ([#575](https://github.com/open-mmlab/mmsegmentation/pull/575))
+
+**New Features**
+
+- Support loading DeiT weights ([#538](https://github.com/open-mmlab/mmsegmentation/pull/538))
+- Support ONNX to TensorRT ([#542](https://github.com/open-mmlab/mmsegmentation/pull/542))
+- Support output results for ADE20k ([#544](https://github.com/open-mmlab/mmsegmentation/pull/544))
+- Support MIM ([#549](https://github.com/open-mmlab/mmsegmentation/pull/549))
+
+**Improvements**
+
+- Add option for ViT output shape ([#530](https://github.com/open-mmlab/mmsegmentation/pull/530))
+- Infer batch size using len(result) ([#532](https://github.com/open-mmlab/mmsegmentation/pull/532))
+- Add compatible table between MMSeg and MMCV ([#558](https://github.com/open-mmlab/mmsegmentation/pull/558))
+
+### V0.13 (05/05/2021)
+
+**Highlights**
+
+- Support Pascal Context Class-59 dataset.
+- Support Visual Transformer Backbone.
+- Support mFscore metric.
+
+**Bug Fixes**
+
+- Fixed Colaboratory tutorial ([#451](https://github.com/open-mmlab/mmsegmentation/pull/451))
+- Fixed mIoU calculation range ([#471](https://github.com/open-mmlab/mmsegmentation/pull/471))
+- Fixed sem_fpn, unet README.md ([#492](https://github.com/open-mmlab/mmsegmentation/pull/492))
+- Fixed `num_classes` in FCN for Pascal Context 60-class dataset ([#488](https://github.com/open-mmlab/mmsegmentation/pull/488))
+- Fixed FP16 inference ([#497](https://github.com/open-mmlab/mmsegmentation/pull/497))
+
+**New Features**
+
+- Support dynamic export and visualize to pytorch2onnx ([#463](https://github.com/open-mmlab/mmsegmentation/pull/463))
+- Support export to torchscript ([#469](https://github.com/open-mmlab/mmsegmentation/pull/469), [#499](https://github.com/open-mmlab/mmsegmentation/pull/499))
+- Support Pascal Context Class-59 dataset ([#459](https://github.com/open-mmlab/mmsegmentation/pull/459))
+- Support Visual Transformer backbone ([#465](https://github.com/open-mmlab/mmsegmentation/pull/465))
+- Support UpSample Neck ([#512](https://github.com/open-mmlab/mmsegmentation/pull/512))
+- Support mFscore metric ([#509](https://github.com/open-mmlab/mmsegmentation/pull/509))
+
+**Improvements**
+
+- Add more CI for PyTorch ([#460](https://github.com/open-mmlab/mmsegmentation/pull/460))
+- Add print model graph args for tools/print_config.py ([#451](https://github.com/open-mmlab/mmsegmentation/pull/451))
+- Add cfg links in modelzoo README.md ([#468](https://github.com/open-mmlab/mmsegmentation/pull/469))
+- Add BaseSegmentor import to segmentors/__init__.py ([#495](https://github.com/open-mmlab/mmsegmentation/pull/495))
+- Add MMOCR, MMGeneration links ([#501](https://github.com/open-mmlab/mmsegmentation/pull/501), [#506](https://github.com/open-mmlab/mmsegmentation/pull/506))
+- Add Chinese QR code ([#506](https://github.com/open-mmlab/mmsegmentation/pull/506))
+- Use MMCV MODEL_REGISTRY ([#515](https://github.com/open-mmlab/mmsegmentation/pull/515))
+- Add ONNX testing tools ([#498](https://github.com/open-mmlab/mmsegmentation/pull/498))
+- Replace data_dict calling 'img' key to support MMDet3D ([#514](https://github.com/open-mmlab/mmsegmentation/pull/514))
+- Support reading class_weight from file in loss function ([#513](https://github.com/open-mmlab/mmsegmentation/pull/513))
+- Make tags as comment ([#505](https://github.com/open-mmlab/mmsegmentation/pull/505))
+- Use MMCV EvalHook ([#438](https://github.com/open-mmlab/mmsegmentation/pull/438))
+
+### V0.12 (04/03/2021)
+
+**Highlights**
+
+- Support FCN-Dilate 6 model.
+- Support Dice Loss.
+
+**Bug Fixes**
+
+- Fixed PhotoMetricDistortion Doc ([#388](https://github.com/open-mmlab/mmsegmentation/pull/388))
+- Fixed install scripts ([#399](https://github.com/open-mmlab/mmsegmentation/pull/399))
+- Fixed Dice Loss multi-class ([#417](https://github.com/open-mmlab/mmsegmentation/pull/417))
+
+**New Features**
+
+- Support Dice Loss ([#396](https://github.com/open-mmlab/mmsegmentation/pull/396))
+- Add plot logs tool ([#426](https://github.com/open-mmlab/mmsegmentation/pull/426))
+- Add opacity option to show_result ([#425](https://github.com/open-mmlab/mmsegmentation/pull/425))
+- Speed up mIoU metric ([#430](https://github.com/open-mmlab/mmsegmentation/pull/430))
+
+**Improvements**
+
+- Refactor unittest file structure ([#440](https://github.com/open-mmlab/mmsegmentation/pull/440))
+- Fix typos in the repo ([#449](https://github.com/open-mmlab/mmsegmentation/pull/449))
+- Include class-level metrics in the log ([#445](https://github.com/open-mmlab/mmsegmentation/pull/445))
+
+### V0.11 (02/02/2021)
+
+**Highlights**
+
+- Support memory efficient test, add more UNet models.
+
+**Bug Fixes**
+
+- Fixed TTA resize scale ([#334](https://github.com/open-mmlab/mmsegmentation/pull/334))
+- Fixed CI for pip 20.3 ([#307](https://github.com/open-mmlab/mmsegmentation/pull/307))
+- Fixed ADE20k test ([#359](https://github.com/open-mmlab/mmsegmentation/pull/359))
+
+**New Features**
+
+- Support memory efficient test ([#330](https://github.com/open-mmlab/mmsegmentation/pull/330))
+- Add more UNet benchmarks ([#324](https://github.com/open-mmlab/mmsegmentation/pull/324))
+- Support Lovasz Loss ([#351](https://github.com/open-mmlab/mmsegmentation/pull/351))
+
+**Improvements**
+
+- Move train_cfg/test_cfg inside model ([#341](https://github.com/open-mmlab/mmsegmentation/pull/341))
+
+### V0.10 (01/01/2021)
+
+**Highlights**
+
+- Support MobileNetV3, DMNet, APCNet. Add models of ResNet18V1b, ResNet18V1c, ResNet50V1b.
+
+**Bug Fixes**
+
+- Fixed CPU TTA ([#276](https://github.com/open-mmlab/mmsegmentation/pull/276))
+- Fixed CI for pip 20.3 ([#307](https://github.com/open-mmlab/mmsegmentation/pull/307))
+
+**New Features**
+
+- Add ResNet18V1b, ResNet18V1c, ResNet50V1b, ResNet101V1b models ([#316](https://github.com/open-mmlab/mmsegmentation/pull/316))
+- Support MobileNetV3 ([#268](https://github.com/open-mmlab/mmsegmentation/pull/268))
+- Add 4 retinal vessel segmentation benchmark  ([#315](https://github.com/open-mmlab/mmsegmentation/pull/315))
+- Support DMNet ([#313](https://github.com/open-mmlab/mmsegmentation/pull/313))
+- Support APCNet ([#299](https://github.com/open-mmlab/mmsegmentation/pull/299))
+
+**Improvements**
+
+- Refactor Documentation page ([#311](https://github.com/open-mmlab/mmsegmentation/pull/311))
+- Support resize data augmentation according to original image size ([#291](https://github.com/open-mmlab/mmsegmentation/pull/291))
+
+### V0.9 (30/11/2020)
+
+**Highlights**
+
+- Support 4 medical dataset, UNet and CGNet.
+
+**New Features**
+
+- Support RandomRotate transform ([#215](https://github.com/open-mmlab/mmsegmentation/pull/215), [#260](https://github.com/open-mmlab/mmsegmentation/pull/260))
+- Support RGB2Gray transform ([#227](https://github.com/open-mmlab/mmsegmentation/pull/227))
+- Support Rerange transform ([#228](https://github.com/open-mmlab/mmsegmentation/pull/228))
+- Support ignore_index for BCE loss ([#210](https://github.com/open-mmlab/mmsegmentation/pull/210))
+- Add modelzoo statistics ([#263](https://github.com/open-mmlab/mmsegmentation/pull/263))
+- Support Dice evaluation metric ([#225](https://github.com/open-mmlab/mmsegmentation/pull/225))
+- Support Adjust Gamma transform ([#232](https://github.com/open-mmlab/mmsegmentation/pull/232))
+- Support CLAHE transform ([#229](https://github.com/open-mmlab/mmsegmentation/pull/229))
+
+**Bug Fixes**
+
+- Fixed detail API link ([#267](https://github.com/open-mmlab/mmsegmentation/pull/267))
+
+### V0.8 (03/11/2020)
+
+**Highlights**
+
+- Support 4 medical dataset, UNet and CGNet.
+
+**New Features**
+
+- Support customize runner ([#118](https://github.com/open-mmlab/mmsegmentation/pull/118))
+- Support UNet ([#161](https://github.com/open-mmlab/mmsegmentation/pull/162))
+- Support CHASE_DB1, DRIVE, STARE, HRD ([#203](https://github.com/open-mmlab/mmsegmentation/pull/203))
+- Support CGNet ([#223](https://github.com/open-mmlab/mmsegmentation/pull/223))
+
+### V0.7 (07/10/2020)
+
+**Highlights**
+
+- Support Pascal Context dataset and customizing class dataset.
+
+**Bug Fixes**
+
+- Fixed CPU inference ([#153](https://github.com/open-mmlab/mmsegmentation/pull/153))
+
+**New Features**
+
+- Add DeepLab OS16 models ([#154](https://github.com/open-mmlab/mmsegmentation/pull/154))
+- Support Pascal Context dataset ([#133](https://github.com/open-mmlab/mmsegmentation/pull/133))
+- Support customizing dataset classes ([#71](https://github.com/open-mmlab/mmsegmentation/pull/71))
+- Support customizing dataset palette ([#157](https://github.com/open-mmlab/mmsegmentation/pull/157))
+
+**Improvements**
+
+- Support 4D tensor output in ONNX ([#150](https://github.com/open-mmlab/mmsegmentation/pull/150))
+- Remove redundancies in ONNX export ([#160](https://github.com/open-mmlab/mmsegmentation/pull/160))
+- Migrate to MMCV DepthwiseSeparableConv ([#158](https://github.com/open-mmlab/mmsegmentation/pull/158))
+- Migrate to MMCV collect_env ([#137](https://github.com/open-mmlab/mmsegmentation/pull/137))
+- Use img_prefix and seg_prefix for loading ([#153](https://github.com/open-mmlab/mmsegmentation/pull/153))
+
+### V0.6 (10/09/2020)
+
+**Highlights**
+
+- Support new methods i.e. MobileNetV2, EMANet, DNL, PointRend, Semantic FPN, Fast-SCNN, ResNeSt.
+
+**Bug Fixes**
+
+- Fixed sliding inference ONNX export ([#90](https://github.com/open-mmlab/mmsegmentation/pull/90))
+
+**New Features**
+
+- Support MobileNet v2 ([#86](https://github.com/open-mmlab/mmsegmentation/pull/86))
+- Support EMANet ([#34](https://github.com/open-mmlab/mmsegmentation/pull/34))
+- Support DNL ([#37](https://github.com/open-mmlab/mmsegmentation/pull/37))
+- Support PointRend ([#109](https://github.com/open-mmlab/mmsegmentation/pull/109))
+- Support Semantic FPN ([#94](https://github.com/open-mmlab/mmsegmentation/pull/94))
+- Support Fast-SCNN ([#58](https://github.com/open-mmlab/mmsegmentation/pull/58))
+- Support ResNeSt backbone ([#47](https://github.com/open-mmlab/mmsegmentation/pull/47))
+- Support ONNX export (experimental) ([#12](https://github.com/open-mmlab/mmsegmentation/pull/12))
+
+**Improvements**
+
+- Support Upsample in ONNX ([#100](https://github.com/open-mmlab/mmsegmentation/pull/100))
+- Support Windows install (experimental) ([#75](https://github.com/open-mmlab/mmsegmentation/pull/75))
+- Add more OCRNet results ([#20](https://github.com/open-mmlab/mmsegmentation/pull/20))
+- Add PyTorch 1.6 CI ([#64](https://github.com/open-mmlab/mmsegmentation/pull/64))
+- Get version and githash automatically ([#55](https://github.com/open-mmlab/mmsegmentation/pull/55))
+
+### v0.5.1 (11/08/2020)
+
+**Highlights**
+
+- Support FP16 and more generalized OHEM
+
+**Bug Fixes**
+
+- Fixed Pascal VOC conversion script (#19)
+- Fixed OHEM weight assign bug (#54)
+- Fixed palette type when palette is not given (#27)
+
+**New Features**
+
+- Support FP16 (#21)
+- Generalized OHEM (#54)
+
+**Improvements**
+
+- Add load-from flag (#33)
+- Fixed training tricks doc about different learning rates of model (#26)
diff --git a/mmsegmentation/docs/en/notes/faq.md b/mmsegmentation/docs/en/notes/faq.md
new file mode 100644
index 0000000..a3f8099
--- /dev/null
+++ b/mmsegmentation/docs/en/notes/faq.md
@@ -0,0 +1,132 @@
+# Frequently Asked Questions (FAQ)
+
+We list some common troubles faced by many users and their corresponding solutions here. Feel free to enrich the list if you find any frequent issues and have ways to help others to solve them. If the contents here do not cover your issue, please create an issue using the [provided templates](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/.github/ISSUE_TEMPLATE/error-report.md/) and make sure you fill in all required information in the template.
+
+## Installation
+
+The compatible MMSegmentation, MMCV and MMEngine versions are as below. Please install the correct versions of them to avoid installation issues.
+
+| MMSegmentation version |          MMCV version          | MMEngine version  | MMClassification (optional) version | MMDetection (optional) version |
+| :--------------------: | :----------------------------: | :---------------: | :---------------------------------: | :----------------------------: |
+|     dev-1.x branch     |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
+|      main branch       |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
+|         1.2.2          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
+|         1.2.1          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
+|         1.2.0          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
+|         1.1.2          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
+|         1.1.1          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
+|         1.1.0          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
+|         1.0.0          |        mmcv >= 2.0.0rc4        | MMEngine >= 0.7.1 |           mmcls==1.0.0rc6           |         mmdet >= 3.0.0         |
+|        1.0.0rc6        |        mmcv >= 2.0.0rc4        | MMEngine >= 0.5.0 |           mmcls>=1.0.0rc0           |       mmdet >= 3.0.0rc6        |
+|        1.0.0rc5        |        mmcv >= 2.0.0rc4        | MMEngine >= 0.2.0 |           mmcls>=1.0.0rc0           |        mmdet>=3.0.0rc6         |
+|        1.0.0rc4        |        mmcv == 2.0.0rc3        | MMEngine >= 0.1.0 |           mmcls>=1.0.0rc0           |  mmdet>=3.0.0rc4, \<=3.0.0rc5  |
+|        1.0.0rc3        |        mmcv == 2.0.0rc3        | MMEngine >= 0.1.0 |           mmcls>=1.0.0rc0           |  mmdet>=3.0.0rc4, \<=3.0.0rc5  |
+|        1.0.0rc2        |        mmcv == 2.0.0rc3        | MMEngine >= 0.1.0 |           mmcls>=1.0.0rc0           |  mmdet>=3.0.0rc4, \<=3.0.0rc5  |
+|        1.0.0rc1        | mmcv >= 2.0.0rc1, \<=2.0.0rc3> | MMEngine >= 0.1.0 |           mmcls>=1.0.0rc0           |          Not required          |
+|        1.0.0rc0        | mmcv >= 2.0.0rc1, \<=2.0.0rc3> | MMEngine >= 0.1.0 |           mmcls>=1.0.0rc0           |          Not required          |
+
+Notes:
+
+- MMClassification and MMDetatction are optional for MMSegmentation. If you didn't install them, `ConvNeXt` (required MMClassification) and MaskFormer, Mask2Former (required MMDetection) cannot be used. We recommend to install them with source code. Please refer to [MMClasssication](https://github.com/open-mmlab/mmclassification) and [MMDetection](https://github.com/open-mmlab/mmdetection) for more details about their installation.
+
+- To install MMSegmentation 0.x and master branch, please refer to [the faq 0.x document](https://mmsegmentation.readthedocs.io/en/latest/faq.html#installation) to check compatible versions of MMCV.
+
+- If you have installed an incompatible version of mmcv, please run `pip uninstall mmcv` to uninstall the installed mmcv first. If you have previously installed mmcv-full (which exists in OpenMMLab 1.x), please run `pip uninstall mmcv-full` to uninstall it.
+
+- If "No module named 'mmcv'" appears, please follow the steps below;
+
+  1. Use `pip uninstall mmcv` to uninstall the existing mmcv in the environment.
+  2. Install the corresponding mmcv according to the [installation instructions](https://mmsegmentation.readthedocs.io/en/dev-1.x/get_started.html#best-practices).
+
+## How to know the number of GPUs needed to train the model
+
+- Infer from the name of the config file of the model. You can refer to the `Config Name Style` part of [Learn about Configs](../user_guides/1_config.md). For example, for config file with name `segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py`, `8xb1` means training the model corresponding to it needs 8 GPUs, and the batch size of each GPU is 1.
+- Infer from the log file. Open the log file of the model and search `nGPU` in the file. The number of figures following `nGPU` is the number of GPUs needed to train the model. For instance, searching for `nGPU` in the log file yields the record `nGPU 0,1,2,3,4,5,6,7`, which indicates that eight GPUs are needed to train the model.
+
+## What does the auxiliary head mean
+
+Briefly, it is a deep supervision trick to improve the accuracy. In the training phase, `decode_head` is for decoding semantic segmentation output, `auxiliary_head` is just adding an auxiliary loss, the segmentation result produced by it has no impact to your model's result, it just works in training. You may read this [paper](https://arxiv.org/pdf/1612.01105.pdf) for more information.
+
+## How to output the segmentation mask image when running the test script
+
+In the test script, we provide `--out` argument to control whether output the painted images. Users might run the following command:
+
+```shell
+python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} --out ${OUTPUT_DIR}
+```
+
+## How to handle binary segmentation task
+
+MMSegmentation uses `num_classes` and `out_channels` to control output of last layer `self.conv_seg`. More details could be found [here](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/mmseg/models/decode_heads/decode_head.py).
+
+`num_classes` should be the same as number of types of labels, in binary segmentation task, dataset only has two types of labels: foreground and background, so `num_classes=2`. `out_channels` controls the output channel of last layer of model, it usually equals to `num_classes`.
+But in binary segmentation task, there are two solutions:
+
+- Set `out_channels=2`, using Cross Entropy Loss in training, using `F.softmax()` and `argmax()` to get prediction of each pixel in inference.
+
+- Set `out_channels=1`, using Binary Cross Entropy Loss in training, using `F.sigmoid()` and `threshold` to get prediction of each pixel in inference. `threshold` is set 0.3 as default.
+
+In summary, to implement binary segmentation methods users should modify below parameters in the `decode_head` and `auxiliary_head` configs. Here is a modification example of [pspnet_unet_s5-d16.py](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/_base_/models/pspnet_unet_s5-d16.py):
+
+- (1) `num_classes=2`, `out_channels=2` and `use_sigmoid=False` in `CrossEntropyLoss`.
+
+```python
+decode_head=dict(
+    type='PSPHead',
+    in_channels=64,
+    in_index=4,
+    num_classes=2,
+    out_channels=2,
+    loss_decode=dict(
+        type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+auxiliary_head=dict(
+    type='FCNHead',
+    in_channels=128,
+    in_index=3,
+    num_classes=2,
+    out_channels=2,
+    loss_decode=dict(
+        type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+```
+
+- (2) `num_classes=2`, `out_channels=1` and `use_sigmoid=True` in `CrossEntropyLoss`.
+
+```python
+decode_head=dict(
+    type='PSPHead',
+    in_channels=64,
+    in_index=4,
+    num_classes=2,
+    out_channels=1,
+    loss_decode=dict(
+        type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)),
+auxiliary_head=dict(
+    type='FCNHead',
+    in_channels=128,
+    in_index=3,
+    num_classes=2,
+    out_channels=1,
+    loss_decode=dict(
+        type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.4)),
+```
+
+## Functionality of `reduce_zero_label`
+
+The parameter type of `reduce_zero_label` in dataset is Boolean, which is default to False. It is used to ignore the dataset label 0. The specific method is to change label 0 to 255, and subtract 1 from the corresponding number of all the remaining labels. At the same time, set 255 as ignore index in the decode head, which means that it will not participate in the loss calculation.
+
+Following is the specific implementation logic of `reduce_zero_label`:
+
+```python
+if self.reduce_zero_label:
+    # avoid using underflow conversion
+    gt_semantic_seg[gt_semantic_seg == 0] = 255
+    gt_semantic_seg = gt_semantic_seg - 1
+    gt_semantic_seg[gt_semantic_seg == 254] = 255
+```
+
+Whether your dataset needs to use `reduce_zero_label`, there are two types of situations:
+
+- On [Potsdam](https://github.com/open-mmlab/mmsegmentation/blob/1.x/docs/en/user_guides/2_dataset_prepare.md#isprs-potsdam) dataset, there are six classes: 0-Impervious surfaces, 1-Building, 2-Low vegetation, 3-Tree, 4-Car, 5-Clutter/background. However, this dataset provides two types of RGB labels, one with black pixels at the edges of the images, and the other without. For labels with black edges, in [dataset_converters.py](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/tools/dataset_converters/potsdam.py), it converts the black edges to label 0, and the other labels are 1-Impervious surfaces, 2-Building, 3-Low vegetation, 4-Tree, 5-Car, 6-Clutter/background. Therefore, in the dataset config [potsdam.py](https://github.com/open-mmlab/mmsegmentation/blob/ff95416c3b5ce8d62b9289f743531398efce534f/mmseg/datasets/potsdam.py#L23) `reduce_zero_label=True`。 If you are using labels without black edges, then there are only class 0-5 in the mask label. At this point, you should use `reduce_zero_label=False`. `reduce_zero_label` usage needs to be considered with your actual situation.
+- On a dataset with class 0 as the background class, if you need to separate the background from the rest of your classes ultimately then you do not need to use `reduce_zero_label`, which in the dataset config settings should be `reduce_zero_label=False`
+
+**Note:** Please confirm the number of original classes in the dataset. If there are only two classes, you should not use `reduce_zero_label` which is `reduce_zero_label=False`.
diff --git a/mmsegmentation/docs/en/overview.md b/mmsegmentation/docs/en/overview.md
new file mode 100644
index 0000000..bbc0b8e
--- /dev/null
+++ b/mmsegmentation/docs/en/overview.md
@@ -0,0 +1,85 @@
+# Overview
+
+This chapter introduces you to the framework of MMSegmentation, and the basic conception of semantic segmentation. It also provides links to detailed tutorials about MMSegmentation.
+
+## What is semantic segmentation?
+
+Semantic segmentation is the task of clustering parts of an image together that belong to the same object class.
+It is a form of pixel-level prediction because each pixel in an image is classified according to a category.
+Some example benchmarks for this task are [Cityscapes](https://www.cityscapes-dataset.com/benchmarks/), [PASCAL VOC](http://host.robots.ox.ac.uk/pascal/VOC/voc2012/) and [ADE20K](https://groups.csail.mit.edu/vision/datasets/ADE20K/).
+Models are usually evaluated with the Mean Intersection-Over-Union (Mean IoU) and Pixel Accuracy metrics.
+
+## What is MMSegmentation?
+
+MMSegmentation is a toolbox that provides a framework for unified implementation and evaluation of semant
+ic segmentation methods,
+and contains high-quality implementations of popular semantic segmentation methods and datasets.
+
+MMSeg consists of 7 main parts including apis, structures, datasets, models, engine, evaluation and visualization.
+
+- **apis** provides high-level APIs for model inference.
+
+- **structures** provides segmentation data structure `SegDataSample`.
+
+- **datasets** supports various datasets for semantic segmentation.
+
+  - **transforms** contains a lot of useful data augmentation transforms.
+
+- **models** is the most vital part for segmentors and contains different components of a segmentor.
+
+  - **segmentors** defines all of the segmentation model classes.
+  - **data_preprocessors** works for preprocessing the input data of the model.
+  - **backbones** contains various backbone networks that transform an image to feature maps.
+  - **necks** contains various neck components that connect the backbone and heads.
+  - **decode_heads** contains various head components that take feature map as input and predict segmentation results.
+  - **losses** contains various loss functions.
+
+- **engine** is a part for runtime components that extends function of [MMEngine](https://github.com/open-mmlab/mmengine).
+
+  - **optimizers** provides optimizers and optimizer wrappers.
+  - **hooks** provides various hooks of the runner.
+
+- **evaluation** provides different metrics for evaluating model performance.
+
+- **visualization** is for visualizing segmentation results.
+
+## How to use this documentation
+
+Here is a detailed step-by-step guide to learn more about MMSegmentation:
+
+1. For installation instructions, please see [get_started](getting_started.md).
+
+2. For beginners, MMSegmentation is the best place to start the journey of semantic segmentation
+   as there are many SOTA and classic segmentation [models](model_zoo.md),
+   and it is easier to carry out a segmentation task by plugging together building blocks and convenient high-level apis.
+   Refer to the tutorials below for the basic usage of MMSegmentation:
+
+   - [Config](user_guides/1_config.md)
+   - [Dataset Preparation](user_guides/2_dataset_prepare.md)
+   - [Inference](user_guides/3_inference.md)
+   - [Train and Test](user_guides/4_train_test.md)
+
+3. If you would like to learn about the fundamental classes and features that make MMSegmentation work,
+   please refer to the tutorials below to dive deeper:
+
+   - [Data flow](advanced_guides/data_flow.md)
+   - [Structures](advanced_guides/structures.md)
+   - [Models](advanced_guides/models.md)
+   - [Datasets](advanced_guides/datasets.md)
+   - [Evaluation](advanced_guides/evaluation.md)
+
+4. MMSegmentation also provide tutorials for customization and advanced research,
+   please refer to the below guides to build your own segmentation project:
+
+   - [Add new models](advanced_guides/add_models.md)
+   - [Add new datasets](advanced_guides/add_datasets.md)
+   - [Add new transforms](advanced_guides/add_transforms.md)
+   - [Customize runtime](advanced_guides/customize_runtime.md)
+
+5. If you are more familiar with MMSegmentation v0.x, there is documentation about migration from MMSegmentation v0.x to v1.x
+
+   - [migration](migration/index.rst)
+
+## References
+
+- [Paper with code](https://paperswithcode.com/task/semantic-segmentation/codeless#task-home)
diff --git a/mmsegmentation/docs/en/stat.py b/mmsegmentation/docs/en/stat.py
new file mode 100755
index 0000000..c458ee3
--- /dev/null
+++ b/mmsegmentation/docs/en/stat.py
@@ -0,0 +1,67 @@
+#!/usr/bin/env python
+# Copyright (c) OpenMMLab. All rights reserved.
+import functools as func
+import glob
+import os.path as osp
+import re
+
+import numpy as np
+
+url_prefix = 'https://github.com/open-mmlab/mmsegmentation/blob/master/'
+
+files = sorted(glob.glob('../../configs/*/README.md'))
+
+stats = []
+titles = []
+num_ckpts = 0
+
+for f in files:
+    url = osp.dirname(f.replace('../../', url_prefix))
+
+    with open(f) as content_file:
+        content = content_file.read()
+
+    title = content.split('\n')[0].replace('#', '').strip()
+    ckpts = {
+        x.lower().strip()
+        for x in re.findall(r'https?://download.*\.pth', content)
+        if 'mmsegmentation' in x
+    }
+    if len(ckpts) == 0:
+        continue
+
+    _papertype = [
+        x for x in re.findall(r'<!--\s*\[([A-Z]*?)\]\s*-->', content)
+    ]
+    assert len(_papertype) > 0
+    papertype = _papertype[0]
+
+    paper = {(papertype, title)}
+
+    titles.append(title)
+    num_ckpts += len(ckpts)
+    statsmsg = f"""
+\t* [{papertype}] [{title}]({url}) ({len(ckpts)} ckpts)
+"""
+    stats.append((paper, ckpts, statsmsg))
+
+allpapers = func.reduce(lambda a, b: a.union(b), [p for p, _, _ in stats])
+msglist = '\n'.join(x for _, _, x in stats)
+
+papertypes, papercounts = np.unique([t for t, _ in allpapers],
+                                    return_counts=True)
+countstr = '\n'.join(
+    [f'   - {t}: {c}' for t, c in zip(papertypes, papercounts)])
+
+modelzoo = f"""
+# Model Zoo Statistics
+
+* Number of papers: {len(set(titles))}
+{countstr}
+
+* Number of checkpoints: {num_ckpts}
+{msglist}
+"""
+
+with open('modelzoo_statistics.md', 'w') as f:
+    f.write(modelzoo)
diff --git a/mmsegmentation/docs/en/switch_language.md b/mmsegmentation/docs/en/switch_language.md
new file mode 100644
index 0000000..f58efc4
--- /dev/null
+++ b/mmsegmentation/docs/en/switch_language.md
@@ -0,0 +1,3 @@
+## <a href='https://mmsegmentation.readthedocs.io/en/latest/'>English</a>
+
+## <a href='https://mmsegmentation.readthedocs.io/zh_CN/latest/'>简体中文</a>
diff --git a/mmsegmentation/docs/en/user_guides/1_config.md b/mmsegmentation/docs/en/user_guides/1_config.md
new file mode 100644
index 0000000..291c488
--- /dev/null
+++ b/mmsegmentation/docs/en/user_guides/1_config.md
@@ -0,0 +1,588 @@
+# Tutorial 1: Learn about Configs
+
+We incorporate modular and inheritance design into our config system, which is convenient to conduct various experiments.
+If you wish to inspect the config file, you may run `python tools/misc/print_config.py /PATH/TO/CONFIG` to see the complete config.
+You may also pass `--cfg-options xxx.yyy=zzz` to see updated config.
+
+## Config File Structure
+
+There are 4 basic component types under `config/_base_`, datasets, models, schedules, default_runtime.
+Many methods could be easily constructed with one of each like DeepLabV3, PSPNet.
+The configs that are composed by components from `_base_` are called _primitive_.
+
+For all configs under the same folder, it is recommended to have only **one** _primitive_ config. All other configs should inherit from the _primitive_ config. In this way, the maximum of inheritance level is 3.
+
+For easy understanding, we recommend contributors to inherit from existing methods.
+For example, if some modification is made base on DeepLabV3, user may first inherit the basic DeepLabV3 structure by specifying `_base_ = ../deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py`, then modify the necessary fields in the config files.
+
+If you are building an entirely new method that does not share the structure with any of the existing methods, you may create a folder `xxxnet` under `configs`,
+
+Please refer to [mmengine](https://mmengine.readthedocs.io/en/latest/tutorials/config.html) for detailed documentation.
+
+## Config Name Style
+
+We follow the below style to name config files. Contributors are advised to follow the same style.
+
+```text
+{algorithm name}_{model component names [component1]_[component2]_[...]}_{training settings}_{training dataset information}_{testing dataset information}
+```
+
+The file name is divided to five parts. All parts and components are connected with `_` and words of each part or component should be connected with `-`.
+
+- `{algorithm name}`: The name of the algorithm, such as `deeplabv3`, `pspnet`, etc.
+- `{model component names}`: Names of the components used in the algorithm such as backbone, head, etc. For example, `r50-d8` means using ResNet50 backbone and use output of backbone is 8 times downsampling as input.
+- `{training settings}`: Information of training settings such as batch size, augmentations, loss, learning rate scheduler, and epochs/iterations. For example: `4xb4-ce-linearlr-40K` means using 4-gpus x 4-images-per-gpu, CrossEntropy loss, Linear learning rate scheduler, and train 40K iterations.
+  Some abbreviations:
+  - `{gpu x batch_per_gpu}`: GPUs and samples per GPU. `bN` indicates N batch size per GPU. E.g. `8xb2` is the short term of 8-gpus x 2-images-per-gpu. And `4xb4` is used by default if not mentioned.
+  - `{schedule}`: training schedule, options are `20k`, `40k`, etc. `20k` and `40k` means 20000 iterations and 40000 iterations respectively.
+- `{training dataset information}`: Training dataset names like `cityscapes`, `ade20k`, etc, and input resolutions. For example: `cityscapes-768x768` means training on `cityscapes` dataset and the input shape is `768x768`.
+- `{testing dataset information}` (optional): Testing dataset name for models trained on one dataset but tested on another. If not mentioned, it means the model was trained and tested on the same dataset type.
+
+## An Example of PSPNet
+
+To help the users have a basic idea of a complete config and the modules in a modern semantic segmentation system,
+we make brief comments on the config of PSPNet using ResNet50V1c as the following.
+For more detailed usage and the corresponding alternative for each module, please refer to the API documentation.
+
+```python
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+] # base config file which we build new config file on.
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
+```
+
+`_base_/models/pspnet_r50-d8.py` is a basic model cfg file for PSPNet using ResNet50V1c
+
+```python
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)  # Segmentation usually uses SyncBN
+data_preprocessor = dict(  # The config of data preprocessor, usually includes image normalization and augmentation.
+    type='SegDataPreProcessor',  # The type of data preprocessor.
+    mean=[123.675, 116.28, 103.53],  # Mean values used for normalizing the input images.
+    std=[58.395, 57.12, 57.375],  # Standard variance used for normalizing the input images.
+    bgr_to_rgb=True,  # Whether to convert image from BGR to RGB.
+    pad_val=0,  # Padding value of image.
+    seg_pad_val=255)  # Padding value of segmentation map.
+model = dict(
+    type='EncoderDecoder',  # Name of segmentor
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',  # The ImageNet pretrained backbone to be loaded
+    backbone=dict(
+        type='ResNetV1c',  # The type of backbone. Please refer to mmseg/models/backbones/resnet.py for details.
+        depth=50,  # Depth of backbone. Normally 50, 101 are used.
+        num_stages=4,  # Number of stages of backbone.
+        out_indices=(0, 1, 2, 3),  # The index of output feature maps produced in each stages.
+        dilations=(1, 1, 2, 4),  # The dilation rate of each layer.
+        strides=(1, 2, 1, 1),  # The stride of each layer.
+        norm_cfg=norm_cfg,  # The configuration of norm layer.
+        norm_eval=False,  # Whether to freeze the statistics in BN
+        style='pytorch',  # The style of backbone, 'pytorch' means that stride 2 layers are in 3x3 conv, 'caffe' means stride 2 layers are in 1x1 convs.
+        contract_dilation=True),  # When dilation > 1, whether contract first layer of dilation.
+    decode_head=dict(
+        type='PSPHead',  # Type of decode head. Please refer to mmseg/models/decode_heads for available options.
+        in_channels=2048,  # Input channel of decode head.
+        in_index=3,  # The index of feature map to select.
+        channels=512,  # The intermediate channels of decode head.
+        pool_scales=(1, 2, 3, 6),  # The avg pooling scales of PSPHead. Please refer to paper for details.
+        dropout_ratio=0.1,  # The dropout ratio before final classification layer.
+        num_classes=19,  # Number of segmentation class. Usually 19 for cityscapes, 21 for VOC, 150 for ADE20k.
+        norm_cfg=norm_cfg,  # The configuration of norm layer.
+        align_corners=False,  # The align_corners argument for resize in decoding.
+        loss_decode=dict(  # Config of loss function for the decode_head.
+            type='CrossEntropyLoss',  # Type of loss used for segmentation.
+            use_sigmoid=False,  # Whether use sigmoid activation for segmentation.
+            loss_weight=1.0)),  # Loss weight of decode_head.
+    auxiliary_head=dict(
+        type='FCNHead',  # Type of auxiliary head. Please refer to mmseg/models/decode_heads for available options.
+        in_channels=1024,  # Input channel of auxiliary head.
+        in_index=2,  # The index of feature map to select.
+        channels=256,  # The intermediate channels of decode head.
+        num_convs=1,  # Number of convs in FCNHead. It is usually 1 in auxiliary head.
+        concat_input=False,  # Whether concat output of convs with input before classification layer.
+        dropout_ratio=0.1,  # The dropout ratio before final classification layer.
+        num_classes=19,  # Number of segmentation class. Usually 19 for cityscapes, 21 for VOC, 150 for ADE20k.
+        norm_cfg=norm_cfg,  # The configuration of norm layer.
+        align_corners=False,  # The align_corners argument for resize in decoding.
+        loss_decode=dict(  # Config of loss function for the auxiliary_head.
+            type='CrossEntropyLoss',  # Type of loss used for segmentation.
+            use_sigmoid=False,  # Whether use sigmoid activation for segmentation.
+            loss_weight=0.4)),  # Loss weight of auxiliary_head.
+    # model training and testing settings
+    train_cfg=dict(),  # train_cfg is just a place holder for now.
+    test_cfg=dict(mode='whole'))  # The test mode, options are 'whole' and 'slide'. 'whole': whole image fully-convolutional test. 'slide': sliding crop window on the image.
+```
+
+`_base_/datasets/cityscapes.py` is the configuration file of the dataset
+
+```python
+# dataset settings
+dataset_type = 'CityscapesDataset'  # Dataset type, this will be used to define the dataset.
+data_root = 'data/cityscapes/'  # Root path of data.
+crop_size = (512, 1024)  # The crop size during training.
+train_pipeline = [  # Training pipeline.
+    dict(type='LoadImageFromFile'),  # First pipeline to load images from file path.
+    dict(type='LoadAnnotations'),  # Second pipeline to load annotations for current image.
+    dict(type='RandomResize',  # Augmentation pipeline that resize the images and their annotations.
+        scale=(2048, 1024),  # The scale of image.
+        ratio_range=(0.5, 2.0),  # The augmented scale range as ratio.
+        keep_ratio=True),  # Whether to keep the aspect ratio when resizing the image.
+    dict(type='RandomCrop',  # Augmentation pipeline that randomly crop a patch from current image.
+        crop_size=crop_size,  # The crop size of patch.
+        cat_max_ratio=0.75),  # The max area ratio that could be occupied by single category.
+    dict(type='RandomFlip',  # Augmentation pipeline that flip the images and their annotations
+        prob=0.5),  # The ratio or probability to flip
+    dict(type='PhotoMetricDistortion'),  # Augmentation pipeline that distort current image with several photo metric methods.
+    dict(type='PackSegInputs')  # Pack the inputs data for the semantic segmentation.
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),  # First pipeline to load images from file path
+    dict(type='Resize',  # Use resize augmentation
+        scale=(2048, 1024),  # Images scales for resizing.
+        keep_ratio=True),  # Whether to keep the aspect ratio when resizing the image.
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),  # Load annotations for semantic segmentation provided by dataset.
+    dict(type='PackSegInputs')  # Pack the inputs data for the semantic segmentation.
+]
+train_dataloader = dict(  # Train dataloader config
+    batch_size=2,  # Batch size of a single GPU
+    num_workers=2,  # Worker to pre-fetch data for each single GPU
+    persistent_workers=True,  # Shut down the worker processes after an epoch end, which can accelerate training speed.
+    sampler=dict(type='InfiniteSampler', shuffle=True),  # Randomly shuffle during training.
+    dataset=dict(  # Train dataset config
+        type=dataset_type,  # Type of dataset, refer to mmseg/datasets/ for details.
+        data_root=data_root,  # The root of dataset.
+        data_prefix=dict(
+            img_path='leftImg8bit/train', seg_map_path='gtFine/train'),  # Prefix for training data.
+        pipeline=train_pipeline)) # Processing pipeline. This is passed by the train_pipeline created before.
+val_dataloader = dict(
+    batch_size=1,  # Batch size of a single GPU
+    num_workers=4,  # Worker to pre-fetch data for each single GPU
+    persistent_workers=True,  # Shut down the worker processes after an epoch end, which can accelerate testing speed.
+    sampler=dict(type='DefaultSampler', shuffle=False),  # Not shuffle during validation and testing.
+    dataset=dict(  # Test dataset config
+        type=dataset_type,  # Type of dataset, refer to mmseg/datasets/ for details.
+        data_root=data_root,  # The root of dataset.
+        data_prefix=dict(
+            img_path='leftImg8bit/val', seg_map_path='gtFine/val'),  # Prefix for testing data.
+        pipeline=test_pipeline))  # Processing pipeline. This is passed by the test_pipeline created before.
+test_dataloader = val_dataloader
+# The metric to measure the accuracy. Here, we use IoUMetric.
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
+```
+
+`_base_/schedules/schedule_40k.py`
+
+```python
+# optimizer
+optimizer = dict(type='SGD', # Type of optimizers, refer to https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py for more details
+                lr=0.01,  # Learning rate of optimizers, see detail usages of the parameters in the documentation of PyTorch
+                momentum=0.9,  # Momentum
+                weight_decay=0.0005)  # Weight decay of SGD
+optim_wrapper = dict(type='OptimWrapper',  # Optimizer wrapper provides a common interface for updating parameters.
+                    optimizer=optimizer,  # Optimizer used to update model parameters.
+                    clip_grad=None)  # If ``clip_grad`` is not None, it will be the arguments of ``torch.nn.utils.clip_grad``.
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',  # The policy of scheduler, also support Step, CosineAnnealing, Cyclic, etc. Refer to details of supported LrUpdater from https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/scheduler/lr_scheduler.py
+        eta_min=1e-4,  # Minimum learning rate at the end of scheduling.
+        power=0.9,  # The power of polynomial decay.
+        begin=0,  # Step at which to start updating the parameters.
+        end=40000,  # Step at which to stop updating the parameters.
+        by_epoch=False)  # Whether count by epoch or not.
+]
+# training schedule for 40k iteration
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=40000, val_interval=4000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+# default hooks
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),  # Log the time spent during iteration.
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),  # Collect and write logs from different components of ``Runner``.
+    param_scheduler=dict(type='ParamSchedulerHook'),  # update some hyper-parameters in optimizer, e.g., learning rate.
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=4000),  # Save checkpoints periodically.
+    sampler_seed=dict(type='DistSamplerSeedHook'))  # Data-loading sampler for distributed training.
+```
+
+in `_base_/default_runtime.py`
+
+```python
+# Set the default scope of the registry to mmseg.
+default_scope = 'mmseg'
+# environment
+env_cfg = dict(
+    cudnn_benchmark=True,
+    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+    dist_cfg=dict(backend='nccl'),
+)
+log_level = 'INFO'
+log_processor = dict(by_epoch=False)
+load_from = None  # Load checkpoint from file.
+resume = False  # Whether to resume from existed model.
+```
+
+These are all the configs for training and testing PSPNet, to load and parse them, we can use [Config](https://mmengine.readthedocs.io/en/latest/tutorials/config.html) implemented in [MMEngine](https://github.com/open-mmlab/mmengine)
+
+```python
+from mmengine.config import Config
+
+cfg = Config.fromfile('configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py')
+print(cfg.train_dataloader)
+```
+
+```shell
+{'batch_size': 2,
+ 'num_workers': 2,
+ 'persistent_workers': True,
+ 'sampler': {'type': 'InfiniteSampler', 'shuffle': True},
+ 'dataset': {'type': 'CityscapesDataset',
+  'data_root': 'data/cityscapes/',
+  'data_prefix': {'img_path': 'leftImg8bit/train',
+   'seg_map_path': 'gtFine/train'},
+  'pipeline': [{'type': 'LoadImageFromFile'},
+   {'type': 'LoadAnnotations'},
+   {'type': 'RandomResize',
+    'scale': (2048, 1024),
+    'ratio_range': (0.5, 2.0),
+    'keep_ratio': True},
+   {'type': 'RandomCrop', 'crop_size': (512, 1024), 'cat_max_ratio': 0.75},
+   {'type': 'RandomFlip', 'prob': 0.5},
+   {'type': 'PhotoMetricDistortion'},
+   {'type': 'PackSegInputs'}]}}
+```
+
+`cfg` is an instance of `mmengine.config.Config`, its interface is the same as a dict object and also allows access config values as attributes. See [config tutorial](https://mmengine.readthedocs.io/en/latest/tutorials/config.html) in [MMEngine](https://github.com/open-mmlab/mmengine) for more information.
+
+## FAQ
+
+### Ignore some fields in the base configs
+
+Sometimes, you may set `_delete_=True` to ignore some of the fields in base configs.
+See [config tutorial](https://mmengine.readthedocs.io/en/latest/tutorials/config.html) in [MMEngine](https://github.com/open-mmlab/mmengine) for simple illustration.
+
+In MMSegmentation, for example, if you would like to modify the backbone of PSPNet with the following config file `pspnet.py`:
+
+```python
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    type='EncoderDecoder',
+    pretrained='torchvision://resnet50',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='PSPHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        pool_scales=(1, 2, 3, 6),
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)))
+```
+
+Load and parse the config file `pspnet.py` in the code as follows:
+
+```python
+from mmengine.config import Config
+
+cfg = Config.fromfile('pspnet.py')
+print(cfg.model)
+```
+
+```shell
+{'type': 'EncoderDecoder',
+ 'pretrained': 'torchvision://resnet50',
+ 'backbone': {'type': 'ResNetV1c',
+  'depth': 50,
+  'num_stages': 4,
+  'out_indices': (0, 1, 2, 3),
+  'dilations': (1, 1, 2, 4),
+  'strides': (1, 2, 1, 1),
+  'norm_cfg': {'type': 'SyncBN', 'requires_grad': True},
+  'norm_eval': False,
+  'style': 'pytorch',
+  'contract_dilation': True},
+ 'decode_head': {'type': 'PSPHead',
+  'in_channels': 2048,
+  'in_index': 3,
+  'channels': 512,
+  'pool_scales': (1, 2, 3, 6),
+  'dropout_ratio': 0.1,
+  'num_classes': 19,
+  'norm_cfg': {'type': 'SyncBN', 'requires_grad': True},
+  'align_corners': False,
+  'loss_decode': {'type': 'CrossEntropyLoss',
+   'use_sigmoid': False,
+   'loss_weight': 1.0}}}
+```
+
+`ResNet` and `HRNet` use different keywords to construct, write a new config file `hrnet.py` as follows:
+
+```python
+_base_ = 'pspnet.py'
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w32',
+    backbone=dict(
+        _delete_=True,
+        type='HRNet',
+        norm_cfg=norm_cfg,
+        extra=dict(
+            stage1=dict(
+                num_modules=1,
+                num_branches=1,
+                block='BOTTLENECK',
+                num_blocks=(4, ),
+                num_channels=(64, )),
+            stage2=dict(
+                num_modules=1,
+                num_branches=2,
+                block='BASIC',
+                num_blocks=(4, 4),
+                num_channels=(32, 64)),
+            stage3=dict(
+                num_modules=4,
+                num_branches=3,
+                block='BASIC',
+                num_blocks=(4, 4, 4),
+                num_channels=(32, 64, 128)),
+            stage4=dict(
+                num_modules=3,
+                num_branches=4,
+                block='BASIC',
+                num_blocks=(4, 4, 4, 4),
+                num_channels=(32, 64, 128, 256)))))
+```
+
+Load and parse the config file `hrnet.py` in the code as follows:
+
+```python
+from mmengine.config import Config
+cfg = Config.fromfile('hrnet.py')
+print(cfg.model)
+```
+
+```shell
+{'type': 'EncoderDecoder',
+ 'pretrained': 'open-mmlab://msra/hrnetv2_w32',
+ 'backbone': {'type': 'HRNet',
+  'norm_cfg': {'type': 'SyncBN', 'requires_grad': True},
+  'extra': {'stage1': {'num_modules': 1,
+    'num_branches': 1,
+    'block': 'BOTTLENECK',
+    'num_blocks': (4,),
+    'num_channels': (64,)},
+   'stage2': {'num_modules': 1,
+    'num_branches': 2,
+    'block': 'BASIC',
+    'num_blocks': (4, 4),
+    'num_channels': (32, 64)},
+   'stage3': {'num_modules': 4,
+    'num_branches': 3,
+    'block': 'BASIC',
+    'num_blocks': (4, 4, 4),
+    'num_channels': (32, 64, 128)},
+   'stage4': {'num_modules': 3,
+    'num_branches': 4,
+    'block': 'BASIC',
+    'num_blocks': (4, 4, 4, 4),
+    'num_channels': (32, 64, 128, 256)}}},
+ 'decode_head': {'type': 'PSPHead',
+  'in_channels': 2048,
+  'in_index': 3,
+  'channels': 512,
+  'pool_scales': (1, 2, 3, 6),
+  'dropout_ratio': 0.1,
+  'num_classes': 19,
+  'norm_cfg': {'type': 'SyncBN', 'requires_grad': True},
+  'align_corners': False,
+  'loss_decode': {'type': 'CrossEntropyLoss',
+   'use_sigmoid': False,
+   'loss_weight': 1.0}}}
+```
+
+The `_delete_=True` would replace all old keys in `backbone` field with new keys.
+
+### Use intermediate variables in configs
+
+Some intermediate variables are used in the configs files, like `train_pipeline`/`test_pipeline` in datasets.
+It's worth noting that when modifying intermediate variables in the children configs, user need to pass the intermediate variables into corresponding fields again.
+For example, we would like to change multi scale strategy to train/test a PSPNet. `train_pipeline`/`test_pipeline` are intermediate variable we would like to modify.
+
+```python
+_base_ = '../pspnet/pspnet_r50-d8_4xb4-40k_cityscpaes-512x1024.py'
+crop_size = (512, 1024)
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='RandomResize',
+         img_scale=(2048, 1024),
+         ratio_range=(1., 2.),
+         keep_ration=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', flip_ratio=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs'),
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize',
+        scale=(2048, 1024),
+        keep_ratio=True),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='leftImg8bit/train', seg_map_path='gtFine/train'),
+        pipeline=train_pipeline)
+test_dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='leftImg8bit/val', seg_map_path='gtFine/val'),
+        pipeline=test_pipeline)
+train_dataloader = dict(dataset=train_dataset)
+val_dataloader = dict(dataset=test_dataset)
+test_dataloader = val_dataloader
+```
+
+We first define the new `train_pipeline`/`test_pipeline` and pass them into `dataset`.
+
+Similarly, if we would like to switch from `SyncBN` to `BN` or `MMSyncBN`, we need to substitute every `norm_cfg` in the config.
+
+```python
+_base_ = '../pspnet/pspnet_r50-d8_4xb4-40k_cityscpaes-512x1024.py'
+norm_cfg = dict(type='BN', requires_grad=True)
+model = dict(
+    backbone=dict(norm_cfg=norm_cfg),
+    decode_head=dict(norm_cfg=norm_cfg),
+    auxiliary_head=dict(norm_cfg=norm_cfg))
+```
+
+## Modify config through script arguments
+
+In the [training script](https://github.com/open-mmlab/mmsegmentation/blob/1.x/tools/train.py) and the [testing script](https://github.com/open-mmlab/mmsegmentation/blob/1.x/tools/test.py), we support the script argument `--cfg-options`, it may help users override some settings in the used config, the key-value pair in `xxx=yyy` format will be merged into config file.
+
+For example, this is a simplified script `demo_script.py`:
+
+```python
+import argparse
+
+from mmengine.config import Config, DictAction
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Script Example')
+    parser.add_argument('config', help='train config file path')
+    parser.add_argument(
+        '--cfg-options',
+        nargs='+',
+        action=DictAction,
+        help='override some settings in the used config, the key-value pair '
+        'in xxx=yyy format will be merged into config file. If the value to '
+        'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
+        'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
+        'Note that the quotation marks are necessary and that no white space '
+        'is allowed.')
+    args = parser.parse_args()
+    return args
+
+def main():
+    args = parse_args()
+
+    cfg = Config.fromfile(args.config)
+    if args.cfg_options is not None:
+        cfg.merge_from_dict(args.cfg_options)
+
+    print(cfg)
+
+if __name__ == '__main__':
+    main()
+```
+
+An example config file `demo_config.py` as follows:
+
+```python
+backbone = dict(
+    type='ResNetV1c',
+    depth=50,
+    num_stages=4,
+    out_indices=(0, 1, 2, 3),
+    dilations=(1, 1, 2, 4),
+    strides=(1, 2, 1, 1),
+    norm_eval=False,
+    style='pytorch',
+    contract_dilation=True)
+```
+
+Run `demo_script.py`:
+
+```shell
+python demo_script.py demo_config.py
+```
+
+```shell
+Config (path: demo_config.py): {'backbone': {'type': 'ResNetV1c', 'depth': 50, 'num_stages': 4, 'out_indices': (0, 1, 2, 3), 'dilations': (1, 1, 2, 4), 'strides': (1, 2, 1, 1), 'norm_eval': False, 'style': 'pytorch', 'contract_dilation': True}}
+```
+
+Modify config through script arguments:
+
+```shell
+python demo_script.py demo_config.py --cfg-options backbone.depth=101
+```
+
+```shell
+Config (path: demo_config.py): {'backbone': {'type': 'ResNetV1c', 'depth': 101, 'num_stages': 4, 'out_indices': (0, 1, 2, 3), 'dilations': (1, 1, 2, 4), 'strides': (1, 2, 1, 1), 'norm_eval': False, 'style': 'pytorch', 'contract_dilation': True}}
+```
+
+- Update values of list/tuples.
+
+  If the value to be updated is a list or a tuple. For example, the config file `demo_config.py` sets `strides=(1, 2, 1, 1)` in `backbone`.
+  If you want to change this key, you may specify in two ways:
+
+  1. `--cfg-options backbone.strides="(1, 1, 1, 1)"`. Note that the quotation mark " is necessary to support list/tuple data types.
+
+     ```shell
+     python demo_script.py demo_config.py --cfg-options backbone.strides="(1, 1, 1, 1)"
+     ```
+
+     ```shell
+     Config (path: demo_config.py): {'backbone': {'type': 'ResNetV1c', 'depth': 50, 'num_stages': 4, 'out_indices': (0, 1, 2, 3), 'dilations': (1, 1, 2, 4), 'strides': (1, 1, 1, 1), 'norm_eval': False, 'style': 'pytorch', 'contract_dilation': True}}
+     ```
+
+  2. `--cfg-options backbone.strides=1,1,1,1`. Note that **NO** white space is allowed in the specified value.
+     In addition, if the original type is tuple, it will be automatically converted to list after this way.
+
+     ```shell
+     python demo_script.py demo_config.py --cfg-options backbone.strides=1,1,1,1
+     ```
+
+     ```shell
+     Config (path: demo_config.py): {'backbone': {'type': 'ResNetV1c', 'depth': 50, 'num_stages': 4, 'out_indices': (0, 1, 2, 3), 'dilations': (1, 1, 2, 4), 'strides': [1, 1, 1, 1], 'norm_eval': False, 'style': 'pytorch', 'contract_dilation': True}}
+     ```
+
+```{note}
+    This modification method only supports modifying configuration items of string, int, float, boolean, None, list and tuple types.
+    More specifically, for list and tuple types, the elements inside them must also be one of the above seven types.
+```
diff --git a/mmsegmentation/docs/en/user_guides/2_dataset_prepare.md b/mmsegmentation/docs/en/user_guides/2_dataset_prepare.md
new file mode 100644
index 0000000..3f94a94
--- /dev/null
+++ b/mmsegmentation/docs/en/user_guides/2_dataset_prepare.md
@@ -0,0 +1,806 @@
+# Tutorial 2: Prepare datasets
+
+It is recommended to symlink the dataset root to `$MMSEGMENTATION/data`.
+If your folder structure is different, you may need to change the corresponding paths in config files.
+For users in China, we also recommend you get the dsdl dataset from our opensource platform [OpenDataLab](https://opendatalab.com/), for better download and use experience，here is an example: [DSDLReadme](../../../configs/dsdl/README.md)， welcome to try.
+
+```none
+mmsegmentation
+├── mmseg
+├── tools
+├── configs
+├── data
+│   ├── cityscapes
+│   │   ├── leftImg8bit
+│   │   │   ├── train
+│   │   │   ├── val
+│   │   ├── gtFine
+│   │   │   ├── train
+│   │   │   ├── val
+│   ├── VOCdevkit
+│   │   ├── VOC2012
+│   │   │   ├── JPEGImages
+│   │   │   ├── SegmentationClass
+│   │   │   ├── ImageSets
+│   │   │   │   ├── Segmentation
+│   │   ├── VOC2010
+│   │   │   ├── JPEGImages
+│   │   │   ├── SegmentationClassContext
+│   │   │   ├── ImageSets
+│   │   │   │   ├── SegmentationContext
+│   │   │   │   │   ├── train.txt
+│   │   │   │   │   ├── val.txt
+│   │   │   ├── trainval_merged.json
+│   │   ├── VOCaug
+│   │   │   ├── dataset
+│   │   │   │   ├── cls
+│   ├── ade
+│   │   ├── ADEChallengeData2016
+│   │   │   ├── annotations
+│   │   │   │   ├── training
+│   │   │   │   ├── validation
+│   │   │   ├── images
+│   │   │   │   ├── training
+│   │   │   │   ├── validation
+│   ├── coco_stuff10k
+│   │   ├── images
+│   │   │   ├── train2014
+│   │   │   ├── test2014
+│   │   ├── annotations
+│   │   │   ├── train2014
+│   │   │   ├── test2014
+│   │   ├── imagesLists
+│   │   │   ├── train.txt
+│   │   │   ├── test.txt
+│   │   │   ├── all.txt
+│   ├── coco_stuff164k
+│   │   ├── images
+│   │   │   ├── train2017
+│   │   │   ├── val2017
+│   │   ├── annotations
+│   │   │   ├── train2017
+│   │   │   ├── val2017
+│   ├── CHASE_DB1
+│   │   ├── images
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   ├── annotations
+│   │   │   ├── training
+│   │   │   ├── validation
+│   ├── DRIVE
+│   │   ├── images
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   ├── annotations
+│   │   │   ├── training
+│   │   │   ├── validation
+│   ├── HRF
+│   │   ├── images
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   ├── annotations
+│   │   │   ├── training
+│   │   │   ├── validation
+│   ├── STARE
+│   │   ├── images
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   ├── annotations
+│   │   │   ├── training
+│   │   │   ├── validation
+|   ├── dark_zurich
+|   │   ├── gps
+|   │   │   ├── val
+|   │   │   └── val_ref
+|   │   ├── gt
+|   │   │   └── val
+|   │   ├── LICENSE.txt
+|   │   ├── lists_file_names
+|   │   │   ├── val_filenames.txt
+|   │   │   └── val_ref_filenames.txt
+|   │   ├── README.md
+|   │   └── rgb_anon
+|   │   |   ├── val
+|   │   |   └── val_ref
+|   ├── NighttimeDrivingTest
+|   |   ├── gtCoarse_daytime_trainvaltest
+|   |   │   └── test
+|   |   │       └── night
+|   |   └── leftImg8bit
+|   |   |   └── test
+|   |   |       └── night
+│   ├── loveDA
+│   │   ├── img_dir
+│   │   │   ├── train
+│   │   │   ├── val
+│   │   │   ├── test
+│   │   ├── ann_dir
+│   │   │   ├── train
+│   │   │   ├── val
+│   ├── potsdam
+│   │   ├── img_dir
+│   │   │   ├── train
+│   │   │   ├── val
+│   │   ├── ann_dir
+│   │   │   ├── train
+│   │   │   ├── val
+│   ├── vaihingen
+│   │   ├── img_dir
+│   │   │   ├── train
+│   │   │   ├── val
+│   │   ├── ann_dir
+│   │   │   ├── train
+│   │   │   ├── val
+│   ├── iSAID
+│   │   ├── img_dir
+│   │   │   ├── train
+│   │   │   ├── val
+│   │   │   ├── test
+│   │   ├── ann_dir
+│   │   │   ├── train
+│   │   │   ├── val
+│   ├── synapse
+│   │   ├── img_dir
+│   │   │   ├── train
+│   │   │   ├── val
+│   │   ├── ann_dir
+│   │   │   ├── train
+│   │   │   ├── val
+│   ├── REFUGE
+│   │   ├── images
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   │   ├── test
+│   │   ├── annotations
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   │   ├── test
+│   ├── mapillary
+│   │   ├── training
+│   │   │   ├── images
+│   │   │   ├── v1.2
+|   │   │   │   ├── instances
+|   │   │   │   ├── labels
+|   │   │   │   └── panoptic
+│   │   │   ├── v2.0
+|   │   │   │   ├── instances
+|   │   │   │   ├── labels
+|   │   │   │   ├── panoptic
+|   │   │   │   └── polygons
+│   │   ├── validation
+│   │   │   ├── images
+|   │   │   ├── v1.2
+|   │   │   │   ├── instances
+|   │   │   │   ├── labels
+|   │   │   │   └── panoptic
+│   │   │   ├── v2.0
+|   │   │   │   ├── instances
+|   │   │   │   ├── labels
+|   │   │   │   ├── panoptic
+|   │   │   │   └── polygons
+│   ├── bdd100k
+│   │   ├── images
+│   │   │   └── 10k
+|   │   │   │   ├── test
+|   │   │   │   ├── train
+|   │   │   │   └── val
+│   │   └── labels
+│   │   │   └── sem_seg
+|   │   │   │   ├── colormaps
+|   │   │   │   │   ├──train
+|   │   │   │   │   └──val
+|   │   │   │   ├── masks
+|   │   │   │   │   ├──train
+|   │   │   │   │   └──val
+|   │   │   │   ├── polygons
+|   │   │   │   │   ├──sem_seg_train.json
+|   │   │   │   │   └──sem_seg_val.json
+|   │   │   │   └── rles
+|   │   │   │   │   ├──sem_seg_train.json
+|   │   │   │   │   └──sem_seg_val.json
+│   ├── nyu
+│   │   ├── images
+│   │   │   ├── train
+│   │   │   ├── test
+│   │   ├── annotations
+│   │   │   ├── train
+│   │   │   ├── test
+│   ├── HSIDrive20
+│   │   ├── images
+│   │   │   ├── train
+│   │   │   ├── validation
+│   │   │   ├── test
+│   │   ├── annotations
+│   │   │   ├── train
+│   │   │   ├── validation
+│   │   │   ├── test
+```
+
+## Download dataset via MIM
+
+By using [OpenXLab](https://openxlab.org.cn/datasets), you can obtain free formatted datasets in various fields. Through the search function of the platform, you may address the dataset they look for quickly and easily. Using the formatted datasets from the platform, you can efficiently conduct tasks across datasets.
+
+If you use MIM to download, make sure that the version is greater than v0.3.8. You can use the following command to update, install, login and download the dataset:
+
+```shell
+# upgrade your MIM
+pip install -U openmim
+
+# install OpenXLab CLI tools
+pip install -U openxlab
+# log in OpenXLab
+openxlab login
+
+# download ADE20K by MIM
+mim download mmsegmentation --dataset ade20k
+```
+
+## Cityscapes
+
+The data could be found [here](https://www.cityscapes-dataset.com/downloads/) after registration.
+
+By convention, `**labelTrainIds.png` are used for cityscapes training.
+We provided a [script](https://github.com/open-mmlab/mmsegmentation/blob/1.x/tools/dataset_converters/cityscapes.py) based on [cityscapesscripts](https://github.com/mcordts/cityscapesScripts)to generate `**labelTrainIds.png`.
+
+```shell
+# --nproc means 8 process for conversion, which could be omitted as well.
+python tools/dataset_converters/cityscapes.py data/cityscapes --nproc 8
+```
+
+## Pascal VOC
+
+Pascal VOC 2012 could be downloaded from [here](http://host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCtrainval_11-May-2012.tar).
+Beside, most recent works on Pascal VOC dataset usually exploit extra augmentation data, which could be found [here](http://www.eecs.berkeley.edu/Research/Projects/CS/vision/grouping/semantic_contours/benchmark.tgz).
+
+If you would like to use augmented VOC dataset, please run following command to convert augmentation annotations into proper format.
+
+```shell
+# --nproc means 8 process for conversion, which could be omitted as well.
+python tools/dataset_converters/voc_aug.py data/VOCdevkit data/VOCdevkit/VOCaug --nproc 8
+```
+
+Please refer to [concat dataset](../advanced_guides/add_datasets.md#concatenate-dataset) and [voc_aug config example](../../../configs/_base_/datasets/pascal_voc12_aug.py) for details about how to concatenate them and train them together.
+
+## ADE20K
+
+The training and validation set of ADE20K could be download from this [link](http://data.csail.mit.edu/places/ADEchallenge/ADEChallengeData2016.zip).
+We may also download test set from [here](http://data.csail.mit.edu/places/ADEchallenge/release_test.zip).
+
+## Pascal Context
+
+The training and validation set of Pascal Context could be download from [here](http://host.robots.ox.ac.uk/pascal/VOC/voc2010/VOCtrainval_03-May-2010.tar). You may also download test set from [here](http://host.robots.ox.ac.uk:8080/eval/downloads/VOC2010test.tar) after registration.
+
+To split the training and validation set from original dataset, you may download trainval_merged.json from [here](https://codalabuser.blob.core.windows.net/public/trainval_merged.json).
+
+If you would like to use Pascal Context dataset, please install [Detail](https://github.com/zhanghang1989/detail-api) and then run the following command to convert annotations into proper format.
+
+```shell
+python tools/dataset_converters/pascal_context.py data/VOCdevkit data/VOCdevkit/VOC2010/trainval_merged.json
+```
+
+## COCO Stuff 10k
+
+The data could be downloaded [here](http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/cocostuff-10k-v1.1.zip) by wget.
+
+For COCO Stuff 10k dataset, please run the following commands to download and convert the dataset.
+
+```shell
+# download
+mkdir coco_stuff10k && cd coco_stuff10k
+wget http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/cocostuff-10k-v1.1.zip
+
+# unzip
+unzip cocostuff-10k-v1.1.zip
+
+# --nproc means 8 process for conversion, which could be omitted as well.
+python tools/dataset_converters/coco_stuff10k.py /path/to/coco_stuff10k --nproc 8
+```
+
+By convention, mask labels in `/path/to/coco_stuff164k/annotations/*2014/*_labelTrainIds.png` are used for COCO Stuff 10k training and testing.
+
+## COCO Stuff 164k
+
+For COCO Stuff 164k dataset, please run the following commands to download and convert the augmented dataset.
+
+```shell
+# download
+mkdir coco_stuff164k && cd coco_stuff164k
+wget http://images.cocodataset.org/zips/train2017.zip
+wget http://images.cocodataset.org/zips/val2017.zip
+wget http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/stuffthingmaps_trainval2017.zip
+
+# unzip
+unzip train2017.zip -d images/
+unzip val2017.zip -d images/
+unzip stuffthingmaps_trainval2017.zip -d annotations/
+
+# --nproc means 8 process for conversion, which could be omitted as well.
+python tools/dataset_converters/coco_stuff164k.py /path/to/coco_stuff164k --nproc 8
+```
+
+By convention, mask labels in `/path/to/coco_stuff164k/annotations/*2017/*_labelTrainIds.png` are used for COCO Stuff 164k training and testing.
+
+The details of this dataset could be found at [here](https://github.com/nightrome/cocostuff#downloads).
+
+## CHASE DB1
+
+The training and validation set of CHASE DB1 could be download from [here](https://staffnet.kingston.ac.uk/~ku15565/CHASE_DB1/assets/CHASEDB1.zip).
+
+To convert CHASE DB1 dataset to MMSegmentation format, you should run the following command:
+
+```shell
+python tools/dataset_converters/chase_db1.py /path/to/CHASEDB1.zip
+```
+
+The script will make directory structure automatically.
+
+## DRIVE
+
+The training and validation set of DRIVE could be download from [here](https://drive.grand-challenge.org/). Before that, you should register an account. Currently '1st_manual' is not provided officially.
+
+To convert DRIVE dataset to MMSegmentation format, you should run the following command:
+
+```shell
+python tools/dataset_converters/drive.py /path/to/training.zip /path/to/test.zip
+```
+
+The script will make directory structure automatically.
+
+## HRF
+
+First, download [healthy.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/healthy.zip), [glaucoma.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/glaucoma.zip), [diabetic_retinopathy.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/diabetic_retinopathy.zip), [healthy_manualsegm.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/healthy_manualsegm.zip), [glaucoma_manualsegm.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/glaucoma_manualsegm.zip) and [diabetic_retinopathy_manualsegm.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/diabetic_retinopathy_manualsegm.zip).
+
+To convert HRF dataset to MMSegmentation format, you should run the following command:
+
+```shell
+python tools/dataset_converters/hrf.py /path/to/healthy.zip /path/to/healthy_manualsegm.zip /path/to/glaucoma.zip /path/to/glaucoma_manualsegm.zip /path/to/diabetic_retinopathy.zip /path/to/diabetic_retinopathy_manualsegm.zip
+```
+
+The script will make directory structure automatically.
+
+## STARE
+
+First, download [stare-images.tar](http://cecas.clemson.edu/~ahoover/stare/probing/stare-images.tar), [labels-ah.tar](http://cecas.clemson.edu/~ahoover/stare/probing/labels-ah.tar) and [labels-vk.tar](http://cecas.clemson.edu/~ahoover/stare/probing/labels-vk.tar).
+
+To convert STARE dataset to MMSegmentation format, you should run the following command:
+
+```shell
+python tools/dataset_converters/stare.py /path/to/stare-images.tar /path/to/labels-ah.tar /path/to/labels-vk.tar
+```
+
+The script will make directory structure automatically.
+
+## Dark Zurich
+
+Since we only support test models on this dataset, you may only download [the validation set](https://data.vision.ee.ethz.ch/csakarid/shared/GCMA_UIoU/Dark_Zurich_val_anon.zip).
+
+## Nighttime Driving
+
+Since we only support test models on this dataset, you may only download [the test set](http://data.vision.ee.ethz.ch/daid/NighttimeDriving/NighttimeDrivingTest.zip).
+
+## LoveDA
+
+The data could be downloaded from Google Drive [here](https://drive.google.com/drive/folders/1ibYV0qwn4yuuh068Rnc-w4tPi0U0c-ti?usp=sharing).
+
+Or it can be downloaded from [zenodo](https://zenodo.org/record/5706578#.YZvN7SYRXdF), you should run the following command:
+
+```shell
+# Download Train.zip
+wget https://zenodo.org/record/5706578/files/Train.zip
+# Download Val.zip
+wget https://zenodo.org/record/5706578/files/Val.zip
+# Download Test.zip
+wget https://zenodo.org/record/5706578/files/Test.zip
+```
+
+For LoveDA dataset, please run the following command to re-organize the dataset.
+
+```shell
+python tools/dataset_converters/loveda.py /path/to/loveDA
+```
+
+Using trained model to predict test set of LoveDA and submit it to server can be found [here](https://codalab.lisn.upsaclay.fr/competitions/421).
+
+More details about LoveDA can be found [here](https://github.com/Junjue-Wang/LoveDA).
+
+## ISPRS Potsdam
+
+The [Potsdam](https://www.isprs.org/education/benchmarks/UrbanSemLab/2d-sem-label-potsdam.aspx) dataset is for urban semantic segmentation used in the 2D Semantic Labeling Contest - Potsdam.
+
+The dataset can be requested at the challenge [homepage](https://www.isprs.org/education/benchmarks/UrbanSemLab/default.aspx).
+Or download on [BaiduNetdisk](https://pan.baidu.com/s/1K-cLVZnd1X7d8c26FQ-nGg?pwd=mseg)，password：mseg, [Google Drive](https://drive.google.com/drive/folders/1w3EJuyUGet6_qmLwGAWZ9vw5ogeG0zLz?usp=sharing) and [OpenDataLab](https://opendatalab.com/ISPRS_Potsdam/download).
+The '2_Ortho_RGB.zip' and '5_Labels_all_noBoundary.zip' are required.
+
+For Potsdam dataset, please run the following command to re-organize the dataset.
+
+```shell
+python tools/dataset_converters/potsdam.py /path/to/potsdam
+```
+
+In our default setting, it will generate 3456 images for training and 2016 images for validation.
+
+## ISPRS Vaihingen
+
+The [Vaihingen](https://www2.isprs.org/commissions/comm2/wg4/benchmark/2d-sem-label-vaihingen/) dataset is for urban semantic segmentation used in the 2D Semantic Labeling Contest - Vaihingen.
+
+The dataset can be requested at the challenge [homepage](https://www2.isprs.org/commissions/comm2/wg4/benchmark/data-request-form/).
+Or [BaiduNetdisk](https://pan.baidu.com/s/109D3WLrLafsuYtLeerLiiA?pwd=mseg)，password：mseg, [Google Drive](https://drive.google.com/drive/folders/1w3NhvLVA2myVZqOn2pbiDXngNC7NTP_t?usp=sharing).
+The 'ISPRS_semantic_labeling_Vaihingen.zip' and 'ISPRS_semantic_labeling_Vaihingen_ground_truth_eroded_COMPLETE.zip' are required.
+
+For Vaihingen dataset, please run the following command to re-organize the dataset.
+
+```shell
+python tools/dataset_converters/vaihingen.py /path/to/vaihingen
+```
+
+In our default setting (`clip_size`=512, `stride_size`=256), it will generate 344 images for training and 398 images for validation.
+
+## iSAID
+
+The data images could be download from [DOTA-v1.0](https://captain-whu.github.io/DOTA/dataset.html) (train/val/test)
+
+The data annotations could be download from [iSAID](https://captain-whu.github.io/iSAID/dataset.html) (train/val)
+
+The dataset is a Large-scale Dataset for Instance Segmentation (also have semantic segmentation) in Aerial Images.
+
+You may need to follow the following structure for dataset preparation after downloading iSAID dataset.
+
+```none
+├── data
+│   ├── iSAID
+│   │   ├── train
+│   │   │   ├── images
+│   │   │   │   ├── part1.zip
+│   │   │   │   ├── part2.zip
+│   │   │   │   ├── part3.zip
+│   │   │   ├── Semantic_masks
+│   │   │   │   ├── images.zip
+│   │   ├── val
+│   │   │   ├── images
+│   │   │   │   ├── part1.zip
+│   │   │   ├── Semantic_masks
+│   │   │   │   ├── images.zip
+│   │   ├── test
+│   │   │   ├── images
+│   │   │   │   ├── part1.zip
+│   │   │   │   ├── part2.zip
+```
+
+```shell
+python tools/dataset_converters/isaid.py /path/to/iSAID
+```
+
+In our default setting (`patch_width`=896, `patch_height`=896, `overlap_area`=384), it will generate 33978 images for training and 11644 images for validation.
+
+## LIP(Look Into Person) dataset
+
+This dataset could be download from [this page](https://lip.sysuhcp.com/overview.php).
+
+Please run the following commands to unzip dataset.
+
+```shell
+unzip LIP.zip
+cd LIP
+unzip TrainVal_images.zip
+unzip TrainVal_parsing_annotations.zip
+cd TrainVal_parsing_annotations
+unzip TrainVal_parsing_annotations.zip
+mv train_segmentations ../
+mv val_segmentations ../
+cd ..
+```
+
+The contents of LIP datasets include:
+
+```none
+├── data
+│   ├── LIP
+│   │   ├── train_images
+│   │   │   ├── 1000_1234574.jpg
+│   │   │   ├── ...
+│   │   ├── train_segmentations
+│   │   │   ├── 1000_1234574.png
+│   │   │   ├── ...
+│   │   ├── val_images
+│   │   │   ├── 100034_483681.jpg
+│   │   │   ├── ...
+│   │   ├── val_segmentations
+│   │   │   ├── 100034_483681.png
+│   │   │   ├── ...
+```
+
+## Synapse dataset
+
+This dataset could be download from [this page](https://www.synapse.org/#!Synapse:syn3193805/wiki/).
+
+To follow the data preparation setting of [TransUNet](https://arxiv.org/abs/2102.04306), which splits original training set (30 scans) into new training (18 scans) and validation set (12 scans). Please run the following command to prepare the dataset.
+
+```shell
+unzip RawData.zip
+cd ./RawData/Training
+```
+
+Then create `train.txt` and `val.txt` to split dataset.
+
+According to TransUnet, the following is the data set division.
+
+train.txt
+
+```none
+img0005.nii.gz
+img0006.nii.gz
+img0007.nii.gz
+img0009.nii.gz
+img0010.nii.gz
+img0021.nii.gz
+img0023.nii.gz
+img0024.nii.gz
+img0026.nii.gz
+img0027.nii.gz
+img0028.nii.gz
+img0030.nii.gz
+img0031.nii.gz
+img0033.nii.gz
+img0034.nii.gz
+img0037.nii.gz
+img0039.nii.gz
+img0040.nii.gz
+```
+
+val.txt
+
+```none
+img0008.nii.gz
+img0022.nii.gz
+img0038.nii.gz
+img0036.nii.gz
+img0032.nii.gz
+img0002.nii.gz
+img0029.nii.gz
+img0003.nii.gz
+img0001.nii.gz
+img0004.nii.gz
+img0025.nii.gz
+img0035.nii.gz
+```
+
+The contents of synapse datasets include:
+
+```none
+├── Training
+│   ├── img
+│   │   ├── img0001.nii.gz
+│   │   ├── img0002.nii.gz
+│   │   ├── ...
+│   ├── label
+│   │   ├── label0001.nii.gz
+│   │   ├── label0002.nii.gz
+│   │   ├── ...
+│   ├── train.txt
+│   ├── val.txt
+```
+
+Then, use this command to convert synapse dataset.
+
+```shell
+python tools/dataset_converters/synapse.py --dataset-path /path/to/synapse
+```
+
+Noted that MMSegmentation default evaluation metric (such as mean dice value) is calculated on 2D slice image, which is not comparable to results of 3D scan in some paper such as [TransUNet](https://arxiv.org/abs/2102.04306).
+
+## REFUGE
+
+Register in [REFUGE Challenge](https://refuge.grand-challenge.org) and download [REFUGE dataset](https://refuge.grand-challenge.org/REFUGE2Download).
+
+Then, unzip `REFUGE2.zip` and the contents of original datasets include:
+
+```none
+├── REFUGE2
+│   ├── REFUGE2
+│   │   ├── Annotation-Training400.zip
+│   │   ├── REFUGE-Test400.zip
+│   │   ├── REFUGE-Test-GT.zip
+│   │   ├── REFUGE-Training400.zip
+│   │   ├── REFUGE-Validation400.zip
+│   │   ├── REFUGE-Validation400-GT.zip
+│   ├── __MACOSX
+```
+
+Please run the following command to convert REFUGE dataset:
+
+```shell
+python tools/convert_datasets/refuge.py --raw_data_root=/path/to/refuge/REFUGE2/REFUGE2
+```
+
+The script will make directory structure below:
+
+```none
+│   ├── REFUGE
+│   │   ├── images
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   │   ├── test
+│   │   ├── annotations
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   │   ├── test
+```
+
+It includes 400 images for training, 400 images for validation and 400 images for testing which is the same as REFUGE 2018 dataset.
+
+## Mapillary Vistas Datasets
+
+- The dataset could be download [here](https://www.mapillary.com/dataset/vistas) after registration.
+
+- Mapillary Vistas Dataset use 8-bit with color-palette to store labels. No conversion operation is required.
+
+- Assumption you have put the dataset zip file in `mmsegmentation/data/mapillary`
+
+- Please run the following commands to unzip dataset.
+
+  ```bash
+  cd data/mapillary
+  unzip An-ZjB1Zm61yAZG0ozTymz8I8NqI4x0MrYrh26dq7kPgfu8vf9ImrdaOAVOFYbJ2pNAgUnVGBmbue9lTgdBOb5BbKXIpFs0fpYWqACbrQDChAA2fdX0zS9PcHu7fY8c-FOvyBVxPNYNFQuM.zip
+  ```
+
+- After unzip, you will get Mapillary Vistas Dataset like this structure. Semantic segmentation mask labels in `labels` folder.
+
+  ```none
+  mmsegmentation
+  ├── mmseg
+  ├── tools
+  ├── configs
+  ├── data
+  │   ├── mapillary
+  │   │   ├── training
+  │   │   │   ├── images
+  │   │   │   ├── v1.2
+  |   │   │   │   ├── instances
+  |   │   │   │   ├── labels
+  |   │   │   │   └── panoptic
+  │   │   │   ├── v2.0
+  |   │   │   │   ├── instances
+  |   │   │   │   ├── labels
+  |   │   │   │   ├── panoptic
+  |   │   │   │   └── polygons
+  │   │   ├── validation
+  │   │   │   ├── images
+  |   │   │   ├── v1.2
+  |   │   │   │   ├── instances
+  |   │   │   │   ├── labels
+  |   │   │   │   └── panoptic
+  │   │   │   ├── v2.0
+  |   │   │   │   ├── instances
+  |   │   │   │   ├── labels
+  |   │   │   │   ├── panoptic
+  |   │   │   │   └── polygons
+  ```
+
+- You could set Datasets version with `MapillaryDataset_v1` and `MapillaryDataset_v2` in your configs.
+  View the Mapillary Vistas Datasets config file here [V1.2](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/_base_/datasets/mapillary_v1.py) and [V2.0](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/_base_/datasets/mapillary_v2.py)
+
+## LEVIR-CD
+
+[LEVIR-CD](https://justchenhao.github.io/LEVIR/) Large-scale Remote Sensing Change Detection Dataset for Building.
+
+Download the dataset from [here](https://justchenhao.github.io/LEVIR/).
+
+The supplement version of the dataset can be requested on the [homepage](https://github.com/S2Looking/Dataset)
+
+Please download the supplement version of the dataset, then unzip `LEVIR-CD+.zip`, the contents of original datasets include:
+
+```none
+│   ├── LEVIR-CD+
+│   │   ├── train
+│   │   │   ├── A
+│   │   │   ├── B
+│   │   │   ├── label
+│   │   ├── test
+│   │   │   ├── A
+│   │   │   ├── B
+│   │   │   ├── label
+```
+
+For LEVIR-CD dataset, please run the following command to crop images without overlap:
+
+```shell
+python tools/dataset_converters/levircd.py --dataset-path /path/to/LEVIR-CD+ --out_dir /path/to/LEVIR-CD
+```
+
+The size of cropped image is 256x256, which is consistent with the original paper.
+
+## BDD100K
+
+- You could download BDD100k datasets from  [here](https://bdd-data.berkeley.edu/) after  registration.
+
+- You can download images and masks by clicking  `10K Images` button and `Segmentation` button.
+
+- After download, unzip by the following instructions:
+
+  ```bash
+  unzip ~/bdd100k_images_10k.zip -d ~/mmsegmentation/data/
+  unzip ~/bdd100k_sem_seg_labels_trainval.zip -d ~/mmsegmentation/data/
+  ```
+
+- And get
+
+```none
+mmsegmentation
+├── mmseg
+├── tools
+├── configs
+├── data
+│   ├── bdd100k
+│   │   ├── images
+│   │   │   └── 10k
+|   │   │   │   ├── test
+|   │   │   │   ├── train
+|   │   │   │   └── val
+│   │   └── labels
+│   │   │   └── sem_seg
+|   │   │   │   ├── colormaps
+|   │   │   │   │   ├──train
+|   │   │   │   │   └──val
+|   │   │   │   ├── masks
+|   │   │   │   │   ├──train
+|   │   │   │   │   └──val
+|   │   │   │   ├── polygons
+|   │   │   │   │   ├──sem_seg_train.json
+|   │   │   │   │   └──sem_seg_val.json
+|   │   │   │   └── rles
+|   │   │   │   │   ├──sem_seg_train.json
+|   │   │   │   │   └──sem_seg_val.json
+```
+
+## NYU
+
+- To access the NYU dataset, you can download it from [this link](https://drive.google.com/file/d/1wC-io-14RCIL4XTUrQLk6lBqU2AexLVp/view?usp=share_link)
+
+- Once the download is complete, you can utilize the [tools/dataset_converters/nyu.py](/tools/dataset_converters/nyu.py) script to extract and organize the data into the required format. Run the following command in your terminal:
+
+  ```bash
+  python tools/dataset_converters/nyu.py nyu.zip
+  ```
+
+## HSI Drive 2.0
+
+- You could download HSI Drive 2.0 dataset from [here](https://ipaccess.ehu.eus/HSI-Drive/#download) after just sending an email to gded@ehu.eus with the subject "download HSI-Drive". You will receive a password to uncompress the files.
+
+- After download, unzip by the following instructions:
+
+  ```bash
+  7z x -p"password" ./HSI_Drive_v2_0_Phyton.zip
+
+  mv ./HSIDrive20 path_to_mmsegmentation/data
+  mv ./HSI_Drive_v2_0_release_notes_Python_version.md path_to_mmsegmentation/data
+  mv ./image_numbering.pdf path_to_mmsegmentation/data
+  ```
+
+- After unzip, you get
+
+```none
+mmsegmentation
+├── mmseg
+├── tools
+├── configs
+├── data
+│   ├── HSIDrive20
+│   │   ├── images
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   │   ├── test
+│   │   ├── annotations
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   │   ├── test
+│   │   ├── images_MF
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   │   ├── test
+│   │   ├── RGB
+│   │   ├── training_filenames.txt
+│   │   ├── validation_filenames.txt
+│   │   ├── test_filenames.txt
+│   ├── HSI_Drive_v2_0_release_notes_Python_version.md
+│   ├── image_numbering.pdf
+```
diff --git a/mmsegmentation/docs/en/user_guides/3_inference.md b/mmsegmentation/docs/en/user_guides/3_inference.md
new file mode 100644
index 0000000..cacebd2
--- /dev/null
+++ b/mmsegmentation/docs/en/user_guides/3_inference.md
@@ -0,0 +1,244 @@
+# Tutorial 3: Inference with existing models
+
+MMSegmentation provides pre-trained models for semantic segmentation in [Model Zoo](../model_zoo.md), and supports multiple standard datasets, including Cityscapes, ADE20K, etc.
+This note will show how to use existing models to inference on given images.
+As for how to test existing models on standard datasets, please see this [guide](./4_train_test.md)
+
+MMSegmentation provides several interfaces for users to easily use pre-trained models for inference.
+
+- [Tutorial 3: Inference with existing models](#tutorial-3-inference-with-existing-models)
+  - [Inferencer](#inferencer)
+    - [Basic Usage](#basic-usage)
+    - [Initialization](#initialization)
+    - [Visualize prediction](#visualize-prediction)
+    - [List model](#list-model)
+  - [Inference API](#inference-api)
+    - [mmseg.apis.init_model](#mmsegapisinit_model)
+    - [mmseg.apis.inference_model](#mmsegapisinference_model)
+    - [mmseg.apis.show_result_pyplot](#mmsegapisshow_result_pyplot)
+
+## Inferencer
+
+We provide the most **convenient** way to use the model in MMSegmentation `MMSegInferencer`. You can get segmentation mask for an image with only 3 lines of code.
+
+### Basic Usage
+
+The following example shows how to use `MMSegInferencer` to perform inference on a single image.
+
+```
+>>> from mmseg.apis import MMSegInferencer
+>>> # Load models into memory
+>>> inferencer = MMSegInferencer(model='deeplabv3plus_r18-d8_4xb2-80k_cityscapes-512x1024')
+>>> # Inference
+>>> inferencer('demo/demo.png', show=True)
+```
+
+The visualization result should look like:
+
+<div align="center">
+    <img src='https://user-images.githubusercontent.com/76149310/221507927-ae01e3a7-016f-4425-b966-7b19cbbe494e.png' />
+</div>
+
+Moreover, you can use `MMSegInferencer` to process a list of images:
+
+```
+# Input a list of images
+>>> images = [image1, image2, ...] # image1 can be a file path or a np.ndarray
+>>> inferencer(images, show=True, wait_time=0.5) # wait_time is delay time, and 0 means forever
+
+# Or input image directory
+>>> images = $IMAGESDIR
+>>> inferencer(images, show=True, wait_time=0.5)
+
+# Save visualized rendering color maps and predicted results
+# out_dir is the directory to save the output results, img_out_dir and pred_out_dir are subdirectories of out_dir
+# to save visualized rendering color maps and predicted results
+>>> inferencer(images, out_dir='outputs', img_out_dir='vis', pred_out_dir='pred')
+```
+
+There is a optional parameter of inferencer, `return_datasamples`, whose default value is False, and return value of inferencer is a `dict` type by default, including 2 keys 'visualization' and 'predictions'.
+If `return_datasamples=True` inferencer will return [`SegDataSample`](../advanced_guides/structures.md), or list of it.
+
+```
+result = inferencer('demo/demo.png')
+# result is a `dict` including 2 keys 'visualization' and 'predictions'
+# 'visualization' includes color segmentation map
+print(result['visualization'].shape)
+# (512, 683, 3)
+
+# 'predictions' includes segmentation mask with label indice
+print(result['predictions'].shape)
+# (512, 683)
+
+result = inferencer('demo/demo.png', return_datasamples=True)
+print(type(result))
+# <class 'mmseg.structures.seg_data_sample.SegDataSample'>
+
+# Input a list of images
+results = inferencer(images)
+# The output is list
+print(type(results['visualization']), results['visualization'][0].shape)
+# <class 'list'> (512, 683, 3)
+print(type(results['predictions']), results['predictions'][0].shape)
+# <class 'list'> (512, 683)
+
+results = inferencer(images, return_datasamples=True)
+# <class 'list'>
+print(type(results[0]))
+# <class 'mmseg.structures.seg_data_sample.SegDataSample'>
+```
+
+### Initialization
+
+`MMSegInferencer` must be initialized from a `model`, which can be a model name or a `Config` even a path of config file.
+The model names can be found in models' metafile (configs/xxx/metafile.yaml), like one model name of maskformer is `maskformer_r50-d32_8xb2-160k_ade20k-512x512`, and if input model name and the weights of the model will be download automatically. Below are other input parameters:
+
+- weights (str, optional) -  Path to the checkpoint. If it is not specified and model is a model name of metafile, the weights will be loaded from metafile. Defaults to None.
+- classes (list, optional) - Input classes for result rendering, as the prediction of segmentation model is a segment map with label indices, `classes` is a list which includes items responding to the label indices. If classes is not defined, visualizer will take `cityscapes` classes by default. Defaults to None.
+- palette (list, optional) - Input palette for result rendering, which is a list of colors responding to the classes. If the palette is not defined, the visualizer will take the palette of `cityscapes` by default. Defaults to None.
+- dataset_name (str, optional) - [Dataset name or alias](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/utils/class_names.py#L302-L317), visualizer will use the meta information of the dataset i.e. classes and palette, but the `classes` and `palette` have higher priority. Defaults to None.
+- device (str, optional) - Device to run inference. If None, the available device will be automatically used. Defaults to None.
+- scope (str, optional) - The scope of the model. Defaults to 'mmseg'.
+
+### Visualize prediction
+
+`MMSegInferencer` supports 4 parameters for visualize prediction, you can use them when call initialized inferencer:
+
+- show (bool) - Whether to display the image in a popup window. Defaults to False.
+- wait_time (float) - The interval of show (s). Defaults to 0.
+- img_out_dir (str) - Subdirectory of `out_dir`, used to save rendering color segmentation mask, so `out_dir` must be defined if you would like to save predicted mask. Defaults to 'vis'.
+- opacity (int, float) - The transparency of segmentation mask. Defaults to 0.8.
+
+The examples of these parameters is in [Basic Usage](#basic-usage)
+
+### List model
+
+There is a very easy to list all model names in MMSegmentation
+
+```
+>>> from mmseg.apis import MMSegInferencer
+# models is a list of model names, and them will print automatically
+>>> models = MMSegInferencer.list_models('mmseg')
+```
+
+## Inference API
+
+### mmseg.apis.init_model
+
+Initialize a segmentor from config file.
+
+Parameters:
+
+- config (str, `Path`, or `mmengine.Config`) - Config file path or the config object.
+- checkpoint (str, optional) - Checkpoint path. If left as None, the model will not load any weights.
+- device (str, optional) - CPU/CUDA device option. Default 'cuda:0'.
+- cfg_options (dict, optional) - Options to override some settings in the used config.
+
+Returns:
+
+- nn.Module: The constructed segmentor.
+
+Example:
+
+```python
+from mmseg.apis import init_model
+
+config_path = 'configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+checkpoint_path = 'checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
+
+# initialize model without checkpoint
+model = init_model(config_path)
+
+# init model and load checkpoint
+model = init_model(config_path, checkpoint_path)
+
+# init model and load checkpoint on CPU
+model = init_model(config_path, checkpoint_path, 'cpu')
+```
+
+### mmseg.apis.inference_model
+
+Inference image(s) with the segmentor.
+
+Parameters:
+
+- model (nn.Module) - The loaded segmentor
+- imgs (str, np.ndarray, or list\[str/np.ndarray\]) - Either image files or loaded images
+
+Returns:
+
+- `SegDataSample` or list\[`SegDataSample`\]: If imgs is a list or tuple, the same length list type results will be returned, otherwise return the segmentation results directly.
+
+**Note:** [SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py) is a data structure interface of MMSegmentation, it is used as interfaces between different components. `SegDataSample` implement the abstract data element `mmengine.structures.BaseDataElement`, please refer to data element [documentation](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/data_element.html) in [MMEngine](https://github.com/open-mmlab/mmengine) for more information.
+
+The attributes in `SegDataSample` are divided into several parts:
+
+- `gt_sem_seg` (`PixelData`) - Ground truth of semantic segmentation.
+- `pred_sem_seg` (`PixelData`) - Prediction of semantic segmentation.
+- `seg_logits` (`PixelData`) - Predicted logits of semantic segmentation.
+
+**Note** [PixelData](https://github.com/open-mmlab/mmengine/blob/main/mmengine/structures/pixel_data.py) is the data structure for pixel-level annotations or predictions, please refer to PixelData [documentation](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/data_element.html) in [MMEngine](https://github.com/open-mmlab/mmengine) for more information.
+
+Example:
+
+```python
+from mmseg.apis import init_model, inference_model
+
+config_path = 'configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+checkpoint_path = 'checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
+img_path = 'demo/demo.png'
+
+
+model = init_model(config_path, checkpoint_path)
+result = inference_model(model, img_path)
+```
+
+### mmseg.apis.show_result_pyplot
+
+Visualize the segmentation results on the image.
+
+Parameters:
+
+- model (nn.Module) - The loaded segmentor.
+- img (str or np.ndarray) - Image filename or loaded image.
+- result (`SegDataSample`) - The prediction SegDataSample result.
+- opacity (float) - Opacity of painted segmentation map. Default `0.5`, must be in `(0, 1]` range.
+- title (str) - The title of pyplot figure. Default is ''.
+- draw_gt (bool) - Whether to draw GT SegDataSample. Default to `True`.
+- draw_pred (draws_pred) - Whether to draw Prediction SegDataSample. Default to `True`.
+- wait_time (float) - The interval of show (s), 0 is the special value that means "forever". Default to `0`.
+- show (bool) - Whether to display the drawn image. Default to `True`.
+- save_dir (str, optional) - Save file dir for all storage backends. If it is `None`, the backend storage will not save any data.
+- out_file (str, optional) - Path to output file. Default to `None`.
+
+Returns:
+
+- np.ndarray: the drawn image which channel is RGB.
+
+Example:
+
+```python
+from mmseg.apis import init_model, inference_model, show_result_pyplot
+
+config_path = 'configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+checkpoint_path = 'checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
+img_path = 'demo/demo.png'
+
+
+# build the model from a config file and a checkpoint file
+model = init_model(config_path, checkpoint_path, device='cuda:0')
+
+# inference on given image
+result = inference_model(model, img_path)
+
+# display the segmentation result
+vis_image = show_result_pyplot(model, img_path, result)
+
+# save the visualization result, the output image would be found at the path `work_dirs/result.png`
+vis_iamge = show_result_pyplot(model, img_path, result, out_file='work_dirs/result.png')
+
+# Modify the time of displaying images, note that 0 is the special value that means "forever"
+vis_image = show_result_pyplot(model, img_path, result, wait_time=5)
+```
+
+**Note:** If your current device doesn't have graphical user interface, it is recommended that setting `show` to `False` and specify the `out_file` or `save_dir` to save the results. If you would like to display the result on a window, no special settings are required.
diff --git a/mmsegmentation/docs/en/user_guides/4_train_test.md b/mmsegmentation/docs/en/user_guides/4_train_test.md
new file mode 100644
index 0000000..9b2d17d
--- /dev/null
+++ b/mmsegmentation/docs/en/user_guides/4_train_test.md
@@ -0,0 +1,315 @@
+# Tutorial 4: Train and test with existing models
+
+MMSegmentation supports training and testing models on a variety of devices, which are described below for single-GPU, distributed, and cluster training and testing, respectively. Through this tutorial, you will learn how to train and test using the scripts provided by MMSegmentation.
+
+## Training and testing on a single GPU
+
+### Training on a single GPU
+
+We provide `tools/train.py` to launch training jobs on a single GPU.
+The basic usage is as follows.
+
+```shell
+python tools/train.py  ${CONFIG_FILE} [optional arguments]
+```
+
+This tool accepts several optional arguments, including:
+
+- `--work-dir ${WORK_DIR}`: Override the working directory.
+- `--amp`: Use auto mixed precision training.
+- `--resume`: Resume from the latest checkpoint in the work_dir automatically.
+- `--cfg-options ${OVERRIDE_CONFIGS}`: Override some settings in the used config, and the key-value pair in xxx=yyy format will be merged into the config file.
+  For example, '--cfg-option model.encoder.in_channels=6'. Please see this [guide](./1_config.md#Modify-config-through-script-arguments) for more details.
+
+Below are the optional arguments for the multi-gpu test:
+
+- `--launcher`: Items for distributed job initialization launcher. Allowed choices are `none`, `pytorch`, `slurm`, `mpi`. Especially, if set to none, it will test in a non-distributed mode.
+- `--local_rank`: ID for local rank. If not specified, it will be set to 0.
+
+**Note:** Difference between the argument `--resume` and the field `load_from` in the config file:
+
+`--resume` only determines whether to resume from the latest checkpoint in the work_dir. It is usually used for resuming the training process that is interrupted accidentally.
+
+`load_from` will specify the checkpoint to be loaded and the training iteration starts from 0. It is usually used for fine-tuning.
+
+If you would like to resume training from a specific checkpoint, you can use:
+
+```python
+python tools/train.py ${CONFIG_FILE} --resume --cfg-options load_from=${CHECKPOINT}
+```
+
+**Training on CPU**: The process of training on the CPU is consistent with single GPU training if a machine does not have GPU. If it has GPUs but not wanting to use them, we just need to disable GPUs before the training process.
+
+```shell
+export CUDA_VISIBLE_DEVICES=-1
+```
+
+And then run the script [above](#training-on-a-single-gpu).
+
+### Testing on a single GPU
+
+We provide `tools/test.py` to launch training jobs on a single GPU.
+The basic usage is as follows.
+
+```shell
+python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [optional arguments]
+```
+
+This tool accepts several optional arguments, including:
+
+- `--work-dir`: If specified, results will be saved in this directory. If not specified, the results will be automatically saved to `work_dirs/{CONFIG_NAME}`.
+- `--show`: Show prediction results at runtime, available when `--show-dir` is not specified.
+- `--show-dir`: Directory where painted images will be saved. If specified, the visualized segmentation mask will be saved to the `work_dir/timestamp/show_dir`.
+- `--wait-time`: The interval of show (s), which takes effect when `--show` is activated. Default to 2.
+- `--cfg-options`:  If specified, the key-value pair in xxx=yyy format will be merged into the config file.
+- `--tta`: Test time augmentation option.
+
+**Testing on CPU**: The process of testing on the CPU is consistent with single GPU testing if a machine does not have GPU. If it has GPUs but not wanting to use them, we just need to disable GPUs before the training process.
+
+```shell
+export CUDA_VISIBLE_DEVICES=-1
+```
+
+then run the script [above](#testing-on-a-single-gpu).
+
+## Training and testing on multiple GPUs and multiple machines
+
+### Training on multiple GPUs
+
+OpenMMLab2.0 implements **distributed** training with `MMDistributedDataParallel`.
+We provide `tools/dist_train.sh` to launch training on multiple GPUs.
+
+The basic usage is as follows:
+
+```shell
+sh tools/dist_train.sh ${CONFIG_FILE} ${GPU_NUM} [optional arguments]
+```
+
+Optional arguments remain the same as stated [above](#training-on-a-single-gpu) and have additional arguments to specify the number of GPUs.
+
+An example:
+
+```shell
+# checkpoints and logs saved in WORK_DIR=work_dirs/pspnet_r50-d8_4xb4-80k_ade20k-512x512/
+# If work_dir is not set, it will be generated automatically.
+sh tools/dist_train.sh configs/pspnet/pspnet_r50-d8_4xb4-80k_ade20k-512x512.py 8 --work-dir work_dirs/pspnet_r50-d8_4xb4-80k_ade20k-512x512
+```
+
+**Note**: During training, checkpoints and logs are saved in the same folder structure as the config file under `work_dirs/`. A custom work directory is not recommended since evaluation scripts infer work directories from the config file name. If you want to save your weights somewhere else, please use a symlink, for example:
+
+```shell
+ln -s ${YOUR_WORK_DIRS} ${MMSEG}/work_dirs
+```
+
+### Testing on multiple GPUs
+
+We provide `tools/dist_test.sh` to launch testing on multiple GPUs.
+The basic usage is as follows.
+
+```shell
+sh tools/dist_test.sh ${CONFIG_FILE} ${CHECKPOINT_FILE} ${GPU_NUM} [optional arguments]
+```
+
+Optional arguments remain the same as stated [above](#testing-on-a-single-gpu) and have additional arguments to specify the number of GPUs.
+
+An example:
+
+```shell
+./tools/dist_test.sh configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py \
+    checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth 4
+```
+
+### Launch multiple jobs on a single machine
+
+If you launch multiple jobs on a single machine, e.g., 2 jobs of 4-GPU training on a machine with 8 GPUs, you need to specify different ports (29500 by default) for each job to avoid communication conflict. Otherwise, there will be an error message saying `RuntimeError: Address already in use`.
+If you use `dist_train.sh` to launch training jobs, you can set the port in commands with the environment variable `PORT`.
+
+```shell
+CUDA_VISIBLE_DEVICES=0,1,2,3 PORT=29500 sh tools/dist_train.sh ${CONFIG_FILE} 4
+CUDA_VISIBLE_DEVICES=4,5,6,7 PORT=29501 sh tools/dist_train.sh ${CONFIG_FILE} 4
+```
+
+### Training with multiple machines
+
+MMSegmentation relies on `torch.distributed` package for distributed training.
+Thus, as a basic usage, one can launch distributed training via PyTorch's [launch utility](https://pytorch.org/docs/stable/distributed.html#launch-utility).
+
+If you launch with multiple machines simply connected with ethernet, you can simply run the following commands:
+On the first machine:
+
+```shell
+NNODES=2 NODE_RANK=0 PORT=${MASTER_PORT} MASTER_ADDR=${MASTER_ADDR} sh tools/dist_train.sh ${CONFIG_FILE} ${GPUS}
+```
+
+On the second machine:
+
+```shell
+NNODES=2 NODE_RANK=1 PORT=${MASTER_PORT} MASTER_ADDR=${MASTER_ADDR} sh tools/dist_train.sh ${CONFIG_FILE} ${GPUS}
+```
+
+Usually, it is slow if you do not have high-speed networking like InfiniBand.
+
+## Manage jobs with Slurm
+
+[Slurm](https://slurm.schedmd.com/) is a good job scheduling system for computing clusters.
+
+### Training on a cluster with Slurm
+
+On a cluster managed by Slurm, you can use `slurm_train.sh` to spawn training jobs. It supports both single-node and multi-node training.
+
+The basic usage is as follows:
+
+```shell
+[GPUS=${GPUS}] sh tools/slurm_train.sh ${PARTITION} ${JOB_NAME} ${CONFIG_FILE} [optional arguments]
+```
+
+Below is an example of using 4 GPUs to train PSPNet on a Slurm partition named _dev_, and set the work-dir to some shared file systems.
+
+```shell
+GPUS=4 sh tools/slurm_train.sh dev pspnet configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py --work-dir work_dir/pspnet
+```
+
+You can check [the source code](../../../tools/slurm_train.sh) to review full arguments and environment variables.
+
+### Testing on a cluster with Slurm
+
+Similar to the training task, MMSegmentation provides `slurm_test.sh` to launch testing jobs.
+
+The basic usage is as follows:
+
+```shell
+[GPUS=${GPUS}] sh tools/slurm_test.sh ${PARTITION} ${JOB_NAME} ${CONFIG_FILE} ${CHECKPOINT_FILE} [optional arguments]
+```
+
+You can check [the source code](../../../tools/slurm_test.sh) to review full arguments and environment variables.
+
+**Note:** When using Slurm, the port option needs to be set in one of the following ways:
+
+1. Set the port through `--cfg-options`. This is more recommended since it does not change the original configs.
+
+   ```shell
+   GPUS=4 GPUS_PER_NODE=4 sh tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config1.py ${WORK_DIR} --cfg-options env_cfg.dist_cfg.port=29500
+   GPUS=4 GPUS_PER_NODE=4 sh tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config2.py ${WORK_DIR} --cfg-options env_cfg.dist_cfg.port=29501
+   ```
+
+2. Modify the config files to set different communication ports.
+   In `config1.py`:
+
+   ```python
+   enf_cfg = dict(dist_cfg=dict(backend='nccl', port=29500))
+   ```
+
+   In `config2.py`:
+
+   ```python
+   enf_cfg = dict(dist_cfg=dict(backend='nccl', port=29501))
+   ```
+
+   Then you can launch two jobs with config1.py and config2.py.
+
+   ```shell
+   CUDA_VISIBLE_DEVICES=0,1,2,3 GPUS=4 sh tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config1.py ${WORK_DIR}
+   CUDA_VISIBLE_DEVICES=4,5,6,7 GPUS=4 sh tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config2.py ${WORK_DIR}
+   ```
+
+3. Set the port in the command using the environment variable 'MASTER_PORT':
+
+```shell
+CUDA_VISIBLE_DEVICES=0,1,2,3 GPUS=4 MASTER_PORT=29500 sh tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config1.py ${WORK_DIR}
+CUDA_VISIBLE_DEVICES=4,5,6,7 GPUS=4 MASTER_PORT=29501 sh tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config2.py ${WORK_DIR}
+```
+
+## Testing and saving segment files
+
+### Basic Usage
+
+When you want to save the results, you can use `--out` to specify the output directory.
+
+```shell
+python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} --out ${OUTPUT_DIR}
+```
+
+Here is an example to save the predicted results from model `fcn_r50-d8_4xb4-80k_ade20k-512x512` on ADE20k validatation dataset.
+
+```shell
+python tools/test.py configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py ckpt/fcn_r50-d8_512x512_80k_ade20k_20200614_144016-f8ac5082.pth --out work_dirs/format_results
+```
+
+You also can modify the config file to define `output_dir`. We also take
+`fcn_r50-d8_4xb4-80k_ade20k-512x512` as example just add
+`test_evaluator` in `configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py`
+
+```python
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'], output_dir='work_dirs/format_results')
+```
+
+then run command without `--out`:
+
+```shell
+python tools/test.py configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py ckpt/fcn_r50-d8_512x512_80k_ade20k_20200614_144016-f8ac5082.pth
+```
+
+If you would like to only save the predicted results without evaluation as annotation is not released by the official dataset, you can set `format_only=True` and modify `test_dataloader`.
+As there is no annotation in dataset, we remove `dict(type='LoadAnnotations')` from `test_dataloader` Here is the example configuration:
+
+```python
+test_evaluator = dict(
+    type='IoUMetric',
+    iou_metrics=['mIoU'],
+    format_only=True,
+    output_dir='work_dirs/format_results')
+test_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type = 'ADE20KDataset'
+        data_root='data/ade/release_test',
+        data_prefix=dict(img_path='testing'),
+        # we don't load annotation in test transform pipeline.
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+            dict(type='PackSegInputs')
+        ]))
+```
+
+then run test command:
+
+```shell
+python tools/test.py configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py ckpt/fcn_r50-d8_512x512_80k_ade20k_20200614_144016-f8ac5082.pth
+```
+
+### Testing Cityscape dataset and save predicted segment files
+
+We recommend `CityscapesMetric` which is the wrapper of Cityscapes'sdk, when you want to
+save the predicted results of Cityscape test dataset to submit them in [Cityscape test server](https://www.cityscapes-dataset.com/submit/). Here is the example configuration:
+
+```python
+test_evaluator = dict(
+    type='CityscapesMetric',
+    format_only=True,
+    keep_results=True,
+    output_dir='work_dirs/format_results')
+test_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='CityscapesDataset',
+        data_root='data/cityscapes/',
+        data_prefix=dict(img_path='leftImg8bit/test'),
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
+            dict(type='PackSegInputs')
+        ]))
+```
+
+then run test command, for example:
+
+```shell
+python tools/test.py configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-512x1024.py ckpt/fcn_r18-d8_512x1024_80k_cityscapes_20201225_021327-6c50f8b4.pth
+```
diff --git a/mmsegmentation/docs/en/user_guides/5_deployment.md b/mmsegmentation/docs/en/user_guides/5_deployment.md
new file mode 100644
index 0000000..b3b8f57
--- /dev/null
+++ b/mmsegmentation/docs/en/user_guides/5_deployment.md
@@ -0,0 +1,255 @@
+# Tutorial 5: Model Deployment
+
+# MMSegmentation Model Deployment
+
+- [Tutorial 5: Model Deployment](#tutorial-5-model-deployment)
+- [MMSegmentation Model Deployment](#mmsegmentation-model-deployment)
+  - [Installation](#installation)
+    - [Install mmseg](#install-mmseg)
+    - [Install mmdeploy](#install-mmdeploy)
+  - [Convert model](#convert-model)
+  - [Model specification](#model-specification)
+  - [Model inference](#model-inference)
+    - [Backend model inference](#backend-model-inference)
+    - [SDK model inference](#sdk-model-inference)
+  - [Supported models](#supported-models)
+  - [Note](#note)
+
+______________________________________________________________________
+
+[MMSegmentation](https://github.com/open-mmlab/mmsegmentation/tree/main), also known as `mmseg`, is an open source semantic segmentation toolbox based on Pytorch. It's a part of the [OpenMMLab](<(https://openmmlab.com/)>) object.
+
+## Installation
+
+### Install mmseg
+
+Please follow the [Installation Guide](https://mmsegmentation.readthedocs.io/en/latest/get_started.html).
+
+### Install mmdeploy
+
+`mmdeploy` can be installed as follows:
+
+**Option 1:** Install precompiled package
+
+Please follow the [Installation overview](https://mmdeploy.readthedocs.io/zh_CN/latest/get_started.html#mmdeploy)
+
+**Option 2:**  Automatic Installation script
+
+If the deployment platform is **Ubuntu 18.04 +**, please follow the [scription installation](../01-how-to-build/build_from_script.md) to install.
+For example, the following commands describe how to install mmdeploy and inference engine-`ONNX Runtime`.
+
+```shell
+git clone --recursive -b main https://github.com/open-mmlab/mmdeploy.git
+cd mmdeploy
+python3 tools/scripts/build_ubuntu_x64_ort.py $(nproc)
+export PYTHONPATH=$(pwd)/build/lib:$PYTHONPATH
+export LD_LIBRARY_PATH=$(pwd)/../mmdeploy-dep/onnxruntime-linux-x64-1.8.1/lib/:$LD_LIBRARY_PATH
+```
+
+**NOTE**:
+
+- Add `$(pwd)/build/lib` to `PYTHONPATH`, can loading mmdeploy SDK python package `mmdeploy_runtime`. See [SDK model inference](#SDK-model-inference) for more information.
+- With [ONNX Runtime model inference](#Backend-model-inference), need to load custom operator library and add ONNX Runtime Library's PATH to `LD_LIBRARY_PATH`.
+
+**Option 3:**  Install with mim
+
+1. Use mim to install mmcv
+
+```shell
+pip install -U openmim
+mim install "mmcv>=2.0.0rc2"
+```
+
+2. Install mmdeploy
+
+```shell
+git clone https://github.com/open-mmlab/mmdeploy.git
+cd mmdeploy
+mim install -e .
+```
+
+**Option 4:**  Build MMDeploy from source
+
+If the first three methods aren't suitable, please [Build MMDeploy from source](<(../01-how-to-build/build_from_source.md)>)
+
+## Convert model
+
+[tools/deploy.py](https://github.com/open-mmlab/mmdeploy/tree/main/tools/deploy.py) can convert mmseg Model to backend model conveniently. See [this](https://github.com/open-mmlab/mmdeploy/tree/main/docs/en/02-how-to-run/convert_model.md#usage) for detailed information.
+
+Then convert `unet` to onnx model as follows:
+
+```shell
+cd mmdeploy
+
+# download unet model from mmseg model zoo
+mim download mmsegmentation --config unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024 --dest .
+
+# convert mmseg model to onnxruntime model with dynamic shape
+python tools/deploy.py \
+    configs/mmseg/segmentation_onnxruntime_dynamic.py \
+    unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py \
+    fcn_unet_s5-d16_4x4_512x1024_160k_cityscapes_20211210_145204-6860854e.pth \
+    demo/resources/cityscapes.png \
+    --work-dir mmdeploy_models/mmseg/ort \
+    --device cpu \
+    --show \
+    --dump-info
+```
+
+It is crucial to specify the correct deployment config during model conversion. MMDeploy has already provided builtin deployment config [files](https://github.com/open-mmlab/mmdeploy/tree/main/configs/mmseg) of all supported backends for mmsegmentation, under which the config file path follows the pattern:
+
+```
+segmentation_{backend}-{precision}_{static | dynamic}_{shape}.py
+```
+
+- **{backend}:** inference backend, such as onnxruntime, tensorrt, pplnn, ncnn, openvino, coreml etc.
+- **{precision}:** fp16, int8. When it's empty, it means fp32
+- **{static | dynamic}:** static shape or dynamic shape
+- **{shape}:** input shape or shape range of a model
+
+Therefore, in the above example, you can also convert `unet` to tensorrt-fp16 model by `segmentation_tensorrt-fp16_dynamic-512x1024-2048x2048.py`.
+
+```{tip}
+When converting mmsegmentation models to tensorrt models, --device should be set to "cuda"
+```
+
+## Model specification
+
+Before moving on to model inference chapter, let's know more about the converted model structure which is very important for model inference.
+
+The converted model locates in the working directory like `mmdeploy_models/mmseg/ort` in the previous example. It includes:
+
+```
+mmdeploy_models/mmseg/ort
+├── deploy.json
+├── detail.json
+├── end2end.onnx
+└── pipeline.json
+```
+
+in which,
+
+- **end2end.onnx**: backend model which can be inferred by ONNX Runtime
+- ***xxx*.json**: the necessary information for mmdeploy SDK
+
+The whole package **mmdeploy_models/mmseg/ort** is defined as **mmdeploy SDK model**, i.e., **mmdeploy SDK model** includes both backend model and inference meta information.
+
+## Model inference
+
+### Backend model inference
+
+Take the previous converted `end2end.onnx` model as an example, you can use the following code to inference the model and visualize the results:
+
+```python
+from mmdeploy.apis.utils import build_task_processor
+from mmdeploy.utils import get_input_shape, load_config
+import torch
+
+deploy_cfg = 'configs/mmseg/segmentation_onnxruntime_dynamic.py'
+model_cfg = './unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py'
+device = 'cpu'
+backend_model = ['./mmdeploy_models/mmseg/ort/end2end.onnx']
+image = './demo/resources/cityscapes.png'
+
+# read deploy_cfg and model_cfg
+deploy_cfg, model_cfg = load_config(deploy_cfg, model_cfg)
+
+# build task and backend model
+task_processor = build_task_processor(model_cfg, deploy_cfg, device)
+model = task_processor.build_backend_model(backend_model)
+
+# process input image
+input_shape = get_input_shape(deploy_cfg)
+model_inputs, _ = task_processor.create_input(image, input_shape)
+
+# do model inference
+with torch.no_grad():
+    result = model.test_step(model_inputs)
+
+# visualize results
+task_processor.visualize(
+    image=image,
+    model=model,
+    result=result[0],
+    window_name='visualize',
+    output_file='./output_segmentation.png')
+```
+
+### SDK model inference
+
+You can also perform SDK model inference like following:
+
+```python
+from mmdeploy_runtime import Segmentor
+import cv2
+import numpy as np
+
+img = cv2.imread('./demo/resources/cityscapes.png')
+
+# create a classifier
+segmentor = Segmentor(model_path='./mmdeploy_models/mmseg/ort', device_name='cpu', device_id=0)
+# perform inference
+seg = segmentor(img)
+
+# visualize inference result
+## random a palette with size 256x3
+palette = np.random.randint(0, 256, size=(256, 3))
+color_seg = np.zeros((seg.shape[0], seg.shape[1], 3), dtype=np.uint8)
+for label, color in enumerate(palette):
+    color_seg[seg == label, :] = color
+# convert to BGR
+color_seg = color_seg[..., ::-1]
+img = img * 0.5 + color_seg * 0.5
+img = img.astype(np.uint8)
+cv2.imwrite('output_segmentation.png', img)
+```
+
+Besides python API, mmdeploy SDK also provides other FFI (Foreign Function Interface), such as C, C++, C#, Java and so on. You can learn their usage from [demo](https://github.com/open-mmlab/mmdeploy/tree/main/demo)
+
+## Supported models
+
+| Model                                                                                                     | TorchScript | OnnxRuntime | TensorRT | ncnn | PPLNN | OpenVino |
+| :-------------------------------------------------------------------------------------------------------- | :---------: | :---------: | :------: | :--: | :---: | :------: |
+| [FCN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/fcn)                                 |      Y      |      Y      |    Y     |  Y   |   Y   |    Y     |
+| [PSPNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/pspnet)[\*](#static_shape)        |      Y      |      Y      |    Y     |  Y   |   Y   |    Y     |
+| [DeepLabV3](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/deeplabv3)                     |      Y      |      Y      |    Y     |  Y   |   Y   |    Y     |
+| [DeepLabV3+](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/deeplabv3plus)                |      Y      |      Y      |    Y     |  Y   |   Y   |    Y     |
+| [Fast-SCNN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/fastscnn)[\*](#static_shape)   |      Y      |      Y      |    Y     |  N   |   Y   |    Y     |
+| [UNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/unet)                               |      Y      |      Y      |    Y     |  Y   |   Y   |    Y     |
+| [ANN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/ann)[\*](#static_shape)              |      Y      |      Y      |    Y     |  N   |   N   |    N     |
+| [APCNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/apcnet)                           |      Y      |      Y      |    Y     |  Y   |   N   |    N     |
+| [BiSeNetV1](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/bisenetv1)                     |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
+| [BiSeNetV2](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/bisenetv2)                     |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
+| [CGNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/cgnet)                             |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
+| [DMNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/dmnet)                             |      ?      |      Y      |    N     |  N   |   N   |    N     |
+| [DNLNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/dnlnet)                           |      ?      |      Y      |    Y     |  Y   |   N   |    Y     |
+| [EMANet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/emanet)                           |      Y      |      Y      |    Y     |  N   |   N   |    Y     |
+| [EncNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/encnet)                           |      Y      |      Y      |    Y     |  N   |   N   |    Y     |
+| [ERFNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/erfnet)                           |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
+| [FastFCN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/fastfcn)                         |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
+| [GCNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/gcnet)                             |      Y      |      Y      |    Y     |  N   |   N   |    N     |
+| [ICNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/icnet)[\*](#static_shape)          |      Y      |      Y      |    Y     |  N   |   N   |    Y     |
+| [ISANet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/isanet)[\*](#static_shape)        |      N      |      Y      |    Y     |  N   |   N   |    Y     |
+| [NonLocal Net](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/nonlocal_net)               |      ?      |      Y      |    Y     |  Y   |   N   |    Y     |
+| [OCRNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/ocrnet)                           |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
+| [PointRend](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/point_rend)[\*](#static_shape) |      Y      |      Y      |    Y     |  N   |   N   |    N     |
+| [Semantic FPN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/sem_fpn)                    |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
+| [STDC](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/stdc)                               |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
+| [UPerNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/upernet)[\*](#static_shape)      |      N      |      Y      |    Y     |  N   |   N   |    N     |
+| [DANet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/danet)                             |      ?      |      Y      |    Y     |  N   |   N   |    Y     |
+| [Segmenter](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/segmenter)[\*](#static_shape)  |      N      |      Y      |    Y     |  Y   |   N   |    Y     |
+| [SegFormer](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/segformer)[\*](#static_shape)  |      ?      |      Y      |    Y     |  N   |   N   |    Y     |
+| [SETR](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/setr)                               |      ?      |      Y      |    N     |  N   |   N   |    Y     |
+| [CCNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/ccnet)                             |      ?      |      N      |    N     |  N   |   N   |    N     |
+| [PSANet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/psanet)                           |      ?      |      N      |    N     |  N   |   N   |    N     |
+| [DPT](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/dpt)                                 |      ?      |      N      |    N     |  N   |   N   |    N     |
+
+## Note
+
+- All mmseg models only support the 'whole' inference mode.
+
+- <i id=“static_shape”>PSPNet，Fast-SCNN</i> only supports static input, because most inference framework's [nn.AdaptiveAvgPool2d](https://github.com/open-mmlab/mmsegmentation/blob/0c87f7a0c9099844eff8e90fa3db5b0d0ca02fee/mmseg/models/decode_heads/psp_head.py#L38) don't support dynamic input。
+
+- For models that only support static shapes, should use the static shape deployment config file, such as `configs/mmseg/segmentation_tensorrt_static-1024x2048.py`
+
+- To deploy models to generate probabilistic feature maps, please add `codebase_config = dict(with_argmax=False)` to deployment config file.
diff --git a/mmsegmentation/docs/en/user_guides/index.rst b/mmsegmentation/docs/en/user_guides/index.rst
new file mode 100644
index 0000000..1feb127
--- /dev/null
+++ b/mmsegmentation/docs/en/user_guides/index.rst
@@ -0,0 +1,21 @@
+Train & Test
+**************
+
+.. toctree::
+   :maxdepth: 1
+
+   1_config.md
+   2_dataset_prepare.md
+   3_inference.md
+   4_train_test.md
+
+Useful Tools
+*************
+
+.. toctree::
+   :maxdepth: 2
+
+   visualization.md
+   useful_tools.md
+   deployment.md
+   visualization_feature_map.md
diff --git a/mmsegmentation/docs/en/user_guides/useful_tools.md b/mmsegmentation/docs/en/user_guides/useful_tools.md
new file mode 100644
index 0000000..0d86778
--- /dev/null
+++ b/mmsegmentation/docs/en/user_guides/useful_tools.md
@@ -0,0 +1,245 @@
+# \[WIP\] Useful Tools
+
+Apart from training/testing scripts, We provide lots of useful tools under the
+`tools/` directory.
+
+## Analysis Tools
+
+### Plot training logs
+
+`tools/analyze_logs.py` plots loss/mIoU curves given a training log file. `pip install seaborn` first to install the dependency.
+
+```shell
+python tools/analysis_tools/analyze_logs.py xxx.json [--keys ${KEYS}] [--legend ${LEGEND}] [--backend ${BACKEND}] [--style ${STYLE}] [--out ${OUT_FILE}]
+```
+
+Examples:
+
+- Plot the mIoU, mAcc, aAcc metrics.
+
+  ```shell
+  python tools/analysis_tools/analyze_logs.py log.json --keys mIoU mAcc aAcc --legend mIoU mAcc aAcc
+  ```
+
+- Plot loss metric.
+
+  ```shell
+  python tools/analysis_tools/analyze_logs.py log.json --keys loss --legend loss
+  ```
+
+### Confusion Matrix (experimental)
+
+In order to generate and plot a `nxn` confusion matrix where `n` is the number of classes, you can follow the steps:
+
+#### 1.Generate a prediction result in pkl format using `test.py`
+
+```shell
+python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${PATH_TO_RESULT_FILE}]
+```
+
+Example:
+
+```shell
+python tools/test.py \
+configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py \
+checkpoint/fcn_r50-d8_512x1024_40k_cityscapes_20200604_192608-efe53f0d.pth \
+--out result/pred_result.pkl
+```
+
+#### 2. Use `confusion_matrix.py` to generate and plot a confusion matrix
+
+```shell
+python tools/confusion_matrix.py ${CONFIG_FILE} ${PATH_TO_RESULT_FILE} ${SAVE_DIR} --show
+```
+
+Description of arguments:
+
+- `config`: Path to the test config file.
+- `prediction_path`: Path to the prediction .pkl result.
+- `save_dir`: Directory where confusion matrix will be saved.
+- `--show`: Enable result visualize.
+- `--color-theme`: Theme of the matrix color map.
+- `--cfg_options`: Custom options to replace the config file.
+
+Example:
+
+```shell
+python tools/confusion_matrix.py \
+configs/fcn/fcn_r50-d8_512x1024_40k_cityscapes.py \
+result/pred_result.pkl \
+result/confusion_matrix \
+--show
+```
+
+### Get the FLOPs and params (experimental)
+
+We provide a script adapted from [flops-counter.pytorch](https://github.com/sovrasov/flops-counter.pytorch) to compute the FLOPs and params of a given model.
+
+```shell
+python tools/analysis_tools/get_flops.py ${CONFIG_FILE} [--shape ${INPUT_SHAPE}]
+```
+
+You will get the result like this.
+
+```none
+==============================
+Input shape: (3, 2048, 1024)
+Flops: 1429.68 GMac
+Params: 48.98 M
+==============================
+```
+
+:::{note}
+This tool is still experimental and we do not guarantee that the number is correct. You may well use the result for simple comparisons, but double check it before you adopt it in technical reports or papers.
+:::
+
+(1) FLOPs are related to the input shape while parameters are not. The default input shape is (1, 3, 1280, 800).
+(2) Some operators are not counted into FLOPs like GN and custom operators.
+
+## Miscellaneous
+
+### Publish a model
+
+Before you upload a model to AWS, you may want to
+(1) convert model weights to CPU tensors, (2) delete the optimizer states and
+(3) compute the hash of the checkpoint file and append the hash id to the filename.
+
+```shell
+python tools/misc/publish_model.py ${INPUT_FILENAME} ${OUTPUT_FILENAME}
+```
+
+E.g.,
+
+```shell
+python tools/publish_model.py work_dirs/pspnet/latest.pth psp_r50_512x1024_40k_cityscapes.pth
+```
+
+The final output filename will be `psp_r50_512x1024_40k_cityscapes-{hash id}.pth`.
+
+### Print the entire config
+
+`tools/misc/print_config.py` prints the whole config verbatim, expanding all its
+imports.
+
+```shell
+python tools/misc/print_config.py \
+  ${CONFIG} \
+  --graph \
+  --cfg-options ${OPTIONS [OPTIONS...]} \
+```
+
+Description of arguments:
+
+- `config` : The path of a pytorch model config file.
+- `--graph` : Determines whether to print the models graph.
+- `--cfg-options`: Custom options to replace the config file.
+
+## Model conversion
+
+`tools/model_converters/` provide several scripts to convert pretrain models released by other repos to MMSegmentation style.
+
+### ViT Swin MiT Transformer Models
+
+- ViT
+
+  `tools/model_converters/vit2mmseg.py` convert keys in timm pretrained vit models to MMSegmentation style.
+
+  ```shell
+  python tools/model_converters/vit2mmseg.py ${SRC} ${DST}
+  ```
+
+- Swin
+
+  `tools/model_converters/swin2mmseg.py` convert keys in official pretrained swin models to MMSegmentation style.
+
+  ```shell
+  python tools/model_converters/swin2mmseg.py ${SRC} ${DST}
+  ```
+
+- SegFormer
+
+  `tools/model_converters/mit2mmseg.py` convert keys in official pretrained mit models to MMSegmentation style.
+
+  ```shell
+  python tools/model_converters/mit2mmseg.py ${SRC} ${DST}
+  ```
+
+## Model Serving
+
+In order to serve an `MMSegmentation` model with [`TorchServe`](https://pytorch.org/serve/), you can follow the steps:
+
+### 1. Convert model from MMSegmentation to TorchServe
+
+```shell
+python tools/torchserve/mmseg2torchserve.py ${CONFIG_FILE} ${CHECKPOINT_FILE} \
+--output-folder ${MODEL_STORE} \
+--model-name ${MODEL_NAME}
+```
+
+:::{note}
+${MODEL_STORE} needs to be an absolute path to a folder.
+:::
+
+### 2. Build `mmseg-serve` docker image
+
+```shell
+docker build -t mmseg-serve:latest docker/serve/
+```
+
+### 3. Run `mmseg-serve`
+
+Check the official docs for [running TorchServe with docker](https://github.com/pytorch/serve/blob/master/docker/README.md#running-torchserve-in-a-production-docker-environment).
+
+In order to run in GPU, you need to install [nvidia-docker](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html). You can omit the `--gpus` argument in order to run in CPU.
+
+Example:
+
+```shell
+docker run --rm \
+--cpus 8 \
+--gpus device=0 \
+-p8080:8080 -p8081:8081 -p8082:8082 \
+--mount type=bind,source=$MODEL_STORE,target=/home/model-server/model-store \
+mmseg-serve:latest
+```
+
+[Read the docs](https://github.com/pytorch/serve/blob/072f5d088cce9bb64b2a18af065886c9b01b317b/docs/rest_api.md) about the Inference (8080), Management (8081) and Metrics (8082) APIs
+
+### 4. Test deployment
+
+```shell
+curl -O https://raw.githubusercontent.com/open-mmlab/mmsegmentation/master/resources/3dogs.jpg
+curl http://127.0.0.1:8080/predictions/${MODEL_NAME} -T 3dogs.jpg -o 3dogs_mask.png
+```
+
+The response will be a ".png" mask.
+
+You can visualize the output as follows:
+
+```python
+import matplotlib.pyplot as plt
+import mmcv
+plt.imshow(mmcv.imread("3dogs_mask.png", "grayscale"))
+plt.show()
+```
+
+You should see something similar to:
+
+![3dogs_mask](../../resources/3dogs_mask.png)
+
+And you can use `test_torchserve.py` to compare result of torchserve and pytorch, and visualize them.
+
+```shell
+python tools/torchserve/test_torchserve.py ${IMAGE_FILE} ${CONFIG_FILE} ${CHECKPOINT_FILE} ${MODEL_NAME}
+[--inference-addr ${INFERENCE_ADDR}] [--result-image ${RESULT_IMAGE}] [--device ${DEVICE}]
+```
+
+Example:
+
+```shell
+python tools/torchserve/test_torchserve.py \
+demo/demo.png \
+configs/fcn/fcn_r50-d8_512x1024_40k_cityscapes.py \
+checkpoint/fcn_r50-d8_512x1024_40k_cityscapes_20200604_192608-efe53f0d.pth \
+fcn
+```
diff --git a/mmsegmentation/docs/en/user_guides/visualization.md b/mmsegmentation/docs/en/user_guides/visualization.md
new file mode 100644
index 0000000..e7c3359
--- /dev/null
+++ b/mmsegmentation/docs/en/user_guides/visualization.md
@@ -0,0 +1,174 @@
+# Visualization
+
+MMSegmentation 1.x provides convenient ways for monitoring training status or visualizing data and model predictions.
+
+## Training status Monitor
+
+MMSegmentation 1.x uses TensorBoard to monitor training status.
+
+### TensorBoard Configuration
+
+Install TensorBoard following [official instructions](https://www.tensorflow.org/install) e.g.
+
+```shell
+pip install tensorboardX
+pip install future tensorboard
+```
+
+Add `TensorboardVisBackend` in `vis_backend` of `visualizer` in `default_runtime.py` config file:
+
+```python
+vis_backends = [dict(type='LocalVisBackend'),
+                dict(type='TensorboardVisBackend')]
+visualizer = dict(
+    type='SegLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+```
+
+### Examining scalars in TensorBoard
+
+Launch training experiment e.g.
+
+```shell
+python tools/train.py configs/pspnet/pspnet_r50-d8_4xb4-80k_ade20k-512x512.py --work-dir work_dir/test_visual
+```
+
+Find the `vis_data` path of `work_dir` after starting training, for example, the vis_data path of this particular test is as follows:
+
+```shell
+work_dirs/test_visual/20220810_115248/vis_data
+```
+
+The scalar file in vis_data path includes learning rate, losses and data_time etc, also record metrics results and you can refer [logging tutorial](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/logging.html) in MMEngine to log custom data. The tensorboard visualization results are executed with the following command:
+
+```shell
+tensorboard --logdir work_dirs/test_visual/20220810_115248/vis_data
+```
+
+## Data and Results visualization
+
+### Visualizer Data Samples during Model Testing or Validation
+
+MMSegmentation provides `SegVisualizationHook` which is a [hook](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/hook.md) working to visualize ground truth and prediction of segmentation during model testing and evaluation. Its configuration is in `default_hooks`, please see [Runner tutorial](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/runner.md) for more details.
+
+For example, In `_base_/schedules/schedule_20k.py`, modify the `SegVisualizationHook` configuration, set `draw` to `True` to enable the storage of network inference results, `interval` indicates the sampling interval of the prediction results, and when set to 1, each inference result of the network will be saved. `interval` is set to 50 by default:
+
+```python
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=2000),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook', draw=True, interval=1))
+
+```
+
+After launch training experiment, visualization results will be stored in the local folder in validation loop,
+or when launch evaluation a model on one dataset, the prediction results will be store in the local.
+The stored results of the local visualization are kept in `vis_image` under `$WORK_DIRS/vis_data`, e.g.:
+
+```shell
+work_dirs/test_visual/20220810_115248/vis_data/vis_image
+```
+
+In addition, if `TensorboardVisBackend` is add in `vis_backends`, like [above](#tensorboard-configuration),
+we can also run the following command to view them in TensorBoard:
+
+```shell
+tensorboard --logdir work_dirs/test_visual/20220810_115248/vis_data
+```
+
+### Visualize a Single Data Sample
+
+If you want to visualize a single data sample, we suggest to use `SegLocalVisualizer`.
+
+`SegLocalVisualizer` is child class inherits from `Visualizer` in MMEngine and works for MMSegmentation visualization, for more details about `Visualizer` please refer to [visualization tutorial](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/visualization.md) in MMEngine.
+
+Here is an example about `SegLocalVisualizer`, first you may download example data below by following commands:
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/189833109-eddad58f-f777-4fc0-b98a-6bd429143b06.png" width="70%"/>
+</div>
+
+```shell
+wget https://user-images.githubusercontent.com/24582831/189833109-eddad58f-f777-4fc0-b98a-6bd429143b06.png --output-document aachen_000000_000019_leftImg8bit.png
+wget https://user-images.githubusercontent.com/24582831/189833143-15f60f8a-4d1e-4cbb-a6e7-5e2233869fac.png --output-document aachen_000000_000019_gtFine_labelTrainIds.png
+```
+
+Then you can find their local path and use the scripts below to visualize:
+
+```python
+import mmcv
+import os.path as osp
+import torch
+# `PixelData` is data structure for pixel-level annotations or predictions defined in MMEngine.
+# Please refer to below tutorial file of data structures in MMEngine:
+# https://github.com/open-mmlab/mmengine/tree/main/docs/en/advanced_tutorials/data_element.md
+
+from mmengine.structures import PixelData
+
+# `SegDataSample` is data structure interface between different components
+# defined in MMSegmentation, it includes ground truth, prediction and
+# predicted logits of semantic segmentation.
+# Please refer to below tutorial file of `SegDataSample` for more details:
+# https://github.com/open-mmlab/mmsegmentation/blob/1.x/docs/en/advanced_guides/structures.md
+
+from mmseg.structures import SegDataSample
+from mmseg.visualization import SegLocalVisualizer
+
+out_file = 'out_file_cityscapes'
+save_dir = './work_dirs'
+
+image = mmcv.imread(
+    osp.join(
+        osp.dirname(__file__),
+        './aachen_000000_000019_leftImg8bit.png'
+    ),
+    'color')
+sem_seg = mmcv.imread(
+    osp.join(
+        osp.dirname(__file__),
+        './aachen_000000_000019_gtFine_labelTrainIds.png'  # noqa
+    ),
+    'unchanged')
+sem_seg = torch.from_numpy(sem_seg)
+gt_sem_seg_data = dict(data=sem_seg)
+gt_sem_seg = PixelData(**gt_sem_seg_data)
+data_sample = SegDataSample()
+data_sample.gt_sem_seg = gt_sem_seg
+
+seg_local_visualizer = SegLocalVisualizer(
+    vis_backends=[dict(type='LocalVisBackend')],
+    save_dir=save_dir)
+
+# The meta information of dataset usually includes `classes` for class names and
+# `palette` for visualization color of each foreground.
+# All class names and palettes are defined in the file:
+# https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/utils/class_names.py
+
+seg_local_visualizer.dataset_meta = dict(
+    classes=('road', 'sidewalk', 'building', 'wall', 'fence',
+             'pole', 'traffic light', 'traffic sign',
+             'vegetation', 'terrain', 'sky', 'person', 'rider',
+             'car', 'truck', 'bus', 'train', 'motorcycle',
+             'bicycle'),
+    palette=[[128, 64, 128], [244, 35, 232], [70, 70, 70],
+             [102, 102, 156], [190, 153, 153], [153, 153, 153],
+             [250, 170, 30], [220, 220, 0], [107, 142, 35],
+             [152, 251, 152], [70, 130, 180], [220, 20, 60],
+             [255, 0, 0], [0, 0, 142], [0, 0, 70],
+             [0, 60, 100], [0, 80, 100], [0, 0, 230],
+             [119, 11, 32]])
+# When `show=True`, the results would be shown directly,
+# else if `show=False`, the results would be saved in local directory folder.
+seg_local_visualizer.add_datasample(out_file, image,
+                                    data_sample, show=False)
+```
+
+Then the visualization result of image with its corresponding ground truth could be found in `./work_dirs/vis_data/vis_image/` whose name is `out_file_cityscapes_0.png`:
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/189835713-c0534054-4bfa-4b75-9254-0afbeb5ff02e.png" width="70%"/>
+</div>
+
+If you would like to know more visualization usage, you can refer to [visualization tutorial](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/visualization.html) in MMEngine.
diff --git a/mmsegmentation/docs/en/user_guides/visualization_feature_map.md b/mmsegmentation/docs/en/user_guides/visualization_feature_map.md
new file mode 100644
index 0000000..08398e5
--- /dev/null
+++ b/mmsegmentation/docs/en/user_guides/visualization_feature_map.md
@@ -0,0 +1,201 @@
+# Wandb Feature Map Visualization
+
+MMSegmentation 1.x provides backend support for Weights & Biases to facilitate visualization and management of project code results.
+
+## Wandb Configuration
+
+Install Weights & Biases following [official instructions](https://docs.wandb.ai/quickstart) e.g.
+
+```shell
+pip install wandb
+wandb login
+```
+
+Add `WandbVisBackend` in `vis_backend` of `visualizer` in `default_runtime.py` config file:
+
+```python
+vis_backends=[dict(type='LocalVisBackend'),
+              dict(type='TensorboardVisBackend'),
+              dict(type='WandbVisBackend')]
+```
+
+## Examining feature map visualization in Wandb
+
+`SegLocalVisualizer` is child class inherits from `Visualizer` in MMEngine and works for MMSegmentation visualization, for more details about `Visualizer` please refer to [visualization tutorial](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/visualization.md) in MMEngine.
+
+Here is an example about `SegLocalVisualizer`, first you may download example data below by following commands:
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/189833109-eddad58f-f777-4fc0-b98a-6bd429143b06.png" width="70%"/>
+</div>
+
+```shell
+wget https://user-images.githubusercontent.com/24582831/189833109-eddad58f-f777-4fc0-b98a-6bd429143b06.png --output-document aachen_000000_000019_leftImg8bit.png
+wget https://user-images.githubusercontent.com/24582831/189833143-15f60f8a-4d1e-4cbb-a6e7-5e2233869fac.png --output-document aachen_000000_000019_gtFine_labelTrainIds.png
+
+wget https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x1024_40k_cityscapes/ann_r50-d8_512x1024_40k_cityscapes_20200605_095211-049fc292.pth
+
+```
+
+```python
+# Copyright (c) OpenMMLab. All rights reserved.
+from argparse import ArgumentParser
+from typing import Type
+
+import mmcv
+import torch
+import torch.nn as nn
+
+from mmengine.model import revert_sync_batchnorm
+from mmengine.structures import PixelData
+from mmseg.apis import inference_model, init_model
+from mmseg.structures import SegDataSample
+from mmseg.utils import register_all_modules
+from mmseg.visualization import SegLocalVisualizer
+
+
+class Recorder:
+    """record the forward output feature map and save to data_buffer."""
+
+    def __init__(self) -> None:
+        self.data_buffer = list()
+
+    def __enter__(self, ):
+        self._data_buffer = list()
+
+    def record_data_hook(self, model: nn.Module, input: Type, output: Type):
+        self.data_buffer.append(output)
+
+    def __exit__(self, *args, **kwargs):
+        pass
+
+
+def visualize(args, model, recorder, result):
+    seg_visualizer = SegLocalVisualizer(
+        vis_backends=[dict(type='WandbVisBackend')],
+        save_dir='temp_dir',
+        alpha=0.5)
+    seg_visualizer.dataset_meta = dict(
+        classes=model.dataset_meta['classes'],
+        palette=model.dataset_meta['palette'])
+
+    image = mmcv.imread(args.img, 'color')
+
+    seg_visualizer.add_datasample(
+        name='predict',
+        image=image,
+        data_sample=result,
+        draw_gt=False,
+        draw_pred=True,
+        wait_time=0,
+        out_file=None,
+        show=False)
+
+    # add feature map to wandb visualizer
+    for i in range(len(recorder.data_buffer)):
+        feature = recorder.data_buffer[i][0]  # remove the batch
+        drawn_img = seg_visualizer.draw_featmap(
+            feature, image, channel_reduction='select_max')
+        seg_visualizer.add_image(f'feature_map{i}', drawn_img)
+
+    if args.gt_mask:
+        sem_seg = mmcv.imread(args.gt_mask, 'unchanged')
+        sem_seg = torch.from_numpy(sem_seg)
+        gt_mask = dict(data=sem_seg)
+        gt_mask = PixelData(**gt_mask)
+        data_sample = SegDataSample()
+        data_sample.gt_sem_seg = gt_mask
+
+        seg_visualizer.add_datasample(
+            name='gt_mask',
+            image=image,
+            data_sample=data_sample,
+            draw_gt=True,
+            draw_pred=False,
+            wait_time=0,
+            out_file=None,
+            show=False)
+
+    seg_visualizer.add_image('image', image)
+
+
+def main():
+    parser = ArgumentParser(
+        description='Draw the Feature Map During Inference')
+    parser.add_argument('img', help='Image file')
+    parser.add_argument('config', help='Config file')
+    parser.add_argument('checkpoint', help='Checkpoint file')
+    parser.add_argument('--gt_mask', default=None, help='Path of gt mask file')
+    parser.add_argument('--out-file', default=None, help='Path to output file')
+    parser.add_argument(
+        '--device', default='cuda:0', help='Device used for inference')
+    parser.add_argument(
+        '--opacity',
+        type=float,
+        default=0.5,
+        help='Opacity of painted segmentation map. In (0, 1] range.')
+    parser.add_argument(
+        '--title', default='result', help='The image identifier.')
+    args = parser.parse_args()
+
+    register_all_modules()
+
+    # build the model from a config file and a checkpoint file
+    model = init_model(args.config, args.checkpoint, device=args.device)
+    if args.device == 'cpu':
+        model = revert_sync_batchnorm(model)
+
+    # show all named module in the model and use it in source list below
+    for name, module in model.named_modules():
+        print(name)
+
+    source = [
+        'decode_head.fusion.stages.0.query_project.activate',
+        'decode_head.context.stages.0.key_project.activate',
+        'decode_head.context.bottleneck.activate'
+    ]
+    source = dict.fromkeys(source)
+
+    count = 0
+    recorder = Recorder()
+    # registry the forward hook
+    for name, module in model.named_modules():
+        if name in source:
+            count += 1
+            module.register_forward_hook(recorder.record_data_hook)
+            if count == len(source):
+                break
+
+    with recorder:
+        # test a single image, and record feature map to data_buffer
+        result = inference_model(model, args.img)
+
+    visualize(args, model, recorder, result)
+
+
+if __name__ == '__main__':
+    main()
+
+```
+
+Save the above code as feature_map_visual.py and execute the  following code in terminal
+
+```shell
+python feature_map_visual.py ${image} ${config} ${checkpoint} [optional args]
+```
+
+e.g
+
+```shell
+python feature_map_visual.py \
+aachen_000000_000019_leftImg8bit.png \
+configs/ann/ann_r50-d8_4xb2-40k_cityscapes-512x1024.py \
+ann_r50-d8_512x1024_40k_cityscapes_20200605_095211-049fc292.pth \
+--gt_mask aachen_000000_000019_gtFine_labelTrainIds.png
+```
+
+The visualized image result and its corresponding feature map will appear in the wandb account.
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/76149310/217520321-647f5bf9-eef2-446d-a9e8-5ca7b621d500.png">
+</div>
diff --git a/mmsegmentation/docs/zh_cn/.readthedocs.yaml b/mmsegmentation/docs/zh_cn/.readthedocs.yaml
new file mode 100644
index 0000000..fc3efd0
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/.readthedocs.yaml
@@ -0,0 +1,17 @@
+version: 2
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.8"
+
+formats:
+    - epub
+
+sphinx:
+  configuration: docs/zh_cn/conf.py
+
+python:
+  install:
+    - requirements: requirements/docs.txt
+    - requirements: requirements/readthedocs.txt
diff --git a/mmsegmentation/docs/zh_cn/Makefile b/mmsegmentation/docs/zh_cn/Makefile
new file mode 100644
index 0000000..d4bb2cb
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/Makefile
@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = .
+BUILDDIR      = _build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
diff --git a/mmsegmentation/docs/zh_cn/_static/css/readthedocs.css b/mmsegmentation/docs/zh_cn/_static/css/readthedocs.css
new file mode 100644
index 0000000..2e38d08
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/_static/css/readthedocs.css
@@ -0,0 +1,6 @@
+.header-logo {
+    background-image: url("../images/mmsegmentation.png");
+    background-size: 201px 40px;
+    height: 40px;
+    width: 201px;
+}
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/add_datasets.md b/mmsegmentation/docs/zh_cn/advanced_guides/add_datasets.md
new file mode 100644
index 0000000..316feb0
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/advanced_guides/add_datasets.md
@@ -0,0 +1,199 @@
+# 新增自定义数据集
+
+## 新增自定义数据集
+
+在这里，我们展示如何构建一个新的数据集。
+
+1. 创建一个新文件 `mmseg/datasets/example.py`
+
+   ```python
+   from mmseg.registry import DATASETS
+   from .basesegdataset import BaseSegDataset
+
+
+   @DATASETS.register_module()
+   class ExampleDataset(BaseSegDataset):
+
+       METAINFO = dict(
+           classes=('xxx', 'xxx', ...),
+           palette=[[x, x, x], [x, x, x], ...])
+
+       def __init__(self, arg1, arg2):
+           pass
+   ```
+
+2. 在 `mmseg/datasets/__init__.py` 中导入模块
+
+   ```python
+   from .example import ExampleDataset
+   ```
+
+3. 通过创建一个新的数据集配置文件 `configs/_base_/datasets/example_dataset.py` 来使用它
+
+   ```python
+   dataset_type = 'ExampleDataset'
+   data_root = 'data/example/'
+   ...
+   ```
+
+4. 在 `mmseg/utils/class_names.py` 中补充数据集元信息
+
+   ```python
+   def example_classes():
+       return [
+           'xxx', 'xxx',
+           ...
+       ]
+
+   def example_palette():
+       return [
+           [x, x, x], [x, x, x],
+           ...
+       ]
+   dataset_aliases ={
+       'example': ['example', ...],
+       ...
+   }
+   ```
+
+**注意：** 如果新数据集不满足 mmseg 的要求，则需要在 `tools/dataset_converters/` 中准备一个数据集预处理脚本
+
+## 通过重新组织数据来定制数据集
+
+最简单的方法是将您的数据集进行转化，并组织成文件夹的形式。
+
+如下的文件结构就是一个例子。
+
+```none
+├── data
+│   ├── my_dataset
+│   │   ├── img_dir
+│   │   │   ├── train
+│   │   │   │   ├── xxx{img_suffix}
+│   │   │   │   ├── yyy{img_suffix}
+│   │   │   │   ├── zzz{img_suffix}
+│   │   │   ├── val
+│   │   ├── ann_dir
+│   │   │   ├── train
+│   │   │   │   ├── xxx{seg_map_suffix}
+│   │   │   │   ├── yyy{seg_map_suffix}
+│   │   │   │   ├── zzz{seg_map_suffix}
+│   │   │   ├── val
+
+```
+
+一个训练对将由 img_dir/ann_dir 里同样首缀的文件组成。
+
+有些数据集不会发布测试集或测试集的标注，如果没有测试集的标注，我们就无法在本地进行评估模型，因此我们在配置文件中将验证集设置为默认测试集。
+
+关于如何构建自己的数据集或实现新的数据集类，请参阅[数据集指南](./datasets.md)以获取更多详细信息。
+
+**注意：** 标注是跟图像同样的形状 (H, W)，其中的像素值的范围是 `[0, num_classes - 1]`。
+您也可以使用 [pillow](https://pillow.readthedocs.io/en/stable/handbook/concepts.html#palette) 的 `'P'` 模式去创建包含颜色的标注。
+
+## 通过混合数据去定制数据集
+
+MMSegmentation 同样支持混合数据集去训练。
+当前它支持拼接 (concat), 重复 (repeat) 和多图混合 (multi-image mix) 数据集。
+
+### 重复数据集
+
+我们使用 `RepeatDataset` 作为包装 (wrapper) 去重复数据集。
+例如，假设原始数据集是 `Dataset_A`，为了重复它，配置文件如下：
+
+```python
+dataset_A_train = dict(
+    type='RepeatDataset',
+    times=N,
+    dataset=dict(  # 这是 Dataset_A 数据集的原始配置
+        type='Dataset_A',
+        ...
+        pipeline=train_pipeline
+    )
+)
+```
+
+### 拼接数据集
+
+如果要拼接不同的数据集，可以按如下方式连接数据集配置。
+
+```python
+dataset_A_train = dict()
+dataset_B_train = dict()
+concatenate_dataset = dict(
+    type='ConcatDataset',
+    datasets=[dataset_A_train, dataset_B_train])
+```
+
+下面是一个更复杂的示例，它分别重复 `Dataset_A` 和 `Dataset_B` N 次和 M 次，然后连接重复的数据集。
+
+```python
+dataset_A_train = dict(
+    type='RepeatDataset',
+    times=N,
+    dataset=dict(
+        type='Dataset_A',
+        ...
+        pipeline=train_pipeline
+    )
+)
+dataset_A_val = dict(
+    ...
+    pipeline=test_pipeline
+)
+dataset_A_test = dict(
+    ...
+    pipeline=test_pipeline
+)
+dataset_B_train = dict(
+    type='RepeatDataset',
+    times=M,
+    dataset=dict(
+        type='Dataset_B',
+        ...
+        pipeline=train_pipeline
+    )
+)
+train_dataloader = dict(
+    dataset=dict(
+        type='ConcatDataset',
+        datasets=[dataset_A_train, dataset_B_train]))
+
+val_dataloader = dict(dataset=dataset_A_val)
+test_dataloader = dict(dataset=dataset_A_test)
+
+```
+
+您可以参考 mmengine 的基础数据集[教程](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/basedataset.html)以了解更多详细信息
+
+### 多图混合集
+
+我们使用 `MultiImageMixDataset` 作为包装（wrapper）去混合多个数据集的图片。
+`MultiImageMixDataset`可以被类似 mosaic 和 mixup 的多图混合数据増广使用。
+
+`MultiImageMixDataset` 与 `Mosaic` 数据増广一起使用的例子：
+
+```python
+train_pipeline = [
+    dict(type='RandomMosaic', prob=1),
+    dict(type='Resize', img_scale=(1024, 512), keep_ratio=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackSegInputs')
+]
+
+train_dataset = dict(
+    type='MultiImageMixDataset',
+    dataset=dict(
+        type=dataset_type,
+        reduce_zero_label=False,
+        img_dir=data_root + "images/train",
+        ann_dir=data_root + "annotations/train",
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations'),
+        ]
+    ),
+    pipeline=train_pipeline
+)
+
+```
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/add_metrics.md b/mmsegmentation/docs/zh_cn/advanced_guides/add_metrics.md
new file mode 100644
index 0000000..0637b44
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/advanced_guides/add_metrics.md
@@ -0,0 +1,81 @@
+# 新增评测指标
+
+## 使用 MMSegmentation 的源代码进行开发
+
+在这里，我们用 `CustomMetric` 作为例子来展示如何开发一个新的评测指标。
+
+1. 创建一个新文件 `mmseg/evaluation/metrics/custom_metric.py`。
+
+   ```python
+   from typing import List, Sequence
+
+   from mmengine.evaluator import BaseMetric
+
+   from mmseg.registry import METRICS
+
+
+   @METRICS.register_module()
+   class CustomMetric(BaseMetric):
+
+       def __init__(self, arg1, arg2):
+           """
+           The metric first processes each batch of data_samples and predictions,
+           and appends the processed results to the results list. Then it
+           collects all results together from all ranks if distributed training
+           is used. Finally, it computes the metrics of the entire dataset.
+           """
+
+       def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+           pass
+
+       def compute_metrics(self, results: list) -> dict:
+           pass
+
+       def evaluate(self, size: int) -> dict:
+           pass
+   ```
+
+   在上面的示例中，`CustomMetric` 是 `BaseMetric` 的子类。它有三个方法：`process`，`compute_metrics` 和 `evaluate`。
+
+   - `process()` 处理一批数据样本和预测。处理后的结果需要显示地传给 `self.results` ，将在处理所有数据样本后用于计算指标。更多细节请参考 [MMEngine 文档](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/design/evaluation.md)
+
+   - `compute_metrics()` 用于从处理后的结果中计算指标。
+
+   - `evaluate()` 是一个接口，用于计算指标并返回结果。它将由 `ValLoop` 或 `TestLoop` 在 `Runner` 中调用。在大多数情况下，您不需要重写此方法，但如果您想做一些额外的工作，可以重写它。
+
+   **注意：** 您可以在[这里](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py#L366) 找到 `Runner` 调用 `evaluate()` 方法的过程。`Runner` 是训练和测试过程的执行器，您可以在[训练引擎文档](./engine.md)中找到有关它的详细信息。
+
+2. 在 `mmseg/evaluation/metrics/__init__.py` 中导入新的指标。
+
+   ```python
+   from .custom_metric import CustomMetric
+   __all__ = ['CustomMetric', ...]
+   ```
+
+3. 在配置文件中设置新的评测指标
+
+   ```python
+   val_evaluator = dict(type='CustomMetric', arg1=xxx, arg2=xxx)
+   test_evaluator = dict(type='CustomMetric', arg1=xxx, arg2=xxx)
+   ```
+
+## 使用发布版本的 MMSegmentation 进行开发
+
+上面的示例展示了如何使用 MMSegmentation 的源代码开发新指标。如果您想使用 MMSegmentation 的发布版本开发新指标，可以按照以下步骤操作。
+
+1. 创建一个新文件 `/Path/to/metrics/custom_metric.py`，实现 `process`，`compute_metrics` 和 `evaluate` 方法，`evaluate` 方法是可选的。
+
+2. 在代码或配置文件中导入新的指标。
+
+   ```python
+   from path.to.metrics import CustomMetric
+   ```
+
+   或者
+
+   ```python
+   custom_imports = dict(imports=['/Path/to/metrics'], allow_failed_imports=False)
+
+   val_evaluator = dict(type='CustomMetric', arg1=xxx, arg2=xxx)
+   test_evaluator = dict(type='CustomMetric', arg1=xxx, arg2=xxx)
+   ```
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/add_models.md b/mmsegmentation/docs/zh_cn/advanced_guides/add_models.md
new file mode 100644
index 0000000..e05c07c
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/advanced_guides/add_models.md
@@ -0,0 +1,260 @@
+# 新增模块
+
+## 开发新组件
+
+我们可以自定义 [模型文档](./models.md) 中介绍的所有组件，例如**主干网络（backbone）**、**头（head）**、**损失函数（loss function）**和**数据预处理器（data preprocessor）**。
+
+### 添加新的主干网络（backbone）
+
+在这里，我们以 MobileNet 为例展示如何开发新的主干网络。
+
+1. 创建一个新文件 `mmseg/models/backbones/mobilenet.py`。
+
+   ```python
+   import torch.nn as nn
+
+   from mmseg.registry import MODELS
+
+
+   @MODELS.register_module()
+   class MobileNet(nn.Module):
+
+       def __init__(self, arg1, arg2):
+           pass
+
+       def forward(self, x):  # should return a tuple
+           pass
+
+       def init_weights(self, pretrained=None):
+           pass
+   ```
+
+2. 在 `mmseg/models/backbones/__init__.py` 中引入模块。
+
+   ```python
+   from .mobilenet import MobileNet
+   ```
+
+3. 在配置文件中使用它。
+
+   ```python
+   model = dict(
+       ...
+       backbone=dict(
+           type='MobileNet',
+           arg1=xxx,
+           arg2=xxx),
+       ...
+   ```
+
+### 添加新的头（head）
+
+在 MMSegmentation 中，我们提供 [BaseDecodeHead](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/models/decode_heads/decode_head.py#L17) 用于开发所有分割头。
+所有新实现的解码头都应该从中派生出来。
+接下来我们以 [PSPNet](https://arxiv.org/abs/1612.01105) 为例说明如何开发新的头。
+
+首先，在 `mmseg/models/decode_heads/psp_head.py` 中添加一个新的解码头。
+PSPNet 实现了用于分割解码的解码头。
+为了实现解码头，在新模块中我们需要执行以下三个函数。
+
+```python
+from mmseg.registry import MODELS
+
+@MODELS.register_module()
+class PSPHead(BaseDecodeHead):
+
+    def __init__(self, pool_scales=(1, 2, 3, 6), **kwargs):
+        super(PSPHead, self).__init__(**kwargs)
+
+    def init_weights(self):
+        pass
+
+    def forward(self, inputs):
+        pass
+```
+
+接下来，用户需要在 `mmseg/models/decode_heads/__init__.py` 中添加模块，这样相应的注册器就可以找到并加载它们。
+
+PSPNet 的配置文件如下
+
+```python
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    type='EncoderDecoder',
+    pretrained='pretrain_model/resnet50_v1c_trick-2cccc1ad.pth',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='PSPHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        pool_scales=(1, 2, 3, 6),
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)))
+
+```
+
+### 添加新的损失函数（loss）
+
+假设您想为分割解码添加一个叫做 `MyLoss` 的新的损失函数。
+要添加新的损失函数，用户需要在 `mmseg/models/loss/my_loss.py` 中实现它。
+修饰器 `weighted_loss` 可以对损失的每个元素进行加权。
+
+```python
+import torch
+import torch.nn as nn
+
+from mmseg.registry import MODELS
+from .utils import weighted_loss
+
+@weighted_loss
+def my_loss(pred, target):
+    assert pred.size() == target.size() and target.numel() > 0
+    loss = torch.abs(pred - target)
+    return loss
+
+@MODELS.register_module()
+class MyLoss(nn.Module):
+
+    def __init__(self, reduction='mean', loss_weight=1.0):
+        super(MyLoss, self).__init__()
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+
+    def forward(self,
+                pred,
+                target,
+                weight=None,
+                avg_factor=None,
+                reduction_override=None):
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        loss = self.loss_weight * my_loss(
+            pred, target, weight, reduction=reduction, avg_factor=avg_factor)
+        return loss
+```
+
+然后，用户需要将其添加到 `mmseg/models/loss/__init__.py` 中。
+
+```python
+from .my_loss import MyLoss, my_loss
+
+```
+
+要使用它，请修改 `loss_xx` 字段。
+然后需要修改头中的 `loss_decode` 字段。
+`loss_weight` 可用于平衡多重损失。
+
+```python
+loss_decode=dict(type='MyLoss', loss_weight=1.0))
+```
+
+### 添加新的数据预处理器（data preprocessor）
+
+在 MMSegmentation 1.x 版本中，我们使用 [SegDataPreProcessor](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/data_preprocessor.py#L13) 将数据复制到目标设备，并将数据预处理为默认的模型输入格式。这里我们将展示如何开发一个新的数据预处理器。
+
+1. 创建一个新文件 `mmseg/models/my_datapreprocessor.py`。
+
+   ```python
+   from mmengine.model import BaseDataPreprocessor
+
+   from mmseg.registry import MODELS
+
+   @MODELS.register_module()
+   class MyDataPreProcessor(BaseDataPreprocessor):
+       def __init__(self, **kwargs):
+           super().__init__(**kwargs)
+
+       def forward(self, data: dict, training: bool=False) -> Dict[str, Any]:
+           # TODO Define the logic for data pre-processing in the forward method
+           pass
+   ```
+
+2. 在 `mmseg/models/__init__.py` 中导入数据预处理器
+
+   ```python
+   from .my_datapreprocessor import MyDataPreProcessor
+   ```
+
+3. 在配置文件中使用它。
+
+   ```python
+   model = dict(
+       data_preprocessor=dict(type='MyDataPreProcessor)
+       ...
+   )
+   ```
+
+## 开发新的分割器（segmentor）
+
+分割器是一种户可以通过添加自定义组件和定义算法执行逻辑来自定义其算法的算法架构。请参考[模型文档](./models.md)了解更多详情。
+
+由于 MMSegmentation 中的 [BaseSegmenter](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/models/segmentors/base.py#L15) 统一了前向过程的三种模式，为了开发新的分割器，用户需要重写与 `loss`、`predict` 和 `tensor` 相对应的 `loss`、`predict` 和 `_forward` 方法。
+
+这里我们将展示如何开发一个新的分割器。
+
+1. 创建一个新文件 `mmseg/models/segmentors/my_segmentor.py`。
+
+   ```python
+    from typing import Dict, Optional, Union
+
+    import torch
+
+    from mmseg.registry import MODELS
+    from mmseg.models import BaseSegmentor
+
+    @MODELS.register_module()
+    class MySegmentor(BaseSegmentor):
+        def __init__(self, **kwargs):
+            super().__init__(**kwargs)
+            # TODO users should build components of the network here
+
+        def loss(self, inputs: Tensor, data_samples: SampleList) -> dict:
+            """Calculate losses from a batch of inputs and data samples."""
+            pass
+
+        def predict(self, inputs: Tensor, data_samples: OptSampleList=None) -> SampleList:
+            """Predict results from a batch of inputs and data samples with post-
+            processing."""
+            pass
+
+       def _forward(self,
+                 inputs: Tensor,
+                 data_samples: OptSampleList = None) -> Tuple[List[Tensor]]:
+            """Network forward process.
+
+            Usually includes backbone, neck and head forward without any post-
+            processing.
+            """
+            pass
+   ```
+
+2. 在 `mmseg/models/segmentors/__init__.py` 中导入分割器。
+
+   ```python
+   from .my_segmentor import MySegmentor
+   ```
+
+3. 在配置文件中使用它。
+
+   ```python
+   model = dict(
+       type='MySegmentor'
+       ...
+   )
+   ```
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/add_transforms.md b/mmsegmentation/docs/zh_cn/advanced_guides/add_transforms.md
new file mode 100644
index 0000000..d720668
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/advanced_guides/add_transforms.md
@@ -0,0 +1,51 @@
+# 新增数据增强
+
+## 自定义数据增强
+
+自定义数据增强必须继承 `BaseTransform` 并实现 `transform` 函数。这里我们使用一个简单的翻转变换作为示例：
+
+```python
+import random
+import mmcv
+from mmcv.transforms import BaseTransform, TRANSFORMS
+
+@TRANSFORMS.register_module()
+class MyFlip(BaseTransform):
+    def __init__(self, direction: str):
+        super().__init__()
+        self.direction = direction
+
+    def transform(self, results: dict) -> dict:
+        img = results['img']
+        results['img'] = mmcv.imflip(img, direction=self.direction)
+        return results
+```
+
+此外，新的类需要被导入。
+
+```python
+from .my_pipeline import MyFlip
+```
+
+这样，我们就可以实例化一个 `MyFlip` 对象并使用它来处理数据字典。
+
+```python
+import numpy as np
+
+transform = MyFlip(direction='horizontal')
+data_dict = {'img': np.random.rand(224, 224, 3)}
+data_dict = transform(data_dict)
+processed_img = data_dict['img']
+```
+
+或者，我们可以在配置文件中的数据流程中使用 `MyFlip` 变换。
+
+```python
+pipeline = [
+    ...
+    dict(type='MyFlip', direction='horizontal'),
+    ...
+]
+```
+
+需要注意，如果要在配置文件中使用 `MyFlip`，必须确保在运行时导入了包含 `MyFlip` 的文件。
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/contribute_dataset.md b/mmsegmentation/docs/zh_cn/advanced_guides/contribute_dataset.md
new file mode 100644
index 0000000..4222de3
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/advanced_guides/contribute_dataset.md
@@ -0,0 +1,461 @@
+# 在 mmsegmentation projects 中贡献一个标准格式的数据集
+
+- 在开始您的贡献流程前，请先阅读[《OpenMMLab 贡献代码指南》](https://mmcv.readthedocs.io/zh_CN/latest/community/contributing.html)，以详细的了解 OpenMMLab 代码库的代码贡献流程。
+- 该教程以 [Gaofen Image Dataset (GID)](https://www.sciencedirect.com/science/article/pii/S0034425719303414) 高分 2 号卫星所拍摄的遥感图像语义分割数据集作为样例，来演示在 mmsegmentation 中的数据集贡献流程。
+
+## 步骤 1： 配置 mmsegmentation 开发所需必要环境
+
+- 开发所必需的环境安装请参考[中文快速入门指南](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/get_started.md)或[英文 get_started](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/get_started.md)。
+
+- 如果您已安装了最新版的 pytorch、mmcv、mmengine，那么您可以跳过步骤 1 至[步骤 2](<#[步骤-2](#%E6%AD%A5%E9%AA%A4-2%E4%BB%A3%E7%A0%81%E8%B4%A1%E7%8C%AE%E5%89%8D%E7%9A%84%E5%87%86%E5%A4%87%E5%B7%A5%E4%BD%9C)>)。
+
+- **注：** 在此处无需安装 mmsegmentation，只需安装开发 mmsegmentation 所必需的 pytorch、mmcv、mmengine 等即可。
+
+**新建虚拟环境（如已有合适的开发环境，可跳过）**
+
+- 从[官方网站](https://docs.conda.io/en/latest/miniconda.html)下载并安装 Miniconda
+- 创建一个 conda 环境，并激活
+
+```shell
+conda create --name openmmlab python=3.8 -y
+conda activate openmmlab
+```
+
+**安装 pytorch （如环境下已安装 pytorch，可跳过）**
+
+- 参考 [official instructions](https://pytorch.org/get-started/locally/) 安装 **PyTorch**
+
+**使用 mim 安装 mmcv、mmengine**
+
+- 使用 [MIM](https://github.com/open-mmlab/mim) 安装 [MMCV](https://github.com/open-mmlab/mmcv)
+
+```shell
+pip install -U openmim
+mim install mmengine
+mim install "mmcv>=2.0.0"
+```
+
+## 步骤 2：代码贡献前的准备工作
+
+### 2.1 Fork mmsegmentation 仓库
+
+- 通过浏览器打开[mmsegmentation 官方仓库](https://github.com/open-mmlab/mmsegmentation/tree/main)。
+- 登录您的 GitHub 账户，以下步骤均需在 GitHub 登录的情况下进行。
+- Fork mmsegmentation 仓库
+  ![image](https://user-images.githubusercontent.com/50650583/233825567-b8bf273c-38f5-4487-b4c6-75ede1e283ee.png)
+- Fork 之后，mmsegmentation 仓库将会出现在您的个人仓库中。
+
+### 2.2 在您的代码编写软件中 git clone mmsegmentation
+
+这里以 VSCODE 为例
+
+- 打开 VSCODE，新建终端窗口并激活您在[步骤 1 ](#%E6%AD%A5%E9%AA%A4-1-%E9%85%8D%E7%BD%AE-mmsegmentation-%E5%BC%80%E5%8F%91%E6%89%80%E9%9C%80%E5%BF%85%E8%A6%81%E7%8E%AF%E5%A2%83)中所安装的虚拟环境。
+- 在您 GitHub 的个人仓库中找到您 Fork 的 mmsegmentation 仓库，复制其链接。
+  ![image](https://github.com/AI-Tianlong/OpenMMLabCamp/assets/50650583/92ad555b-c5b2-4a7f-a800-ebee1e405ab6)
+- 在终端中执行命令
+  ```bash
+  git clone {您所复制的个人仓库的链接}
+  ```
+  ![image](https://github.com/AI-Tianlong/OpenMMLabCamp/assets/50650583/23ba2636-e66f-4ea5-9077-9dd6b69deb1d)
+  **注：** 如提示以下信息，请在 GitHub 中添加 [SSH 秘钥](https://docs.github.com/en/authentication/connecting-to-github-with-ssh/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent)
+  ![image](https://github.com/AI-Tianlong/OpenMMLabCamp/assets/50650583/6fcab213-0739-483c-b345-c59656027377)
+- 进入 mmsegmentation 目录（之后的操作均在 mmsegmentation 目录下）。
+  ```bash
+  cd mmsegmentation
+  ```
+- 在终端中执行以下命令，添加官方仓库为上游仓库。
+  ```bash
+  git remote add upstream git@github.com:open-mmlab/mmsegmentation.git
+  ```
+- 使用以下命令检查 remote 是否添加成功。
+  ```bash
+  git remote -v
+  ```
+  ![image](https://github.com/AI-Tianlong/OpenMMLabCamp/assets/50650583/beec7e5e-2b00-4e49-ab38-f0c79e346594)
+
+### 2.3 切换目录至 mmsegmentation 并从源码安装mmsegmentation
+
+在`mmsegmentation`目录下执行`pip install -v -e .`，通过源码构建方式安装 mmsegmentaion 库。
+安装完成后，您将能看到如下图所示的文件树。
+<img src="https://user-images.githubusercontent.com/50650583/233826064-4b111358-8f97-44dd-955c-df3204410b8b.png" alt="image" style="zoom:67%;" />
+
+### 2.4 切换分支为 dev-1.x
+
+正如您在[ mmsegmentation 官网](https://github.com/open-mmlab/mmsegmentation/tree/main)所见，该仓库有许多分支，默认分支`main`为稳定的发行版本，以及用于贡献者进行开发的`dev-1.x`分支。`dev-1.x`分支是贡献者们用来提交创意和 PR 的分支，`dev-1.x`分支的内容会被周期性的合入到`main`分支。
+![image](https://user-images.githubusercontent.com/50650583/233826225-f4b7299d-de23-47db-900d-dfb01ba0efc3.png)
+
+回到 VSCODE 中，在终端执行命令
+
+```bash
+git checkout dev-1.x
+```
+
+### 2.5 创新属于自己的新分支
+
+在基于`dev-1.x`分支下，使用如下命令，创建属于您自己的分支。
+
+```bash
+# git checkout -b 您的GitHubID/您的分支想要实现的功能的名字
+# git checkout -b AI-Tianlong/support_GID_dataset
+git checkout -b {您的GitHubID/您的分支想要实现的功能的名字}
+```
+
+### 2.6 配置 pre-commit
+
+OpenMMLab 仓库对代码质量有着较高的要求，所有提交的 PR 必须要通过代码格式检查。pre-commit 详细配置参阅[配置 pre-commit](https://mmcv.readthedocs.io/zh_CN/latest/community/contributing.html#pre-commit)。
+
+## 步骤 3：在`mmsegmentation/projects`下贡献您的代码
+
+**先对 GID 数据集进行分析**
+
+这里以贡献高分 2 号遥感图像语义分割数据集 GID 为例，GID 数据集是由我国自主研发的高分 2 号卫星所拍摄的光学遥感图像所创建，经图像预处理后共提供了 150 张 6800x7200 像素的 RGB 三通道遥感图像。并提供了两种不同类别数的数据标注，一种是包含 5 类有效物体的 RGB 标签，另一种是包含 15 类有效物体的 RGB 标签。本教程将针对 5 类标签进行数据集贡献流程讲解。
+
+GID 的 5 类有效标签分别为：0-背景-\[0,0,0\](mask 标签值-标签名称-RGB 标签值)、1-建筑-\[255,0,0\]、2-农田-\[0,255,0\]、3-森林-\[0,0,255\]、4-草地-\[255,255,0\]、5-水-\[0,0,255\]。在语义分割任务中，标签是与原图尺寸一致的单通道图像，标签图像中的像素值为真实样本图像中对应像素所包含的物体的类别。GID 数据集提供的是具有 RGB 三通道的彩色标签，为了模型的训练需要将 RGB 标签转换为 mask 标签。并且由于图像尺寸为 6800x7200 像素，对于神经网络的训练来有些过大，所以将每张图像裁切成了没有重叠的 512x512 的图像以便进行训练。
+<img align='center' src="https://user-images.githubusercontent.com/50650583/234192183-83ee4209-e181-4a18-90ca-4d71757cd2c7.png" alt="image" style="zoom:67%;" />
+
+### 3.1 在`mmsegmentation/projects`下创建新的项目文件夹
+
+在`mmsegmentation/projects`下创建文件夹`gid_dataset`
+![image](https://user-images.githubusercontent.com/50650583/233829687-8f2b6600-bc9d-48ff-a865-d462af54d55a.png)
+
+### 3.2 贡献您的数据集代码
+
+为了最终能将您在 projects 中贡献的代码更加顺畅的移入核心库中（对代码要求质量更高），非常建议按照核心库的目录来编辑您的数据集文件。
+关于数据集有 4 个必要的文件：
+
+- **1**  `mmseg/datasets/gid.py` 定义了数据集的尾缀、CLASSES、PALETTE、reduce_zero_label等
+- **2** `configs/_base_/gid.py` GID 数据集的配置文件，定义了数据集的`dataset_type`（数据集类型，`mmseg/datasets/gid.py`中注册的数据集的类名）、`data_root`(数据集所在的根目录，建议将数据集通过软连接的方式将数据集放至`mmsegmentation/data`)、`train_pipline`(训练的数据流)、`test_pipline`(测试和验证时的数据流)、`img_rations`(多尺度预测时的多尺度配置)、`tta_pipeline`（多尺度预测）、`train_dataloader`(训练集的数据加载器)、`val_dataloader`(验证集的数据加载器)、`test_dataloader`(测试集的数据加载器)、`val_evaluator`(验证集的评估器)、`test_evaluator`(测试集的评估器)。
+- **3** 使用了 GID 数据集的模型训练配置文件
+  这个是可选的，但是强烈建议您添加。在核心库中，所贡献的数据集需要和参考文献中所提出的结果精度对齐，为了后期将您贡献的代码合并入核心库。如您的算力充足，最好能提供对应的模型配置文件在您贡献的数据集上所验证的结果以及相应的权重文件，并撰写较为详细的README.md文档。[示例参考结果](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/deeplabv3plus#mapillary-vistas-v12)
+  ![image](https://user-images.githubusercontent.com/50650583/233877682-eabe8723-bce9-40e4-a303-08c8385cb6b5.png)
+- **4** 使用如下命令格式： 撰写`docs/zh_cn/user_guides/2_dataset_prepare.md`来添加您的数据集介绍，包括但不限于数据集的下载方式，数据集目录结构、数据集生成等一些必要性的文字性描述和运行命令。以更好地帮助用户能更快的实现数据集的准备工作。
+
+### 3.3 贡献`tools/dataset_converters/gid.py`
+
+由于 GID 数据集是由未经过切分的 6800x7200 图像所构成的数据集，并且没有划分训练集、验证集与测试集。以及其标签为 RGB 彩色标签，需要将标签转换为单通道的 mask label。为了方便训练，首先将 GID 数据集进行裁切和标签转换，并进行数据集划分，构建为 mmsegmentation 所支持的格式。
+
+```python
+# tools/dataset_converters/gid.py
+import argparse
+import glob
+import math
+import os
+import os.path as osp
+from PIL import Image
+
+import mmcv
+import numpy as np
+from mmengine.utils import ProgressBar, mkdir_or_exist
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Convert GID dataset to mmsegmentation format')
+    parser.add_argument('dataset_img_path', help='GID images folder path')
+    parser.add_argument('dataset_label_path', help='GID labels folder path')
+    parser.add_argument('--tmp_dir', help='path of the temporary directory')
+    parser.add_argument('-o', '--out_dir', help='output path', default='data/gid')
+    parser.add_argument(
+        '--clip_size',
+        type=int,
+        help='clipped size of image after preparation',
+        default=256)
+    parser.add_argument(
+        '--stride_size',
+        type=int,
+        help='stride of clipping original images',
+        default=256)
+    args = parser.parse_args()
+    return args
+
+GID_COLORMAP = dict(
+    Background=(0, 0, 0), #0-背景-黑色
+    Building=(255, 0, 0), #1-建筑-红色
+    Farmland=(0, 255, 0), #2-农田-绿色
+    Forest=(0, 0, 255), #3-森林-蓝色
+    Meadow=(255, 255, 0),#4-草地-黄色
+    Water=(0, 0, 255)#5-水-蓝色
+)
+palette = list(GID_COLORMAP.values())
+classes = list(GID_COLORMAP.keys())
+
+#############用列表来存一个 RGB 和一个类别的对应################
+def colormap2label(palette):
+    colormap2label_list = np.zeros(256**3, dtype = np.longlong)
+    for i, colormap in enumerate(palette):
+        colormap2label_list[(colormap[0] * 256 + colormap[1])*256+colormap[2]] = i
+    return colormap2label_list
+
+#############给定那个列表，和vis_png然后生成masks_png################
+def label_indices(RGB_label, colormap2label_list):
+    RGB_label = RGB_label.astype('int32')
+    idx = (RGB_label[:, :, 0] * 256 + RGB_label[:, :, 1]) * 256 + RGB_label[:, :, 2]
+    # print(idx.shape)
+    return colormap2label_list[idx]
+
+def RGB2mask(RGB_label, colormap2label_list):
+    # RGB_label = np.array(Image.open(RGB_label).convert('RGB')) #打开RGB_png
+    mask_label = label_indices(RGB_label, colormap2label_list) # .numpy()
+    return mask_label
+
+colormap2label_list = colormap2label(palette)
+
+def clip_big_image(image_path, clip_save_dir, args, to_label=False):
+    """
+    Original image of GID dataset is very large, thus pre-processing
+    of them is adopted. Given fixed clip size and stride size to generate
+    clipped image, the intersection　of width and height is determined.
+    For example, given one 6800 x 7200 original image, the clip size is
+    256 and stride size is 256, thus it would generate 29 x 27 = 783 images
+    whose size are all 256 x 256.
+
+    """
+
+    image = mmcv.imread(image_path, channel_order='rgb')
+    # image = mmcv.bgr2gray(image)
+
+    h, w, c = image.shape
+    clip_size = args.clip_size
+    stride_size = args.stride_size
+
+    num_rows = math.ceil((h - clip_size) / stride_size) if math.ceil(
+        (h - clip_size) /
+        stride_size) * stride_size + clip_size >= h else math.ceil(
+            (h - clip_size) / stride_size) + 1
+    num_cols = math.ceil((w - clip_size) / stride_size) if math.ceil(
+        (w - clip_size) /
+        stride_size) * stride_size + clip_size >= w else math.ceil(
+            (w - clip_size) / stride_size) + 1
+
+    x, y = np.meshgrid(np.arange(num_cols + 1), np.arange(num_rows + 1))
+    xmin = x * clip_size
+    ymin = y * clip_size
+
+    xmin = xmin.ravel()
+    ymin = ymin.ravel()
+    xmin_offset = np.where(xmin + clip_size > w, w - xmin - clip_size,
+                           np.zeros_like(xmin))
+    ymin_offset = np.where(ymin + clip_size > h, h - ymin - clip_size,
+                           np.zeros_like(ymin))
+    boxes = np.stack([
+        xmin + xmin_offset, ymin + ymin_offset,
+        np.minimum(xmin + clip_size, w),
+        np.minimum(ymin + clip_size, h)
+    ], axis=1)
+
+    if to_label:
+        image = RGB2mask(image, colormap2label_list) #这里得改一下
+
+    for count, box in enumerate(boxes):
+        start_x, start_y, end_x, end_y = box
+        clipped_image = image[start_y:end_y,
+                              start_x:end_x] if to_label else image[
+                                  start_y:end_y, start_x:end_x, :]
+        img_name = osp.basename(image_path).replace('.tif', '')
+        img_name = img_name.replace('_label', '')
+        if count % 3 == 0:
+            mmcv.imwrite(
+                clipped_image.astype(np.uint8),
+                osp.join(
+                    clip_save_dir.replace('train', 'val'),
+                    f'{img_name}_{start_x}_{start_y}_{end_x}_{end_y}.png'))
+        else:
+            mmcv.imwrite(
+                clipped_image.astype(np.uint8),
+                osp.join(
+                    clip_save_dir,
+                    f'{img_name}_{start_x}_{start_y}_{end_x}_{end_y}.png'))
+        count += 1
+
+def main():
+    args = parse_args()
+
+    """
+    According to this paper: https://ieeexplore.ieee.org/document/9343296/
+    select 15 images contained in GID, , which cover the whole six
+    categories, to generate train set and validation set.
+
+    According to Paper: https://ieeexplore.ieee.org/document/9343296/
+
+    """
+
+    if args.out_dir is None:
+        out_dir = osp.join('data', 'gid')
+    else:
+        out_dir = args.out_dir
+
+    print('Making directories...')
+    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'train'))
+    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'val'))
+    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'train'))
+    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'val'))
+
+    src_path_list = glob.glob(os.path.join(args.dataset_img_path, '*.tif'))
+    print(f'Find {len(src_path_list)} pictures')
+
+    prog_bar = ProgressBar(len(src_path_list))
+
+    dst_img_dir = osp.join(out_dir, 'img_dir', 'train')
+    dst_label_dir = osp.join(out_dir, 'ann_dir', 'train')
+
+    for i, img_path in enumerate(src_path_list):
+        label_path = osp.join(args.dataset_label_path, osp.basename(img_path.replace('.tif', '_label.tif')))
+
+        clip_big_image(img_path, dst_img_dir, args, to_label=False)
+        clip_big_image(label_path, dst_label_dir, args, to_label=True)
+        prog_bar.update()
+
+    print('Done!')
+
+if __name__ == '__main__':
+    main()
+```
+
+### 3.4 贡献`mmseg/datasets/gid.py`
+
+可参考[`projects/mapillary_dataset/mmseg/datasets/mapillary.py`](https://github.com/open-mmlab/mmsegmentation/blob/main/projects/mapillary_dataset/mmseg/datasets/mapillary.py)并在此基础上修改相应变量以适配您的数据集。
+
+```python
+# mmseg/datasets/gid.py
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmseg.datasets.basesegdataset import BaseSegDataset
+from mmseg.registry import DATASETS
+
+# 注册数据集类
+@DATASETS.register_module()
+class GID_Dataset(BaseSegDataset):
+    """Gaofen Image Dataset (GID)
+
+    Dataset paper link:
+    https://www.sciencedirect.com/science/article/pii/S0034425719303414
+    https://x-ytong.github.io/project/GID.html
+
+    GID  6 classes: background(others), built-up, farmland, forest, meadow, water
+
+    In This example, select 10 images from GID dataset as training set,
+    and select 5 images as validation set.
+    The selected images are listed as follows:
+
+    GF2_PMS1__L1A0000647767-MSS1
+    GF2_PMS1__L1A0001064454-MSS1
+    GF2_PMS1__L1A0001348919-MSS1
+    GF2_PMS1__L1A0001680851-MSS1
+    GF2_PMS1__L1A0001680853-MSS1
+    GF2_PMS1__L1A0001680857-MSS1
+    GF2_PMS1__L1A0001757429-MSS1
+    GF2_PMS2__L1A0000607681-MSS2
+    GF2_PMS2__L1A0000635115-MSS2
+    GF2_PMS2__L1A0000658637-MSS2
+    GF2_PMS2__L1A0001206072-MSS2
+    GF2_PMS2__L1A0001471436-MSS2
+    GF2_PMS2__L1A0001642620-MSS2
+    GF2_PMS2__L1A0001787089-MSS2
+    GF2_PMS2__L1A0001838560-MSS2
+
+    The ``img_suffix`` is fixed to '.tif' and ``seg_map_suffix`` is
+    fixed to '.tif' for GID.
+    """
+    METAINFO = dict(
+        classes=('Others', 'Built-up', 'Farmland', 'Forest',
+                 'Meadow', 'Water'),
+
+        palette=[[0, 0, 0], [255, 0, 0], [0, 255, 0], [0, 255, 255],
+                 [255, 255, 0], [0, 0, 255]])
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=None,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
+```
+
+### 3.5 贡献使用 GID 的训练 config file
+
+```python
+_base_ = [
+    '../../../configs/_base_/models/deeplabv3plus_r50-d8.py',
+    './_base_/datasets/gid.py',
+    '../../../configs/_base_/default_runtime.py',
+    '../../../configs/_base_/schedules/schedule_240k.py'
+]
+custom_imports = dict(
+    imports=['projects.gid_dataset.mmseg.datasets.gid'])
+
+crop_size = (256, 256)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet101_v1c',
+    backbone=dict(depth=101),
+    decode_head=dict(num_classes=6),
+    auxiliary_head=dict(num_classes=6))
+
+```
+
+### 3.6 撰写`docs/zh_cn/user_guides/2_dataset_prepare.md`
+
+**Gaofen Image Dataset (GID)**
+
+- GID 数据集可在[此处](https://x-ytong.github.io/project/Five-Billion-Pixels.html)进行下载。
+- GID 数据集包含 150 张 6800x7200 的大尺寸图像，标签为 RGB 标签。
+- 此处选择 15 张图像生成训练集和验证集，该 15 张图像包含了所有六类信息。所选的图像名称如下：
+
+```None
+  GF2_PMS1__L1A0000647767-MSS1
+  GF2_PMS1__L1A0001064454-MSS1
+  GF2_PMS1__L1A0001348919-MSS1
+  GF2_PMS1__L1A0001680851-MSS1
+  GF2_PMS1__L1A0001680853-MSS1
+  GF2_PMS1__L1A0001680857-MSS1
+  GF2_PMS1__L1A0001757429-MSS1
+  GF2_PMS2__L1A0000607681-MSS2
+  GF2_PMS2__L1A0000635115-MSS2
+  GF2_PMS2__L1A0000658637-MSS2
+  GF2_PMS2__L1A0001206072-MSS2
+  GF2_PMS2__L1A0001471436-MSS2
+  GF2_PMS2__L1A0001642620-MSS2
+  GF2_PMS2__L1A0001787089-MSS2
+  GF2_PMS2__L1A0001838560-MSS2
+```
+
+执行以下命令进行裁切及标签的转换，需要修改为您所存储 15 张图像及标签的路径。
+
+```
+python projects/gid_dataset/tools/dataset_converters/gid.py [15 张图像的路径] [15 张标签的路径]
+```
+
+完成裁切后的 GID 数据结构如下：
+
+```none
+mmsegmentation
+├── mmseg
+├── tools
+├── configs
+├── data
+│   ├── gid
+│   │   ├── ann_dir
+|   │   │   │   ├── train
+|   │   │   │   ├── val
+│   │   ├── img_dir
+|   │   │   │   ├── train
+|   │   │   │   ├── val
+
+```
+
+### 3.7 贡献的代码及文档通过`pre-commit`检查
+
+使用命令
+
+```bash
+git add .
+git commit -m "添加描述"
+git push
+```
+
+### 3.8 在 GitHub 中向 mmsegmentation 提交 PR
+
+具体步骤可见[《OpenMMLab 贡献代码指南》](https://mmcv.readthedocs.io/zh_CN/latest/community/contributing.html)
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/customize_runtime.md b/mmsegmentation/docs/zh_cn/advanced_guides/customize_runtime.md
new file mode 100644
index 0000000..a80aca6
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/advanced_guides/customize_runtime.md
@@ -0,0 +1,162 @@
+# 自定义运行设定
+
+## 实现自定义钩子
+
+### Step 1: 创建一个新的钩子
+
+MMEngine 已实现了训练和测试常用的[钩子](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/hook.md),
+当有定制化需求时, 可以按照如下示例实现适用于自身训练需求的钩子, 例如想修改一个超参数 `model.hyper_paramete` 的值, 让它随着训练迭代次数而变化:
+
+```python
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Sequence
+
+from mmengine.hooks import Hook
+from mmengine.model import is_model_wrapper
+
+from mmseg.registry import HOOKS
+
+
+@HOOKS.register_module()
+class NewHook(Hook):
+    """Docstring for NewHook.
+    """
+
+    def __init__(self, a: int, b: int) -> None:
+        self.a = a
+        self.b = b
+
+    def before_train_iter(self,
+                          runner,
+                          batch_idx: int,
+                          data_batch: Optional[Sequence[dict]] = None) -> None:
+        cur_iter = runner.iter
+        # 当模型被包在 wrapper 里时获取这个模型
+        if is_model_wrapper(runner.model):
+          model = runner.model.module
+        model.hyper_parameter = self.a * cur_iter + self.b
+```
+
+### Step 2: 导入一个新的钩子
+
+为了让上面定义的模块可以被执行的程序发现, 这个模块需要先被导入主命名空间 (main namespace) 里面,
+假设 NewHook 在 `mmseg/engine/hooks/new_hook.py` 里面, 有两种方式去实现它:
+
+- 修改 `mmseg/engine/hooks/__init__.py` 来导入它.
+  新定义的模块应该在 `mmseg/engine/hooks/__init__.py` 里面导入, 这样注册器可以发现并添加这个新的模块:
+
+```python
+from .new_hook import NewHook
+
+__all__ = [..., NewHook]
+```
+
+- 在配置文件里使用 custom_imports 来手动导入它.
+
+```python
+custom_imports = dict(imports=['mmseg.engine.hooks.new_hook'], allow_failed_imports=False)
+```
+
+### Step 3: 修改配置文件
+
+可以按照如下方式, 在训练或测试中配置并使用自定义的钩子. 不同钩子在同一位点的优先级可以参考[这里](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/hook.md#%E5%86%85%E7%BD%AE%E9%92%A9%E5%AD%90), 自定义钩子如果没有指定优先, 默认是 `NORMAL`.
+
+```python
+custom_hooks = [
+    dict(type='NewHook', a=a_value, b=b_value, priority='ABOVE_NORMAL')
+]
+```
+
+## 实现自定义优化器
+
+### Step 1: 创建一个新的优化器
+
+如果增加一个叫作 `MyOptimizer` 的优化器, 它有参数 `a`, `b` 和 `c`. 推荐在 `mmseg/engine/optimizers/my_optimizer.py` 文件中实现
+
+```python
+from mmseg.registry import OPTIMIZERS
+from torch.optim import Optimizer
+
+
+@OPTIMIZERS.register_module()
+class MyOptimizer(Optimizer):
+
+    def __init__(self, a, b, c)
+```
+
+### Step 2: 导入一个新的优化器
+
+为了让上面定义的模块可以被执行的程序发现, 这个模块需要先被导入主命名空间 (main namespace) 里面,
+假设 `MyOptimizer` 在 `mmseg/engine/optimizers/my_optimizer.py` 里面, 有两种方式去实现它:
+
+- 修改 `mmseg/engine/optimizers/__init__.py` 来导入它.
+  新定义的模块应该在 `mmseg/engine/optimizers/__init__.py` 里面导入, 这样注册器可以发现并添加这个新的模块:
+
+```python
+from .my_optimizer import MyOptimizer
+```
+
+- 在配置文件里使用 `custom_imports` 来手动导入它.
+
+```python
+custom_imports = dict(imports=['mmseg.engine.optimizers.my_optimizer'], allow_failed_imports=False)
+```
+
+### Step 3: 修改配置文件
+
+随后需要修改配置文件 `optim_wrapper` 里的 `optimizer` 参数, 如果要使用你自己的优化器 `MyOptimizer`, 字段可以被修改成:
+
+```python
+optim_wrapper = dict(type='OptimWrapper',
+                     optimizer=dict(type='MyOptimizer',
+                                    a=a_value, b=b_value, c=c_value),
+                     clip_grad=None)
+```
+
+## 实现自定义优化器封装构造器
+
+### Step 1: 创建一个新的优化器封装构造器
+
+构造器可以用来创建优化器, 优化器包, 以及自定义模型网络不同层的超参数. 一些模型的优化器可能会根据特定的参数而调整, 例如 BatchNorm 层的 weight decay. 使用者可以通过自定义优化器构造器来精细化设定不同参数的优化策略.
+
+```python
+from mmengine.optim import DefaultOptimWrapperConstructor
+from mmseg.registry import OPTIM_WRAPPER_CONSTRUCTORS
+
+@OPTIM_WRAPPER_CONSTRUCTORS.register_module()
+class LearningRateDecayOptimizerConstructor(DefaultOptimWrapperConstructor):
+    def __init__(self, optim_wrapper_cfg, paramwise_cfg=None):
+
+    def __call__(self, model):
+
+        return my_optimizer
+```
+
+默认的优化器构造器在[这里](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py#L19) 被实现, 它也可以用来作为新的优化器构造器的模板.
+
+### Step 2: 导入一个新的优化器封装构造器
+
+为了让上面定义的模块可以被执行的程序发现, 这个模块需要先被导入主命名空间 (main namespace) 里面, 假设 `MyOptimizerConstructor` 在 `mmseg/engine/optimizers/my_optimizer_constructor.py` 里面, 有两种方式去实现它:
+
+- 修改 `mmseg/engine/optimizers/__init__.py` 来导入它.
+  新定义的模块应该在 `mmseg/engine/optimizers/__init__.py` 里面导入, 这样注册器可以发现并添加这个新的模块:
+
+```python
+from .my_optimizer_constructor import MyOptimizerConstructor
+```
+
+- 在配置文件里使用 `custom_imports` 来手动导入它.
+
+```python
+custom_imports = dict(imports=['mmseg.engine.optimizers.my_optimizer_constructor'], allow_failed_imports=False)
+```
+
+### Step 3: 修改配置文件
+
+随后需要修改配置文件 `optim_wrapper`  里的 `constructor` 参数, 如果要使用你自己的优化器封装构造器 `MyOptimizerConstructor`, 字段可以被修改成:
+
+```python
+optim_wrapper = dict(type='OptimWrapper',
+                     constructor='MyOptimizerConstructor',
+                     clip_grad=None)
+```
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/data_flow.md b/mmsegmentation/docs/zh_cn/advanced_guides/data_flow.md
new file mode 100644
index 0000000..20dbe07
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/advanced_guides/data_flow.md
@@ -0,0 +1,90 @@
+# 数据流
+
+在本章节中，我们将介绍 [Runner](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/runner.html) 管理的内部模块之间的数据流和数据格式约定。
+
+## 数据流概述
+
+[Runner](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/design/runner.md) 相当于 MMEngine 中的“集成器”。它覆盖了框架的所有方面，并肩负着组织和调度几乎所有模块的责任，这意味着各模块之间的数据流也由 `Runner` 控制。 如 [MMEngine 中的 Runner 文档](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/runner.html)所示，下图展示了基本的数据流。
+
+![Basic dataflow](https://user-images.githubusercontent.com/112053249/199228350-5f80699e-7fd2-4b4c-ac32-0b16b1922c2e.png)
+
+虚线边框、灰色填充形状代表不同的数据格式，而实心框表示模块/方法。由于 MMEngine 极大的灵活性和可扩展性，一些重要的基类可以被继承，并且它们的方法可以被覆写。 上图所示数据流仅适用于当用户没有自定义 `Runner` 中的 `TrainLoop`、`ValLoop` 和 `TestLoop`，并且没有在其自定义模型中覆写 `train_step`、`val_step` 和 `test_step` 方法时。MMSegmentation 中 loop 的默认设置如下：使用`IterBasedTrainLoop` 训练模型，共计 20000 次迭代，并且在每 2000 次迭代后进行一次验证。
+
+```python
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=20000, val_interval=2000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+```
+
+在上图中，红色线表示 [train_step](./models.md#train_step)，在每次训练迭代中，数据加载器（dataloader）从存储中加载图像并传输到数据预处理器（data preprocessor），数据预处理器会将图像放到特定的设备上，并将数据堆叠到批处理中，之后模型接受批处理数据作为输入，最后将模型的输出发送给优化器（optimizer）。蓝色线表示 [val_step](./models.md#val_step) 和 [test_step](./models.md#test_step)。这两个过程的数据流除了模型输出与 `train_step` 不同外，其余均和 `train_step` 类似。由于在评估时模型参数会被冻结，因此模型的输出将被传递给 [Evaluator](./evaluation.md#ioumetric)。
+来计算指标。
+
+## MMSegmentation 中的数据流约定
+
+在上面的图中，我们可以看到基本的数据流。在本节中，我们将分别介绍数据流中涉及的数据的格式约定。
+
+### 数据加载器到数据预处理器
+
+数据加载器（DataLoader）是 MMEngine 的训练和测试流程中的一个重要组件。
+从概念上讲，它源于 [PyTorch](https://pytorch.org/) 并保持一致。DataLoader 从文件系统加载数据，原始数据通过数据准备流程后被发送给数据预处理器。
+
+MMSegmentation 在 [PackSegInputs](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/transforms/formatting.py#L12) 中定义了默认数据格式， 它是 `train_pipeline` 和 `test_pipeline` 的最后一个组件。有关数据转换 `pipeline` 的更多信息，请参阅[数据转换文档](./transforms.md)。
+
+在没有任何修改的情况下，PackSegInputs 的返回值通常是一个包含 `inputs` 和 `data_samples` 的 `dict`。以下伪代码展示了 mmseg 中数据加载器输出的数据类型，它是从数据集中获取的一批数据样本，数据加载器将它们打包成一个字典列表。`inputs` 是输入进模型的张量列表，`data_samples` 包含了输入图像的 meta information 和相应的 ground truth。
+
+```python
+dict(
+    inputs=List[torch.Tensor],
+    data_samples=List[SegDataSample]
+)
+```
+
+**注意：** [SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py) 是 MMSegmentation 的数据结构接口，用于连接不同组件。`SegDataSample` 实现了抽象数据元素 `mmengine.structures.BaseDataElement`，更多信息请在  [MMEngine](https://github.com/open-mmlab/mmengine) 中参阅 [SegDataSample 文档](./structures.md)和[数据元素文档](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/data_element.html)。
+
+### 数据预处理器到模型
+
+虽然在[上面的图](##数据流概述)中分开绘制了数据预处理器和模型，但数据预处理器是模型的一部分，因此可以在[模型教程](./models.md)中找到数据预处理器章节。
+
+数据预处理器的返回值是一个包含 `inputs` 和 `data_samples` 的字典，其中 `inputs` 是批处理图像的 4D 张量，`data_samples` 中添加了一些用于数据预处理的额外元信息。当传递给网络时，字典将被解包为两个值。 以下伪代码展示了数据预处理器的返回值和模型的输入值。
+
+```python
+dict(
+    inputs=torch.Tensor,
+    data_samples=List[SegDataSample]
+)
+```
+
+```python
+class Network(BaseSegmentor):
+
+    def forward(self, inputs: torch.Tensor, data_samples: List[SegDataSample], mode: str):
+        pass
+```
+
+**注意：** 模型的前向传播有 3 种模式，由输入参数 mode 控制，更多信息请参阅[模型教程](./models.md)。
+
+### 模型输出
+
+如[模型教程](./models.md#forward) ***（[中文链接待更新](./models.md#forward)）*** 所提到的 3 种前向传播具有 3 种输出。
+`train_step` 和 `test_step`（或 `val_step`）分别对应于 `'loss'` 和 `'predict'`。
+
+在 `test_step` 或 `val_step` 中，推理结果会被传递给 `Evaluator` 。您可以参阅[评估文档](./evaluation.md)来获取更多关于 `Evaluator` 的信息。
+
+在推理后，MMSegmentation 中的 [BaseSegmentor](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/segmentors/base.py#L15) 会对推理结果进行简单的后处理以打包推理结果。神经网络生成的分割 logits，经过 `argmax` 操作后的分割 mask 和 ground truth（如果存在）将被打包到类似 `SegDataSample` 的实例。 [postprocess_result](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/segmentors/base.py#L132) 的返回值是一个 **`SegDataSample`的`List`**。下图显示了这些 `SegDataSample` 实例的关键属性。
+
+![SegDataSample](https://user-images.githubusercontent.com/15952744/209912225-ab46a8d9-904a-43cb-8bf1-8bec4938ed29.png)
+
+与数据预处理器一致，损失函数也是模型的一部分，它是[解码头](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/decode_heads/decode_head.py#L142)的属性之一。
+
+在 MMSegmentation 中，`decode_head` 的 [loss_by_feat](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/decode_heads/decode_head.py#L291) 方法是用于计算损失的统一接口。
+
+参数：
+
+- seg_logits (Tensor)：解码头前向函数的输出
+- batch_data_samples (List\[SegDataSample\])：分割数据样本，通常包括如 `metainfo` 和  `gt_sem_seg` 等信息
+
+返回值：
+
+- dict\[str, Tensor\]：一个损失组件的字典
+
+**注意：**  `train_step` 将损失传递进 OptimWrapper 以更新模型中的权重，更多信息请参阅 [train_step](./models.md#train_step)。
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/datasets.md b/mmsegmentation/docs/zh_cn/advanced_guides/datasets.md
new file mode 100644
index 0000000..b45f2d2
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/advanced_guides/datasets.md
@@ -0,0 +1,363 @@
+# 数据集
+
+在 MMSegmentation 算法库中, 所有 Dataset 类的功能有两个: 加载[预处理](../user_guides/2_dataset_prepare.md) 之后的数据集的信息, 和将数据送入[数据集变换流水线](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/basesegdataset.py#L141) 中, 进行[数据变换操作](./transforms.md). 加载的数据集信息包括两类: 元信息 (meta information), 数据集本身的信息, 例如数据集总共的类别, 和它们对应调色盘信息: 数据信息 (data information) 是指每组数据中图片和对应标签的路径. 下文中介绍了 MMSegmentation 1.x 中数据集的常用接口, 和 mmseg 数据集基类中数据信息加载与修改数据集类别的逻辑, 以及数据集与数据变换流水线 (pipeline) 的关系.
+
+## 常用接口
+
+以 Cityscapes 为例, 介绍数据集常用接口. 如需运行以下示例, 请在当前工作目录下的 `data` 目录下载并[预处理](../user_guides/2_dataset_prepare.md#cityscapes) Cityscapes 数据集.
+
+实例化 Cityscapes 训练数据集:
+
+```python
+from mmengine.registry import init_default_scope
+from mmseg.datasets import CityscapesDataset
+
+init_default_scope('mmseg')
+
+data_root = 'data/cityscapes/'
+data_prefix=dict(img_path='leftImg8bit/train', seg_map_path='gtFine/train')
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='RandomCrop', crop_size=(512, 1024), cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackSegInputs')
+]
+
+dataset = CityscapesDataset(data_root=data_root, data_prefix=data_prefix, test_mode=False, pipeline=train_pipeline)
+```
+
+查看训练数据集长度:
+
+```python
+print(len(dataset))
+
+2975
+```
+
+获取数据信息, 数据信息的类型是一个字典, 包括 `'img_path'` 字段的存放图片的路径和 `'seg_map_path'` 字段存放分割标注的路径, 以及标签重映射的字段 `'label_map'` 和 `'reduce_zero_label'`(主要功能在下文中介绍), 还有存放已加载标签字段 `'seg_fields'`, 和当前样本的索引字段 `'sample_idx'`.
+
+```python
+# 获取数据集中第一组样本的数据信息
+print(dataset.get_data_info(0))
+
+{'img_path': 'data/cityscapes/leftImg8bit/train/aachen/aachen_000000_000019_leftImg8bit.png',
+ 'seg_map_path': 'data/cityscapes/gtFine/train/aachen/aachen_000000_000019_gtFine_labelTrainIds.png',
+ 'label_map': None,
+ 'reduce_zero_label': False,
+ 'seg_fields': [],
+ 'sample_idx': 0}
+```
+
+获取数据集元信息, MMSegmentation 的数据集元信息的类型同样是一个字典, 包括 `'classes'` 字段存放数据集类别, `'palette'` 存放数据集类别对应的可视化时调色盘的颜色, 以及标签重映射的字段 `'label_map'` 和 `'reduce_zero_label'`.
+
+```python
+print(dataset.metainfo)
+
+{'classes': ('road',
+  'sidewalk',
+  'building',
+  'wall',
+  'fence',
+  'pole',
+  'traffic light',
+  'traffic sign',
+  'vegetation',
+  'terrain',
+  'sky',
+  'person',
+  'rider',
+  'car',
+  'truck',
+  'bus',
+  'train',
+  'motorcycle',
+  'bicycle'),
+ 'palette': [[128, 64, 128],
+  [244, 35, 232],
+  [70, 70, 70],
+  [102, 102, 156],
+  [190, 153, 153],
+  [153, 153, 153],
+  [250, 170, 30],
+  [220, 220, 0],
+  [107, 142, 35],
+  [152, 251, 152],
+  [70, 130, 180],
+  [220, 20, 60],
+  [255, 0, 0],
+  [0, 0, 142],
+  [0, 0, 70],
+  [0, 60, 100],
+  [0, 80, 100],
+  [0, 0, 230],
+  [119, 11, 32]],
+ 'label_map': None,
+ 'reduce_zero_label': False}
+```
+
+数据集 `__getitem__` 方法的返回值, 是经过数据增强的样本数据的输出, 同样也是一个字典, 包括两个字段, `'inputs'` 字段是当前样本经过数据增强操作的图像, 类型为 torch.Tensor, `'data_samples'` 字段存放的数据类型是 MMSegmentation 1.x 新添加的数据结构 [`Segdatasample`](./structures.md), 其中`gt_sem_seg` 字段是经过数据增强的标签数据.
+
+```python
+print(dataset[0])
+
+{'inputs': tensor([[[131, 130, 130,  ...,  23,  23,  23],
+          [132, 132, 132,  ...,  23,  22,  23],
+          [134, 133, 133,  ...,  23,  23,  23],
+          ...,
+          [ 66,  67,  67,  ...,  71,  71,  71],
+          [ 66,  67,  66,  ...,  68,  68,  68],
+          [ 67,  67,  66,  ...,  70,  70,  70]],
+
+         [[143, 143, 142,  ...,  28,  28,  29],
+          [145, 145, 145,  ...,  28,  28,  29],
+          [145, 145, 145,  ...,  27,  28,  29],
+          ...,
+          [ 75,  75,  76,  ...,  80,  81,  81],
+          [ 75,  76,  75,  ...,  80,  80,  80],
+          [ 77,  76,  76,  ...,  82,  82,  82]],
+
+         [[126, 125, 126,  ...,  21,  21,  22],
+          [127, 127, 128,  ...,  21,  21,  22],
+          [127, 127, 126,  ...,  21,  21,  22],
+          ...,
+          [ 63,  63,  64,  ...,  69,  69,  70],
+          [ 64,  65,  64,  ...,  69,  69,  69],
+          [ 65,  66,  66,  ...,  72,  71,  71]]], dtype=torch.uint8),
+ 'data_samples': <SegDataSample(
+
+     META INFORMATION
+     img_path: 'data/cityscapes/leftImg8bit/train/aachen/aachen_000000_000019_leftImg8bit.png'
+     seg_map_path: 'data/cityscapes/gtFine/train/aachen/aachen_000000_000019_gtFine_labelTrainIds.png'
+     img_shape: (512, 1024, 3)
+     flip_direction: None
+     ori_shape: (1024, 2048)
+     flip: False
+
+     DATA FIELDS
+     gt_sem_seg: <PixelData(
+
+             META INFORMATION
+
+             DATA FIELDS
+             data: tensor([[[2, 2, 2,  ..., 8, 8, 8],
+                          [2, 2, 2,  ..., 8, 8, 8],
+                          [2, 2, 2,  ..., 8, 8, 8],
+                          ...,
+                          [0, 0, 0,  ..., 0, 0, 0],
+                          [0, 0, 0,  ..., 0, 0, 0],
+                          [0, 0, 0,  ..., 0, 0, 0]]])
+         )>
+     _gt_sem_seg: <PixelData(
+
+             META INFORMATION
+
+             DATA FIELDS
+             data: tensor([[[2, 2, 2,  ..., 8, 8, 8],
+                          [2, 2, 2,  ..., 8, 8, 8],
+                          [2, 2, 2,  ..., 8, 8, 8],
+                          ...,
+                          [0, 0, 0,  ..., 0, 0, 0],
+                          [0, 0, 0,  ..., 0, 0, 0],
+                          [0, 0, 0,  ..., 0, 0, 0]]])
+         )>
+ )}
+```
+
+## BaseSegDataset
+
+由于 MMSegmentation 中的所有数据集的基本功能均包括(1) 加载[数据集预处理](../user_guides/2_dataset_prepare.md) 之后的数据信息和 (2) 将数据送入数据变换流水线中进行数据变换, 因此在 MMSegmentation 中将其中的共同接口抽象成 [`BaseSegDataset`](https://mmsegmentation.readthedocs.io/zh_CN/latest/api.html?highlight=BaseSegDataset#mmseg.datasets.BaseSegDataset)，它继承自 [MMEngine 的 `BaseDataset`](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/basedataset.md), 遵循 OpenMMLab 数据集初始化统一流程, 支持高效的内部数据存储格式, 支持数据集拼接、数据集重复采样等功能.
+在 MMSegmentation BaseSegDataset 中重新定义了**数据信息加载方法**（`load_data_list`）和并新增了 `get_label_map` 方法用来**修改数据集的类别信息**.
+
+### 数据信息加载
+
+数据信息加载的内容是样本数据的图片路径和标签路径, 具体实现在 MMSegmentation 的 BaseSegDataset 的 [`load_data_list`](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/basesegdataset.py#L231) 中.
+主要有两种获取图片和标签的路径方法, 如果当数据集目录按以下目录结构组织, [`load_data_list`](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/basesegdataset.py#L231)) 会根据数据路径和后缀来解析.
+
+```
+├── data
+│   ├── my_dataset
+│   │   ├── img_dir
+│   │   │   ├── train
+│   │   │   │   ├── xxx{img_suffix}
+│   │   │   │   ├── yyy{img_suffix}
+│   │   │   ├── val
+│   │   │   │   ├── zzz{img_suffix}
+│   │   ├── ann_dir
+│   │   │   ├── train
+│   │   │   │   ├── xxx{seg_map_suffix}
+│   │   │   │   ├── yyy{seg_map_suffix}
+│   │   │   ├── val
+│   │   │   │   ├── zzz{seg_map_suffix}
+```
+
+例如 ADE20k 数据集结构如下所示:
+
+```
+├── ade
+│   ├── ADEChallengeData2016
+│   │   ├── annotations
+│   │   │   ├── training
+│   │   │   │   ├── ADE_train_00000001.png
+│   │   │   │   ├── ...
+│   │   │   │── validation
+│   │   │   │   ├── ADE_val_00000001.png
+│   │   │   │   ├── ...
+│   │   ├── images
+│   │   │   ├── training
+│   │   │   │   ├── ADE_train_00000001.jpg
+│   │   │   │   ├── ...
+│   │   │   ├── validation
+│   │   │   │   ├── ADE_val_00000001.jpg
+│   │   │   │   ├── ...
+```
+
+实例化 ADE20k 数据集时，输入图片和标签的路径和后缀:
+
+```python
+from mmseg.datasets import ADE20KDataset
+
+ADE20KDataset(data_root = 'data/ade/ADEChallengeData2016',
+    data_prefix=dict(img_path='images/training', seg_map_path='annotations/training'),
+    img_suffix='.jpg',
+    seg_map_suffix='.png',
+    reduce_zero_label=True）
+```
+
+如果数据集有标注文件, 实例化数据集时会根据输入的数据集标注文件加载数据信息. 例如, PascalContext 数据集实例, 输入标注文件的内容为:
+
+```python
+2008_000008
+...
+```
+
+实例化时需要定义 `ann_file`
+
+```python
+PascalContextDataset(data_root='data/VOCdevkit/VOC2010/',
+    data_prefix=dict(img_path='JPEGImages', seg_map_path='SegmentationClassContext'),
+    ann_file='ImageSets/SegmentationContext/train.txt')
+```
+
+### 数据集类别修改
+
+- 通过输入 metainfo 修改
+  `BaseSegDataset` 的子类元信息在数据集实现时定义为类变量，例如 Cityscapes 的 `METAINFO` 变量:
+
+```python
+class CityscapesDataset(BaseSegDataset):
+    """Cityscapes dataset.
+
+    The ``img_suffix`` is fixed to '_leftImg8bit.png' and ``seg_map_suffix`` is
+    fixed to '_gtFine_labelTrainIds.png' for Cityscapes dataset.
+    """
+    METAINFO = dict(
+        classes=('road', 'sidewalk', 'building', 'wall', 'fence', 'pole',
+                 'traffic light', 'traffic sign', 'vegetation', 'terrain',
+                 'sky', 'person', 'rider', 'car', 'truck', 'bus', 'train',
+                 'motorcycle', 'bicycle'),
+        palette=[[128, 64, 128], [244, 35, 232], [70, 70, 70], [102, 102, 156],
+                 [190, 153, 153], [153, 153, 153], [250, 170,
+                                                    30], [220, 220, 0],
+                 [107, 142, 35], [152, 251, 152], [70, 130, 180],
+                 [220, 20, 60], [255, 0, 0], [0, 0, 142], [0, 0, 70],
+                 [0, 60, 100], [0, 80, 100], [0, 0, 230], [119, 11, 32]])
+
+```
+
+这里的 `'classes'` 中定义了 Cityscapes 数据集标签中的类别名, 如果训练时只关注几个交通工具类别, **忽略其他类别**,
+在实例化 Cityscapes 数据集时通过定义 `metainfo` 输入参数的 classes 的字段来修改数据集的元信息:
+
+```python
+from mmseg.datasets import CityscapesDataset
+
+data_root = 'data/cityscapes/'
+data_prefix=dict(img_path='leftImg8bit/train', seg_map_path='gtFine/train')
+# metainfo 中只保留以下 classes
+metainfo=dict(classes=( 'car', 'truck', 'bus', 'train', 'motorcycle', 'bicycle'))
+dataset = CityscapesDataset(data_root=data_root, data_prefix=data_prefix, metainfo=metainfo)
+
+print(dataset.metainfo)
+
+{'classes': ('car', 'truck', 'bus', 'train', 'motorcycle', 'bicycle'),
+ 'palette': [[0, 0, 142],
+  [0, 0, 70],
+  [0, 60, 100],
+  [0, 80, 100],
+  [0, 0, 230],
+  [119, 11, 32],
+  [128, 64, 128],
+  [244, 35, 232],
+  [70, 70, 70],
+  [102, 102, 156],
+  [190, 153, 153],
+  [153, 153, 153],
+  [250, 170, 30],
+  [220, 220, 0],
+  [107, 142, 35],
+  [152, 251, 152],
+  [70, 130, 180],
+  [220, 20, 60],
+  [255, 0, 0]],
+ # 类别索引为 255 的像素，在计算损失时会被忽略
+ 'label_map': {0: 255,
+  1: 255,
+  2: 255,
+  3: 255,
+  4: 255,
+  5: 255,
+  6: 255,
+  7: 255,
+  8: 255,
+  9: 255,
+  10: 255,
+  11: 255,
+  12: 255,
+  13: 0,
+  14: 1,
+  15: 2,
+  16: 3,
+  17: 4,
+  18: 5},
+ 'reduce_zero_label': False}
+```
+
+可以看到, 数据集元信息的类别和默认 Cityscapes 不同. 并且, 定义了标签重映射的字段 `label_map` 用来修改每个分割掩膜上的像素的类别索引, 分割标签类别会根据 `label_map`, 将类别重映射, [具体实现](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/basesegdataset.py#L151):
+
+```python
+gt_semantic_seg_copy = gt_semantic_seg.copy()
+for old_id, new_id in results['label_map'].items():
+    gt_semantic_seg[gt_semantic_seg_copy == old_id] = new_id
+```
+
+- 通过 `reduce_zero_label` 修改
+  对于常见的忽略 0 号标签的场景, `BaseSegDataset` 的子类中可以用 `reduce_zero_label` 输入参数来控制。`reduce_zero_label` (默认为 `False`)
+  用来控制是否将标签 0 忽略, 当该参数为 `True` 时(最常见的应用是 ADE20k 数据集), 对分割标签中第 0 个类别对应的类别索引改为 255 (MMSegmentation 模型中计算损失时, 默认忽略 255), 其他类别对应的类别索引减一:
+
+```python
+gt_semantic_seg[gt_semantic_seg == 0] = 255
+gt_semantic_seg = gt_semantic_seg - 1
+gt_semantic_seg[gt_semantic_seg == 254] = 255
+```
+
+## 数据集与数据变换流水线
+
+在常用接口的例子中可以看到, 输入的参数中定义了数据变换流水线参数 `pipeline`, 数据集 `__getitem__` 方法返回经过数据变换的值.
+当数据集输入参数没有定义 pipeline, 返回值和 `get_data_info` 方法返回值相同, 例如:
+
+```python
+from mmseg.datasets import CityscapesDataset
+
+data_root = 'data/cityscapes/'
+data_prefix=dict(img_path='leftImg8bit/train', seg_map_path='gtFine/train')
+dataset = CityscapesDataset(data_root=data_root, data_prefix=data_prefix, test_mode=False)
+
+print(dataset[0])
+
+{'img_path': 'data/cityscapes/leftImg8bit/train/aachen/aachen_000000_000019_leftImg8bit.png',
+ 'seg_map_path': 'data/cityscapes/gtFine/train/aachen/aachen_000000_000019_gtFine_labelTrainIds.png',
+ 'label_map': None,
+ 'reduce_zero_label': False,
+ 'seg_fields': [],
+ 'sample_idx': 0}
+```
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/engine.md b/mmsegmentation/docs/zh_cn/advanced_guides/engine.md
new file mode 100644
index 0000000..79b4c8d
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/advanced_guides/engine.md
@@ -0,0 +1,281 @@
+# 训练引擎
+
+MMEngine 定义了一些[基础循环控制器](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py) 例如基于轮次的训练循环 (`EpochBasedTrainLoop`), 基于迭代次数的训练循环 (`IterBasedTrainLoop`), 标准的验证循环 (`ValLoop`) 和标准的测试循环 (`TestLoop`).
+OpenMMLab 的算法库如 MMSegmentation 将模型训练, 测试和推理抽象为执行器(`Runner`) 来处理. 用户可以直接使用 MMEngine 中的默认执行器, 也可以对执行器进行修改以满足定制化需求. 这个文档主要介绍用户如何配置已有的运行设定, 钩子和优化器的基本概念与使用方法.
+
+## 配置运行设定
+
+### 配置训练长度
+
+循环控制器指的是训练, 验证和测试时的执行流程, 在配置文件里面使用 `train_cfg`, `val_cfg` 和 `test_cfg` 来构建这些流程. MMSegmentation 在 `configs/_base_/schedules` 文件夹里面的 `train_cfg` 设置常用的训练长度.
+例如, 使用基于迭代次数的训练循环 (`IterBasedTrainLoop`) 去训练 80,000 个迭代次数, 并且每 8,000 iteration 做一次验证, 可以如下设置:
+
+```python
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=80000, val_interval=8000)
+```
+
+### 配置训练优化器
+
+这里是一个 SGD 优化器的例子:
+
+```python
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005),
+    clip_grad=None)
+```
+
+OpenMMLab 支持 PyTorch 里面所有的优化器, 更多细节可以参考 MMEngine [优化器文档](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/optim_wrapper.md).
+
+需要强调的是, `optim_wrapper` 是 `runner` 的变量, 所以需要配置优化器时配置的字段是 `optim_wrapper` 字段. 更多关于优化器的使用方法, 可以看下面优化器的章节.
+
+### 配置训练参数调度器
+
+在配置训练参数调度器前, 推荐先了解 [MMEngine 文档](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/param_scheduler.md) 里面关于参数调度器的基本概念.
+
+以下是一个参数调度器的例子, 训练时前 1,000 个 iteration 时采用线性变化的学习率策略作为训练预热, 从 1,000 iteration 之后直到最后 16,000 个 iteration 时则采用默认的多项式学习率衰减:
+
+```python
+param_scheduler = [
+    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=1000,
+        end=160000,
+        by_epoch=False,
+    )
+]
+```
+
+注意: 当修改 `train_cfg` 里面 `max_iters` 的时候, 请确保参数调度器 `param_scheduler` 里面的参数也被同时修改.
+
+## 钩子 (Hook)
+
+### 介绍
+
+OpenMMLab 将模型训练和测试过程抽象为 `Runner`, 插入钩子可以实现在 `Runner` 中不同的训练和测试节点 (例如 "每个训练 iter 前后", "每个验证 iter 前后" 等不同阶段) 所需要的相应功能. 更多钩子机制的介绍可以参考[这里](https://www.calltutors.com/blog/what-is-hook).
+
+`Runner` 中所使用的钩子分为两类:
+
+- 默认钩子 (default hooks)
+
+它们实现了训练时所必需的功能, 在配置文件中用 `default_hooks` 定义传给 `Runner`, `Runner` 通过 [`register_default_hooks`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py#L1780) 方法注册.
+钩子有对应的优先级, 优先级越高, 越早被执行器调用. 如果优先级一样, 被调用的顺序和钩子注册的顺序一致.
+不建议用户修改默认钩子的优先级, 可以参考 [mmengine hooks 文档](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/hook.md) 了解钩子优先级的定义.
+下面是 MMSegmentation 中所用到的默认钩子：
+
+|                                                          钩子                                                          |                                              功能                                               |      优先级       |
+| :--------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------: | :---------------: |
+|          [IterTimerHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/iter_timer_hook.py)           |                                   记录 iteration 花费的时间.                                    |    NORMAL (50)    |
+|              [LoggerHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/logger_hook.py)              | 从 `Runner` 里不同的组件中收集日志记录, 并将其输出到终端, JSON 文件, tensorboard, wandb 等下游. | BELOW_NORMAL (60) |
+|     [ParamSchedulerHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/param_scheduler_hook.py)      |                          更新优化器里面的一些超参数, 例如学习率的动量.                          |     LOW (70)      |
+|          [CheckpointHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/checkpoint_hook.py)          |                                  规律性地保存 checkpoint 文件.                                  |   VERY_LOW (90)   |
+|      [DistSamplerSeedHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/sampler_seed_hook.py)       |                               确保分布式采样器 shuffle 是打开的.                                |    NORMAL (50)    |
+| [SegVisualizationHook](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/visualization/local_visualizer.py) |                                可视化验证和测试过程里的预测结果.                                |    NORMAL (50)    |
+
+MMSegmentation 会在 [`defualt_hooks`](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/_base_/schedules/schedule_160k.py#L19-L25) 里面注册一些训练所必需功能的钩子::
+
+```python
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=32000),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))
+```
+
+以上默认钩子除 `SegVisualizationHook` 外都是在 MMEngine 中所实现, `SegVisualizationHook` 是在 MMSegmentation 里被实现的钩子, 之后会专门介绍.
+
+- 修改默认的钩子
+
+以 `default_hooks` 里面的 `logger` 和 `checkpoint` 为例, 我们来介绍如何修改 `default_hooks` 中默认的钩子.
+
+(1) 模型保存配置
+
+`default_hooks` 使用 `checkpoint` 字段来初始化[模型保存钩子 (CheckpointHook)](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/checkpoint_hook.py#L19).
+
+```python
+checkpoint = dict(type='CheckpointHook', interval=1)
+```
+
+用户可以设置 `max_keep_ckpts` 来只保存少量的检查点或者用 `save_optimizer` 来决定是否保存 optimizer 的信息.
+更多相关参数的细节可以参考[这里](https://mmengine.readthedocs.io/zh_CN/latest/api/generated/mmengine.hooks.CheckpointHook.html#checkpointhook).
+
+(2) 日志配置
+
+`日志钩子 (LoggerHook)` 被用来收集 `执行器 (Runner)` 里面不同组件的日志信息然后写入终端, JSON 文件, tensorboard 和 wandb 等地方.
+
+```python
+logger=dict(type='LoggerHook', interval=10)
+```
+
+在最新的 1.x 版本的 MMSegmentation 里面, 一些日志钩子 (LoggerHook) 例如 `TextLoggerHook`, `WandbLoggerHook` 和 `TensorboardLoggerHook` 将不再被使用.
+作为替代, MMEngine 使用 `LogProcessor` 来处理上述钩子处理的信息, 它们现在在 [`MessageHub`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/logging/message_hub.py#L17),
+[`WandbVisBackend`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/visualization/vis_backend.py#L324) 和 [`TensorboardVisBackend`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/visualization/vis_backend.py#L472) 里面.
+
+具体使用方法如下, 配置可视化器和同时指定可视化后端, 这里使用 Tensorboard 作为可视化器的后端:
+
+```python
+# TensorboardVisBackend
+visualizer = dict(
+    type='SegLocalVisualizer', vis_backends=[dict(type='TensorboardVisBackend')], name='visualizer')
+```
+
+关于更多相关用法, 可以参考 [MMEngine 可视化后端用户教程](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/advanced_tutorials/visualization.md).
+
+- 自定义钩子 (custom hooks)
+
+自定义钩子在配置通过 `custom_hooks` 定义, `Runner` 通过 [`register_custom_hooks`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py#L1820) 方法注册.
+自定义钩子优先级需要在配置文件里设置, 如果没有设置, 则会被默认设置为 `NORMAL`. 下面是部分 MMEngine 中实现的自定义钩子:
+
+|                                                  钩子                                                  |                                             用法                                             |
+| :----------------------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------: |
+|         [EMAHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/ema_hook.py)         |               在模型训练时使用指数滑动平均 (Exponential Moving Average, EMA).                |
+| [EmptyCacheHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/empty_cache_hook.py)  |                          在训练时释放所有没有被缓存占用的 GPU 显存.                          |
+| [SyncBuffersHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/sync_buffer_hook.py) | 在每个训练 Epoch 结束时同步模型 buffer 里的参数例如 BN 里的 `running_mean` 和 `running_var`. |
+
+以下是 `EMAHook` 的用例, 配置文件中, 将已经实现的自定义钩子的配置作为 `custom_hooks` 列表中的成员.
+
+```python
+custom_hooks = [
+    dict(type='EMAHook', start_iters=500, priority='NORMAL')
+]
+```
+
+### SegVisualizationHook
+
+MMSegmentation 实现了 [`SegVisualizationHook`](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/engine/hooks/visualization_hook.py#L17), 用来在验证和测试时可视化预测结果.
+`SegVisualizationHook` 重写了基类 `Hook` 中的 `_after_iter` 方法, 在验证或测试时, 根据指定的迭代次数间隔调用 `visualizer` 的 `add_datasample` 方法绘制语义分割结果, 具体实现如下:
+
+```python
+...
+@HOOKS.register_module()
+class SegVisualizationHook(Hook):
+...
+    def _after_iter(self,
+                    runner: Runner,
+                    batch_idx: int,
+                    data_batch: dict,
+                    outputs: Sequence[SegDataSample],
+                    mode: str = 'val') -> None:
+...
+        # 如果是训练阶段或者 self.draw 为 False 则直接跳出
+        if self.draw is False or mode == 'train':
+            return
+...
+        if self.every_n_inner_iters(batch_idx, self.interval):
+            for output in outputs:
+                img_path = output.img_path
+                img_bytes = self.file_client.get(img_path)
+                img = mmcv.imfrombytes(img_bytes, channel_order='rgb')
+                window_name = f'{mode}_{osp.basename(img_path)}'
+
+                self._visualizer.add_datasample(
+                    window_name,
+                    img,
+                    data_sample=output,
+                    show=self.show,
+                    wait_time=self.wait_time,
+                    step=runner.iter)
+
+```
+
+关于可视化更多的细节可以查看[这里](../user_guides/visualization.md).
+
+## 优化器
+
+在上面配置运行设定里, 我们给出了配置训练优化器的简单示例. 本章节将进一步详细介绍在 MMSegmentation 里如何配置优化器.
+
+### 优化器封装
+
+OpenMMLab 2.0 设计了优化器封装, 它支持不同的训练策略, 包括混合精度训练、梯度累加和梯度截断等, 用户可以根据需求选择合适的训练策略.
+优化器封装还定义了一套标准的参数更新流程, 用户可以基于这一套流程, 在同一套代码里, 实现不同训练策略的切换. 如果想了解更多, 可以参考 [MMEngine 优化器封装文档](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/optim_wrapper.md).
+
+以下是 MMSegmentation 中常用的使用方法:
+
+#### 配置 PyTorch 支持的优化器
+
+OpenMMLab 2.0 支持 PyTorch 原生所有优化器, 参考[这里](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/optim_wrapper.md#%E7%AE%80%E5%8D%95%E9%85%8D%E7%BD%AE).
+
+在配置文件中设置训练时 `Runner` 所使用的优化器, 需要定义 `optim_wrapper`, 而不是 `optimizer`, 下面是一个配置训练中优化器的例子:
+
+```python
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005),
+    clip_grad=None)
+```
+
+#### 配置梯度裁剪
+
+当模型训练需要使用梯度裁剪的训练技巧式, 可以按照如下示例进行配置:
+
+```python
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer,
+                        clip_grad=dict(max_norm=0.01, norm_type=2))
+```
+
+这里 `max_norm` 指的是裁剪后梯度的最大值,  `norm_type` 指的是裁剪梯度时使用的范数. 相关方法可参考 [torch.nn.utils.clip_grad_norm\_](https://pytorch.org/docs/stable/generated/torch.nn.utils.clip_grad_norm_.html).
+
+#### 配置混合精度训练
+
+当需要使用混合精度训练降低内存时, 可以使用 `AmpOptimWrapper`, 具体配置如下:
+
+```python
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='AmpOptimWrapper', optimizer=optimizer)
+```
+
+[`AmpOptimWrapper`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/amp_optimizer_wrapper.py#L20) 中 `loss_scale` 的默认设置是 `dynamic`.
+
+#### 配置模型网络不同层的超参数
+
+在模型训练中, 如果想在优化器里为不同参数分别设置优化策略, 例如设置不同的学习率、权重衰减等超参数, 可以通过设置配置文件里 `optim_wrapper` 中的 `paramwise_cfg` 来实现.
+
+下面的配置文件以 [ViT `optim_wrapper`](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_vit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py#L15-L27) 为例介绍 `paramwise_cfg` 参数使用.
+训练时将 `pos_embed`, `mask_token`, `norm` 模块的 weight decay 参数的系数设置成 0.
+即: 在训练时, 这些模块的 weight decay 将被变为 `weight_decay * decay_mult`=0.
+
+```python
+optimizer = dict(
+        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01)
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=optimizer,
+    paramwise_cfg=dict(
+        custom_keys={
+            'pos_embed': dict(decay_mult=0.),
+            'cls_token': dict(decay_mult=0.),
+            'norm': dict(decay_mult=0.)
+        }))
+```
+
+其中 `decay_mult` 指的是对应参数的权重衰减的系数.
+关于更多 `paramwise_cfg` 的使用可以在 [MMEngine 优化器封装文档](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/optim_wrapper.md) 里面查到.
+
+### 优化器封装构造器
+
+默认的优化器封装构造器 [`DefaultOptimWrapperConstructor`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py#L19) 根据输入的 `optim_wrapper` 和 `optim_wrapper` 中定义的 `paramwise_cfg` 来构建训练中使用的优化器. 当 [`DefaultOptimWrapperConstructor`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py#L19) 功能不能满足需求时, 可以自定义优化器封装构造器来实现超参数的配置.
+
+MMSegmentation 中的实现了 [`LearningRateDecayOptimizerConstructor`](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/engine/optimizers/layer_decay_optimizer_constructor.py#L104), 可以对以 ConvNeXt, BEiT 和 MAE 为骨干网络的模型训练时, 骨干网络的模型参数的学习率按照定义的衰减比例（`decay_rate`）逐层递减, 在配置文件中的配置如下:
+
+```python
+optim_wrapper = dict(
+    _delete_=True,
+    type='AmpOptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.05),
+    paramwise_cfg={
+        'decay_rate': 0.9,
+        'decay_type': 'stage_wise',
+        'num_layers': 12
+    },
+    constructor='LearningRateDecayOptimizerConstructor',
+    loss_scale='dynamic')
+```
+
+`_delete_=True` 的作用是 OpenMMLab Config 中的忽略继承的配置, 在该代码片段中忽略继承的 `optim_wrapper` 配置, 更多 `_delete_` 字段的内容可以参考 [MMEngine 文档](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/advanced_tutorials/config.md#%E5%88%A0%E9%99%A4%E5%AD%97%E5%85%B8%E4%B8%AD%E7%9A%84-key).
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/evaluation.md b/mmsegmentation/docs/zh_cn/advanced_guides/evaluation.md
new file mode 100644
index 0000000..dc93a46
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/advanced_guides/evaluation.md
@@ -0,0 +1,158 @@
+# 模型评测
+
+模型评测过程会分别在 [ValLoop](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py#L300) 和 [TestLoop](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py#L373) 中被执行，用户可以在训练期间或使用配置文件中简单设置的测试脚本进行模型性能评估。`ValLoop` 和 `TestLoop` 属于 [Runner](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py#L59)，它们会在第一次被调用时构建。由于 `dataloader` 与 `evaluator` 是必需的参数，所以要成功构建 `ValLoop`，在构建 `Runner` 时必须设置 `val_dataloader` 和 `val_evaluator`，`TestLoop` 亦然。有关 Runner 设计的更多信息，请参阅 [MMEngine](https://github.com/open-mmlab/mmengine) 的[文档](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/design/runner.md)。
+
+<center>
+  <img src='../../../resources/test_step.png' />
+  <center>测试/验证 数据流</center>
+</center>
+
+在 MMSegmentation 中，默认情况下，我们将 dataloader 和 metrics 的设置写在数据集配置文件中，并将 evaluation loop 的配置写在 `schedule_x` 配置文件中。
+
+例如，在 ADE20K 配置文件 `configs/_base_/dataset/ADE20K.py` 中，在第37到48行，我们配置了 `val_dataloader`，在第51行，我们选择 `IoUMetric` 作为 evaluator，并设置 `mIoU` 作为指标：
+
+```python
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
+        pipeline=test_pipeline))
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+```
+
+为了能够在训练期间进行评估模型，我们将评估配置添加到了 `configs/schedules/schedule_40k.py` 文件的第15至16行：
+
+```python
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=40000, val_interval=4000)
+val_cfg = dict(type='ValLoop')
+```
+
+使用以上两种设置，MMSegmentation 在 40K 迭代训练期间，每 4000 次迭代进行一次模型 **mIoU** 指标的评估。
+
+如果我们希望在训练后测试模型，则需要将 `test_dataloader`、`test_evaluator` 和 `test_cfg` 配置添加到配置文件中。
+
+```python
+test_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
+        pipeline=test_pipeline))
+
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_cfg = dict(type='TestLoop')
+```
+
+在 MMSegmentation 中，默认情况下，`test_dataloader` 和 `test_evaluator` 的设置与 `ValLoop` 的 dataloader 和 evaluator 相同，我们可以修改这些设置以满足我们的需要。
+
+## IoUMetric
+
+MMSegmentation 基于 [MMEngine](https://github.com/open-mmlab/mmengine) 提供的 [BaseMetric](https://github.com/open-mmlab/mmengine/blob/main/mmengine/evaluator/metric.py) 实现 [IoUMetric](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/evaluation/metrics/iou_metric.py) 和 [CityscapesMetric](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/evaluation/metrics/citys_metric.py)，以评估模型的性能。有关统一评估接口的更多详细信息，请参阅[文档](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/evaluation.html)。
+
+这里我们简要介绍 `IoUMetric` 的参数和两种主要方法。
+
+除了 `collect_device` 和 `prefix` 之外，`IoUMetric` 的构建还包含一些其他参数。
+
+构造函数的参数：
+
+- ignore_index（int）- 将在评估中忽略的类别索引。默认值：255。
+- iou_metrics（list\[str\] | str）- 需要计算的指标，可选项包括 'mIoU'、'mDice' 和 'mFscore'。
+- nan_to_num（int，可选）- 如果指定，NaN 值将被用户定义的数字替换。默认值：None。
+- beta（int）- 决定综合评分中 recall 的权重。默认值：1。
+- collect_device（str）- 用于在分布式训练期间从不同进程收集结果的设备名称。必须是 'cpu' 或 'gpu'。默认为 'cpu'。
+- prefix（str，可选）- 将添加到指标名称中的前缀，以消除不同 evaluator 的同名指标的歧义。如果参数中未提供前缀，则将使用 self.default_prefix 进行替代。默认为 None。
+
+`IoUMetric` 实现 IoU 指标的计算，`IoUMetric` 的两个核心方法是 `process` 和 `compute_metrics`。
+
+- `process` 方法处理一批 data 和 data_samples。
+- `compute_metrics` 方法根据处理的结果计算指标。
+
+### IoUMetric.process
+
+参数：
+
+- data_batch（Any）- 来自 dataloader 的一批数据。
+- data_samples（Sequence\[dict\]）- 模型的一批输出。
+
+返回值：
+
+此方法没有返回值，因为处理的结果将存储在 `self.results` 中，以在处理完所有批次后进行指标的计算。
+
+### IoUMetric.compute_metrics
+
+参数：
+
+- results（list）- 每个批次的处理结果。
+
+返回值：
+
+- Dict\[str，float\] - 计算的指标。指标的名称为 key，值是相应的结果。key 主要包括 **aAcc**、**mIoU**、**mAcc**、**mDice**、**mFscore**、**mPrecision**、**mPrecall**。
+
+## CityscapesMetric
+
+`CityscapesMetric` 使用由 Cityscapes 官方提供的 [CityscapesScripts](https://github.com/mcordts/cityscapesScripts) 进行模型性能的评估。
+
+### 使用方法
+
+在使用之前，请先安装 `cityscapesscripts` 包：
+
+```shell
+pip install cityscapesscripts
+```
+
+由于 `IoUMetric` 在 MMSegmentation 中作为默认的 evaluator 使用，如果您想使用 `CityscapesMetric`，则需要自定义配置文件。在自定义配置文件中，应按如下方式替换默认 evaluator。
+
+```python
+val_evaluator = dict(type='CityscapesMetric', output_dir='tmp')
+test_evaluator = val_evaluator
+```
+
+### 接口
+
+构造函数的参数：
+
+- output_dir (str) - 预测结果输出的路径
+- ignore_index (int) - 将在评估中忽略的类别索引。默认值：255。
+- format_only (bool) - 只为提交进行结果格式化而不进行评估。当您希望将结果格式化为特定格式并将其提交给测试服务器时有用。默认为 False。
+- keep_results (bool) - 是否保留结果。当 `format_only` 为 True 时，`keep_results` 必须为 True。默认为 False。
+- collect_device (str) - 用于在分布式训练期间从不同进程收集结果的设备名称。必须是 'cpu' 或 'gpu'。默认为 'cpu'。
+- prefix (str，可选) - 将添加到指标名称中的前缀，以消除不同 evaluator 的同名指标的歧义。如果参数中未提供前缀，则将使用 self.default_prefix 进行替代。默认为 None。
+
+#### CityscapesMetric.process
+
+该方法将在图像上绘制 mask，并将绘制的图像保存到 `work_dir` 中。
+
+参数：
+
+- data_batch（dict）- 来自 dataloader 的一批数据。
+- data_samples（Sequence\[dict\]）- 模型的一批输出。
+
+返回值：
+
+此方法没有返回值，因为处理的结果将存储在 `self.results` 中，以在处理完所有批次后进行指标的计算。
+
+#### CityscapesMetric.compute_metrics
+
+此方法将调用 `cityscapessscripts.evaluation.evalPixelLevelSemanticLabeling` 工具来计算指标。
+
+参数：
+
+- results（list）- 数据集的测试结果。
+
+返回值：
+
+- dict\[str:float\] - Cityscapes 评测结果。
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/index.rst b/mmsegmentation/docs/zh_cn/advanced_guides/index.rst
new file mode 100644
index 0000000..2aec1ac
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/advanced_guides/index.rst
@@ -0,0 +1,26 @@
+基本概念
+***************
+
+.. toctree::
+   :maxdepth: 1
+
+   data_flow.md
+   structures.md
+   models.md
+   datasets.md
+   transforms.md
+   evaluation.md
+   engine.md
+   training_tricks.md
+
+自定义组件
+************************
+
+.. toctree::
+   :maxdepth: 1
+
+   add_models.md
+   add_datasets.md
+   add_transforms.md
+   add_metrics.md
+   customize_runtime.md
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/models.md b/mmsegmentation/docs/zh_cn/advanced_guides/models.md
new file mode 100644
index 0000000..6eb2251
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/advanced_guides/models.md
@@ -0,0 +1,177 @@
+# 模型
+
+我们通常将深度学习任务中的神经网络定义为模型，这个模型即是算法的核心。[MMEngine](https://github.com/open-mmlab/mmengine) 抽象出了一个统一模型 [BaseModel](https://github.com/open-mmlab/mmengine/blob/main/mmengine/model/base_model/base_model.py#L16) 以标准化训练、测试和其他过程。MMSegmentation 实现的所有模型都继承自 `BaseModel`，并且在 MMSegmention 中，我们实现了前向传播并为语义分割算法添加了一些功能。
+
+## 常用组件
+
+### 分割器（Segmentor）
+
+在 MMSegmentation 中，我们将网络架构抽象为**分割器**，它是一个包含网络所有组件的模型。我们已经实现了**编码器解码器（EncoderDecoder）**和**级联编码器解码器（CascadeEncoderDecoder）**，它们通常由**数据预处理器**、**骨干网络**、**解码头**和**辅助头**组成。
+
+### 数据预处理器（Data preprocessor）
+
+**数据预处理器**是将数据复制到目标设备并将数据预处理为模型输入格式的部分。
+
+### 主干网络（Backbone）
+
+**主干网络**是将图像转换为特征图的部分，例如没有最后全连接层的 **ResNet-50**。
+
+### 颈部（Neck）
+
+**颈部**是连接主干网络和头的部分。它对主干网络生成的原始特征图进行一些改进或重新配置。例如 **Feature Pyramid Network（FPN）**。
+
+### 解码头（Decode head）
+
+**解码头**是将特征图转换为分割掩膜的部分，例如 **PSPNet**。
+
+### 辅助头（Auxiliary head）
+
+**辅助头**是一个可选组件，它将特征图转换为仅用于计算辅助损失的分割掩膜。
+
+## 基本接口
+
+MMSegmentation 封装 `BaseModel` 并实现了 [BaseSegmentor](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/models/segmentors/base.py#L15) 类，主要提供 `forward`、`train_step`、`val_step` 和 `test_step` 接口。接下来将详细介绍这些接口。
+
+### forward
+
+<center>
+  <img src='https://user-images.githubusercontent.com/15952744/228827860-c0e34875-d370-4736-84f0-9560c26c9576.png' />
+  <center>编码器解码器数据流</center>
+</center>
+
+<center>
+  <center><img src='https://user-images.githubusercontent.com/15952744/228827987-aa214507-0c6d-4a08-8ce4-679b2b200b79.png' /></center>
+  <center>级联编码器解码器数据流</center>
+</center>
+
+`forward` 方法返回训练、验证、测试和简单推理过程的损失或预测。
+
+该方法应接受三种模式：“tensor”、“predict” 和 “loss”：
+
+- “tensor”：前向推理整个网络并返回张量或张量数组，无需任何后处理，与常见的 `nn.Module` 相同。
+- “predict”：前向推理并返回预测值，这些预测值将被完全处理到 `SegDataSample` 列表中。
+- “loss”：前向推理并根据给定的输入和数据样本返回损失的`字典`。
+
+**注：**[SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py) 是 MMSegmentation 的数据结构接口，用作不同组件之间的接口。`SegDataSample` 实现了抽象数据元素 `mmengine.structures.BaseDataElement`，请参阅 [MMMEngine](https://github.com/open-mmlab/mmengine) 中的 [SegDataSample 文档](https://mmsegmentation.readthedocs.io/zh_CN/1.x/advanced_guides/structures.html)和[数据元素文档](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/data_element.html)了解更多信息。
+
+注意，此方法不处理在 `train_step` 方法中完成的反向传播或优化器更新。
+
+参数：
+
+- inputs（torch.Tensor）- 通常为形状是（N, C, ...) 的输入张量。
+- data_sample（list\[[SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py)\]) - 分割数据样本。它通常包括 `metainfo` 和 `gt_sem_seg` 等信息。默认值为 None。
+- mode (str) - 返回什么类型的值。默认为 'tensor'。
+
+返回值：
+
+- `dict` 或 `list`：
+  - 如果 `mode == "loss"`，则返回用于反向过程和日志记录的损失张量`字典`。
+  - 如果 `mode == "predict"`，则返回 `SegDataSample` 的`列表`，推理结果将被递增地添加到传递给 forward 方法的 `data_sample` 参数中，每个 `SegDataSeample` 包含以下关键词：
+    - pred_sm_seg (`PixelData`)：语义分割的预测。
+    - seg_logits (`PixelData`)：标准化前语义分割的预测指标。
+  - 如果 `mode == "tensor"`，则返回`张量`或`张量数组`的`字典`以供自定义使用。
+
+### 预测模式
+
+我们在[配置文档](../user_guides/1_config.md)中简要描述了模型配置的字段，这里我们详细介绍 `model.test_cfg` 字段。`model.test_cfg` 用于控制前向行为，`"predict"` 模式下的 `forward` 方法可以在两种模式下运行：
+
+- `whole_inference`：如果 `cfg.model.test_cfg.mode == 'whole'`，则模型将使用完整图像进行推理。
+
+  `whole_inference` 模式的一个示例配置：
+
+  ```python
+  model = dict(
+    type='EncoderDecoder'
+    ...
+    test_cfg=dict(mode='whole')
+  )
+  ```
+
+- `slide_inference`：如果 `cfg.model.test_cfg.mode == ‘slide’`，则模型将通过滑动窗口进行推理。**注意：** 如果选择 `slide` 模式，还应指定 `cfg.model.test_cfg.stride` 和 `cfg.model.test_cfg.crop_size`。
+
+  `slide_inference` 模式的一个示例配置：
+
+  ```python
+  model = dict(
+    type='EncoderDecoder'
+    ...
+    test_cfg=dict(mode='slide', crop_size=256, stride=170)
+  )
+  ```
+
+### train_step
+
+`train_step` 方法调用 `loss` 模式的前向接口以获得损失`字典`。`BaseModel` 类实现默认的模型训练过程，包括预处理、模型前向传播、损失计算、优化和反向传播。
+
+参数：
+
+- data (dict or tuple or list) - 从数据集采样的数据。在 MMSegmentation 中，数据字典包含 `inputs` 和 `data_samples` 两个字段。
+- optim_wrapper (OptimWrapper) - 用于更新模型参数的 OptimWrapper 实例。
+
+**注：**[OptimWrapper](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/optimizer_wrapper.py#L17) 提供了一个用于更新参数的通用接口，请参阅 [MMMEngine](https://github.com/open-mmlab/mmengine) 中的优化器封装[文档](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/optim_wrapper.html)了解更多信息。
+
+返回值：
+
+-Dict\[str, `torch.Tensor`\]：用于记录日志的张量的`字典`。
+
+<center>
+  <img src='https://user-images.githubusercontent.com/15952744/228828089-a9ae1225-958d-4cf7-99af-9af8576f7ef7.png' />
+  <center>train_step 数据流</center>
+</center>
+
+### val_step
+
+`val_step` 方法调用 `predict` 模式的前向接口并返回预测结果，预测结果将进一步被传递给评测器的进程接口和钩子的 `after_val_inter` 接口。
+
+参数：
+
+- data (`dict` or `tuple` or `list`) - 从数据集中采样的数据。在 MMSegmentation 中，数据字典包含 `inputs` 和 `data_samples` 两个字段。
+
+返回值：
+
+- `list` - 给定数据的预测结果。
+
+<center>
+  <img src='https://user-images.githubusercontent.com/15952744/228828179-3269baa3-bebd-4c9a-9787-59e7d785fbcf.png' />
+  <center>test_step/val_step 数据流</center>
+</center>
+
+### test_step
+
+`BaseModel` 中 `test_step` 与 `val_step` 的实现相同。
+
+## 数据预处理器（Data Preprocessor）
+
+MMSegmentation 实现的 [SegDataPreProcessor](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/models/data_preprocessor.py#L13) 继承自由 [MMEngine](https://github.com/open-mmlab/mmengine) 实现的 [BaseDataPreprocessor](https://github.com/open-mmlab/mmengine/blob/main/mmengine/model/base_model/data_preprocessor.py#L18)，提供数据预处理和将数据复制到目标设备的功能。
+
+Runner 在构建阶段将模型传送到指定的设备，而 [SegDataPreProcessor](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/models/data_preprocessor.py#L13) 在 `train_step`、`val_step` 和 `test_step` 中将数据传送到指定设备，之后处理后的数据将被进一步传递给模型。
+
+`SegDataPreProcessor` 构造函数的参数：
+
+- mean (Sequence\[Number\], 可选) - R、G、B 通道的像素平均值。默认为 None。
+- std (Sequence\[Number\], 可选) - R、G、B 通道的像素标准差。默认为 None。
+- size (tuple, 可选) - 固定的填充大小。
+- size_divisor (int, 可选) - 填充大小的除法因子。
+- pad_val (float, 可选) - 填充值。默认值：0。
+- seg_pad_val (float, 可选) - 分割图的填充值。默认值：255。
+- bgr_to_rgb (bool) - 是否将图像从 BGR 转换为 RGB。默认为 False。
+- rgb_to_bgr (bool) - 是否将图像从 RGB 转换为 BGR。默认为 False。
+- batch_augments (list\[dict\], 可选) - 批量化的数据增强。默认值为 None。
+
+数据将按如下方式处理：
+
+- 收集数据并将其移动到目标设备。
+- 用定义的 `pad_val` 将输入填充到输入大小，并用定义的 `seg_Pad_val` 填充分割图。
+- 将输入堆栈到 batch_input。
+- 如果输入的形状为 (3, H, W)，则将输入从 BGR 转换为 RGB。
+- 使用定义的标准差和平均值标准化图像。
+- 在训练期间进行如 Mixup 和 Cutmix 的批量化数据增强。
+
+`forward` 方法的参数：
+
+- data (dict) - 从数据加载器采样的数据。
+- training (bool) - 是否启用训练时数据增强。
+
+`forward` 方法的返回值：
+
+- Dict：与模型输入格式相同的数据。
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/structures.md b/mmsegmentation/docs/zh_cn/advanced_guides/structures.md
new file mode 100644
index 0000000..958e011
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/advanced_guides/structures.md
@@ -0,0 +1,102 @@
+# 数据结构
+
+为了统一模型和各功能模块之间的输入和输出的接口, 在 OpenMMLab 2.0 MMEngine 中定义了一套抽象数据结构, 实现了基础的增/删/查/改功能, 支持不同设备间的数据迁移, 也支持了如
+`.cpu()`, `.cuda()`, `.get()` 和 `.detach()` 的类字典和张量的操作。具体可以参考 [MMEngine 文档](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/data_element.md)。
+
+同样的, MMSegmentation 亦遵循了 OpenMMLab 2.0 各模块间的接口协议, 定义了 `SegDataSample` 用来封装语义分割任务所需要的数据。
+
+## 语义分割数据 SegDataSample
+
+[SegDataSample](mmseg.structures.SegDataSample) 包括了三个主要数据字段 `gt_sem_seg`, `pred_sem_seg` 和 `seg_logits`, 分别用来存放标注信息, 预测结果和预测的未归一化前的 logits 值。
+
+| 字段           | 类型                      | 描述                            |
+| -------------- | ------------------------- | ------------------------------- |
+| gt_sem_seg     | [`PixelData`](#pixeldata) | 图像标注信息.                   |
+| pred_instances | [`PixelData`](#pixeldata) | 图像预测结果.                   |
+| seg_logits     | [`PixelData`](#pixeldata) | 模型预测未归一化前的 logits 值. |
+
+以下示例代码展示了 `SegDataSample` 的使用方法：
+
+```python
+import torch
+from mmengine.structures import PixelData
+from mmseg.structures import SegDataSample
+
+img_meta = dict(img_shape=(4, 4, 3),
+                 pad_shape=(4, 4, 3))
+data_sample = SegDataSample()
+# 定义 gt_segmentations 用于封装模型的输出信息
+gt_segmentations = PixelData(metainfo=img_meta)
+gt_segmentations.data = torch.randint(0, 2, (1, 4, 4))
+
+# 增加和处理 SegDataSample　中的属性
+data_sample.gt_sem_seg = gt_segmentations
+assert 'gt_sem_seg' in data_sample
+assert 'data' in data_sample.gt_sem_seg
+assert 'img_shape' in data_sample.gt_sem_seg.metainfo_keys()
+print(data_sample.gt_sem_seg.shape)
+'''
+(4, 4)
+'''
+print(data_sample)
+'''
+<SegDataSample(
+
+    META INFORMATION
+
+    DATA FIELDS
+    gt_sem_seg: <PixelData(
+
+            META INFORMATION
+            img_shape: (4, 4, 3)
+            pad_shape: (4, 4, 3)
+
+            DATA FIELDS
+            data: tensor([[[1, 1, 1, 0],
+                         [1, 0, 1, 1],
+                         [1, 1, 1, 1],
+                         [0, 1, 0, 1]]])
+        ) at 0x1c2b4156460>
+) at 0x1c2aae44d60>
+'''
+
+# 删除和修改 SegDataSample　中的属性
+data_sample = SegDataSample()
+gt_segmentations = PixelData(metainfo=img_meta)
+gt_segmentations.data = torch.randint(0, 2, (1, 4, 4))
+data_sample.gt_sem_seg = gt_segmentations
+data_sample.gt_sem_seg.set_metainfo(dict(img_shape=(4,4,9), pad_shape=(4,4,9)))
+del data_sample.gt_sem_seg.img_shape
+
+# 类张量的操作
+data_sample = SegDataSample()
+gt_segmentations = PixelData(metainfo=img_meta)
+gt_segmentations.data = torch.randint(0, 2, (1, 4, 4))
+cuda_gt_segmentations = gt_segmentations.cuda()
+cuda_gt_segmentations = gt_segmentations.to('cuda:0')
+cpu_gt_segmentations = cuda_gt_segmentations.cpu()
+cpu_gt_segmentations = cuda_gt_segmentations.to('cpu')
+```
+
+## 在 SegDataSample 中自定义新的属性
+
+如果你想在 `SegDataSample` 中自定义新的属性，你可以参考下面的 [SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py) 示例:
+
+```python
+class SegDataSample(BaseDataElement):
+    ...
+
+    @property
+    def xxx_property(self) -> xxxData:
+        return self._xxx_property
+
+    @xxx_property.setter
+    def xxx_property(self, value: xxxData) -> None:
+        self.set_field(value, '_xxx_property', dtype=xxxData)
+
+    @xxx_property.deleter
+    def xxx_property(self) -> None:
+        del self._xxx_property
+```
+
+这样一个新的属性 `xxx_property` 就将被增加到 `SegDataSample` 里面了。
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/training_tricks.md b/mmsegmentation/docs/zh_cn/advanced_guides/training_tricks.md
new file mode 100644
index 0000000..e5b8e4d
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/advanced_guides/training_tricks.md
@@ -0,0 +1,74 @@
+# 训练技巧
+
+MMSegmentation 支持如下训练技巧：
+
+## 主干网络和解码头组件使用不同的学习率 (Learning Rate, LR)
+
+在语义分割里，一些方法会让解码头组件的学习率大于主干网络的学习率，这样可以获得更好的表现或更快的收敛。
+
+在 MMSegmentation 里面，您也可以在配置文件里添加如下行来让解码头组件的学习率是主干组件的10倍。
+
+```python
+optim_wrapper=dict(
+    paramwise_cfg = dict(
+        custom_keys={
+            'head': dict(lr_mult=10.)}))
+```
+
+通过这种修改，任何被分组到 `'head'` 的参数的学习率都将乘以10。您也可以参照 [MMEngine 文档](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/optim_wrapper.html#id6)  获取更详细的信息。
+
+## 在线难样本挖掘 (Online Hard Example Mining, OHEM)
+
+MMSegmentation 中实现了像素采样器，训练时可以对特定像素进行采样，例如 OHEM(Online Hard Example Mining)，可以解决样本不平衡问题，
+如下例子是使用 PSPNet 训练并采用 OHEM 策略的配置：
+
+```python
+_base_ = './pspnet_r50-d8_512x1024_40k_cityscapes.py'
+model=dict(
+    decode_head=dict(
+        sampler=dict(type='OHEMPixelSampler', thresh=0.7, min_kept=100000)) )
+```
+
+通过这种方式，只有置信分数在0.7以下的像素值点会被拿来训练。在训练时我们至少要保留100000个像素值点。如果 `thresh` 并未被指定，前 `min_kept`
+个损失的像素值点才会被选择。
+
+## 类别平衡损失 (Class Balanced Loss)
+
+对于不平衡类别分布的数据集，您也许可以改变每个类别的损失权重。这里以 cityscapes 数据集为例：
+
+```python
+_base_ = './pspnet_r50-d8_512x1024_40k_cityscapes.py'
+model=dict(
+    decode_head=dict(
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0,
+            # DeepLab 对 cityscapes 使用这种权重
+            class_weight=[0.8373, 0.9180, 0.8660, 1.0345, 1.0166, 0.9969, 0.9754,
+                        1.0489, 0.8786, 1.0023, 0.9539, 0.9843, 1.1116, 0.9037,
+                        1.0865, 1.0955, 1.0865, 1.1529, 1.0507])))
+```
+
+`class_weight` 将被作为 `weight` 参数，传递给 `CrossEntropyLoss`。详细信息请参照 [PyTorch 文档](https://pytorch.org/docs/stable/nn.html?highlight=crossentropy#torch.nn.CrossEntropyLoss) 。
+
+## 同时使用多种损失函数 (Multiple Losses)
+
+对于训练时损失函数的计算，我们目前支持多个损失函数同时使用。 以 `unet` 使用 `DRIVE` 数据集训练为例，
+使用 `CrossEntropyLoss` 和 `DiceLoss` 的 `1:3` 的加权和作为损失函数。配置文件写为:
+
+```python
+_base_ = './fcn_unet_s5-d16_64x64_40k_drive.py'
+model = dict(
+    decode_head=dict(loss_decode=[
+        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
+        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
+    ]),
+    auxiliary_head=dict(loss_decode=[
+        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
+        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
+    ]),
+)
+```
+
+通过这种方式，确定训练过程中损失函数的权重 `loss_weight` 和在训练日志里的名字 `loss_name`。
+
+注意： `loss_name` 的名字必须带有 `loss_` 前缀，这样它才能被包括在计算图里。
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/transforms.md b/mmsegmentation/docs/zh_cn/advanced_guides/transforms.md
new file mode 100644
index 0000000..e5f3beb
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/advanced_guides/transforms.md
@@ -0,0 +1,119 @@
+# 数据增强变化
+
+在本教程中，我们将介绍 MMSegmentation 中数据增强变化流程的设计。
+
+本指南的结构如下：
+
+- [数据增强变化](#数据增强变化)
+  - [数据增强变化流程设计](#数据增强变化流程设计)
+    - [数据加载](#数据加载)
+    - [预处理](#预处理)
+    - [格式修改](#格式修改)
+
+## 数据增强变化流程设计
+
+按照惯例，我们使用 `Dataset` 和 `DataLoader` 多进程地加载数据。`Dataset` 返回与模型 forward 方法的参数相对应的数据项的字典。由于语义分割中的数据可能大小不同，我们在 MMCV 中引入了一种新的 `DataContainer` 类型，以帮助收集和分发不同大小的数据。参见[此处](https://github.com/open-mmlab/mmcv/blob/master/mmcv/parallel/data_container.py)了解更多详情。
+
+在 MMSegmentation 的 1.x 版本中，所有数据转换都继承自 [`BaseTransform`](https://github.com/open-mmlab/mmcv/blob/2.x/mmcv/transforms/base.py#L6).
+
+转换的输入和输出类型都是字典。一个简单的示例如下：
+
+```python
+>>> from mmseg.datasets.transforms import LoadAnnotations
+>>> transforms = LoadAnnotations()
+>>> img_path = './data/cityscapes/leftImg8bit/train/aachen/aachen_000000_000019_leftImg8bit.png.png'
+>>> gt_path = './data/cityscapes/gtFine/train/aachen/aachen_000015_000019_gtFine_instanceTrainIds.png'
+>>> results = dict(
+>>>     img_path=img_path,
+>>>     seg_map_path=gt_path,
+>>>     reduce_zero_label=False,
+>>>     seg_fields=[])
+>>> data_dict = transforms(results)
+>>> print(data_dict.keys())
+dict_keys(['img_path', 'seg_map_path', 'reduce_zero_label', 'seg_fields', 'gt_seg_map'])
+```
+
+数据准备流程和数据集是解耦的。通常，数据集定义如何处理标注，数据流程定义准备数据字典的所有步骤。流程由一系列操作组成。每个操作都将字典作为输入，并为接下来的转换输出字典。
+
+操作分为数据加载、预处理、格式修改和测试数据增强。
+
+这里是 PSPNet 的流程示例：
+
+```python
+crop_size = (512, 1024)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=(2048, 1024),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+```
+
+对于每个操作，我们列出了 `添加`/`更新`/`删除` 相关的字典字段。在流程前，我们可以从数据集直接获得的信息是 `img_path` 和 `seg_map_path`。
+
+### 数据加载
+
+`LoadImageFromFile`：从文件加载图像。
+
+- 添加：`img`，`img_shape`，`ori_shape`
+
+`LoadAnnotations`：加载数据集提供的语义分割图。
+
+- 添加：`seg_fields`，`gt_seg_map`
+
+### 预处理
+
+`RandomResize`：随机调整图像和分割图大小。
+
+-添加：`scale`，`scale_factor`，`keep_ratio`
+-更新：`img`，`img_shape`，`gt_seg_map`
+
+`Resize`：调整图像和分割图的大小。
+
+-添加：`scale`，`scale_factor`，`keep_ratio`
+-更新：`img`，`gt_seg_map`，`img_shape`
+
+`RandomCrop`：随机裁剪图像和分割图。
+
+-更新：`img`，`gt_seg_map`，`img_shape`
+
+`RandomFlip`：翻转图像和分割图。
+
+-添加：`flip`，`flip_direction`
+-更新：`img`，`gt_seg_map`
+
+`PhotoMetricDistortion`：按顺序对图像应用光度失真，每个变换的应用概率为 0.5。随机对比度的位置是第二或倒数第二（分别为下面的模式 0 或 1）。
+
+```
+1.随机亮度
+2.随机对比度（模式 0）
+3.将颜色从 BGR 转换为 HSV
+4.随机饱和度
+5.随机色调
+6.将颜色从 HSV 转换为 BGR
+7.随机对比度（模式 1）
+```
+
+- 更新：`img`
+
+### 格式修改
+
+`PackSegInputs`：为语义分段打包输入数据。
+
+- 添加：`inputs`，`data_sample`
+- 删除：由 `meta_keys` 指定的 keys（合并到 data_sample 的 metainfo 中），所有其他 keys
diff --git a/mmsegmentation/docs/zh_cn/api.rst b/mmsegmentation/docs/zh_cn/api.rst
new file mode 100644
index 0000000..3478aa9
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/api.rst
@@ -0,0 +1,95 @@
+mmseg.apis
+--------------
+.. automodule:: mmseg.apis
+    :members:
+
+mmseg.datasets
+--------------
+
+datasets
+^^^^^^^^^^
+.. automodule:: mmseg.datasets
+    :members:
+
+transforms
+^^^^^^^^^^^^
+.. automodule:: mmseg.datasets.transforms
+    :members:
+
+mmseg.engine
+--------------
+
+hooks
+^^^^^^^^^^
+.. automodule:: mmseg.engine.hooks
+    :members:
+
+optimizers
+^^^^^^^^^^^^^^^
+.. automodule:: mmseg.engine.optimizers
+    :members:
+
+mmseg.evaluation
+--------------
+
+metrics
+^^^^^^^^^^
+.. automodule:: mmseg.evaluation.metrics
+    :members:
+
+mmseg.models
+--------------
+
+backbones
+^^^^^^^^^^^^^^^^^^
+.. automodule:: mmseg.models.backbones
+    :members:
+
+decode_heads
+^^^^^^^^^^^^^^^
+.. automodule:: mmseg.models.decode_heads
+    :members:
+
+segmentors
+^^^^^^^^^^
+.. automodule:: mmseg.models.segmentors
+    :members:
+
+losses
+^^^^^^^^^^
+.. automodule:: mmseg.models.losses
+    :members:
+
+necks
+^^^^^^^^^^^^
+.. automodule:: mmseg.models.necks
+    :members:
+
+utils
+^^^^^^^^^^
+.. automodule:: mmseg.models.utils
+    :members:
+
+
+mmseg.structures
+--------------------
+
+structures
+^^^^^^^^^^^^^^^^^
+.. automodule:: mmseg.structures
+    :members:
+
+sampler
+^^^^^^^^^^
+.. automodule:: mmseg.structures.sampler
+    :members:
+
+mmseg.visualization
+--------------------
+.. automodule:: mmseg.visualization
+    :members:
+
+mmseg.utils
+--------------
+.. automodule:: mmseg.utils
+    :members:
diff --git a/mmsegmentation/docs/zh_cn/conf.py b/mmsegmentation/docs/zh_cn/conf.py
new file mode 100644
index 0000000..1842055
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/conf.py
@@ -0,0 +1,133 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+import subprocess
+import sys
+
+import pytorch_sphinx_theme
+
+sys.path.insert(0, os.path.abspath('../../'))
+
+# -- Project information -----------------------------------------------------
+
+project = 'MMSegmentation'
+copyright = '2020-2021, OpenMMLab'
+author = 'MMSegmentation Authors'
+version_file = '../../mmseg/version.py'
+
+
+def get_version():
+    with open(version_file) as f:
+        exec(compile(f.read(), version_file, 'exec'))
+    return locals()['__version__']
+
+
+# The full version, including alpha/beta/rc tags
+release = get_version()
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    'sphinx.ext.autodoc', 'sphinx.ext.napoleon', 'sphinx.ext.viewcode',
+    'sphinx_markdown_tables', 'sphinx_copybutton', 'myst_parser'
+]
+
+autodoc_mock_imports = [
+    'matplotlib', 'pycocotools', 'mmseg.version', 'mmcv.ops'
+]
+
+# Ignore >>> when copying code
+copybutton_prompt_text = r'>>> |\.\.\. '
+copybutton_prompt_is_regexp = True
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+#
+source_suffix = {
+    '.rst': 'restructuredtext',
+    '.md': 'markdown',
+}
+
+# The master toctree document.
+master_doc = 'index'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+# html_theme = 'sphinx_rtd_theme'
+html_theme = 'pytorch_sphinx_theme'
+html_theme_path = [pytorch_sphinx_theme.get_html_theme_path()]
+html_theme_options = {
+    'logo_url':
+    'https://mmsegmentation.readthedocs.io/zh-CN/latest/',
+    'menu': [
+        {
+            'name':
+            '教程',
+            'url':
+            'https://github.com/open-mmlab/mmsegmentation/blob/master/'
+            'demo/MMSegmentation_Tutorial.ipynb'
+        },
+        {
+            'name': 'GitHub',
+            'url': 'https://github.com/open-mmlab/mmsegmentation'
+        },
+        {
+            'name':
+            '上游库',
+            'children': [
+                {
+                    'name': 'MMCV',
+                    'url': 'https://github.com/open-mmlab/mmcv',
+                    'description': '基础视觉库'
+                },
+            ]
+        },
+    ],
+    # Specify the language of shared menu
+    'menu_lang':
+    'cn',
+}
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+html_css_files = ['css/readthedocs.css']
+
+# Enable ::: for my_st
+myst_enable_extensions = ['colon_fence']
+
+language = 'zh-CN'
+
+
+def builder_inited_handler(app):
+    subprocess.run(['./stat.py'])
+
+
+def setup(app):
+    app.connect('builder-inited', builder_inited_handler)
diff --git a/mmsegmentation/docs/zh_cn/device/npu.md b/mmsegmentation/docs/zh_cn/device/npu.md
new file mode 100644
index 0000000..d50439d
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/device/npu.md
@@ -0,0 +1,39 @@
+# NPU (华为 昇腾)
+
+## 使用方法
+
+请参考 [MMCV 的安装文档](https://mmcv.readthedocs.io/en/latest/get_started/build.html#build-mmcv-full-on-ascend-npu-machine) 来安装 NPU 版本的 MMCV。
+
+以下展示单机四卡场景的运行指令:
+
+```shell
+bash tools/dist_train.sh configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py 4
+```
+
+以下展示单机单卡下的运行指令:
+
+```shell
+python tools/train.py configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py
+```
+
+## 模型验证结果
+
+|        Model        | mIoU  | Config                                                                                                                                     | Download                                                                                                                                    |
+| :-----------------: | :---: | :----------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------ |
+|   [deeplabv3](<>)   | 78.85 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py)         | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024_20230115_205626.json)     |
+| [deeplabv3plus](<>) | 79.23 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024.py) | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024_20230116_043450.json) |
+|     [hrnet](<>)     | 78.1  | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/hrnet/fcn_hr18_4xb2-40k_cityscapes-512x1024.py)                     | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/fcn_hr18_4xb2-40k_cityscapes-512x1024_20230116_215821.json)             |
+|      [fcn](<>)      | 74.15 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py)                     | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/fcn_r50-d8_4xb2-40k_cityscapes-512x1024_20230111_083014.json)           |
+|     [icnet](<>)     | 69.25 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/icnet/icnet_r50-d8_4xb2-80k_cityscapes-832x832.py)                  | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/icnet_r50-d8_4xb2-80k_cityscapes-832x832_20230119_002929.json)          |
+|    [pspnet](<>)     | 77.21 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024.py)              | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024_20230114_042721.json)       |
+|     [unet](<>)      | 68.86 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/unet/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py)              | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024_20230129_224750.json)     |
+|    [upernet](<>)    | 77.81 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/upernet/upernet_r50_4xb2-40k_cityscapes-512x1024.py)                | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/upernet_r50_4xb2-40k_cityscapes-512x1024_20230129_014634.json)          |
+|    [apcnet](<>)     | 78.02 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py)               | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/apcnet_r50-d8_4xb2-40k_cityscapes-512x1024_20230209_212545.json)        |
+|   [bisenetv1](<>)   | 76.04 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024.py)      | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024_20230201_023946.json)  |
+|   [bisenetv2](<>)   | 72.44 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/bisenetv2/bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024.py)      | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024_20230205_215606.json)  |
+
+**注意:**
+
+- 如果没有特别标记，NPU 上的使用混合精度训练的结果与使用 FP32 的 GPU 上的结果相同。
+
+**以上模型结果由华为昇腾团队提供**
diff --git a/mmsegmentation/docs/zh_cn/get_started.md b/mmsegmentation/docs/zh_cn/get_started.md
new file mode 100644
index 0000000..ca375f3
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/get_started.md
@@ -0,0 +1,209 @@
+# 开始：安装和运行 MMSeg
+
+## 预备知识
+
+本教程中，我们将会演示如何使用 PyTorch 准备环境。
+
+MMSegmentation 可以在 Linux, Windows 和 macOS 系统上运行，并且需要安装 Python 3.7+, CUDA 10.2+ 和 PyTorch 1.8+
+
+**注意:**
+如果您已经安装了 PyTorch, 可以跳过该部分，直接到[下一小节](##安装)。否则，您可以按照以下步骤操作。
+
+**步骤 0.** 从[官方网站](https://docs.conda.io/en/latest/miniconda.html)下载并安装 Miniconda
+
+**步骤 1.** 创建一个 conda 环境，并激活
+
+```shell
+conda create --name openmmlab python=3.8 -y
+conda activate openmmlab
+```
+
+**Step 2.** 参考 [official instructions](https://pytorch.org/get-started/locally/) 安装 PyTorch
+
+在 GPU 平台上：
+
+```shell
+conda install pytorch torchvision -c pytorch
+```
+
+在 CPU 平台上
+
+```shell
+conda install pytorch torchvision cpuonly -c pytorch
+```
+
+## 安装
+
+我们建议用户遵循我们的最佳实践来安装 MMSegmentation 。但是整个过程是高度自定义的。更多信息请参见[自定义安装](##自定义安装)部分。
+
+### 最佳实践
+
+**步骤 0.** 使用 [MIM](https://github.com/open-mmlab/mim) 安装 [MMCV](https://github.com/open-mmlab/mmcv)
+
+```shell
+pip install -U openmim
+mim install mmengine
+mim install "mmcv>=2.0.0"
+```
+
+**步骤 1.** 安装 MMSegmentation
+
+情况 a: 如果您想立刻开发和运行 mmsegmentation，您可通过源码安装：
+
+```shell
+git clone -b main https://github.com/open-mmlab/mmsegmentation.git
+cd mmsegmentation
+pip install -v -e .
+# '-v' 表示详细模式，更多的输出
+# '-e' 表示以可编辑模式安装工程，
+# 因此对代码所做的任何修改都生效，无需重新安装
+```
+
+情况 b: 如果您把 mmsegmentation 作为依赖库或者第三方库，可以通过 pip 安装：
+
+```shell
+pip install "mmsegmentation>=1.0.0"
+```
+
+### 验证是否安装成功
+
+为了验证 MMSegmentation 是否正确安装，我们提供了一些示例代码来运行一个推理 demo 。
+
+**步骤 1.** 下载配置文件和模型文件
+
+```shell
+mim download mmsegmentation --config pspnet_r50-d8_4xb2-40k_cityscapes-512x1024 --dest .
+```
+
+该下载过程可能需要花费几分钟，这取决于您的网络环境。当下载结束，您将看到以下两个文件在您当前工作目录：`pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py` 和 `pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth`
+
+**步骤 2.** 验证推理 demo
+
+选项 (a). 如果您通过源码安装了 mmsegmentation，运行以下命令即可：
+
+```shell
+python demo/image_demo.py demo/demo.png configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth --device cuda:0 --out-file result.jpg
+```
+
+您将在当前文件夹中看到一个新图像 `result.jpg`，其中所有目标都覆盖了分割 mask
+
+选项 (b). 如果您通过 pip 安装 mmsegmentation, 打开您的 python 解释器，复制粘贴以下代码：
+
+```python
+from mmseg.apis import inference_model, init_model, show_result_pyplot
+import mmcv
+
+config_file = 'pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+checkpoint_file = 'pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
+
+# 根据配置文件和模型文件建立模型
+model = init_model(config_file, checkpoint_file, device='cuda:0')
+
+# 在单张图像上测试并可视化
+img = 'demo/demo.png'  # or img = mmcv.imread(img), 这样仅需下载一次
+result = inference_model(model, img)
+# 在新的窗口可视化结果
+show_result_pyplot(model, img, result, show=True)
+# 或者将可视化结果保存到图像文件夹中
+# 您可以修改分割 map 的透明度 (0, 1].
+show_result_pyplot(model, img, result, show=True, out_file='result.jpg', opacity=0.5)
+# 在一段视频上测试并可视化分割结果
+video = mmcv.VideoReader('video.mp4')
+for frame in video:
+   result = inference_model(model, frame)
+   show_result_pyplot(model, frame, result, wait_time=1)
+```
+
+您可以修改上面的代码来测试单个图像或视频，这两个选项都可以验证安装是否成功。
+
+### 自定义安装
+
+#### CUDA 版本
+
+当安装 PyTorch 的时候，您需要指定 CUDA 的版本， 如果您不确定选择哪个版本，请遵循我们的建议：
+
+- 对于基于 Ampere 的 NVIDIA GPUs, 例如 GeForce 30 系列和 NVIDIA A100, 必须要求是 CUDA 11.
+- 对于更老的 NVIDIA GPUs, CUDA 11 is backward compatible, but CUDA 10.2 提供了更好的兼容性，以及更加的轻量化
+
+请确保 GPU 驱动满足最小的版本需求。详情请参考这个[表格](https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html#cuda-major-component-versions__table-cuda-toolkit-driver-versions)
+
+**注意:**
+如果您按照我们的最佳实践，安装 CUDA 运行库就足够了，因为不需要 CUDA 代码在本地编译。 但是如果您希望从源码编译 MMCV 或者需要开发其他的 CUDA 算子，您需要从 NVIDIA 的[官网](https://developer.nvidia.com/cuda-downloads)安装完整的 CUDA 工具，同时它的版本需要与 PyTorch 的 CUDA 版本匹配。即 `conda install` 命令中指定的 cudatoolkit 版本。
+
+#### 不使用 MIM 安装 MMCV
+
+MMCV 包含 C++ 和 CUDA 扩展，因此与 PyTorch 的依赖方式比较复杂。MIM 自动解决了这种依赖关系，使安装更容易。然而，MIM 也并不是必须的。
+
+为了使用 pip 而不是 MIM 安装 MMCV, 请参考 [MMCV 安装指南](https://mmcv.readthedocs.io/en/latest/get_started/installation.html). 这需要手动指定一个基于 PyTorch 版本及其 CUDA 版本的 find-url.
+
+例如，以下命令可为 PyTorch 1.10.x and CUDA 11.3 安装 mmcv==2.0.0
+
+```shell
+pip install mmcv==2.0.0 -f https://download.openmmlab.com/mmcv/dist/cu113/torch1.10/index.html
+```
+
+#### 在仅有 CPU 的平台安装
+
+MMSegmentation 可以在仅有 CPU 的版本上运行。在 CPU 模式，您可以训练（需要 MMCV 版本 >= 2.0.0），测试和推理模型。
+
+#### 在 Google Colab 上安装
+
+[Google Colab](https://research.google.com/) 通常已经安装了 PyTorch，因此我们仅需要通过以下命令安装 MMCV 和 MMSegmentation。
+
+**步骤 1.** 使用 [MIM](https://github.com/open-mmlab/mim) 安装 [MMCV](https://github.com/open-mmlab/mmcv)
+
+```shell
+!pip3 install openmim
+!mim install mmengine
+!mim install "mmcv>=2.0.0"
+```
+
+**Step 2.** 通过源码安装 MMSegmentation
+
+```shell
+!git clone https://github.com/open-mmlab/mmsegmentation.git
+%cd mmsegmentation
+!git checkout main
+!pip install -e .
+```
+
+**Step 3.** 验证
+
+```python
+import mmseg
+print(mmseg.__version__)
+# 示例输出: 1.0.0
+```
+
+**注意:**
+在 Jupyter 中, 感叹号 `!` 用于调用外部可执行命令，`%cd` 是一个 [magic command](https://ipython.readthedocs.io/en/stable/interactive/magics.html#magic-cd) 可以改变当前 python 的工作目录。
+
+### 通过 Docker 使用 MMSegmentation
+
+我们提供了一个 [Dockerfile](https://github.com/open-mmlab/mmsegmentation/blob/master/docker/Dockerfile) 来建立映像。确保您的 [docker 版本](https://docs.docker.com/engine/install/) >=19.03.
+
+```shell
+# 通过 PyTorch 1.11, CUDA 11.3 建立映像
+# 如果您使用其他版本，修改 Dockerfile 即可
+docker build -t mmsegmentation docker/
+```
+
+运行：
+
+```shell
+docker run --gpus all --shm-size=8g -it -v {DATA_DIR}:/mmsegmentation/data mmsegmentation
+```
+
+### 可选依赖
+
+#### 安装 GDAL
+
+[GDAL](https://gdal.org/) 是一个用于栅格和矢量地理空间数据格式的转换库。安装 GDAL 可以读取复杂格式和极大的遥感图像。
+
+```shell
+conda install GDAL
+```
+
+## 问题解答
+
+如果您在安装过程中遇到了其他问题，请第一时间查阅 [FAQ](notes/faq.md) 文件。如果没有找到答案，您也可以在 GitHub 上提出 [issue](https://github.com/open-mmlab/mmsegmentation/issues/new/choose)
diff --git a/mmsegmentation/docs/zh_cn/index.rst b/mmsegmentation/docs/zh_cn/index.rst
new file mode 100644
index 0000000..ce5e499
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/index.rst
@@ -0,0 +1,57 @@
+欢迎来到 MMSegmentation 的文档!
+=======================================
+
+.. toctree::
+   :maxdepth: 2
+   :caption: 开始你的第一步
+
+   get_started.md
+
+.. toctree::
+   :maxdepth: 2
+   :caption: 用户指南
+
+   user_guides/index.rst
+
+.. toctree::
+   :maxdepth: 2
+   :caption: 进阶指南
+
+   advanced_guides/index.rst
+
+.. toctree::
+   :maxdepth: 1
+   :caption: 迁移指引
+
+   migration/index.rst
+
+.. toctree::
+   :caption: 接口文档（英文）
+
+   api.rst
+
+.. toctree::
+   :maxdepth: 1
+   :caption: 模型库
+
+   model_zoo.md
+   modelzoo_statistics.md
+
+.. toctree::
+   :maxdepth: 2
+   :caption: 说明
+
+   changelog.md
+   faq.md
+
+.. toctree::
+   :caption: 语言切换
+
+   switch_language.md
+
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`search`
diff --git a/mmsegmentation/docs/zh_cn/make.bat b/mmsegmentation/docs/zh_cn/make.bat
new file mode 100644
index 0000000..922152e
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/make.bat
@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=.
+set BUILDDIR=_build
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.http://sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd
diff --git a/mmsegmentation/docs/zh_cn/migration/index.rst b/mmsegmentation/docs/zh_cn/migration/index.rst
new file mode 100644
index 0000000..854b9e6
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/migration/index.rst
@@ -0,0 +1,8 @@
+迁移
+***************
+
+.. toctree::
+    :maxdepth: 1
+
+    interface.md
+    package.md
diff --git a/mmsegmentation/docs/zh_cn/migration/interface.md b/mmsegmentation/docs/zh_cn/migration/interface.md
new file mode 100644
index 0000000..42f91bf
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/migration/interface.md
@@ -0,0 +1,523 @@
+# 从 MMSegmentation 0.x 迁移
+
+## 引言
+
+本指南介绍了 MMSegmentation 0.x 和 MMSegmentation1.x 在表现和 API 方面的基本区别，以及这些与迁移过程的关系。
+
+## 新的依赖
+
+MMSegmentation 1.x 依赖于一些新的软件包，您可以准备一个新的干净环境，然后根据[安装教程](../get_started.md)重新安装。
+
+或手动安装以下软件包。
+
+1. [MMEngine](https://github.com/open-mmlab/mmengine)：MMEngine 是 OpenMMLab 2.0 架构的核心，我们将许多与计算机视觉无关的内容从 MMCV 拆分到 MMEngine 中。
+
+2. [MMCV](https://github.com/open-mmlab/mmcv)：OpenMMLab 的计算机视觉包。这不是一个新的依赖，但您需要将其升级到 **2.0.0** 或以上的版本。
+
+3. [MMClassification](https://github.com/open-mmlab/mmclassification)（可选）：OpenMMLab 的图像分类工具箱和基准。这不是一个新的依赖，但您需要将其升级到 **1.0.0rc6** 版本。
+
+4. [MMDetection](https://github.com/open-mmlab/mmdetection)(可选): OpenMMLab 的目标检测工具箱和基准。这不是一个新的依赖，但您需要将其升级到 **3.0.0** 或以上的版本。
+
+## 启动训练
+
+OpenMMLab 2.0 的主要改进是发布了 MMEngine，它为启动训练任务的统一接口提供了通用且强大的执行器。
+
+与 MMSeg 0.x 相比，MMSeg 1.x 在 `tools/train.py` 中提供的命令行参数更少
+
+<table class="docutils">
+<tr>
+<td>功能</td>
+<td>原版</td>
+<td>新版</td>
+</tr>
+<tr>
+<td>加载预训练模型</td>
+<td>--load_from=$CHECKPOINT</td>
+<td>--cfg-options load_from=$CHECKPOINT</td>
+</tr>
+<tr>
+<td>从特定检查点恢复训练</td>
+<td>--resume-from=$CHECKPOINT</td>
+<td>--resume=$CHECKPOINT</td>
+</tr>
+<tr>
+<td>从最新的检查点恢复训练</td>
+<td>--auto-resume</td>
+<td>--resume='auto'</td>
+</tr>
+<tr>
+<td>训练期间是否不评估检查点</td>
+<td>--no-validate</td>
+<td>--cfg-options val_cfg=None val_dataloader=None val_evaluator=None</td>
+</tr>
+<tr>
+<td>指定训练设备</td>
+<td>--gpu-id=$DEVICE_ID</td>
+<td>-</td>
+</tr>
+<tr>
+<td>是否为不同进程设置不同的种子</td>
+<td>--diff-seed</td>
+<td>--cfg-options randomness.diff_rank_seed=True</td>
+</tr>
+<td>是否为 CUDNN 后端设置确定性选项</td>
+<td>--deterministic</td>
+<td>--cfg-options randomness.deterministic=True</td>
+</table>
+
+## 测试启动
+
+与训练启动类似，MMSegmentation 1.x 的测试启动脚本在 tools/test.py 中仅提供关键命令行参数，以下是测试启动脚本的区别，更多关于测试启动的细节请参考[这里](../user_guides/4_train_test.md)。
+
+<table class="docutils">
+<tr>
+<td>功能</td>
+<td>0.x</td>
+<td>1.x</td>
+</tr>
+<tr>
+<td>指定评测指标</td>
+<td>--eval mIoU</td>
+<td>--cfg-options test_evaluator.type=IoUMetric</td>
+</tr>
+<tr>
+<td>测试时数据增强</td>
+<td>--aug-test</td>
+<td>--tta</td>
+</tr>
+<tr>
+<td>测试时是否只保存预测结果不计算评测指标</td>
+<td>--format-only</td>
+<td>--cfg-options test_evaluator.format_only=True</td>
+</tr>
+</table>
+
+## 配置文件
+
+### 模型设置
+
+`model.backend`、`model.neck`、`model.decode_head` 和 `model.loss` 字段没有更改。
+
+添加 `model.data_preprocessor` 字段以配置 `DataPreProcessor`，包括：
+
+- `mean`（Sequence，可选）：R、G、B 通道的像素平均值。默认为 None。
+
+- `std`（Sequence，可选）：R、G、B 通道的像素标准差。默认为 None。
+
+- `size`（Sequence，可选）：固定的填充大小。
+
+- `size_divisor`（int，可选）：填充图像可以被当前值整除。
+
+- `seg_pad_val`（float，可选）：分割图的填充值。默认值：255。
+
+- `padding_mode`（str）：填充类型。默认值：'constant'。
+
+  - constant：常量值填充，值由 pad_val 指定。
+
+- `bgr_to_rgb`（bool）：是否将图像从 BGR 转换为 RGB。默认为 False。
+
+- `rgb_to_bgr`（bool）：是否将图像从 RGB 转换为 BGR。默认为 False。
+
+**注：**
+有关详细信息，请参阅[模型文档](../advanced_guides/models.md)。
+
+### 数据集设置
+
+**data** 的更改：
+
+原版 `data` 字段被拆分为 `train_dataloader`、`val_dataloader` 和 `test_dataloader`，允许我们以细粒度配置它们。例如，您可以在训练和测试期间指定不同的采样器和批次大小。
+`samples_per_gpu` 重命名为 `batch_size`。
+`workers_per_gpu` 重命名为 `num_workers`。
+
+<table class="docutils">
+<tr>
+<td>原版</td>
+<td>
+
+```python
+data = dict(
+    samples_per_gpu=4,
+    workers_per_gpu=4,
+    train=dict(...),
+    val=dict(...),
+    test=dict(...),
+)
+```
+
+</td>
+<tr>
+<td>新版</td>
+<td>
+
+```python
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    dataset=dict(...),
+    sampler=dict(type='DefaultSampler', shuffle=True)  # 必须
+)
+
+val_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    dataset=dict(...),
+    sampler=dict(type='DefaultSampler', shuffle=False)  # 必须
+)
+
+test_dataloader = val_dataloader
+```
+
+</td>
+</tr>
+</table>
+
+**数据增强变换流程**变更
+
+- 原始格式转换 **`ToTensor`**、**`ImageToTensor`**、**`Collect`** 组合为 [`PackSegInputs`](mmseg.datasets.transforms.PackSegInputs)
+- 我们不建议在数据集流程中执行 **`Normalize`** 和 **Pad**。请将其从流程中删除，并将其设置在 `data_preprocessor` 字段中。
+- MMSeg 1.x 中原始的 **`Resize`** 已更改为 **`RandomResize `**，输入参数 `img_scale` 重命名为 `scale`，`keep_ratio` 的默认值修改为 False。
+- 原始的 `test_pipeline` 将单尺度和多尺度测试结合在一起，在 MMSeg 1.x 中，我们将其分为 `test_pipeline` 和 `tta_pipeline`。
+
+**注：**
+我们将一些数据转换工作转移到数据预处理器中，如归一化，请参阅[文档](package.md)了解更多详细信息。
+
+训练流程
+
+<table class="docutils">
+<tr>
+<td>原版</td>
+<td>
+
+```python
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='Resize', img_scale=(2560, 640), ratio_range=(0.5, 2.0)),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='Normalize', **img_norm_cfg),
+    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
+]
+```
+
+</td>
+<tr>
+<td>新版</td>
+<td>
+
+```python
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(
+        type='RandomResize',
+        scale=(2560, 640),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+```
+
+</td>
+</tr>
+</table>
+
+测试流程
+
+<table class="docutils">
+<tr>
+<td>原版</td>
+<td>
+
+```python
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(2560, 640),
+        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(type='Normalize', **img_norm_cfg),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img']),
+        ])
+]
+```
+
+</td>
+<tr>
+<td>新版</td>
+<td>
+
+```python
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2560, 640), keep_ratio=True),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+```
+
+</td>
+</tr>
+</table>
+
+**`evaluation`** 中的更改：
+
+- **`evaluation`** 字段被拆分为 `val_evaluator` 和 `test_evaluator `。而且不再支持 `interval` 和 `save_best` 参数。
+  `interval` 已移动到 `train_cfg.val_interval`，`save_best` 已移动到 `default_hooks.checkpoint.save_best`。`pre_eval` 已删除。
+- `IoU` 已更改为 `IoUMetric`。
+
+<table class="docutils">
+<tr>
+<td>原版</td>
+<td>
+
+```python
+evaluation = dict(interval=2000, metric='mIoU', pre_eval=True)
+```
+
+</td>
+<tr>
+<td>新版</td>
+<td>
+
+```python
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
+```
+
+</td>
+</tr>
+</table>
+
+### Optimizer 和 Schedule 设置
+
+**`optimizer`** 和 **`optimizer_config`** 中的更改：
+
+- 现在我们使用 `optim_wrapper` 字段来指定优化过程的所有配置。以及 `optimizer` 是 `optim_wrapper` 的一个子字段。
+- `paramwise_cfg` 也是 `optim_wrapper` 的一个子字段，以替代 `optimizer`。
+- `optimizer_config` 现在被删除，它的所有配置都被移动到 `optim_wrapper` 中。
+- `grad_clip` 重命名为 `clip_grad`。
+
+<table class="docutils">
+<tr>
+<td>原版</td>
+<td>
+
+```python
+optimizer = dict(type='AdamW', lr=0.0001, weight_decay=0.0005)
+optimizer_config = dict(grad_clip=dict(max_norm=1, norm_type=2))
+```
+
+</td>
+<tr>
+<td>新版</td>
+<td>
+
+```python
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0005),
+    clip_grad=dict(max_norm=1, norm_type=2))
+```
+
+</td>
+</tr>
+</table>
+
+**`lr_config`** 中的更改：
+
+- 我们将 `lr_config` 字段删除，并使用新的 `param_scheduler` 替代。
+- 我们删除了与 `warmup` 相关的参数，因为我们使用 scheduler 组合来实现该功能。
+
+新的 scheduler 组合机制非常灵活，您可以使用它来设计多种学习率/动量曲线。有关详细信息，请参见[教程](TODO)。
+
+<table class="docutils">
+<tr>
+<td>原版</td>
+<td>
+
+```python
+lr_config = dict(
+    policy='poly',
+    warmup='linear',
+    warmup_iters=1500,
+    warmup_ratio=1e-6,
+    power=1.0,
+    min_lr=0.0,
+    by_epoch=False)
+```
+
+</td>
+<tr>
+<td>新版</td>
+<td>
+
+```python
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        power=1.0,
+        begin=1500,
+        end=160000,
+        eta_min=0.0,
+        by_epoch=False,
+    )
+]
+```
+
+</td>
+</tr>
+</table>
+
+**`runner`** 中的更改：
+
+原版 `runner` 字段中的大多数配置被移动到 `train_cfg`、`val_cfg` 和 `test_cfg` 中，以在训练、验证和测试中配置 loop。
+
+<table class="docutils">
+<tr>
+<td>原版</td>
+<td>
+
+```python
+runner = dict(type='IterBasedRunner', max_iters=20000)
+```
+
+</td>
+<tr>
+<td>新版</td>
+<td>
+
+```python
+# `val_interval` 是旧版本的 `evaluation.interval`。
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=20000, val_interval=2000)
+val_cfg = dict(type='ValLoop') # 使用默认的验证循环。
+test_cfg = dict(type='TestLoop') # 使用默认的测试循环。
+```
+
+</td>
+</tr>
+</table>
+
+事实上，在 OpenMMLab 2.0 中，我们引入了 `Loop` 来控制训练、验证和测试中的行为。`Runner` 的功能也发生了变化。您可以在 [MMMEngine](https://github.com/open-mmlab/mmengine/) 的[执行器教程](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/design/runner.md) 中找到更多的详细信息。
+
+### 运行时设置
+
+**`checkpoint_config`** 和 **`log_config`** 中的更改：
+
+`checkpoint_config` 被移动到 `default_hooks.checkpoint` 中，`log_config` 被移动到 `default_hooks.logger` 中。
+并且我们将许多钩子设置从脚本代码移动到运行时配置的 `default_hooks` 字段中。
+
+```python
+default_hooks = dict(
+    # 记录每次迭代的时间。
+    timer=dict(type='IterTimerHook'),
+
+    # 每50次迭代打印一次日志。
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+
+    # 启用参数调度程序。
+    param_scheduler=dict(type='ParamSchedulerHook'),
+
+    # 每2000次迭代保存一次检查点。
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=2000),
+
+    # 在分布式环境中设置采样器种子。
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+
+    # 验证结果可视化。
+    visualization=dict(type='SegVisualizationHook'))
+```
+
+此外，我们将原版 logger 拆分为 logger 和 visualizer。logger 用于记录信息，visualizer 用于在不同的后端显示 logger，如 terminal 和 TensorBoard。
+
+<table class="docutils">
+<tr>
+<td>原版</td>
+<td>
+
+```python
+log_config = dict(
+    interval=100,
+    hooks=[
+        dict(type='TextLoggerHook'),
+        dict(type='TensorboardLoggerHook'),
+    ])
+```
+
+</td>
+<tr>
+<td>新版</td>
+<td>
+
+```python
+default_hooks = dict(
+    ...
+    logger=dict(type='LoggerHook', interval=100),
+)
+vis_backends = [dict(type='LocalVisBackend'),
+                dict(type='TensorboardVisBackend')]
+visualizer = dict(
+    type='SegLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+```
+
+</td>
+</tr>
+</table>
+
+**`load_from`** 和 **`resume_from`** 中的更改：
+
+- 删除 `resume_from`。我们使用 `resume` 和 `load_from` 来替换它。
+  - 如果 `resume=True` 且 `load_from` 为 **not None**，则从 `load_from` 中的检查点恢复训练。
+  - 如果 `resume=True` 且 `load_from` 为 **None**，则尝试从工作目录中的最新检查点恢复。
+  - 如果 `resume=False` 且 `load_from` 为 **not None**，则只加载检查点，而不继续训练。
+  - 如果 `resume=False` 且 `load_from` 为 **None**，则不加载或恢复。
+
+**`dist_params`** 中的更改：`dist_params` 字段现在是 `env_cfg` 的子字段。并且 `env_cfg` 中还有一些新的配置。
+
+```python
+env_cfg = dict(
+    # 是否启用 cudnn_benchmark
+    cudnn_benchmark=False,
+
+    # 设置多进程参数
+    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+
+    # 设置分布式参数
+    dist_cfg=dict(backend='nccl'),
+)
+```
+
+**`workflow`** 的改动:`workflow` 相关功能被删除。
+
+新字段 **`visualizer`**：visualizer 是 OpenMMLab 2.0 体系结构中的新设计。我们在 runner 中使用 visualizer 实例来处理结果和日志可视化，并保存到不同的后端。更多详细信息，请参阅[可视化教程](../user_guides/visualization.md)。
+
+新字段 **`default_scope`**：搜索所有注册模块的起点。MMSegmentation 中的 `default_scope` 为 `mmseg`。请参见[注册器教程](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/advanced_tutorials/registry.md)了解更多详情。
diff --git a/mmsegmentation/docs/zh_cn/migration/package.md b/mmsegmentation/docs/zh_cn/migration/package.md
new file mode 100644
index 0000000..19e5f18
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/migration/package.md
@@ -0,0 +1,113 @@
+# 包结构更改
+
+本节包含您对 MMSeg 0.x 和 1.x 之间的变化可能感到好奇的内容。
+
+<table>
+<tr>
+<td>MMSegmentation 0.x</td>
+<td>MMSegmentation 1.x</td>
+</tr>
+<tr>
+<td>mmseg.api</td>
+<td>mmseg.api</td>
+</tr>
+<tr>
+<td bgcolor=#fcf7f7>- mmseg.core</td>
+<td bgcolor=#ecf4eb>+ mmseg.engine</td>
+</tr>
+<tr>
+<td>mmseg.datasets</td>
+<td>mmseg.datasets</td>
+</tr>
+<tr>
+<td>mmseg.models</td>
+<td>mmseg.models</td>
+</tr>
+<tr>
+<td bgcolor=#fcf7f7>- mmseg.ops</td>
+<td bgcolor=#ecf4eb>+ mmseg.structure</td>
+</tr>
+<tr>
+<td>mmseg.utils</td>
+<td>mmseg.utils</td>
+</tr>
+<tr>
+<td></td>
+<td bgcolor=#ecf4eb>+ mmseg.evaluation</td>
+</tr>
+<tr>
+<td></td>
+<td bgcolor=#ecf4eb>+ mmseg.registry</td>
+<tr>
+</table>
+
+## 已删除的包
+
+### `mmseg.core`
+
+在 OpenMMLab 2.0 中，`core` 包已被删除。`core` 的 `hooks` 和 `optimizers` 被移动到了 `mmseg.engine` 中，而 `core` 中的 `evaluation` 目前是 mmseg.evaluation。
+
+## `mmseg.ops`
+
+`ops` 包含 `encoding` 和 `wrappers`，它们被移到了 `mmseg.models.utils` 中。
+
+## 增加的包
+
+### `mmseg.engine`
+
+OpenMMLab 2.0 增加了一个新的深度学习训练基础库 MMEngine。它是所有 OpenMMLab 代码库的训练引擎。
+mmseg 的 `engine` 包是一些用于语义分割任务的定制模块，如 `SegVisualizationHook` 用于可视化分割掩膜。
+
+### `mmseg.structure`
+
+在 OpenMMLab 2.0 中，我们为计算机视觉任务设计了数据结构，在 mmseg 中，我们在 `structure` 包中实现了 `SegDataSample`。
+
+### `mmseg.evaluation`
+
+我们将所有评估指标都移动到了 `mmseg.evaluation` 中。
+
+### `mmseg.registry`
+
+我们将 MMSegmentation 中所有类型模块的注册实现移动到 `mmseg.registry` 中。
+
+## 修改的包
+
+### `mmseg.apis`
+
+OpenMMLab 2.0 尝试支持计算机视觉的多任务统一接口，并发布了更强的 [`Runner`](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/design/runner.md)，因此 MMSeg 1.x 删除了 `train.py` 和 `test.py` 中的模块，并将 `init_segmentor` 重命名为 `init_model`，将 `inference_segmentor` 重命名为 `inference_model`。
+
+以下是 `mmseg.apis` 的更改：
+
+|         函数          | 变化                                           |
+| :-------------------: | :--------------------------------------------- |
+|   `init_segmentor`    | 重命名为 `init_model`                          |
+| `inference_segmentor` | 重命名为 `inference_model`                     |
+| `show_result_pyplot`  | 基于 `SegLocalVisualizer` 实现                 |
+|     `train_model`     | 删除，使用 `runner.train` 训练。               |
+|   `multi_gpu_test`    | 删除，使用 `runner.test` 测试。                |
+|   `single_gpu_test`   | 删除，使用 `runner.test` 测试。                |
+|   `set_random_seed`   | 删除，使用 `mmengine.runner.set_random_seed`。 |
+|  `init_random_seed`   | 删除，使用 `mmengine.dist.sync_random_seed`。  |
+
+### `mmseg.datasets`
+
+OpenMMLab 2.0 将 `BaseDataset` 定义为数据集的函数和接口，MMSegmentation 1.x 也遵循此协议，并定义了从 `BaseDataset` 继承的 `BaseSegDataset`。MMCV 2.x 收集多种任务的通用数据转换，例如分类、检测、分割，因此 MMSegmentation 1.x 使用这些数据转换并将其从 mmseg.dataset 中删除。
+
+|        包/模块        | 更改                                                                                 |
+| :-------------------: | :----------------------------------------------------------------------------------- |
+|   `mmseg.pipelines`   | 移动到 `mmcv.transforms` 中                                                          |
+|    `mmseg.sampler`    | 移动到 `mmengine.dataset.sampler` 中                                                 |
+|    `CustomDataset`    | 重命名为 `BaseSegDataset` 并从 MMEngine 中的 `BaseDataset` 继承                      |
+| `DefaultFormatBundle` | 替换为 `PackSegInputs`                                                               |
+|  `LoadImageFromFile`  | 移动到 `mmcv.transforms.LoadImageFromFile` 中                                        |
+|   `LoadAnnotations`   | 移动到 `mmcv.transforms.LoadAnnotations` 中                                          |
+|       `Resize`        | 移动到 `mmcv.transforms` 中并拆分为 `Resize`，`RandomResize` 和 `RandomChoiceResize` |
+|     `RandomFlip`      | 移动到 `mmcv.transforms.RandomFlip` 中                                               |
+|         `Pad`         | 移动到 `mmcv.transforms.Pad` 中                                                      |
+|      `Normalize`      | 移动到 `mmcv.transforms.Normalize` 中                                                |
+|       `Compose`       | 移动到 `mmcv.transforms.Compose` 中                                                  |
+|    `ImageToTensor`    | 移动到 `mmcv.transforms.ImageToTensor` 中                                            |
+
+### `mmseg.models`
+
+`models` 没有太大变化，只是从以前的 `mmseg.ops` 添加了 `encoding` 和 `wrappers`
diff --git a/mmsegmentation/docs/zh_cn/model_zoo.md b/mmsegmentation/docs/zh_cn/model_zoo.md
new file mode 100644
index 0000000..bd57215
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/model_zoo.md
@@ -0,0 +1,152 @@
+# 标准与模型库
+
+## 共同设定
+
+- 我们默认使用 4 卡分布式训练
+- 所有 PyTorch 风格的 ImageNet 预训练网络由我们自己训练，和 [论文](https://arxiv.org/pdf/1812.01187.pdf) 保持一致。
+  我们的 ResNet 网络是基于 ResNetV1c 的变种，在这里输入层的 7x7 卷积被 3个 3x3 取代
+- 为了在不同的硬件上保持一致，我们以 `torch.cuda.max_memory_allocated()` 的最大值作为 GPU 占用率，同时设置 `torch.backends.cudnn.benchmark=False`。
+  注意，这通常比 `nvidia-smi` 显示的要少
+- 我们以网络 forward 和后处理的时间加和作为推理时间，除去数据加载时间。我们使用脚本 `tools/benchmark.py` 来获取推理时间，它在 `torch.backends.cudnn.benchmark=False` 的设定下，计算 200 张图片的平均推理时间
+- 在框架中，有两种推理模式
+  - `slide` 模式（滑动模式）：测试的配置文件字段 `test_cfg` 会是 `dict(mode='slide', crop_size=(769, 769), stride=(513, 513))`.
+    在这个模式下，从原图中裁剪多个小图分别输入网络中进行推理。小图的大小和小图之间的距离由 `crop_size` 和 `stride` 决定，重合区域会进行平均
+  - `whole` 模式 （全图模式）：测试的配置文件字段 `test_cfg` 会是 `dict(mode='whole')`. 在这个模式下，全图会被直接输入到网络中进行推理。
+    对于 769x769 下训练的模型，我们默认使用 `slide` 进行推理，其余模型用 `whole` 进行推理
+- 对于输入大小为 8x+1 （比如769），我们使用 `align_corners=True`。其余情况，对于输入大小为 8x (比如 512，1024)，我们使用 `align_corners=False`
+
+## 基线
+
+### FCN
+
+请参考 [FCN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/fcn) 获得详细信息。
+
+### PSPNet
+
+请参考 [PSPNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/pspnet) 获得详细信息。
+
+### DeepLabV3
+
+请参考 [DeepLabV3](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/deeplabv3) 获得详细信息。
+
+### PSANet
+
+请参考 [PSANet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/psanet) 获得详细信息。
+
+### DeepLabV3+
+
+请参考 [DeepLabV3+](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/deeplabv3plus) 获得详细信息。
+
+### UPerNet
+
+请参考 [UPerNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/upernet) 获得详细信息。
+
+### NonLocal Net
+
+请参考 [NonLocal Net](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/nlnet) 获得详细信息。
+
+### EncNet
+
+请参考 [EncNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/encnet) 获得详细信息。
+
+### CCNet
+
+请参考 [CCNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/ccnet) 获得详细信息。
+
+### DANet
+
+请参考 [DANet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/danet) 获得详细信息。
+
+### APCNet
+
+请参考 [APCNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/apcnet) 获得详细信息。
+
+### HRNet
+
+请参考 [HRNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/hrnet) 获得详细信息。
+
+### GCNet
+
+请参考 [GCNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/gcnet) 获得详细信息。
+
+### DMNet
+
+请参考 [DMNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/dmnet) 获得详细信息。
+
+### ANN
+
+请参考 [ANN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/ann) 获得详细信息。
+
+### OCRNet
+
+请参考 [OCRNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/ocrnet) 获得详细信息。
+
+### Fast-SCNN
+
+请参考 [Fast-SCNN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/fastscnn) 获得详细信息。
+
+### ResNeSt
+
+请参考 [ResNeSt](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/resnest) 获得详细信息。
+
+### Semantic FPN
+
+请参考 [Semantic FPN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/semfpn) 获得详细信息。
+
+### PointRend
+
+请参考 [PointRend](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/point_rend) 获得详细信息。
+
+### MobileNetV2
+
+请参考 [MobileNetV2](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/mobilenet_v2) 获得详细信息。
+
+### MobileNetV3
+
+请参考 [MobileNetV3](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/mobilenet_v3) 获得详细信息。
+
+### EMANet
+
+请参考 [EMANet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/emanet) 获得详细信息。
+
+### DNLNet
+
+请参考 [DNLNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/dnlnet) 获得详细信息。
+
+### CGNet
+
+请参考 [CGNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/cgnet) 获得详细信息。
+
+### Mixed Precision (FP16) Training
+
+请参考 [Mixed Precision (FP16) Training 在 BiSeNetV2 训练的样例](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/bisenetv2/bisenetv2_fcn_fp16_4x4_1024x1024_160k_cityscapes.py) 获得详细信息。
+
+## 速度标定（待更新）
+
+### 硬件
+
+- 8 NVIDIA Tesla V100 (32G) GPUs
+- Intel(R) Xeon(R) Gold 6148 CPU @ 2.40GHz
+
+### 软件环境
+
+- Python 3.7
+- PyTorch 1.5
+- CUDA 10.1
+- CUDNN 7.6.03
+- NCCL 2.4.08
+
+### 训练速度
+
+为了公平比较，我们全部使用 ResNet-101V1c 进行标定。输入大小为 1024x512，批量样本数为 2。
+
+训练速度如下表，指标为每次迭代的时间，以秒为单位，越低越快。
+
+| Implementation                                                              | PSPNet (s/iter) | DeepLabV3+ (s/iter) |
+| --------------------------------------------------------------------------- | --------------- | ------------------- |
+| [MMSegmentation](https://github.com/open-mmlab/mmsegmentation)              | **0.83**        | **0.85**            |
+| [SegmenTron](https://github.com/LikeLy-Journey/SegmenTron)                  | 0.84            | 0.85                |
+| [CASILVision](https://github.com/CSAILVision/semantic-segmentation-pytorch) | 1.15            | N/A                 |
+| [vedaseg](https://github.com/Media-Smart/vedaseg)                           | 0.95            | 1.25                |
+
+注意：DeepLabV3+ 的输出步长为 8。
diff --git a/mmsegmentation/docs/zh_cn/modelzoo_statistics.md b/mmsegmentation/docs/zh_cn/modelzoo_statistics.md
new file mode 100644
index 0000000..b057575
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/modelzoo_statistics.md
@@ -0,0 +1,102 @@
+# 模型库统计数据
+
+- 论文数量: 47
+
+  - ALGORITHM: 36
+  - BACKBONE: 11
+
+- 模型数量: 612
+
+  - \[ALGORITHM\] [ANN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/ann) (16 ckpts)
+
+  - \[ALGORITHM\] [APCNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/apcnet) (12 ckpts)
+
+  - \[BACKBONE\] [BEiT](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/beit) (2 ckpts)
+
+  - \[ALGORITHM\] [BiSeNetV1](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/bisenetv1) (11 ckpts)
+
+  - \[ALGORITHM\] [BiSeNetV2](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/bisenetv2) (4 ckpts)
+
+  - \[ALGORITHM\] [CCNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/ccnet) (16 ckpts)
+
+  - \[ALGORITHM\] [CGNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/cgnet) (2 ckpts)
+
+  - \[BACKBONE\] [ConvNeXt](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/convnext) (6 ckpts)
+
+  - \[ALGORITHM\] [DANet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/danet) (16 ckpts)
+
+  - \[ALGORITHM\] [DeepLabV3](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/deeplabv3) (41 ckpts)
+
+  - \[ALGORITHM\] [DeepLabV3+](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/deeplabv3plus) (42 ckpts)
+
+  - \[ALGORITHM\] [DMNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/dmnet) (12 ckpts)
+
+  - \[ALGORITHM\] [DNLNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/dnlnet) (12 ckpts)
+
+  - \[ALGORITHM\] [DPT](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/dpt) (1 ckpts)
+
+  - \[ALGORITHM\] [EMANet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/emanet) (4 ckpts)
+
+  - \[ALGORITHM\] [EncNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/encnet) (12 ckpts)
+
+  - \[ALGORITHM\] [ERFNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/erfnet) (1 ckpts)
+
+  - \[ALGORITHM\] [FastFCN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/fastfcn) (12 ckpts)
+
+  - \[ALGORITHM\] [Fast-SCNN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/fastscnn) (1 ckpts)
+
+  - \[ALGORITHM\] [FCN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/fcn) (41 ckpts)
+
+  - \[ALGORITHM\] [GCNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/gcnet) (16 ckpts)
+
+  - \[BACKBONE\] [HRNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/hrnet) (37 ckpts)
+
+  - \[ALGORITHM\] [ICNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/icnet) (12 ckpts)
+
+  - \[ALGORITHM\] [ISANet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/isanet) (16 ckpts)
+
+  - \[ALGORITHM\] [K-Net](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/knet) (7 ckpts)
+
+  - \[BACKBONE\] [MAE](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/mae) (1 ckpts)
+
+  - \[ALGORITHM\] [Mask2Former](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/mask2former) (13 ckpts)
+
+  - \[ALGORITHM\] [MaskFormer](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/maskformer) (4 ckpts)
+
+  - \[BACKBONE\] [MobileNetV2](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/mobilenet_v2) (8 ckpts)
+
+  - \[BACKBONE\] [MobileNetV3](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/mobilenet_v3) (4 ckpts)
+
+  - \[ALGORITHM\] [NonLocal Net](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/nonlocal_net) (16 ckpts)
+
+  - \[ALGORITHM\] [OCRNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/ocrnet) (24 ckpts)
+
+  - \[ALGORITHM\] [PointRend](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/point_rend) (4 ckpts)
+
+  - \[BACKBONE\] [PoolFormer](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/poolformer) (5 ckpts)
+
+  - \[ALGORITHM\] [PSANet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/psanet) (16 ckpts)
+
+  - \[ALGORITHM\] [PSPNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/pspnet) (54 ckpts)
+
+  - \[BACKBONE\] [ResNeSt](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/resnest) (8 ckpts)
+
+  - \[ALGORITHM\] [SegFormer](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/segformer) (13 ckpts)
+
+  - \[ALGORITHM\] [Segmenter](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/segmenter) (5 ckpts)
+
+  - \[ALGORITHM\] [Semantic FPN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/sem_fpn) (4 ckpts)
+
+  - \[ALGORITHM\] [SETR](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/setr) (7 ckpts)
+
+  - \[ALGORITHM\] [STDC](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/stdc) (4 ckpts)
+
+  - \[BACKBONE\] [Swin Transformer](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/swin) (6 ckpts)
+
+  - \[BACKBONE\] [Twins](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/twins) (12 ckpts)
+
+  - \[ALGORITHM\] [UNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/unet) (25 ckpts)
+
+  - \[ALGORITHM\] [UPerNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/upernet) (16 ckpts)
+
+  - \[BACKBONE\] [Vision Transformer](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/vit) (11 ckpts)
diff --git a/mmsegmentation/docs/zh_cn/notes/faq.md b/mmsegmentation/docs/zh_cn/notes/faq.md
new file mode 100644
index 0000000..aa99c25
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/notes/faq.md
@@ -0,0 +1,125 @@
+# 常见问题解答（FAQ）
+
+我们在这里列出了使用时的一些常见问题及其相应的解决方案。 如果您发现有一些问题被遗漏，请随时提 PR 丰富这个列表。 如果您无法在此获得帮助，请使用 [issue 模板](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/.github/ISSUE_TEMPLATE/error-report.md/)创建问题，但是请在模板中填写所有必填信息，这有助于我们更快定位问题。
+
+## 安装
+
+兼容的 MMSegmentation 和 MMCV 版本如下。请安装正确版本的 MMCV 以避免安装问题。
+
+| MMSegmentation version |          MMCV version          | MMEngine version  | MMClassification (optional) version | MMDetection (optional) version |
+| :--------------------: | :----------------------------: | :---------------: | :---------------------------------: | :----------------------------: |
+|     dev-1.x branch     |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
+|      main branch       |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
+|         1.2.2          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
+|         1.2.1          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
+|         1.2.0          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
+|         1.1.2          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
+|         1.1.1          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
+|         1.1.0          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
+|         1.0.0          |        mmcv >= 2.0.0rc4        | MMEngine >= 0.7.1 |           mmcls==1.0.0rc6           |         mmdet >= 3.0.0         |
+|        1.0.0rc6        |        mmcv >= 2.0.0rc4        | MMEngine >= 0.5.0 |           mmcls>=1.0.0rc0           |       mmdet >= 3.0.0rc6        |
+|        1.0.0rc5        |        mmcv >= 2.0.0rc4        | MMEngine >= 0.2.0 |           mmcls>=1.0.0rc0           |        mmdet>=3.0.0rc6         |
+|        1.0.0rc4        |        mmcv == 2.0.0rc3        | MMEngine >= 0.1.0 |           mmcls>=1.0.0rc0           |  mmdet>=3.0.0rc4, \<=3.0.0rc5  |
+|        1.0.0rc3        |        mmcv == 2.0.0rc3        | MMEngine >= 0.1.0 |           mmcls>=1.0.0rc0           |  mmdet>=3.0.0rc4, \<=3.0.0rc5  |
+|        1.0.0rc2        |        mmcv == 2.0.0rc3        | MMEngine >= 0.1.0 |           mmcls>=1.0.0rc0           |  mmdet>=3.0.0rc4, \<=3.0.0rc5  |
+|        1.0.0rc1        | mmcv >= 2.0.0rc1, \<=2.0.0rc3> | MMEngine >= 0.1.0 |           mmcls>=1.0.0rc0           |          Not required          |
+|        1.0.0rc0        | mmcv >= 2.0.0rc1, \<=2.0.0rc3> | MMEngine >= 0.1.0 |           mmcls>=1.0.0rc0           |          Not required          |
+
+如果您已经安装了版本不合适的 mmcv，请先运行`pip uninstall mmcv`卸载已安装的 mmcv，如您先前安装的为 mmcv-full（存在于 OpenMMLab 1.x），请运行`pip uninstall mmcv-full`进行卸载。
+
+- 如出现 "No module named 'mmcv'"
+  1. 使用`pip uninstall mmcv`卸载环境中现有的 mmcv
+  2. 按照[安装说明](../get_started.md)安装对应的 mmcv
+
+## 如何获知模型训练时需要的显卡数量
+
+- 看模型的 config 文件命名。可以参考[了解配置文件](../user_guides/1_config.md)中的`配置文件命名风格`部分。比如，对于名字为`segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py`的 config 文件，`8xb1`代表训练其对应的模型需要的卡数为 8，每张卡中的 batch size 为 1。
+- 看模型的 log 文件。点开该模型的 log 文件，并在其中搜索`nGPU`，在`nGPU`后的数字个数即训练时所需的卡数。比如，在 log 文件中搜索`nGPU`得到`nGPU 0,1,2,3,4,5,6,7`的记录，则说明训练该模型需要使用八张卡。
+
+## auxiliary head 是什么
+
+简单来说，这是一个提高准确率的深度监督技术。在训练阶段，`decode_head`用于输出语义分割的结果，`auxiliary_head` 只是增加了一个辅助损失，其产生的分割结果对你的模型结果没有影响，仅在在训练中起作用。您可以阅读这篇[论文](https://arxiv.org/pdf/1612.01105.pdf)了解更多信息。
+
+## 运行测试脚本时如何输出绘制分割掩膜的图像
+
+在测试脚本中，我们提供了`--out`参数来控制是否输出保存预测的分割掩膜图像。您可以运行以下命令输出测试结果：
+
+```shell
+python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} --out ${OUTPUT_DIR}
+```
+
+更多用例细节可查阅[文档](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/docs/zh_cn/user_guides/4_train_test.md#%E6%B5%8B%E8%AF%95%E5%B9%B6%E4%BF%9D%E5%AD%98%E5%88%86%E5%89%B2%E7%BB%93%E6%9E%9C)，[PR #2712](https://github.com/open-mmlab/mmsegmentation/pull/2712) 以及[迁移文档](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/docs/zh_cn/migration/interface.md#%E6%B5%8B%E8%AF%95%E5%90%AF%E5%8A%A8)了解相关说明。
+
+## 如何处理二值分割任务?
+
+MMSegmentation 使用 `num_classes` 和 `out_channels` 来控制模型最后一层 `self.conv_seg` 的输出。更多细节可以参考 [这里](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/mmseg/models/decode_heads/decode_head.py)。
+
+`num_classes` 应该和数据集本身类别个数一致，当是二值分割时，数据集只有前景和背景两类，所以 `num_classes` 为 2. `out_channels` 控制模型最后一层的输出的通道数，通常和 `num_classes` 相等，但当二值分割时候，可以有两种处理方法, 分别是：
+
+- 设置 `out_channels=2`，在训练时以 Cross Entropy Loss 作为损失函数，在推理时使用 `F.softmax()` 归一化 logits 值，然后通过 `argmax()` 得到每个像素的预测结果。
+
+- 设置 `out_channels=1`，在训练时以 Binary Cross Entropy Loss 作为损失函数，在推理时使用 `F.sigmoid()` 和 `threshold` 得到预测结果，`threshold` 默认为 0.3。
+
+对于实现上述两种计算二值分割的方法，需要在 `decode_head` 和 `auxiliary_head` 的配置里修改。下面是对样例 [pspnet_unet_s5-d16.py](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/configs/_base_/models/pspnet_unet_s5-d16.py) 做出的对应修改。
+
+- (1) `num_classes=2`, `out_channels=2` 并在 `CrossEntropyLoss` 里面设置 `use_sigmoid=False`。
+
+```python
+decode_head=dict(
+    type='PSPHead',
+    in_channels=64,
+    in_index=4,
+    num_classes=2,
+    out_channels=2,
+    loss_decode=dict(
+        type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+auxiliary_head=dict(
+    type='FCNHead',
+    in_channels=128,
+    in_index=3,
+    num_classes=2,
+    out_channels=2,
+    loss_decode=dict(
+        type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+```
+
+- (2) `num_classes=2`, `out_channels=1` 并在 `CrossEntropyLoss` 里面设置 `use_sigmoid=True`.
+
+```python
+decode_head=dict(
+    type='PSPHead',
+    in_channels=64,
+    in_index=4,
+    num_classes=2,
+    out_channels=1,
+    loss_decode=dict(
+        type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)),
+auxiliary_head=dict(
+    type='FCNHead',
+    in_channels=128,
+    in_index=3,
+    num_classes=2,
+    out_channels=1,
+    loss_decode=dict(
+        type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.4)),
+```
+
+## `reduce_zero_label` 的作用
+
+数据集中 `reduce_zero_label` 参数类型为布尔类型，默认为 False，它的功能是为了忽略数据集 label 0。具体做法是将 label 0 改为 255，其余 label 相应编号减 1，同时 decode head 里将 255 设为 ignore index，即不参与 loss 计算。
+以下是 `reduce_zero_label` 具体实现逻辑:
+
+```python
+if self.reduce_zero_label:
+    # avoid using underflow conversion
+    gt_semantic_seg[gt_semantic_seg == 0] = 255
+    gt_semantic_seg = gt_semantic_seg - 1
+    gt_semantic_seg[gt_semantic_seg == 254] = 255
+```
+
+关于您的数据集是否需要使用 reduce_zero_label，有以下两类情况：
+
+- 例如在 [Potsdam](https://github.com/open-mmlab/mmsegmentation/blob/1.x/docs/en/user_guides/2_dataset_prepare.md#isprs-potsdam) 数据集上，有 0-不透水面、1-建筑、2-低矮植被、3-树、4-汽车、5-杂乱，六类。但该数据集提供了两种 RGB 标签，一种为图像边缘处有黑色像素的标签，另一种是没有黑色边缘的标签。对于有黑色边缘的标签，在 [dataset_converters.py](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/tools/dataset_converters/potsdam.py)中，其将黑色边缘转换为 label 0，其余标签分别为 1-不透水面、2-建筑、3-低矮植被、4-树、5-汽车、6-杂乱，那么此时，就应该在数据集 [potsdam.py](https://github.com/open-mmlab/mmsegmentation/blob/ff95416c3b5ce8d62b9289f743531398efce534f/mmseg/datasets/potsdam.py#L23) 中将`reduce_zero_label=True`。如果使用的是没有黑色边缘的标签，那么 mask label 中只有 0-5，此时就应该使`reduce_zero_label=False`。需要结合您的实际情况来使用。
+- 例如在第 0 类为 background 类别的数据集上，如果您最终是需要将背景和您的其余类别分开时，是不需要使用`reduce_zero_label`的，此时在数据集中应该将其设置为`reduce_zero_label=False`
+
+**注意:** 使用 `reduce_zero_label` 请确认数据集原始类别个数，如果只有两类，需要关闭 `reduce_zero_label` 即设置 `reduce_zero_label=False`。
diff --git a/mmsegmentation/docs/zh_cn/overview.md b/mmsegmentation/docs/zh_cn/overview.md
new file mode 100644
index 0000000..ed14795
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/overview.md
@@ -0,0 +1,75 @@
+# 概述
+
+本章节向您介绍 MMSegmentation 框架以及语义分割相关的基本概念。我们还提供了关于 MMSegmentation 的详细教程链接。
+
+## 什么是语义分割？
+
+语义分割是将图像中属于同一目标类别的部分聚类在一起的任务。它也是一种像素级预测任务，因为图像中的每一个像素都将根据类别进行分类。该任务的一些示例基准有 [Cityscapes](https://www.cityscapes-dataset.com/benchmarks/), [PASCAL VOC](http://host.robots.ox.ac.uk/pascal/VOC/voc2012/) 和 [ADE20K](https://groups.csail.mit.edu/vision/datasets/ADE20K/) 。通常用平均交并比 (Mean IoU) 和像素准确率 (Pixel Accuracy) 这两个指标来评估模型。
+
+## 什么是 MMSegmentation?
+
+MMSegmentation 是一个工具箱，它为语义分割任务的统一实现和模型评估提供了一个框架，并且高质量实现了常用的语义分割方法和数据集。
+
+MMSeg 主要包含了 apis, structures, datasets, models, engine, evaluation 和 visualization 这七个主要部分。
+
+- **apis** 提供了模型推理的高级api
+
+- **structures** 提供了分割任务的数据结构 `SegDataSample`
+
+- **datasets** 支持用于语义分割的多种数据集
+
+  - **transforms** 包含多种数据增强变换
+
+- **models** 是分割器最重要的部分，包含了分割器的不同组件
+
+  - **segmentors** 定义了所有分割模型类
+  - **data_preprocessors** 用于预处理模型的输入数据
+  - **backbones** 包含各种骨干网络，可将图像映射为特征图
+  - **necks** 包含各种模型颈部组件，用于连接分割头和骨干网络
+  - **decode_heads** 包含各种分割头，将特征图作为输入，并预测分割结果
+  - **losses** 包含各种损失函数
+
+- **engine** 是运行时组件的一部分，扩展了 [MMEngine](https://github.com/open-mmlab/mmengine) 的功能
+
+  - **optimizers** 提供了优化器和优化器封装
+  - **hooks** 提供了 runner 的各种钩子
+
+- **evaluation** 提供了评估模型性能的不同指标
+
+- **visualization** 分割结果的可视化工具
+
+## 如何使用本指南？
+
+以下是详细步骤，将带您一步步学习如何使用 MMSegmentation :
+
+1. 有关安装说明，请参阅 [开始你的第一步](get_started.md)。
+
+2. 对于初学者来说，MMSegmentation 是开始语义分割之旅的最好选择，因为这里实现了许多 SOTA 模型以及经典的模型 [model](model_zoo.md) 。另外，将各类组件和高级 API 結合使用，可以更便捷的执行分割任务。关于 MMSegmentation 的基本用法，请参考下面的教程：
+
+   - [配置](user_guides/1_config.md)
+   - [数据预处理](user_guides/2_dataset_prepare.md)
+   - [推理](user_guides/3_inference.md)
+   - [训练和测试](user_guides/4_train_test.md)
+
+3. 如果你想了解 MMSegmentation 工作的基本类和功能，请参考下面的教程来深入研究：
+
+   - [数据流](advanced_guides/data_flow.md)
+   - [结构](advanced_guides/structures.md)
+   - [模型](advanced_guides/models.md)
+   - [数据集](advanced_guides/datasets.md)
+   - [评估](advanced_guides/evaluation.md)
+
+4. MMSegmentation 也为用户自定义和一些前沿的研究提供了教程，请参考下面的教程来建立你自己的分割项目：
+
+   - [添加新的模型](advanced_guides/add_models.md)
+   - [添加新的数据集](advanced_guides/add_datasets.md)
+   - [添加新的 transform](advanced_guides/add_transforms.md)
+   - [自定义 runtime](advanced_guides/customize_runtime.md)
+
+5. 如果您更熟悉 MMSegmentation v0.x , 以下是 MMSegmentation v0.x 迁移到 v1.x 的文档
+
+   - [迁移](migration/index.rst)
+
+## 参考来源
+
+- https://paperswithcode.com/task/semantic-segmentation/codeless#task-home
diff --git a/mmsegmentation/docs/zh_cn/stat.py b/mmsegmentation/docs/zh_cn/stat.py
new file mode 100755
index 0000000..7a86302
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/stat.py
@@ -0,0 +1,67 @@
+#!/usr/bin/env python
+# Copyright (c) OpenMMLab. All rights reserved.
+import functools as func
+import glob
+import os.path as osp
+import re
+
+import numpy as np
+
+url_prefix = 'https://github.com/open-mmlab/mmsegmentation/blob/master/'
+
+files = sorted(glob.glob('../../configs/*/README.md'))
+
+stats = []
+titles = []
+num_ckpts = 0
+
+for f in files:
+    url = osp.dirname(f.replace('../../', url_prefix))
+
+    with open(f) as content_file:
+        content = content_file.read()
+
+    title = content.split('\n')[0].replace('#', '').strip()
+    ckpts = {
+        x.lower().strip()
+        for x in re.findall(r'https?://download.*\.pth', content)
+        if 'mmsegmentation' in x
+    }
+    if len(ckpts) == 0:
+        continue
+
+    _papertype = [
+        x for x in re.findall(r'<!--\s*\[([A-Z]*?)\]\s*-->', content)
+    ]
+    assert len(_papertype) > 0
+    papertype = _papertype[0]
+
+    paper = {(papertype, title)}
+
+    titles.append(title)
+    num_ckpts += len(ckpts)
+    statsmsg = f"""
+\t* [{papertype}] [{title}]({url}) ({len(ckpts)} ckpts)
+"""
+    stats.append((paper, ckpts, statsmsg))
+
+allpapers = func.reduce(lambda a, b: a.union(b), [p for p, _, _ in stats])
+msglist = '\n'.join(x for _, _, x in stats)
+
+papertypes, papercounts = np.unique([t for t, _ in allpapers],
+                                    return_counts=True)
+countstr = '\n'.join(
+    [f'   - {t}: {c}' for t, c in zip(papertypes, papercounts)])
+
+modelzoo = f"""
+# 模型库统计数据
+
+* 论文数量: {len(set(titles))}
+{countstr}
+
+* 模型数量: {num_ckpts}
+{msglist}
+"""
+
+with open('modelzoo_statistics.md', 'w') as f:
+    f.write(modelzoo)
diff --git a/mmsegmentation/docs/zh_cn/switch_language.md b/mmsegmentation/docs/zh_cn/switch_language.md
new file mode 100644
index 0000000..f58efc4
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/switch_language.md
@@ -0,0 +1,3 @@
+## <a href='https://mmsegmentation.readthedocs.io/en/latest/'>English</a>
+
+## <a href='https://mmsegmentation.readthedocs.io/zh_CN/latest/'>简体中文</a>
diff --git a/mmsegmentation/docs/zh_cn/user_guides/1_config.md b/mmsegmentation/docs/zh_cn/user_guides/1_config.md
new file mode 100644
index 0000000..dfcf0f9
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/user_guides/1_config.md
@@ -0,0 +1,577 @@
+# 教程1：了解配置文件
+
+我们将模块化和继承性设计融入到我们的配置文件系统中，方便进行各种实验。如果您想查看配置文件，你可以运行 `python tools/misc/print_config.py /PATH/TO/CONFIG` 来查看完整的配置文件。你也可以通过传递参数 `--cfg-options xxx.yyy=zzz` 来查看更新的配置信息。
+
+## 配置文件的结构
+
+在  `config/_base_ ` 文件夹下面有4种基本组件类型： 数据集(dataset)，模型(model)，训练策略(schedule)和运行时的默认设置(default runtime)。许多模型都可以很容易地通过组合这些组件进行实现，比如 DeepLabV3，PSPNet。使用 `_base_` 下的组件构建的配置信息叫做原始配置 (primitive)。
+
+对于同一个文件夹下的所有配置文件，建议**只有一个**对应的**原始配置文件**。所有其他的配置文件都应该继承自这个原始配置文件，从而保证每个配置文件的最大继承深度为 3。
+
+为了便于理解，我们建议社区贡献者从现有的方法继承。例如，如果您在 DeepLabV3 基础上进行了一些修改，用户可以先通过指定 `_base_ = ../deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py` 继承基本的 DeepLabV3 结构，然后在配置文件中修改必要的字段。
+
+如果你正在构建一个全新的方法，它不与现有的任何方法共享基本组件，您可以在`config`下创建一个新的文件夹`xxxnet` ，详细文档请参考[mmengine](https://mmengine.readthedocs.io/en/latest/tutorials/config.html)。
+
+## 配置文件命名风格
+
+我们遵循以下格式来命名配置文件，建议社区贡献者遵循相同的风格。
+
+```text
+{algorithm name}_{model component names [component1]_[component2]_[...]}_{training settings}_{training dataset information}_{testing dataset information}
+```
+
+配置文件的文件名分为五个部分，组成文件名每一个部分和组件之间都用`_`连接，每个部分或组件中的每个单词都要用`-`连接。
+
+- `{algorithm name}`: 算法的名称，如 `deeplabv3`,  `pspnet` 等。
+- `{model component names}`: 算法中使用的组件名称，如主干(backbone)、解码头(head)等。例如，`r50-d8 `表示使用ResNet50主干网络，并使用主干网络的8倍下采样输出作为下一级的输入。
+- `{training settings}`: 训练时的参数设置，如 `batch size`、数据增强(augmentation)、损失函数(loss)、学习率调度器(learning rate scheduler)和训练轮数(epochs/iterations)。例如: `4xb4-ce-linearlr-40K` 意味着使用4个gpu，每个gpu4个图像，使用交叉熵损失函数(CrossEntropy)，线性学习率调度程序，训练40K iterations。
+  一些缩写:
+  - `{gpu x batch_per_gpu}`: GPU数量和每个GPU的样本数。`bN ` 表示每个GPU的batch size为N，如 `8xb2` 为8个gpu x 每个gpu2张图像的缩写。如果未提及，则默认使用 `4xb4 `。
+  - `{schedule}`: 训练计划，选项有`20k`，`40k`等。`20k ` 和 `40k` 分别表示20000次迭代(iterations)和40000次迭代(iterations)。
+- `{training dataset information}`: 训练数据集名称，如 `cityscapes `， `ade20k ` 等，以及输入分辨率。例如: `cityscapes-768x768  `表示使用 `cityscapes` 数据集进行训练，输入分辨率为`768x768 `。
+- `{testing dataset information}` (可选): 测试数据集名称。当您的模型在一个数据集上训练但在另一个数据集上测试时，请将测试数据集名称添加到此处。如果没有这一部分，则意味着模型是在同一个数据集上进行训练和测试的。
+
+## PSPNet 的一个例子
+
+为了帮助用户熟悉对这个现代语义分割系统的完整配置文件和模块，我们对使用ResNet50V1c作为主干网络的PSPNet的配置文件作如下的简要注释和说明。要了解更详细的用法和每个模块对应的替换方法，请参阅API文档。
+
+```python
+_base_ = [
+    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+] # 我们可以在基本配置文件的基础上 构建新的配置文件
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
+```
+
+`_base_/models/pspnet_r50-d8.py`是使用ResNet50V1c作为主干网络的PSPNet的基本模型配置文件。
+
+```python
+# 模型设置
+norm_cfg = dict(type='SyncBN', requires_grad=True)  # 分割框架通常使用 SyncBN
+data_preprocessor = dict(  # 数据预处理的配置项，通常包括图像的归一化和增强
+    type='SegDataPreProcessor',  # 数据预处理的类型
+    mean=[123.675, 116.28, 103.53],  # 用于归一化输入图像的平均值
+    std=[58.395, 57.12, 57.375],  # 用于归一化输入图像的标准差
+    bgr_to_rgb=True,  # 是否将图像从 BGR 转为 RGB
+    pad_val=0,  # 图像的填充值
+    seg_pad_val=255)  # 'gt_seg_map'的填充值
+model = dict(
+    type='EncoderDecoder',  # 分割器(segmentor)的名字
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',  # 加载使用 ImageNet 预训练的主干网络
+    backbone=dict(
+        type='ResNetV1c',  # 主干网络的类别，更多细节请参考 mmseg/models/backbones/resnet.py
+        depth=50,  # 主干网络的深度，通常为 50 和 101
+        num_stages=4,  # 主干网络状态(stages)的数目
+        out_indices=(0, 1, 2, 3),  # 每个状态(stage)产生的特征图输出的索引
+        dilations=(1, 1, 2, 4),  # 每一层(layer)的空心率(dilation rate)
+        strides=(1, 2, 1, 1),  # 每一层(layer)的步长(stride)
+        norm_cfg=norm_cfg,  # 归一化层(norm layer)的配置项
+        norm_eval=False,  # 是否冻结 BN 里的统计项
+        style='pytorch',  # 主干网络的风格，'pytorch' 意思是步长为2的层为 3x3 卷积， 'caffe' 意思是步长为2的层为 1x1 卷积
+        contract_dilation=True),  # 当空洞率 > 1, 是否压缩第一个空洞层
+    decode_head=dict(
+        type='PSPHead',  # 解码头(decode head)的类别。可用选项请参 mmseg/models/decode_heads
+        in_channels=2048,  # 解码头的输入通道数
+        in_index=3,  # 被选择特征图(feature map)的索引
+        channels=512,  # 解码头中间态(intermediate)的通道数
+        pool_scales=(1, 2, 3, 6),  # PSPHead 平均池化(avg pooling)的规模(scales)。 细节请参考文章内容
+        dropout_ratio=0.1,  # 进入最后分类层(classification layer)之前的 dropout 比例
+        num_classes=19,  # 分割前景的种类数目。 通常情况下，cityscapes 为19，VOC为21，ADE20k 为150
+        norm_cfg=norm_cfg,  # 归一化层的配置项
+        align_corners=False,  # 解码过程中调整大小(resize)的 align_corners 参数
+        loss_decode=dict(  # 解码头(decode_head)里的损失函数的配置项
+            type='CrossEntropyLoss',  # 分割时使用的损失函数的类别
+            use_sigmoid=False,  # 分割时是否使用 sigmoid 激活
+            loss_weight=1.0)),  # 解码头的损失权重
+    auxiliary_head=dict(
+        type='FCNHead',  # 辅助头(auxiliary head)的种类。可用选项请参考 mmseg/models/decode_heads
+        in_channels=1024,  # 辅助头的输入通道数
+        in_index=2,  # 被选择的特征图(feature map)的索引
+        channels=256,  # 辅助头中间态(intermediate)的通道数
+        num_convs=1,  # FCNHead 里卷积(convs)的数目，辅助头中通常为1
+        concat_input=False,  # 在分类层(classification layer)之前是否连接(concat)输入和卷积的输出
+        dropout_ratio=0.1,  # 进入最后分类层(classification layer)之前的 dropout 比例
+        num_classes=19,  # 分割前景的种类数目。 通常情况下，cityscapes 为19，VOC为21，ADE20k 为150
+        norm_cfg=norm_cfg,  # 归一化层的配置项
+        align_corners=False,  # 解码过程中调整大小(resize)的 align_corners 参数
+        loss_decode=dict(  # 辅助头(auxiliary head)里的损失函数的配置项
+            type='CrossEntropyLoss',  # 分割时使用的损失函数的类别
+            use_sigmoid=False,  # 分割时是否使用 sigmoid 激活
+            loss_weight=0.4)),  # 辅助头损失的权重，默认设置为0.4
+    # 模型训练和测试设置项
+    train_cfg=dict(),  # train_cfg 当前仅是一个占位符
+    test_cfg=dict(mode='whole'))  # 测试模式，可选参数为 'whole' 和 'slide'. 'whole': 在整张图像上全卷积(fully-convolutional)测试。 'slide': 在输入图像上做滑窗预测
+```
+
+`_base_/datasets/cityscapes.py`是数据集的基本配置文件。
+
+```python
+# 数据集设置
+dataset_type = 'CityscapesDataset'  # 数据集类型，这将被用来定义数据集
+data_root = 'data/cityscapes/'  # 数据的根路径
+crop_size = (512, 1024)  # 训练时的裁剪大小
+train_pipeline = [  # 训练流程
+    dict(type='LoadImageFromFile'),  # 第1个流程，从文件路径里加载图像
+    dict(type='LoadAnnotations'),  # 第2个流程，对于当前图像，加载它的标注图像
+    dict(type='RandomResize',  # 调整输入图像大小(resize)和其标注图像的数据增广流程
+        scale=(2048, 1024),  # 图像裁剪的大小
+        ratio_range=(0.5, 2.0),  # 数据增广的比例范围
+        keep_ratio=True),  # 调整图像大小时是否保持纵横比
+    dict(type='RandomCrop',  # 随机裁剪当前图像和其标注图像的数据增广流程
+        crop_size=crop_size,  # 随机裁剪的大小
+        cat_max_ratio=0.75),  # 单个类别可以填充的最大区域的比
+    dict(type='RandomFlip',  # 翻转图像和其标注图像的数据增广流程
+        prob=0.5),  # 翻转图像的概率
+    dict(type='PhotoMetricDistortion'),  # 光学上使用一些方法扭曲当前图像和其标注图像的数据增广流程
+    dict(type='PackSegInputs')  # 打包用于语义分割的输入数据
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),  # 第1个流程，从文件路径里加载图像
+    dict(type='Resize',  # 使用调整图像大小(resize)增强
+        scale=(2048, 1024),  # 图像缩放的大小
+        keep_ratio=True),  # 在调整图像大小时是否保留长宽比
+    # 在' Resize '之后添加标注图像
+    # 不需要做调整图像大小(resize)的数据变换
+    dict(type='LoadAnnotations'),  # 加载数据集提供的语义分割标注
+    dict(type='PackSegInputs')  # 打包用于语义分割的输入数据
+]
+train_dataloader = dict(  # 训练数据加载器(dataloader)的配置
+    batch_size=2,  # 每一个GPU的batch size大小
+    num_workers=2,  # 为每一个GPU预读取数据的进程个数
+    persistent_workers=True,  # 在一个epoch结束后关闭worker进程，可以加快训练速度
+    sampler=dict(type='InfiniteSampler', shuffle=True),  # 训练时进行随机洗牌(shuffle)
+    dataset=dict(  # 训练数据集配置
+        type=dataset_type,  # 数据集类型，详见mmseg/datassets/
+        data_root=data_root,  # 数据集的根目录
+        data_prefix=dict(
+            img_path='leftImg8bit/train', seg_map_path='gtFine/train'),  # 训练数据的前缀
+        pipeline=train_pipeline)) # 数据处理流程，它通过之前创建的train_pipeline传递。
+val_dataloader = dict(
+    batch_size=1,  # 每一个GPU的batch size大小
+    num_workers=4,  # 为每一个GPU预读取数据的进程个数
+    persistent_workers=True,  # 在一个epoch结束后关闭worker进程，可以加快训练速度
+    sampler=dict(type='DefaultSampler', shuffle=False),  # 训练时不进行随机洗牌(shuffle)
+    dataset=dict(  # 测试数据集配置
+        type=dataset_type,  # 数据集类型，详见mmseg/datassets/
+        data_root=data_root,  # 数据集的根目录
+        data_prefix=dict(
+            img_path='leftImg8bit/val', seg_map_path='gtFine/val'),  # 测试数据的前缀
+        pipeline=test_pipeline))  # 数据处理流程，它通过之前创建的test_pipeline传递。
+test_dataloader = val_dataloader
+# 精度评估方法，我们在这里使用 IoUMetric 进行评估
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
+```
+
+`_base_/schedules/schedule_40k.py`
+
+```python
+# optimizer
+optimizer = dict(type='SGD', # 优化器种类，更多细节可参考 https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py
+                lr=0.01,  # 优化器的学习率，参数的使用细节请参照对应的 PyTorch 文档
+                momentum=0.9,  # 动量大小 (Momentum)
+                weight_decay=0.0005)  # SGD 的权重衰减 (weight decay)
+optim_wrapper = dict(type='OptimWrapper',  # 优化器包装器(Optimizer wrapper)为更新参数提供了一个公共接口
+                    optimizer=optimizer,  # 用于更新模型参数的优化器(Optimizer)
+                    clip_grad=None)  # 如果 'clip_grad' 不是None，它将是 ' torch.nn.utils.clip_grad' 的参数。
+# 学习策略
+param_scheduler = [
+    dict(
+        type='PolyLR',  # 调度流程的策略，同样支持 Step, CosineAnnealing, Cyclic 等. 请从 https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/scheduler/lr_scheduler.py 参考 LrUpdater 的细节
+        eta_min=1e-4,  # 训练结束时的最小学习率
+        power=0.9,  # 多项式衰减 (polynomial decay) 的幂
+        begin=0,  # 开始更新参数的时间步(step)
+        end=40000,  # 停止更新参数的时间步(step)
+        by_epoch=False)  # 是否按照 epoch 计算训练时间
+]
+# 40k iteration 的训练计划
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=40000, val_interval=4000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+# 默认钩子(hook)配置
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),  # 记录迭代过程中花费的时间
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),  # 从'Runner'的不同组件收集和写入日志
+    param_scheduler=dict(type='ParamSchedulerHook'),  # 更新优化器中的一些超参数，例如学习率
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=4000),  # 定期保存检查点(checkpoint)
+    sampler_seed=dict(type='DistSamplerSeedHook'))  # 用于分布式训练的数据加载采样器
+```
+
+in `_base_/default_runtime.py`
+
+```python
+# 将注册表的默认范围设置为mmseg
+default_scope = 'mmseg'
+# environment
+env_cfg = dict(
+    cudnn_benchmark=True,
+    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+    dist_cfg=dict(backend='nccl'),
+)
+log_level = 'INFO'
+log_processor = dict(by_epoch=False)
+load_from = None  # 从文件中加载检查点(checkpoint)
+resume = False  # 是否从已有的模型恢复
+```
+
+这些都是用于训练和测试PSPNet的配置文件，要加载和解析它们，我们可以使用[MMEngine](https://github.com/open-mmlab/mmengine)实现的[Config](https://mmengine.readthedocs.io/en/latest/tutorials/config.html)。
+
+```python
+from mmengine.config import Config
+
+cfg = Config.fromfile('configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py')
+print(cfg.train_dataloader)
+```
+
+```shell
+{'batch_size': 2,
+ 'num_workers': 2,
+ 'persistent_workers': True,
+ 'sampler': {'type': 'InfiniteSampler', 'shuffle': True},
+ 'dataset': {'type': 'CityscapesDataset',
+  'data_root': 'data/cityscapes/',
+  'data_prefix': {'img_path': 'leftImg8bit/train',
+   'seg_map_path': 'gtFine/train'},
+  'pipeline': [{'type': 'LoadImageFromFile'},
+   {'type': 'LoadAnnotations'},
+   {'type': 'RandomResize',
+    'scale': (2048, 1024),
+    'ratio_range': (0.5, 2.0),
+    'keep_ratio': True},
+   {'type': 'RandomCrop', 'crop_size': (512, 1024), 'cat_max_ratio': 0.75},
+   {'type': 'RandomFlip', 'prob': 0.5},
+   {'type': 'PhotoMetricDistortion'},
+   {'type': 'PackSegInputs'}]}}
+```
+
+`cfg `是`mmengine.config.Config `的一个实例。它的接口与dict对象相同，也允许将配置值作为属性访问。更多信息请参见[MMEngine](https://github.com/open-mmlab/mmengine)中的[config tutorial](https://mmengine.readthedocs.io/en/latest/tutorials/config.html)。
+
+## FAQ
+
+### 忽略基础配置文件里的一些字段
+
+有时，您可以设置`_delete_=True `来忽略基本配置文件中的某些字段。您可以参考[MMEngine](https://github.com/open-mmlab/mmengine)中的[config tutorial](https://mmengine.readthedocs.io/en/latest/tutorials/config.html)来获得一些简单的指导。
+
+例如，在MMSegmentation中，如果您想在下面的配置文件`pspnet.py `中修改PSPNet的主干网络:
+
+```python
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    type='EncoderDecoder',
+    pretrained='torchvision://resnet50',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='PSPHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        pool_scales=(1, 2, 3, 6),
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)))
+```
+
+用以下代码加载并解析配置文件`pspnet.py`:
+
+```python
+from mmengine.config import Config
+
+cfg = Config.fromfile('pspnet.py')
+print(cfg.model)
+```
+
+```shell
+{'type': 'EncoderDecoder',
+ 'pretrained': 'torchvision://resnet50',
+ 'backbone': {'type': 'ResNetV1c',
+  'depth': 50,
+  'num_stages': 4,
+  'out_indices': (0, 1, 2, 3),
+  'dilations': (1, 1, 2, 4),
+  'strides': (1, 2, 1, 1),
+  'norm_cfg': {'type': 'SyncBN', 'requires_grad': True},
+  'norm_eval': False,
+  'style': 'pytorch',
+  'contract_dilation': True},
+ 'decode_head': {'type': 'PSPHead',
+  'in_channels': 2048,
+  'in_index': 3,
+  'channels': 512,
+  'pool_scales': (1, 2, 3, 6),
+  'dropout_ratio': 0.1,
+  'num_classes': 19,
+  'norm_cfg': {'type': 'SyncBN', 'requires_grad': True},
+  'align_corners': False,
+  'loss_decode': {'type': 'CrossEntropyLoss',
+   'use_sigmoid': False,
+   'loss_weight': 1.0}}}
+```
+
+`ResNet`和`HRNet`使用不同的关键字构建，编写一个新的配置文件`hrnet.py`，如下所示:
+
+```python
+_base_ = 'pspnet.py'
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    pretrained='open-mmlab://msra/hrnetv2_w32',
+    backbone=dict(
+        _delete_=True,
+        type='HRNet',
+        norm_cfg=norm_cfg,
+        extra=dict(
+            stage1=dict(
+                num_modules=1,
+                num_branches=1,
+                block='BOTTLENECK',
+                num_blocks=(4, ),
+                num_channels=(64, )),
+            stage2=dict(
+                num_modules=1,
+                num_branches=2,
+                block='BASIC',
+                num_blocks=(4, 4),
+                num_channels=(32, 64)),
+            stage3=dict(
+                num_modules=4,
+                num_branches=3,
+                block='BASIC',
+                num_blocks=(4, 4, 4),
+                num_channels=(32, 64, 128)),
+            stage4=dict(
+                num_modules=3,
+                num_branches=4,
+                block='BASIC',
+                num_blocks=(4, 4, 4, 4),
+                num_channels=(32, 64, 128, 256)))))
+```
+
+用以下代码加载并解析配置文件`hrnet.py`:
+
+```python
+from mmengine.config import Config
+cfg = Config.fromfile('hrnet.py')
+print(cfg.model)
+```
+
+```shell
+{'type': 'EncoderDecoder',
+ 'pretrained': 'open-mmlab://msra/hrnetv2_w32',
+ 'backbone': {'type': 'HRNet',
+  'norm_cfg': {'type': 'SyncBN', 'requires_grad': True},
+  'extra': {'stage1': {'num_modules': 1,
+    'num_branches': 1,
+    'block': 'BOTTLENECK',
+    'num_blocks': (4,),
+    'num_channels': (64,)},
+   'stage2': {'num_modules': 1,
+    'num_branches': 2,
+    'block': 'BASIC',
+    'num_blocks': (4, 4),
+    'num_channels': (32, 64)},
+   'stage3': {'num_modules': 4,
+    'num_branches': 3,
+    'block': 'BASIC',
+    'num_blocks': (4, 4, 4),
+    'num_channels': (32, 64, 128)},
+   'stage4': {'num_modules': 3,
+    'num_branches': 4,
+    'block': 'BASIC',
+    'num_blocks': (4, 4, 4, 4),
+    'num_channels': (32, 64, 128, 256)}}},
+ 'decode_head': {'type': 'PSPHead',
+  'in_channels': 2048,
+  'in_index': 3,
+  'channels': 512,
+  'pool_scales': (1, 2, 3, 6),
+  'dropout_ratio': 0.1,
+  'num_classes': 19,
+  'norm_cfg': {'type': 'SyncBN', 'requires_grad': True},
+  'align_corners': False,
+  'loss_decode': {'type': 'CrossEntropyLoss',
+   'use_sigmoid': False,
+   'loss_weight': 1.0}}}
+```
+
+`_delete_=True` 将用新的键去替换 `backbone` 字段内所有旧的键。
+
+### 使用配置文件里的中间变量
+
+配置文件中会使用一些中间变量，例如数据集(datasets)字段里的 `train_pipeline`/`test_pipeline`。 需要注意的是，在子配置文件里修改中间变量时，您需要再次传递这些变量给对应的字段。例如，我们想改变在训练或测试PSPNet时采用的多尺度策略 (multi scale strategy)，`train_pipeline`/`test_pipeline` 是我们需要修改的中间变量。
+
+```python
+_base_ = '../pspnet/pspnet_r50-d8_4xb4-40k_cityscpaes-512x1024.py'
+crop_size = (512, 1024)
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='RandomResize',
+         img_scale=(2048, 1024),
+         ratio_range=(1., 2.),
+         keep_ration=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', flip_ratio=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs'),
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize',
+        scale=(2048, 1024),
+        keep_ratio=True),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='leftImg8bit/train', seg_map_path='gtFine/train'),
+        pipeline=train_pipeline)
+test_dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='leftImg8bit/val', seg_map_path='gtFine/val'),
+        pipeline=test_pipeline)
+train_dataloader = dict(dataset=train_dataset)
+val_dataloader = dict(dataset=test_dataset)
+test_dataloader = val_dataloader
+```
+
+我们首先需要定义新的 `train_pipeline`/`test_pipeline` 然后传递到 `dataset` 里。
+
+类似的，如果我们想从 `SyncBN` 切换到 `BN` 或者 `MMSyncBN`，我们需要替换配置文件里的每一个 `norm_cfg`。
+
+```python
+_base_ = '../pspnet/pspnet_r50-d8_4xb4-40k_cityscpaes-512x1024.py'
+norm_cfg = dict(type='BN', requires_grad=True)
+model = dict(
+    backbone=dict(norm_cfg=norm_cfg),
+    decode_head=dict(norm_cfg=norm_cfg),
+    auxiliary_head=dict(norm_cfg=norm_cfg))
+```
+
+## 通过脚本参数修改配置文件
+
+在[training script](https://github.com/open-mmlab/mmsegmentation/blob/1.x/tools/train.py)和[testing script](https://github.com/open-mmlab/mmsegmentation/blob/1.x/tools/test.py)中，我们支持脚本参数 `--cfg-options`，它可以帮助用户覆盖所使用的配置中的一些设置，`xxx=yyy` 格式的键值对将合并到配置文件中。
+
+例如，这是一个简化的脚本 `demo_script.py `:
+
+```python
+import argparse
+
+from mmengine.config import Config, DictAction
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Script Example')
+    parser.add_argument('config', help='train config file path')
+    parser.add_argument(
+        '--cfg-options',
+        nargs='+',
+        action=DictAction,
+        help='override some settings in the used config, the key-value pair '
+        'in xxx=yyy format will be merged into config file. If the value to '
+        'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
+        'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
+        'Note that the quotation marks are necessary and that no white space '
+        'is allowed.')
+    args = parser.parse_args()
+    return args
+
+def main():
+    args = parse_args()
+
+    cfg = Config.fromfile(args.config)
+    if args.cfg_options is not None:
+        cfg.merge_from_dict(args.cfg_options)
+
+    print(cfg)
+
+if __name__ == '__main__':
+    main()
+```
+
+一个配置文件示例 `demo_config.py` 如下所示:
+
+```python
+backbone = dict(
+    type='ResNetV1c',
+    depth=50,
+    num_stages=4,
+    out_indices=(0, 1, 2, 3),
+    dilations=(1, 1, 2, 4),
+    strides=(1, 2, 1, 1),
+    norm_eval=False,
+    style='pytorch',
+    contract_dilation=True)
+```
+
+运行 `demo_script.py`:
+
+```shell
+python demo_script.py demo_config.py
+```
+
+```shell
+Config (path: demo_config.py): {'backbone': {'type': 'ResNetV1c', 'depth': 50, 'num_stages': 4, 'out_indices': (0, 1, 2, 3), 'dilations': (1, 1, 2, 4), 'strides': (1, 2, 1, 1), 'norm_eval': False, 'style': 'pytorch', 'contract_dilation': True}}
+```
+
+通过脚本参数修改配置:
+
+```shell
+python demo_script.py demo_config.py --cfg-options backbone.depth=101
+```
+
+```shell
+Config (path: demo_config.py): {'backbone': {'type': 'ResNetV1c', 'depth': 101, 'num_stages': 4, 'out_indices': (0, 1, 2, 3), 'dilations': (1, 1, 2, 4), 'strides': (1, 2, 1, 1), 'norm_eval': False, 'style': 'pytorch', 'contract_dilation': True}}
+```
+
+- 更新列表/元组的值。
+
+  如果要更新的值是一个 list 或 tuple。例如，需要在配置文件 `demo_config.py ` 的 `backbone ` 中设置 `stride =(1,2,1,1) `。
+  如果您想更改这个键，你可以用两种方式进行指定:
+
+  1. `--cfg-options backbone.strides="(1, 1, 1, 1)"`. 注意引号 " 是支持 list/tuple 数据类型所必需的。
+
+     ```shell
+     python demo_script.py demo_config.py --cfg-options backbone.strides="(1, 1, 1, 1)"
+     ```
+
+     ```shell
+     Config (path: demo_config.py): {'backbone': {'type': 'ResNetV1c', 'depth': 50, 'num_stages': 4, 'out_indices': (0, 1, 2, 3), 'dilations': (1, 1, 2, 4), 'strides': (1, 1, 1, 1), 'norm_eval': False, 'style': 'pytorch', 'contract_dilation': True}}
+     ```
+
+  2. `--cfg-options backbone.strides=1,1,1,1`. 注意，在指定的值中**不允许**有空格。
+
+     另外，如果原来的类型是tuple，通过这种方式修改后会自动转换为list。
+
+     ```shell
+     python demo_script.py demo_config.py --cfg-options backbone.strides=1,1,1,1
+     ```
+
+     ```shell
+     Config (path: demo_config.py): {'backbone': {'type': 'ResNetV1c', 'depth': 50, 'num_stages': 4, 'out_indices': (0, 1, 2, 3), 'dilations': (1, 1, 2, 4), 'strides': [1, 1, 1, 1], 'norm_eval': False, 'style': 'pytorch', 'contract_dilation': True}}
+     ```
+
+```{note}
+  这种修改方法仅支持修改string、int、float、boolean、None、list和tuple类型的配置项。
+  具体来说，对于list和tuple类型的配置项，它们内部的元素也必须是上述七种类型之一。
+```
diff --git a/mmsegmentation/docs/zh_cn/user_guides/2_dataset_prepare.md b/mmsegmentation/docs/zh_cn/user_guides/2_dataset_prepare.md
new file mode 100644
index 0000000..e32303a
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/user_guides/2_dataset_prepare.md
@@ -0,0 +1,802 @@
+# 教程2：准备数据集
+
+我们建议将数据集根目录符号链接到 `$MMSEGMENTATION/data`。
+如果您的目录结构不同，您可能需要更改配置文件中相应的路径。
+对于中国境内的用户，我们也推荐通过开源数据平台 [OpenDataLab](https://opendatalab.com/) 来下载dsdl标准数据，以获得更好的下载和使用体验，这里有一个下载dsdl数据集并进行训练的案例[DSDLReadme](../../../configs/dsdl/README.md)，欢迎尝试。
+
+```none
+mmsegmentation
+├── mmseg
+├── tools
+├── configs
+├── data
+│   ├── cityscapes
+│   │   ├── leftImg8bit
+│   │   │   ├── train
+│   │   │   ├── val
+│   │   ├── gtFine
+│   │   │   ├── train
+│   │   │   ├── val
+│   ├── VOCdevkit
+│   │   ├── VOC2012
+│   │   │   ├── JPEGImages
+│   │   │   ├── SegmentationClass
+│   │   │   ├── ImageSets
+│   │   │   │   ├── Segmentation
+│   │   ├── VOC2010
+│   │   │   ├── JPEGImages
+│   │   │   ├── SegmentationClassContext
+│   │   │   ├── ImageSets
+│   │   │   │   ├── SegmentationContext
+│   │   │   │   │   ├── train.txt
+│   │   │   │   │   ├── val.txt
+│   │   │   ├── trainval_merged.json
+│   │   ├── VOCaug
+│   │   │   ├── dataset
+│   │   │   │   ├── cls
+│   ├── ade
+│   │   ├── ADEChallengeData2016
+│   │   │   ├── annotations
+│   │   │   │   ├── training
+│   │   │   │   ├── validation
+│   │   │   ├── images
+│   │   │   │   ├── training
+│   │   │   │   ├── validation
+│   ├── coco_stuff10k
+│   │   ├── images
+│   │   │   ├── train2014
+│   │   │   ├── test2014
+│   │   ├── annotations
+│   │   │   ├── train2014
+│   │   │   ├── test2014
+│   │   ├── imagesLists
+│   │   │   ├── train.txt
+│   │   │   ├── test.txt
+│   │   │   ├── all.txt
+│   ├── coco_stuff164k
+│   │   ├── images
+│   │   │   ├── train2017
+│   │   │   ├── val2017
+│   │   ├── annotations
+│   │   │   ├── train2017
+│   │   │   ├── val2017
+│   ├── CHASE_DB1
+│   │   ├── images
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   ├── annotations
+│   │   │   ├── training
+│   │   │   ├── validation
+│   ├── DRIVE
+│   │   ├── images
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   ├── annotations
+│   │   │   ├── training
+│   │   │   ├── validation
+│   ├── HRF
+│   │   ├── images
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   ├── annotations
+│   │   │   ├── training
+│   │   │   ├── validation
+│   ├── STARE
+│   │   ├── images
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   ├── annotations
+│   │   │   ├── training
+│   │   │   ├── validation
+|   ├── dark_zurich
+|   │   ├── gps
+|   │   │   ├── val
+|   │   │   └── val_ref
+|   │   ├── gt
+|   │   │   └── val
+|   │   ├── LICENSE.txt
+|   │   ├── lists_file_names
+|   │   │   ├── val_filenames.txt
+|   │   │   └── val_ref_filenames.txt
+|   │   ├── README.md
+|   │   └── rgb_anon
+|   │   |   ├── val
+|   │   |   └── val_ref
+|   ├── NighttimeDrivingTest
+|   |   ├── gtCoarse_daytime_trainvaltest
+|   |   │   └── test
+|   |   │       └── night
+|   |   └── leftImg8bit
+|   |   |   └── test
+|   |   |       └── night
+│   ├── loveDA
+│   │   ├── img_dir
+│   │   │   ├── train
+│   │   │   ├── val
+│   │   │   ├── test
+│   │   ├── ann_dir
+│   │   │   ├── train
+│   │   │   ├── val
+│   ├── potsdam
+│   │   ├── img_dir
+│   │   │   ├── train
+│   │   │   ├── val
+│   │   ├── ann_dir
+│   │   │   ├── train
+│   │   │   ├── val
+│   ├── vaihingen
+│   │   ├── img_dir
+│   │   │   ├── train
+│   │   │   ├── val
+│   │   ├── ann_dir
+│   │   │   ├── train
+│   │   │   ├── val
+│   ├── iSAID
+│   │   ├── img_dir
+│   │   │   ├── train
+│   │   │   ├── val
+│   │   │   ├── test
+│   │   ├── ann_dir
+│   │   │   ├── train
+│   │   │   ├── val
+│   ├── synapse
+│   │   ├── img_dir
+│   │   │   ├── train
+│   │   │   ├── val
+│   │   ├── ann_dir
+│   │   │   ├── train
+│   │   │   ├── val
+│   ├── REFUGE
+│   │   ├── images
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   │   ├── test
+│   │   ├── annotations
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   │   ├── test
+│   ├── mapillary
+│   │   ├── training
+│   │   │   ├── images
+│   │   │   ├── v1.2
+|   │   │   │   ├── instances
+|   │   │   │   ├── labels
+|   │   │   │   └── panoptic
+│   │   │   ├── v2.0
+|   │   │   │   ├── instances
+|   │   │   │   ├── labels
+|   │   │   │   ├── panoptic
+|   │   │   │   └── polygons
+│   │   ├── validation
+│   │   │   ├── images
+|   │   │   ├── v1.2
+|   │   │   │   ├── instances
+|   │   │   │   ├── labels
+|   │   │   │   └── panoptic
+│   │   │   ├── v2.0
+|   │   │   │   ├── instances
+|   │   │   │   ├── labels
+|   │   │   │   ├── panoptic
+|   │   │   │   └── polygons
+│   ├── bdd100k
+│   │   ├── images
+│   │   │   └── 10k
+|   │   │   │   ├── test
+|   │   │   │   ├── train
+|   │   │   │   └── val
+│   │   └── labels
+│   │   │   └── sem_seg
+|   │   │   │   ├── colormaps
+|   │   │   │   │   ├──train
+|   │   │   │   │   └──val
+|   │   │   │   ├── masks
+|   │   │   │   │   ├──train
+|   │   │   │   │   └──val
+|   │   │   │   ├── polygons
+|   │   │   │   │   ├──sem_seg_train.json
+|   │   │   │   │   └──sem_seg_val.json
+|   │   │   │   └── rles
+|   │   │   │   │   ├──sem_seg_train.json
+|   │   │   │   │   └──sem_seg_val.json
+│   ├── nyu
+│   │   ├── images
+│   │   │   ├── train
+│   │   │   ├── test
+│   │   ├── annotations
+│   │   │   ├── train
+│   │   │   ├── test
+│   ├── HSIDrive20
+│   │   ├── images
+│   │   │   ├── train
+│   │   │   ├── validation
+│   │   │   ├── test
+│   │   ├── annotations
+│   │   │   ├── train
+│   │   │   ├── validation
+│   │   │   ├── test
+```
+
+## 用 MIM 下载数据集
+
+通过使用 [OpenXLab](https://openxlab.org.cn/datasets)，您可以直接下载开源数据集。通过平台的搜索功能，您可以快速轻松地找到他们正在寻找的数据集。使用平台上的格式化数据集，您可以高效地跨数据集执行任务。
+
+如果您使用 MIM 下载，请确保版本大于 v0.3.8。您可以使用以下命令进行更新、安装、登录和数据集下载：
+
+```shell
+# upgrade your MIM
+pip install -U openmim
+
+# install OpenXLab CLI tools
+pip install -U openxlab
+# log in OpenXLab
+openxlab login
+
+# download ADE20K by MIM
+mim download mmsegmentation --dataset ade20k
+```
+
+## Cityscapes
+
+Cityscapes [官方网站](https://www.cityscapes-dataset.com/)可以下载 Cityscapes 数据集，按照官网要求注册并登陆后，数据可以在[这里](https://www.cityscapes-dataset.com/downloads/)找到。
+
+按照惯例，`**labelTrainIds.png` 用于 cityscapes 训练。
+我们提供了一个基于 [cityscapesscripts](https://github.com/mcordts/cityscapesScripts) 的[脚本](https://github.com/open-mmlab/mmsegmentation/blob/1.x/tools/dataset_converters/cityscapes.py)用于生成 `**labelTrainIds.png`。
+
+```shell
+# --nproc 表示 8 个转换进程，也可以省略。
+python tools/dataset_converters/cityscapes.py data/cityscapes --nproc 8
+```
+
+## Pascal VOC
+
+Pascal VOC 2012 可从[此处](http://host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCtrainval_11-May-2012.tar)下载。
+此外，Pascal VOC 数据集的最新工作通常利用额外的增强数据，可以在[这里](http://www.eecs.berkeley.edu/Research/Projects/CS/vision/grouping/semantic_contours/benchmark.tgz)找到。
+
+如果您想使用增强的 VOC 数据集，请运行以下命令将增强数据的标注转换为正确的格式。
+
+```shell
+# --nproc 表示 8 个转换进程，也可以省略。
+python tools/dataset_converters/voc_aug.py data/VOCdevkit data/VOCdevkit/VOCaug --nproc 8
+```
+
+请参考[拼接数据集文档](../advanced_guides/add_datasets.md#拼接数据集)及 [voc_aug 配置示例](../../../configs/_base_/datasets/pascal_voc12_aug.py)以详细了解如何将它们拼接并合并训练。
+
+## ADE20K
+
+ADE20K 的训练和验证集可以从这个[链接](http://data.csail.mit.edu/places/ADEchallenge/ADEChallengeData2016.zip)下载。
+如果需要下载测试数据集，可以在[官网](http://host.robots.ox.ac.uk/)注册后，下载[测试集](http://host.robots.ox.ac.uk:8080/eval/downloads/VOC2010test.tar)。
+
+## Pascal Context
+
+Pascal Context 的训练和验证集可以从[此处](http://host.robots.ox.ac.uk/pascal/VOC/voc2010/VOCtrainval_03-May-2010.tar)下载。注册后，您也可以从[此处](http://host.robots.ox.ac.uk:8080/eval/downloads/VOC2010test.tar)下载测试集。
+
+从原始数据集中抽出部分数据作为验证集，您可以从[此处](https://codalabuser.blob.core.windows.net/public/trainval_merged.json)下载 trainval_merged.json 文件。
+
+请先安装 [Detail](https://github.com/zhanghang1989/detail-api) 工具然后运行以下命令将标注转换为正确的格式。
+
+```shell
+python tools/dataset_converters/pascal_context.py data/VOCdevkit data/VOCdevkit/VOC2010/trainval_merged.json
+```
+
+## COCO Stuff 10k
+
+数据可以通过 wget 在[这里](http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/cocostuff-10k-v1.1.zip)下载。
+
+对于 COCO Stuff 10k 数据集，请运行以下命令下载并转换数据集。
+
+```shell
+# 下载
+mkdir coco_stuff10k && cd coco_stuff10k
+wget http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/cocostuff-10k-v1.1.zip
+
+# 解压
+unzip cocostuff-10k-v1.1.zip
+
+# --nproc 表示 8 个转换进程，也可以省略。
+python tools/dataset_converters/coco_stuff10k.py /path/to/coco_stuff10k --nproc 8
+```
+
+按照惯例，`/path/to/coco_stuff164k/annotations/*2014/*_labelTrainIds.png` 中的 mask 标注用于 COCO Stuff 10k 的训练和测试。
+
+## COCO Stuff 164k
+
+对于 COCO Stuff 164k 数据集，请运行以下命令下载并转换增强的数据集。
+
+```shell
+# 下载
+mkdir coco_stuff164k && cd coco_stuff164k
+wget http://images.cocodataset.org/zips/train2017.zip
+wget http://images.cocodataset.org/zips/val2017.zip
+wget http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/stuffthingmaps_trainval2017.zip
+
+# 解压
+unzip train2017.zip -d images/
+unzip val2017.zip -d images/
+unzip stuffthingmaps_trainval2017.zip -d annotations/
+
+# --nproc 表示 8 个转换进程，也可以省略。
+python tools/dataset_converters/coco_stuff164k.py /path/to/coco_stuff164k --nproc 8
+```
+
+按照惯例，`/path/to/coco_stuff164k/annotations/*2017/*_labelTrainIds.png` 中的 mask 标注用于 COCO Stuff 164k 的训练和测试。
+
+此数据集的详细信息可在[此处](https://github.com/nightrome/cocostuff#downloads)找到。
+
+## CHASE DB1
+
+CHASE DB1 的训练和验证集可以从[此处](https://staffnet.kingston.ac.uk/~ku15565/CHASE_DB1/assets/CHASEDB1.zip)下载。
+
+请运行以下命令，准备 CHASE DB1 数据集：
+
+```shell
+python tools/dataset_converters/chase_db1.py /path/to/CHASEDB1.zip
+```
+
+该脚本将自动调整数据集目录结构，使其满足 MMSegmentation 数据集加载要求。
+
+## DRIVE
+
+按照[官网](https://drive.grand-challenge.org/)要求，注册并登陆后，便可以下载 DRIVE 的训练和验证数据集。
+
+要将 DRIVE 数据集转换为 MMSegmentation 的格式，请运行以下命令：
+
+```shell
+python tools/dataset_converters/drive.py /path/to/training.zip /path/to/test.zip
+```
+
+该脚本将自动调整数据集目录结构，使其满足 MMSegmentation 数据集加载要求。
+
+## HRF
+
+请下载 [health.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/healthy.zip)、[glaucoma.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/glaucoma.zip)、[diabetic_retinopathy.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/diabetic_retinopathy.zip)、[healthy_manualsegm.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/healthy_manualsegm.zip)、[glaucoma_manualsegm.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/glaucoma_manualsegm.zip) 和 [diabetic_retinopathy_manualsegm.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/diabetic_retinopathy_manualsegm.zip)，无需解压，可以直接运行以下命令，准备 HRF 数据集：
+
+```shell
+python tools/dataset_converters/hrf.py /path/to/healthy.zip /path/to/healthy_manualsegm.zip /path/to/glaucoma.zip /path/to/glaucoma_manualsegm.zip /path/to/diabetic_retinopathy.zip /path/to/diabetic_retinopathy_manualsegm.zip
+```
+
+该脚本将自动调整数据集目录结构，使其满足 MMSegmentation 数据集加载要求。
+
+## STARE
+
+请下载 [stare images.tar](http://cecas.clemson.edu/~ahoover/stare/probing/stare-images.tar)、[labels-ah.tar](http://cecas.clemson.edu/~ahoover/stare/probing/labels-ah.tar) 和 [labels-vk.tar](http://cecas.clemson.edu/~ahoover/stare/probing/labels-vk.tar)，无需解压，可以直接运行以下命令，准备 STARE 数据集：
+
+```shell
+python tools/dataset_converters/stare.py /path/to/stare-images.tar /path/to/labels-ah.tar /path/to/labels-vk.tar
+```
+
+该脚本将自动调整数据集目录结构，使其满足 MMSegmentation 数据集加载要求。
+
+## Dark Zurich
+
+由于我们只支持在此数据集上的模型测试，因此您只需要下载并解压[验证数据集](https://data.vision.ee.ethz.ch/csakarid/shared/GCMA_UIoU/Dark_Zurich_val_anon.zip)。
+
+## Nighttime Driving
+
+由于我们只支持在此数据集上的模型测试，因此您只需要下载并解压[验证数据集](http://data.vision.ee.ethz.ch/daid/NighttimeDriving/NighttimeDrivingTest.zip)。
+
+## LoveDA
+
+数据可以从[此处](https://drive.google.com/drive/folders/1ibYV0qwn4yuuh068Rnc-w4tPi0U0c-ti?usp=sharing)下载 LaveDA 数据集。
+
+或者可以从 [zenodo](https://zenodo.org/record/5706578#.YZvN7SYRXdF) 下载。下载后，无需解压，直接运行以下命令：
+
+```shell
+# 下载 Train.zip
+wget https://zenodo.org/record/5706578/files/Train.zip
+# 下载 Val.zip
+wget https://zenodo.org/record/5706578/files/Val.zip
+# 下载 Test.zip
+wget https://zenodo.org/record/5706578/files/Test.zip
+```
+
+请对于 LoveDA 数据集，请运行以下命令调整数据集目录。
+
+```shell
+python tools/dataset_converters/loveda.py /path/to/loveDA
+```
+
+可将模型对 LoveDA 的测试集的预测结果上传至到数据集[测试服务器](https://codalab.lisn.upsaclay.fr/competitions/421)，查看评测结果。
+
+有关 LoveDA 的更多详细信息，可查看[此处](https://github.com/Junjue-Wang/LoveDA).
+
+## ISPRS Potsdam
+
+[Potsdam](https://www.isprs.org/education/benchmarks/UrbanSemLab/2d-sem-label-potsdam.aspx) 城市语义分割数据集用于 2D 语义分割竞赛 —— Potsdam。
+
+数据集可以在竞赛[主页](https://www.isprs.org/education/benchmarks/UrbanSemLab/default.aspx)上请求获得。
+这里也提供了[BaiduNetdisk](https://pan.baidu.com/s/1K-cLVZnd1X7d8c26FQ-nGg?pwd=mseg)，提取码：mseg、 [Google Drive](https://drive.google.com/drive/folders/1w3EJuyUGet6_qmLwGAWZ9vw5ogeG0zLz?usp=sharing)以及[OpenDataLab](https://opendatalab.com/ISPRS_Potsdam/download)。
+实验中需要下载 '2_Ortho_RGB.zip' 和 '5_Labels_all_noBoundary.zip'。
+
+对于 Potsdam 数据集，请运行以下命令调整数据集目录。
+
+```shell
+python tools/dataset_converters/potsdam.py /path/to/potsdam
+```
+
+在我们的默认设置中，将生成 3456 张图像用于训练和 2016 张图像用于验证。
+
+## ISPRS Vaihingen
+
+[Vaihingen](https://www.isprs.org/education/benchmarks/UrbanSemLab/2d-sem-label-vaihingen.aspx) 城市语义分割数据集用于 2D 语义分割竞赛 —— Vaihingen。
+
+数据集可以在竞赛[主页](https://www.isprs.org/education/benchmarks/UrbanSemLab/default.aspx)上请求获得。
+这里也提供了[BaiduNetdisk](https://pan.baidu.com/s/109D3WLrLafsuYtLeerLiiA?pwd=mseg)，提取码：mseg 、 [Google Drive](https://drive.google.com/drive/folders/1w3NhvLVA2myVZqOn2pbiDXngNC7NTP_t?usp=sharing)。
+实验中需要下载 'ISPRS_semantic_labeling_Vaihingen.zip' 和 'ISPRS_semantic_labeling_Vaihingen_ground_truth_eroded_COMPLETE.zip'。
+
+对于 Vaihingen 数据集，请运行以下命令调整数据集目录。
+
+```shell
+python tools/dataset_converters/vaihingen.py /path/to/vaihingen
+```
+
+在我们的默认设置（`clip_size`=512, `stride_size`=256）中，将生成 344 张图像用于训练和 398 张图像用于验证。
+
+## iSAID
+
+iSAID 数据集可从 [DOTA-v1.0](https://captain-whu.github.io/DOTA/dataset.html) 下载训练/验证/测试数据集的图像数据，
+
+并从 [iSAID](https://captain-whu.github.io/iSAID/dataset.html)下载训练/验证数据集的标注数据。
+
+该数据集是航空图像实例分割和语义分割任务的大规模数据集。
+
+下载 iSAID 数据集后，您可能需要按照以下结构进行数据集准备。
+
+```none
+├── data
+│   ├── iSAID
+│   │   ├── train
+│   │   │   ├── images
+│   │   │   │   ├── part1.zip
+│   │   │   │   ├── part2.zip
+│   │   │   │   ├── part3.zip
+│   │   │   ├── Semantic_masks
+│   │   │   │   ├── images.zip
+│   │   ├── val
+│   │   │   ├── images
+│   │   │   │   ├── part1.zip
+│   │   │   ├── Semantic_masks
+│   │   │   │   ├── images.zip
+│   │   ├── test
+│   │   │   ├── images
+│   │   │   │   ├── part1.zip
+│   │   │   │   ├── part2.zip
+```
+
+```shell
+python tools/dataset_converters/isaid.py /path/to/iSAID
+```
+
+在我们的默认设置（`patch_width`=896, `patch_height`=896, `overlap_area`=384）中，将生成 33978 张图像用于训练和 11644 张图像用于验证。
+
+## LIP(Look Into Person) dataset
+
+该数据集可以从[此页面](https://lip.sysuhcp.com/overview.php)下载。
+
+请运行以下命令来解压数据集。
+
+```shell
+unzip LIP.zip
+cd LIP
+unzip TrainVal_images.zip
+unzip TrainVal_parsing_annotations.zip
+cd TrainVal_parsing_annotations
+unzip TrainVal_parsing_annotations.zip
+mv train_segmentations ../
+mv val_segmentations ../
+cd ..
+```
+
+LIP 数据集的内容包括：
+
+```none
+├── data
+│   ├── LIP
+│   │   ├── train_images
+│   │   │   ├── 1000_1234574.jpg
+│   │   │   ├── ...
+│   │   ├── train_segmentations
+│   │   │   ├── 1000_1234574.png
+│   │   │   ├── ...
+│   │   ├── val_images
+│   │   │   ├── 100034_483681.jpg
+│   │   │   ├── ...
+│   │   ├── val_segmentations
+│   │   │   ├── 100034_483681.png
+│   │   │   ├── ...
+```
+
+## Synapse dataset
+
+此数据集可以从[此页面](https://www.synapse.org/#!Synapse:syn3193805/wiki/)下载。
+
+遵循 [TransUNet](https://arxiv.org/abs/2102.04306) 的数据准备设定，将原始训练集（30 次扫描）拆分为新的训练集（18 次扫描）和验证集（12 次扫描）。请运行以下命令来准备数据集。
+
+```shell
+unzip RawData.zip
+cd ./RawData/Training
+```
+
+然后创建 `train.txt` 和 `val.txt` 以拆分数据集。
+
+根据 TransUnet，以下是数据集的划分。
+
+train.txt
+
+```none
+img0005.nii.gz
+img0006.nii.gz
+img0007.nii.gz
+img0009.nii.gz
+img0010.nii.gz
+img0021.nii.gz
+img0023.nii.gz
+img0024.nii.gz
+img0026.nii.gz
+img0027.nii.gz
+img0028.nii.gz
+img0030.nii.gz
+img0031.nii.gz
+img0033.nii.gz
+img0034.nii.gz
+img0037.nii.gz
+img0039.nii.gz
+img0040.nii.gz
+```
+
+val.txt
+
+```none
+img0008.nii.gz
+img0022.nii.gz
+img0038.nii.gz
+img0036.nii.gz
+img0032.nii.gz
+img0002.nii.gz
+img0029.nii.gz
+img0003.nii.gz
+img0001.nii.gz
+img0004.nii.gz
+img0025.nii.gz
+img0035.nii.gz
+```
+
+synapse 数据集的内容包括：
+
+```none
+├── Training
+│   ├── img
+│   │   ├── img0001.nii.gz
+│   │   ├── img0002.nii.gz
+│   │   ├── ...
+│   ├── label
+│   │   ├── label0001.nii.gz
+│   │   ├── label0002.nii.gz
+│   │   ├── ...
+│   ├── train.txt
+│   ├── val.txt
+```
+
+然后，使用此命令转换 synapse 数据集。
+
+```shell
+python tools/dataset_converters/synapse.py --dataset-path /path/to/synapse
+```
+
+注意，MMSegmentation 的默认评估指标（例如 mean dice value）是在 2D 切片图像上计算的，这与 [TransUNet](https://arxiv.org/abs/2102.04306) 等一些论文中的 3D 扫描结果是不同的。
+
+## REFUGE
+
+在 [REFUGE Challenge](https://refuge.grand-challenge.org) 官网上注册并下载 [REFUGE 数据集](https://refuge.grand-challenge.org/REFUGE2Download)。
+
+然后，解压 `REFUGE2.zip`，原始数据集的内容包括：
+
+```none
+├── REFUGE2
+│   ├── REFUGE2
+│   │   ├── Annotation-Training400.zip
+│   │   ├── REFUGE-Test400.zip
+│   │   ├── REFUGE-Test-GT.zip
+│   │   ├── REFUGE-Training400.zip
+│   │   ├── REFUGE-Validation400.zip
+│   │   ├── REFUGE-Validation400-GT.zip
+│   ├── __MACOSX
+```
+
+请运行以下命令转换 REFUGE 数据集：
+
+```shell
+python tools/convert_datasets/refuge.py --raw_data_root=/path/to/refuge/REFUGE2/REFUGE2
+```
+
+脚本会将目录结构转换如下：
+
+```none
+│   ├── REFUGE
+│   │   ├── images
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   │   ├── test
+│   │   ├── annotations
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   │   ├── test
+```
+
+包含 400 张用于训练的图像、400 张用于验证的图像和 400 张用于测试的图像，这与 REFUGE 2018 数据集相同。
+
+## Mapillary Vistas Datasets
+
+- Mapillary Vistas [官方网站](https://www.mapillary.com/dataset/vistas) 可以下载 Mapillary Vistas 数据集，按照官网要求注册并登陆后，数据可以在[这里](https://www.mapillary.com/dataset/vistas)找到。
+
+- Mapillary Vistas 数据集使用 8-bit with color-palette 来存储标签。不需要进行转换操作。
+
+- 假设您已将数据集 zip 文件放在 `mmsegmentation/data/mapillary` 中
+
+- 请运行以下命令来解压数据集。
+
+  ```bash
+  cd data/mapillary
+  unzip An-ZjB1Zm61yAZG0ozTymz8I8NqI4x0MrYrh26dq7kPgfu8vf9ImrdaOAVOFYbJ2pNAgUnVGBmbue9lTgdBOb5BbKXIpFs0fpYWqACbrQDChAA2fdX0zS9PcHu7fY8c-FOvyBVxPNYNFQuM.zip
+  ```
+
+- 解压后，您将获得类似于此结构的 Mapillary Vistas 数据集。语义分割 mask 标签在 `labels` 文件夹中。
+
+  ```none
+  mmsegmentation
+  ├── mmseg
+  ├── tools
+  ├── configs
+  ├── data
+  │   ├── mapillary
+  │   │   ├── training
+  │   │   │   ├── images
+  │   │   │   ├── v1.2
+  |   │   │   │   ├── instances
+  |   │   │   │   ├── labels
+  |   │   │   │   └── panoptic
+  │   │   │   ├── v2.0
+  |   │   │   │   ├── instances
+  |   │   │   │   ├── labels
+  |   │   │   │   ├── panoptic
+  |   │   │   │   └── polygons
+  │   │   ├── validation
+  │   │   │   ├── images
+  |   │   │   ├── v1.2
+  |   │   │   │   ├── instances
+  |   │   │   │   ├── labels
+  |   │   │   │   └── panoptic
+  │   │   │   ├── v2.0
+  |   │   │   │   ├── instances
+  |   │   │   │   ├── labels
+  |   │   │   │   ├── panoptic
+  |   │   │   │   └── polygons
+  ```
+
+- 您可以在配置中使用 `MapillaryDataset_v1` 和 `Mapillary Dataset_v2` 设置数据集版本。
+  在此处 [V1.2](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/_base_/datasets/mapillary_v1.py) 和 [V2.0](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/_base_/datasets/mapillary_v2.py) 查看 Mapillary Vistas 数据集配置文件
+
+## LEVIR-CD
+
+[LEVIR-CD](https://justchenhao.github.io/LEVIR/) 大规模遥感建筑变化检测数据集。
+
+数据集可以在[主页](https://justchenhao.github.io/LEVIR/)上请求获得。
+
+数据集的补充版本可以在[主页](https://github.com/S2Looking/Dataset)上请求获得。
+
+请下载数据集的补充版本，然后解压 `LEVIR-CD+.zip`，数据集的内容包括：
+
+```none
+│   ├── LEVIR-CD+
+│   │   ├── train
+│   │   │   ├── A
+│   │   │   ├── B
+│   │   │   ├── label
+│   │   ├── test
+│   │   │   ├── A
+│   │   │   ├── B
+│   │   │   ├── label
+```
+
+对于 LEVIR-CD 数据集，请运行以下命令无重叠裁剪影像：
+
+```shell
+python tools/dataset_converters/levircd.py --dataset-path /path/to/LEVIR-CD+ --out_dir /path/to/LEVIR-CD
+```
+
+裁剪后的影像大小为256x256，与原论文保持一致。
+
+## BDD100K
+
+- 可以从[官方网站](https://bdd-data.berkeley.edu/) 下载 BDD100K数据集（语义分割任务主要是10K数据集），按照官网要求注册并登陆后，数据可以在[这里](https://bdd-data.berkeley.edu/portal.html#download)找到。
+
+- 图像数据对应的名称是是`10K Images`, 语义分割标注对应的名称是`Segmentation`
+
+- 下载后，可以使用以下代码进行解压
+
+  ```bash
+  unzip ~/bdd100k_images_10k.zip -d ~/mmsegmentation/data/
+  unzip ~/bdd100k_sem_seg_labels_trainval.zip -d ~/mmsegmentation/data/
+  ```
+
+就可以得到以下文件结构了：
+
+```none
+mmsegmentation
+├── mmseg
+├── tools
+├── configs
+├── data
+│   ├── bdd100k
+│   │   ├── images
+│   │   │   └── 10k
+|   │   │   │   ├── test
+|   │   │   │   ├── train
+|   │   │   │   └── val
+│   │   └── labels
+│   │   │   └── sem_seg
+|   │   │   │   ├── colormaps
+|   │   │   │   │   ├──train
+|   │   │   │   │   └──val
+|   │   │   │   ├── masks
+|   │   │   │   │   ├──train
+|   │   │   │   │   └──val
+|   │   │   │   ├── polygons
+|   │   │   │   │   ├──sem_seg_train.json
+|   │   │   │   │   └──sem_seg_val.json
+|   │   │   │   └── rles
+|   │   │   │   │   ├──sem_seg_train.json
+|   │   │   │   │   └──sem_seg_val.json
+```
+
+## NYU
+
+- 您可以从 [这个链接](https://drive.google.com/file/d/1wC-io-14RCIL4XTUrQLk6lBqU2AexLVp/view?usp=share_link) 下载 NYU 数据集
+
+- 下载完成后，您可以使用 [tools/dataset_converters/nyu.py](/tools/dataset_converters/nyu.py) 脚本来解压和组织数据到所需的格式
+
+  ```bash
+  python tools/dataset_converters/nyu.py nyu.zip
+  ```
+
+## HSI Drive 2.0
+
+- 您可以从以下位置下载 HSI Drive 2.0 数据集 [here](https://ipaccess.ehu.eus/HSI-Drive/#download) 刚刚向 gded@ehu.eus 发送主题为“下载 HSI-Drive”的电子邮件后 您将收到解压缩文件的密码.
+
+- 下载后，按照以下说明解压：
+
+  ```bash
+  7z x -p"password" ./HSI_Drive_v2_0_Phyton.zip
+
+  mv ./HSIDrive20 path_to_mmsegmentation/data
+  mv ./HSI_Drive_v2_0_release_notes_Python_version.md path_to_mmsegmentation/data
+  mv ./image_numbering.pdf path_to_mmsegmentation/data
+  ```
+
+- 解压后得到:
+
+```none
+mmsegmentation
+├── mmseg
+├── tools
+├── configs
+├── data
+│   ├── HSIDrive20
+│   │   ├── images
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   │   ├── test
+│   │   ├── annotations
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   │   ├── test
+│   │   ├── images_MF
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   │   ├── test
+│   │   ├── RGB
+│   │   ├── training_filenames.txt
+│   │   ├── validation_filenames.txt
+│   │   ├── test_filenames.txt
+│   ├── HSI_Drive_v2_0_release_notes_Python_version.md
+│   ├── image_numbering.pdf
+```
diff --git a/mmsegmentation/docs/zh_cn/user_guides/3_inference.md b/mmsegmentation/docs/zh_cn/user_guides/3_inference.md
new file mode 100644
index 0000000..0afcb4b
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/user_guides/3_inference.md
@@ -0,0 +1,244 @@
+# 教程3：使用预训练模型推理
+
+MMSegmentation 在 [Model Zoo](../Model_Zoo.md) 中为语义分割提供了预训练的模型，并支持多个标准数据集，包括 Cityscapes、ADE20K 等。
+本说明将展示如何使用现有模型对给定图像进行推理。
+关于如何在标准数据集上测试现有模型，请参阅本[指南](./4_train_test.md)
+
+MMSegmentation 为用户提供了数个接口，以便轻松使用预训练的模型进行推理。
+
+- [教程3：使用预训练模型推理](#教程3使用预训练模型推理)
+  - [推理器](#推理器)
+    - [基本使用](#基本使用)
+    - [初始化](#初始化)
+    - [可视化预测结果](#可视化预测结果)
+    - [模型列表](#模型列表)
+  - [推理 API](#推理-api)
+    - [mmseg.apis.init_model](#mmsegapisinit_model)
+    - [mmseg.apis.inference_model](#mmsegapisinference_model)
+    - [mmseg.apis.show_result_pyplot](#mmsegapisshow_result_pyplot)
+
+## 推理器
+
+在 MMSegmentation 中，我们提供了最**方便的**方式 `MMSegInferencer` 来使用模型。您只需 3 行代码就可以获得图像的分割掩膜。
+
+### 基本使用
+
+以下示例展示了如何使用 `MMSegInferencer` 对单个图像执行推理。
+
+```
+>>> from mmseg.apis import MMSegInferencer
+>>> # 将模型加载到内存中
+>>> inferencer = MMSegInferencer(model='deeplabv3plus_r18-d8_4xb2-80k_cityscapes-512x1024')
+>>> # 推理
+>>> inferencer('demo/demo.png', show=True)
+```
+
+可视化结果应如下所示：
+
+<div align="center">
+    <img src='https://user-images.githubusercontent.com/76149310/221507927-ae01e3a7-016f-4425-b966-7b19cbbe494e.png' />
+</div>
+
+此外，您可以使用 `MMSegInferencer` 来处理一个包含多张图片的 `list`：
+
+```
+# 输入一个图片 list
+>>> images = [image1, image2, ...] # image1 可以是文件路径或 np.ndarray
+>>> inferencer(images, show=True, wait_time=0.5) # wait_time 是延迟时间，0 表示无限
+
+# 或输入图像目录
+>>> images = $IMAGESDIR
+>>> inferencer(images, show=True, wait_time=0.5)
+
+# 保存可视化渲染彩色分割图和预测结果
+# out_dir 是保存输出结果的目录，img_out_dir 和 pred_out_dir 为 out_dir 的子目录
+# 以保存可视化渲染彩色分割图和预测结果
+>>> inferencer(images, out_dir='outputs', img_out_dir='vis', pred_out_dir='pred')
+```
+
+推理器有一个可选参数 `return_datasamples`，其默认值为 False，推理器的返回值默认为 `dict` 类型，包括 'visualization' 和 'predictions' 两个 key。
+如果 `return_datasamples=True` 推理器将返回 [`SegDataSample`](../advanced_guides/structures.md) 或其列表。
+
+```
+result = inferencer('demo/demo.png')
+# 结果是一个包含 'visualization' 和 'predictions' 两个 key 的 `dict`
+# 'visualization' 包含彩色分割图
+print(result['visualization'].shape)
+# (512, 683, 3)
+
+# 'predictions' 包含带有标签索引的分割掩膜
+print(result['predictions'].shape)
+# (512, 683)
+
+result = inferencer('demo/demo.png', return_datasamples=True)
+print(type(result))
+# <class 'mmseg.structures.seg_data_sample.SegDataSample'>
+
+# 输入一个图片 list
+results = inferencer(images)
+# 输出为列表
+print(type(results['visualization']), results['visualization'][0].shape)
+# <class 'list'> (512, 683, 3)
+print(type(results['predictions']), results['predictions'][0].shape)
+# <class 'list'> (512, 683)
+
+results = inferencer(images, return_datasamples=True)
+# <class 'list'>
+print(type(results[0]))
+# <class 'mmseg.structures.seg_data_sample.SegDataSample'>
+```
+
+### 初始化
+
+`MMSegInferencer` 必须使用 `model` 初始化，该 `model` 可以是模型名称或一个 `Config`，甚至可以是配置文件的路径。
+模型名称可以在模型的元文件（configs/xxx/metafile.yaml）中找到，比如 maskformer 的一个模型名称是 `maskformer_r50-d32_8xb2-160k_ade20k-512x512`，如果输入模型名称，模型的权重将自动下载。以下是其他输入参数：
+
+- weights（str，可选）- 权重的路径。如果未指定，并且模型是元文件中的模型名称，则权重将从元文件加载。默认为 None。
+- classes（list，可选）- 输入类别用于结果渲染，由于分割模型的预测结构是标签索引的分割图，`classes` 是一个相应的标签索引的类别列表。若 classes 没有定义，可视化工具将默认使用 `cityscapes` 的类别。默认为 None。
+- palette（list，可选）- 输入调色盘用于结果渲染，它是对应分类的配色列表。若 palette 没有定义，可视化工具将默认使用 `cityscapes` 的调色盘。默认为 None。
+- dataset_name（str，可选）- [数据集名称或别名](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/utils/class_names.py#L302-L317)，可视化工具将使用数据集的元信息，如类别和配色，但 `classes` 和 `palette` 具有更高的优先级。默认为 None。
+- device（str，可选）- 运行推理的设备。如果无，则会自动使用可用的设备。默认为 None。
+- scope（str，可选）- 模型的作用域。默认为 'mmseg'。
+
+### 可视化预测结果
+
+`MMSegInferencer` 有4个用于可视化预测的参数，您可以在初始化推理器时使用它们：
+
+- show（bool）- 是否弹出窗口显示图像。默认为 False。
+- wait_time（float）- 显示的间隔。默认值为 0。
+- img_out_dir（str）- `out_dir` 的子目录，用于保存渲染有色分割掩膜，因此如果要保存预测掩膜，则必须定义 `out_dir`。默认为 `vis`。
+- opacity（int，float）- 分割掩膜的透明度。默认值为 0.8。
+
+这些参数的示例请参考[基本使用](#基本使用)
+
+### 模型列表
+
+在 MMSegmentation 中有一个非常容易列出所有模型名称的方法
+
+```
+>>> from mmseg.apis import MMSegInferencer
+# models 是一个模型名称列表，它们将自动打印
+>>> models = MMSegInferencer.list_models('mmseg')
+```
+
+## 推理 API
+
+### mmseg.apis.init_model
+
+从配置文件初始化一个分割器。
+
+参数：
+
+- config（str，`Path` 或 `mmengine.Config`）- 配置文件路径或配置对象。
+- checkpoint（str，可选）- 权重路径。如果为 None，则模型将不会加载任何权重。
+- device（str，可选）- CPU/CUDA 设备选项。默认为 'cuda:0'。
+- cfg_options（dict，可选）- 用于覆盖所用配置中的某些设置的选项。
+
+返回值：
+
+- nn.Module：构建好的分割器。
+
+示例：
+
+```python
+from mmseg.apis import init_model
+
+config_path = 'configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+checkpoint_path = 'checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
+
+# 初始化不带权重的模型
+model = init_model(config_path)
+
+# 初始化模型并加载权重
+model = init_model(config_path, checkpoint_path)
+
+# 在 CPU 上的初始化模型并加载权重
+model = init_model(config_path, checkpoint_path, 'cpu')
+```
+
+### mmseg.apis.inference_model
+
+使用分割器推理图像。
+
+参数：
+
+- model（nn.Module）- 加载的分割器
+- imgs（str，np.ndarray 或 list\[str/np.ndarray\]）- 图像文件或加载的图像
+
+返回值：
+
+- `SegDataSample` 或 list\[`SegDataSample`\]：如果 imgs 是列表或元组，则返回相同长度的列表类型结果，否则直接返回分割结果。
+
+**注意：** [SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py) 是 MMSegmentation 的数据结构接口，用作不同组件之间的接口。`SegDataSample` 实现抽象数据元素 `mmengine.structures.BaseDataElement`，请参阅 [MMEngine](https://github.com/open-mmlab/mmengine) 中的数据元素[文档](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/data_element.html)了解更多信息。
+
+`SegDataSample` 中的参数分为几个部分：
+
+- `gt_sem_seg`（`PixelData`）- 语义分割的标注。
+- `pred_sem_seg`（`PixelData`）- 语义分割的预测。
+- `seg_logits`（`PixelData`）- 模型最后一层的输出结果。
+
+**注意：** [PixelData](https://github.com/open-mmlab/mmengine/blob/main/mmengine/structures/pixel_data.py) 是像素级标注或预测的数据结构，请参阅 [MMEngine](https://github.com/open-mmlab/mmengine) 中的 PixelData [文档](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/data_element.html)了解更多信息。
+
+示例：
+
+```python
+from mmseg.apis import init_model, inference_model
+
+config_path = 'configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+checkpoint_path = 'checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
+img_path = 'demo/demo.png'
+
+
+model = init_model(config_path, checkpoint_path)
+result = inference_model(model, img_path)
+```
+
+### mmseg.apis.show_result_pyplot
+
+在图像上可视化分割结果。
+
+参数：
+
+- model（nn.Module）- 加载的分割器。
+- img（str 或 np.ndarray）- 图像文件名或加载的图像。
+- result（`SegDataSample`）- SegDataSample 预测结果。
+- opacity（float）- 绘制分割图的不透明度。默认值为 `0.5`，必须在 `(0，1]` 范围内。
+- title（str）- pyplot 图的标题。默认值为 ''。
+- draw_gt（bool）- 是否绘制 GT SegDataSample。默认为 `True`。
+- draw_pred（draws_pred）- 是否绘制预测 SegDataSample。默认为 `True`。
+- wait_time（float）- 显示的间隔，0 是表示“无限”的特殊值。默认为 `0`。
+- show（bool）- 是否展示绘制的图像。默认为 `True`。
+- save_dir（str，可选）- 为所有存储后端保存的文件路径。如果为 `None`，则后端存储将不会保存任何数据。
+- out_file（str，可选）- 输出文件的路径。默认为 `None`。
+
+返回值：
+
+- np.ndarray：通道为 RGB 的绘制图像。
+
+示例：
+
+```python
+from mmseg.apis import init_model, inference_model, show_result_pyplot
+
+config_path = 'configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+checkpoint_path = 'checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
+img_path = 'demo/demo.png'
+
+
+# 从配置文件和权重文件构建模型
+model = init_model(config_path, checkpoint_path, device='cuda:0')
+
+# 推理给定图像
+result = inference_model(model, img_path)
+
+# 展示分割结果
+vis_image = show_result_pyplot(model, img_path, result)
+
+# 保存可视化结果，输出图像将在 `workdirs/result.png` 路径下找到
+vis_iamge = show_result_pyplot(model, img_path, result, out_file='work_dirs/result.png')
+
+# 修改展示图像的时间，注意 0 是表示“无限”的特殊值
+vis_image = show_result_pyplot(model, img_path, result, wait_time=5)
+```
+
+**注意：** 如果当前设备没有图形用户界面，建议将 `show` 设置为 `False`，并指定 `out_file` 或 `save_dir` 来保存结果。如果您想在窗口上显示结果，则不需要特殊设置。
diff --git a/mmsegmentation/docs/zh_cn/user_guides/4_train_test.md b/mmsegmentation/docs/zh_cn/user_guides/4_train_test.md
new file mode 100644
index 0000000..f821aca
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/user_guides/4_train_test.md
@@ -0,0 +1,317 @@
+# 教程4：使用现有模型进行训练和测试
+
+MMSegmentation 支持在多种设备上训练和测试模型。如下文，具体方式分别为单GPU、分布式以及计算集群的训练和测试。通过本教程，您将知晓如何用 MMSegmentation 提供的脚本进行训练和测试。
+
+## 在单GPU上训练和测试
+
+### 在单GPU上训练
+
+`tools/train.py` 文件提供了在单GPU上部署训练任务的方法。
+
+基础用法如下:
+
+```shell
+python tools/train.py  ${配置文件} [可选参数]
+```
+
+- `--work-dir ${工作路径}`: 重新指定工作路径
+- `--amp`: 使用自动混合精度计算
+- `--resume`: 从工作路径中保存的最新检查点文件（checkpoint）恢复训练
+- `--cfg-options ${需更覆盖的配置}`: 覆盖已载入的配置中的部分设置，并且 以 xxx=yyy 格式的键值对 将被合并到配置文件中。
+  比如： '--cfg-option model.encoder.in_channels=6'， 更多细节请看[指导](./1_config.md#Modify-config-through-script-arguments)。
+
+下面是对于多GPU测试的可选参数:
+
+- `--launcher`: 执行器的启动方式。允许选择的参数值有 `none`, `pytorch`, `slurm`, `mpi`。特别的，如果设置为none，测试将非分布式模式下进行。
+- `--local_rank`: 分布式中进程的序号。如果没有指定，默认设置为0。
+
+**注意：** 命令行参数 `--resume` 和在配置文件中的参数 `load_from` 的不同之处：
+
+`--resume` 只决定是否继续使用工作路径中最新的检查点，它常常用于恢复被意外打断的训练。
+
+`load_from` 会明确指定被载入的检查点文件，且训练迭代器将从0开始，通常用于微调模型。
+
+如果您希望从指定的检查点上恢复训练您可以使用：
+
+```python
+python tools/train.py ${配置文件} --resume --cfg-options load_from=${检查点}
+```
+
+**在 CPU 上训练**: 如果机器没有 GPU，则在 CPU 上训练的过程是与单GPU训练一致的。如果机器有 GPU 但是不希望使用它们，我们只需要在训练前通过以下方式关闭 GPU 训练功能。
+
+```shell
+export CUDA_VISIBLE_DEVICES=-1
+```
+
+然后运行[上方](###在单GPU上训练)脚本。
+
+### 在单GPU上测试
+
+`tools/test.py` 文件提供了在单 GPU 上启动测试任务的方法。
+
+基础用法如下:
+
+```shell
+python tools/test.py ${配置文件} ${模型权重文件} [可选参数]
+```
+
+这个工具有几个可选参数，包括：
+
+- `--work-dir`: 如果指定了路径，结果会保存在该路径下。如果没有指定则会保存在 `work_dirs/{配置文件名}` 路径下.
+- `--show`: 当 `--show-dir` 没有指定时，可以使用该参数，在程序运行过程中显示预测结果。
+- `--show-dir`: 绘制了分割掩膜图片的存储文件夹。如果指定了该参数，则可视化的分割掩膜将被保存到 `work_dir/timestamp/{指定路径}`.
+- `--wait-time`: 多次可视化结果的时间间隔。当 `--show` 为激活状态时发挥作用。默认为2。
+- `--cfg-options`:  如果被具体指定，以 xxx=yyy 形式的键值对将被合并入配置文件中。
+
+**在CPU上测试**: 如果机器没有GPU，则在CPU上训练的过程是与单GPU训练一致的。如果机器有GPU，但是不希望使用它们，我们只需要在训练前通过以下方式关闭GPUs训练功能。
+
+```shell
+export CUDA_VISIBLE_DEVICES=-1
+```
+
+然后运行[上方](###在单GPU上测试)脚本。
+
+## 多GPU、多机器上训练和测试
+
+### 在多GPU上训练
+
+OpenMMLab2.0 通过 `MMDistributedDataParallel`实现 **分布式** 训练。
+
+`tools/dist_train.sh` 文件提供了在在多GPU上部署训练任务的方法。
+
+基础用法如下:
+
+```shell
+sh tools/dist_train.sh ${配置文件} ${GPU数量} [可选参数]
+```
+
+可选参数与[上方](###在单GPU上训练)相同并且还增加了可以指定gpu数量的参数。
+
+示例:
+
+```shell
+# 模型训练的检查点和日志保存在这个路径下： WORK_DIR=work_dirs/pspnet_r50-d8_4xb4-80k_ade20k-512x512/
+# 如果工作路径没有被设定，它将会被自动生成。
+sh tools/dist_train.sh configs/pspnet/pspnet_r50-d8_4xb4-80k_ade20k-512x512.py 8 --work-dir work_dirs/pspnet_r50-d8_4xb4-80k_ade20k-512x512
+```
+
+**注意**: 在训练过程中，检查点和日志保存在`work_dirs/`下的配置文件的相同文件夹结构下。
+不推荐自定义的工作路径，因为评估脚本依赖于源自配置文件名的路径。如果您希望将权重保存在其他地方，请用符号链接，例如：
+
+```shell
+ln -s ${您的工作路径} ${MMSEG 路径}/work_dirs
+```
+
+### 在多GPU上测试
+
+`tools/dist_test.sh` 文件提供了在多GPU上启动测试任务的方法。
+
+基础用法如下:
+
+```shell
+sh tools/dist_test.sh ${配置文件} ${检查点文件} ${GPU数量} [可选参数]
+```
+
+可选参数与[上方](###在单GPU上测试)相同并且增加了可以指定 gpu 数量的参数。
+
+示例:
+
+```shell
+./tools/dist_test.sh configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py \
+    checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth 4
+```
+
+### 在单台机器上启动多个任务
+
+如果您在单个机器上运行多个任务，比如：在8卡GPU的单个机器上执行2个各需4卡GPU的训练任务，您需要为每个任务具体指定不同端口（默认29500），从而避免通讯冲突。否则，会有报错信息——`RuntimeError: Address already in use`（运行错误：地址被使用）。
+
+如果您使用 `dist_train.sh` 来启动训练任务，您可以通过环境变量 `PORT` 设置端口。
+
+```shell
+CUDA_VISIBLE_DEVICES=0,1,2,3 PORT=29500 sh tools/dist_train.sh ${配置文件} 4
+CUDA_VISIBLE_DEVICES=4,5,6,7 PORT=29501 sh tools/dist_train.sh ${配置文件} 4
+```
+
+### 在多台机器上训练
+
+MMSegmentation 的分布式训练依赖 `torch.distributed`。
+因此， 可以通过 PyTorch 的 [运行工具 launch utility](https://pytorch.org/docs/stable/distributed.html#launch-utility) 来进行分布式训练。
+
+如果您启动的多台机器简单地通过以太网连接，您可以直接运行下方命令：
+
+在第一个机器上:
+
+```shell
+NNODES=2 NODE_RANK=0 PORT=${主节点端口} MASTER_ADDR=${主节点地址} sh tools/dist_train.sh ${配置文件} ${GPUS}
+```
+
+在第二个机器上:
+
+```shell
+NNODES=2 NODE_RANK=1 PORT=${主节点端口} MASTER_ADDR=${主节点地址} sh tools/dist_train.sh ${配置文件} ${GPUS}
+```
+
+通常，如果您没有使用像无限带宽一类的高速网络，这个会过程比较慢。
+
+## 通过 Slurm 管理任务
+
+[Slurm](https://slurm.schedmd.com/) 是一个很好的计算集群作业调度系统。
+
+### 通过 Slurm 在集群上训练
+
+在一个由Slurm管理的集群上，您可以使用`slurm_train.sh`来启动训练任务。它同时支持单节点和多节点的训练。
+
+基础用法如下：
+
+```shell
+[GPUS=${GPUS}] sh tools/slurm_train.sh ${分区} ${任务名} ${配置文件} [可选参数]
+```
+
+下方是一个通过名为 `dev` 的 Slurm 分区，调用4个 GPU 来训练 PSPNet，并设置工作路径为共享文件系统。
+
+```shell
+GPUS=4 sh tools/slurm_train.sh dev pspnet configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py --work-dir work_dir/pspnet
+```
+
+您可以检查 [源码](../../../tools/slurm_train.sh) 来查看全部的参数和环境变量。
+
+### 通过 Slurm 在集群上测试
+
+与训练任务相同， MMSegmentation 提供 `slurm_test.sh` 文件来启动测试任务。
+
+基础用法如下：
+
+```shell
+[GPUS=${GPUS}] sh tools/slurm_test.sh ${分区} ${任务名} ${配置文件} ${检查点文件} [可选参数]
+```
+
+您可以通过 [源码](../../../tools/slurm_test.sh) 来查看全部的参数和环境变量。
+
+**注意：** 使用 Slurm 时，需要设置端口，可从以下方式中选取一种。
+
+1. 我们更推荐的通过`--cfg-options`设置端口，因为这不会改变原始配置：
+
+   ```shell
+   GPUS=4 GPUS_PER_NODE=4 sh tools/slurm_train.sh ${分区} ${任务名} config1.py ${工作路径} --cfg-options env_cfg.dist_cfg.port=29500
+   GPUS=4 GPUS_PER_NODE=4 sh tools/slurm_train.sh ${任务名} ${工作路径} config2.py ${工作路径} --cfg-options env_cfg.dist_cfg.port=29501
+   ```
+
+2. 通过修改配置文件设置不同的通讯端口：
+
+   在 `config1.py`中:
+
+   ```python
+   enf_cfg = dict(dist_cfg=dict(backend='nccl', port=29500))
+   ```
+
+   在 `config2.py`中：
+
+   ```python
+   enf_cfg = dict(dist_cfg=dict(backend='nccl', port=29501))
+   ```
+
+   然后您可以通过 config1.py 和 config2.py 同时启动两个任务：
+
+   ```shell
+   CUDA_VISIBLE_DEVICES=0,1,2,3 GPUS=4 sh tools/slurm_train.sh ${分区} ${任务名} config1.py ${工作路径}
+   CUDA_VISIBLE_DEVICES=4,5,6,7 GPUS=4 sh tools/slurm_train.sh ${分区} ${任务名} config2.py ${工作路径}
+   ```
+
+3. 在命令行中通过环境变量 `MASTER_PORT` 设置端口 ：
+
+```shell
+CUDA_VISIBLE_DEVICES=0,1,2,3 GPUS=4 MASTER_PORT=29500 sh tools/slurm_train.sh ${分区} ${任务名} config1.py ${工作路径}
+CUDA_VISIBLE_DEVICES=4,5,6,7 GPUS=4 MASTER_PORT=29501 sh tools/slurm_train.sh ${分区} ${任务名} config2.py ${工作路径}
+```
+
+## 测试并保存分割结果
+
+### 基础使用
+
+当需要保存测试输出的分割结果，用 `--out` 指定分割结果输出路径
+
+```shell
+python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} --out ${OUTPUT_DIR}
+```
+
+以保存模型 `fcn_r50-d8_4xb4-80k_ade20k-512x512` 在 ADE20K 验证数据集上的结果为例：
+
+```shell
+python tools/test.py configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py ckpt/fcn_r50-d8_512x512_80k_ade20k_20200614_144016-f8ac5082.pth --out work_dirs/format_results
+```
+
+或者通过配置文件定义 `output_dir`。例如在 `configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py` 添加 `test_evaluator` 定义：
+
+```python
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'], output_dir='work_dirs/format_results')
+```
+
+然后执行相同功能的命令不需要再使用 `--out`：
+
+```shell
+python tools/test.py configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py ckpt/fcn_r50-d8_512x512_80k_ade20k_20200614_144016-f8ac5082.pth
+```
+
+当测试的数据集没有提供标注，评测时没有真值可以参与计算，因此需要设置 `format_only=True`，
+同时需要修改 `test_dataloader`，由于没有标注，我们需要在数据增强变换中删掉 `dict(type='LoadAnnotations')`，以下是一个配置示例：
+
+```python
+test_evaluator = dict(
+    type='IoUMetric',
+    iou_metrics=['mIoU'],
+    format_only=True,
+    output_dir='work_dirs/format_results')
+test_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type = 'ADE20KDataset'
+        data_root='data/ade/release_test',
+        data_prefix=dict(img_path='testing'),
+        # 测试数据变换中没有加载标注
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+            dict(type='PackSegInputs')
+        ]))
+```
+
+然后执行测试命令：
+
+```shell
+python tools/test.py configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py ckpt/fcn_r50-d8_512x512_80k_ade20k_20200614_144016-f8ac5082.pth
+```
+
+### 测试 Cityscapes 数据集并保存输出分割结果
+
+推荐使用 `CityscapesMetric` 来保存模型在 Cityscapes 数据集上的测试结果，以下是一个配置示例：
+
+```python
+test_evaluator = dict(
+    type='CityscapesMetric',
+    format_only=True,
+    keep_results=True,
+    output_dir='work_dirs/format_results')
+test_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='CityscapesDataset',
+        data_root='data/cityscapes/',
+        data_prefix=dict(img_path='leftImg8bit/test'),
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
+            dict(type='PackSegInputs')
+        ]))
+```
+
+然后执行相同的命令，例如：
+
+```shell
+python tools/test.py configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-512x1024.py ckpt/fcn_r18-d8_512x1024_80k_cityscapes_20201225_021327-6c50f8b4.pth
+```
diff --git a/mmsegmentation/docs/zh_cn/user_guides/5_deployment.md b/mmsegmentation/docs/zh_cn/user_guides/5_deployment.md
new file mode 100644
index 0000000..b2bec02
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/user_guides/5_deployment.md
@@ -0,0 +1,243 @@
+# 教程5：模型部署
+
+# MMSegmentation 模型部署
+
+- [教程5：模型部署](#教程5模型部署)
+- [MMSegmentation 模型部署](#mmsegmentation-模型部署)
+  - [安装](#安装)
+    - [安装 mmseg](#安装-mmseg)
+    - [安装 mmdeploy](#安装-mmdeploy)
+  - [模型转换](#模型转换)
+  - [模型规范](#模型规范)
+  - [模型推理](#模型推理)
+    - [后端模型推理](#后端模型推理)
+    - [SDK 模型推理](#sdk-模型推理)
+  - [模型支持列表](#模型支持列表)
+  - [注意事项](#注意事项)
+
+______________________________________________________________________
+
+[MMSegmentation](https://github.com/open-mmlab/mmsegmentation/tree/main) 又称`mmseg`，是一个基于 PyTorch 的开源对象分割工具箱。它是 [OpenMMLab](https://openmmlab.com/) 项目的一部分。
+
+## 安装
+
+### 安装 mmseg
+
+请参考[官网安装指南](https://mmsegmentation.readthedocs.io/en/latest/get_started.html)。
+
+### 安装 mmdeploy
+
+mmdeploy 有以下几种安装方式:
+
+**方式一：** 安装预编译包
+
+请参考[安装概述](https://mmdeploy.readthedocs.io/zh_CN/latest/get_started.html#mmdeploy)
+
+**方式二：** 一键式脚本安装
+
+如果部署平台是 **Ubuntu 18.04 及以上版本**， 请参考[脚本安装说明](../01-how-to-build/build_from_script.md)，完成安装过程。
+比如，以下命令可以安装 mmdeploy 以及配套的推理引擎——`ONNX Runtime`.
+
+```shell
+git clone --recursive -b main https://github.com/open-mmlab/mmdeploy.git
+cd mmdeploy
+python3 tools/scripts/build_ubuntu_x64_ort.py $(nproc)
+export PYTHONPATH=$(pwd)/build/lib:$PYTHONPATH
+export LD_LIBRARY_PATH=$(pwd)/../mmdeploy-dep/onnxruntime-linux-x64-1.8.1/lib/:$LD_LIBRARY_PATH
+```
+
+**说明**:
+
+- 把 `$(pwd)/build/lib` 添加到 `PYTHONPATH`，目的是为了加载 mmdeploy SDK python 包 `mmdeploy_runtime`，在章节 [SDK模型推理](#sdk模型推理)中讲述其用法。
+- 在[使用 ONNX Runtime推理后端模型](#后端模型推理)时，需要加载自定义算子库，需要把 ONNX Runtime 库的路径加入环境变量 `LD_LIBRARY_PATH`中。
+
+**方式三：** 源码安装
+
+在方式一、二都满足不了的情况下，请参考[源码安装说明](../01-how-to-build/build_from_source.md) 安装 mmdeploy 以及所需推理引擎。
+
+## 模型转换
+
+你可以使用 [tools/deploy.py](https://github.com/open-mmlab/mmdeploy/tree/main/tools/deploy.py) 把 mmseg 模型一键式转换为推理后端模型。
+该工具的详细使用说明请参考[这里](https://github.com/open-mmlab/mmdeploy/tree/main/docs/en/02-how-to-run/convert_model.md#usage).
+
+以下，我们将演示如何把 `unet` 转换为 onnx 模型。
+
+```shell
+cd mmdeploy
+
+# download unet model from mmseg model zoo
+mim download mmsegmentation --config unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024 --dest .
+
+# convert mmseg model to onnxruntime model with dynamic shape
+python tools/deploy.py \
+    configs/mmseg/segmentation_onnxruntime_dynamic.py \
+    unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py \
+    fcn_unet_s5-d16_4x4_512x1024_160k_cityscapes_20211210_145204-6860854e.pth \
+    demo/resources/cityscapes.png \
+    --work-dir mmdeploy_models/mmseg/ort \
+    --device cpu \
+    --show \
+    --dump-info
+```
+
+转换的关键之一是使用正确的配置文件。项目中已内置了各后端部署[配置文件](https://github.com/open-mmlab/mmdeploy/tree/main/configs/mmseg)。
+文件的命名模式是：
+
+```
+segmentation_{backend}-{precision}_{static | dynamic}_{shape}.py
+```
+
+其中：
+
+- **{backend}:** 推理后端名称。比如，onnxruntime、tensorrt、pplnn、ncnn、openvino、coreml 等等
+- **{precision}:** 推理精度。比如，fp16、int8。不填表示 fp32
+- **{static | dynamic}:** 动态、静态 shape
+- **{shape}:** 模型输入的 shape 或者 shape 范围
+
+在上例中，你也可以把 `unet` 转为其他后端模型。比如使用`segmentation_tensorrt-fp16_dynamic-512x1024-2048x2048.py`，把模型转为 tensorrt-fp16 模型。
+
+```{tip}
+当转 tensorrt 模型时, --device 需要被设置为 "cuda"
+```
+
+## 模型规范
+
+在使用转换后的模型进行推理之前，有必要了解转换结果的结构。 它存放在 `--work-dir` 指定的路路径下。
+
+上例中的`mmdeploy_models/mmseg/ort`，结构如下：
+
+```
+mmdeploy_models/mmseg/ort
+├── deploy.json
+├── detail.json
+├── end2end.onnx
+└── pipeline.json
+```
+
+重要的是：
+
+- **end2end.onnx**: 推理引擎文件。可用 ONNX Runtime 推理
+- \***.json**:  mmdeploy SDK 推理所需的 meta 信息
+
+整个文件夹被定义为**mmdeploy SDK model**。换言之，**mmdeploy SDK model**既包括推理引擎，也包括推理 meta 信息。
+
+## 模型推理
+
+### 后端模型推理
+
+以上述模型转换后的 `end2end.onnx` 为例，你可以使用如下代码进行推理：
+
+```python
+from mmdeploy.apis.utils import build_task_processor
+from mmdeploy.utils import get_input_shape, load_config
+import torch
+
+deploy_cfg = 'configs/mmseg/segmentation_onnxruntime_dynamic.py'
+model_cfg = './unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py'
+device = 'cpu'
+backend_model = ['./mmdeploy_models/mmseg/ort/end2end.onnx']
+image = './demo/resources/cityscapes.png'
+
+# read deploy_cfg and model_cfg
+deploy_cfg, model_cfg = load_config(deploy_cfg, model_cfg)
+
+# build task and backend model
+task_processor = build_task_processor(model_cfg, deploy_cfg, device)
+model = task_processor.build_backend_model(backend_model)
+
+# process input image
+input_shape = get_input_shape(deploy_cfg)
+model_inputs, _ = task_processor.create_input(image, input_shape)
+
+# do model inference
+with torch.no_grad():
+    result = model.test_step(model_inputs)
+
+# visualize results
+task_processor.visualize(
+    image=image,
+    model=model,
+    result=result[0],
+    window_name='visualize',
+    output_file='./output_segmentation.png')
+```
+
+### SDK 模型推理
+
+你也可以参考如下代码，对 SDK model 进行推理：
+
+```python
+from mmdeploy_runtime import Segmentor
+import cv2
+import numpy as np
+
+img = cv2.imread('./demo/resources/cityscapes.png')
+
+# create a classifier
+segmentor = Segmentor(model_path='./mmdeploy_models/mmseg/ort', device_name='cpu', device_id=0)
+# perform inference
+seg = segmentor(img)
+
+# visualize inference result
+## random a palette with size 256x3
+palette = np.random.randint(0, 256, size=(256, 3))
+color_seg = np.zeros((seg.shape[0], seg.shape[1], 3), dtype=np.uint8)
+for label, color in enumerate(palette):
+    color_seg[seg == label, :] = color
+# convert to BGR
+color_seg = color_seg[..., ::-1]
+img = img * 0.5 + color_seg * 0.5
+img = img.astype(np.uint8)
+cv2.imwrite('output_segmentation.png', img)
+```
+
+除了python API，mmdeploy SDK 还提供了诸如 C、C++、C#、Java等多语言接口。
+你可以参考[样例](https://github.com/open-mmlab/mmdeploy/tree/main/demo)学习其他语言接口的使用方法。
+
+## 模型支持列表
+
+| Model                                                                                                     | TorchScript | OnnxRuntime | TensorRT | ncnn | PPLNN | OpenVino |
+| :-------------------------------------------------------------------------------------------------------- | :---------: | :---------: | :------: | :--: | :---: | :------: |
+| [FCN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/fcn)                                 |      Y      |      Y      |    Y     |  Y   |   Y   |    Y     |
+| [PSPNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/pspnet)[\*](#static_shape)        |      Y      |      Y      |    Y     |  Y   |   Y   |    Y     |
+| [DeepLabV3](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/deeplabv3)                     |      Y      |      Y      |    Y     |  Y   |   Y   |    Y     |
+| [DeepLabV3+](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/deeplabv3plus)                |      Y      |      Y      |    Y     |  Y   |   Y   |    Y     |
+| [Fast-SCNN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/fastscnn)[\*](#static_shape)   |      Y      |      Y      |    Y     |  N   |   Y   |    Y     |
+| [UNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/unet)                               |      Y      |      Y      |    Y     |  Y   |   Y   |    Y     |
+| [ANN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/ann)[\*](#static_shape)              |      Y      |      Y      |    Y     |  N   |   N   |    N     |
+| [APCNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/apcnet)                           |      Y      |      Y      |    Y     |  Y   |   N   |    N     |
+| [BiSeNetV1](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/bisenetv1)                     |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
+| [BiSeNetV2](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/bisenetv2)                     |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
+| [CGNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/cgnet)                             |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
+| [DMNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/dmnet)                             |      ?      |      Y      |    N     |  N   |   N   |    N     |
+| [DNLNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/dnlnet)                           |      ?      |      Y      |    Y     |  Y   |   N   |    Y     |
+| [EMANet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/emanet)                           |      Y      |      Y      |    Y     |  N   |   N   |    Y     |
+| [EncNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/encnet)                           |      Y      |      Y      |    Y     |  N   |   N   |    Y     |
+| [ERFNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/erfnet)                           |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
+| [FastFCN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/fastfcn)                         |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
+| [GCNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/gcnet)                             |      Y      |      Y      |    Y     |  N   |   N   |    N     |
+| [ICNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/icnet)[\*](#static_shape)          |      Y      |      Y      |    Y     |  N   |   N   |    Y     |
+| [ISANet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/isanet)[\*](#static_shape)        |      N      |      Y      |    Y     |  N   |   N   |    Y     |
+| [NonLocal Net](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/nonlocal_net)               |      ?      |      Y      |    Y     |  Y   |   N   |    Y     |
+| [OCRNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/ocrnet)                           |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
+| [PointRend](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/point_rend)[\*](#static_shape) |      Y      |      Y      |    Y     |  N   |   N   |    N     |
+| [Semantic FPN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/sem_fpn)                    |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
+| [STDC](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/stdc)                               |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
+| [UPerNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/upernet)[\*](#static_shape)      |      N      |      Y      |    Y     |  N   |   N   |    N     |
+| [DANet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/danet)                             |      ?      |      Y      |    Y     |  N   |   N   |    Y     |
+| [Segmenter](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/segmenter)[\*](#static_shape)  |      N      |      Y      |    Y     |  Y   |   N   |    Y     |
+| [SegFormer](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/segformer)[\*](#static_shape)  |      ?      |      Y      |    Y     |  N   |   N   |    Y     |
+| [SETR](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/setr)                               |      ?      |      Y      |    N     |  N   |   N   |    Y     |
+| [CCNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/ccnet)                             |      ?      |      N      |    N     |  N   |   N   |    N     |
+| [PSANet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/psanet)                           |      ?      |      N      |    N     |  N   |   N   |    N     |
+| [DPT](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/dpt)                                 |      ?      |      N      |    N     |  N   |   N   |    N     |
+
+## 注意事项
+
+- 所有 mmseg 模型仅支持 "whole" 推理模式。
+
+- <i id=“static_shape”>PSPNet，Fast-SCNN</i> 仅支持静态输入，因为多数推理框架的 [nn.AdaptiveAvgPool2d](https://github.com/open-mmlab/mmsegmentation/blob/0c87f7a0c9099844eff8e90fa3db5b0d0ca02fee/mmseg/models/decode_heads/psp_head.py#L38) 不支持动态输入。
+
+- 对于仅支持静态形状的模型，应使用静态形状的部署配置文件，例如 `configs/mmseg/segmentation_tensorrt_static-1024x2048.py`
+
+- 对于喜欢部署模型生成概率特征图的用户，将 `codebase_config = dict(with_argmax=False)` 放在部署配置中就足够了。
diff --git a/mmsegmentation/docs/zh_cn/user_guides/deploy_jetson.md b/mmsegmentation/docs/zh_cn/user_guides/deploy_jetson.md
new file mode 100644
index 0000000..6cebd9c
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/user_guides/deploy_jetson.md
@@ -0,0 +1,372 @@
+# 将 MMSeg 模型调优及部署到 NVIDIA Jetson 平台教程
+
+- 请先查阅[MMSegmentation 模型部署](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/5_deployment.md)文档。
+- **本教程所用 mmsegmentation 版本： v1.1.2**
+- **本教程所用 NVIDIA Jetson 设备： NVIDIA Jetson AGX Orin 64G**
+
+<div align="center">
+    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/b5466cfd-71a9-4e06-9823-c253a97d57b5" alt="Smiley face" width="50%">
+</div>
+
+## 1 配置 [mmsegmentation](https://github.com/open-mmlab/mmsegmentation)
+
+- 根据[安装和验证](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/get_started.md)文档，完成开发 [mmsegmentation](https://github.com/open-mmlab/mmsegmentation) 所需的 [`pytorch`](https://pytorch.org/get-started/locally/)、[`mmcv`](https://github.com/open-mmlab/mmcv)、[`mmengine`](https://github.com/open-mmlab/mmengine) 等环境依赖安装。
+- 从 GitHub 使用 git clone 命令完成 [mmsegmentation](https://github.com/open-mmlab/mmsegmentation) 下载。网络不好的同学，可通过 [MMSeg GitHub](https://github.com/open-mmlab/mmsegmentation) 页面进行 zip 的下载。
+  ```bash
+  git clone https://github.com/open-mmlab/mmsegmentation.git
+  ```
+- 使用 `pip install -v -e.` 命令动态安装 mmsegmentation 。
+  ```bash
+  cd mmsegmentation
+  pip install -v -e .
+  ```
+  提示成功安装后，可通过 `pip list` 命令查看到 mmsegmentation 已通过本地安装方式安装到了您的环境中。
+  ![mmseg-install](https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/a9c7bcc9-cdcc-40a4-bd7b-8153195549c8)
+
+## 2 准备您的数据集
+
+- 本教程使用遥感图像语义分割数据集 [potsdam](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#isprs-potsdam) 作为示例。
+- 根据 [potsdam 数据准备](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#isprs-potsdam)文档，进行数据集下载及 MMSeg 格式的准备。
+- 数据集介绍： potsdam 数据集是以德国一个典型的历史城市 Potsdam 命名的，该城市有着大建筑群、狭窄的街道和密集的建筑结构。 potsdam 数据集包含 38 幅 6000x6000 像素的图像，空间分辨率为 5cm，数据集的示例如下图：
+  ![potsdam-img](https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/3bc0a75b-1693-4ae6-aeea-ad502e955068)
+
+## 3 从 config 页面下载模型的 pth 权重文件
+
+这里以 [`deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py`](../../configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py) 配置文件举例，在 [configs](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/deeplabv3plus#potsdam) 页面下载权重文件，
+![pth](https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/8f747362-caf4-406c-808d-4ca72babb209)
+
+## 4 通过 [OpenMMLab deployee](https://platform.openmmlab.com/deploee) 以交互式方式进行模型转换及测速
+
+### 4.1 模型转换
+
+在该部分中，[OpenMMLab 官网](https://platform.openmmlab.com/deploee)提供了模型转换及模型测速的交互界面，无需任何代码，即可通过选择对应选项完成模型 ONNX 格式`xxxx.onnx` 和 TensorRT `.engine`格式的转换。
+如您的自定义 config 文件中有相对引用关系，如：
+
+```python
+# xxxx.py
+_base_ = [
+    '../_base_/models/deeplabv3plus_r50-d8.py',
+    '../_base_/datasets/potsdam.py',
+    '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+```
+
+您可以使用以下代码消除相对引用关系，以生成完整的 config 文件。
+
+```python
+import mmengine
+
+mmengine.Config.fromfile("configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py").dump("My_config.py")
+```
+
+使用上述代码后，您能够看到，在`My_config.py`包含着完整的配置文件，无相对引用。这时，上传模型 config 至网页内对应处。
+
+#### 创建转换任务
+
+按照下图提示及自己的需求，创建转换任务并提交。
+
+<div align="center">
+    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/4918d2f9-d63c-480f-97f1-054529770cfd" alt="NVIDIA-Jetson" width="80%">
+</div>
+
+### 4.2 模型测速
+
+在完成模型转换后可通过**模型测速**界面，完成在真实设备上的模型测速。
+
+#### 创建测速任务
+
+<div align="center">
+    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/27340556-c81a-4ce3-8560-2c4727d3355e" alt="NVIDIA-Jetson" width="100%">
+</div>
+
+<div align="center">
+    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/6f4fc3a9-ba9d-4829-8407-ed1470ba7bf3" alt="NVIDIA-Jetson" width="100%">
+</div>
+
+测速完成后，可在页面生成完整的测速报告。[查看测速报告示例](https://openmmlab-deploee.oss-cn-shanghai.aliyuncs.com/tmp/profile_speed/4352f5.txt)
+
+## 5 通过 OpenMMLab mmdeploy 以命令行将模型转换为ONNX格式
+
+该部分可以通过 mmdeploy 库对 mmseg 训练好的模型进行推理格式的转换。这里给出一个示例，具体文档可见[ mmdeploy 模型转换文档](../../docs/zh_cn/user_guides/5_deployment.md)。
+
+### 5.1 通过源码构建 mmdeploy 库
+
+在您安装 mmsegmentation 库的虚拟环境下，通过 `git clone`命令从 GitHub 克隆 [mmdeploy](https://github.com/open-mmlab/mmdeploy)
+
+### 5.2 模型转换
+
+如您的 config 中含有相对引用，仍需进行消除，如[4.1 模型转换](#4.1-模型转换)所述,
+进入 mmdeploy 文件夹，执行以下命令，即可完成模型转换。
+
+```bash
+python tools/deploy.py \
+    configs/mmseg/segmentation_onnxruntime_static-512x512.py \
+    ../atl_config.py \
+    ../deeplabv3plus_r18-d8_512x512_80k_potsdam_20211219_020601-75fd5bc3.pth \
+    ../2_13_1024_5488_1536_6000.png \
+    --work-dir ../atl_models \
+    --device cpu \
+    --show \
+    --dump-info
+```
+
+```bash
+# 使用方法
+python ./tools/deploy.py \
+    ${部署配置文件路径} \
+    ${模型配置文件路径} \
+    ${模型权重路径} \
+    ${输入图像路径} \
+    --work-dir ${用来保存日志和模型文件路径} \
+    --device ${cpu/cuda:0} \
+    --show \    # 是否显示检测的结果
+    --dump-info # 是否输出 SDK 信息
+
+```
+
+执行成功后，您将能够看到以下提示，即为转换成功。
+
+```bash
+10/08 17:40:44 - mmengine - INFO - visualize pytorch model success.
+10/08 17:40:44 - mmengine - INFO - All process success.
+```
+
+<div align="center">
+    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/b752ccf8-903f-4ad3-ad7c-74fc25cb89a5" alt="NVIDIA-Jetson" width="400">
+</div>
+
+# 6 在 Jetson 平台进行转换及部署
+
+## 6.1 环境准备
+
+参考[如何在 Jetson 模组上安装 MMDeploy](https://github.com/open-mmlab/mmdeploy/blob/main/docs/zh_cn/01-how-to-build/jetsons.md)文档，完成在 Jetson 上的环境准备工作。
+**注**：安装 Pytorch，可查阅 [NVIDIA Jetson Pytorch 安装文档](https://github.com/open-mmlab/mmdeploy/blob/main/docs/zh_cn/01-how-to-build/jetsons.md)安装最新的 Pytorch。
+
+### 6.1.1 创建虚拟环境
+
+```bash
+conda create -n {您虚拟环境的名字} python={python版本}
+```
+
+### 6.1.2 虚拟环境内安装Pytorch
+
+<font color="red">注意：</font>这里不要安装最新的 pytorch 2.0，因为 pyTorch 1.11 是最后一个使用 USE_DISTRIBUTED 构建的wheel，否则会在用mmdeploy进行模型转换的时候提示`AttributeError: module 'torch.distributed' has no attribute 'ReduceOp'`的错误。参考以下链接：https://forums.developer.nvidia.com/t/module-torch-distributed-has-no-attribute-reduceop/256581/6
+下载`torch-1.11.0-cp38-cp38-linux_aarch64.whl`并安装
+
+```bash
+pip install torch-1.11.0-cp38-cp38-linux_aarch64.whl
+```
+
+执行以上命令后，您将能看到以下提示，即为安装成功。
+
+```bash
+Processing ./torch-1.11.0-cp38-cp38-linux_aarch64.whl
+Requirement already satisfied: typing-extensions in /home/sirs/miniconda3/envs/openmmlab/lib/python3.8/site-packages (from torch==1.11.0) (4.7.1)
+Installing collected packages: torch
+Successfully installed torch-1.11.0
+```
+
+### 6.1.3 将 Jetson Pack 自带的 tensorrt 拷贝至虚拟环境下
+
+请参考[配置 TensorRT](https://github.com/open-mmlab/mmdeploy/blob/main/docs/zh_cn/01-how-to-build/jetsons.md#%E9%85%8D%E7%BD%AE-tensorrt)。
+JetPack SDK 自带 TensorRT。 但是为了能够在 Conda 环境中成功导入，我们需要将 TensorRT 拷贝进先前创建的 Conda 环境中。
+
+```bash
+export PYTHON_VERSION=`python3 --version | cut -d' ' -f 2 | cut -d'.' -f1,2`
+cp -r /usr/lib/python${PYTHON_VERSION}/dist-packages/tensorrt* ~/miniconda/envs/{您的虚拟环境名字}/lib/python${PYTHON_VERSION}/site-packages/
+```
+
+### 6.1.4 安装 MMCV
+
+通过`mim install mmcv`或从源码对其进行编译。
+
+```bash
+pip install openmim
+mim install mmcv
+```
+
+或者从源码对其进行编译。
+
+```bash
+sudo apt-get install -y libssl-dev
+git clone https://github.com/open-mmlab/mmcv.git
+cd mmcv
+pip install -e .
+```
+
+<font color="red">注：pytorch版本发生变动后，需要重新编译mmcv。</font>
+
+### 6.1.5 安装 ONNX
+
+<font color="red">注：以下方式二选一</font>
+
+- conda
+  ```bash
+  conda install -c conda-forge onnx
+  ```
+- pip
+  ```bash
+  python3 -m pip install onnx
+  ```
+
+### 6.1.6 安装 ONNX Runtime
+
+根据网页 [ONNX Runtime](https://elinux.org/Jetson_Zoo#ONNX_Runtime) 选择合适的ONNX Runtime版本进行下载安装。
+示例：
+
+```bash
+# Install pip wheel
+$ pip3 install onnxruntime_gpu-1.10.0-cp38-cp38-linux_aarch64.whl
+
+```
+
+## 6.2 在 Jetson AGX Orin 进行模型转换及推理
+
+### 6.2.1 ONNX 模型转换
+
+同[4.1 模型转换](#4.1-模型转换)相同，在 Jetson 平台下进入安装好的虚拟环境，以及mmdeploy 目录，进行模型ONNX转换。
+
+```bash
+python tools/deploy.py \
+    configs/mmseg/segmentation_onnxruntime_static-512x512.py \
+    ../atl_config.py \
+    ../deeplabv3plus_r18-d8_512x512_80k_potsdam_20211219_020601-75fd5bc3.pth \
+    ../2_13_3584_2560_4096_3072.png \
+    --work-dir ../atl_models \
+    --device cpu \
+    --show \
+    --dump-info
+
+```
+
+<font color="red">注：</font> 如果报错提示内容：
+
+```none
+AttributeError: module 'torch.distributed' has no attribute 'ReduceOp'
+```
+
+可参考以下链接进行解决：https://forums.developer.nvidia.com/t/module-torch-distributed-has-no-attribute-reduceop/256581/6，即安装 pytorch 1.11.0 版本。
+
+转换成功后，您将会看到如下信息以及包含 ONNX 模型的文件夹：
+
+```bash
+10/09 19:58:22 - mmengine - INFO - visualize pytorch model success.
+10/09 19:58:22 - mmengine - INFO - All process success.
+```
+
+<div align="center">
+    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/d68f1cf6-0e80-4261-91a3-6046b17de146" alt="NVIDIA-Jetson" width="400">
+    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/70470a39-6a4f-4fd5-a06d-9b9d59a768ef" alt="NVIDIA-Jetson" width="160">
+</div>
+
+### 6.2.2 TensorRT 模型转换
+
+更换部署trt配置文件，进行 TensorRT 模型转换。
+
+```bash
+python tools/deploy.py \
+    configs/mmseg/segmentation_tensorrt_static-512x512.py \
+    ../atl_config.py \
+    ../deeplabv3plus_r18-d8_512x512_80k_potsdam_20211219_020601-75fd5bc3.pth \
+    ../2_13_3584_2560_4096_3072.png \
+    --work-dir ../atl_trt_models \
+    --device cuda:0 \
+    --show \
+    --dump-info
+
+```
+
+转换成功后您将看到以下信息及 TensorRT 模型文件夹：
+
+```bash
+10/09 20:15:50 - mmengine - INFO - visualize pytorch model success.
+10/09 20:15:50 - mmengine - INFO - All process success.
+```
+
+<div align="center">
+    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/2ac1428f-b787-4fdd-beaf-6397e5b21e33" alt="NVIDIA-Jetson" width="340">
+    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/70470a39-6a4f-4fd5-a06d-9b9d59a768ef" alt="NVIDIA-Jetson" width="200">
+</div>
+
+## 6.3 模型测速
+
+执行以下命令完成模型测速，详细内容请查看[ profiler ](https://github.com/open-mmlab/mmdeploy/blob/main/docs/zh_cn/02-how-to-run/useful_tools.md#profiler)
+
+```bash
+python tools/profiler.py \
+    ${DEPLOY_CFG} \
+    ${MODEL_CFG} \
+    ${IMAGE_DIR} \
+    --model ${MODEL} \
+    --device ${DEVICE} \
+    --shape ${SHAPE} \
+    --num-iter ${NUM_ITER} \
+    --warmup ${WARMUP} \
+    --cfg-options ${CFG_OPTIONS} \
+    --batch-size ${BATCH_SIZE} \
+    --img-ext ${IMG_EXT}
+```
+
+示例：
+
+```bash
+python tools/profiler.py \
+    configs/mmseg/segmentation_tensorrt_static-512x512.py \
+    ../atl_config.py \
+    ../atl_demo_img \
+    --model /home/sirs/AI-Tianlong/OpenMMLab/atl_trt_models/end2end.engine \
+    --device cuda:0 \
+    --shape 512x512 \
+    --num-iter 100
+```
+
+测速结果
+
+![image](https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/874e9742-ee10-490c-9e69-17da0096c49b)
+
+## 6.4 模型推理
+
+根据[6.2.2](#6.2.2-TensorRT-模型转换)中生成的TensorRT模型文件夹，进行模型推理。
+
+```python
+from mmdeploy.apis.utils import build_task_processor
+from mmdeploy.utils import get_input_shape, load_config
+import torch
+
+deploy_cfg='./mmdeploy/configs/mmseg/segmentation_tensorrt_static-512x512.py'
+model_cfg='./atl_config.py'
+device='cuda:0'
+backend_model = ['./atl_trt_models/end2end.engine']
+image = './atl_demo_img/2_13_2048_1024_2560_1536.png'
+
+# read deploy_cfg and model_cfg
+deploy_cfg, model_cfg = load_config(deploy_cfg, model_cfg)
+
+# build task and backend model
+task_processor = build_task_processor(model_cfg, deploy_cfg, device)
+model = task_processor.build_backend_model(backend_model)
+
+# process input image
+input_shape = get_input_shape(deploy_cfg)
+model_inputs, _ = task_processor.create_input(image, input_shape)
+
+# do model inference
+with torch.no_grad():
+    result = model.test_step(model_inputs)
+
+# visualize results
+task_processor.visualize(
+    image=image,
+    model=model,
+    result=result[0],
+    window_name='visualize',
+    output_file='./output_segmentation.png')
+```
+
+即可得到推理结果：
+
+<div align="center">
+    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/d0ae1fa8-e223-4b3f-b699-6bfa8db38133" alt="NVIDIA-Jetson" width="40%">
+    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/6d999cbe-2101-4e1b-b4a9-13115c9d1928" alt="NVIDIA-Jetson" width="40%">
+</div>
diff --git a/mmsegmentation/docs/zh_cn/user_guides/index.rst b/mmsegmentation/docs/zh_cn/user_guides/index.rst
new file mode 100644
index 0000000..d0a313d
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/user_guides/index.rst
@@ -0,0 +1,21 @@
+训练 & 测试
+**************
+
+.. toctree::
+   :maxdepth: 1
+
+   1_config.md
+   2_dataset_prepare.md
+   3_inference.md
+   4_train_test.md
+
+实用工具
+*************
+
+.. toctree::
+   :maxdepth: 2
+
+   visualization.md
+   useful_tools.md
+   deployment.md
+   visualization_feature_map.md
diff --git a/mmsegmentation/docs/zh_cn/user_guides/useful_tools.md b/mmsegmentation/docs/zh_cn/user_guides/useful_tools.md
new file mode 100644
index 0000000..acbacb9
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/user_guides/useful_tools.md
@@ -0,0 +1,368 @@
+## 常用工具（待更新）
+
+除了训练和测试的脚本，我们在 `tools/` 文件夹路径下还提供许多有用的工具。
+
+### 计算参数量（params）和计算量（ FLOPs） (试验性)
+
+我们基于 [flops-counter.pytorch](https://github.com/sovrasov/flops-counter.pytorch)
+提供了一个用于计算给定模型参数量和计算量的脚本。
+
+```shell
+python tools/get_flops.py ${CONFIG_FILE} [--shape ${INPUT_SHAPE}]
+```
+
+您将得到如下的结果：
+
+```none
+==============================
+Input shape: (3, 2048, 1024)
+Flops: 1429.68 GMac
+Params: 48.98 M
+==============================
+```
+
+**注意**: 这个工具仍然是试验性的，我们无法保证数字是正确的。您可以拿这些结果做简单的实验的对照，在写技术文档报告或者论文前您需要再次确认一下。
+
+(1) 计算量与输入的形状有关，而参数量与输入的形状无关，默认的输入形状是 (1, 3, 1280, 800)；
+(2) 一些运算操作，如 GN 和其他定制的运算操作没有加入到计算量的计算中。
+
+### 发布模型
+
+在您上传一个模型到云服务器之前，您需要做以下几步：
+(1) 将模型权重转成 CPU 张量；
+(2) 删除记录优化器状态 (optimizer states)的相关信息；
+(3) 计算检查点文件 (checkpoint file) 的哈希编码（hash id）并且将哈希编码加到文件名中。
+
+```shell
+python tools/publish_model.py ${INPUT_FILENAME} ${OUTPUT_FILENAME}
+```
+
+例如，
+
+```shell
+python tools/publish_model.py work_dirs/pspnet/latest.pth psp_r50_hszhao_200ep.pth
+```
+
+最终输出文件将是 `psp_r50_512x1024_40ki_cityscapes-{hash id}.pth`。
+
+### 导出 ONNX (试验性)
+
+我们提供了一个脚本来导出模型到 [ONNX](https://github.com/onnx/onnx) 格式。被转换的模型可以通过工具 [Netron](https://github.com/lutzroeder/netron)
+来可视化。除此以外，我们同样支持对 PyTorch 和 ONNX 模型的输出结果做对比。
+
+```bash
+python tools/pytorch2onnx.py \
+    ${CONFIG_FILE} \
+    --checkpoint ${CHECKPOINT_FILE} \
+    --output-file ${ONNX_FILE} \
+    --input-img ${INPUT_IMG} \
+    --shape ${INPUT_SHAPE} \
+    --rescale-shape ${RESCALE_SHAPE} \
+    --show \
+    --verify \
+    --dynamic-export \
+    --cfg-options \
+      model.test_cfg.mode="whole"
+```
+
+各个参数的描述:
+
+- `config` : 模型配置文件的路径
+- `--checkpoint` : 模型检查点文件的路径
+- `--output-file`: 输出的 ONNX 模型的路径。如果没有专门指定，它默认是 `tmp.onnx`
+- `--input-img` : 用来转换和可视化的一张输入图像的路径
+- `--shape`: 模型的输入张量的高和宽。如果没有专门指定，它将被设置成 `test_pipeline` 的 `img_scale`
+- `--rescale-shape`: 改变输出的形状。设置这个值来避免 OOM，它仅在 `slide` 模式下可以用
+- `--show`: 是否打印输出模型的结构。如果没有被专门指定，它将被设置成 `False`
+- `--verify`: 是否验证一个输出模型的正确性 (correctness)。如果没有被专门指定，它将被设置成 `False`
+- `--dynamic-export`: 是否导出形状变化的输入与输出的 ONNX 模型。如果没有被专门指定，它将被设置成 `False`
+- `--cfg-options`: 更新配置选项
+
+**注意**: 这个工具仍然是试验性的，目前一些自定义操作还没有被支持
+
+### 评估 ONNX 模型
+
+我们提供 `tools/deploy_test.py` 去评估不同后端的 ONNX 模型。
+
+#### 先决条件
+
+- 安装 onnx 和 onnxruntime-gpu
+
+  ```shell
+  pip install onnx onnxruntime-gpu
+  ```
+
+- 参考 [如何在 MMCV 里构建 tensorrt 插件](https://mmcv.readthedocs.io/en/latest/tensorrt_plugin.html#how-to-build-tensorrt-plugins-in-mmcv) 安装TensorRT (可选)
+
+#### 使用方法
+
+```bash
+python tools/deploy_test.py \
+    ${CONFIG_FILE} \
+    ${MODEL_FILE} \
+    ${BACKEND} \
+    --out ${OUTPUT_FILE} \
+    --eval ${EVALUATION_METRICS} \
+    --show \
+    --show-dir ${SHOW_DIRECTORY} \
+    --cfg-options ${CFG_OPTIONS} \
+    --eval-options ${EVALUATION_OPTIONS} \
+    --opacity ${OPACITY} \
+```
+
+各个参数的描述:
+
+- `config`: 模型配置文件的路径
+- `model`: 被转换的模型文件的路径
+- `backend`: 推理的后端，可选项：`onnxruntime`， `tensorrt`
+- `--out`: 输出结果成 pickle 格式文件的路径
+- `--format-only` : 不评估直接给输出结果的格式。通常用在当您想把结果输出成一些测试服务器需要的特定格式时。如果没有被专门指定，它将被设置成 `False`。 注意这个参数是用 `--eval` 来 **手动添加**
+- `--eval`: 评估指标，取决于每个数据集的要求，例如 "mIoU" 是大多数据集的指标而 "cityscapes" 仅针对 Cityscapes 数据集。注意这个参数是用 `--format-only` 来 **手动添加**
+- `--show`: 是否展示结果
+- `--show-dir`: 涂上结果的图像被保存的文件夹的路径
+- `--cfg-options`: 重写配置文件里的一些设置，`xxx=yyy` 格式的键值对将被覆盖到配置文件里
+- `--eval-options`: 自定义的评估的选项， `xxx=yyy` 格式的键值对将成为  `dataset.evaluate()` 函数的参数变量
+- `--opacity`: 涂上结果的分割图的透明度，范围在 (0, 1\] 之间
+
+#### 结果和模型
+
+|    模型    |                    配置文件                     |   数据集   | 评价指标 | PyTorch | ONNXRuntime | TensorRT-fp32 | TensorRT-fp16 |
+| :--------: | :---------------------------------------------: | :--------: | :------: | :-----: | :---------: | :-----------: | :-----------: |
+|    FCN     |      fcn_r50-d8_512x1024_40k_cityscapes.py      | cityscapes |   mIoU   |  72.2   |    72.2     |     72.2      |     72.2      |
+|   PSPNet   |    pspnet_r50-d8_512x1024_40k_cityscapes.py     | cityscapes |   mIoU   |  77.8   |    77.8     |     77.8      |     77.8      |
+| deeplabv3  |   deeplabv3_r50-d8_512x1024_40k_cityscapes.py   | cityscapes |   mIoU   |  79.0   |    79.0     |     79.0      |     79.0      |
+| deeplabv3+ | deeplabv3plus_r50-d8_512x1024_40k_cityscapes.py | cityscapes |   mIoU   |  79.6   |    79.5     |     79.5      |     79.5      |
+|   PSPNet   |     pspnet_r50-d8_769x769_40k_cityscapes.py     | cityscapes |   mIoU   |  78.2   |    78.1     |               |               |
+| deeplabv3  |   deeplabv3_r50-d8_769x769_40k_cityscapes.py    | cityscapes |   mIoU   |  78.5   |    78.3     |               |               |
+| deeplabv3+ | deeplabv3plus_r50-d8_769x769_40k_cityscapes.py  | cityscapes |   mIoU   |  78.9   |    78.7     |               |               |
+
+**注意**: TensorRT 仅在使用 `whole mode` 测试模式时的配置文件里可用。
+
+### 导出 TorchScript (试验性)
+
+我们同样提供一个脚本去把模型导出成 [TorchScript](https://pytorch.org/docs/stable/jit.html) 格式。您可以使用 pytorch C++ API [LibTorch](https://pytorch.org/docs/stable/cpp_index.html) 去推理训练好的模型。
+被转换的模型能被像 [Netron](https://github.com/lutzroeder/netron) 的工具来可视化。此外，我们还支持 PyTorch 和 TorchScript 模型的输出结果的比较。
+
+```shell
+python tools/pytorch2torchscript.py \
+    ${CONFIG_FILE} \
+    --checkpoint ${CHECKPOINT_FILE} \
+    --output-file ${ONNX_FILE}
+    --shape ${INPUT_SHAPE}
+    --verify \
+    --show
+```
+
+各个参数的描述:
+
+- `config` : pytorch 模型的配置文件的路径
+- `--checkpoint` : pytorch 模型的检查点文件的路径
+- `--output-file`: TorchScript 模型输出的路径，如果没有被专门指定，它将被设置成 `tmp.pt`
+- `--input-img` : 用来转换和可视化的输入图像的路径
+- `--shape`: 模型的输入张量的宽和高。如果没有被专门指定，它将被设置成 `512 512`
+- `--show`: 是否打印输出模型的追踪图 (traced graph)，如果没有被专门指定，它将被设置成 `False`
+- `--verify`: 是否验证一个输出模型的正确性 (correctness)，如果没有被专门指定，它将被设置成 `False`
+
+**注意**: 目前仅支持 PyTorch>=1.8.0 版本
+
+**注意**: 这个工具仍然是试验性的，一些自定义操作符目前还不被支持
+
+例子:
+
+- 导出 PSPNet 在 cityscapes 数据集上的 pytorch 模型
+
+  ```shell
+  python tools/pytorch2torchscript.py configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py \
+  --checkpoint checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth \
+  --output-file checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pt \
+  --shape 512 1024
+  ```
+
+### 导出 TensorRT (试验性)
+
+一个导出 [ONNX](https://github.com/onnx/onnx) 模型成 [TensorRT](https://developer.nvidia.com/tensorrt) 格式的脚本
+
+先决条件
+
+- 按照 [ONNXRuntime in mmcv](https://mmcv.readthedocs.io/en/latest/deployment/onnxruntime_op.html) 和 [TensorRT plugin in mmcv](https://github.com/open-mmlab/mmcv/blob/master/docs/en/deployment/tensorrt_plugin.md) ，用 ONNXRuntime 自定义运算 (custom ops) 和 TensorRT 插件安装 `mmcv-full`
+- 使用 [pytorch2onnx](#convert-to-onnx-experimental) 将模型从 PyTorch 转成 ONNX
+
+使用方法
+
+```bash
+python ${MMSEG_PATH}/tools/onnx2tensorrt.py \
+    ${CFG_PATH} \
+    ${ONNX_PATH} \
+    --trt-file ${OUTPUT_TRT_PATH} \
+    --min-shape ${MIN_SHAPE} \
+    --max-shape ${MAX_SHAPE} \
+    --input-img ${INPUT_IMG} \
+    --show \
+    --verify
+```
+
+各个参数的描述:
+
+- `config` : 模型的配置文件
+- `model` : 输入的 ONNX 模型的路径
+- `--trt-file` : 输出的 TensorRT 引擎的路径
+- `--max-shape` : 模型的输入的最大形状
+- `--min-shape` : 模型的输入的最小形状
+- `--fp16` : 做 fp16 模型转换
+- `--workspace-size` : 在 GiB 里的最大工作空间大小 (Max workspace size)
+- `--input-img` : 用来可视化的图像
+- `--show` : 做结果的可视化
+- `--dataset` : Palette provider, 默认为 `CityscapesDataset`
+- `--verify` : 验证 ONNXRuntime 和 TensorRT 的输出
+- `--verbose` : 当创建 TensorRT 引擎时，是否详细做信息日志。默认为 False
+
+**注意**: 仅在全图测试模式 (whole mode) 下测试过
+
+## 其他内容
+
+### 打印完整的配置文件
+
+`tools/print_config.py` 会逐字逐句的打印整个配置文件，展开所有的导入。
+
+```shell
+python tools/print_config.py \
+  ${CONFIG} \
+  --graph \
+  --cfg-options ${OPTIONS [OPTIONS...]} \
+```
+
+各个参数的描述:
+
+- `config` : pytorch 模型的配置文件的路径
+- `--graph` : 是否打印模型的图 (models graph)
+- `--cfg-options`: 自定义替换配置文件的选项
+
+### 对训练日志 (training logs) 画图
+
+`tools/analyze_logs.py` 会画出给定的训练日志文件的 loss/mIoU 曲线，首先需要 `pip install seaborn` 安装依赖包。
+
+```shell
+python tools/analyze_logs.py xxx.log.json [--keys ${KEYS}] [--legend ${LEGEND}] [--backend ${BACKEND}] [--style ${STYLE}] [--out ${OUT_FILE}]
+```
+
+示例:
+
+- 对 mIoU, mAcc, aAcc 指标画图
+
+  ```shell
+  python tools/analyze_logs.py log.json --keys mIoU mAcc aAcc --legend mIoU mAcc aAcc
+  ```
+
+- 对 loss 指标画图
+
+  ```shell
+  python tools/analyze_logs.py log.json --keys loss --legend loss
+  ```
+
+### 转换其他仓库的权重
+
+`tools/model_converters/` 提供了若干个预训练权重转换脚本，支持将其他仓库的预训练权重的 key 转换为与 MMSegmentation 相匹配的 key。
+
+#### ViT Swin MiT Transformer 模型
+
+- ViT
+
+`tools/model_converters/vit2mmseg.py` 将 timm 预训练模型转换到 MMSegmentation。
+
+```shell
+python tools/model_converters/vit2mmseg.py ${SRC} ${DST}
+```
+
+- Swin
+
+  `tools/model_converters/swin2mmseg.py` 将官方预训练模型转换到 MMSegmentation。
+
+  ```shell
+  python tools/model_converters/swin2mmseg.py ${SRC} ${DST}
+  ```
+
+- SegFormer
+
+  `tools/model_converters/mit2mmseg.py` 将官方预训练模型转换到 MMSegmentation。
+
+  ```shell
+  python tools/model_converters/mit2mmseg.py ${SRC} ${DST}
+  ```
+
+## 模型服务
+
+为了用 [`TorchServe`](https://pytorch.org/serve/) 服务 `MMSegmentation` 的模型 ， 您可以遵循如下流程:
+
+### 1. 将 model 从　MMSegmentation 转换到 TorchServe
+
+```shell
+python tools/mmseg2torchserve.py ${CONFIG_FILE} ${CHECKPOINT_FILE} \
+--output-folder ${MODEL_STORE} \
+--model-name ${MODEL_NAME}
+```
+
+**注意**: ${MODEL_STORE} 需要设置为某个文件夹的绝对路径
+
+### 2. 构建 `mmseg-serve` 容器镜像 (docker image)
+
+```shell
+docker build -t mmseg-serve:latest docker/serve/
+```
+
+### 3. 运行 `mmseg-serve`
+
+请查阅官方文档: [使用容器运行 TorchServe](https://github.com/pytorch/serve/blob/master/docker/README.md#running-torchserve-in-a-production-docker-environment)
+
+为了在 GPU 环境下使用, 您需要安装 [nvidia-docker](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html). 若在 CPU 环境下使用，您可以忽略添加 `--gpus` 参数。
+
+示例:
+
+```shell
+docker run --rm \
+--cpus 8 \
+--gpus device=0 \
+-p8080:8080 -p8081:8081 -p8082:8082 \
+--mount type=bind,source=$MODEL_STORE,target=/home/model-server/model-store \
+mmseg-serve:latest
+```
+
+阅读关于推理 (8080), 管理 (8081) 和指标 (8082) APIs 的 [文档](https://github.com/pytorch/serve/blob/072f5d088cce9bb64b2a18af065886c9b01b317b/docs/rest_api.md) 。
+
+### 4. 测试部署
+
+```shell
+curl -O https://raw.githubusercontent.com/open-mmlab/mmsegmentation/master/resources/3dogs.jpg
+curl http://127.0.0.1:8080/predictions/${MODEL_NAME} -T 3dogs.jpg -o 3dogs_mask.png
+```
+
+得到的响应将是一个 ".png" 的分割掩码.
+
+您可以按照如下方法可视化输出:
+
+```python
+import matplotlib.pyplot as plt
+import mmcv
+plt.imshow(mmcv.imread("3dogs_mask.png", "grayscale"))
+plt.show()
+```
+
+看到的东西将会和下图类似:
+
+![3dogs_mask](../../resources/3dogs_mask.png)
+
+然后您可以使用 `test_torchserve.py` 比较 torchserve 和 pytorch 的结果，并将它们可视化。
+
+```shell
+python tools/torchserve/test_torchserve.py ${IMAGE_FILE} ${CONFIG_FILE} ${CHECKPOINT_FILE} ${MODEL_NAME}
+[--inference-addr ${INFERENCE_ADDR}] [--result-image ${RESULT_IMAGE}] [--device ${DEVICE}]
+```
+
+示例：
+
+```shell
+python tools/torchserve/test_torchserve.py \
+demo/demo.png \
+configs/fcn/fcn_r50-d8_512x1024_40k_cityscapes.py \
+checkpoint/fcn_r50-d8_512x1024_40k_cityscapes_20200604_192608-efe53f0d.pth \
+fcn
+```
diff --git a/mmsegmentation/docs/zh_cn/user_guides/visualization.md b/mmsegmentation/docs/zh_cn/user_guides/visualization.md
new file mode 100644
index 0000000..2ef020b
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/user_guides/visualization.md
@@ -0,0 +1,173 @@
+# 可视化
+
+MMSegmentation 1.x 提供了简便的方式监控训练时的状态以及可视化在模型预测时的数据。
+
+## 训练状态监控
+
+MMSegmentation 1.x 使用 TensorBoard 来监控训练时候的状态。
+
+### TensorBoard 的配置
+
+安装 TensorBoard 的过程可以按照 [官方安装指南](https://www.tensorflow.org/install) ，具体的步骤如下：
+
+```shell
+pip install tensorboardX
+pip install future tensorboard
+```
+
+在配置文件 `default_runtime.py` 的 `vis_backend` 中添加 `TensorboardVisBackend`。
+
+```python
+vis_backends = [dict(type='LocalVisBackend'),
+                dict(type='TensorboardVisBackend')]
+visualizer = dict(
+    type='SegLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+```
+
+### 检查 TensorBoard 中的标量
+
+启动训练实验的命令如下
+
+```shell
+python tools/train.py configs/pspnet/pspnet_r50-d8_4xb4-80k_ade20k-512x512.py --work-dir work_dir/test_visual
+```
+
+开始训练后找到 `work_dir` 中的 `vis_data` 路径，例如：本次特定测试的 vis_data 路径如下所示：
+
+```shell
+work_dirs/test_visual/20220810_115248/vis_data
+```
+
+vis_data 路径中的标量文件包括了学习率、损失函数和 data_time 等，还记录了指标结果，您可以参考 MMEngine 中的 [记录日志教程](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/logging.html) 中的日志教程来帮助记录自己定义的数据。 Tensorboard 的可视化结果使用下面的命令执行：
+
+```shell
+tensorboard --logdir work_dirs/test_visual/20220810_115248/vis_data
+```
+
+## 数据和结果的可视化
+
+### 模型测试或验证期间的可视化数据样本
+
+MMSegmentation 提供了 `SegVisualizationHook` ，它是一个可以用于可视化 ground truth 和在模型测试和验证期间的预测分割结果的[钩子](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/hook.html) 。 它的配置在 `default_hooks` 中，更多详细信息请参见 [执行器教程](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/runner.html)。
+
+例如，在 `_base_/schedules/schedule_20k.py` 中，修改 `SegVisualizationHook` 配置，将 `draw` 设置为 `True` 以启用网络推理结果的存储，`interval` 表示预测结果的采样间隔， 设置为 1 时，将保存网络的每个推理结果。 `interval` 默认设置为 50：
+
+```python
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=2000),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook', draw=True, interval=1))
+
+```
+
+启动训练实验后，可视化结果将在 validation loop 存储到本地文件夹中，或者在一个数据集上启动评估模型时，预测结果将存储在本地。本地的可视化的存储结果保存在 `$WORK_DIRS/vis_data` 下的 `vis_image` 中，例如：
+
+```shell
+work_dirs/test_visual/20220810_115248/vis_data/vis_image
+```
+
+另外，如果在 `vis_backends` 中添加 `TensorboardVisBackend` ，如 [TensorBoard 的配置](###TensorBoard的配置)，我们还可以运行下面的命令在 TensorBoard 中查看它们：
+
+```shell
+tensorboard --logdir work_dirs/test_visual/20220810_115248/vis_data
+```
+
+### 可视化单个数据样本
+
+如果你想可视化单个样本数据，我们建议使用 `SegLocalVisualizer` 。
+
+`SegLocalVisualizer`是继承自 MMEngine 中`Visualizer` 类的子类，适用于 MMSegmentation 可视化，有关`Visualizer`的详细信息请参考在 MMEngine 中的[可视化教程](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/visualization.html) 。
+
+以下是一个关于 `SegLocalVisualizer` 的示例，首先你可以使用下面的命令下载这个案例中的数据：
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/189833109-eddad58f-f777-4fc0-b98a-6bd429143b06.png" width="70%"/>
+</div>
+
+```shell
+wget https://user-images.githubusercontent.com/24582831/189833109-eddad58f-f777-4fc0-b98a-6bd429143b06.png --output-document aachen_000000_000019_leftImg8bit.png
+wget https://user-images.githubusercontent.com/24582831/189833143-15f60f8a-4d1e-4cbb-a6e7-5e2233869fac.png --output-document aachen_000000_000019_gtFine_labelTrainIds.png
+```
+
+然后你可以找到他们本地的路径和使用下面的脚本文件对其进行可视化：
+
+```python
+import mmcv
+import os.path as osp
+import torch
+
+# `PixelData` 是 MMEngine 中用于定义像素级标注或预测的数据结构。
+# 请参考下面的MMEngine数据结构教程文件：
+# https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/data_element.html#pixeldata
+
+from mmengine.structures import PixelData
+
+# `SegDataSample` 是在 MMSegmentation 中定义的不同组件之间的数据结构接口，
+# 它包括 ground truth、语义分割的预测结果和预测逻辑。
+# 详情请参考下面的 `SegDataSample` 教程文件：
+# https://github.com/open-mmlab/mmsegmentation/blob/1.x/docs/en/advanced_guides/structures.md
+
+from mmseg.structures import SegDataSample
+from mmseg.visualization import SegLocalVisualizer
+
+out_file = 'out_file_cityscapes'
+save_dir = './work_dirs'
+
+image = mmcv.imread(
+    osp.join(
+        osp.dirname(__file__),
+        './aachen_000000_000019_leftImg8bit.png'
+    ),
+    'color')
+sem_seg = mmcv.imread(
+    osp.join(
+        osp.dirname(__file__),
+        './aachen_000000_000019_gtFine_labelTrainIds.png'  # noqa
+    ),
+    'unchanged')
+sem_seg = torch.from_numpy(sem_seg)
+gt_sem_seg_data = dict(data=sem_seg)
+gt_sem_seg = PixelData(**gt_sem_seg_data)
+data_sample = SegDataSample()
+data_sample.gt_sem_seg = gt_sem_seg
+
+seg_local_visualizer = SegLocalVisualizer(
+    vis_backends=[dict(type='LocalVisBackend')],
+    save_dir=save_dir)
+
+# 数据集的元信息通常包括类名的 `classes` 和
+# 用于可视化每个前景颜色的 `palette` 。
+# 所有类名和调色板都在此文件中定义：
+# https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/utils/class_names.py
+
+seg_local_visualizer.dataset_meta = dict(
+    classes=('road', 'sidewalk', 'building', 'wall', 'fence',
+             'pole', 'traffic light', 'traffic sign',
+             'vegetation', 'terrain', 'sky', 'person', 'rider',
+             'car', 'truck', 'bus', 'train', 'motorcycle',
+             'bicycle'),
+    palette=[[128, 64, 128], [244, 35, 232], [70, 70, 70],
+             [102, 102, 156], [190, 153, 153], [153, 153, 153],
+             [250, 170, 30], [220, 220, 0], [107, 142, 35],
+             [152, 251, 152], [70, 130, 180], [220, 20, 60],
+             [255, 0, 0], [0, 0, 142], [0, 0, 70],
+             [0, 60, 100], [0, 80, 100], [0, 0, 230],
+             [119, 11, 32]])
+
+# 当`show=True`时，直接显示结果，
+# 当 `show=False`时，结果将保存在本地文件夹中。
+
+seg_local_visualizer.add_datasample(out_file, image,
+                                    data_sample, show=False)
+```
+
+可视化后的图像结果和它的对应的 ground truth 图像可以在 `./work_dirs/vis_data/vis_image/` 路径找到，文件名字是：`out_file_cityscapes_0.png` ：
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/189835713-c0534054-4bfa-4b75-9254-0afbeb5ff02e.png" width="70%"/>
+</div>
+
+如果你想知道更多的关于可视化的使用指引，你可以参考 MMEngine 中的[可视化教程](<[https://mmengine.readthedocs.io/en/latest/advanced_tutorials/visualization.html](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/advanced_tutorials/visualization.md)>)
diff --git a/mmsegmentation/docs/zh_cn/user_guides/visualization_feature_map.md b/mmsegmentation/docs/zh_cn/user_guides/visualization_feature_map.md
new file mode 100644
index 0000000..fda99bb
--- /dev/null
+++ b/mmsegmentation/docs/zh_cn/user_guides/visualization_feature_map.md
@@ -0,0 +1,201 @@
+# wandb记录特征图可视化
+
+MMSegmentation 1.x 提供了 Weights & Biases 的后端支持，方便对项目代码结果的可视化和管理。
+
+## Wandb的配置
+
+安装 Weights & Biases 的过程可以参考 [官方安装指南](https://docs.wandb.ai/quickstart)，具体的步骤如下:
+
+```shell
+pip install wandb
+wandb login
+```
+
+在 `vis_backend` 中添加 `WandbVisBackend`。
+
+```python
+vis_backends=[dict(type='LocalVisBackend'),
+              dict(type='TensorboardVisBackend'),
+              dict(type='WandbVisBackend')]
+```
+
+## 测试数据和结果及特征图的可视化
+
+`SegLocalVisualizer` 是继承自 MMEngine 中 `Visualizer` 类的子类，适用于 MMSegmentation 可视化，有关 `Visualizer` 的详细信息请参考在 MMEngine 中的[可视化教程](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/visualization.html) 。
+
+以下是一个关于 `SegLocalVisualizer` 的示例，首先你可以使用下面的命令下载这个案例中的数据：
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/24582831/189833109-eddad58f-f777-4fc0-b98a-6bd429143b06.png" width="70%"/>
+</div>
+
+```shell
+wget https://user-images.githubusercontent.com/24582831/189833109-eddad58f-f777-4fc0-b98a-6bd429143b06.png --output-document aachen_000000_000019_leftImg8bit.png
+wget https://user-images.githubusercontent.com/24582831/189833143-15f60f8a-4d1e-4cbb-a6e7-5e2233869fac.png --output-document aachen_000000_000019_gtFine_labelTrainIds.png
+
+wget https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x1024_40k_cityscapes/ann_r50-d8_512x1024_40k_cityscapes_20200605_095211-049fc292.pth
+
+```
+
+```python
+# Copyright (c) OpenMMLab. All rights reserved.
+from argparse import ArgumentParser
+from typing import Type
+
+import mmcv
+import torch
+import torch.nn as nn
+
+from mmengine.model import revert_sync_batchnorm
+from mmengine.structures import PixelData
+from mmseg.apis import inference_model, init_model
+from mmseg.structures import SegDataSample
+from mmseg.utils import register_all_modules
+from mmseg.visualization import SegLocalVisualizer
+
+
+class Recorder:
+    """record the forward output feature map and save to data_buffer."""
+
+    def __init__(self) -> None:
+        self.data_buffer = list()
+
+    def __enter__(self, ):
+        self._data_buffer = list()
+
+    def record_data_hook(self, model: nn.Module, input: Type, output: Type):
+        self.data_buffer.append(output)
+
+    def __exit__(self, *args, **kwargs):
+        pass
+
+
+def visualize(args, model, recorder, result):
+    seg_visualizer = SegLocalVisualizer(
+        vis_backends=[dict(type='WandbVisBackend')],
+        save_dir='temp_dir',
+        alpha=0.5)
+    seg_visualizer.dataset_meta = dict(
+        classes=model.dataset_meta['classes'],
+        palette=model.dataset_meta['palette'])
+
+    image = mmcv.imread(args.img, 'color')
+
+    seg_visualizer.add_datasample(
+        name='predict',
+        image=image,
+        data_sample=result,
+        draw_gt=False,
+        draw_pred=True,
+        wait_time=0,
+        out_file=None,
+        show=False)
+
+    # add feature map to wandb visualizer
+    for i in range(len(recorder.data_buffer)):
+        feature = recorder.data_buffer[i][0]  # remove the batch
+        drawn_img = seg_visualizer.draw_featmap(
+            feature, image, channel_reduction='select_max')
+        seg_visualizer.add_image(f'feature_map{i}', drawn_img)
+
+    if args.gt_mask:
+        sem_seg = mmcv.imread(args.gt_mask, 'unchanged')
+        sem_seg = torch.from_numpy(sem_seg)
+        gt_mask = dict(data=sem_seg)
+        gt_mask = PixelData(**gt_mask)
+        data_sample = SegDataSample()
+        data_sample.gt_sem_seg = gt_mask
+
+        seg_visualizer.add_datasample(
+            name='gt_mask',
+            image=image,
+            data_sample=data_sample,
+            draw_gt=True,
+            draw_pred=False,
+            wait_time=0,
+            out_file=None,
+            show=False)
+
+    seg_visualizer.add_image('image', image)
+
+
+def main():
+    parser = ArgumentParser(
+        description='Draw the Feature Map During Inference')
+    parser.add_argument('img', help='Image file')
+    parser.add_argument('config', help='Config file')
+    parser.add_argument('checkpoint', help='Checkpoint file')
+    parser.add_argument('--gt_mask', default=None, help='Path of gt mask file')
+    parser.add_argument('--out-file', default=None, help='Path to output file')
+    parser.add_argument(
+        '--device', default='cuda:0', help='Device used for inference')
+    parser.add_argument(
+        '--opacity',
+        type=float,
+        default=0.5,
+        help='Opacity of painted segmentation map. In (0, 1] range.')
+    parser.add_argument(
+        '--title', default='result', help='The image identifier.')
+    args = parser.parse_args()
+
+    register_all_modules()
+
+    # build the model from a config file and a checkpoint file
+    model = init_model(args.config, args.checkpoint, device=args.device)
+    if args.device == 'cpu':
+        model = revert_sync_batchnorm(model)
+
+    # show all named module in the model and use it in source list below
+    for name, module in model.named_modules():
+        print(name)
+
+    source = [
+        'decode_head.fusion.stages.0.query_project.activate',
+        'decode_head.context.stages.0.key_project.activate',
+        'decode_head.context.bottleneck.activate'
+    ]
+    source = dict.fromkeys(source)
+
+    count = 0
+    recorder = Recorder()
+    # registry the forward hook
+    for name, module in model.named_modules():
+        if name in source:
+            count += 1
+            module.register_forward_hook(recorder.record_data_hook)
+            if count == len(source):
+                break
+
+    with recorder:
+        # test a single image, and record feature map to data_buffer
+        result = inference_model(model, args.img)
+
+    visualize(args, model, recorder, result)
+
+
+if __name__ == '__main__':
+    main()
+
+```
+
+将上述代码保存为 feature_map_visual.py，在终端执行如下代码
+
+```shell
+python feature_map_visual.py ${图像} ${配置文件} ${检查点文件} [可选参数]
+```
+
+样例
+
+```shell
+python feature_map_visual.py \
+aachen_000000_000019_leftImg8bit.png \
+configs/ann/ann_r50-d8_4xb2-40k_cityscapes-512x1024.py \
+ann_r50-d8_512x1024_40k_cityscapes_20200605_095211-049fc292.pth \
+--gt_mask aachen_000000_000019_gtFine_labelTrainIds.png
+```
+
+可视化后的图像结果和它的对应的 feature map图像会出现在wandb账户中
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/76149310/217520321-647f5bf9-eef2-446d-a9e8-5ca7b621d500.png">
+</div>
diff --git a/mmsegmentation/mmseg/__init__.py b/mmsegmentation/mmseg/__init__.py
new file mode 100644
index 0000000..5fcb84e
--- /dev/null
+++ b/mmsegmentation/mmseg/__init__.py
@@ -0,0 +1,74 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+import mmcv
+import mmengine
+from packaging.version import parse
+
+from .version import __version__, version_info
+
+MMCV_MIN = '2.0.0rc4'
+MMCV_MAX = '2.2.0'
+MMENGINE_MIN = '0.5.0'
+MMENGINE_MAX = '1.0.0'
+
+
+def digit_version(version_str: str, length: int = 4):
+    """Convert a version string into a tuple of integers.
+
+    This method is usually used for comparing two versions. For pre-release
+    versions: alpha < beta < rc.
+
+    Args:
+        version_str (str): The version string.
+        length (int): The maximum number of version levels. Default: 4.
+
+    Returns:
+        tuple[int]: The version info in digits (integers).
+    """
+    version = parse(version_str)
+    assert version.release, f'failed to parse version {version_str}'
+    release = list(version.release)
+    release = release[:length]
+    if len(release) < length:
+        release = release + [0] * (length - len(release))
+    if version.is_prerelease:
+        mapping = {'a': -3, 'b': -2, 'rc': -1}
+        val = -4
+        # version.pre can be None
+        if version.pre:
+            if version.pre[0] not in mapping:
+                warnings.warn(f'unknown prerelease version {version.pre[0]}, '
+                              'version checking may go wrong')
+            else:
+                val = mapping[version.pre[0]]
+            release.extend([val, version.pre[-1]])
+        else:
+            release.extend([val, 0])
+
+    elif version.is_postrelease:
+        release.extend([1, version.post])
+    else:
+        release.extend([0, 0])
+    return tuple(release)
+
+
+mmcv_min_version = digit_version(MMCV_MIN)
+mmcv_max_version = digit_version(MMCV_MAX)
+mmcv_version = digit_version(mmcv.__version__)
+
+
+assert (mmcv_min_version <= mmcv_version < mmcv_max_version), \
+    f'MMCV=={mmcv.__version__} is used but incompatible. ' \
+    f'Please install mmcv>=2.0.0rc4.'
+
+mmengine_min_version = digit_version(MMENGINE_MIN)
+mmengine_max_version = digit_version(MMENGINE_MAX)
+mmengine_version = digit_version(mmengine.__version__)
+
+assert (mmengine_min_version <= mmengine_version < mmengine_max_version), \
+    f'MMEngine=={mmengine.__version__} is used but incompatible. ' \
+    f'Please install mmengine>={mmengine_min_version}, '\
+    f'<{mmengine_max_version}.'
+
+__all__ = ['__version__', 'version_info', 'digit_version']
diff --git a/mmsegmentation/mmseg/apis/__init__.py b/mmsegmentation/mmseg/apis/__init__.py
new file mode 100644
index 0000000..b50a266
--- /dev/null
+++ b/mmsegmentation/mmseg/apis/__init__.py
@@ -0,0 +1,9 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .inference import inference_model, init_model, show_result_pyplot
+from .mmseg_inferencer import MMSegInferencer
+from .remote_sense_inferencer import RSImage, RSInferencer
+
+__all__ = [
+    'init_model', 'inference_model', 'show_result_pyplot', 'MMSegInferencer',
+    'RSInferencer', 'RSImage'
+]
diff --git a/mmsegmentation/mmseg/apis/inference.py b/mmsegmentation/mmseg/apis/inference.py
new file mode 100644
index 0000000..aab11d1
--- /dev/null
+++ b/mmsegmentation/mmseg/apis/inference.py
@@ -0,0 +1,189 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+from pathlib import Path
+from typing import Optional, Union
+
+import mmcv
+import numpy as np
+import torch
+from mmengine import Config
+from mmengine.registry import init_default_scope
+from mmengine.runner import load_checkpoint
+from mmengine.utils import mkdir_or_exist
+
+from mmseg.models import BaseSegmentor
+from mmseg.registry import MODELS
+from mmseg.structures import SegDataSample
+from mmseg.utils import SampleList, dataset_aliases, get_classes, get_palette
+from mmseg.visualization import SegLocalVisualizer
+from .utils import ImageType, _preprare_data
+
+
+def init_model(config: Union[str, Path, Config],
+               checkpoint: Optional[str] = None,
+               device: str = 'cuda:0',
+               cfg_options: Optional[dict] = None):
+    """Initialize a segmentor from config file.
+
+    Args:
+        config (str, :obj:`Path`, or :obj:`mmengine.Config`): Config file path,
+            :obj:`Path`, or the config object.
+        checkpoint (str, optional): Checkpoint path. If left as None, the model
+            will not load any weights.
+        device (str, optional) CPU/CUDA device option. Default 'cuda:0'.
+            Use 'cpu' for loading model on CPU.
+        cfg_options (dict, optional): Options to override some settings in
+            the used config.
+    Returns:
+        nn.Module: The constructed segmentor.
+    """
+    if isinstance(config, (str, Path)):
+        config = Config.fromfile(config)
+    elif not isinstance(config, Config):
+        raise TypeError('config must be a filename or Config object, '
+                        'but got {}'.format(type(config)))
+    if cfg_options is not None:
+        config.merge_from_dict(cfg_options)
+    if config.model.type == 'EncoderDecoder':
+        if 'init_cfg' in config.model.backbone:
+            config.model.backbone.init_cfg = None
+    elif config.model.type == 'MultimodalEncoderDecoder':
+        for k, v in config.model.items():
+            if isinstance(v, dict) and 'init_cfg' in v:
+                config.model[k].init_cfg = None
+    config.model.pretrained = None
+    config.model.train_cfg = None
+    init_default_scope(config.get('default_scope', 'mmseg'))
+
+    model = MODELS.build(config.model)
+    if checkpoint is not None:
+        checkpoint = load_checkpoint(model, checkpoint, map_location='cpu')
+        dataset_meta = checkpoint['meta'].get('dataset_meta', None)
+        # save the dataset_meta in the model for convenience
+        if 'dataset_meta' in checkpoint.get('meta', {}):
+            # mmseg 1.x
+            model.dataset_meta = dataset_meta
+        elif 'CLASSES' in checkpoint.get('meta', {}):
+            # < mmseg 1.x
+            classes = checkpoint['meta']['CLASSES']
+            palette = checkpoint['meta']['PALETTE']
+            model.dataset_meta = {'classes': classes, 'palette': palette}
+        else:
+            warnings.simplefilter('once')
+            warnings.warn(
+                'dataset_meta or class names are not saved in the '
+                'checkpoint\'s meta data, classes and palette will be'
+                'set according to num_classes ')
+            num_classes = model.decode_head.num_classes
+            dataset_name = None
+            for name in dataset_aliases.keys():
+                if len(get_classes(name)) == num_classes:
+                    dataset_name = name
+                    break
+            if dataset_name is None:
+                warnings.warn(
+                    'No suitable dataset found, use Cityscapes by default')
+                dataset_name = 'cityscapes'
+            model.dataset_meta = {
+                'classes': get_classes(dataset_name),
+                'palette': get_palette(dataset_name)
+            }
+    model.cfg = config  # save the config in the model for convenience
+    model.to(device)
+    model.eval()
+    return model
+
+
+def inference_model(model: BaseSegmentor,
+                    img: ImageType) -> Union[SegDataSample, SampleList]:
+    """Inference image(s) with the segmentor.
+
+    Args:
+        model (nn.Module): The loaded segmentor.
+        imgs (str/ndarray or list[str/ndarray]): Either image files or loaded
+            images.
+
+    Returns:
+        :obj:`SegDataSample` or list[:obj:`SegDataSample`]:
+        If imgs is a list or tuple, the same length list type results
+        will be returned, otherwise return the segmentation results directly.
+    """
+    # prepare data
+    data, is_batch = _preprare_data(img, model)
+
+    # forward the model
+    with torch.no_grad():
+        results = model.test_step(data)
+
+    return results if is_batch else results[0]
+
+
+def show_result_pyplot(model: BaseSegmentor,
+                       img: Union[str, np.ndarray],
+                       result: SegDataSample,
+                       opacity: float = 0.5,
+                       title: str = '',
+                       draw_gt: bool = True,
+                       draw_pred: bool = True,
+                       wait_time: float = 0,
+                       show: bool = True,
+                       with_labels: Optional[bool] = True,
+                       save_dir=None,
+                       out_file=None):
+    """Visualize the segmentation results on the image.
+
+    Args:
+        model (nn.Module): The loaded segmentor.
+        img (str or np.ndarray): Image filename or loaded image.
+        result (SegDataSample): The prediction SegDataSample result.
+        opacity(float): Opacity of painted segmentation map.
+            Default 0.5. Must be in (0, 1] range.
+        title (str): The title of pyplot figure.
+            Default is ''.
+        draw_gt (bool): Whether to draw GT SegDataSample. Default to True.
+        draw_pred (bool): Whether to draw Prediction SegDataSample.
+            Defaults to True.
+        wait_time (float): The interval of show (s). 0 is the special value
+            that means "forever". Defaults to 0.
+        show (bool): Whether to display the drawn image.
+            Default to True.
+        with_labels(bool, optional): Add semantic labels in visualization
+            result, Default to True.
+        save_dir (str, optional): Save file dir for all storage backends.
+            If it is None, the backend storage will not save any data.
+        out_file (str, optional): Path to output file. Default to None.
+
+
+
+    Returns:
+        np.ndarray: the drawn image which channel is RGB.
+    """
+    if hasattr(model, 'module'):
+        model = model.module
+    if isinstance(img, str):
+        image = mmcv.imread(img, channel_order='rgb')
+    else:
+        image = img
+    if save_dir is not None:
+        mkdir_or_exist(save_dir)
+    # init visualizer
+    visualizer = SegLocalVisualizer(
+        vis_backends=[dict(type='LocalVisBackend')],
+        save_dir=save_dir,
+        alpha=opacity)
+    visualizer.dataset_meta = dict(
+        classes=model.dataset_meta['classes'],
+        palette=model.dataset_meta['palette'])
+    visualizer.add_datasample(
+        name=title,
+        image=image,
+        data_sample=result,
+        draw_gt=draw_gt,
+        draw_pred=draw_pred,
+        wait_time=wait_time,
+        out_file=out_file,
+        show=show,
+        with_labels=with_labels)
+    vis_img = visualizer.get_image()
+
+    return vis_img
diff --git a/mmsegmentation/mmseg/apis/mmseg_inferencer.py b/mmsegmentation/mmseg/apis/mmseg_inferencer.py
new file mode 100644
index 0000000..02a198b
--- /dev/null
+++ b/mmsegmentation/mmseg/apis/mmseg_inferencer.py
@@ -0,0 +1,382 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+import warnings
+from typing import List, Optional, Sequence, Union
+
+import mmcv
+import mmengine
+import numpy as np
+import torch
+import torch.nn as nn
+from mmcv.transforms import Compose
+from mmengine.infer.infer import BaseInferencer, ModelType
+from mmengine.model import revert_sync_batchnorm
+from mmengine.registry import init_default_scope
+from mmengine.runner.checkpoint import _load_checkpoint_to_model
+from PIL import Image
+
+from mmseg.structures import SegDataSample
+from mmseg.utils import ConfigType, SampleList, get_classes, get_palette
+from mmseg.visualization import SegLocalVisualizer
+
+InputType = Union[str, np.ndarray]
+InputsType = Union[InputType, Sequence[InputType]]
+PredType = Union[SegDataSample, SampleList]
+
+
+class MMSegInferencer(BaseInferencer):
+    """Semantic segmentation inferencer, provides inference and visualization
+    interfaces. Note: MMEngine >= 0.5.0 is required.
+
+    Args:
+        model (str, optional): Path to the config file or the model name
+            defined in metafile. Take the `mmseg metafile <https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/metafile.yaml>`_
+            as an example the `model` could be
+            "fcn_r50-d8_4xb2-40k_cityscapes-512x1024", and the weights of model
+            will be download automatically. If use config file, like
+            "configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py", the
+            `weights` should be defined.
+        weights (str, optional): Path to the checkpoint. If it is not specified
+            and model is a model name of metafile, the weights will be loaded
+            from metafile. Defaults to None.
+        classes (list, optional): Input classes for result rendering, as the
+            prediction of segmentation model is a segment map with label
+            indices, `classes` is a list which includes items responding to the
+            label indices. If classes is not defined, visualizer will take
+            `cityscapes` classes by default. Defaults to None.
+        palette (list, optional): Input palette for result rendering, which is
+            a list of color palette responding to the classes. If palette is
+            not defined, visualizer will take `cityscapes` palette by default.
+            Defaults to None.
+        dataset_name (str, optional): `Dataset name or alias <https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/utils/class_names.py#L302-L317>`_
+            visulizer will use the meta information of the dataset i.e. classes
+            and palette, but the `classes` and `palette` have higher priority.
+            Defaults to None.
+        device (str, optional): Device to run inference. If None, the available
+            device will be automatically used. Defaults to None.
+        scope (str, optional): The scope of the model. Defaults to 'mmseg'.
+    """ # noqa
+
+    preprocess_kwargs: set = set()
+    forward_kwargs: set = {'mode', 'out_dir'}
+    visualize_kwargs: set = {
+        'show', 'wait_time', 'img_out_dir', 'opacity', 'return_vis',
+        'with_labels'
+    }
+    postprocess_kwargs: set = {'pred_out_dir', 'return_datasample'}
+
+    def __init__(self,
+                 model: Union[ModelType, str],
+                 weights: Optional[str] = None,
+                 classes: Optional[Union[str, List]] = None,
+                 palette: Optional[Union[str, List]] = None,
+                 dataset_name: Optional[str] = None,
+                 device: Optional[str] = None,
+                 scope: Optional[str] = 'mmseg') -> None:
+        # A global counter tracking the number of images processes, for
+        # naming of the output images
+        self.num_visualized_imgs = 0
+        self.num_pred_imgs = 0
+        init_default_scope(scope if scope else 'mmseg')
+        super().__init__(
+            model=model, weights=weights, device=device, scope=scope)
+
+        if device == 'cpu' or not torch.cuda.is_available():
+            self.model = revert_sync_batchnorm(self.model)
+
+        assert isinstance(self.visualizer, SegLocalVisualizer)
+        self.visualizer.set_dataset_meta(classes, palette, dataset_name)
+
+    def _load_weights_to_model(self, model: nn.Module,
+                               checkpoint: Optional[dict],
+                               cfg: Optional[ConfigType]) -> None:
+        """Loading model weights and meta information from cfg and checkpoint.
+
+        Subclasses could override this method to load extra meta information
+        from ``checkpoint`` and ``cfg`` to model.
+
+        Args:
+            model (nn.Module): Model to load weights and meta information.
+            checkpoint (dict, optional): The loaded checkpoint.
+            cfg (Config or ConfigDict, optional): The loaded config.
+        """
+
+        if checkpoint is not None:
+            _load_checkpoint_to_model(model, checkpoint)
+            checkpoint_meta = checkpoint.get('meta', {})
+            # save the dataset_meta in the model for convenience
+            if 'dataset_meta' in checkpoint_meta:
+                # mmsegmentation 1.x
+                model.dataset_meta = {
+                    'classes': checkpoint_meta['dataset_meta'].get('classes'),
+                    'palette': checkpoint_meta['dataset_meta'].get('palette')
+                }
+            elif 'CLASSES' in checkpoint_meta:
+                # mmsegmentation 0.x
+                classes = checkpoint_meta['CLASSES']
+                palette = checkpoint_meta.get('PALETTE', None)
+                model.dataset_meta = {'classes': classes, 'palette': palette}
+            else:
+                warnings.warn(
+                    'dataset_meta or class names are not saved in the '
+                    'checkpoint\'s meta data, use classes of Cityscapes by '
+                    'default.')
+                model.dataset_meta = {
+                    'classes': get_classes('cityscapes'),
+                    'palette': get_palette('cityscapes')
+                }
+        else:
+            warnings.warn('Checkpoint is not loaded, and the inference '
+                          'result is calculated by the randomly initialized '
+                          'model!')
+            warnings.warn(
+                'weights is None, use cityscapes classes by default.')
+            model.dataset_meta = {
+                'classes': get_classes('cityscapes'),
+                'palette': get_palette('cityscapes')
+            }
+
+    def __call__(self,
+                 inputs: InputsType,
+                 return_datasamples: bool = False,
+                 batch_size: int = 1,
+                 return_vis: bool = False,
+                 show: bool = False,
+                 wait_time: int = 0,
+                 out_dir: str = '',
+                 img_out_dir: str = 'vis',
+                 pred_out_dir: str = 'pred',
+                 **kwargs) -> dict:
+        """Call the inferencer.
+
+        Args:
+            inputs (Union[list, str, np.ndarray]): Inputs for the inferencer.
+            return_datasamples (bool): Whether to return results as
+                :obj:`SegDataSample`. Defaults to False.
+            batch_size (int): Batch size. Defaults to 1.
+            show (bool): Whether to display the rendering color segmentation
+                mask in a popup window. Defaults to False.
+            wait_time (float): The interval of show (s). Defaults to 0.
+            out_dir (str): Output directory of inference results. Defaults
+                to ''.
+            img_out_dir (str): Subdirectory of `out_dir`, used to save
+                rendering color segmentation mask, so `out_dir` must be defined
+                if you would like to save predicted mask. Defaults to 'vis'.
+            pred_out_dir (str): Subdirectory of `out_dir`, used to save
+                predicted mask file, so `out_dir` must be defined if you would
+                like to save predicted mask. Defaults to 'pred'.
+
+            **kwargs: Other keyword arguments passed to :meth:`preprocess`,
+                :meth:`forward`, :meth:`visualize` and :meth:`postprocess`.
+                Each key in kwargs should be in the corresponding set of
+                ``preprocess_kwargs``, ``forward_kwargs``, ``visualize_kwargs``
+                and ``postprocess_kwargs``.
+
+
+        Returns:
+            dict: Inference and visualization results.
+        """
+
+        if out_dir != '':
+            pred_out_dir = osp.join(out_dir, pred_out_dir)
+            img_out_dir = osp.join(out_dir, img_out_dir)
+        else:
+            pred_out_dir = ''
+            img_out_dir = ''
+
+        return super().__call__(
+            inputs=inputs,
+            return_datasamples=return_datasamples,
+            batch_size=batch_size,
+            show=show,
+            wait_time=wait_time,
+            img_out_dir=img_out_dir,
+            pred_out_dir=pred_out_dir,
+            return_vis=return_vis,
+            **kwargs)
+
+    def visualize(self,
+                  inputs: list,
+                  preds: List[dict],
+                  return_vis: bool = False,
+                  show: bool = False,
+                  wait_time: int = 0,
+                  img_out_dir: str = '',
+                  opacity: float = 0.8,
+                  with_labels: Optional[bool] = True) -> List[np.ndarray]:
+        """Visualize predictions.
+
+        Args:
+            inputs (list): Inputs preprocessed by :meth:`_inputs_to_list`.
+            preds (Any): Predictions of the model.
+            show (bool): Whether to display the image in a popup window.
+                Defaults to False.
+            wait_time (float): The interval of show (s). Defaults to 0.
+            img_out_dir (str): Output directory of rendering prediction i.e.
+                color segmentation mask. Defaults: ''
+            opacity (int, float): The transparency of segmentation mask.
+                Defaults to 0.8.
+
+        Returns:
+            List[np.ndarray]: Visualization results.
+        """
+        if not show and img_out_dir == '' and not return_vis:
+            return None
+        if self.visualizer is None:
+            raise ValueError('Visualization needs the "visualizer" term'
+                             'defined in the config, but got None.')
+
+        self.visualizer.set_dataset_meta(**self.model.dataset_meta)
+        self.visualizer.alpha = opacity
+
+        results = []
+
+        for single_input, pred in zip(inputs, preds):
+            if isinstance(single_input, str):
+                img_bytes = mmengine.fileio.get(single_input)
+                img = mmcv.imfrombytes(img_bytes)
+                img = img[:, :, ::-1]
+                img_name = osp.basename(single_input)
+            elif isinstance(single_input, np.ndarray):
+                img = single_input.copy()
+                img_num = str(self.num_visualized_imgs).zfill(8) + '_vis'
+                img_name = f'{img_num}.jpg'
+            else:
+                raise ValueError('Unsupported input type:'
+                                 f'{type(single_input)}')
+
+            out_file = osp.join(img_out_dir, img_name) if img_out_dir != ''\
+                else None
+
+            self.visualizer.add_datasample(
+                img_name,
+                img,
+                pred,
+                show=show,
+                wait_time=wait_time,
+                draw_gt=False,
+                draw_pred=True,
+                out_file=out_file,
+                with_labels=with_labels)
+            if return_vis:
+                results.append(self.visualizer.get_image())
+            self.num_visualized_imgs += 1
+
+        return results if return_vis else None
+
+    def postprocess(self,
+                    preds: PredType,
+                    visualization: List[np.ndarray],
+                    return_datasample: bool = False,
+                    pred_out_dir: str = '') -> dict:
+        """Process the predictions and visualization results from ``forward``
+        and ``visualize``.
+
+        This method should be responsible for the following tasks:
+
+        1. Pack the predictions and visualization results and return them.
+        2. Save the predictions, if it needed.
+
+        Args:
+            preds (List[Dict]): Predictions of the model.
+            visualization (List[np.ndarray]): The list of rendering color
+                segmentation mask.
+            return_datasample (bool): Whether to return results as datasamples.
+                Defaults to False.
+            pred_out_dir: File to save the inference results w/o
+                visualization. If left as empty, no file will be saved.
+                Defaults to ''.
+
+        Returns:
+            dict: Inference and visualization results with key ``predictions``
+            and ``visualization``
+
+            - ``visualization (Any)``: Returned by :meth:`visualize`
+            - ``predictions`` (List[np.ndarray], np.ndarray): Returned by
+              :meth:`forward` and processed in :meth:`postprocess`.
+              If ``return_datasample=False``, it will be the segmentation mask
+              with label indice.
+        """
+        if return_datasample:
+            if len(preds) == 1:
+                return preds[0]
+            else:
+                return preds
+
+        results_dict = {}
+
+        results_dict['predictions'] = []
+        results_dict['visualization'] = []
+
+        for i, pred in enumerate(preds):
+            pred_data = dict()
+            if 'pred_sem_seg' in pred.keys():
+                pred_data['sem_seg'] = pred.pred_sem_seg.numpy().data[0]
+            elif 'pred_depth_map' in pred.keys():
+                pred_data['depth_map'] = pred.pred_depth_map.numpy().data[0]
+
+            if visualization is not None:
+                vis = visualization[i]
+                results_dict['visualization'].append(vis)
+            if pred_out_dir != '':
+                mmengine.mkdir_or_exist(pred_out_dir)
+                for key, data in pred_data.items():
+                    post_fix = '_pred.png' if key == 'sem_seg' else '_pred.npy'
+                    img_name = str(self.num_pred_imgs).zfill(8) + post_fix
+                    img_path = osp.join(pred_out_dir, img_name)
+                    if key == 'sem_seg':
+                        output = Image.fromarray(data.astype(np.uint8))
+                        output.save(img_path)
+                    else:
+                        np.save(img_path, data)
+            pred_data = next(iter(pred_data.values()))
+            results_dict['predictions'].append(pred_data)
+            self.num_pred_imgs += 1
+
+        if len(results_dict['predictions']) == 1:
+            results_dict['predictions'] = results_dict['predictions'][0]
+            if visualization is not None:
+                results_dict['visualization'] = \
+                    results_dict['visualization'][0]
+        return results_dict
+
+    def _init_pipeline(self, cfg: ConfigType) -> Compose:
+        """Initialize the test pipeline.
+
+        Return a pipeline to handle various input data, such as ``str``,
+        ``np.ndarray``. It is an abstract method in BaseInferencer, and should
+        be implemented in subclasses.
+
+        The returned pipeline will be used to process a single data.
+        It will be used in :meth:`preprocess` like this:
+
+        .. code-block:: python
+            def preprocess(self, inputs, batch_size, **kwargs):
+                ...
+                dataset = map(self.pipeline, dataset)
+                ...
+        """
+        pipeline_cfg = cfg.test_dataloader.dataset.pipeline
+        # Loading annotations is also not applicable
+        for transform in ('LoadAnnotations', 'LoadDepthAnnotation'):
+            idx = self._get_transform_idx(pipeline_cfg, transform)
+            if idx != -1:
+                del pipeline_cfg[idx]
+
+        load_img_idx = self._get_transform_idx(pipeline_cfg,
+                                               'LoadImageFromFile')
+        if load_img_idx == -1:
+            raise ValueError(
+                'LoadImageFromFile is not found in the test pipeline')
+        pipeline_cfg[load_img_idx]['type'] = 'InferencerLoader'
+        return Compose(pipeline_cfg)
+
+    def _get_transform_idx(self, pipeline_cfg: ConfigType, name: str) -> int:
+        """Returns the index of the transform in a pipeline.
+
+        If the transform is not found, returns -1.
+        """
+        for i, transform in enumerate(pipeline_cfg):
+            if transform['type'] == name:
+                return i
+        return -1
diff --git a/mmsegmentation/mmseg/apis/remote_sense_inferencer.py b/mmsegmentation/mmseg/apis/remote_sense_inferencer.py
new file mode 100644
index 0000000..6726c6a
--- /dev/null
+++ b/mmsegmentation/mmseg/apis/remote_sense_inferencer.py
@@ -0,0 +1,279 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import threading
+from queue import Queue
+from typing import List, Optional, Tuple
+
+import numpy as np
+import torch
+from mmengine import Config
+from mmengine.model import BaseModel
+from mmengine.registry import init_default_scope
+from mmengine.runner import load_checkpoint
+
+try:
+    from osgeo import gdal
+except ImportError:
+    gdal = None
+
+from mmseg.registry import MODELS
+from .utils import _preprare_data
+
+
+class RSImage:
+    """Remote sensing image class.
+
+    Args:
+        img (str or gdal.Dataset): Image file path or gdal.Dataset.
+    """
+
+    def __init__(self, image):
+        self.dataset = gdal.Open(image, gdal.GA_ReadOnly) if isinstance(
+            image, str) else image
+        assert isinstance(self.dataset, gdal.Dataset), \
+            f'{image} is not a image'
+        self.width = self.dataset.RasterXSize
+        self.height = self.dataset.RasterYSize
+        self.channel = self.dataset.RasterCount
+        self.trans = self.dataset.GetGeoTransform()
+        self.proj = self.dataset.GetProjection()
+        self.band_list = []
+        self.band_list.extend(
+            self.dataset.GetRasterBand(c + 1) for c in range(self.channel))
+        self.grids = []
+
+    def read(self, grid: Optional[List] = None) -> np.ndarray:
+        """Read image data. If grid is None, read the whole image.
+
+        Args:
+            grid (Optional[List], optional): Grid to read. Defaults to None.
+        Returns:
+            np.ndarray: Image data.
+        """
+        if grid is None:
+            return np.einsum('ijk->jki', self.dataset.ReadAsArray())
+        assert len(
+            grid) >= 4, 'grid must be a list containing at least 4 elements'
+        data = self.dataset.ReadAsArray(*grid[:4])
+        if data.ndim == 2:
+            data = data[np.newaxis, ...]
+        return np.einsum('ijk->jki', data)
+
+    def write(self, data: Optional[np.ndarray], grid: Optional[List] = None):
+        """Write image data.
+
+        Args:
+            grid (Optional[List], optional): Grid to write. Defaults to None.
+            data (Optional[np.ndarray], optional): Data to write.
+                Defaults to None.
+
+        Raises:
+            ValueError: Either grid or data must be provided.
+        """
+        if grid is not None:
+            assert len(grid) == 8, 'grid must be a list of 8 elements'
+            for band in self.band_list:
+                band.WriteArray(
+                    data[grid[5]:grid[5] + grid[7], grid[4]:grid[4] + grid[6]],
+                    grid[0] + grid[4], grid[1] + grid[5])
+        elif data is not None:
+            for i in range(self.channel):
+                self.band_list[i].WriteArray(data[..., i])
+        else:
+            raise ValueError('Either grid or data must be provided.')
+
+    def create_seg_map(self, output_path: Optional[str] = None):
+        if output_path is None:
+            output_path = 'output_label.tif'
+        driver = gdal.GetDriverByName('GTiff')
+        seg_map = driver.Create(output_path, self.width, self.height, 1,
+                                gdal.GDT_Byte)
+        seg_map.SetGeoTransform(self.trans)
+        seg_map.SetProjection(self.proj)
+        seg_map_img = RSImage(seg_map)
+        seg_map_img.path = output_path
+        return seg_map_img
+
+    def create_grids(self,
+                     window_size: Tuple[int, int],
+                     stride: Tuple[int, int] = (0, 0)):
+        """Create grids for image inference.
+
+        Args:
+            window_size (Tuple[int, int]): the size of the sliding window.
+            stride (Tuple[int, int], optional): the stride of the sliding
+                window. Defaults to (0, 0).
+
+        Raises:
+            AssertionError: window_size must be a tuple of 2 elements.
+            AssertionError: stride must be a tuple of 2 elements.
+        """
+        assert len(
+            window_size) == 2, 'window_size must be a tuple of 2 elements'
+        assert len(stride) == 2, 'stride must be a tuple of 2 elements'
+        win_w, win_h = window_size
+        stride_x, stride_y = stride
+
+        stride_x = win_w if stride_x == 0 else stride_x
+        stride_y = win_h if stride_y == 0 else stride_y
+
+        x_half_overlap = (win_w - stride_x + 1) // 2
+        y_half_overlap = (win_h - stride_y + 1) // 2
+
+        for y in range(0, self.height, stride_y):
+            y_end = y + win_h >= self.height
+            y_offset = self.height - win_h if y_end else y
+            y_size = win_h
+            y_crop_off = 0 if y_offset == 0 else y_half_overlap
+            y_crop_size = y_size if y_end else win_h - y_crop_off
+
+            for x in range(0, self.width, stride_x):
+                x_end = x + win_w >= self.width
+                x_offset = self.width - win_w if x_end else x
+                x_size = win_w
+                x_crop_off = 0 if x_offset == 0 else x_half_overlap
+                x_crop_size = x_size if x_end else win_w - x_crop_off
+
+                self.grids.append([
+                    x_offset, y_offset, x_size, y_size, x_crop_off, y_crop_off,
+                    x_crop_size, y_crop_size
+                ])
+
+
+class RSInferencer:
+    """Remote sensing inference class.
+
+    Args:
+        model (BaseModel): The loaded model.
+        batch_size (int, optional): Batch size. Defaults to 1.
+        thread (int, optional): Number of threads. Defaults to 1.
+    """
+
+    def __init__(self, model: BaseModel, batch_size: int = 1, thread: int = 1):
+        self.model = model
+        self.batch_size = batch_size
+        self.END_FLAG = object()
+        self.read_buffer = Queue(self.batch_size)
+        self.write_buffer = Queue(self.batch_size)
+        self.thread = thread
+
+    @classmethod
+    def from_config_path(cls,
+                         config_path: str,
+                         checkpoint_path: str,
+                         batch_size: int = 1,
+                         thread: int = 1,
+                         device: Optional[str] = 'cpu'):
+        """Initialize a segmentor from config file.
+
+        Args:
+            config_path (str): Config file path.
+            checkpoint_path (str): Checkpoint path.
+            batch_size (int, optional): Batch size. Defaults to 1.
+        """
+        init_default_scope('mmseg')
+        cfg = Config.fromfile(config_path)
+        model = MODELS.build(cfg.model)
+        model.cfg = cfg
+        load_checkpoint(model, checkpoint_path, map_location='cpu')
+        model.to(device)
+        model.eval()
+        return cls(model, batch_size, thread)
+
+    @classmethod
+    def from_model(cls,
+                   model: BaseModel,
+                   checkpoint_path: Optional[str] = None,
+                   batch_size: int = 1,
+                   thread: int = 1,
+                   device: Optional[str] = 'cpu'):
+        """Initialize a segmentor from model.
+
+        Args:
+            model (BaseModel): The loaded model.
+            checkpoint_path (Optional[str]): Checkpoint path.
+            batch_size (int, optional): Batch size. Defaults to 1.
+        """
+        if checkpoint_path is not None:
+            load_checkpoint(model, checkpoint_path, map_location='cpu')
+        model.to(device)
+        return cls(model, batch_size, thread)
+
+    def read(self,
+             image: RSImage,
+             window_size: Tuple[int, int],
+             strides: Tuple[int, int] = (0, 0)):
+        """Load image data to read buffer.
+
+        Args:
+            image (RSImage): The image to read.
+            window_size (Tuple[int, int]): The size of the sliding window.
+            strides (Tuple[int, int], optional): The stride of the sliding
+                window. Defaults to (0, 0).
+        """
+        image.create_grids(window_size, strides)
+        for grid in image.grids:
+            self.read_buffer.put([grid, image.read(grid=grid)])
+        self.read_buffer.put(self.END_FLAG)
+
+    def inference(self):
+        """Inference image data from read buffer and put the result to write
+        buffer."""
+        while True:
+            item = self.read_buffer.get()
+            if item == self.END_FLAG:
+                self.read_buffer.put(self.END_FLAG)
+                self.write_buffer.put(item)
+                break
+            data, _ = _preprare_data(item[1], self.model)
+            with torch.no_grad():
+                result = self.model.test_step(data)
+            item[1] = result[0].pred_sem_seg.cpu().data.numpy()[0]
+            self.write_buffer.put(item)
+            self.read_buffer.task_done()
+
+    def write(self, image: RSImage, output_path: Optional[str] = None):
+        """Write image data from write buffer.
+
+        Args:
+            image (RSImage): The image to write.
+            output_path (Optional[str], optional): The path to save the
+                segmentation map. Defaults to None.
+        """
+        seg_map = image.create_seg_map(output_path)
+        while True:
+            item = self.write_buffer.get()
+            if item == self.END_FLAG:
+                break
+            seg_map.write(data=item[1], grid=item[0])
+            self.write_buffer.task_done()
+
+    def run(self,
+            image: RSImage,
+            window_size: Tuple[int, int],
+            strides: Tuple[int, int] = (0, 0),
+            output_path: Optional[str] = None):
+        """Run inference with multi-threading.
+
+        Args:
+            image (RSImage): The image to inference.
+            window_size (Tuple[int, int]): The size of the sliding window.
+            strides (Tuple[int, int], optional): The stride of the sliding
+                window. Defaults to (0, 0).
+            output_path (Optional[str], optional): The path to save the
+                segmentation map. Defaults to None.
+        """
+        read_thread = threading.Thread(
+            target=self.read, args=(image, window_size, strides))
+        read_thread.start()
+        inference_threads = []
+        for _ in range(self.thread):
+            inference_thread = threading.Thread(target=self.inference)
+            inference_thread.start()
+            inference_threads.append(inference_thread)
+        write_thread = threading.Thread(
+            target=self.write, args=(image, output_path))
+        write_thread.start()
+        read_thread.join()
+        for inference_thread in inference_threads:
+            inference_thread.join()
+        write_thread.join()
diff --git a/mmsegmentation/mmseg/apis/utils.py b/mmsegmentation/mmseg/apis/utils.py
new file mode 100644
index 0000000..4cf8775
--- /dev/null
+++ b/mmsegmentation/mmseg/apis/utils.py
@@ -0,0 +1,41 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from collections import defaultdict
+from typing import Sequence, Union
+
+import numpy as np
+from mmengine.dataset import Compose
+from mmengine.model import BaseModel
+
+ImageType = Union[str, np.ndarray, Sequence[str], Sequence[np.ndarray]]
+
+
+def _preprare_data(imgs: ImageType, model: BaseModel):
+
+    cfg = model.cfg
+    for t in cfg.test_pipeline:
+        if t.get('type') == 'LoadAnnotations':
+            cfg.test_pipeline.remove(t)
+
+    is_batch = True
+    if not isinstance(imgs, (list, tuple)):
+        imgs = [imgs]
+        is_batch = False
+
+    if isinstance(imgs[0], np.ndarray):
+        cfg.test_pipeline[0]['type'] = 'LoadImageFromNDArray'
+
+    # TODO: Consider using the singleton pattern to avoid building
+    # a pipeline for each inference
+    pipeline = Compose(cfg.test_pipeline)
+
+    data = defaultdict(list)
+    for img in imgs:
+        if isinstance(img, np.ndarray):
+            data_ = dict(img=img)
+        else:
+            data_ = dict(img_path=img)
+        data_ = pipeline(data_)
+        data['inputs'].append(data_['inputs'])
+        data['data_samples'].append(data_['data_samples'])
+
+    return data, is_batch
diff --git a/mmsegmentation/mmseg/configs/_base_/datasets/loveda.py b/mmsegmentation/mmseg/configs/_base_/datasets/loveda.py
new file mode 100644
index 0000000..eb3d358
--- /dev/null
+++ b/mmsegmentation/mmseg/configs/_base_/datasets/loveda.py
@@ -0,0 +1,79 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.transforms.loading import LoadImageFromFile
+from mmcv.transforms.processing import (RandomFlip, RandomResize, Resize,
+                                        TestTimeAug)
+from mmengine.dataset.sampler import DefaultSampler, InfiniteSampler
+
+from mmseg.datasets.loveda import LoveDADataset
+from mmseg.datasets.transforms.formatting import PackSegInputs
+from mmseg.datasets.transforms.loading import LoadAnnotations
+from mmseg.datasets.transforms.transforms import (PhotoMetricDistortion,
+                                                  RandomCrop)
+from mmseg.evaluation import IoUMetric
+
+# dataset settings
+dataset_type = LoveDADataset
+data_root = 'data/loveDA'
+crop_size = (512, 512)
+train_pipeline = [
+    dict(type=LoadImageFromFile),
+    dict(type=LoadAnnotations, reduce_zero_label=True),
+    dict(
+        type=RandomResize,
+        scale=(2048, 512),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type=RandomCrop, crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=PhotoMetricDistortion),
+    dict(type=PackSegInputs)
+]
+test_pipeline = [
+    dict(type=LoadImageFromFile),
+    dict(type=Resize, scale=(1024, 1024), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type=LoadAnnotations, reduce_zero_label=True),
+    dict(type=PackSegInputs)
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=None),
+    dict(
+        type=TestTimeAug,
+        transforms=[[
+            dict(type=Resize, scale_factor=r, keep_ratio=True)
+            for r in img_ratios
+        ],
+                    [
+                        dict(type=RandomFlip, prob=0., direction='horizontal'),
+                        dict(type=RandomFlip, prob=1., direction='horizontal')
+                    ], [dict(type=LoadAnnotations)],
+                    [dict(type=PackSegInputs)]])
+]
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=12,
+    persistent_workers=True,
+    sampler=dict(type=InfiniteSampler, shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='img_dir/train', seg_map_path='ann_dir/train'),
+        pipeline=train_pipeline))
+
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type=DefaultSampler, shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(img_path='img_dir/val', seg_map_path='ann_dir/val'),
+        pipeline=test_pipeline))
+
+test_dataloader = val_dataloader
+val_evaluator = dict(type=IoUMetric, iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/mmseg/configs/_base_/datasets/potsdam.py b/mmsegmentation/mmseg/configs/_base_/datasets/potsdam.py
new file mode 100644
index 0000000..33a4ebf
--- /dev/null
+++ b/mmsegmentation/mmseg/configs/_base_/datasets/potsdam.py
@@ -0,0 +1,81 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.transforms.loading import LoadImageFromFile
+from mmcv.transforms.processing import (RandomFlip, RandomResize, Resize,
+                                        TestTimeAug)
+from mmengine.dataset.sampler import DefaultSampler, InfiniteSampler
+
+from mmseg.datasets.potsdam import PotsdamDataset
+from mmseg.datasets.transforms.formatting import PackSegInputs
+from mmseg.datasets.transforms.loading import LoadAnnotations
+from mmseg.datasets.transforms.transforms import (PhotoMetricDistortion,
+                                                  RandomCrop)
+from mmseg.evaluation import IoUMetric
+
+# dataset settings
+dataset_type = PotsdamDataset
+data_root = 'data/potsdam'
+crop_size = (512, 512)
+train_pipeline = [
+    dict(type=LoadImageFromFile),
+    dict(type=LoadAnnotations, reduce_zero_label=True),
+    dict(
+        type=RandomResize,
+        scale=(512, 512),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type=RandomCrop, crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=PhotoMetricDistortion),
+    dict(type=PackSegInputs)
+]
+test_pipeline = [
+    dict(type=LoadImageFromFile),
+    dict(type=Resize, scale=(512, 512), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type=LoadAnnotations, reduce_zero_label=True),
+    dict(type=PackSegInputs)
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=None),
+    dict(
+        type=TestTimeAug,
+        transforms=[[
+            dict(type=Resize, scale_factor=r, keep_ratio=True)
+            for r in img_ratios
+        ],
+                    [
+                        dict(type=RandomFlip, prob=0., direction='horizontal'),
+                        dict(type=RandomFlip, prob=1., direction='horizontal')
+                    ], [dict(type=LoadAnnotations)],
+                    [dict(type=PackSegInputs)]])
+]
+
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type=InfiniteSampler, shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='img_dir/train', seg_map_path='ann_dir/train'),
+        pipeline=train_pipeline))
+
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type=DefaultSampler, shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(img_path='img_dir/val', seg_map_path='ann_dir/val'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(
+    type=IoUMetric, iou_metrics=['mIoU'])  # 'mDice', 'mFscore'
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/mmseg/configs/_base_/default_runtime.py b/mmsegmentation/mmseg/configs/_base_/default_runtime.py
new file mode 100644
index 0000000..c905020
--- /dev/null
+++ b/mmsegmentation/mmseg/configs/_base_/default_runtime.py
@@ -0,0 +1,22 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+from mmengine.visualization import LocalVisBackend
+
+from mmseg.models import SegTTAModel
+from mmseg.visualization import SegLocalVisualizer
+
+env_cfg = dict(
+    cudnn_benchmark=False,
+    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+    dist_cfg=dict(backend='nccl'),
+)
+vis_backends = [dict(type=LocalVisBackend)]
+visualizer = dict(
+    type=SegLocalVisualizer, vis_backends=vis_backends, name='visualizer')
+log_processor = dict(by_epoch=False)
+log_level = 'INFO'
+load_from = None
+resume = False
+
+tta_model = dict(type=SegTTAModel)
+default_scope = None
diff --git a/mmsegmentation/mmseg/configs/_base_/schedules/schedule_160k.py b/mmsegmentation/mmseg/configs/_base_/schedules/schedule_160k.py
new file mode 100644
index 0000000..294d6ee
--- /dev/null
+++ b/mmsegmentation/mmseg/configs/_base_/schedules/schedule_160k.py
@@ -0,0 +1,43 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.hooks import (CheckpointHook, DistSamplerSeedHook, IterTimerHook,
+                            LoggerHook, ParamSchedulerHook)
+from mmengine.optim.optimizer.optimizer_wrapper import OptimWrapper
+from mmengine.optim.scheduler.lr_scheduler import PolyLR
+from mmengine.runner.loops import IterBasedTrainLoop, TestLoop, ValLoop
+from torch.optim.sgd import SGD
+
+from mmseg.engine import SegVisualizationHook
+
+# optimizer
+optimizer = dict(
+    type=SGD,
+    #  lr=0.01,
+    #  momentum=0.9,
+    #  weight_decay=0.0005
+)
+
+optim_wrapper = dict(type=OptimWrapper, optimizer=optimizer, clip_grad=None)
+
+# learning policy
+param_scheduler = [
+    dict(
+        type=PolyLR,
+        eta_min=1e-4,
+        power=0.9,
+        begin=0,
+        end=160000,
+        by_epoch=False)
+]
+# training schedule for 160k
+
+train_cfg = dict(type=IterBasedTrainLoop, max_iters=160000, val_interval=8000)
+val_cfg = dict(type=ValLoop)
+test_cfg = dict(type=TestLoop)
+
+default_hooks = dict(
+    timer=dict(type=IterTimerHook),
+    logger=dict(type=LoggerHook, interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type=ParamSchedulerHook),
+    checkpoint=dict(type=CheckpointHook, by_epoch=False, interval=8000),
+    sampler_seed=dict(type=DistSamplerSeedHook),
+    visualization=dict(type=SegVisualizationHook))
diff --git a/mmsegmentation/mmseg/configs/_base_/schedules/schedule_20k.py b/mmsegmentation/mmseg/configs/_base_/schedules/schedule_20k.py
new file mode 100644
index 0000000..255300a
--- /dev/null
+++ b/mmsegmentation/mmseg/configs/_base_/schedules/schedule_20k.py
@@ -0,0 +1,36 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.hooks import (CheckpointHook, DistSamplerSeedHook, IterTimerHook,
+                            LoggerHook, ParamSchedulerHook)
+from mmengine.optim.optimizer.optimizer_wrapper import OptimWrapper
+from mmengine.optim.scheduler.lr_scheduler import PolyLR
+from mmengine.runner.loops import IterBasedTrainLoop, TestLoop, ValLoop
+from torch.optim.sgd import SGD
+
+from mmseg.engine import SegVisualizationHook
+
+# optimizer
+optimizer = dict(type=SGD, lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type=OptimWrapper, optimizer=optimizer, clip_grad=None)
+
+# learning policy
+param_scheduler = [
+    dict(
+        type=PolyLR,
+        eta_min=1e-4,
+        power=0.9,
+        begin=0,
+        end=20000,
+        by_epoch=False)
+]
+# training schedule for 20k
+train_cfg = dict(type=IterBasedTrainLoop, max_iters=20000, val_interval=2000)
+val_cfg = dict(type=ValLoop)
+test_cfg = dict(type=TestLoop)
+
+default_hooks = dict(
+    timer=dict(type=IterTimerHook),
+    logger=dict(type=LoggerHook, interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type=ParamSchedulerHook),
+    checkpoint=dict(type=CheckpointHook, by_epoch=False, interval=2000),
+    sampler_seed=dict(type=DistSamplerSeedHook),
+    visualization=dict(type=SegVisualizationHook))
diff --git a/mmsegmentation/mmseg/configs/_base_/schedules/schedule_240k.py b/mmsegmentation/mmseg/configs/_base_/schedules/schedule_240k.py
new file mode 100644
index 0000000..cf9e5d3
--- /dev/null
+++ b/mmsegmentation/mmseg/configs/_base_/schedules/schedule_240k.py
@@ -0,0 +1,34 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.hooks import (CheckpointHook, DistSamplerSeedHook, IterTimerHook,
+                            LoggerHook, ParamSchedulerHook)
+from mmengine.optim.optimizer.optimizer_wrapper import OptimWrapper
+from mmengine.optim.scheduler.lr_scheduler import PolyLR
+from mmengine.runner.loops import IterBasedTrainLoop, TestLoop, ValLoop
+# from mmengine.runner.loops import EpochBasedTrainLoop
+from torch.optim.sgd import SGD
+
+from mmseg.engine import SegVisualizationHook
+
+optimizer = dict(type=SGD, lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type=OptimWrapper, optimizer=optimizer, clip_grad=None)
+# learning policy
+param_scheduler = [
+    dict(
+        type=PolyLR,
+        eta_min=1e-4,
+        power=0.9,
+        begin=0,
+        end=240000,
+        by_epoch=False)
+]
+# training schedule for 240k
+train_cfg = dict(type=IterBasedTrainLoop, max_iters=240000, val_interval=24000)
+val_cfg = dict(type=ValLoop)
+test_cfg = dict(type=TestLoop)
+default_hooks = dict(
+    timer=dict(type=IterTimerHook),
+    logger=dict(type=LoggerHook, interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type=ParamSchedulerHook),
+    checkpoint=dict(type=CheckpointHook, by_epoch=False, interval=24000),
+    sampler_seed=dict(type=DistSamplerSeedHook),
+    visualization=dict(type=SegVisualizationHook))
diff --git a/mmsegmentation/mmseg/configs/_base_/schedules/schedule_25k.py b/mmsegmentation/mmseg/configs/_base_/schedules/schedule_25k.py
new file mode 100644
index 0000000..8a3ebf4
--- /dev/null
+++ b/mmsegmentation/mmseg/configs/_base_/schedules/schedule_25k.py
@@ -0,0 +1,43 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.hooks import (CheckpointHook, DistSamplerSeedHook, IterTimerHook,
+                            LoggerHook, ParamSchedulerHook)
+from mmengine.optim.optimizer.optimizer_wrapper import OptimWrapper
+from mmengine.optim.scheduler.lr_scheduler import ConstantLR, LinearLR
+from mmengine.runner.loops import IterBasedTrainLoop, TestLoop, ValLoop
+# from mmengine.runner.loops import EpochBasedTrainLoop
+from torch.optim.adamw import AdamW
+
+from mmseg.engine import SegVisualizationHook
+from mmseg.engine.schedulers import PolyLRRatio
+
+# optimizer
+optimizer = dict(type=AdamW, lr=0.01, weight_decay=0.1)
+
+optim_wrapper = dict(type=OptimWrapper, optimizer=optimizer, clip_grad=None)
+# learning policy
+
+# learning policy
+param_scheduler = [
+    dict(type=LinearLR, start_factor=3e-2, begin=0, end=12000, by_epoch=False),
+    dict(
+        type=PolyLRRatio,
+        eta_min_ratio=3e-2,
+        power=0.9,
+        begin=12000,
+        end=24000,
+        by_epoch=False),
+    dict(type=ConstantLR, by_epoch=False, factor=1, begin=24000, end=25000)
+]
+
+# training schedule for 25k
+train_cfg = dict(type=IterBasedTrainLoop, max_iters=25000, val_interval=1000)
+val_cfg = dict(type=ValLoop)
+test_cfg = dict(type=TestLoop)
+
+default_hooks = dict(
+    timer=dict(type=IterTimerHook),
+    logger=dict(type=LoggerHook, interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type=ParamSchedulerHook),
+    checkpoint=dict(type=CheckpointHook, by_epoch=False, interval=1000),
+    sampler_seed=dict(type=DistSamplerSeedHook),
+    visualization=dict(type=SegVisualizationHook))
diff --git a/mmsegmentation/mmseg/configs/_base_/schedules/schedule_320k.py b/mmsegmentation/mmseg/configs/_base_/schedules/schedule_320k.py
new file mode 100644
index 0000000..dae323e
--- /dev/null
+++ b/mmsegmentation/mmseg/configs/_base_/schedules/schedule_320k.py
@@ -0,0 +1,36 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.hooks import (CheckpointHook, DistSamplerSeedHook, IterTimerHook,
+                            LoggerHook, ParamSchedulerHook)
+from mmengine.optim.optimizer.optimizer_wrapper import OptimWrapper
+from mmengine.optim.scheduler.lr_scheduler import PolyLR
+from mmengine.runner.loops import IterBasedTrainLoop, TestLoop, ValLoop
+# from mmengine.runner.loops import EpochBasedTrainLoop
+from torch.optim.sgd import SGD
+
+from mmseg.engine import SegVisualizationHook
+
+# optimizer
+optimizer = dict(type=SGD, lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type=OptimWrapper, optimizer=optimizer, clip_grad=None)
+
+# learning policy
+param_scheduler = [
+    dict(
+        type=PolyLR,
+        eta_min=1e-4,
+        power=0.9,
+        begin=0,
+        end=320000,
+        by_epoch=False)
+]
+# training schedule for 320k
+train_cfg = dict(type=IterBasedTrainLoop, max_iters=320000, val_interval=32000)
+val_cfg = dict(type=ValLoop)
+test_cfg = dict(type=TestLoop)
+default_hooks = dict(
+    timer=dict(type=IterTimerHook),
+    logger=dict(type=LoggerHook, interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type=ParamSchedulerHook),
+    checkpoint=dict(type=CheckpointHook, by_epoch=False, interval=32000),
+    sampler_seed=dict(type=DistSamplerSeedHook),
+    visualization=dict(type=SegVisualizationHook))
diff --git a/mmsegmentation/mmseg/configs/_base_/schedules/schedule_40k.py b/mmsegmentation/mmseg/configs/_base_/schedules/schedule_40k.py
new file mode 100644
index 0000000..b4b2ea4
--- /dev/null
+++ b/mmsegmentation/mmseg/configs/_base_/schedules/schedule_40k.py
@@ -0,0 +1,34 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.hooks import (CheckpointHook, DistSamplerSeedHook, IterTimerHook,
+                            LoggerHook, ParamSchedulerHook)
+from mmengine.optim.optimizer.optimizer_wrapper import OptimWrapper
+from mmengine.optim.scheduler.lr_scheduler import PolyLR
+from mmengine.runner.loops import IterBasedTrainLoop, TestLoop, ValLoop
+from torch.optim.sgd import SGD
+
+from mmseg.engine import SegVisualizationHook
+
+# optimizer
+optimizer = dict(type=SGD, lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type=OptimWrapper, optimizer=optimizer, clip_grad=None)
+
+param_scheduler = [
+    dict(
+        type=PolyLR,
+        eta_min=1e-4,
+        power=0.9,
+        begin=0,
+        end=40000,
+        by_epoch=False)
+]
+# training schedule for 40k
+train_cfg = dict(type=IterBasedTrainLoop, max_iters=40000, val_interval=4000)
+val_cfg = dict(type=ValLoop)
+test_cfg = dict(type=TestLoop)
+default_hooks = dict(
+    timer=dict(type=IterTimerHook),
+    logger=dict(type=LoggerHook, interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type=ParamSchedulerHook),
+    checkpoint=dict(type=CheckpointHook, by_epoch=False, interval=4000),
+    sampler_seed=dict(type=DistSamplerSeedHook),
+    visualization=dict(type=SegVisualizationHook))
diff --git a/mmsegmentation/mmseg/configs/_base_/schedules/schedule_80k.py b/mmsegmentation/mmseg/configs/_base_/schedules/schedule_80k.py
new file mode 100644
index 0000000..3e711ca
--- /dev/null
+++ b/mmsegmentation/mmseg/configs/_base_/schedules/schedule_80k.py
@@ -0,0 +1,42 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.hooks import (CheckpointHook, DistSamplerSeedHook, IterTimerHook,
+                            LoggerHook, ParamSchedulerHook)
+from mmengine.optim.optimizer.optimizer_wrapper import OptimWrapper
+from mmengine.optim.scheduler.lr_scheduler import PolyLR
+from mmengine.runner.loops import IterBasedTrainLoop, TestLoop, ValLoop
+from torch.optim.sgd import SGD
+
+from mmseg.engine import SegVisualizationHook
+
+# optimizer
+optimizer = dict(
+    type=SGD,
+    #  lr=0.01,
+    #  momentum=0.9,
+    #  weight_decay=0.0005
+)
+
+optim_wrapper = dict(type=OptimWrapper, optimizer=optimizer, clip_grad=None)
+
+# learning policy
+param_scheduler = [
+    dict(
+        type=PolyLR,
+        eta_min=1e-4,
+        power=0.9,
+        begin=0,
+        end=80000,
+        by_epoch=False)
+]
+# training schedule for 80k
+train_cfg = dict(type=IterBasedTrainLoop, max_iters=80000, val_interval=8000)
+val_cfg = dict(type=ValLoop)
+test_cfg = dict(type=TestLoop)
+
+default_hooks = dict(
+    timer=dict(type=IterTimerHook),
+    logger=dict(type=LoggerHook, interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type=ParamSchedulerHook),
+    checkpoint=dict(type=CheckpointHook, by_epoch=False, interval=8000),
+    sampler_seed=dict(type=DistSamplerSeedHook),
+    visualization=dict(type=SegVisualizationHook))
diff --git a/mmsegmentation/mmseg/datasets/__init__.py b/mmsegmentation/mmseg/datasets/__init__.py
new file mode 100644
index 0000000..49c3383
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/__init__.py
@@ -0,0 +1,69 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# yapf: disable
+from .ade import ADE20KDataset
+from .basesegdataset import BaseCDDataset, BaseSegDataset
+from .bdd100k import BDD100KDataset
+from .chase_db1 import ChaseDB1Dataset
+from .cityscapes import CityscapesDataset
+from .coco_stuff import COCOStuffDataset
+from .dark_zurich import DarkZurichDataset
+from .dataset_wrappers import MultiImageMixDataset
+from .decathlon import DecathlonDataset
+from .drive import DRIVEDataset
+from .dsdl import DSDLSegDataset
+from .hrf import HRFDataset
+from .hsi_drive import HSIDrive20Dataset
+from .isaid import iSAIDDataset
+from .isprs import ISPRSDataset
+from .levir import LEVIRCDDataset
+from .lip import LIPDataset
+from .loveda import LoveDADataset
+from .mapillary import MapillaryDataset_v1, MapillaryDataset_v2
+from .night_driving import NightDrivingDataset
+from .nyu import NYUDataset
+from .pascal_context import PascalContextDataset, PascalContextDataset59
+from .potsdam import PotsdamDataset
+from .refuge import REFUGEDataset
+from .stare import STAREDataset
+from .synapse import SynapseDataset
+from .xray import XRayDataset
+from .xray2 import XRayDataset2, LoadXRayAnnotations, TransposeAnnotations
+
+# yapf: disable
+from .transforms import (CLAHE, AdjustGamma, Albu, BioMedical3DPad,
+                         BioMedical3DRandomCrop, BioMedical3DRandomFlip,
+                         BioMedicalGaussianBlur, BioMedicalGaussianNoise,
+                         BioMedicalRandomGamma, ConcatCDInput, GenerateEdge,
+                         LoadAnnotations, LoadBiomedicalAnnotation,
+                         LoadBiomedicalData, LoadBiomedicalImageFromFile,
+                         LoadImageFromNDArray, LoadMultipleRSImageFromFile,
+                         LoadSingleRSImageFromFile, PackSegInputs,
+                         PhotoMetricDistortion, RandomCrop, RandomCutOut,
+                         RandomMosaic, RandomRotate, RandomRotFlip, Rerange,
+                         ResizeShortestEdge, ResizeToMultiple, RGB2Gray,
+                         SegRescale)
+from .voc import PascalVOCDataset
+
+
+# yapf: enable
+__all__ = [
+    'BaseSegDataset', 'BioMedical3DRandomCrop', 'BioMedical3DRandomFlip',
+    'CityscapesDataset', 'PascalVOCDataset', 'ADE20KDataset',
+    'PascalContextDataset', 'PascalContextDataset59', 'ChaseDB1Dataset',
+    'DRIVEDataset', 'HRFDataset', 'STAREDataset', 'DarkZurichDataset',
+    'NightDrivingDataset', 'COCOStuffDataset', 'LoveDADataset',
+    'MultiImageMixDataset', 'iSAIDDataset', 'ISPRSDataset', 'PotsdamDataset',
+    'LoadAnnotations', 'RandomCrop', 'SegRescale', 'PhotoMetricDistortion',
+    'RandomRotate', 'AdjustGamma', 'CLAHE', 'Rerange', 'RGB2Gray',
+    'RandomCutOut', 'RandomMosaic', 'PackSegInputs', 'ResizeToMultiple',
+    'LoadImageFromNDArray', 'LoadBiomedicalImageFromFile',
+    'LoadBiomedicalAnnotation', 'LoadBiomedicalData', 'GenerateEdge',
+    'DecathlonDataset', 'LIPDataset', 'ResizeShortestEdge',
+    'BioMedicalGaussianNoise', 'BioMedicalGaussianBlur',
+    'BioMedicalRandomGamma', 'BioMedical3DPad', 'RandomRotFlip',
+    'SynapseDataset', 'REFUGEDataset', 'MapillaryDataset_v1',
+    'MapillaryDataset_v2', 'Albu', 'LEVIRCDDataset',
+    'LoadMultipleRSImageFromFile', 'LoadSingleRSImageFromFile',
+    'ConcatCDInput', 'BaseCDDataset', 'DSDLSegDataset', 'BDD100KDataset',
+    'NYUDataset', 'HSIDrive20Dataset', 'XRayDataset', 'XRayDataset2', 'LoadXRayAnnotations', 'TransposeAnnotations'
+]
diff --git a/mmsegmentation/mmseg/datasets/ade.py b/mmsegmentation/mmseg/datasets/ade.py
new file mode 100644
index 0000000..e9bdae7
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/ade.py
@@ -0,0 +1,92 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmseg.registry import DATASETS
+from .basesegdataset import BaseSegDataset
+
+
+@DATASETS.register_module()
+class ADE20KDataset(BaseSegDataset):
+    """ADE20K dataset.
+
+    In segmentation map annotation for ADE20K, 0 stands for background, which
+    is not included in 150 categories. ``reduce_zero_label`` is fixed to True.
+    The ``img_suffix`` is fixed to '.jpg' and ``seg_map_suffix`` is fixed to
+    '.png'.
+    """
+    METAINFO = dict(
+        classes=('wall', 'building', 'sky', 'floor', 'tree', 'ceiling', 'road',
+                 'bed ', 'windowpane', 'grass', 'cabinet', 'sidewalk',
+                 'person', 'earth', 'door', 'table', 'mountain', 'plant',
+                 'curtain', 'chair', 'car', 'water', 'painting', 'sofa',
+                 'shelf', 'house', 'sea', 'mirror', 'rug', 'field', 'armchair',
+                 'seat', 'fence', 'desk', 'rock', 'wardrobe', 'lamp',
+                 'bathtub', 'railing', 'cushion', 'base', 'box', 'column',
+                 'signboard', 'chest of drawers', 'counter', 'sand', 'sink',
+                 'skyscraper', 'fireplace', 'refrigerator', 'grandstand',
+                 'path', 'stairs', 'runway', 'case', 'pool table', 'pillow',
+                 'screen door', 'stairway', 'river', 'bridge', 'bookcase',
+                 'blind', 'coffee table', 'toilet', 'flower', 'book', 'hill',
+                 'bench', 'countertop', 'stove', 'palm', 'kitchen island',
+                 'computer', 'swivel chair', 'boat', 'bar', 'arcade machine',
+                 'hovel', 'bus', 'towel', 'light', 'truck', 'tower',
+                 'chandelier', 'awning', 'streetlight', 'booth',
+                 'television receiver', 'airplane', 'dirt track', 'apparel',
+                 'pole', 'land', 'bannister', 'escalator', 'ottoman', 'bottle',
+                 'buffet', 'poster', 'stage', 'van', 'ship', 'fountain',
+                 'conveyer belt', 'canopy', 'washer', 'plaything',
+                 'swimming pool', 'stool', 'barrel', 'basket', 'waterfall',
+                 'tent', 'bag', 'minibike', 'cradle', 'oven', 'ball', 'food',
+                 'step', 'tank', 'trade name', 'microwave', 'pot', 'animal',
+                 'bicycle', 'lake', 'dishwasher', 'screen', 'blanket',
+                 'sculpture', 'hood', 'sconce', 'vase', 'traffic light',
+                 'tray', 'ashcan', 'fan', 'pier', 'crt screen', 'plate',
+                 'monitor', 'bulletin board', 'shower', 'radiator', 'glass',
+                 'clock', 'flag'),
+        palette=[[120, 120, 120], [180, 120, 120], [6, 230, 230], [80, 50, 50],
+                 [4, 200, 3], [120, 120, 80], [140, 140, 140], [204, 5, 255],
+                 [230, 230, 230], [4, 250, 7], [224, 5, 255], [235, 255, 7],
+                 [150, 5, 61], [120, 120, 70], [8, 255, 51], [255, 6, 82],
+                 [143, 255, 140], [204, 255, 4], [255, 51, 7], [204, 70, 3],
+                 [0, 102, 200], [61, 230, 250], [255, 6, 51], [11, 102, 255],
+                 [255, 7, 71], [255, 9, 224], [9, 7, 230], [220, 220, 220],
+                 [255, 9, 92], [112, 9, 255], [8, 255, 214], [7, 255, 224],
+                 [255, 184, 6], [10, 255, 71], [255, 41, 10], [7, 255, 255],
+                 [224, 255, 8], [102, 8, 255], [255, 61, 6], [255, 194, 7],
+                 [255, 122, 8], [0, 255, 20], [255, 8, 41], [255, 5, 153],
+                 [6, 51, 255], [235, 12, 255], [160, 150, 20], [0, 163, 255],
+                 [140, 140, 140], [250, 10, 15], [20, 255, 0], [31, 255, 0],
+                 [255, 31, 0], [255, 224, 0], [153, 255, 0], [0, 0, 255],
+                 [255, 71, 0], [0, 235, 255], [0, 173, 255], [31, 0, 255],
+                 [11, 200, 200], [255, 82, 0], [0, 255, 245], [0, 61, 255],
+                 [0, 255, 112], [0, 255, 133], [255, 0, 0], [255, 163, 0],
+                 [255, 102, 0], [194, 255, 0], [0, 143, 255], [51, 255, 0],
+                 [0, 82, 255], [0, 255, 41], [0, 255, 173], [10, 0, 255],
+                 [173, 255, 0], [0, 255, 153], [255, 92, 0], [255, 0, 255],
+                 [255, 0, 245], [255, 0, 102], [255, 173, 0], [255, 0, 20],
+                 [255, 184, 184], [0, 31, 255], [0, 255, 61], [0, 71, 255],
+                 [255, 0, 204], [0, 255, 194], [0, 255, 82], [0, 10, 255],
+                 [0, 112, 255], [51, 0, 255], [0, 194, 255], [0, 122, 255],
+                 [0, 255, 163], [255, 153, 0], [0, 255, 10], [255, 112, 0],
+                 [143, 255, 0], [82, 0, 255], [163, 255, 0], [255, 235, 0],
+                 [8, 184, 170], [133, 0, 255], [0, 255, 92], [184, 0, 255],
+                 [255, 0, 31], [0, 184, 255], [0, 214, 255], [255, 0, 112],
+                 [92, 255, 0], [0, 224, 255], [112, 224, 255], [70, 184, 160],
+                 [163, 0, 255], [153, 0, 255], [71, 255, 0], [255, 0, 163],
+                 [255, 204, 0], [255, 0, 143], [0, 255, 235], [133, 255, 0],
+                 [255, 0, 235], [245, 0, 255], [255, 0, 122], [255, 245, 0],
+                 [10, 190, 212], [214, 255, 0], [0, 204, 255], [20, 0, 255],
+                 [255, 255, 0], [0, 153, 255], [0, 41, 255], [0, 255, 204],
+                 [41, 0, 255], [41, 255, 0], [173, 0, 255], [0, 245, 255],
+                 [71, 0, 255], [122, 0, 255], [0, 255, 184], [0, 92, 255],
+                 [184, 255, 0], [0, 133, 255], [255, 214, 0], [25, 194, 194],
+                 [102, 255, 0], [92, 0, 255]])
+
+    def __init__(self,
+                 img_suffix='.jpg',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=True,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/basesegdataset.py b/mmsegmentation/mmseg/datasets/basesegdataset.py
new file mode 100644
index 0000000..3a5c49c
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/basesegdataset.py
@@ -0,0 +1,552 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import os.path as osp
+from typing import Callable, Dict, List, Optional, Sequence, Union
+
+import mmengine
+import mmengine.fileio as fileio
+import numpy as np
+from mmengine.dataset import BaseDataset, Compose
+
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class BaseSegDataset(BaseDataset):
+    """Custom dataset for semantic segmentation. An example of file structure
+    is as followed.
+
+    .. code-block:: none
+
+        ├── data
+        │   ├── my_dataset
+        │   │   ├── img_dir
+        │   │   │   ├── train
+        │   │   │   │   ├── xxx{img_suffix}
+        │   │   │   │   ├── yyy{img_suffix}
+        │   │   │   │   ├── zzz{img_suffix}
+        │   │   │   ├── val
+        │   │   ├── ann_dir
+        │   │   │   ├── train
+        │   │   │   │   ├── xxx{seg_map_suffix}
+        │   │   │   │   ├── yyy{seg_map_suffix}
+        │   │   │   │   ├── zzz{seg_map_suffix}
+        │   │   │   ├── val
+
+    The img/gt_semantic_seg pair of BaseSegDataset should be of the same
+    except suffix. A valid img/gt_semantic_seg filename pair should be like
+    ``xxx{img_suffix}`` and ``xxx{seg_map_suffix}`` (extension is also included
+    in the suffix). If split is given, then ``xxx`` is specified in txt file.
+    Otherwise, all files in ``img_dir/``and ``ann_dir`` will be loaded.
+    Please refer to ``docs/en/tutorials/new_dataset.md`` for more details.
+
+
+    Args:
+        ann_file (str): Annotation file path. Defaults to ''.
+        metainfo (dict, optional): Meta information for dataset, such as
+            specify classes to load. Defaults to None.
+        data_root (str, optional): The root directory for ``data_prefix`` and
+            ``ann_file``. Defaults to None.
+        data_prefix (dict, optional): Prefix for training data. Defaults to
+            dict(img_path=None, seg_map_path=None).
+        img_suffix (str): Suffix of images. Default: '.jpg'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+        filter_cfg (dict, optional): Config for filter data. Defaults to None.
+        indices (int or Sequence[int], optional): Support using first few
+            data in annotation file to facilitate training/testing on a smaller
+            dataset. Defaults to None which means using all ``data_infos``.
+        serialize_data (bool, optional): Whether to hold memory using
+            serialized objects, when enabled, data loader workers can use
+            shared RAM from master process instead of making a copy. Defaults
+            to True.
+        pipeline (list, optional): Processing pipeline. Defaults to [].
+        test_mode (bool, optional): ``test_mode=True`` means in test phase.
+            Defaults to False.
+        lazy_init (bool, optional): Whether to load annotation during
+            instantiation. In some cases, such as visualization, only the meta
+            information of the dataset is needed, which is not necessary to
+            load annotation file. ``Basedataset`` can skip load annotations to
+            save time by set ``lazy_init=True``. Defaults to False.
+        max_refetch (int, optional): If ``Basedataset.prepare_data`` get a
+            None img. The maximum extra number of cycles to get a valid
+            image. Defaults to 1000.
+        ignore_index (int): The label index to be ignored. Default: 255
+        reduce_zero_label (bool): Whether to mark label zero as ignored.
+            Default to False.
+        backend_args (dict, Optional): Arguments to instantiate a file backend.
+            See https://mmengine.readthedocs.io/en/latest/api/fileio.htm
+            for details. Defaults to None.
+            Notes: mmcv>=2.0.0rc4, mmengine>=0.2.0 required.
+    """
+    METAINFO: dict = dict()
+
+    def __init__(self,
+                 ann_file: str = '',
+                 img_suffix='.jpg',
+                 seg_map_suffix='.png',
+                 metainfo: Optional[dict] = None,
+                 data_root: Optional[str] = None,
+                 data_prefix: dict = dict(img_path='', seg_map_path=''),
+                 filter_cfg: Optional[dict] = None,
+                 indices: Optional[Union[int, Sequence[int]]] = None,
+                 serialize_data: bool = True,
+                 pipeline: List[Union[dict, Callable]] = [],
+                 test_mode: bool = False,
+                 lazy_init: bool = False,
+                 max_refetch: int = 1000,
+                 ignore_index: int = 255,
+                 reduce_zero_label: bool = False,
+                 backend_args: Optional[dict] = None) -> None:
+
+        self.img_suffix = img_suffix
+        self.seg_map_suffix = seg_map_suffix
+        self.ignore_index = ignore_index
+        self.reduce_zero_label = reduce_zero_label
+        self.backend_args = backend_args.copy() if backend_args else None
+
+        self.data_root = data_root
+        self.data_prefix = copy.copy(data_prefix)
+        self.ann_file = ann_file
+        self.filter_cfg = copy.deepcopy(filter_cfg)
+        self._indices = indices
+        self.serialize_data = serialize_data
+        self.test_mode = test_mode
+        self.max_refetch = max_refetch
+        self.data_list: List[dict] = []
+        self.data_bytes: np.ndarray
+
+        # Set meta information.
+        self._metainfo = self._load_metainfo(copy.deepcopy(metainfo))
+
+        # Get label map for custom classes
+        new_classes = self._metainfo.get('classes', None)
+        self.label_map = self.get_label_map(new_classes)
+        self._metainfo.update(
+            dict(
+                label_map=self.label_map,
+                reduce_zero_label=self.reduce_zero_label))
+        
+        # Update palette based on label map or generate palette
+        # if it is not defined
+        updated_palette = self._update_palette()
+        self._metainfo.update(dict(palette=updated_palette))
+
+        # Join paths.
+        if self.data_root is not None:
+            self._join_prefix()
+
+        # Build pipeline.
+        self.pipeline = Compose(pipeline)
+        # Full initialize the dataset.
+        if not lazy_init:
+            self.full_init()
+
+        if test_mode:
+            assert self._metainfo.get('classes') is not None, \
+                'dataset metainfo `classes` should be specified when testing'
+
+    @classmethod
+    def get_label_map(cls,
+                      new_classes: Optional[Sequence] = None
+                      ) -> Union[Dict, None]:
+        """Require label mapping.
+
+        The ``label_map`` is a dictionary, its keys are the old label ids and
+        its values are the new label ids, and is used for changing pixel
+        labels in load_annotations. If and only if old classes in cls.METAINFO
+        is not equal to new classes in self._metainfo and nether of them is not
+        None, `label_map` is not None.
+
+        Args:
+            new_classes (list, tuple, optional): The new classes name from
+                metainfo. Default to None.
+
+
+        Returns:
+            dict, optional: The mapping from old classes in cls.METAINFO to
+                new classes in self._metainfo
+        """
+        old_classes = cls.METAINFO.get('classes', None)
+        if (new_classes is not None and old_classes is not None
+                and list(new_classes) != list(old_classes)):
+
+            label_map = {}
+            if not set(new_classes).issubset(cls.METAINFO['classes']):
+                raise ValueError(
+                    f'new classes {new_classes} is not a '
+                    f'subset of classes {old_classes} in METAINFO.')
+            for i, c in enumerate(old_classes):
+                if c not in new_classes:
+                    label_map[i] = 255
+                else:
+                    label_map[i] = new_classes.index(c)
+            return label_map
+        else:
+            return None
+
+    def _update_palette(self) -> list:
+        """Update palette after loading metainfo.
+
+        If length of palette is equal to classes, just return the palette.
+        If palette is not defined, it will randomly generate a palette.
+        If classes is updated by customer, it will return the subset of
+        palette.
+
+        Returns:
+            Sequence: Palette for current dataset.
+        """
+        palette = self._metainfo.get('palette', [])
+        classes = self._metainfo.get('classes', [])
+        # palette does match classes
+        if len(palette) == len(classes):
+            return palette
+
+        if len(palette) == 0:
+            # Get random state before set seed, and restore
+            # random state later.
+            # It will prevent loss of randomness, as the palette
+            # may be different in each iteration if not specified.
+            # See: https://github.com/open-mmlab/mmdetection/issues/5844
+            state = np.random.get_state()
+            np.random.seed(42)
+            # random palette
+            new_palette = np.random.randint(
+                0, 255, size=(len(classes), 3)).tolist()
+            np.random.set_state(state)
+        elif len(palette) >= len(classes) and self.label_map is not None:
+            new_palette = []
+            # return subset of palette
+            for old_id, new_id in sorted(
+                    self.label_map.items(), key=lambda x: x[1]):
+                if new_id != 255:
+                    new_palette.append(palette[old_id])
+            new_palette = type(palette)(new_palette)
+        else:
+            raise ValueError('palette does not match classes '
+                             f'as metainfo is {self._metainfo}.')
+        return new_palette
+
+    def load_data_list(self) -> List[dict]:
+        """Load annotation from directory or annotation file.
+
+        Returns:
+            list[dict]: All data info of dataset.
+        """
+        data_list = []
+        img_dir = self.data_prefix.get('img_path', None)
+        ann_dir = self.data_prefix.get('seg_map_path', None)
+        if not osp.isdir(self.ann_file) and self.ann_file:
+            assert osp.isfile(self.ann_file), \
+                f'Failed to load `ann_file` {self.ann_file}'
+            lines = mmengine.list_from_file(
+                self.ann_file, backend_args=self.backend_args)
+            for line in lines:
+                img_name = line.strip()
+                data_info = dict(
+                    img_path=osp.join(img_dir, img_name + self.img_suffix))
+                if ann_dir is not None:
+                    seg_map = img_name + self.seg_map_suffix
+                    data_info['seg_map_path'] = osp.join(ann_dir, seg_map)
+                data_info['label_map'] = self.label_map
+                data_info['reduce_zero_label'] = self.reduce_zero_label
+                data_info['seg_fields'] = []
+                data_list.append(data_info)
+        else:
+            _suffix_len = len(self.img_suffix)
+            for img in fileio.list_dir_or_file(
+                    dir_path=img_dir,
+                    list_dir=False,
+                    suffix=self.img_suffix,
+                    recursive=True,
+                    backend_args=self.backend_args):
+                data_info = dict(img_path=osp.join(img_dir, img))
+                if ann_dir is not None:
+                    seg_map = img[:-_suffix_len] + self.seg_map_suffix
+                    data_info['seg_map_path'] = osp.join(ann_dir, seg_map)
+                data_info['label_map'] = self.label_map
+                data_info['reduce_zero_label'] = self.reduce_zero_label
+                data_info['seg_fields'] = []
+                data_list.append(data_info)
+            data_list = sorted(data_list, key=lambda x: x['img_path'])
+        return data_list
+
+
+@DATASETS.register_module()
+class BaseCDDataset(BaseDataset):
+    """Custom dataset for change detection. An example of file structure is as
+    followed.
+
+    .. code-block:: none
+
+        ├── data
+        │   ├── my_dataset
+        │   │   ├── img_dir
+        │   │   │   ├── train
+        │   │   │   │   ├── xxx{img_suffix}
+        │   │   │   │   ├── yyy{img_suffix}
+        │   │   │   │   ├── zzz{img_suffix}
+        │   │   │   ├── val
+        │   │   ├── img_dir2
+        │   │   │   ├── train
+        │   │   │   │   ├── xxx{img_suffix}
+        │   │   │   │   ├── yyy{img_suffix}
+        │   │   │   │   ├── zzz{img_suffix}
+        │   │   │   ├── val
+        │   │   ├── ann_dir
+        │   │   │   ├── train
+        │   │   │   │   ├── xxx{seg_map_suffix}
+        │   │   │   │   ├── yyy{seg_map_suffix}
+        │   │   │   │   ├── zzz{seg_map_suffix}
+        │   │   │   ├── val
+
+    The image names in img_dir and img_dir2 should be consistent.
+    The img/gt_semantic_seg pair of BaseSegDataset should be of the same
+    except suffix. A valid img/gt_semantic_seg filename pair should be like
+    ``xxx{img_suffix}`` and ``xxx{seg_map_suffix}`` (extension is also included
+    in the suffix). If split is given, then ``xxx`` is specified in txt file.
+    Otherwise, all files in ``img_dir/``and ``ann_dir`` will be loaded.
+    Please refer to ``docs/en/tutorials/new_dataset.md`` for more details.
+
+
+    Args:
+        ann_file (str): Annotation file path. Defaults to ''.
+        metainfo (dict, optional): Meta information for dataset, such as
+            specify classes to load. Defaults to None.
+        data_root (str, optional): The root directory for ``data_prefix`` and
+            ``ann_file``. Defaults to None.
+        data_prefix (dict, optional): Prefix for training data. Defaults to
+            dict(img_path=None, img_path2=None, seg_map_path=None).
+        img_suffix (str): Suffix of images. Default: '.jpg'
+        img_suffix2 (str): Suffix of images. Default: '.jpg'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+        filter_cfg (dict, optional): Config for filter data. Defaults to None.
+        indices (int or Sequence[int], optional): Support using first few
+            data in annotation file to facilitate training/testing on a smaller
+            dataset. Defaults to None which means using all ``data_infos``.
+        serialize_data (bool, optional): Whether to hold memory using
+            serialized objects, when enabled, data loader workers can use
+            shared RAM from master process instead of making a copy. Defaults
+            to True.
+        pipeline (list, optional): Processing pipeline. Defaults to [].
+        test_mode (bool, optional): ``test_mode=True`` means in test phase.
+            Defaults to False.
+        lazy_init (bool, optional): Whether to load annotation during
+            instantiation. In some cases, such as visualization, only the meta
+            information of the dataset is needed, which is not necessary to
+            load annotation file. ``Basedataset`` can skip load annotations to
+            save time by set ``lazy_init=True``. Defaults to False.
+        max_refetch (int, optional): If ``Basedataset.prepare_data`` get a
+            None img. The maximum extra number of cycles to get a valid
+            image. Defaults to 1000.
+        ignore_index (int): The label index to be ignored. Default: 255
+        reduce_zero_label (bool): Whether to mark label zero as ignored.
+            Default to False.
+        backend_args (dict, Optional): Arguments to instantiate a file backend.
+            See https://mmengine.readthedocs.io/en/latest/api/fileio.htm
+            for details. Defaults to None.
+            Notes: mmcv>=2.0.0rc4, mmengine>=0.2.0 required.
+    """
+    METAINFO: dict = dict()
+
+    def __init__(self,
+                 ann_file: str = '',
+                 img_suffix='.jpg',
+                 img_suffix2='.jpg',
+                 seg_map_suffix='.png',
+                 metainfo: Optional[dict] = None,
+                 data_root: Optional[str] = None,
+                 data_prefix: dict = dict(
+                     img_path='', img_path2='', seg_map_path=''),
+                 filter_cfg: Optional[dict] = None,
+                 indices: Optional[Union[int, Sequence[int]]] = None,
+                 serialize_data: bool = True,
+                 pipeline: List[Union[dict, Callable]] = [],
+                 test_mode: bool = False,
+                 lazy_init: bool = False,
+                 max_refetch: int = 1000,
+                 ignore_index: int = 255,
+                 reduce_zero_label: bool = False,
+                 backend_args: Optional[dict] = None) -> None:
+
+        self.img_suffix = img_suffix
+        self.img_suffix2 = img_suffix2
+        self.seg_map_suffix = seg_map_suffix
+        self.ignore_index = ignore_index
+        self.reduce_zero_label = reduce_zero_label
+        self.backend_args = backend_args.copy() if backend_args else None
+
+        self.data_root = data_root
+        self.data_prefix = copy.copy(data_prefix)
+        self.ann_file = ann_file
+        self.filter_cfg = copy.deepcopy(filter_cfg)
+        self._indices = indices
+        self.serialize_data = serialize_data
+        self.test_mode = test_mode
+        self.max_refetch = max_refetch
+        self.data_list: List[dict] = []
+        self.data_bytes: np.ndarray
+
+        # Set meta information.
+        self._metainfo = self._load_metainfo(copy.deepcopy(metainfo))
+
+        # Get label map for custom classes
+        new_classes = self._metainfo.get('classes', None)
+        self.label_map = self.get_label_map(new_classes)
+        self._metainfo.update(
+            dict(
+                label_map=self.label_map,
+                reduce_zero_label=self.reduce_zero_label))
+
+        # Update palette based on label map or generate palette
+        # if it is not defined
+        updated_palette = self._update_palette()
+        self._metainfo.update(dict(palette=updated_palette))
+
+        # Join paths.
+        if self.data_root is not None:
+            self._join_prefix()
+
+        # Build pipeline.
+        self.pipeline = Compose(pipeline)
+        # Full initialize the dataset.
+        if not lazy_init:
+            self.full_init()
+
+        if test_mode:
+            assert self._metainfo.get('classes') is not None, \
+                'dataset metainfo `classes` should be specified when testing'
+
+    @classmethod
+    def get_label_map(cls,
+                      new_classes: Optional[Sequence] = None
+                      ) -> Union[Dict, None]:
+        """Require label mapping.
+
+        The ``label_map`` is a dictionary, its keys are the old label ids and
+        its values are the new label ids, and is used for changing pixel
+        labels in load_annotations. If and only if old classes in cls.METAINFO
+        is not equal to new classes in self._metainfo and nether of them is not
+        None, `label_map` is not None.
+
+        Args:
+            new_classes (list, tuple, optional): The new classes name from
+                metainfo. Default to None.
+
+
+        Returns:
+            dict, optional: The mapping from old classes in cls.METAINFO to
+                new classes in self._metainfo
+        """
+        old_classes = cls.METAINFO.get('classes', None)
+        if (new_classes is not None and old_classes is not None
+                and list(new_classes) != list(old_classes)):
+
+            label_map = {}
+            if not set(new_classes).issubset(cls.METAINFO['classes']):
+                raise ValueError(
+                    f'new classes {new_classes} is not a '
+                    f'subset of classes {old_classes} in METAINFO.')
+            for i, c in enumerate(old_classes):
+                if c not in new_classes:
+                    label_map[i] = 255
+                else:
+                    label_map[i] = new_classes.index(c)
+            return label_map
+        else:
+            return None
+
+    def _update_palette(self) -> list:
+        """Update palette after loading metainfo.
+
+        If length of palette is equal to classes, just return the palette.
+        If palette is not defined, it will randomly generate a palette.
+        If classes is updated by customer, it will return the subset of
+        palette.
+
+        Returns:
+            Sequence: Palette for current dataset.
+        """
+        palette = self._metainfo.get('palette', [])
+        classes = self._metainfo.get('classes', [])
+        # palette does match classes
+        if len(palette) == len(classes):
+            return palette
+
+        if len(palette) == 0:
+            # Get random state before set seed, and restore
+            # random state later.
+            # It will prevent loss of randomness, as the palette
+            # may be different in each iteration if not specified.
+            # See: https://github.com/open-mmlab/mmdetection/issues/5844
+            state = np.random.get_state()
+            np.random.seed(42)
+            # random palette
+            new_palette = np.random.randint(
+                0, 255, size=(len(classes), 3)).tolist()
+            np.random.set_state(state)
+        elif len(palette) >= len(classes) and self.label_map is not None:
+            new_palette = []
+            # return subset of palette
+            for old_id, new_id in sorted(
+                    self.label_map.items(), key=lambda x: x[1]):
+                if new_id != 255:
+                    new_palette.append(palette[old_id])
+            new_palette = type(palette)(new_palette)
+        else:
+            raise ValueError('palette does not match classes '
+                             f'as metainfo is {self._metainfo}.')
+        return new_palette
+
+    def load_data_list(self) -> List[dict]:
+        """Load annotation from directory or annotation file.
+
+        Returns:
+            list[dict]: All data info of dataset.
+        """
+        data_list = []
+        img_dir = self.data_prefix.get('img_path', None)
+        img_dir2 = self.data_prefix.get('img_path2', None)
+        ann_dir = self.data_prefix.get('seg_map_path', None)
+        if osp.isfile(self.ann_file):
+            lines = mmengine.list_from_file(
+                self.ann_file, backend_args=self.backend_args)
+            for line in lines:
+                img_name = line.strip()
+                if '.' in osp.basename(img_name):
+                    img_name, img_ext = osp.splitext(img_name)
+                    self.img_suffix = img_ext
+                    self.img_suffix2 = img_ext
+                data_info = dict(
+                    img_path=osp.join(img_dir, img_name + self.img_suffix),
+                    img_path2=osp.join(img_dir2, img_name + self.img_suffix2))
+
+                if ann_dir is not None:
+                    seg_map = img_name + self.seg_map_suffix
+                    data_info['seg_map_path'] = osp.join(ann_dir, seg_map)
+                data_info['label_map'] = self.label_map
+                data_info['reduce_zero_label'] = self.reduce_zero_label
+                data_info['seg_fields'] = []
+                data_list.append(data_info)
+        else:
+            for img in fileio.list_dir_or_file(
+                    dir_path=img_dir,
+                    list_dir=False,
+                    suffix=self.img_suffix,
+                    recursive=True,
+                    backend_args=self.backend_args):
+                if '.' in osp.basename(img):
+                    img, img_ext = osp.splitext(img)
+                    self.img_suffix = img_ext
+                    self.img_suffix2 = img_ext
+                data_info = dict(
+                    img_path=osp.join(img_dir, img + self.img_suffix),
+                    img_path2=osp.join(img_dir2, img + self.img_suffix2))
+                if ann_dir is not None:
+                    seg_map = img + self.seg_map_suffix
+                    data_info['seg_map_path'] = osp.join(ann_dir, seg_map)
+                data_info['label_map'] = self.label_map
+                data_info['reduce_zero_label'] = self.reduce_zero_label
+                data_info['seg_fields'] = []
+                data_list.append(data_info)
+            data_list = sorted(data_list, key=lambda x: x['img_path'])
+        return data_list
diff --git a/mmsegmentation/mmseg/datasets/bdd100k.py b/mmsegmentation/mmseg/datasets/bdd100k.py
new file mode 100644
index 0000000..8ae70b5
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/bdd100k.py
@@ -0,0 +1,30 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+from mmseg.datasets.basesegdataset import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class BDD100KDataset(BaseSegDataset):
+    METAINFO = dict(
+        classes=('road', 'sidewalk', 'building', 'wall', 'fence', 'pole',
+                 'traffic light', 'traffic sign', 'vegetation', 'terrain',
+                 'sky', 'person', 'rider', 'car', 'truck', 'bus', 'train',
+                 'motorcycle', 'bicycle'),
+        palette=[[128, 64, 128], [244, 35, 232], [70, 70, 70], [102, 102, 156],
+                 [190, 153, 153], [153, 153, 153], [250, 170,
+                                                    30], [220, 220, 0],
+                 [107, 142, 35], [152, 251, 152], [70, 130, 180],
+                 [220, 20, 60], [255, 0, 0], [0, 0, 142], [0, 0, 70],
+                 [0, 60, 100], [0, 80, 100], [0, 0, 230], [119, 11, 32]])
+
+    def __init__(self,
+                 img_suffix='.jpg',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/chase_db1.py b/mmsegmentation/mmseg/datasets/chase_db1.py
new file mode 100644
index 0000000..626ddf7
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/chase_db1.py
@@ -0,0 +1,32 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import mmengine.fileio as fileio
+
+from mmseg.registry import DATASETS
+from .basesegdataset import BaseSegDataset
+
+
+@DATASETS.register_module()
+class ChaseDB1Dataset(BaseSegDataset):
+    """Chase_db1 dataset.
+
+    In segmentation map annotation for Chase_db1, 0 stands for background,
+    which is included in 2 categories. ``reduce_zero_label`` is fixed to False.
+    The ``img_suffix`` is fixed to '.png' and ``seg_map_suffix`` is fixed to
+    '_1stHO.png'.
+    """
+    METAINFO = dict(
+        classes=('background', 'vessel'),
+        palette=[[120, 120, 120], [6, 230, 230]])
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='_1stHO.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
+        assert fileio.exists(
+            self.data_prefix['img_path'], backend_args=self.backend_args)
diff --git a/mmsegmentation/mmseg/datasets/cityscapes.py b/mmsegmentation/mmseg/datasets/cityscapes.py
new file mode 100644
index 0000000..f494d62
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/cityscapes.py
@@ -0,0 +1,30 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmseg.registry import DATASETS
+from .basesegdataset import BaseSegDataset
+
+
+@DATASETS.register_module()
+class CityscapesDataset(BaseSegDataset):
+    """Cityscapes dataset.
+
+    The ``img_suffix`` is fixed to '_leftImg8bit.png' and ``seg_map_suffix`` is
+    fixed to '_gtFine_labelTrainIds.png' for Cityscapes dataset.
+    """
+    METAINFO = dict(
+        classes=('road', 'sidewalk', 'building', 'wall', 'fence', 'pole',
+                 'traffic light', 'traffic sign', 'vegetation', 'terrain',
+                 'sky', 'person', 'rider', 'car', 'truck', 'bus', 'train',
+                 'motorcycle', 'bicycle'),
+        palette=[[128, 64, 128], [244, 35, 232], [70, 70, 70], [102, 102, 156],
+                 [190, 153, 153], [153, 153, 153], [250, 170,
+                                                    30], [220, 220, 0],
+                 [107, 142, 35], [152, 251, 152], [70, 130, 180],
+                 [220, 20, 60], [255, 0, 0], [0, 0, 142], [0, 0, 70],
+                 [0, 60, 100], [0, 80, 100], [0, 0, 230], [119, 11, 32]])
+
+    def __init__(self,
+                 img_suffix='_leftImg8bit.png',
+                 seg_map_suffix='_gtFine_labelTrainIds.png',
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/coco_stuff.py b/mmsegmentation/mmseg/datasets/coco_stuff.py
new file mode 100644
index 0000000..1e1574d
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/coco_stuff.py
@@ -0,0 +1,99 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmseg.registry import DATASETS
+from .basesegdataset import BaseSegDataset
+
+
+@DATASETS.register_module()
+class COCOStuffDataset(BaseSegDataset):
+    """COCO-Stuff dataset.
+
+    In segmentation map annotation for COCO-Stuff, Train-IDs of the 10k version
+    are from 1 to 171, where 0 is the ignore index, and Train-ID of COCO Stuff
+    164k is from 0 to 170, where 255 is the ignore index. So, they are all 171
+    semantic categories. ``reduce_zero_label`` is set to True and False for the
+    10k and 164k versions, respectively. The ``img_suffix`` is fixed to '.jpg',
+    and ``seg_map_suffix`` is fixed to '.png'.
+    """
+    METAINFO = dict(
+        classes=(
+            'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',
+            'train', 'truck', 'boat', 'traffic light', 'fire hydrant',
+            'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog',
+            'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe',
+            'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee',
+            'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat',
+            'baseball glove', 'skateboard', 'surfboard', 'tennis racket',
+            'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl',
+            'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot',
+            'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch',
+            'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop',
+            'mouse', 'remote', 'keyboard', 'cell phone', 'microwave', 'oven',
+            'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',
+            'scissors', 'teddy bear', 'hair drier', 'toothbrush', 'banner',
+            'blanket', 'branch', 'bridge', 'building-other', 'bush', 'cabinet',
+            'cage', 'cardboard', 'carpet', 'ceiling-other', 'ceiling-tile',
+            'cloth', 'clothes', 'clouds', 'counter', 'cupboard', 'curtain',
+            'desk-stuff', 'dirt', 'door-stuff', 'fence', 'floor-marble',
+            'floor-other', 'floor-stone', 'floor-tile', 'floor-wood', 'flower',
+            'fog', 'food-other', 'fruit', 'furniture-other', 'grass', 'gravel',
+            'ground-other', 'hill', 'house', 'leaves', 'light', 'mat', 'metal',
+            'mirror-stuff', 'moss', 'mountain', 'mud', 'napkin', 'net',
+            'paper', 'pavement', 'pillow', 'plant-other', 'plastic',
+            'platform', 'playingfield', 'railing', 'railroad', 'river', 'road',
+            'rock', 'roof', 'rug', 'salad', 'sand', 'sea', 'shelf',
+            'sky-other', 'skyscraper', 'snow', 'solid-other', 'stairs',
+            'stone', 'straw', 'structural-other', 'table', 'tent',
+            'textile-other', 'towel', 'tree', 'vegetable', 'wall-brick',
+            'wall-concrete', 'wall-other', 'wall-panel', 'wall-stone',
+            'wall-tile', 'wall-wood', 'water-other', 'waterdrops',
+            'window-blind', 'window-other', 'wood'),
+        palette=[[0, 192, 64], [0, 192, 64], [0, 64, 96], [128, 192, 192],
+                 [0, 64, 64], [0, 192, 224], [0, 192, 192], [128, 192, 64],
+                 [0, 192, 96], [128, 192, 64], [128, 32, 192], [0, 0, 224],
+                 [0, 0, 64], [0, 160, 192], [128, 0, 96], [128, 0, 192],
+                 [0, 32, 192], [128, 128, 224], [0, 0, 192], [128, 160, 192],
+                 [128, 128, 0], [128, 0, 32], [128, 32, 0], [128, 0, 128],
+                 [64, 128, 32], [0, 160, 0], [0, 0, 0], [192, 128, 160],
+                 [0, 32, 0], [0, 128, 128], [64, 128, 160], [128, 160, 0],
+                 [0, 128, 0], [192, 128, 32], [128, 96, 128], [0, 0, 128],
+                 [64, 0, 32], [0, 224, 128], [128, 0, 0], [192, 0, 160],
+                 [0, 96, 128], [128, 128, 128], [64, 0, 160], [128, 224, 128],
+                 [128, 128, 64], [192, 0, 32], [128, 96, 0], [128, 0, 192],
+                 [0, 128, 32], [64, 224, 0], [0, 0, 64], [128, 128, 160],
+                 [64, 96, 0], [0, 128, 192], [0, 128, 160], [192, 224, 0],
+                 [0, 128, 64], [128, 128, 32], [192, 32, 128], [0, 64, 192],
+                 [0, 0, 32], [64, 160, 128], [128, 64, 64], [128, 0, 160],
+                 [64, 32, 128], [128, 192, 192], [0, 0, 160], [192, 160, 128],
+                 [128, 192, 0], [128, 0, 96], [192, 32, 0], [128, 64, 128],
+                 [64, 128, 96], [64, 160, 0], [0, 64, 0], [192, 128, 224],
+                 [64, 32, 0], [0, 192, 128], [64, 128, 224], [192, 160, 0],
+                 [0, 192, 0], [192, 128, 96], [192, 96, 128], [0, 64, 128],
+                 [64, 0, 96], [64, 224, 128], [128, 64, 0], [192, 0, 224],
+                 [64, 96, 128], [128, 192, 128], [64, 0, 224], [192, 224, 128],
+                 [128, 192, 64], [192, 0, 96], [192, 96, 0], [128, 64, 192],
+                 [0, 128, 96], [0, 224, 0], [64, 64, 64], [128, 128, 224],
+                 [0, 96, 0], [64, 192, 192], [0, 128, 224], [128, 224, 0],
+                 [64, 192, 64], [128, 128, 96], [128, 32, 128], [64, 0, 192],
+                 [0, 64, 96], [0, 160, 128], [192, 0, 64], [128, 64, 224],
+                 [0, 32, 128], [192, 128, 192], [0, 64, 224], [128, 160, 128],
+                 [192, 128, 0], [128, 64, 32], [128, 32, 64], [192, 0, 128],
+                 [64, 192, 32], [0, 160, 64], [64, 0, 0], [192, 192, 160],
+                 [0, 32, 64], [64, 128, 128], [64, 192, 160], [128, 160, 64],
+                 [64, 128, 0], [192, 192, 32], [128, 96, 192], [64, 0, 128],
+                 [64, 64, 32], [0, 224, 192], [192, 0, 0], [192, 64, 160],
+                 [0, 96, 192], [192, 128, 128], [64, 64, 160], [128, 224, 192],
+                 [192, 128, 64], [192, 64, 32], [128, 96, 64], [192, 0, 192],
+                 [0, 192, 32], [64, 224, 64], [64, 0, 64], [128, 192, 160],
+                 [64, 96, 64], [64, 128, 192], [0, 192, 160], [192, 224, 64],
+                 [64, 128, 64], [128, 192, 32], [192, 32, 192], [64, 64, 192],
+                 [0, 64, 32], [64, 160, 192], [192, 64, 64], [128, 64, 160],
+                 [64, 32, 192], [192, 192, 192], [0, 64, 160], [192, 160, 192],
+                 [192, 192, 0], [128, 64, 96], [192, 32, 64], [192, 64, 128],
+                 [64, 192, 96], [64, 160, 64], [64, 64, 0]])
+
+    def __init__(self,
+                 img_suffix='.jpg',
+                 seg_map_suffix='_labelTrainIds.png',
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/dark_zurich.py b/mmsegmentation/mmseg/datasets/dark_zurich.py
new file mode 100644
index 0000000..9b5393f
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/dark_zurich.py
@@ -0,0 +1,15 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmseg.registry import DATASETS
+from .cityscapes import CityscapesDataset
+
+
+@DATASETS.register_module()
+class DarkZurichDataset(CityscapesDataset):
+    """DarkZurichDataset dataset."""
+
+    def __init__(self,
+                 img_suffix='_rgb_anon.png',
+                 seg_map_suffix='_gt_labelTrainIds.png',
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/dataset_wrappers.py b/mmsegmentation/mmseg/datasets/dataset_wrappers.py
new file mode 100644
index 0000000..082c116
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/dataset_wrappers.py
@@ -0,0 +1,136 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import collections
+import copy
+from typing import List, Optional, Sequence, Union
+
+from mmengine.dataset import ConcatDataset, force_full_init
+
+from mmseg.registry import DATASETS, TRANSFORMS
+
+
+@DATASETS.register_module()
+class MultiImageMixDataset:
+    """A wrapper of multiple images mixed dataset.
+
+    Suitable for training on multiple images mixed data augmentation like
+    mosaic and mixup.
+
+    Args:
+        dataset (ConcatDataset or dict): The dataset to be mixed.
+        pipeline (Sequence[dict]): Sequence of transform object or
+            config dict to be composed.
+        skip_type_keys (list[str], optional): Sequence of type string to
+            be skip pipeline. Default to None.
+    """
+
+    def __init__(self,
+                 dataset: Union[ConcatDataset, dict],
+                 pipeline: Sequence[dict],
+                 skip_type_keys: Optional[List[str]] = None,
+                 lazy_init: bool = False) -> None:
+        assert isinstance(pipeline, collections.abc.Sequence)
+
+        if isinstance(dataset, dict):
+            self.dataset = DATASETS.build(dataset)
+        elif isinstance(dataset, ConcatDataset):
+            self.dataset = dataset
+        else:
+            raise TypeError(
+                'elements in datasets sequence should be config or '
+                f'`ConcatDataset` instance, but got {type(dataset)}')
+
+        if skip_type_keys is not None:
+            assert all([
+                isinstance(skip_type_key, str)
+                for skip_type_key in skip_type_keys
+            ])
+        self._skip_type_keys = skip_type_keys
+
+        self.pipeline = []
+        self.pipeline_types = []
+        for transform in pipeline:
+            if isinstance(transform, dict):
+                self.pipeline_types.append(transform['type'])
+                transform = TRANSFORMS.build(transform)
+                self.pipeline.append(transform)
+            else:
+                raise TypeError('pipeline must be a dict')
+
+        self._metainfo = self.dataset.metainfo
+        self.num_samples = len(self.dataset)
+
+        self._fully_initialized = False
+        if not lazy_init:
+            self.full_init()
+
+    @property
+    def metainfo(self) -> dict:
+        """Get the meta information of the multi-image-mixed dataset.
+
+        Returns:
+            dict: The meta information of multi-image-mixed dataset.
+        """
+        return copy.deepcopy(self._metainfo)
+
+    def full_init(self):
+        """Loop to ``full_init`` each dataset."""
+        if self._fully_initialized:
+            return
+
+        self.dataset.full_init()
+        self._ori_len = len(self.dataset)
+        self._fully_initialized = True
+
+    @force_full_init
+    def get_data_info(self, idx: int) -> dict:
+        """Get annotation by index.
+
+        Args:
+            idx (int): Global index of ``ConcatDataset``.
+
+        Returns:
+            dict: The idx-th annotation of the datasets.
+        """
+        return self.dataset.get_data_info(idx)
+
+    @force_full_init
+    def __len__(self):
+        return self.num_samples
+
+    def __getitem__(self, idx):
+        results = copy.deepcopy(self.dataset[idx])
+        for (transform, transform_type) in zip(self.pipeline,
+                                               self.pipeline_types):
+            if self._skip_type_keys is not None and \
+                    transform_type in self._skip_type_keys:
+                continue
+
+            if hasattr(transform, 'get_indices'):
+                indices = transform.get_indices(self.dataset)
+                if not isinstance(indices, collections.abc.Sequence):
+                    indices = [indices]
+                mix_results = [
+                    copy.deepcopy(self.dataset[index]) for index in indices
+                ]
+                results['mix_results'] = mix_results
+
+            results = transform(results)
+
+            if 'mix_results' in results:
+                results.pop('mix_results')
+
+        return results
+
+    def update_skip_type_keys(self, skip_type_keys):
+        """Update skip_type_keys.
+
+        It is called by an external hook.
+
+        Args:
+            skip_type_keys (list[str], optional): Sequence of type
+                string to be skip pipeline.
+        """
+        assert all([
+            isinstance(skip_type_key, str) for skip_type_key in skip_type_keys
+        ])
+        self._skip_type_keys = skip_type_keys
diff --git a/mmsegmentation/mmseg/datasets/decathlon.py b/mmsegmentation/mmseg/datasets/decathlon.py
new file mode 100644
index 0000000..26aa4ef
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/decathlon.py
@@ -0,0 +1,96 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import os.path as osp
+from typing import List
+
+from mmengine.fileio import load
+
+from mmseg.registry import DATASETS
+from .basesegdataset import BaseSegDataset
+
+
+@DATASETS.register_module()
+class DecathlonDataset(BaseSegDataset):
+    """Dataset for Dacathlon dataset.
+
+    The dataset.json format is shown as follows
+
+    .. code-block:: none
+
+        {
+            "name": "BRATS",
+            "tensorImageSize": "4D",
+            "modality":
+            {
+                "0": "FLAIR",
+                "1": "T1w",
+                "2": "t1gd",
+                "3": "T2w"
+            },
+            "labels": {
+                "0": "background",
+                "1": "edema",
+                "2": "non-enhancing tumor",
+                "3": "enhancing tumour"
+            },
+            "numTraining": 484,
+            "numTest": 266,
+            "training":
+            [
+                {
+                    "image": "./imagesTr/BRATS_306.nii.gz"
+                    "label": "./labelsTr/BRATS_306.nii.gz"
+                    ...
+                }
+            ]
+            "test":
+            [
+                "./imagesTs/BRATS_557.nii.gz"
+                ...
+            ]
+        }
+    """
+
+    def load_data_list(self) -> List[dict]:
+        """Load annotation from directory or annotation file.
+
+        Returns:
+            list[dict]: All data info of dataset.
+        """
+        # `self.ann_file` denotes the absolute annotation file path if
+        # `self.root=None` or relative path if `self.root=/path/to/data/`.
+        annotations = load(self.ann_file)
+        if not isinstance(annotations, dict):
+            raise TypeError(f'The annotations loaded from annotation file '
+                            f'should be a dict, but got {type(annotations)}!')
+        raw_data_list = annotations[
+            'training'] if not self.test_mode else annotations['test']
+        data_list = []
+        for raw_data_info in raw_data_list:
+            # `2:` works for removing './' in file path, which will break
+            # loading from cloud storage.
+            if isinstance(raw_data_info, dict):
+                data_info = dict(
+                    img_path=osp.join(self.data_root, raw_data_info['image']
+                                      [2:]))
+                data_info['seg_map_path'] = osp.join(
+                    self.data_root, raw_data_info['label'][2:])
+            else:
+                data_info = dict(
+                    img_path=osp.join(self.data_root, raw_data_info)[2:])
+            data_info['label_map'] = self.label_map
+            data_info['reduce_zero_label'] = self.reduce_zero_label
+            data_info['seg_fields'] = []
+            data_list.append(data_info)
+        annotations.pop('training')
+        annotations.pop('test')
+
+        metainfo = copy.deepcopy(annotations)
+        metainfo['classes'] = [*metainfo['labels'].values()]
+        # Meta information load from annotation file will not influence the
+        # existed meta information load from `BaseDataset.METAINFO` and
+        # `metainfo` arguments defined in constructor.
+        for k, v in metainfo.items():
+            self._metainfo.setdefault(k, v)
+
+        return data_list
diff --git a/mmsegmentation/mmseg/datasets/drive.py b/mmsegmentation/mmseg/datasets/drive.py
new file mode 100644
index 0000000..76c0160
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/drive.py
@@ -0,0 +1,32 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import mmengine.fileio as fileio
+
+from mmseg.registry import DATASETS
+from .basesegdataset import BaseSegDataset
+
+
+@DATASETS.register_module()
+class DRIVEDataset(BaseSegDataset):
+    """DRIVE dataset.
+
+    In segmentation map annotation for DRIVE, 0 stands for background, which is
+    included in 2 categories. ``reduce_zero_label`` is fixed to False. The
+    ``img_suffix`` is fixed to '.png' and ``seg_map_suffix`` is fixed to
+    '_manual1.png'.
+    """
+    METAINFO = dict(
+        classes=('background', 'vessel'),
+        palette=[[120, 120, 120], [6, 230, 230]])
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='_manual1.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
+        assert fileio.exists(
+            self.data_prefix['img_path'], backend_args=self.backend_args)
diff --git a/mmsegmentation/mmseg/datasets/dsdl.py b/mmsegmentation/mmseg/datasets/dsdl.py
new file mode 100644
index 0000000..bf7e4e6
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/dsdl.py
@@ -0,0 +1,116 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os
+from typing import Dict, List, Optional, Sequence, Union
+
+from mmseg.registry import DATASETS
+from .basesegdataset import BaseSegDataset
+
+try:
+    from dsdl.dataset import DSDLDataset
+except ImportError:
+    DSDLDataset = None
+
+
+@DATASETS.register_module()
+class DSDLSegDataset(BaseSegDataset):
+    """Dataset for dsdl segmentation.
+
+    Args:
+        specific_key_path(dict): Path of specific key which can not
+            be loaded by it's field name.
+        pre_transform(dict): pre-transform functions before loading.
+        used_labels(sequence): list of actual used classes in train steps,
+            this must be subset of class domain.
+    """
+
+    METAINFO = {}
+
+    def __init__(self,
+                 specific_key_path: Dict = {},
+                 pre_transform: Dict = {},
+                 used_labels: Optional[Sequence] = None,
+                 **kwargs) -> None:
+
+        if DSDLDataset is None:
+            raise RuntimeError(
+                'Package dsdl is not installed. Please run "pip install dsdl".'
+            )
+        self.used_labels = used_labels
+
+        loc_config = dict(type='LocalFileReader', working_dir='')
+        if kwargs.get('data_root'):
+            kwargs['ann_file'] = os.path.join(kwargs['data_root'],
+                                              kwargs['ann_file'])
+        required_fields = ['Image', 'LabelMap']
+
+        self.dsdldataset = DSDLDataset(
+            dsdl_yaml=kwargs['ann_file'],
+            location_config=loc_config,
+            required_fields=required_fields,
+            specific_key_path=specific_key_path,
+            transform=pre_transform,
+        )
+        BaseSegDataset.__init__(self, **kwargs)
+
+    def load_data_list(self) -> List[Dict]:
+        """Load data info from a dsdl yaml file named as ``self.ann_file``
+
+        Returns:
+            List[dict]: A list of data list.
+        """
+
+        if self.used_labels:
+            self._metainfo['classes'] = tuple(self.used_labels)
+            self.label_map = self.get_label_map(self.used_labels)
+        else:
+            self._metainfo['classes'] = tuple(['background'] +
+                                              self.dsdldataset.class_names)
+        data_list = []
+
+        for i, data in enumerate(self.dsdldataset):
+            datainfo = dict(
+                img_path=os.path.join(self.data_prefix['img_path'],
+                                      data['Image'][0].location),
+                seg_map_path=os.path.join(self.data_prefix['seg_map_path'],
+                                          data['LabelMap'][0].location),
+                label_map=self.label_map,
+                reduce_zero_label=self.reduce_zero_label,
+                seg_fields=[],
+            )
+            data_list.append(datainfo)
+
+        return data_list
+
+    def get_label_map(self,
+                      new_classes: Optional[Sequence] = None
+                      ) -> Union[Dict, None]:
+        """Require label mapping.
+
+        The ``label_map`` is a dictionary, its keys are the old label ids and
+        its values are the new label ids, and is used for changing pixel
+        labels in load_annotations. If and only if old classes in class_dom
+        is not equal to new classes in args and nether of them is not
+        None, `label_map` is not None.
+        Args:
+            new_classes (list, tuple, optional): The new classes name from
+                metainfo. Default to None.
+        Returns:
+            dict, optional: The mapping from old classes to new classes.
+        """
+        old_classes = ['background'] + self.dsdldataset.class_names
+        if (new_classes is not None and old_classes is not None
+                and list(new_classes) != list(old_classes)):
+
+            label_map = {}
+            if not set(new_classes).issubset(old_classes):
+                raise ValueError(
+                    f'new classes {new_classes} is not a '
+                    f'subset of classes {old_classes} in class_dom.')
+            for i, c in enumerate(old_classes):
+                if c not in new_classes:
+                    label_map[i] = 255
+                else:
+                    label_map[i] = new_classes.index(c)
+            return label_map
+        else:
+            return None
diff --git a/mmsegmentation/mmseg/datasets/hrf.py b/mmsegmentation/mmseg/datasets/hrf.py
new file mode 100644
index 0000000..fd669cc
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/hrf.py
@@ -0,0 +1,32 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import mmengine.fileio as fileio
+
+from mmseg.registry import DATASETS
+from .basesegdataset import BaseSegDataset
+
+
+@DATASETS.register_module()
+class HRFDataset(BaseSegDataset):
+    """HRF dataset.
+
+    In segmentation map annotation for HRF, 0 stands for background, which is
+    included in 2 categories. ``reduce_zero_label`` is fixed to False. The
+    ``img_suffix`` is fixed to '.png' and ``seg_map_suffix`` is fixed to
+    '.png'.
+    """
+    METAINFO = dict(
+        classes=('background', 'vessel'),
+        palette=[[120, 120, 120], [6, 230, 230]])
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
+        assert fileio.exists(
+            self.data_prefix['img_path'], backend_args=self.backend_args)
diff --git a/mmsegmentation/mmseg/datasets/hsi_drive.py b/mmsegmentation/mmseg/datasets/hsi_drive.py
new file mode 100644
index 0000000..3d46a86
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/hsi_drive.py
@@ -0,0 +1,42 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+classes_exp = ('unlabelled', 'road', 'road marks', 'vegetation',
+               'painted metal', 'sky', 'concrete', 'pedestrian', 'water',
+               'unpainted metal', 'glass')
+palette_exp = [[0, 0, 0], [77, 77, 77], [255, 255, 255], [0, 255, 0],
+               [255, 0, 0], [0, 0, 255], [102, 51, 0], [255, 255, 0],
+               [0, 207, 250], [255, 166, 0], [0, 204, 204]]
+
+
+@DATASETS.register_module()
+class HSIDrive20Dataset(BaseSegDataset):
+    """HSI-Drive v2.0 (https://ieeexplore.ieee.org/document/10371793), the
+    updated version of HSI-Drive
+    (https://ieeexplore.ieee.org/document/9575298), is a structured dataset for
+    the research and development of automated driving systems (ADS) supported
+    by hyperspectral imaging (HSI). It contains per-pixel manually annotated
+    images selected from videos recorded in real driving conditions and has
+    been organized according to four parameters: season, daytime, road type,
+    and weather conditions.
+
+    The video sequences have been captured with a small-size 25-band VNIR
+    (Visible-NearlnfraRed) snapshot hyperspectral camera mounted on a driving
+    automobile. As a consequence, you need to modify the in_channels parameter
+    of your model from 3 (RGB images) to 25 (HSI images) as it is done in
+    configs/unet/unet-s5-d16_fcn_4xb4-160k_hsidrive-192x384.py
+
+    Apart from the abovementioned articles, additional information is provided
+    in the website (https://ipaccess.ehu.eus/HSI-Drive/) from where you can
+    download the dataset and also visualize some examples of segmented videos.
+    """
+
+    METAINFO = dict(classes=classes_exp, palette=palette_exp)
+
+    def __init__(self,
+                 img_suffix='.npy',
+                 seg_map_suffix='.png',
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/isaid.py b/mmsegmentation/mmseg/datasets/isaid.py
new file mode 100644
index 0000000..61942ec
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/isaid.py
@@ -0,0 +1,39 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import mmengine.fileio as fileio
+
+from mmseg.registry import DATASETS
+from .basesegdataset import BaseSegDataset
+
+
+@DATASETS.register_module()
+class iSAIDDataset(BaseSegDataset):
+    """ iSAID: A Large-scale Dataset for Instance Segmentation in Aerial Images
+    In segmentation map annotation for iSAID dataset, which is included
+    in 16 categories. ``reduce_zero_label`` is fixed to False. The
+    ``img_suffix`` is fixed to '.png' and ``seg_map_suffix`` is fixed to
+    '_manual1.png'.
+    """
+
+    METAINFO = dict(
+        classes=('background', 'ship', 'store_tank', 'baseball_diamond',
+                 'tennis_court', 'basketball_court', 'Ground_Track_Field',
+                 'Bridge', 'Large_Vehicle', 'Small_Vehicle', 'Helicopter',
+                 'Swimming_pool', 'Roundabout', 'Soccer_ball_field', 'plane',
+                 'Harbor'),
+        palette=[[0, 0, 0], [0, 0, 63], [0, 63, 63], [0, 63, 0], [0, 63, 127],
+                 [0, 63, 191], [0, 63, 255], [0, 127, 63], [0, 127, 127],
+                 [0, 0, 127], [0, 0, 191], [0, 0, 255], [0, 191, 127],
+                 [0, 127, 191], [0, 127, 255], [0, 100, 155]])
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='_instance_color_RGB.png',
+                 ignore_index=255,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            ignore_index=ignore_index,
+            **kwargs)
+        assert fileio.exists(
+            self.data_prefix['img_path'], backend_args=self.backend_args)
diff --git a/mmsegmentation/mmseg/datasets/isprs.py b/mmsegmentation/mmseg/datasets/isprs.py
new file mode 100644
index 0000000..30af53c
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/isprs.py
@@ -0,0 +1,29 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmseg.registry import DATASETS
+from .basesegdataset import BaseSegDataset
+
+
+@DATASETS.register_module()
+class ISPRSDataset(BaseSegDataset):
+    """ISPRS dataset.
+
+    In segmentation map annotation for ISPRS, 0 is the ignore index.
+    ``reduce_zero_label`` should be set to True. The ``img_suffix`` and
+    ``seg_map_suffix`` are both fixed to '.png'.
+    """
+    METAINFO = dict(
+        classes=('impervious_surface', 'building', 'low_vegetation', 'tree',
+                 'car', 'clutter'),
+        palette=[[255, 255, 255], [0, 0, 255], [0, 255, 255], [0, 255, 0],
+                 [255, 255, 0], [255, 0, 0]])
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=True,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/levir.py b/mmsegmentation/mmseg/datasets/levir.py
new file mode 100644
index 0000000..f467481
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/levir.py
@@ -0,0 +1,31 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+from mmseg.registry import DATASETS
+from .basesegdataset import BaseCDDataset
+
+
+@DATASETS.register_module()
+class LEVIRCDDataset(BaseCDDataset):
+    """ISPRS dataset.
+
+    In segmentation map annotation for ISPRS, 0 is to ignore index.
+    ``reduce_zero_label`` should be set to True. The ``img_suffix`` and
+    ``seg_map_suffix`` are both fixed to '.png'.
+    """
+
+    METAINFO = dict(
+        classes=('background', 'changed'),
+        palette=[[0, 0, 0], [255, 255, 255]])
+
+    def __init__(self,
+                 img_suffix='.png',
+                 img_suffix2='.png',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            img_suffix2=img_suffix2,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/lip.py b/mmsegmentation/mmseg/datasets/lip.py
new file mode 100644
index 0000000..3a32a19
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/lip.py
@@ -0,0 +1,47 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmseg.registry import DATASETS
+from .basesegdataset import BaseSegDataset
+
+
+@DATASETS.register_module()
+class LIPDataset(BaseSegDataset):
+    """LIP dataset.
+
+    The ``img_suffix`` is fixed to '.jpg' and ``seg_map_suffix`` is fixed to
+    '.png'.
+    """
+    METAINFO = dict(
+        classes=('Background', 'Hat', 'Hair', 'Glove', 'Sunglasses',
+                 'UpperClothes', 'Dress', 'Coat', 'Socks', 'Pants',
+                 'Jumpsuits', 'Scarf', 'Skirt', 'Face', 'Left-arm',
+                 'Right-arm', 'Left-leg', 'Right-leg', 'Left-shoe',
+                 'Right-shoe'),
+        palette=(
+            [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 __init__(self,
+                 img_suffix='.jpg',
+                 seg_map_suffix='.png',
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/loveda.py b/mmsegmentation/mmseg/datasets/loveda.py
new file mode 100644
index 0000000..5c16db5
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/loveda.py
@@ -0,0 +1,29 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmseg.registry import DATASETS
+from .basesegdataset import BaseSegDataset
+
+
+@DATASETS.register_module()
+class LoveDADataset(BaseSegDataset):
+    """LoveDA dataset.
+
+    In segmentation map annotation for LoveDA, 0 is the ignore index.
+    ``reduce_zero_label`` should be set to True. The ``img_suffix`` and
+    ``seg_map_suffix`` are both fixed to '.png'.
+    """
+    METAINFO = dict(
+        classes=('background', 'building', 'road', 'water', 'barren', 'forest',
+                 'agricultural'),
+        palette=[[255, 255, 255], [255, 0, 0], [255, 255, 0], [0, 0, 255],
+                 [159, 129, 183], [0, 255, 0], [255, 195, 128]])
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=True,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/mapillary.py b/mmsegmentation/mmseg/datasets/mapillary.py
new file mode 100644
index 0000000..6c29473
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/mapillary.py
@@ -0,0 +1,176 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmseg.registry import DATASETS
+from .basesegdataset import BaseSegDataset
+
+
+@DATASETS.register_module()
+class MapillaryDataset_v1(BaseSegDataset):
+    """Mapillary Vistas Dataset.
+
+    Dataset paper link:
+    http://ieeexplore.ieee.org/document/8237796/
+
+    v1.2 contain 66 object classes.
+    (37 instance-specific)
+
+    v2.0 contain 124 object classes.
+    (70 instance-specific, 46 stuff, 8 void or crowd).
+
+    The ``img_suffix`` is fixed to '.jpg' and ``seg_map_suffix`` is
+    fixed to '.png' for Mapillary Vistas Dataset.
+    """
+    METAINFO = dict(
+        classes=('Bird', 'Ground Animal', 'Curb', 'Fence', 'Guard Rail',
+                 'Barrier', 'Wall', 'Bike Lane', 'Crosswalk - Plain',
+                 'Curb Cut', 'Parking', 'Pedestrian Area', 'Rail Track',
+                 'Road', 'Service Lane', 'Sidewalk', 'Bridge', 'Building',
+                 'Tunnel', 'Person', 'Bicyclist', 'Motorcyclist',
+                 'Other Rider', 'Lane Marking - Crosswalk',
+                 'Lane Marking - General', 'Mountain', 'Sand', 'Sky', 'Snow',
+                 'Terrain', 'Vegetation', 'Water', 'Banner', 'Bench',
+                 'Bike Rack', 'Billboard', 'Catch Basin', 'CCTV Camera',
+                 'Fire Hydrant', 'Junction Box', 'Mailbox', 'Manhole',
+                 'Phone Booth', 'Pothole', 'Street Light', 'Pole',
+                 'Traffic Sign Frame', 'Utility Pole', 'Traffic Light',
+                 'Traffic Sign (Back)', 'Traffic Sign (Front)', 'Trash Can',
+                 'Bicycle', 'Boat', 'Bus', 'Car', 'Caravan', 'Motorcycle',
+                 'On Rails', 'Other Vehicle', 'Trailer', 'Truck',
+                 'Wheeled Slow', 'Car Mount', 'Ego Vehicle', 'Unlabeled'),
+        palette=[[165, 42, 42], [0, 192, 0], [196, 196, 196], [190, 153, 153],
+                 [180, 165, 180], [90, 120, 150], [102, 102, 156],
+                 [128, 64, 255], [140, 140, 200], [170, 170, 170],
+                 [250, 170, 160], [96, 96, 96],
+                 [230, 150, 140], [128, 64, 128], [110, 110, 110],
+                 [244, 35, 232], [150, 100, 100], [70, 70, 70], [150, 120, 90],
+                 [220, 20, 60], [255, 0, 0], [255, 0, 100], [255, 0, 200],
+                 [200, 128, 128], [255, 255, 255], [64, 170,
+                                                    64], [230, 160, 50],
+                 [70, 130, 180], [190, 255, 255], [152, 251, 152],
+                 [107, 142, 35], [0, 170, 30], [255, 255, 128], [250, 0, 30],
+                 [100, 140, 180], [220, 220, 220], [220, 128, 128],
+                 [222, 40, 40], [100, 170, 30], [40, 40, 40], [33, 33, 33],
+                 [100, 128, 160], [142, 0, 0], [70, 100, 150], [210, 170, 100],
+                 [153, 153, 153], [128, 128, 128], [0, 0, 80], [250, 170, 30],
+                 [192, 192, 192], [220, 220, 0], [140, 140, 20], [119, 11, 32],
+                 [150, 0, 255], [0, 60, 100], [0, 0, 142], [0, 0, 90],
+                 [0, 0, 230], [0, 80, 100], [128, 64, 64], [0, 0, 110],
+                 [0, 0, 70], [0, 0, 192], [32, 32, 32], [120, 10,
+                                                         10], [0, 0, 0]])
+
+    def __init__(self,
+                 img_suffix='.jpg',
+                 seg_map_suffix='.png',
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
+
+
+@DATASETS.register_module()
+class MapillaryDataset_v2(BaseSegDataset):
+    """Mapillary Vistas Dataset.
+
+    Dataset paper link:
+    http://ieeexplore.ieee.org/document/8237796/
+
+    v1.2 contain 66 object classes.
+    (37 instance-specific)
+
+    v2.0 contain 124 object classes.
+    (70 instance-specific, 46 stuff, 8 void or crowd).
+
+    The ``img_suffix`` is fixed to '.jpg' and ``seg_map_suffix`` is
+    fixed to '.png' for Mapillary Vistas Dataset.
+    """
+    METAINFO = dict(
+        classes=(
+            'Bird', 'Ground Animal', 'Ambiguous Barrier', 'Concrete Block',
+            'Curb', 'Fence', 'Guard Rail', 'Barrier', 'Road Median',
+            'Road Side', 'Lane Separator', 'Temporary Barrier', 'Wall',
+            'Bike Lane', 'Crosswalk - Plain', 'Curb Cut', 'Driveway',
+            'Parking', 'Parking Aisle', 'Pedestrian Area', 'Rail Track',
+            'Road', 'Road Shoulder', 'Service Lane', 'Sidewalk',
+            'Traffic Island', 'Bridge', 'Building', 'Garage', 'Tunnel',
+            'Person', 'Person Group', 'Bicyclist', 'Motorcyclist',
+            'Other Rider', 'Lane Marking - Dashed Line',
+            'Lane Marking - Straight Line', 'Lane Marking - Zigzag Line',
+            'Lane Marking - Ambiguous', 'Lane Marking - Arrow (Left)',
+            'Lane Marking - Arrow (Other)', 'Lane Marking - Arrow (Right)',
+            'Lane Marking - Arrow (Split Left or Straight)',
+            'Lane Marking - Arrow (Split Right or Straight)',
+            'Lane Marking - Arrow (Straight)', 'Lane Marking - Crosswalk',
+            'Lane Marking - Give Way (Row)',
+            'Lane Marking - Give Way (Single)',
+            'Lane Marking - Hatched (Chevron)',
+            'Lane Marking - Hatched (Diagonal)', 'Lane Marking - Other',
+            'Lane Marking - Stop Line', 'Lane Marking - Symbol (Bicycle)',
+            'Lane Marking - Symbol (Other)', 'Lane Marking - Text',
+            'Lane Marking (only) - Dashed Line',
+            'Lane Marking (only) - Crosswalk', 'Lane Marking (only) - Other',
+            'Lane Marking (only) - Test', 'Mountain', 'Sand', 'Sky', 'Snow',
+            'Terrain', 'Vegetation', 'Water', 'Banner', 'Bench', 'Bike Rack',
+            'Catch Basin', 'CCTV Camera', 'Fire Hydrant', 'Junction Box',
+            'Mailbox', 'Manhole', 'Parking Meter', 'Phone Booth', 'Pothole',
+            'Signage - Advertisement', 'Signage - Ambiguous', 'Signage - Back',
+            'Signage - Information', 'Signage - Other', 'Signage - Store',
+            'Street Light', 'Pole', 'Pole Group', 'Traffic Sign Frame',
+            'Utility Pole', 'Traffic Cone', 'Traffic Light - General (Single)',
+            'Traffic Light - Pedestrians', 'Traffic Light - General (Upright)',
+            'Traffic Light - General (Horizontal)', 'Traffic Light - Cyclists',
+            'Traffic Light - Other', 'Traffic Sign - Ambiguous',
+            'Traffic Sign (Back)', 'Traffic Sign - Direction (Back)',
+            'Traffic Sign - Direction (Front)', 'Traffic Sign (Front)',
+            'Traffic Sign - Parking', 'Traffic Sign - Temporary (Back)',
+            'Traffic Sign - Temporary (Front)', 'Trash Can', 'Bicycle', 'Boat',
+            'Bus', 'Car', 'Caravan', 'Motorcycle', 'On Rails', 'Other Vehicle',
+            'Trailer', 'Truck', 'Vehicle Group', 'Wheeled Slow', 'Water Valve',
+            'Car Mount', 'Dynamic', 'Ego Vehicle', 'Ground', 'Static',
+            'Unlabeled'),
+        palette=[[165, 42, 42], [0, 192, 0], [250, 170, 31], [250, 170, 32],
+                 [196, 196, 196], [190, 153, 153], [180, 165, 180],
+                 [90, 120, 150], [250, 170, 33], [250, 170, 34],
+                 [128, 128, 128], [250, 170, 35], [102, 102, 156],
+                 [128, 64, 255], [140, 140, 200], [170, 170, 170],
+                 [250, 170, 36], [250, 170, 160], [250, 170, 37], [96, 96, 96],
+                 [230, 150, 140], [128, 64, 128], [110, 110, 110],
+                 [110, 110, 110], [244, 35, 232], [128, 196,
+                                                   128], [150, 100, 100],
+                 [70, 70, 70], [150, 150, 150], [150, 120, 90], [220, 20, 60],
+                 [220, 20, 60], [255, 0, 0], [255, 0, 100], [255, 0, 200],
+                 [255, 255, 255], [255, 255, 255], [250, 170, 29],
+                 [250, 170, 28], [250, 170, 26], [250, 170,
+                                                  25], [250, 170, 24],
+                 [250, 170, 22], [250, 170, 21], [250, 170,
+                                                  20], [255, 255, 255],
+                 [250, 170, 19], [250, 170, 18], [250, 170,
+                                                  12], [250, 170, 11],
+                 [255, 255, 255], [255, 255, 255], [250, 170, 16],
+                 [250, 170, 15], [250, 170, 15], [255, 255, 255],
+                 [255, 255, 255], [255, 255, 255], [255, 255, 255],
+                 [64, 170, 64], [230, 160, 50],
+                 [70, 130, 180], [190, 255, 255], [152, 251, 152],
+                 [107, 142, 35], [0, 170, 30], [255, 255, 128], [250, 0, 30],
+                 [100, 140, 180], [220, 128, 128], [222, 40,
+                                                    40], [100, 170, 30],
+                 [40, 40, 40], [33, 33, 33], [100, 128, 160], [20, 20, 255],
+                 [142, 0, 0], [70, 100, 150], [250, 171, 30], [250, 172, 30],
+                 [250, 173, 30], [250, 174, 30], [250, 175,
+                                                  30], [250, 176, 30],
+                 [210, 170, 100], [153, 153, 153], [153, 153, 153],
+                 [128, 128, 128], [0, 0, 80], [210, 60, 60], [250, 170, 30],
+                 [250, 170, 30], [250, 170, 30], [250, 170,
+                                                  30], [250, 170, 30],
+                 [250, 170, 30], [192, 192, 192], [192, 192, 192],
+                 [192, 192, 192], [220, 220, 0], [220, 220, 0], [0, 0, 196],
+                 [192, 192, 192], [220, 220, 0], [140, 140, 20], [119, 11, 32],
+                 [150, 0, 255], [0, 60, 100], [0, 0, 142], [0, 0, 90],
+                 [0, 0, 230], [0, 80, 100], [128, 64, 64], [0, 0, 110],
+                 [0, 0, 70], [0, 0, 142], [0, 0, 192], [170, 170, 170],
+                 [32, 32, 32], [111, 74, 0], [120, 10, 10], [81, 0, 81],
+                 [111, 111, 0], [0, 0, 0]])
+
+    def __init__(self,
+                 img_suffix='.jpg',
+                 seg_map_suffix='.png',
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/night_driving.py b/mmsegmentation/mmseg/datasets/night_driving.py
new file mode 100644
index 0000000..3ead91e
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/night_driving.py
@@ -0,0 +1,15 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmseg.registry import DATASETS
+from .cityscapes import CityscapesDataset
+
+
+@DATASETS.register_module()
+class NightDrivingDataset(CityscapesDataset):
+    """NightDrivingDataset dataset."""
+
+    def __init__(self,
+                 img_suffix='_leftImg8bit.png',
+                 seg_map_suffix='_gtCoarse_labelTrainIds.png',
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/nyu.py b/mmsegmentation/mmseg/datasets/nyu.py
new file mode 100644
index 0000000..fcfda46
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/nyu.py
@@ -0,0 +1,123 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+from typing import List
+
+import mmengine.fileio as fileio
+
+from mmseg.registry import DATASETS
+from .basesegdataset import BaseSegDataset
+
+
+@DATASETS.register_module()
+class NYUDataset(BaseSegDataset):
+    """NYU depth estimation dataset. The file structure should be.
+
+    .. code-block:: none
+
+        ├── data
+        │   ├── nyu
+        │   │   ├── images
+        │   │   │   ├── train
+        │   │   │   │   ├── scene_xxx.jpg
+        │   │   │   │   ├── ...
+        │   │   │   ├── test
+        │   │   ├── annotations
+        │   │   │   ├── train
+        │   │   │   │   ├── scene_xxx.png
+        │   │   │   │   ├── ...
+        │   │   │   ├── test
+
+    Args:
+        ann_file (str): Annotation file path. Defaults to ''.
+        metainfo (dict, optional): Meta information for dataset, such as
+            specify classes to load. Defaults to None.
+        data_root (str, optional): The root directory for ``data_prefix`` and
+            ``ann_file``. Defaults to None.
+        data_prefix (dict, optional): Prefix for training data. Defaults to
+            dict(img_path='images', depth_map_path='annotations').
+        img_suffix (str): Suffix of images. Default: '.jpg'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+        filter_cfg (dict, optional): Config for filter data. Defaults to None.
+        indices (int or Sequence[int], optional): Support using first few
+            data in annotation file to facilitate training/testing on a smaller
+            dataset. Defaults to None which means using all ``data_infos``.
+        serialize_data (bool, optional): Whether to hold memory using
+            serialized objects, when enabled, data loader workers can use
+            shared RAM from master process instead of making a copy. Defaults
+            to True.
+        pipeline (list, optional): Processing pipeline. Defaults to [].
+        test_mode (bool, optional): ``test_mode=True`` means in test phase.
+            Defaults to False.
+        lazy_init (bool, optional): Whether to load annotation during
+            instantiation. In some cases, such as visualization, only the meta
+            information of the dataset is needed, which is not necessary to
+            load annotation file. ``Basedataset`` can skip load annotations to
+            save time by set ``lazy_init=True``. Defaults to False.
+        max_refetch (int, optional): If ``Basedataset.prepare_data`` get a
+            None img. The maximum extra number of cycles to get a valid
+            image. Defaults to 1000.
+        ignore_index (int): The label index to be ignored. Default: 255
+        reduce_zero_label (bool): Whether to mark label zero as ignored.
+            Default to False.
+        backend_args (dict, Optional): Arguments to instantiate a file backend.
+            See https://mmengine.readthedocs.io/en/latest/api/fileio.htm
+            for details. Defaults to None.
+            Notes: mmcv>=2.0.0rc4, mmengine>=0.2.0 required.
+    """
+    METAINFO = dict(
+        classes=('printer_room', 'bathroom', 'living_room', 'study',
+                 'conference_room', 'study_room', 'kitchen', 'home_office',
+                 'bedroom', 'dinette', 'playroom', 'indoor_balcony',
+                 'laundry_room', 'basement', 'excercise_room', 'foyer',
+                 'home_storage', 'cafe', 'furniture_store', 'office_kitchen',
+                 'student_lounge', 'dining_room', 'reception_room',
+                 'computer_lab', 'classroom', 'office', 'bookstore'))
+
+    def __init__(self,
+                 data_prefix=dict(
+                     img_path='images', depth_map_path='annotations'),
+                 img_suffix='.jpg',
+                 depth_map_suffix='.png',
+                 **kwargs) -> None:
+        super().__init__(
+            data_prefix=data_prefix,
+            img_suffix=img_suffix,
+            seg_map_suffix=depth_map_suffix,
+            **kwargs)
+
+    def _get_category_id_from_filename(self, image_fname: str) -> int:
+        """Retrieve the category ID from the given image filename."""
+        image_fname = osp.basename(image_fname)
+        position = image_fname.find(next(filter(str.isdigit, image_fname)), 0)
+        categoty_name = image_fname[:position - 1]
+        if categoty_name not in self._metainfo['classes']:
+            return -1
+        else:
+            return self._metainfo['classes'].index(categoty_name)
+
+    def load_data_list(self) -> List[dict]:
+        """Load annotation from directory or annotation file.
+
+        Returns:
+            list[dict]: All data info of dataset.
+        """
+        data_list = []
+        img_dir = self.data_prefix.get('img_path', None)
+        ann_dir = self.data_prefix.get('depth_map_path', None)
+
+        _suffix_len = len(self.img_suffix)
+        for img in fileio.list_dir_or_file(
+                dir_path=img_dir,
+                list_dir=False,
+                suffix=self.img_suffix,
+                recursive=True,
+                backend_args=self.backend_args):
+            data_info = dict(img_path=osp.join(img_dir, img))
+            if ann_dir is not None:
+                depth_map = img[:-_suffix_len] + self.seg_map_suffix
+                data_info['depth_map_path'] = osp.join(ann_dir, depth_map)
+            data_info['seg_fields'] = []
+            data_info['category_id'] = self._get_category_id_from_filename(img)
+            data_list.append(data_info)
+        data_list = sorted(data_list, key=lambda x: x['img_path'])
+        return data_list
diff --git a/mmsegmentation/mmseg/datasets/pascal_context.py b/mmsegmentation/mmseg/datasets/pascal_context.py
new file mode 100644
index 0000000..82d00a9
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/pascal_context.py
@@ -0,0 +1,116 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import mmengine.fileio as fileio
+
+from mmseg.registry import DATASETS
+from .basesegdataset import BaseSegDataset
+
+
+@DATASETS.register_module()
+class PascalContextDataset(BaseSegDataset):
+    """PascalContext dataset.
+
+    In segmentation map annotation for PascalContext, 0 stands for background,
+    which is included in 60 categories. ``reduce_zero_label`` is fixed to
+    False. The ``img_suffix`` is fixed to '.jpg' and ``seg_map_suffix`` is
+    fixed to '.png'.
+
+    Args:
+        ann_file (str): Annotation file path.
+    """
+
+    METAINFO = dict(
+        classes=('background', 'aeroplane', 'bag', 'bed', 'bedclothes',
+                 'bench', 'bicycle', 'bird', 'boat', 'book', 'bottle',
+                 'building', 'bus', 'cabinet', 'car', 'cat', 'ceiling',
+                 'chair', 'cloth', 'computer', 'cow', 'cup', 'curtain', 'dog',
+                 'door', 'fence', 'floor', 'flower', 'food', 'grass', 'ground',
+                 'horse', 'keyboard', 'light', 'motorbike', 'mountain',
+                 'mouse', 'person', 'plate', 'platform', 'pottedplant', 'road',
+                 'rock', 'sheep', 'shelves', 'sidewalk', 'sign', 'sky', 'snow',
+                 'sofa', 'table', 'track', 'train', 'tree', 'truck',
+                 'tvmonitor', 'wall', 'water', 'window', 'wood'),
+        palette=[[120, 120, 120], [180, 120, 120], [6, 230, 230], [80, 50, 50],
+                 [4, 200, 3], [120, 120, 80], [140, 140, 140], [204, 5, 255],
+                 [230, 230, 230], [4, 250, 7], [224, 5, 255], [235, 255, 7],
+                 [150, 5, 61], [120, 120, 70], [8, 255, 51], [255, 6, 82],
+                 [143, 255, 140], [204, 255, 4], [255, 51, 7], [204, 70, 3],
+                 [0, 102, 200], [61, 230, 250], [255, 6, 51], [11, 102, 255],
+                 [255, 7, 71], [255, 9, 224], [9, 7, 230], [220, 220, 220],
+                 [255, 9, 92], [112, 9, 255], [8, 255, 214], [7, 255, 224],
+                 [255, 184, 6], [10, 255, 71], [255, 41, 10], [7, 255, 255],
+                 [224, 255, 8], [102, 8, 255], [255, 61, 6], [255, 194, 7],
+                 [255, 122, 8], [0, 255, 20], [255, 8, 41], [255, 5, 153],
+                 [6, 51, 255], [235, 12, 255], [160, 150, 20], [0, 163, 255],
+                 [140, 140, 140], [250, 10, 15], [20, 255, 0], [31, 255, 0],
+                 [255, 31, 0], [255, 224, 0], [153, 255, 0], [0, 0, 255],
+                 [255, 71, 0], [0, 235, 255], [0, 173, 255], [31, 0, 255]])
+
+    def __init__(self,
+                 ann_file='',
+                 img_suffix='.jpg',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            ann_file=ann_file,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
+        assert fileio.exists(self.data_prefix['img_path'], self.backend_args)
+
+
+@DATASETS.register_module()
+class PascalContextDataset59(BaseSegDataset):
+    """PascalContext dataset.
+
+    In segmentation map annotation for PascalContext, 0 stands for background,
+    which is included in 60 categories. ``reduce_zero_label`` is fixed to
+    True. The ``img_suffix`` is fixed to '.jpg' and ``seg_map_suffix`` is
+    fixed to '.png'.
+    Noted: If the background is 255 and the ids of categories are from 0 to 58,
+    ``reduce_zero_label`` needs to be set to False.
+
+    Args:
+        ann_file (str): Annotation file path.
+    """
+    METAINFO = dict(
+        classes=('aeroplane', 'bag', 'bed', 'bedclothes', 'bench', 'bicycle',
+                 'bird', 'boat', 'book', 'bottle', 'building', 'bus',
+                 'cabinet', 'car', 'cat', 'ceiling', 'chair', 'cloth',
+                 'computer', 'cow', 'cup', 'curtain', 'dog', 'door', 'fence',
+                 'floor', 'flower', 'food', 'grass', 'ground', 'horse',
+                 'keyboard', 'light', 'motorbike', 'mountain', 'mouse',
+                 'person', 'plate', 'platform', 'pottedplant', 'road', 'rock',
+                 'sheep', 'shelves', 'sidewalk', 'sign', 'sky', 'snow', 'sofa',
+                 'table', 'track', 'train', 'tree', 'truck', 'tvmonitor',
+                 'wall', 'water', 'window', 'wood'),
+        palette=[[180, 120, 120], [6, 230, 230], [80, 50, 50], [4, 200, 3],
+                 [120, 120, 80], [140, 140, 140], [204, 5, 255],
+                 [230, 230, 230], [4, 250, 7], [224, 5, 255], [235, 255, 7],
+                 [150, 5, 61], [120, 120, 70], [8, 255, 51], [255, 6, 82],
+                 [143, 255, 140], [204, 255, 4], [255, 51, 7], [204, 70, 3],
+                 [0, 102, 200], [61, 230, 250], [255, 6, 51], [11, 102, 255],
+                 [255, 7, 71], [255, 9, 224], [9, 7, 230], [220, 220, 220],
+                 [255, 9, 92], [112, 9, 255], [8, 255, 214], [7, 255, 224],
+                 [255, 184, 6], [10, 255, 71], [255, 41, 10], [7, 255, 255],
+                 [224, 255, 8], [102, 8, 255], [255, 61, 6], [255, 194, 7],
+                 [255, 122, 8], [0, 255, 20], [255, 8, 41], [255, 5, 153],
+                 [6, 51, 255], [235, 12, 255], [160, 150, 20], [0, 163, 255],
+                 [140, 140, 140], [250, 10, 15], [20, 255, 0], [31, 255, 0],
+                 [255, 31, 0], [255, 224, 0], [153, 255, 0], [0, 0, 255],
+                 [255, 71, 0], [0, 235, 255], [0, 173, 255], [31, 0, 255]])
+
+    def __init__(self,
+                 ann_file='',
+                 img_suffix='.jpg',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=True,
+                 **kwargs):
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            ann_file=ann_file,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
+        assert fileio.exists(self.data_prefix['img_path'], self.backend_args)
diff --git a/mmsegmentation/mmseg/datasets/potsdam.py b/mmsegmentation/mmseg/datasets/potsdam.py
new file mode 100644
index 0000000..6892de3
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/potsdam.py
@@ -0,0 +1,29 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmseg.registry import DATASETS
+from .basesegdataset import BaseSegDataset
+
+
+@DATASETS.register_module()
+class PotsdamDataset(BaseSegDataset):
+    """ISPRS Potsdam dataset.
+
+    In segmentation map annotation for Potsdam dataset, 0 is the ignore index.
+    ``reduce_zero_label`` should be set to True. The ``img_suffix`` and
+    ``seg_map_suffix`` are both fixed to '.png'.
+    """
+    METAINFO = dict(
+        classes=('impervious_surface', 'building', 'low_vegetation', 'tree',
+                 'car', 'clutter'),
+        palette=[[255, 255, 255], [0, 0, 255], [0, 255, 255], [0, 255, 0],
+                 [255, 255, 0], [255, 0, 0]])
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=True,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/refuge.py b/mmsegmentation/mmseg/datasets/refuge.py
new file mode 100644
index 0000000..4016a82
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/refuge.py
@@ -0,0 +1,28 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import mmengine.fileio as fileio
+
+from mmseg.registry import DATASETS
+from .basesegdataset import BaseSegDataset
+
+
+@DATASETS.register_module()
+class REFUGEDataset(BaseSegDataset):
+    """REFUGE dataset.
+
+    In segmentation map annotation for REFUGE, 0 stands for background, which
+    is not included in 2 categories. ``reduce_zero_label`` is fixed to True.
+    The ``img_suffix`` is fixed to '.png' and ``seg_map_suffix`` is fixed to
+    '.png'.
+    """
+    METAINFO = dict(
+        classes=('background', ' Optic Cup', 'Optic Disc'),
+        palette=[[120, 120, 120], [6, 230, 230], [56, 59, 120]])
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(
+            img_suffix='.png',
+            seg_map_suffix='.png',
+            reduce_zero_label=False,
+            **kwargs)
+        assert fileio.exists(
+            self.data_prefix['img_path'], backend_args=self.backend_args)
diff --git a/mmsegmentation/mmseg/datasets/stare.py b/mmsegmentation/mmseg/datasets/stare.py
new file mode 100644
index 0000000..1b997bb
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/stare.py
@@ -0,0 +1,32 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import mmengine.fileio as fileio
+
+from mmseg.registry import DATASETS
+from .basesegdataset import BaseSegDataset
+
+
+@DATASETS.register_module()
+class STAREDataset(BaseSegDataset):
+    """STARE dataset.
+
+    In segmentation map annotation for STARE, 0 stands for background, which is
+    included in 2 categories. ``reduce_zero_label`` is fixed to False. The
+    ``img_suffix`` is fixed to '.png' and ``seg_map_suffix`` is fixed to
+    '.ah.png'.
+    """
+    METAINFO = dict(
+        classes=('background', 'vessel'),
+        palette=[[120, 120, 120], [6, 230, 230]])
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.ah.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
+        assert fileio.exists(
+            self.data_prefix['img_path'], backend_args=self.backend_args)
diff --git a/mmsegmentation/mmseg/datasets/synapse.py b/mmsegmentation/mmseg/datasets/synapse.py
new file mode 100644
index 0000000..6f83b64
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/synapse.py
@@ -0,0 +1,28 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmseg.registry import DATASETS
+from .basesegdataset import BaseSegDataset
+
+
+@DATASETS.register_module()
+class SynapseDataset(BaseSegDataset):
+    """Synapse dataset.
+
+    Before dataset preprocess of Synapse, there are total 13 categories of
+    foreground which does not include background. After preprocessing, 8
+    foreground categories are kept while the other 5 foreground categories are
+    handled as background. The ``img_suffix`` is fixed to '.jpg' and
+    ``seg_map_suffix`` is fixed to '.png'.
+    """
+    METAINFO = dict(
+        classes=('background', 'aorta', 'gallbladder', 'left_kidney',
+                 'right_kidney', 'liver', 'pancreas', 'spleen', 'stomach'),
+        palette=[[0, 0, 0], [0, 0, 255], [0, 255, 0], [255, 0, 0],
+                 [0, 255, 255], [255, 0, 255], [255, 255, 0], [60, 255, 255],
+                 [240, 240, 240]])
+
+    def __init__(self,
+                 img_suffix='.jpg',
+                 seg_map_suffix='.png',
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/transforms/__init__.py b/mmsegmentation/mmseg/datasets/transforms/__init__.py
new file mode 100644
index 0000000..125f070
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/transforms/__init__.py
@@ -0,0 +1,30 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .formatting import PackSegInputs
+from .loading import (LoadAnnotations, LoadBiomedicalAnnotation,
+                      LoadBiomedicalData, LoadBiomedicalImageFromFile,
+                      LoadDepthAnnotation, LoadImageFromNDArray,
+                      LoadMultipleRSImageFromFile, LoadSingleRSImageFromFile)
+# yapf: disable
+from .transforms import (CLAHE, AdjustGamma, Albu, BioMedical3DPad,
+                         BioMedical3DRandomCrop, BioMedical3DRandomFlip,
+                         BioMedicalGaussianBlur, BioMedicalGaussianNoise,
+                         BioMedicalRandomGamma, ConcatCDInput, GenerateEdge,
+                         PhotoMetricDistortion, RandomCrop, RandomCutOut,
+                         RandomDepthMix, RandomFlip, RandomMosaic,
+                         RandomRotate, RandomRotFlip, Rerange, Resize,
+                         ResizeShortestEdge, ResizeToMultiple, RGB2Gray,
+                         SegRescale)
+
+# yapf: enable
+__all__ = [
+    'LoadAnnotations', 'RandomCrop', 'BioMedical3DRandomCrop', 'SegRescale',
+    'PhotoMetricDistortion', 'RandomRotate', 'AdjustGamma', 'CLAHE', 'Rerange',
+    'RGB2Gray', 'RandomCutOut', 'RandomMosaic', 'PackSegInputs',
+    'ResizeToMultiple', 'LoadImageFromNDArray', 'LoadBiomedicalImageFromFile',
+    'LoadBiomedicalAnnotation', 'LoadBiomedicalData', 'GenerateEdge',
+    'ResizeShortestEdge', 'BioMedicalGaussianNoise', 'BioMedicalGaussianBlur',
+    'BioMedical3DRandomFlip', 'BioMedicalRandomGamma', 'BioMedical3DPad',
+    'RandomRotFlip', 'Albu', 'LoadSingleRSImageFromFile', 'ConcatCDInput',
+    'LoadMultipleRSImageFromFile', 'LoadDepthAnnotation', 'RandomDepthMix',
+    'RandomFlip', 'Resize'
+]
diff --git a/mmsegmentation/mmseg/datasets/transforms/formatting.py b/mmsegmentation/mmseg/datasets/transforms/formatting.py
new file mode 100644
index 0000000..bd25055
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/transforms/formatting.py
@@ -0,0 +1,112 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+import numpy as np
+from mmcv.transforms import to_tensor
+from mmcv.transforms.base import BaseTransform
+from mmengine.structures import PixelData
+
+from mmseg.registry import TRANSFORMS
+from mmseg.structures import SegDataSample
+
+
+@TRANSFORMS.register_module()
+class PackSegInputs(BaseTransform):
+    """Pack the inputs data for the semantic segmentation.
+
+    The ``img_meta`` item is always populated.  The contents of the
+    ``img_meta`` dictionary depends on ``meta_keys``. By default this includes:
+
+        - ``img_path``: filename of the image
+
+        - ``ori_shape``: original shape of the image as a tuple (h, w, c)
+
+        - ``img_shape``: shape of the image input to the network as a tuple \
+            (h, w, c).  Note that images may be zero padded on the \
+            bottom/right if the batch tensor is larger than this shape.
+
+        - ``pad_shape``: shape of padded images
+
+        - ``scale_factor``: a float indicating the preprocessing scale
+
+        - ``flip``: a boolean indicating if image flip transform was used
+
+        - ``flip_direction``: the flipping direction
+
+    Args:
+        meta_keys (Sequence[str], optional): Meta keys to be packed from
+            ``SegDataSample`` and collected in ``data[img_metas]``.
+            Default: ``('img_path', 'ori_shape',
+            'img_shape', 'pad_shape', 'scale_factor', 'flip',
+            'flip_direction')``
+    """
+
+    def __init__(self,
+                 meta_keys=('img_path', 'seg_map_path', 'ori_shape',
+                            'img_shape', 'pad_shape', 'scale_factor', 'flip',
+                            'flip_direction', 'reduce_zero_label')):
+        self.meta_keys = meta_keys
+
+    def transform(self, results: dict) -> dict:
+        """Method to pack the input data.
+
+        Args:
+            results (dict): Result dict from the data pipeline.
+
+        Returns:
+            dict:
+
+            - 'inputs' (obj:`torch.Tensor`): The forward data of models.
+            - 'data_sample' (obj:`SegDataSample`): The annotation info of the
+                sample.
+        """
+        packed_results = dict()
+        if 'img' in results:
+            img = results['img']
+            if len(img.shape) < 3:
+                img = np.expand_dims(img, -1)
+            if not img.flags.c_contiguous:
+                img = to_tensor(np.ascontiguousarray(img.transpose(2, 0, 1)))
+            else:
+                img = img.transpose(2, 0, 1)
+                img = to_tensor(img).contiguous()
+            packed_results['inputs'] = img
+
+        data_sample = SegDataSample()
+        if 'gt_seg_map' in results:
+            if len(results['gt_seg_map'].shape) == 2:
+                data = to_tensor(results['gt_seg_map'][None,
+                                                       ...].astype(np.int64))
+            else:
+                warnings.warn('Please pay attention your ground truth '
+                              'segmentation map, usually the segmentation '
+                              'map is 2D, but got '
+                              f'{results["gt_seg_map"].shape}')
+                data = to_tensor(results['gt_seg_map'].astype(np.int64))
+            gt_sem_seg_data = dict(data=data)
+            data_sample.gt_sem_seg = PixelData(**gt_sem_seg_data)
+
+        if 'gt_edge_map' in results:
+            gt_edge_data = dict(
+                data=to_tensor(results['gt_edge_map'][None,
+                                                      ...].astype(np.int64)))
+            data_sample.set_data(dict(gt_edge_map=PixelData(**gt_edge_data)))
+
+        if 'gt_depth_map' in results:
+            gt_depth_data = dict(
+                data=to_tensor(results['gt_depth_map'][None, ...]))
+            data_sample.set_data(dict(gt_depth_map=PixelData(**gt_depth_data)))
+
+        img_meta = {}
+        for key in self.meta_keys:
+            if key in results:
+                img_meta[key] = results[key]
+        data_sample.set_metainfo(img_meta)
+        packed_results['data_samples'] = data_sample
+
+        return packed_results
+
+    def __repr__(self) -> str:
+        repr_str = self.__class__.__name__
+        repr_str += f'(meta_keys={self.meta_keys})'
+        return repr_str
diff --git a/mmsegmentation/mmseg/datasets/transforms/loading.py b/mmsegmentation/mmseg/datasets/transforms/loading.py
new file mode 100644
index 0000000..c28937e
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/transforms/loading.py
@@ -0,0 +1,771 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+from pathlib import Path
+from typing import Dict, Optional, Union
+
+import mmcv
+import mmengine.fileio as fileio
+import numpy as np
+from mmcv.transforms import BaseTransform
+from mmcv.transforms import LoadAnnotations as MMCV_LoadAnnotations
+from mmcv.transforms import LoadImageFromFile
+
+from mmseg.registry import TRANSFORMS
+from mmseg.utils import datafrombytes
+
+try:
+    from osgeo import gdal
+except ImportError:
+    gdal = None
+
+
+@TRANSFORMS.register_module()
+class LoadAnnotations(MMCV_LoadAnnotations):
+    """Load annotations for semantic segmentation provided by dataset.
+
+    The annotation format is as the following:
+
+    .. code-block:: python
+
+        {
+            # Filename of semantic segmentation ground truth file.
+            'seg_map_path': 'a/b/c'
+        }
+
+    After this module, the annotation has been changed to the format below:
+
+    .. code-block:: python
+
+        {
+            # in str
+            'seg_fields': List
+             # In uint8 type.
+            'gt_seg_map': np.ndarray (H, W)
+        }
+
+    Required Keys:
+
+    - seg_map_path (str): Path of semantic segmentation ground truth file.
+
+    Added Keys:
+
+    - seg_fields (List)
+    - gt_seg_map (np.uint8)
+
+    Args:
+        reduce_zero_label (bool, optional): Whether reduce all label value
+            by 1. Usually used for datasets where 0 is background label.
+            Defaults to None.
+        imdecode_backend (str): The image decoding backend type. The backend
+            argument for :func:``mmcv.imfrombytes``.
+            See :fun:``mmcv.imfrombytes`` for details.
+            Defaults to 'pillow'.
+        backend_args (dict): Arguments to instantiate a file backend.
+            See https://mmengine.readthedocs.io/en/latest/api/fileio.htm
+            for details. Defaults to None.
+            Notes: mmcv>=2.0.0rc4, mmengine>=0.2.0 required.
+    """
+
+    def __init__(
+        self,
+        reduce_zero_label=None,
+        backend_args=None,
+        imdecode_backend='pillow',
+    ) -> None:
+        super().__init__(
+            with_bbox=False,
+            with_label=False,
+            with_seg=True,
+            with_keypoints=False,
+            imdecode_backend=imdecode_backend,
+            backend_args=backend_args)
+        self.reduce_zero_label = reduce_zero_label
+        if self.reduce_zero_label is not None:
+            warnings.warn('`reduce_zero_label` will be deprecated, '
+                          'if you would like to ignore the zero label, please '
+                          'set `reduce_zero_label=True` when dataset '
+                          'initialized')
+        self.imdecode_backend = imdecode_backend
+
+    def _load_seg_map(self, results: dict) -> None:
+        """Private function to load semantic segmentation annotations.
+
+        Args:
+            results (dict): Result dict from :obj:``mmcv.BaseDataset``.
+
+        Returns:
+            dict: The dict contains loaded semantic segmentation annotations.
+        """
+
+        img_bytes = fileio.get(
+            results['seg_map_path'], backend_args=self.backend_args)
+        gt_semantic_seg = mmcv.imfrombytes(
+            img_bytes, flag='unchanged',
+            backend=self.imdecode_backend).squeeze().astype(np.uint8)
+
+        # reduce zero_label
+        if self.reduce_zero_label is None:
+            self.reduce_zero_label = results['reduce_zero_label']
+        assert self.reduce_zero_label == results['reduce_zero_label'], \
+            'Initialize dataset with `reduce_zero_label` as ' \
+            f'{results["reduce_zero_label"]} but when load annotation ' \
+            f'the `reduce_zero_label` is {self.reduce_zero_label}'
+        if self.reduce_zero_label:
+            # avoid using underflow conversion
+            gt_semantic_seg[gt_semantic_seg == 0] = 255
+            gt_semantic_seg = gt_semantic_seg - 1
+            gt_semantic_seg[gt_semantic_seg == 254] = 255
+        # modify if custom classes
+        if results.get('label_map', None) is not None:
+            # Add deep copy to solve bug of repeatedly
+            # replace `gt_semantic_seg`, which is reported in
+            # https://github.com/open-mmlab/mmsegmentation/pull/1445/
+            gt_semantic_seg_copy = gt_semantic_seg.copy()
+            for old_id, new_id in results['label_map'].items():
+                gt_semantic_seg[gt_semantic_seg_copy == old_id] = new_id
+        results['gt_seg_map'] = gt_semantic_seg
+        results['seg_fields'].append('gt_seg_map')
+
+    def __repr__(self) -> str:
+        repr_str = self.__class__.__name__
+        repr_str += f'(reduce_zero_label={self.reduce_zero_label}, '
+        repr_str += f"imdecode_backend='{self.imdecode_backend}', "
+        repr_str += f'backend_args={self.backend_args})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class LoadImageFromNDArray(LoadImageFromFile):
+    """Load an image from ``results['img']``.
+
+    Similar with :obj:`LoadImageFromFile`, but the image has been loaded as
+    :obj:`np.ndarray` in ``results['img']``. Can be used when loading image
+    from webcam.
+
+    Required Keys:
+
+    - img
+
+    Modified Keys:
+
+    - img
+    - img_path
+    - img_shape
+    - ori_shape
+
+    Args:
+        to_float32 (bool): Whether to convert the loaded image to a float32
+            numpy array. If set to False, the loaded image is an uint8 array.
+            Defaults to False.
+    """
+
+    def transform(self, results: dict) -> dict:
+        """Transform function to add image meta information.
+
+        Args:
+            results (dict): Result dict with Webcam read image in
+                ``results['img']``.
+
+        Returns:
+            dict: The dict contains loaded image and meta information.
+        """
+
+        img = results['img']
+        if self.to_float32:
+            img = img.astype(np.float32)
+
+        results['img_path'] = None
+        results['img'] = img
+        results['img_shape'] = img.shape[:2]
+        results['ori_shape'] = img.shape[:2]
+        return results
+
+
+@TRANSFORMS.register_module()
+class LoadBiomedicalImageFromFile(BaseTransform):
+    """Load an biomedical mage from file.
+
+    Required Keys:
+
+    - img_path
+
+    Added Keys:
+
+    - img (np.ndarray): Biomedical image with shape (N, Z, Y, X) by default,
+        N is the number of modalities, and data type is float32
+        if set to_float32 = True, or float64 if decode_backend is 'nifti' and
+        to_float32 is False.
+    - img_shape
+    - ori_shape
+
+    Args:
+        decode_backend (str): The data decoding backend type. Options are
+            'numpy'and 'nifti', and there is a convention that when backend is
+            'nifti' the axis of data loaded is XYZ, and when backend is
+            'numpy', the the axis is ZYX. The data will be transposed if the
+            backend is 'nifti'. Defaults to 'nifti'.
+        to_xyz (bool): Whether transpose data from Z, Y, X to X, Y, Z.
+            Defaults to False.
+        to_float32 (bool): Whether to convert the loaded image to a float32
+            numpy array. If set to False, the loaded image is an float64 array.
+            Defaults to True.
+        backend_args (dict, Optional): Arguments to instantiate a file backend.
+            See https://mmengine.readthedocs.io/en/latest/api/fileio.htm
+            for details. Defaults to None.
+            Notes: mmcv>=2.0.0rc4, mmengine>=0.2.0 required.
+    """
+
+    def __init__(self,
+                 decode_backend: str = 'nifti',
+                 to_xyz: bool = False,
+                 to_float32: bool = True,
+                 backend_args: Optional[dict] = None) -> None:
+        self.decode_backend = decode_backend
+        self.to_xyz = to_xyz
+        self.to_float32 = to_float32
+        self.backend_args = backend_args.copy() if backend_args else None
+
+    def transform(self, results: Dict) -> Dict:
+        """Functions to load image.
+
+        Args:
+            results (dict): Result dict from :obj:``mmcv.BaseDataset``.
+
+        Returns:
+            dict: The dict contains loaded image and meta information.
+        """
+
+        filename = results['img_path']
+
+        data_bytes = fileio.get(filename, self.backend_args)
+        img = datafrombytes(data_bytes, backend=self.decode_backend)
+
+        if self.to_float32:
+            img = img.astype(np.float32)
+
+        if len(img.shape) == 3:
+            img = img[None, ...]
+
+        if self.decode_backend == 'nifti':
+            img = img.transpose(0, 3, 2, 1)
+
+        if self.to_xyz:
+            img = img.transpose(0, 3, 2, 1)
+
+        results['img'] = img
+        results['img_shape'] = img.shape[1:]
+        results['ori_shape'] = img.shape[1:]
+        return results
+
+    def __repr__(self):
+        repr_str = (f'{self.__class__.__name__}('
+                    f"decode_backend='{self.decode_backend}', "
+                    f'to_xyz={self.to_xyz}, '
+                    f'to_float32={self.to_float32}, '
+                    f'backend_args={self.backend_args})')
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class LoadBiomedicalAnnotation(BaseTransform):
+    """Load ``seg_map`` annotation provided by biomedical dataset.
+
+    The annotation format is as the following:
+
+    .. code-block:: python
+
+        {
+            'gt_seg_map': np.ndarray (X, Y, Z) or (Z, Y, X)
+        }
+
+    Required Keys:
+
+    - seg_map_path
+
+    Added Keys:
+
+    - gt_seg_map (np.ndarray): Biomedical seg map with shape (Z, Y, X) by
+        default, and data type is float32 if set to_float32 = True, or
+        float64 if decode_backend is 'nifti' and to_float32 is False.
+
+    Args:
+        decode_backend (str): The data decoding backend type. Options are
+            'numpy'and 'nifti', and there is a convention that when backend is
+            'nifti' the axis of data loaded is XYZ, and when backend is
+            'numpy', the the axis is ZYX. The data will be transposed if the
+            backend is 'nifti'. Defaults to 'nifti'.
+        to_xyz (bool): Whether transpose data from Z, Y, X to X, Y, Z.
+            Defaults to False.
+        to_float32 (bool): Whether to convert the loaded seg map to a float32
+            numpy array. If set to False, the loaded image is an float64 array.
+            Defaults to True.
+        backend_args (dict, Optional): Arguments to instantiate a file backend.
+            See :class:`mmengine.fileio` for details.
+            Defaults to None.
+            Notes: mmcv>=2.0.0rc4, mmengine>=0.2.0 required.
+    """
+
+    def __init__(self,
+                 decode_backend: str = 'nifti',
+                 to_xyz: bool = False,
+                 to_float32: bool = True,
+                 backend_args: Optional[dict] = None) -> None:
+        super().__init__()
+        self.decode_backend = decode_backend
+        self.to_xyz = to_xyz
+        self.to_float32 = to_float32
+        self.backend_args = backend_args.copy() if backend_args else None
+
+    def transform(self, results: Dict) -> Dict:
+        """Functions to load image.
+
+        Args:
+            results (dict): Result dict from :obj:``mmcv.BaseDataset``.
+
+        Returns:
+            dict: The dict contains loaded image and meta information.
+        """
+        data_bytes = fileio.get(results['seg_map_path'], self.backend_args)
+        gt_seg_map = datafrombytes(data_bytes, backend=self.decode_backend)
+
+        if self.to_float32:
+            gt_seg_map = gt_seg_map.astype(np.float32)
+
+        if self.decode_backend == 'nifti':
+            gt_seg_map = gt_seg_map.transpose(2, 1, 0)
+
+        if self.to_xyz:
+            gt_seg_map = gt_seg_map.transpose(2, 1, 0)
+
+        results['gt_seg_map'] = gt_seg_map
+        return results
+
+    def __repr__(self):
+        repr_str = (f'{self.__class__.__name__}('
+                    f"decode_backend='{self.decode_backend}', "
+                    f'to_xyz={self.to_xyz}, '
+                    f'to_float32={self.to_float32}, '
+                    f'backend_args={self.backend_args})')
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class LoadBiomedicalData(BaseTransform):
+    """Load an biomedical image and annotation from file.
+
+    The loading data format is as the following:
+
+    .. code-block:: python
+
+        {
+            'img': np.ndarray data[:-1, X, Y, Z]
+            'seg_map': np.ndarray data[-1, X, Y, Z]
+        }
+
+
+    Required Keys:
+
+    - img_path
+
+    Added Keys:
+
+    - img (np.ndarray): Biomedical image with shape (N, Z, Y, X) by default,
+        N is the number of modalities.
+    - gt_seg_map (np.ndarray, optional): Biomedical seg map with shape
+        (Z, Y, X) by default.
+    - img_shape
+    - ori_shape
+
+    Args:
+        with_seg (bool): Whether to parse and load the semantic segmentation
+            annotation. Defaults to False.
+        decode_backend (str): The data decoding backend type. Options are
+            'numpy'and 'nifti', and there is a convention that when backend is
+            'nifti' the axis of data loaded is XYZ, and when backend is
+            'numpy', the the axis is ZYX. The data will be transposed if the
+            backend is 'nifti'. Defaults to 'nifti'.
+        to_xyz (bool): Whether transpose data from Z, Y, X to X, Y, Z.
+            Defaults to False.
+        backend_args (dict, Optional): Arguments to instantiate a file backend.
+            See https://mmengine.readthedocs.io/en/latest/api/fileio.htm
+            for details. Defaults to None.
+            Notes: mmcv>=2.0.0rc4, mmengine>=0.2.0 required.
+    """
+
+    def __init__(self,
+                 with_seg=False,
+                 decode_backend: str = 'numpy',
+                 to_xyz: bool = False,
+                 backend_args: Optional[dict] = None) -> None:  # noqa
+        self.with_seg = with_seg
+        self.decode_backend = decode_backend
+        self.to_xyz = to_xyz
+        self.backend_args = backend_args.copy() if backend_args else None
+
+    def transform(self, results: Dict) -> Dict:
+        """Functions to load image.
+
+        Args:
+            results (dict): Result dict from :obj:``mmcv.BaseDataset``.
+
+        Returns:
+            dict: The dict contains loaded image and meta information.
+        """
+        data_bytes = fileio.get(results['img_path'], self.backend_args)
+        data = datafrombytes(data_bytes, backend=self.decode_backend)
+        # img is 4D data (N, X, Y, Z), N is the number of protocol
+        img = data[:-1, :]
+
+        if self.decode_backend == 'nifti':
+            img = img.transpose(0, 3, 2, 1)
+
+        if self.to_xyz:
+            img = img.transpose(0, 3, 2, 1)
+
+        results['img'] = img
+        results['img_shape'] = img.shape[1:]
+        results['ori_shape'] = img.shape[1:]
+
+        if self.with_seg:
+            gt_seg_map = data[-1, :]
+            if self.decode_backend == 'nifti':
+                gt_seg_map = gt_seg_map.transpose(2, 1, 0)
+
+            if self.to_xyz:
+                gt_seg_map = gt_seg_map.transpose(2, 1, 0)
+            results['gt_seg_map'] = gt_seg_map
+        return results
+
+    def __repr__(self) -> str:
+        repr_str = (f'{self.__class__.__name__}('
+                    f'with_seg={self.with_seg}, '
+                    f"decode_backend='{self.decode_backend}', "
+                    f'to_xyz={self.to_xyz}, '
+                    f'backend_args={self.backend_args})')
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class InferencerLoader(BaseTransform):
+    """Load an image from ``results['img']``.
+
+    Similar with :obj:`LoadImageFromFile`, but the image has been loaded as
+    :obj:`np.ndarray` in ``results['img']``. Can be used when loading image
+    from webcam.
+
+    Required Keys:
+
+    - img
+
+    Modified Keys:
+
+    - img
+    - img_path
+    - img_shape
+    - ori_shape
+
+    Args:
+        to_float32 (bool): Whether to convert the loaded image to a float32
+            numpy array. If set to False, the loaded image is an uint8 array.
+            Defaults to False.
+    """
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__()
+        self.from_file = TRANSFORMS.build(
+            dict(type='LoadImageFromFile', **kwargs))
+        self.from_ndarray = TRANSFORMS.build(
+            dict(type='LoadImageFromNDArray', **kwargs))
+
+    def transform(self, single_input: Union[str, np.ndarray, dict]) -> dict:
+        """Transform function to add image meta information.
+
+        Args:
+            results (dict): Result dict with Webcam read image in
+                ``results['img']``.
+
+        Returns:
+            dict: The dict contains loaded image and meta information.
+        """
+        if isinstance(single_input, str):
+            inputs = dict(img_path=single_input)
+        elif isinstance(single_input, np.ndarray):
+            inputs = dict(img=single_input)
+        elif isinstance(single_input, dict):
+            inputs = single_input
+        else:
+            raise NotImplementedError
+
+        if 'img' in inputs:
+            return self.from_ndarray(inputs)
+        return self.from_file(inputs)
+
+
+@TRANSFORMS.register_module()
+class LoadSingleRSImageFromFile(BaseTransform):
+    """Load a Remote Sensing mage from file.
+
+    Required Keys:
+
+    - img_path
+
+    Modified Keys:
+
+    - img
+    - img_shape
+    - ori_shape
+
+    Args:
+        to_float32 (bool): Whether to convert the loaded image to a float32
+            numpy array. If set to False, the loaded image is a float64 array.
+            Defaults to True.
+    """
+
+    def __init__(self, to_float32: bool = True):
+        self.to_float32 = to_float32
+
+        if gdal is None:
+            raise RuntimeError('gdal is not installed')
+
+    def transform(self, results: Dict) -> Dict:
+        """Functions to load image.
+
+        Args:
+            results (dict): Result dict from :obj:``mmcv.BaseDataset``.
+
+        Returns:
+            dict: The dict contains loaded image and meta information.
+        """
+
+        filename = results['img_path']
+        ds = gdal.Open(filename)
+        if ds is None:
+            raise Exception(f'Unable to open file: {filename}')
+        img = np.einsum('ijk->jki', ds.ReadAsArray())
+
+        if self.to_float32:
+            img = img.astype(np.float32)
+
+        results['img'] = img
+        results['img_shape'] = img.shape[:2]
+        results['ori_shape'] = img.shape[:2]
+        return results
+
+    def __repr__(self):
+        repr_str = (f'{self.__class__.__name__}('
+                    f'to_float32={self.to_float32})')
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class LoadMultipleRSImageFromFile(BaseTransform):
+    """Load two Remote Sensing mage from file.
+
+    Required Keys:
+
+    - img_path
+    - img_path2
+
+    Modified Keys:
+
+    - img
+    - img2
+    - img_shape
+    - ori_shape
+
+    Args:
+        to_float32 (bool): Whether to convert the loaded image to a float32
+            numpy array. If set to False, the loaded image is a float64 array.
+            Defaults to True.
+    """
+
+    def __init__(self, to_float32: bool = True):
+        if gdal is None:
+            raise RuntimeError('gdal is not installed')
+        self.to_float32 = to_float32
+
+    def transform(self, results: Dict) -> Dict:
+        """Functions to load image.
+
+        Args:
+            results (dict): Result dict from :obj:``mmcv.BaseDataset``.
+
+        Returns:
+            dict: The dict contains loaded image and meta information.
+        """
+
+        filename = results['img_path']
+        filename2 = results['img_path2']
+
+        ds = gdal.Open(filename)
+        ds2 = gdal.Open(filename2)
+
+        if ds is None:
+            raise Exception(f'Unable to open file: {filename}')
+        if ds2 is None:
+            raise Exception(f'Unable to open file: {filename2}')
+
+        img = np.einsum('ijk->jki', ds.ReadAsArray())
+        img2 = np.einsum('ijk->jki', ds2.ReadAsArray())
+
+        if self.to_float32:
+            img = img.astype(np.float32)
+            img2 = img2.astype(np.float32)
+
+        if img.shape != img2.shape:
+            raise Exception(f'Image shapes do not match:'
+                            f' {img.shape} vs {img2.shape}')
+
+        results['img'] = img
+        results['img2'] = img2
+        results['img_shape'] = img.shape[:2]
+        results['ori_shape'] = img.shape[:2]
+        return results
+
+    def __repr__(self):
+        repr_str = (f'{self.__class__.__name__}('
+                    f'to_float32={self.to_float32})')
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class LoadDepthAnnotation(BaseTransform):
+    """Load ``depth_map`` annotation provided by depth estimation dataset.
+
+    The annotation format is as the following:
+
+    .. code-block:: python
+
+        {
+            'gt_depth_map': np.ndarray [Y, X]
+        }
+
+    Required Keys:
+
+    - seg_depth_path
+
+    Added Keys:
+
+    - gt_depth_map (np.ndarray): Depth map with shape (Y, X) by
+        default, and data type is float32 if set to_float32 = True.
+    - depth_rescale_factor (float): The rescale factor of depth map, which
+        can be used to recover the original value of depth map.
+
+    Args:
+        decode_backend (str): The data decoding backend type. Options are
+            'numpy', 'nifti', and 'cv2'. Defaults to 'cv2'.
+        to_float32 (bool): Whether to convert the loaded depth map to a float32
+            numpy array. If set to False, the loaded image is an uint16 array.
+            Defaults to True.
+        depth_rescale_factor (float): Factor to rescale the depth value to
+            limit the range. Defaults to 1.0.
+        backend_args (dict, Optional): Arguments to instantiate a file backend.
+            See :class:`mmengine.fileio` for details.
+            Defaults to None.
+            Notes: mmcv>=2.0.0rc4, mmengine>=0.2.0 required.
+    """
+
+    def __init__(self,
+                 decode_backend: str = 'cv2',
+                 to_float32: bool = True,
+                 depth_rescale_factor: float = 1.0,
+                 backend_args: Optional[dict] = None) -> None:
+        super().__init__()
+        self.decode_backend = decode_backend
+        self.to_float32 = to_float32
+        self.depth_rescale_factor = depth_rescale_factor
+        self.backend_args = backend_args.copy() if backend_args else None
+
+    def transform(self, results: Dict) -> Dict:
+        """Functions to load depth map.
+
+        Args:
+            results (dict): Result dict from :obj:``mmcv.BaseDataset``.
+
+        Returns:
+            dict: The dict contains loaded depth map.
+        """
+        data_bytes = fileio.get(results['depth_map_path'], self.backend_args)
+        gt_depth_map = datafrombytes(data_bytes, backend=self.decode_backend)
+
+        if self.to_float32:
+            gt_depth_map = gt_depth_map.astype(np.float32)
+
+        gt_depth_map *= self.depth_rescale_factor
+        results['gt_depth_map'] = gt_depth_map
+        results['seg_fields'].append('gt_depth_map')
+        results['depth_rescale_factor'] = self.depth_rescale_factor
+        return results
+
+    def __repr__(self):
+        repr_str = (f'{self.__class__.__name__}('
+                    f"decode_backend='{self.decode_backend}', "
+                    f'to_float32={self.to_float32}, '
+                    f'backend_args={self.backend_args})')
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class LoadImageFromNpyFile(LoadImageFromFile):
+    """Load an image from ``results['img_path']``.
+
+    Required Keys:
+
+    - img_path
+
+    Modified Keys:
+
+    - img
+    - img_shape
+    - ori_shape
+
+    Args:
+        to_float32 (bool): Whether to convert the loaded image to a float32
+            numpy array. If set to False, the loaded image is an uint8 array.
+            Defaults to False.
+    """
+
+    def transform(self, results: dict) -> Optional[dict]:
+        """Functions to load image.
+
+        Args:
+            results (dict): Result dict from
+                :class:`mmengine.dataset.BaseDataset`.
+
+        Returns:
+            dict: The dict contains loaded image and meta information.
+        """
+
+        filename = results['img_path']
+
+        try:
+            if Path(filename).suffix in ['.npy', '.npz']:
+                img = np.load(filename)
+            else:
+                if self.file_client_args is not None:
+                    file_client = fileio.FileClient.infer_client(
+                        self.file_client_args, filename)
+                    img_bytes = file_client.get(filename)
+                else:
+                    img_bytes = fileio.get(
+                        filename, backend_args=self.backend_args)
+                img = mmcv.imfrombytes(
+                    img_bytes,
+                    flag=self.color_type,
+                    backend=self.imdecode_backend)
+        except Exception as e:
+            if self.ignore_empty:
+                return None
+            else:
+                raise e
+
+        # in some cases, images are not read successfully, the img would be
+        # `None`, refer to https://github.com/open-mmlab/mmpretrain/issues/1427
+        assert img is not None, f'failed to load image: {filename}'
+        if self.to_float32:
+            img = img.astype(np.float32)
+
+        results['img'] = img
+        results['img_shape'] = img.shape[:2]
+        results['ori_shape'] = img.shape[:2]
+        return results
diff --git a/mmsegmentation/mmseg/datasets/transforms/transforms.py b/mmsegmentation/mmseg/datasets/transforms/transforms.py
new file mode 100644
index 0000000..64e2323
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/transforms/transforms.py
@@ -0,0 +1,2537 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import inspect
+import warnings
+from typing import Dict, List, Optional, Sequence, Tuple, Union
+
+import cv2
+import mmcv
+import mmengine
+import numpy as np
+from mmcv.transforms import RandomFlip as MMCV_RandomFlip
+from mmcv.transforms import Resize as MMCV_Resize
+from mmcv.transforms.base import BaseTransform
+from mmcv.transforms.utils import cache_randomness
+from mmengine.utils import is_tuple_of
+from numpy import random
+from scipy.ndimage import gaussian_filter
+
+from mmseg.datasets.dataset_wrappers import MultiImageMixDataset
+from mmseg.registry import TRANSFORMS
+
+try:
+    import albumentations
+    from albumentations import Compose
+    ALBU_INSTALLED = True
+except ImportError:
+    albumentations = None
+    Compose = None
+    ALBU_INSTALLED = False
+
+
+@TRANSFORMS.register_module()
+class ResizeToMultiple(BaseTransform):
+    """Resize images & seg to multiple of divisor.
+
+    Required Keys:
+
+    - img
+    - gt_seg_map
+
+    Modified Keys:
+
+    - img
+    - img_shape
+    - pad_shape
+
+    Args:
+        size_divisor (int): images and gt seg maps need to resize to multiple
+            of size_divisor. Default: 32.
+        interpolation (str, optional): The interpolation mode of image resize.
+            Default: None
+    """
+
+    def __init__(self, size_divisor=32, interpolation=None):
+        self.size_divisor = size_divisor
+        self.interpolation = interpolation
+
+    def transform(self, results: dict) -> dict:
+        """Call function to resize images, semantic segmentation map to
+        multiple of size divisor.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Resized results, 'img_shape', 'pad_shape' keys are updated.
+        """
+        # Align image to multiple of size divisor.
+        img = results['img']
+        img = mmcv.imresize_to_multiple(
+            img,
+            self.size_divisor,
+            scale_factor=1,
+            interpolation=self.interpolation
+            if self.interpolation else 'bilinear')
+
+        results['img'] = img
+        results['img_shape'] = img.shape[:2]
+        results['pad_shape'] = img.shape[:2]
+
+        # Align segmentation map to multiple of size divisor.
+        for key in results.get('seg_fields', []):
+            gt_seg = results[key]
+            gt_seg = mmcv.imresize_to_multiple(
+                gt_seg,
+                self.size_divisor,
+                scale_factor=1,
+                interpolation='nearest')
+            results[key] = gt_seg
+
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += (f'(size_divisor={self.size_divisor}, '
+                     f'interpolation={self.interpolation})')
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class Rerange(BaseTransform):
+    """Rerange the image pixel value.
+
+    Required Keys:
+
+    - img
+
+    Modified Keys:
+
+    - img
+
+    Args:
+        min_value (float or int): Minimum value of the reranged image.
+            Default: 0.
+        max_value (float or int): Maximum value of the reranged image.
+            Default: 255.
+    """
+
+    def __init__(self, min_value=0, max_value=255):
+        assert isinstance(min_value, float) or isinstance(min_value, int)
+        assert isinstance(max_value, float) or isinstance(max_value, int)
+        assert min_value < max_value
+        self.min_value = min_value
+        self.max_value = max_value
+
+    def transform(self, results: dict) -> dict:
+        """Call function to rerange images.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+        Returns:
+            dict: Reranged results.
+        """
+
+        img = results['img']
+        img_min_value = np.min(img)
+        img_max_value = np.max(img)
+
+        assert img_min_value < img_max_value
+        # rerange to [0, 1]
+        img = (img - img_min_value) / (img_max_value - img_min_value)
+        # rerange to [min_value, max_value]
+        img = img * (self.max_value - self.min_value) + self.min_value
+        results['img'] = img
+
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(min_value={self.min_value}, max_value={self.max_value})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class CLAHE(BaseTransform):
+    """Use CLAHE method to process the image.
+
+    See `ZUIDERVELD,K. Contrast Limited Adaptive Histogram Equalization[J].
+    Graphics Gems, 1994:474-485.` for more information.
+
+    Required Keys:
+
+    - img
+
+    Modified Keys:
+
+    - img
+
+    Args:
+        clip_limit (float): Threshold for contrast limiting. Default: 40.0.
+        tile_grid_size (tuple[int]): Size of grid for histogram equalization.
+            Input image will be divided into equally sized rectangular tiles.
+            It defines the number of tiles in row and column. Default: (8, 8).
+    """
+
+    def __init__(self, clip_limit=40.0, tile_grid_size=(8, 8)):
+        assert isinstance(clip_limit, (float, int))
+        self.clip_limit = clip_limit
+        assert is_tuple_of(tile_grid_size, int)
+        assert len(tile_grid_size) == 2
+        self.tile_grid_size = tile_grid_size
+
+    def transform(self, results: dict) -> dict:
+        """Call function to Use CLAHE method process images.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Processed results.
+        """
+
+        for i in range(results['img'].shape[2]):
+            results['img'][:, :, i] = mmcv.clahe(
+                np.array(results['img'][:, :, i], dtype=np.uint8),
+                self.clip_limit, self.tile_grid_size)
+
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(clip_limit={self.clip_limit}, ' \
+                    f'tile_grid_size={self.tile_grid_size})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class RandomCrop(BaseTransform):
+    """Random crop the image & seg.
+
+    Required Keys:
+
+    - img
+    - gt_seg_map
+
+    Modified Keys:
+
+    - img
+    - img_shape
+    - gt_seg_map
+
+
+    Args:
+        crop_size (Union[int, Tuple[int, int]]):  Expected size after cropping
+            with the format of (h, w). If set to an integer, then cropping
+            width and height are equal to this integer.
+        cat_max_ratio (float): The maximum ratio that single category could
+            occupy.
+        ignore_index (int): The label index to be ignored. Default: 255
+    """
+
+    def __init__(self,
+                 crop_size: Union[int, Tuple[int, int]],
+                 cat_max_ratio: float = 1.,
+                 ignore_index: int = 255):
+        super().__init__()
+        assert isinstance(crop_size, int) or (
+            isinstance(crop_size, tuple) and len(crop_size) == 2
+        ), 'The expected crop_size is an integer, or a tuple containing two '
+        'intergers'
+
+        if isinstance(crop_size, int):
+            crop_size = (crop_size, crop_size)
+        assert crop_size[0] > 0 and crop_size[1] > 0
+        self.crop_size = crop_size
+        self.cat_max_ratio = cat_max_ratio
+        self.ignore_index = ignore_index
+
+    @cache_randomness
+    def crop_bbox(self, results: dict) -> tuple:
+        """get a crop bounding box.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            tuple: Coordinates of the cropped image.
+        """
+
+        def generate_crop_bbox(img: np.ndarray) -> tuple:
+            """Randomly get a crop bounding box.
+
+            Args:
+                img (np.ndarray): Original input image.
+
+            Returns:
+                tuple: Coordinates of the cropped image.
+            """
+
+            margin_h = max(img.shape[0] - self.crop_size[0], 0)
+            margin_w = max(img.shape[1] - self.crop_size[1], 0)
+            offset_h = np.random.randint(0, margin_h + 1)
+            offset_w = np.random.randint(0, margin_w + 1)
+            crop_y1, crop_y2 = offset_h, offset_h + self.crop_size[0]
+            crop_x1, crop_x2 = offset_w, offset_w + self.crop_size[1]
+
+            return crop_y1, crop_y2, crop_x1, crop_x2
+
+        img = results['img']
+        crop_bbox = generate_crop_bbox(img)
+        if self.cat_max_ratio < 1.:
+            # Repeat 10 times
+            for _ in range(10):
+                seg_temp = self.crop(results['gt_seg_map'], crop_bbox)
+                labels, cnt = np.unique(seg_temp, return_counts=True)
+                cnt = cnt[labels != self.ignore_index]
+                if len(cnt) > 1 and np.max(cnt) / np.sum(
+                        cnt) < self.cat_max_ratio:
+                    break
+                crop_bbox = generate_crop_bbox(img)
+
+        return crop_bbox
+
+    def crop(self, img: np.ndarray, crop_bbox: tuple) -> np.ndarray:
+        """Crop from ``img``
+
+        Args:
+            img (np.ndarray): Original input image.
+            crop_bbox (tuple): Coordinates of the cropped image.
+
+        Returns:
+            np.ndarray: The cropped image.
+        """
+
+        crop_y1, crop_y2, crop_x1, crop_x2 = crop_bbox
+        img = img[crop_y1:crop_y2, crop_x1:crop_x2, ...]
+        return img
+
+    def transform(self, results: dict) -> dict:
+        """Transform function to randomly crop images, semantic segmentation
+        maps.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Randomly cropped results, 'img_shape' key in result dict is
+                updated according to crop size.
+        """
+
+        img = results['img']
+        crop_bbox = self.crop_bbox(results)
+
+        # crop the image
+        img = self.crop(img, crop_bbox)
+
+        # crop semantic seg
+        for key in results.get('seg_fields', []):
+            results[key] = self.crop(results[key], crop_bbox)
+
+        results['img'] = img
+        results['img_shape'] = img.shape[:2]
+        return results
+
+    def __repr__(self):
+        return self.__class__.__name__ + f'(crop_size={self.crop_size})'
+
+
+@TRANSFORMS.register_module()
+class RandomRotate(BaseTransform):
+    """Rotate the image & seg.
+
+    Required Keys:
+
+    - img
+    - gt_seg_map
+
+    Modified Keys:
+
+    - img
+    - gt_seg_map
+
+    Args:
+        prob (float): The rotation probability.
+        degree (float, tuple[float]): Range of degrees to select from. If
+            degree is a number instead of tuple like (min, max),
+            the range of degree will be (``-degree``, ``+degree``)
+        pad_val (float, optional): Padding value of image. Default: 0.
+        seg_pad_val (float, optional): Padding value of segmentation map.
+            Default: 255.
+        center (tuple[float], optional): Center point (w, h) of the rotation in
+            the source image. If not specified, the center of the image will be
+            used. Default: None.
+        auto_bound (bool): Whether to adjust the image size to cover the whole
+            rotated image. Default: False
+    """
+
+    def __init__(self,
+                 prob,
+                 degree,
+                 pad_val=0,
+                 seg_pad_val=255,
+                 center=None,
+                 auto_bound=False):
+        self.prob = prob
+        assert prob >= 0 and prob <= 1
+        if isinstance(degree, (float, int)):
+            assert degree > 0, f'degree {degree} should be positive'
+            self.degree = (-degree, degree)
+        else:
+            self.degree = degree
+        assert len(self.degree) == 2, f'degree {self.degree} should be a ' \
+                                      f'tuple of (min, max)'
+        self.pal_val = pad_val
+        self.seg_pad_val = seg_pad_val
+        self.center = center
+        self.auto_bound = auto_bound
+
+    @cache_randomness
+    def generate_degree(self):
+        return np.random.rand() < self.prob, np.random.uniform(
+            min(*self.degree), max(*self.degree))
+
+    def transform(self, results: dict) -> dict:
+        """Call function to rotate image, semantic segmentation maps.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Rotated results.
+        """
+
+        rotate, degree = self.generate_degree()
+        if rotate:
+            # rotate image
+            results['img'] = mmcv.imrotate(
+                results['img'],
+                angle=degree,
+                border_value=self.pal_val,
+                center=self.center,
+                auto_bound=self.auto_bound)
+
+            # rotate segs
+            for key in results.get('seg_fields', []):
+                results[key] = mmcv.imrotate(
+                    results[key],
+                    angle=degree,
+                    border_value=self.seg_pad_val,
+                    center=self.center,
+                    auto_bound=self.auto_bound,
+                    interpolation='nearest')
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(prob={self.prob}, ' \
+                    f'degree={self.degree}, ' \
+                    f'pad_val={self.pal_val}, ' \
+                    f'seg_pad_val={self.seg_pad_val}, ' \
+                    f'center={self.center}, ' \
+                    f'auto_bound={self.auto_bound})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class RGB2Gray(BaseTransform):
+    """Convert RGB image to grayscale image.
+
+    Required Keys:
+
+    - img
+
+    Modified Keys:
+
+    - img
+    - img_shape
+
+    This transform calculate the weighted mean of input image channels with
+    ``weights`` and then expand the channels to ``out_channels``. When
+    ``out_channels`` is None, the number of output channels is the same as
+    input channels.
+
+    Args:
+        out_channels (int): Expected number of output channels after
+            transforming. Default: None.
+        weights (tuple[float]): The weights to calculate the weighted mean.
+            Default: (0.299, 0.587, 0.114).
+    """
+
+    def __init__(self, out_channels=None, weights=(0.299, 0.587, 0.114)):
+        assert out_channels is None or out_channels > 0
+        self.out_channels = out_channels
+        assert isinstance(weights, tuple)
+        for item in weights:
+            assert isinstance(item, (float, int))
+        self.weights = weights
+
+    def transform(self, results: dict) -> dict:
+        """Call function to convert RGB image to grayscale image.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Result dict with grayscale image.
+        """
+        img = results['img']
+        assert len(img.shape) == 3
+        assert img.shape[2] == len(self.weights)
+        weights = np.array(self.weights).reshape((1, 1, -1))
+        img = (img * weights).sum(2, keepdims=True)
+        if self.out_channels is None:
+            img = img.repeat(weights.shape[2], axis=2)
+        else:
+            img = img.repeat(self.out_channels, axis=2)
+
+        results['img'] = img
+        results['img_shape'] = img.shape
+
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(out_channels={self.out_channels}, ' \
+                    f'weights={self.weights})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class AdjustGamma(BaseTransform):
+    """Using gamma correction to process the image.
+
+    Required Keys:
+
+    - img
+
+    Modified Keys:
+
+    - img
+
+    Args:
+        gamma (float or int): Gamma value used in gamma correction.
+            Default: 1.0.
+    """
+
+    def __init__(self, gamma=1.0):
+        assert isinstance(gamma, float) or isinstance(gamma, int)
+        assert gamma > 0
+        self.gamma = gamma
+        inv_gamma = 1.0 / gamma
+        self.table = np.array([(i / 255.0)**inv_gamma * 255
+                               for i in np.arange(256)]).astype('uint8')
+
+    def transform(self, results: dict) -> dict:
+        """Call function to process the image with gamma correction.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Processed results.
+        """
+
+        results['img'] = mmcv.lut_transform(
+            np.array(results['img'], dtype=np.uint8), self.table)
+
+        return results
+
+    def __repr__(self):
+        return self.__class__.__name__ + f'(gamma={self.gamma})'
+
+
+@TRANSFORMS.register_module()
+class SegRescale(BaseTransform):
+    """Rescale semantic segmentation maps.
+
+    Required Keys:
+
+    - gt_seg_map
+
+    Modified Keys:
+
+    - gt_seg_map
+
+    Args:
+        scale_factor (float): The scale factor of the final output.
+    """
+
+    def __init__(self, scale_factor=1):
+        self.scale_factor = scale_factor
+
+    def transform(self, results: dict) -> dict:
+        """Call function to scale the semantic segmentation map.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Result dict with semantic segmentation map scaled.
+        """
+        for key in results.get('seg_fields', []):
+            if self.scale_factor != 1:
+                results[key] = mmcv.imrescale(
+                    results[key], self.scale_factor, interpolation='nearest')
+        return results
+
+    def __repr__(self):
+        return self.__class__.__name__ + f'(scale_factor={self.scale_factor})'
+
+
+@TRANSFORMS.register_module()
+class PhotoMetricDistortion(BaseTransform):
+    """Apply photometric distortion to image sequentially, every transformation
+    is applied with a probability of 0.5. The position of random contrast is in
+    second or second to last.
+
+    1. random brightness
+    2. random contrast (mode 0)
+    3. convert color from BGR to HSV
+    4. random saturation
+    5. random hue
+    6. convert color from HSV to BGR
+    7. random contrast (mode 1)
+
+    Required Keys:
+
+    - img
+
+    Modified Keys:
+
+    - img
+
+    Args:
+        brightness_delta (int): delta of brightness.
+        contrast_range (tuple): range of contrast.
+        saturation_range (tuple): range of saturation.
+        hue_delta (int): delta of hue.
+    """
+
+    def __init__(self,
+                 brightness_delta: int = 32,
+                 contrast_range: Sequence[float] = (0.5, 1.5),
+                 saturation_range: Sequence[float] = (0.5, 1.5),
+                 hue_delta: int = 18):
+        self.brightness_delta = brightness_delta
+        self.contrast_lower, self.contrast_upper = contrast_range
+        self.saturation_lower, self.saturation_upper = saturation_range
+        self.hue_delta = hue_delta
+
+    def convert(self,
+                img: np.ndarray,
+                alpha: int = 1,
+                beta: int = 0) -> np.ndarray:
+        """Multiple with alpha and add beat with clip.
+
+        Args:
+            img (np.ndarray): The input image.
+            alpha (int): Image weights, change the contrast/saturation
+                of the image. Default: 1
+            beta (int): Image bias, change the brightness of the
+                image. Default: 0
+
+        Returns:
+            np.ndarray: The transformed image.
+        """
+
+        img = img.astype(np.float32) * alpha + beta
+        img = np.clip(img, 0, 255)
+        return img.astype(np.uint8)
+
+    def brightness(self, img: np.ndarray) -> np.ndarray:
+        """Brightness distortion.
+
+        Args:
+            img (np.ndarray): The input image.
+        Returns:
+            np.ndarray: Image after brightness change.
+        """
+
+        if random.randint(2):
+            return self.convert(
+                img,
+                beta=random.uniform(-self.brightness_delta,
+                                    self.brightness_delta))
+        return img
+
+    def contrast(self, img: np.ndarray) -> np.ndarray:
+        """Contrast distortion.
+
+        Args:
+            img (np.ndarray): The input image.
+        Returns:
+            np.ndarray: Image after contrast change.
+        """
+
+        if random.randint(2):
+            return self.convert(
+                img,
+                alpha=random.uniform(self.contrast_lower, self.contrast_upper))
+        return img
+
+    def saturation(self, img: np.ndarray) -> np.ndarray:
+        """Saturation distortion.
+
+        Args:
+            img (np.ndarray): The input image.
+        Returns:
+            np.ndarray: Image after saturation change.
+        """
+
+        if random.randint(2):
+            img = mmcv.bgr2hsv(img)
+            img[:, :, 1] = self.convert(
+                img[:, :, 1],
+                alpha=random.uniform(self.saturation_lower,
+                                     self.saturation_upper))
+            img = mmcv.hsv2bgr(img)
+        return img
+
+    def hue(self, img: np.ndarray) -> np.ndarray:
+        """Hue distortion.
+
+        Args:
+            img (np.ndarray): The input image.
+        Returns:
+            np.ndarray: Image after hue change.
+        """
+
+        if random.randint(2):
+            img = mmcv.bgr2hsv(img)
+            img[:, :,
+                0] = (img[:, :, 0].astype(int) +
+                      random.randint(-self.hue_delta, self.hue_delta)) % 180
+            img = mmcv.hsv2bgr(img)
+        return img
+
+    def transform(self, results: dict) -> dict:
+        """Transform function to perform photometric distortion on images.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Result dict with images distorted.
+        """
+
+        img = results['img']
+        # random brightness
+        img = self.brightness(img)
+
+        # mode == 0 --> do random contrast first
+        # mode == 1 --> do random contrast last
+        mode = random.randint(2)
+        if mode == 1:
+            img = self.contrast(img)
+
+        # random saturation
+        img = self.saturation(img)
+
+        # random hue
+        img = self.hue(img)
+
+        # random contrast
+        if mode == 0:
+            img = self.contrast(img)
+
+        results['img'] = img
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += (f'(brightness_delta={self.brightness_delta}, '
+                     f'contrast_range=({self.contrast_lower}, '
+                     f'{self.contrast_upper}), '
+                     f'saturation_range=({self.saturation_lower}, '
+                     f'{self.saturation_upper}), '
+                     f'hue_delta={self.hue_delta})')
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class RandomCutOut(BaseTransform):
+    """CutOut operation.
+
+    Randomly drop some regions of image used in
+    `Cutout <https://arxiv.org/abs/1708.04552>`_.
+
+    Required Keys:
+
+    - img
+    - gt_seg_map
+
+    Modified Keys:
+
+    - img
+    - gt_seg_map
+
+    Args:
+        prob (float): cutout probability.
+        n_holes (int | tuple[int, int]): Number of regions to be dropped.
+            If it is given as a list, number of holes will be randomly
+            selected from the closed interval [`n_holes[0]`, `n_holes[1]`].
+        cutout_shape (tuple[int, int] | list[tuple[int, int]]): The candidate
+            shape of dropped regions. It can be `tuple[int, int]` to use a
+            fixed cutout shape, or `list[tuple[int, int]]` to randomly choose
+            shape from the list.
+        cutout_ratio (tuple[float, float] | list[tuple[float, float]]): The
+            candidate ratio of dropped regions. It can be `tuple[float, float]`
+            to use a fixed ratio or `list[tuple[float, float]]` to randomly
+            choose ratio from the list. Please note that `cutout_shape`
+            and `cutout_ratio` cannot be both given at the same time.
+        fill_in (tuple[float, float, float] | tuple[int, int, int]): The value
+            of pixel to fill in the dropped regions. Default: (0, 0, 0).
+        seg_fill_in (int): The labels of pixel to fill in the dropped regions.
+            If seg_fill_in is None, skip. Default: None.
+    """
+
+    def __init__(self,
+                 prob,
+                 n_holes,
+                 cutout_shape=None,
+                 cutout_ratio=None,
+                 fill_in=(0, 0, 0),
+                 seg_fill_in=None):
+
+        assert 0 <= prob and prob <= 1
+        assert (cutout_shape is None) ^ (cutout_ratio is None), \
+            'Either cutout_shape or cutout_ratio should be specified.'
+        assert (isinstance(cutout_shape, (list, tuple))
+                or isinstance(cutout_ratio, (list, tuple)))
+        if isinstance(n_holes, tuple):
+            assert len(n_holes) == 2 and 0 <= n_holes[0] < n_holes[1]
+        else:
+            n_holes = (n_holes, n_holes)
+        if seg_fill_in is not None:
+            assert (isinstance(seg_fill_in, int) and 0 <= seg_fill_in
+                    and seg_fill_in <= 255)
+        self.prob = prob
+        self.n_holes = n_holes
+        self.fill_in = fill_in
+        self.seg_fill_in = seg_fill_in
+        self.with_ratio = cutout_ratio is not None
+        self.candidates = cutout_ratio if self.with_ratio else cutout_shape
+        if not isinstance(self.candidates, list):
+            self.candidates = [self.candidates]
+
+    @cache_randomness
+    def do_cutout(self):
+        return np.random.rand() < self.prob
+
+    @cache_randomness
+    def generate_patches(self, results):
+        cutout = self.do_cutout()
+
+        h, w, _ = results['img'].shape
+        if cutout:
+            n_holes = np.random.randint(self.n_holes[0], self.n_holes[1] + 1)
+        else:
+            n_holes = 0
+        x1_lst = []
+        y1_lst = []
+        index_lst = []
+        for _ in range(n_holes):
+            x1_lst.append(np.random.randint(0, w))
+            y1_lst.append(np.random.randint(0, h))
+            index_lst.append(np.random.randint(0, len(self.candidates)))
+        return cutout, n_holes, x1_lst, y1_lst, index_lst
+
+    def transform(self, results: dict) -> dict:
+        """Call function to drop some regions of image."""
+        cutout, n_holes, x1_lst, y1_lst, index_lst = self.generate_patches(
+            results)
+        if cutout:
+            h, w, c = results['img'].shape
+            for i in range(n_holes):
+                x1 = x1_lst[i]
+                y1 = y1_lst[i]
+                index = index_lst[i]
+                if not self.with_ratio:
+                    cutout_w, cutout_h = self.candidates[index]
+                else:
+                    cutout_w = int(self.candidates[index][0] * w)
+                    cutout_h = int(self.candidates[index][1] * h)
+
+                x2 = np.clip(x1 + cutout_w, 0, w)
+                y2 = np.clip(y1 + cutout_h, 0, h)
+                results['img'][y1:y2, x1:x2, :] = self.fill_in
+
+                if self.seg_fill_in is not None:
+                    for key in results.get('seg_fields', []):
+                        results[key][y1:y2, x1:x2] = self.seg_fill_in
+
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(prob={self.prob}, '
+        repr_str += f'n_holes={self.n_holes}, '
+        repr_str += (f'cutout_ratio={self.candidates}, ' if self.with_ratio
+                     else f'cutout_shape={self.candidates}, ')
+        repr_str += f'fill_in={self.fill_in}, '
+        repr_str += f'seg_fill_in={self.seg_fill_in})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class RandomRotFlip(BaseTransform):
+    """Rotate and flip the image & seg or just rotate the image & seg.
+
+    Required Keys:
+
+    - img
+    - gt_seg_map
+
+    Modified Keys:
+
+    - img
+    - gt_seg_map
+
+    Args:
+        rotate_prob (float): The probability of rotate image.
+        flip_prob (float): The probability of rotate&flip image.
+        degree (float, tuple[float]): Range of degrees to select from. If
+            degree is a number instead of tuple like (min, max),
+            the range of degree will be (``-degree``, ``+degree``)
+    """
+
+    def __init__(self, rotate_prob=0.5, flip_prob=0.5, degree=(-20, 20)):
+        self.rotate_prob = rotate_prob
+        self.flip_prob = flip_prob
+        assert 0 <= rotate_prob <= 1 and 0 <= flip_prob <= 1
+        if isinstance(degree, (float, int)):
+            assert degree > 0, f'degree {degree} should be positive'
+            self.degree = (-degree, degree)
+        else:
+            self.degree = degree
+        assert len(self.degree) == 2, f'degree {self.degree} should be a ' \
+                                      f'tuple of (min, max)'
+
+    def random_rot_flip(self, results: dict) -> dict:
+        k = np.random.randint(0, 4)
+        results['img'] = np.rot90(results['img'], k)
+        for key in results.get('seg_fields', []):
+            results[key] = np.rot90(results[key], k)
+        axis = np.random.randint(0, 2)
+        results['img'] = np.flip(results['img'], axis=axis).copy()
+        for key in results.get('seg_fields', []):
+            results[key] = np.flip(results[key], axis=axis).copy()
+        return results
+
+    def random_rotate(self, results: dict) -> dict:
+        angle = np.random.uniform(min(*self.degree), max(*self.degree))
+        results['img'] = mmcv.imrotate(results['img'], angle=angle)
+        for key in results.get('seg_fields', []):
+            results[key] = mmcv.imrotate(results[key], angle=angle)
+        return results
+
+    def transform(self, results: dict) -> dict:
+        """Call function to rotate or rotate & flip image, semantic
+        segmentation maps.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Rotated or rotated & flipped results.
+        """
+        rotate_flag = 0
+        if random.random() < self.rotate_prob:
+            results = self.random_rotate(results)
+            rotate_flag = 1
+        if random.random() < self.flip_prob and rotate_flag == 0:
+            results = self.random_rot_flip(results)
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(rotate_prob={self.rotate_prob}, ' \
+                    f'flip_prob={self.flip_prob}, ' \
+                    f'degree={self.degree})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class RandomFlip(MMCV_RandomFlip):
+    """Flip the image & bbox & segmentation map. Added or Updated
+    keys: flip, flip_direction, img, gt_bboxes, gt_seg_map, and gt_depth_map.
+    There are 3 flip modes:
+
+    - ``prob`` is float, ``direction`` is string: the image will be
+      ``direction``ly flipped with probability of ``prob`` .
+      E.g., ``prob=0.5``, ``direction='horizontal'``,
+      then image will be horizontally flipped with probability of 0.5.
+
+    - ``prob`` is float, ``direction`` is list of string: the image will
+      be ``direction[i]``ly flipped with probability of
+      ``prob/len(direction)``.
+      E.g., ``prob=0.5``, ``direction=['horizontal', 'vertical']``,
+      then image will be horizontally flipped with probability of 0.25,
+      vertically with probability of 0.25.
+
+    - ``prob`` is list of float, ``direction`` is list of string:
+      given ``len(prob) == len(direction)``, the image will
+      be ``direction[i]``ly flipped with probability of ``prob[i]``.
+      E.g., ``prob=[0.3, 0.5]``, ``direction=['horizontal',
+      'vertical']``, then image will be horizontally flipped with
+      probability of 0.3, vertically with probability of 0.5.
+
+    Required Keys:
+
+    - img
+    - gt_bboxes (optional)
+    - gt_seg_map (optional)
+    - gt_depth_map (optional)
+
+    Modified Keys:
+
+    - img
+    - gt_bboxes (optional)
+    - gt_seg_map (optional)
+    - gt_depth_map (optional)
+
+    Added Keys:
+
+    - flip
+    - flip_direction
+    - swap_seg_labels (optional)
+
+    Args:
+        prob (float | list[float], optional): The flipping probability.
+            Defaults to None.
+        direction(str | list[str]): The flipping direction. Options
+            If input is a list, the length must equal ``prob``. Each
+            element in ``prob`` indicates the flip probability of
+            corresponding direction. Defaults to 'horizontal'.
+        swap_seg_labels (list, optional): The label pair need to be swapped
+            for ground truth, like 'left arm' and 'right arm' need to be
+            swapped after horizontal flipping. For example, ``[(1, 5)]``,
+            where 1/5 is the label of the left/right arm. Defaults to None.
+    """
+
+    def _flip(self, results: dict) -> None:
+        """Flip images, bounding boxes and semantic segmentation map."""
+        # flip image
+        results['img'] = mmcv.imflip(
+            results['img'], direction=results['flip_direction'])
+
+        img_shape = results['img'].shape[:2]
+
+        # flip bboxes
+        if results.get('gt_bboxes', None) is not None:
+            results['gt_bboxes'] = self._flip_bbox(results['gt_bboxes'],
+                                                   img_shape,
+                                                   results['flip_direction'])
+
+        # flip seg map
+        for key in results.get('seg_fields', []):
+            if results.get(key, None) is not None:
+                results[key] = self._flip_seg_map(
+                    results[key], direction=results['flip_direction']).copy()
+                results['swap_seg_labels'] = self.swap_seg_labels
+
+
+@TRANSFORMS.register_module()
+class Resize(MMCV_Resize):
+    """Resize images & seg & depth map.
+
+    This transform resizes the input image according to ``scale`` or
+    ``scale_factor``. Seg map, depth map and other relative annotations are
+    then resized with the same scale factor.
+    if ``scale`` and ``scale_factor`` are both set, it will use ``scale`` to
+    resize.
+
+    Required Keys:
+
+    - img
+    - gt_seg_map (optional)
+    - gt_depth_map (optional)
+
+    Modified Keys:
+
+    - img
+    - gt_seg_map
+    - gt_depth_map
+
+    Added Keys:
+
+    - scale
+    - scale_factor
+    - keep_ratio
+
+    Args:
+        scale (int or tuple): Images scales for resizing. Defaults to None
+        scale_factor (float or tuple[float]): Scale factors for resizing.
+            Defaults to None.
+        keep_ratio (bool): Whether to keep the aspect ratio when resizing the
+            image. Defaults to False.
+        clip_object_border (bool): Whether to clip the objects
+            outside the border of the image. In some dataset like MOT17, the gt
+            bboxes are allowed to cross the border of images. Therefore, we
+            don't need to clip the gt bboxes in these cases. Defaults to True.
+        backend (str): Image resize backend, choices are 'cv2' and 'pillow'.
+            These two backends generates slightly different results. Defaults
+            to 'cv2'.
+        interpolation (str): Interpolation method, accepted values are
+            "nearest", "bilinear", "bicubic", "area", "lanczos" for 'cv2'
+            backend, "nearest", "bilinear" for 'pillow' backend. Defaults
+            to 'bilinear'.
+    """
+
+    def _resize_seg(self, results: dict) -> None:
+        """Resize semantic segmentation map with ``results['scale']``."""
+        for seg_key in results.get('seg_fields', []):
+            if results.get(seg_key, None) is not None:
+                if self.keep_ratio:
+                    gt_seg = mmcv.imrescale(
+                        results[seg_key],
+                        results['scale'],
+                        interpolation='nearest',
+                        backend=self.backend)
+                else:
+                    gt_seg = mmcv.imresize(
+                        results[seg_key],
+                        results['scale'],
+                        interpolation='nearest',
+                        backend=self.backend)
+                results[seg_key] = gt_seg
+
+
+@TRANSFORMS.register_module()
+class RandomMosaic(BaseTransform):
+    """Mosaic augmentation. Given 4 images, mosaic transform combines them into
+    one output image. The output image is composed of the parts from each sub-
+    image.
+
+    .. code:: text
+
+                        mosaic transform
+                           center_x
+                +------------------------------+
+                |       pad        |  pad      |
+                |      +-----------+           |
+                |      |           |           |
+                |      |  image1   |--------+  |
+                |      |           |        |  |
+                |      |           | image2 |  |
+     center_y   |----+-------------+-----------|
+                |    |   cropped   |           |
+                |pad |   image3    |  image4   |
+                |    |             |           |
+                +----|-------------+-----------+
+                     |             |
+                     +-------------+
+
+     The mosaic transform steps are as follows:
+         1. Choose the mosaic center as the intersections of 4 images
+         2. Get the left top image according to the index, and randomly
+            sample another 3 images from the custom dataset.
+         3. Sub image will be cropped if image is larger than mosaic patch
+
+    Required Keys:
+
+    - img
+    - gt_seg_map
+    - mix_results
+
+    Modified Keys:
+
+    - img
+    - img_shape
+    - ori_shape
+    - gt_seg_map
+
+    Args:
+        prob (float): mosaic probability.
+        img_scale (Sequence[int]): Image size after mosaic pipeline of
+            a single image. The size of the output image is four times
+            that of a single image. The output image comprises 4 single images.
+            Default: (640, 640).
+        center_ratio_range (Sequence[float]): Center ratio range of mosaic
+            output. Default: (0.5, 1.5).
+        pad_val (int): Pad value. Default: 0.
+        seg_pad_val (int): Pad value of segmentation map. Default: 255.
+    """
+
+    def __init__(self,
+                 prob,
+                 img_scale=(640, 640),
+                 center_ratio_range=(0.5, 1.5),
+                 pad_val=0,
+                 seg_pad_val=255):
+        assert 0 <= prob and prob <= 1
+        assert isinstance(img_scale, tuple)
+        self.prob = prob
+        self.img_scale = img_scale
+        self.center_ratio_range = center_ratio_range
+        self.pad_val = pad_val
+        self.seg_pad_val = seg_pad_val
+
+    @cache_randomness
+    def do_mosaic(self):
+        return np.random.rand() < self.prob
+
+    def transform(self, results: dict) -> dict:
+        """Call function to make a mosaic of image.
+
+        Args:
+            results (dict): Result dict.
+
+        Returns:
+            dict: Result dict with mosaic transformed.
+        """
+        mosaic = self.do_mosaic()
+        if mosaic:
+            results = self._mosaic_transform_img(results)
+            results = self._mosaic_transform_seg(results)
+        return results
+
+    def get_indices(self, dataset: MultiImageMixDataset) -> list:
+        """Call function to collect indices.
+
+        Args:
+            dataset (:obj:`MultiImageMixDataset`): The dataset.
+
+        Returns:
+            list: indices.
+        """
+
+        indices = [random.randint(0, len(dataset)) for _ in range(3)]
+        return indices
+
+    @cache_randomness
+    def generate_mosaic_center(self):
+        # mosaic center x, y
+        center_x = int(
+            random.uniform(*self.center_ratio_range) * self.img_scale[1])
+        center_y = int(
+            random.uniform(*self.center_ratio_range) * self.img_scale[0])
+        return center_x, center_y
+
+    def _mosaic_transform_img(self, results: dict) -> dict:
+        """Mosaic transform function.
+
+        Args:
+            results (dict): Result dict.
+
+        Returns:
+            dict: Updated result dict.
+        """
+
+        assert 'mix_results' in results
+        if len(results['img'].shape) == 3:
+            c = results['img'].shape[2]
+            mosaic_img = np.full(
+                (int(self.img_scale[0] * 2), int(self.img_scale[1] * 2), c),
+                self.pad_val,
+                dtype=results['img'].dtype)
+        else:
+            mosaic_img = np.full(
+                (int(self.img_scale[0] * 2), int(self.img_scale[1] * 2)),
+                self.pad_val,
+                dtype=results['img'].dtype)
+
+        # mosaic center x, y
+        self.center_x, self.center_y = self.generate_mosaic_center()
+        center_position = (self.center_x, self.center_y)
+
+        loc_strs = ('top_left', 'top_right', 'bottom_left', 'bottom_right')
+        for i, loc in enumerate(loc_strs):
+            if loc == 'top_left':
+                result_patch = copy.deepcopy(results)
+            else:
+                result_patch = copy.deepcopy(results['mix_results'][i - 1])
+
+            img_i = result_patch['img']
+            h_i, w_i = img_i.shape[:2]
+            # keep_ratio resize
+            scale_ratio_i = min(self.img_scale[0] / h_i,
+                                self.img_scale[1] / w_i)
+            img_i = mmcv.imresize(
+                img_i, (int(w_i * scale_ratio_i), int(h_i * scale_ratio_i)))
+
+            # compute the combine parameters
+            paste_coord, crop_coord = self._mosaic_combine(
+                loc, center_position, img_i.shape[:2][::-1])
+            x1_p, y1_p, x2_p, y2_p = paste_coord
+            x1_c, y1_c, x2_c, y2_c = crop_coord
+
+            # crop and paste image
+            mosaic_img[y1_p:y2_p, x1_p:x2_p] = img_i[y1_c:y2_c, x1_c:x2_c]
+
+        results['img'] = mosaic_img
+        results['img_shape'] = mosaic_img.shape
+        results['ori_shape'] = mosaic_img.shape
+
+        return results
+
+    def _mosaic_transform_seg(self, results: dict) -> dict:
+        """Mosaic transform function for label annotations.
+
+        Args:
+            results (dict): Result dict.
+
+        Returns:
+            dict: Updated result dict.
+        """
+
+        assert 'mix_results' in results
+        for key in results.get('seg_fields', []):
+            mosaic_seg = np.full(
+                (int(self.img_scale[0] * 2), int(self.img_scale[1] * 2)),
+                self.seg_pad_val,
+                dtype=results[key].dtype)
+
+            # mosaic center x, y
+            center_position = (self.center_x, self.center_y)
+
+            loc_strs = ('top_left', 'top_right', 'bottom_left', 'bottom_right')
+            for i, loc in enumerate(loc_strs):
+                if loc == 'top_left':
+                    result_patch = copy.deepcopy(results)
+                else:
+                    result_patch = copy.deepcopy(results['mix_results'][i - 1])
+
+                gt_seg_i = result_patch[key]
+                h_i, w_i = gt_seg_i.shape[:2]
+                # keep_ratio resize
+                scale_ratio_i = min(self.img_scale[0] / h_i,
+                                    self.img_scale[1] / w_i)
+                gt_seg_i = mmcv.imresize(
+                    gt_seg_i,
+                    (int(w_i * scale_ratio_i), int(h_i * scale_ratio_i)),
+                    interpolation='nearest')
+
+                # compute the combine parameters
+                paste_coord, crop_coord = self._mosaic_combine(
+                    loc, center_position, gt_seg_i.shape[:2][::-1])
+                x1_p, y1_p, x2_p, y2_p = paste_coord
+                x1_c, y1_c, x2_c, y2_c = crop_coord
+
+                # crop and paste image
+                mosaic_seg[y1_p:y2_p, x1_p:x2_p] = \
+                    gt_seg_i[y1_c:y2_c, x1_c:x2_c]
+
+            results[key] = mosaic_seg
+
+        return results
+
+    def _mosaic_combine(self, loc: str, center_position_xy: Sequence[float],
+                        img_shape_wh: Sequence[int]) -> tuple:
+        """Calculate global coordinate of mosaic image and local coordinate of
+        cropped sub-image.
+
+        Args:
+            loc (str): Index for the sub-image, loc in ('top_left',
+              'top_right', 'bottom_left', 'bottom_right').
+            center_position_xy (Sequence[float]): Mixing center for 4 images,
+                (x, y).
+            img_shape_wh (Sequence[int]): Width and height of sub-image
+
+        Returns:
+            tuple[tuple[float]]: Corresponding coordinate of pasting and
+                cropping
+                - paste_coord (tuple): paste corner coordinate in mosaic image.
+                - crop_coord (tuple): crop corner coordinate in mosaic image.
+        """
+
+        assert loc in ('top_left', 'top_right', 'bottom_left', 'bottom_right')
+        if loc == 'top_left':
+            # index0 to top left part of image
+            x1, y1, x2, y2 = max(center_position_xy[0] - img_shape_wh[0], 0), \
+                             max(center_position_xy[1] - img_shape_wh[1], 0), \
+                             center_position_xy[0], \
+                             center_position_xy[1]
+            crop_coord = img_shape_wh[0] - (x2 - x1), img_shape_wh[1] - (
+                y2 - y1), img_shape_wh[0], img_shape_wh[1]
+
+        elif loc == 'top_right':
+            # index1 to top right part of image
+            x1, y1, x2, y2 = center_position_xy[0], \
+                             max(center_position_xy[1] - img_shape_wh[1], 0), \
+                             min(center_position_xy[0] + img_shape_wh[0],
+                                 self.img_scale[1] * 2), \
+                             center_position_xy[1]
+            crop_coord = 0, img_shape_wh[1] - (y2 - y1), min(
+                img_shape_wh[0], x2 - x1), img_shape_wh[1]
+
+        elif loc == 'bottom_left':
+            # index2 to bottom left part of image
+            x1, y1, x2, y2 = max(center_position_xy[0] - img_shape_wh[0], 0), \
+                             center_position_xy[1], \
+                             center_position_xy[0], \
+                             min(self.img_scale[0] * 2, center_position_xy[1] +
+                                 img_shape_wh[1])
+            crop_coord = img_shape_wh[0] - (x2 - x1), 0, img_shape_wh[0], min(
+                y2 - y1, img_shape_wh[1])
+
+        else:
+            # index3 to bottom right part of image
+            x1, y1, x2, y2 = center_position_xy[0], \
+                             center_position_xy[1], \
+                             min(center_position_xy[0] + img_shape_wh[0],
+                                 self.img_scale[1] * 2), \
+                             min(self.img_scale[0] * 2, center_position_xy[1] +
+                                 img_shape_wh[1])
+            crop_coord = 0, 0, min(img_shape_wh[0],
+                                   x2 - x1), min(y2 - y1, img_shape_wh[1])
+
+        paste_coord = x1, y1, x2, y2
+        return paste_coord, crop_coord
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(prob={self.prob}, '
+        repr_str += f'img_scale={self.img_scale}, '
+        repr_str += f'center_ratio_range={self.center_ratio_range}, '
+        repr_str += f'pad_val={self.pad_val}, '
+        repr_str += f'seg_pad_val={self.pad_val})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class GenerateEdge(BaseTransform):
+    """Generate Edge for CE2P approach.
+
+    Edge will be used to calculate loss of
+    `CE2P <https://arxiv.org/abs/1809.05996>`_.
+
+    Modified from https://github.com/liutinglt/CE2P/blob/master/dataset/target_generation.py # noqa:E501
+
+    Required Keys:
+
+        - img_shape
+        - gt_seg_map
+
+    Added Keys:
+        - gt_edge_map (np.ndarray, uint8): The edge annotation generated from the
+            seg map by extracting border between different semantics.
+
+    Args:
+        edge_width (int): The width of edge. Default to 3.
+        ignore_index (int): Index that will be ignored. Default to 255.
+    """
+
+    def __init__(self, edge_width: int = 3, ignore_index: int = 255) -> None:
+        super().__init__()
+        self.edge_width = edge_width
+        self.ignore_index = ignore_index
+
+    def transform(self, results: Dict) -> Dict:
+        """Call function to generate edge from segmentation map.
+
+        Args:
+            results (dict): Result dict.
+
+        Returns:
+            dict: Result dict with edge mask.
+        """
+        h, w = results['img_shape']
+        edge = np.zeros((h, w), dtype=np.uint8)
+        seg_map = results['gt_seg_map']
+
+        # down
+        edge_down = edge[1:h, :]
+        edge_down[(seg_map[1:h, :] != seg_map[:h - 1, :])
+                  & (seg_map[1:h, :] != self.ignore_index) &
+                  (seg_map[:h - 1, :] != self.ignore_index)] = 1
+        # left
+        edge_left = edge[:, :w - 1]
+        edge_left[(seg_map[:, :w - 1] != seg_map[:, 1:w])
+                  & (seg_map[:, :w - 1] != self.ignore_index) &
+                  (seg_map[:, 1:w] != self.ignore_index)] = 1
+        # up_left
+        edge_upleft = edge[:h - 1, :w - 1]
+        edge_upleft[(seg_map[:h - 1, :w - 1] != seg_map[1:h, 1:w])
+                    & (seg_map[:h - 1, :w - 1] != self.ignore_index) &
+                    (seg_map[1:h, 1:w] != self.ignore_index)] = 1
+        # up_right
+        edge_upright = edge[:h - 1, 1:w]
+        edge_upright[(seg_map[:h - 1, 1:w] != seg_map[1:h, :w - 1])
+                     & (seg_map[:h - 1, 1:w] != self.ignore_index) &
+                     (seg_map[1:h, :w - 1] != self.ignore_index)] = 1
+
+        kernel = cv2.getStructuringElement(cv2.MORPH_RECT,
+                                           (self.edge_width, self.edge_width))
+        edge = cv2.dilate(edge, kernel)
+
+        results['gt_edge_map'] = edge
+        results['edge_width'] = self.edge_width
+
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'edge_width={self.edge_width}, '
+        repr_str += f'ignore_index={self.ignore_index})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class ResizeShortestEdge(BaseTransform):
+    """Resize the image and mask while keeping the aspect ratio unchanged.
+
+    Modified from https://github.com/facebookresearch/detectron2/blob/main/detectron2/data/transforms/augmentation_impl.py#L130 # noqa:E501
+    Copyright (c) Facebook, Inc. and its affiliates.
+    Licensed under the Apache-2.0 License
+
+    This transform attempts to scale the shorter edge to the given
+    `scale`, as long as the longer edge does not exceed `max_size`.
+    If `max_size` is reached, then downscale so that the longer
+    edge does not exceed `max_size`.
+
+    Required Keys:
+
+    - img
+    - gt_seg_map (optional)
+
+    Modified Keys:
+
+    - img
+    - img_shape
+    - gt_seg_map (optional))
+
+    Added Keys:
+
+    - scale
+    - scale_factor
+    - keep_ratio
+
+
+    Args:
+        scale (Union[int, Tuple[int, int]]): The target short edge length.
+            If it's tuple, will select the min value as the short edge length.
+        max_size (int): The maximum allowed longest edge length.
+    """
+
+    def __init__(self, scale: Union[int, Tuple[int, int]],
+                 max_size: int) -> None:
+        super().__init__()
+        self.scale = scale
+        self.max_size = max_size
+
+        # Create a empty Resize object
+        self.resize = TRANSFORMS.build({
+            'type': 'Resize',
+            'scale': 0,
+            'keep_ratio': True
+        })
+
+    def _get_output_shape(self, img, short_edge_length) -> Tuple[int, int]:
+        """Compute the target image shape with the given `short_edge_length`.
+
+        Args:
+            img (np.ndarray): The input image.
+            short_edge_length (Union[int, Tuple[int, int]]): The target short
+                edge length. If it's tuple, will select the min value as the
+                short edge length.
+        """
+        h, w = img.shape[:2]
+        if isinstance(short_edge_length, int):
+            size = short_edge_length * 1.0
+        elif isinstance(short_edge_length, tuple):
+            size = min(short_edge_length) * 1.0
+        scale = size / min(h, w)
+        if h < w:
+            new_h, new_w = size, scale * w
+        else:
+            new_h, new_w = scale * h, size
+
+        if max(new_h, new_w) > self.max_size:
+            scale = self.max_size * 1.0 / max(new_h, new_w)
+            new_h *= scale
+            new_w *= scale
+
+        new_h = int(new_h + 0.5)
+        new_w = int(new_w + 0.5)
+        return (new_w, new_h)
+
+    def transform(self, results: Dict) -> Dict:
+        self.resize.scale = self._get_output_shape(results['img'], self.scale)
+        return self.resize(results)
+
+
+@TRANSFORMS.register_module()
+class BioMedical3DRandomCrop(BaseTransform):
+    """Crop the input patch for medical image & segmentation mask.
+
+    Required Keys:
+
+    - img (np.ndarray): Biomedical image with shape (N, Z, Y, X),
+        N is the number of modalities, and data type is float32.
+    - gt_seg_map (np.ndarray, optional): Biomedical semantic segmentation mask
+        with shape (Z, Y, X).
+
+    Modified Keys:
+
+        - img
+        - img_shape
+        - gt_seg_map (optional)
+
+    Args:
+        crop_shape (Union[int, Tuple[int, int, int]]):  Expected size after
+            cropping with the format of (z, y, x). If set to an integer,
+            then cropping width and height are equal to this integer.
+        keep_foreground (bool): If keep_foreground is True, it will sample a
+            voxel of foreground classes randomly, and will take it as the
+            center of the crop bounding-box. Default to True.
+    """
+
+    def __init__(self,
+                 crop_shape: Union[int, Tuple[int, int, int]],
+                 keep_foreground: bool = True):
+        super().__init__()
+        assert isinstance(crop_shape, int) or (
+            isinstance(crop_shape, tuple) and len(crop_shape) == 3
+        ), 'The expected crop_shape is an integer, or a tuple containing '
+        'three integers'
+
+        if isinstance(crop_shape, int):
+            crop_shape = (crop_shape, crop_shape, crop_shape)
+        assert crop_shape[0] > 0 and crop_shape[1] > 0 and crop_shape[2] > 0
+        self.crop_shape = crop_shape
+        self.keep_foreground = keep_foreground
+
+    def random_sample_location(self, seg_map: np.ndarray) -> dict:
+        """sample foreground voxel when keep_foreground is True.
+
+        Args:
+            seg_map (np.ndarray): gt seg map.
+
+        Returns:
+            dict: Coordinates of selected foreground voxel.
+        """
+        num_samples = 10000
+        # at least 1% of the class voxels need to be selected,
+        # otherwise it may be too sparse
+        min_percent_coverage = 0.01
+        class_locs = {}
+        foreground_classes = []
+        all_classes = np.unique(seg_map)
+        for c in all_classes:
+            if c == 0:
+                # to avoid the segmentation mask full of background 0
+                # and the class_locs is just void dictionary {} when it return
+                # there add a void list for background 0.
+                class_locs[c] = []
+            else:
+                all_locs = np.argwhere(seg_map == c)
+                target_num_samples = min(num_samples, len(all_locs))
+                target_num_samples = max(
+                    target_num_samples,
+                    int(np.ceil(len(all_locs) * min_percent_coverage)))
+
+                selected = all_locs[np.random.choice(
+                    len(all_locs), target_num_samples, replace=False)]
+                class_locs[c] = selected
+                foreground_classes.append(c)
+
+        selected_voxel = None
+        if len(foreground_classes) > 0:
+            selected_class = np.random.choice(foreground_classes)
+            voxels_of_that_class = class_locs[selected_class]
+            selected_voxel = voxels_of_that_class[np.random.choice(
+                len(voxels_of_that_class))]
+
+        return selected_voxel
+
+    def random_generate_crop_bbox(self, margin_z: int, margin_y: int,
+                                  margin_x: int) -> tuple:
+        """Randomly get a crop bounding box.
+
+        Args:
+            seg_map (np.ndarray): Ground truth segmentation map.
+
+        Returns:
+            tuple: Coordinates of the cropped image.
+        """
+        offset_z = np.random.randint(0, margin_z + 1)
+        offset_y = np.random.randint(0, margin_y + 1)
+        offset_x = np.random.randint(0, margin_x + 1)
+        crop_z1, crop_z2 = offset_z, offset_z + self.crop_shape[0]
+        crop_y1, crop_y2 = offset_y, offset_y + self.crop_shape[1]
+        crop_x1, crop_x2 = offset_x, offset_x + self.crop_shape[2]
+
+        return crop_z1, crop_z2, crop_y1, crop_y2, crop_x1, crop_x2
+
+    def generate_margin(self, results: dict) -> tuple:
+        """Generate margin of crop bounding-box.
+
+        If keep_foreground is True, it will sample a voxel of foreground
+        classes randomly, and will take it as the center of the bounding-box,
+        and return the margin between of the bounding-box and image.
+        If keep_foreground is False, it will return the difference from crop
+        shape and image shape.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            tuple: The margin for 3 dimensions of crop bounding-box and image.
+        """
+
+        seg_map = results['gt_seg_map']
+        if self.keep_foreground:
+            selected_voxel = self.random_sample_location(seg_map)
+            if selected_voxel is None:
+                # this only happens if some image does not contain
+                # foreground voxels at all
+                warnings.warn(f'case does not contain any foreground classes'
+                              f': {results["img_path"]}')
+                margin_z = max(seg_map.shape[0] - self.crop_shape[0], 0)
+                margin_y = max(seg_map.shape[1] - self.crop_shape[1], 0)
+                margin_x = max(seg_map.shape[2] - self.crop_shape[2], 0)
+            else:
+                margin_z = max(0, selected_voxel[0] - self.crop_shape[0] // 2)
+                margin_y = max(0, selected_voxel[1] - self.crop_shape[1] // 2)
+                margin_x = max(0, selected_voxel[2] - self.crop_shape[2] // 2)
+                margin_z = max(
+                    0, min(seg_map.shape[0] - self.crop_shape[0], margin_z))
+                margin_y = max(
+                    0, min(seg_map.shape[1] - self.crop_shape[1], margin_y))
+                margin_x = max(
+                    0, min(seg_map.shape[2] - self.crop_shape[2], margin_x))
+        else:
+            margin_z = max(seg_map.shape[0] - self.crop_shape[0], 0)
+            margin_y = max(seg_map.shape[1] - self.crop_shape[1], 0)
+            margin_x = max(seg_map.shape[2] - self.crop_shape[2], 0)
+
+        return margin_z, margin_y, margin_x
+
+    def crop(self, img: np.ndarray, crop_bbox: tuple) -> np.ndarray:
+        """Crop from ``img``
+
+        Args:
+            img (np.ndarray): Original input image.
+            crop_bbox (tuple): Coordinates of the cropped image.
+
+        Returns:
+            np.ndarray: The cropped image.
+        """
+        crop_z1, crop_z2, crop_y1, crop_y2, crop_x1, crop_x2 = crop_bbox
+        if len(img.shape) == 3:
+            # crop seg map
+            img = img[crop_z1:crop_z2, crop_y1:crop_y2, crop_x1:crop_x2]
+        else:
+            # crop image
+            assert len(img.shape) == 4
+            img = img[:, crop_z1:crop_z2, crop_y1:crop_y2, crop_x1:crop_x2]
+        return img
+
+    def transform(self, results: dict) -> dict:
+        """Transform function to randomly crop images, semantic segmentation
+        maps.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Randomly cropped results, 'img_shape' key in result dict is
+                updated according to crop size.
+        """
+        margin = self.generate_margin(results)
+        crop_bbox = self.random_generate_crop_bbox(*margin)
+
+        # crop the image
+        img = results['img']
+        results['img'] = self.crop(img, crop_bbox)
+        results['img_shape'] = results['img'].shape[1:]
+
+        # crop semantic seg
+        seg_map = results['gt_seg_map']
+        results['gt_seg_map'] = self.crop(seg_map, crop_bbox)
+
+        return results
+
+    def __repr__(self):
+        return self.__class__.__name__ + f'(crop_shape={self.crop_shape})'
+
+
+@TRANSFORMS.register_module()
+class BioMedicalGaussianNoise(BaseTransform):
+    """Add random Gaussian noise to image.
+
+    Modified from https://github.com/MIC-DKFZ/batchgenerators/blob/7651ece69faf55263dd582a9f5cbd149ed9c3ad0/batchgenerators/transforms/noise_transforms.py#L53  # noqa:E501
+
+    Copyright (c) German Cancer Research Center (DKFZ)
+    Licensed under the Apache License, Version 2.0
+
+    Required Keys:
+
+    - img (np.ndarray): Biomedical image with shape (N, Z, Y, X),
+            N is the number of modalities, and data type is float32.
+
+    Modified Keys:
+
+    - img
+
+    Args:
+        prob (float): Probability to add Gaussian noise for
+            each sample. Default to 0.1.
+        mean (float): Mean or “centre” of the distribution. Default to 0.0.
+        std (float): Standard deviation of distribution. Default to 0.1.
+    """
+
+    def __init__(self,
+                 prob: float = 0.1,
+                 mean: float = 0.0,
+                 std: float = 0.1) -> None:
+        super().__init__()
+        assert 0.0 <= prob <= 1.0 and std >= 0.0
+        self.prob = prob
+        self.mean = mean
+        self.std = std
+
+    def transform(self, results: Dict) -> Dict:
+        """Call function to add random Gaussian noise to image.
+
+        Args:
+            results (dict): Result dict.
+
+        Returns:
+            dict: Result dict with random Gaussian noise.
+        """
+        if np.random.rand() < self.prob:
+            rand_std = np.random.uniform(0, self.std)
+            noise = np.random.normal(
+                self.mean, rand_std, size=results['img'].shape)
+            # noise is float64 array, convert to the results['img'].dtype
+            noise = noise.astype(results['img'].dtype)
+            results['img'] = results['img'] + noise
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(prob={self.prob}, '
+        repr_str += f'mean={self.mean}, '
+        repr_str += f'std={self.std})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class BioMedicalGaussianBlur(BaseTransform):
+    """Add Gaussian blur with random sigma to image.
+
+    Modified from https://github.com/MIC-DKFZ/batchgenerators/blob/7651ece69faf55263dd582a9f5cbd149ed9c3ad0/batchgenerators/transforms/noise_transforms.py#L81 # noqa:E501
+
+    Copyright (c) German Cancer Research Center (DKFZ)
+    Licensed under the Apache License, Version 2.0
+
+    Required Keys:
+
+    - img (np.ndarray): Biomedical image with shape (N, Z, Y, X),
+            N is the number of modalities, and data type is float32.
+
+    Modified Keys:
+
+    - img
+
+    Args:
+        sigma_range (Tuple[float, float]|float): range to randomly
+            select sigma value. Default to (0.5, 1.0).
+        prob (float): Probability to apply Gaussian blur
+            for each sample. Default to 0.2.
+        prob_per_channel  (float): Probability to apply Gaussian blur
+            for each channel (axis N of the image). Default to 0.5.
+        different_sigma_per_channel (bool): whether to use different
+            sigma for each channel (axis N of the image). Default to True.
+        different_sigma_per_axis (bool): whether to use different
+            sigma for axis Z, X and Y of the image. Default to True.
+    """
+
+    def __init__(self,
+                 sigma_range: Tuple[float, float] = (0.5, 1.0),
+                 prob: float = 0.2,
+                 prob_per_channel: float = 0.5,
+                 different_sigma_per_channel: bool = True,
+                 different_sigma_per_axis: bool = True) -> None:
+        super().__init__()
+        assert 0.0 <= prob <= 1.0
+        assert 0.0 <= prob_per_channel <= 1.0
+        assert isinstance(sigma_range, Sequence) and len(sigma_range) == 2
+        self.sigma_range = sigma_range
+        self.prob = prob
+        self.prob_per_channel = prob_per_channel
+        self.different_sigma_per_channel = different_sigma_per_channel
+        self.different_sigma_per_axis = different_sigma_per_axis
+
+    def _get_valid_sigma(self, value_range) -> Tuple[float, ...]:
+        """Ensure the `value_range` to be either a single value or a sequence
+        of two values. If the `value_range` is a sequence, generate a random
+        value with `[value_range[0], value_range[1]]` based on uniform
+        sampling.
+
+        Modified from https://github.com/MIC-DKFZ/batchgenerators/blob/7651ece69faf55263dd582a9f5cbd149ed9c3ad0/batchgenerators/augmentations/utils.py#L625 # noqa:E501
+
+        Args:
+            value_range (tuple|list|float|int): the input value range
+        """
+        if (isinstance(value_range, (list, tuple))):
+            if (value_range[0] == value_range[1]):
+                value = value_range[0]
+            else:
+                orig_type = type(value_range[0])
+                value = np.random.uniform(value_range[0], value_range[1])
+                value = orig_type(value)
+        return value
+
+    def _gaussian_blur(self, data_sample: np.ndarray) -> np.ndarray:
+        """Random generate sigma and apply Gaussian Blur to the data
+        Args:
+            data_sample (np.ndarray): data sample with multiple modalities,
+                the data shape is (N, Z, Y, X)
+        """
+        sigma = None
+        for c in range(data_sample.shape[0]):
+            if np.random.rand() < self.prob_per_channel:
+                # if no `sigma` is generated, generate one
+                # if `self.different_sigma_per_channel` is True,
+                # re-generate random sigma for each channel
+                if (sigma is None or self.different_sigma_per_channel):
+                    if (not self.different_sigma_per_axis):
+                        sigma = self._get_valid_sigma(self.sigma_range)
+                    else:
+                        sigma = [
+                            self._get_valid_sigma(self.sigma_range)
+                            for _ in data_sample.shape[1:]
+                        ]
+                # apply gaussian filter with `sigma`
+                data_sample[c] = gaussian_filter(
+                    data_sample[c], sigma, order=0)
+        return data_sample
+
+    def transform(self, results: Dict) -> Dict:
+        """Call function to add random Gaussian blur to image.
+
+        Args:
+            results (dict): Result dict.
+
+        Returns:
+            dict: Result dict with random Gaussian noise.
+        """
+        if np.random.rand() < self.prob:
+            results['img'] = self._gaussian_blur(results['img'])
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(prob={self.prob}, '
+        repr_str += f'prob_per_channel={self.prob_per_channel}, '
+        repr_str += f'sigma_range={self.sigma_range}, '
+        repr_str += 'different_sigma_per_channel=' \
+                    f'{self.different_sigma_per_channel}, '
+        repr_str += 'different_sigma_per_axis=' \
+                    f'{self.different_sigma_per_axis})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class BioMedicalRandomGamma(BaseTransform):
+    """Using random gamma correction to process the biomedical image.
+
+    Modified from
+    https://github.com/MIC-DKFZ/batchgenerators/blob/master/batchgenerators/transforms/color_transforms.py#L132 # noqa:E501
+    With licence: Apache 2.0
+
+    Required Keys:
+
+    - img (np.ndarray): Biomedical image with shape (N, Z, Y, X),
+        N is the number of modalities, and data type is float32.
+
+    Modified Keys:
+    - img
+
+    Args:
+        prob (float): The probability to perform this transform. Default: 0.5.
+        gamma_range (Tuple[float]): Range of gamma values. Default: (0.5, 2).
+        invert_image (bool): Whether invert the image before applying gamma
+            augmentation. Default: False.
+        per_channel (bool): Whether perform the transform each channel
+            individually. Default: False
+        retain_stats (bool): Gamma transformation will alter the mean and std
+            of the data in the patch. If retain_stats=True, the data will be
+            transformed to match the mean and standard deviation before gamma
+            augmentation. Default: False.
+    """
+
+    def __init__(self,
+                 prob: float = 0.5,
+                 gamma_range: Tuple[float] = (0.5, 2),
+                 invert_image: bool = False,
+                 per_channel: bool = False,
+                 retain_stats: bool = False):
+        assert 0 <= prob and prob <= 1
+        assert isinstance(gamma_range, tuple) and len(gamma_range) == 2
+        assert isinstance(invert_image, bool)
+        assert isinstance(per_channel, bool)
+        assert isinstance(retain_stats, bool)
+        self.prob = prob
+        self.gamma_range = gamma_range
+        self.invert_image = invert_image
+        self.per_channel = per_channel
+        self.retain_stats = retain_stats
+
+    @cache_randomness
+    def _do_gamma(self):
+        """Whether do adjust gamma for image."""
+        return np.random.rand() < self.prob
+
+    def _adjust_gamma(self, img: np.array):
+        """Gamma adjustment for image.
+
+        Args:
+            img (np.array): Input image before gamma adjust.
+
+        Returns:
+            np.arrays: Image after gamma adjust.
+        """
+
+        if self.invert_image:
+            img = -img
+
+        def _do_adjust(img):
+            if retain_stats_here:
+                img_mean = img.mean()
+                img_std = img.std()
+            if np.random.random() < 0.5 and self.gamma_range[0] < 1:
+                gamma = np.random.uniform(self.gamma_range[0], 1)
+            else:
+                gamma = np.random.uniform(
+                    max(self.gamma_range[0], 1), self.gamma_range[1])
+            img_min = img.min()
+            img_range = img.max() - img_min  # range
+            img = np.power(((img - img_min) / float(img_range + 1e-7)),
+                           gamma) * img_range + img_min
+            if retain_stats_here:
+                img = img - img.mean()
+                img = img / (img.std() + 1e-8) * img_std
+                img = img + img_mean
+            return img
+
+        if not self.per_channel:
+            retain_stats_here = self.retain_stats
+            img = _do_adjust(img)
+        else:
+            for c in range(img.shape[0]):
+                img[c] = _do_adjust(img[c])
+        if self.invert_image:
+            img = -img
+        return img
+
+    def transform(self, results: dict) -> dict:
+        """Call function to perform random gamma correction
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Result dict with random gamma correction performed.
+        """
+        do_gamma = self._do_gamma()
+
+        if do_gamma:
+            results['img'] = self._adjust_gamma(results['img'])
+        else:
+            pass
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(prob={self.prob}, '
+        repr_str += f'gamma_range={self.gamma_range},'
+        repr_str += f'invert_image={self.invert_image},'
+        repr_str += f'per_channel={self.per_channel},'
+        repr_str += f'retain_stats={self.retain_stats}'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class BioMedical3DPad(BaseTransform):
+    """Pad the biomedical 3d image & biomedical 3d semantic segmentation maps.
+
+    Required Keys:
+
+    - img (np.ndarry): Biomedical image with shape (N, Z, Y, X) by default,
+        N is the number of modalities.
+    - gt_seg_map (np.ndarray, optional): Biomedical seg map with shape
+        (Z, Y, X) by default.
+
+    Modified Keys:
+
+    - img (np.ndarry): Biomedical image with shape (N, Z, Y, X) by default,
+        N is the number of modalities.
+    - gt_seg_map (np.ndarray, optional): Biomedical seg map with shape
+        (Z, Y, X) by default.
+
+    Added Keys:
+
+    - pad_shape (Tuple[int, int, int]): The padded shape.
+
+    Args:
+        pad_shape (Tuple[int, int, int]): Fixed padding size.
+            Expected padding shape (Z, Y, X).
+        pad_val (float): Padding value for biomedical image.
+            The padding mode is set to "constant". The value
+            to be filled in padding area. Default: 0.
+        seg_pad_val (int): Padding value for biomedical 3d semantic
+            segmentation maps. The padding mode is set to "constant".
+            The value to be filled in padding area. Default: 0.
+    """
+
+    def __init__(self,
+                 pad_shape: Tuple[int, int, int],
+                 pad_val: float = 0.,
+                 seg_pad_val: int = 0) -> None:
+
+        # check pad_shape
+        assert pad_shape is not None
+        if not isinstance(pad_shape, tuple):
+            assert len(pad_shape) == 3
+
+        self.pad_shape = pad_shape
+        self.pad_val = pad_val
+        self.seg_pad_val = seg_pad_val
+
+    def _pad_img(self, results: dict) -> None:
+        """Pad images according to ``self.pad_shape``
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: The dict contains the padded image and shape
+                information.
+        """
+        padded_img = self._to_pad(
+            results['img'], pad_shape=self.pad_shape, pad_val=self.pad_val)
+
+        results['img'] = padded_img
+        results['pad_shape'] = padded_img.shape[1:]
+
+    def _pad_seg(self, results: dict) -> None:
+        """Pad semantic segmentation map according to ``self.pad_shape`` if
+        ``gt_seg_map`` is not None in results dict.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Update the padded gt seg map in dict.
+        """
+        if results.get('gt_seg_map', None) is not None:
+            pad_gt_seg = self._to_pad(
+                results['gt_seg_map'][None, ...],
+                pad_shape=results['pad_shape'],
+                pad_val=self.seg_pad_val)
+            results['gt_seg_map'] = pad_gt_seg[1:]
+
+    @staticmethod
+    def _to_pad(img: np.ndarray,
+                pad_shape: Tuple[int, int, int],
+                pad_val: Union[int, float] = 0) -> np.ndarray:
+        """Pad the given 3d image to a certain shape with specified padding
+        value.
+
+        Args:
+            img (ndarray): Biomedical image with shape (N, Z, Y, X)
+                to be padded. N is the number of modalities.
+            pad_shape (Tuple[int,int,int]): Expected padding shape (Z, Y, X).
+            pad_val (float, int): Values to be filled in padding areas
+                and the padding_mode is set to 'constant'. Default: 0.
+
+        Returns:
+            ndarray: The padded image.
+        """
+        # compute pad width
+        d = max(pad_shape[0] - img.shape[1], 0)
+        pad_d = (d // 2, d - d // 2)
+        h = max(pad_shape[1] - img.shape[2], 0)
+        pad_h = (h // 2, h - h // 2)
+        w = max(pad_shape[2] - img.shape[2], 0)
+        pad_w = (w // 2, w - w // 2)
+
+        pad_list = [(0, 0), pad_d, pad_h, pad_w]
+
+        img = np.pad(img, pad_list, mode='constant', constant_values=pad_val)
+        return img
+
+    def transform(self, results: dict) -> dict:
+        """Call function to pad images, semantic segmentation maps.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Updated result dict.
+        """
+        self._pad_img(results)
+        self._pad_seg(results)
+
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'pad_shape={self.pad_shape}, '
+        repr_str += f'pad_val={self.pad_val}), '
+        repr_str += f'seg_pad_val={self.seg_pad_val})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class BioMedical3DRandomFlip(BaseTransform):
+    """Flip biomedical 3D images and segmentations.
+
+    Modified from https://github.com/MIC-DKFZ/batchgenerators/blob/master/batchgenerators/transforms/spatial_transforms.py # noqa:E501
+
+    Copyright 2021 Division of
+    Medical Image Computing, German Cancer Research Center (DKFZ) and Applied
+    Computer Vision Lab, Helmholtz Imaging Platform.
+    Licensed under the Apache-2.0 License.
+
+    Required Keys:
+
+    - img (np.ndarry): Biomedical image with shape (N, Z, Y, X) by default,
+        N is the number of modalities.
+    - gt_seg_map (np.ndarray, optional): Biomedical seg map with shape
+        (Z, Y, X) by default.
+
+    Modified Keys:
+
+    - img (np.ndarry): Biomedical image with shape (N, Z, Y, X) by default,
+        N is the number of modalities.
+    - gt_seg_map (np.ndarray, optional): Biomedical seg map with shape
+        (Z, Y, X) by default.
+
+    Added Keys:
+
+    - do_flip
+    - flip_axes
+
+    Args:
+        prob (float): Flipping probability.
+        axes (Tuple[int, ...]): Flipping axes with order 'ZXY'.
+        swap_label_pairs (Optional[List[Tuple[int, int]]]):
+        The segmentation label pairs that are swapped when flipping.
+    """
+
+    def __init__(self,
+                 prob: float,
+                 axes: Tuple[int, ...],
+                 swap_label_pairs: Optional[List[Tuple[int, int]]] = None):
+        self.prob = prob
+        self.axes = axes
+        self.swap_label_pairs = swap_label_pairs
+        assert prob >= 0 and prob <= 1
+        if axes is not None:
+            assert max(axes) <= 2
+
+    @staticmethod
+    def _flip(img, direction: Tuple[bool, bool, bool]) -> np.ndarray:
+        if direction[0]:
+            img[:, :] = img[:, ::-1]
+        if direction[1]:
+            img[:, :, :] = img[:, :, ::-1]
+        if direction[2]:
+            img[:, :, :, :] = img[:, :, :, ::-1]
+        return img
+
+    def _do_flip(self, img: np.ndarray) -> Tuple[bool, bool, bool]:
+        """Call function to determine which axis to flip.
+
+        Args:
+            img (np.ndarry): Image or segmentation map array.
+        Returns:
+            tuple: Flip action, whether to flip on the z, x, and y axes.
+        """
+        flip_c, flip_x, flip_y = False, False, False
+        if self.axes is not None:
+            flip_c = 0 in self.axes and np.random.rand() < self.prob
+            flip_x = 1 in self.axes and np.random.rand() < self.prob
+            if len(img.shape) == 4:
+                flip_y = 2 in self.axes and np.random.rand() < self.prob
+        return flip_c, flip_x, flip_y
+
+    def _swap_label(self, seg: np.ndarray) -> np.ndarray:
+        out = seg.copy()
+        for first, second in self.swap_label_pairs:
+            first_area = (seg == first)
+            second_area = (seg == second)
+            out[first_area] = second
+            out[second_area] = first
+        return out
+
+    def transform(self, results: Dict) -> Dict:
+        """Call function to flip and swap pair labels.
+
+        Args:
+            results (dict): Result dict.
+        Returns:
+            dict: Flipped results, 'do_flip', 'flip_axes' keys are added into
+                result dict.
+        """
+        # get actual flipped axis
+        if 'do_flip' not in results:
+            results['do_flip'] = self._do_flip(results['img'])
+        if 'flip_axes' not in results:
+            results['flip_axes'] = self.axes
+        # flip image
+        results['img'] = self._flip(
+            results['img'], direction=results['do_flip'])
+        # flip seg
+        if results['gt_seg_map'] is not None:
+            if results['gt_seg_map'].shape != results['img'].shape:
+                results['gt_seg_map'] = results['gt_seg_map'][None, :]
+            results['gt_seg_map'] = self._flip(
+                results['gt_seg_map'], direction=results['do_flip'])
+            results['gt_seg_map'] = results['gt_seg_map'].squeeze()
+            # swap label pairs
+            if self.swap_label_pairs is not None:
+                results['gt_seg_map'] = self._swap_label(results['gt_seg_map'])
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(prob={self.prob}, axes={self.axes}, ' \
+                    f'swap_label_pairs={self.swap_label_pairs})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class Albu(BaseTransform):
+    """Albumentation augmentation. Adds custom transformations from
+    Albumentations library. Please, visit
+    `https://albumentations.readthedocs.io` to get more information. An example
+    of ``transforms`` is as followed:
+
+    .. code-block::
+        [
+            dict(
+                type='ShiftScaleRotate',
+                shift_limit=0.0625,
+                scale_limit=0.0,
+                rotate_limit=0,
+                interpolation=1,
+                p=0.5),
+            dict(
+                type='RandomBrightnessContrast',
+                brightness_limit=[0.1, 0.3],
+                contrast_limit=[0.1, 0.3],
+                p=0.2),
+            dict(type='ChannelShuffle', p=0.1),
+            dict(
+                type='OneOf',
+                transforms=[
+                    dict(type='Blur', blur_limit=3, p=1.0),
+                    dict(type='MedianBlur', blur_limit=3, p=1.0)
+                ],
+                p=0.1),
+        ]
+    Args:
+        transforms (list[dict]): A list of albu transformations
+        keymap (dict): Contains {'input key':'albumentation-style key'}
+        additional_targets(dict):  Allows applying same augmentations to \
+        multiple objects of same type.
+        update_pad_shape (bool): Whether to update padding shape according to \
+            the output shape of the last transform
+        bgr_to_rgb (bool): Whether to convert the band order to RGB
+    """
+
+    def __init__(self,
+                 transforms: List[dict],
+                 keymap: Optional[dict] = None,
+                 additional_targets: Optional[dict] = None,
+                 update_pad_shape: bool = False,
+                 bgr_to_rgb: bool = True):
+        if not ALBU_INSTALLED:
+            raise ImportError(
+                'albumentations is not installed, '
+                'we suggest install albumentation by '
+                '"pip install albumentations>=0.3.2 --no-binary qudida,albumentations"'  # noqa
+            )
+
+        # Args will be modified later, copying it will be safer
+        transforms = copy.deepcopy(transforms)
+
+        self.transforms = transforms
+        self.keymap = keymap
+        self.additional_targets = additional_targets
+        self.update_pad_shape = update_pad_shape
+        self.bgr_to_rgb = bgr_to_rgb
+
+        self.aug = Compose([self.albu_builder(t) for t in self.transforms],
+                           additional_targets=self.additional_targets)
+
+        if not keymap:
+            self.keymap_to_albu = {'img': 'image', 'gt_seg_map': 'mask'}
+        else:
+            self.keymap_to_albu = copy.deepcopy(keymap)
+        self.keymap_back = {v: k for k, v in self.keymap_to_albu.items()}
+
+    def albu_builder(self, cfg: dict) -> object:
+        """Build a callable object from a dict containing albu arguments.
+
+        Args:
+            cfg (dict): Config dict. It should at least contain the key "type".
+
+        Returns:
+            Callable: A callable object.
+        """
+
+        assert isinstance(cfg, dict) and 'type' in cfg
+        args = cfg.copy()
+
+        obj_type = args.pop('type')
+        if mmengine.is_str(obj_type):
+            if not ALBU_INSTALLED:
+                raise ImportError(
+                    'albumentations is not installed, '
+                    'we suggest install albumentation by '
+                    '"pip install albumentations>=0.3.2 --no-binary qudida,albumentations"'  # noqa
+                )
+            obj_cls = getattr(albumentations, obj_type)
+        elif inspect.isclass(obj_type):
+            obj_cls = obj_type
+        else:
+            raise TypeError(
+                f'type must be a valid type or str, but got {type(obj_type)}')
+
+        if 'transforms' in args:
+            args['transforms'] = [
+                self.albu_builder(t) for t in args['transforms']
+            ]
+
+        return obj_cls(**args)
+
+    @staticmethod
+    def mapper(d: dict, keymap: dict):
+        """Dictionary mapper.
+
+        Renames keys according to keymap provided.
+        Args:
+            d (dict): old dict
+            keymap (dict): {'old_key':'new_key'}
+        Returns:
+            dict: new dict.
+        """
+
+        updated_dict = {}
+        for k, _ in zip(d.keys(), d.values()):
+            new_k = keymap.get(k, k)
+            updated_dict[new_k] = d[k]
+        return updated_dict
+
+    def transform(self, results):
+        # dict to albumentations format
+        results = self.mapper(results, self.keymap_to_albu)
+
+        # Convert to RGB since Albumentations works with RGB images
+        if self.bgr_to_rgb:
+            results['image'] = cv2.cvtColor(results['image'],
+                                            cv2.COLOR_BGR2RGB)
+            if self.additional_targets:
+                for key, value in self.additional_targets.items():
+                    if value == 'image':
+                        results[key] = cv2.cvtColor(results[key],
+                                                    cv2.COLOR_BGR2RGB)
+
+        # Apply Transform
+        results = self.aug(**results)
+
+        # Convert back to BGR
+        if self.bgr_to_rgb:
+            results['image'] = cv2.cvtColor(results['image'],
+                                            cv2.COLOR_RGB2BGR)
+            if self.additional_targets:
+                for key, value in self.additional_targets.items():
+                    if value == 'image':
+                        results[key] = cv2.cvtColor(results['image2'],
+                                                    cv2.COLOR_RGB2BGR)
+
+        # back to the original format
+        results = self.mapper(results, self.keymap_back)
+
+        # update final shape
+        if self.update_pad_shape:
+            results['pad_shape'] = results['img'].shape
+
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__ + f'(transforms={self.transforms})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class ConcatCDInput(BaseTransform):
+    """Concat images for change detection.
+
+    Required Keys:
+
+    - img
+    - img2
+
+    Args:
+        input_keys (tuple):  Input image keys for change detection.
+            Default: ('img', 'img2').
+    """
+
+    def __init__(self, input_keys=('img', 'img2')):
+        self.input_keys = input_keys
+
+    def transform(self, results: dict) -> dict:
+        img = []
+        for input_key in self.input_keys:
+            img.append(results.pop(input_key))
+        results['img'] = np.concatenate(img, axis=2)
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(input_keys={self.input_keys}, '
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class RandomDepthMix(BaseTransform):
+    """This class implements the RandomDepthMix transform.
+
+    Args:
+        prob (float): Probability of applying the transformation.
+            Defaults to 0.25.
+        mix_scale_ratio (float): Ratio to scale the mix width.
+            Defaults to 0.75.
+    """
+
+    def __init__(
+        self,
+        prob: float = 0.25,
+        mix_scale_ratio: float = 0.75,
+    ):
+        super().__init__()
+
+        self.prob = prob
+        self.mix_scale_ratio = mix_scale_ratio
+
+    def transform(self, results: dict) -> dict:
+        if random.random() > self.prob:
+            return results
+
+        h, w = results['img_shape'][:2]
+        left = int(w * random.random())
+        width_ratio = self.mix_scale_ratio * random.random()
+        width = int(max(1, (w - left) * width_ratio))
+
+        img = results['img']
+        depth_rescale_factor = results.get('depth_rescale_factor', 1)
+        depth_map = results['gt_depth_map'] / depth_rescale_factor
+
+        if img.ndim == 3:
+            for c in range(img.shape[-1]):
+                img[:, left:left + width, c] = depth_map[:, left:left + width]
+        elif img.ndim == 2:
+            img[:, left:left + width] = depth_map[:, left:left + width]
+        else:
+            raise ValueError(f'Invalid image shape ({img.shape})')
+
+        results['img'] = img
+        return results
diff --git a/mmsegmentation/mmseg/datasets/voc.py b/mmsegmentation/mmseg/datasets/voc.py
new file mode 100644
index 0000000..5e5d602
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/voc.py
@@ -0,0 +1,40 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+
+import mmengine.fileio as fileio
+
+from mmseg.registry import DATASETS
+from .basesegdataset import BaseSegDataset
+
+
+@DATASETS.register_module()
+class PascalVOCDataset(BaseSegDataset):
+    """Pascal VOC dataset.
+
+    Args:
+        split (str): Split txt file for Pascal VOC.
+    """
+    METAINFO = dict(
+        classes=('background', 'aeroplane', 'bicycle', 'bird', 'boat',
+                 'bottle', 'bus', 'car', 'cat', 'chair', 'cow', 'diningtable',
+                 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep',
+                 'sofa', 'train', 'tvmonitor'),
+        palette=[[0, 0, 0], [128, 0, 0], [0, 128, 0], [128, 128, 0],
+                 [0, 0, 128], [128, 0, 128], [0, 128, 128], [128, 128, 128],
+                 [64, 0, 0], [192, 0, 0], [64, 128, 0], [192, 128, 0],
+                 [64, 0, 128], [192, 0, 128], [64, 128, 128], [192, 128, 128],
+                 [0, 64, 0], [128, 64, 0], [0, 192, 0], [128, 192, 0],
+                 [0, 64, 128]])
+
+    def __init__(self,
+                 ann_file,
+                 img_suffix='.jpg',
+                 seg_map_suffix='.png',
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            ann_file=ann_file,
+            **kwargs)
+        assert fileio.exists(self.data_prefix['img_path'],
+                             self.backend_args) and osp.isfile(self.ann_file)
diff --git a/mmsegmentation/mmseg/datasets/xray.py b/mmsegmentation/mmseg/datasets/xray.py
new file mode 100644
index 0000000..458e2c2
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/xray.py
@@ -0,0 +1,29 @@
+from mmseg.registry import DATASETS
+from .basesegdataset import BaseSegDataset
+import os.path as osp
+
+
+@DATASETS.register_module()
+class XRayDataset(BaseSegDataset):
+    METAINFO = dict(
+            classes = [
+                'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
+                'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
+                'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
+                'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
+                'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
+                'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
+            ],
+            palette=[
+                    (220, 20, 60), (119, 11, 32), (0, 0, 142), (0, 0, 230), (106, 0, 228),
+                    (0, 60, 100), (0, 80, 100), (0, 0, 70), (0, 0, 192), (250, 170, 30),
+                    (100, 170, 30), (220, 220, 0), (175, 116, 175), (250, 0, 30), (165, 42, 42),
+                    (255, 77, 255), (0, 226, 252), (182, 182, 255), (0, 82, 0), (120, 166, 157),
+                    (110, 76, 0), (174, 57, 255), (199, 100, 0), (72, 0, 118), (255, 179, 240),
+                    (0, 125, 92), (209, 0, 151), (188, 208, 182), (0, 220, 176),
+                ]
+            )
+    
+    def __init__(self, data_root, data_prefix, pipeline, **kwargs):
+        super(XRayDataset, self).__init__(
+            data_root=data_root, data_prefix=data_prefix, pipeline=pipeline, **kwargs)
\ No newline at end of file
diff --git a/mmsegmentation/mmseg/datasets/xray2.py b/mmsegmentation/mmseg/datasets/xray2.py
new file mode 100644
index 0000000..eafe94a
--- /dev/null
+++ b/mmsegmentation/mmseg/datasets/xray2.py
@@ -0,0 +1,141 @@
+import os
+import json
+
+import numpy as np
+import cv2
+from sklearn.model_selection import GroupKFold
+
+from mmseg.registry import DATASETS, TRANSFORMS, MODELS, METRICS
+from mmseg.datasets import BaseSegDataset
+
+from mmcv.transforms import BaseTransform
+
+# 데이터 경로를 입력하세요
+
+IMAGE_ROOT = '/data/ephemeral/home/data/train/DCM'
+LABEL_ROOT = '/data/ephemeral/home/data/train/outputs_json'
+
+CLASSES = [
+    'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
+    'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
+    'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
+    'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
+    'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
+    'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
+]
+
+CLASS2IND = {v: i for i, v in enumerate(CLASSES)}
+IND2CLASS = {v: k for k, v in CLASS2IND.items()}
+
+pngs = {
+    os.path.relpath(os.path.join(root, fname), start=IMAGE_ROOT)
+    for root, _dirs, files in os.walk(IMAGE_ROOT)
+    for fname in files
+    if os.path.splitext(fname)[1].lower() == ".png"
+}
+
+jsons = {
+    os.path.relpath(os.path.join(root, fname), start=LABEL_ROOT)
+    for root, _dirs, files in os.walk(LABEL_ROOT)
+    for fname in files
+    if os.path.splitext(fname)[1].lower() == ".json"
+}
+
+jsons_fn_prefix = {os.path.splitext(fname)[0] for fname in jsons}
+pngs_fn_prefix = {os.path.splitext(fname)[0] for fname in pngs}
+
+assert len(jsons_fn_prefix - pngs_fn_prefix) == 0
+assert len(pngs_fn_prefix - jsons_fn_prefix) == 0
+
+pngs = sorted(pngs)
+jsons = sorted(jsons)
+
+_filenames = np.array(pngs)
+_labelnames = np.array(jsons)
+    
+# split train-valid
+# 한 폴더 안에 한 인물의 양손에 대한 `.dcm` 파일이 존재하기 때문에
+# 폴더 이름을 그룹으로 해서 GroupKFold를 수행합니다.
+# 동일 인물의 손이 train, valid에 따로 들어가는 것을 방지합니다.
+groups = [os.path.dirname(fname) for fname in _filenames]
+
+# dummy label
+ys = [0 for fname in _filenames]
+
+# 전체 데이터의 20%를 validation data로 쓰기 위해 `n_splits`를
+# 5으로 설정하여 KFold를 수행합니다.
+gkf = GroupKFold(n_splits=5)
+
+@DATASETS.register_module()
+class XRayDataset2(BaseSegDataset):
+    def __init__(self, is_train, **kwargs):
+        self.is_train = is_train
+        
+        super().__init__(**kwargs)
+        
+    def load_data_list(self):
+        filenames = []
+        labelnames = []
+        valid_set_num = 2
+        for i, (x, y) in enumerate(gkf.split(_filenames, ys, groups)):
+            if self.is_train:
+                if i == valid_set_num:
+                    continue
+                    
+                filenames += list(_filenames[y])
+                labelnames += list(_labelnames[y])
+            
+            else:
+                if i == valid_set_num:
+                    filenames = list(_filenames[y])
+                    labelnames = list(_labelnames[y])
+                    break
+        
+        data_list = []
+        for i, (img_path, ann_path) in enumerate(zip(filenames, labelnames)):
+            data_info = dict(
+                img_path=os.path.join(IMAGE_ROOT, img_path),
+                seg_map_path=os.path.join(LABEL_ROOT, ann_path),
+            )
+            data_list.append(data_info)
+        
+        return data_list
+        
+
+@TRANSFORMS.register_module()
+class LoadXRayAnnotations(BaseTransform):
+    def transform(self, result):
+        label_path = result["seg_map_path"]
+        
+        image_size = (2048, 2048)
+        
+        # process a label of shape (H, W, NC)
+        label_shape = image_size + (len(CLASSES), )
+        label = np.zeros(label_shape, dtype=np.uint8)
+        
+        # read label file
+        with open(label_path, "r") as f:
+            annotations = json.load(f)
+        annotations = annotations["annotations"]
+        
+        # iterate each class
+        for ann in annotations:
+            c = ann["label"]
+            class_ind = CLASS2IND[c]
+            points = np.array(ann["points"])
+            
+            # polygon to mask
+            class_label = np.zeros(image_size, dtype=np.uint8)
+            cv2.fillPoly(class_label, [points], 1)
+            label[..., class_ind] = class_label
+        
+        result["gt_seg_map"] = label
+        
+        return result
+    
+@TRANSFORMS.register_module()
+class TransposeAnnotations(BaseTransform):
+    def transform(self, result):
+        result["gt_seg_map"] = np.transpose(result["gt_seg_map"], (2, 0, 1))
+        
+        return result
\ No newline at end of file
diff --git a/mmsegmentation/mmseg/engine/__init__.py b/mmsegmentation/mmseg/engine/__init__.py
new file mode 100644
index 0000000..98139a0
--- /dev/null
+++ b/mmsegmentation/mmseg/engine/__init__.py
@@ -0,0 +1,12 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .hooks import SegVisualizationHook
+from .optimizers import (ForceDefaultOptimWrapperConstructor,
+                         LayerDecayOptimizerConstructor,
+                         LearningRateDecayOptimizerConstructor)
+from .schedulers import PolyLRRatio
+
+__all__ = [
+    'LearningRateDecayOptimizerConstructor', 'LayerDecayOptimizerConstructor',
+    'SegVisualizationHook', 'PolyLRRatio',
+    'ForceDefaultOptimWrapperConstructor'
+]
diff --git a/mmsegmentation/mmseg/engine/hooks/__init__.py b/mmsegmentation/mmseg/engine/hooks/__init__.py
new file mode 100644
index 0000000..c604808
--- /dev/null
+++ b/mmsegmentation/mmseg/engine/hooks/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .visualization_hook import SegVisualizationHook
+
+__all__ = ['SegVisualizationHook']
diff --git a/mmsegmentation/mmseg/engine/hooks/visualization_hook.py b/mmsegmentation/mmseg/engine/hooks/visualization_hook.py
new file mode 100644
index 0000000..21cddde
--- /dev/null
+++ b/mmsegmentation/mmseg/engine/hooks/visualization_hook.py
@@ -0,0 +1,129 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+import warnings
+from typing import Optional, Sequence
+
+import mmcv
+from mmengine.fileio import get
+from mmengine.hooks import Hook
+from mmengine.runner import Runner
+from mmengine.visualization import Visualizer
+
+from mmseg.registry import HOOKS
+from mmseg.structures import SegDataSample
+
+
+@HOOKS.register_module()
+class SegVisualizationHook(Hook):
+    """Segmentation Visualization Hook. Used to visualize validation and
+    testing process prediction results.
+
+    In the testing phase:
+
+    1. If ``show`` is True, it means that only the prediction results are
+        visualized without storing data, so ``vis_backends`` needs to
+        be excluded.
+
+    Args:
+        draw (bool): whether to draw prediction results. If it is False,
+            it means that no drawing will be done. Defaults to False.
+        interval (int): The interval of visualization. Defaults to 50.
+        show (bool): Whether to display the drawn image. Default to False.
+        wait_time (float): The interval of show (s). Defaults to 0.
+        backend_args (dict, Optional): Arguments to instantiate a file backend.
+            See https://mmengine.readthedocs.io/en/latest/api/fileio.htm
+            for details. Defaults to None.
+            Notes: mmcv>=2.0.0rc4, mmengine>=0.2.0 required.
+    """
+
+    def __init__(self,
+                 draw: bool = False,
+                 interval: int = 50,
+                 show: bool = False,
+                 wait_time: float = 0.,
+                 backend_args: Optional[dict] = None):
+        self._visualizer: Visualizer = Visualizer.get_current_instance()
+        self.interval = interval
+        self.show = show
+        if self.show:
+            # No need to think about vis backends.
+            self._visualizer._vis_backends = {}
+            warnings.warn('The show is True, it means that only '
+                          'the prediction results are visualized '
+                          'without storing data, so vis_backends '
+                          'needs to be excluded.')
+
+        self.wait_time = wait_time
+        self.backend_args = backend_args.copy() if backend_args else None
+        self.draw = draw
+        if not self.draw:
+            warnings.warn('The draw is False, it means that the '
+                          'hook for visualization will not take '
+                          'effect. The results will NOT be '
+                          'visualized or stored.')
+        self._test_index = 0
+
+    def after_val_iter(self, runner: Runner, batch_idx: int, data_batch: dict,
+                       outputs: Sequence[SegDataSample]) -> None:
+        """Run after every ``self.interval`` validation iterations.
+
+        Args:
+            runner (:obj:`Runner`): The runner of the validation process.
+            batch_idx (int): The index of the current batch in the val loop.
+            data_batch (dict): Data from dataloader.
+            outputs (Sequence[:obj:`SegDataSample`]]): A batch of data samples
+                that contain annotations and predictions.
+        """
+        if self.draw is False:
+            return
+
+        # There is no guarantee that the same batch of images
+        # is visualized for each evaluation.
+        total_curr_iter = runner.iter + batch_idx
+
+        # Visualize only the first data
+        img_path = outputs[0].img_path
+        img_bytes = get(img_path, backend_args=self.backend_args)
+        img = mmcv.imfrombytes(img_bytes, channel_order='rgb')
+        window_name = f'val_{osp.basename(img_path)}'
+
+        if total_curr_iter % self.interval == 0:
+            self._visualizer.add_datasample(
+                window_name,
+                img,
+                data_sample=outputs[0],
+                show=self.show,
+                wait_time=self.wait_time,
+                step=total_curr_iter)
+
+    def after_test_iter(self, runner: Runner, batch_idx: int, data_batch: dict,
+                        outputs: Sequence[SegDataSample]) -> None:
+        """Run after every testing iterations.
+
+        Args:
+            runner (:obj:`Runner`): The runner of the testing process.
+            batch_idx (int): The index of the current batch in the val loop.
+            data_batch (dict): Data from dataloader.
+            outputs (Sequence[:obj:`SegDataSample`]): A batch of data samples
+                that contain annotations and predictions.
+        """
+        if self.draw is False:
+            return
+
+        for data_sample in outputs:
+            self._test_index += 1
+
+            img_path = data_sample.img_path
+            window_name = f'test_{osp.basename(img_path)}'
+
+            img_path = data_sample.img_path
+            img_bytes = get(img_path, backend_args=self.backend_args)
+            img = mmcv.imfrombytes(img_bytes, channel_order='rgb')
+
+            self._visualizer.add_datasample(
+                window_name,
+                img,
+                data_sample=data_sample,
+                show=self.show,
+                wait_time=self.wait_time,
+                step=self._test_index)
diff --git a/mmsegmentation/mmseg/engine/optimizers/__init__.py b/mmsegmentation/mmseg/engine/optimizers/__init__.py
new file mode 100644
index 0000000..e4cf587
--- /dev/null
+++ b/mmsegmentation/mmseg/engine/optimizers/__init__.py
@@ -0,0 +1,9 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .force_default_constructor import ForceDefaultOptimWrapperConstructor
+from .layer_decay_optimizer_constructor import (
+    LayerDecayOptimizerConstructor, LearningRateDecayOptimizerConstructor)
+
+__all__ = [
+    'LearningRateDecayOptimizerConstructor', 'LayerDecayOptimizerConstructor',
+    'ForceDefaultOptimWrapperConstructor'
+]
diff --git a/mmsegmentation/mmseg/engine/optimizers/force_default_constructor.py b/mmsegmentation/mmseg/engine/optimizers/force_default_constructor.py
new file mode 100644
index 0000000..12c642a
--- /dev/null
+++ b/mmsegmentation/mmseg/engine/optimizers/force_default_constructor.py
@@ -0,0 +1,255 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import logging
+from typing import List, Optional, Union
+
+import torch
+import torch.nn as nn
+from mmengine.logging import print_log
+from mmengine.optim import DefaultOptimWrapperConstructor
+from mmengine.utils.dl_utils import mmcv_full_available
+from mmengine.utils.dl_utils.parrots_wrapper import _BatchNorm, _InstanceNorm
+from torch.nn import GroupNorm, LayerNorm
+
+from mmseg.registry import OPTIM_WRAPPER_CONSTRUCTORS
+
+
+@OPTIM_WRAPPER_CONSTRUCTORS.register_module()
+class ForceDefaultOptimWrapperConstructor(DefaultOptimWrapperConstructor):
+    """Default constructor with forced optimizer settings.
+
+    This constructor extends the default constructor to add an option for
+    forcing default optimizer settings. This is useful for ensuring that
+    certain parameters or layers strictly adhere to pre-defined default
+    settings, regardless of any custom settings specified.
+
+    By default, each parameter share the same optimizer settings, and we
+    provide an argument ``paramwise_cfg`` to specify parameter-wise settings.
+    It is a dict and may contain various fields like 'custom_keys',
+    'bias_lr_mult', etc., as well as the additional field
+    `force_default_settings` which allows for enforcing default settings on
+    optimizer parameters.
+
+    - ``custom_keys`` (dict): Specified parameters-wise settings by keys. If
+      one of the keys in ``custom_keys`` is a substring of the name of one
+      parameter, then the setting of the parameter will be specified by
+      ``custom_keys[key]`` and other setting like ``bias_lr_mult`` etc. will
+      be ignored. It should be noted that the aforementioned ``key`` is the
+      longest key that is a substring of the name of the parameter. If there
+      are multiple matched keys with the same length, then the key with lower
+      alphabet order will be chosen.
+      ``custom_keys[key]`` should be a dict and may contain fields ``lr_mult``
+      and ``decay_mult``. See Example 2 below.
+    - ``bias_lr_mult`` (float): It will be multiplied to the learning
+      rate for all bias parameters (except for those in normalization
+      layers and offset layers of DCN).
+    - ``bias_decay_mult`` (float): It will be multiplied to the weight
+      decay for all bias parameters (except for those in
+      normalization layers, depthwise conv layers, offset layers of DCN).
+    - ``norm_decay_mult`` (float): It will be multiplied to the weight
+      decay for all weight and bias parameters of normalization
+      layers.
+    - ``flat_decay_mult`` (float): It will be multiplied to the weight
+      decay for all one-dimensional parameters
+    - ``dwconv_decay_mult`` (float): It will be multiplied to the weight
+      decay for all weight and bias parameters of depthwise conv
+      layers.
+    - ``dcn_offset_lr_mult`` (float): It will be multiplied to the learning
+      rate for parameters of offset layer in the deformable convs
+      of a model.
+    - ``bypass_duplicate`` (bool): If true, the duplicate parameters
+      would not be added into optimizer. Defaults to False.
+    - ``force_default_settings`` (bool): If true, this will override any
+      custom settings defined by ``custom_keys`` and enforce the use of
+      default settings for optimizer parameters like ``bias_lr_mult``.
+      This is particularly useful when you want to ensure that certain layers
+      or parameters adhere strictly to the pre-defined default settings.
+
+    Note:
+
+        1. If the option ``dcn_offset_lr_mult`` is used, the constructor will
+        override the effect of ``bias_lr_mult`` in the bias of offset layer.
+        So be careful when using both ``bias_lr_mult`` and
+        ``dcn_offset_lr_mult``. If you wish to apply both of them to the offset
+        layer in deformable convs, set ``dcn_offset_lr_mult`` to the original
+        ``dcn_offset_lr_mult`` * ``bias_lr_mult``.
+
+        2. If the option ``dcn_offset_lr_mult`` is used, the constructor will
+        apply it to all the DCN layers in the model. So be careful when the
+        model contains multiple DCN layers in places other than backbone.
+
+        3. When the option ``force_default_settings`` is true, it will override
+        any custom settings provided in ``custom_keys``. This ensures that the
+        default settings for the optimizer parameters are used.
+
+    Args:
+        optim_wrapper_cfg (dict): The config dict of the optimizer wrapper.
+
+            Required fields of ``optim_wrapper_cfg`` are
+
+            - ``type``: class name of the OptimizerWrapper
+            - ``optimizer``: The configuration of optimizer.
+
+            Optional fields of ``optim_wrapper_cfg`` are
+
+            - any arguments of the corresponding optimizer wrapper type,
+              e.g., accumulative_counts, clip_grad, etc.
+
+            Required fields of ``optimizer`` are
+
+            - `type`: class name of the optimizer.
+
+            Optional fields of ``optimizer`` are
+
+            - any arguments of the corresponding optimizer type, e.g.,
+              lr, weight_decay, momentum, etc.
+
+        paramwise_cfg (dict, optional): Parameter-wise options.
+
+    Example 1:
+        >>> model = torch.nn.modules.Conv1d(1, 1, 1)
+        >>> optim_wrapper_cfg = dict(
+        >>>     dict(type='OptimWrapper', optimizer=dict(type='SGD', lr=0.01,
+        >>>         momentum=0.9, weight_decay=0.0001))
+        >>> paramwise_cfg = dict(norm_decay_mult=0.)
+        >>> optim_wrapper_builder = DefaultOptimWrapperConstructor(
+        >>>     optim_wrapper_cfg, paramwise_cfg)
+        >>> optim_wrapper = optim_wrapper_builder(model)
+
+    Example 2:
+        >>> # assume model have attribute model.backbone and model.cls_head
+        >>> optim_wrapper_cfg = dict(type='OptimWrapper', optimizer=dict(
+        >>>     type='SGD', lr=0.01, weight_decay=0.95))
+        >>> paramwise_cfg = dict(custom_keys={
+        >>>     'backbone': dict(lr_mult=0.1, decay_mult=0.9)})
+        >>> optim_wrapper_builder = DefaultOptimWrapperConstructor(
+        >>>     optim_wrapper_cfg, paramwise_cfg)
+        >>> optim_wrapper = optim_wrapper_builder(model)
+        >>> # Then the `lr` and `weight_decay` for model.backbone is
+        >>> # (0.01 * 0.1, 0.95 * 0.9). `lr` and `weight_decay` for
+        >>> # model.cls_head is (0.01, 0.95).
+    """
+
+    def add_params(self,
+                   params: List[dict],
+                   module: nn.Module,
+                   prefix: str = '',
+                   is_dcn_module: Optional[Union[int, float]] = None) -> None:
+        """Add all parameters of module to the params list.
+
+        The parameters of the given module will be added to the list of param
+        groups, with specific rules defined by paramwise_cfg.
+
+        Args:
+            params (list[dict]): A list of param groups, it will be modified
+                in place.
+            module (nn.Module): The module to be added.
+            prefix (str): The prefix of the module
+            is_dcn_module (int|float|None): If the current module is a
+                submodule of DCN, `is_dcn_module` will be passed to
+                control conv_offset layer's learning rate. Defaults to None.
+        """
+        # get param-wise options
+        custom_keys = self.paramwise_cfg.get('custom_keys', {})
+        # first sort with alphabet order and then sort with reversed len of str
+        sorted_keys = sorted(sorted(custom_keys.keys()), key=len, reverse=True)
+
+        bias_lr_mult = self.paramwise_cfg.get('bias_lr_mult', None)
+        bias_decay_mult = self.paramwise_cfg.get('bias_decay_mult', None)
+        norm_decay_mult = self.paramwise_cfg.get('norm_decay_mult', None)
+        dwconv_decay_mult = self.paramwise_cfg.get('dwconv_decay_mult', None)
+        flat_decay_mult = self.paramwise_cfg.get('flat_decay_mult', None)
+        bypass_duplicate = self.paramwise_cfg.get('bypass_duplicate', False)
+        dcn_offset_lr_mult = self.paramwise_cfg.get('dcn_offset_lr_mult', None)
+        force_default_settings = self.paramwise_cfg.get(
+            'force_default_settings', False)
+
+        # special rules for norm layers and depth-wise conv layers
+        is_norm = isinstance(module,
+                             (_BatchNorm, _InstanceNorm, GroupNorm, LayerNorm))
+        is_dwconv = (
+            isinstance(module, torch.nn.Conv2d)
+            and module.in_channels == module.groups)
+
+        for name, param in module.named_parameters(recurse=False):
+            param_group = {'params': [param]}
+            if bypass_duplicate and self._is_in(param_group, params):
+                print_log(
+                    f'{prefix} is duplicate. It is skipped since '
+                    f'bypass_duplicate={bypass_duplicate}',
+                    logger='current',
+                    level=logging.WARNING)
+                continue
+            if not param.requires_grad:
+                params.append(param_group)
+                continue
+
+            # if the parameter match one of the custom keys, ignore other rules
+            is_custom = False
+            for key in sorted_keys:
+                if key in f'{prefix}.{name}':
+                    is_custom = True
+                    lr_mult = custom_keys[key].get('lr_mult', 1.)
+                    param_group['lr'] = self.base_lr * lr_mult
+                    if self.base_wd is not None:
+                        decay_mult = custom_keys[key].get('decay_mult', 1.)
+                        param_group['weight_decay'] = self.base_wd * decay_mult
+                    # add custom settings to param_group
+                    for k, v in custom_keys[key].items():
+                        param_group[k] = v
+                    break
+
+            if not is_custom or force_default_settings:
+                # bias_lr_mult affects all bias parameters
+                # except for norm.bias dcn.conv_offset.bias
+                if name == 'bias' and not (
+                        is_norm or is_dcn_module) and bias_lr_mult is not None:
+                    param_group['lr'] = self.base_lr * bias_lr_mult
+
+                if (prefix.find('conv_offset') != -1 and is_dcn_module
+                        and dcn_offset_lr_mult is not None
+                        and isinstance(module, torch.nn.Conv2d)):
+                    # deal with both dcn_offset's bias & weight
+                    param_group['lr'] = self.base_lr * dcn_offset_lr_mult
+
+                # apply weight decay policies
+                if self.base_wd is not None:
+                    # norm decay
+                    if is_norm and norm_decay_mult is not None:
+                        param_group[
+                            'weight_decay'] = self.base_wd * norm_decay_mult
+                    # bias lr and decay
+                    elif (name == 'bias' and not is_dcn_module
+                          and bias_decay_mult is not None):
+                        param_group[
+                            'weight_decay'] = self.base_wd * bias_decay_mult
+                    # depth-wise conv
+                    elif is_dwconv and dwconv_decay_mult is not None:
+                        param_group[
+                            'weight_decay'] = self.base_wd * dwconv_decay_mult
+                    # flatten parameters except dcn offset
+                    elif (param.ndim == 1 and not is_dcn_module
+                          and flat_decay_mult is not None):
+                        param_group[
+                            'weight_decay'] = self.base_wd * flat_decay_mult
+            params.append(param_group)
+            for key, value in param_group.items():
+                if key == 'params':
+                    continue
+                full_name = f'{prefix}.{name}' if prefix else name
+                print_log(
+                    f'paramwise_options -- {full_name}:{key}={value}',
+                    logger='current')
+
+        if mmcv_full_available():
+            from mmcv.ops import DeformConv2d, ModulatedDeformConv2d
+            is_dcn_module = isinstance(module,
+                                       (DeformConv2d, ModulatedDeformConv2d))
+        else:
+            is_dcn_module = False
+        for child_name, child_mod in module.named_children():
+            child_prefix = f'{prefix}.{child_name}' if prefix else child_name
+            self.add_params(
+                params,
+                child_mod,
+                prefix=child_prefix,
+                is_dcn_module=is_dcn_module)
diff --git a/mmsegmentation/mmseg/engine/optimizers/layer_decay_optimizer_constructor.py b/mmsegmentation/mmseg/engine/optimizers/layer_decay_optimizer_constructor.py
new file mode 100644
index 0000000..fdae3ca
--- /dev/null
+++ b/mmsegmentation/mmseg/engine/optimizers/layer_decay_optimizer_constructor.py
@@ -0,0 +1,207 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import json
+import warnings
+
+from mmengine.dist import get_dist_info
+from mmengine.logging import print_log
+from mmengine.optim import DefaultOptimWrapperConstructor
+
+from mmseg.registry import OPTIM_WRAPPER_CONSTRUCTORS
+
+
+def get_layer_id_for_convnext(var_name, max_layer_id):
+    """Get the layer id to set the different learning rates in ``layer_wise``
+    decay_type.
+
+    Args:
+        var_name (str): The key of the model.
+        max_layer_id (int): Maximum number of backbone layers.
+
+    Returns:
+        int: The id number corresponding to different learning rate in
+        ``LearningRateDecayOptimizerConstructor``.
+    """
+
+    if var_name in ('backbone.cls_token', 'backbone.mask_token',
+                    'backbone.pos_embed'):
+        return 0
+    elif var_name.startswith('backbone.downsample_layers'):
+        stage_id = int(var_name.split('.')[2])
+        if stage_id == 0:
+            layer_id = 0
+        elif stage_id == 1:
+            layer_id = 2
+        elif stage_id == 2:
+            layer_id = 3
+        elif stage_id == 3:
+            layer_id = max_layer_id
+        return layer_id
+    elif var_name.startswith('backbone.stages'):
+        stage_id = int(var_name.split('.')[2])
+        block_id = int(var_name.split('.')[3])
+        if stage_id == 0:
+            layer_id = 1
+        elif stage_id == 1:
+            layer_id = 2
+        elif stage_id == 2:
+            layer_id = 3 + block_id // 3
+        elif stage_id == 3:
+            layer_id = max_layer_id
+        return layer_id
+    else:
+        return max_layer_id + 1
+
+
+def get_stage_id_for_convnext(var_name, max_stage_id):
+    """Get the stage id to set the different learning rates in ``stage_wise``
+    decay_type.
+
+    Args:
+        var_name (str): The key of the model.
+        max_stage_id (int): Maximum number of backbone layers.
+
+    Returns:
+        int: The id number corresponding to different learning rate in
+        ``LearningRateDecayOptimizerConstructor``.
+    """
+
+    if var_name in ('backbone.cls_token', 'backbone.mask_token',
+                    'backbone.pos_embed'):
+        return 0
+    elif var_name.startswith('backbone.downsample_layers'):
+        return 0
+    elif var_name.startswith('backbone.stages'):
+        stage_id = int(var_name.split('.')[2])
+        return stage_id + 1
+    else:
+        return max_stage_id - 1
+
+
+def get_layer_id_for_vit(var_name, max_layer_id):
+    """Get the layer id to set the different learning rates.
+
+    Args:
+        var_name (str): The key of the model.
+        num_max_layer (int): Maximum number of backbone layers.
+
+    Returns:
+        int: Returns the layer id of the key.
+    """
+
+    if var_name in ('backbone.cls_token', 'backbone.mask_token',
+                    'backbone.pos_embed'):
+        return 0
+    elif var_name.startswith('backbone.patch_embed'):
+        return 0
+    elif var_name.startswith('backbone.layers'):
+        layer_id = int(var_name.split('.')[2])
+        return layer_id + 1
+    else:
+        return max_layer_id - 1
+
+
+@OPTIM_WRAPPER_CONSTRUCTORS.register_module()
+class LearningRateDecayOptimizerConstructor(DefaultOptimWrapperConstructor):
+    """Different learning rates are set for different layers of backbone.
+
+    Note: Currently, this optimizer constructor is built for ConvNeXt,
+    BEiT and MAE.
+    """
+
+    def add_params(self, params, module, **kwargs):
+        """Add all parameters of module to the params list.
+
+        The parameters of the given module will be added to the list of param
+        groups, with specific rules defined by paramwise_cfg.
+
+        Args:
+            params (list[dict]): A list of param groups, it will be modified
+                in place.
+            module (nn.Module): The module to be added.
+        """
+
+        parameter_groups = {}
+        print_log(f'self.paramwise_cfg is {self.paramwise_cfg}')
+        num_layers = self.paramwise_cfg.get('num_layers') + 2
+        decay_rate = self.paramwise_cfg.get('decay_rate')
+        decay_type = self.paramwise_cfg.get('decay_type', 'layer_wise')
+        print_log('Build LearningRateDecayOptimizerConstructor  '
+                  f'{decay_type} {decay_rate} - {num_layers}')
+        weight_decay = self.base_wd
+        for name, param in module.named_parameters():
+            if not param.requires_grad:
+                continue  # frozen weights
+            if len(param.shape) == 1 or name.endswith('.bias') or name in (
+                    'pos_embed', 'cls_token'):
+                group_name = 'no_decay'
+                this_weight_decay = 0.
+            else:
+                group_name = 'decay'
+                this_weight_decay = weight_decay
+            if 'layer_wise' in decay_type:
+                if 'ConvNeXt' in module.backbone.__class__.__name__:
+                    layer_id = get_layer_id_for_convnext(
+                        name, self.paramwise_cfg.get('num_layers'))
+                    print_log(f'set param {name} as id {layer_id}')
+                elif 'BEiT' in module.backbone.__class__.__name__ or \
+                     'MAE' in module.backbone.__class__.__name__:
+                    layer_id = get_layer_id_for_vit(name, num_layers)
+                    print_log(f'set param {name} as id {layer_id}')
+                else:
+                    raise NotImplementedError()
+            elif decay_type == 'stage_wise':
+                if 'ConvNeXt' in module.backbone.__class__.__name__:
+                    layer_id = get_stage_id_for_convnext(name, num_layers)
+                    print_log(f'set param {name} as id {layer_id}')
+                else:
+                    raise NotImplementedError()
+            group_name = f'layer_{layer_id}_{group_name}'
+
+            if group_name not in parameter_groups:
+                scale = decay_rate**(num_layers - layer_id - 1)
+
+                parameter_groups[group_name] = {
+                    'weight_decay': this_weight_decay,
+                    'params': [],
+                    'param_names': [],
+                    'lr_scale': scale,
+                    'group_name': group_name,
+                    'lr': scale * self.base_lr,
+                }
+
+            parameter_groups[group_name]['params'].append(param)
+            parameter_groups[group_name]['param_names'].append(name)
+        rank, _ = get_dist_info()
+        if rank == 0:
+            to_display = {}
+            for key in parameter_groups:
+                to_display[key] = {
+                    'param_names': parameter_groups[key]['param_names'],
+                    'lr_scale': parameter_groups[key]['lr_scale'],
+                    'lr': parameter_groups[key]['lr'],
+                    'weight_decay': parameter_groups[key]['weight_decay'],
+                }
+            print_log(f'Param groups = {json.dumps(to_display, indent=2)}')
+        params.extend(parameter_groups.values())
+
+
+@OPTIM_WRAPPER_CONSTRUCTORS.register_module()
+class LayerDecayOptimizerConstructor(LearningRateDecayOptimizerConstructor):
+    """Different learning rates are set for different layers of backbone.
+
+    Note: Currently, this optimizer constructor is built for BEiT,
+    and it will be deprecated.
+    Please use ``LearningRateDecayOptimizerConstructor`` instead.
+    """
+
+    def __init__(self, optim_wrapper_cfg, paramwise_cfg):
+        warnings.warn('DeprecationWarning: Original '
+                      'LayerDecayOptimizerConstructor of BEiT '
+                      'will be deprecated. Please use '
+                      'LearningRateDecayOptimizerConstructor instead, '
+                      'and set decay_type = layer_wise_vit in paramwise_cfg.')
+        paramwise_cfg.update({'decay_type': 'layer_wise_vit'})
+        warnings.warn('DeprecationWarning: Layer_decay_rate will '
+                      'be deleted, please use decay_rate instead.')
+        paramwise_cfg['decay_rate'] = paramwise_cfg.pop('layer_decay_rate')
+        super().__init__(optim_wrapper_cfg, paramwise_cfg)
diff --git a/mmsegmentation/mmseg/engine/schedulers/__init__.py b/mmsegmentation/mmseg/engine/schedulers/__init__.py
new file mode 100644
index 0000000..3cd3f62
--- /dev/null
+++ b/mmsegmentation/mmseg/engine/schedulers/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .poly_ratio_scheduler import PolyLRRatio
+
+__all__ = ['PolyLRRatio']
diff --git a/mmsegmentation/mmseg/engine/schedulers/poly_ratio_scheduler.py b/mmsegmentation/mmseg/engine/schedulers/poly_ratio_scheduler.py
new file mode 100644
index 0000000..057203a
--- /dev/null
+++ b/mmsegmentation/mmseg/engine/schedulers/poly_ratio_scheduler.py
@@ -0,0 +1,62 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional
+
+from mmengine.optim.scheduler import PolyLR
+
+from mmseg.registry import PARAM_SCHEDULERS
+
+
+@PARAM_SCHEDULERS.register_module()
+class PolyLRRatio(PolyLR):
+    """Implements polynomial learning rate decay with ratio.
+
+    This scheduler adjusts the learning rate of each parameter group
+    following a polynomial decay equation. The decay can occur in
+    conjunction with external parameter adjustments made outside this
+    scheduler.
+
+    Args:
+        optimizer (Optimizer or OptimWrapper): Wrapped optimizer.
+        eta_min (float): Minimum learning rate at the end of scheduling.
+            Defaults to 0.
+        eta_min_ratio (float, optional): The ratio of the minimum parameter
+            value to the base parameter value. Either `eta_min` or
+            `eta_min_ratio` should be specified. Defaults to None.
+        power (float): The power of the polynomial. Defaults to 1.0.
+        begin (int): Step at which to start updating the parameters.
+            Defaults to 0.
+        end (int): Step at which to stop updating the parameters.
+            Defaults to INF.
+        last_step (int): The index of last step. Used for resume without
+            state dict. Defaults to -1.
+        by_epoch (bool): Whether the scheduled parameters are updated by
+            epochs. Defaults to True.
+        verbose (bool): Whether to print the value for each update.
+            Defaults to False.
+    """
+
+    def __init__(self, eta_min_ratio: Optional[int] = None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.eta_min_ratio = eta_min_ratio
+
+    def _get_value(self):
+        """Compute value using chainable form of the scheduler."""
+
+        if self.last_step == 0:
+            return [
+                group[self.param_name] for group in self.optimizer.param_groups
+            ]
+
+        param_groups_value = []
+        for base_value, param_group in zip(self.base_values,
+                                           self.optimizer.param_groups):
+            eta_min = self.eta_min if self.eta_min_ratio is None else \
+                base_value * self.eta_min_ratio
+            step_ratio = (1 - 1 /
+                          (self.total_iters - self.last_step + 1))**self.power
+            step_value = (param_group[self.param_name] -
+                          eta_min) * step_ratio + eta_min
+            param_groups_value.append(step_value)
+
+        return param_groups_value
diff --git a/mmsegmentation/mmseg/evaluation/__init__.py b/mmsegmentation/mmseg/evaluation/__init__.py
new file mode 100644
index 0000000..82b3a8d
--- /dev/null
+++ b/mmsegmentation/mmseg/evaluation/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .metrics import CityscapesMetric, DepthMetric, IoUMetric
+
+__all__ = ['IoUMetric', 'CityscapesMetric', 'DepthMetric']
diff --git a/mmsegmentation/mmseg/evaluation/metrics/__init__.py b/mmsegmentation/mmseg/evaluation/metrics/__init__.py
new file mode 100644
index 0000000..0814de4
--- /dev/null
+++ b/mmsegmentation/mmseg/evaluation/metrics/__init__.py
@@ -0,0 +1,8 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .citys_metric import CityscapesMetric
+from .depth_metric import DepthMetric
+from .iou_metric import IoUMetric
+from .dice_metric import DiceMetric
+from .submission_metric import SubmissionMetric
+
+__all__ = ['IoUMetric', 'CityscapesMetric', 'DepthMetric', 'DiceMetric', 'SubmissionMetric']
diff --git a/mmsegmentation/mmseg/evaluation/metrics/citys_metric.py b/mmsegmentation/mmseg/evaluation/metrics/citys_metric.py
new file mode 100644
index 0000000..3298465
--- /dev/null
+++ b/mmsegmentation/mmseg/evaluation/metrics/citys_metric.py
@@ -0,0 +1,158 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+import shutil
+from collections import OrderedDict
+from typing import Dict, Optional, Sequence
+
+try:
+
+    import cityscapesscripts.evaluation.evalPixelLevelSemanticLabeling as CSEval  # noqa
+    import cityscapesscripts.helpers.labels as CSLabels
+except ImportError:
+    CSLabels = None
+    CSEval = None
+
+import numpy as np
+from mmengine.dist import is_main_process, master_only
+from mmengine.evaluator import BaseMetric
+from mmengine.logging import MMLogger, print_log
+from mmengine.utils import mkdir_or_exist
+from PIL import Image
+
+from mmseg.registry import METRICS
+
+
+@METRICS.register_module()
+class CityscapesMetric(BaseMetric):
+    """Cityscapes evaluation metric.
+
+    Args:
+        output_dir (str): The directory for output prediction
+        ignore_index (int): Index that will be ignored in evaluation.
+            Default: 255.
+        format_only (bool): Only format result for results commit without
+            perform evaluation. It is useful when you want to format the result
+            to a specific format and submit it to the test server.
+            Defaults to False.
+        keep_results (bool): Whether to keep the results. When ``format_only``
+            is True, ``keep_results`` must be True. Defaults to False.
+        collect_device (str): Device name used for collecting results from
+            different ranks during distributed training. Must be 'cpu' or
+            'gpu'. Defaults to 'cpu'.
+        prefix (str, optional): The prefix that will be added in the metric
+            names to disambiguate homonymous metrics of different evaluators.
+            If prefix is not provided in the argument, self.default_prefix
+            will be used instead. Defaults to None.
+    """
+
+    def __init__(self,
+                 output_dir: str,
+                 ignore_index: int = 255,
+                 format_only: bool = False,
+                 keep_results: bool = False,
+                 collect_device: str = 'cpu',
+                 prefix: Optional[str] = None,
+                 **kwargs) -> None:
+        super().__init__(collect_device=collect_device, prefix=prefix)
+        if CSEval is None:
+            raise ImportError('Please run "pip install cityscapesscripts" to '
+                              'install cityscapesscripts first.')
+        self.output_dir = output_dir
+        self.ignore_index = ignore_index
+
+        self.format_only = format_only
+        if format_only:
+            assert keep_results, (
+                'When format_only is True, the results must be keep, please '
+                f'set keep_results as True, but got {keep_results}')
+        self.keep_results = keep_results
+        self.prefix = prefix
+        if is_main_process():
+            mkdir_or_exist(self.output_dir)
+
+    @master_only
+    def __del__(self) -> None:
+        """Clean up."""
+        if not self.keep_results:
+            shutil.rmtree(self.output_dir)
+
+    def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+        """Process one batch of data and data_samples.
+
+        The processed results should be stored in ``self.results``, which will
+        be used to computed the metrics when all batches have been processed.
+
+        Args:
+            data_batch (dict): A batch of data from the dataloader.
+            data_samples (Sequence[dict]): A batch of outputs from the model.
+        """
+        mkdir_or_exist(self.output_dir)
+
+        for data_sample in data_samples:
+            pred_label = data_sample['pred_sem_seg']['data'][0].cpu().numpy()
+            # when evaluating with official cityscapesscripts,
+            # labelIds should be used
+            pred_label = self._convert_to_label_id(pred_label)
+            basename = osp.splitext(osp.basename(data_sample['img_path']))[0]
+            png_filename = osp.abspath(
+                osp.join(self.output_dir, f'{basename}.png'))
+            output = Image.fromarray(pred_label.astype(np.uint8)).convert('P')
+            output.save(png_filename)
+            if self.format_only:
+                # format_only always for test dataset without ground truth
+                gt_filename = ''
+            else:
+                # when evaluating with official cityscapesscripts,
+                # **_gtFine_labelIds.png is used
+                gt_filename = data_sample['seg_map_path'].replace(
+                    'labelTrainIds.png', 'labelIds.png')
+            self.results.append((png_filename, gt_filename))
+
+    def compute_metrics(self, results: list) -> Dict[str, float]:
+        """Compute the metrics from processed results.
+
+        Args:
+            results (list): Testing results of the dataset.
+
+        Returns:
+            dict[str: float]: Cityscapes evaluation results.
+        """
+        logger: MMLogger = MMLogger.get_current_instance()
+        if self.format_only:
+            logger.info(f'results are saved to {osp.dirname(self.output_dir)}')
+            return OrderedDict()
+
+        msg = 'Evaluating in Cityscapes style'
+        if logger is None:
+            msg = '\n' + msg
+        print_log(msg, logger=logger)
+
+        eval_results = dict()
+        print_log(
+            f'Evaluating results under {self.output_dir} ...', logger=logger)
+
+        CSEval.args.evalInstLevelScore = True
+        CSEval.args.predictionPath = osp.abspath(self.output_dir)
+        CSEval.args.evalPixelAccuracy = True
+        CSEval.args.JSONOutput = False
+
+        pred_list, gt_list = zip(*results)
+        metric = dict()
+        eval_results.update(
+            CSEval.evaluateImgLists(pred_list, gt_list, CSEval.args))
+        metric['averageScoreCategories'] = eval_results[
+            'averageScoreCategories']
+        metric['averageScoreInstCategories'] = eval_results[
+            'averageScoreInstCategories']
+        return metric
+
+    @staticmethod
+    def _convert_to_label_id(result):
+        """Convert trainId to id for cityscapes."""
+        if isinstance(result, str):
+            result = np.load(result)
+        result_copy = result.copy()
+        for trainId, label in CSLabels.trainId2label.items():
+            result_copy[result == trainId] = label.id
+
+        return result_copy
diff --git a/mmsegmentation/mmseg/evaluation/metrics/depth_metric.py b/mmsegmentation/mmseg/evaluation/metrics/depth_metric.py
new file mode 100644
index 0000000..621d4a3
--- /dev/null
+++ b/mmsegmentation/mmseg/evaluation/metrics/depth_metric.py
@@ -0,0 +1,212 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+from collections import OrderedDict, defaultdict
+from typing import Dict, List, Optional, Sequence
+
+import cv2
+import numpy as np
+import torch
+from mmengine.dist import is_main_process
+from mmengine.evaluator import BaseMetric
+from mmengine.logging import MMLogger, print_log
+from mmengine.utils import mkdir_or_exist
+from prettytable import PrettyTable
+from torch import Tensor
+
+from mmseg.registry import METRICS
+
+
+@METRICS.register_module()
+class DepthMetric(BaseMetric):
+    """Depth estimation evaluation metric.
+
+    Args:
+        depth_metrics (List[str], optional): List of metrics to compute. If
+            not specified, defaults to all metrics in self.METRICS.
+        min_depth_eval (float): Minimum depth value for evaluation.
+            Defaults to 0.0.
+        max_depth_eval (float): Maximum depth value for evaluation.
+            Defaults to infinity.
+        crop_type (str, optional): Specifies the type of cropping to be used
+            during evaluation. This option can affect how the evaluation mask
+            is generated. Currently, 'nyu_crop' is supported, but other
+            types can be added in future. Defaults to None if no cropping
+            should be applied.
+        depth_scale_factor (float): Factor to scale the depth values.
+            Defaults to 1.0.
+        collect_device (str): Device name used for collecting results from
+            different ranks during distributed training. Must be 'cpu' or
+            'gpu'. Defaults to 'cpu'.
+        output_dir (str): The directory for output prediction. Defaults to
+            None.
+        format_only (bool): Only format result for results commit without
+            perform evaluation. It is useful when you want to save the result
+            to a specific format and submit it to the test server.
+            Defaults to False.
+        prefix (str, optional): The prefix that will be added in the metric
+            names to disambiguate homonymous metrics of different evaluators.
+            If prefix is not provided in the argument, self.default_prefix
+            will be used instead. Defaults to None.
+    """
+    METRICS = ('d1', 'd2', 'd3', 'abs_rel', 'sq_rel', 'rmse', 'rmse_log',
+               'log10', 'silog')
+
+    def __init__(self,
+                 depth_metrics: Optional[List[str]] = None,
+                 min_depth_eval: float = 0.0,
+                 max_depth_eval: float = float('inf'),
+                 crop_type: Optional[str] = None,
+                 depth_scale_factor: float = 1.0,
+                 collect_device: str = 'cpu',
+                 output_dir: Optional[str] = None,
+                 format_only: bool = False,
+                 prefix: Optional[str] = None,
+                 **kwargs) -> None:
+        super().__init__(collect_device=collect_device, prefix=prefix)
+
+        if depth_metrics is None:
+            self.metrics = self.METRICS
+        elif isinstance(depth_metrics, [tuple, list]):
+            for metric in depth_metrics:
+                assert metric in self.METRICS, f'the metric {metric} is not ' \
+                    f'supported. Please use metrics in {self.METRICS}'
+            self.metrics = depth_metrics
+
+        # Validate crop_type, if provided
+        assert crop_type in [
+            None, 'nyu_crop'
+        ], (f'Invalid value for crop_type: {crop_type}. Supported values are '
+            'None or \'nyu_crop\'.')
+        self.crop_type = crop_type
+        self.min_depth_eval = min_depth_eval
+        self.max_depth_eval = max_depth_eval
+        self.output_dir = output_dir
+        if self.output_dir and is_main_process():
+            mkdir_or_exist(self.output_dir)
+        self.format_only = format_only
+        self.depth_scale_factor = depth_scale_factor
+
+    def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+        """Process one batch of data and data_samples.
+
+        The processed results should be stored in ``self.results``, which will
+        be used to compute the metrics when all batches have been processed.
+
+        Args:
+            data_batch (dict): A batch of data from the dataloader.
+            data_samples (Sequence[dict]): A batch of outputs from the model.
+        """
+        for data_sample in data_samples:
+            pred_label = data_sample['pred_depth_map']['data'].squeeze()
+            # format_only always for test dataset without ground truth
+            if not self.format_only:
+                gt_depth = data_sample['gt_depth_map']['data'].squeeze().to(
+                    pred_label)
+
+                eval_mask = self._get_eval_mask(gt_depth)
+                self.results.append(
+                    (gt_depth[eval_mask], pred_label[eval_mask]))
+            # format_result
+            if self.output_dir is not None:
+                basename = osp.splitext(osp.basename(
+                    data_sample['img_path']))[0]
+                png_filename = osp.abspath(
+                    osp.join(self.output_dir, f'{basename}.png'))
+                output_mask = pred_label.cpu().numpy(
+                ) * self.depth_scale_factor
+
+                cv2.imwrite(png_filename, output_mask.astype(np.uint16),
+                            [cv2.IMWRITE_PNG_COMPRESSION, 0])
+
+    def _get_eval_mask(self, gt_depth: Tensor):
+        """Generates an evaluation mask based on ground truth depth and
+        cropping.
+
+        Args:
+            gt_depth (Tensor): Ground truth depth map.
+
+        Returns:
+            Tensor: Boolean mask where evaluation should be performed.
+        """
+        valid_mask = torch.logical_and(gt_depth > self.min_depth_eval,
+                                       gt_depth < self.max_depth_eval)
+
+        if self.crop_type == 'nyu_crop':
+            # this implementation is adapted from
+            # https://github.com/zhyever/Monocular-Depth-Estimation-Toolbox/blob/main/depth/datasets/nyu.py  # noqa
+            crop_mask = torch.zeros_like(valid_mask)
+            crop_mask[45:471, 41:601] = 1
+        else:
+            crop_mask = torch.ones_like(valid_mask)
+
+        eval_mask = torch.logical_and(valid_mask, crop_mask)
+        return eval_mask
+
+    @staticmethod
+    def _calc_all_metrics(gt_depth, pred_depth):
+        """Computes final evaluation metrics based on accumulated results."""
+        assert gt_depth.shape == pred_depth.shape
+
+        thresh = torch.max((gt_depth / pred_depth), (pred_depth / gt_depth))
+        diff = pred_depth - gt_depth
+        diff_log = torch.log(pred_depth) - torch.log(gt_depth)
+
+        d1 = torch.sum(thresh < 1.25).float() / len(thresh)
+        d2 = torch.sum(thresh < 1.25**2).float() / len(thresh)
+        d3 = torch.sum(thresh < 1.25**3).float() / len(thresh)
+
+        abs_rel = torch.mean(torch.abs(diff) / gt_depth)
+        sq_rel = torch.mean(torch.pow(diff, 2) / gt_depth)
+
+        rmse = torch.sqrt(torch.mean(torch.pow(diff, 2)))
+        rmse_log = torch.sqrt(torch.mean(torch.pow(diff_log, 2)))
+
+        log10 = torch.mean(
+            torch.abs(torch.log10(pred_depth) - torch.log10(gt_depth)))
+        silog = torch.sqrt(
+            torch.pow(diff_log, 2).mean() -
+            0.5 * torch.pow(diff_log.mean(), 2))
+
+        return {
+            'd1': d1.item(),
+            'd2': d2.item(),
+            'd3': d3.item(),
+            'abs_rel': abs_rel.item(),
+            'sq_rel': sq_rel.item(),
+            'rmse': rmse.item(),
+            'rmse_log': rmse_log.item(),
+            'log10': log10.item(),
+            'silog': silog.item()
+        }
+
+    def compute_metrics(self, results: list) -> Dict[str, float]:
+        """Compute the metrics from processed results.
+
+        Args:
+            results (list): The processed results of each batch.
+
+        Returns:
+            Dict[str, float]: The computed metrics. The keys are the names of
+                the metrics, and the values are corresponding results. The keys
+                are identical with self.metrics.
+        """
+        logger: MMLogger = MMLogger.get_current_instance()
+        if self.format_only:
+            logger.info(f'results are saved to {osp.dirname(self.output_dir)}')
+            return OrderedDict()
+
+        metrics = defaultdict(list)
+        for gt_depth, pred_depth in results:
+            for key, value in self._calc_all_metrics(gt_depth,
+                                                     pred_depth).items():
+                metrics[key].append(value)
+        metrics = {k: sum(metrics[k]) / len(metrics[k]) for k in self.metrics}
+
+        table_data = PrettyTable()
+        for key, val in metrics.items():
+            table_data.add_column(key, [round(val, 5)])
+
+        print_log('results:', logger)
+        print_log('\n' + table_data.get_string(), logger=logger)
+
+        return metrics
diff --git a/mmsegmentation/mmseg/evaluation/metrics/dice_metric.py b/mmsegmentation/mmseg/evaluation/metrics/dice_metric.py
new file mode 100644
index 0000000..6ae18cb
--- /dev/null
+++ b/mmsegmentation/mmseg/evaluation/metrics/dice_metric.py
@@ -0,0 +1,119 @@
+from collections import OrderedDict
+
+import numpy as np
+from prettytable import PrettyTable
+
+import torch
+
+from mmseg.registry import METRICS
+
+from mmengine.evaluator import BaseMetric
+from mmengine.logging import MMLogger, print_log
+
+
+CLASSES = [
+    'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
+    'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
+    'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
+    'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
+    'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
+    'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
+]
+num_classes = len(CLASSES) + 1
+
+@METRICS.register_module()
+class DiceMetric(BaseMetric):
+    def __init__(self,
+                 collect_device='cpu',
+                 prefix=None,
+                 **kwargs):
+        super().__init__(collect_device=collect_device, prefix=prefix)
+        
+    @staticmethod
+    def dice_coef(y_true, y_pred):
+        dice_scores = []        
+        y_true_f = y_true.flatten(-2)
+        y_pred_f = y_pred.flatten(-2)
+        eps = 0.0001
+        
+         # 각 클래스에 대해 Dice score 계산
+        for c in range(1, num_classes):
+            # 각 클래스에 해당하는 마스크 생성
+            y_true_c = (y_true_f == c).float()
+            y_pred_c = (y_pred_f == c).float()
+
+            # Dice score 계산
+            intersection = torch.sum(y_true_c * y_pred_c)
+            denominator = torch.sum(y_true_c) + torch.sum(y_pred_c) + eps
+
+            # Dice 계산 시, 분모가 0인 경우 1로 처리 (True와 Pred 모두 없는 경우)
+            dice = (2.0 * intersection) / denominator
+
+            # 결과 리스트에 추가
+            dice_scores.append(dice.item())
+
+        return dice_scores
+        
+        
+
+    def process(self, data_batch, data_samples):
+        """Process one batch of data and data_samples.
+
+        The processed results should be stored in ``self.results``, which will
+        be used to compute the metrics when all batches have been processed.
+
+        Args:
+            data_batch (dict): A batch of data from the dataloader.
+            data_samples (Sequence[dict]): A batch of outputs from the model.
+        """
+        for data_sample in data_samples:
+            pred_label = data_sample['pred_sem_seg']['data']
+            
+            label = data_sample['gt_sem_seg']['data'].to(pred_label)
+            self.results.append(self.dice_coef(label, pred_label))
+            
+
+    def compute_metrics(self, results):
+        """Compute the metrics from processed results.
+
+        Args:
+            results (list): The processed results of each batch.
+
+        Returns:
+            Dict[str, float]: The computed metrics. The keys are the names of
+                the metrics, and the values are corresponding results.
+        """
+        logger: MMLogger = MMLogger.get_current_instance()
+            
+        results = torch.tensor(results)        
+        dices_per_class = torch.mean(results, 0)
+        avg_dice = torch.mean(dices_per_class)
+            
+        ret_metrics = {
+            "Dice": dices_per_class.detach().cpu().numpy(),
+        }
+        # summary table
+        ret_metrics_summary = OrderedDict({
+            ret_metric: np.round(np.nanmean(ret_metric_value) * 100, 2)
+            for ret_metric, ret_metric_value in ret_metrics.items()
+        })
+
+        # each class table
+        ret_metrics.pop('aAcc', None)
+        ret_metrics_class = OrderedDict({
+            ret_metric: np.round(ret_metric_value, 2)
+            for ret_metric, ret_metric_value in ret_metrics.items()
+        })
+        ret_metrics_class.update({'Class': CLASSES})
+        ret_metrics_class.move_to_end('Class', last=False)
+        class_table_data = PrettyTable()
+        for key, val in ret_metrics_class.items():
+            class_table_data.add_column(key, val)
+
+        print(class_table_data)
+        
+        metrics = {
+            "mDice": torch.mean(dices_per_class).item(),
+        }
+
+        return metrics
\ No newline at end of file
diff --git a/mmsegmentation/mmseg/evaluation/metrics/iou_metric.py b/mmsegmentation/mmseg/evaluation/metrics/iou_metric.py
new file mode 100644
index 0000000..16014c7
--- /dev/null
+++ b/mmsegmentation/mmseg/evaluation/metrics/iou_metric.py
@@ -0,0 +1,286 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+from collections import OrderedDict
+from typing import Dict, List, Optional, Sequence
+
+import numpy as np
+import torch
+from mmengine.dist import is_main_process
+from mmengine.evaluator import BaseMetric
+from mmengine.logging import MMLogger, print_log
+from mmengine.utils import mkdir_or_exist
+from PIL import Image
+from prettytable import PrettyTable
+
+from mmseg.registry import METRICS
+
+
+@METRICS.register_module()
+class IoUMetric(BaseMetric):
+    """IoU evaluation metric.
+
+    Args:
+        ignore_index (int): Index that will be ignored in evaluation.
+            Default: 255.
+        iou_metrics (list[str] | str): Metrics to be calculated, the options
+            includes 'mIoU', 'mDice' and 'mFscore'.
+        nan_to_num (int, optional): If specified, NaN values will be replaced
+            by the numbers defined by the user. Default: None.
+        beta (int): Determines the weight of recall in the combined score.
+            Default: 1.
+        collect_device (str): Device name used for collecting results from
+            different ranks during distributed training. Must be 'cpu' or
+            'gpu'. Defaults to 'cpu'.
+        output_dir (str): The directory for output prediction. Defaults to
+            None.
+        format_only (bool): Only format result for results commit without
+            perform evaluation. It is useful when you want to save the result
+            to a specific format and submit it to the test server.
+            Defaults to False.
+        prefix (str, optional): The prefix that will be added in the metric
+            names to disambiguate homonymous metrics of different evaluators.
+            If prefix is not provided in the argument, self.default_prefix
+            will be used instead. Defaults to None.
+    """
+
+    def __init__(self,
+                 ignore_index: int = 255,
+                 iou_metrics: List[str] = ['mIoU'],
+                 nan_to_num: Optional[int] = None,
+                 beta: int = 1,
+                 collect_device: str = 'cpu',
+                 output_dir: Optional[str] = None,
+                 format_only: bool = False,
+                 prefix: Optional[str] = None,
+                 **kwargs) -> None:
+        super().__init__(collect_device=collect_device, prefix=prefix)
+
+        self.ignore_index = ignore_index
+        self.metrics = iou_metrics
+        self.nan_to_num = nan_to_num
+        self.beta = beta
+        self.output_dir = output_dir
+        if self.output_dir and is_main_process():
+            mkdir_or_exist(self.output_dir)
+        self.format_only = format_only
+
+    def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+        """Process one batch of data and data_samples.
+
+        The processed results should be stored in ``self.results``, which will
+        be used to compute the metrics when all batches have been processed.
+
+        Args:
+            data_batch (dict): A batch of data from the dataloader.
+            data_samples (Sequence[dict]): A batch of outputs from the model.
+        """
+        num_classes = len(self.dataset_meta['classes'])
+        for data_sample in data_samples:
+            pred_label = data_sample['pred_sem_seg']['data'].squeeze()
+            # format_only always for test dataset without ground truth
+            if not self.format_only:
+                label = data_sample['gt_sem_seg']['data'].squeeze().to(
+                    pred_label)
+                self.results.append(
+                    self.intersect_and_union(pred_label, label, num_classes,
+                                             self.ignore_index))
+            # format_result
+            if self.output_dir is not None:
+                basename = osp.splitext(osp.basename(
+                    data_sample['img_path']))[0]
+                png_filename = osp.abspath(
+                    osp.join(self.output_dir, f'{basename}.png'))
+                output_mask = pred_label.cpu().numpy()
+                # The index range of official ADE20k dataset is from 0 to 150.
+                # But the index range of output is from 0 to 149.
+                # That is because we set reduce_zero_label=True.
+                if data_sample.get('reduce_zero_label', False):
+                    output_mask = output_mask + 1
+                output = Image.fromarray(output_mask.astype(np.uint8))
+                output.save(png_filename)
+
+    def compute_metrics(self, results: list) -> Dict[str, float]:
+        """Compute the metrics from processed results.
+
+        Args:
+            results (list): The processed results of each batch.
+
+        Returns:
+            Dict[str, float]: The computed metrics. The keys are the names of
+                the metrics, and the values are corresponding results. The key
+                mainly includes aAcc, mIoU, mAcc, mDice, mFscore, mPrecision,
+                mRecall.
+        """
+        logger: MMLogger = MMLogger.get_current_instance()
+        if self.format_only:
+            logger.info(f'results are saved to {osp.dirname(self.output_dir)}')
+            return OrderedDict()
+        # convert list of tuples to tuple of lists, e.g.
+        # [(A_1, B_1, C_1, D_1), ...,  (A_n, B_n, C_n, D_n)] to
+        # ([A_1, ..., A_n], ..., [D_1, ..., D_n])
+        results = tuple(zip(*results))
+        assert len(results) == 4
+
+        total_area_intersect = sum(results[0])
+        total_area_union = sum(results[1])
+        total_area_pred_label = sum(results[2])
+        total_area_label = sum(results[3])
+        ret_metrics = self.total_area_to_metrics(
+            total_area_intersect, total_area_union, total_area_pred_label,
+            total_area_label, self.metrics, self.nan_to_num, self.beta)
+
+        class_names = self.dataset_meta['classes']
+
+        # summary table
+        ret_metrics_summary = OrderedDict({
+            ret_metric: np.round(np.nanmean(ret_metric_value) * 100, 2)
+            for ret_metric, ret_metric_value in ret_metrics.items()
+        })
+        metrics = dict()
+        for key, val in ret_metrics_summary.items():
+            if key == 'aAcc':
+                metrics[key] = val
+            else:
+                metrics['m' + key] = val
+
+        # each class table
+        ret_metrics.pop('aAcc', None)
+        ret_metrics_class = OrderedDict({
+            ret_metric: np.round(ret_metric_value * 100, 2)
+            for ret_metric, ret_metric_value in ret_metrics.items()
+        })
+        ret_metrics_class.update({'Class': class_names})
+        ret_metrics_class.move_to_end('Class', last=False)
+        class_table_data = PrettyTable()
+        for key, val in ret_metrics_class.items():
+            class_table_data.add_column(key, val)
+
+        print_log('per class results:', logger)
+        print_log('\n' + class_table_data.get_string(), logger=logger)
+
+        return metrics
+
+    @staticmethod
+    def intersect_and_union(pred_label: torch.tensor, label: torch.tensor,
+                            num_classes: int, ignore_index: int):
+        """Calculate Intersection and Union.
+
+        Args:
+            pred_label (torch.tensor): Prediction segmentation map
+                or predict result filename. The shape is (H, W).
+            label (torch.tensor): Ground truth segmentation map
+                or label filename. The shape is (H, W).
+            num_classes (int): Number of categories.
+            ignore_index (int): Index that will be ignored in evaluation.
+
+        Returns:
+            torch.Tensor: The intersection of prediction and ground truth
+                histogram on all classes.
+            torch.Tensor: The union of prediction and ground truth histogram on
+                all classes.
+            torch.Tensor: The prediction histogram on all classes.
+            torch.Tensor: The ground truth histogram on all classes.
+        """
+
+        mask = (label != ignore_index)
+        pred_label = pred_label[mask]
+        label = label[mask]
+
+        intersect = pred_label[pred_label == label]
+        area_intersect = torch.histc(
+            intersect.float(), bins=(num_classes), min=0,
+            max=num_classes - 1).cpu()
+        area_pred_label = torch.histc(
+            pred_label.float(), bins=(num_classes), min=0,
+            max=num_classes - 1).cpu()
+        area_label = torch.histc(
+            label.float(), bins=(num_classes), min=0,
+            max=num_classes - 1).cpu()
+        area_union = area_pred_label + area_label - area_intersect
+        return area_intersect, area_union, area_pred_label, area_label
+
+    @staticmethod
+    def total_area_to_metrics(total_area_intersect: np.ndarray,
+                              total_area_union: np.ndarray,
+                              total_area_pred_label: np.ndarray,
+                              total_area_label: np.ndarray,
+                              metrics: List[str] = ['mIoU'],
+                              nan_to_num: Optional[int] = None,
+                              beta: int = 1):
+        """Calculate evaluation metrics
+        Args:
+            total_area_intersect (np.ndarray): The intersection of prediction
+                and ground truth histogram on all classes.
+            total_area_union (np.ndarray): The union of prediction and ground
+                truth histogram on all classes.
+            total_area_pred_label (np.ndarray): The prediction histogram on
+                all classes.
+            total_area_label (np.ndarray): The ground truth histogram on
+                all classes.
+            metrics (List[str] | str): Metrics to be evaluated, 'mIoU' and
+                'mDice'.
+            nan_to_num (int, optional): If specified, NaN values will be
+                replaced by the numbers defined by the user. Default: None.
+            beta (int): Determines the weight of recall in the combined score.
+                Default: 1.
+        Returns:
+            Dict[str, np.ndarray]: per category evaluation metrics,
+                shape (num_classes, ).
+        """
+
+        def f_score(precision, recall, beta=1):
+            """calculate the f-score value.
+
+            Args:
+                precision (float | torch.Tensor): The precision value.
+                recall (float | torch.Tensor): The recall value.
+                beta (int): Determines the weight of recall in the combined
+                    score. Default: 1.
+
+            Returns:
+                [torch.tensor]: The f-score value.
+            """
+            score = (1 + beta**2) * (precision * recall) / (
+                (beta**2 * precision) + recall)
+            return score
+
+        if isinstance(metrics, str):
+            metrics = [metrics]
+        allowed_metrics = ['mIoU', 'mDice', 'mFscore']
+        if not set(metrics).issubset(set(allowed_metrics)):
+            raise KeyError(f'metrics {metrics} is not supported')
+
+        all_acc = total_area_intersect.sum() / total_area_label.sum()
+        ret_metrics = OrderedDict({'aAcc': all_acc})
+        for metric in metrics:
+            if metric == 'mIoU':
+                iou = total_area_intersect / total_area_union
+                acc = total_area_intersect / total_area_label
+                ret_metrics['IoU'] = iou
+                ret_metrics['Acc'] = acc
+            elif metric == 'mDice':
+                dice = 2 * total_area_intersect / (
+                    total_area_pred_label + total_area_label)
+                acc = total_area_intersect / total_area_label
+                ret_metrics['Dice'] = dice
+                ret_metrics['Acc'] = acc
+            elif metric == 'mFscore':
+                precision = total_area_intersect / total_area_pred_label
+                recall = total_area_intersect / total_area_label
+                f_value = torch.tensor([
+                    f_score(x[0], x[1], beta) for x in zip(precision, recall)
+                ])
+                ret_metrics['Fscore'] = f_value
+                ret_metrics['Precision'] = precision
+                ret_metrics['Recall'] = recall
+
+        ret_metrics = {
+            metric: value.numpy()
+            for metric, value in ret_metrics.items()
+        }
+        if nan_to_num is not None:
+            ret_metrics = OrderedDict({
+                metric: np.nan_to_num(metric_value, nan=nan_to_num)
+                for metric, metric_value in ret_metrics.items()
+            })
+        return ret_metrics
diff --git a/mmsegmentation/mmseg/evaluation/metrics/submission_metric.py b/mmsegmentation/mmseg/evaluation/metrics/submission_metric.py
new file mode 100644
index 0000000..4829511
--- /dev/null
+++ b/mmsegmentation/mmseg/evaluation/metrics/submission_metric.py
@@ -0,0 +1,131 @@
+from collections import defaultdict
+import os
+
+import numpy as np
+import pandas as pd
+from prettytable import PrettyTable
+
+import torch
+import torch.nn.functional as F
+import matplotlib.pyplot as plt
+
+from mmseg.registry import METRICS
+
+from mmengine.evaluator import BaseMetric
+from mmengine.logging import MMLogger, print_log
+from tqdm import tqdm
+
+
+
+CLASSES = [
+    'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
+    'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
+    'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
+    'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
+    'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
+    'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
+]
+num_classes = len(CLASSES) + 1
+
+
+@METRICS.register_module()
+class SubmissionMetric(BaseMetric):
+    def __init__(self,
+                 collect_device='cpu',
+                 prefix=None,
+                 save_path='',
+                 **kwargs):
+        super().__init__(collect_device=collect_device, prefix=prefix)
+        self.save_path = save_path
+        if self.save_path == '':
+            self.save_path = '/data/ephemeral/home/submission'
+        
+        os.makedirs(self.save_path, exist_ok=True)
+        self.cnt = 0
+        
+        # self.rles = []
+        # self.filename_and_class = []
+        
+            
+    def encode_mask_to_rle(self, mask):
+        '''
+        mask: numpy array binary mask 
+        1 - mask 
+        0 - background
+        Returns encoded run length 
+        '''
+        pixels = mask.flatten()
+        pixels = np.concatenate([[0], pixels, [0]])
+        runs = np.where(pixels[1:] != pixels[:-1])[0] + 1
+        runs[1::2] -= runs[::2]
+        return ' '.join(str(x) for x in runs)
+    
+    
+    def convert_to_class_masks(self, mask):
+        """
+        Convert a mask of shape (1, H, W) with values in range [0, 29] to (29, H, W) masks.
+        
+        Parameters:
+        - mask: numpy array of shape (1, H, W) with integer values from 0 to 29 representing class labels.
+        
+        Returns:
+        - class_masks: numpy array of shape (29, H, W) where each slice corresponds to a class mask.
+        """
+        # Get the height and width from the input mask shape
+        _, H, W = mask.shape
+
+        # Initialize an empty array to hold the class masks (29, H, W)
+        class_masks = np.zeros((29, H, W), dtype=np.uint8)
+
+        # Iterate over each class (1 to 29)
+        for class_id in range(1, 30):  # Classes 1 to 29
+            class_masks[class_id - 1] = (mask[0] == class_id).astype(np.uint8)
+
+        return class_masks
+    
+
+    def decode_rle_to_mask(self, rle, height, width):
+        s = rle.split()
+        starts, lengths = [np.asarray(x, dtype=int) for x in (s[0:][::2], s[1:][::2])]
+        starts -= 1
+        ends = starts + lengths
+        img = np.zeros(height * width, dtype=np.uint8)
+        
+        for lo, hi in zip(starts, ends):
+            img[lo:hi] = 1
+        
+        return img.reshape(height, width)
+    
+    
+    def process(self, data_batch, data_samples):
+        for data_sample in data_samples:
+            img_path = data_sample['img_path']
+            img_name = os.path.basename(img_path).split('_')[1]
+            pred_label = data_sample['pred_sem_seg']['data']
+            img_shape = data_sample['img_shape']
+            ori_shape = data_sample['ori_shape']
+            
+            # if img_shape != ori_shape:
+            #     pred_label = F.interpolate(pred_label, size=ori_shape, mode="bilinear")
+            pred_label = pred_label.cpu().numpy()
+            
+            
+            pred_label = self.convert_to_class_masks(pred_label)
+            for i, pred in enumerate(pred_label):
+                rle = self.encode_mask_to_rle(pred)
+                self.results.append((rle, f"{CLASSES[i]}_{img_name}"))
+        
+            
+    def compute_metrics(self, results):
+        classes, filename = zip(*[x[1].split("_") for x in self.results])
+        image_name = [f for f in filename]
+        
+        df = pd.DataFrame({
+            "image_name": image_name,
+            "class": classes,
+            "rle": [x[0] for x in self.results]
+        })
+        print(df.head(30))
+        df.to_csv(os.path.join(self.save_path, 'output.csv'), index=False)
+        
+        return {"status": 1}
\ No newline at end of file
diff --git a/mmsegmentation/mmseg/models/__init__.py b/mmsegmentation/mmseg/models/__init__.py
new file mode 100644
index 0000000..a989512
--- /dev/null
+++ b/mmsegmentation/mmseg/models/__init__.py
@@ -0,0 +1,16 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .assigners import *  # noqa: F401,F403
+from .backbones import *  # noqa: F401,F403
+from .builder import (BACKBONES, HEADS, LOSSES, SEGMENTORS, build_backbone,
+                      build_head, build_loss, build_segmentor)
+from .data_preprocessor import SegDataPreProcessor
+from .decode_heads import *  # noqa: F401,F403
+from .losses import *  # noqa: F401,F403
+from .necks import *  # noqa: F401,F403
+from .segmentors import *  # noqa: F401,F403
+from .text_encoder import *  # noqa: F401,F403
+
+__all__ = [
+    'BACKBONES', 'HEADS', 'LOSSES', 'SEGMENTORS', 'build_backbone',
+    'build_head', 'build_loss', 'build_segmentor', 'SegDataPreProcessor'
+]
diff --git a/mmsegmentation/mmseg/models/assigners/__init__.py b/mmsegmentation/mmseg/models/assigners/__init__.py
new file mode 100644
index 0000000..d49b1b1
--- /dev/null
+++ b/mmsegmentation/mmseg/models/assigners/__init__.py
@@ -0,0 +1,12 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .base_assigner import BaseAssigner
+from .hungarian_assigner import HungarianAssigner
+from .match_cost import ClassificationCost, CrossEntropyLossCost, DiceCost
+
+__all__ = [
+    'BaseAssigner',
+    'HungarianAssigner',
+    'ClassificationCost',
+    'CrossEntropyLossCost',
+    'DiceCost',
+]
diff --git a/mmsegmentation/mmseg/models/assigners/base_assigner.py b/mmsegmentation/mmseg/models/assigners/base_assigner.py
new file mode 100644
index 0000000..97895cd
--- /dev/null
+++ b/mmsegmentation/mmseg/models/assigners/base_assigner.py
@@ -0,0 +1,18 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from abc import ABCMeta, abstractmethod
+from typing import Optional
+
+from mmengine.structures import InstanceData
+
+
+class BaseAssigner(metaclass=ABCMeta):
+    """Base assigner that assigns masks to ground truth class labels."""
+
+    @abstractmethod
+    def assign(self,
+               pred_instances: InstanceData,
+               gt_instances: InstanceData,
+               gt_instances_ignore: Optional[InstanceData] = None,
+               **kwargs):
+        """Assign masks to either a ground truth class label or a negative
+        label."""
diff --git a/mmsegmentation/mmseg/models/assigners/hungarian_assigner.py b/mmsegmentation/mmseg/models/assigners/hungarian_assigner.py
new file mode 100644
index 0000000..28868f0
--- /dev/null
+++ b/mmsegmentation/mmseg/models/assigners/hungarian_assigner.py
@@ -0,0 +1,86 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Union
+
+import torch
+from mmengine import ConfigDict
+from mmengine.structures import InstanceData
+from scipy.optimize import linear_sum_assignment
+from torch.cuda.amp import autocast
+
+from mmseg.registry import TASK_UTILS
+from .base_assigner import BaseAssigner
+
+
+@TASK_UTILS.register_module()
+class HungarianAssigner(BaseAssigner):
+    """Computes one-to-one matching between prediction masks and ground truth.
+
+    This class uses bipartite matching-based assignment to computes an
+    assignment between the prediction masks and the ground truth. The
+    assignment result is based on the weighted sum of match costs. The
+    Hungarian algorithm is used to calculate the best matching with the
+    minimum cost. The prediction masks that are not matched are classified
+    as background.
+
+    Args:
+        match_costs (ConfigDict|List[ConfigDict]): Match cost configs.
+    """
+
+    def __init__(
+        self, match_costs: Union[List[Union[dict, ConfigDict]], dict,
+                                 ConfigDict]
+    ) -> None:
+
+        if isinstance(match_costs, dict):
+            match_costs = [match_costs]
+        elif isinstance(match_costs, list):
+            assert len(match_costs) > 0, \
+                'match_costs must not be a empty list.'
+
+        self.match_costs = [
+            TASK_UTILS.build(match_cost) for match_cost in match_costs
+        ]
+
+    def assign(self, pred_instances: InstanceData, gt_instances: InstanceData,
+               **kwargs):
+        """Computes one-to-one matching based on the weighted costs.
+
+        This method assign each query prediction to a ground truth or
+        background. The assignment first calculates the cost for each
+        category assigned to each query mask, and then uses the
+        Hungarian algorithm to calculate the minimum cost as the best
+        match.
+
+        Args:
+            pred_instances (InstanceData): Instances of model
+                predictions. It includes "masks", with shape
+                (n, h, w) or (n, l), and "cls", with shape (n, num_classes+1)
+            gt_instances (InstanceData): Ground truth of instance
+                annotations. It includes "labels", with shape (k, ),
+                and "masks", with shape (k, h, w) or (k, l).
+
+        Returns:
+            matched_quiery_inds (Tensor): The indexes of matched quieres.
+            matched_label_inds (Tensor): The indexes of matched labels.
+        """
+        # compute weighted cost
+        cost_list = []
+        with autocast(enabled=False):
+            for match_cost in self.match_costs:
+                cost = match_cost(
+                    pred_instances=pred_instances, gt_instances=gt_instances)
+                cost_list.append(cost)
+            cost = torch.stack(cost_list).sum(dim=0)
+
+        device = cost.device
+        # do Hungarian matching on CPU using linear_sum_assignment
+        cost = cost.detach().cpu()
+        if linear_sum_assignment is None:
+            raise ImportError('Please run "pip install scipy" '
+                              'to install scipy first.')
+
+        matched_quiery_inds, matched_label_inds = linear_sum_assignment(cost)
+        matched_quiery_inds = torch.from_numpy(matched_quiery_inds).to(device)
+        matched_label_inds = torch.from_numpy(matched_label_inds).to(device)
+
+        return matched_quiery_inds, matched_label_inds
diff --git a/mmsegmentation/mmseg/models/assigners/match_cost.py b/mmsegmentation/mmseg/models/assigners/match_cost.py
new file mode 100644
index 0000000..560df85
--- /dev/null
+++ b/mmsegmentation/mmseg/models/assigners/match_cost.py
@@ -0,0 +1,231 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from abc import abstractmethod
+from typing import Union
+
+import torch
+import torch.nn.functional as F
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmseg.registry import TASK_UTILS
+
+
+class BaseMatchCost:
+    """Base match cost class.
+
+    Args:
+        weight (Union[float, int]): Cost weight. Defaults to 1.
+    """
+
+    def __init__(self, weight: Union[float, int] = 1.) -> None:
+        self.weight = weight
+
+    @abstractmethod
+    def __call__(self, pred_instances: InstanceData,
+                 gt_instances: InstanceData, **kwargs) -> Tensor:
+        """Compute match cost.
+
+        Args:
+            pred_instances (InstanceData): Instances of model predictions.
+            It often includes "labels" and "scores".
+            gt_instances (InstanceData): Ground truth of instance
+            annotations. It usually includes "labels".
+
+        Returns:
+            Tensor: Match Cost matrix of shape (num_preds, num_gts).
+        """
+        pass
+
+
+@TASK_UTILS.register_module()
+class ClassificationCost(BaseMatchCost):
+    """ClsSoftmaxCost.
+
+    Args:
+        weight (Union[float, int]): Cost weight. Defaults to 1.
+
+    Examples:
+        >>> from mmseg.models.assigners import ClassificationCost
+        >>> import torch
+        >>> self = ClassificationCost()
+        >>> cls_pred = torch.rand(4, 3)
+        >>> gt_labels = torch.tensor([0, 1, 2])
+        >>> factor = torch.tensor([10, 8, 10, 8])
+        >>> self(cls_pred, gt_labels)
+        tensor([[-0.3430, -0.3525, -0.3045],
+            [-0.3077, -0.2931, -0.3992],
+            [-0.3664, -0.3455, -0.2881],
+            [-0.3343, -0.2701, -0.3956]])
+    """
+
+    def __init__(self, weight: Union[float, int] = 1) -> None:
+        super().__init__(weight=weight)
+
+    def __call__(self, pred_instances: InstanceData,
+                 gt_instances: InstanceData, **kwargs) -> Tensor:
+        """Compute match cost.
+
+        Args:
+            pred_instances (InstanceData): "scores" inside is
+                predicted classification logits, of shape
+                (num_queries, num_class).
+            gt_instances (InstanceData): "labels" inside should have
+                shape (num_gt, ).
+
+        Returns:
+            Tensor: Match Cost matrix of shape (num_preds, num_gts).
+        """
+        assert hasattr(pred_instances, 'scores'), \
+            "pred_instances must contain 'scores'"
+        assert hasattr(gt_instances, 'labels'), \
+            "gt_instances must contain 'labels'"
+        pred_scores = pred_instances.scores
+        gt_labels = gt_instances.labels
+
+        pred_scores = pred_scores.softmax(-1)
+        cls_cost = -pred_scores[:, gt_labels]
+
+        return cls_cost * self.weight
+
+
+@TASK_UTILS.register_module()
+class DiceCost(BaseMatchCost):
+    """Cost of mask assignments based on dice losses.
+
+    Args:
+        pred_act (bool): Whether to apply sigmoid to mask_pred.
+            Defaults to False.
+        eps (float): Defaults to 1e-3.
+        naive_dice (bool): If True, use the naive dice loss
+            in which the power of the number in the denominator is
+            the first power. If False, use the second power that
+            is adopted by K-Net and SOLO. Defaults to True.
+        weight (Union[float, int]): Cost weight. Defaults to 1.
+    """
+
+    def __init__(self,
+                 pred_act: bool = False,
+                 eps: float = 1e-3,
+                 naive_dice: bool = True,
+                 weight: Union[float, int] = 1.) -> None:
+        super().__init__(weight=weight)
+        self.pred_act = pred_act
+        self.eps = eps
+        self.naive_dice = naive_dice
+
+    def _binary_mask_dice_loss(self, mask_preds: Tensor,
+                               gt_masks: Tensor) -> Tensor:
+        """
+        Args:
+            mask_preds (Tensor): Mask prediction in shape (num_queries, *).
+            gt_masks (Tensor): Ground truth in shape (num_gt, *)
+                store 0 or 1, 0 for negative class and 1 for
+                positive class.
+
+        Returns:
+            Tensor: Dice cost matrix in shape (num_queries, num_gt).
+        """
+        mask_preds = mask_preds.flatten(1)
+        gt_masks = gt_masks.flatten(1).float()
+        numerator = 2 * torch.einsum('nc,mc->nm', mask_preds, gt_masks)
+        if self.naive_dice:
+            denominator = mask_preds.sum(-1)[:, None] + \
+                gt_masks.sum(-1)[None, :]
+        else:
+            denominator = mask_preds.pow(2).sum(1)[:, None] + \
+                gt_masks.pow(2).sum(1)[None, :]
+        loss = 1 - (numerator + self.eps) / (denominator + self.eps)
+        return loss
+
+    def __call__(self, pred_instances: InstanceData,
+                 gt_instances: InstanceData, **kwargs) -> Tensor:
+        """Compute match cost.
+
+        Args:
+            pred_instances (InstanceData): Predicted instances which
+                must contain "masks".
+            gt_instances (InstanceData): Ground truth which must contain
+                "mask".
+
+        Returns:
+            Tensor: Match Cost matrix of shape (num_preds, num_gts).
+        """
+        assert hasattr(pred_instances, 'masks'), \
+            "pred_instances must contain 'masks'"
+        assert hasattr(gt_instances, 'masks'), \
+            "gt_instances must contain 'masks'"
+        pred_masks = pred_instances.masks
+        gt_masks = gt_instances.masks
+
+        if self.pred_act:
+            pred_masks = pred_masks.sigmoid()
+        dice_cost = self._binary_mask_dice_loss(pred_masks, gt_masks)
+        return dice_cost * self.weight
+
+
+@TASK_UTILS.register_module()
+class CrossEntropyLossCost(BaseMatchCost):
+    """CrossEntropyLossCost.
+
+    Args:
+        use_sigmoid (bool): Whether the prediction uses sigmoid
+                of softmax. Defaults to True.
+        weight (Union[float, int]): Cost weight. Defaults to 1.
+    """
+
+    def __init__(self,
+                 use_sigmoid: bool = True,
+                 weight: Union[float, int] = 1.) -> None:
+        super().__init__(weight=weight)
+        self.use_sigmoid = use_sigmoid
+
+    def _binary_cross_entropy(self, cls_pred: Tensor,
+                              gt_labels: Tensor) -> Tensor:
+        """
+        Args:
+            cls_pred (Tensor): The prediction with shape (num_queries, 1, *) or
+                (num_queries, *).
+            gt_labels (Tensor): The learning label of prediction with
+                shape (num_gt, *).
+
+        Returns:
+            Tensor: Cross entropy cost matrix in shape (num_queries, num_gt).
+        """
+        cls_pred = cls_pred.flatten(1).float()
+        gt_labels = gt_labels.flatten(1).float()
+        n = cls_pred.shape[1]
+        pos = F.binary_cross_entropy_with_logits(
+            cls_pred, torch.ones_like(cls_pred), reduction='none')
+        neg = F.binary_cross_entropy_with_logits(
+            cls_pred, torch.zeros_like(cls_pred), reduction='none')
+        cls_cost = torch.einsum('nc,mc->nm', pos, gt_labels) + \
+            torch.einsum('nc,mc->nm', neg, 1 - gt_labels)
+        cls_cost = cls_cost / n
+
+        return cls_cost
+
+    def __call__(self, pred_instances: InstanceData,
+                 gt_instances: InstanceData, **kwargs) -> Tensor:
+        """Compute match cost.
+
+        Args:
+            pred_instances (:obj:`InstanceData`): Predicted instances which
+                must contain ``masks``.
+            gt_instances (:obj:`InstanceData`): Ground truth which must contain
+                ``masks``.
+
+        Returns:
+            Tensor: Match Cost matrix of shape (num_preds, num_gts).
+        """
+        assert hasattr(pred_instances, 'masks'), \
+            "pred_instances must contain 'masks'"
+        assert hasattr(gt_instances, 'masks'), \
+            "gt_instances must contain 'masks'"
+        pred_masks = pred_instances.masks
+        gt_masks = gt_instances.masks
+        if self.use_sigmoid:
+            cls_cost = self._binary_cross_entropy(pred_masks, gt_masks)
+        else:
+            raise NotImplementedError
+
+        return cls_cost * self.weight
diff --git a/mmsegmentation/mmseg/models/backbones/__init__.py b/mmsegmentation/mmseg/models/backbones/__init__.py
new file mode 100644
index 0000000..784d3df
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/__init__.py
@@ -0,0 +1,35 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .beit import BEiT
+from .bisenetv1 import BiSeNetV1
+from .bisenetv2 import BiSeNetV2
+from .cgnet import CGNet
+from .ddrnet import DDRNet
+from .erfnet import ERFNet
+from .fast_scnn import FastSCNN
+from .hrnet import HRNet
+from .icnet import ICNet
+from .mae import MAE
+from .mit import MixVisionTransformer
+from .mobilenet_v2 import MobileNetV2
+from .mobilenet_v3 import MobileNetV3
+from .mscan import MSCAN
+from .pidnet import PIDNet
+from .resnest import ResNeSt
+from .resnet import ResNet, ResNetV1c, ResNetV1d
+from .resnext import ResNeXt
+from .stdc import STDCContextPathNet, STDCNet
+from .swin import SwinTransformer
+from .timm_backbone import TIMMBackbone
+from .twins import PCPVT, SVT
+from .unet import UNet
+from .vit import VisionTransformer
+from .vpd import VPD
+
+__all__ = [
+    'ResNet', 'ResNetV1c', 'ResNetV1d', 'ResNeXt', 'HRNet', 'FastSCNN',
+    'ResNeSt', 'MobileNetV2', 'UNet', 'CGNet', 'MobileNetV3',
+    'VisionTransformer', 'SwinTransformer', 'MixVisionTransformer',
+    'BiSeNetV1', 'BiSeNetV2', 'ICNet', 'TIMMBackbone', 'ERFNet', 'PCPVT',
+    'SVT', 'STDCNet', 'STDCContextPathNet', 'BEiT', 'MAE', 'PIDNet', 'MSCAN',
+    'DDRNet', 'VPD'
+]
diff --git a/mmsegmentation/mmseg/models/backbones/beit.py b/mmsegmentation/mmseg/models/backbones/beit.py
new file mode 100644
index 0000000..e5da71e
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/beit.py
@@ -0,0 +1,554 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import build_norm_layer
+from mmcv.cnn.bricks.drop import build_dropout
+from mmengine.model import BaseModule, ModuleList
+from mmengine.model.weight_init import (constant_init, kaiming_init,
+                                        trunc_normal_)
+from mmengine.runner.checkpoint import _load_checkpoint
+from scipy import interpolate
+from torch.nn.modules.batchnorm import _BatchNorm
+from torch.nn.modules.utils import _pair as to_2tuple
+
+from mmseg.registry import MODELS
+from ..utils import PatchEmbed
+from .vit import TransformerEncoderLayer as VisionTransformerEncoderLayer
+
+
+class BEiTAttention(BaseModule):
+    """Window based multi-head self-attention (W-MSA) module with relative
+    position bias.
+
+    Args:
+        embed_dims (int): Number of input channels.
+        num_heads (int): Number of attention heads.
+        window_size (tuple[int]): The height and width of the window.
+        bias (bool): The option to add leanable bias for q, k, v. If bias is
+            True, it will add leanable bias. If bias is 'qv_bias', it will only
+            add leanable bias for q, v. If bias is False, it will not add bias
+            for q, k, v. Default to 'qv_bias'.
+        qk_scale (float | None, optional): Override default qk scale of
+            head_dim ** -0.5 if set. Default: None.
+        attn_drop_rate (float): Dropout ratio of attention weight.
+            Default: 0.0
+        proj_drop_rate (float): Dropout ratio of output. Default: 0.
+        init_cfg (dict | None, optional): The Config for initialization.
+            Default: None.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 num_heads,
+                 window_size,
+                 bias='qv_bias',
+                 qk_scale=None,
+                 attn_drop_rate=0.,
+                 proj_drop_rate=0.,
+                 init_cfg=None,
+                 **kwargs):
+        super().__init__(init_cfg=init_cfg)
+        self.embed_dims = embed_dims
+        self.num_heads = num_heads
+        head_embed_dims = embed_dims // num_heads
+        self.bias = bias
+        self.scale = qk_scale or head_embed_dims**-0.5
+
+        qkv_bias = bias
+        if bias == 'qv_bias':
+            self._init_qv_bias()
+            qkv_bias = False
+
+        self.window_size = window_size
+        self._init_rel_pos_embedding()
+
+        self.qkv = nn.Linear(embed_dims, embed_dims * 3, bias=qkv_bias)
+        self.attn_drop = nn.Dropout(attn_drop_rate)
+        self.proj = nn.Linear(embed_dims, embed_dims)
+        self.proj_drop = nn.Dropout(proj_drop_rate)
+
+    def _init_qv_bias(self):
+        self.q_bias = nn.Parameter(torch.zeros(self.embed_dims))
+        self.v_bias = nn.Parameter(torch.zeros(self.embed_dims))
+
+    def _init_rel_pos_embedding(self):
+        Wh, Ww = self.window_size
+        # cls to token & token 2 cls & cls to cls
+        self.num_relative_distance = (2 * Wh - 1) * (2 * Ww - 1) + 3
+        # relative_position_bias_table shape is (2*Wh-1 * 2*Ww-1 + 3, nH)
+        self.relative_position_bias_table = nn.Parameter(
+            torch.zeros(self.num_relative_distance, self.num_heads))
+
+        # get pair-wise relative position index for
+        # each token inside the window
+        coords_h = torch.arange(Wh)
+        coords_w = torch.arange(Ww)
+        # coords shape is (2, Wh, Ww)
+        coords = torch.stack(torch.meshgrid([coords_h, coords_w]))
+        # coords_flatten shape is (2, Wh*Ww)
+        coords_flatten = torch.flatten(coords, 1)
+        relative_coords = (
+            coords_flatten[:, :, None] - coords_flatten[:, None, :])
+        # relative_coords shape is (Wh*Ww, Wh*Ww, 2)
+        relative_coords = relative_coords.permute(1, 2, 0).contiguous()
+        # shift to start from 0
+        relative_coords[:, :, 0] += Wh - 1
+        relative_coords[:, :, 1] += Ww - 1
+        relative_coords[:, :, 0] *= 2 * Ww - 1
+        relative_position_index = torch.zeros(
+            size=(Wh * Ww + 1, ) * 2, dtype=relative_coords.dtype)
+        # relative_position_index shape is (Wh*Ww, Wh*Ww)
+        relative_position_index[1:, 1:] = relative_coords.sum(-1)
+        relative_position_index[0, 0:] = self.num_relative_distance - 3
+        relative_position_index[0:, 0] = self.num_relative_distance - 2
+        relative_position_index[0, 0] = self.num_relative_distance - 1
+
+        self.register_buffer('relative_position_index',
+                             relative_position_index)
+
+    def init_weights(self):
+        trunc_normal_(self.relative_position_bias_table, std=0.02)
+
+    def forward(self, x):
+        """
+        Args:
+            x (tensor): input features with shape of (num_windows*B, N, C).
+        """
+        B, N, C = x.shape
+
+        if self.bias == 'qv_bias':
+            k_bias = torch.zeros_like(self.v_bias, requires_grad=False)
+            qkv_bias = torch.cat((self.q_bias, k_bias, self.v_bias))
+            qkv = F.linear(input=x, weight=self.qkv.weight, bias=qkv_bias)
+        else:
+            qkv = self.qkv(x)
+
+        qkv = qkv.reshape(B, N, 3, self.num_heads, -1).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv[0], qkv[1], qkv[2]
+        q = q * self.scale
+        attn = (q @ k.transpose(-2, -1))
+        if self.relative_position_bias_table is not None:
+            Wh = self.window_size[0]
+            Ww = self.window_size[1]
+            relative_position_bias = self.relative_position_bias_table[
+                self.relative_position_index.view(-1)].view(
+                    Wh * Ww + 1, Wh * Ww + 1, -1)
+            relative_position_bias = relative_position_bias.permute(
+                2, 0, 1).contiguous()  # nH, Wh*Ww, Wh*Ww
+            attn = attn + relative_position_bias.unsqueeze(0)
+        attn = attn.softmax(dim=-1)
+        attn = self.attn_drop(attn)
+        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+
+class BEiTTransformerEncoderLayer(VisionTransformerEncoderLayer):
+    """Implements one encoder layer in Vision Transformer.
+
+    Args:
+        embed_dims (int): The feature dimension.
+        num_heads (int): Parallel attention heads.
+        feedforward_channels (int): The hidden dimension for FFNs.
+        attn_drop_rate (float): The drop out rate for attention layer.
+            Default: 0.0.
+        drop_path_rate (float): Stochastic depth rate. Default 0.0.
+        num_fcs (int): The number of fully-connected layers for FFNs.
+            Default: 2.
+        bias (bool): The option to add leanable bias for q, k, v. If bias is
+            True, it will add leanable bias. If bias is 'qv_bias', it will only
+            add leanable bias for q, v. If bias is False, it will not add bias
+            for q, k, v. Default to 'qv_bias'.
+        act_cfg (dict): The activation config for FFNs.
+            Default: dict(type='GELU').
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='LN').
+        window_size (tuple[int], optional): The height and width of the window.
+            Default: None.
+        init_values (float, optional): Initialize the values of BEiTAttention
+            and FFN with learnable scaling. Default: None.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 num_heads,
+                 feedforward_channels,
+                 attn_drop_rate=0.,
+                 drop_path_rate=0.,
+                 num_fcs=2,
+                 bias='qv_bias',
+                 act_cfg=dict(type='GELU'),
+                 norm_cfg=dict(type='LN'),
+                 window_size=None,
+                 attn_cfg=dict(),
+                 ffn_cfg=dict(add_identity=False),
+                 init_values=None):
+        attn_cfg.update(dict(window_size=window_size, qk_scale=None))
+
+        super().__init__(
+            embed_dims=embed_dims,
+            num_heads=num_heads,
+            feedforward_channels=feedforward_channels,
+            attn_drop_rate=attn_drop_rate,
+            drop_path_rate=0.,
+            drop_rate=0.,
+            num_fcs=num_fcs,
+            qkv_bias=bias,
+            act_cfg=act_cfg,
+            norm_cfg=norm_cfg,
+            attn_cfg=attn_cfg,
+            ffn_cfg=ffn_cfg)
+
+        # NOTE: drop path for stochastic depth, we shall see if
+        # this is better than dropout here
+        dropout_layer = dict(type='DropPath', drop_prob=drop_path_rate)
+        self.drop_path = build_dropout(
+            dropout_layer) if dropout_layer else nn.Identity()
+        self.gamma_1 = nn.Parameter(
+            init_values * torch.ones(embed_dims), requires_grad=True)
+        self.gamma_2 = nn.Parameter(
+            init_values * torch.ones(embed_dims), requires_grad=True)
+
+    def build_attn(self, attn_cfg):
+        self.attn = BEiTAttention(**attn_cfg)
+
+    def forward(self, x):
+        x = x + self.drop_path(self.gamma_1 * self.attn(self.norm1(x)))
+        x = x + self.drop_path(self.gamma_2 * self.ffn(self.norm2(x)))
+        return x
+
+
+@MODELS.register_module()
+class BEiT(BaseModule):
+    """BERT Pre-Training of Image Transformers.
+
+    Args:
+        img_size (int | tuple): Input image size. Default: 224.
+        patch_size (int): The patch size. Default: 16.
+        in_channels (int): Number of input channels. Default: 3.
+        embed_dims (int): Embedding dimension. Default: 768.
+        num_layers (int): Depth of transformer. Default: 12.
+        num_heads (int): Number of attention heads. Default: 12.
+        mlp_ratio (int): Ratio of mlp hidden dim to embedding dim.
+            Default: 4.
+        out_indices (list | tuple | int): Output from which stages.
+            Default: -1.
+        qv_bias (bool): Enable bias for qv if True. Default: True.
+        attn_drop_rate (float): The drop out rate for attention layer.
+            Default 0.0
+        drop_path_rate (float): Stochastic depth rate. Default 0.0.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='LN')
+        act_cfg (dict): The activation config for FFNs.
+            Default: dict(type='GELU').
+        patch_norm (bool): Whether to add a norm in PatchEmbed Block.
+            Default: False.
+        final_norm (bool): Whether to add a additional layer to normalize
+            final feature map. Default: False.
+        num_fcs (int): The number of fully-connected layers for FFNs.
+            Default: 2.
+        norm_eval (bool): Whether to set norm layers to eval mode, namely,
+            freeze running stats (mean and var). Note: Effect on Batch Norm
+            and its variants only. Default: False.
+        pretrained (str, optional): Model pretrained path. Default: None.
+        init_values (float): Initialize the values of BEiTAttention and FFN
+            with learnable scaling.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    """
+
+    def __init__(self,
+                 img_size=224,
+                 patch_size=16,
+                 in_channels=3,
+                 embed_dims=768,
+                 num_layers=12,
+                 num_heads=12,
+                 mlp_ratio=4,
+                 out_indices=-1,
+                 qv_bias=True,
+                 attn_drop_rate=0.,
+                 drop_path_rate=0.,
+                 norm_cfg=dict(type='LN'),
+                 act_cfg=dict(type='GELU'),
+                 patch_norm=False,
+                 final_norm=False,
+                 num_fcs=2,
+                 norm_eval=False,
+                 pretrained=None,
+                 init_values=0.1,
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        if isinstance(img_size, int):
+            img_size = to_2tuple(img_size)
+        elif isinstance(img_size, tuple):
+            if len(img_size) == 1:
+                img_size = to_2tuple(img_size[0])
+            assert len(img_size) == 2, \
+                f'The size of image should have length 1 or 2, ' \
+                f'but got {len(img_size)}'
+
+        assert not (init_cfg and pretrained), \
+            'init_cfg and pretrained cannot be set at the same time'
+        if isinstance(pretrained, str):
+            warnings.warn('DeprecationWarning: pretrained is deprecated, '
+                          'please use "init_cfg" instead')
+            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
+        elif pretrained is not None:
+            raise TypeError('pretrained must be a str or None')
+
+        self.in_channels = in_channels
+        self.img_size = img_size
+        self.patch_size = patch_size
+        self.norm_eval = norm_eval
+        self.pretrained = pretrained
+        self.num_layers = num_layers
+        self.embed_dims = embed_dims
+        self.num_heads = num_heads
+        self.mlp_ratio = mlp_ratio
+        self.attn_drop_rate = attn_drop_rate
+        self.drop_path_rate = drop_path_rate
+        self.num_fcs = num_fcs
+        self.qv_bias = qv_bias
+        self.act_cfg = act_cfg
+        self.norm_cfg = norm_cfg
+        self.patch_norm = patch_norm
+        self.init_values = init_values
+        self.window_size = (img_size[0] // patch_size,
+                            img_size[1] // patch_size)
+        self.patch_shape = self.window_size
+        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dims))
+
+        self._build_patch_embedding()
+        self._build_layers()
+
+        if isinstance(out_indices, int):
+            if out_indices == -1:
+                out_indices = num_layers - 1
+            self.out_indices = [out_indices]
+        elif isinstance(out_indices, list) or isinstance(out_indices, tuple):
+            self.out_indices = out_indices
+        else:
+            raise TypeError('out_indices must be type of int, list or tuple')
+
+        self.final_norm = final_norm
+        if final_norm:
+            self.norm1_name, norm1 = build_norm_layer(
+                norm_cfg, embed_dims, postfix=1)
+            self.add_module(self.norm1_name, norm1)
+
+    def _build_patch_embedding(self):
+        """Build patch embedding layer."""
+        self.patch_embed = PatchEmbed(
+            in_channels=self.in_channels,
+            embed_dims=self.embed_dims,
+            conv_type='Conv2d',
+            kernel_size=self.patch_size,
+            stride=self.patch_size,
+            padding=0,
+            norm_cfg=self.norm_cfg if self.patch_norm else None,
+            init_cfg=None)
+
+    def _build_layers(self):
+        """Build transformer encoding layers."""
+
+        dpr = [
+            x.item()
+            for x in torch.linspace(0, self.drop_path_rate, self.num_layers)
+        ]
+        self.layers = ModuleList()
+        for i in range(self.num_layers):
+            self.layers.append(
+                BEiTTransformerEncoderLayer(
+                    embed_dims=self.embed_dims,
+                    num_heads=self.num_heads,
+                    feedforward_channels=self.mlp_ratio * self.embed_dims,
+                    attn_drop_rate=self.attn_drop_rate,
+                    drop_path_rate=dpr[i],
+                    num_fcs=self.num_fcs,
+                    bias='qv_bias' if self.qv_bias else False,
+                    act_cfg=self.act_cfg,
+                    norm_cfg=self.norm_cfg,
+                    window_size=self.window_size,
+                    init_values=self.init_values))
+
+    @property
+    def norm1(self):
+        return getattr(self, self.norm1_name)
+
+    def _geometric_sequence_interpolation(self, src_size, dst_size, sequence,
+                                          num):
+        """Get new sequence via geometric sequence interpolation.
+
+        Args:
+            src_size (int): Pos_embedding size in pre-trained model.
+            dst_size (int): Pos_embedding size in the current model.
+            sequence (tensor): The relative position bias of the pretrain
+                model after removing the extra tokens.
+            num (int): Number of attention heads.
+        Returns:
+            new_sequence (tensor): Geometric sequence interpolate the
+                pre-trained relative position bias to the size of
+                the current model.
+        """
+
+        def geometric_progression(a, r, n):
+            return a * (1.0 - r**n) / (1.0 - r)
+
+        # Here is a binary function.
+        left, right = 1.01, 1.5
+        while right - left > 1e-6:
+            q = (left + right) / 2.0
+            gp = geometric_progression(1, q, src_size // 2)
+            if gp > dst_size // 2:
+                right = q
+            else:
+                left = q
+        # The position of each interpolated point is determined
+        # by the ratio obtained by dichotomy.
+        dis = []
+        cur = 1
+        for i in range(src_size // 2):
+            dis.append(cur)
+            cur += q**(i + 1)
+        r_ids = [-_ for _ in reversed(dis)]
+        x = r_ids + [0] + dis
+        y = r_ids + [0] + dis
+        t = dst_size // 2.0
+        dx = np.arange(-t, t + 0.1, 1.0)
+        dy = np.arange(-t, t + 0.1, 1.0)
+        # Interpolation functions are being executed and called.
+        new_sequence = []
+        for i in range(num):
+            z = sequence[:, i].view(src_size, src_size).float().numpy()
+            f = interpolate.interp2d(x, y, z, kind='cubic')
+            new_sequence.append(
+                torch.Tensor(f(dx, dy)).contiguous().view(-1, 1).to(sequence))
+        new_sequence = torch.cat(new_sequence, dim=-1)
+        return new_sequence
+
+    def resize_rel_pos_embed(self, checkpoint):
+        """Resize relative pos_embed weights.
+
+        This function is modified from
+        https://github.com/microsoft/unilm/blob/master/beit/semantic_segmentation/mmcv_custom/checkpoint.py.  # noqa: E501
+        Copyright (c) Microsoft Corporation
+        Licensed under the MIT License
+        Args:
+            checkpoint (dict): Key and value of the pretrain model.
+        Returns:
+            state_dict (dict): Interpolate the relative pos_embed weights
+                in the pre-train model to the current model size.
+        """
+        if 'state_dict' in checkpoint:
+            state_dict = checkpoint['state_dict']
+        else:
+            state_dict = checkpoint
+
+        all_keys = list(state_dict.keys())
+        for key in all_keys:
+            if 'relative_position_index' in key:
+                state_dict.pop(key)
+            # In order to keep the center of pos_bias as consistent as
+            # possible after interpolation, and vice versa in the edge
+            # area, the geometric sequence interpolation method is adopted.
+            if 'relative_position_bias_table' in key:
+                rel_pos_bias = state_dict[key]
+                src_num_pos, num_attn_heads = rel_pos_bias.size()
+                dst_num_pos, _ = self.state_dict()[key].size()
+                dst_patch_shape = self.patch_shape
+                if dst_patch_shape[0] != dst_patch_shape[1]:
+                    raise NotImplementedError()
+                # Count the number of extra tokens.
+                num_extra_tokens = dst_num_pos - (
+                    dst_patch_shape[0] * 2 - 1) * (
+                        dst_patch_shape[1] * 2 - 1)
+                src_size = int((src_num_pos - num_extra_tokens)**0.5)
+                dst_size = int((dst_num_pos - num_extra_tokens)**0.5)
+                if src_size != dst_size:
+                    extra_tokens = rel_pos_bias[-num_extra_tokens:, :]
+                    rel_pos_bias = rel_pos_bias[:-num_extra_tokens, :]
+                    new_rel_pos_bias = self._geometric_sequence_interpolation(
+                        src_size, dst_size, rel_pos_bias, num_attn_heads)
+                    new_rel_pos_bias = torch.cat(
+                        (new_rel_pos_bias, extra_tokens), dim=0)
+                    state_dict[key] = new_rel_pos_bias
+
+        return state_dict
+
+    def init_weights(self):
+
+        def _init_weights(m):
+            if isinstance(m, nn.Linear):
+                trunc_normal_(m.weight, std=.02)
+                if isinstance(m, nn.Linear) and m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.LayerNorm):
+                nn.init.constant_(m.bias, 0)
+                nn.init.constant_(m.weight, 1.0)
+
+        self.apply(_init_weights)
+
+        if (isinstance(self.init_cfg, dict)
+                and self.init_cfg.get('type') == 'Pretrained'):
+            checkpoint = _load_checkpoint(
+                self.init_cfg['checkpoint'], logger=None, map_location='cpu')
+            state_dict = self.resize_rel_pos_embed(checkpoint)
+            self.load_state_dict(state_dict, False)
+        elif self.init_cfg is not None:
+            super().init_weights()
+        else:
+            # We only implement the 'jax_impl' initialization implemented at
+            # https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/vision_transformer.py#L353  # noqa: E501
+            # Copyright 2019 Ross Wightman
+            # Licensed under the Apache License, Version 2.0 (the "License")
+            trunc_normal_(self.cls_token, std=.02)
+            for n, m in self.named_modules():
+                if isinstance(m, nn.Linear):
+                    trunc_normal_(m.weight, std=.02)
+                    if m.bias is not None:
+                        if 'ffn' in n:
+                            nn.init.normal_(m.bias, mean=0., std=1e-6)
+                        else:
+                            nn.init.constant_(m.bias, 0)
+                elif isinstance(m, nn.Conv2d):
+                    kaiming_init(m, mode='fan_in', bias=0.)
+                elif isinstance(m, (_BatchNorm, nn.GroupNorm, nn.LayerNorm)):
+                    constant_init(m, val=1.0, bias=0.)
+
+    def forward(self, inputs):
+        B = inputs.shape[0]
+
+        x, hw_shape = self.patch_embed(inputs)
+
+        # stole cls_tokens impl from Phil Wang, thanks
+        cls_tokens = self.cls_token.expand(B, -1, -1)
+        x = torch.cat((cls_tokens, x), dim=1)
+
+        outs = []
+        for i, layer in enumerate(self.layers):
+            x = layer(x)
+            if i == len(self.layers) - 1:
+                if self.final_norm:
+                    x = self.norm1(x)
+            if i in self.out_indices:
+                # Remove class token and reshape token for decoder head
+                out = x[:, 1:]
+                B, _, C = out.shape
+                out = out.reshape(B, hw_shape[0], hw_shape[1],
+                                  C).permute(0, 3, 1, 2).contiguous()
+                outs.append(out)
+
+        return tuple(outs)
+
+    def train(self, mode=True):
+        super().train(mode)
+        if mode and self.norm_eval:
+            for m in self.modules():
+                if isinstance(m, nn.LayerNorm):
+                    m.eval()
diff --git a/mmsegmentation/mmseg/models/backbones/bisenetv1.py b/mmsegmentation/mmseg/models/backbones/bisenetv1.py
new file mode 100644
index 0000000..ca58bf9
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/bisenetv1.py
@@ -0,0 +1,332 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule
+
+from mmseg.registry import MODELS
+from ..utils import resize
+
+
+class SpatialPath(BaseModule):
+    """Spatial Path to preserve the spatial size of the original input image
+    and encode affluent spatial information.
+
+    Args:
+        in_channels(int): The number of channels of input
+            image. Default: 3.
+        num_channels (Tuple[int]): The number of channels of
+            each layers in Spatial Path.
+            Default: (64, 64, 64, 128).
+    Returns:
+        x (torch.Tensor): Feature map for Feature Fusion Module.
+    """
+
+    def __init__(self,
+                 in_channels=3,
+                 num_channels=(64, 64, 64, 128),
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        assert len(num_channels) == 4, 'Length of input channels \
+                                        of Spatial Path must be 4!'
+
+        self.layers = []
+        for i in range(len(num_channels)):
+            layer_name = f'layer{i + 1}'
+            self.layers.append(layer_name)
+            if i == 0:
+                self.add_module(
+                    layer_name,
+                    ConvModule(
+                        in_channels=in_channels,
+                        out_channels=num_channels[i],
+                        kernel_size=7,
+                        stride=2,
+                        padding=3,
+                        conv_cfg=conv_cfg,
+                        norm_cfg=norm_cfg,
+                        act_cfg=act_cfg))
+            elif i == len(num_channels) - 1:
+                self.add_module(
+                    layer_name,
+                    ConvModule(
+                        in_channels=num_channels[i - 1],
+                        out_channels=num_channels[i],
+                        kernel_size=1,
+                        stride=1,
+                        padding=0,
+                        conv_cfg=conv_cfg,
+                        norm_cfg=norm_cfg,
+                        act_cfg=act_cfg))
+            else:
+                self.add_module(
+                    layer_name,
+                    ConvModule(
+                        in_channels=num_channels[i - 1],
+                        out_channels=num_channels[i],
+                        kernel_size=3,
+                        stride=2,
+                        padding=1,
+                        conv_cfg=conv_cfg,
+                        norm_cfg=norm_cfg,
+                        act_cfg=act_cfg))
+
+    def forward(self, x):
+        for i, layer_name in enumerate(self.layers):
+            layer_stage = getattr(self, layer_name)
+            x = layer_stage(x)
+        return x
+
+
+class AttentionRefinementModule(BaseModule):
+    """Attention Refinement Module (ARM) to refine the features of each stage.
+
+    Args:
+        in_channels (int): The number of input channels.
+        out_channels (int): The number of output channels.
+    Returns:
+        x_out (torch.Tensor): Feature map of Attention Refinement Module.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channel,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        self.conv_layer = ConvModule(
+            in_channels=in_channels,
+            out_channels=out_channel,
+            kernel_size=3,
+            stride=1,
+            padding=1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        self.atten_conv_layer = nn.Sequential(
+            nn.AdaptiveAvgPool2d((1, 1)),
+            ConvModule(
+                in_channels=out_channel,
+                out_channels=out_channel,
+                kernel_size=1,
+                bias=False,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=None), nn.Sigmoid())
+
+    def forward(self, x):
+        x = self.conv_layer(x)
+        x_atten = self.atten_conv_layer(x)
+        x_out = x * x_atten
+        return x_out
+
+
+class ContextPath(BaseModule):
+    """Context Path to provide sufficient receptive field.
+
+    Args:
+        backbone_cfg:(dict): Config of backbone of
+            Context Path.
+        context_channels (Tuple[int]): The number of channel numbers
+            of various modules in Context Path.
+            Default: (128, 256, 512).
+        align_corners (bool, optional): The align_corners argument of
+            resize operation. Default: False.
+    Returns:
+        x_16_up, x_32_up (torch.Tensor, torch.Tensor): Two feature maps
+            undergoing upsampling from 1/16 and 1/32 downsampling
+            feature maps. These two feature maps are used for Feature
+            Fusion Module and Auxiliary Head.
+    """
+
+    def __init__(self,
+                 backbone_cfg,
+                 context_channels=(128, 256, 512),
+                 align_corners=False,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        assert len(context_channels) == 3, 'Length of input channels \
+                                           of Context Path must be 3!'
+
+        self.backbone = MODELS.build(backbone_cfg)
+
+        self.align_corners = align_corners
+        self.arm16 = AttentionRefinementModule(context_channels[1],
+                                               context_channels[0])
+        self.arm32 = AttentionRefinementModule(context_channels[2],
+                                               context_channels[0])
+        self.conv_head32 = ConvModule(
+            in_channels=context_channels[0],
+            out_channels=context_channels[0],
+            kernel_size=3,
+            stride=1,
+            padding=1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        self.conv_head16 = ConvModule(
+            in_channels=context_channels[0],
+            out_channels=context_channels[0],
+            kernel_size=3,
+            stride=1,
+            padding=1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        self.gap_conv = nn.Sequential(
+            nn.AdaptiveAvgPool2d((1, 1)),
+            ConvModule(
+                in_channels=context_channels[2],
+                out_channels=context_channels[0],
+                kernel_size=1,
+                stride=1,
+                padding=0,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg))
+
+    def forward(self, x):
+        x_4, x_8, x_16, x_32 = self.backbone(x)
+        x_gap = self.gap_conv(x_32)
+
+        x_32_arm = self.arm32(x_32)
+        x_32_sum = x_32_arm + x_gap
+        x_32_up = resize(input=x_32_sum, size=x_16.shape[2:], mode='nearest')
+        x_32_up = self.conv_head32(x_32_up)
+
+        x_16_arm = self.arm16(x_16)
+        x_16_sum = x_16_arm + x_32_up
+        x_16_up = resize(input=x_16_sum, size=x_8.shape[2:], mode='nearest')
+        x_16_up = self.conv_head16(x_16_up)
+
+        return x_16_up, x_32_up
+
+
+class FeatureFusionModule(BaseModule):
+    """Feature Fusion Module to fuse low level output feature of Spatial Path
+    and high level output feature of Context Path.
+
+    Args:
+        in_channels (int): The number of input channels.
+        out_channels (int): The number of output channels.
+    Returns:
+        x_out (torch.Tensor): Feature map of Feature Fusion Module.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        self.conv1 = ConvModule(
+            in_channels=in_channels,
+            out_channels=out_channels,
+            kernel_size=1,
+            stride=1,
+            padding=0,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        self.gap = nn.AdaptiveAvgPool2d((1, 1))
+        self.conv_atten = nn.Sequential(
+            ConvModule(
+                in_channels=out_channels,
+                out_channels=out_channels,
+                kernel_size=1,
+                stride=1,
+                padding=0,
+                bias=False,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg), nn.Sigmoid())
+
+    def forward(self, x_sp, x_cp):
+        x_concat = torch.cat([x_sp, x_cp], dim=1)
+        x_fuse = self.conv1(x_concat)
+        x_atten = self.gap(x_fuse)
+        # Note: No BN and more 1x1 conv in paper.
+        x_atten = self.conv_atten(x_atten)
+        x_atten = x_fuse * x_atten
+        x_out = x_atten + x_fuse
+        return x_out
+
+
+@MODELS.register_module()
+class BiSeNetV1(BaseModule):
+    """BiSeNetV1 backbone.
+
+    This backbone is the implementation of `BiSeNet: Bilateral
+    Segmentation Network for Real-time Semantic
+    Segmentation <https://arxiv.org/abs/1808.00897>`_.
+
+    Args:
+        backbone_cfg:(dict): Config of backbone of
+            Context Path.
+        in_channels (int): The number of channels of input
+            image. Default: 3.
+        spatial_channels (Tuple[int]): Size of channel numbers of
+            various layers in Spatial Path.
+            Default: (64, 64, 64, 128).
+        context_channels (Tuple[int]): Size of channel numbers of
+            various modules in Context Path.
+            Default: (128, 256, 512).
+        out_indices (Tuple[int] | int, optional): Output from which stages.
+            Default: (0, 1, 2).
+        align_corners (bool, optional): The align_corners argument of
+            resize operation in Bilateral Guided Aggregation Layer.
+            Default: False.
+        out_channels(int): The number of channels of output.
+            It must be the same with `in_channels` of decode_head.
+            Default: 256.
+    """
+
+    def __init__(self,
+                 backbone_cfg,
+                 in_channels=3,
+                 spatial_channels=(64, 64, 64, 128),
+                 context_channels=(128, 256, 512),
+                 out_indices=(0, 1, 2),
+                 align_corners=False,
+                 out_channels=256,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN', requires_grad=True),
+                 act_cfg=dict(type='ReLU'),
+                 init_cfg=None):
+
+        super().__init__(init_cfg=init_cfg)
+        assert len(spatial_channels) == 4, 'Length of input channels \
+                                           of Spatial Path must be 4!'
+
+        assert len(context_channels) == 3, 'Length of input channels \
+                                           of Context Path must be 3!'
+
+        self.out_indices = out_indices
+        self.align_corners = align_corners
+        self.context_path = ContextPath(backbone_cfg, context_channels,
+                                        self.align_corners)
+        self.spatial_path = SpatialPath(in_channels, spatial_channels)
+        self.ffm = FeatureFusionModule(context_channels[1], out_channels)
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+
+    def forward(self, x):
+        # stole refactoring code from Coin Cheung, thanks
+        x_context8, x_context16 = self.context_path(x)
+        x_spatial = self.spatial_path(x)
+        x_fuse = self.ffm(x_spatial, x_context8)
+
+        outs = [x_fuse, x_context8, x_context16]
+        outs = [outs[i] for i in self.out_indices]
+        return tuple(outs)
diff --git a/mmsegmentation/mmseg/models/backbones/bisenetv2.py b/mmsegmentation/mmseg/models/backbones/bisenetv2.py
new file mode 100644
index 0000000..32aa498
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/bisenetv2.py
@@ -0,0 +1,622 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmcv.cnn import (ConvModule, DepthwiseSeparableConvModule,
+                      build_activation_layer, build_norm_layer)
+from mmengine.model import BaseModule
+
+from mmseg.registry import MODELS
+from ..utils import resize
+
+
+class DetailBranch(BaseModule):
+    """Detail Branch with wide channels and shallow layers to capture low-level
+    details and generate high-resolution feature representation.
+
+    Args:
+        detail_channels (Tuple[int]): Size of channel numbers of each stage
+            in Detail Branch, in paper it has 3 stages.
+            Default: (64, 64, 128).
+        in_channels (int): Number of channels of input image. Default: 3.
+        conv_cfg (dict | None): Config of conv layers.
+            Default: None.
+        norm_cfg (dict | None): Config of norm layers.
+            Default: dict(type='BN').
+        act_cfg (dict): Config of activation layers.
+            Default: dict(type='ReLU').
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    Returns:
+        x (torch.Tensor): Feature map of Detail Branch.
+    """
+
+    def __init__(self,
+                 detail_channels=(64, 64, 128),
+                 in_channels=3,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        detail_branch = []
+        for i in range(len(detail_channels)):
+            if i == 0:
+                detail_branch.append(
+                    nn.Sequential(
+                        ConvModule(
+                            in_channels=in_channels,
+                            out_channels=detail_channels[i],
+                            kernel_size=3,
+                            stride=2,
+                            padding=1,
+                            conv_cfg=conv_cfg,
+                            norm_cfg=norm_cfg,
+                            act_cfg=act_cfg),
+                        ConvModule(
+                            in_channels=detail_channels[i],
+                            out_channels=detail_channels[i],
+                            kernel_size=3,
+                            stride=1,
+                            padding=1,
+                            conv_cfg=conv_cfg,
+                            norm_cfg=norm_cfg,
+                            act_cfg=act_cfg)))
+            else:
+                detail_branch.append(
+                    nn.Sequential(
+                        ConvModule(
+                            in_channels=detail_channels[i - 1],
+                            out_channels=detail_channels[i],
+                            kernel_size=3,
+                            stride=2,
+                            padding=1,
+                            conv_cfg=conv_cfg,
+                            norm_cfg=norm_cfg,
+                            act_cfg=act_cfg),
+                        ConvModule(
+                            in_channels=detail_channels[i],
+                            out_channels=detail_channels[i],
+                            kernel_size=3,
+                            stride=1,
+                            padding=1,
+                            conv_cfg=conv_cfg,
+                            norm_cfg=norm_cfg,
+                            act_cfg=act_cfg),
+                        ConvModule(
+                            in_channels=detail_channels[i],
+                            out_channels=detail_channels[i],
+                            kernel_size=3,
+                            stride=1,
+                            padding=1,
+                            conv_cfg=conv_cfg,
+                            norm_cfg=norm_cfg,
+                            act_cfg=act_cfg)))
+        self.detail_branch = nn.ModuleList(detail_branch)
+
+    def forward(self, x):
+        for stage in self.detail_branch:
+            x = stage(x)
+        return x
+
+
+class StemBlock(BaseModule):
+    """Stem Block at the beginning of Semantic Branch.
+
+    Args:
+        in_channels (int): Number of input channels.
+            Default: 3.
+        out_channels (int): Number of output channels.
+            Default: 16.
+        conv_cfg (dict | None): Config of conv layers.
+            Default: None.
+        norm_cfg (dict | None): Config of norm layers.
+            Default: dict(type='BN').
+        act_cfg (dict): Config of activation layers.
+            Default: dict(type='ReLU').
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    Returns:
+        x (torch.Tensor): First feature map in Semantic Branch.
+    """
+
+    def __init__(self,
+                 in_channels=3,
+                 out_channels=16,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+
+        self.conv_first = ConvModule(
+            in_channels=in_channels,
+            out_channels=out_channels,
+            kernel_size=3,
+            stride=2,
+            padding=1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        self.convs = nn.Sequential(
+            ConvModule(
+                in_channels=out_channels,
+                out_channels=out_channels // 2,
+                kernel_size=1,
+                stride=1,
+                padding=0,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg),
+            ConvModule(
+                in_channels=out_channels // 2,
+                out_channels=out_channels,
+                kernel_size=3,
+                stride=2,
+                padding=1,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg))
+        self.pool = nn.MaxPool2d(
+            kernel_size=3, stride=2, padding=1, ceil_mode=False)
+        self.fuse_last = ConvModule(
+            in_channels=out_channels * 2,
+            out_channels=out_channels,
+            kernel_size=3,
+            stride=1,
+            padding=1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+
+    def forward(self, x):
+        x = self.conv_first(x)
+        x_left = self.convs(x)
+        x_right = self.pool(x)
+        x = self.fuse_last(torch.cat([x_left, x_right], dim=1))
+        return x
+
+
+class GELayer(BaseModule):
+    """Gather-and-Expansion Layer.
+
+    Args:
+        in_channels (int): Number of input channels.
+        out_channels (int): Number of output channels.
+        exp_ratio (int): Expansion ratio for middle channels.
+            Default: 6.
+        stride (int): Stride of GELayer. Default: 1
+        conv_cfg (dict | None): Config of conv layers.
+            Default: None.
+        norm_cfg (dict | None): Config of norm layers.
+            Default: dict(type='BN').
+        act_cfg (dict): Config of activation layers.
+            Default: dict(type='ReLU').
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    Returns:
+        x (torch.Tensor): Intermediate feature map in
+            Semantic Branch.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 exp_ratio=6,
+                 stride=1,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        mid_channel = in_channels * exp_ratio
+        self.conv1 = ConvModule(
+            in_channels=in_channels,
+            out_channels=in_channels,
+            kernel_size=3,
+            stride=1,
+            padding=1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        if stride == 1:
+            self.dwconv = nn.Sequential(
+                # ReLU in ConvModule not shown in paper
+                ConvModule(
+                    in_channels=in_channels,
+                    out_channels=mid_channel,
+                    kernel_size=3,
+                    stride=stride,
+                    padding=1,
+                    groups=in_channels,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg))
+            self.shortcut = None
+        else:
+            self.dwconv = nn.Sequential(
+                ConvModule(
+                    in_channels=in_channels,
+                    out_channels=mid_channel,
+                    kernel_size=3,
+                    stride=stride,
+                    padding=1,
+                    groups=in_channels,
+                    bias=False,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=None),
+                # ReLU in ConvModule not shown in paper
+                ConvModule(
+                    in_channels=mid_channel,
+                    out_channels=mid_channel,
+                    kernel_size=3,
+                    stride=1,
+                    padding=1,
+                    groups=mid_channel,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg),
+            )
+            self.shortcut = nn.Sequential(
+                DepthwiseSeparableConvModule(
+                    in_channels=in_channels,
+                    out_channels=out_channels,
+                    kernel_size=3,
+                    stride=stride,
+                    padding=1,
+                    dw_norm_cfg=norm_cfg,
+                    dw_act_cfg=None,
+                    pw_norm_cfg=norm_cfg,
+                    pw_act_cfg=None,
+                ))
+
+        self.conv2 = nn.Sequential(
+            ConvModule(
+                in_channels=mid_channel,
+                out_channels=out_channels,
+                kernel_size=1,
+                stride=1,
+                padding=0,
+                bias=False,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=None,
+            ))
+
+        self.act = build_activation_layer(act_cfg)
+
+    def forward(self, x):
+        identity = x
+        x = self.conv1(x)
+        x = self.dwconv(x)
+        x = self.conv2(x)
+        if self.shortcut is not None:
+            shortcut = self.shortcut(identity)
+            x = x + shortcut
+        else:
+            x = x + identity
+        x = self.act(x)
+        return x
+
+
+class CEBlock(BaseModule):
+    """Context Embedding Block for large receptive filed in Semantic Branch.
+
+    Args:
+        in_channels (int): Number of input channels.
+            Default: 3.
+        out_channels (int): Number of output channels.
+            Default: 16.
+        conv_cfg (dict | None): Config of conv layers.
+            Default: None.
+        norm_cfg (dict | None): Config of norm layers.
+            Default: dict(type='BN').
+        act_cfg (dict): Config of activation layers.
+            Default: dict(type='ReLU').
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    Returns:
+        x (torch.Tensor): Last feature map in Semantic Branch.
+    """
+
+    def __init__(self,
+                 in_channels=3,
+                 out_channels=16,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.gap = nn.Sequential(
+            nn.AdaptiveAvgPool2d((1, 1)),
+            build_norm_layer(norm_cfg, self.in_channels)[1])
+        self.conv_gap = ConvModule(
+            in_channels=self.in_channels,
+            out_channels=self.out_channels,
+            kernel_size=1,
+            stride=1,
+            padding=0,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        # Note: in paper here is naive conv2d, no bn-relu
+        self.conv_last = ConvModule(
+            in_channels=self.out_channels,
+            out_channels=self.out_channels,
+            kernel_size=3,
+            stride=1,
+            padding=1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+
+    def forward(self, x):
+        identity = x
+        x = self.gap(x)
+        x = self.conv_gap(x)
+        x = identity + x
+        x = self.conv_last(x)
+        return x
+
+
+class SemanticBranch(BaseModule):
+    """Semantic Branch which is lightweight with narrow channels and deep
+    layers to obtain　high-level semantic context.
+
+    Args:
+        semantic_channels(Tuple[int]): Size of channel numbers of
+            various stages in Semantic Branch.
+            Default: (16, 32, 64, 128).
+        in_channels (int): Number of channels of input image. Default: 3.
+        exp_ratio (int): Expansion ratio for middle channels.
+            Default: 6.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    Returns:
+        semantic_outs (List[torch.Tensor]): List of several feature maps
+            for auxiliary heads (Booster) and Bilateral
+            Guided Aggregation Layer.
+    """
+
+    def __init__(self,
+                 semantic_channels=(16, 32, 64, 128),
+                 in_channels=3,
+                 exp_ratio=6,
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        self.in_channels = in_channels
+        self.semantic_channels = semantic_channels
+        self.semantic_stages = []
+        for i in range(len(semantic_channels)):
+            stage_name = f'stage{i + 1}'
+            self.semantic_stages.append(stage_name)
+            if i == 0:
+                self.add_module(
+                    stage_name,
+                    StemBlock(self.in_channels, semantic_channels[i]))
+            elif i == (len(semantic_channels) - 1):
+                self.add_module(
+                    stage_name,
+                    nn.Sequential(
+                        GELayer(semantic_channels[i - 1], semantic_channels[i],
+                                exp_ratio, 2),
+                        GELayer(semantic_channels[i], semantic_channels[i],
+                                exp_ratio, 1),
+                        GELayer(semantic_channels[i], semantic_channels[i],
+                                exp_ratio, 1),
+                        GELayer(semantic_channels[i], semantic_channels[i],
+                                exp_ratio, 1)))
+            else:
+                self.add_module(
+                    stage_name,
+                    nn.Sequential(
+                        GELayer(semantic_channels[i - 1], semantic_channels[i],
+                                exp_ratio, 2),
+                        GELayer(semantic_channels[i], semantic_channels[i],
+                                exp_ratio, 1)))
+
+        self.add_module(f'stage{len(semantic_channels)}_CEBlock',
+                        CEBlock(semantic_channels[-1], semantic_channels[-1]))
+        self.semantic_stages.append(f'stage{len(semantic_channels)}_CEBlock')
+
+    def forward(self, x):
+        semantic_outs = []
+        for stage_name in self.semantic_stages:
+            semantic_stage = getattr(self, stage_name)
+            x = semantic_stage(x)
+            semantic_outs.append(x)
+        return semantic_outs
+
+
+class BGALayer(BaseModule):
+    """Bilateral Guided Aggregation Layer to fuse the complementary information
+    from both Detail Branch and Semantic Branch.
+
+    Args:
+        out_channels (int): Number of output channels.
+            Default: 128.
+        align_corners (bool): align_corners argument of F.interpolate.
+            Default: False.
+        conv_cfg (dict | None): Config of conv layers.
+            Default: None.
+        norm_cfg (dict | None): Config of norm layers.
+            Default: dict(type='BN').
+        act_cfg (dict): Config of activation layers.
+            Default: dict(type='ReLU').
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    Returns:
+        output (torch.Tensor): Output feature map for Segment heads.
+    """
+
+    def __init__(self,
+                 out_channels=128,
+                 align_corners=False,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        self.out_channels = out_channels
+        self.align_corners = align_corners
+        self.detail_dwconv = nn.Sequential(
+            DepthwiseSeparableConvModule(
+                in_channels=self.out_channels,
+                out_channels=self.out_channels,
+                kernel_size=3,
+                stride=1,
+                padding=1,
+                dw_norm_cfg=norm_cfg,
+                dw_act_cfg=None,
+                pw_norm_cfg=None,
+                pw_act_cfg=None,
+            ))
+        self.detail_down = nn.Sequential(
+            ConvModule(
+                in_channels=self.out_channels,
+                out_channels=self.out_channels,
+                kernel_size=3,
+                stride=2,
+                padding=1,
+                bias=False,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=None),
+            nn.AvgPool2d(kernel_size=3, stride=2, padding=1, ceil_mode=False))
+        self.semantic_conv = nn.Sequential(
+            ConvModule(
+                in_channels=self.out_channels,
+                out_channels=self.out_channels,
+                kernel_size=3,
+                stride=1,
+                padding=1,
+                bias=False,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=None))
+        self.semantic_dwconv = nn.Sequential(
+            DepthwiseSeparableConvModule(
+                in_channels=self.out_channels,
+                out_channels=self.out_channels,
+                kernel_size=3,
+                stride=1,
+                padding=1,
+                dw_norm_cfg=norm_cfg,
+                dw_act_cfg=None,
+                pw_norm_cfg=None,
+                pw_act_cfg=None,
+            ))
+        self.conv = ConvModule(
+            in_channels=self.out_channels,
+            out_channels=self.out_channels,
+            kernel_size=3,
+            stride=1,
+            padding=1,
+            inplace=True,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg,
+        )
+
+    def forward(self, x_d, x_s):
+        detail_dwconv = self.detail_dwconv(x_d)
+        detail_down = self.detail_down(x_d)
+        semantic_conv = self.semantic_conv(x_s)
+        semantic_dwconv = self.semantic_dwconv(x_s)
+        semantic_conv = resize(
+            input=semantic_conv,
+            size=detail_dwconv.shape[2:],
+            mode='bilinear',
+            align_corners=self.align_corners)
+        fuse_1 = detail_dwconv * torch.sigmoid(semantic_conv)
+        fuse_2 = detail_down * torch.sigmoid(semantic_dwconv)
+        fuse_2 = resize(
+            input=fuse_2,
+            size=fuse_1.shape[2:],
+            mode='bilinear',
+            align_corners=self.align_corners)
+        output = self.conv(fuse_1 + fuse_2)
+        return output
+
+
+@MODELS.register_module()
+class BiSeNetV2(BaseModule):
+    """BiSeNetV2: Bilateral Network with Guided Aggregation for
+    Real-time Semantic Segmentation.
+
+    This backbone is the implementation of
+    `BiSeNetV2 <https://arxiv.org/abs/2004.02147>`_.
+
+    Args:
+        in_channels (int): Number of channel of input image. Default: 3.
+        detail_channels (Tuple[int], optional): Channels of each stage
+            in Detail Branch. Default: (64, 64, 128).
+        semantic_channels (Tuple[int], optional): Channels of each stage
+            in Semantic Branch. Default: (16, 32, 64, 128).
+            See Table 1 and Figure 3 of paper for more details.
+        semantic_expansion_ratio (int, optional): The expansion factor
+            expanding channel number of middle channels in Semantic Branch.
+            Default: 6.
+        bga_channels (int, optional): Number of middle channels in
+            Bilateral Guided Aggregation Layer. Default: 128.
+        out_indices (Tuple[int] | int, optional): Output from which stages.
+            Default: (0, 1, 2, 3, 4).
+        align_corners (bool, optional): The align_corners argument of
+            resize operation in Bilateral Guided Aggregation Layer.
+            Default: False.
+        conv_cfg (dict | None): Config of conv layers.
+            Default: None.
+        norm_cfg (dict | None): Config of norm layers.
+            Default: dict(type='BN').
+        act_cfg (dict): Config of activation layers.
+            Default: dict(type='ReLU').
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    """
+
+    def __init__(self,
+                 in_channels=3,
+                 detail_channels=(64, 64, 128),
+                 semantic_channels=(16, 32, 64, 128),
+                 semantic_expansion_ratio=6,
+                 bga_channels=128,
+                 out_indices=(0, 1, 2, 3, 4),
+                 align_corners=False,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 init_cfg=None):
+        if init_cfg is None:
+            init_cfg = [
+                dict(type='Kaiming', layer='Conv2d'),
+                dict(
+                    type='Constant', val=1, layer=['_BatchNorm', 'GroupNorm'])
+            ]
+        super().__init__(init_cfg=init_cfg)
+        self.in_channels = in_channels
+        self.out_indices = out_indices
+        self.detail_channels = detail_channels
+        self.semantic_channels = semantic_channels
+        self.semantic_expansion_ratio = semantic_expansion_ratio
+        self.bga_channels = bga_channels
+        self.align_corners = align_corners
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+
+        self.detail = DetailBranch(self.detail_channels, self.in_channels)
+        self.semantic = SemanticBranch(self.semantic_channels,
+                                       self.in_channels,
+                                       self.semantic_expansion_ratio)
+        self.bga = BGALayer(self.bga_channels, self.align_corners)
+
+    def forward(self, x):
+        #  stole refactoring code from Coin Cheung, thanks
+        x_detail = self.detail(x)
+        x_semantic_lst = self.semantic(x)
+        x_head = self.bga(x_detail, x_semantic_lst[-1])
+        outs = [x_head] + x_semantic_lst[:-1]
+        outs = [outs[i] for i in self.out_indices]
+        return tuple(outs)
diff --git a/mmsegmentation/mmseg/models/backbones/cgnet.py b/mmsegmentation/mmseg/models/backbones/cgnet.py
new file mode 100644
index 0000000..b74b494
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/cgnet.py
@@ -0,0 +1,372 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+import torch
+import torch.nn as nn
+import torch.utils.checkpoint as cp
+from mmcv.cnn import ConvModule, build_conv_layer, build_norm_layer
+from mmengine.model import BaseModule
+from mmengine.utils.dl_utils.parrots_wrapper import _BatchNorm
+
+from mmseg.registry import MODELS
+
+
+class GlobalContextExtractor(nn.Module):
+    """Global Context Extractor for CGNet.
+
+    This class is employed to refine the joint feature of both local feature
+    and surrounding context.
+
+    Args:
+        channel (int): Number of input feature channels.
+        reduction (int): Reductions for global context extractor. Default: 16.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed. Default: False.
+    """
+
+    def __init__(self, channel, reduction=16, with_cp=False):
+        super().__init__()
+        self.channel = channel
+        self.reduction = reduction
+        assert reduction >= 1 and channel >= reduction
+        self.with_cp = with_cp
+        self.avg_pool = nn.AdaptiveAvgPool2d(1)
+        self.fc = nn.Sequential(
+            nn.Linear(channel, channel // reduction), nn.ReLU(inplace=True),
+            nn.Linear(channel // reduction, channel), nn.Sigmoid())
+
+    def forward(self, x):
+
+        def _inner_forward(x):
+            num_batch, num_channel = x.size()[:2]
+            y = self.avg_pool(x).view(num_batch, num_channel)
+            y = self.fc(y).view(num_batch, num_channel, 1, 1)
+            return x * y
+
+        if self.with_cp and x.requires_grad:
+            out = cp.checkpoint(_inner_forward, x)
+        else:
+            out = _inner_forward(x)
+
+        return out
+
+
+class ContextGuidedBlock(nn.Module):
+    """Context Guided Block for CGNet.
+
+    This class consists of four components: local feature extractor,
+    surrounding feature extractor, joint feature extractor and global
+    context extractor.
+
+    Args:
+        in_channels (int): Number of input feature channels.
+        out_channels (int): Number of output feature channels.
+        dilation (int): Dilation rate for surrounding context extractor.
+            Default: 2.
+        reduction (int): Reduction for global context extractor. Default: 16.
+        skip_connect (bool): Add input to output or not. Default: True.
+        downsample (bool): Downsample the input to 1/2 or not. Default: False.
+        conv_cfg (dict): Config dict for convolution layer.
+            Default: None, which means using conv2d.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN', requires_grad=True).
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='PReLU').
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed. Default: False.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 dilation=2,
+                 reduction=16,
+                 skip_connect=True,
+                 downsample=False,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN', requires_grad=True),
+                 act_cfg=dict(type='PReLU'),
+                 with_cp=False):
+        super().__init__()
+        self.with_cp = with_cp
+        self.downsample = downsample
+
+        channels = out_channels if downsample else out_channels // 2
+        if 'type' in act_cfg and act_cfg['type'] == 'PReLU':
+            act_cfg['num_parameters'] = channels
+        kernel_size = 3 if downsample else 1
+        stride = 2 if downsample else 1
+        padding = (kernel_size - 1) // 2
+
+        self.conv1x1 = ConvModule(
+            in_channels,
+            channels,
+            kernel_size,
+            stride,
+            padding,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+
+        self.f_loc = build_conv_layer(
+            conv_cfg,
+            channels,
+            channels,
+            kernel_size=3,
+            padding=1,
+            groups=channels,
+            bias=False)
+        self.f_sur = build_conv_layer(
+            conv_cfg,
+            channels,
+            channels,
+            kernel_size=3,
+            padding=dilation,
+            groups=channels,
+            dilation=dilation,
+            bias=False)
+
+        self.bn = build_norm_layer(norm_cfg, 2 * channels)[1]
+        self.activate = nn.PReLU(2 * channels)
+
+        if downsample:
+            self.bottleneck = build_conv_layer(
+                conv_cfg,
+                2 * channels,
+                out_channels,
+                kernel_size=1,
+                bias=False)
+
+        self.skip_connect = skip_connect and not downsample
+        self.f_glo = GlobalContextExtractor(out_channels, reduction, with_cp)
+
+    def forward(self, x):
+
+        def _inner_forward(x):
+            out = self.conv1x1(x)
+            loc = self.f_loc(out)
+            sur = self.f_sur(out)
+
+            joi_feat = torch.cat([loc, sur], 1)  # the joint feature
+            joi_feat = self.bn(joi_feat)
+            joi_feat = self.activate(joi_feat)
+            if self.downsample:
+                joi_feat = self.bottleneck(joi_feat)  # channel = out_channels
+            # f_glo is employed to refine the joint feature
+            out = self.f_glo(joi_feat)
+
+            if self.skip_connect:
+                return x + out
+            else:
+                return out
+
+        if self.with_cp and x.requires_grad:
+            out = cp.checkpoint(_inner_forward, x)
+        else:
+            out = _inner_forward(x)
+
+        return out
+
+
+class InputInjection(nn.Module):
+    """Downsampling module for CGNet."""
+
+    def __init__(self, num_downsampling):
+        super().__init__()
+        self.pool = nn.ModuleList()
+        for i in range(num_downsampling):
+            self.pool.append(nn.AvgPool2d(3, stride=2, padding=1))
+
+    def forward(self, x):
+        for pool in self.pool:
+            x = pool(x)
+        return x
+
+
+@MODELS.register_module()
+class CGNet(BaseModule):
+    """CGNet backbone.
+
+    This backbone is the implementation of `A Light-weight Context Guided
+    Network for Semantic Segmentation <https://arxiv.org/abs/1811.08201>`_.
+
+    Args:
+        in_channels (int): Number of input image channels. Normally 3.
+        num_channels (tuple[int]): Numbers of feature channels at each stages.
+            Default: (32, 64, 128).
+        num_blocks (tuple[int]): Numbers of CG blocks at stage 1 and stage 2.
+            Default: (3, 21).
+        dilations (tuple[int]): Dilation rate for surrounding context
+            extractors at stage 1 and stage 2. Default: (2, 4).
+        reductions (tuple[int]): Reductions for global context extractors at
+            stage 1 and stage 2. Default: (8, 16).
+        conv_cfg (dict): Config dict for convolution layer.
+            Default: None, which means using conv2d.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN', requires_grad=True).
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='PReLU').
+        norm_eval (bool): Whether to set norm layers to eval mode, namely,
+            freeze running stats (mean and var). Note: Effect on Batch Norm
+            and its variants only. Default: False.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed. Default: False.
+        pretrained (str, optional): model pretrained path. Default: None
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None
+    """
+
+    def __init__(self,
+                 in_channels=3,
+                 num_channels=(32, 64, 128),
+                 num_blocks=(3, 21),
+                 dilations=(2, 4),
+                 reductions=(8, 16),
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN', requires_grad=True),
+                 act_cfg=dict(type='PReLU'),
+                 norm_eval=False,
+                 with_cp=False,
+                 pretrained=None,
+                 init_cfg=None):
+
+        super().__init__(init_cfg)
+
+        assert not (init_cfg and pretrained), \
+            'init_cfg and pretrained cannot be setting at the same time'
+        if isinstance(pretrained, str):
+            warnings.warn('DeprecationWarning: pretrained is a deprecated, '
+                          'please use "init_cfg" instead')
+            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
+        elif pretrained is None:
+            if init_cfg is None:
+                self.init_cfg = [
+                    dict(type='Kaiming', layer=['Conv2d', 'Linear']),
+                    dict(
+                        type='Constant',
+                        val=1,
+                        layer=['_BatchNorm', 'GroupNorm']),
+                    dict(type='Constant', val=0, layer='PReLU')
+                ]
+        else:
+            raise TypeError('pretrained must be a str or None')
+
+        self.in_channels = in_channels
+        self.num_channels = num_channels
+        assert isinstance(self.num_channels, tuple) and len(
+            self.num_channels) == 3
+        self.num_blocks = num_blocks
+        assert isinstance(self.num_blocks, tuple) and len(self.num_blocks) == 2
+        self.dilations = dilations
+        assert isinstance(self.dilations, tuple) and len(self.dilations) == 2
+        self.reductions = reductions
+        assert isinstance(self.reductions, tuple) and len(self.reductions) == 2
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+        if 'type' in self.act_cfg and self.act_cfg['type'] == 'PReLU':
+            self.act_cfg['num_parameters'] = num_channels[0]
+        self.norm_eval = norm_eval
+        self.with_cp = with_cp
+
+        cur_channels = in_channels
+        self.stem = nn.ModuleList()
+        for i in range(3):
+            self.stem.append(
+                ConvModule(
+                    cur_channels,
+                    num_channels[0],
+                    3,
+                    2 if i == 0 else 1,
+                    padding=1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg))
+            cur_channels = num_channels[0]
+
+        self.inject_2x = InputInjection(1)  # down-sample for Input, factor=2
+        self.inject_4x = InputInjection(2)  # down-sample for Input, factor=4
+
+        cur_channels += in_channels
+        self.norm_prelu_0 = nn.Sequential(
+            build_norm_layer(norm_cfg, cur_channels)[1],
+            nn.PReLU(cur_channels))
+
+        # stage 1
+        self.level1 = nn.ModuleList()
+        for i in range(num_blocks[0]):
+            self.level1.append(
+                ContextGuidedBlock(
+                    cur_channels if i == 0 else num_channels[1],
+                    num_channels[1],
+                    dilations[0],
+                    reductions[0],
+                    downsample=(i == 0),
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg,
+                    with_cp=with_cp))  # CG block
+
+        cur_channels = 2 * num_channels[1] + in_channels
+        self.norm_prelu_1 = nn.Sequential(
+            build_norm_layer(norm_cfg, cur_channels)[1],
+            nn.PReLU(cur_channels))
+
+        # stage 2
+        self.level2 = nn.ModuleList()
+        for i in range(num_blocks[1]):
+            self.level2.append(
+                ContextGuidedBlock(
+                    cur_channels if i == 0 else num_channels[2],
+                    num_channels[2],
+                    dilations[1],
+                    reductions[1],
+                    downsample=(i == 0),
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg,
+                    with_cp=with_cp))  # CG block
+
+        cur_channels = 2 * num_channels[2]
+        self.norm_prelu_2 = nn.Sequential(
+            build_norm_layer(norm_cfg, cur_channels)[1],
+            nn.PReLU(cur_channels))
+
+    def forward(self, x):
+        output = []
+
+        # stage 0
+        inp_2x = self.inject_2x(x)
+        inp_4x = self.inject_4x(x)
+        for layer in self.stem:
+            x = layer(x)
+        x = self.norm_prelu_0(torch.cat([x, inp_2x], 1))
+        output.append(x)
+
+        # stage 1
+        for i, layer in enumerate(self.level1):
+            x = layer(x)
+            if i == 0:
+                down1 = x
+        x = self.norm_prelu_1(torch.cat([x, down1, inp_4x], 1))
+        output.append(x)
+
+        # stage 2
+        for i, layer in enumerate(self.level2):
+            x = layer(x)
+            if i == 0:
+                down2 = x
+        x = self.norm_prelu_2(torch.cat([down2, x], 1))
+        output.append(x)
+
+        return output
+
+    def train(self, mode=True):
+        """Convert the model into training mode will keeping the normalization
+        layer freezed."""
+        super().train(mode)
+        if mode and self.norm_eval:
+            for m in self.modules():
+                # trick: eval have effect on BatchNorm only
+                if isinstance(m, _BatchNorm):
+                    m.eval()
diff --git a/mmsegmentation/mmseg/models/backbones/ddrnet.py b/mmsegmentation/mmseg/models/backbones/ddrnet.py
new file mode 100644
index 0000000..4508aad
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/ddrnet.py
@@ -0,0 +1,222 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch.nn as nn
+from mmcv.cnn import ConvModule, build_norm_layer
+from mmengine.model import BaseModule
+
+from mmseg.models.utils import DAPPM, BasicBlock, Bottleneck, resize
+from mmseg.registry import MODELS
+from mmseg.utils import OptConfigType
+
+
+@MODELS.register_module()
+class DDRNet(BaseModule):
+    """DDRNet backbone.
+
+    This backbone is the implementation of `Deep Dual-resolution Networks for
+    Real-time and Accurate Semantic Segmentation of Road Scenes
+    <http://arxiv.org/abs/2101.06085>`_.
+    Modified from https://github.com/ydhongHIT/DDRNet.
+
+    Args:
+        in_channels (int): Number of input image channels. Default: 3.
+        channels: (int): The base channels of DDRNet. Default: 32.
+        ppm_channels (int): The channels of PPM module. Default: 128.
+        align_corners (bool): align_corners argument of F.interpolate.
+            Default: False.
+        norm_cfg (dict): Config dict to build norm layer.
+            Default: dict(type='BN', requires_grad=True).
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='ReLU', inplace=True).
+        init_cfg (dict, optional): Initialization config dict.
+            Default: None.
+    """
+
+    def __init__(self,
+                 in_channels: int = 3,
+                 channels: int = 32,
+                 ppm_channels: int = 128,
+                 align_corners: bool = False,
+                 norm_cfg: OptConfigType = dict(type='BN', requires_grad=True),
+                 act_cfg: OptConfigType = dict(type='ReLU', inplace=True),
+                 init_cfg: OptConfigType = None):
+        super().__init__(init_cfg)
+
+        self.in_channels = in_channels
+        self.ppm_channels = ppm_channels
+
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+        self.align_corners = align_corners
+
+        # stage 0-2
+        self.stem = self._make_stem_layer(in_channels, channels, num_blocks=2)
+        self.relu = nn.ReLU()
+
+        # low resolution(context) branch
+        self.context_branch_layers = nn.ModuleList()
+        for i in range(3):
+            self.context_branch_layers.append(
+                self._make_layer(
+                    block=BasicBlock if i < 2 else Bottleneck,
+                    inplanes=channels * 2**(i + 1),
+                    planes=channels * 8 if i > 0 else channels * 4,
+                    num_blocks=2 if i < 2 else 1,
+                    stride=2))
+
+        # bilateral fusion
+        self.compression_1 = ConvModule(
+            channels * 4,
+            channels * 2,
+            kernel_size=1,
+            norm_cfg=self.norm_cfg,
+            act_cfg=None)
+        self.down_1 = ConvModule(
+            channels * 2,
+            channels * 4,
+            kernel_size=3,
+            stride=2,
+            padding=1,
+            norm_cfg=self.norm_cfg,
+            act_cfg=None)
+
+        self.compression_2 = ConvModule(
+            channels * 8,
+            channels * 2,
+            kernel_size=1,
+            norm_cfg=self.norm_cfg,
+            act_cfg=None)
+        self.down_2 = nn.Sequential(
+            ConvModule(
+                channels * 2,
+                channels * 4,
+                kernel_size=3,
+                stride=2,
+                padding=1,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg),
+            ConvModule(
+                channels * 4,
+                channels * 8,
+                kernel_size=3,
+                stride=2,
+                padding=1,
+                norm_cfg=self.norm_cfg,
+                act_cfg=None))
+
+        # high resolution(spatial) branch
+        self.spatial_branch_layers = nn.ModuleList()
+        for i in range(3):
+            self.spatial_branch_layers.append(
+                self._make_layer(
+                    block=BasicBlock if i < 2 else Bottleneck,
+                    inplanes=channels * 2,
+                    planes=channels * 2,
+                    num_blocks=2 if i < 2 else 1,
+                ))
+
+        self.spp = DAPPM(
+            channels * 16, ppm_channels, channels * 4, num_scales=5)
+
+    def _make_stem_layer(self, in_channels, channels, num_blocks):
+        layers = [
+            ConvModule(
+                in_channels,
+                channels,
+                kernel_size=3,
+                stride=2,
+                padding=1,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg),
+            ConvModule(
+                channels,
+                channels,
+                kernel_size=3,
+                stride=2,
+                padding=1,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg)
+        ]
+
+        layers.extend([
+            self._make_layer(BasicBlock, channels, channels, num_blocks),
+            nn.ReLU(),
+            self._make_layer(
+                BasicBlock, channels, channels * 2, num_blocks, stride=2),
+            nn.ReLU(),
+        ])
+
+        return nn.Sequential(*layers)
+
+    def _make_layer(self, block, inplanes, planes, num_blocks, stride=1):
+        downsample = None
+        if stride != 1 or inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv2d(
+                    inplanes,
+                    planes * block.expansion,
+                    kernel_size=1,
+                    stride=stride,
+                    bias=False),
+                build_norm_layer(self.norm_cfg, planes * block.expansion)[1])
+
+        layers = [
+            block(
+                in_channels=inplanes,
+                channels=planes,
+                stride=stride,
+                downsample=downsample)
+        ]
+        inplanes = planes * block.expansion
+        for i in range(1, num_blocks):
+            layers.append(
+                block(
+                    in_channels=inplanes,
+                    channels=planes,
+                    stride=1,
+                    norm_cfg=self.norm_cfg,
+                    act_cfg_out=None if i == num_blocks - 1 else self.act_cfg))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        """Forward function."""
+        out_size = (x.shape[-2] // 8, x.shape[-1] // 8)
+
+        # stage 0-2
+        x = self.stem(x)
+
+        # stage3
+        x_c = self.context_branch_layers[0](x)
+        x_s = self.spatial_branch_layers[0](x)
+        comp_c = self.compression_1(self.relu(x_c))
+        x_c += self.down_1(self.relu(x_s))
+        x_s += resize(
+            comp_c,
+            size=out_size,
+            mode='bilinear',
+            align_corners=self.align_corners)
+        if self.training:
+            temp_context = x_s.clone()
+
+        # stage4
+        x_c = self.context_branch_layers[1](self.relu(x_c))
+        x_s = self.spatial_branch_layers[1](self.relu(x_s))
+        comp_c = self.compression_2(self.relu(x_c))
+        x_c += self.down_2(self.relu(x_s))
+        x_s += resize(
+            comp_c,
+            size=out_size,
+            mode='bilinear',
+            align_corners=self.align_corners)
+
+        # stage5
+        x_s = self.spatial_branch_layers[2](self.relu(x_s))
+        x_c = self.context_branch_layers[2](self.relu(x_c))
+        x_c = self.spp(x_c)
+        x_c = resize(
+            x_c,
+            size=out_size,
+            mode='bilinear',
+            align_corners=self.align_corners)
+
+        return (temp_context, x_s + x_c) if self.training else x_s + x_c
diff --git a/mmsegmentation/mmseg/models/backbones/erfnet.py b/mmsegmentation/mmseg/models/backbones/erfnet.py
new file mode 100644
index 0000000..2c5ec67
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/erfnet.py
@@ -0,0 +1,329 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmcv.cnn import build_activation_layer, build_conv_layer, build_norm_layer
+from mmengine.model import BaseModule
+
+from mmseg.registry import MODELS
+from ..utils import resize
+
+
+class DownsamplerBlock(BaseModule):
+    """Downsampler block of ERFNet.
+
+    This module is a little different from basical ConvModule.
+    The features from Conv and MaxPool layers are
+    concatenated before BatchNorm.
+
+    Args:
+        in_channels (int): Number of input channels.
+        out_channels (int): Number of output channels.
+        conv_cfg (dict | None): Config of conv layers.
+            Default: None.
+        norm_cfg (dict | None): Config of norm layers.
+            Default: dict(type='BN').
+        act_cfg (dict): Config of activation layers.
+            Default: dict(type='ReLU').
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN', eps=1e-3),
+                 act_cfg=dict(type='ReLU'),
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+
+        self.conv = build_conv_layer(
+            self.conv_cfg,
+            in_channels,
+            out_channels - in_channels,
+            kernel_size=3,
+            stride=2,
+            padding=1)
+        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
+        self.bn = build_norm_layer(self.norm_cfg, out_channels)[1]
+        self.act = build_activation_layer(self.act_cfg)
+
+    def forward(self, input):
+        conv_out = self.conv(input)
+        pool_out = self.pool(input)
+        pool_out = resize(
+            input=pool_out,
+            size=conv_out.size()[2:],
+            mode='bilinear',
+            align_corners=False)
+        output = torch.cat([conv_out, pool_out], 1)
+        output = self.bn(output)
+        output = self.act(output)
+        return output
+
+
+class NonBottleneck1d(BaseModule):
+    """Non-bottleneck block of ERFNet.
+
+    Args:
+        channels (int): Number of channels in Non-bottleneck block.
+        drop_rate (float): Probability of an element to be zeroed.
+            Default 0.
+        dilation (int): Dilation rate for last two conv layers.
+            Default 1.
+        num_conv_layer (int): Number of 3x1 and 1x3 convolution layers.
+            Default 2.
+        conv_cfg (dict | None): Config of conv layers.
+            Default: None.
+        norm_cfg (dict | None): Config of norm layers.
+            Default: dict(type='BN').
+        act_cfg (dict): Config of activation layers.
+            Default: dict(type='ReLU').
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    """
+
+    def __init__(self,
+                 channels,
+                 drop_rate=0,
+                 dilation=1,
+                 num_conv_layer=2,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN', eps=1e-3),
+                 act_cfg=dict(type='ReLU'),
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+        self.act = build_activation_layer(self.act_cfg)
+
+        self.convs_layers = nn.ModuleList()
+        for conv_layer in range(num_conv_layer):
+            first_conv_padding = (1, 0) if conv_layer == 0 else (dilation, 0)
+            first_conv_dilation = 1 if conv_layer == 0 else (dilation, 1)
+            second_conv_padding = (0, 1) if conv_layer == 0 else (0, dilation)
+            second_conv_dilation = 1 if conv_layer == 0 else (1, dilation)
+
+            self.convs_layers.append(
+                build_conv_layer(
+                    self.conv_cfg,
+                    channels,
+                    channels,
+                    kernel_size=(3, 1),
+                    stride=1,
+                    padding=first_conv_padding,
+                    bias=True,
+                    dilation=first_conv_dilation))
+            self.convs_layers.append(self.act)
+            self.convs_layers.append(
+                build_conv_layer(
+                    self.conv_cfg,
+                    channels,
+                    channels,
+                    kernel_size=(1, 3),
+                    stride=1,
+                    padding=second_conv_padding,
+                    bias=True,
+                    dilation=second_conv_dilation))
+            self.convs_layers.append(
+                build_norm_layer(self.norm_cfg, channels)[1])
+            if conv_layer == 0:
+                self.convs_layers.append(self.act)
+            else:
+                self.convs_layers.append(nn.Dropout(p=drop_rate))
+
+    def forward(self, input):
+        output = input
+        for conv in self.convs_layers:
+            output = conv(output)
+        output = self.act(output + input)
+        return output
+
+
+class UpsamplerBlock(BaseModule):
+    """Upsampler block of ERFNet.
+
+    Args:
+        in_channels (int): Number of input channels.
+        out_channels (int): Number of output channels.
+        conv_cfg (dict | None): Config of conv layers.
+            Default: None.
+        norm_cfg (dict | None): Config of norm layers.
+            Default: dict(type='BN').
+        act_cfg (dict): Config of activation layers.
+            Default: dict(type='ReLU').
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN', eps=1e-3),
+                 act_cfg=dict(type='ReLU'),
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+
+        self.conv = nn.ConvTranspose2d(
+            in_channels=in_channels,
+            out_channels=out_channels,
+            kernel_size=3,
+            stride=2,
+            padding=1,
+            output_padding=1,
+            bias=True)
+        self.bn = build_norm_layer(self.norm_cfg, out_channels)[1]
+        self.act = build_activation_layer(self.act_cfg)
+
+    def forward(self, input):
+        output = self.conv(input)
+        output = self.bn(output)
+        output = self.act(output)
+        return output
+
+
+@MODELS.register_module()
+class ERFNet(BaseModule):
+    """ERFNet backbone.
+
+    This backbone is the implementation of `ERFNet: Efficient Residual
+    Factorized ConvNet for Real-time SemanticSegmentation
+    <https://ieeexplore.ieee.org/document/8063438>`_.
+
+    Args:
+        in_channels (int): The number of channels of input
+            image. Default: 3.
+        enc_downsample_channels (Tuple[int]): Size of channel
+            numbers of various Downsampler block in encoder.
+            Default: (16, 64, 128).
+        enc_stage_non_bottlenecks (Tuple[int]): Number of stages of
+            Non-bottleneck block in encoder.
+            Default: (5, 8).
+        enc_non_bottleneck_dilations (Tuple[int]): Dilation rate of each
+            stage of Non-bottleneck block of encoder.
+            Default: (2, 4, 8, 16).
+        enc_non_bottleneck_channels (Tuple[int]): Size of channel
+            numbers of various Non-bottleneck block in encoder.
+            Default: (64, 128).
+        dec_upsample_channels (Tuple[int]): Size of channel numbers of
+            various Deconvolution block in decoder.
+            Default: (64, 16).
+        dec_stages_non_bottleneck (Tuple[int]): Number of stages of
+            Non-bottleneck block in decoder.
+            Default: (2, 2).
+        dec_non_bottleneck_channels (Tuple[int]): Size of channel
+            numbers of various Non-bottleneck block in decoder.
+            Default: (64, 16).
+        drop_rate (float): Probability of an element to be zeroed.
+            Default 0.1.
+    """
+
+    def __init__(self,
+                 in_channels=3,
+                 enc_downsample_channels=(16, 64, 128),
+                 enc_stage_non_bottlenecks=(5, 8),
+                 enc_non_bottleneck_dilations=(2, 4, 8, 16),
+                 enc_non_bottleneck_channels=(64, 128),
+                 dec_upsample_channels=(64, 16),
+                 dec_stages_non_bottleneck=(2, 2),
+                 dec_non_bottleneck_channels=(64, 16),
+                 dropout_ratio=0.1,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN', requires_grad=True),
+                 act_cfg=dict(type='ReLU'),
+                 init_cfg=None):
+
+        super().__init__(init_cfg=init_cfg)
+        assert len(enc_downsample_channels) \
+               == len(dec_upsample_channels)+1, 'Number of downsample\
+                     block of encoder does not \
+                    match number of upsample block of decoder!'
+        assert len(enc_downsample_channels) \
+               == len(enc_stage_non_bottlenecks)+1, 'Number of \
+                    downsample block of encoder does not match \
+                    number of Non-bottleneck block of encoder!'
+        assert len(enc_downsample_channels) \
+               == len(enc_non_bottleneck_channels)+1, 'Number of \
+                    downsample block of encoder does not match \
+                    number of channels of Non-bottleneck block of encoder!'
+        assert enc_stage_non_bottlenecks[-1] \
+               % len(enc_non_bottleneck_dilations) == 0, 'Number of \
+                    Non-bottleneck block of encoder does not match \
+                    number of Non-bottleneck block of encoder!'
+        assert len(dec_upsample_channels) \
+               == len(dec_stages_non_bottleneck), 'Number of \
+                upsample block of decoder does not match \
+                number of Non-bottleneck block of decoder!'
+        assert len(dec_stages_non_bottleneck) \
+               == len(dec_non_bottleneck_channels), 'Number of \
+                Non-bottleneck block of decoder does not match \
+                number of channels of Non-bottleneck block of decoder!'
+
+        self.in_channels = in_channels
+        self.enc_downsample_channels = enc_downsample_channels
+        self.enc_stage_non_bottlenecks = enc_stage_non_bottlenecks
+        self.enc_non_bottleneck_dilations = enc_non_bottleneck_dilations
+        self.enc_non_bottleneck_channels = enc_non_bottleneck_channels
+        self.dec_upsample_channels = dec_upsample_channels
+        self.dec_stages_non_bottleneck = dec_stages_non_bottleneck
+        self.dec_non_bottleneck_channels = dec_non_bottleneck_channels
+        self.dropout_ratio = dropout_ratio
+
+        self.encoder = nn.ModuleList()
+        self.decoder = nn.ModuleList()
+
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+
+        self.encoder.append(
+            DownsamplerBlock(self.in_channels, enc_downsample_channels[0]))
+
+        for i in range(len(enc_downsample_channels) - 1):
+            self.encoder.append(
+                DownsamplerBlock(enc_downsample_channels[i],
+                                 enc_downsample_channels[i + 1]))
+            # Last part of encoder is some dilated NonBottleneck1d blocks.
+            if i == len(enc_downsample_channels) - 2:
+                iteration_times = int(enc_stage_non_bottlenecks[-1] /
+                                      len(enc_non_bottleneck_dilations))
+                for j in range(iteration_times):
+                    for k in range(len(enc_non_bottleneck_dilations)):
+                        self.encoder.append(
+                            NonBottleneck1d(enc_downsample_channels[-1],
+                                            self.dropout_ratio,
+                                            enc_non_bottleneck_dilations[k]))
+            else:
+                for j in range(enc_stage_non_bottlenecks[i]):
+                    self.encoder.append(
+                        NonBottleneck1d(enc_downsample_channels[i + 1],
+                                        self.dropout_ratio))
+
+        for i in range(len(dec_upsample_channels)):
+            if i == 0:
+                self.decoder.append(
+                    UpsamplerBlock(enc_downsample_channels[-1],
+                                   dec_non_bottleneck_channels[i]))
+            else:
+                self.decoder.append(
+                    UpsamplerBlock(dec_non_bottleneck_channels[i - 1],
+                                   dec_non_bottleneck_channels[i]))
+            for j in range(dec_stages_non_bottleneck[i]):
+                self.decoder.append(
+                    NonBottleneck1d(dec_non_bottleneck_channels[i]))
+
+    def forward(self, x):
+        for enc in self.encoder:
+            x = enc(x)
+        for dec in self.decoder:
+            x = dec(x)
+        return [x]
diff --git a/mmsegmentation/mmseg/models/backbones/fast_scnn.py b/mmsegmentation/mmseg/models/backbones/fast_scnn.py
new file mode 100644
index 0000000..6ff7a31
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/fast_scnn.py
@@ -0,0 +1,408 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule, DepthwiseSeparableConvModule
+from mmengine.model import BaseModule
+
+from mmseg.models.decode_heads.psp_head import PPM
+from mmseg.registry import MODELS
+from ..utils import InvertedResidual, resize
+
+
+class LearningToDownsample(nn.Module):
+    """Learning to downsample module.
+
+    Args:
+        in_channels (int): Number of input channels.
+        dw_channels (tuple[int]): Number of output channels of the first and
+            the second depthwise conv (dwconv) layers.
+        out_channels (int): Number of output channels of the whole
+            'learning to downsample' module.
+        conv_cfg (dict | None): Config of conv layers. Default: None
+        norm_cfg (dict | None): Config of norm layers. Default:
+            dict(type='BN')
+        act_cfg (dict): Config of activation layers. Default:
+            dict(type='ReLU')
+        dw_act_cfg (dict): In DepthwiseSeparableConvModule, activation config
+            of depthwise ConvModule. If it is 'default', it will be the same
+            as `act_cfg`. Default: None.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 dw_channels,
+                 out_channels,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 dw_act_cfg=None):
+        super().__init__()
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+        self.dw_act_cfg = dw_act_cfg
+        dw_channels1 = dw_channels[0]
+        dw_channels2 = dw_channels[1]
+
+        self.conv = ConvModule(
+            in_channels,
+            dw_channels1,
+            3,
+            stride=2,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+        self.dsconv1 = DepthwiseSeparableConvModule(
+            dw_channels1,
+            dw_channels2,
+            kernel_size=3,
+            stride=2,
+            padding=1,
+            norm_cfg=self.norm_cfg,
+            dw_act_cfg=self.dw_act_cfg)
+
+        self.dsconv2 = DepthwiseSeparableConvModule(
+            dw_channels2,
+            out_channels,
+            kernel_size=3,
+            stride=2,
+            padding=1,
+            norm_cfg=self.norm_cfg,
+            dw_act_cfg=self.dw_act_cfg)
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.dsconv1(x)
+        x = self.dsconv2(x)
+        return x
+
+
+class GlobalFeatureExtractor(nn.Module):
+    """Global feature extractor module.
+
+    Args:
+        in_channels (int): Number of input channels of the GFE module.
+            Default: 64
+        block_channels (tuple[int]): Tuple of ints. Each int specifies the
+            number of output channels of each Inverted Residual module.
+            Default: (64, 96, 128)
+        out_channels(int): Number of output channels of the GFE module.
+            Default: 128
+        expand_ratio (int): Adjusts number of channels of the hidden layer
+            in InvertedResidual by this amount.
+            Default: 6
+        num_blocks (tuple[int]): Tuple of ints. Each int specifies the
+            number of times each Inverted Residual module is repeated.
+            The repeated Inverted Residual modules are called a 'group'.
+            Default: (3, 3, 3)
+        strides (tuple[int]): Tuple of ints. Each int specifies
+            the downsampling factor of each 'group'.
+            Default: (2, 2, 1)
+        pool_scales (tuple[int]): Tuple of ints. Each int specifies
+            the parameter required in 'global average pooling' within PPM.
+            Default: (1, 2, 3, 6)
+        conv_cfg (dict | None): Config of conv layers. Default: None
+        norm_cfg (dict | None): Config of norm layers. Default:
+            dict(type='BN')
+        act_cfg (dict): Config of activation layers. Default:
+            dict(type='ReLU')
+        align_corners (bool): align_corners argument of F.interpolate.
+            Default: False
+    """
+
+    def __init__(self,
+                 in_channels=64,
+                 block_channels=(64, 96, 128),
+                 out_channels=128,
+                 expand_ratio=6,
+                 num_blocks=(3, 3, 3),
+                 strides=(2, 2, 1),
+                 pool_scales=(1, 2, 3, 6),
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 align_corners=False):
+        super().__init__()
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+        assert len(block_channels) == len(num_blocks) == 3
+        self.bottleneck1 = self._make_layer(in_channels, block_channels[0],
+                                            num_blocks[0], strides[0],
+                                            expand_ratio)
+        self.bottleneck2 = self._make_layer(block_channels[0],
+                                            block_channels[1], num_blocks[1],
+                                            strides[1], expand_ratio)
+        self.bottleneck3 = self._make_layer(block_channels[1],
+                                            block_channels[2], num_blocks[2],
+                                            strides[2], expand_ratio)
+        self.ppm = PPM(
+            pool_scales,
+            block_channels[2],
+            block_channels[2] // 4,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg,
+            align_corners=align_corners)
+
+        self.out = ConvModule(
+            block_channels[2] * 2,
+            out_channels,
+            3,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+    def _make_layer(self,
+                    in_channels,
+                    out_channels,
+                    blocks,
+                    stride=1,
+                    expand_ratio=6):
+        layers = [
+            InvertedResidual(
+                in_channels,
+                out_channels,
+                stride,
+                expand_ratio,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg)
+        ]
+        for i in range(1, blocks):
+            layers.append(
+                InvertedResidual(
+                    out_channels,
+                    out_channels,
+                    1,
+                    expand_ratio,
+                    norm_cfg=self.norm_cfg,
+                    act_cfg=self.act_cfg))
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        x = self.bottleneck1(x)
+        x = self.bottleneck2(x)
+        x = self.bottleneck3(x)
+        x = torch.cat([x, *self.ppm(x)], dim=1)
+        x = self.out(x)
+        return x
+
+
+class FeatureFusionModule(nn.Module):
+    """Feature fusion module.
+
+    Args:
+        higher_in_channels (int): Number of input channels of the
+            higher-resolution branch.
+        lower_in_channels (int): Number of input channels of the
+            lower-resolution branch.
+        out_channels (int): Number of output channels.
+        conv_cfg (dict | None): Config of conv layers. Default: None
+        norm_cfg (dict | None): Config of norm layers. Default:
+            dict(type='BN')
+        dwconv_act_cfg (dict): Config of activation layers in 3x3 conv.
+            Default: dict(type='ReLU').
+        conv_act_cfg (dict): Config of activation layers in the two 1x1 conv.
+            Default: None.
+        align_corners (bool): align_corners argument of F.interpolate.
+            Default: False.
+    """
+
+    def __init__(self,
+                 higher_in_channels,
+                 lower_in_channels,
+                 out_channels,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 dwconv_act_cfg=dict(type='ReLU'),
+                 conv_act_cfg=None,
+                 align_corners=False):
+        super().__init__()
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.dwconv_act_cfg = dwconv_act_cfg
+        self.conv_act_cfg = conv_act_cfg
+        self.align_corners = align_corners
+        self.dwconv = ConvModule(
+            lower_in_channels,
+            out_channels,
+            3,
+            padding=1,
+            groups=out_channels,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.dwconv_act_cfg)
+        self.conv_lower_res = ConvModule(
+            out_channels,
+            out_channels,
+            1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.conv_act_cfg)
+
+        self.conv_higher_res = ConvModule(
+            higher_in_channels,
+            out_channels,
+            1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.conv_act_cfg)
+
+        self.relu = nn.ReLU(True)
+
+    def forward(self, higher_res_feature, lower_res_feature):
+        lower_res_feature = resize(
+            lower_res_feature,
+            size=higher_res_feature.size()[2:],
+            mode='bilinear',
+            align_corners=self.align_corners)
+        lower_res_feature = self.dwconv(lower_res_feature)
+        lower_res_feature = self.conv_lower_res(lower_res_feature)
+
+        higher_res_feature = self.conv_higher_res(higher_res_feature)
+        out = higher_res_feature + lower_res_feature
+        return self.relu(out)
+
+
+@MODELS.register_module()
+class FastSCNN(BaseModule):
+    """Fast-SCNN Backbone.
+
+    This backbone is the implementation of `Fast-SCNN: Fast Semantic
+    Segmentation Network <https://arxiv.org/abs/1902.04502>`_.
+
+    Args:
+        in_channels (int): Number of input image channels. Default: 3.
+        downsample_dw_channels (tuple[int]): Number of output channels after
+            the first conv layer & the second conv layer in
+            Learning-To-Downsample (LTD) module.
+            Default: (32, 48).
+        global_in_channels (int): Number of input channels of
+            Global Feature Extractor(GFE).
+            Equal to number of output channels of LTD.
+            Default: 64.
+        global_block_channels (tuple[int]): Tuple of integers that describe
+            the output channels for each of the MobileNet-v2 bottleneck
+            residual blocks in GFE.
+            Default: (64, 96, 128).
+        global_block_strides (tuple[int]): Tuple of integers
+            that describe the strides (downsampling factors) for each of the
+            MobileNet-v2 bottleneck residual blocks in GFE.
+            Default: (2, 2, 1).
+        global_out_channels (int): Number of output channels of GFE.
+            Default: 128.
+        higher_in_channels (int): Number of input channels of the higher
+            resolution branch in FFM.
+            Equal to global_in_channels.
+            Default: 64.
+        lower_in_channels (int): Number of input channels of  the lower
+            resolution branch in FFM.
+            Equal to global_out_channels.
+            Default: 128.
+        fusion_out_channels (int): Number of output channels of FFM.
+            Default: 128.
+        out_indices (tuple): Tuple of indices of list
+            [higher_res_features, lower_res_features, fusion_output].
+            Often set to (0,1,2) to enable aux. heads.
+            Default: (0, 1, 2).
+        conv_cfg (dict | None): Config of conv layers. Default: None
+        norm_cfg (dict | None): Config of norm layers. Default:
+            dict(type='BN')
+        act_cfg (dict): Config of activation layers. Default:
+            dict(type='ReLU')
+        align_corners (bool): align_corners argument of F.interpolate.
+            Default: False
+        dw_act_cfg (dict): In DepthwiseSeparableConvModule, activation config
+            of depthwise ConvModule. If it is 'default', it will be the same
+            as `act_cfg`. Default: None.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None
+    """
+
+    def __init__(self,
+                 in_channels=3,
+                 downsample_dw_channels=(32, 48),
+                 global_in_channels=64,
+                 global_block_channels=(64, 96, 128),
+                 global_block_strides=(2, 2, 1),
+                 global_out_channels=128,
+                 higher_in_channels=64,
+                 lower_in_channels=128,
+                 fusion_out_channels=128,
+                 out_indices=(0, 1, 2),
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 align_corners=False,
+                 dw_act_cfg=None,
+                 init_cfg=None):
+
+        super().__init__(init_cfg)
+
+        if init_cfg is None:
+            self.init_cfg = [
+                dict(type='Kaiming', layer='Conv2d'),
+                dict(
+                    type='Constant', val=1, layer=['_BatchNorm', 'GroupNorm'])
+            ]
+
+        if global_in_channels != higher_in_channels:
+            raise AssertionError('Global Input Channels must be the same \
+                                 with Higher Input Channels!')
+        elif global_out_channels != lower_in_channels:
+            raise AssertionError('Global Output Channels must be the same \
+                                with Lower Input Channels!')
+
+        self.in_channels = in_channels
+        self.downsample_dw_channels1 = downsample_dw_channels[0]
+        self.downsample_dw_channels2 = downsample_dw_channels[1]
+        self.global_in_channels = global_in_channels
+        self.global_block_channels = global_block_channels
+        self.global_block_strides = global_block_strides
+        self.global_out_channels = global_out_channels
+        self.higher_in_channels = higher_in_channels
+        self.lower_in_channels = lower_in_channels
+        self.fusion_out_channels = fusion_out_channels
+        self.out_indices = out_indices
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+        self.align_corners = align_corners
+        self.learning_to_downsample = LearningToDownsample(
+            in_channels,
+            downsample_dw_channels,
+            global_in_channels,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg,
+            dw_act_cfg=dw_act_cfg)
+        self.global_feature_extractor = GlobalFeatureExtractor(
+            global_in_channels,
+            global_block_channels,
+            global_out_channels,
+            strides=self.global_block_strides,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg,
+            align_corners=self.align_corners)
+        self.feature_fusion = FeatureFusionModule(
+            higher_in_channels,
+            lower_in_channels,
+            fusion_out_channels,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            dwconv_act_cfg=self.act_cfg,
+            align_corners=self.align_corners)
+
+    def forward(self, x):
+        higher_res_features = self.learning_to_downsample(x)
+        lower_res_features = self.global_feature_extractor(higher_res_features)
+        fusion_output = self.feature_fusion(higher_res_features,
+                                            lower_res_features)
+
+        outs = [higher_res_features, lower_res_features, fusion_output]
+        outs = [outs[i] for i in self.out_indices]
+        return tuple(outs)
diff --git a/mmsegmentation/mmseg/models/backbones/hrnet.py b/mmsegmentation/mmseg/models/backbones/hrnet.py
new file mode 100644
index 0000000..2da755e
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/hrnet.py
@@ -0,0 +1,642 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+import torch.nn as nn
+from mmcv.cnn import build_conv_layer, build_norm_layer
+from mmengine.model import BaseModule, ModuleList, Sequential
+from mmengine.utils.dl_utils.parrots_wrapper import _BatchNorm
+
+from mmseg.registry import MODELS
+from ..utils import Upsample, resize
+from .resnet import BasicBlock, Bottleneck
+
+
+class HRModule(BaseModule):
+    """High-Resolution Module for HRNet.
+
+    In this module, every branch has 4 BasicBlocks/Bottlenecks. Fusion/Exchange
+    is in this module.
+    """
+
+    def __init__(self,
+                 num_branches,
+                 blocks,
+                 num_blocks,
+                 in_channels,
+                 num_channels,
+                 multiscale_output=True,
+                 with_cp=False,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN', requires_grad=True),
+                 block_init_cfg=None,
+                 init_cfg=None):
+        super().__init__(init_cfg)
+        self.block_init_cfg = block_init_cfg
+        self._check_branches(num_branches, num_blocks, in_channels,
+                             num_channels)
+
+        self.in_channels = in_channels
+        self.num_branches = num_branches
+
+        self.multiscale_output = multiscale_output
+        self.norm_cfg = norm_cfg
+        self.conv_cfg = conv_cfg
+        self.with_cp = with_cp
+        self.branches = self._make_branches(num_branches, blocks, num_blocks,
+                                            num_channels)
+        self.fuse_layers = self._make_fuse_layers()
+        self.relu = nn.ReLU(inplace=False)
+
+    def _check_branches(self, num_branches, num_blocks, in_channels,
+                        num_channels):
+        """Check branches configuration."""
+        if num_branches != len(num_blocks):
+            error_msg = f'NUM_BRANCHES({num_branches}) <> NUM_BLOCKS(' \
+                        f'{len(num_blocks)})'
+            raise ValueError(error_msg)
+
+        if num_branches != len(num_channels):
+            error_msg = f'NUM_BRANCHES({num_branches}) <> NUM_CHANNELS(' \
+                        f'{len(num_channels)})'
+            raise ValueError(error_msg)
+
+        if num_branches != len(in_channels):
+            error_msg = f'NUM_BRANCHES({num_branches}) <> NUM_INCHANNELS(' \
+                        f'{len(in_channels)})'
+            raise ValueError(error_msg)
+
+    def _make_one_branch(self,
+                         branch_index,
+                         block,
+                         num_blocks,
+                         num_channels,
+                         stride=1):
+        """Build one branch."""
+        downsample = None
+        if stride != 1 or \
+                self.in_channels[branch_index] != \
+                num_channels[branch_index] * block.expansion:
+            downsample = nn.Sequential(
+                build_conv_layer(
+                    self.conv_cfg,
+                    self.in_channels[branch_index],
+                    num_channels[branch_index] * block.expansion,
+                    kernel_size=1,
+                    stride=stride,
+                    bias=False),
+                build_norm_layer(self.norm_cfg, num_channels[branch_index] *
+                                 block.expansion)[1])
+
+        layers = []
+        layers.append(
+            block(
+                self.in_channels[branch_index],
+                num_channels[branch_index],
+                stride,
+                downsample=downsample,
+                with_cp=self.with_cp,
+                norm_cfg=self.norm_cfg,
+                conv_cfg=self.conv_cfg,
+                init_cfg=self.block_init_cfg))
+        self.in_channels[branch_index] = \
+            num_channels[branch_index] * block.expansion
+        for i in range(1, num_blocks[branch_index]):
+            layers.append(
+                block(
+                    self.in_channels[branch_index],
+                    num_channels[branch_index],
+                    with_cp=self.with_cp,
+                    norm_cfg=self.norm_cfg,
+                    conv_cfg=self.conv_cfg,
+                    init_cfg=self.block_init_cfg))
+
+        return Sequential(*layers)
+
+    def _make_branches(self, num_branches, block, num_blocks, num_channels):
+        """Build multiple branch."""
+        branches = []
+
+        for i in range(num_branches):
+            branches.append(
+                self._make_one_branch(i, block, num_blocks, num_channels))
+
+        return ModuleList(branches)
+
+    def _make_fuse_layers(self):
+        """Build fuse layer."""
+        if self.num_branches == 1:
+            return None
+
+        num_branches = self.num_branches
+        in_channels = self.in_channels
+        fuse_layers = []
+        num_out_branches = num_branches if self.multiscale_output else 1
+        for i in range(num_out_branches):
+            fuse_layer = []
+            for j in range(num_branches):
+                if j > i:
+                    fuse_layer.append(
+                        nn.Sequential(
+                            build_conv_layer(
+                                self.conv_cfg,
+                                in_channels[j],
+                                in_channels[i],
+                                kernel_size=1,
+                                stride=1,
+                                padding=0,
+                                bias=False),
+                            build_norm_layer(self.norm_cfg, in_channels[i])[1],
+                            # we set align_corners=False for HRNet
+                            Upsample(
+                                scale_factor=2**(j - i),
+                                mode='bilinear',
+                                align_corners=False)))
+                elif j == i:
+                    fuse_layer.append(None)
+                else:
+                    conv_downsamples = []
+                    for k in range(i - j):
+                        if k == i - j - 1:
+                            conv_downsamples.append(
+                                nn.Sequential(
+                                    build_conv_layer(
+                                        self.conv_cfg,
+                                        in_channels[j],
+                                        in_channels[i],
+                                        kernel_size=3,
+                                        stride=2,
+                                        padding=1,
+                                        bias=False),
+                                    build_norm_layer(self.norm_cfg,
+                                                     in_channels[i])[1]))
+                        else:
+                            conv_downsamples.append(
+                                nn.Sequential(
+                                    build_conv_layer(
+                                        self.conv_cfg,
+                                        in_channels[j],
+                                        in_channels[j],
+                                        kernel_size=3,
+                                        stride=2,
+                                        padding=1,
+                                        bias=False),
+                                    build_norm_layer(self.norm_cfg,
+                                                     in_channels[j])[1],
+                                    nn.ReLU(inplace=False)))
+                    fuse_layer.append(nn.Sequential(*conv_downsamples))
+            fuse_layers.append(nn.ModuleList(fuse_layer))
+
+        return nn.ModuleList(fuse_layers)
+
+    def forward(self, x):
+        """Forward function."""
+        if self.num_branches == 1:
+            return [self.branches[0](x[0])]
+
+        for i in range(self.num_branches):
+            x[i] = self.branches[i](x[i])
+
+        x_fuse = []
+        for i in range(len(self.fuse_layers)):
+            y = 0
+            for j in range(self.num_branches):
+                if i == j:
+                    y += x[j]
+                elif j > i:
+                    y = y + resize(
+                        self.fuse_layers[i][j](x[j]),
+                        size=x[i].shape[2:],
+                        mode='bilinear',
+                        align_corners=False)
+                else:
+                    y += self.fuse_layers[i][j](x[j])
+            x_fuse.append(self.relu(y))
+        return x_fuse
+
+
+@MODELS.register_module()
+class HRNet(BaseModule):
+    """HRNet backbone.
+
+    This backbone is the implementation of `High-Resolution Representations
+    for Labeling Pixels and Regions <https://arxiv.org/abs/1904.04514>`_.
+
+    Args:
+        extra (dict): Detailed configuration for each stage of HRNet.
+            There must be 4 stages, the configuration for each stage must have
+            5 keys:
+
+                - num_modules (int): The number of HRModule in this stage.
+                - num_branches (int): The number of branches in the HRModule.
+                - block (str): The type of convolution block.
+                - num_blocks (tuple): The number of blocks in each branch.
+                    The length must be equal to num_branches.
+                - num_channels (tuple): The number of channels in each branch.
+                    The length must be equal to num_branches.
+        in_channels (int): Number of input image channels. Normally 3.
+        conv_cfg (dict): Dictionary to construct and config conv layer.
+            Default: None.
+        norm_cfg (dict): Dictionary to construct and config norm layer.
+            Use `BN` by default.
+        norm_eval (bool): Whether to set norm layers to eval mode, namely,
+            freeze running stats (mean and var). Note: Effect on Batch Norm
+            and its variants only. Default: False.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed. Default: False.
+        frozen_stages (int): Stages to be frozen (stop grad and set eval mode).
+            -1 means not freezing any parameters. Default: -1.
+        zero_init_residual (bool): Whether to use zero init for last norm layer
+            in resblocks to let them behave as identity. Default: False.
+        multiscale_output (bool): Whether to output multi-level features
+            produced by multiple branches. If False, only the first level
+            feature will be output. Default: True.
+        pretrained (str, optional): Model pretrained path. Default: None.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+
+    Example:
+        >>> from mmseg.models import HRNet
+        >>> import torch
+        >>> extra = dict(
+        >>>     stage1=dict(
+        >>>         num_modules=1,
+        >>>         num_branches=1,
+        >>>         block='BOTTLENECK',
+        >>>         num_blocks=(4, ),
+        >>>         num_channels=(64, )),
+        >>>     stage2=dict(
+        >>>         num_modules=1,
+        >>>         num_branches=2,
+        >>>         block='BASIC',
+        >>>         num_blocks=(4, 4),
+        >>>         num_channels=(32, 64)),
+        >>>     stage3=dict(
+        >>>         num_modules=4,
+        >>>         num_branches=3,
+        >>>         block='BASIC',
+        >>>         num_blocks=(4, 4, 4),
+        >>>         num_channels=(32, 64, 128)),
+        >>>     stage4=dict(
+        >>>         num_modules=3,
+        >>>         num_branches=4,
+        >>>         block='BASIC',
+        >>>         num_blocks=(4, 4, 4, 4),
+        >>>         num_channels=(32, 64, 128, 256)))
+        >>> self = HRNet(extra, in_channels=1)
+        >>> self.eval()
+        >>> inputs = torch.rand(1, 1, 32, 32)
+        >>> level_outputs = self.forward(inputs)
+        >>> for level_out in level_outputs:
+        ...     print(tuple(level_out.shape))
+        (1, 32, 8, 8)
+        (1, 64, 4, 4)
+        (1, 128, 2, 2)
+        (1, 256, 1, 1)
+    """
+
+    blocks_dict = {'BASIC': BasicBlock, 'BOTTLENECK': Bottleneck}
+
+    def __init__(self,
+                 extra,
+                 in_channels=3,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN', requires_grad=True),
+                 norm_eval=False,
+                 with_cp=False,
+                 frozen_stages=-1,
+                 zero_init_residual=False,
+                 multiscale_output=True,
+                 pretrained=None,
+                 init_cfg=None):
+        super().__init__(init_cfg)
+
+        self.pretrained = pretrained
+        self.zero_init_residual = zero_init_residual
+        assert not (init_cfg and pretrained), \
+            'init_cfg and pretrained cannot be setting at the same time'
+        if isinstance(pretrained, str):
+            warnings.warn('DeprecationWarning: pretrained is deprecated, '
+                          'please use "init_cfg" instead')
+            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
+        elif pretrained is None:
+            if init_cfg is None:
+                self.init_cfg = [
+                    dict(type='Kaiming', layer='Conv2d'),
+                    dict(
+                        type='Constant',
+                        val=1,
+                        layer=['_BatchNorm', 'GroupNorm'])
+                ]
+        else:
+            raise TypeError('pretrained must be a str or None')
+
+        # Assert configurations of 4 stages are in extra
+        assert 'stage1' in extra and 'stage2' in extra \
+               and 'stage3' in extra and 'stage4' in extra
+        # Assert whether the length of `num_blocks` and `num_channels` are
+        # equal to `num_branches`
+        for i in range(4):
+            cfg = extra[f'stage{i + 1}']
+            assert len(cfg['num_blocks']) == cfg['num_branches'] and \
+                   len(cfg['num_channels']) == cfg['num_branches']
+
+        self.extra = extra
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.norm_eval = norm_eval
+        self.with_cp = with_cp
+        self.frozen_stages = frozen_stages
+
+        # stem net
+        self.norm1_name, norm1 = build_norm_layer(self.norm_cfg, 64, postfix=1)
+        self.norm2_name, norm2 = build_norm_layer(self.norm_cfg, 64, postfix=2)
+
+        self.conv1 = build_conv_layer(
+            self.conv_cfg,
+            in_channels,
+            64,
+            kernel_size=3,
+            stride=2,
+            padding=1,
+            bias=False)
+
+        self.add_module(self.norm1_name, norm1)
+        self.conv2 = build_conv_layer(
+            self.conv_cfg,
+            64,
+            64,
+            kernel_size=3,
+            stride=2,
+            padding=1,
+            bias=False)
+
+        self.add_module(self.norm2_name, norm2)
+        self.relu = nn.ReLU(inplace=True)
+
+        # stage 1
+        self.stage1_cfg = self.extra['stage1']
+        num_channels = self.stage1_cfg['num_channels'][0]
+        block_type = self.stage1_cfg['block']
+        num_blocks = self.stage1_cfg['num_blocks'][0]
+
+        block = self.blocks_dict[block_type]
+        stage1_out_channels = num_channels * block.expansion
+        self.layer1 = self._make_layer(block, 64, num_channels, num_blocks)
+
+        # stage 2
+        self.stage2_cfg = self.extra['stage2']
+        num_channels = self.stage2_cfg['num_channels']
+        block_type = self.stage2_cfg['block']
+
+        block = self.blocks_dict[block_type]
+        num_channels = [channel * block.expansion for channel in num_channels]
+        self.transition1 = self._make_transition_layer([stage1_out_channels],
+                                                       num_channels)
+        self.stage2, pre_stage_channels = self._make_stage(
+            self.stage2_cfg, num_channels)
+
+        # stage 3
+        self.stage3_cfg = self.extra['stage3']
+        num_channels = self.stage3_cfg['num_channels']
+        block_type = self.stage3_cfg['block']
+
+        block = self.blocks_dict[block_type]
+        num_channels = [channel * block.expansion for channel in num_channels]
+        self.transition2 = self._make_transition_layer(pre_stage_channels,
+                                                       num_channels)
+        self.stage3, pre_stage_channels = self._make_stage(
+            self.stage3_cfg, num_channels)
+
+        # stage 4
+        self.stage4_cfg = self.extra['stage4']
+        num_channels = self.stage4_cfg['num_channels']
+        block_type = self.stage4_cfg['block']
+
+        block = self.blocks_dict[block_type]
+        num_channels = [channel * block.expansion for channel in num_channels]
+        self.transition3 = self._make_transition_layer(pre_stage_channels,
+                                                       num_channels)
+        self.stage4, pre_stage_channels = self._make_stage(
+            self.stage4_cfg, num_channels, multiscale_output=multiscale_output)
+
+        self._freeze_stages()
+
+    @property
+    def norm1(self):
+        """nn.Module: the normalization layer named "norm1" """
+        return getattr(self, self.norm1_name)
+
+    @property
+    def norm2(self):
+        """nn.Module: the normalization layer named "norm2" """
+        return getattr(self, self.norm2_name)
+
+    def _make_transition_layer(self, num_channels_pre_layer,
+                               num_channels_cur_layer):
+        """Make transition layer."""
+        num_branches_cur = len(num_channels_cur_layer)
+        num_branches_pre = len(num_channels_pre_layer)
+
+        transition_layers = []
+        for i in range(num_branches_cur):
+            if i < num_branches_pre:
+                if num_channels_cur_layer[i] != num_channels_pre_layer[i]:
+                    transition_layers.append(
+                        nn.Sequential(
+                            build_conv_layer(
+                                self.conv_cfg,
+                                num_channels_pre_layer[i],
+                                num_channels_cur_layer[i],
+                                kernel_size=3,
+                                stride=1,
+                                padding=1,
+                                bias=False),
+                            build_norm_layer(self.norm_cfg,
+                                             num_channels_cur_layer[i])[1],
+                            nn.ReLU(inplace=True)))
+                else:
+                    transition_layers.append(None)
+            else:
+                conv_downsamples = []
+                for j in range(i + 1 - num_branches_pre):
+                    in_channels = num_channels_pre_layer[-1]
+                    out_channels = num_channels_cur_layer[i] \
+                        if j == i - num_branches_pre else in_channels
+                    conv_downsamples.append(
+                        nn.Sequential(
+                            build_conv_layer(
+                                self.conv_cfg,
+                                in_channels,
+                                out_channels,
+                                kernel_size=3,
+                                stride=2,
+                                padding=1,
+                                bias=False),
+                            build_norm_layer(self.norm_cfg, out_channels)[1],
+                            nn.ReLU(inplace=True)))
+                transition_layers.append(nn.Sequential(*conv_downsamples))
+
+        return nn.ModuleList(transition_layers)
+
+    def _make_layer(self, block, inplanes, planes, blocks, stride=1):
+        """Make each layer."""
+        downsample = None
+        if stride != 1 or inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                build_conv_layer(
+                    self.conv_cfg,
+                    inplanes,
+                    planes * block.expansion,
+                    kernel_size=1,
+                    stride=stride,
+                    bias=False),
+                build_norm_layer(self.norm_cfg, planes * block.expansion)[1])
+
+        layers = []
+        block_init_cfg = None
+        if self.pretrained is None and not hasattr(
+                self, 'init_cfg') and self.zero_init_residual:
+            if block is BasicBlock:
+                block_init_cfg = dict(
+                    type='Constant', val=0, override=dict(name='norm2'))
+            elif block is Bottleneck:
+                block_init_cfg = dict(
+                    type='Constant', val=0, override=dict(name='norm3'))
+
+        layers.append(
+            block(
+                inplanes,
+                planes,
+                stride,
+                downsample=downsample,
+                with_cp=self.with_cp,
+                norm_cfg=self.norm_cfg,
+                conv_cfg=self.conv_cfg,
+                init_cfg=block_init_cfg))
+        inplanes = planes * block.expansion
+        for i in range(1, blocks):
+            layers.append(
+                block(
+                    inplanes,
+                    planes,
+                    with_cp=self.with_cp,
+                    norm_cfg=self.norm_cfg,
+                    conv_cfg=self.conv_cfg,
+                    init_cfg=block_init_cfg))
+
+        return Sequential(*layers)
+
+    def _make_stage(self, layer_config, in_channels, multiscale_output=True):
+        """Make each stage."""
+        num_modules = layer_config['num_modules']
+        num_branches = layer_config['num_branches']
+        num_blocks = layer_config['num_blocks']
+        num_channels = layer_config['num_channels']
+        block = self.blocks_dict[layer_config['block']]
+
+        hr_modules = []
+        block_init_cfg = None
+        if self.pretrained is None and not hasattr(
+                self, 'init_cfg') and self.zero_init_residual:
+            if block is BasicBlock:
+                block_init_cfg = dict(
+                    type='Constant', val=0, override=dict(name='norm2'))
+            elif block is Bottleneck:
+                block_init_cfg = dict(
+                    type='Constant', val=0, override=dict(name='norm3'))
+
+        for i in range(num_modules):
+            # multi_scale_output is only used for the last module
+            if not multiscale_output and i == num_modules - 1:
+                reset_multiscale_output = False
+            else:
+                reset_multiscale_output = True
+
+            hr_modules.append(
+                HRModule(
+                    num_branches,
+                    block,
+                    num_blocks,
+                    in_channels,
+                    num_channels,
+                    reset_multiscale_output,
+                    with_cp=self.with_cp,
+                    norm_cfg=self.norm_cfg,
+                    conv_cfg=self.conv_cfg,
+                    block_init_cfg=block_init_cfg))
+
+        return Sequential(*hr_modules), in_channels
+
+    def _freeze_stages(self):
+        """Freeze stages param and norm stats."""
+        if self.frozen_stages >= 0:
+
+            self.norm1.eval()
+            self.norm2.eval()
+            for m in [self.conv1, self.norm1, self.conv2, self.norm2]:
+                for param in m.parameters():
+                    param.requires_grad = False
+
+        for i in range(1, self.frozen_stages + 1):
+            if i == 1:
+                m = getattr(self, f'layer{i}')
+                t = getattr(self, f'transition{i}')
+            elif i == 4:
+                m = getattr(self, f'stage{i}')
+            else:
+                m = getattr(self, f'stage{i}')
+                t = getattr(self, f'transition{i}')
+            m.eval()
+            for param in m.parameters():
+                param.requires_grad = False
+            t.eval()
+            for param in t.parameters():
+                param.requires_grad = False
+
+    def forward(self, x):
+        """Forward function."""
+
+        x = self.conv1(x)
+        x = self.norm1(x)
+        x = self.relu(x)
+        x = self.conv2(x)
+        x = self.norm2(x)
+        x = self.relu(x)
+        x = self.layer1(x)
+
+        x_list = []
+        for i in range(self.stage2_cfg['num_branches']):
+            if self.transition1[i] is not None:
+                x_list.append(self.transition1[i](x))
+            else:
+                x_list.append(x)
+        y_list = self.stage2(x_list)
+
+        x_list = []
+        for i in range(self.stage3_cfg['num_branches']):
+            if self.transition2[i] is not None:
+                x_list.append(self.transition2[i](y_list[-1]))
+            else:
+                x_list.append(y_list[i])
+        y_list = self.stage3(x_list)
+
+        x_list = []
+        for i in range(self.stage4_cfg['num_branches']):
+            if self.transition3[i] is not None:
+                x_list.append(self.transition3[i](y_list[-1]))
+            else:
+                x_list.append(y_list[i])
+        y_list = self.stage4(x_list)
+
+        return y_list
+
+    def train(self, mode=True):
+        """Convert the model into training mode will keeping the normalization
+        layer freezed."""
+        super().train(mode)
+        self._freeze_stages()
+        if mode and self.norm_eval:
+            for m in self.modules():
+                # trick: eval have effect on BatchNorm only
+                if isinstance(m, _BatchNorm):
+                    m.eval()
diff --git a/mmsegmentation/mmseg/models/backbones/icnet.py b/mmsegmentation/mmseg/models/backbones/icnet.py
new file mode 100644
index 0000000..8ff3448
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/icnet.py
@@ -0,0 +1,166 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule
+
+from mmseg.registry import MODELS
+from ..decode_heads.psp_head import PPM
+from ..utils import resize
+
+
+@MODELS.register_module()
+class ICNet(BaseModule):
+    """ICNet for Real-Time Semantic Segmentation on High-Resolution Images.
+
+    This backbone is the implementation of
+    `ICNet <https://arxiv.org/abs/1704.08545>`_.
+
+    Args:
+        backbone_cfg (dict): Config dict to build backbone. Usually it is
+            ResNet but it can also be other backbones.
+        in_channels (int): The number of input image channels. Default: 3.
+        layer_channels (Sequence[int]): The numbers of feature channels at
+            layer 2 and layer 4 in ResNet. It can also be other backbones.
+            Default: (512, 2048).
+        light_branch_middle_channels (int): The number of channels of the
+            middle layer in light branch. Default: 32.
+        psp_out_channels (int): The number of channels of the output of PSP
+            module. Default: 512.
+        out_channels (Sequence[int]): The numbers of output feature channels
+            at each branches. Default: (64, 256, 256).
+        pool_scales (tuple[int]): Pooling scales used in Pooling Pyramid
+            Module. Default: (1, 2, 3, 6).
+        conv_cfg (dict): Dictionary to construct and config conv layer.
+            Default: None.
+        norm_cfg (dict): Dictionary to construct and config norm layer.
+            Default: dict(type='BN').
+        act_cfg (dict): Dictionary to construct and config act layer.
+            Default: dict(type='ReLU').
+        align_corners (bool): align_corners argument of F.interpolate.
+            Default: False.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    """
+
+    def __init__(self,
+                 backbone_cfg,
+                 in_channels=3,
+                 layer_channels=(512, 2048),
+                 light_branch_middle_channels=32,
+                 psp_out_channels=512,
+                 out_channels=(64, 256, 256),
+                 pool_scales=(1, 2, 3, 6),
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN', requires_grad=True),
+                 act_cfg=dict(type='ReLU'),
+                 align_corners=False,
+                 init_cfg=None):
+        if backbone_cfg is None:
+            raise TypeError('backbone_cfg must be passed from config file!')
+        if init_cfg is None:
+            init_cfg = [
+                dict(type='Kaiming', mode='fan_out', layer='Conv2d'),
+                dict(type='Constant', val=1, layer='_BatchNorm'),
+                dict(type='Normal', mean=0.01, layer='Linear')
+            ]
+        super().__init__(init_cfg=init_cfg)
+        self.align_corners = align_corners
+        self.backbone = MODELS.build(backbone_cfg)
+
+        # Note: Default `ceil_mode` is false in nn.MaxPool2d, set
+        # `ceil_mode=True` to keep information in the corner of feature map.
+        self.backbone.maxpool = nn.MaxPool2d(
+            kernel_size=3, stride=2, padding=1, ceil_mode=True)
+
+        self.psp_modules = PPM(
+            pool_scales=pool_scales,
+            in_channels=layer_channels[1],
+            channels=psp_out_channels,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg,
+            align_corners=align_corners)
+
+        self.psp_bottleneck = ConvModule(
+            layer_channels[1] + len(pool_scales) * psp_out_channels,
+            psp_out_channels,
+            3,
+            padding=1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+
+        self.conv_sub1 = nn.Sequential(
+            ConvModule(
+                in_channels=in_channels,
+                out_channels=light_branch_middle_channels,
+                kernel_size=3,
+                stride=2,
+                padding=1,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg),
+            ConvModule(
+                in_channels=light_branch_middle_channels,
+                out_channels=light_branch_middle_channels,
+                kernel_size=3,
+                stride=2,
+                padding=1,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg),
+            ConvModule(
+                in_channels=light_branch_middle_channels,
+                out_channels=out_channels[0],
+                kernel_size=3,
+                stride=2,
+                padding=1,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg))
+
+        self.conv_sub2 = ConvModule(
+            layer_channels[0],
+            out_channels[1],
+            1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg)
+
+        self.conv_sub4 = ConvModule(
+            psp_out_channels,
+            out_channels[2],
+            1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg)
+
+    def forward(self, x):
+        output = []
+
+        # sub 1
+        output.append(self.conv_sub1(x))
+
+        # sub 2
+        x = resize(
+            x,
+            scale_factor=0.5,
+            mode='bilinear',
+            align_corners=self.align_corners)
+        x = self.backbone.stem(x)
+        x = self.backbone.maxpool(x)
+        x = self.backbone.layer1(x)
+        x = self.backbone.layer2(x)
+        output.append(self.conv_sub2(x))
+
+        # sub 4
+        x = resize(
+            x,
+            scale_factor=0.5,
+            mode='bilinear',
+            align_corners=self.align_corners)
+        x = self.backbone.layer3(x)
+        x = self.backbone.layer4(x)
+        psp_outs = self.psp_modules(x) + [x]
+        psp_outs = torch.cat(psp_outs, dim=1)
+        x = self.psp_bottleneck(psp_outs)
+
+        output.append(self.conv_sub4(x))
+
+        return output
diff --git a/mmsegmentation/mmseg/models/backbones/mae.py b/mmsegmentation/mmseg/models/backbones/mae.py
new file mode 100644
index 0000000..a1f243f
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/mae.py
@@ -0,0 +1,260 @@
+# Copyright (c) OpenMMLab. All rights reserved.import math
+import math
+
+import torch
+import torch.nn as nn
+from mmengine.model import ModuleList
+from mmengine.model.weight_init import (constant_init, kaiming_init,
+                                        trunc_normal_)
+from mmengine.runner.checkpoint import _load_checkpoint
+from torch.nn.modules.batchnorm import _BatchNorm
+
+from mmseg.registry import MODELS
+from .beit import BEiT, BEiTAttention, BEiTTransformerEncoderLayer
+
+
+class MAEAttention(BEiTAttention):
+    """Multi-head self-attention with relative position bias used in MAE.
+
+    This module is different from ``BEiTAttention`` by initializing the
+    relative bias table with zeros.
+    """
+
+    def init_weights(self):
+        """Initialize relative position bias with zeros."""
+
+        # As MAE initializes relative position bias as zeros and this class
+        # inherited from BEiT which initializes relative position bias
+        # with `trunc_normal`, `init_weights` here does
+        # nothing and just passes directly
+
+        pass
+
+
+class MAETransformerEncoderLayer(BEiTTransformerEncoderLayer):
+    """Implements one encoder layer in Vision Transformer.
+
+    This module is different from ``BEiTTransformerEncoderLayer`` by replacing
+    ``BEiTAttention`` with ``MAEAttention``.
+    """
+
+    def build_attn(self, attn_cfg):
+        self.attn = MAEAttention(**attn_cfg)
+
+
+@MODELS.register_module()
+class MAE(BEiT):
+    """VisionTransformer with support for patch.
+
+    Args:
+        img_size (int | tuple): Input image size. Default: 224.
+        patch_size (int): The patch size. Default: 16.
+        in_channels (int): Number of input channels. Default: 3.
+        embed_dims (int): embedding dimension. Default: 768.
+        num_layers (int): depth of transformer. Default: 12.
+        num_heads (int): number of attention heads. Default: 12.
+        mlp_ratio (int): ratio of mlp hidden dim to embedding dim.
+            Default: 4.
+        out_indices (list | tuple | int): Output from which stages.
+            Default: -1.
+        attn_drop_rate (float): The drop out rate for attention layer.
+            Default 0.0
+        drop_path_rate (float): stochastic depth rate. Default 0.0.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='LN')
+        act_cfg (dict): The activation config for FFNs.
+            Default: dict(type='GELU').
+        patch_norm (bool): Whether to add a norm in PatchEmbed Block.
+            Default: False.
+        final_norm (bool): Whether to add a additional layer to normalize
+            final feature map. Default: False.
+        num_fcs (int): The number of fully-connected layers for FFNs.
+            Default: 2.
+        norm_eval (bool): Whether to set norm layers to eval mode, namely,
+            freeze running stats (mean and var). Note: Effect on Batch Norm
+            and its variants only. Default: False.
+        pretrained (str, optional): model pretrained path. Default: None.
+        init_values (float): Initialize the values of Attention and FFN
+            with learnable scaling. Defaults to 0.1.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    """
+
+    def __init__(self,
+                 img_size=224,
+                 patch_size=16,
+                 in_channels=3,
+                 embed_dims=768,
+                 num_layers=12,
+                 num_heads=12,
+                 mlp_ratio=4,
+                 out_indices=-1,
+                 attn_drop_rate=0.,
+                 drop_path_rate=0.,
+                 norm_cfg=dict(type='LN'),
+                 act_cfg=dict(type='GELU'),
+                 patch_norm=False,
+                 final_norm=False,
+                 num_fcs=2,
+                 norm_eval=False,
+                 pretrained=None,
+                 init_values=0.1,
+                 init_cfg=None):
+        super().__init__(
+            img_size=img_size,
+            patch_size=patch_size,
+            in_channels=in_channels,
+            embed_dims=embed_dims,
+            num_layers=num_layers,
+            num_heads=num_heads,
+            mlp_ratio=mlp_ratio,
+            out_indices=out_indices,
+            qv_bias=False,
+            attn_drop_rate=attn_drop_rate,
+            drop_path_rate=drop_path_rate,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg,
+            patch_norm=patch_norm,
+            final_norm=final_norm,
+            num_fcs=num_fcs,
+            norm_eval=norm_eval,
+            pretrained=pretrained,
+            init_values=init_values,
+            init_cfg=init_cfg)
+
+        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dims))
+
+        self.num_patches = self.patch_shape[0] * self.patch_shape[1]
+        self.pos_embed = nn.Parameter(
+            torch.zeros(1, self.num_patches + 1, embed_dims))
+
+    def _build_layers(self):
+        dpr = [
+            x.item()
+            for x in torch.linspace(0, self.drop_path_rate, self.num_layers)
+        ]
+        self.layers = ModuleList()
+        for i in range(self.num_layers):
+            self.layers.append(
+                MAETransformerEncoderLayer(
+                    embed_dims=self.embed_dims,
+                    num_heads=self.num_heads,
+                    feedforward_channels=self.mlp_ratio * self.embed_dims,
+                    attn_drop_rate=self.attn_drop_rate,
+                    drop_path_rate=dpr[i],
+                    num_fcs=self.num_fcs,
+                    bias=True,
+                    act_cfg=self.act_cfg,
+                    norm_cfg=self.norm_cfg,
+                    window_size=self.patch_shape,
+                    init_values=self.init_values))
+
+    def fix_init_weight(self):
+        """Rescale the initialization according to layer id.
+
+        This function is copied from  https://github.com/microsoft/unilm/blob/master/beit/modeling_pretrain.py. # noqa: E501
+        Copyright (c) Microsoft Corporation
+        Licensed under the MIT License
+        """
+
+        def rescale(param, layer_id):
+            param.div_(math.sqrt(2.0 * layer_id))
+
+        for layer_id, layer in enumerate(self.layers):
+            rescale(layer.attn.proj.weight.data, layer_id + 1)
+            rescale(layer.ffn.layers[1].weight.data, layer_id + 1)
+
+    def init_weights(self):
+
+        def _init_weights(m):
+            if isinstance(m, nn.Linear):
+                trunc_normal_(m.weight, std=.02)
+                if isinstance(m, nn.Linear) and m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.LayerNorm):
+                nn.init.constant_(m.bias, 0)
+                nn.init.constant_(m.weight, 1.0)
+
+        self.apply(_init_weights)
+        self.fix_init_weight()
+
+        if (isinstance(self.init_cfg, dict)
+                and self.init_cfg.get('type') == 'Pretrained'):
+            checkpoint = _load_checkpoint(
+                self.init_cfg['checkpoint'], logger=None, map_location='cpu')
+            state_dict = self.resize_rel_pos_embed(checkpoint)
+            state_dict = self.resize_abs_pos_embed(state_dict)
+            self.load_state_dict(state_dict, False)
+        elif self.init_cfg is not None:
+            super().init_weights()
+        else:
+            # We only implement the 'jax_impl' initialization implemented at
+            # https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/vision_transformer.py#L353  # noqa: E501
+            # Copyright 2019 Ross Wightman
+            # Licensed under the Apache License, Version 2.0 (the "License")
+            trunc_normal_(self.cls_token, std=.02)
+            for n, m in self.named_modules():
+                if isinstance(m, nn.Linear):
+                    trunc_normal_(m.weight, std=.02)
+                    if m.bias is not None:
+                        if 'ffn' in n:
+                            nn.init.normal_(m.bias, mean=0., std=1e-6)
+                        else:
+                            nn.init.constant_(m.bias, 0)
+                elif isinstance(m, nn.Conv2d):
+                    kaiming_init(m, mode='fan_in', bias=0.)
+                elif isinstance(m, (_BatchNorm, nn.GroupNorm, nn.LayerNorm)):
+                    constant_init(m, val=1.0, bias=0.)
+
+    def resize_abs_pos_embed(self, state_dict):
+        if 'pos_embed' in state_dict:
+            pos_embed_checkpoint = state_dict['pos_embed']
+            embedding_size = pos_embed_checkpoint.shape[-1]
+            num_extra_tokens = self.pos_embed.shape[-2] - self.num_patches
+            # height (== width) for the checkpoint position embedding
+            orig_size = int(
+                (pos_embed_checkpoint.shape[-2] - num_extra_tokens)**0.5)
+            # height (== width) for the new position embedding
+            new_size = int(self.num_patches**0.5)
+            # class_token and dist_token are kept unchanged
+            if orig_size != new_size:
+                extra_tokens = pos_embed_checkpoint[:, :num_extra_tokens]
+                # only the position tokens are interpolated
+                pos_tokens = pos_embed_checkpoint[:, num_extra_tokens:]
+                pos_tokens = pos_tokens.reshape(-1, orig_size, orig_size,
+                                                embedding_size).permute(
+                                                    0, 3, 1, 2)
+                pos_tokens = torch.nn.functional.interpolate(
+                    pos_tokens,
+                    size=(new_size, new_size),
+                    mode='bicubic',
+                    align_corners=False)
+                pos_tokens = pos_tokens.permute(0, 2, 3, 1).flatten(1, 2)
+                new_pos_embed = torch.cat((extra_tokens, pos_tokens), dim=1)
+                state_dict['pos_embed'] = new_pos_embed
+        return state_dict
+
+    def forward(self, inputs):
+        B = inputs.shape[0]
+
+        x, hw_shape = self.patch_embed(inputs)
+
+        # stole cls_tokens impl from Phil Wang, thanks
+        cls_tokens = self.cls_token.expand(B, -1, -1)
+        x = torch.cat((cls_tokens, x), dim=1)
+        x = x + self.pos_embed
+
+        outs = []
+        for i, layer in enumerate(self.layers):
+            x = layer(x)
+            if i == len(self.layers) - 1:
+                if self.final_norm:
+                    x = self.norm1(x)
+            if i in self.out_indices:
+                out = x[:, 1:]
+                B, _, C = out.shape
+                out = out.reshape(B, hw_shape[0], hw_shape[1],
+                                  C).permute(0, 3, 1, 2).contiguous()
+                outs.append(out)
+
+        return tuple(outs)
diff --git a/mmsegmentation/mmseg/models/backbones/mit.py b/mmsegmentation/mmseg/models/backbones/mit.py
new file mode 100644
index 0000000..66556bd
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/mit.py
@@ -0,0 +1,450 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+import warnings
+
+import torch
+import torch.nn as nn
+import torch.utils.checkpoint as cp
+from mmcv.cnn import Conv2d, build_activation_layer, build_norm_layer
+from mmcv.cnn.bricks.drop import build_dropout
+from mmcv.cnn.bricks.transformer import MultiheadAttention
+from mmengine.model import BaseModule, ModuleList, Sequential
+from mmengine.model.weight_init import (constant_init, normal_init,
+                                        trunc_normal_init)
+
+from mmseg.registry import MODELS
+from ..utils import PatchEmbed, nchw_to_nlc, nlc_to_nchw
+
+
+class MixFFN(BaseModule):
+    """An implementation of MixFFN of Segformer.
+
+    The differences between MixFFN & FFN:
+        1. Use 1X1 Conv to replace Linear layer.
+        2. Introduce 3X3 Conv to encode positional information.
+    Args:
+        embed_dims (int): The feature dimension. Same as
+            `MultiheadAttention`. Defaults: 256.
+        feedforward_channels (int): The hidden dimension of FFNs.
+            Defaults: 1024.
+        act_cfg (dict, optional): The activation config for FFNs.
+            Default: dict(type='ReLU')
+        ffn_drop (float, optional): Probability of an element to be
+            zeroed in FFN. Default 0.0.
+        dropout_layer (obj:`ConfigDict`): The dropout_layer used
+            when adding the shortcut.
+        init_cfg (obj:`mmcv.ConfigDict`): The Config for initialization.
+            Default: None.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 feedforward_channels,
+                 act_cfg=dict(type='GELU'),
+                 ffn_drop=0.,
+                 dropout_layer=None,
+                 init_cfg=None):
+        super().__init__(init_cfg)
+
+        self.embed_dims = embed_dims
+        self.feedforward_channels = feedforward_channels
+        self.act_cfg = act_cfg
+        self.activate = build_activation_layer(act_cfg)
+
+        in_channels = embed_dims
+        fc1 = Conv2d(
+            in_channels=in_channels,
+            out_channels=feedforward_channels,
+            kernel_size=1,
+            stride=1,
+            bias=True)
+        # 3x3 depth wise conv to provide positional encode information
+        pe_conv = Conv2d(
+            in_channels=feedforward_channels,
+            out_channels=feedforward_channels,
+            kernel_size=3,
+            stride=1,
+            padding=(3 - 1) // 2,
+            bias=True,
+            groups=feedforward_channels)
+        fc2 = Conv2d(
+            in_channels=feedforward_channels,
+            out_channels=in_channels,
+            kernel_size=1,
+            stride=1,
+            bias=True)
+        drop = nn.Dropout(ffn_drop)
+        layers = [fc1, pe_conv, self.activate, drop, fc2, drop]
+        self.layers = Sequential(*layers)
+        self.dropout_layer = build_dropout(
+            dropout_layer) if dropout_layer else torch.nn.Identity()
+
+    def forward(self, x, hw_shape, identity=None):
+        out = nlc_to_nchw(x, hw_shape)
+        out = self.layers(out)
+        out = nchw_to_nlc(out)
+        if identity is None:
+            identity = x
+        return identity + self.dropout_layer(out)
+
+
+class EfficientMultiheadAttention(MultiheadAttention):
+    """An implementation of Efficient Multi-head Attention of Segformer.
+
+    This module is modified from MultiheadAttention which is a module from
+    mmcv.cnn.bricks.transformer.
+    Args:
+        embed_dims (int): The embedding dimension.
+        num_heads (int): Parallel attention heads.
+        attn_drop (float): A Dropout layer on attn_output_weights.
+            Default: 0.0.
+        proj_drop (float): A Dropout layer after `nn.MultiheadAttention`.
+            Default: 0.0.
+        dropout_layer (obj:`ConfigDict`): The dropout_layer used
+            when adding the shortcut. Default: None.
+        init_cfg (obj:`mmcv.ConfigDict`): The Config for initialization.
+            Default: None.
+        batch_first (bool): Key, Query and Value are shape of
+            (batch, n, embed_dim)
+            or (n, batch, embed_dim). Default: False.
+        qkv_bias (bool): enable bias for qkv if True. Default True.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='LN').
+        sr_ratio (int): The ratio of spatial reduction of Efficient Multi-head
+            Attention of Segformer. Default: 1.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 num_heads,
+                 attn_drop=0.,
+                 proj_drop=0.,
+                 dropout_layer=None,
+                 init_cfg=None,
+                 batch_first=True,
+                 qkv_bias=False,
+                 norm_cfg=dict(type='LN'),
+                 sr_ratio=1):
+        super().__init__(
+            embed_dims,
+            num_heads,
+            attn_drop,
+            proj_drop,
+            dropout_layer=dropout_layer,
+            init_cfg=init_cfg,
+            batch_first=batch_first,
+            bias=qkv_bias)
+
+        self.sr_ratio = sr_ratio
+        if sr_ratio > 1:
+            self.sr = Conv2d(
+                in_channels=embed_dims,
+                out_channels=embed_dims,
+                kernel_size=sr_ratio,
+                stride=sr_ratio)
+            # The ret[0] of build_norm_layer is norm name.
+            self.norm = build_norm_layer(norm_cfg, embed_dims)[1]
+
+        # handle the BC-breaking from https://github.com/open-mmlab/mmcv/pull/1418 # noqa
+        from mmseg import digit_version, mmcv_version
+        if mmcv_version < digit_version('1.3.17'):
+            warnings.warn('The legacy version of forward function in'
+                          'EfficientMultiheadAttention is deprecated in'
+                          'mmcv>=1.3.17 and will no longer support in the'
+                          'future. Please upgrade your mmcv.')
+            self.forward = self.legacy_forward
+
+    def forward(self, x, hw_shape, identity=None):
+
+        x_q = x
+        if self.sr_ratio > 1:
+            x_kv = nlc_to_nchw(x, hw_shape)
+            x_kv = self.sr(x_kv)
+            x_kv = nchw_to_nlc(x_kv)
+            x_kv = self.norm(x_kv)
+        else:
+            x_kv = x
+
+        if identity is None:
+            identity = x_q
+
+        # Because the dataflow('key', 'query', 'value') of
+        # ``torch.nn.MultiheadAttention`` is (num_query, batch,
+        # embed_dims), We should adjust the shape of dataflow from
+        # batch_first (batch, num_query, embed_dims) to num_query_first
+        # (num_query ,batch, embed_dims), and recover ``attn_output``
+        # from num_query_first to batch_first.
+        if self.batch_first:
+            x_q = x_q.transpose(0, 1)
+            x_kv = x_kv.transpose(0, 1)
+
+        out = self.attn(query=x_q, key=x_kv, value=x_kv)[0]
+
+        if self.batch_first:
+            out = out.transpose(0, 1)
+
+        return identity + self.dropout_layer(self.proj_drop(out))
+
+    def legacy_forward(self, x, hw_shape, identity=None):
+        """multi head attention forward in mmcv version < 1.3.17."""
+
+        x_q = x
+        if self.sr_ratio > 1:
+            x_kv = nlc_to_nchw(x, hw_shape)
+            x_kv = self.sr(x_kv)
+            x_kv = nchw_to_nlc(x_kv)
+            x_kv = self.norm(x_kv)
+        else:
+            x_kv = x
+
+        if identity is None:
+            identity = x_q
+
+        # `need_weights=True` will let nn.MultiHeadAttention
+        # `return attn_output, attn_output_weights.sum(dim=1) / num_heads`
+        # The `attn_output_weights.sum(dim=1)` may cause cuda error. So, we set
+        # `need_weights=False` to ignore `attn_output_weights.sum(dim=1)`.
+        # This issue - `https://github.com/pytorch/pytorch/issues/37583` report
+        # the error that large scale tensor sum operation may cause cuda error.
+        out = self.attn(query=x_q, key=x_kv, value=x_kv, need_weights=False)[0]
+
+        return identity + self.dropout_layer(self.proj_drop(out))
+
+
+class TransformerEncoderLayer(BaseModule):
+    """Implements one encoder layer in Segformer.
+
+    Args:
+        embed_dims (int): The feature dimension.
+        num_heads (int): Parallel attention heads.
+        feedforward_channels (int): The hidden dimension for FFNs.
+        drop_rate (float): Probability of an element to be zeroed.
+            after the feed forward layer. Default 0.0.
+        attn_drop_rate (float): The drop out rate for attention layer.
+            Default 0.0.
+        drop_path_rate (float): stochastic depth rate. Default 0.0.
+        qkv_bias (bool): enable bias for qkv if True.
+            Default: True.
+        act_cfg (dict): The activation config for FFNs.
+            Default: dict(type='GELU').
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='LN').
+        batch_first (bool): Key, Query and Value are shape of
+            (batch, n, embed_dim)
+            or (n, batch, embed_dim). Default: False.
+        init_cfg (dict, optional): Initialization config dict.
+            Default:None.
+        sr_ratio (int): The ratio of spatial reduction of Efficient Multi-head
+            Attention of Segformer. Default: 1.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save
+            some memory while slowing down the training speed. Default: False.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 num_heads,
+                 feedforward_channels,
+                 drop_rate=0.,
+                 attn_drop_rate=0.,
+                 drop_path_rate=0.,
+                 qkv_bias=True,
+                 act_cfg=dict(type='GELU'),
+                 norm_cfg=dict(type='LN'),
+                 batch_first=True,
+                 sr_ratio=1,
+                 with_cp=False):
+        super().__init__()
+
+        # The ret[0] of build_norm_layer is norm name.
+        self.norm1 = build_norm_layer(norm_cfg, embed_dims)[1]
+
+        self.attn = EfficientMultiheadAttention(
+            embed_dims=embed_dims,
+            num_heads=num_heads,
+            attn_drop=attn_drop_rate,
+            proj_drop=drop_rate,
+            dropout_layer=dict(type='DropPath', drop_prob=drop_path_rate),
+            batch_first=batch_first,
+            qkv_bias=qkv_bias,
+            norm_cfg=norm_cfg,
+            sr_ratio=sr_ratio)
+
+        # The ret[0] of build_norm_layer is norm name.
+        self.norm2 = build_norm_layer(norm_cfg, embed_dims)[1]
+
+        self.ffn = MixFFN(
+            embed_dims=embed_dims,
+            feedforward_channels=feedforward_channels,
+            ffn_drop=drop_rate,
+            dropout_layer=dict(type='DropPath', drop_prob=drop_path_rate),
+            act_cfg=act_cfg)
+
+        self.with_cp = with_cp
+
+    def forward(self, x, hw_shape):
+
+        def _inner_forward(x):
+            x = self.attn(self.norm1(x), hw_shape, identity=x)
+            x = self.ffn(self.norm2(x), hw_shape, identity=x)
+            return x
+
+        if self.with_cp and x.requires_grad:
+            x = cp.checkpoint(_inner_forward, x)
+        else:
+            x = _inner_forward(x)
+        return x
+
+
+@MODELS.register_module()
+class MixVisionTransformer(BaseModule):
+    """The backbone of Segformer.
+
+    This backbone is the implementation of `SegFormer: Simple and
+    Efficient Design for Semantic Segmentation with
+    Transformers <https://arxiv.org/abs/2105.15203>`_.
+    Args:
+        in_channels (int): Number of input channels. Default: 3.
+        embed_dims (int): Embedding dimension. Default: 768.
+        num_stags (int): The num of stages. Default: 4.
+        num_layers (Sequence[int]): The layer number of each transformer encode
+            layer. Default: [3, 4, 6, 3].
+        num_heads (Sequence[int]): The attention heads of each transformer
+            encode layer. Default: [1, 2, 4, 8].
+        patch_sizes (Sequence[int]): The patch_size of each overlapped patch
+            embedding. Default: [7, 3, 3, 3].
+        strides (Sequence[int]): The stride of each overlapped patch embedding.
+            Default: [4, 2, 2, 2].
+        sr_ratios (Sequence[int]): The spatial reduction rate of each
+            transformer encode layer. Default: [8, 4, 2, 1].
+        out_indices (Sequence[int] | int): Output from which stages.
+            Default: (0, 1, 2, 3).
+        mlp_ratio (int): ratio of mlp hidden dim to embedding dim.
+            Default: 4.
+        qkv_bias (bool): Enable bias for qkv if True. Default: True.
+        drop_rate (float): Probability of an element to be zeroed.
+            Default 0.0
+        attn_drop_rate (float): The drop out rate for attention layer.
+            Default 0.0
+        drop_path_rate (float): stochastic depth rate. Default 0.0
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='LN')
+        act_cfg (dict): The activation config for FFNs.
+            Default: dict(type='GELU').
+        pretrained (str, optional): model pretrained path. Default: None.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save
+            some memory while slowing down the training speed. Default: False.
+    """
+
+    def __init__(self,
+                 in_channels=3,
+                 embed_dims=64,
+                 num_stages=4,
+                 num_layers=[3, 4, 6, 3],
+                 num_heads=[1, 2, 4, 8],
+                 patch_sizes=[7, 3, 3, 3],
+                 strides=[4, 2, 2, 2],
+                 sr_ratios=[8, 4, 2, 1],
+                 out_indices=(0, 1, 2, 3),
+                 mlp_ratio=4,
+                 qkv_bias=True,
+                 drop_rate=0.,
+                 attn_drop_rate=0.,
+                 drop_path_rate=0.,
+                 act_cfg=dict(type='GELU'),
+                 norm_cfg=dict(type='LN', eps=1e-6),
+                 pretrained=None,
+                 init_cfg=None,
+                 with_cp=False):
+        super().__init__(init_cfg=init_cfg)
+
+        assert not (init_cfg and pretrained), \
+            'init_cfg and pretrained cannot be set at the same time'
+        if isinstance(pretrained, str):
+            warnings.warn('DeprecationWarning: pretrained is deprecated, '
+                          'please use "init_cfg" instead')
+            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
+        elif pretrained is not None:
+            raise TypeError('pretrained must be a str or None')
+
+        self.embed_dims = embed_dims
+        self.num_stages = num_stages
+        self.num_layers = num_layers
+        self.num_heads = num_heads
+        self.patch_sizes = patch_sizes
+        self.strides = strides
+        self.sr_ratios = sr_ratios
+        self.with_cp = with_cp
+        assert num_stages == len(num_layers) == len(num_heads) \
+               == len(patch_sizes) == len(strides) == len(sr_ratios)
+
+        self.out_indices = out_indices
+        assert max(out_indices) < self.num_stages
+
+        # transformer encoder
+        dpr = [
+            x.item()
+            for x in torch.linspace(0, drop_path_rate, sum(num_layers))
+        ]  # stochastic num_layer decay rule
+
+        cur = 0
+        self.layers = ModuleList()
+        for i, num_layer in enumerate(num_layers):
+            embed_dims_i = embed_dims * num_heads[i]
+            patch_embed = PatchEmbed(
+                in_channels=in_channels,
+                embed_dims=embed_dims_i,
+                kernel_size=patch_sizes[i],
+                stride=strides[i],
+                padding=patch_sizes[i] // 2,
+                norm_cfg=norm_cfg)
+            layer = ModuleList([
+                TransformerEncoderLayer(
+                    embed_dims=embed_dims_i,
+                    num_heads=num_heads[i],
+                    feedforward_channels=mlp_ratio * embed_dims_i,
+                    drop_rate=drop_rate,
+                    attn_drop_rate=attn_drop_rate,
+                    drop_path_rate=dpr[cur + idx],
+                    qkv_bias=qkv_bias,
+                    act_cfg=act_cfg,
+                    norm_cfg=norm_cfg,
+                    with_cp=with_cp,
+                    sr_ratio=sr_ratios[i]) for idx in range(num_layer)
+            ])
+            in_channels = embed_dims_i
+            # The ret[0] of build_norm_layer is norm name.
+            norm = build_norm_layer(norm_cfg, embed_dims_i)[1]
+            self.layers.append(ModuleList([patch_embed, layer, norm]))
+            cur += num_layer
+
+    def init_weights(self):
+        if self.init_cfg is None:
+            for m in self.modules():
+                if isinstance(m, nn.Linear):
+                    trunc_normal_init(m, std=.02, bias=0.)
+                elif isinstance(m, nn.LayerNorm):
+                    constant_init(m, val=1.0, bias=0.)
+                elif isinstance(m, nn.Conv2d):
+                    fan_out = m.kernel_size[0] * m.kernel_size[
+                        1] * m.out_channels
+                    fan_out //= m.groups
+                    normal_init(
+                        m, mean=0, std=math.sqrt(2.0 / fan_out), bias=0)
+        else:
+            super().init_weights()
+
+    def forward(self, x):
+        outs = []
+
+        for i, layer in enumerate(self.layers):
+            x, hw_shape = layer[0](x)
+            for block in layer[1]:
+                x = block(x, hw_shape)
+            x = layer[2](x)
+            x = nlc_to_nchw(x, hw_shape)
+            if i in self.out_indices:
+                outs.append(x)
+
+        return outs
diff --git a/mmsegmentation/mmseg/models/backbones/mobilenet_v2.py b/mmsegmentation/mmseg/models/backbones/mobilenet_v2.py
new file mode 100644
index 0000000..1c21b5d
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/mobilenet_v2.py
@@ -0,0 +1,197 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule
+from torch.nn.modules.batchnorm import _BatchNorm
+
+from mmseg.registry import MODELS
+from ..utils import InvertedResidual, make_divisible
+
+
+@MODELS.register_module()
+class MobileNetV2(BaseModule):
+    """MobileNetV2 backbone.
+
+    This backbone is the implementation of
+    `MobileNetV2: Inverted Residuals and Linear Bottlenecks
+    <https://arxiv.org/abs/1801.04381>`_.
+
+    Args:
+        widen_factor (float): Width multiplier, multiply number of
+            channels in each layer by this amount. Default: 1.0.
+        strides (Sequence[int], optional): Strides of the first block of each
+            layer. If not specified, default config in ``arch_setting`` will
+            be used.
+        dilations (Sequence[int]): Dilation of each layer.
+        out_indices (None or Sequence[int]): Output from which stages.
+            Default: (7, ).
+        frozen_stages (int): Stages to be frozen (all param fixed).
+            Default: -1, which means not freezing any parameters.
+        conv_cfg (dict): Config dict for convolution layer.
+            Default: None, which means using conv2d.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN').
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='ReLU6').
+        norm_eval (bool): Whether to set norm layers to eval mode, namely,
+            freeze running stats (mean and var). Note: Effect on Batch Norm
+            and its variants only. Default: False.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed. Default: False.
+        pretrained (str, optional): model pretrained path. Default: None
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None
+    """
+
+    # Parameters to build layers. 3 parameters are needed to construct a
+    # layer, from left to right: expand_ratio, channel, num_blocks.
+    arch_settings = [[1, 16, 1], [6, 24, 2], [6, 32, 3], [6, 64, 4],
+                     [6, 96, 3], [6, 160, 3], [6, 320, 1]]
+
+    def __init__(self,
+                 widen_factor=1.,
+                 strides=(1, 2, 2, 2, 1, 2, 1),
+                 dilations=(1, 1, 1, 1, 1, 1, 1),
+                 out_indices=(1, 2, 4, 6),
+                 frozen_stages=-1,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU6'),
+                 norm_eval=False,
+                 with_cp=False,
+                 pretrained=None,
+                 init_cfg=None):
+        super().__init__(init_cfg)
+
+        self.pretrained = pretrained
+        assert not (init_cfg and pretrained), \
+            'init_cfg and pretrained cannot be setting at the same time'
+        if isinstance(pretrained, str):
+            warnings.warn('DeprecationWarning: pretrained is a deprecated, '
+                          'please use "init_cfg" instead')
+            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
+        elif pretrained is None:
+            if init_cfg is None:
+                self.init_cfg = [
+                    dict(type='Kaiming', layer='Conv2d'),
+                    dict(
+                        type='Constant',
+                        val=1,
+                        layer=['_BatchNorm', 'GroupNorm'])
+                ]
+        else:
+            raise TypeError('pretrained must be a str or None')
+
+        self.widen_factor = widen_factor
+        self.strides = strides
+        self.dilations = dilations
+        assert len(strides) == len(dilations) == len(self.arch_settings)
+        self.out_indices = out_indices
+        for index in out_indices:
+            if index not in range(0, 7):
+                raise ValueError('the item in out_indices must in '
+                                 f'range(0, 7). But received {index}')
+
+        if frozen_stages not in range(-1, 7):
+            raise ValueError('frozen_stages must be in range(-1, 7). '
+                             f'But received {frozen_stages}')
+        self.out_indices = out_indices
+        self.frozen_stages = frozen_stages
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+        self.norm_eval = norm_eval
+        self.with_cp = with_cp
+
+        self.in_channels = make_divisible(32 * widen_factor, 8)
+
+        self.conv1 = ConvModule(
+            in_channels=3,
+            out_channels=self.in_channels,
+            kernel_size=3,
+            stride=2,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+        self.layers = []
+
+        for i, layer_cfg in enumerate(self.arch_settings):
+            expand_ratio, channel, num_blocks = layer_cfg
+            stride = self.strides[i]
+            dilation = self.dilations[i]
+            out_channels = make_divisible(channel * widen_factor, 8)
+            inverted_res_layer = self.make_layer(
+                out_channels=out_channels,
+                num_blocks=num_blocks,
+                stride=stride,
+                dilation=dilation,
+                expand_ratio=expand_ratio)
+            layer_name = f'layer{i + 1}'
+            self.add_module(layer_name, inverted_res_layer)
+            self.layers.append(layer_name)
+
+    def make_layer(self, out_channels, num_blocks, stride, dilation,
+                   expand_ratio):
+        """Stack InvertedResidual blocks to build a layer for MobileNetV2.
+
+        Args:
+            out_channels (int): out_channels of block.
+            num_blocks (int): Number of blocks.
+            stride (int): Stride of the first block.
+            dilation (int): Dilation of the first block.
+            expand_ratio (int): Expand the number of channels of the
+                hidden layer in InvertedResidual by this ratio.
+        """
+        layers = []
+        for i in range(num_blocks):
+            layers.append(
+                InvertedResidual(
+                    self.in_channels,
+                    out_channels,
+                    stride if i == 0 else 1,
+                    expand_ratio=expand_ratio,
+                    dilation=dilation if i == 0 else 1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg,
+                    act_cfg=self.act_cfg,
+                    with_cp=self.with_cp))
+            self.in_channels = out_channels
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        x = self.conv1(x)
+
+        outs = []
+        for i, layer_name in enumerate(self.layers):
+            layer = getattr(self, layer_name)
+            x = layer(x)
+            if i in self.out_indices:
+                outs.append(x)
+
+        if len(outs) == 1:
+            return outs[0]
+        else:
+            return tuple(outs)
+
+    def _freeze_stages(self):
+        if self.frozen_stages >= 0:
+            for param in self.conv1.parameters():
+                param.requires_grad = False
+        for i in range(1, self.frozen_stages + 1):
+            layer = getattr(self, f'layer{i}')
+            layer.eval()
+            for param in layer.parameters():
+                param.requires_grad = False
+
+    def train(self, mode=True):
+        super().train(mode)
+        self._freeze_stages()
+        if mode and self.norm_eval:
+            for m in self.modules():
+                if isinstance(m, _BatchNorm):
+                    m.eval()
diff --git a/mmsegmentation/mmseg/models/backbones/mobilenet_v3.py b/mmsegmentation/mmseg/models/backbones/mobilenet_v3.py
new file mode 100644
index 0000000..1efb6e0
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/mobilenet_v3.py
@@ -0,0 +1,267 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+from mmcv.cnn import ConvModule
+from mmcv.cnn.bricks import Conv2dAdaptivePadding
+from mmengine.model import BaseModule
+from mmengine.utils import is_tuple_of
+from torch.nn.modules.batchnorm import _BatchNorm
+
+from mmseg.registry import MODELS
+from ..utils import InvertedResidualV3 as InvertedResidual
+
+
+@MODELS.register_module()
+class MobileNetV3(BaseModule):
+    """MobileNetV3 backbone.
+
+    This backbone is the improved implementation of `Searching for MobileNetV3
+    <https://ieeexplore.ieee.org/document/9008835>`_.
+
+    Args:
+        arch (str): Architecture of mobilnetv3, from {'small', 'large'}.
+            Default: 'small'.
+        conv_cfg (dict): Config dict for convolution layer.
+            Default: None, which means using conv2d.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN').
+        out_indices (tuple[int]): Output from which layer.
+            Default: (0, 1, 12).
+        frozen_stages (int): Stages to be frozen (all param fixed).
+            Default: -1, which means not freezing any parameters.
+        norm_eval (bool): Whether to set norm layers to eval mode, namely,
+            freeze running stats (mean and var). Note: Effect on Batch Norm
+            and its variants only. Default: False.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save
+            some memory while slowing down the training speed.
+            Default: False.
+        pretrained (str, optional): model pretrained path. Default: None
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None
+    """
+    # Parameters to build each block:
+    #     [kernel size, mid channels, out channels, with_se, act type, stride]
+    arch_settings = {
+        'small': [[3, 16, 16, True, 'ReLU', 2],  # block0 layer1 os=4
+                  [3, 72, 24, False, 'ReLU', 2],  # block1 layer2 os=8
+                  [3, 88, 24, False, 'ReLU', 1],
+                  [5, 96, 40, True, 'HSwish', 2],  # block2 layer4 os=16
+                  [5, 240, 40, True, 'HSwish', 1],
+                  [5, 240, 40, True, 'HSwish', 1],
+                  [5, 120, 48, True, 'HSwish', 1],  # block3 layer7 os=16
+                  [5, 144, 48, True, 'HSwish', 1],
+                  [5, 288, 96, True, 'HSwish', 2],  # block4 layer9 os=32
+                  [5, 576, 96, True, 'HSwish', 1],
+                  [5, 576, 96, True, 'HSwish', 1]],
+        'large': [[3, 16, 16, False, 'ReLU', 1],  # block0 layer1 os=2
+                  [3, 64, 24, False, 'ReLU', 2],  # block1 layer2 os=4
+                  [3, 72, 24, False, 'ReLU', 1],
+                  [5, 72, 40, True, 'ReLU', 2],  # block2 layer4 os=8
+                  [5, 120, 40, True, 'ReLU', 1],
+                  [5, 120, 40, True, 'ReLU', 1],
+                  [3, 240, 80, False, 'HSwish', 2],  # block3 layer7 os=16
+                  [3, 200, 80, False, 'HSwish', 1],
+                  [3, 184, 80, False, 'HSwish', 1],
+                  [3, 184, 80, False, 'HSwish', 1],
+                  [3, 480, 112, True, 'HSwish', 1],  # block4 layer11 os=16
+                  [3, 672, 112, True, 'HSwish', 1],
+                  [5, 672, 160, True, 'HSwish', 2],  # block5 layer13 os=32
+                  [5, 960, 160, True, 'HSwish', 1],
+                  [5, 960, 160, True, 'HSwish', 1]]
+    }  # yapf: disable
+
+    def __init__(self,
+                 arch='small',
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 out_indices=(0, 1, 12),
+                 frozen_stages=-1,
+                 reduction_factor=1,
+                 norm_eval=False,
+                 with_cp=False,
+                 pretrained=None,
+                 init_cfg=None):
+        super().__init__(init_cfg)
+
+        self.pretrained = pretrained
+        assert not (init_cfg and pretrained), \
+            'init_cfg and pretrained cannot be setting at the same time'
+        if isinstance(pretrained, str):
+            warnings.warn('DeprecationWarning: pretrained is a deprecated, '
+                          'please use "init_cfg" instead')
+            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
+        elif pretrained is None:
+            if init_cfg is None:
+                self.init_cfg = [
+                    dict(type='Kaiming', layer='Conv2d'),
+                    dict(
+                        type='Constant',
+                        val=1,
+                        layer=['_BatchNorm', 'GroupNorm'])
+                ]
+        else:
+            raise TypeError('pretrained must be a str or None')
+
+        assert arch in self.arch_settings
+        assert isinstance(reduction_factor, int) and reduction_factor > 0
+        assert is_tuple_of(out_indices, int)
+        for index in out_indices:
+            if index not in range(0, len(self.arch_settings[arch]) + 2):
+                raise ValueError(
+                    'the item in out_indices must in '
+                    f'range(0, {len(self.arch_settings[arch])+2}). '
+                    f'But received {index}')
+
+        if frozen_stages not in range(-1, len(self.arch_settings[arch]) + 2):
+            raise ValueError('frozen_stages must be in range(-1, '
+                             f'{len(self.arch_settings[arch])+2}). '
+                             f'But received {frozen_stages}')
+        self.arch = arch
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.out_indices = out_indices
+        self.frozen_stages = frozen_stages
+        self.reduction_factor = reduction_factor
+        self.norm_eval = norm_eval
+        self.with_cp = with_cp
+        self.layers = self._make_layer()
+
+    def _make_layer(self):
+        layers = []
+
+        # build the first layer (layer0)
+        in_channels = 16
+        layer = ConvModule(
+            in_channels=3,
+            out_channels=in_channels,
+            kernel_size=3,
+            stride=2,
+            padding=1,
+            conv_cfg=dict(type='Conv2dAdaptivePadding'),
+            norm_cfg=self.norm_cfg,
+            act_cfg=dict(type='HSwish'))
+        self.add_module('layer0', layer)
+        layers.append('layer0')
+
+        layer_setting = self.arch_settings[self.arch]
+        for i, params in enumerate(layer_setting):
+            (kernel_size, mid_channels, out_channels, with_se, act,
+             stride) = params
+
+            if self.arch == 'large' and i >= 12 or self.arch == 'small' and \
+                    i >= 8:
+                mid_channels = mid_channels // self.reduction_factor
+                out_channels = out_channels // self.reduction_factor
+
+            if with_se:
+                se_cfg = dict(
+                    channels=mid_channels,
+                    ratio=4,
+                    act_cfg=(dict(type='ReLU'),
+                             dict(type='HSigmoid', bias=3.0, divisor=6.0)))
+            else:
+                se_cfg = None
+
+            layer = InvertedResidual(
+                in_channels=in_channels,
+                out_channels=out_channels,
+                mid_channels=mid_channels,
+                kernel_size=kernel_size,
+                stride=stride,
+                se_cfg=se_cfg,
+                with_expand_conv=(in_channels != mid_channels),
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg,
+                act_cfg=dict(type=act),
+                with_cp=self.with_cp)
+            in_channels = out_channels
+            layer_name = f'layer{i + 1}'
+            self.add_module(layer_name, layer)
+            layers.append(layer_name)
+
+        # build the last layer
+        # block5 layer12 os=32 for small model
+        # block6 layer16 os=32 for large model
+        layer = ConvModule(
+            in_channels=in_channels,
+            out_channels=576 if self.arch == 'small' else 960,
+            kernel_size=1,
+            stride=1,
+            dilation=4,
+            padding=0,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=dict(type='HSwish'))
+        layer_name = f'layer{len(layer_setting) + 1}'
+        self.add_module(layer_name, layer)
+        layers.append(layer_name)
+
+        # next, convert backbone MobileNetV3 to a semantic segmentation version
+        if self.arch == 'small':
+            self.layer4.depthwise_conv.conv.stride = (1, 1)
+            self.layer9.depthwise_conv.conv.stride = (1, 1)
+            for i in range(4, len(layers)):
+                layer = getattr(self, layers[i])
+                if isinstance(layer, InvertedResidual):
+                    modified_module = layer.depthwise_conv.conv
+                else:
+                    modified_module = layer.conv
+
+                if i < 9:
+                    modified_module.dilation = (2, 2)
+                    pad = 2
+                else:
+                    modified_module.dilation = (4, 4)
+                    pad = 4
+
+                if not isinstance(modified_module, Conv2dAdaptivePadding):
+                    # Adjust padding
+                    pad *= (modified_module.kernel_size[0] - 1) // 2
+                    modified_module.padding = (pad, pad)
+        else:
+            self.layer7.depthwise_conv.conv.stride = (1, 1)
+            self.layer13.depthwise_conv.conv.stride = (1, 1)
+            for i in range(7, len(layers)):
+                layer = getattr(self, layers[i])
+                if isinstance(layer, InvertedResidual):
+                    modified_module = layer.depthwise_conv.conv
+                else:
+                    modified_module = layer.conv
+
+                if i < 13:
+                    modified_module.dilation = (2, 2)
+                    pad = 2
+                else:
+                    modified_module.dilation = (4, 4)
+                    pad = 4
+
+                if not isinstance(modified_module, Conv2dAdaptivePadding):
+                    # Adjust padding
+                    pad *= (modified_module.kernel_size[0] - 1) // 2
+                    modified_module.padding = (pad, pad)
+
+        return layers
+
+    def forward(self, x):
+        outs = []
+        for i, layer_name in enumerate(self.layers):
+            layer = getattr(self, layer_name)
+            x = layer(x)
+            if i in self.out_indices:
+                outs.append(x)
+        return outs
+
+    def _freeze_stages(self):
+        for i in range(self.frozen_stages + 1):
+            layer = getattr(self, f'layer{i}')
+            layer.eval()
+            for param in layer.parameters():
+                param.requires_grad = False
+
+    def train(self, mode=True):
+        super().train(mode)
+        self._freeze_stages()
+        if mode and self.norm_eval:
+            for m in self.modules():
+                if isinstance(m, _BatchNorm):
+                    m.eval()
diff --git a/mmsegmentation/mmseg/models/backbones/mscan.py b/mmsegmentation/mmseg/models/backbones/mscan.py
new file mode 100644
index 0000000..7150cb7
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/mscan.py
@@ -0,0 +1,467 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# Originally from https://github.com/visual-attention-network/segnext
+# Licensed under the Apache License, Version 2.0 (the "License")
+import math
+import warnings
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import build_activation_layer, build_norm_layer
+from mmcv.cnn.bricks import DropPath
+from mmengine.model import BaseModule
+from mmengine.model.weight_init import (constant_init, normal_init,
+                                        trunc_normal_init)
+
+from mmseg.registry import MODELS
+
+
+class Mlp(BaseModule):
+    """Multi Layer Perceptron (MLP) Module.
+
+    Args:
+        in_features (int): The dimension of input features.
+        hidden_features (int): The dimension of hidden features.
+            Defaults: None.
+        out_features (int): The dimension of output features.
+            Defaults: None.
+        act_cfg (dict): Config dict for activation layer in block.
+            Default: dict(type='GELU').
+        drop (float): The number of dropout rate in MLP block.
+            Defaults: 0.0.
+    """
+
+    def __init__(self,
+                 in_features,
+                 hidden_features=None,
+                 out_features=None,
+                 act_cfg=dict(type='GELU'),
+                 drop=0.):
+        super().__init__()
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+        self.fc1 = nn.Conv2d(in_features, hidden_features, 1)
+        self.dwconv = nn.Conv2d(
+            hidden_features,
+            hidden_features,
+            3,
+            1,
+            1,
+            bias=True,
+            groups=hidden_features)
+        self.act = build_activation_layer(act_cfg)
+        self.fc2 = nn.Conv2d(hidden_features, out_features, 1)
+        self.drop = nn.Dropout(drop)
+
+    def forward(self, x):
+        """Forward function."""
+
+        x = self.fc1(x)
+
+        x = self.dwconv(x)
+        x = self.act(x)
+        x = self.drop(x)
+        x = self.fc2(x)
+        x = self.drop(x)
+
+        return x
+
+
+class StemConv(BaseModule):
+    """Stem Block at the beginning of Semantic Branch.
+
+    Args:
+        in_channels (int): The dimension of input channels.
+        out_channels (int): The dimension of output channels.
+        act_cfg (dict): Config dict for activation layer in block.
+            Default: dict(type='GELU').
+        norm_cfg (dict): Config dict for normalization layer.
+            Defaults: dict(type='SyncBN', requires_grad=True).
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 act_cfg=dict(type='GELU'),
+                 norm_cfg=dict(type='SyncBN', requires_grad=True)):
+        super().__init__()
+
+        self.proj = nn.Sequential(
+            nn.Conv2d(
+                in_channels,
+                out_channels // 2,
+                kernel_size=(3, 3),
+                stride=(2, 2),
+                padding=(1, 1)),
+            build_norm_layer(norm_cfg, out_channels // 2)[1],
+            build_activation_layer(act_cfg),
+            nn.Conv2d(
+                out_channels // 2,
+                out_channels,
+                kernel_size=(3, 3),
+                stride=(2, 2),
+                padding=(1, 1)),
+            build_norm_layer(norm_cfg, out_channels)[1],
+        )
+
+    def forward(self, x):
+        """Forward function."""
+
+        x = self.proj(x)
+        _, _, H, W = x.size()
+        x = x.flatten(2).transpose(1, 2)
+        return x, H, W
+
+
+class MSCAAttention(BaseModule):
+    """Attention Module in Multi-Scale Convolutional Attention Module (MSCA).
+
+    Args:
+        channels (int): The dimension of channels.
+        kernel_sizes (list): The size of attention
+            kernel. Defaults: [5, [1, 7], [1, 11], [1, 21]].
+        paddings (list): The number of
+            corresponding padding value in attention module.
+            Defaults: [2, [0, 3], [0, 5], [0, 10]].
+    """
+
+    def __init__(self,
+                 channels,
+                 kernel_sizes=[5, [1, 7], [1, 11], [1, 21]],
+                 paddings=[2, [0, 3], [0, 5], [0, 10]]):
+        super().__init__()
+        self.conv0 = nn.Conv2d(
+            channels,
+            channels,
+            kernel_size=kernel_sizes[0],
+            padding=paddings[0],
+            groups=channels)
+        for i, (kernel_size,
+                padding) in enumerate(zip(kernel_sizes[1:], paddings[1:])):
+            kernel_size_ = [kernel_size, kernel_size[::-1]]
+            padding_ = [padding, padding[::-1]]
+            conv_name = [f'conv{i}_1', f'conv{i}_2']
+            for i_kernel, i_pad, i_conv in zip(kernel_size_, padding_,
+                                               conv_name):
+                self.add_module(
+                    i_conv,
+                    nn.Conv2d(
+                        channels,
+                        channels,
+                        tuple(i_kernel),
+                        padding=i_pad,
+                        groups=channels))
+        self.conv3 = nn.Conv2d(channels, channels, 1)
+
+    def forward(self, x):
+        """Forward function."""
+
+        u = x.clone()
+
+        attn = self.conv0(x)
+
+        # Multi-Scale Feature extraction
+        attn_0 = self.conv0_1(attn)
+        attn_0 = self.conv0_2(attn_0)
+
+        attn_1 = self.conv1_1(attn)
+        attn_1 = self.conv1_2(attn_1)
+
+        attn_2 = self.conv2_1(attn)
+        attn_2 = self.conv2_2(attn_2)
+
+        attn = attn + attn_0 + attn_1 + attn_2
+        # Channel Mixing
+        attn = self.conv3(attn)
+
+        # Convolutional Attention
+        x = attn * u
+
+        return x
+
+
+class MSCASpatialAttention(BaseModule):
+    """Spatial Attention Module in Multi-Scale Convolutional Attention Module
+    (MSCA).
+
+    Args:
+        in_channels (int): The dimension of channels.
+        attention_kernel_sizes (list): The size of attention
+            kernel. Defaults: [5, [1, 7], [1, 11], [1, 21]].
+        attention_kernel_paddings (list): The number of
+            corresponding padding value in attention module.
+            Defaults: [2, [0, 3], [0, 5], [0, 10]].
+        act_cfg (dict): Config dict for activation layer in block.
+            Default: dict(type='GELU').
+    """
+
+    def __init__(self,
+                 in_channels,
+                 attention_kernel_sizes=[5, [1, 7], [1, 11], [1, 21]],
+                 attention_kernel_paddings=[2, [0, 3], [0, 5], [0, 10]],
+                 act_cfg=dict(type='GELU')):
+        super().__init__()
+        self.proj_1 = nn.Conv2d(in_channels, in_channels, 1)
+        self.activation = build_activation_layer(act_cfg)
+        self.spatial_gating_unit = MSCAAttention(in_channels,
+                                                 attention_kernel_sizes,
+                                                 attention_kernel_paddings)
+        self.proj_2 = nn.Conv2d(in_channels, in_channels, 1)
+
+    def forward(self, x):
+        """Forward function."""
+
+        shorcut = x.clone()
+        x = self.proj_1(x)
+        x = self.activation(x)
+        x = self.spatial_gating_unit(x)
+        x = self.proj_2(x)
+        x = x + shorcut
+        return x
+
+
+class MSCABlock(BaseModule):
+    """Basic Multi-Scale Convolutional Attention Block. It leverage the large-
+    kernel attention (LKA) mechanism to build both channel and spatial
+    attention. In each branch, it uses two depth-wise strip convolutions to
+    approximate standard depth-wise convolutions with large kernels. The kernel
+    size for each branch is set to 7, 11, and 21, respectively.
+
+    Args:
+        channels (int): The dimension of channels.
+        attention_kernel_sizes (list): The size of attention
+            kernel. Defaults: [5, [1, 7], [1, 11], [1, 21]].
+        attention_kernel_paddings (list): The number of
+            corresponding padding value in attention module.
+            Defaults: [2, [0, 3], [0, 5], [0, 10]].
+        mlp_ratio (float): The ratio of multiple input dimension to
+            calculate hidden feature in MLP layer. Defaults: 4.0.
+        drop (float): The number of dropout rate in MLP block.
+            Defaults: 0.0.
+        drop_path (float): The ratio of drop paths.
+            Defaults: 0.0.
+        act_cfg (dict): Config dict for activation layer in block.
+            Default: dict(type='GELU').
+        norm_cfg (dict): Config dict for normalization layer.
+            Defaults: dict(type='SyncBN', requires_grad=True).
+    """
+
+    def __init__(self,
+                 channels,
+                 attention_kernel_sizes=[5, [1, 7], [1, 11], [1, 21]],
+                 attention_kernel_paddings=[2, [0, 3], [0, 5], [0, 10]],
+                 mlp_ratio=4.,
+                 drop=0.,
+                 drop_path=0.,
+                 act_cfg=dict(type='GELU'),
+                 norm_cfg=dict(type='SyncBN', requires_grad=True)):
+        super().__init__()
+        self.norm1 = build_norm_layer(norm_cfg, channels)[1]
+        self.attn = MSCASpatialAttention(channels, attention_kernel_sizes,
+                                         attention_kernel_paddings, act_cfg)
+        self.drop_path = DropPath(
+            drop_path) if drop_path > 0. else nn.Identity()
+        self.norm2 = build_norm_layer(norm_cfg, channels)[1]
+        mlp_hidden_channels = int(channels * mlp_ratio)
+        self.mlp = Mlp(
+            in_features=channels,
+            hidden_features=mlp_hidden_channels,
+            act_cfg=act_cfg,
+            drop=drop)
+        layer_scale_init_value = 1e-2
+        self.layer_scale_1 = nn.Parameter(
+            layer_scale_init_value * torch.ones(channels), requires_grad=True)
+        self.layer_scale_2 = nn.Parameter(
+            layer_scale_init_value * torch.ones(channels), requires_grad=True)
+
+    def forward(self, x, H, W):
+        """Forward function."""
+
+        B, N, C = x.shape
+        x = x.permute(0, 2, 1).view(B, C, H, W)
+        x = x + self.drop_path(
+            self.layer_scale_1.unsqueeze(-1).unsqueeze(-1) *
+            self.attn(self.norm1(x)))
+        x = x + self.drop_path(
+            self.layer_scale_2.unsqueeze(-1).unsqueeze(-1) *
+            self.mlp(self.norm2(x)))
+        x = x.view(B, C, N).permute(0, 2, 1)
+        return x
+
+
+class OverlapPatchEmbed(BaseModule):
+    """Image to Patch Embedding.
+
+    Args:
+        patch_size (int): The patch size.
+            Defaults: 7.
+        stride (int): Stride of the convolutional layer.
+            Default: 4.
+        in_channels (int): The number of input channels.
+            Defaults: 3.
+        embed_dims (int): The dimensions of embedding.
+            Defaults: 768.
+        norm_cfg (dict): Config dict for normalization layer.
+            Defaults: dict(type='SyncBN', requires_grad=True).
+    """
+
+    def __init__(self,
+                 patch_size=7,
+                 stride=4,
+                 in_channels=3,
+                 embed_dim=768,
+                 norm_cfg=dict(type='SyncBN', requires_grad=True)):
+        super().__init__()
+
+        self.proj = nn.Conv2d(
+            in_channels,
+            embed_dim,
+            kernel_size=patch_size,
+            stride=stride,
+            padding=patch_size // 2)
+        self.norm = build_norm_layer(norm_cfg, embed_dim)[1]
+
+    def forward(self, x):
+        """Forward function."""
+
+        x = self.proj(x)
+        _, _, H, W = x.shape
+        x = self.norm(x)
+
+        x = x.flatten(2).transpose(1, 2)
+
+        return x, H, W
+
+
+@MODELS.register_module()
+class MSCAN(BaseModule):
+    """SegNeXt Multi-Scale Convolutional Attention Network (MCSAN) backbone.
+
+    This backbone is the implementation of `SegNeXt: Rethinking
+    Convolutional Attention Design for Semantic
+    Segmentation <https://arxiv.org/abs/2209.08575>`_.
+    Inspiration from https://github.com/visual-attention-network/segnext.
+
+    Args:
+        in_channels (int): The number of input channels. Defaults: 3.
+        embed_dims (list[int]): Embedding dimension.
+            Defaults: [64, 128, 256, 512].
+        mlp_ratios (list[int]): Ratio of mlp hidden dim to embedding dim.
+            Defaults: [4, 4, 4, 4].
+        drop_rate (float): Dropout rate. Defaults: 0.
+        drop_path_rate (float): Stochastic depth rate. Defaults: 0.
+        depths (list[int]): Depths of each Swin Transformer stage.
+            Default: [3, 4, 6, 3].
+        num_stages (int): MSCAN stages. Default: 4.
+        attention_kernel_sizes (list): Size of attention kernel in
+            Attention Module (Figure 2(b) of original paper).
+            Defaults: [5, [1, 7], [1, 11], [1, 21]].
+        attention_kernel_paddings (list): Size of attention paddings
+            in Attention Module (Figure 2(b) of original paper).
+            Defaults: [2, [0, 3], [0, 5], [0, 10]].
+        norm_cfg (dict): Config of norm layers.
+            Defaults: dict(type='SyncBN', requires_grad=True).
+        pretrained (str, optional): model pretrained path.
+            Default: None.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    """
+
+    def __init__(self,
+                 in_channels=3,
+                 embed_dims=[64, 128, 256, 512],
+                 mlp_ratios=[4, 4, 4, 4],
+                 drop_rate=0.,
+                 drop_path_rate=0.,
+                 depths=[3, 4, 6, 3],
+                 num_stages=4,
+                 attention_kernel_sizes=[5, [1, 7], [1, 11], [1, 21]],
+                 attention_kernel_paddings=[2, [0, 3], [0, 5], [0, 10]],
+                 act_cfg=dict(type='GELU'),
+                 norm_cfg=dict(type='SyncBN', requires_grad=True),
+                 pretrained=None,
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+
+        assert not (init_cfg and pretrained), \
+            'init_cfg and pretrained cannot be set at the same time'
+        if isinstance(pretrained, str):
+            warnings.warn('DeprecationWarning: pretrained is deprecated, '
+                          'please use "init_cfg" instead')
+            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
+        elif pretrained is not None:
+            raise TypeError('pretrained must be a str or None')
+
+        self.depths = depths
+        self.num_stages = num_stages
+
+        dpr = [
+            x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))
+        ]  # stochastic depth decay rule
+        cur = 0
+
+        for i in range(num_stages):
+            if i == 0:
+                patch_embed = StemConv(3, embed_dims[0], norm_cfg=norm_cfg)
+            else:
+                patch_embed = OverlapPatchEmbed(
+                    patch_size=7 if i == 0 else 3,
+                    stride=4 if i == 0 else 2,
+                    in_channels=in_channels if i == 0 else embed_dims[i - 1],
+                    embed_dim=embed_dims[i],
+                    norm_cfg=norm_cfg)
+
+            block = nn.ModuleList([
+                MSCABlock(
+                    channels=embed_dims[i],
+                    attention_kernel_sizes=attention_kernel_sizes,
+                    attention_kernel_paddings=attention_kernel_paddings,
+                    mlp_ratio=mlp_ratios[i],
+                    drop=drop_rate,
+                    drop_path=dpr[cur + j],
+                    act_cfg=act_cfg,
+                    norm_cfg=norm_cfg) for j in range(depths[i])
+            ])
+            norm = nn.LayerNorm(embed_dims[i])
+            cur += depths[i]
+
+            setattr(self, f'patch_embed{i + 1}', patch_embed)
+            setattr(self, f'block{i + 1}', block)
+            setattr(self, f'norm{i + 1}', norm)
+
+    def init_weights(self):
+        """Initialize modules of MSCAN."""
+
+        print('init cfg', self.init_cfg)
+        if self.init_cfg is None:
+            for m in self.modules():
+                if isinstance(m, nn.Linear):
+                    trunc_normal_init(m, std=.02, bias=0.)
+                elif isinstance(m, nn.LayerNorm):
+                    constant_init(m, val=1.0, bias=0.)
+                elif isinstance(m, nn.Conv2d):
+                    fan_out = m.kernel_size[0] * m.kernel_size[
+                        1] * m.out_channels
+                    fan_out //= m.groups
+                    normal_init(
+                        m, mean=0, std=math.sqrt(2.0 / fan_out), bias=0)
+        else:
+            super().init_weights()
+
+    def forward(self, x):
+        """Forward function."""
+
+        B = x.shape[0]
+        outs = []
+
+        for i in range(self.num_stages):
+            patch_embed = getattr(self, f'patch_embed{i + 1}')
+            block = getattr(self, f'block{i + 1}')
+            norm = getattr(self, f'norm{i + 1}')
+            x, H, W = patch_embed(x)
+            for blk in block:
+                x = blk(x, H, W)
+            x = norm(x)
+            x = x.reshape(B, H, W, -1).permute(0, 3, 1, 2).contiguous()
+            outs.append(x)
+
+        return outs
diff --git a/mmsegmentation/mmseg/models/backbones/pidnet.py b/mmsegmentation/mmseg/models/backbones/pidnet.py
new file mode 100644
index 0000000..0b711a3
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/pidnet.py
@@ -0,0 +1,522 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Tuple, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule
+from mmengine.runner import CheckpointLoader
+from torch import Tensor
+
+from mmseg.registry import MODELS
+from mmseg.utils import OptConfigType
+from ..utils import DAPPM, PAPPM, BasicBlock, Bottleneck
+
+
+class PagFM(BaseModule):
+    """Pixel-attention-guided fusion module.
+
+    Args:
+        in_channels (int): The number of input channels.
+        channels (int): The number of channels.
+        after_relu (bool): Whether to use ReLU before attention.
+            Default: False.
+        with_channel (bool): Whether to use channel attention.
+            Default: False.
+        upsample_mode (str): The mode of upsample. Default: 'bilinear'.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN').
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(typ='ReLU', inplace=True).
+        init_cfg (dict): Config dict for initialization. Default: None.
+    """
+
+    def __init__(self,
+                 in_channels: int,
+                 channels: int,
+                 after_relu: bool = False,
+                 with_channel: bool = False,
+                 upsample_mode: str = 'bilinear',
+                 norm_cfg: OptConfigType = dict(type='BN'),
+                 act_cfg: OptConfigType = dict(typ='ReLU', inplace=True),
+                 init_cfg: OptConfigType = None):
+        super().__init__(init_cfg)
+        self.after_relu = after_relu
+        self.with_channel = with_channel
+        self.upsample_mode = upsample_mode
+        self.f_i = ConvModule(
+            in_channels, channels, 1, norm_cfg=norm_cfg, act_cfg=None)
+        self.f_p = ConvModule(
+            in_channels, channels, 1, norm_cfg=norm_cfg, act_cfg=None)
+        if with_channel:
+            self.up = ConvModule(
+                channels, in_channels, 1, norm_cfg=norm_cfg, act_cfg=None)
+        if after_relu:
+            self.relu = MODELS.build(act_cfg)
+
+    def forward(self, x_p: Tensor, x_i: Tensor) -> Tensor:
+        """Forward function.
+
+        Args:
+            x_p (Tensor): The featrue map from P branch.
+            x_i (Tensor): The featrue map from I branch.
+
+        Returns:
+            Tensor: The feature map with pixel-attention-guided fusion.
+        """
+        if self.after_relu:
+            x_p = self.relu(x_p)
+            x_i = self.relu(x_i)
+
+        f_i = self.f_i(x_i)
+        f_i = F.interpolate(
+            f_i,
+            size=x_p.shape[2:],
+            mode=self.upsample_mode,
+            align_corners=False)
+
+        f_p = self.f_p(x_p)
+
+        if self.with_channel:
+            sigma = torch.sigmoid(self.up(f_p * f_i))
+        else:
+            sigma = torch.sigmoid(torch.sum(f_p * f_i, dim=1).unsqueeze(1))
+
+        x_i = F.interpolate(
+            x_i,
+            size=x_p.shape[2:],
+            mode=self.upsample_mode,
+            align_corners=False)
+
+        out = sigma * x_i + (1 - sigma) * x_p
+        return out
+
+
+class Bag(BaseModule):
+    """Boundary-attention-guided fusion module.
+
+    Args:
+        in_channels (int): The number of input channels.
+        out_channels (int): The number of output channels.
+        kernel_size (int): The kernel size of the convolution. Default: 3.
+        padding (int): The padding of the convolution. Default: 1.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN').
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='ReLU', inplace=True).
+        conv_cfg (dict): Config dict for convolution layer.
+            Default: dict(order=('norm', 'act', 'conv')).
+        init_cfg (dict): Config dict for initialization. Default: None.
+    """
+
+    def __init__(self,
+                 in_channels: int,
+                 out_channels: int,
+                 kernel_size: int = 3,
+                 padding: int = 1,
+                 norm_cfg: OptConfigType = dict(type='BN'),
+                 act_cfg: OptConfigType = dict(type='ReLU', inplace=True),
+                 conv_cfg: OptConfigType = dict(order=('norm', 'act', 'conv')),
+                 init_cfg: OptConfigType = None):
+        super().__init__(init_cfg)
+
+        self.conv = ConvModule(
+            in_channels,
+            out_channels,
+            kernel_size,
+            padding=padding,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg,
+            **conv_cfg)
+
+    def forward(self, x_p: Tensor, x_i: Tensor, x_d: Tensor) -> Tensor:
+        """Forward function.
+
+        Args:
+            x_p (Tensor): The featrue map from P branch.
+            x_i (Tensor): The featrue map from I branch.
+            x_d (Tensor): The featrue map from D branch.
+
+        Returns:
+            Tensor: The feature map with boundary-attention-guided fusion.
+        """
+        sigma = torch.sigmoid(x_d)
+        return self.conv(sigma * x_p + (1 - sigma) * x_i)
+
+
+class LightBag(BaseModule):
+    """Light Boundary-attention-guided fusion module.
+
+    Args:
+        in_channels (int): The number of input channels.
+        out_channels (int): The number of output channels.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN').
+        act_cfg (dict): Config dict for activation layer. Default: None.
+        init_cfg (dict): Config dict for initialization. Default: None.
+    """
+
+    def __init__(self,
+                 in_channels: int,
+                 out_channels: int,
+                 norm_cfg: OptConfigType = dict(type='BN'),
+                 act_cfg: OptConfigType = None,
+                 init_cfg: OptConfigType = None):
+        super().__init__(init_cfg)
+        self.f_p = ConvModule(
+            in_channels,
+            out_channels,
+            kernel_size=1,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        self.f_i = ConvModule(
+            in_channels,
+            out_channels,
+            kernel_size=1,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+
+    def forward(self, x_p: Tensor, x_i: Tensor, x_d: Tensor) -> Tensor:
+        """Forward function.
+        Args:
+            x_p (Tensor): The featrue map from P branch.
+            x_i (Tensor): The featrue map from I branch.
+            x_d (Tensor): The featrue map from D branch.
+
+        Returns:
+            Tensor: The feature map with light boundary-attention-guided
+                fusion.
+        """
+        sigma = torch.sigmoid(x_d)
+
+        f_p = self.f_p((1 - sigma) * x_i + x_p)
+        f_i = self.f_i(x_i + sigma * x_p)
+
+        return f_p + f_i
+
+
+@MODELS.register_module()
+class PIDNet(BaseModule):
+    """PIDNet backbone.
+
+    This backbone is the implementation of `PIDNet: A Real-time Semantic
+    Segmentation Network Inspired from PID Controller
+    <https://arxiv.org/abs/2206.02066>`_.
+    Modified from https://github.com/XuJiacong/PIDNet.
+
+    Licensed under the MIT License.
+
+    Args:
+        in_channels (int): The number of input channels. Default: 3.
+        channels (int): The number of channels in the stem layer. Default: 64.
+        ppm_channels (int): The number of channels in the PPM layer.
+            Default: 96.
+        num_stem_blocks (int): The number of blocks in the stem layer.
+            Default: 2.
+        num_branch_blocks (int): The number of blocks in the branch layer.
+            Default: 3.
+        align_corners (bool): The align_corners argument of F.interpolate.
+            Default: False.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN').
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='ReLU', inplace=True).
+        init_cfg (dict): Config dict for initialization. Default: None.
+    """
+
+    def __init__(self,
+                 in_channels: int = 3,
+                 channels: int = 64,
+                 ppm_channels: int = 96,
+                 num_stem_blocks: int = 2,
+                 num_branch_blocks: int = 3,
+                 align_corners: bool = False,
+                 norm_cfg: OptConfigType = dict(type='BN'),
+                 act_cfg: OptConfigType = dict(type='ReLU', inplace=True),
+                 init_cfg: OptConfigType = None,
+                 **kwargs):
+        super().__init__(init_cfg)
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+        self.align_corners = align_corners
+
+        # stem layer
+        self.stem = self._make_stem_layer(in_channels, channels,
+                                          num_stem_blocks)
+        self.relu = nn.ReLU()
+
+        # I Branch
+        self.i_branch_layers = nn.ModuleList()
+        for i in range(3):
+            self.i_branch_layers.append(
+                self._make_layer(
+                    block=BasicBlock if i < 2 else Bottleneck,
+                    in_channels=channels * 2**(i + 1),
+                    channels=channels * 8 if i > 0 else channels * 4,
+                    num_blocks=num_branch_blocks if i < 2 else 2,
+                    stride=2))
+
+        # P Branch
+        self.p_branch_layers = nn.ModuleList()
+        for i in range(3):
+            self.p_branch_layers.append(
+                self._make_layer(
+                    block=BasicBlock if i < 2 else Bottleneck,
+                    in_channels=channels * 2,
+                    channels=channels * 2,
+                    num_blocks=num_stem_blocks if i < 2 else 1))
+        self.compression_1 = ConvModule(
+            channels * 4,
+            channels * 2,
+            kernel_size=1,
+            bias=False,
+            norm_cfg=norm_cfg,
+            act_cfg=None)
+        self.compression_2 = ConvModule(
+            channels * 8,
+            channels * 2,
+            kernel_size=1,
+            bias=False,
+            norm_cfg=norm_cfg,
+            act_cfg=None)
+        self.pag_1 = PagFM(channels * 2, channels)
+        self.pag_2 = PagFM(channels * 2, channels)
+
+        # D Branch
+        if num_stem_blocks == 2:
+            self.d_branch_layers = nn.ModuleList([
+                self._make_single_layer(BasicBlock, channels * 2, channels),
+                self._make_layer(Bottleneck, channels, channels, 1)
+            ])
+            channel_expand = 1
+            spp_module = PAPPM
+            dfm_module = LightBag
+            act_cfg_dfm = None
+        else:
+            self.d_branch_layers = nn.ModuleList([
+                self._make_single_layer(BasicBlock, channels * 2,
+                                        channels * 2),
+                self._make_single_layer(BasicBlock, channels * 2, channels * 2)
+            ])
+            channel_expand = 2
+            spp_module = DAPPM
+            dfm_module = Bag
+            act_cfg_dfm = act_cfg
+
+        self.diff_1 = ConvModule(
+            channels * 4,
+            channels * channel_expand,
+            kernel_size=3,
+            padding=1,
+            bias=False,
+            norm_cfg=norm_cfg,
+            act_cfg=None)
+        self.diff_2 = ConvModule(
+            channels * 8,
+            channels * 2,
+            kernel_size=3,
+            padding=1,
+            bias=False,
+            norm_cfg=norm_cfg,
+            act_cfg=None)
+
+        self.spp = spp_module(
+            channels * 16, ppm_channels, channels * 4, num_scales=5)
+        self.dfm = dfm_module(
+            channels * 4, channels * 4, norm_cfg=norm_cfg, act_cfg=act_cfg_dfm)
+
+        self.d_branch_layers.append(
+            self._make_layer(Bottleneck, channels * 2, channels * 2, 1))
+
+    def _make_stem_layer(self, in_channels: int, channels: int,
+                         num_blocks: int) -> nn.Sequential:
+        """Make stem layer.
+
+        Args:
+            in_channels (int): Number of input channels.
+            channels (int): Number of output channels.
+            num_blocks (int): Number of blocks.
+
+        Returns:
+            nn.Sequential: The stem layer.
+        """
+
+        layers = [
+            ConvModule(
+                in_channels,
+                channels,
+                kernel_size=3,
+                stride=2,
+                padding=1,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg),
+            ConvModule(
+                channels,
+                channels,
+                kernel_size=3,
+                stride=2,
+                padding=1,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg)
+        ]
+
+        layers.append(
+            self._make_layer(BasicBlock, channels, channels, num_blocks))
+        layers.append(nn.ReLU())
+        layers.append(
+            self._make_layer(
+                BasicBlock, channels, channels * 2, num_blocks, stride=2))
+        layers.append(nn.ReLU())
+
+        return nn.Sequential(*layers)
+
+    def _make_layer(self,
+                    block: BasicBlock,
+                    in_channels: int,
+                    channels: int,
+                    num_blocks: int,
+                    stride: int = 1) -> nn.Sequential:
+        """Make layer for PIDNet backbone.
+        Args:
+            block (BasicBlock): Basic block.
+            in_channels (int): Number of input channels.
+            channels (int): Number of output channels.
+            num_blocks (int): Number of blocks.
+            stride (int): Stride of the first block. Default: 1.
+
+        Returns:
+            nn.Sequential: The Branch Layer.
+        """
+        downsample = None
+        if stride != 1 or in_channels != channels * block.expansion:
+            downsample = ConvModule(
+                in_channels,
+                channels * block.expansion,
+                kernel_size=1,
+                stride=stride,
+                norm_cfg=self.norm_cfg,
+                act_cfg=None)
+
+        layers = [block(in_channels, channels, stride, downsample)]
+        in_channels = channels * block.expansion
+        for i in range(1, num_blocks):
+            layers.append(
+                block(
+                    in_channels,
+                    channels,
+                    stride=1,
+                    act_cfg_out=None if i == num_blocks - 1 else self.act_cfg))
+        return nn.Sequential(*layers)
+
+    def _make_single_layer(self,
+                           block: Union[BasicBlock, Bottleneck],
+                           in_channels: int,
+                           channels: int,
+                           stride: int = 1) -> nn.Module:
+        """Make single layer for PIDNet backbone.
+        Args:
+            block (BasicBlock or Bottleneck): Basic block or Bottleneck.
+            in_channels (int): Number of input channels.
+            channels (int): Number of output channels.
+            stride (int): Stride of the first block. Default: 1.
+
+        Returns:
+            nn.Module
+        """
+
+        downsample = None
+        if stride != 1 or in_channels != channels * block.expansion:
+            downsample = ConvModule(
+                in_channels,
+                channels * block.expansion,
+                kernel_size=1,
+                stride=stride,
+                norm_cfg=self.norm_cfg,
+                act_cfg=None)
+        return block(
+            in_channels, channels, stride, downsample, act_cfg_out=None)
+
+    def init_weights(self):
+        """Initialize the weights in backbone.
+
+        Since the D branch is not initialized by the pre-trained model, we
+        initialize it with the same method as the ResNet.
+        """
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(
+                    m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+        if self.init_cfg is not None:
+            assert 'checkpoint' in self.init_cfg, f'Only support ' \
+                                                  f'specify `Pretrained` in ' \
+                                                  f'`init_cfg` in ' \
+                                                  f'{self.__class__.__name__} '
+            ckpt = CheckpointLoader.load_checkpoint(
+                self.init_cfg['checkpoint'], map_location='cpu')
+            self.load_state_dict(ckpt, strict=False)
+
+    def forward(self, x: Tensor) -> Union[Tensor, Tuple[Tensor]]:
+        """Forward function.
+
+        Args:
+            x (Tensor): Input tensor with shape (B, C, H, W).
+
+        Returns:
+            Tensor or tuple[Tensor]: If self.training is True, return
+                tuple[Tensor], else return Tensor.
+        """
+        w_out = x.shape[-1] // 8
+        h_out = x.shape[-2] // 8
+
+        # stage 0-2
+        x = self.stem(x)
+
+        # stage 3
+        x_i = self.relu(self.i_branch_layers[0](x))
+        x_p = self.p_branch_layers[0](x)
+        x_d = self.d_branch_layers[0](x)
+
+        comp_i = self.compression_1(x_i)
+        x_p = self.pag_1(x_p, comp_i)
+        diff_i = self.diff_1(x_i)
+        x_d += F.interpolate(
+            diff_i,
+            size=[h_out, w_out],
+            mode='bilinear',
+            align_corners=self.align_corners)
+        if self.training:
+            temp_p = x_p.clone()
+
+        # stage 4
+        x_i = self.relu(self.i_branch_layers[1](x_i))
+        x_p = self.p_branch_layers[1](self.relu(x_p))
+        x_d = self.d_branch_layers[1](self.relu(x_d))
+
+        comp_i = self.compression_2(x_i)
+        x_p = self.pag_2(x_p, comp_i)
+        diff_i = self.diff_2(x_i)
+        x_d += F.interpolate(
+            diff_i,
+            size=[h_out, w_out],
+            mode='bilinear',
+            align_corners=self.align_corners)
+        if self.training:
+            temp_d = x_d.clone()
+
+        # stage 5
+        x_i = self.i_branch_layers[2](x_i)
+        x_p = self.p_branch_layers[2](self.relu(x_p))
+        x_d = self.d_branch_layers[2](self.relu(x_d))
+
+        x_i = self.spp(x_i)
+        x_i = F.interpolate(
+            x_i,
+            size=[h_out, w_out],
+            mode='bilinear',
+            align_corners=self.align_corners)
+        out = self.dfm(x_p, x_i, x_d)
+        return (temp_p, out, temp_d) if self.training else out
diff --git a/mmsegmentation/mmseg/models/backbones/resnest.py b/mmsegmentation/mmseg/models/backbones/resnest.py
new file mode 100644
index 0000000..3cc380b
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/resnest.py
@@ -0,0 +1,318 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.checkpoint as cp
+from mmcv.cnn import build_conv_layer, build_norm_layer
+
+from mmseg.registry import MODELS
+from ..utils import ResLayer
+from .resnet import Bottleneck as _Bottleneck
+from .resnet import ResNetV1d
+
+
+class RSoftmax(nn.Module):
+    """Radix Softmax module in ``SplitAttentionConv2d``.
+
+    Args:
+        radix (int): Radix of input.
+        groups (int): Groups of input.
+    """
+
+    def __init__(self, radix, groups):
+        super().__init__()
+        self.radix = radix
+        self.groups = groups
+
+    def forward(self, x):
+        batch = x.size(0)
+        if self.radix > 1:
+            x = x.view(batch, self.groups, self.radix, -1).transpose(1, 2)
+            x = F.softmax(x, dim=1)
+            x = x.reshape(batch, -1)
+        else:
+            x = torch.sigmoid(x)
+        return x
+
+
+class SplitAttentionConv2d(nn.Module):
+    """Split-Attention Conv2d in ResNeSt.
+
+    Args:
+        in_channels (int): Same as nn.Conv2d.
+        out_channels (int): Same as nn.Conv2d.
+        kernel_size (int | tuple[int]): Same as nn.Conv2d.
+        stride (int | tuple[int]): Same as nn.Conv2d.
+        padding (int | tuple[int]): Same as nn.Conv2d.
+        dilation (int | tuple[int]): Same as nn.Conv2d.
+        groups (int): Same as nn.Conv2d.
+        radix (int): Radix of SpltAtConv2d. Default: 2
+        reduction_factor (int): Reduction factor of inter_channels. Default: 4.
+        conv_cfg (dict): Config dict for convolution layer. Default: None,
+            which means using conv2d.
+        norm_cfg (dict): Config dict for normalization layer. Default: None.
+        dcn (dict): Config dict for DCN. Default: None.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 channels,
+                 kernel_size,
+                 stride=1,
+                 padding=0,
+                 dilation=1,
+                 groups=1,
+                 radix=2,
+                 reduction_factor=4,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 dcn=None):
+        super().__init__()
+        inter_channels = max(in_channels * radix // reduction_factor, 32)
+        self.radix = radix
+        self.groups = groups
+        self.channels = channels
+        self.with_dcn = dcn is not None
+        self.dcn = dcn
+        fallback_on_stride = False
+        if self.with_dcn:
+            fallback_on_stride = self.dcn.pop('fallback_on_stride', False)
+        if self.with_dcn and not fallback_on_stride:
+            assert conv_cfg is None, 'conv_cfg must be None for DCN'
+            conv_cfg = dcn
+        self.conv = build_conv_layer(
+            conv_cfg,
+            in_channels,
+            channels * radix,
+            kernel_size,
+            stride=stride,
+            padding=padding,
+            dilation=dilation,
+            groups=groups * radix,
+            bias=False)
+        self.norm0_name, norm0 = build_norm_layer(
+            norm_cfg, channels * radix, postfix=0)
+        self.add_module(self.norm0_name, norm0)
+        self.relu = nn.ReLU(inplace=True)
+        self.fc1 = build_conv_layer(
+            None, channels, inter_channels, 1, groups=self.groups)
+        self.norm1_name, norm1 = build_norm_layer(
+            norm_cfg, inter_channels, postfix=1)
+        self.add_module(self.norm1_name, norm1)
+        self.fc2 = build_conv_layer(
+            None, inter_channels, channels * radix, 1, groups=self.groups)
+        self.rsoftmax = RSoftmax(radix, groups)
+
+    @property
+    def norm0(self):
+        """nn.Module: the normalization layer named "norm0" """
+        return getattr(self, self.norm0_name)
+
+    @property
+    def norm1(self):
+        """nn.Module: the normalization layer named "norm1" """
+        return getattr(self, self.norm1_name)
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.norm0(x)
+        x = self.relu(x)
+
+        batch, rchannel = x.shape[:2]
+        batch = x.size(0)
+        if self.radix > 1:
+            splits = x.view(batch, self.radix, -1, *x.shape[2:])
+            gap = splits.sum(dim=1)
+        else:
+            gap = x
+        gap = F.adaptive_avg_pool2d(gap, 1)
+        gap = self.fc1(gap)
+
+        gap = self.norm1(gap)
+        gap = self.relu(gap)
+
+        atten = self.fc2(gap)
+        atten = self.rsoftmax(atten).view(batch, -1, 1, 1)
+
+        if self.radix > 1:
+            attens = atten.view(batch, self.radix, -1, *atten.shape[2:])
+            out = torch.sum(attens * splits, dim=1)
+        else:
+            out = atten * x
+        return out.contiguous()
+
+
+class Bottleneck(_Bottleneck):
+    """Bottleneck block for ResNeSt.
+
+    Args:
+        inplane (int): Input planes of this block.
+        planes (int): Middle planes of this block.
+        groups (int): Groups of conv2.
+        width_per_group (int): Width per group of conv2. 64x4d indicates
+            ``groups=64, width_per_group=4`` and 32x8d indicates
+            ``groups=32, width_per_group=8``.
+        radix (int): Radix of SpltAtConv2d. Default: 2
+        reduction_factor (int): Reduction factor of inter_channels in
+            SplitAttentionConv2d. Default: 4.
+        avg_down_stride (bool): Whether to use average pool for stride in
+            Bottleneck. Default: True.
+        kwargs (dict): Key word arguments for base class.
+    """
+    expansion = 4
+
+    def __init__(self,
+                 inplanes,
+                 planes,
+                 groups=1,
+                 base_width=4,
+                 base_channels=64,
+                 radix=2,
+                 reduction_factor=4,
+                 avg_down_stride=True,
+                 **kwargs):
+        """Bottleneck block for ResNeSt."""
+        super().__init__(inplanes, planes, **kwargs)
+
+        if groups == 1:
+            width = self.planes
+        else:
+            width = math.floor(self.planes *
+                               (base_width / base_channels)) * groups
+
+        self.avg_down_stride = avg_down_stride and self.conv2_stride > 1
+
+        self.norm1_name, norm1 = build_norm_layer(
+            self.norm_cfg, width, postfix=1)
+        self.norm3_name, norm3 = build_norm_layer(
+            self.norm_cfg, self.planes * self.expansion, postfix=3)
+
+        self.conv1 = build_conv_layer(
+            self.conv_cfg,
+            self.inplanes,
+            width,
+            kernel_size=1,
+            stride=self.conv1_stride,
+            bias=False)
+        self.add_module(self.norm1_name, norm1)
+        self.with_modulated_dcn = False
+        self.conv2 = SplitAttentionConv2d(
+            width,
+            width,
+            kernel_size=3,
+            stride=1 if self.avg_down_stride else self.conv2_stride,
+            padding=self.dilation,
+            dilation=self.dilation,
+            groups=groups,
+            radix=radix,
+            reduction_factor=reduction_factor,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            dcn=self.dcn)
+        delattr(self, self.norm2_name)
+
+        if self.avg_down_stride:
+            self.avd_layer = nn.AvgPool2d(3, self.conv2_stride, padding=1)
+
+        self.conv3 = build_conv_layer(
+            self.conv_cfg,
+            width,
+            self.planes * self.expansion,
+            kernel_size=1,
+            bias=False)
+        self.add_module(self.norm3_name, norm3)
+
+    def forward(self, x):
+
+        def _inner_forward(x):
+            identity = x
+
+            out = self.conv1(x)
+            out = self.norm1(out)
+            out = self.relu(out)
+
+            if self.with_plugins:
+                out = self.forward_plugin(out, self.after_conv1_plugin_names)
+
+            out = self.conv2(out)
+
+            if self.avg_down_stride:
+                out = self.avd_layer(out)
+
+            if self.with_plugins:
+                out = self.forward_plugin(out, self.after_conv2_plugin_names)
+
+            out = self.conv3(out)
+            out = self.norm3(out)
+
+            if self.with_plugins:
+                out = self.forward_plugin(out, self.after_conv3_plugin_names)
+
+            if self.downsample is not None:
+                identity = self.downsample(x)
+
+            out += identity
+
+            return out
+
+        if self.with_cp and x.requires_grad:
+            out = cp.checkpoint(_inner_forward, x)
+        else:
+            out = _inner_forward(x)
+
+        out = self.relu(out)
+
+        return out
+
+
+@MODELS.register_module()
+class ResNeSt(ResNetV1d):
+    """ResNeSt backbone.
+
+    This backbone is the implementation of `ResNeSt:
+    Split-Attention Networks <https://arxiv.org/abs/2004.08955>`_.
+
+    Args:
+        groups (int): Number of groups of Bottleneck. Default: 1
+        base_width (int): Base width of Bottleneck. Default: 4
+        radix (int): Radix of SpltAtConv2d. Default: 2
+        reduction_factor (int): Reduction factor of inter_channels in
+            SplitAttentionConv2d. Default: 4.
+        avg_down_stride (bool): Whether to use average pool for stride in
+            Bottleneck. Default: True.
+        kwargs (dict): Keyword arguments for ResNet.
+    """
+
+    arch_settings = {
+        50: (Bottleneck, (3, 4, 6, 3)),
+        101: (Bottleneck, (3, 4, 23, 3)),
+        152: (Bottleneck, (3, 8, 36, 3)),
+        200: (Bottleneck, (3, 24, 36, 3))
+    }
+
+    def __init__(self,
+                 groups=1,
+                 base_width=4,
+                 radix=2,
+                 reduction_factor=4,
+                 avg_down_stride=True,
+                 **kwargs):
+        self.groups = groups
+        self.base_width = base_width
+        self.radix = radix
+        self.reduction_factor = reduction_factor
+        self.avg_down_stride = avg_down_stride
+        super().__init__(**kwargs)
+
+    def make_res_layer(self, **kwargs):
+        """Pack all blocks in a stage into a ``ResLayer``."""
+        return ResLayer(
+            groups=self.groups,
+            base_width=self.base_width,
+            base_channels=self.base_channels,
+            radix=self.radix,
+            reduction_factor=self.reduction_factor,
+            avg_down_stride=self.avg_down_stride,
+            **kwargs)
diff --git a/mmsegmentation/mmseg/models/backbones/resnet.py b/mmsegmentation/mmseg/models/backbones/resnet.py
new file mode 100644
index 0000000..9226c90
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/resnet.py
@@ -0,0 +1,712 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+import torch.nn as nn
+import torch.utils.checkpoint as cp
+from mmcv.cnn import build_conv_layer, build_norm_layer, build_plugin_layer
+from mmengine.model import BaseModule
+from mmengine.utils.dl_utils.parrots_wrapper import _BatchNorm
+
+from mmseg.registry import MODELS
+from ..utils import ResLayer
+
+
+class BasicBlock(BaseModule):
+    """Basic block for ResNet."""
+
+    expansion = 1
+
+    def __init__(self,
+                 inplanes,
+                 planes,
+                 stride=1,
+                 dilation=1,
+                 downsample=None,
+                 style='pytorch',
+                 with_cp=False,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 dcn=None,
+                 plugins=None,
+                 init_cfg=None):
+        super().__init__(init_cfg)
+        assert dcn is None, 'Not implemented yet.'
+        assert plugins is None, 'Not implemented yet.'
+
+        self.norm1_name, norm1 = build_norm_layer(norm_cfg, planes, postfix=1)
+        self.norm2_name, norm2 = build_norm_layer(norm_cfg, planes, postfix=2)
+
+        self.conv1 = build_conv_layer(
+            conv_cfg,
+            inplanes,
+            planes,
+            3,
+            stride=stride,
+            padding=dilation,
+            dilation=dilation,
+            bias=False)
+        self.add_module(self.norm1_name, norm1)
+        self.conv2 = build_conv_layer(
+            conv_cfg, planes, planes, 3, padding=1, bias=False)
+        self.add_module(self.norm2_name, norm2)
+
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+        self.dilation = dilation
+        self.with_cp = with_cp
+
+    @property
+    def norm1(self):
+        """nn.Module: normalization layer after the first convolution layer"""
+        return getattr(self, self.norm1_name)
+
+    @property
+    def norm2(self):
+        """nn.Module: normalization layer after the second convolution layer"""
+        return getattr(self, self.norm2_name)
+
+    def forward(self, x):
+        """Forward function."""
+
+        def _inner_forward(x):
+            identity = x
+
+            out = self.conv1(x)
+            out = self.norm1(out)
+            out = self.relu(out)
+
+            out = self.conv2(out)
+            out = self.norm2(out)
+
+            if self.downsample is not None:
+                identity = self.downsample(x)
+
+            out += identity
+
+            return out
+
+        if self.with_cp and x.requires_grad:
+            out = cp.checkpoint(_inner_forward, x)
+        else:
+            out = _inner_forward(x)
+
+        out = self.relu(out)
+
+        return out
+
+
+class Bottleneck(BaseModule):
+    """Bottleneck block for ResNet.
+
+    If style is "pytorch", the stride-two layer is the 3x3 conv layer, if it is
+    "caffe", the stride-two layer is the first 1x1 conv layer.
+    """
+
+    expansion = 4
+
+    def __init__(self,
+                 inplanes,
+                 planes,
+                 stride=1,
+                 dilation=1,
+                 downsample=None,
+                 style='pytorch',
+                 with_cp=False,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 dcn=None,
+                 plugins=None,
+                 init_cfg=None):
+        super().__init__(init_cfg)
+        assert style in ['pytorch', 'caffe']
+        assert dcn is None or isinstance(dcn, dict)
+        assert plugins is None or isinstance(plugins, list)
+        if plugins is not None:
+            allowed_position = ['after_conv1', 'after_conv2', 'after_conv3']
+            assert all(p['position'] in allowed_position for p in plugins)
+
+        self.inplanes = inplanes
+        self.planes = planes
+        self.stride = stride
+        self.dilation = dilation
+        self.style = style
+        self.with_cp = with_cp
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.dcn = dcn
+        self.with_dcn = dcn is not None
+        self.plugins = plugins
+        self.with_plugins = plugins is not None
+
+        if self.with_plugins:
+            # collect plugins for conv1/conv2/conv3
+            self.after_conv1_plugins = [
+                plugin['cfg'] for plugin in plugins
+                if plugin['position'] == 'after_conv1'
+            ]
+            self.after_conv2_plugins = [
+                plugin['cfg'] for plugin in plugins
+                if plugin['position'] == 'after_conv2'
+            ]
+            self.after_conv3_plugins = [
+                plugin['cfg'] for plugin in plugins
+                if plugin['position'] == 'after_conv3'
+            ]
+
+        if self.style == 'pytorch':
+            self.conv1_stride = 1
+            self.conv2_stride = stride
+        else:
+            self.conv1_stride = stride
+            self.conv2_stride = 1
+
+        self.norm1_name, norm1 = build_norm_layer(norm_cfg, planes, postfix=1)
+        self.norm2_name, norm2 = build_norm_layer(norm_cfg, planes, postfix=2)
+        self.norm3_name, norm3 = build_norm_layer(
+            norm_cfg, planes * self.expansion, postfix=3)
+
+        self.conv1 = build_conv_layer(
+            conv_cfg,
+            inplanes,
+            planes,
+            kernel_size=1,
+            stride=self.conv1_stride,
+            bias=False)
+        self.add_module(self.norm1_name, norm1)
+        fallback_on_stride = False
+        if self.with_dcn:
+            fallback_on_stride = dcn.pop('fallback_on_stride', False)
+        if not self.with_dcn or fallback_on_stride:
+            self.conv2 = build_conv_layer(
+                conv_cfg,
+                planes,
+                planes,
+                kernel_size=3,
+                stride=self.conv2_stride,
+                padding=dilation,
+                dilation=dilation,
+                bias=False)
+        else:
+            assert self.conv_cfg is None, 'conv_cfg must be None for DCN'
+            self.conv2 = build_conv_layer(
+                dcn,
+                planes,
+                planes,
+                kernel_size=3,
+                stride=self.conv2_stride,
+                padding=dilation,
+                dilation=dilation,
+                bias=False)
+
+        self.add_module(self.norm2_name, norm2)
+        self.conv3 = build_conv_layer(
+            conv_cfg,
+            planes,
+            planes * self.expansion,
+            kernel_size=1,
+            bias=False)
+        self.add_module(self.norm3_name, norm3)
+
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+
+        if self.with_plugins:
+            self.after_conv1_plugin_names = self.make_block_plugins(
+                planes, self.after_conv1_plugins)
+            self.after_conv2_plugin_names = self.make_block_plugins(
+                planes, self.after_conv2_plugins)
+            self.after_conv3_plugin_names = self.make_block_plugins(
+                planes * self.expansion, self.after_conv3_plugins)
+
+    def make_block_plugins(self, in_channels, plugins):
+        """make plugins for block.
+
+        Args:
+            in_channels (int): Input channels of plugin.
+            plugins (list[dict]): List of plugins cfg to build.
+
+        Returns:
+            list[str]: List of the names of plugin.
+        """
+        assert isinstance(plugins, list)
+        plugin_names = []
+        for plugin in plugins:
+            plugin = plugin.copy()
+            name, layer = build_plugin_layer(
+                plugin,
+                in_channels=in_channels,
+                postfix=plugin.pop('postfix', ''))
+            assert not hasattr(self, name), f'duplicate plugin {name}'
+            self.add_module(name, layer)
+            plugin_names.append(name)
+        return plugin_names
+
+    def forward_plugin(self, x, plugin_names):
+        """Forward function for plugins."""
+        out = x
+        for name in plugin_names:
+            out = getattr(self, name)(x)
+        return out
+
+    @property
+    def norm1(self):
+        """nn.Module: normalization layer after the first convolution layer"""
+        return getattr(self, self.norm1_name)
+
+    @property
+    def norm2(self):
+        """nn.Module: normalization layer after the second convolution layer"""
+        return getattr(self, self.norm2_name)
+
+    @property
+    def norm3(self):
+        """nn.Module: normalization layer after the third convolution layer"""
+        return getattr(self, self.norm3_name)
+
+    def forward(self, x):
+        """Forward function."""
+
+        def _inner_forward(x):
+            identity = x
+
+            out = self.conv1(x)
+            out = self.norm1(out)
+            out = self.relu(out)
+
+            if self.with_plugins:
+                out = self.forward_plugin(out, self.after_conv1_plugin_names)
+
+            out = self.conv2(out)
+            out = self.norm2(out)
+            out = self.relu(out)
+
+            if self.with_plugins:
+                out = self.forward_plugin(out, self.after_conv2_plugin_names)
+
+            out = self.conv3(out)
+            out = self.norm3(out)
+
+            if self.with_plugins:
+                out = self.forward_plugin(out, self.after_conv3_plugin_names)
+
+            if self.downsample is not None:
+                identity = self.downsample(x)
+
+            out += identity
+
+            return out
+
+        if self.with_cp and x.requires_grad:
+            out = cp.checkpoint(_inner_forward, x)
+        else:
+            out = _inner_forward(x)
+
+        out = self.relu(out)
+
+        return out
+
+
+@MODELS.register_module()
+class ResNet(BaseModule):
+    """ResNet backbone.
+
+    This backbone is the improved implementation of `Deep Residual Learning
+    for Image Recognition <https://arxiv.org/abs/1512.03385>`_.
+
+    Args:
+        depth (int): Depth of resnet, from {18, 34, 50, 101, 152}.
+        in_channels (int): Number of input image channels. Default: 3.
+        stem_channels (int): Number of stem channels. Default: 64.
+        base_channels (int): Number of base channels of res layer. Default: 64.
+        num_stages (int): Resnet stages, normally 4. Default: 4.
+        strides (Sequence[int]): Strides of the first block of each stage.
+            Default: (1, 2, 2, 2).
+        dilations (Sequence[int]): Dilation of each stage.
+            Default: (1, 1, 1, 1).
+        out_indices (Sequence[int]): Output from which stages.
+            Default: (0, 1, 2, 3).
+        style (str): `pytorch` or `caffe`. If set to "pytorch", the stride-two
+            layer is the 3x3 conv layer, otherwise the stride-two layer is
+            the first 1x1 conv layer. Default: 'pytorch'.
+        deep_stem (bool): Replace 7x7 conv in input stem with 3 3x3 conv.
+            Default: False.
+        avg_down (bool): Use AvgPool instead of stride conv when
+            downsampling in the bottleneck. Default: False.
+        frozen_stages (int): Stages to be frozen (stop grad and set eval mode).
+            -1 means not freezing any parameters. Default: -1.
+        conv_cfg (dict | None): Dictionary to construct and config conv layer.
+            When conv_cfg is None, cfg will be set to dict(type='Conv2d').
+            Default: None.
+        norm_cfg (dict): Dictionary to construct and config norm layer.
+            Default: dict(type='BN', requires_grad=True).
+        norm_eval (bool): Whether to set norm layers to eval mode, namely,
+            freeze running stats (mean and var). Note: Effect on Batch Norm
+            and its variants only. Default: False.
+        dcn (dict | None): Dictionary to construct and config DCN conv layer.
+            When dcn is not None, conv_cfg must be None. Default: None.
+        stage_with_dcn (Sequence[bool]): Whether to set DCN conv for each
+            stage. The length of stage_with_dcn is equal to num_stages.
+            Default: (False, False, False, False).
+        plugins (list[dict]): List of plugins for stages, each dict contains:
+
+            - cfg (dict, required): Cfg dict to build plugin.
+
+            - position (str, required): Position inside block to insert plugin,
+            options: 'after_conv1', 'after_conv2', 'after_conv3'.
+
+            - stages (tuple[bool], optional): Stages to apply plugin, length
+            should be same as 'num_stages'.
+            Default: None.
+        multi_grid (Sequence[int]|None): Multi grid dilation rates of last
+            stage. Default: None.
+        contract_dilation (bool): Whether contract first dilation of each layer
+            Default: False.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed. Default: False.
+        zero_init_residual (bool): Whether to use zero init for last norm layer
+            in resblocks to let them behave as identity. Default: True.
+        pretrained (str, optional): model pretrained path. Default: None.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+
+    Example:
+        >>> from mmseg.models import ResNet
+        >>> import torch
+        >>> self = ResNet(depth=18)
+        >>> self.eval()
+        >>> inputs = torch.rand(1, 3, 32, 32)
+        >>> level_outputs = self.forward(inputs)
+        >>> for level_out in level_outputs:
+        ...     print(tuple(level_out.shape))
+        (1, 64, 8, 8)
+        (1, 128, 4, 4)
+        (1, 256, 2, 2)
+        (1, 512, 1, 1)
+    """
+
+    arch_settings = {
+        18: (BasicBlock, (2, 2, 2, 2)),
+        34: (BasicBlock, (3, 4, 6, 3)),
+        50: (Bottleneck, (3, 4, 6, 3)),
+        101: (Bottleneck, (3, 4, 23, 3)),
+        152: (Bottleneck, (3, 8, 36, 3))
+    }
+
+    def __init__(self,
+                 depth,
+                 in_channels=3,
+                 stem_channels=64,
+                 base_channels=64,
+                 num_stages=4,
+                 strides=(1, 2, 2, 2),
+                 dilations=(1, 1, 1, 1),
+                 out_indices=(0, 1, 2, 3),
+                 style='pytorch',
+                 deep_stem=False,
+                 avg_down=False,
+                 frozen_stages=-1,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN', requires_grad=True),
+                 norm_eval=False,
+                 dcn=None,
+                 stage_with_dcn=(False, False, False, False),
+                 plugins=None,
+                 multi_grid=None,
+                 contract_dilation=False,
+                 with_cp=False,
+                 zero_init_residual=True,
+                 pretrained=None,
+                 init_cfg=None):
+        super().__init__(init_cfg)
+        if depth not in self.arch_settings:
+            raise KeyError(f'invalid depth {depth} for resnet')
+
+        self.pretrained = pretrained
+        self.zero_init_residual = zero_init_residual
+        block_init_cfg = None
+        assert not (init_cfg and pretrained), \
+            'init_cfg and pretrained cannot be setting at the same time'
+        if isinstance(pretrained, str):
+            warnings.warn('DeprecationWarning: pretrained is a deprecated, '
+                          'please use "init_cfg" instead')
+            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
+        elif pretrained is None:
+            if init_cfg is None:
+                self.init_cfg = [
+                    dict(type='Kaiming', layer='Conv2d'),
+                    dict(
+                        type='Constant',
+                        val=1,
+                        layer=['_BatchNorm', 'GroupNorm'])
+                ]
+                block = self.arch_settings[depth][0]
+                if self.zero_init_residual:
+                    if block is BasicBlock:
+                        block_init_cfg = dict(
+                            type='Constant',
+                            val=0,
+                            override=dict(name='norm2'))
+                    elif block is Bottleneck:
+                        block_init_cfg = dict(
+                            type='Constant',
+                            val=0,
+                            override=dict(name='norm3'))
+        else:
+            raise TypeError('pretrained must be a str or None')
+
+        self.depth = depth
+        self.stem_channels = stem_channels
+        self.base_channels = base_channels
+        self.num_stages = num_stages
+        assert num_stages >= 1 and num_stages <= 4
+        self.strides = strides
+        self.dilations = dilations
+        assert len(strides) == len(dilations) == num_stages
+        self.out_indices = out_indices
+        assert max(out_indices) < num_stages
+        self.style = style
+        self.deep_stem = deep_stem
+        self.avg_down = avg_down
+        self.frozen_stages = frozen_stages
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.with_cp = with_cp
+        self.norm_eval = norm_eval
+        self.dcn = dcn
+        self.stage_with_dcn = stage_with_dcn
+        if dcn is not None:
+            assert len(stage_with_dcn) == num_stages
+        self.plugins = plugins
+        self.multi_grid = multi_grid
+        self.contract_dilation = contract_dilation
+        self.block, stage_blocks = self.arch_settings[depth]
+        self.stage_blocks = stage_blocks[:num_stages]
+        self.inplanes = stem_channels
+
+        self._make_stem_layer(in_channels, stem_channels)
+
+        self.res_layers = []
+        for i, num_blocks in enumerate(self.stage_blocks):
+            stride = strides[i]
+            dilation = dilations[i]
+            dcn = self.dcn if self.stage_with_dcn[i] else None
+            if plugins is not None:
+                stage_plugins = self.make_stage_plugins(plugins, i)
+            else:
+                stage_plugins = None
+            # multi grid is applied to last layer only
+            stage_multi_grid = multi_grid if i == len(
+                self.stage_blocks) - 1 else None
+            planes = base_channels * 2**i
+            res_layer = self.make_res_layer(
+                block=self.block,
+                inplanes=self.inplanes,
+                planes=planes,
+                num_blocks=num_blocks,
+                stride=stride,
+                dilation=dilation,
+                style=self.style,
+                avg_down=self.avg_down,
+                with_cp=with_cp,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                dcn=dcn,
+                plugins=stage_plugins,
+                multi_grid=stage_multi_grid,
+                contract_dilation=contract_dilation,
+                init_cfg=block_init_cfg)
+            self.inplanes = planes * self.block.expansion
+            layer_name = f'layer{i+1}'
+            self.add_module(layer_name, res_layer)
+            self.res_layers.append(layer_name)
+
+        self._freeze_stages()
+
+        self.feat_dim = self.block.expansion * base_channels * 2**(
+            len(self.stage_blocks) - 1)
+
+    def make_stage_plugins(self, plugins, stage_idx):
+        """make plugins for ResNet 'stage_idx'th stage .
+
+        Currently we support to insert 'context_block',
+        'empirical_attention_block', 'nonlocal_block' into the backbone like
+        ResNet/ResNeXt. They could be inserted after conv1/conv2/conv3 of
+        Bottleneck.
+
+        An example of plugins format could be :
+        >>> plugins=[
+        ...     dict(cfg=dict(type='xxx', arg1='xxx'),
+        ...          stages=(False, True, True, True),
+        ...          position='after_conv2'),
+        ...     dict(cfg=dict(type='yyy'),
+        ...          stages=(True, True, True, True),
+        ...          position='after_conv3'),
+        ...     dict(cfg=dict(type='zzz', postfix='1'),
+        ...          stages=(True, True, True, True),
+        ...          position='after_conv3'),
+        ...     dict(cfg=dict(type='zzz', postfix='2'),
+        ...          stages=(True, True, True, True),
+        ...          position='after_conv3')
+        ... ]
+        >>> self = ResNet(depth=18)
+        >>> stage_plugins = self.make_stage_plugins(plugins, 0)
+        >>> assert len(stage_plugins) == 3
+
+        Suppose 'stage_idx=0', the structure of blocks in the stage would be:
+            conv1-> conv2->conv3->yyy->zzz1->zzz2
+        Suppose 'stage_idx=1', the structure of blocks in the stage would be:
+            conv1-> conv2->xxx->conv3->yyy->zzz1->zzz2
+
+        If stages is missing, the plugin would be applied to all stages.
+
+        Args:
+            plugins (list[dict]): List of plugins cfg to build. The postfix is
+                required if multiple same type plugins are inserted.
+            stage_idx (int): Index of stage to build
+
+        Returns:
+            list[dict]: Plugins for current stage
+        """
+        stage_plugins = []
+        for plugin in plugins:
+            plugin = plugin.copy()
+            stages = plugin.pop('stages', None)
+            assert stages is None or len(stages) == self.num_stages
+            # whether to insert plugin into current stage
+            if stages is None or stages[stage_idx]:
+                stage_plugins.append(plugin)
+
+        return stage_plugins
+
+    def make_res_layer(self, **kwargs):
+        """Pack all blocks in a stage into a ``ResLayer``."""
+        return ResLayer(**kwargs)
+
+    @property
+    def norm1(self):
+        """nn.Module: the normalization layer named "norm1" """
+        return getattr(self, self.norm1_name)
+
+    def _make_stem_layer(self, in_channels, stem_channels):
+        """Make stem layer for ResNet."""
+        if self.deep_stem:
+            self.stem = nn.Sequential(
+                build_conv_layer(
+                    self.conv_cfg,
+                    in_channels,
+                    stem_channels // 2,
+                    kernel_size=3,
+                    stride=2,
+                    padding=1,
+                    bias=False),
+                build_norm_layer(self.norm_cfg, stem_channels // 2)[1],
+                nn.ReLU(inplace=True),
+                build_conv_layer(
+                    self.conv_cfg,
+                    stem_channels // 2,
+                    stem_channels // 2,
+                    kernel_size=3,
+                    stride=1,
+                    padding=1,
+                    bias=False),
+                build_norm_layer(self.norm_cfg, stem_channels // 2)[1],
+                nn.ReLU(inplace=True),
+                build_conv_layer(
+                    self.conv_cfg,
+                    stem_channels // 2,
+                    stem_channels,
+                    kernel_size=3,
+                    stride=1,
+                    padding=1,
+                    bias=False),
+                build_norm_layer(self.norm_cfg, stem_channels)[1],
+                nn.ReLU(inplace=True))
+        else:
+            self.conv1 = build_conv_layer(
+                self.conv_cfg,
+                in_channels,
+                stem_channels,
+                kernel_size=7,
+                stride=2,
+                padding=3,
+                bias=False)
+            self.norm1_name, norm1 = build_norm_layer(
+                self.norm_cfg, stem_channels, postfix=1)
+            self.add_module(self.norm1_name, norm1)
+            self.relu = nn.ReLU(inplace=True)
+        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+
+    def _freeze_stages(self):
+        """Freeze stages param and norm stats."""
+        if self.frozen_stages >= 0:
+            if self.deep_stem:
+                self.stem.eval()
+                for param in self.stem.parameters():
+                    param.requires_grad = False
+            else:
+                self.norm1.eval()
+                for m in [self.conv1, self.norm1]:
+                    for param in m.parameters():
+                        param.requires_grad = False
+
+        for i in range(1, self.frozen_stages + 1):
+            m = getattr(self, f'layer{i}')
+            m.eval()
+            for param in m.parameters():
+                param.requires_grad = False
+
+    def forward(self, x):
+        """Forward function."""
+        if self.deep_stem:
+            x = self.stem(x)
+        else:
+            x = self.conv1(x)
+            x = self.norm1(x)
+            x = self.relu(x)
+        x = self.maxpool(x)
+        outs = []
+        for i, layer_name in enumerate(self.res_layers):
+            res_layer = getattr(self, layer_name)
+            x = res_layer(x)
+            if i in self.out_indices:
+                outs.append(x)
+        return tuple(outs)
+
+    def train(self, mode=True):
+        """Convert the model into training mode while keep normalization layer
+        freezed."""
+        super().train(mode)
+        self._freeze_stages()
+        if mode and self.norm_eval:
+            for m in self.modules():
+                # trick: eval have effect on BatchNorm only
+                if isinstance(m, _BatchNorm):
+                    m.eval()
+
+
+@MODELS.register_module()
+class ResNetV1c(ResNet):
+    """ResNetV1c variant described in [1]_.
+
+    Compared with default ResNet(ResNetV1b), ResNetV1c replaces the 7x7 conv in
+    the input stem with three 3x3 convs. For more details please refer to `Bag
+    of Tricks for Image Classification with Convolutional Neural Networks
+    <https://arxiv.org/abs/1812.01187>`_.
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(deep_stem=True, avg_down=False, **kwargs)
+
+
+@MODELS.register_module()
+class ResNetV1d(ResNet):
+    """ResNetV1d variant described in [1]_.
+
+    Compared with default ResNet(ResNetV1b), ResNetV1d replaces the 7x7 conv in
+    the input stem with three 3x3 convs. And in the downsampling block, a 2x2
+    avg_pool with stride 2 is added before conv, whose stride is changed to 1.
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(deep_stem=True, avg_down=True, **kwargs)
diff --git a/mmsegmentation/mmseg/models/backbones/resnext.py b/mmsegmentation/mmseg/models/backbones/resnext.py
new file mode 100644
index 0000000..67a244a
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/resnext.py
@@ -0,0 +1,150 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+
+from mmcv.cnn import build_conv_layer, build_norm_layer
+
+from mmseg.registry import MODELS
+from ..utils import ResLayer
+from .resnet import Bottleneck as _Bottleneck
+from .resnet import ResNet
+
+
+class Bottleneck(_Bottleneck):
+    """Bottleneck block for ResNeXt.
+
+    If style is "pytorch", the stride-two layer is the 3x3 conv layer, if it is
+    "caffe", the stride-two layer is the first 1x1 conv layer.
+    """
+
+    def __init__(self,
+                 inplanes,
+                 planes,
+                 groups=1,
+                 base_width=4,
+                 base_channels=64,
+                 **kwargs):
+        super().__init__(inplanes, planes, **kwargs)
+
+        if groups == 1:
+            width = self.planes
+        else:
+            width = math.floor(self.planes *
+                               (base_width / base_channels)) * groups
+
+        self.norm1_name, norm1 = build_norm_layer(
+            self.norm_cfg, width, postfix=1)
+        self.norm2_name, norm2 = build_norm_layer(
+            self.norm_cfg, width, postfix=2)
+        self.norm3_name, norm3 = build_norm_layer(
+            self.norm_cfg, self.planes * self.expansion, postfix=3)
+
+        self.conv1 = build_conv_layer(
+            self.conv_cfg,
+            self.inplanes,
+            width,
+            kernel_size=1,
+            stride=self.conv1_stride,
+            bias=False)
+        self.add_module(self.norm1_name, norm1)
+        fallback_on_stride = False
+        self.with_modulated_dcn = False
+        if self.with_dcn:
+            fallback_on_stride = self.dcn.pop('fallback_on_stride', False)
+        if not self.with_dcn or fallback_on_stride:
+            self.conv2 = build_conv_layer(
+                self.conv_cfg,
+                width,
+                width,
+                kernel_size=3,
+                stride=self.conv2_stride,
+                padding=self.dilation,
+                dilation=self.dilation,
+                groups=groups,
+                bias=False)
+        else:
+            assert self.conv_cfg is None, 'conv_cfg must be None for DCN'
+            self.conv2 = build_conv_layer(
+                self.dcn,
+                width,
+                width,
+                kernel_size=3,
+                stride=self.conv2_stride,
+                padding=self.dilation,
+                dilation=self.dilation,
+                groups=groups,
+                bias=False)
+
+        self.add_module(self.norm2_name, norm2)
+        self.conv3 = build_conv_layer(
+            self.conv_cfg,
+            width,
+            self.planes * self.expansion,
+            kernel_size=1,
+            bias=False)
+        self.add_module(self.norm3_name, norm3)
+
+
+@MODELS.register_module()
+class ResNeXt(ResNet):
+    """ResNeXt backbone.
+
+    This backbone is the implementation of `Aggregated
+    Residual Transformations for Deep Neural
+    Networks <https://arxiv.org/abs/1611.05431>`_.
+
+    Args:
+        depth (int): Depth of resnet, from {18, 34, 50, 101, 152}.
+        in_channels (int): Number of input image channels. Normally 3.
+        num_stages (int): Resnet stages, normally 4.
+        groups (int): Group of resnext.
+        base_width (int): Base width of resnext.
+        strides (Sequence[int]): Strides of the first block of each stage.
+        dilations (Sequence[int]): Dilation of each stage.
+        out_indices (Sequence[int]): Output from which stages.
+        style (str): `pytorch` or `caffe`. If set to "pytorch", the stride-two
+            layer is the 3x3 conv layer, otherwise the stride-two layer is
+            the first 1x1 conv layer.
+        frozen_stages (int): Stages to be frozen (all param fixed). -1 means
+            not freezing any parameters.
+        norm_cfg (dict): dictionary to construct and config norm layer.
+        norm_eval (bool): Whether to set norm layers to eval mode, namely,
+            freeze running stats (mean and var). Note: Effect on Batch Norm
+            and its variants only.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed.
+        zero_init_residual (bool): whether to use zero init for last norm layer
+            in resblocks to let them behave as identity.
+
+    Example:
+        >>> from mmseg.models import ResNeXt
+        >>> import torch
+        >>> self = ResNeXt(depth=50)
+        >>> self.eval()
+        >>> inputs = torch.rand(1, 3, 32, 32)
+        >>> level_outputs = self.forward(inputs)
+        >>> for level_out in level_outputs:
+        ...     print(tuple(level_out.shape))
+        (1, 256, 8, 8)
+        (1, 512, 4, 4)
+        (1, 1024, 2, 2)
+        (1, 2048, 1, 1)
+    """
+
+    arch_settings = {
+        50: (Bottleneck, (3, 4, 6, 3)),
+        101: (Bottleneck, (3, 4, 23, 3)),
+        152: (Bottleneck, (3, 8, 36, 3))
+    }
+
+    def __init__(self, groups=1, base_width=4, **kwargs):
+        self.groups = groups
+        self.base_width = base_width
+        super().__init__(**kwargs)
+
+    def make_res_layer(self, **kwargs):
+        """Pack all blocks in a stage into a ``ResLayer``"""
+        return ResLayer(
+            groups=self.groups,
+            base_width=self.base_width,
+            base_channels=self.base_channels,
+            **kwargs)
diff --git a/mmsegmentation/mmseg/models/backbones/stdc.py b/mmsegmentation/mmseg/models/backbones/stdc.py
new file mode 100644
index 0000000..758a3c9
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/stdc.py
@@ -0,0 +1,422 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+"""Modified from https://github.com/MichaelFan01/STDC-Seg."""
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule, ModuleList, Sequential
+
+from mmseg.registry import MODELS
+from ..utils import resize
+from .bisenetv1 import AttentionRefinementModule
+
+
+class STDCModule(BaseModule):
+    """STDCModule.
+
+    Args:
+        in_channels (int): The number of input channels.
+        out_channels (int): The number of output channels before scaling.
+        stride (int): The number of stride for the first conv layer.
+        norm_cfg (dict): Config dict for normalization layer. Default: None.
+        act_cfg (dict): The activation config for conv layers.
+        num_convs (int): Numbers of conv layers.
+        fusion_type (str): Type of fusion operation. Default: 'add'.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 stride,
+                 norm_cfg=None,
+                 act_cfg=None,
+                 num_convs=4,
+                 fusion_type='add',
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        assert num_convs > 1
+        assert fusion_type in ['add', 'cat']
+        self.stride = stride
+        self.with_downsample = True if self.stride == 2 else False
+        self.fusion_type = fusion_type
+
+        self.layers = ModuleList()
+        conv_0 = ConvModule(
+            in_channels, out_channels // 2, kernel_size=1, norm_cfg=norm_cfg)
+
+        if self.with_downsample:
+            self.downsample = ConvModule(
+                out_channels // 2,
+                out_channels // 2,
+                kernel_size=3,
+                stride=2,
+                padding=1,
+                groups=out_channels // 2,
+                norm_cfg=norm_cfg,
+                act_cfg=None)
+
+            if self.fusion_type == 'add':
+                self.layers.append(nn.Sequential(conv_0, self.downsample))
+                self.skip = Sequential(
+                    ConvModule(
+                        in_channels,
+                        in_channels,
+                        kernel_size=3,
+                        stride=2,
+                        padding=1,
+                        groups=in_channels,
+                        norm_cfg=norm_cfg,
+                        act_cfg=None),
+                    ConvModule(
+                        in_channels,
+                        out_channels,
+                        1,
+                        norm_cfg=norm_cfg,
+                        act_cfg=None))
+            else:
+                self.layers.append(conv_0)
+                self.skip = nn.AvgPool2d(kernel_size=3, stride=2, padding=1)
+        else:
+            self.layers.append(conv_0)
+
+        for i in range(1, num_convs):
+            out_factor = 2**(i + 1) if i != num_convs - 1 else 2**i
+            self.layers.append(
+                ConvModule(
+                    out_channels // 2**i,
+                    out_channels // out_factor,
+                    kernel_size=3,
+                    stride=1,
+                    padding=1,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg))
+
+    def forward(self, inputs):
+        if self.fusion_type == 'add':
+            out = self.forward_add(inputs)
+        else:
+            out = self.forward_cat(inputs)
+        return out
+
+    def forward_add(self, inputs):
+        layer_outputs = []
+        x = inputs.clone()
+        for layer in self.layers:
+            x = layer(x)
+            layer_outputs.append(x)
+        if self.with_downsample:
+            inputs = self.skip(inputs)
+
+        return torch.cat(layer_outputs, dim=1) + inputs
+
+    def forward_cat(self, inputs):
+        x0 = self.layers[0](inputs)
+        layer_outputs = [x0]
+        for i, layer in enumerate(self.layers[1:]):
+            if i == 0:
+                if self.with_downsample:
+                    x = layer(self.downsample(x0))
+                else:
+                    x = layer(x0)
+            else:
+                x = layer(x)
+            layer_outputs.append(x)
+        if self.with_downsample:
+            layer_outputs[0] = self.skip(x0)
+        return torch.cat(layer_outputs, dim=1)
+
+
+class FeatureFusionModule(BaseModule):
+    """Feature Fusion Module. This module is different from FeatureFusionModule
+    in BiSeNetV1. It uses two ConvModules in `self.attention` whose inter
+    channel number is calculated by given `scale_factor`, while
+    FeatureFusionModule in BiSeNetV1 only uses one ConvModule in
+    `self.conv_atten`.
+
+    Args:
+        in_channels (int): The number of input channels.
+        out_channels (int): The number of output channels.
+        scale_factor (int): The number of channel scale factor.
+            Default: 4.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN').
+        act_cfg (dict): The activation config for conv layers.
+            Default: dict(type='ReLU').
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 scale_factor=4,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        channels = out_channels // scale_factor
+        self.conv0 = ConvModule(
+            in_channels, out_channels, 1, norm_cfg=norm_cfg, act_cfg=act_cfg)
+        self.attention = nn.Sequential(
+            nn.AdaptiveAvgPool2d((1, 1)),
+            ConvModule(
+                out_channels,
+                channels,
+                1,
+                norm_cfg=None,
+                bias=False,
+                act_cfg=act_cfg),
+            ConvModule(
+                channels,
+                out_channels,
+                1,
+                norm_cfg=None,
+                bias=False,
+                act_cfg=None), nn.Sigmoid())
+
+    def forward(self, spatial_inputs, context_inputs):
+        inputs = torch.cat([spatial_inputs, context_inputs], dim=1)
+        x = self.conv0(inputs)
+        attn = self.attention(x)
+        x_attn = x * attn
+        return x_attn + x
+
+
+@MODELS.register_module()
+class STDCNet(BaseModule):
+    """This backbone is the implementation of `Rethinking BiSeNet For Real-time
+    Semantic Segmentation <https://arxiv.org/abs/2104.13188>`_.
+
+    Args:
+        stdc_type (int): The type of backbone structure,
+            `STDCNet1` and`STDCNet2` denotes two main backbones in paper,
+            whose FLOPs is 813M and 1446M, respectively.
+        in_channels (int): The num of input_channels.
+        channels (tuple[int]): The output channels for each stage.
+        bottleneck_type (str): The type of STDC Module type, the value must
+            be 'add' or 'cat'.
+        norm_cfg (dict): Config dict for normalization layer.
+        act_cfg (dict): The activation config for conv layers.
+        num_convs (int): Numbers of conv layer at each STDC Module.
+            Default: 4.
+        with_final_conv (bool): Whether add a conv layer at the Module output.
+            Default: True.
+        pretrained (str, optional): Model pretrained path. Default: None.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+
+    Example:
+        >>> import torch
+        >>> stdc_type = 'STDCNet1'
+        >>> in_channels = 3
+        >>> channels = (32, 64, 256, 512, 1024)
+        >>> bottleneck_type = 'cat'
+        >>> inputs = torch.rand(1, 3, 1024, 2048)
+        >>> self = STDCNet(stdc_type, in_channels,
+        ...                 channels, bottleneck_type).eval()
+        >>> outputs = self.forward(inputs)
+        >>> for i in range(len(outputs)):
+        ...     print(f'outputs[{i}].shape = {outputs[i].shape}')
+        outputs[0].shape = torch.Size([1, 256, 128, 256])
+        outputs[1].shape = torch.Size([1, 512, 64, 128])
+        outputs[2].shape = torch.Size([1, 1024, 32, 64])
+    """
+
+    arch_settings = {
+        'STDCNet1': [(2, 1), (2, 1), (2, 1)],
+        'STDCNet2': [(2, 1, 1, 1), (2, 1, 1, 1, 1), (2, 1, 1)]
+    }
+
+    def __init__(self,
+                 stdc_type,
+                 in_channels,
+                 channels,
+                 bottleneck_type,
+                 norm_cfg,
+                 act_cfg,
+                 num_convs=4,
+                 with_final_conv=False,
+                 pretrained=None,
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        assert stdc_type in self.arch_settings, \
+            f'invalid structure {stdc_type} for STDCNet.'
+        assert bottleneck_type in ['add', 'cat'],\
+            f'bottleneck_type must be `add` or `cat`, got {bottleneck_type}'
+
+        assert len(channels) == 5,\
+            f'invalid channels length {len(channels)} for STDCNet.'
+
+        self.in_channels = in_channels
+        self.channels = channels
+        self.stage_strides = self.arch_settings[stdc_type]
+        self.prtrained = pretrained
+        self.num_convs = num_convs
+        self.with_final_conv = with_final_conv
+
+        self.stages = ModuleList([
+            ConvModule(
+                self.in_channels,
+                self.channels[0],
+                kernel_size=3,
+                stride=2,
+                padding=1,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg),
+            ConvModule(
+                self.channels[0],
+                self.channels[1],
+                kernel_size=3,
+                stride=2,
+                padding=1,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg)
+        ])
+        # `self.num_shallow_features` is the number of shallow modules in
+        # `STDCNet`, which is noted as `Stage1` and `Stage2` in original paper.
+        # They are both not used for following modules like Attention
+        # Refinement Module and Feature Fusion Module.
+        # Thus they would be cut from `outs`. Please refer to Figure 4
+        # of original paper for more details.
+        self.num_shallow_features = len(self.stages)
+
+        for strides in self.stage_strides:
+            idx = len(self.stages) - 1
+            self.stages.append(
+                self._make_stage(self.channels[idx], self.channels[idx + 1],
+                                 strides, norm_cfg, act_cfg, bottleneck_type))
+        # After appending, `self.stages` is a ModuleList including several
+        # shallow modules and STDCModules.
+        # (len(self.stages) ==
+        # self.num_shallow_features + len(self.stage_strides))
+        if self.with_final_conv:
+            self.final_conv = ConvModule(
+                self.channels[-1],
+                max(1024, self.channels[-1]),
+                1,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg)
+
+    def _make_stage(self, in_channels, out_channels, strides, norm_cfg,
+                    act_cfg, bottleneck_type):
+        layers = []
+        for i, stride in enumerate(strides):
+            layers.append(
+                STDCModule(
+                    in_channels if i == 0 else out_channels,
+                    out_channels,
+                    stride,
+                    norm_cfg,
+                    act_cfg,
+                    num_convs=self.num_convs,
+                    fusion_type=bottleneck_type))
+        return Sequential(*layers)
+
+    def forward(self, x):
+        outs = []
+        for stage in self.stages:
+            x = stage(x)
+            outs.append(x)
+        if self.with_final_conv:
+            outs[-1] = self.final_conv(outs[-1])
+        outs = outs[self.num_shallow_features:]
+        return tuple(outs)
+
+
+@MODELS.register_module()
+class STDCContextPathNet(BaseModule):
+    """STDCNet with Context Path. The `outs` below is a list of three feature
+    maps from deep to shallow, whose height and width is from small to big,
+    respectively. The biggest feature map of `outs` is outputted for
+    `STDCHead`, where Detail Loss would be calculated by Detail Ground-truth.
+    The other two feature maps are used for Attention Refinement Module,
+    respectively. Besides, the biggest feature map of `outs` and the last
+    output of Attention Refinement Module are concatenated for Feature Fusion
+    Module. Then, this fusion feature map `feat_fuse` would be outputted for
+    `decode_head`. More details please refer to Figure 4 of original paper.
+
+    Args:
+        backbone_cfg (dict): Config dict for stdc backbone.
+        last_in_channels (tuple(int)), The number of channels of last
+            two feature maps from stdc backbone. Default: (1024, 512).
+        out_channels (int): The channels of output feature maps.
+            Default: 128.
+        ffm_cfg (dict): Config dict for Feature Fusion Module. Default:
+            `dict(in_channels=512, out_channels=256, scale_factor=4)`.
+        upsample_mode (str): Algorithm used for upsampling:
+                ``'nearest'`` | ``'linear'`` | ``'bilinear'`` | ``'bicubic'`` |
+                ``'trilinear'``. Default: ``'nearest'``.
+        align_corners (str): align_corners argument of F.interpolate. It
+            must be `None` if upsample_mode is ``'nearest'``. Default: None.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN').
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+
+    Return:
+        outputs (tuple): The tuple of list of output feature map for
+            auxiliary heads and decoder head.
+    """
+
+    def __init__(self,
+                 backbone_cfg,
+                 last_in_channels=(1024, 512),
+                 out_channels=128,
+                 ffm_cfg=dict(
+                     in_channels=512, out_channels=256, scale_factor=4),
+                 upsample_mode='nearest',
+                 align_corners=None,
+                 norm_cfg=dict(type='BN'),
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        self.backbone = MODELS.build(backbone_cfg)
+        self.arms = ModuleList()
+        self.convs = ModuleList()
+        for channels in last_in_channels:
+            self.arms.append(AttentionRefinementModule(channels, out_channels))
+            self.convs.append(
+                ConvModule(
+                    out_channels,
+                    out_channels,
+                    3,
+                    padding=1,
+                    norm_cfg=norm_cfg))
+        self.conv_avg = ConvModule(
+            last_in_channels[0], out_channels, 1, norm_cfg=norm_cfg)
+
+        self.ffm = FeatureFusionModule(**ffm_cfg)
+
+        self.upsample_mode = upsample_mode
+        self.align_corners = align_corners
+
+    def forward(self, x):
+        outs = list(self.backbone(x))
+        avg = F.adaptive_avg_pool2d(outs[-1], 1)
+        avg_feat = self.conv_avg(avg)
+
+        feature_up = resize(
+            avg_feat,
+            size=outs[-1].shape[2:],
+            mode=self.upsample_mode,
+            align_corners=self.align_corners)
+        arms_out = []
+        for i in range(len(self.arms)):
+            x_arm = self.arms[i](outs[len(outs) - 1 - i]) + feature_up
+            feature_up = resize(
+                x_arm,
+                size=outs[len(outs) - 1 - i - 1].shape[2:],
+                mode=self.upsample_mode,
+                align_corners=self.align_corners)
+            feature_up = self.convs[i](feature_up)
+            arms_out.append(feature_up)
+
+        feat_fuse = self.ffm(outs[0], arms_out[1])
+
+        # The `outputs` has four feature maps.
+        # `outs[0]` is outputted for `STDCHead` auxiliary head.
+        # Two feature maps of `arms_out` are outputted for auxiliary head.
+        # `feat_fuse` is outputted for decoder head.
+        outputs = [outs[0]] + list(arms_out) + [feat_fuse]
+        return tuple(outputs)
diff --git a/mmsegmentation/mmseg/models/backbones/swin.py b/mmsegmentation/mmseg/models/backbones/swin.py
new file mode 100644
index 0000000..67b28a9
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/swin.py
@@ -0,0 +1,757 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+from collections import OrderedDict
+from copy import deepcopy
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.checkpoint as cp
+from mmcv.cnn import build_norm_layer
+from mmcv.cnn.bricks.transformer import FFN, build_dropout
+from mmengine.logging import print_log
+from mmengine.model import BaseModule, ModuleList
+from mmengine.model.weight_init import (constant_init, trunc_normal_,
+                                        trunc_normal_init)
+from mmengine.runner import CheckpointLoader
+from mmengine.utils import to_2tuple
+
+from mmseg.registry import MODELS
+from ..utils.embed import PatchEmbed, PatchMerging
+
+
+class WindowMSA(BaseModule):
+    """Window based multi-head self-attention (W-MSA) module with relative
+    position bias.
+
+    Args:
+        embed_dims (int): Number of input channels.
+        num_heads (int): Number of attention heads.
+        window_size (tuple[int]): The height and width of the window.
+        qkv_bias (bool, optional):  If True, add a learnable bias to q, k, v.
+            Default: True.
+        qk_scale (float | None, optional): Override default qk scale of
+            head_dim ** -0.5 if set. Default: None.
+        attn_drop_rate (float, optional): Dropout ratio of attention weight.
+            Default: 0.0
+        proj_drop_rate (float, optional): Dropout ratio of output. Default: 0.
+        init_cfg (dict | None, optional): The Config for initialization.
+            Default: None.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 num_heads,
+                 window_size,
+                 qkv_bias=True,
+                 qk_scale=None,
+                 attn_drop_rate=0.,
+                 proj_drop_rate=0.,
+                 init_cfg=None):
+
+        super().__init__(init_cfg=init_cfg)
+        self.embed_dims = embed_dims
+        self.window_size = window_size  # Wh, Ww
+        self.num_heads = num_heads
+        head_embed_dims = embed_dims // num_heads
+        self.scale = qk_scale or head_embed_dims**-0.5
+
+        # define a parameter table of relative position bias
+        self.relative_position_bias_table = nn.Parameter(
+            torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1),
+                        num_heads))  # 2*Wh-1 * 2*Ww-1, nH
+
+        # About 2x faster than original impl
+        Wh, Ww = self.window_size
+        rel_index_coords = self.double_step_seq(2 * Ww - 1, Wh, 1, Ww)
+        rel_position_index = rel_index_coords + rel_index_coords.T
+        rel_position_index = rel_position_index.flip(1).contiguous()
+        self.register_buffer('relative_position_index', rel_position_index)
+
+        self.qkv = nn.Linear(embed_dims, embed_dims * 3, bias=qkv_bias)
+        self.attn_drop = nn.Dropout(attn_drop_rate)
+        self.proj = nn.Linear(embed_dims, embed_dims)
+        self.proj_drop = nn.Dropout(proj_drop_rate)
+
+        self.softmax = nn.Softmax(dim=-1)
+
+    def init_weights(self):
+        trunc_normal_(self.relative_position_bias_table, std=0.02)
+
+    def forward(self, x, mask=None):
+        """
+        Args:
+
+            x (tensor): input features with shape of (num_windows*B, N, C)
+            mask (tensor | None, Optional): mask with shape of (num_windows,
+                Wh*Ww, Wh*Ww), value should be between (-inf, 0].
+        """
+        B, N, C = x.shape
+        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads,
+                                  C // self.num_heads).permute(2, 0, 3, 1, 4)
+        # make torchscript happy (cannot use tensor as tuple)
+        q, k, v = qkv[0], qkv[1], qkv[2]
+
+        q = q * self.scale
+        attn = (q @ k.transpose(-2, -1))
+
+        relative_position_bias = self.relative_position_bias_table[
+            self.relative_position_index.view(-1)].view(
+                self.window_size[0] * self.window_size[1],
+                self.window_size[0] * self.window_size[1],
+                -1)  # Wh*Ww,Wh*Ww,nH
+        relative_position_bias = relative_position_bias.permute(
+            2, 0, 1).contiguous()  # nH, Wh*Ww, Wh*Ww
+        attn = attn + relative_position_bias.unsqueeze(0)
+
+        if mask is not None:
+            nW = mask.shape[0]
+            attn = attn.view(B // nW, nW, self.num_heads, N,
+                             N) + mask.unsqueeze(1).unsqueeze(0)
+            attn = attn.view(-1, self.num_heads, N, N)
+        attn = self.softmax(attn)
+
+        attn = self.attn_drop(attn)
+
+        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+    @staticmethod
+    def double_step_seq(step1, len1, step2, len2):
+        seq1 = torch.arange(0, step1 * len1, step1)
+        seq2 = torch.arange(0, step2 * len2, step2)
+        return (seq1[:, None] + seq2[None, :]).reshape(1, -1)
+
+
+class ShiftWindowMSA(BaseModule):
+    """Shifted Window Multihead Self-Attention Module.
+
+    Args:
+        embed_dims (int): Number of input channels.
+        num_heads (int): Number of attention heads.
+        window_size (int): The height and width of the window.
+        shift_size (int, optional): The shift step of each window towards
+            right-bottom. If zero, act as regular window-msa. Defaults to 0.
+        qkv_bias (bool, optional): If True, add a learnable bias to q, k, v.
+            Default: True
+        qk_scale (float | None, optional): Override default qk scale of
+            head_dim ** -0.5 if set. Defaults: None.
+        attn_drop_rate (float, optional): Dropout ratio of attention weight.
+            Defaults: 0.
+        proj_drop_rate (float, optional): Dropout ratio of output.
+            Defaults: 0.
+        dropout_layer (dict, optional): The dropout_layer used before output.
+            Defaults: dict(type='DropPath', drop_prob=0.).
+        init_cfg (dict, optional): The extra config for initialization.
+            Default: None.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 num_heads,
+                 window_size,
+                 shift_size=0,
+                 qkv_bias=True,
+                 qk_scale=None,
+                 attn_drop_rate=0,
+                 proj_drop_rate=0,
+                 dropout_layer=dict(type='DropPath', drop_prob=0.),
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+
+        self.window_size = window_size
+        self.shift_size = shift_size
+        assert 0 <= self.shift_size < self.window_size
+
+        self.w_msa = WindowMSA(
+            embed_dims=embed_dims,
+            num_heads=num_heads,
+            window_size=to_2tuple(window_size),
+            qkv_bias=qkv_bias,
+            qk_scale=qk_scale,
+            attn_drop_rate=attn_drop_rate,
+            proj_drop_rate=proj_drop_rate,
+            init_cfg=None)
+
+        self.drop = build_dropout(dropout_layer)
+
+    def forward(self, query, hw_shape):
+        B, L, C = query.shape
+        H, W = hw_shape
+        assert L == H * W, 'input feature has wrong size'
+        query = query.view(B, H, W, C)
+
+        # pad feature maps to multiples of window size
+        pad_r = (self.window_size - W % self.window_size) % self.window_size
+        pad_b = (self.window_size - H % self.window_size) % self.window_size
+        query = F.pad(query, (0, 0, 0, pad_r, 0, pad_b))
+        H_pad, W_pad = query.shape[1], query.shape[2]
+
+        # cyclic shift
+        if self.shift_size > 0:
+            shifted_query = torch.roll(
+                query,
+                shifts=(-self.shift_size, -self.shift_size),
+                dims=(1, 2))
+
+            # calculate attention mask for SW-MSA
+            img_mask = torch.zeros((1, H_pad, W_pad, 1), device=query.device)
+            h_slices = (slice(0, -self.window_size),
+                        slice(-self.window_size,
+                              -self.shift_size), slice(-self.shift_size, None))
+            w_slices = (slice(0, -self.window_size),
+                        slice(-self.window_size,
+                              -self.shift_size), slice(-self.shift_size, None))
+            cnt = 0
+            for h in h_slices:
+                for w in w_slices:
+                    img_mask[:, h, w, :] = cnt
+                    cnt += 1
+
+            # nW, window_size, window_size, 1
+            mask_windows = self.window_partition(img_mask)
+            mask_windows = mask_windows.view(
+                -1, self.window_size * self.window_size)
+            attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
+            attn_mask = attn_mask.masked_fill(attn_mask != 0,
+                                              float(-100.0)).masked_fill(
+                                                  attn_mask == 0, float(0.0))
+        else:
+            shifted_query = query
+            attn_mask = None
+
+        # nW*B, window_size, window_size, C
+        query_windows = self.window_partition(shifted_query)
+        # nW*B, window_size*window_size, C
+        query_windows = query_windows.view(-1, self.window_size**2, C)
+
+        # W-MSA/SW-MSA (nW*B, window_size*window_size, C)
+        attn_windows = self.w_msa(query_windows, mask=attn_mask)
+
+        # merge windows
+        attn_windows = attn_windows.view(-1, self.window_size,
+                                         self.window_size, C)
+
+        # B H' W' C
+        shifted_x = self.window_reverse(attn_windows, H_pad, W_pad)
+        # reverse cyclic shift
+        if self.shift_size > 0:
+            x = torch.roll(
+                shifted_x,
+                shifts=(self.shift_size, self.shift_size),
+                dims=(1, 2))
+        else:
+            x = shifted_x
+
+        if pad_r > 0 or pad_b:
+            x = x[:, :H, :W, :].contiguous()
+
+        x = x.view(B, H * W, C)
+
+        x = self.drop(x)
+        return x
+
+    def window_reverse(self, windows, H, W):
+        """
+        Args:
+            windows: (num_windows*B, window_size, window_size, C)
+            H (int): Height of image
+            W (int): Width of image
+        Returns:
+            x: (B, H, W, C)
+        """
+        window_size = self.window_size
+        B = int(windows.shape[0] / (H * W / window_size / window_size))
+        x = windows.view(B, H // window_size, W // window_size, window_size,
+                         window_size, -1)
+        x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)
+        return x
+
+    def window_partition(self, x):
+        """
+        Args:
+            x: (B, H, W, C)
+        Returns:
+            windows: (num_windows*B, window_size, window_size, C)
+        """
+        B, H, W, C = x.shape
+        window_size = self.window_size
+        x = x.view(B, H // window_size, window_size, W // window_size,
+                   window_size, C)
+        windows = x.permute(0, 1, 3, 2, 4, 5).contiguous()
+        windows = windows.view(-1, window_size, window_size, C)
+        return windows
+
+
+class SwinBlock(BaseModule):
+    """"
+    Args:
+        embed_dims (int): The feature dimension.
+        num_heads (int): Parallel attention heads.
+        feedforward_channels (int): The hidden dimension for FFNs.
+        window_size (int, optional): The local window scale. Default: 7.
+        shift (bool, optional): whether to shift window or not. Default False.
+        qkv_bias (bool, optional): enable bias for qkv if True. Default: True.
+        qk_scale (float | None, optional): Override default qk scale of
+            head_dim ** -0.5 if set. Default: None.
+        drop_rate (float, optional): Dropout rate. Default: 0.
+        attn_drop_rate (float, optional): Attention dropout rate. Default: 0.
+        drop_path_rate (float, optional): Stochastic depth rate. Default: 0.
+        act_cfg (dict, optional): The config dict of activation function.
+            Default: dict(type='GELU').
+        norm_cfg (dict, optional): The config dict of normalization.
+            Default: dict(type='LN').
+        with_cp (bool, optional): Use checkpoint or not. Using checkpoint
+            will save some memory while slowing down the training speed.
+            Default: False.
+        init_cfg (dict | list | None, optional): The init config.
+            Default: None.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 num_heads,
+                 feedforward_channels,
+                 window_size=7,
+                 shift=False,
+                 qkv_bias=True,
+                 qk_scale=None,
+                 drop_rate=0.,
+                 attn_drop_rate=0.,
+                 drop_path_rate=0.,
+                 act_cfg=dict(type='GELU'),
+                 norm_cfg=dict(type='LN'),
+                 with_cp=False,
+                 init_cfg=None):
+
+        super().__init__(init_cfg=init_cfg)
+
+        self.with_cp = with_cp
+
+        self.norm1 = build_norm_layer(norm_cfg, embed_dims)[1]
+        self.attn = ShiftWindowMSA(
+            embed_dims=embed_dims,
+            num_heads=num_heads,
+            window_size=window_size,
+            shift_size=window_size // 2 if shift else 0,
+            qkv_bias=qkv_bias,
+            qk_scale=qk_scale,
+            attn_drop_rate=attn_drop_rate,
+            proj_drop_rate=drop_rate,
+            dropout_layer=dict(type='DropPath', drop_prob=drop_path_rate),
+            init_cfg=None)
+
+        self.norm2 = build_norm_layer(norm_cfg, embed_dims)[1]
+        self.ffn = FFN(
+            embed_dims=embed_dims,
+            feedforward_channels=feedforward_channels,
+            num_fcs=2,
+            ffn_drop=drop_rate,
+            dropout_layer=dict(type='DropPath', drop_prob=drop_path_rate),
+            act_cfg=act_cfg,
+            add_identity=True,
+            init_cfg=None)
+
+    def forward(self, x, hw_shape):
+
+        def _inner_forward(x):
+            identity = x
+            x = self.norm1(x)
+            x = self.attn(x, hw_shape)
+
+            x = x + identity
+
+            identity = x
+            x = self.norm2(x)
+            x = self.ffn(x, identity=identity)
+
+            return x
+
+        if self.with_cp and x.requires_grad:
+            x = cp.checkpoint(_inner_forward, x)
+        else:
+            x = _inner_forward(x)
+
+        return x
+
+
+class SwinBlockSequence(BaseModule):
+    """Implements one stage in Swin Transformer.
+
+    Args:
+        embed_dims (int): The feature dimension.
+        num_heads (int): Parallel attention heads.
+        feedforward_channels (int): The hidden dimension for FFNs.
+        depth (int): The number of blocks in this stage.
+        window_size (int, optional): The local window scale. Default: 7.
+        qkv_bias (bool, optional): enable bias for qkv if True. Default: True.
+        qk_scale (float | None, optional): Override default qk scale of
+            head_dim ** -0.5 if set. Default: None.
+        drop_rate (float, optional): Dropout rate. Default: 0.
+        attn_drop_rate (float, optional): Attention dropout rate. Default: 0.
+        drop_path_rate (float | list[float], optional): Stochastic depth
+            rate. Default: 0.
+        downsample (BaseModule | None, optional): The downsample operation
+            module. Default: None.
+        act_cfg (dict, optional): The config dict of activation function.
+            Default: dict(type='GELU').
+        norm_cfg (dict, optional): The config dict of normalization.
+            Default: dict(type='LN').
+        with_cp (bool, optional): Use checkpoint or not. Using checkpoint
+            will save some memory while slowing down the training speed.
+            Default: False.
+        init_cfg (dict | list | None, optional): The init config.
+            Default: None.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 num_heads,
+                 feedforward_channels,
+                 depth,
+                 window_size=7,
+                 qkv_bias=True,
+                 qk_scale=None,
+                 drop_rate=0.,
+                 attn_drop_rate=0.,
+                 drop_path_rate=0.,
+                 downsample=None,
+                 act_cfg=dict(type='GELU'),
+                 norm_cfg=dict(type='LN'),
+                 with_cp=False,
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+
+        if isinstance(drop_path_rate, list):
+            drop_path_rates = drop_path_rate
+            assert len(drop_path_rates) == depth
+        else:
+            drop_path_rates = [deepcopy(drop_path_rate) for _ in range(depth)]
+
+        self.blocks = ModuleList()
+        for i in range(depth):
+            block = SwinBlock(
+                embed_dims=embed_dims,
+                num_heads=num_heads,
+                feedforward_channels=feedforward_channels,
+                window_size=window_size,
+                shift=False if i % 2 == 0 else True,
+                qkv_bias=qkv_bias,
+                qk_scale=qk_scale,
+                drop_rate=drop_rate,
+                attn_drop_rate=attn_drop_rate,
+                drop_path_rate=drop_path_rates[i],
+                act_cfg=act_cfg,
+                norm_cfg=norm_cfg,
+                with_cp=with_cp,
+                init_cfg=None)
+            self.blocks.append(block)
+
+        self.downsample = downsample
+
+    def forward(self, x, hw_shape):
+        for block in self.blocks:
+            x = block(x, hw_shape)
+
+        if self.downsample:
+            x_down, down_hw_shape = self.downsample(x, hw_shape)
+            return x_down, down_hw_shape, x, hw_shape
+        else:
+            return x, hw_shape, x, hw_shape
+
+
+@MODELS.register_module()
+class SwinTransformer(BaseModule):
+    """Swin Transformer backbone.
+
+    This backbone is the implementation of `Swin Transformer:
+    Hierarchical Vision Transformer using Shifted
+    Windows <https://arxiv.org/abs/2103.14030>`_.
+    Inspiration from https://github.com/microsoft/Swin-Transformer.
+
+    Args:
+        pretrain_img_size (int | tuple[int]): The size of input image when
+            pretrain. Defaults: 224.
+        in_channels (int): The num of input channels.
+            Defaults: 3.
+        embed_dims (int): The feature dimension. Default: 96.
+        patch_size (int | tuple[int]): Patch size. Default: 4.
+        window_size (int): Window size. Default: 7.
+        mlp_ratio (int | float): Ratio of mlp hidden dim to embedding dim.
+            Default: 4.
+        depths (tuple[int]): Depths of each Swin Transformer stage.
+            Default: (2, 2, 6, 2).
+        num_heads (tuple[int]): Parallel attention heads of each Swin
+            Transformer stage. Default: (3, 6, 12, 24).
+        strides (tuple[int]): The patch merging or patch embedding stride of
+            each Swin Transformer stage. (In swin, we set kernel size equal to
+            stride.) Default: (4, 2, 2, 2).
+        out_indices (tuple[int]): Output from which stages.
+            Default: (0, 1, 2, 3).
+        qkv_bias (bool, optional): If True, add a learnable bias to query, key,
+            value. Default: True
+        qk_scale (float | None, optional): Override default qk scale of
+            head_dim ** -0.5 if set. Default: None.
+        patch_norm (bool): If add a norm layer for patch embed and patch
+            merging. Default: True.
+        drop_rate (float): Dropout rate. Defaults: 0.
+        attn_drop_rate (float): Attention dropout rate. Default: 0.
+        drop_path_rate (float): Stochastic depth rate. Defaults: 0.1.
+        use_abs_pos_embed (bool): If True, add absolute position embedding to
+            the patch embedding. Defaults: False.
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='LN').
+        norm_cfg (dict): Config dict for normalization layer at
+            output of backone. Defaults: dict(type='LN').
+        with_cp (bool, optional): Use checkpoint or not. Using checkpoint
+            will save some memory while slowing down the training speed.
+            Default: False.
+        pretrained (str, optional): model pretrained path. Default: None.
+        frozen_stages (int): Stages to be frozen (stop grad and set eval mode).
+            -1 means not freezing any parameters.
+        init_cfg (dict, optional): The Config for initialization.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 pretrain_img_size=224,
+                 in_channels=3,
+                 embed_dims=96,
+                 patch_size=4,
+                 window_size=7,
+                 mlp_ratio=4,
+                 depths=(2, 2, 6, 2),
+                 num_heads=(3, 6, 12, 24),
+                 strides=(4, 2, 2, 2),
+                 out_indices=(0, 1, 2, 3),
+                 qkv_bias=True,
+                 qk_scale=None,
+                 patch_norm=True,
+                 drop_rate=0.,
+                 attn_drop_rate=0.,
+                 drop_path_rate=0.1,
+                 use_abs_pos_embed=False,
+                 act_cfg=dict(type='GELU'),
+                 norm_cfg=dict(type='LN'),
+                 with_cp=False,
+                 pretrained=None,
+                 frozen_stages=-1,
+                 init_cfg=None):
+        self.frozen_stages = frozen_stages
+
+        if isinstance(pretrain_img_size, int):
+            pretrain_img_size = to_2tuple(pretrain_img_size)
+        elif isinstance(pretrain_img_size, tuple):
+            if len(pretrain_img_size) == 1:
+                pretrain_img_size = to_2tuple(pretrain_img_size[0])
+            assert len(pretrain_img_size) == 2, \
+                f'The size of image should have length 1 or 2, ' \
+                f'but got {len(pretrain_img_size)}'
+
+        assert not (init_cfg and pretrained), \
+            'init_cfg and pretrained cannot be specified at the same time'
+        if isinstance(pretrained, str):
+            warnings.warn('DeprecationWarning: pretrained is deprecated, '
+                          'please use "init_cfg" instead')
+            init_cfg = dict(type='Pretrained', checkpoint=pretrained)
+        elif pretrained is None:
+            init_cfg = init_cfg
+        else:
+            raise TypeError('pretrained must be a str or None')
+
+        super().__init__(init_cfg=init_cfg)
+
+        num_layers = len(depths)
+        self.out_indices = out_indices
+        self.use_abs_pos_embed = use_abs_pos_embed
+
+        assert strides[0] == patch_size, 'Use non-overlapping patch embed.'
+
+        self.patch_embed = PatchEmbed(
+            in_channels=in_channels,
+            embed_dims=embed_dims,
+            conv_type='Conv2d',
+            kernel_size=patch_size,
+            stride=strides[0],
+            padding='corner',
+            norm_cfg=norm_cfg if patch_norm else None,
+            init_cfg=None)
+
+        if self.use_abs_pos_embed:
+            patch_row = pretrain_img_size[0] // patch_size
+            patch_col = pretrain_img_size[1] // patch_size
+            num_patches = patch_row * patch_col
+            self.absolute_pos_embed = nn.Parameter(
+                torch.zeros((1, num_patches, embed_dims)))
+
+        self.drop_after_pos = nn.Dropout(p=drop_rate)
+
+        # set stochastic depth decay rule
+        total_depth = sum(depths)
+        dpr = [
+            x.item() for x in torch.linspace(0, drop_path_rate, total_depth)
+        ]
+
+        self.stages = ModuleList()
+        in_channels = embed_dims
+        for i in range(num_layers):
+            if i < num_layers - 1:
+                downsample = PatchMerging(
+                    in_channels=in_channels,
+                    out_channels=2 * in_channels,
+                    stride=strides[i + 1],
+                    norm_cfg=norm_cfg if patch_norm else None,
+                    init_cfg=None)
+            else:
+                downsample = None
+
+            stage = SwinBlockSequence(
+                embed_dims=in_channels,
+                num_heads=num_heads[i],
+                feedforward_channels=int(mlp_ratio * in_channels),
+                depth=depths[i],
+                window_size=window_size,
+                qkv_bias=qkv_bias,
+                qk_scale=qk_scale,
+                drop_rate=drop_rate,
+                attn_drop_rate=attn_drop_rate,
+                drop_path_rate=dpr[sum(depths[:i]):sum(depths[:i + 1])],
+                downsample=downsample,
+                act_cfg=act_cfg,
+                norm_cfg=norm_cfg,
+                with_cp=with_cp,
+                init_cfg=None)
+            self.stages.append(stage)
+            if downsample:
+                in_channels = downsample.out_channels
+
+        self.num_features = [int(embed_dims * 2**i) for i in range(num_layers)]
+        # Add a norm layer for each output
+        for i in out_indices:
+            layer = build_norm_layer(norm_cfg, self.num_features[i])[1]
+            layer_name = f'norm{i}'
+            self.add_module(layer_name, layer)
+
+    def train(self, mode=True):
+        """Convert the model into training mode while keep layers freezed."""
+        super().train(mode)
+        self._freeze_stages()
+
+    def _freeze_stages(self):
+        if self.frozen_stages >= 0:
+            self.patch_embed.eval()
+            for param in self.patch_embed.parameters():
+                param.requires_grad = False
+            if self.use_abs_pos_embed:
+                self.absolute_pos_embed.requires_grad = False
+            self.drop_after_pos.eval()
+
+        for i in range(1, self.frozen_stages + 1):
+
+            if (i - 1) in self.out_indices:
+                norm_layer = getattr(self, f'norm{i-1}')
+                norm_layer.eval()
+                for param in norm_layer.parameters():
+                    param.requires_grad = False
+
+            m = self.stages[i - 1]
+            m.eval()
+            for param in m.parameters():
+                param.requires_grad = False
+
+    def init_weights(self):
+        if self.init_cfg is None:
+            print_log(f'No pre-trained weights for '
+                      f'{self.__class__.__name__}, '
+                      f'training start from scratch')
+            if self.use_abs_pos_embed:
+                trunc_normal_(self.absolute_pos_embed, std=0.02)
+            for m in self.modules():
+                if isinstance(m, nn.Linear):
+                    trunc_normal_init(m, std=.02, bias=0.)
+                elif isinstance(m, nn.LayerNorm):
+                    constant_init(m, val=1.0, bias=0.)
+        else:
+            assert 'checkpoint' in self.init_cfg, f'Only support ' \
+                                                  f'specify `Pretrained` in ' \
+                                                  f'`init_cfg` in ' \
+                                                  f'{self.__class__.__name__} '
+            ckpt = CheckpointLoader.load_checkpoint(
+                self.init_cfg['checkpoint'], logger=None, map_location='cpu')
+            if 'state_dict' in ckpt:
+                _state_dict = ckpt['state_dict']
+            elif 'model' in ckpt:
+                _state_dict = ckpt['model']
+            else:
+                _state_dict = ckpt
+
+            state_dict = OrderedDict()
+            for k, v in _state_dict.items():
+                if k.startswith('backbone.'):
+                    state_dict[k[9:]] = v
+                else:
+                    state_dict[k] = v
+
+            # strip prefix of state_dict
+            if list(state_dict.keys())[0].startswith('module.'):
+                state_dict = {k[7:]: v for k, v in state_dict.items()}
+
+            # reshape absolute position embedding
+            if state_dict.get('absolute_pos_embed') is not None:
+                absolute_pos_embed = state_dict['absolute_pos_embed']
+                N1, L, C1 = absolute_pos_embed.size()
+                N2, C2, H, W = self.absolute_pos_embed.size()
+                if N1 != N2 or C1 != C2 or L != H * W:
+                    print_log('Error in loading absolute_pos_embed, pass')
+                else:
+                    state_dict['absolute_pos_embed'] = absolute_pos_embed.view(
+                        N2, H, W, C2).permute(0, 3, 1, 2).contiguous()
+
+            # interpolate position bias table if needed
+            relative_position_bias_table_keys = [
+                k for k in state_dict.keys()
+                if 'relative_position_bias_table' in k
+            ]
+            for table_key in relative_position_bias_table_keys:
+                table_pretrained = state_dict[table_key]
+                if table_key in self.state_dict():
+                    table_current = self.state_dict()[table_key]
+                    L1, nH1 = table_pretrained.size()
+                    L2, nH2 = table_current.size()
+                    if nH1 != nH2:
+                        print_log(f'Error in loading {table_key}, pass')
+                    elif L1 != L2:
+                        S1 = int(L1**0.5)
+                        S2 = int(L2**0.5)
+                        table_pretrained_resized = F.interpolate(
+                            table_pretrained.permute(1, 0).reshape(
+                                1, nH1, S1, S1),
+                            size=(S2, S2),
+                            mode='bicubic')
+                        state_dict[table_key] = table_pretrained_resized.view(
+                            nH2, L2).permute(1, 0).contiguous()
+
+            # load state_dict
+            self.load_state_dict(state_dict, strict=False)
+
+    def forward(self, x):
+        x, hw_shape = self.patch_embed(x)
+
+        if self.use_abs_pos_embed:
+            x = x + self.absolute_pos_embed
+        x = self.drop_after_pos(x)
+
+        outs = []
+        for i, stage in enumerate(self.stages):
+            x, hw_shape, out, out_hw_shape = stage(x, hw_shape)
+            if i in self.out_indices:
+                norm_layer = getattr(self, f'norm{i}')
+                out = norm_layer(out)
+                out = out.view(-1, *out_hw_shape,
+                               self.num_features[i]).permute(0, 3, 1,
+                                                             2).contiguous()
+                outs.append(out)
+
+        return outs
diff --git a/mmsegmentation/mmseg/models/backbones/timm_backbone.py b/mmsegmentation/mmseg/models/backbones/timm_backbone.py
new file mode 100644
index 0000000..1eef302
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/timm_backbone.py
@@ -0,0 +1,63 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+try:
+    import timm
+except ImportError:
+    timm = None
+
+from mmengine.model import BaseModule
+from mmengine.registry import MODELS as MMENGINE_MODELS
+
+from mmseg.registry import MODELS
+
+
+@MODELS.register_module()
+class TIMMBackbone(BaseModule):
+    """Wrapper to use backbones from timm library. More details can be found in
+    `timm <https://github.com/rwightman/pytorch-image-models>`_ .
+
+    Args:
+        model_name (str): Name of timm model to instantiate.
+        pretrained (bool): Load pretrained weights if True.
+        checkpoint_path (str): Path of checkpoint to load after
+            model is initialized.
+        in_channels (int): Number of input image channels. Default: 3.
+        init_cfg (dict, optional): Initialization config dict
+        **kwargs: Other timm & model specific arguments.
+    """
+
+    def __init__(
+        self,
+        model_name,
+        features_only=True,
+        pretrained=True,
+        checkpoint_path='',
+        in_channels=3,
+        init_cfg=None,
+        **kwargs,
+    ):
+        if timm is None:
+            raise RuntimeError('timm is not installed')
+        super().__init__(init_cfg)
+        if 'norm_layer' in kwargs:
+            kwargs['norm_layer'] = MMENGINE_MODELS.get(kwargs['norm_layer'])
+        self.timm_model = timm.create_model(
+            model_name=model_name,
+            features_only=features_only,
+            pretrained=pretrained,
+            in_chans=in_channels,
+            checkpoint_path=checkpoint_path,
+            **kwargs,
+        )
+
+        # Make unused parameters None
+        self.timm_model.global_pool = None
+        self.timm_model.fc = None
+        self.timm_model.classifier = None
+
+        # Hack to use pretrained weights from timm
+        if pretrained or checkpoint_path:
+            self._is_init = True
+
+    def forward(self, x):
+        features = self.timm_model(x)
+        return features
diff --git a/mmsegmentation/mmseg/models/backbones/twins.py b/mmsegmentation/mmseg/models/backbones/twins.py
new file mode 100644
index 0000000..b6a6eea
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/twins.py
@@ -0,0 +1,588 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+import warnings
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import build_norm_layer
+from mmcv.cnn.bricks.drop import build_dropout
+from mmcv.cnn.bricks.transformer import FFN
+from mmengine.model import BaseModule, ModuleList
+from mmengine.model.weight_init import (constant_init, normal_init,
+                                        trunc_normal_init)
+from torch.nn.modules.batchnorm import _BatchNorm
+
+from mmseg.models.backbones.mit import EfficientMultiheadAttention
+from mmseg.registry import MODELS
+from ..utils.embed import PatchEmbed
+
+
+class GlobalSubsampledAttention(EfficientMultiheadAttention):
+    """Global Sub-sampled Attention (Spatial Reduction Attention)
+
+    This module is modified from EfficientMultiheadAttention，
+    which is a module from mmseg.models.backbones.mit.py.
+    Specifically, there is no difference between
+    `GlobalSubsampledAttention` and `EfficientMultiheadAttention`,
+    `GlobalSubsampledAttention` is built as a brand new class
+    because it is renamed as `Global sub-sampled attention (GSA)`
+    in paper.
+
+
+    Args:
+        embed_dims (int): The embedding dimension.
+        num_heads (int): Parallel attention heads.
+        attn_drop (float): A Dropout layer on attn_output_weights.
+            Default: 0.0.
+        proj_drop (float): A Dropout layer after `nn.MultiheadAttention`.
+            Default: 0.0.
+        dropout_layer (obj:`ConfigDict`): The dropout_layer used
+            when adding the shortcut. Default: None.
+        batch_first (bool): Key, Query and Value are shape of
+            (batch, n, embed_dims)
+            or (n, batch, embed_dims). Default: False.
+        qkv_bias (bool): enable bias for qkv if True. Default: True.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='LN').
+        sr_ratio (int): The ratio of spatial reduction of GSA of PCPVT.
+            Default: 1.
+        init_cfg (dict, optional): The Config for initialization.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 num_heads,
+                 attn_drop=0.,
+                 proj_drop=0.,
+                 dropout_layer=None,
+                 batch_first=True,
+                 qkv_bias=True,
+                 norm_cfg=dict(type='LN'),
+                 sr_ratio=1,
+                 init_cfg=None):
+        super().__init__(
+            embed_dims,
+            num_heads,
+            attn_drop=attn_drop,
+            proj_drop=proj_drop,
+            dropout_layer=dropout_layer,
+            batch_first=batch_first,
+            qkv_bias=qkv_bias,
+            norm_cfg=norm_cfg,
+            sr_ratio=sr_ratio,
+            init_cfg=init_cfg)
+
+
+class GSAEncoderLayer(BaseModule):
+    """Implements one encoder layer with GSA.
+
+    Args:
+        embed_dims (int): The feature dimension.
+        num_heads (int): Parallel attention heads.
+        feedforward_channels (int): The hidden dimension for FFNs.
+        drop_rate (float): Probability of an element to be zeroed
+            after the feed forward layer. Default: 0.0.
+        attn_drop_rate (float): The drop out rate for attention layer.
+            Default: 0.0.
+        drop_path_rate (float): Stochastic depth rate. Default 0.0.
+        num_fcs (int): The number of fully-connected layers for FFNs.
+            Default: 2.
+        qkv_bias (bool): Enable bias for qkv if True. Default: True
+        act_cfg (dict): The activation config for FFNs.
+            Default: dict(type='GELU').
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='LN').
+        sr_ratio (float): Kernel_size of conv in Attention modules. Default: 1.
+        init_cfg (dict, optional): The Config for initialization.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 num_heads,
+                 feedforward_channels,
+                 drop_rate=0.,
+                 attn_drop_rate=0.,
+                 drop_path_rate=0.,
+                 num_fcs=2,
+                 qkv_bias=True,
+                 act_cfg=dict(type='GELU'),
+                 norm_cfg=dict(type='LN'),
+                 sr_ratio=1.,
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+
+        self.norm1 = build_norm_layer(norm_cfg, embed_dims, postfix=1)[1]
+        self.attn = GlobalSubsampledAttention(
+            embed_dims=embed_dims,
+            num_heads=num_heads,
+            attn_drop=attn_drop_rate,
+            proj_drop=drop_rate,
+            dropout_layer=dict(type='DropPath', drop_prob=drop_path_rate),
+            qkv_bias=qkv_bias,
+            norm_cfg=norm_cfg,
+            sr_ratio=sr_ratio)
+
+        self.norm2 = build_norm_layer(norm_cfg, embed_dims, postfix=2)[1]
+        self.ffn = FFN(
+            embed_dims=embed_dims,
+            feedforward_channels=feedforward_channels,
+            num_fcs=num_fcs,
+            ffn_drop=drop_rate,
+            dropout_layer=dict(type='DropPath', drop_prob=drop_path_rate),
+            act_cfg=act_cfg,
+            add_identity=False)
+
+        self.drop_path = build_dropout(
+            dict(type='DropPath', drop_prob=drop_path_rate)
+        ) if drop_path_rate > 0. else nn.Identity()
+
+    def forward(self, x, hw_shape):
+        x = x + self.drop_path(self.attn(self.norm1(x), hw_shape, identity=0.))
+        x = x + self.drop_path(self.ffn(self.norm2(x)))
+        return x
+
+
+class LocallyGroupedSelfAttention(BaseModule):
+    """Locally-grouped Self Attention (LSA) module.
+
+    Args:
+        embed_dims (int): Number of input channels.
+        num_heads (int): Number of attention heads. Default: 8
+        qkv_bias (bool, optional):  If True, add a learnable bias to q, k, v.
+            Default: False.
+        qk_scale (float | None, optional): Override default qk scale of
+            head_dim ** -0.5 if set. Default: None.
+        attn_drop_rate (float, optional): Dropout ratio of attention weight.
+            Default: 0.0
+        proj_drop_rate (float, optional): Dropout ratio of output. Default: 0.
+        window_size(int): Window size of LSA. Default: 1.
+        init_cfg (dict, optional): The Config for initialization.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 num_heads=8,
+                 qkv_bias=False,
+                 qk_scale=None,
+                 attn_drop_rate=0.,
+                 proj_drop_rate=0.,
+                 window_size=1,
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+
+        assert embed_dims % num_heads == 0, f'dim {embed_dims} should be ' \
+                                            f'divided by num_heads ' \
+                                            f'{num_heads}.'
+        self.embed_dims = embed_dims
+        self.num_heads = num_heads
+        head_dim = embed_dims // num_heads
+        self.scale = qk_scale or head_dim**-0.5
+
+        self.qkv = nn.Linear(embed_dims, embed_dims * 3, bias=qkv_bias)
+        self.attn_drop = nn.Dropout(attn_drop_rate)
+        self.proj = nn.Linear(embed_dims, embed_dims)
+        self.proj_drop = nn.Dropout(proj_drop_rate)
+        self.window_size = window_size
+
+    def forward(self, x, hw_shape):
+        b, n, c = x.shape
+        h, w = hw_shape
+        x = x.view(b, h, w, c)
+
+        # pad feature maps to multiples of Local-groups
+        pad_l = pad_t = 0
+        pad_r = (self.window_size - w % self.window_size) % self.window_size
+        pad_b = (self.window_size - h % self.window_size) % self.window_size
+        x = F.pad(x, (0, 0, pad_l, pad_r, pad_t, pad_b))
+
+        # calculate attention mask for LSA
+        Hp, Wp = x.shape[1:-1]
+        _h, _w = Hp // self.window_size, Wp // self.window_size
+        mask = torch.zeros((1, Hp, Wp), device=x.device)
+        mask[:, -pad_b:, :].fill_(1)
+        mask[:, :, -pad_r:].fill_(1)
+
+        # [B, _h, _w, window_size, window_size, C]
+        x = x.reshape(b, _h, self.window_size, _w, self.window_size,
+                      c).transpose(2, 3)
+        mask = mask.reshape(1, _h, self.window_size, _w,
+                            self.window_size).transpose(2, 3).reshape(
+                                1, _h * _w,
+                                self.window_size * self.window_size)
+        # [1, _h*_w, window_size*window_size, window_size*window_size]
+        attn_mask = mask.unsqueeze(2) - mask.unsqueeze(3)
+        attn_mask = attn_mask.masked_fill(attn_mask != 0,
+                                          float(-1000.0)).masked_fill(
+                                              attn_mask == 0, float(0.0))
+
+        # [3, B, _w*_h, nhead, window_size*window_size, dim]
+        qkv = self.qkv(x).reshape(b, _h * _w,
+                                  self.window_size * self.window_size, 3,
+                                  self.num_heads, c // self.num_heads).permute(
+                                      3, 0, 1, 4, 2, 5)
+        q, k, v = qkv[0], qkv[1], qkv[2]
+        # [B, _h*_w, n_head, window_size*window_size, window_size*window_size]
+        attn = (q @ k.transpose(-2, -1)) * self.scale
+        attn = attn + attn_mask.unsqueeze(2)
+        attn = attn.softmax(dim=-1)
+        attn = self.attn_drop(attn)
+        attn = (attn @ v).transpose(2, 3).reshape(b, _h, _w, self.window_size,
+                                                  self.window_size, c)
+        x = attn.transpose(2, 3).reshape(b, _h * self.window_size,
+                                         _w * self.window_size, c)
+        if pad_r > 0 or pad_b > 0:
+            x = x[:, :h, :w, :].contiguous()
+
+        x = x.reshape(b, n, c)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+
+class LSAEncoderLayer(BaseModule):
+    """Implements one encoder layer in Twins-SVT.
+
+    Args:
+        embed_dims (int): The feature dimension.
+        num_heads (int): Parallel attention heads.
+        feedforward_channels (int): The hidden dimension for FFNs.
+        drop_rate (float): Probability of an element to be zeroed
+            after the feed forward layer. Default: 0.0.
+        attn_drop_rate (float, optional): Dropout ratio of attention weight.
+           Default: 0.0
+        drop_path_rate (float): Stochastic depth rate. Default 0.0.
+        num_fcs (int): The number of fully-connected layers for FFNs.
+            Default: 2.
+        qkv_bias (bool): Enable bias for qkv if True. Default: True
+        qk_scale (float | None, optional): Override default qk scale of
+           head_dim ** -0.5 if set. Default: None.
+        act_cfg (dict): The activation config for FFNs.
+            Default: dict(type='GELU').
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='LN').
+        window_size (int): Window size of LSA. Default: 1.
+        init_cfg (dict, optional): The Config for initialization.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 num_heads,
+                 feedforward_channels,
+                 drop_rate=0.,
+                 attn_drop_rate=0.,
+                 drop_path_rate=0.,
+                 num_fcs=2,
+                 qkv_bias=True,
+                 qk_scale=None,
+                 act_cfg=dict(type='GELU'),
+                 norm_cfg=dict(type='LN'),
+                 window_size=1,
+                 init_cfg=None):
+
+        super().__init__(init_cfg=init_cfg)
+
+        self.norm1 = build_norm_layer(norm_cfg, embed_dims, postfix=1)[1]
+        self.attn = LocallyGroupedSelfAttention(embed_dims, num_heads,
+                                                qkv_bias, qk_scale,
+                                                attn_drop_rate, drop_rate,
+                                                window_size)
+
+        self.norm2 = build_norm_layer(norm_cfg, embed_dims, postfix=2)[1]
+        self.ffn = FFN(
+            embed_dims=embed_dims,
+            feedforward_channels=feedforward_channels,
+            num_fcs=num_fcs,
+            ffn_drop=drop_rate,
+            dropout_layer=dict(type='DropPath', drop_prob=drop_path_rate),
+            act_cfg=act_cfg,
+            add_identity=False)
+
+        self.drop_path = build_dropout(
+            dict(type='DropPath', drop_prob=drop_path_rate)
+        ) if drop_path_rate > 0. else nn.Identity()
+
+    def forward(self, x, hw_shape):
+        x = x + self.drop_path(self.attn(self.norm1(x), hw_shape))
+        x = x + self.drop_path(self.ffn(self.norm2(x)))
+        return x
+
+
+class ConditionalPositionEncoding(BaseModule):
+    """The Conditional Position Encoding (CPE) module.
+
+    The CPE is the implementation of 'Conditional Positional Encodings
+    for Vision Transformers <https://arxiv.org/abs/2102.10882>'_.
+
+    Args:
+       in_channels (int): Number of input channels.
+       embed_dims (int): The feature dimension. Default: 768.
+       stride (int): Stride of conv layer. Default: 1.
+    """
+
+    def __init__(self, in_channels, embed_dims=768, stride=1, init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        self.proj = nn.Conv2d(
+            in_channels,
+            embed_dims,
+            kernel_size=3,
+            stride=stride,
+            padding=1,
+            bias=True,
+            groups=embed_dims)
+        self.stride = stride
+
+    def forward(self, x, hw_shape):
+        b, n, c = x.shape
+        h, w = hw_shape
+        feat_token = x
+        cnn_feat = feat_token.transpose(1, 2).view(b, c, h, w)
+        if self.stride == 1:
+            x = self.proj(cnn_feat) + cnn_feat
+        else:
+            x = self.proj(cnn_feat)
+        x = x.flatten(2).transpose(1, 2)
+        return x
+
+
+@MODELS.register_module()
+class PCPVT(BaseModule):
+    """The backbone of Twins-PCPVT.
+
+    This backbone is the implementation of `Twins: Revisiting the Design
+    of Spatial Attention in Vision Transformers
+    <https://arxiv.org/abs/1512.03385>`_.
+
+    Args:
+        in_channels (int): Number of input channels. Default: 3.
+        embed_dims (list): Embedding dimension. Default: [64, 128, 256, 512].
+        patch_sizes (list): The patch sizes. Default: [4, 2, 2, 2].
+        strides (list): The strides. Default: [4, 2, 2, 2].
+        num_heads (int): Number of attention heads. Default: [1, 2, 4, 8].
+        mlp_ratios (int): Ratio of mlp hidden dim to embedding dim.
+            Default: [4, 4, 4, 4].
+        out_indices (tuple[int]): Output from which stages.
+            Default: (0, 1, 2, 3).
+        qkv_bias (bool): Enable bias for qkv if True. Default: False.
+        drop_rate (float): Probability of an element to be zeroed.
+            Default 0.
+        attn_drop_rate (float): The drop out rate for attention layer.
+            Default 0.0
+        drop_path_rate (float): Stochastic depth rate. Default 0.0
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='LN')
+        depths (list): Depths of each stage. Default [3, 4, 6, 3]
+        sr_ratios (list): Kernel_size of conv in each Attn module in
+            Transformer encoder layer. Default: [8, 4, 2, 1].
+        norm_after_stage（bool): Add extra norm. Default False.
+        init_cfg (dict, optional): The Config for initialization.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 in_channels=3,
+                 embed_dims=[64, 128, 256, 512],
+                 patch_sizes=[4, 2, 2, 2],
+                 strides=[4, 2, 2, 2],
+                 num_heads=[1, 2, 4, 8],
+                 mlp_ratios=[4, 4, 4, 4],
+                 out_indices=(0, 1, 2, 3),
+                 qkv_bias=False,
+                 drop_rate=0.,
+                 attn_drop_rate=0.,
+                 drop_path_rate=0.,
+                 norm_cfg=dict(type='LN'),
+                 depths=[3, 4, 6, 3],
+                 sr_ratios=[8, 4, 2, 1],
+                 norm_after_stage=False,
+                 pretrained=None,
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        assert not (init_cfg and pretrained), \
+            'init_cfg and pretrained cannot be set at the same time'
+        if isinstance(pretrained, str):
+            warnings.warn('DeprecationWarning: pretrained is deprecated, '
+                          'please use "init_cfg" instead')
+            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
+        elif pretrained is not None:
+            raise TypeError('pretrained must be a str or None')
+        self.depths = depths
+
+        # patch_embed
+        self.patch_embeds = ModuleList()
+        self.position_encoding_drops = ModuleList()
+        self.layers = ModuleList()
+
+        for i in range(len(depths)):
+            self.patch_embeds.append(
+                PatchEmbed(
+                    in_channels=in_channels if i == 0 else embed_dims[i - 1],
+                    embed_dims=embed_dims[i],
+                    conv_type='Conv2d',
+                    kernel_size=patch_sizes[i],
+                    stride=strides[i],
+                    padding='corner',
+                    norm_cfg=norm_cfg))
+
+            self.position_encoding_drops.append(nn.Dropout(p=drop_rate))
+
+        self.position_encodings = ModuleList([
+            ConditionalPositionEncoding(embed_dim, embed_dim)
+            for embed_dim in embed_dims
+        ])
+
+        # transformer encoder
+        dpr = [
+            x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))
+        ]  # stochastic depth decay rule
+        cur = 0
+
+        for k in range(len(depths)):
+            _block = ModuleList([
+                GSAEncoderLayer(
+                    embed_dims=embed_dims[k],
+                    num_heads=num_heads[k],
+                    feedforward_channels=mlp_ratios[k] * embed_dims[k],
+                    attn_drop_rate=attn_drop_rate,
+                    drop_rate=drop_rate,
+                    drop_path_rate=dpr[cur + i],
+                    num_fcs=2,
+                    qkv_bias=qkv_bias,
+                    act_cfg=dict(type='GELU'),
+                    norm_cfg=dict(type='LN'),
+                    sr_ratio=sr_ratios[k]) for i in range(depths[k])
+            ])
+            self.layers.append(_block)
+            cur += depths[k]
+
+        self.norm_name, norm = build_norm_layer(
+            norm_cfg, embed_dims[-1], postfix=1)
+
+        self.out_indices = out_indices
+        self.norm_after_stage = norm_after_stage
+        if self.norm_after_stage:
+            self.norm_list = ModuleList()
+            for dim in embed_dims:
+                self.norm_list.append(build_norm_layer(norm_cfg, dim)[1])
+
+    def init_weights(self):
+        if self.init_cfg is not None:
+            super().init_weights()
+        else:
+            for m in self.modules():
+                if isinstance(m, nn.Linear):
+                    trunc_normal_init(m, std=.02, bias=0.)
+                elif isinstance(m, (_BatchNorm, nn.GroupNorm, nn.LayerNorm)):
+                    constant_init(m, val=1.0, bias=0.)
+                elif isinstance(m, nn.Conv2d):
+                    fan_out = m.kernel_size[0] * m.kernel_size[
+                        1] * m.out_channels
+                    fan_out //= m.groups
+                    normal_init(
+                        m, mean=0, std=math.sqrt(2.0 / fan_out), bias=0)
+
+    def forward(self, x):
+        outputs = list()
+
+        b = x.shape[0]
+
+        for i in range(len(self.depths)):
+            x, hw_shape = self.patch_embeds[i](x)
+            h, w = hw_shape
+            x = self.position_encoding_drops[i](x)
+            for j, blk in enumerate(self.layers[i]):
+                x = blk(x, hw_shape)
+                if j == 0:
+                    x = self.position_encodings[i](x, hw_shape)
+            if self.norm_after_stage:
+                x = self.norm_list[i](x)
+            x = x.reshape(b, h, w, -1).permute(0, 3, 1, 2).contiguous()
+
+            if i in self.out_indices:
+                outputs.append(x)
+
+        return tuple(outputs)
+
+
+@MODELS.register_module()
+class SVT(PCPVT):
+    """The backbone of Twins-SVT.
+
+    This backbone is the implementation of `Twins: Revisiting the Design
+    of Spatial Attention in Vision Transformers
+    <https://arxiv.org/abs/1512.03385>`_.
+
+    Args:
+        in_channels (int): Number of input channels. Default: 3.
+        embed_dims (list): Embedding dimension. Default: [64, 128, 256, 512].
+        patch_sizes (list): The patch sizes. Default: [4, 2, 2, 2].
+        strides (list): The strides. Default: [4, 2, 2, 2].
+        num_heads (int): Number of attention heads. Default: [1, 2, 4].
+        mlp_ratios (int): Ratio of mlp hidden dim to embedding dim.
+            Default: [4, 4, 4].
+        out_indices (tuple[int]): Output from which stages.
+            Default: (0, 1, 2, 3).
+        qkv_bias (bool): Enable bias for qkv if True. Default: False.
+        drop_rate (float): Dropout rate. Default 0.
+        attn_drop_rate (float): Dropout ratio of attention weight.
+            Default 0.0
+        drop_path_rate (float): Stochastic depth rate. Default 0.2.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='LN')
+        depths (list): Depths of each stage. Default [4, 4, 4].
+        sr_ratios (list): Kernel_size of conv in each Attn module in
+            Transformer encoder layer. Default: [4, 2, 1].
+        windiow_sizes (list): Window size of LSA. Default: [7, 7, 7],
+        input_features_slice（bool): Input features need slice. Default: False.
+        norm_after_stage（bool): Add extra norm. Default False.
+        strides (list): Strides in patch-Embedding modules. Default: (2, 2, 2)
+        init_cfg (dict, optional): The Config for initialization.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 in_channels=3,
+                 embed_dims=[64, 128, 256],
+                 patch_sizes=[4, 2, 2, 2],
+                 strides=[4, 2, 2, 2],
+                 num_heads=[1, 2, 4],
+                 mlp_ratios=[4, 4, 4],
+                 out_indices=(0, 1, 2, 3),
+                 qkv_bias=False,
+                 drop_rate=0.,
+                 attn_drop_rate=0.,
+                 drop_path_rate=0.2,
+                 norm_cfg=dict(type='LN'),
+                 depths=[4, 4, 4],
+                 sr_ratios=[4, 2, 1],
+                 windiow_sizes=[7, 7, 7],
+                 norm_after_stage=True,
+                 pretrained=None,
+                 init_cfg=None):
+        super().__init__(in_channels, embed_dims, patch_sizes, strides,
+                         num_heads, mlp_ratios, out_indices, qkv_bias,
+                         drop_rate, attn_drop_rate, drop_path_rate, norm_cfg,
+                         depths, sr_ratios, norm_after_stage, pretrained,
+                         init_cfg)
+        # transformer encoder
+        dpr = [
+            x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))
+        ]  # stochastic depth decay rule
+
+        for k in range(len(depths)):
+            for i in range(depths[k]):
+                if i % 2 == 0:
+                    self.layers[k][i] = \
+                        LSAEncoderLayer(
+                            embed_dims=embed_dims[k],
+                            num_heads=num_heads[k],
+                            feedforward_channels=mlp_ratios[k] * embed_dims[k],
+                            drop_rate=drop_rate,
+                            attn_drop_rate=attn_drop_rate,
+                            drop_path_rate=dpr[sum(depths[:k])+i],
+                            qkv_bias=qkv_bias,
+                            window_size=windiow_sizes[k])
diff --git a/mmsegmentation/mmseg/models/backbones/unet.py b/mmsegmentation/mmseg/models/backbones/unet.py
new file mode 100644
index 0000000..545921d
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/unet.py
@@ -0,0 +1,436 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+import torch.nn as nn
+import torch.utils.checkpoint as cp
+from mmcv.cnn import ConvModule, build_activation_layer, build_norm_layer
+from mmengine.model import BaseModule
+from mmengine.utils.dl_utils.parrots_wrapper import _BatchNorm
+
+from mmseg.registry import MODELS
+from ..utils import UpConvBlock, Upsample
+
+
+class BasicConvBlock(nn.Module):
+    """Basic convolutional block for UNet.
+
+    This module consists of several plain convolutional layers.
+
+    Args:
+        in_channels (int): Number of input channels.
+        out_channels (int): Number of output channels.
+        num_convs (int): Number of convolutional layers. Default: 2.
+        stride (int): Whether use stride convolution to downsample
+            the input feature map. If stride=2, it only uses stride convolution
+            in the first convolutional layer to downsample the input feature
+            map. Options are 1 or 2. Default: 1.
+        dilation (int): Whether use dilated convolution to expand the
+            receptive field. Set dilation rate of each convolutional layer and
+            the dilation rate of the first convolutional layer is always 1.
+            Default: 1.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed. Default: False.
+        conv_cfg (dict | None): Config dict for convolution layer.
+            Default: None.
+        norm_cfg (dict | None): Config dict for normalization layer.
+            Default: dict(type='BN').
+        act_cfg (dict | None): Config dict for activation layer in ConvModule.
+            Default: dict(type='ReLU').
+        dcn (bool): Use deformable convolution in convolutional layer or not.
+            Default: None.
+        plugins (dict): plugins for convolutional layers. Default: None.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 num_convs=2,
+                 stride=1,
+                 dilation=1,
+                 with_cp=False,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 dcn=None,
+                 plugins=None):
+        super().__init__()
+        assert dcn is None, 'Not implemented yet.'
+        assert plugins is None, 'Not implemented yet.'
+
+        self.with_cp = with_cp
+        convs = []
+        for i in range(num_convs):
+            convs.append(
+                ConvModule(
+                    in_channels=in_channels if i == 0 else out_channels,
+                    out_channels=out_channels,
+                    kernel_size=3,
+                    stride=stride if i == 0 else 1,
+                    dilation=1 if i == 0 else dilation,
+                    padding=1 if i == 0 else dilation,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg))
+
+        self.convs = nn.Sequential(*convs)
+
+    def forward(self, x):
+        """Forward function."""
+
+        if self.with_cp and x.requires_grad:
+            out = cp.checkpoint(self.convs, x)
+        else:
+            out = self.convs(x)
+        return out
+
+
+@MODELS.register_module()
+class DeconvModule(nn.Module):
+    """Deconvolution upsample module in decoder for UNet (2X upsample).
+
+    This module uses deconvolution to upsample feature map in the decoder
+    of UNet.
+
+    Args:
+        in_channels (int): Number of input channels.
+        out_channels (int): Number of output channels.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed. Default: False.
+        norm_cfg (dict | None): Config dict for normalization layer.
+            Default: dict(type='BN').
+        act_cfg (dict | None): Config dict for activation layer in ConvModule.
+            Default: dict(type='ReLU').
+        kernel_size (int): Kernel size of the convolutional layer. Default: 4.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 with_cp=False,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 *,
+                 kernel_size=4,
+                 scale_factor=2):
+        super().__init__()
+
+        assert (kernel_size - scale_factor >= 0) and\
+               (kernel_size - scale_factor) % 2 == 0,\
+               f'kernel_size should be greater than or equal to scale_factor '\
+               f'and (kernel_size - scale_factor) should be even numbers, '\
+               f'while the kernel size is {kernel_size} and scale_factor is '\
+               f'{scale_factor}.'
+
+        stride = scale_factor
+        padding = (kernel_size - scale_factor) // 2
+        self.with_cp = with_cp
+        deconv = nn.ConvTranspose2d(
+            in_channels,
+            out_channels,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=padding)
+
+        norm_name, norm = build_norm_layer(norm_cfg, out_channels)
+        activate = build_activation_layer(act_cfg)
+        self.deconv_upsamping = nn.Sequential(deconv, norm, activate)
+
+    def forward(self, x):
+        """Forward function."""
+
+        if self.with_cp and x.requires_grad:
+            out = cp.checkpoint(self.deconv_upsamping, x)
+        else:
+            out = self.deconv_upsamping(x)
+        return out
+
+
+@MODELS.register_module()
+class InterpConv(nn.Module):
+    """Interpolation upsample module in decoder for UNet.
+
+    This module uses interpolation to upsample feature map in the decoder
+    of UNet. It consists of one interpolation upsample layer and one
+    convolutional layer. It can be one interpolation upsample layer followed
+    by one convolutional layer (conv_first=False) or one convolutional layer
+    followed by one interpolation upsample layer (conv_first=True).
+
+    Args:
+        in_channels (int): Number of input channels.
+        out_channels (int): Number of output channels.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed. Default: False.
+        norm_cfg (dict | None): Config dict for normalization layer.
+            Default: dict(type='BN').
+        act_cfg (dict | None): Config dict for activation layer in ConvModule.
+            Default: dict(type='ReLU').
+        conv_cfg (dict | None): Config dict for convolution layer.
+            Default: None.
+        conv_first (bool): Whether convolutional layer or interpolation
+            upsample layer first. Default: False. It means interpolation
+            upsample layer followed by one convolutional layer.
+        kernel_size (int): Kernel size of the convolutional layer. Default: 1.
+        stride (int): Stride of the convolutional layer. Default: 1.
+        padding (int): Padding of the convolutional layer. Default: 1.
+        upsample_cfg (dict): Interpolation config of the upsample layer.
+            Default: dict(
+                scale_factor=2, mode='bilinear', align_corners=False).
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 with_cp=False,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 *,
+                 conv_cfg=None,
+                 conv_first=False,
+                 kernel_size=1,
+                 stride=1,
+                 padding=0,
+                 upsample_cfg=dict(
+                     scale_factor=2, mode='bilinear', align_corners=False)):
+        super().__init__()
+
+        self.with_cp = with_cp
+        conv = ConvModule(
+            in_channels,
+            out_channels,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=padding,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        upsample = Upsample(**upsample_cfg)
+        if conv_first:
+            self.interp_upsample = nn.Sequential(conv, upsample)
+        else:
+            self.interp_upsample = nn.Sequential(upsample, conv)
+
+    def forward(self, x):
+        """Forward function."""
+
+        if self.with_cp and x.requires_grad:
+            out = cp.checkpoint(self.interp_upsample, x)
+        else:
+            out = self.interp_upsample(x)
+        return out
+
+
+@MODELS.register_module()
+class UNet(BaseModule):
+    """UNet backbone.
+
+    This backbone is the implementation of `U-Net: Convolutional Networks
+    for Biomedical Image Segmentation <https://arxiv.org/abs/1505.04597>`_.
+
+    Args:
+        in_channels (int): Number of input image channels. Default" 3.
+        base_channels (int): Number of base channels of each stage.
+            The output channels of the first stage. Default: 64.
+        num_stages (int): Number of stages in encoder, normally 5. Default: 5.
+        strides (Sequence[int 1 | 2]): Strides of each stage in encoder.
+            len(strides) is equal to num_stages. Normally the stride of the
+            first stage in encoder is 1. If strides[i]=2, it uses stride
+            convolution to downsample in the correspondence encoder stage.
+            Default: (1, 1, 1, 1, 1).
+        enc_num_convs (Sequence[int]): Number of convolutional layers in the
+            convolution block of the correspondence encoder stage.
+            Default: (2, 2, 2, 2, 2).
+        dec_num_convs (Sequence[int]): Number of convolutional layers in the
+            convolution block of the correspondence decoder stage.
+            Default: (2, 2, 2, 2).
+        downsamples (Sequence[int]): Whether use MaxPool to downsample the
+            feature map after the first stage of encoder
+            (stages: [1, num_stages)). If the correspondence encoder stage use
+            stride convolution (strides[i]=2), it will never use MaxPool to
+            downsample, even downsamples[i-1]=True.
+            Default: (True, True, True, True).
+        enc_dilations (Sequence[int]): Dilation rate of each stage in encoder.
+            Default: (1, 1, 1, 1, 1).
+        dec_dilations (Sequence[int]): Dilation rate of each stage in decoder.
+            Default: (1, 1, 1, 1).
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed. Default: False.
+        conv_cfg (dict | None): Config dict for convolution layer.
+            Default: None.
+        norm_cfg (dict | None): Config dict for normalization layer.
+            Default: dict(type='BN').
+        act_cfg (dict | None): Config dict for activation layer in ConvModule.
+            Default: dict(type='ReLU').
+        upsample_cfg (dict): The upsample config of the upsample module in
+            decoder. Default: dict(type='InterpConv').
+        norm_eval (bool): Whether to set norm layers to eval mode, namely,
+            freeze running stats (mean and var). Note: Effect on Batch Norm
+            and its variants only. Default: False.
+        dcn (bool): Use deformable convolution in convolutional layer or not.
+            Default: None.
+        plugins (dict): plugins for convolutional layers. Default: None.
+        pretrained (str, optional): model pretrained path. Default: None
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None
+
+    Notice:
+        The input image size should be divisible by the whole downsample rate
+        of the encoder. More detail of the whole downsample rate can be found
+        in UNet._check_input_divisible.
+    """
+
+    def __init__(self,
+                 in_channels=3,
+                 base_channels=64,
+                 num_stages=5,
+                 strides=(1, 1, 1, 1, 1),
+                 enc_num_convs=(2, 2, 2, 2, 2),
+                 dec_num_convs=(2, 2, 2, 2),
+                 downsamples=(True, True, True, True),
+                 enc_dilations=(1, 1, 1, 1, 1),
+                 dec_dilations=(1, 1, 1, 1),
+                 with_cp=False,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 upsample_cfg=dict(type='InterpConv'),
+                 norm_eval=False,
+                 dcn=None,
+                 plugins=None,
+                 pretrained=None,
+                 init_cfg=None):
+        super().__init__(init_cfg)
+
+        self.pretrained = pretrained
+        assert not (init_cfg and pretrained), \
+            'init_cfg and pretrained cannot be setting at the same time'
+        if isinstance(pretrained, str):
+            warnings.warn('DeprecationWarning: pretrained is a deprecated, '
+                          'please use "init_cfg" instead')
+            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
+        elif pretrained is None:
+            if init_cfg is None:
+                self.init_cfg = [
+                    dict(type='Kaiming', layer='Conv2d'),
+                    dict(
+                        type='Constant',
+                        val=1,
+                        layer=['_BatchNorm', 'GroupNorm'])
+                ]
+        else:
+            raise TypeError('pretrained must be a str or None')
+
+        assert dcn is None, 'Not implemented yet.'
+        assert plugins is None, 'Not implemented yet.'
+        assert len(strides) == num_stages, \
+            'The length of strides should be equal to num_stages, '\
+            f'while the strides is {strides}, the length of '\
+            f'strides is {len(strides)}, and the num_stages is '\
+            f'{num_stages}.'
+        assert len(enc_num_convs) == num_stages, \
+            'The length of enc_num_convs should be equal to num_stages, '\
+            f'while the enc_num_convs is {enc_num_convs}, the length of '\
+            f'enc_num_convs is {len(enc_num_convs)}, and the num_stages is '\
+            f'{num_stages}.'
+        assert len(dec_num_convs) == (num_stages-1), \
+            'The length of dec_num_convs should be equal to (num_stages-1), '\
+            f'while the dec_num_convs is {dec_num_convs}, the length of '\
+            f'dec_num_convs is {len(dec_num_convs)}, and the num_stages is '\
+            f'{num_stages}.'
+        assert len(downsamples) == (num_stages-1), \
+            'The length of downsamples should be equal to (num_stages-1), '\
+            f'while the downsamples is {downsamples}, the length of '\
+            f'downsamples is {len(downsamples)}, and the num_stages is '\
+            f'{num_stages}.'
+        assert len(enc_dilations) == num_stages, \
+            'The length of enc_dilations should be equal to num_stages, '\
+            f'while the enc_dilations is {enc_dilations}, the length of '\
+            f'enc_dilations is {len(enc_dilations)}, and the num_stages is '\
+            f'{num_stages}.'
+        assert len(dec_dilations) == (num_stages-1), \
+            'The length of dec_dilations should be equal to (num_stages-1), '\
+            f'while the dec_dilations is {dec_dilations}, the length of '\
+            f'dec_dilations is {len(dec_dilations)}, and the num_stages is '\
+            f'{num_stages}.'
+        self.num_stages = num_stages
+        self.strides = strides
+        self.downsamples = downsamples
+        self.norm_eval = norm_eval
+        self.base_channels = base_channels
+
+        self.encoder = nn.ModuleList()
+        self.decoder = nn.ModuleList()
+
+        for i in range(num_stages):
+            enc_conv_block = []
+            if i != 0:
+                if strides[i] == 1 and downsamples[i - 1]:
+                    enc_conv_block.append(nn.MaxPool2d(kernel_size=2))
+                upsample = (strides[i] != 1 or downsamples[i - 1])
+                self.decoder.append(
+                    UpConvBlock(
+                        conv_block=BasicConvBlock,
+                        in_channels=base_channels * 2**i,
+                        skip_channels=base_channels * 2**(i - 1),
+                        out_channels=base_channels * 2**(i - 1),
+                        num_convs=dec_num_convs[i - 1],
+                        stride=1,
+                        dilation=dec_dilations[i - 1],
+                        with_cp=with_cp,
+                        conv_cfg=conv_cfg,
+                        norm_cfg=norm_cfg,
+                        act_cfg=act_cfg,
+                        upsample_cfg=upsample_cfg if upsample else None,
+                        dcn=None,
+                        plugins=None))
+
+            enc_conv_block.append(
+                BasicConvBlock(
+                    in_channels=in_channels,
+                    out_channels=base_channels * 2**i,
+                    num_convs=enc_num_convs[i],
+                    stride=strides[i],
+                    dilation=enc_dilations[i],
+                    with_cp=with_cp,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg,
+                    dcn=None,
+                    plugins=None))
+            self.encoder.append(nn.Sequential(*enc_conv_block))
+            in_channels = base_channels * 2**i
+
+    def forward(self, x):
+        self._check_input_divisible(x)
+        enc_outs = []
+        for enc in self.encoder:
+            x = enc(x)
+            enc_outs.append(x)
+        dec_outs = [x]
+        for i in reversed(range(len(self.decoder))):
+            x = self.decoder[i](enc_outs[i], x)
+            dec_outs.append(x)
+
+        return dec_outs
+
+    def train(self, mode=True):
+        """Convert the model into training mode while keep normalization layer
+        freezed."""
+        super().train(mode)
+        if mode and self.norm_eval:
+            for m in self.modules():
+                # trick: eval have effect on BatchNorm only
+                if isinstance(m, _BatchNorm):
+                    m.eval()
+
+    def _check_input_divisible(self, x):
+        h, w = x.shape[-2:]
+        whole_downsample_rate = 1
+        for i in range(1, self.num_stages):
+            if self.strides[i] == 2 or self.downsamples[i - 1]:
+                whole_downsample_rate *= 2
+        assert (h % whole_downsample_rate == 0) \
+            and (w % whole_downsample_rate == 0),\
+            f'The input image size {(h, w)} should be divisible by the whole '\
+            f'downsample rate {whole_downsample_rate}, when num_stages is '\
+            f'{self.num_stages}, strides is {self.strides}, and downsamples '\
+            f'is {self.downsamples}.'
diff --git a/mmsegmentation/mmseg/models/backbones/vit.py b/mmsegmentation/mmseg/models/backbones/vit.py
new file mode 100644
index 0000000..dd0f688
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/vit.py
@@ -0,0 +1,501 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+import warnings
+
+import torch
+import torch.nn as nn
+import torch.utils.checkpoint as cp
+from mmcv.cnn import build_norm_layer
+from mmcv.cnn.bricks.transformer import FFN, MultiheadAttention
+from mmengine.logging import print_log
+from mmengine.model import BaseModule, ModuleList
+from mmengine.model.weight_init import (constant_init, kaiming_init,
+                                        trunc_normal_)
+from mmengine.runner.checkpoint import CheckpointLoader, load_state_dict
+from torch.nn.modules.batchnorm import _BatchNorm
+from torch.nn.modules.utils import _pair as to_2tuple
+
+from mmseg.registry import MODELS
+from ..utils import PatchEmbed, resize
+
+
+class TransformerEncoderLayer(BaseModule):
+    """Implements one encoder layer in Vision Transformer.
+
+    Args:
+        embed_dims (int): The feature dimension.
+        num_heads (int): Parallel attention heads.
+        feedforward_channels (int): The hidden dimension for FFNs.
+        drop_rate (float): Probability of an element to be zeroed
+            after the feed forward layer. Default: 0.0.
+        attn_drop_rate (float): The drop out rate for attention layer.
+            Default: 0.0.
+        drop_path_rate (float): stochastic depth rate. Default 0.0.
+        num_fcs (int): The number of fully-connected layers for FFNs.
+            Default: 2.
+        qkv_bias (bool): enable bias for qkv if True. Default: True
+        act_cfg (dict): The activation config for FFNs.
+            Default: dict(type='GELU').
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='LN').
+        batch_first (bool): Key, Query and Value are shape of
+            (batch, n, embed_dim)
+            or (n, batch, embed_dim). Default: True.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save
+            some memory while slowing down the training speed. Default: False.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 num_heads,
+                 feedforward_channels,
+                 drop_rate=0.,
+                 attn_drop_rate=0.,
+                 drop_path_rate=0.,
+                 num_fcs=2,
+                 qkv_bias=True,
+                 act_cfg=dict(type='GELU'),
+                 norm_cfg=dict(type='LN'),
+                 batch_first=True,
+                 attn_cfg=dict(),
+                 ffn_cfg=dict(),
+                 with_cp=False):
+        super().__init__()
+
+        self.norm1_name, norm1 = build_norm_layer(
+            norm_cfg, embed_dims, postfix=1)
+        self.add_module(self.norm1_name, norm1)
+
+        attn_cfg.update(
+            dict(
+                embed_dims=embed_dims,
+                num_heads=num_heads,
+                attn_drop=attn_drop_rate,
+                proj_drop=drop_rate,
+                batch_first=batch_first,
+                bias=qkv_bias))
+
+        self.build_attn(attn_cfg)
+
+        self.norm2_name, norm2 = build_norm_layer(
+            norm_cfg, embed_dims, postfix=2)
+        self.add_module(self.norm2_name, norm2)
+
+        ffn_cfg.update(
+            dict(
+                embed_dims=embed_dims,
+                feedforward_channels=feedforward_channels,
+                num_fcs=num_fcs,
+                ffn_drop=drop_rate,
+                dropout_layer=dict(type='DropPath', drop_prob=drop_path_rate)
+                if drop_path_rate > 0 else None,
+                act_cfg=act_cfg))
+        self.build_ffn(ffn_cfg)
+        self.with_cp = with_cp
+
+    def build_attn(self, attn_cfg):
+        self.attn = MultiheadAttention(**attn_cfg)
+
+    def build_ffn(self, ffn_cfg):
+        self.ffn = FFN(**ffn_cfg)
+
+    @property
+    def norm1(self):
+        return getattr(self, self.norm1_name)
+
+    @property
+    def norm2(self):
+        return getattr(self, self.norm2_name)
+
+    def forward(self, x):
+
+        def _inner_forward(x):
+            x = self.attn(self.norm1(x), identity=x)
+            x = self.ffn(self.norm2(x), identity=x)
+            return x
+
+        if self.with_cp and x.requires_grad:
+            x = cp.checkpoint(_inner_forward, x)
+        else:
+            x = _inner_forward(x)
+        return x
+
+
+@MODELS.register_module()
+class VisionTransformer(BaseModule):
+    """Vision Transformer.
+
+    This backbone is the implementation of `An Image is Worth 16x16 Words:
+    Transformers for Image Recognition at
+    Scale <https://arxiv.org/abs/2010.11929>`_.
+
+    Args:
+        img_size (int | tuple): Input image size. Default: 224.
+        patch_size (int): The patch size. Default: 16.
+        patch_pad  (str | int | None): The padding method in patch embedding.
+            Default: 'corner'.
+        in_channels (int): Number of input channels. Default: 3.
+        embed_dims (int): embedding dimension. Default: 768.
+        num_layers (int): depth of transformer. Default: 12.
+        num_heads (int): number of attention heads. Default: 12.
+        mlp_ratio (int): ratio of mlp hidden dim to embedding dim.
+            Default: 4.
+        out_origin (bool): Whether to output the original input embedding.
+            Default: False
+        out_indices (list | tuple | int): Output from which stages.
+            Default: -1.
+        qkv_bias (bool): enable bias for qkv if True. Default: True.
+        drop_rate (float): Probability of an element to be zeroed.
+            Default 0.0
+        attn_drop_rate (float): The drop out rate for attention layer.
+            Default 0.0
+        drop_path_rate (float): stochastic depth rate. Default 0.0
+        with_cls_token (bool): Whether concatenating class token into image
+            tokens as transformer input. Default: True.
+        output_cls_token (bool): Whether output the cls_token. If set True,
+            `with_cls_token` must be True. Default: False.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='LN')
+        act_cfg (dict): The activation config for FFNs.
+            Default: dict(type='GELU').
+        patch_bias (dict): Whether use bias in convolution of PatchEmbed Block.
+            Default: True.
+        patch_norm (bool): Whether to add a norm in PatchEmbed Block.
+            Default: False.
+        pre_norm (bool): Whether to add a norm before Transformer Layers.
+            Default: False.
+        final_norm (bool): Whether to add a additional layer to normalize
+            final feature map. Default: False.
+        interpolate_mode (str): Select the interpolate mode for position
+            embeding vector resize. Default: bicubic.
+        num_fcs (int): The number of fully-connected layers for FFNs.
+            Default: 2.
+        norm_eval (bool): Whether to set norm layers to eval mode, namely,
+            freeze running stats (mean and var). Note: Effect on Batch Norm
+            and its variants only. Default: False.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save
+            some memory while slowing down the training speed. Default: False.
+        frozen_exclude (List): List of parameters that are not to be frozen.
+            Default: ["all"], "all" means there are no frozen parameters.
+        pretrained (str, optional): model pretrained path. Default: None.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    """
+
+    def __init__(self,
+                 img_size=224,
+                 patch_size=16,
+                 patch_pad='corner',
+                 in_channels=3,
+                 embed_dims=768,
+                 num_layers=12,
+                 num_heads=12,
+                 mlp_ratio=4,
+                 out_origin=False,
+                 out_indices=-1,
+                 qkv_bias=True,
+                 drop_rate=0.,
+                 attn_drop_rate=0.,
+                 drop_path_rate=0.,
+                 with_cls_token=True,
+                 output_cls_token=False,
+                 norm_cfg=dict(type='LN'),
+                 act_cfg=dict(type='GELU'),
+                 patch_norm=False,
+                 patch_bias=False,
+                 pre_norm=False,
+                 final_norm=False,
+                 interpolate_mode='bicubic',
+                 num_fcs=2,
+                 norm_eval=False,
+                 with_cp=False,
+                 frozen_exclude=['all'],
+                 pretrained=None,
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+
+        if isinstance(img_size, int):
+            img_size = to_2tuple(img_size)
+        elif isinstance(img_size, tuple):
+            if len(img_size) == 1:
+                img_size = to_2tuple(img_size[0])
+            assert len(img_size) == 2, \
+                f'The size of image should have length 1 or 2, ' \
+                f'but got {len(img_size)}'
+
+        if output_cls_token:
+            assert with_cls_token is True, f'with_cls_token must be True if' \
+                f'set output_cls_token to True, but got {with_cls_token}'
+
+        assert not (init_cfg and pretrained), \
+            'init_cfg and pretrained cannot be set at the same time'
+        if isinstance(pretrained, str):
+            warnings.warn('DeprecationWarning: pretrained is deprecated, '
+                          'please use "init_cfg" instead')
+            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
+        elif pretrained is not None:
+            raise TypeError('pretrained must be a str or None')
+
+        self.img_size = img_size
+        self.patch_size = patch_size
+        self.interpolate_mode = interpolate_mode
+        self.norm_eval = norm_eval
+        self.with_cp = with_cp
+        self.pretrained = pretrained
+        self.out_origin = out_origin
+        self.frozen_exclude = frozen_exclude
+
+        self.patch_embed = PatchEmbed(
+            in_channels=in_channels,
+            embed_dims=embed_dims,
+            conv_type='Conv2d',
+            kernel_size=patch_size,
+            stride=patch_size,
+            padding=patch_pad,
+            bias=patch_bias,
+            norm_cfg=norm_cfg if patch_norm else None,
+            init_cfg=None,
+        )
+
+        num_patches = (img_size[0] // patch_size) * \
+            (img_size[1] // patch_size)
+
+        self.with_cls_token = with_cls_token
+        self.output_cls_token = output_cls_token
+        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dims))
+        self.pos_embed = nn.Parameter(
+            torch.zeros(1, num_patches + 1, embed_dims))
+        self.drop_after_pos = nn.Dropout(p=drop_rate)
+        self.pre_norm = pre_norm
+
+        if self.pre_norm:
+            self.pre_ln_name, pre_ln = build_norm_layer(
+                norm_cfg, embed_dims, postfix='_pre')
+            self.add_module(self.pre_ln_name, pre_ln)
+
+        if isinstance(out_indices, int):
+            if out_indices == -1:
+                out_indices = num_layers - 1
+            self.out_indices = [out_indices]
+        elif isinstance(out_indices, list) or isinstance(out_indices, tuple):
+            self.out_indices = out_indices
+        else:
+            raise TypeError('out_indices must be type of int, list or tuple')
+
+        dpr = [
+            x.item() for x in torch.linspace(0, drop_path_rate, num_layers)
+        ]  # stochastic depth decay rule
+
+        self.layers = ModuleList()
+        for i in range(num_layers):
+            self.layers.append(
+                TransformerEncoderLayer(
+                    embed_dims=embed_dims,
+                    num_heads=num_heads,
+                    feedforward_channels=mlp_ratio * embed_dims,
+                    attn_drop_rate=attn_drop_rate,
+                    drop_rate=drop_rate,
+                    drop_path_rate=dpr[i],
+                    num_fcs=num_fcs,
+                    qkv_bias=qkv_bias,
+                    act_cfg=act_cfg,
+                    norm_cfg=norm_cfg,
+                    with_cp=with_cp,
+                    batch_first=True))
+
+        self.final_norm = final_norm
+        if final_norm:
+            self.norm1_name, norm1 = build_norm_layer(
+                norm_cfg, embed_dims, postfix=1)
+            self.add_module(self.norm1_name, norm1)
+
+        self._freeze()
+
+    @property
+    def pre_ln(self):
+        return getattr(self, self.pre_ln_name)
+
+    @property
+    def norm1(self):
+        return getattr(self, self.norm1_name)
+
+    def init_weights(self):
+        if isinstance(self.init_cfg, dict) and \
+                self.init_cfg.get('type') in ['Pretrained', 'Pretrained_Part']:
+            checkpoint = CheckpointLoader.load_checkpoint(
+                self.init_cfg['checkpoint'], logger=None, map_location='cpu')
+
+            if self.init_cfg.get('type') == 'Pretrained':
+                if 'state_dict' in checkpoint:
+                    state_dict = checkpoint['state_dict']
+                else:
+                    state_dict = checkpoint
+
+            elif self.init_cfg.get('type') == 'Pretrained_Part':
+                state_dict = checkpoint.copy()
+                para_prefix = 'image_encoder'
+                prefix_len = len(para_prefix) + 1
+                for k, v in checkpoint.items():
+                    state_dict.pop(k)
+                    if para_prefix in k:
+                        state_dict[k[prefix_len:]] = v
+
+            if 'pos_embed' in state_dict.keys():
+                if self.pos_embed.shape != state_dict['pos_embed'].shape:
+                    print_log(msg=f'Resize the pos_embed shape from '
+                              f'{state_dict["pos_embed"].shape} to '
+                              f'{self.pos_embed.shape}')
+                    h, w = self.img_size
+                    pos_size = int(
+                        math.sqrt(state_dict['pos_embed'].shape[1] - 1))
+                    state_dict['pos_embed'] = self.resize_pos_embed(
+                        state_dict['pos_embed'],
+                        (h // self.patch_size, w // self.patch_size),
+                        (pos_size, pos_size), self.interpolate_mode)
+
+            load_state_dict(self, state_dict, strict=False, logger=None)
+        elif self.init_cfg is not None:
+            super().init_weights()
+        else:
+            # We only implement the 'jax_impl' initialization implemented at
+            # https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/vision_transformer.py#L353  # noqa: E501
+            trunc_normal_(self.pos_embed, std=.02)
+            trunc_normal_(self.cls_token, std=.02)
+            for n, m in self.named_modules():
+                if isinstance(m, nn.Linear):
+                    trunc_normal_(m.weight, std=.02)
+                    if m.bias is not None:
+                        if 'ffn' in n:
+                            nn.init.normal_(m.bias, mean=0., std=1e-6)
+                        else:
+                            nn.init.constant_(m.bias, 0)
+                elif isinstance(m, nn.Conv2d):
+                    kaiming_init(m, mode='fan_in', bias=0.)
+                elif isinstance(m, (_BatchNorm, nn.GroupNorm, nn.LayerNorm)):
+                    constant_init(m, val=1.0, bias=0.)
+
+    def _freeze(self):
+        if 'all' in self.frozen_exclude:
+            return
+        for name, param in self.named_parameters():
+            if not any([exclude in name for exclude in self.frozen_exclude]):
+                param.requires_grad = False
+
+    def _pos_embeding(self, patched_img, hw_shape, pos_embed):
+        """Positioning embeding method.
+
+        Resize the pos_embed, if the input image size doesn't match
+            the training size.
+        Args:
+            patched_img (torch.Tensor): The patched image, it should be
+                shape of [B, L1, C].
+            hw_shape (tuple): The downsampled image resolution.
+            pos_embed (torch.Tensor): The pos_embed weighs, it should be
+                shape of [B, L2, c].
+        Return:
+            torch.Tensor: The pos encoded image feature.
+        """
+        assert patched_img.ndim == 3 and pos_embed.ndim == 3, \
+            'the shapes of patched_img and pos_embed must be [B, L, C]'
+        x_len, pos_len = patched_img.shape[1], pos_embed.shape[1]
+        if x_len != pos_len:
+            if pos_len == (self.img_size[0] // self.patch_size) * (
+                    self.img_size[1] // self.patch_size) + 1:
+                pos_h = self.img_size[0] // self.patch_size
+                pos_w = self.img_size[1] // self.patch_size
+            else:
+                raise ValueError(
+                    'Unexpected shape of pos_embed, got {}.'.format(
+                        pos_embed.shape))
+            pos_embed = self.resize_pos_embed(pos_embed, hw_shape,
+                                              (pos_h, pos_w),
+                                              self.interpolate_mode)
+        return self.drop_after_pos(patched_img + pos_embed)
+
+    @staticmethod
+    def resize_pos_embed(pos_embed, input_shpae, pos_shape, mode):
+        """Resize pos_embed weights.
+
+        Resize pos_embed using bicubic interpolate method.
+        Args:
+            pos_embed (torch.Tensor): Position embedding weights.
+            input_shpae (tuple): Tuple for (downsampled input image height,
+                downsampled input image width).
+            pos_shape (tuple): The resolution of downsampled origin training
+                image.
+            mode (str): Algorithm used for upsampling:
+                ``'nearest'`` | ``'linear'`` | ``'bilinear'`` | ``'bicubic'`` |
+                ``'trilinear'``. Default: ``'nearest'``
+        Return:
+            torch.Tensor: The resized pos_embed of shape [B, L_new, C]
+        """
+        assert pos_embed.ndim == 3, 'shape of pos_embed must be [B, L, C]'
+        pos_h, pos_w = pos_shape
+        cls_token_weight = pos_embed[:, 0]
+        pos_embed_weight = pos_embed[:, (-1 * pos_h * pos_w):]
+        pos_embed_weight = pos_embed_weight.reshape(
+            1, pos_h, pos_w, pos_embed.shape[2]).permute(0, 3, 1, 2)
+        pos_embed_weight = resize(
+            pos_embed_weight, size=input_shpae, align_corners=False, mode=mode)
+        cls_token_weight = cls_token_weight.unsqueeze(1)
+        pos_embed_weight = torch.flatten(pos_embed_weight, 2).transpose(1, 2)
+        pos_embed = torch.cat((cls_token_weight, pos_embed_weight), dim=1)
+        return pos_embed
+
+    def forward(self, inputs):
+        B = inputs.shape[0]
+
+        x, hw_shape = self.patch_embed(inputs)
+
+        # stole cls_tokens impl from Phil Wang, thanks
+        cls_tokens = self.cls_token.expand(B, -1, -1)
+        x = torch.cat((cls_tokens, x), dim=1)
+        x = self._pos_embeding(x, hw_shape, self.pos_embed)
+
+        if not self.with_cls_token:
+            # Remove class token for transformer encoder input
+            x = x[:, 1:]
+
+        if self.pre_norm:
+            x = self.pre_ln(x)
+
+        outs = []
+        if self.out_origin:
+            if self.with_cls_token:
+                # Remove class token and reshape token for decoder head
+                out = x[:, 1:]
+            else:
+                out = x
+            B, _, C = out.shape
+            out = out.reshape(B, hw_shape[0], hw_shape[1],
+                              C).permute(0, 3, 1, 2).contiguous()
+            if self.output_cls_token:
+                out = [out, x[:, 0]]
+            outs.append(out)
+
+        for i, layer in enumerate(self.layers):
+            x = layer(x)
+            if i == len(self.layers) - 1:
+                if self.final_norm:
+                    x = self.norm1(x)
+            if i in self.out_indices:
+                if self.with_cls_token:
+                    # Remove class token and reshape token for decoder head
+                    out = x[:, 1:]
+                else:
+                    out = x
+                B, _, C = out.shape
+                out = out.reshape(B, hw_shape[0], hw_shape[1],
+                                  C).permute(0, 3, 1, 2).contiguous()
+                if self.output_cls_token:
+                    out = [out, x[:, 0]]
+                outs.append(out)
+
+        return tuple(outs)
+
+    def train(self, mode=True):
+        super().train(mode)
+        if mode and self.norm_eval:
+            for m in self.modules():
+                if isinstance(m, nn.LayerNorm):
+                    m.eval()
diff --git a/mmsegmentation/mmseg/models/backbones/vpd.py b/mmsegmentation/mmseg/models/backbones/vpd.py
new file mode 100644
index 0000000..e0536d3
--- /dev/null
+++ b/mmsegmentation/mmseg/models/backbones/vpd.py
@@ -0,0 +1,395 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# ------------------------------------------------------------------------------
+# Adapted from https://github.com/wl-zhao/VPD/blob/main/vpd/models.py
+# Original licence: MIT License
+# ------------------------------------------------------------------------------
+
+import math
+from typing import List, Optional, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmengine.model import BaseModule
+from mmengine.runner import CheckpointLoader, load_checkpoint
+
+from mmseg.registry import MODELS
+from mmseg.utils import ConfigType, OptConfigType
+
+try:
+    from ldm.modules.diffusionmodules.util import timestep_embedding
+    from ldm.util import instantiate_from_config
+    has_ldm = True
+except ImportError:
+    has_ldm = False
+
+
+def register_attention_control(model, controller):
+    """Registers a control function to manage attention within a model.
+
+    Args:
+        model: The model to which attention is to be registered.
+        controller: The control function responsible for managing attention.
+    """
+
+    def ca_forward(self, place_in_unet):
+        """Custom forward method for attention.
+
+        Args:
+            self: Reference to the current object.
+            place_in_unet: The location in UNet (down/mid/up).
+
+        Returns:
+            The modified forward method.
+        """
+
+        def forward(x, context=None, mask=None):
+            h = self.heads
+            is_cross = context is not None
+            context = context or x  # if context is None, use x
+
+            q, k, v = self.to_q(x), self.to_k(context), self.to_v(context)
+            q, k, v = (
+                tensor.view(tensor.shape[0] * h, tensor.shape[1],
+                            tensor.shape[2] // h) for tensor in [q, k, v])
+
+            sim = torch.matmul(q, k.transpose(-2, -1)) * self.scale
+
+            if mask is not None:
+                mask = mask.flatten(1).unsqueeze(1).repeat(h, 1, 1)
+                max_neg_value = -torch.finfo(sim.dtype).max
+                sim.masked_fill_(~mask, max_neg_value)
+
+            attn = sim.softmax(dim=-1)
+            attn_mean = attn.view(h, attn.shape[0] // h,
+                                  *attn.shape[1:]).mean(0)
+            controller(attn_mean, is_cross, place_in_unet)
+
+            out = torch.matmul(attn, v)
+            out = out.view(out.shape[0] // h, out.shape[1], out.shape[2] * h)
+            return self.to_out(out)
+
+        return forward
+
+    def register_recr(net_, count, place_in_unet):
+        """Recursive function to register the custom forward method to all
+        CrossAttention layers.
+
+        Args:
+            net_: The network layer currently being processed.
+            count: The current count of layers processed.
+            place_in_unet: The location in UNet (down/mid/up).
+
+        Returns:
+            The updated count of layers processed.
+        """
+        if net_.__class__.__name__ == 'CrossAttention':
+            net_.forward = ca_forward(net_, place_in_unet)
+            return count + 1
+        if hasattr(net_, 'children'):
+            return sum(
+                register_recr(child, 0, place_in_unet)
+                for child in net_.children())
+        return count
+
+    cross_att_count = sum(
+        register_recr(net[1], 0, place) for net, place in [
+            (child, 'down') if 'input_blocks' in name else (
+                child, 'up') if 'output_blocks' in name else
+            (child,
+             'mid') if 'middle_block' in name else (None, None)  # Default case
+            for name, child in model.diffusion_model.named_children()
+        ] if net is not None)
+
+    controller.num_att_layers = cross_att_count
+
+
+class AttentionStore:
+    """A class for storing attention information in the UNet model.
+
+    Attributes:
+        base_size (int): Base size for storing attention information.
+        max_size (int): Maximum size for storing attention information.
+    """
+
+    def __init__(self, base_size=64, max_size=None):
+        """Initialize AttentionStore with default or custom sizes."""
+        self.reset()
+        self.base_size = base_size
+        self.max_size = max_size or (base_size // 2)
+        self.num_att_layers = -1
+
+    @staticmethod
+    def get_empty_store():
+        """Returns an empty store for holding attention values."""
+        return {
+            key: []
+            for key in [
+                'down_cross', 'mid_cross', 'up_cross', 'down_self', 'mid_self',
+                'up_self'
+            ]
+        }
+
+    def reset(self):
+        """Resets the step and attention stores to their initial states."""
+        self.cur_step = 0
+        self.cur_att_layer = 0
+        self.step_store = self.get_empty_store()
+        self.attention_store = {}
+
+    def forward(self, attn, is_cross: bool, place_in_unet: str):
+        """Processes a single forward step, storing the attention.
+
+        Args:
+            attn: The attention tensor.
+            is_cross (bool): Whether it's cross attention.
+            place_in_unet (str): The location in UNet (down/mid/up).
+
+        Returns:
+            The unmodified attention tensor.
+        """
+        key = f"{place_in_unet}_{'cross' if is_cross else 'self'}"
+        if attn.shape[1] <= (self.max_size)**2:
+            self.step_store[key].append(attn)
+        return attn
+
+    def between_steps(self):
+        """Processes and stores attention information between steps."""
+        if not self.attention_store:
+            self.attention_store = self.step_store
+        else:
+            for key in self.attention_store:
+                self.attention_store[key] = [
+                    stored + step for stored, step in zip(
+                        self.attention_store[key], self.step_store[key])
+                ]
+        self.step_store = self.get_empty_store()
+
+    def get_average_attention(self):
+        """Calculates and returns the average attention across all steps."""
+        return {
+            key: [item for item in self.step_store[key]]
+            for key in self.step_store
+        }
+
+    def __call__(self, attn, is_cross: bool, place_in_unet: str):
+        """Allows the class instance to be callable."""
+        return self.forward(attn, is_cross, place_in_unet)
+
+    @property
+    def num_uncond_att_layers(self):
+        """Returns the number of unconditional attention layers (default is
+        0)."""
+        return 0
+
+    def step_callback(self, x_t):
+        """A placeholder for a step callback.
+
+        Returns the input unchanged.
+        """
+        return x_t
+
+
+class UNetWrapper(nn.Module):
+    """A wrapper for UNet with optional attention mechanisms.
+
+    Args:
+        unet (nn.Module): The UNet model to wrap
+        use_attn (bool): Whether to use attention. Defaults to True
+        base_size (int): Base size for the attention store. Defaults to 512
+        max_attn_size (int, optional): Maximum size for the attention store.
+            Defaults to None
+        attn_selector (str): The types of attention to use.
+            Defaults to 'up_cross+down_cross'
+    """
+
+    def __init__(self,
+                 unet,
+                 use_attn=True,
+                 base_size=512,
+                 max_attn_size=None,
+                 attn_selector='up_cross+down_cross'):
+        super().__init__()
+
+        assert has_ldm, 'To use UNetWrapper, please install required ' \
+            'packages via `pip install -r requirements/optional.txt`.'
+
+        self.unet = unet
+        self.attention_store = AttentionStore(
+            base_size=base_size // 8, max_size=max_attn_size)
+        self.attn_selector = attn_selector.split('+')
+        self.use_attn = use_attn
+        self.init_sizes(base_size)
+        if self.use_attn:
+            register_attention_control(unet, self.attention_store)
+
+    def init_sizes(self, base_size):
+        """Initialize sizes based on the base size."""
+        self.size16 = base_size // 32
+        self.size32 = base_size // 16
+        self.size64 = base_size // 8
+
+    def forward(self, x, timesteps=None, context=None, y=None, **kwargs):
+        """Forward pass through the model."""
+        diffusion_model = self.unet.diffusion_model
+        if self.use_attn:
+            self.attention_store.reset()
+        hs, emb, out_list = self._unet_forward(x, timesteps, context, y,
+                                               diffusion_model)
+        if self.use_attn:
+            self._append_attn_to_output(out_list)
+        return out_list[::-1]
+
+    def _unet_forward(self, x, timesteps, context, y, diffusion_model):
+        hs = []
+        t_emb = timestep_embedding(
+            timesteps, diffusion_model.model_channels, repeat_only=False)
+        emb = diffusion_model.time_embed(t_emb)
+        h = x.type(diffusion_model.dtype)
+        for module in diffusion_model.input_blocks:
+            h = module(h, emb, context)
+            hs.append(h)
+        h = diffusion_model.middle_block(h, emb, context)
+        out_list = []
+        for i_out, module in enumerate(diffusion_model.output_blocks):
+            h = torch.cat([h, hs.pop()], dim=1)
+            h = module(h, emb, context)
+            if i_out in [1, 4, 7]:
+                out_list.append(h)
+        h = h.type(x.dtype)
+        out_list.append(h)
+        return hs, emb, out_list
+
+    def _append_attn_to_output(self, out_list):
+        avg_attn = self.attention_store.get_average_attention()
+        attns = {self.size16: [], self.size32: [], self.size64: []}
+        for k in self.attn_selector:
+            for up_attn in avg_attn[k]:
+                size = int(math.sqrt(up_attn.shape[1]))
+                up_attn = up_attn.transpose(-1, -2).reshape(
+                    *up_attn.shape[:2], size, -1)
+                attns[size].append(up_attn)
+        attn16 = torch.stack(attns[self.size16]).mean(0)
+        attn32 = torch.stack(attns[self.size32]).mean(0)
+        attn64 = torch.stack(attns[self.size64]).mean(0) if len(
+            attns[self.size64]) > 0 else None
+        out_list[1] = torch.cat([out_list[1], attn16], dim=1)
+        out_list[2] = torch.cat([out_list[2], attn32], dim=1)
+        if attn64 is not None:
+            out_list[3] = torch.cat([out_list[3], attn64], dim=1)
+
+
+class TextAdapter(nn.Module):
+    """A PyTorch Module that serves as a text adapter.
+
+    This module takes text embeddings and adjusts them based on a scaling
+    factor gamma.
+    """
+
+    def __init__(self, text_dim=768):
+        super().__init__()
+        self.fc = nn.Sequential(
+            nn.Linear(text_dim, text_dim), nn.GELU(),
+            nn.Linear(text_dim, text_dim))
+
+    def forward(self, texts, gamma):
+        texts_after = self.fc(texts)
+        texts = texts + gamma * texts_after
+        return texts
+
+
+@MODELS.register_module()
+class VPD(BaseModule):
+    """VPD (Visual Perception Diffusion) model.
+
+    .. _`VPD`: https://arxiv.org/abs/2303.02153
+
+    Args:
+        diffusion_cfg (dict): Configuration for diffusion model.
+        class_embed_path (str): Path for class embeddings.
+        unet_cfg (dict, optional): Configuration for U-Net.
+        gamma (float, optional): Gamma for text adaptation. Defaults to 1e-4.
+        class_embed_select (bool, optional): If True, enables class embedding
+            selection. Defaults to False.
+        pad_shape (Optional[Union[int, List[int]]], optional): Padding shape.
+            Defaults to None.
+        pad_val (Union[int, List[int]], optional): Padding value.
+            Defaults to 0.
+        init_cfg (dict, optional): Configuration for network initialization.
+    """
+
+    def __init__(self,
+                 diffusion_cfg: ConfigType,
+                 class_embed_path: str,
+                 unet_cfg: OptConfigType = dict(),
+                 gamma: float = 1e-4,
+                 class_embed_select=False,
+                 pad_shape: Optional[Union[int, List[int]]] = None,
+                 pad_val: Union[int, List[int]] = 0,
+                 init_cfg: OptConfigType = None):
+
+        super().__init__(init_cfg=init_cfg)
+
+        assert has_ldm, 'To use VPD model, please install required packages' \
+            ' via `pip install -r requirements/optional.txt`.'
+
+        if pad_shape is not None:
+            if not isinstance(pad_shape, (list, tuple)):
+                pad_shape = (pad_shape, pad_shape)
+
+        self.pad_shape = pad_shape
+        self.pad_val = pad_val
+
+        # diffusion model
+        diffusion_checkpoint = diffusion_cfg.pop('checkpoint', None)
+        sd_model = instantiate_from_config(diffusion_cfg)
+        if diffusion_checkpoint is not None:
+            load_checkpoint(sd_model, diffusion_checkpoint, strict=False)
+
+        self.encoder_vq = sd_model.first_stage_model
+        self.unet = UNetWrapper(sd_model.model, **unet_cfg)
+
+        # class embeddings & text adapter
+        class_embeddings = CheckpointLoader.load_checkpoint(class_embed_path)
+        text_dim = class_embeddings.size(-1)
+        self.text_adapter = TextAdapter(text_dim=text_dim)
+        self.class_embed_select = class_embed_select
+        if class_embed_select:
+            class_embeddings = torch.cat(
+                (class_embeddings, class_embeddings.mean(dim=0,
+                                                         keepdims=True)),
+                dim=0)
+        self.register_buffer('class_embeddings', class_embeddings)
+        self.gamma = nn.Parameter(torch.ones(text_dim) * gamma)
+
+    def forward(self, x):
+        """Extract features from images."""
+
+        # calculate cross-attn map
+        if self.class_embed_select:
+            if isinstance(x, (tuple, list)):
+                x, class_ids = x[:2]
+                class_ids = class_ids.tolist()
+            else:
+                class_ids = [-1] * x.size(0)
+            class_embeddings = self.class_embeddings[class_ids]
+            c_crossattn = self.text_adapter(class_embeddings, self.gamma)
+            c_crossattn = c_crossattn.unsqueeze(1)
+        else:
+            class_embeddings = self.class_embeddings
+            c_crossattn = self.text_adapter(class_embeddings, self.gamma)
+            c_crossattn = c_crossattn.unsqueeze(0).repeat(x.size(0), 1, 1)
+
+        # pad to required input shape for pretrained diffusion model
+        if self.pad_shape is not None:
+            pad_width = max(0, self.pad_shape[1] - x.shape[-1])
+            pad_height = max(0, self.pad_shape[0] - x.shape[-2])
+            x = F.pad(x, (0, pad_width, 0, pad_height), value=self.pad_val)
+
+        # forward the denoising model
+        with torch.no_grad():
+            latents = self.encoder_vq.encode(x).mode().detach()
+        t = torch.ones((x.shape[0], ), device=x.device).long()
+        outs = self.unet(latents, t, context=c_crossattn)
+
+        return outs
diff --git a/mmsegmentation/mmseg/models/builder.py b/mmsegmentation/mmseg/models/builder.py
new file mode 100644
index 0000000..081c646
--- /dev/null
+++ b/mmsegmentation/mmseg/models/builder.py
@@ -0,0 +1,52 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+from mmseg.registry import MODELS
+
+BACKBONES = MODELS
+NECKS = MODELS
+HEADS = MODELS
+LOSSES = MODELS
+SEGMENTORS = MODELS
+
+
+def build_backbone(cfg):
+    """Build backbone."""
+    warnings.warn('``build_backbone`` would be deprecated soon, please use '
+                  '``mmseg.registry.MODELS.build()`` ')
+    return BACKBONES.build(cfg)
+
+
+def build_neck(cfg):
+    """Build neck."""
+    warnings.warn('``build_neck`` would be deprecated soon, please use '
+                  '``mmseg.registry.MODELS.build()`` ')
+    return NECKS.build(cfg)
+
+
+def build_head(cfg):
+    """Build head."""
+    warnings.warn('``build_head`` would be deprecated soon, please use '
+                  '``mmseg.registry.MODELS.build()`` ')
+    return HEADS.build(cfg)
+
+
+def build_loss(cfg):
+    """Build loss."""
+    warnings.warn('``build_loss`` would be deprecated soon, please use '
+                  '``mmseg.registry.MODELS.build()`` ')
+    return LOSSES.build(cfg)
+
+
+def build_segmentor(cfg, train_cfg=None, test_cfg=None):
+    """Build segmentor."""
+    if train_cfg is not None or test_cfg is not None:
+        warnings.warn(
+            'train_cfg and test_cfg is deprecated, '
+            'please specify them in model', UserWarning)
+    assert cfg.get('train_cfg') is None or train_cfg is None, \
+        'train_cfg specified in both outer field and model field '
+    assert cfg.get('test_cfg') is None or test_cfg is None, \
+        'test_cfg specified in both outer field and model field '
+    return SEGMENTORS.build(
+        cfg, default_args=dict(train_cfg=train_cfg, test_cfg=test_cfg))
diff --git a/mmsegmentation/mmseg/models/data_preprocessor.py b/mmsegmentation/mmseg/models/data_preprocessor.py
new file mode 100644
index 0000000..8d32bc6
--- /dev/null
+++ b/mmsegmentation/mmseg/models/data_preprocessor.py
@@ -0,0 +1,151 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from numbers import Number
+from typing import Any, Dict, List, Optional, Sequence
+
+import torch
+from mmengine.model import BaseDataPreprocessor
+
+from mmseg.registry import MODELS
+from mmseg.utils import stack_batch
+
+
+@MODELS.register_module()
+class SegDataPreProcessor(BaseDataPreprocessor):
+    """Image pre-processor for segmentation tasks.
+
+    Comparing with the :class:`mmengine.ImgDataPreprocessor`,
+
+    1. It won't do normalization if ``mean`` is not specified.
+    2. It does normalization and color space conversion after stacking batch.
+    3. It supports batch augmentations like mixup and cutmix.
+
+
+    It provides the data pre-processing as follows
+
+    - Collate and move data to the target device.
+    - Pad inputs to the input size with defined ``pad_val``, and pad seg map
+        with defined ``seg_pad_val``.
+    - Stack inputs to batch_inputs.
+    - Convert inputs from bgr to rgb if the shape of input is (3, H, W).
+    - Normalize image with defined std and mean.
+    - Do batch augmentations like Mixup and Cutmix during training.
+
+    Args:
+        mean (Sequence[Number], optional): The pixel mean of R, G, B channels.
+            Defaults to None.
+        std (Sequence[Number], optional): The pixel standard deviation of
+            R, G, B channels. Defaults to None.
+        size (tuple, optional): Fixed padding size.
+        size_divisor (int, optional): The divisor of padded size.
+        pad_val (float, optional): Padding value. Default: 0.
+        seg_pad_val (float, optional): Padding value of segmentation map.
+            Default: 255.
+        padding_mode (str): Type of padding. Default: constant.
+            - constant: pads with a constant value, this value is specified
+              with pad_val.
+        bgr_to_rgb (bool): whether to convert image from BGR to RGB.
+            Defaults to False.
+        rgb_to_bgr (bool): whether to convert image from RGB to RGB.
+            Defaults to False.
+        batch_augments (list[dict], optional): Batch-level augmentations
+        test_cfg (dict, optional): The padding size config in testing, if not
+            specify, will use `size` and `size_divisor` params as default.
+            Defaults to None, only supports keys `size` or `size_divisor`.
+    """
+
+    def __init__(
+        self,
+        mean: Sequence[Number] = None,
+        std: Sequence[Number] = None,
+        size: Optional[tuple] = None,
+        size_divisor: Optional[int] = None,
+        pad_val: Number = 0,
+        seg_pad_val: Number = 255,
+        bgr_to_rgb: bool = False,
+        rgb_to_bgr: bool = False,
+        batch_augments: Optional[List[dict]] = None,
+        test_cfg: dict = None,
+    ):
+        super().__init__()
+        self.size = size
+        self.size_divisor = size_divisor
+        self.pad_val = pad_val
+        self.seg_pad_val = seg_pad_val
+
+        assert not (bgr_to_rgb and rgb_to_bgr), (
+            '`bgr2rgb` and `rgb2bgr` cannot be set to True at the same time')
+        self.channel_conversion = rgb_to_bgr or bgr_to_rgb
+
+        if mean is not None:
+            assert std is not None, 'To enable the normalization in ' \
+                                    'preprocessing, please specify both ' \
+                                    '`mean` and `std`.'
+            # Enable the normalization in preprocessing.
+            self._enable_normalize = True
+            self.register_buffer('mean',
+                                 torch.tensor(mean).view(-1, 1, 1), False)
+            self.register_buffer('std',
+                                 torch.tensor(std).view(-1, 1, 1), False)
+        else:
+            self._enable_normalize = False
+
+        # TODO: support batch augmentations.
+        self.batch_augments = batch_augments
+
+        # Support different padding methods in testing
+        self.test_cfg = test_cfg
+
+    def forward(self, data: dict, training: bool = False) -> Dict[str, Any]:
+        """Perform normalization、padding and bgr2rgb conversion based on
+        ``BaseDataPreprocessor``.
+
+        Args:
+            data (dict): data sampled from dataloader.
+            training (bool): Whether to enable training time augmentation.
+
+        Returns:
+            Dict: Data in the same format as the model input.
+        """
+        data = self.cast_data(data)  # type: ignore
+        inputs = data['inputs']
+        data_samples = data.get('data_samples', None)
+        # TODO: whether normalize should be after stack_batch
+        if self.channel_conversion and inputs[0].size(0) == 3:
+            inputs = [_input[[2, 1, 0], ...] for _input in inputs]
+
+        inputs = [_input.float() for _input in inputs]
+        if self._enable_normalize:
+            inputs = [(_input - self.mean) / self.std for _input in inputs]
+
+        if training:
+            assert data_samples is not None, ('During training, ',
+                                              '`data_samples` must be define.')
+            inputs, data_samples = stack_batch(
+                inputs=inputs,
+                data_samples=data_samples,
+                size=self.size,
+                size_divisor=self.size_divisor,
+                pad_val=self.pad_val,
+                seg_pad_val=self.seg_pad_val)
+
+            if self.batch_augments is not None:
+                inputs, data_samples = self.batch_augments(
+                    inputs, data_samples)
+        else:
+            img_size = inputs[0].shape[1:]
+            assert all(input_.shape[1:] == img_size for input_ in inputs),  \
+                'The image size in a batch should be the same.'
+            # pad images when testing
+            if self.test_cfg:
+                inputs, padded_samples = stack_batch(
+                    inputs=inputs,
+                    size=self.test_cfg.get('size', None),
+                    size_divisor=self.test_cfg.get('size_divisor', None),
+                    pad_val=self.pad_val,
+                    seg_pad_val=self.seg_pad_val)
+                for data_sample, pad_info in zip(data_samples, padded_samples):
+                    data_sample.set_metainfo({**pad_info})
+            else:
+                inputs = torch.stack(inputs, dim=0)
+
+        return dict(inputs=inputs, data_samples=data_samples)
diff --git a/mmsegmentation/mmseg/models/decode_heads/__init__.py b/mmsegmentation/mmseg/models/decode_heads/__init__.py
new file mode 100644
index 0000000..eef905a
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/__init__.py
@@ -0,0 +1,57 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .ann_head import ANNHead
+from .apc_head import APCHead
+from .aspp_head import ASPPHead
+from .cc_head import CCHead
+from .da_head import DAHead
+from .ddr_head import DDRHead
+from .dm_head import DMHead
+from .dnl_head import DNLHead
+from .dpt_head import DPTHead
+from .ema_head import EMAHead
+from .enc_head import EncHead
+from .fcn_head import FCNHead
+from .fpn_head import FPNHead
+from .gc_head import GCHead
+from .ham_head import LightHamHead
+from .isa_head import ISAHead
+from .knet_head import IterativeDecodeHead, KernelUpdateHead, KernelUpdator
+from .lraspp_head import LRASPPHead
+from .mask2former_head import Mask2FormerHead
+from .maskformer_head import MaskFormerHead
+from .nl_head import NLHead
+from .ocr_head import OCRHead
+from .pid_head import PIDHead
+from .point_head import PointHead
+from .psa_head import PSAHead
+from .psp_head import PSPHead
+from .san_head import SideAdapterCLIPHead
+from .segformer_head import SegformerHead
+from .segmenter_mask_head import SegmenterMaskTransformerHead
+from .sep_aspp_head import DepthwiseSeparableASPPHead
+from .sep_fcn_head import DepthwiseSeparableFCNHead
+from .setr_mla_head import SETRMLAHead
+from .setr_up_head import SETRUPHead
+from .stdc_head import STDCHead
+from .uper_head import UPerHead
+from .vpd_depth_head import VPDDepthHead
+from .custom import (
+    ASPPHeadWithoutAccuracy,
+    FCNHeadWithoutAccuracy,
+    SegformerHeadWithoutAccuracy,
+    UPerHeadWithoutAccuracy,
+)
+
+__all__ = [
+    'FCNHead', 'PSPHead', 'ASPPHead', 'PSAHead', 'NLHead', 'GCHead', 'CCHead',
+    'UPerHead', 'DepthwiseSeparableASPPHead', 'ANNHead', 'DAHead', 'OCRHead',
+    'EncHead', 'DepthwiseSeparableFCNHead', 'FPNHead', 'EMAHead', 'DNLHead',
+    'PointHead', 'APCHead', 'DMHead', 'LRASPPHead', 'SETRUPHead',
+    'SETRMLAHead', 'DPTHead', 'SETRMLAHead', 'SegmenterMaskTransformerHead',
+    'SegformerHead', 'ISAHead', 'STDCHead', 'IterativeDecodeHead',
+    'KernelUpdateHead', 'KernelUpdator', 'MaskFormerHead', 'Mask2FormerHead',
+    'LightHamHead', 'PIDHead', 'DDRHead', 'VPDDepthHead', 'SideAdapterCLIPHead', "ASPPHeadWithoutAccuracy",
+    "FCNHeadWithoutAccuracy",
+    "SegformerHeadWithoutAccuracy",
+    "UPerHeadWithoutAccuracy",
+]
diff --git a/mmsegmentation/mmseg/models/decode_heads/ann_head.py b/mmsegmentation/mmseg/models/decode_heads/ann_head.py
new file mode 100644
index 0000000..2b40ef5
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/ann_head.py
@@ -0,0 +1,245 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+
+from mmseg.registry import MODELS
+from ..utils import SelfAttentionBlock as _SelfAttentionBlock
+from .decode_head import BaseDecodeHead
+
+
+class PPMConcat(nn.ModuleList):
+    """Pyramid Pooling Module that only concat the features of each layer.
+
+    Args:
+        pool_scales (tuple[int]): Pooling scales used in Pooling Pyramid
+            Module.
+    """
+
+    def __init__(self, pool_scales=(1, 3, 6, 8)):
+        super().__init__(
+            [nn.AdaptiveAvgPool2d(pool_scale) for pool_scale in pool_scales])
+
+    def forward(self, feats):
+        """Forward function."""
+        ppm_outs = []
+        for ppm in self:
+            ppm_out = ppm(feats)
+            ppm_outs.append(ppm_out.view(*feats.shape[:2], -1))
+        concat_outs = torch.cat(ppm_outs, dim=2)
+        return concat_outs
+
+
+class SelfAttentionBlock(_SelfAttentionBlock):
+    """Make a ANN used SelfAttentionBlock.
+
+    Args:
+        low_in_channels (int): Input channels of lower level feature,
+            which is the key feature for self-attention.
+        high_in_channels (int): Input channels of higher level feature,
+            which is the query feature for self-attention.
+        channels (int): Output channels of key/query transform.
+        out_channels (int): Output channels.
+        share_key_query (bool): Whether share projection weight between key
+            and query projection.
+        query_scale (int): The scale of query feature map.
+        key_pool_scales (tuple[int]): Pooling scales used in Pooling Pyramid
+            Module of key feature.
+        conv_cfg (dict|None): Config of conv layers.
+        norm_cfg (dict|None): Config of norm layers.
+        act_cfg (dict|None): Config of activation layers.
+    """
+
+    def __init__(self, low_in_channels, high_in_channels, channels,
+                 out_channels, share_key_query, query_scale, key_pool_scales,
+                 conv_cfg, norm_cfg, act_cfg):
+        key_psp = PPMConcat(key_pool_scales)
+        if query_scale > 1:
+            query_downsample = nn.MaxPool2d(kernel_size=query_scale)
+        else:
+            query_downsample = None
+        super().__init__(
+            key_in_channels=low_in_channels,
+            query_in_channels=high_in_channels,
+            channels=channels,
+            out_channels=out_channels,
+            share_key_query=share_key_query,
+            query_downsample=query_downsample,
+            key_downsample=key_psp,
+            key_query_num_convs=1,
+            key_query_norm=True,
+            value_out_num_convs=1,
+            value_out_norm=False,
+            matmul_norm=True,
+            with_out=True,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+
+
+class AFNB(nn.Module):
+    """Asymmetric Fusion Non-local Block(AFNB)
+
+    Args:
+        low_in_channels (int): Input channels of lower level feature,
+            which is the key feature for self-attention.
+        high_in_channels (int): Input channels of higher level feature,
+            which is the query feature for self-attention.
+        channels (int): Output channels of key/query transform.
+        out_channels (int): Output channels.
+            and query projection.
+        query_scales (tuple[int]): The scales of query feature map.
+            Default: (1,)
+        key_pool_scales (tuple[int]): Pooling scales used in Pooling Pyramid
+            Module of key feature.
+        conv_cfg (dict|None): Config of conv layers.
+        norm_cfg (dict|None): Config of norm layers.
+        act_cfg (dict|None): Config of activation layers.
+    """
+
+    def __init__(self, low_in_channels, high_in_channels, channels,
+                 out_channels, query_scales, key_pool_scales, conv_cfg,
+                 norm_cfg, act_cfg):
+        super().__init__()
+        self.stages = nn.ModuleList()
+        for query_scale in query_scales:
+            self.stages.append(
+                SelfAttentionBlock(
+                    low_in_channels=low_in_channels,
+                    high_in_channels=high_in_channels,
+                    channels=channels,
+                    out_channels=out_channels,
+                    share_key_query=False,
+                    query_scale=query_scale,
+                    key_pool_scales=key_pool_scales,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg))
+        self.bottleneck = ConvModule(
+            out_channels + high_in_channels,
+            out_channels,
+            1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=None)
+
+    def forward(self, low_feats, high_feats):
+        """Forward function."""
+        priors = [stage(high_feats, low_feats) for stage in self.stages]
+        context = torch.stack(priors, dim=0).sum(dim=0)
+        output = self.bottleneck(torch.cat([context, high_feats], 1))
+        return output
+
+
+class APNB(nn.Module):
+    """Asymmetric Pyramid Non-local Block (APNB)
+
+    Args:
+        in_channels (int): Input channels of key/query feature,
+            which is the key feature for self-attention.
+        channels (int): Output channels of key/query transform.
+        out_channels (int): Output channels.
+        query_scales (tuple[int]): The scales of query feature map.
+            Default: (1,)
+        key_pool_scales (tuple[int]): Pooling scales used in Pooling Pyramid
+            Module of key feature.
+        conv_cfg (dict|None): Config of conv layers.
+        norm_cfg (dict|None): Config of norm layers.
+        act_cfg (dict|None): Config of activation layers.
+    """
+
+    def __init__(self, in_channels, channels, out_channels, query_scales,
+                 key_pool_scales, conv_cfg, norm_cfg, act_cfg):
+        super().__init__()
+        self.stages = nn.ModuleList()
+        for query_scale in query_scales:
+            self.stages.append(
+                SelfAttentionBlock(
+                    low_in_channels=in_channels,
+                    high_in_channels=in_channels,
+                    channels=channels,
+                    out_channels=out_channels,
+                    share_key_query=True,
+                    query_scale=query_scale,
+                    key_pool_scales=key_pool_scales,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg))
+        self.bottleneck = ConvModule(
+            2 * in_channels,
+            out_channels,
+            1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+
+    def forward(self, feats):
+        """Forward function."""
+        priors = [stage(feats, feats) for stage in self.stages]
+        context = torch.stack(priors, dim=0).sum(dim=0)
+        output = self.bottleneck(torch.cat([context, feats], 1))
+        return output
+
+
+@MODELS.register_module()
+class ANNHead(BaseDecodeHead):
+    """Asymmetric Non-local Neural Networks for Semantic Segmentation.
+
+    This head is the implementation of `ANNNet
+    <https://arxiv.org/abs/1908.07678>`_.
+
+    Args:
+        project_channels (int): Projection channels for Nonlocal.
+        query_scales (tuple[int]): The scales of query feature map.
+            Default: (1,)
+        key_pool_scales (tuple[int]): The pooling scales of key feature map.
+            Default: (1, 3, 6, 8).
+    """
+
+    def __init__(self,
+                 project_channels,
+                 query_scales=(1, ),
+                 key_pool_scales=(1, 3, 6, 8),
+                 **kwargs):
+        super().__init__(input_transform='multiple_select', **kwargs)
+        assert len(self.in_channels) == 2
+        low_in_channels, high_in_channels = self.in_channels
+        self.project_channels = project_channels
+        self.fusion = AFNB(
+            low_in_channels=low_in_channels,
+            high_in_channels=high_in_channels,
+            out_channels=high_in_channels,
+            channels=project_channels,
+            query_scales=query_scales,
+            key_pool_scales=key_pool_scales,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+        self.bottleneck = ConvModule(
+            high_in_channels,
+            self.channels,
+            3,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+        self.context = APNB(
+            in_channels=self.channels,
+            out_channels=self.channels,
+            channels=project_channels,
+            query_scales=query_scales,
+            key_pool_scales=key_pool_scales,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+    def forward(self, inputs):
+        """Forward function."""
+        low_feats, high_feats = self._transform_inputs(inputs)
+        output = self.fusion(low_feats, high_feats)
+        output = self.dropout(output)
+        output = self.bottleneck(output)
+        output = self.context(output)
+        output = self.cls_seg(output)
+
+        return output
diff --git a/mmsegmentation/mmseg/models/decode_heads/apc_head.py b/mmsegmentation/mmseg/models/decode_heads/apc_head.py
new file mode 100644
index 0000000..728f396
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/apc_head.py
@@ -0,0 +1,159 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+
+from mmseg.registry import MODELS
+from ..utils import resize
+from .decode_head import BaseDecodeHead
+
+
+class ACM(nn.Module):
+    """Adaptive Context Module used in APCNet.
+
+    Args:
+        pool_scale (int): Pooling scale used in Adaptive Context
+            Module to extract region features.
+        fusion (bool): Add one conv to fuse residual feature.
+        in_channels (int): Input channels.
+        channels (int): Channels after modules, before conv_seg.
+        conv_cfg (dict | None): Config of conv layers.
+        norm_cfg (dict | None): Config of norm layers.
+        act_cfg (dict): Config of activation layers.
+    """
+
+    def __init__(self, pool_scale, fusion, in_channels, channels, conv_cfg,
+                 norm_cfg, act_cfg):
+        super().__init__()
+        self.pool_scale = pool_scale
+        self.fusion = fusion
+        self.in_channels = in_channels
+        self.channels = channels
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+        self.pooled_redu_conv = ConvModule(
+            self.in_channels,
+            self.channels,
+            1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+        self.input_redu_conv = ConvModule(
+            self.in_channels,
+            self.channels,
+            1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+        self.global_info = ConvModule(
+            self.channels,
+            self.channels,
+            1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+        self.gla = nn.Conv2d(self.channels, self.pool_scale**2, 1, 1, 0)
+
+        self.residual_conv = ConvModule(
+            self.channels,
+            self.channels,
+            1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+        if self.fusion:
+            self.fusion_conv = ConvModule(
+                self.channels,
+                self.channels,
+                1,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg)
+
+    def forward(self, x):
+        """Forward function."""
+        pooled_x = F.adaptive_avg_pool2d(x, self.pool_scale)
+        # [batch_size, channels, h, w]
+        x = self.input_redu_conv(x)
+        # [batch_size, channels, pool_scale, pool_scale]
+        pooled_x = self.pooled_redu_conv(pooled_x)
+        batch_size = x.size(0)
+        # [batch_size, pool_scale * pool_scale, channels]
+        pooled_x = pooled_x.view(batch_size, self.channels,
+                                 -1).permute(0, 2, 1).contiguous()
+        # [batch_size, h * w, pool_scale * pool_scale]
+        affinity_matrix = self.gla(x + resize(
+            self.global_info(F.adaptive_avg_pool2d(x, 1)), size=x.shape[2:])
+                                   ).permute(0, 2, 3, 1).reshape(
+                                       batch_size, -1, self.pool_scale**2)
+        affinity_matrix = F.sigmoid(affinity_matrix)
+        # [batch_size, h * w, channels]
+        z_out = torch.matmul(affinity_matrix, pooled_x)
+        # [batch_size, channels, h * w]
+        z_out = z_out.permute(0, 2, 1).contiguous()
+        # [batch_size, channels, h, w]
+        z_out = z_out.view(batch_size, self.channels, x.size(2), x.size(3))
+        z_out = self.residual_conv(z_out)
+        z_out = F.relu(z_out + x)
+        if self.fusion:
+            z_out = self.fusion_conv(z_out)
+
+        return z_out
+
+
+@MODELS.register_module()
+class APCHead(BaseDecodeHead):
+    """Adaptive Pyramid Context Network for Semantic Segmentation.
+
+    This head is the implementation of
+    `APCNet <https://openaccess.thecvf.com/content_CVPR_2019/papers/\
+    He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_\
+    CVPR_2019_paper.pdf>`_.
+
+    Args:
+        pool_scales (tuple[int]): Pooling scales used in Adaptive Context
+            Module. Default: (1, 2, 3, 6).
+        fusion (bool): Add one conv to fuse residual feature.
+    """
+
+    def __init__(self, pool_scales=(1, 2, 3, 6), fusion=True, **kwargs):
+        super().__init__(**kwargs)
+        assert isinstance(pool_scales, (list, tuple))
+        self.pool_scales = pool_scales
+        self.fusion = fusion
+        acm_modules = []
+        for pool_scale in self.pool_scales:
+            acm_modules.append(
+                ACM(pool_scale,
+                    self.fusion,
+                    self.in_channels,
+                    self.channels,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg,
+                    act_cfg=self.act_cfg))
+        self.acm_modules = nn.ModuleList(acm_modules)
+        self.bottleneck = ConvModule(
+            self.in_channels + len(pool_scales) * self.channels,
+            self.channels,
+            3,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+    def forward(self, inputs):
+        """Forward function."""
+        x = self._transform_inputs(inputs)
+        acm_outs = [x]
+        for acm_module in self.acm_modules:
+            acm_outs.append(acm_module(x))
+        acm_outs = torch.cat(acm_outs, dim=1)
+        output = self.bottleneck(acm_outs)
+        output = self.cls_seg(output)
+        return output
diff --git a/mmsegmentation/mmseg/models/decode_heads/aspp_head.py b/mmsegmentation/mmseg/models/decode_heads/aspp_head.py
new file mode 100644
index 0000000..6d7185d
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/aspp_head.py
@@ -0,0 +1,122 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+
+from mmseg.registry import MODELS
+from ..utils import resize
+from .decode_head import BaseDecodeHead
+
+
+class ASPPModule(nn.ModuleList):
+    """Atrous Spatial Pyramid Pooling (ASPP) Module.
+
+    Args:
+        dilations (tuple[int]): Dilation rate of each layer.
+        in_channels (int): Input channels.
+        channels (int): Channels after modules, before conv_seg.
+        conv_cfg (dict|None): Config of conv layers.
+        norm_cfg (dict|None): Config of norm layers.
+        act_cfg (dict): Config of activation layers.
+    """
+
+    def __init__(self, dilations, in_channels, channels, conv_cfg, norm_cfg,
+                 act_cfg):
+        super().__init__()
+        self.dilations = dilations
+        self.in_channels = in_channels
+        self.channels = channels
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+        for dilation in dilations:
+            self.append(
+                ConvModule(
+                    self.in_channels,
+                    self.channels,
+                    1 if dilation == 1 else 3,
+                    dilation=dilation,
+                    padding=0 if dilation == 1 else dilation,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg,
+                    act_cfg=self.act_cfg))
+
+    def forward(self, x):
+        """Forward function."""
+        aspp_outs = []
+        for aspp_module in self:
+            aspp_outs.append(aspp_module(x))
+
+        return aspp_outs
+
+
+@MODELS.register_module()
+class ASPPHead(BaseDecodeHead):
+    """Rethinking Atrous Convolution for Semantic Image Segmentation.
+
+    This head is the implementation of `DeepLabV3
+    <https://arxiv.org/abs/1706.05587>`_.
+
+    Args:
+        dilations (tuple[int]): Dilation rates for ASPP module.
+            Default: (1, 6, 12, 18).
+    """
+
+    def __init__(self, dilations=(1, 6, 12, 18), **kwargs):
+        super().__init__(**kwargs)
+        assert isinstance(dilations, (list, tuple))
+        self.dilations = dilations
+        self.image_pool = nn.Sequential(
+            nn.AdaptiveAvgPool2d(1),
+            ConvModule(
+                self.in_channels,
+                self.channels,
+                1,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg))
+        self.aspp_modules = ASPPModule(
+            dilations,
+            self.in_channels,
+            self.channels,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+        self.bottleneck = ConvModule(
+            (len(dilations) + 1) * self.channels,
+            self.channels,
+            3,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+    def _forward_feature(self, inputs):
+        """Forward function for feature maps before classifying each pixel with
+        ``self.cls_seg`` fc.
+
+        Args:
+            inputs (list[Tensor]): List of multi-level img features.
+
+        Returns:
+            feats (Tensor): A tensor of shape (batch_size, self.channels,
+                H, W) which is feature map for last layer of decoder head.
+        """
+        x = self._transform_inputs(inputs)
+        aspp_outs = [
+            resize(
+                self.image_pool(x),
+                size=x.size()[2:],
+                mode='bilinear',
+                align_corners=self.align_corners)
+        ]
+        aspp_outs.extend(self.aspp_modules(x))
+        aspp_outs = torch.cat(aspp_outs, dim=1)
+        feats = self.bottleneck(aspp_outs)
+        return feats
+
+    def forward(self, inputs):
+        """Forward function."""
+        output = self._forward_feature(inputs)
+        output = self.cls_seg(output)
+        return output
diff --git a/mmsegmentation/mmseg/models/decode_heads/cascade_decode_head.py b/mmsegmentation/mmseg/models/decode_heads/cascade_decode_head.py
new file mode 100644
index 0000000..fe2bcb9
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/cascade_decode_head.py
@@ -0,0 +1,62 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from abc import ABCMeta, abstractmethod
+from typing import List
+
+from torch import Tensor
+
+from mmseg.utils import ConfigType
+from .decode_head import BaseDecodeHead
+
+
+class BaseCascadeDecodeHead(BaseDecodeHead, metaclass=ABCMeta):
+    """Base class for cascade decode head used in
+    :class:`CascadeEncoderDecoder."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    @abstractmethod
+    def forward(self, inputs, prev_output):
+        """Placeholder of forward function."""
+        pass
+
+    def loss(self, inputs: List[Tensor], prev_output: Tensor,
+             batch_data_samples: List[dict], train_cfg: ConfigType) -> Tensor:
+        """Forward function for training.
+
+        Args:
+            inputs (List[Tensor]): List of multi-level img features.
+            prev_output (Tensor): The output of previous decode head.
+            batch_data_samples (List[:obj:`SegDataSample`]): The seg
+                data samples. It usually includes information such
+                as `metainfo` and `gt_sem_seg`.
+            train_cfg (dict): The training config.
+
+        Returns:
+            dict[str, Tensor]: a dictionary of loss components
+        """
+        seg_logits = self.forward(inputs, prev_output)
+        losses = self.loss_by_feat(seg_logits, batch_data_samples)
+
+        return losses
+
+    def predict(self, inputs: List[Tensor], prev_output: Tensor,
+                batch_img_metas: List[dict], tese_cfg: ConfigType):
+        """Forward function for testing.
+
+        Args:
+            inputs (List[Tensor]): List of multi-level img features.
+            prev_output (Tensor): The output of previous decode head.
+            batch_img_metas (dict): List Image info where each dict may also
+                contain: 'img_shape', 'scale_factor', 'flip', 'img_path',
+                'ori_shape', and 'pad_shape'.
+                For details on the values of these keys see
+                `mmseg/datasets/pipelines/formatting.py:PackSegInputs`.
+            test_cfg (dict): The testing config.
+
+        Returns:
+            Tensor: Output segmentation map.
+        """
+        seg_logits = self.forward(inputs, prev_output)
+
+        return self.predict_by_feat(seg_logits, batch_img_metas)
diff --git a/mmsegmentation/mmseg/models/decode_heads/cc_head.py b/mmsegmentation/mmseg/models/decode_heads/cc_head.py
new file mode 100644
index 0000000..e9075a2
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/cc_head.py
@@ -0,0 +1,43 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+
+from mmseg.registry import MODELS
+from .fcn_head import FCNHead
+
+try:
+    from mmcv.ops import CrissCrossAttention
+except ModuleNotFoundError:
+    CrissCrossAttention = None
+
+
+@MODELS.register_module()
+class CCHead(FCNHead):
+    """CCNet: Criss-Cross Attention for Semantic Segmentation.
+
+    This head is the implementation of `CCNet
+    <https://arxiv.org/abs/1811.11721>`_.
+
+    Args:
+        recurrence (int): Number of recurrence of Criss Cross Attention
+            module. Default: 2.
+    """
+
+    def __init__(self, recurrence=2, **kwargs):
+        if CrissCrossAttention is None:
+            raise RuntimeError('Please install mmcv-full for '
+                               'CrissCrossAttention ops')
+        super().__init__(num_convs=2, **kwargs)
+        self.recurrence = recurrence
+        self.cca = CrissCrossAttention(self.channels)
+
+    def forward(self, inputs):
+        """Forward function."""
+        x = self._transform_inputs(inputs)
+        output = self.convs[0](x)
+        for _ in range(self.recurrence):
+            output = self.cca(output)
+        output = self.convs[1](output)
+        if self.concat_input:
+            output = self.conv_cat(torch.cat([x, output], dim=1))
+        output = self.cls_seg(output)
+        return output
diff --git a/mmsegmentation/mmseg/models/decode_heads/custom.py b/mmsegmentation/mmseg/models/decode_heads/custom.py
new file mode 100644
index 0000000..8995296
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/custom.py
@@ -0,0 +1,74 @@
+from torch import nn
+
+from mmseg.registry import MODELS
+from mmseg.models.utils.wrappers import resize
+from mmseg.models.decode_heads import ASPPHead, FCNHead, SegformerHead, UPerHead
+
+
+class LossByFeatMixIn:
+    def loss_by_feat(self, seg_logits, batch_data_samples) -> dict:
+        """Compute segmentation loss.
+
+        Args:
+            seg_logits (Tensor): The output from decode head forward function.
+            batch_data_samples (List[:obj:`SegDataSample`]): The seg
+                data samples. It usually includes information such
+                as `metainfo` and `gt_sem_seg`.
+
+        Returns:
+            dict[str, Tensor]: a dictionary of loss components
+        """
+
+        seg_label = self._stack_batch_gt(batch_data_samples)
+        loss = dict()
+        seg_logits = resize(
+            input=seg_logits,
+            size=seg_label.shape[2:],
+            mode="bilinear",
+            align_corners=self.align_corners,
+        )
+        if self.sampler is not None:
+            seg_weight = self.sampler.sample(seg_logits, seg_label)
+        else:
+            seg_weight = None
+
+        if not isinstance(self.loss_decode, nn.ModuleList):
+            losses_decode = [self.loss_decode]
+        else:
+            losses_decode = self.loss_decode
+        for loss_decode in losses_decode:
+            if loss_decode.loss_name not in loss:
+                loss[loss_decode.loss_name] = loss_decode(
+                    seg_logits,
+                    seg_label,
+                    weight=seg_weight,
+                    ignore_index=self.ignore_index,
+                )
+            else:
+                loss[loss_decode.loss_name] += loss_decode(
+                    seg_logits,
+                    seg_label,
+                    weight=seg_weight,
+                    ignore_index=self.ignore_index,
+                )
+
+        return loss
+
+
+@MODELS.register_module()
+class ASPPHeadWithoutAccuracy(LossByFeatMixIn, ASPPHead):
+    pass
+
+
+@MODELS.register_module()
+class FCNHeadWithoutAccuracy(LossByFeatMixIn, FCNHead):
+    pass
+
+
+@MODELS.register_module()
+class SegformerHeadWithoutAccuracy(LossByFeatMixIn, SegformerHead):
+    pass
+
+@MODELS.register_module()
+class UPerHeadWithoutAccuracy(LossByFeatMixIn, UPerHead):
+    pass
\ No newline at end of file
diff --git a/mmsegmentation/mmseg/models/decode_heads/da_head.py b/mmsegmentation/mmseg/models/decode_heads/da_head.py
new file mode 100644
index 0000000..d872143
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/da_head.py
@@ -0,0 +1,184 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple
+
+import torch
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule, Scale
+from torch import Tensor, nn
+
+from mmseg.registry import MODELS
+from mmseg.utils import SampleList, add_prefix
+from ..utils import SelfAttentionBlock as _SelfAttentionBlock
+from .decode_head import BaseDecodeHead
+
+
+class PAM(_SelfAttentionBlock):
+    """Position Attention Module (PAM)
+
+    Args:
+        in_channels (int): Input channels of key/query feature.
+        channels (int): Output channels of key/query transform.
+    """
+
+    def __init__(self, in_channels, channels):
+        super().__init__(
+            key_in_channels=in_channels,
+            query_in_channels=in_channels,
+            channels=channels,
+            out_channels=in_channels,
+            share_key_query=False,
+            query_downsample=None,
+            key_downsample=None,
+            key_query_num_convs=1,
+            key_query_norm=False,
+            value_out_num_convs=1,
+            value_out_norm=False,
+            matmul_norm=False,
+            with_out=False,
+            conv_cfg=None,
+            norm_cfg=None,
+            act_cfg=None)
+
+        self.gamma = Scale(0)
+
+    def forward(self, x):
+        """Forward function."""
+        out = super().forward(x, x)
+
+        out = self.gamma(out) + x
+        return out
+
+
+class CAM(nn.Module):
+    """Channel Attention Module (CAM)"""
+
+    def __init__(self):
+        super().__init__()
+        self.gamma = Scale(0)
+
+    def forward(self, x):
+        """Forward function."""
+        batch_size, channels, height, width = x.size()
+        proj_query = x.view(batch_size, channels, -1)
+        proj_key = x.view(batch_size, channels, -1).permute(0, 2, 1)
+        energy = torch.bmm(proj_query, proj_key)
+        energy_new = torch.max(
+            energy, -1, keepdim=True)[0].expand_as(energy) - energy
+        attention = F.softmax(energy_new, dim=-1)
+        proj_value = x.view(batch_size, channels, -1)
+
+        out = torch.bmm(attention, proj_value)
+        out = out.view(batch_size, channels, height, width)
+
+        out = self.gamma(out) + x
+        return out
+
+
+@MODELS.register_module()
+class DAHead(BaseDecodeHead):
+    """Dual Attention Network for Scene Segmentation.
+
+    This head is the implementation of `DANet
+    <https://arxiv.org/abs/1809.02983>`_.
+
+    Args:
+        pam_channels (int): The channels of Position Attention Module(PAM).
+    """
+
+    def __init__(self, pam_channels, **kwargs):
+        super().__init__(**kwargs)
+        self.pam_channels = pam_channels
+        self.pam_in_conv = ConvModule(
+            self.in_channels,
+            self.channels,
+            3,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+        self.pam = PAM(self.channels, pam_channels)
+        self.pam_out_conv = ConvModule(
+            self.channels,
+            self.channels,
+            3,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+        self.pam_conv_seg = nn.Conv2d(
+            self.channels, self.num_classes, kernel_size=1)
+
+        self.cam_in_conv = ConvModule(
+            self.in_channels,
+            self.channels,
+            3,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+        self.cam = CAM()
+        self.cam_out_conv = ConvModule(
+            self.channels,
+            self.channels,
+            3,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+        self.cam_conv_seg = nn.Conv2d(
+            self.channels, self.num_classes, kernel_size=1)
+
+    def pam_cls_seg(self, feat):
+        """PAM feature classification."""
+        if self.dropout is not None:
+            feat = self.dropout(feat)
+        output = self.pam_conv_seg(feat)
+        return output
+
+    def cam_cls_seg(self, feat):
+        """CAM feature classification."""
+        if self.dropout is not None:
+            feat = self.dropout(feat)
+        output = self.cam_conv_seg(feat)
+        return output
+
+    def forward(self, inputs):
+        """Forward function."""
+        x = self._transform_inputs(inputs)
+        pam_feat = self.pam_in_conv(x)
+        pam_feat = self.pam(pam_feat)
+        pam_feat = self.pam_out_conv(pam_feat)
+        pam_out = self.pam_cls_seg(pam_feat)
+
+        cam_feat = self.cam_in_conv(x)
+        cam_feat = self.cam(cam_feat)
+        cam_feat = self.cam_out_conv(cam_feat)
+        cam_out = self.cam_cls_seg(cam_feat)
+
+        feat_sum = pam_feat + cam_feat
+        pam_cam_out = self.cls_seg(feat_sum)
+
+        return pam_cam_out, pam_out, cam_out
+
+    def predict(self, inputs, batch_img_metas: List[dict], test_cfg,
+                **kwargs) -> List[Tensor]:
+        """Forward function for testing, only ``pam_cam`` is used."""
+        seg_logits = self.forward(inputs)[0]
+        return self.predict_by_feat(seg_logits, batch_img_metas, **kwargs)
+
+    def loss_by_feat(self, seg_logit: Tuple[Tensor],
+                     batch_data_samples: SampleList, **kwargs) -> dict:
+        """Compute ``pam_cam``, ``pam``, ``cam`` loss."""
+        pam_cam_seg_logit, pam_seg_logit, cam_seg_logit = seg_logit
+        loss = dict()
+        loss.update(
+            add_prefix(
+                super().loss_by_feat(pam_cam_seg_logit, batch_data_samples),
+                'pam_cam'))
+        loss.update(
+            add_prefix(super().loss_by_feat(pam_seg_logit, batch_data_samples),
+                       'pam'))
+        loss.update(
+            add_prefix(super().loss_by_feat(cam_seg_logit, batch_data_samples),
+                       'cam'))
+        return loss
diff --git a/mmsegmentation/mmseg/models/decode_heads/ddr_head.py b/mmsegmentation/mmseg/models/decode_heads/ddr_head.py
new file mode 100644
index 0000000..ba26d65
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/ddr_head.py
@@ -0,0 +1,116 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Tuple, Union
+
+import torch.nn as nn
+from mmcv.cnn import ConvModule, build_activation_layer, build_norm_layer
+from torch import Tensor
+
+from mmseg.models.decode_heads.decode_head import BaseDecodeHead
+from mmseg.models.losses import accuracy
+from mmseg.models.utils import resize
+from mmseg.registry import MODELS
+from mmseg.utils import OptConfigType, SampleList
+
+
+@MODELS.register_module()
+class DDRHead(BaseDecodeHead):
+    """Decode head for DDRNet.
+
+    Args:
+        in_channels (int): Number of input channels.
+        channels (int): Number of output channels.
+        num_classes (int): Number of classes.
+        norm_cfg (dict, optional): Config dict for normalization layer.
+            Default: dict(type='BN').
+        act_cfg (dict, optional): Config dict for activation layer.
+            Default: dict(type='ReLU', inplace=True).
+    """
+
+    def __init__(self,
+                 in_channels: int,
+                 channels: int,
+                 num_classes: int,
+                 norm_cfg: OptConfigType = dict(type='BN'),
+                 act_cfg: OptConfigType = dict(type='ReLU', inplace=True),
+                 **kwargs):
+        super().__init__(
+            in_channels,
+            channels,
+            num_classes=num_classes,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg,
+            **kwargs)
+
+        self.head = self._make_base_head(self.in_channels, self.channels)
+        self.aux_head = self._make_base_head(self.in_channels // 2,
+                                             self.channels)
+        self.aux_cls_seg = nn.Conv2d(
+            self.channels, self.out_channels, kernel_size=1)
+
+    def init_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(
+                    m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+    def forward(
+            self,
+            inputs: Union[Tensor,
+                          Tuple[Tensor]]) -> Union[Tensor, Tuple[Tensor]]:
+        if self.training:
+            c3_feat, c5_feat = inputs
+            x_c = self.head(c5_feat)
+            x_c = self.cls_seg(x_c)
+            x_s = self.aux_head(c3_feat)
+            x_s = self.aux_cls_seg(x_s)
+
+            return x_c, x_s
+        else:
+            x_c = self.head(inputs)
+            x_c = self.cls_seg(x_c)
+            return x_c
+
+    def _make_base_head(self, in_channels: int,
+                        channels: int) -> nn.Sequential:
+        layers = [
+            ConvModule(
+                in_channels,
+                channels,
+                kernel_size=3,
+                padding=1,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg,
+                order=('norm', 'act', 'conv')),
+            build_norm_layer(self.norm_cfg, channels)[1],
+            build_activation_layer(self.act_cfg),
+        ]
+
+        return nn.Sequential(*layers)
+
+    def loss_by_feat(self, seg_logits: Tuple[Tensor],
+                     batch_data_samples: SampleList) -> dict:
+        loss = dict()
+        context_logit, spatial_logit = seg_logits
+        seg_label = self._stack_batch_gt(batch_data_samples)
+
+        context_logit = resize(
+            context_logit,
+            size=seg_label.shape[2:],
+            mode='bilinear',
+            align_corners=self.align_corners)
+        spatial_logit = resize(
+            spatial_logit,
+            size=seg_label.shape[2:],
+            mode='bilinear',
+            align_corners=self.align_corners)
+        seg_label = seg_label.squeeze(1)
+
+        loss['loss_context'] = self.loss_decode[0](context_logit, seg_label)
+        loss['loss_spatial'] = self.loss_decode[1](spatial_logit, seg_label)
+        loss['acc_seg'] = accuracy(
+            context_logit, seg_label, ignore_index=self.ignore_index)
+
+        return loss
diff --git a/mmsegmentation/mmseg/models/decode_heads/decode_head.py b/mmsegmentation/mmseg/models/decode_heads/decode_head.py
new file mode 100644
index 0000000..fd53afe
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/decode_head.py
@@ -0,0 +1,366 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+from abc import ABCMeta, abstractmethod
+from typing import List, Tuple
+
+import torch
+import torch.nn as nn
+from mmengine.model import BaseModule
+from torch import Tensor
+
+from mmseg.registry import MODELS
+from mmseg.structures import build_pixel_sampler
+from mmseg.utils import ConfigType, SampleList
+from ..losses import accuracy
+from ..utils import resize
+
+
+class BaseDecodeHead(BaseModule, metaclass=ABCMeta):
+    """Base class for BaseDecodeHead.
+
+    1. The ``init_weights`` method is used to initialize decode_head's
+    model parameters. After segmentor initialization, ``init_weights``
+    is triggered when ``segmentor.init_weights()`` is called externally.
+
+    2. The ``loss`` method is used to calculate the loss of decode_head,
+    which includes two steps: (1) the decode_head model performs forward
+    propagation to obtain the feature maps (2) The ``loss_by_feat`` method
+    is called based on the feature maps to calculate the loss.
+
+    .. code:: text
+
+    loss(): forward() -> loss_by_feat()
+
+    3. The ``predict`` method is used to predict segmentation results,
+    which includes two steps: (1) the decode_head model performs forward
+    propagation to obtain the feature maps (2) The ``predict_by_feat`` method
+    is called based on the feature maps to predict segmentation results
+    including post-processing.
+
+    .. code:: text
+
+    predict(): forward() -> predict_by_feat()
+
+    Args:
+        in_channels (int|Sequence[int]): Input channels.
+        channels (int): Channels after modules, before conv_seg.
+        num_classes (int): Number of classes.
+        out_channels (int): Output channels of conv_seg. Default: None.
+        threshold (float): Threshold for binary segmentation in the case of
+            `num_classes==1`. Default: None.
+        dropout_ratio (float): Ratio of dropout layer. Default: 0.1.
+        conv_cfg (dict|None): Config of conv layers. Default: None.
+        norm_cfg (dict|None): Config of norm layers. Default: None.
+        act_cfg (dict): Config of activation layers.
+            Default: dict(type='ReLU')
+        in_index (int|Sequence[int]): Input feature index. Default: -1
+        input_transform (str|None): Transformation type of input features.
+            Options: 'resize_concat', 'multiple_select', None.
+            'resize_concat': Multiple feature maps will be resize to the
+                same size as first one and than concat together.
+                Usually used in FCN head of HRNet.
+            'multiple_select': Multiple feature maps will be bundle into
+                a list and passed into decode head.
+            None: Only one select feature map is allowed.
+            Default: None.
+        loss_decode (dict | Sequence[dict]): Config of decode loss.
+            The `loss_name` is property of corresponding loss function which
+            could be shown in training log. If you want this loss
+            item to be included into the backward graph, `loss_` must be the
+            prefix of the name. Defaults to 'loss_ce'.
+             e.g. dict(type='CrossEntropyLoss'),
+             [dict(type='CrossEntropyLoss', loss_name='loss_ce'),
+              dict(type='DiceLoss', loss_name='loss_dice')]
+            Default: dict(type='CrossEntropyLoss').
+        ignore_index (int | None): The label index to be ignored. When using
+            masked BCE loss, ignore_index should be set to None. Default: 255.
+        sampler (dict|None): The config of segmentation map sampler.
+            Default: None.
+        align_corners (bool): align_corners argument of F.interpolate.
+            Default: False.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 channels,
+                 *,
+                 num_classes,
+                 out_channels=None,
+                 threshold=None,
+                 dropout_ratio=0.1,
+                 conv_cfg=None,
+                 norm_cfg=None,
+                 act_cfg=dict(type='ReLU'),
+                 in_index=-1,
+                 input_transform=None,
+                 loss_decode=dict(
+                     type='CrossEntropyLoss',
+                     use_sigmoid=False,
+                     loss_weight=1.0),
+                 ignore_index=255,
+                 sampler=None,
+                 align_corners=False,
+                 init_cfg=dict(
+                     type='Normal', std=0.01, override=dict(name='conv_seg'))):
+        super().__init__(init_cfg)
+        self._init_inputs(in_channels, in_index, input_transform)
+        self.channels = channels
+        self.dropout_ratio = dropout_ratio
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+        self.in_index = in_index
+
+        self.ignore_index = ignore_index
+        self.align_corners = align_corners
+
+        if out_channels is None:
+            if num_classes == 2:
+                warnings.warn('For binary segmentation, we suggest using'
+                              '`out_channels = 1` to define the output'
+                              'channels of segmentor, and use `threshold`'
+                              'to convert `seg_logits` into a prediction'
+                              'applying a threshold')
+            out_channels = num_classes
+
+        if out_channels != num_classes and out_channels != 1:
+            raise ValueError(
+                'out_channels should be equal to num_classes,'
+                'except binary segmentation set out_channels == 1 and'
+                f'num_classes == 2, but got out_channels={out_channels}'
+                f'and num_classes={num_classes}')
+
+        if out_channels == 1 and threshold is None:
+            threshold = 0.3
+            warnings.warn('threshold is not defined for binary, and defaults'
+                          'to 0.3')
+        self.num_classes = num_classes
+        self.out_channels = out_channels
+        self.threshold = threshold
+
+        if isinstance(loss_decode, dict):
+            self.loss_decode = MODELS.build(loss_decode)
+        elif isinstance(loss_decode, (list, tuple)):
+            self.loss_decode = nn.ModuleList()
+            for loss in loss_decode:
+                self.loss_decode.append(MODELS.build(loss))
+        else:
+            raise TypeError(f'loss_decode must be a dict or sequence of dict,\
+                but got {type(loss_decode)}')
+
+        if sampler is not None:
+            self.sampler = build_pixel_sampler(sampler, context=self)
+        else:
+            self.sampler = None
+
+        self.conv_seg = nn.Conv2d(channels, self.out_channels, kernel_size=1)
+        if dropout_ratio > 0:
+            self.dropout = nn.Dropout2d(dropout_ratio)
+        else:
+            self.dropout = None
+
+    def extra_repr(self):
+        """Extra repr."""
+        s = f'input_transform={self.input_transform}, ' \
+            f'ignore_index={self.ignore_index}, ' \
+            f'align_corners={self.align_corners}'
+        return s
+
+    def _init_inputs(self, in_channels, in_index, input_transform):
+        """Check and initialize input transforms.
+
+        The in_channels, in_index and input_transform must match.
+        Specifically, when input_transform is None, only single feature map
+        will be selected. So in_channels and in_index must be of type int.
+        When input_transform
+
+        Args:
+            in_channels (int|Sequence[int]): Input channels.
+            in_index (int|Sequence[int]): Input feature index.
+            input_transform (str|None): Transformation type of input features.
+                Options: 'resize_concat', 'multiple_select', None.
+                'resize_concat': Multiple feature maps will be resize to the
+                    same size as first one and than concat together.
+                    Usually used in FCN head of HRNet.
+                'multiple_select': Multiple feature maps will be bundle into
+                    a list and passed into decode head.
+                None: Only one select feature map is allowed.
+        """
+
+        if input_transform is not None:
+            assert input_transform in ['resize_concat', 'multiple_select']
+        self.input_transform = input_transform
+        self.in_index = in_index
+        if input_transform is not None:
+            assert isinstance(in_channels, (list, tuple))
+            assert isinstance(in_index, (list, tuple))
+            assert len(in_channels) == len(in_index)
+            if input_transform == 'resize_concat':
+                self.in_channels = sum(in_channels)
+            else:
+                self.in_channels = in_channels
+        else:
+            assert isinstance(in_channels, int)
+            assert isinstance(in_index, int)
+            self.in_channels = in_channels
+
+    def _transform_inputs(self, inputs):
+        """Transform inputs for decoder.
+
+        Args:
+            inputs (list[Tensor]): List of multi-level img features.
+
+        Returns:
+            Tensor: The transformed inputs
+        """
+
+        if self.input_transform == 'resize_concat':
+            inputs = [inputs[i] for i in self.in_index]
+            upsampled_inputs = [
+                resize(
+                    input=x,
+                    size=inputs[0].shape[2:],
+                    mode='bilinear',
+                    align_corners=self.align_corners) for x in inputs
+            ]
+            inputs = torch.cat(upsampled_inputs, dim=1)
+        elif self.input_transform == 'multiple_select':
+            inputs = [inputs[i] for i in self.in_index]
+        else:
+            inputs = inputs[self.in_index]
+
+        return inputs
+
+    @abstractmethod
+    def forward(self, inputs):
+        """Placeholder of forward function."""
+        pass
+
+    def cls_seg(self, feat):
+        """Classify each pixel."""
+        if self.dropout is not None:
+            feat = self.dropout(feat)
+        output = self.conv_seg(feat)
+        return output
+
+    def loss(self, inputs: Tuple[Tensor], batch_data_samples: SampleList,
+             train_cfg: ConfigType) -> dict:
+        """Forward function for training.
+
+        Args:
+            inputs (Tuple[Tensor]): List of multi-level img features.
+            batch_data_samples (list[:obj:`SegDataSample`]): The seg
+                data samples. It usually includes information such
+                as `img_metas` or `gt_semantic_seg`.
+            train_cfg (dict): The training config.
+
+        Returns:
+            dict[str, Tensor]: a dictionary of loss components
+        """
+        seg_logits = self.forward(inputs)
+        losses = self.loss_by_feat(seg_logits, batch_data_samples)
+        return losses
+
+    def predict(self, inputs: Tuple[Tensor], batch_img_metas: List[dict],
+                test_cfg: ConfigType) -> Tensor:
+        """Forward function for prediction.
+
+        Args:
+            inputs (Tuple[Tensor]): List of multi-level img features.
+            batch_img_metas (dict): List Image info where each dict may also
+                contain: 'img_shape', 'scale_factor', 'flip', 'img_path',
+                'ori_shape', and 'pad_shape'.
+                For details on the values of these keys see
+                `mmseg/datasets/pipelines/formatting.py:PackSegInputs`.
+            test_cfg (dict): The testing config.
+
+        Returns:
+            Tensor: Outputs segmentation logits map.
+        """
+        seg_logits = self.forward(inputs)
+
+        return self.predict_by_feat(seg_logits, batch_img_metas)
+
+    def _stack_batch_gt(self, batch_data_samples: SampleList) -> Tensor:
+        gt_semantic_segs = [
+            data_sample.gt_sem_seg.data for data_sample in batch_data_samples
+        ]
+        return torch.stack(gt_semantic_segs, dim=0)
+
+    def loss_by_feat(self, seg_logits: Tensor,
+                     batch_data_samples: SampleList) -> dict:
+        """Compute segmentation loss.
+
+        Args:
+            seg_logits (Tensor): The output from decode head forward function.
+            batch_data_samples (List[:obj:`SegDataSample`]): The seg
+                data samples. It usually includes information such
+                as `metainfo` and `gt_sem_seg`.
+
+        Returns:
+            dict[str, Tensor]: a dictionary of loss components
+        """
+
+        seg_label = self._stack_batch_gt(batch_data_samples)
+        loss = dict()
+        seg_logits = resize(
+            input=seg_logits,
+            size=seg_label.shape[2:],
+            mode='bilinear',
+            align_corners=self.align_corners)
+        if self.sampler is not None:
+            seg_weight = self.sampler.sample(seg_logits, seg_label)
+        else:
+            seg_weight = None
+        seg_label = seg_label.squeeze(1)
+
+        if not isinstance(self.loss_decode, nn.ModuleList):
+            losses_decode = [self.loss_decode]
+        else:
+            losses_decode = self.loss_decode
+        for loss_decode in losses_decode:
+            if loss_decode.loss_name not in loss:
+                loss[loss_decode.loss_name] = loss_decode(
+                    seg_logits,
+                    seg_label,
+                    weight=seg_weight,
+                    ignore_index=self.ignore_index)
+            else:
+                loss[loss_decode.loss_name] += loss_decode(
+                    seg_logits,
+                    seg_label,
+                    weight=seg_weight,
+                    ignore_index=self.ignore_index)
+
+        loss['acc_seg'] = accuracy(
+            seg_logits, seg_label, ignore_index=self.ignore_index)
+        return loss
+
+    def predict_by_feat(self, seg_logits: Tensor,
+                        batch_img_metas: List[dict]) -> Tensor:
+        """Transform a batch of output seg_logits to the input shape.
+
+        Args:
+            seg_logits (Tensor): The output from decode head forward function.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+
+        Returns:
+            Tensor: Outputs segmentation logits map.
+        """
+
+        if isinstance(batch_img_metas[0]['img_shape'], torch.Size):
+            # slide inference
+            size = batch_img_metas[0]['img_shape']
+        elif 'pad_shape' in batch_img_metas[0]:
+            size = batch_img_metas[0]['pad_shape'][:2]
+        else:
+            size = batch_img_metas[0]['img_shape']
+
+        seg_logits = resize(
+            input=seg_logits,
+            size=size,
+            mode='bilinear',
+            align_corners=self.align_corners)
+        return seg_logits
diff --git a/mmsegmentation/mmseg/models/decode_heads/dm_head.py b/mmsegmentation/mmseg/models/decode_heads/dm_head.py
new file mode 100644
index 0000000..7694abd
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/dm_head.py
@@ -0,0 +1,141 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule, build_activation_layer, build_norm_layer
+
+from mmseg.registry import MODELS
+from .decode_head import BaseDecodeHead
+
+
+class DCM(nn.Module):
+    """Dynamic Convolutional Module used in DMNet.
+
+    Args:
+        filter_size (int): The filter size of generated convolution kernel
+            used in Dynamic Convolutional Module.
+        fusion (bool): Add one conv to fuse DCM output feature.
+        in_channels (int): Input channels.
+        channels (int): Channels after modules, before conv_seg.
+        conv_cfg (dict | None): Config of conv layers.
+        norm_cfg (dict | None): Config of norm layers.
+        act_cfg (dict): Config of activation layers.
+    """
+
+    def __init__(self, filter_size, fusion, in_channels, channels, conv_cfg,
+                 norm_cfg, act_cfg):
+        super().__init__()
+        self.filter_size = filter_size
+        self.fusion = fusion
+        self.in_channels = in_channels
+        self.channels = channels
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+        self.filter_gen_conv = nn.Conv2d(self.in_channels, self.channels, 1, 1,
+                                         0)
+
+        self.input_redu_conv = ConvModule(
+            self.in_channels,
+            self.channels,
+            1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+        if self.norm_cfg is not None:
+            self.norm = build_norm_layer(self.norm_cfg, self.channels)[1]
+        else:
+            self.norm = None
+        self.activate = build_activation_layer(self.act_cfg)
+
+        if self.fusion:
+            self.fusion_conv = ConvModule(
+                self.channels,
+                self.channels,
+                1,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg)
+
+    def forward(self, x):
+        """Forward function."""
+        generated_filter = self.filter_gen_conv(
+            F.adaptive_avg_pool2d(x, self.filter_size))
+        x = self.input_redu_conv(x)
+        b, c, h, w = x.shape
+        # [1, b * c, h, w], c = self.channels
+        x = x.view(1, b * c, h, w)
+        # [b * c, 1, filter_size, filter_size]
+        generated_filter = generated_filter.view(b * c, 1, self.filter_size,
+                                                 self.filter_size)
+        pad = (self.filter_size - 1) // 2
+        if (self.filter_size - 1) % 2 == 0:
+            p2d = (pad, pad, pad, pad)
+        else:
+            p2d = (pad + 1, pad, pad + 1, pad)
+        x = F.pad(input=x, pad=p2d, mode='constant', value=0)
+        # [1, b * c, h, w]
+        output = F.conv2d(input=x, weight=generated_filter, groups=b * c)
+        # [b, c, h, w]
+        output = output.view(b, c, h, w)
+        if self.norm is not None:
+            output = self.norm(output)
+        output = self.activate(output)
+
+        if self.fusion:
+            output = self.fusion_conv(output)
+
+        return output
+
+
+@MODELS.register_module()
+class DMHead(BaseDecodeHead):
+    """Dynamic Multi-scale Filters for Semantic Segmentation.
+
+    This head is the implementation of
+    `DMNet <https://openaccess.thecvf.com/content_ICCV_2019/papers/\
+        He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_\
+            ICCV_2019_paper.pdf>`_.
+
+    Args:
+        filter_sizes (tuple[int]): The size of generated convolutional filters
+            used in Dynamic Convolutional Module. Default: (1, 3, 5, 7).
+        fusion (bool): Add one conv to fuse DCM output feature.
+    """
+
+    def __init__(self, filter_sizes=(1, 3, 5, 7), fusion=False, **kwargs):
+        super().__init__(**kwargs)
+        assert isinstance(filter_sizes, (list, tuple))
+        self.filter_sizes = filter_sizes
+        self.fusion = fusion
+        dcm_modules = []
+        for filter_size in self.filter_sizes:
+            dcm_modules.append(
+                DCM(filter_size,
+                    self.fusion,
+                    self.in_channels,
+                    self.channels,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg,
+                    act_cfg=self.act_cfg))
+        self.dcm_modules = nn.ModuleList(dcm_modules)
+        self.bottleneck = ConvModule(
+            self.in_channels + len(filter_sizes) * self.channels,
+            self.channels,
+            3,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+    def forward(self, inputs):
+        """Forward function."""
+        x = self._transform_inputs(inputs)
+        dcm_outs = [x]
+        for dcm_module in self.dcm_modules:
+            dcm_outs.append(dcm_module(x))
+        dcm_outs = torch.cat(dcm_outs, dim=1)
+        output = self.bottleneck(dcm_outs)
+        output = self.cls_seg(output)
+        return output
diff --git a/mmsegmentation/mmseg/models/decode_heads/dnl_head.py b/mmsegmentation/mmseg/models/decode_heads/dnl_head.py
new file mode 100644
index 0000000..248c118
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/dnl_head.py
@@ -0,0 +1,137 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from mmcv.cnn import NonLocal2d
+from torch import nn
+
+from mmseg.registry import MODELS
+from .fcn_head import FCNHead
+
+
+class DisentangledNonLocal2d(NonLocal2d):
+    """Disentangled Non-Local Blocks.
+
+    Args:
+        temperature (float): Temperature to adjust attention. Default: 0.05
+    """
+
+    def __init__(self, *arg, temperature, **kwargs):
+        super().__init__(*arg, **kwargs)
+        self.temperature = temperature
+        self.conv_mask = nn.Conv2d(self.in_channels, 1, kernel_size=1)
+
+    def embedded_gaussian(self, theta_x, phi_x):
+        """Embedded gaussian with temperature."""
+
+        # NonLocal2d pairwise_weight: [N, HxW, HxW]
+        pairwise_weight = torch.matmul(theta_x, phi_x)
+        if self.use_scale:
+            # theta_x.shape[-1] is `self.inter_channels`
+            pairwise_weight /= torch.tensor(
+                theta_x.shape[-1],
+                dtype=torch.float,
+                device=pairwise_weight.device)**torch.tensor(
+                    0.5, device=pairwise_weight.device)
+        pairwise_weight /= torch.tensor(
+            self.temperature, device=pairwise_weight.device)
+        pairwise_weight = pairwise_weight.softmax(dim=-1)
+        return pairwise_weight
+
+    def forward(self, x):
+        # x: [N, C, H, W]
+        n = x.size(0)
+
+        # g_x: [N, HxW, C]
+        g_x = self.g(x).view(n, self.inter_channels, -1)
+        g_x = g_x.permute(0, 2, 1)
+
+        # theta_x: [N, HxW, C], phi_x: [N, C, HxW]
+        if self.mode == 'gaussian':
+            theta_x = x.view(n, self.in_channels, -1)
+            theta_x = theta_x.permute(0, 2, 1)
+            if self.sub_sample:
+                phi_x = self.phi(x).view(n, self.in_channels, -1)
+            else:
+                phi_x = x.view(n, self.in_channels, -1)
+        elif self.mode == 'concatenation':
+            theta_x = self.theta(x).view(n, self.inter_channels, -1, 1)
+            phi_x = self.phi(x).view(n, self.inter_channels, 1, -1)
+        else:
+            theta_x = self.theta(x).view(n, self.inter_channels, -1)
+            theta_x = theta_x.permute(0, 2, 1)
+            phi_x = self.phi(x).view(n, self.inter_channels, -1)
+
+        # subtract mean
+        theta_x -= theta_x.mean(dim=-2, keepdim=True)
+        phi_x -= phi_x.mean(dim=-1, keepdim=True)
+
+        pairwise_func = getattr(self, self.mode)
+        # pairwise_weight: [N, HxW, HxW]
+        pairwise_weight = pairwise_func(theta_x, phi_x)
+
+        # y: [N, HxW, C]
+        y = torch.matmul(pairwise_weight, g_x)
+        # y: [N, C, H, W]
+        y = y.permute(0, 2, 1).contiguous().reshape(n, self.inter_channels,
+                                                    *x.size()[2:])
+
+        # unary_mask: [N, 1, HxW]
+        unary_mask = self.conv_mask(x)
+        unary_mask = unary_mask.view(n, 1, -1)
+        unary_mask = unary_mask.softmax(dim=-1)
+        # unary_x: [N, 1, C]
+        unary_x = torch.matmul(unary_mask, g_x)
+        # unary_x: [N, C, 1, 1]
+        unary_x = unary_x.permute(0, 2, 1).contiguous().reshape(
+            n, self.inter_channels, 1, 1)
+
+        output = x + self.conv_out(y + unary_x)
+
+        return output
+
+
+@MODELS.register_module()
+class DNLHead(FCNHead):
+    """Disentangled Non-Local Neural Networks.
+
+    This head is the implementation of `DNLNet
+    <https://arxiv.org/abs/2006.06668>`_.
+
+    Args:
+        reduction (int): Reduction factor of projection transform. Default: 2.
+        use_scale (bool): Whether to scale pairwise_weight by
+            sqrt(1/inter_channels). Default: False.
+        mode (str): The nonlocal mode. Options are 'embedded_gaussian',
+            'dot_product'. Default: 'embedded_gaussian.'.
+        temperature (float): Temperature to adjust attention. Default: 0.05
+    """
+
+    def __init__(self,
+                 reduction=2,
+                 use_scale=True,
+                 mode='embedded_gaussian',
+                 temperature=0.05,
+                 **kwargs):
+        super().__init__(num_convs=2, **kwargs)
+        self.reduction = reduction
+        self.use_scale = use_scale
+        self.mode = mode
+        self.temperature = temperature
+        self.dnl_block = DisentangledNonLocal2d(
+            in_channels=self.channels,
+            reduction=self.reduction,
+            use_scale=self.use_scale,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            mode=self.mode,
+            temperature=self.temperature)
+
+    def forward(self, inputs):
+        """Forward function."""
+        x = self._transform_inputs(inputs)
+        output = self.convs[0](x)
+        output = self.dnl_block(output)
+        output = self.convs[1](output)
+        if self.concat_input:
+            output = self.conv_cat(torch.cat([x, output], dim=1))
+        output = self.cls_seg(output)
+        return output
diff --git a/mmsegmentation/mmseg/models/decode_heads/dpt_head.py b/mmsegmentation/mmseg/models/decode_heads/dpt_head.py
new file mode 100644
index 0000000..d2cfd89
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/dpt_head.py
@@ -0,0 +1,294 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule, Linear, build_activation_layer
+from mmengine.model import BaseModule
+
+from mmseg.registry import MODELS
+from ..utils import resize
+from .decode_head import BaseDecodeHead
+
+
+class ReassembleBlocks(BaseModule):
+    """ViTPostProcessBlock, process cls_token in ViT backbone output and
+    rearrange the feature vector to feature map.
+
+    Args:
+        in_channels (int): ViT feature channels. Default: 768.
+        out_channels (List): output channels of each stage.
+            Default: [96, 192, 384, 768].
+        readout_type (str): Type of readout operation. Default: 'ignore'.
+        patch_size (int): The patch size. Default: 16.
+        init_cfg (dict, optional): Initialization config dict. Default: None.
+    """
+
+    def __init__(self,
+                 in_channels=768,
+                 out_channels=[96, 192, 384, 768],
+                 readout_type='ignore',
+                 patch_size=16,
+                 init_cfg=None):
+        super().__init__(init_cfg)
+
+        assert readout_type in ['ignore', 'add', 'project']
+        self.readout_type = readout_type
+        self.patch_size = patch_size
+
+        self.projects = nn.ModuleList([
+            ConvModule(
+                in_channels=in_channels,
+                out_channels=out_channel,
+                kernel_size=1,
+                act_cfg=None,
+            ) for out_channel in out_channels
+        ])
+
+        self.resize_layers = nn.ModuleList([
+            nn.ConvTranspose2d(
+                in_channels=out_channels[0],
+                out_channels=out_channels[0],
+                kernel_size=4,
+                stride=4,
+                padding=0),
+            nn.ConvTranspose2d(
+                in_channels=out_channels[1],
+                out_channels=out_channels[1],
+                kernel_size=2,
+                stride=2,
+                padding=0),
+            nn.Identity(),
+            nn.Conv2d(
+                in_channels=out_channels[3],
+                out_channels=out_channels[3],
+                kernel_size=3,
+                stride=2,
+                padding=1)
+        ])
+        if self.readout_type == 'project':
+            self.readout_projects = nn.ModuleList()
+            for _ in range(len(self.projects)):
+                self.readout_projects.append(
+                    nn.Sequential(
+                        Linear(2 * in_channels, in_channels),
+                        build_activation_layer(dict(type='GELU'))))
+
+    def forward(self, inputs):
+        assert isinstance(inputs, list)
+        out = []
+        for i, x in enumerate(inputs):
+            assert len(x) == 2
+            x, cls_token = x[0], x[1]
+            feature_shape = x.shape
+            if self.readout_type == 'project':
+                x = x.flatten(2).permute((0, 2, 1))
+                readout = cls_token.unsqueeze(1).expand_as(x)
+                x = self.readout_projects[i](torch.cat((x, readout), -1))
+                x = x.permute(0, 2, 1).reshape(feature_shape)
+            elif self.readout_type == 'add':
+                x = x.flatten(2) + cls_token.unsqueeze(-1)
+                x = x.reshape(feature_shape)
+            else:
+                pass
+            x = self.projects[i](x)
+            x = self.resize_layers[i](x)
+            out.append(x)
+        return out
+
+
+class PreActResidualConvUnit(BaseModule):
+    """ResidualConvUnit, pre-activate residual unit.
+
+    Args:
+        in_channels (int): number of channels in the input feature map.
+        act_cfg (dict): dictionary to construct and config activation layer.
+        norm_cfg (dict): dictionary to construct and config norm layer.
+        stride (int): stride of the first block. Default: 1
+        dilation (int): dilation rate for convs layers. Default: 1.
+        init_cfg (dict, optional): Initialization config dict. Default: None.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 act_cfg,
+                 norm_cfg,
+                 stride=1,
+                 dilation=1,
+                 init_cfg=None):
+        super().__init__(init_cfg)
+
+        self.conv1 = ConvModule(
+            in_channels,
+            in_channels,
+            3,
+            stride=stride,
+            padding=dilation,
+            dilation=dilation,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg,
+            bias=False,
+            order=('act', 'conv', 'norm'))
+
+        self.conv2 = ConvModule(
+            in_channels,
+            in_channels,
+            3,
+            padding=1,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg,
+            bias=False,
+            order=('act', 'conv', 'norm'))
+
+    def forward(self, inputs):
+        inputs_ = inputs.clone()
+        x = self.conv1(inputs)
+        x = self.conv2(x)
+        return x + inputs_
+
+
+class FeatureFusionBlock(BaseModule):
+    """FeatureFusionBlock, merge feature map from different stages.
+
+    Args:
+        in_channels (int): Input channels.
+        act_cfg (dict): The activation config for ResidualConvUnit.
+        norm_cfg (dict): Config dict for normalization layer.
+        expand (bool): Whether expand the channels in post process block.
+            Default: False.
+        align_corners (bool): align_corner setting for bilinear upsample.
+            Default: True.
+        init_cfg (dict, optional): Initialization config dict. Default: None.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 act_cfg,
+                 norm_cfg,
+                 expand=False,
+                 align_corners=True,
+                 init_cfg=None):
+        super().__init__(init_cfg)
+
+        self.in_channels = in_channels
+        self.expand = expand
+        self.align_corners = align_corners
+
+        self.out_channels = in_channels
+        if self.expand:
+            self.out_channels = in_channels // 2
+
+        self.project = ConvModule(
+            self.in_channels,
+            self.out_channels,
+            kernel_size=1,
+            act_cfg=None,
+            bias=True)
+
+        self.res_conv_unit1 = PreActResidualConvUnit(
+            in_channels=self.in_channels, act_cfg=act_cfg, norm_cfg=norm_cfg)
+        self.res_conv_unit2 = PreActResidualConvUnit(
+            in_channels=self.in_channels, act_cfg=act_cfg, norm_cfg=norm_cfg)
+
+    def forward(self, *inputs):
+        x = inputs[0]
+        if len(inputs) == 2:
+            if x.shape != inputs[1].shape:
+                res = resize(
+                    inputs[1],
+                    size=(x.shape[2], x.shape[3]),
+                    mode='bilinear',
+                    align_corners=False)
+            else:
+                res = inputs[1]
+            x = x + self.res_conv_unit1(res)
+        x = self.res_conv_unit2(x)
+        x = resize(
+            x,
+            scale_factor=2,
+            mode='bilinear',
+            align_corners=self.align_corners)
+        x = self.project(x)
+        return x
+
+
+@MODELS.register_module()
+class DPTHead(BaseDecodeHead):
+    """Vision Transformers for Dense Prediction.
+
+    This head is implemented of `DPT <https://arxiv.org/abs/2103.13413>`_.
+
+    Args:
+        embed_dims (int): The embed dimension of the ViT backbone.
+            Default: 768.
+        post_process_channels (List): Out channels of post process conv
+            layers. Default: [96, 192, 384, 768].
+        readout_type (str): Type of readout operation. Default: 'ignore'.
+        patch_size (int): The patch size. Default: 16.
+        expand_channels (bool): Whether expand the channels in post process
+            block. Default: False.
+        act_cfg (dict): The activation config for residual conv unit.
+            Default dict(type='ReLU').
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN').
+    """
+
+    def __init__(self,
+                 embed_dims=768,
+                 post_process_channels=[96, 192, 384, 768],
+                 readout_type='ignore',
+                 patch_size=16,
+                 expand_channels=False,
+                 act_cfg=dict(type='ReLU'),
+                 norm_cfg=dict(type='BN'),
+                 **kwargs):
+        super().__init__(**kwargs)
+
+        self.in_channels = self.in_channels
+        self.expand_channels = expand_channels
+        self.reassemble_blocks = ReassembleBlocks(embed_dims,
+                                                  post_process_channels,
+                                                  readout_type, patch_size)
+
+        self.post_process_channels = [
+            channel * math.pow(2, i) if expand_channels else channel
+            for i, channel in enumerate(post_process_channels)
+        ]
+        self.convs = nn.ModuleList()
+        for channel in self.post_process_channels:
+            self.convs.append(
+                ConvModule(
+                    channel,
+                    self.channels,
+                    kernel_size=3,
+                    padding=1,
+                    act_cfg=None,
+                    bias=False))
+        self.fusion_blocks = nn.ModuleList()
+        for _ in range(len(self.convs)):
+            self.fusion_blocks.append(
+                FeatureFusionBlock(self.channels, act_cfg, norm_cfg))
+        self.fusion_blocks[0].res_conv_unit1 = None
+        self.project = ConvModule(
+            self.channels,
+            self.channels,
+            kernel_size=3,
+            padding=1,
+            norm_cfg=norm_cfg)
+        self.num_fusion_blocks = len(self.fusion_blocks)
+        self.num_reassemble_blocks = len(self.reassemble_blocks.resize_layers)
+        self.num_post_process_channels = len(self.post_process_channels)
+        assert self.num_fusion_blocks == self.num_reassemble_blocks
+        assert self.num_reassemble_blocks == self.num_post_process_channels
+
+    def forward(self, inputs):
+        assert len(inputs) == self.num_reassemble_blocks
+        x = self._transform_inputs(inputs)
+        x = self.reassemble_blocks(x)
+        x = [self.convs[i](feature) for i, feature in enumerate(x)]
+        out = self.fusion_blocks[0](x[-1])
+        for i in range(1, len(self.fusion_blocks)):
+            out = self.fusion_blocks[i](out, x[-(i + 1)])
+        out = self.project(out)
+        out = self.cls_seg(out)
+        return out
diff --git a/mmsegmentation/mmseg/models/decode_heads/ema_head.py b/mmsegmentation/mmseg/models/decode_heads/ema_head.py
new file mode 100644
index 0000000..ab8dbb0
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/ema_head.py
@@ -0,0 +1,169 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+
+from mmseg.registry import MODELS
+from .decode_head import BaseDecodeHead
+
+
+def reduce_mean(tensor):
+    """Reduce mean when distributed training."""
+    if not (dist.is_available() and dist.is_initialized()):
+        return tensor
+    tensor = tensor.clone()
+    dist.all_reduce(tensor.div_(dist.get_world_size()), op=dist.ReduceOp.SUM)
+    return tensor
+
+
+class EMAModule(nn.Module):
+    """Expectation Maximization Attention Module used in EMANet.
+
+    Args:
+        channels (int): Channels of the whole module.
+        num_bases (int): Number of bases.
+        num_stages (int): Number of the EM iterations.
+    """
+
+    def __init__(self, channels, num_bases, num_stages, momentum):
+        super().__init__()
+        assert num_stages >= 1, 'num_stages must be at least 1!'
+        self.num_bases = num_bases
+        self.num_stages = num_stages
+        self.momentum = momentum
+
+        bases = torch.zeros(1, channels, self.num_bases)
+        bases.normal_(0, math.sqrt(2. / self.num_bases))
+        # [1, channels, num_bases]
+        bases = F.normalize(bases, dim=1, p=2)
+        self.register_buffer('bases', bases)
+
+    def forward(self, feats):
+        """Forward function."""
+        batch_size, channels, height, width = feats.size()
+        # [batch_size, channels, height*width]
+        feats = feats.view(batch_size, channels, height * width)
+        # [batch_size, channels, num_bases]
+        bases = self.bases.repeat(batch_size, 1, 1)
+
+        with torch.no_grad():
+            for i in range(self.num_stages):
+                # [batch_size, height*width, num_bases]
+                attention = torch.einsum('bcn,bck->bnk', feats, bases)
+                attention = F.softmax(attention, dim=2)
+                # l1 norm
+                attention_normed = F.normalize(attention, dim=1, p=1)
+                # [batch_size, channels, num_bases]
+                bases = torch.einsum('bcn,bnk->bck', feats, attention_normed)
+                # l2 norm
+                bases = F.normalize(bases, dim=1, p=2)
+
+        feats_recon = torch.einsum('bck,bnk->bcn', bases, attention)
+        feats_recon = feats_recon.view(batch_size, channels, height, width)
+
+        if self.training:
+            bases = bases.mean(dim=0, keepdim=True)
+            bases = reduce_mean(bases)
+            # l2 norm
+            bases = F.normalize(bases, dim=1, p=2)
+            self.bases = (1 -
+                          self.momentum) * self.bases + self.momentum * bases
+
+        return feats_recon
+
+
+@MODELS.register_module()
+class EMAHead(BaseDecodeHead):
+    """Expectation Maximization Attention Networks for Semantic Segmentation.
+
+    This head is the implementation of `EMANet
+    <https://arxiv.org/abs/1907.13426>`_.
+
+    Args:
+        ema_channels (int): EMA module channels
+        num_bases (int): Number of bases.
+        num_stages (int): Number of the EM iterations.
+        concat_input (bool): Whether concat the input and output of convs
+            before classification layer. Default: True
+        momentum (float): Momentum to update the base. Default: 0.1.
+    """
+
+    def __init__(self,
+                 ema_channels,
+                 num_bases,
+                 num_stages,
+                 concat_input=True,
+                 momentum=0.1,
+                 **kwargs):
+        super().__init__(**kwargs)
+        self.ema_channels = ema_channels
+        self.num_bases = num_bases
+        self.num_stages = num_stages
+        self.concat_input = concat_input
+        self.momentum = momentum
+        self.ema_module = EMAModule(self.ema_channels, self.num_bases,
+                                    self.num_stages, self.momentum)
+
+        self.ema_in_conv = ConvModule(
+            self.in_channels,
+            self.ema_channels,
+            3,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+        # project (0, inf) -> (-inf, inf)
+        self.ema_mid_conv = ConvModule(
+            self.ema_channels,
+            self.ema_channels,
+            1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=None,
+            act_cfg=None)
+        for param in self.ema_mid_conv.parameters():
+            param.requires_grad = False
+
+        self.ema_out_conv = ConvModule(
+            self.ema_channels,
+            self.ema_channels,
+            1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=None)
+        self.bottleneck = ConvModule(
+            self.ema_channels,
+            self.channels,
+            3,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+        if self.concat_input:
+            self.conv_cat = ConvModule(
+                self.in_channels + self.channels,
+                self.channels,
+                kernel_size=3,
+                padding=1,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg)
+
+    def forward(self, inputs):
+        """Forward function."""
+        x = self._transform_inputs(inputs)
+        feats = self.ema_in_conv(x)
+        identity = feats
+        feats = self.ema_mid_conv(feats)
+        recon = self.ema_module(feats)
+        recon = F.relu(recon, inplace=True)
+        recon = self.ema_out_conv(recon)
+        output = F.relu(identity + recon, inplace=True)
+        output = self.bottleneck(output)
+        if self.concat_input:
+            output = self.conv_cat(torch.cat([x, output], dim=1))
+        output = self.cls_seg(output)
+        return output
diff --git a/mmsegmentation/mmseg/models/decode_heads/enc_head.py b/mmsegmentation/mmseg/models/decode_heads/enc_head.py
new file mode 100644
index 0000000..2bba73b
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/enc_head.py
@@ -0,0 +1,196 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule, build_norm_layer
+from torch import Tensor
+
+from mmseg.registry import MODELS
+from mmseg.utils import ConfigType, SampleList
+from ..utils import Encoding, resize
+from .decode_head import BaseDecodeHead
+
+
+class EncModule(nn.Module):
+    """Encoding Module used in EncNet.
+
+    Args:
+        in_channels (int): Input channels.
+        num_codes (int): Number of code words.
+        conv_cfg (dict|None): Config of conv layers.
+        norm_cfg (dict|None): Config of norm layers.
+        act_cfg (dict): Config of activation layers.
+    """
+
+    def __init__(self, in_channels, num_codes, conv_cfg, norm_cfg, act_cfg):
+        super().__init__()
+        self.encoding_project = ConvModule(
+            in_channels,
+            in_channels,
+            1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        # TODO: resolve this hack
+        # change to 1d
+        if norm_cfg is not None:
+            encoding_norm_cfg = norm_cfg.copy()
+            if encoding_norm_cfg['type'] in ['BN', 'IN']:
+                encoding_norm_cfg['type'] += '1d'
+            else:
+                encoding_norm_cfg['type'] = encoding_norm_cfg['type'].replace(
+                    '2d', '1d')
+        else:
+            # fallback to BN1d
+            encoding_norm_cfg = dict(type='BN1d')
+        self.encoding = nn.Sequential(
+            Encoding(channels=in_channels, num_codes=num_codes),
+            build_norm_layer(encoding_norm_cfg, num_codes)[1],
+            nn.ReLU(inplace=True))
+        self.fc = nn.Sequential(
+            nn.Linear(in_channels, in_channels), nn.Sigmoid())
+
+    def forward(self, x):
+        """Forward function."""
+        encoding_projection = self.encoding_project(x)
+        encoding_feat = self.encoding(encoding_projection).mean(dim=1)
+        batch_size, channels, _, _ = x.size()
+        gamma = self.fc(encoding_feat)
+        y = gamma.view(batch_size, channels, 1, 1)
+        output = F.relu_(x + x * y)
+        return encoding_feat, output
+
+
+@MODELS.register_module()
+class EncHead(BaseDecodeHead):
+    """Context Encoding for Semantic Segmentation.
+
+    This head is the implementation of `EncNet
+    <https://arxiv.org/abs/1803.08904>`_.
+
+    Args:
+        num_codes (int): Number of code words. Default: 32.
+        use_se_loss (bool): Whether use Semantic Encoding Loss (SE-loss) to
+            regularize the training. Default: True.
+        add_lateral (bool): Whether use lateral connection to fuse features.
+            Default: False.
+        loss_se_decode (dict): Config of decode loss.
+            Default: dict(type='CrossEntropyLoss', use_sigmoid=True).
+    """
+
+    def __init__(self,
+                 num_codes=32,
+                 use_se_loss=True,
+                 add_lateral=False,
+                 loss_se_decode=dict(
+                     type='CrossEntropyLoss',
+                     use_sigmoid=True,
+                     loss_weight=0.2),
+                 **kwargs):
+        super().__init__(input_transform='multiple_select', **kwargs)
+        self.use_se_loss = use_se_loss
+        self.add_lateral = add_lateral
+        self.num_codes = num_codes
+        self.bottleneck = ConvModule(
+            self.in_channels[-1],
+            self.channels,
+            3,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+        if add_lateral:
+            self.lateral_convs = nn.ModuleList()
+            for in_channels in self.in_channels[:-1]:  # skip the last one
+                self.lateral_convs.append(
+                    ConvModule(
+                        in_channels,
+                        self.channels,
+                        1,
+                        conv_cfg=self.conv_cfg,
+                        norm_cfg=self.norm_cfg,
+                        act_cfg=self.act_cfg))
+            self.fusion = ConvModule(
+                len(self.in_channels) * self.channels,
+                self.channels,
+                3,
+                padding=1,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg)
+        self.enc_module = EncModule(
+            self.channels,
+            num_codes=num_codes,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+        if self.use_se_loss:
+            self.loss_se_decode = MODELS.build(loss_se_decode)
+            self.se_layer = nn.Linear(self.channels, self.num_classes)
+
+    def forward(self, inputs):
+        """Forward function."""
+        inputs = self._transform_inputs(inputs)
+        feat = self.bottleneck(inputs[-1])
+        if self.add_lateral:
+            laterals = [
+                resize(
+                    lateral_conv(inputs[i]),
+                    size=feat.shape[2:],
+                    mode='bilinear',
+                    align_corners=self.align_corners)
+                for i, lateral_conv in enumerate(self.lateral_convs)
+            ]
+            feat = self.fusion(torch.cat([feat, *laterals], 1))
+        encode_feat, output = self.enc_module(feat)
+        output = self.cls_seg(output)
+        if self.use_se_loss:
+            se_output = self.se_layer(encode_feat)
+            return output, se_output
+        else:
+            return output
+
+    def predict(self, inputs: Tuple[Tensor], batch_img_metas: List[dict],
+                test_cfg: ConfigType):
+        """Forward function for testing, ignore se_loss."""
+        if self.use_se_loss:
+            seg_logits = self.forward(inputs)[0]
+        else:
+            seg_logits = self.forward(inputs)
+        return self.predict_by_feat(seg_logits, batch_img_metas)
+
+    @staticmethod
+    def _convert_to_onehot_labels(seg_label, num_classes):
+        """Convert segmentation label to onehot.
+
+        Args:
+            seg_label (Tensor): Segmentation label of shape (N, H, W).
+            num_classes (int): Number of classes.
+
+        Returns:
+            Tensor: Onehot labels of shape (N, num_classes).
+        """
+
+        batch_size = seg_label.size(0)
+        onehot_labels = seg_label.new_zeros((batch_size, num_classes))
+        for i in range(batch_size):
+            hist = seg_label[i].float().histc(
+                bins=num_classes, min=0, max=num_classes - 1)
+            onehot_labels[i] = hist > 0
+        return onehot_labels
+
+    def loss_by_feat(self, seg_logit: Tuple[Tensor],
+                     batch_data_samples: SampleList, **kwargs) -> dict:
+        """Compute segmentation and semantic encoding loss."""
+        seg_logit, se_seg_logit = seg_logit
+        loss = dict()
+        loss.update(super().loss_by_feat(seg_logit, batch_data_samples))
+
+        seg_label = self._stack_batch_gt(batch_data_samples)
+        se_loss = self.loss_se_decode(
+            se_seg_logit,
+            self._convert_to_onehot_labels(seg_label, self.num_classes))
+        loss['loss_se'] = se_loss
+        return loss
diff --git a/mmsegmentation/mmseg/models/decode_heads/fcn_head.py b/mmsegmentation/mmseg/models/decode_heads/fcn_head.py
new file mode 100644
index 0000000..3418018
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/fcn_head.py
@@ -0,0 +1,96 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+
+from mmseg.registry import MODELS
+from .decode_head import BaseDecodeHead
+
+
+@MODELS.register_module()
+class FCNHead(BaseDecodeHead):
+    """Fully Convolution Networks for Semantic Segmentation.
+
+    This head is implemented of `FCNNet <https://arxiv.org/abs/1411.4038>`_.
+
+    Args:
+        num_convs (int): Number of convs in the head. Default: 2.
+        kernel_size (int): The kernel size for convs in the head. Default: 3.
+        concat_input (bool): Whether concat the input and output of convs
+            before classification layer.
+        dilation (int): The dilation rate for convs in the head. Default: 1.
+    """
+
+    def __init__(self,
+                 num_convs=2,
+                 kernel_size=3,
+                 concat_input=True,
+                 dilation=1,
+                 **kwargs):
+        assert num_convs >= 0 and dilation > 0 and isinstance(dilation, int)
+        self.num_convs = num_convs
+        self.concat_input = concat_input
+        self.kernel_size = kernel_size
+        super().__init__(**kwargs)
+        if num_convs == 0:
+            assert self.in_channels == self.channels
+
+        conv_padding = (kernel_size // 2) * dilation
+        convs = []
+        convs.append(
+            ConvModule(
+                self.in_channels,
+                self.channels,
+                kernel_size=kernel_size,
+                padding=conv_padding,
+                dilation=dilation,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg))
+        for i in range(num_convs - 1):
+            convs.append(
+                ConvModule(
+                    self.channels,
+                    self.channels,
+                    kernel_size=kernel_size,
+                    padding=conv_padding,
+                    dilation=dilation,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg,
+                    act_cfg=self.act_cfg))
+        if num_convs == 0:
+            self.convs = nn.Identity()
+        else:
+            self.convs = nn.Sequential(*convs)
+        if self.concat_input:
+            self.conv_cat = ConvModule(
+                self.in_channels + self.channels,
+                self.channels,
+                kernel_size=kernel_size,
+                padding=kernel_size // 2,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg)
+
+    def _forward_feature(self, inputs):
+        """Forward function for feature maps before classifying each pixel with
+        ``self.cls_seg`` fc.
+
+        Args:
+            inputs (list[Tensor]): List of multi-level img features.
+
+        Returns:
+            feats (Tensor): A tensor of shape (batch_size, self.channels,
+                H, W) which is feature map for last layer of decoder head.
+        """
+        x = self._transform_inputs(inputs)
+        feats = self.convs(x)
+        if self.concat_input:
+            feats = self.conv_cat(torch.cat([x, feats], dim=1))
+        return feats
+
+    def forward(self, inputs):
+        """Forward function."""
+        output = self._forward_feature(inputs)
+        output = self.cls_seg(output)
+        return output
diff --git a/mmsegmentation/mmseg/models/decode_heads/fpn_head.py b/mmsegmentation/mmseg/models/decode_heads/fpn_head.py
new file mode 100644
index 0000000..25f481f
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/fpn_head.py
@@ -0,0 +1,68 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import numpy as np
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+
+from mmseg.registry import MODELS
+from ..utils import Upsample, resize
+from .decode_head import BaseDecodeHead
+
+
+@MODELS.register_module()
+class FPNHead(BaseDecodeHead):
+    """Panoptic Feature Pyramid Networks.
+
+    This head is the implementation of `Semantic FPN
+    <https://arxiv.org/abs/1901.02446>`_.
+
+    Args:
+        feature_strides (tuple[int]): The strides for input feature maps.
+            stack_lateral. All strides suppose to be power of 2. The first
+            one is of largest resolution.
+    """
+
+    def __init__(self, feature_strides, **kwargs):
+        super().__init__(input_transform='multiple_select', **kwargs)
+        assert len(feature_strides) == len(self.in_channels)
+        assert min(feature_strides) == feature_strides[0]
+        self.feature_strides = feature_strides
+
+        self.scale_heads = nn.ModuleList()
+        for i in range(len(feature_strides)):
+            head_length = max(
+                1,
+                int(np.log2(feature_strides[i]) - np.log2(feature_strides[0])))
+            scale_head = []
+            for k in range(head_length):
+                scale_head.append(
+                    ConvModule(
+                        self.in_channels[i] if k == 0 else self.channels,
+                        self.channels,
+                        3,
+                        padding=1,
+                        conv_cfg=self.conv_cfg,
+                        norm_cfg=self.norm_cfg,
+                        act_cfg=self.act_cfg))
+                if feature_strides[i] != feature_strides[0]:
+                    scale_head.append(
+                        Upsample(
+                            scale_factor=2,
+                            mode='bilinear',
+                            align_corners=self.align_corners))
+            self.scale_heads.append(nn.Sequential(*scale_head))
+
+    def forward(self, inputs):
+
+        x = self._transform_inputs(inputs)
+
+        output = self.scale_heads[0](x[0])
+        for i in range(1, len(self.feature_strides)):
+            # non inplace
+            output = output + resize(
+                self.scale_heads[i](x[i]),
+                size=output.shape[2:],
+                mode='bilinear',
+                align_corners=self.align_corners)
+
+        output = self.cls_seg(output)
+        return output
diff --git a/mmsegmentation/mmseg/models/decode_heads/gc_head.py b/mmsegmentation/mmseg/models/decode_heads/gc_head.py
new file mode 100644
index 0000000..14f0ef0
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/gc_head.py
@@ -0,0 +1,48 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from mmcv.cnn import ContextBlock
+
+from mmseg.registry import MODELS
+from .fcn_head import FCNHead
+
+
+@MODELS.register_module()
+class GCHead(FCNHead):
+    """GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond.
+
+    This head is the implementation of `GCNet
+    <https://arxiv.org/abs/1904.11492>`_.
+
+    Args:
+        ratio (float): Multiplier of channels ratio. Default: 1/4.
+        pooling_type (str): The pooling type of context aggregation.
+            Options are 'att', 'avg'. Default: 'avg'.
+        fusion_types (tuple[str]): The fusion type for feature fusion.
+            Options are 'channel_add', 'channel_mul'. Default: ('channel_add',)
+    """
+
+    def __init__(self,
+                 ratio=1 / 4.,
+                 pooling_type='att',
+                 fusion_types=('channel_add', ),
+                 **kwargs):
+        super().__init__(num_convs=2, **kwargs)
+        self.ratio = ratio
+        self.pooling_type = pooling_type
+        self.fusion_types = fusion_types
+        self.gc_block = ContextBlock(
+            in_channels=self.channels,
+            ratio=self.ratio,
+            pooling_type=self.pooling_type,
+            fusion_types=self.fusion_types)
+
+    def forward(self, inputs):
+        """Forward function."""
+        x = self._transform_inputs(inputs)
+        output = self.convs[0](x)
+        output = self.gc_block(output)
+        output = self.convs[1](output)
+        if self.concat_input:
+            output = self.conv_cat(torch.cat([x, output], dim=1))
+        output = self.cls_seg(output)
+        return output
diff --git a/mmsegmentation/mmseg/models/decode_heads/ham_head.py b/mmsegmentation/mmseg/models/decode_heads/ham_head.py
new file mode 100644
index 0000000..073d801
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/ham_head.py
@@ -0,0 +1,255 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# Originally from https://github.com/visual-attention-network/segnext
+# Licensed under the Apache License, Version 2.0 (the "License")
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+from mmengine.device import get_device
+
+from mmseg.registry import MODELS
+from ..utils import resize
+from .decode_head import BaseDecodeHead
+
+
+class Matrix_Decomposition_2D_Base(nn.Module):
+    """Base class of 2D Matrix Decomposition.
+
+    Args:
+        MD_S (int): The number of spatial coefficient in
+            Matrix Decomposition, it may be used for calculation
+            of the number of latent dimension D in Matrix
+            Decomposition. Defaults: 1.
+        MD_R (int): The number of latent dimension R in
+            Matrix Decomposition. Defaults: 64.
+        train_steps (int): The number of iteration steps in
+            Multiplicative Update (MU) rule to solve Non-negative
+            Matrix Factorization (NMF) in training. Defaults: 6.
+        eval_steps (int): The number of iteration steps in
+            Multiplicative Update (MU) rule to solve Non-negative
+            Matrix Factorization (NMF) in evaluation. Defaults: 7.
+        inv_t (int): Inverted multiple number to make coefficient
+            smaller in softmax. Defaults: 100.
+        rand_init (bool): Whether to initialize randomly.
+            Defaults: True.
+    """
+
+    def __init__(self,
+                 MD_S=1,
+                 MD_R=64,
+                 train_steps=6,
+                 eval_steps=7,
+                 inv_t=100,
+                 rand_init=True):
+        super().__init__()
+
+        self.S = MD_S
+        self.R = MD_R
+
+        self.train_steps = train_steps
+        self.eval_steps = eval_steps
+
+        self.inv_t = inv_t
+
+        self.rand_init = rand_init
+
+    def _build_bases(self, B, S, D, R, device=None):
+        raise NotImplementedError
+
+    def local_step(self, x, bases, coef):
+        raise NotImplementedError
+
+    def local_inference(self, x, bases):
+        # (B * S, D, N)^T @ (B * S, D, R) -> (B * S, N, R)
+        coef = torch.bmm(x.transpose(1, 2), bases)
+        coef = F.softmax(self.inv_t * coef, dim=-1)
+
+        steps = self.train_steps if self.training else self.eval_steps
+        for _ in range(steps):
+            bases, coef = self.local_step(x, bases, coef)
+
+        return bases, coef
+
+    def compute_coef(self, x, bases, coef):
+        raise NotImplementedError
+
+    def forward(self, x, return_bases=False):
+        """Forward Function."""
+        B, C, H, W = x.shape
+
+        # (B, C, H, W) -> (B * S, D, N)
+        D = C // self.S
+        N = H * W
+        x = x.view(B * self.S, D, N)
+        if not self.rand_init and not hasattr(self, 'bases'):
+            bases = self._build_bases(1, self.S, D, self.R, device=x.device)
+            self.register_buffer('bases', bases)
+
+        # (S, D, R) -> (B * S, D, R)
+        if self.rand_init:
+            bases = self._build_bases(B, self.S, D, self.R, device=x.device)
+        else:
+            bases = self.bases.repeat(B, 1, 1)
+
+        bases, coef = self.local_inference(x, bases)
+
+        # (B * S, N, R)
+        coef = self.compute_coef(x, bases, coef)
+
+        # (B * S, D, R) @ (B * S, N, R)^T -> (B * S, D, N)
+        x = torch.bmm(bases, coef.transpose(1, 2))
+
+        # (B * S, D, N) -> (B, C, H, W)
+        x = x.view(B, C, H, W)
+
+        return x
+
+
+class NMF2D(Matrix_Decomposition_2D_Base):
+    """Non-negative Matrix Factorization (NMF) module.
+
+    It is inherited from ``Matrix_Decomposition_2D_Base`` module.
+    """
+
+    def __init__(self, args=dict()):
+        super().__init__(**args)
+
+        self.inv_t = 1
+
+    def _build_bases(self, B, S, D, R, device=None):
+        """Build bases in initialization."""
+        if device is None:
+            device = get_device()
+        bases = torch.rand((B * S, D, R)).to(device)
+        bases = F.normalize(bases, dim=1)
+
+        return bases
+
+    def local_step(self, x, bases, coef):
+        """Local step in iteration to renew bases and coefficient."""
+        # (B * S, D, N)^T @ (B * S, D, R) -> (B * S, N, R)
+        numerator = torch.bmm(x.transpose(1, 2), bases)
+        # (B * S, N, R) @ [(B * S, D, R)^T @ (B * S, D, R)] -> (B * S, N, R)
+        denominator = coef.bmm(bases.transpose(1, 2).bmm(bases))
+        # Multiplicative Update
+        coef = coef * numerator / (denominator + 1e-6)
+
+        # (B * S, D, N) @ (B * S, N, R) -> (B * S, D, R)
+        numerator = torch.bmm(x, coef)
+        # (B * S, D, R) @ [(B * S, N, R)^T @ (B * S, N, R)] -> (B * S, D, R)
+        denominator = bases.bmm(coef.transpose(1, 2).bmm(coef))
+        # Multiplicative Update
+        bases = bases * numerator / (denominator + 1e-6)
+
+        return bases, coef
+
+    def compute_coef(self, x, bases, coef):
+        """Compute coefficient."""
+        # (B * S, D, N)^T @ (B * S, D, R) -> (B * S, N, R)
+        numerator = torch.bmm(x.transpose(1, 2), bases)
+        # (B * S, N, R) @ (B * S, D, R)^T @ (B * S, D, R) -> (B * S, N, R)
+        denominator = coef.bmm(bases.transpose(1, 2).bmm(bases))
+        # multiplication update
+        coef = coef * numerator / (denominator + 1e-6)
+
+        return coef
+
+
+class Hamburger(nn.Module):
+    """Hamburger Module. It consists of one slice of "ham" (matrix
+    decomposition) and two slices of "bread" (linear transformation).
+
+    Args:
+        ham_channels (int): Input and output channels of feature.
+        ham_kwargs (dict): Config of matrix decomposition module.
+        norm_cfg (dict | None): Config of norm layers.
+    """
+
+    def __init__(self,
+                 ham_channels=512,
+                 ham_kwargs=dict(),
+                 norm_cfg=None,
+                 **kwargs):
+        super().__init__()
+
+        self.ham_in = ConvModule(
+            ham_channels, ham_channels, 1, norm_cfg=None, act_cfg=None)
+
+        self.ham = NMF2D(ham_kwargs)
+
+        self.ham_out = ConvModule(
+            ham_channels, ham_channels, 1, norm_cfg=norm_cfg, act_cfg=None)
+
+    def forward(self, x):
+        enjoy = self.ham_in(x)
+        enjoy = F.relu(enjoy, inplace=True)
+        enjoy = self.ham(enjoy)
+        enjoy = self.ham_out(enjoy)
+        ham = F.relu(x + enjoy, inplace=True)
+
+        return ham
+
+
+@MODELS.register_module()
+class LightHamHead(BaseDecodeHead):
+    """SegNeXt decode head.
+
+    This decode head is the implementation of `SegNeXt: Rethinking
+    Convolutional Attention Design for Semantic
+    Segmentation <https://arxiv.org/abs/2209.08575>`_.
+    Inspiration from https://github.com/visual-attention-network/segnext.
+
+    Specifically, LightHamHead is inspired by HamNet from
+    `Is Attention Better Than Matrix Decomposition?
+    <https://arxiv.org/abs/2109.04553>`.
+
+    Args:
+        ham_channels (int): input channels for Hamburger.
+            Defaults: 512.
+        ham_kwargs (int): kwagrs for Ham. Defaults: dict().
+    """
+
+    def __init__(self, ham_channels=512, ham_kwargs=dict(), **kwargs):
+        super().__init__(input_transform='multiple_select', **kwargs)
+        self.ham_channels = ham_channels
+
+        self.squeeze = ConvModule(
+            sum(self.in_channels),
+            self.ham_channels,
+            1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+        self.hamburger = Hamburger(ham_channels, ham_kwargs, **kwargs)
+
+        self.align = ConvModule(
+            self.ham_channels,
+            self.channels,
+            1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+    def forward(self, inputs):
+        """Forward function."""
+        inputs = self._transform_inputs(inputs)
+
+        inputs = [
+            resize(
+                level,
+                size=inputs[0].shape[2:],
+                mode='bilinear',
+                align_corners=self.align_corners) for level in inputs
+        ]
+
+        inputs = torch.cat(inputs, dim=1)
+        # apply a conv block to squeeze feature map
+        x = self.squeeze(inputs)
+        # apply hamburger module
+        x = self.hamburger(x)
+
+        # apply a conv block to align feature map
+        output = self.align(x)
+        output = self.cls_seg(output)
+        return output
diff --git a/mmsegmentation/mmseg/models/decode_heads/isa_head.py b/mmsegmentation/mmseg/models/decode_heads/isa_head.py
new file mode 100644
index 0000000..355f215
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/isa_head.py
@@ -0,0 +1,143 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+
+import torch
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+
+from mmseg.registry import MODELS
+from ..utils import SelfAttentionBlock as _SelfAttentionBlock
+from .decode_head import BaseDecodeHead
+
+
+class SelfAttentionBlock(_SelfAttentionBlock):
+    """Self-Attention Module.
+
+    Args:
+        in_channels (int): Input channels of key/query feature.
+        channels (int): Output channels of key/query transform.
+        conv_cfg (dict | None): Config of conv layers.
+        norm_cfg (dict | None): Config of norm layers.
+        act_cfg (dict | None): Config of activation layers.
+    """
+
+    def __init__(self, in_channels, channels, conv_cfg, norm_cfg, act_cfg):
+        super().__init__(
+            key_in_channels=in_channels,
+            query_in_channels=in_channels,
+            channels=channels,
+            out_channels=in_channels,
+            share_key_query=False,
+            query_downsample=None,
+            key_downsample=None,
+            key_query_num_convs=2,
+            key_query_norm=True,
+            value_out_num_convs=1,
+            value_out_norm=False,
+            matmul_norm=True,
+            with_out=False,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+
+        self.output_project = self.build_project(
+            in_channels,
+            in_channels,
+            num_convs=1,
+            use_conv_module=True,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+
+    def forward(self, x):
+        """Forward function."""
+        context = super().forward(x, x)
+        return self.output_project(context)
+
+
+@MODELS.register_module()
+class ISAHead(BaseDecodeHead):
+    """Interlaced Sparse Self-Attention for Semantic Segmentation.
+
+    This head is the implementation of `ISA
+    <https://arxiv.org/abs/1907.12273>`_.
+
+    Args:
+        isa_channels (int): The channels of ISA Module.
+        down_factor (tuple[int]): The local group size of ISA.
+    """
+
+    def __init__(self, isa_channels, down_factor=(8, 8), **kwargs):
+        super().__init__(**kwargs)
+        self.down_factor = down_factor
+
+        self.in_conv = ConvModule(
+            self.in_channels,
+            self.channels,
+            3,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+        self.global_relation = SelfAttentionBlock(
+            self.channels,
+            isa_channels,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+        self.local_relation = SelfAttentionBlock(
+            self.channels,
+            isa_channels,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+        self.out_conv = ConvModule(
+            self.channels * 2,
+            self.channels,
+            1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+    def forward(self, inputs):
+        """Forward function."""
+        x_ = self._transform_inputs(inputs)
+        x = self.in_conv(x_)
+        residual = x
+
+        n, c, h, w = x.size()
+        loc_h, loc_w = self.down_factor  # size of local group in H- and W-axes
+        glb_h, glb_w = math.ceil(h / loc_h), math.ceil(w / loc_w)
+        pad_h, pad_w = glb_h * loc_h - h, glb_w * loc_w - w
+        if pad_h > 0 or pad_w > 0:  # pad if the size is not divisible
+            padding = (pad_w // 2, pad_w - pad_w // 2, pad_h // 2,
+                       pad_h - pad_h // 2)
+            x = F.pad(x, padding)
+
+        # global relation
+        x = x.view(n, c, glb_h, loc_h, glb_w, loc_w)
+        # do permutation to gather global group
+        x = x.permute(0, 3, 5, 1, 2, 4)  # (n, loc_h, loc_w, c, glb_h, glb_w)
+        x = x.reshape(-1, c, glb_h, glb_w)
+        # apply attention within each global group
+        x = self.global_relation(x)  # (n * loc_h * loc_w, c, glb_h, glb_w)
+
+        # local relation
+        x = x.view(n, loc_h, loc_w, c, glb_h, glb_w)
+        # do permutation to gather local group
+        x = x.permute(0, 4, 5, 3, 1, 2)  # (n, glb_h, glb_w, c, loc_h, loc_w)
+        x = x.reshape(-1, c, loc_h, loc_w)
+        # apply attention within each local group
+        x = self.local_relation(x)  # (n * glb_h * glb_w, c, loc_h, loc_w)
+
+        # permute each pixel back to its original position
+        x = x.view(n, glb_h, glb_w, c, loc_h, loc_w)
+        x = x.permute(0, 3, 1, 4, 2, 5)  # (n, c, glb_h, loc_h, glb_w, loc_w)
+        x = x.reshape(n, c, glb_h * loc_h, glb_w * loc_w)
+        if pad_h > 0 or pad_w > 0:  # remove padding
+            x = x[:, :, pad_h // 2:pad_h // 2 + h, pad_w // 2:pad_w // 2 + w]
+
+        x = self.out_conv(torch.cat([x, residual], dim=1))
+        out = self.cls_seg(x)
+
+        return out
diff --git a/mmsegmentation/mmseg/models/decode_heads/knet_head.py b/mmsegmentation/mmseg/models/decode_heads/knet_head.py
new file mode 100644
index 0000000..82d3a28
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/knet_head.py
@@ -0,0 +1,461 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule, build_activation_layer, build_norm_layer
+from mmcv.cnn.bricks.transformer import (FFN, MultiheadAttention,
+                                         build_transformer_layer)
+from mmengine.logging import print_log
+from torch import Tensor
+
+from mmseg.models.decode_heads.decode_head import BaseDecodeHead
+from mmseg.registry import MODELS
+from mmseg.utils import SampleList
+
+
+@MODELS.register_module()
+class KernelUpdator(nn.Module):
+    """Dynamic Kernel Updator in Kernel Update Head.
+
+    Args:
+        in_channels (int): The number of channels of input feature map.
+            Default: 256.
+        feat_channels (int): The number of middle-stage channels in
+            the kernel updator. Default: 64.
+        out_channels (int): The number of output channels.
+        gate_sigmoid (bool): Whether use sigmoid function in gate
+            mechanism. Default: True.
+        gate_norm_act (bool): Whether add normalization and activation
+            layer in gate mechanism. Default: False.
+        activate_out: Whether add activation after gate mechanism.
+            Default: False.
+        norm_cfg (dict | None): Config of norm layers.
+            Default: dict(type='LN').
+        act_cfg (dict): Config of activation layers.
+            Default: dict(type='ReLU').
+    """
+
+    def __init__(
+            self,
+            in_channels=256,
+            feat_channels=64,
+            out_channels=None,
+            gate_sigmoid=True,
+            gate_norm_act=False,
+            activate_out=False,
+            norm_cfg=dict(type='LN'),
+            act_cfg=dict(type='ReLU', inplace=True),
+    ):
+        super().__init__()
+        self.in_channels = in_channels
+        self.feat_channels = feat_channels
+        self.out_channels_raw = out_channels
+        self.gate_sigmoid = gate_sigmoid
+        self.gate_norm_act = gate_norm_act
+        self.activate_out = activate_out
+        self.act_cfg = act_cfg
+        self.norm_cfg = norm_cfg
+        self.out_channels = out_channels if out_channels else in_channels
+
+        self.num_params_in = self.feat_channels
+        self.num_params_out = self.feat_channels
+        self.dynamic_layer = nn.Linear(
+            self.in_channels, self.num_params_in + self.num_params_out)
+        self.input_layer = nn.Linear(self.in_channels,
+                                     self.num_params_in + self.num_params_out,
+                                     1)
+        self.input_gate = nn.Linear(self.in_channels, self.feat_channels, 1)
+        self.update_gate = nn.Linear(self.in_channels, self.feat_channels, 1)
+        if self.gate_norm_act:
+            self.gate_norm = build_norm_layer(norm_cfg, self.feat_channels)[1]
+
+        self.norm_in = build_norm_layer(norm_cfg, self.feat_channels)[1]
+        self.norm_out = build_norm_layer(norm_cfg, self.feat_channels)[1]
+        self.input_norm_in = build_norm_layer(norm_cfg, self.feat_channels)[1]
+        self.input_norm_out = build_norm_layer(norm_cfg, self.feat_channels)[1]
+
+        self.activation = build_activation_layer(act_cfg)
+
+        self.fc_layer = nn.Linear(self.feat_channels, self.out_channels, 1)
+        self.fc_norm = build_norm_layer(norm_cfg, self.out_channels)[1]
+
+    def forward(self, update_feature, input_feature):
+        """Forward function of KernelUpdator.
+
+        Args:
+            update_feature (torch.Tensor): Feature map assembled from
+                each group. It would be reshaped with last dimension
+                shape: `self.in_channels`.
+            input_feature (torch.Tensor): Intermediate feature
+                with shape: (N, num_classes, conv_kernel_size**2, channels).
+        Returns:
+            Tensor: The output tensor of shape (N*C1/C2, K*K, C2), where N is
+            the number of classes, C1 and C2 are the feature map channels of
+            KernelUpdateHead and KernelUpdator, respectively.
+        """
+
+        update_feature = update_feature.reshape(-1, self.in_channels)
+        num_proposals = update_feature.size(0)
+        # dynamic_layer works for
+        # phi_1 and psi_3 in Eq.(4) and (5) of K-Net paper
+        parameters = self.dynamic_layer(update_feature)
+        param_in = parameters[:, :self.num_params_in].view(
+            -1, self.feat_channels)
+        param_out = parameters[:, -self.num_params_out:].view(
+            -1, self.feat_channels)
+
+        # input_layer works for
+        # phi_2 and psi_4 in Eq.(4) and (5) of K-Net paper
+        input_feats = self.input_layer(
+            input_feature.reshape(num_proposals, -1, self.feat_channels))
+        input_in = input_feats[..., :self.num_params_in]
+        input_out = input_feats[..., -self.num_params_out:]
+
+        # `gate_feats` is F^G in K-Net paper
+        gate_feats = input_in * param_in.unsqueeze(-2)
+        if self.gate_norm_act:
+            gate_feats = self.activation(self.gate_norm(gate_feats))
+
+        input_gate = self.input_norm_in(self.input_gate(gate_feats))
+        update_gate = self.norm_in(self.update_gate(gate_feats))
+        if self.gate_sigmoid:
+            input_gate = input_gate.sigmoid()
+            update_gate = update_gate.sigmoid()
+        param_out = self.norm_out(param_out)
+        input_out = self.input_norm_out(input_out)
+
+        if self.activate_out:
+            param_out = self.activation(param_out)
+            input_out = self.activation(input_out)
+
+        # Gate mechanism. Eq.(5) in original paper.
+        # param_out has shape (batch_size, feat_channels, out_channels)
+        features = update_gate * param_out.unsqueeze(
+            -2) + input_gate * input_out
+
+        features = self.fc_layer(features)
+        features = self.fc_norm(features)
+        features = self.activation(features)
+
+        return features
+
+
+@MODELS.register_module()
+class KernelUpdateHead(nn.Module):
+    """Kernel Update Head in K-Net.
+
+    Args:
+        num_classes (int): Number of classes. Default: 150.
+        num_ffn_fcs (int): The number of fully-connected layers in
+            FFNs. Default: 2.
+        num_heads (int): The number of parallel attention heads.
+            Default: 8.
+        num_mask_fcs (int): The number of fully connected layers for
+            mask prediction. Default: 3.
+        feedforward_channels (int): The hidden dimension of FFNs.
+            Defaults: 2048.
+        in_channels (int): The number of channels of input feature map.
+            Default: 256.
+        out_channels (int): The number of output channels.
+            Default: 256.
+        dropout (float): The Probability of an element to be
+            zeroed in MultiheadAttention and FFN. Default 0.0.
+        act_cfg (dict): Config of activation layers.
+            Default: dict(type='ReLU').
+        ffn_act_cfg (dict): Config of activation layers in FFN.
+            Default: dict(type='ReLU').
+        conv_kernel_size (int): The kernel size of convolution in
+            Kernel Update Head for dynamic kernel updation.
+            Default: 1.
+        feat_transform_cfg (dict | None): Config of feature transform.
+            Default: None.
+        kernel_init (bool): Whether initiate mask kernel in mask head.
+            Default: False.
+        with_ffn (bool): Whether add FFN in kernel update head.
+            Default: True.
+        feat_gather_stride (int): Stride of convolution in feature transform.
+            Default: 1.
+        mask_transform_stride (int): Stride of mask transform.
+            Default: 1.
+        kernel_updator_cfg (dict): Config of kernel updator.
+            Default: dict(
+                     type='DynamicConv',
+                     in_channels=256,
+                     feat_channels=64,
+                     out_channels=256,
+                     act_cfg=dict(type='ReLU', inplace=True),
+                     norm_cfg=dict(type='LN')).
+    """
+
+    def __init__(self,
+                 num_classes=150,
+                 num_ffn_fcs=2,
+                 num_heads=8,
+                 num_mask_fcs=3,
+                 feedforward_channels=2048,
+                 in_channels=256,
+                 out_channels=256,
+                 dropout=0.0,
+                 act_cfg=dict(type='ReLU', inplace=True),
+                 ffn_act_cfg=dict(type='ReLU', inplace=True),
+                 conv_kernel_size=1,
+                 feat_transform_cfg=None,
+                 kernel_init=False,
+                 with_ffn=True,
+                 feat_gather_stride=1,
+                 mask_transform_stride=1,
+                 kernel_updator_cfg=dict(
+                     type='DynamicConv',
+                     in_channels=256,
+                     feat_channels=64,
+                     out_channels=256,
+                     act_cfg=dict(type='ReLU', inplace=True),
+                     norm_cfg=dict(type='LN'))):
+        super().__init__()
+        self.num_classes = num_classes
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.fp16_enabled = False
+        self.dropout = dropout
+        self.num_heads = num_heads
+        self.kernel_init = kernel_init
+        self.with_ffn = with_ffn
+        self.conv_kernel_size = conv_kernel_size
+        self.feat_gather_stride = feat_gather_stride
+        self.mask_transform_stride = mask_transform_stride
+
+        self.attention = MultiheadAttention(in_channels * conv_kernel_size**2,
+                                            num_heads, dropout)
+        self.attention_norm = build_norm_layer(
+            dict(type='LN'), in_channels * conv_kernel_size**2)[1]
+        self.kernel_update_conv = build_transformer_layer(kernel_updator_cfg)
+
+        if feat_transform_cfg is not None:
+            kernel_size = feat_transform_cfg.pop('kernel_size', 1)
+            transform_channels = in_channels
+            self.feat_transform = ConvModule(
+                transform_channels,
+                in_channels,
+                kernel_size,
+                stride=feat_gather_stride,
+                padding=int(feat_gather_stride // 2),
+                **feat_transform_cfg)
+        else:
+            self.feat_transform = None
+
+        if self.with_ffn:
+            self.ffn = FFN(
+                in_channels,
+                feedforward_channels,
+                num_ffn_fcs,
+                act_cfg=ffn_act_cfg,
+                dropout=dropout)
+            self.ffn_norm = build_norm_layer(dict(type='LN'), in_channels)[1]
+
+        self.mask_fcs = nn.ModuleList()
+        for _ in range(num_mask_fcs):
+            self.mask_fcs.append(
+                nn.Linear(in_channels, in_channels, bias=False))
+            self.mask_fcs.append(
+                build_norm_layer(dict(type='LN'), in_channels)[1])
+            self.mask_fcs.append(build_activation_layer(act_cfg))
+
+        self.fc_mask = nn.Linear(in_channels, out_channels)
+
+    def init_weights(self):
+        """Use xavier initialization for all weight parameter and set
+        classification head bias as a specific value when use focal loss."""
+        for p in self.parameters():
+            if p.dim() > 1:
+                nn.init.xavier_uniform_(p)
+            else:
+                # adopt the default initialization for
+                # the weight and bias of the layer norm
+                pass
+        if self.kernel_init:
+            print_log(
+                'mask kernel in mask head is normal initialized by std 0.01')
+            nn.init.normal_(self.fc_mask.weight, mean=0, std=0.01)
+
+    def forward(self, x, proposal_feat, mask_preds, mask_shape=None):
+        """Forward function of Dynamic Instance Interactive Head.
+
+        Args:
+            x (Tensor): Feature map from FPN with shape
+                (batch_size, feature_dimensions, H , W).
+            proposal_feat (Tensor): Intermediate feature get from
+                diihead in last stage, has shape
+                (batch_size, num_proposals, feature_dimensions)
+            mask_preds (Tensor): mask prediction from the former stage in shape
+                (batch_size, num_proposals, H, W).
+
+        Returns:
+            Tuple: The first tensor is predicted mask with shape
+            (N, num_classes, H, W), the second tensor is dynamic kernel
+            with shape (N, num_classes, channels, K, K).
+        """
+        N, num_proposals = proposal_feat.shape[:2]
+        if self.feat_transform is not None:
+            x = self.feat_transform(x)
+
+        C, H, W = x.shape[-3:]
+
+        mask_h, mask_w = mask_preds.shape[-2:]
+        if mask_h != H or mask_w != W:
+            gather_mask = F.interpolate(
+                mask_preds, (H, W), align_corners=False, mode='bilinear')
+        else:
+            gather_mask = mask_preds
+
+        sigmoid_masks = gather_mask.softmax(dim=1)
+
+        # Group Feature Assembling. Eq.(3) in original paper.
+        # einsum is faster than bmm by 30%
+        x_feat = torch.einsum('bnhw,bchw->bnc', sigmoid_masks, x)
+
+        # obj_feat in shape [B, N, C, K, K] -> [B, N, C, K*K] -> [B, N, K*K, C]
+        proposal_feat = proposal_feat.reshape(N, num_proposals,
+                                              self.in_channels,
+                                              -1).permute(0, 1, 3, 2)
+        obj_feat = self.kernel_update_conv(x_feat, proposal_feat)
+
+        # [B, N, K*K, C] -> [B, N, K*K*C] -> [N, B, K*K*C]
+        obj_feat = obj_feat.reshape(N, num_proposals, -1).permute(1, 0, 2)
+        obj_feat = self.attention_norm(self.attention(obj_feat))
+        # [N, B, K*K*C] -> [B, N, K*K*C]
+        obj_feat = obj_feat.permute(1, 0, 2)
+
+        # obj_feat in shape [B, N, K*K*C] -> [B, N, K*K, C]
+        obj_feat = obj_feat.reshape(N, num_proposals, -1, self.in_channels)
+
+        # FFN
+        if self.with_ffn:
+            obj_feat = self.ffn_norm(self.ffn(obj_feat))
+
+        mask_feat = obj_feat
+
+        for reg_layer in self.mask_fcs:
+            mask_feat = reg_layer(mask_feat)
+
+        # [B, N, K*K, C] -> [B, N, C, K*K]
+        mask_feat = self.fc_mask(mask_feat).permute(0, 1, 3, 2)
+
+        if (self.mask_transform_stride == 2 and self.feat_gather_stride == 1):
+            mask_x = F.interpolate(
+                x, scale_factor=0.5, mode='bilinear', align_corners=False)
+            H, W = mask_x.shape[-2:]
+        else:
+            mask_x = x
+        # group conv is 5x faster than unfold and uses about 1/5 memory
+        # Group conv vs. unfold vs. concat batch, 2.9ms :13.5ms :3.8ms
+        # Group conv vs. unfold vs. concat batch, 278 : 1420 : 369
+        # but in real training group conv is slower than concat batch
+        # so we keep using concat batch.
+        # fold_x = F.unfold(
+        #     mask_x,
+        #     self.conv_kernel_size,
+        #     padding=int(self.conv_kernel_size // 2))
+        # mask_feat = mask_feat.reshape(N, num_proposals, -1)
+        # new_mask_preds = torch.einsum('bnc,bcl->bnl', mask_feat, fold_x)
+        # [B, N, C, K*K] -> [B*N, C, K, K]
+        mask_feat = mask_feat.reshape(N, num_proposals, C,
+                                      self.conv_kernel_size,
+                                      self.conv_kernel_size)
+        # [B, C, H, W] -> [1, B*C, H, W]
+        new_mask_preds = []
+        for i in range(N):
+            new_mask_preds.append(
+                F.conv2d(
+                    mask_x[i:i + 1],
+                    mask_feat[i],
+                    padding=int(self.conv_kernel_size // 2)))
+
+        new_mask_preds = torch.cat(new_mask_preds, dim=0)
+        new_mask_preds = new_mask_preds.reshape(N, num_proposals, H, W)
+        if self.mask_transform_stride == 2:
+            new_mask_preds = F.interpolate(
+                new_mask_preds,
+                scale_factor=2,
+                mode='bilinear',
+                align_corners=False)
+
+        if mask_shape is not None and mask_shape[0] != H:
+            new_mask_preds = F.interpolate(
+                new_mask_preds,
+                mask_shape,
+                align_corners=False,
+                mode='bilinear')
+
+        return new_mask_preds, obj_feat.permute(0, 1, 3, 2).reshape(
+            N, num_proposals, self.in_channels, self.conv_kernel_size,
+            self.conv_kernel_size)
+
+
+@MODELS.register_module()
+class IterativeDecodeHead(BaseDecodeHead):
+    """K-Net: Towards Unified Image Segmentation.
+
+    This head is the implementation of
+    `K-Net:　<https://arxiv.org/abs/2106.14855>`_.
+
+    Args:
+        num_stages (int): The number of stages (kernel update heads)
+            in IterativeDecodeHead. Default: 3.
+        kernel_generate_head:(dict): Config of kernel generate head which
+            generate mask predictions, dynamic kernels and class predictions
+            for next kernel update heads.
+        kernel_update_head (dict): Config of kernel update head which refine
+            dynamic kernels and class predictions iteratively.
+
+    """
+
+    def __init__(self, num_stages, kernel_generate_head, kernel_update_head,
+                 **kwargs):
+        # ``IterativeDecodeHead`` would skip initialization of
+        # ``BaseDecodeHead`` which would be called when building
+        # ``self.kernel_generate_head``.
+        super(BaseDecodeHead, self).__init__(**kwargs)
+        assert num_stages == len(kernel_update_head)
+        self.num_stages = num_stages
+        self.kernel_generate_head = MODELS.build(kernel_generate_head)
+        self.kernel_update_head = nn.ModuleList()
+        self.align_corners = self.kernel_generate_head.align_corners
+        self.num_classes = self.kernel_generate_head.num_classes
+        self.input_transform = self.kernel_generate_head.input_transform
+        self.ignore_index = self.kernel_generate_head.ignore_index
+        self.out_channels = self.num_classes
+
+        for head_cfg in kernel_update_head:
+            self.kernel_update_head.append(MODELS.build(head_cfg))
+
+    def forward(self, inputs):
+        """Forward function."""
+        feats = self.kernel_generate_head._forward_feature(inputs)
+        sem_seg = self.kernel_generate_head.cls_seg(feats)
+        seg_kernels = self.kernel_generate_head.conv_seg.weight.clone()
+        seg_kernels = seg_kernels[None].expand(
+            feats.size(0), *seg_kernels.size())
+
+        stage_segs = [sem_seg]
+        for i in range(self.num_stages):
+            sem_seg, seg_kernels = self.kernel_update_head[i](feats,
+                                                              seg_kernels,
+                                                              sem_seg)
+            stage_segs.append(sem_seg)
+        if self.training:
+            return stage_segs
+        # only return the prediction of the last stage during testing
+        return stage_segs[-1]
+
+    def loss_by_feat(self, seg_logits: List[Tensor],
+                     batch_data_samples: SampleList, **kwargs) -> dict:
+        losses = dict()
+        for i, logit in enumerate(seg_logits):
+            loss = self.kernel_generate_head.loss_by_feat(
+                logit, batch_data_samples)
+            for k, v in loss.items():
+                losses[f'{k}.s{i}'] = v
+
+        return losses
diff --git a/mmsegmentation/mmseg/models/decode_heads/lraspp_head.py b/mmsegmentation/mmseg/models/decode_heads/lraspp_head.py
new file mode 100644
index 0000000..ba2465f
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/lraspp_head.py
@@ -0,0 +1,91 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmengine.utils import is_tuple_of
+
+from mmseg.registry import MODELS
+from ..utils import resize
+from .decode_head import BaseDecodeHead
+
+
+@MODELS.register_module()
+class LRASPPHead(BaseDecodeHead):
+    """Lite R-ASPP (LRASPP) head is proposed in Searching for MobileNetV3.
+
+    This head is the improved implementation of `Searching for MobileNetV3
+    <https://ieeexplore.ieee.org/document/9008835>`_.
+
+    Args:
+        branch_channels (tuple[int]): The number of output channels in every
+            each branch. Default: (32, 64).
+    """
+
+    def __init__(self, branch_channels=(32, 64), **kwargs):
+        super().__init__(**kwargs)
+        if self.input_transform != 'multiple_select':
+            raise ValueError('in Lite R-ASPP (LRASPP) head, input_transform '
+                             f'must be \'multiple_select\'. But received '
+                             f'\'{self.input_transform}\'')
+        assert is_tuple_of(branch_channels, int)
+        assert len(branch_channels) == len(self.in_channels) - 1
+        self.branch_channels = branch_channels
+
+        self.convs = nn.Sequential()
+        self.conv_ups = nn.Sequential()
+        for i in range(len(branch_channels)):
+            self.convs.add_module(
+                f'conv{i}',
+                nn.Conv2d(
+                    self.in_channels[i], branch_channels[i], 1, bias=False))
+            self.conv_ups.add_module(
+                f'conv_up{i}',
+                ConvModule(
+                    self.channels + branch_channels[i],
+                    self.channels,
+                    1,
+                    norm_cfg=self.norm_cfg,
+                    act_cfg=self.act_cfg,
+                    bias=False))
+
+        self.conv_up_input = nn.Conv2d(self.channels, self.channels, 1)
+
+        self.aspp_conv = ConvModule(
+            self.in_channels[-1],
+            self.channels,
+            1,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg,
+            bias=False)
+        self.image_pool = nn.Sequential(
+            nn.AvgPool2d(kernel_size=49, stride=(16, 20)),
+            ConvModule(
+                self.in_channels[2],
+                self.channels,
+                1,
+                act_cfg=dict(type='Sigmoid'),
+                bias=False))
+
+    def forward(self, inputs):
+        """Forward function."""
+        inputs = self._transform_inputs(inputs)
+
+        x = inputs[-1]
+
+        x = self.aspp_conv(x) * resize(
+            self.image_pool(x),
+            size=x.size()[2:],
+            mode='bilinear',
+            align_corners=self.align_corners)
+        x = self.conv_up_input(x)
+
+        for i in range(len(self.branch_channels) - 1, -1, -1):
+            x = resize(
+                x,
+                size=inputs[i].size()[2:],
+                mode='bilinear',
+                align_corners=self.align_corners)
+            x = torch.cat([x, self.convs[i](inputs[i])], 1)
+            x = self.conv_ups[i](x)
+
+        return self.cls_seg(x)
diff --git a/mmsegmentation/mmseg/models/decode_heads/mask2former_head.py b/mmsegmentation/mmseg/models/decode_heads/mask2former_head.py
new file mode 100644
index 0000000..0135af0
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/mask2former_head.py
@@ -0,0 +1,163 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmengine.model import BaseModule
+
+try:
+    from mmdet.models.dense_heads import \
+        Mask2FormerHead as MMDET_Mask2FormerHead
+except ModuleNotFoundError:
+    MMDET_Mask2FormerHead = BaseModule
+
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmseg.registry import MODELS
+from mmseg.structures.seg_data_sample import SegDataSample
+from mmseg.utils import ConfigType, SampleList
+
+
+@MODELS.register_module()
+class Mask2FormerHead(MMDET_Mask2FormerHead):
+    """Implements the Mask2Former head.
+
+    See `Mask2Former: Masked-attention Mask Transformer for Universal Image
+    Segmentation <https://arxiv.org/abs/2112.01527>`_ for details.
+
+    Args:
+        num_classes (int): Number of classes. Default: 150.
+        align_corners (bool): align_corners argument of F.interpolate.
+            Default: False.
+        ignore_index (int): The label index to be ignored. Default: 255.
+    """
+
+    def __init__(self,
+                 num_classes,
+                 align_corners=False,
+                 ignore_index=255,
+                 **kwargs):
+        super().__init__(**kwargs)
+
+        self.num_classes = num_classes
+        self.align_corners = align_corners
+        self.out_channels = num_classes
+        self.ignore_index = ignore_index
+
+        feat_channels = kwargs['feat_channels']
+        self.cls_embed = nn.Linear(feat_channels, self.num_classes + 1)
+
+    def _seg_data_to_instance_data(self, batch_data_samples: SampleList):
+        """Perform forward propagation to convert paradigm from MMSegmentation
+        to MMDetection to ensure ``MMDET_Mask2FormerHead`` could be called
+        normally. Specifically, ``batch_gt_instances`` would be added.
+
+        Args:
+            batch_data_samples (List[:obj:`SegDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_sem_seg`.
+
+        Returns:
+            tuple[Tensor]: A tuple contains two lists.
+
+                - batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                    gt_instance. It usually includes ``labels``, each is
+                    unique ground truth label id of images, with
+                    shape (num_gt, ) and ``masks``, each is ground truth
+                    masks of each instances of a image, shape (num_gt, h, w).
+                - batch_img_metas (list[dict]): List of image meta information.
+        """
+        batch_img_metas = []
+        batch_gt_instances = []
+
+        for data_sample in batch_data_samples:
+            batch_img_metas.append(data_sample.metainfo)
+            gt_sem_seg = data_sample.gt_sem_seg.data
+            classes = torch.unique(
+                gt_sem_seg,
+                sorted=False,
+                return_inverse=False,
+                return_counts=False)
+
+            # remove ignored region
+            gt_labels = classes[classes != self.ignore_index]
+
+            masks = []
+            for class_id in gt_labels:
+                masks.append(gt_sem_seg == class_id)
+
+            if len(masks) == 0:
+                gt_masks = torch.zeros(
+                    (0, gt_sem_seg.shape[-2],
+                     gt_sem_seg.shape[-1])).to(gt_sem_seg).long()
+            else:
+                gt_masks = torch.stack(masks).squeeze(1).long()
+
+            instance_data = InstanceData(labels=gt_labels, masks=gt_masks)
+            batch_gt_instances.append(instance_data)
+        return batch_gt_instances, batch_img_metas
+
+    def loss(self, x: Tuple[Tensor], batch_data_samples: SampleList,
+             train_cfg: ConfigType) -> dict:
+        """Perform forward propagation and loss calculation of the decoder head
+        on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Multi-level features from the upstream
+                network, each is a 4D-tensor.
+            batch_data_samples (List[:obj:`SegDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_sem_seg`.
+            train_cfg (ConfigType): Training config.
+
+        Returns:
+            dict[str, Tensor]: a dictionary of loss components.
+        """
+        # batch SegDataSample to InstanceDataSample
+        batch_gt_instances, batch_img_metas = self._seg_data_to_instance_data(
+            batch_data_samples)
+
+        # forward
+        all_cls_scores, all_mask_preds = self(x, batch_data_samples)
+
+        # loss
+        losses = self.loss_by_feat(all_cls_scores, all_mask_preds,
+                                   batch_gt_instances, batch_img_metas)
+
+        return losses
+
+    def predict(self, x: Tuple[Tensor], batch_img_metas: List[dict],
+                test_cfg: ConfigType) -> Tuple[Tensor]:
+        """Test without augmentaton.
+
+        Args:
+            x (tuple[Tensor]): Multi-level features from the
+                upstream network, each is a 4D-tensor.
+            batch_img_metas (List[:obj:`SegDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_sem_seg`.
+            test_cfg (ConfigType): Test config.
+
+        Returns:
+            Tensor: A tensor of segmentation mask.
+        """
+        batch_data_samples = [
+            SegDataSample(metainfo=metainfo) for metainfo in batch_img_metas
+        ]
+
+        all_cls_scores, all_mask_preds = self(x, batch_data_samples)
+        mask_cls_results = all_cls_scores[-1]
+        mask_pred_results = all_mask_preds[-1]
+        if 'pad_shape' in batch_img_metas[0]:
+            size = batch_img_metas[0]['pad_shape']
+        else:
+            size = batch_img_metas[0]['img_shape']
+        # upsample mask
+        mask_pred_results = F.interpolate(
+            mask_pred_results, size=size, mode='bilinear', align_corners=False)
+        cls_score = F.softmax(mask_cls_results, dim=-1)[..., :-1]
+        mask_pred = mask_pred_results.sigmoid()
+        seg_logits = torch.einsum('bqc, bqhw->bchw', cls_score, mask_pred)
+        return seg_logits
diff --git a/mmsegmentation/mmseg/models/decode_heads/maskformer_head.py b/mmsegmentation/mmseg/models/decode_heads/maskformer_head.py
new file mode 100644
index 0000000..6e61a7f
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/maskformer_head.py
@@ -0,0 +1,174 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmengine.model import BaseModule
+
+try:
+    from mmdet.models.dense_heads import MaskFormerHead as MMDET_MaskFormerHead
+except ModuleNotFoundError:
+    MMDET_MaskFormerHead = BaseModule
+
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmseg.registry import MODELS
+from mmseg.structures.seg_data_sample import SegDataSample
+from mmseg.utils import ConfigType, SampleList
+
+
+@MODELS.register_module()
+class MaskFormerHead(MMDET_MaskFormerHead):
+    """Implements the MaskFormer head.
+
+    See `Per-Pixel Classification is Not All You Need for Semantic Segmentation
+    <https://arxiv.org/pdf/2107.06278>`_ for details.
+
+    Args:
+        num_classes (int): Number of classes. Default: 150.
+        align_corners (bool): align_corners argument of F.interpolate.
+            Default: False.
+        ignore_index (int): The label index to be ignored. Default: 255.
+    """
+
+    def __init__(self,
+                 num_classes: int = 150,
+                 align_corners: bool = False,
+                 ignore_index: int = 255,
+                 **kwargs) -> None:
+        super().__init__(**kwargs)
+
+        self.out_channels = kwargs['out_channels']
+        self.align_corners = True
+        self.num_classes = num_classes
+        self.align_corners = align_corners
+        self.out_channels = num_classes
+        self.ignore_index = ignore_index
+
+        feat_channels = kwargs['feat_channels']
+        self.cls_embed = nn.Linear(feat_channels, self.num_classes + 1)
+
+    def _seg_data_to_instance_data(self, batch_data_samples: SampleList):
+        """Perform forward propagation to convert paradigm from MMSegmentation
+        to MMDetection to ensure ``MMDET_MaskFormerHead`` could be called
+        normally. Specifically, ``batch_gt_instances`` would be added.
+
+        Args:
+            batch_data_samples (List[:obj:`SegDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_sem_seg`.
+
+        Returns:
+            tuple[Tensor]: A tuple contains two lists.
+
+                - batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                    gt_instance. It usually includes ``labels``, each is
+                    unique ground truth label id of images, with
+                    shape (num_gt, ) and ``masks``, each is ground truth
+                    masks of each instances of a image, shape (num_gt, h, w).
+                - batch_img_metas (list[dict]): List of image meta information.
+        """
+        batch_img_metas = []
+        batch_gt_instances = []
+        for data_sample in batch_data_samples:
+            # Add `batch_input_shape` in metainfo of data_sample, which would
+            # be used in MaskFormerHead of MMDetection.
+            metainfo = data_sample.metainfo
+            metainfo['batch_input_shape'] = metainfo['img_shape']
+            data_sample.set_metainfo(metainfo)
+            batch_img_metas.append(data_sample.metainfo)
+            gt_sem_seg = data_sample.gt_sem_seg.data
+            classes = torch.unique(
+                gt_sem_seg,
+                sorted=False,
+                return_inverse=False,
+                return_counts=False)
+
+            # remove ignored region
+            gt_labels = classes[classes != self.ignore_index]
+
+            masks = []
+            for class_id in gt_labels:
+                masks.append(gt_sem_seg == class_id)
+
+            if len(masks) == 0:
+                gt_masks = torch.zeros((0, gt_sem_seg.shape[-2],
+                                        gt_sem_seg.shape[-1])).to(gt_sem_seg)
+            else:
+                gt_masks = torch.stack(masks).squeeze(1)
+
+            instance_data = InstanceData(
+                labels=gt_labels, masks=gt_masks.long())
+            batch_gt_instances.append(instance_data)
+        return batch_gt_instances, batch_img_metas
+
+    def loss(self, x: Tuple[Tensor], batch_data_samples: SampleList,
+             train_cfg: ConfigType) -> dict:
+        """Perform forward propagation and loss calculation of the decoder head
+        on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Multi-level features from the upstream
+                network, each is a 4D-tensor.
+            batch_data_samples (List[:obj:`SegDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_sem_seg`.
+            train_cfg (ConfigType): Training config.
+
+        Returns:
+            dict[str, Tensor]: a dictionary of loss components.
+        """
+        # batch SegDataSample to InstanceDataSample
+        batch_gt_instances, batch_img_metas = self._seg_data_to_instance_data(
+            batch_data_samples)
+
+        # forward
+        all_cls_scores, all_mask_preds = self(x, batch_data_samples)
+
+        # loss
+        losses = self.loss_by_feat(all_cls_scores, all_mask_preds,
+                                   batch_gt_instances, batch_img_metas)
+
+        return losses
+
+    def predict(self, x: Tuple[Tensor], batch_img_metas: List[dict],
+                test_cfg: ConfigType) -> Tuple[Tensor]:
+        """Test without augmentaton.
+
+        Args:
+            x (tuple[Tensor]): Multi-level features from the
+                upstream network, each is a 4D-tensor.
+            batch_img_metas (List[:obj:`SegDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_sem_seg`.
+            test_cfg (ConfigType): Test config.
+
+        Returns:
+            Tensor: A tensor of segmentation mask.
+        """
+
+        batch_data_samples = []
+        for metainfo in batch_img_metas:
+            metainfo['batch_input_shape'] = metainfo['img_shape']
+            batch_data_samples.append(SegDataSample(metainfo=metainfo))
+        # Forward function of MaskFormerHead from MMDetection needs
+        # 'batch_data_samples' as inputs, which is image shape　actually.
+        all_cls_scores, all_mask_preds = self(x, batch_data_samples)
+        mask_cls_results = all_cls_scores[-1]
+        mask_pred_results = all_mask_preds[-1]
+
+        # upsample masks
+        img_shape = batch_img_metas[0]['batch_input_shape']
+        mask_pred_results = F.interpolate(
+            mask_pred_results,
+            size=img_shape,
+            mode='bilinear',
+            align_corners=False)
+
+        # semantic inference
+        cls_score = F.softmax(mask_cls_results, dim=-1)[..., :-1]
+        mask_pred = mask_pred_results.sigmoid()
+        seg_logits = torch.einsum('bqc,bqhw->bchw', cls_score, mask_pred)
+        return seg_logits
diff --git a/mmsegmentation/mmseg/models/decode_heads/nl_head.py b/mmsegmentation/mmseg/models/decode_heads/nl_head.py
new file mode 100644
index 0000000..0ffcc2a
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/nl_head.py
@@ -0,0 +1,50 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from mmcv.cnn import NonLocal2d
+
+from mmseg.registry import MODELS
+from .fcn_head import FCNHead
+
+
+@MODELS.register_module()
+class NLHead(FCNHead):
+    """Non-local Neural Networks.
+
+    This head is the implementation of `NLNet
+    <https://arxiv.org/abs/1711.07971>`_.
+
+    Args:
+        reduction (int): Reduction factor of projection transform. Default: 2.
+        use_scale (bool): Whether to scale pairwise_weight by
+            sqrt(1/inter_channels). Default: True.
+        mode (str): The nonlocal mode. Options are 'embedded_gaussian',
+            'dot_product'. Default: 'embedded_gaussian.'.
+    """
+
+    def __init__(self,
+                 reduction=2,
+                 use_scale=True,
+                 mode='embedded_gaussian',
+                 **kwargs):
+        super().__init__(num_convs=2, **kwargs)
+        self.reduction = reduction
+        self.use_scale = use_scale
+        self.mode = mode
+        self.nl_block = NonLocal2d(
+            in_channels=self.channels,
+            reduction=self.reduction,
+            use_scale=self.use_scale,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            mode=self.mode)
+
+    def forward(self, inputs):
+        """Forward function."""
+        x = self._transform_inputs(inputs)
+        output = self.convs[0](x)
+        output = self.nl_block(output)
+        output = self.convs[1](output)
+        if self.concat_input:
+            output = self.conv_cat(torch.cat([x, output], dim=1))
+        output = self.cls_seg(output)
+        return output
diff --git a/mmsegmentation/mmseg/models/decode_heads/ocr_head.py b/mmsegmentation/mmseg/models/decode_heads/ocr_head.py
new file mode 100644
index 0000000..9afe37b
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/ocr_head.py
@@ -0,0 +1,127 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+
+from mmseg.registry import MODELS
+from ..utils import SelfAttentionBlock as _SelfAttentionBlock
+from ..utils import resize
+from .cascade_decode_head import BaseCascadeDecodeHead
+
+
+class SpatialGatherModule(nn.Module):
+    """Aggregate the context features according to the initial predicted
+    probability distribution.
+
+    Employ the soft-weighted method to aggregate the context.
+    """
+
+    def __init__(self, scale):
+        super().__init__()
+        self.scale = scale
+
+    def forward(self, feats, probs):
+        """Forward function."""
+        batch_size, num_classes, height, width = probs.size()
+        channels = feats.size(1)
+        probs = probs.view(batch_size, num_classes, -1)
+        feats = feats.view(batch_size, channels, -1)
+        # [batch_size, height*width, num_classes]
+        feats = feats.permute(0, 2, 1)
+        # [batch_size, channels, height*width]
+        probs = F.softmax(self.scale * probs, dim=2)
+        # [batch_size, channels, num_classes]
+        ocr_context = torch.matmul(probs, feats)
+        ocr_context = ocr_context.permute(0, 2, 1).contiguous().unsqueeze(3)
+        return ocr_context
+
+
+class ObjectAttentionBlock(_SelfAttentionBlock):
+    """Make a OCR used SelfAttentionBlock."""
+
+    def __init__(self, in_channels, channels, scale, conv_cfg, norm_cfg,
+                 act_cfg):
+        if scale > 1:
+            query_downsample = nn.MaxPool2d(kernel_size=scale)
+        else:
+            query_downsample = None
+        super().__init__(
+            key_in_channels=in_channels,
+            query_in_channels=in_channels,
+            channels=channels,
+            out_channels=in_channels,
+            share_key_query=False,
+            query_downsample=query_downsample,
+            key_downsample=None,
+            key_query_num_convs=2,
+            key_query_norm=True,
+            value_out_num_convs=1,
+            value_out_norm=True,
+            matmul_norm=True,
+            with_out=True,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        self.bottleneck = ConvModule(
+            in_channels * 2,
+            in_channels,
+            1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+    def forward(self, query_feats, key_feats):
+        """Forward function."""
+        context = super().forward(query_feats, key_feats)
+        output = self.bottleneck(torch.cat([context, query_feats], dim=1))
+        if self.query_downsample is not None:
+            output = resize(query_feats)
+
+        return output
+
+
+@MODELS.register_module()
+class OCRHead(BaseCascadeDecodeHead):
+    """Object-Contextual Representations for Semantic Segmentation.
+
+    This head is the implementation of `OCRNet
+    <https://arxiv.org/abs/1909.11065>`_.
+
+    Args:
+        ocr_channels (int): The intermediate channels of OCR block.
+        scale (int): The scale of probability map in SpatialGatherModule in
+            Default: 1.
+    """
+
+    def __init__(self, ocr_channels, scale=1, **kwargs):
+        super().__init__(**kwargs)
+        self.ocr_channels = ocr_channels
+        self.scale = scale
+        self.object_context_block = ObjectAttentionBlock(
+            self.channels,
+            self.ocr_channels,
+            self.scale,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+        self.spatial_gather_module = SpatialGatherModule(self.scale)
+
+        self.bottleneck = ConvModule(
+            self.in_channels,
+            self.channels,
+            3,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+    def forward(self, inputs, prev_output):
+        """Forward function."""
+        x = self._transform_inputs(inputs)
+        feats = self.bottleneck(x)
+        context = self.spatial_gather_module(feats, prev_output)
+        object_context = self.object_context_block(feats, context)
+        output = self.cls_seg(object_context)
+
+        return output
diff --git a/mmsegmentation/mmseg/models/decode_heads/pid_head.py b/mmsegmentation/mmseg/models/decode_heads/pid_head.py
new file mode 100644
index 0000000..c092cb3
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/pid_head.py
@@ -0,0 +1,183 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule, build_activation_layer, build_norm_layer
+from mmengine.model import BaseModule
+from torch import Tensor
+
+from mmseg.models.decode_heads.decode_head import BaseDecodeHead
+from mmseg.models.losses import accuracy
+from mmseg.models.utils import resize
+from mmseg.registry import MODELS
+from mmseg.utils import OptConfigType, SampleList
+
+
+class BasePIDHead(BaseModule):
+    """Base class for PID head.
+
+    Args:
+        in_channels (int): Number of input channels.
+        channels (int): Number of output channels.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN').
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='ReLU', inplace=True).
+        init_cfg (dict or list[dict], optional): Init config dict.
+            Default: None.
+    """
+
+    def __init__(self,
+                 in_channels: int,
+                 channels: int,
+                 norm_cfg: OptConfigType = dict(type='BN'),
+                 act_cfg: OptConfigType = dict(type='ReLU', inplace=True),
+                 init_cfg: OptConfigType = None):
+        super().__init__(init_cfg)
+        self.conv = ConvModule(
+            in_channels,
+            channels,
+            kernel_size=3,
+            padding=1,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg,
+            order=('norm', 'act', 'conv'))
+        _, self.norm = build_norm_layer(norm_cfg, num_features=channels)
+        self.act = build_activation_layer(act_cfg)
+
+    def forward(self, x: Tensor, cls_seg: Optional[nn.Module]) -> Tensor:
+        """Forward function.
+        Args:
+            x (Tensor): Input tensor.
+            cls_seg (nn.Module, optional): The classification head.
+
+        Returns:
+            Tensor: Output tensor.
+        """
+        x = self.conv(x)
+        x = self.norm(x)
+        x = self.act(x)
+        if cls_seg is not None:
+            x = cls_seg(x)
+        return x
+
+
+@MODELS.register_module()
+class PIDHead(BaseDecodeHead):
+    """Decode head for PIDNet.
+
+    Args:
+        in_channels (int): Number of input channels.
+        channels (int): Number of output channels.
+        num_classes (int): Number of classes.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN').
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='ReLU', inplace=True).
+    """
+
+    def __init__(self,
+                 in_channels: int,
+                 channels: int,
+                 num_classes: int,
+                 norm_cfg: OptConfigType = dict(type='BN'),
+                 act_cfg: OptConfigType = dict(type='ReLU', inplace=True),
+                 **kwargs):
+        super().__init__(
+            in_channels,
+            channels,
+            num_classes=num_classes,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg,
+            **kwargs)
+        self.i_head = BasePIDHead(in_channels, channels, norm_cfg, act_cfg)
+        self.p_head = BasePIDHead(in_channels // 2, channels, norm_cfg,
+                                  act_cfg)
+        self.d_head = BasePIDHead(
+            in_channels // 2,
+            in_channels // 4,
+            norm_cfg,
+        )
+        self.p_cls_seg = nn.Conv2d(channels, self.out_channels, kernel_size=1)
+        self.d_cls_seg = nn.Conv2d(in_channels // 4, 1, kernel_size=1)
+
+    def init_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(
+                    m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+    def forward(
+            self,
+            inputs: Union[Tensor,
+                          Tuple[Tensor]]) -> Union[Tensor, Tuple[Tensor]]:
+        """Forward function.
+        Args:
+            inputs (Tensor | tuple[Tensor]): Input tensor or tuple of
+                Tensor. When training, the input is a tuple of three tensors,
+                (p_feat, i_feat, d_feat), and the output is a tuple of three
+                tensors, (p_seg_logit, i_seg_logit, d_seg_logit).
+                When inference, only the head of integral branch is used, and
+                input is a tensor of integral feature map, and the output is
+                the segmentation logit.
+
+        Returns:
+            Tensor | tuple[Tensor]: Output tensor or tuple of tensors.
+        """
+        if self.training:
+            x_p, x_i, x_d = inputs
+            x_p = self.p_head(x_p, self.p_cls_seg)
+            x_i = self.i_head(x_i, self.cls_seg)
+            x_d = self.d_head(x_d, self.d_cls_seg)
+            return x_p, x_i, x_d
+        else:
+            return self.i_head(inputs, self.cls_seg)
+
+    def _stack_batch_gt(self, batch_data_samples: SampleList) -> Tuple[Tensor]:
+        gt_semantic_segs = [
+            data_sample.gt_sem_seg.data for data_sample in batch_data_samples
+        ]
+        gt_edge_segs = [
+            data_sample.gt_edge_map.data for data_sample in batch_data_samples
+        ]
+        gt_sem_segs = torch.stack(gt_semantic_segs, dim=0)
+        gt_edge_segs = torch.stack(gt_edge_segs, dim=0)
+        return gt_sem_segs, gt_edge_segs
+
+    def loss_by_feat(self, seg_logits: Tuple[Tensor],
+                     batch_data_samples: SampleList) -> dict:
+        loss = dict()
+        p_logit, i_logit, d_logit = seg_logits
+        sem_label, bd_label = self._stack_batch_gt(batch_data_samples)
+        p_logit = resize(
+            input=p_logit,
+            size=sem_label.shape[2:],
+            mode='bilinear',
+            align_corners=self.align_corners)
+        i_logit = resize(
+            input=i_logit,
+            size=sem_label.shape[2:],
+            mode='bilinear',
+            align_corners=self.align_corners)
+        d_logit = resize(
+            input=d_logit,
+            size=bd_label.shape[2:],
+            mode='bilinear',
+            align_corners=self.align_corners)
+        sem_label = sem_label.squeeze(1)
+        bd_label = bd_label.squeeze(1)
+        loss['loss_sem_p'] = self.loss_decode[0](
+            p_logit, sem_label, ignore_index=self.ignore_index)
+        loss['loss_sem_i'] = self.loss_decode[1](i_logit, sem_label)
+        loss['loss_bd'] = self.loss_decode[2](d_logit, bd_label)
+        filler = torch.ones_like(sem_label) * self.ignore_index
+        sem_bd_label = torch.where(
+            torch.sigmoid(d_logit[:, 0, :, :]) > 0.8, sem_label, filler)
+        loss['loss_sem_bd'] = self.loss_decode[3](i_logit, sem_bd_label)
+        loss['acc_seg'] = accuracy(
+            i_logit, sem_label, ignore_index=self.ignore_index)
+        return loss
diff --git a/mmsegmentation/mmseg/models/decode_heads/point_head.py b/mmsegmentation/mmseg/models/decode_heads/point_head.py
new file mode 100644
index 0000000..e8e433d
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/point_head.py
@@ -0,0 +1,367 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# Modified from https://github.com/facebookresearch/detectron2/tree/master/projects/PointRend/point_head/point_head.py  # noqa
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+
+try:
+    from mmcv.ops import point_sample
+except ModuleNotFoundError:
+    point_sample = None
+
+from typing import List
+
+from mmseg.registry import MODELS
+from mmseg.utils import SampleList
+from ..losses import accuracy
+from ..utils import resize
+from .cascade_decode_head import BaseCascadeDecodeHead
+
+
+def calculate_uncertainty(seg_logits):
+    """Estimate uncertainty based on seg logits.
+
+    For each location of the prediction ``seg_logits`` we estimate
+    uncertainty as the difference between top first and top second
+    predicted logits.
+
+    Args:
+        seg_logits (Tensor): Semantic segmentation logits,
+            shape (batch_size, num_classes, height, width).
+
+    Returns:
+        scores (Tensor): T uncertainty scores with the most uncertain
+            locations having the highest uncertainty score, shape (
+            batch_size, 1, height, width)
+    """
+    top2_scores = torch.topk(seg_logits, k=2, dim=1)[0]
+    return (top2_scores[:, 1] - top2_scores[:, 0]).unsqueeze(1)
+
+
+@MODELS.register_module()
+class PointHead(BaseCascadeDecodeHead):
+    """A mask point head use in PointRend.
+
+    This head is implemented of `PointRend: Image Segmentation as
+    Rendering <https://arxiv.org/abs/1912.08193>`_.
+    ``PointHead`` use shared multi-layer perceptron (equivalent to
+    nn.Conv1d) to predict the logit of input points. The fine-grained feature
+    and coarse feature will be concatenate together for predication.
+
+    Args:
+        num_fcs (int): Number of fc layers in the head. Default: 3.
+        in_channels (int): Number of input channels. Default: 256.
+        fc_channels (int): Number of fc channels. Default: 256.
+        num_classes (int): Number of classes for logits. Default: 80.
+        class_agnostic (bool): Whether use class agnostic classification.
+            If so, the output channels of logits will be 1. Default: False.
+        coarse_pred_each_layer (bool): Whether concatenate coarse feature with
+            the output of each fc layer. Default: True.
+        conv_cfg (dict|None): Dictionary to construct and config conv layer.
+            Default: dict(type='Conv1d'))
+        norm_cfg (dict|None): Dictionary to construct and config norm layer.
+            Default: None.
+        loss_point (dict): Dictionary to construct and config loss layer of
+            point head. Default: dict(type='CrossEntropyLoss', use_mask=True,
+            loss_weight=1.0).
+    """
+
+    def __init__(self,
+                 num_fcs=3,
+                 coarse_pred_each_layer=True,
+                 conv_cfg=dict(type='Conv1d'),
+                 norm_cfg=None,
+                 act_cfg=dict(type='ReLU', inplace=False),
+                 **kwargs):
+        super().__init__(
+            input_transform='multiple_select',
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg,
+            init_cfg=dict(
+                type='Normal', std=0.01, override=dict(name='fc_seg')),
+            **kwargs)
+        if point_sample is None:
+            raise RuntimeError('Please install mmcv-full for '
+                               'point_sample ops')
+
+        self.num_fcs = num_fcs
+        self.coarse_pred_each_layer = coarse_pred_each_layer
+
+        fc_in_channels = sum(self.in_channels) + self.num_classes
+        fc_channels = self.channels
+        self.fcs = nn.ModuleList()
+        for k in range(num_fcs):
+            fc = ConvModule(
+                fc_in_channels,
+                fc_channels,
+                kernel_size=1,
+                stride=1,
+                padding=0,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg)
+            self.fcs.append(fc)
+            fc_in_channels = fc_channels
+            fc_in_channels += self.num_classes if self.coarse_pred_each_layer \
+                else 0
+        self.fc_seg = nn.Conv1d(
+            fc_in_channels,
+            self.num_classes,
+            kernel_size=1,
+            stride=1,
+            padding=0)
+        if self.dropout_ratio > 0:
+            self.dropout = nn.Dropout(self.dropout_ratio)
+        delattr(self, 'conv_seg')
+
+    def cls_seg(self, feat):
+        """Classify each pixel with fc."""
+        if self.dropout is not None:
+            feat = self.dropout(feat)
+        output = self.fc_seg(feat)
+        return output
+
+    def forward(self, fine_grained_point_feats, coarse_point_feats):
+        x = torch.cat([fine_grained_point_feats, coarse_point_feats], dim=1)
+        for fc in self.fcs:
+            x = fc(x)
+            if self.coarse_pred_each_layer:
+                x = torch.cat((x, coarse_point_feats), dim=1)
+        return self.cls_seg(x)
+
+    def _get_fine_grained_point_feats(self, x, points):
+        """Sample from fine grained features.
+
+        Args:
+            x (list[Tensor]): Feature pyramid from by neck or backbone.
+            points (Tensor): Point coordinates, shape (batch_size,
+                num_points, 2).
+
+        Returns:
+            fine_grained_feats (Tensor): Sampled fine grained feature,
+                shape (batch_size, sum(channels of x), num_points).
+        """
+
+        fine_grained_feats_list = [
+            point_sample(_, points, align_corners=self.align_corners)
+            for _ in x
+        ]
+        if len(fine_grained_feats_list) > 1:
+            fine_grained_feats = torch.cat(fine_grained_feats_list, dim=1)
+        else:
+            fine_grained_feats = fine_grained_feats_list[0]
+
+        return fine_grained_feats
+
+    def _get_coarse_point_feats(self, prev_output, points):
+        """Sample from fine grained features.
+
+        Args:
+            prev_output (list[Tensor]): Prediction of previous decode head.
+            points (Tensor): Point coordinates, shape (batch_size,
+                num_points, 2).
+
+        Returns:
+            coarse_feats (Tensor): Sampled coarse feature, shape (batch_size,
+                num_classes, num_points).
+        """
+
+        coarse_feats = point_sample(
+            prev_output, points, align_corners=self.align_corners)
+
+        return coarse_feats
+
+    def loss(self, inputs, prev_output, batch_data_samples: SampleList,
+             train_cfg, **kwargs):
+        """Forward function for training.
+        Args:
+            inputs (list[Tensor]): List of multi-level img features.
+            prev_output (Tensor): The output of previous decode head.
+            batch_data_samples (list[:obj:`SegDataSample`]): The seg
+                data samples. It usually includes information such
+                as `img_metas` or `gt_semantic_seg`.
+            train_cfg (dict): The training config.
+
+        Returns:
+            dict[str, Tensor]: a dictionary of loss components
+        """
+        x = self._transform_inputs(inputs)
+        with torch.no_grad():
+            points = self.get_points_train(
+                prev_output, calculate_uncertainty, cfg=train_cfg)
+        fine_grained_point_feats = self._get_fine_grained_point_feats(
+            x, points)
+        coarse_point_feats = self._get_coarse_point_feats(prev_output, points)
+        point_logits = self.forward(fine_grained_point_feats,
+                                    coarse_point_feats)
+
+        losses = self.loss_by_feat(point_logits, points, batch_data_samples)
+
+        return losses
+
+    def predict(self, inputs, prev_output, batch_img_metas: List[dict],
+                test_cfg, **kwargs):
+        """Forward function for testing.
+
+        Args:
+            inputs (list[Tensor]): List of multi-level img features.
+            prev_output (Tensor): The output of previous decode head.
+            img_metas (list[dict]): List of image info dict where each dict
+                has: 'img_shape', 'scale_factor', 'flip', and may also contain
+                'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
+                For details on the values of these keys see
+                `mmseg/datasets/pipelines/formatting.py:Collect`.
+            test_cfg (dict): The testing config.
+
+        Returns:
+            Tensor: Output segmentation map.
+        """
+
+        x = self._transform_inputs(inputs)
+        refined_seg_logits = prev_output.clone()
+        for _ in range(test_cfg.subdivision_steps):
+            refined_seg_logits = resize(
+                refined_seg_logits,
+                scale_factor=test_cfg.scale_factor,
+                mode='bilinear',
+                align_corners=self.align_corners)
+            batch_size, channels, height, width = refined_seg_logits.shape
+            point_indices, points = self.get_points_test(
+                refined_seg_logits, calculate_uncertainty, cfg=test_cfg)
+            fine_grained_point_feats = self._get_fine_grained_point_feats(
+                x, points)
+            coarse_point_feats = self._get_coarse_point_feats(
+                prev_output, points)
+            point_logits = self.forward(fine_grained_point_feats,
+                                        coarse_point_feats)
+
+            point_indices = point_indices.unsqueeze(1).expand(-1, channels, -1)
+            refined_seg_logits = refined_seg_logits.reshape(
+                batch_size, channels, height * width)
+            refined_seg_logits = refined_seg_logits.scatter_(
+                2, point_indices, point_logits)
+            refined_seg_logits = refined_seg_logits.view(
+                batch_size, channels, height, width)
+
+        return self.predict_by_feat(refined_seg_logits, batch_img_metas,
+                                    **kwargs)
+
+    def loss_by_feat(self, point_logits, points, batch_data_samples, **kwargs):
+        """Compute segmentation loss."""
+        gt_semantic_seg = self._stack_batch_gt(batch_data_samples)
+        point_label = point_sample(
+            gt_semantic_seg.float(),
+            points,
+            mode='nearest',
+            align_corners=self.align_corners)
+        point_label = point_label.squeeze(1).long()
+
+        loss = dict()
+        if not isinstance(self.loss_decode, nn.ModuleList):
+            losses_decode = [self.loss_decode]
+        else:
+            losses_decode = self.loss_decode
+        for loss_module in losses_decode:
+            loss['point' + loss_module.loss_name] = loss_module(
+                point_logits, point_label, ignore_index=self.ignore_index)
+
+        loss['acc_point'] = accuracy(
+            point_logits, point_label, ignore_index=self.ignore_index)
+        return loss
+
+    def get_points_train(self, seg_logits, uncertainty_func, cfg):
+        """Sample points for training.
+
+        Sample points in [0, 1] x [0, 1] coordinate space based on their
+        uncertainty. The uncertainties are calculated for each point using
+        'uncertainty_func' function that takes point's logit prediction as
+        input.
+
+        Args:
+            seg_logits (Tensor): Semantic segmentation logits, shape (
+                batch_size, num_classes, height, width).
+            uncertainty_func (func): uncertainty calculation function.
+            cfg (dict): Training config of point head.
+
+        Returns:
+            point_coords (Tensor): A tensor of shape (batch_size, num_points,
+                2) that contains the coordinates of ``num_points`` sampled
+                points.
+        """
+        num_points = cfg.num_points
+        oversample_ratio = cfg.oversample_ratio
+        importance_sample_ratio = cfg.importance_sample_ratio
+        assert oversample_ratio >= 1
+        assert 0 <= importance_sample_ratio <= 1
+        batch_size = seg_logits.shape[0]
+        num_sampled = int(num_points * oversample_ratio)
+        point_coords = torch.rand(
+            batch_size, num_sampled, 2, device=seg_logits.device)
+        point_logits = point_sample(seg_logits, point_coords)
+        # It is crucial to calculate uncertainty based on the sampled
+        # prediction value for the points. Calculating uncertainties of the
+        # coarse predictions first and sampling them for points leads to
+        # incorrect results.  To illustrate this: assume uncertainty func(
+        # logits)=-abs(logits), a sampled point between two coarse
+        # predictions with -1 and 1 logits has 0 logits, and therefore 0
+        # uncertainty value. However, if we calculate uncertainties for the
+        # coarse predictions first, both will have -1 uncertainty,
+        # and sampled point will get -1 uncertainty.
+        point_uncertainties = uncertainty_func(point_logits)
+        num_uncertain_points = int(importance_sample_ratio * num_points)
+        num_random_points = num_points - num_uncertain_points
+        idx = torch.topk(
+            point_uncertainties[:, 0, :], k=num_uncertain_points, dim=1)[1]
+        shift = num_sampled * torch.arange(
+            batch_size, dtype=torch.long, device=seg_logits.device)
+        idx += shift[:, None]
+        point_coords = point_coords.view(-1, 2)[idx.view(-1), :].view(
+            batch_size, num_uncertain_points, 2)
+        if num_random_points > 0:
+            rand_point_coords = torch.rand(
+                batch_size, num_random_points, 2, device=seg_logits.device)
+            point_coords = torch.cat((point_coords, rand_point_coords), dim=1)
+        return point_coords
+
+    def get_points_test(self, seg_logits, uncertainty_func, cfg):
+        """Sample points for testing.
+
+        Find ``num_points`` most uncertain points from ``uncertainty_map``.
+
+        Args:
+            seg_logits (Tensor): A tensor of shape (batch_size, num_classes,
+                height, width) for class-specific or class-agnostic prediction.
+            uncertainty_func (func): uncertainty calculation function.
+            cfg (dict): Testing config of point head.
+
+        Returns:
+            point_indices (Tensor): A tensor of shape (batch_size, num_points)
+                that contains indices from [0, height x width) of the most
+                uncertain points.
+            point_coords (Tensor): A tensor of shape (batch_size, num_points,
+                2) that contains [0, 1] x [0, 1] normalized coordinates of the
+                most uncertain points from the ``height x width`` grid .
+        """
+
+        num_points = cfg.subdivision_num_points
+        uncertainty_map = uncertainty_func(seg_logits)
+        batch_size, _, height, width = uncertainty_map.shape
+        h_step = 1.0 / height
+        w_step = 1.0 / width
+
+        uncertainty_map = uncertainty_map.view(batch_size, height * width)
+        num_points = min(height * width, num_points)
+        point_indices = uncertainty_map.topk(num_points, dim=1)[1]
+        point_coords = torch.zeros(
+            batch_size,
+            num_points,
+            2,
+            dtype=torch.float,
+            device=seg_logits.device)
+        point_coords[:, :, 0] = w_step / 2.0 + (point_indices %
+                                                width).float() * w_step
+        point_coords[:, :, 1] = h_step / 2.0 + (point_indices //
+                                                width).float() * h_step
+        return point_indices, point_coords
diff --git a/mmsegmentation/mmseg/models/decode_heads/psa_head.py b/mmsegmentation/mmseg/models/decode_heads/psa_head.py
new file mode 100644
index 0000000..13ee5c5
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/psa_head.py
@@ -0,0 +1,197 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+
+from mmseg.registry import MODELS
+from ..utils import resize
+from .decode_head import BaseDecodeHead
+
+try:
+    from mmcv.ops import PSAMask
+except ModuleNotFoundError:
+    PSAMask = None
+
+
+@MODELS.register_module()
+class PSAHead(BaseDecodeHead):
+    """Point-wise Spatial Attention Network for Scene Parsing.
+
+    This head is the implementation of `PSANet
+    <https://hszhao.github.io/papers/eccv18_psanet.pdf>`_.
+
+    Args:
+        mask_size (tuple[int]): The PSA mask size. It usually equals input
+            size.
+        psa_type (str): The type of psa module. Options are 'collect',
+            'distribute', 'bi-direction'. Default: 'bi-direction'
+        compact (bool): Whether use compact map for 'collect' mode.
+            Default: True.
+        shrink_factor (int): The downsample factors of psa mask. Default: 2.
+        normalization_factor (float): The normalize factor of attention.
+        psa_softmax (bool): Whether use softmax for attention.
+    """
+
+    def __init__(self,
+                 mask_size,
+                 psa_type='bi-direction',
+                 compact=False,
+                 shrink_factor=2,
+                 normalization_factor=1.0,
+                 psa_softmax=True,
+                 **kwargs):
+        if PSAMask is None:
+            raise RuntimeError('Please install mmcv-full for PSAMask ops')
+        super().__init__(**kwargs)
+        assert psa_type in ['collect', 'distribute', 'bi-direction']
+        self.psa_type = psa_type
+        self.compact = compact
+        self.shrink_factor = shrink_factor
+        self.mask_size = mask_size
+        mask_h, mask_w = mask_size
+        self.psa_softmax = psa_softmax
+        if normalization_factor is None:
+            normalization_factor = mask_h * mask_w
+        self.normalization_factor = normalization_factor
+
+        self.reduce = ConvModule(
+            self.in_channels,
+            self.channels,
+            kernel_size=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+        self.attention = nn.Sequential(
+            ConvModule(
+                self.channels,
+                self.channels,
+                kernel_size=1,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg),
+            nn.Conv2d(
+                self.channels, mask_h * mask_w, kernel_size=1, bias=False))
+        if psa_type == 'bi-direction':
+            self.reduce_p = ConvModule(
+                self.in_channels,
+                self.channels,
+                kernel_size=1,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg)
+            self.attention_p = nn.Sequential(
+                ConvModule(
+                    self.channels,
+                    self.channels,
+                    kernel_size=1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg,
+                    act_cfg=self.act_cfg),
+                nn.Conv2d(
+                    self.channels, mask_h * mask_w, kernel_size=1, bias=False))
+            self.psamask_collect = PSAMask('collect', mask_size)
+            self.psamask_distribute = PSAMask('distribute', mask_size)
+        else:
+            self.psamask = PSAMask(psa_type, mask_size)
+        self.proj = ConvModule(
+            self.channels * (2 if psa_type == 'bi-direction' else 1),
+            self.in_channels,
+            kernel_size=1,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+        self.bottleneck = ConvModule(
+            self.in_channels * 2,
+            self.channels,
+            kernel_size=3,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+    def forward(self, inputs):
+        """Forward function."""
+        x = self._transform_inputs(inputs)
+        identity = x
+        align_corners = self.align_corners
+        if self.psa_type in ['collect', 'distribute']:
+            out = self.reduce(x)
+            n, c, h, w = out.size()
+            if self.shrink_factor != 1:
+                if h % self.shrink_factor and w % self.shrink_factor:
+                    h = (h - 1) // self.shrink_factor + 1
+                    w = (w - 1) // self.shrink_factor + 1
+                    align_corners = True
+                else:
+                    h = h // self.shrink_factor
+                    w = w // self.shrink_factor
+                    align_corners = False
+                out = resize(
+                    out,
+                    size=(h, w),
+                    mode='bilinear',
+                    align_corners=align_corners)
+            y = self.attention(out)
+            if self.compact:
+                if self.psa_type == 'collect':
+                    y = y.view(n, h * w,
+                               h * w).transpose(1, 2).view(n, h * w, h, w)
+            else:
+                y = self.psamask(y)
+            if self.psa_softmax:
+                y = F.softmax(y, dim=1)
+            out = torch.bmm(
+                out.view(n, c, h * w), y.view(n, h * w, h * w)).view(
+                    n, c, h, w) * (1.0 / self.normalization_factor)
+        else:
+            x_col = self.reduce(x)
+            x_dis = self.reduce_p(x)
+            n, c, h, w = x_col.size()
+            if self.shrink_factor != 1:
+                if h % self.shrink_factor and w % self.shrink_factor:
+                    h = (h - 1) // self.shrink_factor + 1
+                    w = (w - 1) // self.shrink_factor + 1
+                    align_corners = True
+                else:
+                    h = h // self.shrink_factor
+                    w = w // self.shrink_factor
+                    align_corners = False
+                x_col = resize(
+                    x_col,
+                    size=(h, w),
+                    mode='bilinear',
+                    align_corners=align_corners)
+                x_dis = resize(
+                    x_dis,
+                    size=(h, w),
+                    mode='bilinear',
+                    align_corners=align_corners)
+            y_col = self.attention(x_col)
+            y_dis = self.attention_p(x_dis)
+            if self.compact:
+                y_dis = y_dis.view(n, h * w,
+                                   h * w).transpose(1, 2).view(n, h * w, h, w)
+            else:
+                y_col = self.psamask_collect(y_col)
+                y_dis = self.psamask_distribute(y_dis)
+            if self.psa_softmax:
+                y_col = F.softmax(y_col, dim=1)
+                y_dis = F.softmax(y_dis, dim=1)
+            x_col = torch.bmm(
+                x_col.view(n, c, h * w), y_col.view(n, h * w, h * w)).view(
+                    n, c, h, w) * (1.0 / self.normalization_factor)
+            x_dis = torch.bmm(
+                x_dis.view(n, c, h * w), y_dis.view(n, h * w, h * w)).view(
+                    n, c, h, w) * (1.0 / self.normalization_factor)
+            out = torch.cat([x_col, x_dis], 1)
+        out = self.proj(out)
+        out = resize(
+            out,
+            size=identity.shape[2:],
+            mode='bilinear',
+            align_corners=align_corners)
+        out = self.bottleneck(torch.cat((identity, out), dim=1))
+        out = self.cls_seg(out)
+        return out
diff --git a/mmsegmentation/mmseg/models/decode_heads/psp_head.py b/mmsegmentation/mmseg/models/decode_heads/psp_head.py
new file mode 100644
index 0000000..a40ec41
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/psp_head.py
@@ -0,0 +1,117 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+
+from mmseg.registry import MODELS
+from ..utils import resize
+from .decode_head import BaseDecodeHead
+
+
+class PPM(nn.ModuleList):
+    """Pooling Pyramid Module used in PSPNet.
+
+    Args:
+        pool_scales (tuple[int]): Pooling scales used in Pooling Pyramid
+            Module.
+        in_channels (int): Input channels.
+        channels (int): Channels after modules, before conv_seg.
+        conv_cfg (dict|None): Config of conv layers.
+        norm_cfg (dict|None): Config of norm layers.
+        act_cfg (dict): Config of activation layers.
+        align_corners (bool): align_corners argument of F.interpolate.
+    """
+
+    def __init__(self, pool_scales, in_channels, channels, conv_cfg, norm_cfg,
+                 act_cfg, align_corners, **kwargs):
+        super().__init__()
+        self.pool_scales = pool_scales
+        self.align_corners = align_corners
+        self.in_channels = in_channels
+        self.channels = channels
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+        for pool_scale in pool_scales:
+            self.append(
+                nn.Sequential(
+                    nn.AdaptiveAvgPool2d(pool_scale),
+                    ConvModule(
+                        self.in_channels,
+                        self.channels,
+                        1,
+                        conv_cfg=self.conv_cfg,
+                        norm_cfg=self.norm_cfg,
+                        act_cfg=self.act_cfg,
+                        **kwargs)))
+
+    def forward(self, x):
+        """Forward function."""
+        ppm_outs = []
+        for ppm in self:
+            ppm_out = ppm(x)
+            upsampled_ppm_out = resize(
+                ppm_out,
+                size=x.size()[2:],
+                mode='bilinear',
+                align_corners=self.align_corners)
+            ppm_outs.append(upsampled_ppm_out)
+        return ppm_outs
+
+
+@MODELS.register_module()
+class PSPHead(BaseDecodeHead):
+    """Pyramid Scene Parsing Network.
+
+    This head is the implementation of
+    `PSPNet <https://arxiv.org/abs/1612.01105>`_.
+
+    Args:
+        pool_scales (tuple[int]): Pooling scales used in Pooling Pyramid
+            Module. Default: (1, 2, 3, 6).
+    """
+
+    def __init__(self, pool_scales=(1, 2, 3, 6), **kwargs):
+        super().__init__(**kwargs)
+        assert isinstance(pool_scales, (list, tuple))
+        self.pool_scales = pool_scales
+        self.psp_modules = PPM(
+            self.pool_scales,
+            self.in_channels,
+            self.channels,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg,
+            align_corners=self.align_corners)
+        self.bottleneck = ConvModule(
+            self.in_channels + len(pool_scales) * self.channels,
+            self.channels,
+            3,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+    def _forward_feature(self, inputs):
+        """Forward function for feature maps before classifying each pixel with
+        ``self.cls_seg`` fc.
+
+        Args:
+            inputs (list[Tensor]): List of multi-level img features.
+
+        Returns:
+            feats (Tensor): A tensor of shape (batch_size, self.channels,
+                H, W) which is feature map for last layer of decoder head.
+        """
+        x = self._transform_inputs(inputs)
+        psp_outs = [x]
+        psp_outs.extend(self.psp_modules(x))
+        psp_outs = torch.cat(psp_outs, dim=1)
+        feats = self.bottleneck(psp_outs)
+        return feats
+
+    def forward(self, inputs):
+        """Forward function."""
+        output = self._forward_feature(inputs)
+        output = self.cls_seg(output)
+        return output
diff --git a/mmsegmentation/mmseg/models/decode_heads/san_head.py b/mmsegmentation/mmseg/models/decode_heads/san_head.py
new file mode 100644
index 0000000..d20da80
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/san_head.py
@@ -0,0 +1,736 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from functools import partial
+from typing import Dict, List, Tuple
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule, build_norm_layer
+from mmcv.cnn.bricks.transformer import BaseTransformerLayer
+from mmcv.ops import point_sample
+from mmengine.dist import all_reduce
+from mmengine.model.weight_init import (caffe2_xavier_init, normal_init,
+                                        trunc_normal_)
+from mmengine.runner.checkpoint import CheckpointLoader, load_state_dict
+from mmengine.structures import InstanceData
+from torch import Tensor
+from torch.nn import functional as F
+
+from mmseg.models.backbones.vit import TransformerEncoderLayer
+from mmseg.registry import MODELS
+from mmseg.utils import (ConfigType, MatchMasks, SampleList,
+                         seg_data_to_instance_data)
+from ..utils import (MLP, LayerNorm2d, PatchEmbed, cross_attn_layer,
+                     get_uncertain_point_coords_with_randomness, resize)
+from .decode_head import BaseDecodeHead
+
+
+class MLPMaskDecoder(nn.Module):
+    """Module for decoding query and visual features with MLP layers to
+    generate the attention biases and the mask proposals."""
+
+    def __init__(
+        self,
+        *,
+        in_channels: int,
+        total_heads: int = 1,
+        total_layers: int = 1,
+        embed_channels: int = 256,
+        mlp_channels: int = 256,
+        mlp_num_layers: int = 3,
+        rescale_attn_bias: bool = False,
+    ):
+        super().__init__()
+        self.total_heads = total_heads
+        self.total_layers = total_layers
+
+        dense_affine_func = partial(nn.Conv2d, kernel_size=1)
+        # Query Branch
+        self.query_mlp = MLP(in_channels, mlp_channels, embed_channels,
+                             mlp_num_layers)
+        # Pixel Branch
+        self.pix_mlp = MLP(
+            in_channels,
+            mlp_channels,
+            embed_channels,
+            mlp_num_layers,
+            affine_func=dense_affine_func,
+        )
+        # Attention Bias Branch
+        self.attn_mlp = MLP(
+            in_channels,
+            mlp_channels,
+            embed_channels * self.total_heads * self.total_layers,
+            mlp_num_layers,
+            affine_func=dense_affine_func,
+        )
+        if rescale_attn_bias:
+            self.bias_scaling = nn.Linear(1, 1)
+        else:
+            self.bias_scaling = nn.Identity()
+
+    def forward(self, query: torch.Tensor,
+                x: torch.Tensor) -> Tuple[torch.Tensor, List[torch.Tensor]]:
+        """Forward function.
+        Args:
+            query (Tensor): Query Tokens [B,N,C].
+            x (Tensor): Visual features [B,C,H,W]
+
+        Return:
+            mask_preds (Tensor): Mask proposals.
+            attn_bias (List[Tensor]): List of attention bias.
+        """
+        query = self.query_mlp(query)
+        pix = self.pix_mlp(x)
+        b, c, h, w = pix.shape
+        # preidict mask
+        mask_preds = torch.einsum('bqc,bchw->bqhw', query, pix)
+        # generate attn bias
+        attn = self.attn_mlp(x)
+        attn = attn.reshape(b, self.total_layers, self.total_heads, c, h, w)
+        attn_bias = torch.einsum('bqc,blnchw->blnqhw', query, attn)
+        attn_bias = self.bias_scaling(attn_bias[..., None]).squeeze(-1)
+        attn_bias = attn_bias.chunk(self.total_layers, dim=1)
+        attn_bias = [attn.squeeze(1) for attn in attn_bias]
+        return mask_preds, attn_bias
+
+
+class SideAdapterNetwork(nn.Module):
+    """Side Adapter Network for predicting mask proposals and attention bias.
+
+    Args:
+        in_channels (int): Number of input channels. Default: 3.
+        clip_channels (int): Number of channels of visual features.
+            Default: 768.
+        embed_dims (int): embedding dimension. Default: 240.
+        patch_size (int): The patch size. Default: 16.
+        patch_bias (bool): Whether use bias in patch embedding.
+            Default: True.
+        num_queries (int): Number of queries for mask proposals.
+            Default: 100.
+        fusion_index (List[int]): The layer number of the encode
+            transformer to fuse with the CLIP feature.
+            Default: [0, 1, 2, 3].
+        cfg_encoder (ConfigType): Configs for the encode layers.
+        cfg_decoder (ConfigType): Configs for the decode layers.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='LN').
+    """
+
+    def __init__(
+            self,
+            in_channels: int = 3,
+            clip_channels: int = 768,
+            embed_dims: int = 240,
+            patch_size: int = 16,
+            patch_bias: bool = True,
+            num_queries: int = 100,
+            fusion_index: list = [0, 1, 2, 3],
+            cfg_encoder: ConfigType = ...,
+            cfg_decoder: ConfigType = ...,
+            norm_cfg: dict = dict(type='LN'),
+    ):
+        super().__init__()
+
+        self.patch_embed = PatchEmbed(
+            in_channels=in_channels,
+            embed_dims=embed_dims,
+            conv_type='Conv2d',
+            kernel_size=patch_size,
+            stride=patch_size,
+            padding=0,
+            input_size=(640, 640),
+            bias=patch_bias,
+            norm_cfg=None,
+            init_cfg=None,
+        )
+        ori_h, ori_w = self.patch_embed.init_out_size
+        num_patches = ori_h * ori_w
+        self.pos_embed = nn.Parameter(
+            torch.randn(1, num_patches, embed_dims) * .02)
+        self.query_pos_embed = nn.Parameter(
+            torch.zeros(1, num_queries, embed_dims))
+        self.query_embed = nn.Parameter(
+            torch.zeros(1, num_queries, embed_dims))
+        encode_layers = []
+        for i in range(cfg_encoder.num_encode_layer):
+            encode_layers.append(
+                TransformerEncoderLayer(
+                    embed_dims=embed_dims,
+                    num_heads=cfg_encoder.num_heads,
+                    feedforward_channels=cfg_encoder.mlp_ratio * embed_dims,
+                    norm_cfg=norm_cfg))
+        self.encode_layers = nn.ModuleList(encode_layers)
+        conv_clips = []
+        for i in range(len(fusion_index)):
+            conv_clips.append(
+                nn.Sequential(
+                    LayerNorm2d(clip_channels),
+                    ConvModule(
+                        clip_channels,
+                        embed_dims,
+                        kernel_size=1,
+                        norm_cfg=None,
+                        act_cfg=None)))
+        self.conv_clips = nn.ModuleList(conv_clips)
+        self.fusion_index = fusion_index
+        self.mask_decoder = MLPMaskDecoder(
+            in_channels=embed_dims,
+            total_heads=cfg_decoder.num_heads,
+            total_layers=cfg_decoder.num_layers,
+            embed_channels=cfg_decoder.embed_channels,
+            mlp_channels=cfg_decoder.mlp_channels,
+            mlp_num_layers=cfg_decoder.num_mlp,
+            rescale_attn_bias=cfg_decoder.rescale)
+
+    def init_weights(self):
+        trunc_normal_(self.pos_embed, std=0.02)
+        nn.init.normal_(self.query_embed, std=0.02)
+        nn.init.normal_(self.query_pos_embed, std=0.02)
+        for i in range(len(self.conv_clips)):
+            caffe2_xavier_init(self.conv_clips[i][1].conv)
+
+    def fuse_clip(self, fused_index: int, x: torch.Tensor,
+                  clip_feature: torch.Tensor, hwshape: Tuple[int,
+                                                             int], L: int):
+        """Fuse CLIP feature and visual tokens."""
+        fused_clip = (resize(
+            self.conv_clips[fused_index](clip_feature.contiguous()),
+            size=hwshape,
+            mode='bilinear',
+            align_corners=False)).permute(0, 2, 3, 1).reshape(x[:, -L:,
+                                                                ...].shape)
+        x = torch.cat([x[:, :-L, ...], x[:, -L:, ...] + fused_clip], dim=1)
+        return x
+
+    def encode_feature(self, image: torch.Tensor,
+                       clip_features: List[torch.Tensor],
+                       deep_supervision_idxs: List[int]) -> List[List]:
+        """Encode images by a lightweight vision transformer."""
+        assert len(self.fusion_index) == len(clip_features)
+        x, hwshape = self.patch_embed(image)
+        ori_h, ori_w = self.patch_embed.init_out_size
+        pos_embed = self.pos_embed
+        if self.pos_embed.shape[1] != x.shape[1]:
+            # resize the position embedding
+            pos_embed = (
+                resize(
+                    self.pos_embed.reshape(1, ori_h, ori_w,
+                                           -1).permute(0, 3, 1, 2),
+                    size=hwshape,
+                    mode='bicubic',
+                    align_corners=False,
+                ).flatten(2).permute(0, 2, 1))
+        pos_embed = torch.cat([
+            self.query_pos_embed.expand(pos_embed.shape[0], -1, -1), pos_embed
+        ],
+                              dim=1)
+        x = torch.cat([self.query_embed.expand(x.shape[0], -1, -1), x], dim=1)
+        x = x + pos_embed
+        L = hwshape[0] * hwshape[1]
+        fused_index = 0
+        if self.fusion_index[fused_index] == 0:
+            x = self.fuse_clip(fused_index, x, clip_features[0][0], hwshape, L)
+            fused_index += 1
+        outs = []
+        for index, block in enumerate(self.encode_layers, start=1):
+            x = block(x)
+            if index < len(self.fusion_index
+                           ) and index == self.fusion_index[fused_index]:
+                x = self.fuse_clip(fused_index, x,
+                                   clip_features[fused_index][0], hwshape, L)
+                fused_index += 1
+            x_query = x[:, :-L, ...]
+            x_feat = x[:, -L:, ...].permute(0, 2, 1)\
+                .reshape(x.shape[0], x.shape[-1], hwshape[0], hwshape[1])
+
+            if index in deep_supervision_idxs or index == len(
+                    self.encode_layers):
+                outs.append({'query': x_query, 'x': x_feat})
+
+            if index < len(self.encode_layers):
+                x = x + pos_embed
+        return outs
+
+    def decode_feature(self, features):
+        mask_embeds = []
+        attn_biases = []
+        for feature in features:
+            mask_embed, attn_bias = self.mask_decoder(**feature)
+            mask_embeds.append(mask_embed)
+            attn_biases.append(attn_bias)
+        return mask_embeds, attn_biases
+
+    def forward(
+        self, image: torch.Tensor, clip_features: List[torch.Tensor],
+        deep_supervision_idxs: List[int]
+    ) -> Tuple[List[torch.Tensor], List[List[torch.Tensor]]]:
+        """Forward function."""
+        features = self.encode_feature(image, clip_features,
+                                       deep_supervision_idxs)
+        mask_embeds, attn_biases = self.decode_feature(features)
+        return mask_embeds, attn_biases
+
+
+class RecWithAttnbias(nn.Module):
+    """Mask recognition module by applying the attention biases to rest deeper
+    CLIP layers.
+
+    Args:
+        sos_token_format (str): The format of sos token. It should be
+            chosen from  ["cls_token", "learnable_token", "pos_embedding"].
+            Default: 'cls_token'.
+        sos_token_num (int): Number of sos token. It should be equal to
+            the number of quries. Default: 100.
+        num_layers (int): Number of rest CLIP layers for mask recognition.
+            Default: 3.
+        cross_attn (bool): Whether use cross attention to update sos token.
+            Default: False.
+        embed_dims (int): The feature dimension of CLIP layers.
+            Default: 768.
+        num_heads (int): Parallel attention heads of CLIP layers.
+            Default: 768.
+        mlp_ratio (int): Ratio of mlp hidden dim to embedding dim.
+            Default: 4.
+        qkv_bias (bool): Whether to use bias in multihead-attention.
+            Default: True.
+        out_dims (int): Number of channels of the output mask proposals.
+            It should be equal to the out_dims of text_encoder.
+            Default: 512.
+        final_norm (True): Whether use norm layer for sos token.
+        act_cfg (dict): The activation config for FFNs.
+            Default: dict(type='GELU').
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='LN').
+        frozen_exclude (List): List of parameters that are not to be frozen.
+    """
+
+    def __init__(self,
+                 sos_token_format: str = 'cls_token',
+                 sos_token_num: int = 100,
+                 num_layers: int = 3,
+                 cross_attn: bool = False,
+                 embed_dims: int = 768,
+                 num_heads: int = 12,
+                 mlp_ratio: int = 4,
+                 num_fcs: int = 2,
+                 qkv_bias: bool = True,
+                 out_dims: int = 512,
+                 final_norm: bool = True,
+                 act_cfg: dict = dict(type='GELU'),
+                 norm_cfg: dict = dict(type='LN'),
+                 frozen_exclude: List = []):
+        super().__init__()
+
+        assert sos_token_format in [
+            'cls_token', 'learnable_token', 'pos_embedding'
+        ]
+        self.sos_token_format = sos_token_format
+        self.sos_token_num = sos_token_num
+        self.frozen_exclude = frozen_exclude
+        self.cross_attn = cross_attn
+        self.num_layers = num_layers
+        self.num_heads = num_heads
+        if sos_token_format in ['learnable_token', 'pos_embedding']:
+            self.sos_token = nn.Parameter(
+                torch.randn(sos_token_num, 1, self.proj.shape[0]))
+            self.frozen.append('sos_token')
+
+        layers = []
+        for i in range(num_layers):
+            layers.append(
+                BaseTransformerLayer(
+                    attn_cfgs=dict(
+                        type='MultiheadAttention',
+                        embed_dims=embed_dims,
+                        num_heads=num_heads,
+                        batch_first=False,
+                        bias=qkv_bias),
+                    ffn_cfgs=dict(
+                        type='FFN',
+                        embed_dims=embed_dims,
+                        feedforward_channels=mlp_ratio * embed_dims,
+                        act_cfg=act_cfg),
+                    operation_order=('norm', 'self_attn', 'norm', 'ffn')))
+        self.layers = nn.ModuleList(layers)
+
+        self.ln_post = build_norm_layer(norm_cfg, embed_dims)[1]
+        self.proj = nn.Linear(embed_dims, out_dims, bias=False)
+
+        self.final_norm = final_norm
+        self._freeze()
+
+    def init_weights(self, rec_state_dict):
+        if hasattr(self, 'sos_token'):
+            normal_init(self.sos_token, std=0.02)
+        if rec_state_dict is not None:
+            load_state_dict(self, rec_state_dict, strict=False, logger=None)
+        else:
+            super().init_weights()
+
+    def _freeze(self):
+        if 'all' in self.frozen_exclude:
+            return
+        for name, param in self.named_parameters():
+            if not any([exclude in name for exclude in self.frozen_exclude]):
+                param.requires_grad = False
+
+    def _build_attn_biases(self, attn_biases, target_shape):
+        formatted_attn_biases = []
+        for attn_bias in attn_biases:
+            # convert it to proper format: N*num_head,L,L
+            # attn_bias: [N, num_head/1, num_sos,H,W]
+            n, num_head, num_sos, h, w = attn_bias.shape
+            # reshape and downsample
+            attn_bias = F.adaptive_max_pool2d(
+                attn_bias.reshape(n, num_head * num_sos, h, w),
+                output_size=target_shape)
+            attn_bias = attn_bias.reshape(n, num_head, num_sos, *target_shape)
+
+            true_num_head = self.num_heads
+            assert (num_head == 1 or num_head
+                    == true_num_head), f'num_head={num_head} is not supported.'
+            if num_head == 1:
+                attn_bias = attn_bias.repeat(1, true_num_head, 1, 1, 1)
+            attn_bias = attn_bias.reshape(n * true_num_head, num_sos, -1)
+            L = attn_bias.shape[-1]
+            if self.cross_attn:
+                # [n*num_head, num_sos, L]
+                formatted_attn_biases.append(attn_bias)
+            else:
+                # [n*num_head, num_sos+1+L, num_sos+1+L]
+                new_attn_bias = attn_bias.new_zeros(num_sos + 1 + L,
+                                                    num_sos + 1 + L)
+                new_attn_bias[:, :num_sos] = -100
+                new_attn_bias[torch.arange(num_sos), torch.arange(num_sos)] = 0
+                new_attn_bias[:num_sos, num_sos] = -100
+                new_attn_bias = (
+                    new_attn_bias[None, ...].expand(n * true_num_head, -1,
+                                                    -1).clone())
+                new_attn_bias[..., :num_sos, -L:] = attn_bias
+                formatted_attn_biases.append(new_attn_bias)
+
+        if len(formatted_attn_biases) == 1:
+            formatted_attn_biases = [
+                formatted_attn_biases[0] for _ in range(self.num_layers)
+            ]
+        return formatted_attn_biases
+
+    def forward(self, bias: List[Tensor], feature: List[Tensor]):
+        """Forward function to recognize the category of masks
+        Args:
+            bias (List[Tensor]): Attention bias for transformer layers
+            feature (List[Tensor]): Output of the image encoder,
+            including cls_token and img_feature.
+        """
+        cls_token = feature[1].unsqueeze(0)
+        img_feature = feature[0]
+        b, c, h, w = img_feature.shape
+        # construct clip shadow features
+        x = torch.cat(
+            [cls_token,
+             img_feature.reshape(b, c, -1).permute(2, 0, 1)])
+
+        # construct sos token
+        if self.sos_token_format == 'cls_token':
+            sos_token = cls_token.repeat(self.sos_token_num, 1, 1)
+        elif self.sos_token_format == 'learnable_token':
+            sos_token = self.sos_token.expand(-1, b, -1)
+        elif self.sos_token_format == 'pos_embedding':
+            sos_token = self.sos_token.expand(-1, b, -1) + cls_token
+
+        # construct attn bias
+        attn_biases = self._build_attn_biases(bias, target_shape=(h, w))
+
+        if self.cross_attn:
+            for i, block in enumerate(self.layers):
+                if self.cross_attn:
+                    sos_token = cross_attn_layer(
+                        block,
+                        sos_token,
+                        x[1:, ],
+                        attn_biases[i],
+                    )
+                    if i < len(self.layers) - 1:
+                        x = block(x)
+        else:
+            x = torch.cat([sos_token, x], dim=0)
+            for i, block in enumerate(self.layers):
+                x = block(x, attn_masks=[attn_biases[i]])
+            sos_token = x[:self.sos_token_num]
+
+        sos_token = sos_token.permute(1, 0, 2)  # LND -> NLD
+        sos_token = self.ln_post(sos_token)
+        sos_token = self.proj(sos_token)
+        if self.final_norm:
+            sos_token = F.normalize(sos_token, dim=-1)
+        return sos_token
+
+
+@MODELS.register_module()
+class SideAdapterCLIPHead(BaseDecodeHead):
+    """Side Adapter Network (SAN) for open-vocabulary semantic segmentation
+    with pre-trained vision-language model.
+
+    This decode head is the implementation of `Side Adapter Network
+    for Open-Vocabulary Semantic Segmentation`
+    <https://arxiv.org/abs/2302.12242>.
+    Modified from https://github.com/MendelXu/SAN/blob/main/san/model/side_adapter/side_adapter.py # noqa:E501
+    Copyright (c) 2023 MendelXu.
+    Licensed under the MIT License
+
+    Args:
+        num_classes (int): the number of classes.
+        san_cfg (ConfigType): Configs for SideAdapterNetwork module
+        maskgen_cfg (ConfigType): Configs for RecWithAttnbias module
+    """
+
+    def __init__(self, num_classes: int, san_cfg: ConfigType,
+                 maskgen_cfg: ConfigType, deep_supervision_idxs: List[int],
+                 train_cfg: ConfigType, **kwargs):
+        super().__init__(
+            in_channels=san_cfg.in_channels,
+            channels=san_cfg.embed_dims,
+            num_classes=num_classes,
+            **kwargs)
+        assert san_cfg.num_queries == maskgen_cfg.sos_token_num, \
+            'num_queries in san_cfg should be equal to sos_token_num ' \
+            'in maskgen_cfg'
+        del self.conv_seg
+        self.side_adapter_network = SideAdapterNetwork(**san_cfg)
+        self.rec_with_attnbias = RecWithAttnbias(**maskgen_cfg)
+        self.deep_supervision_idxs = deep_supervision_idxs
+        self.train_cfg = train_cfg
+        if train_cfg:
+            self.match_masks = MatchMasks(
+                num_points=train_cfg.num_points,
+                num_queries=san_cfg.num_queries,
+                num_classes=num_classes,
+                assigner=train_cfg.assigner)
+
+    def init_weights(self):
+
+        rec_state_dict = None
+        if isinstance(self.init_cfg, dict) and \
+                self.init_cfg.get('type') == 'Pretrained_Part':
+            checkpoint = CheckpointLoader.load_checkpoint(
+                self.init_cfg['checkpoint'], logger=None, map_location='cpu')
+
+            rec_state_dict = checkpoint.copy()
+            para_prefix = 'decode_head.rec_with_attnbias'
+            prefix_len = len(para_prefix) + 1
+            for k, v in checkpoint.items():
+                rec_state_dict.pop(k)
+                if para_prefix in k:
+                    rec_state_dict[k[prefix_len:]] = v
+
+        self.side_adapter_network.init_weights()
+        self.rec_with_attnbias.init_weights(rec_state_dict)
+
+    def forward(self, inputs: Tuple[Tensor],
+                deep_supervision_idxs) -> Tuple[List]:
+        """Forward function.
+
+        Args:
+            inputs (Tuple[Tensor]): A triplet including images,
+            list of multi-level visual features from image encoder and
+            class embeddings from text_encoder.
+
+        Returns:
+            mask_props (List[Tensor]): Mask proposals predicted by SAN.
+            mask_logits (List[Tensor]): Class logits of mask proposals.
+        """
+        imgs, clip_feature, class_embeds = inputs
+        # predict mask proposals and attention bias
+        mask_props, attn_biases = self.side_adapter_network(
+            imgs, clip_feature, deep_supervision_idxs)
+
+        # mask recognition with attention bias
+        mask_embeds = [
+            self.rec_with_attnbias(att_bias, clip_feature[-1])
+            for att_bias in attn_biases
+        ]
+        # Obtain class prediction of masks by comparing the similarity
+        # between the image token and the text embedding of class names.
+        mask_logits = [
+            torch.einsum('bqc,nc->bqn', mask_embed, class_embeds)
+            for mask_embed in mask_embeds
+        ]
+        return mask_props, mask_logits
+
+    def predict(self, inputs: Tuple[Tensor], batch_img_metas: List[dict],
+                test_cfg: ConfigType) -> Tensor:
+        """Forward function for prediction.
+
+        Args:
+            inputs (Tuple[Tensor]): Images, visual features from image encoder
+            and class embedding from text encoder.
+            batch_img_metas (dict): List Image info where each dict may also
+                contain: 'img_shape', 'scale_factor', 'flip', 'img_path',
+                'ori_shape', and 'pad_shape'.
+                For details on the values of these keys see
+                `mmseg/datasets/pipelines/formatting.py:PackSegInputs`.
+            test_cfg (dict): The testing config.
+
+        Returns:
+            Tensor: Outputs segmentation logits map.
+        """
+        mask_props, mask_logits = self.forward(inputs, [])
+
+        return self.predict_by_feat([mask_props[-1], mask_logits[-1]],
+                                    batch_img_metas)
+
+    def predict_by_feat(self, seg_logits: List[Tensor],
+                        batch_img_metas: List[dict]) -> Tensor:
+        """1. Transform a batch of mask proposals to the input shape.
+           2. Generate segmentation map with mask proposals and class logits.
+        """
+        mask_pred = seg_logits[0]
+        cls_score = seg_logits[1]
+        if isinstance(batch_img_metas[0]['img_shape'], torch.Size):
+            # slide inference
+            size = batch_img_metas[0]['img_shape']
+        elif 'pad_shape' in batch_img_metas[0]:
+            size = batch_img_metas[0]['pad_shape'][:2]
+        else:
+            size = batch_img_metas[0]['img_shape']
+        # upsample mask
+        mask_pred = F.interpolate(
+            mask_pred, size=size, mode='bilinear', align_corners=False)
+
+        mask_cls = F.softmax(cls_score, dim=-1)[..., :-1]
+        mask_pred = mask_pred.sigmoid()
+        seg_logits = torch.einsum('bqc,bqhw->bchw', mask_cls, mask_pred)
+        return seg_logits
+
+    def loss(self, x: Tuple[Tensor], batch_data_samples: SampleList,
+             train_cfg: ConfigType) -> dict:
+        """Perform forward propagation and loss calculation of the decoder head
+        on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Multi-level features from the upstream
+                network, each is a 4D-tensor.
+            batch_data_samples (List[:obj:`SegDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_sem_seg`.
+            train_cfg (ConfigType): Training config.
+
+        Returns:
+            dict[str, Tensor]: a dictionary of loss components.
+        """
+        # batch SegDataSample to InstanceDataSample
+        batch_gt_instances = seg_data_to_instance_data(self.ignore_index,
+                                                       batch_data_samples)
+
+        # forward
+        all_mask_props, all_mask_logits = self.forward(
+            x, self.deep_supervision_idxs)
+
+        # loss
+        losses = self.loss_by_feat(all_mask_logits, all_mask_props,
+                                   batch_gt_instances)
+
+        return losses
+
+    def loss_by_feat(
+            self, all_cls_scores: Tensor, all_mask_preds: Tensor,
+            batch_gt_instances: List[InstanceData]) -> Dict[str, Tensor]:
+        """Loss function.
+
+        Args:
+            all_cls_scores (Tensor): Classification scores for all decoder
+                layers with shape (num_decoder, batch_size, num_queries,
+                cls_out_channels). Note `cls_out_channels` should includes
+                background.
+            all_mask_preds (Tensor): Mask scores for all decoder layers with
+                shape (num_decoder, batch_size, num_queries, h, w).
+            batch_gt_instances (list[obj:`InstanceData`]): each contains
+                ``labels`` and ``masks``.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        num_dec_layers = len(all_cls_scores)
+        batch_gt_instances_list = [
+            batch_gt_instances for _ in range(num_dec_layers)
+        ]
+
+        losses = []
+        for i in range(num_dec_layers):
+            cls_scores = all_cls_scores[i]
+            mask_preds = all_mask_preds[i]
+            # matching N mask predictions to K category labels
+            (labels, mask_targets, mask_weights,
+             avg_factor) = self.match_masks.get_targets(
+                 cls_scores, mask_preds, batch_gt_instances_list[i])
+            cls_scores = cls_scores.flatten(0, 1)
+            labels = labels.flatten(0, 1)
+            num_total_masks = cls_scores.new_tensor([avg_factor],
+                                                    dtype=torch.float)
+            all_reduce(num_total_masks, op='mean')
+            num_total_masks = max(num_total_masks, 1)
+
+            # extract positive ones
+            # shape (batch_size, num_queries, h, w) -> (num_total_gts, h, w)
+            mask_preds = mask_preds[mask_weights > 0]
+
+            if mask_targets.shape[0] != 0:
+                with torch.no_grad():
+                    points_coords = get_uncertain_point_coords_with_randomness(
+                        mask_preds.unsqueeze(1), None,
+                        self.train_cfg.num_points,
+                        self.train_cfg.oversample_ratio,
+                        self.train_cfg.importance_sample_ratio)
+                    # shape (num_total_gts, h, w)
+                    # -> (num_total_gts, num_points)
+                    mask_point_targets = point_sample(
+                        mask_targets.unsqueeze(1).float(),
+                        points_coords).squeeze(1)
+                # shape (num_queries, h, w) -> (num_queries, num_points)
+                mask_point_preds = point_sample(
+                    mask_preds.unsqueeze(1), points_coords).squeeze(1)
+
+            if not isinstance(self.loss_decode, nn.ModuleList):
+                losses_decode = [self.loss_decode]
+            else:
+                losses_decode = self.loss_decode
+            loss = dict()
+            for loss_decode in losses_decode:
+                if 'loss_cls' in loss_decode.loss_name:
+                    if loss_decode.loss_name == 'loss_cls_ce':
+                        loss[loss_decode.loss_name] = loss_decode(
+                            cls_scores, labels)
+                    else:
+                        assert False, "Only support 'CrossEntropyLoss' in" \
+                                      ' classification loss'
+
+                elif 'loss_mask' in loss_decode.loss_name:
+                    if mask_targets.shape[0] == 0:
+                        loss[loss_decode.loss_name] = mask_preds.sum()
+                    elif loss_decode.loss_name == 'loss_mask_ce':
+                        loss[loss_decode.loss_name] = loss_decode(
+                            mask_point_preds,
+                            mask_point_targets,
+                            avg_factor=num_total_masks *
+                            self.train_cfg.num_points)
+                    elif loss_decode.loss_name == 'loss_mask_dice':
+                        loss[loss_decode.loss_name] = loss_decode(
+                            mask_point_preds,
+                            mask_point_targets,
+                            avg_factor=num_total_masks)
+                    else:
+                        assert False, "Only support 'CrossEntropyLoss' and" \
+                                      " 'DiceLoss' in mask loss"
+                else:
+                    assert False, "Only support for 'loss_cls' and 'loss_mask'"
+
+            losses.append(loss)
+
+        loss_dict = dict()
+        # loss from the last decoder layer
+        loss_dict.update(losses[-1])
+        # loss from other decoder layers
+        for i, loss in enumerate(losses[:-1]):
+            for k, v in loss.items():
+                loss_dict[f'd{self.deep_supervision_idxs[i]}.{k}'] = v
+        return loss_dict
diff --git a/mmsegmentation/mmseg/models/decode_heads/segformer_head.py b/mmsegmentation/mmseg/models/decode_heads/segformer_head.py
new file mode 100644
index 0000000..f9eb0b3
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/segformer_head.py
@@ -0,0 +1,66 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+
+from mmseg.models.decode_heads.decode_head import BaseDecodeHead
+from mmseg.registry import MODELS
+from ..utils import resize
+
+
+@MODELS.register_module()
+class SegformerHead(BaseDecodeHead):
+    """The all mlp Head of segformer.
+
+    This head is the implementation of
+    `Segformer <https://arxiv.org/abs/2105.15203>` _.
+
+    Args:
+        interpolate_mode: The interpolate mode of MLP head upsample operation.
+            Default: 'bilinear'.
+    """
+
+    def __init__(self, interpolate_mode='bilinear', **kwargs):
+        super().__init__(input_transform='multiple_select', **kwargs)
+
+        self.interpolate_mode = interpolate_mode
+        num_inputs = len(self.in_channels)
+
+        assert num_inputs == len(self.in_index)
+
+        self.convs = nn.ModuleList()
+        for i in range(num_inputs):
+            self.convs.append(
+                ConvModule(
+                    in_channels=self.in_channels[i],
+                    out_channels=self.channels,
+                    kernel_size=1,
+                    stride=1,
+                    norm_cfg=self.norm_cfg,
+                    act_cfg=self.act_cfg))
+
+        self.fusion_conv = ConvModule(
+            in_channels=self.channels * num_inputs,
+            out_channels=self.channels,
+            kernel_size=1,
+            norm_cfg=self.norm_cfg)
+
+    def forward(self, inputs):
+        # Receive 4 stage backbone feature map: 1/4, 1/8, 1/16, 1/32
+        inputs = self._transform_inputs(inputs)
+        outs = []
+        for idx in range(len(inputs)):
+            x = inputs[idx]
+            conv = self.convs[idx]
+            outs.append(
+                resize(
+                    input=conv(x),
+                    size=inputs[0].shape[2:],
+                    mode=self.interpolate_mode,
+                    align_corners=self.align_corners))
+
+        out = self.fusion_conv(torch.cat(outs, dim=1))
+
+        out = self.cls_seg(out)
+
+        return out
diff --git a/mmsegmentation/mmseg/models/decode_heads/segmenter_mask_head.py b/mmsegmentation/mmseg/models/decode_heads/segmenter_mask_head.py
new file mode 100644
index 0000000..85d2773
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/segmenter_mask_head.py
@@ -0,0 +1,132 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import build_norm_layer
+from mmengine.model import ModuleList
+from mmengine.model.weight_init import (constant_init, trunc_normal_,
+                                        trunc_normal_init)
+
+from mmseg.models.backbones.vit import TransformerEncoderLayer
+from mmseg.registry import MODELS
+from .decode_head import BaseDecodeHead
+
+
+@MODELS.register_module()
+class SegmenterMaskTransformerHead(BaseDecodeHead):
+    """Segmenter: Transformer for Semantic Segmentation.
+
+    This head is the implementation of
+    `Segmenter: <https://arxiv.org/abs/2105.05633>`_.
+
+    Args:
+        backbone_cfg:(dict): Config of backbone of
+            Context Path.
+        in_channels (int): The number of channels of input image.
+        num_layers (int): The depth of transformer.
+        num_heads (int): The number of attention heads.
+        embed_dims (int): The number of embedding dimension.
+        mlp_ratio (int): ratio of mlp hidden dim to embedding dim.
+            Default: 4.
+        drop_path_rate (float): stochastic depth rate. Default 0.1.
+        drop_rate (float): Probability of an element to be zeroed.
+            Default 0.0
+        attn_drop_rate (float): The drop out rate for attention layer.
+            Default 0.0
+        num_fcs (int): The number of fully-connected layers for FFNs.
+            Default: 2.
+        qkv_bias (bool): Enable bias for qkv if True. Default: True.
+        act_cfg (dict): The activation config for FFNs.
+            Default: dict(type='GELU').
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='LN')
+        init_std (float): The value of std in weight initialization.
+            Default: 0.02.
+    """
+
+    def __init__(
+            self,
+            in_channels,
+            num_layers,
+            num_heads,
+            embed_dims,
+            mlp_ratio=4,
+            drop_path_rate=0.1,
+            drop_rate=0.0,
+            attn_drop_rate=0.0,
+            num_fcs=2,
+            qkv_bias=True,
+            act_cfg=dict(type='GELU'),
+            norm_cfg=dict(type='LN'),
+            init_std=0.02,
+            **kwargs,
+    ):
+        super().__init__(in_channels=in_channels, **kwargs)
+
+        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, num_layers)]
+        self.layers = ModuleList()
+        for i in range(num_layers):
+            self.layers.append(
+                TransformerEncoderLayer(
+                    embed_dims=embed_dims,
+                    num_heads=num_heads,
+                    feedforward_channels=mlp_ratio * embed_dims,
+                    attn_drop_rate=attn_drop_rate,
+                    drop_rate=drop_rate,
+                    drop_path_rate=dpr[i],
+                    num_fcs=num_fcs,
+                    qkv_bias=qkv_bias,
+                    act_cfg=act_cfg,
+                    norm_cfg=norm_cfg,
+                    batch_first=True,
+                ))
+
+        self.dec_proj = nn.Linear(in_channels, embed_dims)
+
+        self.cls_emb = nn.Parameter(
+            torch.randn(1, self.num_classes, embed_dims))
+        self.patch_proj = nn.Linear(embed_dims, embed_dims, bias=False)
+        self.classes_proj = nn.Linear(embed_dims, embed_dims, bias=False)
+
+        self.decoder_norm = build_norm_layer(
+            norm_cfg, embed_dims, postfix=1)[1]
+        self.mask_norm = build_norm_layer(
+            norm_cfg, self.num_classes, postfix=2)[1]
+
+        self.init_std = init_std
+
+        delattr(self, 'conv_seg')
+
+    def init_weights(self):
+        trunc_normal_(self.cls_emb, std=self.init_std)
+        trunc_normal_init(self.patch_proj, std=self.init_std)
+        trunc_normal_init(self.classes_proj, std=self.init_std)
+        for n, m in self.named_modules():
+            if isinstance(m, nn.Linear):
+                trunc_normal_init(m, std=self.init_std, bias=0)
+            elif isinstance(m, nn.LayerNorm):
+                constant_init(m, val=1.0, bias=0.0)
+
+    def forward(self, inputs):
+        x = self._transform_inputs(inputs)
+        b, c, h, w = x.shape
+        x = x.permute(0, 2, 3, 1).contiguous().view(b, -1, c)
+
+        x = self.dec_proj(x)
+        cls_emb = self.cls_emb.expand(x.size(0), -1, -1)
+        x = torch.cat((x, cls_emb), 1)
+        for layer in self.layers:
+            x = layer(x)
+        x = self.decoder_norm(x)
+
+        patches = self.patch_proj(x[:, :-self.num_classes])
+        cls_seg_feat = self.classes_proj(x[:, -self.num_classes:])
+
+        patches = F.normalize(patches, dim=2, p=2)
+        cls_seg_feat = F.normalize(cls_seg_feat, dim=2, p=2)
+
+        masks = patches @ cls_seg_feat.transpose(1, 2)
+        masks = self.mask_norm(masks)
+        masks = masks.permute(0, 2, 1).contiguous().view(b, -1, h, w)
+
+        return masks
diff --git a/mmsegmentation/mmseg/models/decode_heads/sep_aspp_head.py b/mmsegmentation/mmseg/models/decode_heads/sep_aspp_head.py
new file mode 100644
index 0000000..9dba68c
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/sep_aspp_head.py
@@ -0,0 +1,102 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule, DepthwiseSeparableConvModule
+
+from mmseg.registry import MODELS
+from ..utils import resize
+from .aspp_head import ASPPHead, ASPPModule
+
+
+class DepthwiseSeparableASPPModule(ASPPModule):
+    """Atrous Spatial Pyramid Pooling (ASPP) Module with depthwise separable
+    conv."""
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        for i, dilation in enumerate(self.dilations):
+            if dilation > 1:
+                self[i] = DepthwiseSeparableConvModule(
+                    self.in_channels,
+                    self.channels,
+                    3,
+                    dilation=dilation,
+                    padding=dilation,
+                    norm_cfg=self.norm_cfg,
+                    act_cfg=self.act_cfg)
+
+
+@MODELS.register_module()
+class DepthwiseSeparableASPPHead(ASPPHead):
+    """Encoder-Decoder with Atrous Separable Convolution for Semantic Image
+    Segmentation.
+
+    This head is the implementation of `DeepLabV3+
+    <https://arxiv.org/abs/1802.02611>`_.
+
+    Args:
+        c1_in_channels (int): The input channels of c1 decoder. If is 0,
+            the no decoder will be used.
+        c1_channels (int): The intermediate channels of c1 decoder.
+    """
+
+    def __init__(self, c1_in_channels, c1_channels, **kwargs):
+        super().__init__(**kwargs)
+        assert c1_in_channels >= 0
+        self.aspp_modules = DepthwiseSeparableASPPModule(
+            dilations=self.dilations,
+            in_channels=self.in_channels,
+            channels=self.channels,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+        if c1_in_channels > 0:
+            self.c1_bottleneck = ConvModule(
+                c1_in_channels,
+                c1_channels,
+                1,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg)
+        else:
+            self.c1_bottleneck = None
+        self.sep_bottleneck = nn.Sequential(
+            DepthwiseSeparableConvModule(
+                self.channels + c1_channels,
+                self.channels,
+                3,
+                padding=1,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg),
+            DepthwiseSeparableConvModule(
+                self.channels,
+                self.channels,
+                3,
+                padding=1,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg))
+
+    def forward(self, inputs):
+        """Forward function."""
+        x = self._transform_inputs(inputs)
+        aspp_outs = [
+            resize(
+                self.image_pool(x),
+                size=x.size()[2:],
+                mode='bilinear',
+                align_corners=self.align_corners)
+        ]
+        aspp_outs.extend(self.aspp_modules(x))
+        aspp_outs = torch.cat(aspp_outs, dim=1)
+        output = self.bottleneck(aspp_outs)
+        if self.c1_bottleneck is not None:
+            c1_output = self.c1_bottleneck(inputs[0])
+            output = resize(
+                input=output,
+                size=c1_output.shape[2:],
+                mode='bilinear',
+                align_corners=self.align_corners)
+            output = torch.cat([output, c1_output], dim=1)
+        output = self.sep_bottleneck(output)
+        output = self.cls_seg(output)
+        return output
diff --git a/mmsegmentation/mmseg/models/decode_heads/sep_fcn_head.py b/mmsegmentation/mmseg/models/decode_heads/sep_fcn_head.py
new file mode 100644
index 0000000..3b15983
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/sep_fcn_head.py
@@ -0,0 +1,60 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.cnn import DepthwiseSeparableConvModule
+
+from mmseg.registry import MODELS
+from .fcn_head import FCNHead
+
+
+@MODELS.register_module()
+class DepthwiseSeparableFCNHead(FCNHead):
+    """Depthwise-Separable Fully Convolutional Network for Semantic
+    Segmentation.
+
+    This head is implemented according to `Fast-SCNN: Fast Semantic
+    Segmentation Network <https://arxiv.org/abs/1902.04502>`_.
+
+    Args:
+        in_channels(int): Number of output channels of FFM.
+        channels(int): Number of middle-stage channels in the decode head.
+        concat_input(bool): Whether to concatenate original decode input into
+            the result of several consecutive convolution layers.
+            Default: True.
+        num_classes(int): Used to determine the dimension of
+            final prediction tensor.
+        in_index(int): Correspond with 'out_indices' in FastSCNN backbone.
+        norm_cfg (dict | None): Config of norm layers.
+        align_corners (bool): align_corners argument of F.interpolate.
+            Default: False.
+        loss_decode(dict): Config of loss type and some
+            relevant additional options.
+        dw_act_cfg (dict):Activation config of depthwise ConvModule. If it is
+            'default', it will be the same as `act_cfg`. Default: None.
+    """
+
+    def __init__(self, dw_act_cfg=None, **kwargs):
+        super().__init__(**kwargs)
+        self.convs[0] = DepthwiseSeparableConvModule(
+            self.in_channels,
+            self.channels,
+            kernel_size=self.kernel_size,
+            padding=self.kernel_size // 2,
+            norm_cfg=self.norm_cfg,
+            dw_act_cfg=dw_act_cfg)
+
+        for i in range(1, self.num_convs):
+            self.convs[i] = DepthwiseSeparableConvModule(
+                self.channels,
+                self.channels,
+                kernel_size=self.kernel_size,
+                padding=self.kernel_size // 2,
+                norm_cfg=self.norm_cfg,
+                dw_act_cfg=dw_act_cfg)
+
+        if self.concat_input:
+            self.conv_cat = DepthwiseSeparableConvModule(
+                self.in_channels + self.channels,
+                self.channels,
+                kernel_size=self.kernel_size,
+                padding=self.kernel_size // 2,
+                norm_cfg=self.norm_cfg,
+                dw_act_cfg=dw_act_cfg)
diff --git a/mmsegmentation/mmseg/models/decode_heads/setr_mla_head.py b/mmsegmentation/mmseg/models/decode_heads/setr_mla_head.py
new file mode 100644
index 0000000..1975991
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/setr_mla_head.py
@@ -0,0 +1,62 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+
+from mmseg.registry import MODELS
+from ..utils import Upsample
+from .decode_head import BaseDecodeHead
+
+
+@MODELS.register_module()
+class SETRMLAHead(BaseDecodeHead):
+    """Multi level feature aggretation head of SETR.
+
+    MLA head of `SETR  <https://arxiv.org/pdf/2012.15840.pdf>`_.
+
+    Args:
+        mlahead_channels (int): Channels of conv-conv-4x of multi-level feature
+            aggregation. Default: 128.
+        up_scale (int): The scale factor of interpolate. Default:4.
+    """
+
+    def __init__(self, mla_channels=128, up_scale=4, **kwargs):
+        super().__init__(input_transform='multiple_select', **kwargs)
+        self.mla_channels = mla_channels
+
+        num_inputs = len(self.in_channels)
+
+        # Refer to self.cls_seg settings of BaseDecodeHead
+        assert self.channels == num_inputs * mla_channels
+
+        self.up_convs = nn.ModuleList()
+        for i in range(num_inputs):
+            self.up_convs.append(
+                nn.Sequential(
+                    ConvModule(
+                        in_channels=self.in_channels[i],
+                        out_channels=mla_channels,
+                        kernel_size=3,
+                        padding=1,
+                        norm_cfg=self.norm_cfg,
+                        act_cfg=self.act_cfg),
+                    ConvModule(
+                        in_channels=mla_channels,
+                        out_channels=mla_channels,
+                        kernel_size=3,
+                        padding=1,
+                        norm_cfg=self.norm_cfg,
+                        act_cfg=self.act_cfg),
+                    Upsample(
+                        scale_factor=up_scale,
+                        mode='bilinear',
+                        align_corners=self.align_corners)))
+
+    def forward(self, inputs):
+        inputs = self._transform_inputs(inputs)
+        outs = []
+        for x, up_conv in zip(inputs, self.up_convs):
+            outs.append(up_conv(x))
+        out = torch.cat(outs, dim=1)
+        out = self.cls_seg(out)
+        return out
diff --git a/mmsegmentation/mmseg/models/decode_heads/setr_up_head.py b/mmsegmentation/mmseg/models/decode_heads/setr_up_head.py
new file mode 100644
index 0000000..9c796d8
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/setr_up_head.py
@@ -0,0 +1,81 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch.nn as nn
+from mmcv.cnn import ConvModule, build_norm_layer
+
+from mmseg.registry import MODELS
+from ..utils import Upsample
+from .decode_head import BaseDecodeHead
+
+
+@MODELS.register_module()
+class SETRUPHead(BaseDecodeHead):
+    """Naive upsampling head and Progressive upsampling head of SETR.
+
+    Naive or PUP head of `SETR  <https://arxiv.org/pdf/2012.15840.pdf>`_.
+
+    Args:
+        norm_layer (dict): Config dict for input normalization.
+            Default: norm_layer=dict(type='LN', eps=1e-6, requires_grad=True).
+        num_convs (int): Number of decoder convolutions. Default: 1.
+        up_scale (int): The scale factor of interpolate. Default:4.
+        kernel_size (int): The kernel size of convolution when decoding
+            feature information from backbone. Default: 3.
+        init_cfg (dict | list[dict] | None): Initialization config dict.
+            Default: dict(
+                     type='Constant', val=1.0, bias=0, layer='LayerNorm').
+    """
+
+    def __init__(self,
+                 norm_layer=dict(type='LN', eps=1e-6, requires_grad=True),
+                 num_convs=1,
+                 up_scale=4,
+                 kernel_size=3,
+                 init_cfg=[
+                     dict(type='Constant', val=1.0, bias=0, layer='LayerNorm'),
+                     dict(
+                         type='Normal',
+                         std=0.01,
+                         override=dict(name='conv_seg'))
+                 ],
+                 **kwargs):
+
+        assert kernel_size in [1, 3], 'kernel_size must be 1 or 3.'
+
+        super().__init__(init_cfg=init_cfg, **kwargs)
+
+        assert isinstance(self.in_channels, int)
+
+        _, self.norm = build_norm_layer(norm_layer, self.in_channels)
+
+        self.up_convs = nn.ModuleList()
+        in_channels = self.in_channels
+        out_channels = self.channels
+        for _ in range(num_convs):
+            self.up_convs.append(
+                nn.Sequential(
+                    ConvModule(
+                        in_channels=in_channels,
+                        out_channels=out_channels,
+                        kernel_size=kernel_size,
+                        stride=1,
+                        padding=int(kernel_size - 1) // 2,
+                        norm_cfg=self.norm_cfg,
+                        act_cfg=self.act_cfg),
+                    Upsample(
+                        scale_factor=up_scale,
+                        mode='bilinear',
+                        align_corners=self.align_corners)))
+            in_channels = out_channels
+
+    def forward(self, x):
+        x = self._transform_inputs(x)
+
+        n, c, h, w = x.shape
+        x = x.reshape(n, c, h * w).transpose(2, 1).contiguous()
+        x = self.norm(x)
+        x = x.transpose(1, 2).reshape(n, c, h, w).contiguous()
+
+        for up_conv in self.up_convs:
+            x = up_conv(x)
+        out = self.cls_seg(x)
+        return out
diff --git a/mmsegmentation/mmseg/models/decode_heads/stdc_head.py b/mmsegmentation/mmseg/models/decode_heads/stdc_head.py
new file mode 100644
index 0000000..1c1c21e
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/stdc_head.py
@@ -0,0 +1,97 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn.functional as F
+from mmengine.structures import PixelData
+from torch import Tensor
+
+from mmseg.registry import MODELS
+from mmseg.structures import SegDataSample
+from mmseg.utils import SampleList
+from .fcn_head import FCNHead
+
+
+@MODELS.register_module()
+class STDCHead(FCNHead):
+    """This head is the implementation of `Rethinking BiSeNet For Real-time
+    Semantic Segmentation <https://arxiv.org/abs/2104.13188>`_.
+
+    Args:
+        boundary_threshold (float): The threshold of calculating boundary.
+            Default: 0.1.
+    """
+
+    def __init__(self, boundary_threshold=0.1, **kwargs):
+        super().__init__(**kwargs)
+        self.boundary_threshold = boundary_threshold
+        # Using register buffer to make laplacian kernel on the same
+        # device of `seg_label`.
+        self.register_buffer(
+            'laplacian_kernel',
+            torch.tensor([-1, -1, -1, -1, 8, -1, -1, -1, -1],
+                         dtype=torch.float32,
+                         requires_grad=False).reshape((1, 1, 3, 3)))
+        self.fusion_kernel = torch.nn.Parameter(
+            torch.tensor([[6. / 10], [3. / 10], [1. / 10]],
+                         dtype=torch.float32).reshape(1, 3, 1, 1),
+            requires_grad=False)
+
+    def loss_by_feat(self, seg_logits: Tensor,
+                     batch_data_samples: SampleList) -> dict:
+        """Compute Detail Aggregation Loss."""
+        # Note: The paper claims `fusion_kernel` is a trainable 1x1 conv
+        # parameters. However, it is a constant in original repo and other
+        # codebase because it would not be added into computation graph
+        # after threshold operation.
+        seg_label = self._stack_batch_gt(batch_data_samples).to(
+            self.laplacian_kernel)
+        boundary_targets = F.conv2d(
+            seg_label, self.laplacian_kernel, padding=1)
+        boundary_targets = boundary_targets.clamp(min=0)
+        boundary_targets[boundary_targets > self.boundary_threshold] = 1
+        boundary_targets[boundary_targets <= self.boundary_threshold] = 0
+
+        boundary_targets_x2 = F.conv2d(
+            seg_label, self.laplacian_kernel, stride=2, padding=1)
+        boundary_targets_x2 = boundary_targets_x2.clamp(min=0)
+
+        boundary_targets_x4 = F.conv2d(
+            seg_label, self.laplacian_kernel, stride=4, padding=1)
+        boundary_targets_x4 = boundary_targets_x4.clamp(min=0)
+
+        boundary_targets_x4_up = F.interpolate(
+            boundary_targets_x4, boundary_targets.shape[2:], mode='nearest')
+        boundary_targets_x2_up = F.interpolate(
+            boundary_targets_x2, boundary_targets.shape[2:], mode='nearest')
+
+        boundary_targets_x2_up[
+            boundary_targets_x2_up > self.boundary_threshold] = 1
+        boundary_targets_x2_up[
+            boundary_targets_x2_up <= self.boundary_threshold] = 0
+
+        boundary_targets_x4_up[
+            boundary_targets_x4_up > self.boundary_threshold] = 1
+        boundary_targets_x4_up[
+            boundary_targets_x4_up <= self.boundary_threshold] = 0
+
+        boundary_targets_pyramids = torch.stack(
+            (boundary_targets, boundary_targets_x2_up, boundary_targets_x4_up),
+            dim=1)
+
+        boundary_targets_pyramids = boundary_targets_pyramids.squeeze(2)
+        boudary_targets_pyramid = F.conv2d(boundary_targets_pyramids,
+                                           self.fusion_kernel)
+
+        boudary_targets_pyramid[
+            boudary_targets_pyramid > self.boundary_threshold] = 1
+        boudary_targets_pyramid[
+            boudary_targets_pyramid <= self.boundary_threshold] = 0
+
+        seg_labels = boudary_targets_pyramid.long()
+        batch_sample_list = []
+        for label in seg_labels:
+            seg_data_sample = SegDataSample()
+            seg_data_sample.gt_sem_seg = PixelData(data=label)
+            batch_sample_list.append(seg_data_sample)
+
+        loss = super().loss_by_feat(seg_logits, batch_sample_list)
+        return loss
diff --git a/mmsegmentation/mmseg/models/decode_heads/uper_head.py b/mmsegmentation/mmseg/models/decode_heads/uper_head.py
new file mode 100644
index 0000000..b1ccc31
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/uper_head.py
@@ -0,0 +1,139 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+
+from mmseg.registry import MODELS
+from ..utils import resize
+from .decode_head import BaseDecodeHead
+from .psp_head import PPM
+
+
+@MODELS.register_module()
+class UPerHead(BaseDecodeHead):
+    """Unified Perceptual Parsing for Scene Understanding.
+
+    This head is the implementation of `UPerNet
+    <https://arxiv.org/abs/1807.10221>`_.
+
+    Args:
+        pool_scales (tuple[int]): Pooling scales used in Pooling Pyramid
+            Module applied on the last feature. Default: (1, 2, 3, 6).
+    """
+
+    def __init__(self, pool_scales=(1, 2, 3, 6), **kwargs):
+        super().__init__(input_transform='multiple_select', **kwargs)
+        # PSP Module
+        self.psp_modules = PPM(
+            pool_scales,
+            self.in_channels[-1],
+            self.channels,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg,
+            align_corners=self.align_corners)
+        self.bottleneck = ConvModule(
+            self.in_channels[-1] + len(pool_scales) * self.channels,
+            self.channels,
+            3,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+        # FPN Module
+        self.lateral_convs = nn.ModuleList()
+        self.fpn_convs = nn.ModuleList()
+        for in_channels in self.in_channels[:-1]:  # skip the top layer
+            l_conv = ConvModule(
+                in_channels,
+                self.channels,
+                1,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg,
+                inplace=False)
+            fpn_conv = ConvModule(
+                self.channels,
+                self.channels,
+                3,
+                padding=1,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg,
+                inplace=False)
+            self.lateral_convs.append(l_conv)
+            self.fpn_convs.append(fpn_conv)
+
+        self.fpn_bottleneck = ConvModule(
+            len(self.in_channels) * self.channels,
+            self.channels,
+            3,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+    def psp_forward(self, inputs):
+        """Forward function of PSP module."""
+        x = inputs[-1]
+        psp_outs = [x]
+        psp_outs.extend(self.psp_modules(x))
+        psp_outs = torch.cat(psp_outs, dim=1)
+        output = self.bottleneck(psp_outs)
+
+        return output
+
+    def _forward_feature(self, inputs):
+        """Forward function for feature maps before classifying each pixel with
+        ``self.cls_seg`` fc.
+
+        Args:
+            inputs (list[Tensor]): List of multi-level img features.
+
+        Returns:
+            feats (Tensor): A tensor of shape (batch_size, self.channels,
+                H, W) which is feature map for last layer of decoder head.
+        """
+        inputs = self._transform_inputs(inputs)
+
+        # build laterals
+        laterals = [
+            lateral_conv(inputs[i])
+            for i, lateral_conv in enumerate(self.lateral_convs)
+        ]
+
+        laterals.append(self.psp_forward(inputs))
+
+        # build top-down path
+        used_backbone_levels = len(laterals)
+        for i in range(used_backbone_levels - 1, 0, -1):
+            prev_shape = laterals[i - 1].shape[2:]
+            laterals[i - 1] = laterals[i - 1] + resize(
+                laterals[i],
+                size=prev_shape,
+                mode='bilinear',
+                align_corners=self.align_corners)
+
+        # build outputs
+        fpn_outs = [
+            self.fpn_convs[i](laterals[i])
+            for i in range(used_backbone_levels - 1)
+        ]
+        # append psp feature
+        fpn_outs.append(laterals[-1])
+
+        for i in range(used_backbone_levels - 1, 0, -1):
+            fpn_outs[i] = resize(
+                fpn_outs[i],
+                size=fpn_outs[0].shape[2:],
+                mode='bilinear',
+                align_corners=self.align_corners)
+        fpn_outs = torch.cat(fpn_outs, dim=1)
+        feats = self.fpn_bottleneck(fpn_outs)
+        return feats
+
+    def forward(self, inputs):
+        """Forward function."""
+        output = self._forward_feature(inputs)
+        output = self.cls_seg(output)
+        return output
diff --git a/mmsegmentation/mmseg/models/decode_heads/vpd_depth_head.py b/mmsegmentation/mmseg/models/decode_heads/vpd_depth_head.py
new file mode 100644
index 0000000..65bdfbd
--- /dev/null
+++ b/mmsegmentation/mmseg/models/decode_heads/vpd_depth_head.py
@@ -0,0 +1,253 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, List, Optional, Sequence, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import build_conv_layer, build_norm_layer, build_upsample_layer
+from mmengine.model import BaseModule
+from torch import Tensor
+
+from mmseg.registry import MODELS
+from mmseg.utils import SampleList
+from ..utils import resize
+from .decode_head import BaseDecodeHead
+
+
+class VPDDepthDecoder(BaseModule):
+    """VPD Depth Decoder class.
+
+    Args:
+        in_channels (int): Number of input channels.
+        out_channels (int): Number of output channels.
+        num_deconv_layers (int): Number of deconvolution layers.
+        num_deconv_filters (List[int]): List of output channels for
+            deconvolution layers.
+        init_cfg (Optional[Union[Dict, List[Dict]]], optional): Configuration
+            for weight initialization. Defaults to Normal for Conv2d and
+            ConvTranspose2d layers.
+    """
+
+    def __init__(self,
+                 in_channels: int,
+                 out_channels: int,
+                 num_deconv_layers: int,
+                 num_deconv_filters: List[int],
+                 init_cfg: Optional[Union[Dict, List[Dict]]] = dict(
+                     type='Normal',
+                     std=0.001,
+                     layer=['Conv2d', 'ConvTranspose2d'])):
+        super().__init__(init_cfg=init_cfg)
+        self.in_channels = in_channels
+
+        self.deconv_layers = self._make_deconv_layer(
+            num_deconv_layers,
+            num_deconv_filters,
+        )
+
+        conv_layers = []
+        conv_layers.append(
+            build_conv_layer(
+                dict(type='Conv2d'),
+                in_channels=num_deconv_filters[-1],
+                out_channels=out_channels,
+                kernel_size=3,
+                stride=1,
+                padding=1))
+        conv_layers.append(build_norm_layer(dict(type='BN'), out_channels)[1])
+        conv_layers.append(nn.ReLU(inplace=True))
+        self.conv_layers = nn.Sequential(*conv_layers)
+
+        self.up_sample = nn.Upsample(
+            scale_factor=2, mode='bilinear', align_corners=False)
+
+    def forward(self, x):
+        """Forward pass through the decoder network."""
+        out = self.deconv_layers(x)
+        out = self.conv_layers(out)
+
+        out = self.up_sample(out)
+        out = self.up_sample(out)
+
+        return out
+
+    def _make_deconv_layer(self, num_layers, num_deconv_filters):
+        """Make deconv layers."""
+
+        layers = []
+        in_channels = self.in_channels
+        for i in range(num_layers):
+
+            num_channels = num_deconv_filters[i]
+            layers.append(
+                build_upsample_layer(
+                    dict(type='deconv'),
+                    in_channels=in_channels,
+                    out_channels=num_channels,
+                    kernel_size=2,
+                    stride=2,
+                    padding=0,
+                    output_padding=0,
+                    bias=False))
+            layers.append(nn.BatchNorm2d(num_channels))
+            layers.append(nn.ReLU(inplace=True))
+            in_channels = num_channels
+
+        return nn.Sequential(*layers)
+
+
+@MODELS.register_module()
+class VPDDepthHead(BaseDecodeHead):
+    """Depth Prediction Head for VPD.
+
+    .. _`VPD`: https://arxiv.org/abs/2303.02153
+
+    Args:
+        max_depth (float): Maximum depth value. Defaults to 10.0.
+        in_channels (Sequence[int]): Number of input channels for each
+            convolutional layer.
+        embed_dim (int): Dimension of embedding. Defaults to 192.
+        feature_dim (int): Dimension of aggregated feature. Defaults to 1536.
+        num_deconv_layers (int): Number of deconvolution layers in the
+            decoder. Defaults to 3.
+        num_deconv_filters (Sequence[int]): Number of filters for each deconv
+            layer. Defaults to (32, 32, 32).
+        fmap_border (Union[int, Sequence[int]]): Feature map border for
+            cropping. Defaults to 0.
+        align_corners (bool): Flag for align_corners in interpolation.
+            Defaults to False.
+        loss_decode (dict): Configurations for the loss function. Defaults to
+            dict(type='SiLogLoss').
+        init_cfg (dict): Initialization configurations. Defaults to
+            dict(type='TruncNormal', std=0.02, layer=['Conv2d', 'Linear']).
+    """
+
+    num_classes = 1
+    out_channels = 1
+    input_transform = None
+
+    def __init__(
+        self,
+        max_depth: float = 10.0,
+        in_channels: Sequence[int] = [320, 640, 1280, 1280],
+        embed_dim: int = 192,
+        feature_dim: int = 1536,
+        num_deconv_layers: int = 3,
+        num_deconv_filters: Sequence[int] = (32, 32, 32),
+        fmap_border: Union[int, Sequence[int]] = 0,
+        align_corners: bool = False,
+        loss_decode: dict = dict(type='SiLogLoss'),
+        init_cfg=dict(
+            type='TruncNormal', std=0.02, layer=['Conv2d', 'Linear']),
+    ):
+
+        super(BaseDecodeHead, self).__init__(init_cfg=init_cfg)
+
+        # initialize parameters
+        self.in_channels = in_channels
+        self.max_depth = max_depth
+        self.align_corners = align_corners
+
+        # feature map border
+        if isinstance(fmap_border, int):
+            fmap_border = (fmap_border, fmap_border)
+        self.fmap_border = fmap_border
+
+        # define network layers
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(in_channels[0], in_channels[0], 3, stride=2, padding=1),
+            nn.GroupNorm(16, in_channels[0]),
+            nn.ReLU(),
+            nn.Conv2d(in_channels[0], in_channels[0], 3, stride=2, padding=1),
+        )
+        self.conv2 = nn.Conv2d(
+            in_channels[1], in_channels[1], 3, stride=2, padding=1)
+
+        self.conv_aggregation = nn.Sequential(
+            nn.Conv2d(sum(in_channels), feature_dim, 1),
+            nn.GroupNorm(16, feature_dim),
+            nn.ReLU(),
+        )
+
+        self.decoder = VPDDepthDecoder(
+            in_channels=embed_dim * 8,
+            out_channels=embed_dim,
+            num_deconv_layers=num_deconv_layers,
+            num_deconv_filters=num_deconv_filters)
+
+        self.depth_pred_layer = nn.Sequential(
+            nn.Conv2d(
+                embed_dim, embed_dim, kernel_size=3, stride=1, padding=1),
+            nn.ReLU(inplace=False),
+            nn.Conv2d(embed_dim, 1, kernel_size=3, stride=1, padding=1))
+
+        # build loss
+        if isinstance(loss_decode, dict):
+            self.loss_decode = MODELS.build(loss_decode)
+        elif isinstance(loss_decode, (list, tuple)):
+            self.loss_decode = nn.ModuleList()
+            for loss in loss_decode:
+                self.loss_decode.append(MODELS.build(loss))
+        else:
+            raise TypeError(f'loss_decode must be a dict or sequence of dict,\
+                but got {type(loss_decode)}')
+
+    def _stack_batch_gt(self, batch_data_samples: SampleList) -> Tensor:
+        gt_depth_maps = [
+            data_sample.gt_depth_map.data for data_sample in batch_data_samples
+        ]
+        return torch.stack(gt_depth_maps, dim=0)
+
+    def forward(self, x):
+        x = [
+            x[0], x[1],
+            torch.cat([x[2], F.interpolate(x[3], scale_factor=2)], dim=1)
+        ]
+        x = torch.cat([self.conv1(x[0]), self.conv2(x[1]), x[2]], dim=1)
+        x = self.conv_aggregation(x)
+
+        x = x[:, :, :x.size(2) - self.fmap_border[0], :x.size(3) -
+              self.fmap_border[1]].contiguous()
+        x = self.decoder(x)
+        out = self.depth_pred_layer(x)
+
+        depth = torch.sigmoid(out) * self.max_depth
+
+        return depth
+
+    def loss_by_feat(self, pred_depth_map: Tensor,
+                     batch_data_samples: SampleList) -> dict:
+        """Compute depth estimation loss.
+
+        Args:
+            pred_depth_map (Tensor): The output from decode head forward
+                function.
+            batch_data_samples (List[:obj:`SegDataSample`]): The seg
+                data samples. It usually includes information such
+                as `metainfo` and `gt_dpeth_map`.
+
+        Returns:
+            dict[str, Tensor]: a dictionary of loss components
+        """
+
+        gt_depth_map = self._stack_batch_gt(batch_data_samples)
+        loss = dict()
+        pred_depth_map = resize(
+            input=pred_depth_map,
+            size=gt_depth_map.shape[2:],
+            mode='bilinear',
+            align_corners=self.align_corners)
+
+        if not isinstance(self.loss_decode, nn.ModuleList):
+            losses_decode = [self.loss_decode]
+        else:
+            losses_decode = self.loss_decode
+        for loss_decode in losses_decode:
+            if loss_decode.loss_name not in loss:
+                loss[loss_decode.loss_name] = loss_decode(
+                    pred_depth_map, gt_depth_map)
+            else:
+                loss[loss_decode.loss_name] += loss_decode(
+                    pred_depth_map, gt_depth_map)
+
+        return loss
diff --git a/mmsegmentation/mmseg/models/losses/__init__.py b/mmsegmentation/mmseg/models/losses/__init__.py
new file mode 100644
index 0000000..0467cb3
--- /dev/null
+++ b/mmsegmentation/mmseg/models/losses/__init__.py
@@ -0,0 +1,21 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .accuracy import Accuracy, accuracy
+from .boundary_loss import BoundaryLoss
+from .cross_entropy_loss import (CrossEntropyLoss, binary_cross_entropy,
+                                 cross_entropy, mask_cross_entropy)
+from .dice_loss import DiceLoss
+from .focal_loss import FocalLoss
+from .huasdorff_distance_loss import HuasdorffDisstanceLoss
+from .lovasz_loss import LovaszLoss
+from .ohem_cross_entropy_loss import OhemCrossEntropy
+from .silog_loss import SiLogLoss
+from .tversky_loss import TverskyLoss
+from .utils import reduce_loss, weight_reduce_loss, weighted_loss
+
+__all__ = [
+    'accuracy', 'Accuracy', 'cross_entropy', 'binary_cross_entropy',
+    'mask_cross_entropy', 'CrossEntropyLoss', 'reduce_loss',
+    'weight_reduce_loss', 'weighted_loss', 'LovaszLoss', 'DiceLoss',
+    'FocalLoss', 'TverskyLoss', 'OhemCrossEntropy', 'BoundaryLoss',
+    'HuasdorffDisstanceLoss', 'SiLogLoss'
+]
diff --git a/mmsegmentation/mmseg/models/losses/accuracy.py b/mmsegmentation/mmseg/models/losses/accuracy.py
new file mode 100644
index 0000000..1d9e2d7
--- /dev/null
+++ b/mmsegmentation/mmseg/models/losses/accuracy.py
@@ -0,0 +1,92 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+
+
+def accuracy(pred, target, topk=1, thresh=None, ignore_index=None):
+    """Calculate accuracy according to the prediction and target.
+
+    Args:
+        pred (torch.Tensor): The model prediction, shape (N, num_class, ...)
+        target (torch.Tensor): The target of each prediction, shape (N, , ...)
+        ignore_index (int | None): The label index to be ignored. Default: None
+        topk (int | tuple[int], optional): If the predictions in ``topk``
+            matches the target, the predictions will be regarded as
+            correct ones. Defaults to 1.
+        thresh (float, optional): If not None, predictions with scores under
+            this threshold are considered incorrect. Default to None.
+
+    Returns:
+        float | tuple[float]: If the input ``topk`` is a single integer,
+            the function will return a single float as accuracy. If
+            ``topk`` is a tuple containing multiple integers, the
+            function will return a tuple containing accuracies of
+            each ``topk`` number.
+    """
+    assert isinstance(topk, (int, tuple))
+    if isinstance(topk, int):
+        topk = (topk, )
+        return_single = True
+    else:
+        return_single = False
+
+    maxk = max(topk)
+    if pred.size(0) == 0:
+        accu = [pred.new_tensor(0.) for i in range(len(topk))]
+        return accu[0] if return_single else accu
+    assert pred.ndim == target.ndim + 1
+    assert pred.size(0) == target.size(0)
+    assert maxk <= pred.size(1), \
+        f'maxk {maxk} exceeds pred dimension {pred.size(1)}'
+    pred_value, pred_label = pred.topk(maxk, dim=1)
+    # transpose to shape (maxk, N, ...)
+    pred_label = pred_label.transpose(0, 1)
+    correct = pred_label.eq(target.unsqueeze(0).expand_as(pred_label))
+    if thresh is not None:
+        # Only prediction values larger than thresh are counted as correct
+        correct = correct & (pred_value > thresh).t()
+    if ignore_index is not None:
+        correct = correct[:, target != ignore_index]
+    res = []
+    eps = torch.finfo(torch.float32).eps
+    for k in topk:
+        # Avoid causing ZeroDivisionError when all pixels
+        # of an image are ignored
+        correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True) + eps
+        if ignore_index is not None:
+            total_num = target[target != ignore_index].numel() + eps
+        else:
+            total_num = target.numel() + eps
+        res.append(correct_k.mul_(100.0 / total_num))
+    return res[0] if return_single else res
+
+
+class Accuracy(nn.Module):
+    """Accuracy calculation module."""
+
+    def __init__(self, topk=(1, ), thresh=None, ignore_index=None):
+        """Module to calculate the accuracy.
+
+        Args:
+            topk (tuple, optional): The criterion used to calculate the
+                accuracy. Defaults to (1,).
+            thresh (float, optional): If not None, predictions with scores
+                under this threshold are considered incorrect. Default to None.
+        """
+        super().__init__()
+        self.topk = topk
+        self.thresh = thresh
+        self.ignore_index = ignore_index
+
+    def forward(self, pred, target):
+        """Forward function to calculate accuracy.
+
+        Args:
+            pred (torch.Tensor): Prediction of models.
+            target (torch.Tensor): Target for each prediction.
+
+        Returns:
+            tuple[float]: The accuracies under different topk criterions.
+        """
+        return accuracy(pred, target, self.topk, self.thresh,
+                        self.ignore_index)
diff --git a/mmsegmentation/mmseg/models/losses/boundary_loss.py b/mmsegmentation/mmseg/models/losses/boundary_loss.py
new file mode 100644
index 0000000..e86b850
--- /dev/null
+++ b/mmsegmentation/mmseg/models/losses/boundary_loss.py
@@ -0,0 +1,62 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch import Tensor
+
+from mmseg.registry import MODELS
+
+
+@MODELS.register_module()
+class BoundaryLoss(nn.Module):
+    """Boundary loss.
+
+    This function is modified from
+    `PIDNet <https://github.com/XuJiacong/PIDNet/blob/main/utils/criterion.py#L122>`_.  # noqa
+    Licensed under the MIT License.
+
+
+    Args:
+        loss_weight (float): Weight of the loss. Defaults to 1.0.
+        loss_name (str): Name of the loss item. If you want this loss
+            item to be included into the backward graph, `loss_` must be the
+            prefix of the name. Defaults to 'loss_boundary'.
+    """
+
+    def __init__(self,
+                 loss_weight: float = 1.0,
+                 loss_name: str = 'loss_boundary'):
+        super().__init__()
+        self.loss_weight = loss_weight
+        self.loss_name_ = loss_name
+
+    def forward(self, bd_pre: Tensor, bd_gt: Tensor) -> Tensor:
+        """Forward function.
+        Args:
+            bd_pre (Tensor): Predictions of the boundary head.
+            bd_gt (Tensor): Ground truth of the boundary.
+
+        Returns:
+            Tensor: Loss tensor.
+        """
+        log_p = bd_pre.permute(0, 2, 3, 1).contiguous().view(1, -1)
+        target_t = bd_gt.view(1, -1).float()
+
+        pos_index = (target_t == 1)
+        neg_index = (target_t == 0)
+
+        weight = torch.zeros_like(log_p)
+        pos_num = pos_index.sum()
+        neg_num = neg_index.sum()
+        sum_num = pos_num + neg_num
+        weight[pos_index] = neg_num * 1.0 / sum_num
+        weight[neg_index] = pos_num * 1.0 / sum_num
+
+        loss = F.binary_cross_entropy_with_logits(
+            log_p, target_t, weight, reduction='mean')
+
+        return self.loss_weight * loss
+
+    @property
+    def loss_name(self):
+        return self.loss_name_
diff --git a/mmsegmentation/mmseg/models/losses/cross_entropy_loss.py b/mmsegmentation/mmseg/models/losses/cross_entropy_loss.py
new file mode 100644
index 0000000..988fb78
--- /dev/null
+++ b/mmsegmentation/mmseg/models/losses/cross_entropy_loss.py
@@ -0,0 +1,311 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from mmseg.registry import MODELS
+from .utils import get_class_weight, weight_reduce_loss
+
+
+def cross_entropy(pred,
+                  label,
+                  weight=None,
+                  class_weight=None,
+                  reduction='mean',
+                  avg_factor=None,
+                  ignore_index=-100,
+                  avg_non_ignore=False):
+    """cross_entropy. The wrapper function for :func:`F.cross_entropy`
+
+    Args:
+        pred (torch.Tensor): The prediction with shape (N, 1).
+        label (torch.Tensor): The learning label of the prediction.
+        weight (torch.Tensor, optional): Sample-wise loss weight.
+            Default: None.
+        class_weight (list[float], optional): The weight for each class.
+            Default: None.
+        reduction (str, optional): The method used to reduce the loss.
+            Options are 'none', 'mean' and 'sum'. Default: 'mean'.
+        avg_factor (int, optional): Average factor that is used to average
+            the loss. Default: None.
+        ignore_index (int): Specifies a target value that is ignored and
+            does not contribute to the input gradients. When
+            ``avg_non_ignore `` is ``True``, and the ``reduction`` is
+            ``''mean''``, the loss is averaged over non-ignored targets.
+            Defaults: -100.
+        avg_non_ignore (bool): The flag decides to whether the loss is
+            only averaged over non-ignored targets. Default: False.
+            `New in version 0.23.0.`
+    """
+
+    # class_weight is a manual rescaling weight given to each class.
+    # If given, has to be a Tensor of size C element-wise losses
+    loss = F.cross_entropy(
+        pred,
+        label,
+        weight=class_weight,
+        reduction='none',
+        ignore_index=ignore_index)
+
+    # apply weights and do the reduction
+    # average loss over non-ignored elements
+    # pytorch's official cross_entropy average loss over non-ignored elements
+    # refer to https://github.com/pytorch/pytorch/blob/56b43f4fec1f76953f15a627694d4bba34588969/torch/nn/functional.py#L2660  # noqa
+    if (avg_factor is None) and reduction == 'mean':
+        if class_weight is None:
+            if avg_non_ignore:
+                avg_factor = label.numel() - (label
+                                              == ignore_index).sum().item()
+            else:
+                avg_factor = label.numel()
+
+        else:
+            # the average factor should take the class weights into account
+            label_weights = torch.stack([class_weight[cls] for cls in label
+                                         ]).to(device=class_weight.device)
+
+            if avg_non_ignore:
+                label_weights[label == ignore_index] = 0
+            avg_factor = label_weights.sum()
+
+    if weight is not None:
+        weight = weight.float()
+    loss = weight_reduce_loss(
+        loss, weight=weight, reduction=reduction, avg_factor=avg_factor)
+
+    return loss
+
+
+def _expand_onehot_labels(labels, label_weights, target_shape, ignore_index):
+    """Expand onehot labels to match the size of prediction."""
+    bin_labels = labels.new_zeros(target_shape)
+    valid_mask = (labels >= 0) & (labels != ignore_index)
+    inds = torch.nonzero(valid_mask, as_tuple=True)
+
+    if inds[0].numel() > 0:
+        if labels.dim() == 3:
+            bin_labels[inds[0], labels[valid_mask], inds[1], inds[2]] = 1
+        else:
+            bin_labels[inds[0], labels[valid_mask]] = 1
+
+    valid_mask = valid_mask.unsqueeze(1).expand(target_shape).float()
+
+    if label_weights is None:
+        bin_label_weights = valid_mask
+    else:
+        bin_label_weights = label_weights.unsqueeze(1).expand(target_shape)
+        bin_label_weights = bin_label_weights * valid_mask
+
+    return bin_labels, bin_label_weights, valid_mask
+
+
+def binary_cross_entropy(pred,
+                         label,
+                         weight=None,
+                         reduction='mean',
+                         avg_factor=None,
+                         class_weight=None,
+                         ignore_index=-100,
+                         avg_non_ignore=False,
+                         **kwargs):
+    """Calculate the binary CrossEntropy loss.
+
+    Args:
+        pred (torch.Tensor): The prediction with shape (N, 1).
+        label (torch.Tensor): The learning label of the prediction.
+            Note: In bce loss, label < 0 is invalid.
+        weight (torch.Tensor, optional): Sample-wise loss weight.
+        reduction (str, optional): The method used to reduce the loss.
+            Options are "none", "mean" and "sum".
+        avg_factor (int, optional): Average factor that is used to average
+            the loss. Defaults to None.
+        class_weight (list[float], optional): The weight for each class.
+        ignore_index (int): The label index to be ignored. Default: -100.
+        avg_non_ignore (bool): The flag decides to whether the loss is
+            only averaged over non-ignored targets. Default: False.
+            `New in version 0.23.0.`
+
+    Returns:
+        torch.Tensor: The calculated loss
+    """
+    if pred.size(1) == 1:
+        # For binary class segmentation, the shape of pred is
+        # [N, 1, H, W] and that of label is [N, H, W].
+        # As the ignore_index often set as 255, so the
+        # binary class label check should mask out
+        # ignore_index
+        assert label[label != ignore_index].max() <= 1, \
+            'For pred with shape [N, 1, H, W], its label must have at ' \
+            'most 2 classes'
+        pred = pred.squeeze(1)
+    if pred.dim() != label.dim():
+        assert (pred.dim() == 2 and label.dim() == 1) or (
+                pred.dim() == 4 and label.dim() == 3), \
+            'Only pred shape [N, C], label shape [N] or pred shape [N, C, ' \
+            'H, W], label shape [N, H, W] are supported'
+        # `weight` returned from `_expand_onehot_labels`
+        # has been treated for valid (non-ignore) pixels
+        label, weight, valid_mask = _expand_onehot_labels(
+            label, weight, pred.shape, ignore_index)
+    else:
+        # should mask out the ignored elements
+        valid_mask = ((label >= 0) & (label != ignore_index)).float()
+        if weight is not None:
+            weight = weight * valid_mask
+        else:
+            weight = valid_mask
+    # average loss over non-ignored and valid elements
+    if reduction == 'mean' and avg_factor is None and avg_non_ignore:
+        avg_factor = valid_mask.sum().item()
+
+    loss = F.binary_cross_entropy_with_logits(
+        pred, label.float(), pos_weight=class_weight, reduction='none')
+    # do the reduction for the weighted loss
+    loss = weight_reduce_loss(
+        loss, weight, reduction=reduction, avg_factor=avg_factor)
+
+    return loss
+
+
+def mask_cross_entropy(pred,
+                       target,
+                       label,
+                       reduction='mean',
+                       avg_factor=None,
+                       class_weight=None,
+                       ignore_index=None,
+                       **kwargs):
+    """Calculate the CrossEntropy loss for masks.
+
+    Args:
+        pred (torch.Tensor): The prediction with shape (N, C), C is the number
+            of classes.
+        target (torch.Tensor): The learning label of the prediction.
+        label (torch.Tensor): ``label`` indicates the class label of the mask'
+            corresponding object. This will be used to select the mask in the
+            of the class which the object belongs to when the mask prediction
+            if not class-agnostic.
+        reduction (str, optional): The method used to reduce the loss.
+            Options are "none", "mean" and "sum".
+        avg_factor (int, optional): Average factor that is used to average
+            the loss. Defaults to None.
+        class_weight (list[float], optional): The weight for each class.
+        ignore_index (None): Placeholder, to be consistent with other loss.
+            Default: None.
+
+    Returns:
+        torch.Tensor: The calculated loss
+    """
+    assert ignore_index is None, 'BCE loss does not support ignore_index'
+    # TODO: handle these two reserved arguments
+    assert reduction == 'mean' and avg_factor is None
+    num_rois = pred.size()[0]
+    inds = torch.arange(0, num_rois, dtype=torch.long, device=pred.device)
+    pred_slice = pred[inds, label].squeeze(1)
+    return F.binary_cross_entropy_with_logits(
+        pred_slice, target, weight=class_weight, reduction='mean')[None]
+
+
+@MODELS.register_module()
+class CrossEntropyLoss(nn.Module):
+    """CrossEntropyLoss.
+
+    Args:
+        use_sigmoid (bool, optional): Whether the prediction uses sigmoid
+            of softmax. Defaults to False.
+        use_mask (bool, optional): Whether to use mask cross entropy loss.
+            Defaults to False.
+        reduction (str, optional): . Defaults to 'mean'.
+            Options are "none", "mean" and "sum".
+        class_weight (list[float] | str, optional): Weight of each class. If in
+            str format, read them from a file. Defaults to None.
+        loss_weight (float, optional): Weight of the loss. Defaults to 1.0.
+        loss_name (str, optional): Name of the loss item. If you want this loss
+            item to be included into the backward graph, `loss_` must be the
+            prefix of the name. Defaults to 'loss_ce'.
+        avg_non_ignore (bool): The flag decides to whether the loss is
+            only averaged over non-ignored targets. Default: False.
+            `New in version 0.23.0.`
+    """
+
+    def __init__(self,
+                 use_sigmoid=False,
+                 use_mask=False,
+                 reduction='mean',
+                 class_weight=None,
+                 loss_weight=1.0,
+                 loss_name='loss_ce',
+                 avg_non_ignore=False):
+        super().__init__()
+        assert (use_sigmoid is False) or (use_mask is False)
+        self.use_sigmoid = use_sigmoid
+        self.use_mask = use_mask
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+        self.class_weight = get_class_weight(class_weight)
+        self.avg_non_ignore = avg_non_ignore
+        if not self.avg_non_ignore and self.reduction == 'mean':
+            warnings.warn(
+                'Default ``avg_non_ignore`` is False, if you would like to '
+                'ignore the certain label and average loss over non-ignore '
+                'labels, which is the same with PyTorch official '
+                'cross_entropy, set ``avg_non_ignore=True``.')
+
+        if self.use_sigmoid:
+            self.cls_criterion = binary_cross_entropy
+        elif self.use_mask:
+            self.cls_criterion = mask_cross_entropy
+        else:
+            self.cls_criterion = cross_entropy
+        self._loss_name = loss_name
+
+    def extra_repr(self):
+        """Extra repr."""
+        s = f'avg_non_ignore={self.avg_non_ignore}'
+        return s
+
+    def forward(self,
+                cls_score,
+                label,
+                weight=None,
+                avg_factor=None,
+                reduction_override=None,
+                ignore_index=-100,
+                **kwargs):
+        """Forward function."""
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        if self.class_weight is not None:
+            class_weight = cls_score.new_tensor(self.class_weight)
+        else:
+            class_weight = None
+        # Note: for BCE loss, label < 0 is invalid.
+        loss_cls = self.loss_weight * self.cls_criterion(
+            cls_score,
+            label,
+            weight,
+            class_weight=class_weight,
+            reduction=reduction,
+            avg_factor=avg_factor,
+            avg_non_ignore=self.avg_non_ignore,
+            ignore_index=ignore_index,
+            **kwargs)
+        return loss_cls
+
+    @property
+    def loss_name(self):
+        """Loss Name.
+
+        This function must be implemented and will return the name of this
+        loss function. This name will be used to combine different loss items
+        by simple sum operation. In addition, if you want this loss item to be
+        included into the backward graph, `loss_` must be the prefix of the
+        name.
+
+        Returns:
+            str: The name of this loss item.
+        """
+        return self._loss_name
diff --git a/mmsegmentation/mmseg/models/losses/dice_loss.py b/mmsegmentation/mmseg/models/losses/dice_loss.py
new file mode 100644
index 0000000..fb2ffdb
--- /dev/null
+++ b/mmsegmentation/mmseg/models/losses/dice_loss.py
@@ -0,0 +1,202 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Union
+
+import torch
+import torch.nn as nn
+
+from mmseg.registry import MODELS
+from .utils import weight_reduce_loss
+
+
+def _expand_onehot_labels_dice(pred: torch.Tensor,
+                               target: torch.Tensor) -> torch.Tensor:
+    """Expand onehot labels to match the size of prediction.
+
+    Args:
+        pred (torch.Tensor): The prediction, has a shape (N, num_class, H, W).
+        target (torch.Tensor): The learning label of the prediction,
+            has a shape (N, H, W).
+
+    Returns:
+        torch.Tensor: The target after one-hot encoding,
+            has a shape (N, num_class, H, W).
+    """
+    num_classes = pred.shape[1]
+    one_hot_target = torch.clamp(target, min=0, max=num_classes)
+    one_hot_target = torch.nn.functional.one_hot(one_hot_target,
+                                                 num_classes + 1)
+    one_hot_target = one_hot_target[..., :num_classes].permute(0, 3, 1, 2)
+    return one_hot_target
+
+
+def dice_loss(pred: torch.Tensor,
+              target: torch.Tensor,
+              weight: Union[torch.Tensor, None],
+              eps: float = 1e-3,
+              reduction: Union[str, None] = 'mean',
+              naive_dice: Union[bool, None] = False,
+              avg_factor: Union[int, None] = None,
+              ignore_index: Union[int, None] = 255) -> float:
+    """Calculate dice loss, there are two forms of dice loss is supported:
+
+        - the one proposed in `V-Net: Fully Convolutional Neural
+            Networks for Volumetric Medical Image Segmentation
+            <https://arxiv.org/abs/1606.04797>`_.
+        - the dice loss in which the power of the number in the
+            denominator is the first power instead of the second
+            power.
+
+    Args:
+        pred (torch.Tensor): The prediction, has a shape (n, *)
+        target (torch.Tensor): The learning label of the prediction,
+            shape (n, *), same shape of pred.
+        weight (torch.Tensor, optional): The weight of loss for each
+            prediction, has a shape (n,). Defaults to None.
+        eps (float): Avoid dividing by zero. Default: 1e-3.
+        reduction (str, optional): The method used to reduce the loss into
+            a scalar. Defaults to 'mean'.
+            Options are "none", "mean" and "sum".
+        naive_dice (bool, optional): If false, use the dice
+            loss defined in the V-Net paper, otherwise, use the
+            naive dice loss in which the power of the number in the
+            denominator is the first power instead of the second
+            power.Defaults to False.
+        avg_factor (int, optional): Average factor that is used to average
+            the loss. Defaults to None.
+        ignore_index (int, optional): The label index to be ignored.
+            Defaults to 255.
+    """
+    if ignore_index is not None:
+        num_classes = pred.shape[1]
+        pred = pred[:, torch.arange(num_classes) != ignore_index, :, :]
+        target = target[:, torch.arange(num_classes) != ignore_index, :, :]
+        assert pred.shape[1] != 0  # if the ignored index is the only class
+    input = pred.flatten(1)
+    target = target.flatten(1).float()
+    a = torch.sum(input * target, 1)
+    if naive_dice:
+        b = torch.sum(input, 1)
+        c = torch.sum(target, 1)
+        d = (2 * a + eps) / (b + c + eps)
+    else:
+        b = torch.sum(input * input, 1) + eps
+        c = torch.sum(target * target, 1) + eps
+        d = (2 * a) / (b + c)
+
+    loss = 1 - d
+    if weight is not None:
+        assert weight.ndim == loss.ndim
+        assert len(weight) == len(pred)
+    loss = weight_reduce_loss(loss, weight, reduction, avg_factor)
+    return loss
+
+
+@MODELS.register_module()
+class DiceLoss(nn.Module):
+
+    def __init__(self,
+                 use_sigmoid=True,
+                 activate=True,
+                 reduction='mean',
+                 naive_dice=False,
+                 loss_weight=1.0,
+                 ignore_index=255,
+                 eps=1e-3,
+                 loss_name='loss_dice'):
+        """Compute dice loss.
+
+        Args:
+            use_sigmoid (bool, optional): Whether to the prediction is
+                used for sigmoid or softmax. Defaults to True.
+            activate (bool): Whether to activate the predictions inside,
+                this will disable the inside sigmoid operation.
+                Defaults to True.
+            reduction (str, optional): The method used
+                to reduce the loss. Options are "none",
+                "mean" and "sum". Defaults to 'mean'.
+            naive_dice (bool, optional): If false, use the dice
+                loss defined in the V-Net paper, otherwise, use the
+                naive dice loss in which the power of the number in the
+                denominator is the first power instead of the second
+                power. Defaults to False.
+            loss_weight (float, optional): Weight of loss. Defaults to 1.0.
+            ignore_index (int, optional): The label index to be ignored.
+                Default: 255.
+            eps (float): Avoid dividing by zero. Defaults to 1e-3.
+            loss_name (str, optional): Name of the loss item. If you want this
+                loss item to be included into the backward graph, `loss_` must
+                be the prefix of the name. Defaults to 'loss_dice'.
+        """
+
+        super().__init__()
+        self.use_sigmoid = use_sigmoid
+        self.reduction = reduction
+        self.naive_dice = naive_dice
+        self.loss_weight = loss_weight
+        self.eps = eps
+        self.activate = activate
+        self.ignore_index = ignore_index
+        self._loss_name = loss_name
+
+    def forward(self,
+                pred,
+                target,
+                weight=None,
+                avg_factor=None,
+                reduction_override=None,
+                ignore_index=255,
+                **kwargs):
+        """Forward function.
+
+        Args:
+            pred (torch.Tensor): The prediction, has a shape (n, *).
+            target (torch.Tensor): The label of the prediction,
+                shape (n, *), same shape of pred.
+            weight (torch.Tensor, optional): The weight of loss for each
+                prediction, has a shape (n,). Defaults to None.
+            avg_factor (int, optional): Average factor that is used to average
+                the loss. Defaults to None.
+            reduction_override (str, optional): The reduction method used to
+                override the original reduction method of the loss.
+                Options are "none", "mean" and "sum".
+
+        Returns:
+            torch.Tensor: The calculated loss
+        """
+        one_hot_target = target
+        if (pred.shape != target.shape):
+            one_hot_target = _expand_onehot_labels_dice(pred, target)
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        if self.activate:
+            if self.use_sigmoid:
+                pred = pred.sigmoid()
+            elif pred.shape[1] != 1:
+                # softmax does not work when there is only 1 class
+                pred = pred.softmax(dim=1)
+        loss = self.loss_weight * dice_loss(
+            pred,
+            one_hot_target,
+            weight,
+            eps=self.eps,
+            reduction=reduction,
+            naive_dice=self.naive_dice,
+            avg_factor=avg_factor,
+            ignore_index=self.ignore_index)
+
+        return loss
+
+    @property
+    def loss_name(self):
+        """Loss Name.
+
+        This function must be implemented and will return the name of this
+        loss function. This name will be used to combine different loss items
+        by simple sum operation. In addition, if you want this loss item to be
+        included into the backward graph, `loss_` must be the prefix of the
+        name.
+        Returns:
+            str: The name of this loss item.
+        """
+        return self._loss_name
diff --git a/mmsegmentation/mmseg/models/losses/focal_loss.py b/mmsegmentation/mmseg/models/losses/focal_loss.py
new file mode 100644
index 0000000..6507ed7
--- /dev/null
+++ b/mmsegmentation/mmseg/models/losses/focal_loss.py
@@ -0,0 +1,337 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# Modified from https://github.com/open-mmlab/mmdetection
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.ops import sigmoid_focal_loss as _sigmoid_focal_loss
+
+from mmseg.registry import MODELS
+from .utils import weight_reduce_loss
+
+
+# This method is used when cuda is not available
+def py_sigmoid_focal_loss(pred,
+                          target,
+                          one_hot_target=None,
+                          weight=None,
+                          gamma=2.0,
+                          alpha=0.5,
+                          class_weight=None,
+                          valid_mask=None,
+                          reduction='mean',
+                          avg_factor=None):
+    """PyTorch version of `Focal Loss <https://arxiv.org/abs/1708.02002>`_.
+
+    Args:
+        pred (torch.Tensor): The prediction with shape (N, C), C is the
+            number of classes
+        target (torch.Tensor): The learning label of the prediction with
+            shape (N, C)
+        one_hot_target (None): Placeholder. It should be None.
+        weight (torch.Tensor, optional): Sample-wise loss weight.
+        gamma (float, optional): The gamma for calculating the modulating
+            factor. Defaults to 2.0.
+        alpha (float | list[float], optional): A balanced form for Focal Loss.
+            Defaults to 0.5.
+        class_weight (list[float], optional): Weight of each class.
+            Defaults to None.
+        valid_mask (torch.Tensor, optional): A mask uses 1 to mark the valid
+            samples and uses 0 to mark the ignored samples. Default: None.
+        reduction (str, optional): The method used to reduce the loss into
+            a scalar. Defaults to 'mean'.
+        avg_factor (int, optional): Average factor that is used to average
+            the loss. Defaults to None.
+    """
+    if isinstance(alpha, list):
+        alpha = pred.new_tensor(alpha)
+    pred_sigmoid = pred.sigmoid()
+    target = target.type_as(pred)
+    one_minus_pt = (1 - pred_sigmoid) * target + pred_sigmoid * (1 - target)
+    focal_weight = (alpha * target + (1 - alpha) *
+                    (1 - target)) * one_minus_pt.pow(gamma)
+
+    loss = F.binary_cross_entropy_with_logits(
+        pred, target, reduction='none') * focal_weight
+    final_weight = torch.ones(1, pred.size(1)).type_as(loss)
+    if weight is not None:
+        if weight.shape != loss.shape and weight.size(0) == loss.size(0):
+            # For most cases, weight is of shape (N, ),
+            # which means it does not have the second axis num_class
+            weight = weight.view(-1, 1)
+        assert weight.dim() == loss.dim()
+        final_weight = final_weight * weight
+    if class_weight is not None:
+        final_weight = final_weight * pred.new_tensor(class_weight)
+    if valid_mask is not None:
+        final_weight = final_weight * valid_mask
+    loss = weight_reduce_loss(loss, final_weight, reduction, avg_factor)
+    return loss
+
+
+def sigmoid_focal_loss(pred,
+                       target,
+                       one_hot_target,
+                       weight=None,
+                       gamma=2.0,
+                       alpha=0.5,
+                       class_weight=None,
+                       valid_mask=None,
+                       reduction='mean',
+                       avg_factor=None):
+    r"""A wrapper of cuda version `Focal Loss
+    <https://arxiv.org/abs/1708.02002>`_.
+    Args:
+        pred (torch.Tensor): The prediction with shape (N, C), C is the number
+            of classes.
+        target (torch.Tensor): The learning label of the prediction. It's shape
+            should be (N, )
+        one_hot_target (torch.Tensor): The learning label with shape (N, C)
+        weight (torch.Tensor, optional): Sample-wise loss weight.
+        gamma (float, optional): The gamma for calculating the modulating
+            factor. Defaults to 2.0.
+        alpha (float | list[float], optional): A balanced form for Focal Loss.
+            Defaults to 0.5.
+        class_weight (list[float], optional): Weight of each class.
+            Defaults to None.
+        valid_mask (torch.Tensor, optional): A mask uses 1 to mark the valid
+            samples and uses 0 to mark the ignored samples. Default: None.
+        reduction (str, optional): The method used to reduce the loss into
+            a scalar. Defaults to 'mean'. Options are "none", "mean" and "sum".
+        avg_factor (int, optional): Average factor that is used to average
+            the loss. Defaults to None.
+    """
+    # Function.apply does not accept keyword arguments, so the decorator
+    # "weighted_loss" is not applicable
+    final_weight = torch.ones(1, pred.size(1)).type_as(pred)
+    if isinstance(alpha, list):
+        # _sigmoid_focal_loss doesn't accept alpha of list type. Therefore, if
+        # a list is given, we set the input alpha as 0.5. This means setting
+        # equal weight for foreground class and background class. By
+        # multiplying the loss by 2, the effect of setting alpha as 0.5 is
+        # undone. The alpha of type list is used to regulate the loss in the
+        # post-processing process.
+        loss = _sigmoid_focal_loss(pred.contiguous(), target.contiguous(),
+                                   gamma, 0.5, None, 'none') * 2
+        alpha = pred.new_tensor(alpha)
+        final_weight = final_weight * (
+            alpha * one_hot_target + (1 - alpha) * (1 - one_hot_target))
+    else:
+        loss = _sigmoid_focal_loss(pred.contiguous(), target.contiguous(),
+                                   gamma, alpha, None, 'none')
+    if weight is not None:
+        if weight.shape != loss.shape and weight.size(0) == loss.size(0):
+            # For most cases, weight is of shape (N, ),
+            # which means it does not have the second axis num_class
+            weight = weight.view(-1, 1)
+        assert weight.dim() == loss.dim()
+        final_weight = final_weight * weight
+    if class_weight is not None:
+        final_weight = final_weight * pred.new_tensor(class_weight)
+    if valid_mask is not None:
+        final_weight = final_weight * valid_mask
+    loss = weight_reduce_loss(loss, final_weight, reduction, avg_factor)
+    return loss
+
+
+@MODELS.register_module()
+class FocalLoss(nn.Module):
+
+    def __init__(self,
+                 use_sigmoid=True,
+                 gamma=2.0,
+                 alpha=0.5,
+                 reduction='mean',
+                 class_weight=None,
+                 loss_weight=1.0,
+                 loss_name='loss_focal'):
+        """`Focal Loss <https://arxiv.org/abs/1708.02002>`_
+        Args:
+            use_sigmoid (bool, optional): Whether to the prediction is
+                used for sigmoid or softmax. Defaults to True.
+            gamma (float, optional): The gamma for calculating the modulating
+                factor. Defaults to 2.0.
+            alpha (float | list[float], optional): A balanced form for Focal
+                Loss. Defaults to 0.5. When a list is provided, the length
+                of the list should be equal to the number of classes.
+                Please be careful that this parameter is not the
+                class-wise weight but the weight of a binary classification
+                problem. This binary classification problem regards the
+                pixels which belong to one class as the foreground
+                and the other pixels as the background, each element in
+                the list is the weight of the corresponding foreground class.
+                The value of alpha or each element of alpha should be a float
+                in the interval [0, 1]. If you want to specify the class-wise
+                weight, please use `class_weight` parameter.
+            reduction (str, optional): The method used to reduce the loss into
+                a scalar. Defaults to 'mean'. Options are "none", "mean" and
+                "sum".
+            class_weight (list[float], optional): Weight of each class.
+                Defaults to None.
+            loss_weight (float, optional): Weight of loss. Defaults to 1.0.
+            loss_name (str, optional): Name of the loss item. If you want this
+                loss item to be included into the backward graph, `loss_` must
+                be the prefix of the name. Defaults to 'loss_focal'.
+        """
+        super().__init__()
+        assert use_sigmoid is True, \
+            'AssertionError: Only sigmoid focal loss supported now.'
+        assert reduction in ('none', 'mean', 'sum'), \
+            "AssertionError: reduction should be 'none', 'mean' or " \
+            "'sum'"
+        assert isinstance(alpha, (float, list)), \
+            'AssertionError: alpha should be of type float'
+        assert isinstance(gamma, float), \
+            'AssertionError: gamma should be of type float'
+        assert isinstance(loss_weight, float), \
+            'AssertionError: loss_weight should be of type float'
+        assert isinstance(loss_name, str), \
+            'AssertionError: loss_name should be of type str'
+        assert isinstance(class_weight, list) or class_weight is None, \
+            'AssertionError: class_weight must be None or of type list'
+        self.use_sigmoid = use_sigmoid
+        self.gamma = gamma
+        self.alpha = alpha
+        self.reduction = reduction
+        self.class_weight = class_weight
+        self.loss_weight = loss_weight
+        self._loss_name = loss_name
+
+    def forward(self,
+                pred,
+                target,
+                weight=None,
+                avg_factor=None,
+                reduction_override=None,
+                ignore_index=255,
+                **kwargs):
+        """Forward function.
+
+        Args:
+            pred (torch.Tensor): The prediction with shape
+                (N, C) where C = number of classes, or
+                (N, C, d_1, d_2, ..., d_K) with K≥1 in the
+                case of K-dimensional loss.
+            target (torch.Tensor): The ground truth. If containing class
+                indices, shape (N) where each value is 0≤targets[i]≤C−1,
+                or (N, d_1, d_2, ..., d_K) with K≥1 in the case of
+                K-dimensional loss. If containing class probabilities,
+                same shape as the input.
+            weight (torch.Tensor, optional): The weight of loss for each
+                prediction. Defaults to None.
+            avg_factor (int, optional): Average factor that is used to
+                average the loss. Defaults to None.
+            reduction_override (str, optional): The reduction method used
+                to override the original reduction method of the loss.
+                Options are "none", "mean" and "sum".
+            ignore_index (int, optional): The label index to be ignored.
+                Default: 255
+        Returns:
+            torch.Tensor: The calculated loss
+        """
+        assert isinstance(ignore_index, int), \
+            'ignore_index must be of type int'
+        assert reduction_override in (None, 'none', 'mean', 'sum'), \
+            "AssertionError: reduction should be 'none', 'mean' or " \
+            "'sum'"
+        assert pred.shape == target.shape or \
+               (pred.size(0) == target.size(0) and
+                pred.shape[2:] == target.shape[1:]), \
+               "The shape of pred doesn't match the shape of target"
+
+        original_shape = pred.shape
+
+        # [B, C, d_1, d_2, ..., d_k] -> [C, B, d_1, d_2, ..., d_k]
+        pred = pred.transpose(0, 1)
+        # [C, B, d_1, d_2, ..., d_k] -> [C, N]
+        pred = pred.reshape(pred.size(0), -1)
+        # [C, N] -> [N, C]
+        pred = pred.transpose(0, 1).contiguous()
+
+        if original_shape == target.shape:
+            # target with shape [B, C, d_1, d_2, ...]
+            # transform it's shape into [N, C]
+            # [B, C, d_1, d_2, ...] -> [C, B, d_1, d_2, ..., d_k]
+            target = target.transpose(0, 1)
+            # [C, B, d_1, d_2, ..., d_k] -> [C, N]
+            target = target.reshape(target.size(0), -1)
+            # [C, N] -> [N, C]
+            target = target.transpose(0, 1).contiguous()
+        else:
+            # target with shape [B, d_1, d_2, ...]
+            # transform it's shape into [N, ]
+            target = target.view(-1).contiguous()
+            valid_mask = (target != ignore_index).view(-1, 1)
+            # avoid raising error when using F.one_hot()
+            target = torch.where(target == ignore_index, target.new_tensor(0),
+                                 target)
+
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        if self.use_sigmoid:
+            num_classes = pred.size(1)
+            if torch.cuda.is_available() and pred.is_cuda:
+                if target.dim() == 1:
+                    one_hot_target = F.one_hot(
+                        target, num_classes=num_classes + 1)
+                    if num_classes == 1:
+                        one_hot_target = one_hot_target[:, 1]
+                        target = 1 - target
+                    else:
+                        one_hot_target = one_hot_target[:, :num_classes]
+                else:
+                    one_hot_target = target
+                    target = target.argmax(dim=1)
+                    valid_mask = (target != ignore_index).view(-1, 1)
+                calculate_loss_func = sigmoid_focal_loss
+            else:
+                one_hot_target = None
+                if target.dim() == 1:
+                    target = F.one_hot(target, num_classes=num_classes + 1)
+                    if num_classes == 1:
+                        target = target[:, 1]
+                    else:
+                        target = target[:, num_classes]
+                else:
+                    valid_mask = (target.argmax(dim=1) != ignore_index).view(
+                        -1, 1)
+                calculate_loss_func = py_sigmoid_focal_loss
+
+            loss_cls = self.loss_weight * calculate_loss_func(
+                pred,
+                target,
+                one_hot_target,
+                weight,
+                gamma=self.gamma,
+                alpha=self.alpha,
+                class_weight=self.class_weight,
+                valid_mask=valid_mask,
+                reduction=reduction,
+                avg_factor=avg_factor)
+
+            if reduction == 'none':
+                # [N, C] -> [C, N]
+                loss_cls = loss_cls.transpose(0, 1)
+                # [C, N] -> [C, B, d1, d2, ...]
+                # original_shape: [B, C, d1, d2, ...]
+                loss_cls = loss_cls.reshape(original_shape[1],
+                                            original_shape[0],
+                                            *original_shape[2:])
+                # [C, B, d1, d2, ...] -> [B, C, d1, d2, ...]
+                loss_cls = loss_cls.transpose(0, 1).contiguous()
+        else:
+            raise NotImplementedError
+        return loss_cls
+
+    @property
+    def loss_name(self):
+        """Loss Name.
+
+        This function must be implemented and will return the name of this
+        loss function. This name will be used to combine different loss items
+        by simple sum operation. In addition, if you want this loss item to be
+        included into the backward graph, `loss_` must be the prefix of the
+        name.
+        Returns:
+            str: The name of this loss item.
+        """
+        return self._loss_name
diff --git a/mmsegmentation/mmseg/models/losses/huasdorff_distance_loss.py b/mmsegmentation/mmseg/models/losses/huasdorff_distance_loss.py
new file mode 100644
index 0000000..d950ba7
--- /dev/null
+++ b/mmsegmentation/mmseg/models/losses/huasdorff_distance_loss.py
@@ -0,0 +1,160 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+"""Modified from https://github.com/JunMa11/SegWithDistMap/blob/
+master/code/train_LA_HD.py (Apache-2.0 License)"""
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from scipy.ndimage import distance_transform_edt as distance
+from torch import Tensor
+
+from mmseg.registry import MODELS
+from .utils import get_class_weight, weighted_loss
+
+
+def compute_dtm(img_gt: Tensor, pred: Tensor) -> Tensor:
+    """
+    compute the distance transform map of foreground in mask
+    Args:
+        img_gt: Ground truth of the image, (b, h, w)
+        pred: Predictions of the segmentation head after softmax, (b, c, h, w)
+
+    Returns:
+        output: the foreground Distance Map (SDM)
+        dtm(x) = 0; x in segmentation boundary
+                inf|x-y|; x in segmentation
+    """
+
+    fg_dtm = torch.zeros_like(pred)
+    out_shape = pred.shape
+    for b in range(out_shape[0]):  # batch size
+        for c in range(1, out_shape[1]):  # default 0 channel is background
+            posmask = img_gt[b].byte()
+            if posmask.any():
+                posdis = distance(posmask)
+                fg_dtm[b][c] = torch.from_numpy(posdis)
+
+    return fg_dtm
+
+
+@weighted_loss
+def hd_loss(seg_soft: Tensor,
+            gt: Tensor,
+            seg_dtm: Tensor,
+            gt_dtm: Tensor,
+            class_weight=None,
+            ignore_index=255) -> Tensor:
+    """
+    compute huasdorff distance loss for segmentation
+    Args:
+        seg_soft: softmax results, shape=(b,c,x,y)
+        gt: ground truth, shape=(b,x,y)
+        seg_dtm: segmentation distance transform map, shape=(b,c,x,y)
+        gt_dtm: ground truth distance transform map, shape=(b,c,x,y)
+
+    Returns:
+        output: hd_loss
+    """
+    assert seg_soft.shape[0] == gt.shape[0]
+    total_loss = 0
+    num_class = seg_soft.shape[1]
+    if class_weight is not None:
+        assert class_weight.ndim == num_class
+    for i in range(1, num_class):
+        if i != ignore_index:
+            delta_s = (seg_soft[:, i, ...] - gt.float())**2
+            s_dtm = seg_dtm[:, i, ...]**2
+            g_dtm = gt_dtm[:, i, ...]**2
+            dtm = s_dtm + g_dtm
+            multiplied = torch.einsum('bxy, bxy->bxy', delta_s, dtm)
+            hd_loss = multiplied.mean()
+        if class_weight is not None:
+            hd_loss *= class_weight[i]
+        total_loss += hd_loss
+
+    return total_loss / num_class
+
+
+@MODELS.register_module()
+class HuasdorffDisstanceLoss(nn.Module):
+    """HuasdorffDisstanceLoss. This loss is proposed in `How Distance Transform
+    Maps Boost Segmentation CNNs: An Empirical Study.
+
+    <http://proceedings.mlr.press/v121/ma20b.html>`_.
+    Args:
+        reduction (str, optional): The method used to reduce the loss into
+            a scalar. Defaults to 'mean'.
+        class_weight (list[float] | str, optional): Weight of each class. If in
+            str format, read them from a file. Defaults to None.
+        loss_weight (float): Weight of the loss. Defaults to 1.0.
+        ignore_index (int | None): The label index to be ignored. Default: 255.
+        loss_name (str): Name of the loss item. If you want this loss
+            item to be included into the backward graph, `loss_` must be the
+            prefix of the name. Defaults to 'loss_boundary'.
+    """
+
+    def __init__(self,
+                 reduction='mean',
+                 class_weight=None,
+                 loss_weight=1.0,
+                 ignore_index=255,
+                 loss_name='loss_huasdorff_disstance',
+                 **kwargs):
+        super().__init__()
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+        self.class_weight = get_class_weight(class_weight)
+        self._loss_name = loss_name
+        self.ignore_index = ignore_index
+
+    def forward(self,
+                pred: Tensor,
+                target: Tensor,
+                avg_factor=None,
+                reduction_override=None,
+                **kwargs) -> Tensor:
+        """Forward function.
+
+        Args:
+            pred (Tensor): Predictions of the segmentation head. (B, C, H, W)
+            target (Tensor): Ground truth of the image. (B, H, W)
+            avg_factor (int, optional): Average factor that is used to
+                average the loss. Defaults to None.
+            reduction_override (str, optional): The reduction method used
+                to override the original reduction method of the loss.
+                Options are "none", "mean" and "sum".
+        Returns:
+            Tensor: Loss tensor.
+        """
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        if self.class_weight is not None:
+            class_weight = pred.new_tensor(self.class_weight)
+        else:
+            class_weight = None
+
+        pred_soft = F.softmax(pred, dim=1)
+        valid_mask = (target != self.ignore_index).long()
+        target = target * valid_mask
+
+        with torch.no_grad():
+            gt_dtm = compute_dtm(target.cpu(), pred_soft)
+            gt_dtm = gt_dtm.float()
+            seg_dtm2 = compute_dtm(
+                pred_soft.argmax(dim=1, keepdim=False).cpu(), pred_soft)
+            seg_dtm2 = seg_dtm2.float()
+
+        loss_hd = self.loss_weight * hd_loss(
+            pred_soft,
+            target,
+            seg_dtm=seg_dtm2,
+            gt_dtm=gt_dtm,
+            reduction=reduction,
+            avg_factor=avg_factor,
+            class_weight=class_weight,
+            ignore_index=self.ignore_index)
+        return loss_hd
+
+    @property
+    def loss_name(self):
+        return self._loss_name
diff --git a/mmsegmentation/mmseg/models/losses/kldiv_loss.py b/mmsegmentation/mmseg/models/losses/kldiv_loss.py
new file mode 100644
index 0000000..496ef97
--- /dev/null
+++ b/mmsegmentation/mmseg/models/losses/kldiv_loss.py
@@ -0,0 +1,99 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from mmseg.registry import MODELS
+
+
+@MODELS.register_module()
+class KLDivLoss(nn.Module):
+
+    def __init__(self,
+                 temperature: float = 1.0,
+                 reduction: str = 'mean',
+                 loss_name: str = 'loss_kld'):
+        """Kullback-Leibler divergence Loss.
+
+        <https://en.wikipedia.org/wiki/Kullback%E2%80%93Leibler_divergence>
+
+        Args:
+            temperature (float, optional): Temperature param
+            reduction  (str,  optional): The method to reduce the loss into a
+            scalar. Default is "mean". Options are "none", "sum",
+            and "mean"
+        """
+
+        assert isinstance(temperature, (float, int)), \
+            'Expected temperature to be' \
+            f'float or int, but got {temperature.__class__.__name__} instead'
+        assert temperature != 0., 'Temperature must not be zero'
+
+        assert reduction in ['mean', 'none', 'sum'], \
+            'Reduction must be one of the options ("mean", ' \
+            f'"sum", "none"), but got {reduction}'
+
+        super().__init__()
+        self.temperature = temperature
+        self.reduction = reduction
+        self._loss_name = loss_name
+
+    def forward(self, input: torch.Tensor, target: torch.Tensor):
+        """Forward function. Calculate KL divergence Loss.
+
+        Args:
+            input (Tensor): Logit tensor,
+                the data type is float32 or float64.
+                The shape is (N, C) where N is batchsize and C  is number of
+                channels.
+                If there more than 2 dimensions, shape is (N, C, D1, D2, ...
+                Dk), k>= 1
+            target (Tensor): Logit tensor,
+                the data type is float32 or float64.
+                input and target must be with the same shape.
+
+        Returns:
+            (Tensor): Reduced loss.
+        """
+        assert isinstance(input, torch.Tensor), 'Expected input to' \
+            f'be Tensor, but got {input.__class__.__name__} instead'
+        assert isinstance(target, torch.Tensor), 'Expected target to' \
+            f'be Tensor, but got {target.__class__.__name__} instead'
+
+        assert input.shape == target.shape, 'Input and target ' \
+            'must have same shape,' \
+            f'but got shapes {input.shape} and {target.shape}'
+
+        input = F.softmax(input / self.temperature, dim=1)
+        target = F.softmax(target / self.temperature, dim=1)
+
+        loss = F.kl_div(input, target, reduction='none', log_target=False)
+        loss = loss * self.temperature**2
+
+        batch_size = input.shape[0]
+
+        if self.reduction == 'sum':
+            # Change view to calculate instance-wise sum
+            loss = loss.view(batch_size, -1)
+            return torch.sum(loss, dim=1)
+
+        elif self.reduction == 'mean':
+            # Change view to calculate instance-wise mean
+            loss = loss.view(batch_size, -1)
+            return torch.mean(loss, dim=1)
+
+        return loss
+
+    @property
+    def loss_name(self):
+        """Loss Name.
+
+        This function must be implemented and will return the name of this
+        loss function. This name will be used to combine different loss items
+        by simple sum operation. In addition, if you want this loss item to be
+        included into the backward graph, `loss_` must be the prefix of the
+        name.
+        Returns:
+            str: The name of this loss item.
+        """
+        return self._loss_name
diff --git a/mmsegmentation/mmseg/models/losses/lovasz_loss.py b/mmsegmentation/mmseg/models/losses/lovasz_loss.py
new file mode 100644
index 0000000..b47f9d8
--- /dev/null
+++ b/mmsegmentation/mmseg/models/losses/lovasz_loss.py
@@ -0,0 +1,323 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+"""Modified from https://github.com/bermanmaxim/LovaszSoftmax/blob/master/pytor
+ch/lovasz_losses.py Lovasz-Softmax and Jaccard hinge loss in PyTorch Maxim
+Berman 2018 ESAT-PSI KU Leuven (MIT License)"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmengine.utils import is_list_of
+
+from mmseg.registry import MODELS
+from .utils import get_class_weight, weight_reduce_loss
+
+
+def lovasz_grad(gt_sorted):
+    """Computes gradient of the Lovasz extension w.r.t sorted errors.
+
+    See Alg. 1 in paper.
+    """
+    p = len(gt_sorted)
+    gts = gt_sorted.sum()
+    intersection = gts - gt_sorted.float().cumsum(0)
+    union = gts + (1 - gt_sorted).float().cumsum(0)
+    jaccard = 1. - intersection / union
+    if p > 1:  # cover 1-pixel case
+        jaccard[1:p] = jaccard[1:p] - jaccard[0:-1]
+    return jaccard
+
+
+def flatten_binary_logits(logits, labels, ignore_index=None):
+    """Flattens predictions in the batch (binary case) Remove labels equal to
+    'ignore_index'."""
+    logits = logits.view(-1)
+    labels = labels.view(-1)
+    if ignore_index is None:
+        return logits, labels
+    valid = (labels != ignore_index)
+    vlogits = logits[valid]
+    vlabels = labels[valid]
+    return vlogits, vlabels
+
+
+def flatten_probs(probs, labels, ignore_index=None):
+    """Flattens predictions in the batch."""
+    if probs.dim() == 3:
+        # assumes output of a sigmoid layer
+        B, H, W = probs.size()
+        probs = probs.view(B, 1, H, W)
+    B, C, H, W = probs.size()
+    probs = probs.permute(0, 2, 3, 1).contiguous().view(-1, C)  # B*H*W, C=P,C
+    labels = labels.view(-1)
+    if ignore_index is None:
+        return probs, labels
+    valid = (labels != ignore_index)
+    vprobs = probs[valid.nonzero().squeeze()]
+    vlabels = labels[valid]
+    return vprobs, vlabels
+
+
+def lovasz_hinge_flat(logits, labels):
+    """Binary Lovasz hinge loss.
+
+    Args:
+        logits (torch.Tensor): [P], logits at each prediction
+            (between -infty and +infty).
+        labels (torch.Tensor): [P], binary ground truth labels (0 or 1).
+
+    Returns:
+        torch.Tensor: The calculated loss.
+    """
+    if len(labels) == 0:
+        # only void pixels, the gradients should be 0
+        return logits.sum() * 0.
+    signs = 2. * labels.float() - 1.
+    errors = (1. - logits * signs)
+    errors_sorted, perm = torch.sort(errors, dim=0, descending=True)
+    perm = perm.data
+    gt_sorted = labels[perm]
+    grad = lovasz_grad(gt_sorted)
+    loss = torch.dot(F.relu(errors_sorted), grad)
+    return loss
+
+
+def lovasz_hinge(logits,
+                 labels,
+                 classes='present',
+                 per_image=False,
+                 class_weight=None,
+                 reduction='mean',
+                 avg_factor=None,
+                 ignore_index=255):
+    """Binary Lovasz hinge loss.
+
+    Args:
+        logits (torch.Tensor): [B, H, W], logits at each pixel
+            (between -infty and +infty).
+        labels (torch.Tensor): [B, H, W], binary ground truth masks (0 or 1).
+        classes (str | list[int], optional): Placeholder, to be consistent with
+            other loss. Default: None.
+        per_image (bool, optional): If per_image is True, compute the loss per
+            image instead of per batch. Default: False.
+        class_weight (list[float], optional): Placeholder, to be consistent
+            with other loss. Default: None.
+        reduction (str, optional): The method used to reduce the loss. Options
+            are "none", "mean" and "sum". This parameter only works when
+            per_image is True. Default: 'mean'.
+        avg_factor (int, optional): Average factor that is used to average
+            the loss. This parameter only works when per_image is True.
+            Default: None.
+        ignore_index (int | None): The label index to be ignored. Default: 255.
+
+    Returns:
+        torch.Tensor: The calculated loss.
+    """
+    if per_image:
+        loss = [
+            lovasz_hinge_flat(*flatten_binary_logits(
+                logit.unsqueeze(0), label.unsqueeze(0), ignore_index))
+            for logit, label in zip(logits, labels)
+        ]
+        loss = weight_reduce_loss(
+            torch.stack(loss), None, reduction, avg_factor)
+    else:
+        loss = lovasz_hinge_flat(
+            *flatten_binary_logits(logits, labels, ignore_index))
+    return loss
+
+
+def lovasz_softmax_flat(probs, labels, classes='present', class_weight=None):
+    """Multi-class Lovasz-Softmax loss.
+
+    Args:
+        probs (torch.Tensor): [P, C], class probabilities at each prediction
+            (between 0 and 1).
+        labels (torch.Tensor): [P], ground truth labels (between 0 and C - 1).
+        classes (str | list[int], optional): Classes chosen to calculate loss.
+            'all' for all classes, 'present' for classes present in labels, or
+            a list of classes to average. Default: 'present'.
+        class_weight (list[float], optional): The weight for each class.
+            Default: None.
+
+    Returns:
+        torch.Tensor: The calculated loss.
+    """
+    if probs.numel() == 0:
+        # only void pixels, the gradients should be 0
+        return probs * 0.
+    C = probs.size(1)
+    losses = []
+    class_to_sum = list(range(C)) if classes in ['all', 'present'] else classes
+    for c in class_to_sum:
+        fg = (labels == c).float()  # foreground for class c
+        if (classes == 'present' and fg.sum() == 0):
+            continue
+        if C == 1:
+            if len(classes) > 1:
+                raise ValueError('Sigmoid output possible only with 1 class')
+            class_pred = probs[:, 0]
+        else:
+            class_pred = probs[:, c]
+        errors = (fg - class_pred).abs()
+        errors_sorted, perm = torch.sort(errors, 0, descending=True)
+        perm = perm.data
+        fg_sorted = fg[perm]
+        loss = torch.dot(errors_sorted, lovasz_grad(fg_sorted))
+        if class_weight is not None:
+            loss *= class_weight[c]
+        losses.append(loss)
+    return torch.stack(losses).mean()
+
+
+def lovasz_softmax(probs,
+                   labels,
+                   classes='present',
+                   per_image=False,
+                   class_weight=None,
+                   reduction='mean',
+                   avg_factor=None,
+                   ignore_index=255):
+    """Multi-class Lovasz-Softmax loss.
+
+    Args:
+        probs (torch.Tensor): [B, C, H, W], class probabilities at each
+            prediction (between 0 and 1).
+        labels (torch.Tensor): [B, H, W], ground truth labels (between 0 and
+            C - 1).
+        classes (str | list[int], optional): Classes chosen to calculate loss.
+            'all' for all classes, 'present' for classes present in labels, or
+            a list of classes to average. Default: 'present'.
+        per_image (bool, optional): If per_image is True, compute the loss per
+            image instead of per batch. Default: False.
+        class_weight (list[float], optional): The weight for each class.
+            Default: None.
+        reduction (str, optional): The method used to reduce the loss. Options
+            are "none", "mean" and "sum". This parameter only works when
+            per_image is True. Default: 'mean'.
+        avg_factor (int, optional): Average factor that is used to average
+            the loss. This parameter only works when per_image is True.
+            Default: None.
+        ignore_index (int | None): The label index to be ignored. Default: 255.
+
+    Returns:
+        torch.Tensor: The calculated loss.
+    """
+
+    if per_image:
+        loss = [
+            lovasz_softmax_flat(
+                *flatten_probs(
+                    prob.unsqueeze(0), label.unsqueeze(0), ignore_index),
+                classes=classes,
+                class_weight=class_weight)
+            for prob, label in zip(probs, labels)
+        ]
+        loss = weight_reduce_loss(
+            torch.stack(loss), None, reduction, avg_factor)
+    else:
+        loss = lovasz_softmax_flat(
+            *flatten_probs(probs, labels, ignore_index),
+            classes=classes,
+            class_weight=class_weight)
+    return loss
+
+
+@MODELS.register_module()
+class LovaszLoss(nn.Module):
+    """LovaszLoss.
+
+    This loss is proposed in `The Lovasz-Softmax loss: A tractable surrogate
+    for the optimization of the intersection-over-union measure in neural
+    networks <https://arxiv.org/abs/1705.08790>`_.
+
+    Args:
+        loss_type (str, optional): Binary or multi-class loss.
+            Default: 'multi_class'. Options are "binary" and "multi_class".
+        classes (str | list[int], optional): Classes chosen to calculate loss.
+            'all' for all classes, 'present' for classes present in labels, or
+            a list of classes to average. Default: 'present'.
+        per_image (bool, optional): If per_image is True, compute the loss per
+            image instead of per batch. Default: False.
+        reduction (str, optional): The method used to reduce the loss. Options
+            are "none", "mean" and "sum". This parameter only works when
+            per_image is True. Default: 'mean'.
+        class_weight (list[float] | str, optional): Weight of each class. If in
+            str format, read them from a file. Defaults to None.
+        loss_weight (float, optional): Weight of the loss. Defaults to 1.0.
+        loss_name (str, optional): Name of the loss item. If you want this loss
+            item to be included into the backward graph, `loss_` must be the
+            prefix of the name. Defaults to 'loss_lovasz'.
+    """
+
+    def __init__(self,
+                 loss_type='multi_class',
+                 classes='present',
+                 per_image=False,
+                 reduction='mean',
+                 class_weight=None,
+                 loss_weight=1.0,
+                 loss_name='loss_lovasz'):
+        super().__init__()
+        assert loss_type in ('binary', 'multi_class'), "loss_type should be \
+                                                    'binary' or 'multi_class'."
+
+        if loss_type == 'binary':
+            self.cls_criterion = lovasz_hinge
+        else:
+            self.cls_criterion = lovasz_softmax
+        assert classes in ('all', 'present') or is_list_of(classes, int)
+        if not per_image:
+            assert reduction == 'none', "reduction should be 'none' when \
+                                                        per_image is False."
+
+        self.classes = classes
+        self.per_image = per_image
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+        self.class_weight = get_class_weight(class_weight)
+        self._loss_name = loss_name
+
+    def forward(self,
+                cls_score,
+                label,
+                weight=None,
+                avg_factor=None,
+                reduction_override=None,
+                **kwargs):
+        """Forward function."""
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        if self.class_weight is not None:
+            class_weight = cls_score.new_tensor(self.class_weight)
+        else:
+            class_weight = None
+
+        # if multi-class loss, transform logits to probs
+        if self.cls_criterion == lovasz_softmax:
+            cls_score = F.softmax(cls_score, dim=1)
+
+        loss_cls = self.loss_weight * self.cls_criterion(
+            cls_score,
+            label,
+            self.classes,
+            self.per_image,
+            class_weight=class_weight,
+            reduction=reduction,
+            avg_factor=avg_factor,
+            **kwargs)
+        return loss_cls
+
+    @property
+    def loss_name(self):
+        """Loss Name.
+
+        This function must be implemented and will return the name of this
+        loss function. This name will be used to combine different loss items
+        by simple sum operation. In addition, if you want this loss item to be
+        included into the backward graph, `loss_` must be the prefix of the
+        name.
+        Returns:
+            str: The name of this loss item.
+        """
+        return self._loss_name
diff --git a/mmsegmentation/mmseg/models/losses/ohem_cross_entropy_loss.py b/mmsegmentation/mmseg/models/losses/ohem_cross_entropy_loss.py
new file mode 100644
index 0000000..a519b4d
--- /dev/null
+++ b/mmsegmentation/mmseg/models/losses/ohem_cross_entropy_loss.py
@@ -0,0 +1,94 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Union
+
+import torch.nn as nn
+import torch.nn.functional as F
+from torch import Tensor
+
+from mmseg.registry import MODELS
+
+
+@MODELS.register_module()
+class OhemCrossEntropy(nn.Module):
+    """OhemCrossEntropy loss.
+
+    This func is modified from
+    `PIDNet <https://github.com/XuJiacong/PIDNet/blob/main/utils/criterion.py#L43>`_.  # noqa
+
+    Licensed under the MIT License.
+
+    Args:
+        ignore_label (int): Labels to ignore when computing the loss.
+            Default: 255
+        thresh (float, optional): The threshold for hard example selection.
+            Below which, are prediction with low confidence. If not
+            specified, the hard examples will be pixels of top ``min_kept``
+            loss. Default: 0.7.
+        min_kept (int, optional): The minimum number of predictions to keep.
+            Default: 100000.
+        loss_weight (float): Weight of the loss. Defaults to 1.0.
+        class_weight (list[float] | str, optional): Weight of each class. If in
+            str format, read them from a file. Defaults to None.
+        loss_name (str): Name of the loss item. If you want this loss
+            item to be included into the backward graph, `loss_` must be the
+            prefix of the name. Defaults to 'loss_boundary'.
+    """
+
+    def __init__(self,
+                 ignore_label: int = 255,
+                 thres: float = 0.7,
+                 min_kept: int = 100000,
+                 loss_weight: float = 1.0,
+                 class_weight: Optional[Union[List[float], str]] = None,
+                 loss_name: str = 'loss_ohem'):
+        super().__init__()
+        self.thresh = thres
+        self.min_kept = max(1, min_kept)
+        self.ignore_label = ignore_label
+        self.loss_weight = loss_weight
+        self.loss_name_ = loss_name
+        self.class_weight = class_weight
+
+    def forward(self, score: Tensor, target: Tensor) -> Tensor:
+        """Forward function.
+        Args:
+            score (Tensor): Predictions of the segmentation head.
+            target (Tensor): Ground truth of the image.
+
+        Returns:
+            Tensor: Loss tensor.
+        """
+        # score: (N, C, H, W)
+        pred = F.softmax(score, dim=1)
+        if self.class_weight is not None:
+            class_weight = score.new_tensor(self.class_weight)
+        else:
+            class_weight = None
+
+        pixel_losses = F.cross_entropy(
+            score,
+            target,
+            weight=class_weight,
+            ignore_index=self.ignore_label,
+            reduction='none').contiguous().view(-1)  # (N*H*W)
+        mask = target.contiguous().view(-1) != self.ignore_label  # (N*H*W)
+
+        tmp_target = target.clone()  # (N, H, W)
+        tmp_target[tmp_target == self.ignore_label] = 0
+        # pred: (N, C, H, W) -> (N*H*W, C)
+        pred = pred.gather(1, tmp_target.unsqueeze(1))
+        # pred: (N*H*W, C) -> (N*H*W), ind: (N*H*W)
+        pred, ind = pred.contiguous().view(-1, )[mask].contiguous().sort()
+        if pred.numel() > 0:
+            min_value = pred[min(self.min_kept, pred.numel() - 1)]
+        else:
+            return score.new_tensor(0.0)
+        threshold = max(min_value, self.thresh)
+
+        pixel_losses = pixel_losses[mask][ind]
+        pixel_losses = pixel_losses[pred < threshold]
+        return self.loss_weight * pixel_losses.mean()
+
+    @property
+    def loss_name(self):
+        return self.loss_name_
diff --git a/mmsegmentation/mmseg/models/losses/silog_loss.py b/mmsegmentation/mmseg/models/losses/silog_loss.py
new file mode 100644
index 0000000..ecc07aa
--- /dev/null
+++ b/mmsegmentation/mmseg/models/losses/silog_loss.py
@@ -0,0 +1,122 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Union
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+
+from mmseg.registry import MODELS
+from .utils import weight_reduce_loss
+
+
+def silog_loss(pred: Tensor,
+               target: Tensor,
+               weight: Optional[Tensor] = None,
+               eps: float = 1e-4,
+               reduction: Union[str, None] = 'mean',
+               avg_factor: Optional[int] = None) -> Tensor:
+    """Computes the Scale-Invariant Logarithmic (SI-Log) loss between
+    prediction and target.
+
+    Args:
+        pred (Tensor): Predicted output.
+        target (Tensor): Ground truth.
+        weight (Optional[Tensor]): Optional weight to apply on the loss.
+        eps (float): Epsilon value to avoid division and log(0).
+        reduction (Union[str, None]): Specifies the reduction to apply to the
+            output: 'mean', 'sum' or None.
+        avg_factor (Optional[int]): Optional average factor for the loss.
+
+    Returns:
+        Tensor: The calculated SI-Log loss.
+    """
+    pred, target = pred.flatten(1), target.flatten(1)
+    valid_mask = (target > eps).detach().float()
+
+    diff_log = torch.log(target.clamp(min=eps)) - torch.log(
+        pred.clamp(min=eps))
+
+    valid_mask = (target > eps).detach() & (~torch.isnan(diff_log))
+    diff_log[~valid_mask] = 0.0
+    valid_mask = valid_mask.float()
+
+    diff_log_sq_mean = (diff_log.pow(2) * valid_mask).sum(
+        dim=1) / valid_mask.sum(dim=1).clamp(min=eps)
+    diff_log_mean = (diff_log * valid_mask).sum(dim=1) / valid_mask.sum(
+        dim=1).clamp(min=eps)
+
+    loss = torch.sqrt(diff_log_sq_mean - 0.5 * diff_log_mean.pow(2))
+
+    if weight is not None:
+        weight = weight.float()
+
+    loss = weight_reduce_loss(loss, weight, reduction, avg_factor)
+    return loss
+
+
+@MODELS.register_module()
+class SiLogLoss(nn.Module):
+    """Compute SiLog loss.
+
+    Args:
+        reduction (str, optional): The method used
+            to reduce the loss. Options are "none",
+            "mean" and "sum". Defaults to 'mean'.
+        loss_weight (float, optional): Weight of loss. Defaults to 1.0.
+        eps (float): Avoid dividing by zero. Defaults to 1e-3.
+        loss_name (str, optional): Name of the loss item. If you want this
+            loss item to be included into the backward graph, `loss_` must
+            be the prefix of the name. Defaults to 'loss_silog'.
+    """
+
+    def __init__(self,
+                 reduction='mean',
+                 loss_weight=1.0,
+                 eps=1e-6,
+                 loss_name='loss_silog'):
+        super().__init__()
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+        self.eps = eps
+        self._loss_name = loss_name
+
+    def forward(
+        self,
+        pred,
+        target,
+        weight=None,
+        avg_factor=None,
+        reduction_override=None,
+    ):
+
+        assert pred.shape == target.shape, 'the shapes of pred ' \
+            f'({pred.shape}) and target ({target.shape}) are mismatch'
+
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+
+        loss = self.loss_weight * silog_loss(
+            pred,
+            target,
+            weight,
+            eps=self.eps,
+            reduction=reduction,
+            avg_factor=avg_factor,
+        )
+
+        return loss
+
+    @property
+    def loss_name(self):
+        """Loss Name.
+
+        This function must be implemented and will return the name of this
+        loss function. This name will be used to combine different loss items
+        by simple sum operation. In addition, if you want this loss item to be
+        included into the backward graph, `loss_` must be the prefix of the
+        name.
+        Returns:
+            str: The name of this loss item.
+        """
+        return self._loss_name
diff --git a/mmsegmentation/mmseg/models/losses/tversky_loss.py b/mmsegmentation/mmseg/models/losses/tversky_loss.py
new file mode 100644
index 0000000..bfca1af
--- /dev/null
+++ b/mmsegmentation/mmseg/models/losses/tversky_loss.py
@@ -0,0 +1,137 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+"""Modified from
+https://github.com/JunMa11/SegLoss/blob/master/losses_pytorch/dice_loss.py#L333
+(Apache-2.0 License)"""
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from ..builder import LOSSES
+from .utils import get_class_weight, weighted_loss
+
+
+@weighted_loss
+def tversky_loss(pred,
+                 target,
+                 valid_mask,
+                 alpha=0.3,
+                 beta=0.7,
+                 smooth=1,
+                 class_weight=None,
+                 ignore_index=255):
+    assert pred.shape[0] == target.shape[0]
+    total_loss = 0
+    num_classes = pred.shape[1]
+    for i in range(num_classes):
+        if i != ignore_index:
+            tversky_loss = binary_tversky_loss(
+                pred[:, i],
+                target[..., i],
+                valid_mask=valid_mask,
+                alpha=alpha,
+                beta=beta,
+                smooth=smooth)
+            if class_weight is not None:
+                tversky_loss *= class_weight[i]
+            total_loss += tversky_loss
+    return total_loss / num_classes
+
+
+@weighted_loss
+def binary_tversky_loss(pred,
+                        target,
+                        valid_mask,
+                        alpha=0.3,
+                        beta=0.7,
+                        smooth=1):
+    assert pred.shape[0] == target.shape[0]
+    pred = pred.reshape(pred.shape[0], -1)
+    target = target.reshape(target.shape[0], -1)
+    valid_mask = valid_mask.reshape(valid_mask.shape[0], -1)
+
+    TP = torch.sum(torch.mul(pred, target) * valid_mask, dim=1)
+    FP = torch.sum(torch.mul(pred, 1 - target) * valid_mask, dim=1)
+    FN = torch.sum(torch.mul(1 - pred, target) * valid_mask, dim=1)
+    tversky = (TP + smooth) / (TP + alpha * FP + beta * FN + smooth)
+
+    return 1 - tversky
+
+
+@LOSSES.register_module()
+class TverskyLoss(nn.Module):
+    """TverskyLoss. This loss is proposed in `Tversky loss function for image
+    segmentation using 3D fully convolutional deep networks.
+
+    <https://arxiv.org/abs/1706.05721>`_.
+    Args:
+        smooth (float): A float number to smooth loss, and avoid NaN error.
+            Default: 1.
+        class_weight (list[float] | str, optional): Weight of each class. If in
+            str format, read them from a file. Defaults to None.
+        loss_weight (float, optional): Weight of the loss. Default to 1.0.
+        ignore_index (int | None): The label index to be ignored. Default: 255.
+        alpha(float, in [0, 1]):
+            The coefficient of false positives. Default: 0.3.
+        beta (float, in [0, 1]):
+            The coefficient of false negatives. Default: 0.7.
+            Note: alpha + beta = 1.
+        loss_name (str, optional): Name of the loss item. If you want this loss
+            item to be included into the backward graph, `loss_` must be the
+            prefix of the name. Defaults to 'loss_tversky'.
+    """
+
+    def __init__(self,
+                 smooth=1,
+                 class_weight=None,
+                 loss_weight=1.0,
+                 ignore_index=255,
+                 alpha=0.3,
+                 beta=0.7,
+                 loss_name='loss_tversky'):
+        super().__init__()
+        self.smooth = smooth
+        self.class_weight = get_class_weight(class_weight)
+        self.loss_weight = loss_weight
+        self.ignore_index = ignore_index
+        assert (alpha + beta == 1.0), 'Sum of alpha and beta but be 1.0!'
+        self.alpha = alpha
+        self.beta = beta
+        self._loss_name = loss_name
+
+    def forward(self, pred, target, **kwargs):
+        if self.class_weight is not None:
+            class_weight = pred.new_tensor(self.class_weight)
+        else:
+            class_weight = None
+
+        pred = F.softmax(pred, dim=1)
+        num_classes = pred.shape[1]
+        one_hot_target = F.one_hot(
+            torch.clamp(target.long(), 0, num_classes - 1),
+            num_classes=num_classes)
+        valid_mask = (target != self.ignore_index).long()
+
+        loss = self.loss_weight * tversky_loss(
+            pred,
+            one_hot_target,
+            valid_mask=valid_mask,
+            alpha=self.alpha,
+            beta=self.beta,
+            smooth=self.smooth,
+            class_weight=class_weight,
+            ignore_index=self.ignore_index)
+        return loss
+
+    @property
+    def loss_name(self):
+        """Loss Name.
+
+        This function must be implemented and will return the name of this
+        loss function. This name will be used to combine different loss items
+        by simple sum operation. In addition, if you want this loss item to be
+        included into the backward graph, `loss_` must be the prefix of the
+        name.
+        Returns:
+            str: The name of this loss item.
+        """
+        return self._loss_name
diff --git a/mmsegmentation/mmseg/models/losses/utils.py b/mmsegmentation/mmseg/models/losses/utils.py
new file mode 100644
index 0000000..0478034
--- /dev/null
+++ b/mmsegmentation/mmseg/models/losses/utils.py
@@ -0,0 +1,129 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import functools
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from mmengine.fileio import load
+
+
+def get_class_weight(class_weight):
+    """Get class weight for loss function.
+
+    Args:
+        class_weight (list[float] | str | None): If class_weight is a str,
+            take it as a file name and read from it.
+    """
+    if isinstance(class_weight, str):
+        # take it as a file path
+        if class_weight.endswith('.npy'):
+            class_weight = np.load(class_weight)
+        else:
+            # pkl, json or yaml
+            class_weight = load(class_weight)
+
+    return class_weight
+
+
+def reduce_loss(loss, reduction) -> torch.Tensor:
+    """Reduce loss as specified.
+
+    Args:
+        loss (Tensor): Elementwise loss tensor.
+        reduction (str): Options are "none", "mean" and "sum".
+
+    Return:
+        Tensor: Reduced loss tensor.
+    """
+    reduction_enum = F._Reduction.get_enum(reduction)
+    # none: 0, elementwise_mean:1, sum: 2
+    if reduction_enum == 0:
+        return loss
+    elif reduction_enum == 1:
+        return loss.mean()
+    elif reduction_enum == 2:
+        return loss.sum()
+
+
+def weight_reduce_loss(loss,
+                       weight=None,
+                       reduction='mean',
+                       avg_factor=None) -> torch.Tensor:
+    """Apply element-wise weight and reduce loss.
+
+    Args:
+        loss (Tensor): Element-wise loss.
+        weight (Tensor): Element-wise weights.
+        reduction (str): Same as built-in losses of PyTorch.
+        avg_factor (float): Average factor when computing the mean of losses.
+
+    Returns:
+        Tensor: Processed loss values.
+    """
+    # if weight is specified, apply element-wise weight
+    if weight is not None:
+        assert weight.dim() == loss.dim()
+        if weight.dim() > 1:
+            assert weight.size(1) == 1 or weight.size(1) == loss.size(1)
+        loss = loss * weight
+
+    # if avg_factor is not specified, just reduce the loss
+    if avg_factor is None:
+        loss = reduce_loss(loss, reduction)
+    else:
+        # if reduction is mean, then average the loss by avg_factor
+        if reduction == 'mean':
+            # Avoid causing ZeroDivisionError when avg_factor is 0.0,
+            # i.e., all labels of an image belong to ignore index.
+            eps = torch.finfo(torch.float32).eps
+            loss = loss.sum() / (avg_factor + eps)
+        # if reduction is 'none', then do nothing, otherwise raise an error
+        elif reduction != 'none':
+            raise ValueError('avg_factor can not be used with reduction="sum"')
+    return loss
+
+
+def weighted_loss(loss_func):
+    """Create a weighted version of a given loss function.
+
+    To use this decorator, the loss function must have the signature like
+    `loss_func(pred, target, **kwargs)`. The function only needs to compute
+    element-wise loss without any reduction. This decorator will add weight
+    and reduction arguments to the function. The decorated function will have
+    the signature like `loss_func(pred, target, weight=None, reduction='mean',
+    avg_factor=None, **kwargs)`.
+
+    :Example:
+
+    >>> import torch
+    >>> @weighted_loss
+    >>> def l1_loss(pred, target):
+    >>>     return (pred - target).abs()
+
+    >>> pred = torch.Tensor([0, 2, 3])
+    >>> target = torch.Tensor([1, 1, 1])
+    >>> weight = torch.Tensor([1, 0, 1])
+
+    >>> l1_loss(pred, target)
+    tensor(1.3333)
+    >>> l1_loss(pred, target, weight)
+    tensor(1.)
+    >>> l1_loss(pred, target, reduction='none')
+    tensor([1., 1., 2.])
+    >>> l1_loss(pred, target, weight, avg_factor=2)
+    tensor(1.5000)
+    """
+
+    @functools.wraps(loss_func)
+    def wrapper(pred,
+                target,
+                weight=None,
+                reduction='mean',
+                avg_factor=None,
+                **kwargs):
+        # get element-wise loss
+        loss = loss_func(pred, target, **kwargs)
+        loss = weight_reduce_loss(loss, weight, reduction, avg_factor)
+        return loss
+
+    return wrapper
diff --git a/mmsegmentation/mmseg/models/necks/__init__.py b/mmsegmentation/mmseg/models/necks/__init__.py
new file mode 100644
index 0000000..ff03186
--- /dev/null
+++ b/mmsegmentation/mmseg/models/necks/__init__.py
@@ -0,0 +1,11 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .featurepyramid import Feature2Pyramid
+from .fpn import FPN
+from .ic_neck import ICNeck
+from .jpu import JPU
+from .mla_neck import MLANeck
+from .multilevel_neck import MultiLevelNeck
+
+__all__ = [
+    'FPN', 'MultiLevelNeck', 'MLANeck', 'ICNeck', 'JPU', 'Feature2Pyramid'
+]
diff --git a/mmsegmentation/mmseg/models/necks/featurepyramid.py b/mmsegmentation/mmseg/models/necks/featurepyramid.py
new file mode 100644
index 0000000..dc1250d
--- /dev/null
+++ b/mmsegmentation/mmseg/models/necks/featurepyramid.py
@@ -0,0 +1,67 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch.nn as nn
+from mmcv.cnn import build_norm_layer
+
+from mmseg.registry import MODELS
+
+
+@MODELS.register_module()
+class Feature2Pyramid(nn.Module):
+    """Feature2Pyramid.
+
+    A neck structure connect ViT backbone and decoder_heads.
+
+    Args:
+        embed_dims (int): Embedding dimension.
+        rescales (list[float]): Different sampling multiples were
+            used to obtain pyramid features. Default: [4, 2, 1, 0.5].
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='SyncBN', requires_grad=True).
+    """
+
+    def __init__(self,
+                 embed_dim,
+                 rescales=[4, 2, 1, 0.5],
+                 norm_cfg=dict(type='SyncBN', requires_grad=True)):
+        super().__init__()
+        self.rescales = rescales
+        self.upsample_4x = None
+        for k in self.rescales:
+            if k == 4:
+                self.upsample_4x = nn.Sequential(
+                    nn.ConvTranspose2d(
+                        embed_dim, embed_dim, kernel_size=2, stride=2),
+                    build_norm_layer(norm_cfg, embed_dim)[1],
+                    nn.GELU(),
+                    nn.ConvTranspose2d(
+                        embed_dim, embed_dim, kernel_size=2, stride=2),
+                )
+            elif k == 2:
+                self.upsample_2x = nn.Sequential(
+                    nn.ConvTranspose2d(
+                        embed_dim, embed_dim, kernel_size=2, stride=2))
+            elif k == 1:
+                self.identity = nn.Identity()
+            elif k == 0.5:
+                self.downsample_2x = nn.MaxPool2d(kernel_size=2, stride=2)
+            elif k == 0.25:
+                self.downsample_4x = nn.MaxPool2d(kernel_size=4, stride=4)
+            else:
+                raise KeyError(f'invalid {k} for feature2pyramid')
+
+    def forward(self, inputs):
+        assert len(inputs) == len(self.rescales)
+        outputs = []
+        if self.upsample_4x is not None:
+            ops = [
+                self.upsample_4x, self.upsample_2x, self.identity,
+                self.downsample_2x
+            ]
+        else:
+            ops = [
+                self.upsample_2x, self.identity, self.downsample_2x,
+                self.downsample_4x
+            ]
+        for i in range(len(inputs)):
+            outputs.append(ops[i](inputs[i]))
+        return tuple(outputs)
diff --git a/mmsegmentation/mmseg/models/necks/fpn.py b/mmsegmentation/mmseg/models/necks/fpn.py
new file mode 100644
index 0000000..ddab74c
--- /dev/null
+++ b/mmsegmentation/mmseg/models/necks/fpn.py
@@ -0,0 +1,212 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule
+
+from mmseg.registry import MODELS
+from ..utils import resize
+
+
+@MODELS.register_module()
+class FPN(BaseModule):
+    """Feature Pyramid Network.
+
+    This neck is the implementation of `Feature Pyramid Networks for Object
+    Detection <https://arxiv.org/abs/1612.03144>`_.
+
+    Args:
+        in_channels (list[int]): Number of input channels per scale.
+        out_channels (int): Number of output channels (used at each scale).
+        num_outs (int): Number of output scales.
+        start_level (int): Index of the start input backbone level used to
+            build the feature pyramid. Default: 0.
+        end_level (int): Index of the end input backbone level (exclusive) to
+            build the feature pyramid. Default: -1, which means the last level.
+        add_extra_convs (bool | str): If bool, it decides whether to add conv
+            layers on top of the original feature maps. Default to False.
+            If True, its actual mode is specified by `extra_convs_on_inputs`.
+            If str, it specifies the source feature map of the extra convs.
+            Only the following options are allowed
+
+            - 'on_input': Last feat map of neck inputs (i.e. backbone feature).
+            - 'on_lateral': Last feature map after lateral convs.
+            - 'on_output': The last output feature map after fpn convs.
+        extra_convs_on_inputs (bool, deprecated): Whether to apply extra convs
+            on the original feature from the backbone. If True,
+            it is equivalent to `add_extra_convs='on_input'`. If False, it is
+            equivalent to set `add_extra_convs='on_output'`. Default to True.
+        relu_before_extra_convs (bool): Whether to apply relu before the extra
+            conv. Default: False.
+        no_norm_on_lateral (bool): Whether to apply norm on lateral.
+            Default: False.
+        conv_cfg (dict): Config dict for convolution layer. Default: None.
+        norm_cfg (dict): Config dict for normalization layer. Default: None.
+        act_cfg (dict): Config dict for activation layer in ConvModule.
+            Default: None.
+        upsample_cfg (dict): Config dict for interpolate layer.
+            Default: dict(mode='nearest').
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+
+    Example:
+        >>> import torch
+        >>> in_channels = [2, 3, 5, 7]
+        >>> scales = [340, 170, 84, 43]
+        >>> inputs = [torch.rand(1, c, s, s)
+        ...           for c, s in zip(in_channels, scales)]
+        >>> self = FPN(in_channels, 11, len(in_channels)).eval()
+        >>> outputs = self.forward(inputs)
+        >>> for i in range(len(outputs)):
+        ...     print(f'outputs[{i}].shape = {outputs[i].shape}')
+        outputs[0].shape = torch.Size([1, 11, 340, 340])
+        outputs[1].shape = torch.Size([1, 11, 170, 170])
+        outputs[2].shape = torch.Size([1, 11, 84, 84])
+        outputs[3].shape = torch.Size([1, 11, 43, 43])
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 num_outs,
+                 start_level=0,
+                 end_level=-1,
+                 add_extra_convs=False,
+                 extra_convs_on_inputs=False,
+                 relu_before_extra_convs=False,
+                 no_norm_on_lateral=False,
+                 conv_cfg=None,
+                 norm_cfg=None,
+                 act_cfg=None,
+                 upsample_cfg=dict(mode='nearest'),
+                 init_cfg=dict(
+                     type='Xavier', layer='Conv2d', distribution='uniform')):
+        super().__init__(init_cfg)
+        assert isinstance(in_channels, list)
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.num_ins = len(in_channels)
+        self.num_outs = num_outs
+        self.relu_before_extra_convs = relu_before_extra_convs
+        self.no_norm_on_lateral = no_norm_on_lateral
+        self.fp16_enabled = False
+        self.upsample_cfg = upsample_cfg.copy()
+
+        if end_level == -1:
+            self.backbone_end_level = self.num_ins
+            assert num_outs >= self.num_ins - start_level
+        else:
+            # if end_level < inputs, no extra level is allowed
+            self.backbone_end_level = end_level
+            assert end_level <= len(in_channels)
+            assert num_outs == end_level - start_level
+        self.start_level = start_level
+        self.end_level = end_level
+        self.add_extra_convs = add_extra_convs
+        assert isinstance(add_extra_convs, (str, bool))
+        if isinstance(add_extra_convs, str):
+            # Extra_convs_source choices: 'on_input', 'on_lateral', 'on_output'
+            assert add_extra_convs in ('on_input', 'on_lateral', 'on_output')
+        elif add_extra_convs:  # True
+            if extra_convs_on_inputs:
+                # For compatibility with previous release
+                # TODO: deprecate `extra_convs_on_inputs`
+                self.add_extra_convs = 'on_input'
+            else:
+                self.add_extra_convs = 'on_output'
+
+        self.lateral_convs = nn.ModuleList()
+        self.fpn_convs = nn.ModuleList()
+
+        for i in range(self.start_level, self.backbone_end_level):
+            l_conv = ConvModule(
+                in_channels[i],
+                out_channels,
+                1,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg if not self.no_norm_on_lateral else None,
+                act_cfg=act_cfg,
+                inplace=False)
+            fpn_conv = ConvModule(
+                out_channels,
+                out_channels,
+                3,
+                padding=1,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg,
+                inplace=False)
+
+            self.lateral_convs.append(l_conv)
+            self.fpn_convs.append(fpn_conv)
+
+        # add extra conv layers (e.g., RetinaNet)
+        extra_levels = num_outs - self.backbone_end_level + self.start_level
+        if self.add_extra_convs and extra_levels >= 1:
+            for i in range(extra_levels):
+                if i == 0 and self.add_extra_convs == 'on_input':
+                    in_channels = self.in_channels[self.backbone_end_level - 1]
+                else:
+                    in_channels = out_channels
+                extra_fpn_conv = ConvModule(
+                    in_channels,
+                    out_channels,
+                    3,
+                    stride=2,
+                    padding=1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg,
+                    inplace=False)
+                self.fpn_convs.append(extra_fpn_conv)
+
+    def forward(self, inputs):
+        assert len(inputs) == len(self.in_channels)
+
+        # build laterals
+        laterals = [
+            lateral_conv(inputs[i + self.start_level])
+            for i, lateral_conv in enumerate(self.lateral_convs)
+        ]
+
+        # build top-down path
+        used_backbone_levels = len(laterals)
+        for i in range(used_backbone_levels - 1, 0, -1):
+            # In some cases, fixing `scale factor` (e.g. 2) is preferred, but
+            #  it cannot co-exist with `size` in `F.interpolate`.
+            if 'scale_factor' in self.upsample_cfg:
+                laterals[i - 1] = laterals[i - 1] + resize(
+                    laterals[i], **self.upsample_cfg)
+            else:
+                prev_shape = laterals[i - 1].shape[2:]
+                laterals[i - 1] = laterals[i - 1] + resize(
+                    laterals[i], size=prev_shape, **self.upsample_cfg)
+
+        # build outputs
+        # part 1: from original levels
+        outs = [
+            self.fpn_convs[i](laterals[i]) for i in range(used_backbone_levels)
+        ]
+        # part 2: add extra levels
+        if self.num_outs > len(outs):
+            # use max pool to get more levels on top of outputs
+            # (e.g., Faster R-CNN, Mask R-CNN)
+            if not self.add_extra_convs:
+                for i in range(self.num_outs - used_backbone_levels):
+                    outs.append(F.max_pool2d(outs[-1], 1, stride=2))
+            # add conv layers on top of original feature maps (RetinaNet)
+            else:
+                if self.add_extra_convs == 'on_input':
+                    extra_source = inputs[self.backbone_end_level - 1]
+                elif self.add_extra_convs == 'on_lateral':
+                    extra_source = laterals[-1]
+                elif self.add_extra_convs == 'on_output':
+                    extra_source = outs[-1]
+                else:
+                    raise NotImplementedError
+                outs.append(self.fpn_convs[used_backbone_levels](extra_source))
+                for i in range(used_backbone_levels + 1, self.num_outs):
+                    if self.relu_before_extra_convs:
+                        outs.append(self.fpn_convs[i](F.relu(outs[-1])))
+                    else:
+                        outs.append(self.fpn_convs[i](outs[-1]))
+        return tuple(outs)
diff --git a/mmsegmentation/mmseg/models/necks/ic_neck.py b/mmsegmentation/mmseg/models/necks/ic_neck.py
new file mode 100644
index 0000000..9763541
--- /dev/null
+++ b/mmsegmentation/mmseg/models/necks/ic_neck.py
@@ -0,0 +1,148 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule
+
+from mmseg.registry import MODELS
+from ..utils import resize
+
+
+class CascadeFeatureFusion(BaseModule):
+    """Cascade Feature Fusion Unit in ICNet.
+
+    Args:
+        low_channels (int): The number of input channels for
+            low resolution feature map.
+        high_channels (int): The number of input channels for
+            high resolution feature map.
+        out_channels (int): The number of output channels.
+        conv_cfg (dict): Dictionary to construct and config conv layer.
+            Default: None.
+        norm_cfg (dict): Dictionary to construct and config norm layer.
+            Default: dict(type='BN').
+        act_cfg (dict): Dictionary to construct and config act layer.
+            Default: dict(type='ReLU').
+        align_corners (bool): align_corners argument of F.interpolate.
+            Default: False.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+
+    Returns:
+        x (Tensor): The output tensor of shape (N, out_channels, H, W).
+        x_low (Tensor): The output tensor of shape (N, out_channels, H, W)
+            for Cascade Label Guidance in auxiliary heads.
+    """
+
+    def __init__(self,
+                 low_channels,
+                 high_channels,
+                 out_channels,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 align_corners=False,
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        self.align_corners = align_corners
+        self.conv_low = ConvModule(
+            low_channels,
+            out_channels,
+            3,
+            padding=2,
+            dilation=2,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        self.conv_high = ConvModule(
+            high_channels,
+            out_channels,
+            1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+
+    def forward(self, x_low, x_high):
+        x_low = resize(
+            x_low,
+            size=x_high.size()[2:],
+            mode='bilinear',
+            align_corners=self.align_corners)
+        # Note: Different from original paper, `x_low` is underwent
+        # `self.conv_low` rather than another 1x1 conv classifier
+        #  before being used for auxiliary head.
+        x_low = self.conv_low(x_low)
+        x_high = self.conv_high(x_high)
+        x = x_low + x_high
+        x = F.relu(x, inplace=True)
+        return x, x_low
+
+
+@MODELS.register_module()
+class ICNeck(BaseModule):
+    """ICNet for Real-Time Semantic Segmentation on High-Resolution Images.
+
+    This head is the implementation of `ICHead
+    <https://arxiv.org/abs/1704.08545>`_.
+
+    Args:
+        in_channels (int): The number of input image channels. Default: 3.
+        out_channels (int): The numbers of output feature channels.
+            Default: 128.
+        conv_cfg (dict): Dictionary to construct and config conv layer.
+            Default: None.
+        norm_cfg (dict): Dictionary to construct and config norm layer.
+            Default: dict(type='BN').
+        act_cfg (dict): Dictionary to construct and config act layer.
+            Default: dict(type='ReLU').
+        align_corners (bool): align_corners argument of F.interpolate.
+            Default: False.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    """
+
+    def __init__(self,
+                 in_channels=(64, 256, 256),
+                 out_channels=128,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 align_corners=False,
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        assert len(in_channels) == 3, 'Length of input channels \
+                                        must be 3!'
+
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+        self.align_corners = align_corners
+        self.cff_24 = CascadeFeatureFusion(
+            self.in_channels[2],
+            self.in_channels[1],
+            self.out_channels,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg,
+            align_corners=self.align_corners)
+
+        self.cff_12 = CascadeFeatureFusion(
+            self.out_channels,
+            self.in_channels[0],
+            self.out_channels,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg,
+            align_corners=self.align_corners)
+
+    def forward(self, inputs):
+        assert len(inputs) == 3, 'Length of input feature \
+                                        maps must be 3!'
+
+        x_sub1, x_sub2, x_sub4 = inputs
+        x_cff_24, x_24 = self.cff_24(x_sub4, x_sub2)
+        x_cff_12, x_12 = self.cff_12(x_cff_24, x_sub1)
+        # Note: `x_cff_12` is used for decode_head,
+        # `x_24` and `x_12` are used for auxiliary head.
+        return x_24, x_12, x_cff_12
diff --git a/mmsegmentation/mmseg/models/necks/jpu.py b/mmsegmentation/mmseg/models/necks/jpu.py
new file mode 100644
index 0000000..3ea0fe2
--- /dev/null
+++ b/mmsegmentation/mmseg/models/necks/jpu.py
@@ -0,0 +1,131 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule, DepthwiseSeparableConvModule
+from mmengine.model import BaseModule
+
+from mmseg.registry import MODELS
+from ..utils import resize
+
+
+@MODELS.register_module()
+class JPU(BaseModule):
+    """FastFCN: Rethinking Dilated Convolution in the Backbone
+    for Semantic Segmentation.
+
+    This Joint Pyramid Upsampling (JPU) neck is the implementation of
+    `FastFCN <https://arxiv.org/abs/1903.11816>`_.
+
+    Args:
+        in_channels (Tuple[int], optional): The number of input channels
+            for each convolution operations before upsampling.
+            Default: (512, 1024, 2048).
+        mid_channels (int): The number of output channels of JPU.
+            Default: 512.
+        start_level (int): Index of the start input backbone level used to
+            build the feature pyramid. Default: 0.
+        end_level (int): Index of the end input backbone level (exclusive) to
+            build the feature pyramid. Default: -1, which means the last level.
+        dilations (tuple[int]): Dilation rate of each Depthwise
+            Separable ConvModule. Default: (1, 2, 4, 8).
+        align_corners (bool, optional): The align_corners argument of
+            resize operation. Default: False.
+        conv_cfg (dict | None): Config of conv layers.
+            Default: None.
+        norm_cfg (dict | None): Config of norm layers.
+            Default: dict(type='BN').
+        act_cfg (dict): Config of activation layers.
+            Default: dict(type='ReLU').
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    """
+
+    def __init__(self,
+                 in_channels=(512, 1024, 2048),
+                 mid_channels=512,
+                 start_level=0,
+                 end_level=-1,
+                 dilations=(1, 2, 4, 8),
+                 align_corners=False,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        assert isinstance(in_channels, tuple)
+        assert isinstance(dilations, tuple)
+        self.in_channels = in_channels
+        self.mid_channels = mid_channels
+        self.start_level = start_level
+        self.num_ins = len(in_channels)
+        if end_level == -1:
+            self.backbone_end_level = self.num_ins
+        else:
+            self.backbone_end_level = end_level
+            assert end_level <= len(in_channels)
+
+        self.dilations = dilations
+        self.align_corners = align_corners
+
+        self.conv_layers = nn.ModuleList()
+        self.dilation_layers = nn.ModuleList()
+        for i in range(self.start_level, self.backbone_end_level):
+            conv_layer = nn.Sequential(
+                ConvModule(
+                    self.in_channels[i],
+                    self.mid_channels,
+                    kernel_size=3,
+                    padding=1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg))
+            self.conv_layers.append(conv_layer)
+        for i in range(len(dilations)):
+            dilation_layer = nn.Sequential(
+                DepthwiseSeparableConvModule(
+                    in_channels=(self.backbone_end_level - self.start_level) *
+                    self.mid_channels,
+                    out_channels=self.mid_channels,
+                    kernel_size=3,
+                    stride=1,
+                    padding=dilations[i],
+                    dilation=dilations[i],
+                    dw_norm_cfg=norm_cfg,
+                    dw_act_cfg=None,
+                    pw_norm_cfg=norm_cfg,
+                    pw_act_cfg=act_cfg))
+            self.dilation_layers.append(dilation_layer)
+
+    def forward(self, inputs):
+        """Forward function."""
+        assert len(inputs) == len(self.in_channels), 'Length of inputs must \
+                                           be the same with self.in_channels!'
+
+        feats = [
+            self.conv_layers[i - self.start_level](inputs[i])
+            for i in range(self.start_level, self.backbone_end_level)
+        ]
+
+        h, w = feats[0].shape[2:]
+        for i in range(1, len(feats)):
+            feats[i] = resize(
+                feats[i],
+                size=(h, w),
+                mode='bilinear',
+                align_corners=self.align_corners)
+
+        feat = torch.cat(feats, dim=1)
+        concat_feat = torch.cat([
+            self.dilation_layers[i](feat) for i in range(len(self.dilations))
+        ],
+                                dim=1)
+
+        outs = []
+
+        # Default: outs[2] is the output of JPU for decoder head, outs[1] is
+        # the feature map from backbone for auxiliary head. Additionally,
+        # outs[0] can also be used for auxiliary head.
+        for i in range(self.start_level, self.backbone_end_level - 1):
+            outs.append(inputs[i])
+        outs.append(concat_feat)
+        return tuple(outs)
diff --git a/mmsegmentation/mmseg/models/necks/mla_neck.py b/mmsegmentation/mmseg/models/necks/mla_neck.py
new file mode 100644
index 0000000..db250ae
--- /dev/null
+++ b/mmsegmentation/mmseg/models/necks/mla_neck.py
@@ -0,0 +1,118 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch.nn as nn
+from mmcv.cnn import ConvModule, build_norm_layer
+
+from mmseg.registry import MODELS
+
+
+class MLAModule(nn.Module):
+
+    def __init__(self,
+                 in_channels=[1024, 1024, 1024, 1024],
+                 out_channels=256,
+                 norm_cfg=None,
+                 act_cfg=None):
+        super().__init__()
+        self.channel_proj = nn.ModuleList()
+        for i in range(len(in_channels)):
+            self.channel_proj.append(
+                ConvModule(
+                    in_channels=in_channels[i],
+                    out_channels=out_channels,
+                    kernel_size=1,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg))
+        self.feat_extract = nn.ModuleList()
+        for i in range(len(in_channels)):
+            self.feat_extract.append(
+                ConvModule(
+                    in_channels=out_channels,
+                    out_channels=out_channels,
+                    kernel_size=3,
+                    padding=1,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg))
+
+    def forward(self, inputs):
+
+        # feat_list -> [p2, p3, p4, p5]
+        feat_list = []
+        for x, conv in zip(inputs, self.channel_proj):
+            feat_list.append(conv(x))
+
+        # feat_list -> [p5, p4, p3, p2]
+        # mid_list -> [m5, m4, m3, m2]
+        feat_list = feat_list[::-1]
+        mid_list = []
+        for feat in feat_list:
+            if len(mid_list) == 0:
+                mid_list.append(feat)
+            else:
+                mid_list.append(mid_list[-1] + feat)
+
+        # mid_list -> [m5, m4, m3, m2]
+        # out_list -> [o2, o3, o4, o5]
+        out_list = []
+        for mid, conv in zip(mid_list, self.feat_extract):
+            out_list.append(conv(mid))
+
+        return tuple(out_list)
+
+
+@MODELS.register_module()
+class MLANeck(nn.Module):
+    """Multi-level Feature Aggregation.
+
+    This neck is `The Multi-level Feature Aggregation construction of
+    SETR <https://arxiv.org/abs/2012.15840>`_.
+
+
+    Args:
+        in_channels (List[int]): Number of input channels per scale.
+        out_channels (int): Number of output channels (used at each scale).
+        norm_layer (dict): Config dict for input normalization.
+            Default: norm_layer=dict(type='LN', eps=1e-6, requires_grad=True).
+        norm_cfg (dict): Config dict for normalization layer. Default: None.
+        act_cfg (dict): Config dict for activation layer in ConvModule.
+            Default: None.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 norm_layer=dict(type='LN', eps=1e-6, requires_grad=True),
+                 norm_cfg=None,
+                 act_cfg=None):
+        super().__init__()
+        assert isinstance(in_channels, list)
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+
+        # In order to build general vision transformer backbone, we have to
+        # move MLA to neck.
+        self.norm = nn.ModuleList([
+            build_norm_layer(norm_layer, in_channels[i])[1]
+            for i in range(len(in_channels))
+        ])
+
+        self.mla = MLAModule(
+            in_channels=in_channels,
+            out_channels=out_channels,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+
+    def forward(self, inputs):
+        assert len(inputs) == len(self.in_channels)
+
+        # Convert from nchw to nlc
+        outs = []
+        for i in range(len(inputs)):
+            x = inputs[i]
+            n, c, h, w = x.shape
+            x = x.reshape(n, c, h * w).transpose(2, 1).contiguous()
+            x = self.norm[i](x)
+            x = x.transpose(1, 2).reshape(n, c, h, w).contiguous()
+            outs.append(x)
+
+        outs = self.mla(outs)
+        return tuple(outs)
diff --git a/mmsegmentation/mmseg/models/necks/multilevel_neck.py b/mmsegmentation/mmseg/models/necks/multilevel_neck.py
new file mode 100644
index 0000000..c997125
--- /dev/null
+++ b/mmsegmentation/mmseg/models/necks/multilevel_neck.py
@@ -0,0 +1,79 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmengine.model.weight_init import xavier_init
+
+from mmseg.registry import MODELS
+from ..utils import resize
+
+
+@MODELS.register_module()
+class MultiLevelNeck(nn.Module):
+    """MultiLevelNeck.
+
+    A neck structure connect vit backbone and decoder_heads.
+
+    Args:
+        in_channels (List[int]): Number of input channels per scale.
+        out_channels (int): Number of output channels (used at each scale).
+        scales (List[float]): Scale factors for each input feature map.
+            Default: [0.5, 1, 2, 4]
+        norm_cfg (dict): Config dict for normalization layer. Default: None.
+        act_cfg (dict): Config dict for activation layer in ConvModule.
+            Default: None.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 scales=[0.5, 1, 2, 4],
+                 norm_cfg=None,
+                 act_cfg=None):
+        super().__init__()
+        assert isinstance(in_channels, list)
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.scales = scales
+        self.num_outs = len(scales)
+        self.lateral_convs = nn.ModuleList()
+        self.convs = nn.ModuleList()
+        for in_channel in in_channels:
+            self.lateral_convs.append(
+                ConvModule(
+                    in_channel,
+                    out_channels,
+                    kernel_size=1,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg))
+        for _ in range(self.num_outs):
+            self.convs.append(
+                ConvModule(
+                    out_channels,
+                    out_channels,
+                    kernel_size=3,
+                    padding=1,
+                    stride=1,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg))
+
+    # default init_weights for conv(msra) and norm in ConvModule
+    def init_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                xavier_init(m, distribution='uniform')
+
+    def forward(self, inputs):
+        assert len(inputs) == len(self.in_channels)
+        inputs = [
+            lateral_conv(inputs[i])
+            for i, lateral_conv in enumerate(self.lateral_convs)
+        ]
+        # for len(inputs) not equal to self.num_outs
+        if len(inputs) == 1:
+            inputs = [inputs[0] for _ in range(self.num_outs)]
+        outs = []
+        for i in range(self.num_outs):
+            x_resize = resize(
+                inputs[i], scale_factor=self.scales[i], mode='bilinear')
+            outs.append(self.convs[i](x_resize))
+        return tuple(outs)
diff --git a/mmsegmentation/mmseg/models/segmentors/__init__.py b/mmsegmentation/mmseg/models/segmentors/__init__.py
new file mode 100644
index 0000000..80bced1
--- /dev/null
+++ b/mmsegmentation/mmseg/models/segmentors/__init__.py
@@ -0,0 +1,13 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .base import BaseSegmentor
+from .cascade_encoder_decoder import CascadeEncoderDecoder
+from .depth_estimator import DepthEstimator
+from .encoder_decoder import EncoderDecoder
+from .multimodal_encoder_decoder import MultimodalEncoderDecoder
+from .seg_tta import SegTTAModel
+from .custom import EncoderDecoderWithoutArgmax
+
+__all__ = [
+    'BaseSegmentor', 'EncoderDecoder', 'CascadeEncoderDecoder', 'SegTTAModel',
+    'MultimodalEncoderDecoder', 'DepthEstimator', 'EncoderDecoderWithoutArgmax'
+]
diff --git a/mmsegmentation/mmseg/models/segmentors/base.py b/mmsegmentation/mmseg/models/segmentors/base.py
new file mode 100644
index 0000000..17a0bb2
--- /dev/null
+++ b/mmsegmentation/mmseg/models/segmentors/base.py
@@ -0,0 +1,200 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from abc import ABCMeta, abstractmethod
+from typing import List, Tuple
+
+from mmengine.model import BaseModel
+from mmengine.structures import PixelData
+from torch import Tensor
+
+from mmseg.structures import SegDataSample
+from mmseg.utils import (ForwardResults, OptConfigType, OptMultiConfig,
+                         OptSampleList, SampleList)
+from ..utils import resize
+
+
+class BaseSegmentor(BaseModel, metaclass=ABCMeta):
+    """Base class for segmentors.
+
+    Args:
+        data_preprocessor (dict, optional): Model preprocessing config
+            for processing the input data. it usually includes
+            ``to_rgb``, ``pad_size_divisor``, ``pad_val``,
+            ``mean`` and ``std``. Default to None.
+       init_cfg (dict, optional): the config to control the
+           initialization. Default to None.
+    """
+
+    def __init__(self,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None):
+        super().__init__(
+            data_preprocessor=data_preprocessor, init_cfg=init_cfg)
+
+    @property
+    def with_neck(self) -> bool:
+        """bool: whether the segmentor has neck"""
+        return hasattr(self, 'neck') and self.neck is not None
+
+    @property
+    def with_auxiliary_head(self) -> bool:
+        """bool: whether the segmentor has auxiliary head"""
+        return hasattr(self,
+                       'auxiliary_head') and self.auxiliary_head is not None
+
+    @property
+    def with_decode_head(self) -> bool:
+        """bool: whether the segmentor has decode head"""
+        return hasattr(self, 'decode_head') and self.decode_head is not None
+
+    @abstractmethod
+    def extract_feat(self, inputs: Tensor) -> bool:
+        """Placeholder for extract features from images."""
+        pass
+
+    @abstractmethod
+    def encode_decode(self, inputs: Tensor, batch_data_samples: SampleList):
+        """Placeholder for encode images with backbone and decode into a
+        semantic segmentation map of the same size as input."""
+        pass
+
+    def forward(self,
+                inputs: Tensor,
+                data_samples: OptSampleList = None,
+                mode: str = 'tensor') -> ForwardResults:
+        """The unified entry for a forward process in both training and test.
+
+        The method should accept three modes: "tensor", "predict" and "loss":
+
+        - "tensor": Forward the whole network and return tensor or tuple of
+        tensor without any post-processing, same as a common nn.Module.
+        - "predict": Forward and return the predictions, which are fully
+        processed to a list of :obj:`SegDataSample`.
+        - "loss": Forward and return a dict of losses according to the given
+        inputs and data samples.
+
+        Note that this method doesn't handle neither back propagation nor
+        optimizer updating, which are done in the :meth:`train_step`.
+
+        Args:
+            inputs (torch.Tensor): The input tensor with shape (N, C, ...) in
+                general.
+            data_samples (list[:obj:`SegDataSample`]): The seg data samples.
+                It usually includes information such as `metainfo` and
+                `gt_sem_seg`. Default to None.
+            mode (str): Return what kind of value. Defaults to 'tensor'.
+
+        Returns:
+            The return type depends on ``mode``.
+
+            - If ``mode="tensor"``, return a tensor or a tuple of tensor.
+            - If ``mode="predict"``, return a list of :obj:`DetDataSample`.
+            - If ``mode="loss"``, return a dict of tensor.
+        """
+        if mode == 'loss':
+            return self.loss(inputs, data_samples)
+        elif mode == 'predict':
+            return self.predict(inputs, data_samples)
+        elif mode == 'tensor':
+            return self._forward(inputs, data_samples)
+        else:
+            raise RuntimeError(f'Invalid mode "{mode}". '
+                               'Only supports loss, predict and tensor mode')
+
+    @abstractmethod
+    def loss(self, inputs: Tensor, data_samples: SampleList) -> dict:
+        """Calculate losses from a batch of inputs and data samples."""
+        pass
+
+    @abstractmethod
+    def predict(self,
+                inputs: Tensor,
+                data_samples: OptSampleList = None) -> SampleList:
+        """Predict results from a batch of inputs and data samples with post-
+        processing."""
+        pass
+
+    @abstractmethod
+    def _forward(self,
+                 inputs: Tensor,
+                 data_samples: OptSampleList = None) -> Tuple[List[Tensor]]:
+        """Network forward process.
+
+        Usually includes backbone, neck and head forward without any post-
+        processing.
+        """
+        pass
+
+    def postprocess_result(self,
+                           seg_logits: Tensor,
+                           data_samples: OptSampleList = None) -> SampleList:
+        """ Convert results list to `SegDataSample`.
+        Args:
+            seg_logits (Tensor): The segmentation results, seg_logits from
+                model of each input image.
+            data_samples (list[:obj:`SegDataSample`]): The seg data samples.
+                It usually includes information such as `metainfo` and
+                `gt_sem_seg`. Default to None.
+        Returns:
+            list[:obj:`SegDataSample`]: Segmentation results of the
+            input images. Each SegDataSample usually contain:
+
+            - ``pred_sem_seg``(PixelData): Prediction of semantic segmentation.
+            - ``seg_logits``(PixelData): Predicted logits of semantic
+                segmentation before normalization.
+        """
+        batch_size, C, H, W = seg_logits.shape
+
+        if data_samples is None:
+            data_samples = [SegDataSample() for _ in range(batch_size)]
+            only_prediction = True
+        else:
+            only_prediction = False
+
+        for i in range(batch_size):
+            if not only_prediction:
+                img_meta = data_samples[i].metainfo
+                # remove padding area
+                if 'img_padding_size' not in img_meta:
+                    padding_size = img_meta.get('padding_size', [0] * 4)
+                else:
+                    padding_size = img_meta['img_padding_size']
+                padding_left, padding_right, padding_top, padding_bottom =\
+                    padding_size
+                # i_seg_logits shape is 1, C, H, W after remove padding
+                i_seg_logits = seg_logits[i:i + 1, :,
+                                          padding_top:H - padding_bottom,
+                                          padding_left:W - padding_right]
+
+                flip = img_meta.get('flip', None)
+                if flip:
+                    flip_direction = img_meta.get('flip_direction', None)
+                    assert flip_direction in ['horizontal', 'vertical']
+                    if flip_direction == 'horizontal':
+                        i_seg_logits = i_seg_logits.flip(dims=(3, ))
+                    else:
+                        i_seg_logits = i_seg_logits.flip(dims=(2, ))
+
+                # resize as original shape
+                i_seg_logits = resize(
+                    i_seg_logits,
+                    size=img_meta['ori_shape'],
+                    mode='bilinear',
+                    align_corners=self.align_corners,
+                    warning=False).squeeze(0)
+            else:
+                i_seg_logits = seg_logits[i]
+
+            if C > 1:
+                i_seg_pred = i_seg_logits.argmax(dim=0, keepdim=True)
+            else:
+                i_seg_logits = i_seg_logits.sigmoid()
+                i_seg_pred = (i_seg_logits >
+                              self.decode_head.threshold).to(i_seg_logits)
+            data_samples[i].set_data({
+                'seg_logits':
+                PixelData(**{'data': i_seg_logits}),
+                'pred_sem_seg':
+                PixelData(**{'data': i_seg_pred})
+            })
+
+        return data_samples
diff --git a/mmsegmentation/mmseg/models/segmentors/cascade_encoder_decoder.py b/mmsegmentation/mmseg/models/segmentors/cascade_encoder_decoder.py
new file mode 100644
index 0000000..0184a35
--- /dev/null
+++ b/mmsegmentation/mmseg/models/segmentors/cascade_encoder_decoder.py
@@ -0,0 +1,138 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional
+
+from torch import Tensor, nn
+
+from mmseg.registry import MODELS
+from mmseg.utils import (ConfigType, OptConfigType, OptMultiConfig,
+                         OptSampleList, SampleList, add_prefix)
+from .encoder_decoder import EncoderDecoder
+
+
+@MODELS.register_module()
+class CascadeEncoderDecoder(EncoderDecoder):
+    """Cascade Encoder Decoder segmentors.
+
+    CascadeEncoderDecoder almost the same as EncoderDecoder, while decoders of
+    CascadeEncoderDecoder are cascaded. The output of previous decoder_head
+    will be the input of next decoder_head.
+
+    Args:
+
+        num_stages (int): How many stages will be cascaded.
+        backbone (ConfigType): The config for the backnone of segmentor.
+        decode_head (ConfigType): The config for the decode head of segmentor.
+        neck (OptConfigType): The config for the neck of segmentor.
+            Defaults to None.
+        auxiliary_head (OptConfigType): The config for the auxiliary head of
+            segmentor. Defaults to None.
+        train_cfg (OptConfigType): The config for training. Defaults to None.
+        test_cfg (OptConfigType): The config for testing. Defaults to None.
+        data_preprocessor (dict, optional): The pre-process config of
+            :class:`BaseDataPreprocessor`.
+        pretrained (str, optional): The path for pretrained model.
+            Defaults to None.
+        init_cfg (dict, optional): The weight initialized config for
+            :class:`BaseModule`.
+    """
+
+    def __init__(self,
+                 num_stages: int,
+                 backbone: ConfigType,
+                 decode_head: ConfigType,
+                 neck: OptConfigType = None,
+                 auxiliary_head: OptConfigType = None,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 pretrained: Optional[str] = None,
+                 init_cfg: OptMultiConfig = None):
+        self.num_stages = num_stages
+        super().__init__(
+            backbone=backbone,
+            decode_head=decode_head,
+            neck=neck,
+            auxiliary_head=auxiliary_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            pretrained=pretrained,
+            init_cfg=init_cfg)
+
+    def _init_decode_head(self, decode_head: ConfigType) -> None:
+        """Initialize ``decode_head``"""
+        assert isinstance(decode_head, list)
+        assert len(decode_head) == self.num_stages
+        self.decode_head = nn.ModuleList()
+        for i in range(self.num_stages):
+            self.decode_head.append(MODELS.build(decode_head[i]))
+        self.align_corners = self.decode_head[-1].align_corners
+        self.num_classes = self.decode_head[-1].num_classes
+        self.out_channels = self.decode_head[-1].out_channels
+
+    def encode_decode(self, inputs: Tensor,
+                      batch_img_metas: List[dict]) -> Tensor:
+        """Encode images with backbone and decode into a semantic segmentation
+        map of the same size as input."""
+        x = self.extract_feat(inputs)
+        out = self.decode_head[0].forward(x)
+        for i in range(1, self.num_stages - 1):
+            out = self.decode_head[i].forward(x, out)
+        seg_logits_list = self.decode_head[-1].predict(x, out, batch_img_metas,
+                                                       self.test_cfg)
+
+        return seg_logits_list
+
+    def _decode_head_forward_train(self, inputs: Tensor,
+                                   data_samples: SampleList) -> dict:
+        """Run forward function and calculate loss for decode head in
+        training."""
+        losses = dict()
+
+        loss_decode = self.decode_head[0].loss(inputs, data_samples,
+                                               self.train_cfg)
+
+        losses.update(add_prefix(loss_decode, 'decode_0'))
+        # get batch_img_metas
+        batch_size = len(data_samples)
+        batch_img_metas = []
+        for batch_index in range(batch_size):
+            metainfo = data_samples[batch_index].metainfo
+            batch_img_metas.append(metainfo)
+
+        for i in range(1, self.num_stages):
+            # forward test again, maybe unnecessary for most methods.
+            if i == 1:
+                prev_outputs = self.decode_head[0].forward(inputs)
+            else:
+                prev_outputs = self.decode_head[i - 1].forward(
+                    inputs, prev_outputs)
+            loss_decode = self.decode_head[i].loss(inputs, prev_outputs,
+                                                   data_samples,
+                                                   self.train_cfg)
+            losses.update(add_prefix(loss_decode, f'decode_{i}'))
+
+        return losses
+
+    def _forward(self,
+                 inputs: Tensor,
+                 data_samples: OptSampleList = None) -> Tensor:
+        """Network forward process.
+
+        Args:
+            inputs (Tensor): Inputs with shape (N, C, H, W).
+            data_samples (List[:obj:`SegDataSample`]): The seg data samples.
+                It usually includes information such as `metainfo` and
+                `gt_semantic_seg`.
+
+        Returns:
+            Tensor: Forward output of model without any post-processes.
+        """
+        x = self.extract_feat(inputs)
+
+        out = self.decode_head[0].forward(x)
+        for i in range(1, self.num_stages):
+            # TODO support PointRend tensor mode
+            out = self.decode_head[i].forward(x, out)
+
+        return out
diff --git a/mmsegmentation/mmseg/models/segmentors/custom.py b/mmsegmentation/mmseg/models/segmentors/custom.py
new file mode 100644
index 0000000..3a03d50
--- /dev/null
+++ b/mmsegmentation/mmseg/models/segmentors/custom.py
@@ -0,0 +1,86 @@
+from mmseg.registry import MODELS
+from mmseg.models.segmentors import EncoderDecoder
+from mmseg.structures.seg_data_sample import SegDataSample
+from mmseg.models.utils.wrappers import resize
+
+from mmengine.structures import PixelData
+
+
+class PostProcessResultMixin:
+    def postprocess_result(self, seg_logits, data_samples):
+        """Convert results list to `SegDataSample`.
+        Args:
+            seg_logits (Tensor): The segmentation results, seg_logits from
+                model of each input image.
+            data_samples (list[:obj:`SegDataSample`]): The seg data samples.
+                It usually includes information such as `metainfo` and
+                `gt_sem_seg`. Default to None.
+        Returns:
+            list[:obj:`SegDataSample`]: Segmentation results of the
+            input images. Each SegDataSample usually contain:
+
+            - ``pred_sem_seg``(PixelData): Prediction of semantic segmentation.
+            - ``seg_logits``(PixelData): Predicted logits of semantic
+                segmentation before normalization.
+        """
+        batch_size, C, H, W = seg_logits.shape
+
+        if data_samples is None:
+            data_samples = [SegDataSample() for _ in range(batch_size)]
+            only_prediction = True
+        else:
+            only_prediction = False
+
+        for i in range(batch_size):
+            if not only_prediction:
+                img_meta = data_samples[i].metainfo
+                # remove padding area
+                if "img_padding_size" not in img_meta:
+                    padding_size = img_meta.get("padding_size", [0] * 4)
+                else:
+                    padding_size = img_meta["img_padding_size"]
+                padding_left, padding_right, padding_top, padding_bottom = padding_size
+                # i_seg_logits shape is 1, C, H, W after remove padding
+                i_seg_logits = seg_logits[
+                    i : i + 1,
+                    :,
+                    padding_top : H - padding_bottom,
+                    padding_left : W - padding_right,
+                ]
+
+                flip = img_meta.get("flip", None)
+                if flip:
+                    flip_direction = img_meta.get("flip_direction", None)
+                    assert flip_direction in ["horizontal", "vertical"]
+                    if flip_direction == "horizontal":
+                        i_seg_logits = i_seg_logits.flip(dims=(3,))
+                    else:
+                        i_seg_logits = i_seg_logits.flip(dims=(2,))
+
+                # resize as original shape
+                i_seg_logits = resize(
+                    i_seg_logits,
+                    size=img_meta["ori_shape"],
+                    mode="bilinear",
+                    align_corners=self.align_corners,
+                    warning=False,
+                ).squeeze(0)
+            else:
+                i_seg_logits = seg_logits[i]
+
+            i_seg_logits = i_seg_logits.sigmoid()
+            i_seg_pred = (i_seg_logits > 0.5).to(i_seg_logits)
+
+            data_samples[i].set_data(
+                {
+                    "seg_logits": PixelData(**{"data": i_seg_logits}),
+                    "pred_sem_seg": PixelData(**{"data": i_seg_pred}),
+                }
+            )
+
+        return data_samples
+
+
+@MODELS.register_module()
+class EncoderDecoderWithoutArgmax(PostProcessResultMixin, EncoderDecoder):
+    pass
\ No newline at end of file
diff --git a/mmsegmentation/mmseg/models/segmentors/depth_estimator.py b/mmsegmentation/mmseg/models/segmentors/depth_estimator.py
new file mode 100644
index 0000000..1020637
--- /dev/null
+++ b/mmsegmentation/mmseg/models/segmentors/depth_estimator.py
@@ -0,0 +1,392 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import logging
+from typing import List, Optional
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmengine.logging import print_log
+from mmengine.structures import PixelData
+from torch import Tensor
+
+from mmseg.registry import MODELS
+from mmseg.structures import SegDataSample
+from mmseg.utils import (ConfigType, OptConfigType, OptMultiConfig,
+                         OptSampleList, SampleList, add_prefix)
+from ..utils import resize
+from .encoder_decoder import EncoderDecoder
+
+
+@MODELS.register_module()
+class DepthEstimator(EncoderDecoder):
+    """Encoder Decoder depth estimator.
+
+    EncoderDecoder typically consists of backbone, decode_head, auxiliary_head.
+    Note that auxiliary_head is only used for deep supervision during training,
+    which could be dumped during inference.
+
+    1. The ``loss`` method is used to calculate the loss of model,
+    which includes two steps: (1) Extracts features to obtain the feature maps
+    (2) Call the decode head loss function to forward decode head model and
+    calculate losses.
+
+    .. code:: text
+
+     loss(): extract_feat() -> _decode_head_forward_train() -> _auxiliary_head_forward_train (optional)
+     _decode_head_forward_train(): decode_head.loss()
+     _auxiliary_head_forward_train(): auxiliary_head.loss (optional)
+
+    2. The ``predict`` method is used to predict depth estimation results,
+    which includes two steps: (1) Run inference function to obtain the list of
+    depth (2) Call post-processing function to obtain list of
+    ``SegDataSample`` including ``pred_depth_map``.
+
+    .. code:: text
+
+     predict(): inference() -> postprocess_result()
+     inference(): whole_inference()/slide_inference()
+     whole_inference()/slide_inference(): encoder_decoder()
+     encoder_decoder(): extract_feat() -> decode_head.predict()
+
+    3. The ``_forward`` method is used to output the tensor by running the model,
+    which includes two steps: (1) Extracts features to obtain the feature maps
+    (2)Call the decode head forward function to forward decode head model.
+
+    .. code:: text
+
+     _forward(): extract_feat() -> _decode_head.forward()
+
+    Args:
+
+        backbone (ConfigType): The config for the backnone of depth estimator.
+        decode_head (ConfigType): The config for the decode head of depth estimator.
+        neck (OptConfigType): The config for the neck of depth estimator.
+            Defaults to None.
+        auxiliary_head (OptConfigType): The config for the auxiliary head of
+            depth estimator. Defaults to None.
+        train_cfg (OptConfigType): The config for training. Defaults to None.
+        test_cfg (OptConfigType): The config for testing. Defaults to None.
+        data_preprocessor (dict, optional): The pre-process config of
+            :class:`BaseDataPreprocessor`.
+        pretrained (str, optional): The path for pretrained model.
+            Defaults to None.
+        init_cfg (dict, optional): The weight initialized config for
+            :class:`BaseModule`.
+    """  # noqa: E501
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 decode_head: ConfigType,
+                 neck: OptConfigType = None,
+                 auxiliary_head: OptConfigType = None,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 pretrained: Optional[str] = None,
+                 init_cfg: OptMultiConfig = None):
+        super().__init__(
+            backbone=backbone,
+            decode_head=decode_head,
+            neck=neck,
+            auxiliary_head=auxiliary_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            pretrained=pretrained,
+            init_cfg=init_cfg)
+
+    def extract_feat(self,
+                     inputs: Tensor,
+                     batch_img_metas: Optional[List[dict]] = None) -> Tensor:
+        """Extract features from images."""
+
+        if getattr(self.backbone, 'class_embed_select', False) and \
+                isinstance(batch_img_metas, list) and \
+                'category_id' in batch_img_metas[0]:
+            cat_ids = [meta['category_id'] for meta in batch_img_metas]
+            cat_ids = torch.tensor(cat_ids).to(inputs.device)
+            inputs = (inputs, cat_ids)
+
+        x = self.backbone(inputs)
+        if self.with_neck:
+            x = self.neck(x)
+        return x
+
+    def encode_decode(self, inputs: Tensor,
+                      batch_img_metas: List[dict]) -> Tensor:
+        """Encode images with backbone and decode into a depth map of the same
+        size as input."""
+        x = self.extract_feat(inputs, batch_img_metas)
+        depth = self.decode_head.predict(x, batch_img_metas, self.test_cfg)
+
+        return depth
+
+    def _decode_head_forward_train(self, inputs: List[Tensor],
+                                   data_samples: SampleList) -> dict:
+        """Run forward function and calculate loss for decode head in
+        training."""
+        losses = dict()
+        loss_decode = self.decode_head.loss(inputs, data_samples,
+                                            self.train_cfg)
+
+        losses.update(add_prefix(loss_decode, 'decode'))
+        return losses
+
+    def _auxiliary_head_forward_train(self, inputs: List[Tensor],
+                                      data_samples: SampleList) -> dict:
+        """Run forward function and calculate loss for auxiliary head in
+        training."""
+        losses = dict()
+        if isinstance(self.auxiliary_head, nn.ModuleList):
+            for idx, aux_head in enumerate(self.auxiliary_head):
+                loss_aux = aux_head.loss(inputs, data_samples, self.train_cfg)
+                losses.update(add_prefix(loss_aux, f'aux_{idx}'))
+        else:
+            loss_aux = self.auxiliary_head.loss(inputs, data_samples,
+                                                self.train_cfg)
+            losses.update(add_prefix(loss_aux, 'aux'))
+
+        return losses
+
+    def loss(self, inputs: Tensor, data_samples: SampleList) -> dict:
+        """Calculate losses from a batch of inputs and data samples.
+
+        Args:
+            inputs (Tensor): Input images.
+            data_samples (list[:obj:`SegDataSample`]): The seg data samples.
+                It usually includes information such as `metainfo` and
+                `gt_depth_map`.
+
+        Returns:
+            dict[str, Tensor]: a dictionary of loss components
+        """
+        if data_samples is not None:
+            batch_img_metas = [
+                data_sample.metainfo for data_sample in data_samples
+            ]
+        else:
+            batch_img_metas = [
+                dict(
+                    ori_shape=inputs.shape[2:],
+                    img_shape=inputs.shape[2:],
+                    pad_shape=inputs.shape[2:],
+                    padding_size=[0, 0, 0, 0])
+            ] * inputs.shape[0]
+
+        x = self.extract_feat(inputs, batch_img_metas)
+
+        losses = dict()
+
+        loss_decode = self._decode_head_forward_train(x, data_samples)
+        losses.update(loss_decode)
+
+        if self.with_auxiliary_head:
+            loss_aux = self._auxiliary_head_forward_train(x, data_samples)
+            losses.update(loss_aux)
+
+        return losses
+
+    def predict(self,
+                inputs: Tensor,
+                data_samples: OptSampleList = None) -> SampleList:
+        """Predict results from a batch of inputs and data samples with post-
+        processing.
+
+        Args:
+            inputs (Tensor): Inputs with shape (N, C, H, W).
+            data_samples (List[:obj:`SegDataSample`], optional): The seg data
+                samples. It usually includes information such as `metainfo`
+                and `gt_depth_map`.
+
+        Returns:
+            list[:obj:`SegDataSample`]: Depth estimation results of the
+            input images. Each SegDataSample usually contain:
+
+            - ``pred_depth_max``(PixelData): Prediction of depth estimation.
+        """
+        if data_samples is not None:
+            batch_img_metas = [
+                data_sample.metainfo for data_sample in data_samples
+            ]
+        else:
+            batch_img_metas = [
+                dict(
+                    ori_shape=inputs.shape[2:],
+                    img_shape=inputs.shape[2:],
+                    pad_shape=inputs.shape[2:],
+                    padding_size=[0, 0, 0, 0])
+            ] * inputs.shape[0]
+
+        depth = self.inference(inputs, batch_img_metas)
+
+        return self.postprocess_result(depth, data_samples)
+
+    def _forward(self,
+                 inputs: Tensor,
+                 data_samples: OptSampleList = None) -> Tensor:
+        """Network forward process.
+
+        Args:
+            inputs (Tensor): Inputs with shape (N, C, H, W).
+            data_samples (List[:obj:`SegDataSample`]): The seg
+                data samples. It usually includes information such
+                as `metainfo` and `gt_depth_map`.
+
+        Returns:
+            Tensor: Forward output of model without any post-processes.
+        """
+        x = self.extract_feat(inputs)
+        return self.decode_head.forward(x)
+
+    def slide_flip_inference(self, inputs: Tensor,
+                             batch_img_metas: List[dict]) -> Tensor:
+        """Inference by sliding-window with overlap and flip.
+
+        If h_crop > h_img or w_crop > w_img, the small patch will be used to
+        decode without padding.
+
+        Args:
+            inputs (tensor): the tensor should have a shape NxCxHxW,
+                which contains all images in the batch.
+            batch_img_metas (List[dict]): List of image metainfo where each may
+                also contain: 'img_shape', 'scale_factor', 'flip', 'img_path',
+                'ori_shape', and 'pad_shape'.
+                For details on the values of these keys see
+                `mmseg/datasets/pipelines/formatting.py:PackSegInputs`.
+
+        Returns:
+            Tensor: The depth estimation results.
+        """
+
+        h_stride, w_stride = self.test_cfg.stride
+        h_crop, w_crop = self.test_cfg.crop_size
+        batch_size, _, h_img, w_img = inputs.size()
+        out_channels = self.out_channels
+        h_grids = max(h_img - h_crop + h_stride - 1, 0) // h_stride + 1
+        w_grids = max(w_img - w_crop + w_stride - 1, 0) // w_stride + 1
+        preds = inputs.new_zeros((batch_size, out_channels, h_img, w_img))
+        count_mat = inputs.new_zeros((batch_size, 1, h_img, w_img))
+        for h_idx in range(h_grids):
+            for w_idx in range(w_grids):
+                y1 = h_idx * h_stride
+                x1 = w_idx * w_stride
+                y2 = min(y1 + h_crop, h_img)
+                x2 = min(x1 + w_crop, w_img)
+                y1 = max(y2 - h_crop, 0)
+                x1 = max(x2 - w_crop, 0)
+                crop_img = inputs[:, :, y1:y2, x1:x2]
+                # change the image shape to patch shape
+                batch_img_metas[0]['img_shape'] = crop_img.shape[2:]
+                # the output of encode_decode is depth tensor map
+                # with shape [N, C, H, W]
+                crop_depth_map = self.encode_decode(crop_img, batch_img_metas)
+
+                # average out the original and flipped prediction
+                crop_depth_map_flip = self.encode_decode(
+                    crop_img.flip(dims=(3, )), batch_img_metas)
+                crop_depth_map_flip = crop_depth_map_flip.flip(dims=(3, ))
+                crop_depth_map = (crop_depth_map + crop_depth_map_flip) / 2.0
+
+                preds += F.pad(crop_depth_map,
+                               (int(x1), int(preds.shape[3] - x2), int(y1),
+                                int(preds.shape[2] - y2)))
+
+                count_mat[:, :, y1:y2, x1:x2] += 1
+        assert (count_mat == 0).sum() == 0
+        depth = preds / count_mat
+
+        return depth
+
+    def inference(self, inputs: Tensor, batch_img_metas: List[dict]) -> Tensor:
+        """Inference with slide/whole style.
+
+        Args:
+            inputs (Tensor): The input image of shape (N, 3, H, W).
+            batch_img_metas (List[dict]): List of image metainfo where each may
+                also contain: 'img_shape', 'scale_factor', 'flip', 'img_path',
+                'ori_shape', 'pad_shape', and 'padding_size'.
+                For details on the values of these keys see
+                `mmseg/datasets/pipelines/formatting.py:PackSegInputs`.
+
+        Returns:
+            Tensor: The depth estimation results.
+        """
+        assert self.test_cfg.get('mode', 'whole') in ['slide', 'whole',
+                                                      'slide_flip'], \
+            f'Only "slide", "slide_flip" or "whole" test mode are ' \
+            f'supported, but got {self.test_cfg["mode"]}.'
+        ori_shape = batch_img_metas[0]['ori_shape']
+        if not all(_['ori_shape'] == ori_shape for _ in batch_img_metas):
+            print_log(
+                'Image shapes are different in the batch.',
+                logger='current',
+                level=logging.WARN)
+        if self.test_cfg.mode == 'slide':
+            depth_map = self.slide_inference(inputs, batch_img_metas)
+        if self.test_cfg.mode == 'slide_flip':
+            depth_map = self.slide_flip_inference(inputs, batch_img_metas)
+        else:
+            depth_map = self.whole_inference(inputs, batch_img_metas)
+
+        return depth_map
+
+    def postprocess_result(self,
+                           depth: Tensor,
+                           data_samples: OptSampleList = None) -> SampleList:
+        """ Convert results list to `SegDataSample`.
+        Args:
+            depth (Tensor): The depth estimation results.
+            data_samples (list[:obj:`SegDataSample`]): The seg data samples.
+                It usually includes information such as `metainfo` and
+                `gt_depth_map`. Default to None.
+        Returns:
+            list[:obj:`SegDataSample`]: Depth estomation results of the
+            input images. Each SegDataSample usually contain:
+
+            - ``pred_depth_map``(PixelData): Prediction of depth estimation.
+        """
+        batch_size, C, H, W = depth.shape
+
+        if data_samples is None:
+            data_samples = [SegDataSample() for _ in range(batch_size)]
+            only_prediction = True
+        else:
+            only_prediction = False
+
+        for i in range(batch_size):
+            if not only_prediction:
+                img_meta = data_samples[i].metainfo
+                # remove padding area
+                if 'img_padding_size' not in img_meta:
+                    padding_size = img_meta.get('padding_size', [0] * 4)
+                else:
+                    padding_size = img_meta['img_padding_size']
+                padding_left, padding_right, padding_top, padding_bottom =\
+                    padding_size
+                # i_depth shape is 1, C, H, W after remove padding
+                i_depth = depth[i:i + 1, :, padding_top:H - padding_bottom,
+                                padding_left:W - padding_right]
+
+                flip = img_meta.get('flip', None)
+                if flip:
+                    flip_direction = img_meta.get('flip_direction', None)
+                    assert flip_direction in ['horizontal', 'vertical']
+                    if flip_direction == 'horizontal':
+                        i_depth = i_depth.flip(dims=(3, ))
+                    else:
+                        i_depth = i_depth.flip(dims=(2, ))
+
+                # resize as original shape
+                i_depth = resize(
+                    i_depth,
+                    size=img_meta['ori_shape'],
+                    mode='bilinear',
+                    align_corners=self.align_corners,
+                    warning=False).squeeze(0)
+            else:
+                i_depth = depth[i]
+
+            data_samples[i].set_data(
+                {'pred_depth_map': PixelData(**{'data': i_depth})})
+
+        return data_samples
diff --git a/mmsegmentation/mmseg/models/segmentors/encoder_decoder.py b/mmsegmentation/mmseg/models/segmentors/encoder_decoder.py
new file mode 100644
index 0000000..fa4050e
--- /dev/null
+++ b/mmsegmentation/mmseg/models/segmentors/encoder_decoder.py
@@ -0,0 +1,364 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import logging
+from typing import List, Optional
+
+import torch.nn as nn
+import torch.nn.functional as F
+from mmengine.logging import print_log
+from torch import Tensor
+
+from mmseg.registry import MODELS
+from mmseg.utils import (ConfigType, OptConfigType, OptMultiConfig,
+                         OptSampleList, SampleList, add_prefix)
+from .base import BaseSegmentor
+
+
+@MODELS.register_module()
+class EncoderDecoder(BaseSegmentor):
+    """Encoder Decoder segmentors.
+
+    EncoderDecoder typically consists of backbone, decode_head, auxiliary_head.
+    Note that auxiliary_head is only used for deep supervision during training,
+    which could be dumped during inference.
+
+    1. The ``loss`` method is used to calculate the loss of model,
+    which includes two steps: (1) Extracts features to obtain the feature maps
+    (2) Call the decode head loss function to forward decode head model and
+    calculate losses.
+
+    .. code:: text
+
+     loss(): extract_feat() -> _decode_head_forward_train() -> _auxiliary_head_forward_train (optional)
+     _decode_head_forward_train(): decode_head.loss()
+     _auxiliary_head_forward_train(): auxiliary_head.loss (optional)
+
+    2. The ``predict`` method is used to predict segmentation results,
+    which includes two steps: (1) Run inference function to obtain the list of
+    seg_logits (2) Call post-processing function to obtain list of
+    ``SegDataSample`` including ``pred_sem_seg`` and ``seg_logits``.
+
+    .. code:: text
+
+     predict(): inference() -> postprocess_result()
+     infercen(): whole_inference()/slide_inference()
+     whole_inference()/slide_inference(): encoder_decoder()
+     encoder_decoder(): extract_feat() -> decode_head.predict()
+
+    3. The ``_forward`` method is used to output the tensor by running the model,
+    which includes two steps: (1) Extracts features to obtain the feature maps
+    (2)Call the decode head forward function to forward decode head model.
+
+    .. code:: text
+
+     _forward(): extract_feat() -> _decode_head.forward()
+
+    Args:
+
+        backbone (ConfigType): The config for the backnone of segmentor.
+        decode_head (ConfigType): The config for the decode head of segmentor.
+        neck (OptConfigType): The config for the neck of segmentor.
+            Defaults to None.
+        auxiliary_head (OptConfigType): The config for the auxiliary head of
+            segmentor. Defaults to None.
+        train_cfg (OptConfigType): The config for training. Defaults to None.
+        test_cfg (OptConfigType): The config for testing. Defaults to None.
+        data_preprocessor (dict, optional): The pre-process config of
+            :class:`BaseDataPreprocessor`.
+        pretrained (str, optional): The path for pretrained model.
+            Defaults to None.
+        init_cfg (dict, optional): The weight initialized config for
+            :class:`BaseModule`.
+    """  # noqa: E501
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 decode_head: ConfigType,
+                 neck: OptConfigType = None,
+                 auxiliary_head: OptConfigType = None,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 pretrained: Optional[str] = None,
+                 init_cfg: OptMultiConfig = None):
+        super().__init__(
+            data_preprocessor=data_preprocessor, init_cfg=init_cfg)
+        if pretrained is not None:
+            assert backbone.get('pretrained') is None, \
+                'both backbone and segmentor set pretrained weight'
+            backbone.pretrained = pretrained
+        self.backbone = MODELS.build(backbone)
+        if neck is not None:
+            self.neck = MODELS.build(neck)
+        self._init_decode_head(decode_head)
+        self._init_auxiliary_head(auxiliary_head)
+
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+
+        assert self.with_decode_head
+
+    def _init_decode_head(self, decode_head: ConfigType) -> None:
+        """Initialize ``decode_head``"""
+        self.decode_head = MODELS.build(decode_head)
+        self.align_corners = self.decode_head.align_corners
+        self.num_classes = self.decode_head.num_classes
+        self.out_channels = self.decode_head.out_channels
+
+    def _init_auxiliary_head(self, auxiliary_head: ConfigType) -> None:
+        """Initialize ``auxiliary_head``"""
+        if auxiliary_head is not None:
+            if isinstance(auxiliary_head, list):
+                self.auxiliary_head = nn.ModuleList()
+                for head_cfg in auxiliary_head:
+                    self.auxiliary_head.append(MODELS.build(head_cfg))
+            else:
+                self.auxiliary_head = MODELS.build(auxiliary_head)
+
+    def extract_feat(self, inputs: Tensor) -> List[Tensor]:
+        """Extract features from images."""
+        x = self.backbone(inputs)
+        if self.with_neck:
+            x = self.neck(x)
+        return x
+
+    def encode_decode(self, inputs: Tensor,
+                      batch_img_metas: List[dict]) -> Tensor:
+        """Encode images with backbone and decode into a semantic segmentation
+        map of the same size as input."""
+        x = self.extract_feat(inputs)
+        seg_logits = self.decode_head.predict(x, batch_img_metas,
+                                              self.test_cfg)
+
+        return seg_logits
+
+    def _decode_head_forward_train(self, inputs: List[Tensor],
+                                   data_samples: SampleList) -> dict:
+        """Run forward function and calculate loss for decode head in
+        training."""
+        losses = dict()
+        loss_decode = self.decode_head.loss(inputs, data_samples,
+                                            self.train_cfg)
+
+        losses.update(add_prefix(loss_decode, 'decode'))
+        return losses
+
+    def _auxiliary_head_forward_train(self, inputs: List[Tensor],
+                                      data_samples: SampleList) -> dict:
+        """Run forward function and calculate loss for auxiliary head in
+        training."""
+        losses = dict()
+        if isinstance(self.auxiliary_head, nn.ModuleList):
+            for idx, aux_head in enumerate(self.auxiliary_head):
+                loss_aux = aux_head.loss(inputs, data_samples, self.train_cfg)
+                losses.update(add_prefix(loss_aux, f'aux_{idx}'))
+        else:
+            loss_aux = self.auxiliary_head.loss(inputs, data_samples,
+                                                self.train_cfg)
+            losses.update(add_prefix(loss_aux, 'aux'))
+
+        return losses
+
+    def loss(self, inputs: Tensor, data_samples: SampleList) -> dict:
+        """Calculate losses from a batch of inputs and data samples.
+
+        Args:
+            inputs (Tensor): Input images.
+            data_samples (list[:obj:`SegDataSample`]): The seg data samples.
+                It usually includes information such as `metainfo` and
+                `gt_sem_seg`.
+
+        Returns:
+            dict[str, Tensor]: a dictionary of loss components
+        """
+
+        x = self.extract_feat(inputs)
+
+        losses = dict()
+
+        loss_decode = self._decode_head_forward_train(x, data_samples)
+        losses.update(loss_decode)
+
+        if self.with_auxiliary_head:
+            loss_aux = self._auxiliary_head_forward_train(x, data_samples)
+            losses.update(loss_aux)
+
+        return losses
+
+    def predict(self,
+                inputs: Tensor,
+                data_samples: OptSampleList = None) -> SampleList:
+        """Predict results from a batch of inputs and data samples with post-
+        processing.
+
+        Args:
+            inputs (Tensor): Inputs with shape (N, C, H, W).
+            data_samples (List[:obj:`SegDataSample`], optional): The seg data
+                samples. It usually includes information such as `metainfo`
+                and `gt_sem_seg`.
+
+        Returns:
+            list[:obj:`SegDataSample`]: Segmentation results of the
+            input images. Each SegDataSample usually contain:
+
+            - ``pred_sem_seg``(PixelData): Prediction of semantic segmentation.
+            - ``seg_logits``(PixelData): Predicted logits of semantic
+                segmentation before normalization.
+        """
+        if data_samples is not None:
+            batch_img_metas = [
+                data_sample.metainfo for data_sample in data_samples
+            ]
+        else:
+            batch_img_metas = [
+                dict(
+                    ori_shape=inputs.shape[2:],
+                    img_shape=inputs.shape[2:],
+                    pad_shape=inputs.shape[2:],
+                    padding_size=[0, 0, 0, 0])
+            ] * inputs.shape[0]
+
+        seg_logits = self.inference(inputs, batch_img_metas)
+
+        return self.postprocess_result(seg_logits, data_samples)
+
+    def _forward(self,
+                 inputs: Tensor,
+                 data_samples: OptSampleList = None) -> Tensor:
+        """Network forward process.
+
+        Args:
+            inputs (Tensor): Inputs with shape (N, C, H, W).
+            data_samples (List[:obj:`SegDataSample`]): The seg
+                data samples. It usually includes information such
+                as `metainfo` and `gt_sem_seg`.
+
+        Returns:
+            Tensor: Forward output of model without any post-processes.
+        """
+        x = self.extract_feat(inputs)
+        return self.decode_head.forward(x)
+
+    def slide_inference(self, inputs: Tensor,
+                        batch_img_metas: List[dict]) -> Tensor:
+        """Inference by sliding-window with overlap.
+
+        If h_crop > h_img or w_crop > w_img, the small patch will be used to
+        decode without padding.
+
+        Args:
+            inputs (tensor): the tensor should have a shape NxCxHxW,
+                which contains all images in the batch.
+            batch_img_metas (List[dict]): List of image metainfo where each may
+                also contain: 'img_shape', 'scale_factor', 'flip', 'img_path',
+                'ori_shape', and 'pad_shape'.
+                For details on the values of these keys see
+                `mmseg/datasets/pipelines/formatting.py:PackSegInputs`.
+
+        Returns:
+            Tensor: The segmentation results, seg_logits from model of each
+                input image.
+        """
+
+        h_stride, w_stride = self.test_cfg.stride
+        h_crop, w_crop = self.test_cfg.crop_size
+        batch_size, _, h_img, w_img = inputs.size()
+        out_channels = self.out_channels
+        h_grids = max(h_img - h_crop + h_stride - 1, 0) // h_stride + 1
+        w_grids = max(w_img - w_crop + w_stride - 1, 0) // w_stride + 1
+        preds = inputs.new_zeros((batch_size, out_channels, h_img, w_img))
+        count_mat = inputs.new_zeros((batch_size, 1, h_img, w_img))
+        for h_idx in range(h_grids):
+            for w_idx in range(w_grids):
+                y1 = h_idx * h_stride
+                x1 = w_idx * w_stride
+                y2 = min(y1 + h_crop, h_img)
+                x2 = min(x1 + w_crop, w_img)
+                y1 = max(y2 - h_crop, 0)
+                x1 = max(x2 - w_crop, 0)
+                crop_img = inputs[:, :, y1:y2, x1:x2]
+                # change the image shape to patch shape
+                batch_img_metas[0]['img_shape'] = crop_img.shape[2:]
+                # the output of encode_decode is seg logits tensor map
+                # with shape [N, C, H, W]
+                crop_seg_logit = self.encode_decode(crop_img, batch_img_metas)
+                preds += F.pad(crop_seg_logit,
+                               (int(x1), int(preds.shape[3] - x2), int(y1),
+                                int(preds.shape[2] - y2)))
+
+                count_mat[:, :, y1:y2, x1:x2] += 1
+        assert (count_mat == 0).sum() == 0
+        seg_logits = preds / count_mat
+
+        return seg_logits
+
+    def whole_inference(self, inputs: Tensor,
+                        batch_img_metas: List[dict]) -> Tensor:
+        """Inference with full image.
+
+        Args:
+            inputs (Tensor): The tensor should have a shape NxCxHxW, which
+                contains all images in the batch.
+            batch_img_metas (List[dict]): List of image metainfo where each may
+                also contain: 'img_shape', 'scale_factor', 'flip', 'img_path',
+                'ori_shape', and 'pad_shape'.
+                For details on the values of these keys see
+                `mmseg/datasets/pipelines/formatting.py:PackSegInputs`.
+
+        Returns:
+            Tensor: The segmentation results, seg_logits from model of each
+                input image.
+        """
+
+        seg_logits = self.encode_decode(inputs, batch_img_metas)
+
+        return seg_logits
+
+    def inference(self, inputs: Tensor, batch_img_metas: List[dict]) -> Tensor:
+        """Inference with slide/whole style.
+
+        Args:
+            inputs (Tensor): The input image of shape (N, 3, H, W).
+            batch_img_metas (List[dict]): List of image metainfo where each may
+                also contain: 'img_shape', 'scale_factor', 'flip', 'img_path',
+                'ori_shape', 'pad_shape', and 'padding_size'.
+                For details on the values of these keys see
+                `mmseg/datasets/pipelines/formatting.py:PackSegInputs`.
+
+        Returns:
+            Tensor: The segmentation results, seg_logits from model of each
+                input image.
+        """
+        assert self.test_cfg.get('mode', 'whole') in ['slide', 'whole'], \
+            f'Only "slide" or "whole" test mode are supported, but got ' \
+            f'{self.test_cfg["mode"]}.'
+        ori_shape = batch_img_metas[0]['ori_shape']
+        if not all(_['ori_shape'] == ori_shape for _ in batch_img_metas):
+            print_log(
+                'Image shapes are different in the batch.',
+                logger='current',
+                level=logging.WARN)
+        if self.test_cfg.mode == 'slide':
+            seg_logit = self.slide_inference(inputs, batch_img_metas)
+        else:
+            seg_logit = self.whole_inference(inputs, batch_img_metas)
+
+        return seg_logit
+
+    def aug_test(self, inputs, batch_img_metas, rescale=True):
+        """Test with augmentations.
+
+        Only rescale=True is supported.
+        """
+        # aug_test rescale all imgs back to ori_shape for now
+        assert rescale
+        # to save memory, we get augmented seg logit inplace
+        seg_logit = self.inference(inputs[0], batch_img_metas[0], rescale)
+        for i in range(1, len(inputs)):
+            cur_seg_logit = self.inference(inputs[i], batch_img_metas[i],
+                                           rescale)
+            seg_logit += cur_seg_logit
+        seg_logit /= len(inputs)
+        seg_pred = seg_logit.argmax(dim=1)
+        # unravel batch dim
+        seg_pred = list(seg_pred)
+        return seg_pred
diff --git a/mmsegmentation/mmseg/models/segmentors/multimodal_encoder_decoder.py b/mmsegmentation/mmseg/models/segmentors/multimodal_encoder_decoder.py
new file mode 100644
index 0000000..75aa8b9
--- /dev/null
+++ b/mmsegmentation/mmseg/models/segmentors/multimodal_encoder_decoder.py
@@ -0,0 +1,350 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional
+
+import torch.nn.functional as F
+from torch import Tensor
+
+from mmseg.registry import MODELS
+from mmseg.utils import (ConfigType, OptConfigType, OptMultiConfig,
+                         OptSampleList, SampleList, add_prefix)
+from .base import BaseSegmentor
+
+
+@MODELS.register_module()
+class MultimodalEncoderDecoder(BaseSegmentor):
+    """Multimodal Encoder-Decoder segmentors.
+
+    Multimodal segmentation architecture is used for open-vocabulary
+    semantic segmentation with combining the visual and language
+    pretrain models. It consists of a image_encoder (backbone) to extract
+    visual feature, a text encoder to extract text feature, and a decode
+    head to generate semantic maps.
+    Note that the deep supervision during training is implemented in decode head.
+
+    1. The ``loss`` method is used to calculate the loss of model,
+    which includes two steps: (1) Extracts features to obtain the feature maps
+    (2) Call the decode head loss function to forward decode head model and
+    calculate losses.
+
+    .. code:: text
+
+     loss(): extract_feat() -> _decode_head_forward_train()
+     _decode_head_forward_train(): decode_head.loss()
+
+    2. The ``predict`` method is used to predict segmentation results,
+    which includes two steps: (1) Run inference function to obtain the list of
+    seg_logits (2) Call post-processing function to obtain list of
+    ``SegDataSampel`` including ``pred_sem_seg`` and ``seg_logits``.
+
+    .. code:: text
+
+     predict(): inference() -> postprocess_result()
+     inference(): whole_inference()/slide_inference()
+     whole_inference()/slide_inference(): encoder_decoder()
+     encoder_decoder(): extract_feat() -> decode_head.predict()
+
+    3. The ``_forward`` method is used to output the tensor by running the model,
+    which includes two steps: (1) Extracts features to obtain the feature maps
+    (2)Call the decode head forward function to forward decode head model.
+
+    .. code:: text
+
+     _forward(): extract_feat() -> _decode_head.forward()
+
+    Args:
+
+        image_encoder (ConfigType): The config for the visual encoder of segmentor.
+        text_encoder ((ConfigType): The config for the text encoder of segmentor.
+        decode_head (ConfigType): The config for the decode head of segmentor.
+        train_cfg (OptConfigType): The config for training. Defaults to None.
+        test_cfg (OptConfigType): The config for testing. Defaults to None.
+        data_preprocessor (dict, optional): The pre-process config of
+            :class:`BaseDataPreprocessor`.
+        pretrained (str, optional): The path for pretrained model.
+            Defaults to None.
+        asymetric_input (bool): whether to use different size of input for image encoder
+            and decode head. Defaults to False.
+        encoder_resolution (float): resize scale of input images for image encoder.
+            Defaults to None.
+        init_cfg (dict, optional): The weight initialized config for
+            :class:`BaseModule`.
+    """  # noqa: E501
+
+    def __init__(self,
+                 image_encoder: ConfigType,
+                 text_encoder: ConfigType,
+                 decode_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 pretrained: Optional[str] = None,
+                 asymetric_input: bool = True,
+                 encoder_resolution: float = None,
+                 init_cfg: OptMultiConfig = None):
+        super().__init__(
+            data_preprocessor=data_preprocessor, init_cfg=init_cfg)
+        if pretrained is not None:
+            image_encoder.init_cfg = dict(
+                type='Pretrained_Part', checkpoint=pretrained)
+            text_encoder.init_cfg = dict(
+                type='Pretrained_Part', checkpoint=pretrained)
+            decode_head.init_cfg = dict(
+                type='Pretrained_Part', checkpoint=pretrained)
+
+        if asymetric_input:
+            assert encoder_resolution is not None, \
+                'if asymetric_input set True, ' \
+                'clip_resolution must be a certain value'
+        self.asymetric_input = asymetric_input
+        self.encoder_resolution = encoder_resolution
+        self.image_encoder = MODELS.build(image_encoder)
+        self.text_encoder = MODELS.build(text_encoder)
+        self._init_decode_head(decode_head)
+
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+
+        assert self.with_decode_head
+
+    def _init_decode_head(self, decode_head: ConfigType) -> None:
+        """Initialize ``decode_head``"""
+        self.decode_head = MODELS.build(decode_head)
+        self.align_corners = self.decode_head.align_corners
+        self.num_classes = self.decode_head.num_classes
+        self.out_channels = self.decode_head.out_channels
+
+    def extract_feat(self, inputs: Tensor) -> List[Tensor]:
+        """Extract visual features from images."""
+        x = self.image_encoder(inputs)
+        return x
+
+    def encode_decode(self, inputs: Tensor,
+                      batch_img_metas: List[dict]) -> Tensor:
+        """Encode the name of classes with text_encoder and encode images with
+        image_encoder.
+
+        Then decode the class embedding and visual feature into a semantic
+        segmentation map of the same size as input.
+        """
+        classifier_embeds = self.text_encoder()
+        clip_inputs = inputs
+        if self.asymetric_input:
+            clip_inputs = F.interpolate(
+                inputs, scale_factor=self.encoder_resolution, mode='bilinear')
+        x = self.image_encoder(clip_inputs)
+        seg_logits = self.decode_head.predict([inputs, x, classifier_embeds],
+                                              batch_img_metas, self.test_cfg)
+
+        return seg_logits
+
+    def _decode_head_forward_train(self, inputs: List[Tensor],
+                                   data_samples: SampleList) -> dict:
+        """Run forward function and calculate loss for decode head in
+        training."""
+        losses = dict()
+        loss_decode = self.decode_head.loss(inputs, data_samples,
+                                            self.train_cfg)
+
+        losses.update(add_prefix(loss_decode, 'decode'))
+        return losses
+
+    def loss(self, inputs: Tensor, data_samples: SampleList) -> dict:
+        """Calculate losses from a batch of inputs and data samples.
+
+        Args:
+            inputs (Tensor): Input images.
+            data_samples (list[:obj:`SegDataSample`]): The seg data samples.
+                It usually includes information such as `metainfo` and
+                `gt_sem_seg`.
+
+        Returns:
+            dict[str, Tensor]: a dictionary of loss components
+        """
+        classifier_embeds = self.text_encoder()
+        clip_inputs = inputs
+        if self.asymetric_input:
+            clip_inputs = F.interpolate(
+                inputs, scale_factor=self.encoder_resolution, mode='bilinear')
+        x = self.image_encoder(clip_inputs)
+
+        losses = dict()
+
+        loss_decode = self._decode_head_forward_train(
+            [inputs, x, classifier_embeds], data_samples)
+        losses.update(loss_decode)
+
+        return losses
+
+    def predict(self,
+                inputs: Tensor,
+                data_samples: OptSampleList = None) -> SampleList:
+        """Predict results from a batch of inputs and data samples with post-
+        processing.
+
+        Args:
+            inputs (Tensor): Inputs with shape (N, C, H, W).
+            data_samples (List[:obj:`SegDataSample`], optional): The seg data
+                samples. It usually includes information such as `metainfo`
+                and `gt_sem_seg`.
+
+        Returns:
+            list[:obj:`SegDataSample`]: Segmentation results of the
+            input images. Each SegDataSample usually contain:
+
+            - ``pred_sem_seg``(PixelData): Prediction of semantic segmentation.
+            - ``seg_logits``(PixelData): Predicted logits of semantic
+                segmentation before normalization.
+        """
+        if data_samples is not None:
+            batch_img_metas = [
+                data_sample.metainfo for data_sample in data_samples
+            ]
+        else:
+            batch_img_metas = [
+                dict(
+                    ori_shape=inputs.shape[2:],
+                    img_shape=inputs.shape[2:],
+                    pad_shape=inputs.shape[2:],
+                    padding_size=[0, 0, 0, 0])
+            ] * inputs.shape[0]
+
+        seg_logits = self.inference(inputs, batch_img_metas)
+
+        return self.postprocess_result(seg_logits, data_samples)
+
+    def _forward(self,
+                 inputs: Tensor,
+                 data_samples: OptSampleList = None) -> Tensor:
+        """Network forward process.
+
+        Args:
+            inputs (Tensor): Inputs with shape (N, C, H, W).
+            data_samples (List[:obj:`SegDataSample`]): The seg
+                data samples. It usually includes information such
+                as `metainfo` and `gt_sem_seg`.
+
+        Returns:
+            Tensor: Forward output of model without any post-processes.
+        """
+        x = self.extract_feat(inputs)
+        return self.decode_head.forward(x)
+
+    def slide_inference(self, inputs: Tensor,
+                        batch_img_metas: List[dict]) -> Tensor:
+        """Inference by sliding-window with overlap.
+
+        If h_crop > h_img or w_crop > w_img, the small patch will be used to
+        decode without padding.
+
+        Args:
+            inputs (tensor): the tensor should have a shape NxCxHxW,
+                which contains all images in the batch.
+            batch_img_metas (List[dict]): List of image metainfo where each may
+                also contain: 'img_shape', 'scale_factor', 'flip', 'img_path',
+                'ori_shape', and 'pad_shape'.
+                For details on the values of these keys see
+                `mmseg/datasets/pipelines/formatting.py:PackSegInputs`.
+
+        Returns:
+            Tensor: The segmentation results, seg_logits from model of each
+                input image.
+        """
+
+        h_stride, w_stride = self.test_cfg.stride
+        h_crop, w_crop = self.test_cfg.crop_size
+        batch_size, _, h_img, w_img = inputs.size()
+        out_channels = self.out_channels
+        h_grids = max(h_img - h_crop + h_stride - 1, 0) // h_stride + 1
+        w_grids = max(w_img - w_crop + w_stride - 1, 0) // w_stride + 1
+        preds = inputs.new_zeros((batch_size, out_channels, h_img, w_img))
+        count_mat = inputs.new_zeros((batch_size, 1, h_img, w_img))
+        for h_idx in range(h_grids):
+            for w_idx in range(w_grids):
+                y1 = h_idx * h_stride
+                x1 = w_idx * w_stride
+                y2 = min(y1 + h_crop, h_img)
+                x2 = min(x1 + w_crop, w_img)
+                y1 = max(y2 - h_crop, 0)
+                x1 = max(x2 - w_crop, 0)
+                crop_img = inputs[:, :, y1:y2, x1:x2]
+                # change the image shape to patch shape
+                batch_img_metas[0]['img_shape'] = crop_img.shape[2:]
+                # the output of encode_decode is seg logits tensor map
+                # with shape [N, C, H, W]
+                crop_seg_logit = self.encode_decode(crop_img, batch_img_metas)
+                preds += F.pad(crop_seg_logit,
+                               (int(x1), int(preds.shape[3] - x2), int(y1),
+                                int(preds.shape[2] - y2)))
+
+                count_mat[:, :, y1:y2, x1:x2] += 1
+        assert (count_mat == 0).sum() == 0
+        seg_logits = preds / count_mat
+
+        return seg_logits
+
+    def whole_inference(self, inputs: Tensor,
+                        batch_img_metas: List[dict]) -> Tensor:
+        """Inference with full image.
+
+        Args:
+            inputs (Tensor): The tensor should have a shape NxCxHxW, which
+                contains all images in the batch.
+            batch_img_metas (List[dict]): List of image metainfo where each may
+                also contain: 'img_shape', 'scale_factor', 'flip', 'img_path',
+                'ori_shape', and 'pad_shape'.
+                For details on the values of these keys see
+                `mmseg/datasets/pipelines/formatting.py:PackSegInputs`.
+
+        Returns:
+            Tensor: The segmentation results, seg_logits from model of each
+                input image.
+        """
+
+        seg_logits = self.encode_decode(inputs, batch_img_metas)
+
+        return seg_logits
+
+    def inference(self, inputs: Tensor, batch_img_metas: List[dict]) -> Tensor:
+        """Inference with slide/whole style.
+
+        Args:
+            inputs (Tensor): The input image of shape (N, 3, H, W).
+            batch_img_metas (List[dict]): List of image metainfo where each may
+                also contain: 'img_shape', 'scale_factor', 'flip', 'img_path',
+                'ori_shape', 'pad_shape', and 'padding_size'.
+                For details on the values of these keys see
+                `mmseg/datasets/pipelines/formatting.py:PackSegInputs`.
+
+        Returns:
+            Tensor: The segmentation results, seg_logits from model of each
+                input image.
+        """
+
+        assert self.test_cfg.mode in ['slide', 'whole']
+        ori_shape = batch_img_metas[0]['ori_shape']
+        assert all(_['ori_shape'] == ori_shape for _ in batch_img_metas)
+        if self.test_cfg.mode == 'slide':
+            seg_logit = self.slide_inference(inputs, batch_img_metas)
+        else:
+            seg_logit = self.whole_inference(inputs, batch_img_metas)
+
+        return seg_logit
+
+    def aug_test(self, inputs, batch_img_metas, rescale=True):
+        """Test with augmentations.
+
+        Only rescale=True is supported.
+        """
+        # aug_test rescale all imgs back to ori_shape for now
+        assert rescale
+        # to save memory, we get augmented seg logit inplace
+        seg_logit = self.inference(inputs[0], batch_img_metas[0], rescale)
+        for i in range(1, len(inputs)):
+            cur_seg_logit = self.inference(inputs[i], batch_img_metas[i],
+                                           rescale)
+            seg_logit += cur_seg_logit
+        seg_logit /= len(inputs)
+        seg_pred = seg_logit.argmax(dim=1)
+        # unravel batch dim
+        seg_pred = list(seg_pred)
+        return seg_pred
diff --git a/mmsegmentation/mmseg/models/segmentors/seg_tta.py b/mmsegmentation/mmseg/models/segmentors/seg_tta.py
new file mode 100644
index 0000000..63ef61d
--- /dev/null
+++ b/mmsegmentation/mmseg/models/segmentors/seg_tta.py
@@ -0,0 +1,47 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List
+
+import torch
+from mmengine.model import BaseTTAModel
+from mmengine.structures import PixelData
+
+from mmseg.registry import MODELS
+from mmseg.utils import SampleList
+
+
+@MODELS.register_module()
+class SegTTAModel(BaseTTAModel):
+
+    def merge_preds(self, data_samples_list: List[SampleList]) -> SampleList:
+        """Merge predictions of enhanced data to one prediction.
+
+        Args:
+            data_samples_list (List[SampleList]): List of predictions
+                of all enhanced data.
+
+        Returns:
+            SampleList: Merged prediction.
+        """
+        predictions = []
+        for data_samples in data_samples_list:
+            seg_logits = data_samples[0].seg_logits.data
+            logits = torch.zeros(seg_logits.shape).to(seg_logits)
+            for data_sample in data_samples:
+                seg_logit = data_sample.seg_logits.data
+                if self.module.out_channels > 1:
+                    logits += seg_logit.softmax(dim=0)
+                else:
+                    logits += seg_logit.sigmoid()
+            logits /= len(data_samples)
+            if self.module.out_channels == 1:
+                seg_pred = (logits > self.module.decode_head.threshold
+                            ).to(logits).squeeze(1)
+            else:
+                seg_pred = logits.argmax(dim=0)
+            data_sample.set_data({'pred_sem_seg': PixelData(data=seg_pred)})
+            if hasattr(data_samples[0], 'gt_sem_seg'):
+                data_sample.set_data(
+                    {'gt_sem_seg': data_samples[0].gt_sem_seg})
+            data_sample.set_metainfo({'img_path': data_samples[0].img_path})
+            predictions.append(data_sample)
+        return predictions
diff --git a/mmsegmentation/mmseg/models/text_encoder/__init__.py b/mmsegmentation/mmseg/models/text_encoder/__init__.py
new file mode 100644
index 0000000..199856d
--- /dev/null
+++ b/mmsegmentation/mmseg/models/text_encoder/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .clip_text_encoder import CLIPTextEncoder
+
+__all__ = ['CLIPTextEncoder']
diff --git a/mmsegmentation/mmseg/models/text_encoder/clip_text_encoder.py b/mmsegmentation/mmseg/models/text_encoder/clip_text_encoder.py
new file mode 100644
index 0000000..1a18b86
--- /dev/null
+++ b/mmsegmentation/mmseg/models/text_encoder/clip_text_encoder.py
@@ -0,0 +1,229 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List
+
+import numpy as np
+import torch
+import torch.nn as nn
+from mmcv.cnn import build_norm_layer
+from mmcv.cnn.bricks.transformer import BaseTransformerLayer
+from mmengine.model import BaseModule, ModuleList
+from mmengine.runner.checkpoint import CheckpointLoader, load_state_dict
+from torch.nn import functional as F
+
+from mmseg.registry import MODELS
+from mmseg.utils import get_classes, get_predefined_templates, tokenizer
+
+
+@MODELS.register_module()
+class CLIPTextEncoder(BaseModule):
+    """A text encoder with transformer architecture to encode the label text.
+
+    Modified from https://github.com/MendelXu/SAN/blob/main/san/model/clip_utils/classifier.py # noqa:E501
+    Copyright (c) 2023 MendelXu.
+    Licensed under the MIT License
+
+    Args:
+        dataset_name: (str|None): The name of the dataset to which
+            the data belongs.
+        vocabulary: (List[str]|None): The list of class names. Default: None.
+        templates: (List[str]|None): The prompt template used for labels.
+            Default: None.
+        total_vocab_size: (int): Number of all words used by the pre-trained
+            model. Default: 49408 (CLIP).
+        context_length: (int): The max length of prompt text.
+            Default: 77 (CLIP).
+        embed_dims: (int): Width of transformer model. Default: 512.
+        num_layers: (int): Depth of transformer. Default: 12,
+        num_heads: (int): Number of attention heads in transformer.
+            Default: 8,
+        mlp_ratio: (int) Ratio of mlp hidden dim to embedding dim in
+            transformer. Default: 4,
+        output_dims: (int) Dim of output text embeddings. Default: 512,
+        cache_feature: (bool) Whether to save class embeddings in cache.
+            Default: True,
+        cat_bg: (bool) Whether to add background embedding. Default: True.
+        norm_cfg (dict|None): Config for norm layer. Default: dict(type='LN')
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    """
+
+    def __init__(self,
+                 dataset_name: str = None,
+                 vocabulary: List[str] = None,
+                 templates: str = 'vild',
+                 total_vocab_size: int = 49408,
+                 context_length: int = 77,
+                 embed_dims: int = 512,
+                 num_layers: int = 12,
+                 num_heads: int = 8,
+                 mlp_ratio: int = 4,
+                 output_dims: int = 512,
+                 cache_feature: bool = True,
+                 cat_bg: bool = True,
+                 norm_cfg: dict = dict(type='LN'),
+                 init_cfg: dict = None):
+        super().__init__(init_cfg)
+        if isinstance(templates, List):
+            self.templates = templates
+        else:
+            self.templates = get_predefined_templates(templates)
+
+        assert dataset_name is not None or vocabulary is not None, \
+            "text_encoder required either 'dataset_name' or 'vocabulary'"
+        assert dataset_name is None or vocabulary is None, \
+            "there is conflict between 'dataset_name' and 'vocabulary'"
+        self.dataset_name = dataset_name
+        self.vocabulary = vocabulary
+        self.num_pos = context_length
+        self.token_embedding = nn.Embedding(total_vocab_size, embed_dims)
+        self.positional_embedding = nn.Parameter(
+            torch.empty(context_length, embed_dims))
+        self.text_projection = nn.Parameter(
+            torch.empty(embed_dims, output_dims))
+        self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07))
+        self.transformer = ModuleList()
+        self.register_buffer(
+            'attn_mask', self.build_attention_mask(), persistent=False)
+        for i in range(num_layers):
+            self.transformer.append(
+                BaseTransformerLayer(
+                    attn_cfgs=dict(
+                        type='MultiheadAttention',
+                        embed_dims=embed_dims,
+                        num_heads=num_heads,
+                        batch_first=False,
+                        bias=True),
+                    ffn_cfgs=dict(
+                        type='FFN',
+                        embed_dims=embed_dims,
+                        feedforward_channels=mlp_ratio * embed_dims,
+                        act_cfg=dict(type='QuickGELU')),
+                    operation_order=('norm', 'self_attn', 'norm', 'ffn')))
+        self.ln_final = build_norm_layer(
+            norm_cfg, embed_dims, postfix='_final')[1]
+
+        self.cache_feature = cache_feature
+        if self.cache_feature:
+            self.cache = {}
+
+        self._freeze()
+
+        self.cat_bg = cat_bg
+        if self.cat_bg:
+            self.bg_embed = nn.Parameter(
+                torch.randn(1, self.text_projection.shape[1]))
+
+    @property
+    def ln_final(self):
+        return getattr(self, self.final_name)
+
+    def build_attention_mask(self):
+        """lazily create causal attention mask, with full attention between the
+        tokens.
+
+        pytorch uses additive attention mask; fill with -inf
+        """
+        mask = torch.empty(self.num_pos, self.num_pos)
+        mask.fill_(float('-inf'))
+        mask.triu_(1)  # zero out the lower diagonal
+        return mask
+
+    def _freeze(self):
+        for param in self.parameters():
+            param.requires_grad = False
+
+    def init_weights(self):
+        if self.cat_bg:
+            nn.init.normal_(
+                self.bg_embed,
+                std=self.bg_embed.shape[1]**-0.5,
+            )
+        if isinstance(self.init_cfg, dict) and \
+                self.init_cfg.get('type') == 'Pretrained_Part':
+            checkpoint = CheckpointLoader.load_checkpoint(
+                self.init_cfg['checkpoint'], logger=None, map_location='cpu')
+
+            state_dict = checkpoint.copy()
+            para_prefix = 'text_encoder'
+            prefix_len = len(para_prefix) + 1
+            for k, v in checkpoint.items():
+                state_dict.pop(k)
+                if para_prefix in k:
+                    state_dict[k[prefix_len:]] = v
+
+            load_state_dict(self, state_dict, strict=False, logger=None)
+
+        else:
+            super().init_weights()
+
+    @torch.no_grad()
+    def encode_text(self, text, normalize=False):
+        """encode class token."""
+
+        embed_device = self.token_embedding.weight.device
+        x = self.token_embedding(
+            text.to(embed_device))  # [batch_size, n_ctx, d_model]
+        x = x + self.positional_embedding
+        x = x.permute(1, 0, 2)  # NLD -> LND
+        for block in self.transformer:
+            x = block(query=x, attn_masks=self.attn_mask)
+        x = x.permute(1, 0, 2)  # LND -> NLD
+        x = self.ln_final(x)  # [batch_size, n_ctx, transformer.width]
+        # take features from the eot embedding
+        # (eot_token is the highest number in each sequence)
+        x = x[torch.arange(x.shape[0]),
+              text.argmax(dim=-1)] @ self.text_projection
+        return F.normalize(x, dim=-1) if normalize else x
+
+    def template_encode(self, vocabulary):
+        """Prompt engineering."""
+        text_embed_bucket = []
+        for template in self.templates:
+            text_inputs = tokenizer.tokenize(
+                [template.format(noun) for noun in vocabulary])
+            text_embed = self.encode_text(text_inputs, normalize=True)
+            text_embed_bucket.append(text_embed)
+        text_embed = torch.stack(text_embed_bucket).mean(dim=0)
+        text_embed = text_embed / text_embed.norm(dim=-1, keepdim=True)
+        return text_embed
+
+    def forward(self):
+        """Forward function."""
+        if self.dataset_name is None:  # encoding vocabulary directly
+            class_names = self.vocabulary
+            if self.cache_feature:
+                new_classes = [
+                    word for word in class_names if word not in self.cache
+                ]
+                if len(new_classes) > 0:
+                    class_embeds = self.template_encode(new_classes)
+                    self.cache.update(dict(zip(new_classes, class_embeds)))
+                class_embeds = torch.stack(
+                    [self.cache[word] for word in class_names])
+            else:
+                class_embeds = self.template_encode(class_names)
+
+        else:  # encoding the classes of the dataset
+            class_names = get_classes(self.dataset_name)
+            if class_names[0] == 'background':
+                class_names = class_names[1:]
+            if self.cache_feature:
+                if self.dataset_name not in self.cache:
+                    class_embeds = self.template_encode(class_names)
+                    self.cache[self.dataset_name] = class_embeds
+                else:
+                    class_embeds = self.cache[self.dataset_name]
+            else:
+                class_embeds = self.template_encode(class_names)
+
+        if self.cat_bg:
+            class_embeds = torch.cat([class_embeds, self.bg_embed])
+            class_embeds = F.normalize(class_embeds, p=2, dim=-1)
+        return self.logit_scale.exp() * class_embeds
+
+
+@MODELS.register_module()
+class QuickGELU(nn.Module):
+    # From https://github.com/openai/CLIP/blob/main/clip/model.py
+    def forward(self, x: torch.Tensor):
+        return x * torch.sigmoid(1.702 * x)
diff --git a/mmsegmentation/mmseg/models/utils/__init__.py b/mmsegmentation/mmseg/models/utils/__init__.py
new file mode 100644
index 0000000..c0751b1
--- /dev/null
+++ b/mmsegmentation/mmseg/models/utils/__init__.py
@@ -0,0 +1,27 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .basic_block import BasicBlock, Bottleneck
+from .embed import PatchEmbed
+from .encoding import Encoding
+from .inverted_residual import InvertedResidual, InvertedResidualV3
+from .make_divisible import make_divisible
+from .point_sample import get_uncertain_point_coords_with_randomness
+from .ppm import DAPPM, PAPPM
+from .res_layer import ResLayer
+from .se_layer import SELayer
+from .self_attention_block import SelfAttentionBlock
+from .shape_convert import (nchw2nlc2nchw, nchw_to_nlc, nlc2nchw2nlc,
+                            nlc_to_nchw)
+from .up_conv_block import UpConvBlock
+
+# isort: off
+from .wrappers import Upsample, resize
+from .san_layers import MLP, LayerNorm2d, cross_attn_layer
+
+__all__ = [
+    'ResLayer', 'SelfAttentionBlock', 'make_divisible', 'InvertedResidual',
+    'UpConvBlock', 'InvertedResidualV3', 'SELayer', 'PatchEmbed',
+    'nchw_to_nlc', 'nlc_to_nchw', 'nchw2nlc2nchw', 'nlc2nchw2nlc', 'Encoding',
+    'Upsample', 'resize', 'DAPPM', 'PAPPM', 'BasicBlock', 'Bottleneck',
+    'cross_attn_layer', 'LayerNorm2d', 'MLP',
+    'get_uncertain_point_coords_with_randomness'
+]
diff --git a/mmsegmentation/mmseg/models/utils/basic_block.py b/mmsegmentation/mmseg/models/utils/basic_block.py
new file mode 100644
index 0000000..4e1ad81
--- /dev/null
+++ b/mmsegmentation/mmseg/models/utils/basic_block.py
@@ -0,0 +1,143 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional
+
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule
+from torch import Tensor
+
+from mmseg.registry import MODELS
+from mmseg.utils import OptConfigType
+
+
+class BasicBlock(BaseModule):
+    """Basic block from `ResNet <https://arxiv.org/abs/1512.03385>`_.
+
+    Args:
+        in_channels (int): Input channels.
+        channels (int): Output channels.
+        stride (int): Stride of the first block. Default: 1.
+        downsample (nn.Module, optional): Downsample operation on identity.
+            Default: None.
+        norm_cfg (dict, optional): Config dict for normalization layer.
+            Default: dict(type='BN').
+        act_cfg (dict, optional): Config dict for activation layer in
+            ConvModule. Default: dict(type='ReLU', inplace=True).
+        act_cfg_out (dict, optional): Config dict for activation layer at the
+            last of the block. Default: None.
+        init_cfg (dict, optional): Initialization config dict. Default: None.
+    """
+
+    expansion = 1
+
+    def __init__(self,
+                 in_channels: int,
+                 channels: int,
+                 stride: int = 1,
+                 downsample: nn.Module = None,
+                 norm_cfg: OptConfigType = dict(type='BN'),
+                 act_cfg: OptConfigType = dict(type='ReLU', inplace=True),
+                 act_cfg_out: OptConfigType = dict(type='ReLU', inplace=True),
+                 init_cfg: OptConfigType = None):
+        super().__init__(init_cfg)
+        self.conv1 = ConvModule(
+            in_channels,
+            channels,
+            kernel_size=3,
+            stride=stride,
+            padding=1,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        self.conv2 = ConvModule(
+            channels,
+            channels,
+            kernel_size=3,
+            padding=1,
+            norm_cfg=norm_cfg,
+            act_cfg=None)
+        self.downsample = downsample
+        if act_cfg_out:
+            self.act = MODELS.build(act_cfg_out)
+
+    def forward(self, x: Tensor) -> Tensor:
+        residual = x
+        out = self.conv1(x)
+        out = self.conv2(out)
+
+        if self.downsample:
+            residual = self.downsample(x)
+
+        out += residual
+
+        if hasattr(self, 'act'):
+            out = self.act(out)
+
+        return out
+
+
+class Bottleneck(BaseModule):
+    """Bottleneck block from `ResNet <https://arxiv.org/abs/1512.03385>`_.
+
+    Args:
+        in_channels (int): Input channels.
+        channels (int): Output channels.
+        stride (int): Stride of the first block. Default: 1.
+        downsample (nn.Module, optional): Downsample operation on identity.
+            Default: None.
+        norm_cfg (dict, optional): Config dict for normalization layer.
+            Default: dict(type='BN').
+        act_cfg (dict, optional): Config dict for activation layer in
+            ConvModule. Default: dict(type='ReLU', inplace=True).
+        act_cfg_out (dict, optional): Config dict for activation layer at
+            the last of the block. Default: None.
+        init_cfg (dict, optional): Initialization config dict. Default: None.
+    """
+
+    expansion = 2
+
+    def __init__(self,
+                 in_channels: int,
+                 channels: int,
+                 stride: int = 1,
+                 downsample: Optional[nn.Module] = None,
+                 norm_cfg: OptConfigType = dict(type='BN'),
+                 act_cfg: OptConfigType = dict(type='ReLU', inplace=True),
+                 act_cfg_out: OptConfigType = None,
+                 init_cfg: OptConfigType = None):
+        super().__init__(init_cfg)
+        self.conv1 = ConvModule(
+            in_channels, channels, 1, norm_cfg=norm_cfg, act_cfg=act_cfg)
+        self.conv2 = ConvModule(
+            channels,
+            channels,
+            3,
+            stride,
+            1,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        self.conv3 = ConvModule(
+            channels,
+            channels * self.expansion,
+            1,
+            norm_cfg=norm_cfg,
+            act_cfg=None)
+        if act_cfg_out:
+            self.act = MODELS.build(act_cfg_out)
+        self.downsample = downsample
+
+    def forward(self, x: Tensor) -> Tensor:
+        residual = x
+
+        out = self.conv1(x)
+        out = self.conv2(out)
+        out = self.conv3(out)
+
+        if self.downsample:
+            residual = self.downsample(x)
+
+        out += residual
+
+        if hasattr(self, 'act'):
+            out = self.act(out)
+
+        return out
diff --git a/mmsegmentation/mmseg/models/utils/embed.py b/mmsegmentation/mmseg/models/utils/embed.py
new file mode 100644
index 0000000..aef0a40
--- /dev/null
+++ b/mmsegmentation/mmseg/models/utils/embed.py
@@ -0,0 +1,330 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+from typing import Sequence
+
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import build_conv_layer, build_norm_layer
+from mmengine.model import BaseModule
+from mmengine.utils import to_2tuple
+
+
+class AdaptivePadding(nn.Module):
+    """Applies padding to input (if needed) so that input can get fully covered
+    by filter you specified. It support two modes "same" and "corner". The
+    "same" mode is same with "SAME" padding mode in TensorFlow, pad zero around
+    input. The "corner"  mode would pad zero to bottom right.
+
+    Args:
+        kernel_size (int | tuple): Size of the kernel:
+        stride (int | tuple): Stride of the filter. Default: 1:
+        dilation (int | tuple): Spacing between kernel elements.
+            Default: 1.
+        padding (str): Support "same" and "corner", "corner" mode
+            would pad zero to bottom right, and "same" mode would
+            pad zero around input. Default: "corner".
+    Example:
+        >>> kernel_size = 16
+        >>> stride = 16
+        >>> dilation = 1
+        >>> input = torch.rand(1, 1, 15, 17)
+        >>> adap_pad = AdaptivePadding(
+        >>>     kernel_size=kernel_size,
+        >>>     stride=stride,
+        >>>     dilation=dilation,
+        >>>     padding="corner")
+        >>> out = adap_pad(input)
+        >>> assert (out.shape[2], out.shape[3]) == (16, 32)
+        >>> input = torch.rand(1, 1, 16, 17)
+        >>> out = adap_pad(input)
+        >>> assert (out.shape[2], out.shape[3]) == (16, 32)
+    """
+
+    def __init__(self, kernel_size=1, stride=1, dilation=1, padding='corner'):
+
+        super().__init__()
+
+        assert padding in ('same', 'corner')
+
+        kernel_size = to_2tuple(kernel_size)
+        stride = to_2tuple(stride)
+        dilation = to_2tuple(dilation)
+
+        self.padding = padding
+        self.kernel_size = kernel_size
+        self.stride = stride
+        self.dilation = dilation
+
+    def get_pad_shape(self, input_shape):
+        input_h, input_w = input_shape
+        kernel_h, kernel_w = self.kernel_size
+        stride_h, stride_w = self.stride
+        output_h = math.ceil(input_h / stride_h)
+        output_w = math.ceil(input_w / stride_w)
+        pad_h = max((output_h - 1) * stride_h +
+                    (kernel_h - 1) * self.dilation[0] + 1 - input_h, 0)
+        pad_w = max((output_w - 1) * stride_w +
+                    (kernel_w - 1) * self.dilation[1] + 1 - input_w, 0)
+        return pad_h, pad_w
+
+    def forward(self, x):
+        pad_h, pad_w = self.get_pad_shape(x.size()[-2:])
+        if pad_h > 0 or pad_w > 0:
+            if self.padding == 'corner':
+                x = F.pad(x, [0, pad_w, 0, pad_h])
+            elif self.padding == 'same':
+                x = F.pad(x, [
+                    pad_w // 2, pad_w - pad_w // 2, pad_h // 2,
+                    pad_h - pad_h // 2
+                ])
+        return x
+
+
+class PatchEmbed(BaseModule):
+    """Image to Patch Embedding.
+
+    We use a conv layer to implement PatchEmbed.
+
+    Args:
+        in_channels (int): The num of input channels. Default: 3
+        embed_dims (int): The dimensions of embedding. Default: 768
+        conv_type (str): The config dict for embedding
+            conv layer type selection. Default: "Conv2d".
+        kernel_size (int): The kernel_size of embedding conv. Default: 16.
+        stride (int, optional): The slide stride of embedding conv.
+            Default: None (Would be set as `kernel_size`).
+        padding (int | tuple | string ): The padding length of
+            embedding conv. When it is a string, it means the mode
+            of adaptive padding, support "same" and "corner" now.
+            Default: "corner".
+        dilation (int): The dilation rate of embedding conv. Default: 1.
+        bias (bool): Bias of embed conv. Default: True.
+        norm_cfg (dict, optional): Config dict for normalization layer.
+            Default: None.
+        input_size (int | tuple | None): The size of input, which will be
+            used to calculate the out size. Only work when `dynamic_size`
+            is False. Default: None.
+        init_cfg (`mmengine.ConfigDict`, optional): The Config for
+            initialization. Default: None.
+    """
+
+    def __init__(self,
+                 in_channels=3,
+                 embed_dims=768,
+                 conv_type='Conv2d',
+                 kernel_size=16,
+                 stride=None,
+                 padding='corner',
+                 dilation=1,
+                 bias=True,
+                 norm_cfg=None,
+                 input_size=None,
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+
+        self.embed_dims = embed_dims
+        if stride is None:
+            stride = kernel_size
+
+        kernel_size = to_2tuple(kernel_size)
+        stride = to_2tuple(stride)
+        dilation = to_2tuple(dilation)
+
+        if isinstance(padding, str):
+            self.adap_padding = AdaptivePadding(
+                kernel_size=kernel_size,
+                stride=stride,
+                dilation=dilation,
+                padding=padding)
+            # disable the padding of conv
+            padding = 0
+        else:
+            self.adap_padding = None
+        padding = to_2tuple(padding)
+
+        self.projection = build_conv_layer(
+            dict(type=conv_type),
+            in_channels=in_channels,
+            out_channels=embed_dims,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=padding,
+            dilation=dilation,
+            bias=bias)
+
+        if norm_cfg is not None:
+            self.norm = build_norm_layer(norm_cfg, embed_dims)[1]
+        else:
+            self.norm = None
+
+        if input_size:
+            input_size = to_2tuple(input_size)
+            # `init_out_size` would be used outside to
+            # calculate the num_patches
+            # when `use_abs_pos_embed` outside
+            self.init_input_size = input_size
+            if self.adap_padding:
+                pad_h, pad_w = self.adap_padding.get_pad_shape(input_size)
+                input_h, input_w = input_size
+                input_h = input_h + pad_h
+                input_w = input_w + pad_w
+                input_size = (input_h, input_w)
+
+            # https://pytorch.org/docs/stable/generated/torch.nn.Conv2d.html
+            h_out = (input_size[0] + 2 * padding[0] - dilation[0] *
+                     (kernel_size[0] - 1) - 1) // stride[0] + 1
+            w_out = (input_size[1] + 2 * padding[1] - dilation[1] *
+                     (kernel_size[1] - 1) - 1) // stride[1] + 1
+            self.init_out_size = (h_out, w_out)
+        else:
+            self.init_input_size = None
+            self.init_out_size = None
+
+    def forward(self, x):
+        """
+        Args:
+            x (Tensor): Has shape (B, C, H, W). In most case, C is 3.
+
+        Returns:
+            tuple: Contains merged results and its spatial shape.
+
+                - x (Tensor): Has shape (B, out_h * out_w, embed_dims)
+                - out_size (tuple[int]): Spatial shape of x, arrange as
+                    (out_h, out_w).
+        """
+
+        if self.adap_padding:
+            x = self.adap_padding(x)
+
+        x = self.projection(x)
+        out_size = (x.shape[2], x.shape[3])
+        x = x.flatten(2).transpose(1, 2)
+        if self.norm is not None:
+            x = self.norm(x)
+        return x, out_size
+
+
+class PatchMerging(BaseModule):
+    """Merge patch feature map.
+
+    This layer groups feature map by kernel_size, and applies norm and linear
+    layers to the grouped feature map. Our implementation uses `nn.Unfold` to
+    merge patch, which is about 25% faster than original implementation.
+    Instead, we need to modify pretrained models for compatibility.
+
+    Args:
+        in_channels (int): The num of input channels.
+        out_channels (int): The num of output channels.
+        kernel_size (int | tuple, optional): the kernel size in the unfold
+            layer. Defaults to 2.
+        stride (int | tuple, optional): the stride of the sliding blocks in the
+            unfold layer. Default: None. (Would be set as `kernel_size`)
+        padding (int | tuple | string ): The padding length of
+            embedding conv. When it is a string, it means the mode
+            of adaptive padding, support "same" and "corner" now.
+            Default: "corner".
+        dilation (int | tuple, optional): dilation parameter in the unfold
+            layer. Default: 1.
+        bias (bool, optional): Whether to add bias in linear layer or not.
+            Defaults: False.
+        norm_cfg (dict, optional): Config dict for normalization layer.
+            Default: dict(type='LN').
+        init_cfg (dict, optional): The extra config for initialization.
+            Default: None.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 kernel_size=2,
+                 stride=None,
+                 padding='corner',
+                 dilation=1,
+                 bias=False,
+                 norm_cfg=dict(type='LN'),
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        if stride:
+            stride = stride
+        else:
+            stride = kernel_size
+
+        kernel_size = to_2tuple(kernel_size)
+        stride = to_2tuple(stride)
+        dilation = to_2tuple(dilation)
+
+        if isinstance(padding, str):
+            self.adap_padding = AdaptivePadding(
+                kernel_size=kernel_size,
+                stride=stride,
+                dilation=dilation,
+                padding=padding)
+            # disable the padding of unfold
+            padding = 0
+        else:
+            self.adap_padding = None
+
+        padding = to_2tuple(padding)
+        self.sampler = nn.Unfold(
+            kernel_size=kernel_size,
+            dilation=dilation,
+            padding=padding,
+            stride=stride)
+
+        sample_dim = kernel_size[0] * kernel_size[1] * in_channels
+
+        if norm_cfg is not None:
+            self.norm = build_norm_layer(norm_cfg, sample_dim)[1]
+        else:
+            self.norm = None
+
+        self.reduction = nn.Linear(sample_dim, out_channels, bias=bias)
+
+    def forward(self, x, input_size):
+        """
+        Args:
+            x (Tensor): Has shape (B, H*W, C_in).
+            input_size (tuple[int]): The spatial shape of x, arrange as (H, W).
+                Default: None.
+
+        Returns:
+            tuple: Contains merged results and its spatial shape.
+
+                - x (Tensor): Has shape (B, Merged_H * Merged_W, C_out)
+                - out_size (tuple[int]): Spatial shape of x, arrange as
+                    (Merged_H, Merged_W).
+        """
+        B, L, C = x.shape
+        assert isinstance(input_size, Sequence), f'Expect ' \
+                                                 f'input_size is ' \
+                                                 f'`Sequence` ' \
+                                                 f'but get {input_size}'
+
+        H, W = input_size
+        assert L == H * W, 'input feature has wrong size'
+
+        x = x.view(B, H, W, C).permute([0, 3, 1, 2])  # B, C, H, W
+        # Use nn.Unfold to merge patch. About 25% faster than original method,
+        # but need to modify pretrained model for compatibility
+
+        if self.adap_padding:
+            x = self.adap_padding(x)
+            H, W = x.shape[-2:]
+
+        x = self.sampler(x)
+        # if kernel_size=2 and stride=2, x should has shape (B, 4*C, H/2*W/2)
+
+        out_h = (H + 2 * self.sampler.padding[0] - self.sampler.dilation[0] *
+                 (self.sampler.kernel_size[0] - 1) -
+                 1) // self.sampler.stride[0] + 1
+        out_w = (W + 2 * self.sampler.padding[1] - self.sampler.dilation[1] *
+                 (self.sampler.kernel_size[1] - 1) -
+                 1) // self.sampler.stride[1] + 1
+
+        output_size = (out_h, out_w)
+        x = x.transpose(1, 2)  # B, H/2*W/2, 4*C
+        x = self.norm(x) if self.norm else x
+        x = self.reduction(x)
+        return x, output_size
diff --git a/mmsegmentation/mmseg/models/utils/encoding.py b/mmsegmentation/mmseg/models/utils/encoding.py
new file mode 100644
index 0000000..ee4f057
--- /dev/null
+++ b/mmsegmentation/mmseg/models/utils/encoding.py
@@ -0,0 +1,75 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+
+class Encoding(nn.Module):
+    """Encoding Layer: a learnable residual encoder.
+
+    Input is of shape  (batch_size, channels, height, width).
+    Output is of shape (batch_size, num_codes, channels).
+
+    Args:
+        channels: dimension of the features or feature channels
+        num_codes: number of code words
+    """
+
+    def __init__(self, channels, num_codes):
+        super().__init__()
+        # init codewords and smoothing factor
+        self.channels, self.num_codes = channels, num_codes
+        std = 1. / ((num_codes * channels)**0.5)
+        # [num_codes, channels]
+        self.codewords = nn.Parameter(
+            torch.empty(num_codes, channels,
+                        dtype=torch.float).uniform_(-std, std),
+            requires_grad=True)
+        # [num_codes]
+        self.scale = nn.Parameter(
+            torch.empty(num_codes, dtype=torch.float).uniform_(-1, 0),
+            requires_grad=True)
+
+    @staticmethod
+    def scaled_l2(x, codewords, scale):
+        num_codes, channels = codewords.size()
+        batch_size = x.size(0)
+        reshaped_scale = scale.view((1, 1, num_codes))
+        expanded_x = x.unsqueeze(2).expand(
+            (batch_size, x.size(1), num_codes, channels))
+        reshaped_codewords = codewords.view((1, 1, num_codes, channels))
+
+        scaled_l2_norm = reshaped_scale * (
+            expanded_x - reshaped_codewords).pow(2).sum(dim=3)
+        return scaled_l2_norm
+
+    @staticmethod
+    def aggregate(assignment_weights, x, codewords):
+        num_codes, channels = codewords.size()
+        reshaped_codewords = codewords.view((1, 1, num_codes, channels))
+        batch_size = x.size(0)
+
+        expanded_x = x.unsqueeze(2).expand(
+            (batch_size, x.size(1), num_codes, channels))
+        encoded_feat = (assignment_weights.unsqueeze(3) *
+                        (expanded_x - reshaped_codewords)).sum(dim=1)
+        return encoded_feat
+
+    def forward(self, x):
+        assert x.dim() == 4 and x.size(1) == self.channels
+        # [batch_size, channels, height, width]
+        batch_size = x.size(0)
+        # [batch_size, height x width, channels]
+        x = x.view(batch_size, self.channels, -1).transpose(1, 2).contiguous()
+        # assignment_weights: [batch_size, channels, num_codes]
+        assignment_weights = F.softmax(
+            self.scaled_l2(x, self.codewords, self.scale), dim=2)
+        # aggregate
+        encoded_feat = self.aggregate(assignment_weights, x, self.codewords)
+        return encoded_feat
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(Nx{self.channels}xHxW =>Nx{self.num_codes}' \
+                    f'x{self.channels})'
+        return repr_str
diff --git a/mmsegmentation/mmseg/models/utils/inverted_residual.py b/mmsegmentation/mmseg/models/utils/inverted_residual.py
new file mode 100644
index 0000000..56190b3
--- /dev/null
+++ b/mmsegmentation/mmseg/models/utils/inverted_residual.py
@@ -0,0 +1,213 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.cnn import ConvModule
+from torch import nn
+from torch.utils import checkpoint as cp
+
+from .se_layer import SELayer
+
+
+class InvertedResidual(nn.Module):
+    """InvertedResidual block for MobileNetV2.
+
+    Args:
+        in_channels (int): The input channels of the InvertedResidual block.
+        out_channels (int): The output channels of the InvertedResidual block.
+        stride (int): Stride of the middle (first) 3x3 convolution.
+        expand_ratio (int): Adjusts number of channels of the hidden layer
+            in InvertedResidual by this amount.
+        dilation (int): Dilation rate of depthwise conv. Default: 1
+        conv_cfg (dict): Config dict for convolution layer.
+            Default: None, which means using conv2d.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN').
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='ReLU6').
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed. Default: False.
+
+    Returns:
+        Tensor: The output tensor.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 stride,
+                 expand_ratio,
+                 dilation=1,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU6'),
+                 with_cp=False,
+                 **kwargs):
+        super().__init__()
+        self.stride = stride
+        assert stride in [1, 2], f'stride must in [1, 2]. ' \
+            f'But received {stride}.'
+        self.with_cp = with_cp
+        self.use_res_connect = self.stride == 1 and in_channels == out_channels
+        hidden_dim = int(round(in_channels * expand_ratio))
+
+        layers = []
+        if expand_ratio != 1:
+            layers.append(
+                ConvModule(
+                    in_channels=in_channels,
+                    out_channels=hidden_dim,
+                    kernel_size=1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg,
+                    **kwargs))
+        layers.extend([
+            ConvModule(
+                in_channels=hidden_dim,
+                out_channels=hidden_dim,
+                kernel_size=3,
+                stride=stride,
+                padding=dilation,
+                dilation=dilation,
+                groups=hidden_dim,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg,
+                **kwargs),
+            ConvModule(
+                in_channels=hidden_dim,
+                out_channels=out_channels,
+                kernel_size=1,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=None,
+                **kwargs)
+        ])
+        self.conv = nn.Sequential(*layers)
+
+    def forward(self, x):
+
+        def _inner_forward(x):
+            if self.use_res_connect:
+                return x + self.conv(x)
+            else:
+                return self.conv(x)
+
+        if self.with_cp and x.requires_grad:
+            out = cp.checkpoint(_inner_forward, x)
+        else:
+            out = _inner_forward(x)
+
+        return out
+
+
+class InvertedResidualV3(nn.Module):
+    """Inverted Residual Block for MobileNetV3.
+
+    Args:
+        in_channels (int): The input channels of this Module.
+        out_channels (int): The output channels of this Module.
+        mid_channels (int): The input channels of the depthwise convolution.
+        kernel_size (int): The kernel size of the depthwise convolution.
+            Default: 3.
+        stride (int): The stride of the depthwise convolution. Default: 1.
+        se_cfg (dict): Config dict for se layer. Default: None, which means no
+            se layer.
+        with_expand_conv (bool): Use expand conv or not. If set False,
+            mid_channels must be the same with in_channels. Default: True.
+        conv_cfg (dict): Config dict for convolution layer. Default: None,
+            which means using conv2d.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN').
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='ReLU').
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed. Default: False.
+
+    Returns:
+        Tensor: The output tensor.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 mid_channels,
+                 kernel_size=3,
+                 stride=1,
+                 se_cfg=None,
+                 with_expand_conv=True,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 with_cp=False):
+        super().__init__()
+        self.with_res_shortcut = (stride == 1 and in_channels == out_channels)
+        assert stride in [1, 2]
+        self.with_cp = with_cp
+        self.with_se = se_cfg is not None
+        self.with_expand_conv = with_expand_conv
+
+        if self.with_se:
+            assert isinstance(se_cfg, dict)
+        if not self.with_expand_conv:
+            assert mid_channels == in_channels
+
+        if self.with_expand_conv:
+            self.expand_conv = ConvModule(
+                in_channels=in_channels,
+                out_channels=mid_channels,
+                kernel_size=1,
+                stride=1,
+                padding=0,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg)
+        self.depthwise_conv = ConvModule(
+            in_channels=mid_channels,
+            out_channels=mid_channels,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=kernel_size // 2,
+            groups=mid_channels,
+            conv_cfg=dict(
+                type='Conv2dAdaptivePadding') if stride == 2 else conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+
+        if self.with_se:
+            self.se = SELayer(**se_cfg)
+
+        self.linear_conv = ConvModule(
+            in_channels=mid_channels,
+            out_channels=out_channels,
+            kernel_size=1,
+            stride=1,
+            padding=0,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=None)
+
+    def forward(self, x):
+
+        def _inner_forward(x):
+            out = x
+
+            if self.with_expand_conv:
+                out = self.expand_conv(out)
+
+            out = self.depthwise_conv(out)
+
+            if self.with_se:
+                out = self.se(out)
+
+            out = self.linear_conv(out)
+
+            if self.with_res_shortcut:
+                return x + out
+            else:
+                return out
+
+        if self.with_cp and x.requires_grad:
+            out = cp.checkpoint(_inner_forward, x)
+        else:
+            out = _inner_forward(x)
+
+        return out
diff --git a/mmsegmentation/mmseg/models/utils/make_divisible.py b/mmsegmentation/mmseg/models/utils/make_divisible.py
new file mode 100644
index 0000000..ed42c2e
--- /dev/null
+++ b/mmsegmentation/mmseg/models/utils/make_divisible.py
@@ -0,0 +1,28 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+def make_divisible(value, divisor, min_value=None, min_ratio=0.9):
+    """Make divisible function.
+
+    This function rounds the channel number to the nearest value that can be
+    divisible by the divisor. It is taken from the original tf repo. It ensures
+    that all layers have a channel number that is divisible by divisor. It can
+    be seen here: https://github.com/tensorflow/models/blob/master/research/slim/nets/mobilenet/mobilenet.py  # noqa
+
+    Args:
+        value (int): The original channel number.
+        divisor (int): The divisor to fully divide the channel number.
+        min_value (int): The minimum value of the output channel.
+            Default: None, means that the minimum value equal to the divisor.
+        min_ratio (float): The minimum ratio of the rounded channel number to
+            the original channel number. Default: 0.9.
+
+    Returns:
+        int: The modified output channel number.
+    """
+
+    if min_value is None:
+        min_value = divisor
+    new_value = max(min_value, int(value + divisor / 2) // divisor * divisor)
+    # Make sure that round down does not go down by more than (1-min_ratio).
+    if new_value < min_ratio * value:
+        new_value += divisor
+    return new_value
diff --git a/mmsegmentation/mmseg/models/utils/point_sample.py b/mmsegmentation/mmseg/models/utils/point_sample.py
new file mode 100644
index 0000000..1afc957
--- /dev/null
+++ b/mmsegmentation/mmseg/models/utils/point_sample.py
@@ -0,0 +1,88 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from mmcv.ops import point_sample
+from torch import Tensor
+
+
+def get_uncertainty(mask_preds: Tensor, labels: Tensor) -> Tensor:
+    """Estimate uncertainty based on pred logits.
+
+    We estimate uncertainty as L1 distance between 0.0 and the logits
+    prediction in 'mask_preds' for the foreground class in `classes`.
+
+    Args:
+        mask_preds (Tensor): mask predication logits, shape (num_rois,
+            num_classes, mask_height, mask_width).
+
+        labels (Tensor): Either predicted or ground truth label for
+            each predicted mask, of length num_rois.
+
+    Returns:
+        scores (Tensor): Uncertainty scores with the most uncertain
+            locations having the highest uncertainty score,
+            shape (num_rois, 1, mask_height, mask_width)
+    """
+    if mask_preds.shape[1] == 1:
+        gt_class_logits = mask_preds.clone()
+    else:
+        inds = torch.arange(mask_preds.shape[0], device=mask_preds.device)
+        gt_class_logits = mask_preds[inds, labels].unsqueeze(1)
+    return -torch.abs(gt_class_logits)
+
+
+def get_uncertain_point_coords_with_randomness(
+        mask_preds: Tensor, labels: Tensor, num_points: int,
+        oversample_ratio: float, importance_sample_ratio: float) -> Tensor:
+    """Get ``num_points`` most uncertain points with random points during
+    train.
+
+    Sample points in [0, 1] x [0, 1] coordinate space based on their
+    uncertainty. The uncertainties are calculated for each point using
+    'get_uncertainty()' function that takes point's logit prediction as
+    input.
+
+    Args:
+        mask_preds (Tensor): A tensor of shape (num_rois, num_classes,
+            mask_height, mask_width) for class-specific or class-agnostic
+            prediction.
+        labels (Tensor): The ground truth class for each instance.
+        num_points (int): The number of points to sample.
+        oversample_ratio (float): Oversampling parameter.
+        importance_sample_ratio (float): Ratio of points that are sampled
+            via importnace sampling.
+
+    Returns:
+        point_coords (Tensor): A tensor of shape (num_rois, num_points, 2)
+            that contains the coordinates sampled points.
+    """
+    assert oversample_ratio >= 1
+    assert 0 <= importance_sample_ratio <= 1
+    batch_size = mask_preds.shape[0]
+    num_sampled = int(num_points * oversample_ratio)
+    point_coords = torch.rand(
+        batch_size, num_sampled, 2, device=mask_preds.device)
+    point_logits = point_sample(mask_preds, point_coords)
+    # It is crucial to calculate uncertainty based on the sampled
+    # prediction value for the points. Calculating uncertainties of the
+    # coarse predictions first and sampling them for points leads to
+    # incorrect results.  To illustrate this: assume uncertainty func(
+    # logits)=-abs(logits), a sampled point between two coarse
+    # predictions with -1 and 1 logits has 0 logits, and therefore 0
+    # uncertainty value. However, if we calculate uncertainties for the
+    # coarse predictions first, both will have -1 uncertainty,
+    # and sampled point will get -1 uncertainty.
+    point_uncertainties = get_uncertainty(point_logits, labels)
+    num_uncertain_points = int(importance_sample_ratio * num_points)
+    num_random_points = num_points - num_uncertain_points
+    idx = torch.topk(
+        point_uncertainties[:, 0, :], k=num_uncertain_points, dim=1)[1]
+    shift = num_sampled * torch.arange(
+        batch_size, dtype=torch.long, device=mask_preds.device)
+    idx += shift[:, None]
+    point_coords = point_coords.view(-1, 2)[idx.view(-1), :].view(
+        batch_size, num_uncertain_points, 2)
+    if num_random_points > 0:
+        rand_roi_coords = torch.rand(
+            batch_size, num_random_points, 2, device=mask_preds.device)
+        point_coords = torch.cat((point_coords, rand_roi_coords), dim=1)
+    return point_coords
diff --git a/mmsegmentation/mmseg/models/utils/ppm.py b/mmsegmentation/mmseg/models/utils/ppm.py
new file mode 100644
index 0000000..5fe6ff2
--- /dev/null
+++ b/mmsegmentation/mmseg/models/utils/ppm.py
@@ -0,0 +1,193 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, List
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule, ModuleList, Sequential
+from torch import Tensor
+
+
+class DAPPM(BaseModule):
+    """DAPPM module in `DDRNet <https://arxiv.org/abs/2101.06085>`_.
+
+    Args:
+        in_channels (int): Input channels.
+        branch_channels (int): Branch channels.
+        out_channels (int): Output channels.
+        num_scales (int): Number of scales.
+        kernel_sizes (list[int]): Kernel sizes of each scale.
+        strides (list[int]): Strides of each scale.
+        paddings (list[int]): Paddings of each scale.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN').
+        act_cfg (dict): Config dict for activation layer in ConvModule.
+            Default: dict(type='ReLU', inplace=True).
+        conv_cfg (dict): Config dict for convolution layer in ConvModule.
+            Default: dict(order=('norm', 'act', 'conv'), bias=False).
+        upsample_mode (str): Upsample mode. Default: 'bilinear'.
+    """
+
+    def __init__(self,
+                 in_channels: int,
+                 branch_channels: int,
+                 out_channels: int,
+                 num_scales: int,
+                 kernel_sizes: List[int] = [5, 9, 17],
+                 strides: List[int] = [2, 4, 8],
+                 paddings: List[int] = [2, 4, 8],
+                 norm_cfg: Dict = dict(type='BN', momentum=0.1),
+                 act_cfg: Dict = dict(type='ReLU', inplace=True),
+                 conv_cfg: Dict = dict(
+                     order=('norm', 'act', 'conv'), bias=False),
+                 upsample_mode: str = 'bilinear'):
+        super().__init__()
+
+        self.num_scales = num_scales
+        self.unsample_mode = upsample_mode
+        self.in_channels = in_channels
+        self.branch_channels = branch_channels
+        self.out_channels = out_channels
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+        self.conv_cfg = conv_cfg
+
+        self.scales = ModuleList([
+            ConvModule(
+                in_channels,
+                branch_channels,
+                kernel_size=1,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg,
+                **conv_cfg)
+        ])
+        for i in range(1, num_scales - 1):
+            self.scales.append(
+                Sequential(*[
+                    nn.AvgPool2d(
+                        kernel_size=kernel_sizes[i - 1],
+                        stride=strides[i - 1],
+                        padding=paddings[i - 1]),
+                    ConvModule(
+                        in_channels,
+                        branch_channels,
+                        kernel_size=1,
+                        norm_cfg=norm_cfg,
+                        act_cfg=act_cfg,
+                        **conv_cfg)
+                ]))
+        self.scales.append(
+            Sequential(*[
+                nn.AdaptiveAvgPool2d((1, 1)),
+                ConvModule(
+                    in_channels,
+                    branch_channels,
+                    kernel_size=1,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg,
+                    **conv_cfg)
+            ]))
+        self.processes = ModuleList()
+        for i in range(num_scales - 1):
+            self.processes.append(
+                ConvModule(
+                    branch_channels,
+                    branch_channels,
+                    kernel_size=3,
+                    padding=1,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg,
+                    **conv_cfg))
+
+        self.compression = ConvModule(
+            branch_channels * num_scales,
+            out_channels,
+            kernel_size=1,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg,
+            **conv_cfg)
+
+        self.shortcut = ConvModule(
+            in_channels,
+            out_channels,
+            kernel_size=1,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg,
+            **conv_cfg)
+
+    def forward(self, inputs: Tensor):
+        feats = []
+        feats.append(self.scales[0](inputs))
+
+        for i in range(1, self.num_scales):
+            feat_up = F.interpolate(
+                self.scales[i](inputs),
+                size=inputs.shape[2:],
+                mode=self.unsample_mode)
+            feats.append(self.processes[i - 1](feat_up + feats[i - 1]))
+
+        return self.compression(torch.cat(feats,
+                                          dim=1)) + self.shortcut(inputs)
+
+
+class PAPPM(DAPPM):
+    """PAPPM module in `PIDNet <https://arxiv.org/abs/2206.02066>`_.
+
+    Args:
+        in_channels (int): Input channels.
+        branch_channels (int): Branch channels.
+        out_channels (int): Output channels.
+        num_scales (int): Number of scales.
+        kernel_sizes (list[int]): Kernel sizes of each scale.
+        strides (list[int]): Strides of each scale.
+        paddings (list[int]): Paddings of each scale.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN', momentum=0.1).
+        act_cfg (dict): Config dict for activation layer in ConvModule.
+            Default: dict(type='ReLU', inplace=True).
+        conv_cfg (dict): Config dict for convolution layer in ConvModule.
+            Default: dict(order=('norm', 'act', 'conv'), bias=False).
+        upsample_mode (str): Upsample mode. Default: 'bilinear'.
+    """
+
+    def __init__(self,
+                 in_channels: int,
+                 branch_channels: int,
+                 out_channels: int,
+                 num_scales: int,
+                 kernel_sizes: List[int] = [5, 9, 17],
+                 strides: List[int] = [2, 4, 8],
+                 paddings: List[int] = [2, 4, 8],
+                 norm_cfg: Dict = dict(type='BN', momentum=0.1),
+                 act_cfg: Dict = dict(type='ReLU', inplace=True),
+                 conv_cfg: Dict = dict(
+                     order=('norm', 'act', 'conv'), bias=False),
+                 upsample_mode: str = 'bilinear'):
+        super().__init__(in_channels, branch_channels, out_channels,
+                         num_scales, kernel_sizes, strides, paddings, norm_cfg,
+                         act_cfg, conv_cfg, upsample_mode)
+
+        self.processes = ConvModule(
+            self.branch_channels * (self.num_scales - 1),
+            self.branch_channels * (self.num_scales - 1),
+            kernel_size=3,
+            padding=1,
+            groups=self.num_scales - 1,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg,
+            **self.conv_cfg)
+
+    def forward(self, inputs: Tensor):
+        x_ = self.scales[0](inputs)
+        feats = []
+        for i in range(1, self.num_scales):
+            feat_up = F.interpolate(
+                self.scales[i](inputs),
+                size=inputs.shape[2:],
+                mode=self.unsample_mode,
+                align_corners=False)
+            feats.append(feat_up + x_)
+        scale_out = self.processes(torch.cat(feats, dim=1))
+        return self.compression(torch.cat([x_, scale_out],
+                                          dim=1)) + self.shortcut(inputs)
diff --git a/mmsegmentation/mmseg/models/utils/res_layer.py b/mmsegmentation/mmseg/models/utils/res_layer.py
new file mode 100644
index 0000000..3dd7a6f
--- /dev/null
+++ b/mmsegmentation/mmseg/models/utils/res_layer.py
@@ -0,0 +1,96 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.cnn import build_conv_layer, build_norm_layer
+from mmengine.model import Sequential
+from torch import nn as nn
+
+
+class ResLayer(Sequential):
+    """ResLayer to build ResNet style backbone.
+
+    Args:
+        block (nn.Module): block used to build ResLayer.
+        inplanes (int): inplanes of block.
+        planes (int): planes of block.
+        num_blocks (int): number of blocks.
+        stride (int): stride of the first block. Default: 1
+        avg_down (bool): Use AvgPool instead of stride conv when
+            downsampling in the bottleneck. Default: False
+        conv_cfg (dict): dictionary to construct and config conv layer.
+            Default: None
+        norm_cfg (dict): dictionary to construct and config norm layer.
+            Default: dict(type='BN')
+        multi_grid (int | None): Multi grid dilation rates of last
+            stage. Default: None
+        contract_dilation (bool): Whether contract first dilation of each layer
+            Default: False
+    """
+
+    def __init__(self,
+                 block,
+                 inplanes,
+                 planes,
+                 num_blocks,
+                 stride=1,
+                 dilation=1,
+                 avg_down=False,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 multi_grid=None,
+                 contract_dilation=False,
+                 **kwargs):
+        self.block = block
+
+        downsample = None
+        if stride != 1 or inplanes != planes * block.expansion:
+            downsample = []
+            conv_stride = stride
+            if avg_down:
+                conv_stride = 1
+                downsample.append(
+                    nn.AvgPool2d(
+                        kernel_size=stride,
+                        stride=stride,
+                        ceil_mode=True,
+                        count_include_pad=False))
+            downsample.extend([
+                build_conv_layer(
+                    conv_cfg,
+                    inplanes,
+                    planes * block.expansion,
+                    kernel_size=1,
+                    stride=conv_stride,
+                    bias=False),
+                build_norm_layer(norm_cfg, planes * block.expansion)[1]
+            ])
+            downsample = nn.Sequential(*downsample)
+
+        layers = []
+        if multi_grid is None:
+            if dilation > 1 and contract_dilation:
+                first_dilation = dilation // 2
+            else:
+                first_dilation = dilation
+        else:
+            first_dilation = multi_grid[0]
+        layers.append(
+            block(
+                inplanes=inplanes,
+                planes=planes,
+                stride=stride,
+                dilation=first_dilation,
+                downsample=downsample,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                **kwargs))
+        inplanes = planes * block.expansion
+        for i in range(1, num_blocks):
+            layers.append(
+                block(
+                    inplanes=inplanes,
+                    planes=planes,
+                    stride=1,
+                    dilation=dilation if multi_grid is None else multi_grid[i],
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    **kwargs))
+        super().__init__(*layers)
diff --git a/mmsegmentation/mmseg/models/utils/san_layers.py b/mmsegmentation/mmseg/models/utils/san_layers.py
new file mode 100644
index 0000000..2267686
--- /dev/null
+++ b/mmsegmentation/mmseg/models/utils/san_layers.py
@@ -0,0 +1,418 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# Modified from https://github.com/MendelXu/SAN/blob/main/san/model/attn_helper.py  # noqa: E501
+# Copyright (c) 2023 MendelXu.
+# Licensed under the MIT License
+
+import warnings
+from typing import Optional
+
+import torch
+from mmcv.cnn.bricks.transformer import BaseTransformerLayer
+from torch import Tensor, nn
+from torch.nn import functional as F
+
+
+def cross_attn_with_self_bias(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    embed_dim_to_check: int,
+    num_heads: int,
+    in_proj_weight: Tensor,
+    in_proj_bias: Tensor,
+    bias_k: Optional[Tensor],
+    bias_v: Optional[Tensor],
+    add_zero_attn: bool,
+    dropout_p: float,
+    out_proj_weight: Tensor,
+    out_proj_bias: Tensor,
+    training: bool = True,
+    key_padding_mask: Optional[Tensor] = None,
+    need_weights: bool = True,
+    attn_mask: Optional[Tensor] = None,
+    use_separate_proj_weight: bool = False,
+    q_proj_weight: Optional[Tensor] = None,
+    k_proj_weight: Optional[Tensor] = None,
+    v_proj_weight: Optional[Tensor] = None,
+    static_k: Optional[Tensor] = None,
+    static_v: Optional[Tensor] = None,
+):
+    """Forward function of multi-head attention. Modified from
+    multi_head_attention_forward in
+    https://github.com/pytorch/pytorch/blob/main/torch/nn/functional.py.
+
+    Args:
+        query, key, value: map a query and a set of key-value pairs to an output.
+            See "Attention Is All You Need" for more details.
+        embed_dim_to_check: total dimension of the model.
+        num_heads: parallel attention heads.
+        in_proj_weight, in_proj_bias: input projection weight and bias.
+        bias_k, bias_v: bias of the key and value sequences to be added at dim=0.
+        add_zero_attn: add a new batch of zeros to the key and
+                       value sequences at dim=1.
+        dropout_p: probability of an element to be zeroed.
+        out_proj_weight, out_proj_bias: the output projection weight and bias.
+        training: apply dropout if is ``True``.
+        key_padding_mask: if provided, specified padding elements in the key will
+            be ignored by the attention. This is an binary mask. When the value is True,
+            the corresponding value on the attention layer will be filled with -inf.
+        need_weights: output attn_output_weights.
+            Default: `True`
+            Note: `needs_weight` defaults to `True`, but should be set to `False`
+            For best performance when attention weights are not needed.
+            *Setting needs_weights to `True`
+            leads to a significant performance degradation.*
+        attn_mask: 2D mask that prevents attention to certain positions. A 2D mask will be broadcasted for all
+            the batches while a 3D mask allows to specify a different mask for the entries of each batch.
+        use_separate_proj_weight: the function accept the proj. weights for query, key,
+            and value in different forms. If false, in_proj_weight will be used, which is
+            a combination of q_proj_weight, k_proj_weight, v_proj_weight.
+        q_proj_weight, k_proj_weight, v_proj_weight, in_proj_bias: input projection weight and bias.
+        static_k, static_v: static key and value used for attention operators.
+    """  # noqa: E501
+    tgt_len, bsz, embed_dim = query.size()
+    assert embed_dim == embed_dim_to_check
+    # allow MHA to have different sizes for the feature dimension
+    assert key.size(0) == value.size(0) and key.size(1) == value.size(1)
+
+    head_dim = embed_dim // num_heads
+    assert head_dim * num_heads == embed_dim, \
+        'embed_dim must be divisible by num_heads'
+    scaling = float(head_dim)**-0.5
+
+    if not use_separate_proj_weight:
+        if (query is key or torch.equal(
+                query, key)) and (key is value or torch.equal(key, value)):
+            # self-attention
+            raise NotImplementedError('self-attention is not implemented')
+
+        elif key is value or torch.equal(key, value):
+            # encoder-decoder attention
+            # This is inline in_proj function
+            # with in_proj_weight and in_proj_bias
+            _b = in_proj_bias
+            _start = 0
+            _end = embed_dim
+            _w = in_proj_weight[_start:_end, :]
+            if _b is not None:
+                _b = _b[_start:_end]
+            q = F.linear(query, _w, _b)
+
+            if key is None:
+                assert value is None
+                k = None
+                v = None
+                q_k = None
+                q_v = None
+            else:
+                # This is inline in_proj function with
+                # in_proj_weight and in_proj_bias
+                _b = in_proj_bias
+                _start = embed_dim
+                _end = None
+                _w = in_proj_weight[_start:, :]
+                if _b is not None:
+                    _b = _b[_start:]
+                k, v = F.linear(key, _w, _b).chunk(2, dim=-1)
+                q_k, q_v = F.linear(query, _w, _b).chunk(2, dim=-1)
+        else:
+            # This is inline in_proj function with
+            # in_proj_weight and in_proj_bias
+            _b = in_proj_bias
+            _start = 0
+            _end = embed_dim
+            _w = in_proj_weight[_start:_end, :]
+            if _b is not None:
+                _b = _b[_start:_end]
+            q = F.linear(query, _w, _b)
+
+            # This is inline in_proj function with
+            # in_proj_weight and in_proj_bias
+            _b = in_proj_bias
+            _start = embed_dim
+            _end = embed_dim * 2
+            _w = in_proj_weight[_start:_end, :]
+            if _b is not None:
+                _b = _b[_start:_end]
+            k = F.linear(key, _w, _b)
+            q_k = F.linear(query, _w, _b)
+            # This is inline in_proj function with
+            # in_proj_weight and in_proj_bias
+            _b = in_proj_bias
+            _start = embed_dim * 2
+            _end = None
+            _w = in_proj_weight[_start:, :]
+            if _b is not None:
+                _b = _b[_start:]
+            v = F.linear(value, _w, _b)
+            q_v = F.linear(query, _w, _b)
+    else:
+        q_proj_weight_non_opt = \
+            torch.jit._unwrap_optional(q_proj_weight)
+        len1, len2 = q_proj_weight_non_opt.size()
+        assert len1 == embed_dim and len2 == query.size(-1)
+
+        k_proj_weight_non_opt = \
+            torch.jit._unwrap_optional(k_proj_weight)
+        len1, len2 = k_proj_weight_non_opt.size()
+        assert len1 == embed_dim and len2 == key.size(-1)
+
+        v_proj_weight_non_opt = \
+            torch.jit._unwrap_optional(v_proj_weight)
+        len1, len2 = v_proj_weight_non_opt.size()
+        assert len1 == embed_dim and len2 == value.size(-1)
+
+        if in_proj_bias is not None:
+            q = F.linear(query, q_proj_weight_non_opt,
+                         in_proj_bias[0:embed_dim])
+            k = F.linear(key, k_proj_weight_non_opt,
+                         in_proj_bias[embed_dim:(embed_dim * 2)])
+            v = F.linear(value, v_proj_weight_non_opt,
+                         in_proj_bias[(embed_dim * 2):])
+        else:
+            q = F.linear(query, q_proj_weight_non_opt, in_proj_bias)
+            k = F.linear(key, k_proj_weight_non_opt, in_proj_bias)
+            v = F.linear(value, v_proj_weight_non_opt, in_proj_bias)
+    q = q * scaling
+
+    if attn_mask is not None:
+        assert (
+            attn_mask.dtype == torch.float32
+            or attn_mask.dtype == torch.float64
+            or attn_mask.dtype == torch.float16
+            or attn_mask.dtype == torch.uint8 or attn_mask.dtype == torch.bool
+        ), 'Only float, byte, and bool types are supported for ' \
+           'attn_mask, not {}'.format(attn_mask.dtype)
+        if attn_mask.dtype == torch.uint8:
+            warnings.warn('Byte tensor for attn_mask in nn.MultiheadAttention '
+                          'is deprecated. Use bool tensor instead.')
+            attn_mask = attn_mask.to(torch.bool)
+
+        if attn_mask.dim() == 2:
+            attn_mask = attn_mask.unsqueeze(0)
+            if list(attn_mask.size()) != [1, query.size(0), key.size(0)]:
+                raise RuntimeError(
+                    'The size of the 2D attn_mask is not correct.')
+        elif attn_mask.dim() == 3:
+            if list(attn_mask.size()) != [
+                    bsz * num_heads,
+                    query.size(0), key.size(0)
+            ]:
+                raise RuntimeError(
+                    'The size of the 3D attn_mask is not correct.')
+        else:
+            raise RuntimeError(
+                "attn_mask's dimension {} is not supported".format(
+                    attn_mask.dim()))
+        # attn_mask's dim is 3 now.
+
+    # convert ByteTensor key_padding_mask to bool
+    if key_padding_mask is not None and key_padding_mask.dtype == torch.uint8:
+        warnings.warn(
+            'Byte tensor for key_padding_mask in nn.MultiheadAttention '
+            'is deprecated. Use bool tensor instead.')
+        key_padding_mask = key_padding_mask.to(torch.bool)
+
+    if bias_k is not None and bias_v is not None:
+        if static_k is None and static_v is None:
+            k = torch.cat([k, bias_k.repeat(1, bsz, 1)])
+            v = torch.cat([v, bias_v.repeat(1, bsz, 1)])
+            if attn_mask is not None:
+                attn_mask = F.pad(attn_mask, (0, 1))
+            if key_padding_mask is not None:
+                key_padding_mask = F.pad(key_padding_mask, (0, 1))
+        else:
+            assert static_k is None, 'bias cannot be added to static key.'
+            assert static_v is None, 'bias cannot be added to static value.'
+    else:
+        assert bias_k is None
+        assert bias_v is None
+
+    q = q.contiguous().view(tgt_len, bsz * num_heads, head_dim).transpose(0, 1)
+    if k is not None:
+        k = k.contiguous().view(-1, bsz * num_heads, head_dim).transpose(0, 1)
+        q_k = q_k.contiguous().view(tgt_len, bsz * num_heads,
+                                    head_dim).transpose(0, 1)
+    if v is not None:
+        v = v.contiguous().view(-1, bsz * num_heads, head_dim).transpose(0, 1)
+        q_v = q_v.contiguous().view(tgt_len, bsz * num_heads,
+                                    head_dim).transpose(0, 1)
+
+    if static_k is not None:
+        assert static_k.size(0) == bsz * num_heads
+        assert static_k.size(2) == head_dim
+        k = static_k
+
+    if static_v is not None:
+        assert static_v.size(0) == bsz * num_heads
+        assert static_v.size(2) == head_dim
+        v = static_v
+
+    src_len = k.size(1)
+
+    if key_padding_mask is not None:
+        assert key_padding_mask.size(0) == bsz
+        assert key_padding_mask.size(1) == src_len
+
+    if add_zero_attn:
+        src_len += 1
+        k = torch.cat(
+            [
+                k,
+                torch.zeros(
+                    (k.size(0), 1) + k.size()[2:],
+                    dtype=k.dtype,
+                    device=k.device),
+            ],
+            dim=1,
+        )
+        v = torch.cat(
+            [
+                v,
+                torch.zeros(
+                    (v.size(0), 1) + v.size()[2:],
+                    dtype=v.dtype,
+                    device=v.device),
+            ],
+            dim=1,
+        )
+        if attn_mask is not None:
+            attn_mask = F.pad(attn_mask, (0, 1))
+        if key_padding_mask is not None:
+            key_padding_mask = F.pad(key_padding_mask, (0, 1))
+
+    attn_output_weights = torch.bmm(q, k.transpose(1, 2))
+    assert list(
+        attn_output_weights.size()) == [bsz * num_heads, tgt_len, src_len]
+
+    if attn_mask is not None:
+        if attn_mask.dtype == torch.bool:
+            attn_output_weights.masked_fill_(attn_mask, float('-inf'))
+        else:
+            attn_output_weights += attn_mask
+
+    if key_padding_mask is not None:
+        attn_output_weights = attn_output_weights.view(bsz, num_heads, tgt_len,
+                                                       src_len)
+        attn_output_weights = attn_output_weights.masked_fill(
+            key_padding_mask.unsqueeze(1).unsqueeze(2),
+            float('-inf'),
+        )
+        attn_output_weights = attn_output_weights.view(bsz * num_heads,
+                                                       tgt_len, src_len)
+    # attn_out_weights: [bsz * num_heads, tgt_len, src_len]
+    # ->[bsz * num_heads, tgt_len, src_len+1]
+    self_weight = (q * q_k).sum(
+        dim=-1, keepdim=True)  # [bsz * num_heads, tgt_len, 1]
+    total_attn_output_weights = torch.cat([attn_output_weights, self_weight],
+                                          dim=-1)
+    total_attn_output_weights = F.softmax(total_attn_output_weights, dim=-1)
+    total_attn_output_weights = F.dropout(
+        total_attn_output_weights, p=dropout_p, training=training)
+    attn_output_weights = \
+        total_attn_output_weights[:, :, : -1]
+    # [bsz * num_heads, tgt_len, src_len]
+    self_weight = \
+        total_attn_output_weights[:, :, -1:]  # [bsz * num_heads, tgt_len, 1]
+
+    attn_output = torch.bmm(attn_output_weights,
+                            v)  # [bsz * num_heads, tgt_len, head_dim]
+    attn_output = (attn_output + self_weight * q_v
+                   )  # [bsz * num_heads, tgt_len, head_dim]
+    assert list(attn_output.size()) == [bsz * num_heads, tgt_len, head_dim]
+    attn_output = attn_output.transpose(0, 1).contiguous().view(
+        tgt_len, bsz, embed_dim)
+    attn_output = F.linear(attn_output, out_proj_weight, out_proj_bias)
+
+    if need_weights:
+        # average attention weights over heads
+        attn_output_weights = attn_output_weights.view(bsz, num_heads, tgt_len,
+                                                       src_len)
+        return attn_output, attn_output_weights  # .sum(dim=1) / num_heads
+    else:
+        return attn_output, None
+
+
+def cross_attn_layer(tf_layer: BaseTransformerLayer, x, mem, attn_bias):
+    """Implementation of transformer layer with cross attention. The cross
+    attention shares the embedding weights with self-attention of tf_layer.
+    Args:
+        tf_layer: (TransformerEncoderLayer): The Module of transformer layer.
+        x (Tensor): query [K,N,C]
+        mem (Tensor): key and value [L,N,C]
+        attn_bias (Tensor): attention bias [N*num_head,K,L]
+
+    Return:
+        x (Tensor): cross attention output [K,N,C]
+    """
+    self_attn_layer = tf_layer.attentions[0].attn
+    attn_layer_paras = {
+        'embed_dim_to_check': self_attn_layer.embed_dim,
+        'num_heads': self_attn_layer.num_heads,
+        'in_proj_weight': self_attn_layer.in_proj_weight,
+        'in_proj_bias': self_attn_layer.in_proj_bias,
+        'bias_k': self_attn_layer.bias_k,
+        'bias_v': self_attn_layer.bias_v,
+        'add_zero_attn': self_attn_layer.add_zero_attn,
+        'dropout_p': self_attn_layer.dropout,
+        'out_proj_weight': self_attn_layer.out_proj.weight,
+        'out_proj_bias': self_attn_layer.out_proj.bias,
+        'training': self_attn_layer.training
+    }
+
+    q_x = tf_layer.norms[0](x)
+    k_x = v_x = tf_layer.norms[0](mem)
+    x = x + cross_attn_with_self_bias(
+        q_x,
+        k_x,
+        v_x,
+        attn_mask=attn_bias,
+        need_weights=False,
+        **attn_layer_paras)[0]
+    x = tf_layer.ffns[0](tf_layer.norms[1](x), identity=x)
+    return x
+
+
+class LayerNorm2d(nn.Module):
+    """A LayerNorm variant, popularized by Transformers, that performs point-
+    wise mean and variance normalization over the channel dimension for inputs
+    that have shape (batch_size, channels, height, width).
+
+    https://github.com/facebookresearch/ConvNeXt/blob/d1fa8f6fef0a165b27399986cc2bdacc92777e40/models/convnext.py#L119  # noqa B950
+    """
+
+    def __init__(self, normalized_shape, eps=1e-6):
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(normalized_shape))
+        self.bias = nn.Parameter(torch.zeros(normalized_shape))
+        self.eps = eps
+        self.normalized_shape = (normalized_shape, )
+
+    def forward(self, x: torch.Tensor):
+        u = x.mean(1, keepdim=True)
+        s = (x - u).pow(2).mean(1, keepdim=True)
+        x = (x - u) / torch.sqrt(s + self.eps)
+        x = self.weight[:, None, None] * x + self.bias[:, None, None]
+        return x
+
+
+class MLP(nn.Module):
+    """Very simple multi-layer perceptron (also called FFN)"""
+
+    def __init__(self,
+                 input_dim,
+                 hidden_dim,
+                 output_dim,
+                 num_layers,
+                 affine_func=nn.Linear):
+        super().__init__()
+        self.num_layers = num_layers
+        h = [hidden_dim] * (num_layers - 1)
+        self.layers = nn.ModuleList(
+            affine_func(n, k)
+            for n, k in zip([input_dim] + h, h + [output_dim]))
+
+    def forward(self, x: torch.Tensor):
+        for i, layer in enumerate(self.layers):
+            x = F.relu(layer(x)) if i < self.num_layers - 1 else layer(x)
+        return x
diff --git a/mmsegmentation/mmseg/models/utils/se_layer.py b/mmsegmentation/mmseg/models/utils/se_layer.py
new file mode 100644
index 0000000..0ff632c
--- /dev/null
+++ b/mmsegmentation/mmseg/models/utils/se_layer.py
@@ -0,0 +1,58 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmengine.utils import is_tuple_of
+
+from .make_divisible import make_divisible
+
+
+class SELayer(nn.Module):
+    """Squeeze-and-Excitation Module.
+
+    Args:
+        channels (int): The input (and output) channels of the SE layer.
+        ratio (int): Squeeze ratio in SELayer, the intermediate channel will be
+            ``int(channels/ratio)``. Default: 16.
+        conv_cfg (None or dict): Config dict for convolution layer.
+            Default: None, which means using conv2d.
+        act_cfg (dict or Sequence[dict]): Config dict for activation layer.
+            If act_cfg is a dict, two activation layers will be configured
+            by this dict. If act_cfg is a sequence of dicts, the first
+            activation layer will be configured by the first dict and the
+            second activation layer will be configured by the second dict.
+            Default: (dict(type='ReLU'), dict(type='HSigmoid', bias=3.0,
+            divisor=6.0)).
+    """
+
+    def __init__(self,
+                 channels,
+                 ratio=16,
+                 conv_cfg=None,
+                 act_cfg=(dict(type='ReLU'),
+                          dict(type='HSigmoid', bias=3.0, divisor=6.0))):
+        super().__init__()
+        if isinstance(act_cfg, dict):
+            act_cfg = (act_cfg, act_cfg)
+        assert len(act_cfg) == 2
+        assert is_tuple_of(act_cfg, dict)
+        self.global_avgpool = nn.AdaptiveAvgPool2d(1)
+        self.conv1 = ConvModule(
+            in_channels=channels,
+            out_channels=make_divisible(channels // ratio, 8),
+            kernel_size=1,
+            stride=1,
+            conv_cfg=conv_cfg,
+            act_cfg=act_cfg[0])
+        self.conv2 = ConvModule(
+            in_channels=make_divisible(channels // ratio, 8),
+            out_channels=channels,
+            kernel_size=1,
+            stride=1,
+            conv_cfg=conv_cfg,
+            act_cfg=act_cfg[1])
+
+    def forward(self, x):
+        out = self.global_avgpool(x)
+        out = self.conv1(out)
+        out = self.conv2(out)
+        return x * out
diff --git a/mmsegmentation/mmseg/models/utils/self_attention_block.py b/mmsegmentation/mmseg/models/utils/self_attention_block.py
new file mode 100644
index 0000000..5bb6e82
--- /dev/null
+++ b/mmsegmentation/mmseg/models/utils/self_attention_block.py
@@ -0,0 +1,161 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from mmcv.cnn import ConvModule
+from mmengine.model.weight_init import constant_init
+from torch import nn as nn
+from torch.nn import functional as F
+
+
+class SelfAttentionBlock(nn.Module):
+    """General self-attention block/non-local block.
+
+    Please refer to https://arxiv.org/abs/1706.03762 for details about key,
+    query and value.
+
+    Args:
+        key_in_channels (int): Input channels of key feature.
+        query_in_channels (int): Input channels of query feature.
+        channels (int): Output channels of key/query transform.
+        out_channels (int): Output channels.
+        share_key_query (bool): Whether share projection weight between key
+            and query projection.
+        query_downsample (nn.Module): Query downsample module.
+        key_downsample (nn.Module): Key downsample module.
+        key_query_num_convs (int): Number of convs for key/query projection.
+        value_num_convs (int): Number of convs for value projection.
+        matmul_norm (bool): Whether normalize attention map with sqrt of
+            channels
+        with_out (bool): Whether use out projection.
+        conv_cfg (dict|None): Config of conv layers.
+        norm_cfg (dict|None): Config of norm layers.
+        act_cfg (dict|None): Config of activation layers.
+    """
+
+    def __init__(self, key_in_channels, query_in_channels, channels,
+                 out_channels, share_key_query, query_downsample,
+                 key_downsample, key_query_num_convs, value_out_num_convs,
+                 key_query_norm, value_out_norm, matmul_norm, with_out,
+                 conv_cfg, norm_cfg, act_cfg):
+        super().__init__()
+        if share_key_query:
+            assert key_in_channels == query_in_channels
+        self.key_in_channels = key_in_channels
+        self.query_in_channels = query_in_channels
+        self.out_channels = out_channels
+        self.channels = channels
+        self.share_key_query = share_key_query
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+        self.key_project = self.build_project(
+            key_in_channels,
+            channels,
+            num_convs=key_query_num_convs,
+            use_conv_module=key_query_norm,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        if share_key_query:
+            self.query_project = self.key_project
+        else:
+            self.query_project = self.build_project(
+                query_in_channels,
+                channels,
+                num_convs=key_query_num_convs,
+                use_conv_module=key_query_norm,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg)
+        self.value_project = self.build_project(
+            key_in_channels,
+            channels if with_out else out_channels,
+            num_convs=value_out_num_convs,
+            use_conv_module=value_out_norm,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        if with_out:
+            self.out_project = self.build_project(
+                channels,
+                out_channels,
+                num_convs=value_out_num_convs,
+                use_conv_module=value_out_norm,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg)
+        else:
+            self.out_project = None
+
+        self.query_downsample = query_downsample
+        self.key_downsample = key_downsample
+        self.matmul_norm = matmul_norm
+
+        self.init_weights()
+
+    def init_weights(self):
+        """Initialize weight of later layer."""
+        if self.out_project is not None:
+            if not isinstance(self.out_project, ConvModule):
+                constant_init(self.out_project, 0)
+
+    def build_project(self, in_channels, channels, num_convs, use_conv_module,
+                      conv_cfg, norm_cfg, act_cfg):
+        """Build projection layer for key/query/value/out."""
+        if use_conv_module:
+            convs = [
+                ConvModule(
+                    in_channels,
+                    channels,
+                    1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg)
+            ]
+            for _ in range(num_convs - 1):
+                convs.append(
+                    ConvModule(
+                        channels,
+                        channels,
+                        1,
+                        conv_cfg=conv_cfg,
+                        norm_cfg=norm_cfg,
+                        act_cfg=act_cfg))
+        else:
+            convs = [nn.Conv2d(in_channels, channels, 1)]
+            for _ in range(num_convs - 1):
+                convs.append(nn.Conv2d(channels, channels, 1))
+        if len(convs) > 1:
+            convs = nn.Sequential(*convs)
+        else:
+            convs = convs[0]
+        return convs
+
+    def forward(self, query_feats, key_feats):
+        """Forward function."""
+        batch_size = query_feats.size(0)
+        query = self.query_project(query_feats)
+        if self.query_downsample is not None:
+            query = self.query_downsample(query)
+        query = query.reshape(*query.shape[:2], -1)
+        query = query.permute(0, 2, 1).contiguous()
+
+        key = self.key_project(key_feats)
+        value = self.value_project(key_feats)
+        if self.key_downsample is not None:
+            key = self.key_downsample(key)
+            value = self.key_downsample(value)
+        key = key.reshape(*key.shape[:2], -1)
+        value = value.reshape(*value.shape[:2], -1)
+        value = value.permute(0, 2, 1).contiguous()
+
+        sim_map = torch.matmul(query, key)
+        if self.matmul_norm:
+            sim_map = (self.channels**-.5) * sim_map
+        sim_map = F.softmax(sim_map, dim=-1)
+
+        context = torch.matmul(sim_map, value)
+        context = context.permute(0, 2, 1).contiguous()
+        context = context.reshape(batch_size, -1, *query_feats.shape[2:])
+        if self.out_project is not None:
+            context = self.out_project(context)
+        return context
diff --git a/mmsegmentation/mmseg/models/utils/shape_convert.py b/mmsegmentation/mmseg/models/utils/shape_convert.py
new file mode 100644
index 0000000..cce1e22
--- /dev/null
+++ b/mmsegmentation/mmseg/models/utils/shape_convert.py
@@ -0,0 +1,107 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+def nlc_to_nchw(x, hw_shape):
+    """Convert [N, L, C] shape tensor to [N, C, H, W] shape tensor.
+
+    Args:
+        x (Tensor): The input tensor of shape [N, L, C] before conversion.
+        hw_shape (Sequence[int]): The height and width of output feature map.
+
+    Returns:
+        Tensor: The output tensor of shape [N, C, H, W] after conversion.
+    """
+    H, W = hw_shape
+    assert len(x.shape) == 3
+    B, L, C = x.shape
+    assert L == H * W, 'The seq_len doesn\'t match H, W'
+    return x.transpose(1, 2).reshape(B, C, H, W)
+
+
+def nchw_to_nlc(x):
+    """Flatten [N, C, H, W] shape tensor to [N, L, C] shape tensor.
+
+    Args:
+        x (Tensor): The input tensor of shape [N, C, H, W] before conversion.
+
+    Returns:
+        Tensor: The output tensor of shape [N, L, C] after conversion.
+    """
+    assert len(x.shape) == 4
+    return x.flatten(2).transpose(1, 2).contiguous()
+
+
+def nchw2nlc2nchw(module, x, contiguous=False, **kwargs):
+    """Flatten [N, C, H, W] shape tensor `x` to [N, L, C] shape tensor. Use the
+    reshaped tensor as the input of `module`, and the convert the output of
+    `module`, whose shape is.
+
+    [N, L, C], to [N, C, H, W].
+
+    Args:
+        module (Callable): A callable object the takes a tensor
+            with shape [N, L, C] as input.
+        x (Tensor): The input tensor of shape [N, C, H, W].
+                contiguous:
+        contiguous (Bool): Whether to make the tensor contiguous
+            after each shape transform.
+
+    Returns:
+        Tensor: The output tensor of shape [N, C, H, W].
+
+    Example:
+        >>> import torch
+        >>> import torch.nn as nn
+        >>> norm = nn.LayerNorm(4)
+        >>> feature_map = torch.rand(4, 4, 5, 5)
+        >>> output = nchw2nlc2nchw(norm, feature_map)
+    """
+    B, C, H, W = x.shape
+    if not contiguous:
+        x = x.flatten(2).transpose(1, 2)
+        x = module(x, **kwargs)
+        x = x.transpose(1, 2).reshape(B, C, H, W)
+    else:
+        x = x.flatten(2).transpose(1, 2).contiguous()
+        x = module(x, **kwargs)
+        x = x.transpose(1, 2).reshape(B, C, H, W).contiguous()
+    return x
+
+
+def nlc2nchw2nlc(module, x, hw_shape, contiguous=False, **kwargs):
+    """Convert [N, L, C] shape tensor `x` to [N, C, H, W] shape tensor. Use the
+    reshaped tensor as the input of `module`, and convert the output of
+    `module`, whose shape is.
+
+    [N, C, H, W], to [N, L, C].
+
+    Args:
+        module (Callable): A callable object the takes a tensor
+            with shape [N, C, H, W] as input.
+        x (Tensor): The input tensor of shape [N, L, C].
+        hw_shape: (Sequence[int]): The height and width of the
+            feature map with shape [N, C, H, W].
+        contiguous (Bool): Whether to make the tensor contiguous
+            after each shape transform.
+
+    Returns:
+        Tensor: The output tensor of shape [N, L, C].
+
+    Example:
+        >>> import torch
+        >>> import torch.nn as nn
+        >>> conv = nn.Conv2d(16, 16, 3, 1, 1)
+        >>> feature_map = torch.rand(4, 25, 16)
+        >>> output = nlc2nchw2nlc(conv, feature_map, (5, 5))
+    """
+    H, W = hw_shape
+    assert len(x.shape) == 3
+    B, L, C = x.shape
+    assert L == H * W, 'The seq_len doesn\'t match H, W'
+    if not contiguous:
+        x = x.transpose(1, 2).reshape(B, C, H, W)
+        x = module(x, **kwargs)
+        x = x.flatten(2).transpose(1, 2)
+    else:
+        x = x.transpose(1, 2).reshape(B, C, H, W).contiguous()
+        x = module(x, **kwargs)
+        x = x.flatten(2).transpose(1, 2).contiguous()
+    return x
diff --git a/mmsegmentation/mmseg/models/utils/up_conv_block.py b/mmsegmentation/mmseg/models/utils/up_conv_block.py
new file mode 100644
index 0000000..4fa3b59
--- /dev/null
+++ b/mmsegmentation/mmseg/models/utils/up_conv_block.py
@@ -0,0 +1,102 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule, build_upsample_layer
+
+
+class UpConvBlock(nn.Module):
+    """Upsample convolution block in decoder for UNet.
+
+    This upsample convolution block consists of one upsample module
+    followed by one convolution block. The upsample module expands the
+    high-level low-resolution feature map and the convolution block fuses
+    the upsampled high-level low-resolution feature map and the low-level
+    high-resolution feature map from encoder.
+
+    Args:
+        conv_block (nn.Sequential): Sequential of convolutional layers.
+        in_channels (int): Number of input channels of the high-level
+        skip_channels (int): Number of input channels of the low-level
+        high-resolution feature map from encoder.
+        out_channels (int): Number of output channels.
+        num_convs (int): Number of convolutional layers in the conv_block.
+            Default: 2.
+        stride (int): Stride of convolutional layer in conv_block. Default: 1.
+        dilation (int): Dilation rate of convolutional layer in conv_block.
+            Default: 1.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed. Default: False.
+        conv_cfg (dict | None): Config dict for convolution layer.
+            Default: None.
+        norm_cfg (dict | None): Config dict for normalization layer.
+            Default: dict(type='BN').
+        act_cfg (dict | None): Config dict for activation layer in ConvModule.
+            Default: dict(type='ReLU').
+        upsample_cfg (dict): The upsample config of the upsample module in
+            decoder. Default: dict(type='InterpConv'). If the size of
+            high-level feature map is the same as that of skip feature map
+            (low-level feature map from encoder), it does not need upsample the
+            high-level feature map and the upsample_cfg is None.
+        dcn (bool): Use deformable convolution in convolutional layer or not.
+            Default: None.
+        plugins (dict): plugins for convolutional layers. Default: None.
+    """
+
+    def __init__(self,
+                 conv_block,
+                 in_channels,
+                 skip_channels,
+                 out_channels,
+                 num_convs=2,
+                 stride=1,
+                 dilation=1,
+                 with_cp=False,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 upsample_cfg=dict(type='InterpConv'),
+                 dcn=None,
+                 plugins=None):
+        super().__init__()
+        assert dcn is None, 'Not implemented yet.'
+        assert plugins is None, 'Not implemented yet.'
+
+        self.conv_block = conv_block(
+            in_channels=2 * skip_channels,
+            out_channels=out_channels,
+            num_convs=num_convs,
+            stride=stride,
+            dilation=dilation,
+            with_cp=with_cp,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg,
+            dcn=None,
+            plugins=None)
+        if upsample_cfg is not None:
+            self.upsample = build_upsample_layer(
+                cfg=upsample_cfg,
+                in_channels=in_channels,
+                out_channels=skip_channels,
+                with_cp=with_cp,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg)
+        else:
+            self.upsample = ConvModule(
+                in_channels,
+                skip_channels,
+                kernel_size=1,
+                stride=1,
+                padding=0,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg)
+
+    def forward(self, skip, x):
+        """Forward function."""
+
+        x = self.upsample(x)
+        out = torch.cat([skip, x], dim=1)
+        out = self.conv_block(out)
+
+        return out
diff --git a/mmsegmentation/mmseg/models/utils/wrappers.py b/mmsegmentation/mmseg/models/utils/wrappers.py
new file mode 100644
index 0000000..abbd0c0
--- /dev/null
+++ b/mmsegmentation/mmseg/models/utils/wrappers.py
@@ -0,0 +1,51 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+def resize(input,
+           size=None,
+           scale_factor=None,
+           mode='nearest',
+           align_corners=None,
+           warning=True):
+    if warning:
+        if size is not None and align_corners:
+            input_h, input_w = tuple(int(x) for x in input.shape[2:])
+            output_h, output_w = tuple(int(x) for x in size)
+            if output_h > input_h or output_w > output_h:
+                if ((output_h > 1 and output_w > 1 and input_h > 1
+                     and input_w > 1) and (output_h - 1) % (input_h - 1)
+                        and (output_w - 1) % (input_w - 1)):
+                    warnings.warn(
+                        f'When align_corners={align_corners}, '
+                        'the output would more aligned if '
+                        f'input size {(input_h, input_w)} is `x+1` and '
+                        f'out size {(output_h, output_w)} is `nx+1`')
+    return F.interpolate(input, size, scale_factor, mode, align_corners)
+
+
+class Upsample(nn.Module):
+
+    def __init__(self,
+                 size=None,
+                 scale_factor=None,
+                 mode='nearest',
+                 align_corners=None):
+        super().__init__()
+        self.size = size
+        if isinstance(scale_factor, tuple):
+            self.scale_factor = tuple(float(factor) for factor in scale_factor)
+        else:
+            self.scale_factor = float(scale_factor) if scale_factor else None
+        self.mode = mode
+        self.align_corners = align_corners
+
+    def forward(self, x):
+        if not self.size:
+            size = [int(t * self.scale_factor) for t in x.shape[-2:]]
+        else:
+            size = self.size
+        return resize(x, size, None, self.mode, self.align_corners)
diff --git a/mmsegmentation/mmseg/registry/__init__.py b/mmsegmentation/mmseg/registry/__init__.py
new file mode 100644
index 0000000..ee514d1
--- /dev/null
+++ b/mmsegmentation/mmseg/registry/__init__.py
@@ -0,0 +1,15 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .registry import (DATA_SAMPLERS, DATASETS, EVALUATOR, HOOKS, INFERENCERS,
+                       LOG_PROCESSORS, LOOPS, METRICS, MODEL_WRAPPERS, MODELS,
+                       OPTIM_WRAPPER_CONSTRUCTORS, OPTIM_WRAPPERS, OPTIMIZERS,
+                       PARAM_SCHEDULERS, RUNNER_CONSTRUCTORS, RUNNERS,
+                       TASK_UTILS, TRANSFORMS, VISBACKENDS, VISUALIZERS,
+                       WEIGHT_INITIALIZERS)
+
+__all__ = [
+    'HOOKS', 'DATASETS', 'DATA_SAMPLERS', 'TRANSFORMS', 'MODELS',
+    'WEIGHT_INITIALIZERS', 'OPTIMIZERS', 'OPTIM_WRAPPER_CONSTRUCTORS',
+    'TASK_UTILS', 'PARAM_SCHEDULERS', 'METRICS', 'MODEL_WRAPPERS',
+    'VISBACKENDS', 'VISUALIZERS', 'RUNNERS', 'RUNNER_CONSTRUCTORS', 'LOOPS',
+    'EVALUATOR', 'LOG_PROCESSORS', 'OPTIM_WRAPPERS', 'INFERENCERS'
+]
diff --git a/mmsegmentation/mmseg/registry/registry.py b/mmsegmentation/mmseg/registry/registry.py
new file mode 100644
index 0000000..37b6a77
--- /dev/null
+++ b/mmsegmentation/mmseg/registry/registry.py
@@ -0,0 +1,118 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+"""MMSegmentation provides 21 registry nodes to support using modules across
+projects. Each node is a child of the root registry in MMEngine.
+
+More details can be found at
+https://mmengine.readthedocs.io/en/latest/advanced_tutorials/registry.html.
+"""
+
+from mmengine.registry import DATA_SAMPLERS as MMENGINE_DATA_SAMPLERS
+from mmengine.registry import DATASETS as MMENGINE_DATASETS
+from mmengine.registry import EVALUATOR as MMENGINE_EVALUATOR
+from mmengine.registry import HOOKS as MMENGINE_HOOKS
+from mmengine.registry import INFERENCERS as MMENGINE_INFERENCERS
+from mmengine.registry import LOG_PROCESSORS as MMENGINE_LOG_PROCESSORS
+from mmengine.registry import LOOPS as MMENGINE_LOOPS
+from mmengine.registry import METRICS as MMENGINE_METRICS
+from mmengine.registry import MODEL_WRAPPERS as MMENGINE_MODEL_WRAPPERS
+from mmengine.registry import MODELS as MMENGINE_MODELS
+from mmengine.registry import \
+    OPTIM_WRAPPER_CONSTRUCTORS as MMENGINE_OPTIM_WRAPPER_CONSTRUCTORS
+from mmengine.registry import OPTIM_WRAPPERS as MMENGINE_OPTIM_WRAPPERS
+from mmengine.registry import OPTIMIZERS as MMENGINE_OPTIMIZERS
+from mmengine.registry import PARAM_SCHEDULERS as MMENGINE_PARAM_SCHEDULERS
+from mmengine.registry import \
+    RUNNER_CONSTRUCTORS as MMENGINE_RUNNER_CONSTRUCTORS
+from mmengine.registry import RUNNERS as MMENGINE_RUNNERS
+from mmengine.registry import TASK_UTILS as MMENGINE_TASK_UTILS
+from mmengine.registry import TRANSFORMS as MMENGINE_TRANSFORMS
+from mmengine.registry import VISBACKENDS as MMENGINE_VISBACKENDS
+from mmengine.registry import VISUALIZERS as MMENGINE_VISUALIZERS
+from mmengine.registry import \
+    WEIGHT_INITIALIZERS as MMENGINE_WEIGHT_INITIALIZERS
+from mmengine.registry import Registry
+
+# manage all kinds of runners like `EpochBasedRunner` and `IterBasedRunner`
+RUNNERS = Registry('runner', parent=MMENGINE_RUNNERS)
+# manage runner constructors that define how to initialize runners
+RUNNER_CONSTRUCTORS = Registry(
+    'runner constructor', parent=MMENGINE_RUNNER_CONSTRUCTORS)
+# manage all kinds of loops like `EpochBasedTrainLoop`
+LOOPS = Registry('loop', parent=MMENGINE_LOOPS)
+# manage all kinds of hooks like `CheckpointHook`
+HOOKS = Registry(
+    'hook', parent=MMENGINE_HOOKS, locations=['mmseg.engine.hooks'])
+
+# manage data-related modules
+DATASETS = Registry(
+    'dataset', parent=MMENGINE_DATASETS, locations=['mmseg.datasets'])
+DATA_SAMPLERS = Registry('data sampler', parent=MMENGINE_DATA_SAMPLERS)
+TRANSFORMS = Registry(
+    'transform',
+    parent=MMENGINE_TRANSFORMS,
+    locations=['mmseg.datasets.transforms'])
+
+# mangage all kinds of modules inheriting `nn.Module`
+MODELS = Registry('model', parent=MMENGINE_MODELS, locations=['mmseg.models'])
+# mangage all kinds of model wrappers like 'MMDistributedDataParallel'
+MODEL_WRAPPERS = Registry(
+    'model_wrapper',
+    parent=MMENGINE_MODEL_WRAPPERS,
+    locations=['mmseg.models'])
+# mangage all kinds of weight initialization modules like `Uniform`
+WEIGHT_INITIALIZERS = Registry(
+    'weight initializer',
+    parent=MMENGINE_WEIGHT_INITIALIZERS,
+    locations=['mmseg.models'])
+
+# mangage all kinds of optimizers like `SGD` and `Adam`
+OPTIMIZERS = Registry(
+    'optimizer',
+    parent=MMENGINE_OPTIMIZERS,
+    locations=['mmseg.engine.optimizers'])
+# manage optimizer wrapper
+OPTIM_WRAPPERS = Registry(
+    'optim_wrapper',
+    parent=MMENGINE_OPTIM_WRAPPERS,
+    locations=['mmseg.engine.optimizers'])
+# manage constructors that customize the optimization hyperparameters.
+OPTIM_WRAPPER_CONSTRUCTORS = Registry(
+    'optimizer wrapper constructor',
+    parent=MMENGINE_OPTIM_WRAPPER_CONSTRUCTORS,
+    locations=['mmseg.engine.optimizers'])
+# mangage all kinds of parameter schedulers like `MultiStepLR`
+PARAM_SCHEDULERS = Registry(
+    'parameter scheduler',
+    parent=MMENGINE_PARAM_SCHEDULERS,
+    locations=['mmseg.engine.schedulers'])
+
+# manage all kinds of metrics
+METRICS = Registry(
+    'metric', parent=MMENGINE_METRICS, locations=['mmseg.evaluation'])
+# manage evaluator
+EVALUATOR = Registry(
+    'evaluator', parent=MMENGINE_EVALUATOR, locations=['mmseg.evaluation'])
+
+# manage task-specific modules like ohem pixel sampler
+TASK_UTILS = Registry(
+    'task util', parent=MMENGINE_TASK_UTILS, locations=['mmseg.models'])
+
+# manage visualizer
+VISUALIZERS = Registry(
+    'visualizer',
+    parent=MMENGINE_VISUALIZERS,
+    locations=['mmseg.visualization'])
+# manage visualizer backend
+VISBACKENDS = Registry(
+    'vis_backend',
+    parent=MMENGINE_VISBACKENDS,
+    locations=['mmseg.visualization'])
+
+# manage logprocessor
+LOG_PROCESSORS = Registry(
+    'log_processor',
+    parent=MMENGINE_LOG_PROCESSORS,
+    locations=['mmseg.visualization'])
+
+# manage inferencer
+INFERENCERS = Registry('inferencer', parent=MMENGINE_INFERENCERS)
diff --git a/mmsegmentation/mmseg/structures/__init__.py b/mmsegmentation/mmseg/structures/__init__.py
new file mode 100644
index 0000000..63d118d
--- /dev/null
+++ b/mmsegmentation/mmseg/structures/__init__.py
@@ -0,0 +1,8 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .sampler import BasePixelSampler, OHEMPixelSampler, build_pixel_sampler
+from .seg_data_sample import SegDataSample
+
+__all__ = [
+    'SegDataSample', 'BasePixelSampler', 'OHEMPixelSampler',
+    'build_pixel_sampler'
+]
diff --git a/mmsegmentation/mmseg/structures/sampler/__init__.py b/mmsegmentation/mmseg/structures/sampler/__init__.py
new file mode 100644
index 0000000..91d762d
--- /dev/null
+++ b/mmsegmentation/mmseg/structures/sampler/__init__.py
@@ -0,0 +1,6 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .base_pixel_sampler import BasePixelSampler
+from .builder import build_pixel_sampler
+from .ohem_pixel_sampler import OHEMPixelSampler
+
+__all__ = ['build_pixel_sampler', 'BasePixelSampler', 'OHEMPixelSampler']
diff --git a/mmsegmentation/mmseg/structures/sampler/base_pixel_sampler.py b/mmsegmentation/mmseg/structures/sampler/base_pixel_sampler.py
new file mode 100644
index 0000000..03672cd
--- /dev/null
+++ b/mmsegmentation/mmseg/structures/sampler/base_pixel_sampler.py
@@ -0,0 +1,13 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from abc import ABCMeta, abstractmethod
+
+
+class BasePixelSampler(metaclass=ABCMeta):
+    """Base class of pixel sampler."""
+
+    def __init__(self, **kwargs):
+        pass
+
+    @abstractmethod
+    def sample(self, seg_logit, seg_label):
+        """Placeholder for sample function."""
diff --git a/mmsegmentation/mmseg/structures/sampler/builder.py b/mmsegmentation/mmseg/structures/sampler/builder.py
new file mode 100644
index 0000000..48e1479
--- /dev/null
+++ b/mmsegmentation/mmseg/structures/sampler/builder.py
@@ -0,0 +1,14 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+from mmseg.registry import TASK_UTILS
+
+PIXEL_SAMPLERS = TASK_UTILS
+
+
+def build_pixel_sampler(cfg, **default_args):
+    """Build pixel sampler for segmentation map."""
+    warnings.warn(
+        '``build_pixel_sampler`` would be deprecated soon, please use '
+        '``mmseg.registry.TASK_UTILS.build()`` ')
+    return TASK_UTILS.build(cfg, default_args=default_args)
diff --git a/mmsegmentation/mmseg/structures/sampler/ohem_pixel_sampler.py b/mmsegmentation/mmseg/structures/sampler/ohem_pixel_sampler.py
new file mode 100644
index 0000000..a974273
--- /dev/null
+++ b/mmsegmentation/mmseg/structures/sampler/ohem_pixel_sampler.py
@@ -0,0 +1,85 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from .base_pixel_sampler import BasePixelSampler
+from .builder import PIXEL_SAMPLERS
+
+
+@PIXEL_SAMPLERS.register_module()
+class OHEMPixelSampler(BasePixelSampler):
+    """Online Hard Example Mining Sampler for segmentation.
+
+    Args:
+        context (nn.Module): The context of sampler, subclass of
+            :obj:`BaseDecodeHead`.
+        thresh (float, optional): The threshold for hard example selection.
+            Below which, are prediction with low confidence. If not
+            specified, the hard examples will be pixels of top ``min_kept``
+            loss. Default: None.
+        min_kept (int, optional): The minimum number of predictions to keep.
+            Default: 100000.
+    """
+
+    def __init__(self, context, thresh=None, min_kept=100000):
+        super().__init__()
+        self.context = context
+        assert min_kept > 1
+        self.thresh = thresh
+        self.min_kept = min_kept
+
+    def sample(self, seg_logit, seg_label):
+        """Sample pixels that have high loss or with low prediction confidence.
+
+        Args:
+            seg_logit (torch.Tensor): segmentation logits, shape (N, C, H, W)
+            seg_label (torch.Tensor): segmentation label, shape (N, 1, H, W)
+
+        Returns:
+            torch.Tensor: segmentation weight, shape (N, H, W)
+        """
+        with torch.no_grad():
+            assert seg_logit.shape[2:] == seg_label.shape[2:]
+            assert seg_label.shape[1] == 1
+            seg_label = seg_label.squeeze(1).long()
+            batch_kept = self.min_kept * seg_label.size(0)
+            valid_mask = seg_label != self.context.ignore_index
+            seg_weight = seg_logit.new_zeros(size=seg_label.size())
+            valid_seg_weight = seg_weight[valid_mask]
+            if self.thresh is not None:
+                seg_prob = F.softmax(seg_logit, dim=1)
+
+                tmp_seg_label = seg_label.clone().unsqueeze(1)
+                tmp_seg_label[tmp_seg_label == self.context.ignore_index] = 0
+                seg_prob = seg_prob.gather(1, tmp_seg_label).squeeze(1)
+                sort_prob, sort_indices = seg_prob[valid_mask].sort()
+
+                if sort_prob.numel() > 0:
+                    min_threshold = sort_prob[min(batch_kept,
+                                                  sort_prob.numel() - 1)]
+                else:
+                    min_threshold = 0.0
+                threshold = max(min_threshold, self.thresh)
+                valid_seg_weight[seg_prob[valid_mask] < threshold] = 1.
+            else:
+                if not isinstance(self.context.loss_decode, nn.ModuleList):
+                    losses_decode = [self.context.loss_decode]
+                else:
+                    losses_decode = self.context.loss_decode
+                losses = 0.0
+                for loss_module in losses_decode:
+                    losses += loss_module(
+                        seg_logit,
+                        seg_label,
+                        weight=None,
+                        ignore_index=self.context.ignore_index,
+                        reduction_override='none')
+
+                # faster than topk according to https://github.com/pytorch/pytorch/issues/22812  # noqa
+                _, sort_indices = losses[valid_mask].sort(descending=True)
+                valid_seg_weight[sort_indices[:batch_kept]] = 1.
+
+            seg_weight[valid_mask] = valid_seg_weight
+
+            return seg_weight
diff --git a/mmsegmentation/mmseg/structures/seg_data_sample.py b/mmsegmentation/mmseg/structures/seg_data_sample.py
new file mode 100644
index 0000000..ce68b54
--- /dev/null
+++ b/mmsegmentation/mmseg/structures/seg_data_sample.py
@@ -0,0 +1,92 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.structures import BaseDataElement, PixelData
+
+
+class SegDataSample(BaseDataElement):
+    """A data structure interface of MMSegmentation. They are used as
+    interfaces between different components.
+
+    The attributes in ``SegDataSample`` are divided into several parts:
+
+        - ``gt_sem_seg``(PixelData): Ground truth of semantic segmentation.
+        - ``pred_sem_seg``(PixelData): Prediction of semantic segmentation.
+        - ``seg_logits``(PixelData): Predicted logits of semantic segmentation.
+
+    Examples:
+         >>> import torch
+         >>> import numpy as np
+         >>> from mmengine.structures import PixelData
+         >>> from mmseg.structures import SegDataSample
+
+         >>> data_sample = SegDataSample()
+         >>> img_meta = dict(img_shape=(4, 4, 3),
+         ...                 pad_shape=(4, 4, 3))
+         >>> gt_segmentations = PixelData(metainfo=img_meta)
+         >>> gt_segmentations.data = torch.randint(0, 2, (1, 4, 4))
+         >>> data_sample.gt_sem_seg = gt_segmentations
+         >>> assert 'img_shape' in data_sample.gt_sem_seg.metainfo_keys()
+         >>> data_sample.gt_sem_seg.shape
+         (4, 4)
+         >>> print(data_sample)
+        <SegDataSample(
+
+            META INFORMATION
+
+            DATA FIELDS
+            gt_sem_seg: <PixelData(
+
+                    META INFORMATION
+                    img_shape: (4, 4, 3)
+                    pad_shape: (4, 4, 3)
+
+                    DATA FIELDS
+                    data: tensor([[[1, 1, 1, 0],
+                                 [1, 0, 1, 1],
+                                 [1, 1, 1, 1],
+                                 [0, 1, 0, 1]]])
+                ) at 0x1c2b4156460>
+        ) at 0x1c2aae44d60>
+
+        >>> data_sample = SegDataSample()
+        >>> gt_sem_seg_data = dict(sem_seg=torch.rand(1, 4, 4))
+        >>> gt_sem_seg = PixelData(**gt_sem_seg_data)
+        >>> data_sample.gt_sem_seg = gt_sem_seg
+        >>> assert 'gt_sem_seg' in data_sample
+        >>> assert 'sem_seg' in data_sample.gt_sem_seg
+    """
+
+    @property
+    def gt_sem_seg(self) -> PixelData:
+        return self._gt_sem_seg
+
+    @gt_sem_seg.setter
+    def gt_sem_seg(self, value: PixelData) -> None:
+        self.set_field(value, '_gt_sem_seg', dtype=PixelData)
+
+    @gt_sem_seg.deleter
+    def gt_sem_seg(self) -> None:
+        del self._gt_sem_seg
+
+    @property
+    def pred_sem_seg(self) -> PixelData:
+        return self._pred_sem_seg
+
+    @pred_sem_seg.setter
+    def pred_sem_seg(self, value: PixelData) -> None:
+        self.set_field(value, '_pred_sem_seg', dtype=PixelData)
+
+    @pred_sem_seg.deleter
+    def pred_sem_seg(self) -> None:
+        del self._pred_sem_seg
+
+    @property
+    def seg_logits(self) -> PixelData:
+        return self._seg_logits
+
+    @seg_logits.setter
+    def seg_logits(self, value: PixelData) -> None:
+        self.set_field(value, '_seg_logits', dtype=PixelData)
+
+    @seg_logits.deleter
+    def seg_logits(self) -> None:
+        del self._seg_logits
diff --git a/mmsegmentation/mmseg/utils/__init__.py b/mmsegmentation/mmseg/utils/__init__.py
new file mode 100644
index 0000000..8743e78
--- /dev/null
+++ b/mmsegmentation/mmseg/utils/__init__.py
@@ -0,0 +1,72 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# yapf: disable
+from .class_names import (ade_classes, ade_palette, bdd100k_classes,
+                          bdd100k_palette, cityscapes_classes,
+                          cityscapes_palette, cocostuff_classes,
+                          cocostuff_palette, dataset_aliases, get_classes,
+                          get_palette, isaid_classes, isaid_palette,
+                          loveda_classes, loveda_palette, potsdam_classes,
+                          potsdam_palette, stare_classes, stare_palette,
+                          synapse_classes, synapse_palette, vaihingen_classes,
+                          vaihingen_palette, voc_classes, voc_palette, xray_classes, xray_palette)
+# yapf: enable
+from .collect_env import collect_env
+from .get_templates import get_predefined_templates
+from .io import datafrombytes
+from .misc import add_prefix, stack_batch
+from .set_env import register_all_modules
+from .tokenizer import tokenize
+from .typing_utils import (ConfigType, ForwardResults, MultiConfig,
+                           OptConfigType, OptMultiConfig, OptSampleList,
+                           SampleList, TensorDict, TensorList)
+
+# isort: off
+from .mask_classification import MatchMasks, seg_data_to_instance_data
+
+__all__ = [
+    'collect_env',
+    'register_all_modules',
+    'stack_batch',
+    'add_prefix',
+    'ConfigType',
+    'OptConfigType',
+    'MultiConfig',
+    'OptMultiConfig',
+    'SampleList',
+    'OptSampleList',
+    'TensorDict',
+    'TensorList',
+    'ForwardResults',
+    'cityscapes_classes',
+    'ade_classes',
+    'voc_classes',
+    'cocostuff_classes',
+    'loveda_classes',
+    'potsdam_classes',
+    'vaihingen_classes',
+    'isaid_classes',
+    'stare_classes',
+    'cityscapes_palette',
+    'ade_palette',
+    'voc_palette',
+    'cocostuff_palette',
+    'loveda_palette',
+    'potsdam_palette',
+    'vaihingen_palette',
+    'isaid_palette',
+    'stare_palette',
+    'dataset_aliases',
+    'get_classes',
+    'get_palette',
+    'datafrombytes',
+    'synapse_palette',
+    'synapse_classes',
+    'get_predefined_templates',
+    'tokenize',
+    'seg_data_to_instance_data',
+    'MatchMasks',
+    'bdd100k_classes',
+    'bdd100k_palette',
+    'xray_classes',
+    'xray_palette'
+]
diff --git a/mmsegmentation/mmseg/utils/bpe_simple_vocab_16e6.txt.gz b/mmsegmentation/mmseg/utils/bpe_simple_vocab_16e6.txt.gz
new file mode 100644
index 0000000000000000000000000000000000000000..7b5088a527f720063f044eb928eee315f63b2fc0
GIT binary patch
literal 1356917
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%0D-8anuzg!0hrX~L}M*$l~SOpZ7=I+%ag
z{;TkR-}PI&T*J&1{NLS`MmqO}$TR+^q9@1&`u^_hV8JBgETyU>7yvMY2kns>(d;7z
z4gVc<OCIn^Ysi@?z_?3ryYDc<_H9NNf}|PaQF%dm7MbV1e7euEM?w&7V=n0-hMu^-
zj=L_@O5~~*puMRo+B0g-xutb3m#*NW<NiS75p?ZMjjmxnD<ixE#)-yPL)tpwE>IAV
zUyBO(=Tz$aw3z83H4$$Zh>4Xpsd$=};~u&v2HW!^5NJ2(XGdcxNuCup0f`wtI=2Xz
z%WkvHV&w&3pEn7%kbfk;1N}iSpdnLn%g*Apql7Kpc(eRJE$2GzaR>qo^C4*umgW#J
zf^%lU5$w3?xaSgmnX#Vr3}8>v_3mfyE1zz0NT)hWy!@<GWd;?#E)xW|drq21`v!Q2
zJRfq$$PwxUe#6mY%6bVN^iRq7I@7g97Hzc$v81M=_xC-ZN!{>W6VHC76XMbD{M9?t
zCzx5@F0`0|2Z6)1?MM%~>RLVx$=AnnIZaVu!B<Jy<yaBQ6+PA|YKt}btH31vJZBLv
zJIm5%n3pr=_6{(!4Rbx%CIbJj)Rakr`%(HMVTN>B^9^{`SKoyA(ugr&29Uo+K%IAJ
zDl}+QCB>OW=sV<c8(NE&^7Xged!~o>qG*nNf2o>Gw6l!~Hy8K;SukIP!~p5kT|ThW
z8_3CaQ$EOKCiMICkg8Ap$vUQo=M88$i!=#RMc9+Y62`oxChA2)hsOm?;!|~$?h8<X
zR@%`!RWdT51i6gC6S~|q|ByM;lwRm)r%3v=FIMNAxi-%o^%=LKrU4!`?oSf~6BuUg
zNB`1_7Ku$wnaCFNb#>GtWd`lYvhehQ-hs}S#Ds$iCA1WsdH^PFppT*=Jrt(UydpE#
z9}14e<=+vY(}Ee;x`|x~HLij-pbwn*Cm<ly;x<rsP3^rvvv7Yu{r1^vxQfUy%odf$
zXR;PZ;&^cArXndsnaRELI9d2j_vaqTec(w7<1b<^><OMUEy%5ydT2S~!n1Z9RX0&k
z7zt;kdbY9f34V$%t=Cr#(=I{MrYTF%In!&Rtmr7+mNxWQ@`=i`d$pp=9#0@VPQ)sg
ze8#V<kN-v|hlZLK=}KN8c4_ayE7#L^SEG*!y>zt9ua@8^MkWN|r&xEDxUx4B{Zs|=
z*Bjrq=xIY!^HD$HChEy^E5S+H4wVO`82gwzDM+<RddEIZ8&*SZH0?LcZH%L1`$SLq
z9mQR|Bt&}$-5sdT-SUn3DTfgky=|#Oa+-^QGn$x^cSK|9QbQ`#5gs2t|M&&ic_bHS
zJ6DVLKIhzFA|lAr<qh2(T(hXi_pKtU&(|cTXBR-S8(2jIN@&%Gnxk-c4Qk&eU8kNO
zukqLR@YBsk@(S5}l)4gzt3!n4Z~ebYUmVWQajIFk2yDcYY88YMJC=6R*_aNfxD+V!
zFcOUf3xvtgoBW5NKO}+V%vSLp{R^_%PVO=MJw$`WHU(CeGVvQZt7w(JacR=B>ieqi
zwG#y0A<8geGYV+N=2PqO=!;;0N2Id72k}biy&S2Iv&AVp!WmxGkR1ZWM9eEmMA`fl
zep!7?jrpm*_vNRiTM%~F%N+dS&(mG$Pqxd69fk`a(z&o{ywO<Lu8_5)p5(Ao49c@3
z`|Nib!gGwPUxQFo9{0FjrWZ$q<&m}l_rA*0njLx@t4!xnlL{i73;e`6wkNQ|R}&z7
zzgVzKQrJU5S-W`Grm7hl<5oYlRm@s2yLwQ@F<sTM+FN@llNV>ua*s};pRJJ^C#tEh
zyKB0P3p@htIZj2S87ThoQeD|%mnR}Eif%KH7NC1ij;DNhi*B5w5^ekF+xa|?w?q~M
zNEXx69&2dgWctR<(TNL41LzNu27{|a^7PU@!txcYCR_G3hpH-yqdI<5B_k7z91b)`
z2xxxzF{Y@PnslQDLMzXrRA;|+cmvCSp}Lz(h@|=bnMO`Yy0@BDzKoy(xb7?PUi|8^
zj{yujA!U2@olm82HG3$xRVayXS-AFu<?K&<D)aIUmPCK*T^ktUUD<=D`3FaVo~>ts
zV(whG5Z8)*hRdf9s4tH{ss83~)2~)jy0lH)0;|?<E>;Ou2P;hda>g;FM^_S*J!l2T
zabstHT&L<NEOjcF+x}4ZF)?NQO=vfdL-R2s2-9bPX!OWL^$wPSNZ!yLrJf!1Y?=U8
zVkk$g&N}O8S%C*pr4<gXB5ffU2&}TzSp{qjh+tbljarIROb4V09M7Zp@xTf0jIW8B
zO?lfuqpgW_I6&BpGqp3+Kb8X;#xsxm`vKn1qUh9aLFdH=Jow)KHd2FoFHZJ(&*=u0
zFY<JDrUb7yWYG0db8;_6c_{bq7`ar`!x*b$9Km-`G1fO2&a_K#vIR6-)#yoI+!IYD
z7@ZQlu!sW1L`OGI%w>B-v|5fMK;zlzW#y5bjBrns^M%rowE~Ii%){Q&;b$}C>Do!^
z#~*(2@fU!6V&?rIRwJsWE<eGSI32k64jf2PO1g`PkxVafN(Xm};y6K4UVMh8o?C-K
zS?vXc#i_H#cVXWQ+o5b5HmPVOFlU()9`hnmdCJ2;VfKlxkT+#D3TK<3*9h(o$Z9c5
zM}WeL@M4J=g2?F=z_FsO6o6Ydi$#`Nv26<XPe71_(nTGM<~V1oWeRZ<-}9WH4t@$0
zC@}!$H!#1`(!hC1Gl8HL0du1V#E#v6@cV~8Q{X8F5KdRvnnu^RALbRK{M3?)$rBLh
z;kdC-{p;S*El=ljvKJOgp^Gz*KurBu7qiM0$FI+p=!jj}8w*}{^<l<(t9CVbdTbo9
zOjVz*zLx*IQZJHSKD*h1iPbH>(J2pVa(1_8leddbyXC=SebESHw*M;GT@#{wxS`u^
zN1%^{YJ!1%$z%o?n*N1)(P~Hct!NHjXrE5SswUbW>j?F6l%$u0p@mh}NM@PUc`6kE
zsRpKO){5&Vcst8Q76aOwI%qV*a}4=4>y3G>?uP-~lL+RekYW0n#U4Q=EI91ccor+$
zv4RLK7lE|e+#|oGJP3vFjvU4k$}75^2LRT*bEX=g8-k*Fk$B%R2=g#s@}4C=Eo>6e
zcAR#30MF2^&q9a9_oZNogxpWaE>8M}IF`C;@VM1*q(@QJsJ(H*RriC{W?`R(xv@8b
zj#ZL^6p@_v5%!vtzKKyrgL6oSHPVh2CFls)tV`>hr<~g{Wtui`NJl1e#zM1YzG|jP
z#|#N+cW29xN&*1ypZ{a>KgWnW3Z7u#SteXd#m5ICfVJL|&`gu<T5cFgpD~Kjw9sA^
zn|;-ei+C`CLX;0On5)E<l|mVyw}%YU9Ih9ZEjGv`d}Upp)$S;iKI;a_BH~v;Mb-;J
zv&hcI>{Ye}*wBykkf4OGp=x+Ec@vsTqw6D*24v8_OKRw6NZ9QcSkS44*t27~-Lzz;
zp}M`kM>h+gS9>>m*8W-0@KLvK>+f&$?EwjmLi^hh#E$za1Z>^D?8qv@?tZCWc9nGa
zhpX*?v2@S8C5MR|R;%duJj?UVV|M$5gN!ei1xGG`Bdx+b?0+pagW^>omwH4mHpS36
z4?(Y;D1obz48VxWBN~8iHY%Rvp=DFSTtc6EP>=dN5Cs#Q#VIi}8uEDe)h!+$Ai1GV
z&2YO16L<hVJ(KzD{ZB=(sV=o++&Gp<TSS0r+8=u?zl0X-F}Nmn&fSVFV;Ry<s*hiO
z_&L%M#WmY`E2gydbhh<&vM@#y6c1B#QyTsNrP~oWwQk`B2N`y$Wlq~=x8JV4BhnQN
zJBt@qO83_;WExk`?m8^3n`FFr0%OcHf@b81%*)KdqxzzZ@`86Rg8Ysh6`j<a`S_y>
z>GNTWrsC2SV;70K=A59y`qi6o$YcTip4IA(uo-|+g9L-bKc7JaOcxAkvyKBWfxDVQ
zDCuIGy7eXeN^7PhNi98{U;Crv$U{zw-};u<pY?(}AB2}}4d?M)nzewJ9nM+gy{q2!
z0I!$IX9$Od-dUorD{tTCQ&o&ZPT??SfyDCVs87%EEI<kAH&czup;|Z_NYz7ipL@|j
zaonENkV|Ys?h;sQ!Vm$rmcB}>KYkChtHS2ytLptP%f0me=i0ofS!J8tYC75OH86OW
zJ|Lifog#N1mXZAc>Ct5JsHrF5z}>B2;Q%cwAjC*J_9_{79MGvQkhzl}%M|ce()jRC
zN1oPtOC|C(^}?Ti#(@tTJ?UhJb#dNmy|U^FKauB3)O&Pbw^zvDs_cLl8WfoA#i1y=
zs=!#t!GM%i9ez}H#^y`j5qqm+x-a%bpO#n8-PBj_k~H(uvBC*yq~jako<8h^C<AB*
z5(mHG>xWi#y(G&5D&+Qvb7(pvj0GK}sc)Fv7jPrn4!=z)q+4G2zO+n#12k@n_A_mZ
z0DT;z(nr6-g8b8$R5Qewh=QVUS~=7^8DSDabJ2K$vV6$(vSZN(DdG~W6oE{Bll_cW
zooLQfo@e5;l!H8|M4eIEqLKgTP`}b-v$sGD)y3)TlghPBp4c^^t4KMBv27aG+ni!n
zkFL|$hjI!x%cyahBrkxD$l?JS0!jpXO01n}jG|?Qu6^34Nb2D=qfn&l{wF<(c?%<q
zm5p;2c0Htsf`l;Jo&nIy-vA3sd04N(nTxLmmw{ro&9Zlqk!)dIxd&!A=PNJ$7{hVY
zvOoh$e$oD-Q0ZH!?x@UnNs|=6$=T1qI}GX6P{9G}V-)nsK+$b>&?=A(1-v|Yle?S>
z4TX#g+Es0g3{(F-jMvA)+;EF}oz%SS)-K(UD-dB=8ExFQPj@7R6IQWi20J@DxC=Ka
zmOui1=rJ^7u5uF9*y%jJ%d3}!k#Z(@!*c_~2nV+%6$zz9_i%+Lhoz7w_B(SUoV?+<
zn6|~h@a>WP*Rub7r;<uCLWTIw!fyD=w)TuO@M;kp5=SAwLMt|39c)+mlg0>0&ly(s
z^*s^S{r8SNjE%%KIkKyY2F8YCT6*GE(t4nFabrqGJrgY~);m2|9^%Vo!-o(505546
z0-S=nPxnBN92c+|ZfLWgB`=?Av?jo*oXD14&Anh|0_xwU9PvUa8+F*AwI^MbBy7`V
za#;$uaA|%cS_UpYG!1cWz7vq5Z&W~=n~wcNFJnNc42b8MMQ4z@SLnPQ>RX|`k>-lN
z;*VU6*p{~*-E|7@`hJ)JXzCMn*B;4JPSYfaRYdgoBYiVCwY7HB;oO3}sC&iH1T<mQ
zqB{*wqS6|grouQuxjiHuL0;VK#MqKal3m#C5-V|?2VXC21|Mtnsi$aAlnqx%`o%&2
z8@fHf_Bl8k`PU%!ub`*q-M!n`s$oVZ%Sf=Onb%dxZnHl}stL5%)Q@Z$Pf0hqU3}1c
zN<AN+nL>uoX;1T#_4<)c@y@Wry~I>o^Pc)ypg~fjSoFi9<s5yS>;uagrXRU&2rge$
z(Xa#V%s#vjupWA<cD`tZ;S|r0|5$JADl6^np#TxP0%PQ8G*H+Z`B<sb|63htCp&f}
zt9r%_*PH;jj?#(f<IgL7p+EgOO>FpNXo&LXWU260Riyg(v-I-w4F^F&=?WK0;|Xf#
zm1X!mwe!G|!Vj%=fe1@s=$qIxbUyOCH2`tx1F~OeV)hGvy=5s~;gE1m7z%lEwPdU|
zbWPEHzhtH;QuY51#Yv0Ck89=Vr#!N2cBpWvdSnSeou>53?f6s<ofwi+r};g+Fr-+p
zfYj`L+Nr2U2M&HLk~A08X8rj9{G7CY?Va50MVg$or`32P-A%NOccG5ZKhbe9F{t81
z{6qEemz1?#oO7vy;C8XQ3Nf!RTeZ-ikz5QGRfzOH=mUd}p{FIlfFThG`BoHHa#;;S
z`W;7v|HebwTTjd;Q?LP>K`qM~kTM8I<*@|u##oRl=zMe${2_b1exEx^`c0}5&wHdv
zmM+ly8p_zN%k8@xKNCAB&FDd`gS+agu?#F2fy1I|flHb!aHPak0AwV`yW7F%9|i6w
ze>hyHK5S@_U`^1?kY3yoko!c{O|MAQoB#UXSFSZgwTqn51u*&?GoY+d56Dv8u)xwL
zmP9jsoz_!zwk$0qv@CBrs+EDM;KNJIB+ZBqbWa|49-%PIxn^D)Y);CF5K}y_xjEF;
zzQ8#LVgHDjyZ=5(wHg0ox40oyPu$4JeQc9$a{Psy*sT(_f!H$mvUsqXGRNFCnF!bn
zEEJ=8GXBWy_!n*1^Py$h{*bXFa_Ezn{FqBP42pGD)+<?(;j|afLkQ{DCk~1g5tjNW
zXRulLU3gA@x_6p5Vw_c<yTfaiRU}q^k}c&50S2-Gg$KeD8KC{TJ*m0Y2PL<A$H{o1
z$svLYG4eZ&viGH+&0n4^@`^5^lPHfLKL6wQK7OA5zbe0>;7Pis4}bUm57mdiJG|I3
zInl{kfoyg9fUT(00*4Q3-oizCs{5d0CV=2B7K%6&I=w0-f}9ofxdnzf;J610c*QgK
z!&dzvjMUMk%EP>B-+a!4XfjF3BuIipsj{oI2*Yd3^%5AHp~O(N5(ERw%@R(Gtu&21
z#{t|v5k#!MCU-?y0CiD_5GzcaqFYW0Z4gB-b7Y<;znf5+#`G#5@pU_9<^kM6FTHOp
zwDN^<fR~|U*8pwwe75z0!rB2o%FT1HO6h^VKoB2g)#=c;w5V^A+(M!5)0;V!Hnk#Y
zyBFiS6GSRP;)lWu>FYbu6yn>a8SN}AI`-6#9}ks$J2DuupygpZCW!MZprbM18Y!d$
zCEz2)7_*yPp}D(s7iccPpK2=_>6THfdZZQ;w#!Z(Imf0!f*Fky^gQIXk&xyp$ClY{
z@KJ#QLc{G7R@m5xVJ>JJ&MkFn2;X=fkvz`(7=h=$Hw9oVqWMw^E3+}!0X#m}?1-|)
zxY`am9UB9T+c9<w_s||*@t~hQ51&+jnRXpo-&Rlo!2<Qi&!PVK+XR2gz6p?qeE5ri
zA=xBTs5cmlBPv%+9jq3ENX0vd@s3&M8eGAzAt%>w_5ge7NoD{a9V{%fu~X)r>-S@B
zm#m^4HYjAH>(@{^K(B(~;}dSVc|xaq{D9$KKi;qpeO15}FLgpiiB0%R&Xn9K^}`n*
ze+={nS`uwf=&Kdy>>3D{8HxipC}9j@*EE&5wqIK|>Z=_6*%lByG_TG9q>^ZFDCwmS
zxZ`ZeWZR}|_e^PhTJ0C3c6=?JV3=~vNqP$N+)e^BS-U+fCtM!@qmtLI4#@}(Afj3T
zMndzlp}K~HEM%dz20#1^6GprM62n_}`0jVBzwux}D;z&@KK`zH|Ifa?;MD2CzmCIs
z+l!7H5mA!@=#Es)bKE*7Z89_R$APjPbTcaigE3||=N70OLel&`+|=5wccuIvK70Q~
z75%dSgM%^|a{zdMU!1LQ!x+c4&NI@?PAB@C)DQw`yP0-wf}Uw`GrV59OicDBrWF8S
zK%c)Zwfve>`4LVbYeKnZ1G4iJD<ASgK;JeYAh-Zl)?|C(TPX*<hecpVq|vDRq-Wkl
zpK;14lovYgf<tA2Z@q}a)2FeCKY)#D<x+)K)67EAQ1|MD-%&bI3fYf!d%X*r+?J@-
zBk@$BLloMlIPV*V%Hodwrh5OQL+!4d9AZxyme^0HAvuC5NjO*2Ol+9UKHp&umnm9J
zf5$<gzGwZCKgzw<%y+OjGuGFv+Z^Hzqa>r|+`>;I!c}{7Q7$`zQ5*uWjr8_qKVAVp
zqX8jIMB<#T=_Vsl|1ae&|E2G*pJ4=uabJrvIrGtuWOU=Sw3BNNfvD7auNR{IFb+lf
z&5}T(iPZ%SsO^48K*Yl?WuqeqG)o8Fl&A|Z80pejpwD)$ZOkZA8KI@JsV+D|2BX6(
zUTP^mu+Q(&za}yaMZq=BvwM%SE@e1jcxNGVnC%H!W_GUqn4xzKzxr<VCkdk3lIZKv
zQ<zRcTR8JqNk?VSfLUDy1~^qsdeZ0EDTLXNbG~!;q%+pNgDiqtES98b;$WNA_6lT;
zYgyoc%CH==^YLGPyZTd)D7JxT?><oFKK;DgLVED}KcT|<vL}%cNh~i&g`71fSI<X}
z(H|#c9`>p~elPt9nx>)0pWta8Z>T8M=t4L?6alGl2*@-@HQ@niBv>kQ(6QQ-ceAxx
zG}Cb$MPF$c>SJ+BYZ5n!Qt*#)yV%L_`dT6N0ueNahTm2nf9z+CKWW<Gz}U9ATE>x+
zF7*n&@MYaxi`h)#(1ldAMcO(39@DuH=P4O_uY{9__QDuy5;>d=&#ZlF$LS@^idN9q
zWrzZFIqjyq&0=+;s4Y4YA)oAFGGhDM1nGRKU-j_dIK@VgMx+oW2di)Dp~&Dy5WvI#
z3h5muN*SkWS(8J1I84K_*l(JVUIVY5I_&m5<Jr>(?*O1)y5t=S6Gwac>z;=o$u?tO
z`>4L_V+*{$^L9|OiO3B|!Ls``FF>`x?IWP3u)o^gmR?P%nr!L4AD)8)ZT{@fsz3X)
z<PG`pcakRI`4>d#KIb{lE(*1V9V@Q|uG0>dx5ar3rhQHcX`k%^5DP%$bygN2b#Q4Y
zsayzH{dx80_GTFugnxeZ>)tBj`(ZZD>QW!>RdX!r%pVVcGrBbZJX9wnRNg`r1D&FQ
z@o-TzoRPEdz_040KZ6HfxA)SMeyEx}(K|~IxIYn#C{DvbTMEs@@q{>2QH9;5p*yUo
z{5~f3CK3QG>n((gOOQ`ac3EhtxB1B@)hC~PqIKxGvS35~;kH(R;{vi){qHSS-}cNY
zHE!69xRx|CkGd6_@nfaIkSnwU(2H@g2*Q7($hR!=`%>N6A#AdPOk4MU^k@4+@Aq8z
zz2`zV+@~z_4tNyMQ5MbYtbmM}lvsw0Ely(S-kcG-cgtRZAZYadP2YyW;)+pipo!Dq
zbtocF7ZDn1m9$q!g>F0h=6mXA3O0)o2yhG)eU;STy%uQFQx5_sQt^$LXz3o%)#OOP
z=cF0nIeZ;5iy2nyqMjXh4WoyyW}!i~(z7VOKu$In+JO~nb0ZYJEU)p2>=t$cRv*?G
zC_@T^-`;`<zCg1ltP7K`Iql0cq7B*KtR9FXnS^`<7;m9T=ite)9m;QfeZG{h&zF8w
zD#2JOH!Y8lmvTUYZ9I=f75T64-7U(#@XL(B{mnAZn_5cKTs`s_3|d0rg$4WQm7P<O
zCS35M(?q4dX8dvs8?Ru4?JWdKZ3T7JtC!OM4^;Ipvpr`4+$ra|)H#uW-4$Sn@VCKG
zJ^4>*MWVai6Al^n8w*+(aOaT}2<f-d9k}e#L=KiC3;EQAh#-i*MjK!_$|JXy8Rh=e
zO4S=W0i-REDl^eA*6T9}2`g==LX}UD7N8u^u~Pw-vNF$`FSR_!;gVUes|FG=`mr0m
zUg{?RBw+qknx>=3oX`xsy0~ni&WilnPTw`l0wQv2va-;zh2l~C{-wGKYj?{7rv-->
z_KMgP7bHg^xjx(Kxkr@^^uyLvBTJi$7nSgOTRTEAW*OSDjb??&+DMEWV*DO$6daqP
z$(=zE+pK}~#H=~Na#mtj+MofkMX!p^o)r`<24NASp0z{X;eqoUcH@9wrmW7N4U7RA
z85}|j_t4#XaMlFw*t56f2ocVwLf1G-o&`g;zo`B!T|uh22HFFqe^0K?Z6{aTpUTZP
z&0%53^{V3!Y9@*^81+ojel7tDXVy#brO@G)bX-th%sEIDmT><w{oYb0vF8hCMz-cM
zLtB1edLFi%PP%uH7VsW%V^0&9ClwN%$gX4w_a2=0+`|TeGON4U;-Rg=&@M4_d=g3R
z`?(IZD-4;!K5EViji{;?p4QM1iE|P*ulHH5##bgJr#j7prQn1<M2J+tfYX*UeK!la
zkG^DD1%=>JEWC$Gc_%bQg)@XO=dtdt)#d4Mbfn{vZGp-xle{m$TmSM<HxQ*4%0iNp
z7>&mq0Y$fM2pnWH@%)ONfP}yLk%|3a;m?cXX2)R_`YCJZ3cK`B9EFzL^#lxV+WzRn
z&)VhPfTBUJ!_K94y{jf(bd%rVF?i=^+W9O+Tx|j%L_I(+!$9LA`g#GhL=Ph!qz4!>
zN`566NUrF!7S=OetE7HIEzwgW?-^~F5ny6vchX0$r!Y0P#gmw#%YJj+^jLU{_rpMM
zA5rw3s+T?T>7kRZ6~?cD*!t3c1xDoh^uTv{6&z8>3Xe5`tRO0v{_b1$Uxokk8+!C1
zECgqf2+a|2ap8-`u9oi!+y&I1i?F}RwJrPfB`iQ7HHkH>L%vrS(yCoqhbZ$C^pI>?
z+GR7RjvVTBU$D#lx%?L&M>J^Tsn>}V^6VRfZ~`^LXEI%ZE;&$xFZ$t?ot+q@QBR=W
zhw!0A(*koCb&hZolPZ&kGzm6ZZh^U63Bj=?{0Dz7v;0XeaE9$dmm5sg#}iL2-33bp
zpgEuz7o&Vyh2@xmsa|RsA!<gKj!1|d(_CPF<O4{>K4cABH(C*rp2;idvAz0+8TtJv
zr;(3Pu1plWj^m9dVxWJneXYjEqgS1wR1#qGy+eESz>QKoWdv@`ZteQ%jx0~(Kgo?U
zH`ySZw5go~8948vOoiCo&<5~VNV*ksrfV`APS~`cB3oGMo4*jEg!0ZhBc1CBg8~dV
zs-(qfIV5;T{!H(%T>)KN$7gqftcduLc(Az|f(n=Ni3!%nyLTQSso?4=^>!Je_ecWD
z!BQejvLL|VIa9mydH9{2=0|lBrlwO)jyCkuk}yRs48ahws503HG`O*Cv1{c$ZTGtO
z#T_}uD$``({`Oc--rR=-vJ&rssKUY<>I@N>wm+RHEWh=K!qf5G&4rE+%KgA^a*8Xc
z^<Vu}^;dsIB(NYV1P6MHs$R)VN4TA#PQOC|A}tx@|8NeuKshvK6o7|W1>Z`t=0>fa
z=%DmK6`%K>sv|2+L^<e@_F|o6?oXLXk5GTp=G!iZWp2Y02^zm4LvKYyqP4>&Q0FlQ
zsv4TqB>BzuBj=f-Ln3m3(kAh+>{$|^W3^&xX7Q{Ng}WJVrFdGmLaQ`5N`1DAfwl2?
zBw1l|<?e)lQ?qhvXiTs6j!d;$B6C1+utgIV?OUmQ{NZz$6D2XO2|V9bf9)RCaCS<b
z3LuOIffT327O})aR_uoJSz1Yy*@B!59*fXZ?5n45-v7!EffLSX{~eU>ltS=cdEpuS
zTg;Ois=CFoML37WBTGpA&ddt>7)a+9HOW~rgs8Jy_Nlh>omw>>nDTUPtwS6fls37<
zKcjL@`t}Ll2vov2x=dH`zLGNfeW=NGvFg+3g-e(>Y>`p;6Bx40Jc|a+7?)D<`3WJE
zl1{ZxTh^hWIoX1+yM{#KX^6(`*cXE-5V~~TAP%HRSGBZ9#{TfY3$eP34un2mt;Q$-
ze}s+v?4%>IO{!^^JC|n+4a?)s@9Qhtk1ZxVmM*kV?e&lIm*1(rlgt@$5W)fYs{SUW
z6$Gc<sy2ny^Uk^oZbste^y<IwsbO^KP(RwXrLT@8{cb_hzCy0&xKNtR=b$yrcNR^l
zx|rWL8VX&XA%<Xu$c0>9i909HNF*k{O2Lly5P2(@yDP*lp){<?>cF+NV%%2e@%+7}
z(H#ZuC;};0AFFev!HZ^i)ml`8c=N&~E_);dv5=bwK!}hD&sc03%SPLqP5$DGmWACC
z6de2-qO`vFsCqQ06P<)<J+MKGTg@;g5TP1pn-8HZxEeu~9l`|Bxz?USB@WSfFR`OX
z-OOenG{Ae|Y~TgvJ;Pl)l~GNXk{M|313>P>sJeRT*d^JXIV$L=K*3vX?Sib3B&m;<
z0kBknHPyxM9l*Qj@p&W#9@myc!FaysX1GNy*p&;gQV4jrbfxqAa8k`Ut>o<|0gv={
zFVzv<K`{5FS_@@7NTm=>7L?frvdLp@|Ag#G7yCk&&S$Cs!yK5X+@ed0$&^o?xbPgK
zM$-+1@bGoT;eYJT{gfR(KrBeD_Iu^tP%v~z;i8QOZ+#~Vt)*MhmIz&2!Q<_-Fu+CU
z{H1Hp;9~@2&~j38lj1~Ppg|khHTzgm*YLzDJE{~t{`}*=z5hXabb4EG->Y|4S2KA`
z;inH%3`*wuRPs0%I`s<>;x&3<Z9a^SczS-St0Lso<n8A10A^3t`77E)FP0P5+6T^I
z!0n%U8Ln>Hdm}4`LZQcQ#8Hrr-EUxb17b_X>i6vgpsRRPF)rPPeS5)7&9k#n1ZntT
z^|~b<+)tQv*pl3XAx&Al@!z$i{@|aJaekp@QZMLr!khjZ%d#NKSCeDo(fj5f{1?jQ
z-_UT|vi7LG?5iqrG?wDAP#)WMrEQpHmJKEPL#KFj7@a4(F_rf-5tFqxN7aK@qk|fJ
zKFW{6Ufmy)k_k%>_3UXrT!MjqBSFA(9cGTWPle|edZ3cH4tweJ43;sYB#(5;k*YLa
z9K)pB3zYrzF&1SGoh^fjT^Z4+;Gp~P!!DdhQ#U0><b9&z`V~JdwL`lI&mRiQ{?NYo
z_~So*uS$PFa)NXJbRlzLB-lh=JPEi3b-0r{Yst2LIxL&Ff{EtvwUnIBRm4U=@TwVi
zH>zBlcoO?*S(l3g9u(P!=8Qb%kUjVw5U|HcY(;u8g2G`ZYM%^<?0`n$8-Vx4N_)$(
z0g4>K`qCtMlY2byz#BU4fR7cXIeK#Na;rz@y3CJgFOvFI`SFqdCdKU{JES~k#93lO
zGc9C7114cq{ICKE)z2F0=N1B-U%&TlX<rE93#=<al)kZ{o>qZi>Ua7!Unv<eYAE^-
z?|&dNd6s0*P#k&8E}*tO?LNCJ;$=f7x^9x2KrVQ!kd*YkW&<yC_2M~IgN#Su6Njrf
z<t8aNZL@Dcx-j?fnppJ|obWXT{NJ(^%LigsQQzlcjC2mo)|q<ih%8ss+){CB=v|?6
zYC^lgv%=><l!5eix^Ar`t{KhIvA%?B2Z({uIY(us;vX$yi}YwxzvNWu$S8fbeCq`9
zj5^bZ&x2-UwjFcZXs7=KD#j_-IB?j7V^Qh0A|bF#>Hk`IlcA4*DO7d>c@~p=SRq=n
zMLuLq?byUWC&@>>3{{$>I8aFA$XmjH>|3D#<51f7ze}GY)2Zo)o<nnztt#+DZI#*W
z&EhT^2kLM8M613_&K{(1Dbu_L4CXWsS9E4Nj`I70)i`eA;oDAo5~99hNU0uP5dz39
zjj?o<rq1b}s1v$m4G?s@^r)dl?w9%uCklIn$7jLAvG=!&!yk6qwH+Z=@_SyxM;Smz
zK^jITN?tW2)fYW^?65X@530x2$2&v9z7i<fG7iOf`|O;65`Bz@aqbsoaV9_1BGn99
z87ie@Hx$sGTeb6OJlrH>cSEnrkxNU5IwEs1J6IcKkGfRg=vdvA!9u`ss}CRku6qAl
z4d;Fqex&Js<00w;BE)jkL+!#*2?2W0xWW!?bm<SKL27!Nl0d-)+AJU%wQrX452+^9
zuv%rPcTigsb0#aHCYXyn<SN{1GoR{S^3X&5uE-PKf2B$UQ%Fe8s{Dld&#(nbv<pMt
zWeZi+wog)(s%{?~6k`Wpp(%@!6kW<rMLraUGe36iX=%B#(f8>N$3(&BQH?>1M<<I9
zyjQ$CSkKb>Te`#-yRlowR@6fYRm0R+<hr2`v*`^Za-K4dY{DsdfZjcB9DCrw$%nRp
zuQ>qdG3`}@_}b@gV?Uj`swtH*k{;}55-w<<X?Oi*80~aM)#0r2?_Jd0DI%?!UE@%c
zZ)3dPP{QU{UFum;{y$g$CH>Q^0ZU4tKhF!y^826V?|v&?C@$XcQtF;FQNoMt)xdBL
z;VEq0d)}_>v~QGeKw+F#*#+2IQnWKBo0@`ppwMsdV)3<l)hM!qYmABxyV_gnQ`jlI
zY(lp}#nU5J0x^WPpq)7Th^~>9Z6AJAef&KKXU`SLYxm3s%4?{@^^a)6oJG})Qb$n(
z|6ju1ZAX&qx)OZ%uP|zamZ%xF-qk{@f22W}o0+>=xZTPw?&0wupvnFK=}kRPQjtYc
zB1KZXv`AKo1TvHVHG8eI*FF|C7>oq4va&KG!p+Xv*L87OVNXmL>o)tM__=|}DK&|1
z_?kc`_H+Oz!DkB|!s(`A*X4w{vWC%*PKkYJ>;*=w<axRleU&9DXKX2?@sy&$a4m-S
znAo&(1TRU<R67cv6bAS^Z+2-%b`4r;{%40FkF<W+;b-MS0%X!=>8TcwdH}b}>nW?S
z48V1JKg!y}i#fW{575iw!Y0rHYuLA2<8|(I)RNbWo*(2(?4Akk(pwF__T@p?5X$ga
ztVtTg{b-WQ*r;#z@M;i!vcrAg?hvL{t8W#e-lUk4<d;@iSCZ-GKqa8@1ozH+6#Cte
z{L?aWIAj3$3hQ37Ro6v|81T25@V(|xX`wxr%8A>~Wq+cijuWP-Rzz8Odhw>J^B?ZY
zmbC0=XkaxW8IQ33>B%RhxZ|v9u@}iwfgy<qY%wTDQ5}1KphlZAt9RNDeWeMfoVRaQ
z*LztG!a$85!jp0l{!m=0zIEES*)#E@V}TRYPX8cQ(YWA&Pr8!$+hSGJvQT#}bP9K0
zX(xxLIO<=1_^0H*`cIY@zvf`{0^a-3xr0I0HT947S49%uPM?z+=BTs#P;w_U7522w
z<`|Y($!}DtP(T@rF&mHi^b6t2)vf}V-X4mCDh6CvIWCqfZJq3=jp;)Yk|5$qNc(1k
zM5!p>a|h?!gC)>A93ebMCg(GCVk(p&+rt4w6fKnYQq6w^jOPM>3ZMoc5~Jr)Ni+80
z|75jbjbgazyEmTE7RY5!<lg2U*79Fj>cY^;4H;JZp%*3k7Sf7NoRP<wJ?|6ESQU+K
zf&)_R(+}akWD(jaI6Y8mv$ht>(s}QZ{&Gg2VgvwnEg+Kxw79Ed-2e#D7PX5pgf(3H
zOi52$Y6sd@TV=e?pwnqFQ(G6(c>{JoXny@%*_!NlX`BQmRpGMOHcLsgQxPxg(X1G#
z9zdK2FQt2IwrPjl1hOz3=&}IPi>L_5WblH@CYe>U5Gbv1T3BkZ+Ub#p=y!Yb>jQWL
zbSR2X#S1E*VSu<{%#^#NV=&KIl)i<V2TQtv^W~)BoxaGDq_iBbijnTcU$4Eq`Du;u
z{Tx@x?TDu>_D!5L`8CQ~oA$lZB#rZxvQK&$H(Z!ftnK#*F;3>uuQZwHgPcMW2H8S@
z+mRkoqnFr2ooa`0<A6{VdA_Mb*})Dl^e^n+C3^#Ggk_n#J;^=uYCxdvd4U^DtzB}<
zVwiY^#4?wD<zPvsDjI?&4?&@4{%caDvUhj6G?5h&)97-sr$+HG6+YDWhtEr;Q-<&4
zR-IV}2}6H-Av-qV2f^_SZd<Y9Q!jC``&c2kx3Ctb$bVxu7*|zOJj@hB0tFSmll$Hd
zmdsBn4kkU@7=FByreq&o>nTRLJ7Jli*6)6p9zrzK*PSEehTmaXYd|_O{Q_b$O(o9&
zy8s;p<h&XGMv<l&7ib|{YYDfHLC=sm%FmYsBpb>axhzL<E}>8WBuSRiMDJu7N-D5b
z-(fr%yBv!K-cMVdCrMN!+7Uh}eW>L_W8&-TQ%RWcbRPV}cO&O(dYh93Py4O`L~YcM
z1jEH}Rl?I459IhTq`m?21@`TKfMyBIQOG(3odmjvN2-C9h^QZ9NbuGKs&Z+P(4#LZ
z;`yALJcvs=)jp8HWX<CUj<5baz`1#-N(W=lv&{j{+2X_RQ6hyE`;gZB77y1rN>;`#
zrTXsVp(|651~Rxaid?-v`fPWOxS`d7uTz0C?vgz5;u-=pRK}QX)f;ZIBIh)|v*3mg
z?@gnVgB}3HuZ}P_7q?xtxOa`Lm%z4zjGDefs-yivHdi~R8D)F7kAOlnFA6?<zexYU
zG{MRNEV`mcl)erWUr@bNLL6E8#ppQw5Kxk?9FTfzQjA-e1*<+Oq;O-N4Y`g!($Gy2
z5qwW8`$zI^%LMF<AG++k5z_^p&Z9`#8UK76rvp;zn8?MhOjy+<f0G_zAotGHq7S8{
zp-UyVbX7pVt|JZ%I=KO}*+QzRfs}mM0H-|1K2b}F+<ZSMyRG`<JH;Qr8<!aP5WmNn
z(NJ55cTmQ)isTD==e0!pKczYI55<Qc`k^{V-<Rv!9Dqn`!@)tjV_jnTsRgiyBn{sy
zW8^(j_hS-Z18|yvtG!!`Jf_7uY<n{o%cT%XSZ6XJg@AyOyVztgJ_gm;Z3rJxG?byr
zwT4mnl2=blLmHN}n9v6So8jLDtk_aB1-yq{_t3&5UyEi2UUhR0crLFBY$I%r<(3@w
zBKEAF!>Qz)Kuxt^!lyUXqY27qJzGiALaBpNs>s;{4Mz^t<e{81BZB*5;ueQM*Q*{Q
zpsSOPNwH#Wewv;X9P>cfa%VDe$|lt@nQnCJoMke%maOg=Kw7$^t&&y%_A8VNlC55X
zRIujQVEOM-K0|x|<LAYvAG22rB?6^2r1C}6?dv2Z7#csgK9C&(j`4>Ws@#QR3f6-K
zDWK*sI1D+70gXX^C?&M+{Z;GlV^)IgyG&*79AlzGP$)lJRkom9C<Jw{C(acAuK4gD
zRC?$^es%*dj0&Jrbj2juulvXEe)wS_Z@X9AFoH_AvW}V)Oc`&Mfa<kd2cXz$_2et!
z?%cu@a4ODGBv;h%eV#f3mt#s(2KpF+&%H{JIieW??<))}LiQvLSxzA<G+HJLr;DnL
z;4|Xd>1Uim)cr4uzx>PeOs~w5p=J(-39yl;=M<_Qgr<xxfj~TxR2Gt=Z$~-TVwwB}
z*3=Dawy<&SLz)v*hC#;To3nCBnoIu~`LUr8n%}hU%5kYs8*Lbt-2$uu^AII;3*7e9
z$-2o+ZPg|!-n{dDEg-Jkfqu=EB-BF{i7>eXSctg318Nd|;)!uUJr*Z+PXxpC)5qB3
z(&tTpeR#*Ak6k!nJ(}!L4_WD~Q*r@M!#*1tI!V8jV$LPq%@fJ6mYn?nh40&{kj-Q%
z+!I}j(~E(zWme6A>UREkUlpHz8&}&();2I6AV($vYb#Yk+NkU6;-ZZh`eiJiR^3PR
zlcCYS&-I};5H;Y-q#M=ky4}}e_nzS<_$(N^rOuG`acGC&-@F&KQ({`Eub-!9M2}e`
zACMq6Pg5u}Z*GJnI}~IDg?#9Jf4v~LL*o;4JGGzfomY8F9wAl-^34^17a!~GOC%(2
z$+0hKln3h$HE2~tbA>(2>GidEJ;*8jPAoS2#fcVjDS+}d3(*D)67(BG7T%h=4pnc0
zW?nnH4HuVJB7<I^eBegcOCpPBLPOFOO^ak0WUMDH!qVfIyI_8ea9D&2#j|IhGKOUN
z8jLe)F0J8&WKrEm9BjR`Z|%-~7DKakbcD}=Rc{sXkcZ~D$XNxWXaMi3tZHH53I0$x
z)jr`ocSWl!HAMkP(E$BCk_#^BF>=t79J}NI4h@y_Ie>BY755W8SPwF_qu31KzD~ih
zBhT;JU~l2oa$uxdhE1#l$HNrrXBf&sJc6K3X{KG4GG>ujfk?5%rw&nh7Uz)v0|y7V
zn48`LN0iYyWQR5jT-)h<t`4H-Kxeyx92F58%ZV5tP1i8leo+5oPNJwu%NZl3HwEJf
zL)<?v{^pw=%{a23nC{w+PC2m_IYTTneYbth!s_&2&+=J$S~pwcYman1+Pd`(*g|TA
zu05*_%}xgHGpy@>W0$<4&UTf)gy^=Xy;=cywlJfhK@E&c(@Pp;JlTD-a<&y}<&4m)
z5$q1WeFqeRJrsHezZ7zNw<0ITGqo3qGupANw?*Sw=m$|XaFaikMc|P%TnSHR<e=W%
zN?D=wMY&euR_Or11OhE!&c1yAnKNTg>(J#Z;idX!A#lICVzZ0&5ubfMI0$-v$I;dh
z2>PwXIRpkkP3)bvAA*G$jqO(@q0&|Bci80J560xF2!~-z^54y4qZP2X^}?>s`&JG!
zEL8n@@#jbnR=rq)Na&al`@h2|m+n!U+6KEOJ9s_Htv4a_FJgUMaAp)G$sN$D6hfTa
z?#)R}8w};aLDPP#nwrphNd9}lq~a<+{pIN~S^_9T3+|mRRWOU|Vs`XZ^l@|Xa1Es$
zmQldtDQ?)Ax&gV{$3Q+U#$pB1OaRP<>o)bPYKvVjOZNx^ns#imwg5I1Q*a!5csq)0
zxN*)CUz!6T%!=k2BjxoSf8!St<tBVF&%iBS)vo=6y&8tlOL-<|q7yk7SFFxPtLqa~
zo)-(F7E@RR3jX<zknyrNan6fziy00WT+|SNz~S4+*W!_K@5>}M;~er8#M8y`ruuCB
z+W_e`s2+!oQ3)SVB<vNcL2e}k`iy^2Dq^qE{CojRZAeC1vI%KB(6gr3uEqc#z7GiK
zRmL_CbYgbHoy<L^+lB^XYzwW<?EybmdJ4zv&0o?(<><U{!Zx1v-ts?|cEaZF9-#1(
zlvnDfi=aY#O^zah7F-n)9op8NmN1>3zyXN_LDfA*>w}E1ECKh6-<BB3Sk;&CEXVut
z)8f;=oIWf1`UE9q560LuEoo()wN)t{nE&Fhi%-At|I`q!sAYB}1(@&!St-Ove9VoI
zlFiadj(z8Fb@Wyng0)SFrw(&*OYg~I!HtZ-Vaq=*O^5C9AUKR=R$QUioXU2vfK^*U
zNi=z)$3z~hN&uaTodQZhI&A<cwq5`S!z-_Y(>JHa2@0=LY+mSIR;(#sK81YQSV4J9
zT?r-MhiRRaF-Zr^+6&i!E63ZiTf7IW8>~S8931a>Fh*bw_z?=rrg(;g7(MJ<YqR5`
z=eS;|gE4t+n2ghpIZ6Hao(qeQ-vPAU{)Ye+{?>#1qx6Hm>{=Yr&sI_&$*nv6auOiF
zr8=NpOGx{rXMmP-JbMBM<W;d31|HCFbh0UeMRx@UFu{3Nw5MSN0K4(c?u%W+Bhmv7
z9SPR{>E8?e0y~XR)^hk;laba=IysRum41{LVna@OXe4yp&vdw=heO{eUPs-`xJzh!
zID88d+;D`Dtg!{aM)uQ}$*JvI{(psjfvW-xoKFF694Rji>C@3&miB)I{>SQzR72Xc
zSTd@7ZMdg{+|*Sy#ztFAITwu~I60#|DX+p&|4%!i5DMrg2jNJmlapS=$szE)S&39*
zU!Wwyhj|7)PHMZcYI(Sy^ze>Zh0aEQ_DXqKqBARaKiZc$z0>1v;5pTB@fI!iIyVh|
z>>wp_EFvE>>a7P<=Kx+FyIXN1yq*R7g~Di3$GTwusogR#aen5BwaR*fD4ugEn^r$T
z=g4l^_6R(Za|#I8-{Q|avUa__C?6}nTkCmo@C9^&XSAH5Rf94<yLcwTm5wGG-0exh
zA0-mN1;5}+@x_=N+M(s#X)1|Ocl=wHi@>q)BSfuvtLD#VPDo4e6J|BEle9Nsb?Z`^
z7BsAxOYZZ~W)Z=xv7V!Rlv(PaFO-SC?MCk}=uoY9vpX50QSKL9AO0nbi(k9k!q>18
zyNYB9s6!q<pz;r7$+Yx!v57%eFL`+e84yjOm%L5jGzy3XEj%Hk?3GY4^pb*HCe+>0
zn_>qM)+8V-dO8YG^iYNU_^%kF;Q*vG;oO4s5%26BEPY9GW_<ubN$fIMbkGRDp>Nf+
z*-8e<Fk2{kNk-Z+H4S2I+Fu15eP7{1)xGIqiZ*OX3B$%%I=x!;*(-Vc#3JvfAJ|n}
z*MsZcm8f5@{eUm6V=e*h^}MR4S(A%?^cW>~ZtI6_uCOlscIYeGn3@8nC2~_keQ77Z
zJ|?QHWRe6;M>QgbcEk*deV2{Sp*7rN59yoE5-JgEDS1PP+urQ%ju<sQ4`U93zP?ER
zn-E}Mq-WVuATn}nC!1HR<6AQGo9(FF!2tw$_*YrNhm=XpK_kb{RDlTr2fe7Fd=(+C
z6t}5r;KDAnjAg2$XB5Z;;1WQdeu*hFY9>$A@Dw_I{PBmMqYj6yS&Q=QEl06#?IZkB
zD*@;*>yZRT7L;2V(g)sUSdxyG;iGE((vKNNR&UvvJ{esyxwNDe*zrn&@Qu$$>`ltX
zU@qU`Iye&c`gDELjkM|gJW(*6zuLtnF8eF0&aL%W(H+=(^c7~(0%Ssj4w><Cr5m;I
z8Oh%A$B@wvTT)34Cz(?A=njkrfbrhRI}sZ0R3hoMx1J|8WOnOSB3p5B(4Ms4_hsS;
zC>@9E_wq&s(oerB(m&|iy$iNAXw3!Zl8i*nWGxHYXl;N=@J||8L#T0phh(uk!_C@#
zMCqz{_7<*2&*E;E%>r{uf-kJ&o2N#_U3RgxOW?KDL-^UTc&y1izQ7zYD_&D=&yJq<
z)gAacUqi)EQpLCJA%Tr=FX?Vqbb%_yDM?GGQ!%n5Aq6Nl(cEBd5Tjm0Vv$=1DmtNz
z=!PUsyFhJjIS8LF4QikIkYQTOpbvPeEeD_z`*J%^Ghnx{ztMkc%k0csmlAsVwH&qT
zKpQ}LIZyqd#L`jx&l_Z7N77PTYGVDtDzGo43^a5hhIyT8yOJ6%Ama9i+SWpQ;l3>E
zl-$`Iw1I9h5Hb+r<LYEto)&teKBI6tB&HS~yykj>@T)a3r-Qr9n6U3v*JMUD(YFar
z<Vd=Sayb4`UJB3-PZV|ZICSBc9boTnnJ}smD4N;FtpibNWvy81;8Q7&V}}~{rl66~
z(OSY}><T@^b=-bFc?YinH}YdRt5K?^qy5?J>jT#O(B&vKsI@ERkVc1Dq#vik3gI0H
zDVYUZD)N68U;hnkUQ_$*hhxSY2eot>^KKQ>{DornBD{3xf)*bZPSCoCco;5wj8)gr
z%B=RRzCgMVAR!xd6jhKswNxLJtmtR5B1m2_m6SGtFQA0rXmi8XK#*xI&nnE<D&RY?
zjfOAta;VKOQh=h66aw0te*<e`t>3|DXIla|;(Y#txT{5)7X<(Al*R!XD3%urpj6;<
ztx{aI4jJy*<#6sI^I;e&`_1eq4C#5t7gp{B(c(*;r&xltO?U`a3?d%SmTa5_#g=Z%
zrg^k9_r1AAm`4&Z5tIx_%Z1geSVaSZDS<gBTyOo9=e`5j$bXKc%7nGuI+SsNA?{>v
z1>-TjbMj-Z5Tp!4V1=t6`K>!2ww{P6OXt^Pz#s$zdr$6GvR*eV*^kOYl*8F9fDRop
zXt)Bwh7C5viCTV`Zv9dQhEmXgy;NqYz<FaINleW%5qqS5%!|SOnYzn{BFC>L5?`nc
zUm&;kZjbwO^lj%*E(CDO%56V|bsXsp?*>kToSjR+@!%$fU{g1TUwRB`8Qah0VmY(g
zb#%hK403^<t0{8_2z&&O`cAEIxv61T8=7Rn#D^Id<y7grKuw4Ax4Y#4mw5&Ow^Fs*
z!k&67uZqO}+xJFuhZ<VuT3a4uHnH4S=%rv`Q@SQQM28MZht|EHevJ{9z3m;u01V2b
zCdVG;I9&f7%&YC@A2SlPdlayig|9EzyI!bpZ)90!o62K@dDjU*^4zEl?JLD88y#n`
z_nvL};CibUe=hr@3_6@n*V9u2R&K*mh-#oA(B!EZ9}Mm(?CNH_I{gXy9Zk>q{=acQ
zDS3C&*n*}s=i!GPUA2Pt)h|mId!%azs8oUOTN&{jLZsbzkAQ}#k>WWKN*YUZxe&_F
zQ||L=h8kLOG<@R9Q#x!G&nW=o@Axl@Z@I8-Rtww_D`Y+U=xWVZR%%|QAz}8v>!@>#
zu3r+3(==zr${mX^AJ<V_dBS}73h-|F84v9e>>B;;uVDTwTW{rP7ogq!2^S%@V;AK5
z&iQYc!XXb1bX7|+ooSD<HO3Fk2=Yiq_~w&j-OVxvTjHg(+$sT_rFb3yITq%MgTC75
z2M*rAy~PC{G%-Ml@eO5hykebNwkBIAZAD*|{!~2WU;3W|Old;{h+IbbQYg>7D(c<+
z;3U~Qfnqff>r0ph`Is6@irMSM2d)Dc>don!J}V>es#W7Z<|KMZo(`V(?^y@C0`*eg
zWNz%xONs`)DR%ech<yaM95+Z}7q?vkRBNmyz!!NU?bHb1dJ&14Xotc=1wu3!_2rK3
zA6fcXhGYD$;Qjy$vf=L*<6$4K9td&|=}%H|FFsfBj4?Slh_x)q`rA1LMbyZ3Q;|Ou
zE0Ll+xI9^f(l$wI3TnrQ?#z7x9I8vi0+%)l>OLmOL<@F9nw+&is-~-hr;6K9#C$lg
zt@A;`vMWM!8lBUmEeLjy(?WwMsNRar(oXjCa1mr*Zm{Yr2h5~Pp&2Rq=UZl@VRCK%
zCUajeV^t6hcCape32klk?jQdigK)?ds0DIywe-b84Ft_YlPxdS0}dgT>e(-9qt5M2
z#p2c9`R4QcCFoEC%#{SK+CW*J8^z1z)?{D+0Rg@d$Ivj*XCIUta9jkmz%MT4l1eum
z6FP|}6mmpStGJ=JB5yz<Dd}}09~SQ{Cs6bR3%$sX3e!Vtv+Oo{&Pm<%=>mvU84zfo
zVou<|Pnjl~H=Rn-KRIQKNO(JycR0Se5;5keJg|CLHCGOffI)w0=}-ijP{M~&4!J9S
z42#*jQ>eWC8&c!~+RC`)U8&^&De#Z*Y&wU|SW*L6n<2!Uhv&h61<Ja5Ut8d2@Z2Sk
zT9Y;=zJ^>VfOdgro8NQ<8NZ}NTRl9>4qfQ-k_e@Z1o+6y!H}!FB1c~JoUuNs4#r9L
z7XV)>vf4YC))F(t;JDExfmtSGqKJE4_v@8I4tYbAg|z#v{I^h0Lv7mYPb-~91mDB9
z51whlnFHgXxlKiif&k>LBmleYGJM^$c6jjKTWc)OQe*@8WxeDPK4-M=5UL-(iuYTT
zbFxsjM#8>G2dl?xzPq01exf}0!vu-xsuMhn!_^hI<F)kTW*5rZ0n4A6Wrk7!hV>aj
ze13Y;^P?Nzk?1u<H7Mf;ab_9Ar7`&kCE>E$fvvXNU$ffh?TwljQ8S=&3AfUfs=?jd
zPeaD?m-JflAIl1pjWYoIh$Im^f^^2G2?ABJJV{NUg?;DT0*U3Hw-r+&u_K#<HOd7}
z2sPDq@_CRQq$rV;+MTC)e=h~+KY1msj}Z{Z13(6^2?9`G+RGdSKd~kkW)E4RzsH`7
z8bxP2tfAXX``Il!1ZN{F?B#_5N~BbjaBG-cVE1b+4R&ua<C^I<=V6euFudtgk|VK<
zfQPPcO%P}<FwqU@<viIw_sy9)ke<x#pw`)9;`oUD@9c}@TI{dcH}vmwvo9=~j8#BK
zch%%r4b#!EOZfPcPd~A~)ekT|gR4mxAX?Cl@oD=qu)M@2T)kYn0_m9KZ}iHF10_K&
zS`dHpY(`s&mFo1<LFi+IqkXC3f*?{42+!3kBzq-lTaZR?R3rCA2z$ELv!QIEpcPYw
zjd+V`Y1EG7ICw+wS6*{A7|>#!=&|8{i4wguAYKJmc3-2PFP1%pF~pb9cCMz}yRZJA
z6+I=|hx!*gDT%FNHD-DKIW32Q5mBaK*!kxiItWt=`n*;YEA}Y6X1`5FM5UohWS}SZ
z%4>Y(^bsuO{!KpjG%xPt4`gTN5*^4alb6&)TC%lv<9o#)zvB?B1M3YBdTox_ff%s)
zBP4CD+PEiCX-3aCl!cy-%eQ7ZTif%Z1O3`|M|2mppS@`%09Q+u8|?LPIQpja<QxaN
zdkej!E>83U^cvooWB$tZmUPTiH(@kfitcZf;LVe?jNmp}#&&`IN&0l;3IH)2mL!1!
zEG6o&hkNOkr%_uPC{mImdkAWzak^&#D3DM{V4GXOO@3>&Ea4_EAru5Dt|p?*O$G!6
ziTP=<79g$#x20A7p5U%yH~5p{)4xJ6Yg9AvlDxO2HOOsjM+?YA@(Ut5(BmQg)}h;#
zF%bq;P@}U`e<>c4j26-qq>@CQ>SFLY2L%B8gA9naBGmH(2Yf%`xMCz9vTB#a@E+jA
z<d1|yB(=jEtUk3+Z7DaqIoAp0tvI&c+p2m^dtXFlpNOqZ4rYTe!srVRgJ~9L3*uvJ
zN}vfUyz{29^#ooPp>^dlC|xZf2Yu@br`6ikD)Xj)&N}r||FjP*<zm&Io)a|Z0G8B;
z!sI{2#tNf0RMYy<4@mq1iUWBU|A-i_p@UMv0F&l0va6!*{cMk!f<xdoy{sOK-t_kN
zOd3Y(PSx)x>Nen+|4VvQaPFF?8!dsHXV+Rg1Fo2cS%9_nfyhnJ6%ShWWIEqjTxmIz
zTSrCY{HJ*o&mENR({mg0AF7w^l6K7xGpFkZ^R=e<pjmrmQSEhB4a6iw#(K!S_bj?$
zEsC2&jEN?|nlY_Az?ZPY|DJ#|l;ckG^F7NKA6yJ9)xf&53t5ICLk&XSb%A*UaFPCG
z0nOHV_?zPYNWVEbAN&p#;p?$-t0F1+^xy5u9dMN{S2N^c1ICqF%nemBl&uu_r!Gr2
zKI~bi%`m1~#iyU^i&_i}!}d+>><IY^$QebYQoR$AXj3Kp9{+-c@YSLyB_*%2;)(Zn
zC%IeX@CSC6(0(q4u10-4W|d0Rd|3qN1!BaEMn5O_(|>n|flGUcB-X9y7s{6@H|mlu
z5@5>eL}cSeP`o!sQUtsE+0!g`tR6l3G~Dja1o-*G1&aCo++uX_u3%xgwXI4_1oT19
zOBtrVR*v5CC;HW=-wK-fTmOmFJ0=pK9~kcKM#)l7+{|w<9tEQ`#Cz?bRvD*h57LXU
z;?fZ`wUw2XKGngm@7m-*Hi|DWG+a>WH9Cv03j6PWQe3S?RLO#yGf1!25<ki{TN(sK
zJDs2g*n{JP+sX)1-K;&(6!CWDXd{M6bL^i04tD3)_GrrGs*fYSUuSV=R?_L4qnsIn
zN`qywI*)EZ0Zj5T6iOjzC5i$uqbS3(k!kW>?jno%+H9q|bt&ovjsz0)3vhvK4AR^G
zUznspr42UQ<<f`jC&W(WH%ha=^t8!+IF&DPBa(joVN>2t6&XL7<gUP@c_<uSgo^@P
zkNPmD49`dXKf=Q!>)W-ez1DX)wYk}0gC^<-mR9rblS|4C`gj6K#rrfY&;3Vx!<>Ps
z4BRJ6HYdgw)HiM8wbjd%i}ImtviZt*baiZSC;ACuFtS&V!*-co!!{K<9HP?mbm(dK
z(>ofR1+Y~F)-o1C_QS22EZq7y3IK$Mrfj9;1c#(;uFVqmgnqVE|2|@db~{KA!)s~s
z0Ur<rR#@LGetN!{GN<r0YjtaoQ|0AmV=rkTicv71{a{Xm0B;o>jHcS4)YTJPR3BTz
zM@+aag~^+OSJSgrJjnU%#azdcYk?VBlUCH$C1p<~*_*EF^`W7zC3ru&_Eewb@P!`x
zOr-!~W`Y5Nj;9OhhogZ5A{MIpGhTVE<Z;bIfRSYGk3WWP0NSq_^K;+c>mCd0Lz+hu
zD%lBNh!dO8B9fu)7L2jgsZ#3%^oaFDa_ndk5WM`nWZ94U^{~74fJgUb6vWoWKqN~B
zEv}`4&^E#bk4j~Nmq72{n-lxegn`GEO#op1j0=?1yUGnfJvY|$*}HU2pBY%)0Tu9b
znXr``MmsQq603k;DCB}^R4h9SG{8~4Pa&6^M(~;K2fR?D@|Es2r|>a37{dH%@u!xo
z78;4BA3JGWfb-*V2ZvqYu0trU6U8N4!gdtul|&iFGiQ&1)Fz=y`<ltNuqkwLCzyzg
zr?xFxXQp7_DzK^oN}~9jaD6!i2M%M5Wob#TQK7|Yb3M^mBz-8(Ze*x13B!Xfbwfy>
zrDf@G&=3Fa7ui3;3jAB7#tprMZ=6C%ZJ;>VnjJ+S(GguRdeN)I+{LdN@jltRtfNe{
z3u*5`T%5u4R2d(0|7|(w3ap`@4s=%)q6kTn=CTl{Y2~zMxdHB2C1#z<>zg-KaElRO
zm&w8tWKADeep)ZnH)N`EkO@YPu=ZLiOViGP#NXIrDhlPYRu1bVk*-rf9qeEMp#e;t
z{~p|xRGokr549GIi(($!c4A|P8(|rSXNS=pnJfW=w#S?#{UuX;4|+@$=p$^xmMmSh
zD3Am_l!M^9IR@}YckmS?Gfs0f`&iC->TX4drUU`qzf1oNW1q7ezU=BxF~Z9u%jDsC
zwTgGw$Ecus5yf07a0CpR-`TW+qp^8pup+`?XwaVsYXV@lNPYE_U32bAA)w|RmF{8<
ztmVNnKoi?@ey3_V9p}9rjN{;36(ajRcg@i?^+nqCigU45P?KC@yiEzTI=?A@x{!kq
zO{4)-a18WK7k|oW|NeFkt*9GMb-9b6)ftWG1fBrQx0Se;Ci?JUYL+l(E_YHg6GJC6
z$B;6kFaTnraWLg8cVOZCaxUuA(l%5<X^8QF77Zl(pjADGHk3k;U6Rbik1algPb?}s
zT%d<tSH(HaJ*0yMjs+4e*8{nCbJbX!D}7%3BrlFQ?~02C)SYEpmBtC`aP%7Ywe*r_
zJ_7wH$jt{o0>|SX^i?q;K2IXCW>QbPXUXLo=Z(xL9B*x4V^sx?xu>C3FCRGXF&YV$
z&)JBu2o0AD-2&2gwZg*%y{*_;0uq71wKU1#(D8OtfFeiq5<#JY!)Yu9&Q?^^h{!Ku
z0@S4n3J8y`(KJ9S<S_24!VbKI>R;grVB>sCx-3=3T2M?lW@YE%><F<tp?%h2UHtA(
zm;4N9HnS#=O%D$D32RY6<x1%d9BPWXcnj@s$!~7UI|dI5b9&)5v<j64agF@BT7MNf
zJLn~Y0!*}86!U@f<EAm%hIh-~%kqAR&S8Q-izyN>b}}+WZ-u}`AYdKb%qL9AMRX4n
zS3-(L>b%ESyaumGB02w#NagTAYd9xYWdq44*Jp`@vnIBb7M_@WQRa;bcUCFa8K(`q
z4WH{^^&c<mg0;t!!KD(7gQ`(pw%zuHyH*uT5R9FI|Cdzw(qB5bj9A4vQUD~(mEO4?
z5G;6&#6huFY#3GSudsZ-dRcYNY(qTA(o>+mvZYducoG9Q9g72;E;+(jyg7%UCWT)R
zj8p@zE$jC)OR%W==fq_4)jkmOLCL1`AX@XMzQ?P-1bamT*h#>$Y=Vvy0{%9ysA**J
zYM<Gi50nnB-O=ywzxX^DoOA)Ex)~5MZ<p&OIeJ#_5huUQreI&;8-PooDfaT@$j?_+
z`)WDro<q-#5K}KI7&pQBD5g!NrFFj`P$HRF$z=tuSTRtMw0N$qTqX)u@o`o<44#si
zT_Q=tVA)lH!<eKOwYfezX1Sn%79m|4Ri^)l75-FH=|MXc>~`#EsPV6;TBzw>1|dhM
zZ7=3sZ#13@t^cu^QqRAF5?ZQn1gtM*1beb;y0ahu1zjpQvQMQZw^ZTkOmlz<*1?(3
z0>jlpMC^)72|KT~rLDc|51M5tjl&(+Cwxz=P84it66-%JQX0-`VoryfBj&PIrze0N
za5k~F7bNwjPV(wjnxyS@K48Cts_Y{BL9|@YgMY7o1yaSl7Me)wlm0_Ym@Zvx!S)OX
zJvXJKqW}k7br|kb1oM*l<H3Q4G(~ylMvPxx>@qJ}Ib8A7<9mb(V;)Ahjdl7#?WLra
z1qzX(A%GB07cZdGEg&H8jxlmS0J1;)Q1jKRC5}r53Rvm7?T7K6y%m~y2CyZ`!lv^~
zF|m_tKxhEdHU5J^&jEL++RvxIF8&${$MQ8^w+qkq;86*_%YZuxt3N>*JLasn&|=z(
z*LU(1;!>7t%exsybHyrqUr23fn?iZ0TBCdXeA&V5H*g}~x=0OBw@S|xKj}dGXt#mD
z7wt|^L%_k&{(Rk9(e3Qdf`WGGcqc<Ro+|V}P(Hkx#Q0ly#hF=hf8%h<V<rVaR2$l5
z?lY@IE6-n~fBSLq;Rn>ZsM_Q`KTO9UL~e~8d5^jfxEoXrK>w$RhQ`wLt%ynWHSeQu
z=uGFS3wP26#2KVqXxzY&VovCB3kWoZ@8KaPGX(o-oY&VMc259xa(HBANK>@W{oN#m
zZa{uukg953lVFE6L2sG+ov?RJo~*Q2o`FlvkB=rO3sw`NjUe8hmkt<Pde1ijs~rR6
zwM{G{+sWbrBP_TA>)}oyg`6A+5pn#ei99Cmn?K{@Yfb8e1G@eNfQ3>EHzfXwC;<C7
zy{6*;f}F;EOUFNkA2A2FzO#sW(FL7lPn%x7&qQ!Ms+2gpn4b|1yOE?;r!8!$6<INy
zr6&3shU&CYgV+v$-Wnl8gmgOXx1di!n{dy4l6A52_`wX@BOCO3hR=K)6E51SvD>^n
z5a}mACB0t+=(OrSJ*jfJ?g#uEboqL_i5hdD&y*B{eLX8rxQ=lYgvAvV#p@$zpZ0go
zZ1^!tYLj#`5Z8z0119oG9b>Xvq)qjQcOE=&y0W%()eGGh%Ioy9cvmg9MfJTjFBz@m
zdc&b~?MHA4$4jsh)K$Q>ei1DVd~pa_^PE#fmEwGY@PmhXIMUmspMzl&E(0R>L{R7f
zf8+)GeVC0wdI2V7+JfY<A(cmyIpV0k2TjnqyK?fq`1kVZVdBLybog$nt4B(nI2Ca}
zh^|0m4p!hK;+1N?t2E`{Jfw@uGM&=iF2o;Q{-zAIsQ0GNzjFVqv!Kn;Sk7q3m`fj$
zXRx2UTF(kRkm5svuAzWEcgfbLiZ7`#mUUlKok=hl2VLQ#(O~2gEiT=EPg8(+S2W>L
zy0jv7%~n?Zgt?-78164!7E-TDLP)%gSR>dI;SdAcvWji}wuItH4^p|n-$BpU2QL=+
zh$lM6S(FNdiYm*aPl0u9q~_@?p8OQAK$)yq!3l(CrNMEcSH8*H01zZer=r@-&fp>V
z#UC;@S)au=nnGe)?!CH(n7>86;{k!8(c;9uNO~AIh9}ER;DiLkMA})fLnI@GM%O~y
z!ko-gS2iK-;$=`@p?HL1Mtx-8ZDsM2e)r%w=j}kT-IMo_w#Or+Q!NbSN`enE{nu%~
zV<+Q`MyqR}YEVd;ZYXY=^<q@}8kH!M3y_JhA9pQ#?j)Wu=ilKJsC7H;K@gP#UEg=0
z^CltJS;rj+6mRS5IwSRWNLBn3#ph{M@+zJmRtwRcJjMX-m-X~$sav$@CHYTUVh15-
zH$*igWcx7i&~r@0&59D4(Wk8!WC1v!ingZ0YIA7t(}$ZhO)aNWIfTv(G?B7`&4`9+
zp)NK220Ue!+UWxe&<Bk08O2Rnr^4(hJ(&OO|5xZ2rzh05{n6jaAh60G`b}8(N`MU*
zUrrn}?WYiBp9OjHWdG9C2d<W#M7v3_!2tx0py0q%G~h3#-B0zbbbRT(?Rbw#?AdeT
zUZi(h>J-ee0dGd`wlXAjKRPe+MxD}L%Y%R&ujskT5F1Vkoyl%A{nv?ePsj0v>-tKI
zy1<Vj$$6)rBEt?`1Df~fM|&+n9;NKzFpt{a!j)T#?3NwFrKeeFrWsfx1~-ZIGZ_H@
zIzYw0%JW$31k5IeGI&$!VZRFF@Sl0yhIk_9HP%%(#hZj8Cin&QQe#=D9fF-vFOqaY
z>2A2kWO*bkCdWh88UYTq3oY@jw6_-EmFlTu%$jygBr?aonGfOved@UADXS@&*d@0v
ztuZ~FU@<Kwf#+KQGm{Jpkvo22=_fbJmvD*R6;FFVc<5a)E>M+EyR|ViQsJiUmycBW
zn#n>O(t%uK^|NrcP~Y%|ankily(gr|Q(vOYvolpHhSI@w^P}BPQ)qf($>0#M!9Lfc
zsUeIW>RO+{V7m@b$+wC>^)pJHCo%u_B1m&q@sNZT)QO-z!T8JXMV2;!N<#Xtc81+A
z9;4JW(#&_|(e!yA0rW;w$^>)>HcUqG$6cK#Hn-<V-frhmMw|~=sHBAFrhkAG3^UC}
za-|O5SpEs@=eu_Y8#~DL#3`k7OkCiZe@^Am=4I>d#|<L(2f4-1Km8`GOa13hrYULj
z<PJdCq@)Kih2b_Evxd6jR`pzB>6(R}C@BpPF{y2t*>*nYOT)LI(<j1H!06#dlNcYP
z*q0y+T<?Wr8h?iPXc}5#TNfiU!11lJ++f=m?r1BO^v1BrTT2U20@d~)!>&-94wgc(
zN>9L2-`eztbtUIdp31D8uVH4KzHEZBq1w*~5gig0kDxv0&A?;9zTZMq=bx($e|E2K
zu5Iz$g`lL#Nx7uMRn}B}O_#o5(Dv^LeXbnI@a^-nnfob*y}PBui~l|yGJ`m}dzHVH
z2ZHk>R{g+Hi;0?AYAAP->V3Kha6%@w2LIx0z7*8O5Cm#`6p`k*EgG6udZFB!U=@u2
zLJ^?`pS2K>1|y7$zEgVA79-}^)+5I?-Y>pUH#RSa${rNea?4B$NG=B<M>-)t14!JO
zO3xdW<3J!kYJWaGiMF$vZlj5h4|P#bkg@ZGm`~^`|J+Y{8}-~vS;RO#cGaI1on~f3
z>_pbX9)inqoxf7!_~7eNjN3mpO>%YDKNna2jYaAu2Dq&h#?L?*C@Y`)B8wQ@fSh_F
zlnXQir5CABB6)<Q>3ZN6FAex<s&+6!v@DY#U{AEys?{7jo1KrB#B$kmj$m=*hblFI
z5%Hl72QP+ywW1jFvcbwQnwf1nZ-7&A2vAn`B!_o<gO8s>9tEuloatt67td3A%Qcv;
zI?5Y@T}(=?k;(%~iWj9H``LvS4r@P|;VjmAhHmw`VfCoOqo>bD9|D6JgXc=)u^al5
zFkPP-VcOgc=;51;+lILL92oO6G*#0Jw&LZPH7tQLTj@epeEQdPj4TJ9u467bFU#%?
zmBiyXSVWnBha^qkR0+8~ojiNxdX;1LH3C`{ex;Q4T+r~hXawgnjoOgGH{1m)x3*=<
zv{Dz@Js27`&n8C2)q6c;yQpg1Es)ul{rHa`z9>HZbNU%@dwi_rlrNt~_w_q{U-iM~
zrcILswXY}*Q#}5wZ@F1C2--QWatDNS@!6h@g|QO8(IL`0krD*(5Zt$S0Fa&3x{@8%
z<gS!G`64ks!v3R!q)<9R;KLsJuW7KmtWa?kU#PWI%yrVtE>)mpPzVpAnIn`*?l5s_
z9WEw`qMyT9sw`eR>_%!#$ns`?Tk>#WjXf&mG($oFaPeAEiGfya^IsHy@fUyL@6dz)
zP!-qZ^yvr1#~*{t)yM$vFgeOfzka=*C_NE<JBfF3Lsxo4>GHS+;Do%~8o;+f%#7~0
zg!OoGxK1^)bq5-{$WANaHy}qBgBttOtlmAgZBs5YVSV6(Ey|}ajp*DzaEFHvze}$V
zg@#zKc(i$5|2tsTEgszAfjwpqm_Z#p#I&GK_;@IE<a)i=e&XZ5fO_{i?)-}=T!4A1
zOQd#UXYHxf^r2!*=!ReB8;sGc-1dIFqq9Q#^{aL4l}1?XTI|Ao-+xGuFdleoSxvoe
zux?a6X6^rwL0_}wdJE7=Yc={nJ5VP|`yUBCc<0lKD55QWOqpidRj=(q^ZB`+P^w_-
znFUQ}(qw%21yksTUlm(2t5ivDsxXpC6@#~NJEk<&xt;r6XC7SI;Lp)yJlB1UUi!iC
zQ<c<hu@rmyKi&7#uHswBfBm8O@V(=J9PkIs7yaI1U6bV-I>_zT(j&;?XX#G^j(wPm
z1D?fcFS=#)hi=~5Jd$q$hyKBHSAx{M9O0tE>2gy$bU-4@?gzK?vcDdD=yu>nr?cj_
zm~cCeu%C{NjO1|q6y3`z<}w}U4tVaDq?3Rlp)aPut;ovVl9A>VM$5ggPV5;&U9Rph
z6%PzZgSG~mTG6U4lLgb=g94{<rxtL$xAJM3(MqgaWU)2?LA^3ZvusIbK{Lo<3co=x
z;Jn*=jqR?Tm`6Eg%cmk^hO2S`OF$46tY`y#FQhCm!gCAwwdKqhlC6)Vmb5gtyvL{z
zBaic!4PLkD=e`!DM^A2KL-Yg%X_sYeknt_cD9~>H#Lo^Qe8PeJ8WcUc`at#4p1^K>
zST#v<ZIlqx82|!J(<d;g{Yyhb1Q$a(E_f&MWN)X1ZnTx3%$3xstT?g=r=0}4JcQZp
zc5|+-kO(p66_w+!^g>jpf9Y{BBwp|{JQ|En9Y3-KPlwK5UVVY4z5=G?Opm5N2;<(O
zbOQ_p*u{!f>?t^?3D@dphweYrSrm@@XT^tKr9)Rq^~OGCvfcK0j2W$HkuFw)R<m0$
zpToZ4(3JKioWCy0o8CA+;eg>&+KMHKXL<|MQF46y+r_uPty_JN-UMY6tCY~eM#1<z
ztQ?>*FQ6k@J2(TUO4@ywyA(nEDC9l~?YK5Ppb=QR4?Q4hjAt#f^S%NEzT$GVv;(=7
zUYb|IlbwPSL+#Vp_60=r+#GOz>wwiLHWyY%L9n*c+frhHBCjg7xsM`%SxYr>uby@q
zo2+yIaz@w%)MfEm`u68S3SB);6af}<Q)kGF13y7)`;k8by9rN~O0S|Ko}q5X5ulj<
zxJ?52b()W1@rvsT9qv|oO9<FYd_ZUlY58TrY#Jo7Qttt3=REANYQU5$-b{Zj&iH}K
z_4Fr&yU<cf3ZOWoE)60ZF_**`dTUVj34#PV$x;gS1d*0>C8xPKZ27Ugw~P;}Nf<SA
zPMD)0(tW_nw)Hs_<0dd18tP~;%UJY+-Y0H;{~YGyLJX1LvAuvV7P6hWLwkzLJS&<}
zH8ub&zjg;JsJyAIX)3{7=^t-=0UW~r#h%0S<bsIBFj;i|np)7WF(b!czw|oxmegqO
z426==^l3W_LS?&CRTWps^<=P2t^;Zd`lKZvdro0fwqgcOZH(5nNP{VHP}7KXV#nh&
z?pF}JQYHgB{7r`guoVY$!=3KdvNW|n8&?v6cj-Wa4w44&lj)riuk5ePPGKXz@-4Li
zi%Ov+euqh;9y10s_R+2_P>1l|3@M-zCR$0uC970jx`O~l4ZSWxq-delkY($4AFi@i
zs6As$K-905u|bVYn8NsY4^+U)+)wWAwX%<%T2lj1>Mr}3roe~M^york%5BxO%+qqL
zm+7zV6W3nWY1AgjfXkRL9fa$^-c}0*lM+mPM~fO75Z$CBWv#ntH$w<a_tZdHB%OS=
zUOmiLv0-)XJkO^G%<`%qvC7?Lnt%wk^9ImPT7kTUGt}$MRpFYSEJ}~`00fPM!?K18
zz@V=djUF0k-NLHZ-uZnxz(Ae{X#ipm@RtE}c5ukGgq?su41{R6r&Y8CY{-38*9(6!
z9CqZ=_xb}@Jsth%m#N<KyI7_v&-5YX6U@XquGV1@>KUhbO$ciyygrDpu(>#KX)s-r
z>uMRvCWr2}31_|JV+;`}W%e=~2|?lugkVAS|D^bnKS|k78*$)fp-7q59Pn#!2QobW
zOo}}Fap4U2JRL=Q&?BcH-)&K!uR=^vA5jbp2U1b56O`6u5fOrwSOZcjvQKWcdY}yv
znm{uynbWs&D{mKr-dBs2D+`78fxe$;oy`5$BwQ3d7wrS!SW<MNqeD*KRiOwgvtH)K
zH#*r`^{%1d(gB(!joJo5W9lJq*hlwprPfCr(Fq*6c9C|-<A}_o9w4DIjXv<YNkEJg
zI6qJOc(u0~`ia!L_8+}j@V*XqfPlh5b;a__lD=6|kSz`dWmrBRjC?4zyY~b|cr;(v
zJ$4ayCWKBy)q4`bye{3_TW-R)HguuqU67~|s&_qHi()_35xlGE9bn*{B&U`_{?-+0
z#UaG#=C+VkcX8R`XZ8^)7;Tj$BMfXPGJr9d{*dL|B%LZ_JKXdVFnFl39(u1chBlL`
zLa1sjCG{aaQc-kDP#il@)^n9tv<mJQl2v06h)y3r|L_xw9gaG?lt6)Z?<NZA^V<Ou
z7h=cN@I}H^1q_fFDKFC^kn)SMqM~y;#gYyX%3n#IZH)R4ba=18?apW*3EVW;19m0*
zCllK{h}4`L^fs6`X{L{nJ`8=(V1TY3{JGJ0R@FkGJV(JU&H%usLV8$rf3We!o_sDt
z>JDc0;bd`DqOiN0xCPlHgOcB5C6+>PWJP(Hi+E@q53+rnjqj9?^##n<$`@eiY7T2M
zd+LUn6-rnY8DNm=?&7qSOpp`UN*0eOy&d_$V~iCLka`s)z)E_%YS{G&mD2%N*@SW*
zRZaSGCzZ3&nZmXhTVoxIOsXdslHr-M9??kd7KS8VH6}rP!AnCU(P4rRdrzlqAqK{4
z1_*_gl4RHDmrBK42wnjIKPb*l6W36({Hu?%T~J^9CX*=8NI#Rva0e`Jakm1lo!o;E
zTLE_mnta(xLmsbrNVg9W8bEb4=z?#b$QBL+Ql?sNQT>6<CQXNE6)OAP=fvSqiX~eh
zP@v+QE?k=aKOu-b(=7z-h7G{-Lg?wsLB|g}0E<k?iYv=^cg4Z4{AZfXe*A~xkKeUa
zxk5{gYli_#<yP9V1A%1_t;i()CLVC}O7^7Bg3pBz*T6obNWFW8A-2%-7ZlC03hsL0
zySC<<VO3Lj@X{2w3`{z>9mLp${b!OtMxY7x`q<FjJIf`9TvG!siqGijEMXG`gqZQ7
zmb_LE$O-z(1_=N4fO$%*q|g2P<YwSJ(Th-9S_-JI$_i&pz|}TEFIG^xa=j_hZ={^Y
zzUbdQT6=u6UpRmB1>Yp<KOnEygkM~U+@>L$G({?P|0}14THtZu0}DE@KKdqu_!QB9
z>;^~IZgJM~lofb5JhBt*x?@~cX>w>un(CT<4eZBx<Dl7VJ-Fc1Ruk2gLN#hLE+GH-
z9X~<XO9gMs&aO6^)>8rd3ta>SMWClFB4fwnm0v{;j^@j|<Tb9#A-g<<MNGc$D1C%<
z<^hmX2L=T%eg@OyfV7I<9m6qFvkw62NBC%usquH8zVE_WE;#5Uzn|qrt~Dn$r~fC=
z9bC8n1)=TQ7W;`Jb^e&=iR`0gX$}COmmO-)4RW;h^djl2E-vp7$}6Ovh}IiSV=sD<
zgXbo<7*_a^nC5pD_$P4|oBLs44^!&ochqEqrGfgaC04i35c+Wjd0mWA?%d_^yhruk
zH+d_Q+H&2VB8%o$mH^JvlZr*@sc&8QIiGjyWUczEND^y$(rWEr0&o617_z1U39c!b
zP(`)S6<Puk3$y2sYc=j9p9Z>*yN4#>m;GS^Sh-_Qgi66@q!?2L8Ra>ITKAF!K!ZLJ
zE3>4Bbugto<C<65#p<95Op1U8I1i~CQKlxqeveK}lDl<V*<0I+WBX{nX?g(|^UxZk
zP-C5$XT6fsk34y3z)m_#sI|pbYH1SEzzU2<XK%PF!-)e<o#|~pL1u>fO_BOAz?1se
zPKptG*^4)aZCY=x$pWU7H~W-#zhsg%z0e^pqy`8hcpMa}9@^HDGIa2y>OpS4r=$Pz
zC!c=w>8Brm4D`bfxNnBQq4$FKA~b&kDcIWsfbprNN$>SA)V9FCX~fs>@8pcLTnU*a
zfQ7jX3f%y-6W^h34_NAiw!rQV%#O)K5LP>ZLnEpw-=B9P(4M-H4gDe~7{C<)R>flC
zU3~v#@!@AD{@8JI`&6E(A60b*+jFpW>>rT5>Vp=pk-*wecJeAuOYD$6US?EKv$6CF
zkk0^94@F}d##HpA(LviaBIgNppW3$RA@87t2Q;qU^a^fMnv8%1R2~$U&`()|)?w7%
z1oxq%e=!hrE;m$L*@*=VHeL18E^9I?Iwr(VKR>+z?7dPpv<jTxiiw_5!i1a;x6pI2
zRkqAfY>8SI4iBm{f$4<t#u<y*4N|gGvR%&GEQl<n7lRMkLYrmF2$7ncT5Zq6;LjQa
z*$@sGw%(wqr1bt9&tc0oS%Ri-6MP>ni8NdyKPU#Tb;g0BBH!8qPzik+l56ZCrZ;&d
z&g<^6g~I-A`Q}@oq7OO;^m<_O+-mYBCu_vCY=l>gE=;lm8|0%^D7h;*j(C!ReK@0=
zb$Ej&+c#@14;fppPE-OrD)zK@4PWiskZ$8)RR?ouRusaWW$yOqnN+nM(0@xwfsfVR
zRKr)J6LRDLTD{*Nxlt(EXH*!%jbT><Im$b@rk*5AD4@=4X=1)}#}L9|>{&{!6ceTp
zz6QTQjlb$Z)@=9F*#W$_LBUS&WO`?Gozy47Ft9H<H#nC8+{JBV^dA6{>1b5r;AT$U
z-$`vn08Lt2fBYYXet{v*cq8F$DPB;R*<s#EvFa^^b=;rGSLEM{Pe1k#gYDrM{(yGp
zuREE1=+;B+_mO)5mOs!rB<09AEOjBt>t64dy5grUF>Rs#Y1aeAS-n$WKfM)uXZG<3
zC6CqM%hZl3yMbL@ZOxJ#;k9r=*7eXCrmm``Ni+20v5iUf0`|rU&FK;Oa!_aA!pPQ|
ze6VE~;oQSobcM5(PrAbn?S|F$1<A`tdDB5YciW3$Q2O06cHs;-@szQ!AAV4L`kr5A
zh!v~(#;UB@7A7`7&vU?o7)~7%OKv(ksuQI}grUma1-|Ty6VFfxK13TMO*H)=F%<$(
zEV8&KaX`hwDWRcLZ+c!unKhn<{6_}r&JaI^Dpa7Ik>)O2anYRm(uJVOWm-`UT$U~z
z$uJ3;g~x^o=z|#g@FvUB&KSHm9>?ry&3bv|Ou=QDQg-77Sj^|Mcs_kU@Q)yaq&@E&
zrhz%URb^iRaUT{clSC#aIsAdOEk}Tbnz_>OBji|IG)i(;U*{s|-gBkq&0Sf%*h>V$
zBmKY^yt%i8^>#5x%qn0gUNMyi@%qyrU~mZGnL}Xsg;gbfnexWv35RosS9jr_P~L*Y
z1>C{;#1&|YrL-#`c79V%tdbMM71Z`#iaQwQgOiULmsI)eObF6EyEEp3N#2N$ej`K`
zD~PAclwkk|4*x|o&!j=55Bl8?Ulkawfr|`T2rMn002SO0Z&+0lH5WeolO0WbuR2aA
zz$Y3Klve0AI>6avGS^(aKvz^MNdNMmi-fUUCh#I;%XZC9vf?#}E!*`_m=Aq0^v-u+
zcj(oee(%qUZ|R(!E9hsIM+p||(#pUXC%DN*>2hp=b6B?YY)$T_GWbR(6n`?+fkR&d
zK)tUmCC|&$xW#}S`;l_COoZ)#mmRSENyqtKtS<d@E?*C8D=Q_3AisRK`0zQUhJ%5E
zaDXBw%G$T|vr|&D9Oi@V<L^KHOI8R|d^q>VwaWsL(eP*5qr9NCxVkzrizwa_)fl(t
zx6mS<Il;~s#>)8rZ5@khb%@8pN!524cCB{+aib-|LRQ5U*8mE>(AgaXDS^;m$PMpv
zi=vkbYFV2Y{<0k<mIL5(2?6c}hc`4`S1(*iQ%V>5>GRbth~kaN6mMyE2y(!BqOjEM
z@Cciljv%*aeU@tgXc`19D@ULS8N}bCC-jnh+dZ3#w7n5!0U__90p85pwiY7m>F*6q
zk~8-^Gu6eV44pV4K&3MbaMS4<#W&N^l``_W*-6V^)xbb^JY~jP@suR_my#s^56=jQ
zn0|PdtX-Lm3$e+%adfk27BTBNK6gFZwg@lJH}*_0{a#51krGL7rIX!oL60yJJ7w$X
z4RY0%<YKcD_^P8eI5?jNFU2aa^0o<<rJ*i`VN;{Q5|^q_5UzAY&y7W>8Uv2CYV;zL
z=wWF7sIfnD0jrCU9@)Y%m(R5<+OK7<XsqJ!9ideRX*m7g9efK5rgHJ0i<WR6MbaNz
zTZ?B^DQ(rchbfM}@o(r;B@`4kT61}Fxta3`H+F|S{ylRq_q<4<!EXBXtCu!oxXJA>
zob}_)IVHgBaK&{_)0Ch@zEIh%naw>RfRxYV2o$KY8>;33Yd?*-Li1kMPoc{h&Li^_
zrnKWk^9GDo{2G<ZfNg=N1j>A+Uvaa_MJWV<S8qr|JdyIM&{~jP+thal(>jV~e*8P&
zAUdLOoL2VFqLp#}hJ8G!(q0l+5id7K@P*MeG&rH2&yjl(AC_VXM<q%7CLgwys0Tmi
z$YwgT7qZQ)AO}OER49FWW1jF*H`Yh*WEc=gW<e;s1P4GA(j=!Xi|ZAF@!3TkiyKKr
zLNi78@PW^?&p_HNG+1h49t16!Rk!N}`UQ@i4*Ousrfe7&Oq;z|s1ABLP<OQ_cGZT8
z5j;Jje}vndCHY$E?(<LoyZEpEz`U*=Cd@nRnk>_dD7Xmq-bTAyQ`q=u<7^4hYPUHX
zw{^uZVVBj#D8thK6$0W1H^UY9t!I_=p0C-prBZi4@6AGOFQ0B>5ZYiQvE;{?p(c=7
zl%^JlLNi2)uxa3ux1TnIGBCEM>`pX@^A4Z(jxO1hGV+4phsB34xZVs>HcT+{J_AnT
z9+dn2RS+!8r9-2t@gHD22{`d)eV-)te2p1I@?K&YyI@w0Ya=o(XTuD@L4pN%DTAaE
z8jn^KU>a3sLacqN5$J1GSPb>JI|24g9)6b)fI+uWxjdopb{AUIVGt>#&Yu<k&3`Da
zwJZD9E$(Cb&2>6XL+l)!6(!Trw^UqFeIDH~R{-`op@myaG#PURmpzL#69I^Mpl%UX
zA2*O1wx$y?6)32cdIu9HsFKobE?ZtL+fA*7>7*`-YN4_s4_A>btv<R@a?F$7L;71s
zMS&K=E4mVC#J1)taZZ4FZE%x7kB`jzsIREpmt0dk5l;t=7au3Wp2V+7T|SCyAe&1J
zj=BTk7z3VzaZp(ubkLC5K=KB~zagE=3L}YaNAC`!Ko5kLT+SKa2$HZL-A1@iYZ9LD
zIFK%K2MF2e2LF}R6ZfT*GAat-EfR#K1YgL*W>+FRQ}}~j-{nU=WjPtE;?uXj#&jeV
zV@q~Tv*<}VvF-5LJHV!f{3;dfOE9hk@wb?h_l{`<3IQjeku9>U=%}J0pe*CTj^;~C
zL%tFGy?=$GyfDL|-HfN0v}>^E#Wl6~x5SnN!$=>K{qcV&J`Ir`L4&PMAOG*-!#~r~
zJr>QsJ%JK(4{r1fIA*wSTN6sz?={}orVtM8ehf(L+enipPpqw=Ksm74H7(Qs7x*84
z_;xV-3+^DGJx`Rx&6|BKC9vFcpuj=e>arj{SE22H=6YMndSWKSOwjkTGem18-b8aK
z;mb9TfrGj|@CZ|L1J&$Jxf1}t^bj8p-`>pq9@61<R$z<V5(3zrRxYOA>6HX=_e&>q
zS#SlTHg-}2?9uE=b@E`iA|MBS0yGhvKAJ&=)*nKGnvXJTxIoYoG=$kxGd$ku4<*j%
zi%I~DwRMTk#S82pM$3(37agPX6MrUL>aY2`AXI=woc_pBO%Q&vvpR_~gjFxNKkAuQ
z(SFKH>a3!4Q5}i#-6KRo>=X3e!FUD*+#+5AOxaXSfBc_z@Ew02`%Y8}xryX)BhBq)
ziWcv2FmeF;Shh3|OQgh`r6>YgUBH4VrWXqj^pJIQ>FX}_nX2E<hx!;iE>}LVf+-}e
zufi2x``mcDH3ln4|9Ic~^nHve5*;+bL#X=Tb2}QH2$~#^6_t1$85QX3&XNhRV9%_s
z4Z%ylJ(uFOb5<67xoCZr^9hBb^T|N;@EeVIHhSczPpzM8U@`ihzgVH92ws`L86k!m
zOwqBP)3z9ciL8y7j80Am`o`BI=2sMjvFrDoM1QhQ7kb58Q8_LF3;9r@7!km)!QUXs
zqpH*<QT0kAlM>QI3HB)0nvD}dm0>Qwfgh6&sOeyKGyDXSYK1+1`#MjH#R!Jh(Wz(H
zNGw!0r-Vccl{u@LN5kC~mlHQLhn)`XxcM(YHrNR{r3N@H<rm9Y(!=O^qU;PG0I2)h
zn|0=j0B35ND{xtv)hyXB{+q>LdU(;zv?DCi6&$8T&q~e^gr90<H|>XYoT^!hX)NIp
zYmd$i8~(~|{Op<EFrOLDN#8}dZs0{e^OHL#H_MnN=IjJuRDzf`P{@}ua(U=T8mT+u
zb)L>c@u1PAMqJeylf`n*;A@MF!$DpHSF3~=nv0*aOT-H=0U=KuBW<5B6qbBIl7x-W
zZ=EE}h7RhePk@}#CEQ_ZaE@nAx3!v(W*?_mtzPE|SP=F~2nZ{-&-U%H5wx-f!$5gm
zQ3(rGpw>aDx}f|gkCxNtI}YQ0L;z7zY?}}6$z0(9xS9X{;jgbDW-@>WP{}Ob0s*(Z
z<r&@Ojr$nSw=C|`kq7hSFh{j!&f@F?BMgdm!EP%oE2<)B%1KZ$DE(b7j{)cQgNpD*
zR)p{Evckg(M1mKdJ<TPWJ4V6Yr(m0oWjbyte}{yN#C5o3^>l1<X3sEm00?f^n)!4|
z$=(yrv_OKQ$yTyC-;6Y&vnU2p&}zyx7X;O2>&Kuml0I1bTvI=q{=jEs<q6||)SbNp
zp`qxqk0>F0(Y2~Znq$|P>epNnjRy^@%ao^5&5p_s5qpGN0q7g>N)F(#L*{~Pv=>_R
zq1{FGuB`^BDxiavw>C3^(gy4g{$pUDXWwq=^s*tq(suS1HsFTR(+5=|aNos2CO3{5
zFc5hruuT$aycC1OE;7he!<kE2B~|`Sod;l$@-FQmj~+(0=@nLKL*+FqQEMR9xs&-h
zelqN!rOB~AEqX!@UOf^@p6&FID+}y`YGD}A{49YC0!_@9WfiJRrnT(Jf!*ur4iF$-
z?X(?~=Xwc!Qw{C^m2SVZsDnW1ryRHy$<!rSaU!1QI~y{lh)IgX7A+7F?4sW7s`<Rt
zDj4VlVzHo+&zzw~7i;*nIH_XYm;PP6f9(Me1HNA&HTo~~PyW}J*hlhE{ZwHQ;0Y|1
z-U$JVuQnwlIyy<;s)DC_m4g#}U#yVE1=_DIIaU}qv{NWLZkD#}`dSNcx+Rdn__a%w
zjsZ!Eo#P9$aHBS+R~7tQ75LN65>T&^E?`;xsV;&}Vg&{;dWhy>s%UR`x5qu@alhSM
z-w&Qyj(U!-y;!ph-jhWs_RqDbDxI>*;$&IvSt^L6a0rD0u0Bd%+-^-D(-(}(7r_zs
zAjYFBZ*?QriSeF%@)(@@;`qD8hhK54F!g(mNOoOA&v+$0W?|%P)6OcKJ1wD01krw(
z`sy?^$v=j!K8EEeVXY%xMTVk6|H!&wh6sm5Y_^9F#<Jw4IDS~b*dZ6!b0fTdiESpx
zTq|yT_(KEK;l)qn1J*SDD-9#;u0p#h&dRraxdF`{z^?j9oefA3pXCekZ^egSdjHk}
z#PEn=8Gzh=ZZ8*tj_*xKw_ds8w98V<O`>@%<__^wH2c}}seEJYJxPViI(SeshBJCB
zAzQFB5nmmN%BK=gQ*cd?ZrOIBC|acObQ}HSP(Z!0;8G#9LLef_*>~n$82QO6^y7E1
zbH4*aHi^iAdef1a<2xMS?;sI2cX1|2*h>HTd!N3Ls2a9?4}DvYsy$twb!qIoUHroB
z%Q;vSSInt_H;p7!M0zPEaYAOz-3b%|!v2zJ(j<PQzy1PPoPP=kYQ15UZBOe~K8mu7
z+Bb1FPt(q8>3rT4nNHhUC_1e&2xdXCL7CMqr5Cu*fJmb}ZnB?H-7tXb$3uRy81qom
z@qZQnDgA(~_5nc%u#KzlFHCFKF)zwP<LQiPVJQs5Ba^z>7Np0qFYNbocEgBz&yeO4
z<IhH4t_nHrGQ31E%2%;|mmao-rmn(d?;yt<3Y29JP2=V*?%Ld(;3MRVx|%Ko$roT%
znK=Yh>YS&$%^a%`%T+rBm!_;$d=5TC4@3cf^=dJ`DlWbcuoUJ*2GmK|&tl1E&8cGV
zg=G(JtP6#q62Fv~kjqxkULb}A{;=xUEAMOG^4r<}T(0L_cAOXOAqQt}K|$H>0+F?_
zx1c;udRgczn!_7v<%dQ^m77%wENWENl+Q?3rF5+3;x2Q^@qk?GFhd=!6CT}q{T!<A
zx7e(|7K@9owh%Kf&%WwjIn^h+<Y|9MI%nW|qIH2d2JTB-Jn*uljes*3a!??@04WKW
zVNGp>BFhXw!P=)k^uG=D`!W~8)(>1Fa&%ZtQKukIWr-Kt&4+S`R&?MTTh0VcI^2__
z242B4tjF^GfIqU2igmI2+XP4Yp*``z(vH^zP@67mA4!$tp=?f=Y7c6!unCK;aO3ME
z&TWA}QnmE)^H0Amd?va*3n+@ul#_MQ0z4iEwF1@ap8`M5sa4W>VxP*TBiftZvy>+=
z93a1-lh;KrFiP^Hv|!k*`JuHUX9224ovgB|lB(iCGijk2rvF*~+8#)w)WKrVb2(rb
zS7@qe+D-3m&+O$z(sm$gdfKy~DmVb_1u^-EN_u;6p|+Igb8yr!Seqz+B(ap5kmV|5
zmRBM~N7Zx<9C7?=j(N?WKvYT5Pnqi;TP8@#Wc-B1gM)U#(g8jOplrHWc0YZyfhW<x
zL~8=Q+0&#Y$)BdVSRdm3%R#;u>|XnlFtWBBQ#@*a8dky)h9)~2sv(`b>(#n04LuMi
z6rK*UJ>a|yF&VvMvpAeNOBtqnCs1t~8l+ILgki{=rAGgoc0AJJk_0rUrs#nz?Gvc{
zIe_#~udDL|Yk_h*V$!o#gEbl`2;Z#Y1MqZ%Tf2sf3EEqQBZl(cP_EJ30ws|G??^PG
zl$x*|?I0E?cu6u|l5O(<&AargokHVhyEj!txNb?>%wphoM2Bb-H_Y#pqf=Mt6{HXv
zPukt2?;tZ#ly{KS8*-cjx7@$#2+B{c%op%cs&-%ew0<2T^`*bIH|riknq;1$_JoTN
z##T$S(QNuaa7%-`20Pd;Y`$oR-A*~qqqOY~O41dFI5QB-neOceIIEWwca3<KJE?FG
zWYYkin4r+q!47Me-Lky{)%!rdNzj6>Q3FvBeb#4>RaqOvG7Hu})m#KE?BM0c44jCc
zn<HrY>zHYwiXX9Wcr-_YYx{&!u9(Q|@(%$ZnLm3pVRF938WtV{N@0M+B20>Z?ZIwA
zXPlBfgr_V&#X+%CzxSsRTK9Fhl-udK<|na%o;(4W55d<ZORrPF9Z)6Br0PP|ZXfQt
z2zYn_TC(9L{SN)Pl{Q_lAKTPLcubrq^&c7nXDIdrr}_($bX^s?q1%iUIf}~#I(i3k
z<~dxWm*&C1<@+rNtm<4P)ldg-wE&BHs>MnPO2GmO?Ic4B>4elCL4945HXH)GaN8&+
z{2R!v8l5|-Yg%%M_TRk2g;{D58+Z^lZR0f7L)Hz-Eq-<%)8aqi9Q~9veD*}?r`&4q
zWf=pi$lQF)d~N9&J~djvb5K$$(Vy$8931ba<yx{y2=`oo;qgrZfJAKoRkc`03IFva
zy>_vU)K>$bL3FBij=ZYqxsQkCETTx@s4-RCG6m)3pf8-n{@`2V&v0pa>;eLxw<SF(
zs|)Op!SJxp($+8K%!&|nOFKk^zn-JbDfAdR;UzxvxH>l!8CO5KBc^+cQ^>1`#Mqy|
zGlau#{79N43p2;zFL~OxJ%nh%1=fO>$a|$}bl|6N72p1re<yefHuC1)Fq#LBFGvz+
zD13TGXz@#}Fd$|!vv~sq`~+I6AAJyfM>Ip#4F|>Aq}v`5k0tEq_ScF3^w2y<<1_>^
zq>42UZl?FL_h9i=^jpi}jQ7p=J`F99v~I=v4eo=VzJE%nhfw9v?0n6Pz<L5o<a8~D
zDiXw2N|>^5ve;QiRn07}p8QEXSEc!-4_~3#oBgwQWUPqKSO@w=g&^ga;Tq6>vL77n
zf*-g7obmMK|DpKsYpZ#NB%tE8wOxlB*b@tWTZ$G?c0jzN(8hxz;!>!}x~DDiouI~O
zD^M2)HwK?sTsQULRWm}fAsW|G___4~xQ;ZMo>4e~wI_jN`!;qO1;QjRT%(&i*X{g9
z2Qr!UF+CKeEmM5m-}(2bW3Py2aWN*<_TXe&C{HhowCXt1jT)5nV6Dg*!dMGamkbg+
zmuRXvB(}Gk;dmZKF&hkX_^GH)fJb>|EG`d)pkl4M0Q>=>>zf7a{{r(L3N5`PfX0dN
z06E#==$;Rb57ueG$?h#bk$;n8>Ne@p;^Sy!aTT*k0totN@%7*Ept@37*0OyqLi2dH
zfackL=yWm$kSR{2%Zp(GD<tX;(6S_5`|o*B)gmnWJ5U<BI_lz;A>uRLw2^_>Aq#}$
zZ8*mV>`NEW+d1DBj-DR(crPMg)CU#aBx(`*sAq09BWP@GXpuZ)S9PUtAiuZT8tqyB
z`E)qQnz=`RI%VGgtEwpb#wqm#?8itcKi|kyswg1v*l`J6>Ui0M0J6@HwEg@~Kv^_2
zrFY-I(C)|~ZvaGT9k|5UvZNO!a3%J?Q|Qpt%^ZSaPlz8Y?HtsMU>ke@eEh2T^a~3j
zsnqk=Uigyv1v)zOl2$^5tHvPHnl?;G&$J?g_*_T4Zp>|N#S2&GR{ay~)+#%XI_vgS
znx|ZKXx7-lo%DLv@%~4I#|PTy6<w5|FU5Np)vrE$A@{^DM9<PsNoBdI7gI_y>Xt2k
zjg68xixwv@0OLq&U@u;AJZdsq@@wlGU1*_mt*NvMRNU_$!7d&B$>9RLo~PG<M(mVL
zPmhNiTg%E`1d$93)E^|UU`SrlDzxsR2fJx9@}T$D0jrfo@j;+~8p7I?1-IVmZmE?R
zsM0<Fo{F^Yw;{y)=&`p1DDe`;YSd-$*L1`4w6tx7iHF)jk|Xo%e?EPAH#@*f-0UG>
ztnlI#rF%DpoI$q8!)nfT&NedRi1$e9%UQ&)4aJ^*ddREwfiTsmCS^tF7j@3k07RU>
zNISZUr}ma4LNS?iHa*cM8|PfjdMe3Yes^PjNJ>@u*pF-(W;Lpvs=j=R2QoeFg+7`(
z3Wp{OU^W&d=59+{7>Se-#qKjnOf;pdjb-~qSEvh7Ih@s=)sgoX6*TLqy5MhDtQSZ>
zw00G*G3C8b`u(*lL80<f=x-A7f*?5zhFnezl&lFfjIkjd+zENm)}hMqBx&1pP|BQO
zz}bPsuKG*p*$0Lq_*9QmdzbR_+`Vc~hnsKN>$YSCva+(ctb)tO7GG(8@fGPZR?iO&
zTeGaz*!HJ#>&Z8m6l_2L@Ok>*;`lFCLv4WMkGk&n$*x~W7o>HdR<X;T%g$nOV$+<g
zqAX6sBjidHBW)d{mO6uLDMR){ckG|)yT}5|RNbh@0TjFUG8U_<Wl!&<29;pd6^&6J
z#2>UK9SDEdgoduaiWC)Wwk_=87zQ1_j3fXT$M{`nJs&K{S7@G#C~Vcs7;=DV)(!V=
z2R^dCk2PksFOq8dalj1I^C*)ZI~s7BC4_TGEd>N?{gvk*+`KI@NZomF&VkB)T91o+
z&}|1&Y;TXqzQCik&JIch+e91dr=RaE1Y_rQ;@Bjgu%Aj87h01ed<|KH&^~*x%IVph
znl~xASF_~fxs;v+P}2c^LA#}GTv2K!6+$2@XZ3Jl3ahv4QI1eV8K6`_H6UW#cNQxE
za@Xhsw-(uLP<?Tp&Q-WzF65cdM?yDxPhpCRYkKUrQakYmA0FcuZ1X{fA^slZeH<L!
z_HivJMWAuce6aR=$efoYrI%^#)MyFu5&*6<8jOeL>yTmpzB6~z5}%S!P4bQRURvx!
zJ9AV79R<H*4;?ikN{#MdHgqfQc!Iln&_JbI^nU|hGZ#iv76&9cQ;XX&Ov8JK;FYm=
z?jS|#C)uL1Q=&fn`ZyE-qBR7U;D~f+1%8Uz*^YT>qXO@U!6U_f+tmtUS)n6lf&bP;
zu}JX2>FJA+2P^~Us6?I$!iaI$<Alaf`kq<fZQTb>nx}iHOReGW$(p^V1Z2178MP*G
zl(D){aV$X{<Aq=+?jmy*OmE)6p-Abi?DD^U>m=|*H;(ANpnebnkTdoQl1gpu4MFN-
zO)@4PW$0D!uMN5f-sI8^g5{TWrwO_oi&J7qL3i1G8;q%UVLwFPVyX9?gZEkHW&tDr
zQDcpH$^ttxJJuM^ub5lGP)tK+3}WLyCd5<xQ2XxiB#{0lKqGv3U4o?0mk5Ze0h;i9
zLt*m_n|btL6QGi%Mpv8X-wE5S*sIWw`SkGz#iu`<?8Nz>L2ZzI;i>qi8Q}y_W%g9=
z-Cxo-gIK9bzqE`G2v@CiwVrv^+%tzu*=uc!^Q6KTOas5}eL&%W#kOuJMoz_WS}DU*
zlE;JXl5iut<vm%tmf$G*($<><z%aBMF40899D_~~B9K@Rs1G1wpDj>HPRE<fnJQBI
zRJ3jDv7$Ji6LSVBBfZY@4dR5LPJy=)5@cs=$rv>4+)go1Ez{i25#bn;Emoa9x~yGO
z_R-~H>FFR4{D3hZg_A=^)fvR$(A>(N#j((h5S3=zkVY;({pj>)&e$GrlQyF@zGwJ`
z($oo$EgC2Ydwar-bt{G-{u0Ya5fwBirZIFW_C<C~MN?U#gltz{rd-LKkCAzoi>Y6F
zyd+95{o3NoG)I{I1CHI9LI~WvT9%)<A~~OfvoP*(8HzzVEn~ro6Mw2{`lKPaNQ}(h
z<-F6+0RY_UbZv&itPe_3c|>)!KYSGg2^2x~VSE6mx2ev~D3Iu#BkC?vKD725%r2dd
zd!o0)Ujb7csiI@mRCgp?Bt3NwFk=^SKFjeu*?Tkm`ENWFY#-LE4T%R3hjDn?@$^Gt
zMZqk0+X}lEbVdHjT8j=?%g#WnqR?5BxFyEyhl)(r4H{<3#e4Puw6*V0=Mv|@cdBAw
zIShwQ)aReR2Xi?7BN1k=Qw~y7_P;3?v@cgO;BHxPa$LKk$==J<2CQzw5@YiN_n#bn
z1$PAM8~9y)&E0$tnkt+QJi?GlCu9NT2vq3iDb*DUx3TGR-jsx&dqgwqS$SbRV0J6m
zRDw{fNVxHFFGZE8S6NrtjsOxM(ZlH^Xnx)t0V(HfPcfBQB=HQYH87h;VkMwAnhp-Y
zg+uM8?Cl44X(Ky}FUc~@vm9Elwbqu1ATdwq@MQIQ^NlA%a@H#XRcui?eGLmF+=g8z
zXe-YYL>P2^tA3CAWIi(Kx1$K=%Jt95d)$$zJ79$}au5~|I-Kg|K@h*wb<J;Gw;gP0
z;cJQc9j1Hf47}-;+h^#r0~dP0u|Tj)PZ_FXI^A1<Sz%ukV)CCA(7T!5AgvQ~>BO9o
z?hbInRJX&XTQoYX9(}O(GX%ty?oo^uyTzF?UiDnY00Louaa_tm%sL`s58U42onl3r
zj`I{YEvN~~dEz4&1;5>wG5e-vTg2qYD=R^qQ84uUhM;^A!4dgCfB*y^^d~SKU;JjS
zBcX37_q19?dUB^V+^<td6jT!bQ|tGYpE`S4(*;ohYcq#+RNVs6#3PQWJ2*5kdLC#p
zF@uMobm;Qh_j{pFb&(E*)o_W<<Y$LkG*Cy6;Wi|Z<kJD<wLRnK9MW<N<#(vga)Fk=
zx1%i^Lf3tdwOfh3OY-H&(4H{L_~Um(LWLYd0;~cQwy95ONwN*nSPB@g7XC+zsi4rG
z7WkAlx@8<Z$XM<$D&=nx!*-%7RQgT2b4`7S>eqXWP&{dc#T5ACFm?C%xG#*q2PrwY
zw7NlL$3b#n5p<kirj^U$^e<Fg@(%<P?D6#O6~GgtJsrSP14(*iw%-J&%DUmRXZsyL
zp8E7chP?zH;)>0Ar`^*L!Lel&u?CPe+qJaZ$fz#a4vNbVzqiih+)cB<K(46c`=A;s
zaMN8*I@7B_sK^yPwGJIVaKOtz^*B35**lsOt6DuXotPy<SiO7bE<yL{7wI94Adtrd
z|C{dfOT7i;+=}u-;%ZEAREf&_32HHFABW7KTo5^nLQ~M)jV&2~Zk|HLwPK@5!cI_c
z&lumeuw8UQ7?zhn(^*;DmrL-etS)S<Bu_c4=RSQ=R->Y<rkxcs#7%Kh34RRuhDXx@
zt6f>yPmFybb4x<^?65naLb`MZF{l~5QbjlLR|dB<E_;0qXctmG(vbjmUU$#VAik#;
z^7nB3K(~`1ov|BmVH5kPpJCmGp@~j%dGVU!V2hmK=p9B=PmK)eK8TZZ?fh8*ZN!b6
zy5Z$`#fad0=<lDYk)g-2VZ}I2r*9R1mcDw^#L|@J-YDnOz#h{~{^GwDf9)SvPoBuo
zW<I?%5L{oLG=XT7S%E{O)}(qffKM{{So;OK8eId#!G|AWcCj5+&1)GHT}p2El;tkF
ztj(3R9M4H$?Ycijlz!Rk&>RKdBw75thtiev%uTA|fv`|NNx^8QaK?NBF&YfF$<-30
z`SD@6He;W@fVhdn(??mc+#ri<1sN>Ju379UD=zLC3;m666yNw0zm#)S)WGotsmaeb
zMqUSjIID4=;mZJxzfLyB-ji9{I1BT5Bj+NWZ)*=gAxR$2$m@3%FOb#HxEb5_^#Bao
zEc0yPrAOz>Q(M&0(+`wP>+T`GGTn>V=|4I^=_amFp?oBSDhy@_$-@@Znp;={q~i;B
zyDn<g<PYiDEKp6=ZWVx})dWl&n@2KTjw#rcYrQV!W*)r;WXWmqVgsr~(wW&I8V_d!
z3~?lDuJaj3mD9znY$h}0{$N8%ZFcC-ujtB)S0BYSS2fVF3)R)9M18Mum{s62tiDr_
zo_3emSR=os2QuK44|8h#HxV>yD&cFF0;+6Y*F~C0riJQz1i|V6tx<fl*nYhR`bX}`
z6(pJ<t)uZS$W?C{aNA@ZStx*>xD_a*%1|G=9*_|ymI`->M`C_FEx8teIEoexE3U5K
zb5PmdQ44u*u0M3K^p4fbQA)X9EAZmKzM3FX!E*X%yR>yO;0`I~Ks;Or0JKpf*VO7z
zT*dZJ-{=aR`zjH<pfDhr0v@CSxL-?;p4-R}fonybupoCYl~?VNYAewrL7lUf#DEz8
z6)jMzqp^Sz3M`F-^XS(PH9lt0LZHPU;wB!=ZG<kbzQ!cH5+}|%?)|j*@C%Qw38sk!
zhlr6Fl<pV~iP!y>eM05Dvqna)>E7w`f)H*P%ONh-vSm^S49;UmFj1^IE=#&SQ;<QT
zeTGUaNRgTekjmD?<E*VxaN=`|;;2pwzl5j2M+zrF5pGKeG)&RgTrMQcKJ;|0y1=-4
zOw+p|gV<e<=7)v<;@|!I%dk>hcI(YXvWYX?-Oec;<MiVD)H&5wk0CZz_CjARo4!fA
zg|;dp=~<~V9rXH>M8U!4VZu6P^|ek7*O8lSh24rof0dhL=QMPMlkl3cPdd0Gttfq5
zT%um{IW0!&R*FSBZj$-6Mgrl-o;@uG3mL%n`zft=t={J{tNY!$Vp0zNy>f68pmO^;
zsC8Q-Bzu>IYa*=+><e8<uTx_Lo~yL$1L*62Jo$)+g-H=zv6JnsSG91Ykz+rpxVCC2
zPzmQ$4aFh{VY&pkE^!*yQc}OtQL14Wk<2sjvOCa=)=;5NqDDVQu*I+wD?`6R5F5Kk
zS!uaOX<!bhTXuB5Ia=hlqocvH^X;t{`H4<$D}Yj|e6p?^%JUHQ-y~}t8ib(X3y{{+
zd`WhU#Tg@xW~A&8jh{oE;|*UIj^T?gC<boYwONff!VyH{j0P%1{sbP)nFIgyUo5Bw
zV1C58jR<A|uF{J+gWqFu+y7i*vr{Zkm85-<baOG52|UTG6}TNY^RYr4V>;8ruF(-S
zZS&Ml9s2anCkT~vvdR26%cHJh66)4g7GQ*s0zz}IGS87K<xQ*SuFs#lMqM;PaYdWU
z{@~JyMWbwFm!pQo6WhJ?<KF-rZQRfM;$qh4P0oKShA!6(_ZYg@Jf~leV^hjH`q#&b
zO8W=lk?dS8dI@Tvf#T>15|+(+Q^+{!Z~wOV+rOnxub8z5I(>z;6YRoLkur9u9=xr;
zrFo#llJ-@7c<&`5v~4Z_Y82Xb+^Sd}B~924<~tP{AB>jU6Wgf}uPv^vosqT!vn?hq
z>)`Fu+J^QB--nlErGOCYMCEOCM|iu^;8ul1p99zj0uB@gg>W&CWdaUkkFFk=P5#c6
zc+NabVA~tTZX#fY<tjE)$_2x4pe3y6x$(bmc_u<?Q}8h53%B{>#AEVB9V8<!m-OGM
z=*oOJQ{}Z*E|{gVHq(Jh#%sXBg#3Lu9?Xy`Z(VQGI?3$l$qg<*5g54b>C#A_Y(cSi
zS;9g&(kl5Smgi}zVXqHPx9GsWnd0j|e)w(i>8E~mFvmORVQbZdiZh(J)}e&*dEbm<
zry}8j*9(~`U=_0j*&37UnRdh>H)<hf%HlTX<7S(7!*QLkO=`>2XNA;$cqdmRStTb}
z)51fup)|DUqCE!Iqm|mBG<+@Jio6*sUL4127g?+nU@vQRc`c><*I)*%O>ljzTXT+*
zb8^&SUoJ;cho(vl*Ggx_#~u3?>8O<U#EA0V-f3T)r+pb4uosE)+OX<#Kxc<J!?Z}L
zR^2!BoUYwrTn)7Keicp^(q-ZNkyRTo-X8+xBJ$%rL!cE@<Vnj`$oPfs5yUC(?lPWj
z#w}S~{JUkxg@M+Bs0rEg!!Zen^=wAH?n|!I8(*}hXHCy3AmcSnRUR3AIcsrZ6*^(G
zGyOzG11V1(RMcp6KDWx4l$b2KQ0hiEtG^PgsHm0&8xeaIypOxjDKVB0=OHjy{KS)P
zh*HFU6u)hf$pc&>9v^&A@e?;=rkV8|B2YpVEWRmJ5-cIzvmN@(#lantFBf>jc=iuT
zi)!hrTN9%bOREn(sO!{Uierkkni^9}uw#T)C_3L0K`V5S#@S#$)ZA@Z=p9QQC<s@f
zSr|UIU;q!ZB6!^pE(AOk;ArFX)EopEV8->?-l5H{Bi)ju7v2%)=0LAYs{H<Kre*G;
z%0yoARIqPwv9$Kvu?x_=w+D2em3T|(UQ~nvOFIFiyu6gOkT+T>li|&-ot+lCqEY%E
zwX=o_DZnw9S!$Si^b#cX-6~IwSsGfIUdRqQPt!pvE#!-}WQu{zTGDr_+oGlz?b}-*
z^OqdLnAEVcJ_1{j$q|wVH0y`&+o#bl6oLDrG}%OKjYlf(ZIl+fEXj49Y9J?lK5o(f
z%||~q<mMOqaY;kvvKtI=M+mvcYxkDhFo-OwR-?)~P+aM|CmH<s(c#Pa|Mkz}|L+et
z-6}b#K?}m0Uo2@i+(Pt~kgix`g;<b%u_f$|1uo2<D~ffc2PN{(iZ%Llmt)C@QHF0E
z@yWe*ij7N}<h`j<eP->sbF%S}G8pX>PN`-cXd}{=4<gixknt-CSBw43dfY5qYPO?X
zJr`k%Ie!R^&$S&AFd%*Jp5qKKWzZs~qa=kMXzNVqE8Cq0<+{fSTj+tghgG&^;}q_#
zyTGMupRjaRp4m1#?fS`~xTuNBFFjcH!eM;2a~TG8CTYY&V+ILGc%z4vSqaNqRzx3B
z@w3xl_^7W95?WR{zLrbfgeK|$h!a-6G0>t&NC2#^8b&3Gq1HYz5ctM7FulhAr9a+^
zy1IKpw<<WJEk^Bqt%d!8U%!~~F3no)c6%3`p!7vzkOY;g(v=JAB}~backCfaoD$F_
z=qPK)O-VU6*{%GXY}WurK)Jt9y9A>#uM($zAW=(WQZNkD)1Q`FxZ|oNk5N`fEJN*I
zh@welD+)1+Ta<yXYuH3juS611uAsN4xchAEvm+Pk+|YeE*!6%tVSs(2;(ebbd2m38
zkaSoRSPagN{ksppFFyV~V7-8?J)P*KCvFLa<Wc|B(6fpL_Y83i__W)zfE{4;6758h
zcwH`gGWLnta(C;X@(1#*v#bi2Rt57gp<hLs9-@XOlmvTu`aw6e0}qH}t(GhNw=PqE
z%k*FS+f7zDRTf;_+|3`G)M+;?{dRdR&{bRRY;}_a)QDY?`+S$pwWyG&1mbXIMJspT
z&5Fu-C`=7_N6tc5QZ;F|)kJ~W1<)97GI2rwn`CRnrn#VJD7B8Yl>CQJzZGs^-N}(<
z4Co=#Qs?-ce)U<Qx1oZRQ05uFuQ*NKsud3c6Y_kNJ|$er14lMzew_8n-f}mOVg*o;
z%wm7h@Sh{<eW6P8<glSYIon-iTy|dVfR}M<DBLkdgCWx);3Czxx#cR!Y)wBA13TK!
zT_u^%jL@C4n9fkXLNvs)4LaNf(`p4jt_IaPqiyYIjT%iARPeBvwznQ2et6c{Z<c32
zEF~~9!6PSO1ts{U>$m0PSbZdh0~7sspMIi$DslhBKlwW;AWrEa_!@`l(queO4USW=
zPlho0^j#%ybzs*~ozlch*T=Oj6yv*~VQyQx_5LUCbms6C_|#9Ze2q6USdT>U$}~Cy
zQY?%GBXrM!E@=Zz0^?07Sw%+cu`&&72@MN}Cq><o78fn*1*)^(>9gPKOm#{`HIBM*
zS{+62_PYL@P;d0Yv}kg<ftAQO3y(oe!j^(le4moGL8)tSxDniCH}N9Pq7pEpHaz3o
zGGlyEQdnV|VrWW+-3?$W2|Y;!>d3wPUGeGHk(81(QyxQFle{G#W&5qxIXpvyRj!j?
z>?5fwg*3@1qo_%AklL#oi0+IH*A3}G_7sJ-d)6K{)@y_-=L2QR2f)mBhoK&R4i?%x
zKMNK`4_&6p(v?!^z^TjCS5%6VKIS5BP+2p?z*opM`DtFVP;zy}zeIU$?HXW?ea44R
zxk)@btmIl{T_B_s@^m%_{B$b}P1uCEXaMOh(fL|QJN2?&T;vY|xq)9Lsy@YnlAix@
zX#ZQi&Rgqg=>fRbjmUEU<iII6A;abQdVRi=hVK3!y54O`lIyw>e2=eiifS9Go5TlD
zYEu6(CXIQxdqjAK-{6;wjI=SCTAUB)$8MV!sQ?lr0TQ5ig8))8%S!xL@3qce`*>0k
z+gd0TsxmX&&)L^?0Sj@GBloox^5HpZ6>R3x1DOIe9~57}R|KZ9@&nZXnw&hV>54N%
z{rwX{#U_kb>1u0L+T=k>%hiSweHd1v%oyCled_>F-3xNiUwsZ3Ti_ey(3(hKGjQk~
zwNN^`UlI|zI$OaC6u@%CY#!~nyOOGWOc>PHVDb1)!g&=-_JpF1NKH!&du1njThGn`
z?YfO5rhtJ-xGnM9meC1A7@Ep9OOB;hkYcgsAl}DJIju`Ti~?{pw__Ry4M}BFel`?Q
zL4k8AB?;G&9+-9q$INF>d|5Y6Y2R2_pT|dupY-E16zN(mM)5=dA*zMq0m!56sr==e
z&Q)e<?>~F_q<DRYr8w0wj>Yl5%bb-Ts+0BD_EOMisMi9NmgAr3=f=}1Z1f&BZrR|l
zx@mV<&V1$jkLExo2-MAwZ`8YMIJm${ScI`TT#vBHECu(TV_>$<8|xmSF6{6t$V`D(
zbyl_19UAVfN-J9-{kVg^R;?ZOVXyLz{h5}ScIkS5AN?IfgrLkr^OF0J%P1X`$6Ol?
zd%4wWWcdY36+*OCsZK5hJgb8Wf`C1@nIg&$R4i1LLOIyO>z8{nTnd~c;lbrJCV_3N
zWV|a*0;<hG3i=$QDN9ZEkz!{BH!eUtu^`60+v**FnZ#a2Pz*^ez!}F}BE!V4i%9?`
z|8*OY=OLLM3%N;;$q_cWC#=0k>|*Ta8||3@FZh_{#_>mool5RW7o<GHE_O%05D<~N
zx3538V7C+O#iD%)#p4U&L6~;tjYdl?0ly}1&>`0CA0B8!W|di&XB0PyI7X@NdsE9f
zfi5IZa3|dI1ymH43_H(i8<cC3(qGbJ4MS54OeuuGM&po3@C_DKX((+yv`g#G3ZV8w
zj9w)zT51DsBe}(@P+A;tVXPvq33ZqN7qF|gW@1|3$RW6#+h?S~6%`SQ5uH9qO{GbU
zEA2B3)Zk5_bX%kk04@Ae+0J*Yh5X)(C~^wbuB*%$IlGHFX$2Vl09D{A%e2}TIj8N9
z8?yhlc=_V{DMrGZgnL%$0sg_20HGA}`fh)7HW@vTSEV;$S)vF+Tq5fR@eAH;ST%<S
zUdB4lI8j=klU#oIlR@4$Kf>Q%U5lI~vNG%c9=ZELQHgRcG=FCrHlXUzMjgyMBK0lU
zK!r8VGuw8_9JE&ZCI!ss?l%fgOH}r@8<cS~qq|+6_^j1T-?JM<5_x!&-GAYK%br9w
z69o)R0a*+oduh*@kIDbsc{295fZN30*S<zNz4H_-q0_vlkIi__TKE;^qkU#ZM*$TI
zVU~K!3gv0<=xtZ;>%6)2m&t9pM9YYS3<4*vU{%H?RO<T3L+;M}6m%2416-rn0(RTe
zhVwp`Lc7~r+|Jt`?_N@tM0?fkeDSfO1y?(W!wx}Pb#2Dh1NG?}z7wf#GbkGZCU@n1
zjM!$E{Z!5ls`YZG%{k?PE6DpMZS9H)*@I_x3KVp1jbS;lu4)Xyw!kVmd#)ARfDwAA
z++hXf+1O6am-u;5_rUWfs2&;Dww4m&!R2{pf1bd)QN7=O8jvEqL^MLo8U58*$5<Cz
zhpr9>0s_p+&IMg&+6zj#lZ7)q_X3ewoPGOW?ck_$b{!fwq_gv`{qO;DBTThhp(v{0
z>A^qG8o*c!u6cfI4c{#zx)6^tEYZ5Ud-3RZ9$6bp&`h|$q#_N=;)XT@&k}=Rw5Qc=
zC2^X*?SNSl1O?-g+V19z5e#r_K!PryK8ky`ciK+%gtfbM{te3?zQzyf-L8F8bOUXn
zKcbEEoFEfEOnLYEZ^dhJ^IDf8mjr3NQCs3wYsfZ7QT8KET|Ux3b(BVO9D&^&qb8)#
z(k-jJqGk{0wQ^X}WX#i~-I1#{Rs+ppy6l^C1n-;6CYjVz=->#DyB#HDxEwvZMotd1
zZgqbw1X^RL2dpU8#&p7Ih*uoyLr6VeW+%N`&GQj-Ptw%SuMxEyLBW%f3tYs6&;&hK
zpxZHQ&$|d7s7dVgW37Stg0|f)z}(h^i#3kTa2CHTqZo`q1lT{T!wQm*o~C719$78f
z>%D!B3;u7e83>@G7pRYg^!Gc=ue`e4?}AWw4F{fmQu3!nLK{Lh?sx~Cv4@<XwRlVR
z2D>%kJNX5Cvv*1h0;l0sZIb=`6Aem2E&M^;GKIiu+frwa*Rp_WgB5VtS;9)x15BE%
zBJ9BMQ}nL{r1e?GtQl6qT;v?|YfTq__42j9iLH)e3CiczOg5gRfjO)s#NN(*$RrKP
zLPH@B`Ro+73!X%9@&YMj5AznVJ^JUBI<^;-ynauLWfPL6)HVk#kN?3lvYnSZkFnM&
zJ7`Qu`UrlP)(OE<U_?rM;=sud+L(M0>2|+WR}F90A{^Q8R{HyX0FC$%7%NOm)myd0
zBf8`BE)f@e`F_@|c(`f;1C*g0n|VrFMcT&^VBIIy#MppX4`#QW2B7{oXU?|sYTr(N
zok;|@Q9Z=moJlVv!||kgP}2#lzPyN{h2(*?4Vs8t9USd<{EF0+R)K0)IY>Q}J(=F6
zJ(mel_K#t<l1?wsat;B*L|V;uCF)M{Q+PY5_^NRE>-y2ha35|v&+cO<c0PPYYVENS
zy7w1?`TjzW^Xbs=l7bNz0&4hq0lbNp5`gSryh72`@k6OU%iy-Kk_A!A-6v4A$XX@*
zsZP+M)UP)f19ZjRamGEh`qJTQ7Sj0xu-t@S^w0<&-2=XHEO-7NzIU$awX`gGA2MW!
z*csT_n$8p950<cCw-9IonI?>X?+u2qJ7I*&I4_vJjXn<QBe^2(Mxn;ZXuJeaioS5P
zhSsff!b+yui=)MW7>3FZ1Y9bxbTDqBmeKpqUVmZ%^!=xf97hckE3dLfHb5MtqeOm#
zKXm8`rO~aEyMvV?I?^bWmQl+BFt1%G12tlMpz`*iwoJNNX0&4XL0swaE$asT4nVG#
zi0XAqk6n*l<Q$aBVqs3YV&yy}KA#?xFLUk<J|70TR*eu5@+cXj@G(8MBj|{V##ZS%
zEMx3JN(e4)7q-6>p-VKqJv`vaD};2rcfQ{k2(cn)0n7}3jDcC*!u@rrHpyUFYCZ>A
z%PQ!N@8|GA@x%0=?NVQwEbeV}QF{FJ5Y5(rK6<9^1l&8*zjCQiZl1xc#<JL)q{;JE
zV;+wgGrZBw+S5++RAEX-p+e707d$z_<B59Dvh5HCaTEmS0mI&+vE9jzeIffaoM11P
z2!ZjF=bSunSm?oCg@pw0W%)`%(Y|Bi%k>x)>;*ME?wuzq#{EW5t62`;D!!YZ5dgtR
z_1GdE)nXw1s9*S-;{W!iL$!nSvq01#X7n4SoToO~_t-Dbq`0Y#ZMt^<tjKtQ>q{xj
z+mKf;Q{Jtmd#SnA23*g%3GK`aL4)xm-7E`b@7f-oMTo2$>utw`L-8R2-`mck98-H*
zIB7p`t<qx#x?{5FeQ5<UTjtkx<+gkFb*#P@Xr5EsNrC(tO9Fa|_%j@Uoo#yn^YV&q
z^PeRhn0K##C|-ZJOM)ZtLQ_Mn0{M}k2w%Lke=LsJ20JJaiN&5Z=33Td2QsF|Ea+I-
zt-A^OaLX%#iuyvFAoW>MsKg~b;5HD6-@uy+>0Rb3c&5%Mu|mT|$;O`gR@hs5I2f7|
zsx0?-9G3dYR-LImE3L^h?qEZsfq(UEIg^FOj}l|o>N294#o`dv6q&$v8DE>yBN1nJ
zkV?u;42MnfR9J~w_j6YDMMD|DsaNnpX;uOOiF?*)1=I?=dta5zZIitS9?Q(A#=6*t
z!HeQ^d0~rT8KT1~br>Z_ZFP^<jus!Y17w*X+4jU;wI^&_b>Qr8c78FSUfGAvAzIb1
zN%p@;Gz3%ag_ND5JrCG`rdgg{`I3ONP+zjtL@5NJ-Y@}vBlP{N;`Jk14*GKM1WnKb
zTQ3K7XYY6TjgA;ogI*}n>XFu-7E{OMcD2rJeQw@-0~Z-6F58@hwX&$rR?%@md`)52
z?AH7QQucjWJU_z<s7@)>4w*mR51dmDSu)Hz+C}uWWCq<ja4|Lc<ZZ?n4g$m=PV5{t
zT}t~Gc2&WLQLcC<Y~j$|BNCR#PFpyV;=p?aK?BNCBE%NdTW`N=4BcYX{)Ay2rCMU0
zib!iOs*&RLH-C@4@?&64T2zQ_ECcN;-ic!^!R-tdP&-g9Ixt7bW{_daetY!X%3%8o
zI<lkv=4m&X=zuL=nmZLad@l@J`oWjyar-n1z$d&TsBM(~z52OGiV95-F;hKlr%7bB
zA*Nw0sYsQN5KXv7g7k;drejV>=UyP{cTtp>s8<&uWl1kKFe8|A&eOR2@$2ZfmU4z6
zr~?E%4!4Kz7k@^hF)Ooj-2!H-9<{Z-C+oWbE%GDu{(ruFS-k(B)&!q24#;kYD^dTh
zcujsab`GCZF`VW0_3Vxw&#CZInj3<^&E2&S_*3UjXCAmmEo7Gl4-ZTljD;*iYQP6^
zkCwg?5plw?$PzMiV;d2k#qENko-#U$%-tFR2xBlS^Lh^RKq$I>iX347wHC;+gfvqY
zddXOVXD?-@EWcC<@hYU}uMSYHouJmX?kr<7j%OG{4-l=e-8vs8T|(ex!6;guL|bv)
zlF!hc0-7r#&A&o98gO(i(zXdp^|%sN&~&hw)M+AicI0BfiX?OjSEsvo8+GO~aGW9N
zC;qK1g-E!ilNd?A6O-Ik4YZEebiD~}Sj;52mRPb|FX#fn*Tiz%TYo??)Yq{Gq0FY!
zIeS=<3Q|jx0?x;FRSJ;Zz)vtZh4IFhGC^4S9slrNUJHAy6_B4ky2daXblc^I61Qvm
z2%u-m-b)QMte&fKYO}P`waq5jD{-C~s;fC8;%Mrs{Zd{Fd3d0WX<c<vM>H?fo4$mV
z8b%GLVCD4FrHru(RFroTHxokc7)`btE(O>Qh&6&Z<-rRz^LDwwg>21mCscB6LU~(|
z1bzPbumlCz8ca+U5EWc386(n4rT~4pP?6lqs(^*u8mOp(M-#Tk0Kht(u9;Jh<OK*s
zZ#&4$gXv^>V~$bDLo-6J!2eza@@+bVk3EVd6;yN#3UG`Sz7zWBNj_cW5|ok!P~b3t
z$zw1N9@`H5aBTV9Howu2W!LPq<$#79=N_8x)Ki3u3I03Eh<lx}Ttp6#)FB}RBBL-B
zZ8()(^Duk_C6@>{<x`q)Z(!Z~J$z{Gw>;0)G%1K>Rg2V%k;9=?ECX)@JUIftlyU&(
zY6yawcQfepi?0soJBMJfC1tWaIP80v$8`E|qs)J*u2_@PTIi~1rJsIS`wW=om--x5
zFKMTOkX%ZugGfe>RWMb-Y#P|UJ4VVUx1`LGr#qaolu_zJLVe?bj6{Sp^kaEYR5M*z
zyLa)|!$Fd73LeKheiWZ@p}s1^d^ibbgS36)Nv%<{kD9S9)JZ$fEznRJ9LDJEjBh$b
zT4z-PeSv!e02&UBU*?fDGazMKx9IX=rV(rq5Tc&5gA#1GV4Zs*FYCV-|NRHb?OG?V
zF-y1Lb{|-R_JQ2-rN1>OSP>3YOYIn?yt>}?Z8ODxRElwk@7I3-!Y=|J)VwXv$iE8{
zK(G2}K~;yY!edxUbnNi6mq<f(;wU02KzO{l?;MktK#6g0Xy_KiIy@BkFR!_mqoZs`
z9h!QR27Wn{!D(L=-TxA^U0iOT!eruB11z;b!+Ymgs2Db4bfBpNdRoOO;5~lQA>UQp
z8jRseJ)VT#c=@VG=nY!0rtkJdJ1ybNx^{&Vf%V4eUqf0qX|k5mO9KDTiWU#Tpk8SV
zaz!_ko{!)a=wa==Y4C`JY`6f{i5IGfDmKQ+4$4|)bPjUph|@10>1oHt9$++k(|wqS
z!Xc()863CJASNHx1N(TyrlRtXcY>*vUEd61@V{fnec%jw(FHwcrOYEbR__omK&zoa
zmBa(TycL}2yWu(2f`ZFNrpammSLpCvgKKXuqdY@>^IOFa6D4R1H{7<S=@{K?g#mql
z(lFiT<EdcUty?<^nt{Opu-TrhWpMZO<b>!n*qW>k0r3O#Z7Vmk#1>rWH+HRR18x~N
zjPB2o@SWuUITrW3h||=|$Hj-9U9$#Y>I3_q&#BW&Istu`%^t)qOL87CX%#kWws|TZ
z0o56$z?nFUff8-rq^>nf`=9d~*^X&-h4xTb6-;di<zYH!C-HJuEE_rYTWM}1SyW8y
z>A%|_CQA)i(u7!+%=a?n!>>US7ghISO{``(@T5&GvQN*qDbalVzdr_9Hu;G>HkknZ
z-6GlUjjQ)9eTzDMM(O7!SLeha?V&8LzH*e0Utd_CbB^7Hq)E<Fo*?H(0-g!DYKMMq
zx21TJIMRUem;c2Y-#=bqQ7^|FjXuZJg@t^24P9b5r%x$Y*BeUjshq-i95yIFagNX0
zTtjx}oMi;pkjzMpe0fhKmk$5l5c(xCU9hsQu5v)}AR#a+wAd2~U1h)9e_jN4gA6Uj
z#w^IIY^h5K-mwlS+l~^6*djXG{DceTwb?}K9rqFC8CgGXHO4$quA4`clx4Q-2HR;E
zqgNliQ!d(Aqk+%vdPdC<<jFSnQT8>9v%?qXbBH57V+Vf`IB!JJnU2c>jY=;YZp~8$
zRa(}<RMrn3wmA0DN6-Zi`$lU2>*7EA59!tZWAXAkoWZ8B#yMof#-v%BKAwd!AToio
z^(RjK7OccGc&bzI!PqZUIDqfOM&9~UI^g)JyOfYGxt13Eg2gzISmDcdt0lL&*>(P!
z#e3fe;Z`6{(l;+2{hAVI-#K*|Q{8M%dv-et3drkgHZ)|MNc8Mwn}`*!FtyMm#*+VZ
z(muZrFJSxmhUSb$ddM?)M210_mop(T0b;BXW$MGa3oH%rCDQ2y$60lxUG%q3PpY`E
zS@G;V5;i8SMyv;>04rhbsR{3tJZk)V*!30D1oZGM>Iv^ry1V#s?AV~BUo*wo_w$2y
z1!PC;Xt*7=xywOKXn%p!n#xmDNs3)R{iz*b7F1<@8V*BCkLDfM>Tc!ZoW*8o9kI1k
zmGHtdp<VuWa4~{_5B1-BjKemo^?aF!#e%L-rwMl1q1SFhY%nj|DZN#c$8nPmRZocO
z2n5<VX1nlv_I{YltuKN~JHhYj;-~IP!4&U8!pa=0eqA_AZ8gEr7^ndQlV9I5m2}Id
z(u+M9nGuvgy`dOFq9`-$4%QD|Pb{HzaN<=+fA6u7$b9JqB-o$Y)8l}pXLb!8;7jxs
z<RtrxB=;U`RcTYxx0}_l1@v7>F<%;jSEN8~j}}7L8OJ-c$$=_^8)-|rDoMD2uyaVD
zDRxFZXHn-a=k6d3O=EWtpD@fQR*i1CH^bTl<RI=4W3ON5E#leUscP{yQ;97eV4c;q
z+=3VD4fzH$FL+K|)(o1m8luVY1CkE`Oj`psvQq-2$CPWd*>Q19=GON~lhqC^SF6FM
z2IUun8oJit(T6Jd(5&H9xMXPBgt70!DnGy`37R9R=t8Xw+FfpmCJ@B3KCQ*^Z2Hv~
zk{y^DXbV|fL**t-9xAa^cm#J`R^Zg8!edoC=LN52ud1N{n8?gE%&=pakg7h7=q;3h
z2ri1u3Aho=q31T|U{EMl7?)y}pI0jAjYEd*Xx~AE(Q*djL1Uw{y1VZs6S$xFE6MWa
z%iam>Ye+-Ox%P_`Y%Z$Yu4rVXnytl~I&gvvIdFZ-xZ^0ylD|*bWZ()wVDzp8YK3Ih
z=Zis2xhy+zKoW-ov0`UOvV9zyRVZN7)p*`eoneBkO)|b4nfR@mnJh_jEfeDOkucJy
zc(@qWA8_HO%OQ)FW<EZEc&9^Brp?OoGiHfdz{Y-BDbz)a+EIO3H1ADXxWId8b9ss;
z@C1_1v$#}Xd!yU+%Ee9z=Cews0aAmE<GFNi1j~fs9bQfu;~Gwx>Kl`en*STdB(siM
z;R?Scm)Ic-`+*&)Z~o!+o&S9}Dfr)>2g%O^p`&|X*U8l@MjEM6`XU{spaVc)r`Z`H
z0ifGp3h3h%Vg2kXTw`E`nM+_Nv0c^40v1JSuf$r~o1WzkVay5Bd22+V^pLN>4z~FR
zzbqSkZWG>0<x0{7+9BPnrH)z+gGY&D*(G__*`T7YT1E<|9AJty_>xpU8#R=V(knfJ
z;!&b~sSc0rV~};{nC4--@1#CE#pok9s$gH612yc&li)WeEDWO2;JCC3B(dO40I_P=
zvC?84;{4%Z+Qc+x=^|jBq37Y)s&D&r2)iG9<T~cx^8Xe3h2@r}kD&#Ws@o!XVvohi
z#mHcj?vlc>y}`I#4B%t3`BG3@FI^LR#uA3H{#T$qokhJcQY~&xmNG1B=zd38hIm3Q
zpkEYJEZFFI%e3AKIW)snBK_v~zE^xNHO|c)0*a+fwC2chkQ9j#ED{LjjZtbYYqmy}
zIMAHu{rJdW9wU9kgQ920A*%_=j^J~DQ1d#5MGi6#;24n_Ru<?mLTxV_tUNPrTkD$!
z=Fc^Prv+bW&8;Gl*JB}4nOz3uE0-#4heR^)JQH6O4OP<%FN!crNJtrg{71OVD>!56
z!1@X=tqZ_8bWB?6ygbO&HJMd;D4McN$g%|y%1TW5<M>|If{F)7OP)8SA1XlxlukA%
z_7&eCLd%dF97CQ5*g<$huF173{%D^!A~SGh<$UyGg)%TUZPw41VGMSMml;At=o$i4
zr|Av{RQ~(*O+W5~m5t?&t^fswQq0z~938+u2%y$_pJQ>h+(KSwB)ZLiWCY_``KCNJ
zAtPu3R0T5>2p|u$UsGvd=I+&>%f|Y1m<!i-#e1&}ri)_Fczk%{+K_h2335!RTD=9p
z45Mz2Q<lvKuHXERJ=NAqBPe~XyA|@6#mgri7&ucQq<^kk_L`w}4bWTxn-7fw2A+TG
zBc6yDvUB~N;#+^=cPIx-G$Hpxuj6n67G3wQcnlF{aJZBY^^BM6uB9!XHDv?MzYTSc
zRC!Vqew;kH0Du1|<pPTV3N)+Tm8{5OB?^{Xey7Kgq}L1<XhUnq-mT~3_dk01sg(7w
z3b-{G+MJsmyWwlS8A=*@;-Y6+G(XndO>ZQxDYGQFbre33m$epS4Bz5B?D=;3Yh9UF
z`h3#Eh+6rsC=@i4YG-=6#8qIZo42Xh!EVYsG0$4tl$3(KvlAA8`Ta+)?+QOos0luL
z{V3V&W?^)P0;$hORQEdOxL5ecOhu`7ARW~G?UMe6C#mBKK`2*0v<Kyjk4<0$2!Q!i
z3V0=GV{;4zN+&e7+~;Y`M$4UD?!79~nUr(idyR7+d9s&R^I!WI9l~)jFtt;DnK!>y
z7BMU;_f}novnrBZnZ<6-FgczY{C$ArLPFk$UQxkQRl(kzcpr<j4Im>5{zcF)Fg$K`
z%yAUQP-84KZkh?*b#NsHI%R;2KTXfNAjlhUNh|w`rDKyQQ^$z4SDaGM4Oe7f(IxBy
zNyGsR<>KXMR0p2pM@ZYDpf%*S5C4HYuP_O~t1AbK$GyaSuiPG42+z_d{U}^!a3mGb
zpqdqG6F|bCRJ+{CHxCdoA8@{ZZjH;L{8=C44=;brqt*DA1Lc^~jhn3Oz`HtXi~vRU
zFi2mTc*W3638Vxh{^%Rg=<|lp8}4w`gkZ1BcHWD5w`lxX@y(B*p<@Y|<238*cRHCI
zmnLH+tD*zDlExoPTaW=3kBYi*7lLDZc&b3nd=_*DtDp1()79kAMbQW`V5>m=mP}Tp
zP9)h%cZIil4)=v=oN{^9K#ijb+R3o3)EW_1?;JSoy4fI^bKxcylGI5Y!FvyT?LcLq
zY|lm-Xq?owh5J(jfwjCvpx|)Vpix*#JgK;z@F<`qr9{3!OCDlN*8^bVm%T$c^%srt
zOha(9u)%#%r%HyZcrJWU!2nIt$3sx{Q9_R^L)b9{ykY4GJV9QvNkcTLb`iXk&bQs9
ztAE!LmI?xh^pa3dHT|;Hr8qfZ{7W8XCk{2xYGmc#p{=RCQL9zr6%w~TY=ZQxZw0OT
zF6~ja8g6BiS`6K`!mU=ne*I;kUw9g5Y3z>Ymu_5ni7lN}kJmEYUX;F}q!)nLsoXMz
zsvA)=k5OHn^U?yuCW&h<380#um|iFB&(}4V)G<n0dLNc@B6qaR2)<mMoZ91RU0Uj`
zs9wBjb%~l92shlsAQ#pV63;PW8>iK(b}5gdZS|UH5s?Ko9`LHo?G89Vm4~Jn%{=SD
zq!56!Dfdw<&3!}G?yVo1V56?>3FrJy!21}Im6(#-ExB4fy{7FPuwg(}qd=UCkPtt2
zqL4E+ik1rum0hPGAGcZff3}Zj@m@XT9TRovQIyh&!-9Y!s|!rb2dlH4gFxEBt%+b+
z0gzm#Z~p*W-x3pB4C}8LgGpBW2G}dydzw1t1gFdftzxQ>cH}?tr+6-;msZ?0W+?|C
z*V_?e4ovNIQPNodFqAHgNETE0)E%K+HH!@BIt;HV`(iKbi~Z<G=bXI<%rh)MK@of0
z(o*S6?F{jb(%-F%?Wz+vAd!P`5d3cIVeF?X>j$p)e4aS&5QqS@=}=uu^+dFs*-tAf
z*_Hw+>*=hq@G?ODYJ%Vf=D(?>_|jjJH@fH1-ra&SUs6lEo=EFK!sPw!Hf2T62fvFC
zRAE|WAPy*}Wc<d!Mht@KoG5p=qwCdFy$j*K(6mA;rPw4oa*1BIrebc0+#Yva%f*uH
zRWk|BE_PNn$vejnRxZGuQKkm7-8C8rNuX(ugO5RBhbP3)V-nLBl)9Au8N34Qb@U|<
zSM=+7#ESKJ$7u@s=_k6X{RY}dvwHX2*fSBOtMYVUR!{%w!E%_3CgYTCeoCIH2veni
z2dwA3hD21w9Zy~nqSqf%F{a@sOOtYeGD@d_xKmtNgsa$~WRza*a<6FSJ9~Kp>ExXe
zg9XmV9Zhd(;~n+coT86W1PXlg1;{H$FO{hrc6k38RF~c!hCg^*@vK*uH~T>Js`V8z
zhWCZ+bF4}9*h!Q&rii<y@Hf!A@?UsRnX%u40Efm-R^!-3^5ceG%Fax->7@!o55S?`
z{EUIBbtG(8I7NuqKw`p=pu8%qL?r4n7Pxz+4hHBhYBOeCm3mi|SCnm5u;|He@0)JT
zKzzYa{}hh;IgmQf5(n6+_F^0Fz1c*4F9jnF>;8=dd+&*SKfYrGko75-N#8P&dkzB=
zL5daxhdRw{1K1CDJarq7BZS5=Xp?&iuV(s>90l$ul5AA`YHslD3kFy6l=g#6pqMJF
zBc7;-Jmkn{K{^FNqP&R&be!cs#KVA$a-|DG`cp%3B}dv-@EP25I#`)Dih6)PTuTeg
zbxscx@U5k4qZ>-OKrV2(lfLpay^$zu@Hsr>jqq;o)C`QpLzdvMph;yRFT=0J#XGTS
zT#_J--r#mtTMP1z^_gN3UJD&XtPIniU5Z|4=1H558mn3ucnZT_?Oq+n#vqt0%Kwq}
zr+1-tE{v-z-gE=Y;;98+r?}=zQap~;j>UyttWxR%mJpr172h^+Q4jOB$mMsTdUgu7
z#d74zS{*0OvfYTCdr2|M3#)l+@_r=N)G52zkXc83-&LGzaZ{^BC--dHg2`+2KDROp
z?0{*Hz3q;dtuFSs$GL3SO7A!Z9>c!YKNZxz_ViQ`%F4~Qbu~#vA*w7<CbB>YHFXXx
z#Pj?CL%79fc(gP=HyOS<dNYPef5?|(I59FTTBl=u{xkx|lqRG<PiL^i&Kxz0FAwZ%
zJwhR9gc1N|FBGO35s!Ngp`_;8oC4?kw{F9;(9H%IZ)i_rX_z?eGff=@5y78HKfix=
zGWs>h#Bz<l0t<8$5GXKEI6%Z%*y-`U>cb6{5@NYtCe&y&cAQ9+0du2s+@L>Spu2#>
zhQqi_#!$Hls$MrqI#n+oaPWJ;iN-9GWM5^hL*jhJh71z#4`Yd+QPiiZlKL$1`0OV4
z7Q#CzvwtpLzCKJ8#o1LzLCiqLyB?Cww+cXOgekPG9@>iq)QpyhfWpF>eU;n|+^Ny$
z-)^_!*q+~v%}z<k1FE(c>n6QPfd{F~q96&{gnJm!bH7hztt&E7J`!!&B18c^P6Avq
zXC(a87WXZg+TTH825Lcw*_`6f%-L96U!cVTVVGv;GkLUw=1T}<&DtMHn&Z8GDqwYz
zcjy|o)=A%ATJ0!@Nq=5S3`NBW1M9Z~0rjNG7$RVkcYe+$yhfwGF+vDq6#`;dsg0pI
zh&m}#Owrx?OI++ziFANM&+m5+BIB_O_l8UM+-uToMP(+<Wc--8a;k3KWjtdJlm!s5
zS|(CKzUSoR>6hCOdc&SP7mzyHUAX5N*g(N?r0cI|6dzftW|%-;@*p-g(xyDdFst*=
z50gdA1S(t*RnCeIeqfpzYxNz|jJ>50k<DI+_7AA(;c}OOz>h8rzN(t01M8K>7#`Qg
zDo*O_$55s#(mxWN@HMGe0a@tH04QBq9B}E0K9iVafCnqACr_S9N18+VQ?=*OwGg(N
zXP|3+p-K0diJ2!_W3cL#dZ|$v6f7v@om~Ru$oUfphX~zrQF;F<lu4oXyTy(Xw~p#F
zxk0Np-yTwnLf6&q+)fwLTBTo7P+1kqI6{tejCJ}fDIOqw6!memo7^kkaUBkKbUh0s
z<gHeb2oC!$&EqPVfoV2^srMA>On^%eC+$21F6WzTu)y$$V2W|-z(U#z%V!qrJeWr!
zMH*0u%W_hfI0nG=xV2sU;E7cF&z^RN)-l%}{6YKO1@hm#zEchG?qCUts5rMo^C2^A
zt|mbu*kXOYUr6?pox7A&WxeiXP+mTM{pxLFzDbx3X}YZ}W!UdXU1AJ#M!Qf)b(rjD
z8m<iAY}^P2i{bGV1k-duac=^9vDn|rLzWsH{KbQ5xdVQJWCV)C8@r(Hj`!j#OBDV`
z;fX8|k2AkmfWMi<Jao4Gl(bbr7;Ck%qT!QrN-33fIB#0G%UcbBaKzZY06nY>Dpi{-
zN-$%dcbS{plI>bCq{whVuu<T-;9qzKu{AIR#0!@d=f0Uvw9W7q*BNF$8>OkpNpAXc
zl%Z}H;zy9C)LeuK3dP*Yo4RU>gklQ~EoMSqRc_7nLhkH6(5`#gCaAf?2C)M`)z7Ql
z+Y5D|d`EVNb;$@pa#n|X(Td*`FYbFmmqL%zly<>V4DqAa4Yaybj{`=`ie!?2dWM>6
z`mbFFAZE;f{;QXi$87ysX*@ZVRDAZ*!m@KeZF&ys{ce!;?NV1L5628!xI6L%?h^>7
z7H-#c1JoS|61|MvCHd=!QlED6ejqZ<WaEfjG4Dgqz2N@Us3nyCAudVduJUQh;&aFl
z&u|xr?a3Q*BFnpUY6Yy*_20`M?|BUagq*DbwMHy~Sac;HEKgcZBl*Q7k?`_k{j>Pf
z-|)BDy|u%1yRB9eHmnjFjHa!W>||S)oKduGVC4Fwc=@NpOozT!neC=DQCu&jMMY+9
z&fpXn-xaS3SqfJyM3@LLS4~l6D*Ye3OizFU>Ea?F5{6SR7%6&hnF8y}M}>ajDFDFS
zXf9@w6s6<P4A4OFLu}!u7w0h4kL=yEy0i>;c+kcR0JIAJMNhjP5DNdQ_{wvLhKlhX
zQ;h3aNbx^8-6<p^R>16S8?r^`*{X`OrijNm#J^yT7I|-WPGr}>UF!fhyzxLtxVj%$
z+BiSAiG%$9Gx%ftnsi=|XI95hr9Yf6yN-)TM^7HE_P+xEheNZiKOP=7z`*4A%F%=%
z;0PF5u#)6?H56R>z-crnAwurs+o<C|Z91huMD~eGyimzF)41&~h*>goMoI&OzRlt(
zw*a&EnFtK{&BEE}$C#O6@ii2hz|S<@Y7T!^{9oyJvWE|jf~KNa+})LK^6Giss34vh
zPf67)@OzjbG+L2^4(I_Rb74>I$zHL&j6UW9@PeSpT948@Z%NC}$|0Z>1X4K96v+~v
z`zutt*L;6pf2}n$TsVM6z>?h`_(PoAb7A+*JqKGWVMbiykBXO%pw;pPv|1KAxRQ^k
z7>8N=e1ORToTBW1n$MQ{Gv$&eeiz-A2^AixATZNi<lkMw0dVowa0EGbI1G7heQ9!9
zu17%|*vI}37X(V`bUW~aLc-5}()03jRbYSQ@6yVBNZtqn;6Vf{dL+syOqVRxAd3qB
zs{eq;Q*Q7a@<catcri-z+G-v>>1)%(3he^5YwGFwhoR267}IW7`1%D{P%HIK{bZl4
zmcHx=W=pxClMUgTgdWjk<H4HHc{?&6+Py}NSI?~of{;$FBv`?KC&>R8865B<4BcXG
z0<We10OjGBr32%zMM88_8UV=C7vlswJaa6IWNg?o21|{SCm!a{-~dn)ok3OE5KOMe
zjG?s~{PHn26hT=(g&=C#rOl<>z58wV{kq~3Kj&GEdg$D038|5>FZh2I3l!pz0?|4(
zYera7bJ&ZA;Qw}IQVBeh6rrNwxX=fv(6@mO73xNaUj^&p4EVmf{4StjH5sXXT_Iv$
z+y$UNmJs%IMius#)cyb?!Yi$Zk@PqI`tOQF89%mau>N1i;7wiT0kQv~!rW0gJwx{X
z+K&x%Z|MhkZUdrl1X9GyVp`l5$8o%d_+bM-cl$Acv4qEnj%yEnxmum%88K)}-x-VX
zXRb0(9{M+7Fi?|$i@LP*az#2A<)L?T!@HOtWd)?6K{)}>G8M%3tgH|h6AuRF0#3B+
zWf^mq3!q|orgemPl}8kkOS(tFtwUvfd85Rn4o#$G#q6|3OOw(_^43c0Xaao*WhLl+
zYrG@utH7WnYFV?;?Gq|u_Cz@9sN|y&7ib2~-IK>`1%=1DRZk5pMF)H19sMzBJA->L
zWee9%bq5-ZdC!7wk_FToNk@;loSpl*R&!v_{K@lS@$5*NMABNewAV!wOTB@^hjvNo
zXhxD1Vl`G)UyZ(SEwf-y)nyJ0=&SlPn@$RZG#|C@6{PT!^wWRy_vuqUdKrh~j5F=0
z?>=rsun~r_XjFPC9-#4Ol~PLQ?xCV^Rs;7yZAYv4hG%=w;y+~~&y>Jj7i^}r3%C5%
z+*sU_Ye_Y8h&{3pE9bzn!zAinC_D_6CazdcI_I#2)qN}^q|z{1yg6$D10?A^p~Iy_
zGAi67^Vr>@#zL>>d?vK4#3HJmh3Z<iNRQXNeZkUrqO|m|Cgd+=(Cvx1!PjID0?wu4
zULCUXdZkS&-u5<Ng%|`W`&qWV{3(Pkca&i&DkUX`P*1dE`v;1NC&hWJ`6MO+@R}<A
z|5|*IzC=d=${M)~WKKEg!uNw5vJfXL{n%K|T%lgYI~*VPm+Fxl=q0tB$`n*PN#VI~
z7ifs06ajF=j|Z+``up^7&ayb$LUV1kDYI}c(B_S4$4X1t^o2%+>$95`){%;iZK}8Z
z>I@sZ6Te3n5@=yGFB0CePy`7|9$FX++xqgy{h*A@?{uIl+~}BcUU<=44XGd^1#<(m
zIUI~QRL^>4Pu!56mTtn9bQfd%@xO~#_cn_%cg}<S1p^O@(!Mgy-P63m6iE=GB-GQj
zI67PhF7l<n;tY_*7A#w9FI^C4j6sI|p4-Kh_`)v0(C<<$G|n;XZT+u8K4LdBM;$95
zD`^d=NoNJQWzSim{u|B!Y7cK!YT)28&`n>0zN+a$wjCTsJYXjmU`XDMKs2J|g2WmH
zzL&nJ4qfcp0FS~*$N%l<nevS3XtpRQVo$L}l(8I1GFP^YICGGbm5qmh#8|ew+2g${
zw<O(94*(8-x>!pJ*1wv+V6I((B_VJ}(Ag6mX+=#1Ki+b@bn2k4Kj_FV0bK!-n%oXd
zNc=-UcuU_68Y`*-`@1}s(fR5_)Hvz#G;kr*HHbHMq#T#m77yi7uivZmtJYnW(v)l=
zIpFF7hYTG${nCD@BUcS}duE8BLHN&u!T;kL*k_Jt1wz<}6c4BJrFdvH`?ctY>7&1Z
zBFrMJ^tC2(iWYYXX3GRjlV7A0pRykL9XJ*ZbRg2>!~J%)=P`9sH&`l~yn7XeiUvt=
zY9C=T=8pHc;|N=ILpL1HY-91%_LLW^VnmZwRgY{9(VEtQe5Nf3C8`hP33VHHb&#b|
z$*2wQR~`#GwU@g$Pq7MGtK`-U1J)*>Ho&g=B&0ZY^bDi=$yeA4><rM7{de%<nymQ^
z6=`YG{pms>wfBGkdjP{0qV`C64BM7tcu)Z|26FO&iY2nrr8YwEX$+wbx~&~##yUx~
zN{{FFp>-Ypzoh4ir8y`0EA}CvS~(Wfx6b&7<&CJtF*J9ad=kSOqc9Z0>Y6!{coO4b
zCos`N=iulvG(C#*PVG1LTqAft5N6Uimp+dH0zEps9l4{Vo{JB4DyfQ}!5dP;_U+<>
z4^kO$9YxW`7K9$Uf!9Re?o2*AC5d4>*(LQ&E~ZUtQ7)=w;HVY*H>)AiM@Uu{60vy{
zLYThy{xa!Exj+{~L1zVy%7skYbFy?z?>J%*#}>yn@!g&2FeM8Kdpj?`E$kov;-C|-
zZjjb3i{^Et1z4w;1Fj-1K)bkHhAz~Z+(ddJpQ;QxNxfwk=BXIm^RDF{>==|WYVHd?
ziaE!?$--`U{7W&nYT{lREe;@EvU&2cMA&&F$tmQe^cR!H-WWwKcPl#KEPe8iJ7hPx
zYoJGwQYi{LWX$>^QaQj;P+@Mk!%yd6>oxoVyMK%T@+goAr{-rtzA=hDVR7r8Y9n^^
z5el|`!idXDl8cYOILE=yyBz+u_y7xR+G&smC-wmD=y_ij*|FU{kEMOq#>etbgSCKb
z&V)Hd-m*D&-q)nRc2xi<Danrj#rEaEE~8FH3F~HWd?&uoJ*2k6mfpdfkWUA&CJ?Tx
zgo!92zkpTKf}y_pM0fys_5RW8$HmL%NCvHdlbp=Qn0<i|WqKjk2pLBR(u~S67?hj^
zGem2fWhHyf?m?3-uOdIAb4%JK{&S8##DvwReFV%7D-1a1?4n8iDcFy3$Gy$KjDwO&
z>47B-d|Oz)f&n1^n}I~t6fD{dW12Rq>V%k1%wH~Q@aQ%$FD+)t+U=e!E*+i=aZii#
z#x&@2YfRCT=sd=6r(`MMulSysU3R_f>}q2H#tF2h^uWS~Pm%|C$8aV%+!_jvHeIqo
zK*oL?D=KY|D-w75u>cXQ>BNTmdgq!AW7>fW0UyL+n*SxhZvCO9yrIR9%Lv#Db!spX
zj=_XAUx)GpF@VgbS*8&yXT{ftF<`+ce?dLQupl>zU%&jU;6Fa~Kw}@I^#119G&ly1
zo3SqXq12Qg-Z*0&xD$*zzeWXQ(WFD+z-4TYpZusagVM#iDlcn`HN8I!VEuIfk7rS5
z+{t(qov!?cz!9%xp`P0O{Fa70^VqLCBp~n_{7YoPFH6`>okay3(7l9dNV67s3HJuK
zb*Q(!B@Rz~?m8g_-+7*ddxEF43+SW(GmigmSpRhb-q&-P^2E1_@Bf8ABfEr}EkK1}
z?BT<tn+U_R12Ip%U+OSsT~$w`atpy;R*+tiv{plVcY`(GV|&<-XQ?>eVOe<dr-3?3
z1^^I{86pu6?&BL~9Jf64e9)kpwP_m`udHoUFHWG$6q^rltXD*QZK$B<0Sl4Iiml0#
zL0Tb&R27j7?tampLtI|N?YBejuRWP!(M;sa!d}rKW?^y<teCyyJ_pGw7Gw6XA-COn
zpg9K=6R?Agq?`xqL)RO8tM<yc3lBRmh5@>;OLs&iSJ$XU{-t>R2}{QJ|DXDKtAs<Q
zo&qyizL6yEzqQS=o82Huv_<h;XEEwTK(vB<JnL?5LU#7e6QT)bYRTTg>VyXrf=kGk
zz%g*gr0MB3;U^O|NNAlM_5AW#@%~fGW94~+fq*5n0JZ{y6m0{Yj?>Ywa>nk>sAIG&
zhf64_lvEx(X<mu(7aR-V`LgOa-E79cFs6p9*bUr~O2g}sCgy&}DH@=uAyWBxI&i4z
z1wtU`A#c<OF9=tWG+6NpKe5i{TQbR{B#?p(SL@<P9h*AS_}>5M<#)vlfgB6+X_lJN
z6p#=B^kxicG}<?;$q-jr3F`S6EuVMchn8mjo*)g^F_9uKcoucWkNPpXSm+gAeW)&6
ziKow$b*y*eAOBi-0#00@6ARa5g1S>Bx+_6|Mqxl}Zt9bqQQU#`oL+~}rD&{j(R8)v
zvFYX8ud>Pwkco*5h#xXzT{GsCU{AQ8vNla+Cm`5;k@Z+Q+_(v-2WR;eJATSGltbI^
zWZ=(5pDM_c<5FUJ2he*NPK6mvjyn$YR{Y#o;AMp>eiW(He!z5tSE<SMBS1R(icbZT
zQ(UsQ<^q%81F5p^?h&A%k+cR@!wRQT@+R6HF5wtxHTCIKye)V$sgCqjiOO7q?+Bq0
ziz~jVyS2f|sq%2^nC1=GJAwDmL+1;~Zn(L5%dqfo`e(3A3|-2p38);V*6=9@&(Oyw
zzT$uV#3R;7J1>Zt%%T5WLHH7L0PdAiaX+UyNBVJL2>=D^HkipA?ykDu5*PBW{+P{~
z8(qhQ>c_&x_XNdrnY7j2tsc0$oqP}lK0M|KugJZsC5M6j!1hUxJ9p!yES_RBpY3tG
zy`SKp7k~ce>8ZT?=I@J_e{z+Bwx?!ynDi0vlJ@&|;7Ks>M5xm0gbZpteZt_Y23#QR
zMEa2fYJVO=A^f~}`7PN>5NGsa9ZjF#rAre0i-((M(0CuAbrwr?Smlc3kI_T8wx9wN
z5Cr~9UnfGK-7lDzx&zHxgecsYweE2!b^wFlf|6#(t>39wC53gJ`JbuDODXpmXLo4M
zY^}8XCyp~~xNRZeYTs?q2h^x~xk1<Fa-@oQF-7B2&9aqz<H<y!(x?=!P&z`gswj&J
z5kl%9-8sxuWd^I|KODy3Tncd&k!%Vs!N4gH3iaNHy(iEiHHK{R)U=8Bc9VJ*MrCaV
zg}OMEJOQW&aCK-V!k2Y~_fbD&a-obp*oxLIp-coC9kJ<mwH*Ma?L!_hWbeY5=T7Pc
zhP)E33a<kDx}Mv1GQAFCMN|Mv46uuq=FE}^20)3^gre5C5I?vuMz;`M-Jm4ir7(9b
z2dbcH5sKy?1w-<M@)FpZ8qj#sx9Kdw4xHwlF+Xc)T{?gV5hVz<tL*OA@U_q;_NPe_
zW9ftrrbLZj5!WJv3#i?JOQ`Oj<n=B&&lISN4-a%2$B)|PPN1^NE`4sg@Jy)tFgi)I
zgbmzGzzk-|_6OA$?lqa+a)U*pUueh;1r8CA{$HWT0GHm=XnQ<HFZzLNmD{=81XX=j
zp2BQ!w(9wj+N|j(=yt9LUB<W0RE6xC@bg+}|40&MEJe@uQqoavx-N6p2dga}#;B_y
z&fi7RVF%=nc>!F&7VC3MU3>J~$8A^1EvRSUt5sHG;MQ2s9hy5}7W5c_h`^=_Bw&+K
zC$>VFi9`woJUbJkA3ktYybz#P^O+)x{6X9t4(e4OA4qytjt+)5hBt5U@YU8IK|dI^
z)LrgSeUiz^7JgStQkP90>M#ycHPT~LmY?O^Ffe5o3aU1if)H4J74%<gSxNPYy%)(|
z@LX=X);p#$Wo$oN;}xcp&3tNNsBKwdT&;du9z%^MnLMG(^!$pPE{e<1%8#55K9}<r
zAuL;Xl+b^WzkYfuo}MgbOw&Ct$m#E?Pkg(%RV<dU)sAQi71(me^w~A{f3S~dd2?z+
zvZbV&eGY`x8AzEcMUc_M-(^}z)iWGPiz4s;7wBx;u?6KcW-nOe2+Hao3#7Ca7yd3L
ziKA6h)WK>oZ*=T)*_T*QQTb5+NO`YZ5o3TK+gm$XkEmUR*ui&`^#VGEj__x}L3{Zg
zV!d61n&&5|6GcaBmM?VE?+~1pR3+?I%afpJp>>!9m0tc?esF*Eb3N^aR&kjC!i&a`
zvOW^bWt+A4qx_F3@PGQxbX}=#t|<?Q9Owd+$mf7;*RWMsfz5;iD!Km})F$^Tsh9jC
z;DBU4=m$#5yo&A{>qO+fo&s8-9SbaaFFM*1g=!aimr_KcR4v?TS|1oS8vx-FEx-h!
z+#uWM)6w%r9TcI9+;InFF1zMX(`n<jgA;JCI#8IF87<w@lRs>@MTFD9atZmOdINLc
zBhLj2o*`XT?xp(IeX<8Ouc4xqHN7zp|8ep1bC);}HD(F%X<zu+VMQ$#2!y-+i20{N
z?+4kz&;WRhjVV(6EyU7p#PH<(YbcR`*<w)}v|_t)q5A{3i>x45cI6WghEEbJc8hg|
zv~cIRY+C0mRc;mfc5k!TJaMc98;EnZ3+qQlc%FNjfvs{$fDceDOcjW4!jwZM<$9py
zA3z_=n3iIMvArV{C7OB!>efNiD+hH=CwV6LS*K6+fZ%lmupvaF7jXF^mJb<6_<$aH
zuzJrbv2KAVXLuz{yNV~|KzlbHgj`ktR-hx|6Rw>Ac01INKpwi*9-QiTE8b9m4eG^8
zj5=yN9Zx$Oic5oWvmG(NH<loJC2a!mm9YW!k`gD*q0fO%73SJi)2VHy;;oM;hthI|
zTxtMM_e*+qPSUmj+SooT+(G{vlefa-G8EzuQvm&-dqzLwt(JAdvH&(f$-jYuRtY((
z3}&UI0@M+Tc3wW!qX0Z5dIb*}b$f;<vQuR|eDFIlt{+&-WP11ef5I(HpPqtocPdr-
zL%RTXyC$wv7g3$Qq9g5v#y+MU3A-IL#+E`&L)Na9!2v|ntw1ZKg#lLc*yU){Vx$c)
zjDx1oeNz(xAX;BMbwLR1MbV*)@akCBL14-m?llVr+FNEkfip-Cxd!QPMHT9!V+!o}
zGrc7TaX8>u2?fWE6^QbZ=-Z^V^bwBbJzLh)<5}S0dEDDF(B`$0$I%slXKQ!w+5Fm1
zJ}7?KCGFDq((p?bgl;c8lWBdh?*-CIItsuyR($+wG^~Zfh8nRWICfnFVu>Om=+^pa
zFQBe-llCy)BN1Ur03Hp{$G~-Aq}WSZp^Nqu8*MB4=tywHpYat?iEmYmj?g)e;{wL3
z46pi~G2cCSie*6C>|u|j4>`u6Aqij-i?9zJ0!&My3;?z2KjvC3u`HgOhi1olna6cc
z&ugj0(#nMZI!Xf(!j1vL%7ShCp-EMDgDEUcBp&>Ok$!N|)EdgS?SgGJkp<FSr7C;_
zdXa4DDgl;?N65R$R!pFmYK{rjVu9aZeUFlDW9;{IL)$oEaCtJ)HNz|!(4u&6Wp^U@
zCcT2jT6<WpVk;$75(hm8B$wDFES3XdKQjmlU*y=kWtcAem&OBR6Z7KPS)$<VN?aUk
z6$@Hy#2-bX#J&-eX(z*4>O#UUvhRWP^xJHebEAP*xL78&Off_;Cs(2P6BUR*@rViB
z_Avm~4(3Qc^_GeQG1(@?5_=IRt*7A3QNbr96)|U2L{}i+pbNWT_3SUAxcQ|(5vw^=
zfaupZz;(nrm6G;=?@C*zIdO#dMDSmtrvMk=tbP&etKfG*W@*4IJ(;-AWfEpSJR(f0
z9O{Z}za+#oAk8pM$x1Sm9Ki_!d`0o0S69r2vIB`4+ZD`jTS$nVOHN497{(Q|KXHDe
zUXICoQ$y;p8Qe@P*$}5co-BtWSk%Y}wP-ZpjXP)&KA!1s&j9>iDjmj~B(AZEv<DsK
z$EBtFES*?xgXsPjgh~H7)^;DB+xiXS0$hI2%T}s5`2?oxF$!D(`YZ-5-XUU0A~VmC
zePa9mF?FFqQouAgbhdw>WFAVl2}+2{=-aVT**%yNWhTtOJj$V>lr(IT2mXnrh(1I^
z6=`uG8$9w6(k+_EU2s{OOn4{3&!10#zqX|~9SH7df#})TZFYx?(hy(<mO$u=Ad0m;
zemp`sv7pd9C)Edm8&>gIdRjuHKQ|Czy8|%K5zw!3R!WtV&*&KhA3)%IY|sFS_T}Vr
zookIc5TWl7o3u7?+T|w-Q29jO?gWYx4KW)ONPZS)(F4)uRMaWDSrBSNdNRqqPh;OC
z5|sveyq{x2B5LR}0-g$#rIgx}#Kx}U{mtti#Y6rh3x$_|fhhQolL>_5UkW=9xzm?s
zEtL-Jx*oAb@hHGLf2P-|aHD+unAg`V0Q8ZiZAXa@#SWy%>LOC5ecRRBCOs;+eRjCy
zxly=c2>!d&Dh6uU`X-GlSyFi#oI_u|q5WuD)@Ekw+84nLc5c81j0P7|#}Tx2d=UG{
zZPXaJfq)uZ+93>ZAQiI^V|x*9oto0b=Pg`JYV2n1bdv{6+?h$&)3QL}dbblGWP9bH
zUkM6G%$U6eEBiv}^qc_EL_F$>OiTzvqq=M<SK?M;oq<7gKxJAi>r#RPgZg&yh2;b`
zKzsPRzbpRE-)<<cOeF<Gme`mVF!8{!z*mOQ@+n2Uhg)k2GDKRkX9p<MXwk62!oJub
za#=y3JrK0+$w%=HtkyJ1jP)FJX@}TUZ*^A4c!rwyAyLe3O;!u6=n<H$_Imci%GwDz
zsNMzpuP-qJVqDjEgpIaJ(T&Vwlt#^jf530VC#O){w)0U5LTbUhT`nJ5;$W+JZI~oQ
znkT~FTkcJcC`gW|R60;1wcfcUC2^n!HA)78;(XwIqdnLYk*xzJEa60&Kyz!5Cm!I+
zQ&!a*xseAF@6VDcZl0<zdf?oD8BacM4wd2wAh>i$V4>Gx8FdQ+X9H-|B0?LP#Bu9e
zF4r;>7?6bhRA|0{b!Z2|6Rh>r+Ap50!#U7wrQT_!RH7sdcNbZ)V|<52pliA4yw%M_
z_LLkIvZTagnd3E0lLRHe@Jf>>hyhhH>;j~0O|`N|rOr;p3PQP^XDb2xY|^Y2Y`z(A
zHAsYJ4?9OA()-hrhT~a+K&=2(1!)}KYl5ELv$prQiht)SY6WT;z$yHc8KLAmCvfon
z1;7?X$qGGi$Fe22rdVWZRiq7l8s>Ir1+|^*Hzy4!#D<w<2XFH`zUsM)l$(SAe}!)F
zyn*t!TO-2QbQVCKgLs%yU7OnFLIBKj-m-;vNCu&}RA{|FQd%hG51OM~8{MQ9pm=$U
zVnBOTP;9EK54^NbD&L`F!XqnMJQ&Y!7@sMSzWln-FA&cMbaNO++vS2ekbif8Wa|jZ
z_8*QjH$F~O*p2|y_R7Lt0=sk1hS4&mY~An8xy#AAs-Zn|jf!0fAkQ)^ieps+0BJ63
zapvp*lsid*U%mV~JZj%*ME*-h%};qZPGLIFTT~{;xqQCk5%xGJ*-V9#gx%kw+>IUe
zW(R4qPy8?{iOor*3gPYnJ1zaNv(UGlebG_*o>+;y&h3gB!TAE3BY1G?BrLCt%Lo@d
zfjuX?)0-Rti^V<Jr~{~JZhe<e5XE0ya*M>h0V?R{Ep!Z^kck(Bopx>;dRR#gNzK9|
z0U9B4Jsk=mc?min`vU_G&`DC@bsSjDLNy~|6Ga)q=g5vuD{R00<x9jtA5pbE(Wc5`
z4I4D)mK*^{kZzk*>jWI@>OSX2YL8_s&stN`feI?ol<ilyL5zuq1EQ8B^e%FqKhtl1
z^!m?5`o{sbow^?!Pql|93?MKwBdt^Be~B2X4QJC4qN5eC=nl`^uJt76s&q#AW`$8k
zhj~3=m6d<`oxv@~ZazYS-J1m6sE*|m6}z_|TF3$yan|b|%03w$TRN7Cw-v?Kj;ZrN
zv!x(^EQz4Dv`w&*lq)JMtpY4Vsw0JoTWv-s`gAEdMG8rvIFIXg9&a;!+Pv6lk`9u#
zeU`_ZAWKbVzsZu1>3}@k4#b%0g1Ud{`~Saij|e->er*8G-VS93Sgku@lX5#VAqXp6
z6^}=cufrQvm){aYUh2}x=ndfcs<b!9&3;onZh<Dl{_}F+z`5AdxxOlVm`6GAat^9@
z2O}^QTlNKdxc$j}e7&(FFRq)^o}mipy)3}87PH8m4h8I#{{TBwe8ZHB?hOYnCHCW*
z3WyXxb22eLHs}%(1M`AG3Q62m5+~FZB0#NnN>pMG1`Mzkw(`%4@A&D#8uGji(Iwk!
zx=0yudxTJkfPkD$Cuyx)8?!*dQUd8d&W*FbBSjX;iKE@^+O1VdUk5eRxzsLi0qQ<4
zw5AqonMx<Sm4or6ghsk0eyIz7R=ob)O3I1G9!Tn%lgM;No4<jG+9m<AwY|<FYe&vM
z{Rn@r_~3hf1u2rICBX#=YXQhc=y<6DPSWuiZ{Y<x6!GkN^@v_?xziZn+->y_a8f{4
zw^`%B0_823Y+z!gUqMtLghlO>cxbdg{oyt;MOn?5`r)FHXYSR$6k0(^sIG{|V)qW}
zei6>BY5v5ODY3p5loN9qKLEwcXNLiO;JK)Guk+V<{{2W4fF5>FK3XfK%UNIJ-OFdM
zKixAvrxw#7zYx!jYLU|zGDdjWo_blY&4&-+@Hr=6q^Qi$HM?j|MoDx+$Ut~?P~-;@
zI<`bp=_T=0?lp}A{wKLgWbH*?*Tq=r`=q_ciThWrp>bQj`B8cWrA&NN`6mC~V(WY{
z94w=C*@<Y)<r(~yu&)_IP;+Vn1O-n8X-oP=nYytLrSc{#fkW$aAVU3@#mm3yaJR0+
zVEtIl8uUmR?BXPF7o^v=mF5Osk-{Rn45?nqMq&qeN@+*^v;C$Y)obCuVlNe5GximI
zU)#(xEoIbC4fOxh;sT6*`~H;SEOU#|FIK&bgDgxUMNa~hPSAy>dbtlTo5AYZad2@A
z%@=4}4XXEs!c;~!0h+q*2#XiMI2cHL^cr;-R7(9`Ldqna7z@|(3f^FR69|J1#8dw>
z#W)2`ngZE=Ql=%FX;AVm{RHx)^GEAs68_7B(730fcV5K)Ki5{HIRtQ!A_3Ks4s{W<
zXiEpWfn^;dX+RhhFJbha#vdmkqaGTpZkv13XI1et(`sZ<Un@w@uay|6W)kA%<&c52
zvJ)bee#t)sNZaW}B9mLx!%`$Y(7hV$MFuj-+A#SylH@Vap)5;#!<<reRI{T@HiPA>
zOKwc5b%()P4^LjIm#Tz**y(5azDI2+s^F5yE^)0$vh+udKN}GVW&Gyt@=cOC)`iIa
zxH-9rz$*1u@GE_d1ucWX8e31-2qSXID!Kp{p7V}qE+5(fs$|2u6Jq-6<((SRchH(m
zj#o)iB>fl`zMe2+n=r=5!s^sY(E)AT9R2UI-VsCmPEaOmhxUWfO}SeFT`0Wj1<3Vo
zDXUWjj1Cm#A;y;!rcK`gr9vR-IZsYvLjL5j@1N}Uxfr_qI$(8iQ+&N4<%*p$bdUr*
zT<0xViq}AtcFhA;D*_}jh(*{ZCN}t{QyEmhG3+7|aoX#CL;_ej#D-=a>yqExI;|!`
z;KL|%&Y5oHa^g)Ms^}{_g(vtrIe@!ds{QmTfuTM-EWl&?#+Eh~G1Qy@zjt}<<~*)#
zULVZN44N@RL?gYRAN-*B!4H0reze>npY0DMGi2`P^TPBQIwS$Q5X=^9JxPr86R}uv
z+xkIDEm_68nlV2S8XGg=HkuwH-0z1q^n5V(^hogl;Tz{op3x|&BpD$9;h*Rv61yd8
z08SS2M?%5av1?qxF%%1i-W9XvnPFolTrpOb*t_LgA25%LGz08C!a6aY(lv~9k19h5
z3YTz7nKekPC^&E~xTbYWJW&fS9IJS0fn9OGYnXnm`HcPI0GI9PUr$yhAIDC|bJ2;g
z>jPwQHQqvmX1T;>9t&<rSXvZ)j5!+JO(d~=@do<{L<l_^9bw*vJ|0ef`oeAC#;=gl
z#*#GhAK;UeG98*V@@dwO>=PcAx_dkKD61Ocm?O;!6x?GlwGsdq(?bxXM8e2LLXuGi
z{B4SArU%;HFZ>ybJhk$DRTd9kdSsHErI@PO>BJCGE8h4Vwsnivpj4exFHD$t7j=yv
zv2l`TmD>iq{)=U(Gsfv6_+n7qs#>e>`?ZRWOTrdS!UwA{`wX7EnmmR~mv?`kqE*Li
zeid-gdRGC{Hg@2rhIAkQ&y_@h&u=>JUly-vJa*Z7I4Ib)6h2pOb>L<+X-sIP{<Jk<
zsq(*kzxaOQNa{I45^%lHfesUZCAKPDRY#nrqXqhED2fO^SYF063=`8M-ezb@W|@e+
z71ODq$?*BGa)@-2j*=@BjaBicQGVw!mDXAmGxR@??P5s&V=ah8T3do>PmUd3KsA&I
z%eX{`gAu1ny)oQ<@eUxO05#>C^u|HNWmfer@)}mZ0??%cwyOUl|2inKbf2z$=m#I!
zXML-*+YIFrc%a<wg|;KmBeIYGc^Ioef9PPfZcpPYLEy<~{urhftIBQAP#iL}=tCyT
zE>(D}R5}0`<tecnmHuv{9=p{h3q(M@ps}MTVRer%>?zWZRd!h_hNAG1cDZR&74w)Z
z-nD$0E^s!WAFov_5u1|Xf*(Z;?>v?4+@&rfCq2vF1?F0!Exr$j`En26a!{7rC2QG1
zA5?Utj#{#)F)S+J(KhNr-oLY(`;z+U8_C8OumwvnM*Jxt))x;k6h3wBbj{Ruq#@dt
zc#JB}8|_VnVA#C50sLs*r4)P7zexwVqlv24iHQo6iDnhbH9gleENnH9<fN6TEQbKv
z$rcDLHH$=VrUy`H^xV+>COpzkp*ZN#1|u;0`7_-t1HFN?dkA^MdymBDH7xwMv7xTR
zpXN$lm3$O|7b}uNqTe1cSGjBn02#RQ#FtlCTdJA6v=mxRA0J~0=zETK=R%<Rcl>Y9
zdZTEWdro{u`6puu#a{x}pwh=4O(oug<IjEubViJ>k6;;(F7lRw&nD;6|Ml_-1Ok8R
z0g^V)emtPR51xLUiKPFY9s|(tS$Ku*$2gpKiUw_9$w7L?BTly*%LB~$05IB(I&ZW%
z5+b`Bk1TQo1{%h-0H|3kH}ChM>X^PCb~kw_0Q~KCfPvo<cquGoUjC5nzvExhmns9o
zZx8DZAEMnN^KSpLr835HpXXHgfAAOIEx!BR?|RUN14ud-+pai;?r9rxoluUx2~h`>
z%QIqd7t=bv!G8e+7(vggjE5%6&C}HT922BVK<JyeHm$yy-MN$BIE-1d9LZJn%Mn+j
zDy0{0zdayT+?2kPj7sLV4@J~mNa&D|56eq1jH|or@?jKEjC}?K$OQVj70<K;1^&hQ
zX&O_g^-Jx_r({_S5k2Q{e6HHL%1DSKTQ8BV*9%!NixNr=ksVc~-~)Q>---urMEW)c
zx?q6@jf^A%@1~y-n$9f+M4eAyaZZn`ZmMp#HQcPjlC9~G+ZKR27vg97m=jPQ`~VBP
zhMKrSJYxnzKdA;VyCI7EBen0q%XHU*;oN0+5s+xE{sQqe58o-i^Bupm$76_DTuK%<
zhdm_j6l!Ab%AS7LKJasSNUbueE2-+uQbs?!^}GNynqpWlDJu|SN-r8`(I?H5_obHd
zAp#l15A)Ig>h%{w(WbEte+ci9PVJcj3Mx2zW<vkuC%YP0PGu`=ythH(1mTx;jSmmd
zVur1cJ>2txI{V<=*vUSTYgg;zLJP$aZ%fo^)Wfp6O0cm&{9gz+_b*G^RzDi&mIdxI
zWf^r3<X<X~(_vCNzXa_leREf5r|Uk!Jan7EDF`qM?5i)%n;5CgJ$P*ebLEv9QDypn
zF21=<X~N=>EX=0HBNs&eNubi@@umZcqjoCEX>LQ@oXe7<JmHRESX)BfyaFg2>RRas
z{hpRk6Lz4^t{xD6Lhv6qMYz2b|Lr*9vw<EiVKM0bc@1d4nxHz3vjLrqLvv@<o^@jC
zQR8syvv!iw7{@@ba&~ZL2bmI8th4|G=D5t0_Y+?E8fIq+WiTqN%3g1x+eJXofyU9E
zea;mzKIpvY8co#o>@mq%?-GXxWNFJ$^7Z$CW?GGE1>$+uH0mUmw{r}V-+%J@yW*Sw
zA^z<QmdiaNQMyujboyV4zw`@3qp0S9(Ms#0Hc18n&K}pz=@wUO5EmDPbGmd2Cn6i3
zvkwif7za9f7?!>;YH8R-)adtoZ)354^>+(0+S2Sy*#J3re_`*}yQW%WH-Xi+p7j_L
z1tN7OEm%EPJ?A_3dEtU)37b0XaKZd-i0cWNb}2%2X+LT^%j^#O`W*PE>9{z$%@0$J
z^NL05Tyl*EA+3#493J{U{?Gnd{OND_Q61>!0*v%h?OYi^dJH*qd-M`yt7+vLy8lhx
z3~M$##dVsQBVF-_5Ri<HvDkC6x9|{l02pz2#SqReXg4S&6nmK?kdOJ1{|4*(3NKVP
zJzLgeNtO`{*nb{+Zh2Y-eY+?BZTl`hR(=0T@%pbkA*0?t3>MCF$aY~5RKt-(;&~WC
zO7hTN_o>sMzArDV;ZI4-u|a2h1+IC7t56fpqeqLMfrhN5uXWm>mT*e5a<xgn^}7Sm
zBn=)PQP{R&0#|P8dTX)>LpBN09!XBe|6ul2rS)Mfgkgia9<ep-wH->TYuTh5dK2OG
zh()$NJ_!pQTe)NcPgBYzCF#%LyLt_FWmyI3I>z(3PuDWAI?pT(FD>;RDbps=5CY+;
z(iDT4q#UaQixKz`a7P$^LP*V-kk|&P_8aLh>$+L*UO)QgAByyk^q<l41Z)wLph**-
z`*;TRS`d~QHADlhZ-^Fv3+btF7+b9w@T_DWgK5=UC(0v1qJvn9Xsdpl?7GHN(pVDR
zbGhVX*X-1pp8)_pfZe$Pm|X%yo8D^&vLW}Qih@^c{K1-$HuG=vvlF2iSM`J9Z#?2a
z(BpizA~HU<216}8+rsG9ZXESTBrdevhw@CYWjc*wXlFsJ6gC0kI<-4<?V828a?nSw
zAHlHuF#)`enwG5PwDTrJs$8bH1)(LEY~TaJ!g(qV5q)F)B7_kv_(7#T*9REIglTR@
z@j$a#<?K-_TS#0sho%So^l-C}auyN;)zSj48N|bYe*_34-ne9Y0JnqgLorQpba&Bg
zfxf8cBt(=U_O;!9D*Ez?rlQCdb=h`zzH7efqI`aC6>6RiEzsefVX7;4LL#Mr73eGY
z6Y@+=fD3t<Qf{e2n}_|V|7fs<J8W0~Q|A`Y+{v}L06l4SA_&xOVYh}ksAEg*VV|MV
z5HD(#F8OlXvz_X8r|oztJ`6F*482=+7A6%GaXYH~jG?X6NLvZIHnqns93OkT7`<Q7
zRX*6?-6#Cx+}wnH<B$n}^fJyH4lua$!<s|n`i53FleS1bYL!2z0o%YqTfgY}gCus3
zL=bTd1+UJ!UjU`Ip%(FTyk?OOJlVw2Nq>F=N94l|?IT3AC(A+0wTPC*!Wg;o7G4}$
zM>#6>FtrEH9&iwS1`3!$$+qE!H(JQOdQIR2%BqPw-e)!gEGmw{+<}_wAN_I(4pCMW
zBz^OY2Y1`*95lFrD;f4|J@7BQL$-iZFC=$h`U^z?xhnqXn;)tAYR;h7rE<?f{lh?s
z5<Q-o>)jR~?t}>^cyKwf_UK<jCV_gDUY|jAOL%Lj6-v{p2z~Xs>``A-8^X{X%C(Tx
z%bgP3IrTZQYC<Oxo2-S78~(a2y;$pn#WV7Y#04Sb>NRufUeaI1s{kCUfyiSgWu(V;
z3CC;5e*0G*=PUuDNm`S12tze6dxv5axnLU>Fl_NYPYF}70PhNr888e$u@U)%prO5j
z9hGoF8RBH2C(fgst?2u7CdaIl)^-`-Z{Jv=c;gdiA<ykjZh{r}SpZt=UGOZRur$Mw
zUWghnn-)yq0-=a%Lyh`0bvxVEC(i+AYM#sP)kWUYwZ22Pg42RtgVX`g75_0jx_S9f
zoF6^R?dx#lJe8VY{zOQ@G>lT*m;+d$**M1xAc(n5kE-m>c@_w4`fe+K+=er{d|z-A
zwRgBj`mP(gJ;X3}fVuFzpS>dDJeK`rZ}vusu<jndD{%|XxJs&7lC*kO5`||`Cx|T6
zFrWhe{?pfA02PQ5sHgLFK)_?U95#y3O#yHZ-gkO<*n-4t<%s`YdFiBr>A{Da6Ah5K
z)3TtHU7Mv0v6363TVMGpso7*E(6@>h>i{Adzy7N5S`zTAG?g1OTd69K+%;<J^8|C8
z89)_56c#*qT%0Y78{ky>PrqKq@ZP*ffJ@^O<-YR<n2FuZ)Tu)KEq#i6aYIXbL_oC$
zTvSer^A=9{%Kf!%SyF2%!c(G>6V^^iXX)ZcgZs#u(HM_o^>z=s`Z{KU!gso1BS%@#
zys(P>N+d=tLC*^aZxw1Mc-#3K1zdr$7xvPC!%2ZR+3@bi`6S<mBR2M^K}g3^rHnNh
z?eN4iShopIdTZ2`nC)c$-4m?f{d<1D_;U}m?aulS3Yew-^7_UR_}GqNCUFFvr0imt
zDU9&31^imD08GFA1c3WO$FiPUbm?b55eSDR`!?7sZ85}B?6S%a5?MQC6?<flq+IF=
zT?k9zrrtU{JeG{5x=2g)tTpwy8@DP!bTWrvk_PO0p~0qfQ!K1KTB+byJrdEaN%KW;
z*1eNXBoTkNE3^f@)qnT;B>+ehckeBQ>`u-pk)+6ACw6^<8Xu03E*vzFcucM&KIygh
zbZx|LTbm@Ol77NFO+nOX&B99{K-63b6s^Lj#Y_te+@)2Qyo6SlFcred4OaFSF_D~t
zm`pxLizcFKB+E>KoZUWPX1OJP*dSeR?PV!+3A*%78{K*@@eK35Li6L}yeIvnx!(iA
zt5RXvs?-9tbnpZK0ImvJ`>=K<r~PfRTX-6G2;8!MK)vWsHX>#c_S#JVwi$Cc0Hf|h
z+AR+|5CcY&mLTn@+IK^?0dA(eh5t)KRGXj2amRoAjR4Ycx^LG57Dpi_j0+J=8vE`i
zGI;wCRvy--pY{&uO;=*nt=1ibpECwfxj=`~s`bHXm<c=6i@jG2E1KA-p%xi(wFY1w
z!FvAgIxq{v^$|83TUOPLL1bH@!FY7@^LC~<c`s<a#qJAEONCxl$YjC};-j4KS9awY
zO$@ZmwlIae7|gU5u<jaO08{$-2g)#xS=S9G1Pv}?2H&DZ&c_n+$U}4R-vbNK^`r<d
z4nk3=>fTyPAp)!oc?+CHOwjTY_$Vm6#mtjEL%hHUTc|pg7{_F;@C1d9b<VCsnBc)@
z{S==)`VuQO7eH3i!$%Jr8fPy2TL)syB6wC#KJUD8?EzW!<_qa^uYh>o*F|_|B5`0)
z?+f%B<jx=`be`|@pa{0gWs{6f-O$cLmB<M?sxGMTrT!^}1@}Eg2?zWq(qYyfsB@<P
z47_D~c)DpP46RS>UqCg2G^Jg3%4M|?4>?f5WYJDKz1l3@YuE}X<TmTrpEmo-`H&_e
z6{+@3MQetdw=aV_A2?I!noz8<a)=^O;yw2mrJSi{6uwobaZX6y%;SWR=o;AbyI1fU
zC*#6;avgDx-6`lg1X;Ra=@IrFXAFDe%VWTvE{T2g(|UOQWKTT7Ua_cgEjF1pH2pDX
z=eJ0rNBm%$;!qGi`rUWt+x$JO$FX&?o{>`b7PDxAMiuX4yy;R7V?8^u{i(y&yE+WT
zlu{UXb^dhTB*+<M_p(9=COCIM$2W%&=)pm1P)iRr+%Rjx0(bReJ)Thd--SxHqQTPa
z7WbZWD&a<d_0~50iixcl?%28dppKi5aOvQIXrisVWRyI#`ZQI5JKz&{1H<7v#ruD7
zCLZvK7D4^zz80$&lVeW<tFGRyZJFNvJ^aGn!s}OuKT9Z&B*bL3gpU~3HTwx%QdIy+
zfuPt_lwv|}&{);!R^B0XqyTb_D&qZ5p)|>`3Lp2?o9~(+50w(+$9e1)qWn)SV}9;$
z@JUmHd$IXM2T9Q(su3d_SYSfxMX?84Kzpo*mGTa=OjXL{OCj_Y8+5#BRF!%iP_2_c
z?b4o$fr^jKV;+;RvL2$Nl)F(4yy6?%mg%y^V6jg!ZC2;jI@wlkIV+3@5r!?4&b9aa
z;A!0|cT5MPU9}vT@p#}6boM?hI&@f1HK0KTqYK!H_dk01nNBlKM%T#Pc#CI+t79Kn
z*)3r;w6)*h3Mr~0Hn(8}AF%*#K)w`28SXn-?0oo(r@~Q_fv{a+%9?`aNUt@ZX#6~o
z#=@uTk8~-L!R4y3)#$V?TFxgCLx=sKcL*4$eId_N(1?aeR!AD1%RG(|5N3e<d(grs
zatA}{?{C~FGuc!eP6X_CQGC%Ue%nhL|FU@b=fjDwfQ&t_C69ujTM3d7++rT0^sdEi
z1dc8?<TS6y!a4SkZgADk`dIkXp8L<h;{bAJ#a{x|_d?x0hR1~;r1$_O?WSdO(_^@z
zZiFZ}t(!rEw9pTk4S@Z!DBYBY3($WRjo2p!+HWRZrnFsH^fAlWV?JX5F|`nXjr!De
z1%UNHw+l0ooy*17yGVS%nhHu@A#H7e24Y(C#lL!ah6<UGYE}&Rc+@ZC28j>9b{rCg
ztD5$87g8NkXMs&6q_o3bbqpifLL?WV`ur-x-|LQvOFiDS396e0J5b@v`s5zukNZv&
zY`Ioz%-}mn5g}9vA4wg~!vIP{A=F7YDo<xxa+Jk0hJa2hnblEfoSynWIpF}3ppB><
z9nyCW=PJBIst`zcBtF{XDG(6kfy*qnVjvR0Jh93~%(@_4vBb{^(#K`9d`)}l05kUc
zxBs)3UrO29^Tn-=k;76#RF%K{!2VZ!U`^FAX&-3HYVY!pxY+C-z-*ZtPSvcZX&tTt
z)LGzd%4G+_10L8)&|BLj7(90pdo5-F%l#H@XfdLwsiG>!V9DFlGBMe?UQfOu_C#Xu
z+T5}}(-oE&Rz|l?4M>hGG~I*vm^69(TXhUQLe+lrBYPJ@j1Gu=(}51;o|1@<vMMF@
z8h`N@#a|>}wexJbtqr9MD~ytYEHc6{(vfi9ln{>hW#7A1WyqhR4YMl<aftMe;4Gis
z96G=5kQQluY)Hx^r>I@tS@{Q=%f6*M!44e6!Ql=}hc(WM`A{SSYP$=(@)=qWn~$_8
zbqmg6Bs<JDAUW;~k6v7Gi<=LJg>+l0*0tkP3s()*>5%(g<%dfNEK5#JsKFKw4rj_3
z*b$AHbXhF(d(%76$fP4qEl3txGp?BWivDUj2)2yb9|orKtrvZ6@BlD~H*)sNGIHeY
zR@`of#v-Y`x-^s-cG~>*kkUcAH<DIMX&DpgRg`{0{+rp6MHh&eb))+W_sv>PG1-6(
z&53zI&VEgI$}7b|YLX2)B##<*?19slz86paAzHHeT`XlMa#<W@s&n##O`X3QyA?He
z!*-3Q3<kI;=U4x%%^e#B5A8K;8sD%$wjX08A>haP8s~96s&KIvrqUi}l;>e5+u$P*
z&wW-p9WgnFZ6!W?`ZnKYeeQx7Sc5~l?bMBMcql2I*b20IgAkK6wc$MZPsxDtpOj@9
zNFDpvMdfRshpJG(<x>w)<8*>ya7bJf`U!Q`E@J_-@w3G5Q*V=>>7VA`e?1VUNFFL!
z;}@kGFhGY4M-NSVN^qxNK2V!F-8Cq`6oH*b7CMs^6u7cmb3_UWnyqy!TV_oQW@lgI
z8q@2ZMfn)QYmZRII<$53X1Y*Tu#c>hG!fhZoPaiOz;#H%4pyU&+BPA=2WYyJa3W_;
z*e~QkI5{kWX2W#6Od7WfHeU8{w3xfHAMh(pE}eenzj8Ae?xci+FQFAx+h@U*gV~)1
z`n#4F>&E-x{f}V?2D?wtvJQYoIVOI>PCG_pH?WZXr^!IENtGj@)smM%!f#jL+EvYY
zR{p87@=p$w6!WS74O1hu4j$jngw<d!oBc_+^@V+0=;>P;6nh=?#N;`jbak}^PZWXI
z-=@lAjm09wUF$9OORxhKw)(@sN};Bkcifz0)EHA!_8v^w9<42Q<le~TcL?Uz0a-H)
z%bVGE!SPERxVoJ)vmTyZzkpWhq#>N0&Q?V!BqIIWJ$tE@U>!+-Qt{Sq5{5}=7I&-A
zO0$Q)q7H#-P7p|zQQY*UZ?k@)w0Tc-*qg)A#^d5FJCa+Pw`jVxP4w=G6^!Lv7fU&U
zIT`{>bWqr-i2oP?#xi(JS%}J<#QR<MYLfxi>F?`KhzvglRFv}yFLEM;GJJ+>Cwv;Q
zMh$!mXej0IhIPYy8eGQ`rV%qmV>@R3{h|wCgR5o@GmY*CY(V^tl!8t$a!b)*raOS=
zK-`NA>_bn~3lCH{6vh*WpOcSXKLMtX|464UEL5J8bbbk>ql{!}vKx~Fh_SBeNA$k~
z`{g1mrkh?3JxUd<kn)Bcj^8s?K?aELSe?~bM4UV#!oB6rf()C4q?PcsL=(OymuQ9#
zW$8DM3492q9f(Y^`m#TXBFm|DnB@9%C<AIT0AQuPEJn6g#){fL;oTqRViB?}6+t5N
zxJH^H%LVK~T{F6K!qMaPlk|U!{lAbe_4>Pi|9^}B>^~efxPJt-Ui(fE5n`CrN0nY-
zCo&~lI$xv$1r;v!0KV6E-u#Ol!#&tQzD(~wefhkAcM>&`#LBYJHpf}PbZ;%Rs~IJv
zU6pIO(60QV!_E1fC418Qqz-Yk)9)e*|A>p5=qQteN%${+Tl_8c7_Q`UVu>$7ZTCpg
z5S9|y%DV`jF1LaozIF#PuQQ+`|EZ-VY%;UW3^RBNW+-m>t8Y2Db8g(2Y*GptBW$61
zW5)A$0Q`(SGR+Y!<!+W7kKG%?*t5laAMxE|2wpk0MgvIpfML~8ikl7*xhENHv5uxi
zMK^9<tXp9^gCr!0;Bjg9rkPjEcP@Ai4BhhKR%WN@N;=cUw5t@z5upXlO7>;4n+l1;
zD*IH?<^>cOwalRxL6|of86C?aAbspd(aJW$m_6iDK?_J#kc?sd24S7l7zc!3LMomE
zEhS+ZI_8blLu^Mfv;vShFMKTswCQ7Y*n@WWL}&1h2iX(EPY6vqX7t#U*|4!MrL|`T
zjK`OFN2rZ{g{1Y!S$aR|HFix&cy7=hdg)?Rl09tFSa$$g-zV^`l`~P;kJ!1KGxJIB
z6%Mbh%X6b}2Eea*OlYBW=x_v&3FD@ZfN=x*ox5jUfR;l5=Nf9S0B)%&ZI{5(91$<e
zozZ$Y>x{j9@3Px=eHFy#`XlC5BP8SO>_x6hv*TQ|xtgrcU}(34#h7qGBy@PpP54qO
zZ=s3tLkI_~Jm<2nyQLwt$fHo6JdAGpVHE<%Kxc>#j2ZGFl~Xhd()NdlR)F5H?Ynx*
zGspA{Sno%Hg}@wxB94EhIY{Uzd=|MJ)TtlJ1tWG1eG^E>J?Ob=86M>j37ITMI$$LA
z{rvcTBWI+92+_ilt5zKJz&2aB0MZ0c(%CgGf|p(;si6Vkw7AgjiO1A1IDo`2{q$bz
zYCJf%vhWU!!*=cY=YF%_^g_Ojdxwyoj5hrT{^1XcAKL%?KUybr9`R0|t!#g`!<bXv
zBPJN?+O(rfPhcr16q$ZNkkaPTlDD-b(i{V3(k=Mru>|qpE+yZ;PDf_ejH`4{6{z~d
z(pV|yF58z8e_$FtRgCxIC|ddz&<*?hAfHNZFDVc6*WXF;?6)t!|Gqz8s%`A#H7qD=
z9c3?Y#NNA2llcmA?H_Ij7D9vK#L2INDDO3DHGMfcvr&Xv=o~u&5~V@F$N1E9Ei#kJ
z%<R7~6z710jog^{5;`^wEFghOOJ%@Aaq&orZ0xg}VLz}xk5(X5qqy4hIG!YLVqLNZ
z+yG?g!dWtUc!M4rAch2RfrqZiU)&i=;G^$&o;hw)---0odT@CE3#jkAxjc*md;|pt
z5LM16kd^4Z5g~cKaXqwHAJbeB<S<5%I74`<c{}@awX<KPlM4$P=~5<JQ>s*h#;0*P
zbbwVTzz^30*-|`?%DoQ|JpfDUZUI=;FeFPPr#h9n3$@#40Ww_~j|BC&9cdF@#_IQ8
zAtdT*CZuGdn!Nlp+0}jX54(N8U6R|IqZ{p8J7=H(AQvbE0GD_SnUv(I2C<kyQ9J~G
z?g3f0@R|<wpBEpb*K1AJnDHz4RJ67sLdITLYex!oYLU_2U5*URv;$O7$3a<U!S+pp
zs#J4yA|Ote9?u4;!bd9y;SiRd5#)%a<BDo}ywX=|<RsyF<A%p0L-vfF+Bw@V)Yg%}
z%E_8vNfxgS-hR6XFju#47_ZjbBPrB-{ny{v4@?_*f0!t_C^w=h#D!FgF>%j!6Kz1c
zFr(~BR&VxxtYefwMrb0o*khJ+9(CDa_=6NL?=&NvcUWGlhhDx&n?E1wCpuG*QKfKH
z(m*g9*1iACI@H(S<BsO>IChJD{-|Hs*G})I38Dfdwz4hqv2!k)GVD`sLaMzr;@xM_
zl4TmD2$=$$E`rAR9aj6Dt9k(%)GCctT;`64BPv!_dx1W&5{&CH;7I`|Eo7^Cg1@p|
zug_lpE$C+8*u`e=JQq<SQ8>Y)>KK!8LRIF?!q16XUqpa+o{K<3^RNs>cNK9D;WDs3
z6_>^J1VJJ1DFkdswmEQLyweFFqyerxO^--7V_u>?*#uplE#qG8h7kfM1SJx+mV+3B
zhj+;wZ6@J-N_3j_T+lqiob5mxWvg75t)lFWfBI``PugcuzFxlAqmeKPg6m5c>rnfQ
zK9Mc8*+bRh%CpE(F}snyF&XJDeGUprFbn1JD-<y4A>o&^fK-vRS;g*y68%!OncrtW
zI+k(>i^A~%Rqr>$>XJ1El&7*v+?s6KdMh&~x%7POi7VS7Ib<Zy+h0DGTBw~=s|kJO
zK0|-kYcu3A3)mKm@Ah0pl)<!@YysR>q5JG@N`B72ll`p}um4+-_I{6Y%>x?^V$psm
z%0+-0ds0`R@MNJ}f*#XGQC&C3ZO5xYJWj_aRgLQAgIvS8$8wRKe89EB+^Dp^ApsDu
z(n#OrFN?nn;^*fWFh4&dN@XXNt)pjTQg=}W4qu*41>p%`I!K`pVZw?Lr-*}#gx$}f
z-vFG}qCb1$)IP>JvYxQ2I!UCZA49n15^l?jmZHlxXHVAUMolX?ABZqt&c}A$OA?f~
zLIxiLJeOj8W(ORg$Kr&!EtH$c5Of4N0k5R3h?4sbg@HSg0^*8iuK;`tiFM!0Tl|R~
z!2(?eNjtduZs#$c1_cW#eNd$E_?$|%J4sV#b-1JbFvHQKnq}}ywspF`VUDIy14kW1
z%sl*Jm*@}9;^M_SBHr7%t<MUdaF!2Tja3cMtKHQrz)j~f+6$0lXVqaDZQlB?n7KBZ
zPtU;xfNWi#*%E4%&iJWr*Ekka8}r8gnAgxtlOl}e{6P__4y`W8V!G%FB@I;HjcL!B
zR3`LDP#OCuoSc*N_OU3!p2$9%KRlQb%6_botMWqAO|Xkk2TM7lMH#Pz-+lA<g=2G*
zte$V#vS4g80L>L7ndW@n$?DmGKZ5K*KdlbRK$cOL%}S{%kYvjpbs0+PumixzV`Eae
z${NYrgnJX$YHp=(Q7%g&f<%$?F{l<8V4Nf`*aj7B4cajb#Z)U`8B~W5UY+UaH?f2s
z*@}8t$o@P>OJoqGb&n=;_=Z^ge9o3&^tBy(xt@+XSgAfBTz9xOkVrVUJ0+oVCcDyO
z`z&1dLZot(ILW>C-!MhPaZ8WrDPFMkbiEGpo5_XBY{G#~f{9(Jyno*<*S^4H*^cM2
zeX}s3b?h6_&^*1zDpiCb>sc+5b|Hmq^(MdUPpwu=ALjxUBT2HI3XQaASV`#@;;}k=
zKUNg0OiVZzRl*B&aMI)5p5T*v7m|sLR9(}Bc{ub?Zn0lFXUAtN!yrpt00nly{z_yt
zP!Q2~pZuo-ex}?~CUwK=660j_)a7FTu#<K3Pe}0xt=u@vp6dezsI5M*FYJXw_wO`)
z^I?EBkKOUqJ||c55nW3j#SO961*aJ-+*MmeKwNVlZUv`r`i^&R)RFt72!?R`t#1|I
z_L~jG34h9Mc1MCcL=}1-pON-*ZDg!G0og4T?(j9yiCHEN0%f1)kwyE;5Bz_H{eK-0
zNqPbL(gn>hcteoe!>Cj=u^w+H4jn*&bNr|ub0!X1B#SvB><w6vCWN8#>=A(W*anO{
zRfYr_nagluEIZ2Bx~$m@D3YJXhAzc|wOK4*AN_)C6iGnIzg4anG-zr9SE=hxwXlyE
zP3!b~Gi&&`(HlclIP%co=yB>ck_##Y<iRcl&6n;Y84wc*5a(T80f#cHoLDA;g;0fz
zz*bw+b!=Qgb`LT_UmGekJuozlFf>-;INqk1&heq_3wQAxleo~L>ui;;jK@U-0$g}J
z{8jN+f8{q|3&0_UFs_=P8E>3@!Su?1#)_vvXQ1DPygakCQfvMBZ66$7N~^20@Yjm!
zQ>ZDf4<TRYEKq_+y8QT(o4WlK&DFoP$K1n!Eq$;5QhY1@jx||?-=vQ}Z~up`cUzL>
zxUK}>^DCU}88c~QqTaiw#r_XjH_ao$Gb1YFhPY%_*4UV-CF|#r-qhAFBY+SE0>Xs=
zC=sMUvvZ37HG6H}YkL%=fzfzwRau!H?%VfeT@KVY048faq-n8gE^Zq~ca3JhQ*5k?
zJ+%)iStyLa-LtBNM9~Kdn(Y6nec>v~W_Uv-f<>+bK_H*TEJbKb$b9IGMyZ|Wdl9&!
zzEOj=SOl708zhHo;)O%_3AcG6PT%CsO(in}Wil2iy2T!JB|HBt<q1R|D~mfDfkTo=
z5X~2R$*+0~O_Fy}3{??C$r}mX=sh|R6T?1dp90YSX0^t!NIXJ1SG~<r?J@>Bpej)&
zK|zbk1U*Yhl6A(on7Efs5sny)89&_mGuSs)d2WQwUz27^XKg+dx=J`qryzr}(K>OQ
zboB4meqZy3V;>y7fo6v<Vg8bLALj=4uU~&-%c1l_)ZKTg&ErZ?WUQ(oOOVz2C*^yM
zkP#htSenVIP$gE&(U{QyE4)s*v0VR@C<<jxQLGXwd0v{y<7v|1gR_XzS8Iu5K|OR*
za#x){3}7`57BGObkg{}-ZC`{LN<X4IZ=9*z!Cra)w-`PD&AadAH$TV8(qtRbOsCxF
zSFWr*PQ)D}P|KR}ev(Lv8qJv^IYbnM&MhlF0O_*z2N2dADtp;`Q1yToPB%V`>VYYd
zy~@i=nP{=2OgQXwo6Z%zVG;T6A4C4-G&Md(0SbsH4tOOQ)czn02^oa*F#<?>VJB=W
z1jQXn9~0#y0I7BPGmUSd2y!jz(MdNkB<61hEB1Alv~A(BdbW_01>{ezswl@5DYi!o
zIZTk+*;u=Wb6&}v*k%ptVLG3nh!C2L_4w%6aH^$tu(mKt5vuvJo9N>bRq$?H*X07_
z(@h>3zaUGs@k+*3d-Kj`7B!Y^CN_<v>PivLY_C<G@(Wa9Da=@O+fnSusidi)Hh~%C
zsJz;(X0>v}#e!M?pe{I2ew0fFN;<ZtrU3x5>xt~MijSdS#JAhS*}yqsOXq_f>~m^c
zS;32fR+2+#=E(OxIA7e}OhYeWGh?uwc2iIx7<Wq<<%nGrafTX@{A2WcwRO1nPRw51
z3sgOQ({pECM@NMys@i>WM$6dQL;F21w8PM2ggmvqO+f2MBI0JwgC*=d+l6Kg$&qyb
zdb6K!1r+SmElW~mi;g{QM9hQM-`B5S(Ml`)@Go$w-T6Uf|DM!jhef~S=nrm#yT$n4
zlpC|lt8=E~ZPGynN_lGuw5U|bpi(y4DI%D~i-Si%{!y0kbV{%?C#fAy%ISs{QdK#V
zVFO>^1}MMb6`Qx)oj0?ZLv0RISIK^d+>U6%HKxl)gmv#y{vE7#4V?$zm+RLw65ZJh
zXy7e-QJ$Q2wm^Ecp8O^$Qbg}asSZj|8ym}QRuzXa%LvoEgz)y}+%`4jIRKk6F3geJ
z<wTR)(O26Vs%oHn-#n?Z;>%&=^7`!?zAemEIFSYAu2>F^(Nmmk{@zSPCCbS=Ne&7@
z33r`Xvy9@CQ<gBUncI`p9R>j1c~PmRYZlpL3n!#}G44yAMqsSR+<j2unyXr_Cg`o;
zIj6aOrOrY?mrn=BT*-cp_9ORupv&19SkFo}zuP(9&MFV7{uu_?3-?ZG)Ii6$n8pw~
zn*zN5yYMbcwO`}f4joC$TahhEc>f*mES2TlklZTG@zjuBHn-(iz}<UP*OmcF&-BtO
z^6r}oPW5T@Zn&~mXxLn7gTcFnJSjun%T;h`iKJf+Do&cbzyQrV|DY~M`<PH}PfnMR
zO=t+DMJ-jb2DJl5dg#s<p70AOZ_am1a4gz9Z$qVo_HLm1U?Y!=-GHG(SHnBYy{?>G
zS`9%WRs%!IX?C9?MeODmzzyOIXY@2E=>9o`4|PDkD`^V!@a;h1ye8lKnTu@vQHbSt
zXKrFr;f|2qS}X181aGR*CjwvUT__79N9meq6k{{*i&u_=S|t~09i>@<6LO`(GxXaF
zYP?6;E}LkGIOF!3>Z#ZfmOW8>%#2ah^^<9WEZilz-twwjYB>b%LOgH6rI6e=?f916
zfk_M7cvn|ng{QPP%BzlU_g6_Uu5oFA$+FePn99aT4=5aym$!#v(enX@xw-Elv7>r~
z7f2nUP{{Y4dQu=eR=~ZrQWrX_O7y()x<=2_$+pc@?+0Vs8S}t%=aQjlSS>C(1|!p<
z5TIH|b13%~>{UYo)LK}n6>K-iX|@SNjX2=`2N9WK;}SY?mTd@rOwPgWYdEf1RlS1n
zNm<w(!{65S0pNlAf~Q0YTuG}L$N@fD`N^rDA?fT0eaHMMnK{Jfrc_(+pv%v&P2Nvy
z*|!Ote3C2CAk1GRK@!@*YbUqk&1YN}b*3C*c(BR>1nCaNMycP%GK89Ut^3fE1VNCx
zH>#uVwxc_`MFzY<?(XtO2F=rFYCi`q2pz-jZ3+iaCmlZWg*%n<B6hC$y@K>?6Oe9D
zXXM`Fe`gqv&-2TpYxVFah1~lfx;eLUsjPDtPo-@SxrK!^c?5RLFe*xvQ@6L8SP_DW
z+?;+CtRIO<KSZDX%#IvQLz^{|cIi^u4bay+Q@VA}gQEPZ`?h1=WPkxB+ouz7dW~az
z5y~z&<hB7S=OSrSvq-Xd6Mj`kBYR_aY)6TG$iy96iZg>B($Vw+!HkGHz$6<0{CmGf
zZ$6~4*0}PcvmL8Nvl*@NxYlNUnt!(J)Fy65J%fjcEL`QY-X7|_Sp>_a)}A8O6fV00
zv{u@PR>;gcf}|mt-xYDfY}4n>fI3__%s{umF1%E?XlHaqSZ8|!^NuK7WV2o@Z1NOD
zrE18c!Eja$1CGR_?_NLSui=M(ftaS=_FWz_7CE5dD6R;7@h6kDLEV)XPZIg7$GgV4
zJYdY*^;oH35&gy%sH@~-X@1pco~lV_qg~HJ_n$!5AE3g;7!B&1x|{aAYHIh%fF~$P
z)pr&C#ax*^u{-QDl2hw|KFk729gvmscwr1(06crRTLX70EX;b^<dvtMHhHM@B$>qZ
ztSbU^0&hUq3d5xN%-E@7l@4uy#_Vb^sGF+5y#FQC7`CZTMG$L2vlqUBF8=YP-Qp4L
z7DAKsXq;r%!d~i>I!MU3Zg{khU6zV>yfg6qVeHU@X5~~(%_CfPM^{PO`bCcY!6%Ix
z;7+PnaX@ksj<1sKov-nXZD^6|nI)*~ON^dqZpFPOneEdPL+XpI_Tr)dKa&5#kMzI1
zT0CL{Br-NU`@Gt8n#rOgsdjl@^mGb%yPf8PqPkR%rt$;e2jiDqv$?<EQ1}f!cbl97
zcGjVlpkob-6tQ|_rUsXTe37Cz542F@<^{j8zl7Bi?tn*sN@M%>f`tz4>8#@<`VT_?
zC-3=*^D(5DojS_f=B(_tLmgQJR+g0Y&+UL?3M4NA`7>_Hv+ifQHHOxhVoR3Y*@^Z-
z)(Oj?gRA)xU+mL5AW7=k4ba8^5#Ig1>_VmPVz}pEcc0Qdh~R<a5I$k7-Ou~2ulLvH
zXCeDzN%b3|QnjD%&`cidJhy7)*xSW2@0gFRMa^1`JJ6t2L)(e~Q5B%a<ifVs3SF7-
z;_VkzGR^-+g$}jWQ*&34BtKI48BC3k{_l*8vZTPO_-%k<40a=~dj`s@1ixml%|$!E
zo!$GgDrD>H4UlbwXg2)2vkq_sQ;sqV3xM1Ewn5i3w0`GGjLKi|pTeJNV>r^~^g5|;
zTPsPTCa0L8-<W<MaXpvFq!1JZNVIwP2#UtkA{eMeB3Ez~IsRx}P_cC1<OrRCs6acl
z=Lh^CHZ;CfgmK4lUbyFt66dJ~BV%?T$uv>dG`e!&(VTo%;I}`?(C3rBK|h&Mg`k>_
zDPogSn9G0@o^^|oXAQM|vjP*En#@BQPp9AiHK1NQ)V|0tlLtoSwe0|-u0lMYb#!kZ
z0gkq#YP#MF(E_qDWL4K)AVqS4eIjFnTLd&NycUP516dpt_u$pV9O{L?p}5ar;X|s(
zGlU(XOs3+H(O|_aSHH@$WJDKR8NXo&XCJq?KIBTBwu)US&|a5G_V_{FU4ABU>S$m|
z$!ObY&{4*W^s3(di8@}Q)%luaWd!D6Yt<(h2zZC8TUY^Ma4@?3qkYP_gC<XI>2pXm
z05d?$zh@T@rJ-i=06OhSzIxN(7S#~AzIrU&!P?#q6EGB*6Xv>mRRF)a|Cs4VYCH(Q
zRAB)Rl}`8EGOOK?j^rZ;HD>!rFE2X%u7RbED>uJd>sUpoR<DzGs7JgEPAq2a_}o1m
zhgQ!on&Jif{$oh5bdY<(H*^ZHf^=ec`hiWv2B)Ou;8$!o?-c+Bw6iX%yh0vJS1Lob
zbo5()U4xtO9^gF4&LFL6f>7$Q#H+8$CiXpHfETwokUHo>?GA7Xh7x01IKu}%f7zMC
z(F15{<Gi|Wx1lb!Lw(@ofe%aoOMLf<@dc*kBDL}Xeg}?+4|H&P7AOaylbugj%#CCd
zzv$HV99<y?JI@&yZCE48<j@m#D~v@Fh5UtyI8WK$!;Aq7>biya-~aZL@ZW5|Vc(uy
zr|t~A5WUHvj%kHvHi2XoeH0i`h-=9m)=oB}H&NG!+G{7LXwzw7#rU$M^S-EBx+gV_
z8|%uMk@cn(Km`VaH3CtTpklH<m1>+pWCNW<(3GHf>@r7Ewn@}hTp>pUXYVg45~1k&
zNkz&1_ace&Xb{p_X;hfmv5J({l=GQgNb{{^LnVSirlKzgE()i_>h<HZcqnBhw|vg*
zoTpGQaeC-fNY=*99UMr4x@%fcN8Y{Tr^}_dOBvJ^0*!p=?qGdkDbnX}l^^TY;|KP^
zP3>}ey&dgd-Mny*xd}*_HCcAAiY}I#Z$}gI3lteu65q2czyo%B&cM=8QTTjV8047;
z?Vl$0sB>r~LAK!+xp0fu5;0o35VkG=Psfrf`Oq;&Vskn<*>ANRerYeou1Q}y$W*5S
zXwQ+)^WrdL6k$ohAUsD2UWkOM%O9@nLTNH{>WZN^eqdkjIUk&^ZZWAzDiq3~r=DNZ
z+tYW_njr>vkt;zy)pVNRAw%EK%un?Bbf-RxE(nq@iidprrPwDb*bmKcHe#UgFzfZB
z9G*WhIl){$uP{QCHwY!P=*`}j;{LJo1i%`G8;H1?T5}qjeC!S_j!Z&TdIA{jWn;Q%
zGb_N}ssFRlejpoTy5cq5PwcdZC!VAp6leBW!swRYZ-(ZNNpZvrpT<IqwR2SYusW(k
zQ_-t+&v`{6+d2UC?Ndz&1><y=Q|#_yG$;7)>PJn)as`nw0)3XFugZeau!W)G9E*Vl
zDsTibiGdiCZEF0;x*%Z$QXUSNwmuSynxHX7{$Nii(fjET=MIcs@Ezrn`&?qyk&LId
z&pd5NH5Z8r15ne<qF3*ZVvpLLDurarXI#5nI5OKY0!zE8R6B0E8Et98RbZ6UCsn41
ztFj-~x}4?L@1%w{LFSCmeFAlNG~b09EpViA);!WByFW(e1T_$ZCeO=lnU-78Y}vH+
zQuT66kh0#$(R<N+_~9r80Mn~}qMEr}ME4fOpZl`b)OGD4ezb3=gH{}T_S`iH3a4IN
zu99?(ZbyphmQ_}9r~+mgnhADc2117p&L*oyH-BIoTWg>+Qgx;;S_|3tkgKoIZ(PI^
zy=Z`6MK%+6aEiL@t=%(ym!i}}&K6FC?qRA_PI=uVn*7P1<ZTSDbyiDvg5u3<F4V@)
zrW2DIR$55lH|m&;+WiePN#r|SrO(qFC$&7YoTo&yvQ;|}R<r!6{1^UQe+zRc%V*Dv
zYxL)ECkO5l`&-u2%_}CEF{lBx3ZQ9$`trgz?=yEDMX4VOg?7Ue3y*LB!F_L!d;ovh
zq_TlObV0|3YF2l~I86DBBG}6^*hN^6vJnlIjnebGa#X$q#o$n2Y-;SptwjcAZohNW
zGC6qv;k%!Qci$eufa&zg6LOPKfX*$>D%+iY2k6oC9nDjTZT_{r3{s67k6VZ225v2q
z`1(9vYC0=op?Prv+>uxnNjN(~tFdQbz314BZZx1+r|q3*$E@yfno{@fh$?#@aWSE6
zCZAevtVqm?B(V>E=M!3flw|1^2f(WkwYjOG?aiHLW+^nhfci;k;7Q0Fb_`ICKGaCe
zCc3Vx(T#1Jn$xqb5JURztVppH3nK~e)|M=ANqtdAMr_|YH<*|o;E-PmrWf^_)u2m|
z>{7k*>^;HT3jAYV1W4|}IYUbxFwgQLCpFEnlS~CHi9whcv!?MXvD%l>Gb*iD3I#)F
z&-ou36<zX@VZXA6!t0|4oCKDZH{YrtCft(hl5-XSi_m5oJI_)K*}gtZaX^iNN{eT9
zc^MRehZfD+mx^(KjtkXrM;{07v(nITf#GANSQ>U4I?`+}*axW822?KfYhaULLndy|
ztpPpmm_B@qzDv6=>fkwM6%h-|pol-LtspgrwFMMcV)u+P33TbH^E0Veu-uVPUf@U(
znX?dCFxFj{F%&p@9qk40;W0YkW=416mJZF>EY88s%uXm8s9l48va!n=`h0RgxQ?f>
z&7&&@{o;3RzmX&R1KhSme(T=fRq}vLcqyO|plM5KFbX1G(H&+q$8|E<G6nJ{#*R`v
zisRytL>~J=+Sdy$`OQf+Y&xb6kn6B4GeNGgYMt2Iz*jC%ZU>5p6<vd1&}I=0O+zYN
z{=e_OmRg8${SSYoCXE)fA$M@e+Q@9n;y`oTNiN)uvUewkKO@bSXbrw^Qa0rYMXlGG
zI$W~Y39JKz18ku^OL)-&G#^X1Z&QNaL8ngZSBd?_19Wx~^Rf0mZk=0g7?oQVhtboo
z;2B_9b~b+bjs2K>gZl-q7T;b{rXnMRw$=k9CN@zz%m-#K+2e9~F!j2I)!vR&kT3e8
zQ1^-qd1_kX2N@mhyp)Rk@t%H@&IgCOTS(8SgXHVS&H=<hp;w5>lY5`e-2=t5ULN-F
z*BaQ-ZBj(0IU20VF$jNdqCDD!tEmIdPN-VL+H3-Qd$$)Qjp?_LUfSB_)OL<xl0(d?
zOjO~J6L^@$Wtto@QSU_(cu*jRtB0&q%GJjX>flqDiF4+qxDRva+!~!$-oFg*zJ?;R
zMTyscf_~sfy42cy06BJ5$!bc#su9gGH2#{XWt4j^RD$q5gUHy!*0}0cG`RdO%PP0F
z16mvc&-+IV1sIc6o<ji~Zmwk2wAxZyj%T|p+t*04U<v8Z!vA3_q}=s}!@^;;_Px9@
zB6_Fs#Sv4020#wddJ8vTD~vK(XEPQm%OdVf%UIxLyg*=B$W1$W0}OZLO3|3#<nZ;0
zCi{-KN2#lOi(%Nr!vKeC(|)1GRNS>ahm6U}A%MWuA=EYlFfL^<V#U%%>{5-@VkI;`
zhh;MWSQ;P2SSZWO%Nd1?>z|qL8@ONY=dBVF;XtCZ+h#_Nrve^us|C~ByU5vawx<a9
zMIFiQhbN~}sw?|uP+z-gQ87|QyOwp&h&k4j@HHuR3()aCTFrd<?$?38v8#ta3SWKh
zfZ{FMee%|)S)qs@qB?xp^(x)et0DHv%Uk!#wz2V>LE225S%YyaxjUMSSR{$&_m-^(
zaP=1UhrpSruiCbe)9bvCoJX%rL#ZAH9DTtvs#2i!-Bq5Tg|L%-gdGirA*__-0}hmk
zD>(c0EVbU4MH|NJ{ipD08HO+n>IJnwD<`#caZHdt?2hecZ-P{imgZnJc0eoHP1}XL
z<V~}DA`pGtO{&KH%=#1I1x_*v5TS#3y3%ZW&Hw{V#{$&^)D|_rCrOYl09ED^0)sc$
zIh179TckZ{F{oYcCGs3n_hAq1sZz??A%uVP`mbzz{MNR7(HP7v2KJ|iN@XgnFzaLK
z{5@m5ds=BWE2nE>lj)NAnNkjb2U$zLdZy=Po2U^A?7d^*Et-77Xd=ftC)p5#wAmsi
z%*s!7L{ZhnGph#ZX*i*=8$uQ=I_ecQ$Oj0@qPZtKU9dyv#Fk_-WXVYzKy~yhhlCu+
zTwvI}`Uk^IDHU;GZ5ICn=J~3e=jL%&DNh+EE3|$&Jw$=mpD=AMbCE1yl>5yQB<l4f
zkqr`x32j%@S&FNo=Ws(!-63Ak`{{P-AlAT2oXHfwdJYez^rnn3(L)?~U>o(Lmt(vg
zEHY+X!5~g+f@JZqr)H{lU?rVEZB;!~1@6l3VH?`EbnzaPOH!%v{9Ev4Sa`UgHku<3
z(wFbW@?l}u0SKvdQ_$xOIU<P)d7jD3YsS^I`8tPs--zhs$YiC~2u7E6#?{`sL;%z}
zW6c;6p7tve-{-P*zkB^Tm}kF#_wz%OV}{rWAA8?rj;>X3dr_|iEOAp!blDk9`Ei6f
z^{DoyAZmbaj{}Fkb9+eJu8+{=Q*+1a-CYG-TQ!t(MS+l1c9U~*Njq_N7CsF;5IhJ8
zI}b?0+pDPJZO?@>n4UVh-6Q3as&J)?TIY?4YdZ8RSG-<Hd1rK8HgJfoADhp*qBdca
zxNtfEgOpe?Gq!TMF04bTfNwdEm50~tmR}9%r5!@dH-Grcz~AIZLAM#*Wegs3?3A&-
zu;Fs<UAiy3P315NefE+L4&bPBe!OT7)Ocb8LE}|+p6$YgYF((X!RWK=4T-WH*<e<8
zI}-5SL5-K9eW3P67pIG<TPjU*`kr;l6RB}6x&?XPygUe|hb9BV%ZSKr*x<BulZ&^l
zsx`yuHpuYBht?#w?Skx~4p2YBymWw4Ne~|0V<t<)HQma+Kw{1B<U|eS`h|vNs7=S<
zci?o|Z!}ZzL>U1<VG2c)9+?lV0kkf3?9L745Jt-G-1nJWf+nHcD%TNb+HicJ#pHbq
z$ovF26@!?@e+p$_i&(!EU<{XBr=Fj60vxzYKtSv_TZbZER%1wL#nh&{8muz**?TIs
zKHOCBpv~VvPnT?;y6pw>4uy=~i-1)Q>nfQTK#vEV4CE?>O(a?Cj)4?n1-}9Se!6P)
zbX@gX{o*db>*%&OamU<Qvibb@JHEhk=&U`EoGftBJ}yW4a@uVDp96+f9Pq)>`LK>E
zxe|B1l{@&1#C6lTNAIOhh=!R*-87vg&n%YGo!m&c*^BB({sdb#cBdTp!+4SeDst+3
zn8L}~$*slh7$j$ip?E7)B{)-|ebjzxF8d-GW&mHc&{b6t!q^odc|8=f-VU-Cs7emZ
zc&^Js!KDllCi|+|Ncr<;g=D3L?Y_506^pgoYCGH|QXR?eR!0oe6u=mkCZAV`)BvV&
zC!7_yt9sK3PBB@Knuudc36mqHHg@0Ux_6k0wlGkDz+EawMGeJxdtcT02nLp_;eHT>
zM8D%g6`4n+uQ--{51KH6ETqJKtA^Q}0znW9&~5Z+Rh-L8>YI)-Rgl=UWF-iUurAa;
zOv~JQdAV(@dsiqs(3@y&KY+KFL0aXr0r4#B??FNiDcVK`JJxYFM<M9$jcg8sxOj8c
z4`93&hau@Z9vYx3I;tmPq^cJ1(d+3d6>UFFRx@AG{p9%pa=`A=jGin7M&`|%AXlZT
z<QR54sRN2dbWE%eT}RqM;)uvb%WggY*1D(h4qB^;0Yl=|u~BCVIo%RF<4sa|$OC|E
zdUl3I0)}NgFe7sLRa8G<%nA-6>X%u510Li?)*kF4%alNNVtwFWUpQHqZWGBH+1vb=
zJk{Y)$l_v5AY54Q8&=iR11QLS%<fW5++2ld#GdX#es`R+U);P%@x)SGSQH+eKPWM0
zL6g}FGR<396LPDbv-d~MH(o3s$_@N=c$bBVFxqOJ$wR3BB@0kJPDv6DD3;c^;N=3K
zw>ZZgzzz)Fr>s+9*2(S2ch=n4TFx_F&O^|G!u_P?Ven=<^yYqhfFnV)0zp)<37t-p
z*=AeN?I;utQ1$E?$6R0ce8NO3scJS?=hmqy=_4~RZ@gHcfQe*7at)W8?&u$&BC!yI
z0XKxcO{-oX1tK#CA8`&9GLeR&!v(Jdi}#!6e-3bo=O5@1KE;=p;tEo+^9qn1-J&_@
z>tO;&JvCw>S;2uoS5GKln=<UEDy|za&YES?77CAsrc@Zh(ccL%-}Yj;%(S200n`<3
zfC@zp3A|kUb#hty8JJZ>RlUzrKh4B)ku2yUI<aHlK(2@F#S!Fj88f0q2`Lt=ub>Ru
z6GC^5qz%=BXl$*J(cU|%h{=kmbuos}wo|XW1TuDtu5g|{X?klLL%r?FbS^>YtVo+6
zNjI9dzNr0npnxeVi!yFSg`MBki{#@3mCD93Bx5ERp=ZXM>khMk#kInLZUHuq;&XsD
z15QZgzbVY{>*_n5+s_A0X1Ns2XJ_YFG;>Vk6wc6V8x@}*N9(ksHMN{j684@H`b6`R
zO{oeau<8^T@TS4@H8sY+;#JTvvqM$k=mI%dagpS4wZnmP;Ks_K+T}bN$8iX5LOf-!
zY&`ynT0X3Sc1+$a?kIL5w|rf@bDoaKcA^J=uWju!^2vrBF{r7oWE94^;7er#+<_I4
zJ-}|!RP2W@@!^dxDZK$xm>FRu*Y|Yd3T+TI|MR}-1ql!Uw?!UV*}$XDKkYT-hEq7n
zEjc>6Tc)gQ#KyL>Xy-K)Y9A1dpW4cpa;1I4W0#nO<Qg}ZfpgDk*}A@<0V?g+w^SWc
zv-U+%K+H>CLUE+itJC(Ie5qBQjiR0W+J#&i`PqqJJuU4^pZu~D+;GP&(w^ocR<18N
z6#$Z(1R)DMgAa*)F0I<VxF$5vK*&DjqJj$ni7N!r)ey|<owflEJ=83HvSdG30c}sH
za<feJoP7$`Q{!nXKBxTDPAfB(167ZOKa|A>d%3S|GqFJl=AF|aW#OSZS}c|%Ww%m6
zvIuV^O2u}N=mmJMJI#`DnbL?4GJ&#A&op?3?&%JT$&14+(ATr!<z<1808lCfsjPd2
z#Hx7m?H6>dEeBtaNO-pdFf@|G;lpJ3o}a(_F1-5=!UO$)o*Q5$qkY|`eoEECdE|gr
z%-`$2Uf`{(H=!XNUcayrrvi)FF^1E6$sw<Sm8te>BuA)x!4?%~chr;_siWTSS>VJM
z9|eb}-8!i%2)+=GzJ}(^LuP2IO#V4RgxfF8-Hy~T_`Lf_O?kON7O=*x&}bejY_19k
zrUs4A4FeQ^O;CCnXs^42L7L(!sFJ9M`WA;-lV$nYe5`E(kdOiqmBQP4x(4COlbZrq
zI~ub#Y2Q%#J5?JVPI6W%U@CeGS07NpXjuU*xtDknYh_ELvDK;QXw$h^fV$PVmcjt7
z3bls01Xe{G?wk&T!xc7vG?{daQia2Locw<GhrfQ?eH<cNZ&xBBb9FiIye(QsS@fpB
zglBL-OySr>-$45{pk+crJ1RyPbr7cnp7OyO5OB~3$Yhe9B1%4((-+=yt;)(=vK^(P
z<Ju^~m2>*qGwBbZ;Qz5L`a0*PzE7m(L!8>^GRN}tJgMFox$rGoQB;(IuTq}!T2Q`&
zFN56C;vvA4MWD$7@?GL<TS3N}7ToB)vMmF3Qg1o`IQ&Kap3Vn?5FE9dc^XtNw{S?L
z9#r>e;zz)gy_EgG+K_Bf7Yz>MZj#?yQp8gKU@Wavp_<Mw(4kc0GEa7;=1*lH1#U=<
z@Pv>d`;VgshtekAS{N$ZfqkNG=+D9*<)0}@BHbI{Bhpd5LsoxQSkfJ!NQXE+O{zbX
zznAP60Jp3UCp(^~XNX#N-u+QL?*c5){h%SHLXd8Vz87H<_(rjTyig4a!Zvw+?0P%r
zJX+5GthU@2Ig<rU7!b?k?<izWkSxKXumAGyvygv*#=$viWGC$rI*Hjj?vx<qYD&>9
zaXK+8{v0$oK6&?hn=6_~>6L8nST%c=8MZeY96bn8him8UO)C6yPLys(hxTt?f5U<5
zZ}@9I_;$k#q)*^pOQGMNY#w_7B`5Z~#1Tohn2JDp95DqR)$Ao|PX*B8q}ISqGT!Ji
zU6xn`^<D~{R#_&%*;>em#oR<m^l+gKSEr->9#>8dQ<7;&Sl$xtqDH50N+K<RRn>r`
zctkN9n;k}HXp6EmEsx0E(Jb897eKBMNvPrOoIl#5y(J+g`zCU7b1kVeE<~khS9VnQ
zazjGZCMrTP(DWl>uYsQC86SjCCHS7fv0kW)Q!DD0mEI0LSvxu!XXCRSvmLTa`Gr-`
znmvhZkNE|9T(2J<2Y}PWBE404h7}p4L<LAj!=2b@e*-x$)4?rc*+^<@r{+@rzV|(G
z%ZX&dSi`CzY9Eqin@tF%&>0~SWWG@0g;_MX1Cdw?wU$SVVb|FgLc5%1xCwFYDGz0G
z*c@`NuVlXz)?yDYj=b|EJ$+~_rX_@SKS}PHoV+(69LY*Zv3frytMUjU^f7P<a2hTy
z+z0#yCVWWNRJTDchEshlV_~&oUZ=Aagn%&EXT{aB8x{_t*ESgF%!$sCP7nukiw5e2
zDsjJs#NNI@{2{uVE<~AJAIxR;@?=SpT&adObwrz<Z5L-BMDL^aAhCKQU$QhCldS4a
z$ulKevUMmlfpw6)!eOx;gZ5Gd+^8$OtB#2`b_TbRxGIiCO)Tu@lFfDj8?DI~2T%p-
z`(P0OifQAt6+2}#3BWS6hW;G6D_8Xl2BA?lGjM<^D_~9UTXzVzv99-F?+*#N+;xQl
zTDSCI?zPDVlr#Mv(MPg$XOzG0EILV;rDeRKVmP#+j@t!83!ZN9E6$y-k1`UZVs<S%
z<z!wH3N8l}vmyDmF)6>vKgjtuvcEbk0=hgK<$SQ$-RM#WG4^gBl*2)<-n+P${Q~+Y
z3<dM$Jlw){YRzsPO4Mp;MRJE4CqQA>J}FYSR<_{w5|j&TpL+N4A*Q-=x#DwPY!f{(
zN=R9aY-3Y&hM`Di>MY8cQJ^uy`=a`oDAv<rv>oLws*J|$6CsrYvpV&_Kz;uYa(!B6
zs{AWMpCtHZl<Ta)kVf@5s75dMjMOD{8AF0l(m#fh%U$9=Zmv^&2SwZ=YwHeI4)$Wz
zMcvzXH@P{Wn-9$m2}k!ZID-^6yRO0}=f^2WkP@BFASKzf@~JdfC1G~DhZ<`<vhT{(
z$_wq~(B{ZFDQF!?xN~`D=%Cfdu`7Vu-VU~~p?ZcK#KgtXgn(jgB%R>~mAxjhhS{+K
z&Sf*K>Yi$=sqDr`R!*l_OZke6`%K^|JC;MTVb_6FF$Hb?q|-Bpqf=mkv}EX$W`mMO
zXdgXZRNre-W&RBZ(-Idn`!qrlv3lSgUt#c|MJ#l=0NnKf)jIb|f?{T?mc4R??H34?
zAdw=Q=8?HsWE=s#DJjY(Np?$)Nz=ij@}QzvKxn&ut9o#O|8y;F#<TG?AUlP9=x9K*
z4gY)khyT3_{8AL0_>OJ`qtCAiTv8Sh?>K3j^ZT!lJ+u$=u!DkNnI+Cq1uE^KWY21}
z*WB2#hk&XhwR;^H_9{R#6-iX6VC+3y9cl&#xE|}&cThmUq#Y#%Wps4(DK_8O4N^o=
zyg<R`r){w0ID3|!ZDRzA0BKH3ISbVrzRRMMSu?}`Nmj%Xi8irJI`@Fv6|+91GSfn)
zj*H<aGW8AV{a18}Qu&;X;mDAuz?Hc*a3wWcR!1i$$QDM;A*MU02GI|_+|=@1?e0`S
zzocz)kPMZ1fR4TGMZjOx8ka46ZV`GROICPuacR1PnVOFAy+P6*Fn5v#lCzy=gsWol
zUC^IrmG$yHr?!=(s(eAJ$`|~#ES~@CSMPo&X(*T{CyBzf8ewoC5J#AR&vxphz`EI9
z(J^UwWb1&3R`y^R9B}s3J7jCy$5V9~LXCA1(AXV;Eyp;?ou8tMsQjG5Wb4&=`w33N
z+KA8la9RniS!HX@vpZww3A<dolg`UEWUX>mVvRptrs*O{5q!q-d&;WQMA<YN=wxa1
z5%^o|6dvCa{HGmDZ<lOYM8iR5Nj5@rc;IpgUX%}{a4Xx6lHO`W2k+aG8Pv0n)1`NU
zX6~lWMRX1w&%t|G<4)PR%TB1~I=@lti~R=KV&xPnX&77!yN33Om|rb@9*R~2MufN;
zRBlBt1)!T<r-qBddeG@t&~#_-u2pMKXsh$cNnV*D9O}2CfBDn!(;t;R`N_Lq5KmlH
zb@+fNIVDex%|hOh$}(yx((p2*d@J<mJp^NBZz2~LwSLfmx}%?$>eCsJPE103Dm5t=
z*6zF30e5#`%e^fr?@Jf;Qj}3P$2BN7y5`o?WMn~n!{J~<C#or`tnFb-C>enO2ZaA7
znRnKw^6C|FH3^DzcDpZGR~%`5aZZRZ7N>B=UWofIl9B@d+jr@fpgPa18m#{$m#4fb
zGyv3mcq5mlZc)9<HT`d+9dYPTk5(zN3p?%-%J)It1*}7m?y4|5z!lZtrQs>(_UB!P
zW<+k`QaQ8@yk+c2M(CHwuCwFtGxLJ%eatV91S&ct++ZvfJIzjzS2v43@S0N_2usmX
zB7!(VXp^KkdtEy|ZeE;ydIpM^YE+UuRV=q=oiy>7YA^*V9mTLbPUxD;Dv`5>2jjSQ
z6u<G%p9CQnPOsi2k$p1z-1*7<_v-c-_|b;p>w)CrDwvn9QZ>9Y#<gXhpt&KF1rW!7
zZ9AE@&dfE7;harGyz0{GgVnEs)Kk{mabL^cSsE8WWXPlGmi{m|h@kgK5du>$H8Ugn
zVI{!Vfn{9*iQROla^ZugW7`)#bc5YhjUBzXt@wlG)04&qyCoFX?2?uZ;2<XrEW~j^
zUepA$eW+Q<N<4GjfF7EjyCT=TLOmgW2R+agAdG!*>#C!sp4@^t>Remrt~H&ie&#mH
zVYXnmaoag|`t{SJM8~GRaElA0a=Gk5g=h1%Sh7$Oou2!C&s<z;;6UopE@Bn@a3nH@
z?92va2RD9U19{Y`a=FxtU_Ey=A+Fq_`edX~{OIsraW$!%;vAsAYMU*o|B8-ATh|U!
zQ{?=T-J+f$kPACK$rlfp2`|-ybmTLNO1owz@Y6IX*>Ji*tS?^8sz7x_wX1`*1I9C&
zpcuN{FDK=Ytq6-4@w4z;(1YInhM)H^sP44Xov7M~qgg^_6<#@>W3Xm`+^%P*5WUsA
zl#I;wI=$6~dOYd?nhs{^d+d0(gas}|ob|#P<I2`;pHy9+3~QZ%qPGhL!wp#p#|0^5
zu}9Ba+sWQctI#Z7aimbn<(`dR2sTpL^p5QZHwuyUw)hF1sJSgXx)Fu~WEsdupHL%g
zU>4a`GIoyKd?Mg*9o4UZZl3Ch!|s{u8pG-1%ILVt?JFORmbdB<q`x)Ws#P9$EM$*(
zM#HJVHqcY<-8xH;>Za<Yp6LSpTm!6Cpu{W6PZQ)uw;KTyhLQaDABX>xzb=L=(vxMX
zL-7{wAQJ-j7hY>qe}GOR_txN5E$YZ>N*2merTt>1j^EUstk`{$ZQ15!=<<`W?KDmL
z7CXYT7P8fbq%GCNbD)aK)PeymRT9?iNGJrG^<ZiRFc-lE;{^DSgRPmzLs%7jprTte
zv-f;gJX8xqE22HBg9aJo|8Jqs2BQwtkw-(0?~bewq%z2Cs+3&*iDQ|}Nmc&<#&t~=
zDqGdL=v?Ir8Av{|pGi*iO?dxVZuIi$580lRI`z|7I@4--VZ~V~Y0TkT*2ys#gxD?$
zIp9W9QY%a~^SuJAgkpCyxzBa09$YmxzbCEgU?+K8lgiW%%|?m0FyMPoAZmr~Fbba2
zK%%4e0rHX51{)F`=g>aS$-4)zA%~WdUU4{J7);t;RG3FzgrELMGX9_Dw+g33ykVvx
zpUGwM`YUXVtWw}jU8%`ku~Kej+I&`}t%trNp8zbXZHr?DaF@pefYuN6EURfc)@%z6
zz(M*fhBuXBa@e<4lOEX;FY@+!5;WynjAecm;u(2?GqQoaU({r=NJC7_hj^k*!pIW1
z4C~Jy)>Tk{7XIwiKL)8mCpw;<S>&lCb}x|%^-FOQFyxq;r9CC7e<Zg%;FS)NfxpWx
zg}o;PW6bKdb`wS$oq-*hJ1+e$VT9WtqU|;K#c}8Zy#J@ykHhQtfEn$abLYC|pH=og
zko>bl)k^)a779FFVsR(cBQkX^aRF=PV(*E>6O#nyJv!tV>8^e%FdQV4B)wSIN);r^
z50%S%VENt1);YUyLGgG-$>Uy!Fk>fLr&_zh8qXSnwkDH$t&+hxBX!>-byfY^R$Y>)
zxRHe?@+%}o8`DM+HAT;iLX~$N_D2BHzvLcGQp9Ke(bq16JS{@P{FmxbSyWr0m#{zK
zMPT$j0C((n{iG#c6_-lkLz9)%5Uk7Z?!{ZPWAc%eiaB&E2HYbA9YCn`gY~qdMGVRy
zNKnTXIS_qFO?iOk&}5S8St=MtyS0`FF8S=?9@K719Tdy~IP3zMyLcJ3RY9ak<i}I*
z?St`(to5^HlT-1vp<s{%DMF|>*t4S5(YqIh7Lo=YhFffzO-f3E=gBF1%)KNzr;R!*
zlY8<bQ;Zm?_$a?#UF9N6q*SR@$yLgqMu3ge;(WRHa;Sc*tGs1CY_0HODE!I+Y#eN%
zO^MNmnSGan2TPS|F!d^UeoP!o6cS7BeZWrF_+G6J$UGOW>rmL#uV01N>~=O_LW@Zk
zIIk9%pz3<)=Kgbd{Vf0KuW6qJDt$V|n+uIum*`spEx+Uqq39BDlGw190+?5#<Wd+_
z^!qu_gXM@Vcna|WOy(g=+KR<BgzmxG9(nu8wR4Sqj$m8N@I%;zZu0*2XH>@&Jb9YX
zCuA<QsT}G+*ALw)kbbpsFNETn(${TO=vUIgpSZ!aS{q$;RAIfM-1zYg-4NI&`MG6t
zx3FGm59V!WYEv*HoVoEa3DA7VRbTb~HR#n;$rn5`3N|#8$pIMCnS*HR6rPfu(ZMki
zIy}g)`;%a94!st`#dGT1D@2yyQnSP0?553@v+sWq-hC?pW=O6l(JK_d9?C)rV!c2l
zo-s&rE4uIAAXh)qJV~#$+K~<ad-&t5eEOs~KEjF9MeaZF9WIcLGdKjYes};n329KJ
zxcr{N8HRIB<31%F5D-*sT>9dZGeY&>u^8a-(;;Pxkkf)%wsno*_0nx}KedxeA7HNc
zaPc5W_=W?@HIfMApY9yx3}0PFV|0s>Icm6ldCBn$G(x$c<hb_ab}D7YQzgjk+5>kt
z)vGrQ5JBL@i0qHT<Iw%x2UW74V}<+LJn7Zk*x7K?vu?lw#viAGJh<#g#9mqhtrIc%
zg*~Hl-~n^@sG#>l$@f<6qZ7Y&#h!YywVl<(I%mGIILjf|8euD9mD{#bB@R@OuI|{_
zI)hBtuyzWyR}<(K-Lp3M3eS=$6z^ak;9yELN%d8ARK2Ko-B^5;7qmSOnlVzrSd7cW
zc2u`(+D=#e${W&spG<@PbUQSkV2TtU=<nVSaAhyib?-G)qR<?gla7r1%PP9ol>(gB
z)mh|Z=7)(NL7AVHE??Oajg8%Es$kxiR~u4+&FMvLz~28)rkOTb`-mg9kFvg9)A1(w
zXW|6EvmdaGD*r22s-5Ny9BuXY$nW9B=Z>|`IqdvOyizm4HmUYLI7OP4TTZfhg4FLy
zm9R+A!5i&Lx2j+!oFFyx@j_~SUD-m{{}0DMU{<!X#g8@tb)a{=%FV8n1D*<vqvT{I
zOz<s`FRN=jEU5#OdT|%I{)o$fd%@(b;73GEX&tKGt+TQ*JhnXr^9lZ(;!*M&*u0uV
zrR+5c{gO;s&C;RDBohXMv58?lWlKIZ*^+-?x!x36;k}139MuNCL#?3VDZFSD;y|VE
zgQ*v7>H756ITk^`Okcg{)*sY62ECW_t3xlbfV(pfNt*|&r$%8urJO8m4g!->7`<s1
zH<Yhp=n5|f7LZxDK&oZ}Zx#;ninjCaIZA8*DDpc~b#UDQ`iw3TZBpMH)GKcXn#kHJ
z;+Miu(6X{SG*3~#2mZ54g?LXvqNVWXuUWwSa+2Kh{ii40Yx(t_RbFd6Np51m=Pb2p
z&!wlWr1F)iq!_NP?Tf^2<}7bA_79ZcLn(E;+F&At^k5S%)Ffs;EqhuX?zyADF7SZ~
z0$6W|U_~zJcc_z}`K4(eidC*=0M_j9Jf--f{GH!g+AY=UhvD_-Idp`B4M1v7tykx=
zf!DfIfR_R9hdC)IVcE@I3dIt~T%!Wi@!@1EFP`K~fO4FHh_egFp#(}c;(>+i4CXnQ
z>(ab$lAvg3T~npMfkwvz%?O~)whSD*>{1leEP;PW)cqdB(UjY=(RH5GeUUU&fJNxs
z0tsYDflKv0GP-+P`e>;59YvzPvx-w|2Q4BjO_|CDZs<l0-36$;(qRH<WH#V2jv~9d
z-iOKoXz1#1-o!YgJU#M8q(c6d9}0ban#(>g`IbX=SHlTYS&Gn+f1uXnx(_;CmC$w4
zbfY8|NdiuxhQ=MZEn_%8$z7oW{PuP+lC0f)`zlLKH_50~@@?u-B~IRn1#GCJ3BhEu
ziE6LqtA4QQzs6ALXaQkcSI*$W^RpTzHl{e;?ng$-%L^N5@Bbgt3-!ZiJ{-rD;1sy{
zxKF9%Q027*1OXtjU6FPc1JI#|UN<>>x)WL58VnQQf=J*%C~Q~6e=7#j&Y2CKx5HOJ
z%7#bj`hc4!g|%s{ULXbGs0X+Fxk^R%Li2_cymMTW%QK^2tD;h}scdQ(TG!|a3VGnf
zV9Q>~CuNcPp#|W1I_H9`kJd+4A3c(PZ`y~c3wZ~Cpl3(rp`BN$dXtSHHo0(IFa~*?
zz37-Z$+R|*D?+JWmr~sK9<rc!R>r^39dk5YtsFVF`js+m?`rN3MjCippIQ!Av~A`k
z<tvRnk4%AKZVU}xC5LV50u?-OL|-cIzBXr7e`PpTc;Lh*Tl9Zz13d@Ys$zpW-r_LU
zw9Pv0eF19UJL2=R3b|xDbq6z1R_^Bv6<Uj-j22z40|~!ts_)1}xWI<i8ep;uY9%SL
zizRm(9t}0=agHKxXLo6TQ7kBjU(r1QBtR>vmopkPJ|8Br3c2$fG3(&czY&vtd>ok4
zk&2*_a7>>ap_WImkJ!RU1lMaMVu4AKM6%H(U#4Adjxl$)V62B}`whH{?9So+VMyDo
z+=I8I#(W@pF=BKk%4g8AO#JV;kY{|?IfsffmY69EMjivO3vf&xZw&HSk^y^VbD#?#
zBFxCuSsm|9O>?9``nnLOWeL7}i`L7AfVktXTz&(UJMDEl2r)1s{Zi+njQEoMZpwEe
z>{rz{EFg|by@cLGuc!-@a*xvo%=qEpg1g5r7Z!z3y5p#irMIR~AV=SU-oP>OsmC0z
z@G9F0T3WY)cYQ<0z(ZXeYbkNysA~%&+@$WTgQv?ZWG-^d6fe$$JyABQf!e^6*_9;6
z@PG_~-ZIK~rG-&slp?{XqK%)ati7d36R5C*?HBp>^@L$E-8Hs*1OGs3C%}K9f=NtH
z^FU{V+EM<BkQHe4U!FaAS+%0JhE2kB?4T~bhvuQWNX@jI?TxxZyi&I%M90-ZbuZn3
zJ;xk>g6-tx@PhEkT8W{M=eqKyP|;z8bjCR~jVJJ<n3JpDlB-x`;j`kf2MBMHdZ732
zMw!`N=P($7{K^6cp3S3kHR=f+VN8#9cQFNFT3%v`j<B`@fqCAvG}%lo{~4ith{de@
zXaLY#A_U8-Nr5!ZfF6NEKlsV3qgJ`SSF~T-Lo@v;N{T{-n6omnNITtHB{cA1IT7m`
zUZ}u^K{c@QI-G;y(Lo;_^e!TazIrwJy06Rx5PlT4&r{!32cO<aZcc!zB_JW~ydeGY
zJ{k0xA^CB@`8KN2fx!wd381~kj1;$21?$(%{v*(AGXi><_IwglzWIO|pVp!@v5$BH
zXQjw)e1KB988j=!v(qai17gUkWk;uQX75d{<&BG@F7rCo#i1A}HQP^PPK68)G%Bzb
zimpYPsiGdrGCeB-$<$6_cm~WHu~+NuxpSeeM$<~GlvJI-NR2g4#1hqrflO}6yD85F
zcR=6+?1dU-nslRDH$iRwf6@i4$~Mr}5sr%gq2}+t!56$pHxaUo`jEFG2I~e~pQc8$
z_OojoZt3iyLJkd_3aMoy=gU<WJIC^D>EO2Z!Oo3)1~~yD!@NcF2%H96*VZW`unyxT
za0?z4p!c8bp<EXBgL?&vw1=|$4HbA$w@`;BqE5%vq;v1y1A!rJcajt!>5w6gGf%c;
z0cF#3OUZ7a=~=k+-g;<SFjP@aIIvDNF?wQ`MqsjFLm@dcS`V~@K1-aXAvM;ZwIfgI
z-=@pe3;ND3Bd>C~iP^x%%m&D^_mBXZZ-mi~ox|pa4txQI?+TAP$=kF+$<AyY@+%+g
zY9*quVVxJREx5|7l7=f7LOmp<zow*9cFEW3=%)AQj6O<eE1RWWa(Csien4wcK2PV$
zRxb%9MRE)R0g<2B8CRUK;{)~O<&pg&>yP{7o2kvmplw+&I$No?sqbrkIe2G5-Y{Pk
zNkdPZy<?LvOkkXLa^f(LIH~rMQ9}r|xUUthS>SbL7L{F5Mv*_8TUUOxSizjT%lTmF
zhpsD+CQ=TA0v87ZiS&AY^9l}Ns=Bfe`t$NL<Z4j$qBjNguQ+;LFj@AjM#)BKDPA3^
zj~QB#i%*k^X&0S7V5{u7zyAzW(=Si&|K{EIXwrP6W6(OACgaX02}nVC^EB^={BP~m
z*yc`>vC@55wq49!#nTQYT92JdO1jG^)Vx?$Z3w8=UqOXT%la1cHL}=Y@ZOuLmXupG
z6iI_BYG^|<gEKA7kUunw0R-Tst%klRjzULGM0_!;9YCrJ+Ewn8C+IxY**T$%g7l3S
zgn&M&%!RhvpYGYXz((q_R4NL2fsgxkNYFq?)Fx_v2fMQqpOVA4lENI&5t2YP$hMQ!
z&I`bi5#|`DgyaeQdm3BAl`Jy)z&_Bavpv%85ei1DEEh-MX#mJ>kQ)&Rml|T(J=obC
zeJU2R5Po5NuRE`J`p&od5TAW9frBPNF@^^SGID=YJfvddvknvQm67(Xi1Kl_(b2E$
z>Hu`lmHYGwSld_KDN%Uf!kE{tMrshsyaFf2x(i$6P`*hfhgB3!a{8<K6an~k!oO5E
zI9uDJ>)z4=0-_b58FAoWzv)Y$7{;r6E5yZOVasHXc~pmltJM8`SLagr#g*cS5`Ycq
zo0Nd<Srv*dhY!d$0gJka&)$S0In^p~4!0y~4;-Xxa!>gw4%Ot`fIkmE`9Je>0lGsj
z%CRdd#m9`9Jrs!ms2=C29c&l(t5cs2Qe*SfKMs6J6=k>4<v|U5jk_966iGLf1h%^A
zQ7aUk^q6SX)<yN9r3AdnK8hzDON6`QV?pU2QqEvU`;b{$wdySC!8>Dv6vyi9ZsqVO
z1uXn%+`K7?!*O5}w9{k}F3ELT;W(Z){UsJjbGb3gE;M)namWkN7`r<~qTyN}dQP%k
z<Hlg=w^n+FNch21_ZkYk=LhrWT!q_Sgs$#ACGwlx;q5LZuGEAa+@T=_JS<lvi}h}t
z3^^YQA>I-$C`(w9d6PIpTf6S;p$$_7SuUN&C)hGiK!2#94)hoFx^)tR;n%~w^Sm_b
zHf@UM%TXNwPi8Vyfu!c8u#>$!9_n>T!jSdso$Lhl3stvcYJI95fqOUJUA74fU^4tv
z$eH0m;+!?4C&Ue-AcJ}-Z?h{vbs&(?>$DlECbeJ|U>z^uCt;9O#$ax-Wl>lwUbd!i
zQ|RS~jD2yNrC*(<u~!RE*u49>f<_JcDk{rTx#DBem9$R{J^?-S46s~DmURZsKo(F!
zqtzcOu8?1$3)iblLS}XR2ElgX=8+B1sDh^@vGQt5k;MHT!-0#=JUGV8YM&rfPvc`S
zZ`u56iS7JKZDaXtA6fvR;mF2rtp_mwRw|{gE>r0kZWB&(dY)yQGskE!JgHHP)>c}8
zTMaEa0wFPFJi~9nn)s6PbsiJL=Ay9&LKIqpvT6!}xgW<--!SR_>RqO=o!z}^ka%~{
ze9wFHX@~ful8If+LvC%kv?U7o0lOxYoATus42Rb!Cre81Hfnz_W9ICK9V5EBR}<#=
z=H1J?emb>oxwhufZ}txeuJ~;23>D3(4Ev=f2))NkXnXM3p)X&uDA`_5>dt*yCkUUX
z47hn?qY9tiyn!g2*G>eMxk2~j*XbacG;%R1>blb-`ut)fGHZx*zN!*<m>{8W(<G;B
zR540TC^u<Q4BeDC;+PZd*FLy?`l)jl@bx+oq=r>TTjW|U^fe7tQLP!eMZ4{jGZNTY
zfB=!CjWmdw=5&}UR1yqe9pfEtRs7Dk5oq{SE3@6AvkR2sQs-Ox_5QEIyD!vQ9%4`K
zq#_$jr{FwW(?&@*2%S4vq3M1wW`$M(j;dQ?0tF+N=gHeuCT~GpScgU%?BF^4>lG>H
z8WESac$MEKm;w1llz`lO8jlg5<=POj;9yPi#@~e3Tz=-3kl)uSST_f>`;BVkErz&~
zBEfcTwrzXhu1HeyyG+!Fs5pJzI`kH9-D(->H9I}ULQ!9+R!}lw%qKBS2fhkZnHS$0
z%Rvac8#Jz<>kA>B;6hrq-jUFbP1SlbWzO59tplf*aMhHU>kKv{6wA(%t2k()XJuXK
zo*zw2!zTeKmKx6?Fy9P!=Neg^`uZIs{)VPnQtU6(zGPF?K1)KSd587`L}r<vF_)5^
zJIPYFR%;+bnHwl_AnxU-r{=42_Gb9Wmfo<+CHv53Nw=x@nd}pD$;Tr+9teiOfKO-1
zmEGM35Kgp>$!o^U-^ySL<QwQ6T%JY)fz*emTldUvnd0v0T_b59W0kGDVt7sydWp-f
zfOF8mhzZ}XVK{rKqDCNxOQ5*>%BAyx9rxrA=Hd|8q>7(OHtNd@dQvwnm{=V&H3V3l
z$Wn(3{rr$M>LsUo{rN9f#-bXHO%_}4KMwDH1E`a`8;?-Am<k+b37(;26c=4U<Dw-n
zQC`c@&kZWDL$`VG$5AUu0W=&AOA?>lW3cUtjNMr>q2hw|md$U{`v3w=z|K^Ra5*Tl
zh1RV-E+orPTD7>-Dfya3!e9p?Ka-Wa`j&R5pUHpWXBJ=zAE_HT*MK5e?Y<JNie%*<
zs8c6rNu861G`7+53yfQay>#?dkk8nZ=!kAGogUD5tf9hS_(FZPxa|e#Dfj4P?t{Hg
z&(7UB1{JriO{)NHh;0ACJ?Q>-2_RX?W08Zg-KSounZG?eymnATat}!wuXHkcfKjf7
z3g8)Yl&R86Qo<g%Q@gC$_!M~iB7jZWOq%v8i#piz2E^2w%`L!4XZcRq1@eJUYUN;w
zyQ+G#8YGq$8Xf2JNx1};^K~^OUM#KeK<dHI22BR@5i$indi{vt(5MYed+<su9Ee+x
zYeXpzsuh8$C3ClCGDs!#gzEfsY%@hk-K@ECCHpPo_4us8`(Y;;6}D99^8J;{(&V+8
z?bSi@^q0oaHjhDo>JLBp4|y$Itpoi5FmF)^o+DIfyN;INpykdG&MbnTm;?a(q7uMR
zYgG)HT15mS4zH9ZGU6Y%KA>H_?<JrYZ0C2uoP_eohy$J*e9rTVV8%#j6fidzyS2_L
zck99?>vW8sDm9y*+h-CC2<nBK#qYx#*~LEV&^o}v`HZsWdv5vymf@%e<+fOZc?EjH
zv`yJR>p@l5uANF~Iv^Xj$!0ZTqs#=yah>%ZvtyRE&?NKCU5+&~pyZqTDH6XNk8U<&
zyh)|*{V`=-v8ZYat1Lr|-LEe~eBM^Cc}Vo1i(AN@x6D`=nt<lmZ@Yr`zkrwta*+S{
zc+h)aB`dEeo-6f7^8kez_IUQt4*s~9E?ZAQN{+2~W>BFXOWjT;Ts6kIc;W%nN3j)&
zLM+Nw%r18AGqxT4C09r~mIZ$xy+^lfRx&_W#Q5w4s9;2Z+J9cM$+0R>o;VX-g}s6I
zeC2ppg0w7&oqC8183-uqI1piPP1Jt0UfewvGBLnGXx{y2`7hxAP8W#9RC4CmP05dj
z0aGP`1Vf8C9F4-ipy3SINj=Pz+VGe(EJJFZ$j(`HCIBU|>TW-(E5g{8id?WK&f=9P
zb(?1~1g#XZ)X@8GX&e|sm!rb#$EZl%hXetmuo+dl)_qj7Uns{7)G5rxbUI0vZmr@5
z8M|9W{O#*M=s@FdVX7#<u|3$vq1k~!BULs*Yp3E?u2Sbp06qIx@v$!wb{Z;e-;y?j
zT(?lJO}ins;`my@ON%+O+?FS~zvjDLy5r<}i{~O-V1PEuoFQrnWcui4%m~VIm0H7L
zviNd!6QCy~1=p6jLu%;%6rVZUfPj-qNA2hs!10W#fN_CJr5kZiXhBK1$wZM_Dx3Uu
z|26zYzAOG?_~Xn5yH5_+K^EiF;VE3Y-e>!)0-@b*teAt}Y|&U)CKYd4*gJ=e&9bdW
z&k8p;%(LLU2y)B;a9&g#(}(^4SNOjz97El>Vsrxk@L!?J&bfqU*hTkYNSj80Y)d2|
zb{NY*J|(N+R9|Lx;?x;3R?3J?&uOWDppd;n+;5SXuqD;$NEx8XG;<*QqH|xN$wO^t
zds^Pbot5r-#9Az*xb(QdEmn3ItYgL*sg<P`e#|)U-YluAP}gt;g9svI%JN`;^@CYx
z3v+Jv+Dnkw4Y17+Hyew3RMy5NrPQWFb#_JA?ZH5+CkxeAb&KC5@V3d-D2E6;@Y<|)
zfI!JIqY`R}BReMwz9qM|WLFYERD%Q55Ob*(*2?3Cx4N$8mh<A*7JwNS5=`%h)XL@~
zzu=%G8()p+>&#}CCzp+qNls(i!(M`j1*k;h=~q<w1WNjT`pLhwdR;MDNS6|8aYUDE
z>CX;ztqoMV!A>g8mOrc;*&<};d&})o{_t0?ABOx(z6&AM$VyW(%tW%O@{+Pp9wUy6
zwZm%JV!BG=+<9B0szaRG0q}H>yxhoKsQiv9(;6PBXt2OPeN3e6OZbrDpRu$B0>f&x
zPg%76^Qo6BuN$#TTu|fXK?rLXVcO~uO#vqbiM&H{rbOhCvVQCKU@D?GO-^d1ewfY_
zmPI~)eS>L(*)n<&haR&XRMm#F$1<s%QT|9HnoYB@A}$46j4t#JEi{FpJ~A9=qrcwX
zBirGR(InHU36r{w5t*gT4zSHhqR9-KFHfkqFxmj8Fuy2rSoq<AH0xH2K!Pc)`lR~p
zj);s`FqQSqt@H$xl*ejCWG_=5Q`*8c>>m|?>ks!j&}lCwQ)`{6=r!5UHBg0K)3a?1
z$#ERk8uHjx?}hC5<3lzmYO_+lSs7Mo+FkW~nI^CZnh1E^z**l^w%;JY^3%Cdv>s<B
zFv^2y-)PUh)uH?U`G?bs%})?cFKn8wb%!1mG(ZZeR38j3v4?kzA$qn#eX@+%o*fpF
ziRK#9iuV~rE>Xs!le>?ExT&GD-Ca<GHvX@i1q<Zs*-b4M=&(1Etu{<z6wC$*l)S!p
z;S4H?2Eed{EUkz6bAsu#Z7*5+>uIeD9t`B1sgUKaU2hO-PZkR79b%XV`}0I>G$0Lf
z(?V%i?ff7FQv&EC6(`Zz1=IFfb?GhU!ecpGq?@IbQZTvq(Ux{MpVWFDA}@BchX{Z(
z$Vm&s{pDZ;*<a&9IjssbI>q(e8BVqo5{oL?I2a}?Vyo<L((=gXWWNRNVXB}!D2F_}
z`&W}N$%YX~9ihW;0EmAX3_2S3?O@8Y!pp-;tuX=-t~EAfcntN0$Zkqi+EB`x5xgQ$
z)>W}88EOybE_iX(JE5REtjBO%M+bRV==e6B4`ZcRQg|BP4m&u}(>vAh;_aq_cs{(+
zAr16#Hc#fr<?hrE5(M?}0HONkoekT*F}3hby(*Gwa$gPl)~X+1K9Ny(xkYMBb@J~p
zc~x-0aOl{eVe0#Pp3-*UhyrKV*iC-kF9+>A-~b+gfi00Y-oLzUQ%a~nHaAYP!cPW0
z2CgT$^cX!ARNH_WlEAYvk9!U|mCiRMMx+l7r#L>Gzo`*vUX&g8EOC_pdyl7=?m`uk
z7wc)9yOIz>09`<$zlX{Iq$&}uzUr#-jE?11?yX4yVx@T>ob2Pu2oFh)N6*IecI)B^
zl^s1*)Cs@|rSiNW@?2n9XC)GZ;@~;L4*;N&=)NMdnTDB8WZ66-e@vCzhg#cJ?H24g
zqGfuKeSby9&H^*DC^)3s!tgjPkYP#Kte%;V;84jGNubY+?7z6}LLCO;Fh|Q_(DS?t
z-ed$_O<JIo2gU=iCvRs4sWZee4<vZZJTU&tJM0ELVdpZIwKWqpivsp}^7C7qHP?H&
zPhsIfY?t>zvV%9@_$AU^vupLz>daq4?Mh;mYf8?&KYIOz+>ZMH;rIvHbn?|He4sjN
z4|r9hU-+~WNv<5Jep-FTp#`l%7BvO8yCfXu>tCV=V7~$CU!fg6zNoWJWN>*-jJ$dG
zG!_35h+;2O|HkP-0`1BLhtxrL;pWAr8BRT+cM0$dNj<I>*|RSfG@Oo_qHY_9jaJD&
z!yd&?Gs14}v|yM;JvQ3fWal_Z7py(FtC%V}qsQ4^BWJktC-C}D`TxW552w<^xJ6t6
z(W=X&GhVK{GS&PmDa`Dc-EZx9N$7w7;k(Z`dsR#2&Ccrb2ET`dW$R4vArn!$0v&~S
z<iDq(f!1Xf7g|#mY3dYu?Ob)+>43m$ed?%V<T9lL^=IKHyj;HzvIr6(NjE|YVEf_%
zPby+J3Z~8dq=8c<Ven!<8R<b`W$6L)Pc?eXjN`$+b7vpMjO?sYE4lsYzl8sAyvu&+
zRO$SBI}@X|&927Gtpd@Q;TkuNQL-?T{foLZ*tA@p*Kdnev(r2-7uQ@`aUad9&*z$u
zNK;1jzgQW-RYpDsX1N8T`~RuMD3Vw;aAErtyk%LSn+Nxdcw+|HLP9H1MqKsR9Q3Ug
zPOP|*If7Nz*~w6|)FyE5iD&%oA4C2n|9@VPoihiJu^w8|=GLHWGH9bO4)7j=iwUgW
z4n^8<req`vn9eQ;m|fiSbN;X4$M%k~Pz;=^RX*Fng411HKC@DCf!K#0wvNvyWgeCZ
zt8A;e^_C5~dgEyWDC;cA%{>&|ce$o|T(`1oCyEQGi;o=<Ajoj#xG>%bvtEl}BZ}jU
z9jU3gj=>_u;I@O^H@dzSwNTvJ5!CMB0V*IjgY^pGfQ#<I|3>}n9SKkVqV5Il{e_!I
z;@9Fa__7p-FIly`95?N^ooY8rh4)I~!prenH&j?~ZZ3!cHPhp*B30Ge4yw<7=j<AU
z=$0b!N(_@?yr`SVcb^9BO1ng%m2lbW{Zk!jZ{5a_`4l!R_9%sxax&mEMWx@dEo+9+
z7RF)mp7Ia-ariTP5AZpGZ;lVI<+z&4#rbTju@CIe!tIem8<%9yPzh$Ny^}Qu;1~3|
zkopm|7(XaGI;irg4&T?n)Y=V0D`PAE|B*d2qpo4BODN@BG-+x@Et=wP$w;9hx}GMS
z-TbkDO&JwJM?Q~srw=seZp>+x{{>o+an4q@6Dn!R#NF`&UP11t32_Cq9La16kJ>I7
z$#bnap@wN4IHV&u@Rz+)YN9pw>TanaroSWz5Zbarr`hXJc(ThmV<D;Kq0ObX?yZwm
z9anFXKkc4wR_JU_XReR)<A5q~(WkXWEtxKik9s9~NBZF=IvMY3M`L9pnc5V;&$}wL
zhXU#gxgPCDM0mF3u$5a)`PPSuXwd?W!{kjhHAGAt5WKvU3Kie|^GwwpyIKP9Ef}n?
zNg0<V`(55Q6x)y6%N#?#`@>)7_aq6o#L5Q}ak)Og?oX^7;hux0JuswaSR$nI&R@T`
z8;jGrEQ4~ITe$H?GU{DOQX-1M@^(3CQuEvVPXhTUM`L)S4lvAaFo}NdLG1-{$1ir{
zj9Dn!dg|)Xx19dSWEdfMu_~>@WB?#2>{uB&Bs=D)z|$zi&~~jm`Kjy%KjNqwmn#fE
zvm46FS7FNul`827k@$@N9RB!^EszW_%3kTP)pzxgPn_Yq)?PMz5=Iv}FHL1Fg5~rO
zz@X6HS;vT@vz<P&p9srF6grnfHUes-i;^@*J-U?`3BbZGE|oc}79$3akc%o^$lk1n
z1_e7X#>5#6*}%E)rhT)APH2JpcM~^l!~9kiAIf=NA<LRS)<iw;RRP(GiOFCHxtrA$
zB6&YVy>x7@wPo#&vGq&`gwXtDZlQgRws9_6Xw;1@YYPh;v%;~X-)MQsy)JL!AMndb
ziBN1DM{PtFKs@vVB<4>&5u+FgW4_dx+qD9)EDxxmAh?3%y8+^`IV=?eNs92|B=wyS
z$K^Uxi_W}XEoIK)adlhd+g`l-S^KPPl6Mh?_bcmmiTHU~O5o(y<=3!_>S)jq>kszs
zO=U5ui1e^;Zy5JD>R7Ii!)xAy^VFyi2Q)j-5K?Ws3*>~|CK-3z%8?#QoB0iS?^{{>
z|B~N66j*WFDP2rOn|OAl#KhI2#R}d0R=<+qVVoT4g+bT@c(b@ns=-3@wq$wL1s8pv
zNRE9n5&nrB=!QhDaRNA`O(jcOLp=S*@aOrtFf#OEoOxHeahN2x)=P<3v@)!?=;q9#
zvrD-N?vb}p{v3-eb$Ax$wlKKio!nhW03(Mhg<C;Q?DBTD8RWEXK6Q~Gv`dDIEtKDv
zq{k00$8ht==NouAZb<N#doUaNVOl>xGJD$9_zbk??$|Z_I=p^~rWhJeC-~uxhVq(G
zx>Lp54$JyLB@mhBREz2nT9kE~2w+K$w%R5HEub*4&9$#)wMNzu)-I6?N#=(OB-$x6
z$B86Fy=bZ6J#2;ujU&+DMGX1bp4Q?R`ZT~#fHI%JJ(~<p8xDHJS!TyMli6THCrhAx
zrb`iSgBar90^>0&d%G~e+bkNZY>J0$ARcE)$q)CXdVed<m0z#}#11|Xqzz&rGy?y8
zLch=3eVNr&9^7}YUorvxlE2!gk@BC>bbd$$>Do(k5n0^f$*58X2c=3yB)A#aL*jr*
zq(T#y>=|r<8Tt;0>{r@EX_*RH<0Fx)!=3y_&*f{s`F85iWI%cmxCxV7Q?hlS_sch)
zy(xKy;Rd;1TKj+qEFC$PRhH8OLjG*ma@S9+AS;6WAwuR45B8JSGI><VNzWXn;k39;
z<eD{u_4i;S^_k4YW&*FkK>8fGcW&#vD!c615AdL5B0lOX&xf%O1C<Wu9o={dl^v0Q
zDv~hMHysBHu7nl^WB35Yk=aUO>LW!$eY~<%26F%&0-7{Zq!PY%#Y@de3Bh)RhJ8Gm
zd4C?PBcrq1OX~)ikxX{I<E<o+Pz9U@#UzzsC~3;?gUP0~(^l}kQiI-L1h%maRT05@
zfuu&NT&UwEm~D+DKuu;FtE$<#pB!HG`aKjCVFoU%%hU$dZKH~Pzaj`WuCjtV1x)~_
ziPRR5l$NOq!1NG-*YcBufPZ@Zj5nm_jjIH$z2M?D=aH>fwJa&UvOC<s-!xp4r+g4^
zGPLFJ&}PsBnk%Ir0KX&D0BHs&RZg*`HV;`96+>JOvSq*_<BqCacY8VL=dC(&D2PP4
z_;=?5!&rEw=!ui3Krh|8yq`)fq+X{CI$7UHVu3Mw;QDCm@UUSGT2R|DF#P8A+hYPN
zYs9UEvKO^rqj9=JvxYEY*DXT#@2Wb25g2k6!F$lY<NaswZeLIlSNnprXh)A6dVD?r
z??NJDRz)k=gT)x3R!eTeFt6$vHU?KDQ0c>mX<-!&P<*I=B<2meTr=J<RABUPUM5H3
zxy|%l%9Fl1H4kouCIfLFsBPrSB>!<|j^aJ1l{pIYplwYK^n*rf^fT>j>u>;=CY6$0
zG_*B1>WYYC_*FSGR_Rc{V(&q6;rdNaxPqCO8zxwFhfHKGA}a$nmoIXDFb=zcs0||p
zP+vvPwYWJ9Wt4I5cR(&pasno=&vYV!bDm4QB%%Y3sf#ijrZad3(G$=E^9OTtN^eTK
zl4Iu}H9ce31R)TkE+2eK;<bFb#k;Cd7Lt?1p`l7YTKX-IxTRq0+g7*yhQH=;C|4Lo
zSn_8kga`xO8MYdx!JF^K{E}J_f5sPhv9Av=&}tdClalxkiVUi%*8xNfj0~9T@gmV7
zJ4vroV#oTf7IkHgvmZDs_%{76R~_5kU=C2kgIVXOevwjctp`noHq0gthA8XBmm1X)
z^9h|s_z6e=v3eU6K8$ADuo323^WJVXc~c=RR6y!bZYK&;(M}=Hk(W$mJseO{yB@6)
zX7uyJ+XXY$@Ish2TF~}g82yLs4s7K?8Ft(hVL3pDs!OLvE_Q4BK&MOAfB>Ds*NEvV
zwZ~}c5^+;45tU$??s9Z`@IB@6O5K+8yobZAR;3<x)Q7KK#~m8CSOupcoY6y<tVN-L
z`Zs?8`-7AE8~S*niZ?Y3&_5`2aN_-Kb3VB*Z4~myHnu@!W5pCqvS*gCBT!0y-=Gav
zd7q<|t4>aj3bi?!#XYNf)v&ifqO<VL`~Av$n`9rtg)5$ui{?%xlLMQuBJE#Fq<rRq
zf8N?hI1{W?EwOW%bkG4inDaRDp*~)wXgsAWI>e0|n<LoO2~82YqDq*1fyzA04Op_!
zrcZk=4*&>|mu}pyRh=Uaas!UG)V!3F>D|c)Do}3)^g|xaBlGWLeOeoXv#hZ3I{oyg
z;iqJ!_G}=fS<333l#$NI?RQyqdwPnTaqZHT`ggc7B_TCs9*M<L%-%Rv?p&YhQ*cjy
zsV;eIJ5le<B2|OxKVkh`qsR20t$%QppM51mZG?7WkpX>fVRTxWA(;a_krM}@JqJAW
zQ7+MHx8$S?H=WiP4~|@~O4Yb5bnKE9j0gT^8l<{qr{$WC9&pOveh_}Vp--`LY__IU
z=#du%&iZIY9s(Rq^FKk8O48$70ro3M9xi7ezWz?Gf|3h?sDiP(-QyD`NX(HTx@aF^
zbK%{ZlM1A0WHV|%-tMdz=7~MQ%77T&`}^?SKZN{?9eS8cPyN}Bv($&Dtn*kpIV+}i
zgR1!2yd@n(&RZ2&G6l7Xy8Y+iOeRVk`lB7;!e^gLxpf4moq;plU`rXybmbgs97v=?
zBT?=#5Lm40)hajeP)WjB+fb`Zhp%ru3=y5=m2M<rjCm}-cnz*YT3J#WjO<EmQ3G8v
z?P0Q;PV*&huBVMICq~lt_(rrfXB=Zkz5On{`+KyT<X*L*!{=Zcf0N~leLvlTg^8<A
zU=&ATx1NenMXJy=Z`5@M$U-%;8|7!qibg~&!iKO(@|_BNyn)A2N7M%&10duFm0yNd
zr}eZ9stN%&u*9aG*u@o~#I+#ip{Koc0QVPtEL>T=%5=YJP&WIhM@awhjH4Fy#8I|I
z!oBKTK@`ef$-Tm_BP6%kqrXxKp@T6MGbEq@Wj8!cmNdW+f;Lq^n3e8D++rT{Q~m;j
z3!=V5Dc<%hIrMj+;Qrmauk>;<HdhU?YtvaF2m;2N(+Tj&$Ww|Yr|Ac7-WqB#Zp*=0
z?vpFg)krd7c@xg`{HRnN?U2-66EV(dymYEvj#hTKl}FhzMNlA&oN+!B9l2Ug9BA(R
zBI|!qd)=#T*>|74e&X2R@`u75VY-VjK+vrFXgwTF^SQQa=GL9uHe6=5ZO&d2AGqH;
zU~+{ZcO!mWLx5e`a+ftOaIvq&ZsJ*P6T77;__yLn@0``<o8K-!WMHUsEzskm6)T9#
zLE(GPnrB^ap$$4`+b*9TbE~tQJ8~T%>r`@oSo~$E=I+Tb8W72v5t5L?ZZ-cy8e-R*
zQVaLq!+XR4_fZu9QVYiCgHT15=R|;AETry`Few7*<`hx^WA7P$eCh}UMmCsNphfGV
zI1Q!nj1j8*Xa5X{{>ISQJEj;O5~PvO#ZM~nY6q{C^CCbg$_+Y#_X`CgB83X9e&5jA
zby0~`g@tW8Fu~_*plab0Ss9Y`Uy1+PZIYlg`Si@;eEuNVZ?tSG9qt3lPxax{vP`qT
zd`hEw&?50~^3Ma@1;UjV_w-uWBufvqtB;^GNQkQ-K)iSuS1m%@<UQ_1hWK9fq=4ty
zMxxv&>c-!r>KG>ex#=K{Kq&@~YiFfa6FHB*0aVSrn?%{C_~Zl9#2n+H7=`4(8YOP_
z@#HpDS1mU9U10SB6k(cCcez`P`USNYWYs;tt#bj%EQ=*O#ya8HR4Sw)Tb;rSP%F3e
zT~R(1@_|3`juCR(Vf=)XzfJC$wyShBbPpKMQR!}R)?SFMy*2{;bTlfq3|*xw@033K
z!Vuvj_ud?jx?y<|`OoMh-HQxd+#86Ij&{ukb%c@~bcKAir3Q_67BNbaodoSqHlhbK
zA5~{hetwyhIC^954(NQ@ldURV5$YX2P~}3Yjod5n6Wi(r!-)N*+z>69`$<hm%Aq<_
zXaG2|3sxEgFl648y4YC)bI_gpqriI%_TiEFnEn<XNDX-yfF}WLkZfdD;!k0bgQEDt
zbPcHl^m^@fBfU~5I7h6EPYy85e)n;qvG^ZO#R?EYmJ%HYTRX51yqO;uihFJ0ohO?x
zF6o24BTFAf77Sopw(Q2dylY?{Kul;FvL33u(-SoLtpU>>#X+hhr3$hDFp8y2J*^J{
zn&ARqamZUvO&7tHW6O3`$zhj@x(5RN!7`w8XG3x-nCePcXMB^Sd+s4jGh1HLP-Rzk
zpHzZW{sP>$SA5NINIG;ljn1kbPTMlmr6|#64ktvi7B_Zyd06W+UqYu2Wm?-Q8fr)<
zbYhEzs5k47UuM85SWwLJFi`~-yx4;f5rwQm{`R192C7oX+JSb*NwVcw{R6iKzL{Dy
zTY#wYBtPR}_1ma+F%Zy%cATScHBH4lc=z}iuSh<mTCp(Mdp1^eFwv>ou?U$v<?7>i
zAB8`)BU`)4EH;_r<-=8nGImy^$jgK>9d781K^{?w5ppvDawx%UZI{?IEdaD$7Ro;7
z6b9wN02o_jZ%SQrdW!XRnj_=$ua+7$g~BL#3Gdz<D=K;OcT2&X4~t189|cg)EVoc>
z+6^(CnK*s;hrfLNm;C?X_y@&;!BV#jG-Y$!eD)sXiR;w;34KnfwV+LEOuD4T)s$$!
z=&N|hN_weo>l-9Ubi9<`<w3nr`!Caa$V5P;cH_Of<M8%Py;`nz2Zk2I6x23(b5!!g
z;_3bWfK*`n@Rl}OmIDHAT3}A3EFq#fF~OLMh4aGxXTqZ%)17Du)k!SuwR+$DuBj#l
zQJW%v%CU0xCF+w4n67}DImq!s&ZJzk<}E|^1<I3nzpy-$8Y4{9o{I;a1IDrTF$dsm
z(G;MW&6xJZJ=f2>q%t{3Df=&f7do%V#2n}axy|e8rq{7#Flz5?iKDhb`<~-!I7__2
z*l<1wNQy)wHP1PXoXo(+cF%7BU0#l%rKB4|!P;6;^M}98h;f|#w|d{d(s&^IgL#aU
z#fMx<Hr~J+`Ww2Zd_&oUxS~Aiob_lvRT3wgbhA5LEnzk_AyYAFJ5dm@C%8eUz-U+6
zBBr7Q7$_5)2Y65W*wIl!o7-q&a4^+NRUq%RN%a8?BO!bXJ3&(K|5teZNbbhXSTz?l
zw5!`vi>HHVa1CzFYNqKxzYMju;$bzs%KwhSw6k{pcIK+s*B4iuMN+D*97(b8CVOhJ
zOHMDzrEMth@pE*w#%j_#CO_Liu;I*X-iS7zl6LsZOig_K3_3}tC&El<rbeVcxHAY5
zgX$)_nimodDmludda-8=l@>Q!4~^CQ1oNDIM`eOB3IY2V87s_5i^Ot+@rOIQmyeVM
z#PVN`h-)2zy_AK76|`BAC8+qby4At=2uKRJ1~7O;rNfxkEr%Rnl~Z!D_o^)tLw7yY
z?1nDIP?_E+0obdj=b@aCyuIlznhtP;P#msYvq}*cXoeJ^yPO}1f%yk&&Fu`3)F&-}
z{En#rc*luC+3uEBng%*5B=co{ZOP*F&|DrkMY%B>Nt%$pNU_Q;Ww_Zrr-MX!^{CJ!
zrm8Ch2km!~+LTSN+8UK%N-of0vuZ$73`y%Hw`N0%v~JLVNC!V?0;gG0$@VnXIH=rx
znN!huT_<<hR;J!Wl)J6_)c8NDg;xQF6h7oQd5dk3)l;iXPWz-f&qD6wr2so1jiP_b
zI>@d-epl}!jeObj!7U%Oj~W45V+z`-+Bn8iPRvp(-a=c8%OdF}_1C1#P(!gYyvZ@5
zJLCtTHQIT{C%rtNlh!GDo%m0=VRhg1eI$emVR|h<{y9`erGcx|T4;4QxQGI(?dV;V
zb5vjS>v{n;iaNDkQ=k#=XbkY;rBv^9DxprL9n76_Qz*Y6C|suZgX=Dt#Sq$hY!?FY
z!q~rR>sf<L{>kX!!0+|+Y<OnP>GgM*d6<3olRV(&RD2!k9c{WS{&Hj6X~i8WHw*8&
zd~2Z_LIL+$8E3u|0VLT^H|2c3*ynHPHMt^9&T>=>)S+FbJj9icc!^IAE00<@$fpBP
zin?WskLk44+{O&j<K~^J6?ATj*<#$tq=>Swu9_^@oz~AQVV5_RLZ`L?Q-XCyWk1Iw
zaYDKOjC|^dNH@8zhMd?r!>(o@fNJhR#fDbL_7%~mk!EfSaB^%9WV@r1HsAPupwY57
zn$|!tGTG6PawPd1?ilFT(d}F$Kk|>Rt~K+aK_9!djGDk@FY~S*_BhtL!4)+);%sv@
zCs|o|K*p1ni<HIf;5<9ZGrb?i<8YmM_Qm3iu?iP*oG}OiO8D{!j>JU&OR}H~D13yf
zfLvo@C8%@qix;8Y*!9q#nHU!!^C{&pO^(khDF)4$2r-kw0>GTL29(E6Y(#ooJhxQU
z)^@wZ4|&)YC$&MJJVsyn&K5|Wq1n~j?&}$c`ub>2lG7UUAtf}=H2aY)zXNPN3@RE4
zai-w4sLnL6=|C!1-2%jFf@{aHGntd59D5w%;anGF&2$0E7Vks{L11Pp-hIe-v=`w>
z$PvuLUM;usQAkQivR(e8AK3s{s-Hjn_xuCaK;nNLTxdp*oqOAi;Vc33P{%9R*`7@g
zzPiHVCE0NhisGiA(dAmet4gdRuDaI2L|2p9`@j+4^W-(&91aq$Pp0<DC48vv#`kDA
zl_@TCx_0ZHy}+hMcL;Qmz%PJ(iCT26Zt!zgQI?ABSjamv->ux;I7sZ#)V5)BMBQEU
zF2jSx89>qxW6&#ZU;45v&B0V~EiEND7&)5gGl=X=pttT^k7KW@jedzq4gS}!zhb+h
z{5~B2V24rSk2_MR^o|KvZYe^A)GkGsq7jM@ExP&C>-}!U*Tapbq=c@oCEMsS{k9Hg
z<DEX%aK>!^DB?Y;21zj=b?{fjf}vHk(c0nJ2|=LgEL3^WE@oGGwIkmWv%0WE`Q4=D
z@;^OI?WhmpSZBYZQ|LQemdX1B5Atgk$+>CmG*4PL6|IK`RuU_4yhQ_alo*q@*hqtL
zmTGx(Xc1zdTC}o$t#!B|E>s5sMKphiB-!vWlW53BGU^sWLs0)+)jG(8`O%M+>kL(j
z!S|HCaq7qikN|SYO>C;~!d_@{JCP=x6)<i!n1q{RwjQs}*fk60uiS$9wC`cJao*iO
zYn!F<?6U89eXM1AUa2?&KE`OxJIsNKk>4OS<dZkywPD7dkDOI`#*q$^=xfYAzv-s}
zs%^3mET5bLW9^5lqmk-hBTO5Xk~z7BI2Q~1CcJ*0pAuAOo&dnZfXT8yuv(dtHzr#G
z9hIW-1Bt9&M@OqS)1f(rc5QT#zO`sYyb!6O^l-jC(B@LNsu%pkn+v&k-IamgzNmHA
zLj4pZakc75Ouegev2=xCjLo^BA_#~K+YnN9Nj=4uz5-0LAOlNw$&CL!>4aSK9H7z7
zR2N_v+*-|P`9qLzKJkz~PO?78(E$>$Qx{}IOLlqW>n~GP`M6GAYi2ceWQt#}!O8x6
ze<_nSG`e61%o)>=uP90}s2?A&Dzfcd1^?=bHA6zhJh6IKja^$lps-x%14ixYu)VVf
z=nY-@;n4rbEs_QnQ|JyWe(Hcm`kcJirA67o@*S-eo_9F`7zRL{wmWvgzNXi`{D!|C
z{x!U2rz?fQ<m4YwL#|#VwrbOAOD!L^;<!ikR!|p%D6AU(D?#GO&PQ88$Yo9k&ik70
z>il}i)KqK)LF`8+u5o?j0n3vgi#8Kj1CmuyuNSS!eWjAQ@>wOr*faUgmRnX6%B_;P
z6Hc)=AVv}uBc<ioXgi)zP?)PIOdG^>umJpG0ad*A^6RST)~g~8j{U`VU;X<xi>elt
z$s)LUMTW;@k|Gs>fLQ2GnFO=*fsdFV`(DiX(lxY?Q+20M04!CY&`PhltOKK!fBDe|
z;YrmgXp>p3r-K?9+@%6~`T6T$U2ely$f-`ftZn5P_)|O_>{|OBO;R;F$Sq|8O6L(=
zMa-e!TuBgi(?H09>0I}O_N5UD9DD<+<Dv3}XQGa6<%pV+l`Z!t>P8_Ukebr0GXRdX
zPSjPYZTCcJ-?mu0$o6Ogl&i8WxTDZ&OvCTCsRo2cuie)NxpWY-h7gZk@=%!v1g2H3
z`9;d&to-jG8I)+dt|Y6G+)(>oP!@ScLV!{qykhkh`4|%<1V9OO=#;la&iWVnq!m(g
z)-cnxm@r?ymg}bXk_$ekZnF#o&c#|F5jgMspxl~PHA`TmI?e4=SphNL52O+wb+j&K
zuE&@Yse2bX%V6c`VuY9f{s|oiyFy9U|AmEhkZZl~&^q}JaKu#^RD%wjcL%<HiLrl8
z%;-&t8;T2(2t-5(I}+-!B4>TFa{d-6Vbv#jmPIi-ReH&z$1S%;$8D%>k^Fwvu<$w<
z<L*Ej9e7-Tdj;s8H|Ttb7nB(A(EPci7$D{Wy=RcsJ#g&OZQTJJhcFe-n=Rr9dx%(H
zT{KC{ct_5!kS8z%a9RnakbNmBL)FI@&;D?+;TSF~`#~&O)$1^Ar+07aDQKG)FnHXk
zx-PLF))n^H;&K#&mP!LiQ@6uKFP7IZ;LWuO*VI#SngD;!eU2x%N?QgP)_f|#_g{c?
zd$upKbB}?>DhG!iqL}riY%lG)^A)BTEQH{iP5oHRtDQyDII>a&Ze1ah&C!bz;GUsM
zj}hynrW*%)t84I%iW^DWP4X1M(mWK^!@y0J_PJH*(ERpbD#ME^LLf;B*sE<UX!q>w
z$$-cWo(6pe&p8#;yrC#gHU;Db9gUma-Iqn>S!xK`_vW&-W}e<+xtt1yIO42I_ik$+
z({ArsGLrr=yID^*m6c$$>2j9NM-6dAxePhif50MZ&)sx(;*c4yDf37uJo`%=^KVVX
zJF&r$yt;^s>QLmj=fl|*5Fr;omW&O7?n<2Bxd|hyPfgpP>FiB4Hv?U53+&-KTE%vg
zTZ*c?#5Ai|*bJfg4<Qi$FKPx|dxTU%JQ2(j{qN8<aQNU8R2S+zPQ4I^y{IjT?Pbl|
zCWc08$;47zs&=y6)dO8a29<B@JyW#~wxOlCQ{{t7kqCbza#6C+MF*?!x8@P-_d&l%
zhdZ&CAPI?2UUHYrd?n!Nb8URSa99G39-yZWCFLjY{xSa=OmwA%ea-{ZNR*OOWMqZG
z>8J`hvi`fGMB47uLC!sa7W#2`{ZL1L+5|Y*(!Lx%=!itlM(>5|8=I#i%V8{5)22e^
z?3tR3fLjNz_CXn&T;Xe&ISK1E;MjRNWL5z3NSeWx9RialoXB|h%21?Nm~V8=r1X~?
zpC<K+<=+PCkHI(y1*-%im%E#2Q21kI6_|Mr>_SUa8nV~@Qu1fWT2duPiPJ}O&s_^3
z)?ZSmny5`Nwn8?_YvqFJH__F|IOS7JN0)9T>_}<>S)ArTjXEzjMa=JU0vpMm(ZLV}
zTICP!`F+eD6;thDrbpYRK0*Bdgc1{#i(ISetj=_~3{pp;tRE(2MqxkJeI{?YFcoPS
zo4PH_F7cLn>bwfIt`JKt>!;S!`FuphegFE|TZz3!aqK3tNExO@5<(ycVVA6g**hxu
z)fc&;|B@uO#xSCW0V<e*xmZg<w0&DUC)M>T<&WETk=O63!6*AHAqMUXRp5vC|1tJv
zOR^+Ymgu{Gg;LUTfs!hCr$vhXk6V3HY)~7*Z8|o%hljM3+@kses@`tDH6+QDKtclv
zl|UjAC-T2~udRD+wL^D{TuLfW#5ob}=4Pr}_pk=XISyb4up_X5d7IV-q%GyB^F`6W
z$nCbN$<v`O?;QPO*mv39+36`k;3t$7Q7t%qIrK%4h|ya`s!jAXK&Vqi4SKpgfWv36
zU|Afgyx)U^fZZBma(uy6a(YWP)QM@n%hChgHeJ&9BociON`CeQGIQvsghXFU7u$Qx
zc(GWFl-155$Ud|lUseU<0)Tr;0Dmj_x_$9ydvpNn%VvU!ALGIZN5BAhIMM%E&MQ-~
zI%m85WB7V{u_aJ#td8!&T}h=;0dbblsPqdifI_nO>#Nk9Z{v{RW>6`DJZwaMYEO0h
zU;^P*VBa;tONq)&w5hT4-)eB3PTJdYiji*TU?X4+OV7*30!t2dAI!+n#kxT5lSEY=
z>FPw#);l;Q-nyJoulr_9QrzRAs6Sh*uEn9?ug~P5z@V_GJbc*_EW^7CXr(q;glaz)
zAk_vA1_1f1n|d<OTfbla&hE!uLH0;4B1Et&6#;C(4p2eI^cH&J_fB|fHOzFN7H-y)
z9^qfA>W$3r<)83w629^%@UEszCj!y}%OX|%?J4>jVU&@_-56%Gfe6({YnK1y^=GK7
z4i&(_`>e3^7&6$U1snl=NwAx)rxyF?R5-$z8Y|kBq){cM_sL)3dCECatK2YDFC=Es
zaH&uYeY3IxXV(#DvMDV1Cjs5m=I5!_dcv!@6ahaySY{TCq8<s6Zv+mQ33`2zLCgM)
zz3GCv`{upqPCh$8w|ouN1!dmmUhPh6!%V?8jZ|i|hycEzcB3kt@WWWQgCWAs7wg<p
zzUm#6qeI2jLt8R)wuC$x?%i4ZAqkJ$$@sTOwml1m@14#E2m$F_jaiYZ@l>hl7*hM&
zD|BGEF9Cjq;LcfRaDf_tscvJ$R-A^EbLPw-!6DfSw&0q(Wzfui*d~KeD+g_HEa5G*
zZD&<{J?7C}u>~^erXwW#5ypwJdr?i64bo20k4I?bf@+)di_V4nz_5!3f4UV&AvA+X
z&L>+XfoySnm84{zLV(ypqHe8;C+mdDj*VGPOViYxcz$SKZa5S3fP!73FJdWejq`Yf
zXCJipY74@cT&ruC>EIcVSB1e8KAZRB3aL*{NRk(1nV-`Zz4>wjKw7cqd7<FC;7|;X
zrzG`!WQv;@G(|DWEqqqpX`zSww#DDOL&!mRlmtOuzje$>HORdTDvF(13ChB@r@lSb
zEOD$d_4H%gAK8^TjtJNcTGym%e&r3&*+{8yuXzWqO;$JnP_1N9_Uw{byS2FUoFNT6
zPSl6)2(EiOflbf#D*p?SsxY2xZHnZ{*x+UDabC~Up4(zl8GZ5B`u+YFwnyXmp=-uc
zfE}yMCQF;&|NQMouYY*|DJs5{_wGf1*QDxnRWmv(n`SIhV@<MhGHprH>#Eq5`3*~s
zbSsqiob4&>!#?k-nZ)AhF{;vkrSRA35?>+`LZ1dt=aXo2(uXQAr0^c0#5j07zsK+x
zVHf1*11BluxhPZG@;<1~_Nnk#D62F}g{|sjB{eSEEO+q|w(gxDB5fZNxv8i)<J%UL
z0}nOlq2Hkn@@%7^Y%Cy-)xwFs$*AFF#fn;0=D#GxOeHM57lK_-_m}$v&h%4pL3<Gk
ztTO&h9TzHEDcja|VVF17Y?!gTUDr4XfFa|{07!WV3q-b$TtCFxkFQ283ej}gE>E#(
z+>ckiLO7B@w(Qbc*FxP+y+y0a+n!hy;YH=-Nj8*&4eeJx`vwTV500b(Vk4Ymeaa^3
zr?wCz-`~36eU2&IA|*xR2OhUiQX<cI_SKqEh*9a^RiQ(prI0hc*LC((7$piknch8I
zqq5#EGo<vvudtl-z!rI$0S>ch{{H_1nYN-8Oo`q^jdFL3C-Xjx!mKYK=ZDF9sO784
zAL1C7%X(xL<=V-M6Be9yArOZKLbsaL8$f{{9nNc9<^$Z_v3>@-D{8ky?p3??<3@b*
zq>dxWDdseX{L`yxE&s_HG=DN(a}X}cUU=r*KlMpi6V}B;l3YE_5Gj1pwYflj1@N3f
zUT5MD8-rkUE^8)b+5l6@CzK{|b+->agPqZ?#Yto9Z^GZWFXeC1;`$Lq(+Z4@P|ZjH
z0XvELDsZq_J_}qI6;4G8X3w_*0qrcV2Q-;_1s6UnmApge<KYRRKR_SlfzC>Cv)h|m
zEXk9zU$fk#{N1V&nLHD?jL@s}vW!}p;5_l@gM#KnNvfH2o3(%8v~aE+ZBgOPtIXv7
zR``07jF-s%;%LKDFB-y;EHVJsNk6QUMQVe=9A|Y8vAVd0tbes2H8_#$x)}sui@(Wa
zmz(FuZ(oM5{uzC%gVWemYF+^4_oE_fOovuVH`!f126Mue$Gurt;}ADHsTY#`S4dTo
zzvg~wCk5N>s!0*e(0J1tkgV6lM@hd74|ll*7XTl!Yk(G9ql*UsvPno+i5rG0xOaE#
zh{j9S4QaT<AX;mnjkrP=#4au=lTGY@<}vP#sT2IYXackpt306u*SPjI2yyJm-f`O%
z3f`itOJPN+aefls64>C@$NR}TYS*qZ5r4%0*Gkjkvj)qMM#>I^x%RA8lD?4TXFS|X
z#~CU3LGHpS<y6(+%%4Sr_gQ|mE8JABJyM2tGFOxMccMZ-y>PNMVABdHsnGDZmz86e
zhse@9HvwHWYb?NN?d?Y=3pRcuK^;wUgUx+6{9TTfKZSaWc?za2GA0x}C51=i{d;rJ
zGV(z)3Fw5%y}uM^O%Z4=dR5*IxpgPUwB+$><P|vtN$M<FTu{9fZDXRu>41JZa!JkS
zG`V^lk&B%ZSadLNJ3;lhYiEd+&UBYD%BBIcN-0}yeUhHrRLkQb`=SNj&35_qtYJ97
zB9zc0O%!`6&@4wRQTW*Km8Kqr`hD71i#B|C>WVRrmjtB%kt%u@ZrdFd4x!09i$Vh1
z(hM%uUF#SvK8GaGr<R#|*jX<9iR93*r1K$P23QY=oXtE^|BC@@M;%%8ibJ&CblJB^
zKHG$E>E$yYCqqCWu_Or5zq@ro9`yyj!s7s!WBp=?bx8W|Gd<vv?D=A3260Ev{)zp;
zK!0-m#>4WTW5NV+-C$4asCUT;=abrQF1<jDw~#P#XQP`Ai51Cc0j7tukXrcZKRy*V
zg~EH#virTNN^-1lqa|D3@)-vhBEj+~jVwaLH1m+!4<jH1h!*m+xO7{b1Cgv-rwTii
zgpUgo7352#F1JLOB<h{3lhqOFi66JXraqJ!iM%S0FcNY+(rsOl!&jUgqk~vNbtuzD
zE^~>M2Y^let;_xeV%UbYS82!!!agOcd?hX3iox3<V3N5b=z;~0rc$9pn{i<;0Jw~?
zSnO_rH6vS0jnfI*`Ub6*rx_fV;P70ep`#-Er`C7Gc<NL77=e)nOv1gpta|pUX{6+_
z=)cW5H2(JWS5#X3)kRHD$0#8{c5F?<Uub!ai7pK-UZysZM<We~gM<1HJCoqpFgD3u
z&bf??4x@_yMxTvo0Vl6KWVM8mun?$m!oH!4O*%rrq_Yr(-m~5jAadlQxFL&9A|o?c
z&<<$+xh$l1&i9P;svel$ND4NxEx76^kd5)J!pDW9n=FOBTj>+JCisL66|%1M6@=aN
zn|eT43e>CWVFiyw7<!@0BL!6hE=0Ph2Ta|;%(0W<3KZNbg`~nim~~2=mo0^6w+V@Z
zm*fKBNw|&nw5e4oR}IdywN<OIoFq2?_+}ED@<qB#+4m++I{^9}QI>6&4=qp4;?-ha
zfe{2lvx^>E5is^`Hmik;gg&fQso#Fc$rfjHZIH9C+gXtS$EZu*PEj34f#jIx)V1KQ
zLLQE07j`Yh>LhF*Ne24LhtkE8P^0#6ag};*1FXHu_2hd$4Jmaz3k#hb!0d0n8NT%`
zi|l=S=HkjaFVx#4#e-TE40MK)lc7;fah2YA5H(A)c@Fp{m=$z|n@5p&q;qN_gyG^_
zuCBF#x#!}UF)E)axiiv+N7G(f#Uuo@9k=ReEjJGC!E#psQnF93z3hj5=#vm0Fe|q>
z+*k}K&r{*rX_PG)<(Bog)?RJgK?hKj0Iht(0@<Gmr;9(o_b@nB<tOWSuSGlIrW!i~
z&HdbZL=^=)f<ux(lONGE)XX?B2!81edNa)0nzS8`uHmK6(~B}M+6P@V5OyV27m6VE
z;p;{Y0wJ+F1ckLQ=b$LCVH!Pw=xcPO|43t%vPd<Hy_ZvOp5})fqR)I|_yky0U7W>S
ziam1=R|Mv|a8a6_VDLq%21u<|2N0UUpy4SYfdA!oDFCxZ9nJf$1+}dd6y}}FX~{Y?
zPl+Z$mB6e7C))6IHg2_n=+ePc#4UvX*7EUDEmHeQN1CYo=^F-xI~!rDF^-}%Z7KZM
zV5r?XlIm9zV@o4I(!xro`rI;1WY@+b{LLYGZ30!^DpnA#`;t_u86lB+dlwpRso>C?
zVoV>oUu&-cu=P)_&NeV7IBCa}O!fHOScum(L$DRHmmHPI5f7IyP|v73pq;g4!MM@h
zZ6l2m)9%eSWy)xuB=Gl&WiOb0>ul**lhUy)U`7&^HMhw6yt})s8l58q0CE4!t!$m6
zBxSetHQ|A^p?3h2K#P-{=iye+906dPns*AbR6;k#(9tf_9T3%@%0Bu($o~TVBl!rc
zAz8G_M)ssgO3FbBQ(LlNOx7FbzidC;k$nMTYRev86wrXgbhK0tfIe%SL56`QIFeou
zvmQFOw=;`TY8>m@YF?^Ma63xwlhU`-bMM?Tp`t*u^5|?BfF?GWZV#7Kogj{uRhDSq
zE~^o&IM+AP8FC`kQ+JLnd9=^yEV#8tRz-PO9dMg_sp7NgBJ5F(Cb)#NrbBrBQYX%t
zTAa2CvmO;9wtsmF?ZwEB324Kf3IsI)qO;qO?9bSfc*%&~YwE|svcfju14#HD(Wlka
zX@$lswAN?JxfIKySz}8W`|85ImZtphLnyDR(^!Vyx@d%Ach)S|A@QJ<OyJBc?J!tN
z>kFaP)5rU2t1?0L!B*Skn3t79K&2d_yrvC(?<d&_>APDv8x%iFgu?LY?l5wfl^i{J
zPOEK$V_JG~_(KgWC_f3We?YQ^0l#a0rYLc^yH)E}mM}7}uJm_SGckLvwM%`Y2Q(lu
zx@->>%$qEvlB{8e^9@A&%+KMcufH?^p`7P)hA1@su%D&#p{zwo+fgzyV&c(qf(qKE
zc87Ye+rtmo@B}LYpfD9>rioViH)Y8CkaR3+@0PYJ=ERl6!p%N^cUYj6I$<qJ!`LPj
z9A5_LEpGST(l_}@L&++Lv$w;~#k0tfRi~jEg=ChBhlRAO(#GdB#&A9DgS71eext6I
z@hp|~u>?$J$OhGsi>+wiWyeS&EDnm^1p;BWz%g~CQXl5MJ2e(a?^<Cp<0^gep+H`4
z9qi!|T49_qC<hq&ACSu7y3tt{jX%s^Y=3yy8QszY5$uF_G<5P;|Ex?Ei=pLKN=%sL
zVcNK>*NN&wbLs8cuP$XI#ZP@n!i|PmQ0YcmOJVX!%FINY;Hwk|7MA5R$PLX{-FL^#
zn7VjEcvnJ|d{!G|(1x&^Q%4=2OTmoj8sD7alUj&l)nKSX7Y!H`Vs=;XBed`fYP`ig
z53aA4`nr3<L{#fR1({^E{Nob}W(VN$$gWX`_W)NqLA6m{jSh{Hw_#8h=JTOCWMxMw
zWA8-8r{(<hbN2rP*}Hs?F3O3V7lemxXaC=~ogSeDBqx&Qq-&9?;>O5g<KEX&_!G5J
zQz{TFNJ9$uNawnFswL(QeWpLZc<ZbJn7A~!&6rGR>XixRJ%V+hI;0a72U;SwzXR=m
ziy+MZ3iU>Z4V)TlegM1Gk5mp|iL!k(^;egI1BzE}Et{+FY~_thD~n>W7eS71>m78y
z7r2D018{o$_$(!+3QX8gveJIQAt|=CvdWe#jh|%M;QIT3$Z9D`YO?Qf@t93TP_mOJ
z3WjWesRJes)gddg`^8_Q`gts{Mc5q$x=Pq^*(O*DQs43#_DKblm<2E3uFXl%AF`?K
zWtj{Lgy@tM#l3y44WnaIktNremDm!^-!gsQ&DL<hz1lA7kDfNo$8R44Pq-!QeR^P$
z6b=tn4j|1pQ3(LVaB9h<PE8~1x=n<RMls&rM0?BSK(}i+COgCr4(a<u8w4mr(yIrU
zZ?ai8S<x+-TL?1#?DB9SWePOQeEl-;3tQ8WGc*6Rsh;6J9Bao88?xL!)ZmWkAp2N%
z|E0$bDeY8Bv^FT=qfP7!emS-4>!`kySqC1(PEPJh?JJy4t4%7BaIi0pHe5~Wiu#XO
zsFOukQ{4frD}U!CJ@pqATA~o7543@kYGff#a?nPVY_ZicjG-wUb}q*li#+g<cGY9I
z?4#0_ZAsO>Igj%cxJqFWBAB7GF_GQdC~%3cF!DttVr&8@;IHH>!Oc+>6l&WfsB?Mh
zjO|VkfG`#1LqPxYY2&qkD9WhQC0l+o4ZEtdduCZ^Hy+2oEk-cR(x)jTQfFPH@z{C@
z@##0Q*wnrL@}Ogm3hKBAhHHsy^ad<RLbA8<lOx_ujs%?l2vW)8%JC=TfWT>;{wL?~
zNiiM)BxhG09oTt>!5BwG!%!&u&t>n9HhcCyd^(~d4O_|wQ1g>q%1qjgZSN#iy7E-%
zGeETW*=W2ecGG(;IJ9|s#!wCBTfb)wQ3p|^rd&8Vc!HZsXb|QFKC6H}LSm6z;{y^O
z)|@!pcnZnwoxL02B$OY)Ga%emsWuC4f-WAi@(eaJhm@r~&*>4C8Ym4px@@k9yf8j4
z?}pmt(kkdSWYLi()Ev2IU=`4~;q5mTIIPlKR2Lf(R4&<5L<n``vle$Amg+BI-KrTp
zHHnlK0Dy^_bsjkoaHdWXSu6`v2FtTCYA>$99vqjmwqr-LEaP8V9%<YddmT)jtQ|b`
z<s+P}H54dB5J*$t4%s*Fz!NvHmE?~N-=+Z{*sxv@v%`r+XaI<l56T+gfbGropm@<S
ze5A_2+aJ+DkW?GlLCxnlfVpgUy*%__=MfEGHiJFDPuSM}9a`XPt<}yN4TJfeZ-#GL
z7ZN;g8qq+ul3t2hQrRnm5V=6;7859m5l(GWCl%!Z4?{}t)_Ef+8l444mVyP3v7?;o
zs22)O1mmI9L`hn$c-eCzxa;{1MDwm4V_E+_e-ET~$zq(doBWnWR3+x{oPlAxI!VZd
z?}}0ysZ0gsw}}pESV@&;@_W{xQceSsZ`NQ_XOeJ`_nsaYwT@I4Uc%w>mS}N5VX1B^
zqKAB&5Dn$z;jJnD&)vudF+-<oge6`HGrzE?4z7L&Vra~2L+XR|vkRbm)DCec94P?e
z$*5u5a%rUCT&LofZsN4+qreqb!-0Kd&<x2TBRP8`54vT=Aj1*b4fJ(pca3N;>b%@t
z;9D^{Ctz|lZ|F2UAdGsm1p~<u9k2q<<P{B$hneILWj12N8Mo0vzBP$g6?gw*zQR3`
zqu+T0nRY}7PY=|bhJN?IIt{gj;+i*TaLWEGY10LsmCL_L95~i8ho<Cg+(}(*ji76&
z@Kfut<f(<?iJ|nwL}&`_5Fu1tC+&25@ia_D#~d=db7MDWRE;3NGitV_&LJ;-TF|qk
zAEBpjAEJzf;niC_YR{*XYa5RinQx-f6cL6t?qd9eH3V`AGfO=jwh9J%`uz*w$V;}d
zlSmByqlMO_#LfjXml+*MiF?xkcBm|1=mY3Ytn1*Q5miBP;<Q7eFofuCn5X2@?AfT8
zZB!gUDt_-cOJ<8n+PjS^kG8Wt_EID;n`EyHU2^+x&Y)bOg-p!H5LKkx*%DUH_8g;1
z@*7?xW0%vw(+O3WClRBkCC#Q0bT}$y<asWn9CS<6cbB76Fw|OH6z~99Mad{7Yo13H
zAV5_7d3gQ&l4glkRg@qwAE22{=+0g=GXc7C%h}1!)V8Q_JU;Yj*6xt9M0lPa?0RB2
zTXlAfH+eLMDl!FgFkUt_A(M;41cXLGQRzY)T+7M*P^H};N%j4WZ=`Ujuwl>>4)(L%
z<z)2MOk(~)tu`uno6fX#e3k^pz69&l086Fw%bGw&#vR(TDm#6NgAWGpp2evZ7*Pc~
zgboiK;aq*5I-!5Uk3Qz8m)dIV9)38v0A$>l{8ATLy)x<+$bdmbUAtF+4|{5<6evPl
zD{l*LW%)~@%~r>f99!(T(y<GmJ@84h9XKl@!R4s%GlY;@@K2xlYhMdrOUc3mt1E$>
zQ|Seso2^fXT&L^CD9!xBRa4p8V0WTEYoIaQFF0{6|47p1mln1sXx2z5dd%EiH(<zA
zI)@E#d1msVAbrqZ9*3o!vQg;U<;tBt5BL_(R7(L`Cl5(5&C2VNFlok{w%E(;{DGpr
zy#Mj*C*Jsrn5V63M(>@GzP=O#@Pu~MNYW}nwxIjk67P^GU)b=0QLcNeYd#1)V79H*
zmCeo+l?;<Yv8W0qk6J`|_NNBK$B7e;4bes(Q6)1K`CUhJ_Re0#2N^DKY_}|=X-prQ
z!SR;li*0w_Q*kIc$B*BB5z-%NVRt%%;|ACZXLN!x@c|nK60c+l^nQ6Lec>?K^XyEy
zsA{0hz(bf5o&g+GsqzVrVhb)k2ejIFVz>fR4lN*d0w7)N)l?bR)(^e+|NZrc;qBio
zGW3{%drM5tcsbfs^jD%M3mBN5V3MALdE@~g*(}Sb{ZOdUG0bTquyuG4lEPn9)?w0)
zkYi?7#WPP)5iPv5dn~}mRlb5nb&th^oG`?LfR<}By#~!H)w*(I3Y<VDcz+i7zq~zu
z`uaN`)7a;Nu<)R5ui`XU`+a!(IY>$as^zS5J1S|@Q7DN;|J6UA)oC8Z^`H~S3pLyO
z+;U9*C0@cNgt8COF?-}ly|_9grUE3VrTPN}I3&&5C@{Q3coJE}15<b(p8>O$#qgj-
z-Za+2bB>Y+juiip9!DtMsm}356-F<0Wq~h&UTx^T2Z}jvdmfm7EBsSh?xpqRN1$=7
zC88G5D99wB!7`>e!Sv+`j*m<G7^lKPkt!p-A(f{p=RMCj<g9FYTV@zCOO_8hC@4Tk
z`P)Ddn{niF?Ua&8yMZ*!rap@<`GE@Q?AH`+K}}@I=7wUU82Y;F=y<=Rt{k4$lF0n_
zG{IGSkO2PrXX6C}v#Tm`JFQcH7G8gUxx1oT11uDBfvXS8YO6&3#eNAs(t#=kbfCqt
z(i5$sfkm_Z(XS)wV<uJ`0HMvG0hq~!PZWXth2Hz-jVo{@4SVS#{1RB&8T~_gSd=q3
zvFPwq^*)ejmGF1r?Z-IElJb7KQry*~6SrM3VL;w7_`wazMZ-Zn3eTQ77)JX{MSz-I
zN7?BB4XVO@TnaV?(=7Q>RJL6Ke}(0`>jWcB_8uGjwiA5k@54tQsZK*$BJ%rCda`Ci
z{e)S-DgnydMd}B|Vfad%CP#hWvolVr=!@I{QeE3DoRGTVkIT@Ow3%*U`sB=o6%_h{
zp<K>dr29VZQ2j=dbsma(=0wcSCYIUI{NoSeumIhkBv~B7Y&_Jl!7=TJEc6$4XsmCt
zMb?6&0X1R1yP0b;;yRMw?4`de80WoK>mX1zY%QuD%P<p(t<yw#tl5hNO0FwQOqB4T
z3@Sr3UEPBxbUCk+stNX9AQoHQ$S!^YuxS7ogJV#WbxZGXlWNcOFn<2_@3NodkDpvr
z!~5|23T&~Y3sS!#$DA)m>H*o^3gt@Xl85PO2E^RD12yzyiMc^r&Sxet41NFKg1n>T
z3Izm1m<a$&K(xPI)4ltvv&s@N^?bxEO6u(G(n(IW^|_bsV&cbGVk$-30%i0OO&8sH
z6w0H0KJ;N*=|hNrk?den7l<w8*M*zWRWv(M5M+sav>=bJ3H91$jZ_fHJ<n)2%rp2h
zvg)2(HERfEu|tJxX96gjt*3u(F{=9k@eL1!)v;45<sQW=(CLx&h=NY7@htIddX?b8
z7z5g?+%OUFgWl>96|_ro#zfjeA&j1_z3lGV_ZRNk;$860p*+f2Ez~liP(-e-3e)NW
z=(yz0QYy>2B;Bq7042(EV<5}vi-yCzhA@HX9G``Wc8PRC7MF_bpHL<*!Iiv|v~EWR
z#UUrDVvOuGug}_k65CXuo}zPw>Xh25qJa1`Kj+rR)6CkaR|N$7HDhwfx~fks@3=c=
zDv2_Ue6aTpehlC~c&kaXkn7Cc57odBwRn9=uy?@ANgcMFfkGXUE?@Jwd5n9UjW%It
z_haAy4!{KnukC1cCH?&@!G#W{!3Aal)wGvv`G*wXGo^K@h^Gc~k4V8NNzvsp*WBoO
zc$ehX&wA3PiyR$5hVo&!tmn)qWp@n5y~8e)J0XV=P;xlSY|`tQiFfF&oN!<*+Qm|c
z+XCH@Z!`_47k1zjA*zuSG)Y?Jc4M3_+l#G7%Q7%`qq0;|UU~go$K~){r)F5`0y~lp
zou+S<7VP@vbI@n|%$<MJ)5xSKUG!L@^p|p=Uf%yGynS(zS~(n=wB>72kHuTz>kKB6
zEE%>%;++G=BsFN1TxkmqMTc4nCeH=eR+e>GTxu3>6^6fd>)qdEnc{)Jr<Bg@*sWrL
z3RoM#w1!{_Pc4-6-^6?ZeW%<9pJ8g;I~8ChJrn73mQ-|$K_EE~JLlB^kMc8>gl{O-
z9d3P-J~M!`VJjY|`B{cQVX_K!;b4bZuLY?jh?vd~D*3!V79<gJ3Mn*NsruP8TIx9!
z%914xm=MMjOJSa%$RIYxplY6%m=WmiS(=nfH*zDx-G#AZxU-L@={pxSoD84{kanY&
za6lSV*Ir$~B;9c9QlMx6Wur}QL|>!jsHB7_x?-zjnPi_PXsNE9Qoi6ao1VCW!PK<P
z6*{HrF#KzQOMJczkBLyiA>MmcrSAt1=dxs^0NPn3)$^cQvvQS(EUa{e-?IM!u0w4r
ziGxQ?2CwIks@Ft(<BoodD{jtEL{45yYm%Rp6Tv_(b>1p}EB_1lk1KWmgj1&O@+2SB
zKHQco$38o6_iOcmG8j!@KS_@mea<ZJ?v!>LF?S9Fo>565B%dHUfm$g8{K6O{`+dJW
z6#)ND%8ZyIL|`JpJowaXo}A6*+E5y>v<j8l4q7M&52cd&O<j9dZK7w8Gr(d5N6eb5
ztLc)Z2mmVad91x*pjTTett?{zbV6w<!102U4FURIxH$>zb8VG^`MDk!*qmASwVNlv
z515=6tG*<<p=3~uHV0T8`ubE1kU#>XH!USOY-|FmZuaOXJ{@-W_L$$pfds2sHW(+_
z2O;Y^u7kgH(Nb@&?FR?@<KDGWcibU8;ifY%n4f713^83(4JuuL2AKAf>?)#Ia9w%~
z7^N<(Yfch^`DZQzAO?IkLtnC;r+(!vp6t%?vGV5&y;(cp5efZ8mvzj?p*daAcwV-o
zy;7d7qtgW-)2jKlB3WElfX=U2+727p;#rSoiqMywFW<1fY_+;uxq5$}4$sekZpJiO
zmaYnT^rgPn<=U^;tS%yj+l(>bz0fnZs828P#oL$UuYGAp`#Zb;t1>Zdrdrs+fhSg4
z2zi1FfcfSvJllW?k-`r=9Hb-Z19obdAWQbz0pGgqN)PZeiIzPW=NJr8j_In)A3@t6
z=?LOzxSH=Jy!KAL-A1yT?dYj}zaD7mAz6EXpu#@q26WGK(IJ&2o{reIR=HfxGkQWG
zC@x*k!2`PzCZaWk&Zb{cAy35YZCd8jV53kU?VZ9*weFXzDt%p^!0#P;OM#)Yu(<D5
zp-r!s7h0KaT8LSzyw3&%K=y^KxJK;%<Ss3tH1}n+bCvu3fYq5{v=5-`!A$^MDoc}v
zZZ=57%Pgle_N0km$x}slOX3M<f0AaV1%NzQ$$b@3Db)(vmrJXn*)wH4J!vje;WUkU
z-kk=s^nRu#Y;L+@hiHFDX87Xmv$S~8PewagcAkZGMWnGzL$)CI>Bu`W-lV$GZ2=}L
zm#c%eC3zo{xe!qw+n!QL3sYB2F)mj?buDE=YsN&U0hI^7#5OjBqZ@DhOdoO^v<$fQ
zrLCmD&w$$*uq#x3Yd`2F;T}N`D{X}r%p9Q+bhDWr=Il!!=_Arh2w3Rv(e&=msII5`
zX@URx_0LIr_cIuvzy0vkrzQdBV>^EoW@IM>`rZ$z-c-tCa~xQCTxKlY`7)^8ZbR5I
zAo|&kaY;_ukgukMPP!P#Qrj02zvP3nt-2j0`pP8#w92&0;K5?&*zJyPkG$`~!h+K*
z;83hkgs0ia;y0?m6-Q4<!qf2MHHi^R?i$Lz@Nwx=s$Izf7(F*ziN>gt`)!HFn%1Ee
z@Y^ay9uC*q>S)0Y2qB`L1rR#ls19(2CwwOq2`}3+Idq=Cy`0<tctTnN@YtkKdCtnt
zYI|qD2iGMDHW1GsuKQ4IkVO?R5O1zThEz+kc{I8vUO1W9gAb391;!oFLHSL#E%4c?
z(>fN(E{<Uc)M{1ZPfr&Oj-6#fON7k=mq1hT&^c--ntmldex^;a0wHtZ`rYq_uYHZt
zSPFy7P<wxCb!odrMR%CvCQHX8{0{H-yL+dn4speNR(=fh+?B%<HON~j&jRqn=BH*w
zv_;e@R@$cE@D;2=u9!0>4tF_ghdlE@)*@Sa!IM@3>fISFu-hGH$87-|1PzjGy)(?4
z58UhaWL>*_z!x8`4{y&RHMR9Jt9B;(mwAFO$KvIkiYHh)y!1-u<SYct5wy2XgoX_<
zoiccU21}BYEbWba2}EjwMrNzHw?CzbB!47Pl=XlBginAVJJRQItWF&VDKr=EZV5Fi
z8#+t)#e9xSVXJ0)IL(mM=)Hhg)eUeX)Is+DFT?Av><K52(L`HfR))cUi7xH0!~6gC
z_Vd&$-#TuncHSKw564@Tbpz4Z8UKSif3mP@JI5@?BPj;gdRSc2VMY~P=+|qP?`};o
z`b<3ebewFb^gdA)XB;PT1@`3fPvIZz^<?=$o)=mzFUbG)40?*n#R9VwHoh<P66+py
zDkCL?1Y#@64SfN;nGVI!|MNLc>((oiPlW+L$bBAd<4f!uF~(QeT_ncrsaL=vl;%kz
z*x+}vc`hX@=$*aJprj1z`OP48cdW{kgW?J17LzNHM`W19#%P1`8DRjda}1!m)1Hw)
zv7?r8cTz0KZ9mH)bO~i5QB^YIu`mNT!sxL9cnx*L!;HL1;Q!nDP^L4~;o&n+upn@h
z?Lkyyi|2*bp1O{zgya-_@ciVOzpai_U@c#`hE<yzgdm^u^*$&{IL?JH3cL-O;Yx%g
zdkfMe?&N}e(bd@yuYu-GKL^_jilU+G$TL~xg7}ON6}x)OKD(6)ZBvy)+Kgm#Rpc0V
z_6i0FbdBdS>7+pV|4*V6<$Ld|#*gv}tq|%CBoCms&jY{UpZ55A&sB!r+nHZ|55q0B
z+v9>s`RiBz!au`b{{{clpMKz^mdJu42Bo_8_vrHka+I875`9&2nW)QU*7KZpF*>Ht
zC>;Gsh)O-I`!R3eh^=h2)6a8P4V(on(}c!;{Up48p;;c}Qu|#h?`Uo<7QC)%^QFcH
zs#Z+giME>oPn!qYfxrLN+h4-lZ_yZ-ur}>{l#K9^4M2CKoR14EO{CU7>pZt77z>f&
zzdQx+<l6`Ale?Q0!%H^c28{sM=RBAPIr}9vZZ|;ZecR0@riN*Kx?=}$7)(ZS8r5<R
z6^=1JH1_%UipTW(pUY={{S&H*=gT}Jftly5`Bi-2`8Ft*lcy)M#aPWDVF{@70D(jl
zI<eAUuzcZgp|};sT^8Va??8-MYH=gw4++Mzy?5f4%ub41UFZr)NpL+_FjbCWKMxKn
zxmH;pw|;F^@n@S^Tdh)iS-?lC)N@+V@}PMCW00fo4&rN*S5Y{Y%hy=<{X8AvnDOsE
zwbqVrdizeBSAJ&pE@r6EsM$|b)m2TOHad;4cSaZ_h0U}H6=V994Z2UpTtv{Jg&0O+
zob7l-EYV-2J}R70eXs@gYP!13M$hwt5Oxsg%t}Q{&(JiStlH@}uR0w!>X&48^+k@t
zf(~d_j2E!jVFyJ)shT)gnQ_m<V90<RF8!cwSgnanh+h(@lZ9FV8M6`c2H;@GjpO{R
zE{4H9C$5<E$#QnxS{(IFa{)j=p*paOup?y8%sXhJ9HmjnJ2|OWogxk_m?rndULcxW
zI_s>5Ms>7Fs_CG3Z@W+#5eo;sk0_;524ZOE0*BbITDs)s5@0Ur7rzt!bGmInS)jhj
z>h{`$lwi;_&Xkg3%fMeBzx@y=&c|<`sHo8dN7q62?)fD66@g|-5oS4$*^!+)SK2Fp
z*#uME^e#aaj3{9Awea`pdG%Rw-kjj9gy_Lk*En;W1cM&QQy_s(e@FD`?<_EY-9~Pe
zi||!YiFWxNpU-t{3^htI_pWt<iO7D6^o%`1#n3ACSec3q{fqx6{5^64g>s$je`ZEH
z39A&cFZ&Y%3b{4k5p!~iJT3g)7KOyYbQ|oWD98F`eVmZFYaGu7_KgF~5#2W{HmacX
zB)hf=T@b350;3BCxv>(O;saKK4ht?)BPS}S{XX80w8jDXC|EKr=UCL-1Fw0ocpIMq
ziS))@NiM_Do_vIH`Y#uiKC@IiI$@)oF=wl0O7(-mV{%5=`)YnZ=F5Ue{-$Fr*&y|i
zrDit>oQJEt4!eI4{fPD9P4R1Z=u8l&tk<G<s1;by)}bMoQj<0-?Urt?`(?NU3PhkA
zU=b1-HqmP6#-=NHfFpc)|BLYULuFxEaW{agP@QPvi)t=1Z4JBS#3-E7OQtDTS_M!M
zO8tp+k7`xjPWL95GB!GMu87y4pzBC`A3Ej$C&y5TB{C<HUF5uwfLLZSH87HBwt5cS
z9_os4D4R+G>3*Ed%1_$WULd2UmS1{o_?@N5Zqt@=*hXsmbpYm<iy3|qpV{HC)-%X^
zk*jx4hL(~*FlZ-qMmZ1EFp^raDYg@vJvGtNX}xnWqrBC{Y3yt96j}I!#ME!uUD<T=
zvhe<%X>?2l!daEi-ib(dkb2?3<PD=qt){sYpNbfs=Gk5yMb)&)$xT2(4?j4o#u6OV
zj>92SNwkyE^4%l}y1VbqsD3|`YFF8!jjM5SdIoT+03V^juXo0RIb^h~-1fSDnR{d}
zyuO(%8%TXyc?1aEYLO3YW_Pz(Ag8>!><SK%h?wT!5#+*b?{m5?`Oo6TGB89qF9|%Z
z(O9V2+nt#k0+-D`gldV|hh|=y4m_zNzLS0tWVfx8yH)JDL)EB0#ze=JRo+--<zdh0
zXqCy4BcPSq_%|^ws^DAOG)n<+BS&|;t{|G5HtiFUR0#&&eSimt0_?^W&|(rF#}hjX
zB@T0FokgxONxqQ#dDFRL4)?g7yVnIO6qSBiwa<%TRfLm#@|DETQp$P-p8?=#i=#tv
zQIymLIwqjS78o2N|Hq*Q>7v=I_*>7c5=JUn#u{o;Lm}z%x}B|0Fp@)zq0q!J$QBv~
zblA~NRfHfBLuy{76=haA&HXv1Q78#9&rtD&ieX#j>z#KDha#GvK&5HDK*8P)D6C|f
zOG+}@*uw#QcvZ@wwSV>RUjhMMRE~o5JXX-gD9>S;G5a^}BTEhMSqOfE9^AaP0J}@D
z=jMJW&P<*;m?o}&dJrijfq)=T!%i#c-02E;SEIolF}MgkKMU*yi3J^P7&~t#pYdT=
z*)1C_l;&0a6DE>c8WnRGod62p-~}pl8>}|=_>2P`CVEsw2#VURl*L{%ELqodi+bc!
z5y@o4KBG6_pKXa)2P-P-z~bah4dc_tjGBigS~BYoDId&55T0p=?DETh;`|#x2cLKU
zN`9hE%21ArS)C20_5e1Vp7k>zDS|#3`r~PqstA4ujgMiJ|D_G8wA#R%hweo$D+;>#
zzBOkmZ31FMmJnvM*@YAGaCe4x;8H3sFSK4Dj1ZI62?_J}@UT(KmP@Or`4QwMz~Uo^
z>ic7Y%}S6xu-IarSR7xW#VPw22Fh-hL{REhJZn8TsVE2gZ7r6(EfjT!agvFgYn%ft
zlt>z=St{2PnjO&{E=S&SeR;v=m#5{oqL+j)EnFxQ0X1Qe(omQj-^3L?A{3zBzEfCw
zg5ZT0?$`K1iyqlKl~UxKD;_8JG#19Uq@wICNG&b3P-wBn<<E3vV2AZq%ydv(g1>ru
zl2QG?fv5V<7JZ!A7ok+D-mDw!((P?hAL}>hNu%h+g--O2s(`t!hJJMJSoDNEH<V|5
zLnt8t=81SmWqY-JK~v@Kdr%HgNpZnikROJOgq^0LgGc;)o2!sbWoCCNh2u2i{6`;!
zkK}owibqq~r5+$WxnULZ{nuFftmQl5JL%y5TKJp)WKRtsB#L^=&1|U241LVq9Vn_!
z!&*iXqK?g2h*4g~zmcp3v(u;q+Ja9uIDtGxzDIPJIV^!CMSZvcwG?2OHtW!mUAXnh
z8|QUxuc7=BpLE`O>w_tV{nQ*h-L^`lmAuih%@3NOOYm?is{Pet)=odiKynt(m9wq^
z)wZ~U(S3TjLj*c}tuJXLV|#}R^T)EN42Pq58>u#i#M^df0@X(MyriU>!tICyo4_OF
zS6~=g&@6L_UQSJ=B&Y+7aT?|+;l_W%Oy_B)bS3%`E3G&xig;Hm{H!<kUqTX9P~Nvi
z(dT)A1g_atIwf^&*$KJ_bEuO_$vCcPw;EKYnpFwF%5zCe(#O*7j<P_kdC&Z+M!a={
z6j|OCG=#yC8zl8i_Gp(YV46I%F-B2~h)mNTfaW`OXQ@W1Ms~JLTjwE;Mco~0SN=?J
zk_49;LgneVicwNEr~}%-Fsaemf{>!<`p}LPH0W}(rtobF!Wjkr)QWvzy9FR+6s^``
z0s*|B-tLNtZFJ+3G~sIsJBZEK#OnL+Qq%k1*K+IaB~XPXe+mp6IMI>A-ga3Jpb$Ai
zMeT093n5=xK6}eeClNQOP)hc+L^51fAHG8-+h%^j_;~6HE?EIwF{&%Ht%htejXtBK
z(w+_K&{icNR98MiQnSzSZo~&0OHzo$#EN3>6R$dj_7i!|-n56LO)X<DlH|467CG`I
z6q&?4Oe<&A?DG&j7Lvd;4d{4Q<D>a|>c<0inm%&R!!dfd7MP123XhQFNw!jeB3@1K
zYF2tl?T4^i(9zOGLf2sM&mKqc<lX>9Rq5$Ng&ySakHmoQsaG)1P5@KAobIx!)=5(7
zwLJ!}*}0LkP9>tIlogn$lOCViuq_LIeC-fQs)Bad4s^NY5Wu^_!5Meo9@%~i&+qK4
zDPRL@ebm$i(Eo<>H};(2c;OpuJln8>30lXJ2b@8YZN>mtjGR0755q4ue1xK!ZFD)u
z4Dial39RtVHXWR9`^0=p8El5e)O2Zlq-G0V3)CPeHCUQl!TbPcA-yb$bdSs=-g=uZ
zD4}EO=G3=&{eF1+5~z182i5t@q9gPWOClmrMROhuVpu6hX;LzJBov3?K*H|QrmDD>
z0PhQNM+(mc?pF0zdU(_%5`WEQta>hab2)6QoonR@@O6e*AT3geD+WLuo?bK63`RO6
zCaQ{+RzIO)QAr4)B1F8;U#lq-u|0eRV0@&;?Y9n%TEdTjmUM~eMV%+`2-5<-yOK8N
zzAH>bJy6^f_c6^kLUdpgikf*=(5OiYSVaIZ7bHxww&m7G9IxcQ+{{8@N`8!yx3mh4
z?}0Dgew_Xr&flb{mGBj8=YTltOBF+Is^`jAt(sS#y`1eL{@%*79Wv<<v?sU_$6n4i
z)myXF)1^W!)`75~C7Fd8m~7J|#c6@)tDr2E=zmZ}I1b*7QZf48jsh5hANCW2uiH`)
zk>J^Yl9Uz|5bgk^=NV>HpQ8z&P|4w~AfG&Chcg!|oSqZ(3MTi?`J9wC&;wM-SO^6h
zB%!OWBO3&+XBqL|zJ5k~na^x_%BcmW`p~eGr-rx~*X~(FTJgKqTOKqY0k(O9=S=T~
z@05mNNqnF>tk(vKHlV`O&3U{a1oET3J7TWdT8-hbX&O#KM4ft4+qR!iBO{y$rDVsd
zx@BnP|0AR!>3LsFAG9DhJS<ismx1ITIcAQ9yMF}DiI?*Jdvf#s5&nDDd0p^OPjI4$
z-tlRalIYi#Xq6c=vSlgxdDpz}0>Xl4rfo0Jzou4<@}guTfX(3tlH@47#{GonhY1I{
z^Hlw5`aGYC568it$hHd<0Sac6BSwowWDG7D=8C#FX=N>}uokre-W?%DscxVVjZg7d
zX6T1dGOb?*MS0qrcMpt33QS;14u`;n+idr#K<w-9!GGCzwbmWNG1+ZTDx`lnHQv!6
zD-?&2G5j0A<fh-0&ptWLCDb2$DxIv5(H5eV3LD{>1^XN`ID8T@mHy59@DEbHs(UHJ
zx`Z_O{VKY79XJ(*;R&-%o_~`*hR!H{W+%%K2mrz<rl_fOiD5l1AO^th9vBdoHl?rV
zy$h30>ve-dBhbaN>RG#274<|<;GhCa()Ia(m~PpX04HVjTNG9{HA8QNKb#de9~jJ8
z(|>ZnLj&!m;WXktviNNpH*WdNkDIKm+hWfRvpr;J=~?tIFX+rr$$5oZu6=M&8=43(
zMeQf$UJfdg;ivp2kKgttA_>=H+h?kz<P2(U>S6=S3hWgUfB}FbS%%vI$yoUHswS3o
z4hmHlgaTj5#3qoDph9?(gLHj~YR^)a4Q+)gk3I;`e|`?n&(HkDEZjY>CoWM^8?n!_
zw#dgSPU>n90G&Ut#6P$Gg9Q8)!;WG#o+xIwHV}dAQ(lxutCGyL;?Rw?=bqwb9oD%z
zRCetoT-{m0i$GNzq$N`&@#=d&a*nEn3Fa@MK4{}pXwnA>R2ZG7pLf;hUGbGtM}aZn
zLPex=5l(ICsTZ@}_Nh=oTu(r~&p9E)-KynR42B~&pqp<e8w=g17X`JW3NVWx+<vbm
z_h_QlKe=qF<7_W>4<E>F*gIaSoq`F%3d>EG)q%s%L23FXx+*US;2Yzqd2gqaF1-H9
z9v9N;z2DkmO{e-lnIlcI$0m0S**`K$#f0QTmt2=hu`cLUTiKXZ^wF<hZE-9r!!89D
zDpoeX@H}8zL(pU?MQRB}nMrY0y}JU=?nXDW&eXp=i6Q+my#B_B`0O#K!<lgdZtLnq
zOovtNr*i@eN_t!_8yf$v3$3T#5ZV50RD0NrzEQ~2t#{C65B-*^v>4$IVKC>RS&$s$
z>paLl?qdJpbN)iHYHMHR>ClE#J1dj#^2y;vv&vc+@>IJgolCs~YcOJQvz`xzbV<q7
zSCo7bXzK5#%Tmu6=G)SOjiqfI41}$}ct$TR=-Alq(pj~+QbW2+jjEz;r^-mz#fs=;
z&%#<UZml`aWtMD4)@rG2!YF4^hMC!^daVVwUT|NVdn_REYs;(+v$Zi5ABOtHej$>-
zGZxPo!G<6gS~_mdiQuBJujypH_uKIH>E->WP%~EqLp1deG%hy6ZU3EcThk&#Xpnjj
zgdmg1wt5eC5P_kvr}}byt_BF>k^B|L9`mKW1Ejr|j~TDH;e=e?l}%_haj{O0O@oE{
z&usnTQTy=6GZ4trN^!=mse%4%k5~ZgZX}X$Qhia^RZBdS99#2%c92K~%RjsVL$rEt
zS$H>9B_0n>z(fetaX_e*#jg!@gk^$q%cGGRVTRzHZP@oelC19a=M;hc#N>nzXi2Lu
zKwo*qvwHg)M#tpaVN=+26~y~FTTITtDbT=8*@+62o7&4tDQ!3ixa{)HwyiCwF;KF1
zU%e-YdmOxJaO=1JtbD4?j?oUzQd{vrJIx->Aw8ZFp8e43XQtGnYBO6V>I#~8I__%u
z&eno<$GrWnf_0#p#2bOQs>Cy*#W@c(O59n3Rd*n7(N3cR;w8@6aVUFX^L~ybjl(JT
z?_5i(fl?kEf-OuzcyVVC(LF&dqWlaLh&lW$`Z~40(t`y)NYynRwAIZS#4qa=x3Ez(
zi`_<~CVhooSDm3{#nf7IwJ3A(Nhugm$m}6kok2Wu)aq=86#NPdGTDj+xuN%P5UvC9
zXIZ$lA1CT;<xjhi|AoT(2rxS@ln2pIF7-elkeuv|o<-2Pa#-lmmKfuEzhxp50S#cV
z(b8XkBbBnhd;P<AxcWwjl@R$dyORBu1+{BiRw^e6J1;dMw}Y)O+9@BsQnjFYY9C5f
z1hUg6219mr+ubD;BjC{JO@_sms1&U`Mgw$AN1%1Y1iDh|*?__YtQRIvT@T#rN`v`Y
zUGiF&J$d59YC`^+b~g@2E7zksA4^=Vi<>;{a;7MUDx{(TDod!YtuK<u+aXg?<aQRT
zP7Y`bp<@?_%291r+dLTQS8!Sfh2L9vu$7d5K+<}L9u@uN&{Ac4Byx2r2i2WX5-I~T
zV|QOvXN>f*BdXClM-%Jb{D^IwAK7w{GCg?=sO=H7P2~EHllbEoG?@Lu3}$b$%Eg1(
z5-&QuLowepNlpbv+q_6hbI@$;!Bf1PCA@^ExtoZrxEH<0-hPxLFl2iT<I(<vf09`H
zlk~4Yz}WhiY6vA~n0rdA9o?q5g-Ytn++Ks3V$YsSR6x%-19_8WGYX49e`hk0t5ymU
zq}72^KB|=mPX$s48+M?Y(x*R0;%;GcHZJye1iE%Q+NVtw+ygIJU7}I>q0K1~An|VD
zCE}vIjHh-RhKjNvV+>C&OoyKL?vpX}0PB1c|3o^;(x2FPvQ^Use?9z1TT${r6%@q&
zz@at;W6~m4aG?95Ny4*Gq7c6bL${cDswg!IbrXRt?pUhn8j=+n8a!qzYL-k;>au{)
zvKiJv9qH5<j%!FOSV<`*SY$1*mvmKs8$SA59>CcnLT)`pJvt}dwuM4nOkv{y|0q3N
zZ?d)O;gp_F4|keI9v4qlq_gqnpZ5_C=mAAQeY^oH+o0=}5=gjxj|SG7dfh+BO&$LR
zK;3jNGBvruGO@-ns=|)gsLqX0js;C9RH^ofy;8o<;YE?Le@SIRW)-;lMR+<;Zq+#)
zIfMo3Q?@rxc}cStD#gQGYDAw(C9f?Y0+Nhh0k#haGU%7{4s<GYZc8ZFUD$l2tPOJ>
zPN;s?Nu?23nCRy~+Y#V^VMXL1(zT;h4e*e}<uNXK?xHFBrdEm2!)s4=Q`3WHr)t8@
z^LKTTn3fI;FyCRHy`|YgrPl6NTG}yT?LFMek}XzfZK+8peACkj@qw2u#2u=uto7Js
zC8#y^=G59;36YL$RXH_wSkxq=JBhof*4J>xao%MmLrK28G?kq19DD$`O0WkwQq|1E
z1XyC$0VV`HJfPxycM-zftzVIc?x|3vYzGLW_yJD@y-LU4r1UDN_lW0eL^iADG8;3g
z7{O=+9bX>$@J=$g!eNK6RNHi_7=~o^>Qo@;H5a?emm0d))81KeM0V(X`uZ8$A$Qar
zw#eY#hBtZw4QQ977{F1?I(PLRpftULH8J|;)JE&7jP|pPVBa2K02+D(Y^KOUlrTNX
zoQ;q&oRJ)o4cG<E5?*#(5+uGj|A&&nyq#GZ?>~{l^X-rLmr{WzwwZcp+dO~?p`Tv%
zS^}50>UG*@1-C;VB|q08B8rG3LiSQp<pqZAmn(4KU9lY~-zM#;!W(B~ELsO$!=UHO
z(y`d8x)LKX^YDqHqR2H|&(*duSMddi;|Hw4rDV>QMxY|E5{io}Iov2gcL+w8iXdlW
zbMTql9$5H+b)ejZE5~$_9wY@Xj@C4-MgoZZl0Blh-a?k$1j4+B=mmWPF}rQSX((#a
zb0L0UPv%qfr=<FUwMN#$*wE*A1|(m(M`?+;h*>4!Lqd|Jx{?~QsFJw${$E~ylfL;V
zd_BF^{VcMGPRzy)_XG_Q30-y~$LB>=XdL~bGLG0$Dg`WshSc%!(xCtw$vIE4!Oy_t
z2XIF&Ar)$1Ceb5mZHp|)p3OpeL1iE5H#dw`ZIrCzZtp1;!@lbH(q&z-(njr^rijxf
znazvVroPpdBO^M%m9^m~lJ7w-9`j_o+t~VRtcIS3RiFdAf1E4v7T`EA+DLT9fF9lX
zfm>uy(3>}kgUO`bl{@TppM++ebsm#vjD{3```zUQd(n!Z{p_*=w+;y_IOc8J$SoR9
zXPO$Kq|yfTG@XCKv_j40*+V$UDU!P|K#<zXt->klYnD~cw&)Y+l;t^9R^tz)VWby8
zHfYgd9sn+d>0i3NkI-Iu#4(nP6G%Qb?g3tYJ2ByK#oI$RR;3OnY8B)7#iu^VL$*B|
zM^(cu)x5^j86;_T<~DMu)-1nEv_CG5(iUg}b}(1y32>TvHMOwK&5C#o6InNy$*dCQ
z2lvjA8hIfoiPHDEiF2qoA?0BK1l=@QNuM??QnoCCwL<%q6B4NwAyO_!G-LU-kn;y{
zX4nE+H3HdeRTIq?8{o%FPPg{9)vuT@+X4MFd%LYqj5yAO(b_1o$dOd~&`7cx8(o%L
z?@(HmT>3mIFC_s1wFY$)KA3!6-Vtu|bf6GpPa-*wK;$D+EbigD0dSm4CNvL7Lx9%L
zBtc^IWtIvi%s9eOn*h*UBHMQ7m#9QT7p;(c2H!7(rfJtlYN>lHF-2tG6}3f+Q*AoC
zt!|1qO+Ns%uE(&A4CONv9sNuxQsyBwn+M9%5b>5NEc+>3sxF#G-ec=vS}L1^t(vv-
zx&p~$p=~w-|6}$*HUD;MAvia5QNtA-(%x)J56mjr`%}2lCa#2T&aForsU+~o=UpF~
z1g|q$)ELBQEG1ghtN8lx)^6pj!m&_a@3-Hd$As^H3WxLE9aX!Bc0wSum9iqqG*LBb
z0;kqU_PQ$9+N&Qf8_x^m=^BOq6|zw7>bp_8C>3g^x(^TQ8x>KFv$O?YA+3u(?xzj=
z=)5&3TR&*sBU`6|L(vdU;R@P-1+0mo-1b!TI}1-`u)73osZu~d6Gm1}_i#HdeJuwq
zP^_k4tDbj~RrnC3NggWrhcUbUq)l{V9#R<W=^Nqw_pI7ibuln+xoon?NIByHqIU`v
zA1}gy{@U5~`GS9jzy6D~UP0^RpngskPu9BEc0{_3C7<p#LVTcH31tFi0~5r41crU3
zKnhMPs0nRumkP}A4zxT=+TL6NC3Y~o0K*Dg5zmm6^c4qUb0pL4$=U@9L^AfRLXTwx
zs}+XDvbt_Z?_&0lt?c&VQq(*F`srp!>wF;lqKFlIj}u)WxFn*K2?In`3OY!J&B-!J
zREa7f@(*+YTTMS$#Zoh0Ya`0FJxSI;mB(>4I<}QEfYLVGXqf!*XlS``?en1yA4vcu
zPL;)Wg}Z@!nX;pAI#T#aFkT?4f*@o1$|mf0l3YM4l6dIq#PRM>RpJ*HLYJqN+R7;G
z8IP+96~u?<!;XY!bs6*iIb<k^%CV(qB^lLCGAHb4$zid#At%N$ajjC++~8wieIC`&
z*CNlNZEzlSDm8y4j%RiO?d0djRd$2wwJr1GO!%K6`Rd2N_DUN{a)VwCfcxC5#fJ*S
zbkwov3cx%ZP^DhjjmIJ4L&|-Vynqkqx9OhBhfLY#5jqnjQX9ca)tb1!!S83hm(O_6
z#{+bs|BDYNS*jbBUGD7y_{;UOY5=xOSGF1qUJ(GSQwRyk(aEGC9w&u}&nRu9ioob4
zs+7J|`LKb37j`i^I1cfc5+EaB)oc|=IFo$N6Jk6Ii?iPi-~F4k82c=ls{8z+Zb0d_
z#TVwE@Bb~l{UUXD4U~&Ii;fFZ-oc8^=Q|$S1GA~KQl|kT**)i3T@Xg@{DJLWxZ63*
zWT>`N7Ue@$Ax)xETlEC#mdBg$0@aa05ojgG;Zop2C3sd>_4%U6Fp5XJvM12Y2b&4?
ziX}4pL$d+894{q`T$~ObIVPt}zq2TlG}68qKKiyElX~KA6cI)kt9;bZLvS5XP<qlU
z3_=B!i>M8KA0i*qU-27M%D^gRTfws9c2%v<29u%d%jCJSxk^0(K+)<@M+$!(H4;(L
z9(OgiH#|e+@1Qrc*mX1{7Qtc=TNISMfyWTAlU@UOhLXGti<T+^1F-{`y>h+?IK*k9
zdz`fCQK%9&kqp_HdE{d~O&*m(9+^_b5AFwCC-$Jqx#<FL^n09FvzRqqyDHSyOz!R8
zs--QIE}3MPoi&>VC`WQ0o7UvXWp>JZL3v{Zl4rp5*28uUlb1AjabUj+4SP4>fqdE)
z<DNDU5i}EoF*E+O-};Nz={b?2Wap9j?rU<RvWFC8w@_#R1njiYe-1e&Sx?Y*>H2{<
zGTS%bmH!3&N1kMtUI-nDhlK0S$M#Ssf?5Ep$o1TQL9??oLc-KnXnf*~os2AcSBnSv
zw3~K%Y40b8EK+8jOISqu`0bO|-#}>RhbGuL7VFiGGaiGgiv~zSroVwxNaVA1c$#cm
zD4R9VpR$zd3cLvxB<gQlF%YcmtSJX@@;`=;l36EO$*z1qD({v(?n;Fg(WD;p?nTeP
zcg|T79!pEM-;!mM*Hv*{3)~-~67OnFbteu86j8}^2epiM?*{o+0ttGomQfwqQMMd(
zC}b~xLO!L}mny=D3*+1ts_=GLtY>&dyU=!ap9MT4X4W-Ca%XE0y+@(@_5-9PkWnTM
zc2avGI`M|$$u1GS!OK-`0_AkfIEJ(Rc-`Mr#ja-6Nqu){a&<~j)8>XZALV>q3zaA@
zZILU=QLc654c{C}B;_0YmRf695#g8E?rH2W^cVn00`d)4ZN>({1Gk;?`Z1K=M&u71
zvw;$iOif?G^%elwmd~f^=S%<&X!pdhrhLqG{p8c^Nz1?i2$F=jKFUt&K~!1pkyuI)
zBVF!C%~**QmRR^m!lqmkvrV!OToslfpjc(kB(l!xogMsk;KB@7#Z^ypSu>a=QDUoj
z05C1-6ZI<L^V88K#n$dgoNy>q$<l6u1W)Ey$~(>Z(U^ifj<CZ>r`dJfohecT3GZZ=
zEuD()dUvuqLHA*}HyxLOA_l6PsUm=FRCx#stCe@}MhK3hah9<m-0;tVB~_x&lsy4=
zNq9&FK#CI@u|JP>RKU{}3R{Vk2fGr8Y|H}XJa5Qxa&QdT#irtSJiM`?7PE0^)xvm2
zoX}yNMVz8Ow^d==&GB(tsJ`Yy?=kQV8%>vCyk^%<^oUa6JdI_wp=u*!X-KlPoG_mg
zyzH~2Z<+<B$M-1MhJ)@R)e)~Qk1M%&RO|RFMunFIa#KUt2k|ON|MsL?$Sh&4Z1)c_
zD=7~k7ffJ<U2eY26)10Y6zIYLJFm*hxWKn5Y#6#|zb}6%D4O$eDHQPLEHfAkCn@dK
z1$v~CB<6MpDV24-dJ90bVLb6DfX~=nAO|%p(O$a4oUrkO@Rr2dRRr^^e@>fRPE>mi
zPyIMTnhdi&{@m{ZrSzRp)IvSb7An(hs5hfJ>L@=a-)fx)C`%un4z9UPF^#TnASpnV
z5zEN$s=-|f1MksD-C#Lh?Cf8Iw{@{GFa^lL-V_fCrw^{gLp0!NFBhnAT-~niB|LQC
zR?~(a&h55P7mNnxvnO>;kqlKC9-J+R8CZ7=Z17hxS(sVus?qbXoh9qZ*=kx3vb(M7
ztG@0lISnO?;~qqok|+9F658_svcsMOPcXT~#;Gk>l{Og}2@}!-K?s&>cE%2_ZHeV+
zdd@f}vn+KdImM}mpl*#>z9{YvUm0ek>2B*NMaiTU+vBqIk3&v^c7Cv-x+a)z#au?p
zvNVE8==Z}5IV^c<qzy<ZcyK!Vc`pdwJPUsrFHuF@6_I4GD0|<1b0Jg!3T_%cSx`bx
zw&$9t<H4?EQL3e_7o4zL+Fc!A7BI~}FtIukcj081wVoIcIP|S7x)*~FPW9`Ay|TwJ
zfuM5fdXmjL@H{mHuW}}PR+;3XLh9|NUoCBQRg!SAO#<KykN_+(FkEOI&MjxYjdCj-
z-m}HlCuIa#i0*d>?8)Oy_z+C!I3(%MvRw9eKC`a@-c3jG@0d7k3u=K9HQ?|For8|I
z2S7RLOVjSO+Y5yD#GBsOg9q}!Iz^Zz^e0$)GpJf@x_v9it37eT2w(HcU_jIe0NN61
z(f6>xzoV&@fmNK?Pj!*FHf$N7Vx^{_sn4cch!OG+AzljTn*<ULCnk<(_adPVdg>ny
z@@Puib3_uR54~iEhSgQNC9U0CBr_bER(AIGedsO!JHW|52nujSgZ+x)kU<o%#e%^`
zt%!wPQ)e8X#G*i!)^&m<aa}TbZN*0NtWqvoZHdsoP$^io+0z!TJomkOpk`(2u=w0H
zrj2HyO+%%moYY@cPS9n$qO)L~CUhgg$Dk?9f0fhAEUYUB>@;pOiCLu*d~jC}el8$y
ze9X<6?vsRJ=w@g)d~)Z7C^xd1U6HLAnb91z<XI&QZfzBWYsWsvT{1rd?n(eyi=8-|
z<c5cC0mfkVpdsOc7792ow#qke+x0K(q_hc7sS<N5K!%<-qEe(kXVwzBg(oz9(7}sp
zYz#1>g@E~v>Y`3biR${1T%s(SAv+8Wew3q0lUDpAT4^@|cI(FWNk8I*KK%{gc}Xhl
zOGfQagTY|OqV@?sOl=GKfUsex08C0Rh-wbVZCl8NoKJf}u`kRW(Id;zGHDCA__C}z
zyy1_iuM0%g3uTT#L6~_>f0iFQP1fdTi3(O1Lif^xxt!noi{r`>J!WR#)sXQ}NI~|)
z8|V_6@Iib^&>c(%FrYW!&JdQSM>Z$>VYZtO8X6hT$^1}`WLNhn51rp(jgRUHXzO@T
zFe^I$sCKC@pnN#0O6br{TcYX4^ipeXRK=4efw7^YceFdQff}xpF#Ft<T|dghbzV$;
zPf?k9+HqnDZN-?p%$Y|a80R}+JFQ7bZrLh2CO<g?*HNRKLt2I?*G|Qo4%Bj=@>bw4
z)E$X4;D&K-|NeWg-^Xz8`*wk;Da)ViCmJL$O({_(4>*(+Yp?KXd;cO_XWL}JQ!MtN
z!;_Q>$*^EtHm5sxDtR5l6}S(bicgI1CxtAW{IbA_MN<1qse3QaS=?`6t-q@~i|38e
zv1>!0eI`m*%iRV812;uyIvMcYG({`=ygdVr1JtRK&g=n8ZQNroQG%*Va{ufX92&TY
z=tbLQuFpuxI$<d)Ou>!znc8zF;swHc8F%Gh*HodBDqQ{w+_2BUelnYR3<|HgtG#f3
zI(I>BGD%yRZGl3z7DgH)h{g~VIjY?;<G1M2)iV{+l(nXs*2R%r{oLY?r_{Ee#Xqin
zrGPyN%r<o=t@R7Wh%RK-Nm0PWqaORq%=D@vW>kZ}(r>vUH%&MgTq$f4Pq@cEShAw+
z+?*sHLy|>eM{COsVt_a;0glf*nu>0zjsb)Vi!@5%CS;k2ms&^Zp2Mo;ds@sJU}Y-=
zSXSa;wm4tI6HVMv71}}4$gXttcMiR!dT6wLT{&?ldXFJRkcm{C5o`5y8mQ0PPM5$#
zef2V!#DSc~3;l!C>cN^evNx>O({9M>TY<AJ^bBo#N#GliS=pJ@QC?D;k#1n5Zt*aS
zXTJt+oR8u1f}LaW3*yYszI}K2gzHe`<K8doduw}YR>^y}E3A92M_8Bv4wF_2X~G(N
z4y&|#z?6tg0s^~8_VA<{`6Df|-HC>I7D3R98<YQs)BZY7P_&aZS`A0h1*N;q4Ps%*
z!vwr5lXzUCTj65HIpE0ngVYBmgbehudMh&60JJ~_D~F%9=#gL*TIXPpgVSn%wD{L3
zabgDH%9;$4ZMs3BJk^(QV^2=@ff|d*-p<m<5-aKLHA8)^cfoT2SuDX*Jh!zq2M{cK
zh4FIDV7xz9Du~?y#qKumDsYkRdh7l?a-a_oh;VH=n2)$y#1vboDR>XKg@iS3xCF4Q
zU9jB)rSz0+rnb_+)uvFFj&Bk_Ti=P0Om&)<MCLlzUj0}WrGyltf3th4;=+zLyyIcR
zI|eejx}rA)@ynqh2b2Z)6t*o;NtLhdAs<|z<WViM(K6;@4{nk8Ae?fFayoSVxW&P$
zrckDVff`L{DM&G&SvCGNzT2@C-yJ<uDNShG=yY@_M=(t0I|dYCI}}dK)3btz20%Cr
z&KM*?h6yQPr|M+(qGn__N8T+-c*&k+*2ML>x)LxmOz^3obtuTGv$wN9w!=rCehZ8V
zHRg*ni)N&}Ln7j^n5JiK*<T${Gf_TMjz)O%u|EL9gK5b1+ge0#72N>)+lk^C+&=?3
z5Ma1#d|=S&spXO35^zlnWUZIQFz;#s$$+$;6-W8$a`CSNG47C6Hm!XkU5!d7S9m(G
z$YXipv~KF6!!!!|_xZDLKv`kDfe()5WFKW$vs&Ckd%vseti1gqO%>5slKhb4r@*Y$
zYTdI8Qh59QrJaW+RKsDTGReqSJuj<y=ZV~Dl7UKYamFpUW7CO2goevx9x`fLv3pcq
zXE;u%3D!mF;Y752ZczZu8Dx>*SGz?+GsI`G^Kl#)wDJAVUVnv4-jac@`y#BWkA(3J
zQ;bo{r*xT^CwX@oPGMFp(sfgX@|qdy<%f<m$b5nXt(83BJ=>|FZHCRNo@eW#?hi8D
zR9#H@Ei1fSUr<n|=MW+Ev0v&m29O-YP)89srJaIf_zczn|K>;EMh)<pt@<Ny2=q|a
z&uA)+lI>q6a-JKsWgVV`(a-J7unccMy=W&4IR_f*pJ3Q|SM@D&@o_t<gX8GlO(+o@
zv|+L+tX<i9b`HVR2}8-pd@%6l6JN?js|1P=9|gq-=3QC(LviICS!!nj2&4M^^$SkP
z!vS!4Zkx;88po&<e<mH0KkIMae#(0Oj~AVyRfOWsp+bGCdx&=mx>W!acY~gY$VT(*
z3oX`}IvGlZvYGg?+ffQNfz1s-0nc1#_aXa@6dwvm2lPzx5IAXC((k~%c~aG%NZ5jR
zz!oVW;p=*1rQO2P1_X@vzkukK$v?_+W#hTXxm2&e2Fc_p@k=MRUf}8_DWdVnFhQlE
zfhLrR`Nh<hPZ}kbUBp1>^|esWhJ+!iJ<SS{cg<T=swk)(LjqkI)Q45&r8xkaNdW7M
z@R~BwYcdLKi$m`j)PgHQC?MS!UC9UFR19|Mw}NV7w**7IE{i)H0WhyT+4t=C@VFp*
z<*Ha>b#=E3jBVu>SMv&6*xp`R#q}_InK;Wo0mydtwsA@#MS(sbKC1ixe2g(%*iMx&
zOf-=HcmgpTQ%0Rp93RznaO<{aWqV$}xv!b-Cf{!vs!|LPY#P-SkK<~&#gK*1?%dF=
zY%_vrS8e{pLAVn4+B8bcyOiBg!r>4h+=Bs^40NJmP&61YzG0=OMAv&;7wTS<?TtFu
zdQrLmsvk1aa92%~n80*O8+s(UKo_<GN~G6&Gi3KSTdZ<FHSw#w2PDP2_Zj<y$%JlW
zy7oynewM7-5);6*3!Y&>eTo85`Q&N6p?UtX(TmRx5{;}|$j5+4{!r;xIf)z#uz~*H
zuLmTf&SSj&+@Y4_gB)f_RUs88M<%jBOE6U$?)zt*xbL4jf&ewF7#-P}V#)@)3b%T|
z10iB|(ZoB3cJ|at)N2$OP-P>FcJF`u`tRZG7tpN&G^4nJTKfL`I6?ON37I6TPC^3X
zs<m@uUA2}vwQ^j@11Rn9fiQ{ekD)i7e(Hf<A++7>$6Vt?t+sCtZiR9u^nX2BU05Vn
zI@h!`M8dP$0%esJpbgSdbl53=gxovDV8Q+wC_wbB#uN}#_1xrCDMy_=BS9%lD`#-%
zF~;A;nof$`Tah1V)J)=7TeZlD!(-wmuV91w&|{jluKE>2HEzn(BPP{vztpVn?dSSn
zif0Ei!ZdJpyL0(%bX5t)Xkoyft_5IsqDz7I+31mu_6sG`o6ySMDi0!oY9!1bO!|TK
zR_o=<w$$NHSE((qAdeKFJ}bWdZ=_)T5vX}!`rYq@|B`Mr(mqbZQSHC5$BxdsR3s8F
zbZw@OiD?)1ZP=J$z2sQ%6dS-vqjp1&Nd-*^c1e=QplHeAc0I}1SD@vQ!;q_Pn^r;m
z&un#eTr25G4*5!mCP3`^3Qw_#rmj1nbIcK_1!jwY+kP^61=kQ1I-|X#=`sUBB5QF}
zwO-Bf{j8N>HmVmEp*QH<&{ubuOSRHi-5;ca29dkOm9Z;sy&lcP5d^nK8ywJBsevN%
zm9PF8%kks4q&c!$hGe@$@(j+kB;L;pNO|@#=RG6->zJhOA>FeXc6Zcn2g!5=G#Xs7
zaDT~h8Rmafy-?|?CRVQTz?N+VcOUP&0Sf7+ZfF3QmM0!97$bpGV{D?RqIDa)TR;$6
z*`GMja!wU0I01(b)#Z<L-o&P}8@pbC>U>C8Vm}CL|MiQI{;=(bq>-p$wB}bI>yMyA
zb1XP#%{Z`gUep~uLhYzQ@s}8R?(1qQA)i}A>kGZJ4h;IiSKoX4!T<W-@PGOTjO#JD
z7zXN4pAG0KE+iK;M8jzB@H#J03tBQ)gr`CyS}TR^IIEngJxi6ES@I}*nvsl3mhs}u
z#6P}%AV?{fv#Mv^keni}DmgF5uqN?_(ZgxWEKL2ZdJ?iA-6{`v+7vNL`4U-D##1;z
z{%QI(Cjy|P%N>yGZ&x33NIgwDf8k{A72#o5ErXafr3OVOYE6;ZJ$BR$u{*T~oZ=r|
ze+|zxw8>Dz{hFXCaD?IoU~URanPOHTd|}Q$vTD{>v=Lv`xe$7BHoFR3(7^IoRZK<^
z;f2I>3kXj-ze^if;!nD}SBbaOH1+DSA?M>59@$kv33)EC_ai7En^?Ab;aX;mCs$CY
z82LD{Jdk7Z{=*}@GsxMjt$s9WAq!%QE-b~1oh-dJ=m|<dlHI>pf4p;zWyO<9n(2C%
zj}y5%suoyAO@;NKtF+Vxu%Y)LE63QF;8=C9OzZL}`I;qOQ%$Ig(NLTjqJr^4Q}j$<
zcG8OGd&t70PJvMyP1mp;(Y?xr|LYIKTN)wAK?d@y9C;%I4zftc;HkPYtnbWzaD<v=
z9ZcBf#Q%%Cqz$&Wp^!&TUy1iEY}bSgXojp81n*QVQo)DM8Idw5)1oFNNL9rWl8C^B
z1xg&zvU*DL#w6Se()kSgyVK`aPm%OfM`&B0Q>tYIw;t6)Qt^qJvf9Jb#y6yQGPckO
zkOCB8pY-z63_u6iH~~w799tfYSM(W7#^O)>le!j3bmWGy`PxgmKIV=I7E251p#Kh7
zwrc&Q<pKpaACuIk-F?lS${L^q7sv;ktLl@6MGOZG<}}$*9CT6PC;`%!wwBS=KwDY1
z*~MduQmWm0g7-@G@TAay+z9IA5Dals#?)@?K%SjIa=2#HH99~~Wy9wE^1r`DN!%6I
z#P-GIra9CI(UJzj2Zx8)*5QkAL6vxAlA6p}95wd@CMx<F?c)*?KL1i&``}EeBA6td
zLi4Ew59z2zsw;HB(8)i>GJit!dkIF!^&r$($!)2M1)OCS4x;Y!mNcL(I-<y9cNp4A
zhWzCWf>XhCXV#dkqkyKu&US?ZRE?51IWclnXt0fH$Ml_TB3b?9%`1zcs3nUAjDE&3
zR1iIALU(pB0OXjwE;6JT^El`ynv*-MdQS<*uW?F4Kj1TizvKbbOr^@J9HQ)}!-?>r
zHe1_HpkRa9%}x(2^bw%A4Mmy4?xm!4)tMEwI(BPO{O-WM184wAK(@c6#RgB$s6o`W
zM&c^~;Zuyo3%A`<#IV}It~i$H?gp~~-q^SWV9=+@XSnk^rGbq-hHrm6eEZwVVyjOY
zSI|y|!h~-W5O*ctSP6PaVT<^b9u0LKxstrwtqHk{>V^2m(^MPeD>0aAPr(fXba4&j
zCS34ll{yQNP=Yigc>VXlFZ4c6Bz*3gA=vpk5`rl^V+TSHO&ULc8;sI|Lq?QbCo!9x
z9uSldrQeYN8sRV4%}}kmONj<fk<KxD@55t?e%XM@i)J_?ck!_GeiGMgGQ8QGY)*U0
z{U3h&_Iv%?cN$DOdeM(?ly7WI9iJgZOx8ptA5ncGpd_|m@VXci%Pt&`fepiA!GT6J
zC&YeS`3KTxPJK9_&u!-iF3|$Yk}!rVZOa--`2O|vFX8>aN&fw>5(+o9+2TAn#A~vg
zGE*QaT}+4UDa0{NTdgtEwoYEDDAQhy>R*J#;5^8($o&NLM|_a*KhU#oK}Pk)9!EY3
zu1tVon0%pVBTF$k3$faiSa&HIi@@Bsy^SKma2wi>m@fAYSdC4+H?GPp0#-a@d*m6z
zDq8z%ceWW4r1$L?7A%8WTV`tzMQOB<zUa{kU(`{;Y83PlW+#2@QliK~3bQL)8Ih)&
zve_0;Vccg61tE*`5mRP27KTiscF@;+n2<iX-+N1ER6lPglx|CppTLVbJZd$Iln(<@
z4j9Q}A;vbVu9vcpUo1tCUF1BytKKA8&W5^QPip-28c(h<+K?aEIx-E>pSh8$njA;~
zCkfe2$rYAsCtcSs&;-QewV6=&fc6*d9V<(?F}JYAfw*cklaXIZ;yj1!&No$=Ji9_2
z!421e8T~81v4qO=VW8qes_mfq(&ee-(p4r`EV07wTsgayrbO9y;K+TB!J`B;wKvX}
zF{v1>qNM<qI;kPO|M>04+AjTZ8qEIKR^oOvjfASJGFj)<WLY*8Hr8W;ZGoQ$#vb-8
z0|0Ta?ohifc@Rws{^us<48t_;<EuJ8XufIZ?JTQ$B;TzJoYBLwd3CRt3W(i`n|uJw
zN$qO=<~2BlYRUHxxh+pcZs&~Ti>m6J?zA<l?Lua<%A}0FzkDbBP10h;u@8$B4o1)u
zl@t_u6tyhjN|6gbM|nb8Fd4YDNmg&b0q&@nCZx|i2pWd6tFJD2huouTx)!|m4~433
zaA}YPGd$ULK~7Gg_b>8jv5q6G?$0xbhpi%Q++Df&-pNJ<w#|90YjKlv%8$qevwc3;
znuDA4fqHaMb~fVWfR*E7rDq2E!uGs6$0yX1V-S?1?p@>y$=*g#^8Pe1v&fTnh1JLn
z+v79n{!y1F5F?7aWBU`u9+e2zp4jybF7O@#M>f<G@X9kiq|(fd01!_QI=>;^k=5mE
zwFR-|qaq*l5r%$(b=)AO9WOVe9+qXytC}j31h4?8njUq{K?Ja75BAaTCX#DgJz&J+
z4Q=Gf<kbL#fw5Gb;r{K(065t&mwn63;FK6cb8}EBGmEZIY66?~w%$aOVZ>MV@YDp_
z*4=?o7rAu=jv(ekK9K^~lJ8h=s|gmE%d9<EXx*z06Z6^r3^iH5<{V6FYTbN6lWw`$
z_p@oqFw9`*+WSa|=4rjU@PuN*p%nQ-o(SNq7V~3`)U`fEs^7f*Jn#$s+jkl#ln0uA
zyOM>D3I{VR<euKKc>ja1{@-9Z+X~i?odfmEG591Wgl@`HB!fLoJH_l!)6q=|+09y9
zdTh6vmgZ8id>r0BJ+&9F=wD0P=EE8TCL*>FD?s1mdGqF-97H>P=6#T$2p064*Q3u|
zy5f*!*juX#6n{SmR?wm*1$9uEag9*u<UWyo>P?E`icwJSe6`Rw=^Q?mP(3PUWF2JT
za@AWQ;plC1$Qm0S>^f1_)h)$BY?7hTZWx(}G1huQoBS@k{y-^cvTal(?*cmPVwPQq
z`5lzIb>x8K$`%tQdc8XYsG<jj=FqBBbKRu>SzQXCL_5bMGtj`~WQG-NK@lvez`e)a
zIr9(-=2?EY(=xpAZhrxZst4&_cWtvU;RJl*TNKMm)}5;NcZDm8EnZoA;AN2&tl&}!
zv+@k3U~wZx@S?q(J7{uMt8t%Ys?ek$4zyv9Wm{yu-eDb(zJGyC2+;vrtlK00diZ+k
zvGedipwchD5&pwBEezHt6IsaF$pf(?vVh_&JXt<Od%^R}5T+{MEC0gcx;IP<njyx(
zn>p>hO9_*{f}^q|^zA{V^=h6Sg(Rs-olN^0ur=kVOo}|o&OW`s00ubX8f9$h%BiQh
zV+EEi9()KT%S$kgyeL_TpF`>N)xV?y>ZizZZSz!g)c_g_mZoYrn6(^L>$U*NEIo=V
zNq?{nQ!1G|g`suM?r&c|2G{b5aOK7P14+4$C?knKJI)s=UyIs1trW+&_ruAbT`Mo5
z8XL9K;Fu_x=s_?K6HN!L*n&IRW8(yb5`wj!b<Xet>3du6W)J!K>nFBeR0u8Iq1|2&
zP;8rGG_v4f!`Mk}lkAG^dT=-Gwx|dM<J?0s)zY~SCcZ%+2~`e@QjxsuL{LaG$(8yv
zPdR1mI`r8GMg<jn1-;Zd96n9{_x<uxG@LjT1HgQj)Jt8|Lk<2Lwy+PabM0Yo>yhD+
zrD}O@I&*>YgrduPV@gQmx;lXA{ijkNy#DZVy`wQ`Axg>u;2&;Yq4nktr6*OD?I;{|
zI`-bHlcctm;6Ulr+V$m!x!K*9O76L7cB@F#<lBJ=i7W?loY25<&d8p>)GVI*YTljo
zAgLp~Ax2BSW*h>t!O?0CUbVl>W2y5=>?R8WIO0}J$~NlDD<s`Tx}dv-zJX2i<?Jfg
z`6kCv8yu2es<3W6!CZgy_G`=6{}lfEFVgk8>GhbMJY+*)SnjjIzDlmN7rBR48{dEm
zQGy;FOHTG%904IC@ME(jp{^?F=M$~O0J-Q??bqr_-8wC%E8OR=Ml)nU-K3J#QWm>6
z#Jpw_ELcuM&aZD0e5}@lpR5A5FtncUa-PAq$)+{i2fC&5h(>wl{UFif8h0b8Em4vK
zIa5sY9f~1xsT&F6P~nLN-BH@9#I7w{Re{*W#peCvBnGTb@=)Hv-ePLntLi<>WB_>W
zhkKD_Lkz``TE^*b&{nY=<_JZxK)2koR@}0xKlyK<^GKY}v0TbS4dn4)-J55FbvVqT
zGl>oIt;EfB;b7d1Y#*#+pB$)8Ymn4VIAk8vC97B0$@RwNO;U~d`g^Z2Q{x=7ZhA-9
zxig^)v|T|kQZNj`i?foG9e1H#OeWOgtoRm#s>yz1zlRJal#qyiNES&#$Wv{_la`wz
zHz@a|k?G3X1wb}BOsHmF+PY16P8FCej7ecL_5{FKbk>Q=vio;MlfcRiQA~=&VTd)c
z92abzp?<ZyMmz|5vb<C=MN)fkVr+@uvJt{|??-p2ld`yIof@mpaEL1X(L0Vx!K@D`
zQLdEQv<C7Y*-8F0VESq!vtU3_b6+ISSZ1Uk&#`V#(9oDW%g{RD0IpCDnXT8CKDN&N
z+9WITcH%=Gp*e!iRP2<EQ)3z@!9qUhQ0H3-7VW#^0)w7VMcYfNOM0d|VxX(oW;_NG
zryfd(u<g`NAq!wX6&0w?WI~i#s&MO}S?(C~<4V}TI6nbEWgiE4od~esJ&R3HfCIvV
z>rv0tB2Xvqv=L;rD*zQ1?MB_f*cxd8UJKwn!;j?dXW{CpO4bEp7}JnC+Y7}_)s;Yo
z9h8xu0RU~zeu3EEJK1A)#NwRq5ushK{YV0~{^M-(ZIW5soj@{@v?yu3LTVkLSK3_4
zPG$1AwdX{65Y!p=5aHhj=P2V@vNYFe!%lLIi;$^yrfsJnduPBE9wUk^<2_^GPe#?Q
zod)RBAtTL80y2n!bSIS<dEoT7m?LS53Gtw%QVcas`+l3yt3NYCoc(ZPN+{Nx(VA%w
zx}6bD{j}EQu|-z=8UyV<#^*&9LiqD;0bie1D3EK`h}q4>@$FBfLdrSb6`HV<K?V*+
zmT*_2P+RtsXFekwq`;jSnRBTIJCaQZTTp~lhlp4<$xNt@#N_~E>>a4o)XteiJaxz_
zFuvfyVR<S<QfVh(W8$|@ZON(CVhfau#eN{(Kz1%L5OQ}Gkl5wfCBz}!h1g?4m(7ZX
zF3IA<Saj3sh6(UZkpkKgB};jSV#;*sJ}_N|<ha^Bzno8$j2)@ghl&&X+HNnSkE!cp
zI(fxotfK^$`l7j0*my%AgH`L`sPL|00l(=Ls*tRP*T9<R+U@9MuYizw=CNTE2JiB8
z-7`b}q8=mN1-YI|9$VrrXEF#r6+aa8O;g=(TloXa+Ak=3RRc}_Cs`^8;szoHmO%no
z?MS!3gtxz>e*q}o4zdnsH^HS2wl>8@whaNqAhZ+%sS9|p;IOW-r|*gc-)o27I-gwe
zV$)Q}<}Zu@*BIIKrIhleLsORG7OIM8$Jn?8S!#zpIFvV!e5Jjnv>m0or%X#<nImJ>
z9PFXhcT1SpsICivYjo0LL;h<lMd&BWF@0G)(v|~;8s~M5_<D2mmqJ&KiVa1Aue`6+
zCgWf^jvxN4zWNu8D;+%wuxe+mwpoRi=x;KX>PE0}v<8qX`Hng%cR{@t2({{}xQ2O*
z7lZdFSJQq{dpok-)u4>^{{~8P`sy82V{DGI=5hfQiR7?PYED*RQVoE9MI9q9CQQxC
zi^6QdxXzbpk4P@S;vE8`)CI<{!+v4Lr<|PuBVVRAYUCi#`Z2)+k`(zDI72fO)~bI7
z%tiXEw_j#JyX=q?oLCLUa;B`V*XtuRj7;eKEN;ReHFTS!H%fb}+WJ+Fn%U$SF`4`7
zd+ER7{EghgC))y;cpiEZDu+>iyH(FvKl0^)(?W>xd7f~DRg7<Xbj~{3N%wP@;ZJ9c
z=6?gk_FrGWl>h&&iY#wPlK~7GbVVFCCH&~4@Ex9S`1{`VFA{q_s;#Y0VgQ>s*$9+u
z=Ev;m47>sn^~*5<O?3*&Ju)&hPHv=|*1U_4M|jBp(vlpsl`iYo9*lg}jjXBKbOI&#
zwUi=3jUI3FkYoU=wO?4}N^Dya99SZ2qaF72D=(2I=yG&ktvig~jFpwcAvwtKU=j?0
zIa+5!LCA7U2}#3@UU9*|L)z9_ybJFvp=>Bvrxs=I!wJsACYy7W&0e1|GM~fn9i{Z7
zn=KOX^|kQbuYH#>I6oHPeX{4>j+tiIY}&i+#3QK;r^2%kp`f`W1+b|TNd4{;K;TWU
zDh}nAEC2?e#Pq?il8EVbC`WoOA>ed1$w4A#`34Oh1DS%H6z3+a1lNw0-YY1O!E%Ac
z+d{um*oU3zm*Mr(q$SOfSrG$;1*DqNgX8_LaH#zbVoFhOZ2E9RQ~@(@CM_;AmPe#2
zEia2m_A+j|PMH+n1H0AJi4MR>X;t}bzuTySlggALkl%Xh#7YSfj>Aaj9q<?z9mQvz
zLx*|pFXZnwM|gQbsf+3W)W_lQ{R3MXc&4IBIJL5&U9#lr{Y@ZbIDG*Fgz{bP)_R^A
zH7L_h$|solNWo_BCW#{Kub_Iuc|laEG$wOQe5K;H_Qq3~(&zowx5D40my}NdrGQ=`
zjw&(Rs(lQnVjDC(OnNclE3=Upc45Goms@dGImp_Ta5BIb!&<Fz+PI??(c;SSa$p?T
z8K8{CGi~9w=CF=0(2O6HI^z?}>or`BpR}`mOW&8}TuT61sgtCpS1lvP?7O<)%vK}T
zn;eJgUcrCgl7h&C!IC`>bS3L<c2krtV>qj(ShIP`ph5{YO^73y)LX9#FV=?y$CHBU
z5*VV6*kr>xokxcRszXd{w2ImLy;~q?nb;K|PQW`B?kf@6J%+HxOXPd{>(?*CsloKa
zQ-euSDp6rkQvnm;yd|CftD<YP*^r%N&-0$Q^9|AB@Pry8f7>}*l#0avMc)2PAXirH
zrV=L-RS^!&H$4+7&T|t1^?wrfCQG(t*LC3he#HS~RTM}eHAhh(Kcq}BZ_ai1xZb5V
z_lCznCK9u%8fZwFCQ`OYW}-(DAdm#i;ywIV?X}Nd`*@^86RU*xGV{HN8}8@qb~Tzl
z)L<hC%|^8scX>JU@K9;@gQ}c(-+6Mi#cUZOhZ&>~ho?zpw?fPDa#Mdi>vEQ9_U%}5
zZZSLuYD~`b<b;(JjztP-+$(epRY|<<7_Vm(zEqq?Fl7tqBEs;GGP)=+=>xc=Wf0w;
z7yO*uIzZL9&!b6mz+RARGk<=hd&2F2qT>^~QOj^T06Reh7RSV?Y-Pnp$Dom!lDlR#
z=w#%2chXp&{81HQC5`>mjHn%*SfQv8`aNO(1mRFXx$Ks7Nogb5Qgs`xt0W{IZ17P=
z`y_1iaeJd|I5%u7ds|Lbs@uZG;``qZKm1|(ntSLsDRCfGO@`+VRNkQ`CN`x4xm}}9
zdehrIl#8@(sCf>KwL#_9vGI((gaM5j=ky)&U(trGE9`5qU%RTPDm7$lqAaw{NxcDw
zMkiG(2%g6dx2@};wj28l7ARcHH7Zr_f_`AqSo4WR<Plrn%F#S-%X^FLivK!%-;M=z
zmE_H!gI?7GFoRstrLo|FIqWEZB39@=NMq`fftxzjI)EebQvUp73v7~Md{(uc_&FHc
zno!419fDz!l&ps+le4wObI2K7u^W>4+i-op{8jj?6!5-y{aN}I!VL07(ieYluWY1D
zJa))KnW2nXE?Y_o1*gX*7wlRMs)#k&@?o5O`dtGzoqlfVW?p|1K&Cb>bxZ$igo$(j
z=CE<z3n5wrCKS~0+~lxJG2;_`54!PWZff`gY*JK6!%Y@S8w5@2^NB$itksZ6-{=(q
zT$G!va_J;Yk%l-b5O<`~JPbVAOTCw8=jILYrIYjF3Y6Ew;OtF|jQ>&@R%x`{t&K#n
z^hF^GRFqVQwVq!wwv$=;qI8tch()<d?6`sg=D3ln6=jwDhwMtR`Yig5tZjI^J=g~q
zW0!|(56*ek9e#H-1psEvZNqv#@sk=!DF>4;5pW$#^s8CzC?lI+SKjf?DoxI<ybGK3
z{QUJ#sx#L0K3|lRSlV62927G#xeXZgX7OgUzHf@p*-VQ!OUi9A&!DG_KAm`mC<cl*
zlJw3Hw~eeptuPdq<&;PO-)%g6hd%+y-j2Nroi(gjR_|}Xsjr`baZiTm`8z)CNo0G~
zG!)!@t5(#6O3zx`Csl*D0XKB~egl`uiaSh3uNNGR>>B)#NSPA1YR<nVaaUE$;bOFK
z0#Q`<FogYZLf`0cy#=oU1q!^Ilq0kHlq{#!8Jsqd)wq6K2W-=zf%SqS!B=GxFpV-=
zZ0@a*HYnD`LcTOj_Ida4Sb%qMIgLW{i87L$tft_u<p79t$8q<Y8##!qS}Xzww)fBU
z8~aUo{aPCT<t=E<2^ui$svTJ|RU0OHhI<=NYF$s#pxioL`W83&xu3z;SfKEuTUfBu
zTFv%a%%{tMo)@L=jY)1MBOPM@x_+x*7D1*e3LxMy%`OOFrI0r+Pr+cB559abNo*nU
zthO1MNAU9E*k_c(%$0MfsJ|tNT|SPwJV>6$W{&j;kUmyr%C|B*rn~c?6z}4)8tN%V
z!L&5o`fx{SS}=@Hm#gFHqIP|(niV{q75Iv)M4DaMD3<$43!1^7cIsO2fDB#$mR2hX
zGjL|%(WtYvt7*jHba#ZqCz-bC(NmU|k~3OKgWX&gJp<qP5)MM}-hG0ohMsO@Jc8^a
zNYe~q_2QaskD|Yw9MQDWA&+9rGP9-hyDqx{(9Y=EV*ji+rj5QxsMXU&e+$~<UP;hc
zxxq?57l2)a{LZ&P=~09N536k&K_=7UUXDUivh_1WFNl5AZd_&Y1HJQR1yOPa9Y{?D
zmR4n5!uvmJM77E4F#uWDc4kKgjaVbpU$5N~&h|_LrAUrYU0os8wo0oyx?*^*!s$@+
zt=uI=%1y{XFo`O^Y~hEzjV`GB?o(Ll>CAuX9kY#M^aQk2+Yk@OBl=sbxhHi;?xj$T
zeFeuLsYV}w#jns-ac_-|u2I{bu-UX(NO)07n4?KKp;W#XzVjW+z!_XExx}V;GyDN<
zWTX=#l_09!+e1pawYnVSTe?VRl+Vx}Mx9*?^}o@9KM*E9tpZSs5qKt$2>NUzw=@}C
zIb!ZZ#C0!!aox1*=eXvX@nky;ez^Ian0r@GRw|4YI-oxk-fe~(lrpD5$~y%IadrjZ
zziA2C=&{doEE4Ea3`#)$i$fbG?}V!5Fn?;rq+4B!-B2xOv!7<qLK|YUgX(+W{4<PP
zl1A-Y!2aaLRVA{p#YeS3o384UZC3#z0An)4lBY<wyP|1z!glOrOso_DniZ=F)deTd
z47j@}WgrE4dn$CqKU<WMCu+6hO)5(%3}5(oK6?Eqq+ineED~;BBcQ5zcCJt{&7C~6
zn$(NgjRbC4DGV~dCWfHf!lVJ9%KGWwlFzWUK&+ROR?tl9(s4|-O*}hz%U_nX8cf{`
z$)@9jC>I|#VqADpb%68%9xc9WLFK6r!vAGC;M)1$DMM4)3!D24-$P$c92YDu!S0yb
zNeRu5qO`Lqhs;DvHnh-$rp=w&xM$6aMO~w7UymvX_aA}K_TIAE6Q7HtiFf}cNadv{
zP<F9^QKX;bufo4it?TP&6!C|wmXDf#DczsNnKYdsig>{lzMo!IQNgxGOLy+9t_rzR
zBxbL;WuEn>+&~ulhu6>F{nzmRbE$r4o1KXHc8x=C5@rC_$@yDywx-==grXK3*sGd8
z4Jxe%u~-lb9I}c{zOG$oZ`tZN!4>c_txDdaGQ|srcILLdwVc3UIlow}A~kA;bH$X!
zOE3s^M2oEwRQji6h<W#=JnYx6q^$5;J6cx4oZ0|0?NKi$AUPJq@>8WJFv0t1fX}-<
zhqmD+rXQ|qvSs<KpIa(J7HfTN+NW?c6N7O~IuryeNT*d2C<ENj-CngcQrc@8Xbuz&
zyo=f8>*Sqvbtml`MpPNsyOh|=jXVkT!ClU){Z}b=zO<7bh|5=)l4LzpFb7KD&~(7%
zRCX*UId>7FIn#at?Bq~z<F{}UgYv;_!l0NpsS50;yE4k^{Vk!&qt_9kN~hgafxaWY
zjUJ#SIo_b)m_DUyx{O32fQw0Vd4yhBaCv6{|51Ehrv4aammcqw^ab9cB9#1-%gvJF
zP?6y{%g7~A>{@g4vFQxe%_ko26ESq&gu`HEVvLX;?pJ)YFp(xo0SGu7cT4H&YF%Na
zSH>~{+-!kAJ_C(t)zA?}7D6axsEwTE1VNFp=a`vY)@tl(0op1*R?=uQDVy?CkGRKE
z(U<B7L=mCMm2!Y~rwWH0$8V8Z71L;I%|UlNoU@O#9zb)U-`{2nQd8i(I+S)$Xo<5f
zu>B3s`FJg4$6&U70yzE(oNr}5^nl?z7H%`+WV&E?No~qTuANRqmZJ7~FZ3PDXdE?=
zd-2$$l*5pb!N&14Aj_bDSAK+Ts^ma3CCDq4jDztgs6>qvah7&=PfZo@JD22F3a*X4
zDk)r0LfYHdrl6~q9E|VXq}{R$Phq*&6<(!j+w8TAiY91&gri&jQFo29wrVb2bP5~I
zUa0`Z$@l>Hse|J7o$3VwCEN}0rbbWZbmg{NFu9`R-d4Dfqhi+8n*q;I0_q^ytmD*F
zYWdzp(^O*?AIk2%7C4^;a|pe|!~we#AgpYb^O#;>v9V5hjsThFxGb=(Up5eS>Ml?T
zyD9o&D|Gm0<0YwPURX8bAbZ(tO1bYpwP%ktj}EO@z*8hQQGYzFd6gtR6|^W|6x2EG
zoXd09B1f3`Re1fAy>*VQq_vtQ7N=<Nq&s``6dcIaOVKE6!76Vk*JNDY?4V|qBx$GX
z(@yi63VJ};x|TbSn#TR2oObWn`z<4J>j(kk6X>F9y#arK!^u7kl8|zF=as|}Ku=$Q
z7&WKh#RZ6`;@L$}B$i`hanfj$6jtfr4UiuQfriOGJ%IJdm6%v<(l9DzMd3Wh<+fA)
z=c&k)8fj+w?CVudz??R`z0`_G<j!@3X6PIvSyJ<25&}?L@aDb-TKNS7vQ8Ppn{$;F
z$7a<`c2=9im1#}&EhGYiz%HjzSw&el(e+icr;y#5SV3jjCq}>wxZSiGG~4M*61jKf
z@6vs=yJq1gH512@-yv91&g{e_t6@adxh3PddQbM*KJtHgv6uettM_s({-j%KJ5Ks3
zED()5;!a;=JO}tCw*Ew;-knCTzb0Q6Vg~Pj8{Yl&{cqp@URx|QnI+CoO(=q<1=kXl
zOILntdPw&?<!5rldr!<Uw(!y?t@|kL6a+X|Nz&cP<4Ddu@S09ql1R9sn&<8k(1GVo
zPS_31dvi=}Av^#9zQBdIE&^1@t^yE3yR4N{brmc|&f}2(S)uUKhwuR_IVHQFU$bP8
zF68!wB}IikvX4oGtJURgat_=Ir%7Eao2RMq>U71T0&3k}0Clx$ES=;U-3IYCL7)ib
zVnHzjDd{<vghnnE*#L@Mm>$8=&#t`Hv{pXMF2k6P@Kt9r3CqOpA9=nYwc8h_a(q>t
z=&GW$BZq!b5(l5)J<B3W>KLboQU`DOnEf8jvi*kHZcp3$m4<PcMm_k=6^m-97;fPj
z^(?e{^>2d7E+o4E6TeZc96)owu+X#X_^!^M<V4B%BL)N<>_>$KG=yi%ZEAHdogGp~
zNoVybqAg^~tv+UujQ3Q`ydDw}k}*Y!iVIuj=xbvXvkWlM1#deA5lgv1V>#twjFbU_
z7Mr}yyqS=A)m^zb+q@sC70f9&&-PmzaIjfeT5g;Yy&zl?TpCWjl-$PwfY0*a87MG>
z?Jr}83A=Tp5SFB$ul&~+%mh|D!Bg+>tlFn{_YUSDYuwuXG7jNkx-Kh67dIVA7|IuN
z$&h+AF8!(!faH=*uDNqV4u!4P&WU83i~-BA8d&wiko_Nw*D7J_Mnt$ee5W6JvBtEx
zgDCDG(IV4Rclf%d&t0nJ56=dcsP<iKz@nUvQ>6V}FlwxhF<yVmhz5*Uc#8IOPA#7c
zH)CI7AlgnY1&2iic}J2i=#H?4u}urbvXjFpjrum7277n4wvC&5Vic-aTB^2iO##_|
z8~##Wq|Fy=G%XaEnj?kKwTPS)*bT1)SY~-$Td3<D<xZ|i4Rxca<>JZ^ikenMT%B)0
zSfa=#4ye(u7GE4C7zbSyDTy1y<E%kw`9{(ICN2oDN+qqb8`wxfnG}9TwU7|61SdTQ
z7Uh0-6kz=Nnb|fcr-gLjCy)r!Z@W@SD|jE0=&Pu!Y!|EVd~(zlyL$!6BT+Drr>J-u
zvaKgRxD?&LMPF6NyU#oT=5h>^`ULBIYT===)S()YM3UhJ>~d>Ch@BYLRY#voe3cQ&
zr|lQ-P0;BV#uBMJ1)oJVC>iAKx=@+Cdw%doK>{dtvQi{uw^3lM#<4&GbGKjZ=0{xI
zY-?b<x$GVAkiy5Z*$%c^53M7^z+v{G%jTw)Mh;MAA2wCf^-60`gp#C#lx;@Sk)^(U
zgbvj(&=3qECo2c6N|R6DG1gM}2m8qfM!B{1=`w)ewc5H<B}3)D(^FPy*U%Vv2g1>S
zj`QLkUZpAG37ePo21t`1r43gt0o*Uw9k%n#nKgKX7YwiLs2j6{Kf;M4FZCli9WTLm
zR`RxX>c}1GXe2kRnzBMok?g;j8EaJqf+r}J@=M-3YbLWSwYkPgtt!H>50JC^6e$ce
zEw`96gi%x7{ck{NcxV7X1D_dja&;d(#}L|;$W-u-hv_11ryDLwp5olxrUIq~#*uDO
zhVr;18?>6lMR=;(Tf<W*r5l2cKzeXk!R=!bcT=H&TRZ?GsQp6g;=&Rprc*_k?!`ks
z-A*Pgs5!lArS!a#`)M1omk`V8Aa+Y?MKNHb$%OUpv+({8@~ZdIAE5N*l>+oQj+~-C
z_LW#vbvw67-Z4vZC+8wUV4g2)2GEW<^r6IYP*X1hRGeJWaz~H2C0u18AM%PBh<%Xh
z*##d92(5-;S8YN{6NYn{=2hCj;T0sXVQf5R>(pX_ce$1S9oQ&xaV-6HCsG4Q^!@3s
zj~%xjeRq2!wS?IZxXV%*s{YIp6<@m`NP!E4+J|f9gK{4$mf=mdO%L7W35|ujssqVy
zns)H*mas*^FHQG<{?B&V?T;tDIRZ{$-D9A#CrA#-&tk;{HXU7)1xu$Y*4dY5=uAST
zRlLnboiZACbm34jv+*#69JqB>8ZxT-7-3X#yzw4+<D$YRnts4;yrK^0$Cp^(lRcy~
zD02=`4K2B;2q#Yy6*P37K@SN^<#9%r0WKGprYP0%iKEiNxmz&4zX4>n?iz*HhcdO~
z1aRW0u8$8ckTFQ5e&*I~;M+2L0ibHWaf|(cK-|_@ztXh@NfiLLpF|Pt3Zr?uwa%JS
z^Fk@HMqrg~429vDFC*<!rYI^$sdr4f^uvMWiPWJ!n^eL>RP(-<sGS-W5asbz0Lpnd
zjWmOQK*&{c?G>uvWI)M}VRAbzRE5TViLJ9Kr7dbEIjqV*gtZm1Qg9NtkE4Kq^r%l5
zIdn{m%GLr(x}6qtg&L|YD-i~>asqQ{#L@h_|B52yA6|c{KsH}4sh0U0YAAjV&<N4V
zJ5srh*%v@MddhVJp>uN*)(~n^Vn$bsQBA#@&xi5-x|giWBe(dI@cOd^K`AH?wLUse
zzIT;lclIIV0x>MHTJ<>$lU<}2-{z|Xn?1LBuTImZK9Bw(nwgp2#D}w3{W84%3do|z
z!#u-^6>7(>jnYA+6hPAhR(Pz5fqdjt6S50a)?}<BO<`9g(FF!k{(P}}hQJaFAo=ry
zO^zded}b2v27ZB~#La=OwKu+hd?W*8qdG6{oGLVI6e=p=>dr+q`fi4l%|O|3<^{f?
z1xgkD>FdYgZ_|k$`Nc3VrBuZA8nc46lvq}x-4*uf^Am+k;vQ|CQKnk+0&T)LRqR9|
zTG}*LHeo<Wp-aq?Y=ob2PH?c6Zdfm}e32UyVF`joozLChh9CXtNA|&0vjW3+xqHu&
z<R4+RnhumWE~{*+xp7awnlb`bCRXVx0JwMnURMn4Svbh;8qA`y^>zVEw9aYsSL}r;
z1)+0z8-mCI=K!i;$y6WIR<CtiN7M*v_N0daQyhEBFpRM{Gqo<|a_vuA>or605+%jJ
zyQs>F@wE>_U$US22CX3S{}UW`*`$Vg|0ft`p!KhDNmeLbjt&8=r5d%JKvAD+JQZ{G
zqE{aDQ@q@crIB2(!u((AzDTtabEJ}D{{hmJVmw<gsCI1tD3yZIG2n~iq@_Js!G`XV
zq{7i<u{XLHilCQ87f`OiX0LTvy0+}*<q_A?>01plKucc-=L=KSQi428)^@SfdTi3@
zmU5f%Br_oS$3=rGB<u=uC!sTg>I*jIfJMhEnEg^(jPc=nG(&E$kmRyik6YvbwU+FO
zGATABbrCy)5IVu)J%Tz1B?Kqa5+gsT(|lcQAR~IxnCw3*R2MRF4nUaTpEotkm-uT_
z4;|Y!B+HE)#j;5KS!*W^bF*2HfvWLbEVn-B{M#MgdNoTI)s=_=ZaSl&zm_xk1AAhN
zZ-Fr{@2HLODSr*${ugh=*BbXUGIv)(?-bc1Jy6dMI5>QHi5f(FW_%E$v=p8eP3lbz
ziT-3LSm<x4XD$y)-x1x^QZx)qi5lY`V6CAvM}opS!G)62=gA+nGF*Ha>V`Lv%}bLc
z_R@!+kglYDT`OA;BpOl3k|4uQoGnlX08n(W<;xouT{zZWy+PrS$kliY06_v3THK4S
z_lP`47)XOFe^KUyrYD=+=>6@yOE=k>a72uCi<1hMgai`MCm*AxK7>2?MMH%C{y&B9
zrcbqOsn*h_Mw=EX7tzAGwq0}?9v!W9W3u2q%ujdOXX=ojIU7|W0qowLa27qZC>dd{
zoUK+MM)RdAddYeKgmE8jVWEoh&*yjR1Q37dNI4&`Dmy;ImAZ<GP{))*N>r~1q=l+a
z`4kQc#d<k<=RpHc=J*WgaH<X;P1pv^FrtrVE7&+d7QI{@c)_(yk&!HfLQSLM3~y6t
zsTF}rx|MgY3SPt(_xPzLj##1sVuD1bFW-L>-v3_Ji|iw*a@$y(EqDO!{X;qi1xx^7
zR!{)z1UH^;&3Gkxgd`yu%eTE8Xvk3&n5R*>>?R3D-UIE_$l1c3q(E)C^CyNz+KoL@
zr)c28Ol;ILz3U~W4%+Wa+#q;^T0?quMxgc_9zW~-^q&t@uD`py`v(|`tt$Uw<-V@!
zT1<xsh;MwwhTe`L9$mb<Y;R6)?T^#h+H|chscVLWrIZT?z38Y}%!v%-EA5r9Si%t*
z0%PiesRrt^4{mBI^$XwRk>&O36O>(;fhMYl8T;ecloI@P*6Dd6X>9~_iSs8#iI=+J
zHHuT$*ZP^?4nR=mQIu+SFC9g!reif=_(h@Tf&=^odD7kq7Ol4U(4u|<U5W(_RCuWa
z1Ga4@u>6aikwfLax)n|w?&~F`rz_J>!*JrejgY||a~TnzXUO&Yw8J>@K#h^fP%(lR
zkQe8u;7%!}wSxjAx$eL*+jg{=foHioG(J*y08zEH&oev-H;ggieCJS>kS6GSUcYWC
z_GMpI{)|+$L3KsA(89dIia=;=`}K)L0`hrwH5OV+*FccP#+IaB-1x^p;l)bs4JHB_
zstITFa9h;*wA4Gv>$mX2#i-rJKavY9`>I$QhxCIg2wFCs2@G1!%mnD$RqaIuVqprs
zV^4GdFK?l>l?Nrolblx<1}%t5UehjT%#@U#r>@kNn;SVr^~pB|s*H+{Dp7ynJvcT1
z*~Mjx##P<O=-T5FZ%=C30H->+LG<Q=r{Pjb3R%y)Ofxh8Le*$3g`vCR(Y)bb@0A^z
zE2p3FEF4)WPKPi*a3F2QuSl`8)?ax2LW&am8fio1##~pojw-HFfSDuxsKtc=4(aYn
zQ_&mbTB-JzF%b!J{y+b3_}Bi!C0QIXUSQ^tWRh7(VXaO#*2%+)wERu3S5RXRlVL)#
z7SwXu2dJwm90ItgvQR6}NlKYoRYW-3P)}{!I~@LGtb;%Uk);?X`@g{7sFd9Zp+77?
zSm3)!FWQRix*{F&Xi{Y-wLa@5u|*@0SVbjJ>>+!)BH8ZKA(bkNHSt_3L}Oo8TC${A
zQ^_GcpnTvjz0)~@?}#bDIE2Qm2|5)PWfaZ!I+glSH_f8XI8MdH{cx1myC2KDMe?gD
zzkm_7eclhTT_r&^o~S0Zl&+k#D2v){5%4gqxSCM0UXz@A30PNsQD{`T#AjbjVbupU
zqdc@yXY4oe>|gse{O|riLS6%#f6Fm%S3urXU7v{Gt<)2CkRo!-yVWNx)->#7kl~Q=
z$=jau>xco2tHVek@MKC%a$qMsPy3R`^hVk9=Mq-ZpHt{H5t=jVT50%Za2Vy&x5>8Q
zN|4|O-%ZV=fmVKuks=2CgTtsQc&z0$Qs+K(un0Br#Wd1y<P|1SJc4hein?Zhlq;~I
zF+)kK-RHg0Fbdy(AD=LIs$2Q24MSrrBGA@4m@X+2S-J)J$|iU%C4y^nNC(_#Um`&i
z9Pnkj%kwp$eFq(w<+3X+rPb|ldMUFv9{9H$Q=(_EW7`p$v2aQU^MN^g1YlFjE%ZHU
zBv+JM!TM@+=Z$MJjh7Ij9nlGECP_-^RF->-Z3~A=-#||2CM^=mf`YTvr1N2uWEa0~
z<LaP27{)$AlJaHn{`mC^)6@YYf}@7EaG!C2h`nn)5ysZpG}@goGJ5jAYKx7=aME(U
zQfTMcaO4fqXN={^saCsAYYFWN^YzUHq&DDVYa%u+F8-l=F+vW^mO)$2SQwvJZ-5HV
z0O>O_v2np;%o{rpDU|Lg2V!0ic+D|&bZKf~zgoF4j+r8*q)npXCGdjrrPD;oDlLzW
z>!d^pRM;Nyb7HW?2mgPVn8nV9eA}fY=qVJW1VzF#VI2(j8jJ2d-&k^dWTxQV0su6$
zPAzyiK3%ec%6nKCmYBJ^G}Id);EagwPGJ)`8}9q7WH@=RUG195hTQn-ErerHr2R-T
z{V?ak{0jXJ{q3{-%Ou%+VtJylg^N)7jzGt{clp-Mu8*W}Q?><?+2!z?*&D?hZk+-^
zc`FLVRw+W=Ph_&?+KMr9Bqnt<VEhF}tUJa5*RH{86kfC^lH*O<gdP~1Vo^L4M*>6f
zR%8hVDcAV0vxLRxMY_CERZEQA1VCH1G@(C&p267+rJ|C<^XT<a*noA1CK6`8KDU<d
zVOLvv#94xp4!}<t<m>SI@dcO~)a%^kB}bY!Hg<jHYnOPC>rjxhQ@n&^ILN~!nWxZ~
zxhB;Dn@YI`Y=h9c`XyL(c#E)6?2!L`Bc9R?Gx+$@z}g%Oq!Nrppc4km-$@-lOwS#=
ziAPu4KSGvwgWD*J&Z&iVxSjEnA;RENqjJvSgV%91c=Of!YLNs473OIPgzeOWum+(U
zxUS0mH8GKd2w#e;JyJ}ME4AaY725^9Yup@p34xGVWu@5QzzANxH1OWx0oa!P6!IAZ
zjV`4iFw{BNr@ZpRY2^tr*MzS=!@FV4EwMUsbzWLxBuo%apFC9^28-Uy%=SLzuYtee
z1-Eq+%<L#Yw67ZPto~_WR}8f1OyHZM$v9({G=TJ((Ov3^MBZ&Gg90&Kz<BuR1v=q!
zxB8@V$!Q>FC7Uk+e~#yfpWSqZ6EVl4bfnN?1OTaUtwEGT-5ZkAReeG*^Q^*$SdGIr
z&C<;c%S6T1$~A0yY@L?Wy6$utE0t-Qzg(kKGisj9CV^`l9^QVZRZS(3s9sWlHNg%U
zBOGZ+-+lc4)9~m240eWz2Nn23C7Xev;J&=eMuAt=9jjXXjgE>eu1w(xsIM{E>8_lc
zo@V#RhmPKJdr935S_qtr6<Q!?7r<YK*UxnVpwg-%vAzqo0BE}83A0B-9YLpn4F)kJ
z?BHcyHy<d;$DU5snm?!S{11N^e)vO^(1JgYi-M`GMyr6{cDDlvpjyuX4-Qp94jQW0
z!ln!5x2hWD7)THsRN~tX*Tfp(s^m+JsPMT>C-WM-i~i^E{wL|vsb!tA++SX-Uzl71
zTUoYLhECQ4HP@6XB(wS;Qsv{*<LlID(1Q9DntjxD)q|ECDj9ovF;aT}Yrlqn?LVZy
z{ZmQ!@O)Jt42-?!_DFzOyBdWGEJ`*&TLfBwZ6#33T40MG?&e@nsO>t>Orekyo#Z-U
zdc)wH^-&VxQN;yKfwctg8rA{ZetKt+hJZBu>gRq_4}tMAKFO=jpcq&7;O+^)xWe_C
zF>6{UsEy9k3_9>i*EztK`u|CR=Nl+-&r4Lhp6-mr{yMz>oq33d_uojyM7RL|E^}}8
z5+En`b$ICmrh6_Q3*84BHinx!&RWk6#o5XMI$bE~5CC0WR0MYq{!&GndIv<`%8Ak`
zW6X+&*gQ)3*Z&RYe}LaP-1+1QCl!bEak<)9!<A<cnVKTrm2L%HBx>4J<6H`Usq{x_
zYc{RPTkMBRvSCM++IIl*RYk;5?wrQ`@4tC(ED!n3WrjrGsOqfJwM*)?Tm#ryS=1^<
zH$u%fF7VK?C18{~5g;~KIFf$@(cgz6XrNMMWwZM`)=QCX+*A(Gy%egwM2&gRBZS`T
z^qOcd)RV5b^l)q)T6x3VV-^|uy<#K%paEB|m@UbKr$Pq;k`VZGuTbCSd=w_(aq-9t
z>oCrg04y+0D3p4gRCjLFU%%k5B-5lBM558itEhmE9!Cxh1Ludt-ee7EiLPkHR(`B$
zRt-b8v5J1?9flN(1F@8@eB|(V+Ly0tNXFqA_*BMnfoi2>@(W7qkp#ryj95j79t}kJ
zgm6Bm(TByM3Y?<UE~kI<H!7l>)Lp*ww&9U-(4}q~>7Q)7Tev86jj?fr-W|8{Al_;l
zrjYn&b$PJOr&@Bs*oY`Llu2@UgN@#iWy+{#15!<pJ_hUsa%wS0a0n~TN*6S#;P;nF
zmU~wn;q<Ad$Jm2+=8NWpohIzMq7?*Mj4Z7KJ^iTD!Wqg&%UdADn^25_Y(Wz_h~~|%
z4+?lBlj?3exyhZESG16^xj;C{-Pt5kxeQE#1NczSUb<9Ui>Ch7k)o2%O?4Q+#`MMA
zv869wFx}y@4E~{RtD!MKE^4d$Fn;b1Y@F%BqRn3P;zkZl3%PHqB==G?W_OZOm6i-(
zEe)MDa*r0%EsxKtg||hrC*gq&k;FwIPTZ;un<~HK@PlY*e-od$oo?YK{qDs0a8voU
zzVUIN!r0jtl&ShBZxlq)qL8|glN2d!=<f>@UO6cmFXb4W<w&yIF4EcDLD*UW(x!Cx
zEcKVX5%-V2cU4E>%t9f>cKMK3Q&2!-^@0vn9`A0WX-uGNmY3a__GxciFky6JRHkan
zq<}6>kxEw9Qyv5*e!LkLVLGQ)q!t!>Iw~~ebE!ZOPrp@&7RGe1%g$2nttGE+gn3e2
za=5A0iR;wHWAAR0#t8l$U8u45XbO9OI2bP~x6FN2EuY(x#BP@brkB>aYM)$`EjW8a
z^f0j9?S{>)3lIsbYF}ImR*J(UVkqg(<wgsYRFGPE+D?~zko1WOeV5I-8ZhD)_zeNy
zNH`P#UJbW%l1*Dy+#qL2d{uiS0&UReVo};~C@cS;i@G<v)9+Sz?G<naT2yo#_%V>f
zP&xprh$_i@y{z6|mhcp*fu}rKVJ%#M%xRl<UBclkZ?x7@J520grN1xa<-q*XrgH^0
z66sq#W1hNZ#dTm5B%W=iJ-c8IKyqn@hBw7YUXlXw>i{xN2c&q;bP%t_Mq6Fk9~ZQ6
zfYBB`v@KF4=F>(wJx*m!)W2WYhXnD1Ds^aPJ1XrSK^dmjBZB8kFxbRAfUs#YeH|a$
z`p9&^xV*8C16#!BrPnJ_%E0|g0>K1mM4jUKrZw^n1lPd;XWrEsv7NF&1IAd%!VY>A
z#gH{1)}(vM%Q+{rT?qM%z_R$tP93!!kforFISUDNXedr2QBUq;Poku`I&tbUqXfKM
z2|KO|%8x7eaf?_%w+>7SEw54180Z1VBG{C&pKxVaCZgcBL@?a|c=iXTSJ)>%i8r^!
zMiO8Eyvd1eOENh~jBa3j+?WKIn3)6F7hufOgX}86NEYT0Oa$;8%^i+@9r80DN~Ex-
z-6~zd?03R&=e_8#G|yatN6U5@smGmm0bZNgt4e{PA_dfhj;H2zR1XyJ!q*+)aBy@O
zgrz9O#NRbqif7@a^$q_HN)0dmS*#8Kzv8yj1m;>SScv!p;0l3FCxlu}{2La>zu`NU
zn+pOZcec`#E=Ptd&kEJUoQsCUV0}E2G|Ds6ot!eCt|jHo7+DnrpQ}B~t0K*mO1+S2
zkdO%NVRfUj&j7C3q^co{D*W}{X#Z4~U}S#6)FmXZY?hG)#1%c4tKJiYCmn+MI6S89
zgiWNwnspO3qNb-kg=orbCvZ(UI+&&y6^zL3OiI9)@7Vu^@0iM>lK2XL6bLT3Of{{e
z?h&$(D;Di827;z{3vlF1Z}6-4-!MJ`1Zc&}5FD_dg*}@C9xS7#t+;e2gewlHD<Ibd
zWb9#P-Zo8tE><wrb<(8ds|QY~*V_;l>a5Bd+g@4+i)c7d*ki~aAldhz^KFGGRtck>
z)A;T66F_Ir;3~CdMm*5vUV}MR=c{^M^G^E)JvjIoEk>Vw6y^;JS^o$yV$FkYNQ#Bc
zc8c&)-cXryqZRWN5PUWolFRrkhWUgn=a}WhMP=!&YwwmUgAc-A{Ds}62_n=!DbQW6
zJxTRUYgCnMd$GW@kx?Z-BUP4^o=|slHUoXZ$j}PVe)X*t2h6|b3$~yx$1bj>N@Xpc
z{PyMS83J6Qg2cMX>$2<gOgPBo)bast<AAK3$FrD!><+41;Y@4f2+ZB4iyBD3!FK<K
zpYka}tISxI7!O+;2|A3ykklK{&Z*KB*ipDo9PVyBF{+=~Oi8`v`hAEYQlmE~==Rs)
z{Z~fiw&$-#6L#GeeODZ>`0bO@q+>r_6Hw9j>PJvZs@SDcWQhmt%*dHJu8ve`=>-oy
zuTflt5@aZDj_>7WF`d_-SM@Z2H=4!0m6|&`<A!_}-PYX0O3Lun6r$H~=Y7{FYBmg2
zN8$m5?{CsCDF$5rx9lKIXU(!i9}fs>^p-vXero!B$d7=9PuhWuh1=F7i5UI;UB1PK
zyD_Rh+zWWlT7fiZJ+d<F{iC9Vp`o-~#vSMy==jn;w8*MG_>4ma2bzBU>D&CxDIhOQ
zY11`pOZ_N(hjAU11VIv#ua=4UCaW!n<PQ-c8O|D3B~hpxTGFczM)I9H|4H#{m4jq^
zxkqk14LYC|;Okh-A<1cZKB^Wb)S;`=)x7l7KbIWqhGc6WyzLz@)*%?TxASpVr@8D+
z1PxNVW#RA=AnccW*r>F$bQs!H>d-bhrV2vs(%6sd$t(1bhQOG<F*BB)z?jxqk6qE2
zs(YdrB|`W(R}D5LQyt+ERf=|(SDwt3lX*OI*S<|yTsf{uS`1oNv&mkQHOs?(49Ea&
zicl@m+;YYe9iwdew<}dJ{c)Wke-=*WK2HEUrel;m=^fR(x?s@?&4I@(m682urNs4&
zEqt~cw=dXe$x#BU%6!%!!l4uyN`^p<LA&pTwjq|<Dz#X`K;-4c1=mXacuc5wrJXZH
zNP_4Zx9;^qZKh4gsQ&Z?!>an4K*t{%J#^HS`fM)dOq+(*8|2sZA76^`rE@d{KxDd#
zJM}OX2M@+yxt)k-NJ%K#VX=$kz}z4K;Xc8m6qBJ51>(ps=1M9Es3hI0s`J2~?eKjH
zz!Ur|B`{V}H`m&bTD&d+nw%6BzHs{7Z6S+9U3FLeGSS-*%q~2D=JJS10^;nVtqa7}
zc@veIL3Qiuk~vpm>))&j+?NGMq8l#<guXQ$^!QdwOsrl|Ad<%JH0MlQ7G9>v;aDS%
z<N{KwJ<B~)0_4YfndTPuDkSDajDqES6IxZr4aI$eUH0;=UMy11PMMG=g}wE3xAa#I
zb~slj>!!m1c&b4Zrtt*}QT>O9qkmQx1*#)J0j^Tk_Y#=v{S4swZFv2?Mbrt*xoINA
zVxa&zhBM>E9L(gatiU~`*M`2D;$+xrP4XlU6~95;-h7=URa9BLQN<#vz~mOYfk<wJ
zwn|p&-6un$y4kik+GTYk(g8Wlo<O5wA#q$FX%Y33T66%_u!N0Xlq+uqVi#Jg;S)N+
z7BAhVrDHMRkenO=Z`jF~%fW=Iwby|;{#bKU?fSKVBseoyx$AHAb0xO{Md6}7o3qRy
ziM%SWMb1c{`q$O7CZ_*Rm(*;)CFC#pYxwrR;HU7mb=IX2eTcrM5795}lYxT5aWt^k
z=&<ZNR(`6+Y_#?6zlHay^Sxp8(4kF`)Tzj|^hIc33V_ta6QLje7F{A$j;t*as}u7^
z^%4%H&Rk}-&JA?*9CCj=OzeYjk9Wh(sxjZ1uwiD>ntntSiY}KZ1rV?*j7u+oHW<pA
z2L<1CWkI&HR#t)GMp11xx|6V}bX$9nYhEa+ak6Q0NaUufn3`5mTSFx*<Sgw(KP^s!
zSM$4=^Ozh7W|m2{28hOxavEk6w)DVq>@+$1&HF#{&ZTZ}1vAG7=>Uvyh411k)ub15
zbFjs4QppS1dFgNz&n8`C?tg(gOHbn#VV*9%W;3m5@-Fg|fh0qn*(}UVBx~rWrAxq;
z_g|{`cc;{y)9`s<zL1l-Lk5JKjF=$GjDU9dKjLlph`**E9A3%|6h}{P6V-$RYz^1c
zKq5uOahv7M*Cc~ZgT{kI08l`$zqA#M10P1tDs#7i&{uP@K-wpep#?{+S2TOY-YCl&
zHYAz<oVl;*l_mYQ9SO^VZ*n!aVHTVkoI+0rMC=yALax?SReQj2h0Y(O)u;ywm}`y-
z1c-wFu;Qn2TbINVA1M2)wttzb>S8Zf>EgB(YWEw|@+1%wM2!J(B3#DNV+hotH~c`O
zYIr>+!fKaE64o}&EIVKf%o^h<3>H@)%#+TL*>%`w%bf5bJFuV&ks5V?`Yam|6cig*
zuBDtSV!TlbTN1rT0svH4cUngN@os^{K$VSaF$$2Q4R#H?k*#Q*(g@UyL-^qhW1TP9
zAScuVbReAe0Ue0QOgZnPdQUPN%FW#&+)gZ&DhZPzWzhXft)HFAK2EfV@%~vJzX1!L
zaOo{ltB83Pxmsd-`QYv5^{Ly#laxwEZ>?1PhO@(cZIfJ1D4uxtfVFfTVrYoTX*f6q
zFV;#$c(^!RnzYE_O<!U*S^PKQFYF|o?#%y+wJ!DeIL#n_b(J?aFJ8`m=Pe%r1jlNh
zFR{kwuKAtoXDiu0_`q9UAS!&Zctsy>U2}^bp99v<FAwZ=FmUtXf;?htt0Q4&DG@y2
zLg<@l4Cq{T4|_239<Dt%fbTw)pY-)#Qj;r3j}KO&z@~!a9PL-ZqD3DM&aRZ1r8D81
zuLc@d8%~Lb!UW&^YaXo+70bM!<d(m(VB+IGBYzn__)AZitY9HRemPF6`y0eXSR6qX
ze+6pEBr!^D<%i3v!0wb?ARd=~f-7+~(^%{Jv1X)!Dkur|y*j-48<!;WQF#Ara0_aO
z#;+0)r#Eu*U%&prBoeS+0myU2Q+>gYYTKX&E-tP+k4>Drcoe0onA%K8VY#}5yeeq2
z!yFziVFb4!2+3P@(5K<W{`~hm7F%@4nrZ-Sij9P*ZngJt@>^VQHMyT=Nsx~AT#RdV
zG<c&C95%U@<(`|2bk`N^dndxZIYWGFMUbZVqx!|wNkW6Rp6;IsU>*E!Zcngi%M2QF
zKc?t|MEp!9pR!|X5f84)fAIbA@6(g{@2|gm{W{1m|7;+fm`F@eD5N>|gfnT~s0y1{
ztQ_28v?y$z7w<*2JG88IXOWr$tq&y2qErfT`T@(}-Ui7)2mmgrhwfC2xx<HW#fca}
z0Oi&WN#RP-6y5l3t^k+=+m(cHxy0{&{QAoz0Df}m?NyqtqsCtyGYkvp@)K>E`M5>k
zY?;HL?2B4m&)6S8S%n90sWL$?zT{KSWczU@Qe9`Yi<W9}x3*qerZQb`Jr*$sK}oPl
zeNYu-vL)dL?*Do_+?fRrf<#pC2kk5<CrpL!E%=x4C@c{FzU@j5)3?Z^rIi`cLXdF!
zZBW^!pQS_#lur7Hf$svFK}YB-{xY2+MfcPgm_uz%?xvOGB}7<RrbrXm?20*Qb+1Pu
zPpN-;`l8HJ%JtM0RT&*S{||{yi%;<5uDb*lU=?h(PKcM)xw#SWpwSVNr0uV0*cs9=
zHeb!_v{Y>tyB;&r+$J@Ly!sD!N8+ix(2LqZrAN_mt=o+5e2W8b2Rd6WLY?5&MP&@X
z|2pN0uXVLiy(wyc9&8)6tL0*rKve-C;&{snh>qfRrNwlihooRuTz$l7XuMC}!t(Sd
zcR_kMC#8!JotV4>5?;L7EpNp|BJe`tD5dLJh|5eHc=L2#6sa8)H>Ysp!)oDDw~9ly
z;c4rib!)o?wYqdKi&H|M3O8^}@a6PJX<GyY^i*EJK!Gj-mnqjIR-d-hS=TDga3~!x
zlYQ80SsY{v&I&G<O~`Lyx_iv^Me2}~cQ1DxAd`fhwJGr<ocbY^H&-~`sUFxK+>~IA
z5Sni3byhoFRXh;AxPAFiL3<c$RGq@z@Z1__B`ke?s^N8uyf|SCbIRwg0(ib-zXJ{f
zZ=W&Wi74tbimQe2mU^ct!3g#fg^s~5O3QX3C@j7glYYI@$r>zg0ERi%gvNONR<P(3
zQ-Q-A4y+9Br$BJ#u;7{ysm<hD;Zzp*7O2bO<VEr-Dk)qpKUt4mKIkWwgJO|g_F8T+
z<Y~@UCLQw7b&|xDEhbyNbPcy2ytm;pWqJ~!vKD=GBfXx<1Fyd(<RL8?fgVw{Za3<R
zrQ)0vrc&QyQXc7)>04QnMe={6-}j66pYaNRt_9A(dX%!GHO!XNr;1s3%OCo`NykLR
zC!NER_4c&wd$dX0*a)J_bXDElY~l!sgbnqJn@xvUDIb6BZlr@%x8$!xUAm2C&P%dt
zPv39^>U4C;);lEr;o68K;WXQde(=RxI$Wu9`1AuNAG-9YGpkEtijwGgn?a<QPS5k#
zQaoDa{znFqTcAq|#x0zORgmu|NCpD+k-bS#meQQ9J}m<QxpRIXQUekX)?+4Z3|m7~
zgAW4dvGTa-Xq2b<X<xckZ7ZA`wL1<MGeSpFWGp9ywh|$*8|0<kv)yo=$vE117B0<A
zs1>MG1#{UFb#j9a#fD^e-#o8#rzM!(eiXo~PEF=)IGCKwI#u!2u$4baTwUdLhsB60
z8LK8bi(H9j8Qj}6p=nfTO3J1KPQD8W#Q;*aJ9HXG!pFA)xu-vTKP#2^x9qI{WSI%B
zeoy;Kw`~Z>k7IWVXKOZUt9SKWz3~d0eZh_Dobp3Jg$KlGB|KIOptGQ;gJR87I2JzX
z#?Tk9nV_GN6A4K{XA-6=BjrVv^%tYs-}IV`?g{6zNbg~CoeM|xp>SJ<Qmt_E+1&V4
zW&qRds;)Lcw{7_nXEoC1=op{H0{gqq!B&G25j2gl)*$S=XQ%U>@SiN2T5^4;P6rhl
zVNzs>pAn2sO3~7e_1$Oiv#zz!Kc~=7vxhen3$6dd)C|^nIAy*!>lU3VJ2ylg@^;4X
z00T+0RK?<VF21#2uf9`Fikvlz8<YhK3zB?c#n2(C39deHK>EMKzrD=6J~v5!`$@I_
zgoZ;HsW_W#yWD-D_>$_FxRft0OTzM4mw_7N^fdm7c)EXj{W^UqVhTzyJT7&jD5mfJ
zz!lxRGKOgWgi^g$VH+pur~-^6L+R2mKwPK}03!uLD4$fN3YR!#m^esQXc|m;uf@2^
zcVDfuduZk1X;jM@rag&2`$&3@JW_8bI%X>gYtDmFAWBZV;o+`7kfo}5VkM(N{lxyU
z(DC0R+@x*-<FeF>CH*~(Hu83#ca^Y2QFrh&$Fsu_t!vd4!s4x*@=h}%RE`-QCpX+e
z`L#_4C31Znx#o8%u{ry`U%RUmx>5ph333cPe)O>i9-&+NI9<cTds(Qp`rUl7d<Iu)
z^Rkp2FteuHwP2F>zM&&==S75f7v_!|DC`TRXit`l@<^PBC3giBRA(eZ7g#FOIu;6o
z2cvI^+?oAzu-~MiysFUIkR6RV&fX2Kob*_(VKs0vL6-Qv5LEMRBaDB9(gvZT$b7ax
z?l2i<tdtY|@UQn!xhs!+b%doji(tu8Nvjv#I8a>NE~${99ZC7fFlR(lV~Q1+yQsX3
z&mqm42ujfqE|3Q@8NyA|^8$+y2A&D9i#VchIBE4KD`;QYPtGPDmf+*F@dVe1si5FI
z?cGn`|1=oLmM({xjPV5i#R~J@EN_?n#3fD{ELDeI_6!!x^^2O+KjeaECah5A)qs`c
zDyWeDz(x;2RJ}&32-B*Uq{$|UZ<n%ChsnphVw8aXnxbwCFtConk#Zz`<6~!-yX!D7
z{WiS&@t=Q8oUF8Uhf8K9&fSBFq0zkpm&$vXTW8Tr2(fQg#-)xJnzqb`q#6zOYF&Hq
z8Ub2$k3XxZv_-@9Etaf+uxaqOQm7@wL+i$i{waxBa+1&kXC?Pljg{a$g4*4<m+5$P
zO|k_b{4hLCaO{OwMEWrr9eb-6;|77eHQ_({i6q<#{0#KuMDNt~ajGf`rL?%_-!j2V
ztL7e;RfXyY5tBA%P+GYp_O*RFWb4EoJFyC&JtK*;f^oS-87{Y%0_lx7o-5-+_Lb8K
z9+eSZc&V{ayJ0Q_d_tcy2%1-idW3yQjypET>2ar72&0Ncu$QP3;J3z>8XcAnM(myU
zp6TX^#sXDdhbR46dpe=)pmZ5gVRws{Aq&U&g9*+_79y$>T9fQZ!8@_c5d)<(>dq;S
zD(!Z1n7Qx$i0iApn-7{h?gi5HTjfMtD-mAo=>Q;$&M=3tGSpO9aFiySc+TtL>y}#K
zTo!w$>83cmGu-z5zr0<oFRGSH&&Yl!0@>Q;Kd^uPgFOeiXOajxQYduqWbo@5T-#j@
z?l3+ki?OPb7b2mVQ^-{)k1po`-5owX<+he3C(#x7+5L$m23AjcE5M+!+L-rQnjhXo
zNyEQ;{qhXp+g^xng*N+D8A};gYscuJD%m#GqKTt@gFY5-7#4DqwvDAN5ER_L;XYAm
zI5zSkG5zJ1bDdRALlG1`<pqeBmMmuE6BtK1A@dP>j!U>OR`#ZAJ@}aQ3J(Un9J`-X
z=~XiJ=q@b~7=mAqlou@&WpBExBz*3}eNtV^sYd;tHN(O8+nj`BAqBX6fD}hB?AL^7
zwog!_!myhRE%vpd)L#;dCd(Ou!pZUb5lx2}L$;+mPk6BQ>K5mZnGyjcI5)%80kCW*
za|bHiStYA;!L$M(1&cm*(!xQ)&3tTKSwYvLp9g|5AbOMYxT>j4hyivD5f*&P#SXja
z=<Z$?fSaW&@4b$fO*gJ%8qBwngPp~g0Xq;An^{h3Na{huYagB!1lw;kyNp>P3`xSm
zi8{nW&|Sji&TU>dK)IBqoU*mfhC%VMhS95DDU&4>(n4J;1bHqln<}w>3elJ1T;EPr
z)WMX6rco8OdkmE0Y1XGs5&knt1Duv~bSsu#mejQk1qFc;7;{On02SMEvT4q{{~{Hb
zZ>%r>@%!OFrlX7T-o{%*ebZ%gLG-IOZ{Te1shfNEUm=|F52h%9mdb8-d$>1EExEDD
zNPtSwRmALIUgo1<%x(8<l_j05n)r6W;abNc5yB47({%WzE!ps%1S_SVW{7RPRfO`p
zv?>E?doGwwo6r4)zm$S(=AZzZh0)=`QeD}Xk<x|8Iw%PFJ}{v=`ituH+Oz&{_}&K|
z7kH&00-Jp9c+8}bG10;_d*l?q7+VMm7Nf$D(m{R1MDlNWN*itP`J=ZSV@BN#b$6=Y
z9X7zAWrQDM#I!5nI5RoSMjuOGv}-_SblrdD8K3Pc78S^+=5R^Vr(xblXXG>os8^B!
z?D4|(b>Z<=-Cnx@q28fX&JLqED~Umpgz{7<9-R+f$h*afE+s>#cC|doWMRWL&-y*B
zW@qMQ$<ZI~q`SA9dYk43^4kQgZ=~Lxvcr&s+-<)kR=9fwk4H1zL$y!C<d3&d5$&{{
zP+b`GRZ{i&H^JHaTxW+9pQjYTZRcfx`X8pBJIp4?DJ82zPIrn=NV8ijqL=v|Epgk`
zHI#*Xax{STpN`nB;37M2H<j&Bn}UV>AUUVjYIDY;)Wl(W$viEk6FvYQumde2Q)vb`
zybIBuQUyh-B@@V5g=?j}M?0o>h5yd#Txq#ot^GLSDGLyU<jP*j(XC-L!&U`Fmz&eB
zceOT?Z)^Kf$-O!vqll#x&jnfvtMR4p^rr^Mj$`81y+pO>MDL+!KsJ>!5~8<yk)t|q
zcbmMQt9jI-a<HM8!Xdu^gkrHplDgWSX5(%8V${-IcW?BNZxpz#=n($|T8E=cNd<YY
zV;|rg10l(`(Tk04d<wgFv}-KV8c!874esd6jG=p$6Fd7iLR7b*f2Tkj%XR1vX&BU@
z>SE@*>vm+F1E(p_U|Z3rrdNcz#|9ERnx9I(S^A4e2Zd`s*E))_f0&?bVSxZ!DJwMO
z6C9x%Tz#sM7U`M6H<HIGY3V6R72DfwmAA%oGEZv~w72bfhpKU3RLG%^Qf5HVfl~-n
zm+)28WV9+9+YH`8a5ykIxYG|CWHb~s<Rvc@Z$Ql@i4?@gi9gF6%AFPrs}7(%y2+!1
zkZBEPqObv$3^_Ktmcy=KEq)VhQq$wx^GHdmt0be#AHnDSt)BpCjb~qi%AYuhgQTWW
ziiQZJ|7!%<9TWpn&I`mTGDxMrgZ#urJpgZBX^-Sr&eB^^=~D%`A&)I*&H13-wT>#%
z&f0jt$t%X#AbmxsfiX5i2X$aeEtN1IkF*sd27Qw1+R4t{K#ylA!`WBHOo-94vMw~Q
z_scv|!$6JIgy*p0;j$G&1sj`=ZmaMZ;pn=byfX(m2w~f{6&gxRFG}6vcSp%fWZcyh
zhNJiHsx%=9=<v1TKm$k|Nq!}jN@3Z4Ku_O*nRbr7CYOQ{<F)}7A?E*$U2wV(%OS^A
z{$fh&H^nz_{#Gm*=qZ=xE-BZ?mVmb!707OguN@<}SbUGDasy{q3QEhUxBc1eTjYSE
z3$^^eD{sXP{T?W8G%8Qz*12(q$&lec*g`Er%DBUj8ncljlcZa~uK1a>m>A^i*ur=Z
z^!X`EckY(AEA5{|^Hpk!1r?#o{;N7F5K&9#{b(Q*Yr{;`>QVqHqfYu8_;A9zjE4t+
z2i4E^9t}HxwhFCeFPr7dJ@6uX*QBeyhHlJVLmtwWgVKdgZZ`eyD?rCSy1e^TMK`-}
zYts{3CiNP05G$Bw4&y-AMLtXO;O&813t>e41cRQPO2)NH{3<0zPNMD!B`Z*o0U)Z@
zuaQdA0QQ4o*h-G?ob97VsG7^GDdg?66bx4L(K(Yqy3z{a1{e}z@)9jA`?@0LIp5NK
zW8`r^6~0!eCLYS{3e)w3EKoVZ_%kPWEG1Orrmc?+J71}l4yk-NYnMa-@ddenlG~!9
zbwG)}p$5e6C97BAM6KjUl$cw94#n}^=KSMy^(0o(`DdCpg=_QZ6ovC!G3@jiti?Pi
zG$bSj^wPa?hVstVrY#an0)@lcH|<X1eyGoF#<G()0nHn@uE~v&uVm4;+&34j{S`V>
zq`KmuYPCvpsk~jQvrWCsuK2p>o~t!A(PIqEuNYN4IrLZx8dI>WxI>W6&{~JiJxyWK
zm^CXF2m9Y{#?^!CkNwdD-e7%{uprm)@JYp^vne5@p<U`7CB@D4db5@-zTR#L$G7n+
z@Q^nsH#Hkb=O!(%ej48Yi;^#wGd1Y<6tVm@)znawpEm17Vu*5Vdk5aMRyPQ%Utn>6
z@=fg4s+-jo)T{z9arW8AZM)k?ui+f*9sW+jeTyDI?XJ1&FTBQ-q?V^F>N0tLW_Ils
zT|sc9bW-Bth(I2{?(V0@>VnXlT7396v^qbZ&v;co<F6?I#|19mJ7v;f;#O)jgY_H8
zA#`Df$-Iw3s0AWN^2q|(0rFgW_9}kj+(hZIDsm7vo!Sz4s2!4tJ~c6w<;l~HCYXxb
zJA3Sv7BqlqLMJn3rbt^f4Y{xI78|%0djLnTlpHIMlt$43tKug@9;KIAcP}r|Uc^N1
z@Mj4=#2229=+27no>f7g8R-(ZfB*g`A^oENMD-`BMdBmm7Czfsmza9w-Du(6ZxRBx
z3KGMG9`lU57V7pPbbYt*Mc|ZCRGnOl&%^5<mGCPU(OqoU)lVlXqmuG{1zc@{1EDr;
zyP(^bj^$1^q<mL0kw8+t>8hgAEe(N%|1b0!k~zZB!!VYh3pqm2NLM1I0@iJKr^Xl3
zDEj5<t74ND(qspzAu}Ycd{5|qQgL5}U0+Xi{%~npx=KMi1bx{B5d7p$*^O7-?2r{)
z5;UOt$V`{eMWWo>Gl%QgHf(r;*x8W_2@Tf;7N$<9X^$|BY}`giV)QBwpwtL}9kcG$
zolovVqsPOphH`3v09Jj>qkbfxA%ghWnfM(fJnYBsP9{uGh3=tH0y<CUt$!N8b8qdq
z02w<g{Q?aPxXCT5^r&g9;HToxkD7<=z%_YisPrHA$zQxx^{Hc-16)Ssrr&(SJM7{R
zaH*W!ba@Ewz&_S-$n-fS-B`)FO8j3yP0j;rMZSzE3YPqRzlJ+BOa%w8Gf~!7z9U?q
zRcf~jBESSd2SN#&u-}*rjIZ~SUGIy;2Tob9#}>~j+eG-T!5l~Eo@^66Ijekt54?&r
zwiy4sMAcs=<=`Huxwz25c2cEX%00kU8u7rwIibk%V7lz74PtEPxFF=fDK~gpzji<f
zz#gWNAYqrTx`r~5YURJBv4LwINisi+I)SiDD#Vk#x2QM{`M2~q17-j6-SF>{edhre
zIeTzw6g0q1zz`0_0$&T{mr47s9WIG0_};dJj5_b~f@XSlLqc4YcJkF}tIU-2PF$#Q
z0&-&yWD)e>i7G)SUM(OzV!UA!aqmh;4PWKrsBUI9h(XM}ck$s>IIK0(mHyy^55f<=
zm%dnXrz2uYCpMV}T8G<M%(Go*pW1Hn5#$r1Q^Sli_`+l^di}VTPkMDhJwuhhc>OhL
z^IxR{QK2v+I0s|2F5bBdkYhPrRMywM2CIsJ8X4WRP*p(5(h~@Bpt~P(y7IJ1O@|J<
zAz+Zve3cdO=XOqtF_%?q*DGh&36w=v(yhVKmT#PxA#Xs5KV<~@DOBc6nOAor_F3X4
z&2VxPseH1hUMB8N5n-{xdbN{tb_0@Bm+X91YcjlC(CRZMsA!_RPu3e_<u_gWQCk7H
zzk#Cbppa~;QAhASPbk-HAZIQyUbMgv$e?;_EMX+aoB@lObxRKD@H=sg&6=d>powhF
zf@+?0*znuo>jw!hrg1nZ<(6YKP|)lQefs(du%<)8R9c3Um}0<O2&3A*?c?|ICx3m}
z(we+>35Shy>0#2$k3QIkv}GxA(2`rk81go{{dKdCE6NQHyGjYPZDA9xqk&6ghhvK0
z+iwGOf{nAMq#0LvPZ|{VNuU5}WB;lGz07wytJ%t>e?;E6j3*t`Ti#Vb)`)WIO8bJ0
zl;32G9_$JJ`1OC#l}C5|DK6JKb+C-r%jX<b;iaD_n1=pvnI3%NTpj3GhgcJ*V&vs(
z>Es`2V@nL&IN-~$cAX^S)MkA*d6=DU<XDXAynRfqPa|yuR1wfB1!_%MbMa;P9^*jE
zbJmf0ImTxw=8u=y&{Fu?y8_0uI$6z_5kcF5++{!8C0FBBW_%#8)DT)~k_aFwNyXCV
z&!n*2kKTXt`sHbA`%cd0H@f{^JbH|kB3aTs2Bg(eyxNwe=hAIsf_QD+{X}>GFq7IU
zg*=q=C~xKg>E>{~6tQvdWVqQI6Zkw&1r*-G2b97T+38{G3C@KXH4H;3Af|w*$=?!p
zeHgM{5!|P3{)jj&kEnQr20_}e=JG9%VA8yHS>$)!tX3CH;c!RXUT%!O37nZVFce3b
zPu?m;_`q1Ly*=7)Ih(_wOU+d?Sj+bCu@UiuxI~o^Mha+@t=t>k;3_=uz%Qec?b4&`
zE0X_PqzcII64ASyLBuC&)?TqV*zj<oI<?x2Pi?jBszPtX1+UD1B15+jW}3W5YbS|g
zgy6`dy^V%2fSH6LW};&f*S(YozMUw{h*aiOv_!ae=_tN?;qp=rEl1{fiH~^dh}@Q3
zqL#;HEk?jCV0*f1ja(KG$yOMpR}j!8+|ch3brH(rQUUM?iMJlbXOXo+CZqJleNj9;
z0sH(jWh_Ychon6B5u<9}M&k?CD3o2wT}m{}pbBj+Ez1FHw544Qe?EEK7D8$xNCE&J
z!65a-6&_ZeR5m_%_YpK><#692uj-8O<h0S}al?qh66<Hut-#(``47pyW`T?-5f_!h
z@)+fM93rV&YSNjtfA6^g!ML5zdO6g|M732Th$?bum+f?>K_;1?k+IUE0zxF%oOT%c
z?@k+<HTsRnw&|WQ3RYRCL&5ZqV!UOdV6@TT^n7S&#+J<HihFoTj~Lp=`B~}2eu(bs
zBIoz%#OCV8w!`LY@@3JS%vs%wXzU=C>NLF_j3(<DSn8>WVtNsHQR+ojs!0WVJoQRZ
zbRdkbqROZf^m6Z3*Y?`r-au(|AZ%2(16*3XiJ??w1eES_crT55S~`yndc^f5nLxSX
zRkkOzg8KLN>+in(&*6Xf2a=m3rpJp@rsW){yNI{NK*BZ+mpEZVm4Oy#n%e?oODvNy
zQqrNz#^Aea+?Qf#gS=q5%ikF~^sr1bC1R8r)uVy0Res&(M|V}c<Le5o(_W_r?Y;dc
zDHpv|SIRvgG7?HIwY1v>#Am9I>4@^q4ef(5Of5|v^g@T2jY)N7VX1LQnDoh7>A@#m
z_$l3FO5z>f{<|+<e~#(TyZ`?BvtZ<#L#|nr7$u);s36Ynriv>xXNnB2z}%x*xKY8?
zy}Bx*d{X1UtHzv)H5Mm3r8YRSGte-k<x{NNuxG~3suXKKMp6va(2g|;e3se~cx+JF
zq^ZC(NWQ^-gX?(T4f56{_^PUc#G*KBTRP1oK4CgivrU6?<7sEC^UF`e`;U1i_C*St
z2#ZTvBzEITa1RcWEF7<RK<IhX4+YYp1&;`|YnYB*fJRZ706Q3WT>@%V0B!~a8lmrG
zzb`uoE?cfDfI3ZIewnhpmD(f|MEmlRv<~aZ<svF9X|f13UR;%}3~-mn34n%me$$$t
zMUGBY+@75VPc^la+WL|PKOHAk&bx%nXzOH*=HQ3gq)+!<Bi!luVYG@uZJOOj+K$$W
zkWH0{M2vL|j+~R*uHJEDl+$qpKH#M0?vA|UsiM)@IQawXd=SZiX@aS24kwyX2N6tw
zGNv0U>$!kz_WfH-ke_kQBEPx3yo9VC)?WduLk5(~YGF!_RnKQiIxdo0;qv|m4(ASO
z%0m6;X|DvCWi_UeR>wnqYe7IM8-;`_FSOJr$l(OAVscCjK>2WLaNmJ4dE`<vVdB;n
z+$r7wJUSOUKWtTYFI)!t8rITdhE`5eHfqh`ls9SFDyFt^awS`>z^2(@|K^@oP!<ki
zcrn4o%%ZYWrI9-H+%qq{3mA5zsrl;tSGF6LqG9(=bjT8ps#X}OG1-O;X*qM&KV~Tq
z(aovs_{&6(m%B?eE7N3)@+wtM-3GoLth_9vJO^#O$u_X=0u@6En<AcZjoBzfMr3{1
zMzyi`m#7v?iN(fuxh+uza3lQIZM_M~`Q?M~qXaaCQc8ek2kEUSl6Z+!$W`jO&J(2c
zgRryH-@jxl6Lo@RwJ`Uf{q5NN0$w&<+M{0bIvi7g3DGbrT@@gY9U#yri)j0ruYFV#
zIp%kiSw6o_+^1q0_>@&)#^!MVJ7QnuIM=(XBTKsuPXqfikW=H}p-^KMsH&BhzP8G)
zn({VNmvS`^rRrVcQ`%+Lp3JBewjS-13{Llw;-_T?+)o|~Zr<RjGWzJ|Ar-+26lS;j
zW;1!7k>ZPGo8^lKL=Alxx$4|dik4}$LSw`aXvq~#92CF#8bWIy1de=Y=xq_ZMzt<R
z2_fY*1Y4%wAv+rsaqgW-hzzJB%6-K-P$Jx>(*9k>BcHVU&~jn*=-nVxrAK=5sZ?7H
zV2X`dc1Ra7TDF}E&8oT($PbNFz86XV6ZH}j3^mXI7P4qgxoz+%30sRpIpsMOI6mvf
zg@-5c8MCre(UI&gifiO<0D<Dh$ac>umpdal5Q^HBI!=x!?KnW`EBO@`#4O8IQCa#H
z__qzarf4Djs%SK<m0ehJ*zV;LZu2xtkNhokw#oq<mnml{C{_fj0j-LEP~itFeNI+6
zHV+)~OlCphmckjHRQmQV1^AUcHtgdj$Hfdq>l!>T2De_OP^(E+EhB8$ri~H4-Z|LQ
zUS@G<D7=Vr-f%mq(P;q9L`c)ZDe(sR4i<KhvV)L$C8f1?c$HjrDN0UO!cg8{%+@qL
zL-}ksCbk-y-)O&eh<<1UF6Ba~O272zTgTf6ErScBgBMkfo-zhh)iLCTnedvl4^}bD
zU$FvS)i|M&$SC{i>&Ipr4{N|1#{R^(T(uaqck#DBN>56)pjb$wPmt56S}<t0aa<26
zF0Qe|pu1)k9Tpogxbc>}@tZ5p*U;(NtJeAcfJ=j;VpV#$mdtOUTDsOQ+(4ArtJY8H
z2ZRXvq^7L>L|Z=HZPx_VF54CT+r&{(UP~%}0LFzD$av{>R@M7@vcc-T=tDcLv!@A=
zJ=EAQp{rPqHdJkIy=Iog=uU}J7Cf>emei6DLw3jI-X#t)6C`lJhF6g%<x=srqQxCD
z`Lru|nrRJS;5;<}CQ_b_e4P%rq{A|PiG%74EG+1IMeP#ijb7)WTV)_MpH$9Ve(=#X
ze62eAPWWp+o2+r)A|<&ro*ZrHp`axKxT|Qfx48S-BE0@q&5}|j37ueD_ccJ0LM8^I
zTPu+2-J3aJ%5*koAE>6)qtq+vR3L$F&pUK&77kE2nMieF8yDU1o~TRkATAzZ(sTpG
z4eJ1!JlU5BIC8B1Q%0+w^4FB5cb(!_D4eZ@Y(weKI>b_kRrjoG2P*zbx!tyNIk`Gc
zwN{vvGVp~6ZJNGK7fsdE0Wb;x(2p!4{6a5rAOJQZ>X(oQ2Pc6A*o>qzT;Qk4N-<Tn
zt3nwA-1p`GES8{d*-IGT`pjGzka09OSSeR*RRILEL7c!3HjJ*i9NS~Y!ZhoY$Mr<i
zMH|kzEcHrod)!fNt=i%NWykNOjmKz`egVwWBU8W?QXnS|-rH>faq;whcN7vXT-;a<
zdG>Ly!Sgf!Y`ynH9c-bo&<m$muWAM?A{`jsy2o<tbAYOp>1D{jav&NI^%vbgi|VB9
zL7vWM5_bu~Ox)_rzY8Cv;u|j16p=tVkEM6|gU?m$F_2vt3?X_3u|Wwy=}(MA8*a-U
zPb*H)V(W`7o~1)OhS@z{@;np6J)iD@jalwpuJT?&x$I=`PFO6A)J`l&+C=nLs)n3Z
z*TlY|qpdU&X>6nu_}UFzv{>GTOSMNo5Gk`dc;;wzp2nBrmi8$2zVJxx9et=j{vw^v
zuz;w53Fpn8X;6X(cMF&ZRE2A7l|b+=^zUp{Ue$sX8eWdy<O4#`aI|d)#wh$?2jm1G
z!DYD<x>*-U-vL)Fg~%qS%pJNxL}t5jg|?_Sv#^II(he;V^e?+;-QcDMe(vTB_|avT
z*JZCx?OsvQ!Tr6295wahrP^HWZN@=4N%I7!H{GZ@?h228zU=OEG|LM<kV46L!_?az
zdIba(5GN`hOx?`>ZHvR1mwn<bv;8+`geTxAaSR{5|09$f^NtZpGdD#9PlF@;7M2q8
z$(yH-n|adO<S^DcK<_RcCWPd`EfLmJhh&C<%B!H;)?TK<Y~w7Qiw4WE-KdQ9a84(@
zVJxy=!LbiC&5)i@rLtfz&^f1efqH;ix#&ONRo>Kqgd55eGKqArNMKBY`P+GfCSkF-
zbh2vL!DWhR@hQu^)e#irm{D6O6EX#PU()QJQ;KoR(i3IzMBg`1t8P@ay?45UoTW=J
z1k1W`Nv#w9j5k$jW33v#QK9VKfFX@a)g^VbeOW9VyHX92?GG5W=$7!_(XR*P_|>AM
zyhe}+1KqAVkhM33z^kIYt5}xqMDp%S47iU%Rjmytk22T(Gt61-cSr(Y-dx`O<n<rl
z|2Dk){Poj6|2X}a0HOnIwj@G#_W8a|8^lT4(Winlb;x$AN4@*%{b#Sgd-o+I{eFcU
ztn;#y+F(un2{62}Hy%9G;d)>Psdd_8o6k&>MwlBTm)BnibcM<=;*$?W(}iRXZrPfW
zI4|HMrjMR9JZJ=@>$HmE(*|LCDoz`m(<JOO^*QzPHeb>>c41eca?GnaIW71>2eo78
zZZB4dQcj&&X)0Z+eu@gz!D0>6D3@Nn2V!~NefA!nx7x23giXD?0CK--!8#D{EzQ2J
zdYOcXU7K}f>Q5KycUUr1iB1VTjMVe9J3}e$Cd-2W1kf^={Zc+j5)eOp=(etT@QXFD
z`rOrK^0ul@OW~4UrS#u!^;E2TaQ{+W@><e{W)=*NRN^IHa5c2aLdnEkHu-9daaYNV
z0kt|?0<T&R<z&%NQ~7F!^V$bEWuI_*QsdcTy^LdieItOQNrWZmjW_PpSNSqF5zs|Z
zjl-ZTeu_gXbQSy8OkmxhLRqM^MFCO8orBtOJPS>fa>D9^d#*Cs#bs<olRDPhI6Y2Y
zrBH|68NynI7v&W-{65$h>bfu>>+8SU)j`7R?4`hBa8tAKNIXT^Cs-74*_OZnso=m*
zlH7`*WQAUNYG=nZynqx8bG6zQ<4EIwG3l}IE2n;t+UrAv*~3vkF}2Xn83e7x>fK#|
zGX~B{LzgFtfnw&ec0`)>>Md;3OXES$7Smf-qQ34b+_>=TNfty?Vg;%~`>5%>x&k(O
zy`~^8E8OK|$`4-xfu9TWCZw$`nlgXV@)iu0wsh<lW~IQ=$4buj&SBF%ET(z<q$5o!
z(28)q5)9X(O1#6>rcpygxX#OmeBuwiaZ?GvBp=1D?X>jXy@us$$1d+<C;v004-TJv
z_xG<~oa-F@LAiSW!FR(C?EzKJm0O_6?}LKk3eeRBr;81ZDrlykGlJIOaKOb#a_KMb
zwN%zDH(?gy@uFVhv*QGd1Wp(m-}@H|?U}<sp6*h$SH+_&y=OtS&`c+ENs0g#^~Zdp
z_weF|LcdVkC~LNA8lp<yIt@UvcHR$5FoW59YZTM9s1P-v+lLGShlBHWQWB31$mD13
zl|pRS3Yc(;xs1?w_)5~d(Rn1=nbtXca}-)AMN9gu|4i9({imNO9|L`w+G|S+!$#Nb
z@gQ}Uc;SpHSoc)zk;chLrIF79TgWl76#w}86MKKp)U*bLYX@Ioh2c>R^c)c1>BScE
z*X?$GVE-5Nf74Gh^%&?bj`jt_wQ=S;UdcX6XP9eU90t2qPdky6Nh6Ol9oX0T!2)x_
zmvc}C^<h6$`pXM3eAXRogv!IYfey7}sWzpC*srfxdf*z#<FCkEErvxaJCb>&BGj^N
zS`hHcPPcL}>Iv&Gq36uYZ0R2|5?s@a4ZHSC>?@LYy<`1XHn=Mll8!J=deG2^LShb>
zck78eC{lWh=2P+;oEyGD6)fQ;J<}Ixvg!0s4%HnX#*KJh#A9>21DVL?Nn^5q;C(w$
zbyO;G%iCr6i~XJEc5h>o5S6!!bK!16a&r%P6r+3<^edhpK_-xEHrq2#4|tu>T+qvM
zRJ=NoyUya-7Ilu6zw*@aTZG0(aA&JNy;blAflCNEHju4qxUd_cciu^`UgiEsQh+0b
z_dm^kLY5RaY<8HtHW$rs*A3S=8N;$;A`uCKF9Ak3a1OfQ%T2c>t{Az*N{#Sr>4QA2
zVBYRj8caBGEYOpI8{Az2mBPx<xFO@!sb|IWG`Bi8u*C{&uOKsPARSdy?cyEU(5mBl
z$YXF3aa?D+1<>$YnD5Z95WE1zWQ<RrD4gD{MG2(Wi*IA@DqM^e#Q<Xt#&~duhZFVU
z?vGS)gjDSOAgGt?r}m_-Dyx!C{gRhx33x_0!?wVLrn3L0xEk(=rRP?qEKA<ID#r&4
z^d<Os>bRahVx@zXdFul4>2`Wi;Q&Q!ryqLvgVS-W<MCCLLT`PnfnmFyoP!GU#RzM&
zHSNqw4r>mSp&W>(8&>T2$~~!VeeTB;5tbe|5XcfY)CW(g4pIV>yQx@FvipDVJ#t!R
zj3pha*M+^}K=bO5vkl`FY-~Z$yg8slkx8XO{}Y!_9lTSHMQdE`4(aXH{7GFCqG_Jf
z>rf71AL>ipH6v!KoOgt){iF%Wg?@o(ct~VM=yxjBE5no&uz`?kkzmtdVICFCO9ISl
zH=VvzmnBk1Pz-{13<r$&4k?Ys!{iO&t$dwM4$Ng%!n{gD6|O|gKwA8k^wnI%u8KtI
zt%)yb?fj(P#=wGsE&EI~&I3i9oV00^j+kYX8d)Z3NbsqM9!{oH-3pICHCnc>pm2rj
z-Ye!Pp8iHkj9=NMb}S0aH{_G2;{pw+%Xfo0kU^>TG}5v0Iri&P4})LDLy?S4*tCKl
zaI=c&1>k?fXOi*>oSxJVTLJ4dp94U_s_uy6hsQ7Br_ir^P?S)6H4`!b%+~ly5~Mnp
zR2vT|B<v|YVE9_{cp?)kxP0|Juq~XnRwsW>WJ(>El{3--R4r}9(H`0?U3qe~g6zCv
zFGCx%NkUR9m^|-K)UO%a9^)7*O?p^T>x^{A=rmU9S8aF(bWQz49=nuFCkJoXC=-MO
z^8zf;&{<%P(PXtj+e!U`OR8U7kVz~=spE|m7C5{!HWL;<eBDlm%7op7Vyl;=F+#CB
zsyJ(KUuA`sV06~!S|W|06rxKXizK~g=?eZbV2Kdmg?n0FUQkwdY8ZBv>b27XfO0Tx
zgdajgT9#rc-L9o8OE*lEu<>LB==-^^k}`PiC&fMugLjnJe<YeM)=>bIUv2=2((4N3
z;)UT28tBGA?h{K?dO$G$Xv7BwS4UCE6_gb4M=_jia4#*b?R1j>X~-<-FjePMJESgV
zfVwM2&cWdm$YDexB0}sl&viybOAa2+Iw2dc`xT+gBpeVTDehumYu<!?%t2tyly-?B
zMY<EJH+hW&DIs$`REFA12p}(do2?>AIEs8@SOEKQmw#=ka&qS*Kq%lk2T=gijgf@m
zG*-}UE4k5}IB3iQ6i2>adKQmkgqWI%CCtjDVB7#U%F!8^L`EJ<T@&-v)Dv2IyQ<Lr
zfaIqgHmP#29{Qv?0mlO-1li9k4r&d*oK|784%ri0y8?P^R0L@OZRfH)RG7np&#hxe
zEC0_N1Mgk!TlTp<TsQKmsC*i7oq9yS)8rz3BoEpspY%6BlK%@o`cb~-|3cSgDQ)3z
zAW`NTt`o*N8!K-~XFVmOCmty5s~bQ~JDvAmPo922J>7W8H|1K(pOh}IboipC^?Njh
zx~1Vd4SLziR!mN7pUO*Cxtwxh$AX)<!i}<0W@r|9xN2EQAllk#8@I7?3rsh|?viA+
z3jce++Fa49P6{}i;=%@SvtR6cpA4%Z{4x_g@z>$|X&bJN_36KN0E2tq)Qvb?_6^#z
zxCG>}<(wt&LHquy-Oq*!f+nimG=kU|U+n9V_GMt#3GNs=rGnBY#W>`M!q-bjTSTJ|
zrB-xup$w@LogW1$#$lp)qk2>GsZXQly06{}2cS*ASzW!|c$j<1ThcDHg-VfKR-mD1
z(>J;#Hn>gQ+J?rIp;|0>QSpGl<<TzBS{{&O=%J~&!ZCxu4tWqyZX;kL^txE^xccsd
zod#j{f22Ux#qA}m{2XIxJtRsgDeP$M6hZItt?kT=u#sX72Lbh#c9vRa#-IORc>O2K
z+q5Ld0$nZKGpBs^dFK-*VvFlPfhu7|5$^V=q-~Y&EY<SBJQukx`2&??f;8IcBg$*N
zdSx-7u*6QY)9~*YnHkk|mc5gc*HWTFfu2MY%4-5I6#yAyffc8fqy9sb8jmcNLB8xF
zKW7Rcah3C-5`s|Qw%WawvMYt-(`w?@Ew^m9pq3D%OLp~yh7R_CoUs7#C?(lh8xU@+
zkD}kuLV!nScm4!20Q7@<1uzJT+uCA9jR~A9z9D#Ku=t{$6{ZCNt*F9gS~YZ&i=kY&
z+s4SL4oas;-z+wAXu4;eEbTN5r7k7D>vTzJp6gQHZx95=X;n#CmrX@QLciKcNzFEi
zktCu1lAT)(Mt1<jV2p|&&^+1uO+|BNmkQKQBz=CBxE&=BNU1W>sLX^CV0|Oi{+-BA
zUZ^x|R2-gkIE9J<*=3b0zmOjaFgZ0>*GWxn?e>-`_<jQZ6wBZO62{N^f=UU$NMB%+
zVnv&`6l~$x&CJMg#g&M)_^eX`dGL5DloC7iCxz6~hWUNAoO!37zE>_Euky^RETK6^
zNW4jCJ(7s-azMs472DzUW911&mjICR#}p$5wF_MonQ`w3835sfXhi^BGBdt&;fL|e
z=)>YSy#7-2AV&q+JhM;`v)tU1D%a2c{CE5{@HhHjUtpXw#JIRH82S-YU6v}TqmaNg
zJj|xJOv(%_SFpxG%qX&vrz%kwm9KXu$1+1t*Y%kG30n>Q#l{~}Cfz&?d3b_rmsj^A
zGMSM`d!lvGEjkzqATAyVorlZiO!oyd-0UN~IqVUTbXsB+;loSk3b<8osQbIRCM}9+
zj5shou+!Tx8Nm1jAWiVDpaX%B8K#m*B30>u+Ak(xTUHPTRnAHwz&e;q2J9#~3B)O?
zDQV&SiKjh0?G&VPMT0)erlOkIQ6SOD^LYb4gFkxmvyMLS)2fNzF<X??Jt@5vBy_Y4
zCdLV$-d;(mz_8dSY1?$ICLf)t6sLV{RLb>^m}Z{?`^t-M<}8@*tIEqtu9Lp$iKJy}
zE1wW>zj^&Re+~RidVmuB7GE7yh@2TCqnsTIs4geA<OZXqtQx653(QwB7F&<YBe^k*
z$P+4v+wza9!k-8J*l(&WKFAM(602C{FAoPs2sYVOahHYbt13+zE5{G5PZ}U@3^Pi}
zb4Q(<+$3;x_F<+?{f}RN5<IrfY39b%-#beRJhgG+F7YEGM$I+hG!h+(+l?l@<rynv
z4&tvrvs}{?P`%zQ((2DU-mp?RjteSmd69EyxYd3N-IDpzQmN}3;5G=?w7RH;xm_p&
zxj_47&nsHYtgDNJzxV%$3D+mDe+;RUf!SRO9_4;0=ga1FMRRuMy`jk`Na>11s5B~9
zzcXpIYkz?1cPARHQpr&MUfLw150vb3>WQ@aGJ;V+CqfBikeQNxvX=Np7%ql}(*4)W
zEkLbxmjlHX=M~V<>P+#MMD@M^AY^fv+E@T@uyh0cIKWh7LSIlyUe<^7Wn33X0+gb1
zbya%|DYNV->EjCXx_}ku=Gm!zJ*`yJ2V*?KP-ULMD6>_+3N#tEKiq7#s@pBBb^vH3
zPvnq5(qzIb$^*XXk#o0gr9KbJKDv{HZId%qViay$eC{5B-*OkM#7}y#N<wy%2Zo9}
z|AlPix1H7e5i+}H#xCd(TS=<4Kq;4ub*$9hO@%NoDx)B$jFE8G#@W>&e1)On+2Dpz
zmI0-D+L7D82#?FV&)@$O61L*TPO!0SJ}67x`z`D4K8&ip&+T1F;nSj)3+WliimI<z
zR3!&GsV)8(UO!2TGOl?3L--FVqn?-*cW98cSP)!+k;R&o1UUInkEP4zwWvM4-lC~m
zb~e`~jE?&;_6E_Vpf~*!=3Q!+MGOW+&@GCn-G(_U{8O-k1`QU9b!iPv{$X|@qI7a3
z9nstN{|T>uP<SLo{?WaZS-rMBc`i5ZR94Y5L1h7!e6CzlqQ>#-)cz$SCw8CQO10T>
zhNAQgtVAs2<Az_9kLD~$OiTyzjH?K|I7=P1R54|s^!KI5m?Vs2z&sXQvH{Jch9~*O
ze-qw+0u+02og0>~pL?p5vLpSRFro~l;mX<rC99o+l~!ZGwpdcbCEhPDld2`r=B<*_
zD}BNajLwy(e4VFTyc9{9;Pg4(e`UjTc|DTXs2)*_1q8JcP~uxEEf4B;EwS0NeeYB$
z?;L&25IDGs5<8`tw0Dc89s(^F)2phTz}q`Z3Ux%5zhIS@pl_F~dAI=XW64pOUrnLy
z4SABo^i<GuaR}8?SUf6_;(cf)x2T*7Vq0q{{F~hhL{rc1R?3|rlt_zDD{(TgXjM~T
z;2N-DmfJN$TG{dv;|ADddEFb`ty8I|DDJTDqx22*>lDjlVmO#;pXiiLMoJZGw^;D)
zZ!g%(IHy>vWK;-k=M2SWT4&ug?hYKDm3Pj;X!HUC{wRGR!9p7mOBWr<)So5YQJ9=v
z<WF!J1gxYKajN})SxYPINB*_7Rp2AK?{2&NApGS8=CJ&BM95-n+eD@LEb`?)q$FrB
zRc&5TNa3}+bs{Hj*lhrd*k*&O;@QsQpo|bs{uD4&7p@FasEwhV*M)yte(s{zKzj!Y
z0@i$PY}H9m+!rnv0yXlEWHIc&<t8d`-$Dxv$?{|sBvw6Y_7*qH>F(+x7gcGiJ_B`s
z7hXTb71-$8hN1-rX5ih!x@JrUC+p?f)wQDrV4r1g{*EYsy-VjbhAtc4V#Lk!+}BR4
zyFw=nT^V&M-lEf69;*%0yPfSfGRdF=UByG#w^;lpfk|VZoY=F0at&R_b@jD(L=&2A
zR!Ndqphc0+)xJs0wk&q`o?5Xzj2BQ6@10!Er=rqTl6K8bS*nVyb};)mDXmm$%%-0*
zcMPz$CAKOq;R-nlK(OjgVq;nQ<|w!uh*BFSKiipppm<}(S+y-n@A{+nAHQm=F2C3h
z(JJtrTu5vh6cJnGl?RsE-A0At5r+x`HR)x19xj(Rx@ch;lXoGP=IT8{Ek9RgOTpZi
zZ2I`u6$3H?ZDA?vW@pfqa<E_v+v*fT=ZQGMoiDtGA2_d|IoV*YVDa$Q)fjVtC>0Gh
z-PIOEKpb-yKCXVH@U9qZL0ok$Ku-B|b0rT<;Xz4J37%-blz6>4Uv;6+(lCu{l4kZ*
ziTvFjUwgBwesGPuLY(2|Yde=rdpNmdmoH`0cC=TS95p#Kx=m6*L^9)&faXLplQdty
z3a@|UXA9ec&_gTY=5U=6XWqkrv?pV&SdZ`&ofpN9q>KmlKWZQjrCi#50$?Wj0S11A
zg29HXJ(Lod^z8gt!8K6Y>_W+37^yi@@OOB;8@?SI?1w9`jWBIqIKsb&1JtLY@2=C5
z$pKJ@7`t=lqh!vMsX7o(PH^J5OXvhmY13w@bQ100n^X>1k}r4k#iFu;(nnlk@~g<E
zwLsjBIw$DpEg{+cG#vST`19W@iXq!($OU@hOODTyB1#33#?#;WC8XGv;_Aiv4OKMS
zKHGiHg^DWC3d!keI<1486+~+il{w}^4vH?H|EKRiV!NJ(h?0{=Rw7Tz2C9MoLNl~J
z3M;q(#g{rC<07{4b0yW5D=Gr^1Xm0BgwG*51Q;L{?m_{dL19K-Bs>w+MOY54R~1Vg
zO0J5pS++rCp?bG=URP*X*?)Tg`F)4c7!8Z3?0G!5T@SW8=r_iEcw!kWFC30Sev+=N
zR8~yPi$s?K0xlhQBterAa1$1}+AC$>7YM?U71Jm6Lm#EjQKiUS#Y8GGC5%e>4Jefo
zBzq}o!So|KE$us?Ur^k@n6)Q?nbM+~_w0P0B0%=`;p7LtDlj-5v|%ZrR#r&S)7if%
z%C2buDJsS_Jnh)dmR+PLlw8;V%hk>?Vqp1_2#eJP@Qmqfp#_&uW9tK05yB(R&0i&Q
zvW<uIkf9edb*xS|w^Xs<%m$S7q;AUTkB9rDtC1U~tqWdOCQW0=4=u28qZscP6Ws>s
zr~@DetCspCefs<NKQ{*%Q@dXuV7s&Yhkxdh{P$KLgVgHs^0V;%V?aj%W<c}=<V;Gc
zq9|Bo|DWM+(}|pVs3LJiy(W)UFAi%%`jiZ5=|4*@GQ$x1gU^eO^CW(vy?-OGc{{>f
z%qR0HlOh}7&0_@+*4L>XuBU!dUq$;2sQgUbUpIsowMod~8#{0lmTiw2Tq*y%YnJ8E
z4&RP9yq~>|MI4v^C;z`i)@R6UMd}?(R7_DN0eg|w8OaZM+xAQ%I1$t6OrzFa8OlA5
z$nl+1h<1p2&up70eW3$2Rq0i&;Vq%>Q(V=7q^@Y}Coa{^VH!%7Ztefi*qbd$b6jVF
z_xTh~^^A>VP4WRoZOwTTna7fmkr^9e$*iccX_G|j%bAhxB%7Ni2rk%25Cj1d;9^#P
z;l1X3$Io{>3X*IFG~%!NQI#1P;ePxq-xA5Yto!L`sf)(Dv$xd@Tz;=$Z)4hEU1BaI
zL)PI2>0RYul8_~B3Kcdpn(c~8!ag!sghj)+gKuYN`0EESZchIW$8Rty*#<O8Y#G5b
zilA8epww}bw0IyI7t^J4EOF2FWcn->p&SgLH!lO{t5eGos<~L}r-{HAQiKc@%$u%g
z8308<y1!hTSIU-jJ=bKY48<cPjMNU2z;LxY-omobDP3}*53i|vbmrd5Dt{2nht9RS
zWTT$*(IcNIIfMIzfnK(9sgAX{BHUVaVQIdr=OxIc4<u7RM$VU#xzY;tB74J8Jvgaw
z0N6jcdbz_1i5vKZu-1lyMr&i32c*`s#wJQ@A0dEx;rOp%I5r?gj6iJ*Aitr-i*`cK
z<Ad5!;0)?tGDNPqCpK1lQV1ZSs8ExW^|3<{BvI^Y9L!h}jx?yBR7A<iAaX=FHXeYY
z4!UA_=+h1hU`p%hibvemI;of=M|`-3rR^uD6hS4tqG$AZ3#y1g-WZ&K(|eT{9MsR;
z>?==|DvNloia$jogscsvD~~Fi7phs!xt*jpZEEZzNyq}uFlK*lJPze~2+w=XIswO6
zvmqeYH&COZ#UXaF&fUE~6#F9>ktqW0JmEG_8y29oH~S$#=F^>lHOZ`u$@ezUUK#L4
zn9Q)X2)w5OjcN?=FQb(k4SHGiye3h7FEA9%c$)lNJlBd_%kn>xom3##P~c~9#`tEK
zL2WG)4?9#k6v6Iy1fANv*;U|)T@r@0*)ac~GckR0p|I88q?4OW9E$uZPnEN7W(Wup
ze1~ordI{(<ZDdlQlbeP`eX5yyCFag~h)|8_WKFK8V1fZ?1SVvRwZ~fpcFQ9+vPOGv
z@llrAkLR(ORq0Sxe80hALxNnR6IIAEJIx@T&xv451ppMaSZV2@sXm>y5?cRg7tjN-
z^U4TWv&zAt<8kxOn|A=-eT34=P#G5>@G~Y}<%!cJt6m|!7?5DohBmso=Q_&s1UR(K
z(j()Uvuc$shWcRgwBUef8G_&6l{f%(yJ=k^rf7*5exwcvJXO4ccmQ&iz5-HTb?B{J
zGtY|$Rn@Lh4SvuAT2~Juc!u87p5%zXV487|CzM<~3-S~PaciZ&e3V!)AK4uPrC}XU
z5TLZ;DS;eS<bh&zk_qnNpia||xNKK&hc(7no!))&^5yGS?>>F~3I@{h$4kO`YBl`&
zr_&Qy!i6drNZF>MfzwI7ZHFA()2-=zleE2RP%-b-m1@WS8MCqco6tfkl9~oQE7T#o
zN&|{>H`0nl@;vqbF70mi(7X3-T6Wm9JfN@(M&7wEgAK7;p5xFkmbb`!AO-Ku?3C}`
z!7LmOia`bE-}0R0;cZq*f&G99n=1bUA;3#QLbZU*KSFyOu2E>MSPcUk(amZ1)hHjW
zxolMWQfC3gqcn18X$aC3M9HW&NUOscd5e*Wy1MS#lULu}ZU;IJ{Xl0<Y=PDcmli}5
zK;9J=C1=g%zL@i<x&vuq=*`1wYzP>T8Wfq~L*2N7*CJJxJcWLMEe2V2Yn!tMxix!~
z)dw`cLI0Ftzi?H;*IT`Nf2S6{FA21`!l5G@&7kL<?B`CBy&D$<l@S5`j(U)?73pK2
z>-D*YsY&aDPFN7Xx6uO;>fD`Fy*g!-o4m`PoMj>ECRJOU`cjVB{6f|f#Mz7hScc`y
z_nuX|j%%umz|x<YdDKs?w9b}533T2@VE$s=2$f9-J1kwIe0U%oF~T(L<z8W)!lXoM
zV2R;U)m!)GQ#iYPpysI`pPr8$h*j;qQ-{V*)U!NVQZ}?(?2Ty&+^xGa&&aW0CVN)u
zmV<Bpukeys=Kp*6KThf`8%x`_vL+p*vA}2St~8yc&Jz#G18zV*a7ta&nY2>0i(0_k
zxKQfqwCs>&DK<7@It=DIAJ>~LspY*=`1QNIs1}=`!w|~%?T=qSPX%{4ev_W2<6U$T
zM!ko##2f3D4IsdeTzIk)pkbbV_gtpoD_SuUuc4e@m`H5aS(UTp#<OGvIn9TeIvrub
zr5F$orxdXolu*pk^`_;2JCvP!^UAs@WV;)lLJv0A*htL8!&LQmobIBy=}hf9O$kZ2
zmXu%Ho{qM*j^gX@5W7kek|UWUXy93Ir`drn;BKn4Z<)Q~0p)-BBM|)`oYW&vj__9J
z8AF1cLU7EM&kC@5O#;cJY8!yenv3kw&gCZi0-~SRFMooJtgQ{nAywpFza1j8g#u7=
z1jLfsRNbEO#)F!hUfj_HxVC>I1SeZn&tr3cLOP5=+y-PV_Jjv@_<zs#^pG$hE6zw?
zY_SMe1qn~>3hIl>5S{jsTXaG?PR5*$PYe~cWU~B}1{XH)sKP_4J+<wEDCs41$pk?1
zYp+G|8*_IU<b6#{n0&!M?cPfugkwRWtbo{+Be4ha8h3Pj=(8AZqs99Ujc@k|T8tUE
z$-)9)*Mg1HiY}0*EV-RmH~E6PsIjBaZ>?rd`J-Ev$-*GVq@K$>I)Yoab;i-;sa^gM
zSxZT0EO6MfIz7^4Rl>4cv<Fvw?<r(aqYH}@+j4gd?5Zq&x9lhcGGEfR{06Q?rl-O~
z?B1%yPw)JXzEpjP!MD_HM-!o8Cl$>~DM~f}YgeAM6Uh{*??ze0J@?YCV|Z>EN~F-0
zl+5!V42djo4xu?gScf`LsvA48d7iqxgB-<DN%TP(o$8W6&2&|Vw_}-%ZKe8C4>qN~
zhQh7wU7}Rs+r;K)iK;inCQL??LD#`biKo=1mHk=D@&ogU3UZwzh8p#uHF(dDUp};a
z2zD=QC`nLyvgJ@G&5cK!ElGBCM$(qFiP0CQXY4hjEMT*7r%_S@RF!A%({oTTf<;Pr
zqa1|j$A?uadH4L;`mDdbY_8i41TOnSY6*utNCL8hi#o3XB!F;sJ2pBzRlZ#brfCv^
zlRx1L)bCWAsgs-;#SC!RGz=x@EnH7`pPE1b$?h<c?#_w%F;LvroM_2I%qU6u>;A3p
z7Wzkv;}iSwd_EXURfZ^uc))~bnT@mofmXP`Akb-t9CD**R>*l+)R)}qggT^E@}n9z
zr#Fvt0_=1yPd=xvF{4+rom3-9d6?KYWm0NzbImyHWXTRb=3kPkyrtDp*!WTwxGKm4
zpRxD_6c`b?x8nPp6A|db*3aT<aqPY}BsIZ#!elQEx%Vp~_fjSU3rrwYu5zQvhXVp>
z0je%g+5oTbzFT%ZuV1@{&L7gp!V;0ARnE}eG(57`Wf{TD<uJ*>*S{nRI}t%Hn<tWz
z$Pz1CJBv}_zL4pX9J{dSU)3v`5%qB<d2q*cilT3y8iJs+3z1Mu7)VVzE$!}&k`CrW
zR@SPy7)s{WyJ&lSR%aI;rhrXw!AeyopTKZZka#QGlj}7MND!?|Q>JlrFpugkN&MPe
zb{`ARm8dkJGmap$CA8-CE7)>MxV35@S&-@oLGUEd)uaohwe$cqjj0qLIah~kN~bRO
zZjmxxtW@vRMY2m#@R?<mPa!YL42KUFkS7r>dPrJPufiw^9pUC!D(+txOU;+`Ylu54
zHI+x*4X{mh799D+Fw&NnDj0?kqi)RSrg0%#XB+w!NGPAa!<vG?T{(FPH^V$w@)k^7
zBxqoSh9a3u^&>JD{|vf;jVq9^E3Dn~fvlsE#-|itigy2?6X-C4&gmzJG?kBSle4K4
zG!Z%P?V8>bBncNpIV+UuXfb7Z%A{uW>BY9({OMtl`9>4?i}3Q3(>~bvX;SD)EkW?E
z1kv>NOq^W9Rbp3&(+26+l6qeU$v~jeB*W?03v1-ew)-<|x^y|0lJk9mfnLYmh}8qB
z?NfuHqaWWWfI=K?M0G|VgP<FALvTM(9l5QiT}4>!T&yZ|NC{3eq<-%6v%v=gI;e>}
zLL*sz)T&TYkQ*zy_N};ZL({l&h8_q`+<}aW#AC8dPUTNz`_fISl>-CvL)M`U&!@#%
zc1t*$Dqrf*xRW4eUT4n+H&+erYG;Jqp!`YRm(F-NIg-7!p`to1nu%Igs`zTUaHBT~
zTFDAZHfbhxSeRkA5GvCq8mmwYOe2*UtM)AK;g_q`=MJ^6*<0bWd}_0s7#H<n(V2xe
z@L^6j>)ctR-|etQe;r;vJjj;H(ev)p*H109s|CA@AncNf$l9%mT_1vR=%8Ue9i~4^
zoswdrV<aIjK;8iH$cf>VYS>9ir}9v+ccVHx1_~H(0wV5Jl%ler)eCof6Vt*psvogH
z*r5;2z-J)2pbcu^QlG9E^S=$!vSHZ_G5~B!@P#LjsqD6JFhPNMMNKvMv+R6pe3gMU
zk@5qR?T;i%x6>Uh|Kg;`D4sA~-Ke-TIS2|UwaA!C0Cj7y$KR*y-d23}WG=Ca;?`VX
zyJ%ZfHI;w$midh%+~Ad9dd+g{RYKV3J8_ZRHCrq#7%qU)gm#9!x)k3P*xmu2wkNm?
zW<Re6{wNcbCLB?Xo?wJGVo__mjUFcoIqsl7l+{57*M>pEa#1%0A|F7fvQOLDQFPf3
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%0D+{l&4Elf+RUJ>DPlT<0vI!uxp-LitG
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%0DQu49$GwTP{0?>4l_B{}_v8!N|W%zC&9>
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%0Dk}39ByCzIU5yLcM+o6FDFaENYBu
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%0DL<K?1>h
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

literal 0
HcmV?d00001

diff --git a/mmsegmentation/mmseg/utils/class_names.py b/mmsegmentation/mmseg/utils/class_names.py
new file mode 100644
index 0000000..cd4392b
--- /dev/null
+++ b/mmsegmentation/mmseg/utils/class_names.py
@@ -0,0 +1,570 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.utils import is_str
+
+def xray_classes():
+    return [
+        'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
+        'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
+        'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
+        'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
+        'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
+        'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
+    ]
+
+
+def xray_palette():
+    return [
+            (220, 20, 60), (119, 11, 32), (0, 0, 142), (0, 0, 230), (106, 0, 228),
+            (0, 60, 100), (0, 80, 100), (0, 0, 70), (0, 0, 192), (250, 170, 30),
+            (100, 170, 30), (220, 220, 0), (175, 116, 175), (250, 0, 30), (165, 42, 42),
+            (255, 77, 255), (0, 226, 252), (182, 182, 255), (0, 82, 0), (120, 166, 157),
+            (110, 76, 0), (174, 57, 255), (199, 100, 0), (72, 0, 118), (255, 179, 240),
+            (0, 125, 92), (209, 0, 151), (188, 208, 182), (0, 220, 176),
+        ]
+
+
+def cityscapes_classes():
+    """Cityscapes class names for external use."""
+    return [
+        'road', 'sidewalk', 'building', 'wall', 'fence', 'pole',
+        'traffic light', 'traffic sign', 'vegetation', 'terrain', 'sky',
+        'person', 'rider', 'car', 'truck', 'bus', 'train', 'motorcycle',
+        'bicycle'
+    ]
+
+
+def ade_classes():
+    """ADE20K class names for external use."""
+    return [
+        'wall', 'building', 'sky', 'floor', 'tree', 'ceiling', 'road', 'bed ',
+        'windowpane', 'grass', 'cabinet', 'sidewalk', 'person', 'earth',
+        'door', 'table', 'mountain', 'plant', 'curtain', 'chair', 'car',
+        'water', 'painting', 'sofa', 'shelf', 'house', 'sea', 'mirror', 'rug',
+        'field', 'armchair', 'seat', 'fence', 'desk', 'rock', 'wardrobe',
+        'lamp', 'bathtub', 'railing', 'cushion', 'base', 'box', 'column',
+        'signboard', 'chest of drawers', 'counter', 'sand', 'sink',
+        'skyscraper', 'fireplace', 'refrigerator', 'grandstand', 'path',
+        'stairs', 'runway', 'case', 'pool table', 'pillow', 'screen door',
+        'stairway', 'river', 'bridge', 'bookcase', 'blind', 'coffee table',
+        'toilet', 'flower', 'book', 'hill', 'bench', 'countertop', 'stove',
+        'palm', 'kitchen island', 'computer', 'swivel chair', 'boat', 'bar',
+        'arcade machine', 'hovel', 'bus', 'towel', 'light', 'truck', 'tower',
+        'chandelier', 'awning', 'streetlight', 'booth', 'television receiver',
+        'airplane', 'dirt track', 'apparel', 'pole', 'land', 'bannister',
+        'escalator', 'ottoman', 'bottle', 'buffet', 'poster', 'stage', 'van',
+        'ship', 'fountain', 'conveyer belt', 'canopy', 'washer', 'plaything',
+        'swimming pool', 'stool', 'barrel', 'basket', 'waterfall', 'tent',
+        'bag', 'minibike', 'cradle', 'oven', 'ball', 'food', 'step', 'tank',
+        'trade name', 'microwave', 'pot', 'animal', 'bicycle', 'lake',
+        'dishwasher', 'screen', 'blanket', 'sculpture', 'hood', 'sconce',
+        'vase', 'traffic light', 'tray', 'ashcan', 'fan', 'pier', 'crt screen',
+        'plate', 'monitor', 'bulletin board', 'shower', 'radiator', 'glass',
+        'clock', 'flag'
+    ]
+
+
+def voc_classes():
+    """Pascal VOC class names for external use."""
+    return [
+        'background', 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus',
+        'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse',
+        'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train',
+        'tvmonitor'
+    ]
+
+
+def pcontext_classes():
+    """Pascal Context class names for external use."""
+    return [
+        'aeroplane', 'bag', 'bed', 'bedclothes', 'bench', 'bicycle', 'bird',
+        'boat', 'book', 'bottle', 'building', 'bus', 'cabinet', 'car', 'cat',
+        'ceiling', 'chair', 'cloth', 'computer', 'cow', 'cup', 'curtain',
+        'dog', 'door', 'fence', 'floor', 'flower', 'food', 'grass', 'ground',
+        'horse', 'keyboard', 'light', 'motorbike', 'mountain', 'mouse',
+        'person', 'plate', 'platform', 'pottedplant', 'road', 'rock', 'sheep',
+        'shelves', 'sidewalk', 'sign', 'sky', 'snow', 'sofa', 'table', 'track',
+        'train', 'tree', 'truck', 'tvmonitor', 'wall', 'water', 'window',
+        'wood'
+    ]
+
+
+def cocostuff_classes():
+    """CocoStuff class names for external use."""
+    return [
+        'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train',
+        'truck', 'boat', 'traffic light', 'fire hydrant', 'stop sign',
+        'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep',
+        'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella',
+        'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard',
+        'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard',
+        'surfboard', 'tennis racket', 'bottle', 'wine glass', 'cup', 'fork',
+        'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich', 'orange',
+        'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair',
+        'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv',
+        'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',
+        'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',
+        'scissors', 'teddy bear', 'hair drier', 'toothbrush', 'banner',
+        'blanket', 'branch', 'bridge', 'building-other', 'bush', 'cabinet',
+        'cage', 'cardboard', 'carpet', 'ceiling-other', 'ceiling-tile',
+        'cloth', 'clothes', 'clouds', 'counter', 'cupboard', 'curtain',
+        'desk-stuff', 'dirt', 'door-stuff', 'fence', 'floor-marble',
+        'floor-other', 'floor-stone', 'floor-tile', 'floor-wood', 'flower',
+        'fog', 'food-other', 'fruit', 'furniture-other', 'grass', 'gravel',
+        'ground-other', 'hill', 'house', 'leaves', 'light', 'mat', 'metal',
+        'mirror-stuff', 'moss', 'mountain', 'mud', 'napkin', 'net', 'paper',
+        'pavement', 'pillow', 'plant-other', 'plastic', 'platform',
+        'playingfield', 'railing', 'railroad', 'river', 'road', 'rock', 'roof',
+        'rug', 'salad', 'sand', 'sea', 'shelf', 'sky-other', 'skyscraper',
+        'snow', 'solid-other', 'stairs', 'stone', 'straw', 'structural-other',
+        'table', 'tent', 'textile-other', 'towel', 'tree', 'vegetable',
+        'wall-brick', 'wall-concrete', 'wall-other', 'wall-panel',
+        'wall-stone', 'wall-tile', 'wall-wood', 'water-other', 'waterdrops',
+        'window-blind', 'window-other', 'wood'
+    ]
+
+
+def loveda_classes():
+    """LoveDA class names for external use."""
+    return [
+        'background', 'building', 'road', 'water', 'barren', 'forest',
+        'agricultural'
+    ]
+
+
+def potsdam_classes():
+    """Potsdam class names for external use."""
+    return [
+        'impervious_surface', 'building', 'low_vegetation', 'tree', 'car',
+        'clutter'
+    ]
+
+
+def vaihingen_classes():
+    """Vaihingen class names for external use."""
+    return [
+        'impervious_surface', 'building', 'low_vegetation', 'tree', 'car',
+        'clutter'
+    ]
+
+
+def isaid_classes():
+    """iSAID class names for external use."""
+    return [
+        'background', 'ship', 'store_tank', 'baseball_diamond', 'tennis_court',
+        'basketball_court', 'Ground_Track_Field', 'Bridge', 'Large_Vehicle',
+        'Small_Vehicle', 'Helicopter', 'Swimming_pool', 'Roundabout',
+        'Soccer_ball_field', 'plane', 'Harbor'
+    ]
+
+
+def stare_classes():
+    """stare class names for external use."""
+    return ['background', 'vessel']
+
+
+def mapillary_v1_classes():
+    """mapillary_v1 class names for external use."""
+    return [
+        'Bird', 'Ground Animal', 'Curb', 'Fence', 'Guard Rail', 'Barrier',
+        'Wall', 'Bike Lane', 'Crosswalk - Plain', 'Curb Cut', 'Parking',
+        'Pedestrian Area', 'Rail Track', 'Road', 'Service Lane', 'Sidewalk',
+        'Bridge', 'Building', 'Tunnel', 'Person', 'Bicyclist', 'Motorcyclist',
+        'Other Rider', 'Lane Marking - Crosswalk', 'Lane Marking - General',
+        'Mountain', 'Sand', 'Sky', 'Snow', 'Terrain', 'Vegetation', 'Water',
+        'Banner', 'Bench', 'Bike Rack', 'Billboard', 'Catch Basin',
+        'CCTV Camera', 'Fire Hydrant', 'Junction Box', 'Mailbox', 'Manhole',
+        'Phone Booth', 'Pothole', 'Street Light', 'Pole', 'Traffic Sign Frame',
+        'Utility Pole', 'Traffic Light', 'Traffic Sign (Back)',
+        'Traffic Sign (Front)', 'Trash Can', 'Bicycle', 'Boat', 'Bus', 'Car',
+        'Caravan', 'Motorcycle', 'On Rails', 'Other Vehicle', 'Trailer',
+        'Truck', 'Wheeled Slow', 'Car Mount', 'Ego Vehicle', 'Unlabeled'
+    ]
+
+
+def mapillary_v1_palette():
+    """mapillary_v1_ palette for external use."""
+    return [[165, 42, 42], [0, 192, 0], [196, 196, 196], [190, 153, 153],
+            [180, 165, 180], [90, 120, 150], [102, 102, 156], [128, 64, 255],
+            [140, 140, 200], [170, 170, 170], [250, 170, 160], [96, 96, 96],
+            [230, 150, 140], [128, 64, 128], [110, 110, 110], [244, 35, 232],
+            [150, 100, 100], [70, 70, 70], [150, 120, 90], [220, 20, 60],
+            [255, 0, 0], [255, 0, 100], [255, 0, 200], [200, 128, 128],
+            [255, 255, 255], [64, 170, 64], [230, 160, 50], [70, 130, 180],
+            [190, 255, 255], [152, 251, 152], [107, 142, 35], [0, 170, 30],
+            [255, 255, 128], [250, 0, 30], [100, 140, 180], [220, 220, 220],
+            [220, 128, 128], [222, 40, 40], [100, 170, 30], [40, 40, 40],
+            [33, 33, 33], [100, 128, 160], [142, 0, 0], [70, 100, 150],
+            [210, 170, 100], [153, 153, 153], [128, 128, 128], [0, 0, 80],
+            [250, 170, 30], [192, 192, 192], [220, 220, 0], [140, 140, 20],
+            [119, 11, 32], [150, 0, 255], [0, 60, 100], [0, 0, 142],
+            [0, 0, 90], [0, 0, 230], [0, 80, 100], [128, 64, 64], [0, 0, 110],
+            [0, 0, 70], [0, 0, 192], [32, 32, 32], [120, 10, 10], [0, 0, 0]]
+
+
+def mapillary_v2_classes():
+    """mapillary_v2 class names for external use."""
+    return [
+        'Bird', 'Ground Animal', 'Ambiguous Barrier', 'Concrete Block', 'Curb',
+        'Fence', 'Guard Rail', 'Barrier', 'Road Median', 'Road Side',
+        'Lane Separator', 'Temporary Barrier', 'Wall', 'Bike Lane',
+        'Crosswalk - Plain', 'Curb Cut', 'Driveway', 'Parking',
+        'Parking Aisle', 'Pedestrian Area', 'Rail Track', 'Road',
+        'Road Shoulder', 'Service Lane', 'Sidewalk', 'Traffic Island',
+        'Bridge', 'Building', 'Garage', 'Tunnel', 'Person', 'Person Group',
+        'Bicyclist', 'Motorcyclist', 'Other Rider',
+        'Lane Marking - Dashed Line', 'Lane Marking - Straight Line',
+        'Lane Marking - Zigzag Line', 'Lane Marking - Ambiguous',
+        'Lane Marking - Arrow (Left)', 'Lane Marking - Arrow (Other)',
+        'Lane Marking - Arrow (Right)',
+        'Lane Marking - Arrow (Split Left or Straight)',
+        'Lane Marking - Arrow (Split Right or Straight)',
+        'Lane Marking - Arrow (Straight)', 'Lane Marking - Crosswalk',
+        'Lane Marking - Give Way (Row)', 'Lane Marking - Give Way (Single)',
+        'Lane Marking - Hatched (Chevron)',
+        'Lane Marking - Hatched (Diagonal)', 'Lane Marking - Other',
+        'Lane Marking - Stop Line', 'Lane Marking - Symbol (Bicycle)',
+        'Lane Marking - Symbol (Other)', 'Lane Marking - Text',
+        'Lane Marking (only) - Dashed Line', 'Lane Marking (only) - Crosswalk',
+        'Lane Marking (only) - Other', 'Lane Marking (only) - Test',
+        'Mountain', 'Sand', 'Sky', 'Snow', 'Terrain', 'Vegetation', 'Water',
+        'Banner', 'Bench', 'Bike Rack', 'Catch Basin', 'CCTV Camera',
+        'Fire Hydrant', 'Junction Box', 'Mailbox', 'Manhole', 'Parking Meter',
+        'Phone Booth', 'Pothole', 'Signage - Advertisement',
+        'Signage - Ambiguous', 'Signage - Back', 'Signage - Information',
+        'Signage - Other', 'Signage - Store', 'Street Light', 'Pole',
+        'Pole Group', 'Traffic Sign Frame', 'Utility Pole', 'Traffic Cone',
+        'Traffic Light - General (Single)', 'Traffic Light - Pedestrians',
+        'Traffic Light - General (Upright)',
+        'Traffic Light - General (Horizontal)', 'Traffic Light - Cyclists',
+        'Traffic Light - Other', 'Traffic Sign - Ambiguous',
+        'Traffic Sign (Back)', 'Traffic Sign - Direction (Back)',
+        'Traffic Sign - Direction (Front)', 'Traffic Sign (Front)',
+        'Traffic Sign - Parking', 'Traffic Sign - Temporary (Back)',
+        'Traffic Sign - Temporary (Front)', 'Trash Can', 'Bicycle', 'Boat',
+        'Bus', 'Car', 'Caravan', 'Motorcycle', 'On Rails', 'Other Vehicle',
+        'Trailer', 'Truck', 'Vehicle Group', 'Wheeled Slow', 'Water Valve',
+        'Car Mount', 'Dynamic', 'Ego Vehicle', 'Ground', 'Static', 'Unlabeled'
+    ]
+
+
+def mapillary_v2_palette():
+    """mapillary_v2_ palette for external use."""
+    return [[165, 42, 42], [0, 192, 0], [250, 170, 31], [250, 170, 32],
+            [196, 196, 196], [190, 153, 153], [180, 165, 180], [90, 120, 150],
+            [250, 170, 33], [250, 170, 34], [128, 128, 128], [250, 170, 35],
+            [102, 102, 156], [128, 64, 255], [140, 140, 200], [170, 170, 170],
+            [250, 170, 36], [250, 170, 160], [250, 170, 37], [96, 96, 96],
+            [230, 150, 140], [128, 64, 128], [110, 110, 110], [110, 110, 110],
+            [244, 35, 232], [128, 196, 128], [150, 100, 100], [70, 70, 70],
+            [150, 150, 150], [150, 120, 90], [220, 20, 60], [220, 20, 60],
+            [255, 0, 0], [255, 0, 100], [255, 0, 200], [255, 255, 255],
+            [255, 255, 255], [250, 170, 29], [250, 170, 28], [250, 170, 26],
+            [250, 170, 25], [250, 170, 24], [250, 170, 22], [250, 170, 21],
+            [250, 170, 20], [255, 255, 255], [250, 170, 19], [250, 170, 18],
+            [250, 170, 12], [250, 170, 11], [255, 255, 255], [255, 255, 255],
+            [250, 170, 16], [250, 170, 15], [250, 170, 15], [255, 255, 255],
+            [255, 255, 255], [255, 255, 255], [255, 255, 255], [64, 170, 64],
+            [230, 160, 50], [70, 130, 180], [190, 255, 255], [152, 251, 152],
+            [107, 142, 35], [0, 170, 30], [255, 255, 128], [250, 0, 30],
+            [100, 140, 180], [220, 128, 128], [222, 40, 40], [100, 170, 30],
+            [40, 40, 40], [33, 33, 33], [100, 128, 160], [20, 20, 255],
+            [142, 0, 0], [70, 100, 150], [250, 171, 30], [250, 172, 30],
+            [250, 173, 30], [250, 174, 30], [250, 175, 30], [250, 176, 30],
+            [210, 170, 100], [153, 153, 153], [153, 153, 153], [128, 128, 128],
+            [0, 0, 80], [210, 60, 60], [250, 170, 30], [250, 170, 30],
+            [250, 170, 30], [250, 170, 30], [250, 170, 30], [250, 170, 30],
+            [192, 192, 192], [192, 192, 192], [192, 192, 192], [220, 220, 0],
+            [220, 220, 0], [0, 0, 196], [192, 192, 192], [220, 220, 0],
+            [140, 140, 20], [119, 11, 32], [150, 0, 255], [0, 60, 100],
+            [0, 0, 142], [0, 0, 90], [0, 0, 230], [0, 80, 100], [128, 64, 64],
+            [0, 0, 110], [0, 0, 70], [0, 0, 142], [0, 0, 192], [170, 170, 170],
+            [32, 32, 32], [111, 74, 0], [120, 10, 10], [81, 0, 81],
+            [111, 111, 0], [0, 0, 0]]
+
+
+def cityscapes_palette():
+    """Cityscapes palette for external use."""
+    return [[128, 64, 128], [244, 35, 232], [70, 70, 70], [102, 102, 156],
+            [190, 153, 153], [153, 153, 153], [250, 170, 30], [220, 220, 0],
+            [107, 142, 35], [152, 251, 152], [70, 130, 180], [220, 20, 60],
+            [255, 0, 0], [0, 0, 142], [0, 0, 70], [0, 60, 100], [0, 80, 100],
+            [0, 0, 230], [119, 11, 32]]
+
+
+def ade_palette():
+    """ADE20K palette for external use."""
+    return [[120, 120, 120], [180, 120, 120], [6, 230, 230], [80, 50, 50],
+            [4, 200, 3], [120, 120, 80], [140, 140, 140], [204, 5, 255],
+            [230, 230, 230], [4, 250, 7], [224, 5, 255], [235, 255, 7],
+            [150, 5, 61], [120, 120, 70], [8, 255, 51], [255, 6, 82],
+            [143, 255, 140], [204, 255, 4], [255, 51, 7], [204, 70, 3],
+            [0, 102, 200], [61, 230, 250], [255, 6, 51], [11, 102, 255],
+            [255, 7, 71], [255, 9, 224], [9, 7, 230], [220, 220, 220],
+            [255, 9, 92], [112, 9, 255], [8, 255, 214], [7, 255, 224],
+            [255, 184, 6], [10, 255, 71], [255, 41, 10], [7, 255, 255],
+            [224, 255, 8], [102, 8, 255], [255, 61, 6], [255, 194, 7],
+            [255, 122, 8], [0, 255, 20], [255, 8, 41], [255, 5, 153],
+            [6, 51, 255], [235, 12, 255], [160, 150, 20], [0, 163, 255],
+            [140, 140, 140], [250, 10, 15], [20, 255, 0], [31, 255, 0],
+            [255, 31, 0], [255, 224, 0], [153, 255, 0], [0, 0, 255],
+            [255, 71, 0], [0, 235, 255], [0, 173, 255], [31, 0, 255],
+            [11, 200, 200], [255, 82, 0], [0, 255, 245], [0, 61, 255],
+            [0, 255, 112], [0, 255, 133], [255, 0, 0], [255, 163, 0],
+            [255, 102, 0], [194, 255, 0], [0, 143, 255], [51, 255, 0],
+            [0, 82, 255], [0, 255, 41], [0, 255, 173], [10, 0, 255],
+            [173, 255, 0], [0, 255, 153], [255, 92, 0], [255, 0, 255],
+            [255, 0, 245], [255, 0, 102], [255, 173, 0], [255, 0, 20],
+            [255, 184, 184], [0, 31, 255], [0, 255, 61], [0, 71, 255],
+            [255, 0, 204], [0, 255, 194], [0, 255, 82], [0, 10, 255],
+            [0, 112, 255], [51, 0, 255], [0, 194, 255], [0, 122, 255],
+            [0, 255, 163], [255, 153, 0], [0, 255, 10], [255, 112, 0],
+            [143, 255, 0], [82, 0, 255], [163, 255, 0], [255, 235, 0],
+            [8, 184, 170], [133, 0, 255], [0, 255, 92], [184, 0, 255],
+            [255, 0, 31], [0, 184, 255], [0, 214, 255], [255, 0, 112],
+            [92, 255, 0], [0, 224, 255], [112, 224, 255], [70, 184, 160],
+            [163, 0, 255], [153, 0, 255], [71, 255, 0], [255, 0, 163],
+            [255, 204, 0], [255, 0, 143], [0, 255, 235], [133, 255, 0],
+            [255, 0, 235], [245, 0, 255], [255, 0, 122], [255, 245, 0],
+            [10, 190, 212], [214, 255, 0], [0, 204, 255], [20, 0, 255],
+            [255, 255, 0], [0, 153, 255], [0, 41, 255], [0, 255, 204],
+            [41, 0, 255], [41, 255, 0], [173, 0, 255], [0, 245, 255],
+            [71, 0, 255], [122, 0, 255], [0, 255, 184], [0, 92, 255],
+            [184, 255, 0], [0, 133, 255], [255, 214, 0], [25, 194, 194],
+            [102, 255, 0], [92, 0, 255]]
+
+
+def voc_palette():
+    """Pascal VOC palette for external use."""
+    return [[0, 0, 0], [128, 0, 0], [0, 128, 0], [128, 128, 0], [0, 0, 128],
+            [128, 0, 128], [0, 128, 128], [128, 128, 128], [64, 0, 0],
+            [192, 0, 0], [64, 128, 0], [192, 128, 0], [64, 0, 128],
+            [192, 0, 128], [64, 128, 128], [192, 128, 128], [0, 64, 0],
+            [128, 64, 0], [0, 192, 0], [128, 192, 0], [0, 64, 128]]
+
+
+def pcontext_palette():
+    """Pascal Context palette for external use."""
+    return [[180, 120, 120], [6, 230, 230], [80, 50, 50], [4, 200, 3],
+            [120, 120, 80], [140, 140, 140], [204, 5, 255], [230, 230, 230],
+            [4, 250, 7], [224, 5, 255], [235, 255, 7], [150, 5, 61],
+            [120, 120, 70], [8, 255, 51], [255, 6, 82], [143, 255, 140],
+            [204, 255, 4], [255, 51, 7], [204, 70, 3], [0, 102, 200],
+            [61, 230, 250], [255, 6, 51], [11, 102, 255], [255, 7, 71],
+            [255, 9, 224], [9, 7, 230], [220, 220, 220], [255, 9, 92],
+            [112, 9, 255], [8, 255, 214], [7, 255, 224], [255, 184, 6],
+            [10, 255, 71], [255, 41, 10], [7, 255, 255], [224, 255, 8],
+            [102, 8, 255], [255, 61, 6], [255, 194, 7], [255, 122, 8],
+            [0, 255, 20], [255, 8, 41], [255, 5, 153], [6, 51, 255],
+            [235, 12, 255], [160, 150, 20], [0, 163, 255], [140, 140, 140],
+            [250, 10, 15], [20, 255, 0], [31, 255, 0], [255, 31, 0],
+            [255, 224, 0], [153, 255, 0], [0, 0, 255], [255, 71, 0],
+            [0, 235, 255], [0, 173, 255], [31, 0, 255]]
+
+
+def cocostuff_palette():
+    """CocoStuff palette for external use."""
+    return [[0, 192, 64], [0, 192, 64], [0, 64, 96], [128, 192, 192],
+            [0, 64, 64], [0, 192, 224], [0, 192, 192], [128, 192, 64],
+            [0, 192, 96], [128, 192, 64], [128, 32, 192], [0, 0, 224],
+            [0, 0, 64], [0, 160, 192], [128, 0, 96], [128, 0, 192],
+            [0, 32, 192], [128, 128, 224], [0, 0, 192], [128, 160, 192],
+            [128, 128, 0], [128, 0, 32], [128, 32, 0], [128, 0, 128],
+            [64, 128, 32], [0, 160, 0], [0, 0, 0], [192, 128, 160], [0, 32, 0],
+            [0, 128, 128], [64, 128, 160], [128, 160, 0], [0, 128, 0],
+            [192, 128, 32], [128, 96, 128], [0, 0, 128], [64, 0, 32],
+            [0, 224, 128], [128, 0, 0], [192, 0, 160], [0, 96, 128],
+            [128, 128, 128], [64, 0, 160], [128, 224, 128], [128, 128, 64],
+            [192, 0, 32], [128, 96, 0], [128, 0, 192], [0, 128, 32],
+            [64, 224, 0], [0, 0, 64], [128, 128, 160], [64, 96, 0],
+            [0, 128, 192], [0, 128, 160], [192, 224, 0], [0, 128, 64],
+            [128, 128, 32], [192, 32, 128], [0, 64, 192], [0, 0, 32],
+            [64, 160, 128], [128, 64, 64], [128, 0, 160], [64, 32, 128],
+            [128, 192, 192], [0, 0, 160], [192, 160, 128], [128, 192, 0],
+            [128, 0, 96], [192, 32, 0], [128, 64, 128], [64, 128, 96],
+            [64, 160, 0], [0, 64, 0], [192, 128, 224], [64, 32, 0],
+            [0, 192, 128], [64, 128, 224], [192, 160, 0], [0, 192, 0],
+            [192, 128, 96], [192, 96, 128], [0, 64, 128], [64, 0, 96],
+            [64, 224, 128], [128, 64, 0], [192, 0, 224], [64, 96, 128],
+            [128, 192, 128], [64, 0, 224], [192, 224, 128], [128, 192, 64],
+            [192, 0, 96], [192, 96, 0], [128, 64, 192], [0, 128, 96],
+            [0, 224, 0], [64, 64, 64], [128, 128, 224], [0, 96, 0],
+            [64, 192, 192], [0, 128, 224], [128, 224, 0], [64, 192, 64],
+            [128, 128, 96], [128, 32, 128], [64, 0, 192], [0, 64, 96],
+            [0, 160, 128], [192, 0, 64], [128, 64, 224], [0, 32, 128],
+            [192, 128, 192], [0, 64, 224], [128, 160, 128], [192, 128, 0],
+            [128, 64, 32], [128, 32, 64], [192, 0, 128], [64, 192, 32],
+            [0, 160, 64], [64, 0, 0], [192, 192, 160], [0, 32, 64],
+            [64, 128, 128], [64, 192, 160], [128, 160, 64], [64, 128, 0],
+            [192, 192, 32], [128, 96, 192], [64, 0, 128], [64, 64, 32],
+            [0, 224, 192], [192, 0, 0], [192, 64, 160], [0, 96, 192],
+            [192, 128, 128], [64, 64, 160], [128, 224, 192], [192, 128, 64],
+            [192, 64, 32], [128, 96, 64], [192, 0, 192], [0, 192, 32],
+            [64, 224, 64], [64, 0, 64], [128, 192, 160], [64, 96, 64],
+            [64, 128, 192], [0, 192, 160], [192, 224, 64], [64, 128, 64],
+            [128, 192, 32], [192, 32, 192], [64, 64, 192], [0, 64, 32],
+            [64, 160, 192], [192, 64, 64], [128, 64, 160], [64, 32, 192],
+            [192, 192, 192], [0, 64, 160], [192, 160, 192], [192, 192, 0],
+            [128, 64, 96], [192, 32, 64], [192, 64, 128], [64, 192, 96],
+            [64, 160, 64], [64, 64, 0]]
+
+
+def loveda_palette():
+    """LoveDA palette for external use."""
+    return [[255, 255, 255], [255, 0, 0], [255, 255, 0], [0, 0, 255],
+            [159, 129, 183], [0, 255, 0], [255, 195, 128]]
+
+
+def potsdam_palette():
+    """Potsdam palette for external use."""
+    return [[255, 255, 255], [0, 0, 255], [0, 255, 255], [0, 255, 0],
+            [255, 255, 0], [255, 0, 0]]
+
+
+def vaihingen_palette():
+    """Vaihingen palette for external use."""
+    return [[255, 255, 255], [0, 0, 255], [0, 255, 255], [0, 255, 0],
+            [255, 255, 0], [255, 0, 0]]
+
+
+def isaid_palette():
+    """iSAID palette for external use."""
+    return [[0, 0, 0], [0, 0, 63], [0, 63, 63], [0, 63, 0], [0, 63, 127],
+            [0, 63, 191], [0, 63, 255], [0, 127, 63], [0, 127,
+                                                       127], [0, 0, 127],
+            [0, 0, 191], [0, 0, 255], [0, 191, 127], [0, 127, 191],
+            [0, 127, 255], [0, 100, 155]]
+
+
+def stare_palette():
+    """STARE palette for external use."""
+    return [[120, 120, 120], [6, 230, 230]]
+
+
+def synapse_palette():
+    """Synapse palette for external use."""
+    return [[0, 0, 0], [0, 0, 255], [0, 255, 0], [255, 0, 0], [0, 255, 255],
+            [255, 0, 255], [255, 255, 0], [60, 255, 255], [240, 240, 240]]
+
+
+def synapse_classes():
+    """Synapse class names for external use."""
+    return [
+        'background', 'aorta', 'gallbladder', 'left_kidney', 'right_kidney',
+        'liver', 'pancreas', 'spleen', 'stomach'
+    ]
+
+
+def lip_classes():
+    """LIP class names for external use."""
+    return [
+        'background', 'hat', 'hair', 'glove', 'sunglasses', 'upperclothes',
+        'dress', 'coat', 'socks', 'pants', 'jumpsuits', 'scarf', 'skirt',
+        'face', 'leftArm', 'rightArm', 'leftLeg', 'rightLeg', 'leftShoe',
+        'rightShoe'
+    ]
+
+
+def lip_palette():
+    """LIP palette for external use."""
+    return [
+        'Background', 'Hat', 'Hair', 'Glove', 'Sunglasses', 'UpperClothes',
+        'Dress', 'Coat', 'Socks', 'Pants', 'Jumpsuits', 'Scarf', 'Skirt',
+        'Face', 'Left-arm', 'Right-arm', 'Left-leg', 'Right-leg', 'Left-shoe',
+        'Right-shoe'
+    ]
+
+
+def bdd100k_classes():
+    """BDD100K class names for external use(the class name is compatible with
+    Cityscapes )."""
+    return [
+        'road', 'sidewalk', 'building', 'wall', 'fence', 'pole',
+        'traffic light', 'traffic sign', 'vegetation', 'terrain', 'sky',
+        'person', 'rider', 'car', 'truck', 'bus', 'train', 'motorcycle',
+        'bicycle'
+    ]
+
+
+def bdd100k_palette():
+    """bdd100k palette for external use(same with cityscapes)"""
+    return [[128, 64, 128], [244, 35, 232], [70, 70, 70], [102, 102, 156],
+            [190, 153, 153], [153, 153, 153], [250, 170, 30], [220, 220, 0],
+            [107, 142, 35], [152, 251, 152], [70, 130, 180], [220, 20, 60],
+            [255, 0, 0], [0, 0, 142], [0, 0, 70], [0, 60, 100], [0, 80, 100],
+            [0, 0, 230], [119, 11, 32]]
+
+
+def hsidrive_classes():
+    """HSI Drive 2.0 class names for external use."""
+    return [
+        'unlabelled', 'road', 'road marks', 'vegetation', 'painted metal',
+        'sky', 'concrete', 'pedestrian', 'water', 'unpainted metal', 'glass'
+    ]
+
+
+def hsidrive_palette():
+    """HSI Drive 2.0 palette for external use."""
+    return [[0, 0, 0], [77, 77, 77], [255, 255, 255], [0, 255, 0], [255, 0, 0],
+            [0, 0, 255], [102, 51, 0], [255, 255, 0], [0, 207, 250],
+            [255, 166, 0], [0, 204, 204]]
+
+
+dataset_aliases = {
+    'cityscapes': ['cityscapes'],
+    'ade': ['ade', 'ade20k'],
+    'voc': ['voc', 'pascal_voc', 'voc12', 'voc12aug'],
+    'pcontext': ['pcontext', 'pascal_context', 'voc2010'],
+    'loveda': ['loveda'],
+    'potsdam': ['potsdam'],
+    'vaihingen': ['vaihingen'],
+    'cocostuff': [
+        'cocostuff', 'cocostuff10k', 'cocostuff164k', 'coco-stuff',
+        'coco-stuff10k', 'coco-stuff164k', 'coco_stuff', 'coco_stuff10k',
+        'coco_stuff164k'
+    ],
+    'isaid': ['isaid', 'iSAID'],
+    'stare': ['stare', 'STARE'],
+    'lip': ['LIP', 'lip'],
+    'mapillary_v1': ['mapillary_v1'],
+    'mapillary_v2': ['mapillary_v2'],
+    'bdd100k': ['bdd100k'],
+    'hsidrive': [
+        'hsidrive', 'HSIDrive', 'HSI-Drive', 'hsidrive20', 'HSIDrive20',
+        'HSI-Drive20'
+    ],
+    'xray': ['xray', 'XRay'],
+}
+
+
+def get_classes(dataset):
+    """Get class names of a dataset."""
+    alias2name = {}
+    for name, aliases in dataset_aliases.items():
+        for alias in aliases:
+            alias2name[alias] = name
+            
+    if is_str(dataset):
+        if dataset in alias2name:
+            labels = eval(alias2name[dataset] + '_classes()')
+        else:
+            raise ValueError(f'Unrecognized dataset: {dataset}')
+    else:
+        raise TypeError(f'dataset must a str, but got {type(dataset)}')
+    return labels
+
+
+def get_palette(dataset):
+    """Get class palette (RGB) of a dataset."""
+    alias2name = {}
+    for name, aliases in dataset_aliases.items():
+        for alias in aliases:
+            alias2name[alias] = name
+
+    if is_str(dataset):
+        if dataset in alias2name:
+            labels = eval(alias2name[dataset] + '_palette()')
+        else:
+            raise ValueError(f'Unrecognized dataset: {dataset}')
+    else:
+        raise TypeError(f'dataset must a str, but got {type(dataset)}')
+    return labels
diff --git a/mmsegmentation/mmseg/utils/collect_env.py b/mmsegmentation/mmseg/utils/collect_env.py
new file mode 100644
index 0000000..d5d6ea2
--- /dev/null
+++ b/mmsegmentation/mmseg/utils/collect_env.py
@@ -0,0 +1,18 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.utils import get_git_hash
+from mmengine.utils.dl_utils import collect_env as collect_base_env
+
+import mmseg
+
+
+def collect_env():
+    """Collect the information of the running environments."""
+    env_info = collect_base_env()
+    env_info['MMSegmentation'] = f'{mmseg.__version__}+{get_git_hash()[:7]}'
+
+    return env_info
+
+
+if __name__ == '__main__':
+    for name, val in collect_env().items():
+        print(f'{name}: {val}')
diff --git a/mmsegmentation/mmseg/utils/get_templates.py b/mmsegmentation/mmseg/utils/get_templates.py
new file mode 100644
index 0000000..7e9032b
--- /dev/null
+++ b/mmsegmentation/mmseg/utils/get_templates.py
@@ -0,0 +1,109 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List
+
+PREDEFINED_TEMPLATES = {
+    'imagenet': [
+        'a bad photo of a {}.',
+        'a photo of many {}.',
+        'a sculpture of a {}.',
+        'a photo of the hard to see {}.',
+        'a low resolution photo of the {}.',
+        'a rendering of a {}.',
+        'graffiti of a {}.',
+        'a bad photo of the {}.',
+        'a cropped photo of the {}.',
+        'a tattoo of a {}.',
+        'the embroidered {}.',
+        'a photo of a hard to see {}.',
+        'a bright photo of a {}.',
+        'a photo of a clean {}.',
+        'a photo of a dirty {}.',
+        'a dark photo of the {}.',
+        'a drawing of a {}.',
+        'a photo of my {}.',
+        'the plastic {}.',
+        'a photo of the cool {}.',
+        'a close-up photo of a {}.',
+        'a black and white photo of the {}.',
+        'a painting of the {}.',
+        'a painting of a {}.',
+        'a pixelated photo of the {}.',
+        'a sculpture of the {}.',
+        'a bright photo of the {}.',
+        'a cropped photo of a {}.',
+        'a plastic {}.',
+        'a photo of the dirty {}.',
+        'a jpeg corrupted photo of a {}.',
+        'a blurry photo of the {}.',
+        'a photo of the {}.',
+        'a good photo of the {}.',
+        'a rendering of the {}.',
+        'a {} in a video game.',
+        'a photo of one {}.',
+        'a doodle of a {}.',
+        'a close-up photo of the {}.',
+        'a photo of a {}.',
+        'the origami {}.',
+        'the {} in a video game.',
+        'a sketch of a {}.',
+        'a doodle of the {}.',
+        'a origami {}.',
+        'a low resolution photo of a {}.',
+        'the toy {}.',
+        'a rendition of the {}.',
+        'a photo of the clean {}.',
+        'a photo of a large {}.',
+        'a rendition of a {}.',
+        'a photo of a nice {}.',
+        'a photo of a weird {}.',
+        'a blurry photo of a {}.',
+        'a cartoon {}.',
+        'art of a {}.',
+        'a sketch of the {}.',
+        'a embroidered {}.',
+        'a pixelated photo of a {}.',
+        'itap of the {}.',
+        'a jpeg corrupted photo of the {}.',
+        'a good photo of a {}.',
+        'a plushie {}.',
+        'a photo of the nice {}.',
+        'a photo of the small {}.',
+        'a photo of the weird {}.',
+        'the cartoon {}.',
+        'art of the {}.',
+        'a drawing of the {}.',
+        'a photo of the large {}.',
+        'a black and white photo of a {}.',
+        'the plushie {}.',
+        'a dark photo of a {}.',
+        'itap of a {}.',
+        'graffiti of the {}.',
+        'a toy {}.',
+        'itap of my {}.',
+        'a photo of a cool {}.',
+        'a photo of a small {}.',
+        'a tattoo of the {}.',
+    ],
+    'vild': [
+        'a photo of a {}.',
+        'This is a photo of a {}',
+        'There is a {} in the scene',
+        'There is the {} in the scene',
+        'a photo of a {} in the scene',
+        'a photo of a small {}.',
+        'a photo of a medium {}.',
+        'a photo of a large {}.',
+        'This is a photo of a small {}.',
+        'This is a photo of a medium {}.',
+        'This is a photo of a large {}.',
+        'There is a small {} in the scene.',
+        'There is a medium {} in the scene.',
+        'There is a large {} in the scene.',
+    ],
+}
+
+
+def get_predefined_templates(template_set_name: str) -> List[str]:
+    if template_set_name not in PREDEFINED_TEMPLATES:
+        raise ValueError(f'Template set {template_set_name} not found')
+    return PREDEFINED_TEMPLATES[template_set_name]
diff --git a/mmsegmentation/mmseg/utils/io.py b/mmsegmentation/mmseg/utils/io.py
new file mode 100644
index 0000000..7029c3c
--- /dev/null
+++ b/mmsegmentation/mmseg/utils/io.py
@@ -0,0 +1,42 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import gzip
+import io
+import pickle
+
+import cv2
+import numpy as np
+
+
+def datafrombytes(content: bytes, backend: str = 'numpy') -> np.ndarray:
+    """Data decoding from bytes.
+
+    Args:
+        content (bytes): The data bytes got from files or other streams.
+        backend (str): The data decoding backend type. Options are 'numpy',
+            'nifti', 'cv2' and 'pickle'. Defaults to 'numpy'.
+
+    Returns:
+        numpy.ndarray: Loaded data array.
+    """
+    if backend == 'pickle':
+        data = pickle.loads(content)
+    else:
+        with io.BytesIO(content) as f:
+            if backend == 'nifti':
+                f = gzip.open(f)
+                try:
+                    from nibabel import FileHolder, Nifti1Image
+                except ImportError:
+                    print('nifti files io depends on nibabel, please run'
+                          '`pip install nibabel` to install it')
+                fh = FileHolder(fileobj=f)
+                data = Nifti1Image.from_file_map({'header': fh, 'image': fh})
+                data = Nifti1Image.from_bytes(data.to_bytes()).get_fdata()
+            elif backend == 'numpy':
+                data = np.load(f)
+            elif backend == 'cv2':
+                data = np.frombuffer(f.read(), dtype=np.uint8)
+                data = cv2.imdecode(data, cv2.IMREAD_UNCHANGED)
+            else:
+                raise ValueError
+    return data
diff --git a/mmsegmentation/mmseg/utils/mask_classification.py b/mmsegmentation/mmseg/utils/mask_classification.py
new file mode 100644
index 0000000..205d525
--- /dev/null
+++ b/mmsegmentation/mmseg/utils/mask_classification.py
@@ -0,0 +1,205 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple
+
+import torch
+from mmcv.ops import point_sample
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmseg.registry import TASK_UTILS
+from mmseg.utils import ConfigType, SampleList
+
+
+def seg_data_to_instance_data(ignore_index: int,
+                              batch_data_samples: SampleList):
+    """Convert the paradigm of ground truth from semantic segmentation to
+    instance segmentation.
+
+    Args:
+        ignore_index (int): The label index to be ignored.
+        batch_data_samples (List[SegDataSample]): The Data
+            Samples. It usually includes information such as
+            `gt_sem_seg`.
+
+    Returns:
+        tuple[Tensor]: A tuple contains two lists.
+            - batch_gt_instances (List[InstanceData]): Batch of
+                gt_instance. It usually includes ``labels``, each is
+                unique ground truth label id of images, with
+                shape (num_gt, ) and ``masks``, each is ground truth
+                masks of each instances of a image, shape (num_gt, h, w).
+            - batch_img_metas (List[Dict]): List of image meta information.
+    """
+    batch_gt_instances = []
+
+    for data_sample in batch_data_samples:
+        gt_sem_seg = data_sample.gt_sem_seg.data
+        classes = torch.unique(
+            gt_sem_seg,
+            sorted=False,
+            return_inverse=False,
+            return_counts=False)
+
+        # remove ignored region
+        gt_labels = classes[classes != ignore_index]
+
+        masks = []
+        for class_id in gt_labels:
+            masks.append(gt_sem_seg == class_id)
+
+        if len(masks) == 0:
+            gt_masks = torch.zeros(
+                (0, gt_sem_seg.shape[-2],
+                 gt_sem_seg.shape[-1])).to(gt_sem_seg).long()
+        else:
+            gt_masks = torch.stack(masks).squeeze(1).long()
+
+        instance_data = InstanceData(labels=gt_labels, masks=gt_masks)
+        batch_gt_instances.append(instance_data)
+    return batch_gt_instances
+
+
+class MatchMasks:
+    """Match the predictions to category labels.
+
+    Args:
+        num_points (int): the number of sampled points to compute cost.
+        num_queries (int): the number of prediction masks.
+        num_classes (int): the number of classes.
+        assigner (BaseAssigner): the assigner to compute matching.
+    """
+
+    def __init__(self,
+                 num_points: int,
+                 num_queries: int,
+                 num_classes: int,
+                 assigner: ConfigType = None):
+        assert assigner is not None, "\'assigner\' in decode_head.train_cfg" \
+                                     'cannot be None'
+        assert num_points > 0, 'num_points should be a positive integer.'
+        self.num_points = num_points
+        self.num_queries = num_queries
+        self.num_classes = num_classes
+        self.assigner = TASK_UTILS.build(assigner)
+
+    def get_targets(self, cls_scores: List[Tensor], mask_preds: List[Tensor],
+                    batch_gt_instances: List[InstanceData]) -> Tuple:
+        """Compute best mask matches for all images for a decoder layer.
+
+        Args:
+            cls_scores (List[Tensor]): Mask score logits from a single
+                decoder layer for all images. Each with shape (num_queries,
+                cls_out_channels).
+            mask_preds (List[Tensor]): Mask logits from a single decoder
+                layer for all images. Each with shape (num_queries, h, w).
+            batch_gt_instances (List[InstanceData]): each contains
+                ``labels`` and ``masks``.
+
+        Returns:
+            tuple: a tuple containing the following targets.
+
+                - labels (List[Tensor]): Labels of all images.\
+                    Each with shape (num_queries, ).
+                - mask_targets (List[Tensor]): Mask targets of\
+                    all images. Each with shape (num_queries, h, w).
+                - mask_weights (List[Tensor]): Mask weights of\
+                    all images. Each with shape (num_queries, ).
+                - avg_factor (int): Average factor that is used to
+                    average the loss. `avg_factor` is usually equal
+                    to the number of positive priors.
+        """
+        batch_size = cls_scores.shape[0]
+        results = dict({
+            'labels': [],
+            'mask_targets': [],
+            'mask_weights': [],
+        })
+        for i in range(batch_size):
+            labels, mask_targets, mask_weights\
+                = self._get_targets_single(cls_scores[i],
+                                           mask_preds[i],
+                                           batch_gt_instances[i])
+            results['labels'].append(labels)
+            results['mask_targets'].append(mask_targets)
+            results['mask_weights'].append(mask_weights)
+
+        # shape (batch_size, num_queries)
+        labels = torch.stack(results['labels'], dim=0)
+        # shape (batch_size, num_gts, h, w)
+        mask_targets = torch.cat(results['mask_targets'], dim=0)
+        # shape (batch_size, num_queries)
+        mask_weights = torch.stack(results['mask_weights'], dim=0)
+
+        avg_factor = sum(
+            [len(gt_instances.labels) for gt_instances in batch_gt_instances])
+
+        res = (labels, mask_targets, mask_weights, avg_factor)
+
+        return res
+
+    def _get_targets_single(self, cls_score: Tensor, mask_pred: Tensor,
+                            gt_instances: InstanceData) \
+            -> Tuple[Tensor, Tensor, Tensor]:
+        """Compute a set of best mask matches for one image.
+
+        Args:
+            cls_score (Tensor): Mask score logits from a single decoder layer
+                for one image. Shape (num_queries, cls_out_channels).
+            mask_pred (Tensor): Mask logits for a single decoder layer for one
+                image. Shape (num_queries, h, w).
+            gt_instances (:obj:`InstanceData`): It contains ``labels`` and
+                ``masks``.
+
+        Returns:
+            tuple[Tensor]: A tuple containing the following for one image.
+
+                - labels (Tensor): Labels of each image. \
+                    shape (num_queries, ).
+                - mask_targets (Tensor): Mask targets of each image. \
+                    shape (num_queries, h, w).
+                - mask_weights (Tensor): Mask weights of each image. \
+                    shape (num_queries, ).
+        """
+        gt_labels = gt_instances.labels
+        gt_masks = gt_instances.masks
+        # when "gt_labels" is empty, classify all queries to background
+        if len(gt_labels) == 0:
+            labels = gt_labels.new_full((self.num_queries, ),
+                                        self.num_classes,
+                                        dtype=torch.long)
+            mask_targets = gt_labels
+            mask_weights = gt_labels.new_zeros((self.num_queries, ))
+            return labels, mask_targets, mask_weights
+        # sample points
+        num_queries = cls_score.shape[0]
+        num_gts = gt_labels.shape[0]
+
+        point_coords = torch.rand((1, self.num_points, 2),
+                                  device=cls_score.device)
+        # shape (num_queries, num_points)
+        mask_points_pred = point_sample(
+            mask_pred.unsqueeze(1), point_coords.repeat(num_queries, 1,
+                                                        1)).squeeze(1)
+        # shape (num_gts, num_points)
+        gt_points_masks = point_sample(
+            gt_masks.unsqueeze(1).float(), point_coords.repeat(num_gts, 1,
+                                                               1)).squeeze(1)
+
+        sampled_gt_instances = InstanceData(
+            labels=gt_labels, masks=gt_points_masks)
+        sampled_pred_instances = InstanceData(
+            scores=cls_score, masks=mask_points_pred)
+        # assign and sample
+        matched_quiery_inds, matched_label_inds = self.assigner.assign(
+            pred_instances=sampled_pred_instances,
+            gt_instances=sampled_gt_instances)
+        labels = gt_labels.new_full((self.num_queries, ),
+                                    self.num_classes,
+                                    dtype=torch.long)
+        labels[matched_quiery_inds] = gt_labels[matched_label_inds]
+
+        mask_weights = gt_labels.new_zeros((self.num_queries, ))
+        mask_weights[matched_quiery_inds] = 1
+        mask_targets = gt_masks[matched_label_inds]
+
+        return labels, mask_targets, mask_weights
diff --git a/mmsegmentation/mmseg/utils/misc.py b/mmsegmentation/mmseg/utils/misc.py
new file mode 100644
index 0000000..dfc469e
--- /dev/null
+++ b/mmsegmentation/mmseg/utils/misc.py
@@ -0,0 +1,128 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Union
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+from .typing_utils import SampleList
+
+
+def add_prefix(inputs, prefix):
+    """Add prefix for dict.
+
+    Args:
+        inputs (dict): The input dict with str keys.
+        prefix (str): The prefix to add.
+
+    Returns:
+
+        dict: The dict with keys updated with ``prefix``.
+    """
+
+    outputs = dict()
+    for name, value in inputs.items():
+        outputs[f'{prefix}.{name}'] = value
+
+    return outputs
+
+
+def stack_batch(inputs: List[torch.Tensor],
+                data_samples: Optional[SampleList] = None,
+                size: Optional[tuple] = None,
+                size_divisor: Optional[int] = None,
+                pad_val: Union[int, float] = 0,
+                seg_pad_val: Union[int, float] = 255) -> torch.Tensor:
+    """Stack multiple inputs to form a batch and pad the images and gt_sem_segs
+    to the max shape use the right bottom padding mode.
+
+    Args:
+        inputs (List[Tensor]): The input multiple tensors. each is a
+            CHW 3D-tensor.
+        data_samples (list[:obj:`SegDataSample`]): The list of data samples.
+            It usually includes information such as `gt_sem_seg`.
+        size (tuple, optional): Fixed padding size.
+        size_divisor (int, optional): The divisor of padded size.
+        pad_val (int, float): The padding value. Defaults to 0
+        seg_pad_val (int, float): The padding value. Defaults to 255
+
+    Returns:
+       Tensor: The 4D-tensor.
+       List[:obj:`SegDataSample`]: After the padding of the gt_seg_map.
+    """
+    assert isinstance(inputs, list), \
+        f'Expected input type to be list, but got {type(inputs)}'
+    assert len({tensor.ndim for tensor in inputs}) == 1, \
+        f'Expected the dimensions of all inputs must be the same, ' \
+        f'but got {[tensor.ndim for tensor in inputs]}'
+    assert inputs[0].ndim == 3, f'Expected tensor dimension to be 3, ' \
+        f'but got {inputs[0].ndim}'
+    assert len({tensor.shape[0] for tensor in inputs}) == 1, \
+        f'Expected the channels of all inputs must be the same, ' \
+        f'but got {[tensor.shape[0] for tensor in inputs]}'
+
+    # only one of size and size_divisor should be valid
+    assert (size is not None) ^ (size_divisor is not None), \
+        'only one of size and size_divisor should be valid'
+
+    padded_inputs = []
+    padded_samples = []
+    inputs_sizes = [(img.shape[-2], img.shape[-1]) for img in inputs]
+    max_size = np.stack(inputs_sizes).max(0)
+    if size_divisor is not None and size_divisor > 1:
+        # the last two dims are H,W, both subject to divisibility requirement
+        max_size = (max_size +
+                    (size_divisor - 1)) // size_divisor * size_divisor
+
+    for i in range(len(inputs)):
+        tensor = inputs[i]
+        if size is not None:
+            width = max(size[-1] - tensor.shape[-1], 0)
+            height = max(size[-2] - tensor.shape[-2], 0)
+            # (padding_left, padding_right, padding_top, padding_bottom)
+            padding_size = (0, width, 0, height)
+        elif size_divisor is not None:
+            width = max(max_size[-1] - tensor.shape[-1], 0)
+            height = max(max_size[-2] - tensor.shape[-2], 0)
+            padding_size = (0, width, 0, height)
+        else:
+            padding_size = [0, 0, 0, 0]
+
+        # pad img
+        pad_img = F.pad(tensor, padding_size, value=pad_val)
+        padded_inputs.append(pad_img)
+        # pad gt_sem_seg
+        if data_samples is not None:
+            data_sample = data_samples[i]
+            pad_shape = None
+            if 'gt_sem_seg' in data_sample:
+                gt_sem_seg = data_sample.gt_sem_seg.data
+                del data_sample.gt_sem_seg.data
+                data_sample.gt_sem_seg.data = F.pad(
+                    gt_sem_seg, padding_size, value=seg_pad_val)
+                pad_shape = data_sample.gt_sem_seg.shape
+            if 'gt_edge_map' in data_sample:
+                gt_edge_map = data_sample.gt_edge_map.data
+                del data_sample.gt_edge_map.data
+                data_sample.gt_edge_map.data = F.pad(
+                    gt_edge_map, padding_size, value=seg_pad_val)
+                pad_shape = data_sample.gt_edge_map.shape
+            if 'gt_depth_map' in data_sample:
+                gt_depth_map = data_sample.gt_depth_map.data
+                del data_sample.gt_depth_map.data
+                data_sample.gt_depth_map.data = F.pad(
+                    gt_depth_map, padding_size, value=seg_pad_val)
+                pad_shape = data_sample.gt_depth_map.shape
+            data_sample.set_metainfo({
+                'img_shape': tensor.shape[-2:],
+                'pad_shape': pad_shape,
+                'padding_size': padding_size
+            })
+            padded_samples.append(data_sample)
+        else:
+            padded_samples.append(
+                dict(
+                    img_padding_size=padding_size,
+                    pad_shape=pad_img.shape[-2:]))
+
+    return torch.stack(padded_inputs, dim=0), padded_samples
diff --git a/mmsegmentation/mmseg/utils/set_env.py b/mmsegmentation/mmseg/utils/set_env.py
new file mode 100644
index 0000000..c948950
--- /dev/null
+++ b/mmsegmentation/mmseg/utils/set_env.py
@@ -0,0 +1,40 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import datetime
+import warnings
+
+from mmengine import DefaultScope
+
+
+def register_all_modules(init_default_scope: bool = True) -> None:
+    """Register all modules in mmseg into the registries.
+
+    Args:
+        init_default_scope (bool): Whether initialize the mmseg default scope.
+            When `init_default_scope=True`, the global default scope will be
+            set to `mmseg`, and all registries will build modules from mmseg's
+            registry node. To understand more about the registry, please refer
+            to https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/registry.md
+            Defaults to True.
+    """  # noqa
+    import mmseg.datasets  # noqa: F401,F403
+    import mmseg.engine  # noqa: F401,F403
+    import mmseg.evaluation  # noqa: F401,F403
+    import mmseg.models  # noqa: F401,F403
+    import mmseg.structures  # noqa: F401,F403
+
+    if init_default_scope:
+        never_created = DefaultScope.get_current_instance() is None \
+                        or not DefaultScope.check_instance_created('mmseg')
+        if never_created:
+            DefaultScope.get_instance('mmseg', scope_name='mmseg')
+            return
+        current_scope = DefaultScope.get_current_instance()
+        if current_scope.scope_name != 'mmseg':
+            warnings.warn('The current default scope '
+                          f'"{current_scope.scope_name}" is not "mmseg", '
+                          '`register_all_modules` will force the current'
+                          'default scope to be "mmseg". If this is not '
+                          'expected, please set `init_default_scope=False`.')
+            # avoid name conflict
+            new_instance_name = f'mmseg-{datetime.datetime.now()}'
+            DefaultScope.get_instance(new_instance_name, scope_name='mmseg')
diff --git a/mmsegmentation/mmseg/utils/tokenizer.py b/mmsegmentation/mmseg/utils/tokenizer.py
new file mode 100644
index 0000000..d56f5fa
--- /dev/null
+++ b/mmsegmentation/mmseg/utils/tokenizer.py
@@ -0,0 +1,240 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+"""CLIP tokenizer.
+
+Copied from https://github.com/openai/CLIP. Originally MIT License, Copyright
+(c) 2021 OpenAI.
+"""
+import gzip
+import html
+import os
+from functools import lru_cache
+from typing import List, Union
+
+import ftfy
+import regex as re
+import torch
+
+os.environ['TOKENIZERS_PARALLELISM'] = 'false'
+
+
+@lru_cache()
+def default_bpe():
+    return os.path.join(
+        os.path.dirname(os.path.abspath(__file__)),
+        'bpe_simple_vocab_16e6.txt.gz')
+
+
+@lru_cache()
+def bytes_to_unicode():
+    """Returns list of utf-8 byte and a corresponding list of unicode strings.
+
+    The reversible bpe codes work on unicode strings. This means you need a
+    large # of unicode characters in your vocab if you want to avoid UNKs. When
+    you're at something like a 10B token dataset you end up needing around 5K
+    for decent coverage. This is a significant percentage of your normal, say,
+    32K bpe vocab. To avoid that, we want lookup tables between utf-8 bytes and
+    unicode strings. And avoids mapping to whitespace/control characters the
+    bpe code barfs on.
+    """
+    bs = list(range(ord('!'),
+                    ord('~') + 1)) + list(range(
+                        ord('¡'),
+                        ord('¬') + 1)) + list(range(ord('®'),
+                                                    ord('ÿ') + 1))
+    cs = bs[:]
+    n = 0
+    for b in range(2**8):
+        if b not in bs:
+            bs.append(b)
+            cs.append(2**8 + n)
+            n += 1
+    cs = [chr(n) for n in cs]
+    return dict(zip(bs, cs))
+
+
+def get_pairs(word):
+    """Return set of symbol pairs in a word.
+
+    Word is represented as tuple of symbols (symbols being variable-length
+    strings).
+    """
+    pairs = set()
+    prev_char = word[0]
+    for char in word[1:]:
+        pairs.add((prev_char, char))
+        prev_char = char
+    return pairs
+
+
+def basic_clean(text):
+    text = ftfy.fix_text(text)
+    text = html.unescape(html.unescape(text))
+    return text.strip()
+
+
+def whitespace_clean(text):
+    text = re.sub(r'\s+', ' ', text)
+    text = text.strip()
+    return text
+
+
+class SimpleTokenizer:
+
+    def __init__(self, bpe_path: str = default_bpe(), special_tokens=None):
+        self.byte_encoder = bytes_to_unicode()
+        self.byte_decoder = {v: k for k, v in self.byte_encoder.items()}
+        merges = gzip.open(bpe_path).read().decode('utf-8').split('\n')
+        merges = merges[1:49152 - 256 - 2 + 1]
+        merges = [tuple(merge.split()) for merge in merges]
+        vocab = list(bytes_to_unicode().values())
+        vocab = vocab + [v + '</w>' for v in vocab]
+        for merge in merges:
+            vocab.append(''.join(merge))
+        if not special_tokens:
+            special_tokens = ['<start_of_text>', '<end_of_text>']
+        else:
+            special_tokens = ['<start_of_text>', '<end_of_text>'
+                              ] + special_tokens
+        vocab.extend(special_tokens)
+        self.encoder = dict(zip(vocab, range(len(vocab))))
+        self.decoder = {v: k for k, v in self.encoder.items()}
+        self.bpe_ranks = dict(zip(merges, range(len(merges))))
+        self.cache = {t: t for t in special_tokens}
+        special = '|'.join(special_tokens)
+        self.pat = re.compile(
+            special +
+            r"""|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""",
+            re.IGNORECASE)
+
+        self.vocab_size = len(self.encoder)
+        self.all_special_ids = [self.encoder[t] for t in special_tokens]
+
+    def bpe(self, token):
+        if token in self.cache:
+            return self.cache[token]
+        word = tuple(token[:-1]) + (token[-1] + '</w>', )
+        pairs = get_pairs(word)
+
+        if not pairs:
+            return token + '</w>'
+
+        while True:
+            bigram = min(
+                pairs, key=lambda pair: self.bpe_ranks.get(pair, float('inf')))
+            if bigram not in self.bpe_ranks:
+                break
+            first, second = bigram
+            new_word = []
+            i = 0
+            while i < len(word):
+                try:
+                    j = word.index(first, i)
+                    new_word.extend(word[i:j])
+                    i = j
+                except:  # noqa: E722, E261
+                    new_word.extend(word[i:])
+                    break
+
+                if word[i] == first and i < len(word) - 1 and word[
+                        i + 1] == second:
+                    new_word.append(first + second)
+                    i += 2
+                else:
+                    new_word.append(word[i])
+                    i += 1
+            new_word = tuple(new_word)
+            word = new_word
+            if len(word) == 1:
+                break
+            else:
+                pairs = get_pairs(word)
+        word = ' '.join(word)
+        self.cache[token] = word
+        return word
+
+    def encode(self, text):
+        bpe_tokens = []
+        text = whitespace_clean(basic_clean(text)).lower()
+        for token in re.findall(self.pat, text):
+            token = ''.join(self.byte_encoder[b]
+                            for b in token.encode('utf-8'))
+            bpe_tokens.extend(self.encoder[bpe_token]
+                              for bpe_token in self.bpe(token).split(' '))
+        return bpe_tokens
+
+    def decode(self, tokens):
+        text = ''.join([self.decoder[token] for token in tokens])
+        text = bytearray([self.byte_decoder[c] for c in text]).decode(
+            'utf-8', errors='replace').replace('</w>', ' ')
+        return text
+
+
+_tokenizer = SimpleTokenizer()
+
+
+def decode(output_ids: torch.Tensor):
+    output_ids = output_ids.cpu().numpy()
+    return _tokenizer.decode(output_ids)
+
+
+def tokenize(texts: Union[str, List[str]],
+             context_length: int = 77) -> torch.LongTensor:
+    """Returns the tokenized representation of given input string(s)
+
+    Parameters
+    ----------
+    texts : Union[str, List[str]]
+        An input string or a list of input strings to tokenize
+    context_length : int
+        The context length to use; all CLIP models use 77 as the context length
+
+    Returns
+    -------
+    A two-dimensional tensor containing the resulting tokens,
+    shape = [number of input strings, context_length]
+    """
+    if isinstance(texts, str):
+        texts = [texts]
+
+    sot_token = _tokenizer.encoder['<start_of_text>']
+    eot_token = _tokenizer.encoder['<end_of_text>']
+    all_tokens = [[sot_token] + _tokenizer.encode(text) + [eot_token]
+                  for text in texts]
+    result = torch.zeros(len(all_tokens), context_length, dtype=torch.long)
+
+    for i, tokens in enumerate(all_tokens):
+        if len(tokens) > context_length:
+            tokens = tokens[:context_length]  # Truncate
+            tokens[-1] = eot_token
+        result[i, :len(tokens)] = torch.tensor(tokens)
+
+    return result
+
+
+class HFTokenizer:
+    """HuggingFace tokenizer wrapper."""
+
+    def __init__(self, tokenizer_name: str):
+        from transformers import AutoTokenizer
+        self.tokenizer = AutoTokenizer.from_pretrained(tokenizer_name)
+
+    def save_pretrained(self, dest):
+        self.tokenizer.save_pretrained(dest)
+
+    def __call__(self,
+                 texts: Union[str, List[str]],
+                 context_length: int = 77) -> torch.Tensor:
+        # same cleaning as for default tokenizer, except lowercasing
+        # adding lower (for case-sensitive tokenizers) will make it
+        # more robust but less sensitive to nuance
+        if isinstance(texts, str):
+            texts = [texts]
+        texts = [whitespace_clean(basic_clean(text)) for text in texts]
+        input_ids = self.tokenizer(
+            texts,
+            return_tensors='pt',
+            max_length=context_length,
+            padding='max_length',
+            truncation=True,
+        ).input_ids
+        return input_ids
diff --git a/mmsegmentation/mmseg/utils/typing_utils.py b/mmsegmentation/mmseg/utils/typing_utils.py
new file mode 100644
index 0000000..fba7d3b
--- /dev/null
+++ b/mmsegmentation/mmseg/utils/typing_utils.py
@@ -0,0 +1,25 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+"""Collecting some commonly used type hint in mmflow."""
+from typing import Dict, List, Optional, Sequence, Tuple, Union
+
+import torch
+from mmengine.config import ConfigDict
+
+from mmseg.structures import SegDataSample
+
+# Type hint of config data
+ConfigType = Union[ConfigDict, dict]
+OptConfigType = Optional[ConfigType]
+# Type hint of one or more config data
+MultiConfig = Union[ConfigType, Sequence[ConfigType]]
+OptMultiConfig = Optional[MultiConfig]
+
+SampleList = Sequence[SegDataSample]
+OptSampleList = Optional[SampleList]
+
+# Type hint of Tensor
+TensorDict = Dict[str, torch.Tensor]
+TensorList = Sequence[torch.Tensor]
+
+ForwardResults = Union[Dict[str, torch.Tensor], List[SegDataSample],
+                       Tuple[torch.Tensor], torch.Tensor]
diff --git a/mmsegmentation/mmseg/version.py b/mmsegmentation/mmseg/version.py
new file mode 100644
index 0000000..b76bb45
--- /dev/null
+++ b/mmsegmentation/mmseg/version.py
@@ -0,0 +1,18 @@
+# Copyright (c) Open-MMLab. All rights reserved.
+
+__version__ = '1.2.2'
+
+
+def parse_version_info(version_str):
+    version_info = []
+    for x in version_str.split('.'):
+        if x.isdigit():
+            version_info.append(int(x))
+        elif x.find('rc') != -1:
+            patch_version = x.split('rc')
+            version_info.append(int(patch_version[0]))
+            version_info.append(f'rc{patch_version[1]}')
+    return tuple(version_info)
+
+
+version_info = parse_version_info(__version__)
diff --git a/mmsegmentation/mmseg/visualization/__init__.py b/mmsegmentation/mmseg/visualization/__init__.py
new file mode 100644
index 0000000..8cbb211
--- /dev/null
+++ b/mmsegmentation/mmseg/visualization/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .local_visualizer import SegLocalVisualizer
+
+__all__ = ['SegLocalVisualizer']
diff --git a/mmsegmentation/mmseg/visualization/local_visualizer.py b/mmsegmentation/mmseg/visualization/local_visualizer.py
new file mode 100644
index 0000000..ee3d652
--- /dev/null
+++ b/mmsegmentation/mmseg/visualization/local_visualizer.py
@@ -0,0 +1,349 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, List, Optional
+
+import cv2
+import mmcv
+import numpy as np
+import torch
+from mmengine.dist import master_only
+from mmengine.structures import PixelData
+from mmengine.visualization import Visualizer
+
+from mmseg.registry import VISUALIZERS
+from mmseg.structures import SegDataSample
+from mmseg.utils import get_classes, get_palette
+
+
+@VISUALIZERS.register_module()
+class SegLocalVisualizer(Visualizer):
+    """Local Visualizer.
+
+    Args:
+        name (str): Name of the instance. Defaults to 'visualizer'.
+        image (np.ndarray, optional): the origin image to draw. The format
+            should be RGB. Defaults to None.
+        vis_backends (list, optional): Visual backend config list.
+            Defaults to None.
+        save_dir (str, optional): Save file dir for all storage backends.
+            If it is None, the backend storage will not save any data.
+        classes (list, optional): Input classes for result rendering, as the
+            prediction of segmentation model is a segment map with label
+            indices, `classes` is a list which includes items responding to the
+            label indices. If classes is not defined, visualizer will take
+            `cityscapes` classes by default. Defaults to None.
+        palette (list, optional): Input palette for result rendering, which is
+            a list of color palette responding to the classes. Defaults to None.
+        dataset_name (str, optional): `Dataset name or alias <https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/utils/class_names.py#L302-L317>`_
+            visulizer will use the meta information of the dataset i.e. classes
+            and palette, but the `classes` and `palette` have higher priority.
+            Defaults to None.
+        alpha (int, float): The transparency of segmentation mask.
+                Defaults to 0.8.
+
+    Examples:
+        >>> import numpy as np
+        >>> import torch
+        >>> from mmengine.structures import PixelData
+        >>> from mmseg.structures import SegDataSample
+        >>> from mmseg.visualization import SegLocalVisualizer
+
+        >>> seg_local_visualizer = SegLocalVisualizer()
+        >>> image = np.random.randint(0, 256,
+        ...                     size=(10, 12, 3)).astype('uint8')
+        >>> gt_sem_seg_data = dict(data=torch.randint(0, 2, (1, 10, 12)))
+        >>> gt_sem_seg = PixelData(**gt_sem_seg_data)
+        >>> gt_seg_data_sample = SegDataSample()
+        >>> gt_seg_data_sample.gt_sem_seg = gt_sem_seg
+        >>> seg_local_visualizer.dataset_meta = dict(
+        >>>     classes=('background', 'foreground'),
+        >>>     palette=[[120, 120, 120], [6, 230, 230]])
+        >>> seg_local_visualizer.add_datasample('visualizer_example',
+        ...                         image, gt_seg_data_sample)
+        >>> seg_local_visualizer.add_datasample(
+        ...                        'visualizer_example', image,
+        ...                         gt_seg_data_sample, show=True)
+    """  # noqa
+
+    def __init__(self,
+                 name: str = 'visualizer',
+                 image: Optional[np.ndarray] = None,
+                 vis_backends: Optional[Dict] = None,
+                 save_dir: Optional[str] = None,
+                 classes: Optional[List] = None,
+                 palette: Optional[List] = None,
+                 dataset_name: Optional[str] = None,
+                 alpha: float = 0.8,
+                 **kwargs):
+        super().__init__(name, image, vis_backends, save_dir, **kwargs)
+        self.alpha: float = alpha
+        self.set_dataset_meta(palette, classes, dataset_name)
+
+    def _get_center_loc(self, mask: np.ndarray) -> np.ndarray:
+        """Get semantic seg center coordinate.
+
+        Args:
+            mask: np.ndarray: get from sem_seg
+        """
+        loc = np.argwhere(mask == 1)
+
+        loc_sort = np.array(
+            sorted(loc.tolist(), key=lambda row: (row[0], row[1])))
+        y_list = loc_sort[:, 0]
+        unique, indices, counts = np.unique(
+            y_list, return_index=True, return_counts=True)
+        y_loc = unique[counts.argmax()]
+        y_most_freq_loc = loc[loc_sort[:, 0] == y_loc]
+        center_num = len(y_most_freq_loc) // 2
+        x = y_most_freq_loc[center_num][1]
+        y = y_most_freq_loc[center_num][0]
+        return np.array([x, y])
+
+    def _draw_sem_seg(self,
+                      image: np.ndarray,
+                      sem_seg: PixelData,
+                      classes: Optional[List],
+                      palette: Optional[List],
+                      with_labels: Optional[bool] = True) -> np.ndarray:
+        """Draw semantic seg of GT or prediction.
+
+        Args:
+            image (np.ndarray): The image to draw.
+            sem_seg (:obj:`PixelData`): Data structure for pixel-level
+                annotations or predictions.
+            classes (list, optional): Input classes for result rendering, as
+                the prediction of segmentation model is a segment map with
+                label indices, `classes` is a list which includes items
+                responding to the label indices. If classes is not defined,
+                visualizer will take `cityscapes` classes by default.
+                Defaults to None.
+            palette (list, optional): Input palette for result rendering, which
+                is a list of color palette responding to the classes.
+                Defaults to None.
+            with_labels(bool, optional): Add semantic labels in visualization
+                result, Default to True.
+
+        Returns:
+            np.ndarray: the drawn image which channel is RGB.
+        """
+        num_classes = len(classes)
+
+        sem_seg = sem_seg.cpu().data
+        ids = np.unique(sem_seg)[::-1]
+        legal_indices = ids < num_classes
+        ids = ids[legal_indices]
+        labels = np.array(ids, dtype=np.int64)
+
+        colors = [palette[label] for label in labels]
+
+        mask = np.zeros_like(image, dtype=np.uint8)
+        for label, color in zip(labels, colors):
+            mask[sem_seg[0] == label, :] = color
+
+        if with_labels:
+            font = cv2.FONT_HERSHEY_SIMPLEX
+            # (0,1] to change the size of the text relative to the image
+            scale = 0.05
+            fontScale = min(image.shape[0], image.shape[1]) / (25 / scale)
+            fontColor = (255, 255, 255)
+            if image.shape[0] < 300 or image.shape[1] < 300:
+                thickness = 1
+                rectangleThickness = 1
+            else:
+                thickness = 2
+                rectangleThickness = 2
+            lineType = 2
+
+            if isinstance(sem_seg[0], torch.Tensor):
+                masks = sem_seg[0].numpy() == labels[:, None, None]
+            else:
+                masks = sem_seg[0] == labels[:, None, None]
+            masks = masks.astype(np.uint8)
+            for mask_num in range(len(labels)):
+                classes_id = labels[mask_num]
+                classes_color = colors[mask_num]
+                loc = self._get_center_loc(masks[mask_num])
+                text = classes[classes_id]
+                (label_width, label_height), baseline = cv2.getTextSize(
+                    text, font, fontScale, thickness)
+                mask = cv2.rectangle(mask, loc,
+                                     (loc[0] + label_width + baseline,
+                                      loc[1] + label_height + baseline),
+                                     classes_color, -1)
+                mask = cv2.rectangle(mask, loc,
+                                     (loc[0] + label_width + baseline,
+                                      loc[1] + label_height + baseline),
+                                     (0, 0, 0), rectangleThickness)
+                mask = cv2.putText(mask, text, (loc[0], loc[1] + label_height),
+                                   font, fontScale, fontColor, thickness,
+                                   lineType)
+        color_seg = (image * (1 - self.alpha) + mask * self.alpha).astype(
+            np.uint8)
+        self.set_image(color_seg)
+        return color_seg
+
+    def _draw_depth_map(self, image: np.ndarray,
+                        depth_map: PixelData) -> np.ndarray:
+        """Draws a depth map on a given image.
+
+        This function takes an image and a depth map as input,
+        renders the depth map, and concatenates it with the original image.
+        Finally, it updates the internal image state of the visualizer with
+        the concatenated result.
+
+        Args:
+            image (np.ndarray): The original image where the depth map will
+                be drawn. The array should be in the format HxWx3 where H is
+                the height, W is the width.
+
+            depth_map (PixelData): Depth map to be drawn. The depth map
+                should be in the form of a PixelData object. It will be
+                converted to a torch tensor if it is a numpy array.
+
+        Returns:
+            np.ndarray: The concatenated image with the depth map drawn.
+
+        Example:
+            >>> depth_map_data = PixelData(data=torch.rand(1, 10, 10))
+            >>> image = np.random.randint(0, 256,
+            >>>                           size=(10, 10, 3)).astype('uint8')
+            >>> visualizer = SegLocalVisualizer()
+            >>> visualizer._draw_depth_map(image, depth_map_data)
+        """
+        depth_map = depth_map.cpu().data
+        if isinstance(depth_map, np.ndarray):
+            depth_map = torch.from_numpy(depth_map)
+        if depth_map.ndim == 2:
+            depth_map = depth_map[None]
+
+        depth_map = self.draw_featmap(depth_map, resize_shape=image.shape[:2])
+        out_image = np.concatenate((image, depth_map), axis=0)
+        self.set_image(out_image)
+        return out_image
+
+    def set_dataset_meta(self,
+                         classes: Optional[List] = None,
+                         palette: Optional[List] = None,
+                         dataset_name: Optional[str] = None) -> None:
+        """Set meta information to visualizer.
+
+        Args:
+            classes (list, optional): Input classes for result rendering, as
+                the prediction of segmentation model is a segment map with
+                label indices, `classes` is a list which includes items
+                responding to the label indices. If classes is not defined,
+                visualizer will take `cityscapes` classes by default.
+                Defaults to None.
+            palette (list, optional): Input palette for result rendering, which
+                is a list of color palette responding to the classes.
+                Defaults to None.
+            dataset_name (str, optional): `Dataset name or alias <https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/utils/class_names.py#L302-L317>`_
+                visulizer will use the meta information of the dataset i.e.
+                classes and palette, but the `classes` and `palette` have
+                higher priority. Defaults to None.
+        """  # noqa
+        # Set default value. When calling
+        # `SegLocalVisualizer().dataset_meta=xxx`,
+        # it will override the default value.
+        if dataset_name is None:
+            dataset_name = 'cityscapes'
+        classes = classes if classes else get_classes(dataset_name)
+        palette = palette if palette else get_palette(dataset_name)
+        assert len(classes) == len(
+            palette), 'The length of classes should be equal to palette'
+        self.dataset_meta: dict = {'classes': classes, 'palette': palette}
+
+    @master_only
+    def add_datasample(
+            self,
+            name: str,
+            image: np.ndarray,
+            data_sample: Optional[SegDataSample] = None,
+            draw_gt: bool = True,
+            draw_pred: bool = True,
+            show: bool = False,
+            wait_time: float = 0,
+            # TODO: Supported in mmengine's Viusalizer.
+            out_file: Optional[str] = None,
+            step: int = 0,
+            with_labels: Optional[bool] = True) -> None:
+        """Draw datasample and save to all backends.
+
+        - If GT and prediction are plotted at the same time, they are
+        displayed in a stitched image where the left image is the
+        ground truth and the right image is the prediction.
+        - If ``show`` is True, all storage backends are ignored, and
+        the images will be displayed in a local window.
+        - If ``out_file`` is specified, the drawn image will be
+        saved to ``out_file``. it is usually used when the display
+        is not available.
+
+        Args:
+            name (str): The image identifier.
+            image (np.ndarray): The image to draw.
+            gt_sample (:obj:`SegDataSample`, optional): GT SegDataSample.
+                Defaults to None.
+            pred_sample (:obj:`SegDataSample`, optional): Prediction
+                SegDataSample. Defaults to None.
+            draw_gt (bool): Whether to draw GT SegDataSample. Default to True.
+            draw_pred (bool): Whether to draw Prediction SegDataSample.
+                Defaults to True.
+            show (bool): Whether to display the drawn image. Default to False.
+            wait_time (float): The interval of show (s). Defaults to 0.
+            out_file (str): Path to output file. Defaults to None.
+            step (int): Global step value to record. Defaults to 0.
+            with_labels(bool, optional): Add semantic labels in visualization
+                result, Defaults to True.
+        """
+        classes = self.dataset_meta.get('classes', None)
+        palette = self.dataset_meta.get('palette', None)
+
+        gt_img_data = None
+        pred_img_data = None
+
+        if draw_gt and data_sample is not None:
+            if 'gt_sem_seg' in data_sample:
+                assert classes is not None, 'class information is ' \
+                                            'not provided when ' \
+                                            'visualizing semantic ' \
+                                            'segmentation results.'
+                gt_img_data = self._draw_sem_seg(image, data_sample.gt_sem_seg,
+                                                 classes, palette, with_labels)
+
+            if 'gt_depth_map' in data_sample:
+                gt_img_data = gt_img_data if gt_img_data is not None else image
+                gt_img_data = self._draw_depth_map(gt_img_data,
+                                                   data_sample.gt_depth_map)
+
+        if draw_pred and data_sample is not None:
+
+            if 'pred_sem_seg' in data_sample:
+
+                assert classes is not None, 'class information is ' \
+                                            'not provided when ' \
+                                            'visualizing semantic ' \
+                                            'segmentation results.'
+                pred_img_data = self._draw_sem_seg(image,
+                                                   data_sample.pred_sem_seg,
+                                                   classes, palette,
+                                                   with_labels)
+
+            if 'pred_depth_map' in data_sample:
+                pred_img_data = pred_img_data if pred_img_data is not None \
+                    else image
+                pred_img_data = self._draw_depth_map(
+                    pred_img_data, data_sample.pred_depth_map)
+
+        if gt_img_data is not None and pred_img_data is not None:
+            drawn_img = np.concatenate((gt_img_data, pred_img_data), axis=1)
+        elif gt_img_data is not None:
+            drawn_img = gt_img_data
+        else:
+            drawn_img = pred_img_data
+
+        if show:
+            self.show(drawn_img, win_name=name, wait_time=wait_time)
+
+        if out_file is not None:
+            mmcv.imwrite(mmcv.rgb2bgr(drawn_img), out_file)
+        else:
+            self.add_image(name, drawn_img, step)
diff --git a/mmsegmentation/model-index.yml b/mmsegmentation/model-index.yml
new file mode 100644
index 0000000..4026bb9
--- /dev/null
+++ b/mmsegmentation/model-index.yml
@@ -0,0 +1,53 @@
+Import:
+- configs/ann/metafile.yaml
+- configs/apcnet/metafile.yaml
+- configs/beit/metafile.yaml
+- configs/bisenetv1/metafile.yaml
+- configs/bisenetv2/metafile.yaml
+- configs/ccnet/metafile.yaml
+- configs/cgnet/metafile.yaml
+- configs/convnext/metafile.yaml
+- configs/danet/metafile.yaml
+- configs/ddrnet/metafile.yaml
+- configs/deeplabv3/metafile.yaml
+- configs/deeplabv3plus/metafile.yaml
+- configs/dmnet/metafile.yaml
+- configs/dnlnet/metafile.yaml
+- configs/dpt/metafile.yaml
+- configs/emanet/metafile.yaml
+- configs/encnet/metafile.yaml
+- configs/erfnet/metafile.yaml
+- configs/fastfcn/metafile.yaml
+- configs/fastscnn/metafile.yaml
+- configs/fcn/metafile.yaml
+- configs/gcnet/metafile.yaml
+- configs/hrnet/metafile.yaml
+- configs/icnet/metafile.yaml
+- configs/isanet/metafile.yaml
+- configs/knet/metafile.yaml
+- configs/mae/metafile.yaml
+- configs/mask2former/metafile.yaml
+- configs/maskformer/metafile.yaml
+- configs/mobilenet_v2/metafile.yaml
+- configs/mobilenet_v3/metafile.yaml
+- configs/nonlocal_net/metafile.yaml
+- configs/ocrnet/metafile.yaml
+- configs/pidnet/metafile.yaml
+- configs/point_rend/metafile.yaml
+- configs/poolformer/metafile.yaml
+- configs/psanet/metafile.yaml
+- configs/pspnet/metafile.yaml
+- configs/resnest/metafile.yaml
+- configs/san/metafile.yaml
+- configs/segformer/metafile.yaml
+- configs/segmenter/metafile.yaml
+- configs/segnext/metafile.yaml
+- configs/sem_fpn/metafile.yaml
+- configs/setr/metafile.yaml
+- configs/stdc/metafile.yaml
+- configs/swin/metafile.yaml
+- configs/twins/metafile.yaml
+- configs/unet/metafile.yaml
+- configs/upernet/metafile.yaml
+- configs/vit/metafile.yaml
+- configs/vpd/metafile.yaml
diff --git a/mmsegmentation/nohup.out b/mmsegmentation/nohup.out
new file mode 100644
index 0000000..5856e6a
--- /dev/null
+++ b/mmsegmentation/nohup.out
@@ -0,0 +1,2216 @@
+/bin/sh: 1: gcc: not found
+11/14 21:28:56 - mmengine - INFO - 
+------------------------------------------------------------
+System environment:
+    sys.platform: linux
+    Python: 3.10.13 (main, Sep 11 2023, 13:44:35) [GCC 11.2.0]
+    CUDA available: True
+    MUSA available: False
+    numpy_random_seed: 586206344
+    GPU 0: Tesla V100-SXM2-32GB
+    CUDA_HOME: None
+    GCC: n/a
+    PyTorch: 2.1.0
+    PyTorch compiling details: PyTorch built with:
+  - GCC 9.3
+  - C++ Version: 201703
+  - Intel(R) oneAPI Math Kernel Library Version 2023.1-Product Build 20230303 for Intel(R) 64 architecture applications
+  - Intel(R) MKL-DNN v3.1.1 (Git Hash 64f6bcbcbab628e96f33a62c3e975f8535a7bde4)
+  - OpenMP 201511 (a.k.a. OpenMP 4.5)
+  - LAPACK is enabled (usually provided by MKL)
+  - NNPACK is enabled
+  - CPU capability usage: AVX512
+  - CUDA Runtime 11.8
+  - NVCC architecture flags: -gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_61,code=sm_61;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_37,code=compute_37
+  - CuDNN 8.7
+  - Magma 2.6.1
+  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, CUDA_VERSION=11.8, CUDNN_VERSION=8.7.0, CXX_COMPILER=/opt/rh/devtoolset-9/root/usr/bin/c++, CXX_FLAGS= -D_GLIBCXX_USE_CXX11_ABI=0 -fabi-version=11 -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-unused-parameter -Wno-unused-function -Wno-unused-result -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=old-style-cast -Wno-invalid-partial-specialization -Wno-unused-private-field -Wno-aligned-allocation-unavailable -Wno-missing-braces -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Werror=cast-function-type -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, TORCH_DISABLE_GPU_ASSERTS=ON, TORCH_VERSION=2.1.0, USE_CUDA=ON, USE_CUDNN=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, 
+
+    TorchVision: 0.16.0
+    OpenCV: 4.10.0
+    MMEngine: 0.10.5
+
+Runtime environment:
+    cudnn_benchmark: True
+    mp_cfg: {'mp_start_method': 'fork', 'opencv_num_threads': 0}
+    dist_cfg: {'backend': 'nccl'}
+    seed: 586206344
+    Distributed launcher: none
+    Distributed training: False
+    GPU number: 1
+------------------------------------------------------------
+
+11/14 21:28:57 - mmengine - INFO - Config:
+auto_scale_lr = dict(base_batch_size=16, enable=False)
+backbone_embed_multi = dict(decay_mult=0.0, lr_mult=0.1)
+backbone_norm_multi = dict(decay_mult=0.0, lr_mult=0.1)
+crop_size = (
+    1536,
+    1536,
+)
+custom_keys = dict({
+    'absolute_pos_embed':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone':
+    dict(decay_mult=1.0, lr_mult=0.1),
+    'backbone.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.patch_embed.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.0.blocks.0.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.0.blocks.1.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.0.downsample.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.1.blocks.0.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.1.blocks.1.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.1.downsample.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.2.blocks.0.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.2.blocks.1.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.2.blocks.10.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.2.blocks.11.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.2.blocks.12.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.2.blocks.13.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.2.blocks.14.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.2.blocks.15.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.2.blocks.16.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.2.blocks.17.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.2.blocks.2.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.2.blocks.3.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.2.blocks.4.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.2.blocks.5.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.2.blocks.6.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.2.blocks.7.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.2.blocks.8.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.2.blocks.9.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.2.downsample.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.3.blocks.0.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'backbone.stages.3.blocks.1.norm':
+    dict(decay_mult=0.0, lr_mult=0.1),
+    'level_embed':
+    dict(decay_mult=0.0, lr_mult=1.0),
+    'query_embed':
+    dict(decay_mult=0.0, lr_mult=1.0),
+    'query_feat':
+    dict(decay_mult=0.0, lr_mult=1.0),
+    'relative_position_bias_table':
+    dict(decay_mult=0.0, lr_mult=0.1)
+})
+data_preprocessor = dict(
+    bgr_to_rgb=True,
+    mean=[
+        123.675,
+        116.28,
+        103.53,
+    ],
+    pad_val=0,
+    seg_pad_val=255,
+    size=(
+        1536,
+        1536,
+    ),
+    std=[
+        58.395,
+        57.12,
+        57.375,
+    ],
+    test_cfg=dict(size_divisor=32),
+    type='SegDataPreProcessor')
+data_root = '/data/ephemeral/home/cityscapes_format_xlay/'
+dataset_type = 'XRayDataset'
+default_hooks = dict(
+    checkpoint=dict(
+        by_epoch=False,
+        interval=3000,
+        rule='greater',
+        save_best='mDice',
+        type='CheckpointHook'),
+    logger=dict(interval=100, log_metric_by_epoch=False, type='LoggerHook'),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    timer=dict(type='IterTimerHook'),
+    visualization=dict(type='SegVisualizationHook'))
+default_scope = 'mmseg'
+depths = [
+    2,
+    2,
+    18,
+    2,
+]
+embed_multi = dict(decay_mult=0.0, lr_mult=1.0)
+env_cfg = dict(
+    cudnn_benchmark=True,
+    dist_cfg=dict(backend='nccl'),
+    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0))
+fp16 = dict(loss_scale=512.0)
+img_ratios = [
+    0.5,
+    0.75,
+    1.0,
+    1.25,
+    1.5,
+    1.75,
+]
+launcher = 'none'
+load_from = 'https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221202_141901-28ad20f1.pth'
+log_config = dict(
+    hooks=[
+        dict(by_epoch=False, type='TextLoggerHook'),
+        dict(
+            by_epoch=False,
+            init_kwargs=dict(
+                entity='frostings',
+                name='mmsegtest',
+                project='Boost Camp Lv2-3'),
+            interval=1,
+            log_checkpoint=True,
+            log_checkpoint_metadata=True,
+            num_eval_images=10,
+            type='MMSegWandbHook',
+            with_step=False),
+    ],
+    interval=1)
+log_level = 'INFO'
+log_processor = dict(by_epoch=False)
+model = dict(
+    backbone=dict(
+        attn_drop_rate=0.0,
+        depths=[
+            2,
+            2,
+            18,
+            2,
+        ],
+        drop_path_rate=0.3,
+        drop_rate=0.0,
+        embed_dims=192,
+        frozen_stages=-1,
+        init_cfg=dict(
+            checkpoint=
+            'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_large_patch4_window12_384_22k_20220412-6580f57d.pth',
+            type='Pretrained'),
+        mlp_ratio=4,
+        num_heads=[
+            6,
+            12,
+            24,
+            48,
+        ],
+        out_indices=(
+            0,
+            1,
+            2,
+            3,
+        ),
+        patch_norm=True,
+        pretrain_img_size=384,
+        qk_scale=None,
+        qkv_bias=True,
+        type='SwinTransformer',
+        window_size=12,
+        with_cp=False),
+    data_preprocessor=dict(
+        bgr_to_rgb=True,
+        mean=[
+            123.675,
+            116.28,
+            103.53,
+        ],
+        pad_val=0,
+        seg_pad_val=255,
+        size=(
+            1536,
+            1536,
+        ),
+        std=[
+            58.395,
+            57.12,
+            57.375,
+        ],
+        test_cfg=dict(size_divisor=32),
+        type='SegDataPreProcessor'),
+    decode_head=dict(
+        align_corners=False,
+        enforce_decoder_input_project=False,
+        feat_channels=256,
+        in_channels=[
+            192,
+            384,
+            768,
+            1536,
+        ],
+        loss_cls=dict(
+            class_weight=[
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                0.1,
+            ],
+            loss_weight=2.0,
+            reduction='mean',
+            type='mmdet.CrossEntropyLoss',
+            use_sigmoid=False),
+        loss_dice=dict(
+            activate=True,
+            eps=1.0,
+            loss_weight=5.0,
+            naive_dice=True,
+            reduction='mean',
+            type='mmdet.DiceLoss',
+            use_sigmoid=True),
+        loss_mask=dict(
+            loss_weight=5.0,
+            reduction='mean',
+            type='mmdet.CrossEntropyLoss',
+            use_sigmoid=True),
+        num_classes=30,
+        num_queries=100,
+        num_transformer_feat_level=3,
+        out_channels=256,
+        pixel_decoder=dict(
+            act_cfg=dict(type='ReLU'),
+            encoder=dict(
+                init_cfg=None,
+                layer_cfg=dict(
+                    ffn_cfg=dict(
+                        act_cfg=dict(inplace=True, type='ReLU'),
+                        embed_dims=256,
+                        feedforward_channels=1024,
+                        ffn_drop=0.0,
+                        num_fcs=2),
+                    self_attn_cfg=dict(
+                        batch_first=True,
+                        dropout=0.0,
+                        embed_dims=256,
+                        im2col_step=64,
+                        init_cfg=None,
+                        norm_cfg=None,
+                        num_heads=8,
+                        num_levels=3,
+                        num_points=4)),
+                num_layers=6),
+            init_cfg=None,
+            norm_cfg=dict(num_groups=32, type='GN'),
+            num_outs=3,
+            positional_encoding=dict(normalize=True, num_feats=128),
+            type='mmdet.MSDeformAttnPixelDecoder'),
+        positional_encoding=dict(normalize=True, num_feats=128),
+        strides=[
+            4,
+            8,
+            16,
+            32,
+        ],
+        train_cfg=dict(
+            assigner=dict(
+                match_costs=[
+                    dict(type='mmdet.ClassificationCost', weight=2.0),
+                    dict(
+                        type='mmdet.CrossEntropyLossCost',
+                        use_sigmoid=True,
+                        weight=5.0),
+                    dict(
+                        eps=1.0,
+                        pred_act=True,
+                        type='mmdet.DiceCost',
+                        weight=5.0),
+                ],
+                type='mmdet.HungarianAssigner'),
+            importance_sample_ratio=0.75,
+            num_points=12544,
+            oversample_ratio=3.0,
+            sampler=dict(type='mmdet.MaskPseudoSampler')),
+        transformer_decoder=dict(
+            init_cfg=None,
+            layer_cfg=dict(
+                cross_attn_cfg=dict(
+                    attn_drop=0.0,
+                    batch_first=True,
+                    dropout_layer=None,
+                    embed_dims=256,
+                    num_heads=8,
+                    proj_drop=0.0),
+                ffn_cfg=dict(
+                    act_cfg=dict(inplace=True, type='ReLU'),
+                    add_identity=True,
+                    dropout_layer=None,
+                    embed_dims=256,
+                    feedforward_channels=2048,
+                    ffn_drop=0.0,
+                    num_fcs=2),
+                self_attn_cfg=dict(
+                    attn_drop=0.0,
+                    batch_first=True,
+                    dropout_layer=None,
+                    embed_dims=256,
+                    num_heads=8,
+                    proj_drop=0.0)),
+            num_layers=9,
+            return_intermediate=True),
+        type='Mask2FormerHead'),
+    test_cfg=dict(mode='whole'),
+    train_cfg=dict(),
+    type='EncoderDecoder')
+num_classes = 30
+optim_wrapper = dict(
+    clip_grad=dict(max_norm=0.01, norm_type=2),
+    optimizer=dict(
+        betas=(
+            0.9,
+            0.999,
+        ),
+        eps=1e-08,
+        lr=0.0001,
+        type='AdamW',
+        weight_decay=0.05),
+    paramwise_cfg=dict(
+        custom_keys=dict({
+            'absolute_pos_embed':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone':
+            dict(decay_mult=1.0, lr_mult=0.1),
+            'backbone.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.patch_embed.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.0.blocks.0.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.0.blocks.1.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.0.downsample.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.1.blocks.0.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.1.blocks.1.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.1.downsample.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.2.blocks.0.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.2.blocks.1.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.2.blocks.10.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.2.blocks.11.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.2.blocks.12.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.2.blocks.13.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.2.blocks.14.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.2.blocks.15.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.2.blocks.16.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.2.blocks.17.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.2.blocks.2.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.2.blocks.3.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.2.blocks.4.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.2.blocks.5.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.2.blocks.6.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.2.blocks.7.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.2.blocks.8.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.2.blocks.9.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.2.downsample.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.3.blocks.0.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'backbone.stages.3.blocks.1.norm':
+            dict(decay_mult=0.0, lr_mult=0.1),
+            'level_embed':
+            dict(decay_mult=0.0, lr_mult=1.0),
+            'query_embed':
+            dict(decay_mult=0.0, lr_mult=1.0),
+            'query_feat':
+            dict(decay_mult=0.0, lr_mult=1.0),
+            'relative_position_bias_table':
+            dict(decay_mult=0.0, lr_mult=0.1)
+        }),
+        norm_decay_mult=0.0),
+    type='OptimWrapper')
+optimizer = dict(
+    betas=(
+        0.9,
+        0.999,
+    ),
+    eps=1e-08,
+    lr=0.0001,
+    type='AdamW',
+    weight_decay=0.05)
+param_scheduler = [
+    dict(
+        begin=0,
+        by_epoch=False,
+        end=90000,
+        eta_min=0,
+        power=0.9,
+        type='PolyLR'),
+]
+pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_large_patch4_window12_384_22k_20220412-6580f57d.pth'
+resize_size = (
+    1748,
+    1748,
+)
+resume = False
+test_cfg = dict(type='TestLoop')
+test_dataloader = dict(
+    batch_size=1,
+    dataset=dict(
+        data_prefix=dict(img_path='leftImg8bit/test'),
+        data_root='/data/ephemeral/home/cityscapes_format_xlay/',
+        img_suffix='.png',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(keep_ratio=True, scale=(
+                2048,
+                2048,
+            ), type='Resize'),
+            dict(type='PackSegInputs'),
+        ],
+        type='XRayDataset'),
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(shuffle=False, type='DefaultSampler'))
+test_evaluator = dict(
+    save_path='/data/ephemeral/home/submission', type='SubmissionMetric')
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(keep_ratio=True, scale=(
+        2048,
+        2048,
+    ), type='Resize'),
+    dict(type='PackSegInputs'),
+]
+test_size = (
+    2048,
+    2048,
+)
+train_cfg = dict(max_iters=90000, type='IterBasedTrainLoop', val_interval=3000)
+train_dataloader = dict(
+    batch_size=1,
+    dataset=dict(
+        data_prefix=dict(
+            img_path='leftImg8bit/train', seg_map_path='gtFine/train'),
+        data_root='/data/ephemeral/home/cityscapes_format_xlay/',
+        img_suffix='.png',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations'),
+            dict(keep_ratio=True, scale=(
+                1748,
+                1748,
+            ), type='Resize'),
+            dict(
+                cat_max_ratio=0.75,
+                crop_size=(
+                    1536,
+                    1536,
+                ),
+                type='RandomCrop'),
+            dict(prob=0.5, type='RandomFlip'),
+            dict(type='PhotoMetricDistortion'),
+            dict(type='PackSegInputs'),
+        ],
+        seg_map_suffix='_gtFine_labelIds.png',
+        type='XRayDataset'),
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(shuffle=True, type='InfiniteSampler'))
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(keep_ratio=True, scale=(
+        1748,
+        1748,
+    ), type='Resize'),
+    dict(cat_max_ratio=0.75, crop_size=(
+        1536,
+        1536,
+    ), type='RandomCrop'),
+    dict(prob=0.5, type='RandomFlip'),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs'),
+]
+tta_model = dict(type='SegTTAModel')
+tta_pipeline = [
+    dict(backend_args=None, type='LoadImageFromFile'),
+    dict(
+        transforms=[
+            [
+                dict(keep_ratio=True, scale_factor=0.5, type='Resize'),
+                dict(keep_ratio=True, scale_factor=0.75, type='Resize'),
+                dict(keep_ratio=True, scale_factor=1.0, type='Resize'),
+                dict(keep_ratio=True, scale_factor=1.25, type='Resize'),
+                dict(keep_ratio=True, scale_factor=1.5, type='Resize'),
+                dict(keep_ratio=True, scale_factor=1.75, type='Resize'),
+            ],
+            [
+                dict(direction='horizontal', prob=0.0, type='RandomFlip'),
+                dict(direction='horizontal', prob=1.0, type='RandomFlip'),
+            ],
+            [
+                dict(type='PackSegInputs'),
+            ],
+        ],
+        type='TestTimeAug'),
+]
+val_cfg = dict(type='ValLoop')
+val_dataloader = dict(
+    batch_size=1,
+    dataset=dict(
+        data_prefix=dict(
+            img_path='leftImg8bit/val', seg_map_path='gtFine/val'),
+        data_root='/data/ephemeral/home/cityscapes_format_xlay/',
+        img_suffix='.png',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(keep_ratio=True, scale=(
+                2048,
+                2048,
+            ), type='Resize'),
+            dict(type='LoadAnnotations'),
+            dict(type='PackSegInputs'),
+        ],
+        seg_map_suffix='_gtFine_labelIds.png',
+        type='XRayDataset'),
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(shuffle=False, type='DefaultSampler'))
+val_evaluator = dict(type='DiceMetric')
+val_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(keep_ratio=True, scale=(
+        2048,
+        2048,
+    ), type='Resize'),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs'),
+]
+val_save_interval = 3000
+vis_backends = [
+    dict(type='LocalVisBackend'),
+    dict(type='WandbVisBackend'),
+]
+visualizer = dict(
+    name='visualizer',
+    type='SegLocalVisualizer',
+    vis_backends=[
+        dict(type='LocalVisBackend'),
+        dict(type='WandbVisBackend'),
+    ])
+work_dir = '/data/ephemeral/home/parkjunil/mask2former_base_1748_1536'
+
+wandb: Using wandb-core as the SDK backend.  Please refer to https://wandb.me/wandb-core for more information.
+wandb: Currently logged in as: june21a (june21a-chung-ang-university). Use `wandb login --relogin` to force relogin
+wandb: Tracking run with wandb version 0.18.6
+wandb: Run data is saved locally in /data/ephemeral/home/parkjunil/mask2former_base_1748_1536/20241114_212855/vis_data/wandb/run-20241114_212900-v5mxuanf
+wandb: Run `wandb offline` to turn off syncing.
+wandb: Syncing run faithful-wave-6
+wandb: ⭐️ View project at https://wandb.ai/june21a-chung-ang-university/mmsegmentation-tools
+wandb: 🚀 View run at https://wandb.ai/june21a-chung-ang-university/mmsegmentation-tools/runs/v5mxuanf
+/opt/conda/lib/python3.10/site-packages/albumentations/__init__.py:13: UserWarning: A new version of Albumentations is available: 1.4.21 (you have 1.4.18). Upgrade using: pip install -U albumentations. To disable automatic update checks, set the environment variable NO_ALBUMENTATIONS_UPDATE to 1.
+  check_for_updates()
+11/14 21:29:07 - mmengine - INFO - Distributed training is not used, all SyncBatchNorm (SyncBN) layers in the model will be automatically reverted to BatchNormXd layers if they are used.
+/data/ephemeral/home/mmsegmentation/mmseg/engine/hooks/visualization_hook.py:60: UserWarning: The draw is False, it means that the hook for visualization will not take effect. The results will NOT be visualized or stored.
+  warnings.warn('The draw is False, it means that the '
+11/14 21:29:07 - mmengine - INFO - Hooks will be executed in the following order:
+before_run:
+(VERY_HIGH   ) RuntimeInfoHook                    
+(BELOW_NORMAL) LoggerHook                         
+ -------------------- 
+before_train:
+(VERY_HIGH   ) RuntimeInfoHook                    
+(NORMAL      ) IterTimerHook                      
+(VERY_LOW    ) CheckpointHook                     
+ -------------------- 
+before_train_epoch:
+(VERY_HIGH   ) RuntimeInfoHook                    
+(NORMAL      ) IterTimerHook                      
+(NORMAL      ) DistSamplerSeedHook                
+ -------------------- 
+before_train_iter:
+(VERY_HIGH   ) RuntimeInfoHook                    
+(NORMAL      ) IterTimerHook                      
+ -------------------- 
+after_train_iter:
+(VERY_HIGH   ) RuntimeInfoHook                    
+(NORMAL      ) IterTimerHook                      
+(BELOW_NORMAL) LoggerHook                         
+(LOW         ) ParamSchedulerHook                 
+(VERY_LOW    ) CheckpointHook                     
+ -------------------- 
+after_train_epoch:
+(NORMAL      ) IterTimerHook                      
+(LOW         ) ParamSchedulerHook                 
+(VERY_LOW    ) CheckpointHook                     
+ -------------------- 
+before_val:
+(VERY_HIGH   ) RuntimeInfoHook                    
+ -------------------- 
+before_val_epoch:
+(NORMAL      ) IterTimerHook                      
+ -------------------- 
+before_val_iter:
+(NORMAL      ) IterTimerHook                      
+ -------------------- 
+after_val_iter:
+(NORMAL      ) IterTimerHook                      
+(NORMAL      ) SegVisualizationHook               
+(BELOW_NORMAL) LoggerHook                         
+ -------------------- 
+after_val_epoch:
+(VERY_HIGH   ) RuntimeInfoHook                    
+(NORMAL      ) IterTimerHook                      
+(BELOW_NORMAL) LoggerHook                         
+(LOW         ) ParamSchedulerHook                 
+(VERY_LOW    ) CheckpointHook                     
+ -------------------- 
+after_val:
+(VERY_HIGH   ) RuntimeInfoHook                    
+ -------------------- 
+after_train:
+(VERY_HIGH   ) RuntimeInfoHook                    
+(VERY_LOW    ) CheckpointHook                     
+ -------------------- 
+before_test:
+(VERY_HIGH   ) RuntimeInfoHook                    
+ -------------------- 
+before_test_epoch:
+(NORMAL      ) IterTimerHook                      
+ -------------------- 
+before_test_iter:
+(NORMAL      ) IterTimerHook                      
+ -------------------- 
+after_test_iter:
+(NORMAL      ) IterTimerHook                      
+(NORMAL      ) SegVisualizationHook               
+(BELOW_NORMAL) LoggerHook                         
+ -------------------- 
+after_test_epoch:
+(VERY_HIGH   ) RuntimeInfoHook                    
+(NORMAL      ) IterTimerHook                      
+(BELOW_NORMAL) LoggerHook                         
+ -------------------- 
+after_test:
+(VERY_HIGH   ) RuntimeInfoHook                    
+ -------------------- 
+after_run:
+(BELOW_NORMAL) LoggerHook                         
+ -------------------- 
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.projection.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.projection.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.projection.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.projection.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.projection.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.projection.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.projection.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.projection.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.norm.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.norm.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.norm.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.norm.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.norm.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.norm.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.norm.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.norm.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.norm.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.norm.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.norm.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.norm.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.norm.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.norm.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.norm.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.norm.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.reduction.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.reduction.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.reduction.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.reduction.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.norm.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.norm.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.norm.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.norm.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.norm.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.norm.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.norm.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.norm.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.reduction.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.reduction.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.reduction.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.reduction.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.norm.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.norm.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.norm.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.norm.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.norm.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.norm.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.norm.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.norm.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.reduction.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.reduction.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.reduction.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.reduction.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.relative_position_bias_table:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.relative_position_bias_table:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.relative_position_bias_table:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.relative_position_bias_table:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.qkv.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.qkv.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.qkv.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.qkv.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.qkv.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.qkv.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.qkv.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.qkv.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.proj.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.proj.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.proj.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.proj.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.proj.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.proj.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.proj.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.proj.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.0.0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.0.0.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.0.0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.0.0.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.0.0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.0.0.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.0.0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.0.0.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.1.weight:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.1.weight:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.1.bias:weight_decay=0.05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.1.bias:decay_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm0.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm0.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm0.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm0.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm0.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm0.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm0.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm0.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm1.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm1.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm1.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm1.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm1.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm1.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm2.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm2.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm2.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm2.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm2.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm2.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm3.weight:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm3.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm3.weight:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm3.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm3.bias:lr=1e-05
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm3.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm3.bias:lr_mult=0.1
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm3.bias:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.input_convs.0.gn.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.input_convs.0.gn.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.input_convs.1.gn.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.input_convs.1.gn.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.input_convs.2.gn.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.input_convs.2.gn.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.0.norms.0.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.0.norms.0.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.0.norms.1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.0.norms.1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.1.norms.0.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.1.norms.0.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.1.norms.1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.1.norms.1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.2.norms.0.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.2.norms.0.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.2.norms.1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.2.norms.1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.3.norms.0.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.3.norms.0.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.3.norms.1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.3.norms.1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.4.norms.0.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.4.norms.0.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.4.norms.1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.4.norms.1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.5.norms.0.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.5.norms.0.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.5.norms.1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.5.norms.1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.lateral_convs.0.gn.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.lateral_convs.0.gn.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.output_convs.0.gn.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.output_convs.0.gn.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.0.norms.0.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.0.norms.0.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.0.norms.1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.0.norms.1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.0.norms.2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.0.norms.2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.1.norms.0.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.1.norms.0.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.1.norms.1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.1.norms.1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.1.norms.2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.1.norms.2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.2.norms.0.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.2.norms.0.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.2.norms.1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.2.norms.1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.2.norms.2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.2.norms.2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.3.norms.0.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.3.norms.0.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.3.norms.1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.3.norms.1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.3.norms.2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.3.norms.2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.4.norms.0.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.4.norms.0.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.4.norms.1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.4.norms.1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.4.norms.2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.4.norms.2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.5.norms.0.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.5.norms.0.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.5.norms.1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.5.norms.1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.5.norms.2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.5.norms.2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.6.norms.0.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.6.norms.0.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.6.norms.1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.6.norms.1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.6.norms.2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.6.norms.2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.7.norms.0.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.7.norms.0.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.7.norms.1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.7.norms.1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.7.norms.2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.7.norms.2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.8.norms.0.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.8.norms.0.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.8.norms.1.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.8.norms.1.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.8.norms.2.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.8.norms.2.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.post_norm.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.post_norm.bias:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.query_embed.weight:lr=0.0001
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.query_embed.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.query_embed.weight:lr_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.query_embed.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.query_feat.weight:lr=0.0001
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.query_feat.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.query_feat.weight:lr_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.query_feat.weight:decay_mult=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.level_embed.weight:lr=0.0001
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.level_embed.weight:weight_decay=0.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.level_embed.weight:lr_mult=1.0
+11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.level_embed.weight:decay_mult=0.0
+11/14 21:29:09 - mmengine - WARNING - The prefix is not set in metric class DiceMetric.
+Loads checkpoint by http backend from path: https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_large_patch4_window12_384_22k_20220412-6580f57d.pth
+Loads checkpoint by http backend from path: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221202_141901-28ad20f1.pth
+The model and loaded state dict do not match exactly
+
+size mismatch for decode_head.cls_embed.weight: copying a param with shape torch.Size([20, 256]) from checkpoint, the shape in current model is torch.Size([31, 256]).
+size mismatch for decode_head.cls_embed.bias: copying a param with shape torch.Size([20]) from checkpoint, the shape in current model is torch.Size([31]).
+11/14 21:29:11 - mmengine - INFO - Load checkpoint from https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221202_141901-28ad20f1.pth
+11/14 21:29:11 - mmengine - WARNING - "FileClient" will be deprecated in future. Please use io functions in https://mmengine.readthedocs.io/en/latest/api/fileio.html#file-io
+11/14 21:29:11 - mmengine - WARNING - "HardDiskBackend" is the alias of "LocalBackend" and the former will be deprecated in future.
+11/14 21:29:11 - mmengine - INFO - Checkpoints will be saved to /data/ephemeral/home/parkjunil/mask2former_base_1748_1536.
+/opt/conda/lib/python3.10/site-packages/torch/functional.py:504: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at /opt/conda/conda-bld/pytorch_1695392020201/work/aten/src/ATen/native/TensorShape.cpp:3526.)
+  return _VF.meshgrid(tensors, **kwargs)  # type: ignore[attr-defined]
+11/14 21:31:54 - mmengine - INFO - Iter(train) [  100/90000]  base_lr: 9.9901e-05 lr: 9.9901e-06  eta: 1 day, 16:33:54  time: 1.5990  data_time: 0.0178  memory: 28594  grad_norm: 305.1580  loss: 37.3849  decode.loss_cls: 1.7073  decode.loss_mask: 0.1344  decode.loss_dice: 0.9270  decode.d0.loss_cls: 6.4599  decode.d0.loss_mask: 0.1695  decode.d0.loss_dice: 1.5017  decode.d1.loss_cls: 3.7023  decode.d1.loss_mask: 0.1622  decode.d1.loss_dice: 1.1506  decode.d2.loss_cls: 2.6918  decode.d2.loss_mask: 0.1256  decode.d2.loss_dice: 1.0338  decode.d3.loss_cls: 2.2764  decode.d3.loss_mask: 0.1170  decode.d3.loss_dice: 0.8932  decode.d4.loss_cls: 2.0114  decode.d4.loss_mask: 0.1265  decode.d4.loss_dice: 0.9013  decode.d5.loss_cls: 1.9429  decode.d5.loss_mask: 0.1322  decode.d5.loss_dice: 0.9058  decode.d6.loss_cls: 1.8207  decode.d6.loss_mask: 0.1260  decode.d6.loss_dice: 0.8958  decode.d7.loss_cls: 1.7324  decode.d7.loss_mask: 0.1306  decode.d7.loss_dice: 0.9058  decode.d8.loss_cls: 1.6652  decode.d8.loss_mask: 0.1336  decode.d8.loss_dice: 0.9021
+11/14 21:34:34 - mmengine - INFO - Iter(train) [  200/90000]  base_lr: 9.9801e-05 lr: 9.9801e-06  eta: 1 day, 16:17:27  time: 1.6043  data_time: 0.0178  memory: 28552  grad_norm: 139.1402  loss: 14.3850  decode.loss_cls: 0.3627  decode.loss_mask: 0.0540  decode.loss_dice: 0.4288  decode.d0.loss_cls: 5.4133  decode.d0.loss_mask: 0.0604  decode.d0.loss_dice: 0.5897  decode.d1.loss_cls: 0.6901  decode.d1.loss_mask: 0.0603  decode.d1.loss_dice: 0.4657  decode.d2.loss_cls: 0.4056  decode.d2.loss_mask: 0.0563  decode.d2.loss_dice: 0.4811  decode.d3.loss_cls: 0.4355  decode.d3.loss_mask: 0.0544  decode.d3.loss_dice: 0.4227  decode.d4.loss_cls: 0.3797  decode.d4.loss_mask: 0.0569  decode.d4.loss_dice: 0.4430  decode.d5.loss_cls: 0.3940  decode.d5.loss_mask: 0.0556  decode.d5.loss_dice: 0.4528  decode.d6.loss_cls: 0.3936  decode.d6.loss_mask: 0.0548  decode.d6.loss_dice: 0.4532  decode.d7.loss_cls: 0.3870  decode.d7.loss_mask: 0.0567  decode.d7.loss_dice: 0.4517  decode.d8.loss_cls: 0.3207  decode.d8.loss_mask: 0.0563  decode.d8.loss_dice: 0.4482
+11/14 21:37:14 - mmengine - INFO - Iter(train) [  300/90000]  base_lr: 9.9701e-05 lr: 9.9701e-06  eta: 1 day, 16:07:08  time: 1.5979  data_time: 0.0175  memory: 28552  grad_norm: 108.5796  loss: 10.2965  decode.loss_cls: 0.2175  decode.loss_mask: 0.0544  decode.loss_dice: 0.4410  decode.d0.loss_cls: 3.4332  decode.d0.loss_mask: 0.0485  decode.d0.loss_dice: 0.4727  decode.d1.loss_cls: 0.2831  decode.d1.loss_mask: 0.0563  decode.d1.loss_dice: 0.4471  decode.d2.loss_cls: 0.1703  decode.d2.loss_mask: 0.0640  decode.d2.loss_dice: 0.4391  decode.d3.loss_cls: 0.1884  decode.d3.loss_mask: 0.0668  decode.d3.loss_dice: 0.4280  decode.d4.loss_cls: 0.1928  decode.d4.loss_mask: 0.0648  decode.d4.loss_dice: 0.4329  decode.d5.loss_cls: 0.2099  decode.d5.loss_mask: 0.0605  decode.d5.loss_dice: 0.4298  decode.d6.loss_cls: 0.2080  decode.d6.loss_mask: 0.0552  decode.d6.loss_dice: 0.4343  decode.d7.loss_cls: 0.1973  decode.d7.loss_mask: 0.0557  decode.d7.loss_dice: 0.4426  decode.d8.loss_cls: 0.2031  decode.d8.loss_mask: 0.0561  decode.d8.loss_dice: 0.4430
+11/14 21:39:54 - mmengine - INFO - Iter(train) [  400/90000]  base_lr: 9.9601e-05 lr: 9.9601e-06  eta: 1 day, 16:00:23  time: 1.5985  data_time: 0.0177  memory: 28552  grad_norm: 140.5457  loss: 9.6174  decode.loss_cls: 0.2714  decode.loss_mask: 0.0582  decode.loss_dice: 0.4477  decode.d0.loss_cls: 2.0169  decode.d0.loss_mask: 0.0622  decode.d0.loss_dice: 0.5964  decode.d1.loss_cls: 0.2883  decode.d1.loss_mask: 0.0685  decode.d1.loss_dice: 0.5144  decode.d2.loss_cls: 0.2179  decode.d2.loss_mask: 0.0604  decode.d2.loss_dice: 0.5060  decode.d3.loss_cls: 0.2298  decode.d3.loss_mask: 0.0559  decode.d3.loss_dice: 0.4529  decode.d4.loss_cls: 0.2189  decode.d4.loss_mask: 0.0567  decode.d4.loss_dice: 0.4637  decode.d5.loss_cls: 0.2093  decode.d5.loss_mask: 0.0571  decode.d5.loss_dice: 0.4727  decode.d6.loss_cls: 0.2620  decode.d6.loss_mask: 0.0600  decode.d6.loss_dice: 0.4539  decode.d7.loss_cls: 0.2354  decode.d7.loss_mask: 0.0614  decode.d7.loss_dice: 0.4600  decode.d8.loss_cls: 0.2377  decode.d8.loss_mask: 0.0633  decode.d8.loss_dice: 0.4584
+11/14 21:42:34 - mmengine - INFO - Iter(train) [  500/90000]  base_lr: 9.9501e-05 lr: 9.9501e-06  eta: 1 day, 15:54:55  time: 1.5954  data_time: 0.0170  memory: 28552  grad_norm: 37.0008  loss: 5.2917  decode.loss_cls: 0.0460  decode.loss_mask: 0.0408  decode.loss_dice: 0.3249  decode.d0.loss_cls: 1.0061  decode.d0.loss_mask: 0.0421  decode.d0.loss_dice: 0.3511  decode.d1.loss_cls: 0.0856  decode.d1.loss_mask: 0.0433  decode.d1.loss_dice: 0.3465  decode.d2.loss_cls: 0.0669  decode.d2.loss_mask: 0.0411  decode.d2.loss_dice: 0.3340  decode.d3.loss_cls: 0.0478  decode.d3.loss_mask: 0.0427  decode.d3.loss_dice: 0.3442  decode.d4.loss_cls: 0.0357  decode.d4.loss_mask: 0.0421  decode.d4.loss_dice: 0.3434  decode.d5.loss_cls: 0.0388  decode.d5.loss_mask: 0.0418  decode.d5.loss_dice: 0.3501  decode.d6.loss_cls: 0.0374  decode.d6.loss_mask: 0.0410  decode.d6.loss_dice: 0.3282  decode.d7.loss_cls: 0.0376  decode.d7.loss_mask: 0.0424  decode.d7.loss_dice: 0.3410  decode.d8.loss_cls: 0.0670  decode.d8.loss_mask: 0.0414  decode.d8.loss_dice: 0.3405
+11/14 21:45:14 - mmengine - INFO - Iter(train) [  600/90000]  base_lr: 9.9401e-05 lr: 9.9401e-06  eta: 1 day, 15:49:52  time: 1.5952  data_time: 0.0172  memory: 28552  grad_norm: 52.8307  loss: 4.5907  decode.loss_cls: 0.0382  decode.loss_mask: 0.0405  decode.loss_dice: 0.3034  decode.d0.loss_cls: 0.6743  decode.d0.loss_mask: 0.0415  decode.d0.loss_dice: 0.3407  decode.d1.loss_cls: 0.1023  decode.d1.loss_mask: 0.0421  decode.d1.loss_dice: 0.3323  decode.d2.loss_cls: 0.0785  decode.d2.loss_mask: 0.0378  decode.d2.loss_dice: 0.3112  decode.d3.loss_cls: 0.0388  decode.d3.loss_mask: 0.0367  decode.d3.loss_dice: 0.2940  decode.d4.loss_cls: 0.0358  decode.d4.loss_mask: 0.0373  decode.d4.loss_dice: 0.3112  decode.d5.loss_cls: 0.0471  decode.d5.loss_mask: 0.0362  decode.d5.loss_dice: 0.2931  decode.d6.loss_cls: 0.0415  decode.d6.loss_mask: 0.0384  decode.d6.loss_dice: 0.3013  decode.d7.loss_cls: 0.0353  decode.d7.loss_mask: 0.0380  decode.d7.loss_dice: 0.2944  decode.d8.loss_cls: 0.0375  decode.d8.loss_mask: 0.0389  decode.d8.loss_dice: 0.2922
+11/14 21:46:17 - mmengine - INFO - Exp name: mask2former_20241114_212855
+11/14 21:47:53 - mmengine - INFO - Iter(train) [  700/90000]  base_lr: 9.9301e-05 lr: 9.9301e-06  eta: 1 day, 15:45:39  time: 1.5983  data_time: 0.0172  memory: 28552  grad_norm: 23.3135  loss: 4.0187  decode.loss_cls: 0.0280  decode.loss_mask: 0.0343  decode.loss_dice: 0.2815  decode.d0.loss_cls: 0.4558  decode.d0.loss_mask: 0.0355  decode.d0.loss_dice: 0.2945  decode.d1.loss_cls: 0.0485  decode.d1.loss_mask: 0.0348  decode.d1.loss_dice: 0.2924  decode.d2.loss_cls: 0.0629  decode.d2.loss_mask: 0.0361  decode.d2.loss_dice: 0.2880  decode.d3.loss_cls: 0.0411  decode.d3.loss_mask: 0.0348  decode.d3.loss_dice: 0.2779  decode.d4.loss_cls: 0.0184  decode.d4.loss_mask: 0.0358  decode.d4.loss_dice: 0.2872  decode.d5.loss_cls: 0.0197  decode.d5.loss_mask: 0.0351  decode.d5.loss_dice: 0.2766  decode.d6.loss_cls: 0.0346  decode.d6.loss_mask: 0.0348  decode.d6.loss_dice: 0.2810  decode.d7.loss_cls: 0.0356  decode.d7.loss_mask: 0.0348  decode.d7.loss_dice: 0.2891  decode.d8.loss_cls: 0.0675  decode.d8.loss_mask: 0.0355  decode.d8.loss_dice: 0.2872
+11/14 21:50:33 - mmengine - INFO - Iter(train) [  800/90000]  base_lr: 9.9201e-05 lr: 9.9201e-06  eta: 1 day, 15:41:40  time: 1.5919  data_time: 0.0167  memory: 28552  grad_norm: 35.1899  loss: 4.5128  decode.loss_cls: 0.0478  decode.loss_mask: 0.0494  decode.loss_dice: 0.3324  decode.d0.loss_cls: 0.2883  decode.d0.loss_mask: 0.0474  decode.d0.loss_dice: 0.3263  decode.d1.loss_cls: 0.0650  decode.d1.loss_mask: 0.0483  decode.d1.loss_dice: 0.3340  decode.d2.loss_cls: 0.0824  decode.d2.loss_mask: 0.0490  decode.d2.loss_dice: 0.3390  decode.d3.loss_cls: 0.0920  decode.d3.loss_mask: 0.0490  decode.d3.loss_dice: 0.3177  decode.d4.loss_cls: 0.0293  decode.d4.loss_mask: 0.0464  decode.d4.loss_dice: 0.3208  decode.d5.loss_cls: 0.0670  decode.d5.loss_mask: 0.0472  decode.d5.loss_dice: 0.3292  decode.d6.loss_cls: 0.0268  decode.d6.loss_mask: 0.0477  decode.d6.loss_dice: 0.3305  decode.d7.loss_cls: 0.0261  decode.d7.loss_mask: 0.0472  decode.d7.loss_dice: 0.3233  decode.d8.loss_cls: 0.0262  decode.d8.loss_mask: 0.0480  decode.d8.loss_dice: 0.3291
diff --git a/mmsegmentation/projects/Adabins/README.md b/mmsegmentation/projects/Adabins/README.md
new file mode 100644
index 0000000..8a23e92
--- /dev/null
+++ b/mmsegmentation/projects/Adabins/README.md
@@ -0,0 +1,46 @@
+# AdaBins: Depth Estimation Using Adaptive Bins
+
+## Reference
+
+> [AdaBins: Depth Estimation Using Adaptive Bins](https://arxiv.org/abs/2011.14141)
+
+## Introduction
+
+<a href="https://github.com/shariqfarooq123/AdaBins">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/projects/Adabins">Code Snippet</a>
+
+## <img src="https://user-images.githubusercontent.com/34859558/190043857-bfbdaf8b-d2dc-4fff-81c7-e0aac50851f9.png" width="25"/> Abstract
+
+We address the problem of estimating a high quality dense depth map from a single RGB input image. We start out with a baseline encoder-decoder convolutional neural network architecture and pose the question of how the global processing of information can help improve overall depth estimation. To this end, we propose a transformer-based architecture block that divides the depth range into bins whose center value is estimated adaptively per image. The final depth values are estimated as linear combinations of the bin centers. We call our new building block AdaBins. Our results show a decisive improvement over the state-of-the-art on several popular depth datasets across all metrics.We also validate the effectiveness of the proposed block with an ablation study and provide the code and corresponding pre-trained weights of the new state-of-the-art model.
+
+Our main contributions are the following:
+
+- We propose an architecture building block that performs global processing of the scene’s information.We propose to divide the predicted depth range into bins where the bin widths change per image. The final depth estimation is a linear combination of the bin center values.
+- We show a decisive improvement for supervised single image depth estimation across all metrics for the two most popular datasets, NYU and KITTI.
+- We analyze our findings and investigate different modifications on the proposed AdaBins block and study their effect on the accuracy of the depth estimation.
+
+<div align="center">
+<img src="https://github.com/open-mmlab/mmsegmentation/assets/15952744/915bcd5a-9dc2-4602-a6e7-055ff5d4889f"  width = "1000" />
+</div>
+
+## <img src="https://user-images.githubusercontent.com/34859558/190044217-8f6befc2-7f20-473d-b356-148e06265205.png" width="25"/> Performance
+
+### NYU and KITTI
+
+| Model         | Encoder         | Training epoch | Batchsize | Train Resolution | δ1    | δ2    | δ3    | REL   | RMS   | RMS log | params(M) | Links                                                                                                                   |
+| ------------- | --------------- | -------------- | --------- | ---------------- | ----- | ----- | ----- | ----- | ----- | ------- | --------- | ----------------------------------------------------------------------------------------------------------------------- |
+| AdaBins_nyu   | EfficientNet-B5 | 25             | 16        | 416x544          | 0.903 | 0.984 | 0.997 | 0.103 | 0.364 | 0.044   | 78        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/adabins/adabins_efficient_b5_nyu_third-party-f68d6bd3.pth)   |
+| AdaBins_kitti | EfficientNet-B5 | 25             | 16        | 352x764          | 0.964 | 0.995 | 0.999 | 0.058 | 2.360 | 0.088   | 78        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/adabins/adabins_efficient-b5_kitty_third-party-a1aa6f36.pth) |
+
+## Citation
+
+```bibtex
+@article{10.1109/cvpr46437.2021.00400,
+    author = {Bhat, S. A. and Alhashim, I. and Wonka, P.},
+    title = {Adabins: depth estimation using adaptive bins},
+    journal = {2021 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
+    year = {2021},
+    doi = {10.1109/cvpr46437.2021.00400}
+}
+```
diff --git a/mmsegmentation/projects/Adabins/backbones/__init__.py b/mmsegmentation/projects/Adabins/backbones/__init__.py
new file mode 100644
index 0000000..04ae180
--- /dev/null
+++ b/mmsegmentation/projects/Adabins/backbones/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .adabins_backbone import AdabinsBackbone
+
+__all__ = ['AdabinsBackbone']
diff --git a/mmsegmentation/projects/Adabins/backbones/adabins_backbone.py b/mmsegmentation/projects/Adabins/backbones/adabins_backbone.py
new file mode 100644
index 0000000..07d7380
--- /dev/null
+++ b/mmsegmentation/projects/Adabins/backbones/adabins_backbone.py
@@ -0,0 +1,141 @@
+import timm
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule, build_conv_layer
+from mmengine.model import BaseModule
+
+from mmseg.registry import MODELS
+
+
+class UpSampleBN(nn.Module):
+    """ UpSample module
+    Args:
+        skip_input (int): the input feature
+        output_features (int): the output feature
+        norm_cfg (dict, optional): Config dict for normalization layer.
+            Default: dict(type='BN', requires_grad=True).
+        act_cfg (dict, optional): The activation layer of AAM:
+            Aggregate Attention Module.
+    """
+
+    def __init__(self,
+                 skip_input,
+                 output_features,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='LeakyReLU')):
+        super().__init__()
+
+        self._net = nn.Sequential(
+            ConvModule(
+                in_channels=skip_input,
+                out_channels=output_features,
+                kernel_size=3,
+                stride=1,
+                padding=1,
+                bias=True,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg,
+            ),
+            ConvModule(
+                in_channels=output_features,
+                out_channels=output_features,
+                kernel_size=3,
+                stride=1,
+                padding=1,
+                bias=True,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg,
+            ))
+
+    def forward(self, x, concat_with):
+        up_x = F.interpolate(
+            x,
+            size=[concat_with.size(2),
+                  concat_with.size(3)],
+            mode='bilinear',
+            align_corners=True)
+        f = torch.cat([up_x, concat_with], dim=1)
+        return self._net(f)
+
+
+class Encoder(nn.Module):
+    """ the efficientnet_b5 model
+    Args:
+        basemodel_name (str): the name of base model
+    """
+
+    def __init__(self, basemodel_name):
+        super().__init__()
+        self.original_model = timm.create_model(
+            basemodel_name, pretrained=True)
+        # Remove last layer
+        self.original_model.global_pool = nn.Identity()
+        self.original_model.classifier = nn.Identity()
+
+    def forward(self, x):
+        features = [x]
+        for k, v in self.original_model._modules.items():
+            if k == 'blocks':
+                for ki, vi in v._modules.items():
+                    features.append(vi(features[-1]))
+            else:
+                features.append(v(features[-1]))
+        return features
+
+
+@MODELS.register_module()
+class AdabinsBackbone(BaseModule):
+    """ the backbone of the adabins
+    Args:
+        basemodel_name (str):the name of base model
+        num_features (int): the middle feature
+        num_classes (int): the classes number
+        bottleneck_features (int): the bottleneck features
+        conv_cfg (dict): Config dict for convolution layer.
+    """
+
+    def __init__(self,
+                 basemodel_name,
+                 num_features=2048,
+                 num_classes=128,
+                 bottleneck_features=2048,
+                 conv_cfg=dict(type='Conv')):
+        super().__init__()
+        self.encoder = Encoder(basemodel_name)
+        features = int(num_features)
+        self.conv2 = build_conv_layer(
+            conv_cfg,
+            bottleneck_features,
+            features,
+            kernel_size=1,
+            stride=1,
+            padding=1)
+        self.up1 = UpSampleBN(
+            skip_input=features // 1 + 112 + 64, output_features=features // 2)
+        self.up2 = UpSampleBN(
+            skip_input=features // 2 + 40 + 24, output_features=features // 4)
+        self.up3 = UpSampleBN(
+            skip_input=features // 4 + 24 + 16, output_features=features // 8)
+        self.up4 = UpSampleBN(
+            skip_input=features // 8 + 16 + 8, output_features=features // 16)
+
+        self.conv3 = build_conv_layer(
+            conv_cfg,
+            features // 16,
+            num_classes,
+            kernel_size=3,
+            stride=1,
+            padding=1)
+
+    def forward(self, x):
+        features = self.encoder(x)
+        x_block0, x_block1, x_block2, x_block3, x_block4 = features[
+            3], features[4], features[5], features[7], features[10]
+        x_d0 = self.conv2(x_block4)
+        x_d1 = self.up1(x_d0, x_block3)
+        x_d2 = self.up2(x_d1, x_block2)
+        x_d3 = self.up3(x_d2, x_block1)
+        x_d4 = self.up4(x_d3, x_block0)
+        out = self.conv3(x_d4)
+        return out
diff --git a/mmsegmentation/projects/Adabins/configs/_base_/datasets/nyu.py b/mmsegmentation/projects/Adabins/configs/_base_/datasets/nyu.py
new file mode 100644
index 0000000..1b49ec7
--- /dev/null
+++ b/mmsegmentation/projects/Adabins/configs/_base_/datasets/nyu.py
@@ -0,0 +1,32 @@
+dataset_type = 'NYUDataset'
+data_root = 'data/nyu'
+
+test_pipeline = [
+    dict(dict(type='LoadImageFromFile', to_float32=True)),
+    dict(dict(type='LoadDepthAnnotation', depth_rescale_factor=1e-3)),
+    dict(
+        type='PackSegInputs',
+        meta_keys=('img_path', 'depth_map_path', 'ori_shape', 'img_shape',
+                   'pad_shape', 'scale_factor', 'flip', 'flip_direction',
+                   'category_id'))
+]
+
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        test_mode=True,
+        data_prefix=dict(
+            img_path='images/test', depth_map_path='annotations/test'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(
+    type='DepthMetric', max_depth_eval=10.0, crop_type='nyu_crop')
+test_evaluator = val_evaluator
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
diff --git a/mmsegmentation/projects/Adabins/configs/_base_/default_runtime.py b/mmsegmentation/projects/Adabins/configs/_base_/default_runtime.py
new file mode 100644
index 0000000..272b4d2
--- /dev/null
+++ b/mmsegmentation/projects/Adabins/configs/_base_/default_runtime.py
@@ -0,0 +1,15 @@
+default_scope = 'mmseg'
+env_cfg = dict(
+    cudnn_benchmark=True,
+    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+    dist_cfg=dict(backend='nccl'),
+)
+vis_backends = [dict(type='LocalVisBackend')]
+visualizer = dict(
+    type='SegLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+log_processor = dict(by_epoch=False)
+log_level = 'INFO'
+load_from = None
+resume = False
+
+tta_model = dict(type='SegTTAModel')
diff --git a/mmsegmentation/projects/Adabins/configs/_base_/models/Adabins.py b/mmsegmentation/projects/Adabins/configs/_base_/models/Adabins.py
new file mode 100644
index 0000000..35cbd8c
--- /dev/null
+++ b/mmsegmentation/projects/Adabins/configs/_base_/models/Adabins.py
@@ -0,0 +1,35 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='DepthEstimator',
+    data_preprocessor=data_preprocessor,
+    # pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='AdabinsBackbone',
+        basemodel_name='tf_efficientnet_b5_ap',
+        num_features=2048,
+        num_classes=128,
+        bottleneck_features=2048,
+    ),
+    decode_head=dict(
+        type='AdabinsHead',
+        in_channels=128,
+        n_query_channels=128,
+        patch_size=16,
+        embedding_dim=128,
+        num_heads=4,
+        n_bins=256,
+        min_val=0.001,
+        max_val=10,
+        norm='linear'),
+
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/projects/Adabins/configs/adabins/adabins_efficient_b5_4x16_25e_NYU_416x544.py b/mmsegmentation/projects/Adabins/configs/adabins/adabins_efficient_b5_4x16_25e_NYU_416x544.py
new file mode 100644
index 0000000..5c00ea1
--- /dev/null
+++ b/mmsegmentation/projects/Adabins/configs/adabins/adabins_efficient_b5_4x16_25e_NYU_416x544.py
@@ -0,0 +1,15 @@
+_base_ = [
+    '../_base_/models/Adabins.py', '../_base_/datasets/nyu.py',
+    '../_base_/default_runtime.py'
+]
+custom_imports = dict(
+    imports=['projects.Adabins.backbones', 'projects.Adabins.decode_head'],
+    allow_failed_imports=False)
+crop_size = (416, 544)
+data_preprocessor = dict(size=crop_size)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(),
+    decode_head=dict(),
+)
diff --git a/mmsegmentation/projects/Adabins/configs/adabins/adabins_efficient_b5_4x16_25e_kitti_352x704.py b/mmsegmentation/projects/Adabins/configs/adabins/adabins_efficient_b5_4x16_25e_kitti_352x704.py
new file mode 100644
index 0000000..330cdf4
--- /dev/null
+++ b/mmsegmentation/projects/Adabins/configs/adabins/adabins_efficient_b5_4x16_25e_kitti_352x704.py
@@ -0,0 +1,12 @@
+_base_ = ['../_base_/models/Adabins.py']
+custom_imports = dict(
+    imports=['projects.Adabins.backbones', 'projects.Adabins.decode_head'],
+    allow_failed_imports=False)
+crop_size = (352, 704)
+data_preprocessor = dict(size=crop_size)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(),
+    decode_head=dict(min_val=0.001, max_val=80),
+)
diff --git a/mmsegmentation/projects/Adabins/decode_head/__init__.py b/mmsegmentation/projects/Adabins/decode_head/__init__.py
new file mode 100644
index 0000000..c7d62df
--- /dev/null
+++ b/mmsegmentation/projects/Adabins/decode_head/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .adabins_head import AdabinsHead
+
+__all__ = ['AdabinsHead']
diff --git a/mmsegmentation/projects/Adabins/decode_head/adabins_head.py b/mmsegmentation/projects/Adabins/decode_head/adabins_head.py
new file mode 100644
index 0000000..ee04317
--- /dev/null
+++ b/mmsegmentation/projects/Adabins/decode_head/adabins_head.py
@@ -0,0 +1,179 @@
+from typing import List, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import build_conv_layer
+from torch import Tensor
+
+from mmseg.registry import MODELS
+
+
+class PatchTransformerEncoder(nn.Module):
+    """the Patch Transformer Encoder.
+
+    Args:
+        in_channels (int): the channels of input
+        patch_size (int): the path size
+        embedding_dim (int): The feature dimension.
+        num_heads (int): the number of encoder head
+        conv_cfg (dict): Config dict for convolution layer.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 patch_size=10,
+                 embedding_dim=128,
+                 num_heads=4,
+                 conv_cfg=dict(type='Conv')):
+        super().__init__()
+        encoder_layers = nn.TransformerEncoderLayer(
+            embedding_dim, num_heads, dim_feedforward=1024)
+        self.transformer_encoder = nn.TransformerEncoder(
+            encoder_layers, num_layers=4)  # takes shape S,N,E
+
+        self.embedding_convPxP = build_conv_layer(
+            conv_cfg,
+            in_channels,
+            embedding_dim,
+            kernel_size=patch_size,
+            stride=patch_size)
+        self.positional_encodings = nn.Parameter(
+            torch.rand(500, embedding_dim), requires_grad=True)
+
+    def forward(self, x):
+        embeddings = self.embedding_convPxP(x).flatten(
+            2)  # .shape = n,c,s = n, embedding_dim, s
+        embeddings = embeddings + self.positional_encodings[:embeddings.shape[
+            2], :].T.unsqueeze(0)
+
+        # change to S,N,E format required by transformer
+        embeddings = embeddings.permute(2, 0, 1)
+        x = self.transformer_encoder(embeddings)  # .shape = S, N, E
+        return x
+
+
+class PixelWiseDotProduct(nn.Module):
+    """the pixel wise dot product."""
+
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x, K):
+        n, c, h, w = x.size()
+        _, cout, ck = K.size()
+        assert c == ck, 'Number of channels in x and Embedding dimension ' \
+                        '(at dim 2) of K matrix must match'
+        y = torch.matmul(
+            x.view(n, c, h * w).permute(0, 2, 1),
+            K.permute(0, 2, 1))  # .shape = n, hw, cout
+        return y.permute(0, 2, 1).view(n, cout, h, w)
+
+
+@MODELS.register_module()
+class AdabinsHead(nn.Module):
+    """the head of the adabins,include mViT.
+
+    Args:
+        in_channels (int):the channels of the input
+        n_query_channels (int):the channels of the query
+        patch_size (int): the patch size
+        embedding_dim (int):The feature dimension.
+        num_heads (int):the number of head
+        n_bins (int):the number of bins
+        min_val (float): the min width of bin
+        max_val (float): the max width of bin
+        conv_cfg (dict): Config dict for convolution layer.
+        norm (str): the activate method
+        align_corners (bool, optional): Geometrically, we consider the pixels
+            of the input and output as squares rather than points.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 n_query_channels=128,
+                 patch_size=16,
+                 embedding_dim=128,
+                 num_heads=4,
+                 n_bins=100,
+                 min_val=0.1,
+                 max_val=10,
+                 conv_cfg=dict(type='Conv'),
+                 norm='linear',
+                 align_corners=False,
+                 threshold=0):
+        super().__init__()
+        self.out_channels = n_bins
+        self.align_corners = align_corners
+        self.norm = norm
+        self.num_classes = n_bins
+        self.min_val = min_val
+        self.max_val = max_val
+        self.n_query_channels = n_query_channels
+        self.patch_transformer = PatchTransformerEncoder(
+            in_channels, patch_size, embedding_dim, num_heads)
+        self.dot_product_layer = PixelWiseDotProduct()
+        self.threshold = threshold
+        self.conv3x3 = build_conv_layer(
+            conv_cfg,
+            in_channels,
+            embedding_dim,
+            kernel_size=3,
+            stride=1,
+            padding=1)
+        self.regressor = nn.Sequential(
+            nn.Linear(embedding_dim, 256), nn.LeakyReLU(), nn.Linear(256, 256),
+            nn.LeakyReLU(), nn.Linear(256, n_bins))
+        self.conv_out = nn.Sequential(
+            build_conv_layer(conv_cfg, in_channels, n_bins, kernel_size=1),
+            nn.Softmax(dim=1))
+
+    def forward(self, x):
+        # n, c, h, w = x.size()
+        tgt = self.patch_transformer(x.clone())  # .shape = S, N, E
+
+        x = self.conv3x3(x)
+
+        regression_head, queries = tgt[0,
+                                       ...], tgt[1:self.n_query_channels + 1,
+                                                 ...]
+
+        # Change from S, N, E to N, S, E
+        queries = queries.permute(1, 0, 2)
+        range_attention_maps = self.dot_product_layer(
+            x, queries)  # .shape = n, n_query_channels, h, w
+
+        y = self.regressor(regression_head)  # .shape = N, dim_out
+        if self.norm == 'linear':
+            y = torch.relu(y)
+            eps = 0.1
+            y = y + eps
+        elif self.norm == 'softmax':
+            return torch.softmax(y, dim=1), range_attention_maps
+        else:
+            y = torch.sigmoid(y)
+        bin_widths_normed = y / y.sum(dim=1, keepdim=True)
+        out = self.conv_out(range_attention_maps)
+
+        bin_widths = (self.max_val -
+                      self.min_val) * bin_widths_normed  # .shape = N, dim_out
+        bin_widths = F.pad(
+            bin_widths, (1, 0), mode='constant', value=self.min_val)
+        bin_edges = torch.cumsum(bin_widths, dim=1)
+
+        centers = 0.5 * (bin_edges[:, :-1] + bin_edges[:, 1:])
+        n, dim_out = centers.size()
+        centers = centers.view(n, dim_out, 1, 1)
+
+        pred = torch.sum(out * centers, dim=1, keepdim=True)
+        return bin_edges, pred
+
+    def predict(self, inputs: Tuple[Tensor], batch_img_metas: List[dict],
+                test_cfg, **kwargs) -> Tensor:
+        """Forward function for testing, only ``pam_cam`` is used."""
+        pred = self.forward(inputs)[-1]
+        final = torch.clamp(pred, self.min_val, self.max_val)
+
+        final[torch.isinf(final)] = self.max_val
+        final[torch.isnan(final)] = self.min_val
+        return final
diff --git a/mmsegmentation/projects/CAT-Seg/README.md b/mmsegmentation/projects/CAT-Seg/README.md
new file mode 100644
index 0000000..890e461
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/README.md
@@ -0,0 +1,92 @@
+# CAT-Seg
+
+> [CAT-Seg: Cost Aggregation for Open-Vocabulary Semantic Segmentation](https://arxiv.org/abs/2303.11797)
+
+## Introduction
+
+<!-- [ALGORITHM] -->
+
+<a href="https://github.com/KU-CVLAB/CAT-Seg">Official Repo</a>
+
+<a href="https://github.com/SheffieldCao/mmsegmentation/blob/support-cat-seg/mmseg/models/necks/cat_aggregator.py">Code Snippet</a>
+
+## Abstract
+
+<!-- [ABSTRACT] -->
+
+Existing works on open-vocabulary semantic segmentation have utilized large-scale vision-language models, such as CLIP, to leverage their exceptional open-vocabulary recognition capabilities. However, the problem of transferring these capabilities learned from image-level supervision to the pixel-level task of segmentation and addressing arbitrary unseen categories at inference makes this task challenging. To address these issues, we aim to attentively relate objects within an image to given categories by leveraging relational information among class categories and visual semantics through aggregation, while also adapting the CLIP representations to the pixel-level task. However, we observe that direct optimization of the CLIP embeddings can harm its open-vocabulary capabilities. In this regard, we propose an alternative approach to optimize the imagetext similarity map, i.e. the cost map, using a novel cost aggregation-based method. Our framework, namely CATSeg, achieves state-of-the-art performance across all benchmarks. We provide extensive ablation studies to validate our choices. [Project page](https://ku-cvlab.github.io/CAT-Seg).
+
+<!-- [IMAGE] -->
+
+<div align=center >
+<img alt="CAT-Seg" src="https://github.com/open-mmlab/mmsegmentation/assets/49406546/d54674bb-52ae-4a20-a168-e25d041111e8"/>
+CAT-Seg model structure
+</div>
+
+## Usage
+
+CAT-Seg model training needs pretrained `CLIP` model. We have implemented `ViT-B` and `ViT-L` based `CLIP` model. To further use `ViT-bigG` or `ViT-H` ones, you need additional dependencies. Please install [open_clip](https://github.com/mlfoundations/open_clip) first. The pretrained `CLIP` model state dicts are loaded from [Huggingface-OpenCLIP](https://huggingface.co/models?library=open_clip). **If you come up with `ConnectionError` when downloading CLIP weights**, you can manually download them from the given repo and use `custom_clip_weights=/path/to/you/folder` of backbone in config file. Related tools are as shown in [requirements/optional.txt](requirements/optional.txt):
+
+```shell
+pip install ftfy==6.0.1
+pip install huggingface-hub
+pip install regex
+```
+
+In addition to the necessary [data preparation](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md), you also need class texts for clip text encoder. Please download the class text json file first [cls_texts](https://github.com/open-mmlab/mmsegmentation/files/11714914/cls_texts.zip) and arrange the folder as follows:
+
+```none
+mmsegmentation
+├── mmseg
+├── tools
+├── configs
+├── data
+│   ├── VOCdevkit
+│   │   ├── VOC2012
+│   │   ├── VOC2010
+│   │   ├── VOCaug
+│   ├── ade
+│   ├── coco_stuff164k
+│   ├── coco.json
+│   ├── pc59.json
+│   ├── pc459.json
+│   ├── ade150.json
+│   ├── ade847.json
+│   ├── voc20b.json
+│   ├── voc20.json
+```
+
+```shell
+# setup PYTHONPATH
+export PYTHONPATH=`pwd`:$PYTHONPATH
+# run evaluation
+mim test mmsegmentation ${CONFIG} --checkpoint ${CHECKPOINT} --launcher pytorch --gpus=8
+```
+
+## Results and models
+
+### ADE20K-150-ZeroShot
+
+| Method  | Backbone      | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device  | mIoU | mIoU(ms+flip) |                                                                                      config | download                                                                                                                                      |
+| ------- | ------------- | --------- | ------- | -------: | -------------- | ------- | ---- | ------------: | ------------------------------------------------------------------------------------------: | --------------------------------------------------------------------------------------------------------------------------------------------- |
+| CAT-Seg | R-101 & ViT-B | 384x384   | 80000   |        - | -              | RTX3090 | 27.2 |             - | [config](./configs/cat_seg/catseg_vitb-r101_4xb1-warmcoslr2e-4-adamw-80k_ade20k-384x384.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/cat_seg/catseg_vitb-r101_4xb1-warmcoslr2e-4-adamw-80k_ade20k-384x384-54194d72.pth) |
+
+Note:
+
+- All experiments of CAT-Seg are implemented with 4 RTX3090 GPUs, except the last one with pretrained ViT-bigG CLIP model (GPU Memory insufficient, you may need A100).
+- Due to the feature size bottleneck of the CLIP image encoder, the inference and testing can only be done under `slide` mode, the inference time is longer since the test size is much more bigger that training size of `(384, 384)`.
+- The ResNet backbones utilized in CAT-Seg models are standard `ResNet` rather than `ResNetV1c`.
+- The zero-shot segmentation results on PASCAL VOC and ADE20K are from the original paper. Our results are coming soon. We appreatiate your contribution!
+- In additional to zero-shot segmentation performance results, we also provided the evaluation results on the `val2017` set of **COCO-stuff164k** for reference, which is the training dataset of CAT-Seg. The testing was done **without TTA**.
+- The number behind the dataset name is the category number for segmentation evaluation (except training data **COCO-stuff 164k**). **PASCAL VOC-20b** defines the "background" as classes present in **PASCAL-Context-59** but not in **PASCAL VOC-20**.
+
+## Citation
+
+```bibtex
+@inproceedings{cheng2021mask2former,
+  title={CAT-Seg: Cost Aggregation for Open-Vocabulary Semantic Segmentation},
+  author={Seokju Cho and Heeseong Shin and Sunghwan Hong and Seungjun An and Seungjun Lee and Anurag Arnab and Paul Hongsuck Seo and Seungryong Kim},
+  journal={CVPR},
+  year={2023}
+}
+```
diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/__init__.py b/mmsegmentation/projects/CAT-Seg/cat_seg/__init__.py
new file mode 100644
index 0000000..2c51fba
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/cat_seg/__init__.py
@@ -0,0 +1,2 @@
+from .models import *  # noqa: F401,F403
+from .utils import *  # noqa: F401,F403
diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/models/__init__.py b/mmsegmentation/projects/CAT-Seg/cat_seg/models/__init__.py
new file mode 100644
index 0000000..cd0e15d
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/cat_seg/models/__init__.py
@@ -0,0 +1,10 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .cat_aggregator import (AggregatorLayer, CATSegAggregator,
+                             ClassAggregateLayer, SpatialAggregateLayer)
+from .cat_head import CATSegHead
+from .clip_ovseg import CLIPOVCATSeg
+
+__all__ = [
+    'AggregatorLayer', 'CATSegAggregator', 'ClassAggregateLayer',
+    'SpatialAggregateLayer', 'CATSegHead', 'CLIPOVCATSeg'
+]
diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/models/cat_aggregator.py b/mmsegmentation/projects/CAT-Seg/cat_seg/models/cat_aggregator.py
new file mode 100644
index 0000000..a0483fe
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/cat_seg/models/cat_aggregator.py
@@ -0,0 +1,763 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import build_norm_layer
+from mmcv.cnn.bricks.transformer import FFN, build_dropout
+from mmengine.model import BaseModule
+from mmengine.utils import to_2tuple
+
+from mmseg.registry import MODELS
+from ..utils import FullAttention, LinearAttention
+
+
+class AGWindowMSA(BaseModule):
+    """Appearance Guidance Window based multi-head self-attention (W-MSA)
+    module with relative position bias.
+
+    Args:
+        embed_dims (int): Number of input channels.
+        appearance_dims (int): Number of appearance guidance feature channels.
+        num_heads (int): Number of attention heads.
+        window_size (tuple[int]): The height and width of the window.
+        qkv_bias (bool, optional):  If True, add a learnable bias to q, k, v.
+            Default: True.
+        qk_scale (float | None, optional): Override default qk scale of
+            head_dim ** -0.5 if set. Default: None.
+        attn_drop_rate (float, optional): Dropout ratio of attention weight.
+            Default: 0.0
+        proj_drop_rate (float, optional): Dropout ratio of output. Default: 0.
+        init_cfg (dict | None, optional): The Config for initialization.
+            Default: None.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 appearance_dims,
+                 num_heads,
+                 window_size,
+                 qkv_bias=True,
+                 qk_scale=None,
+                 attn_drop_rate=0.,
+                 proj_drop_rate=0.,
+                 init_cfg=None):
+
+        super().__init__(init_cfg=init_cfg)
+        self.embed_dims = embed_dims
+        self.appearance_dims = appearance_dims
+        self.window_size = window_size  # Wh, Ww
+        self.num_heads = num_heads
+        head_embed_dims = embed_dims // num_heads
+        self.scale = qk_scale or head_embed_dims**-0.5
+
+        # About 2x faster than original impl
+        Wh, Ww = self.window_size
+        rel_index_coords = self.double_step_seq(2 * Ww - 1, Wh, 1, Ww)
+        rel_position_index = rel_index_coords + rel_index_coords.T
+        rel_position_index = rel_position_index.flip(1).contiguous()
+        self.register_buffer('relative_position_index', rel_position_index)
+
+        self.qk = nn.Linear(
+            embed_dims + appearance_dims, embed_dims * 2, bias=qkv_bias)
+        self.v = nn.Linear(embed_dims, embed_dims, bias=qkv_bias)
+        self.attn_drop = nn.Dropout(attn_drop_rate)
+        self.proj = nn.Linear(embed_dims, embed_dims)
+        self.proj_drop = nn.Dropout(proj_drop_rate)
+
+        self.softmax = nn.Softmax(dim=-1)
+
+    def forward(self, x, mask=None):
+        """
+        Args:
+            x (tensor): input features with shape of (num_windows*B, N, C),
+                C = embed_dims + appearance_dims.
+            mask (tensor | None, Optional): mask with shape of (num_windows,
+                Wh*Ww, Wh*Ww), value should be between (-inf, 0].
+        """
+        B, N, _ = x.shape
+        qk = self.qk(x).reshape(B, N, 2, self.num_heads,
+                                self.embed_dims // self.num_heads).permute(
+                                    2, 0, 3, 1,
+                                    4)  # 2 B NUM_HEADS N embed_dims//NUM_HEADS
+        v = self.v(x[:, :, :self.embed_dims]).reshape(
+            B, N, self.num_heads, self.embed_dims // self.num_heads).permute(
+                0, 2, 1, 3)  # B NUM_HEADS N embed_dims//NUM_HEADS
+        # make torchscript happy (cannot use tensor as tuple)
+        q, k = qk[0], qk[1]
+
+        q = q * self.scale
+        attn = (q @ k.transpose(-2, -1))
+
+        if mask is not None:
+            nW = mask.shape[0]
+            attn = attn.view(B // nW, nW, self.num_heads, N,
+                             N) + mask.unsqueeze(1).unsqueeze(0)
+            attn = attn.view(-1, self.num_heads, N, N)
+        attn = self.softmax(attn)
+
+        attn = self.attn_drop(attn)
+
+        x = (attn @ v).transpose(1, 2).reshape(B, N, self.embed_dims)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+    @staticmethod
+    def double_step_seq(step1, len1, step2, len2):
+        """Double step sequence."""
+        seq1 = torch.arange(0, step1 * len1, step1)
+        seq2 = torch.arange(0, step2 * len2, step2)
+        return (seq1[:, None] + seq2[None, :]).reshape(1, -1)
+
+
+class AGShiftWindowMSA(BaseModule):
+    """Appearance Guidance Shifted Window Multihead Self-Attention Module.
+
+    Args:
+        embed_dims (int): Number of input channels.
+        appearance_dims (int): Number of appearance guidance channels
+        num_heads (int): Number of attention heads.
+        window_size (int): The height and width of the window.
+        shift_size (int, optional): The shift step of each window towards
+            right-bottom. If zero, act as regular window-msa. Defaults to 0.
+        qkv_bias (bool, optional): If True, add a learnable bias to q, k, v.
+            Default: True
+        qk_scale (float | None, optional): Override default qk scale of
+            head_dim ** -0.5 if set. Defaults: None.
+        attn_drop_rate (float, optional): Dropout ratio of attention weight.
+            Defaults: 0.
+        proj_drop_rate (float, optional): Dropout ratio of output.
+            Defaults: 0.
+        dropout_layer (dict, optional): The dropout_layer used before output.
+            Defaults: dict(type='DropPath', drop_prob=0.).
+        init_cfg (dict, optional): The extra config for initialization.
+            Default: None.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 appearance_dims,
+                 num_heads,
+                 window_size,
+                 shift_size=0,
+                 qkv_bias=True,
+                 qk_scale=None,
+                 attn_drop_rate=0,
+                 proj_drop_rate=0,
+                 dropout_layer=dict(type='DropPath', drop_prob=0.),
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+
+        self.window_size = window_size
+        self.shift_size = shift_size
+        assert 0 <= self.shift_size < self.window_size
+
+        self.w_msa = AGWindowMSA(
+            embed_dims=embed_dims,
+            appearance_dims=appearance_dims,
+            num_heads=num_heads,
+            window_size=to_2tuple(window_size),
+            qkv_bias=qkv_bias,
+            qk_scale=qk_scale,
+            attn_drop_rate=attn_drop_rate,
+            proj_drop_rate=proj_drop_rate,
+            init_cfg=None)
+
+        self.drop = build_dropout(dropout_layer)
+
+    def forward(self, query, hw_shape):
+        """
+        Args:
+            query: The input query.
+            hw_shape: The shape of the feature height and width.
+        """
+        B, L, C = query.shape
+        H, W = hw_shape
+        assert L == H * W, 'input feature has wrong size'
+        query = query.view(B, H, W, C)
+
+        # pad feature maps to multiples of window size
+        pad_r = (self.window_size - W % self.window_size) % self.window_size
+        pad_b = (self.window_size - H % self.window_size) % self.window_size
+        query = F.pad(query, (0, 0, 0, pad_r, 0, pad_b))
+        H_pad, W_pad = query.shape[1], query.shape[2]
+
+        # cyclic shift
+        if self.shift_size > 0:
+            shifted_query = torch.roll(
+                query,
+                shifts=(-self.shift_size, -self.shift_size),
+                dims=(1, 2))
+
+            # calculate attention mask for SW-MSA
+            img_mask = torch.zeros((1, H_pad, W_pad, 1), device=query.device)
+            h_slices = (slice(0, -self.window_size),
+                        slice(-self.window_size,
+                              -self.shift_size), slice(-self.shift_size, None))
+            w_slices = (slice(0, -self.window_size),
+                        slice(-self.window_size,
+                              -self.shift_size), slice(-self.shift_size, None))
+            cnt = 0
+            for h in h_slices:
+                for w in w_slices:
+                    img_mask[:, h, w, :] = cnt
+                    cnt += 1
+
+            # nW, window_size, window_size, 1
+            mask_windows = self.window_partition(img_mask)
+            mask_windows = mask_windows.view(
+                -1, self.window_size * self.window_size)
+            attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
+            attn_mask = attn_mask.masked_fill(attn_mask != 0,
+                                              float(-100.0)).masked_fill(
+                                                  attn_mask == 0, float(0.0))
+        else:
+            shifted_query = query
+            attn_mask = None
+
+        # nW*B, window_size, window_size, C
+        query_windows = self.window_partition(shifted_query)
+        # nW*B, window_size*window_size, C
+        query_windows = query_windows.view(-1, self.window_size**2, C)
+
+        # W-MSA/SW-MSA (nW*B, window_size*window_size, C)
+        attn_windows = self.w_msa(query_windows, mask=attn_mask)
+
+        # merge windows
+        attn_windows = attn_windows.view(-1, self.window_size,
+                                         self.window_size,
+                                         self.w_msa.embed_dims)
+
+        # B H' W' self.w_msa.embed_dims
+        shifted_x = self.window_reverse(attn_windows, H_pad, W_pad)
+        # reverse cyclic shift
+        if self.shift_size > 0:
+            x = torch.roll(
+                shifted_x,
+                shifts=(self.shift_size, self.shift_size),
+                dims=(1, 2))
+        else:
+            x = shifted_x
+
+        if pad_r > 0 or pad_b:
+            x = x[:, :H, :W, :].contiguous()
+
+        x = x.view(B, H * W, self.w_msa.embed_dims)
+
+        x = self.drop(x)
+        return x
+
+    def window_reverse(self, windows, H, W):
+        """
+        Args:
+            windows: (num_windows*B, window_size, window_size, C)
+            H (int): Height of image
+            W (int): Width of image
+        Returns:
+            x: (B, H, W, C)
+        """
+        window_size = self.window_size
+        B = int(windows.shape[0] / (H * W / window_size / window_size))
+        x = windows.view(B, H // window_size, W // window_size, window_size,
+                         window_size, -1)
+        x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)
+        return x
+
+    def window_partition(self, x):
+        """
+        Args:
+            x: (B, H, W, C)
+        Returns:
+            windows: (num_windows*B, window_size, window_size, C)
+        """
+        B, H, W, C = x.shape
+        window_size = self.window_size
+        x = x.view(B, H // window_size, window_size, W // window_size,
+                   window_size, C)
+        windows = x.permute(0, 1, 3, 2, 4, 5).contiguous()
+        windows = windows.view(-1, window_size, window_size, C)
+        return windows
+
+
+class AGSwinBlock(BaseModule):
+    """Appearance Guidance Swin Transformer Block.
+
+    Args:
+        embed_dims (int): The feature dimension.
+        appearance_dims (int): The appearance guidance dimension.
+        num_heads (int): Parallel attention heads.
+        mlp_ratios (int): The hidden dimension ratio w.r.t. embed_dims
+            for FFNs.
+        window_size (int, optional): The local window scale.
+            Default: 7.
+        shift (bool, optional): whether to shift window or not.
+            Default False.
+        qkv_bias (bool, optional): enable bias for qkv if True.
+            Default: True.
+        qk_scale (float | None, optional): Override default qk scale of
+            head_dim ** -0.5 if set. Default: None.
+        drop_rate (float, optional): Dropout rate. Default: 0.
+        attn_drop_rate (float, optional): Attention dropout rate.
+            Default: 0.
+        drop_path_rate (float, optional): Stochastic depth rate.
+            Default: 0.
+        act_cfg (dict, optional): The config dict of activation function.
+            Default: dict(type='GELU').
+        norm_cfg (dict, optional): The config dict of normalization.
+            Default: dict(type='LN').
+        init_cfg (dict | list | None, optional): The init config.
+            Default: None.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 appearance_dims,
+                 num_heads,
+                 mlp_ratios=4,
+                 window_size=7,
+                 shift=False,
+                 qkv_bias=True,
+                 qk_scale=None,
+                 drop_rate=0.,
+                 attn_drop_rate=0.,
+                 drop_path_rate=0.,
+                 act_cfg=dict(type='GELU'),
+                 norm_cfg=dict(type='LN'),
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        self.norm1 = build_norm_layer(norm_cfg, embed_dims)[1]
+        self.attn = AGShiftWindowMSA(
+            embed_dims=embed_dims,
+            appearance_dims=appearance_dims,
+            num_heads=num_heads,
+            window_size=window_size,
+            shift_size=window_size // 2 if shift else 0,
+            qkv_bias=qkv_bias,
+            qk_scale=qk_scale,
+            attn_drop_rate=attn_drop_rate,
+            proj_drop_rate=drop_rate,
+            dropout_layer=dict(type='DropPath', drop_prob=drop_path_rate),
+            init_cfg=None)
+
+        self.norm2 = build_norm_layer(norm_cfg, embed_dims)[1]
+        self.ffn = FFN(
+            embed_dims=embed_dims,
+            feedforward_channels=embed_dims * mlp_ratios,
+            num_fcs=2,
+            ffn_drop=drop_rate,
+            dropout_layer=dict(type='DropPath', drop_prob=drop_path_rate),
+            act_cfg=act_cfg,
+            add_identity=True,
+            init_cfg=None)
+
+    def forward(self, inputs, hw_shape):
+        """
+        Args:
+            inputs (list[Tensor]): appearance_guidance (B, H, W, C);
+                x (B, L, C)
+            hw_shape (tuple[int]): shape of feature.
+        """
+        x, appearance_guidance = inputs
+        B, L, C = x.shape
+        H, W = hw_shape
+        assert L == H * W, 'input feature has wrong size'
+
+        identity = x
+        x = self.norm1(x)
+
+        # appearance guidance
+        x = x.view(B, H, W, C)
+        if appearance_guidance is not None:
+            x = torch.cat([x, appearance_guidance], dim=-1).flatten(1, 2)
+
+        x = self.attn(x, hw_shape)
+
+        x = x + identity
+
+        identity = x
+        x = self.norm2(x)
+        x = self.ffn(x, identity=identity)
+
+        return x
+
+
+@MODELS.register_module()
+class SpatialAggregateLayer(BaseModule):
+    """Spatial aggregation layer of CAT-Seg.
+
+    Args:
+        embed_dims (int): The feature dimension.
+        appearance_dims (int): The appearance guidance dimension.
+        num_heads (int): Parallel attention heads.
+        mlp_ratios (int): The hidden dimension ratio w.r.t. embed_dims
+            for FFNs.
+        window_size (int, optional): The local window scale. Default: 7.
+        qk_scale (float | None, optional): Override default qk scale of
+            head_dim ** -0.5 if set. Default: None.
+        init_cfg (dict | list | None, optional): The init config.
+            Default: None.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 appearance_dims,
+                 num_heads,
+                 mlp_ratios,
+                 window_size=7,
+                 qk_scale=None,
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        self.block_1 = AGSwinBlock(
+            embed_dims,
+            appearance_dims,
+            num_heads,
+            mlp_ratios,
+            window_size=window_size,
+            shift=False,
+            qk_scale=qk_scale)
+        self.block_2 = AGSwinBlock(
+            embed_dims,
+            appearance_dims,
+            num_heads,
+            mlp_ratios,
+            window_size=window_size,
+            shift=True,
+            qk_scale=qk_scale)
+        self.guidance_norm = nn.LayerNorm(
+            appearance_dims) if appearance_dims > 0 else None
+
+    def forward(self, x, appearance_guidance):
+        """
+        Args:
+            x (torch.Tensor): B C T H W.
+            appearance_guidance (torch.Tensor): B C H W.
+        """
+        B, C, T, H, W = x.shape
+        x = x.permute(0, 2, 3, 4, 1).flatten(0, 1).flatten(1, 2)  # BT, HW, C
+        if appearance_guidance is not None:
+            appearance_guidance = appearance_guidance.repeat(
+                T, 1, 1, 1).permute(0, 2, 3, 1)  # BT, HW, C
+            appearance_guidance = self.guidance_norm(appearance_guidance)
+        else:
+            assert self.appearance_dims == 0
+        x = self.block_1((x, appearance_guidance), (H, W))
+        x = self.block_2((x, appearance_guidance), (H, W))
+        x = x.transpose(1, 2).reshape(B, T, C, -1)
+        x = x.transpose(1, 2).reshape(B, C, T, H, W)
+        return x
+
+
+class AttentionLayer(nn.Module):
+    """Attention layer for ClassAggregration of CAT-Seg.
+
+    Source: https://github.com/KU-CVLAB/CAT-Seg/blob/main/cat_seg/modeling/transformer/model.py#L310 # noqa
+    """
+
+    def __init__(self,
+                 hidden_dim,
+                 guidance_dim,
+                 nheads=8,
+                 attention_type='linear'):
+        super().__init__()
+        self.nheads = nheads
+        self.q = nn.Linear(hidden_dim + guidance_dim, hidden_dim)
+        self.k = nn.Linear(hidden_dim + guidance_dim, hidden_dim)
+        self.v = nn.Linear(hidden_dim, hidden_dim)
+
+        if attention_type == 'linear':
+            self.attention = LinearAttention()
+        elif attention_type == 'full':
+            self.attention = FullAttention()
+        else:
+            raise NotImplementedError
+
+    def forward(self, x, guidance=None):
+        """
+        Args:
+            x: B*H_p*W_p, T, C
+            guidance: B*H_p*W_p, T, C
+        """
+        B, L, _ = x.shape
+        q = self.q(torch.cat([x, guidance],
+                             dim=-1)) if guidance is not None else self.q(x)
+        k = self.k(torch.cat([x, guidance],
+                             dim=-1)) if guidance is not None else self.k(x)
+        v = self.v(x)
+
+        q = q.reshape(B, L, self.nheads, -1)
+        k = k.reshape(B, L, self.nheads, -1)
+        v = v.reshape(B, L, self.nheads, -1)
+
+        out = self.attention(q, k, v)
+        out = out.reshape(B, L, -1)
+        return out
+
+
+@MODELS.register_module()
+class ClassAggregateLayer(BaseModule):
+    """Class aggregation layer of CAT-Seg.
+
+    Args:
+        hidden_dims (int): The feature dimension.
+        guidance_dims (int): The appearance guidance dimension.
+        num_heads (int): Parallel attention heads.
+        attention_type (str): Type of attention layer. Default: 'linear'.
+        pooling_size (tuple[int] | list[int]): Pooling size.
+        init_cfg (dict | list | None, optional): The init config.
+            Default: None.
+    """
+
+    def __init__(
+            self,
+            hidden_dims=64,
+            guidance_dims=64,
+            num_heads=8,
+            attention_type='linear',
+            pooling_size=(4, 4),
+            init_cfg=None,
+    ):
+        super().__init__(init_cfg=init_cfg)
+        self.pool = nn.AvgPool2d(pooling_size)
+        self.attention = AttentionLayer(
+            hidden_dims,
+            guidance_dims,
+            nheads=num_heads,
+            attention_type=attention_type)
+        self.MLP = FFN(
+            embed_dims=hidden_dims,
+            feedforward_channels=hidden_dims * 4,
+            num_fcs=2)
+        self.norm1 = nn.LayerNorm(hidden_dims)
+        self.norm2 = nn.LayerNorm(hidden_dims)
+
+    def pool_features(self, x):
+        """Intermediate pooling layer for computational efficiency.
+
+        Args:
+            x: B, C, T, H, W
+        """
+        B, C, T, H, W = x.shape
+        x = x.transpose(1, 2).reshape(-1, C, H, W)
+        x = self.pool(x)
+        *_, H_, W_ = x.shape
+        x = x.reshape(B, T, C, H_, W_).transpose(1, 2)
+        return x
+
+    def forward(self, x, guidance):
+        """
+        Args:
+            x: B, C, T, H, W
+            guidance: B, T, C
+        """
+        B, C, T, H, W = x.size()
+        x_pool = self.pool_features(x)
+        *_, H_pool, W_pool = x_pool.size()
+
+        x_pool = x_pool.permute(0, 3, 4, 2, 1).reshape(-1, T, C)
+        # B*H_p*W_p T C
+        if guidance is not None:
+            guidance = guidance.repeat(H_pool * W_pool, 1, 1)
+
+        x_pool = x_pool + self.attention(self.norm1(x_pool),
+                                         guidance)  # Attention
+        x_pool = x_pool + self.MLP(self.norm2(x_pool))  # MLP
+
+        x_pool = x_pool.reshape(B, H_pool * W_pool, T,
+                                C).permute(0, 2, 3, 1).reshape(
+                                    B, T, C, H_pool,
+                                    W_pool).flatten(0, 1)  # BT C H_p W_p
+        x_pool = F.interpolate(
+            x_pool, size=(H, W), mode='bilinear', align_corners=True)
+        x_pool = x_pool.reshape(B, T, C, H, W).transpose(1, 2)  # B C T H W
+        x = x + x_pool  # Residual
+
+        return x
+
+
+@MODELS.register_module()
+class AggregatorLayer(BaseModule):
+    """Single Aggregator Layer of CAT-Seg."""
+
+    def __init__(self,
+                 embed_dims=64,
+                 text_guidance_dims=512,
+                 appearance_guidance_dims=512,
+                 num_heads=4,
+                 mlp_ratios=4,
+                 window_size=7,
+                 attention_type='linear',
+                 pooling_size=(2, 2),
+                 init_cfg=None) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.spatial_agg = SpatialAggregateLayer(
+            embed_dims,
+            appearance_guidance_dims,
+            num_heads=num_heads,
+            mlp_ratios=mlp_ratios,
+            window_size=window_size)
+        self.class_agg = ClassAggregateLayer(
+            embed_dims,
+            text_guidance_dims,
+            num_heads=num_heads,
+            attention_type=attention_type,
+            pooling_size=pooling_size)
+
+    def forward(self, x, appearance_guidance, text_guidance):
+        """
+        Args:
+            x: B C T H W
+        """
+        x = self.spatial_agg(x, appearance_guidance)
+        x = self.class_agg(x, text_guidance)
+        return x
+
+
+@MODELS.register_module()
+class CATSegAggregator(BaseModule):
+    """CATSeg Aggregator.
+
+    This Aggregator is the mmseg implementation of
+    `CAT-Seg <https://arxiv.org/abs/2303.11797>`_.
+
+    Args:
+        text_guidance_dim (int): Text guidance dimensions. Default: 512.
+        text_guidance_proj_dim (int): Text guidance projection dimensions.
+            Default: 128.
+        appearance_guidance_dim (int): Appearance guidance dimensions.
+            Default: 512.
+        appearance_guidance_proj_dim (int): Appearance guidance projection
+            dimensions. Default: 128.
+        num_layers (int): Aggregator layer number. Default: 4.
+        num_heads (int): Attention layer head number. Default: 4.
+        embed_dims (int): Input feature dimensions. Default: 128.
+        pooling_size (tuple | list): Pooling size of the class aggregator
+            layer. Default: (6, 6).
+        mlp_ratios (int): The hidden dimension ratio w.r.t. input dimension.
+            Default: 4.
+        window_size (int): Swin block window size. Default:12.
+        attention_type (str): Attention type of class aggregator layer.
+            Default:'linear'.
+        prompt_channel (int): Prompt channels. Default: 80.
+    """
+
+    def __init__(self,
+                 text_guidance_dim=512,
+                 text_guidance_proj_dim=128,
+                 appearance_guidance_dim=512,
+                 appearance_guidance_proj_dim=128,
+                 num_layers=4,
+                 num_heads=4,
+                 embed_dims=128,
+                 pooling_size=(6, 6),
+                 mlp_ratios=4,
+                 window_size=12,
+                 attention_type='linear',
+                 prompt_channel=80,
+                 **kwargs):
+        super().__init__(**kwargs)
+        self.num_layers = num_layers
+        self.embed_dims = embed_dims
+
+        self.layers = nn.ModuleList([
+            AggregatorLayer(
+                embed_dims=embed_dims,
+                text_guidance_dims=text_guidance_proj_dim,
+                appearance_guidance_dims=appearance_guidance_proj_dim,
+                num_heads=num_heads,
+                mlp_ratios=mlp_ratios,
+                window_size=window_size,
+                attention_type=attention_type,
+                pooling_size=pooling_size) for _ in range(num_layers)
+        ])
+
+        self.conv1 = nn.Conv2d(
+            prompt_channel, embed_dims, kernel_size=7, stride=1, padding=3)
+
+        self.guidance_projection = nn.Sequential(
+            nn.Conv2d(
+                appearance_guidance_dim,
+                appearance_guidance_proj_dim,
+                kernel_size=3,
+                stride=1,
+                padding=1),
+            nn.ReLU(),
+        ) if appearance_guidance_dim > 0 else None
+
+        self.text_guidance_projection = nn.Sequential(
+            nn.Linear(text_guidance_dim, text_guidance_proj_dim),
+            nn.ReLU(),
+        ) if text_guidance_dim > 0 else None
+
+    def feature_map(self, img_feats, text_feats):
+        """Concatenation type cost volume.
+
+        For ablation study of cost volume type.
+        """
+        img_feats = F.normalize(img_feats, dim=1)  # B C H W
+        img_feats = img_feats.unsqueeze(2).repeat(1, 1, text_feats.shape[1], 1,
+                                                  1)
+        text_feats = F.normalize(text_feats, dim=-1)  # B T P C
+        text_feats = text_feats.mean(dim=-2)
+        text_feats = F.normalize(text_feats, dim=-1)  # B T C
+        text_feats = text_feats.unsqueeze(-1).unsqueeze(-1).repeat(
+            1, 1, 1, img_feats.shape[-2], img_feats.shape[-1]).transpose(1, 2)
+        return torch.cat((img_feats, text_feats), dim=1)  # B 2C T H W
+
+    def correlation(self, img_feats, text_feats):
+        """Correlation of image features and text features."""
+        img_feats = F.normalize(img_feats, dim=1)  # B C H W
+        text_feats = F.normalize(text_feats, dim=-1)  # B T P C
+        corr = torch.einsum('bchw, btpc -> bpthw', img_feats, text_feats)
+        return corr
+
+    def corr_embed(self, x):
+        """Correlation embeddings encoding."""
+        B = x.shape[0]
+        corr_embed = x.permute(0, 2, 1, 3, 4).flatten(0, 1)
+        corr_embed = self.conv1(corr_embed)
+        corr_embed = corr_embed.reshape(B, -1, self.embed_dims, x.shape[-2],
+                                        x.shape[-1]).transpose(1, 2)
+        return corr_embed
+
+    def forward(self, inputs):
+        """
+        Args:
+            inputs (dict): including the following keys,
+                'appearance_feat': list[torch.Tensor], w.r.t. out_indices of
+                    `self.feature_extractor`.
+                'clip_text_feat': the text feature extracted by clip text
+                    encoder.
+                'clip_text_feat_test': the text feature extracted by clip text
+                    encoder for testing.
+                'clip_img_feat': the image feature extracted clip image
+                    encoder.
+        """
+        img_feats = inputs['clip_img_feat']
+        B = img_feats.size(0)
+        appearance_guidance = inputs[
+            'appearance_feat'][::-1]  # order (out_indices) 2, 1, 0
+        text_feats = inputs['clip_text_feat'] if self.training else inputs[
+            'clip_text_feat_test']
+        text_feats = text_feats.repeat(B, 1, 1, 1)
+
+        corr = self.correlation(img_feats, text_feats)
+        # corr = self.feature_map(img_feats, text_feats)
+        corr_embed = self.corr_embed(corr)
+
+        projected_guidance, projected_text_guidance = None, None
+
+        if self.guidance_projection is not None:
+            projected_guidance = self.guidance_projection(
+                appearance_guidance[0])
+
+        if self.text_guidance_projection is not None:
+            text_feats = text_feats.mean(dim=-2)
+            text_feats = text_feats / text_feats.norm(dim=-1, keepdim=True)
+            projected_text_guidance = self.text_guidance_projection(text_feats)
+
+        for layer in self.layers:
+            corr_embed = layer(corr_embed, projected_guidance,
+                               projected_text_guidance)
+
+        return dict(
+            corr_embed=corr_embed, appearance_feats=appearance_guidance[1:])
diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/models/cat_head.py b/mmsegmentation/projects/CAT-Seg/cat_seg/models/cat_head.py
new file mode 100644
index 0000000..36bb1c5
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/cat_seg/models/cat_head.py
@@ -0,0 +1,116 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+
+from mmseg.models.decode_heads.decode_head import BaseDecodeHead
+from mmseg.registry import MODELS
+
+
+class UpBlock(nn.Module):
+    """Upsample Block with two consecutive convolution layers."""
+
+    def __init__(self, in_channels, out_channels, guidance_channels):
+        super().__init__()
+        self.up = nn.ConvTranspose2d(
+            in_channels,
+            in_channels - guidance_channels,
+            kernel_size=2,
+            stride=2)
+        self.conv1 = ConvModule(
+            in_channels,
+            out_channels,
+            3,
+            padding=1,
+            bias=False,
+            norm_cfg=dict(type='GN', num_groups=out_channels // 16))
+        self.conv2 = ConvModule(
+            out_channels,
+            out_channels,
+            3,
+            padding=1,
+            bias=False,
+            norm_cfg=dict(type='GN', num_groups=out_channels // 16))
+
+    def forward(self, x, guidance=None):
+        """Forward function with visual guidance."""
+        x = self.up(x)
+        if guidance is not None:
+            T = x.size(0) // guidance.size(0)
+            # guidance = repeat(guidance, "B C H W -> (B T) C H W", T=T)
+            guidance = guidance.repeat(T, 1, 1, 1)
+            x = torch.cat([x, guidance], dim=1)
+        x = self.conv1(x)
+
+        return self.conv2(x)
+
+
+@MODELS.register_module()
+class CATSegHead(BaseDecodeHead):
+    """CATSeg Head.
+
+    This segmentation head is the mmseg implementation of
+    `CAT-Seg <https://arxiv.org/abs/2303.11797>`_.
+
+    Args:
+        embed_dims (int): The number of input dimensions.
+        decoder_dims (list): The number of decoder dimensions.
+        decoder_guidance_proj_dims (list): The number of appearance
+            guidance dimensions.
+        init_cfg
+    """
+
+    def __init__(self,
+                 embed_dims=128,
+                 decoder_dims=(64, 32),
+                 decoder_guidance_dims=(256, 128),
+                 decoder_guidance_proj_dims=(32, 16),
+                 **kwargs):
+        super().__init__(**kwargs)
+        self.decoder_guidance_projection = nn.ModuleList([
+            nn.Sequential(
+                nn.Conv2d(
+                    dec_dims,
+                    dec_dims_proj,
+                    kernel_size=3,
+                    stride=1,
+                    padding=1),
+                nn.ReLU(),
+            ) for dec_dims, dec_dims_proj in zip(decoder_guidance_dims,
+                                                 decoder_guidance_proj_dims)
+        ]) if decoder_guidance_dims[0] > 0 else None
+
+        self.decoder1 = UpBlock(embed_dims, decoder_dims[0],
+                                decoder_guidance_proj_dims[0])
+        self.decoder2 = UpBlock(decoder_dims[0], decoder_dims[1],
+                                decoder_guidance_proj_dims[1])
+        self.conv_seg = nn.Conv2d(
+            decoder_dims[1], 1, kernel_size=3, stride=1, padding=1)
+
+    def forward(self, inputs):
+        """Forward function.
+
+        Args:
+            inputs (dict): Input features including the following features,
+                corr_embed: aggregated correlation embeddings.
+                appearance_feats: decoder appearance feature guidance.
+        """
+        # decoder guidance projection
+        if self.decoder_guidance_projection is not None:
+            projected_decoder_guidance = [
+                proj(g) for proj, g in zip(self.decoder_guidance_projection,
+                                           inputs['appearance_feats'])
+            ]
+
+        # decoder layers
+        B = inputs['corr_embed'].size(0)
+        corr_embed = inputs['corr_embed'].transpose(1, 2).flatten(0, 1)
+        corr_embed = self.decoder1(corr_embed, projected_decoder_guidance[0])
+        corr_embed = self.decoder2(corr_embed, projected_decoder_guidance[1])
+
+        output = self.cls_seg(corr_embed)
+
+        # rearrange the output to (B, T, H, W)
+        H_ori, W_ori = output.shape[-2:]
+        output = output.reshape(B, -1, H_ori, W_ori)
+        return output
diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/models/clip_ovseg.py b/mmsegmentation/projects/CAT-Seg/cat_seg/models/clip_ovseg.py
new file mode 100644
index 0000000..cb67744
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/cat_seg/models/clip_ovseg.py
@@ -0,0 +1,293 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import json
+import os
+from typing import List
+
+import torch
+import torch.nn.functional as F
+from huggingface_hub.utils._errors import LocalEntryNotFoundError
+from mmengine.model import BaseModule
+
+from mmseg.registry import MODELS
+from mmseg.utils import ConfigType
+from ..utils import clip_wrapper
+from ..utils.clip_templates import (IMAGENET_TEMPLATES,
+                                    IMAGENET_TEMPLATES_SELECT)
+
+
+@MODELS.register_module()
+class CLIPOVCATSeg(BaseModule):
+    """CLIP based Open Vocabulary CAT-Seg model backbone.
+
+    This backbone is the modified implementation of `CAT-Seg Backbone
+    <https://arxiv.org/abs/2303.11797>`_. It combines the CLIP model and
+    another feature extractor, a.k.a the appearance guidance extractor
+    in the original `CAT-Seg`.
+
+    Args:
+        feature_extractor (ConfigType): Appearance guidance extractor
+            config dict.
+        train_class_json (str): The training class json file.
+        test_class_json (str): The path to test class json file.
+        clip_pretrained (str): The pre-trained clip type.
+        clip_finetune (str): The finetuning settings of clip model.
+        custom_clip_weights (str): The custmized clip weights directory. When
+            encountering huggingface model download errors, you can manually
+            download the pretrained weights.
+        backbone_multiplier (float): The learning rate multiplier.
+            Default: 0.01.
+        prompt_depth (int): The prompt depth. Default: 0.
+        prompt_length (int): The prompt length. Default: 0.
+        prompt_ensemble_type (str): The prompt ensemble type.
+            Default: "imagenet".
+        pixel_mean (List[float]): The pixel mean for feature extractor.
+        pxiel_std (List[float]): The pixel std for feature extractor.
+        clip_pixel_mean (List[float]): The pixel mean for clip model.
+        clip_pxiel_std (List[float]): The pixel std for clip model.
+        clip_img_feat_size: (List[int]: Clip image embedding size from
+            image encoder.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    """
+
+    def __init__(
+            self,
+            feature_extractor: ConfigType,
+            train_class_json: str,
+            test_class_json: str,
+            clip_pretrained: str,
+            clip_finetune: str,
+            custom_clip_weights: str = None,
+            backbone_multiplier=0.01,
+            prompt_depth: int = 0,
+            prompt_length: int = 0,
+            prompt_ensemble_type: str = 'imagenet',
+            pixel_mean: List[float] = [123.675, 116.280, 103.530],
+            pixel_std: List[float] = [58.395, 57.120, 57.375],
+            clip_pixel_mean: List[float] = [
+                122.7709383, 116.7460125, 104.09373615
+            ],
+            clip_pixel_std: List[float] = [68.5005327, 66.6321579, 70.3231630],
+            clip_img_feat_size: List[int] = [24, 24],
+            init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+        # normalization parameters
+        self.register_buffer('pixel_mean',
+                             torch.Tensor(pixel_mean).view(1, -1, 1, 1), False)
+        self.register_buffer('pixel_std',
+                             torch.Tensor(pixel_std).view(1, -1, 1, 1), False)
+        self.register_buffer('clip_pixel_mean',
+                             torch.Tensor(clip_pixel_mean).view(1, -1, 1, 1),
+                             False)
+        self.register_buffer('clip_pixel_std',
+                             torch.Tensor(clip_pixel_std).view(1, -1, 1, 1),
+                             False)
+        self.clip_resolution = (
+            384, 384) if clip_pretrained == 'ViT-B/16' else (336, 336)
+        # modified clip image encoder with fixed size dense output
+        self.clip_img_feat_size = clip_img_feat_size
+
+        # prepare clip templates
+        self.prompt_ensemble_type = prompt_ensemble_type
+        if self.prompt_ensemble_type == 'imagenet_select':
+            prompt_templates = IMAGENET_TEMPLATES_SELECT
+        elif self.prompt_ensemble_type == 'imagenet':
+            prompt_templates = IMAGENET_TEMPLATES
+        elif self.prompt_ensemble_type == 'single':
+            prompt_templates = [
+                'A photo of a {} in the scene',
+            ]
+        else:
+            raise NotImplementedError
+        self.prompt_templates = prompt_templates
+
+        # build the feature extractor
+        self.feature_extractor = MODELS.build(feature_extractor)
+
+        # build CLIP model
+        with open(train_class_json) as f_in:
+            self.class_texts = json.load(f_in)
+        with open(test_class_json) as f_in:
+            self.test_class_texts = json.load(f_in)
+        assert self.class_texts is not None
+        if self.test_class_texts is None:
+            self.test_class_texts = self.class_texts
+        device = 'cuda' if torch.cuda.is_available() else 'cpu'
+        self.tokenizer = None
+        if clip_pretrained == 'ViT-G' or clip_pretrained == 'ViT-H':
+            # for OpenCLIP models
+            import open_clip
+            name, pretrain = (
+                'ViT-H-14',
+                'laion2b_s32b_b79k') if clip_pretrained == 'ViT-H' else (
+                    'ViT-bigG-14', 'laion2b_s39b_b160k')
+            try:
+                open_clip_model = open_clip.create_model_and_transforms(
+                    name,
+                    pretrained=pretrain,
+                    device=device,
+                    force_image_size=336,
+                )
+                clip_model, _, clip_preprocess = open_clip_model
+            except ConnectionError or LocalEntryNotFoundError as e:
+                print(f'Has {e} when loading weights from huggingface!')
+                print(
+                    f'Will load {pretrain} weights from {custom_clip_weights}.'
+                )
+                assert custom_clip_weights is not None, 'Please specify custom weights directory.'  # noqa
+                assert os.path.exists(
+                    os.path.join(custom_clip_weights,
+                                 'open_clip_pytorch_model.bin')
+                ), 'Please provide a valid directory for manually downloaded model.'  # noqa
+                open_clip_model = open_clip.create_model_and_transforms(
+                    name,
+                    pretrained=None,
+                    device='cpu',
+                    force_image_size=336,
+                )
+                clip_model, _, clip_preprocess = open_clip_model
+
+                open_clip.load_checkpoint(
+                    clip_model,
+                    os.path.expanduser(
+                        os.path.join(custom_clip_weights,
+                                     'open_clip_pytorch_model.bin')))
+                clip_model.to(torch.device(device))
+
+            self.tokenizer = open_clip.get_tokenizer(name)
+        else:
+            # for OpenAI models
+            clip_model, clip_preprocess = clip_wrapper.load(
+                clip_pretrained,
+                device=device,
+                jit=False,
+                prompt_depth=prompt_depth,
+                prompt_length=prompt_length)
+
+        # pre-encode classes text prompts
+        text_features = self.class_embeddings(self.class_texts,
+                                              prompt_templates, clip_model,
+                                              device).permute(1, 0, 2).float()
+        text_features_test = self.class_embeddings(self.test_class_texts,
+                                                   prompt_templates,
+                                                   clip_model,
+                                                   device).permute(1, 0,
+                                                                   2).float()
+        self.register_buffer('text_features', text_features, False)
+        self.register_buffer('text_features_test', text_features_test, False)
+
+        # prepare CLIP model finetune
+        self.clip_finetune = clip_finetune
+        self.clip_model = clip_model.float()
+        self.clip_preprocess = clip_preprocess
+
+        for name, params in self.clip_model.named_parameters():
+            if 'visual' in name:
+                if clip_finetune == 'prompt':
+                    params.requires_grad = True if 'prompt' in name else False
+                elif clip_finetune == 'attention':
+                    if 'attn' in name or 'position' in name:
+                        params.requires_grad = True
+                    else:
+                        params.requires_grad = False
+                elif clip_finetune == 'full':
+                    params.requires_grad = True
+                else:
+                    params.requires_grad = False
+            else:
+                params.requires_grad = False
+
+        finetune_backbone = backbone_multiplier > 0.
+        for name, params in self.feature_extractor.named_parameters():
+            if 'norm0' in name:
+                params.requires_grad = False
+            else:
+                params.requires_grad = finetune_backbone
+
+    @torch.no_grad()
+    def class_embeddings(self,
+                         classnames,
+                         templates,
+                         clip_model,
+                         device='cpu'):
+        """Convert class names to text embeddings by clip model.
+
+        Args:
+            classnames (list): loaded from json file.
+            templates (dict): text template.
+            clip_model (nn.Module): prepared clip model.
+            device (str | torch.device): loading device of text
+                encoder results.
+        """
+        zeroshot_weights = []
+        for classname in classnames:
+            if ', ' in classname:
+                classname_splits = classname.split(', ')
+                texts = []
+                for template in templates:
+                    for cls_split in classname_splits:
+                        texts.append(template.format(cls_split))
+            else:
+                texts = [template.format(classname)
+                         for template in templates]  # format with class
+            if self.tokenizer is not None:
+                texts = self.tokenizer(texts).to(device)
+            else:
+                texts = clip_wrapper.tokenize(texts).to(device)
+            class_embeddings = clip_model.encode_text(texts)
+            class_embeddings /= class_embeddings.norm(dim=-1, keepdim=True)
+            if len(templates) != class_embeddings.shape[0]:
+                class_embeddings = class_embeddings.reshape(
+                    len(templates), -1, class_embeddings.shape[-1]).mean(dim=1)
+                class_embeddings /= class_embeddings.norm(dim=-1, keepdim=True)
+            class_embedding = class_embeddings
+            zeroshot_weights.append(class_embedding)
+        zeroshot_weights = torch.stack(zeroshot_weights, dim=1).to(device)
+        return zeroshot_weights
+
+    def custom_normalize(self, inputs):
+        """Input normalization for clip model and feature extractor
+        respectively.
+
+        Args:
+            inputs: batched input images.
+        """
+        # clip images
+        batched_clip = (inputs - self.clip_pixel_mean) / self.clip_pixel_std
+        batched_clip = F.interpolate(
+            batched_clip,
+            size=self.clip_resolution,
+            mode='bilinear',
+            align_corners=False)
+        # feature extractor images
+        batched = (inputs - self.pixel_mean) / self.pixel_std
+        return batched, batched_clip
+
+    def forward(self, inputs):
+        """
+        Args:
+            inputs: minibatch image. (B, 3, H, W)
+        Returns:
+            outputs (dict):
+            'appearance_feat': list[torch.Tensor], w.r.t. out_indices of
+                `self.feature_extractor`.
+            'clip_text_feat': the text feature extracted by clip text encoder.
+            'clip_text_feat_test': the text feature extracted by clip text
+                encoder for testing.
+            'clip_img_feat': the image feature extracted clip image encoder.
+        """
+        inputs, clip_inputs = self.custom_normalize(inputs)
+        outputs = dict()
+        # extract appearance guidance feature
+        outputs['appearance_feat'] = self.feature_extractor(inputs)
+
+        # extract clip features
+        outputs['clip_text_feat'] = self.text_features
+        outputs['clip_text_feat_test'] = self.text_features_test
+        clip_features = self.clip_model.encode_image(
+            clip_inputs, dense=True)  # B, 577(24x24+1), C
+        B = clip_features.size(0)
+        outputs['clip_img_feat'] = clip_features[:, 1:, :].permute(
+            0, 2, 1).reshape(B, -1, *self.clip_img_feat_size)
+
+        return outputs
diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/utils/__init__.py b/mmsegmentation/projects/CAT-Seg/cat_seg/utils/__init__.py
new file mode 100644
index 0000000..88746b2
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/cat_seg/utils/__init__.py
@@ -0,0 +1,10 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .clip_templates import (IMAGENET_TEMPLATES, IMAGENET_TEMPLATES_SELECT,
+                             IMAGENET_TEMPLATES_SELECT_CLIP, ViLD_templates)
+from .self_attention_block import FullAttention, LinearAttention
+
+__all__ = [
+    'FullAttention', 'LinearAttention', 'IMAGENET_TEMPLATES',
+    'IMAGENET_TEMPLATES_SELECT', 'IMAGENET_TEMPLATES_SELECT_CLIP',
+    'ViLD_templates'
+]
diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/utils/bpe_vocab/bpe_simple_vocab_16e6.txt.gz b/mmsegmentation/projects/CAT-Seg/cat_seg/utils/bpe_vocab/bpe_simple_vocab_16e6.txt.gz
new file mode 100644
index 0000000000000000000000000000000000000000..7b5088a527f720063f044eb928eee315f63b2fc0
GIT binary patch
literal 1356917
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%0D-8anuzg!0hrX~L}M*$l~SOpZ7=I+%ag
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%0A|F7fvQOLDQFPf3
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%0D+{l&4Elf+RUJ>DPlT<0vI!uxp-LitG
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%0DQu49$GwTP{0?>4l_B{}_v8!N|W%zC&9>
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%0Dk}39ByCzIU5yLcM+o6FDFaENYBu
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%0DL<K?1>h
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

literal 0
HcmV?d00001

diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_model.py b/mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_model.py
new file mode 100644
index 0000000..977444f
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_model.py
@@ -0,0 +1,651 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from collections import OrderedDict
+from typing import Tuple, Union
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+
+class Bottleneck(nn.Module):
+    """Custom implementation of Bottleneck in ResNet."""
+    expansion = 4
+
+    def __init__(self, inplanes, planes, stride=1):
+        super().__init__()
+        # all conv layers have stride 1.
+        # an avgpool is performed after the second convolution when stride > 1
+        self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False)
+        self.bn1 = nn.BatchNorm2d(planes)
+
+        self.conv2 = nn.Conv2d(planes, planes, 3, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(planes)
+
+        self.avgpool = nn.AvgPool2d(stride) if stride > 1 else nn.Identity()
+
+        self.conv3 = nn.Conv2d(planes, planes * self.expansion, 1, bias=False)
+        self.bn3 = nn.BatchNorm2d(planes * self.expansion)
+
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = None
+        self.stride = stride
+
+        if stride > 1 or inplanes != planes * Bottleneck.expansion:
+            # downsampling layer is prepended with an avgpool,
+            # and the subsequent convolution has stride 1
+            self.downsample = nn.Sequential(
+                OrderedDict([('-1', nn.AvgPool2d(stride)),
+                             ('0',
+                              nn.Conv2d(
+                                  inplanes,
+                                  planes * self.expansion,
+                                  1,
+                                  stride=1,
+                                  bias=False)),
+                             ('1', nn.BatchNorm2d(planes * self.expansion))]))
+
+    def forward(self, x: torch.Tensor):
+        """
+        Args:
+            x (torch.Tensor): the input feature.
+        """
+        identity = x
+
+        out = self.relu(self.bn1(self.conv1(x)))
+        out = self.relu(self.bn2(self.conv2(out)))
+        out = self.avgpool(out)
+        out = self.bn3(self.conv3(out))
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out += identity
+        out = self.relu(out)
+        return out
+
+
+class AttentionPool2d(nn.Module):
+    """Attention Pool2d."""
+
+    def __init__(self,
+                 spacial_dim: int,
+                 embed_dim: int,
+                 num_heads: int,
+                 output_dim: int = None):
+        super().__init__()
+        self.positional_embedding = nn.Parameter(
+            torch.randn(spacial_dim**2 + 1, embed_dim) / embed_dim**0.5)
+        self.k_proj = nn.Linear(embed_dim, embed_dim)
+        self.q_proj = nn.Linear(embed_dim, embed_dim)
+        self.v_proj = nn.Linear(embed_dim, embed_dim)
+        self.c_proj = nn.Linear(embed_dim, output_dim or embed_dim)
+        self.num_heads = num_heads
+
+    def forward(self, x):
+        """
+        Args:
+            x (torch.Tensor): the input feature.
+        """
+        x = x.flatten(start_dim=2).permute(2, 0, 1)  # NCHW -> (HW)NC
+        x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0)  # (HW+1)NC
+        x = x + self.positional_embedding[:, None, :].to(x.dtype)  # (HW+1)NC
+        x, _ = F.multi_head_attention_forward(
+            query=x[:1],
+            key=x,
+            value=x,
+            embed_dim_to_check=x.shape[-1],
+            num_heads=self.num_heads,
+            q_proj_weight=self.q_proj.weight,
+            k_proj_weight=self.k_proj.weight,
+            v_proj_weight=self.v_proj.weight,
+            in_proj_weight=None,
+            in_proj_bias=torch.cat(
+                [self.q_proj.bias, self.k_proj.bias, self.v_proj.bias]),
+            bias_k=None,
+            bias_v=None,
+            add_zero_attn=False,
+            dropout_p=0,
+            out_proj_weight=self.c_proj.weight,
+            out_proj_bias=self.c_proj.bias,
+            use_separate_proj_weight=True,
+            training=self.training,
+            need_weights=False)
+        return x.squeeze(0)
+
+
+class ModifiedResNet(nn.Module):
+    """A ResNet class that is similar to torchvision's but contains the
+    following changes:
+
+    - There are now 3 "stem" convolutions as opposed to 1, with an average
+        pool instead of a max pool.
+    - Performs anti-aliasing strided convolutions, where an avgpool is
+        prepended to convolutions with stride > 1
+    - The final pooling layer is a QKV attention instead of an average pool
+    """
+
+    def __init__(self,
+                 layers,
+                 output_dim,
+                 heads,
+                 input_resolution=224,
+                 width=64):
+        super().__init__()
+        self.output_dim = output_dim
+        self.input_resolution = input_resolution
+
+        # the 3-layer stem
+        self.conv1 = nn.Conv2d(
+            3, width // 2, kernel_size=3, stride=2, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(width // 2)
+        self.relu1 = nn.ReLU(inplace=True)
+        self.conv2 = nn.Conv2d(
+            width // 2, width // 2, kernel_size=3, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(width // 2)
+        self.relu2 = nn.ReLU(inplace=True)
+        self.conv3 = nn.Conv2d(
+            width // 2, width, kernel_size=3, padding=1, bias=False)
+        self.bn3 = nn.BatchNorm2d(width)
+        self.relu3 = nn.ReLU(inplace=True)
+        self.avgpool = nn.AvgPool2d(2)
+
+        # residual layers
+        # this is a *mutable* variable used during construction
+        self._inplanes = width
+        self.layer1 = self._make_layer(width, layers[0])
+        self.layer2 = self._make_layer(width * 2, layers[1], stride=2)
+        self.layer3 = self._make_layer(width * 4, layers[2], stride=2)
+        self.layer4 = self._make_layer(width * 8, layers[3], stride=2)
+
+        embed_dim = width * 32  # the ResNet feature dimension
+        self.attnpool = AttentionPool2d(input_resolution // 32, embed_dim,
+                                        heads, output_dim)
+
+    def _make_layer(self, planes, blocks, stride=1):
+        """Build resnet layers."""
+        layers = [Bottleneck(self._inplanes, planes, stride)]
+
+        self._inplanes = planes * Bottleneck.expansion
+        for _ in range(1, blocks):
+            layers.append(Bottleneck(self._inplanes, planes))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        """
+        Args:
+            x (torch.Tensor): the input mini-batch images.
+        """
+
+        def stem(x):
+            x = self.relu1(self.bn1(self.conv1(x)))
+            x = self.relu2(self.bn2(self.conv2(x)))
+            x = self.relu3(self.bn3(self.conv3(x)))
+            x = self.avgpool(x)
+            return x
+
+        x = x.type(self.conv1.weight.dtype)
+        x = stem(x)
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)
+        x = self.attnpool(x)
+
+        return x
+
+
+class LayerNorm(nn.LayerNorm):
+    """Subclass torch's LayerNorm to handle fp16."""
+
+    def forward(self, x: torch.Tensor):
+        """
+        Args:
+            x (torch.Tensor): the input feature.
+        """
+        orig_type = x.dtype
+        ret = super().forward(x.type(torch.float32))
+        return ret.type(orig_type)
+
+
+class QuickGELU(nn.Module):
+    """Wrapper of GELU activation layer."""
+
+    def forward(self, x: torch.Tensor):
+        """
+        Args:
+            x (torch.Tensor): the input feature.
+        """
+        return x * torch.sigmoid(1.702 * x)
+
+
+class ResidualAttentionBlock(nn.Module):
+    """Attention block with residual connection."""
+
+    def __init__(self,
+                 d_model: int,
+                 n_head: int,
+                 attn_mask: torch.Tensor = None):
+        super().__init__()
+
+        self.attn = nn.MultiheadAttention(d_model, n_head)
+        self.ln_1 = LayerNorm(d_model)
+        self.mlp = nn.Sequential(
+            OrderedDict([('c_fc', nn.Linear(d_model, d_model * 4)),
+                         ('gelu', QuickGELU()),
+                         ('c_proj', nn.Linear(d_model * 4, d_model))]))
+        self.ln_2 = LayerNorm(d_model)
+        self.attn_mask = attn_mask
+        self.mask_pre_mlp = True
+
+    def attention(self, x: torch.Tensor):
+        """Calculate mask multi-head-attention."""
+        self.attn_mask = self.attn_mask.to(
+            dtype=x.dtype,
+            device=x.device) if self.attn_mask is not None else None
+        return self.attn(
+            x, x, x, need_weights=False, attn_mask=self.attn_mask)[0]
+
+    def forward(self, x: torch.Tensor):
+        """
+        Args:
+            x (torch.Tensor): the input feature.
+        """
+        x = x + self.attention(self.ln_1(x))
+        x = x + self.mlp(self.ln_2(x))
+        return x
+
+    def forward_dense(self, x: torch.Tensor):
+        """Reinplementation of forward function for dense prediction of image
+        encoder in CLIP model.
+
+        Args:
+            x (torch.Tensor): the input feature.
+        """
+        y = self.ln_1(x)
+        y = F.linear(y, self.attn.in_proj_weight, self.attn.in_proj_bias)
+        L, N, D = y.shape  # L N 3D
+
+        y = y.reshape(L, N, 3, D // 3).permute(2, 1, 0,
+                                               3).reshape(3 * N, L, D // 3)
+        y = F.linear(y, self.attn.out_proj.weight, self.attn.out_proj.bias)
+
+        q, k, v = y.tensor_split(3, dim=0)
+        v = v.transpose(1, 0) + x  # L N D
+
+        v = v + self.mlp(self.ln_2(v))
+        return v
+
+
+class Transformer(nn.Module):
+    """General Transformer Architecture for both image and text encoder."""
+
+    def __init__(self,
+                 width: int,
+                 layers: int,
+                 heads: int,
+                 attn_mask: torch.Tensor = None,
+                 prompt_length=0,
+                 prompt_depth=0):
+        super().__init__()
+        self.width = width
+        self.layers = layers
+        self.resblocks = nn.Sequential(*[
+            ResidualAttentionBlock(width, heads, attn_mask)
+            for _ in range(layers)
+        ])
+
+        self.prompt_length = prompt_length
+        self.prompt_depth = prompt_depth
+        self.prompt_tokens = nn.Parameter(
+            torch.zeros(prompt_depth, prompt_length,
+                        width)) if prompt_length > 0 else None
+        if self.prompt_tokens is not None:
+            nn.init.xavier_uniform_(self.prompt_tokens)
+
+    def forward(self, x: torch.Tensor, dense=False):
+        """
+        Args:
+            x (torch.Tensor): input features.
+            dense (bool): whether use reimplemented dense forward
+                function in the last layer.
+        """
+        for i, resblock in enumerate(self.resblocks):
+            if self.prompt_length > 0 and i < self.prompt_depth:
+                length = self.prompt_length + 1 if i > 0 else 1
+                x = torch.cat((x[0:1, :, :], self.prompt_tokens[i].repeat(
+                    x.shape[1], 1, 1).permute(1, 0, 2), x[length:, :, :]))
+
+            if i == self.layers - 1 and dense:
+                x = resblock.forward_dense(x)
+                x = torch.cat((x[0:1, :, :], x[self.prompt_length + 1::, :]),
+                              dim=0)
+            else:
+                x = resblock(x)
+
+        return x
+
+
+class VisualTransformer(nn.Module):
+    """Visual encoder for CLIP model."""
+
+    def __init__(self, input_resolution: int, patch_size: int, width: int,
+                 layers: int, heads: int, output_dim: int, prompt_depth: int,
+                 prompt_length: int):
+        super().__init__()
+        self.output_dim = output_dim
+        self.conv1 = nn.Conv2d(
+            in_channels=3,
+            out_channels=width,
+            kernel_size=patch_size,
+            stride=patch_size,
+            bias=False)
+
+        scale = width**-0.5
+        self.class_embedding = nn.Parameter(scale * torch.randn(width))
+        self.positional_embedding = nn.Parameter(scale * torch.randn(
+            (input_resolution // patch_size)**2 + 1, width))
+        self.ln_pre = LayerNorm(width)
+
+        self.transformer = Transformer(
+            width,
+            layers,
+            heads,
+            prompt_depth=prompt_depth,
+            prompt_length=prompt_length)
+
+        self.ln_post = LayerNorm(width)
+        self.proj = nn.Parameter(scale * torch.randn(width, output_dim))
+
+        self.patch_size = patch_size
+        self.input_resolution = input_resolution
+
+    def forward(self, x: torch.Tensor, dense=False):
+        """
+        Args:
+            x (torch.Tensor): input features.
+            dense (bool): whether use reimplemented dense forward
+                function in the last layer.
+        """
+        x = self.conv1(x)  # shape = [*, width, grid, grid]
+        x = x.reshape(x.shape[0], x.shape[1],
+                      -1)  # shape = [*, width, grid ** 2]
+        x = x.permute(0, 2, 1)  # shape = [*, grid ** 2, width]
+        x = torch.cat([
+            self.class_embedding.to(x.dtype) + torch.zeros(
+                x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device), x
+        ],
+                      dim=1)  # shape = [*, grid ** 2 + 1, width]
+
+        if dense and (x.shape[1] != self.positional_embedding.shape[0]):
+            x = x + self.resized_pos_embed(self.input_resolution,
+                                           x.shape[1]).to(x.dtype)
+        else:
+            x = x + self.positional_embedding.to(x.dtype)
+
+        x = self.ln_pre(x)
+
+        x = x.permute(1, 0, 2)  # NLD -> LND
+        x = self.transformer(x, dense)
+        x = x.permute(1, 0, 2)  # LND -> NLD
+
+        if dense:
+            x = self.ln_post(x[:, :, :])
+        else:
+            x = self.ln_post(x[:, 0, :])
+
+        if self.proj is not None:
+            x = x @ self.proj
+
+        return x
+
+    def resized_pos_embed(self, in_res, tgt_res, mode='bicubic'):
+        """Resize the position embedding."""
+        # assert L == (input_resolution // self.patch_size) ** 2 + 1
+        L, D = self.positional_embedding.shape
+
+        in_side = in_res // self.patch_size
+        # tgt_side = tgt_res // self.patch_size
+        tgt_side = int((tgt_res - 1)**0.5)
+
+        cls_pos = self.positional_embedding[0].unsqueeze(0)  # 1 D
+        pos_embed = self.positional_embedding[1:].reshape(
+            1, in_side, in_side, D).permute(0, 3, 1, 2)  # L-1 D -> 1 D S S
+        resized_pos_embed = F.interpolate(
+            pos_embed,
+            size=(tgt_side, tgt_side),
+            mode=mode,
+            align_corners=False,
+        )  # 1 D S S -> 1 D S' S'
+        resized_pos_embed = resized_pos_embed.squeeze(0).reshape(
+            D, -1).T  # L'-1 D
+
+        return torch.cat((cls_pos, resized_pos_embed), dim=0)
+
+
+class CLIP(nn.Module):
+    """Custom implementation of CLIP model.
+
+    Refer to: https://github.com/openai/CLIP
+    """
+
+    def __init__(
+        self,
+        embed_dim: int,
+        # vision
+        image_resolution: int,
+        vision_layers: Union[Tuple[int, int, int, int], int],
+        vision_width: int,
+        vision_patch_size: int,
+        # text
+        context_length: int,
+        vocab_size: int,
+        transformer_width: int,
+        transformer_heads: int,
+        transformer_layers: int,
+        # prompt
+        prompt_depth: int = 0,
+        prompt_length: int = 0,
+    ):
+        super().__init__()
+
+        self.context_length = context_length
+
+        self.image_resolution = image_resolution
+
+        if isinstance(vision_layers, (tuple, list)):
+            assert prompt_length == 0 and prompt_depth == 0
+            vision_heads = vision_width * 32 // 64
+            self.visual = ModifiedResNet(
+                layers=vision_layers,
+                output_dim=embed_dim,
+                heads=vision_heads,
+                input_resolution=image_resolution,
+                width=vision_width)
+        else:
+            vision_heads = vision_width // 64
+            self.visual = VisualTransformer(
+                input_resolution=image_resolution,
+                patch_size=vision_patch_size,
+                width=vision_width,
+                layers=vision_layers,
+                heads=vision_heads,
+                output_dim=embed_dim,
+                prompt_depth=prompt_depth,
+                prompt_length=prompt_length,
+            )
+
+        self.transformer = Transformer(
+            width=transformer_width,
+            layers=transformer_layers,
+            heads=transformer_heads,
+            attn_mask=self.build_attention_mask())
+
+        self.vocab_size = vocab_size
+        self.token_embedding = nn.Embedding(vocab_size, transformer_width)
+        self.positional_embedding = nn.Parameter(
+            torch.empty(self.context_length, transformer_width))
+        self.ln_final = LayerNorm(transformer_width)
+
+        self.text_projection = nn.Parameter(
+            torch.empty(transformer_width, embed_dim))
+        self.logit_scale = nn.Parameter(torch.ones([]))
+
+    def build_attention_mask(self):
+        """Create causal attention mask."""
+        # lazily create causal attention mask, with full attention between
+        # the vision tokens pytorch uses additive attention mask; fill with
+        # -inf
+        mask = torch.empty(self.context_length, self.context_length)
+        mask.fill_(float('-inf'))
+        mask.triu_(1)  # zero out the lower diagonal
+        return mask
+
+    @property
+    def dtype(self):
+        """Return the dtype of the model."""
+        return self.visual.conv1.weight.dtype
+
+    def encode_image(self, image, masks=None, pool_mask=None, dense=False):
+        """Image encoding."""
+        if pool_mask is not None:
+            return self.visual(
+                image.type(self.dtype), mask=pool_mask, dense=dense)
+        if masks is None:
+            return self.visual(image.type(self.dtype), dense=dense)
+        else:
+            return self.visual(image.type(self.dtype), masks.type(self.dtype))
+
+    def encode_text(self, text):
+        """Texts encoding."""
+        x = self.token_embedding(text).type(
+            self.dtype)  # [batch_size, n_ctx, d_model]
+
+        x = x + self.positional_embedding.type(self.dtype)
+        x = x.permute(1, 0, 2)  # NLD -> LND
+        x = self.transformer(x)
+        x = x.permute(1, 0, 2)  # LND -> NLD
+        x = self.ln_final(x).type(self.dtype)
+
+        # x.shape = [batch_size, n_ctx, transformer.width]
+        # take features from the eot embedding (eot_token is the highest number
+        # in each sequence)
+        x = x[torch.arange(x.shape[0]),
+              text.argmax(dim=-1)] @ self.text_projection
+
+        return x
+
+    def forward(self, image, text):
+        """
+        Args:
+            image (torch.Tensor): input images.
+            text (torch.Tensor): input text.
+        """
+        image_features = self.encode_image(image)
+        text_features = self.encode_text(text)
+        # import pdb; pdb.set_trace()
+        # normalized features
+        # image_features shape: [1, 1024]
+        image_features = image_features / image_features.norm(
+            dim=-1, keepdim=True)
+        text_features = text_features / text_features.norm(
+            dim=-1, keepdim=True)
+
+        # cosine similarity as logits
+        logit_scale = self.logit_scale.exp()
+        logits_per_iamge = logit_scale * image_features @ text_features.t()
+        logits_per_text = logit_scale * text_features @ image_features.t()
+
+        # shape = [global_batch_size, global_batch_size]
+        return logits_per_iamge, logits_per_text
+
+
+def convert_weights(model: nn.Module):
+    """Convert applicable model parameters to fp16."""
+
+    def _convert_weights_to_fp16(layer):
+        if isinstance(layer, (nn.Conv1d, nn.Conv2d, nn.Linear)):
+            layer.weight.data = layer.weight.data.half()
+            if layer.bias is not None:
+                layer.bias.data = layer.bias.data.half()
+
+        if isinstance(layer, nn.MultiheadAttention):
+            for attr in [
+                    *[f'{s}_proj_weight' for s in ['in', 'q', 'k', 'v']],
+                    'in_proj_bias', 'bias_k', 'bias_v'
+            ]:
+                tensor = getattr(layer, attr)
+                if tensor is not None:
+                    tensor.data = tensor.data.half()
+
+        for name in ['text_projection', 'proj']:
+            if hasattr(layer, name):
+                attr = getattr(layer, name)
+                if attr is not None:
+                    attr.data = attr.data.half()
+
+    model.apply(_convert_weights_to_fp16)
+
+
+def build_model(state_dict: dict, prompt_depth=0, prompt_length=0):
+    """Build a CLIP model from given pretrained weights."""
+    vit = 'visual.proj' in state_dict
+
+    if vit:
+        vision_width = state_dict['visual.conv1.weight'].shape[0]
+        vision_layers = len([
+            k for k in state_dict.keys()
+            if k.startswith('visual.') and k.endswith('.attn.in_proj_weight')
+        ])
+        vision_patch_size = state_dict['visual.conv1.weight'].shape[-1]
+        grid_size = round(
+            (state_dict['visual.positional_embedding'].shape[0] - 1)**0.5)
+        image_resolution = vision_patch_size * grid_size
+    else:
+        counts: list = [
+            len({
+                k.split('.')[2]
+                for k in state_dict if k.startswith(f'visual.layer{b}')
+            }) for b in [1, 2, 3, 4]
+        ]
+        vision_layers = tuple(counts)
+        vision_width = state_dict['visual.layer1.0.conv1.weight'].shape[0]
+        output_width = round(
+            (state_dict['visual.attnpool.positional_embedding'].shape[0] -
+             1)**0.5)
+        vision_patch_size = None
+        assert output_width**2 + 1 == state_dict[
+            'visual.attnpool.positional_embedding'].shape[0]
+        image_resolution = output_width * 32
+
+    embed_dim = state_dict['text_projection'].shape[1]
+    context_length = state_dict['positional_embedding'].shape[0]
+    vocab_size = state_dict['token_embedding.weight'].shape[0]
+    transformer_width = state_dict['ln_final.weight'].shape[0]
+    transformer_heads = transformer_width // 64
+    transformer_layers = len({
+        k.split('.')[2]
+        for k in state_dict if k.startswith('transformer.resblocks')
+    })
+
+    model = CLIP(
+        embed_dim,
+        image_resolution,
+        vision_layers,
+        vision_width,
+        vision_patch_size,
+        context_length,
+        vocab_size,
+        transformer_width,
+        transformer_heads,
+        transformer_layers,
+        prompt_depth=prompt_depth,
+        prompt_length=prompt_length,
+    )
+
+    for key in ['input_resolution', 'context_length', 'vocab_size']:
+        del state_dict[key]
+
+    convert_weights(model)
+    model.load_state_dict(state_dict, strict=False)
+    return model.eval()
diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_templates.py b/mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_templates.py
new file mode 100644
index 0000000..bfc32df
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_templates.py
@@ -0,0 +1,204 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Source: https://github.com/openai/CLIP.
+
+IMAGENET_TEMPLATES = [
+    'a bad photo of a {}.',
+    'a photo of many {}.',
+    'a sculpture of a {}.',
+    'a photo of the hard to see {}.',
+    'a low resolution photo of the {}.',
+    'a rendering of a {}.',
+    'graffiti of a {}.',
+    'a bad photo of the {}.',
+    'a cropped photo of the {}.',
+    'a tattoo of a {}.',
+    'the embroidered {}.',
+    'a photo of a hard to see {}.',
+    'a bright photo of a {}.',
+    'a photo of a clean {}.',
+    'a photo of a dirty {}.',
+    'a dark photo of the {}.',
+    'a drawing of a {}.',
+    'a photo of my {}.',
+    'the plastic {}.',
+    'a photo of the cool {}.',
+    'a close-up photo of a {}.',
+    'a black and white photo of the {}.',
+    'a painting of the {}.',
+    'a painting of a {}.',
+    'a pixelated photo of the {}.',
+    'a sculpture of the {}.',
+    'a bright photo of the {}.',
+    'a cropped photo of a {}.',
+    'a plastic {}.',
+    'a photo of the dirty {}.',
+    'a jpeg corrupted photo of a {}.',
+    'a blurry photo of the {}.',
+    'a photo of the {}.',
+    'a good photo of the {}.',
+    'a rendering of the {}.',
+    'a {} in a video game.',
+    'a photo of one {}.',
+    'a doodle of a {}.',
+    'a close-up photo of the {}.',
+    'a photo of a {}.',
+    'the origami {}.',
+    'the {} in a video game.',
+    'a sketch of a {}.',
+    'a doodle of the {}.',
+    'a origami {}.',
+    'a low resolution photo of a {}.',
+    'the toy {}.',
+    'a rendition of the {}.',
+    'a photo of the clean {}.',
+    'a photo of a large {}.',
+    'a rendition of a {}.',
+    'a photo of a nice {}.',
+    'a photo of a weird {}.',
+    'a blurry photo of a {}.',
+    'a cartoon {}.',
+    'art of a {}.',
+    'a sketch of the {}.',
+    'a embroidered {}.',
+    'a pixelated photo of a {}.',
+    'itap of the {}.',
+    'a jpeg corrupted photo of the {}.',
+    'a good photo of a {}.',
+    'a plushie {}.',
+    'a photo of the nice {}.',
+    'a photo of the small {}.',
+    'a photo of the weird {}.',
+    'the cartoon {}.',
+    'art of the {}.',
+    'a drawing of the {}.',
+    'a photo of the large {}.',
+    'a black and white photo of a {}.',
+    'the plushie {}.',
+    'a dark photo of a {}.',
+    'itap of a {}.',
+    'graffiti of the {}.',
+    'a toy {}.',
+    'itap of my {}.',
+    'a photo of a cool {}.',
+    'a photo of a small {}.',
+    'a tattoo of the {}.',
+    # 'A photo of a {} in the scene.',
+]
+
+# v1: 59.0875
+IMAGENET_TEMPLATES_SELECT = [
+    'itap of a {}.',
+    'a bad photo of the {}.',
+    'a origami {}.',
+    'a photo of the large {}.',
+    'a {} in a video game.',
+    'art of the {}.',
+    'a photo of the small {}.',
+    'A photo of a {} in the scene',
+]
+
+# v9
+IMAGENET_TEMPLATES_SELECT_CLIP = [
+    'a bad photo of the {}.',
+    'a photo of the large {}.',
+    'a photo of the small {}.',
+    'a cropped photo of a {}.',
+    'This is a photo of a {}',
+    'This is a photo of a small {}',
+    'This is a photo of a medium {}',
+    'This is a photo of a large {}',
+    'This is a masked photo of a {}',
+    'This is a masked photo of a small {}',
+    'This is a masked photo of a medium {}',
+    'This is a masked photo of a large {}',
+    'This is a cropped photo of a {}',
+    'This is a cropped photo of a small {}',
+    'This is a cropped photo of a medium {}',
+    'This is a cropped photo of a large {}',
+    'A photo of a {} in the scene',
+    'a bad photo of the {} in the scene',
+    'a photo of the large {} in the scene',
+    'a photo of the small {} in the scene',
+    'a cropped photo of a {} in the scene',
+    'a photo of a masked {} in the scene',
+    'There is a {} in the scene',
+    'There is the {} in the scene',
+    'This is a {} in the scene',
+    'This is the {} in the scene',
+    'This is one {} in the scene',
+    'There is a masked {} in the scene',
+    'There is the masked {} in the scene',
+    'This is a masked {} in the scene',
+    'This is the masked {} in the scene',
+    'This is one masked {} in the scene',
+]
+
+# v10, for comparison
+# IMAGENET_TEMPLATES_SELECT_CLIP = [
+#     'a photo of a {}.',
+#
+#     'This is a photo of a {}',
+#     'This is a photo of a small {}',
+#     'This is a photo of a medium {}',
+#     'This is a photo of a large {}',
+#
+#     'This is a photo of a {}',
+#     'This is a photo of a small {}',
+#     'This is a photo of a medium {}',
+#     'This is a photo of a large {}',
+#
+#     'a photo of a {} in the scene',
+#     'a photo of a {} in the scene',
+#
+#     'There is a {} in the scene',
+#     'There is the {} in the scene',
+#     'This is a {} in the scene',
+#     'This is the {} in the scene',
+#     'This is one {} in the scene',
+# ]
+
+ViLD_templates = [
+    'There is {article} {category} in the scene.',
+    'There is the {category} in the scene.',
+    'a photo of {article} {category} in the scene.',
+    'a photo of the {category} in the scene.',
+    'a photo of one {category} in the scene.', 'itap of {article} {category}.',
+    'itap of my {category}.', 'itap of the {category}.',
+    'a photo of {article} {category}.', 'a photo of my {category}.',
+    'a photo of the {category}.', 'a photo of one {category}.',
+    'a photo of many {category}.', 'a good photo of {article} {category}.',
+    'a good photo of the {category}.', 'a bad photo of {article} {category}.',
+    'a bad photo of the {category}.', 'a photo of a nice {category}.',
+    'a photo of the nice {category}.', 'a photo of a cool {category}.',
+    'a photo of the cool {category}.', 'a photo of a weird {category}.',
+    'a photo of the weird {category}.', 'a photo of a small {category}.',
+    'a photo of the small {category}.', 'a photo of a large {category}.',
+    'a photo of the large {category}.', 'a photo of a clean {category}.',
+    'a photo of the clean {category}.', 'a photo of a dirty {category}.',
+    'a photo of the dirty {category}.',
+    'a bright photo of {article} {category}.',
+    'a bright photo of the {category}.',
+    'a dark photo of {article} {category}.', 'a dark photo of the {category}.',
+    'a photo of a hard to see {category}.',
+    'a photo of the hard to see {category}.',
+    'a low resolution photo of {article} {category}.',
+    'a low resolution photo of the {category}.',
+    'a cropped photo of {article} {category}.',
+    'a cropped photo of the {category}.',
+    'a close-up photo of {article} {category}.',
+    'a close-up photo of the {category}.',
+    'a jpeg corrupted photo of {article} {category}.',
+    'a jpeg corrupted photo of the {category}.',
+    'a blurry photo of {article} {category}.',
+    'a blurry photo of the {category}.',
+    'a pixelated photo of {article} {category}.',
+    'a pixelated photo of the {category}.',
+    'a black and white photo of the {category}.',
+    'a black and white photo of {article} {category}.',
+    'a plastic {category}.', 'the plastic {category}.', 'a toy {category}.',
+    'the toy {category}.', 'a plushie {category}.', 'the plushie {category}.',
+    'a cartoon {category}.', 'the cartoon {category}.',
+    'an embroidered {category}.', 'the embroidered {category}.',
+    'a painting of the {category}.', 'a painting of a {category}.'
+]
diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_wrapper.py b/mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_wrapper.py
new file mode 100644
index 0000000..f809d2b
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_wrapper.py
@@ -0,0 +1,275 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# Referred to: https://github.com/KU-CVLAB/CAT-Seg/blob/main/cat_seg/third_party/clip.py # noqa
+import hashlib
+import os
+import urllib
+import warnings
+from typing import List, Union
+
+import torch
+from PIL import Image
+from torchvision.transforms import (CenterCrop, Compose, Normalize, Resize,
+                                    ToTensor)
+from tqdm import tqdm
+
+from .clip_model import build_model
+from .tokenizer import SimpleTokenizer as _Tokenizer
+
+__all__ = ['available_models', 'load', 'tokenize']
+_tokenizer = _Tokenizer()
+
+_MODELS = {
+    'RN50':
+    'https://openaipublic.azureedge.net/clip/models/afeb0e10f9e5a86da6080e35cf09123aca3b358a0c3e3b6c78a7b63bc04b6762/RN50.pt',  # noqa
+    'RN101':
+    'https://openaipublic.azureedge.net/clip/models/8fa8567bab74a42d41c5915025a8e4538c3bdbe8804a470a72f30b0d94fab599/RN101.pt',  # noqa
+    'RN50x4':
+    'https://openaipublic.azureedge.net/clip/models/7e526bd135e493cef0776de27d5f42653e6b4c8bf9e0f653bb11773263205fdd/RN50x4.pt',  # noqa
+    'RN50x16':
+    'https://openaipublic.azureedge.net/clip/models/52378b407f34354e150460fe41077663dd5b39c54cd0bfd2b27167a4a06ec9aa/RN50x16.pt',  # noqa
+    'RN50x64':
+    'https://openaipublic.azureedge.net/clip/models/be1cfb55d75a9666199fb2206c106743da0f6468c9d327f3e0d0a543a9919d9c/RN50x64.pt',  # noqa
+    'ViT-B/32':
+    'https://openaipublic.azureedge.net/clip/models/40d365715913c9da98579312b702a82c18be219cc2a73407c4526f58eba950af/ViT-B-32.pt',  # noqa
+    'ViT-B/16':
+    'https://openaipublic.azureedge.net/clip/models/5806e77cd80f8b59890b7e101eabd078d9fb84e6937f9e85e4ecb61988df416f/ViT-B-16.pt',  # noqa
+    'ViT-L/14':
+    'https://openaipublic.azureedge.net/clip/models/b8cca3fd41ae0c99ba7e8951adf17d267cdb84cd88be6f7c2e0eca1737a03836/ViT-L-14.pt',  # noqa
+    'ViT-L/14@336px':
+    'https://openaipublic.azureedge.net/clip/models/3035c92b350959924f9f00213499208652fc7ea050643e8b385c2dac08641f02/ViT-L-14-336px.pt',  # noqa
+}
+
+
+def _download(url: str, root: str = os.path.expanduser('~/.cache/clip')):
+    """Download clip pretrained weights."""
+    os.makedirs(root, exist_ok=True)
+    filename = os.path.basename(url)
+
+    expected_sha256 = url.split('/')[-2]
+    download_target = os.path.join(root, filename)
+
+    if os.path.exists(download_target) and not os.path.isfile(download_target):
+        raise RuntimeError(
+            f'{download_target} exists and is not a regular file')
+
+    if os.path.isfile(download_target):
+        if hashlib.sha256(open(download_target,
+                               'rb').read()).hexdigest() == expected_sha256:
+            return download_target
+        else:
+            warnings.warn(
+                f'{download_target} exists, but the SHA256 checksum does not\
+                match; re-downloading the file')
+
+    with urllib.request.urlopen(url) as source, open(download_target,
+                                                     'wb') as output:
+        with tqdm(
+                total=int(source.info().get('Content-Length')),
+                ncols=80) as loop:
+            while True:
+                buffer = source.read(8192)
+                if not buffer:
+                    break
+
+                output.write(buffer)
+                loop.update(len(buffer))
+
+    if hashlib.sha256(open(download_target,
+                           'rb').read()).hexdigest() != expected_sha256:
+        raise RuntimeError(
+            'Model has been downloaded but the SHA256 checksum does not not\
+                match')
+
+    return download_target
+
+
+def available_models():
+    """Returns a list of available models."""
+    return list(_MODELS.keys())
+
+
+def load(name: str,
+         device: Union[str, torch.device] = 'cuda'
+         if torch.cuda.is_available() else 'cpu',
+         jit=True,
+         prompt_depth=0,
+         prompt_length=0):
+    """Load target clip model."""
+    if name not in _MODELS:
+        raise RuntimeError(
+            f'Model {name} not found; available models = {available_models()}')
+
+    model_path = _download(_MODELS[name])
+    model = torch.jit.load(
+        model_path, map_location=device if jit else 'cpu').eval()
+    n_px = model.input_resolution.item()
+
+    transform = Compose([
+        Resize(n_px, interpolation=Image.BICUBIC),
+        CenterCrop(n_px),
+        lambda image: image.convert('RGB'),
+        ToTensor(),
+        Normalize((0.48145466, 0.4578275, 0.40821073),
+                  (0.26862954, 0.26130258, 0.27577711)),
+    ])
+
+    if not jit:
+        model = build_model(model.state_dict(), prompt_depth,
+                            prompt_length).to(device)
+        return model, transform
+
+    # patch the device names
+    device_holder = torch.jit.trace(
+        lambda: torch.ones([]).to(torch.device(device)), example_inputs=[])
+    device_node = [
+        n for n in device_holder.graph.findAllNodes('prim::Constant')
+        if 'Device' in repr(n)
+    ][-1]
+
+    def patch_device(module):
+        graphs = [module.graph] if hasattr(module, 'graph') else []
+        if hasattr(module, 'forward1'):
+            graphs.append(module.forward1.graph)
+
+        for graph in graphs:
+            for node in graph.findAllNodes('prim::Constant'):
+                if 'value' in node.attributeNames() and str(
+                        node['value']).startswith('cuda'):
+                    node.copyAttributes(device_node)
+
+    model.apply(patch_device)
+    patch_device(model.encode_image)
+    patch_device(model.encode_text)
+
+    # patch dtype to float32 on CPU
+    if device == 'cpu':
+        float_holder = torch.jit.trace(
+            lambda: torch.ones([]).float(), example_inputs=[])
+        float_input = list(float_holder.graph.findNode('aten::to').inputs())[1]
+        float_node = float_input.node()
+
+        def patch_float(module):
+            graphs = [module.graph] if hasattr(module, 'graph') else []
+            if hasattr(module, 'forward1'):
+                graphs.append(module.forward1.graph)
+
+            for graph in graphs:
+                for node in graph.findAllNodes('aten::to'):
+                    inputs = list(node.inputs())
+                    for i in [1, 2]:
+                        # dtype can be the second or third argument to
+                        # aten::to()
+                        if inputs[i].node()['value'] == 5:
+                            inputs[i].node().copyAttributes(float_node)
+
+        model.apply(patch_float)
+        patch_float(model.encode_image)
+        patch_float(model.encode_text)
+
+        model.float()
+
+    return model, transform
+
+
+def load_custom(name: str,
+                device: Union[str, torch.device] = 'cuda'
+                if torch.cuda.is_available() else 'cpu',
+                jit=True,
+                n_px=224):
+    """Load a customized clip model."""
+    if name not in _MODELS:
+        raise RuntimeError(
+            f'Model {name} not found; available models = {available_models()}')
+
+    model_path = _download(_MODELS[name])
+    model = torch.jit.load(
+        model_path, map_location=device if jit else 'cpu').eval()
+    # n_px = model.input_resolution.item()
+
+    transform = Compose([
+        Resize(n_px, interpolation=Image.BICUBIC),
+        CenterCrop(n_px),
+        lambda image: image.convert('RGB'),
+        ToTensor(),
+        Normalize((0.48145466, 0.4578275, 0.40821073),
+                  (0.26862954, 0.26130258, 0.27577711)),
+    ])
+
+    if not jit:
+        model = build_model(model.state_dict()).to(device)
+        return model, transform
+
+    # patch the device names
+    device_holder = torch.jit.trace(
+        lambda: torch.ones([]).to(torch.device(device)), example_inputs=[])
+    device_node = [
+        n for n in device_holder.graph.findAllNodes('prim::Constant')
+        if 'Device' in repr(n)
+    ][-1]
+
+    def patch_device(module):
+        graphs = [module.graph] if hasattr(module, 'graph') else []
+        if hasattr(module, 'forward1'):
+            graphs.append(module.forward1.graph)
+
+        for graph in graphs:
+            for node in graph.findAllNodes('prim::Constant'):
+                if 'value' in node.attributeNames() and str(
+                        node['value']).startswith('cuda'):
+                    node.copyAttributes(device_node)
+
+    model.apply(patch_device)
+    patch_device(model.encode_image)
+    patch_device(model.encode_text)
+
+    # patch dtype to float32 on CPU
+    if device == 'cpu':
+        float_holder = torch.jit.trace(
+            lambda: torch.ones([]).float(), example_inputs=[])
+        float_input = list(float_holder.graph.findNode('aten::to').inputs())[1]
+        float_node = float_input.node()
+
+        def patch_float(module):
+            graphs = [module.graph] if hasattr(module, 'graph') else []
+            if hasattr(module, 'forward1'):
+                graphs.append(module.forward1.graph)
+
+            for graph in graphs:
+                for node in graph.findAllNodes('aten::to'):
+                    inputs = list(node.inputs())
+                    for i in [
+                            1, 2
+                    ]:  # dtype can be the second or third argument to
+                        # aten::to()
+                        if inputs[i].node()['value'] == 5:
+                            inputs[i].node().copyAttributes(float_node)
+
+        model.apply(patch_float)
+        patch_float(model.encode_image)
+        patch_float(model.encode_text)
+
+        model.float()
+
+    return model, transform
+
+
+def tokenize(texts: Union[str, List[str]], context_length: int = 77):
+    """Convert texts to tokens."""
+    if isinstance(texts, str):
+        texts = [texts]
+
+    sot_token = _tokenizer.encoder['<|startoftext|>']
+    eot_token = _tokenizer.encoder['<|endoftext|>']
+    # encode each template text phrase
+    all_tokens = [[sot_token] + _tokenizer.encode(text) + [eot_token]
+                  for text in texts]
+    result = torch.zeros(len(all_tokens), context_length, dtype=torch.long)
+
+    for i, tokens in enumerate(all_tokens):
+        if len(tokens) > context_length:
+            raise RuntimeError(
+                f'Input {texts[i]} is too long for context length\
+                    {context_length}')
+        result[i, :len(tokens)] = torch.tensor(tokens)
+
+    return result
diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/utils/self_attention_block.py b/mmsegmentation/projects/CAT-Seg/cat_seg/utils/self_attention_block.py
new file mode 100644
index 0000000..1c06cbd
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/cat_seg/utils/self_attention_block.py
@@ -0,0 +1,79 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from torch import nn as nn
+from torch.nn import functional as F
+
+
+class LinearAttention(nn.Module):
+    """Multi-Head linear attention proposed in "Transformers are RNNs".
+
+    Source: https://github.com/KU-CVLAB/CAT-Seg/blob/main/cat_seg/modeling/transformer/model.py#L247 # noqa
+    """
+
+    def __init__(self, eps=1e-6):
+        super().__init__()
+        self.eps = eps
+
+    def forward(self, queries, keys, values):
+        """
+        Args:
+            queries: [N, L, H, D]
+            keys: [N, S, H, D]
+            values: [N, S, H, D]
+            q_mask: [N, L]
+            kv_mask: [N, S]
+        Returns:
+            queried_values: (N, L, H, D)
+        """
+        Q = F.elu(queries) + 1
+        K = F.elu(keys) + 1
+
+        v_length = values.size(1)
+        values = values / v_length  # prevent fp16 overflow
+        KV = torch.einsum('nshd,nshv->nhdv', K, values)  # (S,D)' @ S,V
+        Z = 1 / (torch.einsum('nlhd,nhd->nlh', Q, K.sum(dim=1)) + self.eps)
+        queried_values = torch.einsum('nlhd,nhdv,nlh->nlhv', Q, KV,
+                                      Z) * v_length
+
+        return queried_values.contiguous()
+
+
+class FullAttention(nn.Module):
+    """Multi-head scaled dot-product attention, a.k.a full attention.
+
+    Source: https://github.com/KU-CVLAB/CAT-Seg/blob/main/cat_seg/modeling/transformer/model.py#L276 # noqa
+    """
+
+    def __init__(self, use_dropout=False, attention_dropout=0.1):
+        super().__init__()
+        self.use_dropout = use_dropout
+        self.dropout = nn.Dropout(attention_dropout)
+
+    def forward(self, queries, keys, values, q_mask=None, kv_mask=None):
+        """
+        Args:
+            queries: [N, L, H, D]
+            keys: [N, S, H, D]
+            values: [N, S, H, D]
+            q_mask: [N, L]
+            kv_mask: [N, S]
+        Returns:
+            queried_values: (N, L, H, D)
+        """
+
+        # Compute the unnormalized attention and apply the masks
+        QK = torch.einsum('nlhd,nshd->nlsh', queries, keys)
+        if kv_mask is not None:
+            QK.masked_fill_(
+                ~(q_mask[:, :, None, None] * kv_mask[:, None, :, None]),
+                float('-inf'))
+
+        # Compute the attention and the weighted average
+        softmax_temp = 1. / queries.size(3)**.5  # sqrt(D)
+        A = torch.softmax(softmax_temp * QK, dim=2)
+        if self.use_dropout:
+            A = self.dropout(A)
+
+        queried_values = torch.einsum('nlsh,nshd->nlhd', A, values)
+
+        return queried_values.contiguous()
diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/utils/tokenizer.py b/mmsegmentation/projects/CAT-Seg/cat_seg/utils/tokenizer.py
new file mode 100644
index 0000000..c84711b
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/cat_seg/utils/tokenizer.py
@@ -0,0 +1,160 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import gzip
+import html
+import os
+from functools import lru_cache
+
+import ftfy
+import regex as re
+
+
+@lru_cache()
+def default_bpe():
+    """Return default BPE vocabulary path."""
+    return os.path.join(
+        os.path.dirname(os.path.abspath(__file__)),
+        'bpe_vocab/bpe_simple_vocab_16e6.txt.gz')
+
+
+@lru_cache()
+def bytes_to_unicode():
+    """Returns list of utf-8 byte and a corresponding list of unicode strings.
+
+    The reversible bpe codes work on unicode strings. This means you need a
+    large # of unicode characters in your vocab if you want to avoid UNKs. When
+    you're at something like a 10B token dataset you end up needing around 5K
+    for decent coverage. This is a significant percentage of your normal, say,
+    32K bpe vocab. To avoid that, we want lookup tables between utf-8 bytes and
+    unicode strings. And avoids mapping to whitespace/control characters the
+    bpe code barfs on.
+    """
+    bs = list(range(ord('!'),
+                    ord('~') + 1)) + list(range(
+                        ord('¡'),
+                        ord('¬') + 1)) + list(range(ord('®'),
+                                                    ord('ÿ') + 1))
+    cs = bs[:]
+    n = 0
+    for b in range(2**8):
+        if b not in bs:
+            bs.append(b)
+            cs.append(2**8 + n)
+            n += 1
+    cs = [chr(n) for n in cs]
+    return dict(zip(bs, cs))
+
+
+def get_pairs(word):
+    """Return set of symbol pairs in a word.
+
+    Word is represented as tuple of symbols (symbols being variable-length
+    strings).
+    """
+    pairs = set()
+    prev_char = word[0]
+    for char in word[1:]:
+        pairs.add((prev_char, char))
+        prev_char = char
+    return pairs
+
+
+def basic_clean(text):
+    """Clean string."""
+    text = ftfy.fix_text(text)
+    text = html.unescape(html.unescape(text))
+    return text.strip()
+
+
+def whitespace_clean(text):
+    """Clean whitespace in string."""
+    text = re.sub(r'\s+', ' ', text)
+    text = text.strip()
+    return text
+
+
+class SimpleTokenizer:
+    """Customized Tokenizer implementation."""
+
+    def __init__(self, bpe_path: str = default_bpe()):
+        self.byte_encoder = bytes_to_unicode()
+        self.byte_decoder = {v: k for k, v in self.byte_encoder.items()}
+        merges = gzip.open(bpe_path).read().decode('utf-8').split('\n')
+        merges = merges[1:49152 - 256 - 2 + 1]
+        merges = [tuple(merge.split()) for merge in merges]
+        vocab = list(bytes_to_unicode().values())
+        vocab = vocab + [v + '</w>' for v in vocab]
+        for merge in merges:
+            vocab.append(''.join(merge))
+        vocab.extend(['<|startoftext|>', '<|endoftext|>'])
+        self.encoder = dict(zip(vocab, range(len(vocab))))
+        self.decoder = {v: k for k, v in self.encoder.items()}
+        self.bpe_ranks = dict(zip(merges, range(len(merges))))
+        self.cache = {
+            '<|startoftext|>': '<|startoftext|>',
+            '<|endoftext|>': '<|endoftext|>'
+        }
+        self.pat = re.compile(
+            r"""<\|startoftext\|>|<\|endoftext\|>|'s|'t|'re|'ve|'m|\
+                'll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""", re.IGNORECASE)
+
+    def bpe(self, token):
+        """Refer to bpe vocabulary dictionary."""
+        if token in self.cache:
+            return self.cache[token]
+        word = tuple(token[:-1]) + (token[-1] + '</w>', )
+        pairs = get_pairs(word)
+
+        if not pairs:
+            return token + '</w>'
+
+        while True:
+            bigram = min(
+                pairs, key=lambda pair: self.bpe_ranks.get(pair, float('inf')))
+            if bigram not in self.bpe_ranks:
+                break
+            first, second = bigram
+            new_word = []
+            i = 0
+            while i < len(word):
+                try:
+                    j = word.index(first, i)
+                    new_word.extend(word[i:j])
+                    i = j
+                except ValueError:
+                    new_word.extend(word[i:])
+                    break
+
+                if word[i] == first and i < len(word) - 1 and word[
+                        i + 1] == second:
+                    new_word.append(first + second)
+                    i += 2
+                else:
+                    new_word.append(word[i])
+                    i += 1
+            new_word = tuple(new_word)
+            word = new_word
+            if len(word) == 1:
+                break
+            else:
+                pairs = get_pairs(word)
+        word = ' '.join(word)
+        self.cache[token] = word
+        return word
+
+    def encode(self, text):
+        """Encode text strings."""
+        bpe_tokens = []
+        text = whitespace_clean(basic_clean(text)).lower()
+        for token in re.findall(self.pat, text):
+            token = ''.join(self.byte_encoder[b]
+                            for b in token.encode('utf-8'))
+            bpe_tokens.extend(self.encoder[bpe_token]
+                              for bpe_token in self.bpe(token).split(' '))
+        return bpe_tokens
+
+    def decode(self, tokens):
+        """Decoder tokens to strings."""
+        text = ''.join([self.decoder[token] for token in tokens])
+        text = bytearray([self.byte_decoder[c] for c in text]).decode(
+            'utf-8', errors='replace').replace('</w>', ' ')
+        return text
diff --git a/mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/ade20k_384x384.py b/mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/ade20k_384x384.py
new file mode 100644
index 0000000..488ba3d
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/ade20k_384x384.py
@@ -0,0 +1,68 @@
+# dataset settings
+dataset_type = 'ADE20KDataset'
+data_root = 'data/ade/ADEChallengeData2016'
+crop_size = (384, 384)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(
+        type='RandomResize',
+        scale=(2048, 512),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/training', seg_map_path='annotations/training'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/coco-stuff164k_384x384.py b/mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/coco-stuff164k_384x384.py
new file mode 100644
index 0000000..dd05176
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/coco-stuff164k_384x384.py
@@ -0,0 +1,62 @@
+# dataset settings
+dataset_type = 'COCOStuffDataset'
+data_root = 'data/coco_stuff164k'
+crop_size = (384, 384)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/train2017', seg_map_path='annotations/train2017'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/val2017', seg_map_path='annotations/val2017'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/pascal_context_59_384x384.py b/mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/pascal_context_59_384x384.py
new file mode 100644
index 0000000..250c599
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/pascal_context_59_384x384.py
@@ -0,0 +1,72 @@
+# dataset settings
+dataset_type = 'PascalContextDataset59'
+data_root = 'data/VOCdevkit/VOC2010/'
+
+img_scale = (520, 520)
+crop_size = (384, 384)
+
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(
+        type='RandomResize',
+        scale=img_scale,
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='JPEGImages', seg_map_path='SegmentationClassContext'),
+        ann_file='ImageSets/SegmentationContext/train.txt',
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='JPEGImages', seg_map_path='SegmentationClassContext'),
+        ann_file='ImageSets/SegmentationContext/val.txt',
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/projects/CAT-Seg/configs/_base_/default_runtime.py b/mmsegmentation/projects/CAT-Seg/configs/_base_/default_runtime.py
new file mode 100644
index 0000000..272b4d2
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/configs/_base_/default_runtime.py
@@ -0,0 +1,15 @@
+default_scope = 'mmseg'
+env_cfg = dict(
+    cudnn_benchmark=True,
+    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+    dist_cfg=dict(backend='nccl'),
+)
+vis_backends = [dict(type='LocalVisBackend')]
+visualizer = dict(
+    type='SegLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+log_processor = dict(by_epoch=False)
+log_level = 'INFO'
+load_from = None
+resume = False
+
+tta_model = dict(type='SegTTAModel')
diff --git a/mmsegmentation/projects/CAT-Seg/configs/_base_/schedules/schedule_80k.py b/mmsegmentation/projects/CAT-Seg/configs/_base_/schedules/schedule_80k.py
new file mode 100644
index 0000000..0dcd6c4
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/configs/_base_/schedules/schedule_80k.py
@@ -0,0 +1,24 @@
+# optimizer
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=0,
+        end=80000,
+        by_epoch=False)
+]
+# training schedule for 80k
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=80000, val_interval=8000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=8000),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))
diff --git a/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb1-warmcoslr2e-4-adamw-80k_ade20k-384x384.py b/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb1-warmcoslr2e-4-adamw-80k_ade20k-384x384.py
new file mode 100644
index 0000000..bab43a6
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb1-warmcoslr2e-4-adamw-80k_ade20k-384x384.py
@@ -0,0 +1,103 @@
+_base_ = [
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py',
+    '../_base_/datasets/ade20k_384x384.py'
+]
+
+custom_imports = dict(imports=['cat_seg'])
+
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+crop_size = (384, 384)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    size=crop_size,
+    # due to the clip model, we do normalization in backbone forward()
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+# model_cfg
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='CLIPOVCATSeg',
+        feature_extractor=dict(
+            type='ResNet',
+            depth=101,
+            # only use the first three layers
+            num_stages=3,
+            out_indices=(0, 1, 2),
+            dilations=(1, 1, 1),
+            strides=(1, 2, 2),
+            norm_cfg=norm_cfg,
+            norm_eval=False,
+            style='pytorch',
+            contract_dilation=True,
+            init_cfg=dict(
+                type='Pretrained', checkpoint='torchvision://resnet101'),
+        ),
+        train_class_json='data/ade150.json',
+        test_class_json='data/ade150.json',
+        clip_pretrained='ViT-B/16',
+        clip_finetune='attention',
+    ),
+    neck=dict(
+        type='CATSegAggregator',
+        appearance_guidance_dim=1024,
+        num_layers=2,
+        pooling_size=(1, 1),
+    ),
+    decode_head=dict(
+        type='CATSegHead',
+        in_channels=128,
+        channels=128,
+        num_classes=150,
+        embed_dims=128,
+        decoder_dims=(64, 32),
+        decoder_guidance_dims=(512, 256),
+        decoder_guidance_proj_dims=(32, 16),
+        loss_decode=dict(
+            type='CrossEntropyLoss',
+            use_sigmoid=False,
+            loss_weight=1.0,
+            avg_non_ignore=True)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='slide', stride=crop_size, crop_size=crop_size))
+
+# dataset settings
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=4,
+)
+
+# training schedule for 80k
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=80000, val_interval=4000)
+
+default_hooks = dict(
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=4000),
+    visualization=dict(type='SegVisualizationHook', draw=True, interval=4000))
+
+# optimizer
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.0002, betas=(0.9, 0.999), weight_decay=0.0001),
+    paramwise_cfg=dict(
+        custom_keys={
+            'backbone.feature_extractor': dict(lr_mult=0.01),
+            'backbone.clip_model.visual': dict(lr_mult=0.01)
+        }))
+
+# learning policy
+param_scheduler = [
+    # Use a linear warm-up at [0, 100) iterations
+    dict(type='LinearLR', start_factor=0.01, by_epoch=False, begin=0, end=500),
+    # Use a cosine learning rate at [100, 900) iterations
+    dict(
+        type='CosineAnnealingLR',
+        T_max=79500,
+        by_epoch=False,
+        begin=500,
+        end=80000),
+]
diff --git a/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb1-warmcoslr2e-4-adamw-80k_pascal-context-59-384x384.py b/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb1-warmcoslr2e-4-adamw-80k_pascal-context-59-384x384.py
new file mode 100644
index 0000000..8b412cb
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb1-warmcoslr2e-4-adamw-80k_pascal-context-59-384x384.py
@@ -0,0 +1,103 @@
+_base_ = [
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py',
+    '../_base_/datasets/pascal_context_59_384x384.py'
+]
+
+custom_imports = dict(imports=['cat_seg'])
+
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+crop_size = (384, 384)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    size=crop_size,
+    # due to the clip model, we do normalization in backbone forward()
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+# model_cfg
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='CLIPOVCATSeg',
+        feature_extractor=dict(
+            type='ResNet',
+            depth=101,
+            # only use the first three layers
+            num_stages=3,
+            out_indices=(0, 1, 2),
+            dilations=(1, 1, 1),
+            strides=(1, 2, 2),
+            norm_cfg=norm_cfg,
+            norm_eval=False,
+            style='pytorch',
+            contract_dilation=True,
+            init_cfg=dict(
+                type='Pretrained', checkpoint='torchvision://resnet101'),
+        ),
+        train_class_json='data/pc59.json',
+        test_class_json='data/pc59.json',
+        clip_pretrained='ViT-B/16',
+        clip_finetune='attention',
+    ),
+    neck=dict(
+        type='CATSegAggregator',
+        appearance_guidance_dim=1024,
+        num_layers=2,
+        pooling_size=(1, 1),
+    ),
+    decode_head=dict(
+        type='CATSegHead',
+        in_channels=128,
+        channels=128,
+        num_classes=59,
+        embed_dims=128,
+        decoder_dims=(64, 32),
+        decoder_guidance_dims=(512, 256),
+        decoder_guidance_proj_dims=(32, 16),
+        loss_decode=dict(
+            type='CrossEntropyLoss',
+            use_sigmoid=False,
+            loss_weight=1.0,
+            avg_non_ignore=True)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='slide', stride=crop_size, crop_size=crop_size))
+
+# dataset settings
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=4,
+)
+
+# training schedule for 80k
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=80000, val_interval=4000)
+
+default_hooks = dict(
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=4000),
+    visualization=dict(type='SegVisualizationHook', draw=True, interval=4000))
+
+# optimizer
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.0002, betas=(0.9, 0.999), weight_decay=0.0001),
+    paramwise_cfg=dict(
+        custom_keys={
+            'backbone.feature_extractor': dict(lr_mult=0.01),
+            'backbone.clip_model.visual': dict(lr_mult=0.01)
+        }))
+
+# learning policy
+param_scheduler = [
+    # Use a linear warm-up at [0, 100) iterations
+    dict(type='LinearLR', start_factor=0.01, by_epoch=False, begin=0, end=500),
+    # Use a cosine learning rate at [100, 900) iterations
+    dict(
+        type='CosineAnnealingLR',
+        T_max=79500,
+        by_epoch=False,
+        begin=500,
+        end=80000),
+]
diff --git a/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb2-warmcoslr2e-4-adamw-80k_coco-stuff164k-384x384.py b/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb2-warmcoslr2e-4-adamw-80k_coco-stuff164k-384x384.py
new file mode 100644
index 0000000..52bf712
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb2-warmcoslr2e-4-adamw-80k_coco-stuff164k-384x384.py
@@ -0,0 +1,102 @@
+_base_ = [
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py',
+    '../_base_/datasets/coco-stuff164k_384x384.py'
+]
+
+custom_imports = dict(imports=['cat_seg'])
+
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+crop_size = (384, 384)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    size=crop_size,
+    # due to the clip model, we do normalization in backbone forward()
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+# model_cfg
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='CLIPOVCATSeg',
+        feature_extractor=dict(
+            type='ResNet',
+            depth=101,
+            # only use the first three layers
+            num_stages=3,
+            out_indices=(0, 1, 2),
+            dilations=(1, 1, 1),
+            strides=(1, 2, 2),
+            norm_cfg=norm_cfg,
+            norm_eval=False,
+            style='pytorch',
+            contract_dilation=True,
+            init_cfg=dict(
+                type='Pretrained', checkpoint='torchvision://resnet101'),
+        ),
+        train_class_json='data/coco.json',
+        test_class_json='data/coco.json',
+        clip_pretrained='ViT-B/16',
+        clip_finetune='attention',
+    ),
+    neck=dict(
+        type='CATSegAggregator',
+        appearance_guidance_dim=1024,
+        num_layers=2,
+    ),
+    decode_head=dict(
+        type='CATSegHead',
+        in_channels=128,
+        channels=128,
+        num_classes=171,
+        embed_dims=128,
+        decoder_dims=(64, 32),
+        decoder_guidance_dims=(512, 256),
+        decoder_guidance_proj_dims=(32, 16),
+        loss_decode=dict(
+            type='CrossEntropyLoss',
+            use_sigmoid=False,
+            loss_weight=1.0,
+            avg_non_ignore=True)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='slide', stride=crop_size, crop_size=crop_size))
+
+# dataset settings
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=4,
+)
+
+# training schedule for 80k
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=80000, val_interval=4000)
+
+default_hooks = dict(
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=4000),
+    visualization=dict(type='SegVisualizationHook', draw=True, interval=4000))
+
+# optimizer
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.0002, betas=(0.9, 0.999), weight_decay=0.0001),
+    paramwise_cfg=dict(
+        custom_keys={
+            'backbone.feature_extractor': dict(lr_mult=0.01),
+            'backbone.clip_model.visual': dict(lr_mult=0.01)
+        }))
+
+# learning policy
+param_scheduler = [
+    # Use a linear warm-up at [0, 100) iterations
+    dict(type='LinearLR', start_factor=0.01, by_epoch=False, begin=0, end=500),
+    # Use a cosine learning rate at [100, 900) iterations
+    dict(
+        type='CosineAnnealingLR',
+        T_max=79500,
+        by_epoch=False,
+        begin=500,
+        end=80000),
+]
diff --git a/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitg-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py b/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitg-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py
new file mode 100644
index 0000000..345945d
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitg-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py
@@ -0,0 +1,11 @@
+_base_ = './catseg_vitl-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py'  # noqa
+
+model = dict(
+    backbone=dict(
+        type='CLIPOVCATSeg',
+        clip_pretrained='ViT-G',
+        custom_clip_weights='~/CLIP-ViT-bigG-14-laion2B-39B-b160k'),
+    neck=dict(
+        text_guidance_dim=1280,
+        appearance_guidance_dim=512,
+    ))
diff --git a/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vith-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py b/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vith-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py
new file mode 100644
index 0000000..2f09b8c
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vith-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py
@@ -0,0 +1,11 @@
+_base_ = './catseg_vitl-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py'  # noqa
+
+model = dict(
+    backbone=dict(
+        type='CLIPOVCATSeg',
+        clip_pretrained='ViT-H',
+        custom_clip_weights='~/CLIP-ViT-H-14-laion2B-s32B-b79K'),
+    neck=dict(
+        text_guidance_dim=1024,
+        appearance_guidance_dim=512,
+    ))
diff --git a/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitl-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py b/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitl-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py
new file mode 100644
index 0000000..bb4d57a
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitl-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py
@@ -0,0 +1,72 @@
+_base_ = './catseg_vitb-r101_4xb2-warmcoslr2e-4-adamw-80k_coco-stuff164k-384x384.py'  # noqa
+
+pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_base_patch4_window12_384_20220317-55b0104a.pth'  # noqa
+crop_size = (384, 384)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    backbone=dict(
+        type='CLIPOVCATSeg',
+        feature_extractor=dict(
+            _delete_=True,
+            type='SwinTransformer',
+            pretrain_img_size=384,
+            embed_dims=128,
+            depths=[2, 2, 18],
+            num_heads=[4, 8, 16],
+            window_size=12,
+            mlp_ratio=4,
+            qkv_bias=True,
+            qk_scale=None,
+            drop_rate=0.,
+            attn_drop_rate=0.,
+            drop_path_rate=0.3,
+            patch_norm=True,
+            out_indices=(0, 1, 2),
+            init_cfg=dict(type='Pretrained', checkpoint=pretrained)),
+        clip_pretrained='ViT-L/14@336px',
+    ),
+    neck=dict(
+        text_guidance_dim=768,
+        appearance_guidance_dim=512,
+    ),
+    decode_head=dict(
+        embed_dims=128,
+        decoder_guidance_dims=(256, 128),
+    ))
+
+# dataset settings
+train_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+)
+
+# training schedule for 80k
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=80000, val_interval=4000)
+
+default_hooks = dict(
+    visualization=dict(type='SegVisualizationHook', draw=True, interval=4000))
+
+# optimizer
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.0002, betas=(0.9, 0.999), weight_decay=0.0001),
+    paramwise_cfg=dict(
+        custom_keys={
+            'backbone.feature_extractor': dict(lr_mult=0.01),
+            'backbone.clip_model.visual': dict(lr_mult=0.01)
+        }))
+
+# learning policy
+param_scheduler = [
+    # Use a linear warm-up at [0, 100) iterations
+    dict(type='LinearLR', start_factor=0.01, by_epoch=False, begin=0, end=500),
+    # Use a cosine learning rate at [100, 900) iterations
+    dict(
+        type='CosineAnnealingLR',
+        T_max=79500,
+        by_epoch=False,
+        begin=500,
+        end=80000),
+]
diff --git a/mmsegmentation/projects/CAT-Seg/utils/__init__.py b/mmsegmentation/projects/CAT-Seg/utils/__init__.py
new file mode 100644
index 0000000..02d85f2
--- /dev/null
+++ b/mmsegmentation/projects/CAT-Seg/utils/__init__.py
@@ -0,0 +1,7 @@
+from .clip_templates import (IMAGENET_TEMPLATES, IMAGENET_TEMPLATES_SELECT,
+                             IMAGENET_TEMPLATES_SELECT_CLIP, ViLD_templates)
+
+__all__ = [
+    'IMAGENET_TEMPLATES', 'IMAGENET_TEMPLATES_SELECT',
+    'IMAGENET_TEMPLATES_SELECT_CLIP', 'ViLD_templates'
+]
diff --git a/mmsegmentation/projects/README.md b/mmsegmentation/projects/README.md
new file mode 100644
index 0000000..5482c47
--- /dev/null
+++ b/mmsegmentation/projects/README.md
@@ -0,0 +1,19 @@
+# Projects
+
+The OpenMMLab ecosystem can only grow through the contributions of the community.
+Everyone is welcome to post their implementation of any great ideas in this folder! If you wish to start your own project, please go through the [example project](example_project/) for the best practice. For common questions about projects, please read our [faq](faq.md).
+
+## External Projects
+
+There are also selected external projects released in the community that use MMSegmentation:
+
+- [SegNeXt: Rethinking Convolutional Attention Design for Semantic Segmentation](https://github.com/visual-attention-network/segnext)
+- [Vision Transformer Adapter for Dense Predictions](https://github.com/czczup/ViT-Adapter)
+- [UniFormer: Unifying Convolution and Self-attention for Visual Recognition](https://github.com/Sense-X/UniFormer)
+- [Multi-Scale High-Resolution Vision Transformer for Semantic Segmentation](https://github.com/facebookresearch/HRViT)
+- [ViTAE: Vision Transformer Advanced by Exploring Intrinsic Inductive Bias](https://github.com/ViTAE-Transformer/ViTAE-Transformer)
+- [DAFormer: Improving Network Architectures and Training Strategies for Domain-Adaptive Semantic Segmentation](https://github.com/lhoyer/DAFormer)
+- [MPViT : Multi-Path Vision Transformer for Dense Prediction](https://github.com/youngwanLEE/MPViT)
+- [TopFormer: Token Pyramid Transformer for Mobile Semantic Segmentation](https://github.com/hustvl/TopFormer)
+
+Note: These projects are supported and maintained by their own contributors. The core maintainers of MMSegmentation only ensure the results are reproducible and the code quality meets its claim at the time each project was submitted, but they may not be responsible for future maintenance.
diff --git a/mmsegmentation/projects/XDecoder/README.md b/mmsegmentation/projects/XDecoder/README.md
new file mode 100644
index 0000000..3d55575
--- /dev/null
+++ b/mmsegmentation/projects/XDecoder/README.md
@@ -0,0 +1,17 @@
+# X-Decoder
+
+> [X-Decoder: Generalized Decoding for Pixel, Image, and Language](https://arxiv.org/pdf/2212.11270.pdf)
+
+<!-- [ALGORITHM] -->
+
+## Abstract
+
+We present X-Decoder, a generalized decoding model that can predict pixel-level segmentation and language tokens seamlessly. X-Decodert takes as input two types of queries: (i) generic non-semantic queries and (ii) semantic queries induced from text inputs, to decode different pixel-level and token-level outputs in the same semantic space. With such a novel design, X-Decoder is the first work that provides a unified way to support all types of image segmentation and a variety of vision-language (VL) tasks. Further, our design enables seamless interactions across tasks at different granularities and brings mutual benefits by learning a common and rich pixel-level visual-semantic understanding space, without any pseudo-labeling. After pretraining on a mixed set of a limited amount of segmentation data and millions of image-text pairs, X-Decoder exhibits strong transferability to a wide range of downstream tasks in both zero-shot and finetuning settings. Notably, it achieves (1) state-of-the-art results on open-vocabulary segmentation and referring segmentation on eight datasets; (2) better or competitive finetuned performance to other generalist and specialist models on segmentation and VL tasks; and (3) flexibility for efficient finetuning and novel task composition (e.g., referring captioning and image editing).
+
+<div align=center>
+<img src="https://github.com/open-mmlab/mmdetection/assets/17425982/cb126615-9402-4c19-8ea9-133722d7519c" width="70%"/>
+</div>
+
+## Usage
+
+We implement it based on [mmdetection](https://github.com/open-mmlab/mmdetection/), please refer to [mmdetection/projects/XDecoder](https://github.com/open-mmlab/mmdetection/tree/main/projects/XDecoder) for more details.
diff --git a/mmsegmentation/projects/bdd100k_dataset/README.md b/mmsegmentation/projects/bdd100k_dataset/README.md
new file mode 100644
index 0000000..c774525
--- /dev/null
+++ b/mmsegmentation/projects/bdd100k_dataset/README.md
@@ -0,0 +1,50 @@
+# BDD100K Dataset
+
+Support **`BDD100K Dataset`**
+
+## Description
+
+Author: CastleDream
+
+This project implements **`BDD100K Dataset`**
+
+### Dataset preparing
+
+Preparing `BDD100K Dataset` dataset following [BDD100K Dataset Preparing Guide](https://github.com/open-mmlab/mmsegmentation/tree/main/projects/mapillary_dataset/docs/en/user_guides/2_dataset_prepare.md#bdd100k)
+
+```none
+mmsegmentation/data
+└── bdd100k
+    ├── images
+    │   └── 10k
+    │       ├── test [2000 entries exceeds filelimit, not opening dir]
+    │       ├── train [7000 entries exceeds filelimit, not opening dir]
+    │       └── val [1000 entries exceeds filelimit, not opening dir]
+    └── labels
+        └── sem_seg
+            ├── colormaps
+            │   ├── train [7000 entries exceeds filelimit, not opening dir]
+            │   └── val [1000 entries exceeds filelimit, not opening dir]
+            ├── masks
+            │   ├── train [7000 entries exceeds filelimit, not opening dir]
+            │   └── val [1000 entries exceeds filelimit, not opening dir]
+            ├── polygons
+            │   ├── sem_seg_train.json
+            │   └── sem_seg_val.json
+            └── rles
+                ├── sem_seg_train.json
+                └── sem_seg_val.json
+```
+
+### Training commands
+
+```bash
+%cd mmsegmentation
+!python tools/train.py projects/bdd100k_dataset/configs/pspnet_r50-d8_4xb2-80k_bdd100k-512x1024.py\
+--work-dir your_work_dir
+```
+
+## Thanks
+
+- [\[Datasets\] Add Mapillary Vistas Datasets to MMSeg Core Package. #2576](https://github.com/open-mmlab/mmsegmentation/pull/2576/files)
+- [\[Feature\] Support CIHP dataset #1493](https://github.com/open-mmlab/mmsegmentation/pull/1493/files)
diff --git a/mmsegmentation/projects/bdd100k_dataset/configs/_base_/datasets/bdd100k.py b/mmsegmentation/projects/bdd100k_dataset/configs/_base_/datasets/bdd100k.py
new file mode 100644
index 0000000..24cec69
--- /dev/null
+++ b/mmsegmentation/projects/bdd100k_dataset/configs/_base_/datasets/bdd100k.py
@@ -0,0 +1,70 @@
+# dataset settings
+dataset_type = 'BDD100KDataset'
+data_root = 'data/bdd100k/'
+
+crop_size = (512, 1024)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=(2048, 1024),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/10k/train',
+            seg_map_path='labels/sem_seg/masks/train'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/10k/val',
+            seg_map_path='labels/sem_seg/masks/val'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/projects/bdd100k_dataset/configs/pspnet_r50-d8_4xb2-80k_bdd100k-512x1024.py b/mmsegmentation/projects/bdd100k_dataset/configs/pspnet_r50-d8_4xb2-80k_bdd100k-512x1024.py
new file mode 100644
index 0000000..456d4c7
--- /dev/null
+++ b/mmsegmentation/projects/bdd100k_dataset/configs/pspnet_r50-d8_4xb2-80k_bdd100k-512x1024.py
@@ -0,0 +1,11 @@
+_base_ = [
+    '../../../configs/_base_/models/pspnet_r50-d8.py',
+    './_base_/datasets/bdd100k.py',
+    '../../../configs/_base_/default_runtime.py',
+    '../../../configs/_base_/schedules/schedule_80k.py'
+]
+custom_imports = dict(
+    imports=['projects.bdd100k_dataset.mmseg.datasets.bdd100k'])
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/projects/bdd100k_dataset/docs/en/user_guides/2_dataset_prepare.md b/mmsegmentation/projects/bdd100k_dataset/docs/en/user_guides/2_dataset_prepare.md
new file mode 100644
index 0000000..f2383cf
--- /dev/null
+++ b/mmsegmentation/projects/bdd100k_dataset/docs/en/user_guides/2_dataset_prepare.md
@@ -0,0 +1,40 @@
+## BDD100K
+
+- You could download BDD100k datasets from  [here](https://bdd-data.berkeley.edu/) after  registration.
+
+- You can download images and masks by clicking  `10K Images` button and `Segmentation` button.
+
+- After download, unzip by the following instructions:
+
+  ```bash
+  unzip ~/bdd100k_images_10k.zip -d ~/mmsegmentation/data/
+  unzip ~/bdd100k_sem_seg_labels_trainval.zip -d ~/mmsegmentation/data/
+  ```
+
+```none
+mmsegmentation
+├── mmseg
+├── tools
+├── configs
+├── data
+│   ├── bdd100k
+│   │   ├── images
+│   │   │   └── 10k
+|   │   │   │   ├── test
+|   │   │   │   ├── train
+|   │   │   │   └── val
+│   │   └── labels
+│   │   │   └── sem_seg
+|   │   │   │   ├── colormaps
+|   │   │   │   │   ├──train
+|   │   │   │   │   └──val
+|   │   │   │   ├── masks
+|   │   │   │   │   ├──train
+|   │   │   │   │   └──val
+|   │   │   │   ├── polygons
+|   │   │   │   │   ├──sem_seg_train.json
+|   │   │   │   │   └──sem_seg_val.json
+|   │   │   │   └── rles
+|   │   │   │   │   ├──sem_seg_train.json
+|   │   │   │   │   └──sem_seg_val.json
+```
diff --git a/mmsegmentation/projects/bdd100k_dataset/docs/zh_cn/user_guides/2_dataset_prepare.md b/mmsegmentation/projects/bdd100k_dataset/docs/zh_cn/user_guides/2_dataset_prepare.md
new file mode 100644
index 0000000..64fb763
--- /dev/null
+++ b/mmsegmentation/projects/bdd100k_dataset/docs/zh_cn/user_guides/2_dataset_prepare.md
@@ -0,0 +1,42 @@
+## BDD100K
+
+- 可以从[官方网站](https://bdd-data.berkeley.edu/) 下载 BDD100K数据集（语义分割任务主要是10K数据集），按照官网要求注册并登陆后，数据可以在[这里](https://bdd-data.berkeley.edu/portal.html#download)找到。
+
+- 图像数据对应的名称是是`10K Images`, 语义分割标注对应的名称是`Segmentation`
+
+- 下载后，可以使用以下代码进行解压
+
+  ```bash
+  unzip ~/bdd100k_images_10k.zip -d ~/mmsegmentation/data/
+  unzip ~/bdd100k_sem_seg_labels_trainval.zip -d ~/mmsegmentation/data/
+  ```
+
+就可以得到以下文件结构了：
+
+```none
+mmsegmentation
+├── mmseg
+├── tools
+├── configs
+├── data
+│   ├── bdd100k
+│   │   ├── images
+│   │   │   └── 10k
+|   │   │   │   ├── test
+|   │   │   │   ├── train
+|   │   │   │   └── val
+│   │   └── labels
+│   │   │   └── sem_seg
+|   │   │   │   ├── colormaps
+|   │   │   │   │   ├──train
+|   │   │   │   │   └──val
+|   │   │   │   ├── masks
+|   │   │   │   │   ├──train
+|   │   │   │   │   └──val
+|   │   │   │   ├── polygons
+|   │   │   │   │   ├──sem_seg_train.json
+|   │   │   │   │   └──sem_seg_val.json
+|   │   │   │   └── rles
+|   │   │   │   │   ├──sem_seg_train.json
+|   │   │   │   │   └──sem_seg_val.json
+```
diff --git a/mmsegmentation/projects/bdd100k_dataset/mmseg/datasets/bdd100k.py b/mmsegmentation/projects/bdd100k_dataset/mmseg/datasets/bdd100k.py
new file mode 100644
index 0000000..e536de7
--- /dev/null
+++ b/mmsegmentation/projects/bdd100k_dataset/mmseg/datasets/bdd100k.py
@@ -0,0 +1,31 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+from mmseg.datasets.basesegdataset import BaseSegDataset
+
+# from mmseg.registry import DATASETS
+# @DATASETS.register_module()
+
+
+class BDD100KDataset(BaseSegDataset):
+    METAINFO = dict(
+        classes=('road', 'sidewalk', 'building', 'wall', 'fence', 'pole',
+                 'traffic light', 'traffic sign', 'vegetation', 'terrain',
+                 'sky', 'person', 'rider', 'car', 'truck', 'bus', 'train',
+                 'motorcycle', 'bicycle'),
+        palette=[[128, 64, 128], [244, 35, 232], [70, 70, 70], [102, 102, 156],
+                 [190, 153, 153], [153, 153, 153], [250, 170,
+                                                    30], [220, 220, 0],
+                 [107, 142, 35], [152, 251, 152], [70, 130, 180],
+                 [220, 20, 60], [255, 0, 0], [0, 0, 142], [0, 0, 70],
+                 [0, 60, 100], [0, 80, 100], [0, 0, 230], [119, 11, 32]])
+
+    def __init__(self,
+                 img_suffix='.jpg',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/projects/example_project/README.md b/mmsegmentation/projects/example_project/README.md
new file mode 100644
index 0000000..e4fd03c
--- /dev/null
+++ b/mmsegmentation/projects/example_project/README.md
@@ -0,0 +1,134 @@
+# Dummy ResNet Wrapper
+
+> A README.md template for releasing a project.
+>
+> All the fields in this README are **mandatory** for others to understand what you have achieved in this implementation.
+> Please read our [Projects FAQ](../faq.md) if you still feel unclear about the requirements, or raise an [issue](https://github.com/open-mmlab/mmsegmentation/issues) to us!
+
+## Description
+
+> Share any information you would like others to know. For example:
+>
+> Author: @xxx.
+>
+> This is an implementation of \[XXX\].
+
+Author： @xxx.
+
+This project implements a dummy ResNet wrapper, which literally does nothing new but prints "hello world" during initialization.
+
+## Usage
+
+> For a typical model, this section should contain the commands for training and testing.
+> You are also suggested to dump your environment specification to env.yml by `conda env export > env.yml`.
+
+### Prerequisites
+
+- Python 3.7
+- PyTorch 1.6 or higher
+- [MIM](https://github.com/open-mmlab/mim) v0.33 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc2 or higher
+
+All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `example_project/` root directory, run the following line to add the current directory to `PYTHONPATH`:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Training commands
+
+```shell
+mim train mmsegmentation configs/fcn_dummy-r50-d8_4xb2-40k_cityscapes-512x1024.py --work-dir work_dirs/dummy_resnet
+```
+
+To train on multiple GPUs, e.g. 8 GPUs, run the following command:
+
+```shell
+mim train mmsegmentation configs/fcn_dummy-r50-d8_4xb2-40k_cityscapes-512x1024.py --work-dir work_dirs/dummy_resnet --launcher pytorch --gpus 8
+```
+
+### Testing commands
+
+```shell
+mim test mmsegmentation configs/fcn_dummy-r50-d8_4xb2-40k_cityscapes-512x1024.py --work-dir work_dirs/dummy_resnet --checkpoint ${CHECKPOINT_PATH}
+```
+
+> List the results as usually done in other model's README. \[Example\](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/fcn#results-and-models
+> You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) |  mIoU | mIoU(ms+flip) | config                                                             | download                                                                                                                                                                                                                                                                                                                           |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ----: | ------------: | ------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FCN    | R-50-D8  | 512x1024  |   40000 | 5.7      | 4.17           | 72.25 |         73.36 | [config](configs/fcn_dummy-r50-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x1024_40k_cityscapes/fcn_r50-d8_512x1024_40k_cityscapes_20200604_192608-efe53f0d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x1024_40k_cityscapes/fcn_r50-d8_512x1024_40k_cityscapes_20200604_192608.log.json) |
+
+## Citation
+
+> You may remove this section if not applicable.
+
+```bibtex
+@misc{mmseg2020,
+    title={{MMSegmentation}: OpenMMLab Semantic Segmentation Toolbox and Benchmark},
+    author={MMSegmentation Contributors},
+    howpublished = {\url{https://github.com/open-mmlab/mmsegmentation}},
+    year={2020}
+}
+```
+
+## Checklist
+
+Here is a checklist illustrating a usual development workflow of a successful project, and also serves as an overview of this project's progress.
+
+> The PIC (person in charge) or contributors of this project should check all the items that they believe have been finished, which will further be verified by codebase maintainers via a PR.
+
+> OpenMMLab's maintainer will review the code to ensure the project's quality. Reaching the first milestone means that this project suffices the minimum requirement of being merged into 'projects/'. But this project is only eligible to become a part of the core package upon attaining the last milestone.
+
+> Note that keeping this section up-to-date is crucial not only for this project's developers but the entire community, since there might be some other contributors joining this project and deciding their starting point from this list. It also helps maintainers accurately estimate time and effort on further code polishing, if needed.
+
+> A project does not necessarily have to be finished in a single PR, but it's essential for the project to at least reach the first milestone in its very first PR.
+
+- [ ] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [ ] Finish the code
+
+> The code's design shall follow existing interfaces and convention. For example, each model component should be registered into `mmseg.registry.MODELS` and configurable via a config file.
+
+- [ ] Basic docstrings & proper citation
+
+> Each major object should contain a docstring, describing its functionality and arguments. If you have adapted the code from other open-source projects, don't forget to cite the source project in docstring and make sure your behavior is not against its license. Typically, we do not accept any code snippet under GPL license. [A Short Guide to Open Source Licenses](https://medium.com/nationwide-technology/a-short-guide-to-open-source-licenses-cf5b1c329edd)
+
+- [ ] Test-time correctness
+
+> If you are reproducing the result from a paper, make sure your model's inference-time performance matches that in the original paper. The weights usually could be obtained by simply renaming the keys in the official pre-trained weights. This test could be skipped though, if you are able to prove the training-time correctness and check the second milestone.
+
+- [ ] A full README
+
+> As this template does.
+
+- [ ] Milestone 2: Indicates a successful model implementation.
+
+  - [ ] Training-time correctness
+
+> If you are reproducing the result from a paper, checking this item means that you should have trained your model from scratch based on the original paper's specification and verified that the final result matches the report within a minor error range.
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+
+> Ideally *all* the methods should have [type hints](https://www.pythontutorial.net/python-basics/python-type-hints/) and [docstrings](https://google.github.io/styleguide/pyguide.html#381-docstrings). [Example](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/utils/io.py#L9)
+
+- [ ] Unit tests
+
+> Unit tests for each module are required. [Example](https://github.com/open-mmlab/mmsegmentation/blob/main/tests/test_utils/test_io.py#L14)
+
+- [ ] Code polishing
+
+> Refactor your code according to reviewer's comment.
+
+- [ ] Metafile.yml
+
+> It will be parsed by MIM and Inferencer. [Example](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn.yml)
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+> In particular, you may have to refactor this README into a standard one. [Example](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/README.md)
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/example_project/configs/fcn_dummy-r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/projects/example_project/configs/fcn_dummy-r50-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..4301536
--- /dev/null
+++ b/mmsegmentation/projects/example_project/configs/fcn_dummy-r50-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,8 @@
+_base_ = ['mmseg::fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py']
+
+custom_imports = dict(imports=['dummy'])
+
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor, backbone=dict(type='DummyResNet'))
diff --git a/mmsegmentation/projects/example_project/dummy/__init__.py b/mmsegmentation/projects/example_project/dummy/__init__.py
new file mode 100644
index 0000000..70df789
--- /dev/null
+++ b/mmsegmentation/projects/example_project/dummy/__init__.py
@@ -0,0 +1,3 @@
+from .dummy_resnet import DummyResNet
+
+__all__ = ['DummyResNet']
diff --git a/mmsegmentation/projects/example_project/dummy/dummy_resnet.py b/mmsegmentation/projects/example_project/dummy/dummy_resnet.py
new file mode 100644
index 0000000..a510eaf
--- /dev/null
+++ b/mmsegmentation/projects/example_project/dummy/dummy_resnet.py
@@ -0,0 +1,14 @@
+from mmseg.models.backbones import ResNetV1c
+from mmseg.registry import MODELS
+
+
+@MODELS.register_module()
+class DummyResNet(ResNetV1c):
+    """Implements a dummy ResNet wrapper for demonstration purpose.
+    Args:
+        **kwargs: All the arguments are passed to the parent class.
+    """
+
+    def __init__(self, **kwargs) -> None:
+        print('Hello world!')
+        super().__init__(**kwargs)
diff --git a/mmsegmentation/projects/faq.md b/mmsegmentation/projects/faq.md
new file mode 100644
index 0000000..74b292b
--- /dev/null
+++ b/mmsegmentation/projects/faq.md
@@ -0,0 +1,19 @@
+Q1: Why set up `projects/` folder?
+
+Implementing new models and features into OpenMMLab's algorithm libraries could be troublesome due to the rigorous requirements on code quality, which could hinder the fast iteration of SOTA models and might discourage our members from sharing their latest outcomes here. And that's why we have this `projects/` folder now, where some experimental features, frameworks and models are placed, only needed to satisfy the minimum requirement on the code quality, and can be used as standalone libraries. Users are welcome to use them if they [use MMSegmentation from source](https://mmsegmentation.readthedocs.io/en/latest/get_started.html#best-practices).
+
+Q2: Why should there be a checklist for a project?
+
+This checkelist is crucial not only for this project's developers but the entire community, since there might be some other contributors joining this project and deciding their starting point from this list. It also helps maintainers accurately estimate time and effort on further code polishing, if needed.
+
+Q3: What kind of PR will be merged?
+
+Reaching the first milestone means that this project suffices the minimum requirement of being merged into 'projects/'. That is, the very first PR of a project must have all the terms in the first milestone checked. We do not have any extra requirements on the project's following PRs, so they can be a minor bug fix or update, and do not have to achieve one milestone at once. But keep in mind that this project is only eligible to become a part of the core package upon attaining the last milestone.
+
+Q4: Compared to other models in the core packages, why do the model implementations in projects have different training/testing commands?
+
+Projects are organized independently from the core package, and therefore their modules cannot be directly imported by train.py and test.py. Each model implementation in projects should either use `mim` for training/testing as suggested in the example project or provide a custom train.py/test.py.
+
+Q5: How to debug a project with a debugger?
+
+Debugger makes our lives easier, but using it becomes a bit tricky if we have to train/test a model via `mim`. The way to circumvent that is that we can take advantage of relative path to import these modules. Assuming that we are developing a project X and the core modules are placed under `projects/X/modules`, then simply adding `custom_imports = dict(imports='projects.X.modules')` to the config allows us to debug from usual entrypoints (e.g. `tools/train.py`) from the root directory of the algorithm library. Just don't forget to remove 'projects.X' before project publishment.
diff --git a/mmsegmentation/projects/gid_dataset/configs/_base_/datasets/gid.py b/mmsegmentation/projects/gid_dataset/configs/_base_/datasets/gid.py
new file mode 100644
index 0000000..f721810
--- /dev/null
+++ b/mmsegmentation/projects/gid_dataset/configs/_base_/datasets/gid.py
@@ -0,0 +1,67 @@
+# dataset settings
+dataset_type = 'GID_Dataset'  # 注册的类名
+data_root = 'data/gid/'  # 数据集根目录
+crop_size = (256, 256)  # 图像裁剪大小
+train_pipeline = [
+    dict(type='LoadImageFromFile'),  # 从文件中加载图像
+    dict(type='LoadAnnotations'),  # 从文件中加载标注
+    dict(
+        type='RandomResize',  # 随机缩放
+        scale=(512, 512),  # 缩放尺寸
+        ratio_range=(0.5, 2.0),  # 缩放比例范围
+        keep_ratio=True),  # 是否保持长宽比
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),  # 随机裁剪
+    dict(type='RandomFlip', prob=0.5),  # 随机翻转
+    dict(type='PhotoMetricDistortion'),  # 图像增强
+    dict(type='PackSegInputs')  # 打包数据
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),  # 从文件中加载图像
+    dict(type='Resize', scale=(256, 256), keep_ratio=True),  # 缩放
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),  # 从文件中加载标注
+    dict(type='PackSegInputs')  # 打包数据
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]  # 多尺度预测缩放比例
+tta_pipeline = [  # 多尺度测试
+    dict(type='LoadImageFromFile', file_client_args=dict(backend='disk')),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(  # 训练数据加载器
+    batch_size=2,  # 训练时的数据批量大小
+    num_workers=4,  # 数据加载线程数
+    persistent_workers=True,  # 是否持久化线程
+    sampler=dict(type='InfiniteSampler', shuffle=True),  # 无限采样器
+    dataset=dict(
+        type=dataset_type,  # 数据集类名
+        data_root=data_root,  # 数据集根目录
+        data_prefix=dict(
+            img_path='img_dir/train',
+            seg_map_path='ann_dir/train'),  # 训练集图像和标注路径
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,  # 验证时的数据批量大小
+    num_workers=4,  # 数据加载线程数
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(img_path='img_dir/val', seg_map_path='ann_dir/val'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/projects/gid_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_gid-256x256.py b/mmsegmentation/projects/gid_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_gid-256x256.py
new file mode 100644
index 0000000..70cb600
--- /dev/null
+++ b/mmsegmentation/projects/gid_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_gid-256x256.py
@@ -0,0 +1,15 @@
+_base_ = [
+    '../../../configs/_base_/models/deeplabv3plus_r50-d8.py',
+    './_base_/datasets/gid.py', '../../../configs/_base_/default_runtime.py',
+    '../../../configs/_base_/schedules/schedule_240k.py'
+]
+custom_imports = dict(imports=['projects.gid_dataset.mmseg.datasets.gid'])
+
+crop_size = (256, 256)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet101_v1c',
+    backbone=dict(depth=101),
+    decode_head=dict(num_classes=6),
+    auxiliary_head=dict(num_classes=6))
diff --git a/mmsegmentation/projects/gid_dataset/mmseg/datasets/gid.py b/mmsegmentation/projects/gid_dataset/mmseg/datasets/gid.py
new file mode 100644
index 0000000..a9e8c51
--- /dev/null
+++ b/mmsegmentation/projects/gid_dataset/mmseg/datasets/gid.py
@@ -0,0 +1,55 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmseg.datasets.basesegdataset import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+# 注册数据集类
+@DATASETS.register_module()
+class GID_Dataset(BaseSegDataset):
+    """Gaofen Image Dataset (GID)
+
+    Dataset paper link:
+    https://www.sciencedirect.com/science/article/pii/S0034425719303414
+    https://x-ytong.github.io/project/GID.html
+
+    GID  6 classes: others, built-up, farmland, forest, meadow, water
+
+    In this example, select 15 images from GID dataset as training set,
+    and select 5 images as validation set.
+    The selected images are listed as follows:
+
+    GF2_PMS1__L1A0000647767-MSS1
+    GF2_PMS1__L1A0001064454-MSS1
+    GF2_PMS1__L1A0001348919-MSS1
+    GF2_PMS1__L1A0001680851-MSS1
+    GF2_PMS1__L1A0001680853-MSS1
+    GF2_PMS1__L1A0001680857-MSS1
+    GF2_PMS1__L1A0001757429-MSS1
+    GF2_PMS2__L1A0000607681-MSS2
+    GF2_PMS2__L1A0000635115-MSS2
+    GF2_PMS2__L1A0000658637-MSS2
+    GF2_PMS2__L1A0001206072-MSS2
+    GF2_PMS2__L1A0001471436-MSS2
+    GF2_PMS2__L1A0001642620-MSS2
+    GF2_PMS2__L1A0001787089-MSS2
+    GF2_PMS2__L1A0001838560-MSS2
+
+    The ``img_suffix`` is fixed to '.tif' and ``seg_map_suffix`` is
+    fixed to '.tif' for GID.
+    """
+    METAINFO = dict(
+        classes=('Others', 'Built-up', 'Farmland', 'Forest', 'Meadow',
+                 'Water'),
+        palette=[[0, 0, 0], [255, 0, 0], [0, 255, 0], [0, 255, 255],
+                 [255, 255, 0], [0, 0, 255]])
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=None,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/projects/gid_dataset/tools/dataset_converters/gid.py b/mmsegmentation/projects/gid_dataset/tools/dataset_converters/gid.py
new file mode 100644
index 0000000..d95654a
--- /dev/null
+++ b/mmsegmentation/projects/gid_dataset/tools/dataset_converters/gid.py
@@ -0,0 +1,181 @@
+import argparse
+import glob
+import math
+import os
+import os.path as osp
+
+import mmcv
+import numpy as np
+from mmengine.utils import ProgressBar, mkdir_or_exist
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Convert GID dataset to mmsegmentation format')
+    parser.add_argument('dataset_img_path', help='GID images folder path')
+    parser.add_argument('dataset_label_path', help='GID labels folder path')
+    parser.add_argument('--tmp_dir', help='path of the temporary directory')
+    parser.add_argument(
+        '-o', '--out_dir', help='output path', default='data/gid')
+    parser.add_argument(
+        '--clip_size',
+        type=int,
+        help='clipped size of image after preparation',
+        default=256)
+    parser.add_argument(
+        '--stride_size',
+        type=int,
+        help='stride of clipping original images',
+        default=256)
+    args = parser.parse_args()
+    return args
+
+
+GID_COLORMAP = dict(
+    Background=(0, 0, 0),  # 0-背景-黑色
+    Building=(255, 0, 0),  # 1-建筑-红色
+    Farmland=(0, 255, 0),  # 2-农田-绿色
+    Forest=(0, 0, 255),  # 3-森林-蓝色
+    Meadow=(255, 255, 0),  # 4-草地-黄色
+    Water=(0, 0, 255)  # 5-水-蓝色
+)
+palette = list(GID_COLORMAP.values())
+classes = list(GID_COLORMAP.keys())
+
+
+# 用列表来存一个 RGB 和一个类别的对应
+def colormap2label(palette):
+    colormap2label_list = np.zeros(256**3, dtype=np.longlong)
+    for i, colormap in enumerate(palette):
+        colormap2label_list[(colormap[0] * 256 + colormap[1]) * 256 +
+                            colormap[2]] = i
+    return colormap2label_list
+
+
+# 给定那个列表，和vis_png然后生成masks_png
+def label_indices(RGB_label, colormap2label_list):
+    RGB_label = RGB_label.astype('int32')
+    idx = (RGB_label[:, :, 0] * 256 +
+           RGB_label[:, :, 1]) * 256 + RGB_label[:, :, 2]
+    return colormap2label_list[idx]
+
+
+def RGB2mask(RGB_label, colormap2label_list):
+    mask_label = label_indices(RGB_label, colormap2label_list)
+    return mask_label
+
+
+colormap2label_list = colormap2label(palette)
+
+
+def clip_big_image(image_path, clip_save_dir, args, to_label=False):
+    """Original image of GID dataset is very large, thus pre-processing of them
+    is adopted.
+
+    Given fixed clip size and stride size to generate
+    clipped image, the intersection　of width and height is determined.
+    For example, given one 6800 x 7200 original image, the clip size is
+    256 and stride size is 256, thus it would generate 29 x 27 = 783 images
+    whose size are all 256 x 256.
+    """
+
+    image = mmcv.imread(image_path, channel_order='rgb')
+    # image = mmcv.bgr2gray(image)
+
+    h, w, c = image.shape
+    clip_size = args.clip_size
+    stride_size = args.stride_size
+
+    num_rows = math.ceil((h - clip_size) / stride_size) if math.ceil(
+        (h - clip_size) /
+        stride_size) * stride_size + clip_size >= h else math.ceil(
+            (h - clip_size) / stride_size) + 1
+    num_cols = math.ceil((w - clip_size) / stride_size) if math.ceil(
+        (w - clip_size) /
+        stride_size) * stride_size + clip_size >= w else math.ceil(
+            (w - clip_size) / stride_size) + 1
+
+    x, y = np.meshgrid(np.arange(num_cols + 1), np.arange(num_rows + 1))
+    xmin = x * clip_size
+    ymin = y * clip_size
+
+    xmin = xmin.ravel()
+    ymin = ymin.ravel()
+    xmin_offset = np.where(xmin + clip_size > w, w - xmin - clip_size,
+                           np.zeros_like(xmin))
+    ymin_offset = np.where(ymin + clip_size > h, h - ymin - clip_size,
+                           np.zeros_like(ymin))
+    boxes = np.stack([
+        xmin + xmin_offset, ymin + ymin_offset,
+        np.minimum(xmin + clip_size, w),
+        np.minimum(ymin + clip_size, h)
+    ],
+                     axis=1)
+
+    if to_label:
+        image = RGB2mask(image, colormap2label_list)
+
+    for count, box in enumerate(boxes):
+        start_x, start_y, end_x, end_y = box
+        clipped_image = image[start_y:end_y,
+                              start_x:end_x] if to_label else image[
+                                  start_y:end_y, start_x:end_x, :]
+        img_name = osp.basename(image_path).replace('.tif', '')
+        img_name = img_name.replace('_label', '')
+        if count % 3 == 0:
+            mmcv.imwrite(
+                clipped_image.astype(np.uint8),
+                osp.join(
+                    clip_save_dir.replace('train', 'val'),
+                    f'{img_name}_{start_x}_{start_y}_{end_x}_{end_y}.png'))
+        else:
+            mmcv.imwrite(
+                clipped_image.astype(np.uint8),
+                osp.join(
+                    clip_save_dir,
+                    f'{img_name}_{start_x}_{start_y}_{end_x}_{end_y}.png'))
+        count += 1
+
+
+def main():
+    args = parse_args()
+    """
+    According to this paper: https://ieeexplore.ieee.org/document/9343296/
+    select 15 images contained in GID, , which cover the whole six
+    categories, to generate train set and validation set.
+
+    """
+
+    if args.out_dir is None:
+        out_dir = osp.join('data', 'gid')
+    else:
+        out_dir = args.out_dir
+
+    print('Making directories...')
+    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'train'))
+    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'val'))
+    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'train'))
+    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'val'))
+
+    src_path_list = glob.glob(os.path.join(args.dataset_img_path, '*.tif'))
+    print(f'Find {len(src_path_list)} pictures')
+
+    prog_bar = ProgressBar(len(src_path_list))
+
+    dst_img_dir = osp.join(out_dir, 'img_dir', 'train')
+    dst_label_dir = osp.join(out_dir, 'ann_dir', 'train')
+
+    for i, img_path in enumerate(src_path_list):
+        label_path = osp.join(
+            args.dataset_label_path,
+            osp.basename(img_path.replace('.tif', '_label.tif')))
+
+        clip_big_image(img_path, dst_img_dir, args, to_label=False)
+        clip_big_image(label_path, dst_label_dir, args, to_label=True)
+        prog_bar.update()
+
+    print('Done!')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/projects/gid_dataset/tools/dataset_converters/gid_select15imgFromAll.py b/mmsegmentation/projects/gid_dataset/tools/dataset_converters/gid_select15imgFromAll.py
new file mode 100644
index 0000000..d3eeff2
--- /dev/null
+++ b/mmsegmentation/projects/gid_dataset/tools/dataset_converters/gid_select15imgFromAll.py
@@ -0,0 +1,75 @@
+import argparse
+import os
+import shutil
+
+# select 15 images from GID dataset
+
+img_list = [
+    'GF2_PMS1__L1A0000647767-MSS1.tif', 'GF2_PMS1__L1A0001064454-MSS1.tif',
+    'GF2_PMS1__L1A0001348919-MSS1.tif', 'GF2_PMS1__L1A0001680851-MSS1.tif',
+    'GF2_PMS1__L1A0001680853-MSS1.tif', 'GF2_PMS1__L1A0001680857-MSS1.tif',
+    'GF2_PMS1__L1A0001757429-MSS1.tif', 'GF2_PMS2__L1A0000607681-MSS2.tif',
+    'GF2_PMS2__L1A0000635115-MSS2.tif', 'GF2_PMS2__L1A0000658637-MSS2.tif',
+    'GF2_PMS2__L1A0001206072-MSS2.tif', 'GF2_PMS2__L1A0001471436-MSS2.tif',
+    'GF2_PMS2__L1A0001642620-MSS2.tif', 'GF2_PMS2__L1A0001787089-MSS2.tif',
+    'GF2_PMS2__L1A0001838560-MSS2.tif'
+]
+
+labels_list = [
+    'GF2_PMS1__L1A0000647767-MSS1_label.tif',
+    'GF2_PMS1__L1A0001064454-MSS1_label.tif',
+    'GF2_PMS1__L1A0001348919-MSS1_label.tif',
+    'GF2_PMS1__L1A0001680851-MSS1_label.tif',
+    'GF2_PMS1__L1A0001680853-MSS1_label.tif',
+    'GF2_PMS1__L1A0001680857-MSS1_label.tif',
+    'GF2_PMS1__L1A0001757429-MSS1_label.tif',
+    'GF2_PMS2__L1A0000607681-MSS2_label.tif',
+    'GF2_PMS2__L1A0000635115-MSS2_label.tif',
+    'GF2_PMS2__L1A0000658637-MSS2_label.tif',
+    'GF2_PMS2__L1A0001206072-MSS2_label.tif',
+    'GF2_PMS2__L1A0001471436-MSS2_label.tif',
+    'GF2_PMS2__L1A0001642620-MSS2_label.tif',
+    'GF2_PMS2__L1A0001787089-MSS2_label.tif',
+    'GF2_PMS2__L1A0001838560-MSS2_label.tif'
+]
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='From 150 images of GID dataset to select 15 images')
+    parser.add_argument('dataset_img_dir', help='150 GID images folder path')
+    parser.add_argument('dataset_label_dir', help='150 GID labels folder path')
+
+    parser.add_argument('dest_img_dir', help='15 GID images folder path')
+    parser.add_argument('dest_label_dir', help='15 GID labels folder path')
+
+    args = parser.parse_args()
+
+    return args
+
+
+def main():
+    """This script is used to select 15 images from GID dataset, According to
+    paper: https://ieeexplore.ieee.org/document/9343296/"""
+    args = parse_args()
+
+    img_path = args.dataset_img_dir
+    label_path = args.dataset_label_dir
+
+    dest_img_dir = args.dest_img_dir
+    dest_label_dir = args.dest_label_dir
+
+    # copy images of 'img_list' to 'desr_dir'
+    print('Copy images of img_list to desr_dir ing...')
+    for img in img_list:
+        shutil.copy(os.path.join(img_path, img), dest_img_dir)
+    print('Done!')
+
+    print('copy labels of labels_list to desr_dir ing...')
+    for label in labels_list:
+        shutil.copy(os.path.join(label_path, label), dest_label_dir)
+    print('Done!')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/projects/gid_dataset/user_guides/2_dataset_prepare.md b/mmsegmentation/projects/gid_dataset/user_guides/2_dataset_prepare.md
new file mode 100644
index 0000000..63bd4d4
--- /dev/null
+++ b/mmsegmentation/projects/gid_dataset/user_guides/2_dataset_prepare.md
@@ -0,0 +1,53 @@
+## Gaofen Image Dataset (GID)
+
+- GID 数据集可在[此处](https://x-ytong.github.io/project/GID.html)进行下载。
+- GID 数据集包含 150 张 6800x7200 的大尺寸图像，标签为 RGB 标签。
+- 根据[文献](https://ieeexplore.ieee.org/document/9343296/)，此处选择 15 张图像生成训练集和验证集，该 15 张图像包含了所有六类信息。所选的图像名称如下：
+
+```None
+  GF2_PMS1__L1A0000647767-MSS1
+  GF2_PMS1__L1A0001064454-MSS1
+  GF2_PMS1__L1A0001348919-MSS1
+  GF2_PMS1__L1A0001680851-MSS1
+  GF2_PMS1__L1A0001680853-MSS1
+  GF2_PMS1__L1A0001680857-MSS1
+  GF2_PMS1__L1A0001757429-MSS1
+  GF2_PMS2__L1A0000607681-MSS2
+  GF2_PMS2__L1A0000635115-MSS2
+  GF2_PMS2__L1A0000658637-MSS2
+  GF2_PMS2__L1A0001206072-MSS2
+  GF2_PMS2__L1A0001471436-MSS2
+  GF2_PMS2__L1A0001642620-MSS2
+  GF2_PMS2__L1A0001787089-MSS2
+  GF2_PMS2__L1A0001838560-MSS2
+```
+
+这里也提供了一个脚本来方便的筛选出15张图像，
+
+```
+python projects/gid_dataset/tools/dataset_converters/gid_select15imgFromAll.py {150 张图像的路径} {150 张标签的路径} {15 张图像的路径} {15 张标签的路径}
+```
+
+在选择出 15 张图像后，执行以下命令进行裁切及标签的转换，需要修改为您所存储 15 张图像及标签的路径。
+
+```
+python projects/gid_dataset/tools/dataset_converters/gid.py {15 张图像的路径} {15 张标签的路径}
+```
+
+完成裁切后的 GID 数据结构如下：
+
+```none
+mmsegmentation
+├── mmseg
+├── tools
+├── configs
+├── data
+│   ├── gid
+│   │   ├── ann_dir
+|   │   │   │   ├── train
+|   │   │   │   ├── val
+│   │   ├── img_dir
+|   │   │   │   ├── train
+|   │   │   │   ├── val
+
+```
diff --git a/mmsegmentation/projects/hsidrive20_dataset/README.md b/mmsegmentation/projects/hsidrive20_dataset/README.md
new file mode 100644
index 0000000..7ee6e98
--- /dev/null
+++ b/mmsegmentation/projects/hsidrive20_dataset/README.md
@@ -0,0 +1,34 @@
+# HSI Drive 2.0 Dataset
+
+Support **`HSI Drive 2.0 Dataset`**
+
+## Description
+
+Author: Jon Gutierrez
+
+This project implements **`HSI Drive 2.0 Dataset`**
+
+### Dataset preparing
+
+Preparing `HSI Drive 2.0 Dataset` dataset following [HSI Drive 2.0 Dataset Preparing Guide](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#hsi-drive-2.0)
+
+```none
+mmsegmentation/data
+└── HSIDrive20
+    ├── images
+    │   |── training []
+    │   |── validation []
+    │   |── test []
+    └── labels
+    │   |── training []
+    │   |── validation []
+    │   |── test []
+```
+
+### Training commands
+
+```bash
+%cd mmsegmentation
+!python tools/train.py projects/hsidrive20_dataset/configs/unet-s5-d16_fcn_4xb4-160k_hsidrive-208x400.py\
+--work-dir your_work_dir
+```
diff --git a/mmsegmentation/projects/hsidrive20_dataset/configs/_base_/datasets/hsi_drive.py b/mmsegmentation/projects/hsidrive20_dataset/configs/_base_/datasets/hsi_drive.py
new file mode 100644
index 0000000..3114262
--- /dev/null
+++ b/mmsegmentation/projects/hsidrive20_dataset/configs/_base_/datasets/hsi_drive.py
@@ -0,0 +1,50 @@
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+
+train_dataloader = dict(
+    batch_size=1,
+    num_workers=1,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type='HSIDrive20',
+        data_root='data/HSIDrive20',
+        data_prefix=dict(
+            img_path='images/training', seg_map_path='annotations/training'),
+        pipeline=train_pipeline))
+
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=1,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='HSIDrive20',
+        data_root='data/HSIDrive20',
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
+        pipeline=test_pipeline))
+
+test_dataloader = dict(
+    batch_size=1,
+    num_workers=1,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='HSIDrive20',
+        data_root='data/HSIDrive20',
+        data_prefix=dict(
+            img_path='images/test', seg_map_path='annotations/test'),
+        pipeline=test_pipeline))
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'], ignore_index=0)
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/projects/hsidrive20_dataset/configs/unet-s5-d16_fcn_4xb4-160k_hsidrive-192x384.py b/mmsegmentation/projects/hsidrive20_dataset/configs/unet-s5-d16_fcn_4xb4-160k_hsidrive-192x384.py
new file mode 100644
index 0000000..d5eab91
--- /dev/null
+++ b/mmsegmentation/projects/hsidrive20_dataset/configs/unet-s5-d16_fcn_4xb4-160k_hsidrive-192x384.py
@@ -0,0 +1,58 @@
+_base_ = [
+    '../../../configs/_base_/models/fcn_unet_s5-d16.py',
+    './_base_/datasets/hsi_drive.py',
+    '../../../configs/_base_/default_runtime.py',
+    '../../../configs/_base_/schedules/schedule_160k.py'
+]
+
+custom_imports = dict(
+    imports=['projects.hsidrive20_dataset.mmseg.datasets.hsi_drive'])
+
+crop_size = (192, 384)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    size=crop_size,
+    mean=None,
+    std=None,
+    bgr_to_rgb=None,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(in_channels=25),
+    decode_head=dict(
+        ignore_index=0,
+        num_classes=11,
+        loss_decode=dict(
+            type='CrossEntropyLoss',
+            use_sigmoid=False,
+            loss_weight=1.0,
+            avg_non_ignore=True)),
+    auxiliary_head=dict(
+        ignore_index=0,
+        num_classes=11,
+        loss_decode=dict(
+            type='CrossEntropyLoss',
+            use_sigmoid=False,
+            loss_weight=1.0,
+            avg_non_ignore=True)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='RandomCrop', crop_size=crop_size),
+    dict(type='PackSegInputs')
+]
+
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='RandomCrop', crop_size=crop_size),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+
+train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
+test_dataloader = dict(dataset=dict(pipeline=test_pipeline))
diff --git a/mmsegmentation/projects/hsidrive20_dataset/docs/en/user_guides/2_dataset_prepare.md b/mmsegmentation/projects/hsidrive20_dataset/docs/en/user_guides/2_dataset_prepare.md
new file mode 100644
index 0000000..1d4ac8c
--- /dev/null
+++ b/mmsegmentation/projects/hsidrive20_dataset/docs/en/user_guides/2_dataset_prepare.md
@@ -0,0 +1,42 @@
+## HSI Drive 2.0
+
+- You could download HSI Drive 2.0 dataset from [here](https://ipaccess.ehu.eus/HSI-Drive/#download) after just sending an email to gded@ehu.eus with the subject "download HSI-Drive". You will receive a password to uncompress the files.
+
+- After download, unzip by the following instructions:
+
+  ```bash
+  7z x -p"password" ./HSI_Drive_v2_0_Phyton.zip
+
+  mv ./HSIDrive20 path_to_mmsegmentation/data
+  mv ./HSI_Drive_v2_0_release_notes_Python_version.md path_to_mmsegmentation/data
+  mv ./image_numbering.pdf path_to_mmsegmentation/data
+  ```
+
+- After unzip, you get
+
+```none
+mmsegmentation
+├── mmseg
+├── tools
+├── configs
+├── data
+│   ├── HSIDrive20
+│   │   ├── images
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   │   ├── test
+│   │   ├── annotations
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   │   ├── test
+│   │   ├── images_MF
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   │   ├── test
+│   │   ├── RGB
+│   │   ├── training_filenames.txt
+│   │   ├── validation_filenames.txt
+│   │   ├── test_filenames.txt
+│   ├── HSI_Drive_v2_0_release_notes_Python_version.md
+│   ├── image_numbering.pdf
+```
diff --git a/mmsegmentation/projects/hsidrive20_dataset/docs/zh_cn/user_guides/2_dataset_prepare.md b/mmsegmentation/projects/hsidrive20_dataset/docs/zh_cn/user_guides/2_dataset_prepare.md
new file mode 100644
index 0000000..dbf704a
--- /dev/null
+++ b/mmsegmentation/projects/hsidrive20_dataset/docs/zh_cn/user_guides/2_dataset_prepare.md
@@ -0,0 +1,42 @@
+## HSI Drive 2.0
+
+- 您可以从以下位置下载 HSI Drive 2.0 数据集 [here](https://ipaccess.ehu.eus/HSI-Drive/#download) 刚刚向 gded@ehu.eus 发送主题为“下载 HSI-Drive”的电子邮件后 您将收到解压缩文件的密码.
+
+- 下载后，按照以下说明解压：
+
+  ```bash
+  7z x -p"password" ./HSI_Drive_v2_0_Phyton.zip
+
+  mv ./HSIDrive20 path_to_mmsegmentation/data
+  mv ./HSI_Drive_v2_0_release_notes_Python_version.md path_to_mmsegmentation/data
+  mv ./image_numbering.pdf path_to_mmsegmentation/data
+  ```
+
+- 解压后得到:
+
+```none
+mmsegmentation
+├── mmseg
+├── tools
+├── configs
+├── data
+│   ├── HSIDrive20
+│   │   ├── images
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   │   ├── test
+│   │   ├── annotations
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   │   ├── test
+│   │   ├── images_MF
+│   │   │   ├── training
+│   │   │   ├── validation
+│   │   │   ├── test
+│   │   ├── RGB
+│   │   ├── training_filenames.txt
+│   │   ├── validation_filenames.txt
+│   │   ├── test_filenames.txt
+│   ├── HSI_Drive_v2_0_release_notes_Python_version.md
+│   ├── image_numbering.pdf
+```
diff --git a/mmsegmentation/projects/hsidrive20_dataset/mmseg/datasets/hsi_drive.py b/mmsegmentation/projects/hsidrive20_dataset/mmseg/datasets/hsi_drive.py
new file mode 100644
index 0000000..f8589b0
--- /dev/null
+++ b/mmsegmentation/projects/hsidrive20_dataset/mmseg/datasets/hsi_drive.py
@@ -0,0 +1,23 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmseg.datasets import BaseSegDataset
+
+# from mmseg.registry import DATASETS
+
+classes_exp = ('unlabelled', 'road', 'road marks', 'vegetation',
+               'painted metal', 'sky', 'concrete', 'pedestrian', 'water',
+               'unpainted metal', 'glass')
+palette_exp = [[0, 0, 0], [77, 77, 77], [255, 255, 255], [0, 255, 0],
+               [255, 0, 0], [0, 0, 255], [102, 51, 0], [255, 255, 0],
+               [0, 207, 250], [255, 166, 0], [0, 204, 204]]
+
+
+# @DATASETS.register_module()
+class HSIDrive20Dataset(BaseSegDataset):
+    METAINFO = dict(classes=classes_exp, palette=palette_exp)
+
+    def __init__(self,
+                 img_suffix='.npy',
+                 seg_map_suffix='.png',
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
diff --git a/mmsegmentation/projects/hssn/README.md b/mmsegmentation/projects/hssn/README.md
new file mode 100644
index 0000000..9dcbf37
--- /dev/null
+++ b/mmsegmentation/projects/hssn/README.md
@@ -0,0 +1,91 @@
+# HSSN
+
+## Description
+
+Author: AI-Tianlong
+
+This project implements `Deep Hierarchical Semantic Segmentation`  inference on `cityscapes` dataset
+
+## Usage
+
+### Prerequisites
+
+- Python 3.8
+- PyTorch 1.6 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+- mmcv v2.0.0rc4
+- mmengine >=0.4.0
+
+### Dataset preparing
+
+Preparing `cityscapes` dataset following this [Dataset Preparing Guide](https://github.com/open-mmlab/mmsegmentation/blob/master/docs/en/dataset_prepare.md#prepare-datasets)
+
+### Testing commands
+
+Please put [`hieraseg_deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024_20230112_125023-bc59a3d1.pth`](https://download.openmmlab.com/mmsegmentation/v0.5/hieraseg/hieraseg_deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024_20230112_125023-bc59a3d1.pth) to `mmsegmentation/checkpoints`
+
+#### Multi-GPUs Test
+
+```bash
+# --tta optional, multi-scale test, need mmengine >=0.4.0
+bash tools/dist_test.sh [configs] [model weights] [number of gpu]  --tta
+```
+
+#### Example
+
+```shell
+bash tools/dist_test.sh projects/hssn/configs/hssn/hieraseg_deeplabv3plus_r101-d8_4xb2-80l_cityscapes-512x1024.py checkpoints/hieraseg_deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024_20230112_125023-bc59a3d1.pth 2 --tta
+```
+
+## Results
+
+### Cityscapes
+
+|   Method   | Backbone | Crop Size | mIoU  | mIoU (ms+flip) |                                                                               config                                                                               |                                                                             model                                                                             |
+| :--------: | :------: | :-------: | :---: | :------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------: |
+| DeeplabV3+ | R-101-D8 | 512x1024  | 81.61 |     82.71      | [config](https://github.com/open-mmlab/mmsegmentation/tree/main/projects/HieraSeg/configs/hieraseg/hieraseg_deeplabv3plus_r101-d8_4xb2-80l_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hieraseg/hieraseg_deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024_20230112_125023-bc59a3d1.pth) |
+
+<img src="https://user-images.githubusercontent.com/50650583/210488953-e3e35ade-1132-47e1-9dfd-cf12b357ae80.png" width="50%"><img src="https://user-images.githubusercontent.com/50650583/210489746-e35ee229-3234-4292-a649-a8cd85f312ad.png" width="50%">
+
+## Citation
+
+This project is modified from [qhanghu/HSSN_pytorch](https://github.com/qhanghu/HSSN_pytorch)
+
+```bibtex
+@article{li2022deep,
+  title={Deep Hierarchical Semantic Segmentation},
+  author={Li, Liulei and Zhou, Tianfei and Wang, Wenguan and Li, Jianwu and Yang, Yi},
+  journal={CVPR},
+  year={2022}
+}
+```
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+
+  - [x] Basic docstrings & proper citation
+
+  - [x] Test-time correctness
+
+  - [x] A full README
+
+- [ ] Milestone 2: Indicates a successful model implementation.
+
+  - [ ] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+
+  - [ ] Unit tests
+
+  - [ ] Code polishing
+
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/hssn/configs/_base_/datasets/cityscapes.py b/mmsegmentation/projects/hssn/configs/_base_/datasets/cityscapes.py
new file mode 100644
index 0000000..1698e04
--- /dev/null
+++ b/mmsegmentation/projects/hssn/configs/_base_/datasets/cityscapes.py
@@ -0,0 +1,67 @@
+# dataset settings
+dataset_type = 'CityscapesDataset'
+data_root = 'data/cityscapes/'
+crop_size = (512, 1024)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=(2048, 1024),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', file_client_args=dict(backend='disk')),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='leftImg8bit/train', seg_map_path='gtFine/train'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='leftImg8bit/val', seg_map_path='gtFine/val'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/projects/hssn/configs/_base_/default_runtime.py b/mmsegmentation/projects/hssn/configs/_base_/default_runtime.py
new file mode 100644
index 0000000..272b4d2
--- /dev/null
+++ b/mmsegmentation/projects/hssn/configs/_base_/default_runtime.py
@@ -0,0 +1,15 @@
+default_scope = 'mmseg'
+env_cfg = dict(
+    cudnn_benchmark=True,
+    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+    dist_cfg=dict(backend='nccl'),
+)
+vis_backends = [dict(type='LocalVisBackend')]
+visualizer = dict(
+    type='SegLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+log_processor = dict(by_epoch=False)
+log_level = 'INFO'
+load_from = None
+resume = False
+
+tta_model = dict(type='SegTTAModel')
diff --git a/mmsegmentation/projects/hssn/configs/_base_/models/deeplabv3plus_r50-d8_vd_contrast.py b/mmsegmentation/projects/hssn/configs/_base_/models/deeplabv3plus_r50-d8_vd_contrast.py
new file mode 100644
index 0000000..a6af45c
--- /dev/null
+++ b/mmsegmentation/projects/hssn/configs/_base_/models/deeplabv3plus_r50-d8_vd_contrast.py
@@ -0,0 +1,55 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        type='ResNetV1d',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='DepthwiseSeparableASPPContrastHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        dilations=(1, 12, 24, 36),
+        c1_in_channels=256,
+        c1_channels=48,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        proj='convmlp',
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/projects/hssn/configs/_base_/schedules/schedule_80k.py b/mmsegmentation/projects/hssn/configs/_base_/schedules/schedule_80k.py
new file mode 100644
index 0000000..0dcd6c4
--- /dev/null
+++ b/mmsegmentation/projects/hssn/configs/_base_/schedules/schedule_80k.py
@@ -0,0 +1,24 @@
+# optimizer
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=0,
+        end=80000,
+        by_epoch=False)
+]
+# training schedule for 80k
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=80000, val_interval=8000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=8000),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))
diff --git a/mmsegmentation/projects/hssn/configs/hssn/hieraseg_deeplabv3plus_r101-d8_4xb2-80l_cityscapes-512x1024.py b/mmsegmentation/projects/hssn/configs/hssn/hieraseg_deeplabv3plus_r101-d8_4xb2-80l_cityscapes-512x1024.py
new file mode 100644
index 0000000..8f04a2d
--- /dev/null
+++ b/mmsegmentation/projects/hssn/configs/hssn/hieraseg_deeplabv3plus_r101-d8_4xb2-80l_cityscapes-512x1024.py
@@ -0,0 +1,21 @@
+_base_ = [
+    '../_base_/models/deeplabv3plus_r50-d8_vd_contrast.py',
+    '../_base_/datasets/cityscapes.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+
+custom_imports = dict(imports=[
+    'projects.hssn.decode_head.sep_aspp_contrast_head',
+    'projects.hssn.losses.hiera_triplet_loss_cityscape'
+])
+
+model = dict(
+    pretrained=None,
+    backbone=dict(depth=101),
+    decode_head=dict(
+        num_classes=26,
+        loss_decode=dict(
+            type='HieraTripletLossCityscape', num_classes=19,
+            loss_weight=1.0)),
+    auxiliary_head=dict(num_classes=19),
+    test_cfg=dict(mode='whole', is_hiera=True, hiera_num_classes=7))
diff --git a/mmsegmentation/projects/hssn/decode_head/__init__.py b/mmsegmentation/projects/hssn/decode_head/__init__.py
new file mode 100644
index 0000000..da454ea
--- /dev/null
+++ b/mmsegmentation/projects/hssn/decode_head/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .sep_aspp_contrast_head import DepthwiseSeparableASPPContrastHead
+
+__all__ = ['DepthwiseSeparableASPPContrastHead']
diff --git a/mmsegmentation/projects/hssn/decode_head/sep_aspp_contrast_head.py b/mmsegmentation/projects/hssn/decode_head/sep_aspp_contrast_head.py
new file mode 100644
index 0000000..331af30
--- /dev/null
+++ b/mmsegmentation/projects/hssn/decode_head/sep_aspp_contrast_head.py
@@ -0,0 +1,193 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import build_norm_layer
+from torch import Tensor
+
+from mmseg.models.decode_heads.sep_aspp_head import DepthwiseSeparableASPPHead
+from mmseg.models.losses import accuracy
+from mmseg.models.utils import resize
+from mmseg.registry import MODELS
+from mmseg.utils import SampleList
+
+
+class ProjectionHead(nn.Module):
+    """ProjectionHead, project feature map to specific channels.
+
+    Args:
+        dim_in (int): Input channels.
+        norm_cfg (dict): config of norm layer.
+        proj_dim (int): Output channels. Default: 256.
+        proj (str): Projection type, 'linear' or 'convmlp'. Default: 'convmlp'
+    """
+
+    def __init__(self,
+                 dim_in: int,
+                 norm_cfg: dict,
+                 proj_dim: int = 256,
+                 proj: str = 'convmlp'):
+        super().__init__()
+        assert proj in ['convmlp', 'linear']
+        if proj == 'linear':
+            self.proj = nn.Conv2d(dim_in, proj_dim, kernel_size=1)
+        elif proj == 'convmlp':
+            self.proj = nn.Sequential(
+                nn.Conv2d(dim_in, dim_in, kernel_size=1),
+                build_norm_layer(norm_cfg, dim_in)[1], nn.ReLU(inplace=True),
+                nn.Conv2d(dim_in, proj_dim, kernel_size=1))
+
+    def forward(self, x):
+        return torch.nn.functional.normalize(self.proj(x), p=2, dim=1)
+
+
+@MODELS.register_module()
+class DepthwiseSeparableASPPContrastHead(DepthwiseSeparableASPPHead):
+    """Deep Hierarchical Semantic Segmentation. This head is the implementation
+    of `<https://arxiv.org/abs/2203.14335>`_.
+
+    Based on Encoder-Decoder with Atrous Separable Convolution for
+    Semantic Image Segmentation.
+    `DeepLabV3+ <https://arxiv.org/abs/1802.02611>`_.
+
+    Args:
+        proj (str): The type of ProjectionHead, 'linear' or 'convmlp',
+            default 'convmlp'
+    """
+
+    def __init__(self, proj: str = 'convmlp', **kwargs):
+        super().__init__(**kwargs)
+        self.proj_head = ProjectionHead(
+            dim_in=2048, norm_cfg=self.norm_cfg, proj=proj)
+        self.register_buffer('step', torch.zeros(1))
+
+    def forward(self, inputs) -> Tuple[Tensor]:
+        """Forward function."""
+        output = super().forward(inputs)
+
+        self.step += 1
+        embedding = self.proj_head(inputs[-1])
+
+        return output, embedding
+
+    def predict_by_feat(self, seg_logits: Tuple[Tensor],
+                        batch_img_metas: List[dict]) -> Tensor:
+        """Transform a batch of output seg_logits to the input shape.
+
+        Args:
+            seg_logits (Tensor): The output from decode head forward function.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+
+        Returns:
+            Tensor: Outputs segmentation logits map.
+        """
+        # HSSN decode_head output is: (out, embedding): tuple
+        # only need 'out' here.
+        if isinstance(seg_logits, tuple):
+            seg_logit = seg_logits[0]
+
+        if seg_logit.size(1) == 26:  # For cityscapes dataset，19 + 7
+            hiera_num_classes = 7
+            seg_logit[:, 0:2] += seg_logit[:, -7]
+            seg_logit[:, 2:5] += seg_logit[:, -6]
+            seg_logit[:, 5:8] += seg_logit[:, -5]
+            seg_logit[:, 8:10] += seg_logit[:, -4]
+            seg_logit[:, 10:11] += seg_logit[:, -3]
+            seg_logit[:, 11:13] += seg_logit[:, -2]
+            seg_logit[:, 13:19] += seg_logit[:, -1]
+
+        elif seg_logit.size(1) == 12:  # For Pascal_person dataset, 7 + 5
+            hiera_num_classes = 5
+            seg_logit[:, 0:1] = seg_logit[:, 0:1] + \
+                seg_logit[:, 7] + seg_logit[:, 10]
+            seg_logit[:, 1:5] = seg_logit[:, 1:5] + \
+                seg_logit[:, 8] + seg_logit[:, 11]
+            seg_logit[:, 5:7] = seg_logit[:, 5:7] + \
+                seg_logit[:, 9] + seg_logit[:, 11]
+
+        elif seg_logit.size(1) == 25:  # For LIP dataset, 20 + 5
+            hiera_num_classes = 5
+            seg_logit[:, 0:1] = seg_logit[:, 0:1] + \
+                seg_logit[:, 20] + seg_logit[:, 23]
+            seg_logit[:, 1:8] = seg_logit[:, 1:8] + \
+                seg_logit[:, 21] + seg_logit[:, 24]
+            seg_logit[:, 10:12] = seg_logit[:, 10:12] + \
+                seg_logit[:, 21] + seg_logit[:, 24]
+            seg_logit[:, 13:16] = seg_logit[:, 13:16] + \
+                seg_logit[:, 21] + seg_logit[:, 24]
+            seg_logit[:, 8:10] = seg_logit[:, 8:10] + \
+                seg_logit[:, 22] + seg_logit[:, 24]
+            seg_logit[:, 12:13] = seg_logit[:, 12:13] + \
+                seg_logit[:, 22] + seg_logit[:, 24]
+            seg_logit[:, 16:20] = seg_logit[:, 16:20] + \
+                seg_logit[:, 22] + seg_logit[:, 24]
+
+        # elif seg_logit.size(1) == 144 # For Mapillary dataset, 124+16+4
+        # unofficial repository not release mapillary until 2023/2/6
+
+        if isinstance(batch_img_metas[0]['img_shape'], torch.Size):
+            # slide inference
+            size = batch_img_metas[0]['img_shape']
+        elif 'pad_shape' in batch_img_metas[0]:
+            size = batch_img_metas[0]['pad_shape'][:2]
+        else:
+            size = batch_img_metas[0]['img_shape']
+        seg_logit = seg_logit[:, :-hiera_num_classes]
+        seg_logit = resize(
+            input=seg_logit,
+            size=size,
+            mode='bilinear',
+            align_corners=self.align_corners)
+
+        return seg_logit
+
+    def loss_by_feat(
+            self,
+            seg_logits: Tuple[Tensor],  # (out, embedding)
+            batch_data_samples: SampleList) -> dict:
+        """Compute segmentation loss. Will fix in future.
+
+        Args:
+            seg_logits (Tuple[Tensor]): The output from decode head
+                forward function.
+                For this decode_head output are (out, embedding): tuple
+            batch_data_samples (List[:obj:`SegDataSample`]): The seg
+                data samples. It usually includes information such
+                as `metainfo` and `gt_sem_seg`.
+
+        Returns:
+            dict[str, Tensor]: a dictionary of loss components
+        """
+        seg_logit_before = seg_logits[0]
+        embedding = seg_logits[1]
+        seg_label = self._stack_batch_gt(batch_data_samples)
+
+        loss = dict()
+        seg_logit = resize(
+            input=seg_logit_before,
+            size=seg_label.shape[2:],
+            mode='bilinear',
+            align_corners=self.align_corners)
+        if self.sampler is not None:
+            seg_weight = self.sampler.sample(seg_logit, seg_label)
+        else:
+            seg_weight = None
+        seg_label = seg_label.squeeze(1)
+        seg_logit_before = resize(
+            input=seg_logit_before,
+            scale_factor=0.5,
+            mode='bilinear',
+            align_corners=self.align_corners)
+
+        loss['loss_seg'] = self.loss_decode(
+            self.step,
+            embedding,
+            seg_logit_before,
+            seg_logit,
+            seg_label,
+            weight=seg_weight,
+            ignore_index=self.ignore_index)
+        loss['acc_seg'] = accuracy(seg_logit, seg_label)
+        return loss
diff --git a/mmsegmentation/projects/hssn/losses/__init__.py b/mmsegmentation/projects/hssn/losses/__init__.py
new file mode 100644
index 0000000..47d2686
--- /dev/null
+++ b/mmsegmentation/projects/hssn/losses/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .hiera_triplet_loss_cityscape import HieraTripletLossCityscape
+
+__all__ = ['HieraTripletLossCityscape']
diff --git a/mmsegmentation/projects/hssn/losses/hiera_triplet_loss_cityscape.py b/mmsegmentation/projects/hssn/losses/hiera_triplet_loss_cityscape.py
new file mode 100644
index 0000000..a784f13
--- /dev/null
+++ b/mmsegmentation/projects/hssn/losses/hiera_triplet_loss_cityscape.py
@@ -0,0 +1,218 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from mmseg.models.builder import LOSSES
+from mmseg.models.losses.cross_entropy_loss import CrossEntropyLoss
+from .tree_triplet_loss import TreeTripletLoss
+
+hiera_map = [0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 4, 5, 5, 6, 6, 6, 6, 6, 6]
+hiera_index = [[0, 2], [2, 5], [5, 8], [8, 10], [10, 11], [11, 13], [13, 19]]
+
+hiera = {
+    'hiera_high': {
+        'flat': [0, 2],
+        'construction': [2, 5],
+        'object': [5, 8],
+        'nature': [8, 10],
+        'sky': [10, 11],
+        'human': [11, 13],
+        'vehicle': [13, 19]
+    }
+}
+
+
+def prepare_targets(targets):
+    b, h, w = targets.shape
+    targets_high = torch.ones(
+        (b, h, w), dtype=targets.dtype, device=targets.device) * 255
+    indices_high = []
+    for index, high in enumerate(hiera['hiera_high'].keys()):
+        indices = hiera['hiera_high'][high]
+        for ii in range(indices[0], indices[1]):
+            targets_high[targets == ii] = index
+        indices_high.append(indices)
+
+    return targets, targets_high, indices_high
+
+
+def losses_hiera(predictions,
+                 targets,
+                 targets_top,
+                 num_classes,
+                 indices_high,
+                 eps=1e-8):
+    """Implementation of hiera loss.
+
+    Args:
+        predictions (torch.Tensor): seg logits produced by decode head.
+        targets (torch.Tensor): The learning label of the prediction.
+        targets_top (torch.Tensor): The hierarchy ground truth of the learning
+            label.
+        num_classes (int): Number of categories.
+        indices_high (List[List[int]]): Hierarchy indices of each hierarchy.
+        eps (float):Term added to the Logarithm to improve numerical stability.
+    """
+    b, _, h, w = predictions.shape
+    predictions = torch.sigmoid(predictions.float())
+    void_indices = (targets == 255)
+    targets[void_indices] = 0
+    targets = F.one_hot(targets, num_classes=num_classes).permute(0, 3, 1, 2)
+    void_indices2 = (targets_top == 255)
+    targets_top[void_indices2] = 0
+    targets_top = F.one_hot(targets_top, num_classes=7).permute(0, 3, 1, 2)
+
+    MCMA = predictions[:, :num_classes, :, :]
+    MCMB = torch.zeros((b, 7, h, w)).to(predictions)
+    for ii in range(7):
+        MCMB[:, ii:ii + 1, :, :] = torch.max(
+            torch.cat([
+                predictions[:, indices_high[ii][0]:indices_high[ii][1], :, :],
+                predictions[:, num_classes + ii:num_classes + ii + 1, :, :]
+            ],
+                      dim=1), 1, True)[0]
+
+    MCLB = predictions[:, num_classes:num_classes + 7, :, :]
+    MCLA = predictions[:, :num_classes, :, :].clone()
+    for ii in range(7):
+        for jj in range(indices_high[ii][0], indices_high[ii][1]):
+            MCLA[:, jj:jj + 1, :, :] = torch.min(
+                torch.cat([
+                    predictions[:, jj:jj + 1, :, :], MCLB[:, ii:ii + 1, :, :]
+                ],
+                          dim=1), 1, True)[0]
+
+    valid_indices = (~void_indices).unsqueeze(1)
+    num_valid = valid_indices.sum()
+    valid_indices2 = (~void_indices2).unsqueeze(1)
+    num_valid2 = valid_indices2.sum()
+    # channel_num*sum()/one_channel_valid already has a weight
+    loss = (
+        (-targets[:, :num_classes, :, :] * torch.log(MCLA + eps) -
+         (1.0 - targets[:, :num_classes, :, :]) * torch.log(1.0 - MCMA + eps))
+        * valid_indices).sum() / num_valid / num_classes
+    loss += ((-targets_top[:, :, :, :] * torch.log(MCLB + eps) -
+              (1.0 - targets_top[:, :, :, :]) * torch.log(1.0 - MCMB + eps)) *
+             valid_indices2).sum() / num_valid2 / 7
+
+    return 5 * loss
+
+
+def losses_hiera_focal(predictions,
+                       targets,
+                       targets_top,
+                       num_classes,
+                       indices_high,
+                       eps=1e-8,
+                       gamma=2):
+    """Implementation of hiera loss.
+
+    Args:
+        predictions (torch.Tensor): seg logits produced by decode head.
+        targets (torch.Tensor): The learning label of the prediction.
+        targets_top (torch.Tensor): The hierarchy ground truth of the learning
+            label.
+        num_classes (int): Number of categories.
+        indices_high (List[List[int]]): Hierarchy indices of each hierarchy.
+        eps (float):Term added to the Logarithm to improve numerical stability.
+            Defaults: 1e-8.
+        gamma (int): The exponent value. Defaults: 2.
+    """
+    b, _, h, w = predictions.shape
+    predictions = torch.sigmoid(predictions.float())
+    void_indices = (targets == 255)
+    targets[void_indices] = 0
+    targets = F.one_hot(targets, num_classes=num_classes).permute(0, 3, 1, 2)
+    void_indices2 = (targets_top == 255)
+    targets_top[void_indices2] = 0
+    targets_top = F.one_hot(targets_top, num_classes=7).permute(0, 3, 1, 2)
+
+    MCMA = predictions[:, :num_classes, :, :]
+    MCMB = torch.zeros((b, 7, h, w),
+                       dtype=predictions.dtype,
+                       device=predictions.device)
+    for ii in range(7):
+        MCMB[:, ii:ii + 1, :, :] = torch.max(
+            torch.cat([
+                predictions[:, indices_high[ii][0]:indices_high[ii][1], :, :],
+                predictions[:, num_classes + ii:num_classes + ii + 1, :, :]
+            ],
+                      dim=1), 1, True)[0]
+
+    MCLB = predictions[:, num_classes:num_classes + 7, :, :]
+    MCLA = predictions[:, :num_classes, :, :].clone()
+    for ii in range(7):
+        for jj in range(indices_high[ii][0], indices_high[ii][1]):
+            MCLA[:, jj:jj + 1, :, :] = torch.min(
+                torch.cat([
+                    predictions[:, jj:jj + 1, :, :], MCLB[:, ii:ii + 1, :, :]
+                ],
+                          dim=1), 1, True)[0]
+
+    valid_indices = (~void_indices).unsqueeze(1)
+    num_valid = valid_indices.sum()
+    valid_indices2 = (~void_indices2).unsqueeze(1)
+    num_valid2 = valid_indices2.sum()
+    # channel_num*sum()/one_channel_valid already has a weight
+    loss = ((-targets[:, :num_classes, :, :] * torch.pow(
+        (1.0 - MCLA), gamma) * torch.log(MCLA + eps) -
+             (1.0 - targets[:, :num_classes, :, :]) * torch.pow(MCMA, gamma) *
+             torch.log(1.0 - MCMA + eps)) *
+            valid_indices).sum() / num_valid / num_classes
+    loss += (
+        (-targets_top[:, :, :, :] * torch.pow(
+            (1.0 - MCLB), gamma) * torch.log(MCLB + eps) -
+         (1.0 - targets_top[:, :, :, :]) * torch.pow(MCMB, gamma) *
+         torch.log(1.0 - MCMB + eps)) * valid_indices2).sum() / num_valid2 / 7
+
+    return 5 * loss
+
+
+@LOSSES.register_module()
+class HieraTripletLossCityscape(nn.Module):
+    """Modified from https://github.com/qhanghu/HSSN_pytorch/blob/main/mmseg/mo
+    dels/losses/hiera_triplet_loss_cityscape.py."""
+
+    def __init__(self, num_classes, use_sigmoid=False, loss_weight=1.0):
+        super().__init__()
+        self.num_classes = num_classes
+        self.loss_weight = loss_weight
+        self.treetripletloss = TreeTripletLoss(num_classes, hiera_map,
+                                               hiera_index)
+        self.ce = CrossEntropyLoss()
+
+    def forward(self,
+                step,
+                embedding,
+                cls_score_before,
+                cls_score,
+                label,
+                weight=None,
+                **kwargs):
+        targets, targets_top, indices_top = prepare_targets(label)
+
+        loss = losses_hiera(cls_score, targets, targets_top, self.num_classes,
+                            indices_top)
+        ce_loss = self.ce(cls_score[:, :-7], label)
+        ce_loss2 = self.ce(cls_score[:, -7:], targets_top)
+        loss = loss + ce_loss + ce_loss2
+
+        loss_triplet, class_count = self.treetripletloss(embedding, label)
+        class_counts = [
+            torch.ones_like(class_count)
+            for _ in range(torch.distributed.get_world_size())
+        ]
+        torch.distributed.all_gather(class_counts, class_count, async_op=False)
+        class_counts = torch.cat(class_counts, dim=0)
+
+        if torch.distributed.get_world_size() == torch.nonzero(
+                class_counts, as_tuple=False).size(0):
+            factor = 1 / 4 * (1 + torch.cos(
+                torch.tensor((step.item() - 80000) / 80000 *
+                             math.pi))) if step.item() < 80000 else 0.5
+            loss += factor * loss_triplet
+
+        return loss * self.loss_weight
diff --git a/mmsegmentation/projects/hssn/losses/tree_triplet_loss.py b/mmsegmentation/projects/hssn/losses/tree_triplet_loss.py
new file mode 100644
index 0000000..ccc0937
--- /dev/null
+++ b/mmsegmentation/projects/hssn/losses/tree_triplet_loss.py
@@ -0,0 +1,86 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from mmseg.models.builder import LOSSES
+
+
+@LOSSES.register_module()
+class TreeTripletLoss(nn.Module):
+    """TreeTripletLoss. Modified from https://github.com/qhanghu/HSSN_pytorch/b
+    lob/main/mmseg/models/losses/tree_triplet_loss.py.
+
+    Args:
+        num_classes (int): Number of categories.
+        hiera_map (List[int]): Hierarchy map of each category.
+        hiera_index (List[List[int]]): Hierarchy indices of each hierarchy.
+        ignore_index (int): Specifies a target value that is ignored and
+            does not contribute to the input gradients. Defaults: 255.
+
+    Examples:
+        >>> num_classes = 19
+        >>> hiera_map = [
+                0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 4, 5, 5, 6, 6, 6, 6, 6, 6]
+        >>> hiera_index = [
+                0, 2], [2, 5], [5, 8], [8, 10], [10, 11], [11, 13], [13, 19]]
+    """
+
+    def __init__(self, num_classes, hiera_map, hiera_index, ignore_index=255):
+        super().__init__()
+
+        self.ignore_label = ignore_index
+        self.num_classes = num_classes
+        self.hiera_map = hiera_map
+        self.hiera_index = hiera_index
+
+    def forward(self, feats: torch.Tensor, labels=None, max_triplet=200):
+        labels = labels.unsqueeze(1).float().clone()
+        labels = torch.nn.functional.interpolate(
+            labels, (feats.shape[2], feats.shape[3]), mode='nearest')
+        labels = labels.squeeze(1).long()
+        assert labels.shape[-1] == feats.shape[-1], '{} {}'.format(
+            labels.shape, feats.shape)
+
+        labels = labels.view(-1)
+        feats = feats.permute(0, 2, 3, 1)
+        feats = feats.contiguous().view(-1, feats.shape[-1])
+
+        triplet_loss = 0
+        exist_classes = torch.unique(labels)
+        exist_classes = [x for x in exist_classes if x != 255]
+        class_count = 0
+
+        for ii in exist_classes:
+            index_range = self.hiera_index[self.hiera_map[ii]]
+            index_anchor = labels == ii
+            index_pos = (labels >= index_range[0]) & (
+                labels < index_range[-1]) & (~index_anchor)
+            index_neg = (labels < index_range[0]) | (labels >= index_range[-1])
+
+            min_size = min(
+                torch.sum(index_anchor), torch.sum(index_pos),
+                torch.sum(index_neg), max_triplet)
+
+            feats_anchor = feats[index_anchor][:min_size]
+            feats_pos = feats[index_pos][:min_size]
+            feats_neg = feats[index_neg][:min_size]
+
+            distance = torch.zeros(min_size, 2).to(feats)
+            distance[:, 0:1] = 1 - (feats_anchor * feats_pos).sum(1, True)
+            distance[:, 1:2] = 1 - (feats_anchor * feats_neg).sum(1, True)
+
+            # margin always 0.1 + (4-2)/4 since the hierarchy is three level
+            # TODO: should include label of pos is the same as anchor
+            margin = 0.6 * torch.ones(min_size).to(feats)
+
+            tl = distance[:, 0] - distance[:, 1] + margin
+            tl = F.relu(tl)
+
+            if tl.size(0) > 0:
+                triplet_loss += tl.mean()
+                class_count += 1
+        if class_count == 0:
+            return None, torch.tensor([0]).to(feats)
+        triplet_loss /= class_count
+        return triplet_loss, torch.tensor([class_count]).to(feats)
diff --git a/mmsegmentation/projects/isnet/README.md b/mmsegmentation/projects/isnet/README.md
new file mode 100644
index 0000000..0a79ad6
--- /dev/null
+++ b/mmsegmentation/projects/isnet/README.md
@@ -0,0 +1,117 @@
+# ISNet
+
+[ISNet: Integrate Image-Level and Semantic-Level Context for Semantic Segmentation](https://arxiv.org/pdf/2108.12382.pdf)
+
+## Description
+
+This is an implementation of [ISNet](https://arxiv.org/pdf/2108.12382.pdf).
+[Official Repo](https://github.com/SegmentationBLWX/sssegmentation)
+
+## Usage
+
+### Prerequisites
+
+- Python 3.7
+- PyTorch 1.6 or higher
+- [MIM](https://github.com/open-mmlab/mim) v0.33 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc2 or higher
+
+All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `isnet/` root directory, run the following line to add the current directory to `PYTHONPATH`:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Training commands
+
+```shell
+mim train mmsegmentation configs/isnet_r50-d8_8xb2-160k_cityscapes-512x1024.py --work-dir work_dirs/isnet
+```
+
+To train on multiple GPUs, e.g. 8 GPUs, run the following command:
+
+```shell
+mim train mmsegmentation configs/isnet_r50-d8_8xb2-160k_cityscapes-512x1024.py --work-dir work_dirs/isnet --launcher pytorch --gpus 8
+```
+
+### Testing commands
+
+```shell
+mim test mmsegmentation configs/isnet_r50-d8_8xb2-160k_cityscapes-512x1024.py --work-dir work_dirs/isnet --checkpoint ${CHECKPOINT_PATH}
+```
+
+| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) |  mIoU | mIoU(ms+flip) | config                                                          | download                                                                                                                 |
+| ------ | -------- | --------- | ------: | -------- | -------------- | ----: | ------------: | --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
+| ISNet  | R-50-D8  | 512x1024  |       - | -        | -              | 79.32 |         80.88 | [config](configs/isnet_r50-d8_8xb2-160k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isnet/isnet_r50-d8_cityscapes-512x1024_20230104-a7a8ccf2.pth) |
+
+## Citation
+
+```bibtex
+@article{Jin2021ISNetII,
+  title={ISNet: Integrate Image-Level and Semantic-Level Context for Semantic Segmentation},
+  author={Zhenchao Jin and B. Liu and Qi Chu and Nenghai Yu},
+  journal={2021 IEEE/CVF International Conference on Computer Vision (ICCV)},
+  year={2021},
+  pages={7169-7178}
+}
+```
+
+## Checklist
+
+The progress of ISNet.
+
+<!-- The PIC (person in charge) or contributors of this project should check all the items that they believe have been finished, which will further be verified by codebase maintainers via a PR.
+
+OpenMMLab's maintainer will review the code to ensure the project's quality. Reaching the first milestone means that this project suffices the minimum requirement of being merged into 'projects/'. But this project is only eligible to become a part of the core package upon attaining the last milestone.
+
+Note that keeping this section up-to-date is crucial not only for this project's developers but the entire community, since there might be some other contributors joining this project and deciding their starting point from this list. It also helps maintainers accurately estimate time and effort on further code polishing, if needed.
+
+A project does not necessarily have to be finished in a single PR, but it's essential for the project to at least reach the first milestone in its very first PR. -->
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+
+  <!-- The code's design shall follow existing interfaces and convention. For example, each model component should be registered into `mmseg.registry.MODELS` and configurable via a config file. -->
+
+  - [x] Basic docstrings & proper citation
+
+  <!-- Each major object should contain a docstring, describing its functionality and arguments. If you have adapted the code from other open-source projects, don't forget to cite the source project in docstring and make sure your behavior is not against its license. Typically, we do not accept any code snippet under GPL license. [A Short Guide to Open Source Licenses](https://medium.com/nationwide-technology/a-short-guide-to-open-source-licenses-cf5b1c329edd) -->
+
+  - [x] Test-time correctness
+
+  <!-- If you are reproducing the result from a paper, make sure your model's inference-time performance matches that in the original paper. The weights usually could be obtained by simply renaming the keys in the official pre-trained weights. This test could be skipped though, if you are able to prove the training-time correctness and check the second milestone. -->
+
+  - [x] A full README
+
+  <!-- As this template does. -->
+
+- [ ] Milestone 2: Indicates a successful model implementation.
+
+  - [ ] Training-time correctness
+
+  <!-- If you are reproducing the result from a paper, checking this item means that you should have trained your model from scratch based on the original paper's specification and verified that the final result matches the report within a minor error range. -->
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+
+  <!-- Ideally *all* the methods should have [type hints](https://www.pythontutorial.net/python-basics/python-type-hints/) and [docstrings](https://google.github.io/styleguide/pyguide.html#381-docstrings). [Example](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/utils/io.py#L9) -->
+
+  - [ ] Unit tests
+
+  <!-- Unit tests for each module are required. [Example](https://github.com/open-mmlab/mmsegmentation/blob/main/tests/test_utils/test_io.py#L14) -->
+
+  - [ ] Code polishing
+
+  <!-- Refactor your code according to reviewer's comment. -->
+
+  - [ ] Metafile.yml
+
+  <!-- It will be parsed by MIM and Inferencer. [Example](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn.yml) -->
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+  <!-- In particular, you may have to refactor this README into a standard one. [Example](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/README.md) -->
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/isnet/configs/isnet_r50-d8_8xb2-160k_cityscapes-512x1024.py b/mmsegmentation/projects/isnet/configs/isnet_r50-d8_8xb2-160k_cityscapes-512x1024.py
new file mode 100644
index 0000000..a00d392
--- /dev/null
+++ b/mmsegmentation/projects/isnet/configs/isnet_r50-d8_8xb2-160k_cityscapes-512x1024.py
@@ -0,0 +1,80 @@
+_base_ = [
+    '../../../configs/_base_/datasets/cityscapes.py',
+    '../../../configs/_base_/default_runtime.py',
+    '../../../configs/_base_/schedules/schedule_80k.py'
+]
+
+data_root = '../../data/cityscapes/'
+train_dataloader = dict(dataset=dict(data_root=data_root))
+val_dataloader = dict(dataset=dict(data_root=data_root))
+test_dataloader = dict(dataset=dict(data_root=data_root))
+
+custom_imports = dict(imports=['projects.isnet.decode_heads'])
+
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='ISNetHead',
+        in_channels=(256, 512, 1024, 2048),
+        input_transform='multiple_select',
+        in_index=(0, 1, 2, 3),
+        channels=512,
+        dropout_ratio=0.1,
+        transform_channels=256,
+        concat_input=True,
+        with_shortcut=False,
+        shortcut_in_channels=256,
+        shortcut_feat_channels=48,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=[
+            dict(
+                type='CrossEntropyLoss',
+                use_sigmoid=False,
+                loss_weight=1.0,
+                loss_name='loss_o'),
+            dict(
+                type='CrossEntropyLoss',
+                use_sigmoid=False,
+                loss_weight=0.4,
+                loss_name='loss_d'),
+        ]),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=512,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    train_cfg=dict(),
+    # test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513))
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/projects/isnet/decode_heads/__init__.py b/mmsegmentation/projects/isnet/decode_heads/__init__.py
new file mode 100644
index 0000000..a451629
--- /dev/null
+++ b/mmsegmentation/projects/isnet/decode_heads/__init__.py
@@ -0,0 +1,3 @@
+from .isnet_head import ISNetHead
+
+__all__ = ['ISNetHead']
diff --git a/mmsegmentation/projects/isnet/decode_heads/isnet_head.py b/mmsegmentation/projects/isnet/decode_heads/isnet_head.py
new file mode 100644
index 0000000..9c8df54
--- /dev/null
+++ b/mmsegmentation/projects/isnet/decode_heads/isnet_head.py
@@ -0,0 +1,337 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from torch import Tensor
+
+from mmseg.models.decode_heads.decode_head import BaseDecodeHead
+from mmseg.models.losses import accuracy
+from mmseg.models.utils import SelfAttentionBlock, resize
+from mmseg.registry import MODELS
+from mmseg.utils import SampleList
+
+
+class ImageLevelContext(nn.Module):
+    """ Image-Level Context Module
+    Args:
+        feats_channels (int): Input channels of query/key feature.
+        transform_channels (int): Output channels of key/query transform.
+        concat_input (bool): whether to concat input feature.
+        align_corners (bool): align_corners argument of F.interpolate.
+        conv_cfg (dict|None): Config of conv layers.
+        norm_cfg (dict|None): Config of norm layers.
+        act_cfg (dict): Config of activation layers.
+    """
+
+    def __init__(self,
+                 feats_channels,
+                 transform_channels,
+                 concat_input=False,
+                 align_corners=False,
+                 conv_cfg=None,
+                 norm_cfg=None,
+                 act_cfg=None):
+        super().__init__()
+        self.align_corners = align_corners
+        self.global_avgpool = nn.AdaptiveAvgPool2d((1, 1))
+        self.correlate_net = SelfAttentionBlock(
+            key_in_channels=feats_channels * 2,
+            query_in_channels=feats_channels,
+            channels=transform_channels,
+            out_channels=feats_channels,
+            share_key_query=False,
+            query_downsample=None,
+            key_downsample=None,
+            key_query_num_convs=2,
+            value_out_num_convs=1,
+            key_query_norm=True,
+            value_out_norm=True,
+            matmul_norm=True,
+            with_out=True,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg,
+        )
+        if concat_input:
+            self.bottleneck = ConvModule(
+                feats_channels * 2,
+                feats_channels,
+                kernel_size=3,
+                stride=1,
+                padding=1,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg,
+            )
+
+    '''forward'''
+
+    def forward(self, x):
+        x_global = self.global_avgpool(x)
+        x_global = resize(
+            x_global,
+            size=x.shape[2:],
+            mode='bilinear',
+            align_corners=self.align_corners)
+        feats_il = self.correlate_net(x, torch.cat([x_global, x], dim=1))
+        if hasattr(self, 'bottleneck'):
+            feats_il = self.bottleneck(torch.cat([x, feats_il], dim=1))
+        return feats_il
+
+
+class SemanticLevelContext(nn.Module):
+    """ Semantic-Level Context Module
+    Args:
+        feats_channels (int): Input channels of query/key feature.
+        transform_channels (int): Output channels of key/query transform.
+        concat_input (bool): whether to concat input feature.
+        conv_cfg (dict|None): Config of conv layers.
+        norm_cfg (dict|None): Config of norm layers.
+        act_cfg (dict): Config of activation layers.
+    """
+
+    def __init__(self,
+                 feats_channels,
+                 transform_channels,
+                 concat_input=False,
+                 conv_cfg=None,
+                 norm_cfg=None,
+                 act_cfg=None):
+        super().__init__()
+        self.correlate_net = SelfAttentionBlock(
+            key_in_channels=feats_channels,
+            query_in_channels=feats_channels,
+            channels=transform_channels,
+            out_channels=feats_channels,
+            share_key_query=False,
+            query_downsample=None,
+            key_downsample=None,
+            key_query_num_convs=2,
+            value_out_num_convs=1,
+            key_query_norm=True,
+            value_out_norm=True,
+            matmul_norm=True,
+            with_out=True,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg,
+        )
+        if concat_input:
+            self.bottleneck = ConvModule(
+                feats_channels * 2,
+                feats_channels,
+                kernel_size=3,
+                stride=1,
+                padding=1,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg,
+            )
+
+    '''forward'''
+
+    def forward(self, x, preds, feats_il):
+        inputs = x
+        batch_size, num_channels, h, w = x.size()
+        num_classes = preds.size(1)
+        feats_sl = torch.zeros(batch_size, h * w, num_channels).type_as(x)
+        for batch_idx in range(batch_size):
+            # (C, H, W), (num_classes, H, W) --> (H*W, C), (H*W, num_classes)
+            feats_iter, preds_iter = x[batch_idx], preds[batch_idx]
+            feats_iter, preds_iter = feats_iter.reshape(
+                num_channels, -1), preds_iter.reshape(num_classes, -1)
+            feats_iter, preds_iter = feats_iter.permute(1,
+                                                        0), preds_iter.permute(
+                                                            1, 0)
+            # (H*W, )
+            argmax = preds_iter.argmax(1)
+            for clsid in range(num_classes):
+                mask = (argmax == clsid)
+                if mask.sum() == 0:
+                    continue
+                feats_iter_cls = feats_iter[mask]
+                preds_iter_cls = preds_iter[:, clsid][mask]
+                weight = torch.softmax(preds_iter_cls, dim=0)
+                feats_iter_cls = feats_iter_cls * weight.unsqueeze(-1)
+                feats_iter_cls = feats_iter_cls.sum(0)
+                feats_sl[batch_idx][mask] = feats_iter_cls
+        feats_sl = feats_sl.reshape(batch_size, h, w, num_channels)
+        feats_sl = feats_sl.permute(0, 3, 1, 2).contiguous()
+        feats_sl = self.correlate_net(inputs, feats_sl)
+        if hasattr(self, 'bottleneck'):
+            feats_sl = self.bottleneck(torch.cat([feats_il, feats_sl], dim=1))
+        return feats_sl
+
+
+@MODELS.register_module()
+class ISNetHead(BaseDecodeHead):
+    """ISNet: Integrate Image-Level and Semantic-Level
+    Context for Semantic Segmentation
+
+    This head is the implementation of `ISNet`
+    <https://arxiv.org/pdf/2108.12382.pdf>`_.
+
+    Args:
+        transform_channels (int): Output channels of key/query transform.
+        concat_input (bool): whether to concat input feature.
+        with_shortcut (bool): whether to use shortcut connection.
+        shortcut_in_channels (int): Input channels of shortcut.
+        shortcut_feat_channels (int): Output channels of shortcut.
+        dropout_ratio (float): Ratio of dropout.
+    """
+
+    def __init__(self, transform_channels, concat_input, with_shortcut,
+                 shortcut_in_channels, shortcut_feat_channels, dropout_ratio,
+                 **kwargs):
+        super().__init__(**kwargs)
+
+        self.in_channels = self.in_channels[-1]
+
+        self.bottleneck = ConvModule(
+            self.in_channels,
+            self.channels,
+            kernel_size=3,
+            stride=1,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+        self.ilc_net = ImageLevelContext(
+            feats_channels=self.channels,
+            transform_channels=transform_channels,
+            concat_input=concat_input,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg,
+            align_corners=self.align_corners)
+        self.slc_net = SemanticLevelContext(
+            feats_channels=self.channels,
+            transform_channels=transform_channels,
+            concat_input=concat_input,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+        self.decoder_stage1 = nn.Sequential(
+            ConvModule(
+                self.channels,
+                self.channels,
+                kernel_size=1,
+                stride=1,
+                padding=0,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg),
+            nn.Dropout2d(dropout_ratio),
+            nn.Conv2d(
+                self.channels,
+                self.num_classes,
+                kernel_size=1,
+                stride=1,
+                padding=0,
+                bias=True),
+        )
+
+        if with_shortcut:
+            self.shortcut = ConvModule(
+                shortcut_in_channels,
+                shortcut_feat_channels,
+                kernel_size=1,
+                stride=1,
+                padding=0,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg)
+            self.decoder_stage2 = nn.Sequential(
+                ConvModule(
+                    self.channels + shortcut_feat_channels,
+                    self.channels,
+                    kernel_size=3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg,
+                    act_cfg=self.act_cfg),
+                nn.Dropout2d(dropout_ratio),
+                nn.Conv2d(
+                    self.channels,
+                    self.num_classes,
+                    kernel_size=1,
+                    stride=1,
+                    padding=0,
+                    bias=True),
+            )
+        else:
+            self.decoder_stage2 = nn.Sequential(
+                nn.Dropout2d(dropout_ratio),
+                nn.Conv2d(
+                    self.channels,
+                    self.num_classes,
+                    kernel_size=1,
+                    stride=1,
+                    padding=0,
+                    bias=True),
+            )
+
+        self.conv_seg = None
+        self.dropout = None
+
+    def forward(self, inputs):
+        x = self._transform_inputs(inputs)
+        feats = self.bottleneck(x[-1])
+
+        feats_il = self.ilc_net(feats)
+
+        preds_stage1 = self.decoder_stage1(feats)
+        preds_stage1 = resize(
+            preds_stage1,
+            size=feats.size()[2:],
+            mode='bilinear',
+            align_corners=self.align_corners)
+
+        feats_sl = self.slc_net(feats, preds_stage1, feats_il)
+
+        if hasattr(self, 'shortcut'):
+            shortcut_out = self.shortcut(x[0])
+            feats_sl = resize(
+                feats_sl,
+                size=shortcut_out.shape[2:],
+                mode='bilinear',
+                align_corners=self.align_corners)
+            feats_sl = torch.cat([feats_sl, shortcut_out], dim=1)
+        preds_stage2 = self.decoder_stage2(feats_sl)
+
+        return preds_stage1, preds_stage2
+
+    def loss_by_feat(self, seg_logits: Tensor,
+                     batch_data_samples: SampleList) -> dict:
+        seg_label = self._stack_batch_gt(batch_data_samples)
+        loss = dict()
+
+        if self.sampler is not None:
+            seg_weight = self.sampler.sample(seg_logits[-1], seg_label)
+        else:
+            seg_weight = None
+        seg_label = seg_label.squeeze(1)
+
+        for seg_logit, loss_decode in zip(seg_logits, self.loss_decode):
+            seg_logit = resize(
+                input=seg_logit,
+                size=seg_label.shape[2:],
+                mode='bilinear',
+                align_corners=self.align_corners)
+            loss[loss_decode.name] = loss_decode(
+                seg_logit,
+                seg_label,
+                seg_weight,
+                ignore_index=self.ignore_index)
+
+        loss['acc_seg'] = accuracy(
+            seg_logits[-1], seg_label, ignore_index=self.ignore_index)
+        return loss
+
+    def predict_by_feat(self, seg_logits: Tensor,
+                        batch_img_metas: List[dict]) -> Tensor:
+        _, seg_logits_stage2 = seg_logits
+        return super().predict_by_feat(seg_logits_stage2, batch_img_metas)
diff --git a/mmsegmentation/projects/mapillary_dataset/README.md b/mmsegmentation/projects/mapillary_dataset/README.md
new file mode 100644
index 0000000..44a1e33
--- /dev/null
+++ b/mmsegmentation/projects/mapillary_dataset/README.md
@@ -0,0 +1,86 @@
+# Mapillary Vistas Dataset
+
+Support **`Mapillary Vistas Dataset`**
+
+## Description
+
+Author: AI-Tianlong
+
+This project implements **`Mapillary Vistas Dataset`**
+
+### Dataset preparing
+
+Preparing `Mapillary Vistas Dataset` dataset following [Mapillary Vistas Dataset Preparing Guide](https://github.com/open-mmlab/mmsegmentation/tree/main/projects/mapillary_dataset/docs/en/user_guides/2_dataset_prepare.md)
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── tools
+  ├── configs
+  ├── data
+  │   ├── mapillary
+  │   │   ├── training
+  │   │   │   ├── images
+  │   │   │   ├── v1.2
+  |   │   │   │   ├── instances
+  |   │   │   │   ├── labels
+  |   │   │   │   ├── labels_mask
+  |   │   │   │   └── panoptic
+  │   │   │   ├── v2.0
+  |   │   │   │   ├── instances
+  |   │   │   │   ├── labels
+  |   │   │   │   ├── labels_mask
+  |   │   │   │   ├── panoptic
+  |   │   │   │   └── polygons
+  │   │   ├── validation
+  │   │   │   ├── images
+  │   │   │   ├── v1.2
+  |   │   │   │   ├── instances
+  |   │   │   │   ├── labels
+  |   │   │   │   ├── labels_mask
+  |   │   │   │   └── panoptic
+  │   │   │   ├── v2.0
+  |   │   │   │   ├── instances
+  |   │   │   │   ├── labels
+  |   │   │   │   ├── labels_mask
+  |   │   │   │   ├── panoptic
+  |   │   │   │   └── polygons
+```
+
+### Training commands
+
+```bash
+# Dataset train commands
+# at `mmsegmentation` folder
+bash tools/dist_train.sh projects/mapillary_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_mapillay_v1-512x1024.py 4
+```
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+
+  - [x] Basic docstrings & proper citation
+
+  - [ ] Test-time correctness
+
+  - [x] A full README
+
+- [x] Milestone 2: Indicates a successful model implementation.
+
+  - [x] Training-time correctness
+
+- [x] Milestone 3: Good to be a part of our core package!
+
+  - [x] Type hints and docstrings
+
+  - [x] Unit tests
+
+  - [x] Code polishing
+
+  - [x] Metafile.yml
+
+- [x] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [x] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v1.py b/mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v1.py
new file mode 100644
index 0000000..611aa47
--- /dev/null
+++ b/mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v1.py
@@ -0,0 +1,68 @@
+# dataset settings
+dataset_type = 'MapillaryDataset_v1'
+data_root = 'data/mapillary/'
+crop_size = (512, 1024)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=(2048, 1024),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', file_client_args=dict(backend='disk')),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='training/images', seg_map_path='training/v1.2/labels'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='validation/images',
+            seg_map_path='validation/v1.2/labels'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v1_65.py b/mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v1_65.py
new file mode 100644
index 0000000..f594f37
--- /dev/null
+++ b/mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v1_65.py
@@ -0,0 +1,37 @@
+# dataset settings
+_base_ = './mapillary_v1.py'
+metainfo = dict(
+    classes=('Bird', 'Ground Animal', 'Curb', 'Fence', 'Guard Rail', 'Barrier',
+             'Wall', 'Bike Lane', 'Crosswalk - Plain', 'Curb Cut', 'Parking',
+             'Pedestrian Area', 'Rail Track', 'Road', 'Service Lane',
+             'Sidewalk', 'Bridge', 'Building', 'Tunnel', 'Person', 'Bicyclist',
+             'Motorcyclist', 'Other Rider', 'Lane Marking - Crosswalk',
+             'Lane Marking - General', 'Mountain', 'Sand', 'Sky', 'Snow',
+             'Terrain', 'Vegetation', 'Water', 'Banner', 'Bench', 'Bike Rack',
+             'Billboard', 'Catch Basin', 'CCTV Camera', 'Fire Hydrant',
+             'Junction Box', 'Mailbox', 'Manhole', 'Phone Booth', 'Pothole',
+             'Street Light', 'Pole', 'Traffic Sign Frame', 'Utility Pole',
+             'Traffic Light', 'Traffic Sign (Back)', 'Traffic Sign (Front)',
+             'Trash Can', 'Bicycle', 'Boat', 'Bus', 'Car', 'Caravan',
+             'Motorcycle', 'On Rails', 'Other Vehicle', 'Trailer', 'Truck',
+             'Wheeled Slow', 'Car Mount', 'Ego Vehicle'),
+    palette=[[165, 42, 42], [0, 192, 0], [196, 196, 196], [190, 153, 153],
+             [180, 165, 180], [90, 120, 150], [102, 102, 156], [128, 64, 255],
+             [140, 140, 200], [170, 170, 170], [250, 170, 160], [96, 96, 96],
+             [230, 150, 140], [128, 64, 128], [110, 110, 110], [244, 35, 232],
+             [150, 100, 100], [70, 70, 70], [150, 120, 90], [220, 20, 60],
+             [255, 0, 0], [255, 0, 100], [255, 0, 200], [200, 128, 128],
+             [255, 255, 255], [64, 170, 64], [230, 160, 50], [70, 130, 180],
+             [190, 255, 255], [152, 251, 152], [107, 142, 35], [0, 170, 30],
+             [255, 255, 128], [250, 0, 30], [100, 140, 180], [220, 220, 220],
+             [220, 128, 128], [222, 40, 40], [100, 170, 30], [40, 40, 40],
+             [33, 33, 33], [100, 128, 160], [142, 0, 0], [70, 100, 150],
+             [210, 170, 100], [153, 153, 153], [128, 128, 128], [0, 0, 80],
+             [250, 170, 30], [192, 192, 192], [220, 220, 0], [140, 140, 20],
+             [119, 11, 32], [150, 0, 255], [0, 60, 100], [0, 0, 142],
+             [0, 0, 90], [0, 0, 230], [0, 80, 100], [128, 64, 64], [0, 0, 110],
+             [0, 0, 70], [0, 0, 192], [32, 32, 32], [120, 10, 10]])
+
+train_dataloader = dict(dataset=dict(metainfo=metainfo))
+val_dataloader = dict(dataset=dict(metainfo=metainfo))
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v2.py b/mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v2.py
new file mode 100644
index 0000000..7cb7a95
--- /dev/null
+++ b/mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v2.py
@@ -0,0 +1,68 @@
+# dataset settings
+dataset_type = 'MapillaryDataset_v2'
+data_root = 'data/mapillary/'
+crop_size = (512, 1024)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        type='RandomResize',
+        scale=(2048, 1024),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', file_client_args=dict(backend='disk')),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='training/images', seg_map_path='training/v2.0/labels'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='validation/images',
+            seg_map_path='validation/v2.0/labels'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/projects/mapillary_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_mapillay_v1-512x1024.py b/mmsegmentation/projects/mapillary_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_mapillay_v1-512x1024.py
new file mode 100644
index 0000000..b559e0d
--- /dev/null
+++ b/mmsegmentation/projects/mapillary_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_mapillay_v1-512x1024.py
@@ -0,0 +1,17 @@
+_base_ = [
+    '../../../configs/_base_/models/deeplabv3plus_r50-d8.py',
+    './_base_/datasets/mapillary_v1.py',
+    '../../../configs/_base_/default_runtime.py',
+    '../../../configs/_base_/schedules/schedule_240k.py'
+]
+custom_imports = dict(
+    imports=['projects.mapillary_dataset.mmseg.datasets.mapillary'])
+
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet101_v1c',
+    backbone=dict(depth=101),
+    decode_head=dict(num_classes=66),
+    auxiliary_head=dict(num_classes=66))
diff --git a/mmsegmentation/projects/mapillary_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_mapillay_v2-512x1024.py b/mmsegmentation/projects/mapillary_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_mapillay_v2-512x1024.py
new file mode 100644
index 0000000..cfe31a2
--- /dev/null
+++ b/mmsegmentation/projects/mapillary_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_mapillay_v2-512x1024.py
@@ -0,0 +1,16 @@
+_base_ = [
+    '../../../configs/_base_/models/deeplabv3plus_r50-d8.py',
+    './_base_/datasets/mapillary_v2.py',
+    '../../../configs/_base_/default_runtime.py',
+    '../../../configs/_base_/schedules/schedule_240k.py'
+]
+custom_imports = dict(
+    imports=['projects.mapillary_dataset.mmseg.datasets.mapillary'])
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet101_v1c',
+    backbone=dict(depth=101),
+    decode_head=dict(num_classes=124),
+    auxiliary_head=dict(num_classes=124))
diff --git a/mmsegmentation/projects/mapillary_dataset/configs/pspnet_r101-d8_4xb2-240k_mapillay_v1-512x1024.py b/mmsegmentation/projects/mapillary_dataset/configs/pspnet_r101-d8_4xb2-240k_mapillay_v1-512x1024.py
new file mode 100644
index 0000000..1ca2b57
--- /dev/null
+++ b/mmsegmentation/projects/mapillary_dataset/configs/pspnet_r101-d8_4xb2-240k_mapillay_v1-512x1024.py
@@ -0,0 +1,16 @@
+_base_ = [
+    '../../../configs/_base_/models/pspnet_r50-d8.py',
+    './_base_/datasets/mapillary_v1.py',
+    '../../../configs/_base_/default_runtime.py',
+    '../../../configs/_base_/schedules/schedule_240k.py'
+]
+custom_imports = dict(
+    imports=['projects.mapillary_dataset.mmseg.datasets.mapillary'])
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet101_v1c',
+    backbone=dict(depth=101),
+    decode_head=dict(num_classes=66),
+    auxiliary_head=dict(num_classes=66))
diff --git a/mmsegmentation/projects/mapillary_dataset/configs/pspnet_r101-d8_4xb2-240k_mapillay_v2-512x1024.py b/mmsegmentation/projects/mapillary_dataset/configs/pspnet_r101-d8_4xb2-240k_mapillay_v2-512x1024.py
new file mode 100644
index 0000000..c04746a
--- /dev/null
+++ b/mmsegmentation/projects/mapillary_dataset/configs/pspnet_r101-d8_4xb2-240k_mapillay_v2-512x1024.py
@@ -0,0 +1,16 @@
+_base_ = [
+    '../../../configs/_base_/models/pspnet_r50-d8.py',
+    './_base_/datasets/mapillary_v2.py',
+    '../../../configs/_base_/default_runtime.py',
+    '../../../configs/_base_/schedules/schedule_240k.py'
+]
+custom_imports = dict(
+    imports=['projects.mapillary_dataset.mmseg.datasets.mapillary'])
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet101_v1c',
+    backbone=dict(depth=101),
+    decode_head=dict(num_classes=124),
+    auxiliary_head=dict(num_classes=124))
diff --git a/mmsegmentation/projects/mapillary_dataset/docs/en/user_guides/2_dataset_prepare.md b/mmsegmentation/projects/mapillary_dataset/docs/en/user_guides/2_dataset_prepare.md
new file mode 100644
index 0000000..c5cbc0f
--- /dev/null
+++ b/mmsegmentation/projects/mapillary_dataset/docs/en/user_guides/2_dataset_prepare.md
@@ -0,0 +1,255 @@
+## Mapillary Vistas Datasets
+
+- The dataset could be download [here](https://www.mapillary.com/dataset/vistas) after registration.
+
+- Mapillary Vistas Dataset use 8-bit with color-palette to store labels. No conversion operation is required.
+
+- Assumption you have put the dataset zip file in `mmsegmentation/data/mapillary`
+
+- Please run the following commands to unzip dataset.
+
+  ```bash
+  cd data/mapillary
+  unzip An-ZjB1Zm61yAZG0ozTymz8I8NqI4x0MrYrh26dq7kPgfu8vf9ImrdaOAVOFYbJ2pNAgUnVGBmbue9lTgdBOb5BbKXIpFs0fpYWqACbrQDChAA2fdX0zS9PcHu7fY8c-FOvyBVxPNYNFQuM.zip
+  ```
+
+- After unzip, you will get Mapillary Vistas Dataset like this structure. Semantic segmentation mask labels in `labels` folder.
+
+  ```none
+  mmsegmentation
+  ├── mmseg
+  ├── tools
+  ├── configs
+  ├── data
+  │   ├── mapillary
+  │   │   ├── training
+  │   │   │   ├── images
+  │   │   │   ├── v1.2
+  |   │   │   │   ├── instances
+  |   │   │   │   ├── labels
+  |   │   │   │   └── panoptic
+  │   │   │   ├── v2.0
+  |   │   │   │   ├── instances
+  |   │   │   │   ├── labels
+  |   │   │   │   ├── panoptic
+  |   │   │   │   └── polygons
+  │   │   ├── validation
+  │   │   │   ├── images
+  |   │   │   ├── v1.2
+  |   │   │   │   ├── instances
+  |   │   │   │   ├── labels
+  |   │   │   │   └── panoptic
+  │   │   │   ├── v2.0
+  |   │   │   │   ├── instances
+  |   │   │   │   ├── labels
+  |   │   │   │   ├── panoptic
+  |   │   │   │   └── polygons
+  ```
+
+- You could set Datasets version with `MapillaryDataset_v1` and `MapillaryDataset_v2` in your configs.
+  View the Mapillary Vistas Datasets config file here [V1.2](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/_base_/datasets/mapillary_v1.py) and  [V2.0](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/_base_/datasets/mapillary_v2.py)
+
+- **View datasets labels index and palette**
+
+- **Mapillary Vistas Datasets labels information**
+  **v1.2 information**
+
+  ```none
+  There are 66 labels classes in v1.2
+  0--Bird--[165, 42, 42],
+  1--Ground Animal--[0, 192, 0],
+  2--Curb--[196, 196, 196],
+  3--Fence--[190, 153, 153],
+  4--Guard Rail--[180, 165, 180],
+  5--Barrier--[90, 120, 150],
+  6--Wall--[102, 102, 156],
+  7--Bike Lane--[128, 64, 255],
+  8--Crosswalk - Plain--[140, 140, 200],
+  9--Curb Cut--[170, 170, 170],
+  10--Parking--[250, 170, 160],
+  11--Pedestrian Area--[96, 96, 96],
+  12--Rail Track--[230, 150, 140],
+  13--Road--[128, 64, 128],
+  14--Service Lane--[110, 110, 110],
+  15--Sidewalk--[244, 35, 232],
+  16--Bridge--[150, 100, 100],
+  17--Building--[70, 70, 70],
+  18--Tunnel--[150, 120, 90],
+  19--Person--[220, 20, 60],
+  20--Bicyclist--[255, 0, 0],
+  21--Motorcyclist--[255, 0, 100],
+  22--Other Rider--[255, 0, 200],
+  23--Lane Marking - Crosswalk--[200, 128, 128],
+  24--Lane Marking - General--[255, 255, 255],
+  25--Mountain--[64, 170, 64],
+  26--Sand--[230, 160, 50],
+  27--Sky--[70, 130, 180],
+  28--Snow--[190, 255, 255],
+  29--Terrain--[152, 251, 152],
+  30--Vegetation--[107, 142, 35],
+  31--Water--[0, 170, 30],
+  32--Banner--[255, 255, 128],
+  33--Bench--[250, 0, 30],
+  34--Bike Rack--[100, 140, 180],
+  35--Billboard--[220, 220, 220],
+  36--Catch Basin--[220, 128, 128],
+  37--CCTV Camera--[222, 40, 40],
+  38--Fire Hydrant--[100, 170, 30],
+  39--Junction Box--[40, 40, 40],
+  40--Mailbox--[33, 33, 33],
+  41--Manhole--[100, 128, 160],
+  42--Phone Booth--[142, 0, 0],
+  43--Pothole--[70, 100, 150],
+  44--Street Light--[210, 170, 100],
+  45--Pole--[153, 153, 153],
+  46--Traffic Sign Frame--[128, 128, 128],
+  47--Utility Pole--[0, 0, 80],
+  48--Traffic Light--[250, 170, 30],
+  49--Traffic Sign (Back)--[192, 192, 192],
+  50--Traffic Sign (Front)--[220, 220, 0],
+  51--Trash Can--[140, 140, 20],
+  52--Bicycle--[119, 11, 32],
+  53--Boat--[150, 0, 255],
+  54--Bus--[0, 60, 100],
+  55--Car--[0, 0, 142],
+  56--Caravan--[0, 0, 90],
+  57--Motorcycle--[0, 0, 230],
+  58--On Rails--[0, 80, 100],
+  59--Other Vehicle--[128, 64, 64],
+  60--Trailer--[0, 0, 110],
+  61--Truck--[0, 0, 70],
+  62--Wheeled Slow--[0, 0, 192],
+  63--Car Mount--[32, 32, 32],
+  64--Ego Vehicle--[120, 10, 10],
+  65--Unlabeled--[0, 0, 0]
+  ```
+
+  **v2.0 information**
+
+  ```none
+  There are 124 labels classes in v2.0
+  0--Bird--[165, 42, 42],
+  1--Ground Animal--[0, 192, 0],
+  2--Ambiguous Barrier--[250, 170, 31],
+  3--Concrete Block--[250, 170, 32],
+  4--Curb--[196, 196, 196],
+  5--Fence--[190, 153, 153],
+  6--Guard Rail--[180, 165, 180],
+  7--Barrier--[90, 120, 150],
+  8--Road Median--[250, 170, 33],
+  9--Road Side--[250, 170, 34],
+  10--Lane Separator--[128, 128, 128],
+  11--Temporary Barrier--[250, 170, 35],
+  12--Wall--[102, 102, 156],
+  13--Bike Lane--[128, 64, 255],
+  14--Crosswalk - Plain--[140, 140, 200],
+  15--Curb Cut--[170, 170, 170],
+  16--Driveway--[250, 170, 36],
+  17--Parking--[250, 170, 160],
+  18--Parking Aisle--[250, 170, 37],
+  19--Pedestrian Area--[96, 96, 96],
+  20--Rail Track--[230, 150, 140],
+  21--Road--[128, 64, 128],
+  22--Road Shoulder--[110, 110, 110],
+  23--Service Lane--[110, 110, 110],
+  24--Sidewalk--[244, 35, 232],
+  25--Traffic Island--[128, 196, 128],
+  26--Bridge--[150, 100, 100],
+  27--Building--[70, 70, 70],
+  28--Garage--[150, 150, 150],
+  29--Tunnel--[150, 120, 90],
+  30--Person--[220, 20, 60],
+  31--Person Group--[220, 20, 60],
+  32--Bicyclist--[255, 0, 0],
+  33--Motorcyclist--[255, 0, 100],
+  34--Other Rider--[255, 0, 200],
+  35--Lane Marking - Dashed Line--[255, 255, 255],
+  36--Lane Marking - Straight Line--[255, 255, 255],
+  37--Lane Marking - Zigzag Line--[250, 170, 29],
+  38--Lane Marking - Ambiguous--[250, 170, 28],
+  39--Lane Marking - Arrow (Left)--[250, 170, 26],
+  40--Lane Marking - Arrow (Other)--[250, 170, 25],
+  41--Lane Marking - Arrow (Right)--[250, 170, 24],
+  42--Lane Marking - Arrow (Split Left or Straight)--[250, 170, 22],
+  43--Lane Marking - Arrow (Split Right or Straight)--[250, 170, 21],
+  44--Lane Marking - Arrow (Straight)--[250, 170, 20],
+  45--Lane Marking - Crosswalk--[255, 255, 255],
+  46--Lane Marking - Give Way (Row)--[250, 170, 19],
+  47--Lane Marking - Give Way (Single)--[250, 170, 18],
+  48--Lane Marking - Hatched (Chevron)--[250, 170, 12],
+  49--Lane Marking - Hatched (Diagonal)--[250, 170, 11],
+  50--Lane Marking - Other--[255, 255, 255],
+  51--Lane Marking - Stop Line--[255, 255, 255],
+  52--Lane Marking - Symbol (Bicycle)--[250, 170, 16],
+  53--Lane Marking - Symbol (Other)--[250, 170, 15],
+  54--Lane Marking - Text--[250, 170, 15],
+  55--Lane Marking (only) - Dashed Line--[255, 255, 255],
+  56--Lane Marking (only) - Crosswalk--[255, 255, 255],
+  57--Lane Marking (only) - Other--[255, 255, 255],
+  58--Lane Marking (only) - Test--[255, 255, 255],
+  59--Mountain--[64, 170, 64],
+  60--Sand--[230, 160, 50],
+  61--Sky--[70, 130, 180],
+  62--Snow--[190, 255, 255],
+  63--Terrain--[152, 251, 152],
+  64--Vegetation--[107, 142, 35],
+  65--Water--[0, 170, 30],
+  66--Banner--[255, 255, 128],
+  67--Bench--[250, 0, 30],
+  68--Bike Rack--[100, 140, 180],
+  69--Catch Basin--[220, 128, 128],
+  70--CCTV Camera--[222, 40, 40],
+  71--Fire Hydrant--[100, 170, 30],
+  72--Junction Box--[40, 40, 40],
+  73--Mailbox--[33, 33, 33],
+  74--Manhole--[100, 128, 160],
+  75--Parking Meter--[20, 20, 255],
+  76--Phone Booth--[142, 0, 0],
+  77--Pothole--[70, 100, 150],
+  78--Signage - Advertisement--[250, 171, 30],
+  79--Signage - Ambiguous--[250, 172, 30],
+  80--Signage - Back--[250, 173, 30],
+  81--Signage - Information--[250, 174, 30],
+  82--Signage - Other--[250, 175, 30],
+  83--Signage - Store--[250, 176, 30],
+  84--Street Light--[210, 170, 100],
+  85--Pole--[153, 153, 153],
+  86--Pole Group--[153, 153, 153],
+  87--Traffic Sign Frame--[128, 128, 128],
+  88--Utility Pole--[0, 0, 80],
+  89--Traffic Cone--[210, 60, 60],
+  90--Traffic Light - General (Single)--[250, 170, 30],
+  91--Traffic Light - Pedestrians--[250, 170, 30],
+  92--Traffic Light - General (Upright)--[250, 170, 30],
+  93--Traffic Light - General (Horizontal)--[250, 170, 30],
+  94--Traffic Light - Cyclists--[250, 170, 30],
+  95--Traffic Light - Other--[250, 170, 30],
+  96--Traffic Sign - Ambiguous--[192, 192, 192],
+  97--Traffic Sign (Back)--[192, 192, 192],
+  98--Traffic Sign - Direction (Back)--[192, 192, 192],
+  99--Traffic Sign - Direction (Front)--[220, 220, 0],
+  100--Traffic Sign (Front)--[220, 220, 0],
+  101--Traffic Sign - Parking--[0, 0, 196],
+  102--Traffic Sign - Temporary (Back)--[192, 192, 192],
+  103--Traffic Sign - Temporary (Front)--[220, 220, 0],
+  104--Trash Can--[140, 140, 20],
+  105--Bicycle--[119, 11, 32],
+  106--Boat--[150, 0, 255],
+  107--Bus--[0, 60, 100],
+  108--Car--[0, 0, 142],
+  109--Caravan--[0, 0, 90],
+  110--Motorcycle--[0, 0, 230],
+  111--On Rails--[0, 80, 100],
+  112--Other Vehicle--[128, 64, 64],
+  113--Trailer--[0, 0, 110],
+  114--Truck--[0, 0, 70],
+  115--Vehicle Group--[0, 0, 142],
+  116--Wheeled Slow--[0, 0, 192],
+  117--Water Valve--[170, 170, 170],
+  118--Car Mount--[32, 32, 32],
+  119--Dynamic--[111, 74, 0],
+  120--Ego Vehicle--[120, 10, 10],
+  121--Ground--[81, 0, 81],
+  122--Static--[111, 111, 0],
+  123--Unlabeled--[0, 0, 0]
+  ```
diff --git a/mmsegmentation/projects/mapillary_dataset/mmseg/datasets/mapillary.py b/mmsegmentation/projects/mapillary_dataset/mmseg/datasets/mapillary.py
new file mode 100644
index 0000000..f49bd54
--- /dev/null
+++ b/mmsegmentation/projects/mapillary_dataset/mmseg/datasets/mapillary.py
@@ -0,0 +1,177 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmseg.datasets.basesegdataset import BaseSegDataset
+
+# from mmseg.registry import DATASETS
+
+
+# @DATASETS.register_module()
+class MapillaryDataset_v1(BaseSegDataset):
+    """Mapillary Vistas Dataset.
+
+    Dataset paper link:
+    http://ieeexplore.ieee.org/document/8237796/
+
+    v1.2 contain 66 object classes.
+    (37 instance-specific)
+
+    v2.0 contain 124 object classes.
+    (70 instance-specific, 46 stuff, 8 void or crowd).
+
+    The ``img_suffix`` is fixed to '.jpg' and ``seg_map_suffix`` is
+    fixed to '.png' for Mapillary Vistas Dataset.
+    """
+    METAINFO = dict(
+        classes=('Bird', 'Ground Animal', 'Curb', 'Fence', 'Guard Rail',
+                 'Barrier', 'Wall', 'Bike Lane', 'Crosswalk - Plain',
+                 'Curb Cut', 'Parking', 'Pedestrian Area', 'Rail Track',
+                 'Road', 'Service Lane', 'Sidewalk', 'Bridge', 'Building',
+                 'Tunnel', 'Person', 'Bicyclist', 'Motorcyclist',
+                 'Other Rider', 'Lane Marking - Crosswalk',
+                 'Lane Marking - General', 'Mountain', 'Sand', 'Sky', 'Snow',
+                 'Terrain', 'Vegetation', 'Water', 'Banner', 'Bench',
+                 'Bike Rack', 'Billboard', 'Catch Basin', 'CCTV Camera',
+                 'Fire Hydrant', 'Junction Box', 'Mailbox', 'Manhole',
+                 'Phone Booth', 'Pothole', 'Street Light', 'Pole',
+                 'Traffic Sign Frame', 'Utility Pole', 'Traffic Light',
+                 'Traffic Sign (Back)', 'Traffic Sign (Front)', 'Trash Can',
+                 'Bicycle', 'Boat', 'Bus', 'Car', 'Caravan', 'Motorcycle',
+                 'On Rails', 'Other Vehicle', 'Trailer', 'Truck',
+                 'Wheeled Slow', 'Car Mount', 'Ego Vehicle', 'Unlabeled'),
+        palette=[[165, 42, 42], [0, 192, 0], [196, 196, 196], [190, 153, 153],
+                 [180, 165, 180], [90, 120, 150], [102, 102, 156],
+                 [128, 64, 255], [140, 140, 200], [170, 170, 170],
+                 [250, 170, 160], [96, 96, 96],
+                 [230, 150, 140], [128, 64, 128], [110, 110, 110],
+                 [244, 35, 232], [150, 100, 100], [70, 70, 70], [150, 120, 90],
+                 [220, 20, 60], [255, 0, 0], [255, 0, 100], [255, 0, 200],
+                 [200, 128, 128], [255, 255, 255], [64, 170,
+                                                    64], [230, 160, 50],
+                 [70, 130, 180], [190, 255, 255], [152, 251, 152],
+                 [107, 142, 35], [0, 170, 30], [255, 255, 128], [250, 0, 30],
+                 [100, 140, 180], [220, 220, 220], [220, 128, 128],
+                 [222, 40, 40], [100, 170, 30], [40, 40, 40], [33, 33, 33],
+                 [100, 128, 160], [142, 0, 0], [70, 100, 150], [210, 170, 100],
+                 [153, 153, 153], [128, 128, 128], [0, 0, 80], [250, 170, 30],
+                 [192, 192, 192], [220, 220, 0], [140, 140, 20], [119, 11, 32],
+                 [150, 0, 255], [0, 60, 100], [0, 0, 142], [0, 0, 90],
+                 [0, 0, 230], [0, 80, 100], [128, 64, 64], [0, 0, 110],
+                 [0, 0, 70], [0, 0, 192], [32, 32, 32], [120, 10,
+                                                         10], [0, 0, 0]])
+
+    def __init__(self,
+                 img_suffix='.jpg',
+                 seg_map_suffix='.png',
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
+
+
+# @DATASETS.register_module()
+class MapillaryDataset_v2(BaseSegDataset):
+    """Mapillary Vistas Dataset.
+
+    Dataset paper link:
+    http://ieeexplore.ieee.org/document/8237796/
+
+    v1.2 contain 66 object classes.
+    (37 instance-specific)
+
+    v2.0 contain 124 object classes.
+    (70 instance-specific, 46 stuff, 8 void or crowd).
+
+    The ``img_suffix`` is fixed to '.jpg' and ``seg_map_suffix`` is
+    fixed to '.png' for Mapillary Vistas Dataset.
+    """
+    METAINFO = dict(
+        classes=(
+            'Bird', 'Ground Animal', 'Ambiguous Barrier', 'Concrete Block',
+            'Curb', 'Fence', 'Guard Rail', 'Barrier', 'Road Median',
+            'Road Side', 'Lane Separator', 'Temporary Barrier', 'Wall',
+            'Bike Lane', 'Crosswalk - Plain', 'Curb Cut', 'Driveway',
+            'Parking', 'Parking Aisle', 'Pedestrian Area', 'Rail Track',
+            'Road', 'Road Shoulder', 'Service Lane', 'Sidewalk',
+            'Traffic Island', 'Bridge', 'Building', 'Garage', 'Tunnel',
+            'Person', 'Person Group', 'Bicyclist', 'Motorcyclist',
+            'Other Rider', 'Lane Marking - Dashed Line',
+            'Lane Marking - Straight Line', 'Lane Marking - Zigzag Line',
+            'Lane Marking - Ambiguous', 'Lane Marking - Arrow (Left)',
+            'Lane Marking - Arrow (Other)', 'Lane Marking - Arrow (Right)',
+            'Lane Marking - Arrow (Split Left or Straight)',
+            'Lane Marking - Arrow (Split Right or Straight)',
+            'Lane Marking - Arrow (Straight)', 'Lane Marking - Crosswalk',
+            'Lane Marking - Give Way (Row)',
+            'Lane Marking - Give Way (Single)',
+            'Lane Marking - Hatched (Chevron)',
+            'Lane Marking - Hatched (Diagonal)', 'Lane Marking - Other',
+            'Lane Marking - Stop Line', 'Lane Marking - Symbol (Bicycle)',
+            'Lane Marking - Symbol (Other)', 'Lane Marking - Text',
+            'Lane Marking (only) - Dashed Line',
+            'Lane Marking (only) - Crosswalk', 'Lane Marking (only) - Other',
+            'Lane Marking (only) - Test', 'Mountain', 'Sand', 'Sky', 'Snow',
+            'Terrain', 'Vegetation', 'Water', 'Banner', 'Bench', 'Bike Rack',
+            'Catch Basin', 'CCTV Camera', 'Fire Hydrant', 'Junction Box',
+            'Mailbox', 'Manhole', 'Parking Meter', 'Phone Booth', 'Pothole',
+            'Signage - Advertisement', 'Signage - Ambiguous', 'Signage - Back',
+            'Signage - Information', 'Signage - Other', 'Signage - Store',
+            'Street Light', 'Pole', 'Pole Group', 'Traffic Sign Frame',
+            'Utility Pole', 'Traffic Cone', 'Traffic Light - General (Single)',
+            'Traffic Light - Pedestrians', 'Traffic Light - General (Upright)',
+            'Traffic Light - General (Horizontal)', 'Traffic Light - Cyclists',
+            'Traffic Light - Other', 'Traffic Sign - Ambiguous',
+            'Traffic Sign (Back)', 'Traffic Sign - Direction (Back)',
+            'Traffic Sign - Direction (Front)', 'Traffic Sign (Front)',
+            'Traffic Sign - Parking', 'Traffic Sign - Temporary (Back)',
+            'Traffic Sign - Temporary (Front)', 'Trash Can', 'Bicycle', 'Boat',
+            'Bus', 'Car', 'Caravan', 'Motorcycle', 'On Rails', 'Other Vehicle',
+            'Trailer', 'Truck', 'Vehicle Group', 'Wheeled Slow', 'Water Valve',
+            'Car Mount', 'Dynamic', 'Ego Vehicle', 'Ground', 'Static',
+            'Unlabeled'),
+        palette=[[165, 42, 42], [0, 192, 0], [250, 170, 31], [250, 170, 32],
+                 [196, 196, 196], [190, 153, 153], [180, 165, 180],
+                 [90, 120, 150], [250, 170, 33], [250, 170, 34],
+                 [128, 128, 128], [250, 170, 35], [102, 102, 156],
+                 [128, 64, 255], [140, 140, 200], [170, 170, 170],
+                 [250, 170, 36], [250, 170, 160], [250, 170, 37], [96, 96, 96],
+                 [230, 150, 140], [128, 64, 128], [110, 110, 110],
+                 [110, 110, 110], [244, 35, 232], [128, 196,
+                                                   128], [150, 100, 100],
+                 [70, 70, 70], [150, 150, 150], [150, 120, 90], [220, 20, 60],
+                 [220, 20, 60], [255, 0, 0], [255, 0, 100], [255, 0, 200],
+                 [255, 255, 255], [255, 255, 255], [250, 170, 29],
+                 [250, 170, 28], [250, 170, 26], [250, 170,
+                                                  25], [250, 170, 24],
+                 [250, 170, 22], [250, 170, 21], [250, 170,
+                                                  20], [255, 255, 255],
+                 [250, 170, 19], [250, 170, 18], [250, 170,
+                                                  12], [250, 170, 11],
+                 [255, 255, 255], [255, 255, 255], [250, 170, 16],
+                 [250, 170, 15], [250, 170, 15], [255, 255, 255],
+                 [255, 255, 255], [255, 255, 255], [255, 255, 255],
+                 [64, 170, 64], [230, 160, 50],
+                 [70, 130, 180], [190, 255, 255], [152, 251, 152],
+                 [107, 142, 35], [0, 170, 30], [255, 255, 128], [250, 0, 30],
+                 [100, 140, 180], [220, 128, 128], [222, 40,
+                                                    40], [100, 170, 30],
+                 [40, 40, 40], [33, 33, 33], [100, 128, 160], [20, 20, 255],
+                 [142, 0, 0], [70, 100, 150], [250, 171, 30], [250, 172, 30],
+                 [250, 173, 30], [250, 174, 30], [250, 175,
+                                                  30], [250, 176, 30],
+                 [210, 170, 100], [153, 153, 153], [153, 153, 153],
+                 [128, 128, 128], [0, 0, 80], [210, 60, 60], [250, 170, 30],
+                 [250, 170, 30], [250, 170, 30], [250, 170,
+                                                  30], [250, 170, 30],
+                 [250, 170, 30], [192, 192, 192], [192, 192, 192],
+                 [192, 192, 192], [220, 220, 0], [220, 220, 0], [0, 0, 196],
+                 [192, 192, 192], [220, 220, 0], [140, 140, 20], [119, 11, 32],
+                 [150, 0, 255], [0, 60, 100], [0, 0, 142], [0, 0, 90],
+                 [0, 0, 230], [0, 80, 100], [128, 64, 64], [0, 0, 110],
+                 [0, 0, 70], [0, 0, 142], [0, 0, 192], [170, 170, 170],
+                 [32, 32, 32], [111, 74, 0], [120, 10, 10], [81, 0, 81],
+                 [111, 111, 0], [0, 0, 0]])
+
+    def __init__(self,
+                 img_suffix='.jpg',
+                 seg_map_suffix='.png',
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/ct/cranium/README.md b/mmsegmentation/projects/medical/2d_image/ct/cranium/README.md
new file mode 100644
index 0000000..d3fa64e
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/ct/cranium/README.md
@@ -0,0 +1,142 @@
+# Brain CT Images with Intracranial Hemorrhage Masks (Cranium)
+
+## Description
+
+This project supports **`Brain CT Images with Intracranial Hemorrhage Masks (Cranium)`**, which can be downloaded from [here](https://www.kaggle.com/datasets/vbookshelf/computed-tomography-ct-images).
+
+### Dataset Overview
+
+This dataset consists of head CT (Computed Thomography) images in jpg format. There are 2500 brain window images and 2500 bone window images, for 82 patients. There are approximately 30 image slices per patient. 318 images have associated intracranial image masks. Also included are csv files containing hemorrhage diagnosis data and patient data.
+This is version 1.0.0 of this dataset. A full description of this dataset as well as updated versions can be found here:
+https://physionet.org/content/ct-ich/1.0.0/
+
+### Statistic Information
+
+| Dataset Name                                                                        | Anatomical Region | Task Type    | Modality | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                   |
+| ----------------------------------------------------------------------------------- | ----------------- | ------------ | -------- | ------------ | --------------------- | ---------------------- | ------------ | --------------------------------------------------------- |
+| [Cranium](https://www.kaggle.com/datasets/vbookshelf/computed-tomography-ct-images) | head_and_neck     | segmentation | ct       | 2            | 2501/-/-              | yes/-/-                | 2020         | [CC-BY 4.0](https://creativecommons.org/licenses/by/4.0/) |
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |    2501    |   99.93    |    -     |    -     |     -     |     -     |
+| hemorrhage |    318     |    0.07    |    -     |    -     |     -     |     -     |
+
+Note:
+
+- `Pct` means percentage of pixels in this category in all pixels.
+
+### Visualization
+
+![cranium](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/ct/cranium/cranium_dataset.png?raw=true)
+
+## Dataset Citation
+
+```
+@article{hssayeni2020computed,
+	title={Computed tomography images for intracranial hemorrhage detection and segmentation},
+	author={Hssayeni, Murtadha and Croock, MS and Salman, AD and Al-khafaji, HF and Yahya, ZA and Ghoraani, B},
+	journal={Intracranial Hemorrhage Segmentation Using A Deep Convolutional Model. Data},
+	volume={5},
+	number={1},
+	pages={179},
+	year={2020}
+}
+```
+
+### Prerequisites
+
+- Python v3.8
+- PyTorch v1.10.0
+- pillow(PIL) v9.3.0 9.3.0
+- scikit-learn(sklearn) v1.2.0 1.2.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+
+All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `cranium/` root directory, run the following line to add the current directory to `PYTHONPATH`:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset Preparing
+
+- download dataset from [here](https://www.kaggle.com/datasets/vbookshelf/computed-tomography-ct-images) and decompress data to path `'data/'`.
+- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
+- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set cannot be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── ct
+  │   │   │   │   ├── cranium
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── train.txt
+  │   │   │   │   │   │   ├── val.txt
+  │   │   │   │   │   │   ├── images
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   ├── masks
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+```
+
+### Divided Dataset Information
+
+***Note: The table information below is divided by ourselves.***
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |    2000    |   99.93    |   501    |  99.92   |     -     |     -     |
+| hemorrhage |    260     |    0.07    |   260    |   0.08   |     -     |     -     |
+
+### Training commands
+
+To train models on a single server with one GPU. (default)
+
+```shell
+mim train mmseg ./configs/${CONFIG_FILE}
+```
+
+### Testing commands
+
+To test models on a single server with one GPU. (default)
+
+```shell
+mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+  - [x] Basic docstrings & proper citation
+  - [ ] Test-time correctness
+  - [x] A full README
+
+- [ ] Milestone 2: Indicates a successful model implementation.
+
+  - [ ] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+  - [ ] Unit tests
+  - [ ] Code polishing
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/cranium_512x512.py b/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/cranium_512x512.py
new file mode 100644
index 0000000..d9b4436
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/cranium_512x512.py
@@ -0,0 +1,42 @@
+dataset_type = 'CraniumDataset'
+data_root = 'data/'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='train.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='val.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_cranium-512x512.py b/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_cranium-512x512.py
new file mode 100644
index 0000000..ac013a2
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_cranium-512x512.py
@@ -0,0 +1,18 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './cranium_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.cranium_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(
+        num_classes=2, loss_decode=dict(use_sigmoid=True), out_channels=1),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_cranium-512x512.py b/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_cranium-512x512.py
new file mode 100644
index 0000000..c71110a
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_cranium-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './cranium_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.cranium_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_cranium-512x512.py b/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_cranium-512x512.py
new file mode 100644
index 0000000..abbdac2
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_cranium-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './cranium_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.cranium_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_cranium-512x512.py b/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_cranium-512x512.py
new file mode 100644
index 0000000..4185952
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_cranium-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './cranium_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.cranium_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/ct/cranium/datasets/cranium_dataset.py b/mmsegmentation/projects/medical/2d_image/ct/cranium/datasets/cranium_dataset.py
new file mode 100644
index 0000000..d65f1cb
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/ct/cranium/datasets/cranium_dataset.py
@@ -0,0 +1,31 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class CraniumDataset(BaseSegDataset):
+    """CraniumDataset dataset.
+
+    In segmentation map annotation for CraniumDataset,
+    0 stands for background, which is included in 2 categories.
+    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
+    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
+
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+        reduce_zero_label (bool): Whether to mark label zero as ignored.
+            Default to False.
+    """
+    METAINFO = dict(classes=('background', 'hemorrhage'))
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/ct/cranium/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/ct/cranium/tools/prepare_dataset.py
new file mode 100644
index 0000000..1aa4e43
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/ct/cranium/tools/prepare_dataset.py
@@ -0,0 +1,66 @@
+import os
+
+import numpy as np
+from PIL import Image
+
+root_path = 'data/'
+img_suffix = '.png'
+seg_map_suffix = '.png'
+save_img_suffix = '.png'
+save_seg_map_suffix = '.png'
+tgt_img_dir = os.path.join(root_path, 'images/train/')
+tgt_mask_dir = os.path.join(root_path, 'masks/train/')
+os.system('mkdir -p ' + tgt_img_dir)
+os.system('mkdir -p ' + tgt_mask_dir)
+
+
+def read_single_array_from_pil(path):
+    return np.asarray(Image.open(path))
+
+
+def save_png_from_array(arr, save_path, mode=None):
+    Image.fromarray(arr, mode=mode).save(save_path)
+
+
+def convert_label(img, convert_dict):
+    arr = np.zeros_like(img, dtype=np.uint8)
+    for c, i in convert_dict.items():
+        arr[img == c] = i
+    return arr
+
+
+patients_dir = os.path.join(
+    root_path, 'Cranium/computed-tomography-images-for-' +
+    'intracranial-hemorrhage-detection-and-segmentation-1.0.0' +
+    '/Patients_CT')
+
+patients = sorted(os.listdir(patients_dir))
+for p in patients:
+    data_dir = os.path.join(patients_dir, p, 'brain')
+    file_names = os.listdir(data_dir)
+    img_w_mask_names = [
+        _.replace('_HGE_Seg', '') for _ in file_names if 'Seg' in _
+    ]
+    img_wo_mask_names = [
+        _ for _ in file_names if _ not in img_w_mask_names and 'Seg' not in _
+    ]
+
+    for file_name in file_names:
+        path = os.path.join(data_dir, file_name)
+        img = read_single_array_from_pil(path)
+        tgt_name = file_name.replace('.jpg', img_suffix)
+        tgt_name = p + '_' + tgt_name
+        if 'Seg' in file_name:  # is a mask
+            tgt_name = tgt_name.replace('_HGE_Seg', '')
+            mask_path = os.path.join(tgt_mask_dir, tgt_name)
+            mask = convert_label(img, convert_dict={0: 0, 255: 1})
+            save_png_from_array(mask, mask_path)
+        else:
+            img_path = os.path.join(tgt_img_dir, tgt_name)
+            pil = Image.fromarray(img).convert('RGB')
+            pil.save(img_path)
+
+            if file_name in img_wo_mask_names:
+                mask = np.zeros_like(img, dtype=np.uint8)
+                mask_path = os.path.join(tgt_mask_dir, tgt_name)
+                save_png_from_array(mask, mask_path)
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/README.md b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/README.md
new file mode 100644
index 0000000..6e44e41
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/README.md
@@ -0,0 +1,149 @@
+# ISIC-2016 Task1
+
+## Description
+
+This project support **`ISIC-2016 Task1 `**, and the dataset used in this project can be downloaded from [here](https://challenge.isic-archive.com/data/#2016).
+
+### Dataset Overview
+
+The overarching goal of the challenge is to develop image analysis tools to enable the automated diagnosis of melanoma from dermoscopic images.
+
+This challenge provides training data (~900 images) for participants to engage in all 3 components of lesion image analysis. A separate test dataset (~350 images) will be provided for participants to generate and submit automated results.
+
+### Original Statistic Information
+
+| Dataset name                                                     | Anatomical region | Task type    | Modality   | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                                |
+| ---------------------------------------------------------------- | ----------------- | ------------ | ---------- | ------------ | --------------------- | ---------------------- | ------------ | ---------------------------------------------------------------------- |
+| [ISIC-2016 Task1](https://challenge.isic-archive.com/data/#2016) | full body         | segmentation | dermoscopy | 2            | 900/-/379-            | yes/-/yes              | 2016         | [CC-0](https://creativecommons.org/share-your-work/public-domain/cc0/) |
+
+| Class Name  | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :---------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background  |    900     |   82.08    |    -     |    -     |    379    |   81.98   |
+| skin lesion |    900     |   17.92    |    -     |    -     |    379    |   18.02   |
+
+Note:
+
+- `Pct` means percentage of pixels in this category in all pixels.
+
+### Visualization
+
+![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/dermoscopy/isic2016_task1/isic2016_task1.png)
+
+### Prerequisites
+
+- Python 3.8
+- PyTorch 1.10.0
+- pillow(PIL) 9.3.0
+- scikit-learn(sklearn) 1.2.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+
+All the commands below rely on the correct configuration of PYTHONPATH, which should point to the project's directory so that Python can locate the module files. In isic2016_task1/ root directory, run the following line to add the current directory to PYTHONPATH:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset preparing
+
+- download dataset from [here](https://challenge.isic-archive.com/data/#2016) and decompression data to path 'data/'.
+- run script `"python tools/prepare_dataset.py"` to split dataset and change folder structure as below.
+- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt` and `test.txt`. If the label of official validation set and test set can't be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── dermoscopy
+  │   │   │   │   ├── isic2016_task1
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── train.txt
+  │   │   │   │   │   │   ├── test.txt
+  │   │   │   │   │   │   ├── images
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   │   ├── test
+  │   │   │   │   |   │   │   │   ├── yyy.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── yyy.png
+  │   │   │   │   │   │   ├── masks
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   │   ├── test
+  │   │   │   │   |   │   │   │   ├── yyy.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── yyy.png
+```
+
+### Training commands
+
+```shell
+mim train mmseg ./configs/${CONFIG_PATH}
+```
+
+To train on multiple GPUs, e.g. 8 GPUs, run the following command:
+
+```shell
+mim train mmseg ./configs/${CONFIG_PATH}  --launcher pytorch --gpus 8
+```
+
+### Testing commands
+
+```shell
+mim test mmseg ./configs/${CONFIG_PATH}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
+
+You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
+
+## Results
+
+### ISIC-2016 Task1
+
+|     Method      | Backbone | Crop Size |   lr   | mIoU | mDice |                                                                                             config                                                                                              |
+| :-------------: | :------: | :-------: | :----: | :--: | :---: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+| fcn_unet_s5-d16 |   unet   |  512x512  |  0.01  |  -   |   -   |  [config](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_isic2016-task1-512x512.py)  |
+| fcn_unet_s5-d16 |   unet   |  512x512  | 0.001  |  -   |   -   | [config](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_isic2016-task1-512x512.py)  |
+| fcn_unet_s5-d16 |   unet   |  512x512  | 0.0001 |  -   |   -   | [config](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_isic2016-task1-512x512.py) |
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+
+  - [x] Basic docstrings & proper citation
+
+  - [x] Test-time correctness
+
+  - [x] A full README
+
+- [x] Milestone 2: Indicates a successful model implementation.
+
+  - [x] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+
+  - [ ] Unit tests
+
+  - [ ] Code polishing
+
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_isic2016-task1-512x512.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_isic2016-task1-512x512.py
new file mode 100644
index 0000000..5638de4
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_isic2016-task1-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './isic2016-task1_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.isic2016-task1_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_isic2016-task1-512x512.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_isic2016-task1-512x512.py
new file mode 100644
index 0000000..bf17faa
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_isic2016-task1-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './isic2016-task1_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.isic2016-task1_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_isic2016-task1-512x512.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_isic2016-task1-512x512.py
new file mode 100644
index 0000000..f7bfcf6
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_isic2016-task1-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './isic2016-task1_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.isic2016-task1_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/isic2016-task1_512x512.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/isic2016-task1_512x512.py
new file mode 100644
index 0000000..029f5d4
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/isic2016-task1_512x512.py
@@ -0,0 +1,42 @@
+dataset_type = 'ISIC2017Task1'
+data_root = 'data/'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='train.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='test.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/datasets/isic2016-task1_dataset.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/datasets/isic2016-task1_dataset.py
new file mode 100644
index 0000000..8f11bdd
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/datasets/isic2016-task1_dataset.py
@@ -0,0 +1,30 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class ISIC2017Task1(BaseSegDataset):
+    """ISIC2017Task1 dataset.
+
+    In segmentation map annotation for ISIC2017Task1,
+    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
+    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
+
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+        reduce_zero_label (bool): Whether to mark label zero as ignored.
+            Default to False.
+    """
+    METAINFO = dict(classes=('normal', 'skin lesion'))
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/tools/prepare_dataset.py
new file mode 100755
index 0000000..ef4dad5
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/tools/prepare_dataset.py
@@ -0,0 +1,120 @@
+import glob
+import os
+import shutil
+
+import numpy as np
+from PIL import Image
+
+
+def check_maskid(train_imgs):
+    for i in train_masks:
+        img = Image.open(i)
+        print(np.unique(np.array(img)))
+
+
+def reformulate_file(image_list, mask_list):
+    file_list = []
+    for idx, (imgp,
+              maskp) in enumerate(zip(sorted(image_list), sorted(mask_list))):
+        item = {'image': imgp, 'label': maskp}
+        file_list.append(item)
+    return file_list
+
+
+def check_file_exist(pair_list):
+    rel_path = os.getcwd()
+    for idx, sample in enumerate(pair_list):
+        image_path = sample['image']
+        assert os.path.exists(os.path.join(rel_path, image_path))
+        if 'label' in sample:
+            mask_path = sample['label']
+            assert os.path.exists(os.path.join(rel_path, mask_path))
+    print('all file path ok!')
+
+
+def convert_maskid(mask):
+    # add mask id conversion
+    arr_mask = np.array(mask).astype(np.uint8)
+    arr_mask[arr_mask == 255] = 1
+    return Image.fromarray(arr_mask)
+
+
+def process_dataset(file_lists, part_dir_dict):
+    for ith, part in enumerate(file_lists):
+        part_dir = part_dir_dict[ith]
+        for sample in part:
+            # read image and mask
+            image_path = sample['image']
+            if 'label' in sample:
+                mask_path = sample['label']
+
+            basename = os.path.basename(image_path)
+            targetname = basename.split('.')[0]  # from image name
+
+            # check image file
+            img_save_path = os.path.join(root_path, 'images', part_dir,
+                                         targetname + save_img_suffix)
+            if not os.path.exists(img_save_path):
+                if not image_path.endswith('.png'):
+                    src = Image.open(image_path)
+                    src.save(img_save_path)
+                else:
+                    shutil.copy(image_path, img_save_path)
+
+            if mask_path is not None:
+                mask_save_path = os.path.join(root_path, 'masks', part_dir,
+                                              targetname + save_seg_map_suffix)
+                if not os.path.exists(mask_save_path):
+                    # check mask file
+                    mask = Image.open(mask_path).convert('L')
+                    # convert mask id
+                    mask = convert_maskid(mask)
+                    if not mask_path.endswith('.png'):
+                        mask.save(mask_save_path)
+                    else:
+                        mask.save(mask_save_path)
+
+        # print image num
+        part_dir_folder = os.path.join(root_path, 'images', part_dir)
+        print(
+            f'{part_dir} has {len(os.listdir(part_dir_folder))} images completed!'  # noqa
+        )
+
+
+if __name__ == '__main__':
+
+    root_path = 'data/'  # original file
+    img_suffix = '.jpg'
+    seg_map_suffix = '.png'
+    save_img_suffix = '.png'
+    save_seg_map_suffix = '.png'
+
+    train_imgs = glob.glob('data/ISBI2016_ISIC_Part1_Training_Data/*'  # noqa
+                           + img_suffix)
+    train_masks = glob.glob(
+        'data/ISBI2016_ISIC_Part1_Training_GroundTruth/*'  # noqa
+        + seg_map_suffix)
+
+    test_imgs = glob.glob('data/ISBI2016_ISIC_Part1_Test_Data/*' + img_suffix)
+    test_masks = glob.glob(
+        'data/ISBI2016_ISIC_Part1_Test_GroundTruth/*'  # noqa
+        + seg_map_suffix)
+
+    assert len(train_imgs) == len(train_masks)
+    assert len(test_imgs) == len(test_masks)
+
+    print(f'training images: {len(train_imgs)}, test images: {len(test_imgs)}')
+
+    os.system('mkdir -p ' + root_path + 'images/train/')
+    os.system('mkdir -p ' + root_path + 'images/test/')
+    os.system('mkdir -p ' + root_path + 'masks/train/')
+    os.system('mkdir -p ' + root_path + 'masks/test/')
+
+    train_pair_list = reformulate_file(train_imgs, train_masks)
+    test_pair_list = reformulate_file(test_imgs, test_masks)
+
+    check_file_exist(train_pair_list)
+    check_file_exist(test_pair_list)
+
+    part_dir_dict = {0: 'train/', 1: 'test/'}
+    process_dataset([train_pair_list, test_pair_list], part_dir_dict)
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/README.md b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/README.md
new file mode 100644
index 0000000..c7cc270
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/README.md
@@ -0,0 +1,158 @@
+# ISIC-2017 Task1
+
+## Description
+
+This project support **`ISIC-2017 Task1 `**, and the dataset used in this project can be downloaded from [here](https://challenge.isic-archive.com/data/#2017).
+
+### Dataset Overview
+
+The goal of the challenge is to help participants develop image analysis tools to enable the automated diagnosis of melanoma from dermoscopic images.
+
+This challenge provides training data (~2000 images) for participants to engage in all 3 components of lesion image analysis. A separate public validation dataset (~150 images) and blind held-out test dataset (~600 images) will be provided for participants to generate and submit automated results.
+
+### Original Statistic Information
+
+| Dataset name                                                     | Anatomical region | Task type    | Modality   | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                                |
+| ---------------------------------------------------------------- | ----------------- | ------------ | ---------- | ------------ | --------------------- | ---------------------- | ------------ | ---------------------------------------------------------------------- |
+| [ISIC-2017 Task1](https://challenge.isic-archive.com/data/#2017) | full body         | segmentation | dermoscopy | 2            | 2000/150/600          | yes/yes/yes            | 2017         | [CC-0](https://creativecommons.org/share-your-work/public-domain/cc0/) |
+
+| Class Name  | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :---------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+|   normal    |    2000    |   82.86    |   150    |  73.88   |    600    |   70.62   |
+| skin lesion |    2000    |   17.14    |   150    |  26.12   |    600    |   29.38   |
+
+Note:
+
+- `Pct` means percentage of pixels in this category in all pixels.
+
+### Visualization
+
+![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/dermoscopy/isic2017_task1/isic2017_task1.png)
+
+### Prerequisites
+
+- Python 3.8
+- PyTorch 1.10.0
+- pillow(PIL) 9.3.0
+- scikit-learn(sklearn) 1.2.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+
+All the commands below rely on the correct configuration of PYTHONPATH, which should point to the project's directory so that Python can locate the module files. In isic2017_task1/ root directory, run the following line to add the current directory to PYTHONPATH:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset preparing
+
+- download dataset from [here](https://challenge.isic-archive.com/data/#2017) and decompression data to path 'data/'.
+- run script `"python tools/prepare_dataset.py"` to split dataset and change folder structure as below.
+- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt` and `test.txt`. If the label of official validation set and test set can't be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── dermoscopy
+  │   │   │   │   ├── isic2017_task1
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── train.txt
+  │   │   │   │   │   │   ├── val.txt
+  │   │   │   │   │   │   ├── test.txt
+  │   │   │   │   │   │   ├── images
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   │   ├── val
+  │   │   │   │   |   │   │   │   ├── yyy.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── yyy.png
+  │   │   │   │   │   │   │   ├── test
+  │   │   │   │   |   │   │   │   ├── yyy.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── yyy.png
+  │   │   │   │   │   │   ├── masks
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   │   ├── val
+  │   │   │   │   |   │   │   │   ├── yyy.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── yyy.png
+  │   │   │   │   │   │   │   ├── test
+  │   │   │   │   |   │   │   │   ├── yyy.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── yyy.png
+```
+
+### Training commands
+
+```shell
+mim train mmseg ./configs/${CONFIG_PATH}
+```
+
+To train on multiple GPUs, e.g. 8 GPUs, run the following command:
+
+```shell
+mim train mmseg ./configs/${CONFIG_PATH}  --launcher pytorch --gpus 8
+```
+
+### Testing commands
+
+```shell
+mim test mmseg ./configs/${CONFIG_PATH}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
+
+You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
+
+## Results
+
+### ISIC-2017 Task1
+
+|     Method      | Backbone | Crop Size |   lr   | mIoU | mDice |                                                                                             config                                                                                              |
+| :-------------: | :------: | :-------: | :----: | :--: | :---: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+| fcn_unet_s5-d16 |   unet   |  512x512  |  0.01  |  -   |   -   |  [config](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_isic2017-task1-512x512.py)  |
+| fcn_unet_s5-d16 |   unet   |  512x512  | 0.001  |  -   |   -   | [config](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_isic2017-task1-512x512.py)  |
+| fcn_unet_s5-d16 |   unet   |  512x512  | 0.0001 |  -   |   -   | [config](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_isic2017-task1-512x512.py) |
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+
+  - [x] Basic docstrings & proper citation
+
+  - [ ] Test-time correctness
+
+  - [x] A full README
+
+- [ ] Milestone 2: Indicates a successful model implementation.
+
+  - [ ] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+
+  - [ ] Unit tests
+
+  - [ ] Code polishing
+
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_isic2017-task1-512x512.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_isic2017-task1-512x512.py
new file mode 100644
index 0000000..58d0a12
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_isic2017-task1-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './isic2017-task1_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.isic2017-task1_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_isic2017-task1-512x512.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_isic2017-task1-512x512.py
new file mode 100644
index 0000000..3becacf
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_isic2017-task1-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './isic2017-task1_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.isic2017-task1_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_isic2017-task1-512x512.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_isic2017-task1-512x512.py
new file mode 100644
index 0000000..654ef4d
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_isic2017-task1-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './isic2017-task1_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.isic2017-task1_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/isic2017-task1_512x512.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/isic2017-task1_512x512.py
new file mode 100644
index 0000000..95997a1
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/isic2017-task1_512x512.py
@@ -0,0 +1,41 @@
+dataset_type = 'ISIC2017Task1'
+data_root = 'data/'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/train/', seg_map_path='masks/train/'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(img_path='images/val/', seg_map_path='masks/val/'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/datasets/isic2017-task1_dataset.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/datasets/isic2017-task1_dataset.py
new file mode 100644
index 0000000..8f11bdd
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/datasets/isic2017-task1_dataset.py
@@ -0,0 +1,30 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class ISIC2017Task1(BaseSegDataset):
+    """ISIC2017Task1 dataset.
+
+    In segmentation map annotation for ISIC2017Task1,
+    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
+    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
+
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+        reduce_zero_label (bool): Whether to mark label zero as ignored.
+            Default to False.
+    """
+    METAINFO = dict(classes=('normal', 'skin lesion'))
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/tools/prepare_dataset.py
new file mode 100755
index 0000000..b3643c9
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/tools/prepare_dataset.py
@@ -0,0 +1,127 @@
+import glob
+import os
+import shutil
+
+import numpy as np
+from PIL import Image
+
+
+def check_maskid(train_imgs):
+    for i in train_masks:
+        img = Image.open(i)
+        print(np.unique(np.array(img)))
+
+
+def reformulate_file(image_list, mask_list):
+    file_list = []
+    for idx, (imgp,
+              maskp) in enumerate(zip(sorted(image_list), sorted(mask_list))):
+        item = {'image': imgp, 'label': maskp}
+        file_list.append(item)
+    return file_list
+
+
+def convert_maskid(mask):
+    # add mask id conversion
+    arr_mask = np.array(mask).astype(np.uint8)
+    arr_mask[arr_mask == 255] = 1
+    return Image.fromarray(arr_mask)
+
+
+def check_file_exist(pair_list):
+    rel_path = os.getcwd()
+    for idx, sample in enumerate(pair_list):
+        image_path = sample['image']
+        assert os.path.exists(os.path.join(rel_path, image_path))
+        if 'label' in sample:
+            mask_path = sample['label']
+            assert os.path.exists(os.path.join(rel_path, mask_path))
+    print('all file path ok!')
+
+
+def process_dataset(file_lists, part_dir_dict):
+    for ith, part in enumerate(file_lists):
+        part_dir = part_dir_dict[ith]
+        for sample in part:
+            # read image and mask
+            image_path = sample['image']
+            if 'label' in sample:
+                mask_path = sample['label']
+
+            basename = os.path.basename(image_path)
+            targetname = basename.split('.')[0]  # from image name
+
+            # check image file
+            img_save_path = os.path.join(root_path, 'images', part_dir,
+                                         targetname + save_img_suffix)
+            if not os.path.exists(img_save_path):
+                if not image_path.endswith('.png'):
+                    src = Image.open(image_path)
+                    src.save(img_save_path)
+                else:
+                    shutil.copy(image_path, img_save_path)
+
+            if mask_path is not None:
+                mask_save_path = os.path.join(root_path, 'masks', part_dir,
+                                              targetname + save_seg_map_suffix)
+                if not os.path.exists(mask_save_path):
+                    # check mask file
+                    mask = Image.open(mask_path).convert('L')
+                    # convert mask id
+                    mask = convert_maskid(mask)
+                    if not mask_path.endswith('.png'):
+                        mask.save(mask_save_path)
+                    else:
+                        mask.save(mask_save_path)
+
+        # print image num
+        part_dir_folder = os.path.join(root_path, 'images', part_dir)
+        print(
+            f'{part_dir} has {len(os.listdir(part_dir_folder))} images completed!'  # noqa
+        )
+
+
+if __name__ == '__main__':
+
+    root_path = 'data/'  # original file
+    img_suffix = '.jpg'
+    seg_map_suffix = '.png'
+    save_img_suffix = '.png'
+    save_seg_map_suffix = '.png'
+
+    train_imgs = glob.glob('data/ISIC-2017_Training_Data/*' + img_suffix)
+    train_masks = glob.glob('data/ISIC-2017_Training_Part1_GroundTruth/*' +
+                            seg_map_suffix)
+
+    val_imgs = glob.glob('data/ISIC-2017_Validation_Data/*' + img_suffix)
+    val_masks = glob.glob('data/ISIC-2017_Validation_Part1_GroundTruth/*' +
+                          seg_map_suffix)
+
+    test_imgs = glob.glob('data/ISIC-2017_Test_v2_Data/*' + img_suffix)
+    test_masks = glob.glob('data/ISIC-2017_Test_v2_Part1_GroundTruth/*' +
+                           seg_map_suffix)
+
+    assert len(train_imgs) == len(train_masks)
+    assert len(val_imgs) == len(val_masks)
+    assert len(test_imgs) == len(test_masks)
+
+    os.system('mkdir -p ' + root_path + 'images/train/')
+    os.system('mkdir -p ' + root_path + 'images/val/')
+    os.system('mkdir -p ' + root_path + 'images/test/')
+    os.system('mkdir -p ' + root_path + 'masks/train/')
+    os.system('mkdir -p ' + root_path + 'masks/val/')
+    os.system('mkdir -p ' + root_path + 'masks/test/')
+
+    part_dir_dict = {0: 'train/', 1: 'val/', 2: 'test/'}
+
+    train_pair_list = reformulate_file(train_imgs, train_masks)
+    val_pair_list = reformulate_file(val_imgs, val_masks)
+    test_pair_list = reformulate_file(test_imgs, test_masks)
+
+    check_file_exist(train_pair_list)
+    check_file_exist(val_pair_list)
+    check_file_exist(test_pair_list)
+
+    part_dir_dict = {0: 'train/', 1: 'val/', 2: 'test/'}
+    process_dataset([train_pair_list, val_pair_list, test_pair_list],
+                    part_dir_dict)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/README.md b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/README.md
new file mode 100644
index 0000000..ea597bc
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/README.md
@@ -0,0 +1,145 @@
+# Kvasir-Sessile Dataset (Kvasir SEG)
+
+## Description
+
+This project supports **`Kvasir-Sessile Dataset (Kvasir SEG) `**, which can be downloaded from [here](https://opendatalab.com/Kvasir-Sessile_dataset).
+
+## Dataset Overview
+
+The Kvasir-SEG dataset contains polyp images and their corresponding ground truth from the Kvasir Dataset v2. The resolution of the images contained in Kvasir-SEG varies from 332x487 to 1920x1072 pixels.
+
+<!-- For a typical model, this section should contain the commands for training and testing. You are also suggested to dump your environment specification to env.yml by `conda env export > env.yml`. -->
+
+### Information Statistics
+
+| Dataset Name                                                  | Anatomical Region | Task Type    | Modality  | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                   |
+| ------------------------------------------------------------- | ----------------- | ------------ | --------- | ------------ | --------------------- | ---------------------- | ------------ | --------------------------------------------------------- |
+| [Kvarsir-SEG](https://opendatalab.com/Kvasir-Sessile_dataset) | abdomen           | segmentation | endoscopy | 2            | 196/-/-               | yes/-/-                | 2020         | [CC-BY 4.0](https://creativecommons.org/licenses/by/4.0/) |
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |    196     |   92.31    |    -     |    -     |     -     |     -     |
+|   polyp    |    196     |    7.69    |    -     |    -     |     -     |     -     |
+
+Note:
+
+- `Pct` means percentage of pixels in this category in all pixels.
+
+### Visualization
+
+![kvasir-seg](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/endoscopy_images/kvasir_seg/kvasir_seg_dataset.png?raw=true)
+
+### Dataset Citation
+
+```
+@inproceedings{jha2020kvasir,
+	title={Kvasir-seg: A segmented polyp dataset},
+	author={Jha, Debesh and Smedsrud, Pia H and Riegler, Michael A and Halvorsen, P{\aa}l and Lange, Thomas de and Johansen, Dag and Johansen, H{\aa}vard D},
+	booktitle={International Conference on Multimedia Modeling},
+	pages={451--462},
+	year={2020},
+	organization={Springer}
+ }
+```
+
+### Prerequisites
+
+- Python v3.8
+- PyTorch v1.10.0
+- pillow(PIL) v9.3.0
+- scikit-learn(sklearn) v1.2.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+
+All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `kvasir_seg/` root directory, run the following line to add the current directory to `PYTHONPATH`:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset Preparing
+
+- download dataset from [here](https://opendatalab.com/Kvasir-Sessile_dataset) and decompress data to path `'data/'`.
+- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
+- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set cannot be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── endoscopy
+  │   │   │   │   ├── kvasir_seg
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── train.txt
+  │   │   │   │   │   │   ├── val.txt
+  │   │   │   │   │   │   ├── images
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   ├── masks
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+```
+
+### Divided Dataset Information
+
+***Note: The table information below is divided by ourselves.***
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |    156     |   92.28    |    40    |  92.41   |     -     |     -     |
+|   polyp    |    156     |    7.72    |    40    |   7.59   |     -     |     -     |
+
+### Training commands
+
+To train models on a single server with one GPU. (default)
+
+```shell
+mim train mmseg .configs/${CONFIG_FILE}
+```
+
+### Testing commands
+
+To test models on a single server with one GPU. (default)
+
+```shell
+mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
+
+You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+  - [x] Basic docstrings & proper citation
+  - [ ] Test-time correctness
+  - [x] A full README
+
+- [x] Milestone 2: Indicates a successful model implementation.
+
+  - [x] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+  - [ ] Unit tests
+  - [ ] Code polishing
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_kvasir-seg-512x512.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_kvasir-seg-512x512.py
new file mode 100644
index 0000000..145d5a7
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_kvasir-seg-512x512.py
@@ -0,0 +1,18 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './kvasir-seg_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.kvasir-seg_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(
+        num_classes=2, loss_decode=dict(use_sigmoid=True), out_channels=1),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_kvasir-seg-512x512.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_kvasir-seg-512x512.py
new file mode 100644
index 0000000..3ea05c5
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_kvasir-seg-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './kvasir-seg_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.kvasir-seg_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_kvasir-seg-512x512.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_kvasir-seg-512x512.py
new file mode 100644
index 0000000..7e064a7
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_kvasir-seg-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './kvasir-seg_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.kvasir-seg_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_kvasir-seg-512x512.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_kvasir-seg-512x512.py
new file mode 100644
index 0000000..0fc1d6e
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_kvasir-seg-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './kvasir-seg_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.kvasir-seg_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/kvasir-seg_512x512.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/kvasir-seg_512x512.py
new file mode 100644
index 0000000..e8b2467
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/kvasir-seg_512x512.py
@@ -0,0 +1,42 @@
+dataset_type = 'KvasirSEGDataset'
+data_root = 'data/'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='train.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='val.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/datasets/kvasir-seg_dataset.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/datasets/kvasir-seg_dataset.py
new file mode 100644
index 0000000..9d60132
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/datasets/kvasir-seg_dataset.py
@@ -0,0 +1,30 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class KvasirSEGDataset(BaseSegDataset):
+    """KvasirSEGDataset dataset.
+
+    In segmentation map annotation for KvasirSEGDataset, 0 stands for
+    background, which is included in 2 categories.
+    ``reduce_zero_label`` is fixed to False. The ``img_suffix`` is
+    fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+        reduce_zero_label (bool): Whether to mark label zero as ignored.
+            Default to False..
+    """
+    METAINFO = dict(classes=('background', 'polyp'))
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/tools/prepare_dataset.py
new file mode 100644
index 0000000..74c43e9
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/tools/prepare_dataset.py
@@ -0,0 +1,87 @@
+import glob
+import os
+
+import numpy as np
+from PIL import Image
+
+root_path = 'data/'
+img_suffix = '.jpg'
+seg_map_suffix = '.jpg'
+save_img_suffix = '.png'
+save_seg_map_suffix = '.png'
+tgt_img_dir = os.path.join(root_path, 'images/train/')
+tgt_mask_dir = os.path.join(root_path, 'masks/train/')
+os.system('mkdir -p ' + tgt_img_dir)
+os.system('mkdir -p ' + tgt_mask_dir)
+
+
+def filter_suffix_recursive(src_dir, suffix):
+    # filter out file names and paths in source directory
+    suffix = '.' + suffix if '.' not in suffix else suffix
+    file_paths = glob.glob(
+        os.path.join(src_dir, '**', '*' + suffix), recursive=True)
+    file_names = [_.split('/')[-1] for _ in file_paths]
+    return sorted(file_paths), sorted(file_names)
+
+
+def convert_label(img, convert_dict):
+    arr = np.zeros_like(img, dtype=np.uint8)
+    for c, i in convert_dict.items():
+        arr[img == c] = i
+    return arr
+
+
+def convert_pics_into_pngs(src_dir, tgt_dir, suffix, convert='RGB'):
+    if not os.path.exists(tgt_dir):
+        os.makedirs(tgt_dir)
+
+    src_paths, src_names = filter_suffix_recursive(src_dir, suffix=suffix)
+    for i, (src_name, src_path) in enumerate(zip(src_names, src_paths)):
+        tgt_name = src_name.replace(suffix, save_img_suffix)
+        tgt_path = os.path.join(tgt_dir, tgt_name)
+        num = len(src_paths)
+        img = np.array(Image.open(src_path))
+        if len(img.shape) == 2:
+            pil = Image.fromarray(img).convert(convert)
+        elif len(img.shape) == 3:
+            pil = Image.fromarray(img)
+        else:
+            raise ValueError('Input image not 2D/3D: ', img.shape)
+
+        pil.save(tgt_path)
+        print(f'processed {i+1}/{num}.')
+
+
+def convert_label_pics_into_pngs(src_dir,
+                                 tgt_dir,
+                                 suffix,
+                                 convert_dict={
+                                     0: 0,
+                                     255: 1
+                                 }):
+    if not os.path.exists(tgt_dir):
+        os.makedirs(tgt_dir)
+
+    src_paths, src_names = filter_suffix_recursive(src_dir, suffix=suffix)
+    num = len(src_paths)
+    for i, (src_name, src_path) in enumerate(zip(src_names, src_paths)):
+        tgt_name = src_name.replace(suffix, save_seg_map_suffix)
+        tgt_path = os.path.join(tgt_dir, tgt_name)
+
+        img = np.array(Image.open(src_path))
+        img = convert_label(img, convert_dict)
+        Image.fromarray(img).save(tgt_path)
+        print(f'processed {i+1}/{num}.')
+
+
+if __name__ == '__main__':
+
+    convert_pics_into_pngs(
+        os.path.join(root_path, 'sessile-main-Kvasir-SEG/images'),
+        tgt_img_dir,
+        suffix=img_suffix)
+
+    convert_label_pics_into_pngs(
+        os.path.join(root_path, 'sessile-main-Kvasir-SEG/masks'),
+        tgt_mask_dir,
+        suffix=seg_map_suffix)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/README.md b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/README.md
new file mode 100644
index 0000000..80eb00f
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/README.md
@@ -0,0 +1,145 @@
+# Kvasir-SEG Segmented Polyp Dataset from Aliyun (Kvasir SEG Aliyun)
+
+## Description
+
+This project supports **`Kvasir-SEG Segmented Polyp Dataset from Aliyun (Kvasir SEG Aliyun) `**, which can be downloaded from [here](https://tianchi.aliyun.com/dataset/84385).
+
+### Dataset Overview
+
+Colorectal cancer is the second most common cancer type among women and third most common among men. Polyps are precursors to colorectal cancer and therefore important to detect and remove at an early stage. Polyps are found in nearly half of the individuals at age 50 that undergo a colonoscopy screening, and their frequency increase with age.Polyps are abnormal tissue growth from the mucous membrane, which is lining the inside of the GI tract, and can sometimes be cancerous. Colonoscopy is the gold standard for detection and assessment of these polyps with subsequent biopsy and removal of the polyps. Early disease detection has a huge impact on survival from colorectal cancer. Increasing the detection of polyps has been shown to decrease risk of colorectal cancer. Thus, automatic detection of more polyps at an early stage can play a crucial role in prevention and survival from colorectal cancer.
+
+The Kvasir-SEG dataset is based on the previous Kvasir dataset, which is the first multi-class dataset for gastrointestinal (GI) tract disease detection and classification. It contains annotated polyp images and their corresponding masks. The pixels depicting polyp tissue, the ROI, are represented by the foreground (white mask), while the background (in black) does not contain positive pixels. These images were collected and verified by experienced gastroenterologists from Vestre Viken Health Trust in Norway. The classes include anatomical landmarks, pathological findings and endoscopic procedures.
+
+### Information Statistics
+
+| Dataset Name                                           | Anatomical Region | Task Type    | Modality  | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                   |
+| ------------------------------------------------------ | ----------------- | ------------ | --------- | ------------ | --------------------- | ---------------------- | ------------ | --------------------------------------------------------- |
+| [kvasir-seg](https://tianchi.aliyun.com/dataset/84385) | abdomen           | segmentation | endoscopy | 2            | 1000/-/-              | yes/-/-                | 2020         | [CC-BY 4.0](https://creativecommons.org/licenses/by/4.0/) |
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |    1000    |   84.72    |    -     |    -     |     -     |     -     |
+|   polyp    |    1000    |   15.28    |    -     |    -     |     -     |     -     |
+
+Note:
+
+- `Pct` means percentage of pixels in this category in all pixels.
+
+### Visualization
+
+![kvasir_seg_aliyun](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/endoscopy_images/kvasir_seg_aliyun/kvasir_seg_aliyun_dataset.png?raw=true)
+
+### Dataset Citation
+
+```
+@inproceedings{jha2020kvasir,
+	title={Kvasir-seg: A segmented polyp dataset},
+	author={Jha, Debesh and Smedsrud, Pia H and Riegler, Michael A and Halvorsen, P{\aa}l and Lange, Thomas de and Johansen, Dag and Johansen, H{\aa}vard D},
+	booktitle={International Conference on Multimedia Modeling},
+	pages={451--462},
+	year={2020},
+	organization={Springer}
+ }
+```
+
+### Prerequisites
+
+- Python v3.8
+- PyTorch v1.10.0
+- pillow(PIL) v9.3.0
+- scikit-learn(sklearn) v1.2.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+
+All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `kvasir_seg_aliyun/` root directory, run the following line to add the current directory to `PYTHONPATH`:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset Preparing
+
+- download dataset from [here](https://tianchi.aliyun.com/dataset/84385) and decompression data to path 'data/.'.
+- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
+- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set cannot be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── endoscopy
+  │   │   │   │   ├── kvasir_seg_aliyun
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── train.txt
+  │   │   │   │   │   │   ├── val.txt
+  │   │   │   │   │   │   ├── images
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   ├── masks
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+```
+
+### Divided Dataset Information
+
+***Note: The table information below is divided by ourselves.***
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |    800     |   84.66    |   200    |  84.94   |     -     |     -     |
+|   polyp    |    800     |   15.34    |   200    |  15.06   |     -     |     -     |
+
+### Training commands
+
+To train models on a single server with one GPU. (default)
+
+```shell
+mim train mmseg ./configs/${CONFIG_FILE}
+```
+
+### Testing commands
+
+To test models on a single server with one GPU. (default)
+
+```shell
+mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
+
+You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+  - [x] Basic docstrings & proper citation
+  - [ ] Test-time correctness
+  - [x] A full README
+
+- [ ] Milestone 2: Indicates a successful model implementation.
+
+  - [ ] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+  - [ ] Unit tests
+  - [ ] Code polishing
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_kvasir-seg-aliyun-512x512.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_kvasir-seg-aliyun-512x512.py
new file mode 100644
index 0000000..b59db95
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_kvasir-seg-aliyun-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    './kvasir-seg-aliyun_512x512.py', 'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.kvasir-seg-aliyun_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_kvasir-seg-aliyun-512x512.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_kvasir-seg-aliyun-512x512.py
new file mode 100644
index 0000000..6c52668
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_kvasir-seg-aliyun-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    './kvasir-seg-aliyun_512x512.py', 'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.kvasir-seg-aliyun_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_kvasir-seg-aliyun-512x512.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_kvasir-seg-aliyun-512x512.py
new file mode 100644
index 0000000..a192a5b
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_kvasir-seg-aliyun-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    './kvasir-seg-aliyun_512x512.py', 'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.kvasir-seg-aliyun_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_kvasir-seg-aliyun-512x512.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_kvasir-seg-aliyun-512x512.py
new file mode 100644
index 0000000..5325e1f
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_kvasir-seg-aliyun-512x512.py
@@ -0,0 +1,18 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    './kvasir-seg-aliyun_512x512.py', 'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.kvasir-seg-aliyun_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(
+        num_classes=2, loss_decode=dict(use_sigmoid=True), out_channels=1),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/kvasir-seg-aliyun_512x512.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/kvasir-seg-aliyun_512x512.py
new file mode 100644
index 0000000..5f86880
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/kvasir-seg-aliyun_512x512.py
@@ -0,0 +1,42 @@
+dataset_type = 'KvasirSEGAliyunDataset'
+data_root = 'data/'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='train.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='val.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/datasets/kvasir-seg-aliyun_dataset.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/datasets/kvasir-seg-aliyun_dataset.py
new file mode 100644
index 0000000..198caf0
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/datasets/kvasir-seg-aliyun_dataset.py
@@ -0,0 +1,30 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class KvasirSEGAliyunDataset(BaseSegDataset):
+    """KvasirSEGAliyunDataset dataset.
+
+    In segmentation map annotation for KvasirSEGAliyunDataset,
+    0 stands for  background,which is included in 2 categories.
+    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
+    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+        reduce_zero_label (bool): Whether to mark label zero as ignored.
+            Default to False..
+    """
+    METAINFO = dict(classes=('background', 'polyp'))
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/tools/prepare_dataset.py
new file mode 100644
index 0000000..b230e7f
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/tools/prepare_dataset.py
@@ -0,0 +1,86 @@
+import glob
+import os
+
+import numpy as np
+from PIL import Image
+
+root_path = 'data/'
+img_suffix = '.jpg'
+seg_map_suffix = '.jpg'
+save_img_suffix = '.png'
+save_seg_map_suffix = '.png'
+tgt_img_dir = os.path.join(root_path, 'images/train/')
+tgt_mask_dir = os.path.join(root_path, 'masks/train/')
+os.system('mkdir -p ' + tgt_img_dir)
+os.system('mkdir -p ' + tgt_mask_dir)
+
+
+def filter_suffix_recursive(src_dir, suffix):
+    # filter out file names and paths in source directory
+    suffix = '.' + suffix if '.' not in suffix else suffix
+    file_paths = glob.glob(
+        os.path.join(src_dir, '**', '*' + suffix), recursive=True)
+    file_names = [_.split('/')[-1] for _ in file_paths]
+    return sorted(file_paths), sorted(file_names)
+
+
+def convert_label(img, convert_dict):
+    arr = np.zeros_like(img, dtype=np.uint8)
+    for c, i in convert_dict.items():
+        arr[img == c] = i
+    return arr
+
+
+def convert_pics_into_pngs(src_dir, tgt_dir, suffix, convert='RGB'):
+    if not os.path.exists(tgt_dir):
+        os.makedirs(tgt_dir)
+
+    src_paths, src_names = filter_suffix_recursive(src_dir, suffix=suffix)
+    for i, (src_name, src_path) in enumerate(zip(src_names, src_paths)):
+        tgt_name = src_name.replace(suffix, save_img_suffix)
+        tgt_path = os.path.join(tgt_dir, tgt_name)
+        num = len(src_paths)
+        img = np.array(Image.open(src_path))
+        if len(img.shape) == 2:
+            pil = Image.fromarray(img).convert(convert)
+        elif len(img.shape) == 3:
+            pil = Image.fromarray(img)
+        else:
+            raise ValueError('Input image not 2D/3D: ', img.shape)
+
+        pil.save(tgt_path)
+        print(f'processed {i+1}/{num}.')
+
+
+def convert_label_pics_into_pngs(src_dir,
+                                 tgt_dir,
+                                 suffix,
+                                 convert_dict={
+                                     0: 0,
+                                     255: 1
+                                 }):
+    if not os.path.exists(tgt_dir):
+        os.makedirs(tgt_dir)
+
+    src_paths, src_names = filter_suffix_recursive(src_dir, suffix=suffix)
+    num = len(src_paths)
+    for i, (src_name, src_path) in enumerate(zip(src_names, src_paths)):
+        tgt_name = src_name.replace(suffix, save_seg_map_suffix)
+        tgt_path = os.path.join(tgt_dir, tgt_name)
+
+        img = np.array(Image.open(src_path).convert('L'))
+        img = convert_label(img, convert_dict)
+        Image.fromarray(img).save(tgt_path)
+        print(f'processed {i+1}/{num}.')
+
+
+if __name__ == '__main__':
+    convert_pics_into_pngs(
+        os.path.join(root_path, 'Kvasir-SEG/images'),
+        tgt_img_dir,
+        suffix=img_suffix)
+
+    convert_label_pics_into_pngs(
+        os.path.join(root_path, 'Kvasir-SEG/masks'),
+        tgt_mask_dir,
+        suffix=seg_map_suffix)
diff --git a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/README.md b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/README.md
new file mode 100644
index 0000000..c2c61c4
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/README.md
@@ -0,0 +1,158 @@
+# Vessel Assessment and Measurement Platform for Images of the REtina
+
+## Description
+
+This project support **`Vessel Assessment and Measurement Platform for Images of the REtina`**, and the dataset used in this project can be downloaded from [here](https://vampire.computing.dundee.ac.uk/vesselseg.html).
+
+### Dataset Overview
+
+In order to promote evaluation of vessel segmentation on ultra-wide field-of-view (UWFV) fluorescein angriogram (FA) frames, we make public 8 frames from two different sequences, the manually annotated images and the result of our automatic vessel segmentation algorithm.
+
+### Original Statistic Information
+
+| Dataset name                                                     | Anatomical region | Task type    | Modality               | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                         |
+| ---------------------------------------------------------------- | ----------------- | ------------ | ---------------------- | ------------ | --------------------- | ---------------------- | ------------ | --------------------------------------------------------------- |
+| [Vampire](https://vampire.computing.dundee.ac.uk/vesselseg.html) | vessel            | segmentation | fluorescein angriogram | 2            | 8/-/-                 | yes/-/-                | 2017         | [CC-BY-NC 4.0](https://creativecommons.org/licenses/by-sa/4.0/) |
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |     8      |   96.75    |    -     |    -     |     -     |     -     |
+|   vessel   |     8      |    3.25    |    -     |    -     |     -     |     -     |
+
+Note:
+
+- `Pct` means percentage of pixels in this category in all pixels.
+
+### Visualization
+
+![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/fluorescein_angriogram/vampire/vampire_dataset.png)
+
+## Dataset Citation
+
+```bibtex
+
+@inproceedings{perez2011improving,
+  title={Improving vessel segmentation in ultra-wide field-of-view retinal fluorescein angiograms},
+  author={Perez-Rovira, Adria and Zutis, K and Hubschman, Jean Pierre and Trucco, Emanuele},
+  booktitle={2011 Annual International Conference of the IEEE Engineering in Medicine and Biology Society},
+  pages={2614--2617},
+  year={2011},
+  organization={IEEE}
+}
+
+@article{perez2011rerbee,
+  title={RERBEE: robust efficient registration via bifurcations and elongated elements applied to retinal fluorescein angiogram sequences},
+  author={Perez-Rovira, Adria and Cabido, Raul and Trucco, Emanuele and McKenna, Stephen J and Hubschman, Jean Pierre},
+  journal={IEEE Transactions on Medical Imaging},
+  volume={31},
+  number={1},
+  pages={140--150},
+  year={2011},
+  publisher={IEEE}
+}
+
+```
+
+### Prerequisites
+
+- Python v3.8
+- PyTorch v1.10.0
+- pillow(PIL) v9.3.0
+- scikit-learn(sklearn) v1.2.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+
+All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `vampire/` root directory, run the following line to add the current directory to `PYTHONPATH`:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset preparing
+
+- download dataset from [here](https://vampire.computing.dundee.ac.uk/vesselseg.html) and decompression data to path `'data/'`.
+- run script `"python tools/prepare_dataset.py"` to split dataset and change folder structure as below.
+- run script `python ../../tools/split_seg_dataset.py` to split dataset. For the Bacteria_detection dataset, as there is no test or validation dataset, we sample 20% samples from the whole dataset as the validation dataset and 80% samples for training data and make two filename lists `train.txt` and `val.txt`. As we set the random seed as the hard code, we eliminated the randomness, the dataset split actually can be reproducible.
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── fluorescein_angriogram
+  │   │   │   │   ├── vampire
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── train.txt
+  │   │   │   │   │   │   ├── val.txt
+  │   │   │   │   │   │   ├── images
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   ├── masks
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+```
+
+### Divided Dataset Information
+
+***Note: The table information below is divided by ourselves.***
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |     6      |   97.48    |    2     |  94.54   |     -     |     -     |
+|   vessel   |     6      |    2.52    |    2     |   5.46   |     -     |     -     |
+
+### Training commands
+
+To train models on a single server with one GPU. (default）
+
+```shell
+mim train mmseg ./configs/${CONFIG_PATH}
+```
+
+### Testing commands
+
+To test models on a single server with one GPU. (default)
+
+```shell
+mim test mmseg ./configs/${CONFIG_PATH}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+
+  - [x] Basic docstrings & proper citation
+
+  - [ ] Test-time correctness
+
+  - [x] A full README
+
+- [ ] Milestone 2: Indicates a successful model implementation.
+
+  - [ ] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+
+  - [ ] Unit tests
+
+  - [ ] Code polishing
+
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_vampire-512x512.py b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_vampire-512x512.py
new file mode 100755
index 0000000..7f5273a
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_vampire-512x512.py
@@ -0,0 +1,19 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './vampire_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.vampire_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_vampire-512x512.py b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_vampire-512x512.py
new file mode 100755
index 0000000..4382229
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_vampire-512x512.py
@@ -0,0 +1,19 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './vampire_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.vampire_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=dict(size=img_scale),
+    pretrained=None,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_vampire-512x512.py b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_vampire-512x512.py
new file mode 100755
index 0000000..8d93e17
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_vampire-512x512.py
@@ -0,0 +1,22 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './vampire_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.vampire_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    decode_head=dict(
+        num_classes=2,
+        loss_decode=dict(type='CrossEntropyLoss', use_sigmoid=True),
+        out_channels=1),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/vampire_512x512.py b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/vampire_512x512.py
new file mode 100755
index 0000000..4eda92f
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/vampire_512x512.py
@@ -0,0 +1,42 @@
+dataset_type = 'VampireDataset'
+data_root = 'data'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='train.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='val.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/datasets/__init__.py b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/datasets/__init__.py
new file mode 100755
index 0000000..93f9cbf
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/datasets/__init__.py
@@ -0,0 +1,3 @@
+from .vampire_dataset import VampireDataset
+
+__all__ = ['VampireDataset']
diff --git a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/datasets/vampire_dataset.py b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/datasets/vampire_dataset.py
new file mode 100755
index 0000000..4d38040
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/datasets/vampire_dataset.py
@@ -0,0 +1,28 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class VampireDataset(BaseSegDataset):
+    """VampireDataset dataset.
+
+    In segmentation map annotation for VampireDataset, 0 stands for background,
+    which is included in 2 categories. ``reduce_zero_label`` is fixed to
+    False. The ``img_suffix`` is fixed to '.png' and ``seg_map_suffix`` is
+    fixed to '.png'.
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+    """
+    METAINFO = dict(classes=('background', 'vessel'))
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/tools/prepare_dataset.py
new file mode 100644
index 0000000..2755b5d
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/tools/prepare_dataset.py
@@ -0,0 +1,44 @@
+import os
+import shutil
+
+from PIL import Image
+
+path = 'data'
+
+if not os.path.exists(os.path.join(path, 'images', 'train')):
+    os.system(f'mkdir -p {os.path.join(path, "images", "train")}')
+
+if not os.path.exists(os.path.join(path, 'masks', 'train')):
+    os.system(f'mkdir -p {os.path.join(path, "masks", "train")}')
+
+origin_data_path = os.path.join(path, 'vesselSegmentation')
+
+imgs_amd14 = os.listdir(os.path.join(origin_data_path, 'AMD14'))
+imgs_ger7 = os.listdir(os.path.join(origin_data_path, 'GER7'))
+
+for img in imgs_amd14:
+    shutil.copy(
+        os.path.join(origin_data_path, 'AMD14', img),
+        os.path.join(path, 'images', 'train', img))
+    # copy GT
+    img_gt = img.replace('.png', '-GT.png')
+    shutil.copy(
+        os.path.join(origin_data_path, 'AMD14-GT', f'{img_gt}'),
+        os.path.join(path, 'masks', 'train', img))
+
+for img in imgs_ger7:
+    shutil.copy(
+        os.path.join(origin_data_path, 'GER7', img),
+        os.path.join(path, 'images', 'train', img))
+    # copy GT
+    img_gt = img.replace('.bmp', '-GT.png')
+    img = img.replace('bmp', 'png')
+    shutil.copy(
+        os.path.join(origin_data_path, 'GER7-GT', img_gt),
+        os.path.join(path, 'masks', 'train', img))
+
+imgs = os.listdir(os.path.join(path, 'images', 'train'))
+for img in imgs:
+    if not img.endswith('.png'):
+        im = Image.open(os.path.join(path, 'images', 'train', img))
+        im.save(os.path.join(path, 'images', 'train', img[:-4] + '.png'))
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/README.md b/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/README.md
new file mode 100644
index 0000000..85d8a3e
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/README.md
@@ -0,0 +1,155 @@
+# DR HAGIS: Diabetic Retinopathy, Hypertension, Age-related macular degeneration and Glacuoma ImageS
+
+## Description
+
+This project supports **`DR HAGIS: Diabetic Retinopathy, Hypertension, Age-related macular degeneration and Glacuoma ImageS`**, which can be downloaded from [here](https://paperswithcode.com/dataset/dr-hagis).
+
+### Dataset Overview
+
+The DR HAGIS database has been created to aid the development of vessel extraction algorithms suitable for retinal screening programmes. Researchers are encouraged to test their segmentation algorithms using this database. All thirty-nine fundus images were obtained from a diabetic retinopathy screening programme in the UK. Hence, all images were taken from diabetic patients.
+
+Besides the fundus images, the manual segmentation of the retinal surface vessels is provided by an expert grader. These manually segmented images can be used as the ground truth to compare and assess the automatic vessel extraction algorithms. Masks of the FOV are provided as well to quantify the accuracy of vessel extraction within the FOV only. The images were acquired in different screening centers, therefore reflecting the range of image resolutions, digital cameras and fundus cameras used in the clinic. The fundus images were captured using a Topcon TRC-NW6s, Topcon TRC-NW8 or a Canon CR DGi fundus camera with a horizontal 45 degree field-of-view (FOV). The images are 4752x3168 pixels, 3456x2304 pixels, 3126x2136 pixels, 2896x1944 pixels or 2816x1880 pixels in size.
+
+### Original Statistic Information
+
+| Dataset name                                            | Anatomical region | Task type    | Modality           | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License |
+| ------------------------------------------------------- | ----------------- | ------------ | ------------------ | ------------ | --------------------- | ---------------------- | ------------ | ------- |
+| [DR HAGIS](https://paperswithcode.com/dataset/dr-hagis) | head and neck     | segmentation | fundus photography | 2            | 40/-/-                | yes/-/-                | 2017         | -       |
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |     40     |   96.38    |    -     |    -     |     -     |     -     |
+|   vessel   |     40     |    3.62    |    -     |    -     |     -     |     -     |
+
+Note:
+
+- `Pct` means percentage of pixels in this category in all pixels.
+
+### Visualization
+
+![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/fundus_photography/dr_hagis/dr_hagis_dataset.png)
+
+## Usage
+
+### Prerequisites
+
+- Python v3.8
+- PyTorch v1.10.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+
+All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `dr_hagis/` root directory, run the following line to add the current directory to `PYTHONPATH`:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset preparing
+
+- download dataset from [here](https://paperswithcode.com/dataset/dr-hagis) and decompress data to path `'data/'`.
+- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
+- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set can't be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── fundus_photography
+  │   │   │   │   ├── dr_hagis
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── train.txt
+  │   │   │   │   │   │   ├── val.txt
+  │   │   │   │   │   │   ├── images
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   ├── masks
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+```
+
+### Divided Dataset Information
+
+***Note: The table information below is divided by ourselves.***
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |     32     |   96.21    |    8     |  97.12   |     -     |     -     |
+|   vessel   |     32     |    3.79    |    8     |   2.88   |     -     |     -     |
+
+### Training commands
+
+Train models on a single server with one GPU.
+
+```shell
+mim train mmseg ./configs/${CONFIG_FILE}
+```
+
+### Testing commands
+
+Test models on a single server with one GPU.
+
+```shell
+mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
+
+You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
+
+## Dataset Citation
+
+If this work is helpful for your research, please consider citing the below paper.
+
+```
+@article{holm2017dr,
+  title={DR HAGIS—a fundus image database for the automatic extraction of retinal surface vessels from diabetic patients},
+  author={Holm, Sven and Russell, Greg and Nourrit, Vincent and McLoughlin, Niall},
+  journal={Journal of Medical Imaging},
+  volume={4},
+  number={1},
+  pages={014503--014503},
+  year={2017},
+  publisher={Society of Photo-Optical Instrumentation Engineers}
+}
+```
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+
+  - [x] Basic docstrings & proper citation
+
+  - [ ] Test-time correctness
+
+  - [x] A full README
+
+- [ ] Milestone 2: Indicates a successful model implementation.
+
+  - [ ] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+
+  - [ ] Unit tests
+
+  - [ ] Code polishing
+
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/dr-hagis_512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/dr-hagis_512x512.py
new file mode 100644
index 0000000..93b9638
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/dr-hagis_512x512.py
@@ -0,0 +1,42 @@
+dataset_type = 'DRHAGISDataset'
+data_root = 'data/'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='train.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='val.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_dr-hagis-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_dr-hagis-512x512.py
new file mode 100644
index 0000000..9d14427
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_dr-hagis-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    './dr-hagis_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.dr-hagis_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_dr-hagis-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_dr-hagis-512x512.py
new file mode 100644
index 0000000..507ec74
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_dr-hagis-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    './dr-hagis_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.dr-hagis_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_dr-hagis-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_dr-hagis-512x512.py
new file mode 100644
index 0000000..092ae00
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_dr-hagis-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    './dr-hagis_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.dr-hagis_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/datasets/dr-hagis_dataset.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/datasets/dr-hagis_dataset.py
new file mode 100644
index 0000000..9659f0b
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/datasets/dr-hagis_dataset.py
@@ -0,0 +1,27 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class DRHAGISDataset(BaseSegDataset):
+    """DRHAGISDataset dataset.
+
+    In segmentation map annotation for DRHAGISDataset,
+    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
+    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
+
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+    """
+    METAINFO = dict(classes=('background', 'vessel'))
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=False,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/tools/prepare_dataset.py
new file mode 100755
index 0000000..51f4df7
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/tools/prepare_dataset.py
@@ -0,0 +1,41 @@
+import glob
+import os
+import shutil
+
+import mmengine
+import numpy as np
+from PIL import Image
+
+root_path = 'data/'
+img_suffix = '.jpg'
+seg_map_suffix = '_manual_orig.png'
+save_img_suffix = '.png'
+save_seg_map_suffix = '.png'
+
+x_train = glob.glob(os.path.join('data/DRHAGIS/**/*' + img_suffix))
+
+mmengine.mkdir_or_exist(root_path + 'images/train/')
+mmengine.mkdir_or_exist(root_path + 'masks/train/')
+
+D3_palette = {0: (0, 0, 0), 1: (1, 1, 1)}
+D3_invert_palette = {v: k for k, v in D3_palette.items()}
+D2_255_convert_dict = {0: 0, 255: 1}
+
+part_dir_dict = {0: 'train/', 1: 'val/'}
+for ith, part in enumerate([x_train]):
+    part_dir = part_dir_dict[ith]
+    for img in part:
+        basename = os.path.basename(img)
+        shutil.copy(
+            img, root_path + 'images/' + part_dir + basename.split('.')[0] +
+            save_img_suffix)
+        mask_path = root_path + 'DRHAGIS/Manual_Segmentations/' + basename.split(  # noqa
+            '.')[0] + seg_map_suffix
+        label = np.array(Image.open(mask_path))
+
+        save_mask_path = root_path + 'masks/' + part_dir + basename.split(
+            '.')[0] + save_seg_map_suffix  # noqa
+        mask = np.array(Image.open(mask_path)).astype(np.uint8)
+        mask[mask == 255] = 1
+        mask = Image.fromarray(mask)
+        mask.save(save_mask_path)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/README.md b/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/README.md
new file mode 100644
index 0000000..e834508
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/README.md
@@ -0,0 +1,167 @@
+# Glaucoma grAding from Multi-Modality imAges Task3
+
+## Description
+
+This project support **`Glaucoma grAding from Multi-Modality imAges Task3`**, and the dataset used in this project can be downloaded from [here](https://aistudio.baidu.com/aistudio/competition/detail/121/0/datasets).
+
+### Dataset Overview
+
+This regular-challenge dataset was provided by Sun Yat-sen Ophthalmic Center, Sun Yat-sen University, Guangzhou, China. The dataset contains 200 fundus color images: 100 pairs in the training set and 100 pairs in the test set.
+
+### Original Statistic Information
+
+| Dataset name                                                                        | Anatomical region | Task type    | Modality        | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                         |
+| ----------------------------------------------------------------------------------- | ----------------- | ------------ | --------------- | ------------ | --------------------- | ---------------------- | ------------ | --------------------------------------------------------------- |
+| [GammaTask3](https://aistudio.baidu.com/aistudio/competition/detail/121/0/datasets) | eye               | segmentation | fundus photophy | 3            | 100/-/100             | yes/-/-                | 2021         | [CC-BY-NC 4.0](https://creativecommons.org/licenses/by-sa/4.0/) |
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |    100     |   99.02    |    -     |    -     |     -     |     -     |
+| optic disc |    100     |    0.67    |    -     |    -     |     -     |     -     |
+| optic cup  |    100     |    0.31    |    -     |    -     |     -     |     -     |
+
+Note:
+
+- `Pct` means percentage of pixels in this category in all pixels.
+
+### Visualization
+
+![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/fundus_photography/gamma3/gamma3_dataset.png)
+
+## Dataset Citation
+
+```bibtex
+@article{fu2018joint,
+  title={Joint optic disc and cup segmentation based on multi-label deep network and polar transformation},
+  author={Fu, Huazhu and Cheng, Jun and Xu, Yanwu and Wong, Damon Wing Kee and Liu, Jiang and Cao, Xiaochun},
+  journal={IEEE transactions on medical imaging},
+  volume={37},
+  number={7},
+  pages={1597--1605},
+  year={2018},
+  publisher={IEEE}
+}
+
+@article{sevastopolsky2017optic,
+  title={Optic disc and cup segmentation methods for glaucoma detection with modification of U-Net convolutional neural network},
+  author={Sevastopolsky, Artem},
+  journal={Pattern Recognition and Image Analysis},
+  volume={27},
+  pages={618--624},
+  year={2017},
+  publisher={Springer}
+}
+```
+
+### Prerequisites
+
+- Python v3.8
+- PyTorch v1.10.0
+- pillow(PIL) v9.3.0
+- scikit-learn(sklearn) v1.2.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+
+All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `gammm3/` root directory, run the following line to add the current directory to `PYTHONPATH`:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset preparing
+
+- download dataset from [here](https://aistudio.baidu.com/aistudio/competition/detail/121/0/datasets) and decompression data to path `'data/'`.
+- run script `"python tools/prepare_dataset.py"` to split dataset and change folder structure as below.
+- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set can't be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── fundus_photography
+  │   │   │   │   ├── gamma3
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── train.txt
+  │   │   │   │   │   │   ├── val.txt
+  │   │   │   │   │   │   ├── images
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   │   ├── test
+  │   │   │   │   |   │   │   │   ├── yyy.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── yyy.png
+  │   │   │   │   │   │   ├── masks
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+```
+
+### Divided Dataset Information
+
+***Note: The table information below is divided by ourselves.***
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |     80     |   99.01    |    20    |  99.07   |     -     |     -     |
+| optic disc |     80     |    0.68    |    20    |   0.63   |     -     |     -     |
+| optic cup  |     80     |    0.32    |    20    |   0.31   |     -     |     -     |
+
+### Training commands
+
+To train models on a single server with one GPU. (default）
+
+```shell
+mim train mmseg ./configs/${CONFIG_PATH}
+```
+
+### Testing commands
+
+To test models on a single server with one GPU. (default）
+
+```shell
+mim test mmseg ./configs/${CONFIG_PATH}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
+
+You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+
+  - [x] Basic docstrings & proper citation
+
+  - [ ] Test-time correctness
+
+  - [x] A full README
+
+- [ ] Milestone 2: Indicates a successful model implementation.
+
+  - [ ] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+
+  - [ ] Unit tests
+
+  - [ ] Code polishing
+
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_gamma3-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_gamma3-512x512.py
new file mode 100644
index 0000000..0daac51
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_gamma3-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './gamma3_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.gamma3_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=3),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_gamma3-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_gamma3-512x512.py
new file mode 100644
index 0000000..8a25cd0
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_gamma3-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './gamma3_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.gamma3_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=3),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_gamma3-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_gamma3-512x512.py
new file mode 100644
index 0000000..ea64843
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_gamma3-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './gamma3_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.gamma3_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=3),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/gamma3_512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/gamma3_512x512.py
new file mode 100644
index 0000000..d23ab55
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/gamma3_512x512.py
@@ -0,0 +1,42 @@
+dataset_type = 'Gamma3Dataset'
+data_root = 'data/'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='train.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='val.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/datasets/gamma3_dataset.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/datasets/gamma3_dataset.py
new file mode 100644
index 0000000..56cbdd6
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/datasets/gamma3_dataset.py
@@ -0,0 +1,30 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class Gamma3Dataset(BaseSegDataset):
+    """Gamma3Dataset dataset.
+
+    In segmentation map annotation for Gamma3Dataset,
+    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
+    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
+
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+        reduce_zero_label (bool): Whether to mark label zero as ignored.
+            Default to False.
+    """
+    METAINFO = dict(classes=('background', 'disc', 'cup'))
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/tools/prepare_dataset.py
new file mode 100644
index 0000000..eb820b6
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/tools/prepare_dataset.py
@@ -0,0 +1,107 @@
+import glob
+import os
+
+import numpy as np
+from PIL import Image
+
+root_path = 'data/'
+img_suffix = '.jpg'
+seg_map_suffix = '.png'
+save_img_suffix = '.png'
+save_seg_map_suffix = '.png'
+tgt_img_train_dir = os.path.join(root_path, 'images/train/')
+tgt_mask_train_dir = os.path.join(root_path, 'masks/train/')
+tgt_img_test_dir = os.path.join(root_path, 'images/test/')
+os.system('mkdir -p ' + tgt_img_train_dir)
+os.system('mkdir -p ' + tgt_mask_train_dir)
+os.system('mkdir -p ' + tgt_img_test_dir)
+
+
+def filter_suffix_recursive(src_dir, suffix):
+    # filter out file names and paths in source directory
+    suffix = '.' + suffix if '.' not in suffix else suffix
+    file_paths = glob.glob(
+        os.path.join(src_dir, '**/*' + suffix), recursive=True)
+    file_names = [_.split('/')[-1] for _ in file_paths]
+    return sorted(file_paths), sorted(file_names)
+
+
+def convert_label(img, convert_dict):
+    arr = np.zeros_like(img, dtype=np.uint8)
+    for c, i in convert_dict.items():
+        arr[img == c] = i
+    return arr
+
+
+def convert_pics_into_pngs(src_dir, tgt_dir, suffix, convert='RGB'):
+    if not os.path.exists(tgt_dir):
+        os.makedirs(tgt_dir)
+    src_paths, src_names = filter_suffix_recursive(src_dir, suffix=suffix)
+
+    for i, (src_name, src_path) in enumerate(zip(src_names, src_paths)):
+        tgt_name = src_name.replace(suffix, save_img_suffix)
+        tgt_path = os.path.join(tgt_dir, tgt_name)
+        num = len(src_paths)
+        img = np.array(Image.open(src_path))
+        if len(img.shape) == 2:
+            pil = Image.fromarray(img).convert(convert)
+        elif len(img.shape) == 3:
+            pil = Image.fromarray(img)
+        else:
+            raise ValueError('Input image not 2D/3D: ', img.shape)
+
+        pil.save(tgt_path)
+        print(f'processed {i+1}/{num}.')
+
+
+def convert_label_pics_into_pngs(src_dir,
+                                 tgt_dir,
+                                 suffix,
+                                 convert_dict={
+                                     0: 2,
+                                     128: 1,
+                                     255: 0
+                                 }):
+    if not os.path.exists(tgt_dir):
+        os.makedirs(tgt_dir)
+
+    src_paths, src_names = filter_suffix_recursive(src_dir, suffix=suffix)
+    num = len(src_paths)
+    for i, (src_name, src_path) in enumerate(zip(src_names, src_paths)):
+        tgt_name = src_name.replace(suffix, save_seg_map_suffix)
+        tgt_path = os.path.join(tgt_dir, tgt_name)
+
+        img = np.array(Image.open(src_path))
+        img = convert_label(img, convert_dict)
+        Image.fromarray(img).save(tgt_path)
+        print(f'processed {i+1}/{num}.')
+
+
+if __name__ == '__main__':
+
+    convert_pics_into_pngs(
+        os.path.join(
+            root_path,
+            'task3_disc_cup_segmentation/training/fundus color images/'),
+        tgt_img_train_dir,
+        suffix=img_suffix)
+
+    convert_pics_into_pngs(
+        os.path.join(
+            root_path,
+            'task3_disc_cup_segmentation/testing/fundus color images/'),
+        tgt_img_test_dir,
+        suffix=img_suffix)
+
+    convert_label_pics_into_pngs(
+        os.path.join(root_path,
+                     'task3_disc_cup_segmentation/training/Disc_Cup_Mask/'),
+        tgt_mask_train_dir,
+        suffix=seg_map_suffix,
+        convert_dict={
+            0: 2,
+            128: 1,
+            255: 0
+        })
+    # original: [0, 128, 255] for ['optic cup', 'optic disc', 'background']
+    # converted: [0, 1, 2] for ['background', 'optic disc', 'optic cup']
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/README.md b/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/README.md
new file mode 100644
index 0000000..6f09203
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/README.md
@@ -0,0 +1,140 @@
+# ORVS (Online Retinal image for Vessel Segmentation (ORVS))
+
+## Description
+
+This project supports **`ORVS (Online Retinal image for Vessel Segmentation (ORVS))`**, which can be downloaded from [here](https://opendatalab.org.cn/ORVS).
+
+### Dataset Overview
+
+The ORVS dataset is a newly established collaboration between the Department of Computer Science and the Department of Vision Science at the University of Calgary. The dataset contains 49 images collected from a clinic in Calgary, Canada, consisting of 42 training images and 7 testing images. All images were obtained using a Zeiss Visucam 200 with a 30-degree field of view (FOV). The image size is 1444×1444 pixels with 24 bits per pixel. The images are stored in JPEG format with low compression, which is common in ophthalmic practice. All images were manually traced by an expert who has been working in the field of retinal image analysis and has been trained to mark all pixels belonging to retinal vessels. The Windows Paint 3D tool was used for manual image annotation.
+
+### Original Statistic Information
+
+| Dataset name                                           | Anatomical region | Task type    | Modality           | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License |
+| ------------------------------------------------------ | ----------------- | ------------ | ------------------ | ------------ | --------------------- | ---------------------- | ------------ | ------- |
+| [Bactteria detection](https://opendatalab.org.cn/ORVS) | bacteria          | segmentation | fundus photography | 2            | 130/-/72              | yes/-/yes              | 2020         | -       |
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |    130     |   94.83    |    -     |    -     |    72     |   94.25   |
+|   vessel   |    130     |    5.17    |    -     |    -     |    72     |   5.75    |
+
+Note:
+
+- `Pct` means percentage of pixels in this category in all pixels.
+
+### Visualization
+
+![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/fundus_photography/orvs/ORVS_dataset.png)
+
+### Prerequisites
+
+- Python v3.8
+- PyTorch v1.10.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+
+All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `orvs/` root directory, run the following line to add the current directory to `PYTHONPATH`:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset preparing
+
+- Clone this [repository](https://github.com/AbdullahSarhan/ICPRVessels), then move `Vessels-Datasets` to `data/`.
+- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
+- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set can't be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── fundus_photography
+  │   │   │   │   ├── orvs
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── train.txt
+  │   │   │   │   │   │   ├── test.txt
+  │   │   │   │   │   │   ├── images
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   ├── masks
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+```
+
+### Training commands
+
+Train models on a single server with one GPU.
+
+```shell
+mim train mmseg ./configs/${CONFIG_FILE}
+```
+
+### Testing commands
+
+Test models on a single server with one GPU.
+
+```shell
+mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
+
+You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
+
+## Dataset Citation
+
+If this work is helpful for your research, please consider citing the below paper.
+
+```
+@inproceedings{sarhan2021transfer,
+  title={Transfer learning through weighted loss function and group normalization for vessel segmentation from retinal images},
+  author={Sarhan, Abdullah and Rokne, Jon and Alhajj, Reda and Crichton, Andrew},
+  booktitle={2020 25th International Conference on Pattern Recognition (ICPR)},
+  pages={9211--9218},
+  year={2021},
+  organization={IEEE}
+}
+```
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+
+  - [x] Basic docstrings & proper citation
+
+  - [ ] Test-time correctness
+
+  - [x] A full README
+
+- [ ] Milestone 2: Indicates a successful model implementation.
+
+  - [ ] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+
+  - [ ] Unit tests
+
+  - [ ] Code polishing
+
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_orvs-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_orvs-512x512.py
new file mode 100644
index 0000000..662f837
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_orvs-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    './orvs_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.orvs_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_orvs-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_orvs-512x512.py
new file mode 100644
index 0000000..c47cdb6
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_orvs-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    './orvs_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.orvs_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_orvs-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_orvs-512x512.py
new file mode 100644
index 0000000..1097aad
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_orvs-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    './orvs_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.orvs_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/orvs_512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/orvs_512x512.py
new file mode 100644
index 0000000..a5594de
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/orvs_512x512.py
@@ -0,0 +1,42 @@
+dataset_type = 'ORVSDataset'
+data_root = 'data/'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='train.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='test.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/datasets/orvs_dataset.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/datasets/orvs_dataset.py
new file mode 100644
index 0000000..e915ae4
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/datasets/orvs_dataset.py
@@ -0,0 +1,27 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class ORVSDataset(BaseSegDataset):
+    """ORVSDataset dataset.
+
+    In segmentation map annotation for ORVSDataset,
+    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
+    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
+
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+    """
+    METAINFO = dict(classes=('background', 'vessel'))
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=False,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/tools/prepare_dataset.py
new file mode 100755
index 0000000..f902d87
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/tools/prepare_dataset.py
@@ -0,0 +1,55 @@
+import glob
+import os
+
+import numpy as np
+from PIL import Image
+
+root_path = 'data/'
+img_suffix = '.jpg'
+seg_map_suffix_list = ['.jpg', '.png', '.tif']
+save_img_suffix = '.png'
+save_seg_map_suffix = '.png'
+
+x_train = glob.glob(
+    os.path.join('data/Vessels-Datasets/*/Train/Original/Images/*' +
+                 img_suffix))
+x_test = glob.glob(
+    os.path.join('data/Vessels-Datasets/*/Test/Original/Images/*' +
+                 img_suffix))
+
+os.system('mkdir -p ' + root_path + 'images/train/')
+os.system('mkdir -p ' + root_path + 'images/test/')
+os.system('mkdir -p ' + root_path + 'masks/train/')
+os.system('mkdir -p ' + root_path + 'masks/test/')
+
+part_dir_dict = {0: 'train/', 1: 'test/'}
+for ith, part in enumerate([x_train, x_test]):
+    part_dir = part_dir_dict[ith]
+    for img in part:
+        type_name = img.split('/')[-5]
+        basename = type_name + '_' + os.path.basename(img)
+        save_img_path = root_path + 'images/' + part_dir + basename.split(
+            '.')[0] + save_img_suffix
+        Image.open(img).save(save_img_path)
+
+        for seg_map_suffix in seg_map_suffix_list:
+            if os.path.exists('/'.join(img.split('/')[:-1]).replace(
+                    'Images', 'Labels')):
+                mask_path = img.replace('Images', 'Labels').replace(
+                    img_suffix, seg_map_suffix)
+            else:
+                mask_path = img.replace('Images', 'labels').replace(
+                    img_suffix, seg_map_suffix)
+            if os.path.exists(mask_path):
+                break
+        save_mask_path = root_path + 'masks/' + part_dir + basename.split(
+            '.')[0] + save_seg_map_suffix
+        masks = np.array(Image.open(mask_path).convert('L')).astype(np.uint8)
+        if len(np.unique(masks)) == 2 and 1 in np.unique(masks):
+            print(np.unique(masks))
+            pass
+        else:
+            masks[masks < 128] = 0
+            masks[masks >= 128] = 1
+        masks = Image.fromarray(masks)
+        masks.save(save_mask_path)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/README.md b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/README.md
new file mode 100644
index 0000000..0aea9b0
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/README.md
@@ -0,0 +1,135 @@
+# Retinal Images vessel Tree Extraction (RITE)
+
+## Description
+
+This project supports **`Retinal Images vessel Tree Extraction (RITE) `**, which can be downloaded from [here](https://opendatalab.com/RITE).
+
+### Dataset Overview
+
+The RITE (Retinal Images vessel Tree Extraction) is a database that enables comparative studies on segmentation or classification of arteries and veins on retinal fundus images, which is established based on the public available DRIVE database (Digital Retinal Images for Vessel Extraction). RITE contains 40 sets of images, equally separated into a training subset and a test subset, the same as DRIVE. The two subsets are built from the corresponding two subsets in DRIVE. For each set, there is a fundus photograph, a vessel reference standard. The fundus photograph is inherited from DRIVE. For the training set, the vessel reference standard is a modified version of 1st_manual from DRIVE. For the test set, the vessel reference standard is 2nd_manual from DRIVE.
+
+### Statistic Information
+
+| Dataset Name                         | Anatomical Region | Task Type    | Modality           | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                         |
+| ------------------------------------ | ----------------- | ------------ | ------------------ | ------------ | --------------------- | ---------------------- | ------------ | --------------------------------------------------------------- |
+| [Rite](https://opendatalab.com/RITE) | head_and_neck     | segmentation | fundus_photography | 2            | 20/-/20               | yes/-/yes              | 2013         | [CC-BY-NC 4.0](https://creativecommons.org/licenses/by-sa/4.0/) |
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |     20     |   91.61    |    -     |    -     |    20     |   91.58   |
+|   vessel   |     20     |    8.39    |    -     |    -     |    20     |   8.42    |
+
+Note:
+
+- `Pct` means percentage of pixels in this category in all pixels.
+
+### Visualization
+
+![rite](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/fundus_photography/rite/rite_dataset.png?raw=true)
+
+### Dataset Citation
+
+```
+@InProceedings{10.1007/978-3-642-40763-5_54,
+	author={Hu, Qiao and Abr{\`a}moff, Michael D. and Garvin, Mona K.},
+	title={Automated Separation of Binary Overlapping Trees in Low-Contrast Color Retinal Images},
+	booktitle={Medical Image Computing and Computer-Assisted Intervention -- MICCAI 2013},
+	year={2013},
+	pages={436--443},
+}
+
+
+```
+
+### Prerequisites
+
+- Python v3.8
+- PyTorch v1.10.0
+- pillow(PIL) v9.3.0 9.3.0
+- scikit-learn(sklearn) v1.2.0 1.2.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+
+All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `rite/` root directory, run the following line to add the current directory to `PYTHONPATH`:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset Preparing
+
+- download dataset from [here](https://opendatalab.com/RITE) and decompress data to path `'data/'`.
+- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
+- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set cannot be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── fundus_photography
+  │   │   │   │   ├── rite
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── train.txt
+  │   │   │   │   │   │   ├── val.txt
+  │   │   │   │   │   │   ├── images
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   ├── masks
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+```
+
+### Training commands
+
+To train models on a single server with one GPU. (default)
+
+```shell
+mim train mmseg ./configs/${CONFIG_FILE}
+```
+
+### Testing commands
+
+To test models on a single server with one GPU. (default)
+
+```shell
+mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
+
+You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+  - [x] Basic docstrings & proper citation
+  - [ ] Test-time correctness
+  - [x] A full README
+
+- [ ] Milestone 2: Indicates a successful model implementation.
+
+  - [ ] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+  - [ ] Unit tests
+  - [ ] Code polishing
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_rite-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_rite-512x512.py
new file mode 100644
index 0000000..27dd436
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_rite-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './rite_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.rite_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_rite-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_rite-512x512.py
new file mode 100644
index 0000000..48f6f97
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_rite-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './rite_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.rite_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_rite-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_rite-512x512.py
new file mode 100644
index 0000000..5f5b24b
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_rite-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './rite_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.rite_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_rite-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_rite-512x512.py
new file mode 100644
index 0000000..bf66b6f
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_rite-512x512.py
@@ -0,0 +1,18 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './rite_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.rite_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(
+        num_classes=2, loss_decode=dict(use_sigmoid=True), out_channels=1),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/rite_512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/rite_512x512.py
new file mode 100644
index 0000000..02f620c
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/rite_512x512.py
@@ -0,0 +1,42 @@
+dataset_type = 'RITEDataset'
+data_root = 'data/'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='train.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='test.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/datasets/rite_dataset.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/datasets/rite_dataset.py
new file mode 100644
index 0000000..99f688d
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/datasets/rite_dataset.py
@@ -0,0 +1,31 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class RITEDataset(BaseSegDataset):
+    """RITEDataset dataset.
+
+    In segmentation map annotation for RITEDataset,
+    0 stands for background, which is included in 2 categories.
+    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
+    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
+
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+        reduce_zero_label (bool): Whether to mark label zero as ignored.
+            Default to False.
+    """
+    METAINFO = dict(classes=('background', 'vessel'))
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/tools/prepare_dataset.py
new file mode 100644
index 0000000..ca7e996
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/tools/prepare_dataset.py
@@ -0,0 +1,98 @@
+import glob
+import os
+
+import numpy as np
+from PIL import Image
+
+root_path = 'data/'
+img_suffix = '.tif'
+seg_map_suffix = '.png'
+save_img_suffix = '.png'
+save_seg_map_suffix = '.png'
+src_img_train_dir = os.path.join(root_path, 'AV_groundTruth/training/images/')
+src_img_test_dir = os.path.join(root_path, 'AV_groundTruth/test/images/')
+src_mask_train_dir = os.path.join(root_path, 'AV_groundTruth/training/vessel/')
+src_mask_test_dir = os.path.join(root_path, 'AV_groundTruth/test/vessel/')
+
+tgt_img_train_dir = os.path.join(root_path, 'images/train/')
+tgt_mask_train_dir = os.path.join(root_path, 'masks/train/')
+tgt_img_test_dir = os.path.join(root_path, 'images/test/')
+tgt_mask_test_dir = os.path.join(root_path, 'masks/test/')
+os.system('mkdir -p ' + tgt_img_train_dir)
+os.system('mkdir -p ' + tgt_mask_train_dir)
+os.system('mkdir -p ' + tgt_img_test_dir)
+os.system('mkdir -p ' + tgt_mask_test_dir)
+
+
+def filter_suffix_recursive(src_dir, suffix):
+    # filter out file names and paths in source directory
+    suffix = '.' + suffix if '.' not in suffix else suffix
+    file_paths = glob.glob(
+        os.path.join(src_dir, '**', '*' + suffix), recursive=True)
+    file_names = [_.split('/')[-1] for _ in file_paths]
+    return sorted(file_paths), sorted(file_names)
+
+
+def convert_label(img, convert_dict):
+    arr = np.zeros_like(img, dtype=np.uint8)
+    for c, i in convert_dict.items():
+        arr[img == c] = i
+    return arr
+
+
+def convert_pics_into_pngs(src_dir, tgt_dir, suffix, convert='RGB'):
+    if not os.path.exists(tgt_dir):
+        os.makedirs(tgt_dir)
+
+    src_paths, src_names = filter_suffix_recursive(src_dir, suffix=suffix)
+    for i, (src_name, src_path) in enumerate(zip(src_names, src_paths)):
+        tgt_name = src_name.replace(suffix, save_img_suffix)
+        tgt_path = os.path.join(tgt_dir, tgt_name)
+        num = len(src_paths)
+        img = np.array(Image.open(src_path))
+        if len(img.shape) == 2:
+            pil = Image.fromarray(img).convert(convert)
+        elif len(img.shape) == 3:
+            pil = Image.fromarray(img)
+        else:
+            raise ValueError('Input image not 2D/3D: ', img.shape)
+
+        pil.save(tgt_path)
+        print(f'processed {i+1}/{num}.')
+
+
+def convert_label_pics_into_pngs(src_dir,
+                                 tgt_dir,
+                                 suffix,
+                                 convert_dict={
+                                     0: 0,
+                                     255: 1
+                                 }):
+    if not os.path.exists(tgt_dir):
+        os.makedirs(tgt_dir)
+
+    src_paths, src_names = filter_suffix_recursive(src_dir, suffix=suffix)
+    num = len(src_paths)
+    for i, (src_name, src_path) in enumerate(zip(src_names, src_paths)):
+        tgt_name = src_name.replace(suffix, save_seg_map_suffix)
+        tgt_path = os.path.join(tgt_dir, tgt_name)
+
+        img = np.array(Image.open(src_path))
+        img = convert_label(img, convert_dict)
+        Image.fromarray(img).save(tgt_path)
+        print(f'processed {i+1}/{num}.')
+
+
+if __name__ == '__main__':
+
+    convert_pics_into_pngs(
+        src_img_train_dir, tgt_img_train_dir, suffix=img_suffix)
+
+    convert_pics_into_pngs(
+        src_img_test_dir, tgt_img_test_dir, suffix=img_suffix)
+
+    convert_label_pics_into_pngs(
+        src_mask_train_dir, tgt_mask_train_dir, suffix=seg_map_suffix)
+
+    convert_label_pics_into_pngs(
+        src_mask_test_dir, tgt_mask_test_dir, suffix=seg_map_suffix)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/README.md b/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/README.md
new file mode 100644
index 0000000..97c4a0f
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/README.md
@@ -0,0 +1,123 @@
+# breastCancerCellSegmentation
+
+## Description
+
+This project supports **`breastCancerCellSegmentation`**, which can be downloaded from [here](https://www.heywhale.com/mw/dataset/5e9e9b35ebb37f002c625423).
+
+### Dataset Overview
+
+This dataset, with 58 H&E-stained histopathology images was used for breast cancer cell detection and associated real-world data.
+Conventional histology uses a combination of hematoxylin and eosin stains, commonly referred to as H&E. These images are stained because most cells are inherently transparent with little or no intrinsic pigment.
+Certain special stains selectively bind to specific components and can be used to identify biological structures such as cells.
+
+### Original Statistic Information
+
+| Dataset name                                                                                 | Anatomical region | Task type    | Modality       | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                         |
+| -------------------------------------------------------------------------------------------- | ----------------- | ------------ | -------------- | ------------ | --------------------- | ---------------------- | ------------ | --------------------------------------------------------------- |
+| [breastCancerCellSegmentation](https://www.heywhale.com/mw/dataset/5e9e9b35ebb37f002c625423) | cell              | segmentation | histopathology | 2            | 58/-/-                | yes/-/-                | 2020         | [CC-BY-NC 4.0](https://creativecommons.org/licenses/by-sa/4.0/) |
+
+|    Class Name    | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+|    background    |     58     |   98.37    |    -     |    -     |     -     |     -     |
+| breastCancerCell |     58     |    1.63    |    -     |    -     |     -     |     -     |
+
+Note:
+
+- `Pct` means percentage of pixels in this category in all pixels.
+
+### Visualization
+
+![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/histopathology/breastCancerCellSegmentation/breastCancerCellSegmentation_dataset.png)
+
+## Usage
+
+### Prerequisites
+
+- Python v3.8
+- PyTorch v1.10.0
+- pillow (PIL) v9.3.0
+- scikit-learn (sklearn) v1.2.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0
+
+All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `breastCancerCellSegmentation/` root directory, run the following line to add the current directory to `PYTHONPATH`:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset Preparing
+
+- Download dataset from [here](https://www.heywhale.com/mw/dataset/5e9e9b35ebb37f002c625423) and save it to the `data/` directory .
+- Decompress data to path `data/`. This will create a new folder named `data/breastCancerCellSegmentation/`, which contains the original image data.
+- run script `python tools/prepare_dataset.py` to format data and change folder structure as below.
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── histopathology
+  │   │   │   │   ├── breastCancerCellSegmentation
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── breastCancerCellSegmentation
+  |   │   │   │   │   │   │   ├── train.txt
+  |   │   │   │   │   │   │   ├── val.txt
+  |   │   │   │   │   │   │   ├── images
+  |   │   │   │   │   │   │   |   ├── xxx.tif
+  |   │   │   │   │   │   │   ├── masks
+  |   │   │   │   │   │   │   |   ├── xxx.TIF
+
+```
+
+### Training commands
+
+Train models on a single server with one GPU.
+
+```shell
+mim train mmseg ./configs/${CONFIG_FILE}
+```
+
+### Testing commands
+
+Test models on a single server with one GPU.
+
+```shell
+mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+
+  - [x] Basic docstrings & proper citation
+
+  - [x] Test-time correctness
+
+  - [x] A full README
+
+- [ ] Milestone 2: Indicates a successful model implementation.
+
+  - [ ] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+
+  - [ ] Unit tests
+
+  - [ ] Code polishing
+
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/breastCancerCellSegmentation_512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/breastCancerCellSegmentation_512x512.py
new file mode 100644
index 0000000..1cf0fcc
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/breastCancerCellSegmentation_512x512.py
@@ -0,0 +1,42 @@
+dataset_type = 'breastCancerCellSegmentationDataset'
+data_root = 'data/breastCancerCellSegmentation'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile', imdecode_backend='tifffile'),
+    dict(type='LoadAnnotations', imdecode_backend='tifffile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile', imdecode_backend='tifffile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations', imdecode_backend='tifffile'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='train.txt',
+        data_prefix=dict(img_path='images', seg_map_path='masks'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='val.txt',
+        data_prefix=dict(img_path='images', seg_map_path='masks'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_breastCancerCellSegmentation-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_breastCancerCellSegmentation-512x512.py
new file mode 100644
index 0000000..55d1708
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_breastCancerCellSegmentation-512x512.py
@@ -0,0 +1,18 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    './breastCancerCellSegmentation_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.breastCancerCellSegmentation_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_breastCancerCellSegmentation-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_breastCancerCellSegmentation-512x512.py
new file mode 100644
index 0000000..cf28aad
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_breastCancerCellSegmentation-512x512.py
@@ -0,0 +1,18 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    './breastCancerCellSegmentation_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.breastCancerCellSegmentation_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_breastCancerCellSegmentation-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_breastCancerCellSegmentation-512x512.py
new file mode 100644
index 0000000..29aaff3
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_breastCancerCellSegmentation-512x512.py
@@ -0,0 +1,18 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    './breastCancerCellSegmentation_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.breastCancerCellSegmentation_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/datasets/breastCancerCellSegmentation_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/datasets/breastCancerCellSegmentation_dataset.py
new file mode 100644
index 0000000..eeceb63
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/datasets/breastCancerCellSegmentation_dataset.py
@@ -0,0 +1,30 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class breastCancerCellSegmentationDataset(BaseSegDataset):
+    """breastCancerCellSegmentationDataset dataset.
+
+    In segmentation map annotation for breastCancerCellSegmentationDataset,
+    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
+    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
+
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+        reduce_zero_label (bool): Whether to mark label zero as ignored.
+            Default to False.
+    """
+    METAINFO = dict(classes=('background', 'breastCancerCell'))
+
+    def __init__(self,
+                 img_suffix='_ccd.tif',
+                 seg_map_suffix='.TIF',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/tools/prepare_dataset.py
new file mode 100644
index 0000000..09cc689
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/tools/prepare_dataset.py
@@ -0,0 +1,36 @@
+import argparse
+import glob
+import os
+
+from sklearn.model_selection import train_test_split
+
+
+def save_anno(img_list, file_path, suffix):
+    # 只保留文件名，不保留后缀
+    img_list = [x.split('/')[-1][:-len(suffix)] for x in img_list]
+
+    with open(file_path, 'w') as file_:
+        for x in list(img_list):
+            file_.write(x + '\n')
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        '--data_root', default='data/breastCancerCellSegmentation/')
+    args = parser.parse_args()
+    data_root = args.data_root
+
+    # 1. 划分训练集、验证集
+    # 1.1 获取所有图片路径
+    img_list = glob.glob(os.path.join(data_root, 'images', '*.tif'))
+    img_list.sort()
+    mask_list = glob.glob(os.path.join(data_root, 'masks', '*.TIF'))
+    mask_list.sort()
+    assert len(img_list) == len(mask_list)
+    # 1.2 划分训练集、验证集、测试集
+    train_img_list, val_img_list, train_mask_list, val_mask_list = train_test_split(  # noqa
+        img_list, mask_list, test_size=0.2, random_state=42)
+    # 1.3 保存划分结果
+    save_anno(train_img_list, os.path.join(data_root, 'train.txt'), '_ccd.tif')
+    save_anno(val_img_list, os.path.join(data_root, 'val.txt'), '_ccd.tif')
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/README.md b/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/README.md
new file mode 100644
index 0000000..b6f1ca6
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/README.md
@@ -0,0 +1,147 @@
+# Breast Cancer Cell Segmentation
+
+## Description
+
+This project support **`Breast Cancer Cell Segmentation`**, and the dataset used in this project can be downloaded from [here](https://tianchi.aliyun.com/dataset/dataDetail?dataId=90152).
+
+### Dataset Overview
+
+In this dataset, there are 58 H&E stained histopathology images used in breast cancer cell detection with associated ground truth data available. Routine histology uses the stain combination of hematoxylin and eosin, commonly referred to as H&E. These images are stained since most cells are essentially transparent, with little or no intrinsic pigment. Certain special stains, which bind selectively to particular components, are be used to identify biological structures such as cells. In those images, the challenging problem is cell segmentation for subsequent classification in benign and malignant cells.
+
+### Original Statistic Information
+
+| Dataset name                                                                                  | Anatomical region | Task type    | Modality       | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                                                                |
+| --------------------------------------------------------------------------------------------- | ----------------- | ------------ | -------------- | ------------ | --------------------- | ---------------------- | ------------ | ------------------------------------------------------------------------------------------------------ |
+| [Breast Cancer Cell Segmentation](https://tianchi.aliyun.com/dataset/dataDetail?dataId=90152) | thorax            | segmentation | histopathology | 2            | 58/-/-                | yes/-/-                | 2021         | [CC-BY-SA-NC 4.0](http://creativecommons.org/licenses/by-sa/4.0/?spm=5176.12282016.0.0.3f5b5291ypBxb2) |
+
+|     Class Name     | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :----------------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+|       normal       |     58     |   98.37    |    -     |    -     |     -     |     -     |
+| breast cancer cell |     58     |    1.63    |    -     |    -     |     -     |     -     |
+
+Note:
+
+- `Pct` means percentage of pixels in this category in all pixels.
+
+### Visualization
+
+![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/histopathology/breast_cancer_cell_seg/breast_cancer_cell_seg_dataset.png)
+
+## Dataset Citation
+
+```
+@inproceedings{gelasca2008evaluation,
+  title={Evaluation and benchmark for biological image segmentation},
+  author={Gelasca, Elisa Drelie and Byun, Jiyun and Obara, Boguslaw and Manjunath, BS},
+  booktitle={2008 15th IEEE international conference on image processing},
+  pages={1816--1819},
+  year={2008},
+  organization={IEEE}
+}
+```
+
+### Prerequisites
+
+- Python v3.8
+- PyTorch v1.10.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+
+All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `breast_cancer_cell_seg/` root directory, run the following line to add the current directory to `PYTHONPATH`:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset preparing
+
+- download dataset from [here](https://tianchi.aliyun.com/dataset/dataDetail?dataId=90152) and decompression data to path `'data/'`.
+- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
+- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set can't be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── histopathology
+  │   │   │   │   ├── breast_cancer_cell_seg
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── train.txt
+  │   │   │   │   │   │   ├── val.txt
+  │   │   │   │   │   │   ├── images
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   ├── masks
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+```
+
+### Divided Dataset Information
+
+***Note: The table information below is divided by ourselves.***
+
+|  Class Name  | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :----------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+|  background  |     46     |   98.36    |    12    |  98.41   |     -     |     -     |
+| erythrocytes |     46     |    1.64    |    12    |   1.59   |     -     |     -     |
+
+### Training commands
+
+Train models on a single server with one GPU.
+
+```shell
+mim train mmseg ./configs/${CONFIG_FILE}
+```
+
+### Testing commands
+
+Test models on a single server with one GPU.
+
+```shell
+mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
+
+You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+
+  - [x] Basic docstrings & proper citation
+
+  - [x] Test-time correctness
+
+  - [x] A full README
+
+- [ ] Milestone 2: Indicates a successful model implementation.
+
+  - [ ] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+
+  - [ ] Unit tests
+
+  - [ ] Code polishing
+
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/breast-cancer-cell-seg_512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/breast-cancer-cell-seg_512x512.py
new file mode 100644
index 0000000..ead40e4
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/breast-cancer-cell-seg_512x512.py
@@ -0,0 +1,42 @@
+dataset_type = 'BreastCancerCellSegDataset'
+data_root = 'data/'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='train.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='val.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_breast-cancer-cell-seg-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_breast-cancer-cell-seg-512x512.py
new file mode 100644
index 0000000..691a0ff
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_breast-cancer-cell-seg-512x512.py
@@ -0,0 +1,18 @@
+_base_ = [
+    './breast-cancer-cell-seg_512x512.py',
+    'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.breast-cancer-cell-seg_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_breast-cancer-cell-seg-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_breast-cancer-cell-seg-512x512.py
new file mode 100644
index 0000000..719b767
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_breast-cancer-cell-seg-512x512.py
@@ -0,0 +1,18 @@
+_base_ = [
+    './breast-cancer-cell-seg_512x512.py',
+    'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.breast-cancer-cell-seg_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_breast-cancer-cell-seg-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_breast-cancer-cell-seg-512x512.py
new file mode 100644
index 0000000..9dfe70f
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_breast-cancer-cell-seg-512x512.py
@@ -0,0 +1,18 @@
+_base_ = [
+    './breast-cancer-cell-seg_512x512.py',
+    'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.breast-cancer-cell-seg_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/datasets/breast-cancer-cell-seg_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/datasets/breast-cancer-cell-seg_dataset.py
new file mode 100644
index 0000000..6f27029
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/datasets/breast-cancer-cell-seg_dataset.py
@@ -0,0 +1,29 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class BreastCancerCellSegDataset(BaseSegDataset):
+    """BreastCancerCellSegDataset dataset.
+
+    In segmentation map annotation for BreastCancerCellSegDataset,
+    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
+    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
+
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+        reduce_zero_label (bool): Whether to mark label zero as ignored.
+            Default to False.
+    """
+    METAINFO = dict(classes=('normal', 'breast cancer cell'))
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=False,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/tools/prepare_dataset.py
new file mode 100755
index 0000000..775f2ee
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/tools/prepare_dataset.py
@@ -0,0 +1,47 @@
+import glob
+import os
+
+import numpy as np
+from PIL import Image
+
+root_path = 'data/'
+img_suffix = '.tif'
+seg_map_suffix = '.TIF'
+save_img_suffix = '.png'
+save_seg_map_suffix = '.png'
+
+x_train = glob.glob(
+    os.path.join('data/Breast Cancer Cell Segmentation_datasets/Images/*' +
+                 img_suffix))
+
+os.system('mkdir -p ' + root_path + 'images/train/')
+os.system('mkdir -p ' + root_path + 'masks/train/')
+
+D2_255_convert_dict = {0: 0, 255: 1}
+
+
+def convert_2d(img, convert_dict=D2_255_convert_dict):
+    arr_2d = np.zeros((img.shape[0], img.shape[1]), dtype=np.uint8)
+    for c, i in convert_dict.items():
+        arr_2d[img == c] = i
+    return arr_2d
+
+
+part_dir_dict = {0: 'train/'}
+for ith, part in enumerate([x_train]):
+    part_dir = part_dir_dict[ith]
+    for img in part:
+        basename = os.path.basename(img)
+        img_save_path = root_path + 'images/' + part_dir + basename.split(
+            '.')[0] + save_img_suffix
+        Image.open(img).save(img_save_path)
+        mask_path = root_path + 'Breast Cancer Cell Segmentation_datasets/Masks/' + '_'.join(  # noqa
+            basename.split('_')[:-1]) + seg_map_suffix
+        label = np.array(Image.open(mask_path))
+
+        save_mask_path = root_path + 'masks/' + part_dir + basename.split(
+            '.')[0] + save_seg_map_suffix
+        assert len(label.shape) == 2 and 255 in label and 1 not in label
+        mask = convert_2d(label)
+        mask = Image.fromarray(mask.astype(np.uint8))
+        mask.save(save_mask_path)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/README.md b/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/README.md
new file mode 100644
index 0000000..1f55b44
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/README.md
@@ -0,0 +1,207 @@
+# CoNIC: Colon Nuclei Identification and Counting Challenge
+
+## Description
+
+This project supports **`CoNIC: Colon Nuclei Identification and Counting Challenge`**, which can be downloaded from [here](https://drive.google.com/drive/folders/1il9jG7uA4-ebQ_lNmXbbF2eOK9uNwheb).
+
+### Dataset Overview
+
+Nuclear segmentation, classification and quantification within Haematoxylin & Eosin stained histology images enables the extraction of interpretable cell-based features that can be used in downstream explainable models in computational pathology (CPath). To help drive forward research and innovation for automatic nuclei recognition in CPath, we organise the Colon Nuclei Identification and Counting (CoNIC) Challenge. The challenge requires researchers to develop algorithms that perform segmentation, classification and counting of 6 different types of nuclei within the current largest known publicly available nuclei-level dataset in CPath, containing around half a million labelled nuclei.
+
+### Task Information
+
+The CONIC challenge has 2 tasks:
+
+- Task 1: Nuclear segmentation and classification.
+
+The first task requires participants to segment nuclei within the tissue, while also classifying each nucleus into one of the following categories: epithelial, lymphocyte, plasma, eosinophil, neutrophil or connective tissue.
+
+- Task 2: Prediction of cellular composition.
+
+For the second task, we ask participants to predict how many nuclei of each class are present in each input image.
+
+The output of Task 1 can be directly used to perform Task 2, but these can be treated as independent tasks. Therefore, if it is preferred, prediction of cellular composition can be treated as a stand alone regression task.
+
+***NOTE：We only consider `Task 1` in the following sections.***
+
+### Original Statistic Information
+
+| Dataset name                                             | Anatomical region | Task type    | Modality       | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                                                                      |
+| -------------------------------------------------------- | ----------------- | ------------ | -------------- | ------------ | --------------------- | ---------------------- | ------------ | ------------------------------------------------------------------------------------------------------------ |
+| [CoNIC202](https://conic-challenge.grand-challenge.org/) | abdomen           | segmentation | histopathology | 7            | 4981/-/-              | yes/-/-                | 2022         | [Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/) |
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |    4981    |   83.97    |    -     |    -     |     -     |     -     |
+| neutrophil |    1218    |    0.13    |    -     |    -     |     -     |     -     |
+| epithelial |    4256    |   10.31    |    -     |    -     |     -     |     -     |
+| lymphocyte |    4473    |    1.85    |    -     |    -     |     -     |     -     |
+|   plasma   |    3316    |    0.55    |    -     |    -     |     -     |     -     |
+| eosinophil |    1456    |    0.1     |    -     |    -     |     -     |     -     |
+| connective |    4613    |    3.08    |    -     |    -     |     -     |     -     |
+
+Note:
+
+- `Pct` means percentage of pixels in this category in all pixels.
+
+### Visualization
+
+![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/histopathology/conic2022_seg/conic2022_seg_dataset.png)
+
+### Prerequisites
+
+- Python v3.8
+- PyTorch v1.10.0
+- pillow(PIL) v9.3.0
+- scikit-learn(sklearn) v1.2.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+
+All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `conic2022_seg/` root directory, run the following line to add the current directory to `PYTHONPATH`:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset preparing
+
+- download dataset from [here](https://drive.google.com/drive/folders/1il9jG7uA4-ebQ_lNmXbbF2eOK9uNwheb/) and move data to path `'data/CoNIC_Challenge'`. The directory should be like:
+  ```shell
+  data/CoNIC_Challenge
+        ├── README.txt
+        ├── by-nc-sa.md
+        ├── counts.csv
+        ├── images.npy
+        ├── labels.npy
+        └── patch_info.csv
+  ```
+- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
+- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set can't be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── histopathology
+  │   │   │   │   ├── conic2022_seg
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── train.txt
+  │   │   │   │   │   │   ├── val.txt
+  │   │   │   │   │   │   ├── images
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   ├── masks
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+```
+
+### Divided Dataset Information
+
+***Note: The table information below is divided by ourselves.***
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |    3984    |   84.06    |   997    |  83.65   |     -     |     -     |
+| neutrophil |    956     |    0.12    |   262    |   0.13   |     -     |     -     |
+| epithelial |    3400    |   10.26    |   856    |  10.52   |     -     |     -     |
+| lymphocyte |    3567    |    1.83    |   906    |   1.96   |     -     |     -     |
+|   plasma   |    2645    |    0.55    |   671    |   0.56   |     -     |     -     |
+| eosinophil |    1154    |    0.1     |   302    |   0.1    |     -     |     -     |
+| connective |    3680    |    3.08    |   933    |   3.08   |     -     |     -     |
+
+### Training commands
+
+Train models on a single server with one GPU.
+
+```shell
+mim train mmseg ./configs/${CONFIG_FILE}
+```
+
+### Testing commands
+
+Test models on a single server with one GPU.
+
+```shell
+mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
+
+You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
+
+## Organizers
+
+- Simon Graham (TIA, PathLAKE)
+- Mostafa Jahanifar (TIA, PathLAKE)
+- Dang Vu (TIA)
+- Giorgos Hadjigeorghiou (TIA, PathLAKE)
+- Thomas Leech (TIA, PathLAKE)
+- David Snead (UHCW, PathLAKE)
+- Shan Raza (TIA, PathLAKE)
+- Fayyaz Minhas (TIA, PathLAKE)
+- Nasir Rajpoot (TIA, PathLAKE)
+
+TIA: Tissue Image Analytics Centre, Department of Computer Science, University of Warwick, United Kingdom
+
+UHCW: Department of Pathology, University Hospitals Coventry and Warwickshire, United Kingdom
+
+PathLAKE: Pathology Image Data Lake for Analytics Knowledge & Education, , University Hospitals Coventry and Warwickshire, United Kingdom
+
+## Dataset Citation
+
+If this work is helpful for your research, please consider citing the below paper.
+
+```
+@inproceedings{graham2021lizard,
+  title={Lizard: A large-scale dataset for colonic nuclear instance segmentation and classification},
+  author={Graham, Simon and Jahanifar, Mostafa and Azam, Ayesha and Nimir, Mohammed and Tsang, Yee-Wah and Dodd, Katherine and Hero, Emily and Sahota, Harvir and Tank, Atisha and Benes, Ksenija and others},
+  booktitle={Proceedings of the IEEE/CVF International Conference on Computer Vision},
+  pages={684--693},
+  year={2021}
+}
+@article{graham2021conic,
+  title={Conic: Colon nuclei identification and counting challenge 2022},
+  author={Graham, Simon and Jahanifar, Mostafa and Vu, Quoc Dang and Hadjigeorghiou, Giorgos and Leech, Thomas and Snead, David and Raza, Shan E Ahmed and Minhas, Fayyaz and Rajpoot, Nasir},
+  journal={arXiv preprint arXiv:2111.14485},
+  year={2021}
+}
+```
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+
+  - [x] Basic docstrings & proper citation
+
+  - [x] A full README
+
+- [ ] Milestone 2: Indicates a successful model implementation.
+
+  - [ ] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+
+  - [ ] Unit tests
+
+  - [ ] Code polishing
+
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/conic2022-seg_512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/conic2022-seg_512x512.py
new file mode 100644
index 0000000..51b4e57
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/conic2022-seg_512x512.py
@@ -0,0 +1,42 @@
+dataset_type = 'Conic2022SegDataset'
+data_root = 'data/'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='train.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='val.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_conic2022-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_conic2022-512x512.py
new file mode 100644
index 0000000..3e0248c
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_conic2022-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    './conic2022-seg_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.conic2022-seg_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=7),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_conic2022-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_conic2022-512x512.py
new file mode 100644
index 0000000..fd0e9d8
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_conic2022-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    './conic2022-seg_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.conic2022-seg_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=7),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_conic2022-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_conic2022-512x512.py
new file mode 100644
index 0000000..bb667f1
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_conic2022-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    './conic2022-seg_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.conic2022-seg_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=7),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/datasets/conic2022-seg_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/datasets/conic2022-seg_dataset.py
new file mode 100644
index 0000000..9af0958
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/datasets/conic2022-seg_dataset.py
@@ -0,0 +1,29 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class Conic2022SegDataset(BaseSegDataset):
+    """Conic2022SegDataset dataset.
+
+    In segmentation map annotation for Conic2022SegDataset,
+    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
+    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
+
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+    """
+    METAINFO = dict(
+        classes=('background', 'neutrophil', 'epithelial', 'lymphocyte',
+                 'plasma', 'eosinophil', 'connective'))
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=False,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/tools/prepare_dataset.py
new file mode 100755
index 0000000..89cfb4a
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/tools/prepare_dataset.py
@@ -0,0 +1,65 @@
+import glob
+import os
+import shutil
+
+import numpy as np
+from PIL import Image
+
+img_save_root = 'data/'
+root_path = 'data/'
+img_suffix = '.png'
+seg_map_suffix = '.png'
+save_img_suffix = '.png'
+save_seg_map_suffix = '.png'
+
+label_set = set()
+
+
+def save_masks_from_npz(data, save_root, part='masks/'):
+    global label_set
+    num = data.shape[0]
+    for i in range(num):
+        # np_img = data[i, :, :, :]
+        np_mask = data[i, :, :, 1]
+        label_set = set.union(label_set, set(np.unique(np_mask)))
+        img = Image.fromarray(np_mask)
+        save_path = os.path.join(save_root, part, str(i) + save_seg_map_suffix)
+        img.save(save_path)
+
+
+def save_images_from_npz(data, save_root, part='images/'):
+    num = data.shape[0]
+    for i in range(num):
+        np_img = data[i, :, :, :]
+        img = Image.fromarray(np_img)
+        save_path = os.path.join(save_root, part, str(i) + save_img_suffix)
+        img.save(save_path)
+
+
+images_npy = np.load('data/CoNIC_Challenge/images.npy')
+labels_npy = np.load('data/CoNIC_Challenge/labels.npy')
+
+os.system('mkdir -p ' + img_save_root + 'images_ori')
+os.system('mkdir -p ' + img_save_root + 'labels')
+save_images_from_npz(images_npy, img_save_root, 'images_ori')
+save_masks_from_npz(labels_npy, img_save_root, 'labels')
+print(label_set)
+
+x_train = glob.glob(os.path.join('data/images_ori/*' + img_suffix))
+
+os.system('mkdir -p ' + root_path + 'images/train/')
+os.system('mkdir -p ' + root_path + 'masks/train/')
+
+part_dir_dict = {0: 'train/', 1: 'val/'}
+for ith, part in enumerate([x_train]):
+    part_dir = part_dir_dict[ith]
+    for img in part:
+        basename = os.path.basename(img)
+        shutil.copy(
+            img, root_path + 'images/' + part_dir + basename.split('.')[0] +
+            save_img_suffix)
+        mask_path = root_path + 'labels/' + basename.split(
+            '.')[0] + seg_map_suffix
+        save_mask_path = root_path + 'masks/' + part_dir + basename.split(
+            '.')[0] + save_seg_map_suffix
+        shutil.copy(mask_path, save_mask_path)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/consep/README.md b/mmsegmentation/projects/medical/2d_image/histopathology/consep/README.md
new file mode 100644
index 0000000..ca3d7aa
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/consep/README.md
@@ -0,0 +1,147 @@
+# Colorectal Nuclear Segmentation and Phenotypes (CoNSeP) Dataset
+
+## Description
+
+This project supports **`Colorectal Nuclear Segmentation and Phenotypes (CoNSeP) Dataset`**, which can be downloaded from [here](https://warwick.ac.uk/fac/cross_fac/tia/data/hovernet/).
+
+### Dataset Overview
+
+The CoNSeP (Colon Segmentation and Phenotyping) dataset consists of 41 H&E stained image tiles, each with a size of 1,000×1,000 pixels and a magnification of 40x. These images were extracted from 16 colorectal adenocarcinoma (CRA) whole slide images (WSI), each of which belonged to a separate patient and was scanned using an Omnyx VL120 scanner at the Pathology Department of the University Hospitals Coventry and Warwickshire NHS Trust, UK. This dataset was first used in  paper named, "HoVer-Net: Simultaneous Segmentation and Classification of Nuclei in Multi-Tissue Histology Images".
+
+### Original Statistic Information
+
+| Dataset name                                             | Anatomical region | Task type    | Modality       | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License |
+| -------------------------------------------------------- | ----------------- | ------------ | -------------- | ------------ | --------------------- | ---------------------- | ------------ | ------- |
+| [CoNIC202](https://conic-challenge.grand-challenge.org/) | abdomen           | segmentation | histopathology | 7            | 4981/-/-              | yes/-/-                | 2022         | -       |
+
+|           Class Name            | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :-----------------------------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+|           background            |     27     |   83.61    |    14    |   80.4   |     -     |     -     |
+|              other              |     17     |    0.17    |    9     |   0.52   |     -     |     -     |
+|          inflammatory           |     25     |    2.66    |    14    |   2.14   |     -     |     -     |
+|       healthy epithelial        |     3      |    1.47    |    2     |   1.58   |     -     |     -     |
+| dysplastic/malignant epithelial |     10     |    7.17    |    8     |   9.16   |     -     |     -     |
+|           fibroblast            |     23     |    3.84    |    14    |   4.63   |     -     |     -     |
+|             muscle              |     8      |    1.05    |    3     |   1.42   |     -     |     -     |
+|           endothelial           |     7      |    0.02    |    4     |   0.15   |     -     |     -     |
+
+Note:
+
+- `Pct` means percentage of pixels in this category in all pixels.
+
+### Visualization
+
+![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/histopathology/consep/consep_dataset.png)
+
+### Prerequisites
+
+- Python v3.8
+- PyTorch v1.10.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+
+All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `conic2022_seg/` root directory, run the following line to add the current directory to `PYTHONPATH`:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset preparing
+
+- download dataset from [here](https://opendatalab.com/CoNSeP) and decompress data to path `'data/'`.
+- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
+- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set can't be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── histopathology
+  │   │   │   │   ├── consep
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── train.txt
+  │   │   │   │   │   │   ├── val.txt
+  │   │   │   │   │   │   ├── images
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   ├── masks
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+```
+
+### Training commands
+
+Train models on a single server with one GPU.
+
+```shell
+mim train mmseg ./configs/${CONFIG_FILE}
+```
+
+### Testing commands
+
+Test models on a single server with one GPU.
+
+```shell
+mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
+
+You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
+
+## Dataset Citation
+
+If this work is helpful for your research, please consider citing the below paper.
+
+```
+@article{graham2019hover,
+  title={Hover-net: Simultaneous segmentation and classification of nuclei in multi-tissue histology images},
+  author={Graham, Simon and Vu, Quoc Dang and Raza, Shan E Ahmed and Azam, Ayesha and Tsang, Yee Wah and Kwak, Jin Tae and Rajpoot, Nasir},
+  journal={Medical Image Analysis},
+  volume={58},
+  pages={101563},
+  year={2019},
+  publisher={Elsevier}
+}
+```
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+
+  - [x] Basic docstrings & proper citation
+
+  - [x] Test-time correctness
+
+  - [x] A full README
+
+- [ ] Milestone 2: Indicates a successful model implementation.
+
+  - [ ] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+
+  - [ ] Unit tests
+
+  - [ ] Code polishing
+
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/consep_512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/consep_512x512.py
new file mode 100644
index 0000000..0d9b894
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/consep_512x512.py
@@ -0,0 +1,42 @@
+dataset_type = 'ConsepDataset'
+data_root = 'data/'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='train.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='val.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_consep-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_consep-512x512.py
new file mode 100644
index 0000000..cbcf5db
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_consep-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    './consep_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.consep_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=8),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_consep-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_consep-512x512.py
new file mode 100644
index 0000000..b374566
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_consep-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    './consep_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.consep_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=8),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_consep-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_consep-512x512.py
new file mode 100644
index 0000000..35bdaa3
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_consep-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    './consep_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.consep_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=8),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/consep/datasets/consep_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/consep/datasets/consep_dataset.py
new file mode 100644
index 0000000..ceb2b3a
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/consep/datasets/consep_dataset.py
@@ -0,0 +1,30 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class ConsepDataset(BaseSegDataset):
+    """ConsepDataset dataset.
+
+    In segmentation map annotation for ConsepDataset,
+    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
+    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
+
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+    """
+    METAINFO = dict(
+        classes=('background', 'other', 'inflammatory', 'healthy epithelial',
+                 'dysplastic/malignant epithelial', 'fibroblast', 'muscle',
+                 'endothelial'))
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=False,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/consep/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/consep/tools/prepare_dataset.py
new file mode 100755
index 0000000..83a2e18
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/consep/tools/prepare_dataset.py
@@ -0,0 +1,54 @@
+import glob
+import os
+import shutil
+
+import numpy as np
+from PIL import Image
+from scipy.io import loadmat
+
+root_path = 'data/'
+img_suffix = '.png'
+seg_map_suffix = '.mat'
+save_img_suffix = '.png'
+save_seg_map_suffix = '.png'
+
+x_train = glob.glob(os.path.join('data/CoNSeP/Train/Images/*' + img_suffix))
+x_test = glob.glob(os.path.join('data/CoNSeP/Test/Images/*' + img_suffix))
+
+os.system('mkdir -p ' + root_path + 'images/train/')
+os.system('mkdir -p ' + root_path + 'images/val/')
+os.system('mkdir -p ' + root_path + 'masks/train/')
+os.system('mkdir -p ' + root_path + 'masks/val/')
+D2_255_convert_dict = {0: 0, 255: 1}
+
+
+def convert_2d(img, convert_dict=D2_255_convert_dict):
+    arr_2d = np.zeros((img.shape[0], img.shape[1]), dtype=np.uint8)
+    for c, i in convert_dict.items():
+        arr_2d[img == c] = i
+    return arr_2d
+
+
+part_dir_dict = {0: 'CoNSeP/Train/', 1: 'CoNSeP/Test/'}
+save_dir_dict = {0: 'train/', 1: 'val/'}
+for ith, part in enumerate([x_train, x_test]):
+    part_dir = part_dir_dict[ith]
+    for img in part:
+        basename = os.path.basename(img)
+        shutil.copy(
+            img, root_path + 'images/' + save_dir_dict[ith] +
+            basename.split('.')[0] + save_img_suffix)
+
+        mask_path = root_path + part_dir + 'Labels/' + basename.split(
+            '.')[0] + seg_map_suffix
+        label_ = loadmat(mask_path)
+        label = label_['inst_map']
+        label_type = label_['inst_type']
+        label_dict = {i + 1: int(val) for i, val in enumerate(label_type)}
+
+        save_mask_path = root_path + 'masks/' + save_dir_dict[
+            ith] + basename.split('.')[0] + save_seg_map_suffix
+
+        res = convert_2d(label, convert_dict=label_dict)
+        res = Image.fromarray(res.astype(np.uint8))
+        res.save(save_mask_path)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/README.md b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/README.md
new file mode 100644
index 0000000..8130d59
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/README.md
@@ -0,0 +1,136 @@
+# Foot Ulcer Segmentation Challenge 2021 (FUSC 2021)
+
+## Description
+
+This project supports **`Foot Ulcer Segmentation Challenge 2021 (FUSC 2021) `**, which can be downloaded from [here](https://fusc.grand-challenge.org/).
+
+### Dataset Overview
+
+This chronic wound dataset was collected over 2 years from October 2019 to April 2021 at the center and contains 1,210 foot ulcer images taken from 889 patients during multiple clinical visits. The raw images were taken by Canon SX 620 HS digital camera and iPad Pro under uncontrolled illumination conditions,
+with various backgrounds. The images (shown in Figure 1) are randomly split into 3 subsets: a training set with 810 images, a validation set with 200 images, and a testing set with 200 images. Of course, the annotations of the testing set are kept private. The data collected were de-identified and in accordance with relevant guidelines and regulations and the patient’s informed consent is waived by the institutional review board of the University of Wisconsin-Milwaukee.
+
+### Information Statistics
+
+| Dataset Name                                  | Anatomical Region | Task Type    | Modality       | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                       |
+| --------------------------------------------- | ----------------- | ------------ | -------------- | ------------ | --------------------- | ---------------------- | ------------ | ------------------------------------------------------------- |
+| [fusc2021](https://fusc.grand-challenge.org/) | lower limb        | segmentation | histopathology | 2            | 810/200/200           | yes/yes/no             | 2021         | [CC0 1.0](https://creativecommons.org/publicdomain/zero/1.0/) |
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |    810     |   98.71    |   200    |  98.78   |     -     |     -     |
+|   wound    |    791     |    1.29    |   195    |   1.22   |     -     |     -     |
+
+Note:
+
+- `Pct` means percentage of pixels in this category in all pixels.
+
+### Visualization
+
+![fusc2021](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/histopathology/fusc2021/fusc2021_dataset.png?raw=true)
+
+### Dataset Citation
+
+```
+@article{s41598-020-78799-w,
+	title={Fully automatic wound segmentation with deep convolutional neural networks},
+	author={Chuanbo Wang and D. M. Anisuzzaman and Victor Williamson and Mrinal Kanti Dhar and Behrouz Rostami and Jeffrey Niezgoda and Sandeep Gopalakrishnan and Zeyun Yu},
+	journal={Scientific Reports},
+	volume={10},
+	number={1},
+	pages={21897},
+	year={2020}
+}
+```
+
+### Prerequisites
+
+- Python v3.8
+- PyTorch v1.10.0
+- pillow(PIL) v9.3.0
+- scikit-learn(sklearn) v1.2.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+
+All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `fusc2021/` root directory, run the following line to add the current directory to `PYTHONPATH`:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset Preparing
+
+- download dataset from [here](https://fusc.grand-challenge.org/) and decompress data to path `'data/'`.
+- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
+- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set cannot be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── histopathology
+  │   │   │   │   ├── fusc2021
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── train.txt
+  │   │   │   │   │   │   ├── val.txt
+  │   │   │   │   │   │   ├── images
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   ├── masks
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+```
+
+### Training commands
+
+To train models on a single server with one GPU. (default)
+
+```shell
+mim train mmseg ./configs/${CONFIG_FILE}
+```
+
+### Testing commands
+
+To test models on a single server with one GPU. (default)
+
+```shell
+mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
+
+You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+  - [x] Basic docstrings & proper citation
+  - [ ] Test-time correctness
+  - [x] A full README
+
+- [ ] Milestone 2: Indicates a successful model implementation.
+
+  - [ ] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+  - [ ] Unit tests
+  - [ ] Code polishing
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_fusc2021-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_fusc2021-512x512.py
new file mode 100644
index 0000000..c3f4275
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_fusc2021-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './fusc2021_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.fusc2021_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_fusc2021-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_fusc2021-512x512.py
new file mode 100644
index 0000000..ed87030
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_fusc2021-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './fusc2021_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.fusc2021_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_fusc2021-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_fusc2021-512x512.py
new file mode 100644
index 0000000..cbc09ae
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_fusc2021-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './fusc2021_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.fusc2021_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_fusc2021-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_fusc2021-512x512.py
new file mode 100644
index 0000000..f1477ee
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_fusc2021-512x512.py
@@ -0,0 +1,18 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './fusc2021_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.fusc2021_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(
+        num_classes=2, loss_decode=dict(use_sigmoid=True), out_channels=1),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fusc2021_512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fusc2021_512x512.py
new file mode 100644
index 0000000..e650474
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fusc2021_512x512.py
@@ -0,0 +1,42 @@
+dataset_type = 'FUSC2021Dataset'
+data_root = 'data/'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='train.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='val.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/datasets/fusc2021_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/datasets/fusc2021_dataset.py
new file mode 100644
index 0000000..d331ac8
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/datasets/fusc2021_dataset.py
@@ -0,0 +1,30 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class FUSC2021Dataset(BaseSegDataset):
+    """FUSC2021Dataset dataset.
+
+    In segmentation map annotation for FUSC2021Dataset, 0 stands for background
+    , which is included in 2 categories. ``reduce_zero_label``
+    is fixed to False. The ``img_suffix`` is fixed to '.png' and
+    ``seg_map_suffix`` is fixed to '.png'.
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+        reduce_zero_label (bool): Whether to mark label zero as ignored.
+            Default to False..
+    """
+    METAINFO = dict(classes=('background', 'wound'))
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/tools/prepare_dataset.py
new file mode 100644
index 0000000..8f2de3d
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/tools/prepare_dataset.py
@@ -0,0 +1,114 @@
+import glob
+import os
+
+import numpy as np
+from PIL import Image
+
+root_path = 'data/'
+img_suffix = '.png'
+seg_map_suffix = '.png'
+save_img_suffix = '.png'
+save_seg_map_suffix = '.png'
+src_img_train_dir = os.path.join(
+    root_path, 'wound-segmentation/data/' +
+    'Foot Ulcer Segmentation Challenge/train/images')
+src_img_val_dir = os.path.join(
+    root_path, 'wound-segmentation/data/' +
+    'Foot Ulcer Segmentation Challenge/validation/images')
+src_img_test_dir = os.path.join(
+    root_path, 'wound-segmentation/data/' +
+    'Foot Ulcer Segmentation Challenge/test/images')
+src_mask_train_dir = os.path.join(
+    root_path, 'wound-segmentation/data/' +
+    'Foot Ulcer Segmentation Challenge/train/labels')
+src_mask_val_dir = os.path.join(
+    root_path, 'wound-segmentation/data/' +
+    'Foot Ulcer Segmentation Challenge/validation/labels')
+
+tgt_img_train_dir = os.path.join(root_path, 'images/train/')
+tgt_mask_train_dir = os.path.join(root_path, 'masks/train/')
+tgt_img_val_dir = os.path.join(root_path, 'images/val/')
+tgt_mask_val_dir = os.path.join(root_path, 'masks/val/')
+tgt_img_test_dir = os.path.join(root_path, 'images/test/')
+os.system('mkdir -p ' + tgt_img_train_dir)
+os.system('mkdir -p ' + tgt_img_val_dir)
+os.system('mkdir -p ' + tgt_img_test_dir)
+os.system('mkdir -p ' + tgt_mask_train_dir)
+os.system('mkdir -p ' + tgt_mask_val_dir)
+
+
+def filter_suffix_recursive(src_dir, suffix):
+    # filter out file names and paths in source directory
+    suffix = '.' + suffix if '.' not in suffix else suffix
+    file_paths = glob.glob(
+        os.path.join(src_dir, '**', '*' + suffix), recursive=True)
+    file_names = [_.split('/')[-1] for _ in file_paths]
+    return sorted(file_paths), sorted(file_names)
+
+
+def convert_label(img, convert_dict):
+    arr = np.zeros_like(img, dtype=np.uint8)
+    for c, i in convert_dict.items():
+        arr[img == c] = i
+    return arr
+
+
+def convert_pics_into_pngs(src_dir, tgt_dir, suffix, convert='RGB'):
+    if not os.path.exists(tgt_dir):
+        os.makedirs(tgt_dir)
+
+    src_paths, src_names = filter_suffix_recursive(src_dir, suffix=suffix)
+
+    for i, (src_name, src_path) in enumerate(zip(src_names, src_paths)):
+        tgt_name = src_name.replace(suffix, save_img_suffix)
+        tgt_path = os.path.join(tgt_dir, tgt_name)
+        num = len(src_paths)
+        img = np.array(Image.open(src_path))
+        if len(img.shape) == 2:
+            pil = Image.fromarray(img).convert(convert)
+        elif len(img.shape) == 3:
+            pil = Image.fromarray(img)
+        else:
+            raise ValueError('Input image not 2D/3D: ', img.shape)
+
+        pil.save(tgt_path)
+        print(f'processed {i+1}/{num}.')
+
+
+def convert_label_pics_into_pngs(src_dir,
+                                 tgt_dir,
+                                 suffix,
+                                 convert_dict={
+                                     0: 0,
+                                     255: 1
+                                 }):
+    if not os.path.exists(tgt_dir):
+        os.makedirs(tgt_dir)
+
+    src_paths, src_names = filter_suffix_recursive(src_dir, suffix=suffix)
+    num = len(src_paths)
+    for i, (src_name, src_path) in enumerate(zip(src_names, src_paths)):
+        tgt_name = src_name.replace(suffix, save_seg_map_suffix)
+        tgt_path = os.path.join(tgt_dir, tgt_name)
+
+        img = np.array(Image.open(src_path).convert('L'))
+        img = convert_label(img, convert_dict)
+        Image.fromarray(img).save(tgt_path)
+        print(f'processed {i+1}/{num}.')
+
+
+if __name__ == '__main__':
+
+    convert_pics_into_pngs(
+        src_img_train_dir, tgt_img_train_dir, suffix=img_suffix)
+
+    convert_pics_into_pngs(src_img_val_dir, tgt_img_val_dir, suffix=img_suffix)
+
+    convert_pics_into_pngs(
+        src_img_test_dir, tgt_img_test_dir, suffix=img_suffix)
+
+    convert_label_pics_into_pngs(
+        src_mask_train_dir, tgt_mask_train_dir, suffix=seg_map_suffix)
+
+    convert_label_pics_into_pngs(
+        src_mask_val_dir, tgt_mask_val_dir, suffix=seg_map_suffix)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/README.md b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/README.md
new file mode 100644
index 0000000..e0cade7
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/README.md
@@ -0,0 +1,146 @@
+# Pan-Cancer Histology Dataset for Nuclei Instance Segmentation and Classification (PanNuke)
+
+## Description
+
+This project supports **`Pan-Cancer Histology Dataset for Nuclei Instance Segmentation and Classification (PanNuke)`**, which can be downloaded from [here](https://academictorrents.com/details/99f2c7b57b95500711e33f2ee4d14c9fd7c7366c).
+
+### Dataset Overview
+
+Semi automatically generated nuclei instance segmentation and classification dataset with exhaustive nuclei labels across 19 different tissue types. The dataset consists of 481 visual fields, of which 312 are randomly sampled from more than 20K whole slide images at different magnifications, from multiple data sources. In total the dataset contains 205,343 labeled nuclei, each with an instance segmentation mask. Models trained on pannuke can aid in whole slide image tissue type segmentation, and generalise to new tissues. PanNuke demonstrates one of the first successfully semi-automatically generated datasets.
+
+### Statistic Information
+
+| Dataset Name                                                                             | Anatomical Region | Task Type    | Modality       | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                         |
+| ---------------------------------------------------------------------------------------- | ----------------- | ------------ | -------------- | ------------ | --------------------- | ---------------------- | ------------ | --------------------------------------------------------------- |
+| [Pannuke](https://academictorrents.com/details/99f2c7b57b95500711e33f2ee4d14c9fd7c7366c) | full_body         | segmentation | histopathology | 6            | 7901/-/-              | yes/-/-                | 2019         | [CC-BY-NC 4.0](https://creativecommons.org/licenses/by-sa/4.0/) |
+
+|        Class Name         | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :-----------------------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+|        background         |    7901    |   83.32    |    -     |    -     |     -     |     -     |
+|        neoplastic         |    4190    |    8.64    |    -     |    -     |     -     |     -     |
+| non-neoplastic epithelial |    4126    |    1.77    |    -     |    -     |     -     |     -     |
+|       inflammatory        |    6137    |    3.73    |    -     |    -     |     -     |     -     |
+|        connective         |    232     |    0.07    |    -     |    -     |     -     |     -     |
+|           dead            |    1528    |    2.47    |    -     |    -     |     -     |     -     |
+
+Note:
+
+- `Pct` means percentage of pixels in this category in all pixels.
+
+### Visualization
+
+![pannuke](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/histopathology/pannuke/pannuke_dataset.png?raw=true)
+
+### Dataset Citation
+
+```
+@inproceedings{gamper2019pannuke,
+  title={PanNuke: an open pan-cancer histology dataset for nuclei instance segmentation and classification},
+  author={Gamper, Jevgenij and Koohbanani, Navid Alemi and Benet, Ksenija and Khuram, Ali and Rajpoot, Nasir},
+  booktitle={European Congress on Digital Pathology},
+  pages={11--19},
+  year={2019},
+}
+```
+
+### Prerequisites
+
+- Python v3.8
+- PyTorch v1.10.0
+- pillow(PIL) v9.3.0 9.3.0
+- scikit-learn(sklearn) v1.2.0 1.2.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+
+All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `pannuke/` root directory, run the following line to add the current directory to `PYTHONPATH`:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset Preparing
+
+- download dataset from [here](https://academictorrents.com/details/99f2c7b57b95500711e33f2ee4d14c9fd7c7366c) and decompress data to path `'data/'`.
+- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
+- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set cannot be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── histopathology
+  │   │   │   │   ├── pannuke
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── train.txt
+  │   │   │   │   │   │   ├── val.txt
+  │   │   │   │   │   │   ├── images
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   ├── masks
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+```
+
+### Divided Dataset Information
+
+***Note: The table information below is divided by ourselves.***
+
+|        Class Name         | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :-----------------------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+|        background         |    6320    |   83.38    |   1581   |   83.1   |     -     |     -     |
+|        neoplastic         |    3339    |    8.55    |   851    |   9.0    |     -     |     -     |
+| non-neoplastic epithelial |    3293    |    1.77    |   833    |   1.76   |     -     |     -     |
+|       inflammatory        |    4914    |    3.72    |   1223   |   3.76   |     -     |     -     |
+|        connective         |    170     |    0.06    |    62    |   0.09   |     -     |     -     |
+|           dead            |    1235    |    2.51    |   293    |   2.29   |     -     |     -     |
+
+### Training commands
+
+To train models on a single server with one GPU. (default)
+
+```shell
+mim train mmseg ./configs/${CONFIG_FILE}
+```
+
+### Testing commands
+
+To test models on a single server with one GPU. (default)
+
+```shell
+mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+  - [x] Basic docstrings & proper citation
+  - [ ] Test-time correctness
+  - [x] A full README
+
+- [ ] Milestone 2: Indicates a successful model implementation.
+
+  - [ ] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+  - [ ] Unit tests
+  - [ ] Code polishing
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_bactteria-detection-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_bactteria-detection-512x512.py
new file mode 100644
index 0000000..92584e9
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_bactteria-detection-512x512.py
@@ -0,0 +1,18 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    './bactteria-detection_512x512.py', 'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.bactteria-detection_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(
+        num_classes=2, loss_decode=dict(use_sigmoid=True), out_channels=1),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_pannuke-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_pannuke-512x512.py
new file mode 100644
index 0000000..042a08c
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_pannuke-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './pannuke_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.pannuke_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=6),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_pannuke-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_pannuke-512x512.py
new file mode 100644
index 0000000..e92514c
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_pannuke-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './pannuke_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.pannuke_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=6),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_pannuke-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_pannuke-512x512.py
new file mode 100644
index 0000000..a9403c8
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_pannuke-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './pannuke_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.pannuke_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=6),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/pannuke_512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/pannuke_512x512.py
new file mode 100644
index 0000000..316ac1a
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/pannuke_512x512.py
@@ -0,0 +1,42 @@
+dataset_type = 'PanNukeDataset'
+data_root = 'data/'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='train.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='val.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/datasets/pannuke_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/datasets/pannuke_dataset.py
new file mode 100644
index 0000000..4d3c687
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/datasets/pannuke_dataset.py
@@ -0,0 +1,33 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class PanNukeDataset(BaseSegDataset):
+    """PanNukeDataset dataset.
+
+    In segmentation map annotation for PanNukeDataset,
+    0 stands for background, which is included in 6 categories.
+    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
+    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
+
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+        reduce_zero_label (bool): Whether to mark label zero as ignored.
+            Default to False.
+    """
+    METAINFO = dict(
+        classes=('background', 'neoplastic', 'non-neoplastic epithelial',
+                 'inflammatory', 'connective', 'dead'))
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/tools/prepare_dataset.py
new file mode 100644
index 0000000..7213b18
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/tools/prepare_dataset.py
@@ -0,0 +1,49 @@
+import os
+
+import numpy as np
+from PIL import Image
+
+root_path = 'data/'
+
+tgt_img_dir = os.path.join(root_path, 'images/train')
+tgt_mask_dir = os.path.join(root_path, 'masks/train')
+os.system('mkdir -p ' + tgt_img_dir)
+os.system('mkdir -p ' + tgt_mask_dir)
+
+fold_img_paths = sorted([
+    os.path.join(root_path, 'pannuke/Fold 1/images/fold1/images.npy'),
+    os.path.join(root_path, 'pannuke/Fold 2/images/fold2/images.npy'),
+    os.path.join(root_path, 'pannuke/Fold 3/images/fold3/images.npy')
+])
+
+fold_mask_paths = sorted([
+    os.path.join(root_path, 'pannuke/Fold 1/masks/fold1/masks.npy'),
+    os.path.join(root_path, 'pannuke/Fold 2/masks/fold2/masks.npy'),
+    os.path.join(root_path, 'pannuke/Fold 3/masks/fold3/masks.npy')
+])
+
+for n, (img_path,
+        mask_path) in enumerate(zip(fold_img_paths, fold_mask_paths)):
+    fold_name = str(n + 1)
+    imgs = np.load(img_path)
+    masks = np.load(mask_path)
+
+    for i in range(imgs.shape[0]):
+        img = np.uint8(imgs[i])
+        mask_multichannel = np.minimum(np.uint8(masks[i]), 1)
+        mask = np.zeros((img.shape[0], img.shape[1]), dtype=np.uint8)
+        for j in range(mask_multichannel.shape[-1]):
+            factor = (j + 1) % mask_multichannel.shape[-1]
+            # convert [0,1,2,3,4,5] to [1,2,3,4,5,0],
+            # with the last label being background
+            mask[mask_multichannel[..., j] == 1] = factor
+
+        file_name = 'fold' + fold_name + '_' + str(i).rjust(4, '0') + '.png'
+        print('Processing: ', file_name)
+        tgt_img_path = os.path.join(tgt_img_dir, file_name)
+        tgt_mask_path = os.path.join(tgt_mask_dir, file_name)
+        Image.fromarray(img).save(tgt_img_path)
+        Image.fromarray(mask).save(tgt_mask_path)
+
+    del imgs
+    del masks
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/README.md b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/README.md
new file mode 100644
index 0000000..5a80949
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/README.md
@@ -0,0 +1,153 @@
+# PCam (PatchCamelyon)
+
+## Description
+
+This project supports **`Patch Camelyon (PCam) `**, which can be downloaded from [here](https://opendatalab.com/PCam).
+
+### Dataset Overview
+
+PatchCamelyon is an image classification dataset. It consists of 327680 color images (96 x 96px) extracted from histopathologic scans of lymph node sections. Each image is annotated with a binary label indicating presence of metastatic tissue. PCam provides a new benchmark for machine learning models: bigger than CIFAR10, smaller than ImageNet, trainable on a single GPU.
+
+### Statistic Information
+
+| Dataset Name                         | Anatomical Region | Task Type    | Modality       | Num. Classes | Train/Val/Test images | Train/Val/Test Labeled | Release Date | License                                                       |
+| ------------------------------------ | ----------------- | ------------ | -------------- | ------------ | --------------------- | ---------------------- | ------------ | ------------------------------------------------------------- |
+| [Pcam](https://opendatalab.com/PCam) | throax            | segmentation | histopathology | 2            | 327680/-/-            | yes/-/-                | 2018         | [CC0 1.0](https://creativecommons.org/publicdomain/zero/1.0/) |
+
+|    Class Name     | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :---------------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+|    background     |   214849   |   63.77    |    -     |    -     |     -     |     -     |
+| metastatic tissue |   131832   |   36.22    |    -     |    -     |     -     |     -     |
+
+Note:
+
+- `Pct` means percentage of pixels in this category in all pixels.
+
+### Visualization
+
+![pcam](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/histopathology/pcam/pcam_dataset.png?raw=true)
+
+### Dataset Citation
+
+```
+@inproceedings{veeling2018rotation,
+	title={Rotation equivariant CNNs for digital pathology},
+	author={Veeling, Bastiaan S and Linmans, Jasper and Winkens, Jim and Cohen, Taco and Welling, Max},
+	booktitle={International Conference on Medical image computing and computer-assisted intervention},
+	pages={210--218},
+	year={2018},
+}
+```
+
+### Prerequisites
+
+- Python v3.8
+- PyTorch v1.10.0
+- pillow(PIL) v9.3.0 9.3.0
+- scikit-learn(sklearn) v1.2.0 1.2.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+
+All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `pcam/` root directory, run the following line to add the current directory to `PYTHONPATH`:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset Preparing
+
+- download dataset from [here](https://opendatalab.com/PCam) and decompress data to path `'data/'`.
+- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
+- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set cannot be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
+
+```shell
+mkdir data & cd data
+pip install opendatalab
+odl get PCam
+mv ./PCam/raw/pcamv1 ./
+rm -rf PCam
+cd ..
+python tools/prepare_dataset.py
+python ../../tools/split_seg_dataset.py
+```
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── histopathology
+  │   │   │   │   ├── pcam
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── train.txt
+  │   │   │   │   │   │   ├── val.txt
+  │   │   │   │   │   │   ├── images
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   ├── masks
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+```
+
+### Divided Dataset Information
+
+***Note: The table information below is divided by ourselves.***
+
+|    Class Name     | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :---------------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+|    background     |   171948   |   63.82    |  42901   |   63.6   |     -     |     -     |
+| metastatic tissue |   105371   |   36.18    |  26461   |   36.4   |     -     |     -     |
+
+### Training commands
+
+To train models on a single server with one GPU. (default)
+
+```shell
+mim train mmseg ./configs/${CONFIG_FILE}
+```
+
+### Testing commands
+
+To test models on a single server with one GPU. (default)
+
+```shell
+mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
+
+You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+  - [x] Basic docstrings & proper citation
+  - [ ] Test-time correctness
+  - [x] A full README
+
+- [ ] Milestone 2: Indicates a successful model implementation.
+
+  - [ ] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+  - [ ] Unit tests
+  - [ ] Code polishing
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_pcam-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_pcam-512x512.py
new file mode 100644
index 0000000..20601f1
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_pcam-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './pcam_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.pcam_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_pcam-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_pcam-512x512.py
new file mode 100644
index 0000000..c057535
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_pcam-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './pcam_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.pcam_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_pcam-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_pcam-512x512.py
new file mode 100644
index 0000000..4c1d5fe
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_pcam-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './pcam_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.pcam_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_pcam-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_pcam-512x512.py
new file mode 100644
index 0000000..25e3734
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_pcam-512x512.py
@@ -0,0 +1,18 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './pcam_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.pcam_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(
+        num_classes=2, loss_decode=dict(use_sigmoid=True), out_channels=1),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/pcam_512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/pcam_512x512.py
new file mode 100644
index 0000000..04efc23
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/pcam_512x512.py
@@ -0,0 +1,42 @@
+dataset_type = 'PCamDataset'
+data_root = 'data/'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='train.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='val.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/datasets/pcam_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/datasets/pcam_dataset.py
new file mode 100644
index 0000000..1c27de5
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/datasets/pcam_dataset.py
@@ -0,0 +1,31 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class PCamDataset(BaseSegDataset):
+    """PCamDataset dataset.
+
+    In segmentation map annotation for PCamDataset,
+    0 stands for background, which is included in 2 categories.
+    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
+    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
+
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+        reduce_zero_label (bool): Whether to mark label zero as ignored.
+            Default to False.
+    """
+    METAINFO = dict(classes=('background', 'metastatic tissue'))
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/tools/prepare_dataset.py
new file mode 100644
index 0000000..75038e6
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/tools/prepare_dataset.py
@@ -0,0 +1,49 @@
+import os
+
+import h5py
+import numpy as np
+from PIL import Image
+
+root_path = 'data/'
+
+tgt_img_train_dir = os.path.join(root_path, 'images/train/')
+tgt_mask_train_dir = os.path.join(root_path, 'masks/train/')
+tgt_img_val_dir = os.path.join(root_path, 'images/val/')
+tgt_img_test_dir = os.path.join(root_path, 'images/test/')
+
+os.system('mkdir -p ' + tgt_img_train_dir)
+os.system('mkdir -p ' + tgt_mask_train_dir)
+os.system('mkdir -p ' + tgt_img_val_dir)
+os.system('mkdir -p ' + tgt_img_test_dir)
+
+
+def extract_pics_from_h5(h5_path, h5_key, save_dir):
+    f = h5py.File(h5_path, 'r')
+    for i, img in enumerate(f[h5_key]):
+        img = img.astype(np.uint8).squeeze()
+        img = Image.fromarray(img)
+        save_image_path = os.path.join(save_dir, str(i).zfill(8) + '.png')
+        img.save(save_image_path)
+
+
+if __name__ == '__main__':
+
+    extract_pics_from_h5(
+        'data/pcamv1/camelyonpatch_level_2_split_train_x.h5',
+        h5_key='x',
+        save_dir=tgt_img_train_dir)
+
+    extract_pics_from_h5(
+        'data/pcamv1/camelyonpatch_level_2_split_valid_x.h5',
+        h5_key='x',
+        save_dir=tgt_img_val_dir)
+
+    extract_pics_from_h5(
+        'data/pcamv1/camelyonpatch_level_2_split_test_x.h5',
+        h5_key='x',
+        save_dir=tgt_img_test_dir)
+
+    extract_pics_from_h5(
+        'data/pcamv1/camelyonpatch_level_2_split_train_mask.h5',
+        h5_key='mask',
+        save_dir=tgt_mask_train_dir)
diff --git a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/README.md b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/README.md
new file mode 100644
index 0000000..ca95921
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/README.md
@@ -0,0 +1,167 @@
+# RAVIR: A Dataset and Methodology for the Semantic Segmentation and Quantitative Analysis of Retinal Arteries and Veins in Infrared Reflectance Imaging
+
+## Description
+
+This project support **`RAVIR: A Dataset and Methodology for the Semantic Segmentation and Quantitative Analysis of Retinal Arteries and Veins in Infrared Reflectance Imaging`**, and the dataset used in this project can be downloaded from [here](https://ravir.grand-challenge.org/).
+
+### Dataset Overview
+
+The retinal vasculature provides important clues in the diagnosis and monitoring of systemic diseases including hypertension and diabetes. The microvascular system is of primary involvement in such conditions, and the retina is the only anatomical site where the microvasculature can be directly observed. The objective assessment of retinal vessels has long been considered a surrogate biomarker for systemic vascular diseases, and with recent advancements in retinal imaging and computer vision technologies, this topic has become the subject of renewed attention. In this paper, we present a novel dataset, dubbed RAVIR, for the semantic segmentation of Retinal Arteries and Veins in Infrared Reflectance (IR) imaging. It enables the creation of deep learning-based models that distinguish extracted vessel type without extensive post-processing.
+
+### Original Statistic Information
+
+| Dataset name                                | Anatomical region | Task type    | Modality                     | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                         |
+| ------------------------------------------- | ----------------- | ------------ | ---------------------------- | ------------ | --------------------- | ---------------------- | ------------ | --------------------------------------------------------------- |
+| [Ravir](https://ravir.grand-challenge.org/) | eye               | segmentation | infrared reflectance imaging | 3            | 23/-/19               | yes/-/-                | 2022         | [CC-BY-NC 4.0](https://creativecommons.org/licenses/by-sa/4.0/) |
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |     23     |   87.22    |    -     |    -     |     -     |     -     |
+|   artery   |     23     |    5.45    |    -     |    -     |     -     |     -     |
+|    vein    |     23     |    7.33    |    -     |    -     |     -     |     -     |
+
+Note:
+
+- `Pct` means percentage of pixels in this category in all pixels.
+
+### Visualization
+
+![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/infrared_reflectance_imaging/ravir/ravir_dataset.png)
+
+## Dataset Citation
+
+```bibtex
+@article{hatamizadeh2022ravir,
+  title={RAVIR: A dataset and methodology for the semantic segmentation and quantitative analysis of retinal arteries and veins in infrared reflectance imaging},
+  author={Hatamizadeh, Ali and Hosseini, Hamid and Patel, Niraj and Choi, Jinseo and Pole, Cameron C and Hoeferlin, Cory M and Schwartz, Steven D and Terzopoulos, Demetri},
+  journal={IEEE Journal of Biomedical and Health Informatics},
+  volume={26},
+  number={7},
+  pages={3272--3283},
+  year={2022},
+  publisher={IEEE}
+}
+```
+
+### Prerequisites
+
+- Python v3.8
+- PyTorch v1.10.0
+- pillow(PIL) v9.3.0
+- scikit-learn(sklearn) v1.2.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+
+All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `ravir/` root directory, run the following line to add the current directory to `PYTHONPATH`:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset preparing
+
+- download dataset from [here](https://ravir.grand-challenge.org/) and decompression data to path `'data/ravir/'`.
+- run script `"python tools/prepare_dataset.py"` to split dataset and change folder structure as below.
+- run script `"python ../../tools/split_seg_dataset.py --data_root data/ravir"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set can't be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── infrared_reflectance_imaging
+  │   │   │   │   ├── ravir
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── train.txt
+  │   │   │   │   │   │   ├── val.txt
+  │   │   │   │   │   │   ├── images
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   │   ├── test
+  │   │   │   │   |   │   │   │   ├── yyy.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── yyy.png
+  │   │   │   │   │   │   ├── masks
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+```
+
+### Divided Dataset Information
+
+***Note: The table information below is divided by ourselves.***
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |     18     |   87.41    |    5     |  86.53   |     -     |     -     |
+|   artery   |     18     |    5.44    |    5     |   5.50   |     -     |     -     |
+|    vein    |     18     |    7.15    |    5     |   7.97   |     -     |     -     |
+
+### Training commands
+
+To train models on a single server with one GPU. (default）
+
+```shell
+mim train mmseg ./configs/${CONFIG_PATH}
+```
+
+### Testing commands
+
+To train models on a single server with one GPU. (default）
+
+```shell
+mim test mmseg ./configs/${CONFIG_PATH}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
+
+You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
+
+## Results
+
+### Ravir
+
+|     Method      | Backbone | Crop Size |   lr   |                                   config                                   |
+| :-------------: | :------: | :-------: | :----: | :------------------------------------------------------------------------: |
+| fcn_unet_s5-d16 |   unet   |  512x512  |  0.01  |  [config](./configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_ravir-512x512.py)  |
+| fcn_unet_s5-d16 |   unet   |  512x512  | 0.001  | [config](./configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_ravir-512x512.py)  |
+| fcn_unet_s5-d16 |   unet   |  512x512  | 0.0001 | [config](./configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_ravir-512x512.py) |
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+
+  - [x] Basic docstrings & proper citation
+
+  - [x] Test-time correctness
+
+  - [x] A full README
+
+- [x] Milestone 2: Indicates a successful model implementation.
+
+  - [x] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+
+  - [ ] Unit tests
+
+  - [ ] Code polishing
+
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_ravir-512x512.py b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_ravir-512x512.py
new file mode 100755
index 0000000..375ad5a
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_ravir-512x512.py
@@ -0,0 +1,19 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './ravir_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.ravir_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    decode_head=dict(num_classes=3),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_ravir-512x512.py b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_ravir-512x512.py
new file mode 100755
index 0000000..a7ecf6d
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_ravir-512x512.py
@@ -0,0 +1,19 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './ravir_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.ravir_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=dict(size=img_scale),
+    pretrained=None,
+    decode_head=dict(num_classes=3),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_ravir-512x512.py b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_ravir-512x512.py
new file mode 100755
index 0000000..28556df
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_ravir-512x512.py
@@ -0,0 +1,19 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './ravir_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.ravir_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    decode_head=dict(num_classes=3),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/ravir_512x512.py b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/ravir_512x512.py
new file mode 100755
index 0000000..cb4c292
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/ravir_512x512.py
@@ -0,0 +1,42 @@
+dataset_type = 'RAVIRDataset'
+data_root = 'data/ravir'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='train.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='val.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/datasets/__init__.py b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/datasets/__init__.py
new file mode 100755
index 0000000..6f1d051
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/datasets/__init__.py
@@ -0,0 +1,3 @@
+from .ravir_dataset import RAVIRDataset
+
+__all__ = ['RAVIRDataset']
diff --git a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/datasets/ravir_dataset.py b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/datasets/ravir_dataset.py
new file mode 100755
index 0000000..c9e0a8e
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/datasets/ravir_dataset.py
@@ -0,0 +1,28 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class RAVIRDataset(BaseSegDataset):
+    """RAVIRDataset dataset.
+
+    In segmentation map annotation for RAVIRDataset, 0 stands for background,
+    which is included in 3 categories. ``reduce_zero_label`` is fixed to
+    False. The ``img_suffix`` is fixed to '.png' and ``seg_map_suffix`` is
+    fixed to '.png'.
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+    """
+    METAINFO = dict(classes=('background', 'artery', 'vein'))
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/tools/prepare_dataset.py
new file mode 100644
index 0000000..068dcad
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/tools/prepare_dataset.py
@@ -0,0 +1,33 @@
+import glob
+import os
+
+import numpy as np
+from PIL import Image
+from tqdm import tqdm
+
+# map = {255:2, 128:1, 0:0}
+
+os.makedirs('data/ravir/images/train', exist_ok=True)
+os.makedirs('data/ravir/images/test', exist_ok=True)
+os.makedirs('data/ravir/masks/train', exist_ok=True)
+
+os.system(
+    r'cp data/ravir/RAVIR\ Dataset/train/training_images/* data/ravir/images/train'  # noqa
+)
+os.system(
+    r'cp data/ravir/RAVIR\ Dataset/train/training_masks/* data/ravir/masks/train'  # noqa
+)
+os.system(r'cp data/ravir/RAVIR\ Dataset/test/* data/ravir/images/test')
+
+os.system(r'rm -rf data/ravir/RAVIR\ Dataset')
+
+imgs = glob.glob(os.path.join('data/ravir/masks/train', '*.png'))
+
+for im_path in tqdm(imgs):
+    im = Image.open(im_path)
+    imn = np.array(im)
+    imn[imn == 255] = 2
+    imn[imn == 128] = 1
+    imn[imn == 0] = 0
+    new_im = Image.fromarray(imn)
+    new_im.save(im_path)
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/README.md b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/README.md
new file mode 100644
index 0000000..1feb433
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/README.md
@@ -0,0 +1,153 @@
+# 2-PM Vessel Dataset
+
+## Description
+
+This project supports **`2-PM Vessel Dataset`**, which can be downloaded from [here](https://opendatalab.org.cn/2-PM_Vessel_Dataset).
+
+### Dataset Overview
+
+An open-source volumetric brain vasculature dataset obtained with two-photon microscopy at Focused Ultrasound Lab, at Sunnybrook Research Institute (affiliated with University of Toronto by Dr. Alison Burgess, Charissa Poon and Marc Santos).
+
+The dataset contains a total of 12 volumetric stacks consisting images of mouse brain vasculature and tumor vasculature.
+
+### Information Statistics
+
+| Dataset Name                                                 | Anatomical Region | Task Type    | Modality          | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                       |
+| ------------------------------------------------------------ | ----------------- | ------------ | ----------------- | ------------ | --------------------- | ---------------------- | ------------ | ------------------------------------------------------------- |
+| [2pm_vessel](https://opendatalab.org.cn/2-PM_Vessel_Dataset) | vessel            | segmentation | microscopy_images | 2            | 216/-/-               | yes/-/-                | 2021         | [CC0 1.0](https://creativecommons.org/publicdomain/zero/1.0/) |
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |    216     |   85.78    |    -     |    -     |     -     |     -     |
+|   vessel   |    180     |   14.22    |    -     |    -     |     -     |     -     |
+
+Note:
+
+- `Pct` means percentage of pixels in this category in all pixels.
+
+### Visualization
+
+![2pmv](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/histopathology/2pm_vessel/2pm_vessel_dataset.png?raw=true)
+
+### Dataset Citation
+
+```
+@article{teikari2016deep,
+	title={Deep learning convolutional networks for multiphoton microscopy vasculature segmentation},
+	author={Teikari, Petteri and Santos, Marc and Poon, Charissa and Hynynen, Kullervo},
+	journal={arXiv preprint arXiv:1606.02382},
+	year={2016}
+}
+```
+
+### Prerequisites
+
+- Python v3.8
+- PyTorch v1.10.0
+- pillow(PIL) v9.3.0
+- scikit-learn(sklearn) v1.2.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+
+All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `2pm_vessel/` root directory, run the following line to add the current directory to `PYTHONPATH`:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset Preparing
+
+- download dataset from [here](https://opendatalab.org.cn/2-PM_Vessel_Dataset) and decompress data to path `'data/'`.
+- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
+- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set can't be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
+
+```shell
+mkdir data & cd data
+pip install opendatalab
+odl get    2-PM_Vessel_Dataset
+cd ..
+python tools/prepare_dataset.py
+python ../../tools/split_seg_dataset.py
+```
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── microscopy_images
+  │   │   │   │   ├── 2pm_vessel
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── train.txt
+  │   │   │   │   │   │   ├── val.txt
+  │   │   │   │   │   │   ├── images
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   ├── masks
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+
+```
+
+### Divided Dataset Information
+
+***Note: The table information below is divided by ourselves.***
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |    172     |   85.88    |    44    |   85.4   |     -     |     -     |
+|   vessel   |    142     |   14.12    |    38    |   14.6   |     -     |     -     |
+
+### Training commands
+
+To train models on a single server with one GPU. (default)
+
+```shell
+mim train mmseg ./configs/${CONFIG_FILE}
+```
+
+### Testing commands
+
+To test models on a single server with one GPU. (default)
+
+```shell
+mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
+
+You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+  - [x] Basic docstrings & proper citation
+  - [ ] Test-time correctness
+  - [x] A full README
+
+- [ ] Milestone 2: Indicates a successful model implementation.
+
+  - [ ] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+  - [ ] Unit tests
+  - [ ] Code polishing
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/2pm-vessel_512x512.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/2pm-vessel_512x512.py
new file mode 100644
index 0000000..124403f
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/2pm-vessel_512x512.py
@@ -0,0 +1,42 @@
+dataset_type = 'TwoPMVesselDataset'
+data_root = 'data/'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='train.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='val.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_2pm-vessel-512x512.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_2pm-vessel-512x512.py
new file mode 100644
index 0000000..2a429e9
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_2pm-vessel-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './2pm-vessel_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.2pm-vessel_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_2pm-vessel-512x512.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_2pm-vessel-512x512.py
new file mode 100644
index 0000000..10d9bb8
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_2pm-vessel-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './2pm-vessel_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.2pm-vessel_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_2pm-vessel-512x512.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_2pm-vessel-512x512.py
new file mode 100644
index 0000000..65c1579
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_2pm-vessel-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './2pm-vessel_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.2pm-vessel_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_bactteria-detection-512x512.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_bactteria-detection-512x512.py
new file mode 100644
index 0000000..91ed6ad
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_bactteria-detection-512x512.py
@@ -0,0 +1,18 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './2pm-vessel_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.2pm-vessel_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(
+        num_classes=2, loss_decode=dict(use_sigmoid=True), out_channels=1),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/datasets/2pm-vessel_dataset.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/datasets/2pm-vessel_dataset.py
new file mode 100644
index 0000000..984b5a1
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/datasets/2pm-vessel_dataset.py
@@ -0,0 +1,31 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class TwoPMVesselDataset(BaseSegDataset):
+    """TwoPMVesselDataset dataset.
+
+    In segmentation map annotation for TwoPMVesselDataset,
+    0 stands for background, which is included in 2 categories.
+    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
+    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
+
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+        reduce_zero_label (bool): Whether to mark label zero as ignored.
+            Default to False.
+    """
+    METAINFO = dict(classes=('background', 'vessel'))
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/tools/prepare_dataset.py
new file mode 100644
index 0000000..1b46af2
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/tools/prepare_dataset.py
@@ -0,0 +1,46 @@
+import os
+
+import tifffile as tiff
+from PIL import Image
+
+root_path = 'data/'
+
+image_dir = os.path.join(root_path,
+                         '2-PM_Vessel_Dataset/raw/vesselNN_dataset/denoised')
+label_dir = os.path.join(root_path,
+                         '2-PM_Vessel_Dataset/raw/vesselNN_dataset/labels')
+tgt_img_train_dir = os.path.join(root_path, 'images/train/')
+tgt_mask_train_dir = os.path.join(root_path, 'masks/train/')
+os.system('mkdir -p ' + tgt_img_train_dir)
+os.system('mkdir -p ' + tgt_mask_train_dir)
+
+
+def filter_suffix(src_dir, suffix):
+    suffix = '.' + suffix if '.' not in suffix else suffix
+    file_names = [_ for _ in os.listdir(src_dir) if _.endswith(suffix)]
+    file_paths = [os.path.join(src_dir, _) for _ in file_names]
+    return sorted(file_paths), sorted(file_names)
+
+
+if __name__ == '__main__':
+
+    image_path_list, _ = filter_suffix(image_dir, suffix='tif')
+    label_path_list, _ = filter_suffix(label_dir, suffix='.tif')
+
+    for img_path, label_path in zip(image_path_list, label_path_list):
+        labels = tiff.imread(label_path)
+        images = tiff.imread(img_path)
+        assert labels.ndim == 3
+        assert images.shape == labels.shape
+        name = img_path.split('/')[-1].replace('.tif', '')
+        # a single .tif file contains multiple slices
+        # as long as it is read by tifffile package.
+        for i in range(labels.shape[0]):
+            slice_name = name + '_' + str(i).rjust(3, '0') + '.png'
+            image = images[i]
+            label = labels[i] // 255
+
+            save_path_label = os.path.join(tgt_mask_train_dir, slice_name)
+            Image.fromarray(label).save(save_path_label)
+            save_path_image = os.path.join(tgt_img_train_dir, slice_name)
+            Image.fromarray(image).convert('RGB').save(save_path_image)
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/README.md b/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/README.md
new file mode 100644
index 0000000..1cedda7
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/README.md
@@ -0,0 +1,160 @@
+# Bactteria detection with darkfield microscopy
+
+## Description
+
+This project supports **`Bactteria detection with darkfield microscopy`**, which can be downloaded from [here](https://tianchi.aliyun.com/dataset/94411).
+
+### Dataset Overview
+
+Spirochaeta is a genus of bacteria classified within the phylum Spirochaetes. Included in this dataset are 366 darkfield microscopy images and manually annotated masks which can be used for classification and segmentation purposes. Detecting bacteria in blood could have a huge significance for research in both the medical and computer science field.
+
+It was gathered and annotated by students (hand-on experience)
+It has more than just one targeted class (blood cell and bacteria were annotated)
+It is highly imbalanced, so naive loss functions would work less properly
+
+### Original Statistic Information
+
+| Dataset name                                                    | Anatomical region | Task type    | Modality   | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                         |
+| --------------------------------------------------------------- | ----------------- | ------------ | ---------- | ------------ | --------------------- | ---------------------- | ------------ | --------------------------------------------------------------- |
+| [Bactteria detection](https://tianchi.aliyun.com/dataset/94411) | bacteria          | segmentation | microscopy | 3            | 366/-/-               | yes/-/-                | 2017         | [CC-BY-NC 4.0](https://creativecommons.org/licenses/by-sa/4.0/) |
+
+|  Class Name  | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :----------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+|  background  |    366     |    85.9    |    -     |    -     |     -     |     -     |
+| erythrocytes |    345     |   13.03    |    -     |    -     |     -     |     -     |
+| spirochaete  |    288     |    1.07    |    -     |    -     |     -     |     -     |
+
+Note:
+
+- `Pct` means percentage of pixels in this category in all pixels.
+
+### Visualization
+
+![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/microscopy_images/bactteria_detection/bactteria_detection_dataset.png)
+
+## Usage
+
+### Prerequisites
+
+- Python v3.8
+- PyTorch v1.10.0
+- pillow (PIL) v9.3.0
+- scikit-learn (sklearn) v1.2.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+
+All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `bactteria_detection/` root directory, run the following line to add the current directory to `PYTHONPATH`:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset Preparing
+
+- Download dataset from [here](https://tianchi.aliyun.com/dataset/94411) and save it to the `data/` directory .
+- Decompress data to path `data/`. This will create a new folder named `data/Bacteria_detection_with_darkfield_microscopy_datasets/`, which contains the original image data.
+- run script `python tools/prepare_dataset.py` to format data and change folder structure as below.
+- run script `python ../../tools/split_seg_dataset.py` to split dataset. For the Bacteria_detection dataset, as there is no test or validation dataset, we sample 20% samples from the whole dataset as the validation dataset and 80% samples for training data and make two filename lists `train.txt` and `val.txt`. As we set the random seed as the hard code, we eliminated the randomness, the dataset split actually can be reproducible.
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── microscopy_images
+  │   │   │   │   ├── bactteria_detection
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── train.txt
+  │   │   │   │   │   │   ├── val.txt
+  │   │   │   │   │   │   ├── Bacteria_detection_with_darkfield_microscopy_datasets
+  │   │   │   │   │   │   ├── images
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   ├── masks
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+```
+
+### Divided Dataset Information
+
+***Note: The table information below is divided by ourselves.***
+
+|  Class Name  | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :----------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+|  background  |    292     |   85.66    |    74    |   86.7   |     -     |     -     |
+| erythrocytes |    274     |   13.25    |    71    |  12.29   |     -     |     -     |
+| spirochaete  |    231     |    1.09    |    57    |   1.01   |     -     |     -     |
+
+### Training commands
+
+Train models on a single server with one GPU.
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+mim train mmseg ./configs/${CONFIG_FILE}
+```
+
+### Testing commands
+
+Test models on a single server with one GPU.
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
+
+You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
+
+## Results
+
+### Bactteria detection with darkfield microscopy
+
+***Note: The following experimental results are based on the data randomly partitioned according to the above method described in the dataset preparing section.***
+
+|     Method      | Backbone | Crop Size |   lr   | mIoU  | mDice |                                          config                                          |         download         |
+| :-------------: | :------: | :-------: | :----: | :---: | :---: | :--------------------------------------------------------------------------------------: | :----------------------: |
+| fcn_unet_s5-d16 |   unet   |  512x512  |  0.01  | 76.48 | 84.68 |  [config](./configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_bactteria-detection-512x512.py)  | [model](<>) \| [log](<>) |
+| fcn_unet_s5-d16 |   unet   |  512x512  | 0.001  | 61.06 | 63.69 | [config](./configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_bactteria-detection-512x512.py)  | [model](<>) \| [log](<>) |
+| fcn_unet_s5-d16 |   unet   |  512x512  | 0.0001 | 58.87 | 62.42 | [config](./configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_bactteria-detection-512x512.py) | [model](<>) \| [log](<>) |
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+
+  - [x] Basic docstrings & proper citation
+
+  - [x] Test-time correctness
+
+  - [x] A full README
+
+- [x] Milestone 2: Indicates a successful model implementation.
+
+  - [x] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+
+  - [ ] Unit tests
+
+  - [ ] Code polishing
+
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/bactteria-detection_512x512.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/bactteria-detection_512x512.py
new file mode 100644
index 0000000..e3eab4e
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/bactteria-detection_512x512.py
@@ -0,0 +1,42 @@
+dataset_type = 'BactteriaDetectionDataset'
+data_root = 'data/'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='train.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='val.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_bactteria-detection-512x512.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_bactteria-detection-512x512.py
new file mode 100644
index 0000000..ede58d7
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_bactteria-detection-512x512.py
@@ -0,0 +1,18 @@
+_base_ = [
+    './bactteria-detection_512x512.py',
+    'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.bactteria-detection_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=3),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_bactteria-detection-512x512.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_bactteria-detection-512x512.py
new file mode 100644
index 0000000..bde3fa1
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_bactteria-detection-512x512.py
@@ -0,0 +1,18 @@
+_base_ = [
+    './bactteria-detection_512x512.py',
+    'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.bactteria-detection_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=3),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_bactteria-detection-512x512.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_bactteria-detection-512x512.py
new file mode 100644
index 0000000..08e204f
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_bactteria-detection-512x512.py
@@ -0,0 +1,18 @@
+_base_ = [
+    './bactteria-detection_512x512.py',
+    'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.bactteria-detection_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=3),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/datasets/bactteria-detection_dataset.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/datasets/bactteria-detection_dataset.py
new file mode 100644
index 0000000..c95097b
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/datasets/bactteria-detection_dataset.py
@@ -0,0 +1,27 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class BactteriaDetectionDataset(BaseSegDataset):
+    """BactteriaDetectionDataset dataset.
+
+    In segmentation map annotation for BactteriaDetectionDataset,
+    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
+    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
+
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+    """
+    METAINFO = dict(classes=('background', 'erythrocytes', 'spirochaete'))
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=False,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/tools/prepare_dataset.py
new file mode 100755
index 0000000..8dcc719
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/tools/prepare_dataset.py
@@ -0,0 +1,33 @@
+import glob
+import os
+import shutil
+
+from PIL import Image
+
+root_path = 'data/'
+img_suffix = '.png'
+seg_map_suffix = '.png'
+save_img_suffix = '.png'
+save_seg_map_suffix = '.png'
+
+x_train = glob.glob(
+    'data/Bacteria_detection_with_darkfield_microscopy_datasets/images/*' +
+    img_suffix)  # noqa
+
+os.system('mkdir -p ' + root_path + 'images/train/')
+os.system('mkdir -p ' + root_path + 'masks/train/')
+
+part_dir_dict = {0: 'train/'}
+for ith, part in enumerate([x_train]):
+    part_dir = part_dir_dict[ith]
+    for img in part:
+        basename = os.path.basename(img)
+        img_save_path = os.path.join(root_path, 'images', part_dir,
+                                     basename.split('.')[0] + save_img_suffix)
+        shutil.copy(img, img_save_path)
+        mask_path = 'data/Bacteria_detection_with_darkfield_microscopy_datasets/masks/' + basename  # noqa
+        mask = Image.open(mask_path).convert('L')
+        mask_save_path = os.path.join(
+            root_path, 'masks', part_dir,
+            basename.split('.')[0] + save_seg_map_suffix)
+        mask.save(mask_save_path)
diff --git a/mmsegmentation/projects/medical/2d_image/tools/split_seg_dataset.py b/mmsegmentation/projects/medical/2d_image/tools/split_seg_dataset.py
new file mode 100644
index 0000000..9ab2e92
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/tools/split_seg_dataset.py
@@ -0,0 +1,42 @@
+import argparse
+import glob
+import os
+
+from sklearn.model_selection import train_test_split
+
+
+def save_anno(img_list, file_path, remove_suffix=True):
+    if remove_suffix:
+        img_list = [
+            '/'.join(img_path.split('/')[-2:]) for img_path in img_list
+        ]
+        img_list = [
+            '.'.join(img_path.split('.')[:-1]) for img_path in img_list
+        ]
+    with open(file_path, 'w') as file_:
+        for x in list(img_list):
+            file_.write(x + '\n')
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--data_root', default='data/')
+    args = parser.parse_args()
+    data_root = args.data_root
+    if os.path.exists(os.path.join(data_root, 'masks/val')):
+        x_val = sorted(glob.glob(data_root + '/images/val/*.png'))
+        save_anno(x_val, data_root + '/val.txt')
+    if os.path.exists(os.path.join(data_root, 'masks/test')):
+        x_test = sorted(glob.glob(data_root + '/images/test/*.png'))
+        save_anno(x_test, data_root + '/test.txt')
+    if not os.path.exists(os.path.join(
+            data_root, 'masks/val')) and not os.path.exists(
+                os.path.join(data_root, 'masks/test')):
+        all_imgs = sorted(glob.glob(data_root + '/images/train/*.png'))
+        x_train, x_val = train_test_split(
+            all_imgs, test_size=0.2, random_state=0)
+        save_anno(x_train, data_root + '/train.txt')
+        save_anno(x_val, data_root + '/val.txt')
+    else:
+        x_train = sorted(glob.glob(data_root + '/images/train/*.png'))
+        save_anno(x_train, data_root + '/train.txt')
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/README.md b/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/README.md
new file mode 100644
index 0000000..a1cd27b
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/README.md
@@ -0,0 +1,147 @@
+# Chest Image Dataset for Pneumothorax Segmentation
+
+## Description
+
+This project supports **`Chest Image Dataset for Pneumothorax Segmentation`**, which can be downloaded from [here](https://tianchi.aliyun.com/dataset/83075).
+
+### Dataset Overview
+
+Pneumothorax can be caused by a blunt chest injury, damage from underlying lung disease, or most horrifying—it may occur for no obvious reason at all. On some occasions, a collapsed lung can be a life-threatening event.
+Pneumothorax is usually diagnosed by a radiologist on a chest x-ray, and can sometimes be very difficult to confirm. An accurate AI algorithm to detect pneumothorax would be useful in a lot of clinical scenarios. AI could be used to triage chest radiographs for priority interpretation, or to provide a more confident diagnosis for non-radiologists.
+
+The dataset is provided by the Society for Imaging Informatics in Medicine(SIIM), American College of Radiology (ACR),Society of Thoracic Radiology (STR) and MD.ai. You can develop a model to classify (and if present, segment) pneumothorax from a set of chest radiographic images. If successful, you could aid in the early recognition of pneumothoraces and save lives.
+
+### Original Statistic Information
+
+| Dataset name                                                          | Anatomical region | Task type    | Modality | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                            |
+| --------------------------------------------------------------------- | ----------------- | ------------ | -------- | ------------ | --------------------- | ---------------------- | ------------ | ------------------------------------------------------------------ |
+| [pneumothorax segmentation](https://tianchi.aliyun.com/dataset/83075) | thorax            | segmentation | x_ray    | 2            | 12089/-/3205          | yes/-/no               | -            | [CC-BY-SA-NC 4.0](https://creativecommons.org/licenses/by-sa/4.0/) |
+
+|    Class Name     | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :---------------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+|      normal       |   12089    |   99.75    |    -     |    -     |     -     |     -     |
+| pneumothorax area |    2669    |    0.25    |    -     |    -     |     -     |     -     |
+
+Note:
+
+- `Pct` means percentage of pixels in this category in all pixels.
+
+### Visualization
+
+![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/x_ray/chest_image_pneum/chest_image_pneum_dataset.png)
+
+### Prerequisites
+
+- Python v3.8
+- PyTorch v1.10.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+
+All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `chest_image_pneum/` root directory, run the following line to add the current directory to `PYTHONPATH`:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset preparing
+
+- download dataset from [here](https://tianchi.aliyun.com/dataset/83075) and decompress data to path `'data/'`.
+- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
+- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set can't be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── x_ray
+  │   │   │   │   ├── chest_image_pneum
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── train.txt
+  │   │   │   │   │   │   ├── test.txt
+  │   │   │   │   │   │   ├── images
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   ├── masks
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+```
+
+### Divided Dataset Information
+
+***Note: The table information below is divided by ourselves.***
+
+|    Class Name     | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :---------------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+|      normal       |    9637    |   99.75    |   2410   |  99.74   |     -     |     -     |
+| pneumothorax area |    2137    |    0.25    |   532    |   0.26   |     -     |     -     |
+
+### Training commands
+
+Train models on a single server with one GPU.
+
+```shell
+mim train mmseg ./configs/${CONFIG_FILE}
+```
+
+### Testing commands
+
+Test models on a single server with one GPU.
+
+```shell
+mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
+
+You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
+
+## Results
+
+### Bactteria detection with darkfield microscopy
+
+|     Method      | Backbone | Crop Size |   lr   | mIoU | mDice |                                         config                                         |         download         |
+| :-------------: | :------: | :-------: | :----: | :--: | :---: | :------------------------------------------------------------------------------------: | :----------------------: |
+| fcn_unet_s5-d16 |   unet   |  512x512  |  0.01  |  -   |   -   |  [config](./configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_chest-image-pneum-512x512.py)  | [model](<>) \| [log](<>) |
+| fcn_unet_s5-d16 |   unet   |  512x512  | 0.001  |  -   |   -   | [config](./configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_chest-image-pneum-512x512.py)  | [model](<>) \| [log](<>) |
+| fcn_unet_s5-d16 |   unet   |  512x512  | 0.0001 |  -   |   -   | [config](./configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_chest-image-pneum-512x512.py) | [model](<>) \| [log](<>) |
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+
+  - [x] Basic docstrings & proper citation
+
+  - [x] Test-time correctness
+
+  - [x] A full README
+
+- [x] Milestone 2: Indicates a successful model implementation.
+
+  - [x] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+
+  - [ ] Unit tests
+
+  - [ ] Code polishing
+
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/chest-image-pneum_512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/chest-image-pneum_512x512.py
new file mode 100644
index 0000000..411229b
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/chest-image-pneum_512x512.py
@@ -0,0 +1,42 @@
+dataset_type = 'ChestImagePneumDataset'
+data_root = 'data/'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='train.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='val.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_chest-image-pneum-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_chest-image-pneum-512x512.py
new file mode 100644
index 0000000..0f26459
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_chest-image-pneum-512x512.py
@@ -0,0 +1,18 @@
+_base_ = [
+    './chest-image-pneum_512x512.py',
+    'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.chest-image-pneum_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_chest-image-pneum-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_chest-image-pneum-512x512.py
new file mode 100644
index 0000000..37b9188
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_chest-image-pneum-512x512.py
@@ -0,0 +1,18 @@
+_base_ = [
+    './chest-image-pneum_512x512.py',
+    'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.chest-image-pneum_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_chest-image-pneum-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_chest-image-pneum-512x512.py
new file mode 100644
index 0000000..379e818
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_chest-image-pneum-512x512.py
@@ -0,0 +1,18 @@
+_base_ = [
+    './chest-image-pneum_512x512.py',
+    'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.chest-image-pneum_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/datasets/chest-image-pneum_dataset.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/datasets/chest-image-pneum_dataset.py
new file mode 100644
index 0000000..aeee60a
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/datasets/chest-image-pneum_dataset.py
@@ -0,0 +1,27 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class ChestImagePneumDataset(BaseSegDataset):
+    """ChestImagePneumDataset dataset.
+
+    In segmentation map annotation for ChestImagePneumDataset,
+    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
+    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
+
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+    """
+    METAINFO = dict(classes=('normal', 'pneumothorax area'))
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=False,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/tools/prepare_dataset.py
new file mode 100755
index 0000000..47eddc9
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/tools/prepare_dataset.py
@@ -0,0 +1,73 @@
+import os
+
+import numpy as np
+import pandas as pd
+import pydicom
+from PIL import Image
+
+root_path = 'data/'
+img_suffix = '.dcm'
+seg_map_suffix = '.png'
+save_img_suffix = '.png'
+save_seg_map_suffix = '.png'
+
+x_train = []
+for fpath, dirname, fnames in os.walk('data/chestimage_train_datasets'):
+    for fname in fnames:
+        if fname.endswith('.dcm'):
+            x_train.append(os.path.join(fpath, fname))
+x_test = []
+for fpath, dirname, fnames in os.walk('data/chestimage_test_datasets/'):
+    for fname in fnames:
+        if fname.endswith('.dcm'):
+            x_test.append(os.path.join(fpath, fname))
+
+os.system('mkdir -p ' + root_path + 'images/train/')
+os.system('mkdir -p ' + root_path + 'images/test/')
+os.system('mkdir -p ' + root_path + 'masks/train/')
+
+
+def rle_decode(rle, width, height):
+    mask = np.zeros(width * height, dtype=np.uint8)
+    array = np.asarray([int(x) for x in rle.split()])
+    starts = array[0::2]
+    lengths = array[1::2]
+
+    current_position = 0
+    for index, start in enumerate(starts):
+        current_position += start
+        mask[current_position:current_position + lengths[index]] = 1
+        current_position += lengths[index]
+
+    return mask.reshape(width, height, order='F')
+
+
+part_dir_dict = {0: 'train/', 1: 'test/'}
+dict_from_csv = pd.read_csv(
+    root_path + 'chestimage_train-rle_datasets.csv', sep=',',
+    index_col=0).to_dict()[' EncodedPixels']
+
+for ith, part in enumerate([x_train, x_test]):
+    part_dir = part_dir_dict[ith]
+    for img in part:
+        basename = os.path.basename(img)
+        img_id = '.'.join(basename.split('.')[:-1])
+        if ith == 0 and (img_id not in dict_from_csv.keys()):
+            continue
+        image = pydicom.read_file(img).pixel_array
+        save_img_path = root_path + 'images/' + part_dir + '.'.join(
+            basename.split('.')[:-1]) + save_img_suffix
+        print(save_img_path)
+        img_h, img_w = image.shape[:2]
+        image = Image.fromarray(image)
+        image.save(save_img_path)
+        if ith == 1:
+            continue
+        if dict_from_csv[img_id] == '-1':
+            mask = np.zeros((img_h, img_w), dtype=np.uint8)
+        else:
+            mask = rle_decode(dict_from_csv[img_id], img_h, img_w)
+        save_mask_path = root_path + 'masks/' + part_dir + '.'.join(
+            basename.split('.')[:-1]) + save_seg_map_suffix
+        mask = Image.fromarray(mask)
+        mask.save(save_mask_path)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/README.md b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/README.md
new file mode 100644
index 0000000..7cb099c
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/README.md
@@ -0,0 +1,119 @@
+# Chest X-ray Images with Pneumothorax Masks
+
+## Description
+
+This project support **`Chest X-ray Images with Pneumothorax Masks `**, and the dataset used in this project can be downloaded from [here](https://www.kaggle.com/datasets/vbookshelf/pneumothorax-chest-xray-images-and-masks).
+
+### Dataset Overview
+
+A pneumothorax (noo-moe-THOR-aks) is a collapsed lung. A pneumothorax occurs when air leaks into the space between your lung and chest wall. This air pushes on the outside of your lung and makes it collapse. Pneumothorax can be a complete lung collapse or a collapse of only a portion of the lung.
+
+A pneumothorax can be caused by a blunt or penetrating chest injury, certain medical procedures, or damage from underlying lung disease. Or it may occur for no obvious reason. Symptoms usually include sudden chest pain and shortness of breath. On some occasions, a collapsed lung can be a life-threatening event.
+
+Treatment for a pneumothorax usually involves inserting a needle or chest tube between the ribs to remove the excess air. However, a small pneumothorax may heal on its own.
+
+### Statistic Information
+
+| Dataset Name                                                                                                                      | Anatomical Region | Task type    | Modality | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release date | License                                                         |
+| --------------------------------------------------------------------------------------------------------------------------------- | ----------------- | ------------ | -------- | ------------ | --------------------- | ---------------------- | ------------ | --------------------------------------------------------------- |
+| [Chest-x-ray-images-with-pneumothorax-masks](https://www.kaggle.com/datasets/vbookshelf/pneumothorax-chest-xray-images-and-masks) | throax            | segmentation | x_ray    | 2            | 10675/-/1372          | yes/-/yes              | 2020         | [CC-BY-NC 4.0](https://creativecommons.org/licenses/by-sa/4.0/) |
+
+|  Class Name  | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :----------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+|  background  |   10675    |    99.7    |    -     |    -     |   1372    |   99.71   |
+| pneumothroax |    2379    |    0.3     |    -     |    -     |    290    |   0.29    |
+
+### Visualization
+
+![chest_x_ray_images_with_pneumothorax_masks](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/x_ray/chest_x_ray_images_with_pneumothorax_masks/chest_x_ray_images_with_pneumothorax_masks_dataset.png?raw=true)
+
+### Prerequisites
+
+- Python 3.8
+- PyTorch 1.10.0
+- pillow(PIL) 9.3.0
+- scikit-learn(sklearn) 1.2.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+
+All the commands below rely on the correct configuration of PYTHONPATH, which should point to the project's directory so that Python can locate the module files. In chest_x_ray_images_with_pneumothorax_masks/ root directory, run the following line to add the current directory to PYTHONPATH:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset preparing
+
+- download dataset from [here](https://www.kaggle.com/datasets/vbookshelf/pneumothorax-chest-xray-images-and-masks) and decompression data to path 'data/'.
+- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
+- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set cannot be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── x_ray
+  │   │   │   │   ├── chest_x_ray_images_with_pneumothorax_masks
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── train.txt
+  │   │   │   │   │   │   ├── val.txt
+  │   │   │   │   │   │   ├── images
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   ├── masks
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+```
+
+### Training commands
+
+```shell
+mim train mmseg ./configs/${CONFIG_PATH}
+```
+
+To train on multiple GPUs, e.g. 8 GPUs, run the following command:
+
+```shell
+mim train mmseg ./configs/${CONFIG_PATH}  --launcher pytorch --gpus 8
+```
+
+### Testing commands
+
+```shell
+mim test mmseg ./configs/${CONFIG_PATH}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+  - [x] Basic docstrings & proper citation
+  - [x] Test-time correctness
+  - [x] A full README
+
+- [x] Milestone 2: Indicates a successful model implementation.
+
+  - [x] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+  - [ ] Unit tests
+  - [ ] Code polishing
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/chest-x-ray-images-with-pneumothorax-masks_512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/chest-x-ray-images-with-pneumothorax-masks_512x512.py
new file mode 100644
index 0000000..96676de
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/chest-x-ray-images-with-pneumothorax-masks_512x512.py
@@ -0,0 +1,42 @@
+dataset_type = 'ChestPenumoMaskDataset'
+data_root = 'data/'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='train.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='val.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
new file mode 100644
index 0000000..76c214d
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
@@ -0,0 +1,20 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    './chest-x-ray-images-with-pneumothorax-masks_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(
+    imports='datasets.chest-x-ray-images-with-pneumothorax-masks_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(
+        num_classes=2, loss_decode=dict(use_sigmoid=True), out_channels=1),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
new file mode 100644
index 0000000..066996d
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
@@ -0,0 +1,19 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    './chest-x-ray-images-with-pneumothorax-masks_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(
+    imports='datasets.chest-x-ray-images-with-pneumothorax-masks_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
new file mode 100644
index 0000000..a7065b8
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
@@ -0,0 +1,19 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    './chest-x-ray-images-with-pneumothorax-masks_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(
+    imports='datasets.chest-x-ray-images-with-pneumothorax-masks_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
new file mode 100644
index 0000000..e5682ee
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
@@ -0,0 +1,19 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py',
+    './chest-x-ray-images-with-pneumothorax-masks_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(
+    imports='datasets.chest-x-ray-images-with-pneumothorax-masks_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/datasets/chest-x-ray-images-with-pneumothorax-masks_dataset.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/datasets/chest-x-ray-images-with-pneumothorax-masks_dataset.py
new file mode 100644
index 0000000..d32f597
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/datasets/chest-x-ray-images-with-pneumothorax-masks_dataset.py
@@ -0,0 +1,31 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class ChestPenumoMaskDataset(BaseSegDataset):
+    """ChestPenumoMaskDataset dataset.
+
+    In segmentation map annotation for ChestPenumoMaskDataset,
+    0 stands for background, which is included in 2 categories.
+    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
+    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
+
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+        reduce_zero_label (bool): Whether to mark label zero as ignored.
+            Default to False.
+    """
+    METAINFO = dict(classes=('background', 'penumothroax'))
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/tools/prepare_dataset.py
new file mode 100644
index 0000000..c7de1f1
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/tools/prepare_dataset.py
@@ -0,0 +1,36 @@
+import glob
+import os
+import shutil
+
+from PIL import Image
+from sklearn.model_selection import train_test_split
+
+root_path = 'data/'
+img_suffix = '.png'
+seg_map_suffix = '.png'
+save_img_suffix = '.png'
+save_seg_map_suffix = '.png'
+
+all_imgs = glob.glob('data/siim-acr-pneumothorax/png_images/*' + img_suffix)
+x_train, x_test = train_test_split(all_imgs, test_size=0.2, random_state=0)
+
+print(len(x_train), len(x_test))
+os.system('mkdir -p ' + root_path + 'images/train/')
+os.system('mkdir -p ' + root_path + 'images/val/')
+os.system('mkdir -p ' + root_path + 'masks/train/')
+os.system('mkdir -p ' + root_path + 'masks/val/')
+
+part_dir_dict = {0: 'train/', 1: 'val/'}
+for ith, part in enumerate([x_train, x_test]):
+    part_dir = part_dir_dict[ith]
+    for img in part:
+        basename = os.path.basename(img)
+        img_save_path = os.path.join(root_path, 'images', part_dir,
+                                     basename.split('.')[0] + save_img_suffix)
+        shutil.copy(img, img_save_path)
+        mask_path = 'data/siim-acr-pneumothorax/png_masks/' + basename
+        mask = Image.open(mask_path).convert('L')
+        mask_save_path = os.path.join(
+            root_path, 'masks', part_dir,
+            basename.split('.')[0] + save_seg_map_suffix)
+        mask.save(mask_save_path)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/README.md b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/README.md
new file mode 100644
index 0000000..8469219
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/README.md
@@ -0,0 +1,158 @@
+# Covid-19 CT Chest X-ray Dataset
+
+## Description
+
+This project supports **`Covid-19 CT Chest X-ray Dataset`**, which can be downloaded from [here](https://github.com/ieee8023/covid-chestxray-dataset).
+
+### Dataset Overview
+
+In the context of a COVID-19 pandemic, we want to improve prognostic predictions to triage and manage patient care. Data is the first step to developing any diagnostic/prognostic tool. While there exist large public datasets of more typical chest X-rays from the NIH \[Wang 2017\], Spain \[Bustos 2019\], Stanford \[Irvin 2019\], MIT \[Johnson 2019\] and Indiana University \[Demner-Fushman 2016\], there is no collection of COVID-19 chest X-rays or CT scans designed to be used for computational analysis.
+
+The 2019 novel coronavirus (COVID-19) presents several unique features [Fang, 2020](https://pubs.rsna.org/doi/10.1148/radiol.2020200432) and [Ai 2020](https://pubs.rsna.org/doi/10.1148/radiol.2020200642). While the diagnosis is confirmed using polymerase chain reaction (PCR), infected patients with pneumonia may present on chest X-ray and computed tomography (CT) images with a pattern that is only moderately characteristic for the human eye [Ng, 2020](https://pubs.rsna.org/doi/10.1148/ryct.2020200034). In late January, a Chinese team published a paper detailing the clinical and paraclinical features of COVID-19. They reported that patients present abnormalities in chest CT images with most having bilateral involvement [Huang 2020](<https://www.thelancet.com/journals/lancet/article/PIIS0140-6736(20)30183-5/fulltext>). Bilateral multiple lobular and subsegmental areas of consolidation constitute the typical findings in chest CT images of intensive care unit (ICU) patients on admission [Huang 2020](<https://www.thelancet.com/journals/lancet/article/PIIS0140-6736(20)30183-5/fulltext>). In comparison, non-ICU patients show bilateral ground-glass opacity and subsegmental areas of consolidation in their chest CT images [Huang 2020](<https://www.thelancet.com/journals/lancet/article/PIIS0140-6736(20)30183-5/fulltext>). In these patients, later chest CT images display bilateral ground-glass opacity with resolved consolidation [Huang 2020](<https://www.thelancet.com/journals/lancet/article/PIIS0140-6736(20)30183-5/fulltext>).
+
+### Statistic Information
+
+| Dataset Name                                                           | Anatomical Region | Task Type    | Modality | Nnum. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release date | License                                                               |
+| ---------------------------------------------------------------------- | ----------------- | ------------ | -------- | ------------- | --------------------- | ---------------------- | ------------ | --------------------------------------------------------------------- |
+| [Covid-19-ct-cxr](https://github.com/ieee8023/covid-chestxray-dataset) | thorax            | segmentation | x_ray    | 2             | 205/-/714             | yes/-/no               | 2021         | [CC-BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) |
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |    205     |   72.84    |    -     |    -     |     -     |     -     |
+|    lung    |    205     |   27.16    |    -     |    -     |     -     |     -     |
+
+Note:
+
+- `Pct` means percentage of pixels in this category in all pixels.
+
+### Visualization
+
+![cov19ctcxr](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/x_ray/covid_19_ct_cxr/covid_19_ct_cxr_dataset.png?raw=true)
+
+### Dataset Citation
+
+```
+@article{cohen2020covidProspective,
+  title={{COVID-19} Image Data Collection: Prospective Predictions Are the Future},
+  author={Joseph Paul Cohen and Paul Morrison and Lan Dao and Karsten Roth and Tim Q Duong and Marzyeh Ghassemi},
+  journal={arXiv 2006.11988},
+  year={2020}
+}
+
+@article{cohen2020covid,
+  title={COVID-19 image data collection},
+  author={Joseph Paul Cohen and Paul Morrison and Lan Dao},
+  journal={arXiv 2003.11597},
+  year={2020}
+}
+```
+
+### Prerequisites
+
+- Python v3.8
+- PyTorch v1.10.0
+- pillow(PIL) v9.3.0 9.3.0
+- scikit-learn(sklearn) v1.2.0 1.2.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+
+All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `covid_19_ct_cxr/` root directory, run the following line to add the current directory to `PYTHONPATH`:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset Preparing
+
+- download dataset from [here](https://github.com/ieee8023/covid-chestxray-dataset) and decompress data to path `'data/'`.
+- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
+- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set cannot be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
+
+```shell
+mkdir data && cd data
+git clone git@github.com:ieee8023/covid-chestxray-dataset.git
+cd ..
+python tools/prepare_dataset.py
+python ../../tools/split_seg_dataset.py
+```
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── x_ray
+  │   │   │   │   ├── covid_19_ct_cxr
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── train.txt
+  │   │   │   │   │   │   ├── val.txt
+  │   │   │   │   │   │   ├── images
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   ├── masks
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+```
+
+### Divided Dataset Information
+
+***Note: The table information below is divided by ourselves.***
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |    164     |   72.88    |    41    |  72.69   |     -     |     -     |
+|    lung    |    164     |   27.12    |    41    |  27.31   |     -     |     -     |
+
+### Training commands
+
+To train models on a single server with one GPU. (default)
+
+```shell
+mim train mmseg ./configs/${CONFIG_FILE}
+```
+
+### Testing commands
+
+To test models on a single server with one GPU. (default)
+
+```shell
+mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
+
+You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+  - [x] Basic docstrings & proper citation
+  - [x] Test-time correctness
+  - [x] A full README
+
+- [x] Milestone 2: Indicates a successful model implementation.
+
+  - [x] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+  - [ ] Unit tests
+  - [ ] Code polishing
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/covid-19-ct-cxr_512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/covid-19-ct-cxr_512x512.py
new file mode 100644
index 0000000..5242d06
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/covid-19-ct-cxr_512x512.py
@@ -0,0 +1,42 @@
+dataset_type = 'Covid19CXRDataset'
+data_root = 'data/'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='train.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='val.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_covid-19-ct-cxr-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_covid-19-ct-cxr-512x512.py
new file mode 100644
index 0000000..59a7bed
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_covid-19-ct-cxr-512x512.py
@@ -0,0 +1,18 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './covid-19-ct-cxr_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.covid-19-ct-cxr_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(
+        num_classes=2, loss_decode=dict(use_sigmoid=True), out_channels=1),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_covid-19-ct-cxr-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_covid-19-ct-cxr-512x512.py
new file mode 100644
index 0000000..83b8527
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_covid-19-ct-cxr-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './covid-19-ct-cxr_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.covid-19-ct-cxr_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_covid-19-ct-cxr-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_covid-19-ct-cxr-512x512.py
new file mode 100644
index 0000000..10cfcbd
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_covid-19-ct-cxr-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './covid-19-ct-cxr_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.covid-19-ct-cxr_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_covid-19-ct-cxr-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_covid-19-ct-cxr-512x512.py
new file mode 100644
index 0000000..aaccc8f
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_covid-19-ct-cxr-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './covid-19-ct-cxr_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.covid-19-ct-cxr_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/datasets/covid-19-ct-cxr_dataset.py b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/datasets/covid-19-ct-cxr_dataset.py
new file mode 100644
index 0000000..68a1bb3
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/datasets/covid-19-ct-cxr_dataset.py
@@ -0,0 +1,31 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class Covid19CXRDataset(BaseSegDataset):
+    """Covid19CXRDataset dataset.
+
+    In segmentation map annotation for Covid19CXRDataset,
+    0 stands for background, which is included in 2 categories.
+    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
+    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
+
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+        reduce_zero_label (bool): Whether to mark label zero as ignored.
+            Default to False.
+    """
+    METAINFO = dict(classes=('background', 'lung'))
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/tools/prepare_dataset.py
new file mode 100644
index 0000000..72f6435
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/tools/prepare_dataset.py
@@ -0,0 +1,52 @@
+import os
+
+import numpy as np
+from PIL import Image
+
+root_path = 'data/'
+src_img_dir = os.path.join(root_path, 'covid-chestxray-dataset', 'images')
+src_mask_dir = os.path.join(root_path, 'covid-chestxray-dataset',
+                            'annotations/lungVAE-masks')
+tgt_img_train_dir = os.path.join(root_path, 'images/train/')
+tgt_mask_train_dir = os.path.join(root_path, 'masks/train/')
+tgt_img_test_dir = os.path.join(root_path, 'images/test/')
+os.system('mkdir -p ' + tgt_img_train_dir)
+os.system('mkdir -p ' + tgt_mask_train_dir)
+os.system('mkdir -p ' + tgt_img_test_dir)
+
+
+def convert_label(img, convert_dict):
+    arr = np.zeros_like(img, dtype=np.uint8)
+    for c, i in convert_dict.items():
+        arr[img == c] = i
+    return arr
+
+
+if __name__ == '__main__':
+
+    all_img_names = os.listdir(src_img_dir)
+    all_mask_names = os.listdir(src_mask_dir)
+
+    for img_name in all_img_names:
+        base_name = img_name.replace('.png', '')
+        base_name = base_name.replace('.jpg', '')
+        base_name = base_name.replace('.jpeg', '')
+        mask_name_orig = base_name + '_mask.png'
+        if mask_name_orig in all_mask_names:
+            mask_name = base_name + '.png'
+            src_img_path = os.path.join(src_img_dir, img_name)
+            src_mask_path = os.path.join(src_mask_dir, mask_name_orig)
+            tgt_img_path = os.path.join(tgt_img_train_dir, img_name)
+            tgt_mask_path = os.path.join(tgt_mask_train_dir, mask_name)
+
+            img = Image.open(src_img_path).convert('RGB')
+            img.save(tgt_img_path)
+            mask = np.array(Image.open(src_mask_path))
+            mask = convert_label(mask, {0: 0, 255: 1})
+            mask = Image.fromarray(mask)
+            mask.save(tgt_mask_path)
+        else:
+            src_img_path = os.path.join(src_img_dir, img_name)
+            tgt_img_path = os.path.join(tgt_img_test_dir, img_name)
+            img = Image.open(src_img_path).convert('RGB')
+            img.save(tgt_img_path)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/crass/README.md b/mmsegmentation/projects/medical/2d_image/x_ray/crass/README.md
new file mode 100644
index 0000000..0621205
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/crass/README.md
@@ -0,0 +1,144 @@
+# Chest Radiograph Anatomical Structure Segmentation (CRASS)
+
+## Description
+
+This project supports **`Chest Radiograph Anatomical Structure Segmentation (CRASS) `**, which can be downloaded from [here](https://crass.grand-challenge.org/).
+
+### Dataset Overview
+
+A set of consecutively obtained posterior-anterior chest radiograph were selected from a database containing images acquired at two sites in sub Saharan Africa with a high tuberculosis incidence. All subjects were 15 years or older. Images from digital chest radiography units were used (Delft Imaging Systems, The Netherlands) of varying resolutions, with a typical resolution of 1800--2000 pixels, the pixel size was 250 lm isotropic. From the total set of images, 225 were considered to be normal by an expert radiologist, while 333 of the images contained abnormalities. Of the abnormal images, 220 contained abnormalities in the upper area of the lung where the clavicle is located. The data was divided into a training and a test set. The training set consisted of 299 images, the test set of 249 images.
+The current data is still incomplete and to be added later.
+
+### Information Statistics
+
+| Dataset Name                                | Anatomical Region | Task Type    | Modality | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                       |
+| ------------------------------------------- | ----------------- | ------------ | -------- | ------------ | --------------------- | ---------------------- | ------------ | ------------------------------------------------------------- |
+| [crass](https://crass.grand-challenge.org/) | pulmonary         | segmentation | x_ray    | 2            | 299/-/234             | yes/-/no               | 2021         | [CC0 1.0](https://creativecommons.org/publicdomain/zero/1.0/) |
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |    299     |   98.38    |    -     |    -     |     -     |     -     |
+| clavicles  |    299     |    1.62    |    -     |    -     |     -     |     -     |
+
+Note:
+
+- `Pct` means percentage of pixels in this category in all pixels.
+
+### Visualization
+
+![crass](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/x_ray/crass/crass_dataset.png?raw=true)
+
+### Dataset Citation
+
+```
+@article{HOGEWEG20121490,
+	title={Clavicle segmentation in chest radiographs},
+	journal={Medical Image Analysis},
+	volume={16},
+	number={8},
+	pages={1490-1502},
+	year={2012}
+}
+```
+
+### Prerequisites
+
+- Python v3.8
+- PyTorch v1.10.0
+- pillow(PIL) v9.3.0
+- scikit-learn(sklearn) v1.2.0
+- [MIM](https://github.com/open-mmlab/mim) v0.3.4
+- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
+- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+
+All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `crass/` root directory, run the following line to add the current directory to `PYTHONPATH`:
+
+```shell
+export PYTHONPATH=`pwd`:$PYTHONPATH
+```
+
+### Dataset Preparing
+
+- download dataset from [here](https://crass.grand-challenge.org/) and decompress data to path `'data/'`.
+- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
+- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set cannot be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
+
+```none
+  mmsegmentation
+  ├── mmseg
+  ├── projects
+  │   ├── medical
+  │   │   ├── 2d_image
+  │   │   │   ├── x_ray
+  │   │   │   │   ├── crass
+  │   │   │   │   │   ├── configs
+  │   │   │   │   │   ├── datasets
+  │   │   │   │   │   ├── tools
+  │   │   │   │   │   ├── data
+  │   │   │   │   │   │   ├── train.txt
+  │   │   │   │   │   │   ├── val.txt
+  │   │   │   │   │   │   ├── images
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+  │   │   │   │   │   │   ├── masks
+  │   │   │   │   │   │   │   ├── train
+  │   │   │   │   |   │   │   │   ├── xxx.png
+  │   │   │   │   |   │   │   │   ├── ...
+  │   │   │   │   |   │   │   │   └── xxx.png
+```
+
+### Divided Dataset Information
+
+***Note: The table information below is divided by ourselves.***
+
+| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
+| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
+| background |    227     |   98.38    |    57    |  98.39   |     -     |     -     |
+| clavicles  |    227     |    1.62    |    57    |   1.61   |     -     |     -     |
+
+### Training commands
+
+To train models on a single server with one GPU. (default)
+
+```shell
+mim train mmseg ./configs/${CONFIG_FILE}
+```
+
+### Testing commands
+
+To test models on a single server with one GPU. (default)
+
+```shell
+mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
+```
+
+<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
+
+You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
+
+## Checklist
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+  - [x] Basic docstrings & proper citation
+  - [ ] Test-time correctness
+  - [x] A full README
+
+- [x] Milestone 2: Indicates a successful model implementation.
+
+  - [x] Training-time correctness
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+  - [ ] Unit tests
+  - [ ] Code polishing
+  - [ ] Metafile.yml
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/crass_512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/crass_512x512.py
new file mode 100644
index 0000000..1425f50
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/crass_512x512.py
@@ -0,0 +1,42 @@
+dataset_type = 'CRASSDataset'
+data_root = 'data/'
+img_scale = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=img_scale, keep_ratio=False),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='train.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='tval.txt',
+        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_crass-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_crass-512x512.py
new file mode 100644
index 0000000..b52bc78
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_crass-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './crass_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.crass_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_crass-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_crass-512x512.py
new file mode 100644
index 0000000..45242c6
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_crass-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './crass_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.crass_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.001)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_crass-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_crass-512x512.py
new file mode 100644
index 0000000..bcf9d0a
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_crass-512x512.py
@@ -0,0 +1,17 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './crass_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.crass_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=2),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-lr0.01-sigmoid-20k_crass-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-lr0.01-sigmoid-20k_crass-512x512.py
new file mode 100644
index 0000000..0dde736
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-lr0.01-sigmoid-20k_crass-512x512.py
@@ -0,0 +1,18 @@
+_base_ = [
+    'mmseg::_base_/models/fcn_unet_s5-d16.py', './crass_512x512.py',
+    'mmseg::_base_/default_runtime.py',
+    'mmseg::_base_/schedules/schedule_20k.py'
+]
+custom_imports = dict(imports='datasets.crass_dataset')
+img_scale = (512, 512)
+data_preprocessor = dict(size=img_scale)
+optimizer = dict(lr=0.01)
+optim_wrapper = dict(optimizer=optimizer)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(
+        num_classes=2, loss_decode=dict(use_sigmoid=True), out_channels=1),
+    auxiliary_head=None,
+    test_cfg=dict(mode='whole', _delete_=True))
+vis_backends = None
+visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/crass/datasets/crass_dataset.py b/mmsegmentation/projects/medical/2d_image/x_ray/crass/datasets/crass_dataset.py
new file mode 100644
index 0000000..f6b5c52
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/crass/datasets/crass_dataset.py
@@ -0,0 +1,30 @@
+from mmseg.datasets import BaseSegDataset
+from mmseg.registry import DATASETS
+
+
+@DATASETS.register_module()
+class CRASSDataset(BaseSegDataset):
+    """CRASSDataset dataset.
+
+    In segmentation map annotation for CRASSDataset, 0 stands for background,
+    which is included in 2 categories. ``reduce_zero_label`` is fixed to
+    False. The ``img_suffix`` is fixed to '.png' and ``seg_map_suffix`` is
+    fixed to '.png'.
+    Args:
+        img_suffix (str): Suffix of images. Default: '.png'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+        reduce_zero_label (bool): Whether to mark label zero as ignored.
+            Default to False..
+    """
+    METAINFO = dict(classes=('background', 'clavicles'))
+
+    def __init__(self,
+                 img_suffix='.png',
+                 seg_map_suffix='.png',
+                 reduce_zero_label=False,
+                 **kwargs) -> None:
+        super().__init__(
+            img_suffix=img_suffix,
+            seg_map_suffix=seg_map_suffix,
+            reduce_zero_label=reduce_zero_label,
+            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/crass/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/x_ray/crass/tools/prepare_dataset.py
new file mode 100644
index 0000000..bbd5d88
--- /dev/null
+++ b/mmsegmentation/projects/medical/2d_image/x_ray/crass/tools/prepare_dataset.py
@@ -0,0 +1,84 @@
+import glob
+import os
+
+import cv2
+import SimpleITK as sitk
+from PIL import Image
+
+root_path = 'data/'
+img_suffix = '.tif'
+seg_map_suffix = '.png'
+save_img_suffix = '.png'
+save_seg_map_suffix = '.png'
+
+src_img_train_dir = os.path.join(root_path, 'CRASS/data_train')
+src_mask_train_dir = os.path.join(root_path, 'CRASS/mask_mhd')
+src_img_test_dir = os.path.join(root_path, 'CRASS/data_test')
+
+tgt_img_train_dir = os.path.join(root_path, 'images/train/')
+tgt_mask_train_dir = os.path.join(root_path, 'masks/train/')
+tgt_img_test_dir = os.path.join(root_path, 'images/test/')
+os.system('mkdir -p ' + tgt_img_train_dir)
+os.system('mkdir -p ' + tgt_mask_train_dir)
+os.system('mkdir -p ' + tgt_img_test_dir)
+
+
+def filter_suffix_recursive(src_dir, suffix):
+    suffix = '.' + suffix if '.' not in suffix else suffix
+    file_paths = glob(
+        os.path.join(src_dir, '**', '*' + suffix), recursive=True)
+    file_names = [_.split('/')[-1] for _ in file_paths]
+    return sorted(file_paths), sorted(file_names)
+
+
+def read_single_array_from_med(path):
+    return sitk.GetArrayFromImage(sitk.ReadImage(path)).squeeze()
+
+
+def convert_meds_into_pngs(src_dir,
+                           tgt_dir,
+                           suffix='.dcm',
+                           norm_min=0,
+                           norm_max=255,
+                           convert='RGB'):
+    if not os.path.exists(tgt_dir):
+        os.makedirs(tgt_dir)
+
+    src_paths, src_names = filter_suffix_recursive(src_dir, suffix=suffix)
+    num = len(src_paths)
+    for i, (src_name, src_path) in enumerate(zip(src_names, src_paths)):
+        tgt_name = src_name.replace(suffix, '.png')
+        tgt_path = os.path.join(tgt_dir, tgt_name)
+
+        img = read_single_array_from_med(src_path)
+        if norm_min is not None and norm_max is not None:
+            img = cv2.normalize(img, None, norm_min, norm_max, cv2.NORM_MINMAX,
+                                cv2.CV_8U)
+        pil = Image.fromarray(img).convert(convert)
+        pil.save(tgt_path)
+        print(f'processed {i+1}/{num}.')
+
+
+convert_meds_into_pngs(
+    src_img_train_dir,
+    tgt_img_train_dir,
+    suffix='.mhd',
+    norm_min=0,
+    norm_max=255,
+    convert='RGB')
+
+convert_meds_into_pngs(
+    src_img_test_dir,
+    tgt_img_test_dir,
+    suffix='.mhd',
+    norm_min=0,
+    norm_max=255,
+    convert='RGB')
+
+convert_meds_into_pngs(
+    src_mask_train_dir,
+    tgt_mask_train_dir,
+    suffix='.mhd',
+    norm_min=0,
+    norm_max=1,
+    convert='L')
diff --git a/mmsegmentation/projects/nvidia_jetson/README.md b/mmsegmentation/projects/nvidia_jetson/README.md
new file mode 100644
index 0000000..6cebd9c
--- /dev/null
+++ b/mmsegmentation/projects/nvidia_jetson/README.md
@@ -0,0 +1,372 @@
+# 将 MMSeg 模型调优及部署到 NVIDIA Jetson 平台教程
+
+- 请先查阅[MMSegmentation 模型部署](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/5_deployment.md)文档。
+- **本教程所用 mmsegmentation 版本： v1.1.2**
+- **本教程所用 NVIDIA Jetson 设备： NVIDIA Jetson AGX Orin 64G**
+
+<div align="center">
+    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/b5466cfd-71a9-4e06-9823-c253a97d57b5" alt="Smiley face" width="50%">
+</div>
+
+## 1 配置 [mmsegmentation](https://github.com/open-mmlab/mmsegmentation)
+
+- 根据[安装和验证](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/get_started.md)文档，完成开发 [mmsegmentation](https://github.com/open-mmlab/mmsegmentation) 所需的 [`pytorch`](https://pytorch.org/get-started/locally/)、[`mmcv`](https://github.com/open-mmlab/mmcv)、[`mmengine`](https://github.com/open-mmlab/mmengine) 等环境依赖安装。
+- 从 GitHub 使用 git clone 命令完成 [mmsegmentation](https://github.com/open-mmlab/mmsegmentation) 下载。网络不好的同学，可通过 [MMSeg GitHub](https://github.com/open-mmlab/mmsegmentation) 页面进行 zip 的下载。
+  ```bash
+  git clone https://github.com/open-mmlab/mmsegmentation.git
+  ```
+- 使用 `pip install -v -e.` 命令动态安装 mmsegmentation 。
+  ```bash
+  cd mmsegmentation
+  pip install -v -e .
+  ```
+  提示成功安装后，可通过 `pip list` 命令查看到 mmsegmentation 已通过本地安装方式安装到了您的环境中。
+  ![mmseg-install](https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/a9c7bcc9-cdcc-40a4-bd7b-8153195549c8)
+
+## 2 准备您的数据集
+
+- 本教程使用遥感图像语义分割数据集 [potsdam](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#isprs-potsdam) 作为示例。
+- 根据 [potsdam 数据准备](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#isprs-potsdam)文档，进行数据集下载及 MMSeg 格式的准备。
+- 数据集介绍： potsdam 数据集是以德国一个典型的历史城市 Potsdam 命名的，该城市有着大建筑群、狭窄的街道和密集的建筑结构。 potsdam 数据集包含 38 幅 6000x6000 像素的图像，空间分辨率为 5cm，数据集的示例如下图：
+  ![potsdam-img](https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/3bc0a75b-1693-4ae6-aeea-ad502e955068)
+
+## 3 从 config 页面下载模型的 pth 权重文件
+
+这里以 [`deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py`](../../configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py) 配置文件举例，在 [configs](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/deeplabv3plus#potsdam) 页面下载权重文件，
+![pth](https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/8f747362-caf4-406c-808d-4ca72babb209)
+
+## 4 通过 [OpenMMLab deployee](https://platform.openmmlab.com/deploee) 以交互式方式进行模型转换及测速
+
+### 4.1 模型转换
+
+在该部分中，[OpenMMLab 官网](https://platform.openmmlab.com/deploee)提供了模型转换及模型测速的交互界面，无需任何代码，即可通过选择对应选项完成模型 ONNX 格式`xxxx.onnx` 和 TensorRT `.engine`格式的转换。
+如您的自定义 config 文件中有相对引用关系，如：
+
+```python
+# xxxx.py
+_base_ = [
+    '../_base_/models/deeplabv3plus_r50-d8.py',
+    '../_base_/datasets/potsdam.py',
+    '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_80k.py'
+]
+```
+
+您可以使用以下代码消除相对引用关系，以生成完整的 config 文件。
+
+```python
+import mmengine
+
+mmengine.Config.fromfile("configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py").dump("My_config.py")
+```
+
+使用上述代码后，您能够看到，在`My_config.py`包含着完整的配置文件，无相对引用。这时，上传模型 config 至网页内对应处。
+
+#### 创建转换任务
+
+按照下图提示及自己的需求，创建转换任务并提交。
+
+<div align="center">
+    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/4918d2f9-d63c-480f-97f1-054529770cfd" alt="NVIDIA-Jetson" width="80%">
+</div>
+
+### 4.2 模型测速
+
+在完成模型转换后可通过**模型测速**界面，完成在真实设备上的模型测速。
+
+#### 创建测速任务
+
+<div align="center">
+    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/27340556-c81a-4ce3-8560-2c4727d3355e" alt="NVIDIA-Jetson" width="100%">
+</div>
+
+<div align="center">
+    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/6f4fc3a9-ba9d-4829-8407-ed1470ba7bf3" alt="NVIDIA-Jetson" width="100%">
+</div>
+
+测速完成后，可在页面生成完整的测速报告。[查看测速报告示例](https://openmmlab-deploee.oss-cn-shanghai.aliyuncs.com/tmp/profile_speed/4352f5.txt)
+
+## 5 通过 OpenMMLab mmdeploy 以命令行将模型转换为ONNX格式
+
+该部分可以通过 mmdeploy 库对 mmseg 训练好的模型进行推理格式的转换。这里给出一个示例，具体文档可见[ mmdeploy 模型转换文档](../../docs/zh_cn/user_guides/5_deployment.md)。
+
+### 5.1 通过源码构建 mmdeploy 库
+
+在您安装 mmsegmentation 库的虚拟环境下，通过 `git clone`命令从 GitHub 克隆 [mmdeploy](https://github.com/open-mmlab/mmdeploy)
+
+### 5.2 模型转换
+
+如您的 config 中含有相对引用，仍需进行消除，如[4.1 模型转换](#4.1-模型转换)所述,
+进入 mmdeploy 文件夹，执行以下命令，即可完成模型转换。
+
+```bash
+python tools/deploy.py \
+    configs/mmseg/segmentation_onnxruntime_static-512x512.py \
+    ../atl_config.py \
+    ../deeplabv3plus_r18-d8_512x512_80k_potsdam_20211219_020601-75fd5bc3.pth \
+    ../2_13_1024_5488_1536_6000.png \
+    --work-dir ../atl_models \
+    --device cpu \
+    --show \
+    --dump-info
+```
+
+```bash
+# 使用方法
+python ./tools/deploy.py \
+    ${部署配置文件路径} \
+    ${模型配置文件路径} \
+    ${模型权重路径} \
+    ${输入图像路径} \
+    --work-dir ${用来保存日志和模型文件路径} \
+    --device ${cpu/cuda:0} \
+    --show \    # 是否显示检测的结果
+    --dump-info # 是否输出 SDK 信息
+
+```
+
+执行成功后，您将能够看到以下提示，即为转换成功。
+
+```bash
+10/08 17:40:44 - mmengine - INFO - visualize pytorch model success.
+10/08 17:40:44 - mmengine - INFO - All process success.
+```
+
+<div align="center">
+    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/b752ccf8-903f-4ad3-ad7c-74fc25cb89a5" alt="NVIDIA-Jetson" width="400">
+</div>
+
+# 6 在 Jetson 平台进行转换及部署
+
+## 6.1 环境准备
+
+参考[如何在 Jetson 模组上安装 MMDeploy](https://github.com/open-mmlab/mmdeploy/blob/main/docs/zh_cn/01-how-to-build/jetsons.md)文档，完成在 Jetson 上的环境准备工作。
+**注**：安装 Pytorch，可查阅 [NVIDIA Jetson Pytorch 安装文档](https://github.com/open-mmlab/mmdeploy/blob/main/docs/zh_cn/01-how-to-build/jetsons.md)安装最新的 Pytorch。
+
+### 6.1.1 创建虚拟环境
+
+```bash
+conda create -n {您虚拟环境的名字} python={python版本}
+```
+
+### 6.1.2 虚拟环境内安装Pytorch
+
+<font color="red">注意：</font>这里不要安装最新的 pytorch 2.0，因为 pyTorch 1.11 是最后一个使用 USE_DISTRIBUTED 构建的wheel，否则会在用mmdeploy进行模型转换的时候提示`AttributeError: module 'torch.distributed' has no attribute 'ReduceOp'`的错误。参考以下链接：https://forums.developer.nvidia.com/t/module-torch-distributed-has-no-attribute-reduceop/256581/6
+下载`torch-1.11.0-cp38-cp38-linux_aarch64.whl`并安装
+
+```bash
+pip install torch-1.11.0-cp38-cp38-linux_aarch64.whl
+```
+
+执行以上命令后，您将能看到以下提示，即为安装成功。
+
+```bash
+Processing ./torch-1.11.0-cp38-cp38-linux_aarch64.whl
+Requirement already satisfied: typing-extensions in /home/sirs/miniconda3/envs/openmmlab/lib/python3.8/site-packages (from torch==1.11.0) (4.7.1)
+Installing collected packages: torch
+Successfully installed torch-1.11.0
+```
+
+### 6.1.3 将 Jetson Pack 自带的 tensorrt 拷贝至虚拟环境下
+
+请参考[配置 TensorRT](https://github.com/open-mmlab/mmdeploy/blob/main/docs/zh_cn/01-how-to-build/jetsons.md#%E9%85%8D%E7%BD%AE-tensorrt)。
+JetPack SDK 自带 TensorRT。 但是为了能够在 Conda 环境中成功导入，我们需要将 TensorRT 拷贝进先前创建的 Conda 环境中。
+
+```bash
+export PYTHON_VERSION=`python3 --version | cut -d' ' -f 2 | cut -d'.' -f1,2`
+cp -r /usr/lib/python${PYTHON_VERSION}/dist-packages/tensorrt* ~/miniconda/envs/{您的虚拟环境名字}/lib/python${PYTHON_VERSION}/site-packages/
+```
+
+### 6.1.4 安装 MMCV
+
+通过`mim install mmcv`或从源码对其进行编译。
+
+```bash
+pip install openmim
+mim install mmcv
+```
+
+或者从源码对其进行编译。
+
+```bash
+sudo apt-get install -y libssl-dev
+git clone https://github.com/open-mmlab/mmcv.git
+cd mmcv
+pip install -e .
+```
+
+<font color="red">注：pytorch版本发生变动后，需要重新编译mmcv。</font>
+
+### 6.1.5 安装 ONNX
+
+<font color="red">注：以下方式二选一</font>
+
+- conda
+  ```bash
+  conda install -c conda-forge onnx
+  ```
+- pip
+  ```bash
+  python3 -m pip install onnx
+  ```
+
+### 6.1.6 安装 ONNX Runtime
+
+根据网页 [ONNX Runtime](https://elinux.org/Jetson_Zoo#ONNX_Runtime) 选择合适的ONNX Runtime版本进行下载安装。
+示例：
+
+```bash
+# Install pip wheel
+$ pip3 install onnxruntime_gpu-1.10.0-cp38-cp38-linux_aarch64.whl
+
+```
+
+## 6.2 在 Jetson AGX Orin 进行模型转换及推理
+
+### 6.2.1 ONNX 模型转换
+
+同[4.1 模型转换](#4.1-模型转换)相同，在 Jetson 平台下进入安装好的虚拟环境，以及mmdeploy 目录，进行模型ONNX转换。
+
+```bash
+python tools/deploy.py \
+    configs/mmseg/segmentation_onnxruntime_static-512x512.py \
+    ../atl_config.py \
+    ../deeplabv3plus_r18-d8_512x512_80k_potsdam_20211219_020601-75fd5bc3.pth \
+    ../2_13_3584_2560_4096_3072.png \
+    --work-dir ../atl_models \
+    --device cpu \
+    --show \
+    --dump-info
+
+```
+
+<font color="red">注：</font> 如果报错提示内容：
+
+```none
+AttributeError: module 'torch.distributed' has no attribute 'ReduceOp'
+```
+
+可参考以下链接进行解决：https://forums.developer.nvidia.com/t/module-torch-distributed-has-no-attribute-reduceop/256581/6，即安装 pytorch 1.11.0 版本。
+
+转换成功后，您将会看到如下信息以及包含 ONNX 模型的文件夹：
+
+```bash
+10/09 19:58:22 - mmengine - INFO - visualize pytorch model success.
+10/09 19:58:22 - mmengine - INFO - All process success.
+```
+
+<div align="center">
+    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/d68f1cf6-0e80-4261-91a3-6046b17de146" alt="NVIDIA-Jetson" width="400">
+    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/70470a39-6a4f-4fd5-a06d-9b9d59a768ef" alt="NVIDIA-Jetson" width="160">
+</div>
+
+### 6.2.2 TensorRT 模型转换
+
+更换部署trt配置文件，进行 TensorRT 模型转换。
+
+```bash
+python tools/deploy.py \
+    configs/mmseg/segmentation_tensorrt_static-512x512.py \
+    ../atl_config.py \
+    ../deeplabv3plus_r18-d8_512x512_80k_potsdam_20211219_020601-75fd5bc3.pth \
+    ../2_13_3584_2560_4096_3072.png \
+    --work-dir ../atl_trt_models \
+    --device cuda:0 \
+    --show \
+    --dump-info
+
+```
+
+转换成功后您将看到以下信息及 TensorRT 模型文件夹：
+
+```bash
+10/09 20:15:50 - mmengine - INFO - visualize pytorch model success.
+10/09 20:15:50 - mmengine - INFO - All process success.
+```
+
+<div align="center">
+    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/2ac1428f-b787-4fdd-beaf-6397e5b21e33" alt="NVIDIA-Jetson" width="340">
+    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/70470a39-6a4f-4fd5-a06d-9b9d59a768ef" alt="NVIDIA-Jetson" width="200">
+</div>
+
+## 6.3 模型测速
+
+执行以下命令完成模型测速，详细内容请查看[ profiler ](https://github.com/open-mmlab/mmdeploy/blob/main/docs/zh_cn/02-how-to-run/useful_tools.md#profiler)
+
+```bash
+python tools/profiler.py \
+    ${DEPLOY_CFG} \
+    ${MODEL_CFG} \
+    ${IMAGE_DIR} \
+    --model ${MODEL} \
+    --device ${DEVICE} \
+    --shape ${SHAPE} \
+    --num-iter ${NUM_ITER} \
+    --warmup ${WARMUP} \
+    --cfg-options ${CFG_OPTIONS} \
+    --batch-size ${BATCH_SIZE} \
+    --img-ext ${IMG_EXT}
+```
+
+示例：
+
+```bash
+python tools/profiler.py \
+    configs/mmseg/segmentation_tensorrt_static-512x512.py \
+    ../atl_config.py \
+    ../atl_demo_img \
+    --model /home/sirs/AI-Tianlong/OpenMMLab/atl_trt_models/end2end.engine \
+    --device cuda:0 \
+    --shape 512x512 \
+    --num-iter 100
+```
+
+测速结果
+
+![image](https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/874e9742-ee10-490c-9e69-17da0096c49b)
+
+## 6.4 模型推理
+
+根据[6.2.2](#6.2.2-TensorRT-模型转换)中生成的TensorRT模型文件夹，进行模型推理。
+
+```python
+from mmdeploy.apis.utils import build_task_processor
+from mmdeploy.utils import get_input_shape, load_config
+import torch
+
+deploy_cfg='./mmdeploy/configs/mmseg/segmentation_tensorrt_static-512x512.py'
+model_cfg='./atl_config.py'
+device='cuda:0'
+backend_model = ['./atl_trt_models/end2end.engine']
+image = './atl_demo_img/2_13_2048_1024_2560_1536.png'
+
+# read deploy_cfg and model_cfg
+deploy_cfg, model_cfg = load_config(deploy_cfg, model_cfg)
+
+# build task and backend model
+task_processor = build_task_processor(model_cfg, deploy_cfg, device)
+model = task_processor.build_backend_model(backend_model)
+
+# process input image
+input_shape = get_input_shape(deploy_cfg)
+model_inputs, _ = task_processor.create_input(image, input_shape)
+
+# do model inference
+with torch.no_grad():
+    result = model.test_step(model_inputs)
+
+# visualize results
+task_processor.visualize(
+    image=image,
+    model=model,
+    result=result[0],
+    window_name='visualize',
+    output_file='./output_segmentation.png')
+```
+
+即可得到推理结果：
+
+<div align="center">
+    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/d0ae1fa8-e223-4b3f-b699-6bfa8db38133" alt="NVIDIA-Jetson" width="40%">
+    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/6d999cbe-2101-4e1b-b4a9-13115c9d1928" alt="NVIDIA-Jetson" width="40%">
+</div>
diff --git a/mmsegmentation/projects/pp_mobileseg/README.md b/mmsegmentation/projects/pp_mobileseg/README.md
new file mode 100644
index 0000000..c9f9c12
--- /dev/null
+++ b/mmsegmentation/projects/pp_mobileseg/README.md
@@ -0,0 +1,123 @@
+# PP-MobileSeg: Exploring Transformer Blocks for Efficient Mobile Segmentation.
+
+## Reference
+
+> [PP-MobileSeg: Explore the Fast and Accurate Semantic Segmentation Model on Mobile Devices. ](https://arxiv.org/abs/2304.05152)
+
+## Introduction
+
+<a href="https://github.com/PaddlePaddle/PaddleSeg/tree/release/2.8">Official Repo</a>
+
+<a href="https://github.com/open-mmlab/mmsegmentation/tree/main/projects/pp_mobileseg">Code Snippet</a>
+
+## <img src="https://user-images.githubusercontent.com/34859558/190043857-bfbdaf8b-d2dc-4fff-81c7-e0aac50851f9.png" width="25"/> Abstract
+
+With the success of transformers in computer vision, several attempts have been made to adapt transformers to mobile devices. However, their performance is not satisfied for some real world applications. Therefore, we propose PP-MobileSeg, a SOTA semantic segmentation model for mobile devices.
+
+It is composed of three newly proposed parts, the strideformer backbone, the Aggregated Attention Module(AAM), and the Valid Interpolate Module(VIM):
+
+- With the four-stage MobileNetV3 block as the feature extractor, we manage to extract rich local features of different receptive fields with little parameter overhead. Also, we further efficiently empower features from the last two stages with the global view using strided sea attention.
+- To effectively fuse the features, we use AAM to filter the detail features with ensemble voting and add the semantic feature to it to enhance the semantic information to the most content.
+- At last, we use VIM to upsample the downsampled feature to the original resolution and significantly decrease latency in model inference stage. It only interpolates classes present in the final prediction which only takes around 10% in the ADE20K dataset. This is a common scenario for datasets with large classes. Therefore it significantly decreases the latency of the final upsample process which takes the greatest part of the model's overall latency.
+
+Extensive experiments show that PP-MobileSeg achieves a superior params-accuracy-latency tradeoff compared to other SOTA methods.
+
+<div align="center">
+<img src="https://user-images.githubusercontent.com/34859558/227450728-1338fcb1-3b8a-4453-a155-da60abcacb88.png"  width = "1000" />
+</div>
+
+## <img src="https://user-images.githubusercontent.com/34859558/190044217-8f6befc2-7f20-473d-b356-148e06265205.png" width="25"/> Performance
+
+### ADE20K
+
+| Model             | Backbone          | Training Iters | Batchsize | Train Resolution | mIoU(%) | latency(ms)\* | params(M) | config                                                                                                                    | Links                                                                                                                                                                                                                                |
+| ----------------- | ----------------- | -------------- | --------- | ---------------- | ------- | ------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| PP-MobileSeg-Base | StrideFormer-Base | 80000          | 32        | 512x512          | 41.57%  | 265.5         | 5.62      | [config](https://github.com/Yang-Changhui/mmsegmentation/tree/add_ppmobileseg/projects/pp_mobileseg/configs/pp_mobileseg) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pp_mobileseg/pp_mobileseg_mobilenetv3_2xb16_3rdparty-base_512x512-ade20k-f12b44f3.pth)\|[log](https://bj.bcebos.com/paddleseg/dygraph/ade20k/pp_mobileseg_base/train.log) |
+| PP-MobileSeg-Tiny | StrideFormer-Tiny | 80000          | 32        | 512x512          | 36.39%  | 215.3         | 1.61      | [config](https://github.com/Yang-Changhui/mmsegmentation/tree/add_ppmobileseg/projects/pp_mobileseg/configs/pp_mobileseg) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pp_mobileseg/pp_mobileseg_mobilenetv3_2xb16_3rdparty-tiny_512x512-ade20k-a351ebf5.pth)\|[log](https://bj.bcebos.com/paddleseg/dygraph/ade20k/pp_mobileseg_tiny/train.log) |
+
+## Usage
+
+Same as other models in MMsegmentation, you can run the following command to test the model at ${MMSEG_ROOT}:
+
+```shell
+./tools/dist_test.sh projects/pp_mobileseg/configs/pp_mobileseg/pp_mobileseg_mobilenetv3_2x16_80k_ade20k_512x512_base.py checkpoints/pp_mobileseg_mobilenetv3_2xb16_3rdparty-base_512x512-ade20k-f12b44f3.pth 8
+```
+
+## Inference with ONNXRuntime
+
+### Prerequisites
+
+**1. Install onnxruntime inference engine.**
+
+Choose one of the following ways to install onnxruntime.
+
+- CPU version
+
+```shell
+pip install onnxruntime==1.15.1
+wget https://github.com/microsoft/onnxruntime/releases/download/v1.15.1/onnxruntime-linux-x64-1.15.1.tgz
+tar -zxvf onnxruntime-linux-x64-1.15.1.tgz
+export ONNXRUNTIME_DIR=$(pwd)/onnxruntime-linux-x64-1.15.1
+export LD_LIBRARY_PATH=$ONNXRUNTIME_DIR/lib:$LD_LIBRARY_PATH
+```
+
+**2. Convert model to onnx file**
+
+- Install `mim` and `mmdeploy`.
+
+```shell
+pip install openmim
+mim install mmdeploy
+git clone https://github.com/open-mmlab/mmdeploy.git
+```
+
+- Download pp_mobileseg model.
+
+```shell
+wget https://download.openmmlab.com/mmsegmentation/v0.5/pp_mobileseg/pp_mobileseg_mobilenetv3_2xb16_3rdparty-tiny_512x512-ade20k-a351ebf5.pth
+```
+
+- Convert model to onnx files.
+
+```shell
+python mmdeploy/tools/deploy.py mmdeploy/configs/mmseg/segmentation_onnxruntime_dynamic.py \
+    configs/pp_mobileseg/pp_mobileseg_mobilenetv3_2x16_80k_ade20k_512x512_tiny.py \
+    pp_mobileseg_mobilenetv3_2xb16_3rdparty-tiny_512x512-ade20k-a351ebf5.pth \
+    ../../demo/demo.png \
+    --work-dir mmdeploy_model/mmseg/ort \
+    --show
+```
+
+**3. Run demo**
+
+```shell
+python inference_onnx.py ${ONNX_FILE_PATH} ${IMAGE_PATH} [${MODEL_INPUT_SIZE} ${DEVICE} ${OUTPUT_IMAGE_PATH}]
+```
+
+Example:
+
+```shell
+python inference_onnx.py mmdeploy_model/mmseg/ort/end2end.onnx ../../demo/demo.png
+```
+
+## Citation
+
+If you find our project useful in your research, please consider citing:
+
+```
+@misc{liu2021paddleseg,
+      title={PaddleSeg: A High-Efficient Development Toolkit for Image Segmentation},
+      author={Yi Liu and Lutao Chu and Guowei Chen and Zewu Wu and Zeyu Chen and Baohua Lai and Yuying Hao},
+      year={2021},
+      eprint={2101.06175},
+      archivePrefix={arXiv},
+      primaryClass={cs.CV}
+}
+
+@misc{paddleseg2019,
+    title={PaddleSeg, End-to-end image segmentation kit based on PaddlePaddle},
+    author={PaddlePaddle Contributors},
+    howpublished = {\url{https://github.com/PaddlePaddle/PaddleSeg}},
+    year={2019}
+}
+```
diff --git a/mmsegmentation/projects/pp_mobileseg/backbones/__init__.py b/mmsegmentation/projects/pp_mobileseg/backbones/__init__.py
new file mode 100644
index 0000000..244b33d
--- /dev/null
+++ b/mmsegmentation/projects/pp_mobileseg/backbones/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .strideformer import StrideFormer
+
+__all__ = ['StrideFormer']
diff --git a/mmsegmentation/projects/pp_mobileseg/backbones/strideformer.py b/mmsegmentation/projects/pp_mobileseg/backbones/strideformer.py
new file mode 100644
index 0000000..3f09be5
--- /dev/null
+++ b/mmsegmentation/projects/pp_mobileseg/backbones/strideformer.py
@@ -0,0 +1,958 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+import warnings
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule, build_activation_layer
+from mmcv.cnn.bricks.transformer import build_dropout
+from mmengine.logging import print_log
+from mmengine.model import BaseModule
+from mmengine.runner.checkpoint import CheckpointLoader, load_state_dict
+
+from mmseg.registry import MODELS
+
+
+@MODELS.register_module()
+class StrideFormer(BaseModule):
+    """The StrideFormer implementation based on torch.
+
+    The original article refers to:https://arxiv.org/abs/2304.05152
+    Args:
+        mobileV3_cfg(list): Each sublist describe the config for a
+            MobileNetV3 block.
+        channels(list): The input channels for each MobileNetV3 block.
+        embed_dims(list): The channels of the features input to the sea
+            attention block.
+        key_dims(list, optional): The embeding dims for each head in
+            attention.
+        depths(list, optional): describes the depth of the attention block.
+            i,e: M,N.
+        num_heads(int, optional): The number of heads of the attention
+            blocks.
+        attn_ratios(int, optional): The expand ratio of V.
+        mlp_ratios(list, optional): The ratio of mlp blocks.
+        drop_path_rate(float, optional): The drop path rate in attention
+            block.
+        act_cfg(dict, optional): The activation layer of AAM:
+            Aggregate Attention Module.
+        inj_type(string, optional): The type of injection/AAM.
+        out_channels(int, optional): The output channels of the AAM.
+        dims(list, optional): The dimension of the fusion block.
+        out_feat_chs(list, optional): The input channels of the AAM.
+        stride_attention(bool, optional): whether to stride attention in
+            each attention layer.
+        pretrained(str, optional): the path of pretrained model.
+    """
+
+    def __init__(
+        self,
+        mobileV3_cfg,
+        channels,
+        embed_dims,
+        key_dims=[16, 24],
+        depths=[2, 2],
+        num_heads=8,
+        attn_ratios=2,
+        mlp_ratios=[2, 4],
+        drop_path_rate=0.1,
+        act_cfg=dict(type='ReLU'),
+        inj_type='AAM',
+        out_channels=256,
+        dims=(128, 160),
+        out_feat_chs=None,
+        stride_attention=True,
+        pretrained=None,
+        init_cfg=None,
+    ):
+        super().__init__(init_cfg=init_cfg)
+        assert not (init_cfg and pretrained
+                    ), 'init_cfg and pretrained cannot be set at the same time'
+        if isinstance(pretrained, str):
+            warnings.warn('DeprecationWarning: pretrained is deprecated, '
+                          'please use "init_cfg" instead')
+            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
+        elif pretrained is not None:
+            raise TypeError('pretrained must be a str or None')
+
+        self.depths = depths
+        self.cfgs = mobileV3_cfg
+        self.dims = dims
+        for i in range(len(self.cfgs)):
+            smb = StackedMV3Block(
+                cfgs=self.cfgs[i],
+                stem=True if i == 0 else False,
+                in_channels=channels[i],
+            )
+            setattr(self, f'smb{i + 1}', smb)
+        for i in range(len(depths)):
+            dpr = [
+                x.item() for x in torch.linspace(0, drop_path_rate, depths[i])
+            ]
+            trans = BasicLayer(
+                block_num=depths[i],
+                embedding_dim=embed_dims[i],
+                key_dim=key_dims[i],
+                num_heads=num_heads,
+                mlp_ratio=mlp_ratios[i],
+                attn_ratio=attn_ratios,
+                drop=0,
+                attn_drop=0.0,
+                drop_path=dpr,
+                act_cfg=act_cfg,
+                stride_attention=stride_attention,
+            )
+            setattr(self, f'trans{i + 1}', trans)
+
+        self.inj_type = inj_type
+        if self.inj_type == 'AAM':
+            self.inj_module = InjectionMultiSumallmultiallsum(
+                in_channels=out_feat_chs, out_channels=out_channels)
+            self.feat_channels = [
+                out_channels,
+            ]
+        elif self.inj_type == 'AAMSx8':
+            self.inj_module = InjectionMultiSumallmultiallsumSimpx8(
+                in_channels=out_feat_chs, out_channels=out_channels)
+            self.feat_channels = [
+                out_channels,
+            ]
+        elif self.inj_type == 'origin':
+            for i in range(len(dims)):
+                fuse = FusionBlock(
+                    out_feat_chs[0] if i == 0 else dims[i - 1],
+                    out_feat_chs[i + 1],
+                    embed_dim=dims[i],
+                    act_cfg=None,
+                )
+                setattr(self, f'fuse{i + 1}', fuse)
+            self.feat_channels = [
+                dims[i],
+            ]
+        else:
+            raise NotImplementedError(self.inj_module + ' is not implemented')
+
+        self.pretrained = pretrained
+        # self.init_weights()
+
+    def init_weights(self):
+        if (isinstance(self.init_cfg, dict)
+                and self.init_cfg.get('type') == 'Pretrained'):
+            checkpoint = CheckpointLoader.load_checkpoint(
+                self.init_cfg['checkpoint'], logger=None, map_location='cpu')
+
+            if 'state_dict' in checkpoint:
+                state_dict = checkpoint['state_dict']
+            else:
+                state_dict = checkpoint
+
+            if 'pos_embed' in state_dict.keys():
+                if self.pos_embed.shape != state_dict['pos_embed'].shape:
+                    print_log(msg=f'Resize the pos_embed shape from '
+                              f'{state_dict["pos_embed"].shape} to '
+                              f'{self.pos_embed.shape}')
+                    h, w = self.img_size
+                    pos_size = int(
+                        math.sqrt(state_dict['pos_embed'].shape[1] - 1))
+                    state_dict['pos_embed'] = self.resize_pos_embed(
+                        state_dict['pos_embed'],
+                        (h // self.patch_size, w // self.patch_size),
+                        (pos_size, pos_size),
+                        self.interpolate_mode,
+                    )
+
+            load_state_dict(self, state_dict, strict=False, logger=None)
+
+    def forward(self, x):
+        x_hw = x.shape[2:]
+        outputs = []
+        num_smb_stage = len(self.cfgs)
+        num_trans_stage = len(self.depths)
+
+        for i in range(num_smb_stage):
+            smb = getattr(self, f'smb{i + 1}')
+            x = smb(x)
+
+            # 1/8 shared feat
+            if i == 1:
+                outputs.append(x)
+            if num_trans_stage + i >= num_smb_stage:
+                trans = getattr(
+                    self, f'trans{i + num_trans_stage - num_smb_stage + 1}')
+                x = trans(x)
+                outputs.append(x)
+        if self.inj_type == 'origin':
+            x_detail = outputs[0]
+            for i in range(len(self.dims)):
+                fuse = getattr(self, f'fuse{i + 1}')
+
+                x_detail = fuse(x_detail, outputs[i + 1])
+            output = x_detail
+        else:
+            output = self.inj_module(outputs)
+
+        return [output, x_hw]
+
+
+class StackedMV3Block(nn.Module):
+    """The MobileNetV3 block.
+
+    Args:
+        cfgs (list): The MobileNetV3 config list of a stage.
+        stem (bool): Whether is the first stage or not.
+        in_channels (int, optional): The channels of input image. Default: 3.
+        scale: float=1.0.
+        The coefficient that controls the size of network parameters.
+
+    Returns:
+        model: nn.Module.
+        A stage of specific MobileNetV3 model depends on args.
+    """
+
+    def __init__(self,
+                 cfgs,
+                 stem,
+                 in_channels,
+                 scale=1.0,
+                 norm_cfg=dict(type='BN')):
+        super().__init__()
+
+        self.scale = scale
+        self.stem = stem
+
+        if self.stem:
+            self.conv = ConvModule(
+                in_channels=3,
+                out_channels=_make_divisible(in_channels * self.scale),
+                kernel_size=3,
+                stride=2,
+                padding=1,
+                groups=1,
+                bias=False,
+                norm_cfg=norm_cfg,
+                act_cfg=dict(type='HSwish'),
+            )
+
+        self.blocks = nn.ModuleList()
+        for i, (k, exp, c, se, act, s) in enumerate(cfgs):
+            self.blocks.append(
+                ResidualUnit(
+                    in_channel=_make_divisible(in_channels * self.scale),
+                    mid_channel=_make_divisible(self.scale * exp),
+                    out_channel=_make_divisible(self.scale * c),
+                    kernel_size=k,
+                    stride=s,
+                    use_se=se,
+                    act=act,
+                    dilation=1,
+                ))
+            in_channels = _make_divisible(self.scale * c)
+
+    def forward(self, x):
+        if self.stem:
+            x = self.conv(x)
+        for i, block in enumerate(self.blocks):
+            x = block(x)
+
+        return x
+
+
+class ResidualUnit(nn.Module):
+    """The Residual module.
+
+    Args:
+        in_channel (int, optional): The channels of input feature.
+        mid_channel (int, optional): The channels of middle process.
+        out_channel (int, optional): The channels of output feature.
+        kernel_size (int, optional): The size of the convolving kernel.
+        stride (int, optional): The stride size.
+        use_se (bool, optional): if to use the SEModule.
+        act (string, optional): activation layer.
+        dilation (int, optional): The dilation size.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN', requires_grad=True).
+    """
+
+    def __init__(
+            self,
+            in_channel,
+            mid_channel,
+            out_channel,
+            kernel_size,
+            stride,
+            use_se,
+            act=None,
+            dilation=1,
+            norm_cfg=dict(type='BN'),
+    ):
+        super().__init__()
+        self.if_shortcut = stride == 1 and in_channel == out_channel
+        self.if_se = use_se
+        self.expand_conv = ConvModule(
+            in_channels=in_channel,
+            out_channels=mid_channel,
+            kernel_size=1,
+            bias=False,
+            norm_cfg=norm_cfg,
+            act_cfg=dict(type=act) if act is not None else None,
+        )
+        self.bottleneck_conv = ConvModule(
+            in_channels=mid_channel,
+            out_channels=mid_channel,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=int((kernel_size - 1) // 2) * dilation,
+            bias=False,
+            groups=mid_channel,
+            dilation=dilation,
+            norm_cfg=norm_cfg,
+            act_cfg=dict(type=act) if act is not None else None,
+        )
+        if self.if_se:
+            self.mid_se = SEModule(mid_channel)
+        self.linear_conv = ConvModule(
+            in_channels=mid_channel,
+            out_channels=out_channel,
+            kernel_size=1,
+            bias=False,
+            norm_cfg=norm_cfg,
+            act_cfg=None,
+        )
+
+    def forward(self, x):
+        identity = x
+        x = self.expand_conv(x)
+        x = self.bottleneck_conv(x)
+        if self.if_se:
+            x = self.mid_se(x)
+        x = self.linear_conv(x)
+        if self.if_shortcut:
+            x = torch.add(identity, x)
+        return x
+
+
+class SEModule(nn.Module):
+    """SE Module.
+
+    Args:
+        channel (int, optional): The channels of input feature.
+        reduction (int, optional): The channel reduction rate.
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='PReLU').
+    """
+
+    def __init__(self, channel, reduction=4, act_cfg=dict(type='ReLU')):
+        super().__init__()
+        self.avg_pool = nn.AdaptiveAvgPool2d(1)
+        self.conv_act1 = ConvModule(
+            in_channels=channel,
+            out_channels=channel // reduction,
+            kernel_size=1,
+            norm_cfg=None,
+            act_cfg=act_cfg,
+        )
+
+        self.conv_act2 = ConvModule(
+            in_channels=channel // reduction,
+            out_channels=channel,
+            kernel_size=1,
+            norm_cfg=None,
+            act_cfg=dict(type='Hardsigmoid', slope=0.2, offset=0.5),
+        )
+
+    def forward(self, x):
+        identity = x
+        x = self.avg_pool(x)
+        x = self.conv_act1(x)
+        x = self.conv_act2(x)
+        return torch.mul(identity, x)
+
+
+class BasicLayer(nn.Module):
+    """The transformer basic layer.
+
+    Args:
+        block_num (int): the block nums of the transformer basic layer.
+        embedding_dim (int): The feature dimension.
+        key_dim (int): the key dim.
+        num_heads (int): Parallel attention heads.
+        mlp_ratio (float): the mlp ratio.
+        attn_ratio (float): the attention ratio.
+        drop (float): Probability of an element to be zeroed
+            after the feed forward layer.Default: 0.0.
+        attn_drop (float): The drop out rate for attention layer.
+            Default: 0.0.
+        drop_path (float): stochastic depth rate. Default 0.0.
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='PReLU').
+        stride_attention (bool, optional): whether to stride attention in
+            each attention layer.
+    """
+
+    def __init__(
+        self,
+        block_num,
+        embedding_dim,
+        key_dim,
+        num_heads,
+        mlp_ratio=4.0,
+        attn_ratio=2.0,
+        drop=0.0,
+        attn_drop=0.0,
+        drop_path=None,
+        act_cfg=None,
+        stride_attention=None,
+    ):
+        super().__init__()
+        self.block_num = block_num
+
+        self.transformer_blocks = nn.ModuleList()
+        for i in range(self.block_num):
+            self.transformer_blocks.append(
+                Block(
+                    embedding_dim,
+                    key_dim=key_dim,
+                    num_heads=num_heads,
+                    mlp_ratio=mlp_ratio,
+                    attn_ratio=attn_ratio,
+                    drop=drop,
+                    drop_path=drop_path[i]
+                    if isinstance(drop_path, list) else drop_path,
+                    act_cfg=act_cfg,
+                    stride_attention=stride_attention,
+                ))
+
+    def forward(self, x):
+        for i in range(self.block_num):
+            x = self.transformer_blocks[i](x)
+        return x
+
+
+class Block(nn.Module):
+    """the block of the transformer basic layer.
+
+    Args:
+        dim (int): The feature dimension.
+        key_dim (int): The key dimension.
+        num_heads (int): Parallel attention heads.
+        mlp_ratio (float): the mlp ratio.
+        attn_ratio (float): the attention ratio.
+        drop (float): Probability of an element to be zeroed
+            after the feed forward layer.Default: 0.0.
+        drop_path (float): stochastic depth rate. Default 0.0.
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='PReLU').
+        stride_attention (bool, optional): whether to stride attention in
+            each attention layer.
+    """
+
+    def __init__(
+        self,
+        dim,
+        key_dim,
+        num_heads,
+        mlp_ratio=4.0,
+        attn_ratio=2.0,
+        drop=0.0,
+        drop_path=0.0,
+        act_cfg=None,
+        stride_attention=None,
+    ):
+        super().__init__()
+        self.dim = dim
+        self.num_heads = num_heads
+        self.mlp_ratio = mlp_ratio
+        self.attn = SeaAttention(
+            dim,
+            key_dim=key_dim,
+            num_heads=num_heads,
+            attn_ratio=attn_ratio,
+            act_cfg=act_cfg,
+            stride_attention=stride_attention,
+        )
+        self.drop_path = (
+            build_dropout(dict(type='DropPath', drop_prob=drop_path))
+            if drop_path > 0.0 else nn.Identity())
+        mlp_hidden_dim = int(dim * mlp_ratio)
+        self.mlp = MLP(
+            in_features=dim,
+            hidden_features=mlp_hidden_dim,
+            act_cfg=act_cfg,
+            drop=drop,
+        )
+
+    def forward(self, x1):
+        x1 = x1 + self.drop_path(self.attn(x1))
+        x1 = x1 + self.drop_path(self.mlp(x1))
+
+        return x1
+
+
+class SqueezeAxialPositionalEmbedding(nn.Module):
+    """the Squeeze Axial Positional Embedding.
+
+    Args:
+        dim (int): The feature dimension.
+        shape (int): The patch size.
+    """
+
+    def __init__(self, dim, shape):
+        super().__init__()
+        self.pos_embed = nn.init.normal_(
+            nn.Parameter(torch.zeros(1, dim, shape)))
+
+    def forward(self, x):
+        B, C, N = x.shape
+        x = x + F.interpolate(
+            self.pos_embed, size=(N, ), mode='linear', align_corners=False)
+        return x
+
+
+class SeaAttention(nn.Module):
+    """The sea attention.
+
+    Args:
+        dim (int): The feature dimension.
+        key_dim (int):  The key dimension.
+        num_heads (int): number of attention heads.
+        attn_ratio (float): the attention ratio.
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='PReLU').
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='LN')
+        stride_attention (bool, optional): whether to stride attention in
+            each attention layer.
+    """
+
+    def __init__(
+            self,
+            dim,
+            key_dim,
+            num_heads,
+            attn_ratio=4.0,
+            act_cfg=None,
+            norm_cfg=dict(type='BN'),
+            stride_attention=False,
+    ):
+
+        super().__init__()
+        self.num_heads = num_heads
+        self.scale = key_dim**-0.5
+        self.nh_kd = nh_kd = key_dim * num_heads
+        self.d = int(attn_ratio * key_dim)
+        self.dh = int(attn_ratio * key_dim) * num_heads
+        self.attn_ratio = attn_ratio
+
+        self.to_q = ConvModule(
+            dim, nh_kd, 1, bias=False, norm_cfg=norm_cfg, act_cfg=None)
+        self.to_k = ConvModule(
+            dim, nh_kd, 1, bias=False, norm_cfg=norm_cfg, act_cfg=None)
+
+        self.to_v = ConvModule(
+            dim, self.dh, 1, bias=False, norm_cfg=norm_cfg, act_cfg=None)
+        self.stride_attention = stride_attention
+        if self.stride_attention:
+            self.stride_conv = ConvModule(
+                dim,
+                dim,
+                kernel_size=3,
+                stride=2,
+                padding=1,
+                bias=True,
+                groups=dim,
+                norm_cfg=norm_cfg,
+                act_cfg=None,
+            )
+
+        self.proj = ConvModule(
+            self.dh,
+            dim,
+            1,
+            bias=False,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg,
+            order=('act', 'conv', 'norm'),
+        )
+        self.proj_encode_row = ConvModule(
+            self.dh,
+            self.dh,
+            1,
+            bias=False,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg,
+            order=('act', 'conv', 'norm'),
+        )
+        self.pos_emb_rowq = SqueezeAxialPositionalEmbedding(nh_kd, 16)
+        self.pos_emb_rowk = SqueezeAxialPositionalEmbedding(nh_kd, 16)
+        self.proj_encode_column = ConvModule(
+            self.dh,
+            self.dh,
+            1,
+            bias=False,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg,
+            order=('act', 'conv', 'norm'),
+        )
+        self.pos_emb_columnq = SqueezeAxialPositionalEmbedding(nh_kd, 16)
+        self.pos_emb_columnk = SqueezeAxialPositionalEmbedding(nh_kd, 16)
+        self.dwconv = ConvModule(
+            2 * self.dh,
+            2 * self.dh,
+            3,
+            padding=1,
+            groups=2 * self.dh,
+            bias=False,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg,
+        )
+        self.pwconv = ConvModule(
+            2 * self.dh, dim, 1, bias=False, norm_cfg=norm_cfg, act_cfg=None)
+        self.sigmoid = build_activation_layer(dict(type='HSigmoid'))
+
+    def forward(self, x):
+        B, C, H_ori, W_ori = x.shape
+        if self.stride_attention:
+            x = self.stride_conv(x)
+        B, C, H, W = x.shape
+
+        q = self.to_q(x)  # [B, nhead*dim, H, W]
+        k = self.to_k(x)
+        v = self.to_v(x)
+
+        qkv = torch.cat([q, k, v], dim=1)
+        qkv = self.dwconv(qkv)
+        qkv = self.pwconv(qkv)
+
+        qrow = (self.pos_emb_rowq(q.mean(-1)).reshape(
+            [B, self.num_heads, -1, H]).permute(
+                (0, 1, 3, 2)))  # [B, nhead, H, dim]
+        krow = self.pos_emb_rowk(k.mean(-1)).reshape(
+            [B, self.num_heads, -1, H])  # [B, nhead, dim, H]
+        vrow = (v.mean(-1).reshape([B, self.num_heads, -1,
+                                    H]).permute([0, 1, 3, 2])
+                )  # [B, nhead, H, dim*attn_ratio]
+
+        attn_row = torch.matmul(qrow, krow) * self.scale  # [B, nhead, H, H]
+        attn_row = nn.functional.softmax(attn_row, dim=-1)
+
+        xx_row = torch.matmul(attn_row, vrow)  # [B, nhead, H, dim*attn_ratio]
+        xx_row = self.proj_encode_row(
+            xx_row.permute([0, 1, 3, 2]).reshape([B, self.dh, H, 1]))
+
+        # squeeze column
+        qcolumn = (
+            self.pos_emb_columnq(q.mean(-2)).reshape(
+                [B, self.num_heads, -1, W]).permute([0, 1, 3, 2]))
+        kcolumn = self.pos_emb_columnk(k.mean(-2)).reshape(
+            [B, self.num_heads, -1, W])
+        vcolumn = (
+            torch.mean(v, -2).reshape([B, self.num_heads, -1,
+                                       W]).permute([0, 1, 3, 2]))
+
+        attn_column = torch.matmul(qcolumn, kcolumn) * self.scale
+        attn_column = nn.functional.softmax(attn_column, dim=-1)
+
+        xx_column = torch.matmul(attn_column, vcolumn)  # B nH W C
+        xx_column = self.proj_encode_column(
+            xx_column.permute([0, 1, 3, 2]).reshape([B, self.dh, 1, W]))
+
+        xx = torch.add(xx_row, xx_column)  # [B, self.dh, H, W]
+        xx = torch.add(v, xx)
+
+        xx = self.proj(xx)
+        xx = self.sigmoid(xx) * qkv
+        if self.stride_attention:
+            xx = F.interpolate(xx, size=(H_ori, W_ori), mode='bilinear')
+
+        return xx
+
+
+class MLP(nn.Module):
+    """the Multilayer Perceptron.
+
+    Args:
+        in_features (int): the input feature.
+        hidden_features (int): the hidden feature.
+        out_features (int): the output feature.
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='PReLU').
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN')
+        drop (float): Probability of an element to be zeroed.
+            Default 0.0
+    """
+
+    def __init__(
+            self,
+            in_features,
+            hidden_features=None,
+            out_features=None,
+            act_cfg=None,
+            norm_cfg=dict(type='BN'),
+            drop=0.0,
+    ):
+        super().__init__()
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+        self.fc1 = ConvModule(
+            in_features,
+            hidden_features,
+            kernel_size=1,
+            bias=False,
+            norm_cfg=norm_cfg,
+            act_cfg=None,
+        )
+        self.dwconv = ConvModule(
+            hidden_features,
+            hidden_features,
+            kernel_size=3,
+            padding=1,
+            groups=hidden_features,
+            norm_cfg=None,
+            act_cfg=act_cfg,
+        )
+
+        self.fc2 = ConvModule(
+            hidden_features,
+            out_features,
+            1,
+            bias=False,
+            norm_cfg=norm_cfg,
+            act_cfg=None,
+        )
+        self.drop = build_dropout(dict(type='Dropout', drop_prob=drop))
+
+    def forward(self, x):
+        x = self.fc1(x)
+        x = self.dwconv(x)
+        x = self.drop(x)
+        x = self.fc2(x)
+        x = self.drop(x)
+        return x
+
+
+class FusionBlock(nn.Module):
+    """The feature fusion block.
+
+    Args:
+        in_channel (int): the input channel.
+        out_channel (int): the output channel.
+        embed_dim (int): embedding dimension.
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='ReLU').
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN')
+    """
+
+    def __init__(
+            self,
+            in_channel,
+            out_channel,
+            embed_dim,
+            norm_cfg=dict(type='BN'),
+            act_cfg=dict(type='ReLU'),
+    ) -> None:
+        super().__init__()
+        self.local_embedding = ConvModule(
+            in_channels=in_channel,
+            out_channels=embed_dim,
+            kernel_size=1,
+            bias=False,
+            norm_cfg=norm_cfg,
+            act_cfg=None,
+        )
+
+        self.global_act = ConvModule(
+            in_channels=out_channel,
+            out_channels=embed_dim,
+            kernel_size=1,
+            bias=False,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg if act_cfg is not None else None,
+        )
+
+    def forward(self, x_l, x_g):
+        """
+        x_g: global features
+        x_l: local features
+        """
+        B, C, H, W = x_l.shape
+
+        local_feat = self.local_embedding(x_l)
+        global_act = self.global_act(x_g)
+        sig_act = F.interpolate(
+            global_act, size=(H, W), mode='bilinear', align_corners=False)
+
+        out = local_feat * sig_act
+
+        return out
+
+
+class InjectionMultiSumallmultiallsum(nn.Module):
+    """the Aggregate Attention Module.
+
+    Args:
+        in_channels (tuple): the input channel.
+        out_channels (int): the output channel.
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='ReLU').
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN')
+    """
+
+    def __init__(
+            self,
+            in_channels=(64, 128, 256, 384),
+            out_channels=256,
+            act_cfg=dict(type='Sigmoid'),
+            norm_cfg=dict(type='BN'),
+    ):
+        super().__init__()
+        self.embedding_list = nn.ModuleList()
+        self.act_embedding_list = nn.ModuleList()
+        self.act_list = nn.ModuleList()
+        for i in range(len(in_channels)):
+            self.embedding_list.append(
+                ConvModule(
+                    in_channels=in_channels[i],
+                    out_channels=out_channels,
+                    kernel_size=1,
+                    bias=False,
+                    norm_cfg=norm_cfg,
+                    act_cfg=None,
+                ))
+            self.act_embedding_list.append(
+                ConvModule(
+                    in_channels=in_channels[i],
+                    out_channels=out_channels,
+                    kernel_size=1,
+                    bias=False,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg,
+                ))
+
+    def forward(self, inputs):  # x_x8, x_x16, x_x32, x_x64
+        low_feat1 = F.interpolate(inputs[0], scale_factor=0.5, mode='bilinear')
+        low_feat1_act = self.act_embedding_list[0](low_feat1)
+        low_feat1 = self.embedding_list[0](low_feat1)
+
+        low_feat2 = F.interpolate(
+            inputs[1], size=low_feat1.shape[-2:], mode='bilinear')
+        low_feat2_act = self.act_embedding_list[1](low_feat2)  # x16
+        low_feat2 = self.embedding_list[1](low_feat2)
+
+        high_feat_act = F.interpolate(
+            self.act_embedding_list[2](inputs[2]),
+            size=low_feat2.shape[2:],
+            mode='bilinear',
+        )
+        high_feat = F.interpolate(
+            self.embedding_list[2](inputs[2]),
+            size=low_feat2.shape[2:],
+            mode='bilinear')
+
+        res = (
+            low_feat1_act * low_feat2_act * high_feat_act *
+            (low_feat1 + low_feat2) + high_feat)
+
+        return res
+
+
+class InjectionMultiSumallmultiallsumSimpx8(nn.Module):
+    """the Aggregate Attention Module.
+
+    Args:
+        in_channels (tuple): the input channel.
+        out_channels (int): the output channel.
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='ReLU').
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN')
+    """
+
+    def __init__(
+            self,
+            in_channels=(64, 128, 256, 384),
+            out_channels=256,
+            act_cfg=dict(type='Sigmoid'),
+            norm_cfg=dict(type='BN'),
+    ):
+        super().__init__()
+        self.embedding_list = nn.ModuleList()
+        self.act_embedding_list = nn.ModuleList()
+        self.act_list = nn.ModuleList()
+        for i in range(len(in_channels)):
+            if i != 1:
+                self.embedding_list.append(
+                    ConvModule(
+                        in_channels=in_channels[i],
+                        out_channels=out_channels,
+                        kernel_size=1,
+                        bias=False,
+                        norm_cfg=norm_cfg,
+                        act_cfg=None,
+                    ))
+            if i != 0:
+                self.act_embedding_list.append(
+                    ConvModule(
+                        in_channels=in_channels[i],
+                        out_channels=out_channels,
+                        kernel_size=1,
+                        bias=False,
+                        norm_cfg=norm_cfg,
+                        act_cfg=act_cfg,
+                    ))
+
+    def forward(self, inputs):
+        # x_x8, x_x16, x_x32
+        low_feat1 = self.embedding_list[0](inputs[0])
+
+        low_feat2 = F.interpolate(
+            inputs[1], size=low_feat1.shape[-2:], mode='bilinear')
+        low_feat2_act = self.act_embedding_list[0](low_feat2)
+
+        high_feat_act = F.interpolate(
+            self.act_embedding_list[1](inputs[2]),
+            size=low_feat2.shape[2:],
+            mode='bilinear',
+        )
+        high_feat = F.interpolate(
+            self.embedding_list[1](inputs[2]),
+            size=low_feat2.shape[2:],
+            mode='bilinear')
+
+        res = low_feat2_act * high_feat_act * low_feat1 + high_feat
+
+        return res
+
+
+def _make_divisible(v, divisor=8, min_value=None):
+    if min_value is None:
+        min_value = divisor
+    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
+    if new_v < 0.9 * v:
+        new_v += divisor
+    return new_v
+
+
+@MODELS.register_module()
+class Hardsigmoid(nn.Module):
+    """the hardsigmoid activation.
+
+    Args:
+        slope (float, optional): The slope of hardsigmoid function.
+            Default is 0.1666667.
+        offset (float, optional): The offset of hardsigmoid function.
+            Default is 0.5.
+        inplace (bool): can optionally do the operation in-place.
+            Default: ``False``
+    """
+
+    def __init__(self, slope=0.1666667, offset=0.5, inplace=False):
+        super().__init__()
+        self.slope = slope
+        self.offset = offset
+
+    def forward(self, x):
+        return (x * self.slope + self.offset).clamp(0, 1)
diff --git a/mmsegmentation/projects/pp_mobileseg/configs/_base_/datasets/ade20k.py b/mmsegmentation/projects/pp_mobileseg/configs/_base_/datasets/ade20k.py
new file mode 100644
index 0000000..48340d1
--- /dev/null
+++ b/mmsegmentation/projects/pp_mobileseg/configs/_base_/datasets/ade20k.py
@@ -0,0 +1,68 @@
+# dataset settings
+dataset_type = 'ADE20KDataset'
+data_root = 'data/ade/ADEChallengeData2016'
+crop_size = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(
+        type='RandomResize',
+        scale=(2048, 512),
+        ratio_range=(0.5, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/training', seg_map_path='annotations/training'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
diff --git a/mmsegmentation/projects/pp_mobileseg/configs/_base_/default_runtime.py b/mmsegmentation/projects/pp_mobileseg/configs/_base_/default_runtime.py
new file mode 100644
index 0000000..272b4d2
--- /dev/null
+++ b/mmsegmentation/projects/pp_mobileseg/configs/_base_/default_runtime.py
@@ -0,0 +1,15 @@
+default_scope = 'mmseg'
+env_cfg = dict(
+    cudnn_benchmark=True,
+    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+    dist_cfg=dict(backend='nccl'),
+)
+vis_backends = [dict(type='LocalVisBackend')]
+visualizer = dict(
+    type='SegLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+log_processor = dict(by_epoch=False)
+log_level = 'INFO'
+load_from = None
+resume = False
+
+tta_model = dict(type='SegTTAModel')
diff --git a/mmsegmentation/projects/pp_mobileseg/configs/_base_/models/pp_mobile.py b/mmsegmentation/projects/pp_mobileseg/configs/_base_/models/pp_mobile.py
new file mode 100644
index 0000000..0c76956
--- /dev/null
+++ b/mmsegmentation/projects/pp_mobileseg/configs/_base_/models/pp_mobile.py
@@ -0,0 +1,47 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    # pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='StrideFormer',
+        mobileV3_cfg=[
+            # k t c, s
+            [[3, 16, 16, True, 'ReLU', 1], [3, 64, 32, False, 'ReLU', 2],
+             [3, 96, 32, False, 'ReLU', 1]],  # cfg1
+            [[5, 128, 64, True, 'HSwish', 2], [5, 240, 64, True, 'HSwish',
+                                               1]],  # cfg2
+            [[5, 384, 128, True, 'HSwish', 2],
+             [5, 384, 128, True, 'HSwish', 1]],  # cfg3
+            [[5, 768, 192, True, 'HSwish', 2],
+             [5, 768, 192, True, 'HSwish', 1]],  # cfg4
+        ],
+        channels=[16, 32, 64, 128, 192],
+        depths=[3, 3],
+        embed_dims=[128, 192],
+        num_heads=8,
+        inj_type='AAMSx8',
+        out_feat_chs=[64, 128, 192],
+        act_cfg=dict(type='ReLU6'),
+    ),
+    decode_head=dict(
+        type='PPMobileSegHead',
+        num_classes=150,
+        in_channels=256,
+        dropout_ratio=0.1,
+        use_dw=True,
+        act_cfg=dict(type='ReLU'),
+        align_corners=False),
+
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/projects/pp_mobileseg/configs/_base_/schedules/schedule_80k.py b/mmsegmentation/projects/pp_mobileseg/configs/_base_/schedules/schedule_80k.py
new file mode 100644
index 0000000..0dcd6c4
--- /dev/null
+++ b/mmsegmentation/projects/pp_mobileseg/configs/_base_/schedules/schedule_80k.py
@@ -0,0 +1,24 @@
+# optimizer
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=0,
+        end=80000,
+        by_epoch=False)
+]
+# training schedule for 80k
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=80000, val_interval=8000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=8000),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))
diff --git a/mmsegmentation/projects/pp_mobileseg/configs/pp_mobileseg/pp_mobileseg_mobilenetv3_2x16_80k_ade20k_512x512_base.py b/mmsegmentation/projects/pp_mobileseg/configs/pp_mobileseg/pp_mobileseg_mobilenetv3_2x16_80k_ade20k_512x512_base.py
new file mode 100644
index 0000000..4b68a92
--- /dev/null
+++ b/mmsegmentation/projects/pp_mobileseg/configs/pp_mobileseg/pp_mobileseg_mobilenetv3_2x16_80k_ade20k_512x512_base.py
@@ -0,0 +1,18 @@
+_base_ = [
+    '../_base_/models/pp_mobile.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+# the custom import path is determined by your workspace path (i.e., where you run the command from) # noqa
+custom_imports = dict(
+    imports=[
+        'projects.pp_mobileseg.backbones', 'projects.pp_mobileseg.decode_head'
+    ],
+    allow_failed_imports=False)
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pp_mobileseg/pp_mobileseg_mobilenetv3_3rdparty-base-ed0be681.pth'  # noqa
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size, test_cfg=dict(size_divisor=32))
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(init_cfg=dict(type='Pretrained', checkpoint=checkpoint)),
+    decode_head=dict(num_classes=150, upsample='intepolate'))
diff --git a/mmsegmentation/projects/pp_mobileseg/configs/pp_mobileseg/pp_mobileseg_mobilenetv3_2x16_80k_ade20k_512x512_tiny.py b/mmsegmentation/projects/pp_mobileseg/configs/pp_mobileseg/pp_mobileseg_mobilenetv3_2x16_80k_ade20k_512x512_tiny.py
new file mode 100644
index 0000000..b78869e
--- /dev/null
+++ b/mmsegmentation/projects/pp_mobileseg/configs/pp_mobileseg/pp_mobileseg_mobilenetv3_2x16_80k_ade20k_512x512_tiny.py
@@ -0,0 +1,45 @@
+_base_ = [
+    '../_base_/models/pp_mobile.py', '../_base_/datasets/ade20k.py',
+    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
+]
+# the custom import path is determined by your workspace path (i.e., where you run the command from) # noqa
+custom_imports = dict(
+    imports=[
+        'projects.pp_mobileseg.backbones', 'projects.pp_mobileseg.decode_head'
+    ],
+    allow_failed_imports=False)
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pp_mobileseg/pp_mobileseg_mobilenetv3_3rdparty-tiny-e4b35e96.pth'  # noqa
+crop_size = (512, 512)
+data_preprocessor = dict(size=crop_size, test_cfg=dict(size_divisor=32))
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        type='StrideFormer',
+        mobileV3_cfg=[
+            # k t c, s
+            [[3, 16, 16, True, 'ReLU', 1], [3, 64, 32, False, 'ReLU', 2],
+             [3, 48, 24, False, 'ReLU', 1]],  # cfg1
+            [[5, 96, 32, True, 'HSwish', 2], [5, 96, 32, True, 'HSwish',
+                                              1]],  # cfg2
+            [[5, 160, 64, True, 'HSwish', 2], [5, 160, 64, True, 'HSwish',
+                                               1]],  # cfg3
+            [[3, 384, 128, True, 'HSwish', 2],
+             [3, 384, 128, True, 'HSwish', 1]],  # cfg4
+        ],
+        channels=[16, 24, 32, 64, 128],
+        depths=[2, 2],
+        embed_dims=[64, 128],
+        num_heads=4,
+        inj_type='AAM',
+        out_feat_chs=[32, 64, 128],
+        act_cfg=dict(type='ReLU6'),
+    ),
+    decode_head=dict(
+        num_classes=150,
+        in_channels=256,
+        use_dw=True,
+        act_cfg=dict(type='ReLU'),
+        upsample='intepolate'),
+)
diff --git a/mmsegmentation/projects/pp_mobileseg/decode_head/__init__.py b/mmsegmentation/projects/pp_mobileseg/decode_head/__init__.py
new file mode 100644
index 0000000..6f71b78
--- /dev/null
+++ b/mmsegmentation/projects/pp_mobileseg/decode_head/__init__.py
@@ -0,0 +1,6 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .pp_mobileseg_head import PPMobileSegHead
+
+__all__ = [
+    'PPMobileSegHead',
+]
diff --git a/mmsegmentation/projects/pp_mobileseg/decode_head/pp_mobileseg_head.py b/mmsegmentation/projects/pp_mobileseg/decode_head/pp_mobileseg_head.py
new file mode 100644
index 0000000..243f026
--- /dev/null
+++ b/mmsegmentation/projects/pp_mobileseg/decode_head/pp_mobileseg_head.py
@@ -0,0 +1,94 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule, build_conv_layer
+from torch import Tensor
+
+from mmseg.registry import MODELS
+
+
+@MODELS.register_module()
+class PPMobileSegHead(nn.Module):
+    """the segmentation head.
+
+    Args:
+        num_classes (int): the classes num.
+        in_channels (int): the input channels.
+        use_dw (bool): if to use deepwith convolution.
+        dropout_ratio (float): Probability of an element to be zeroed.
+            Default 0.0。
+        align_corners (bool, optional): Geometrically, we consider the pixels
+            of the input and output as squares rather than points.
+        upsample (str): the upsample method.
+        out_channels (int): the output channel.
+        conv_cfg (dict): Config dict for convolution layer.
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='ReLU').
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN').
+    """
+
+    def __init__(self,
+                 num_classes,
+                 in_channels,
+                 use_dw=True,
+                 dropout_ratio=0.1,
+                 align_corners=False,
+                 upsample='intepolate',
+                 out_channels=None,
+                 conv_cfg=dict(type='Conv'),
+                 act_cfg=dict(type='ReLU'),
+                 norm_cfg=dict(type='BN')):
+
+        super().__init__()
+        self.align_corners = align_corners
+        self.last_channels = in_channels
+        self.upsample = upsample
+        self.num_classes = num_classes
+        self.out_channels = out_channels
+        self.linear_fuse = ConvModule(
+            in_channels=self.last_channels,
+            out_channels=self.last_channels,
+            kernel_size=1,
+            bias=False,
+            groups=self.last_channels if use_dw else 1,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        self.dropout = nn.Dropout2d(dropout_ratio)
+        self.conv_seg = build_conv_layer(
+            conv_cfg, self.last_channels, self.num_classes, kernel_size=1)
+
+    def forward(self, x):
+        x, x_hw = x[0], x[1]
+        x = self.linear_fuse(x)
+        x = self.dropout(x)
+        x = self.conv_seg(x)
+        if self.upsample == 'intepolate' or self.training or \
+                self.num_classes < 30:
+            x = F.interpolate(
+                x, x_hw, mode='bilinear', align_corners=self.align_corners)
+        elif self.upsample == 'vim':
+            labelset = torch.unique(torch.argmax(x, 1))
+            x = torch.gather(x, 1, labelset)
+            x = F.interpolate(
+                x, x_hw, mode='bilinear', align_corners=self.align_corners)
+
+            pred = torch.argmax(x, 1)
+            pred_retrieve = torch.zeros(pred.shape, dtype=torch.int32)
+            for i, val in enumerate(labelset):
+                pred_retrieve[pred == i] = labelset[i].cast('int32')
+
+            x = pred_retrieve
+        else:
+            raise NotImplementedError(self.upsample, ' is not implemented')
+
+        return [x]
+
+    def predict(self, inputs, batch_img_metas: List[dict], test_cfg,
+                **kwargs) -> List[Tensor]:
+        """Forward function for testing, only ``pam_cam`` is used."""
+        seg_logits = self.forward(inputs)[0]
+        return seg_logits
diff --git a/mmsegmentation/projects/pp_mobileseg/inference_onnx.py b/mmsegmentation/projects/pp_mobileseg/inference_onnx.py
new file mode 100644
index 0000000..139d1b1
--- /dev/null
+++ b/mmsegmentation/projects/pp_mobileseg/inference_onnx.py
@@ -0,0 +1,203 @@
+import argparse
+import time
+from typing import List, Tuple
+
+import cv2
+import loguru
+import numpy as np
+import onnxruntime as ort
+
+logger = loguru.logger
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='PP_Mobileseg ONNX inference demo.')
+    parser.add_argument('onnx_file', help='ONNX file path')
+    parser.add_argument('image_file', help='Input image file path')
+    parser.add_argument(
+        '--input-size',
+        type=int,
+        nargs='+',
+        default=[512, 512],
+        help='input image size')
+    parser.add_argument(
+        '--device', help='device type for inference', default='cpu')
+    parser.add_argument(
+        '--save-path',
+        help='path to save the output image',
+        default='output.jpg')
+    args = parser.parse_args()
+    return args
+
+
+def preprocess(
+    img: np.ndarray, input_size: Tuple[int, int] = (512, 512)
+) -> Tuple[np.ndarray, np.ndarray]:
+    """Preprocess image for inference."""
+    img_shape = img.shape[:2]
+    # Resize
+    resized_img = cv2.resize(img, input_size)
+
+    # Normalize
+    mean = np.array([123.575, 116.28, 103.53], dtype=np.float32)
+    std = np.array([58.395, 57.12, 57.375], dtype=np.float32)
+    resized_img = (resized_img - mean) / std
+
+    return resized_img, img_shape
+
+
+def build_session(onnx_file: str, device: str = 'cpu') -> ort.InferenceSession:
+    """Build onnxruntime session.
+
+    Args:
+        onnx_file (str): ONNX file path.
+        device (str): Device type for inference.
+
+    Returns:
+        sess (ort.InferenceSession): ONNXRuntime session.
+    """
+    providers = ['CPUExecutionProvider'
+                 ] if device == 'cpu' else ['CUDAExecutionProvider']
+    sess = ort.InferenceSession(path_or_bytes=onnx_file, providers=providers)
+
+    return sess
+
+
+def inference(sess: ort.InferenceSession, img: np.ndarray) -> np.ndarray:
+    """Inference RTMPose model.
+
+    Args:
+        sess (ort.InferenceSession): ONNXRuntime session.
+        img (np.ndarray): Input image in shape.
+
+    Returns:
+        outputs (np.ndarray): Output of RTMPose model.
+    """
+    # build input
+    input_img = [img.transpose(2, 0, 1).astype(np.float32)]
+
+    # build output
+    sess_input = {sess.get_inputs()[0].name: input_img}
+    sess_output = []
+    for out in sess.get_outputs():
+        sess_output.append(out.name)
+
+    # inference
+    outputs = sess.run(output_names=sess_output, input_feed=sess_input)
+
+    return outputs
+
+
+def postprocess(outputs: List[np.ndarray],
+                origin_shape: Tuple[int, int]) -> np.ndarray:
+    """Postprocess outputs of PP_Mobileseg model.
+
+    Args:
+        outputs (List[np.ndarray]): Outputs of PP_Mobileseg model.
+        origin_shape (Tuple[int, int]): Input size of PP_Mobileseg model.
+
+    Returns:
+        seg_map (np.ndarray): Segmentation map.
+    """
+    seg_map = outputs[0][0][0]
+    seg_map = cv2.resize(seg_map.astype(np.float32), origin_shape)
+    return seg_map
+
+
+def visualize(img: np.ndarray,
+              seg_map: np.ndarray,
+              filename: str = 'output.jpg',
+              opacity: float = 0.8) -> np.ndarray:
+    assert 0.0 <= opacity <= 1.0, 'opacity should be in range [0, 1]'
+    palette = np.array(PALETTE)
+    color_seg = np.zeros((seg_map.shape[0], seg_map.shape[1], 3),
+                         dtype=np.uint8)
+    for label, color in enumerate(palette):
+        color_seg[seg_map == label, :] = color
+    # convert to BGR
+    color_seg = color_seg[..., ::-1]
+
+    img = img * (1 - opacity) + color_seg * opacity
+    cv2.imwrite(filename, img)
+
+    return img
+
+
+def main():
+    args = parse_args()
+    logger.info('Start running model inference...')
+
+    # read image from file
+    logger.info(f'1. Read image from file {args.image_file}...')
+    img = cv2.imread(args.image_file)
+
+    # build onnx model
+    logger.info(f'2. Build onnx model from {args.onnx_file}...')
+    sess = build_session(args.onnx_file, args.device)
+
+    # preprocess
+    logger.info('3. Preprocess image...')
+    model_input_size = tuple(args.input_size)
+    assert len(model_input_size) == 2
+    resized_img, origin_shape = preprocess(img, model_input_size)
+
+    # inference
+    logger.info('4. Inference...')
+    start = time.time()
+    outputs = inference(sess, resized_img)
+    logger.info(f'Inference time: {time.time() - start:.4f}s')
+
+    # postprocess
+    logger.info('5. Postprocess...')
+    h, w = origin_shape
+    seg_map = postprocess(outputs, (w, h))
+
+    # visualize
+    logger.info('6. Visualize...')
+    visualize(img, seg_map, args.save_path)
+
+    logger.info('Done...')
+
+
+PALETTE = [[120, 120, 120], [180, 120, 120], [6, 230, 230], [80, 50, 50],
+           [4, 200, 3], [120, 120, 80], [140, 140, 140], [204, 5, 255],
+           [230, 230, 230], [4, 250, 7], [224, 5, 255], [235, 255, 7],
+           [150, 5, 61], [120, 120, 70], [8, 255, 51], [255, 6, 82],
+           [143, 255, 140], [204, 255, 4], [255, 51, 7], [204, 70, 3],
+           [0, 102, 200], [61, 230, 250], [255, 6, 51], [11, 102, 255],
+           [255, 7, 71], [255, 9, 224], [9, 7, 230], [220, 220, 220],
+           [255, 9, 92], [112, 9, 255], [8, 255, 214], [7, 255, 224],
+           [255, 184, 6], [10, 255, 71], [255, 41, 10], [7, 255, 255],
+           [224, 255, 8], [102, 8, 255], [255, 61, 6], [255, 194, 7],
+           [255, 122, 8], [0, 255, 20], [255, 8, 41], [255, 5, 153],
+           [6, 51, 255], [235, 12, 255], [160, 150, 20], [0, 163, 255],
+           [140, 140, 140], [250, 10, 15], [20, 255, 0], [31, 255, 0],
+           [255, 31, 0], [255, 224, 0], [153, 255, 0], [0, 0, 255],
+           [255, 71, 0], [0, 235, 255], [0, 173, 255], [31, 0, 255],
+           [11, 200, 200], [255, 82, 0], [0, 255, 245], [0, 61, 255],
+           [0, 255, 112], [0, 255, 133], [255, 0, 0], [255, 163, 0],
+           [255, 102, 0], [194, 255, 0], [0, 143, 255], [51, 255, 0],
+           [0, 82, 255], [0, 255, 41], [0, 255, 173], [10, 0, 255],
+           [173, 255, 0], [0, 255, 153], [255, 92, 0], [255, 0, 255],
+           [255, 0, 245], [255, 0, 102], [255, 173, 0], [255, 0, 20],
+           [255, 184, 184], [0, 31, 255], [0, 255, 61], [0, 71, 255],
+           [255, 0, 204], [0, 255, 194], [0, 255, 82], [0, 10, 255],
+           [0, 112, 255], [51, 0, 255], [0, 194, 255], [0, 122, 255],
+           [0, 255, 163], [255, 153, 0], [0, 255, 10], [255, 112, 0],
+           [143, 255, 0], [82, 0, 255], [163, 255, 0], [255, 235, 0],
+           [8, 184, 170], [133, 0, 255], [0, 255, 92], [184, 0, 255],
+           [255, 0, 31], [0, 184, 255], [0, 214, 255], [255, 0, 112],
+           [92, 255, 0], [0, 224, 255], [112, 224, 255], [70, 184, 160],
+           [163, 0, 255], [153, 0, 255], [71, 255, 0], [255, 0, 163],
+           [255, 204, 0], [255, 0, 143], [0, 255, 235], [133, 255, 0],
+           [255, 0, 235], [245, 0, 255], [255, 0, 122], [255, 245, 0],
+           [10, 190, 212], [214, 255, 0], [0, 204, 255], [20, 0, 255],
+           [255, 255, 0], [0, 153, 255], [0, 41, 255], [0, 255, 204],
+           [41, 0, 255], [41, 255, 0], [173, 0, 255], [0, 245, 255],
+           [71, 0, 255], [122, 0, 255], [0, 255, 184], [0, 92, 255],
+           [184, 255, 0], [0, 133, 255], [255, 214, 0], [25, 194, 194],
+           [102, 255, 0], [92, 0, 255]]
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/projects/sam_inference_demo/README.md b/mmsegmentation/projects/sam_inference_demo/README.md
new file mode 100644
index 0000000..f8077b8
--- /dev/null
+++ b/mmsegmentation/projects/sam_inference_demo/README.md
@@ -0,0 +1,40 @@
+# Introducing the Segment Anything Model (SAM) Inference Demo!
+
+Welcome to the Segment Anything (SA) Inference Demo, a user-friendly implementation based on the original Segment Anything project. Our demo allows you to experience the power and versatility of the Segment Anything Model (SAM) through an easy-to-use API.
+
+With this inference demo, you can explore the capabilities of the Segment Anything Model and witness its effectiveness in various tasks and image distributions. For more information on the original project, dataset, and model, please visit the official website at https://segment-anything.com.
+
+### Prerequisites
+
+- Python 3.10
+- PyTorch 1.13
+- MMEngine >= v0.7.2
+- MMCV >= v2.0.0
+
+### Installation
+
+We assume that you have already installed PyTorch. If not, please follow the instructions on the [PyTorch website](https://pytorch.org/).
+
+**1. Install MMEngine & MMCV**
+
+```shell
+pip install openmim
+mim install mmengine
+mim install 'mmcv>=2.0.0'
+```
+
+**2. Install MMPretrain**
+
+```shell
+pip install git+https://github.com/open-mmlab/mmpretrain.git@dev
+```
+
+**3. Install MMSegmentation**
+
+```shell
+pip install mmsegmentation
+```
+
+### Usage
+
+Open the `sam_image_demo.ipynb` notebook and follow the instructions to run the demo.
diff --git a/mmsegmentation/projects/sam_inference_demo/sam/__init__.py b/mmsegmentation/projects/sam_inference_demo/sam/__init__.py
new file mode 100644
index 0000000..82b6b78
--- /dev/null
+++ b/mmsegmentation/projects/sam_inference_demo/sam/__init__.py
@@ -0,0 +1,2 @@
+from .modeling import *  # noqa
+from .utils import *  # noqa
diff --git a/mmsegmentation/projects/sam_inference_demo/sam/modeling/__init__.py b/mmsegmentation/projects/sam_inference_demo/sam/modeling/__init__.py
new file mode 100644
index 0000000..9892a6b
--- /dev/null
+++ b/mmsegmentation/projects/sam_inference_demo/sam/modeling/__init__.py
@@ -0,0 +1,12 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+from .mask_decoder import MaskDecoder
+from .prompt_encoder import PromptEncoder
+from .sam import SAM
+from .transformer import TwoWayTransformer
+
+__all__ = ['SAM', 'MaskDecoder', 'PromptEncoder', 'TwoWayTransformer']
diff --git a/mmsegmentation/projects/sam_inference_demo/sam/modeling/common.py b/mmsegmentation/projects/sam_inference_demo/sam/modeling/common.py
new file mode 100644
index 0000000..d289276
--- /dev/null
+++ b/mmsegmentation/projects/sam_inference_demo/sam/modeling/common.py
@@ -0,0 +1,45 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+from typing import Type
+
+import torch
+import torch.nn as nn
+
+
+class MLPBlock(nn.Module):
+
+    def __init__(
+        self,
+        embedding_dim: int,
+        mlp_dim: int,
+        act: Type[nn.Module] = nn.GELU,
+    ) -> None:
+        super().__init__()
+        self.lin1 = nn.Linear(embedding_dim, mlp_dim)
+        self.lin2 = nn.Linear(mlp_dim, embedding_dim)
+        self.act = act()
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.lin2(self.act(self.lin1(x)))
+
+
+# From https://github.com/facebookresearch/detectron2/blob/main/detectron2/layers/batch_norm.py # noqa
+# Itself from https://github.com/facebookresearch/ConvNeXt/blob/d1fa8f6fef0a165b27399986cc2bdacc92777e40/models/convnext.py#L119  # noqa
+class LayerNorm2d(nn.Module):
+
+    def __init__(self, num_channels: int, eps: float = 1e-6) -> None:
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(num_channels))
+        self.bias = nn.Parameter(torch.zeros(num_channels))
+        self.eps = eps
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        u = x.mean(1, keepdim=True)
+        s = (x - u).pow(2).mean(1, keepdim=True)
+        x = (x - u) / torch.sqrt(s + self.eps)
+        x = self.weight[:, None, None] * x + self.bias[:, None, None]
+        return x
diff --git a/mmsegmentation/projects/sam_inference_demo/sam/modeling/mask_decoder.py b/mmsegmentation/projects/sam_inference_demo/sam/modeling/mask_decoder.py
new file mode 100644
index 0000000..9ad616b
--- /dev/null
+++ b/mmsegmentation/projects/sam_inference_demo/sam/modeling/mask_decoder.py
@@ -0,0 +1,196 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Borrowed from https://github.com/facebookresearch/segment-anything
+
+from typing import List, Tuple
+
+import torch
+from torch import Tensor, nn
+from torch.nn import functional as F
+
+from mmseg.registry import MODELS
+from .common import LayerNorm2d
+
+
+@MODELS.register_module()
+class MaskDecoder(nn.Module):
+
+    def __init__(
+        self,
+        *,
+        transformer_dim: int,
+        transformer: dict,
+        num_multimask_outputs: int = 3,
+        act_cfg: dict = dict(type='GELU'),
+        iou_head_depth: int = 3,
+        iou_head_hidden_dim: int = 256,
+    ) -> None:
+        """Predicts masks given an image and prompt embeddings, using a
+        tranformer architecture.
+
+        Borrowed from https://github.com/facebookresearch/segment-anything
+
+        Arguments:
+          transformer_dim (int): the channel dimension of the transformer
+          transformer (nn.Module): the transformer used to predict masks
+          num_multimask_outputs (int): the number of masks to predict
+            when disambiguating masks
+          activation (nn.Module): the type of activation to use when
+            upscaling masks
+          iou_head_depth (int): the depth of the MLP used to predict
+            mask quality
+          iou_head_hidden_dim (int): the hidden dimension of the MLP
+            used to predict mask quality
+        """
+        super().__init__()
+        self.transformer_dim = transformer_dim
+        self.transformer = MODELS.build(transformer)
+
+        self.num_multimask_outputs = num_multimask_outputs
+
+        self.iou_token = nn.Embedding(1, transformer_dim)
+        self.num_mask_tokens = num_multimask_outputs + 1
+        self.mask_tokens = nn.Embedding(self.num_mask_tokens, transformer_dim)
+
+        activation = MODELS.build(act_cfg)
+        self.output_upscaling = nn.Sequential(
+            nn.ConvTranspose2d(
+                transformer_dim, transformer_dim // 4, kernel_size=2,
+                stride=2),
+            LayerNorm2d(transformer_dim // 4),
+            activation,
+            nn.ConvTranspose2d(
+                transformer_dim // 4,
+                transformer_dim // 8,
+                kernel_size=2,
+                stride=2),
+            activation,
+        )
+        self.output_hypernetworks_mlps = nn.ModuleList([
+            MLP(transformer_dim, transformer_dim, transformer_dim // 8, 3)
+            for i in range(self.num_mask_tokens)
+        ])
+
+        self.iou_prediction_head = MLP(transformer_dim, iou_head_hidden_dim,
+                                       self.num_mask_tokens, iou_head_depth)
+
+    def forward(
+        self,
+        image_embeddings: Tensor,
+        image_pe: Tensor,
+        sparse_prompt_embeddings: Tensor,
+        dense_prompt_embeddings: Tensor,
+        multimask_output: bool,
+    ) -> Tuple[Tensor, Tensor]:
+        """Predict masks given image and prompt embeddings.
+
+        Borrowed from https://github.com/facebookresearch/segment-anything
+
+        Arguments:
+          image_embeddings (Tensor): the embeddings from the image encoder
+          image_pe (Tensor): positional encoding with the shape of
+            image_embeddings
+          sparse_prompt_embeddings (Tensor): the embeddings of
+            the points and boxes
+          dense_prompt_embeddings (Tensor): the embeddings of the mask inputs
+          multimask_output (bool): Whether to return multiple masks or a single
+            mask.
+
+        Returns:
+          Tensor: batched predicted masks
+          Tensor: batched predictions of mask quality
+        """
+        masks, iou_pred = self.predict_masks(
+            image_embeddings=image_embeddings,
+            image_pe=image_pe,
+            sparse_prompt_embeddings=sparse_prompt_embeddings,
+            dense_prompt_embeddings=dense_prompt_embeddings,
+        )
+
+        # Select the correct mask or masks for output
+        if multimask_output:
+            mask_slice = slice(1, None)
+        else:
+            mask_slice = slice(0, 1)
+        masks = masks[:, mask_slice, :, :]
+        iou_pred = iou_pred[:, mask_slice]
+
+        # Prepare output
+        return masks, iou_pred
+
+    def predict_masks(
+        self,
+        image_embeddings: Tensor,
+        image_pe: Tensor,
+        sparse_prompt_embeddings: Tensor,
+        dense_prompt_embeddings: Tensor,
+    ) -> Tuple[Tensor, Tensor]:
+        """Predicts masks.
+
+        See 'forward' for more details.
+        """
+        # Concatenate output tokens
+        output_tokens = torch.cat(
+            [self.iou_token.weight, self.mask_tokens.weight], dim=0)
+        output_tokens = output_tokens.unsqueeze(0).expand(
+            sparse_prompt_embeddings.size(0), -1, -1)
+        tokens = torch.cat((output_tokens, sparse_prompt_embeddings), dim=1)
+
+        # Expand per-image data in batch direction to be per-mask
+        src = torch.repeat_interleave(image_embeddings, tokens.shape[0], dim=0)
+        src = src + dense_prompt_embeddings
+        pos_src = torch.repeat_interleave(image_pe, tokens.shape[0], dim=0)
+        b, c, h, w = src.shape
+
+        # Run the transformer
+        hs, src = self.transformer(src, pos_src, tokens)
+        iou_token_out = hs[:, 0, :]
+        mask_tokens_out = hs[:, 1:(1 + self.num_mask_tokens), :]
+
+        # Upscale mask embeddings and predict masks using the mask tokens
+        src = src.transpose(1, 2).view(b, c, h, w)
+        upscaled_embedding = self.output_upscaling(src)
+        hyper_in_list: List[Tensor] = []
+        for i in range(self.num_mask_tokens):
+            hyper_in_list.append(self.output_hypernetworks_mlps[i](
+                mask_tokens_out[:, i, :]))
+        hyper_in = torch.stack(hyper_in_list, dim=1)
+        b, c, h, w = upscaled_embedding.shape
+        masks = (hyper_in @ upscaled_embedding.view(b, c, h * w)).view(
+            b, -1, h, w)
+
+        # Generate mask quality predictions
+        iou_pred = self.iou_prediction_head(iou_token_out)
+
+        return masks, iou_pred
+
+
+# Lightly adapted from
+# https://github.com/facebookresearch/MaskFormer/blob/main/mask_former/modeling/transformer/transformer_predictor.py # noqa
+class MLP(nn.Module):
+
+    def __init__(
+        self,
+        input_dim: int,
+        hidden_dim: int,
+        output_dim: int,
+        num_layers: int,
+        sigmoid_output: bool = False,
+    ) -> None:
+        super().__init__()
+        self.num_layers = num_layers
+        h = [hidden_dim] * (num_layers - 1)
+        self.layers = nn.ModuleList(
+            nn.Linear(n, k) for n, k in zip([input_dim] + h, h + [output_dim]))
+        self.sigmoid_output = sigmoid_output
+
+    def forward(self, x):
+        for i, layer in enumerate(self.layers):
+            x = F.relu(layer(x)) if i < self.num_layers - 1 else layer(x)
+        if self.sigmoid_output:
+            x = F.sigmoid(x)
+        return x
diff --git a/mmsegmentation/projects/sam_inference_demo/sam/modeling/prompt_encoder.py b/mmsegmentation/projects/sam_inference_demo/sam/modeling/prompt_encoder.py
new file mode 100644
index 0000000..6b7c083
--- /dev/null
+++ b/mmsegmentation/projects/sam_inference_demo/sam/modeling/prompt_encoder.py
@@ -0,0 +1,227 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Borrowed from https://github.com/facebookresearch/segment-anything
+
+from typing import Any, Optional, Tuple, Type
+
+import numpy as np
+import torch
+from torch import nn
+
+from mmseg.registry import MODELS
+from .common import LayerNorm2d
+
+
+@MODELS.register_module()
+class PromptEncoder(nn.Module):
+
+    def __init__(
+        self,
+        embed_dim: int,
+        image_embedding_size: Tuple[int, int],
+        input_image_size: Tuple[int, int],
+        mask_in_chans: int,
+        activation: Type[nn.Module] = nn.GELU,
+    ) -> None:
+        """Encodes prompts for input to SAM's mask decoder.
+
+        Arguments:
+          embed_dim (int): The prompts' embedding dimension
+          image_embedding_size (tuple(int, int)): The spatial size of the
+            image embedding, as (H, W).
+          input_image_size (int): The padded size of the image as input
+            to the image encoder, as (H, W).
+          mask_in_chans (int): The number of hidden channels used for
+            encoding input masks.
+          activation (nn.Module): The activation to use when encoding
+            input masks.
+        """
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.input_image_size = input_image_size
+        self.image_embedding_size = image_embedding_size
+        self.pe_layer = PositionEmbeddingRandom(embed_dim // 2)
+
+        self.num_point_embeddings: int = 4  # pos/neg point + 2 box corners
+        point_embeddings = [
+            nn.Embedding(1, embed_dim)
+            for i in range(self.num_point_embeddings)
+        ]
+        self.point_embeddings = nn.ModuleList(point_embeddings)
+        self.not_a_point_embed = nn.Embedding(1, embed_dim)
+
+        self.mask_input_size = (4 * image_embedding_size[0],
+                                4 * image_embedding_size[1])
+        self.mask_downscaling = nn.Sequential(
+            nn.Conv2d(1, mask_in_chans // 4, kernel_size=2, stride=2),
+            LayerNorm2d(mask_in_chans // 4),
+            activation(),
+            nn.Conv2d(
+                mask_in_chans // 4, mask_in_chans, kernel_size=2, stride=2),
+            LayerNorm2d(mask_in_chans),
+            activation(),
+            nn.Conv2d(mask_in_chans, embed_dim, kernel_size=1),
+        )
+        self.no_mask_embed = nn.Embedding(1, embed_dim)
+
+    def get_dense_pe(self) -> torch.Tensor:
+        """Returns the positional encoding used to encode point prompts,
+        applied to a dense set of points the shape of the image encoding.
+
+        Returns:
+          torch.Tensor: Positional encoding with shape
+            1x(embed_dim)x(embedding_h)x(embedding_w)
+        """
+        return self.pe_layer(self.image_embedding_size).unsqueeze(0)
+
+    def _embed_points(
+        self,
+        points: torch.Tensor,
+        labels: torch.Tensor,
+        pad: bool,
+    ) -> torch.Tensor:
+        """Embeds point prompts."""
+        points = points + 0.5  # Shift to center of pixel
+        if pad:
+            padding_point = torch.zeros((points.shape[0], 1, 2),
+                                        device=points.device)
+            padding_label = -torch.ones(
+                (labels.shape[0], 1), device=labels.device)
+            points = torch.cat([points, padding_point], dim=1)
+            labels = torch.cat([labels, padding_label], dim=1)
+        point_embedding = self.pe_layer.forward_with_coords(
+            points, self.input_image_size)
+        point_embedding[labels == -1] = 0.0
+        point_embedding[labels == -1] += self.not_a_point_embed.weight
+        point_embedding[labels == 0] += self.point_embeddings[0].weight
+        point_embedding[labels == 1] += self.point_embeddings[1].weight
+        return point_embedding
+
+    def _embed_boxes(self, boxes: torch.Tensor) -> torch.Tensor:
+        """Embeds box prompts."""
+        boxes = boxes + 0.5  # Shift to center of pixel
+        coords = boxes.reshape(-1, 2, 2)
+        corner_embedding = self.pe_layer.forward_with_coords(
+            coords, self.input_image_size)
+        corner_embedding[:, 0, :] += self.point_embeddings[2].weight
+        corner_embedding[:, 1, :] += self.point_embeddings[3].weight
+        return corner_embedding
+
+    def _embed_masks(self, masks: torch.Tensor) -> torch.Tensor:
+        """Embeds mask inputs."""
+        mask_embedding = self.mask_downscaling(masks)
+        return mask_embedding
+
+    def _get_batch_size(
+        self,
+        points: Optional[Tuple[torch.Tensor, torch.Tensor]],
+        boxes: Optional[torch.Tensor],
+        masks: Optional[torch.Tensor],
+    ) -> int:
+        """Gets the batch size of the output given the batch size of the input
+        prompts."""
+        if points is not None:
+            return points[0].shape[0]
+        elif boxes is not None:
+            return boxes.shape[0]
+        elif masks is not None:
+            return masks.shape[0]
+        else:
+            return 1
+
+    def _get_device(self) -> torch.device:
+        return self.point_embeddings[0].weight.device
+
+    def forward(
+        self,
+        points: Optional[Tuple[torch.Tensor, torch.Tensor]],
+        boxes: Optional[torch.Tensor],
+        masks: Optional[torch.Tensor],
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """Embeds different types of prompts, returning both sparse and dense
+        embeddings.
+
+        Arguments:
+          points (tuple(torch.Tensor, torch.Tensor) or none): point coordinates
+            and labels to embed.
+          boxes (torch.Tensor or none): boxes to embed
+          masks (torch.Tensor or none): masks to embed
+
+        Returns:
+          torch.Tensor: sparse embeddings for the points and boxes, with shape
+            BxNx(embed_dim), where N is determined by the number of input points
+            and boxes.
+          torch.Tensor: dense embeddings for the masks, in the shape
+            Bx(embed_dim)x(embed_H)x(embed_W)
+        """ # noqa
+        bs = self._get_batch_size(points, boxes, masks)
+        sparse_embeddings = torch.empty((bs, 0, self.embed_dim),
+                                        device=self._get_device())
+        if points is not None:
+            coords, labels = points
+            point_embeddings = self._embed_points(
+                coords, labels, pad=(boxes is None))
+            sparse_embeddings = torch.cat(
+                [sparse_embeddings, point_embeddings], dim=1)
+        if boxes is not None:
+            box_embeddings = self._embed_boxes(boxes)
+            sparse_embeddings = torch.cat([sparse_embeddings, box_embeddings],
+                                          dim=1)
+
+        if masks is not None:
+            dense_embeddings = self._embed_masks(masks)
+        else:
+            dense_embeddings = self.no_mask_embed.weight.reshape(
+                1, -1, 1, 1).expand(bs, -1, self.image_embedding_size[0],
+                                    self.image_embedding_size[1])
+
+        return sparse_embeddings, dense_embeddings
+
+
+class PositionEmbeddingRandom(nn.Module):
+    """Positional encoding using random spatial frequencies."""
+
+    def __init__(self,
+                 num_pos_feats: int = 64,
+                 scale: Optional[float] = None) -> None:
+        super().__init__()
+        if scale is None or scale <= 0.0:
+            scale = 1.0
+        self.register_buffer(
+            'positional_encoding_gaussian_matrix',
+            scale * torch.randn((2, num_pos_feats)),
+        )
+
+    def _pe_encoding(self, coords: torch.Tensor) -> torch.Tensor:
+        """Positionally encode points that are normalized to [0,1]."""
+        # assuming coords are in [0, 1]^2 square and have d_1 x ... x d_n x 2 shape # noqa
+        coords = 2 * coords - 1
+        coords = coords @ self.positional_encoding_gaussian_matrix
+        coords = 2 * np.pi * coords
+        # outputs d_1 x ... x d_n x C shape
+        return torch.cat([torch.sin(coords), torch.cos(coords)], dim=-1)
+
+    def forward(self, size: Tuple[int, int]) -> torch.Tensor:
+        """Generate positional encoding for a grid of the specified size."""
+        h, w = size
+        device: Any = self.positional_encoding_gaussian_matrix.device
+        grid = torch.ones((h, w), device=device, dtype=torch.float32)
+        y_embed = grid.cumsum(dim=0) - 0.5
+        x_embed = grid.cumsum(dim=1) - 0.5
+        y_embed = y_embed / h
+        x_embed = x_embed / w
+
+        pe = self._pe_encoding(torch.stack([x_embed, y_embed], dim=-1))
+        return pe.permute(2, 0, 1)  # C x H x W
+
+    def forward_with_coords(self, coords_input: torch.Tensor,
+                            image_size: Tuple[int, int]) -> torch.Tensor:
+        """Positionally encode points that are not normalized to [0,1]."""
+        coords = coords_input.clone()
+        coords[:, :, 0] = coords[:, :, 0] / image_size[1]
+        coords[:, :, 1] = coords[:, :, 1] / image_size[0]
+        return self._pe_encoding(coords.to(torch.float))  # B x N x C
diff --git a/mmsegmentation/projects/sam_inference_demo/sam/modeling/sam.py b/mmsegmentation/projects/sam_inference_demo/sam/modeling/sam.py
new file mode 100644
index 0000000..c61c1ec
--- /dev/null
+++ b/mmsegmentation/projects/sam_inference_demo/sam/modeling/sam.py
@@ -0,0 +1,188 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Borrowed from https://github.com/facebookresearch/segment-anything
+
+from typing import Any, Dict, List, Tuple
+
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+from mmseg.registry import MODELS
+from .mask_decoder import MaskDecoder
+from .prompt_encoder import PromptEncoder
+
+
+@MODELS.register_module()
+class SAM(nn.Module):
+    mask_threshold: float = 0.0
+    image_format: str = 'RGB'
+
+    def __init__(
+        self,
+        image_encoder_cfg: dict,
+        prompt_encoder_cfg: dict,
+        mask_decoder_cfg: dict,
+        pixel_mean: List[float] = [123.675, 116.28, 103.53],
+        pixel_std: List[float] = [58.395, 57.12, 57.375],
+    ) -> None:
+        """SAM predicts object masks from an image and input prompts. Borrowed
+        from https://github.com/facebookresearch/segment-anything.
+
+        Arguments:
+          image_encoder (ViTSAM): The backbone used to encode the
+            image into image embeddings that allow for efficient mask
+            prediction.
+          prompt_encoder (PromptEncoder): Encodes various types of input
+            prompts.
+          mask_decoder (MaskDecoder): Predicts masks from the image embeddings
+            and encoded prompts.
+          pixel_mean (list(float)): Mean values for normalizing pixels in the
+            input image.
+          pixel_std (list(float)): Std values for normalizing pixels in the
+            input image.
+        """
+        super().__init__()
+        self.image_encoder = MODELS.build(image_encoder_cfg)
+        self.prompt_encoder: PromptEncoder = MODELS.build(prompt_encoder_cfg)
+        self.mask_decoder: MaskDecoder = MODELS.build(mask_decoder_cfg)
+        self.register_buffer('pixel_mean',
+                             torch.Tensor(pixel_mean).view(-1, 1, 1), False)
+        self.register_buffer('pixel_std',
+                             torch.Tensor(pixel_std).view(-1, 1, 1), False)
+
+    @property
+    def device(self) -> Any:
+        return self.pixel_mean.device
+
+    @torch.no_grad()
+    def forward(
+        self,
+        batched_input: List[Dict[str, Any]],
+        multimask_output: bool,
+    ) -> List[Dict[str, torch.Tensor]]:
+        """Predicts masks end-to-end from provided images and prompts. If
+        prompts are not known in advance, using SamPredictor is recommended
+        over calling the model directly.
+
+        Borrowed from https://github.com/facebookresearch/segment-anything
+
+        Arguments:
+          batched_input (list(dict)): A list over input images, each a
+            dictionary with the following keys. A prompt key can be
+            excluded if it is not present.
+              'image': The image as a torch tensor in 3xHxW format,
+                already transformed for input to the model.
+              'original_size': (tuple(int, int)) The original size of
+                the image before transformation, as (H, W).
+              'point_coords': (torch.Tensor) Batched point prompts for
+                this image, with shape BxNx2. Already transformed to the
+                input frame of the model.
+              'point_labels': (torch.Tensor) Batched labels for point prompts,
+                with shape BxN.
+              'boxes': (torch.Tensor) Batched box inputs, with shape Bx4.
+                Already transformed to the input frame of the model.
+              'mask_inputs': (torch.Tensor) Batched mask inputs to the model,
+                in the form Bx1xHxW.
+          multimask_output (bool): Whether the model should predict multiple
+            disambiguating masks, or return a single mask.
+
+        Returns:
+          (list(dict)): A list over input images, where each element is
+            as dictionary with the following keys.
+              'masks': (torch.Tensor) Batched binary mask predictions,
+                with shape BxCxHxW, where B is the number of input prompts,
+                C is determiend by multimask_output, and (H, W) is the
+                original size of the image.
+              'iou_predictions': (torch.Tensor) The model's predictions
+                of mask quality, in shape BxC.
+              'low_res_logits': (torch.Tensor) Low resolution logits with
+                shape BxCxHxW, where H=W=256. Can be passed as mask input
+                to subsequent iterations of prediction.
+        """
+        input_images = torch.stack(
+            [self.preprocess(x['image']) for x in batched_input], dim=0)
+        image_embeddings = self.image_encoder(input_images)
+
+        outputs = []
+        for image_record, curr_embedding in zip(batched_input,
+                                                image_embeddings):
+            if 'point_coords' in image_record:
+                points = (image_record['point_coords'],
+                          image_record['point_labels'])
+            else:
+                points = None
+            sparse_embeddings, dense_embeddings = self.prompt_encoder(
+                points=points,
+                boxes=image_record.get('boxes', None),
+                masks=image_record.get('mask_inputs', None),
+            )
+            low_res_masks, iou_predictions = self.mask_decoder(
+                image_embeddings=curr_embedding.unsqueeze(0),
+                image_pe=self.prompt_encoder.get_dense_pe(),
+                sparse_prompt_embeddings=sparse_embeddings,
+                dense_prompt_embeddings=dense_embeddings,
+                multimask_output=multimask_output,
+            )
+            masks = self.postprocess_masks(
+                low_res_masks,
+                input_size=image_record['image'].shape[-2:],
+                original_size=image_record['original_size'],
+            )
+            masks = masks > self.mask_threshold
+            outputs.append({
+                'masks': masks,
+                'iou_predictions': iou_predictions,
+                'low_res_logits': low_res_masks,
+            })
+        return outputs
+
+    def postprocess_masks(
+        self,
+        masks: torch.Tensor,
+        input_size: Tuple[int, ...],
+        original_size: Tuple[int, ...],
+    ) -> torch.Tensor:
+        """Remove padding and upscale masks to the original image size.
+
+        Borrowed from https://github.com/facebookresearch/segment-anything
+
+        Arguments:
+          masks (torch.Tensor): Batched masks from the mask_decoder,
+            in BxCxHxW format.
+          input_size (tuple(int, int)): The size of the image input to the
+            model, in (H, W) format. Used to remove padding.
+          original_size (tuple(int, int)): The original size of the image
+            before resizing for input to the model, in (H, W) format.
+
+        Returns:
+          (torch.Tensor): Batched masks in BxCxHxW format, where (H, W)
+            is given by original_size.
+        """
+        masks = F.interpolate(
+            masks,
+            self.image_encoder.img_size,
+            mode='bilinear',
+            align_corners=False,
+        )
+        masks = masks[..., :input_size[0], :input_size[1]]
+        masks = F.interpolate(
+            masks, original_size, mode='bilinear', align_corners=False)
+        return masks
+
+    def preprocess(self, x: torch.Tensor) -> torch.Tensor:
+        """Normalize pixel values and pad to a square input."""
+        # Normalize colors
+        x = (x - self.pixel_mean) / self.pixel_std
+
+        # Pad
+        h, w = x.shape[-2:]
+        img_size = max(self.image_encoder.img_size)
+        padh = img_size - h
+        padw = img_size - w
+        x = F.pad(x, (0, padw, 0, padh))
+        return x
diff --git a/mmsegmentation/projects/sam_inference_demo/sam/modeling/transformer.py b/mmsegmentation/projects/sam_inference_demo/sam/modeling/transformer.py
new file mode 100644
index 0000000..c56f602
--- /dev/null
+++ b/mmsegmentation/projects/sam_inference_demo/sam/modeling/transformer.py
@@ -0,0 +1,241 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import math
+from typing import Tuple, Type
+
+import torch
+from torch import Tensor, nn
+
+from mmseg.registry import MODELS
+from .common import MLPBlock
+
+
+@MODELS.register_module()
+class TwoWayTransformer(nn.Module):
+
+    def __init__(
+        self,
+        depth: int,
+        embedding_dim: int,
+        num_heads: int,
+        mlp_dim: int,
+        activation: Type[nn.Module] = nn.ReLU,
+        attention_downsample_rate: int = 2,
+    ) -> None:
+        """A transformer decoder that attends to an input image using queries
+        whose positional embedding is supplied.
+
+        Args:
+          depth (int): number of layers in the transformer
+          embedding_dim (int): the channel dimension for the input embeddings
+          num_heads (int): the number of heads for multihead attention. Must
+            divide embedding_dim
+          mlp_dim (int): the channel dimension internal to the MLP block
+          activation (nn.Module): the activation to use in the MLP block
+        """
+        super().__init__()
+        self.depth = depth
+        self.embedding_dim = embedding_dim
+        self.num_heads = num_heads
+        self.mlp_dim = mlp_dim
+        self.layers = nn.ModuleList()
+
+        for i in range(depth):
+            self.layers.append(
+                TwoWayAttentionBlock(
+                    embedding_dim=embedding_dim,
+                    num_heads=num_heads,
+                    mlp_dim=mlp_dim,
+                    activation=activation,
+                    attention_downsample_rate=attention_downsample_rate,
+                    skip_first_layer_pe=(i == 0),
+                ))
+
+        self.final_attn_token_to_image = Attention(
+            embedding_dim,
+            num_heads,
+            downsample_rate=attention_downsample_rate)
+        self.norm_final_attn = nn.LayerNorm(embedding_dim)
+
+    def forward(
+        self,
+        image_embedding: Tensor,
+        image_pe: Tensor,
+        point_embedding: Tensor,
+    ) -> Tuple[Tensor, Tensor]:
+        """
+        Args:
+          image_embedding (torch.Tensor): image to attend to. Should be shape
+            B x embedding_dim x h x w for any h and w.
+          image_pe (torch.Tensor): the positional encoding to add to the image. Must
+            have the same shape as image_embedding.
+          point_embedding (torch.Tensor): the embedding to add to the query points.
+            Must have shape B x N_points x embedding_dim for any N_points.
+
+        Returns:
+          torch.Tensor: the processed point_embedding
+          torch.Tensor: the processed image_embedding
+        """ # noqa E501
+        # BxCxHxW -> BxHWxC == B x N_image_tokens x C
+        bs, c, h, w = image_embedding.shape
+        image_embedding = image_embedding.flatten(2).permute(0, 2, 1)
+        image_pe = image_pe.flatten(2).permute(0, 2, 1)
+
+        # Prepare queries
+        queries = point_embedding
+        keys = image_embedding
+
+        # Apply transformer blocks and final layernorm
+        for layer in self.layers:
+            queries, keys = layer(
+                queries=queries,
+                keys=keys,
+                query_pe=point_embedding,
+                key_pe=image_pe,
+            )
+
+        # Apply the final attenion layer from the points to the image
+        q = queries + point_embedding
+        k = keys + image_pe
+        attn_out = self.final_attn_token_to_image(q=q, k=k, v=keys)
+        queries = queries + attn_out
+        queries = self.norm_final_attn(queries)
+
+        return queries, keys
+
+
+class TwoWayAttentionBlock(nn.Module):
+
+    def __init__(
+        self,
+        embedding_dim: int,
+        num_heads: int,
+        mlp_dim: int = 2048,
+        activation: Type[nn.Module] = nn.ReLU,
+        attention_downsample_rate: int = 2,
+        skip_first_layer_pe: bool = False,
+    ) -> None:
+        """A transformer block with four layers: (1) self-attention of sparse
+        inputs, (2) cross attention of sparse inputs to dense inputs, (3) mlp
+        block on sparse inputs, and (4) cross attention of dense inputs to
+        sparse inputs.
+
+        Arguments:
+          embedding_dim (int): the channel dimension of the embeddings
+          num_heads (int): the number of heads in the attention layers
+          mlp_dim (int): the hidden dimension of the mlp block
+          activation (nn.Module): the activation of the mlp block
+          skip_first_layer_pe (bool): skip the PE on the first layer
+        """
+        super().__init__()
+        self.self_attn = Attention(embedding_dim, num_heads)
+        self.norm1 = nn.LayerNorm(embedding_dim)
+
+        self.cross_attn_token_to_image = Attention(
+            embedding_dim,
+            num_heads,
+            downsample_rate=attention_downsample_rate)
+        self.norm2 = nn.LayerNorm(embedding_dim)
+
+        self.mlp = MLPBlock(embedding_dim, mlp_dim, activation)
+        self.norm3 = nn.LayerNorm(embedding_dim)
+
+        self.norm4 = nn.LayerNorm(embedding_dim)
+        self.cross_attn_image_to_token = Attention(
+            embedding_dim,
+            num_heads,
+            downsample_rate=attention_downsample_rate)
+
+        self.skip_first_layer_pe = skip_first_layer_pe
+
+    def forward(self, queries: Tensor, keys: Tensor, query_pe: Tensor,
+                key_pe: Tensor) -> Tuple[Tensor, Tensor]:
+        # Self attention block
+        if self.skip_first_layer_pe:
+            queries = self.self_attn(q=queries, k=queries, v=queries)
+        else:
+            q = queries + query_pe
+            attn_out = self.self_attn(q=q, k=q, v=queries)
+            queries = queries + attn_out
+        queries = self.norm1(queries)
+
+        # Cross attention block, tokens attending to image embedding
+        q = queries + query_pe
+        k = keys + key_pe
+        attn_out = self.cross_attn_token_to_image(q=q, k=k, v=keys)
+        queries = queries + attn_out
+        queries = self.norm2(queries)
+
+        # MLP block
+        mlp_out = self.mlp(queries)
+        queries = queries + mlp_out
+        queries = self.norm3(queries)
+
+        # Cross attention block, image embedding attending to tokens
+        q = queries + query_pe
+        k = keys + key_pe
+        attn_out = self.cross_attn_image_to_token(q=k, k=q, v=queries)
+        keys = keys + attn_out
+        keys = self.norm4(keys)
+
+        return queries, keys
+
+
+class Attention(nn.Module):
+    """An attention layer that allows for downscaling the size of the embedding
+    after projection to queries, keys, and values."""
+
+    def __init__(
+        self,
+        embedding_dim: int,
+        num_heads: int,
+        downsample_rate: int = 1,
+    ) -> None:
+        super().__init__()
+        self.embedding_dim = embedding_dim
+        self.internal_dim = embedding_dim // downsample_rate
+        self.num_heads = num_heads
+        assert self.internal_dim % num_heads == 0, 'num_heads must divide embedding_dim.'  # noqa E501
+
+        self.q_proj = nn.Linear(embedding_dim, self.internal_dim)
+        self.k_proj = nn.Linear(embedding_dim, self.internal_dim)
+        self.v_proj = nn.Linear(embedding_dim, self.internal_dim)
+        self.out_proj = nn.Linear(self.internal_dim, embedding_dim)
+
+    def _separate_heads(self, x: Tensor, num_heads: int) -> Tensor:
+        b, n, c = x.shape
+        x = x.reshape(b, n, num_heads, c // num_heads)
+        return x.transpose(1, 2)  # B x N_heads x N_tokens x C_per_head
+
+    def _recombine_heads(self, x: Tensor) -> Tensor:
+        b, n_heads, n_tokens, c_per_head = x.shape
+        x = x.transpose(1, 2)
+        return x.reshape(b, n_tokens, n_heads * c_per_head)  # B x N_tokens x C
+
+    def forward(self, q: Tensor, k: Tensor, v: Tensor) -> Tensor:
+        # Input projections
+        q = self.q_proj(q)
+        k = self.k_proj(k)
+        v = self.v_proj(v)
+
+        # Separate into heads
+        q = self._separate_heads(q, self.num_heads)
+        k = self._separate_heads(k, self.num_heads)
+        v = self._separate_heads(v, self.num_heads)
+
+        # Attention
+        _, _, _, c_per_head = q.shape
+        attn = q @ k.permute(0, 1, 3, 2)  # B x N_heads x N_tokens x N_tokens
+        attn = attn / math.sqrt(c_per_head)
+        attn = torch.softmax(attn, dim=-1)
+
+        # Get output
+        out = attn @ v
+        out = self._recombine_heads(out)
+        out = self.out_proj(out)
+
+        return out
diff --git a/mmsegmentation/projects/sam_inference_demo/sam/sam_inferencer.py b/mmsegmentation/projects/sam_inference_demo/sam/sam_inferencer.py
new file mode 100644
index 0000000..2da2e95
--- /dev/null
+++ b/mmsegmentation/projects/sam_inference_demo/sam/sam_inferencer.py
@@ -0,0 +1,688 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Any, Dict, List, Optional, Tuple
+
+import numpy as np
+import torch
+from mmengine.runner.checkpoint import load_checkpoint
+# yapf: disable
+from sam.utils import (MaskData, area_from_rle, batch_iterator,
+                       batched_mask_to_box, box_xyxy_to_xywh,
+                       build_all_layer_point_grids, calculate_stability_score,
+                       coco_encode_rle, generate_crop_boxes,
+                       is_box_near_crop_edge, mask_to_rle_pytorch,
+                       remove_small_regions, rle_to_mask, uncrop_boxes_xyxy,
+                       uncrop_masks, uncrop_points)
+from torchvision.ops.boxes import batched_nms, box_area
+
+from mmseg.registry import MODELS, TRANSFORMS
+
+# yapf: enable
+
+model_zoo = {
+    'base':
+    'https://download.openmmlab.com/mmsegmentation/v0.5/sam/sam_vit-base-p16_3rdparty_sa1b-1024x1024_20230413-78a25eed.pth',  # noqa
+    'large':
+    'https://download.openmmlab.com/mmsegmentation/v0.5/sam/sam_vit-large-p16_3rdparty_sa1b-1024x1024_20230413-940520da.pth',  # noqa
+    'huge':
+    'https://download.openmmlab.com/mmsegmentation/v0.5/sam/sam_vit-huge-p16_3rdparty_sa1b-1024x1024_20230413-faaf96f6.pth',  # noqa
+}
+
+
+class SAMInferencer:
+
+    def __init__(self, arch: str = 'base') -> None:
+        assert arch in ['base', 'large', 'huge']
+        self.model = self.init_model(arch)
+        self.transform = TRANSFORMS.build(
+            dict(
+                type='ResizeLongestSide',
+                target_length=max(self.model.image_encoder.img_size)))
+
+    def set_image(
+        self,
+        image: np.ndarray,
+        image_format: str = 'RGB',
+    ) -> None:
+        """Calculates the image embeddings for the provided image, allowing
+        masks to be predicted with the 'predict' method.
+
+        Arguments:
+          image (np.ndarray): The image for calculating masks. Expects an
+            image in HWC uint8 format, with pixel values in [0, 255].
+          image_format (str): The color format of the image, in ['RGB', 'BGR'].
+        """
+        assert image_format in [
+            'RGB',
+            'BGR',
+        ], f"image_format must be in ['RGB', 'BGR'], is {image_format}."
+        if image_format != self.model.image_format:
+            image = image[..., ::-1]
+
+        # Transform the image to the form expected by the model
+        input_image = self.transform.apply_image(image)
+        input_image_torch = torch.as_tensor(input_image, device=self.device)
+        input_image_torch = input_image_torch.permute(
+            2, 0, 1).contiguous()[None, :, :, :]
+
+        self.set_torch_image(input_image_torch, image.shape[:2])
+
+    @torch.no_grad()
+    def set_torch_image(
+        self,
+        transformed_image: torch.Tensor,
+        original_image_size: Tuple[int, ...],
+    ) -> None:
+        """Calculates the image embeddings for the provided image, allowing
+        masks to be predicted with the 'predict' method. Expects the input
+        image to be already transformed to the format expected by the model.
+
+        Arguments:
+          transformed_image (torch.Tensor): The input image, with shape
+            1x3xHxW, which has been transformed with ResizeLongestSide.
+          original_image_size (tuple(int, int)): The size of the image
+            before transformation, in (H, W) format.
+        """
+        assert (len(transformed_image.shape) == 4
+                and transformed_image.shape[1] == 3
+                and max(*transformed_image.shape[2:]) == max(
+                    self.model.image_encoder.img_size)
+                ), 'set_torch_image input must be BCHW with long side'
+        f' {self.model.image_encoder.img_size}.'
+        self.reset_image()
+
+        self.original_size = original_image_size
+        self.input_size = tuple(transformed_image.shape[-2:])
+        input_image = self.model.preprocess(transformed_image)
+        self.features = self.model.image_encoder(input_image)[0]
+        self.is_image_set = True
+
+    def predict(
+        self,
+        point_coords: Optional[np.ndarray] = None,
+        point_labels: Optional[np.ndarray] = None,
+        box: Optional[np.ndarray] = None,
+        mask_input: Optional[np.ndarray] = None,
+        multimask_output: bool = True,
+        return_logits: bool = False,
+    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        """Predict masks for the given input prompts, using the currently set
+        image.
+
+        Arguments:
+          point_coords (np.ndarray or None): A Nx2 array of point prompts to the
+            model. Each point is in (X,Y) in pixels.
+          point_labels (np.ndarray or None): A length N array of labels for the
+            point prompts. 1 indicates a foreground point and 0 indicates a
+            background point.
+          box (np.ndarray or None): A length 4 array given a box prompt to the
+            model, in XYXY format.
+          mask_input (np.ndarray): A low resolution mask input to the model, typically
+            coming from a previous prediction iteration. Has form 1xHxW, where
+            for SAM, H=W=256.
+          multimask_output (bool): If true, the model will return three masks.
+            For ambiguous input prompts (such as a single click), this will often
+            produce better masks than a single prediction. If only a single
+            mask is needed, the model's predicted quality score can be used
+            to select the best mask. For non-ambiguous prompts, such as multiple
+            input prompts, multimask_output=False can give better results.
+          return_logits (bool): If true, returns un-thresholded masks logits
+            instead of a binary mask.
+
+        Returns:
+          (np.ndarray): The output masks in CxHxW format, where C is the
+            number of masks, and (H, W) is the original image size.
+          (np.ndarray): An array of length C containing the model's
+            predictions for the quality of each mask.
+          (np.ndarray): An array of shape CxHxW, where C is the number
+            of masks and H=W=256. These low resolution logits can be passed to
+            a subsequent iteration as mask input.
+        """ # noqa
+        if not self.is_image_set:
+            raise RuntimeError(
+                'An image must be set with .set_image(...) before mask'
+                'prediction.')
+
+        # Transform input prompts
+        coords_torch = None
+        labels_torch = None
+        box_torch = None
+        mask_input_torch = None
+
+        if point_coords is not None:
+            assert (
+                point_labels is not None
+            ), 'point_labels must be supplied if point_coords is supplied.'
+            point_coords = self.transform.apply_coords(point_coords,
+                                                       self.original_size)
+            coords_torch = torch.as_tensor(
+                point_coords, dtype=torch.float, device=self.device)
+            labels_torch = torch.as_tensor(
+                point_labels, dtype=torch.int, device=self.device)
+            coords_torch, labels_torch = coords_torch[
+                None, :, :], labels_torch[None, :]
+        if box is not None:
+            box = self.transform.apply_boxes(box, self.original_size)
+            box_torch = torch.as_tensor(
+                box, dtype=torch.float, device=self.device)
+            box_torch = box_torch[None, :]
+        if mask_input is not None:
+            mask_input_torch = torch.as_tensor(
+                mask_input, dtype=torch.float, device=self.device)
+            mask_input_torch = mask_input_torch[None, :, :, :]
+
+        masks, iou_predictions, low_res_masks = self.predict_torch(
+            coords_torch,
+            labels_torch,
+            box_torch,
+            mask_input_torch,
+            multimask_output,
+            return_logits=return_logits,
+        )
+
+        masks = masks[0].detach().cpu().numpy()
+        iou_predictions = iou_predictions[0].detach().cpu().numpy()
+        low_res_masks = low_res_masks[0].detach().cpu().numpy()
+        return masks, iou_predictions, low_res_masks
+
+    @torch.no_grad()
+    def predict_torch(
+        self,
+        point_coords: Optional[torch.Tensor],
+        point_labels: Optional[torch.Tensor],
+        boxes: Optional[torch.Tensor] = None,
+        mask_input: Optional[torch.Tensor] = None,
+        multimask_output: bool = True,
+        return_logits: bool = False,
+    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        """Predict masks for the given input prompts, using the currently set
+        image. Input prompts are batched torch tensors and are expected to
+        already be transformed to the input frame using ResizeLongestSide.
+
+        Arguments:
+          point_coords (torch.Tensor or None): A BxNx2 array of point prompts to the
+            model. Each point is in (X,Y) in pixels.
+          point_labels (torch.Tensor or None): A BxN array of labels for the
+            point prompts. 1 indicates a foreground point and 0 indicates a
+            background point.
+          box (np.ndarray or None): A Bx4 array given a box prompt to the
+            model, in XYXY format.
+          mask_input (np.ndarray): A low resolution mask input to the model, typically
+            coming from a previous prediction iteration. Has form Bx1xHxW, where
+            for SAM, H=W=256. Masks returned by a previous iteration of the
+            predict method do not need further transformation.
+          multimask_output (bool): If true, the model will return three masks.
+            For ambiguous input prompts (such as a single click), this will often
+            produce better masks than a single prediction. If only a single
+            mask is needed, the model's predicted quality score can be used
+            to select the best mask. For non-ambiguous prompts, such as multiple
+            input prompts, multimask_output=False can give better results.
+          return_logits (bool): If true, returns un-thresholded masks logits
+            instead of a binary mask.
+
+        Returns:
+          (torch.Tensor): The output masks in BxCxHxW format, where C is the
+            number of masks, and (H, W) is the original image size.
+          (torch.Tensor): An array of shape BxC containing the model's
+            predictions for the quality of each mask.
+          (torch.Tensor): An array of shape BxCxHxW, where C is the number
+            of masks and H=W=256. These low res logits can be passed to
+            a subsequent iteration as mask input.
+        """ # noqa
+        if not self.is_image_set:
+            raise RuntimeError(
+                'An image must be set with .set_image(...) before mask '
+                'prediction.')
+
+        if point_coords is not None:
+            points = (point_coords, point_labels)
+        else:
+            points = None
+
+        # Embed prompts
+        sparse_embeddings, dense_embeddings = self.model.prompt_encoder(
+            points=points,
+            boxes=boxes,
+            masks=mask_input,
+        )
+
+        # Predict masks
+        low_res_masks, iou_predictions = self.model.mask_decoder(
+            image_embeddings=self.features,
+            image_pe=self.model.prompt_encoder.get_dense_pe(),
+            sparse_prompt_embeddings=sparse_embeddings,
+            dense_prompt_embeddings=dense_embeddings,
+            multimask_output=multimask_output,
+        )
+
+        # Upscale the masks to the original image resolution
+        masks = self.model.postprocess_masks(low_res_masks, self.input_size,
+                                             self.original_size)
+
+        if not return_logits:
+            masks = masks > self.model.mask_threshold
+
+        return masks, iou_predictions, low_res_masks
+
+    def get_image_embedding(self) -> torch.Tensor:
+        """Returns the image embeddings for the currently set image, with shape
+        1xCxHxW, where C is the embedding dimension and (H,W) are the embedding
+        spatial dimension of SAM (typically C=256, H=W=64)."""
+        if not self.is_image_set:
+            raise RuntimeError(
+                'An image must be set with .set_image(...) to generate an '
+                'embedding.')
+        assert self.features is not None, 'Features must exist if an image has'
+        ' been set.'
+        return self.features
+
+    @property
+    def device(self) -> torch.device:
+        return self.model.device
+
+    def reset_image(self) -> None:
+        """Resets the currently set image."""
+        self.is_image_set = False
+        self.features = None
+        self.orig_h = None
+        self.orig_w = None
+        self.input_h = None
+        self.input_w = None
+
+    def init_model(self, arch: str):
+        model = MODELS.build(
+            dict(
+                type='SAM',
+                image_encoder_cfg=dict(
+                    type='mmpretrain.ViTSAM',
+                    arch=arch,
+                    img_size=1024,
+                    patch_size=16,
+                    out_channels=256,
+                    use_abs_pos=True,
+                    use_rel_pos=True,
+                    window_size=14,
+                ),
+                prompt_encoder_cfg=dict(
+                    type='PromptEncoder',
+                    embed_dim=256,
+                    image_embedding_size=(64, 64),
+                    input_image_size=(1024, 1024),
+                    mask_in_chans=16,
+                ),
+                mask_decoder_cfg=dict(
+                    type='MaskDecoder',
+                    num_multimask_outputs=3,
+                    transformer=dict(
+                        type='TwoWayTransformer',
+                        depth=2,
+                        embedding_dim=256,
+                        mlp_dim=2048,
+                        num_heads=8,
+                    ),
+                    transformer_dim=256,
+                    iou_head_depth=3,
+                    iou_head_hidden_dim=256,
+                )))
+        load_checkpoint(model, model_zoo.get(arch), strict=True)
+        if torch.cuda.is_available():
+            model = model.cuda()
+        return model
+
+
+class SamAutomaticMaskGenerator:
+
+    def __init__(
+        self,
+        arch: str = 'base',
+        points_per_side: Optional[int] = 32,
+        points_per_batch: int = 64,
+        pred_iou_thresh: float = 0.88,
+        stability_score_thresh: float = 0.95,
+        stability_score_offset: float = 1.0,
+        box_nms_thresh: float = 0.7,
+        crop_n_layers: int = 0,
+        crop_nms_thresh: float = 0.7,
+        crop_overlap_ratio: float = 512 / 1500,
+        crop_n_points_downscale_factor: int = 1,
+        point_grids: Optional[List[np.ndarray]] = None,
+        min_mask_region_area: int = 0,
+        output_mode: str = 'binary_mask',
+    ) -> None:
+        """Using a SAM model, generates masks for the entire image. Generates a
+        grid of point prompts over the image, then filters low quality and
+        duplicate masks. The default settings are chosen for SAM with a ViT-H
+        backbone.
+
+        Arguments:
+          arch (str): The SAM model to use for mask prediction.
+          points_per_side (int or None): The number of points to be sampled
+            along one side of the image. The total number of points is
+            points_per_side**2. If None, 'point_grids' must provide explicit
+            point sampling.
+          points_per_batch (int): Sets the number of points run simultaneously
+            by the model. Higher numbers may be faster but use more GPU memory.
+          pred_iou_thresh (float): A filtering threshold in [0,1], using the
+            model's predicted mask quality.
+          stability_score_thresh (float): A filtering threshold in [0,1], using
+            the stability of the mask under changes to the cutoff used to binarize
+            the model's mask predictions.
+          stability_score_offset (float): The amount to shift the cutoff when
+            calculated the stability score.
+          box_nms_thresh (float): The box IoU cutoff used by non-maximal
+            suppression to filter duplicate masks.
+          crops_n_layers (int): If >0, mask prediction will be run again on
+            crops of the image. Sets the number of layers to run, where each
+            layer has 2**i_layer number of image crops.
+          crops_nms_thresh (float): The box IoU cutoff used by non-maximal
+            suppression to filter duplicate masks between different crops.
+          crop_overlap_ratio (float): Sets the degree to which crops overlap.
+            In the first crop layer, crops will overlap by this fraction of
+            the image length. Later layers with more crops scale down this overlap.
+          crop_n_points_downscale_factor (int): The number of points-per-side
+            sampled in layer n is scaled down by crop_n_points_downscale_factor**n.
+          point_grids (list(np.ndarray) or None): A list over explicit grids
+            of points used for sampling, normalized to [0,1]. The nth grid in the
+            list is used in the nth crop layer. Exclusive with points_per_side.
+          min_mask_region_area (int): If >0, postprocessing will be applied
+            to remove disconnected regions and holes in masks with area smaller
+            than min_mask_region_area. Requires opencv.
+          output_mode (str): The form masks are returned in. Can be 'binary_mask',
+            'uncompressed_rle', or 'coco_rle'. 'coco_rle' requires pycocotools.
+            For large resolutions, 'binary_mask' may consume large amounts of
+            memory.
+        """ # noqa
+
+        assert (points_per_side is None) != (
+            point_grids is None
+        ), 'Exactly one of points_per_side or point_grid must be provided.'
+        if points_per_side is not None:
+            self.point_grids = build_all_layer_point_grids(
+                points_per_side,
+                crop_n_layers,
+                crop_n_points_downscale_factor,
+            )
+        elif point_grids is not None:
+            self.point_grids = point_grids
+        else:
+            raise ValueError(
+                "Can't have both points_per_side and point_grid be None.")
+
+        assert output_mode in [
+            'binary_mask',
+            'uncompressed_rle',
+            'coco_rle',
+        ], f'Unknown output_mode {output_mode}.'
+        if output_mode == 'coco_rle':
+            from pycocotools import \
+                mask as mask_utils  # type: ignore # noqa: F401
+
+        if min_mask_region_area > 0:
+            import cv2  # type: ignore # noqa: F401
+
+        self.predictor = SAMInferencer(arch)
+        self.points_per_batch = points_per_batch
+        self.pred_iou_thresh = pred_iou_thresh
+        self.stability_score_thresh = stability_score_thresh
+        self.stability_score_offset = stability_score_offset
+        self.box_nms_thresh = box_nms_thresh
+        self.crop_n_layers = crop_n_layers
+        self.crop_nms_thresh = crop_nms_thresh
+        self.crop_overlap_ratio = crop_overlap_ratio
+        self.crop_n_points_downscale_factor = crop_n_points_downscale_factor
+        self.min_mask_region_area = min_mask_region_area
+        self.output_mode = output_mode
+
+    @torch.no_grad()
+    def generate(self, image: np.ndarray) -> List[Dict[str, Any]]:
+        """Generates masks for the given image.
+
+        Arguments:
+          image (np.ndarray): The image to generate masks for, in HWC uint8 format.
+
+        Returns:
+           list(dict(str, any)): A list over records for masks. Each record is
+             a dict containing the following keys:
+               segmentation (dict(str, any) or np.ndarray): The mask. If
+                 output_mode='binary_mask', is an array of shape HW. Otherwise,
+                 is a dictionary containing the RLE.
+               bbox (list(float)): The box around the mask, in XYWH format.
+               area (int): The area in pixels of the mask.
+               predicted_iou (float): The model's own prediction of the mask's
+                 quality. This is filtered by the pred_iou_thresh parameter.
+               point_coords (list(list(float))): The point coordinates input
+                 to the model to generate this mask.
+               stability_score (float): A measure of the mask's quality. This
+                 is filtered on using the stability_score_thresh parameter.
+               crop_box (list(float)): The crop of the image used to generate
+                 the mask, given in XYWH format.
+        """ # noqa
+
+        # Generate masks
+        mask_data = self._generate_masks(image)
+
+        # Filter small disconnected regions and holes in masks
+        if self.min_mask_region_area > 0:
+            mask_data = self.postprocess_small_regions(
+                mask_data,
+                self.min_mask_region_area,
+                max(self.box_nms_thresh, self.crop_nms_thresh),
+            )
+
+        # Encode masks
+        if self.output_mode == 'coco_rle':
+            mask_data['segmentations'] = [
+                coco_encode_rle(rle) for rle in mask_data['rles']
+            ]
+        elif self.output_mode == 'binary_mask':
+            mask_data['segmentations'] = [
+                rle_to_mask(rle) for rle in mask_data['rles']
+            ]
+        else:
+            mask_data['segmentations'] = mask_data['rles']
+
+        # Write mask records
+        curr_anns = []
+        for idx in range(len(mask_data['segmentations'])):
+            ann = {
+                'segmentation':
+                mask_data['segmentations'][idx],
+                'area':
+                area_from_rle(mask_data['rles'][idx]),
+                'bbox':
+                box_xyxy_to_xywh(mask_data['boxes'][idx]).tolist(),
+                'predicted_iou':
+                mask_data['iou_preds'][idx].item(),
+                'point_coords': [mask_data['points'][idx].tolist()],
+                'stability_score':
+                mask_data['stability_score'][idx].item(),
+                'crop_box':
+                box_xyxy_to_xywh(mask_data['crop_boxes'][idx]).tolist(),
+            }
+            curr_anns.append(ann)
+
+        return curr_anns
+
+    def _generate_masks(self, image: np.ndarray) -> MaskData:
+        orig_size = image.shape[:2]
+        crop_boxes, layer_idxs = generate_crop_boxes(orig_size,
+                                                     self.crop_n_layers,
+                                                     self.crop_overlap_ratio)
+
+        # Iterate over image crops
+        data = MaskData()
+        for crop_box, layer_idx in zip(crop_boxes, layer_idxs):
+            crop_data = self._process_crop(image, crop_box, layer_idx,
+                                           orig_size)
+            data.cat(crop_data)
+
+        # Remove duplicate masks between crops
+        if len(crop_boxes) > 1:
+            # Prefer masks from smaller crops
+            scores = 1 / box_area(data['crop_boxes'])
+            scores = scores.to(data['boxes'].device)
+            keep_by_nms = batched_nms(
+                data['boxes'].float(),
+                scores,
+                torch.zeros(len(data['boxes'])),  # categories
+                iou_threshold=self.crop_nms_thresh,
+            )
+            data.filter(keep_by_nms)
+
+        data.to_numpy()
+        return data
+
+    def _process_crop(
+        self,
+        image: np.ndarray,
+        crop_box: List[int],
+        crop_layer_idx: int,
+        orig_size: Tuple[int, ...],
+    ) -> MaskData:
+        # Crop the image and calculate embeddings
+        x0, y0, x1, y1 = crop_box
+        cropped_im = image[y0:y1, x0:x1, :]
+        cropped_im_size = cropped_im.shape[:2]
+        self.predictor.set_image(cropped_im)
+
+        # Get points for this crop
+        points_scale = np.array(cropped_im_size)[None, ::-1]
+        points_for_image = self.point_grids[crop_layer_idx] * points_scale
+
+        # Generate masks for this crop in batches
+        data = MaskData()
+        for (points, ) in batch_iterator(self.points_per_batch,
+                                         points_for_image):
+            batch_data = self._process_batch(points, cropped_im_size, crop_box,
+                                             orig_size)
+            data.cat(batch_data)
+            del batch_data
+        self.predictor.reset_image()
+
+        # Remove duplicates within this crop.
+        keep_by_nms = batched_nms(
+            data['boxes'].float(),
+            data['iou_preds'],
+            torch.zeros(len(data['boxes'])),  # categories
+            iou_threshold=self.box_nms_thresh,
+        )
+        data.filter(keep_by_nms)
+
+        # Return to the original image frame
+        data['boxes'] = uncrop_boxes_xyxy(data['boxes'], crop_box)
+        data['points'] = uncrop_points(data['points'], crop_box)
+        data['crop_boxes'] = torch.tensor(
+            [crop_box for _ in range(len(data['rles']))])
+
+        return data
+
+    def _process_batch(
+        self,
+        points: np.ndarray,
+        im_size: Tuple[int, ...],
+        crop_box: List[int],
+        orig_size: Tuple[int, ...],
+    ) -> MaskData:
+        orig_h, orig_w = orig_size
+
+        # Run model on this batch
+        transformed_points = self.predictor.transform.apply_coords(
+            points, im_size)
+        in_points = torch.as_tensor(
+            transformed_points, device=self.predictor.device)
+        in_labels = torch.ones(
+            in_points.shape[0], dtype=torch.int, device=in_points.device)
+        masks, iou_preds, _ = self.predictor.predict_torch(
+            in_points[:, None, :],
+            in_labels[:, None],
+            multimask_output=True,
+            return_logits=True,
+        )
+
+        # Serialize predictions and store in MaskData
+        data = MaskData(
+            masks=masks.flatten(0, 1),
+            iou_preds=iou_preds.flatten(0, 1),
+            points=torch.as_tensor(points.repeat(masks.shape[1], axis=0)),
+        )
+        del masks
+
+        # Filter by predicted IoU
+        if self.pred_iou_thresh > 0.0:
+            keep_mask = data['iou_preds'] > self.pred_iou_thresh
+            data.filter(keep_mask)
+
+        # Calculate stability score
+        data['stability_score'] = calculate_stability_score(
+            data['masks'], self.predictor.model.mask_threshold,
+            self.stability_score_offset)
+        if self.stability_score_thresh > 0.0:
+            keep_mask = data['stability_score'] >= self.stability_score_thresh
+            data.filter(keep_mask)
+
+        # Threshold masks and calculate boxes
+        data['masks'] = data['masks'] > self.predictor.model.mask_threshold
+        data['boxes'] = batched_mask_to_box(data['masks'])
+
+        # Filter boxes that touch crop boundaries
+        keep_mask = ~is_box_near_crop_edge(data['boxes'], crop_box,
+                                           [0, 0, orig_w, orig_h])
+        if not torch.all(keep_mask):
+            data.filter(keep_mask)
+
+        # Compress to RLE
+        data['masks'] = uncrop_masks(data['masks'], crop_box, orig_h, orig_w)
+        data['rles'] = mask_to_rle_pytorch(data['masks'])
+        del data['masks']
+
+        return data
+
+    @staticmethod
+    def postprocess_small_regions(mask_data: MaskData, min_area: int,
+                                  nms_thresh: float) -> MaskData:
+        """Removes small disconnected regions and holes in masks, then reruns
+        box NMS to remove any new duplicates.
+
+        Edits mask_data in place.
+
+        Requires open-cv as a dependency.
+        """
+        if len(mask_data['rles']) == 0:
+            return mask_data
+
+        # Filter small disconnected regions and holes
+        new_masks = []
+        scores = []
+        for rle in mask_data['rles']:
+            mask = rle_to_mask(rle)
+
+            mask, changed = remove_small_regions(mask, min_area, mode='holes')
+            unchanged = not changed
+            mask, changed = remove_small_regions(
+                mask, min_area, mode='islands')
+            unchanged = unchanged and not changed
+
+            new_masks.append(torch.as_tensor(mask).unsqueeze(0))
+            # Give score=0 to changed masks and score=1 to unchanged masks
+            # so NMS will prefer ones that didn't need postprocessing
+            scores.append(float(unchanged))
+
+        # Recalculate boxes and remove any new duplicates
+        masks = torch.cat(new_masks, dim=0)
+        boxes = batched_mask_to_box(masks)
+        keep_by_nms = batched_nms(
+            boxes.float(),
+            torch.as_tensor(scores),
+            torch.zeros(len(boxes)),  # categories
+            iou_threshold=nms_thresh,
+        )
+
+        # Only recalculate RLEs for masks that have changed
+        for i_mask in keep_by_nms:
+            if scores[i_mask] == 0.0:
+                mask_torch = masks[i_mask].unsqueeze(0)
+                mask_data['rles'][i_mask] = mask_to_rle_pytorch(mask_torch)[0]
+                mask_data['boxes'][i_mask] = boxes[
+                    i_mask]  # update res directly
+        mask_data.filter(keep_by_nms)
+
+        return mask_data
diff --git a/mmsegmentation/projects/sam_inference_demo/sam/utils/__init__.py b/mmsegmentation/projects/sam_inference_demo/sam/utils/__init__.py
new file mode 100644
index 0000000..5d33e33
--- /dev/null
+++ b/mmsegmentation/projects/sam_inference_demo/sam/utils/__init__.py
@@ -0,0 +1,2 @@
+from .amg import *  # noqa: F403 F401
+from .transforms import ResizeLongestSide  # noqa: F403 F401
diff --git a/mmsegmentation/projects/sam_inference_demo/sam/utils/amg.py b/mmsegmentation/projects/sam_inference_demo/sam/utils/amg.py
new file mode 100644
index 0000000..3ba3599
--- /dev/null
+++ b/mmsegmentation/projects/sam_inference_demo/sam/utils/amg.py
@@ -0,0 +1,355 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+# https://github.com/facebookresearch/segment-anything
+
+import math
+from copy import deepcopy
+from itertools import product
+from typing import Any, Dict, Generator, ItemsView, List, Tuple
+
+import numpy as np
+import torch
+
+
+class MaskData:
+    """A structure for storing masks and their related data in batched format.
+
+    Implements basic filtering and concatenation.
+    """
+
+    def __init__(self, **kwargs) -> None:
+        for v in kwargs.values():
+            assert isinstance(
+                v, (list, np.ndarray, torch.Tensor)
+            ), 'MaskData only supports list, numpy arrays, and torch tensors.'
+        self._stats = dict(**kwargs)
+
+    def __setitem__(self, key: str, item: Any) -> None:
+        assert isinstance(
+            item, (list, np.ndarray, torch.Tensor)
+        ), 'MaskData only supports list, numpy arrays, and torch tensors.'
+        self._stats[key] = item
+
+    def __delitem__(self, key: str) -> None:
+        del self._stats[key]
+
+    def __getitem__(self, key: str) -> Any:
+        return self._stats[key]
+
+    def items(self) -> ItemsView[str, Any]:
+        return self._stats.items()
+
+    def filter(self, keep: torch.Tensor) -> None:
+        for k, v in self._stats.items():
+            if v is None:
+                self._stats[k] = None
+            elif isinstance(v, torch.Tensor):
+                self._stats[k] = v[torch.as_tensor(keep, device=v.device)]
+            elif isinstance(v, np.ndarray):
+                self._stats[k] = v[keep.detach().cpu().numpy()]
+            elif isinstance(v, list) and keep.dtype == torch.bool:
+                self._stats[k] = [a for i, a in enumerate(v) if keep[i]]
+            elif isinstance(v, list):
+                self._stats[k] = [v[i] for i in keep]
+            else:
+                raise TypeError(
+                    f'MaskData key {k} has an unsupported type {type(v)}.')
+
+    def cat(self, new_stats: 'MaskData') -> None:
+        for k, v in new_stats.items():
+            if k not in self._stats or self._stats[k] is None:
+                self._stats[k] = deepcopy(v)
+            elif isinstance(v, torch.Tensor):
+                self._stats[k] = torch.cat([self._stats[k], v], dim=0)
+            elif isinstance(v, np.ndarray):
+                self._stats[k] = np.concatenate([self._stats[k], v], axis=0)
+            elif isinstance(v, list):
+                self._stats[k] = self._stats[k] + deepcopy(v)
+            else:
+                raise TypeError(
+                    f'MaskData key {k} has an unsupported type {type(v)}.')
+
+    def to_numpy(self) -> None:
+        for k, v in self._stats.items():
+            if isinstance(v, torch.Tensor):
+                self._stats[k] = v.detach().cpu().numpy()
+
+
+def is_box_near_crop_edge(boxes: torch.Tensor,
+                          crop_box: List[int],
+                          orig_box: List[int],
+                          atol: float = 20.0) -> torch.Tensor:
+    """Filter masks at the edge of a crop, but not at the edge of the original
+    image."""
+    crop_box_torch = torch.as_tensor(
+        crop_box, dtype=torch.float, device=boxes.device)
+    orig_box_torch = torch.as_tensor(
+        orig_box, dtype=torch.float, device=boxes.device)
+    boxes = uncrop_boxes_xyxy(boxes, crop_box).float()
+    near_crop_edge = torch.isclose(
+        boxes, crop_box_torch[None, :], atol=atol, rtol=0)
+    near_image_edge = torch.isclose(
+        boxes, orig_box_torch[None, :], atol=atol, rtol=0)
+    near_crop_edge = torch.logical_and(near_crop_edge, ~near_image_edge)
+    return torch.any(near_crop_edge, dim=1)
+
+
+def box_xyxy_to_xywh(box_xyxy: torch.Tensor) -> torch.Tensor:
+    box_xywh = deepcopy(box_xyxy)
+    box_xywh[2] = box_xywh[2] - box_xywh[0]
+    box_xywh[3] = box_xywh[3] - box_xywh[1]
+    return box_xywh
+
+
+def batch_iterator(batch_size: int, *args) -> Generator[List[Any], None, None]:
+    assert len(args) > 0 and all(
+        len(a) == len(args[0]) for a in
+        args), 'Batched iteration must have inputs of all the same size.'
+    n_batches = len(args[0]) // batch_size + int(
+        len(args[0]) % batch_size != 0)
+    for b in range(n_batches):
+        yield [arg[b * batch_size:(b + 1) * batch_size] for arg in args]
+
+
+def mask_to_rle_pytorch(tensor: torch.Tensor) -> List[Dict[str, Any]]:
+    """Encodes masks to an uncompressed RLE, in the format expected by pycoco
+    tools."""
+    # Put in fortran order and flatten h,w
+    b, h, w = tensor.shape
+    tensor = tensor.permute(0, 2, 1).flatten(1)
+
+    # Compute change indices
+    diff = tensor[:, 1:] ^ tensor[:, :-1]
+    change_indices = diff.nonzero()
+
+    # Encode run length
+    out = []
+    for i in range(b):
+        cur_idxs = change_indices[change_indices[:, 0] == i, 1]
+        cur_idxs = torch.cat([
+            torch.tensor([0], dtype=cur_idxs.dtype, device=cur_idxs.device),
+            cur_idxs + 1,
+            torch.tensor([h * w], dtype=cur_idxs.dtype,
+                         device=cur_idxs.device),
+        ])
+        btw_idxs = cur_idxs[1:] - cur_idxs[:-1]
+        counts = [] if tensor[i, 0] == 0 else [0]
+        counts.extend(btw_idxs.detach().cpu().tolist())
+        out.append({'size': [h, w], 'counts': counts})
+    return out
+
+
+def rle_to_mask(rle: Dict[str, Any]) -> np.ndarray:
+    """Compute a binary mask from an uncompressed RLE."""
+    h, w = rle['size']
+    mask = np.empty(h * w, dtype=bool)
+    idx = 0
+    parity = False
+    for count in rle['counts']:
+        mask[idx:idx + count] = parity
+        idx += count
+        parity ^= True
+    mask = mask.reshape(w, h)
+    return mask.transpose()  # Put in C order
+
+
+def area_from_rle(rle: Dict[str, Any]) -> int:
+    return sum(rle['counts'][1::2])
+
+
+def calculate_stability_score(masks: torch.Tensor, mask_threshold: float,
+                              threshold_offset: float) -> torch.Tensor:
+    """Computes the stability score for a batch of masks.
+
+    The stability score is the IoU between the binary masks obtained by
+    thresholding the predicted mask logits at high and low values.
+    """
+    # One mask is always contained inside the other.
+    # Save memory by preventing unnecessary cast to torch.int64
+    intersections = ((masks > (mask_threshold + threshold_offset)).sum(
+        -1, dtype=torch.int16).sum(-1, dtype=torch.int32))
+    unions = ((masks > (mask_threshold - threshold_offset)).sum(
+        -1, dtype=torch.int16).sum(-1, dtype=torch.int32))
+    return intersections / unions
+
+
+def build_point_grid(n_per_side: int) -> np.ndarray:
+    """Generates a 2D grid of points evenly spaced in [0,1]x[0,1]."""
+    offset = 1 / (2 * n_per_side)
+    points_one_side = np.linspace(offset, 1 - offset, n_per_side)
+    points_x = np.tile(points_one_side[None, :], (n_per_side, 1))
+    points_y = np.tile(points_one_side[:, None], (1, n_per_side))
+    points = np.stack([points_x, points_y], axis=-1).reshape(-1, 2)
+    return points
+
+
+def build_all_layer_point_grids(n_per_side: int, n_layers: int,
+                                scale_per_layer: int) -> List[np.ndarray]:
+    """Generates point grids for all crop layers."""
+    points_by_layer = []
+    for i in range(n_layers + 1):
+        n_points = int(n_per_side / (scale_per_layer**i))
+        points_by_layer.append(build_point_grid(n_points))
+    return points_by_layer
+
+
+def generate_crop_boxes(
+        im_size: Tuple[int, ...], n_layers: int,
+        overlap_ratio: float) -> Tuple[List[List[int]], List[int]]:
+    """Generates a list of crop boxes of different sizes.
+
+    Each layer has (2**i)**2 boxes for the ith layer.
+    """
+    crop_boxes, layer_idxs = [], []
+    im_h, im_w = im_size
+    short_side = min(im_h, im_w)
+
+    # Original image
+    crop_boxes.append([0, 0, im_w, im_h])
+    layer_idxs.append(0)
+
+    def crop_len(orig_len, n_crops, overlap):
+        return int(math.ceil((overlap * (n_crops - 1) + orig_len) / n_crops))
+
+    for i_layer in range(n_layers):
+        n_crops_per_side = 2**(i_layer + 1)
+        overlap = int(overlap_ratio * short_side * (2 / n_crops_per_side))
+
+        crop_w = crop_len(im_w, n_crops_per_side, overlap)
+        crop_h = crop_len(im_h, n_crops_per_side, overlap)
+
+        crop_box_x0 = [
+            int((crop_w - overlap) * i) for i in range(n_crops_per_side)
+        ]
+        crop_box_y0 = [
+            int((crop_h - overlap) * i) for i in range(n_crops_per_side)
+        ]
+
+        # Crops in XYWH format
+        for x0, y0 in product(crop_box_x0, crop_box_y0):
+            box = [x0, y0, min(x0 + crop_w, im_w), min(y0 + crop_h, im_h)]
+            crop_boxes.append(box)
+            layer_idxs.append(i_layer + 1)
+
+    return crop_boxes, layer_idxs
+
+
+def uncrop_boxes_xyxy(boxes: torch.Tensor,
+                      crop_box: List[int]) -> torch.Tensor:
+    x0, y0, _, _ = crop_box
+    offset = torch.tensor([[x0, y0, x0, y0]], device=boxes.device)
+    # Check if boxes has a channel dimension
+    if len(boxes.shape) == 3:
+        offset = offset.unsqueeze(1)
+    return boxes + offset
+
+
+def uncrop_points(points: torch.Tensor, crop_box: List[int]) -> torch.Tensor:
+    x0, y0, _, _ = crop_box
+    offset = torch.tensor([[x0, y0]], device=points.device)
+    # Check if points has a channel dimension
+    if len(points.shape) == 3:
+        offset = offset.unsqueeze(1)
+    return points + offset
+
+
+def uncrop_masks(masks: torch.Tensor, crop_box: List[int], orig_h: int,
+                 orig_w: int) -> torch.Tensor:
+    x0, y0, x1, y1 = crop_box
+    if x0 == 0 and y0 == 0 and x1 == orig_w and y1 == orig_h:
+        return masks
+    # Coordinate transform masks
+    pad_x, pad_y = orig_w - (x1 - x0), orig_h - (y1 - y0)
+    pad = (x0, pad_x - x0, y0, pad_y - y0)
+    return torch.nn.functional.pad(masks, pad, value=0)
+
+
+def remove_small_regions(mask: np.ndarray, area_thresh: float,
+                         mode: str) -> Tuple[np.ndarray, bool]:
+    """Removes small disconnected regions and holes in a mask.
+
+    Returns the mask and an indicator of if the mask has been modified.
+    """
+    import cv2  # type: ignore
+
+    assert mode in ['holes', 'islands']
+    correct_holes = mode == 'holes'
+    working_mask = (correct_holes ^ mask).astype(np.uint8)
+    n_labels, regions, stats, _ = cv2.connectedComponentsWithStats(
+        working_mask, 8)
+    sizes = stats[:, -1][1:]  # Row 0 is background label
+    small_regions = [i + 1 for i, s in enumerate(sizes) if s < area_thresh]
+    if len(small_regions) == 0:
+        return mask, False
+    fill_labels = [0] + small_regions
+    if not correct_holes:
+        fill_labels = [i for i in range(n_labels) if i not in fill_labels]
+        # If every region is below threshold, keep largest
+        if len(fill_labels) == 0:
+            fill_labels = [int(np.argmax(sizes)) + 1]
+    mask = np.isin(regions, fill_labels)
+    return mask, True
+
+
+def coco_encode_rle(uncompressed_rle: Dict[str, Any]) -> Dict[str, Any]:
+    from pycocotools import mask as mask_utils  # type: ignore
+
+    h, w = uncompressed_rle['size']
+    rle = mask_utils.frPyObjects(uncompressed_rle, h, w)
+    rle['counts'] = rle['counts'].decode(
+        'utf-8')  # Necessary to serialize with json
+    return rle
+
+
+def batched_mask_to_box(masks: torch.Tensor) -> torch.Tensor:
+    """Calculates boxes in XYXY format around masks.
+
+    Return [0,0,0,0] for an empty mask. For input shape C1xC2x...xHxW, the
+    output shape is C1xC2x...x4.
+    """
+    # torch.max below raises an error on empty inputs, just skip in this case
+    if torch.numel(masks) == 0:
+        return torch.zeros(*masks.shape[:-2], 4, device=masks.device)
+
+    # Normalize shape to CxHxW
+    shape = masks.shape
+    h, w = shape[-2:]
+    if len(shape) > 2:
+        masks = masks.flatten(0, -3)
+    else:
+        masks = masks.unsqueeze(0)
+
+    # Get top and bottom edges
+    in_height, _ = torch.max(masks, dim=-1)
+    in_height_coords = in_height * torch.arange(
+        h, device=in_height.device)[None, :]
+    bottom_edges, _ = torch.max(in_height_coords, dim=-1)
+    in_height_coords = in_height_coords + h * (~in_height)
+    top_edges, _ = torch.min(in_height_coords, dim=-1)
+
+    # Get left and right edges
+    in_width, _ = torch.max(masks, dim=-2)
+    in_width_coords = in_width * torch.arange(
+        w, device=in_width.device)[None, :]
+    right_edges, _ = torch.max(in_width_coords, dim=-1)
+    in_width_coords = in_width_coords + w * (~in_width)
+    left_edges, _ = torch.min(in_width_coords, dim=-1)
+
+    # If the mask is empty the right edge will be to the left of the left edge.
+    # Replace these boxes with [0, 0, 0, 0]
+    empty_filter = (right_edges < left_edges) | (bottom_edges < top_edges)
+    out = torch.stack([left_edges, top_edges, right_edges, bottom_edges],
+                      dim=-1)
+    out = out * (~empty_filter).unsqueeze(-1)
+
+    # Return to original shape
+    if len(shape) > 2:
+        out = out.reshape(*shape[:-2], 4)
+    else:
+        out = out[0]
+
+    return out
diff --git a/mmsegmentation/projects/sam_inference_demo/sam/utils/transforms.py b/mmsegmentation/projects/sam_inference_demo/sam/utils/transforms.py
new file mode 100644
index 0000000..484fd66
--- /dev/null
+++ b/mmsegmentation/projects/sam_inference_demo/sam/utils/transforms.py
@@ -0,0 +1,110 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+from copy import deepcopy
+from typing import Tuple
+
+import numpy as np
+import torch
+from torch.nn import functional as F
+from torchvision.transforms.functional import resize  # type: ignore
+from torchvision.transforms.functional import to_pil_image
+
+from mmseg.registry import TRANSFORMS
+
+
+@TRANSFORMS.register_module()
+class ResizeLongestSide:
+    """Resizes images to longest side 'target_length', as well as provides
+    methods for resizing coordinates and boxes.
+
+    Provides methods for transforming both numpy array and batched torch
+    tensors.
+    """
+
+    def __init__(self, target_length: int) -> None:
+        self.target_length = target_length
+
+    def apply_image(self, image: np.ndarray) -> np.ndarray:
+        """Expects a numpy array with shape HxWxC in uint8 format."""
+        target_size = self.get_preprocess_shape(image.shape[0], image.shape[1],
+                                                self.target_length)
+        return np.array(resize(to_pil_image(image), target_size))
+
+    def apply_coords(self, coords: np.ndarray,
+                     original_size: Tuple[int, ...]) -> np.ndarray:
+        """Expects a numpy array of length 2 in the final dimension.
+
+        Requires the original image size in (H, W) format.
+        """
+        old_h, old_w = original_size
+        new_h, new_w = self.get_preprocess_shape(original_size[0],
+                                                 original_size[1],
+                                                 self.target_length)
+        coords = deepcopy(coords).astype(float)
+        coords[..., 0] = coords[..., 0] * (new_w / old_w)
+        coords[..., 1] = coords[..., 1] * (new_h / old_h)
+        return coords
+
+    def apply_boxes(self, boxes: np.ndarray,
+                    original_size: Tuple[int, ...]) -> np.ndarray:
+        """Expects a numpy array shape Bx4.
+
+        Requires the original image size in (H, W) format.
+        """
+        boxes = self.apply_coords(boxes.reshape(-1, 2, 2), original_size)
+        return boxes.reshape(-1, 4)
+
+    def apply_image_torch(self, image: torch.Tensor) -> torch.Tensor:
+        """Expects batched images with shape BxCxHxW and float format.
+
+        This transformation may not exactly match apply_image. apply_image is
+        the transformation expected by the model.
+        """
+        # Expects an image in BCHW format. May not exactly match apply_image.
+        target_size = self.get_preprocess_shape(image.shape[0], image.shape[1],
+                                                self.target_length)
+        return F.interpolate(
+            image,
+            target_size,
+            mode='bilinear',
+            align_corners=False,
+            antialias=True)
+
+    def apply_coords_torch(self, coords: torch.Tensor,
+                           original_size: Tuple[int, ...]) -> torch.Tensor:
+        """Expects a torch tensor with length 2 in the last dimension.
+
+        Requires the original image size in (H, W) format.
+        """
+        old_h, old_w = original_size
+        new_h, new_w = self.get_preprocess_shape(original_size[0],
+                                                 original_size[1],
+                                                 self.target_length)
+        coords = deepcopy(coords).to(torch.float)
+        coords[..., 0] = coords[..., 0] * (new_w / old_w)
+        coords[..., 1] = coords[..., 1] * (new_h / old_h)
+        return coords
+
+    def apply_boxes_torch(self, boxes: torch.Tensor,
+                          original_size: Tuple[int, ...]) -> torch.Tensor:
+        """Expects a torch tensor with shape Bx4.
+
+        Requires the original image size in (H, W) format.
+        """
+        boxes = self.apply_coords_torch(boxes.reshape(-1, 2, 2), original_size)
+        return boxes.reshape(-1, 4)
+
+    @staticmethod
+    def get_preprocess_shape(oldh: int, oldw: int,
+                             long_side_length: int) -> Tuple[int, int]:
+        """Compute the output size given input size and target long side
+        length."""
+        scale = long_side_length * 1.0 / max(oldh, oldw)
+        newh, neww = oldh * scale, oldw * scale
+        neww = int(neww + 0.5)
+        newh = int(newh + 0.5)
+        return (newh, neww)
diff --git a/mmsegmentation/projects/sam_inference_demo/sam_image_demo.ipynb b/mmsegmentation/projects/sam_inference_demo/sam_image_demo.ipynb
new file mode 100644
index 0000000..1cb433f
--- /dev/null
+++ b/mmsegmentation/projects/sam_inference_demo/sam_image_demo.ipynb
@@ -0,0 +1,122 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import cv2\n",
+    "\n",
+    "import sam # noqa: F401\n",
+    "from sam.sam_inferencer import SAMInferencer\n",
+    "\n",
+    "\n",
+    "def show_mask(mask, ax, random_color=False):\n",
+    "    if random_color:\n",
+    "        color = np.concatenate([np.random.random(3), np.array([0.6])], axis=0)\n",
+    "    else:\n",
+    "        color = np.array([30/255, 144/255, 255/255, 0.6])\n",
+    "    h, w = mask.shape[-2:]\n",
+    "    mask_image = mask.reshape(h, w, 1) * color.reshape(1, 1, -1)\n",
+    "    ax.imshow(mask_image)\n",
+    "    \n",
+    "def show_points(coords, labels, ax, marker_size=375):\n",
+    "    pos_points = coords[labels==1]\n",
+    "    neg_points = coords[labels==0]\n",
+    "    ax.scatter(pos_points[:, 0], pos_points[:, 1], color='green', marker='*', s=marker_size, edgecolor='white', linewidth=1.25)\n",
+    "    ax.scatter(neg_points[:, 0], neg_points[:, 1], color='red', marker='*', s=marker_size, edgecolor='white', linewidth=1.25)   \n",
+    "    \n",
+    "def show_box(box, ax):\n",
+    "    x0, y0 = box[0], box[1]\n",
+    "    w, h = box[2] - box[0], box[3] - box[1]\n",
+    "    ax.add_patch(plt.Rectangle((x0, y0), w, h, edgecolor='green', facecolor=(0,0,0,0), lw=2))\n",
+    "\n",
+    "image = cv2.imread('../../demo/demo.png')\n",
+    "image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "plt.figure(figsize=(10,10))\n",
+    "plt.imshow(image)\n",
+    "plt.axis('on')\n",
+    "plt.show()\n",
+    "print(image.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "inferencer = SAMInferencer(arch='huge')\n",
+    "inferencer.set_image(image)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "input_point = np.array([[280, 230], [500, 300]])\n",
+    "input_label = np.array([1, 1])\n",
+    "plt.figure(figsize=(10,10))\n",
+    "plt.imshow(image)\n",
+    "show_points(input_point, input_label, plt.gca())\n",
+    "plt.axis('on')\n",
+    "plt.show()  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "masks, scores, logits = inferencer.predict(\n",
+    "    point_coords=input_point,\n",
+    "    point_labels=input_label,\n",
+    "    multimask_output=True,\n",
+    ")\n",
+    "for i, (mask, score) in enumerate(zip(masks, scores)):\n",
+    "    plt.figure(figsize=(10,10))\n",
+    "    plt.imshow(image)\n",
+    "    show_mask(mask, plt.gca(), random_color=True)\n",
+    "    show_points(input_point, input_label, plt.gca())\n",
+    "    plt.title(f\"Mask {i+1}, Score: {score:.3f}\", fontsize=18)\n",
+    "    plt.axis('off')\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "pt1.13",
+   "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.10.9"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/mmsegmentation/projects/van/README.md b/mmsegmentation/projects/van/README.md
new file mode 100644
index 0000000..be0ba36
--- /dev/null
+++ b/mmsegmentation/projects/van/README.md
@@ -0,0 +1,101 @@
+# Visual Attention Network (VAN) for Segmentation
+
+This repo is a PyTorch implementation of applying **VAN** (**Visual Attention Network**) to semantic segmentation.
+
+The code is an integration from [VAN-Segmentation](https://github.com/Visual-Attention-Network/VAN-Segmentation/blob/main/README.md?plain=1)
+
+More details can be found in [**Visual Attention Network**](https://arxiv.org/abs/2202.09741).
+
+## Citation
+
+```bib
+@article{guo2022visual,
+  title={Visual Attention Network},
+  author={Guo, Meng-Hao and Lu, Cheng-Ze and Liu, Zheng-Ning and Cheng, Ming-Ming and Hu, Shi-Min},
+  journal={arXiv preprint arXiv:2202.09741},
+  year={2022}
+}
+```
+
+## Results
+
+**Notes**: Pre-trained models can be found in [TsingHua Cloud](https://cloud.tsinghua.edu.cn/d/0100f0cea37d41ba8d08/).
+
+Results can be found in [VAN-Segmentation](https://github.com/Visual-Attention-Network/VAN-Segmentation/blob/main/README.md?plain=1)
+
+We provide evaluation results of the converted weights.
+
+| Method  |   Backbone   | mIoU  |                                                                    Download                                                                    |
+| :-----: | :----------: | :---: | :--------------------------------------------------------------------------------------------------------------------------------------------: |
+| UPerNet |    VAN-B2    | 49.35 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b2-in1kpre_upernet_3rdparty_512x512-ade20k_20230522-19c58aee.pth)  |
+| UPerNet |    VAN-B3    | 49.71 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b3-in1kpre_upernet_3rdparty_512x512-ade20k_20230522-653bd6b7.pth)  |
+| UPerNet |    VAN-B4    | 51.56 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b4-in1kpre_upernet_3rdparty_512x512-ade20k_20230522-653bd6b7.pth)  |
+| UPerNet | VAN-B4-in22k | 52.61 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b4-in22kpre_upernet_3rdparty_512x512-ade20k_20230522-4a4d744a.pth) |
+| UPerNet | VAN-B5-in22k | 53.11 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b5-in22kpre_upernet_3rdparty_512x512-ade20k_20230522-5bb6f2b4.pth) |
+| UPerNet | VAN-B6-in22k | 54.25 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b6-in22kpre_upernet_3rdparty_512x512-ade20k_20230522-e226b363.pth) |
+|   FPN   |    VAN-B0    | 38.65 |   [model](https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b0-in1kpre_fpn_3rdparty_512x512-ade20k_20230522-75a76298.pth)    |
+|   FPN   |    VAN-B1    | 43.22 |   [model](https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b1-in1kpre_fpn_3rdparty_512x512-ade20k_20230522-104499ff.pth)    |
+|   FPN   |    VAN-B2    | 46.84 |   [model](https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b2-in1kpre_fpn_3rdparty_512x512-ade20k_20230522-7074e6f8.pth)    |
+|   FPN   |    VAN-B3    | 48.32 |   [model](https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b3-in1kpre_fpn_3rdparty_512x512-ade20k_20230522-2c3b7f5e.pth)    |
+
+## Preparation
+
+Install MMSegmentation and download ADE20K according to the guidelines in MMSegmentation.
+
+## Requirement
+
+**Step 0.** Install [MMCV](https://github.com/open-mmlab/mmcv) using [MIM](https://github.com/open-mmlab/mim).
+
+```shell
+pip install -U openmim
+mim install mmengine
+mim install "mmcv>=2.0.0"
+```
+
+**Step 1.** Install MMSegmentation.
+
+Case a: If you develop and run mmseg directly, install it from source:
+
+```shell
+git clone -b main https://github.com/open-mmlab/mmsegmentation.git
+cd mmsegmentation
+pip install -v -e .
+```
+
+Case b: If you use mmsegmentation as a dependency or third-party package, install it with pip:
+
+```shell
+pip install "mmsegmentation>=1.0.0"
+```
+
+## Training
+
+If you use 4 GPUs for training by default. Run:
+
+```bash
+bash tools/dist_train.sh projects/van/configs/van/van-b2_pre1k_upernet_4xb2-160k_ade20k-512x512.py 4
+```
+
+## Evaluation
+
+To evaluate the model, an example is:
+
+```bash
+bash tools/dist_train.sh projects/van/configs/van/van-b2_pre1k_upernet_4xb2-160k_ade20k-512x512.py work_dirs/van-b2_pre1k_upernet_4xb2-160k_ade20k-512x512/iter_160000.pth 4 --eval mIoU
+```
+
+## FLOPs
+
+To calculate FLOPs for a model, run:
+
+```bash
+bash tools/analysis_tools/get_flops.py projects/van/configs/van/van-b2_pre1k_upernet_4xb2-160k_ade20k-512x512.py --shape 512 512
+```
+
+## Acknowledgment
+
+Our implementation is mainly based on [mmsegmentation](https://github.com/open-mmlab/mmsegmentation/tree/v0.12.0), [Swin-Transformer](https://github.com/SwinTransformer/Swin-Transformer-Semantic-Segmentation), [PoolFormer](https://github.com/sail-sg/poolformer), [Enjoy-Hamburger](https://github.com/Gsunshine/Enjoy-Hamburger) and [VAN-Segmentation](https://github.com/Visual-Attention-Network/VAN-Segmentation/blob/main/README.md?plain=1). Thanks for their authors.
+
+## LICENSE
+
+This repo is under the Apache-2.0 license. For commercial use, please contact the authors.
diff --git a/mmsegmentation/projects/van/backbones/__init__.py b/mmsegmentation/projects/van/backbones/__init__.py
new file mode 100644
index 0000000..071995d
--- /dev/null
+++ b/mmsegmentation/projects/van/backbones/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .van import VAN
+
+__all__ = ['VAN']
diff --git a/mmsegmentation/projects/van/backbones/van.py b/mmsegmentation/projects/van/backbones/van.py
new file mode 100644
index 0000000..301834a
--- /dev/null
+++ b/mmsegmentation/projects/van/backbones/van.py
@@ -0,0 +1,124 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+import torch
+import torch.nn as nn
+from mmengine.model import BaseModule
+
+from mmseg.models.backbones.mscan import (MSCAN, MSCABlock,
+                                          MSCASpatialAttention,
+                                          OverlapPatchEmbed)
+from mmseg.registry import MODELS
+
+
+class VANAttentionModule(BaseModule):
+
+    def __init__(self, in_channels):
+        super().__init__()
+        self.conv0 = nn.Conv2d(
+            in_channels, in_channels, 5, padding=2, groups=in_channels)
+        self.conv_spatial = nn.Conv2d(
+            in_channels,
+            in_channels,
+            7,
+            stride=1,
+            padding=9,
+            groups=in_channels,
+            dilation=3)
+        self.conv1 = nn.Conv2d(in_channels, in_channels, 1)
+
+    def forward(self, x):
+        u = x.clone()
+        attn = self.conv0(x)
+        attn = self.conv_spatial(attn)
+        attn = self.conv1(attn)
+        return u * attn
+
+
+class VANSpatialAttention(MSCASpatialAttention):
+
+    def __init__(self, in_channels, act_cfg=dict(type='GELU')):
+        super().__init__(in_channels, act_cfg=act_cfg)
+        self.spatial_gating_unit = VANAttentionModule(in_channels)
+
+
+class VANBlock(MSCABlock):
+
+    def __init__(self,
+                 channels,
+                 mlp_ratio=4.,
+                 drop=0.,
+                 drop_path=0.,
+                 act_cfg=dict(type='GELU'),
+                 norm_cfg=dict(type='SyncBN', requires_grad=True)):
+        super().__init__(
+            channels,
+            mlp_ratio=mlp_ratio,
+            drop=drop,
+            drop_path=drop_path,
+            act_cfg=act_cfg,
+            norm_cfg=norm_cfg)
+        self.attn = VANSpatialAttention(channels)
+
+
+@MODELS.register_module()
+class VAN(MSCAN):
+
+    def __init__(self,
+                 in_channels=3,
+                 embed_dims=[64, 128, 256, 512],
+                 mlp_ratios=[8, 8, 4, 4],
+                 drop_rate=0.,
+                 drop_path_rate=0.,
+                 depths=[3, 4, 6, 3],
+                 num_stages=4,
+                 act_cfg=dict(type='GELU'),
+                 norm_cfg=dict(type='SyncBN', requires_grad=True),
+                 pretrained=None,
+                 init_cfg=None):
+        super(MSCAN, self).__init__(init_cfg=init_cfg)
+
+        assert not (init_cfg and pretrained), \
+            'init_cfg and pretrained cannot be set at the same time'
+        if isinstance(pretrained, str):
+            warnings.warn('DeprecationWarning: pretrained is deprecated, '
+                          'please use "init_cfg" instead')
+            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
+        elif pretrained is not None:
+            raise TypeError('pretrained must be a str or None')
+
+        self.depths = depths
+        self.num_stages = num_stages
+
+        # stochastic depth decay rule
+        dpr = [
+            x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))
+        ]
+        cur = 0
+
+        for i in range(num_stages):
+            patch_embed = OverlapPatchEmbed(
+                patch_size=7 if i == 0 else 3,
+                stride=4 if i == 0 else 2,
+                in_channels=in_channels if i == 0 else embed_dims[i - 1],
+                embed_dim=embed_dims[i],
+                norm_cfg=norm_cfg)
+
+            block = nn.ModuleList([
+                VANBlock(
+                    channels=embed_dims[i],
+                    mlp_ratio=mlp_ratios[i],
+                    drop=drop_rate,
+                    drop_path=dpr[cur + j],
+                    act_cfg=act_cfg,
+                    norm_cfg=norm_cfg) for j in range(depths[i])
+            ])
+            norm = nn.LayerNorm(embed_dims[i])
+            cur += depths[i]
+
+            setattr(self, f'patch_embed{i + 1}', patch_embed)
+            setattr(self, f'block{i + 1}', block)
+            setattr(self, f'norm{i + 1}', norm)
+
+    def init_weights(self):
+        return super().init_weights()
diff --git a/mmsegmentation/projects/van/configs/_base_/datasets/ade20k.py b/mmsegmentation/projects/van/configs/_base_/datasets/ade20k.py
new file mode 100644
index 0000000..69b3c2a
--- /dev/null
+++ b/mmsegmentation/projects/van/configs/_base_/datasets/ade20k.py
@@ -0,0 +1,14 @@
+# dataset settings
+_base_ = '../../../../../configs/_base_/datasets/ade20k.py'
+
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+    dict(type='ResizeToMultiple', size_divisor=32),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='PackSegInputs')
+]
+val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader
diff --git a/mmsegmentation/projects/van/configs/_base_/models/van_fpn.py b/mmsegmentation/projects/van/configs/_base_/models/van_fpn.py
new file mode 100644
index 0000000..c7fd739
--- /dev/null
+++ b/mmsegmentation/projects/van/configs/_base_/models/van_fpn.py
@@ -0,0 +1,43 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255,
+    size=(512, 512))
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='VAN',
+        embed_dims=[32, 64, 160, 256],
+        drop_rate=0.0,
+        drop_path_rate=0.1,
+        depths=[3, 3, 5, 2],
+        act_cfg=dict(type='GELU'),
+        norm_cfg=norm_cfg,
+        init_cfg=dict()),
+    neck=dict(
+        type='FPN',
+        in_channels=[32, 64, 160, 256],
+        out_channels=256,
+        num_outs=4),
+    decode_head=dict(
+        type='FPNHead',
+        in_channels=[256, 256, 256, 256],
+        in_index=[0, 1, 2, 3],
+        feature_strides=[4, 8, 16, 32],
+        channels=128,
+        dropout_ratio=0.1,
+        num_classes=150,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/projects/van/configs/_base_/models/van_upernet.py b/mmsegmentation/projects/van/configs/_base_/models/van_upernet.py
new file mode 100644
index 0000000..8f94c0d
--- /dev/null
+++ b/mmsegmentation/projects/van/configs/_base_/models/van_upernet.py
@@ -0,0 +1,51 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255,
+    size=(512, 512))
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='VAN',
+        embed_dims=[32, 64, 160, 256],
+        drop_rate=0.0,
+        drop_path_rate=0.1,
+        depths=[3, 3, 5, 2],
+        act_cfg=dict(type='GELU'),
+        norm_cfg=norm_cfg,
+        init_cfg=dict()),
+    decode_head=dict(
+        type='UPerHead',
+        in_channels=[32, 64, 160, 256],
+        in_index=[0, 1, 2, 3],
+        pool_scales=(1, 2, 3, 6),
+        channels=512,
+        dropout_ratio=0.1,
+        num_classes=150,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=160,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=150,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/projects/van/configs/van/van-b0_fpn_8xb4-40k_ade20k-512x512.py b/mmsegmentation/projects/van/configs/van/van-b0_fpn_8xb4-40k_ade20k-512x512.py
new file mode 100644
index 0000000..2faf378
--- /dev/null
+++ b/mmsegmentation/projects/van/configs/van/van-b0_fpn_8xb4-40k_ade20k-512x512.py
@@ -0,0 +1,8 @@
+_base_ = './van-b2_fpn_8xb4-40k_ade20k-512x512.py'
+ckpt_path = 'https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b0_3rdparty_20230522-956f5e0d.pth'  # noqa
+model = dict(
+    backbone=dict(
+        embed_dims=[32, 64, 160, 256],
+        depths=[3, 3, 5, 2],
+        init_cfg=dict(type='Pretrained', checkpoint=ckpt_path)),
+    neck=dict(in_channels=[32, 64, 160, 256]))
diff --git a/mmsegmentation/projects/van/configs/van/van-b1_fpn_8xb4-40k_ade20k-512x512.py b/mmsegmentation/projects/van/configs/van/van-b1_fpn_8xb4-40k_ade20k-512x512.py
new file mode 100644
index 0000000..cf64a71
--- /dev/null
+++ b/mmsegmentation/projects/van/configs/van/van-b1_fpn_8xb4-40k_ade20k-512x512.py
@@ -0,0 +1,6 @@
+_base_ = './van-b2_fpn_8xb4-40k_ade20k-512x512.py'
+ckpt_path = 'https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b1_3rdparty_20230522-3adb117f.pth'  # noqa
+model = dict(
+    backbone=dict(
+        depths=[2, 2, 4, 2],
+        init_cfg=dict(type='Pretrained', checkpoint=ckpt_path)))
diff --git a/mmsegmentation/projects/van/configs/van/van-b2_fpn_8xb4-40k_ade20k-512x512.py b/mmsegmentation/projects/van/configs/van/van-b2_fpn_8xb4-40k_ade20k-512x512.py
new file mode 100644
index 0000000..965fa1c
--- /dev/null
+++ b/mmsegmentation/projects/van/configs/van/van-b2_fpn_8xb4-40k_ade20k-512x512.py
@@ -0,0 +1,53 @@
+_base_ = [
+    '../_base_/models/van_fpn.py',
+    '../_base_/datasets/ade20k.py',
+    '../../../../configs/_base_/default_runtime.py',
+]
+custom_imports = dict(imports=['projects.van.backbones'])
+ckpt_path = 'https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b2_3rdparty_20230522-636fac93.pth'  # noqa
+model = dict(
+    type='EncoderDecoder',
+    backbone=dict(
+        embed_dims=[64, 128, 320, 512],
+        depths=[3, 3, 12, 3],
+        init_cfg=dict(type='Pretrained', checkpoint=ckpt_path),
+        drop_path_rate=0.2),
+    neck=dict(in_channels=[64, 128, 320, 512]),
+    decode_head=dict(num_classes=150))
+
+train_dataloader = dict(batch_size=4)
+
+# we use 8 gpu instead of 4 in mmsegmentation, so lr*2 and max_iters/2
+gpu_multiples = 2
+max_iters = 80000 // gpu_multiples
+interval = 8000 // gpu_multiples
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW',
+        lr=0.0001 * gpu_multiples,
+        # betas=(0.9, 0.999),
+        weight_decay=0.0001),
+    clip_grad=None)
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        power=0.9,
+        eta_min=0.0,
+        begin=0,
+        end=max_iters,
+        by_epoch=False,
+    )
+]
+train_cfg = dict(
+    type='IterBasedTrainLoop', max_iters=max_iters, val_interval=interval)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=interval),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))
diff --git a/mmsegmentation/projects/van/configs/van/van-b2_upernet_4xb2-160k_ade20k-512x512.py b/mmsegmentation/projects/van/configs/van/van-b2_upernet_4xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..c529606
--- /dev/null
+++ b/mmsegmentation/projects/van/configs/van/van-b2_upernet_4xb2-160k_ade20k-512x512.py
@@ -0,0 +1,46 @@
+_base_ = [
+    '../_base_/models/van_upernet.py', '../_base_/datasets/ade20k.py',
+    '../../../../configs/_base_/default_runtime.py',
+    '../../../../configs/_base_/schedules/schedule_160k.py'
+]
+custom_imports = dict(imports=['projects.van.backbones'])
+ckpt_path = 'https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b2_3rdparty_20230522-636fac93.pth'  # noqa
+model = dict(
+    type='EncoderDecoder',
+    backbone=dict(
+        embed_dims=[64, 128, 320, 512],
+        depths=[3, 3, 12, 3],
+        init_cfg=dict(type='Pretrained', checkpoint=ckpt_path)),
+    decode_head=dict(in_channels=[64, 128, 320, 512], num_classes=150),
+    auxiliary_head=dict(in_channels=320, num_classes=150))
+
+# AdamW optimizer
+# no weight decay for position embedding & layer norm in backbone
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
+    clip_grad=None,
+    paramwise_cfg=dict(
+        custom_keys={
+            'absolute_pos_embed': dict(decay_mult=0.),
+            'relative_position_bias_table': dict(decay_mult=0.),
+            'norm': dict(decay_mult=0.)
+        }))
+# learning policy
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        power=1.0,
+        begin=1500,
+        end=_base_.train_cfg.max_iters,
+        eta_min=0.0,
+        by_epoch=False,
+    )
+]
+
+# By default, models are trained on 8 GPUs with 2 images per GPU
+train_dataloader = dict(batch_size=2)
diff --git a/mmsegmentation/projects/van/configs/van/van-b3_fpn_8xb4-40k_ade20k-512x512.py b/mmsegmentation/projects/van/configs/van/van-b3_fpn_8xb4-40k_ade20k-512x512.py
new file mode 100644
index 0000000..b0493fe
--- /dev/null
+++ b/mmsegmentation/projects/van/configs/van/van-b3_fpn_8xb4-40k_ade20k-512x512.py
@@ -0,0 +1,11 @@
+_base_ = './van-b2_fpn_8xb4-40k_ade20k-512x512.py'
+ckpt_path = 'https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b3_3rdparty_20230522-a184e051.pth'  # noqa
+model = dict(
+    type='EncoderDecoder',
+    backbone=dict(
+        embed_dims=[64, 128, 320, 512],
+        depths=[3, 5, 27, 3],
+        init_cfg=dict(type='Pretrained', checkpoint=ckpt_path),
+        drop_path_rate=0.3),
+    neck=dict(in_channels=[64, 128, 320, 512]))
+train_dataloader = dict(batch_size=4)
diff --git a/mmsegmentation/projects/van/configs/van/van-b3_upernet_4xb2-160k_ade20k-512x512.py b/mmsegmentation/projects/van/configs/van/van-b3_upernet_4xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..8201801
--- /dev/null
+++ b/mmsegmentation/projects/van/configs/van/van-b3_upernet_4xb2-160k_ade20k-512x512.py
@@ -0,0 +1,8 @@
+_base_ = './van-b2_upernet_4xb2-160k_ade20k-512x512.py'
+ckpt_path = 'https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b3_3rdparty_20230522-a184e051.pth'  # noqa
+model = dict(
+    type='EncoderDecoder',
+    backbone=dict(
+        depths=[3, 5, 27, 3],
+        init_cfg=dict(type='Pretrained', checkpoint=ckpt_path),
+        drop_path_rate=0.3))
diff --git a/mmsegmentation/projects/van/configs/van/van-b4-in22kpre_upernet_4xb4-160k_ade20k-512x512.py b/mmsegmentation/projects/van/configs/van/van-b4-in22kpre_upernet_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..15c8f7c
--- /dev/null
+++ b/mmsegmentation/projects/van/configs/van/van-b4-in22kpre_upernet_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = './van-b2_upernet_4xb2-160k_ade20k-512x512.py'
+ckpt_path = 'https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b4-in22k_3rdparty_20230522-5e31cafb.pth'  # noqa
+model = dict(
+    backbone=dict(
+        depths=[3, 6, 40, 3],
+        init_cfg=dict(type='Pretrained', checkpoint=ckpt_path),
+        drop_path_rate=0.4))
+
+# By default, models are trained on 8 GPUs with 2 images per GPU
+train_dataloader = dict(batch_size=4)
diff --git a/mmsegmentation/projects/van/configs/van/van-b4_upernet_4xb4-160k_ade20k-512x512.py b/mmsegmentation/projects/van/configs/van/van-b4_upernet_4xb4-160k_ade20k-512x512.py
new file mode 100644
index 0000000..33ae049
--- /dev/null
+++ b/mmsegmentation/projects/van/configs/van/van-b4_upernet_4xb4-160k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = './van-b2_upernet_4xb2-160k_ade20k-512x512.py'
+ckpt_path = 'https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b4_3rdparty_20230522-1d71c077.pth'  # noqa
+model = dict(
+    backbone=dict(
+        depths=[3, 6, 40, 3],
+        init_cfg=dict(type='Pretrained', checkpoint=ckpt_path),
+        drop_path_rate=0.4))
+
+# By default, models are trained on 4 GPUs with 4 images per GPU
+train_dataloader = dict(batch_size=4)
diff --git a/mmsegmentation/projects/van/configs/van/van-b5-in22kpre_upernet_4xb2-160k_ade20k-512x512.py b/mmsegmentation/projects/van/configs/van/van-b5-in22kpre_upernet_4xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..f36c624
--- /dev/null
+++ b/mmsegmentation/projects/van/configs/van/van-b5-in22kpre_upernet_4xb2-160k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = './van-b2_upernet_4xb2-160k_ade20k-512x512.py'
+ckpt_path = 'https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b5-in22k_3rdparty_20230522-b26134d7.pth'  # noqa
+model = dict(
+    backbone=dict(
+        embed_dims=[96, 192, 480, 768],
+        depths=[3, 3, 24, 3],
+        init_cfg=dict(type='Pretrained', checkpoint=ckpt_path),
+        drop_path_rate=0.4),
+    decode_head=dict(in_channels=[96, 192, 480, 768], num_classes=150),
+    auxiliary_head=dict(in_channels=480, num_classes=150))
diff --git a/mmsegmentation/projects/van/configs/van/van-b6-in22kpre_upernet_4xb2-160k_ade20k-512x512.py b/mmsegmentation/projects/van/configs/van/van-b6-in22kpre_upernet_4xb2-160k_ade20k-512x512.py
new file mode 100644
index 0000000..aa529ef
--- /dev/null
+++ b/mmsegmentation/projects/van/configs/van/van-b6-in22kpre_upernet_4xb2-160k_ade20k-512x512.py
@@ -0,0 +1,10 @@
+_base_ = './van-b2_upernet_4xb2-160k_ade20k-512x512.py'
+ckpt_path = 'https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b6-in22k_3rdparty_20230522-5e5172a3.pth'  # noqa
+model = dict(
+    backbone=dict(
+        embed_dims=[96, 192, 384, 768],
+        depths=[6, 6, 90, 6],
+        init_cfg=dict(type='Pretrained', checkpoint=ckpt_path),
+        drop_path_rate=0.5),
+    decode_head=dict(in_channels=[96, 192, 384, 768], num_classes=150),
+    auxiliary_head=dict(in_channels=384, num_classes=150))
diff --git a/mmsegmentation/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..689ac07
--- /dev/null
+++ b/mmsegmentation/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,292 @@
+crop_size = (
+    512,
+    1024,
+)
+data_preprocessor = dict(
+    bgr_to_rgb=True,
+    mean=[
+        123.675,
+        116.28,
+        103.53,
+    ],
+    pad_val=0,
+    seg_pad_val=255,
+    size=(
+        512,
+        1024,
+    ),
+    std=[
+        58.395,
+        57.12,
+        57.375,
+    ],
+    type='SegDataPreProcessor')
+data_root = 'data/cityscapes/'
+dataset_type = 'CityscapesDataset'
+default_hooks = dict(
+    checkpoint=dict(by_epoch=False, interval=4000, type='CheckpointHook'),
+    logger=dict(interval=50, log_metric_by_epoch=False, type='LoggerHook'),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    timer=dict(type='IterTimerHook'),
+    visualization=dict(type='SegVisualizationHook'))
+default_scope = 'mmseg'
+env_cfg = dict(
+    cudnn_benchmark=True,
+    dist_cfg=dict(backend='nccl'),
+    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0))
+img_ratios = [
+    0.5,
+    0.75,
+    1.0,
+    1.25,
+    1.5,
+    1.75,
+]
+load_from = None
+log_level = 'INFO'
+log_processor = dict(by_epoch=False)
+model = dict(
+    auxiliary_head=dict(
+        align_corners=False,
+        channels=256,
+        concat_input=False,
+        dropout_ratio=0.1,
+        in_channels=1024,
+        in_index=2,
+        loss_decode=dict(
+            loss_weight=0.4, type='CrossEntropyLoss', use_sigmoid=False),
+        norm_cfg=dict(requires_grad=True, type='SyncBN'),
+        num_classes=19,
+        num_convs=1,
+        type='FCNHead'),
+    backbone=dict(
+        contract_dilation=True,
+        depth=50,
+        dilations=(
+            1,
+            1,
+            2,
+            4,
+        ),
+        norm_cfg=dict(requires_grad=True, type='SyncBN'),
+        norm_eval=False,
+        num_stages=4,
+        out_indices=(
+            0,
+            1,
+            2,
+            3,
+        ),
+        strides=(
+            1,
+            2,
+            1,
+            1,
+        ),
+        style='pytorch',
+        type='ResNetV1c'),
+    data_preprocessor=dict(
+        bgr_to_rgb=True,
+        mean=[
+            123.675,
+            116.28,
+            103.53,
+        ],
+        pad_val=0,
+        seg_pad_val=255,
+        size=(
+            512,
+            1024,
+        ),
+        std=[
+            58.395,
+            57.12,
+            57.375,
+        ],
+        type='SegDataPreProcessor'),
+    decode_head=dict(
+        align_corners=False,
+        channels=512,
+        dropout_ratio=0.1,
+        in_channels=2048,
+        in_index=3,
+        loss_decode=dict(
+            loss_weight=1.0, type='CrossEntropyLoss', use_sigmoid=False),
+        norm_cfg=dict(requires_grad=True, type='SyncBN'),
+        num_classes=19,
+        pool_scales=(
+            1,
+            2,
+            3,
+            6,
+        ),
+        type='PSPHead'),
+    pretrained='open-mmlab://resnet50_v1c',
+    test_cfg=dict(mode='whole'),
+    train_cfg=dict(),
+    type='EncoderDecoder')
+norm_cfg = dict(requires_grad=True, type='SyncBN')
+optim_wrapper = dict(
+    clip_grad=None,
+    optimizer=dict(lr=0.01, momentum=0.9, type='SGD', weight_decay=0.0005),
+    type='OptimWrapper')
+optimizer = dict(lr=0.01, momentum=0.9, type='SGD', weight_decay=0.0005)
+param_scheduler = [
+    dict(
+        begin=0,
+        by_epoch=False,
+        end=40000,
+        eta_min=0.0001,
+        power=0.9,
+        type='PolyLR'),
+]
+resume = False
+test_cfg = dict(type='TestLoop')
+test_dataloader = dict(
+    batch_size=1,
+    dataset=dict(
+        data_prefix=dict(
+            img_path='leftImg8bit/val', seg_map_path='gtFine/val'),
+        data_root='data/cityscapes/',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(keep_ratio=True, scale=(
+                2048,
+                1024,
+            ), type='Resize'),
+            dict(type='LoadAnnotations'),
+            dict(type='PackSegInputs'),
+        ],
+        type='CityscapesDataset'),
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(shuffle=False, type='DefaultSampler'))
+test_evaluator = dict(
+    iou_metrics=[
+        'mIoU',
+    ], type='IoUMetric')
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(keep_ratio=True, scale=(
+        2048,
+        1024,
+    ), type='Resize'),
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs'),
+]
+train_cfg = dict(max_iters=40000, type='IterBasedTrainLoop', val_interval=4000)
+train_dataloader = dict(
+    batch_size=2,
+    dataset=dict(
+        data_prefix=dict(
+            img_path='leftImg8bit/train', seg_map_path='gtFine/train'),
+        data_root='data/cityscapes/',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations'),
+            dict(
+                keep_ratio=True,
+                ratio_range=(
+                    0.5,
+                    2.0,
+                ),
+                scale=(
+                    2048,
+                    1024,
+                ),
+                type='RandomResize'),
+            dict(
+                cat_max_ratio=0.75, crop_size=(
+                    512,
+                    1024,
+                ), type='RandomCrop'),
+            dict(prob=0.5, type='RandomFlip'),
+            dict(type='PhotoMetricDistortion'),
+            dict(type='PackSegInputs'),
+        ],
+        type='CityscapesDataset'),
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(shuffle=True, type='InfiniteSampler'))
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(
+        keep_ratio=True,
+        ratio_range=(
+            0.5,
+            2.0,
+        ),
+        scale=(
+            2048,
+            1024,
+        ),
+        type='RandomResize'),
+    dict(cat_max_ratio=0.75, crop_size=(
+        512,
+        1024,
+    ), type='RandomCrop'),
+    dict(prob=0.5, type='RandomFlip'),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs'),
+]
+tta_model = dict(type='SegTTAModel')
+tta_pipeline = [
+    dict(backend_args=None, type='LoadImageFromFile'),
+    dict(
+        transforms=[
+            [
+                dict(keep_ratio=True, scale_factor=0.5, type='Resize'),
+                dict(keep_ratio=True, scale_factor=0.75, type='Resize'),
+                dict(keep_ratio=True, scale_factor=1.0, type='Resize'),
+                dict(keep_ratio=True, scale_factor=1.25, type='Resize'),
+                dict(keep_ratio=True, scale_factor=1.5, type='Resize'),
+                dict(keep_ratio=True, scale_factor=1.75, type='Resize'),
+            ],
+            [
+                dict(direction='horizontal', prob=0.0, type='RandomFlip'),
+                dict(direction='horizontal', prob=1.0, type='RandomFlip'),
+            ],
+            [
+                dict(type='LoadAnnotations'),
+            ],
+            [
+                dict(type='PackSegInputs'),
+            ],
+        ],
+        type='TestTimeAug'),
+]
+val_cfg = dict(type='ValLoop')
+val_dataloader = dict(
+    batch_size=1,
+    dataset=dict(
+        data_prefix=dict(
+            img_path='leftImg8bit/val', seg_map_path='gtFine/val'),
+        data_root='data/cityscapes/',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(keep_ratio=True, scale=(
+                2048,
+                1024,
+            ), type='Resize'),
+            dict(type='LoadAnnotations'),
+            dict(type='PackSegInputs'),
+        ],
+        type='CityscapesDataset'),
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(shuffle=False, type='DefaultSampler'))
+val_evaluator = dict(
+    iou_metrics=[
+        'mIoU',
+    ], type='IoUMetric')
+vis_backends = [
+    dict(type='LocalVisBackend'),
+]
+visualizer = dict(
+    name='visualizer',
+    type='SegLocalVisualizer',
+    vis_backends=[
+        dict(type='LocalVisBackend'),
+    ])
diff --git a/mmsegmentation/requirements.txt b/mmsegmentation/requirements.txt
new file mode 100644
index 0000000..501bddc
--- /dev/null
+++ b/mmsegmentation/requirements.txt
@@ -0,0 +1,4 @@
+-r requirements/optional.txt
+-r requirements/runtime.txt
+-r requirements/tests.txt
+-r requirements/multimodal.txt
diff --git a/mmsegmentation/requirements/albu.txt b/mmsegmentation/requirements/albu.txt
new file mode 100644
index 0000000..f421fbb
--- /dev/null
+++ b/mmsegmentation/requirements/albu.txt
@@ -0,0 +1 @@
+albumentations>=0.3.2 --no-binary qudida,albumentations
diff --git a/mmsegmentation/requirements/docs.txt b/mmsegmentation/requirements/docs.txt
new file mode 100644
index 0000000..19632d3
--- /dev/null
+++ b/mmsegmentation/requirements/docs.txt
@@ -0,0 +1,7 @@
+docutils==0.16.0
+myst-parser
+-e git+https://github.com/open-mmlab/pytorch_sphinx_theme.git#egg=pytorch_sphinx_theme
+sphinx==4.0.2
+sphinx_copybutton
+sphinx_markdown_tables
+urllib3<2.0.0
diff --git a/mmsegmentation/requirements/mminstall.txt b/mmsegmentation/requirements/mminstall.txt
new file mode 100644
index 0000000..5732d34
--- /dev/null
+++ b/mmsegmentation/requirements/mminstall.txt
@@ -0,0 +1,2 @@
+mmcv>=2.0.0rc4,<2.2.0
+mmengine>=0.5.0,<1.0.0
diff --git a/mmsegmentation/requirements/multimodal.txt b/mmsegmentation/requirements/multimodal.txt
new file mode 100644
index 0000000..2195d0d
--- /dev/null
+++ b/mmsegmentation/requirements/multimodal.txt
@@ -0,0 +1,2 @@
+ftfy
+regex
diff --git a/mmsegmentation/requirements/optional.txt b/mmsegmentation/requirements/optional.txt
new file mode 100644
index 0000000..b0310f5
--- /dev/null
+++ b/mmsegmentation/requirements/optional.txt
@@ -0,0 +1,22 @@
+cityscapesscripts
+-e git+https://github.com/openai/CLIP.git@main#egg=clip
+
+# for vpd model
+diffusers
+einops==0.3.0
+imageio==2.9.0
+imageio-ffmpeg==0.4.2
+invisible-watermark
+kornia==0.6
+-e git+https://github.com/CompVis/stable-diffusion@21f890f#egg=latent-diffusion
+nibabel
+omegaconf==2.1.1
+pudb==2019.2
+pytorch-lightning==1.4.2
+streamlit>=0.73.1
+-e git+https://github.com/CompVis/taming-transformers.git@master#egg=taming-transformers
+test-tube>=0.7.5
+timm
+torch-fidelity==0.3.0
+torchmetrics==0.6.0
+transformers==4.19.2
diff --git a/mmsegmentation/requirements/readthedocs.txt b/mmsegmentation/requirements/readthedocs.txt
new file mode 100644
index 0000000..9627504
--- /dev/null
+++ b/mmsegmentation/requirements/readthedocs.txt
@@ -0,0 +1,6 @@
+mmcv>=2.0.0rc1,<2.1.0
+mmengine>=0.4.0,<1.0.0
+prettytable
+scipy
+torch
+torchvision
diff --git a/mmsegmentation/requirements/runtime.txt b/mmsegmentation/requirements/runtime.txt
new file mode 100644
index 0000000..3e24258
--- /dev/null
+++ b/mmsegmentation/requirements/runtime.txt
@@ -0,0 +1,5 @@
+matplotlib
+numpy
+packaging
+prettytable
+scipy
diff --git a/mmsegmentation/requirements/tests.txt b/mmsegmentation/requirements/tests.txt
new file mode 100644
index 0000000..3fff252
--- /dev/null
+++ b/mmsegmentation/requirements/tests.txt
@@ -0,0 +1,8 @@
+codecov
+flake8
+ftfy
+interrogate
+pytest
+regex
+xdoctest>=0.10.0
+yapf
diff --git a/mmsegmentation/resources/seg_demo.gif b/mmsegmentation/resources/seg_demo.gif
new file mode 100644
index 0000000000000000000000000000000000000000..2f0760fe7a86912c07f9873eec3909ad41fe2acb
GIT binary patch
literal 951973
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%0AM5-r
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
Ss-vXLE+oo&gwdJ{0suScg1(CY

literal 0
HcmV?d00001

diff --git a/mmsegmentation/setup.cfg b/mmsegmentation/setup.cfg
new file mode 100644
index 0000000..2ea0760
--- /dev/null
+++ b/mmsegmentation/setup.cfg
@@ -0,0 +1,19 @@
+[yapf]
+based_on_style = pep8
+blank_line_before_nested_class_or_def = true
+split_before_expression_after_opening_paren = true
+
+[isort]
+line_length = 79
+multi_line_output = 0
+extra_standard_library = setuptools
+known_first_party = mmseg
+known_third_party = PIL,cityscapesscripts,cv2,detail,matplotlib,mmcv,numpy,onnxruntime,packaging,prettytable,pytest,pytorch_sphinx_theme,requests,scipy,seaborn,torch,ts
+no_lines_before = STDLIB,LOCALFOLDER
+default_section = THIRDPARTY
+
+[codespell]
+skip = *.po,*.ts,*.ipynb
+count =
+quiet-level = 3
+ignore-words-list = formating,sur,hist,dota,warmup,damon
diff --git a/mmsegmentation/setup.py b/mmsegmentation/setup.py
new file mode 100755
index 0000000..45d923d
--- /dev/null
+++ b/mmsegmentation/setup.py
@@ -0,0 +1,200 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os
+import os.path as osp
+import platform
+import shutil
+import sys
+import warnings
+from setuptools import find_packages, setup
+
+
+def readme():
+    with open('README.md', encoding='utf-8') as f:
+        content = f.read()
+    return content
+
+
+version_file = 'mmseg/version.py'
+
+
+def get_version():
+    with open(version_file) as f:
+        exec(compile(f.read(), version_file, 'exec'))
+    return locals()['__version__']
+
+
+def parse_requirements(fname='requirements.txt', with_version=True):
+    """Parse the package dependencies listed in a requirements file but strips
+    specific versioning information.
+
+    Args:
+        fname (str): path to requirements file
+        with_version (bool, default=False): if True include version specs
+
+    Returns:
+        List[str]: list of requirements items
+
+    CommandLine:
+        python -c "import setup; print(setup.parse_requirements())"
+    """
+    import re
+    import sys
+    from os.path import exists
+    require_fpath = fname
+
+    def parse_line(line):
+        """Parse information from a line in a requirements text file."""
+        if line.startswith('-r '):
+            # Allow specifying requirements in other files
+            target = line.split(' ')[1]
+            for info in parse_require_file(target):
+                yield info
+        else:
+            info = {'line': line}
+            if line.startswith('-e '):
+                info['package'] = line.split('#egg=')[1]
+            else:
+                # Remove versioning from the package
+                pat = '(' + '|'.join(['>=', '==', '>']) + ')'
+                parts = re.split(pat, line, maxsplit=1)
+                parts = [p.strip() for p in parts]
+
+                info['package'] = parts[0]
+                if len(parts) > 1:
+                    op, rest = parts[1:]
+                    if ';' in rest:
+                        # Handle platform specific dependencies
+                        # http://setuptools.readthedocs.io/en/latest/setuptools.html#declaring-platform-specific-dependencies
+                        version, platform_deps = map(str.strip,
+                                                     rest.split(';'))
+                        info['platform_deps'] = platform_deps
+                    else:
+                        version = rest  # NOQA
+                    info['version'] = (op, version)
+            yield info
+
+    def parse_require_file(fpath):
+        with open(fpath) as f:
+            for line in f.readlines():
+                line = line.strip()
+                if line and not line.startswith('#'):
+                    yield from parse_line(line)
+
+    def gen_packages_items():
+        if exists(require_fpath):
+            for info in parse_require_file(require_fpath):
+                parts = [info['package']]
+                if with_version and 'version' in info:
+                    parts.extend(info['version'])
+                if not sys.version.startswith('3.4'):
+                    # apparently package_deps are broken in 3.4
+                    platform_deps = info.get('platform_deps')
+                    if platform_deps is not None:
+                        parts.append(';' + platform_deps)
+                item = ''.join(parts)
+                yield item
+
+    packages = list(gen_packages_items())
+    return packages
+
+
+def add_mim_extension():
+    """Add extra files that are required to support MIM into the package.
+
+    These files will be added by creating a symlink to the originals if the
+    package is installed in `editable` mode (e.g. pip install -e .), or by
+    copying from the originals otherwise.
+    """
+
+    # parse installment mode
+    if 'develop' in sys.argv:
+        # installed by `pip install -e .`
+        if platform.system() == 'Windows':
+            # set `copy` mode here since symlink fails on Windows.
+            mode = 'copy'
+        else:
+            mode = 'symlink'
+    elif 'sdist' in sys.argv or 'bdist_wheel' in sys.argv or \
+            platform.system() == 'Windows':
+        # installed by `pip install .`
+        # or create source distribution by `python setup.py sdist`
+        # set `copy` mode here since symlink fails with WinError on Windows.
+        mode = 'copy'
+    else:
+        return
+
+    filenames = ['tools', 'configs', 'model-index.yml', 'dataset-index.yml']
+    repo_path = osp.dirname(__file__)
+    mim_path = osp.join(repo_path, 'mmseg', '.mim')
+    os.makedirs(mim_path, exist_ok=True)
+
+    for filename in filenames:
+        if osp.exists(filename):
+            src_path = osp.join(repo_path, filename)
+            tar_path = osp.join(mim_path, filename)
+
+            if osp.isfile(tar_path) or osp.islink(tar_path):
+                os.remove(tar_path)
+            elif osp.isdir(tar_path):
+                shutil.rmtree(tar_path)
+
+            if mode == 'symlink':
+                src_relpath = osp.relpath(src_path, osp.dirname(tar_path))
+                try:
+                    os.symlink(src_relpath, tar_path)
+                except OSError:
+                    # Creating a symbolic link on windows may raise an
+                    # `OSError: [WinError 1314]` due to privilege. If
+                    # the error happens, the src file will be copied
+                    mode = 'copy'
+                    warnings.warn(
+                        f'Failed to create a symbolic link for {src_relpath}, '
+                        f'and it will be copied to {tar_path}')
+                else:
+                    continue
+
+            if mode == 'copy':
+                if osp.isfile(src_path):
+                    shutil.copyfile(src_path, tar_path)
+                elif osp.isdir(src_path):
+                    shutil.copytree(src_path, tar_path)
+                else:
+                    warnings.warn(f'Cannot copy file {src_path}.')
+            else:
+                raise ValueError(f'Invalid mode {mode}')
+
+
+if __name__ == '__main__':
+    add_mim_extension()
+    setup(
+        name='mmsegmentation',
+        version=get_version(),
+        description='Open MMLab Semantic Segmentation Toolbox and Benchmark',
+        long_description=readme(),
+        long_description_content_type='text/markdown',
+        author='MMSegmentation Contributors',
+        author_email='openmmlab@gmail.com',
+        keywords='computer vision, semantic segmentation',
+        url='https://github.com/open-mmlab/mmsegmentation',
+        packages=find_packages(exclude=('configs', 'tools', 'demo')),
+        include_package_data=True,
+        classifiers=[
+            'Development Status :: 4 - Beta',
+            'License :: OSI Approved :: Apache Software License',
+            'Operating System :: OS Independent',
+            'Programming Language :: Python :: 3.6',
+            'Programming Language :: Python :: 3.7',
+            'Programming Language :: Python :: 3.8',
+            'Programming Language :: Python :: 3.9',
+        ],
+        license='Apache License 2.0',
+        install_requires=parse_requirements('requirements/runtime.txt'),
+        extras_require={
+            'all': parse_requirements('requirements.txt'),
+            'tests': parse_requirements('requirements/tests.txt'),
+            'optional': parse_requirements('requirements/optional.txt'),
+            'mim': parse_requirements('requirements/mminstall.txt'),
+            'multimodal': parse_requirements('requirements/multimodal.txt'),
+        },
+        ext_modules=[],
+        zip_safe=False)
diff --git a/mmsegmentation/test.ipynb b/mmsegmentation/test.ipynb
new file mode 100644
index 0000000..6d8c9c5
--- /dev/null
+++ b/mmsegmentation/test.ipynb
@@ -0,0 +1,194 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/conda/lib/python3.10/site-packages/albumentations/__init__.py:13: UserWarning: A new version of Albumentations is available: 1.4.21 (you have 1.4.18). Upgrade using: pip install -U albumentations. To disable automatic update checks, set the environment variable NO_ALBUMENTATIONS_UPDATE to 1.\n",
+      "  check_for_updates()\n"
+     ]
+    }
+   ],
+   "source": [
+    "from mmseg.datasets import XRayDataset\n",
+    "from mmengine.registry import init_default_scope\n",
+    "import sys\n",
+    "init_default_scope('mmseg')\n",
+    "sys.path.append(\"/data/ephemeral/home/mmsegmentation/mmseg\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'/data/ephemeral/home/mmsegmentation'"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import os\n",
+    "os.getcwd()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "crop_size = (1024, 1024)\n",
+    "\n",
+    "data_root = '/data/ephemeral/home/cityscapes_format_xlay/'\n",
+    "data_prefix=dict(img_path='leftImg8bit/train', seg_map_path='gtFine/train')\n",
+    "\n",
+    "train_pipeline = [\n",
+    "    dict(type='LoadImageFromFile'),\n",
+    "    dict(type='LoadAnnotations'),\n",
+    "    dict(\n",
+    "        type='RandomChoiceResize',\n",
+    "        scales=[int(1024 * x * 0.1) for x in range(5, 21)],\n",
+    "        resize_type='ResizeShortestEdge',\n",
+    "        max_size=4096),\n",
+    "    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),\n",
+    "    dict(type='RandomFlip', prob=0.5),\n",
+    "    dict(type='PhotoMetricDistortion'),\n",
+    "    dict(type='PackSegInputs')\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from mmengine.utils import is_str\n",
+    "\n",
+    "is_str('xray')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['finger-1',\n",
+       " 'finger-2',\n",
+       " 'finger-3',\n",
+       " 'finger-4',\n",
+       " 'finger-5',\n",
+       " 'finger-6',\n",
+       " 'finger-7',\n",
+       " 'finger-8',\n",
+       " 'finger-9',\n",
+       " 'finger-10',\n",
+       " 'finger-11',\n",
+       " 'finger-12',\n",
+       " 'finger-13',\n",
+       " 'finger-14',\n",
+       " 'finger-15',\n",
+       " 'finger-16',\n",
+       " 'finger-17',\n",
+       " 'finger-18',\n",
+       " 'finger-19',\n",
+       " 'Trapezium',\n",
+       " 'Trapezoid',\n",
+       " 'Capitate',\n",
+       " 'Hamate',\n",
+       " 'Scaphoid',\n",
+       " 'Lunate',\n",
+       " 'Triquetrum',\n",
+       " 'Pisiform',\n",
+       " 'Radius',\n",
+       " 'Ulna']"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from utils.class_names import get_classes\n",
+    "get_classes('XRay')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ValueError",
+     "evalue": "need at least one array to concatenate",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[6], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m dataset \u001b[38;5;241m=\u001b[39m \u001b[43mXRayDataset\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m      2\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdata_root\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdata_root\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m      3\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdata_prefix\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdata_prefix\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m      4\u001b[0m \u001b[43m    \u001b[49m\u001b[43mpipeline\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtrain_pipeline\u001b[49m\n\u001b[1;32m      5\u001b[0m \u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/mmsegmentation/mmseg/datasets/xray.py:28\u001b[0m, in \u001b[0;36mXRayDataset.__init__\u001b[0;34m(self, data_root, data_prefix, pipeline)\u001b[0m\n\u001b[1;32m     27\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, data_root, data_prefix, pipeline):\n\u001b[0;32m---> 28\u001b[0m     \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mXRayDataset\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__init__\u001b[39;49m\u001b[43m(\u001b[49m\n\u001b[1;32m     29\u001b[0m \u001b[43m        \u001b[49m\u001b[43mdata_root\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdata_root\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata_prefix\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdata_prefix\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpipeline\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpipeline\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/mmsegmentation/mmseg/datasets/basesegdataset.py:142\u001b[0m, in \u001b[0;36mBaseSegDataset.__init__\u001b[0;34m(self, ann_file, img_suffix, seg_map_suffix, metainfo, data_root, data_prefix, filter_cfg, indices, serialize_data, pipeline, test_mode, lazy_init, max_refetch, ignore_index, reduce_zero_label, backend_args)\u001b[0m\n\u001b[1;32m    140\u001b[0m \u001b[38;5;66;03m# Full initialize the dataset.\u001b[39;00m\n\u001b[1;32m    141\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m lazy_init:\n\u001b[0;32m--> 142\u001b[0m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfull_init\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    144\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m test_mode:\n\u001b[1;32m    145\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_metainfo\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mclasses\u001b[39m\u001b[38;5;124m'\u001b[39m) \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m, \\\n\u001b[1;32m    146\u001b[0m         \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdataset metainfo `classes` should be specified when testing\u001b[39m\u001b[38;5;124m'\u001b[39m\n",
+      "File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/mmengine/dataset/base_dataset.py:307\u001b[0m, in \u001b[0;36mBaseDataset.full_init\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    305\u001b[0m \u001b[38;5;66;03m# serialize data_list\u001b[39;00m\n\u001b[1;32m    306\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mserialize_data:\n\u001b[0;32m--> 307\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdata_bytes, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdata_address \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_serialize_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    309\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_fully_initialized \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n",
+      "File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/mmengine/dataset/base_dataset.py:767\u001b[0m, in \u001b[0;36mBaseDataset._serialize_data\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    765\u001b[0m data_address: np\u001b[38;5;241m.\u001b[39mndarray \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mcumsum(address_list)\n\u001b[1;32m    766\u001b[0m \u001b[38;5;66;03m# TODO Check if np.concatenate is necessary\u001b[39;00m\n\u001b[0;32m--> 767\u001b[0m data_bytes \u001b[38;5;241m=\u001b[39m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconcatenate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata_list\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    768\u001b[0m \u001b[38;5;66;03m# Empty cache for preventing making multiple copies of\u001b[39;00m\n\u001b[1;32m    769\u001b[0m \u001b[38;5;66;03m# `self.data_info` when loading data multi-processes.\u001b[39;00m\n\u001b[1;32m    770\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdata_list\u001b[38;5;241m.\u001b[39mclear()\n",
+      "\u001b[0;31mValueError\u001b[0m: need at least one array to concatenate"
+     ]
+    }
+   ],
+   "source": [
+    "dataset = XRayDataset(\n",
+    "    data_root=data_root,\n",
+    "    data_prefix=data_prefix,\n",
+    "    pipeline=train_pipeline\n",
+    ")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "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.10.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/mmsegmentation/tests/__init__.py b/mmsegmentation/tests/__init__.py
new file mode 100644
index 0000000..ef101fe
--- /dev/null
+++ b/mmsegmentation/tests/__init__.py
@@ -0,0 +1 @@
+# Copyright (c) OpenMMLab. All rights reserved.
diff --git a/mmsegmentation/tests/test_apis/test_inferencer.py b/mmsegmentation/tests/test_apis/test_inferencer.py
new file mode 100644
index 0000000..d8dbce8
--- /dev/null
+++ b/mmsegmentation/tests/test_apis/test_inferencer.py
@@ -0,0 +1,60 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import tempfile
+
+import numpy as np
+import torch
+from mmengine import ConfigDict
+from utils import *  # noqa: F401, F403
+
+from mmseg.apis import MMSegInferencer
+from mmseg.registry import MODELS
+from mmseg.utils import register_all_modules
+
+
+def test_inferencer():
+    register_all_modules()
+
+    visualizer = dict(
+        type='SegLocalVisualizer',
+        vis_backends=[dict(type='LocalVisBackend')],
+        name='visualizer')
+
+    cfg_dict = dict(
+        model=dict(
+            type='InferExampleModel',
+            data_preprocessor=dict(type='SegDataPreProcessor'),
+            backbone=dict(type='InferExampleBackbone'),
+            decode_head=dict(type='InferExampleHead'),
+            test_cfg=dict(mode='whole')),
+        visualizer=visualizer,
+        test_dataloader=dict(
+            dataset=dict(
+                type='ExampleDataset',
+                pipeline=[
+                    dict(type='LoadImageFromFile'),
+                    dict(type='LoadAnnotations'),
+                    dict(type='PackSegInputs')
+                ]), ))
+    cfg = ConfigDict(cfg_dict)
+    model = MODELS.build(cfg.model)
+
+    ckpt = model.state_dict()
+    ckpt_filename = tempfile.mktemp()
+    torch.save(ckpt, ckpt_filename)
+
+    # test initialization
+    infer = MMSegInferencer(cfg, ckpt_filename)
+
+    # test forward
+    img = np.random.randint(0, 256, (4, 4, 3))
+    infer(img)
+
+    imgs = [img, img]
+    infer(imgs)
+    results = infer(imgs, out_dir=tempfile.gettempdir())
+
+    # test results
+    assert 'predictions' in results
+    assert 'visualization' in results
+    assert len(results['predictions']) == 2
+    assert results['predictions'][0].shape == (4, 4)
diff --git a/mmsegmentation/tests/test_apis/test_rs_inferencer.py b/mmsegmentation/tests/test_apis/test_rs_inferencer.py
new file mode 100644
index 0000000..03423d9
--- /dev/null
+++ b/mmsegmentation/tests/test_apis/test_rs_inferencer.py
@@ -0,0 +1,73 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+from unittest import TestCase
+
+import numpy as np
+from mmengine import ConfigDict, init_default_scope
+from utils import *  # noqa: F401, F403
+
+from mmseg.apis import RSImage, RSInferencer
+from mmseg.registry import MODELS
+
+
+class TestRSImage(TestCase):
+
+    def test_read_whole_image(self):
+        init_default_scope('mmseg')
+        img_path = osp.join(
+            osp.dirname(__file__),
+            '../data/pseudo_loveda_dataset/img_dir/0.png')
+        rs_image = RSImage(img_path)
+        window_size = (16, 16)
+        rs_image.create_grids(window_size)
+        image_data = rs_image.read(rs_image.grids[0])
+        self.assertIsNotNone(image_data)
+
+    def test_write_image_data(self):
+        init_default_scope('mmseg')
+        img_path = osp.join(
+            osp.dirname(__file__),
+            '../data/pseudo_loveda_dataset/img_dir/0.png')
+        rs_image = RSImage(img_path)
+        window_size = (16, 16)
+        rs_image.create_grids(window_size)
+        data = np.random.random((16, 16)).astype(np.int8)
+        rs_image.write(data, rs_image.grids[0])
+
+
+class TestRSInferencer(TestCase):
+
+    def test_read_and_inference(self):
+        init_default_scope('mmseg')
+        cfg_dict = dict(
+            model=dict(
+                type='InferExampleModel',
+                data_preprocessor=dict(type='SegDataPreProcessor'),
+                backbone=dict(type='InferExampleBackbone'),
+                decode_head=dict(type='InferExampleHead'),
+                test_cfg=dict(mode='whole')),
+            test_dataloader=dict(
+                dataset=dict(
+                    type='ExampleDataset',
+                    pipeline=[
+                        dict(type='LoadImageFromFile'),
+                        dict(type='LoadAnnotations'),
+                        dict(type='PackSegInputs')
+                    ])),
+            test_pipeline=[
+                dict(type='LoadImageFromFile'),
+                dict(type='LoadAnnotations'),
+                dict(type='PackSegInputs')
+            ])
+        cfg = ConfigDict(cfg_dict)
+        model = MODELS.build(cfg.model)
+        model.cfg = cfg
+        inferencer = RSInferencer.from_model(model)
+
+        img_path = osp.join(
+            osp.dirname(__file__),
+            '../data/pseudo_loveda_dataset/img_dir/0.png')
+        rs_image = RSImage(img_path)
+        window_size = (16, 16)
+        stride = (16, 16)
+        inferencer.run(rs_image, window_size, stride)
diff --git a/mmsegmentation/tests/test_apis/utils.py b/mmsegmentation/tests/test_apis/utils.py
new file mode 100644
index 0000000..0a9928f
--- /dev/null
+++ b/mmsegmentation/tests/test_apis/utils.py
@@ -0,0 +1,38 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch.nn as nn
+
+from mmseg.models import EncoderDecoder
+from mmseg.models.decode_heads.decode_head import BaseDecodeHead
+from mmseg.registry import MODELS
+
+
+@MODELS.register_module(name='InferExampleHead')
+class ExampleDecodeHead(BaseDecodeHead):
+
+    def __init__(self, num_classes=19, out_channels=None):
+        super().__init__(
+            3, 3, num_classes=num_classes, out_channels=out_channels)
+
+    def forward(self, inputs):
+        return self.cls_seg(inputs[0])
+
+
+@MODELS.register_module(name='InferExampleBackbone')
+class ExampleBackbone(nn.Module):
+
+    def __init__(self):
+        super().__init__()
+        self.conv = nn.Conv2d(3, 3, 3)
+
+    def init_weights(self, pretrained=None):
+        pass
+
+    def forward(self, x):
+        return [self.conv(x)]
+
+
+@MODELS.register_module(name='InferExampleModel')
+class ExampleModel(EncoderDecoder):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
diff --git a/mmsegmentation/tests/test_config.py b/mmsegmentation/tests/test_config.py
new file mode 100644
index 0000000..cdd85ff
--- /dev/null
+++ b/mmsegmentation/tests/test_config.py
@@ -0,0 +1,175 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import glob
+import os
+from os.path import dirname, exists, isdir, join, relpath
+
+import numpy as np
+from mmengine import Config
+from mmengine.dataset import Compose
+from mmengine.registry import init_default_scope
+from torch import nn
+
+from mmseg.models import build_segmentor
+
+
+def _get_config_directory():
+    """Find the predefined segmentor config directory."""
+    try:
+        # Assume we are running in the source mmsegmentation repo
+        repo_dpath = dirname(dirname(__file__))
+    except NameError:
+        # For IPython development when this __file__ is not defined
+        import mmseg
+        repo_dpath = dirname(dirname(mmseg.__file__))
+    config_dpath = join(repo_dpath, 'configs')
+    if not exists(config_dpath):
+        raise Exception('Cannot find config path')
+    return config_dpath
+
+
+def test_config_build_segmentor():
+    """Test that all segmentation models defined in the configs can be
+    initialized."""
+    init_default_scope('mmseg')
+    config_dpath = _get_config_directory()
+    print(f'Found config_dpath = {config_dpath!r}')
+
+    config_fpaths = []
+    # one config each sub folder
+    for sub_folder in os.listdir(config_dpath):
+        if isdir(sub_folder):
+            config_fpaths.append(
+                list(glob.glob(join(config_dpath, sub_folder, '*.py')))[0])
+    config_fpaths = [p for p in config_fpaths if p.find('_base_') == -1]
+    config_names = [relpath(p, config_dpath) for p in config_fpaths]
+
+    print(f'Using {len(config_names)} config files')
+
+    for config_fname in config_names:
+        config_fpath = join(config_dpath, config_fname)
+        config_mod = Config.fromfile(config_fpath)
+
+        config_mod.model
+        print(f'Building segmentor, config_fpath = {config_fpath!r}')
+
+        # Remove pretrained keys to allow for testing in an offline environment
+        if 'pretrained' in config_mod.model:
+            config_mod.model['pretrained'] = None
+
+        print(f'building {config_fname}')
+        segmentor = build_segmentor(config_mod.model)
+        assert segmentor is not None
+
+        head_config = config_mod.model['decode_head']
+        _check_decode_head(head_config, segmentor.decode_head)
+
+
+def test_config_data_pipeline():
+    """Test whether the data pipeline is valid and can process corner cases.
+
+    CommandLine:
+        xdoctest -m tests/test_config.py test_config_build_data_pipeline
+    """
+
+    init_default_scope('mmseg')
+    config_dpath = _get_config_directory()
+    print(f'Found config_dpath = {config_dpath!r}')
+
+    import glob
+    config_fpaths = list(glob.glob(join(config_dpath, '**', '*.py')))
+    config_fpaths = [p for p in config_fpaths if p.find('_base_') == -1]
+    config_names = [relpath(p, config_dpath) for p in config_fpaths]
+
+    print(f'Using {len(config_names)} config files')
+
+    for config_fname in config_names:
+        config_fpath = join(config_dpath, config_fname)
+        print(f'Building data pipeline, config_fpath = {config_fpath!r}')
+        config_mod = Config.fromfile(config_fpath)
+
+        # remove loading pipeline
+        load_img_pipeline = config_mod.train_pipeline.pop(0)
+        to_float32 = load_img_pipeline.get('to_float32', False)
+        del config_mod.train_pipeline[0]
+        del config_mod.test_pipeline[0]
+        # remove loading annotation in test pipeline
+        load_anno_idx = -1
+        for i in range(len(config_mod.test_pipeline)):
+            if config_mod.test_pipeline[i].type in ('LoadAnnotations',
+                                                    'LoadDepthAnnotation'):
+                load_anno_idx = i
+        del config_mod.test_pipeline[load_anno_idx]
+
+        train_pipeline = Compose(config_mod.train_pipeline)
+        test_pipeline = Compose(config_mod.test_pipeline)
+
+        img = np.random.randint(0, 255, size=(1024, 2048, 3), dtype=np.uint8)
+        if to_float32:
+            img = img.astype(np.float32)
+        seg = np.random.randint(0, 255, size=(1024, 2048, 1), dtype=np.uint8)
+        depth = np.random.rand(1024, 2048).astype(np.float32)
+
+        results = dict(
+            filename='test_img.png',
+            ori_filename='test_img.png',
+            img=img,
+            img_shape=img.shape,
+            ori_shape=img.shape,
+            gt_seg_map=seg,
+            gt_depth_map=depth)
+        results['seg_fields'] = ['gt_seg_map']
+        _check_concat_cd_input(config_mod, results)
+        print(f'Test training data pipeline: \n{train_pipeline!r}')
+        output_results = train_pipeline(results)
+        assert output_results is not None
+
+        _check_concat_cd_input(config_mod, results)
+        print(f'Test testing data pipeline: \n{test_pipeline!r}')
+        output_results = test_pipeline(results)
+        assert output_results is not None
+
+
+def _check_concat_cd_input(config_mod: Config, results: dict):
+    keys = []
+    pipeline = config_mod.train_pipeline.copy()
+    pipeline.extend(config_mod.test_pipeline)
+    for t in pipeline:
+        keys.append(t.type)
+    if 'ConcatCDInput' in keys:
+        results.update({'img2': results['img']})
+
+
+def _check_decode_head(decode_head_cfg, decode_head):
+    if isinstance(decode_head_cfg, list):
+        assert isinstance(decode_head, nn.ModuleList)
+        assert len(decode_head_cfg) == len(decode_head)
+        num_heads = len(decode_head)
+        for i in range(num_heads):
+            _check_decode_head(decode_head_cfg[i], decode_head[i])
+        return
+    # check consistency between head_config and roi_head
+    assert decode_head_cfg['type'] == decode_head.__class__.__name__
+
+    assert decode_head_cfg['type'] == decode_head.__class__.__name__
+
+    in_channels = decode_head_cfg.in_channels
+    input_transform = decode_head.input_transform
+    assert input_transform in ['resize_concat', 'multiple_select', None]
+    if input_transform is not None:
+        assert isinstance(in_channels, (list, tuple))
+        assert isinstance(decode_head.in_index, (list, tuple))
+        assert len(in_channels) == len(decode_head.in_index)
+    elif input_transform == 'resize_concat':
+        assert sum(in_channels) == decode_head.in_channels
+    else:
+        assert in_channels == decode_head.in_channels
+
+    if decode_head_cfg['type'] == 'PointHead':
+        assert decode_head_cfg.channels+decode_head_cfg.num_classes == \
+               decode_head.fc_seg.in_channels
+        assert decode_head.fc_seg.out_channels == decode_head_cfg.num_classes
+    elif decode_head_cfg['type'] == 'VPDDepthHead':
+        assert decode_head.out_channels == 1
+    else:
+        assert decode_head_cfg.channels == decode_head.conv_seg.in_channels
+        assert decode_head.conv_seg.out_channels == decode_head_cfg.num_classes
diff --git a/mmsegmentation/tests/test_datasets/test_dataset.py b/mmsegmentation/tests/test_datasets/test_dataset.py
new file mode 100644
index 0000000..2904e09
--- /dev/null
+++ b/mmsegmentation/tests/test_datasets/test_dataset.py
@@ -0,0 +1,475 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os
+import os.path as osp
+import tempfile
+
+import pytest
+
+from mmseg.datasets import (ADE20KDataset, BaseSegDataset, BDD100KDataset,
+                            CityscapesDataset, COCOStuffDataset,
+                            DecathlonDataset, DSDLSegDataset, ISPRSDataset,
+                            LIPDataset, LoveDADataset, MapillaryDataset_v1,
+                            MapillaryDataset_v2, NYUDataset, PascalVOCDataset,
+                            PotsdamDataset, REFUGEDataset, SynapseDataset,
+                            iSAIDDataset)
+from mmseg.registry import DATASETS
+from mmseg.utils import get_classes, get_palette
+
+try:
+    from dsdl.dataset import DSDLDataset
+except ImportError:
+    DSDLDataset = None
+
+
+def test_classes():
+    assert list(
+        CityscapesDataset.METAINFO['classes']) == get_classes('cityscapes')
+    assert list(PascalVOCDataset.METAINFO['classes']) == get_classes(
+        'voc') == get_classes('pascal_voc')
+    assert list(ADE20KDataset.METAINFO['classes']) == get_classes(
+        'ade') == get_classes('ade20k')
+    assert list(
+        COCOStuffDataset.METAINFO['classes']) == get_classes('cocostuff')
+    assert list(LoveDADataset.METAINFO['classes']) == get_classes('loveda')
+    assert list(PotsdamDataset.METAINFO['classes']) == get_classes('potsdam')
+    assert list(ISPRSDataset.METAINFO['classes']) == get_classes('vaihingen')
+    assert list(iSAIDDataset.METAINFO['classes']) == get_classes('isaid')
+    assert list(
+        MapillaryDataset_v1.METAINFO['classes']) == get_classes('mapillary_v1')
+    assert list(
+        MapillaryDataset_v2.METAINFO['classes']) == get_classes('mapillary_v2')
+    assert list(BDD100KDataset.METAINFO['classes']) == get_classes('bdd100k')
+    with pytest.raises(ValueError):
+        get_classes('unsupported')
+
+
+def test_classes_file_path():
+    tmp_file = tempfile.NamedTemporaryFile()
+    classes_path = f'{tmp_file.name}.txt'
+    train_pipeline = []
+    kwargs = dict(
+        pipeline=train_pipeline,
+        data_prefix=dict(img_path='./', seg_map_path='./'),
+        metainfo=dict(classes=classes_path))
+
+    # classes.txt with full categories
+    categories = get_classes('cityscapes')
+    with open(classes_path, 'w') as f:
+        f.write('\n'.join(categories))
+    dataset = CityscapesDataset(**kwargs)
+    assert list(dataset.metainfo['classes']) == categories
+    assert dataset.label_map is None
+
+    # classes.txt with sub categories
+    categories = ['road', 'sidewalk', 'building']
+    with open(classes_path, 'w') as f:
+        f.write('\n'.join(categories))
+    dataset = CityscapesDataset(**kwargs)
+    assert list(dataset.metainfo['classes']) == categories
+    assert dataset.label_map is not None
+
+    # classes.txt with unknown categories
+    categories = ['road', 'sidewalk', 'unknown']
+    with open(classes_path, 'w') as f:
+        f.write('\n'.join(categories))
+
+    with pytest.raises(ValueError):
+        CityscapesDataset(**kwargs)
+
+    tmp_file.close()
+    os.remove(classes_path)
+    assert not osp.exists(classes_path)
+
+
+def test_palette():
+    assert CityscapesDataset.METAINFO['palette'] == get_palette('cityscapes')
+    assert PascalVOCDataset.METAINFO['palette'] == get_palette(
+        'voc') == get_palette('pascal_voc')
+    assert ADE20KDataset.METAINFO['palette'] == get_palette(
+        'ade') == get_palette('ade20k')
+    assert LoveDADataset.METAINFO['palette'] == get_palette('loveda')
+    assert PotsdamDataset.METAINFO['palette'] == get_palette('potsdam')
+    assert COCOStuffDataset.METAINFO['palette'] == get_palette('cocostuff')
+    assert iSAIDDataset.METAINFO['palette'] == get_palette('isaid')
+    assert list(
+        MapillaryDataset_v1.METAINFO['palette']) == get_palette('mapillary_v1')
+    assert list(
+        MapillaryDataset_v2.METAINFO['palette']) == get_palette('mapillary_v2')
+    assert list(BDD100KDataset.METAINFO['palette']) == get_palette('bdd100k')
+    with pytest.raises(ValueError):
+        get_palette('unsupported')
+
+
+def test_custom_dataset():
+
+    # with 'img_path' and 'seg_map_path' in data_prefix
+    train_dataset = BaseSegDataset(
+        data_root=osp.join(osp.dirname(__file__), '../data/pseudo_dataset'),
+        data_prefix=dict(
+            img_path='imgs/',
+            seg_map_path='gts/',
+        ),
+        img_suffix='img.jpg',
+        seg_map_suffix='gt.png')
+    assert len(train_dataset) == 5
+
+    # with 'img_path' and 'seg_map_path' in data_prefix and ann_file
+    train_dataset = BaseSegDataset(
+        data_root=osp.join(osp.dirname(__file__), '../data/pseudo_dataset'),
+        data_prefix=dict(
+            img_path='imgs/',
+            seg_map_path='gts/',
+        ),
+        img_suffix='img.jpg',
+        seg_map_suffix='gt.png',
+        ann_file='splits/train.txt')
+    assert len(train_dataset) == 4
+
+    # no data_root
+    train_dataset = BaseSegDataset(
+        data_prefix=dict(
+            img_path=osp.join(
+                osp.dirname(__file__), '../data/pseudo_dataset/imgs'),
+            seg_map_path=osp.join(
+                osp.dirname(__file__), '../data/pseudo_dataset/gts')),
+        img_suffix='img.jpg',
+        seg_map_suffix='gt.png')
+    assert len(train_dataset) == 5
+
+    # with data_root but 'img_path' and 'seg_map_path' in data_prefix are
+    # abs path
+    train_dataset = BaseSegDataset(
+        data_root=osp.join(osp.dirname(__file__), '../data/pseudo_dataset'),
+        data_prefix=dict(
+            img_path=osp.join(
+                osp.dirname(__file__), '../data/pseudo_dataset/imgs'),
+            seg_map_path=osp.join(
+                osp.dirname(__file__), '../data/pseudo_dataset/gts')),
+        img_suffix='img.jpg',
+        seg_map_suffix='gt.png')
+    assert len(train_dataset) == 5
+
+    # test_mode=True
+    test_dataset = BaseSegDataset(
+        data_prefix=dict(
+            img_path=osp.join(
+                osp.dirname(__file__), '../data/pseudo_dataset/imgs')),
+        img_suffix='img.jpg',
+        test_mode=True,
+        metainfo=dict(classes=('pseudo_class', )))
+    assert len(test_dataset) == 5
+
+    # training data get
+    train_data = train_dataset[0]
+    assert isinstance(train_data, dict)
+    assert 'img_path' in train_data and osp.isfile(train_data['img_path'])
+    assert 'seg_map_path' in train_data and osp.isfile(
+        train_data['seg_map_path'])
+
+    # test data get
+    test_data = test_dataset[0]
+    assert isinstance(test_data, dict)
+    assert 'img_path' in train_data and osp.isfile(train_data['img_path'])
+    assert 'seg_map_path' in train_data and osp.isfile(
+        train_data['seg_map_path'])
+
+
+def test_ade():
+    test_dataset = ADE20KDataset(
+        pipeline=[],
+        data_prefix=dict(
+            img_path=osp.join(
+                osp.dirname(__file__), '../data/pseudo_dataset/imgs')))
+    assert len(test_dataset) == 5
+
+
+def test_cityscapes():
+    test_dataset = CityscapesDataset(
+        pipeline=[],
+        data_prefix=dict(
+            img_path=osp.join(
+                osp.dirname(__file__),
+                '../data/pseudo_cityscapes_dataset/leftImg8bit/val'),
+            seg_map_path=osp.join(
+                osp.dirname(__file__),
+                '../data/pseudo_cityscapes_dataset/gtFine/val')))
+    assert len(test_dataset) == 1
+
+
+def test_loveda():
+    test_dataset = LoveDADataset(
+        pipeline=[],
+        data_prefix=dict(
+            img_path=osp.join(
+                osp.dirname(__file__),
+                '../data/pseudo_loveda_dataset/img_dir'),
+            seg_map_path=osp.join(
+                osp.dirname(__file__),
+                '../data/pseudo_loveda_dataset/ann_dir')))
+    assert len(test_dataset) == 3
+
+
+def test_potsdam():
+    test_dataset = PotsdamDataset(
+        pipeline=[],
+        data_prefix=dict(
+            img_path=osp.join(
+                osp.dirname(__file__),
+                '../data/pseudo_potsdam_dataset/img_dir'),
+            seg_map_path=osp.join(
+                osp.dirname(__file__),
+                '../data/pseudo_potsdam_dataset/ann_dir')))
+    assert len(test_dataset) == 1
+
+
+def test_vaihingen():
+    test_dataset = ISPRSDataset(
+        pipeline=[],
+        data_prefix=dict(
+            img_path=osp.join(
+                osp.dirname(__file__),
+                '../data/pseudo_vaihingen_dataset/img_dir'),
+            seg_map_path=osp.join(
+                osp.dirname(__file__),
+                '../data/pseudo_vaihingen_dataset/ann_dir')))
+    assert len(test_dataset) == 1
+
+
+def test_synapse():
+    test_dataset = SynapseDataset(
+        pipeline=[],
+        data_prefix=dict(
+            img_path=osp.join(
+                osp.dirname(__file__),
+                '../data/pseudo_synapse_dataset/img_dir'),
+            seg_map_path=osp.join(
+                osp.dirname(__file__),
+                '../data/pseudo_synapse_dataset/ann_dir')))
+    assert len(test_dataset) == 2
+
+
+def test_refuge():
+    test_dataset = REFUGEDataset(
+        pipeline=[],
+        data_prefix=dict(
+            img_path=osp.join(
+                osp.dirname(__file__),
+                '../data/pseudo_refuge_dataset/img_dir'),
+            seg_map_path=osp.join(
+                osp.dirname(__file__),
+                '../data/pseudo_refuge_dataset/ann_dir')))
+    assert len(test_dataset) == 1
+
+
+def test_isaid():
+    test_dataset = iSAIDDataset(
+        pipeline=[],
+        data_prefix=dict(
+            img_path=osp.join(
+                osp.dirname(__file__), '../data/pseudo_isaid_dataset/img_dir'),
+            seg_map_path=osp.join(
+                osp.dirname(__file__),
+                '../data/pseudo_isaid_dataset/ann_dir')))
+    assert len(test_dataset) == 2
+    test_dataset = iSAIDDataset(
+        data_prefix=dict(
+            img_path=osp.join(
+                osp.dirname(__file__), '../data/pseudo_isaid_dataset/img_dir'),
+            seg_map_path=osp.join(
+                osp.dirname(__file__),
+                '../data/pseudo_isaid_dataset/ann_dir')),
+        ann_file=osp.join(
+            osp.dirname(__file__),
+            '../data/pseudo_isaid_dataset/splits/train.txt'))
+    assert len(test_dataset) == 1
+
+
+def test_decathlon():
+    data_root = osp.join(osp.dirname(__file__), '../data')
+    # test load training dataset
+    test_dataset = DecathlonDataset(
+        pipeline=[], data_root=data_root, ann_file='dataset.json')
+    assert len(test_dataset) == 1
+
+    # test load test dataset
+    test_dataset = DecathlonDataset(
+        pipeline=[],
+        data_root=data_root,
+        ann_file='dataset.json',
+        test_mode=True)
+    assert len(test_dataset) == 3
+
+
+def test_lip():
+    data_root = osp.join(osp.dirname(__file__), '../data/pseudo_lip_dataset')
+    # train load training dataset
+    train_dataset = LIPDataset(
+        pipeline=[],
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='train_images', seg_map_path='train_segmentations'))
+    assert len(train_dataset) == 1
+
+    # test load training dataset
+    test_dataset = LIPDataset(
+        pipeline=[],
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='val_images', seg_map_path='val_segmentations'))
+    assert len(test_dataset) == 1
+
+
+def test_mapillary():
+    test_dataset = MapillaryDataset_v1(
+        pipeline=[],
+        data_prefix=dict(
+            img_path=osp.join(
+                osp.dirname(__file__),
+                '../data/pseudo_mapillary_dataset/images'),
+            seg_map_path=osp.join(
+                osp.dirname(__file__),
+                '../data/pseudo_mapillary_dataset/v1.2')))
+    assert len(test_dataset) == 1
+
+
+def test_bdd100k():
+    test_dataset = BDD100KDataset(
+        pipeline=[],
+        data_prefix=dict(
+            img_path=osp.join(
+                osp.dirname(__file__),
+                '../data/pseudo_bdd100k_dataset/images/10k/val'),
+            seg_map_path=osp.join(
+                osp.dirname(__file__),
+                '../data/pseudo_bdd100k_dataset/labels/sem_seg/masks/val')))
+    assert len(test_dataset) == 3
+
+
+@pytest.mark.parametrize('dataset, classes', [
+    ('ADE20KDataset', ('wall', 'building')),
+    ('CityscapesDataset', ('road', 'sidewalk')),
+    ('BaseSegDataset', ('bus', 'car')),
+    ('PascalVOCDataset', ('aeroplane', 'bicycle')),
+])
+def test_custom_classes_override_default(dataset, classes):
+
+    dataset_class = DATASETS.get(dataset)
+    original_classes = dataset_class.METAINFO.get('classes', None)
+
+    tmp_file = tempfile.NamedTemporaryFile()
+    ann_file = tmp_file.name
+    img_path = tempfile.mkdtemp()
+
+    # Test setting classes as a tuple
+    custom_dataset = dataset_class(
+        data_prefix=dict(img_path=img_path),
+        ann_file=ann_file,
+        metainfo=dict(classes=classes),
+        test_mode=True,
+        lazy_init=True)
+
+    assert custom_dataset.metainfo['classes'] != original_classes
+    assert custom_dataset.metainfo['classes'] == classes
+    if not isinstance(custom_dataset, BaseSegDataset):
+        assert isinstance(custom_dataset.label_map, dict)
+
+    # Test setting classes as a list
+    custom_dataset = dataset_class(
+        data_prefix=dict(img_path=img_path),
+        ann_file=ann_file,
+        metainfo=dict(classes=list(classes)),
+        test_mode=True,
+        lazy_init=True)
+
+    assert custom_dataset.metainfo['classes'] != original_classes
+    assert custom_dataset.metainfo['classes'] == list(classes)
+    if not isinstance(custom_dataset, BaseSegDataset):
+        assert isinstance(custom_dataset.label_map, dict)
+
+    # Test overriding not a subset
+    custom_dataset = dataset_class(
+        ann_file=ann_file,
+        data_prefix=dict(img_path=img_path),
+        metainfo=dict(classes=[classes[0]]),
+        test_mode=True,
+        lazy_init=True)
+
+    assert custom_dataset.metainfo['classes'] != original_classes
+    assert custom_dataset.metainfo['classes'] == [classes[0]]
+    if not isinstance(custom_dataset, BaseSegDataset):
+        assert isinstance(custom_dataset.label_map, dict)
+
+    # Test default behavior
+    if dataset_class is BaseSegDataset:
+        with pytest.raises(AssertionError):
+            custom_dataset = dataset_class(
+                ann_file=ann_file,
+                data_prefix=dict(img_path=img_path),
+                metainfo=None,
+                test_mode=True,
+                lazy_init=True)
+    else:
+        custom_dataset = dataset_class(
+            data_prefix=dict(img_path=img_path),
+            ann_file=ann_file,
+            metainfo=None,
+            test_mode=True,
+            lazy_init=True)
+
+        assert custom_dataset.METAINFO['classes'] == original_classes
+        assert custom_dataset.label_map is None
+
+
+def test_custom_dataset_random_palette_is_generated():
+    dataset = BaseSegDataset(
+        pipeline=[],
+        data_prefix=dict(img_path=tempfile.mkdtemp()),
+        ann_file=tempfile.mkdtemp(),
+        metainfo=dict(classes=('bus', 'car')),
+        lazy_init=True,
+        test_mode=True)
+    assert len(dataset.metainfo['palette']) == 2
+    for class_color in dataset.metainfo['palette']:
+        assert len(class_color) == 3
+        assert all(x >= 0 and x <= 255 for x in class_color)
+
+
+def test_custom_dataset_custom_palette():
+    dataset = BaseSegDataset(
+        data_prefix=dict(img_path=tempfile.mkdtemp()),
+        ann_file=tempfile.mkdtemp(),
+        metainfo=dict(
+            classes=('bus', 'car'), palette=[[100, 100, 100], [200, 200,
+                                                               200]]),
+        lazy_init=True,
+        test_mode=True)
+    assert tuple(dataset.metainfo['palette']) == tuple([[100, 100, 100],
+                                                        [200, 200, 200]])
+    # test custom class and palette don't match
+    with pytest.raises(ValueError):
+        dataset = BaseSegDataset(
+            data_prefix=dict(img_path=tempfile.mkdtemp()),
+            ann_file=tempfile.mkdtemp(),
+            metainfo=dict(classes=('bus', 'car'), palette=[[200, 200, 200]]),
+            lazy_init=True)
+
+
+def test_dsdlseg_dataset():
+    if DSDLDataset is not None:
+        dataset = DSDLSegDataset(
+            data_root='tests/data/dsdl_seg', ann_file='set-train/train.yaml')
+        assert len(dataset) == 3
+        assert len(dataset.metainfo['classes']) == 21
+    else:
+        ImportWarning('Package `dsdl` is not installed.')
+
+
+def test_nyu_dataset():
+    dataset = NYUDataset(
+        data_root='tests/data/pseudo_nyu_dataset',
+        data_prefix=dict(img_path='images', depth_map_path='annotations'),
+    )
+    assert len(dataset) == 1
+    data = dataset[0]
+    assert data.get('depth_map_path', None) is not None
+    assert data.get('category_id', -1) == 26
diff --git a/mmsegmentation/tests/test_datasets/test_dataset_builder.py b/mmsegmentation/tests/test_datasets/test_dataset_builder.py
new file mode 100644
index 0000000..b67b1e7
--- /dev/null
+++ b/mmsegmentation/tests/test_datasets/test_dataset_builder.py
@@ -0,0 +1,152 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+
+from mmengine.dataset import ConcatDataset, RepeatDataset
+from mmengine.registry import init_default_scope
+
+from mmseg.datasets import MultiImageMixDataset
+from mmseg.registry import DATASETS
+
+init_default_scope('mmseg')
+
+
+@DATASETS.register_module()
+class ToyDataset:
+
+    def __init__(self, cnt=0):
+        self.cnt = cnt
+
+    def __item__(self, idx):
+        return idx
+
+    def __len__(self):
+        return 100
+
+
+def test_build_dataset():
+    cfg = dict(type='ToyDataset')
+    dataset = DATASETS.build(cfg)
+    assert isinstance(dataset, ToyDataset)
+    assert dataset.cnt == 0
+    dataset = DATASETS.build(cfg, default_args=dict(cnt=1))
+    assert isinstance(dataset, ToyDataset)
+    assert dataset.cnt == 1
+
+    data_root = osp.join(osp.dirname(__file__), '../data/pseudo_dataset')
+    data_prefix = dict(img_path='imgs/', seg_map_path='gts/')
+
+    # test RepeatDataset
+    cfg = dict(
+        type='BaseSegDataset',
+        pipeline=[],
+        data_root=data_root,
+        data_prefix=data_prefix,
+        serialize_data=False)
+    dataset = DATASETS.build(cfg)
+    dataset_repeat = RepeatDataset(dataset=dataset, times=5)
+    assert isinstance(dataset_repeat, RepeatDataset)
+    assert len(dataset_repeat) == 25
+
+    # test ConcatDataset
+    # We use same dir twice for simplicity
+    # with data_prefix.seg_map_path
+    cfg1 = dict(
+        type='BaseSegDataset',
+        pipeline=[],
+        data_root=data_root,
+        data_prefix=data_prefix,
+        serialize_data=False)
+    cfg2 = dict(
+        type='BaseSegDataset',
+        pipeline=[],
+        data_root=data_root,
+        data_prefix=data_prefix,
+        serialize_data=False)
+    dataset1 = DATASETS.build(cfg1)
+    dataset2 = DATASETS.build(cfg2)
+    dataset_concat = ConcatDataset(datasets=[dataset1, dataset2])
+    assert isinstance(dataset_concat, ConcatDataset)
+    assert len(dataset_concat) == 10
+
+    # test MultiImageMixDataset
+    dataset = MultiImageMixDataset(dataset=dataset_concat, pipeline=[])
+    assert isinstance(dataset, MultiImageMixDataset)
+    assert len(dataset) == 10
+
+    cfg = dict(type='ConcatDataset', datasets=[cfg1, cfg2])
+
+    dataset = MultiImageMixDataset(dataset=cfg, pipeline=[])
+    assert isinstance(dataset, MultiImageMixDataset)
+    assert len(dataset) == 10
+
+    # with data_prefix.seg_map_path, ann_file
+    cfg1 = dict(
+        type='BaseSegDataset',
+        pipeline=[],
+        data_root=data_root,
+        data_prefix=data_prefix,
+        ann_file='splits/train.txt',
+        serialize_data=False)
+    cfg2 = dict(
+        type='BaseSegDataset',
+        pipeline=[],
+        data_root=data_root,
+        data_prefix=data_prefix,
+        ann_file='splits/val.txt',
+        serialize_data=False)
+
+    dataset1 = DATASETS.build(cfg1)
+    dataset2 = DATASETS.build(cfg2)
+    dataset_concat = ConcatDataset(datasets=[dataset1, dataset2])
+    assert isinstance(dataset_concat, ConcatDataset)
+    assert len(dataset_concat) == 5
+
+    # test mode
+    cfg1 = dict(
+        type='BaseSegDataset',
+        pipeline=[],
+        data_root=data_root,
+        data_prefix=dict(img_path='imgs/'),
+        test_mode=True,
+        metainfo=dict(classes=('pseudo_class', )),
+        serialize_data=False)
+    cfg2 = dict(
+        type='BaseSegDataset',
+        pipeline=[],
+        data_root=data_root,
+        data_prefix=dict(img_path='imgs/'),
+        test_mode=True,
+        metainfo=dict(classes=('pseudo_class', )),
+        serialize_data=False)
+
+    dataset1 = DATASETS.build(cfg1)
+    dataset2 = DATASETS.build(cfg2)
+    dataset_concat = ConcatDataset(datasets=[dataset1, dataset2])
+    assert isinstance(dataset_concat, ConcatDataset)
+    assert len(dataset_concat) == 10
+
+    # test mode with ann_files
+    cfg1 = dict(
+        type='BaseSegDataset',
+        pipeline=[],
+        data_root=data_root,
+        data_prefix=dict(img_path='imgs/'),
+        ann_file='splits/val.txt',
+        test_mode=True,
+        metainfo=dict(classes=('pseudo_class', )),
+        serialize_data=False)
+    cfg2 = dict(
+        type='BaseSegDataset',
+        pipeline=[],
+        data_root=data_root,
+        data_prefix=dict(img_path='imgs/'),
+        ann_file='splits/val.txt',
+        test_mode=True,
+        metainfo=dict(classes=('pseudo_class', )),
+        serialize_data=False)
+
+    dataset1 = DATASETS.build(cfg1)
+    dataset2 = DATASETS.build(cfg2)
+    dataset_concat = ConcatDataset(datasets=[dataset1, dataset2])
+    assert isinstance(dataset_concat, ConcatDataset)
+    assert len(dataset_concat) == 2
diff --git a/mmsegmentation/tests/test_datasets/test_formatting.py b/mmsegmentation/tests/test_datasets/test_formatting.py
new file mode 100644
index 0000000..d0e5820
--- /dev/null
+++ b/mmsegmentation/tests/test_datasets/test_formatting.py
@@ -0,0 +1,61 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import os.path as osp
+import unittest
+
+import numpy as np
+import pytest
+from mmengine.structures import BaseDataElement
+
+from mmseg.datasets.transforms import PackSegInputs
+from mmseg.structures import SegDataSample
+
+
+class TestPackSegInputs(unittest.TestCase):
+
+    def setUp(self):
+        """Setup the model and optimizer which are used in every test method.
+
+        TestCase calls functions in this order: setUp() -> testMethod() ->
+        tearDown() -> cleanUp()
+        """
+        data_prefix = osp.join(osp.dirname(__file__), '../../data')
+        img_path = osp.join(data_prefix, 'color.jpg')
+        rng = np.random.RandomState(0)
+        self.results = {
+            'img_path': img_path,
+            'ori_shape': (300, 400),
+            'pad_shape': (600, 800),
+            'img_shape': (600, 800),
+            'scale_factor': 2.0,
+            'flip': False,
+            'flip_direction': 'horizontal',
+            'img_norm_cfg': None,
+            'img': rng.rand(300, 400),
+            'gt_seg_map': rng.rand(300, 400),
+        }
+        self.meta_keys = ('img_path', 'ori_shape', 'img_shape', 'pad_shape',
+                          'scale_factor', 'flip', 'flip_direction')
+
+    def test_transform(self):
+        transform = PackSegInputs(meta_keys=self.meta_keys)
+        results = transform(copy.deepcopy(self.results))
+        self.assertIn('data_samples', results)
+        self.assertIsInstance(results['data_samples'], SegDataSample)
+        self.assertIsInstance(results['data_samples'].gt_sem_seg,
+                              BaseDataElement)
+        self.assertEqual(results['data_samples'].ori_shape,
+                         results['data_samples'].gt_sem_seg.shape)
+        results = copy.deepcopy(self.results)
+        # test dataset shape is not 2D
+        results['gt_seg_map'] = np.random.rand(3, 300, 400)
+        msg = 'the segmentation map is 2D'
+        with pytest.warns(UserWarning, match=msg):
+            results = transform(results)
+        self.assertEqual(results['data_samples'].ori_shape,
+                         results['data_samples'].gt_sem_seg.shape)
+
+    def test_repr(self):
+        transform = PackSegInputs(meta_keys=self.meta_keys)
+        self.assertEqual(
+            repr(transform), f'PackSegInputs(meta_keys={self.meta_keys})')
diff --git a/mmsegmentation/tests/test_datasets/test_loading.py b/mmsegmentation/tests/test_datasets/test_loading.py
new file mode 100644
index 0000000..3eea6e3
--- /dev/null
+++ b/mmsegmentation/tests/test_datasets/test_loading.py
@@ -0,0 +1,295 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import os.path as osp
+import tempfile
+
+import mmcv
+import numpy as np
+from mmcv.transforms import LoadImageFromFile
+
+from mmseg.datasets.transforms import LoadAnnotations  # noqa
+from mmseg.datasets.transforms import (LoadBiomedicalAnnotation,
+                                       LoadBiomedicalData,
+                                       LoadBiomedicalImageFromFile,
+                                       LoadDepthAnnotation,
+                                       LoadImageFromNDArray)
+
+
+class TestLoading:
+
+    @classmethod
+    def setup_class(cls):
+        cls.data_prefix = osp.join(osp.dirname(__file__), '../data')
+
+    def test_load_img(self):
+        results = dict(img_path=osp.join(self.data_prefix, 'color.jpg'))
+        transform = LoadImageFromFile()
+        results = transform(copy.deepcopy(results))
+        assert results['img_path'] == osp.join(self.data_prefix, 'color.jpg')
+        assert results['img'].shape == (288, 512, 3)
+        assert results['img'].dtype == np.uint8
+        assert results['ori_shape'] == results['img'].shape[:2]
+        assert repr(transform) == transform.__class__.__name__ + \
+               "(ignore_empty=False, to_float32=False, color_type='color'," + \
+               " imdecode_backend='cv2', backend_args=None)"
+
+        # to_float32
+        transform = LoadImageFromFile(to_float32=True)
+        results = transform(copy.deepcopy(results))
+        assert results['img'].dtype == np.float32
+
+        # gray image
+        results = dict(img_path=osp.join(self.data_prefix, 'gray.jpg'))
+        transform = LoadImageFromFile()
+        results = transform(copy.deepcopy(results))
+        assert results['img'].shape == (288, 512, 3)
+        assert results['img'].dtype == np.uint8
+
+        transform = LoadImageFromFile(color_type='unchanged')
+        results = transform(copy.deepcopy(results))
+        assert results['img'].shape == (288, 512)
+        assert results['img'].dtype == np.uint8
+
+    def test_load_seg(self):
+        seg_path = osp.join(self.data_prefix, 'seg.png')
+        results = dict(
+            seg_map_path=seg_path, reduce_zero_label=True, seg_fields=[])
+        transform = LoadAnnotations()
+        results = transform(copy.deepcopy(results))
+        assert results['gt_seg_map'].shape == (288, 512)
+        assert results['gt_seg_map'].dtype == np.uint8
+        assert repr(transform) == transform.__class__.__name__ + \
+            "(reduce_zero_label=True, imdecode_backend='pillow', " + \
+            'backend_args=None)'
+
+        # reduce_zero_label
+        transform = LoadAnnotations(reduce_zero_label=True)
+        results = transform(copy.deepcopy(results))
+        assert results['gt_seg_map'].shape == (288, 512)
+        assert results['gt_seg_map'].dtype == np.uint8
+
+    def test_load_seg_custom_classes(self):
+
+        test_img = np.random.rand(10, 10)
+        test_gt = np.zeros_like(test_img)
+        test_gt[2:4, 2:4] = 1
+        test_gt[2:4, 6:8] = 2
+        test_gt[6:8, 2:4] = 3
+        test_gt[6:8, 6:8] = 4
+
+        tmp_dir = tempfile.TemporaryDirectory()
+        img_path = osp.join(tmp_dir.name, 'img.jpg')
+        gt_path = osp.join(tmp_dir.name, 'gt.png')
+
+        mmcv.imwrite(test_img, img_path)
+        mmcv.imwrite(test_gt, gt_path)
+
+        # test only train with label with id 3
+        results = dict(
+            img_path=img_path,
+            seg_map_path=gt_path,
+            label_map={
+                0: 0,
+                1: 0,
+                2: 0,
+                3: 1,
+                4: 0
+            },
+            reduce_zero_label=False,
+            seg_fields=[])
+
+        load_imgs = LoadImageFromFile()
+        results = load_imgs(copy.deepcopy(results))
+
+        load_anns = LoadAnnotations()
+        results = load_anns(copy.deepcopy(results))
+
+        gt_array = results['gt_seg_map']
+
+        true_mask = np.zeros_like(gt_array)
+        true_mask[6:8, 2:4] = 1
+
+        assert results['seg_fields'] == ['gt_seg_map']
+        assert gt_array.shape == (10, 10)
+        assert gt_array.dtype == np.uint8
+        np.testing.assert_array_equal(gt_array, true_mask)
+
+        # test only train with label with id 4 and 3
+        results = dict(
+            img_path=osp.join(self.data_prefix, 'color.jpg'),
+            seg_map_path=gt_path,
+            label_map={
+                0: 0,
+                1: 0,
+                2: 0,
+                3: 2,
+                4: 1
+            },
+            reduce_zero_label=False,
+            seg_fields=[])
+
+        load_imgs = LoadImageFromFile()
+        results = load_imgs(copy.deepcopy(results))
+
+        load_anns = LoadAnnotations()
+        results = load_anns(copy.deepcopy(results))
+
+        gt_array = results['gt_seg_map']
+
+        true_mask = np.zeros_like(gt_array)
+        true_mask[6:8, 2:4] = 2
+        true_mask[6:8, 6:8] = 1
+
+        assert results['seg_fields'] == ['gt_seg_map']
+        assert gt_array.shape == (10, 10)
+        assert gt_array.dtype == np.uint8
+        np.testing.assert_array_equal(gt_array, true_mask)
+
+        # test with removing a class and reducing zero label simultaneously
+        results = dict(
+            img_path=img_path,
+            seg_map_path=gt_path,
+            # since reduce_zero_label is True, there are only 4 real classes.
+            # if the full set of classes is ["A", "B", "C", "D"], the
+            # following label map simulates the dataset option
+            # classes=["A", "C", "D"] which removes class "B".
+            label_map={
+                0: 0,
+                1: 255,  # simulate removing class 1
+                2: 1,
+                3: 2
+            },
+            reduce_zero_label=True,  # reduce zero label
+            seg_fields=[])
+
+        load_imgs = LoadImageFromFile()
+        results = load_imgs(copy.deepcopy(results))
+
+        # reduce zero label
+        load_anns = LoadAnnotations()
+        results = load_anns(copy.deepcopy(results))
+
+        gt_array = results['gt_seg_map']
+
+        true_mask = np.ones_like(gt_array) * 255  # all zeros get mapped to 255
+        true_mask[2:4, 2:4] = 0  # 1s are reduced to class 0 mapped to class 0
+        true_mask[2:4, 6:8] = 255  # 2s are reduced to class 1 which is removed
+        true_mask[6:8, 2:4] = 1  # 3s are reduced to class 2 mapped to class 1
+        true_mask[6:8, 6:8] = 2  # 4s are reduced to class 3 mapped to class 2
+
+        assert results['seg_fields'] == ['gt_seg_map']
+        assert gt_array.shape == (10, 10)
+        assert gt_array.dtype == np.uint8
+        np.testing.assert_array_equal(gt_array, true_mask)
+
+        # test no custom classes
+        results = dict(
+            img_path=img_path,
+            seg_map_path=gt_path,
+            reduce_zero_label=False,
+            seg_fields=[])
+
+        load_imgs = LoadImageFromFile()
+        results = load_imgs(copy.deepcopy(results))
+
+        load_anns = LoadAnnotations()
+        results = load_anns(copy.deepcopy(results))
+
+        gt_array = results['gt_seg_map']
+
+        assert results['seg_fields'] == ['gt_seg_map']
+        assert gt_array.shape == (10, 10)
+        assert gt_array.dtype == np.uint8
+        np.testing.assert_array_equal(gt_array, test_gt)
+
+        tmp_dir.cleanup()
+
+    def test_load_image_from_ndarray(self):
+        results = {'img': np.zeros((256, 256, 3), dtype=np.uint8)}
+        transform = LoadImageFromNDArray()
+        results = transform(results)
+
+        assert results['img'].shape == (256, 256, 3)
+        assert results['img'].dtype == np.uint8
+        assert results['img_shape'] == (256, 256)
+        assert results['ori_shape'] == (256, 256)
+
+        # to_float32
+        transform = LoadImageFromNDArray(to_float32=True)
+        results = transform(copy.deepcopy(results))
+        assert results['img'].dtype == np.float32
+
+        # test repr
+        transform = LoadImageFromNDArray()
+        assert repr(transform) == ('LoadImageFromNDArray('
+                                   'ignore_empty=False, '
+                                   'to_float32=False, '
+                                   "color_type='color', "
+                                   "imdecode_backend='cv2', "
+                                   'backend_args=None)')
+
+    def test_load_biomedical_img(self):
+        results = dict(
+            img_path=osp.join(self.data_prefix, 'biomedical.nii.gz'))
+        transform = LoadBiomedicalImageFromFile()
+        results = transform(copy.deepcopy(results))
+        assert results['img_path'] == osp.join(self.data_prefix,
+                                               'biomedical.nii.gz')
+        assert len(results['img'].shape) == 4
+        assert results['img'].dtype == np.float32
+        assert results['ori_shape'] == results['img'].shape[1:]
+        assert repr(transform) == ('LoadBiomedicalImageFromFile('
+                                   "decode_backend='nifti', "
+                                   'to_xyz=False, '
+                                   'to_float32=True, '
+                                   'backend_args=None)')
+
+    def test_load_biomedical_annotation(self):
+        results = dict(
+            seg_map_path=osp.join(self.data_prefix, 'biomedical_ann.nii.gz'))
+        transform = LoadBiomedicalAnnotation()
+        results = transform(copy.deepcopy(results))
+        assert len(results['gt_seg_map'].shape) == 3
+        assert results['gt_seg_map'].dtype == np.float32
+
+    def test_load_biomedical_data(self):
+        input_results = dict(
+            img_path=osp.join(self.data_prefix, 'biomedical.npy'))
+        transform = LoadBiomedicalData(with_seg=True)
+        results = transform(copy.deepcopy(input_results))
+        assert results['img_path'] == osp.join(self.data_prefix,
+                                               'biomedical.npy')
+        assert results['img'][0].shape == results['gt_seg_map'].shape
+        assert results['img'].dtype == np.float32
+        assert results['ori_shape'] == results['img'].shape[1:]
+        assert repr(transform) == ('LoadBiomedicalData('
+                                   'with_seg=True, '
+                                   "decode_backend='numpy', "
+                                   'to_xyz=False, '
+                                   'backend_args=None)')
+
+        transform = LoadBiomedicalData(with_seg=False)
+        results = transform(copy.deepcopy(input_results))
+        assert len(results['img'].shape) == 4
+        assert results.get('gt_seg_map') is None
+        assert repr(transform) == ('LoadBiomedicalData('
+                                   'with_seg=False, '
+                                   "decode_backend='numpy', "
+                                   'to_xyz=False, '
+                                   'backend_args=None)')
+
+    def test_load_depth_annotation(self):
+        input_results = dict(
+            img_path='tests/data/pseudo_nyu_dataset/images/'
+            'bookstore_0001d_00001.jpg',
+            depth_map_path='tests/data/pseudo_nyu_dataset/'
+            'annotations/bookstore_0001d_00001.png',
+            category_id=-1,
+            seg_fields=[])
+        transform = LoadDepthAnnotation(depth_rescale_factor=0.001)
+        results = transform(input_results)
+        assert 'gt_depth_map' in results
+        assert results['gt_depth_map'].shape[:2] == mmcv.imread(
+            input_results['depth_map_path']).shape[:2]
+        assert results['gt_depth_map'].dtype == np.float32
+        assert 'gt_depth_map' in results['seg_fields']
diff --git a/mmsegmentation/tests/test_datasets/test_transform.py b/mmsegmentation/tests/test_datasets/test_transform.py
new file mode 100644
index 0000000..e73e558
--- /dev/null
+++ b/mmsegmentation/tests/test_datasets/test_transform.py
@@ -0,0 +1,1273 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import os.path as osp
+from unittest import TestCase
+
+import mmcv
+import numpy as np
+import pytest
+from mmengine.registry import init_default_scope
+from PIL import Image
+
+from mmseg.datasets.transforms import *  # noqa
+from mmseg.datasets.transforms import (LoadBiomedicalData,
+                                       LoadBiomedicalImageFromFile,
+                                       PhotoMetricDistortion, RandomCrop,
+                                       RandomDepthMix)
+from mmseg.registry import TRANSFORMS
+
+init_default_scope('mmseg')
+
+
+def test_resize():
+    # Test `Resize`, `RandomResize` and `RandomChoiceResize` from
+    # MMCV transform. Noted: `RandomResize` has args `scales` but
+    # `Resize` and `RandomResize` has args `scale`.
+    transform = dict(type='Resize', scale=(1333, 800), keep_ratio=True)
+    resize_module = TRANSFORMS.build(transform)
+
+    results = dict()
+    # (288, 512, 3)
+    img = mmcv.imread(
+        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
+    results['img'] = img
+    results['img_shape'] = img.shape
+    results['ori_shape'] = img.shape
+    # Set initial values for default meta_keys
+    results['pad_shape'] = img.shape
+    results['scale_factor'] = 1.0
+
+    resized_results = resize_module(results.copy())
+    # img_shape = results['img'].shape[:2] in ``MMCV resize`` function
+    # so right now it is (750, 1333) rather than (750, 1333, 3)
+    assert resized_results['img_shape'] == (750, 1333)
+
+    # test keep_ratio=False
+    transform = dict(
+        type='RandomResize',
+        scale=(1280, 800),
+        ratio_range=(1.0, 1.0),
+        resize_type='Resize',
+        keep_ratio=False)
+    resize_module = TRANSFORMS.build(transform)
+    resized_results = resize_module(results.copy())
+    assert resized_results['img_shape'] == (800, 1280)
+
+    # test `RandomChoiceResize`, which in older mmsegmentation
+    # `Resize` is multiscale_mode='range'
+    transform = dict(type='RandomResize', scale=[(1333, 400), (1333, 1200)])
+    resize_module = TRANSFORMS.build(transform)
+    resized_results = resize_module(results.copy())
+    assert max(resized_results['img_shape'][:2]) <= 1333
+    assert min(resized_results['img_shape'][:2]) >= 400
+    assert min(resized_results['img_shape'][:2]) <= 1200
+
+    # test RandomChoiceResize, which in older mmsegmentation
+    # `Resize` is multiscale_mode='value'
+    transform = dict(
+        type='RandomChoiceResize',
+        scales=[(1333, 800), (1333, 400)],
+        resize_type='Resize',
+        keep_ratio=False)
+    resize_module = TRANSFORMS.build(transform)
+    resized_results = resize_module(results.copy())
+    assert resized_results['img_shape'] in [(800, 1333), (400, 1333)]
+
+    transform = dict(type='Resize', scale_factor=(0.9, 1.1), keep_ratio=True)
+    resize_module = TRANSFORMS.build(transform)
+    resized_results = resize_module(results.copy())
+    assert max(resized_results['img_shape'][:2]) <= 1333 * 1.1
+
+    # test RandomChoiceResize, which `resize_type` is `ResizeShortestEdge`
+    transform = dict(
+        type='RandomChoiceResize',
+        scales=[128, 256, 512],
+        resize_type='ResizeShortestEdge',
+        max_size=1333)
+    resize_module = TRANSFORMS.build(transform)
+    resized_results = resize_module(results.copy())
+    assert resized_results['img_shape'][0] in [128, 256, 512]
+
+    transform = dict(
+        type='RandomChoiceResize',
+        scales=[512],
+        resize_type='ResizeShortestEdge',
+        max_size=512)
+    resize_module = TRANSFORMS.build(transform)
+    resized_results = resize_module(results.copy())
+    assert resized_results['img_shape'][1] == 512
+
+    transform = dict(
+        type='RandomChoiceResize',
+        scales=[(128, 256), (256, 512), (512, 1024)],
+        resize_type='ResizeShortestEdge',
+        max_size=1333)
+    resize_module = TRANSFORMS.build(transform)
+    resized_results = resize_module(results.copy())
+    assert resized_results['img_shape'][0] in [128, 256, 512]
+
+    # test scale=None and scale_factor is tuple.
+    # img shape: (288, 512, 3)
+    transform = dict(
+        type='Resize', scale=None, scale_factor=(0.5, 2.0), keep_ratio=True)
+    resize_module = TRANSFORMS.build(transform)
+    resized_results = resize_module(results.copy())
+    assert int(288 * 0.5) <= resized_results['img_shape'][0] <= 288 * 2.0
+    assert int(512 * 0.5) <= resized_results['img_shape'][1] <= 512 * 2.0
+
+    # test minimum resized image shape is 640
+    transform = dict(type='Resize', scale=(2560, 640), keep_ratio=True)
+    resize_module = TRANSFORMS.build(transform)
+    resized_results = resize_module(results.copy())
+    assert resized_results['img_shape'] == (640, 1138)
+
+    # test minimum resized image shape is 640 when img_scale=(512, 640)
+    # where should define `scale_factor` in MMCV new ``Resize`` function.
+    min_size_ratio = max(640 / img.shape[0], 640 / img.shape[1])
+    transform = dict(
+        type='Resize', scale_factor=min_size_ratio, keep_ratio=True)
+    resize_module = TRANSFORMS.build(transform)
+    resized_results = resize_module(results.copy())
+    assert resized_results['img_shape'] == (640, 1138)
+
+    # test h > w
+    img = np.random.randn(512, 288, 3)
+    results['img'] = img
+    results['img_shape'] = img.shape
+    results['ori_shape'] = img.shape
+    # Set initial values for default meta_keys
+    results['pad_shape'] = img.shape
+    results['scale_factor'] = 1.0
+    min_size_ratio = max(640 / img.shape[0], 640 / img.shape[1])
+    transform = dict(
+        type='Resize',
+        scale=(2560, 640),
+        scale_factor=min_size_ratio,
+        keep_ratio=True)
+    resize_module = TRANSFORMS.build(transform)
+    resized_results = resize_module(results.copy())
+    assert resized_results['img_shape'] == (1138, 640)
+
+
+def test_flip():
+    # test assertion for invalid prob
+    with pytest.raises(AssertionError):
+        transform = dict(type='RandomFlip', prob=1.5)
+        TRANSFORMS.build(transform)
+
+    # test assertion for invalid direction
+    with pytest.raises(AssertionError):
+        transform = dict(type='RandomFlip', prob=1.0, direction='horizonta')
+        TRANSFORMS.build(transform)
+
+    transform = dict(type='RandomFlip', prob=1.0)
+    flip_module = TRANSFORMS.build(transform)
+
+    results = dict()
+    img = mmcv.imread(
+        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
+    original_img = copy.deepcopy(img)
+    seg = np.array(
+        Image.open(osp.join(osp.dirname(__file__), '../data/seg.png')))
+    original_seg = copy.deepcopy(seg)
+    results['img'] = img
+    results['gt_semantic_seg'] = seg
+    results['seg_fields'] = ['gt_semantic_seg']
+    results['img_shape'] = img.shape
+    results['ori_shape'] = img.shape
+    # Set initial values for default meta_keys
+    results['pad_shape'] = img.shape
+    results['scale_factor'] = 1.0
+
+    results = flip_module(results)
+
+    flip_module = TRANSFORMS.build(transform)
+    results = flip_module(results)
+    assert np.equal(original_img, results['img']).all()
+    assert np.equal(original_seg, results['gt_semantic_seg']).all()
+
+    results['gt_depth_map'] = seg
+    results['seg_fields'] = ['gt_depth_map']
+    results = flip_module(results)
+    flip_module = TRANSFORMS.build(transform)
+    results = flip_module(results)
+    assert np.equal(original_img, results['img']).all()
+    assert np.equal(original_seg, results['gt_depth_map']).all()
+
+
+def test_random_rotate_flip():
+    with pytest.raises(AssertionError):
+        transform = dict(type='RandomRotFlip', flip_prob=1.5)
+        TRANSFORMS.build(transform)
+
+    with pytest.raises(AssertionError):
+        transform = dict(type='RandomRotFlip', rotate_prob=1.5)
+        TRANSFORMS.build(transform)
+
+    with pytest.raises(AssertionError):
+        transform = dict(type='RandomRotFlip', degree=[20, 20, 20])
+        TRANSFORMS.build(transform)
+
+    with pytest.raises(AssertionError):
+        transform = dict(type='RandomRotFlip', degree=-20)
+        TRANSFORMS.build(transform)
+
+    transform = dict(
+        type='RandomRotFlip', flip_prob=1.0, rotate_prob=0, degree=20)
+    rot_flip_module = TRANSFORMS.build(transform)
+
+    results = dict()
+    img = mmcv.imread(
+        osp.join(
+            osp.dirname(__file__),
+            '../data/pseudo_synapse_dataset/img_dir/case0005_slice000.jpg'),
+        'color')
+    original_img = copy.deepcopy(img)
+    seg = np.array(
+        Image.open(
+            osp.join(
+                osp.dirname(__file__),
+                '../data/pseudo_synapse_dataset/ann_dir/case0005_slice000.png')
+        ))
+    original_seg = copy.deepcopy(seg)
+    results['img'] = img
+    results['gt_semantic_seg'] = seg
+    results['seg_fields'] = ['gt_semantic_seg']
+    results['img_shape'] = img.shape
+    results['ori_shape'] = img.shape
+    # Set initial values for default meta_keys
+    results['pad_shape'] = img.shape
+    results['scale_factor'] = 1.0
+
+    result_flip = rot_flip_module(results)
+    assert original_img.shape == result_flip['img'].shape
+    assert original_seg.shape == result_flip['gt_semantic_seg'].shape
+
+    transform = dict(
+        type='RandomRotFlip', flip_prob=0, rotate_prob=1.0, degree=20)
+    rot_flip_module = TRANSFORMS.build(transform)
+
+    result_rotate = rot_flip_module(results)
+    assert original_img.shape == result_rotate['img'].shape
+    assert original_seg.shape == result_rotate['gt_semantic_seg'].shape
+
+    assert str(transform) == "{'type': 'RandomRotFlip'," \
+                             " 'flip_prob': 0," \
+                             " 'rotate_prob': 1.0," \
+                             " 'degree': 20}"
+
+
+def test_pad():
+    # test assertion if both size_divisor and size is None
+    with pytest.raises(AssertionError):
+        transform = dict(type='Pad')
+        TRANSFORMS.build(transform)
+
+    transform = dict(type='Pad', size_divisor=32)
+    transform = TRANSFORMS.build(transform)
+    results = dict()
+    img = mmcv.imread(
+        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
+    original_img = copy.deepcopy(img)
+    results['img'] = img
+    results['img_shape'] = img.shape
+    results['ori_shape'] = img.shape
+    # Set initial values for default meta_keys
+    results['pad_shape'] = img.shape
+    results['scale_factor'] = 1.0
+
+    results = transform(results)
+    # original img already divisible by 32
+    assert np.equal(results['img'], original_img).all()
+    img_shape = results['img'].shape
+    assert img_shape[0] % 32 == 0
+    assert img_shape[1] % 32 == 0
+
+
+def test_normalize():
+    img_norm_cfg = dict(
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        to_rgb=True)
+    transform = dict(type='Normalize', **img_norm_cfg)
+    transform = TRANSFORMS.build(transform)
+    results = dict()
+    img = mmcv.imread(
+        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
+    original_img = copy.deepcopy(img)
+    results['img'] = img
+    results['img_shape'] = img.shape
+    results['ori_shape'] = img.shape
+    # Set initial values for default meta_keys
+    results['pad_shape'] = img.shape
+    results['scale_factor'] = 1.0
+
+    results = transform(results)
+
+    mean = np.array(img_norm_cfg['mean'])
+    std = np.array(img_norm_cfg['std'])
+    converted_img = (original_img[..., ::-1] - mean) / std
+    assert np.allclose(results['img'], converted_img)
+
+
+def test_random_crop():
+    # test assertion for invalid random crop
+    with pytest.raises(AssertionError):
+        RandomCrop(crop_size=(-1, 0))
+
+    results = dict()
+    img = mmcv.imread(osp.join('tests/data/color.jpg'), 'color')
+    seg = np.array(Image.open(osp.join('tests/data/seg.png')))
+    results['img'] = img
+    results['gt_semantic_seg'] = seg
+    results['seg_fields'] = ['gt_semantic_seg']
+    results['img_shape'] = img.shape
+    results['ori_shape'] = img.shape
+    # Set initial values for default meta_keys
+    results['pad_shape'] = img.shape
+    results['scale_factor'] = 1.0
+
+    h, w, _ = img.shape
+    pipeline = RandomCrop(crop_size=(h - 20, w - 20))
+
+    results = pipeline(results)
+    assert results['img'].shape[:2] == (h - 20, w - 20)
+    assert results['img_shape'] == (h - 20, w - 20)
+    assert results['gt_semantic_seg'].shape[:2] == (h - 20, w - 20)
+
+
+def test_rgb2gray():
+    # test assertion out_channels should be greater than 0
+    with pytest.raises(AssertionError):
+        transform = dict(type='RGB2Gray', out_channels=-1)
+        TRANSFORMS.build(transform)
+    # test assertion weights should be tuple[float]
+    with pytest.raises(AssertionError):
+        transform = dict(type='RGB2Gray', out_channels=1, weights=1.1)
+        TRANSFORMS.build(transform)
+
+    # test out_channels is None
+    transform = dict(type='RGB2Gray')
+    transform = TRANSFORMS.build(transform)
+
+    assert str(transform) == f'RGB2Gray(' \
+                             f'out_channels={None}, ' \
+                             f'weights={(0.299, 0.587, 0.114)})'
+
+    results = dict()
+    img = mmcv.imread(
+        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
+    h, w, c = img.shape
+    seg = np.array(
+        Image.open(osp.join(osp.dirname(__file__), '../data/seg.png')))
+    results['img'] = img
+    results['gt_semantic_seg'] = seg
+    results['seg_fields'] = ['gt_semantic_seg']
+    results['img_shape'] = img.shape
+    results['ori_shape'] = img.shape
+    # Set initial values for default meta_keys
+    results['pad_shape'] = img.shape
+    results['scale_factor'] = 1.0
+
+    results = transform(results)
+    assert results['img'].shape == (h, w, c)
+    assert results['img_shape'] == (h, w, c)
+    assert results['ori_shape'] == (h, w, c)
+
+    # test out_channels = 2
+    transform = dict(type='RGB2Gray', out_channels=2)
+    transform = TRANSFORMS.build(transform)
+
+    assert str(transform) == f'RGB2Gray(' \
+                             f'out_channels={2}, ' \
+                             f'weights={(0.299, 0.587, 0.114)})'
+
+    results = dict()
+    img = mmcv.imread(
+        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
+    h, w, c = img.shape
+    seg = np.array(
+        Image.open(osp.join(osp.dirname(__file__), '../data/seg.png')))
+    results['img'] = img
+    results['gt_semantic_seg'] = seg
+    results['seg_fields'] = ['gt_semantic_seg']
+    results['img_shape'] = img.shape
+    results['ori_shape'] = img.shape
+    # Set initial values for default meta_keys
+    results['pad_shape'] = img.shape
+    results['scale_factor'] = 1.0
+
+    results = transform(results)
+    assert results['img'].shape == (h, w, 2)
+    assert results['img_shape'] == (h, w, 2)
+
+
+def test_photo_metric_distortion():
+
+    results = dict()
+    img = mmcv.imread(osp.join('tests/data/color.jpg'), 'color')
+    seg = np.array(Image.open(osp.join('tests/data/seg.png')))
+    results['img'] = img
+    results['gt_semantic_seg'] = seg
+    results['seg_fields'] = ['gt_semantic_seg']
+    results['img_shape'] = img.shape
+    results['ori_shape'] = img.shape
+    # Set initial values for default meta_keys
+    results['pad_shape'] = img.shape
+    results['scale_factor'] = 1.0
+
+    pipeline = PhotoMetricDistortion(saturation_range=(1., 1.))
+    results = pipeline(results)
+
+    assert (results['gt_semantic_seg'] == seg).all()
+    assert results['img_shape'] == img.shape
+
+
+def test_rerange():
+    # test assertion if min_value or max_value is illegal
+    with pytest.raises(AssertionError):
+        transform = dict(type='Rerange', min_value=[0], max_value=[255])
+        TRANSFORMS.build(transform)
+
+    # test assertion if min_value >= max_value
+    with pytest.raises(AssertionError):
+        transform = dict(type='Rerange', min_value=1, max_value=1)
+        TRANSFORMS.build(transform)
+
+    # test assertion if img_min_value == img_max_value
+    with pytest.raises(AssertionError):
+        transform = dict(type='Rerange', min_value=0, max_value=1)
+        transform = TRANSFORMS.build(transform)
+        results = dict()
+        results['img'] = np.array([[1, 1], [1, 1]])
+        transform(results)
+
+    img_rerange_cfg = dict()
+    transform = dict(type='Rerange', **img_rerange_cfg)
+    transform = TRANSFORMS.build(transform)
+    results = dict()
+    img = mmcv.imread(
+        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
+    original_img = copy.deepcopy(img)
+    results['img'] = img
+    results['img_shape'] = img.shape
+    results['ori_shape'] = img.shape
+    # Set initial values for default meta_keys
+    results['pad_shape'] = img.shape
+    results['scale_factor'] = 1.0
+
+    results = transform(results)
+
+    min_value = np.min(original_img)
+    max_value = np.max(original_img)
+    converted_img = (original_img - min_value) / (max_value - min_value) * 255
+
+    assert np.allclose(results['img'], converted_img)
+    assert str(transform) == f'Rerange(min_value={0}, max_value={255})'
+
+
+def test_CLAHE():
+    # test assertion if clip_limit is None
+    with pytest.raises(AssertionError):
+        transform = dict(type='CLAHE', clip_limit=None)
+        TRANSFORMS.build(transform)
+
+    # test assertion if tile_grid_size is illegal
+    with pytest.raises(AssertionError):
+        transform = dict(type='CLAHE', tile_grid_size=(8.0, 8.0))
+        TRANSFORMS.build(transform)
+
+    # test assertion if tile_grid_size is illegal
+    with pytest.raises(AssertionError):
+        transform = dict(type='CLAHE', tile_grid_size=(9, 9, 9))
+        TRANSFORMS.build(transform)
+
+    transform = dict(type='CLAHE', clip_limit=2)
+    transform = TRANSFORMS.build(transform)
+    results = dict()
+    img = mmcv.imread(
+        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
+    original_img = copy.deepcopy(img)
+    results['img'] = img
+    results['img_shape'] = img.shape
+    results['ori_shape'] = img.shape
+    # Set initial values for default meta_keys
+    results['pad_shape'] = img.shape
+    results['scale_factor'] = 1.0
+
+    results = transform(results)
+
+    converted_img = np.empty(original_img.shape)
+    for i in range(original_img.shape[2]):
+        converted_img[:, :, i] = mmcv.clahe(
+            np.array(original_img[:, :, i], dtype=np.uint8), 2, (8, 8))
+
+    assert np.allclose(results['img'], converted_img)
+    assert str(transform) == f'CLAHE(clip_limit={2}, tile_grid_size={(8, 8)})'
+
+
+def test_adjust_gamma():
+    # test assertion if gamma <= 0
+    with pytest.raises(AssertionError):
+        transform = dict(type='AdjustGamma', gamma=0)
+        TRANSFORMS.build(transform)
+
+    # test assertion if gamma is list
+    with pytest.raises(AssertionError):
+        transform = dict(type='AdjustGamma', gamma=[1.2])
+        TRANSFORMS.build(transform)
+
+    # test with gamma = 1.2
+    transform = dict(type='AdjustGamma', gamma=1.2)
+    transform = TRANSFORMS.build(transform)
+    results = dict()
+    img = mmcv.imread(
+        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
+    original_img = copy.deepcopy(img)
+    results['img'] = img
+    results['img_shape'] = img.shape
+    results['ori_shape'] = img.shape
+    # Set initial values for default meta_keys
+    results['pad_shape'] = img.shape
+    results['scale_factor'] = 1.0
+
+    results = transform(results)
+
+    inv_gamma = 1.0 / 1.2
+    table = np.array([((i / 255.0)**inv_gamma) * 255
+                      for i in np.arange(0, 256)]).astype('uint8')
+    converted_img = mmcv.lut_transform(
+        np.array(original_img, dtype=np.uint8), table)
+    assert np.allclose(results['img'], converted_img)
+    assert str(transform) == f'AdjustGamma(gamma={1.2})'
+
+
+def test_rotate():
+    # test assertion degree should be tuple[float] or float
+    with pytest.raises(AssertionError):
+        transform = dict(type='RandomRotate', prob=0.5, degree=-10)
+        TRANSFORMS.build(transform)
+    # test assertion degree should be tuple[float] or float
+    with pytest.raises(AssertionError):
+        transform = dict(type='RandomRotate', prob=0.5, degree=(10., 20., 30.))
+        TRANSFORMS.build(transform)
+
+    transform = dict(type='RandomRotate', degree=10., prob=1.)
+    transform = TRANSFORMS.build(transform)
+
+    assert str(transform) == f'RandomRotate(' \
+                             f'prob={1.}, ' \
+                             f'degree=({-10.}, {10.}), ' \
+                             f'pad_val={0}, ' \
+                             f'seg_pad_val={255}, ' \
+                             f'center={None}, ' \
+                             f'auto_bound={False})'
+
+    results = dict()
+    img = mmcv.imread(
+        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
+    h, w, _ = img.shape
+    seg = np.array(
+        Image.open(osp.join(osp.dirname(__file__), '../data/seg.png')))
+    results['img'] = img
+    results['gt_semantic_seg'] = seg
+    results['seg_fields'] = ['gt_semantic_seg']
+    results['img_shape'] = img.shape
+    results['ori_shape'] = img.shape
+    # Set initial values for default meta_keys
+    results['pad_shape'] = img.shape
+    results['scale_factor'] = 1.0
+
+    results = transform(results)
+    assert results['img'].shape[:2] == (h, w)
+
+
+def test_seg_rescale():
+    results = dict()
+    seg = np.array(
+        Image.open(osp.join(osp.dirname(__file__), '../data/seg.png')))
+    results['gt_semantic_seg'] = seg
+    results['seg_fields'] = ['gt_semantic_seg']
+    h, w = seg.shape
+
+    transform = dict(type='SegRescale', scale_factor=1. / 2)
+    rescale_module = TRANSFORMS.build(transform)
+    rescale_results = rescale_module(results.copy())
+    assert rescale_results['gt_semantic_seg'].shape == (h // 2, w // 2)
+
+    transform = dict(type='SegRescale', scale_factor=1)
+    rescale_module = TRANSFORMS.build(transform)
+    rescale_results = rescale_module(results.copy())
+    assert rescale_results['gt_semantic_seg'].shape == (h, w)
+
+
+def test_mosaic():
+    # test prob
+    with pytest.raises(AssertionError):
+        transform = dict(type='RandomMosaic', prob=1.5)
+        TRANSFORMS.build(transform)
+    # test assertion for invalid img_scale
+    with pytest.raises(AssertionError):
+        transform = dict(type='RandomMosaic', prob=1, img_scale=640)
+        TRANSFORMS.build(transform)
+
+    results = dict()
+    img = mmcv.imread(
+        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
+    seg = np.array(
+        Image.open(osp.join(osp.dirname(__file__), '../data/seg.png')))
+
+    results['img'] = img
+    results['gt_semantic_seg'] = seg
+    results['seg_fields'] = ['gt_semantic_seg']
+
+    transform = dict(type='RandomMosaic', prob=1, img_scale=(10, 12))
+    mosaic_module = TRANSFORMS.build(transform)
+    assert 'Mosaic' in repr(mosaic_module)
+
+    # test assertion for invalid mix_results
+    with pytest.raises(AssertionError):
+        mosaic_module(results)
+
+    results['mix_results'] = [copy.deepcopy(results)] * 3
+    results = mosaic_module(results)
+    assert results['img'].shape[:2] == (20, 24)
+
+    results = dict()
+    results['img'] = img[:, :, 0]
+    results['gt_semantic_seg'] = seg
+    results['seg_fields'] = ['gt_semantic_seg']
+
+    transform = dict(type='RandomMosaic', prob=0, img_scale=(10, 12))
+    mosaic_module = TRANSFORMS.build(transform)
+    results['mix_results'] = [copy.deepcopy(results)] * 3
+    results = mosaic_module(results)
+    assert results['img'].shape[:2] == img.shape[:2]
+
+    transform = dict(type='RandomMosaic', prob=1, img_scale=(10, 12))
+    mosaic_module = TRANSFORMS.build(transform)
+    results = mosaic_module(results)
+    assert results['img'].shape[:2] == (20, 24)
+
+    results = dict()
+    results['img'] = np.concatenate((img, img), axis=2)
+    results['gt_semantic_seg'] = seg
+    results['seg_fields'] = ['gt_semantic_seg']
+
+    transform = dict(type='RandomMosaic', prob=1, img_scale=(10, 12))
+    mosaic_module = TRANSFORMS.build(transform)
+    results['mix_results'] = [copy.deepcopy(results)] * 3
+    results = mosaic_module(results)
+    assert results['img'].shape[2] == 6
+
+
+def test_cutout():
+    # test prob
+    with pytest.raises(AssertionError):
+        transform = dict(type='RandomCutOut', prob=1.5, n_holes=1)
+        TRANSFORMS.build(transform)
+    # test n_holes
+    with pytest.raises(AssertionError):
+        transform = dict(
+            type='RandomCutOut', prob=0.5, n_holes=(5, 3), cutout_shape=(8, 8))
+        TRANSFORMS.build(transform)
+    with pytest.raises(AssertionError):
+        transform = dict(
+            type='RandomCutOut',
+            prob=0.5,
+            n_holes=(3, 4, 5),
+            cutout_shape=(8, 8))
+        TRANSFORMS.build(transform)
+    # test cutout_shape and cutout_ratio
+    with pytest.raises(AssertionError):
+        transform = dict(
+            type='RandomCutOut', prob=0.5, n_holes=1, cutout_shape=8)
+        TRANSFORMS.build(transform)
+    with pytest.raises(AssertionError):
+        transform = dict(
+            type='RandomCutOut', prob=0.5, n_holes=1, cutout_ratio=0.2)
+        TRANSFORMS.build(transform)
+    # either of cutout_shape and cutout_ratio should be given
+    with pytest.raises(AssertionError):
+        transform = dict(type='RandomCutOut', prob=0.5, n_holes=1)
+        TRANSFORMS.build(transform)
+    with pytest.raises(AssertionError):
+        transform = dict(
+            type='RandomCutOut',
+            prob=0.5,
+            n_holes=1,
+            cutout_shape=(2, 2),
+            cutout_ratio=(0.4, 0.4))
+        TRANSFORMS.build(transform)
+    # test seg_fill_in
+    with pytest.raises(AssertionError):
+        transform = dict(
+            type='RandomCutOut',
+            prob=0.5,
+            n_holes=1,
+            cutout_shape=(8, 8),
+            seg_fill_in='a')
+        TRANSFORMS.build(transform)
+    with pytest.raises(AssertionError):
+        transform = dict(
+            type='RandomCutOut',
+            prob=0.5,
+            n_holes=1,
+            cutout_shape=(8, 8),
+            seg_fill_in=256)
+        TRANSFORMS.build(transform)
+
+    results = dict()
+    img = mmcv.imread(
+        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
+
+    seg = np.array(
+        Image.open(osp.join(osp.dirname(__file__), '../data/seg.png')))
+
+    results['img'] = img
+    results['gt_semantic_seg'] = seg
+    results['seg_fields'] = ['gt_semantic_seg']
+    results['img_shape'] = img.shape
+    results['ori_shape'] = img.shape
+    results['pad_shape'] = img.shape
+    results['img_fields'] = ['img']
+
+    transform = dict(
+        type='RandomCutOut', prob=1, n_holes=1, cutout_shape=(10, 10))
+    cutout_module = TRANSFORMS.build(transform)
+    assert 'cutout_shape' in repr(cutout_module)
+    cutout_result = cutout_module(copy.deepcopy(results))
+    assert cutout_result['img'].sum() < img.sum()
+
+    transform = dict(
+        type='RandomCutOut', prob=1, n_holes=1, cutout_ratio=(0.8, 0.8))
+    cutout_module = TRANSFORMS.build(transform)
+    assert 'cutout_ratio' in repr(cutout_module)
+    cutout_result = cutout_module(copy.deepcopy(results))
+    assert cutout_result['img'].sum() < img.sum()
+
+    transform = dict(
+        type='RandomCutOut', prob=0, n_holes=1, cutout_ratio=(0.8, 0.8))
+    cutout_module = TRANSFORMS.build(transform)
+    cutout_result = cutout_module(copy.deepcopy(results))
+    assert cutout_result['img'].sum() == img.sum()
+    assert cutout_result['gt_semantic_seg'].sum() == seg.sum()
+
+    transform = dict(
+        type='RandomCutOut',
+        prob=1,
+        n_holes=(2, 4),
+        cutout_shape=[(10, 10), (15, 15)],
+        fill_in=(255, 255, 255),
+        seg_fill_in=None)
+    cutout_module = TRANSFORMS.build(transform)
+    cutout_result = cutout_module(copy.deepcopy(results))
+    assert cutout_result['img'].sum() > img.sum()
+    assert cutout_result['gt_semantic_seg'].sum() == seg.sum()
+
+    transform = dict(
+        type='RandomCutOut',
+        prob=1,
+        n_holes=1,
+        cutout_ratio=(0.8, 0.8),
+        fill_in=(255, 255, 255),
+        seg_fill_in=255)
+    cutout_module = TRANSFORMS.build(transform)
+    cutout_result = cutout_module(copy.deepcopy(results))
+    assert cutout_result['img'].sum() > img.sum()
+    assert cutout_result['gt_semantic_seg'].sum() > seg.sum()
+
+
+def test_resize_to_multiple():
+    transform = dict(type='ResizeToMultiple', size_divisor=32)
+    transform = TRANSFORMS.build(transform)
+
+    img = np.random.randn(213, 232, 3)
+    seg = np.random.randint(0, 19, (213, 232))
+    results = dict()
+    results['img'] = img
+    results['gt_semantic_seg'] = seg
+    results['seg_fields'] = ['gt_semantic_seg']
+    results['img_shape'] = img.shape
+    results['pad_shape'] = img.shape
+
+    results = transform(results)
+    assert results['img'].shape == (224, 256, 3)
+    assert results['gt_semantic_seg'].shape == (224, 256)
+    assert results['img_shape'] == (224, 256)
+
+
+def test_generate_edge():
+    transform = dict(type='GenerateEdge', edge_width=1)
+    transform = TRANSFORMS.build(transform)
+
+    seg_map = np.array([
+        [1, 1, 1, 1, 1],
+        [1, 1, 1, 1, 2],
+        [1, 1, 1, 2, 2],
+        [1, 1, 2, 2, 2],
+        [1, 2, 2, 2, 2],
+        [2, 2, 2, 2, 2],
+    ])
+    results = dict()
+    results['gt_seg_map'] = seg_map
+    results['img_shape'] = seg_map.shape
+
+    results = transform(results)
+    assert np.all(results['gt_edge_map'] == np.array([
+        [0, 0, 0, 1, 0],
+        [0, 0, 1, 1, 1],
+        [0, 1, 1, 1, 0],
+        [1, 1, 1, 0, 0],
+        [1, 1, 0, 0, 0],
+        [1, 0, 0, 0, 0],
+    ]))
+
+
+def test_biomedical3d_random_crop():
+    # test assertion for invalid random crop
+    with pytest.raises(AssertionError):
+        transform = dict(type='BioMedical3DRandomCrop', crop_shape=(-2, -1, 0))
+        transform = TRANSFORMS.build(transform)
+
+    from mmseg.datasets.transforms import (LoadBiomedicalAnnotation,
+                                           LoadBiomedicalImageFromFile)
+    results = dict()
+    results['img_path'] = osp.join(
+        osp.dirname(__file__), '../data', 'biomedical.nii.gz')
+    transform = LoadBiomedicalImageFromFile()
+    results = transform(copy.deepcopy(results))
+
+    results['seg_map_path'] = osp.join(
+        osp.dirname(__file__), '../data', 'biomedical_ann.nii.gz')
+    transform = LoadBiomedicalAnnotation()
+    results = transform(copy.deepcopy(results))
+
+    d, h, w = results['img_shape']
+    transform = dict(
+        type='BioMedical3DRandomCrop',
+        crop_shape=(d - 20, h - 20, w - 20),
+        keep_foreground=True)
+    transform = TRANSFORMS.build(transform)
+    crop_results = transform(results)
+    assert crop_results['img'].shape[1:] == (d - 20, h - 20, w - 20)
+    assert crop_results['img_shape'] == (d - 20, h - 20, w - 20)
+    assert crop_results['gt_seg_map'].shape == (d - 20, h - 20, w - 20)
+
+    transform = dict(
+        type='BioMedical3DRandomCrop',
+        crop_shape=(d - 20, h - 20, w - 20),
+        keep_foreground=False)
+    transform = TRANSFORMS.build(transform)
+    crop_results = transform(results)
+    assert crop_results['img'].shape[1:] == (d - 20, h - 20, w - 20)
+    assert crop_results['img_shape'] == (d - 20, h - 20, w - 20)
+    assert crop_results['gt_seg_map'].shape == (d - 20, h - 20, w - 20)
+
+
+def test_biomedical_gaussian_noise():
+    # test assertion for invalid prob
+    with pytest.raises(AssertionError):
+        transform = dict(type='BioMedicalGaussianNoise', prob=1.5)
+        TRANSFORMS.build(transform)
+
+    # test assertion for invalid std
+    with pytest.raises(AssertionError):
+        transform = dict(
+            type='BioMedicalGaussianNoise', prob=0.2, mean=0.5, std=-0.5)
+        TRANSFORMS.build(transform)
+
+    transform = dict(type='BioMedicalGaussianNoise', prob=1.0)
+    noise_module = TRANSFORMS.build(transform)
+    assert str(noise_module) == 'BioMedicalGaussianNoise'\
+                                '(prob=1.0, ' \
+                                'mean=0.0, ' \
+                                'std=0.1)'
+
+    transform = dict(type='BioMedicalGaussianNoise', prob=1.0)
+    noise_module = TRANSFORMS.build(transform)
+    results = dict(
+        img_path=osp.join(osp.dirname(__file__), '../data/biomedical.nii.gz'))
+    from mmseg.datasets.transforms import LoadBiomedicalImageFromFile
+    transform = LoadBiomedicalImageFromFile()
+    results = transform(copy.deepcopy(results))
+    original_img = copy.deepcopy(results['img'])
+    results = noise_module(results)
+    assert original_img.shape == results['img'].shape
+
+
+def test_biomedical_gaussian_blur():
+    # test assertion for invalid prob
+    with pytest.raises(AssertionError):
+        transform = dict(type='BioMedicalGaussianBlur', prob=-1.5)
+        TRANSFORMS.build(transform)
+    with pytest.raises(AssertionError):
+        transform = dict(
+            type='BioMedicalGaussianBlur', prob=1.0, sigma_range=0.6)
+        smooth_module = TRANSFORMS.build(transform)
+
+    with pytest.raises(AssertionError):
+        transform = dict(
+            type='BioMedicalGaussianBlur', prob=1.0, sigma_range=(0.6))
+        smooth_module = TRANSFORMS.build(transform)
+
+    with pytest.raises(AssertionError):
+        transform = dict(
+            type='BioMedicalGaussianBlur', prob=1.0, sigma_range=(15, 8, 9))
+        TRANSFORMS.build(transform)
+
+    with pytest.raises(AssertionError):
+        transform = dict(
+            type='BioMedicalGaussianBlur', prob=1.0, sigma_range='0.16')
+        TRANSFORMS.build(transform)
+
+    transform = dict(
+        type='BioMedicalGaussianBlur', prob=1.0, sigma_range=(0.7, 0.8))
+    smooth_module = TRANSFORMS.build(transform)
+    assert str(
+        smooth_module
+    ) == 'BioMedicalGaussianBlur(prob=1.0, ' \
+         'prob_per_channel=0.5, '\
+         'sigma_range=(0.7, 0.8), ' \
+         'different_sigma_per_channel=True, '\
+         'different_sigma_per_axis=True)'
+
+    transform = dict(type='BioMedicalGaussianBlur', prob=1.0)
+    smooth_module = TRANSFORMS.build(transform)
+    assert str(
+        smooth_module
+    ) == 'BioMedicalGaussianBlur(prob=1.0, ' \
+         'prob_per_channel=0.5, '\
+         'sigma_range=(0.5, 1.0), ' \
+         'different_sigma_per_channel=True, '\
+         'different_sigma_per_axis=True)'
+
+    results = dict(
+        img_path=osp.join(osp.dirname(__file__), '../data/biomedical.nii.gz'))
+    from mmseg.datasets.transforms import LoadBiomedicalImageFromFile
+    transform = LoadBiomedicalImageFromFile()
+    results = transform(copy.deepcopy(results))
+    original_img = copy.deepcopy(results['img'])
+    results = smooth_module(results)
+    assert original_img.shape == results['img'].shape
+    # the max value in the smoothed image should be less than the original one
+    assert original_img.max() >= results['img'].max()
+    assert original_img.min() <= results['img'].min()
+
+    transform = dict(
+        type='BioMedicalGaussianBlur',
+        prob=1.0,
+        different_sigma_per_axis=False)
+    smooth_module = TRANSFORMS.build(transform)
+
+    results = dict(
+        img_path=osp.join(osp.dirname(__file__), '../data/biomedical.nii.gz'))
+    from mmseg.datasets.transforms import LoadBiomedicalImageFromFile
+    transform = LoadBiomedicalImageFromFile()
+    results = transform(copy.deepcopy(results))
+    original_img = copy.deepcopy(results['img'])
+    results = smooth_module(results)
+    assert original_img.shape == results['img'].shape
+    # the max value in the smoothed image should be less than the original one
+    assert original_img.max() >= results['img'].max()
+    assert original_img.min() <= results['img'].min()
+
+
+def test_BioMedicalRandomGamma():
+
+    with pytest.raises(AssertionError):
+        transform = dict(
+            type='BioMedicalRandomGamma', prob=-1, gamma_range=(0.7, 1.2))
+        TRANSFORMS.build(transform)
+
+    with pytest.raises(AssertionError):
+        transform = dict(
+            type='BioMedicalRandomGamma', prob=1.2, gamma_range=(0.7, 1.2))
+        TRANSFORMS.build(transform)
+
+    with pytest.raises(AssertionError):
+        transform = dict(
+            type='BioMedicalRandomGamma', prob=1.0, gamma_range=(0.7))
+        TRANSFORMS.build(transform)
+
+    with pytest.raises(AssertionError):
+        transform = dict(
+            type='BioMedicalRandomGamma',
+            prob=1.0,
+            gamma_range=(0.7, 0.2, 0.3))
+        TRANSFORMS.build(transform)
+
+    with pytest.raises(AssertionError):
+        transform = dict(
+            type='BioMedicalRandomGamma',
+            prob=1.0,
+            gamma_range=(0.7, 2),
+            invert_image=1)
+        TRANSFORMS.build(transform)
+
+    with pytest.raises(AssertionError):
+        transform = dict(
+            type='BioMedicalRandomGamma',
+            prob=1.0,
+            gamma_range=(0.7, 2),
+            per_channel=1)
+        TRANSFORMS.build(transform)
+
+    with pytest.raises(AssertionError):
+        transform = dict(
+            type='BioMedicalRandomGamma',
+            prob=1.0,
+            gamma_range=(0.7, 2),
+            retain_stats=1)
+        TRANSFORMS.build(transform)
+
+    test_img = 'tests/data/biomedical.nii.gz'
+    results = dict(img_path=test_img)
+    transform = LoadBiomedicalImageFromFile()
+    results = transform(copy.deepcopy(results))
+    origin_img = results['img']
+    transform2 = dict(
+        type='BioMedicalRandomGamma',
+        prob=1.0,
+        gamma_range=(0.7, 2),
+    )
+    transform2 = TRANSFORMS.build(transform2)
+    results = transform2(results)
+    transformed_img = results['img']
+    assert origin_img.shape == transformed_img.shape
+
+
+def test_BioMedical3DPad():
+    # test assertion.
+    with pytest.raises(AssertionError):
+        transform = dict(type='BioMedical3DPad', pad_shape=None)
+        TRANSFORMS.build(transform)
+
+    with pytest.raises(AssertionError):
+        transform = dict(type='BioMedical3DPad', pad_shape=[256, 256])
+        TRANSFORMS.build(transform)
+
+    data_info1 = dict(img=np.random.random((8, 6, 4, 4)))
+
+    transform = dict(type='BioMedical3DPad', pad_shape=(6, 6, 6))
+    transform = TRANSFORMS.build(transform)
+    results = transform(copy.deepcopy(data_info1))
+    assert results['img'].shape[1:] == (6, 6, 6)
+    assert results['pad_shape'] == (6, 6, 6)
+
+    transform = dict(type='BioMedical3DPad', pad_shape=(4, 6, 6))
+    transform = TRANSFORMS.build(transform)
+    results = transform(copy.deepcopy(data_info1))
+    assert results['img'].shape[1:] == (6, 6, 6)
+    assert results['pad_shape'] == (6, 6, 6)
+
+    data_info2 = dict(
+        img=np.random.random((8, 6, 4, 4)),
+        gt_seg_map=np.random.randint(0, 2, (6, 4, 4)))
+
+    transform = dict(type='BioMedical3DPad', pad_shape=(6, 6, 6))
+    transform = TRANSFORMS.build(transform)
+    results = transform(copy.deepcopy(data_info2))
+    assert results['img'].shape[1:] == (6, 6, 6)
+    assert results['gt_seg_map'].shape[1:] == (6, 6, 6)
+    assert results['pad_shape'] == (6, 6, 6)
+
+    transform = dict(type='BioMedical3DPad', pad_shape=(4, 6, 6))
+    transform = TRANSFORMS.build(transform)
+    results = transform(copy.deepcopy(data_info2))
+    assert results['img'].shape[1:] == (6, 6, 6)
+    assert results['gt_seg_map'].shape[1:] == (6, 6, 6)
+    assert results['pad_shape'] == (6, 6, 6)
+
+
+def test_biomedical_3d_flip():
+    # test assertion for invalid prob
+    with pytest.raises(AssertionError):
+        transform = dict(type='BioMedical3DRandomFlip', prob=1.5, axes=(0, 1))
+        transform = TRANSFORMS.build(transform)
+
+    # test assertion for invalid direction
+    with pytest.raises(AssertionError):
+        transform = dict(type='BioMedical3DRandomFlip', prob=1, axes=(0, 1, 3))
+        transform = TRANSFORMS.build(transform)
+
+    # test flip axes are (0, 1, 2)
+    transform = dict(type='BioMedical3DRandomFlip', prob=1, axes=(0, 1, 2))
+    transform = TRANSFORMS.build(transform)
+
+    # test with random 3d data
+    results = dict()
+    results['img_path'] = 'Null'
+    results['img_shape'] = (1, 16, 16, 16)
+    results['img'] = np.random.randn(1, 16, 16, 16)
+    results['gt_seg_map'] = np.random.randint(0, 4, (16, 16, 16))
+
+    original_img = results['img'].copy()
+    original_seg = results['gt_seg_map'].copy()
+
+    # flip first time
+    results = transform(results)
+    with pytest.raises(AssertionError):
+        assert np.equal(original_img, results['img']).all()
+    with pytest.raises(AssertionError):
+        assert np.equal(original_seg, results['gt_seg_map']).all()
+
+    # flip second time
+    results = transform(results)
+    assert np.equal(original_img, results['img']).all()
+    assert np.equal(original_seg, results['gt_seg_map']).all()
+
+    # test with actual data and flip axes are (0, 1)
+    # load biomedical 3d img and seg
+    data_prefix = osp.join(osp.dirname(__file__), '../data')
+    input_results = dict(img_path=osp.join(data_prefix, 'biomedical.npy'))
+    biomedical_loader = LoadBiomedicalData(with_seg=True)
+    data = biomedical_loader(copy.deepcopy(input_results))
+    results = data.copy()
+
+    original_img = data['img'].copy()
+    original_seg = data['gt_seg_map'].copy()
+
+    # test flip axes are (0, 1)
+    transform = dict(type='BioMedical3DRandomFlip', prob=1, axes=(0, 1))
+    transform = TRANSFORMS.build(transform)
+
+    # flip first time
+    results = transform(results)
+    with pytest.raises(AssertionError):
+        assert np.equal(original_img, results['img']).all()
+    with pytest.raises(AssertionError):
+        assert np.equal(original_seg, results['gt_seg_map']).all()
+
+    # flip second time
+    results = transform(results)
+    assert np.equal(original_img, results['img']).all()
+    assert np.equal(original_seg, results['gt_seg_map']).all()
+
+    # test transform with flip axes = (1)
+    transform = dict(type='BioMedical3DRandomFlip', prob=1, axes=(1, ))
+    transform = TRANSFORMS.build(transform)
+    results = data.copy()
+    results = transform(results)
+    results = transform(results)
+    assert np.equal(original_img, results['img']).all()
+    assert np.equal(original_seg, results['gt_seg_map']).all()
+
+    # test transform with swap_label_pairs
+    transform = dict(
+        type='BioMedical3DRandomFlip',
+        prob=1,
+        axes=(1, 2),
+        swap_label_pairs=[(0, 1)])
+    transform = TRANSFORMS.build(transform)
+    results = data.copy()
+    results = transform(results)
+
+    with pytest.raises(AssertionError):
+        assert np.equal(original_seg, results['gt_seg_map']).all()
+
+    # swap twice
+    results = transform(results)
+    assert np.equal(original_img, results['img']).all()
+    assert np.equal(original_seg, results['gt_seg_map']).all()
+
+
+def test_albu_transform():
+    results = dict(
+        img_path=osp.join(osp.dirname(__file__), '../data/color.jpg'))
+
+    # Define simple pipeline
+    load = dict(type='LoadImageFromFile')
+    load = TRANSFORMS.build(load)
+
+    albu_transform = dict(
+        type='Albu', transforms=[dict(type='ChannelShuffle', p=1)])
+    albu_transform = TRANSFORMS.build(albu_transform)
+
+    normalize = dict(type='Normalize', mean=[0] * 3, std=[0] * 3, to_rgb=True)
+    normalize = TRANSFORMS.build(normalize)
+
+    # Execute transforms
+    results = load(results)
+    results = albu_transform(results)
+    results = normalize(results)
+
+    assert results['img'].dtype == np.float32
+
+
+def test_albu_channel_order():
+    results = dict(
+        img_path=osp.join(osp.dirname(__file__), '../data/color.jpg'))
+
+    # Define simple pipeline
+    load = dict(type='LoadImageFromFile')
+    load = TRANSFORMS.build(load)
+
+    # Transform is modifying B channel
+    albu_transform = dict(
+        type='Albu',
+        transforms=[
+            dict(
+                type='RGBShift',
+                r_shift_limit=0,
+                g_shift_limit=0,
+                b_shift_limit=200,
+                p=1)
+        ])
+    albu_transform = TRANSFORMS.build(albu_transform)
+
+    # Execute transforms
+    results_load = load(results)
+    results_albu = albu_transform(results_load)
+
+    # assert only Green and Red channel are not modified
+    np.testing.assert_array_equal(results_albu['img'][..., 1:],
+                                  results_load['img'][..., 1:])
+
+    # assert Blue channel is modified
+    with pytest.raises(AssertionError):
+        np.testing.assert_array_equal(results_albu['img'][..., 0],
+                                      results_load['img'][..., 0])
+
+
+class TestRandomDepthMix(TestCase):
+
+    def setUp(self):
+        self.transform = RandomDepthMix(prob=1.0)
+
+    def test_transform_shape(self):
+        # Create a dummy result dict
+        results = {
+            'img_shape': (10, 10),
+            'img': np.random.rand(10, 10, 3),
+            'gt_depth_map': np.random.rand(10, 10)
+        }
+        transformed = self.transform.transform(results)
+
+        # Check if the shape remains the same
+        self.assertEqual(results['img'].shape, transformed['img'].shape)
+
+    def test_transform_values(self):
+        # Create a dummy result dict
+        results = {
+            'img_shape': (10, 10),
+            'img': np.zeros((10, 10, 3)),
+            'gt_depth_map': np.ones((10, 10))
+        }
+        transformed = self.transform.transform(results)
+
+        # Assuming the transformation modifies a portion of the image,
+        # it shouldn't remain all zeros
+        self.assertFalse(np.all(transformed['img'] == 0))
+
+    def test_invalid_image_dimension(self):
+        # Create a dummy result dict with invalid image dimension
+        results = {
+            'img_shape': (10, 10),
+            'img': np.random.rand(10, 10, 3, 3),
+            'gt_depth_map': np.random.rand(10, 10)
+        }
+
+        # Check if a ValueError is raised for invalid dimension
+        with self.assertRaises(ValueError):
+            self.transform.transform(results)
diff --git a/mmsegmentation/tests/test_datasets/test_tta.py b/mmsegmentation/tests/test_datasets/test_tta.py
new file mode 100644
index 0000000..25b1ecd
--- /dev/null
+++ b/mmsegmentation/tests/test_datasets/test_tta.py
@@ -0,0 +1,131 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+
+import mmcv
+import pytest
+
+from mmseg.datasets.transforms import *  # noqa
+from mmseg.registry import TRANSFORMS
+
+
+def test_multi_scale_flip_aug():
+    # test exception
+    with pytest.raises(TypeError):
+        tta_transform = dict(
+            type='TestTimeAug',
+            transforms=[dict(type='Resize', keep_ratio=False)],
+        )
+        TRANSFORMS.build(tta_transform)
+
+    tta_transform = dict(
+        type='TestTimeAug',
+        transforms=[[
+            dict(type='Resize', scale=scale, keep_ratio=False)
+            for scale in [(256, 256), (512, 512), (1024, 1024)]
+        ], [dict(type='mmseg.PackSegInputs')]])
+    tta_module = TRANSFORMS.build(tta_transform)
+
+    results = dict()
+    # (288, 512, 3)
+    img = mmcv.imread(
+        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
+    results['img'] = img
+    results['ori_shape'] = img.shape
+    results['ori_height'] = img.shape[0]
+    results['ori_width'] = img.shape[1]
+    # Set initial values for default meta_keys
+    results['pad_shape'] = img.shape
+    results['scale_factor'] = 1.0
+
+    tta_results = tta_module(results.copy())
+    assert [img.shape for img in tta_results['inputs']] == [(3, 256, 256),
+                                                            (3, 512, 512),
+                                                            (3, 1024, 1024)]
+
+    tta_transform = dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale=scale, keep_ratio=False)
+                for scale in [(256, 256), (512, 512), (1024, 1024)]
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='mmseg.PackSegInputs')]
+        ])
+    tta_module = TRANSFORMS.build(tta_transform)
+    tta_results: dict = tta_module(results.copy())
+    assert [img.shape for img in tta_results['inputs']] == [(3, 256, 256),
+                                                            (3, 256, 256),
+                                                            (3, 512, 512),
+                                                            (3, 512, 512),
+                                                            (3, 1024, 1024),
+                                                            (3, 1024, 1024)]
+    assert [
+        data_sample.metainfo['flip']
+        for data_sample in tta_results['data_samples']
+    ] == [False, True, False, True, False, True]
+
+    tta_transform = dict(
+        type='TestTimeAug',
+        transforms=[[dict(type='Resize', scale=(512, 512), keep_ratio=False)],
+                    [dict(type='mmseg.PackSegInputs')]])
+    tta_module = TRANSFORMS.build(tta_transform)
+    tta_results = tta_module(results.copy())
+    assert [tta_results['inputs'][0].shape] == [(3, 512, 512)]
+
+    tta_transform = dict(
+        type='TestTimeAug',
+        transforms=[
+            [dict(type='Resize', scale=(512, 512), keep_ratio=False)],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='mmseg.PackSegInputs')]
+        ])
+    tta_module = TRANSFORMS.build(tta_transform)
+    tta_results = tta_module(results.copy())
+    assert [img.shape for img in tta_results['inputs']] == [(3, 512, 512),
+                                                            (3, 512, 512)]
+    assert [
+        data_sample.metainfo['flip']
+        for data_sample in tta_results['data_samples']
+    ] == [False, True]
+
+    tta_transform = dict(
+        type='TestTimeAug',
+        transforms=[[
+            dict(type='Resize', scale_factor=r, keep_ratio=False)
+            for r in [0.5, 1.0, 2.0]
+        ], [dict(type='mmseg.PackSegInputs')]])
+    tta_module = TRANSFORMS.build(tta_transform)
+    tta_results = tta_module(results.copy())
+    assert [img.shape for img in tta_results['inputs']] == [(3, 144, 256),
+                                                            (3, 288, 512),
+                                                            (3, 576, 1024)]
+
+    tta_transform = dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in [0.5, 1.0, 2.0]
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='mmseg.PackSegInputs')]
+        ])
+    tta_module = TRANSFORMS.build(tta_transform)
+    tta_results = tta_module(results.copy())
+    assert [img.shape for img in tta_results['inputs']] == [(3, 144, 256),
+                                                            (3, 144, 256),
+                                                            (3, 288, 512),
+                                                            (3, 288, 512),
+                                                            (3, 576, 1024),
+                                                            (3, 576, 1024)]
+    assert [
+        data_sample.metainfo['flip']
+        for data_sample in tta_results['data_samples']
+    ] == [False, True, False, True, False, True]
diff --git a/mmsegmentation/tests/test_digit_version.py b/mmsegmentation/tests/test_digit_version.py
new file mode 100644
index 0000000..45daf09
--- /dev/null
+++ b/mmsegmentation/tests/test_digit_version.py
@@ -0,0 +1,21 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmseg import digit_version
+
+
+def test_digit_version():
+    assert digit_version('0.2.16') == (0, 2, 16, 0, 0, 0)
+    assert digit_version('1.2.3') == (1, 2, 3, 0, 0, 0)
+    assert digit_version('1.2.3rc0') == (1, 2, 3, 0, -1, 0)
+    assert digit_version('1.2.3rc1') == (1, 2, 3, 0, -1, 1)
+    assert digit_version('1.0rc0') == (1, 0, 0, 0, -1, 0)
+    assert digit_version('1.0') == digit_version('1.0.0')
+    assert digit_version('1.5.0+cuda90_cudnn7.6.3_lms') == digit_version('1.5')
+    assert digit_version('1.0.0dev') < digit_version('1.0.0a')
+    assert digit_version('1.0.0a') < digit_version('1.0.0a1')
+    assert digit_version('1.0.0a') < digit_version('1.0.0b')
+    assert digit_version('1.0.0b') < digit_version('1.0.0rc')
+    assert digit_version('1.0.0rc1') < digit_version('1.0.0')
+    assert digit_version('1.0.0') < digit_version('1.0.0post')
+    assert digit_version('1.0.0post') < digit_version('1.0.0post1')
+    assert digit_version('v1') == (1, 0, 0, 0, 0, 0)
+    assert digit_version('v1.1.5') == (1, 1, 5, 0, 0, 0)
diff --git a/mmsegmentation/tests/test_engine/test_layer_decay_optimizer_constructor.py b/mmsegmentation/tests/test_engine/test_layer_decay_optimizer_constructor.py
new file mode 100644
index 0000000..e7d13db
--- /dev/null
+++ b/mmsegmentation/tests/test_engine/test_layer_decay_optimizer_constructor.py
@@ -0,0 +1,300 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# from copyreg import constructor
+import pytest
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmengine.optim.optimizer import build_optim_wrapper
+from mmengine.registry import init_default_scope
+
+from mmseg.engine.optimizers.layer_decay_optimizer_constructor import \
+    LearningRateDecayOptimizerConstructor
+
+init_default_scope('mmseg')
+
+base_lr = 1
+decay_rate = 2
+base_wd = 0.05
+weight_decay = 0.05
+
+expected_stage_wise_lr_wd_convnext = [{
+    'weight_decay': 0.0,
+    'lr_scale': 128
+}, {
+    'weight_decay': 0.0,
+    'lr_scale': 1
+}, {
+    'weight_decay': 0.05,
+    'lr_scale': 64
+}, {
+    'weight_decay': 0.0,
+    'lr_scale': 64
+}, {
+    'weight_decay': 0.05,
+    'lr_scale': 32
+}, {
+    'weight_decay': 0.0,
+    'lr_scale': 32
+}, {
+    'weight_decay': 0.05,
+    'lr_scale': 16
+}, {
+    'weight_decay': 0.0,
+    'lr_scale': 16
+}, {
+    'weight_decay': 0.05,
+    'lr_scale': 8
+}, {
+    'weight_decay': 0.0,
+    'lr_scale': 8
+}, {
+    'weight_decay': 0.05,
+    'lr_scale': 128
+}, {
+    'weight_decay': 0.05,
+    'lr_scale': 1
+}]
+
+expected_layer_wise_lr_wd_convnext = [{
+    'weight_decay': 0.0,
+    'lr_scale': 128
+}, {
+    'weight_decay': 0.0,
+    'lr_scale': 1
+}, {
+    'weight_decay': 0.05,
+    'lr_scale': 64
+}, {
+    'weight_decay': 0.0,
+    'lr_scale': 64
+}, {
+    'weight_decay': 0.05,
+    'lr_scale': 32
+}, {
+    'weight_decay': 0.0,
+    'lr_scale': 32
+}, {
+    'weight_decay': 0.05,
+    'lr_scale': 16
+}, {
+    'weight_decay': 0.0,
+    'lr_scale': 16
+}, {
+    'weight_decay': 0.05,
+    'lr_scale': 2
+}, {
+    'weight_decay': 0.0,
+    'lr_scale': 2
+}, {
+    'weight_decay': 0.05,
+    'lr_scale': 128
+}, {
+    'weight_decay': 0.05,
+    'lr_scale': 1
+}]
+
+expected_layer_wise_wd_lr_beit = [{
+    'weight_decay': 0.0,
+    'lr_scale': 16
+}, {
+    'weight_decay': 0.05,
+    'lr_scale': 8
+}, {
+    'weight_decay': 0.0,
+    'lr_scale': 8
+}, {
+    'weight_decay': 0.05,
+    'lr_scale': 4
+}, {
+    'weight_decay': 0.0,
+    'lr_scale': 4
+}, {
+    'weight_decay': 0.05,
+    'lr_scale': 2
+}, {
+    'weight_decay': 0.0,
+    'lr_scale': 2
+}, {
+    'weight_decay': 0.05,
+    'lr_scale': 1
+}, {
+    'weight_decay': 0.0,
+    'lr_scale': 1
+}]
+
+
+class ToyConvNeXt(nn.Module):
+
+    def __init__(self):
+        super().__init__()
+        self.stages = nn.ModuleList()
+        for i in range(4):
+            stage = nn.Sequential(ConvModule(3, 4, kernel_size=1, bias=True))
+            self.stages.append(stage)
+        self.norm0 = nn.BatchNorm2d(2)
+
+        # add some variables to meet unit test coverate rate
+        self.cls_token = nn.Parameter(torch.ones(1))
+        self.mask_token = nn.Parameter(torch.ones(1))
+        self.pos_embed = nn.Parameter(torch.ones(1))
+        self.stem_norm = nn.Parameter(torch.ones(1))
+        self.downsample_norm0 = nn.BatchNorm2d(2)
+        self.downsample_norm1 = nn.BatchNorm2d(2)
+        self.downsample_norm2 = nn.BatchNorm2d(2)
+        self.lin = nn.Parameter(torch.ones(1))
+        self.lin.requires_grad = False
+        self.downsample_layers = nn.ModuleList()
+        for _ in range(4):
+            stage = nn.Sequential(nn.Conv2d(3, 4, kernel_size=1, bias=True))
+            self.downsample_layers.append(stage)
+
+
+class ToyBEiT(nn.Module):
+
+    def __init__(self):
+        super().__init__()
+        # add some variables to meet unit test coverate rate
+        self.cls_token = nn.Parameter(torch.ones(1))
+        self.patch_embed = nn.Parameter(torch.ones(1))
+        self.layers = nn.ModuleList()
+        for _ in range(3):
+            layer = nn.Conv2d(3, 3, 1)
+            self.layers.append(layer)
+
+
+class ToyMAE(nn.Module):
+
+    def __init__(self):
+        super().__init__()
+        # add some variables to meet unit test coverate rate
+        self.cls_token = nn.Parameter(torch.ones(1))
+        self.patch_embed = nn.Parameter(torch.ones(1))
+        self.layers = nn.ModuleList()
+        for _ in range(3):
+            layer = nn.Conv2d(3, 3, 1)
+            self.layers.append(layer)
+
+
+class ToySegmentor(nn.Module):
+
+    def __init__(self, backbone):
+        super().__init__()
+        self.backbone = backbone
+        self.decode_head = nn.Conv2d(2, 2, kernel_size=1, groups=2)
+
+
+class PseudoDataParallel(nn.Module):
+
+    def __init__(self, model):
+        super().__init__()
+        self.module = model
+
+
+class ToyViT(nn.Module):
+
+    def __init__(self):
+        super().__init__()
+
+
+def check_optimizer_lr_wd(optimizer, gt_lr_wd):
+    assert isinstance(optimizer, torch.optim.AdamW)
+    assert optimizer.defaults['lr'] == base_lr
+    assert optimizer.defaults['weight_decay'] == base_wd
+    param_groups = optimizer.param_groups
+    print(param_groups)
+    assert len(param_groups) == len(gt_lr_wd)
+    for i, param_dict in enumerate(param_groups):
+        assert param_dict['weight_decay'] == gt_lr_wd[i]['weight_decay']
+        assert param_dict['lr_scale'] == gt_lr_wd[i]['lr_scale']
+        assert param_dict['lr_scale'] == param_dict['lr']
+
+
+def test_learning_rate_decay_optimizer_constructor():
+
+    # Test lr wd for ConvNeXT
+    backbone = ToyConvNeXt()
+    model = PseudoDataParallel(ToySegmentor(backbone))
+    # stagewise decay
+    stagewise_paramwise_cfg = dict(
+        decay_rate=decay_rate, decay_type='stage_wise', num_layers=6)
+    optimizer_cfg = dict(
+        type='AdamW', lr=base_lr, betas=(0.9, 0.999), weight_decay=0.05)
+    optim_wrapper_cfg = dict(
+        type='OptimWrapper',
+        optimizer=optimizer_cfg,
+        paramwise_cfg=stagewise_paramwise_cfg,
+        constructor='LearningRateDecayOptimizerConstructor')
+    optim_wrapper = build_optim_wrapper(model, optim_wrapper_cfg)
+    check_optimizer_lr_wd(optim_wrapper.optimizer,
+                          expected_stage_wise_lr_wd_convnext)
+    # layerwise decay
+    layerwise_paramwise_cfg = dict(
+        decay_rate=decay_rate, decay_type='layer_wise', num_layers=6)
+    optim_wrapper_cfg = dict(
+        type='OptimWrapper',
+        optimizer=optimizer_cfg,
+        paramwise_cfg=layerwise_paramwise_cfg,
+        constructor='LearningRateDecayOptimizerConstructor')
+    optim_wrapper = build_optim_wrapper(model, optim_wrapper_cfg)
+    check_optimizer_lr_wd(optim_wrapper.optimizer,
+                          expected_layer_wise_lr_wd_convnext)
+
+    # Test lr wd for BEiT
+    backbone = ToyBEiT()
+    model = PseudoDataParallel(ToySegmentor(backbone))
+
+    layerwise_paramwise_cfg = dict(
+        decay_rate=decay_rate, decay_type='layer_wise', num_layers=3)
+    optim_wrapper_cfg = dict(
+        type='OptimWrapper',
+        optimizer=optimizer_cfg,
+        paramwise_cfg=layerwise_paramwise_cfg,
+        constructor='LearningRateDecayOptimizerConstructor')
+    optim_wrapper = build_optim_wrapper(model, optim_wrapper_cfg)
+    check_optimizer_lr_wd(optim_wrapper.optimizer,
+                          expected_layer_wise_wd_lr_beit)
+
+    # Test invalidation of lr wd for Vit
+    backbone = ToyViT()
+    model = PseudoDataParallel(ToySegmentor(backbone))
+    with pytest.raises(NotImplementedError):
+        optim_constructor = LearningRateDecayOptimizerConstructor(
+            optim_wrapper_cfg, layerwise_paramwise_cfg)
+        optim_constructor(model)
+    with pytest.raises(NotImplementedError):
+        optim_constructor = LearningRateDecayOptimizerConstructor(
+            optim_wrapper_cfg, stagewise_paramwise_cfg)
+        optim_constructor(model)
+
+    # Test lr wd for MAE
+    backbone = ToyMAE()
+    model = PseudoDataParallel(ToySegmentor(backbone))
+
+    layerwise_paramwise_cfg = dict(
+        decay_rate=decay_rate, decay_type='layer_wise', num_layers=3)
+    optim_wrapper_cfg = dict(
+        type='OptimWrapper',
+        optimizer=optimizer_cfg,
+        paramwise_cfg=layerwise_paramwise_cfg,
+        constructor='LearningRateDecayOptimizerConstructor')
+    optim_wrapper = build_optim_wrapper(model, optim_wrapper_cfg)
+    check_optimizer_lr_wd(optim_wrapper.optimizer,
+                          expected_layer_wise_wd_lr_beit)
+
+
+def test_beit_layer_decay_optimizer_constructor():
+
+    # paramwise_cfg with BEiTExampleModel
+    backbone = ToyBEiT()
+    model = PseudoDataParallel(ToySegmentor(backbone))
+    paramwise_cfg = dict(layer_decay_rate=2, num_layers=3)
+    optim_wrapper_cfg = dict(
+        type='OptimWrapper',
+        constructor='LayerDecayOptimizerConstructor',
+        paramwise_cfg=paramwise_cfg,
+        optimizer=dict(
+            type='AdamW', lr=1, betas=(0.9, 0.999), weight_decay=0.05))
+    optim_wrapper = build_optim_wrapper(model, optim_wrapper_cfg)
+    # optimizer = optim_wrapper_builder(model)
+    check_optimizer_lr_wd(optim_wrapper.optimizer,
+                          expected_layer_wise_wd_lr_beit)
diff --git a/mmsegmentation/tests/test_engine/test_optimizer.py b/mmsegmentation/tests/test_engine/test_optimizer.py
new file mode 100644
index 0000000..af69f5f
--- /dev/null
+++ b/mmsegmentation/tests/test_engine/test_optimizer.py
@@ -0,0 +1,33 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmengine.optim import build_optim_wrapper
+
+
+class ExampleModel(nn.Module):
+
+    def __init__(self):
+        super().__init__()
+        self.param1 = nn.Parameter(torch.ones(1))
+        self.conv1 = nn.Conv2d(3, 4, kernel_size=1, bias=False)
+        self.conv2 = nn.Conv2d(4, 2, kernel_size=1)
+        self.bn = nn.BatchNorm2d(2)
+
+    def forward(self, x):
+        return x
+
+
+base_lr = 0.01
+base_wd = 0.0001
+momentum = 0.9
+
+
+def test_build_optimizer():
+    model = ExampleModel()
+    optim_wrapper_cfg = dict(
+        type='OptimWrapper',
+        optimizer=dict(
+            type='SGD', lr=base_lr, weight_decay=base_wd, momentum=momentum))
+    optim_wrapper = build_optim_wrapper(model, optim_wrapper_cfg)
+    # test whether optimizer is successfully built from parent.
+    assert isinstance(optim_wrapper.optimizer, torch.optim.SGD)
diff --git a/mmsegmentation/tests/test_engine/test_visualization_hook.py b/mmsegmentation/tests/test_engine/test_visualization_hook.py
new file mode 100644
index 0000000..022e27c
--- /dev/null
+++ b/mmsegmentation/tests/test_engine/test_visualization_hook.py
@@ -0,0 +1,64 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from unittest import TestCase
+from unittest.mock import Mock
+
+import torch
+from mmengine.structures import PixelData
+
+from mmseg.engine.hooks import SegVisualizationHook
+from mmseg.structures import SegDataSample
+from mmseg.visualization import SegLocalVisualizer
+
+
+class TestVisualizationHook(TestCase):
+
+    def setUp(self) -> None:
+
+        h = 288
+        w = 512
+        num_class = 2
+
+        SegLocalVisualizer.get_instance('visualizer')
+        SegLocalVisualizer.dataset_meta = dict(
+            classes=('background', 'foreground'),
+            palette=[[120, 120, 120], [6, 230, 230]])
+
+        data_sample = SegDataSample()
+        data_sample.set_metainfo({'img_path': 'tests/data/color.jpg'})
+        self.data_batch = [{'data_sample': data_sample}] * 2
+
+        pred_sem_seg_data = dict(data=torch.randint(0, num_class, (1, h, w)))
+        pred_sem_seg = PixelData(**pred_sem_seg_data)
+        pred_seg_data_sample = SegDataSample()
+        pred_seg_data_sample.set_metainfo({'img_path': 'tests/data/color.jpg'})
+        pred_seg_data_sample.pred_sem_seg = pred_sem_seg
+        self.outputs = [pred_seg_data_sample] * 2
+
+    def test_after_iter(self):
+        runner = Mock()
+        runner.iter = 1
+        hook = SegVisualizationHook(draw=True, interval=1)
+        hook._after_iter(
+            runner, 1, self.data_batch, self.outputs, mode='train')
+        hook._after_iter(runner, 1, self.data_batch, self.outputs, mode='val')
+        hook._after_iter(runner, 1, self.data_batch, self.outputs, mode='test')
+
+    def test_after_val_iter(self):
+        runner = Mock()
+        runner.iter = 2
+        hook = SegVisualizationHook(interval=1)
+        hook.after_val_iter(runner, 1, self.data_batch, self.outputs)
+
+        hook = SegVisualizationHook(draw=True, interval=1)
+        hook.after_val_iter(runner, 1, self.data_batch, self.outputs)
+
+        hook = SegVisualizationHook(
+            draw=True, interval=1, show=True, wait_time=1)
+        hook.after_val_iter(runner, 1, self.data_batch, self.outputs)
+
+    def test_after_test_iter(self):
+        runner = Mock()
+        hook = SegVisualizationHook(draw=True, interval=1)
+        assert hook._test_index == 0
+        hook.after_test_iter(runner, 1, self.data_batch, self.outputs)
+        assert hook._test_index == len(self.outputs)
diff --git a/mmsegmentation/tests/test_evaluation/test_metrics/test_citys_metric.py b/mmsegmentation/tests/test_evaluation/test_metrics/test_citys_metric.py
new file mode 100644
index 0000000..06f956f
--- /dev/null
+++ b/mmsegmentation/tests/test_evaluation/test_metrics/test_citys_metric.py
@@ -0,0 +1,119 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+import shutil
+from unittest import TestCase
+
+import numpy as np
+import pytest
+import torch
+from mmengine.structures import PixelData
+
+from mmseg.evaluation import CityscapesMetric
+from mmseg.structures import SegDataSample
+
+
+class TestCityscapesMetric(TestCase):
+
+    def _demo_mm_inputs(self,
+                        batch_size=1,
+                        image_shapes=(3, 128, 256),
+                        num_classes=5):
+        """Create a superset of inputs needed to run test or train batches.
+
+        Args:
+            batch_size (int): batch size. Default to 2.
+            image_shapes (List[tuple], Optional): image shape.
+                Default to (3, 64, 64)
+            num_classes (int): number of different classes.
+                Default to 5.
+        """
+        if isinstance(image_shapes, list):
+            assert len(image_shapes) == batch_size
+        else:
+            image_shapes = [image_shapes] * batch_size
+
+        packed_inputs = []
+        for idx in range(batch_size):
+            image_shape = image_shapes[idx]
+            _, h, w = image_shape
+
+            data_sample = SegDataSample()
+            gt_semantic_seg = np.random.randint(
+                0, num_classes, (1, h, w), dtype=np.uint8)
+            gt_semantic_seg = torch.LongTensor(gt_semantic_seg)
+            gt_sem_seg_data = dict(data=gt_semantic_seg)
+            data_sample.gt_sem_seg = PixelData(**gt_sem_seg_data)
+            data_sample = data_sample.to_dict()
+            data_sample[
+                'seg_map_path'] = 'tests/data/pseudo_cityscapes_dataset/gtFine/val/frankfurt/frankfurt_000000_000294_gtFine_labelTrainIds.png'  # noqa
+            packed_inputs.append(data_sample)
+
+        return packed_inputs
+
+    def _demo_mm_model_output(self,
+                              batch_size=1,
+                              image_shapes=(3, 128, 256),
+                              num_classes=5):
+        """Create a superset of inputs needed to run test or train batches.
+
+        Args:
+            batch_size (int): batch size. Default to 2.
+            image_shapes (List[tuple], Optional): image shape.
+                Default to (3, 64, 64)
+            num_classes (int): number of different classes.
+                Default to 5.
+        """
+        results_dict = dict()
+        _, h, w = image_shapes
+        seg_logit = torch.randn(batch_size, num_classes, h, w)
+        results_dict['seg_logits'] = seg_logit
+        seg_pred = np.random.randint(
+            0, num_classes, (batch_size, h, w), dtype=np.uint8)
+        seg_pred = torch.LongTensor(seg_pred)
+        results_dict['pred_sem_seg'] = seg_pred
+
+        batch_datasampes = [
+            SegDataSample()
+            for _ in range(results_dict['pred_sem_seg'].shape[0])
+        ]
+        for key, value in results_dict.items():
+            for i in range(value.shape[0]):
+                setattr(batch_datasampes[i], key, PixelData(data=value[i]))
+
+        _predictions = []
+        for pred in batch_datasampes:
+            test_data = pred.to_dict()
+            test_data[
+                'img_path'] = 'tests/data/pseudo_cityscapes_dataset/leftImg8bit/val/frankfurt/frankfurt_000000_000294_leftImg8bit.png'  # noqa
+            _predictions.append(test_data)
+
+        return _predictions
+
+    def test_evaluate(self):
+        """Test using the metric in the same way as Evalutor."""
+
+        data_batch = self._demo_mm_inputs(2)
+        predictions = self._demo_mm_model_output(2)
+        data_samples = [
+            dict(**data, **result)
+            for data, result in zip(data_batch, predictions)
+        ]
+        # test keep_results should be True when format_only is True
+        with pytest.raises(AssertionError):
+            CityscapesMetric(
+                output_dir='tmp', format_only=True, keep_results=False)
+
+        # test evaluate with cityscape metric
+        metric = CityscapesMetric(output_dir='tmp')
+        metric.process(data_batch, data_samples)
+        res = metric.evaluate(2)
+        self.assertIsInstance(res, dict)
+
+        # test format_only
+        metric = CityscapesMetric(
+            output_dir='tmp', format_only=True, keep_results=True)
+        metric.process(data_batch, data_samples)
+        metric.evaluate(2)
+        assert osp.exists('tmp')
+        assert osp.isfile('tmp/frankfurt_000000_000294_leftImg8bit.png')
+        shutil.rmtree('tmp')
diff --git a/mmsegmentation/tests/test_evaluation/test_metrics/test_depth_metric.py b/mmsegmentation/tests/test_evaluation/test_metrics/test_depth_metric.py
new file mode 100644
index 0000000..a172db8
--- /dev/null
+++ b/mmsegmentation/tests/test_evaluation/test_metrics/test_depth_metric.py
@@ -0,0 +1,85 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+import shutil
+from unittest import TestCase
+
+import torch
+from mmengine.structures import PixelData
+
+from mmseg.evaluation import DepthMetric
+from mmseg.structures import SegDataSample
+
+
+class TestDepthMetric(TestCase):
+
+    def _demo_mm_inputs(self,
+                        batch_size=2,
+                        image_shapes=(3, 64, 64),
+                        num_classes=5):
+        """Create a superset of inputs needed to run test or train batches.
+
+        Args:
+            batch_size (int): batch size. Default to 2.
+            image_shapes (List[tuple], Optional): image shape.
+                Default to (3, 64, 64)
+            num_classes (int): number of different classes.
+                Default to 5.
+        """
+        if isinstance(image_shapes, list):
+            assert len(image_shapes) == batch_size
+        else:
+            image_shapes = [image_shapes] * batch_size
+
+        data_samples = []
+        for idx in range(batch_size):
+            image_shape = image_shapes[idx]
+            _, h, w = image_shape
+
+            data_sample = SegDataSample()
+            gt_depth_map = torch.rand((1, h, w)) * 10
+            data_sample.gt_depth_map = PixelData(data=gt_depth_map)
+
+            data_samples.append(data_sample.to_dict())
+
+        return data_samples
+
+    def _demo_mm_model_output(self,
+                              data_samples,
+                              batch_size=2,
+                              image_shapes=(3, 64, 64),
+                              num_classes=5):
+
+        _, h, w = image_shapes
+
+        for data_sample in data_samples:
+            data_sample['pred_depth_map'] = dict(data=torch.randn(1, h, w))
+
+            data_sample[
+                'img_path'] = 'tests/data/pseudo_dataset/imgs/00000_img.jpg'
+        return data_samples
+
+    def test_evaluate(self):
+        """Test using the metric in the same way as Evalutor."""
+
+        data_samples = self._demo_mm_inputs()
+        data_samples = self._demo_mm_model_output(data_samples)
+
+        depth_metric = DepthMetric()
+        depth_metric.process([0] * len(data_samples), data_samples)
+        res = depth_metric.compute_metrics(depth_metric.results)
+        self.assertIsInstance(res, dict)
+
+        # test save depth map file in output_dir
+        depth_metric = DepthMetric(output_dir='tmp')
+        depth_metric.process([0] * len(data_samples), data_samples)
+        assert osp.exists('tmp')
+        assert osp.isfile('tmp/00000_img.png')
+        shutil.rmtree('tmp')
+
+        # test format_only
+        depth_metric = DepthMetric(output_dir='tmp', format_only=True)
+        depth_metric.process([0] * len(data_samples), data_samples)
+        assert depth_metric.results == []
+        assert osp.exists('tmp')
+        assert osp.isfile('tmp/00000_img.png')
+        shutil.rmtree('tmp')
diff --git a/mmsegmentation/tests/test_evaluation/test_metrics/test_iou_metric.py b/mmsegmentation/tests/test_evaluation/test_metrics/test_iou_metric.py
new file mode 100644
index 0000000..7a0e9d5
--- /dev/null
+++ b/mmsegmentation/tests/test_evaluation/test_metrics/test_iou_metric.py
@@ -0,0 +1,104 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+import shutil
+from unittest import TestCase
+
+import numpy as np
+import torch
+from mmengine.structures import PixelData
+
+from mmseg.evaluation import IoUMetric
+from mmseg.structures import SegDataSample
+
+
+class TestIoUMetric(TestCase):
+
+    def _demo_mm_inputs(self,
+                        batch_size=2,
+                        image_shapes=(3, 64, 64),
+                        num_classes=5):
+        """Create a superset of inputs needed to run test or train batches.
+
+        Args:
+            batch_size (int): batch size. Default to 2.
+            image_shapes (List[tuple], Optional): image shape.
+                Default to (3, 64, 64)
+            num_classes (int): number of different classes.
+                Default to 5.
+        """
+        if isinstance(image_shapes, list):
+            assert len(image_shapes) == batch_size
+        else:
+            image_shapes = [image_shapes] * batch_size
+
+        data_samples = []
+        for idx in range(batch_size):
+            image_shape = image_shapes[idx]
+            _, h, w = image_shape
+
+            data_sample = SegDataSample()
+            gt_semantic_seg = np.random.randint(
+                0, num_classes, (1, h, w), dtype=np.uint8)
+            gt_semantic_seg = torch.LongTensor(gt_semantic_seg)
+            gt_sem_seg_data = dict(data=gt_semantic_seg)
+            data_sample.gt_sem_seg = PixelData(**gt_sem_seg_data)
+
+            data_samples.append(data_sample.to_dict())
+
+        return data_samples
+
+    def _demo_mm_model_output(self,
+                              data_samples,
+                              batch_size=2,
+                              image_shapes=(3, 64, 64),
+                              num_classes=5):
+
+        _, h, w = image_shapes
+
+        for data_sample in data_samples:
+            data_sample['seg_logits'] = dict(
+                data=torch.randn(num_classes, h, w))
+            data_sample['pred_sem_seg'] = dict(
+                data=torch.randint(0, num_classes, (1, h, w)))
+            data_sample[
+                'img_path'] = 'tests/data/pseudo_dataset/imgs/00000_img.jpg'
+        return data_samples
+
+    def test_evaluate(self):
+        """Test using the metric in the same way as Evalutor."""
+
+        data_samples = self._demo_mm_inputs()
+        data_samples = self._demo_mm_model_output(data_samples)
+
+        iou_metric = IoUMetric(iou_metrics=['mIoU'])
+        iou_metric.dataset_meta = dict(
+            classes=['wall', 'building', 'sky', 'floor', 'tree'],
+            label_map=dict(),
+            reduce_zero_label=False)
+        iou_metric.process([0] * len(data_samples), data_samples)
+        res = iou_metric.evaluate(2)
+        self.assertIsInstance(res, dict)
+
+        # test save segment file in output_dir
+        iou_metric = IoUMetric(iou_metrics=['mIoU'], output_dir='tmp')
+        iou_metric.dataset_meta = dict(
+            classes=['wall', 'building', 'sky', 'floor', 'tree'],
+            label_map=dict(),
+            reduce_zero_label=False)
+        iou_metric.process([0] * len(data_samples), data_samples)
+        assert osp.exists('tmp')
+        assert osp.isfile('tmp/00000_img.png')
+        shutil.rmtree('tmp')
+
+        # test format_only
+        iou_metric = IoUMetric(
+            iou_metrics=['mIoU'], output_dir='tmp', format_only=True)
+        iou_metric.dataset_meta = dict(
+            classes=['wall', 'building', 'sky', 'floor', 'tree'],
+            label_map=dict(),
+            reduce_zero_label=False)
+        iou_metric.process([0] * len(data_samples), data_samples)
+        assert iou_metric.results == []
+        assert osp.exists('tmp')
+        assert osp.isfile('tmp/00000_img.png')
+        shutil.rmtree('tmp')
diff --git a/mmsegmentation/tests/test_models/__init__.py b/mmsegmentation/tests/test_models/__init__.py
new file mode 100644
index 0000000..ef101fe
--- /dev/null
+++ b/mmsegmentation/tests/test_models/__init__.py
@@ -0,0 +1 @@
+# Copyright (c) OpenMMLab. All rights reserved.
diff --git a/mmsegmentation/tests/test_models/test_assigners/test_hungarian_assigner.py b/mmsegmentation/tests/test_models/test_assigners/test_hungarian_assigner.py
new file mode 100644
index 0000000..2cdb1de
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_assigners/test_hungarian_assigner.py
@@ -0,0 +1,77 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from unittest import TestCase
+
+import torch
+from mmengine.structures import InstanceData
+
+from mmseg.models.assigners import HungarianAssigner
+
+
+class TestHungarianAssigner(TestCase):
+
+    def test_init(self):
+        with self.assertRaises(AssertionError):
+            HungarianAssigner([])
+
+    def test_hungarian_match_assigner(self):
+        assigner = HungarianAssigner([
+            dict(type='ClassificationCost', weight=2.0),
+            dict(type='CrossEntropyLossCost', weight=5.0, use_sigmoid=True),
+            dict(type='DiceCost', weight=5.0, pred_act=True, eps=1.0)
+        ])
+        num_classes = 3
+        num_masks = 10
+        num_points = 20
+        gt_instances = InstanceData()
+        gt_instances.labels = torch.randint(0, num_classes, (num_classes, ))
+        gt_instances.masks = torch.randint(0, 2, (num_classes, num_points))
+        pred_instances = InstanceData()
+        pred_instances.scores = torch.rand((num_masks, num_classes))
+        pred_instances.masks = torch.rand((num_masks, num_points))
+
+        matched_quiery_inds, matched_label_inds = \
+            assigner.assign(pred_instances, gt_instances)
+        unique_quiery_inds = torch.unique(matched_quiery_inds)
+        unique_label_inds = torch.unique(matched_label_inds)
+        self.assertTrue(len(unique_quiery_inds) == len(matched_quiery_inds))
+        self.assertTrue(
+            torch.equal(unique_label_inds, torch.arange(0, num_classes)))
+
+    def test_cls_match_cost(self):
+        num_classes = 3
+        num_masks = 10
+        gt_instances = InstanceData()
+        gt_instances.labels = torch.randint(0, num_classes, (num_classes, ))
+        pred_instances = InstanceData()
+        pred_instances.scores = torch.rand((num_masks, num_classes))
+
+        # test ClassificationCost
+        assigner = HungarianAssigner(dict(type='ClassificationCost'))
+        matched_quiery_inds, matched_label_inds = \
+            assigner.assign(pred_instances, gt_instances)
+        unique_quiery_inds = torch.unique(matched_quiery_inds)
+        unique_label_inds = torch.unique(matched_label_inds)
+        self.assertTrue(len(unique_quiery_inds) == len(matched_quiery_inds))
+        self.assertTrue(
+            torch.equal(unique_label_inds, torch.arange(0, num_classes)))
+
+    def test_mask_match_cost(self):
+        num_classes = 3
+        num_masks = 10
+        num_points = 20
+        gt_instances = InstanceData()
+        gt_instances.masks = torch.randint(0, 2, (num_classes, num_points))
+        pred_instances = InstanceData()
+        pred_instances.masks = torch.rand((num_masks, num_points))
+
+        # test DiceCost
+        assigner = HungarianAssigner(
+            dict(type='DiceCost', pred_act=True, eps=1.0))
+        assign_result = assigner.assign(pred_instances, gt_instances)
+        self.assertTrue(len(assign_result[0]) == len(assign_result[1]))
+
+        # test CrossEntropyLossCost
+        assigner = HungarianAssigner(
+            dict(type='CrossEntropyLossCost', use_sigmoid=True))
+        assign_result = assigner.assign(pred_instances, gt_instances)
+        self.assertTrue(len(assign_result[0]) == len(assign_result[1]))
diff --git a/mmsegmentation/tests/test_models/test_backbones/__init__.py b/mmsegmentation/tests/test_models/test_backbones/__init__.py
new file mode 100644
index 0000000..ef101fe
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/__init__.py
@@ -0,0 +1 @@
+# Copyright (c) OpenMMLab. All rights reserved.
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_beit.py b/mmsegmentation/tests/test_models/test_backbones/test_beit.py
new file mode 100644
index 0000000..59a12c5
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_beit.py
@@ -0,0 +1,185 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.backbones.beit import BEiT
+from .utils import check_norm_state
+
+
+def test_beit_backbone():
+    with pytest.raises(TypeError):
+        # pretrained must be a string path
+        model = BEiT()
+        model.init_weights(pretrained=0)
+
+    with pytest.raises(TypeError):
+        # img_size must be int or tuple
+        model = BEiT(img_size=512.0)
+
+    with pytest.raises(TypeError):
+        # out_indices must be int ,list or tuple
+        model = BEiT(out_indices=1.)
+
+    with pytest.raises(AssertionError):
+        # The length of img_size tuple must be lower than 3.
+        BEiT(img_size=(224, 224, 224))
+
+    with pytest.raises(TypeError):
+        # Pretrained must be None or Str.
+        BEiT(pretrained=123)
+
+    # Test img_size isinstance tuple
+    imgs = torch.randn(1, 3, 224, 224)
+    model = BEiT(img_size=(224, ))
+    model.init_weights()
+    model(imgs)
+
+    # Test img_size isinstance tuple
+    imgs = torch.randn(1, 3, 224, 224)
+    model = BEiT(img_size=(224, 224))
+    model(imgs)
+
+    # Test norm_eval = True
+    model = BEiT(norm_eval=True)
+    model.train()
+
+    # Test BEiT backbone with input size of 224 and patch size of 16
+    model = BEiT()
+    model.init_weights()
+    model.train()
+
+    # Test  qv_bias
+    model = BEiT(qv_bias=False)
+    model.train()
+
+    # Test out_indices = list
+    model = BEiT(out_indices=[2, 4, 8, 12])
+    model.train()
+
+    assert check_norm_state(model.modules(), True)
+
+    # Test image size = (224, 224)
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 14, 14)
+
+    # Test BEiT backbone with input size of 256 and patch size of 16
+    model = BEiT(img_size=(256, 256))
+    model.init_weights()
+    model.train()
+    imgs = torch.randn(1, 3, 256, 256)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 16, 16)
+
+    # Test BEiT backbone with input size of 32 and patch size of 16
+    model = BEiT(img_size=(32, 32))
+    model.init_weights()
+    model.train()
+    imgs = torch.randn(1, 3, 32, 32)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 2, 2)
+
+    # Test unbalanced size input image
+    model = BEiT(img_size=(112, 224))
+    model.init_weights()
+    model.train()
+    imgs = torch.randn(1, 3, 112, 224)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 7, 14)
+
+    # Test irregular input image
+    model = BEiT(img_size=(234, 345))
+    model.init_weights()
+    model.train()
+    imgs = torch.randn(1, 3, 234, 345)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 14, 21)
+
+    # Test init_values=0
+    model = BEiT(init_values=0)
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 14, 14)
+
+    # Test final norm
+    model = BEiT(final_norm=True)
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 14, 14)
+
+    # Test patch norm
+    model = BEiT(patch_norm=True)
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 14, 14)
+
+
+def test_beit_init():
+    path = 'PATH_THAT_DO_NOT_EXIST'
+    # Test all combinations of pretrained and init_cfg
+    # pretrained=None, init_cfg=None
+    model = BEiT(pretrained=None, init_cfg=None)
+    assert model.init_cfg is None
+    model.init_weights()
+
+    # pretrained=None
+    # init_cfg loads pretrain from an non-existent file
+    model = BEiT(
+        pretrained=None, init_cfg=dict(type='Pretrained', checkpoint=path))
+    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
+    # Test loading a checkpoint from an non-existent file
+    with pytest.raises(OSError):
+        model.init_weights()
+
+    # test resize_rel_pos_embed
+    value = torch.randn(732, 16)
+    ckpt = {
+        'state_dict': {
+            'layers.0.attn.relative_position_index': 0,
+            'layers.0.attn.relative_position_bias_table': value
+        }
+    }
+    model = BEiT(img_size=(512, 512))
+    # If scipy is installed, this AttributeError would not be raised.
+    from mmengine.utils import is_installed
+    if not is_installed('scipy'):
+        with pytest.raises(AttributeError):
+            model.resize_rel_pos_embed(ckpt)
+
+    # pretrained=None
+    # init_cfg=123, whose type is unsupported
+    model = BEiT(pretrained=None, init_cfg=123)
+    with pytest.raises(TypeError):
+        model.init_weights()
+
+    # pretrained loads pretrain from an non-existent file
+    # init_cfg=None
+    model = BEiT(pretrained=path, init_cfg=None)
+    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
+    # Test loading a checkpoint from an non-existent file
+    with pytest.raises(OSError):
+        model.init_weights()
+
+    # pretrained loads pretrain from an non-existent file
+    # init_cfg loads pretrain from an non-existent file
+    with pytest.raises(AssertionError):
+        model = BEiT(
+            pretrained=path, init_cfg=dict(type='Pretrained', checkpoint=path))
+    with pytest.raises(AssertionError):
+        model = BEiT(pretrained=path, init_cfg=123)
+
+    # pretrain=123, whose type is unsupported
+    # init_cfg=None
+    with pytest.raises(TypeError):
+        model = BEiT(pretrained=123, init_cfg=None)
+
+    # pretrain=123, whose type is unsupported
+    # init_cfg loads pretrain from an non-existent file
+    with pytest.raises(AssertionError):
+        model = BEiT(
+            pretrained=123, init_cfg=dict(type='Pretrained', checkpoint=path))
+
+    # pretrain=123, whose type is unsupported
+    # init_cfg=123, whose type is unsupported
+    with pytest.raises(AssertionError):
+        model = BEiT(pretrained=123, init_cfg=123)
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_bisenetv1.py b/mmsegmentation/tests/test_models/test_backbones/test_bisenetv1.py
new file mode 100644
index 0000000..c067749
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_bisenetv1.py
@@ -0,0 +1,109 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.backbones import BiSeNetV1
+from mmseg.models.backbones.bisenetv1 import (AttentionRefinementModule,
+                                              ContextPath, FeatureFusionModule,
+                                              SpatialPath)
+
+
+def test_bisenetv1_backbone():
+    # Test BiSeNetV1 Standard Forward
+    backbone_cfg = dict(
+        type='ResNet',
+        in_channels=3,
+        depth=18,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 1, 1),
+        strides=(1, 2, 2, 2),
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True)
+    model = BiSeNetV1(in_channels=3, backbone_cfg=backbone_cfg)
+    model.init_weights()
+    model.train()
+    batch_size = 2
+    imgs = torch.randn(batch_size, 3, 64, 128)
+    feat = model(imgs)
+
+    assert len(feat) == 3
+    # output for segment Head
+    assert feat[0].shape == torch.Size([batch_size, 256, 8, 16])
+    # for auxiliary head 1
+    assert feat[1].shape == torch.Size([batch_size, 128, 8, 16])
+    # for auxiliary head 2
+    assert feat[2].shape == torch.Size([batch_size, 128, 4, 8])
+
+    # Test input with rare shape
+    batch_size = 2
+    imgs = torch.randn(batch_size, 3, 95, 27)
+    feat = model(imgs)
+    assert len(feat) == 3
+
+    with pytest.raises(AssertionError):
+        # BiSeNetV1 spatial path channel constraints.
+        BiSeNetV1(
+            backbone_cfg=backbone_cfg,
+            in_channels=3,
+            spatial_channels=(16, 16, 16))
+
+    with pytest.raises(AssertionError):
+        # BiSeNetV1 context path constraints.
+        BiSeNetV1(
+            backbone_cfg=backbone_cfg,
+            in_channels=3,
+            context_channels=(16, 32, 64, 128))
+
+
+def test_bisenetv1_spatial_path():
+    with pytest.raises(AssertionError):
+        # BiSeNetV1 spatial path channel constraints.
+        SpatialPath(num_channels=(16, 16, 16), in_channels=3)
+
+
+def test_bisenetv1_context_path():
+    backbone_cfg = dict(
+        type='ResNet',
+        in_channels=3,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 1, 1),
+        strides=(1, 2, 2, 2),
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True)
+
+    with pytest.raises(AssertionError):
+        # BiSeNetV1 context path constraints.
+        ContextPath(
+            backbone_cfg=backbone_cfg, context_channels=(16, 32, 64, 128))
+
+
+def test_bisenetv1_attention_refinement_module():
+    x_arm = AttentionRefinementModule(32, 8)
+    assert x_arm.conv_layer.in_channels == 32
+    assert x_arm.conv_layer.out_channels == 8
+    assert x_arm.conv_layer.kernel_size == (3, 3)
+    x = torch.randn(2, 32, 8, 16)
+    x_out = x_arm(x)
+    assert x_out.shape == torch.Size([2, 8, 8, 16])
+
+
+def test_bisenetv1_feature_fusion_module():
+    ffm = FeatureFusionModule(16, 32)
+    assert ffm.conv1.in_channels == 16
+    assert ffm.conv1.out_channels == 32
+    assert ffm.conv1.kernel_size == (1, 1)
+    assert ffm.gap.output_size == (1, 1)
+    assert ffm.conv_atten[0].in_channels == 32
+    assert ffm.conv_atten[0].out_channels == 32
+    assert ffm.conv_atten[0].kernel_size == (1, 1)
+
+    ffm = FeatureFusionModule(16, 16)
+    x1 = torch.randn(2, 8, 8, 16)
+    x2 = torch.randn(2, 8, 8, 16)
+    x_out = ffm(x1, x2)
+    assert x_out.shape == torch.Size([2, 16, 8, 16])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_bisenetv2.py b/mmsegmentation/tests/test_models/test_backbones/test_bisenetv2.py
new file mode 100644
index 0000000..cf2dfb3
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_bisenetv2.py
@@ -0,0 +1,57 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from mmcv.cnn import ConvModule
+
+from mmseg.models.backbones import BiSeNetV2
+from mmseg.models.backbones.bisenetv2 import (BGALayer, DetailBranch,
+                                              SemanticBranch)
+
+
+def test_bisenetv2_backbone():
+    # Test BiSeNetV2 Standard Forward
+    model = BiSeNetV2()
+    model.init_weights()
+    model.train()
+    batch_size = 2
+    imgs = torch.randn(batch_size, 3, 128, 256)
+    feat = model(imgs)
+
+    assert len(feat) == 5
+    # output for segment Head
+    assert feat[0].shape == torch.Size([batch_size, 128, 16, 32])
+    # for auxiliary head 1
+    assert feat[1].shape == torch.Size([batch_size, 16, 32, 64])
+    # for auxiliary head 2
+    assert feat[2].shape == torch.Size([batch_size, 32, 16, 32])
+    # for auxiliary head 3
+    assert feat[3].shape == torch.Size([batch_size, 64, 8, 16])
+    # for auxiliary head 4
+    assert feat[4].shape == torch.Size([batch_size, 128, 4, 8])
+
+    # Test input with rare shape
+    batch_size = 2
+    imgs = torch.randn(batch_size, 3, 95, 27)
+    feat = model(imgs)
+    assert len(feat) == 5
+
+
+def test_bisenetv2_DetailBranch():
+    x = torch.randn(1, 3, 32, 64)
+    detail_branch = DetailBranch(detail_channels=(64, 16, 32))
+    assert isinstance(detail_branch.detail_branch[0][0], ConvModule)
+    x_out = detail_branch(x)
+    assert x_out.shape == torch.Size([1, 32, 4, 8])
+
+
+def test_bisenetv2_SemanticBranch():
+    semantic_branch = SemanticBranch(semantic_channels=(16, 32, 64, 128))
+    assert semantic_branch.stage1.pool.stride == 2
+
+
+def test_bisenetv2_BGALayer():
+    x_a = torch.randn(1, 8, 8, 16)
+    x_b = torch.randn(1, 8, 2, 4)
+    bga = BGALayer(out_channels=8)
+    assert isinstance(bga.conv, ConvModule)
+    x_out = bga(x_a, x_b)
+    assert x_out.shape == torch.Size([1, 8, 8, 16])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_blocks.py b/mmsegmentation/tests/test_models/test_backbones/test_blocks.py
new file mode 100644
index 0000000..7a65d27
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_blocks.py
@@ -0,0 +1,187 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import mmcv
+import pytest
+import torch
+from mmengine.utils import digit_version
+from mmengine.utils.dl_utils import TORCH_VERSION
+
+from mmseg.models.utils import (InvertedResidual, InvertedResidualV3, SELayer,
+                                make_divisible)
+
+
+def test_make_divisible():
+    # test with min_value = None
+    assert make_divisible(10, 4) == 12
+    assert make_divisible(9, 4) == 12
+    assert make_divisible(1, 4) == 4
+
+    # test with min_value = 8
+    assert make_divisible(10, 4, 8) == 12
+    assert make_divisible(9, 4, 8) == 12
+    assert make_divisible(1, 4, 8) == 8
+
+
+def test_inv_residual():
+    with pytest.raises(AssertionError):
+        # test stride assertion.
+        InvertedResidual(32, 32, 3, 4)
+
+    # test default config with res connection.
+    # set expand_ratio = 4, stride = 1 and inp=oup.
+    inv_module = InvertedResidual(32, 32, 1, 4)
+    assert inv_module.use_res_connect
+    assert inv_module.conv[0].kernel_size == (1, 1)
+    assert inv_module.conv[0].padding == 0
+    assert inv_module.conv[1].kernel_size == (3, 3)
+    assert inv_module.conv[1].padding == 1
+    assert inv_module.conv[0].with_norm
+    assert inv_module.conv[1].with_norm
+    x = torch.rand(1, 32, 64, 64)
+    output = inv_module(x)
+    assert output.shape == (1, 32, 64, 64)
+
+    # test inv_residual module without res connection.
+    # set expand_ratio = 4, stride = 2.
+    inv_module = InvertedResidual(32, 32, 2, 4)
+    assert not inv_module.use_res_connect
+    assert inv_module.conv[0].kernel_size == (1, 1)
+    x = torch.rand(1, 32, 64, 64)
+    output = inv_module(x)
+    assert output.shape == (1, 32, 32, 32)
+
+    # test expand_ratio == 1
+    inv_module = InvertedResidual(32, 32, 1, 1)
+    assert inv_module.conv[0].kernel_size == (3, 3)
+    x = torch.rand(1, 32, 64, 64)
+    output = inv_module(x)
+    assert output.shape == (1, 32, 64, 64)
+
+    # test with checkpoint forward
+    inv_module = InvertedResidual(32, 32, 1, 1, with_cp=True)
+    assert inv_module.with_cp
+    x = torch.rand(1, 32, 64, 64, requires_grad=True)
+    output = inv_module(x)
+    assert output.shape == (1, 32, 64, 64)
+
+
+def test_inv_residualv3():
+    with pytest.raises(AssertionError):
+        # test stride assertion.
+        InvertedResidualV3(32, 32, 16, stride=3)
+
+    with pytest.raises(AssertionError):
+        # test assertion.
+        InvertedResidualV3(32, 32, 16, with_expand_conv=False)
+
+    # test with se_cfg=None, with_expand_conv=False
+    inv_module = InvertedResidualV3(32, 32, 32, with_expand_conv=False)
+
+    assert inv_module.with_res_shortcut is True
+    assert inv_module.with_se is False
+    assert inv_module.with_expand_conv is False
+    assert not hasattr(inv_module, 'expand_conv')
+    assert isinstance(inv_module.depthwise_conv.conv, torch.nn.Conv2d)
+    assert inv_module.depthwise_conv.conv.kernel_size == (3, 3)
+    assert inv_module.depthwise_conv.conv.stride == (1, 1)
+    assert inv_module.depthwise_conv.conv.padding == (1, 1)
+    assert isinstance(inv_module.depthwise_conv.bn, torch.nn.BatchNorm2d)
+    assert isinstance(inv_module.depthwise_conv.activate, torch.nn.ReLU)
+    assert inv_module.linear_conv.conv.kernel_size == (1, 1)
+    assert inv_module.linear_conv.conv.stride == (1, 1)
+    assert inv_module.linear_conv.conv.padding == (0, 0)
+    assert isinstance(inv_module.linear_conv.bn, torch.nn.BatchNorm2d)
+
+    x = torch.rand(1, 32, 64, 64)
+    output = inv_module(x)
+    assert output.shape == (1, 32, 64, 64)
+
+    # test with se_cfg and with_expand_conv
+    se_cfg = dict(
+        channels=16,
+        ratio=4,
+        act_cfg=(dict(type='ReLU'),
+                 dict(type='HSigmoid', bias=3.0, divisor=6.0)))
+    act_cfg = dict(type='HSwish')
+    inv_module = InvertedResidualV3(
+        32, 40, 16, 3, 2, se_cfg=se_cfg, act_cfg=act_cfg)
+    assert inv_module.with_res_shortcut is False
+    assert inv_module.with_se is True
+    assert inv_module.with_expand_conv is True
+    assert inv_module.expand_conv.conv.kernel_size == (1, 1)
+    assert inv_module.expand_conv.conv.stride == (1, 1)
+    assert inv_module.expand_conv.conv.padding == (0, 0)
+
+    assert isinstance(inv_module.depthwise_conv.conv,
+                      mmcv.cnn.bricks.Conv2dAdaptivePadding)
+    assert inv_module.depthwise_conv.conv.kernel_size == (3, 3)
+    assert inv_module.depthwise_conv.conv.stride == (2, 2)
+    assert inv_module.depthwise_conv.conv.padding == (0, 0)
+    assert isinstance(inv_module.depthwise_conv.bn, torch.nn.BatchNorm2d)
+
+    assert inv_module.linear_conv.conv.kernel_size == (1, 1)
+    assert inv_module.linear_conv.conv.stride == (1, 1)
+    assert inv_module.linear_conv.conv.padding == (0, 0)
+    assert isinstance(inv_module.linear_conv.bn, torch.nn.BatchNorm2d)
+
+    if (TORCH_VERSION == 'parrots'
+            or digit_version(TORCH_VERSION) < digit_version('1.7')):
+        # Note: Use PyTorch official HSwish
+        # when torch>=1.7 after MMCV >= 1.4.5.
+        # Hardswish is not supported when PyTorch version < 1.6.
+        # And Hardswish in PyTorch 1.6 does not support inplace.
+        # More details could be found from:
+        # https://github.com/open-mmlab/mmcv/pull/1709
+        assert isinstance(inv_module.expand_conv.activate, mmcv.cnn.HSwish)
+        assert isinstance(inv_module.depthwise_conv.activate, mmcv.cnn.HSwish)
+    else:
+        assert isinstance(inv_module.expand_conv.activate, torch.nn.Hardswish)
+        assert isinstance(inv_module.depthwise_conv.activate,
+                          torch.nn.Hardswish)
+
+    x = torch.rand(1, 32, 64, 64)
+    output = inv_module(x)
+    assert output.shape == (1, 40, 32, 32)
+
+    # test with checkpoint forward
+    inv_module = InvertedResidualV3(
+        32, 40, 16, 3, 2, se_cfg=se_cfg, act_cfg=act_cfg, with_cp=True)
+    assert inv_module.with_cp
+    x = torch.randn(2, 32, 64, 64, requires_grad=True)
+    output = inv_module(x)
+    assert output.shape == (2, 40, 32, 32)
+
+
+def test_se_layer():
+    with pytest.raises(AssertionError):
+        # test act_cfg assertion.
+        SELayer(32, act_cfg=(dict(type='ReLU'), ))
+
+    # test config with channels = 16.
+    se_layer = SELayer(16)
+    assert se_layer.conv1.conv.kernel_size == (1, 1)
+    assert se_layer.conv1.conv.stride == (1, 1)
+    assert se_layer.conv1.conv.padding == (0, 0)
+    assert isinstance(se_layer.conv1.activate, torch.nn.ReLU)
+    assert se_layer.conv2.conv.kernel_size == (1, 1)
+    assert se_layer.conv2.conv.stride == (1, 1)
+    assert se_layer.conv2.conv.padding == (0, 0)
+    assert isinstance(se_layer.conv2.activate, mmcv.cnn.HSigmoid)
+
+    x = torch.rand(1, 16, 64, 64)
+    output = se_layer(x)
+    assert output.shape == (1, 16, 64, 64)
+
+    # test config with channels = 16, act_cfg = dict(type='ReLU').
+    se_layer = SELayer(16, act_cfg=dict(type='ReLU'))
+    assert se_layer.conv1.conv.kernel_size == (1, 1)
+    assert se_layer.conv1.conv.stride == (1, 1)
+    assert se_layer.conv1.conv.padding == (0, 0)
+    assert isinstance(se_layer.conv1.activate, torch.nn.ReLU)
+    assert se_layer.conv2.conv.kernel_size == (1, 1)
+    assert se_layer.conv2.conv.stride == (1, 1)
+    assert se_layer.conv2.conv.padding == (0, 0)
+    assert isinstance(se_layer.conv2.activate, torch.nn.ReLU)
+
+    x = torch.rand(1, 16, 64, 64)
+    output = se_layer(x)
+    assert output.shape == (1, 16, 64, 64)
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_cgnet.py b/mmsegmentation/tests/test_models/test_backbones/test_cgnet.py
new file mode 100644
index 0000000..f938525
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_cgnet.py
@@ -0,0 +1,151 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.backbones import CGNet
+from mmseg.models.backbones.cgnet import (ContextGuidedBlock,
+                                          GlobalContextExtractor)
+
+
+def test_cgnet_GlobalContextExtractor():
+    block = GlobalContextExtractor(16, 16, with_cp=True)
+    x = torch.randn(2, 16, 64, 64, requires_grad=True)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([2, 16, 64, 64])
+
+
+def test_cgnet_context_guided_block():
+    with pytest.raises(AssertionError):
+        # cgnet ContextGuidedBlock GlobalContextExtractor channel and reduction
+        # constraints.
+        ContextGuidedBlock(8, 8)
+
+    # test cgnet ContextGuidedBlock with checkpoint forward
+    block = ContextGuidedBlock(
+        16, 16, act_cfg=dict(type='PReLU'), with_cp=True)
+    assert block.with_cp
+    x = torch.randn(2, 16, 64, 64, requires_grad=True)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([2, 16, 64, 64])
+
+    # test cgnet ContextGuidedBlock without checkpoint forward
+    block = ContextGuidedBlock(32, 32)
+    assert not block.with_cp
+    x = torch.randn(3, 32, 32, 32)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([3, 32, 32, 32])
+
+    # test cgnet ContextGuidedBlock with down sampling
+    block = ContextGuidedBlock(32, 32, downsample=True)
+    assert block.conv1x1.conv.in_channels == 32
+    assert block.conv1x1.conv.out_channels == 32
+    assert block.conv1x1.conv.kernel_size == (3, 3)
+    assert block.conv1x1.conv.stride == (2, 2)
+    assert block.conv1x1.conv.padding == (1, 1)
+
+    assert block.f_loc.in_channels == 32
+    assert block.f_loc.out_channels == 32
+    assert block.f_loc.kernel_size == (3, 3)
+    assert block.f_loc.stride == (1, 1)
+    assert block.f_loc.padding == (1, 1)
+    assert block.f_loc.groups == 32
+    assert block.f_loc.dilation == (1, 1)
+    assert block.f_loc.bias is None
+
+    assert block.f_sur.in_channels == 32
+    assert block.f_sur.out_channels == 32
+    assert block.f_sur.kernel_size == (3, 3)
+    assert block.f_sur.stride == (1, 1)
+    assert block.f_sur.padding == (2, 2)
+    assert block.f_sur.groups == 32
+    assert block.f_sur.dilation == (2, 2)
+    assert block.f_sur.bias is None
+
+    assert block.bottleneck.in_channels == 64
+    assert block.bottleneck.out_channels == 32
+    assert block.bottleneck.kernel_size == (1, 1)
+    assert block.bottleneck.stride == (1, 1)
+    assert block.bottleneck.bias is None
+
+    x = torch.randn(1, 32, 32, 32)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([1, 32, 16, 16])
+
+    # test cgnet ContextGuidedBlock without down sampling
+    block = ContextGuidedBlock(32, 32, downsample=False)
+    assert block.conv1x1.conv.in_channels == 32
+    assert block.conv1x1.conv.out_channels == 16
+    assert block.conv1x1.conv.kernel_size == (1, 1)
+    assert block.conv1x1.conv.stride == (1, 1)
+    assert block.conv1x1.conv.padding == (0, 0)
+
+    assert block.f_loc.in_channels == 16
+    assert block.f_loc.out_channels == 16
+    assert block.f_loc.kernel_size == (3, 3)
+    assert block.f_loc.stride == (1, 1)
+    assert block.f_loc.padding == (1, 1)
+    assert block.f_loc.groups == 16
+    assert block.f_loc.dilation == (1, 1)
+    assert block.f_loc.bias is None
+
+    assert block.f_sur.in_channels == 16
+    assert block.f_sur.out_channels == 16
+    assert block.f_sur.kernel_size == (3, 3)
+    assert block.f_sur.stride == (1, 1)
+    assert block.f_sur.padding == (2, 2)
+    assert block.f_sur.groups == 16
+    assert block.f_sur.dilation == (2, 2)
+    assert block.f_sur.bias is None
+
+    x = torch.randn(1, 32, 32, 32)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([1, 32, 32, 32])
+
+
+def test_cgnet_backbone():
+    with pytest.raises(AssertionError):
+        # check invalid num_channels
+        CGNet(num_channels=(32, 64, 128, 256))
+
+    with pytest.raises(AssertionError):
+        # check invalid num_blocks
+        CGNet(num_blocks=(3, 21, 3))
+
+    with pytest.raises(AssertionError):
+        # check invalid dilation
+        CGNet(num_blocks=2)
+
+    with pytest.raises(AssertionError):
+        # check invalid reduction
+        CGNet(reductions=16)
+
+    with pytest.raises(AssertionError):
+        # check invalid num_channels and reduction
+        CGNet(num_channels=(32, 64, 128), reductions=(64, 129))
+
+    # Test CGNet with default settings
+    model = CGNet()
+    model.init_weights()
+    model.train()
+
+    imgs = torch.randn(2, 3, 224, 224)
+    feat = model(imgs)
+    assert len(feat) == 3
+    assert feat[0].shape == torch.Size([2, 35, 112, 112])
+    assert feat[1].shape == torch.Size([2, 131, 56, 56])
+    assert feat[2].shape == torch.Size([2, 256, 28, 28])
+
+    # Test CGNet with norm_eval True and with_cp True
+    model = CGNet(norm_eval=True, with_cp=True)
+    with pytest.raises(TypeError):
+        # check invalid pretrained
+        model.init_weights(pretrained=8)
+    model.init_weights()
+    model.train()
+
+    imgs = torch.randn(2, 3, 224, 224)
+    feat = model(imgs)
+    assert len(feat) == 3
+    assert feat[0].shape == torch.Size([2, 35, 112, 112])
+    assert feat[1].shape == torch.Size([2, 131, 56, 56])
+    assert feat[2].shape == torch.Size([2, 256, 28, 28])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_clip_text_encoder.py b/mmsegmentation/tests/test_models/test_backbones/test_clip_text_encoder.py
new file mode 100644
index 0000000..ea06c5b
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_clip_text_encoder.py
@@ -0,0 +1,43 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from mmengine import Config
+from mmengine.registry import init_default_scope
+
+from mmseg.models.text_encoder import CLIPTextEncoder
+from mmseg.utils import get_classes
+
+
+def test_clip_text_encoder():
+    init_default_scope('mmseg')
+    # test vocabulary
+    output_dims = 8
+    embed_dims = 32
+    vocabulary = ['cat', 'dog', 'bird', 'car', 'bike']
+    cfg = dict(
+        vocabulary=vocabulary,
+        templates=['a photo of a {}.'],
+        embed_dims=embed_dims,
+        output_dims=output_dims)
+    cfg = Config(cfg)
+
+    text_encoder = CLIPTextEncoder(**cfg)
+    if torch.cuda.is_available():
+        text_encoder = text_encoder.cuda()
+
+    with torch.no_grad():
+        class_embeds = text_encoder()
+        assert class_embeds.shape == (len(vocabulary) + 1, output_dims)
+
+    # test dataset name
+    cfg = dict(
+        dataset_name='vaihingen',
+        templates=['a photo of a {}.'],
+        embed_dims=embed_dims,
+        output_dims=output_dims)
+    cfg = Config(cfg)
+
+    text_encoder = CLIPTextEncoder(**cfg)
+    with torch.no_grad():
+        class_embeds = text_encoder()
+        class_nums = len(get_classes('vaihingen'))
+        assert class_embeds.shape == (class_nums + 1, output_dims)
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_erfnet.py b/mmsegmentation/tests/test_models/test_backbones/test_erfnet.py
new file mode 100644
index 0000000..6ae7345
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_erfnet.py
@@ -0,0 +1,146 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.backbones import ERFNet
+from mmseg.models.backbones.erfnet import (DownsamplerBlock, NonBottleneck1d,
+                                           UpsamplerBlock)
+
+
+def test_erfnet_backbone():
+    # Test ERFNet Standard Forward.
+    model = ERFNet(
+        in_channels=3,
+        enc_downsample_channels=(16, 64, 128),
+        enc_stage_non_bottlenecks=(5, 8),
+        enc_non_bottleneck_dilations=(2, 4, 8, 16),
+        enc_non_bottleneck_channels=(64, 128),
+        dec_upsample_channels=(64, 16),
+        dec_stages_non_bottleneck=(2, 2),
+        dec_non_bottleneck_channels=(64, 16),
+        dropout_ratio=0.1,
+    )
+    model.init_weights()
+    model.train()
+    batch_size = 2
+    imgs = torch.randn(batch_size, 3, 256, 512)
+    output = model(imgs)
+
+    # output for segment Head
+    assert output[0].shape == torch.Size([batch_size, 16, 128, 256])
+
+    # Test input with rare shape
+    batch_size = 2
+    imgs = torch.randn(batch_size, 3, 527, 279)
+    output = model(imgs)
+    assert len(output[0]) == batch_size
+
+    with pytest.raises(AssertionError):
+        # Number of encoder downsample block and decoder upsample block.
+        ERFNet(
+            in_channels=3,
+            enc_downsample_channels=(16, 64, 128),
+            enc_stage_non_bottlenecks=(5, 8),
+            enc_non_bottleneck_dilations=(2, 4, 8, 16),
+            enc_non_bottleneck_channels=(64, 128),
+            dec_upsample_channels=(128, 64, 16),
+            dec_stages_non_bottleneck=(2, 2),
+            dec_non_bottleneck_channels=(64, 16),
+            dropout_ratio=0.1,
+        )
+    with pytest.raises(AssertionError):
+        # Number of encoder downsample block and encoder Non-bottleneck block.
+        ERFNet(
+            in_channels=3,
+            enc_downsample_channels=(16, 64, 128),
+            enc_stage_non_bottlenecks=(5, 8, 10),
+            enc_non_bottleneck_dilations=(2, 4, 8, 16),
+            enc_non_bottleneck_channels=(64, 128),
+            dec_upsample_channels=(64, 16),
+            dec_stages_non_bottleneck=(2, 2),
+            dec_non_bottleneck_channels=(64, 16),
+            dropout_ratio=0.1,
+        )
+    with pytest.raises(AssertionError):
+        # Number of encoder downsample block and
+        # channels of encoder Non-bottleneck block.
+        ERFNet(
+            in_channels=3,
+            enc_downsample_channels=(16, 64, 128),
+            enc_stage_non_bottlenecks=(5, 8),
+            enc_non_bottleneck_dilations=(2, 4, 8, 16),
+            enc_non_bottleneck_channels=(64, 128, 256),
+            dec_upsample_channels=(64, 16),
+            dec_stages_non_bottleneck=(2, 2),
+            dec_non_bottleneck_channels=(64, 16),
+            dropout_ratio=0.1,
+        )
+
+    with pytest.raises(AssertionError):
+        # Number of encoder Non-bottleneck block and number of its channels.
+        ERFNet(
+            in_channels=3,
+            enc_downsample_channels=(16, 64, 128),
+            enc_stage_non_bottlenecks=(5, 8, 3),
+            enc_non_bottleneck_dilations=(2, 4, 8, 16),
+            enc_non_bottleneck_channels=(64, 128),
+            dec_upsample_channels=(64, 16),
+            dec_stages_non_bottleneck=(2, 2),
+            dec_non_bottleneck_channels=(64, 16),
+            dropout_ratio=0.1,
+        )
+    with pytest.raises(AssertionError):
+        # Number of decoder upsample block and decoder Non-bottleneck block.
+        ERFNet(
+            in_channels=3,
+            enc_downsample_channels=(16, 64, 128),
+            enc_stage_non_bottlenecks=(5, 8),
+            enc_non_bottleneck_dilations=(2, 4, 8, 16),
+            enc_non_bottleneck_channels=(64, 128),
+            dec_upsample_channels=(64, 16),
+            dec_stages_non_bottleneck=(2, 2, 3),
+            dec_non_bottleneck_channels=(64, 16),
+            dropout_ratio=0.1,
+        )
+    with pytest.raises(AssertionError):
+        # Number of decoder Non-bottleneck block and number of its channels.
+        ERFNet(
+            in_channels=3,
+            enc_downsample_channels=(16, 64, 128),
+            enc_stage_non_bottlenecks=(5, 8),
+            enc_non_bottleneck_dilations=(2, 4, 8, 16),
+            enc_non_bottleneck_channels=(64, 128),
+            dec_upsample_channels=(64, 16),
+            dec_stages_non_bottleneck=(2, 2),
+            dec_non_bottleneck_channels=(64, 16, 8),
+            dropout_ratio=0.1,
+        )
+
+
+def test_erfnet_downsampler_block():
+    x_db = DownsamplerBlock(16, 64)
+    assert x_db.conv.in_channels == 16
+    assert x_db.conv.out_channels == 48
+    assert len(x_db.bn.weight) == 64
+    assert x_db.pool.kernel_size == 2
+    assert x_db.pool.stride == 2
+
+
+def test_erfnet_non_bottleneck_1d():
+    x_nb1d = NonBottleneck1d(16, 0, 1)
+    assert x_nb1d.convs_layers[0].in_channels == 16
+    assert x_nb1d.convs_layers[0].out_channels == 16
+    assert x_nb1d.convs_layers[2].in_channels == 16
+    assert x_nb1d.convs_layers[2].out_channels == 16
+    assert x_nb1d.convs_layers[5].in_channels == 16
+    assert x_nb1d.convs_layers[5].out_channels == 16
+    assert x_nb1d.convs_layers[7].in_channels == 16
+    assert x_nb1d.convs_layers[7].out_channels == 16
+    assert x_nb1d.convs_layers[9].p == 0
+
+
+def test_erfnet_upsampler_block():
+    x_ub = UpsamplerBlock(64, 16)
+    assert x_ub.conv.in_channels == 64
+    assert x_ub.conv.out_channels == 16
+    assert len(x_ub.bn.weight) == 16
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_fast_scnn.py b/mmsegmentation/tests/test_models/test_backbones/test_fast_scnn.py
new file mode 100644
index 0000000..7ee638b
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_fast_scnn.py
@@ -0,0 +1,42 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.backbones import FastSCNN
+
+
+def test_fastscnn_backbone():
+    with pytest.raises(AssertionError):
+        # Fast-SCNN channel constraints.
+        FastSCNN(
+            3, (32, 48),
+            64, (64, 96, 128), (2, 2, 1),
+            global_out_channels=127,
+            higher_in_channels=64,
+            lower_in_channels=128)
+
+    # Test FastSCNN Standard Forward
+    model = FastSCNN(
+        in_channels=3,
+        downsample_dw_channels=(4, 6),
+        global_in_channels=8,
+        global_block_channels=(8, 12, 16),
+        global_block_strides=(2, 2, 1),
+        global_out_channels=16,
+        higher_in_channels=8,
+        lower_in_channels=16,
+        fusion_out_channels=16,
+    )
+    model.init_weights()
+    model.train()
+    batch_size = 4
+    imgs = torch.randn(batch_size, 3, 64, 128)
+    feat = model(imgs)
+
+    assert len(feat) == 3
+    # higher-res
+    assert feat[0].shape == torch.Size([batch_size, 8, 8, 16])
+    # lower-res
+    assert feat[1].shape == torch.Size([batch_size, 16, 2, 4])
+    # FFM output
+    assert feat[2].shape == torch.Size([batch_size, 16, 8, 16])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_hrnet.py b/mmsegmentation/tests/test_models/test_backbones/test_hrnet.py
new file mode 100644
index 0000000..3e35515
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_hrnet.py
@@ -0,0 +1,144 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+from mmengine.utils.dl_utils.parrots_wrapper import _BatchNorm
+
+from mmseg.models.backbones.hrnet import HRModule, HRNet
+from mmseg.models.backbones.resnet import BasicBlock, Bottleneck
+
+
+@pytest.mark.parametrize('block', [BasicBlock, Bottleneck])
+def test_hrmodule(block):
+    # Test multiscale forward
+    num_channles = (32, 64)
+    in_channels = [c * block.expansion for c in num_channles]
+    hrmodule = HRModule(
+        num_branches=2,
+        blocks=block,
+        in_channels=in_channels,
+        num_blocks=(4, 4),
+        num_channels=num_channles,
+    )
+
+    feats = [
+        torch.randn(1, in_channels[0], 64, 64),
+        torch.randn(1, in_channels[1], 32, 32)
+    ]
+    feats = hrmodule(feats)
+
+    assert len(feats) == 2
+    assert feats[0].shape == torch.Size([1, in_channels[0], 64, 64])
+    assert feats[1].shape == torch.Size([1, in_channels[1], 32, 32])
+
+    # Test single scale forward
+    num_channles = (32, 64)
+    in_channels = [c * block.expansion for c in num_channles]
+    hrmodule = HRModule(
+        num_branches=2,
+        blocks=block,
+        in_channels=in_channels,
+        num_blocks=(4, 4),
+        num_channels=num_channles,
+        multiscale_output=False,
+    )
+
+    feats = [
+        torch.randn(1, in_channels[0], 64, 64),
+        torch.randn(1, in_channels[1], 32, 32)
+    ]
+    feats = hrmodule(feats)
+
+    assert len(feats) == 1
+    assert feats[0].shape == torch.Size([1, in_channels[0], 64, 64])
+
+
+def test_hrnet_backbone():
+    # only have 3 stages
+    extra = dict(
+        stage1=dict(
+            num_modules=1,
+            num_branches=1,
+            block='BOTTLENECK',
+            num_blocks=(4, ),
+            num_channels=(64, )),
+        stage2=dict(
+            num_modules=1,
+            num_branches=2,
+            block='BASIC',
+            num_blocks=(4, 4),
+            num_channels=(32, 64)),
+        stage3=dict(
+            num_modules=4,
+            num_branches=3,
+            block='BASIC',
+            num_blocks=(4, 4, 4),
+            num_channels=(32, 64, 128)))
+
+    with pytest.raises(AssertionError):
+        # HRNet now only support 4 stages
+        HRNet(extra=extra)
+    extra['stage4'] = dict(
+        num_modules=3,
+        num_branches=3,  # should be 4
+        block='BASIC',
+        num_blocks=(4, 4, 4, 4),
+        num_channels=(32, 64, 128, 256))
+
+    with pytest.raises(AssertionError):
+        # len(num_blocks) should equal num_branches
+        HRNet(extra=extra)
+
+    extra['stage4']['num_branches'] = 4
+
+    # Test hrnetv2p_w32
+    model = HRNet(extra=extra)
+    model.init_weights()
+    model.train()
+
+    imgs = torch.randn(1, 3, 64, 64)
+    feats = model(imgs)
+    assert len(feats) == 4
+    assert feats[0].shape == torch.Size([1, 32, 16, 16])
+    assert feats[3].shape == torch.Size([1, 256, 2, 2])
+
+    # Test single scale output
+    model = HRNet(extra=extra, multiscale_output=False)
+    model.init_weights()
+    model.train()
+
+    imgs = torch.randn(1, 3, 64, 64)
+    feats = model(imgs)
+    assert len(feats) == 1
+    assert feats[0].shape == torch.Size([1, 32, 16, 16])
+
+    # Test HRNET with two stage frozen
+    frozen_stages = 2
+    model = HRNet(extra, frozen_stages=frozen_stages)
+    model.init_weights()
+    model.train()
+    assert model.norm1.training is False
+
+    for layer in [model.conv1, model.norm1]:
+        for param in layer.parameters():
+            assert param.requires_grad is False
+    for i in range(1, frozen_stages + 1):
+        if i == 1:
+            layer = getattr(model, f'layer{i}')
+            transition = getattr(model, f'transition{i}')
+        elif i == 4:
+            layer = getattr(model, f'stage{i}')
+        else:
+            layer = getattr(model, f'stage{i}')
+            transition = getattr(model, f'transition{i}')
+
+        for mod in layer.modules():
+            if isinstance(mod, _BatchNorm):
+                assert mod.training is False
+        for param in layer.parameters():
+            assert param.requires_grad is False
+
+        for mod in transition.modules():
+            if isinstance(mod, _BatchNorm):
+                assert mod.training is False
+        for param in transition.parameters():
+            assert param.requires_grad is False
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_icnet.py b/mmsegmentation/tests/test_models/test_backbones/test_icnet.py
new file mode 100644
index 0000000..a96d8d8
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_icnet.py
@@ -0,0 +1,50 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.backbones import ICNet
+
+
+def test_icnet_backbone():
+    with pytest.raises(TypeError):
+        # Must give backbone dict in config file.
+        ICNet(
+            in_channels=3,
+            layer_channels=(128, 512),
+            light_branch_middle_channels=8,
+            psp_out_channels=128,
+            out_channels=(16, 128, 128),
+            backbone_cfg=None)
+
+    # Test ICNet Standard Forward
+    model = ICNet(
+        layer_channels=(128, 512),
+        backbone_cfg=dict(
+            type='ResNetV1c',
+            in_channels=3,
+            depth=18,
+            num_stages=4,
+            out_indices=(0, 1, 2, 3),
+            dilations=(1, 1, 2, 4),
+            strides=(1, 2, 1, 1),
+            norm_cfg=dict(type='BN', requires_grad=True),
+            norm_eval=False,
+            style='pytorch',
+            contract_dilation=True),
+    )
+    assert hasattr(model.backbone,
+                   'maxpool') and model.backbone.maxpool.ceil_mode is True
+    model.init_weights()
+    model.train()
+    batch_size = 2
+    imgs = torch.randn(batch_size, 3, 32, 64)
+    feat = model(imgs)
+
+    assert model.psp_modules[0][0].output_size == 1
+    assert model.psp_modules[1][0].output_size == 2
+    assert model.psp_modules[2][0].output_size == 3
+    assert model.psp_bottleneck.padding == 1
+    assert model.conv_sub1[0].padding == 1
+
+    assert len(feat) == 3
+    assert feat[0].shape == torch.Size([batch_size, 64, 4, 8])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_mae.py b/mmsegmentation/tests/test_models/test_backbones/test_mae.py
new file mode 100644
index 0000000..16f52b5
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_mae.py
@@ -0,0 +1,186 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.backbones.mae import MAE
+from .utils import check_norm_state
+
+
+def test_mae_backbone():
+    with pytest.raises(TypeError):
+        # pretrained must be a string path
+        model = MAE()
+        model.init_weights(pretrained=0)
+
+    with pytest.raises(TypeError):
+        # img_size must be int or tuple
+        model = MAE(img_size=512.0)
+
+    with pytest.raises(TypeError):
+        # out_indices must be int ,list or tuple
+        model = MAE(out_indices=1.)
+
+    with pytest.raises(AssertionError):
+        # The length of img_size tuple must be lower than 3.
+        MAE(img_size=(224, 224, 224))
+
+    with pytest.raises(TypeError):
+        # Pretrained must be None or Str.
+        MAE(pretrained=123)
+
+    # Test img_size isinstance tuple
+    imgs = torch.randn(1, 3, 224, 224)
+    model = MAE(img_size=(224, ))
+    model.init_weights()
+    model(imgs)
+
+    # Test img_size isinstance tuple
+    imgs = torch.randn(1, 3, 224, 224)
+    model = MAE(img_size=(224, 224))
+    model(imgs)
+
+    # Test norm_eval = True
+    model = MAE(norm_eval=True)
+    model.train()
+
+    # Test BEiT backbone with input size of 224 and patch size of 16
+    model = MAE()
+    model.init_weights()
+    model.train()
+
+    # Test out_indices = list
+    model = MAE(out_indices=[2, 4, 8, 12])
+    model.train()
+
+    assert check_norm_state(model.modules(), True)
+
+    # Test image size = (224, 224)
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 14, 14)
+
+    # Test MAE backbone with input size of 256 and patch size of 16
+    model = MAE(img_size=(256, 256))
+    model.init_weights()
+    model.train()
+    imgs = torch.randn(1, 3, 256, 256)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 16, 16)
+
+    # Test MAE backbone with input size of 32 and patch size of 16
+    model = MAE(img_size=(32, 32))
+    model.init_weights()
+    model.train()
+    imgs = torch.randn(1, 3, 32, 32)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 2, 2)
+
+    # Test unbalanced size input image
+    model = MAE(img_size=(112, 224))
+    model.init_weights()
+    model.train()
+    imgs = torch.randn(1, 3, 112, 224)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 7, 14)
+
+    # Test irregular input image
+    model = MAE(img_size=(234, 345))
+    model.init_weights()
+    model.train()
+    imgs = torch.randn(1, 3, 234, 345)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 14, 21)
+
+    # Test init_values=0
+    model = MAE(init_values=0)
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 14, 14)
+
+    # Test final norm
+    model = MAE(final_norm=True)
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 14, 14)
+
+    # Test patch norm
+    model = MAE(patch_norm=True)
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 14, 14)
+
+
+def test_mae_init():
+    path = 'PATH_THAT_DO_NOT_EXIST'
+    # Test all combinations of pretrained and init_cfg
+    # pretrained=None, init_cfg=None
+    model = MAE(pretrained=None, init_cfg=None)
+    assert model.init_cfg is None
+    model.init_weights()
+
+    # pretrained=None
+    # init_cfg loads pretrain from an non-existent file
+    model = MAE(
+        pretrained=None, init_cfg=dict(type='Pretrained', checkpoint=path))
+    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
+    # Test loading a checkpoint from an non-existent file
+    with pytest.raises(OSError):
+        model.init_weights()
+
+    # test resize_rel_pos_embed
+    value = torch.randn(732, 16)
+    abs_pos_embed_value = torch.rand(1, 17, 768)
+    ckpt = {
+        'state_dict': {
+            'layers.0.attn.relative_position_index': 0,
+            'layers.0.attn.relative_position_bias_table': value,
+            'pos_embed': abs_pos_embed_value
+        }
+    }
+    model = MAE(img_size=(512, 512))
+    # If scipy is installed, this AttributeError would not be raised.
+    from mmengine.utils import is_installed
+    if not is_installed('scipy'):
+        with pytest.raises(AttributeError):
+            model.resize_rel_pos_embed(ckpt)
+
+    # test resize abs pos embed
+    ckpt = model.resize_abs_pos_embed(ckpt['state_dict'])
+
+    # pretrained=None
+    # init_cfg=123, whose type is unsupported
+    model = MAE(pretrained=None, init_cfg=123)
+    with pytest.raises(TypeError):
+        model.init_weights()
+
+    # pretrained loads pretrain from an non-existent file
+    # init_cfg=None
+    model = MAE(pretrained=path, init_cfg=None)
+    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
+    # Test loading a checkpoint from an non-existent file
+    with pytest.raises(OSError):
+        model.init_weights()
+
+    # pretrained loads pretrain from an non-existent file
+    # init_cfg loads pretrain from an non-existent file
+    with pytest.raises(AssertionError):
+        model = MAE(
+            pretrained=path, init_cfg=dict(type='Pretrained', checkpoint=path))
+    with pytest.raises(AssertionError):
+        model = MAE(pretrained=path, init_cfg=123)
+
+    # pretrain=123, whose type is unsupported
+    # init_cfg=None
+    with pytest.raises(TypeError):
+        model = MAE(pretrained=123, init_cfg=None)
+
+    # pretrain=123, whose type is unsupported
+    # init_cfg loads pretrain from an non-existent file
+    with pytest.raises(AssertionError):
+        model = MAE(
+            pretrained=123, init_cfg=dict(type='Pretrained', checkpoint=path))
+
+    # pretrain=123, whose type is unsupported
+    # init_cfg=123, whose type is unsupported
+    with pytest.raises(AssertionError):
+        model = MAE(pretrained=123, init_cfg=123)
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_mit.py b/mmsegmentation/tests/test_models/test_backbones/test_mit.py
new file mode 100644
index 0000000..72f74fe
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_mit.py
@@ -0,0 +1,122 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.backbones import MixVisionTransformer
+from mmseg.models.backbones.mit import (EfficientMultiheadAttention, MixFFN,
+                                        TransformerEncoderLayer)
+
+
+def test_mit():
+    with pytest.raises(TypeError):
+        # Pretrained represents pretrain url and must be str or None.
+        MixVisionTransformer(pretrained=123)
+
+    # Test normal input
+    H, W = (224, 224)
+    temp = torch.randn((1, 3, H, W))
+    model = MixVisionTransformer(
+        embed_dims=32, num_heads=[1, 2, 5, 8], out_indices=(0, 1, 2, 3))
+    model.init_weights()
+    outs = model(temp)
+    assert outs[0].shape == (1, 32, H // 4, W // 4)
+    assert outs[1].shape == (1, 64, H // 8, W // 8)
+    assert outs[2].shape == (1, 160, H // 16, W // 16)
+    assert outs[3].shape == (1, 256, H // 32, W // 32)
+
+    # Test non-squared input
+    H, W = (224, 256)
+    temp = torch.randn((1, 3, H, W))
+    outs = model(temp)
+    assert outs[0].shape == (1, 32, H // 4, W // 4)
+    assert outs[1].shape == (1, 64, H // 8, W // 8)
+    assert outs[2].shape == (1, 160, H // 16, W // 16)
+    assert outs[3].shape == (1, 256, H // 32, W // 32)
+
+    # Test MixFFN
+    FFN = MixFFN(64, 128)
+    hw_shape = (32, 32)
+    token_len = 32 * 32
+    temp = torch.randn((1, token_len, 64))
+    # Self identity
+    out = FFN(temp, hw_shape)
+    assert out.shape == (1, token_len, 64)
+    # Out identity
+    outs = FFN(temp, hw_shape, temp)
+    assert out.shape == (1, token_len, 64)
+
+    # Test EfficientMHA
+    MHA = EfficientMultiheadAttention(64, 2)
+    hw_shape = (32, 32)
+    token_len = 32 * 32
+    temp = torch.randn((1, token_len, 64))
+    # Self identity
+    out = MHA(temp, hw_shape)
+    assert out.shape == (1, token_len, 64)
+    # Out identity
+    outs = MHA(temp, hw_shape, temp)
+    assert out.shape == (1, token_len, 64)
+
+    # Test TransformerEncoderLayer with checkpoint forward
+    block = TransformerEncoderLayer(
+        embed_dims=64, num_heads=4, feedforward_channels=256, with_cp=True)
+    assert block.with_cp
+    x = torch.randn(1, 56 * 56, 64)
+    x_out = block(x, (56, 56))
+    assert x_out.shape == torch.Size([1, 56 * 56, 64])
+
+
+def test_mit_init():
+    path = 'PATH_THAT_DO_NOT_EXIST'
+    # Test all combinations of pretrained and init_cfg
+    # pretrained=None, init_cfg=None
+    model = MixVisionTransformer(pretrained=None, init_cfg=None)
+    assert model.init_cfg is None
+    model.init_weights()
+
+    # pretrained=None
+    # init_cfg loads pretrain from an non-existent file
+    model = MixVisionTransformer(
+        pretrained=None, init_cfg=dict(type='Pretrained', checkpoint=path))
+    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
+    # Test loading a checkpoint from an non-existent file
+    with pytest.raises(OSError):
+        model.init_weights()
+
+    # pretrained=None
+    # init_cfg=123, whose type is unsupported
+    model = MixVisionTransformer(pretrained=None, init_cfg=123)
+    with pytest.raises(TypeError):
+        model.init_weights()
+
+    # pretrained loads pretrain from an non-existent file
+    # init_cfg=None
+    model = MixVisionTransformer(pretrained=path, init_cfg=None)
+    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
+    # Test loading a checkpoint from an non-existent file
+    with pytest.raises(OSError):
+        model.init_weights()
+
+    # pretrained loads pretrain from an non-existent file
+    # init_cfg loads pretrain from an non-existent file
+    with pytest.raises(AssertionError):
+        MixVisionTransformer(
+            pretrained=path, init_cfg=dict(type='Pretrained', checkpoint=path))
+    with pytest.raises(AssertionError):
+        MixVisionTransformer(pretrained=path, init_cfg=123)
+
+    # pretrain=123, whose type is unsupported
+    # init_cfg=None
+    with pytest.raises(TypeError):
+        MixVisionTransformer(pretrained=123, init_cfg=None)
+
+    # pretrain=123, whose type is unsupported
+    # init_cfg loads pretrain from an non-existent file
+    with pytest.raises(AssertionError):
+        MixVisionTransformer(
+            pretrained=123, init_cfg=dict(type='Pretrained', checkpoint=path))
+
+    # pretrain=123, whose type is unsupported
+    # init_cfg=123, whose type is unsupported
+    with pytest.raises(AssertionError):
+        MixVisionTransformer(pretrained=123, init_cfg=123)
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_mobilenet_v3.py b/mmsegmentation/tests/test_models/test_backbones/test_mobilenet_v3.py
new file mode 100644
index 0000000..769ee14
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_mobilenet_v3.py
@@ -0,0 +1,67 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.backbones import MobileNetV3
+
+
+def test_mobilenet_v3():
+    with pytest.raises(AssertionError):
+        # check invalid arch
+        MobileNetV3('big')
+
+    with pytest.raises(AssertionError):
+        # check invalid reduction_factor
+        MobileNetV3(reduction_factor=0)
+
+    with pytest.raises(ValueError):
+        # check invalid out_indices
+        MobileNetV3(out_indices=(0, 1, 15))
+
+    with pytest.raises(ValueError):
+        # check invalid frozen_stages
+        MobileNetV3(frozen_stages=15)
+
+    with pytest.raises(TypeError):
+        # check invalid pretrained
+        model = MobileNetV3()
+        model.init_weights(pretrained=8)
+
+    # Test MobileNetV3 with default settings
+    model = MobileNetV3()
+    model.init_weights()
+    model.train()
+
+    imgs = torch.randn(2, 3, 56, 56)
+    feat = model(imgs)
+    assert len(feat) == 3
+    assert feat[0].shape == (2, 16, 28, 28)
+    assert feat[1].shape == (2, 16, 14, 14)
+    assert feat[2].shape == (2, 576, 7, 7)
+
+    # Test MobileNetV3 with arch = 'large'
+    model = MobileNetV3(arch='large', out_indices=(1, 3, 16))
+    model.init_weights()
+    model.train()
+
+    imgs = torch.randn(2, 3, 56, 56)
+    feat = model(imgs)
+    assert len(feat) == 3
+    assert feat[0].shape == (2, 16, 28, 28)
+    assert feat[1].shape == (2, 24, 14, 14)
+    assert feat[2].shape == (2, 960, 7, 7)
+
+    # Test MobileNetV3 with norm_eval True, with_cp True and frozen_stages=5
+    model = MobileNetV3(norm_eval=True, with_cp=True, frozen_stages=5)
+    with pytest.raises(TypeError):
+        # check invalid pretrained
+        model.init_weights(pretrained=8)
+    model.init_weights()
+    model.train()
+
+    imgs = torch.randn(2, 3, 56, 56)
+    feat = model(imgs)
+    assert len(feat) == 3
+    assert feat[0].shape == (2, 16, 28, 28)
+    assert feat[1].shape == (2, 16, 14, 14)
+    assert feat[2].shape == (2, 576, 7, 7)
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_mscan.py b/mmsegmentation/tests/test_models/test_backbones/test_mscan.py
new file mode 100644
index 0000000..84dfb8e
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_mscan.py
@@ -0,0 +1,69 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+
+from mmseg.models.backbones import MSCAN
+from mmseg.models.backbones.mscan import (MSCAAttention, MSCASpatialAttention,
+                                          OverlapPatchEmbed, StemConv)
+
+
+def test_mscan_backbone():
+    # Test MSCAN Standard Forward
+    model = MSCAN(
+        embed_dims=[8, 16, 32, 64],
+        norm_cfg=dict(type='BN', requires_grad=True))
+    model.init_weights()
+    model.train()
+    batch_size = 2
+    imgs = torch.randn(batch_size, 3, 64, 128)
+    feat = model(imgs)
+
+    assert len(feat) == 4
+    # output for segment Head
+    assert feat[0].shape == torch.Size([batch_size, 8, 16, 32])
+    assert feat[1].shape == torch.Size([batch_size, 16, 8, 16])
+    assert feat[2].shape == torch.Size([batch_size, 32, 4, 8])
+    assert feat[3].shape == torch.Size([batch_size, 64, 2, 4])
+
+    # Test input with rare shape
+    batch_size = 2
+    imgs = torch.randn(batch_size, 3, 95, 27)
+    feat = model(imgs)
+    assert len(feat) == 4
+
+
+def test_mscan_overlap_patch_embed_module():
+    x_overlap_patch_embed = OverlapPatchEmbed(
+        norm_cfg=dict(type='BN', requires_grad=True))
+    assert x_overlap_patch_embed.proj.in_channels == 3
+    assert x_overlap_patch_embed.norm.weight.shape == torch.Size([768])
+    x = torch.randn(2, 3, 16, 32)
+    x_out, H, W = x_overlap_patch_embed(x)
+    assert x_out.shape == torch.Size([2, 32, 768])
+
+
+def test_mscan_spatial_attention_module():
+    x_spatial_attention = MSCASpatialAttention(8)
+    assert x_spatial_attention.proj_1.kernel_size == (1, 1)
+    assert x_spatial_attention.proj_2.stride == (1, 1)
+    x = torch.randn(2, 8, 16, 32)
+    x_out = x_spatial_attention(x)
+    assert x_out.shape == torch.Size([2, 8, 16, 32])
+
+
+def test_mscan_attention_module():
+    x_attention = MSCAAttention(8)
+    assert x_attention.conv0.weight.shape[0] == 8
+    assert x_attention.conv3.kernel_size == (1, 1)
+    x = torch.randn(2, 8, 16, 32)
+    x_out = x_attention(x)
+    assert x_out.shape == torch.Size([2, 8, 16, 32])
+
+
+def test_mscan_stem_module():
+    x_stem = StemConv(8, 8, norm_cfg=dict(type='BN', requires_grad=True))
+    assert x_stem.proj[0].weight.shape[0] == 4
+    assert x_stem.proj[-1].weight.shape[0] == 8
+    x = torch.randn(2, 8, 16, 32)
+    x_out, H, W = x_stem(x)
+    assert x_out.shape == torch.Size([2, 32, 8])
+    assert (H, W) == (4, 8)
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_pidnet.py b/mmsegmentation/tests/test_models/test_backbones/test_pidnet.py
new file mode 100644
index 0000000..208dfc7
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_pidnet.py
@@ -0,0 +1,87 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os
+import tempfile
+
+import torch
+from mmengine.registry import init_default_scope
+
+from mmseg.registry import MODELS
+
+init_default_scope('mmseg')
+
+
+def test_pidnet_backbone():
+    # Test PIDNet Standard Forward
+    norm_cfg = dict(type='BN', requires_grad=True)
+    backbone_cfg = dict(
+        type='PIDNet',
+        in_channels=3,
+        channels=32,
+        ppm_channels=96,
+        num_stem_blocks=2,
+        num_branch_blocks=3,
+        align_corners=False,
+        norm_cfg=norm_cfg,
+        act_cfg=dict(type='ReLU', inplace=True))
+    model = MODELS.build(backbone_cfg)
+    model.init_weights()
+
+    # Test init weights
+    temp_file = tempfile.NamedTemporaryFile()
+    temp_file.close()
+    torch.save(model.state_dict(), temp_file.name)
+    backbone_cfg.update(
+        init_cfg=dict(type='Pretrained', checkpoint=temp_file.name))
+    model = MODELS.build(backbone_cfg)
+    model.init_weights()
+    os.remove(temp_file.name)
+
+    # Test eval mode
+    model.eval()
+    batch_size = 1
+    imgs = torch.randn(batch_size, 3, 64, 128)
+    feats = model(imgs)
+
+    assert type(feats) == torch.Tensor
+    assert feats.shape == torch.Size([batch_size, 128, 8, 16])
+
+    # Test train mode
+    model.train()
+    batch_size = 2
+    imgs = torch.randn(batch_size, 3, 64, 128)
+    feats = model(imgs)
+
+    assert len(feats) == 3
+    # test output for P branch
+    assert feats[0].shape == torch.Size([batch_size, 64, 8, 16])
+    # test output for I branch
+    assert feats[1].shape == torch.Size([batch_size, 128, 8, 16])
+    # test output for D branch
+    assert feats[2].shape == torch.Size([batch_size, 64, 8, 16])
+
+    # Test pidnet-m
+    backbone_cfg.update(channels=64)
+    model = MODELS.build(backbone_cfg)
+    feats = model(imgs)
+
+    assert len(feats) == 3
+    # test output for P branch
+    assert feats[0].shape == torch.Size([batch_size, 128, 8, 16])
+    # test output for I branch
+    assert feats[1].shape == torch.Size([batch_size, 256, 8, 16])
+    # test output for D branch
+    assert feats[2].shape == torch.Size([batch_size, 128, 8, 16])
+
+    # Test pidnet-l
+    backbone_cfg.update(
+        channels=64, ppm_channesl=112, num_stem_blocks=3, num_branch_blocks=4)
+    model = MODELS.build(backbone_cfg)
+    feats = model(imgs)
+
+    assert len(feats) == 3
+    # test output for P branch
+    assert feats[0].shape == torch.Size([batch_size, 128, 8, 16])
+    # test output for I branch
+    assert feats[1].shape == torch.Size([batch_size, 256, 8, 16])
+    # test output for D branch
+    assert feats[2].shape == torch.Size([batch_size, 128, 8, 16])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_resnest.py b/mmsegmentation/tests/test_models/test_backbones/test_resnest.py
new file mode 100644
index 0000000..3013f34
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_resnest.py
@@ -0,0 +1,44 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.backbones import ResNeSt
+from mmseg.models.backbones.resnest import Bottleneck as BottleneckS
+
+
+def test_resnest_bottleneck():
+    with pytest.raises(AssertionError):
+        # Style must be in ['pytorch', 'caffe']
+        BottleneckS(64, 64, radix=2, reduction_factor=4, style='tensorflow')
+
+    # Test ResNeSt Bottleneck structure
+    block = BottleneckS(
+        64, 256, radix=2, reduction_factor=4, stride=2, style='pytorch')
+    assert block.avd_layer.stride == 2
+    assert block.conv2.channels == 256
+
+    # Test ResNeSt Bottleneck forward
+    block = BottleneckS(64, 16, radix=2, reduction_factor=4)
+    x = torch.randn(2, 64, 56, 56)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([2, 64, 56, 56])
+
+
+def test_resnest_backbone():
+    with pytest.raises(KeyError):
+        # ResNeSt depth should be in [50, 101, 152, 200]
+        ResNeSt(depth=18)
+
+    # Test ResNeSt with radix 2, reduction_factor 4
+    model = ResNeSt(
+        depth=50, radix=2, reduction_factor=4, out_indices=(0, 1, 2, 3))
+    model.init_weights()
+    model.train()
+
+    imgs = torch.randn(2, 3, 224, 224)
+    feat = model(imgs)
+    assert len(feat) == 4
+    assert feat[0].shape == torch.Size([2, 256, 56, 56])
+    assert feat[1].shape == torch.Size([2, 512, 28, 28])
+    assert feat[2].shape == torch.Size([2, 1024, 14, 14])
+    assert feat[3].shape == torch.Size([2, 2048, 7, 7])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_resnet.py b/mmsegmentation/tests/test_models/test_backbones/test_resnet.py
new file mode 100644
index 0000000..f2f24ba
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_resnet.py
@@ -0,0 +1,575 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+from mmcv.ops import DeformConv2dPack
+from mmengine.utils.dl_utils.parrots_wrapper import _BatchNorm
+from torch.nn.modules import AvgPool2d, GroupNorm
+
+from mmseg.models.backbones import ResNet, ResNetV1d
+from mmseg.models.backbones.resnet import BasicBlock, Bottleneck
+from mmseg.models.utils import ResLayer
+from .utils import all_zeros, check_norm_state, is_block, is_norm
+
+
+def test_resnet_basic_block():
+    with pytest.raises(AssertionError):
+        # Not implemented yet.
+        dcn = dict(type='DCN', deform_groups=1, fallback_on_stride=False)
+        BasicBlock(64, 64, dcn=dcn)
+
+    with pytest.raises(AssertionError):
+        # Not implemented yet.
+        plugins = [
+            dict(
+                cfg=dict(type='ContextBlock', ratio=1. / 16),
+                position='after_conv3')
+        ]
+        BasicBlock(64, 64, plugins=plugins)
+
+    with pytest.raises(AssertionError):
+        # Not implemented yet
+        plugins = [
+            dict(
+                cfg=dict(
+                    type='GeneralizedAttention',
+                    spatial_range=-1,
+                    num_heads=8,
+                    attention_type='0010',
+                    kv_stride=2),
+                position='after_conv2')
+        ]
+        BasicBlock(64, 64, plugins=plugins)
+
+    # Test BasicBlock with checkpoint forward
+    block = BasicBlock(16, 16, with_cp=True)
+    assert block.with_cp
+    x = torch.randn(1, 16, 28, 28)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([1, 16, 28, 28])
+
+    # test BasicBlock structure and forward
+    block = BasicBlock(32, 32)
+    assert block.conv1.in_channels == 32
+    assert block.conv1.out_channels == 32
+    assert block.conv1.kernel_size == (3, 3)
+    assert block.conv2.in_channels == 32
+    assert block.conv2.out_channels == 32
+    assert block.conv2.kernel_size == (3, 3)
+    x = torch.randn(1, 32, 28, 28)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([1, 32, 28, 28])
+
+
+def test_resnet_bottleneck():
+    with pytest.raises(AssertionError):
+        # Style must be in ['pytorch', 'caffe']
+        Bottleneck(64, 64, style='tensorflow')
+
+    with pytest.raises(AssertionError):
+        # Allowed positions are 'after_conv1', 'after_conv2', 'after_conv3'
+        plugins = [
+            dict(
+                cfg=dict(type='ContextBlock', ratio=1. / 16),
+                position='after_conv4')
+        ]
+        Bottleneck(64, 16, plugins=plugins)
+
+    with pytest.raises(AssertionError):
+        # Need to specify different postfix to avoid duplicate plugin name
+        plugins = [
+            dict(
+                cfg=dict(type='ContextBlock', ratio=1. / 16),
+                position='after_conv3'),
+            dict(
+                cfg=dict(type='ContextBlock', ratio=1. / 16),
+                position='after_conv3')
+        ]
+        Bottleneck(64, 16, plugins=plugins)
+
+    with pytest.raises(KeyError):
+        # Plugin type is not supported
+        plugins = [dict(cfg=dict(type='WrongPlugin'), position='after_conv3')]
+        Bottleneck(64, 16, plugins=plugins)
+
+    # Test Bottleneck with checkpoint forward
+    block = Bottleneck(64, 16, with_cp=True)
+    assert block.with_cp
+    x = torch.randn(1, 64, 56, 56)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([1, 64, 56, 56])
+
+    # Test Bottleneck style
+    block = Bottleneck(64, 64, stride=2, style='pytorch')
+    assert block.conv1.stride == (1, 1)
+    assert block.conv2.stride == (2, 2)
+    block = Bottleneck(64, 64, stride=2, style='caffe')
+    assert block.conv1.stride == (2, 2)
+    assert block.conv2.stride == (1, 1)
+
+    # Test Bottleneck DCN
+    dcn = dict(type='DCN', deform_groups=1, fallback_on_stride=False)
+    with pytest.raises(AssertionError):
+        Bottleneck(64, 64, dcn=dcn, conv_cfg=dict(type='Conv'))
+    block = Bottleneck(64, 64, dcn=dcn)
+    assert isinstance(block.conv2, DeformConv2dPack)
+
+    # Test Bottleneck forward
+    block = Bottleneck(64, 16)
+    x = torch.randn(1, 64, 56, 56)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([1, 64, 56, 56])
+
+    # Test Bottleneck with 1 ContextBlock after conv3
+    plugins = [
+        dict(
+            cfg=dict(type='ContextBlock', ratio=1. / 16),
+            position='after_conv3')
+    ]
+    block = Bottleneck(64, 16, plugins=plugins)
+    assert block.context_block.in_channels == 64
+    x = torch.randn(1, 64, 56, 56)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([1, 64, 56, 56])
+
+    # Test Bottleneck with 1 GeneralizedAttention after conv2
+    plugins = [
+        dict(
+            cfg=dict(
+                type='GeneralizedAttention',
+                spatial_range=-1,
+                num_heads=8,
+                attention_type='0010',
+                kv_stride=2),
+            position='after_conv2')
+    ]
+    block = Bottleneck(64, 16, plugins=plugins)
+    assert block.gen_attention_block.in_channels == 16
+    x = torch.randn(1, 64, 56, 56)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([1, 64, 56, 56])
+
+    # Test Bottleneck with 1 GeneralizedAttention after conv2, 1 NonLocal2d
+    # after conv2, 1 ContextBlock after conv3
+    plugins = [
+        dict(
+            cfg=dict(
+                type='GeneralizedAttention',
+                spatial_range=-1,
+                num_heads=8,
+                attention_type='0010',
+                kv_stride=2),
+            position='after_conv2'),
+        dict(cfg=dict(type='NonLocal2d'), position='after_conv2'),
+        dict(
+            cfg=dict(type='ContextBlock', ratio=1. / 16),
+            position='after_conv3')
+    ]
+    block = Bottleneck(64, 16, plugins=plugins)
+    assert block.gen_attention_block.in_channels == 16
+    assert block.nonlocal_block.in_channels == 16
+    assert block.context_block.in_channels == 64
+    x = torch.randn(1, 64, 56, 56)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([1, 64, 56, 56])
+
+    # Test Bottleneck with 1 ContextBlock after conv2, 2 ContextBlock after
+    # conv3
+    plugins = [
+        dict(
+            cfg=dict(type='ContextBlock', ratio=1. / 16, postfix=1),
+            position='after_conv2'),
+        dict(
+            cfg=dict(type='ContextBlock', ratio=1. / 16, postfix=2),
+            position='after_conv3'),
+        dict(
+            cfg=dict(type='ContextBlock', ratio=1. / 16, postfix=3),
+            position='after_conv3')
+    ]
+    block = Bottleneck(64, 16, plugins=plugins)
+    assert block.context_block1.in_channels == 16
+    assert block.context_block2.in_channels == 64
+    assert block.context_block3.in_channels == 64
+    x = torch.randn(1, 64, 56, 56)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([1, 64, 56, 56])
+
+
+def test_resnet_res_layer():
+    # Test ResLayer of 3 Bottleneck w\o downsample
+    layer = ResLayer(Bottleneck, 64, 16, 3)
+    assert len(layer) == 3
+    assert layer[0].conv1.in_channels == 64
+    assert layer[0].conv1.out_channels == 16
+    for i in range(1, len(layer)):
+        assert layer[i].conv1.in_channels == 64
+        assert layer[i].conv1.out_channels == 16
+    for i in range(len(layer)):
+        assert layer[i].downsample is None
+    x = torch.randn(1, 64, 56, 56)
+    x_out = layer(x)
+    assert x_out.shape == torch.Size([1, 64, 56, 56])
+
+    # Test ResLayer of 3 Bottleneck with downsample
+    layer = ResLayer(Bottleneck, 64, 64, 3)
+    assert layer[0].downsample[0].out_channels == 256
+    for i in range(1, len(layer)):
+        assert layer[i].downsample is None
+    x = torch.randn(1, 64, 56, 56)
+    x_out = layer(x)
+    assert x_out.shape == torch.Size([1, 256, 56, 56])
+
+    # Test ResLayer of 3 Bottleneck with stride=2
+    layer = ResLayer(Bottleneck, 64, 64, 3, stride=2)
+    assert layer[0].downsample[0].out_channels == 256
+    assert layer[0].downsample[0].stride == (2, 2)
+    for i in range(1, len(layer)):
+        assert layer[i].downsample is None
+    x = torch.randn(1, 64, 56, 56)
+    x_out = layer(x)
+    assert x_out.shape == torch.Size([1, 256, 28, 28])
+
+    # Test ResLayer of 3 Bottleneck with stride=2 and average downsample
+    layer = ResLayer(Bottleneck, 64, 64, 3, stride=2, avg_down=True)
+    assert isinstance(layer[0].downsample[0], AvgPool2d)
+    assert layer[0].downsample[1].out_channels == 256
+    assert layer[0].downsample[1].stride == (1, 1)
+    for i in range(1, len(layer)):
+        assert layer[i].downsample is None
+    x = torch.randn(1, 64, 56, 56)
+    x_out = layer(x)
+    assert x_out.shape == torch.Size([1, 256, 28, 28])
+
+    # Test ResLayer of 3 Bottleneck with dilation=2
+    layer = ResLayer(Bottleneck, 64, 16, 3, dilation=2)
+    for i in range(len(layer)):
+        assert layer[i].conv2.dilation == (2, 2)
+    x = torch.randn(1, 64, 56, 56)
+    x_out = layer(x)
+    assert x_out.shape == torch.Size([1, 64, 56, 56])
+
+    # Test ResLayer of 3 Bottleneck with dilation=2, contract_dilation=True
+    layer = ResLayer(Bottleneck, 64, 16, 3, dilation=2, contract_dilation=True)
+    assert layer[0].conv2.dilation == (1, 1)
+    for i in range(1, len(layer)):
+        assert layer[i].conv2.dilation == (2, 2)
+    x = torch.randn(1, 64, 56, 56)
+    x_out = layer(x)
+    assert x_out.shape == torch.Size([1, 64, 56, 56])
+
+    # Test ResLayer of 3 Bottleneck with dilation=2, multi_grid
+    layer = ResLayer(Bottleneck, 64, 16, 3, dilation=2, multi_grid=(1, 2, 4))
+    assert layer[0].conv2.dilation == (1, 1)
+    assert layer[1].conv2.dilation == (2, 2)
+    assert layer[2].conv2.dilation == (4, 4)
+    x = torch.randn(1, 64, 56, 56)
+    x_out = layer(x)
+    assert x_out.shape == torch.Size([1, 64, 56, 56])
+
+
+def test_resnet_backbone():
+    """Test resnet backbone."""
+    with pytest.raises(KeyError):
+        # ResNet depth should be in [18, 34, 50, 101, 152]
+        ResNet(20)
+
+    with pytest.raises(AssertionError):
+        # In ResNet: 1 <= num_stages <= 4
+        ResNet(50, num_stages=0)
+
+    with pytest.raises(AssertionError):
+        # len(stage_with_dcn) == num_stages
+        dcn = dict(type='DCN', deform_groups=1, fallback_on_stride=False)
+        ResNet(50, dcn=dcn, stage_with_dcn=(True, ))
+
+    with pytest.raises(AssertionError):
+        # len(stage_with_plugin) == num_stages
+        plugins = [
+            dict(
+                cfg=dict(type='ContextBlock', ratio=1. / 16),
+                stages=(False, True, True),
+                position='after_conv3')
+        ]
+        ResNet(50, plugins=plugins)
+
+    with pytest.raises(AssertionError):
+        # In ResNet: 1 <= num_stages <= 4
+        ResNet(18, num_stages=5)
+
+    with pytest.raises(AssertionError):
+        # len(strides) == len(dilations) == num_stages
+        ResNet(18, strides=(1, ), dilations=(1, 1), num_stages=3)
+
+    with pytest.raises(TypeError):
+        # pretrained must be a string path
+        model = ResNet(18, pretrained=0)
+        model.init_weights()
+
+    with pytest.raises(AssertionError):
+        # Style must be in ['pytorch', 'caffe']
+        ResNet(50, style='tensorflow')
+
+    # Test ResNet18 norm_eval=True
+    model = ResNet(18, norm_eval=True)
+    model.init_weights()
+    model.train()
+    assert check_norm_state(model.modules(), False)
+
+    # Test ResNet18 with torchvision pretrained weight
+    model = ResNet(
+        depth=18, norm_eval=True, pretrained='torchvision://resnet18')
+    model.init_weights()
+    model.train()
+    assert check_norm_state(model.modules(), False)
+
+    # Test ResNet18 with first stage frozen
+    frozen_stages = 1
+    model = ResNet(18, frozen_stages=frozen_stages)
+    model.init_weights()
+    model.train()
+    assert model.norm1.training is False
+    for layer in [model.conv1, model.norm1]:
+        for param in layer.parameters():
+            assert param.requires_grad is False
+    for i in range(1, frozen_stages + 1):
+        layer = getattr(model, f'layer{i}')
+        for mod in layer.modules():
+            if isinstance(mod, _BatchNorm):
+                assert mod.training is False
+        for param in layer.parameters():
+            assert param.requires_grad is False
+
+    # Test ResNet18V1d with first stage frozen
+    model = ResNetV1d(depth=18, frozen_stages=frozen_stages)
+    assert len(model.stem) == 9
+    model.init_weights()
+    model.train()
+    check_norm_state(model.stem, False)
+    for param in model.stem.parameters():
+        assert param.requires_grad is False
+    for i in range(1, frozen_stages + 1):
+        layer = getattr(model, f'layer{i}')
+        for mod in layer.modules():
+            if isinstance(mod, _BatchNorm):
+                assert mod.training is False
+        for param in layer.parameters():
+            assert param.requires_grad is False
+
+    # Test ResNet18 forward
+    model = ResNet(18)
+    model.init_weights()
+    model.train()
+
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert len(feat) == 4
+    assert feat[0].shape == torch.Size([1, 64, 56, 56])
+    assert feat[1].shape == torch.Size([1, 128, 28, 28])
+    assert feat[2].shape == torch.Size([1, 256, 14, 14])
+    assert feat[3].shape == torch.Size([1, 512, 7, 7])
+
+    # Test ResNet18 with BatchNorm forward
+    model = ResNet(18)
+    for m in model.modules():
+        if is_norm(m):
+            assert isinstance(m, _BatchNorm)
+    model.init_weights()
+    model.train()
+
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert len(feat) == 4
+    assert feat[0].shape == torch.Size([1, 64, 56, 56])
+    assert feat[1].shape == torch.Size([1, 128, 28, 28])
+    assert feat[2].shape == torch.Size([1, 256, 14, 14])
+    assert feat[3].shape == torch.Size([1, 512, 7, 7])
+
+    # Test ResNet18 with layers 1, 2, 3 out forward
+    model = ResNet(18, out_indices=(0, 1, 2))
+    model.init_weights()
+    model.train()
+
+    imgs = torch.randn(1, 3, 112, 112)
+    feat = model(imgs)
+    assert len(feat) == 3
+    assert feat[0].shape == torch.Size([1, 64, 28, 28])
+    assert feat[1].shape == torch.Size([1, 128, 14, 14])
+    assert feat[2].shape == torch.Size([1, 256, 7, 7])
+
+    # Test ResNet18 with checkpoint forward
+    model = ResNet(18, with_cp=True)
+    for m in model.modules():
+        if is_block(m):
+            assert m.with_cp
+    model.init_weights()
+    model.train()
+
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert len(feat) == 4
+    assert feat[0].shape == torch.Size([1, 64, 56, 56])
+    assert feat[1].shape == torch.Size([1, 128, 28, 28])
+    assert feat[2].shape == torch.Size([1, 256, 14, 14])
+    assert feat[3].shape == torch.Size([1, 512, 7, 7])
+
+    # Test ResNet18 with checkpoint forward
+    model = ResNet(18, with_cp=True)
+    for m in model.modules():
+        if is_block(m):
+            assert m.with_cp
+    model.init_weights()
+    model.train()
+
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert len(feat) == 4
+    assert feat[0].shape == torch.Size([1, 64, 56, 56])
+    assert feat[1].shape == torch.Size([1, 128, 28, 28])
+    assert feat[2].shape == torch.Size([1, 256, 14, 14])
+    assert feat[3].shape == torch.Size([1, 512, 7, 7])
+
+    # Test ResNet18 with GroupNorm forward
+    model = ResNet(
+        18, norm_cfg=dict(type='GN', num_groups=32, requires_grad=True))
+    for m in model.modules():
+        if is_norm(m):
+            assert isinstance(m, GroupNorm)
+    model.init_weights()
+    model.train()
+
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert len(feat) == 4
+    assert feat[0].shape == torch.Size([1, 64, 56, 56])
+    assert feat[1].shape == torch.Size([1, 128, 28, 28])
+    assert feat[2].shape == torch.Size([1, 256, 14, 14])
+    assert feat[3].shape == torch.Size([1, 512, 7, 7])
+
+    # Test ResNet50 with 1 GeneralizedAttention after conv2, 1 NonLocal2d
+    # after conv2, 1 ContextBlock after conv3 in layers 2, 3, 4
+    plugins = [
+        dict(
+            cfg=dict(
+                type='GeneralizedAttention',
+                spatial_range=-1,
+                num_heads=8,
+                attention_type='0010',
+                kv_stride=2),
+            stages=(False, True, True, True),
+            position='after_conv2'),
+        dict(cfg=dict(type='NonLocal2d'), position='after_conv2'),
+        dict(
+            cfg=dict(type='ContextBlock', ratio=1. / 16),
+            stages=(False, True, True, False),
+            position='after_conv3')
+    ]
+    model = ResNet(50, plugins=plugins)
+    for m in model.layer1.modules():
+        if is_block(m):
+            assert not hasattr(m, 'context_block')
+            assert not hasattr(m, 'gen_attention_block')
+            assert m.nonlocal_block.in_channels == 64
+    for m in model.layer2.modules():
+        if is_block(m):
+            assert m.nonlocal_block.in_channels == 128
+            assert m.gen_attention_block.in_channels == 128
+            assert m.context_block.in_channels == 512
+
+    for m in model.layer3.modules():
+        if is_block(m):
+            assert m.nonlocal_block.in_channels == 256
+            assert m.gen_attention_block.in_channels == 256
+            assert m.context_block.in_channels == 1024
+
+    for m in model.layer4.modules():
+        if is_block(m):
+            assert m.nonlocal_block.in_channels == 512
+            assert m.gen_attention_block.in_channels == 512
+            assert not hasattr(m, 'context_block')
+    model.init_weights()
+    model.train()
+
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert len(feat) == 4
+    assert feat[0].shape == torch.Size([1, 256, 56, 56])
+    assert feat[1].shape == torch.Size([1, 512, 28, 28])
+    assert feat[2].shape == torch.Size([1, 1024, 14, 14])
+    assert feat[3].shape == torch.Size([1, 2048, 7, 7])
+
+    # Test ResNet50 with 1 ContextBlock after conv2, 1 ContextBlock after
+    # conv3 in layers 2, 3, 4
+    plugins = [
+        dict(
+            cfg=dict(type='ContextBlock', ratio=1. / 16, postfix=1),
+            stages=(False, True, True, False),
+            position='after_conv3'),
+        dict(
+            cfg=dict(type='ContextBlock', ratio=1. / 16, postfix=2),
+            stages=(False, True, True, False),
+            position='after_conv3')
+    ]
+
+    model = ResNet(50, plugins=plugins)
+    for m in model.layer1.modules():
+        if is_block(m):
+            assert not hasattr(m, 'context_block')
+            assert not hasattr(m, 'context_block1')
+            assert not hasattr(m, 'context_block2')
+    for m in model.layer2.modules():
+        if is_block(m):
+            assert not hasattr(m, 'context_block')
+            assert m.context_block1.in_channels == 512
+            assert m.context_block2.in_channels == 512
+
+    for m in model.layer3.modules():
+        if is_block(m):
+            assert not hasattr(m, 'context_block')
+            assert m.context_block1.in_channels == 1024
+            assert m.context_block2.in_channels == 1024
+
+    for m in model.layer4.modules():
+        if is_block(m):
+            assert not hasattr(m, 'context_block')
+            assert not hasattr(m, 'context_block1')
+            assert not hasattr(m, 'context_block2')
+    model.init_weights()
+    model.train()
+
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert len(feat) == 4
+    assert feat[0].shape == torch.Size([1, 256, 56, 56])
+    assert feat[1].shape == torch.Size([1, 512, 28, 28])
+    assert feat[2].shape == torch.Size([1, 1024, 14, 14])
+    assert feat[3].shape == torch.Size([1, 2048, 7, 7])
+
+    # Test ResNet18 zero initialization of residual
+    model = ResNet(18, zero_init_residual=True)
+    model.init_weights()
+    for m in model.modules():
+        if isinstance(m, Bottleneck):
+            assert all_zeros(m.norm3)
+        elif isinstance(m, BasicBlock):
+            assert all_zeros(m.norm2)
+    model.train()
+
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert len(feat) == 4
+    assert feat[0].shape == torch.Size([1, 64, 56, 56])
+    assert feat[1].shape == torch.Size([1, 128, 28, 28])
+    assert feat[2].shape == torch.Size([1, 256, 14, 14])
+    assert feat[3].shape == torch.Size([1, 512, 7, 7])
+
+    # Test ResNetV1d forward
+    model = ResNetV1d(depth=18)
+    model.init_weights()
+    model.train()
+
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert len(feat) == 4
+    assert feat[0].shape == torch.Size([1, 64, 56, 56])
+    assert feat[1].shape == torch.Size([1, 128, 28, 28])
+    assert feat[2].shape == torch.Size([1, 256, 14, 14])
+    assert feat[3].shape == torch.Size([1, 512, 7, 7])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_resnext.py b/mmsegmentation/tests/test_models/test_backbones/test_resnext.py
new file mode 100644
index 0000000..2aecaf0
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_resnext.py
@@ -0,0 +1,62 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.backbones import ResNeXt
+from mmseg.models.backbones.resnext import Bottleneck as BottleneckX
+from .utils import is_block
+
+
+def test_renext_bottleneck():
+    with pytest.raises(AssertionError):
+        # Style must be in ['pytorch', 'caffe']
+        BottleneckX(64, 64, groups=32, base_width=4, style='tensorflow')
+
+    # Test ResNeXt Bottleneck structure
+    block = BottleneckX(
+        64, 64, groups=32, base_width=4, stride=2, style='pytorch')
+    assert block.conv2.stride == (2, 2)
+    assert block.conv2.groups == 32
+    assert block.conv2.out_channels == 128
+
+    # Test ResNeXt Bottleneck with DCN
+    dcn = dict(type='DCN', deform_groups=1, fallback_on_stride=False)
+    with pytest.raises(AssertionError):
+        # conv_cfg must be None if dcn is not None
+        BottleneckX(
+            64,
+            64,
+            groups=32,
+            base_width=4,
+            dcn=dcn,
+            conv_cfg=dict(type='Conv'))
+    BottleneckX(64, 64, dcn=dcn)
+
+    # Test ResNeXt Bottleneck forward
+    block = BottleneckX(64, 16, groups=32, base_width=4)
+    x = torch.randn(1, 64, 56, 56)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([1, 64, 56, 56])
+
+
+def test_resnext_backbone():
+    with pytest.raises(KeyError):
+        # ResNeXt depth should be in [50, 101, 152]
+        ResNeXt(depth=18)
+
+    # Test ResNeXt with group 32, base_width 4
+    model = ResNeXt(depth=50, groups=32, base_width=4)
+    print(model)
+    for m in model.modules():
+        if is_block(m):
+            assert m.conv2.groups == 32
+    model.init_weights()
+    model.train()
+
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert len(feat) == 4
+    assert feat[0].shape == torch.Size([1, 256, 56, 56])
+    assert feat[1].shape == torch.Size([1, 512, 28, 28])
+    assert feat[2].shape == torch.Size([1, 1024, 14, 14])
+    assert feat[3].shape == torch.Size([1, 2048, 7, 7])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_stdc.py b/mmsegmentation/tests/test_models/test_backbones/test_stdc.py
new file mode 100644
index 0000000..1e3862b
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_stdc.py
@@ -0,0 +1,131 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.backbones import STDCContextPathNet
+from mmseg.models.backbones.stdc import (AttentionRefinementModule,
+                                         FeatureFusionModule, STDCModule,
+                                         STDCNet)
+
+
+def test_stdc_context_path_net():
+    # Test STDCContextPathNet Standard Forward
+    model = STDCContextPathNet(
+        backbone_cfg=dict(
+            type='STDCNet',
+            stdc_type='STDCNet1',
+            in_channels=3,
+            channels=(32, 64, 256, 512, 1024),
+            bottleneck_type='cat',
+            num_convs=4,
+            norm_cfg=dict(type='BN', requires_grad=True),
+            act_cfg=dict(type='ReLU'),
+            with_final_conv=True),
+        last_in_channels=(1024, 512),
+        out_channels=128,
+        ffm_cfg=dict(in_channels=384, out_channels=256, scale_factor=4))
+    model.init_weights()
+    model.train()
+    batch_size = 2
+    imgs = torch.randn(batch_size, 3, 256, 512)
+    feat = model(imgs)
+
+    assert len(feat) == 4
+    # output for segment Head
+    assert feat[0].shape == torch.Size([batch_size, 256, 32, 64])
+    # for auxiliary head 1
+    assert feat[1].shape == torch.Size([batch_size, 128, 16, 32])
+    # for auxiliary head 2
+    assert feat[2].shape == torch.Size([batch_size, 128, 32, 64])
+    # for auxiliary head 3
+    assert feat[3].shape == torch.Size([batch_size, 256, 32, 64])
+
+    # Test input with rare shape
+    batch_size = 2
+    imgs = torch.randn(batch_size, 3, 527, 279)
+    model = STDCContextPathNet(
+        backbone_cfg=dict(
+            type='STDCNet',
+            stdc_type='STDCNet1',
+            in_channels=3,
+            channels=(32, 64, 256, 512, 1024),
+            bottleneck_type='add',
+            num_convs=4,
+            norm_cfg=dict(type='BN', requires_grad=True),
+            act_cfg=dict(type='ReLU'),
+            with_final_conv=False),
+        last_in_channels=(1024, 512),
+        out_channels=128,
+        ffm_cfg=dict(in_channels=384, out_channels=256, scale_factor=4))
+    model.init_weights()
+    model.train()
+    feat = model(imgs)
+    assert len(feat) == 4
+
+
+def test_stdcnet():
+    with pytest.raises(AssertionError):
+        # STDC backbone constraints.
+        STDCNet(
+            stdc_type='STDCNet3',
+            in_channels=3,
+            channels=(32, 64, 256, 512, 1024),
+            bottleneck_type='cat',
+            num_convs=4,
+            norm_cfg=dict(type='BN', requires_grad=True),
+            act_cfg=dict(type='ReLU'),
+            with_final_conv=False)
+
+    with pytest.raises(AssertionError):
+        # STDC bottleneck type constraints.
+        STDCNet(
+            stdc_type='STDCNet1',
+            in_channels=3,
+            channels=(32, 64, 256, 512, 1024),
+            bottleneck_type='dog',
+            num_convs=4,
+            norm_cfg=dict(type='BN', requires_grad=True),
+            act_cfg=dict(type='ReLU'),
+            with_final_conv=False)
+
+    with pytest.raises(AssertionError):
+        # STDC channels length constraints.
+        STDCNet(
+            stdc_type='STDCNet1',
+            in_channels=3,
+            channels=(16, 32, 64, 256, 512, 1024),
+            bottleneck_type='cat',
+            num_convs=4,
+            norm_cfg=dict(type='BN', requires_grad=True),
+            act_cfg=dict(type='ReLU'),
+            with_final_conv=False)
+
+
+def test_feature_fusion_module():
+    x_ffm = FeatureFusionModule(in_channels=64, out_channels=32)
+    assert x_ffm.conv0.in_channels == 64
+    assert x_ffm.attention[1].in_channels == 32
+    assert x_ffm.attention[2].in_channels == 8
+    assert x_ffm.attention[2].out_channels == 32
+    x1 = torch.randn(2, 32, 32, 64)
+    x2 = torch.randn(2, 32, 32, 64)
+    x_out = x_ffm(x1, x2)
+    assert x_out.shape == torch.Size([2, 32, 32, 64])
+
+
+def test_attention_refinement_module():
+    x_arm = AttentionRefinementModule(128, 32)
+    assert x_arm.conv_layer.in_channels == 128
+    assert x_arm.atten_conv_layer[1].conv.out_channels == 32
+    x = torch.randn(2, 128, 32, 64)
+    x_out = x_arm(x)
+    assert x_out.shape == torch.Size([2, 32, 32, 64])
+
+
+def test_stdc_module():
+    x_stdc = STDCModule(in_channels=32, out_channels=32, stride=4)
+    assert x_stdc.layers[0].conv.in_channels == 32
+    assert x_stdc.layers[3].conv.out_channels == 4
+    x = torch.randn(2, 32, 32, 64)
+    x_out = x_stdc(x)
+    assert x_out.shape == torch.Size([2, 32, 32, 64])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_swin.py b/mmsegmentation/tests/test_models/test_backbones/test_swin.py
new file mode 100644
index 0000000..8d14d47
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_swin.py
@@ -0,0 +1,100 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.backbones.swin import SwinBlock, SwinTransformer
+
+
+def test_swin_block():
+    # test SwinBlock structure and forward
+    block = SwinBlock(embed_dims=32, num_heads=4, feedforward_channels=128)
+    assert block.ffn.embed_dims == 32
+    assert block.attn.w_msa.num_heads == 4
+    assert block.ffn.feedforward_channels == 128
+    x = torch.randn(1, 56 * 56, 32)
+    x_out = block(x, (56, 56))
+    assert x_out.shape == torch.Size([1, 56 * 56, 32])
+
+    # Test BasicBlock with checkpoint forward
+    block = SwinBlock(
+        embed_dims=64, num_heads=4, feedforward_channels=256, with_cp=True)
+    assert block.with_cp
+    x = torch.randn(1, 56 * 56, 64)
+    x_out = block(x, (56, 56))
+    assert x_out.shape == torch.Size([1, 56 * 56, 64])
+
+
+def test_swin_transformer():
+    """Test Swin Transformer backbone."""
+
+    with pytest.raises(TypeError):
+        # Pretrained arg must be str or None.
+        SwinTransformer(pretrained=123)
+
+    with pytest.raises(AssertionError):
+        # Because swin uses non-overlapping patch embed, so the stride of patch
+        # embed must be equal to patch size.
+        SwinTransformer(strides=(2, 2, 2, 2), patch_size=4)
+
+    # test pretrained image size
+    with pytest.raises(AssertionError):
+        SwinTransformer(pretrain_img_size=(112, 112, 112))
+
+    # Test absolute position embedding
+    temp = torch.randn((1, 3, 112, 112))
+    model = SwinTransformer(pretrain_img_size=112, use_abs_pos_embed=True)
+    model.init_weights()
+    model(temp)
+
+    # Test patch norm
+    model = SwinTransformer(patch_norm=False)
+    model(temp)
+
+    # Test normal inference
+    temp = torch.randn((1, 3, 256, 256))
+    model = SwinTransformer()
+    outs = model(temp)
+    assert outs[0].shape == (1, 96, 64, 64)
+    assert outs[1].shape == (1, 192, 32, 32)
+    assert outs[2].shape == (1, 384, 16, 16)
+    assert outs[3].shape == (1, 768, 8, 8)
+
+    # Test abnormal inference size
+    temp = torch.randn((1, 3, 255, 255))
+    model = SwinTransformer()
+    outs = model(temp)
+    assert outs[0].shape == (1, 96, 64, 64)
+    assert outs[1].shape == (1, 192, 32, 32)
+    assert outs[2].shape == (1, 384, 16, 16)
+    assert outs[3].shape == (1, 768, 8, 8)
+
+    # Test abnormal inference size
+    temp = torch.randn((1, 3, 112, 137))
+    model = SwinTransformer()
+    outs = model(temp)
+    assert outs[0].shape == (1, 96, 28, 35)
+    assert outs[1].shape == (1, 192, 14, 18)
+    assert outs[2].shape == (1, 384, 7, 9)
+    assert outs[3].shape == (1, 768, 4, 5)
+
+    # Test frozen
+    model = SwinTransformer(frozen_stages=4)
+    model.train()
+    for p in model.parameters():
+        assert not p.requires_grad
+
+    # Test absolute position embedding frozen
+    model = SwinTransformer(frozen_stages=4, use_abs_pos_embed=True)
+    model.train()
+    for p in model.parameters():
+        assert not p.requires_grad
+
+    # Test Swin with checkpoint forward
+    temp = torch.randn((1, 3, 56, 56))
+    model = SwinTransformer(with_cp=True)
+    for m in model.modules():
+        if isinstance(m, SwinBlock):
+            assert m.with_cp
+    model.init_weights()
+    model.train()
+    model(temp)
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_timm_backbone.py b/mmsegmentation/tests/test_models/test_backbones/test_timm_backbone.py
new file mode 100644
index 0000000..d9a50cf
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_timm_backbone.py
@@ -0,0 +1,133 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.backbones import TIMMBackbone
+from .utils import check_norm_state
+
+
+def test_timm_backbone():
+    with pytest.raises(TypeError):
+        # pretrained must be a string path
+        model = TIMMBackbone()
+        model.init_weights(pretrained=0)
+
+    # Test different norm_layer, can be: 'SyncBN', 'BN2d', 'GN', 'LN', 'IN'
+    # Test resnet18 from timm, norm_layer='BN2d'
+    model = TIMMBackbone(
+        model_name='resnet18',
+        features_only=True,
+        pretrained=False,
+        output_stride=32,
+        norm_layer='BN2d')
+
+    # Test resnet18 from timm, norm_layer='SyncBN'
+    model = TIMMBackbone(
+        model_name='resnet18',
+        features_only=True,
+        pretrained=False,
+        output_stride=32,
+        norm_layer='SyncBN2d')
+
+    # Test resnet18 from timm, features_only=True, output_stride=32
+    model = TIMMBackbone(
+        model_name='resnet18',
+        features_only=True,
+        pretrained=False,
+        output_stride=32)
+    model.init_weights()
+    model.train()
+    assert check_norm_state(model.modules(), True)
+
+    imgs = torch.randn(1, 3, 224, 224)
+    feats = model(imgs)
+    feats = [feat.shape for feat in feats]
+    assert len(feats) == 5
+    assert feats[0] == torch.Size((1, 64, 112, 112))
+    assert feats[1] == torch.Size((1, 64, 56, 56))
+    assert feats[2] == torch.Size((1, 128, 28, 28))
+    assert feats[3] == torch.Size((1, 256, 14, 14))
+    assert feats[4] == torch.Size((1, 512, 7, 7))
+
+    # Test resnet18 from timm, features_only=True, output_stride=16
+    model = TIMMBackbone(
+        model_name='resnet18',
+        features_only=True,
+        pretrained=False,
+        output_stride=16)
+    imgs = torch.randn(1, 3, 224, 224)
+    feats = model(imgs)
+    feats = [feat.shape for feat in feats]
+    assert len(feats) == 5
+    assert feats[0] == torch.Size((1, 64, 112, 112))
+    assert feats[1] == torch.Size((1, 64, 56, 56))
+    assert feats[2] == torch.Size((1, 128, 28, 28))
+    assert feats[3] == torch.Size((1, 256, 14, 14))
+    assert feats[4] == torch.Size((1, 512, 14, 14))
+
+    # Test resnet18 from timm, features_only=True, output_stride=8
+    model = TIMMBackbone(
+        model_name='resnet18',
+        features_only=True,
+        pretrained=False,
+        output_stride=8)
+    imgs = torch.randn(1, 3, 224, 224)
+    feats = model(imgs)
+    feats = [feat.shape for feat in feats]
+    assert len(feats) == 5
+    assert feats[0] == torch.Size((1, 64, 112, 112))
+    assert feats[1] == torch.Size((1, 64, 56, 56))
+    assert feats[2] == torch.Size((1, 128, 28, 28))
+    assert feats[3] == torch.Size((1, 256, 28, 28))
+    assert feats[4] == torch.Size((1, 512, 28, 28))
+
+    # Test efficientnet_b1 with pretrained weights
+    model = TIMMBackbone(model_name='efficientnet_b1', pretrained=True)
+
+    # Test resnetv2_50x1_bitm from timm, features_only=True, output_stride=8
+    model = TIMMBackbone(
+        model_name='resnetv2_50x1_bitm',
+        features_only=True,
+        pretrained=False,
+        output_stride=8)
+    imgs = torch.randn(1, 3, 8, 8)
+    feats = model(imgs)
+    feats = [feat.shape for feat in feats]
+    assert len(feats) == 5
+    assert feats[0] == torch.Size((1, 64, 4, 4))
+    assert feats[1] == torch.Size((1, 256, 2, 2))
+    assert feats[2] == torch.Size((1, 512, 1, 1))
+    assert feats[3] == torch.Size((1, 1024, 1, 1))
+    assert feats[4] == torch.Size((1, 2048, 1, 1))
+
+    # Test resnetv2_50x3_bitm from timm, features_only=True, output_stride=8
+    model = TIMMBackbone(
+        model_name='resnetv2_50x3_bitm',
+        features_only=True,
+        pretrained=False,
+        output_stride=8)
+    imgs = torch.randn(1, 3, 8, 8)
+    feats = model(imgs)
+    feats = [feat.shape for feat in feats]
+    assert len(feats) == 5
+    assert feats[0] == torch.Size((1, 192, 4, 4))
+    assert feats[1] == torch.Size((1, 768, 2, 2))
+    assert feats[2] == torch.Size((1, 1536, 1, 1))
+    assert feats[3] == torch.Size((1, 3072, 1, 1))
+    assert feats[4] == torch.Size((1, 6144, 1, 1))
+
+    # Test resnetv2_101x1_bitm from timm, features_only=True, output_stride=8
+    model = TIMMBackbone(
+        model_name='resnetv2_101x1_bitm',
+        features_only=True,
+        pretrained=False,
+        output_stride=8)
+    imgs = torch.randn(1, 3, 8, 8)
+    feats = model(imgs)
+    feats = [feat.shape for feat in feats]
+    assert len(feats) == 5
+    assert feats[0] == torch.Size((1, 64, 4, 4))
+    assert feats[1] == torch.Size((1, 256, 2, 2))
+    assert feats[2] == torch.Size((1, 512, 1, 1))
+    assert feats[3] == torch.Size((1, 1024, 1, 1))
+    assert feats[4] == torch.Size((1, 2048, 1, 1))
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_twins.py b/mmsegmentation/tests/test_models/test_backbones/test_twins.py
new file mode 100644
index 0000000..aa3eaf9
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_twins.py
@@ -0,0 +1,171 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.backbones.twins import (PCPVT, SVT,
+                                          ConditionalPositionEncoding,
+                                          LocallyGroupedSelfAttention)
+
+
+def test_pcpvt():
+    # Test normal input
+    H, W = (224, 224)
+    temp = torch.randn((1, 3, H, W))
+    model = PCPVT(
+        embed_dims=[32, 64, 160, 256],
+        num_heads=[1, 2, 5, 8],
+        mlp_ratios=[8, 8, 4, 4],
+        qkv_bias=True,
+        depths=[3, 4, 6, 3],
+        sr_ratios=[8, 4, 2, 1],
+        norm_after_stage=False)
+    model.init_weights()
+    outs = model(temp)
+    assert outs[0].shape == (1, 32, H // 4, W // 4)
+    assert outs[1].shape == (1, 64, H // 8, W // 8)
+    assert outs[2].shape == (1, 160, H // 16, W // 16)
+    assert outs[3].shape == (1, 256, H // 32, W // 32)
+
+
+def test_svt():
+    # Test normal input
+    H, W = (224, 224)
+    temp = torch.randn((1, 3, H, W))
+    model = SVT(
+        embed_dims=[32, 64, 128],
+        num_heads=[1, 2, 4],
+        mlp_ratios=[4, 4, 4],
+        qkv_bias=False,
+        depths=[4, 4, 4],
+        windiow_sizes=[7, 7, 7],
+        norm_after_stage=True)
+
+    model.init_weights()
+    outs = model(temp)
+    assert outs[0].shape == (1, 32, H // 4, W // 4)
+    assert outs[1].shape == (1, 64, H // 8, W // 8)
+    assert outs[2].shape == (1, 128, H // 16, W // 16)
+
+
+def test_svt_init():
+    path = 'PATH_THAT_DO_NOT_EXIST'
+    # Test all combinations of pretrained and init_cfg
+    # pretrained=None, init_cfg=None
+    model = SVT(pretrained=None, init_cfg=None)
+    assert model.init_cfg is None
+    model.init_weights()
+
+    # pretrained=None
+    # init_cfg loads pretrain from an non-existent file
+    model = SVT(
+        pretrained=None, init_cfg=dict(type='Pretrained', checkpoint=path))
+    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
+    # Test loading a checkpoint from an non-existent file
+    with pytest.raises(OSError):
+        model.init_weights()
+
+    # pretrained=None
+    # init_cfg=123, whose type is unsupported
+    model = SVT(pretrained=None, init_cfg=123)
+    with pytest.raises(TypeError):
+        model.init_weights()
+
+    # pretrained loads pretrain from an non-existent file
+    # init_cfg=None
+    model = SVT(pretrained=path, init_cfg=None)
+    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
+    # Test loading a checkpoint from an non-existent file
+    with pytest.raises(OSError):
+        model.init_weights()
+
+    # pretrained loads pretrain from an non-existent file
+    # init_cfg loads pretrain from an non-existent file
+    with pytest.raises(AssertionError):
+        model = SVT(
+            pretrained=path, init_cfg=dict(type='Pretrained', checkpoint=path))
+    with pytest.raises(AssertionError):
+        model = SVT(pretrained=path, init_cfg=123)
+
+    # pretrain=123, whose type is unsupported
+    # init_cfg=None
+    with pytest.raises(TypeError):
+        model = SVT(pretrained=123, init_cfg=None)
+
+    # pretrain=123, whose type is unsupported
+    # init_cfg loads pretrain from an non-existent file
+    with pytest.raises(AssertionError):
+        model = SVT(
+            pretrained=123, init_cfg=dict(type='Pretrained', checkpoint=path))
+
+    # pretrain=123, whose type is unsupported
+    # init_cfg=123, whose type is unsupported
+    with pytest.raises(AssertionError):
+        model = SVT(pretrained=123, init_cfg=123)
+
+
+def test_pcpvt_init():
+    path = 'PATH_THAT_DO_NOT_EXIST'
+    # Test all combinations of pretrained and init_cfg
+    # pretrained=None, init_cfg=None
+    model = PCPVT(pretrained=None, init_cfg=None)
+    assert model.init_cfg is None
+    model.init_weights()
+
+    # pretrained=None
+    # init_cfg loads pretrain from an non-existent file
+    model = PCPVT(
+        pretrained=None, init_cfg=dict(type='Pretrained', checkpoint=path))
+    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
+    # Test loading a checkpoint from an non-existent file
+    with pytest.raises(OSError):
+        model.init_weights()
+
+    # pretrained=None
+    # init_cfg=123, whose type is unsupported
+    model = PCPVT(pretrained=None, init_cfg=123)
+    with pytest.raises(TypeError):
+        model.init_weights()
+
+    # pretrained loads pretrain from an non-existent file
+    # init_cfg=None
+    model = PCPVT(pretrained=path, init_cfg=None)
+    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
+    # Test loading a checkpoint from an non-existent file
+    with pytest.raises(OSError):
+        model.init_weights()
+
+    # pretrained loads pretrain from an non-existent file
+    # init_cfg loads pretrain from an non-existent file
+    with pytest.raises(AssertionError):
+        model = PCPVT(
+            pretrained=path, init_cfg=dict(type='Pretrained', checkpoint=path))
+    with pytest.raises(AssertionError):
+        model = PCPVT(pretrained=path, init_cfg=123)
+
+    # pretrain=123, whose type is unsupported
+    # init_cfg=None
+    with pytest.raises(TypeError):
+        model = PCPVT(pretrained=123, init_cfg=None)
+
+    # pretrain=123, whose type is unsupported
+    # init_cfg loads pretrain from an non-existent file
+    with pytest.raises(AssertionError):
+        model = PCPVT(
+            pretrained=123, init_cfg=dict(type='Pretrained', checkpoint=path))
+
+    # pretrain=123, whose type is unsupported
+    # init_cfg=123, whose type is unsupported
+    with pytest.raises(AssertionError):
+        model = PCPVT(pretrained=123, init_cfg=123)
+
+
+def test_locallygrouped_self_attention_module():
+    LSA = LocallyGroupedSelfAttention(embed_dims=32, window_size=3)
+    outs = LSA(torch.randn(1, 3136, 32), (56, 56))
+    assert outs.shape == torch.Size([1, 3136, 32])
+
+
+def test_conditional_position_encoding_module():
+    CPE = ConditionalPositionEncoding(in_channels=32, embed_dims=32, stride=2)
+    outs = CPE(torch.randn(1, 3136, 32), (56, 56))
+    assert outs.shape == torch.Size([1, 784, 32])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_unet.py b/mmsegmentation/tests/test_models/test_backbones/test_unet.py
new file mode 100644
index 0000000..4d3faf6
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_unet.py
@@ -0,0 +1,825 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+from mmcv.cnn import ConvModule
+from mmengine.registry import init_default_scope
+
+from mmseg.models.backbones.unet import (BasicConvBlock, DeconvModule,
+                                         InterpConv, UNet, UpConvBlock)
+from mmseg.models.utils import Upsample
+from .utils import check_norm_state
+
+init_default_scope('mmseg')
+
+
+def test_unet_basic_conv_block():
+    with pytest.raises(AssertionError):
+        # Not implemented yet.
+        dcn = dict(type='DCN', deform_groups=1, fallback_on_stride=False)
+        BasicConvBlock(64, 64, dcn=dcn)
+
+    with pytest.raises(AssertionError):
+        # Not implemented yet.
+        plugins = [
+            dict(
+                cfg=dict(type='ContextBlock', ratio=1. / 16),
+                position='after_conv3')
+        ]
+        BasicConvBlock(64, 64, plugins=plugins)
+
+    with pytest.raises(AssertionError):
+        # Not implemented yet
+        plugins = [
+            dict(
+                cfg=dict(
+                    type='GeneralizedAttention',
+                    spatial_range=-1,
+                    num_heads=8,
+                    attention_type='0010',
+                    kv_stride=2),
+                position='after_conv2')
+        ]
+        BasicConvBlock(64, 64, plugins=plugins)
+
+    # test BasicConvBlock with checkpoint forward
+    block = BasicConvBlock(16, 16, with_cp=True)
+    assert block.with_cp
+    x = torch.randn(1, 16, 64, 64, requires_grad=True)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([1, 16, 64, 64])
+
+    block = BasicConvBlock(16, 16, with_cp=False)
+    assert not block.with_cp
+    x = torch.randn(1, 16, 64, 64)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([1, 16, 64, 64])
+
+    # test BasicConvBlock with stride convolution to downsample
+    block = BasicConvBlock(16, 16, stride=2)
+    x = torch.randn(1, 16, 64, 64)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([1, 16, 32, 32])
+
+    # test BasicConvBlock structure and forward
+    block = BasicConvBlock(16, 64, num_convs=3, dilation=3)
+    assert block.convs[0].conv.in_channels == 16
+    assert block.convs[0].conv.out_channels == 64
+    assert block.convs[0].conv.kernel_size == (3, 3)
+    assert block.convs[0].conv.dilation == (1, 1)
+    assert block.convs[0].conv.padding == (1, 1)
+
+    assert block.convs[1].conv.in_channels == 64
+    assert block.convs[1].conv.out_channels == 64
+    assert block.convs[1].conv.kernel_size == (3, 3)
+    assert block.convs[1].conv.dilation == (3, 3)
+    assert block.convs[1].conv.padding == (3, 3)
+
+    assert block.convs[2].conv.in_channels == 64
+    assert block.convs[2].conv.out_channels == 64
+    assert block.convs[2].conv.kernel_size == (3, 3)
+    assert block.convs[2].conv.dilation == (3, 3)
+    assert block.convs[2].conv.padding == (3, 3)
+
+
+def test_deconv_module():
+    with pytest.raises(AssertionError):
+        # kernel_size should be greater than or equal to scale_factor and
+        # (kernel_size - scale_factor) should be even numbers
+        DeconvModule(64, 32, kernel_size=1, scale_factor=2)
+
+    with pytest.raises(AssertionError):
+        # kernel_size should be greater than or equal to scale_factor and
+        # (kernel_size - scale_factor) should be even numbers
+        DeconvModule(64, 32, kernel_size=3, scale_factor=2)
+
+    with pytest.raises(AssertionError):
+        # kernel_size should be greater than or equal to scale_factor and
+        # (kernel_size - scale_factor) should be even numbers
+        DeconvModule(64, 32, kernel_size=5, scale_factor=4)
+
+    # test DeconvModule with checkpoint forward and upsample 2X.
+    block = DeconvModule(64, 32, with_cp=True)
+    assert block.with_cp
+    x = torch.randn(1, 64, 128, 128, requires_grad=True)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([1, 32, 256, 256])
+
+    block = DeconvModule(64, 32, with_cp=False)
+    assert not block.with_cp
+    x = torch.randn(1, 64, 128, 128)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([1, 32, 256, 256])
+
+    # test DeconvModule with different kernel size for upsample 2X.
+    x = torch.randn(1, 64, 64, 64)
+    block = DeconvModule(64, 32, kernel_size=2, scale_factor=2)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([1, 32, 128, 128])
+
+    block = DeconvModule(64, 32, kernel_size=6, scale_factor=2)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([1, 32, 128, 128])
+
+    # test DeconvModule with different kernel size for upsample 4X.
+    x = torch.randn(1, 64, 64, 64)
+    block = DeconvModule(64, 32, kernel_size=4, scale_factor=4)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([1, 32, 256, 256])
+
+    block = DeconvModule(64, 32, kernel_size=6, scale_factor=4)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([1, 32, 256, 256])
+
+
+def test_interp_conv():
+    # test InterpConv with checkpoint forward and upsample 2X.
+    block = InterpConv(64, 32, with_cp=True)
+    assert block.with_cp
+    x = torch.randn(1, 64, 128, 128, requires_grad=True)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([1, 32, 256, 256])
+
+    block = InterpConv(64, 32, with_cp=False)
+    assert not block.with_cp
+    x = torch.randn(1, 64, 128, 128)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([1, 32, 256, 256])
+
+    # test InterpConv with conv_first=False for upsample 2X.
+    block = InterpConv(64, 32, conv_first=False)
+    x = torch.randn(1, 64, 128, 128)
+    x_out = block(x)
+    assert isinstance(block.interp_upsample[0], Upsample)
+    assert isinstance(block.interp_upsample[1], ConvModule)
+    assert x_out.shape == torch.Size([1, 32, 256, 256])
+
+    # test InterpConv with conv_first=True for upsample 2X.
+    block = InterpConv(64, 32, conv_first=True)
+    x = torch.randn(1, 64, 128, 128)
+    x_out = block(x)
+    assert isinstance(block.interp_upsample[0], ConvModule)
+    assert isinstance(block.interp_upsample[1], Upsample)
+    assert x_out.shape == torch.Size([1, 32, 256, 256])
+
+    # test InterpConv with bilinear upsample for upsample 2X.
+    block = InterpConv(
+        64,
+        32,
+        conv_first=False,
+        upsample_cfg=dict(
+            scale_factor=2, mode='bilinear', align_corners=False))
+    x = torch.randn(1, 64, 128, 128)
+    x_out = block(x)
+    assert isinstance(block.interp_upsample[0], Upsample)
+    assert isinstance(block.interp_upsample[1], ConvModule)
+    assert x_out.shape == torch.Size([1, 32, 256, 256])
+    assert block.interp_upsample[0].mode == 'bilinear'
+
+    # test InterpConv with nearest upsample for upsample 2X.
+    block = InterpConv(
+        64,
+        32,
+        conv_first=False,
+        upsample_cfg=dict(scale_factor=2, mode='nearest'))
+    x = torch.randn(1, 64, 128, 128)
+    x_out = block(x)
+    assert isinstance(block.interp_upsample[0], Upsample)
+    assert isinstance(block.interp_upsample[1], ConvModule)
+    assert x_out.shape == torch.Size([1, 32, 256, 256])
+    assert block.interp_upsample[0].mode == 'nearest'
+
+
+def test_up_conv_block():
+    with pytest.raises(AssertionError):
+        # Not implemented yet.
+        dcn = dict(type='DCN', deform_groups=1, fallback_on_stride=False)
+        UpConvBlock(BasicConvBlock, 64, 32, 32, dcn=dcn)
+
+    with pytest.raises(AssertionError):
+        # Not implemented yet.
+        plugins = [
+            dict(
+                cfg=dict(type='ContextBlock', ratio=1. / 16),
+                position='after_conv3')
+        ]
+        UpConvBlock(BasicConvBlock, 64, 32, 32, plugins=plugins)
+
+    with pytest.raises(AssertionError):
+        # Not implemented yet
+        plugins = [
+            dict(
+                cfg=dict(
+                    type='GeneralizedAttention',
+                    spatial_range=-1,
+                    num_heads=8,
+                    attention_type='0010',
+                    kv_stride=2),
+                position='after_conv2')
+        ]
+        UpConvBlock(BasicConvBlock, 64, 32, 32, plugins=plugins)
+
+    # test UpConvBlock with checkpoint forward and upsample 2X.
+    block = UpConvBlock(BasicConvBlock, 64, 32, 32, with_cp=True)
+    skip_x = torch.randn(1, 32, 256, 256, requires_grad=True)
+    x = torch.randn(1, 64, 128, 128, requires_grad=True)
+    x_out = block(skip_x, x)
+    assert x_out.shape == torch.Size([1, 32, 256, 256])
+
+    # test UpConvBlock with upsample=True for upsample 2X. The spatial size of
+    # skip_x is 2X larger than x.
+    block = UpConvBlock(
+        BasicConvBlock, 64, 32, 32, upsample_cfg=dict(type='InterpConv'))
+    skip_x = torch.randn(1, 32, 256, 256)
+    x = torch.randn(1, 64, 128, 128)
+    x_out = block(skip_x, x)
+    assert x_out.shape == torch.Size([1, 32, 256, 256])
+
+    # test UpConvBlock with upsample=False for upsample 2X. The spatial size of
+    # skip_x is the same as that of x.
+    block = UpConvBlock(BasicConvBlock, 64, 32, 32, upsample_cfg=None)
+    skip_x = torch.randn(1, 32, 256, 256)
+    x = torch.randn(1, 64, 256, 256)
+    x_out = block(skip_x, x)
+    assert x_out.shape == torch.Size([1, 32, 256, 256])
+
+    # test UpConvBlock with different upsample method for upsample 2X.
+    # The upsample method is interpolation upsample (bilinear or nearest).
+    block = UpConvBlock(
+        BasicConvBlock,
+        64,
+        32,
+        32,
+        upsample_cfg=dict(
+            type='InterpConv',
+            upsample_cfg=dict(
+                scale_factor=2, mode='bilinear', align_corners=False)))
+    skip_x = torch.randn(1, 32, 256, 256)
+    x = torch.randn(1, 64, 128, 128)
+    x_out = block(skip_x, x)
+    assert x_out.shape == torch.Size([1, 32, 256, 256])
+
+    # test UpConvBlock with different upsample method for upsample 2X.
+    # The upsample method is deconvolution upsample.
+    block = UpConvBlock(
+        BasicConvBlock,
+        64,
+        32,
+        32,
+        upsample_cfg=dict(type='DeconvModule', kernel_size=4, scale_factor=2))
+    skip_x = torch.randn(1, 32, 256, 256)
+    x = torch.randn(1, 64, 128, 128)
+    x_out = block(skip_x, x)
+    assert x_out.shape == torch.Size([1, 32, 256, 256])
+
+    # test BasicConvBlock structure and forward
+    block = UpConvBlock(
+        conv_block=BasicConvBlock,
+        in_channels=64,
+        skip_channels=32,
+        out_channels=32,
+        num_convs=3,
+        dilation=3,
+        upsample_cfg=dict(
+            type='InterpConv',
+            upsample_cfg=dict(
+                scale_factor=2, mode='bilinear', align_corners=False)))
+    skip_x = torch.randn(1, 32, 256, 256)
+    x = torch.randn(1, 64, 128, 128)
+    x_out = block(skip_x, x)
+    assert x_out.shape == torch.Size([1, 32, 256, 256])
+
+    assert block.conv_block.convs[0].conv.in_channels == 64
+    assert block.conv_block.convs[0].conv.out_channels == 32
+    assert block.conv_block.convs[0].conv.kernel_size == (3, 3)
+    assert block.conv_block.convs[0].conv.dilation == (1, 1)
+    assert block.conv_block.convs[0].conv.padding == (1, 1)
+
+    assert block.conv_block.convs[1].conv.in_channels == 32
+    assert block.conv_block.convs[1].conv.out_channels == 32
+    assert block.conv_block.convs[1].conv.kernel_size == (3, 3)
+    assert block.conv_block.convs[1].conv.dilation == (3, 3)
+    assert block.conv_block.convs[1].conv.padding == (3, 3)
+
+    assert block.conv_block.convs[2].conv.in_channels == 32
+    assert block.conv_block.convs[2].conv.out_channels == 32
+    assert block.conv_block.convs[2].conv.kernel_size == (3, 3)
+    assert block.conv_block.convs[2].conv.dilation == (3, 3)
+    assert block.conv_block.convs[2].conv.padding == (3, 3)
+
+    assert block.upsample.interp_upsample[1].conv.in_channels == 64
+    assert block.upsample.interp_upsample[1].conv.out_channels == 32
+    assert block.upsample.interp_upsample[1].conv.kernel_size == (1, 1)
+    assert block.upsample.interp_upsample[1].conv.dilation == (1, 1)
+    assert block.upsample.interp_upsample[1].conv.padding == (0, 0)
+
+
+def test_unet():
+    with pytest.raises(AssertionError):
+        # Not implemented yet.
+        dcn = dict(type='DCN', deform_groups=1, fallback_on_stride=False)
+        UNet(3, 64, 5, dcn=dcn)
+
+    with pytest.raises(AssertionError):
+        # Not implemented yet.
+        plugins = [
+            dict(
+                cfg=dict(type='ContextBlock', ratio=1. / 16),
+                position='after_conv3')
+        ]
+        UNet(3, 64, 5, plugins=plugins)
+
+    with pytest.raises(AssertionError):
+        # Not implemented yet
+        plugins = [
+            dict(
+                cfg=dict(
+                    type='GeneralizedAttention',
+                    spatial_range=-1,
+                    num_heads=8,
+                    attention_type='0010',
+                    kv_stride=2),
+                position='after_conv2')
+        ]
+        UNet(3, 64, 5, plugins=plugins)
+
+    with pytest.raises(AssertionError):
+        # Check whether the input image size can be divisible by the whole
+        # downsample rate of the encoder. The whole downsample rate of this
+        # case is 8.
+        unet = UNet(
+            in_channels=3,
+            base_channels=4,
+            num_stages=4,
+            strides=(1, 1, 1, 1),
+            enc_num_convs=(2, 2, 2, 2),
+            dec_num_convs=(2, 2, 2),
+            downsamples=(True, True, True),
+            enc_dilations=(1, 1, 1, 1),
+            dec_dilations=(1, 1, 1))
+        x = torch.randn(2, 3, 65, 65)
+        unet(x)
+
+    with pytest.raises(AssertionError):
+        # Check whether the input image size can be divisible by the whole
+        # downsample rate of the encoder. The whole downsample rate of this
+        # case is 16.
+        unet = UNet(
+            in_channels=3,
+            base_channels=4,
+            num_stages=5,
+            strides=(1, 1, 1, 1, 1),
+            enc_num_convs=(2, 2, 2, 2, 2),
+            dec_num_convs=(2, 2, 2, 2),
+            downsamples=(True, True, True, True),
+            enc_dilations=(1, 1, 1, 1, 1),
+            dec_dilations=(1, 1, 1, 1))
+        x = torch.randn(2, 3, 65, 65)
+        unet(x)
+
+    with pytest.raises(AssertionError):
+        # Check whether the input image size can be divisible by the whole
+        # downsample rate of the encoder. The whole downsample rate of this
+        # case is 8.
+        unet = UNet(
+            in_channels=3,
+            base_channels=4,
+            num_stages=5,
+            strides=(1, 1, 1, 1, 1),
+            enc_num_convs=(2, 2, 2, 2, 2),
+            dec_num_convs=(2, 2, 2, 2),
+            downsamples=(True, True, True, False),
+            enc_dilations=(1, 1, 1, 1, 1),
+            dec_dilations=(1, 1, 1, 1))
+        x = torch.randn(2, 3, 65, 65)
+        unet(x)
+
+    with pytest.raises(AssertionError):
+        # Check whether the input image size can be divisible by the whole
+        # downsample rate of the encoder. The whole downsample rate of this
+        # case is 8.
+        unet = UNet(
+            in_channels=3,
+            base_channels=4,
+            num_stages=5,
+            strides=(1, 2, 2, 2, 1),
+            enc_num_convs=(2, 2, 2, 2, 2),
+            dec_num_convs=(2, 2, 2, 2),
+            downsamples=(True, True, True, False),
+            enc_dilations=(1, 1, 1, 1, 1),
+            dec_dilations=(1, 1, 1, 1))
+        x = torch.randn(2, 3, 65, 65)
+        unet(x)
+
+    with pytest.raises(AssertionError):
+        # Check whether the input image size can be divisible by the whole
+        # downsample rate of the encoder. The whole downsample rate of this
+        # case is 32.
+        unet = UNet(
+            in_channels=3,
+            base_channels=4,
+            num_stages=6,
+            strides=(1, 1, 1, 1, 1, 1),
+            enc_num_convs=(2, 2, 2, 2, 2, 2),
+            dec_num_convs=(2, 2, 2, 2, 2),
+            downsamples=(True, True, True, True, True),
+            enc_dilations=(1, 1, 1, 1, 1, 1),
+            dec_dilations=(1, 1, 1, 1, 1))
+        x = torch.randn(2, 3, 65, 65)
+        unet(x)
+
+    with pytest.raises(AssertionError):
+        # Check if num_stages matches strides, len(strides)=num_stages
+        unet = UNet(
+            in_channels=3,
+            base_channels=4,
+            num_stages=5,
+            strides=(1, 1, 1, 1),
+            enc_num_convs=(2, 2, 2, 2, 2),
+            dec_num_convs=(2, 2, 2, 2),
+            downsamples=(True, True, True, True),
+            enc_dilations=(1, 1, 1, 1, 1),
+            dec_dilations=(1, 1, 1, 1))
+        x = torch.randn(2, 3, 64, 64)
+        unet(x)
+
+    with pytest.raises(AssertionError):
+        # Check if num_stages matches strides, len(enc_num_convs)=num_stages
+        unet = UNet(
+            in_channels=3,
+            base_channels=4,
+            num_stages=5,
+            strides=(1, 1, 1, 1, 1),
+            enc_num_convs=(2, 2, 2, 2),
+            dec_num_convs=(2, 2, 2, 2),
+            downsamples=(True, True, True, True),
+            enc_dilations=(1, 1, 1, 1, 1),
+            dec_dilations=(1, 1, 1, 1))
+        x = torch.randn(2, 3, 64, 64)
+        unet(x)
+
+    with pytest.raises(AssertionError):
+        # Check if num_stages matches strides, len(dec_num_convs)=num_stages-1
+        unet = UNet(
+            in_channels=3,
+            base_channels=4,
+            num_stages=5,
+            strides=(1, 1, 1, 1, 1),
+            enc_num_convs=(2, 2, 2, 2, 2),
+            dec_num_convs=(2, 2, 2, 2, 2),
+            downsamples=(True, True, True, True),
+            enc_dilations=(1, 1, 1, 1, 1),
+            dec_dilations=(1, 1, 1, 1))
+        x = torch.randn(2, 3, 64, 64)
+        unet(x)
+
+    with pytest.raises(AssertionError):
+        # Check if num_stages matches strides, len(downsamples)=num_stages-1
+        unet = UNet(
+            in_channels=3,
+            base_channels=4,
+            num_stages=5,
+            strides=(1, 1, 1, 1, 1),
+            enc_num_convs=(2, 2, 2, 2, 2),
+            dec_num_convs=(2, 2, 2, 2),
+            downsamples=(True, True, True),
+            enc_dilations=(1, 1, 1, 1, 1),
+            dec_dilations=(1, 1, 1, 1))
+        x = torch.randn(2, 3, 64, 64)
+        unet(x)
+
+    with pytest.raises(AssertionError):
+        # Check if num_stages matches strides, len(enc_dilations)=num_stages
+        unet = UNet(
+            in_channels=3,
+            base_channels=4,
+            num_stages=5,
+            strides=(1, 1, 1, 1, 1),
+            enc_num_convs=(2, 2, 2, 2, 2),
+            dec_num_convs=(2, 2, 2, 2),
+            downsamples=(True, True, True, True),
+            enc_dilations=(1, 1, 1, 1),
+            dec_dilations=(1, 1, 1, 1))
+        x = torch.randn(2, 3, 64, 64)
+        unet(x)
+
+    with pytest.raises(AssertionError):
+        # Check if num_stages matches strides, len(dec_dilations)=num_stages-1
+        unet = UNet(
+            in_channels=3,
+            base_channels=4,
+            num_stages=5,
+            strides=(1, 1, 1, 1, 1),
+            enc_num_convs=(2, 2, 2, 2, 2),
+            dec_num_convs=(2, 2, 2, 2),
+            downsamples=(True, True, True, True),
+            enc_dilations=(1, 1, 1, 1, 1),
+            dec_dilations=(1, 1, 1, 1, 1))
+        x = torch.randn(2, 3, 64, 64)
+        unet(x)
+
+    # test UNet norm_eval=True
+    unet = UNet(
+        in_channels=3,
+        base_channels=4,
+        num_stages=5,
+        strides=(1, 1, 1, 1, 1),
+        enc_num_convs=(2, 2, 2, 2, 2),
+        dec_num_convs=(2, 2, 2, 2),
+        downsamples=(True, True, True, True),
+        enc_dilations=(1, 1, 1, 1, 1),
+        dec_dilations=(1, 1, 1, 1),
+        norm_eval=True)
+    unet.train()
+    assert check_norm_state(unet.modules(), False)
+
+    # test UNet norm_eval=False
+    unet = UNet(
+        in_channels=3,
+        base_channels=4,
+        num_stages=5,
+        strides=(1, 1, 1, 1, 1),
+        enc_num_convs=(2, 2, 2, 2, 2),
+        dec_num_convs=(2, 2, 2, 2),
+        downsamples=(True, True, True, True),
+        enc_dilations=(1, 1, 1, 1, 1),
+        dec_dilations=(1, 1, 1, 1),
+        norm_eval=False)
+    unet.train()
+    assert check_norm_state(unet.modules(), True)
+
+    # test UNet forward and outputs. The whole downsample rate is 16.
+    unet = UNet(
+        in_channels=3,
+        base_channels=4,
+        num_stages=5,
+        strides=(1, 1, 1, 1, 1),
+        enc_num_convs=(2, 2, 2, 2, 2),
+        dec_num_convs=(2, 2, 2, 2),
+        downsamples=(True, True, True, True),
+        enc_dilations=(1, 1, 1, 1, 1),
+        dec_dilations=(1, 1, 1, 1))
+
+    x = torch.randn(2, 3, 128, 128)
+    x_outs = unet(x)
+    assert x_outs[0].shape == torch.Size([2, 64, 8, 8])
+    assert x_outs[1].shape == torch.Size([2, 32, 16, 16])
+    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
+    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
+    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
+
+    # test UNet forward and outputs. The whole downsample rate is 8.
+    unet = UNet(
+        in_channels=3,
+        base_channels=4,
+        num_stages=5,
+        strides=(1, 1, 1, 1, 1),
+        enc_num_convs=(2, 2, 2, 2, 2),
+        dec_num_convs=(2, 2, 2, 2),
+        downsamples=(True, True, True, False),
+        enc_dilations=(1, 1, 1, 1, 1),
+        dec_dilations=(1, 1, 1, 1))
+
+    x = torch.randn(2, 3, 128, 128)
+    x_outs = unet(x)
+    assert x_outs[0].shape == torch.Size([2, 64, 16, 16])
+    assert x_outs[1].shape == torch.Size([2, 32, 16, 16])
+    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
+    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
+    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
+
+    # test UNet forward and outputs. The whole downsample rate is 8.
+    unet = UNet(
+        in_channels=3,
+        base_channels=4,
+        num_stages=5,
+        strides=(1, 2, 2, 2, 1),
+        enc_num_convs=(2, 2, 2, 2, 2),
+        dec_num_convs=(2, 2, 2, 2),
+        downsamples=(True, True, True, False),
+        enc_dilations=(1, 1, 1, 1, 1),
+        dec_dilations=(1, 1, 1, 1))
+
+    x = torch.randn(2, 3, 128, 128)
+    x_outs = unet(x)
+    assert x_outs[0].shape == torch.Size([2, 64, 16, 16])
+    assert x_outs[1].shape == torch.Size([2, 32, 16, 16])
+    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
+    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
+    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
+
+    # test UNet forward and outputs. The whole downsample rate is 4.
+    unet = UNet(
+        in_channels=3,
+        base_channels=4,
+        num_stages=5,
+        strides=(1, 1, 1, 1, 1),
+        enc_num_convs=(2, 2, 2, 2, 2),
+        dec_num_convs=(2, 2, 2, 2),
+        downsamples=(True, True, False, False),
+        enc_dilations=(1, 1, 1, 1, 1),
+        dec_dilations=(1, 1, 1, 1))
+
+    x = torch.randn(2, 3, 128, 128)
+    x_outs = unet(x)
+    assert x_outs[0].shape == torch.Size([2, 64, 32, 32])
+    assert x_outs[1].shape == torch.Size([2, 32, 32, 32])
+    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
+    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
+    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
+
+    # test UNet forward and outputs. The whole downsample rate is 4.
+    unet = UNet(
+        in_channels=3,
+        base_channels=4,
+        num_stages=5,
+        strides=(1, 2, 2, 1, 1),
+        enc_num_convs=(2, 2, 2, 2, 2),
+        dec_num_convs=(2, 2, 2, 2),
+        downsamples=(True, True, False, False),
+        enc_dilations=(1, 1, 1, 1, 1),
+        dec_dilations=(1, 1, 1, 1))
+
+    x = torch.randn(2, 3, 128, 128)
+    x_outs = unet(x)
+    assert x_outs[0].shape == torch.Size([2, 64, 32, 32])
+    assert x_outs[1].shape == torch.Size([2, 32, 32, 32])
+    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
+    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
+    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
+
+    # test UNet forward and outputs. The whole downsample rate is 8.
+    unet = UNet(
+        in_channels=3,
+        base_channels=4,
+        num_stages=5,
+        strides=(1, 1, 1, 1, 1),
+        enc_num_convs=(2, 2, 2, 2, 2),
+        dec_num_convs=(2, 2, 2, 2),
+        downsamples=(True, True, True, False),
+        enc_dilations=(1, 1, 1, 1, 1),
+        dec_dilations=(1, 1, 1, 1))
+
+    x = torch.randn(2, 3, 128, 128)
+    x_outs = unet(x)
+    assert x_outs[0].shape == torch.Size([2, 64, 16, 16])
+    assert x_outs[1].shape == torch.Size([2, 32, 16, 16])
+    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
+    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
+    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
+
+    # test UNet forward and outputs. The whole downsample rate is 4.
+    unet = UNet(
+        in_channels=3,
+        base_channels=4,
+        num_stages=5,
+        strides=(1, 1, 1, 1, 1),
+        enc_num_convs=(2, 2, 2, 2, 2),
+        dec_num_convs=(2, 2, 2, 2),
+        downsamples=(True, True, False, False),
+        enc_dilations=(1, 1, 1, 1, 1),
+        dec_dilations=(1, 1, 1, 1))
+
+    x = torch.randn(2, 3, 128, 128)
+    x_outs = unet(x)
+    assert x_outs[0].shape == torch.Size([2, 64, 32, 32])
+    assert x_outs[1].shape == torch.Size([2, 32, 32, 32])
+    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
+    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
+    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
+
+    # test UNet forward and outputs. The whole downsample rate is 2.
+    unet = UNet(
+        in_channels=3,
+        base_channels=4,
+        num_stages=5,
+        strides=(1, 1, 1, 1, 1),
+        enc_num_convs=(2, 2, 2, 2, 2),
+        dec_num_convs=(2, 2, 2, 2),
+        downsamples=(True, False, False, False),
+        enc_dilations=(1, 1, 1, 1, 1),
+        dec_dilations=(1, 1, 1, 1))
+
+    x = torch.randn(2, 3, 128, 128)
+    x_outs = unet(x)
+    assert x_outs[0].shape == torch.Size([2, 64, 64, 64])
+    assert x_outs[1].shape == torch.Size([2, 32, 64, 64])
+    assert x_outs[2].shape == torch.Size([2, 16, 64, 64])
+    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
+    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
+
+    # test UNet forward and outputs. The whole downsample rate is 1.
+    unet = UNet(
+        in_channels=3,
+        base_channels=4,
+        num_stages=5,
+        strides=(1, 1, 1, 1, 1),
+        enc_num_convs=(2, 2, 2, 2, 2),
+        dec_num_convs=(2, 2, 2, 2),
+        downsamples=(False, False, False, False),
+        enc_dilations=(1, 1, 1, 1, 1),
+        dec_dilations=(1, 1, 1, 1))
+
+    x = torch.randn(2, 3, 128, 128)
+    x_outs = unet(x)
+    assert x_outs[0].shape == torch.Size([2, 64, 128, 128])
+    assert x_outs[1].shape == torch.Size([2, 32, 128, 128])
+    assert x_outs[2].shape == torch.Size([2, 16, 128, 128])
+    assert x_outs[3].shape == torch.Size([2, 8, 128, 128])
+    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
+
+    # test UNet forward and outputs. The whole downsample rate is 16.
+    unet = UNet(
+        in_channels=3,
+        base_channels=4,
+        num_stages=5,
+        strides=(1, 2, 2, 1, 1),
+        enc_num_convs=(2, 2, 2, 2, 2),
+        dec_num_convs=(2, 2, 2, 2),
+        downsamples=(True, True, True, True),
+        enc_dilations=(1, 1, 1, 1, 1),
+        dec_dilations=(1, 1, 1, 1))
+    x = torch.randn(2, 3, 128, 128)
+    x_outs = unet(x)
+    assert x_outs[0].shape == torch.Size([2, 64, 8, 8])
+    assert x_outs[1].shape == torch.Size([2, 32, 16, 16])
+    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
+    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
+    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
+
+    # test UNet forward and outputs. The whole downsample rate is 8.
+    unet = UNet(
+        in_channels=3,
+        base_channels=4,
+        num_stages=5,
+        strides=(1, 2, 2, 1, 1),
+        enc_num_convs=(2, 2, 2, 2, 2),
+        dec_num_convs=(2, 2, 2, 2),
+        downsamples=(True, True, True, False),
+        enc_dilations=(1, 1, 1, 1, 1),
+        dec_dilations=(1, 1, 1, 1))
+    x = torch.randn(2, 3, 128, 128)
+    x_outs = unet(x)
+    assert x_outs[0].shape == torch.Size([2, 64, 16, 16])
+    assert x_outs[1].shape == torch.Size([2, 32, 16, 16])
+    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
+    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
+    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
+
+    # test UNet forward and outputs. The whole downsample rate is 8.
+    unet = UNet(
+        in_channels=3,
+        base_channels=4,
+        num_stages=5,
+        strides=(1, 2, 2, 2, 1),
+        enc_num_convs=(2, 2, 2, 2, 2),
+        dec_num_convs=(2, 2, 2, 2),
+        downsamples=(True, True, True, False),
+        enc_dilations=(1, 1, 1, 1, 1),
+        dec_dilations=(1, 1, 1, 1))
+    x = torch.randn(2, 3, 128, 128)
+    x_outs = unet(x)
+    assert x_outs[0].shape == torch.Size([2, 64, 16, 16])
+    assert x_outs[1].shape == torch.Size([2, 32, 16, 16])
+    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
+    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
+    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
+
+    # test UNet forward and outputs. The whole downsample rate is 4.
+    unet = UNet(
+        in_channels=3,
+        base_channels=4,
+        num_stages=5,
+        strides=(1, 2, 2, 1, 1),
+        enc_num_convs=(2, 2, 2, 2, 2),
+        dec_num_convs=(2, 2, 2, 2),
+        downsamples=(True, True, False, False),
+        enc_dilations=(1, 1, 1, 1, 1),
+        dec_dilations=(1, 1, 1, 1))
+    x = torch.randn(2, 3, 128, 128)
+    x_outs = unet(x)
+    assert x_outs[0].shape == torch.Size([2, 64, 32, 32])
+    assert x_outs[1].shape == torch.Size([2, 32, 32, 32])
+    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
+    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
+    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
+
+    # test UNet init_weights method.
+    unet = UNet(
+        in_channels=3,
+        base_channels=4,
+        num_stages=5,
+        strides=(1, 2, 2, 1, 1),
+        enc_num_convs=(2, 2, 2, 2, 2),
+        dec_num_convs=(2, 2, 2, 2),
+        downsamples=(True, True, False, False),
+        enc_dilations=(1, 1, 1, 1, 1),
+        dec_dilations=(1, 1, 1, 1),
+        pretrained=None)
+    unet.init_weights()
+    x = torch.randn(2, 3, 128, 128)
+    x_outs = unet(x)
+    assert x_outs[0].shape == torch.Size([2, 64, 32, 32])
+    assert x_outs[1].shape == torch.Size([2, 32, 32, 32])
+    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
+    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
+    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_vit.py b/mmsegmentation/tests/test_models/test_backbones/test_vit.py
new file mode 100644
index 0000000..0d1ba70
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_vit.py
@@ -0,0 +1,185 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.backbones.vit import (TransformerEncoderLayer,
+                                        VisionTransformer)
+from .utils import check_norm_state
+
+
+def test_vit_backbone():
+    with pytest.raises(TypeError):
+        # pretrained must be a string path
+        model = VisionTransformer()
+        model.init_weights(pretrained=0)
+
+    with pytest.raises(TypeError):
+        # img_size must be int or tuple
+        model = VisionTransformer(img_size=512.0)
+
+    with pytest.raises(TypeError):
+        # out_indices must be int ,list or tuple
+        model = VisionTransformer(out_indices=1.)
+
+    with pytest.raises(TypeError):
+        # test upsample_pos_embed function
+        x = torch.randn(1, 196)
+        VisionTransformer.resize_pos_embed(x, 512, 512, 224, 224, 'bilinear')
+
+    with pytest.raises(AssertionError):
+        # The length of img_size tuple must be lower than 3.
+        VisionTransformer(img_size=(224, 224, 224))
+
+    with pytest.raises(TypeError):
+        # Pretrained must be None or Str.
+        VisionTransformer(pretrained=123)
+
+    with pytest.raises(AssertionError):
+        # with_cls_token must be True when output_cls_token == True
+        VisionTransformer(with_cls_token=False, output_cls_token=True)
+
+    # Test img_size isinstance tuple
+    imgs = torch.randn(1, 3, 224, 224)
+    model = VisionTransformer(img_size=(224, ))
+    model.init_weights()
+    model(imgs)
+
+    # Test img_size isinstance tuple
+    imgs = torch.randn(1, 3, 224, 224)
+    model = VisionTransformer(img_size=(224, 224))
+    model(imgs)
+
+    # Test norm_eval = True
+    model = VisionTransformer(norm_eval=True)
+    model.train()
+
+    # Test ViT backbone with input size of 224 and patch size of 16
+    model = VisionTransformer()
+    model.init_weights()
+    model.train()
+
+    assert check_norm_state(model.modules(), True)
+
+    # Test normal size input image
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 14, 14)
+
+    # Test large size input image
+    imgs = torch.randn(1, 3, 256, 256)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 16, 16)
+
+    # Test small size input image
+    imgs = torch.randn(1, 3, 32, 32)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 2, 2)
+
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 14, 14)
+
+    # Test unbalanced size input image
+    imgs = torch.randn(1, 3, 112, 224)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 7, 14)
+
+    # Test irregular input image
+    imgs = torch.randn(1, 3, 234, 345)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 15, 22)
+
+    # Test with_cp=True
+    model = VisionTransformer(with_cp=True)
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 14, 14)
+
+    # Test with_cls_token=False
+    model = VisionTransformer(with_cls_token=False)
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 14, 14)
+
+    # Test final norm
+    model = VisionTransformer(final_norm=True)
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 14, 14)
+
+    # Test patch norm
+    model = VisionTransformer(patch_norm=True)
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert feat[-1].shape == (1, 768, 14, 14)
+
+    # Test output_cls_token
+    model = VisionTransformer(with_cls_token=True, output_cls_token=True)
+    imgs = torch.randn(1, 3, 224, 224)
+    feat = model(imgs)
+    assert feat[0][0].shape == (1, 768, 14, 14)
+    assert feat[0][1].shape == (1, 768)
+
+    # Test TransformerEncoderLayer with checkpoint forward
+    block = TransformerEncoderLayer(
+        embed_dims=64, num_heads=4, feedforward_channels=256, with_cp=True)
+    assert block.with_cp
+    x = torch.randn(1, 56 * 56, 64)
+    x_out = block(x)
+    assert x_out.shape == torch.Size([1, 56 * 56, 64])
+
+
+def test_vit_init():
+    path = 'PATH_THAT_DO_NOT_EXIST'
+    # Test all combinations of pretrained and init_cfg
+    # pretrained=None, init_cfg=None
+    model = VisionTransformer(pretrained=None, init_cfg=None)
+    assert model.init_cfg is None
+    model.init_weights()
+
+    # pretrained=None
+    # init_cfg loads pretrain from an non-existent file
+    model = VisionTransformer(
+        pretrained=None, init_cfg=dict(type='Pretrained', checkpoint=path))
+    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
+    # Test loading a checkpoint from an non-existent file
+    with pytest.raises(OSError):
+        model.init_weights()
+
+    # pretrained=None
+    # init_cfg=123, whose type is unsupported
+    model = VisionTransformer(pretrained=None, init_cfg=123)
+    with pytest.raises(TypeError):
+        model.init_weights()
+
+    # pretrained loads pretrain from an non-existent file
+    # init_cfg=None
+    model = VisionTransformer(pretrained=path, init_cfg=None)
+    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
+    # Test loading a checkpoint from an non-existent file
+    with pytest.raises(OSError):
+        model.init_weights()
+
+    # pretrained loads pretrain from an non-existent file
+    # init_cfg loads pretrain from an non-existent file
+    with pytest.raises(AssertionError):
+        model = VisionTransformer(
+            pretrained=path, init_cfg=dict(type='Pretrained', checkpoint=path))
+    with pytest.raises(AssertionError):
+        model = VisionTransformer(pretrained=path, init_cfg=123)
+
+    # pretrain=123, whose type is unsupported
+    # init_cfg=None
+    with pytest.raises(TypeError):
+        model = VisionTransformer(pretrained=123, init_cfg=None)
+
+    # pretrain=123, whose type is unsupported
+    # init_cfg loads pretrain from an non-existent file
+    with pytest.raises(AssertionError):
+        model = VisionTransformer(
+            pretrained=123, init_cfg=dict(type='Pretrained', checkpoint=path))
+
+    # pretrain=123, whose type is unsupported
+    # init_cfg=123, whose type is unsupported
+    with pytest.raises(AssertionError):
+        model = VisionTransformer(pretrained=123, init_cfg=123)
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_vpd.py b/mmsegmentation/tests/test_models/test_backbones/test_vpd.py
new file mode 100644
index 0000000..a268159
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/test_vpd.py
@@ -0,0 +1,51 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from os.path import dirname, join
+from unittest import TestCase
+
+import torch
+from mmengine import Config
+
+import mmseg
+from mmseg.models.backbones import VPD
+
+
+class TestVPD(TestCase):
+
+    def setUp(self) -> None:
+
+        repo_dpath = dirname(dirname(mmseg.__file__))
+        config_dpath = join(repo_dpath, 'configs/_base_/models/vpd_sd.py')
+        vpd_cfg = Config.fromfile(config_dpath).stable_diffusion_cfg
+        vpd_cfg.pop('checkpoint')
+
+        self.vpd_model = VPD(
+            diffusion_cfg=vpd_cfg,
+            class_embed_path='https://download.openmmlab.com/mmsegmentation/'
+            'v0.5/vpd/nyu_class_embeddings.pth',
+            class_embed_select=True,
+            pad_shape=64,
+            unet_cfg=dict(use_attn=False),
+        )
+
+    def test_forward(self):
+        # test forward without class_id
+        x = torch.randn(1, 3, 60, 60)
+        with torch.no_grad():
+            out = self.vpd_model(x)
+
+        self.assertEqual(len(out), 4)
+        self.assertListEqual(list(out[0].shape), [1, 320, 8, 8])
+        self.assertListEqual(list(out[1].shape), [1, 640, 4, 4])
+        self.assertListEqual(list(out[2].shape), [1, 1280, 2, 2])
+        self.assertListEqual(list(out[3].shape), [1, 1280, 1, 1])
+
+        # test forward with class_id
+        x = torch.randn(1, 3, 60, 60)
+        with torch.no_grad():
+            out = self.vpd_model((x, torch.tensor([2])))
+
+        self.assertEqual(len(out), 4)
+        self.assertListEqual(list(out[0].shape), [1, 320, 8, 8])
+        self.assertListEqual(list(out[1].shape), [1, 640, 4, 4])
+        self.assertListEqual(list(out[2].shape), [1, 1280, 2, 2])
+        self.assertListEqual(list(out[3].shape), [1, 1280, 1, 1])
diff --git a/mmsegmentation/tests/test_models/test_backbones/utils.py b/mmsegmentation/tests/test_models/test_backbones/utils.py
new file mode 100644
index 0000000..54b6404
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_backbones/utils.py
@@ -0,0 +1,43 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from torch.nn.modules import GroupNorm
+from torch.nn.modules.batchnorm import _BatchNorm
+
+from mmseg.models.backbones.resnet import BasicBlock, Bottleneck
+from mmseg.models.backbones.resnext import Bottleneck as BottleneckX
+
+
+def is_block(modules):
+    """Check if is ResNet building block."""
+    if isinstance(modules, (BasicBlock, Bottleneck, BottleneckX)):
+        return True
+    return False
+
+
+def is_norm(modules):
+    """Check if is one of the norms."""
+    if isinstance(modules, (GroupNorm, _BatchNorm)):
+        return True
+    return False
+
+
+def all_zeros(modules):
+    """Check if the weight(and bias) is all zero."""
+    weight_zero = torch.allclose(modules.weight.data,
+                                 torch.zeros_like(modules.weight.data))
+    if hasattr(modules, 'bias'):
+        bias_zero = torch.allclose(modules.bias.data,
+                                   torch.zeros_like(modules.bias.data))
+    else:
+        bias_zero = True
+
+    return weight_zero and bias_zero
+
+
+def check_norm_state(modules, train_state):
+    """Check if norm layer is in correct train state."""
+    for mod in modules:
+        if isinstance(mod, _BatchNorm):
+            if mod.training != train_state:
+                return False
+    return True
diff --git a/mmsegmentation/tests/test_models/test_data_preprocessor.py b/mmsegmentation/tests/test_models/test_data_preprocessor.py
new file mode 100644
index 0000000..d05eef1
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_data_preprocessor.py
@@ -0,0 +1,64 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from unittest import TestCase
+
+import torch
+from mmengine.structures import PixelData
+
+from mmseg.models import SegDataPreProcessor
+from mmseg.structures import SegDataSample
+
+
+class TestSegDataPreProcessor(TestCase):
+
+    def test_init(self):
+        # test mean is None
+        processor = SegDataPreProcessor()
+        self.assertTrue(not hasattr(processor, 'mean'))
+        self.assertTrue(processor._enable_normalize is False)
+
+        # test mean is not None
+        processor = SegDataPreProcessor(mean=[0, 0, 0], std=[1, 1, 1])
+        self.assertTrue(hasattr(processor, 'mean'))
+        self.assertTrue(hasattr(processor, 'std'))
+        self.assertTrue(processor._enable_normalize)
+
+        # please specify both mean and std
+        with self.assertRaises(AssertionError):
+            SegDataPreProcessor(mean=[0, 0, 0])
+
+        # bgr2rgb and rgb2bgr cannot be set to True at the same time
+        with self.assertRaises(AssertionError):
+            SegDataPreProcessor(bgr_to_rgb=True, rgb_to_bgr=True)
+
+    def test_forward(self):
+        data_sample = SegDataSample()
+        data_sample.gt_sem_seg = PixelData(
+            **{'data': torch.randint(0, 10, (1, 11, 10))})
+        processor = SegDataPreProcessor(
+            mean=[0, 0, 0], std=[1, 1, 1], size=(20, 20))
+        data = {
+            'inputs': [
+                torch.randint(0, 256, (3, 11, 10)),
+                torch.randint(0, 256, (3, 11, 10))
+            ],
+            'data_samples': [data_sample, data_sample]
+        }
+        out = processor(data, training=True)
+        self.assertEqual(out['inputs'].shape, (2, 3, 20, 20))
+        self.assertEqual(len(out['data_samples']), 2)
+
+        # test predict with padding
+        processor = SegDataPreProcessor(
+            mean=[0, 0, 0],
+            std=[1, 1, 1],
+            size=(20, 20),
+            test_cfg=dict(size_divisor=15))
+        data = {
+            'inputs': [
+                torch.randint(0, 256, (3, 11, 10)),
+            ],
+            'data_samples': [data_sample]
+        }
+        out = processor(data, training=False)
+        self.assertEqual(out['inputs'].shape[2] % 15, 0)
+        self.assertEqual(out['inputs'].shape[3] % 15, 0)
diff --git a/mmsegmentation/tests/test_models/test_forward.py b/mmsegmentation/tests/test_models/test_forward.py
new file mode 100644
index 0000000..bb3967f
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_forward.py
@@ -0,0 +1,229 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+"""pytest tests/test_forward.py."""
+import copy
+from os.path import dirname, exists, join
+from unittest.mock import patch
+
+import numpy as np
+import pytest
+import torch
+import torch.nn as nn
+from mmengine.model.utils import revert_sync_batchnorm
+from mmengine.registry import init_default_scope
+from mmengine.structures import PixelData
+from mmengine.utils import is_list_of, is_tuple_of
+from torch import Tensor
+
+from mmseg.structures import SegDataSample
+
+init_default_scope('mmseg')
+
+
+def _demo_mm_inputs(batch_size=2, image_shapes=(3, 32, 32), num_classes=5):
+    """Create a superset of inputs needed to run test or train batches.
+
+    Args:
+        batch_size (int): batch size. Default to 2.
+        image_shapes (List[tuple], Optional): image shape.
+            Default to (3, 128, 128)
+        num_classes (int): number of different labels a
+            box might have. Default to 10.
+    """
+    if isinstance(image_shapes, list):
+        assert len(image_shapes) == batch_size
+    else:
+        image_shapes = [image_shapes] * batch_size
+
+    inputs = []
+    data_samples = []
+    for idx in range(batch_size):
+        image_shape = image_shapes[idx]
+        c, h, w = image_shape
+        image = np.random.randint(0, 255, size=image_shape, dtype=np.uint8)
+
+        mm_input = torch.from_numpy(image)
+
+        img_meta = {
+            'img_id': idx,
+            'img_shape': image_shape[1:],
+            'ori_shape': image_shape[1:],
+            'pad_shape': image_shape[1:],
+            'filename': '<demo>.png',
+            'scale_factor': 1.0,
+            'flip': False,
+            'flip_direction': None,
+        }
+
+        data_sample = SegDataSample()
+        data_sample.set_metainfo(img_meta)
+
+        gt_semantic_seg = np.random.randint(
+            0, num_classes, (1, h, w), dtype=np.uint8)
+        gt_semantic_seg = torch.LongTensor(gt_semantic_seg)
+        gt_sem_seg_data = dict(data=gt_semantic_seg)
+        data_sample.gt_sem_seg = PixelData(**gt_sem_seg_data)
+        inputs.append(mm_input)
+        data_samples.append(data_sample)
+    return dict(inputs=inputs, data_samples=data_samples)
+
+
+def _get_config_directory():
+    """Find the predefined segmentor config directory."""
+    try:
+        # Assume we are running in the source mmsegmentation repo
+        repo_dpath = dirname(dirname(dirname(__file__)))
+    except NameError:
+        # For IPython development when this __file__ is not defined
+        import mmseg
+        repo_dpath = dirname(dirname(dirname(mmseg.__file__)))
+    config_dpath = join(repo_dpath, 'configs')
+    if not exists(config_dpath):
+        raise Exception('Cannot find config path')
+    return config_dpath
+
+
+def _get_config_module(fname):
+    """Load a configuration as a python module."""
+    from mmengine import Config
+    config_dpath = _get_config_directory()
+    config_fpath = join(config_dpath, fname)
+    config_mod = Config.fromfile(config_fpath)
+    return config_mod
+
+
+def _get_segmentor_cfg(fname):
+    """Grab configs necessary to create a segmentor.
+
+    These are deep copied to allow for safe modification of parameters without
+    influencing other tests.
+    """
+    config = _get_config_module(fname)
+    model = copy.deepcopy(config.model)
+    return model
+
+
+def test_pspnet_forward():
+    _test_encoder_decoder_forward(
+        'pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-512x1024.py')
+
+
+def test_fcn_forward():
+    _test_encoder_decoder_forward(
+        'fcn/fcn_r18-d8_4xb2-80k_cityscapes-512x1024.py')
+
+
+def test_deeplabv3_forward():
+    _test_encoder_decoder_forward(
+        'deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-512x1024.py')
+
+
+def test_deeplabv3plus_forward():
+    _test_encoder_decoder_forward(
+        'deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-512x1024.py')
+
+
+def test_gcnet_forward():
+    _test_encoder_decoder_forward(
+        'gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py')
+
+
+def test_ccnet_forward():
+    if not torch.cuda.is_available():
+        pytest.skip('CCNet requires CUDA')
+    _test_encoder_decoder_forward(
+        'ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-512x1024.py')
+
+
+def test_upernet_forward():
+    _test_encoder_decoder_forward(
+        'upernet/upernet_r50_4xb2-40k_cityscapes-512x1024.py')
+
+
+def test_hrnet_forward():
+    _test_encoder_decoder_forward(
+        'hrnet/fcn_hr18s_4xb2-40k_cityscapes-512x1024.py')
+
+
+def test_ocrnet_forward():
+    _test_encoder_decoder_forward(
+        'ocrnet/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024.py')
+
+
+def test_sem_fpn_forward():
+    _test_encoder_decoder_forward(
+        'sem_fpn/fpn_r50_4xb2-80k_cityscapes-512x1024.py')
+
+
+def test_mobilenet_v2_forward():
+    _test_encoder_decoder_forward(
+        'mobilenet_v2/mobilenet-v2-d8_pspnet_4xb2-80k_cityscapes-512x1024.py')
+
+
+def get_world_size(process_group):
+
+    return 1
+
+
+def _check_input_dim(self, inputs):
+    pass
+
+
+@patch('torch.nn.modules.batchnorm._BatchNorm._check_input_dim',
+       _check_input_dim)
+@patch('torch.distributed.get_world_size', get_world_size)
+def _test_encoder_decoder_forward(cfg_file):
+    model = _get_segmentor_cfg(cfg_file)
+    model['pretrained'] = None
+    model['test_cfg']['mode'] = 'whole'
+
+    from mmseg.models import build_segmentor
+    segmentor = build_segmentor(model)
+    segmentor.init_weights()
+
+    if isinstance(segmentor.decode_head, nn.ModuleList):
+        num_classes = segmentor.decode_head[-1].num_classes
+    else:
+        num_classes = segmentor.decode_head.num_classes
+    # batch_size=2 for BatchNorm
+    packed_inputs = _demo_mm_inputs(
+        batch_size=2, image_shapes=(3, 4, 4), num_classes=num_classes)
+    # convert to cuda Tensor if applicable
+    if torch.cuda.is_available():
+        segmentor = segmentor.cuda()
+    else:
+        segmentor = revert_sync_batchnorm(segmentor)
+
+    # Test forward train
+    data = segmentor.data_preprocessor(packed_inputs, True)
+    losses = segmentor.forward(**data, mode='loss')
+    assert isinstance(losses, dict)
+
+    packed_inputs = _demo_mm_inputs(
+        batch_size=1, image_shapes=(3, 32, 32), num_classes=num_classes)
+    data = segmentor.data_preprocessor(packed_inputs, False)
+    with torch.no_grad():
+        segmentor.eval()
+        # Test forward predict
+        batch_results = segmentor.forward(**data, mode='predict')
+        assert len(batch_results) == 1
+        assert is_list_of(batch_results, SegDataSample)
+        assert batch_results[0].pred_sem_seg.shape == (32, 32)
+        assert batch_results[0].seg_logits.data.shape == (num_classes, 32, 32)
+        assert batch_results[0].gt_sem_seg.shape == (32, 32)
+
+        # Test forward tensor
+        batch_results = segmentor.forward(**data, mode='tensor')
+        assert isinstance(batch_results, Tensor) or is_tuple_of(
+            batch_results, Tensor)
+
+        # Test forward predict without ground truth
+        data.pop('data_samples')
+        batch_results = segmentor.forward(**data, mode='predict')
+        assert len(batch_results) == 1
+        assert is_list_of(batch_results, SegDataSample)
+        assert batch_results[0].pred_sem_seg.shape == (32, 32)
+
+        # Test forward tensor without ground truth
+        batch_results = segmentor.forward(**data, mode='tensor')
+        assert isinstance(batch_results, Tensor) or is_tuple_of(
+            batch_results, Tensor)
diff --git a/mmsegmentation/tests/test_models/test_heads/__init__.py b/mmsegmentation/tests/test_models/test_heads/__init__.py
new file mode 100644
index 0000000..ef101fe
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/__init__.py
@@ -0,0 +1 @@
+# Copyright (c) OpenMMLab. All rights reserved.
diff --git a/mmsegmentation/tests/test_models/test_heads/test_ann_head.py b/mmsegmentation/tests/test_models/test_heads/test_ann_head.py
new file mode 100644
index 0000000..c1e44bc
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_ann_head.py
@@ -0,0 +1,20 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+
+from mmseg.models.decode_heads import ANNHead
+from .utils import to_cuda
+
+
+def test_ann_head():
+
+    inputs = [torch.randn(1, 4, 45, 45), torch.randn(1, 8, 21, 21)]
+    head = ANNHead(
+        in_channels=[4, 8],
+        channels=2,
+        num_classes=19,
+        in_index=[-2, -1],
+        project_channels=8)
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 21, 21)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_apc_head.py b/mmsegmentation/tests/test_models/test_heads/test_apc_head.py
new file mode 100644
index 0000000..dc55ccc
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_apc_head.py
@@ -0,0 +1,59 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.decode_heads import APCHead
+from .utils import _conv_has_norm, to_cuda
+
+
+def test_apc_head():
+
+    with pytest.raises(AssertionError):
+        # pool_scales must be list|tuple
+        APCHead(in_channels=8, channels=2, num_classes=19, pool_scales=1)
+
+    # test no norm_cfg
+    head = APCHead(in_channels=8, channels=2, num_classes=19)
+    assert not _conv_has_norm(head, sync_bn=False)
+
+    # test with norm_cfg
+    head = APCHead(
+        in_channels=8,
+        channels=2,
+        num_classes=19,
+        norm_cfg=dict(type='SyncBN'))
+    assert _conv_has_norm(head, sync_bn=True)
+
+    # fusion=True
+    inputs = [torch.randn(1, 8, 45, 45)]
+    head = APCHead(
+        in_channels=8,
+        channels=2,
+        num_classes=19,
+        pool_scales=(1, 2, 3),
+        fusion=True)
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    assert head.fusion is True
+    assert head.acm_modules[0].pool_scale == 1
+    assert head.acm_modules[1].pool_scale == 2
+    assert head.acm_modules[2].pool_scale == 3
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 45, 45)
+
+    # fusion=False
+    inputs = [torch.randn(1, 8, 45, 45)]
+    head = APCHead(
+        in_channels=8,
+        channels=2,
+        num_classes=19,
+        pool_scales=(1, 2, 3),
+        fusion=False)
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    assert head.fusion is False
+    assert head.acm_modules[0].pool_scale == 1
+    assert head.acm_modules[1].pool_scale == 2
+    assert head.acm_modules[2].pool_scale == 3
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 45, 45)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_aspp_head.py b/mmsegmentation/tests/test_models/test_heads/test_aspp_head.py
new file mode 100644
index 0000000..db9e893
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_aspp_head.py
@@ -0,0 +1,76 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.decode_heads import ASPPHead, DepthwiseSeparableASPPHead
+from .utils import _conv_has_norm, to_cuda
+
+
+def test_aspp_head():
+
+    with pytest.raises(AssertionError):
+        # pool_scales must be list|tuple
+        ASPPHead(in_channels=8, channels=4, num_classes=19, dilations=1)
+
+    # test no norm_cfg
+    head = ASPPHead(in_channels=8, channels=4, num_classes=19)
+    assert not _conv_has_norm(head, sync_bn=False)
+
+    # test with norm_cfg
+    head = ASPPHead(
+        in_channels=8,
+        channels=4,
+        num_classes=19,
+        norm_cfg=dict(type='SyncBN'))
+    assert _conv_has_norm(head, sync_bn=True)
+
+    inputs = [torch.randn(1, 8, 45, 45)]
+    head = ASPPHead(
+        in_channels=8, channels=4, num_classes=19, dilations=(1, 12, 24))
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    assert head.aspp_modules[0].conv.dilation == (1, 1)
+    assert head.aspp_modules[1].conv.dilation == (12, 12)
+    assert head.aspp_modules[2].conv.dilation == (24, 24)
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 45, 45)
+
+
+def test_dw_aspp_head():
+
+    # test w.o. c1
+    inputs = [torch.randn(1, 8, 45, 45)]
+    head = DepthwiseSeparableASPPHead(
+        c1_in_channels=0,
+        c1_channels=0,
+        in_channels=8,
+        channels=4,
+        num_classes=19,
+        dilations=(1, 12, 24))
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    assert head.c1_bottleneck is None
+    assert head.aspp_modules[0].conv.dilation == (1, 1)
+    assert head.aspp_modules[1].depthwise_conv.dilation == (12, 12)
+    assert head.aspp_modules[2].depthwise_conv.dilation == (24, 24)
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 45, 45)
+
+    # test with c1
+    inputs = [torch.randn(1, 4, 45, 45), torch.randn(1, 16, 21, 21)]
+    head = DepthwiseSeparableASPPHead(
+        c1_in_channels=4,
+        c1_channels=2,
+        in_channels=16,
+        channels=8,
+        num_classes=19,
+        dilations=(1, 12, 24))
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    assert head.c1_bottleneck.in_channels == 4
+    assert head.c1_bottleneck.out_channels == 2
+    assert head.aspp_modules[0].conv.dilation == (1, 1)
+    assert head.aspp_modules[1].depthwise_conv.dilation == (12, 12)
+    assert head.aspp_modules[2].depthwise_conv.dilation == (24, 24)
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 45, 45)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_cc_head.py b/mmsegmentation/tests/test_models/test_heads/test_cc_head.py
new file mode 100644
index 0000000..0630417
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_cc_head.py
@@ -0,0 +1,18 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.decode_heads import CCHead
+from .utils import to_cuda
+
+
+def test_cc_head():
+    head = CCHead(in_channels=16, channels=8, num_classes=19)
+    assert len(head.convs) == 2
+    assert hasattr(head, 'cca')
+    if not torch.cuda.is_available():
+        pytest.skip('CCHead requires CUDA')
+    inputs = [torch.randn(1, 16, 23, 23)]
+    head, inputs = to_cuda(head, inputs)
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 23, 23)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_decode_head.py b/mmsegmentation/tests/test_models/test_heads/test_decode_head.py
new file mode 100644
index 0000000..88e6bed
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_decode_head.py
@@ -0,0 +1,193 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from unittest.mock import patch
+
+import pytest
+import torch
+from mmengine.structures import PixelData
+
+from mmseg.models.decode_heads.decode_head import BaseDecodeHead
+from mmseg.structures import SegDataSample
+from .utils import to_cuda
+
+
+@patch.multiple(BaseDecodeHead, __abstractmethods__=set())
+def test_decode_head():
+
+    with pytest.raises(AssertionError):
+        # default input_transform doesn't accept multiple inputs
+        BaseDecodeHead([32, 16], 16, num_classes=19)
+
+    with pytest.raises(AssertionError):
+        # default input_transform doesn't accept multiple inputs
+        BaseDecodeHead(32, 16, num_classes=19, in_index=[-1, -2])
+
+    with pytest.raises(AssertionError):
+        # supported mode is resize_concat only
+        BaseDecodeHead(32, 16, num_classes=19, input_transform='concat')
+
+    with pytest.raises(AssertionError):
+        # in_channels should be list|tuple
+        BaseDecodeHead(32, 16, num_classes=19, input_transform='resize_concat')
+
+    with pytest.raises(AssertionError):
+        # in_index should be list|tuple
+        BaseDecodeHead([32],
+                       16,
+                       in_index=-1,
+                       num_classes=19,
+                       input_transform='resize_concat')
+
+    with pytest.raises(AssertionError):
+        # len(in_index) should equal len(in_channels)
+        BaseDecodeHead([32, 16],
+                       16,
+                       num_classes=19,
+                       in_index=[-1],
+                       input_transform='resize_concat')
+
+    with pytest.raises(ValueError):
+        # out_channels should be equal to num_classes
+        BaseDecodeHead(32, 16, num_classes=19, out_channels=18)
+
+    # test out_channels
+    head = BaseDecodeHead(32, 16, num_classes=2)
+    assert head.out_channels == 2
+
+    # test out_channels == 1 and num_classes == 2
+    head = BaseDecodeHead(32, 16, num_classes=2, out_channels=1)
+    assert head.out_channels == 1 and head.num_classes == 2
+
+    # test default dropout
+    head = BaseDecodeHead(32, 16, num_classes=19)
+    assert hasattr(head, 'dropout') and head.dropout.p == 0.1
+
+    # test set dropout
+    head = BaseDecodeHead(32, 16, num_classes=19, dropout_ratio=0.2)
+    assert hasattr(head, 'dropout') and head.dropout.p == 0.2
+
+    # test no input_transform
+    inputs = [torch.randn(1, 32, 45, 45)]
+    head = BaseDecodeHead(32, 16, num_classes=19)
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    assert head.in_channels == 32
+    assert head.input_transform is None
+    transformed_inputs = head._transform_inputs(inputs)
+    assert transformed_inputs.shape == (1, 32, 45, 45)
+
+    # test input_transform = resize_concat
+    inputs = [torch.randn(1, 32, 45, 45), torch.randn(1, 16, 21, 21)]
+    head = BaseDecodeHead([32, 16],
+                          16,
+                          num_classes=19,
+                          in_index=[0, 1],
+                          input_transform='resize_concat')
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    assert head.in_channels == 48
+    assert head.input_transform == 'resize_concat'
+    transformed_inputs = head._transform_inputs(inputs)
+    assert transformed_inputs.shape == (1, 48, 45, 45)
+
+    # test multi-loss, loss_decode is dict
+    with pytest.raises(TypeError):
+        # loss_decode must be a dict or sequence of dict.
+        BaseDecodeHead(3, 16, num_classes=19, loss_decode=['CrossEntropyLoss'])
+
+    inputs = torch.randn(2, 19, 8, 8).float()
+    data_samples = [
+        SegDataSample(gt_sem_seg=PixelData(data=torch.ones(64, 64).long()))
+        for _ in range(2)
+    ]
+
+    head = BaseDecodeHead(
+        3,
+        16,
+        num_classes=19,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    loss = head.loss_by_feat(
+        seg_logits=inputs, batch_data_samples=data_samples)
+    assert 'loss_ce' in loss
+
+    # test multi-loss, loss_decode is list of dict
+    inputs = torch.randn(2, 19, 8, 8).float()
+    data_samples = [
+        SegDataSample(gt_sem_seg=PixelData(data=torch.ones(64, 64).long()))
+        for _ in range(2)
+    ]
+    head = BaseDecodeHead(
+        3,
+        16,
+        num_classes=19,
+        loss_decode=[
+            dict(type='CrossEntropyLoss', loss_name='loss_1'),
+            dict(type='CrossEntropyLoss', loss_name='loss_2')
+        ])
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+
+    loss = head.loss_by_feat(
+        seg_logits=inputs, batch_data_samples=data_samples)
+    assert 'loss_1' in loss
+    assert 'loss_2' in loss
+
+    # 'loss_decode' must be a dict or sequence of dict
+    with pytest.raises(TypeError):
+        BaseDecodeHead(3, 16, num_classes=19, loss_decode=['CrossEntropyLoss'])
+    with pytest.raises(TypeError):
+        BaseDecodeHead(3, 16, num_classes=19, loss_decode=0)
+
+    # test multi-loss, loss_decode is list of dict
+    inputs = torch.randn(2, 19, 8, 8).float()
+    data_samples = [
+        SegDataSample(gt_sem_seg=PixelData(data=torch.ones(64, 64).long()))
+        for _ in range(2)
+    ]
+    head = BaseDecodeHead(
+        3,
+        16,
+        num_classes=19,
+        loss_decode=(dict(type='CrossEntropyLoss', loss_name='loss_1'),
+                     dict(type='CrossEntropyLoss', loss_name='loss_2'),
+                     dict(type='CrossEntropyLoss', loss_name='loss_3')))
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    loss = head.loss_by_feat(
+        seg_logits=inputs, batch_data_samples=data_samples)
+    assert 'loss_1' in loss
+    assert 'loss_2' in loss
+    assert 'loss_3' in loss
+
+    # test multi-loss, loss_decode is list of dict, names of them are identical
+    inputs = torch.randn(2, 19, 8, 8).float()
+    data_samples = [
+        SegDataSample(gt_sem_seg=PixelData(data=torch.ones(64, 64).long()))
+        for _ in range(2)
+    ]
+    head = BaseDecodeHead(
+        3,
+        16,
+        num_classes=19,
+        loss_decode=(dict(type='CrossEntropyLoss', loss_name='loss_ce'),
+                     dict(type='CrossEntropyLoss', loss_name='loss_ce'),
+                     dict(type='CrossEntropyLoss', loss_name='loss_ce')))
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    loss_3 = head.loss_by_feat(
+        seg_logits=inputs, batch_data_samples=data_samples)
+
+    head = BaseDecodeHead(
+        3,
+        16,
+        num_classes=19,
+        loss_decode=(dict(type='CrossEntropyLoss', loss_name='loss_ce')))
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    loss = head.loss_by_feat(
+        seg_logits=inputs, batch_data_samples=data_samples)
+    assert 'loss_ce' in loss
+    assert 'loss_ce' in loss_3
+    assert loss_3['loss_ce'] == 3 * loss['loss_ce']
diff --git a/mmsegmentation/tests/test_models/test_heads/test_dm_head.py b/mmsegmentation/tests/test_models/test_heads/test_dm_head.py
new file mode 100644
index 0000000..a922ff7
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_dm_head.py
@@ -0,0 +1,59 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.decode_heads import DMHead
+from .utils import _conv_has_norm, to_cuda
+
+
+def test_dm_head():
+
+    with pytest.raises(AssertionError):
+        # filter_sizes must be list|tuple
+        DMHead(in_channels=8, channels=4, num_classes=19, filter_sizes=1)
+
+    # test no norm_cfg
+    head = DMHead(in_channels=8, channels=4, num_classes=19)
+    assert not _conv_has_norm(head, sync_bn=False)
+
+    # test with norm_cfg
+    head = DMHead(
+        in_channels=8,
+        channels=4,
+        num_classes=19,
+        norm_cfg=dict(type='SyncBN'))
+    assert _conv_has_norm(head, sync_bn=True)
+
+    # fusion=True
+    inputs = [torch.randn(1, 8, 23, 23)]
+    head = DMHead(
+        in_channels=8,
+        channels=4,
+        num_classes=19,
+        filter_sizes=(1, 3, 5),
+        fusion=True)
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    assert head.fusion is True
+    assert head.dcm_modules[0].filter_size == 1
+    assert head.dcm_modules[1].filter_size == 3
+    assert head.dcm_modules[2].filter_size == 5
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 23, 23)
+
+    # fusion=False
+    inputs = [torch.randn(1, 8, 23, 23)]
+    head = DMHead(
+        in_channels=8,
+        channels=4,
+        num_classes=19,
+        filter_sizes=(1, 3, 5),
+        fusion=False)
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    assert head.fusion is False
+    assert head.dcm_modules[0].filter_size == 1
+    assert head.dcm_modules[1].filter_size == 3
+    assert head.dcm_modules[2].filter_size == 5
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 23, 23)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_dnl_head.py b/mmsegmentation/tests/test_models/test_heads/test_dnl_head.py
new file mode 100644
index 0000000..720cb07
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_dnl_head.py
@@ -0,0 +1,44 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+
+from mmseg.models.decode_heads import DNLHead
+from .utils import to_cuda
+
+
+def test_dnl_head():
+    # DNL with 'embedded_gaussian' mode
+    head = DNLHead(in_channels=8, channels=4, num_classes=19)
+    assert len(head.convs) == 2
+    assert hasattr(head, 'dnl_block')
+    assert head.dnl_block.temperature == 0.05
+    inputs = [torch.randn(1, 8, 23, 23)]
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 23, 23)
+
+    # NonLocal2d with 'dot_product' mode
+    head = DNLHead(
+        in_channels=8, channels=4, num_classes=19, mode='dot_product')
+    inputs = [torch.randn(1, 8, 23, 23)]
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 23, 23)
+
+    # NonLocal2d with 'gaussian' mode
+    head = DNLHead(in_channels=8, channels=4, num_classes=19, mode='gaussian')
+    inputs = [torch.randn(1, 8, 23, 23)]
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 23, 23)
+
+    # NonLocal2d with 'concatenation' mode
+    head = DNLHead(
+        in_channels=8, channels=4, num_classes=19, mode='concatenation')
+    inputs = [torch.randn(1, 8, 23, 23)]
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 23, 23)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_dpt_head.py b/mmsegmentation/tests/test_models/test_heads/test_dpt_head.py
new file mode 100644
index 0000000..0a6af61
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_dpt_head.py
@@ -0,0 +1,49 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.decode_heads import DPTHead
+
+
+def test_dpt_head():
+
+    with pytest.raises(AssertionError):
+        # input_transform must be 'multiple_select'
+        head = DPTHead(
+            in_channels=[768, 768, 768, 768],
+            channels=4,
+            num_classes=19,
+            in_index=[0, 1, 2, 3])
+
+    head = DPTHead(
+        in_channels=[768, 768, 768, 768],
+        channels=4,
+        num_classes=19,
+        in_index=[0, 1, 2, 3],
+        input_transform='multiple_select')
+
+    inputs = [[torch.randn(4, 768, 2, 2),
+               torch.randn(4, 768)] for _ in range(4)]
+    output = head(inputs)
+    assert output.shape == torch.Size((4, 19, 16, 16))
+
+    # test readout operation
+    head = DPTHead(
+        in_channels=[768, 768, 768, 768],
+        channels=4,
+        num_classes=19,
+        in_index=[0, 1, 2, 3],
+        input_transform='multiple_select',
+        readout_type='add')
+    output = head(inputs)
+    assert output.shape == torch.Size((4, 19, 16, 16))
+
+    head = DPTHead(
+        in_channels=[768, 768, 768, 768],
+        channels=4,
+        num_classes=19,
+        in_index=[0, 1, 2, 3],
+        input_transform='multiple_select',
+        readout_type='project')
+    output = head(inputs)
+    assert output.shape == torch.Size((4, 19, 16, 16))
diff --git a/mmsegmentation/tests/test_models/test_heads/test_ema_head.py b/mmsegmentation/tests/test_models/test_heads/test_ema_head.py
new file mode 100644
index 0000000..1811cd2
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_ema_head.py
@@ -0,0 +1,23 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+
+from mmseg.models.decode_heads import EMAHead
+from .utils import to_cuda
+
+
+def test_emanet_head():
+    head = EMAHead(
+        in_channels=4,
+        ema_channels=3,
+        channels=2,
+        num_stages=3,
+        num_bases=2,
+        num_classes=19)
+    for param in head.ema_mid_conv.parameters():
+        assert not param.requires_grad
+    assert hasattr(head, 'ema_module')
+    inputs = [torch.randn(1, 4, 23, 23)]
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 23, 23)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_fcn_head.py b/mmsegmentation/tests/test_models/test_heads/test_fcn_head.py
new file mode 100644
index 0000000..664b543
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_fcn_head.py
@@ -0,0 +1,131 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+from mmcv.cnn import ConvModule, DepthwiseSeparableConvModule
+from mmengine.utils.dl_utils.parrots_wrapper import SyncBatchNorm
+
+from mmseg.models.decode_heads import DepthwiseSeparableFCNHead, FCNHead
+from .utils import to_cuda
+
+
+def test_fcn_head():
+
+    with pytest.raises(AssertionError):
+        # num_convs must be not less than 0
+        FCNHead(num_classes=19, num_convs=-1)
+
+    # test no norm_cfg
+    head = FCNHead(in_channels=8, channels=4, num_classes=19)
+    for m in head.modules():
+        if isinstance(m, ConvModule):
+            assert not m.with_norm
+
+    # test with norm_cfg
+    head = FCNHead(
+        in_channels=8,
+        channels=4,
+        num_classes=19,
+        norm_cfg=dict(type='SyncBN'))
+    for m in head.modules():
+        if isinstance(m, ConvModule):
+            assert m.with_norm and isinstance(m.bn, SyncBatchNorm)
+
+    # test concat_input=False
+    inputs = [torch.randn(1, 8, 23, 23)]
+    head = FCNHead(
+        in_channels=8, channels=4, num_classes=19, concat_input=False)
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    assert len(head.convs) == 2
+    assert not head.concat_input and not hasattr(head, 'conv_cat')
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 23, 23)
+
+    # test concat_input=True
+    inputs = [torch.randn(1, 8, 23, 23)]
+    head = FCNHead(
+        in_channels=8, channels=4, num_classes=19, concat_input=True)
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    assert len(head.convs) == 2
+    assert head.concat_input
+    assert head.conv_cat.in_channels == 12
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 23, 23)
+
+    # test kernel_size=3
+    inputs = [torch.randn(1, 8, 23, 23)]
+    head = FCNHead(in_channels=8, channels=4, num_classes=19)
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    for i in range(len(head.convs)):
+        assert head.convs[i].kernel_size == (3, 3)
+        assert head.convs[i].padding == 1
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 23, 23)
+
+    # test kernel_size=1
+    inputs = [torch.randn(1, 8, 23, 23)]
+    head = FCNHead(in_channels=8, channels=4, num_classes=19, kernel_size=1)
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    for i in range(len(head.convs)):
+        assert head.convs[i].kernel_size == (1, 1)
+        assert head.convs[i].padding == 0
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 23, 23)
+
+    # test num_conv
+    inputs = [torch.randn(1, 8, 23, 23)]
+    head = FCNHead(in_channels=8, channels=4, num_classes=19, num_convs=1)
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    assert len(head.convs) == 1
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 23, 23)
+
+    # test num_conv = 0
+    inputs = [torch.randn(1, 8, 23, 23)]
+    head = FCNHead(
+        in_channels=8,
+        channels=8,
+        num_classes=19,
+        num_convs=0,
+        concat_input=False)
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    assert isinstance(head.convs, torch.nn.Identity)
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 23, 23)
+
+
+def test_sep_fcn_head():
+    # test sep_fcn_head with concat_input=False
+    head = DepthwiseSeparableFCNHead(
+        in_channels=128,
+        channels=128,
+        concat_input=False,
+        num_classes=19,
+        in_index=-1,
+        norm_cfg=dict(type='BN', requires_grad=True, momentum=0.01))
+    x = [torch.rand(2, 128, 8, 8)]
+    output = head(x)
+    assert output.shape == (2, head.num_classes, 8, 8)
+    assert not head.concat_input
+    assert isinstance(head.convs[0], DepthwiseSeparableConvModule)
+    assert isinstance(head.convs[1], DepthwiseSeparableConvModule)
+    assert head.conv_seg.kernel_size == (1, 1)
+
+    head = DepthwiseSeparableFCNHead(
+        in_channels=64,
+        channels=64,
+        concat_input=True,
+        num_classes=19,
+        in_index=-1,
+        norm_cfg=dict(type='BN', requires_grad=True, momentum=0.01))
+    x = [torch.rand(3, 64, 8, 8)]
+    output = head(x)
+    assert output.shape == (3, head.num_classes, 8, 8)
+    assert head.concat_input
+    assert isinstance(head.convs[0], DepthwiseSeparableConvModule)
+    assert isinstance(head.convs[1], DepthwiseSeparableConvModule)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_gc_head.py b/mmsegmentation/tests/test_models/test_heads/test_gc_head.py
new file mode 100644
index 0000000..c62ac9a
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_gc_head.py
@@ -0,0 +1,16 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+
+from mmseg.models.decode_heads import GCHead
+from .utils import to_cuda
+
+
+def test_gc_head():
+    head = GCHead(in_channels=4, channels=4, num_classes=19)
+    assert len(head.convs) == 2
+    assert hasattr(head, 'gc_block')
+    inputs = [torch.randn(1, 4, 23, 23)]
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 23, 23)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_ham_head.py b/mmsegmentation/tests/test_models/test_heads/test_ham_head.py
new file mode 100644
index 0000000..f802d2d
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_ham_head.py
@@ -0,0 +1,44 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+
+from mmseg.models.decode_heads import LightHamHead
+from .utils import _conv_has_norm, to_cuda
+
+ham_norm_cfg = dict(type='GN', num_groups=32, requires_grad=True)
+
+
+def test_ham_head():
+
+    # test without sync_bn
+    head = LightHamHead(
+        in_channels=[16, 32, 64],
+        in_index=[1, 2, 3],
+        channels=64,
+        ham_channels=64,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=ham_norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
+        ham_kwargs=dict(
+            MD_S=1,
+            MD_R=64,
+            train_steps=6,
+            eval_steps=7,
+            inv_t=100,
+            rand_init=True))
+    assert not _conv_has_norm(head, sync_bn=False)
+
+    inputs = [
+        torch.randn(1, 8, 32, 32),
+        torch.randn(1, 16, 16, 16),
+        torch.randn(1, 32, 8, 8),
+        torch.randn(1, 64, 4, 4)
+    ]
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    assert head.in_channels == [16, 32, 64]
+    assert head.hamburger.ham_in.in_channels == 64
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 16, 16)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_isa_head.py b/mmsegmentation/tests/test_models/test_heads/test_isa_head.py
new file mode 100644
index 0000000..b177f6d
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_isa_head.py
@@ -0,0 +1,20 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+
+from mmseg.models.decode_heads import ISAHead
+from .utils import to_cuda
+
+
+def test_isa_head():
+
+    inputs = [torch.randn(1, 8, 23, 23)]
+    isa_head = ISAHead(
+        in_channels=8,
+        channels=4,
+        num_classes=19,
+        isa_channels=4,
+        down_factor=(8, 8))
+    if torch.cuda.is_available():
+        isa_head, inputs = to_cuda(isa_head, inputs)
+    output = isa_head(inputs)
+    assert output.shape == (1, isa_head.num_classes, 23, 23)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_lraspp_head.py b/mmsegmentation/tests/test_models/test_heads/test_lraspp_head.py
new file mode 100644
index 0000000..a46e6a1
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_lraspp_head.py
@@ -0,0 +1,68 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.decode_heads import LRASPPHead
+
+
+def test_lraspp_head():
+    with pytest.raises(ValueError):
+        # check invalid input_transform
+        LRASPPHead(
+            in_channels=(4, 4, 123),
+            in_index=(0, 1, 2),
+            channels=32,
+            input_transform='resize_concat',
+            dropout_ratio=0.1,
+            num_classes=19,
+            norm_cfg=dict(type='BN'),
+            act_cfg=dict(type='ReLU'),
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
+
+    with pytest.raises(AssertionError):
+        # check invalid branch_channels
+        LRASPPHead(
+            in_channels=(4, 4, 123),
+            in_index=(0, 1, 2),
+            channels=32,
+            branch_channels=64,
+            input_transform='multiple_select',
+            dropout_ratio=0.1,
+            num_classes=19,
+            norm_cfg=dict(type='BN'),
+            act_cfg=dict(type='ReLU'),
+            align_corners=False,
+            loss_decode=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
+
+    # test with default settings
+    lraspp_head = LRASPPHead(
+        in_channels=(4, 4, 123),
+        in_index=(0, 1, 2),
+        channels=32,
+        input_transform='multiple_select',
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=dict(type='BN'),
+        act_cfg=dict(type='ReLU'),
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
+    inputs = [
+        torch.randn(2, 4, 45, 45),
+        torch.randn(2, 4, 28, 28),
+        torch.randn(2, 123, 14, 14)
+    ]
+    with pytest.raises(RuntimeError):
+        # check invalid inputs
+        output = lraspp_head(inputs)
+
+    inputs = [
+        torch.randn(2, 4, 111, 111),
+        torch.randn(2, 4, 77, 77),
+        torch.randn(2, 123, 55, 55)
+    ]
+    output = lraspp_head(inputs)
+    assert output.shape == (2, 19, 111, 111)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_mask2former_head.py b/mmsegmentation/tests/test_models/test_heads/test_mask2former_head.py
new file mode 100644
index 0000000..45b353d
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_mask2former_head.py
@@ -0,0 +1,153 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from mmengine import Config
+from mmengine.structures import PixelData
+
+from mmseg.models.decode_heads import Mask2FormerHead
+from mmseg.structures import SegDataSample
+from mmseg.utils import SampleList
+from .utils import to_cuda
+
+
+def test_mask2former_head():
+    num_classes = 19
+    cfg = dict(
+        in_channels=[96, 192, 384, 768],
+        strides=[4, 8, 16, 32],
+        feat_channels=256,
+        out_channels=256,
+        num_classes=num_classes,
+        num_queries=100,
+        num_transformer_feat_level=3,
+        align_corners=False,
+        pixel_decoder=dict(
+            type='mmdet.MSDeformAttnPixelDecoder',
+            num_outs=3,
+            norm_cfg=dict(type='GN', num_groups=32),
+            act_cfg=dict(type='ReLU'),
+            encoder=dict(  # DeformableDetrTransformerEncoder
+                num_layers=6,
+                layer_cfg=dict(  # DeformableDetrTransformerEncoderLayer
+                    self_attn_cfg=dict(  # MultiScaleDeformableAttention
+                        embed_dims=256,
+                        num_heads=8,
+                        num_levels=3,
+                        num_points=4,
+                        im2col_step=64,
+                        dropout=0.0,
+                        batch_first=True,
+                        norm_cfg=None,
+                        init_cfg=None),
+                    ffn_cfg=dict(
+                        embed_dims=256,
+                        feedforward_channels=1024,
+                        num_fcs=2,
+                        ffn_drop=0.0,
+                        act_cfg=dict(type='ReLU', inplace=True))),
+                init_cfg=None),
+            positional_encoding=dict(  # SinePositionalEncoding
+                num_feats=128, normalize=True),
+            init_cfg=None),
+        enforce_decoder_input_project=False,
+        positional_encoding=dict(  # SinePositionalEncoding
+            num_feats=128, normalize=True),
+        transformer_decoder=dict(  # Mask2FormerTransformerDecoder
+            return_intermediate=True,
+            num_layers=9,
+            layer_cfg=dict(  # Mask2FormerTransformerDecoderLayer
+                self_attn_cfg=dict(  # MultiheadAttention
+                    embed_dims=256,
+                    num_heads=8,
+                    attn_drop=0.0,
+                    proj_drop=0.0,
+                    dropout_layer=None,
+                    batch_first=True),
+                cross_attn_cfg=dict(  # MultiheadAttention
+                    embed_dims=256,
+                    num_heads=8,
+                    attn_drop=0.0,
+                    proj_drop=0.0,
+                    dropout_layer=None,
+                    batch_first=True),
+                ffn_cfg=dict(
+                    embed_dims=256,
+                    feedforward_channels=2048,
+                    num_fcs=2,
+                    act_cfg=dict(type='ReLU', inplace=True),
+                    ffn_drop=0.0,
+                    dropout_layer=None,
+                    add_identity=True)),
+            init_cfg=None),
+        loss_cls=dict(
+            type='mmdet.CrossEntropyLoss',
+            use_sigmoid=False,
+            loss_weight=2.0,
+            reduction='mean',
+            class_weight=[1.0] * num_classes + [0.1]),
+        loss_mask=dict(
+            type='mmdet.CrossEntropyLoss',
+            use_sigmoid=True,
+            reduction='mean',
+            loss_weight=5.0),
+        loss_dice=dict(
+            type='mmdet.DiceLoss',
+            use_sigmoid=True,
+            activate=True,
+            reduction='mean',
+            naive_dice=True,
+            eps=1.0,
+            loss_weight=5.0),
+        train_cfg=dict(
+            num_points=12544,
+            oversample_ratio=3.0,
+            importance_sample_ratio=0.75,
+            assigner=dict(
+                type='mmdet.HungarianAssigner',
+                match_costs=[
+                    dict(type='mmdet.ClassificationCost', weight=2.0),
+                    dict(
+                        type='mmdet.CrossEntropyLossCost',
+                        weight=5.0,
+                        use_sigmoid=True),
+                    dict(
+                        type='mmdet.DiceCost',
+                        weight=5.0,
+                        pred_act=True,
+                        eps=1.0)
+                ]),
+            sampler=dict(type='mmdet.MaskPseudoSampler')))
+    cfg = Config(cfg)
+    head = Mask2FormerHead(**cfg)
+
+    inputs = [
+        torch.rand((2, 96, 8, 8)),
+        torch.rand((2, 192, 4, 4)),
+        torch.rand((2, 384, 2, 2)),
+        torch.rand((2, 768, 1, 1))
+    ]
+
+    data_samples: SampleList = []
+    for i in range(2):
+        data_sample = SegDataSample()
+        img_meta = {}
+        img_meta['img_shape'] = (32, 32)
+        img_meta['ori_shape'] = (32, 32)
+        data_sample.gt_sem_seg = PixelData(
+            data=torch.randint(0, num_classes, (1, 32, 32)))
+        data_sample.set_metainfo(img_meta)
+        data_samples.append(data_sample)
+
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+        for data_sample in data_samples:
+            data_sample.gt_sem_seg.data = data_sample.gt_sem_seg.data.cuda()
+
+    loss_dict = head.loss(inputs, data_samples, None)
+    assert isinstance(loss_dict, dict)
+
+    batch_img_metas = []
+    for data_sample in data_samples:
+        batch_img_metas.append(data_sample.metainfo)
+
+    seg_logits = head.predict(inputs, batch_img_metas, None)
+    assert seg_logits.shape == torch.Size((2, num_classes, 32, 32))
diff --git a/mmsegmentation/tests/test_models/test_heads/test_maskformer_head.py b/mmsegmentation/tests/test_models/test_heads/test_maskformer_head.py
new file mode 100644
index 0000000..6a47239
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_maskformer_head.py
@@ -0,0 +1,54 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from os.path import dirname, join
+
+import torch
+from mmengine import Config
+from mmengine.registry import init_default_scope
+from mmengine.structures import PixelData
+
+from mmseg.registry import MODELS
+from mmseg.structures import SegDataSample
+
+
+def test_maskformer_head():
+    init_default_scope('mmseg')
+    repo_dpath = dirname(dirname(__file__))
+    cfg = Config.fromfile(
+        join(
+            repo_dpath,
+            '../../configs/maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512.py'  # noqa
+        ))
+    cfg.model.train_cfg = None
+    decode_head = MODELS.build(cfg.model.decode_head)
+    inputs = (torch.randn(1, 256, 32, 32), torch.randn(1, 512, 16, 16),
+              torch.randn(1, 1024, 8, 8), torch.randn(1, 2048, 4, 4))
+    # test inference
+    batch_img_metas = [
+        dict(
+            scale_factor=(1.0, 1.0),
+            img_shape=(512, 683),
+            ori_shape=(512, 683))
+    ]
+    test_cfg = dict(mode='whole')
+    output = decode_head.predict(inputs, batch_img_metas, test_cfg)
+    assert output.shape == (1, 150, 512, 683)
+
+    # test training
+    inputs = (torch.randn(2, 256, 32, 32), torch.randn(2, 512, 16, 16),
+              torch.randn(2, 1024, 8, 8), torch.randn(2, 2048, 4, 4))
+    batch_data_samples = []
+    img_meta = {
+        'img_shape': (512, 512),
+        'ori_shape': (480, 640),
+        'pad_shape': (512, 512),
+        'scale_factor': (1.425, 1.425),
+    }
+    for _ in range(2):
+        data_sample = SegDataSample(
+            gt_sem_seg=PixelData(data=torch.ones(512, 512).long()))
+        data_sample.set_metainfo(img_meta)
+        batch_data_samples.append(data_sample)
+    train_cfg = {}
+    losses = decode_head.loss(inputs, batch_data_samples, train_cfg)
+    assert (loss in losses.keys()
+            for loss in ('loss_cls', 'loss_mask', 'loss_dice'))
diff --git a/mmsegmentation/tests/test_models/test_heads/test_nl_head.py b/mmsegmentation/tests/test_models/test_heads/test_nl_head.py
new file mode 100644
index 0000000..d4ef0b9
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_nl_head.py
@@ -0,0 +1,16 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+
+from mmseg.models.decode_heads import NLHead
+from .utils import to_cuda
+
+
+def test_nl_head():
+    head = NLHead(in_channels=8, channels=4, num_classes=19)
+    assert len(head.convs) == 2
+    assert hasattr(head, 'nl_block')
+    inputs = [torch.randn(1, 8, 23, 23)]
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 23, 23)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_ocr_head.py b/mmsegmentation/tests/test_models/test_heads/test_ocr_head.py
new file mode 100644
index 0000000..5e5d669
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_ocr_head.py
@@ -0,0 +1,19 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+
+from mmseg.models.decode_heads import FCNHead, OCRHead
+from .utils import to_cuda
+
+
+def test_ocr_head():
+
+    inputs = [torch.randn(1, 8, 23, 23)]
+    ocr_head = OCRHead(
+        in_channels=8, channels=4, num_classes=19, ocr_channels=8)
+    fcn_head = FCNHead(in_channels=8, channels=4, num_classes=19)
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(ocr_head, inputs)
+        head, inputs = to_cuda(fcn_head, inputs)
+    prev_output = fcn_head(inputs)
+    output = ocr_head(inputs, prev_output)
+    assert output.shape == (1, ocr_head.num_classes, 23, 23)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_pidnet_head.py b/mmsegmentation/tests/test_models/test_heads/test_pidnet_head.py
new file mode 100644
index 0000000..a624737
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_pidnet_head.py
@@ -0,0 +1,89 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from mmengine.registry import init_default_scope
+
+from mmseg.registry import MODELS
+
+
+def test_pidnet_head():
+    init_default_scope('mmseg')
+
+    # Test PIDNet decode head Standard Forward
+    norm_cfg = dict(type='BN', requires_grad=True)
+    backbone_cfg = dict(
+        type='PIDNet',
+        in_channels=3,
+        channels=32,
+        ppm_channels=96,
+        num_stem_blocks=2,
+        num_branch_blocks=3,
+        align_corners=False,
+        norm_cfg=norm_cfg,
+        act_cfg=dict(type='ReLU', inplace=True))
+    decode_head_cfg = dict(
+        type='PIDHead',
+        in_channels=128,
+        channels=128,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        act_cfg=dict(type='ReLU', inplace=True),
+        align_corners=True,
+        loss_decode=[
+            dict(
+                type='CrossEntropyLoss',
+                use_sigmoid=False,
+                class_weight=[
+                    0.8373, 0.918, 0.866, 1.0345, 1.0166, 0.9969, 0.9754,
+                    1.0489, 0.8786, 1.0023, 0.9539, 0.9843, 1.1116, 0.9037,
+                    1.0865, 1.0955, 1.0865, 1.1529, 1.0507
+                ],
+                loss_weight=0.4),
+            dict(
+                type='OhemCrossEntropy',
+                thres=0.9,
+                min_kept=131072,
+                class_weight=[
+                    0.8373, 0.918, 0.866, 1.0345, 1.0166, 0.9969, 0.9754,
+                    1.0489, 0.8786, 1.0023, 0.9539, 0.9843, 1.1116, 0.9037,
+                    1.0865, 1.0955, 1.0865, 1.1529, 1.0507
+                ],
+                loss_weight=1.0),
+            dict(type='BoundaryLoss', loss_weight=20.0),
+            dict(
+                type='OhemCrossEntropy',
+                thres=0.9,
+                min_kept=131072,
+                class_weight=[
+                    0.8373, 0.918, 0.866, 1.0345, 1.0166, 0.9969, 0.9754,
+                    1.0489, 0.8786, 1.0023, 0.9539, 0.9843, 1.1116, 0.9037,
+                    1.0865, 1.0955, 1.0865, 1.1529, 1.0507
+                ],
+                loss_weight=1.0)
+        ])
+    backbone = MODELS.build(backbone_cfg)
+    head = MODELS.build(decode_head_cfg)
+
+    # Test train mode
+    backbone.train()
+    head.train()
+    batch_size = 2
+    imgs = torch.randn(batch_size, 3, 64, 128)
+    feats = backbone(imgs)
+    seg_logit = head(feats)
+
+    assert isinstance(seg_logit, tuple)
+    assert len(seg_logit) == 3
+
+    p_logits, i_logits, d_logits = seg_logit
+    assert p_logits.shape == (batch_size, 19, 8, 16)
+    assert i_logits.shape == (batch_size, 19, 8, 16)
+    assert d_logits.shape == (batch_size, 1, 8, 16)
+
+    # Test eval mode
+    backbone.eval()
+    head.eval()
+    feats = backbone(imgs)
+    seg_logit = head(feats)
+
+    assert isinstance(seg_logit, torch.Tensor)
+    assert seg_logit.shape == (batch_size, 19, 8, 16)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_psa_head.py b/mmsegmentation/tests/test_models/test_heads/test_psa_head.py
new file mode 100644
index 0000000..34f592b
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_psa_head.py
@@ -0,0 +1,122 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.decode_heads import PSAHead
+from .utils import _conv_has_norm, to_cuda
+
+
+def test_psa_head():
+
+    with pytest.raises(AssertionError):
+        # psa_type must be in 'bi-direction', 'collect', 'distribute'
+        PSAHead(
+            in_channels=4,
+            channels=2,
+            num_classes=19,
+            mask_size=(13, 13),
+            psa_type='gather')
+
+    # test no norm_cfg
+    head = PSAHead(
+        in_channels=4, channels=2, num_classes=19, mask_size=(13, 13))
+    assert not _conv_has_norm(head, sync_bn=False)
+
+    # test with norm_cfg
+    head = PSAHead(
+        in_channels=4,
+        channels=2,
+        num_classes=19,
+        mask_size=(13, 13),
+        norm_cfg=dict(type='SyncBN'))
+    assert _conv_has_norm(head, sync_bn=True)
+
+    # test 'bi-direction' psa_type
+    inputs = [torch.randn(1, 4, 13, 13)]
+    head = PSAHead(
+        in_channels=4, channels=2, num_classes=19, mask_size=(13, 13))
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 13, 13)
+
+    # test 'bi-direction' psa_type, shrink_factor=1
+    inputs = [torch.randn(1, 4, 13, 13)]
+    head = PSAHead(
+        in_channels=4,
+        channels=2,
+        num_classes=19,
+        mask_size=(13, 13),
+        shrink_factor=1)
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 13, 13)
+
+    # test 'bi-direction' psa_type with soft_max
+    inputs = [torch.randn(1, 4, 13, 13)]
+    head = PSAHead(
+        in_channels=4,
+        channels=2,
+        num_classes=19,
+        mask_size=(13, 13),
+        psa_softmax=True)
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 13, 13)
+
+    # test 'collect' psa_type
+    inputs = [torch.randn(1, 4, 13, 13)]
+    head = PSAHead(
+        in_channels=4,
+        channels=2,
+        num_classes=19,
+        mask_size=(13, 13),
+        psa_type='collect')
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 13, 13)
+
+    # test 'collect' psa_type, shrink_factor=1
+    inputs = [torch.randn(1, 4, 13, 13)]
+    head = PSAHead(
+        in_channels=4,
+        channels=2,
+        num_classes=19,
+        mask_size=(13, 13),
+        shrink_factor=1,
+        psa_type='collect')
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 13, 13)
+
+    # test 'collect' psa_type, shrink_factor=1, compact=True
+    inputs = [torch.randn(1, 4, 13, 13)]
+    head = PSAHead(
+        in_channels=4,
+        channels=2,
+        num_classes=19,
+        mask_size=(13, 13),
+        psa_type='collect',
+        shrink_factor=1,
+        compact=True)
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 13, 13)
+
+    # test 'distribute' psa_type
+    inputs = [torch.randn(1, 4, 13, 13)]
+    head = PSAHead(
+        in_channels=4,
+        channels=2,
+        num_classes=19,
+        mask_size=(13, 13),
+        psa_type='distribute')
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 13, 13)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_psp_head.py b/mmsegmentation/tests/test_models/test_heads/test_psp_head.py
new file mode 100644
index 0000000..fde4087
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_psp_head.py
@@ -0,0 +1,36 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.decode_heads import PSPHead
+from .utils import _conv_has_norm, to_cuda
+
+
+def test_psp_head():
+
+    with pytest.raises(AssertionError):
+        # pool_scales must be list|tuple
+        PSPHead(in_channels=4, channels=2, num_classes=19, pool_scales=1)
+
+    # test no norm_cfg
+    head = PSPHead(in_channels=4, channels=2, num_classes=19)
+    assert not _conv_has_norm(head, sync_bn=False)
+
+    # test with norm_cfg
+    head = PSPHead(
+        in_channels=4,
+        channels=2,
+        num_classes=19,
+        norm_cfg=dict(type='SyncBN'))
+    assert _conv_has_norm(head, sync_bn=True)
+
+    inputs = [torch.randn(1, 4, 23, 23)]
+    head = PSPHead(
+        in_channels=4, channels=2, num_classes=19, pool_scales=(1, 2, 3))
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    assert head.psp_modules[0][0].output_size == 1
+    assert head.psp_modules[1][0].output_size == 2
+    assert head.psp_modules[2][0].output_size == 3
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 23, 23)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_san_head.py b/mmsegmentation/tests/test_models/test_heads/test_san_head.py
new file mode 100644
index 0000000..af85a6e
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_san_head.py
@@ -0,0 +1,126 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from mmengine import Config
+from mmengine.structures import PixelData
+
+from mmseg.models.decode_heads import SideAdapterCLIPHead
+from mmseg.structures import SegDataSample
+from .utils import list_to_cuda
+
+
+def test_san_head():
+    H, W = (64, 64)
+    clip_channels = 64
+    img_channels = 4
+    num_queries = 40
+    out_dims = 64
+    num_classes = 19
+    cfg = dict(
+        num_classes=num_classes,
+        deep_supervision_idxs=[4],
+        san_cfg=dict(
+            in_channels=img_channels,
+            embed_dims=128,
+            clip_channels=clip_channels,
+            num_queries=num_queries,
+            cfg_encoder=dict(num_encode_layer=4, mlp_ratio=2, num_heads=2),
+            cfg_decoder=dict(
+                num_heads=4,
+                num_layers=1,
+                embed_channels=32,
+                mlp_channels=32,
+                num_mlp=2,
+                rescale=True)),
+        maskgen_cfg=dict(
+            sos_token_num=num_queries,
+            embed_dims=clip_channels,
+            out_dims=out_dims,
+            num_heads=4,
+            mlp_ratio=2),
+        train_cfg=dict(
+            num_points=100,
+            oversample_ratio=3.0,
+            importance_sample_ratio=0.75,
+            assigner=dict(
+                type='HungarianAssigner',
+                match_costs=[
+                    dict(type='ClassificationCost', weight=2.0),
+                    dict(
+                        type='CrossEntropyLossCost',
+                        weight=5.0,
+                        use_sigmoid=True),
+                    dict(type='DiceCost', weight=5.0, pred_act=True, eps=1.0)
+                ])),
+        loss_decode=[
+            dict(
+                type='CrossEntropyLoss',
+                loss_name='loss_cls_ce',
+                loss_weight=2.0,
+                class_weight=[1.0] * num_classes + [0.1]),
+            dict(
+                type='CrossEntropyLoss',
+                use_sigmoid=True,
+                loss_name='loss_mask_ce',
+                loss_weight=5.0),
+            dict(
+                type='DiceLoss',
+                ignore_index=None,
+                naive_dice=True,
+                eps=1,
+                loss_name='loss_mask_dice',
+                loss_weight=5.0)
+        ])
+
+    cfg = Config(cfg)
+    head = SideAdapterCLIPHead(**cfg)
+
+    inputs = torch.rand((2, img_channels, H, W))
+    clip_feature = [[
+        torch.rand((2, clip_channels, H // 2, W // 2)),
+        torch.rand((2, clip_channels))
+    ],
+                    [
+                        torch.rand((2, clip_channels, H // 2, W // 2)),
+                        torch.rand((2, clip_channels))
+                    ],
+                    [
+                        torch.rand((2, clip_channels, H // 2, W // 2)),
+                        torch.rand((2, clip_channels))
+                    ],
+                    [
+                        torch.rand((2, clip_channels, H // 2, W // 2)),
+                        torch.rand((2, clip_channels))
+                    ]]
+    class_embed = torch.rand((num_classes + 1, out_dims))
+
+    data_samples = []
+    for i in range(2):
+        data_sample = SegDataSample()
+        img_meta = {}
+        img_meta['img_shape'] = (H, W)
+        img_meta['ori_shape'] = (H, W)
+        data_sample.gt_sem_seg = PixelData(
+            data=torch.randint(0, num_classes, (1, H, W)))
+        data_sample.set_metainfo(img_meta)
+        data_samples.append(data_sample)
+
+    batch_img_metas = []
+    for data_sample in data_samples:
+        batch_img_metas.append(data_sample.metainfo)
+
+    if torch.cuda.is_available():
+        head = head.cuda()
+        data = list_to_cuda([inputs, clip_feature, class_embed])
+        for data_sample in data_samples:
+            data_sample.gt_sem_seg.data = data_sample.gt_sem_seg.data.cuda()
+    else:
+        data = [inputs, clip_feature, class_embed]
+
+    # loss test
+    loss_dict = head.loss(data, data_samples, None)
+    assert isinstance(loss_dict, dict)
+
+    # prediction test
+    with torch.no_grad():
+        seg_logits = head.predict(data, batch_img_metas, None)
+    assert seg_logits.shape == torch.Size((2, num_classes, H, W))
diff --git a/mmsegmentation/tests/test_models/test_heads/test_segformer_head.py b/mmsegmentation/tests/test_models/test_heads/test_segformer_head.py
new file mode 100644
index 0000000..73afaba
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_segformer_head.py
@@ -0,0 +1,40 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.decode_heads import SegformerHead
+
+
+def test_segformer_head():
+    with pytest.raises(AssertionError):
+        # `in_channels` must have same length as `in_index`
+        SegformerHead(
+            in_channels=(1, 2, 3), in_index=(0, 1), channels=5, num_classes=2)
+
+    H, W = (64, 64)
+    in_channels = (32, 64, 160, 256)
+    shapes = [(H // 2**(i + 2), W // 2**(i + 2))
+              for i in range(len(in_channels))]
+    model = SegformerHead(
+        in_channels=in_channels,
+        in_index=[0, 1, 2, 3],
+        channels=256,
+        num_classes=19)
+
+    with pytest.raises(IndexError):
+        # in_index must match the input feature maps.
+        inputs = [
+            torch.randn((1, in_channel, *shape))
+            for in_channel, shape in zip(in_channels, shapes)
+        ][:3]
+        temp = model(inputs)
+
+    # Normal Input
+    # ((1, 32, 16, 16), (1, 64, 8, 8), (1, 160, 4, 4), (1, 256, 2, 2)
+    inputs = [
+        torch.randn((1, in_channel, *shape))
+        for in_channel, shape in zip(in_channels, shapes)
+    ]
+    temp = model(inputs)
+
+    assert temp.shape == (1, 19, H // 4, W // 4)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_segmenter_mask_head.py b/mmsegmentation/tests/test_models/test_heads/test_segmenter_mask_head.py
new file mode 100644
index 0000000..7b681ac
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_segmenter_mask_head.py
@@ -0,0 +1,24 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+
+from mmseg.models.decode_heads import SegmenterMaskTransformerHead
+from .utils import _conv_has_norm, to_cuda
+
+
+def test_segmenter_mask_transformer_head():
+    head = SegmenterMaskTransformerHead(
+        in_channels=2,
+        channels=2,
+        num_classes=150,
+        num_layers=2,
+        num_heads=3,
+        embed_dims=192,
+        dropout_ratio=0.0)
+    assert _conv_has_norm(head, sync_bn=True)
+    head.init_weights()
+
+    inputs = [torch.randn(1, 2, 32, 32)]
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 32, 32)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_setr_mla_head.py b/mmsegmentation/tests/test_models/test_heads/test_setr_mla_head.py
new file mode 100644
index 0000000..301bc0b
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_setr_mla_head.py
@@ -0,0 +1,63 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.decode_heads import SETRMLAHead
+from .utils import to_cuda
+
+
+def test_setr_mla_head(capsys):
+
+    with pytest.raises(AssertionError):
+        # MLA requires input multiple stage feature information.
+        SETRMLAHead(in_channels=8, channels=4, num_classes=19, in_index=1)
+
+    with pytest.raises(AssertionError):
+        # multiple in_indexs requires multiple in_channels.
+        SETRMLAHead(
+            in_channels=8, channels=4, num_classes=19, in_index=(0, 1, 2, 3))
+
+    with pytest.raises(AssertionError):
+        # channels should be len(in_channels) * mla_channels
+        SETRMLAHead(
+            in_channels=(8, 8, 8, 8),
+            channels=8,
+            mla_channels=4,
+            in_index=(0, 1, 2, 3),
+            num_classes=19)
+
+    # test inference of MLA head
+    img_size = (8, 8)
+    patch_size = 4
+    head = SETRMLAHead(
+        in_channels=(8, 8, 8, 8),
+        channels=16,
+        mla_channels=4,
+        in_index=(0, 1, 2, 3),
+        num_classes=19,
+        norm_cfg=dict(type='BN'))
+
+    h, w = img_size[0] // patch_size, img_size[1] // patch_size
+    # Input square NCHW format feature information
+    x = [
+        torch.randn(1, 8, h, w),
+        torch.randn(1, 8, h, w),
+        torch.randn(1, 8, h, w),
+        torch.randn(1, 8, h, w)
+    ]
+    if torch.cuda.is_available():
+        head, x = to_cuda(head, x)
+    out = head(x)
+    assert out.shape == (1, head.num_classes, h * 4, w * 4)
+
+    # Input non-square NCHW format feature information
+    x = [
+        torch.randn(1, 8, h, w * 2),
+        torch.randn(1, 8, h, w * 2),
+        torch.randn(1, 8, h, w * 2),
+        torch.randn(1, 8, h, w * 2)
+    ]
+    if torch.cuda.is_available():
+        head, x = to_cuda(head, x)
+    out = head(x)
+    assert out.shape == (1, head.num_classes, h * 4, w * 8)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_setr_up_head.py b/mmsegmentation/tests/test_models/test_heads/test_setr_up_head.py
new file mode 100644
index 0000000..a051922
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_setr_up_head.py
@@ -0,0 +1,56 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.decode_heads import SETRUPHead
+from .utils import to_cuda
+
+
+def test_setr_up_head(capsys):
+
+    with pytest.raises(AssertionError):
+        # kernel_size must be [1/3]
+        SETRUPHead(num_classes=19, kernel_size=2)
+
+    with pytest.raises(AssertionError):
+        # in_channels must be int type and in_channels must be same
+        # as embed_dim.
+        SETRUPHead(in_channels=(4, 4), channels=2, num_classes=19)
+
+    # test init_cfg of head
+    head = SETRUPHead(
+        in_channels=4,
+        channels=2,
+        norm_cfg=dict(type='SyncBN'),
+        num_classes=19,
+        init_cfg=dict(type='Kaiming'))
+    super(SETRUPHead, head).init_weights()
+
+    # test inference of Naive head
+    # the auxiliary head of Naive head is same as Naive head
+    img_size = (4, 4)
+    patch_size = 2
+    head = SETRUPHead(
+        in_channels=4,
+        channels=2,
+        num_classes=19,
+        num_convs=1,
+        up_scale=4,
+        kernel_size=1,
+        norm_cfg=dict(type='BN'))
+
+    h, w = img_size[0] // patch_size, img_size[1] // patch_size
+
+    # Input square NCHW format feature information
+    x = [torch.randn(1, 4, h, w)]
+    if torch.cuda.is_available():
+        head, x = to_cuda(head, x)
+    out = head(x)
+    assert out.shape == (1, head.num_classes, h * 4, w * 4)
+
+    # Input non-square NCHW format feature information
+    x = [torch.randn(1, 4, h, w * 2)]
+    if torch.cuda.is_available():
+        head, x = to_cuda(head, x)
+    out = head(x)
+    assert out.shape == (1, head.num_classes, h * 4, w * 8)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_uper_head.py b/mmsegmentation/tests/test_models/test_heads/test_uper_head.py
new file mode 100644
index 0000000..09456a8
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_uper_head.py
@@ -0,0 +1,35 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.decode_heads import UPerHead
+from .utils import _conv_has_norm, to_cuda
+
+
+def test_uper_head():
+
+    with pytest.raises(AssertionError):
+        # fpn_in_channels must be list|tuple
+        UPerHead(in_channels=4, channels=2, num_classes=19)
+
+    # test no norm_cfg
+    head = UPerHead(
+        in_channels=[4, 2], channels=2, num_classes=19, in_index=[-2, -1])
+    assert not _conv_has_norm(head, sync_bn=False)
+
+    # test with norm_cfg
+    head = UPerHead(
+        in_channels=[4, 2],
+        channels=2,
+        num_classes=19,
+        norm_cfg=dict(type='SyncBN'),
+        in_index=[-2, -1])
+    assert _conv_has_norm(head, sync_bn=True)
+
+    inputs = [torch.randn(1, 4, 45, 45), torch.randn(1, 2, 21, 21)]
+    head = UPerHead(
+        in_channels=[4, 2], channels=2, num_classes=19, in_index=[-2, -1])
+    if torch.cuda.is_available():
+        head, inputs = to_cuda(head, inputs)
+    outputs = head(inputs)
+    assert outputs.shape == (1, head.num_classes, 45, 45)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_vpd_depth_head.py b/mmsegmentation/tests/test_models/test_heads/test_vpd_depth_head.py
new file mode 100644
index 0000000..e3a4f75
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/test_vpd_depth_head.py
@@ -0,0 +1,50 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from unittest import TestCase
+
+import torch
+from mmengine.structures import PixelData
+
+from mmseg.models.decode_heads import VPDDepthHead
+from mmseg.structures import SegDataSample
+
+
+class TestVPDDepthHead(TestCase):
+
+    def setUp(self):
+        """Set up common resources."""
+        self.in_channels = [320, 640, 1280, 1280]
+        self.max_depth = 10.0
+        self.loss_decode = dict(
+            type='SiLogLoss'
+        )  # Replace with your actual loss type and parameters
+        self.vpd_depth_head = VPDDepthHead(
+            max_depth=self.max_depth,
+            in_channels=self.in_channels,
+            loss_decode=self.loss_decode)
+
+    def test_forward(self):
+        """Test the forward method."""
+        # Create a mock input tensor. Replace shape as per your needs.
+        x = [
+            torch.randn(1, 320, 32, 32),
+            torch.randn(1, 640, 16, 16),
+            torch.randn(1, 1280, 8, 8),
+            torch.randn(1, 1280, 4, 4)
+        ]
+
+        output = self.vpd_depth_head.forward(x)
+        print(output.shape)
+
+        self.assertEqual(output.shape, (1, 1, 256, 256))
+
+    def test_loss_by_feat(self):
+        """Test the loss_by_feat method."""
+        # Create mock data for `pred_depth_map` and `batch_data_samples`.
+        pred_depth_map = torch.randn(1, 1, 32, 32)
+        gt_depth_map = PixelData(data=torch.rand(1, 32, 32))
+        batch_data_samples = [SegDataSample(gt_depth_map=gt_depth_map)]
+
+        loss = self.vpd_depth_head.loss_by_feat(pred_depth_map,
+                                                batch_data_samples)
+
+        self.assertIsNotNone(loss)
diff --git a/mmsegmentation/tests/test_models/test_heads/utils.py b/mmsegmentation/tests/test_models/test_heads/utils.py
new file mode 100644
index 0000000..7282340
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_heads/utils.py
@@ -0,0 +1,31 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.cnn import ConvModule
+from mmengine.utils.dl_utils.parrots_wrapper import SyncBatchNorm
+
+
+def _conv_has_norm(module, sync_bn):
+    for m in module.modules():
+        if isinstance(m, ConvModule):
+            if not m.with_norm:
+                return False
+            if sync_bn:
+                if not isinstance(m.bn, SyncBatchNorm):
+                    return False
+    return True
+
+
+def to_cuda(module, data):
+    module = module.cuda()
+    if isinstance(data, list):
+        for i in range(len(data)):
+            data[i] = data[i].cuda()
+    return module, data
+
+
+def list_to_cuda(data):
+    if isinstance(data, list):
+        for i in range(len(data)):
+            data[i] = list_to_cuda(data[i])
+        return data
+    else:
+        return data.cuda()
diff --git a/mmsegmentation/tests/test_models/test_losses/test_cross_entropy_loss.py b/mmsegmentation/tests/test_models/test_losses/test_cross_entropy_loss.py
new file mode 100644
index 0000000..8c6b86d
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_losses/test_cross_entropy_loss.py
@@ -0,0 +1,28 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn.functional as F
+
+from mmseg.models.losses import CrossEntropyLoss, weight_reduce_loss
+
+
+def test_cross_entropy_loss_class_weights():
+    loss_class = CrossEntropyLoss
+    pred = torch.rand((1, 10, 4, 4))
+    target = torch.randint(0, 10, (1, 4, 4))
+    class_weight = torch.ones(10)
+    avg_factor = target.numel()
+
+    cross_entropy_loss = F.cross_entropy(
+        pred, target, weight=class_weight, reduction='none', ignore_index=-100)
+
+    expected_loss = weight_reduce_loss(
+        cross_entropy_loss,
+        weight=None,
+        reduction='mean',
+        avg_factor=avg_factor)
+
+    # Test loss forward
+    loss = loss_class(class_weight=class_weight.tolist())(pred, target)
+
+    assert isinstance(loss, torch.Tensor)
+    assert expected_loss == loss
diff --git a/mmsegmentation/tests/test_models/test_losses/test_dice_loss.py b/mmsegmentation/tests/test_models/test_losses/test_dice_loss.py
new file mode 100644
index 0000000..34253da
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_losses/test_dice_loss.py
@@ -0,0 +1,96 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.losses import DiceLoss
+
+
+@pytest.mark.parametrize('naive_dice', [True, False])
+def test_dice_loss(naive_dice):
+    loss_class = DiceLoss
+    pred = torch.rand((1, 10, 4, 4))
+    target = torch.randint(0, 10, (1, 4, 4))
+    weight = torch.rand(1)
+    # Test loss forward
+    loss = loss_class(naive_dice=naive_dice)(pred, target)
+    assert isinstance(loss, torch.Tensor)
+
+    # Test loss forward with weight
+    loss = loss_class(naive_dice=naive_dice)(pred, target, weight)
+    assert isinstance(loss, torch.Tensor)
+
+    # Test loss forward with reduction_override
+    loss = loss_class(naive_dice=naive_dice)(
+        pred, target, reduction_override='mean')
+    assert isinstance(loss, torch.Tensor)
+
+    # Test loss forward with avg_factor
+    loss = loss_class(naive_dice=naive_dice)(pred, target, avg_factor=10)
+    assert isinstance(loss, torch.Tensor)
+
+    with pytest.raises(ValueError):
+        # loss can evaluate with avg_factor only if
+        # reduction is None, 'none' or 'mean'.
+        reduction_override = 'sum'
+        loss_class(naive_dice=naive_dice)(
+            pred, target, avg_factor=10, reduction_override=reduction_override)
+
+    # Test loss forward with avg_factor and reduction
+    for reduction_override in [None, 'none', 'mean']:
+        loss_class(naive_dice=naive_dice)(
+            pred, target, avg_factor=10, reduction_override=reduction_override)
+        assert isinstance(loss, torch.Tensor)
+
+    # Test loss forward with has_acted=False and use_sigmoid=False
+    for use_sigmoid in [True, False]:
+        loss_class(
+            use_sigmoid=use_sigmoid, activate=True,
+            naive_dice=naive_dice)(pred, target)
+        assert isinstance(loss, torch.Tensor)
+
+    # Test loss forward with weight.ndim != loss.ndim
+    with pytest.raises(AssertionError):
+        weight = torch.rand((2, 8))
+        loss_class(naive_dice=naive_dice)(pred, target, weight)
+
+    # Test loss forward with len(weight) != len(pred)
+    with pytest.raises(AssertionError):
+        weight = torch.rand(8)
+        loss_class(naive_dice=naive_dice)(pred, target, weight)
+
+    # Test _expand_onehot_labels_dice
+    pred = torch.tensor([[[[1, 1], [1, 0]], [[0, 1], [1, 1]]]]).float()
+    target = torch.tensor([[[0, 0], [0, 1]]])
+    target_onehot = torch.tensor([[[[1, 1], [1, 0]], [[0, 0], [0, 1]]]])
+    weight = torch.rand(1)
+    loss = loss_class(naive_dice=naive_dice)(pred, target, weight)
+    loss_onehot = loss_class(naive_dice=naive_dice)(pred, target_onehot,
+                                                    weight)
+    assert torch.equal(loss, loss_onehot)
+
+    # Test Whether Loss is 0 when pred == target, eps == 0 and naive_dice=False
+    target = torch.randint(0, 2, (1, 10, 4, 4))
+    pred = target.float()
+    target = target.sigmoid()
+    weight = torch.rand(1)
+    loss = loss_class(
+        naive_dice=False, use_sigmoid=True, eps=0)(pred, target, weight)
+    assert loss.item() == 0
+
+    # Test ignore_index when ignore_index is the only class
+    with pytest.raises(AssertionError):
+        pred = torch.ones((1, 1, 4, 4))
+        target = torch.randint(0, 1, (1, 4, 4))
+        weight = torch.rand(1)
+        loss = loss_class(
+            naive_dice=naive_dice, use_sigmoid=False, ignore_index=0,
+            eps=0)(pred, target, weight)
+
+    # Test ignore_index with naive_dice = False
+    pred = torch.tensor([[[[1, 1], [1, 0]], [[0, 1], [1, 1]]]]).float()
+    target = torch.tensor([[[[1, 1], [1, 0]], [[1, 0], [0, 1]]]]).sigmoid()
+    weight = torch.rand(1)
+    loss = loss_class(
+        naive_dice=False, use_sigmoid=True, ignore_index=1,
+        eps=0)(pred, target, weight)
+    assert loss.item() == 0
diff --git a/mmsegmentation/tests/test_models/test_losses/test_huasdorff_distance_loss.py b/mmsegmentation/tests/test_models/test_losses/test_huasdorff_distance_loss.py
new file mode 100644
index 0000000..29c2732
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_losses/test_huasdorff_distance_loss.py
@@ -0,0 +1,29 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.losses import HuasdorffDisstanceLoss
+
+
+def test_huasdorff_distance_loss():
+    loss_class = HuasdorffDisstanceLoss
+    pred = torch.rand((10, 8, 6, 6))
+    target = torch.rand((10, 6, 6))
+    class_weight = torch.rand(8)
+
+    # Test loss forward
+    loss = loss_class()(pred, target)
+    assert isinstance(loss, torch.Tensor)
+
+    # Test loss forward with avg_factor
+    loss = loss_class()(pred, target, avg_factor=10)
+    assert isinstance(loss, torch.Tensor)
+
+    # Test loss forward with avg_factor and reduction is None, 'sum' and 'mean'
+    for reduction in [None, 'sum', 'mean']:
+        loss = loss_class()(pred, target, avg_factor=10, reduction=reduction)
+        assert isinstance(loss, torch.Tensor)
+
+    # Test loss forward with class_weight
+    with pytest.raises(AssertionError):
+        loss_class(class_weight=class_weight)(pred, target)
diff --git a/mmsegmentation/tests/test_models/test_losses/test_kldiv_loss.py b/mmsegmentation/tests/test_models/test_losses/test_kldiv_loss.py
new file mode 100644
index 0000000..48bcc4b
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_losses/test_kldiv_loss.py
@@ -0,0 +1,40 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+
+from mmseg.models.losses.kldiv_loss import KLDivLoss
+
+
+def test_kldiv_loss_with_none_reduction():
+    loss_class = KLDivLoss
+    pred = torch.rand((8, 5, 5))
+    target = torch.rand((8, 5, 5))
+    reduction = 'none'
+
+    # Test loss forward
+    loss = loss_class(reduction=reduction)(pred, target)
+    assert isinstance(loss, torch.Tensor)
+    assert loss.shape == (8, 5, 5), f'{loss.shape}'
+
+
+def test_kldiv_loss_with_mean_reduction():
+    loss_class = KLDivLoss
+    pred = torch.rand((8, 5, 5))
+    target = torch.rand((8, 5, 5))
+    reduction = 'mean'
+
+    # Test loss forward
+    loss = loss_class(reduction=reduction)(pred, target)
+    assert isinstance(loss, torch.Tensor)
+    assert loss.shape == (8, ), f'{loss.shape}'
+
+
+def test_kldiv_loss_with_sum_reduction():
+    loss_class = KLDivLoss
+    pred = torch.rand((8, 5, 5))
+    target = torch.rand((8, 5, 5))
+    reduction = 'sum'
+
+    # Test loss forward
+    loss = loss_class(reduction=reduction)(pred, target)
+    assert isinstance(loss, torch.Tensor)
+    assert loss.shape == (8, ), f'{loss.shape}'
diff --git a/mmsegmentation/tests/test_models/test_losses/test_silog_loss.py b/mmsegmentation/tests/test_models/test_losses/test_silog_loss.py
new file mode 100644
index 0000000..022434b
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_losses/test_silog_loss.py
@@ -0,0 +1,20 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from unittest import TestCase
+
+import torch
+
+from mmseg.models.losses import SiLogLoss
+
+
+class TestSiLogLoss(TestCase):
+
+    def test_SiLogLoss_forward(self):
+        pred = torch.tensor([[1.0, 2.0], [3.5, 4.0]], dtype=torch.float32)
+        target = torch.tensor([[0.0, 2.0], [3.0, 4.0]], dtype=torch.float32)
+        weight = torch.tensor([1.0, 0.5], dtype=torch.float32)
+
+        loss_module = SiLogLoss()
+        loss = loss_module.forward(pred, target, weight)
+
+        expected_loss = 0.02
+        self.assertAlmostEqual(loss.item(), expected_loss, places=2)
diff --git a/mmsegmentation/tests/test_models/test_losses/test_tversky_loss.py b/mmsegmentation/tests/test_models/test_losses/test_tversky_loss.py
new file mode 100644
index 0000000..c5c581d
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_losses/test_tversky_loss.py
@@ -0,0 +1,77 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+
+def test_tversky_lose():
+    from mmseg.models import build_loss
+
+    # test alpha + beta != 1
+    with pytest.raises(AssertionError):
+        loss_cfg = dict(
+            type='TverskyLoss',
+            class_weight=[1.0, 2.0, 3.0],
+            loss_weight=1.0,
+            alpha=0.4,
+            beta=0.7,
+            loss_name='loss_tversky')
+        tversky_loss = build_loss(loss_cfg)
+        logits = torch.rand(8, 3, 4, 4)
+        labels = (torch.rand(8, 4, 4) * 3).long()
+        tversky_loss(logits, labels, ignore_index=1)
+
+    # test tversky loss
+    loss_cfg = dict(
+        type='TverskyLoss',
+        class_weight=[1.0, 2.0, 3.0],
+        loss_weight=1.0,
+        ignore_index=1,
+        loss_name='loss_tversky')
+    tversky_loss = build_loss(loss_cfg)
+    logits = torch.rand(8, 3, 4, 4)
+    labels = (torch.rand(8, 4, 4) * 3).long()
+    tversky_loss(logits, labels)
+
+    # test loss with class weights from file
+    import os
+    import tempfile
+
+    import mmengine
+    import numpy as np
+    tmp_file = tempfile.NamedTemporaryFile()
+
+    mmengine.dump([1.0, 2.0, 3.0], f'{tmp_file.name}.pkl',
+                  'pkl')  # from pkl file
+    loss_cfg = dict(
+        type='TverskyLoss',
+        class_weight=f'{tmp_file.name}.pkl',
+        loss_weight=1.0,
+        ignore_index=1,
+        loss_name='loss_tversky')
+    tversky_loss = build_loss(loss_cfg)
+    tversky_loss(logits, labels)
+
+    np.save(f'{tmp_file.name}.npy', np.array([1.0, 2.0, 3.0]))  # from npy file
+    loss_cfg = dict(
+        type='TverskyLoss',
+        class_weight=f'{tmp_file.name}.pkl',
+        loss_weight=1.0,
+        ignore_index=1,
+        loss_name='loss_tversky')
+    tversky_loss = build_loss(loss_cfg)
+    tversky_loss(logits, labels)
+    tmp_file.close()
+    os.remove(f'{tmp_file.name}.pkl')
+    os.remove(f'{tmp_file.name}.npy')
+
+    # test tversky loss has name `loss_tversky`
+    loss_cfg = dict(
+        type='TverskyLoss',
+        smooth=2,
+        loss_weight=1.0,
+        ignore_index=1,
+        alpha=0.3,
+        beta=0.7,
+        loss_name='loss_tversky')
+    tversky_loss = build_loss(loss_cfg)
+    assert tversky_loss.loss_name == 'loss_tversky'
diff --git a/mmsegmentation/tests/test_models/test_necks/__init__.py b/mmsegmentation/tests/test_models/test_necks/__init__.py
new file mode 100644
index 0000000..ef101fe
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_necks/__init__.py
@@ -0,0 +1 @@
+# Copyright (c) OpenMMLab. All rights reserved.
diff --git a/mmsegmentation/tests/test_models/test_necks/test_feature2pyramid.py b/mmsegmentation/tests/test_models/test_necks/test_feature2pyramid.py
new file mode 100644
index 0000000..44fd02c
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_necks/test_feature2pyramid.py
@@ -0,0 +1,38 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models import Feature2Pyramid
+
+
+def test_feature2pyramid():
+    # test
+    rescales = [4, 2, 1, 0.5]
+    embed_dim = 64
+    inputs = [torch.randn(1, embed_dim, 32, 32) for i in range(len(rescales))]
+
+    fpn = Feature2Pyramid(
+        embed_dim, rescales, norm_cfg=dict(type='BN', requires_grad=True))
+    outputs = fpn(inputs)
+    assert outputs[0].shape == torch.Size([1, 64, 128, 128])
+    assert outputs[1].shape == torch.Size([1, 64, 64, 64])
+    assert outputs[2].shape == torch.Size([1, 64, 32, 32])
+    assert outputs[3].shape == torch.Size([1, 64, 16, 16])
+
+    # test rescales = [2, 1, 0.5, 0.25]
+    rescales = [2, 1, 0.5, 0.25]
+    inputs = [torch.randn(1, embed_dim, 32, 32) for i in range(len(rescales))]
+
+    fpn = Feature2Pyramid(
+        embed_dim, rescales, norm_cfg=dict(type='BN', requires_grad=True))
+    outputs = fpn(inputs)
+    assert outputs[0].shape == torch.Size([1, 64, 64, 64])
+    assert outputs[1].shape == torch.Size([1, 64, 32, 32])
+    assert outputs[2].shape == torch.Size([1, 64, 16, 16])
+    assert outputs[3].shape == torch.Size([1, 64, 8, 8])
+
+    # test rescales = [4, 2, 0.25, 0]
+    rescales = [4, 2, 0.25, 0]
+    with pytest.raises(KeyError):
+        fpn = Feature2Pyramid(
+            embed_dim, rescales, norm_cfg=dict(type='BN', requires_grad=True))
diff --git a/mmsegmentation/tests/test_models/test_necks/test_fpn.py b/mmsegmentation/tests/test_models/test_necks/test_fpn.py
new file mode 100644
index 0000000..c294006
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_necks/test_fpn.py
@@ -0,0 +1,30 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+
+from mmseg.models import FPN
+
+
+def test_fpn():
+    in_channels = [64, 128, 256, 512]
+    inputs = [
+        torch.randn(1, c, 56 // 2**i, 56 // 2**i)
+        for i, c in enumerate(in_channels)
+    ]
+
+    fpn = FPN(in_channels, 64, len(in_channels))
+    outputs = fpn(inputs)
+    assert outputs[0].shape == torch.Size([1, 64, 56, 56])
+    assert outputs[1].shape == torch.Size([1, 64, 28, 28])
+    assert outputs[2].shape == torch.Size([1, 64, 14, 14])
+    assert outputs[3].shape == torch.Size([1, 64, 7, 7])
+
+    fpn = FPN(
+        in_channels,
+        64,
+        len(in_channels),
+        upsample_cfg=dict(mode='nearest', scale_factor=2.0))
+    outputs = fpn(inputs)
+    assert outputs[0].shape == torch.Size([1, 64, 56, 56])
+    assert outputs[1].shape == torch.Size([1, 64, 28, 28])
+    assert outputs[2].shape == torch.Size([1, 64, 14, 14])
+    assert outputs[3].shape == torch.Size([1, 64, 7, 7])
diff --git a/mmsegmentation/tests/test_models/test_necks/test_ic_neck.py b/mmsegmentation/tests/test_models/test_necks/test_ic_neck.py
new file mode 100644
index 0000000..3d13008
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_necks/test_ic_neck.py
@@ -0,0 +1,53 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.necks import ICNeck
+from mmseg.models.necks.ic_neck import CascadeFeatureFusion
+from ..test_heads.utils import _conv_has_norm, to_cuda
+
+
+def test_ic_neck():
+    # test with norm_cfg
+    neck = ICNeck(
+        in_channels=(4, 16, 16),
+        out_channels=8,
+        norm_cfg=dict(type='SyncBN'),
+        align_corners=False)
+    assert _conv_has_norm(neck, sync_bn=True)
+
+    inputs = [
+        torch.randn(1, 4, 32, 64),
+        torch.randn(1, 16, 16, 32),
+        torch.randn(1, 16, 8, 16)
+    ]
+    neck = ICNeck(
+        in_channels=(4, 16, 16),
+        out_channels=4,
+        norm_cfg=dict(type='BN', requires_grad=True),
+        align_corners=False)
+    if torch.cuda.is_available():
+        neck, inputs = to_cuda(neck, inputs)
+
+    outputs = neck(inputs)
+    assert outputs[0].shape == (1, 4, 16, 32)
+    assert outputs[1].shape == (1, 4, 32, 64)
+    assert outputs[1].shape == (1, 4, 32, 64)
+
+
+def test_ic_neck_cascade_feature_fusion():
+    cff = CascadeFeatureFusion(64, 64, 32)
+    assert cff.conv_low.in_channels == 64
+    assert cff.conv_low.out_channels == 32
+    assert cff.conv_high.in_channels == 64
+    assert cff.conv_high.out_channels == 32
+
+
+def test_ic_neck_input_channels():
+    with pytest.raises(AssertionError):
+        # ICNet Neck input channel constraints.
+        ICNeck(
+            in_channels=(16, 64, 64, 64),
+            out_channels=32,
+            norm_cfg=dict(type='BN', requires_grad=True),
+            align_corners=False)
diff --git a/mmsegmentation/tests/test_models/test_necks/test_jpu.py b/mmsegmentation/tests/test_models/test_necks/test_jpu.py
new file mode 100644
index 0000000..4c3fa9f
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_necks/test_jpu.py
@@ -0,0 +1,46 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.necks import JPU
+
+
+def test_fastfcn_neck():
+    # Test FastFCN Standard Forward
+    model = JPU(
+        in_channels=(64, 128, 256),
+        mid_channels=64,
+        start_level=0,
+        end_level=-1,
+        dilations=(1, 2, 4, 8),
+    )
+    model.init_weights()
+    model.train()
+    batch_size = 1
+    input = [
+        torch.randn(batch_size, 64, 64, 128),
+        torch.randn(batch_size, 128, 32, 64),
+        torch.randn(batch_size, 256, 16, 32)
+    ]
+    feat = model(input)
+
+    assert len(feat) == 3
+    assert feat[0].shape == torch.Size([batch_size, 64, 64, 128])
+    assert feat[1].shape == torch.Size([batch_size, 128, 32, 64])
+    assert feat[2].shape == torch.Size([batch_size, 256, 64, 128])
+
+    with pytest.raises(AssertionError):
+        # FastFCN input and in_channels constraints.
+        JPU(in_channels=(256, 64, 128), start_level=0, end_level=5)
+
+    # Test not default start_level
+    model = JPU(in_channels=(64, 128, 256), start_level=1, end_level=-1)
+    input = [
+        torch.randn(batch_size, 64, 64, 128),
+        torch.randn(batch_size, 128, 32, 64),
+        torch.randn(batch_size, 256, 16, 32)
+    ]
+    feat = model(input)
+    assert len(feat) == 2
+    assert feat[0].shape == torch.Size([batch_size, 128, 32, 64])
+    assert feat[1].shape == torch.Size([batch_size, 2048, 32, 64])
diff --git a/mmsegmentation/tests/test_models/test_necks/test_mla_neck.py b/mmsegmentation/tests/test_models/test_necks/test_mla_neck.py
new file mode 100644
index 0000000..e385418
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_necks/test_mla_neck.py
@@ -0,0 +1,16 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+
+from mmseg.models import MLANeck
+
+
+def test_mla():
+    in_channels = [4, 4, 4, 4]
+    mla = MLANeck(in_channels, 32)
+
+    inputs = [torch.randn(1, c, 12, 12) for i, c in enumerate(in_channels)]
+    outputs = mla(inputs)
+    assert outputs[0].shape == torch.Size([1, 32, 12, 12])
+    assert outputs[1].shape == torch.Size([1, 32, 12, 12])
+    assert outputs[2].shape == torch.Size([1, 32, 12, 12])
+    assert outputs[3].shape == torch.Size([1, 32, 12, 12])
diff --git a/mmsegmentation/tests/test_models/test_necks/test_multilevel_neck.py b/mmsegmentation/tests/test_models/test_necks/test_multilevel_neck.py
new file mode 100644
index 0000000..9c71d51
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_necks/test_multilevel_neck.py
@@ -0,0 +1,32 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+
+from mmseg.models import MultiLevelNeck
+
+
+def test_multilevel_neck():
+
+    # Test init_weights
+    MultiLevelNeck([266], 32).init_weights()
+
+    # Test multi feature maps
+    in_channels = [32, 64, 128, 256]
+    inputs = [torch.randn(1, c, 14, 14) for i, c in enumerate(in_channels)]
+
+    neck = MultiLevelNeck(in_channels, 32)
+    outputs = neck(inputs)
+    assert outputs[0].shape == torch.Size([1, 32, 7, 7])
+    assert outputs[1].shape == torch.Size([1, 32, 14, 14])
+    assert outputs[2].shape == torch.Size([1, 32, 28, 28])
+    assert outputs[3].shape == torch.Size([1, 32, 56, 56])
+
+    # Test one feature map
+    in_channels = [768]
+    inputs = [torch.randn(1, 768, 14, 14)]
+
+    neck = MultiLevelNeck(in_channels, 32)
+    outputs = neck(inputs)
+    assert outputs[0].shape == torch.Size([1, 32, 7, 7])
+    assert outputs[1].shape == torch.Size([1, 32, 14, 14])
+    assert outputs[2].shape == torch.Size([1, 32, 28, 28])
+    assert outputs[3].shape == torch.Size([1, 32, 56, 56])
diff --git a/mmsegmentation/tests/test_models/test_segmentors/__init__.py b/mmsegmentation/tests/test_models/test_segmentors/__init__.py
new file mode 100644
index 0000000..ef101fe
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_segmentors/__init__.py
@@ -0,0 +1 @@
+# Copyright (c) OpenMMLab. All rights reserved.
diff --git a/mmsegmentation/tests/test_models/test_segmentors/test_cascade_encoder_decoder.py b/mmsegmentation/tests/test_models/test_segmentors/test_cascade_encoder_decoder.py
new file mode 100644
index 0000000..941816d
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_segmentors/test_cascade_encoder_decoder.py
@@ -0,0 +1,57 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine import ConfigDict
+
+from mmseg.models import build_segmentor
+from .utils import _segmentor_forward_train_test
+
+
+def test_cascade_encoder_decoder():
+
+    # test 1 decode head, w.o. aux head
+    cfg = ConfigDict(
+        type='CascadeEncoderDecoder',
+        num_stages=2,
+        backbone=dict(type='ExampleBackbone'),
+        decode_head=[
+            dict(type='ExampleDecodeHead'),
+            dict(type='ExampleCascadeDecodeHead')
+        ])
+    cfg.test_cfg = ConfigDict(mode='whole')
+    segmentor = build_segmentor(cfg)
+    _segmentor_forward_train_test(segmentor)
+
+    # test slide mode
+    cfg.test_cfg = ConfigDict(mode='slide', crop_size=(3, 3), stride=(2, 2))
+    segmentor = build_segmentor(cfg)
+    _segmentor_forward_train_test(segmentor)
+
+    # test 1 decode head, 1 aux head
+    cfg = ConfigDict(
+        type='CascadeEncoderDecoder',
+        num_stages=2,
+        backbone=dict(type='ExampleBackbone'),
+        decode_head=[
+            dict(type='ExampleDecodeHead'),
+            dict(type='ExampleCascadeDecodeHead')
+        ],
+        auxiliary_head=dict(type='ExampleDecodeHead'))
+    cfg.test_cfg = ConfigDict(mode='whole')
+    segmentor = build_segmentor(cfg)
+    _segmentor_forward_train_test(segmentor)
+
+    # test 1 decode head, 2 aux head
+    cfg = ConfigDict(
+        type='CascadeEncoderDecoder',
+        num_stages=2,
+        backbone=dict(type='ExampleBackbone'),
+        decode_head=[
+            dict(type='ExampleDecodeHead'),
+            dict(type='ExampleCascadeDecodeHead')
+        ],
+        auxiliary_head=[
+            dict(type='ExampleDecodeHead'),
+            dict(type='ExampleDecodeHead')
+        ])
+    cfg.test_cfg = ConfigDict(mode='whole')
+    segmentor = build_segmentor(cfg)
+    _segmentor_forward_train_test(segmentor)
diff --git a/mmsegmentation/tests/test_models/test_segmentors/test_depth_estimator.py b/mmsegmentation/tests/test_models/test_segmentors/test_depth_estimator.py
new file mode 100644
index 0000000..e819c9e
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_segmentors/test_depth_estimator.py
@@ -0,0 +1,64 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from copy import deepcopy
+from os.path import dirname, join
+from unittest import TestCase
+
+import torch
+from mmengine import Config, ConfigDict
+from mmengine.structures import PixelData
+
+import mmseg
+from mmseg.models.segmentors import DepthEstimator
+from mmseg.structures import SegDataSample
+
+
+class TestDepthEstimator(TestCase):
+
+    def setUp(self) -> None:
+        repo_dpath = dirname(dirname(mmseg.__file__))
+        config_dpath = join(repo_dpath, 'configs/_base_/models/vpd_sd.py')
+        vpd_cfg = Config.fromfile(config_dpath).stable_diffusion_cfg
+        vpd_cfg.pop('checkpoint')
+
+        backbone_cfg = dict(
+            type='VPD',
+            diffusion_cfg=vpd_cfg,
+            class_embed_path='https://download.openmmlab.com/mmsegmentation/'
+            'v0.5/vpd/nyu_class_embeddings.pth',
+            class_embed_select=True,
+            pad_shape=64,
+            unet_cfg=dict(use_attn=False),
+        )
+
+        head_cfg = dict(
+            type='VPDDepthHead',
+            max_depth=10,
+        )
+
+        self.model = DepthEstimator(
+            backbone=backbone_cfg, decode_head=head_cfg)
+
+        inputs = torch.randn(1, 3, 64, 80)
+        data_sample = SegDataSample()
+        data_sample.gt_depth_map = PixelData(data=torch.rand(1, 64, 80))
+        data_sample.set_metainfo(dict(img_shape=(64, 80), ori_shape=(64, 80)))
+        self.data = dict(inputs=inputs, data_samples=[data_sample])
+
+    def test_slide_flip_inference(self):
+
+        self.model.test_cfg = ConfigDict(
+            dict(mode='slide_flip', crop_size=(64, 64), stride=(16, 16)))
+
+        with torch.no_grad():
+            out = self.model.predict(**deepcopy(self.data))
+
+        self.assertEqual(len(out), 1)
+        self.assertIn('pred_depth_map', out[0].keys())
+        self.assertListEqual(list(out[0].pred_depth_map.shape), [64, 80])
+
+    def test__forward(self):
+        data = deepcopy(self.data)
+        data['inputs'] = data['inputs'][:, :, :64, :64]
+        with torch.no_grad():
+            out = self.model._forward(**data)
+        self.assertListEqual(list(out.shape), [1, 1, 64, 64])
diff --git a/mmsegmentation/tests/test_models/test_segmentors/test_encoder_decoder.py b/mmsegmentation/tests/test_models/test_segmentors/test_encoder_decoder.py
new file mode 100644
index 0000000..5795f51
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_segmentors/test_encoder_decoder.py
@@ -0,0 +1,100 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from mmengine import ConfigDict
+from mmengine.structures import PixelData
+
+from mmseg.models import build_segmentor
+from mmseg.structures import SegDataSample
+from .utils import _segmentor_forward_train_test
+
+
+def test_encoder_decoder():
+
+    # test 1 decode head, w.o. aux head
+
+    cfg = ConfigDict(
+        type='EncoderDecoder',
+        backbone=dict(type='ExampleBackbone'),
+        decode_head=dict(type='ExampleDecodeHead'),
+        train_cfg=None,
+        test_cfg=dict(mode='whole'))
+    segmentor = build_segmentor(cfg)
+    _segmentor_forward_train_test(segmentor)
+
+    # test out_channels == 1
+    cfg = ConfigDict(
+        type='EncoderDecoder',
+        backbone=dict(type='ExampleBackbone'),
+        decode_head=dict(
+            type='ExampleDecodeHead', num_classes=2, out_channels=1),
+        train_cfg=None,
+        test_cfg=dict(mode='whole'))
+    segmentor = build_segmentor(cfg)
+    _segmentor_forward_train_test(segmentor)
+
+    # test slide mode
+    cfg.test_cfg = ConfigDict(mode='slide', crop_size=(3, 3), stride=(2, 2))
+    segmentor = build_segmentor(cfg)
+    _segmentor_forward_train_test(segmentor)
+
+    # test 1 decode head, 1 aux head
+    cfg = ConfigDict(
+        type='EncoderDecoder',
+        backbone=dict(type='ExampleBackbone'),
+        decode_head=dict(type='ExampleDecodeHead'),
+        auxiliary_head=dict(type='ExampleDecodeHead'))
+    cfg.test_cfg = ConfigDict(mode='whole')
+    segmentor = build_segmentor(cfg)
+    _segmentor_forward_train_test(segmentor)
+
+    # test 1 decode head, 2 aux head
+    cfg = ConfigDict(
+        type='EncoderDecoder',
+        backbone=dict(type='ExampleBackbone'),
+        decode_head=dict(type='ExampleDecodeHead'),
+        auxiliary_head=[
+            dict(type='ExampleDecodeHead'),
+            dict(type='ExampleDecodeHead')
+        ])
+    cfg.test_cfg = ConfigDict(mode='whole')
+    segmentor = build_segmentor(cfg)
+    _segmentor_forward_train_test(segmentor)
+
+
+def test_postprocess_result():
+    cfg = ConfigDict(
+        type='EncoderDecoder',
+        backbone=dict(type='ExampleBackbone'),
+        decode_head=dict(type='ExampleDecodeHead'),
+        train_cfg=None,
+        test_cfg=dict(mode='whole'))
+    model = build_segmentor(cfg)
+
+    # test postprocess
+    data_sample = SegDataSample()
+    data_sample.gt_sem_seg = PixelData(
+        **{'data': torch.randint(0, 10, (1, 8, 8))})
+    data_sample.set_metainfo({
+        'padding_size': (0, 2, 0, 2),
+        'ori_shape': (8, 8)
+    })
+    seg_logits = torch.zeros((1, 2, 10, 10))
+    seg_logits[:, :, :8, :8] = 1
+    data_samples = [data_sample]
+
+    outputs = model.postprocess_result(seg_logits, data_samples)
+    assert outputs[0].seg_logits.data.shape == torch.Size((2, 8, 8))
+    assert torch.allclose(outputs[0].seg_logits.data, torch.ones((2, 8, 8)))
+
+    data_sample = SegDataSample()
+    data_sample.gt_sem_seg = PixelData(
+        **{'data': torch.randint(0, 10, (1, 8, 8))})
+    data_sample.set_metainfo({
+        'img_padding_size': (0, 2, 0, 2),
+        'ori_shape': (8, 8)
+    })
+
+    data_samples = [data_sample]
+    outputs = model.postprocess_result(seg_logits, data_samples)
+    assert outputs[0].seg_logits.data.shape == torch.Size((2, 8, 8))
+    assert torch.allclose(outputs[0].seg_logits.data, torch.ones((2, 8, 8)))
diff --git a/mmsegmentation/tests/test_models/test_segmentors/test_multimodal_encoder_decoder.py b/mmsegmentation/tests/test_models/test_segmentors/test_multimodal_encoder_decoder.py
new file mode 100644
index 0000000..75258d8
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_segmentors/test_multimodal_encoder_decoder.py
@@ -0,0 +1,24 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine import ConfigDict
+
+from mmseg.models import build_segmentor
+from tests.test_models.test_segmentors.utils import \
+    _segmentor_forward_train_test
+
+
+def test_multimodal_encoder_decoder():
+
+    cfg = ConfigDict(
+        type='MultimodalEncoderDecoder',
+        asymetric_input=False,
+        image_encoder=dict(type='ExampleBackbone', out_indices=[1, 2, 3, 4]),
+        text_encoder=dict(
+            type='ExampleTextEncoder',
+            vocabulary=['A', 'B', 'C'],
+            output_dims=3),
+        decode_head=dict(
+            type='ExampleDecodeHead', out_channels=1, num_classes=2),
+        train_cfg=None,
+        test_cfg=dict(mode='whole'))
+    segmentor = build_segmentor(cfg)
+    _segmentor_forward_train_test(segmentor)
diff --git a/mmsegmentation/tests/test_models/test_segmentors/test_seg_tta_model.py b/mmsegmentation/tests/test_models/test_segmentors/test_seg_tta_model.py
new file mode 100644
index 0000000..1e152ed
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_segmentors/test_seg_tta_model.py
@@ -0,0 +1,63 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import tempfile
+
+import torch
+from mmengine import ConfigDict
+from mmengine.model import BaseTTAModel
+from mmengine.registry import init_default_scope
+from mmengine.structures import PixelData
+
+from mmseg.registry import MODELS
+from mmseg.structures import SegDataSample
+from .utils import *  # noqa: F401,F403
+
+init_default_scope('mmseg')
+
+
+def test_encoder_decoder_tta():
+
+    segmentor_cfg = ConfigDict(
+        type='EncoderDecoder',
+        backbone=dict(type='ExampleBackbone'),
+        decode_head=dict(type='ExampleDecodeHead'),
+        train_cfg=None,
+        test_cfg=dict(mode='whole'))
+
+    cfg = ConfigDict(type='SegTTAModel', module=segmentor_cfg)
+
+    model: BaseTTAModel = MODELS.build(cfg)
+
+    imgs = []
+    data_samples = []
+    directions = ['horizontal', 'vertical']
+    for i in range(12):
+        flip_direction = directions[0] if i % 3 == 0 else directions[1]
+        imgs.append(torch.randn(1, 3, 10 + i, 10 + i))
+        data_samples.append([
+            SegDataSample(
+                metainfo=dict(
+                    ori_shape=(10, 10),
+                    img_shape=(10 + i, 10 + i),
+                    flip=(i % 2 == 0),
+                    flip_direction=flip_direction,
+                    img_path=tempfile.mktemp()),
+                gt_sem_seg=PixelData(data=torch.randint(0, 19, (1, 10, 10))))
+        ])
+
+    model.test_step(dict(inputs=imgs, data_samples=data_samples))
+
+    # test out_channels == 1
+    segmentor_cfg = ConfigDict(
+        type='EncoderDecoder',
+        backbone=dict(type='ExampleBackbone'),
+        decode_head=dict(
+            type='ExampleDecodeHead',
+            num_classes=2,
+            out_channels=1,
+            threshold=0.4),
+        train_cfg=None,
+        test_cfg=dict(mode='whole'))
+    model.module = MODELS.build(segmentor_cfg)
+    for data_sample in data_samples:
+        data_sample[0].gt_sem_seg.data = torch.randint(0, 2, (1, 10, 10))
+    model.test_step(dict(inputs=imgs, data_samples=data_samples))
diff --git a/mmsegmentation/tests/test_models/test_segmentors/utils.py b/mmsegmentation/tests/test_models/test_segmentors/utils.py
new file mode 100644
index 0000000..ac31e2b
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_segmentors/utils.py
@@ -0,0 +1,182 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from mmengine.optim import OptimWrapper
+from mmengine.structures import PixelData
+from torch import nn
+from torch.optim import SGD
+
+from mmseg.models import SegDataPreProcessor
+from mmseg.models.decode_heads.cascade_decode_head import BaseCascadeDecodeHead
+from mmseg.models.decode_heads.decode_head import BaseDecodeHead
+from mmseg.registry import MODELS
+from mmseg.structures import SegDataSample
+
+
+def _demo_mm_inputs(input_shape=(1, 3, 8, 16), num_classes=10):
+    """Create a superset of inputs needed to run test or train batches.
+
+    Args:
+        input_shape (tuple):
+            input batch dimensions
+
+        num_classes (int):
+            number of semantic classes
+    """
+    (N, C, H, W) = input_shape
+
+    imgs = torch.randn(*input_shape)
+    segs = torch.randint(
+        low=0, high=num_classes - 1, size=(N, H, W), dtype=torch.long)
+
+    img_metas = [{
+        'img_shape': (H, W),
+        'ori_shape': (H, W),
+        'pad_shape': (H, W, C),
+        'filename': '<demo>.png',
+        'scale_factor': 1.0,
+        'flip': False,
+        'flip_direction': 'horizontal'
+    } for _ in range(N)]
+
+    data_samples = [
+        SegDataSample(
+            gt_sem_seg=PixelData(data=segs[i]), metainfo=img_metas[i])
+        for i in range(N)
+    ]
+
+    mm_inputs = {'imgs': torch.FloatTensor(imgs), 'data_samples': data_samples}
+
+    return mm_inputs
+
+
+@MODELS.register_module()
+class ExampleBackbone(nn.Module):
+
+    def __init__(self, out_indices=None):
+        super().__init__()
+        self.conv = nn.Conv2d(3, 3, 3)
+        self.out_indices = out_indices
+
+    def init_weights(self, pretrained=None):
+        pass
+
+    def forward(self, x):
+        if self.out_indices is None:
+            return [self.conv(x)]
+        else:
+            outs = []
+            for i in self.out_indices:
+                outs.append(self.conv(x))
+        return outs
+
+
+@MODELS.register_module()
+class ExampleDecodeHead(BaseDecodeHead):
+
+    def __init__(self, num_classes=19, out_channels=None, **kwargs):
+        super().__init__(
+            3, 3, num_classes=num_classes, out_channels=out_channels, **kwargs)
+
+    def forward(self, inputs):
+        return self.cls_seg(inputs[0])
+
+
+@MODELS.register_module()
+class ExampleTextEncoder(nn.Module):
+
+    def __init__(self, vocabulary=None, output_dims=None):
+        super().__init__()
+        self.vocabulary = vocabulary
+        self.output_dims = output_dims
+
+    def forward(self):
+        return torch.randn((len(self.vocabulary), self.output_dims))
+
+
+@MODELS.register_module()
+class ExampleCascadeDecodeHead(BaseCascadeDecodeHead):
+
+    def __init__(self):
+        super().__init__(3, 3, num_classes=19)
+
+    def forward(self, inputs, prev_out):
+        return self.cls_seg(inputs[0])
+
+
+def _segmentor_forward_train_test(segmentor):
+    if isinstance(segmentor.decode_head, nn.ModuleList):
+        num_classes = segmentor.decode_head[-1].num_classes
+    else:
+        num_classes = segmentor.decode_head.num_classes
+    # batch_size=2 for BatchNorm
+    mm_inputs = _demo_mm_inputs(num_classes=num_classes)
+
+    # convert to cuda Tensor if applicable
+    if torch.cuda.is_available():
+        segmentor = segmentor.cuda()
+
+    # check data preprocessor
+    if not hasattr(segmentor,
+                   'data_preprocessor') or segmentor.data_preprocessor is None:
+        segmentor.data_preprocessor = SegDataPreProcessor()
+
+    mm_inputs = segmentor.data_preprocessor(mm_inputs, True)
+    imgs = mm_inputs.pop('imgs')
+    data_samples = mm_inputs.pop('data_samples')
+
+    # create optimizer wrapper
+    optimizer = SGD(segmentor.parameters(), lr=0.1)
+    optim_wrapper = OptimWrapper(optimizer)
+
+    # Test forward train
+    losses = segmentor.forward(imgs, data_samples, mode='loss')
+    assert isinstance(losses, dict)
+
+    # Test train_step
+    data_batch = dict(inputs=imgs, data_samples=data_samples)
+    outputs = segmentor.train_step(data_batch, optim_wrapper)
+    assert isinstance(outputs, dict)
+    assert 'loss' in outputs
+
+    # Test val_step
+    with torch.no_grad():
+        segmentor.eval()
+        data_batch = dict(inputs=imgs, data_samples=data_samples)
+        outputs = segmentor.val_step(data_batch)
+        assert isinstance(outputs, list)
+
+    # Test forward simple test
+    with torch.no_grad():
+        segmentor.eval()
+        data_batch = dict(inputs=imgs, data_samples=data_samples)
+        results = segmentor.forward(imgs, data_samples, mode='tensor')
+        assert isinstance(results, torch.Tensor)
+
+
+def _segmentor_predict(segmentor):
+    if isinstance(segmentor.decode_head, nn.ModuleList):
+        num_classes = segmentor.decode_head[-1].num_classes
+    else:
+        num_classes = segmentor.decode_head.num_classes
+    # batch_size=2 for BatchNorm
+    mm_inputs = _demo_mm_inputs(num_classes=num_classes)
+
+    # convert to cuda Tensor if applicable
+    if torch.cuda.is_available():
+        segmentor = segmentor.cuda()
+
+    # check data preprocessor
+    if not hasattr(segmentor,
+                   'data_preprocessor') or segmentor.data_preprocessor is None:
+        segmentor.data_preprocessor = SegDataPreProcessor()
+
+    mm_inputs = segmentor.data_preprocessor(mm_inputs, True)
+    imgs = mm_inputs.pop('imgs')
+    data_samples = mm_inputs.pop('data_samples')
+
+    # Test predict
+    with torch.no_grad():
+        segmentor.eval()
+        data_batch = dict(inputs=imgs, data_samples=data_samples)
+        outputs = segmentor.predict(**data_batch)
+        assert isinstance(outputs, list)
diff --git a/mmsegmentation/tests/test_models/test_utils/__init__.py b/mmsegmentation/tests/test_models/test_utils/__init__.py
new file mode 100644
index 0000000..ef101fe
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_utils/__init__.py
@@ -0,0 +1 @@
+# Copyright (c) OpenMMLab. All rights reserved.
diff --git a/mmsegmentation/tests/test_models/test_utils/test_embed.py b/mmsegmentation/tests/test_models/test_utils/test_embed.py
new file mode 100644
index 0000000..be20c97
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_utils/test_embed.py
@@ -0,0 +1,461 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.utils.embed import AdaptivePadding, PatchEmbed, PatchMerging
+
+
+def test_adaptive_padding():
+
+    for padding in ('same', 'corner'):
+        kernel_size = 16
+        stride = 16
+        dilation = 1
+        input = torch.rand(1, 1, 15, 17)
+        adap_pool = AdaptivePadding(
+            kernel_size=kernel_size,
+            stride=stride,
+            dilation=dilation,
+            padding=padding)
+        out = adap_pool(input)
+        # padding to divisible by 16
+        assert (out.shape[2], out.shape[3]) == (16, 32)
+        input = torch.rand(1, 1, 16, 17)
+        out = adap_pool(input)
+        # padding to divisible by 16
+        assert (out.shape[2], out.shape[3]) == (16, 32)
+
+        kernel_size = (2, 2)
+        stride = (2, 2)
+        dilation = (1, 1)
+
+        adap_pad = AdaptivePadding(
+            kernel_size=kernel_size,
+            stride=stride,
+            dilation=dilation,
+            padding=padding)
+        input = torch.rand(1, 1, 11, 13)
+        out = adap_pad(input)
+        # padding to divisible by 2
+        assert (out.shape[2], out.shape[3]) == (12, 14)
+
+        kernel_size = (2, 2)
+        stride = (10, 10)
+        dilation = (1, 1)
+
+        adap_pad = AdaptivePadding(
+            kernel_size=kernel_size,
+            stride=stride,
+            dilation=dilation,
+            padding=padding)
+        input = torch.rand(1, 1, 10, 13)
+        out = adap_pad(input)
+        #  no padding
+        assert (out.shape[2], out.shape[3]) == (10, 13)
+
+        kernel_size = (11, 11)
+        adap_pad = AdaptivePadding(
+            kernel_size=kernel_size,
+            stride=stride,
+            dilation=dilation,
+            padding=padding)
+        input = torch.rand(1, 1, 11, 13)
+        out = adap_pad(input)
+        #  all padding
+        assert (out.shape[2], out.shape[3]) == (21, 21)
+
+        # test padding as kernel is (7,9)
+        input = torch.rand(1, 1, 11, 13)
+        stride = (3, 4)
+        kernel_size = (4, 5)
+        dilation = (2, 2)
+        # actually (7, 9)
+        adap_pad = AdaptivePadding(
+            kernel_size=kernel_size,
+            stride=stride,
+            dilation=dilation,
+            padding=padding)
+        dilation_out = adap_pad(input)
+        assert (dilation_out.shape[2], dilation_out.shape[3]) == (16, 21)
+        kernel_size = (7, 9)
+        dilation = (1, 1)
+        adap_pad = AdaptivePadding(
+            kernel_size=kernel_size,
+            stride=stride,
+            dilation=dilation,
+            padding=padding)
+        kernel79_out = adap_pad(input)
+        assert (kernel79_out.shape[2], kernel79_out.shape[3]) == (16, 21)
+        assert kernel79_out.shape == dilation_out.shape
+
+    # assert only support "same" "corner"
+    with pytest.raises(AssertionError):
+        AdaptivePadding(
+            kernel_size=kernel_size,
+            stride=stride,
+            dilation=dilation,
+            padding=1)
+
+
+def test_patch_embed():
+    B = 2
+    H = 3
+    W = 4
+    C = 3
+    embed_dims = 10
+    kernel_size = 3
+    stride = 1
+    dummy_input = torch.rand(B, C, H, W)
+    patch_merge_1 = PatchEmbed(
+        in_channels=C,
+        embed_dims=embed_dims,
+        kernel_size=kernel_size,
+        stride=stride,
+        padding=0,
+        dilation=1,
+        norm_cfg=None)
+
+    x1, shape = patch_merge_1(dummy_input)
+    # test out shape
+    assert x1.shape == (2, 2, 10)
+    # test outsize is correct
+    assert shape == (1, 2)
+    # test L = out_h * out_w
+    assert shape[0] * shape[1] == x1.shape[1]
+
+    B = 2
+    H = 10
+    W = 10
+    C = 3
+    embed_dims = 10
+    kernel_size = 5
+    stride = 2
+    dummy_input = torch.rand(B, C, H, W)
+    # test dilation
+    patch_merge_2 = PatchEmbed(
+        in_channels=C,
+        embed_dims=embed_dims,
+        kernel_size=kernel_size,
+        stride=stride,
+        padding=0,
+        dilation=2,
+        norm_cfg=None,
+    )
+
+    x2, shape = patch_merge_2(dummy_input)
+    # test out shape
+    assert x2.shape == (2, 1, 10)
+    # test outsize is correct
+    assert shape == (1, 1)
+    # test L = out_h * out_w
+    assert shape[0] * shape[1] == x2.shape[1]
+
+    stride = 2
+    input_size = (10, 10)
+
+    dummy_input = torch.rand(B, C, H, W)
+    # test stride and norm
+    patch_merge_3 = PatchEmbed(
+        in_channels=C,
+        embed_dims=embed_dims,
+        kernel_size=kernel_size,
+        stride=stride,
+        padding=0,
+        dilation=2,
+        norm_cfg=dict(type='LN'),
+        input_size=input_size)
+
+    x3, shape = patch_merge_3(dummy_input)
+    # test out shape
+    assert x3.shape == (2, 1, 10)
+    # test outsize is correct
+    assert shape == (1, 1)
+    # test L = out_h * out_w
+    assert shape[0] * shape[1] == x3.shape[1]
+
+    # test the init_out_size with nn.Unfold
+    assert patch_merge_3.init_out_size[1] == (input_size[0] - 2 * 4 -
+                                              1) // 2 + 1
+    assert patch_merge_3.init_out_size[0] == (input_size[0] - 2 * 4 -
+                                              1) // 2 + 1
+    H = 11
+    W = 12
+    input_size = (H, W)
+    dummy_input = torch.rand(B, C, H, W)
+    # test stride and norm
+    patch_merge_3 = PatchEmbed(
+        in_channels=C,
+        embed_dims=embed_dims,
+        kernel_size=kernel_size,
+        stride=stride,
+        padding=0,
+        dilation=2,
+        norm_cfg=dict(type='LN'),
+        input_size=input_size)
+
+    _, shape = patch_merge_3(dummy_input)
+    # when input_size equal to real input
+    # the out_size should be equal to `init_out_size`
+    assert shape == patch_merge_3.init_out_size
+
+    input_size = (H, W)
+    dummy_input = torch.rand(B, C, H, W)
+    # test stride and norm
+    patch_merge_3 = PatchEmbed(
+        in_channels=C,
+        embed_dims=embed_dims,
+        kernel_size=kernel_size,
+        stride=stride,
+        padding=0,
+        dilation=2,
+        norm_cfg=dict(type='LN'),
+        input_size=input_size)
+
+    _, shape = patch_merge_3(dummy_input)
+    # when input_size equal to real input
+    # the out_size should be equal to `init_out_size`
+    assert shape == patch_merge_3.init_out_size
+
+    # test adap padding
+    for padding in ('same', 'corner'):
+        in_c = 2
+        embed_dims = 3
+        B = 2
+
+        # test stride is 1
+        input_size = (5, 5)
+        kernel_size = (5, 5)
+        stride = (1, 1)
+        dilation = 1
+        bias = False
+
+        x = torch.rand(B, in_c, *input_size)
+        patch_embed = PatchEmbed(
+            in_channels=in_c,
+            embed_dims=embed_dims,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=padding,
+            dilation=dilation,
+            bias=bias)
+
+        x_out, out_size = patch_embed(x)
+        assert x_out.size() == (B, 25, 3)
+        assert out_size == (5, 5)
+        assert x_out.size(1) == out_size[0] * out_size[1]
+
+        # test kernel_size == stride
+        input_size = (5, 5)
+        kernel_size = (5, 5)
+        stride = (5, 5)
+        dilation = 1
+        bias = False
+
+        x = torch.rand(B, in_c, *input_size)
+        patch_embed = PatchEmbed(
+            in_channels=in_c,
+            embed_dims=embed_dims,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=padding,
+            dilation=dilation,
+            bias=bias)
+
+        x_out, out_size = patch_embed(x)
+        assert x_out.size() == (B, 1, 3)
+        assert out_size == (1, 1)
+        assert x_out.size(1) == out_size[0] * out_size[1]
+
+        # test kernel_size == stride
+        input_size = (6, 5)
+        kernel_size = (5, 5)
+        stride = (5, 5)
+        dilation = 1
+        bias = False
+
+        x = torch.rand(B, in_c, *input_size)
+        patch_embed = PatchEmbed(
+            in_channels=in_c,
+            embed_dims=embed_dims,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=padding,
+            dilation=dilation,
+            bias=bias)
+
+        x_out, out_size = patch_embed(x)
+        assert x_out.size() == (B, 2, 3)
+        assert out_size == (2, 1)
+        assert x_out.size(1) == out_size[0] * out_size[1]
+
+        # test different kernel_size with different stride
+        input_size = (6, 5)
+        kernel_size = (6, 2)
+        stride = (6, 2)
+        dilation = 1
+        bias = False
+
+        x = torch.rand(B, in_c, *input_size)
+        patch_embed = PatchEmbed(
+            in_channels=in_c,
+            embed_dims=embed_dims,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=padding,
+            dilation=dilation,
+            bias=bias)
+
+        x_out, out_size = patch_embed(x)
+        assert x_out.size() == (B, 3, 3)
+        assert out_size == (1, 3)
+        assert x_out.size(1) == out_size[0] * out_size[1]
+
+
+def test_patch_merging():
+
+    # Test the model with int padding
+    in_c = 3
+    out_c = 4
+    kernel_size = 3
+    stride = 3
+    padding = 1
+    dilation = 1
+    bias = False
+    # test the case `pad_to_stride` is False
+    patch_merge = PatchMerging(
+        in_channels=in_c,
+        out_channels=out_c,
+        kernel_size=kernel_size,
+        stride=stride,
+        padding=padding,
+        dilation=dilation,
+        bias=bias)
+    B, L, C = 1, 100, 3
+    input_size = (10, 10)
+    x = torch.rand(B, L, C)
+    x_out, out_size = patch_merge(x, input_size)
+    assert x_out.size() == (1, 16, 4)
+    assert out_size == (4, 4)
+    # assert out size is consistent with real output
+    assert x_out.size(1) == out_size[0] * out_size[1]
+    in_c = 4
+    out_c = 5
+    kernel_size = 6
+    stride = 3
+    padding = 2
+    dilation = 2
+    bias = False
+    patch_merge = PatchMerging(
+        in_channels=in_c,
+        out_channels=out_c,
+        kernel_size=kernel_size,
+        stride=stride,
+        padding=padding,
+        dilation=dilation,
+        bias=bias)
+    B, L, C = 1, 100, 4
+    input_size = (10, 10)
+    x = torch.rand(B, L, C)
+    x_out, out_size = patch_merge(x, input_size)
+    assert x_out.size() == (1, 4, 5)
+    assert out_size == (2, 2)
+    # assert out size is consistent with real output
+    assert x_out.size(1) == out_size[0] * out_size[1]
+
+    # Test with adaptive padding
+    for padding in ('same', 'corner'):
+        in_c = 2
+        out_c = 3
+        B = 2
+
+        # test stride is 1
+        input_size = (5, 5)
+        kernel_size = (5, 5)
+        stride = (1, 1)
+        dilation = 1
+        bias = False
+        L = input_size[0] * input_size[1]
+
+        x = torch.rand(B, L, in_c)
+        patch_merge = PatchMerging(
+            in_channels=in_c,
+            out_channels=out_c,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=padding,
+            dilation=dilation,
+            bias=bias)
+
+        x_out, out_size = patch_merge(x, input_size)
+        assert x_out.size() == (B, 25, 3)
+        assert out_size == (5, 5)
+        assert x_out.size(1) == out_size[0] * out_size[1]
+
+        # test kernel_size == stride
+        input_size = (5, 5)
+        kernel_size = (5, 5)
+        stride = (5, 5)
+        dilation = 1
+        bias = False
+        L = input_size[0] * input_size[1]
+
+        x = torch.rand(B, L, in_c)
+        patch_merge = PatchMerging(
+            in_channels=in_c,
+            out_channels=out_c,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=padding,
+            dilation=dilation,
+            bias=bias)
+
+        x_out, out_size = patch_merge(x, input_size)
+        assert x_out.size() == (B, 1, 3)
+        assert out_size == (1, 1)
+        assert x_out.size(1) == out_size[0] * out_size[1]
+
+        # test kernel_size == stride
+        input_size = (6, 5)
+        kernel_size = (5, 5)
+        stride = (5, 5)
+        dilation = 1
+        bias = False
+        L = input_size[0] * input_size[1]
+
+        x = torch.rand(B, L, in_c)
+        patch_merge = PatchMerging(
+            in_channels=in_c,
+            out_channels=out_c,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=padding,
+            dilation=dilation,
+            bias=bias)
+
+        x_out, out_size = patch_merge(x, input_size)
+        assert x_out.size() == (B, 2, 3)
+        assert out_size == (2, 1)
+        assert x_out.size(1) == out_size[0] * out_size[1]
+
+        # test different kernel_size with different stride
+        input_size = (6, 5)
+        kernel_size = (6, 2)
+        stride = (6, 2)
+        dilation = 1
+        bias = False
+        L = input_size[0] * input_size[1]
+
+        x = torch.rand(B, L, in_c)
+        patch_merge = PatchMerging(
+            in_channels=in_c,
+            out_channels=out_c,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=padding,
+            dilation=dilation,
+            bias=bias)
+
+        x_out, out_size = patch_merge(x, input_size)
+        assert x_out.size() == (B, 3, 3)
+        assert out_size == (1, 3)
+        assert x_out.size(1) == out_size[0] * out_size[1]
diff --git a/mmsegmentation/tests/test_models/test_utils/test_shape_convert.py b/mmsegmentation/tests/test_models/test_utils/test_shape_convert.py
new file mode 100644
index 0000000..60e87f3
--- /dev/null
+++ b/mmsegmentation/tests/test_models/test_utils/test_shape_convert.py
@@ -0,0 +1,89 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+
+from mmseg.models.utils import (nchw2nlc2nchw, nchw_to_nlc, nlc2nchw2nlc,
+                                nlc_to_nchw)
+
+
+def test_nchw2nlc2nchw():
+    # Test nchw2nlc2nchw function
+    shape_nchw = (4, 2, 5, 5)
+    shape_nlc = (4, 25, 2)
+
+    def test_func(x):
+        assert x.shape == torch.Size(shape_nlc)
+        return x
+
+    x = torch.rand(*shape_nchw)
+    output = nchw2nlc2nchw(test_func, x)
+    assert output.shape == torch.Size(shape_nchw)
+
+    def test_func2(x, arg):
+        assert x.shape == torch.Size(shape_nlc)
+        assert arg == 100
+        return x
+
+    x = torch.rand(*shape_nchw)
+    output = nchw2nlc2nchw(test_func2, x, arg=100)
+    assert output.shape == torch.Size(shape_nchw)
+
+    def test_func3(x):
+        assert x.is_contiguous()
+        assert x.shape == torch.Size(shape_nlc)
+        return x
+
+    x = torch.rand(*shape_nchw)
+    output = nchw2nlc2nchw(test_func3, x, contiguous=True)
+    assert output.shape == torch.Size(shape_nchw)
+    assert output.is_contiguous()
+
+
+def test_nlc2nchw2nlc():
+    # Test nlc2nchw2nlc function
+    shape_nchw = (4, 2, 5, 5)
+    shape_nlc = (4, 25, 2)
+
+    def test_func(x):
+        assert x.shape == torch.Size(shape_nchw)
+        return x
+
+    x = torch.rand(*shape_nlc)
+    output = nlc2nchw2nlc(test_func, x, shape_nchw[2:])
+    assert output.shape == torch.Size(shape_nlc)
+
+    def test_func2(x, arg):
+        assert x.shape == torch.Size(shape_nchw)
+        assert arg == 100
+        return x
+
+    x = torch.rand(*shape_nlc)
+    output = nlc2nchw2nlc(test_func2, x, shape_nchw[2:], arg=100)
+    assert output.shape == torch.Size(shape_nlc)
+
+    def test_func3(x):
+        assert x.is_contiguous()
+        assert x.shape == torch.Size(shape_nchw)
+        return x
+
+    x = torch.rand(*shape_nlc)
+    output = nlc2nchw2nlc(test_func3, x, shape_nchw[2:], contiguous=True)
+    assert output.shape == torch.Size(shape_nlc)
+    assert output.is_contiguous()
+
+
+def test_nchw_to_nlc():
+    # Test nchw_to_nlc function
+    shape_nchw = (4, 2, 5, 5)
+    shape_nlc = (4, 25, 2)
+    x = torch.rand(*shape_nchw)
+    y = nchw_to_nlc(x)
+    assert y.shape == torch.Size(shape_nlc)
+
+
+def test_nlc_to_nchw():
+    # Test nlc_to_nchw function
+    shape_nchw = (4, 2, 5, 5)
+    shape_nlc = (4, 25, 2)
+    x = torch.rand(*shape_nlc)
+    y = nlc_to_nchw(x, (5, 5))
+    assert y.shape == torch.Size(shape_nchw)
diff --git a/mmsegmentation/tests/test_sampler.py b/mmsegmentation/tests/test_sampler.py
new file mode 100644
index 0000000..322be95
--- /dev/null
+++ b/mmsegmentation/tests/test_sampler.py
@@ -0,0 +1,78 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import pytest
+import torch
+
+from mmseg.models.decode_heads import FCNHead
+from mmseg.structures import OHEMPixelSampler
+
+
+def _context_for_ohem():
+    return FCNHead(in_channels=32, channels=16, num_classes=19)
+
+
+def _context_for_ohem_multiple_loss():
+    return FCNHead(
+        in_channels=32,
+        channels=16,
+        num_classes=19,
+        loss_decode=[
+            dict(type='CrossEntropyLoss', loss_name='loss_1'),
+            dict(type='CrossEntropyLoss', loss_name='loss_2')
+        ])
+
+
+def test_ohem_sampler():
+
+    with pytest.raises(AssertionError):
+        # seg_logit and seg_label must be of the same size
+        sampler = OHEMPixelSampler(context=_context_for_ohem())
+        seg_logit = torch.randn(1, 19, 45, 45)
+        seg_label = torch.randint(0, 19, size=(1, 1, 89, 89))
+        sampler.sample(seg_logit, seg_label)
+
+    # test with thresh
+    sampler = OHEMPixelSampler(
+        context=_context_for_ohem(), thresh=0.7, min_kept=200)
+    seg_logit = torch.randn(1, 19, 45, 45)
+    seg_label = torch.randint(0, 19, size=(1, 1, 45, 45))
+    seg_weight = sampler.sample(seg_logit, seg_label)
+    assert seg_weight.shape[0] == seg_logit.shape[0]
+    assert seg_weight.shape[1:] == seg_logit.shape[2:]
+    assert seg_weight.sum() > 200
+
+    # test w.o thresh
+    sampler = OHEMPixelSampler(context=_context_for_ohem(), min_kept=200)
+    seg_logit = torch.randn(1, 19, 45, 45)
+    seg_label = torch.randint(0, 19, size=(1, 1, 45, 45))
+    seg_weight = sampler.sample(seg_logit, seg_label)
+    assert seg_weight.shape[0] == seg_logit.shape[0]
+    assert seg_weight.shape[1:] == seg_logit.shape[2:]
+    assert seg_weight.sum() == 200
+
+    # test multiple losses case
+    with pytest.raises(AssertionError):
+        # seg_logit and seg_label must be of the same size
+        sampler = OHEMPixelSampler(context=_context_for_ohem_multiple_loss())
+        seg_logit = torch.randn(1, 19, 45, 45)
+        seg_label = torch.randint(0, 19, size=(1, 1, 89, 89))
+        sampler.sample(seg_logit, seg_label)
+
+    # test with thresh in multiple losses case
+    sampler = OHEMPixelSampler(
+        context=_context_for_ohem_multiple_loss(), thresh=0.7, min_kept=200)
+    seg_logit = torch.randn(1, 19, 45, 45)
+    seg_label = torch.randint(0, 19, size=(1, 1, 45, 45))
+    seg_weight = sampler.sample(seg_logit, seg_label)
+    assert seg_weight.shape[0] == seg_logit.shape[0]
+    assert seg_weight.shape[1:] == seg_logit.shape[2:]
+    assert seg_weight.sum() > 200
+
+    # test w.o thresh in multiple losses case
+    sampler = OHEMPixelSampler(
+        context=_context_for_ohem_multiple_loss(), min_kept=200)
+    seg_logit = torch.randn(1, 19, 45, 45)
+    seg_label = torch.randint(0, 19, size=(1, 1, 45, 45))
+    seg_weight = sampler.sample(seg_logit, seg_label)
+    assert seg_weight.shape[0] == seg_logit.shape[0]
+    assert seg_weight.shape[1:] == seg_logit.shape[2:]
+    assert seg_weight.sum() == 200
diff --git a/mmsegmentation/tests/test_structures/test_seg_data_sample.py b/mmsegmentation/tests/test_structures/test_seg_data_sample.py
new file mode 100644
index 0000000..37796b6
--- /dev/null
+++ b/mmsegmentation/tests/test_structures/test_seg_data_sample.py
@@ -0,0 +1,77 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from unittest import TestCase
+
+import numpy as np
+import pytest
+import torch
+from mmengine.structures import PixelData
+
+from mmseg.structures import SegDataSample
+
+
+def _equal(a, b):
+    if isinstance(a, (torch.Tensor, np.ndarray)):
+        return (a == b).all()
+    else:
+        return a == b
+
+
+class TestSegDataSample(TestCase):
+
+    def test_init(self):
+        meta_info = dict(
+            img_size=[256, 256],
+            scale_factor=np.array([1.5, 1.5]),
+            img_shape=torch.rand(4))
+
+        seg_data_sample = SegDataSample(metainfo=meta_info)
+        assert 'img_size' in seg_data_sample
+        assert seg_data_sample.img_size == [256, 256]
+        assert seg_data_sample.get('img_size') == [256, 256]
+
+    def test_setter(self):
+        seg_data_sample = SegDataSample()
+
+        # test gt_sem_seg
+        gt_sem_seg_data = dict(sem_seg=torch.rand(5, 4, 2))
+        gt_sem_seg = PixelData(**gt_sem_seg_data)
+        seg_data_sample.gt_sem_seg = gt_sem_seg
+        assert 'gt_sem_seg' in seg_data_sample
+        assert _equal(seg_data_sample.gt_sem_seg.sem_seg,
+                      gt_sem_seg_data['sem_seg'])
+
+        # test pred_sem_seg
+        pred_sem_seg_data = dict(sem_seg=torch.rand(5, 4, 2))
+        pred_sem_seg = PixelData(**pred_sem_seg_data)
+        seg_data_sample.pred_sem_seg = pred_sem_seg
+        assert 'pred_sem_seg' in seg_data_sample
+        assert _equal(seg_data_sample.pred_sem_seg.sem_seg,
+                      pred_sem_seg_data['sem_seg'])
+
+        # test seg_logits
+        seg_logits_data = dict(sem_seg=torch.rand(5, 4, 2))
+        seg_logits = PixelData(**seg_logits_data)
+        seg_data_sample.seg_logits = seg_logits
+        assert 'seg_logits' in seg_data_sample
+        assert _equal(seg_data_sample.seg_logits.sem_seg,
+                      seg_logits_data['sem_seg'])
+
+        # test type error
+        with pytest.raises(AssertionError):
+            seg_data_sample.gt_sem_seg = torch.rand(2, 4)
+
+        with pytest.raises(AssertionError):
+            seg_data_sample.pred_sem_seg = torch.rand(2, 4)
+
+        with pytest.raises(AssertionError):
+            seg_data_sample.seg_logits = torch.rand(2, 4)
+
+    def test_deleter(self):
+        seg_data_sample = SegDataSample()
+
+        pred_sem_seg_data = dict(sem_seg=torch.rand(5, 4, 2))
+        pred_sem_seg = PixelData(**pred_sem_seg_data)
+        seg_data_sample.pred_sem_seg = pred_sem_seg
+        assert 'pred_sem_seg' in seg_data_sample
+        del seg_data_sample.pred_sem_seg
+        assert 'pred_sem_seg' not in seg_data_sample
diff --git a/mmsegmentation/tests/test_utils/test_io.py b/mmsegmentation/tests/test_utils/test_io.py
new file mode 100644
index 0000000..05abd27
--- /dev/null
+++ b/mmsegmentation/tests/test_utils/test_io.py
@@ -0,0 +1,33 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+
+import numpy as np
+import pytest
+from mmengine import FileClient
+
+from mmseg.utils import datafrombytes
+
+
+@pytest.mark.parametrize(
+    ['backend', 'suffix'],
+    [['nifti', '.nii.gz'], ['numpy', '.npy'], ['pickle', '.pkl']])
+def test_datafrombytes(backend, suffix):
+
+    file_client = FileClient('disk')
+    file_path = osp.join(osp.dirname(__file__), '../data/biomedical' + suffix)
+    bytes = file_client.get(file_path)
+    data = datafrombytes(bytes, backend)
+
+    if backend == 'pickle':
+        # test pickle loading
+        assert isinstance(data, dict)
+    else:
+        assert isinstance(data, np.ndarray)
+        if backend == 'nifti':
+            # test nifti file loading
+            assert len(data.shape) == 3
+        else:
+            # test npy file loading
+            # testing data biomedical.npy includes data and label
+            assert len(data.shape) == 4
+            assert data.shape[0] == 2
diff --git a/mmsegmentation/tests/test_utils/test_set_env.py b/mmsegmentation/tests/test_utils/test_set_env.py
new file mode 100644
index 0000000..86a2d29
--- /dev/null
+++ b/mmsegmentation/tests/test_utils/test_set_env.py
@@ -0,0 +1,39 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import datetime
+import sys
+from unittest import TestCase
+
+from mmengine import DefaultScope
+
+from mmseg.utils import register_all_modules
+
+
+class TestSetupEnv(TestCase):
+
+    def test_register_all_modules(self):
+        from mmseg.registry import DATASETS
+
+        # not init default scope
+        sys.modules.pop('mmseg.datasets', None)
+        sys.modules.pop('mmseg.datasets.ade', None)
+        DATASETS._module_dict.pop('ADE20KDataset', None)
+        self.assertFalse('ADE20KDataset' in DATASETS.module_dict)
+        register_all_modules(init_default_scope=False)
+        self.assertTrue('ADE20KDataset' in DATASETS.module_dict)
+
+        # init default scope
+        sys.modules.pop('mmseg.datasets')
+        sys.modules.pop('mmseg.datasets.ade')
+        DATASETS._module_dict.pop('ADE20KDataset', None)
+        self.assertFalse('ADE20KDataset' in DATASETS.module_dict)
+        register_all_modules(init_default_scope=True)
+        self.assertTrue('ADE20KDataset' in DATASETS.module_dict)
+        self.assertEqual(DefaultScope.get_current_instance().scope_name,
+                         'mmseg')
+
+        # init default scope when another scope is init
+        name = f'test-{datetime.datetime.now()}'
+        DefaultScope.get_instance(name, scope_name='test')
+        with self.assertWarnsRegex(
+                Warning, 'The current default scope "test" is not "mmseg"'):
+            register_all_modules(init_default_scope=True)
diff --git a/mmsegmentation/tests/test_visualization/test_local_visualizer.py b/mmsegmentation/tests/test_visualization/test_local_visualizer.py
new file mode 100644
index 0000000..e3b2a88
--- /dev/null
+++ b/mmsegmentation/tests/test_visualization/test_local_visualizer.py
@@ -0,0 +1,213 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os
+import os.path as osp
+import tempfile
+from unittest import TestCase
+
+import cv2
+import mmcv
+import numpy as np
+import torch
+from mmengine.structures import PixelData
+
+from mmseg.structures import SegDataSample
+from mmseg.visualization import SegLocalVisualizer
+
+
+class TestSegLocalVisualizer(TestCase):
+
+    def test_add_datasample(self):
+        h = 10
+        w = 12
+        num_class = 2
+        out_file = 'out_file'
+
+        image = np.random.randint(0, 256, size=(h, w, 3)).astype('uint8')
+
+        # test gt_sem_seg
+        gt_sem_seg_data = dict(data=torch.randint(0, num_class, (1, h, w)))
+        gt_sem_seg = PixelData(**gt_sem_seg_data)
+
+        def test_add_datasample_forward(gt_sem_seg):
+            data_sample = SegDataSample()
+            data_sample.gt_sem_seg = gt_sem_seg
+
+            with tempfile.TemporaryDirectory() as tmp_dir:
+                seg_local_visualizer = SegLocalVisualizer(
+                    vis_backends=[dict(type='LocalVisBackend')],
+                    save_dir=tmp_dir)
+                seg_local_visualizer.dataset_meta = dict(
+                    classes=('background', 'foreground'),
+                    palette=[[120, 120, 120], [6, 230, 230]])
+
+                # test out_file
+                seg_local_visualizer.add_datasample(out_file, image,
+                                                    data_sample)
+
+                assert os.path.exists(
+                    osp.join(tmp_dir, 'vis_data', 'vis_image',
+                             out_file + '_0.png'))
+                drawn_img = cv2.imread(
+                    osp.join(tmp_dir, 'vis_data', 'vis_image',
+                             out_file + '_0.png'))
+                assert drawn_img.shape == (h, w, 3)
+
+                # test gt_instances and pred_instances
+                pred_sem_seg_data = dict(
+                    data=torch.randint(0, num_class, (1, h, w)))
+                pred_sem_seg = PixelData(**pred_sem_seg_data)
+
+                data_sample.pred_sem_seg = pred_sem_seg
+
+                seg_local_visualizer.add_datasample(out_file, image,
+                                                    data_sample)
+                self._assert_image_and_shape(
+                    osp.join(tmp_dir, 'vis_data', 'vis_image',
+                             out_file + '_0.png'), (h, w * 2, 3))
+
+                seg_local_visualizer.add_datasample(
+                    out_file, image, data_sample, draw_gt=False)
+                self._assert_image_and_shape(
+                    osp.join(tmp_dir, 'vis_data', 'vis_image',
+                             out_file + '_0.png'), (h, w, 3))
+
+        if torch.cuda.is_available():
+            test_add_datasample_forward(gt_sem_seg.cuda())
+        test_add_datasample_forward(gt_sem_seg)
+
+    def test_cityscapes_add_datasample(self):
+        h = 128
+        w = 256
+        num_class = 19
+        out_file = 'out_file_cityscapes'
+
+        image = mmcv.imread(
+            osp.join(
+                osp.dirname(__file__),
+                '../data/pseudo_cityscapes_dataset/leftImg8bit/val/frankfurt/frankfurt_000000_000294_leftImg8bit.png'  # noqa
+            ),
+            'color')
+        sem_seg = mmcv.imread(
+            osp.join(
+                osp.dirname(__file__),
+                '../data/pseudo_cityscapes_dataset/gtFine/val/frankfurt/frankfurt_000000_000294_gtFine_labelTrainIds.png'  # noqa
+            ),
+            'unchanged')
+        sem_seg = torch.unsqueeze(torch.from_numpy(sem_seg), 0)
+        gt_sem_seg_data = dict(data=sem_seg)
+        gt_sem_seg = PixelData(**gt_sem_seg_data)
+
+        def test_cityscapes_add_datasample_forward(gt_sem_seg):
+            data_sample = SegDataSample()
+            data_sample.gt_sem_seg = gt_sem_seg
+
+            with tempfile.TemporaryDirectory() as tmp_dir:
+                seg_local_visualizer = SegLocalVisualizer(
+                    vis_backends=[dict(type='LocalVisBackend')],
+                    save_dir=tmp_dir)
+                seg_local_visualizer.dataset_meta = dict(
+                    classes=('road', 'sidewalk', 'building', 'wall', 'fence',
+                             'pole', 'traffic light', 'traffic sign',
+                             'vegetation', 'terrain', 'sky', 'person', 'rider',
+                             'car', 'truck', 'bus', 'train', 'motorcycle',
+                             'bicycle'),
+                    palette=[[128, 64, 128], [244, 35, 232], [70, 70, 70],
+                             [102, 102, 156], [190, 153, 153], [153, 153, 153],
+                             [250, 170, 30], [220, 220, 0], [107, 142, 35],
+                             [152, 251, 152], [70, 130, 180], [220, 20, 60],
+                             [255, 0, 0], [0, 0, 142], [0, 0, 70],
+                             [0, 60, 100], [0, 80, 100], [0, 0, 230],
+                             [119, 11, 32]])
+                # test out_file
+                seg_local_visualizer.add_datasample(
+                    out_file,
+                    image,
+                    data_sample,
+                    out_file=osp.join(tmp_dir, 'test.png'))
+                self._assert_image_and_shape(
+                    osp.join(tmp_dir, 'test.png'), (h, w, 3))
+
+                # test gt_instances and pred_instances
+                pred_sem_seg_data = dict(
+                    data=torch.randint(0, num_class, (1, h, w)))
+                pred_sem_seg = PixelData(**pred_sem_seg_data)
+
+                data_sample.pred_sem_seg = pred_sem_seg
+
+                # test draw prediction with gt
+                seg_local_visualizer.add_datasample(out_file, image,
+                                                    data_sample)
+                self._assert_image_and_shape(
+                    osp.join(tmp_dir, 'vis_data', 'vis_image',
+                             out_file + '_0.png'), (h, w * 2, 3))
+                # test draw prediction without gt
+                seg_local_visualizer.add_datasample(
+                    out_file, image, data_sample, draw_gt=False)
+                self._assert_image_and_shape(
+                    osp.join(tmp_dir, 'vis_data', 'vis_image',
+                             out_file + '_0.png'), (h, w, 3))
+
+        if torch.cuda.is_available():
+            test_cityscapes_add_datasample_forward(gt_sem_seg.cuda())
+        test_cityscapes_add_datasample_forward(gt_sem_seg)
+
+    def _assert_image_and_shape(self, out_file, out_shape):
+        assert os.path.exists(out_file)
+        drawn_img = cv2.imread(out_file)
+        assert drawn_img.shape == out_shape
+
+    def test_add_datasample_depth(self):
+        h = 10
+        w = 12
+        out_file = 'out_file'
+
+        image = np.random.randint(0, 256, size=(h, w, 3)).astype('uint8')
+
+        # test gt_depth_map
+        gt_depth_map = PixelData(data=torch.rand(1, h, w))
+
+        def test_add_datasample_forward_depth(gt_depth_map):
+            data_sample = SegDataSample()
+            data_sample.gt_depth_map = gt_depth_map
+
+            with tempfile.TemporaryDirectory() as tmp_dir:
+                seg_local_visualizer = SegLocalVisualizer(
+                    vis_backends=[dict(type='LocalVisBackend')],
+                    save_dir=tmp_dir)
+                seg_local_visualizer.dataset_meta = dict(
+                    classes=('background', 'foreground'),
+                    palette=[[120, 120, 120], [6, 230, 230]])
+
+                # test out_file
+                seg_local_visualizer.add_datasample(out_file, image,
+                                                    data_sample)
+
+                assert os.path.exists(
+                    osp.join(tmp_dir, 'vis_data', 'vis_image',
+                             out_file + '_0.png'))
+                drawn_img = cv2.imread(
+                    osp.join(tmp_dir, 'vis_data', 'vis_image',
+                             out_file + '_0.png'))
+                assert drawn_img.shape == (h * 2, w, 3)
+
+                # test gt_instances and pred_instances
+
+                pred_depth_map = PixelData(data=torch.rand(1, h, w))
+
+                data_sample.pred_depth_map = pred_depth_map
+
+                seg_local_visualizer.add_datasample(out_file, image,
+                                                    data_sample)
+                self._assert_image_and_shape(
+                    osp.join(tmp_dir, 'vis_data', 'vis_image',
+                             out_file + '_0.png'), (h * 2, w * 2, 3))
+
+                seg_local_visualizer.add_datasample(
+                    out_file, image, data_sample, draw_gt=False)
+                self._assert_image_and_shape(
+                    osp.join(tmp_dir, 'vis_data', 'vis_image',
+                             out_file + '_0.png'), (h * 2, w, 3))
+
+        if torch.cuda.is_available():
+            test_add_datasample_forward_depth(gt_depth_map.cuda())
+        test_add_datasample_forward_depth(gt_depth_map)
diff --git a/mmsegmentation/tools/analysis_tools/analyze_logs.py b/mmsegmentation/tools/analysis_tools/analyze_logs.py
new file mode 100644
index 0000000..7464d23
--- /dev/null
+++ b/mmsegmentation/tools/analysis_tools/analyze_logs.py
@@ -0,0 +1,130 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+"""Modified from https://github.com/open-
+mmlab/mmdetection/blob/master/tools/analysis_tools/analyze_logs.py."""
+import argparse
+import json
+from collections import defaultdict
+
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+
+def plot_curve(log_dicts, args):
+    if args.backend is not None:
+        plt.switch_backend(args.backend)
+    sns.set_style(args.style)
+    # if legend is None, use {filename}_{key} as legend
+    legend = args.legend
+    if legend is None:
+        legend = []
+        for json_log in args.json_logs:
+            for metric in args.keys:
+                legend.append(f'{json_log}_{metric}')
+    assert len(legend) == (len(args.json_logs) * len(args.keys))
+    metrics = args.keys
+
+    num_metrics = len(metrics)
+    for i, log_dict in enumerate(log_dicts):
+        epochs = list(log_dict.keys())
+        for j, metric in enumerate(metrics):
+            print(f'plot curve of {args.json_logs[i]}, metric is {metric}')
+            plot_epochs = []
+            plot_iters = []
+            plot_values = []
+            # In some log files exist lines of validation,
+            # `mode` list is used to only collect iter number
+            # of training line.
+            for epoch in epochs:
+                epoch_logs = log_dict[epoch]
+                if metric not in epoch_logs.keys():
+                    continue
+                if metric in ['mIoU', 'mAcc', 'aAcc']:
+                    plot_epochs.append(epoch)
+                    plot_values.append(epoch_logs[metric][0])
+                else:
+                    for idx in range(len(epoch_logs[metric])):
+                        plot_iters.append(epoch_logs['step'][idx])
+                        plot_values.append(epoch_logs[metric][idx])
+            ax = plt.gca()
+            label = legend[i * num_metrics + j]
+            if metric in ['mIoU', 'mAcc', 'aAcc']:
+                ax.set_xticks(plot_epochs)
+                plt.xlabel('step')
+                plt.plot(plot_epochs, plot_values, label=label, marker='o')
+            else:
+                plt.xlabel('iter')
+                plt.plot(plot_iters, plot_values, label=label, linewidth=0.5)
+        plt.legend()
+        if args.title is not None:
+            plt.title(args.title)
+    if args.out is None:
+        plt.show()
+    else:
+        print(f'save curve to: {args.out}')
+        plt.savefig(args.out)
+        plt.cla()
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Analyze Json Log')
+    parser.add_argument(
+        'json_logs',
+        type=str,
+        nargs='+',
+        help='path of train log in json format')
+    parser.add_argument(
+        '--keys',
+        type=str,
+        nargs='+',
+        default=['mIoU'],
+        help='the metric that you want to plot')
+    parser.add_argument('--title', type=str, help='title of figure')
+    parser.add_argument(
+        '--legend',
+        type=str,
+        nargs='+',
+        default=None,
+        help='legend of each plot')
+    parser.add_argument(
+        '--backend', type=str, default=None, help='backend of plt')
+    parser.add_argument(
+        '--style', type=str, default='dark', help='style of plt')
+    parser.add_argument('--out', type=str, default=None)
+    args = parser.parse_args()
+    return args
+
+
+def load_json_logs(json_logs):
+    # load and convert json_logs to log_dict, key is step, value is a sub dict
+    # keys of sub dict is different metrics
+    # value of sub dict is a list of corresponding values of all iterations
+    log_dicts = [dict() for _ in json_logs]
+    prev_step = 0
+    for json_log, log_dict in zip(json_logs, log_dicts):
+        with open(json_log) as log_file:
+            for line in log_file:
+                log = json.loads(line.strip())
+                # the final step in json file is 0.
+                if 'step' in log and log['step'] != 0:
+                    step = log['step']
+                    prev_step = step
+                else:
+                    step = prev_step
+                if step not in log_dict:
+                    log_dict[step] = defaultdict(list)
+                for k, v in log.items():
+                    log_dict[step][k].append(v)
+    return log_dicts
+
+
+def main():
+    args = parse_args()
+    json_logs = args.json_logs
+    for json_log in json_logs:
+        assert json_log.endswith('.json')
+    log_dicts = load_json_logs(json_logs)
+    plot_curve(log_dicts, args)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/analysis_tools/benchmark.py b/mmsegmentation/tools/analysis_tools/benchmark.py
new file mode 100644
index 0000000..afaeaba
--- /dev/null
+++ b/mmsegmentation/tools/analysis_tools/benchmark.py
@@ -0,0 +1,121 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os.path as osp
+import time
+
+import numpy as np
+import torch
+from mmengine import Config
+from mmengine.fileio import dump
+from mmengine.model.utils import revert_sync_batchnorm
+from mmengine.registry import init_default_scope
+from mmengine.runner import Runner, load_checkpoint
+from mmengine.utils import mkdir_or_exist
+
+from mmseg.registry import MODELS
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='MMSeg benchmark a model')
+    parser.add_argument('config', help='test config file path')
+    parser.add_argument('checkpoint', help='checkpoint file')
+    parser.add_argument(
+        '--log-interval', type=int, default=50, help='interval of logging')
+    parser.add_argument(
+        '--work-dir',
+        help=('if specified, the results will be dumped '
+              'into the directory as json'))
+    parser.add_argument('--repeat-times', type=int, default=1)
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    cfg = Config.fromfile(args.config)
+
+    init_default_scope(cfg.get('default_scope', 'mmseg'))
+
+    timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime())
+    if args.work_dir is not None:
+        mkdir_or_exist(osp.abspath(args.work_dir))
+        json_file = osp.join(args.work_dir, f'fps_{timestamp}.json')
+    else:
+        # use config filename as default work_dir if cfg.work_dir is None
+        work_dir = osp.join('./work_dirs',
+                            osp.splitext(osp.basename(args.config))[0])
+        mkdir_or_exist(osp.abspath(work_dir))
+        json_file = osp.join(work_dir, f'fps_{timestamp}.json')
+
+    repeat_times = args.repeat_times
+    # set cudnn_benchmark
+    torch.backends.cudnn.benchmark = False
+    cfg.model.pretrained = None
+
+    benchmark_dict = dict(config=args.config, unit='img / s')
+    overall_fps_list = []
+    cfg.test_dataloader.batch_size = 1
+    for time_index in range(repeat_times):
+        print(f'Run {time_index + 1}:')
+        # build the dataloader
+        data_loader = Runner.build_dataloader(cfg.test_dataloader)
+
+        # build the model and load checkpoint
+        cfg.model.train_cfg = None
+        model = MODELS.build(cfg.model)
+
+        if 'checkpoint' in args and osp.exists(args.checkpoint):
+            load_checkpoint(model, args.checkpoint, map_location='cpu')
+
+        if torch.cuda.is_available():
+            model = model.cuda()
+
+        model = revert_sync_batchnorm(model)
+
+        model.eval()
+
+        # the first several iterations may be very slow so skip them
+        num_warmup = 5
+        pure_inf_time = 0
+        total_iters = 200
+
+        # benchmark with 200 batches and take the average
+        for i, data in enumerate(data_loader):
+            data = model.data_preprocessor(data, True)
+            inputs = data['inputs']
+            data_samples = data['data_samples']
+            if torch.cuda.is_available():
+                torch.cuda.synchronize()
+            start_time = time.perf_counter()
+
+            with torch.no_grad():
+                model(inputs, data_samples, mode='predict')
+
+            if torch.cuda.is_available():
+                torch.cuda.synchronize()
+            elapsed = time.perf_counter() - start_time
+
+            if i >= num_warmup:
+                pure_inf_time += elapsed
+                if (i + 1) % args.log_interval == 0:
+                    fps = (i + 1 - num_warmup) / pure_inf_time
+                    print(f'Done image [{i + 1:<3}/ {total_iters}], '
+                          f'fps: {fps:.2f} img / s')
+
+            if (i + 1) == total_iters:
+                fps = (i + 1 - num_warmup) / pure_inf_time
+                print(f'Overall fps: {fps:.2f} img / s\n')
+                benchmark_dict[f'overall_fps_{time_index + 1}'] = round(fps, 2)
+                overall_fps_list.append(fps)
+                break
+    benchmark_dict['average_fps'] = round(np.mean(overall_fps_list), 2)
+    benchmark_dict['fps_variance'] = round(np.var(overall_fps_list), 4)
+    print(f'Average fps of {repeat_times} evaluations: '
+          f'{benchmark_dict["average_fps"]}')
+    print(f'The variance of {repeat_times} evaluations: '
+          f'{benchmark_dict["fps_variance"]}')
+    dump(benchmark_dict, json_file, indent=4)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/analysis_tools/browse_dataset.py b/mmsegmentation/tools/analysis_tools/browse_dataset.py
new file mode 100644
index 0000000..925c14a
--- /dev/null
+++ b/mmsegmentation/tools/analysis_tools/browse_dataset.py
@@ -0,0 +1,77 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os.path as osp
+
+from mmengine.config import Config, DictAction
+from mmengine.utils import ProgressBar
+
+from mmseg.registry import DATASETS, VISUALIZERS
+from mmseg.utils import register_all_modules
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Browse a dataset')
+    parser.add_argument('config', help='train config file path')
+    parser.add_argument(
+        '--output-dir',
+        default=None,
+        type=str,
+        help='If there is no display interface, you can save it')
+    parser.add_argument('--not-show', default=False, action='store_true')
+    parser.add_argument(
+        '--show-interval',
+        type=float,
+        default=2,
+        help='the interval of show (s)')
+    parser.add_argument(
+        '--cfg-options',
+        nargs='+',
+        action=DictAction,
+        help='override some settings in the used config, the key-value pair '
+        'in xxx=yyy format will be merged into config file. If the value to '
+        'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
+        'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
+        'Note that the quotation marks are necessary and that no white space '
+        'is allowed.')
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    cfg = Config.fromfile(args.config)
+    if args.cfg_options is not None:
+        cfg.merge_from_dict(args.cfg_options)
+
+    # register all modules in mmdet into the registries
+    register_all_modules()
+
+    dataset = DATASETS.build(cfg.train_dataloader.dataset)
+    visualizer = VISUALIZERS.build(cfg.visualizer)
+    visualizer.dataset_meta = dataset.metainfo
+
+    progress_bar = ProgressBar(len(dataset))
+    for item in dataset:
+        img = item['inputs'].permute(1, 2, 0).numpy()
+        img = img[..., [2, 1, 0]]  # bgr to rgb
+        data_sample = item['data_samples'].numpy()
+        img_path = osp.basename(item['data_samples'].img_path)
+
+        out_file = osp.join(
+            args.output_dir,
+            osp.basename(img_path)) if args.output_dir is not None else None
+
+        visualizer.add_datasample(
+            name=osp.basename(img_path),
+            image=img,
+            data_sample=data_sample,
+            draw_gt=True,
+            draw_pred=False,
+            wait_time=args.show_interval,
+            out_file=out_file,
+            show=not args.not_show)
+        progress_bar.update()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/analysis_tools/confusion_matrix.py b/mmsegmentation/tools/analysis_tools/confusion_matrix.py
new file mode 100644
index 0000000..39756cd
--- /dev/null
+++ b/mmsegmentation/tools/analysis_tools/confusion_matrix.py
@@ -0,0 +1,197 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os
+
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.ticker import MultipleLocator
+from mmengine.config import Config, DictAction
+from mmengine.registry import init_default_scope
+from mmengine.utils import mkdir_or_exist, progressbar
+from PIL import Image
+
+from mmseg.registry import DATASETS
+
+init_default_scope('mmseg')
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Generate confusion matrix from segmentation results')
+    parser.add_argument('config', help='test config file path')
+    parser.add_argument(
+        'prediction_path', help='prediction path where test folder result')
+    parser.add_argument(
+        'save_dir', help='directory where confusion matrix will be saved')
+    parser.add_argument(
+        '--show', action='store_true', help='show confusion matrix')
+    parser.add_argument(
+        '--color-theme',
+        default='winter',
+        help='theme of the matrix color map')
+    parser.add_argument(
+        '--title',
+        default='Normalized Confusion Matrix',
+        help='title of the matrix color map')
+    parser.add_argument(
+        '--cfg-options',
+        nargs='+',
+        action=DictAction,
+        help='override some settings in the used config, the key-value pair '
+        'in xxx=yyy format will be merged into config file. If the value to '
+        'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
+        'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
+        'Note that the quotation marks are necessary and that no white space '
+        'is allowed.')
+    args = parser.parse_args()
+    return args
+
+
+def calculate_confusion_matrix(dataset, results):
+    """Calculate the confusion matrix.
+
+    Args:
+        dataset (Dataset): Test or val dataset.
+        results (list[ndarray]): A list of segmentation results in each image.
+    """
+    n = len(dataset.METAINFO['classes'])
+    confusion_matrix = np.zeros(shape=[n, n])
+    assert len(dataset) == len(results)
+    ignore_index = dataset.ignore_index
+    reduce_zero_label = dataset.reduce_zero_label
+    prog_bar = progressbar.ProgressBar(len(results))
+    for idx, per_img_res in enumerate(results):
+        res_segm = per_img_res
+        gt_segm = dataset[idx]['data_samples'] \
+            .gt_sem_seg.data.squeeze().numpy().astype(np.uint8)
+        gt_segm, res_segm = gt_segm.flatten(), res_segm.flatten()
+        if reduce_zero_label:
+            gt_segm = gt_segm - 1
+        to_ignore = gt_segm == ignore_index
+
+        gt_segm, res_segm = gt_segm[~to_ignore], res_segm[~to_ignore]
+        inds = n * gt_segm + res_segm
+        mat = np.bincount(inds, minlength=n**2).reshape(n, n)
+        confusion_matrix += mat
+        prog_bar.update()
+    return confusion_matrix
+
+
+def plot_confusion_matrix(confusion_matrix,
+                          labels,
+                          save_dir=None,
+                          show=True,
+                          title='Normalized Confusion Matrix',
+                          color_theme='OrRd'):
+    """Draw confusion matrix with matplotlib.
+
+    Args:
+        confusion_matrix (ndarray): The confusion matrix.
+        labels (list[str]): List of class names.
+        save_dir (str|optional): If set, save the confusion matrix plot to the
+            given path. Default: None.
+        show (bool): Whether to show the plot. Default: True.
+        title (str): Title of the plot. Default: `Normalized Confusion Matrix`.
+        color_theme (str): Theme of the matrix color map. Default: `winter`.
+    """
+    # normalize the confusion matrix
+    per_label_sums = confusion_matrix.sum(axis=1)[:, np.newaxis]
+    confusion_matrix = \
+        confusion_matrix.astype(np.float32) / per_label_sums * 100
+
+    num_classes = len(labels)
+    fig, ax = plt.subplots(
+        figsize=(2 * num_classes, 2 * num_classes * 0.8), dpi=300)
+    cmap = plt.get_cmap(color_theme)
+    im = ax.imshow(confusion_matrix, cmap=cmap)
+    colorbar = plt.colorbar(mappable=im, ax=ax)
+    colorbar.ax.tick_params(labelsize=20)  # 设置 colorbar 标签的字体大小
+
+    title_font = {'weight': 'bold', 'size': 20}
+    ax.set_title(title, fontdict=title_font)
+    label_font = {'size': 40}
+    plt.ylabel('Ground Truth Label', fontdict=label_font)
+    plt.xlabel('Prediction Label', fontdict=label_font)
+
+    # draw locator
+    xmajor_locator = MultipleLocator(1)
+    xminor_locator = MultipleLocator(0.5)
+    ax.xaxis.set_major_locator(xmajor_locator)
+    ax.xaxis.set_minor_locator(xminor_locator)
+    ymajor_locator = MultipleLocator(1)
+    yminor_locator = MultipleLocator(0.5)
+    ax.yaxis.set_major_locator(ymajor_locator)
+    ax.yaxis.set_minor_locator(yminor_locator)
+
+    # draw grid
+    ax.grid(True, which='minor', linestyle='-')
+
+    # draw label
+    ax.set_xticks(np.arange(num_classes))
+    ax.set_yticks(np.arange(num_classes))
+    ax.set_xticklabels(labels, fontsize=20)
+    ax.set_yticklabels(labels, fontsize=20)
+
+    ax.tick_params(
+        axis='x', bottom=False, top=True, labelbottom=False, labeltop=True)
+    plt.setp(
+        ax.get_xticklabels(), rotation=45, ha='left', rotation_mode='anchor')
+
+    # draw confusion matrix value
+    for i in range(num_classes):
+        for j in range(num_classes):
+            ax.text(
+                j,
+                i,
+                '{}%'.format(
+                    round(confusion_matrix[i, j], 2
+                          ) if not np.isnan(confusion_matrix[i, j]) else -1),
+                ha='center',
+                va='center',
+                color='k',
+                size=20)
+
+    ax.set_ylim(len(confusion_matrix) - 0.5, -0.5)  # matplotlib>3.1.1
+
+    fig.tight_layout()
+    if save_dir is not None:
+        mkdir_or_exist(save_dir)
+        plt.savefig(
+            os.path.join(save_dir, 'confusion_matrix.png'), format='png')
+    if show:
+        plt.show()
+
+
+def main():
+    args = parse_args()
+
+    cfg = Config.fromfile(args.config)
+    if args.cfg_options is not None:
+        cfg.merge_from_dict(args.cfg_options)
+
+    results = []
+    for img in sorted(os.listdir(args.prediction_path)):
+        img = os.path.join(args.prediction_path, img)
+        image = Image.open(img)
+        image = np.copy(image)
+        results.append(image)
+
+    assert isinstance(results, list)
+    if isinstance(results[0], np.ndarray):
+        pass
+    else:
+        raise TypeError('invalid type of prediction results')
+
+    dataset = DATASETS.build(cfg.test_dataloader.dataset)
+    confusion_matrix = calculate_confusion_matrix(dataset, results)
+    plot_confusion_matrix(
+        confusion_matrix,
+        dataset.METAINFO['classes'],
+        save_dir=args.save_dir,
+        show=args.show,
+        title=args.title,
+        color_theme=args.color_theme)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/analysis_tools/get_flops.py b/mmsegmentation/tools/analysis_tools/get_flops.py
new file mode 100644
index 0000000..78a7398
--- /dev/null
+++ b/mmsegmentation/tools/analysis_tools/get_flops.py
@@ -0,0 +1,124 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import tempfile
+from pathlib import Path
+
+import torch
+from mmengine import Config, DictAction
+from mmengine.logging import MMLogger
+from mmengine.model import revert_sync_batchnorm
+from mmengine.registry import init_default_scope
+
+from mmseg.models import BaseSegmentor
+from mmseg.registry import MODELS
+from mmseg.structures import SegDataSample
+
+try:
+    from mmengine.analysis import get_model_complexity_info
+    from mmengine.analysis.print_helper import _format_size
+except ImportError:
+    raise ImportError('Please upgrade mmengine >= 0.6.0 to use this script.')
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Get the FLOPs of a segmentor')
+    parser.add_argument('config', help='train config file path')
+    parser.add_argument(
+        '--shape',
+        type=int,
+        nargs='+',
+        default=[2048, 1024],
+        help='input image size')
+    parser.add_argument(
+        '--cfg-options',
+        nargs='+',
+        action=DictAction,
+        help='override some settings in the used config, the key-value pair '
+        'in xxx=yyy format will be merged into config file. If the value to '
+        'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
+        'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
+        'Note that the quotation marks are necessary and that no white space '
+        'is allowed.')
+    args = parser.parse_args()
+    return args
+
+
+def inference(args: argparse.Namespace, logger: MMLogger) -> dict:
+    config_name = Path(args.config)
+
+    if not config_name.exists():
+        logger.error(f'Config file {config_name} does not exist')
+
+    cfg: Config = Config.fromfile(config_name)
+    cfg.work_dir = tempfile.TemporaryDirectory().name
+    cfg.log_level = 'WARN'
+    if args.cfg_options is not None:
+        cfg.merge_from_dict(args.cfg_options)
+
+    init_default_scope(cfg.get('scope', 'mmseg'))
+
+    if len(args.shape) == 1:
+        input_shape = (3, args.shape[0], args.shape[0])
+    elif len(args.shape) == 2:
+        input_shape = (3, ) + tuple(args.shape)
+    else:
+        raise ValueError('invalid input shape')
+    result = {}
+
+    model: BaseSegmentor = MODELS.build(cfg.model)
+    if hasattr(model, 'auxiliary_head'):
+        model.auxiliary_head = None
+    if torch.cuda.is_available():
+        model.cuda()
+    model = revert_sync_batchnorm(model)
+    result['ori_shape'] = input_shape[-2:]
+    result['pad_shape'] = input_shape[-2:]
+    data_batch = {
+        'inputs': [torch.rand(input_shape)],
+        'data_samples': [SegDataSample(metainfo=result)]
+    }
+    data = model.data_preprocessor(data_batch)
+    model.eval()
+    if cfg.model.decode_head.type in ['MaskFormerHead', 'Mask2FormerHead']:
+        # TODO: Support MaskFormer and Mask2Former
+        raise NotImplementedError('MaskFormer and Mask2Former are not '
+                                  'supported yet.')
+    outputs = get_model_complexity_info(
+        model,
+        input_shape=None,
+        inputs=data['inputs'],
+        show_table=False,
+        show_arch=False)
+    result['flops'] = _format_size(outputs['flops'])
+    result['params'] = _format_size(outputs['params'])
+    result['compute_type'] = 'direct: randomly generate a picture'
+    return result
+
+
+def main():
+
+    args = parse_args()
+    logger = MMLogger.get_instance(name='MMLogger')
+
+    result = inference(args, logger)
+    split_line = '=' * 30
+    ori_shape = result['ori_shape']
+    pad_shape = result['pad_shape']
+    flops = result['flops']
+    params = result['params']
+    compute_type = result['compute_type']
+
+    if pad_shape != ori_shape:
+        print(f'{split_line}\nUse size divisor set input shape '
+              f'from {ori_shape} to {pad_shape}')
+    print(f'{split_line}\nCompute type: {compute_type}\n'
+          f'Input shape: {pad_shape}\nFlops: {flops}\n'
+          f'Params: {params}\n{split_line}')
+    print('!!!Please be cautious if you use the results in papers. '
+          'You may need to check if all ops are supported and verify '
+          'that the flops computation is correct.')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/analysis_tools/visualization_cam.py b/mmsegmentation/tools/analysis_tools/visualization_cam.py
new file mode 100644
index 0000000..00cdb3e
--- /dev/null
+++ b/mmsegmentation/tools/analysis_tools/visualization_cam.py
@@ -0,0 +1,127 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+"""Use the pytorch-grad-cam tool to visualize Class Activation Maps (CAM).
+
+requirement: pip install grad-cam
+"""
+
+from argparse import ArgumentParser
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from mmengine import Config
+from mmengine.model import revert_sync_batchnorm
+from PIL import Image
+from pytorch_grad_cam import GradCAM
+from pytorch_grad_cam.utils.image import preprocess_image, show_cam_on_image
+
+from mmseg.apis import inference_model, init_model, show_result_pyplot
+from mmseg.utils import register_all_modules
+
+
+class SemanticSegmentationTarget:
+    """wrap the model.
+
+    requirement: pip install grad-cam
+
+    Args:
+        category (int): Visualization class.
+        mask (ndarray): Mask of class.
+        size (tuple): Image size.
+    """
+
+    def __init__(self, category, mask, size):
+        self.category = category
+        self.mask = torch.from_numpy(mask)
+        self.size = size
+        if torch.cuda.is_available():
+            self.mask = self.mask.cuda()
+
+    def __call__(self, model_output):
+        model_output = torch.unsqueeze(model_output, dim=0)
+        model_output = F.interpolate(
+            model_output, size=self.size, mode='bilinear')
+        model_output = torch.squeeze(model_output, dim=0)
+
+        return (model_output[self.category, :, :] * self.mask).sum()
+
+
+def main():
+    parser = ArgumentParser()
+    parser.add_argument('img', help='Image file')
+    parser.add_argument('config', help='Config file')
+    parser.add_argument('checkpoint', help='Checkpoint file')
+    parser.add_argument(
+        '--out-file',
+        default='prediction.png',
+        help='Path to output prediction file')
+    parser.add_argument(
+        '--cam-file', default='vis_cam.png', help='Path to output cam file')
+    parser.add_argument(
+        '--target-layers',
+        default='backbone.layer4[2]',
+        help='Target layers to visualize CAM')
+    parser.add_argument(
+        '--category-index', default='7', help='Category to visualize CAM')
+    parser.add_argument(
+        '--device', default='cuda:0', help='Device used for inference')
+    args = parser.parse_args()
+
+    # build the model from a config file and a checkpoint file
+    register_all_modules()
+    model = init_model(args.config, args.checkpoint, device=args.device)
+    if args.device == 'cpu':
+        model = revert_sync_batchnorm(model)
+
+    # test a single image
+    result = inference_model(model, args.img)
+
+    # show the results
+    show_result_pyplot(
+        model,
+        args.img,
+        result,
+        draw_gt=False,
+        show=False if args.out_file is not None else True,
+        out_file=args.out_file)
+
+    # result data conversion
+    prediction_data = result.pred_sem_seg.data
+    pre_np_data = prediction_data.cpu().numpy().squeeze(0)
+
+    target_layers = args.target_layers
+    target_layers = [eval(f'model.{target_layers}')]
+
+    category = int(args.category_index)
+    mask_float = np.float32(pre_np_data == category)
+
+    # data processing
+    image = np.array(Image.open(args.img).convert('RGB'))
+    height, width = image.shape[0], image.shape[1]
+    rgb_img = np.float32(image) / 255
+    config = Config.fromfile(args.config)
+    image_mean = config.data_preprocessor['mean']
+    image_std = config.data_preprocessor['std']
+    input_tensor = preprocess_image(
+        rgb_img,
+        mean=[x / 255 for x in image_mean],
+        std=[x / 255 for x in image_std])
+
+    # Grad CAM(Class Activation Maps)
+    # Can also be LayerCAM, XGradCAM, GradCAMPlusPlus, EigenCAM, EigenGradCAM
+    targets = [
+        SemanticSegmentationTarget(category, mask_float, (height, width))
+    ]
+    with GradCAM(
+            model=model,
+            target_layers=target_layers,
+            use_cuda=torch.cuda.is_available()) as cam:
+        grayscale_cam = cam(input_tensor=input_tensor, targets=targets)[0, :]
+        cam_image = show_cam_on_image(rgb_img, grayscale_cam, use_rgb=True)
+
+        # save cam file
+        Image.fromarray(cam_image).save(args.cam_file)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/dataset_converters/chase_db1.py b/mmsegmentation/tools/dataset_converters/chase_db1.py
new file mode 100644
index 0000000..f4fefbd
--- /dev/null
+++ b/mmsegmentation/tools/dataset_converters/chase_db1.py
@@ -0,0 +1,89 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os
+import os.path as osp
+import tempfile
+import zipfile
+
+import mmcv
+from mmengine.utils import mkdir_or_exist
+
+CHASE_DB1_LEN = 28 * 3
+TRAINING_LEN = 60
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Convert CHASE_DB1 dataset to mmsegmentation format')
+    parser.add_argument('dataset_path', help='path of CHASEDB1.zip')
+    parser.add_argument('--tmp_dir', help='path of the temporary directory')
+    parser.add_argument('-o', '--out_dir', help='output path')
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    dataset_path = args.dataset_path
+    if args.out_dir is None:
+        out_dir = osp.join('data', 'CHASE_DB1')
+    else:
+        out_dir = args.out_dir
+
+    print('Making directories...')
+    mkdir_or_exist(out_dir)
+    mkdir_or_exist(osp.join(out_dir, 'images'))
+    mkdir_or_exist(osp.join(out_dir, 'images', 'training'))
+    mkdir_or_exist(osp.join(out_dir, 'images', 'validation'))
+    mkdir_or_exist(osp.join(out_dir, 'annotations'))
+    mkdir_or_exist(osp.join(out_dir, 'annotations', 'training'))
+    mkdir_or_exist(osp.join(out_dir, 'annotations', 'validation'))
+
+    with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
+        print('Extracting CHASEDB1.zip...')
+        zip_file = zipfile.ZipFile(dataset_path)
+        zip_file.extractall(tmp_dir)
+
+        print('Generating training dataset...')
+
+        assert len(os.listdir(tmp_dir)) == CHASE_DB1_LEN, \
+            f'len(os.listdir(tmp_dir)) != {CHASE_DB1_LEN}'
+
+        for img_name in sorted(os.listdir(tmp_dir))[:TRAINING_LEN]:
+            img = mmcv.imread(osp.join(tmp_dir, img_name))
+            if osp.splitext(img_name)[1] == '.jpg':
+                mmcv.imwrite(
+                    img,
+                    osp.join(out_dir, 'images', 'training',
+                             osp.splitext(img_name)[0] + '.png'))
+            else:
+                # The annotation img should be divided by 128, because some of
+                # the annotation imgs are not standard. We should set a
+                # threshold to convert the nonstandard annotation imgs. The
+                # value divided by 128 is equivalent to '1 if value >= 128
+                # else 0'
+                mmcv.imwrite(
+                    img[:, :, 0] // 128,
+                    osp.join(out_dir, 'annotations', 'training',
+                             osp.splitext(img_name)[0] + '.png'))
+
+        for img_name in sorted(os.listdir(tmp_dir))[TRAINING_LEN:]:
+            img = mmcv.imread(osp.join(tmp_dir, img_name))
+            if osp.splitext(img_name)[1] == '.jpg':
+                mmcv.imwrite(
+                    img,
+                    osp.join(out_dir, 'images', 'validation',
+                             osp.splitext(img_name)[0] + '.png'))
+            else:
+                mmcv.imwrite(
+                    img[:, :, 0] // 128,
+                    osp.join(out_dir, 'annotations', 'validation',
+                             osp.splitext(img_name)[0] + '.png'))
+
+        print('Removing the temporary files...')
+
+    print('Done!')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/dataset_converters/cityscapes.py b/mmsegmentation/tools/dataset_converters/cityscapes.py
new file mode 100644
index 0000000..0d6a801
--- /dev/null
+++ b/mmsegmentation/tools/dataset_converters/cityscapes.py
@@ -0,0 +1,56 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os.path as osp
+
+from cityscapesscripts.preparation.json2labelImg import json2labelImg
+from mmengine.utils import (mkdir_or_exist, scandir, track_parallel_progress,
+                            track_progress)
+
+
+def convert_json_to_label(json_file):
+    label_file = json_file.replace('_polygons.json', '_labelTrainIds.png')
+    json2labelImg(json_file, label_file, 'trainIds')
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Convert Cityscapes annotations to TrainIds')
+    parser.add_argument('cityscapes_path', help='cityscapes data path')
+    parser.add_argument('--gt-dir', default='gtFine', type=str)
+    parser.add_argument('-o', '--out-dir', help='output path')
+    parser.add_argument(
+        '--nproc', default=1, type=int, help='number of process')
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    cityscapes_path = args.cityscapes_path
+    out_dir = args.out_dir if args.out_dir else cityscapes_path
+    mkdir_or_exist(out_dir)
+
+    gt_dir = osp.join(cityscapes_path, args.gt_dir)
+
+    poly_files = []
+    for poly in scandir(gt_dir, '_polygons.json', recursive=True):
+        poly_file = osp.join(gt_dir, poly)
+        poly_files.append(poly_file)
+    if args.nproc > 1:
+        track_parallel_progress(convert_json_to_label, poly_files, args.nproc)
+    else:
+        track_progress(convert_json_to_label, poly_files)
+
+    split_names = ['train', 'val', 'test']
+
+    for split in split_names:
+        filenames = []
+        for poly in scandir(
+                osp.join(gt_dir, split), '_polygons.json', recursive=True):
+            filenames.append(poly.replace('_gtFine_polygons.json', ''))
+        with open(osp.join(out_dir, f'{split}.txt'), 'w') as f:
+            f.writelines(f + '\n' for f in filenames)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/dataset_converters/coco_stuff10k.py b/mmsegmentation/tools/dataset_converters/coco_stuff10k.py
new file mode 100644
index 0000000..920127e
--- /dev/null
+++ b/mmsegmentation/tools/dataset_converters/coco_stuff10k.py
@@ -0,0 +1,308 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os.path as osp
+import shutil
+from functools import partial
+
+import numpy as np
+from mmengine.utils import (mkdir_or_exist, track_parallel_progress,
+                            track_progress)
+from PIL import Image
+from scipy.io import loadmat
+
+COCO_LEN = 10000
+
+clsID_to_trID = {
+    0: 0,
+    1: 1,
+    2: 2,
+    3: 3,
+    4: 4,
+    5: 5,
+    6: 6,
+    7: 7,
+    8: 8,
+    9: 9,
+    10: 10,
+    11: 11,
+    13: 12,
+    14: 13,
+    15: 14,
+    16: 15,
+    17: 16,
+    18: 17,
+    19: 18,
+    20: 19,
+    21: 20,
+    22: 21,
+    23: 22,
+    24: 23,
+    25: 24,
+    27: 25,
+    28: 26,
+    31: 27,
+    32: 28,
+    33: 29,
+    34: 30,
+    35: 31,
+    36: 32,
+    37: 33,
+    38: 34,
+    39: 35,
+    40: 36,
+    41: 37,
+    42: 38,
+    43: 39,
+    44: 40,
+    46: 41,
+    47: 42,
+    48: 43,
+    49: 44,
+    50: 45,
+    51: 46,
+    52: 47,
+    53: 48,
+    54: 49,
+    55: 50,
+    56: 51,
+    57: 52,
+    58: 53,
+    59: 54,
+    60: 55,
+    61: 56,
+    62: 57,
+    63: 58,
+    64: 59,
+    65: 60,
+    67: 61,
+    70: 62,
+    72: 63,
+    73: 64,
+    74: 65,
+    75: 66,
+    76: 67,
+    77: 68,
+    78: 69,
+    79: 70,
+    80: 71,
+    81: 72,
+    82: 73,
+    84: 74,
+    85: 75,
+    86: 76,
+    87: 77,
+    88: 78,
+    89: 79,
+    90: 80,
+    92: 81,
+    93: 82,
+    94: 83,
+    95: 84,
+    96: 85,
+    97: 86,
+    98: 87,
+    99: 88,
+    100: 89,
+    101: 90,
+    102: 91,
+    103: 92,
+    104: 93,
+    105: 94,
+    106: 95,
+    107: 96,
+    108: 97,
+    109: 98,
+    110: 99,
+    111: 100,
+    112: 101,
+    113: 102,
+    114: 103,
+    115: 104,
+    116: 105,
+    117: 106,
+    118: 107,
+    119: 108,
+    120: 109,
+    121: 110,
+    122: 111,
+    123: 112,
+    124: 113,
+    125: 114,
+    126: 115,
+    127: 116,
+    128: 117,
+    129: 118,
+    130: 119,
+    131: 120,
+    132: 121,
+    133: 122,
+    134: 123,
+    135: 124,
+    136: 125,
+    137: 126,
+    138: 127,
+    139: 128,
+    140: 129,
+    141: 130,
+    142: 131,
+    143: 132,
+    144: 133,
+    145: 134,
+    146: 135,
+    147: 136,
+    148: 137,
+    149: 138,
+    150: 139,
+    151: 140,
+    152: 141,
+    153: 142,
+    154: 143,
+    155: 144,
+    156: 145,
+    157: 146,
+    158: 147,
+    159: 148,
+    160: 149,
+    161: 150,
+    162: 151,
+    163: 152,
+    164: 153,
+    165: 154,
+    166: 155,
+    167: 156,
+    168: 157,
+    169: 158,
+    170: 159,
+    171: 160,
+    172: 161,
+    173: 162,
+    174: 163,
+    175: 164,
+    176: 165,
+    177: 166,
+    178: 167,
+    179: 168,
+    180: 169,
+    181: 170,
+    182: 171
+}
+
+
+def convert_to_trainID(tuple_path, in_img_dir, in_ann_dir, out_img_dir,
+                       out_mask_dir, is_train):
+    imgpath, maskpath = tuple_path
+    shutil.copyfile(
+        osp.join(in_img_dir, imgpath),
+        osp.join(out_img_dir, 'train2014', imgpath) if is_train else osp.join(
+            out_img_dir, 'test2014', imgpath))
+    annotate = loadmat(osp.join(in_ann_dir, maskpath))
+    mask = annotate['S'].astype(np.uint8)
+    mask_copy = mask.copy()
+    for clsID, trID in clsID_to_trID.items():
+        mask_copy[mask == clsID] = trID
+    seg_filename = osp.join(out_mask_dir, 'train2014',
+                            maskpath.split('.')[0] +
+                            '_labelTrainIds.png') if is_train else osp.join(
+                                out_mask_dir, 'test2014',
+                                maskpath.split('.')[0] + '_labelTrainIds.png')
+    Image.fromarray(mask_copy).save(seg_filename, 'PNG')
+
+
+def generate_coco_list(folder):
+    train_list = osp.join(folder, 'imageLists', 'train.txt')
+    test_list = osp.join(folder, 'imageLists', 'test.txt')
+    train_paths = []
+    test_paths = []
+
+    with open(train_list) as f:
+        for filename in f:
+            basename = filename.strip()
+            imgpath = basename + '.jpg'
+            maskpath = basename + '.mat'
+            train_paths.append((imgpath, maskpath))
+
+    with open(test_list) as f:
+        for filename in f:
+            basename = filename.strip()
+            imgpath = basename + '.jpg'
+            maskpath = basename + '.mat'
+            test_paths.append((imgpath, maskpath))
+
+    return train_paths, test_paths
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description=\
+        'Convert COCO Stuff 10k annotations to mmsegmentation format')  # noqa
+    parser.add_argument('coco_path', help='coco stuff path')
+    parser.add_argument('-o', '--out_dir', help='output path')
+    parser.add_argument(
+        '--nproc', default=16, type=int, help='number of process')
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    coco_path = args.coco_path
+    nproc = args.nproc
+
+    out_dir = args.out_dir or coco_path
+    out_img_dir = osp.join(out_dir, 'images')
+    out_mask_dir = osp.join(out_dir, 'annotations')
+
+    mkdir_or_exist(osp.join(out_img_dir, 'train2014'))
+    mkdir_or_exist(osp.join(out_img_dir, 'test2014'))
+    mkdir_or_exist(osp.join(out_mask_dir, 'train2014'))
+    mkdir_or_exist(osp.join(out_mask_dir, 'test2014'))
+
+    train_list, test_list = generate_coco_list(coco_path)
+    assert (len(train_list) +
+            len(test_list)) == COCO_LEN, 'Wrong length of list {} & {}'.format(
+                len(train_list), len(test_list))
+
+    if args.nproc > 1:
+        track_parallel_progress(
+            partial(
+                convert_to_trainID,
+                in_img_dir=osp.join(coco_path, 'images'),
+                in_ann_dir=osp.join(coco_path, 'annotations'),
+                out_img_dir=out_img_dir,
+                out_mask_dir=out_mask_dir,
+                is_train=True),
+            train_list,
+            nproc=nproc)
+        track_parallel_progress(
+            partial(
+                convert_to_trainID,
+                in_img_dir=osp.join(coco_path, 'images'),
+                in_ann_dir=osp.join(coco_path, 'annotations'),
+                out_img_dir=out_img_dir,
+                out_mask_dir=out_mask_dir,
+                is_train=False),
+            test_list,
+            nproc=nproc)
+    else:
+        track_progress(
+            partial(
+                convert_to_trainID,
+                in_img_dir=osp.join(coco_path, 'images'),
+                in_ann_dir=osp.join(coco_path, 'annotations'),
+                out_img_dir=out_img_dir,
+                out_mask_dir=out_mask_dir,
+                is_train=True), train_list)
+        track_progress(
+            partial(
+                convert_to_trainID,
+                in_img_dir=osp.join(coco_path, 'images'),
+                in_ann_dir=osp.join(coco_path, 'annotations'),
+                out_img_dir=out_img_dir,
+                out_mask_dir=out_mask_dir,
+                is_train=False), test_list)
+
+    print('Done!')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/dataset_converters/coco_stuff164k.py b/mmsegmentation/tools/dataset_converters/coco_stuff164k.py
new file mode 100644
index 0000000..a13114a
--- /dev/null
+++ b/mmsegmentation/tools/dataset_converters/coco_stuff164k.py
@@ -0,0 +1,265 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os.path as osp
+import shutil
+from functools import partial
+from glob import glob
+
+import numpy as np
+from mmengine.utils import (mkdir_or_exist, track_parallel_progress,
+                            track_progress)
+from PIL import Image
+
+COCO_LEN = 123287
+
+clsID_to_trID = {
+    0: 0,
+    1: 1,
+    2: 2,
+    3: 3,
+    4: 4,
+    5: 5,
+    6: 6,
+    7: 7,
+    8: 8,
+    9: 9,
+    10: 10,
+    12: 11,
+    13: 12,
+    14: 13,
+    15: 14,
+    16: 15,
+    17: 16,
+    18: 17,
+    19: 18,
+    20: 19,
+    21: 20,
+    22: 21,
+    23: 22,
+    24: 23,
+    26: 24,
+    27: 25,
+    30: 26,
+    31: 27,
+    32: 28,
+    33: 29,
+    34: 30,
+    35: 31,
+    36: 32,
+    37: 33,
+    38: 34,
+    39: 35,
+    40: 36,
+    41: 37,
+    42: 38,
+    43: 39,
+    45: 40,
+    46: 41,
+    47: 42,
+    48: 43,
+    49: 44,
+    50: 45,
+    51: 46,
+    52: 47,
+    53: 48,
+    54: 49,
+    55: 50,
+    56: 51,
+    57: 52,
+    58: 53,
+    59: 54,
+    60: 55,
+    61: 56,
+    62: 57,
+    63: 58,
+    64: 59,
+    66: 60,
+    69: 61,
+    71: 62,
+    72: 63,
+    73: 64,
+    74: 65,
+    75: 66,
+    76: 67,
+    77: 68,
+    78: 69,
+    79: 70,
+    80: 71,
+    81: 72,
+    83: 73,
+    84: 74,
+    85: 75,
+    86: 76,
+    87: 77,
+    88: 78,
+    89: 79,
+    91: 80,
+    92: 81,
+    93: 82,
+    94: 83,
+    95: 84,
+    96: 85,
+    97: 86,
+    98: 87,
+    99: 88,
+    100: 89,
+    101: 90,
+    102: 91,
+    103: 92,
+    104: 93,
+    105: 94,
+    106: 95,
+    107: 96,
+    108: 97,
+    109: 98,
+    110: 99,
+    111: 100,
+    112: 101,
+    113: 102,
+    114: 103,
+    115: 104,
+    116: 105,
+    117: 106,
+    118: 107,
+    119: 108,
+    120: 109,
+    121: 110,
+    122: 111,
+    123: 112,
+    124: 113,
+    125: 114,
+    126: 115,
+    127: 116,
+    128: 117,
+    129: 118,
+    130: 119,
+    131: 120,
+    132: 121,
+    133: 122,
+    134: 123,
+    135: 124,
+    136: 125,
+    137: 126,
+    138: 127,
+    139: 128,
+    140: 129,
+    141: 130,
+    142: 131,
+    143: 132,
+    144: 133,
+    145: 134,
+    146: 135,
+    147: 136,
+    148: 137,
+    149: 138,
+    150: 139,
+    151: 140,
+    152: 141,
+    153: 142,
+    154: 143,
+    155: 144,
+    156: 145,
+    157: 146,
+    158: 147,
+    159: 148,
+    160: 149,
+    161: 150,
+    162: 151,
+    163: 152,
+    164: 153,
+    165: 154,
+    166: 155,
+    167: 156,
+    168: 157,
+    169: 158,
+    170: 159,
+    171: 160,
+    172: 161,
+    173: 162,
+    174: 163,
+    175: 164,
+    176: 165,
+    177: 166,
+    178: 167,
+    179: 168,
+    180: 169,
+    181: 170,
+    255: 255
+}
+
+
+def convert_to_trainID(maskpath, out_mask_dir, is_train):
+    mask = np.array(Image.open(maskpath))
+    mask_copy = mask.copy()
+    for clsID, trID in clsID_to_trID.items():
+        mask_copy[mask == clsID] = trID
+    seg_filename = osp.join(
+        out_mask_dir, 'train2017',
+        osp.basename(maskpath).split('.')[0] +
+        '_labelTrainIds.png') if is_train else osp.join(
+            out_mask_dir, 'val2017',
+            osp.basename(maskpath).split('.')[0] + '_labelTrainIds.png')
+    Image.fromarray(mask_copy).save(seg_filename, 'PNG')
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description=\
+        'Convert COCO Stuff 164k annotations to mmsegmentation format')  # noqa
+    parser.add_argument('coco_path', help='coco stuff path')
+    parser.add_argument('-o', '--out_dir', help='output path')
+    parser.add_argument(
+        '--nproc', default=16, type=int, help='number of process')
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    coco_path = args.coco_path
+    nproc = args.nproc
+
+    out_dir = args.out_dir or coco_path
+    out_img_dir = osp.join(out_dir, 'images')
+    out_mask_dir = osp.join(out_dir, 'annotations')
+
+    mkdir_or_exist(osp.join(out_mask_dir, 'train2017'))
+    mkdir_or_exist(osp.join(out_mask_dir, 'val2017'))
+
+    if out_dir != coco_path:
+        shutil.copytree(osp.join(coco_path, 'images'), out_img_dir)
+
+    train_list = glob(osp.join(coco_path, 'annotations', 'train2017', '*.png'))
+    train_list = [file for file in train_list if '_labelTrainIds' not in file]
+    test_list = glob(osp.join(coco_path, 'annotations', 'val2017', '*.png'))
+    test_list = [file for file in test_list if '_labelTrainIds' not in file]
+    assert (len(train_list) +
+            len(test_list)) == COCO_LEN, 'Wrong length of list {} & {}'.format(
+                len(train_list), len(test_list))
+
+    if args.nproc > 1:
+        track_parallel_progress(
+            partial(
+                convert_to_trainID, out_mask_dir=out_mask_dir, is_train=True),
+            train_list,
+            nproc=nproc)
+        track_parallel_progress(
+            partial(
+                convert_to_trainID, out_mask_dir=out_mask_dir, is_train=False),
+            test_list,
+            nproc=nproc)
+    else:
+        track_progress(
+            partial(
+                convert_to_trainID, out_mask_dir=out_mask_dir, is_train=True),
+            train_list)
+        track_progress(
+            partial(
+                convert_to_trainID, out_mask_dir=out_mask_dir, is_train=False),
+            test_list)
+
+    print('Done!')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/dataset_converters/drive.py b/mmsegmentation/tools/dataset_converters/drive.py
new file mode 100644
index 0000000..076fd05
--- /dev/null
+++ b/mmsegmentation/tools/dataset_converters/drive.py
@@ -0,0 +1,114 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os
+import os.path as osp
+import tempfile
+import zipfile
+
+import cv2
+import mmcv
+from mmengine.utils import mkdir_or_exist
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Convert DRIVE dataset to mmsegmentation format')
+    parser.add_argument(
+        'training_path', help='the training part of DRIVE dataset')
+    parser.add_argument(
+        'testing_path', help='the testing part of DRIVE dataset')
+    parser.add_argument('--tmp_dir', help='path of the temporary directory')
+    parser.add_argument('-o', '--out_dir', help='output path')
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    training_path = args.training_path
+    testing_path = args.testing_path
+    if args.out_dir is None:
+        out_dir = osp.join('data', 'DRIVE')
+    else:
+        out_dir = args.out_dir
+
+    print('Making directories...')
+    mkdir_or_exist(out_dir)
+    mkdir_or_exist(osp.join(out_dir, 'images'))
+    mkdir_or_exist(osp.join(out_dir, 'images', 'training'))
+    mkdir_or_exist(osp.join(out_dir, 'images', 'validation'))
+    mkdir_or_exist(osp.join(out_dir, 'annotations'))
+    mkdir_or_exist(osp.join(out_dir, 'annotations', 'training'))
+    mkdir_or_exist(osp.join(out_dir, 'annotations', 'validation'))
+
+    with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
+        print('Extracting training.zip...')
+        zip_file = zipfile.ZipFile(training_path)
+        zip_file.extractall(tmp_dir)
+
+        print('Generating training dataset...')
+        now_dir = osp.join(tmp_dir, 'training', 'images')
+        for img_name in os.listdir(now_dir):
+            img = mmcv.imread(osp.join(now_dir, img_name))
+            mmcv.imwrite(
+                img,
+                osp.join(
+                    out_dir, 'images', 'training',
+                    osp.splitext(img_name)[0].replace('_training', '') +
+                    '.png'))
+
+        now_dir = osp.join(tmp_dir, 'training', '1st_manual')
+        for img_name in os.listdir(now_dir):
+            cap = cv2.VideoCapture(osp.join(now_dir, img_name))
+            ret, img = cap.read()
+            mmcv.imwrite(
+                img[:, :, 0] // 128,
+                osp.join(out_dir, 'annotations', 'training',
+                         osp.splitext(img_name)[0] + '.png'))
+
+        print('Extracting test.zip...')
+        zip_file = zipfile.ZipFile(testing_path)
+        zip_file.extractall(tmp_dir)
+
+        print('Generating validation dataset...')
+        now_dir = osp.join(tmp_dir, 'test', 'images')
+        for img_name in os.listdir(now_dir):
+            img = mmcv.imread(osp.join(now_dir, img_name))
+            mmcv.imwrite(
+                img,
+                osp.join(
+                    out_dir, 'images', 'validation',
+                    osp.splitext(img_name)[0].replace('_test', '') + '.png'))
+
+        now_dir = osp.join(tmp_dir, 'test', '1st_manual')
+        if osp.exists(now_dir):
+            for img_name in os.listdir(now_dir):
+                cap = cv2.VideoCapture(osp.join(now_dir, img_name))
+                ret, img = cap.read()
+                # The annotation img should be divided by 128, because some of
+                # the annotation imgs are not standard. We should set a
+                # threshold to convert the nonstandard annotation imgs. The
+                # value divided by 128 is equivalent to '1 if value >= 128
+                # else 0'
+                mmcv.imwrite(
+                    img[:, :, 0] // 128,
+                    osp.join(out_dir, 'annotations', 'validation',
+                             osp.splitext(img_name)[0] + '.png'))
+
+        now_dir = osp.join(tmp_dir, 'test', '2nd_manual')
+        if osp.exists(now_dir):
+            for img_name in os.listdir(now_dir):
+                cap = cv2.VideoCapture(osp.join(now_dir, img_name))
+                ret, img = cap.read()
+                mmcv.imwrite(
+                    img[:, :, 0] // 128,
+                    osp.join(out_dir, 'annotations', 'validation',
+                             osp.splitext(img_name)[0] + '.png'))
+
+        print('Removing the temporary files...')
+
+    print('Done!')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/dataset_converters/hrf.py b/mmsegmentation/tools/dataset_converters/hrf.py
new file mode 100644
index 0000000..3bfd80c
--- /dev/null
+++ b/mmsegmentation/tools/dataset_converters/hrf.py
@@ -0,0 +1,112 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os
+import os.path as osp
+import tempfile
+import zipfile
+
+import mmcv
+from mmengine.utils import mkdir_or_exist
+
+HRF_LEN = 15
+TRAINING_LEN = 5
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Convert HRF dataset to mmsegmentation format')
+    parser.add_argument('healthy_path', help='the path of healthy.zip')
+    parser.add_argument(
+        'healthy_manualsegm_path', help='the path of healthy_manualsegm.zip')
+    parser.add_argument('glaucoma_path', help='the path of glaucoma.zip')
+    parser.add_argument(
+        'glaucoma_manualsegm_path', help='the path of glaucoma_manualsegm.zip')
+    parser.add_argument(
+        'diabetic_retinopathy_path',
+        help='the path of diabetic_retinopathy.zip')
+    parser.add_argument(
+        'diabetic_retinopathy_manualsegm_path',
+        help='the path of diabetic_retinopathy_manualsegm.zip')
+    parser.add_argument('--tmp_dir', help='path of the temporary directory')
+    parser.add_argument('-o', '--out_dir', help='output path')
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    images_path = [
+        args.healthy_path, args.glaucoma_path, args.diabetic_retinopathy_path
+    ]
+    annotations_path = [
+        args.healthy_manualsegm_path, args.glaucoma_manualsegm_path,
+        args.diabetic_retinopathy_manualsegm_path
+    ]
+    if args.out_dir is None:
+        out_dir = osp.join('data', 'HRF')
+    else:
+        out_dir = args.out_dir
+
+    print('Making directories...')
+    mkdir_or_exist(out_dir)
+    mkdir_or_exist(osp.join(out_dir, 'images'))
+    mkdir_or_exist(osp.join(out_dir, 'images', 'training'))
+    mkdir_or_exist(osp.join(out_dir, 'images', 'validation'))
+    mkdir_or_exist(osp.join(out_dir, 'annotations'))
+    mkdir_or_exist(osp.join(out_dir, 'annotations', 'training'))
+    mkdir_or_exist(osp.join(out_dir, 'annotations', 'validation'))
+
+    print('Generating images...')
+    for now_path in images_path:
+        with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
+            zip_file = zipfile.ZipFile(now_path)
+            zip_file.extractall(tmp_dir)
+
+            assert len(os.listdir(tmp_dir)) == HRF_LEN, \
+                f'len(os.listdir(tmp_dir)) != {HRF_LEN}'
+
+            for filename in sorted(os.listdir(tmp_dir))[:TRAINING_LEN]:
+                img = mmcv.imread(osp.join(tmp_dir, filename))
+                mmcv.imwrite(
+                    img,
+                    osp.join(out_dir, 'images', 'training',
+                             osp.splitext(filename)[0] + '.png'))
+            for filename in sorted(os.listdir(tmp_dir))[TRAINING_LEN:]:
+                img = mmcv.imread(osp.join(tmp_dir, filename))
+                mmcv.imwrite(
+                    img,
+                    osp.join(out_dir, 'images', 'validation',
+                             osp.splitext(filename)[0] + '.png'))
+
+    print('Generating annotations...')
+    for now_path in annotations_path:
+        with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
+            zip_file = zipfile.ZipFile(now_path)
+            zip_file.extractall(tmp_dir)
+
+            assert len(os.listdir(tmp_dir)) == HRF_LEN, \
+                f'len(os.listdir(tmp_dir)) != {HRF_LEN}'
+
+            for filename in sorted(os.listdir(tmp_dir))[:TRAINING_LEN]:
+                img = mmcv.imread(osp.join(tmp_dir, filename))
+                # The annotation img should be divided by 128, because some of
+                # the annotation imgs are not standard. We should set a
+                # threshold to convert the nonstandard annotation imgs. The
+                # value divided by 128 is equivalent to '1 if value >= 128
+                # else 0'
+                mmcv.imwrite(
+                    img[:, :, 0] // 128,
+                    osp.join(out_dir, 'annotations', 'training',
+                             osp.splitext(filename)[0] + '.png'))
+            for filename in sorted(os.listdir(tmp_dir))[TRAINING_LEN:]:
+                img = mmcv.imread(osp.join(tmp_dir, filename))
+                mmcv.imwrite(
+                    img[:, :, 0] // 128,
+                    osp.join(out_dir, 'annotations', 'validation',
+                             osp.splitext(filename)[0] + '.png'))
+
+    print('Done!')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/dataset_converters/isaid.py b/mmsegmentation/tools/dataset_converters/isaid.py
new file mode 100644
index 0000000..1d5ccd9
--- /dev/null
+++ b/mmsegmentation/tools/dataset_converters/isaid.py
@@ -0,0 +1,246 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import glob
+import os
+import os.path as osp
+import shutil
+import tempfile
+import zipfile
+
+import mmcv
+import numpy as np
+from mmengine.utils import ProgressBar, mkdir_or_exist
+from PIL import Image
+
+iSAID_palette = \
+    {
+        0: (0, 0, 0),
+        1: (0, 0, 63),
+        2: (0, 63, 63),
+        3: (0, 63, 0),
+        4: (0, 63, 127),
+        5: (0, 63, 191),
+        6: (0, 63, 255),
+        7: (0, 127, 63),
+        8: (0, 127, 127),
+        9: (0, 0, 127),
+        10: (0, 0, 191),
+        11: (0, 0, 255),
+        12: (0, 191, 127),
+        13: (0, 127, 191),
+        14: (0, 127, 255),
+        15: (0, 100, 155)
+    }
+
+iSAID_invert_palette = {v: k for k, v in iSAID_palette.items()}
+
+
+def iSAID_convert_from_color(arr_3d, palette=iSAID_invert_palette):
+    """RGB-color encoding to grayscale labels."""
+    arr_2d = np.zeros((arr_3d.shape[0], arr_3d.shape[1]), dtype=np.uint8)
+
+    for c, i in palette.items():
+        m = np.all(arr_3d == np.array(c).reshape(1, 1, 3), axis=2)
+        arr_2d[m] = i
+
+    return arr_2d
+
+
+def slide_crop_image(src_path, out_dir, mode, patch_H, patch_W, overlap):
+    img = np.asarray(Image.open(src_path).convert('RGB'))
+
+    img_H, img_W, _ = img.shape
+
+    if img_H < patch_H and img_W > patch_W:
+
+        img = mmcv.impad(img, shape=(patch_H, img_W), pad_val=0)
+
+        img_H, img_W, _ = img.shape
+
+    elif img_H > patch_H and img_W < patch_W:
+
+        img = mmcv.impad(img, shape=(img_H, patch_W), pad_val=0)
+
+        img_H, img_W, _ = img.shape
+
+    elif img_H < patch_H and img_W < patch_W:
+
+        img = mmcv.impad(img, shape=(patch_H, patch_W), pad_val=0)
+
+        img_H, img_W, _ = img.shape
+
+    for x in range(0, img_W, patch_W - overlap):
+        for y in range(0, img_H, patch_H - overlap):
+            x_str = x
+            x_end = x + patch_W
+            if x_end > img_W:
+                diff_x = x_end - img_W
+                x_str -= diff_x
+                x_end = img_W
+            y_str = y
+            y_end = y + patch_H
+            if y_end > img_H:
+                diff_y = y_end - img_H
+                y_str -= diff_y
+                y_end = img_H
+
+            img_patch = img[y_str:y_end, x_str:x_end, :]
+            img_patch = Image.fromarray(img_patch.astype(np.uint8))
+            image = osp.basename(src_path).split('.')[0] + '_' + str(
+                y_str) + '_' + str(y_end) + '_' + str(x_str) + '_' + str(
+                    x_end) + '.png'
+            # print(image)
+            save_path_image = osp.join(out_dir, 'img_dir', mode, str(image))
+            img_patch.save(save_path_image, format='BMP')
+
+
+def slide_crop_label(src_path, out_dir, mode, patch_H, patch_W, overlap):
+    label = mmcv.imread(src_path, channel_order='rgb')
+    label = iSAID_convert_from_color(label)
+    img_H, img_W = label.shape
+
+    if img_H < patch_H and img_W > patch_W:
+
+        label = mmcv.impad(label, shape=(patch_H, img_W), pad_val=255)
+
+        img_H = patch_H
+
+    elif img_H > patch_H and img_W < patch_W:
+
+        label = mmcv.impad(label, shape=(img_H, patch_W), pad_val=255)
+
+        img_W = patch_W
+
+    elif img_H < patch_H and img_W < patch_W:
+
+        label = mmcv.impad(label, shape=(patch_H, patch_W), pad_val=255)
+
+        img_H = patch_H
+        img_W = patch_W
+
+    for x in range(0, img_W, patch_W - overlap):
+        for y in range(0, img_H, patch_H - overlap):
+            x_str = x
+            x_end = x + patch_W
+            if x_end > img_W:
+                diff_x = x_end - img_W
+                x_str -= diff_x
+                x_end = img_W
+            y_str = y
+            y_end = y + patch_H
+            if y_end > img_H:
+                diff_y = y_end - img_H
+                y_str -= diff_y
+                y_end = img_H
+
+            lab_patch = label[y_str:y_end, x_str:x_end]
+            lab_patch = Image.fromarray(lab_patch.astype(np.uint8), mode='P')
+
+            image = osp.basename(src_path).split('.')[0].split(
+                '_')[0] + '_' + str(y_str) + '_' + str(y_end) + '_' + str(
+                    x_str) + '_' + str(x_end) + '_instance_color_RGB' + '.png'
+            lab_patch.save(osp.join(out_dir, 'ann_dir', mode, str(image)))
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Convert iSAID dataset to mmsegmentation format')
+    parser.add_argument('dataset_path', help='iSAID folder path')
+    parser.add_argument('--tmp_dir', help='path of the temporary directory')
+    parser.add_argument('-o', '--out_dir', help='output path')
+
+    parser.add_argument(
+        '--patch_width',
+        default=896,
+        type=int,
+        help='Width of the cropped image patch')
+    parser.add_argument(
+        '--patch_height',
+        default=896,
+        type=int,
+        help='Height of the cropped image patch')
+    parser.add_argument(
+        '--overlap_area', default=384, type=int, help='Overlap area')
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    dataset_path = args.dataset_path
+    # image patch width and height
+    patch_H, patch_W = args.patch_width, args.patch_height
+
+    overlap = args.overlap_area  # overlap area
+
+    if args.out_dir is None:
+        out_dir = osp.join('data', 'iSAID')
+    else:
+        out_dir = args.out_dir
+
+    print('Making directories...')
+    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'train'))
+    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'val'))
+    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'test'))
+
+    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'train'))
+    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'val'))
+    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'test'))
+
+    assert os.path.exists(os.path.join(dataset_path, 'train')), \
+        f'train is not in {dataset_path}'
+    assert os.path.exists(os.path.join(dataset_path, 'val')), \
+        f'val is not in {dataset_path}'
+    assert os.path.exists(os.path.join(dataset_path, 'test')), \
+        f'test is not in {dataset_path}'
+
+    with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
+        for dataset_mode in ['train', 'val', 'test']:
+
+            # for dataset_mode in [ 'test']:
+            print(f'Extracting  {dataset_mode}ing.zip...')
+            img_zipp_list = glob.glob(
+                os.path.join(dataset_path, dataset_mode, 'images', '*.zip'))
+            print('Find the data', img_zipp_list)
+            for img_zipp in img_zipp_list:
+                zip_file = zipfile.ZipFile(img_zipp)
+                zip_file.extractall(os.path.join(tmp_dir, dataset_mode, 'img'))
+            src_path_list = glob.glob(
+                os.path.join(tmp_dir, dataset_mode, 'img', 'images', '*.png'))
+
+            src_prog_bar = ProgressBar(len(src_path_list))
+            for i, img_path in enumerate(src_path_list):
+                if dataset_mode != 'test':
+                    slide_crop_image(img_path, out_dir, dataset_mode, patch_H,
+                                     patch_W, overlap)
+
+                else:
+                    shutil.move(img_path,
+                                os.path.join(out_dir, 'img_dir', dataset_mode))
+                src_prog_bar.update()
+
+            if dataset_mode != 'test':
+                label_zipp_list = glob.glob(
+                    os.path.join(dataset_path, dataset_mode, 'Semantic_masks',
+                                 '*.zip'))
+                for label_zipp in label_zipp_list:
+                    zip_file = zipfile.ZipFile(label_zipp)
+                    zip_file.extractall(
+                        os.path.join(tmp_dir, dataset_mode, 'lab'))
+
+                lab_path_list = glob.glob(
+                    os.path.join(tmp_dir, dataset_mode, 'lab', 'images',
+                                 '*.png'))
+                lab_prog_bar = ProgressBar(len(lab_path_list))
+                for i, lab_path in enumerate(lab_path_list):
+                    slide_crop_label(lab_path, out_dir, dataset_mode, patch_H,
+                                     patch_W, overlap)
+                    lab_prog_bar.update()
+
+        print('Removing the temporary files...')
+
+    print('Done!')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/dataset_converters/levircd.py b/mmsegmentation/tools/dataset_converters/levircd.py
new file mode 100644
index 0000000..8717f3e
--- /dev/null
+++ b/mmsegmentation/tools/dataset_converters/levircd.py
@@ -0,0 +1,99 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import glob
+import math
+import os
+import os.path as osp
+
+import mmcv
+import numpy as np
+from mmengine.utils import ProgressBar
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Convert levir-cd dataset to mmsegmentation format')
+    parser.add_argument('--dataset_path', help='potsdam folder path')
+    parser.add_argument('-o', '--out_dir', help='output path')
+    parser.add_argument(
+        '--clip_size',
+        type=int,
+        help='clipped size of image after preparation',
+        default=256)
+    parser.add_argument(
+        '--stride_size',
+        type=int,
+        help='stride of clipping original images',
+        default=256)
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    input_folder = args.dataset_path
+    png_files = glob.glob(
+        os.path.join(input_folder, '**/*.png'), recursive=True)
+    output_folder = args.out_dir
+    prog_bar = ProgressBar(len(png_files))
+    for png_file in png_files:
+        new_path = os.path.join(
+            output_folder,
+            os.path.relpath(os.path.dirname(png_file), input_folder))
+        os.makedirs(os.path.dirname(new_path), exist_ok=True)
+        label = False
+        if 'label' in png_file:
+            label = True
+        clip_big_image(png_file, new_path, args, label)
+        prog_bar.update()
+
+
+def clip_big_image(image_path, clip_save_dir, args, to_label=False):
+    image = mmcv.imread(image_path)
+
+    h, w, c = image.shape
+    clip_size = args.clip_size
+    stride_size = args.stride_size
+
+    num_rows = math.ceil((h - clip_size) / stride_size) if math.ceil(
+        (h - clip_size) /
+        stride_size) * stride_size + clip_size >= h else math.ceil(
+            (h - clip_size) / stride_size) + 1
+    num_cols = math.ceil((w - clip_size) / stride_size) if math.ceil(
+        (w - clip_size) /
+        stride_size) * stride_size + clip_size >= w else math.ceil(
+            (w - clip_size) / stride_size) + 1
+
+    x, y = np.meshgrid(np.arange(num_cols + 1), np.arange(num_rows + 1))
+    xmin = x * clip_size
+    ymin = y * clip_size
+
+    xmin = xmin.ravel()
+    ymin = ymin.ravel()
+    xmin_offset = np.where(xmin + clip_size > w, w - xmin - clip_size,
+                           np.zeros_like(xmin))
+    ymin_offset = np.where(ymin + clip_size > h, h - ymin - clip_size,
+                           np.zeros_like(ymin))
+    boxes = np.stack([
+        xmin + xmin_offset, ymin + ymin_offset,
+        np.minimum(xmin + clip_size, w),
+        np.minimum(ymin + clip_size, h)
+    ],
+                     axis=1)
+
+    if to_label:
+        image[image == 255] = 1
+        image = image[:, :, 0]
+    for box in boxes:
+        start_x, start_y, end_x, end_y = box
+        clipped_image = image[start_y:end_y, start_x:end_x] \
+            if to_label else image[start_y:end_y, start_x:end_x, :]
+        idx = osp.basename(image_path).split('.')[0]
+        mmcv.imwrite(
+            clipped_image.astype(np.uint8),
+            osp.join(clip_save_dir,
+                     f'{idx}_{start_x}_{start_y}_{end_x}_{end_y}.png'))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/dataset_converters/loveda.py b/mmsegmentation/tools/dataset_converters/loveda.py
new file mode 100644
index 0000000..5b0ef4b
--- /dev/null
+++ b/mmsegmentation/tools/dataset_converters/loveda.py
@@ -0,0 +1,73 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os
+import os.path as osp
+import shutil
+import tempfile
+import zipfile
+
+from mmengine.utils import mkdir_or_exist
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Convert LoveDA dataset to mmsegmentation format')
+    parser.add_argument('dataset_path', help='LoveDA folder path')
+    parser.add_argument('--tmp_dir', help='path of the temporary directory')
+    parser.add_argument('-o', '--out_dir', help='output path')
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    dataset_path = args.dataset_path
+    if args.out_dir is None:
+        out_dir = osp.join('data', 'loveDA')
+    else:
+        out_dir = args.out_dir
+
+    print('Making directories...')
+    mkdir_or_exist(out_dir)
+    mkdir_or_exist(osp.join(out_dir, 'img_dir'))
+    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'train'))
+    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'val'))
+    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'test'))
+    mkdir_or_exist(osp.join(out_dir, 'ann_dir'))
+    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'train'))
+    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'val'))
+
+    assert 'Train.zip' in os.listdir(dataset_path), \
+        f'Train.zip is not in {dataset_path}'
+    assert 'Val.zip' in os.listdir(dataset_path), \
+        f'Val.zip is not in {dataset_path}'
+    assert 'Test.zip' in os.listdir(dataset_path), \
+        f'Test.zip is not in {dataset_path}'
+
+    with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
+        for dataset in ['Train', 'Val', 'Test']:
+            zip_file = zipfile.ZipFile(
+                os.path.join(dataset_path, dataset + '.zip'))
+            zip_file.extractall(tmp_dir)
+            data_type = dataset.lower()
+            for location in ['Rural', 'Urban']:
+                for image_type in ['images_png', 'masks_png']:
+                    if image_type == 'images_png':
+                        dst = osp.join(out_dir, 'img_dir', data_type)
+                    else:
+                        dst = osp.join(out_dir, 'ann_dir', data_type)
+                    if dataset == 'Test' and image_type == 'masks_png':
+                        continue
+                    else:
+                        src_dir = osp.join(tmp_dir, dataset, location,
+                                           image_type)
+                        src_lst = os.listdir(src_dir)
+                        for file in src_lst:
+                            shutil.move(osp.join(src_dir, file), dst)
+        print('Removing the temporary files...')
+
+    print('Done!')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/dataset_converters/nyu.py b/mmsegmentation/tools/dataset_converters/nyu.py
new file mode 100644
index 0000000..49e09e7
--- /dev/null
+++ b/mmsegmentation/tools/dataset_converters/nyu.py
@@ -0,0 +1,89 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os.path as osp
+import shutil
+import tempfile
+import zipfile
+
+from mmengine.utils import mkdir_or_exist
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Convert NYU Depth dataset to mmsegmentation format')
+    parser.add_argument('raw_data', help='the path of raw data')
+    parser.add_argument(
+        '-o', '--out_dir', help='output path', default='./data/nyu')
+    args = parser.parse_args()
+    return args
+
+
+def reorganize(raw_data_dir: str, out_dir: str):
+    """Reorganize NYU Depth dataset files into the required directory
+    structure.
+
+    Args:
+        raw_data_dir (str): Path to the raw data directory.
+        out_dir (str): Output directory for the organized dataset.
+    """
+
+    def move_data(data_list, dst_prefix, fname_func):
+        """Move data files from source to destination directory.
+
+        Args:
+            data_list (list): List of data file paths.
+            dst_prefix (str): Prefix to be added to destination paths.
+            fname_func (callable): Function to process file names
+        """
+        for data_item in data_list:
+            data_item = data_item.strip().strip('/')
+            new_item = fname_func(data_item)
+            shutil.move(
+                osp.join(raw_data_dir, data_item),
+                osp.join(out_dir, dst_prefix, new_item))
+
+    def process_phase(phase):
+        """Process a dataset phase (e.g., 'train' or 'test')."""
+        with open(osp.join(raw_data_dir, f'nyu_{phase}.txt')) as f:
+            data = filter(lambda x: len(x.strip()) > 0, f.readlines())
+            data = map(lambda x: x.split()[:2], data)
+            images, annos = zip(*data)
+
+            move_data(images, f'images/{phase}',
+                      lambda x: x.replace('/rgb', ''))
+            move_data(annos, f'annotations/{phase}',
+                      lambda x: x.replace('/sync_depth', ''))
+
+    process_phase('train')
+    process_phase('test')
+
+
+def main():
+    args = parse_args()
+
+    print('Making directories...')
+    mkdir_or_exist(args.out_dir)
+    for subdir in [
+            'images/train', 'images/test', 'annotations/train',
+            'annotations/test'
+    ]:
+        mkdir_or_exist(osp.join(args.out_dir, subdir))
+
+    print('Generating images and annotations...')
+
+    if args.raw_data.endswith('.zip'):
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            zip_file = zipfile.ZipFile(args.raw_data)
+            zip_file.extractall(tmp_dir)
+            reorganize(osp.join(tmp_dir, 'nyu'), args.out_dir)
+    else:
+        assert osp.isdir(
+            args.raw_data
+        ), 'the argument --raw-data should be either a zip file or directory.'
+        reorganize(args.raw_data, args.out_dir)
+
+    print('Done!')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/dataset_converters/pascal_context.py b/mmsegmentation/tools/dataset_converters/pascal_context.py
new file mode 100644
index 0000000..a92d1dc
--- /dev/null
+++ b/mmsegmentation/tools/dataset_converters/pascal_context.py
@@ -0,0 +1,87 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os.path as osp
+from functools import partial
+
+import numpy as np
+from detail import Detail
+from mmengine.utils import mkdir_or_exist, track_progress
+from PIL import Image
+
+_mapping = np.sort(
+    np.array([
+        0, 2, 259, 260, 415, 324, 9, 258, 144, 18, 19, 22, 23, 397, 25, 284,
+        158, 159, 416, 33, 162, 420, 454, 295, 296, 427, 44, 45, 46, 308, 59,
+        440, 445, 31, 232, 65, 354, 424, 68, 326, 72, 458, 34, 207, 80, 355,
+        85, 347, 220, 349, 360, 98, 187, 104, 105, 366, 189, 368, 113, 115
+    ]))
+_key = np.array(range(len(_mapping))).astype('uint8')
+
+
+def generate_labels(img_id, detail, out_dir):
+
+    def _class_to_index(mask, _mapping, _key):
+        # assert the values
+        values = np.unique(mask)
+        for i in range(len(values)):
+            assert (values[i] in _mapping)
+        index = np.digitize(mask.ravel(), _mapping, right=True)
+        return _key[index].reshape(mask.shape)
+
+    mask = Image.fromarray(
+        _class_to_index(detail.getMask(img_id), _mapping=_mapping, _key=_key))
+    filename = img_id['file_name']
+    mask.save(osp.join(out_dir, filename.replace('jpg', 'png')))
+    return osp.splitext(osp.basename(filename))[0]
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Convert PASCAL VOC annotations to mmsegmentation format')
+    parser.add_argument('devkit_path', help='pascal voc devkit path')
+    parser.add_argument('json_path', help='annoation json filepath')
+    parser.add_argument('-o', '--out_dir', help='output path')
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    devkit_path = args.devkit_path
+    if args.out_dir is None:
+        out_dir = osp.join(devkit_path, 'VOC2010', 'SegmentationClassContext')
+    else:
+        out_dir = args.out_dir
+    json_path = args.json_path
+    mkdir_or_exist(out_dir)
+    img_dir = osp.join(devkit_path, 'VOC2010', 'JPEGImages')
+
+    train_detail = Detail(json_path, img_dir, 'train')
+    train_ids = train_detail.getImgs()
+
+    val_detail = Detail(json_path, img_dir, 'val')
+    val_ids = val_detail.getImgs()
+
+    mkdir_or_exist(
+        osp.join(devkit_path, 'VOC2010/ImageSets/SegmentationContext'))
+
+    train_list = track_progress(
+        partial(generate_labels, detail=train_detail, out_dir=out_dir),
+        train_ids)
+    with open(
+            osp.join(devkit_path, 'VOC2010/ImageSets/SegmentationContext',
+                     'train.txt'), 'w') as f:
+        f.writelines(line + '\n' for line in sorted(train_list))
+
+    val_list = track_progress(
+        partial(generate_labels, detail=val_detail, out_dir=out_dir), val_ids)
+    with open(
+            osp.join(devkit_path, 'VOC2010/ImageSets/SegmentationContext',
+                     'val.txt'), 'w') as f:
+        f.writelines(line + '\n' for line in sorted(val_list))
+
+    print('Done!')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/dataset_converters/potsdam.py b/mmsegmentation/tools/dataset_converters/potsdam.py
new file mode 100644
index 0000000..f3c713e
--- /dev/null
+++ b/mmsegmentation/tools/dataset_converters/potsdam.py
@@ -0,0 +1,158 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import glob
+import math
+import os
+import os.path as osp
+import tempfile
+import zipfile
+
+import mmcv
+import numpy as np
+from mmengine.utils import ProgressBar, mkdir_or_exist
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Convert potsdam dataset to mmsegmentation format')
+    parser.add_argument('dataset_path', help='potsdam folder path')
+    parser.add_argument('--tmp_dir', help='path of the temporary directory')
+    parser.add_argument('-o', '--out_dir', help='output path')
+    parser.add_argument(
+        '--clip_size',
+        type=int,
+        help='clipped size of image after preparation',
+        default=512)
+    parser.add_argument(
+        '--stride_size',
+        type=int,
+        help='stride of clipping original images',
+        default=256)
+    args = parser.parse_args()
+    return args
+
+
+def clip_big_image(image_path, clip_save_dir, args, to_label=False):
+    # Original image of Potsdam dataset is very large, thus pre-processing
+    # of them is adopted. Given fixed clip size and stride size to generate
+    # clipped image, the intersection　of width and height is determined.
+    # For example, given one 5120 x 5120 original image, the clip size is
+    # 512 and stride size is 256, thus it would generate 20x20 = 400 images
+    # whose size are all 512x512.
+    image = mmcv.imread(image_path)
+
+    h, w, c = image.shape
+    clip_size = args.clip_size
+    stride_size = args.stride_size
+
+    num_rows = math.ceil((h - clip_size) / stride_size) if math.ceil(
+        (h - clip_size) /
+        stride_size) * stride_size + clip_size >= h else math.ceil(
+            (h - clip_size) / stride_size) + 1
+    num_cols = math.ceil((w - clip_size) / stride_size) if math.ceil(
+        (w - clip_size) /
+        stride_size) * stride_size + clip_size >= w else math.ceil(
+            (w - clip_size) / stride_size) + 1
+
+    x, y = np.meshgrid(np.arange(num_cols + 1), np.arange(num_rows + 1))
+    xmin = x * clip_size
+    ymin = y * clip_size
+
+    xmin = xmin.ravel()
+    ymin = ymin.ravel()
+    xmin_offset = np.where(xmin + clip_size > w, w - xmin - clip_size,
+                           np.zeros_like(xmin))
+    ymin_offset = np.where(ymin + clip_size > h, h - ymin - clip_size,
+                           np.zeros_like(ymin))
+    boxes = np.stack([
+        xmin + xmin_offset, ymin + ymin_offset,
+        np.minimum(xmin + clip_size, w),
+        np.minimum(ymin + clip_size, h)
+    ],
+                     axis=1)
+
+    if to_label:
+        color_map = np.array([[0, 0, 0], [255, 255, 255], [255, 0, 0],
+                              [255, 255, 0], [0, 255, 0], [0, 255, 255],
+                              [0, 0, 255]])
+        flatten_v = np.matmul(
+            image.reshape(-1, c),
+            np.array([2, 3, 4]).reshape(3, 1))
+        out = np.zeros_like(flatten_v)
+        for idx, class_color in enumerate(color_map):
+            value_idx = np.matmul(class_color,
+                                  np.array([2, 3, 4]).reshape(3, 1))
+            out[flatten_v == value_idx] = idx
+        image = out.reshape(h, w)
+
+    for box in boxes:
+        start_x, start_y, end_x, end_y = box
+        clipped_image = image[start_y:end_y,
+                              start_x:end_x] if to_label else image[
+                                  start_y:end_y, start_x:end_x, :]
+        idx_i, idx_j = osp.basename(image_path).split('_')[2:4]
+        mmcv.imwrite(
+            clipped_image.astype(np.uint8),
+            osp.join(
+                clip_save_dir,
+                f'{idx_i}_{idx_j}_{start_x}_{start_y}_{end_x}_{end_y}.png'))
+
+
+def main():
+    args = parse_args()
+    splits = {
+        'train': [
+            '2_10', '2_11', '2_12', '3_10', '3_11', '3_12', '4_10', '4_11',
+            '4_12', '5_10', '5_11', '5_12', '6_10', '6_11', '6_12', '6_7',
+            '6_8', '6_9', '7_10', '7_11', '7_12', '7_7', '7_8', '7_9'
+        ],
+        'val': [
+            '5_15', '6_15', '6_13', '3_13', '4_14', '6_14', '5_14', '2_13',
+            '4_15', '2_14', '5_13', '4_13', '3_14', '7_13'
+        ]
+    }
+
+    dataset_path = args.dataset_path
+    if args.out_dir is None:
+        out_dir = osp.join('data', 'potsdam')
+    else:
+        out_dir = args.out_dir
+
+    print('Making directories...')
+    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'train'))
+    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'val'))
+    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'train'))
+    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'val'))
+
+    zipp_list = glob.glob(os.path.join(dataset_path, '*.zip'))
+    print('Find the data', zipp_list)
+
+    for zipp in zipp_list:
+        with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
+            zip_file = zipfile.ZipFile(zipp)
+            zip_file.extractall(tmp_dir)
+            src_path_list = glob.glob(os.path.join(tmp_dir, '*.tif'))
+            if not len(src_path_list):
+                sub_tmp_dir = os.path.join(tmp_dir, os.listdir(tmp_dir)[0])
+                src_path_list = glob.glob(os.path.join(sub_tmp_dir, '*.tif'))
+
+            prog_bar = ProgressBar(len(src_path_list))
+            for i, src_path in enumerate(src_path_list):
+                idx_i, idx_j = osp.basename(src_path).split('_')[2:4]
+                data_type = 'train' if f'{idx_i}_{idx_j}' in splits[
+                    'train'] else 'val'
+                if 'label' in src_path:
+                    dst_dir = osp.join(out_dir, 'ann_dir', data_type)
+                    clip_big_image(src_path, dst_dir, args, to_label=True)
+                else:
+                    dst_dir = osp.join(out_dir, 'img_dir', data_type)
+                    clip_big_image(src_path, dst_dir, args, to_label=False)
+                prog_bar.update()
+
+    print('Removing the temporary files...')
+
+    print('Done!')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/dataset_converters/refuge.py b/mmsegmentation/tools/dataset_converters/refuge.py
new file mode 100644
index 0000000..1186866
--- /dev/null
+++ b/mmsegmentation/tools/dataset_converters/refuge.py
@@ -0,0 +1,110 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os
+import os.path as osp
+import tempfile
+import zipfile
+
+import mmcv
+import numpy as np
+from mmengine.utils import mkdir_or_exist
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Convert REFUGE dataset to mmsegmentation format')
+    parser.add_argument('--raw_data_root', help='the root path of raw data')
+
+    parser.add_argument('--tmp_dir', help='path of the temporary directory')
+    parser.add_argument('-o', '--out_dir', help='output path')
+    args = parser.parse_args()
+    return args
+
+
+def extract_img(root: str,
+                cur_dir: str,
+                out_dir: str,
+                mode: str = 'train',
+                file_type: str = 'img') -> None:
+    """_summary_
+
+    Args:
+       Args:
+        root (str): root where the extracted data is saved
+        cur_dir (cur_dir): dir where the zip_file exists
+        out_dir (str): root dir where the data is saved
+
+        mode (str, optional): Defaults to 'train'.
+        file_type (str, optional): Defaults to 'img',else to 'mask'.
+    """
+    zip_file = zipfile.ZipFile(cur_dir)
+    zip_file.extractall(root)
+    for cur_dir, dirs, files in os.walk(root):
+        # filter child dirs and directories with "Illustration" and "MACOSX"
+        if len(dirs) == 0 and \
+                cur_dir.split('\\')[-1].find('Illustration') == -1 and \
+                cur_dir.find('MACOSX') == -1:
+
+            file_names = [
+                file for file in files
+                if file.endswith('.jpg') or file.endswith('.bmp')
+            ]
+            for filename in sorted(file_names):
+                img = mmcv.imread(osp.join(cur_dir, filename))
+
+                if file_type == 'annotations':
+                    img = img[:, :, 0]
+                    img[np.where(img == 0)] = 1
+                    img[np.where(img == 128)] = 2
+                    img[np.where(img == 255)] = 0
+                mmcv.imwrite(
+                    img,
+                    osp.join(out_dir, file_type, mode,
+                             osp.splitext(filename)[0] + '.png'))
+
+
+def main():
+    args = parse_args()
+
+    raw_data_root = args.raw_data_root
+    if args.out_dir is None:
+        out_dir = osp.join('./data', 'REFUGE')
+
+    else:
+        out_dir = args.out_dir
+
+    print('Making directories...')
+    mkdir_or_exist(out_dir)
+    mkdir_or_exist(osp.join(out_dir, 'images'))
+    mkdir_or_exist(osp.join(out_dir, 'images', 'training'))
+    mkdir_or_exist(osp.join(out_dir, 'images', 'validation'))
+    mkdir_or_exist(osp.join(out_dir, 'images', 'test'))
+    mkdir_or_exist(osp.join(out_dir, 'annotations'))
+    mkdir_or_exist(osp.join(out_dir, 'annotations', 'training'))
+    mkdir_or_exist(osp.join(out_dir, 'annotations', 'validation'))
+    mkdir_or_exist(osp.join(out_dir, 'annotations', 'test'))
+
+    print('Generating images and annotations...')
+    # process data from the child dir on the first rank
+    cur_dir, dirs, files = list(os.walk(raw_data_root))[0]
+    print('====================')
+
+    files = list(filter(lambda x: x.endswith('.zip'), files))
+
+    with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
+        for file in files:
+            # search data folders for training,validation,test
+            mode = list(
+                filter(lambda x: file.lower().find(x) != -1,
+                       ['training', 'test', 'validation']))[0]
+            file_root = osp.join(tmp_dir, file[:-4])
+            file_type = 'images' if file.find('Anno') == -1 and file.find(
+                'GT') == -1 else 'annotations'
+            extract_img(file_root, osp.join(cur_dir, file), out_dir, mode,
+                        file_type)
+
+    print('Done!')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/dataset_converters/stare.py b/mmsegmentation/tools/dataset_converters/stare.py
new file mode 100644
index 0000000..4a23ba4
--- /dev/null
+++ b/mmsegmentation/tools/dataset_converters/stare.py
@@ -0,0 +1,167 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import gzip
+import os
+import os.path as osp
+import tarfile
+import tempfile
+
+import mmcv
+from mmengine.utils import mkdir_or_exist
+
+STARE_LEN = 20
+TRAINING_LEN = 10
+
+
+def un_gz(src, dst):
+    g_file = gzip.GzipFile(src)
+    with open(dst, 'wb+') as f:
+        f.write(g_file.read())
+    g_file.close()
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Convert STARE dataset to mmsegmentation format')
+    parser.add_argument('image_path', help='the path of stare-images.tar')
+    parser.add_argument('labels_ah', help='the path of labels-ah.tar')
+    parser.add_argument('labels_vk', help='the path of labels-vk.tar')
+    parser.add_argument('--tmp_dir', help='path of the temporary directory')
+    parser.add_argument('-o', '--out_dir', help='output path')
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    image_path = args.image_path
+    labels_ah = args.labels_ah
+    labels_vk = args.labels_vk
+    if args.out_dir is None:
+        out_dir = osp.join('data', 'STARE')
+    else:
+        out_dir = args.out_dir
+
+    print('Making directories...')
+    mkdir_or_exist(out_dir)
+    mkdir_or_exist(osp.join(out_dir, 'images'))
+    mkdir_or_exist(osp.join(out_dir, 'images', 'training'))
+    mkdir_or_exist(osp.join(out_dir, 'images', 'validation'))
+    mkdir_or_exist(osp.join(out_dir, 'annotations'))
+    mkdir_or_exist(osp.join(out_dir, 'annotations', 'training'))
+    mkdir_or_exist(osp.join(out_dir, 'annotations', 'validation'))
+
+    with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
+        mkdir_or_exist(osp.join(tmp_dir, 'gz'))
+        mkdir_or_exist(osp.join(tmp_dir, 'files'))
+
+        print('Extracting stare-images.tar...')
+        with tarfile.open(image_path) as f:
+            f.extractall(osp.join(tmp_dir, 'gz'))
+
+        for filename in os.listdir(osp.join(tmp_dir, 'gz')):
+            un_gz(
+                osp.join(tmp_dir, 'gz', filename),
+                osp.join(tmp_dir, 'files',
+                         osp.splitext(filename)[0]))
+
+        now_dir = osp.join(tmp_dir, 'files')
+
+        assert len(os.listdir(now_dir)) == STARE_LEN, \
+            f'len(os.listdir(now_dir)) != {STARE_LEN}'
+
+        for filename in sorted(os.listdir(now_dir))[:TRAINING_LEN]:
+            img = mmcv.imread(osp.join(now_dir, filename))
+            mmcv.imwrite(
+                img,
+                osp.join(out_dir, 'images', 'training',
+                         osp.splitext(filename)[0] + '.png'))
+
+        for filename in sorted(os.listdir(now_dir))[TRAINING_LEN:]:
+            img = mmcv.imread(osp.join(now_dir, filename))
+            mmcv.imwrite(
+                img,
+                osp.join(out_dir, 'images', 'validation',
+                         osp.splitext(filename)[0] + '.png'))
+
+        print('Removing the temporary files...')
+
+    with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
+        mkdir_or_exist(osp.join(tmp_dir, 'gz'))
+        mkdir_or_exist(osp.join(tmp_dir, 'files'))
+
+        print('Extracting labels-ah.tar...')
+        with tarfile.open(labels_ah) as f:
+            f.extractall(osp.join(tmp_dir, 'gz'))
+
+        for filename in os.listdir(osp.join(tmp_dir, 'gz')):
+            un_gz(
+                osp.join(tmp_dir, 'gz', filename),
+                osp.join(tmp_dir, 'files',
+                         osp.splitext(filename)[0]))
+
+        now_dir = osp.join(tmp_dir, 'files')
+
+        assert len(os.listdir(now_dir)) == STARE_LEN, \
+            f'len(os.listdir(now_dir)) != {STARE_LEN}'
+
+        for filename in sorted(os.listdir(now_dir))[:TRAINING_LEN]:
+            img = mmcv.imread(osp.join(now_dir, filename))
+            # The annotation img should be divided by 128, because some of
+            # the annotation imgs are not standard. We should set a threshold
+            # to convert the nonstandard annotation imgs. The value divided by
+            # 128 equivalent to '1 if value >= 128 else 0'
+            mmcv.imwrite(
+                img[:, :, 0] // 128,
+                osp.join(out_dir, 'annotations', 'training',
+                         osp.splitext(filename)[0] + '.png'))
+
+        for filename in sorted(os.listdir(now_dir))[TRAINING_LEN:]:
+            img = mmcv.imread(osp.join(now_dir, filename))
+            mmcv.imwrite(
+                img[:, :, 0] // 128,
+                osp.join(out_dir, 'annotations', 'validation',
+                         osp.splitext(filename)[0] + '.png'))
+
+        print('Removing the temporary files...')
+
+    with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
+        mkdir_or_exist(osp.join(tmp_dir, 'gz'))
+        mkdir_or_exist(osp.join(tmp_dir, 'files'))
+
+        print('Extracting labels-vk.tar...')
+        with tarfile.open(labels_vk) as f:
+            f.extractall(osp.join(tmp_dir, 'gz'))
+
+        for filename in os.listdir(osp.join(tmp_dir, 'gz')):
+            un_gz(
+                osp.join(tmp_dir, 'gz', filename),
+                osp.join(tmp_dir, 'files',
+                         osp.splitext(filename)[0]))
+
+        now_dir = osp.join(tmp_dir, 'files')
+
+        assert len(os.listdir(now_dir)) == STARE_LEN, \
+            f'len(os.listdir(now_dir)) != {STARE_LEN}'
+
+        for filename in sorted(os.listdir(now_dir))[:TRAINING_LEN]:
+            img = mmcv.imread(osp.join(now_dir, filename))
+            mmcv.imwrite(
+                img[:, :, 0] // 128,
+                osp.join(out_dir, 'annotations', 'training',
+                         osp.splitext(filename)[0] + '.png'))
+
+        for filename in sorted(os.listdir(now_dir))[TRAINING_LEN:]:
+            img = mmcv.imread(osp.join(now_dir, filename))
+            mmcv.imwrite(
+                img[:, :, 0] // 128,
+                osp.join(out_dir, 'annotations', 'validation',
+                         osp.splitext(filename)[0] + '.png'))
+
+        print('Removing the temporary files...')
+
+    print('Done!')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/dataset_converters/synapse.py b/mmsegmentation/tools/dataset_converters/synapse.py
new file mode 100644
index 0000000..42dac6b
--- /dev/null
+++ b/mmsegmentation/tools/dataset_converters/synapse.py
@@ -0,0 +1,155 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os.path as osp
+
+import nibabel as nib
+import numpy as np
+from mmengine.utils import mkdir_or_exist
+from PIL import Image
+
+
+def read_files_from_txt(txt_path):
+    with open(txt_path) as f:
+        files = f.readlines()
+    files = [file.strip() for file in files]
+    return files
+
+
+def read_nii_file(nii_path):
+    img = nib.load(nii_path).get_fdata()
+    return img
+
+
+def split_3d_image(img):
+    c, _, _ = img.shape
+    res = []
+    for i in range(c):
+        res.append(img[i, :, :])
+    return res
+
+
+def label_mapping(label):
+    """Label mapping from TransUNet paper setting. It only has 9 classes, which
+    are 'background', 'aorta', 'gallbladder', 'left_kidney', 'right_kidney',
+    'liver', 'pancreas', 'spleen', 'stomach', respectively. Other foreground
+    classes in original dataset are all set to background.
+
+    More details could be found here: https://arxiv.org/abs/2102.04306
+    """
+    maped_label = np.zeros_like(label)
+    maped_label[label == 8] = 1
+    maped_label[label == 4] = 2
+    maped_label[label == 3] = 3
+    maped_label[label == 2] = 4
+    maped_label[label == 6] = 5
+    maped_label[label == 11] = 6
+    maped_label[label == 1] = 7
+    maped_label[label == 7] = 8
+    return maped_label
+
+
+def pares_args():
+    parser = argparse.ArgumentParser(
+        description='Convert synapse dataset to mmsegmentation format')
+    parser.add_argument(
+        '--dataset-path', type=str, help='synapse dataset path.')
+    parser.add_argument(
+        '--save-path',
+        default='data/synapse',
+        type=str,
+        help='save path of the dataset.')
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = pares_args()
+    dataset_path = args.dataset_path
+    save_path = args.save_path
+
+    if not osp.exists(dataset_path):
+        raise ValueError('The dataset path does not exist. '
+                         'Please enter a correct dataset path.')
+    if not osp.exists(osp.join(dataset_path, 'img')) \
+            or not osp.exists(osp.join(dataset_path, 'label')):
+        raise FileNotFoundError('The dataset structure is incorrect. '
+                                'Please check your dataset.')
+
+    train_id = read_files_from_txt(osp.join(dataset_path, 'train.txt'))
+    train_id = [idx[3:7] for idx in train_id]
+
+    test_id = read_files_from_txt(osp.join(dataset_path, 'val.txt'))
+    test_id = [idx[3:7] for idx in test_id]
+
+    mkdir_or_exist(osp.join(save_path, 'img_dir/train'))
+    mkdir_or_exist(osp.join(save_path, 'img_dir/val'))
+    mkdir_or_exist(osp.join(save_path, 'ann_dir/train'))
+    mkdir_or_exist(osp.join(save_path, 'ann_dir/val'))
+
+    # It follows data preparation pipeline from here:
+    # https://github.com/Beckschen/TransUNet/tree/main/datasets
+    for i, idx in enumerate(train_id):
+        img_3d = read_nii_file(
+            osp.join(dataset_path, 'img', 'img' + idx + '.nii.gz'))
+        label_3d = read_nii_file(
+            osp.join(dataset_path, 'label', 'label' + idx + '.nii.gz'))
+
+        img_3d = np.clip(img_3d, -125, 275)
+        img_3d = (img_3d + 125) / 400
+        img_3d *= 255
+        img_3d = np.transpose(img_3d, [2, 0, 1])
+        img_3d = np.flip(img_3d, 2)
+
+        label_3d = np.transpose(label_3d, [2, 0, 1])
+        label_3d = np.flip(label_3d, 2)
+        label_3d = label_mapping(label_3d)
+
+        for c in range(img_3d.shape[0]):
+            img = img_3d[c]
+            label = label_3d[c]
+
+            img = Image.fromarray(img).convert('RGB')
+            label = Image.fromarray(label).convert('L')
+            img.save(
+                osp.join(
+                    save_path, 'img_dir/train', 'case' + idx.zfill(4) +
+                    '_slice' + str(c).zfill(3) + '.jpg'))
+            label.save(
+                osp.join(
+                    save_path, 'ann_dir/train', 'case' + idx.zfill(4) +
+                    '_slice' + str(c).zfill(3) + '.png'))
+
+    for i, idx in enumerate(test_id):
+        img_3d = read_nii_file(
+            osp.join(dataset_path, 'img', 'img' + idx + '.nii.gz'))
+        label_3d = read_nii_file(
+            osp.join(dataset_path, 'label', 'label' + idx + '.nii.gz'))
+
+        img_3d = np.clip(img_3d, -125, 275)
+        img_3d = (img_3d + 125) / 400
+        img_3d *= 255
+        img_3d = np.transpose(img_3d, [2, 0, 1])
+        img_3d = np.flip(img_3d, 2)
+
+        label_3d = np.transpose(label_3d, [2, 0, 1])
+        label_3d = np.flip(label_3d, 2)
+        label_3d = label_mapping(label_3d)
+
+        for c in range(img_3d.shape[0]):
+            img = img_3d[c]
+            label = label_3d[c]
+
+            img = Image.fromarray(img).convert('RGB')
+            label = Image.fromarray(label).convert('L')
+            img.save(
+                osp.join(
+                    save_path, 'img_dir/val', 'case' + idx.zfill(4) +
+                    '_slice' + str(c).zfill(3) + '.jpg'))
+            label.save(
+                osp.join(
+                    save_path, 'ann_dir/val', 'case' + idx.zfill(4) +
+                    '_slice' + str(c).zfill(3) + '.png'))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/dataset_converters/vaihingen.py b/mmsegmentation/tools/dataset_converters/vaihingen.py
new file mode 100644
index 0000000..db98014
--- /dev/null
+++ b/mmsegmentation/tools/dataset_converters/vaihingen.py
@@ -0,0 +1,156 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import glob
+import math
+import os
+import os.path as osp
+import tempfile
+import zipfile
+
+import mmcv
+import numpy as np
+from mmengine.utils import ProgressBar, mkdir_or_exist
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Convert vaihingen dataset to mmsegmentation format')
+    parser.add_argument('dataset_path', help='vaihingen folder path')
+    parser.add_argument('--tmp_dir', help='path of the temporary directory')
+    parser.add_argument('-o', '--out_dir', help='output path')
+    parser.add_argument(
+        '--clip_size',
+        type=int,
+        help='clipped size of image after preparation',
+        default=512)
+    parser.add_argument(
+        '--stride_size',
+        type=int,
+        help='stride of clipping original images',
+        default=256)
+    args = parser.parse_args()
+    return args
+
+
+def clip_big_image(image_path, clip_save_dir, to_label=False):
+    # Original image of Vaihingen dataset is very large, thus pre-processing
+    # of them is adopted. Given fixed clip size and stride size to generate
+    # clipped image, the intersection　of width and height is determined.
+    # For example, given one 5120 x 5120 original image, the clip size is
+    # 512 and stride size is 256, thus it would generate 20x20 = 400 images
+    # whose size are all 512x512.
+    image = mmcv.imread(image_path)
+
+    h, w, c = image.shape
+    cs = args.clip_size
+    ss = args.stride_size
+
+    num_rows = math.ceil((h - cs) / ss) if math.ceil(
+        (h - cs) / ss) * ss + cs >= h else math.ceil((h - cs) / ss) + 1
+    num_cols = math.ceil((w - cs) / ss) if math.ceil(
+        (w - cs) / ss) * ss + cs >= w else math.ceil((w - cs) / ss) + 1
+
+    x, y = np.meshgrid(np.arange(num_cols + 1), np.arange(num_rows + 1))
+    xmin = x * cs
+    ymin = y * cs
+
+    xmin = xmin.ravel()
+    ymin = ymin.ravel()
+    xmin_offset = np.where(xmin + cs > w, w - xmin - cs, np.zeros_like(xmin))
+    ymin_offset = np.where(ymin + cs > h, h - ymin - cs, np.zeros_like(ymin))
+    boxes = np.stack([
+        xmin + xmin_offset, ymin + ymin_offset,
+        np.minimum(xmin + cs, w),
+        np.minimum(ymin + cs, h)
+    ],
+                     axis=1)
+
+    if to_label:
+        color_map = np.array([[0, 0, 0], [255, 255, 255], [255, 0, 0],
+                              [255, 255, 0], [0, 255, 0], [0, 255, 255],
+                              [0, 0, 255]])
+        flatten_v = np.matmul(
+            image.reshape(-1, c),
+            np.array([2, 3, 4]).reshape(3, 1))
+        out = np.zeros_like(flatten_v)
+        for idx, class_color in enumerate(color_map):
+            value_idx = np.matmul(class_color,
+                                  np.array([2, 3, 4]).reshape(3, 1))
+            out[flatten_v == value_idx] = idx
+        image = out.reshape(h, w)
+
+    for box in boxes:
+        start_x, start_y, end_x, end_y = box
+        clipped_image = image[start_y:end_y,
+                              start_x:end_x] if to_label else image[
+                                  start_y:end_y, start_x:end_x, :]
+        area_idx = osp.basename(image_path).split('_')[3].strip('.tif')
+        mmcv.imwrite(
+            clipped_image.astype(np.uint8),
+            osp.join(clip_save_dir,
+                     f'{area_idx}_{start_x}_{start_y}_{end_x}_{end_y}.png'))
+
+
+def main():
+    splits = {
+        'train': [
+            'area1', 'area11', 'area13', 'area15', 'area17', 'area21',
+            'area23', 'area26', 'area28', 'area3', 'area30', 'area32',
+            'area34', 'area37', 'area5', 'area7'
+        ],
+        'val': [
+            'area6', 'area24', 'area35', 'area16', 'area14', 'area22',
+            'area10', 'area4', 'area2', 'area20', 'area8', 'area31', 'area33',
+            'area27', 'area38', 'area12', 'area29'
+        ],
+    }
+
+    dataset_path = args.dataset_path
+    if args.out_dir is None:
+        out_dir = osp.join('data', 'vaihingen')
+    else:
+        out_dir = args.out_dir
+
+    print('Making directories...')
+    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'train'))
+    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'val'))
+    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'train'))
+    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'val'))
+
+    zipp_list = glob.glob(os.path.join(dataset_path, '*.zip'))
+    print('Find the data', zipp_list)
+
+    with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
+        for zipp in zipp_list:
+            zip_file = zipfile.ZipFile(zipp)
+            zip_file.extractall(tmp_dir)
+            src_path_list = glob.glob(os.path.join(tmp_dir, '*.tif'))
+            if 'ISPRS_semantic_labeling_Vaihingen' in zipp:
+                src_path_list = glob.glob(
+                    os.path.join(os.path.join(tmp_dir, 'top'), '*.tif'))
+            if 'ISPRS_semantic_labeling_Vaihingen_ground_truth_eroded_COMPLETE' in zipp:  # noqa
+                src_path_list = glob.glob(os.path.join(tmp_dir, '*.tif'))
+                # delete unused area9 ground truth
+                for area_ann in src_path_list:
+                    if 'area9' in area_ann:
+                        src_path_list.remove(area_ann)
+            prog_bar = ProgressBar(len(src_path_list))
+            for i, src_path in enumerate(src_path_list):
+                area_idx = osp.basename(src_path).split('_')[3].strip('.tif')
+                data_type = 'train' if area_idx in splits['train'] else 'val'
+                if 'noBoundary' in src_path:
+                    dst_dir = osp.join(out_dir, 'ann_dir', data_type)
+                    clip_big_image(src_path, dst_dir, to_label=True)
+                else:
+                    dst_dir = osp.join(out_dir, 'img_dir', data_type)
+                    clip_big_image(src_path, dst_dir, to_label=False)
+                prog_bar.update()
+
+        print('Removing the temporary files...')
+
+    print('Done!')
+
+
+if __name__ == '__main__':
+    args = parse_args()
+    main()
diff --git a/mmsegmentation/tools/dataset_converters/voc_aug.py b/mmsegmentation/tools/dataset_converters/voc_aug.py
new file mode 100644
index 0000000..a536f42
--- /dev/null
+++ b/mmsegmentation/tools/dataset_converters/voc_aug.py
@@ -0,0 +1,92 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os.path as osp
+from functools import partial
+
+import numpy as np
+from mmengine.utils import mkdir_or_exist, scandir, track_parallel_progress
+from PIL import Image
+from scipy.io import loadmat
+
+AUG_LEN = 10582
+
+
+def convert_mat(mat_file, in_dir, out_dir):
+    data = loadmat(osp.join(in_dir, mat_file))
+    mask = data['GTcls'][0]['Segmentation'][0].astype(np.uint8)
+    seg_filename = osp.join(out_dir, mat_file.replace('.mat', '.png'))
+    Image.fromarray(mask).save(seg_filename, 'PNG')
+
+
+def generate_aug_list(merged_list, excluded_list):
+    return list(set(merged_list) - set(excluded_list))
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Convert PASCAL VOC annotations to mmsegmentation format')
+    parser.add_argument('devkit_path', help='pascal voc devkit path')
+    parser.add_argument('aug_path', help='pascal voc aug path')
+    parser.add_argument('-o', '--out_dir', help='output path')
+    parser.add_argument(
+        '--nproc', default=1, type=int, help='number of process')
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    devkit_path = args.devkit_path
+    aug_path = args.aug_path
+    nproc = args.nproc
+    if args.out_dir is None:
+        out_dir = osp.join(devkit_path, 'VOC2012', 'SegmentationClassAug')
+    else:
+        out_dir = args.out_dir
+    mkdir_or_exist(out_dir)
+    in_dir = osp.join(aug_path, 'dataset', 'cls')
+
+    track_parallel_progress(
+        partial(convert_mat, in_dir=in_dir, out_dir=out_dir),
+        list(scandir(in_dir, suffix='.mat')),
+        nproc=nproc)
+
+    full_aug_list = []
+    with open(osp.join(aug_path, 'dataset', 'train.txt')) as f:
+        full_aug_list += [line.strip() for line in f]
+    with open(osp.join(aug_path, 'dataset', 'val.txt')) as f:
+        full_aug_list += [line.strip() for line in f]
+
+    with open(
+            osp.join(devkit_path, 'VOC2012/ImageSets/Segmentation',
+                     'train.txt')) as f:
+        ori_train_list = [line.strip() for line in f]
+    with open(
+            osp.join(devkit_path, 'VOC2012/ImageSets/Segmentation',
+                     'val.txt')) as f:
+        val_list = [line.strip() for line in f]
+
+    aug_train_list = generate_aug_list(ori_train_list + full_aug_list,
+                                       val_list)
+    assert len(aug_train_list) == AUG_LEN, 'len(aug_train_list) != {}'.format(
+        AUG_LEN)
+
+    with open(
+            osp.join(devkit_path, 'VOC2012/ImageSets/Segmentation',
+                     'trainaug.txt'), 'w') as f:
+        f.writelines(line + '\n' for line in aug_train_list)
+
+    aug_list = generate_aug_list(full_aug_list, ori_train_list + val_list)
+    assert len(aug_list) == AUG_LEN - len(
+        ori_train_list), 'len(aug_list) != {}'.format(AUG_LEN -
+                                                      len(ori_train_list))
+    with open(
+            osp.join(devkit_path, 'VOC2012/ImageSets/Segmentation', 'aug.txt'),
+            'w') as f:
+        f.writelines(line + '\n' for line in aug_list)
+
+    print('Done!')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/deployment/pytorch2torchscript.py b/mmsegmentation/tools/deployment/pytorch2torchscript.py
new file mode 100644
index 0000000..e69e705
--- /dev/null
+++ b/mmsegmentation/tools/deployment/pytorch2torchscript.py
@@ -0,0 +1,185 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+
+import numpy as np
+import torch
+import torch._C
+import torch.serialization
+from mmengine import Config
+from mmengine.runner import load_checkpoint
+from torch import nn
+
+from mmseg.models import build_segmentor
+
+torch.manual_seed(3)
+
+
+def digit_version(version_str):
+    digit_version = []
+    for x in version_str.split('.'):
+        if x.isdigit():
+            digit_version.append(int(x))
+        elif x.find('rc') != -1:
+            patch_version = x.split('rc')
+            digit_version.append(int(patch_version[0]) - 1)
+            digit_version.append(int(patch_version[1]))
+    return digit_version
+
+
+def check_torch_version():
+    torch_minimum_version = '1.8.0'
+    torch_version = digit_version(torch.__version__)
+
+    assert (torch_version >= digit_version(torch_minimum_version)), \
+        f'Torch=={torch.__version__} is not support for converting to ' \
+        f'torchscript. Please install pytorch>={torch_minimum_version}.'
+
+
+def _convert_batchnorm(module):
+    module_output = module
+    if isinstance(module, torch.nn.SyncBatchNorm):
+        module_output = torch.nn.BatchNorm2d(module.num_features, module.eps,
+                                             module.momentum, module.affine,
+                                             module.track_running_stats)
+        if module.affine:
+            module_output.weight.data = module.weight.data.clone().detach()
+            module_output.bias.data = module.bias.data.clone().detach()
+            # keep requires_grad unchanged
+            module_output.weight.requires_grad = module.weight.requires_grad
+            module_output.bias.requires_grad = module.bias.requires_grad
+        module_output.running_mean = module.running_mean
+        module_output.running_var = module.running_var
+        module_output.num_batches_tracked = module.num_batches_tracked
+    for name, child in module.named_children():
+        module_output.add_module(name, _convert_batchnorm(child))
+    del module
+    return module_output
+
+
+def _demo_mm_inputs(input_shape, num_classes):
+    """Create a superset of inputs needed to run test or train batches.
+
+    Args:
+        input_shape (tuple):
+            input batch dimensions
+        num_classes (int):
+            number of semantic classes
+    """
+    (N, C, H, W) = input_shape
+    rng = np.random.RandomState(0)
+    imgs = rng.rand(*input_shape)
+    segs = rng.randint(
+        low=0, high=num_classes - 1, size=(N, 1, H, W)).astype(np.uint8)
+    img_metas = [{
+        'img_shape': (H, W, C),
+        'ori_shape': (H, W, C),
+        'pad_shape': (H, W, C),
+        'filename': '<demo>.png',
+        'scale_factor': 1.0,
+        'flip': False,
+    } for _ in range(N)]
+    mm_inputs = {
+        'imgs': torch.FloatTensor(imgs).requires_grad_(True),
+        'img_metas': img_metas,
+        'gt_semantic_seg': torch.LongTensor(segs)
+    }
+    return mm_inputs
+
+
+def pytorch2libtorch(model,
+                     input_shape,
+                     show=False,
+                     output_file='tmp.pt',
+                     verify=False):
+    """Export Pytorch model to TorchScript model and verify the outputs are
+    same between Pytorch and TorchScript.
+
+    Args:
+        model (nn.Module): Pytorch model we want to export.
+        input_shape (tuple): Use this input shape to construct
+            the corresponding dummy input and execute the model.
+        show (bool): Whether print the computation graph. Default: False.
+        output_file (string): The path to where we store the
+            output TorchScript model. Default: `tmp.pt`.
+        verify (bool): Whether compare the outputs between
+            Pytorch and TorchScript. Default: False.
+    """
+    if isinstance(model.decode_head, nn.ModuleList):
+        num_classes = model.decode_head[-1].num_classes
+    else:
+        num_classes = model.decode_head.num_classes
+
+    mm_inputs = _demo_mm_inputs(input_shape, num_classes)
+
+    imgs = mm_inputs.pop('imgs')
+
+    # replace the original forword with forward_dummy
+    model.forward = model.forward_dummy
+    model.eval()
+    traced_model = torch.jit.trace(
+        model,
+        example_inputs=imgs,
+        check_trace=verify,
+    )
+
+    if show:
+        print(traced_model.graph)
+
+    traced_model.save(output_file)
+    print(f'Successfully exported TorchScript model: {output_file}')
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Convert MMSeg to TorchScript')
+    parser.add_argument('config', help='test config file path')
+    parser.add_argument('--checkpoint', help='checkpoint file', default=None)
+    parser.add_argument(
+        '--show', action='store_true', help='show TorchScript graph')
+    parser.add_argument(
+        '--verify', action='store_true', help='verify the TorchScript model')
+    parser.add_argument('--output-file', type=str, default='tmp.pt')
+    parser.add_argument(
+        '--shape',
+        type=int,
+        nargs='+',
+        default=[512, 512],
+        help='input image size (height, width)')
+    args = parser.parse_args()
+    return args
+
+
+if __name__ == '__main__':
+    args = parse_args()
+    check_torch_version()
+
+    if len(args.shape) == 1:
+        input_shape = (1, 3, args.shape[0], args.shape[0])
+    elif len(args.shape) == 2:
+        input_shape = (
+            1,
+            3,
+        ) + tuple(args.shape)
+    else:
+        raise ValueError('invalid input shape')
+
+    cfg = Config.fromfile(args.config)
+    cfg.model.pretrained = None
+
+    # build the model and load checkpoint
+    cfg.model.train_cfg = None
+    segmentor = build_segmentor(
+        cfg.model, train_cfg=None, test_cfg=cfg.get('test_cfg'))
+    # convert SyncBN to BN
+    segmentor = _convert_batchnorm(segmentor)
+
+    if args.checkpoint:
+        load_checkpoint(segmentor, args.checkpoint, map_location='cpu')
+
+    # convert the PyTorch model to LibTorch model
+    pytorch2libtorch(
+        segmentor,
+        input_shape,
+        show=args.show,
+        output_file=args.output_file,
+        verify=args.verify)
diff --git a/mmsegmentation/tools/dist_test.sh b/mmsegmentation/tools/dist_test.sh
new file mode 100755
index 0000000..89711fd
--- /dev/null
+++ b/mmsegmentation/tools/dist_test.sh
@@ -0,0 +1,20 @@
+CONFIG=$1
+CHECKPOINT=$2
+GPUS=$3
+NNODES=${NNODES:-1}
+NODE_RANK=${NODE_RANK:-0}
+PORT=${PORT:-29500}
+MASTER_ADDR=${MASTER_ADDR:-"127.0.0.1"}
+
+PYTHONPATH="$(dirname $0)/..":$PYTHONPATH \
+python -m torch.distributed.launch \
+    --nnodes=$NNODES \
+    --node_rank=$NODE_RANK \
+    --master_addr=$MASTER_ADDR \
+    --nproc_per_node=$GPUS \
+    --master_port=$PORT \
+    $(dirname "$0")/test.py \
+    $CONFIG \
+    $CHECKPOINT \
+    --launcher pytorch \
+    ${@:4}
diff --git a/mmsegmentation/tools/dist_train.sh b/mmsegmentation/tools/dist_train.sh
new file mode 100755
index 0000000..a857df7
--- /dev/null
+++ b/mmsegmentation/tools/dist_train.sh
@@ -0,0 +1,17 @@
+CONFIG=$1
+GPUS=$2
+NNODES=${NNODES:-1}
+NODE_RANK=${NODE_RANK:-0}
+PORT=${PORT:-29500}
+MASTER_ADDR=${MASTER_ADDR:-"127.0.0.1"}
+
+PYTHONPATH="$(dirname $0)/..":$PYTHONPATH \
+python -m torch.distributed.launch \
+    --nnodes=$NNODES \
+    --node_rank=$NODE_RANK \
+    --master_addr=$MASTER_ADDR \
+    --nproc_per_node=$GPUS \
+    --master_port=$PORT \
+    $(dirname "$0")/train.py \
+    $CONFIG \
+    --launcher pytorch ${@:3}
diff --git a/mmsegmentation/tools/misc/browse_dataset.py b/mmsegmentation/tools/misc/browse_dataset.py
new file mode 100644
index 0000000..7863eb7
--- /dev/null
+++ b/mmsegmentation/tools/misc/browse_dataset.py
@@ -0,0 +1,73 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os.path as osp
+
+from mmengine import Config, DictAction
+from mmengine.registry import init_default_scope
+from mmengine.utils import ProgressBar
+
+from mmseg.registry import DATASETS, VISUALIZERS
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Browse a dataset')
+    parser.add_argument('config', help='train config file path')
+    parser.add_argument(
+        '--output-dir',
+        default=None,
+        type=str,
+        help='If there is no display interface, you can save it')
+    parser.add_argument('--not-show', default=False, action='store_true')
+    parser.add_argument(
+        '--show-interval',
+        type=float,
+        default=2,
+        help='the interval of show (s)')
+    parser.add_argument(
+        '--cfg-options',
+        nargs='+',
+        action=DictAction,
+        help='override some settings in the used config, the key-value pair '
+        'in xxx=yyy format will be merged into config file. If the value to '
+        'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
+        'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
+        'Note that the quotation marks are necessary and that no white space '
+        'is allowed.')
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    cfg = Config.fromfile(args.config)
+    if args.cfg_options is not None:
+        cfg.merge_from_dict(args.cfg_options)
+
+    # register all modules in mmseg into the registries
+    init_default_scope('mmseg')
+
+    dataset = DATASETS.build(cfg.train_dataloader.dataset)
+    cfg.visualizer['save_dir'] = args.output_dir
+    visualizer = VISUALIZERS.build(cfg.visualizer)
+    visualizer.dataset_meta = dataset.METAINFO
+
+    progress_bar = ProgressBar(len(dataset))
+    for item in dataset:
+        img = item['inputs'].permute(1, 2, 0).numpy()
+        data_sample = item['data_samples'].numpy()
+        img_path = osp.basename(item['data_samples'].img_path)
+
+        img = img[..., [2, 1, 0]]  # bgr to rgb
+
+        visualizer.add_datasample(
+            osp.basename(img_path),
+            img,
+            data_sample,
+            show=not args.not_show,
+            wait_time=args.show_interval)
+
+        progress_bar.update()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/misc/print_config.py b/mmsegmentation/tools/misc/print_config.py
new file mode 100644
index 0000000..2a1c024
--- /dev/null
+++ b/mmsegmentation/tools/misc/print_config.py
@@ -0,0 +1,69 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import warnings
+
+from mmengine import Config, DictAction
+
+from mmseg.apis import init_model
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Print the whole config')
+    parser.add_argument('config', help='config file path')
+    parser.add_argument(
+        '--graph', action='store_true', help='print the models graph')
+    parser.add_argument(
+        '--options',
+        nargs='+',
+        action=DictAction,
+        help="--options is deprecated in favor of --cfg_options' and it will "
+        'not be supported in version v0.22.0. Override some settings in the '
+        'used config, the key-value pair in xxx=yyy format will be merged '
+        'into config file. If the value to be overwritten is a list, it '
+        'should be like key="[a,b]" or key=a,b It also allows nested '
+        'list/tuple values, e.g. key="[(a,b),(c,d)]" Note that the quotation '
+        'marks are necessary and that no white space is allowed.')
+    parser.add_argument(
+        '--cfg-options',
+        nargs='+',
+        action=DictAction,
+        help='override some settings in the used config, the key-value pair '
+        'in xxx=yyy format will be merged into config file. If the value to '
+        'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
+        'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
+        'Note that the quotation marks are necessary and that no white space '
+        'is allowed.')
+    args = parser.parse_args()
+
+    if args.options and args.cfg_options:
+        raise ValueError(
+            '--options and --cfg-options cannot be both '
+            'specified, --options is deprecated in favor of --cfg-options. '
+            '--options will not be supported in version v0.22.0.')
+    if args.options:
+        warnings.warn('--options is deprecated in favor of --cfg-options, '
+                      '--options will not be supported in version v0.22.0.')
+        args.cfg_options = args.options
+
+    return args
+
+
+def main():
+    args = parse_args()
+
+    cfg = Config.fromfile(args.config)
+    if args.cfg_options is not None:
+        cfg.merge_from_dict(args.cfg_options)
+    print(f'Config:\n{cfg.pretty_text}')
+    # dump config
+    cfg.dump('example.py')
+    # dump models graph
+    if args.graph:
+        model = init_model(args.config, device='cpu')
+        print(f'Model graph:\n{str(model)}')
+        with open('example-graph.txt', 'w') as f:
+            f.writelines(str(model))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/misc/publish_model.py b/mmsegmentation/tools/misc/publish_model.py
new file mode 100644
index 0000000..e035ad9
--- /dev/null
+++ b/mmsegmentation/tools/misc/publish_model.py
@@ -0,0 +1,50 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import subprocess
+from hashlib import sha256
+
+import torch
+
+BLOCK_SIZE = 128 * 1024
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Process a checkpoint to be published')
+    parser.add_argument('in_file', help='input checkpoint filename')
+    parser.add_argument('out_file', help='output checkpoint filename')
+    args = parser.parse_args()
+    return args
+
+
+def sha256sum(filename: str) -> str:
+    """Compute SHA256 message digest from a file."""
+    hash_func = sha256()
+    byte_array = bytearray(BLOCK_SIZE)
+    memory_view = memoryview(byte_array)
+    with open(filename, 'rb', buffering=0) as file:
+        for block in iter(lambda: file.readinto(memory_view), 0):
+            hash_func.update(memory_view[:block])
+    return hash_func.hexdigest()
+
+
+def process_checkpoint(in_file, out_file):
+    checkpoint = torch.load(in_file, map_location='cpu')
+    # remove optimizer for smaller file size
+    if 'optimizer' in checkpoint:
+        del checkpoint['optimizer']
+    # if it is necessary to remove some sensitive data in checkpoint['meta'],
+    # add the code here.
+    torch.save(checkpoint, out_file)
+    sha = sha256sum(in_file)
+    final_file = out_file.rstrip('.pth') + f'-{sha[:8]}.pth'
+    subprocess.Popen(['mv', out_file, final_file])
+
+
+def main():
+    args = parse_args()
+    process_checkpoint(args.in_file, args.out_file)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/model_converters/beit2mmseg.py b/mmsegmentation/tools/model_converters/beit2mmseg.py
new file mode 100644
index 0000000..20f8f0f
--- /dev/null
+++ b/mmsegmentation/tools/model_converters/beit2mmseg.py
@@ -0,0 +1,56 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os.path as osp
+from collections import OrderedDict
+
+import mmengine
+import torch
+from mmengine.runner import CheckpointLoader
+
+
+def convert_beit(ckpt):
+    new_ckpt = OrderedDict()
+
+    for k, v in ckpt.items():
+        if k.startswith('patch_embed'):
+            new_key = k.replace('patch_embed.proj', 'patch_embed.projection')
+            new_ckpt[new_key] = v
+        if k.startswith('blocks'):
+            new_key = k.replace('blocks', 'layers')
+            if 'norm' in new_key:
+                new_key = new_key.replace('norm', 'ln')
+            elif 'mlp.fc1' in new_key:
+                new_key = new_key.replace('mlp.fc1', 'ffn.layers.0.0')
+            elif 'mlp.fc2' in new_key:
+                new_key = new_key.replace('mlp.fc2', 'ffn.layers.1')
+            new_ckpt[new_key] = v
+        else:
+            new_key = k
+            new_ckpt[new_key] = v
+
+    return new_ckpt
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Convert keys in official pretrained beit models to'
+        'MMSegmentation style.')
+    parser.add_argument('src', help='src model path or url')
+    # The dst path must be a full path of the new checkpoint.
+    parser.add_argument('dst', help='save path')
+    args = parser.parse_args()
+
+    checkpoint = CheckpointLoader.load_checkpoint(args.src, map_location='cpu')
+    if 'state_dict' in checkpoint:
+        state_dict = checkpoint['state_dict']
+    elif 'model' in checkpoint:
+        state_dict = checkpoint['model']
+    else:
+        state_dict = checkpoint
+    weight = convert_beit(state_dict)
+    mmengine.mkdir_or_exist(osp.dirname(args.dst))
+    torch.save(weight, args.dst)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/model_converters/clip2mmseg.py b/mmsegmentation/tools/model_converters/clip2mmseg.py
new file mode 100644
index 0000000..9a97e4b
--- /dev/null
+++ b/mmsegmentation/tools/model_converters/clip2mmseg.py
@@ -0,0 +1,163 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os.path as osp
+from collections import OrderedDict
+
+import mmengine
+import torch
+from mmengine.runner import CheckpointLoader
+
+
+def convert_vitlayer(paras):
+    new_para_name = ''
+    if paras[0] == 'ln_1':
+        new_para_name = '.'.join(['ln1'] + paras[1:])
+    elif paras[0] == 'attn':
+        new_para_name = '.'.join(['attn.attn'] + paras[1:])
+    elif paras[0] == 'ln_2':
+        new_para_name = '.'.join(['ln2'] + paras[1:])
+    elif paras[0] == 'mlp':
+        if paras[1] == 'c_fc':
+            new_para_name = '.'.join(['ffn.layers.0.0'] + paras[-1:])
+        else:
+            new_para_name = '.'.join(['ffn.layers.1'] + paras[-1:])
+    else:
+        print(f'Wrong for {paras}')
+    return new_para_name
+
+
+def convert_translayer(paras):
+    new_para_name = ''
+    if paras[0] == 'attn':
+        new_para_name = '.'.join(['attentions.0.attn'] + paras[1:])
+    elif paras[0] == 'ln_1':
+        new_para_name = '.'.join(['norms.0'] + paras[1:])
+    elif paras[0] == 'ln_2':
+        new_para_name = '.'.join(['norms.1'] + paras[1:])
+    elif paras[0] == 'mlp':
+        if paras[1] == 'c_fc':
+            new_para_name = '.'.join(['ffns.0.layers.0.0'] + paras[2:])
+        elif paras[1] == 'c_proj':
+            new_para_name = '.'.join(['ffns.0.layers.1'] + paras[2:])
+        else:
+            print(f'Wrong for {paras}')
+    else:
+        print(f'Wrong for {paras}')
+    return new_para_name
+
+
+def convert_key_name(ckpt, visual_split):
+    new_ckpt = OrderedDict()
+    for k, v in ckpt.items():
+        key_list = k.split('.')
+        if key_list[0] == 'visual':
+            new_transform_name = 'image_encoder'
+            if key_list[1] == 'class_embedding':
+                new_name = '.'.join([new_transform_name, 'cls_token'])
+            elif key_list[1] == 'positional_embedding':
+                new_name = '.'.join([new_transform_name, 'pos_embed'])
+            elif key_list[1] == 'conv1':
+                new_name = '.'.join([
+                    new_transform_name, 'patch_embed.projection', key_list[2]
+                ])
+            elif key_list[1] == 'ln_pre':
+                new_name = '.'.join(
+                    [new_transform_name, key_list[1], key_list[2]])
+            elif key_list[1] == 'transformer':
+                new_layer_name = 'layers'
+                layer_index = key_list[3]
+                paras = key_list[4:]
+                if int(layer_index) < visual_split:
+                    new_para_name = convert_vitlayer(paras)
+                    new_name = '.'.join([
+                        new_transform_name, new_layer_name, layer_index,
+                        new_para_name
+                    ])
+                else:
+                    new_para_name = convert_translayer(paras)
+                    new_transform_name = 'decode_head.rec_with_attnbias'
+                    new_layer_name = 'layers'
+                    layer_index = str(int(layer_index) - visual_split)
+                    new_name = '.'.join([
+                        new_transform_name, new_layer_name, layer_index,
+                        new_para_name
+                    ])
+            elif key_list[1] == 'proj':
+                new_name = 'decode_head.rec_with_attnbias.proj.weight'
+            elif key_list[1] == 'ln_post':
+                new_name = k.replace('visual', 'decode_head.rec_with_attnbias')
+            else:
+                print(f'pop parameter: {k}')
+                continue
+        else:
+            text_encoder_name = 'text_encoder'
+            if key_list[0] == 'transformer':
+                layer_name = 'transformer'
+                layer_index = key_list[2]
+                paras = key_list[3:]
+                new_para_name = convert_translayer(paras)
+                new_name = '.'.join([
+                    text_encoder_name, layer_name, layer_index, new_para_name
+                ])
+            elif key_list[0] in [
+                    'positional_embedding', 'text_projection', 'bg_embed',
+                    'attn_mask', 'logit_scale', 'token_embedding', 'ln_final'
+            ]:
+                new_name = 'text_encoder.' + k
+            else:
+                print(f'pop parameter: {k}')
+                continue
+        new_ckpt[new_name] = v
+
+    return new_ckpt
+
+
+def convert_tensor(ckpt):
+    cls_token = ckpt['image_encoder.cls_token']
+    new_cls_token = cls_token.unsqueeze(0).unsqueeze(0)
+    ckpt['image_encoder.cls_token'] = new_cls_token
+    pos_embed = ckpt['image_encoder.pos_embed']
+    new_pos_embed = pos_embed.unsqueeze(0)
+    ckpt['image_encoder.pos_embed'] = new_pos_embed
+    proj_weight = ckpt['decode_head.rec_with_attnbias.proj.weight']
+    new_proj_weight = proj_weight.transpose(1, 0)
+    ckpt['decode_head.rec_with_attnbias.proj.weight'] = new_proj_weight
+    return ckpt
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Convert keys in timm pretrained vit models to '
+        'MMSegmentation style.')
+    parser.add_argument('src', help='src model path or url')
+    # The dst path must be a full path of the new checkpoint.
+    parser.add_argument('dst', help='save path')
+    args = parser.parse_args()
+
+    if any([s in args.src for s in ['B-16', 'b16', 'base_patch16']]):
+        visual_split = 9
+    elif any([s in args.src for s in ['L-14', 'l14', 'large_patch14']]):
+        visual_split = 18
+    else:
+        print('Make sure the clip model is ViT-B/16 or ViT-L/14!')
+        visual_split = -1
+    checkpoint = CheckpointLoader.load_checkpoint(args.src, map_location='cpu')
+    if isinstance(checkpoint, torch.jit.RecursiveScriptModule):
+        state_dict = checkpoint.state_dict()
+    else:
+        if 'state_dict' in checkpoint:
+            # timm checkpoint
+            state_dict = checkpoint['state_dict']
+        elif 'model' in checkpoint:
+            # deit checkpoint
+            state_dict = checkpoint['model']
+        else:
+            state_dict = checkpoint
+    weight = convert_key_name(state_dict, visual_split)
+    weight = convert_tensor(weight)
+    mmengine.mkdir_or_exist(osp.dirname(args.dst))
+    torch.save(weight, args.dst)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/model_converters/mit2mmseg.py b/mmsegmentation/tools/model_converters/mit2mmseg.py
new file mode 100644
index 0000000..f10cbbf
--- /dev/null
+++ b/mmsegmentation/tools/model_converters/mit2mmseg.py
@@ -0,0 +1,82 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os.path as osp
+from collections import OrderedDict
+
+import mmengine
+import torch
+from mmengine.runner import CheckpointLoader
+
+
+def convert_mit(ckpt):
+    new_ckpt = OrderedDict()
+    # Process the concat between q linear weights and kv linear weights
+    for k, v in ckpt.items():
+        if k.startswith('head'):
+            continue
+        # patch embedding conversion
+        elif k.startswith('patch_embed'):
+            stage_i = int(k.split('.')[0].replace('patch_embed', ''))
+            new_k = k.replace(f'patch_embed{stage_i}', f'layers.{stage_i-1}.0')
+            new_v = v
+            if 'proj.' in new_k:
+                new_k = new_k.replace('proj.', 'projection.')
+        # transformer encoder layer conversion
+        elif k.startswith('block'):
+            stage_i = int(k.split('.')[0].replace('block', ''))
+            new_k = k.replace(f'block{stage_i}', f'layers.{stage_i-1}.1')
+            new_v = v
+            if 'attn.q.' in new_k:
+                sub_item_k = k.replace('q.', 'kv.')
+                new_k = new_k.replace('q.', 'attn.in_proj_')
+                new_v = torch.cat([v, ckpt[sub_item_k]], dim=0)
+            elif 'attn.kv.' in new_k:
+                continue
+            elif 'attn.proj.' in new_k:
+                new_k = new_k.replace('proj.', 'attn.out_proj.')
+            elif 'attn.sr.' in new_k:
+                new_k = new_k.replace('sr.', 'sr.')
+            elif 'mlp.' in new_k:
+                string = f'{new_k}-'
+                new_k = new_k.replace('mlp.', 'ffn.layers.')
+                if 'fc1.weight' in new_k or 'fc2.weight' in new_k:
+                    new_v = v.reshape((*v.shape, 1, 1))
+                new_k = new_k.replace('fc1.', '0.')
+                new_k = new_k.replace('dwconv.dwconv.', '1.')
+                new_k = new_k.replace('fc2.', '4.')
+                string += f'{new_k} {v.shape}-{new_v.shape}'
+        # norm layer conversion
+        elif k.startswith('norm'):
+            stage_i = int(k.split('.')[0].replace('norm', ''))
+            new_k = k.replace(f'norm{stage_i}', f'layers.{stage_i-1}.2')
+            new_v = v
+        else:
+            new_k = k
+            new_v = v
+        new_ckpt[new_k] = new_v
+    return new_ckpt
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Convert keys in official pretrained segformer to '
+        'MMSegmentation style.')
+    parser.add_argument('src', help='src model path or url')
+    # The dst path must be a full path of the new checkpoint.
+    parser.add_argument('dst', help='save path')
+    args = parser.parse_args()
+
+    checkpoint = CheckpointLoader.load_checkpoint(args.src, map_location='cpu')
+    if 'state_dict' in checkpoint:
+        state_dict = checkpoint['state_dict']
+    elif 'model' in checkpoint:
+        state_dict = checkpoint['model']
+    else:
+        state_dict = checkpoint
+    weight = convert_mit(state_dict)
+    mmengine.mkdir_or_exist(osp.dirname(args.dst))
+    torch.save(weight, args.dst)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/model_converters/san2mmseg.py b/mmsegmentation/tools/model_converters/san2mmseg.py
new file mode 100644
index 0000000..301a466
--- /dev/null
+++ b/mmsegmentation/tools/model_converters/san2mmseg.py
@@ -0,0 +1,220 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os.path as osp
+from collections import OrderedDict
+
+import mmengine
+import torch
+from mmengine.runner import CheckpointLoader
+
+
+def convert_key_name(ckpt):
+    new_ckpt = OrderedDict()
+
+    for k, v in ckpt.items():
+        key_list = k.split('.')
+        if key_list[0] == 'clip_visual_extractor':
+            new_transform_name = 'image_encoder'
+            if key_list[1] == 'class_embedding':
+                new_name = '.'.join([new_transform_name, 'cls_token'])
+            elif key_list[1] == 'positional_embedding':
+                new_name = '.'.join([new_transform_name, 'pos_embed'])
+            elif key_list[1] == 'conv1':
+                new_name = '.'.join([
+                    new_transform_name, 'patch_embed.projection', key_list[2]
+                ])
+            elif key_list[1] == 'ln_pre':
+                new_name = '.'.join(
+                    [new_transform_name, key_list[1], key_list[2]])
+            elif key_list[1] == 'resblocks':
+                new_layer_name = 'layers'
+                layer_index = key_list[2]
+                paras = key_list[3:]
+                if paras[0] == 'ln_1':
+                    new_para_name = '.'.join(['ln1'] + key_list[4:])
+                elif paras[0] == 'attn':
+                    new_para_name = '.'.join(['attn.attn'] + key_list[4:])
+                elif paras[0] == 'ln_2':
+                    new_para_name = '.'.join(['ln2'] + key_list[4:])
+                elif paras[0] == 'mlp':
+                    if paras[1] == 'c_fc':
+                        new_para_name = '.'.join(['ffn.layers.0.0'] +
+                                                 key_list[-1:])
+                    else:
+                        new_para_name = '.'.join(['ffn.layers.1'] +
+                                                 key_list[-1:])
+                new_name = '.'.join([
+                    new_transform_name, new_layer_name, layer_index,
+                    new_para_name
+                ])
+        elif key_list[0] == 'side_adapter_network':
+            decode_head_name = 'decode_head'
+            module_name = 'side_adapter_network'
+            if key_list[1] == 'vit_model':
+                if key_list[2] == 'blocks':
+                    layer_name = 'encode_layers'
+                    layer_index = key_list[3]
+                    paras = key_list[4:]
+                    if paras[0] == 'norm1':
+                        new_para_name = '.'.join(['ln1'] + key_list[5:])
+                    elif paras[0] == 'attn':
+                        new_para_name = '.'.join(key_list[4:])
+                        new_para_name = new_para_name.replace(
+                            'attn.qkv.', 'attn.attn.in_proj_')
+                        new_para_name = new_para_name.replace(
+                            'attn.proj', 'attn.attn.out_proj')
+                    elif paras[0] == 'norm2':
+                        new_para_name = '.'.join(['ln2'] + key_list[5:])
+                    elif paras[0] == 'mlp':
+                        new_para_name = '.'.join(['ffn'] + key_list[5:])
+                        new_para_name = new_para_name.replace(
+                            'fc1', 'layers.0.0')
+                        new_para_name = new_para_name.replace(
+                            'fc2', 'layers.1')
+                    else:
+                        print(f'Wrong for {k}')
+                    new_name = '.'.join([
+                        decode_head_name, module_name, layer_name, layer_index,
+                        new_para_name
+                    ])
+                elif key_list[2] == 'pos_embed':
+                    new_name = '.'.join(
+                        [decode_head_name, module_name, 'pos_embed'])
+                elif key_list[2] == 'patch_embed':
+                    new_name = '.'.join([
+                        decode_head_name, module_name, 'patch_embed',
+                        'projection', key_list[4]
+                    ])
+                else:
+                    print(f'Wrong for {k}')
+            elif key_list[1] == 'query_embed' or key_list[
+                    1] == 'query_pos_embed':
+                new_name = '.'.join(
+                    [decode_head_name, module_name, key_list[1]])
+            elif key_list[1] == 'fusion_layers':
+                layer_name = 'conv_clips'
+                layer_index = key_list[2][-1]
+                paras = '.'.join(key_list[3:])
+                new_para_name = paras.replace('input_proj.0', '0')
+                new_para_name = new_para_name.replace('input_proj.1', '1.conv')
+                new_name = '.'.join([
+                    decode_head_name, module_name, layer_name, layer_index,
+                    new_para_name
+                ])
+            elif key_list[1] == 'mask_decoder':
+                new_name = 'decode_head.' + k
+            else:
+                print(f'Wrong for {k}')
+        elif key_list[0] == 'clip_rec_head':
+            module_name = 'rec_with_attnbias'
+            if key_list[1] == 'proj':
+                new_name = '.'.join(
+                    [decode_head_name, module_name, 'proj.weight'])
+            elif key_list[1] == 'ln_post':
+                new_name = '.'.join(
+                    [decode_head_name, module_name, 'ln_post', key_list[2]])
+            elif key_list[1] == 'resblocks':
+                new_layer_name = 'layers'
+                layer_index = key_list[2]
+                paras = key_list[3:]
+                if paras[0] == 'ln_1':
+                    new_para_name = '.'.join(['norms.0'] + paras[1:])
+                elif paras[0] == 'attn':
+                    new_para_name = '.'.join(['attentions.0.attn'] + paras[1:])
+                elif paras[0] == 'ln_2':
+                    new_para_name = '.'.join(['norms.1'] + paras[1:])
+                elif paras[0] == 'mlp':
+                    if paras[1] == 'c_fc':
+                        new_para_name = '.'.join(['ffns.0.layers.0.0'] +
+                                                 paras[2:])
+                    elif paras[1] == 'c_proj':
+                        new_para_name = '.'.join(['ffns.0.layers.1'] +
+                                                 paras[2:])
+                    else:
+                        print(f'Wrong for {k}')
+                new_name = '.'.join([
+                    decode_head_name, module_name, new_layer_name, layer_index,
+                    new_para_name
+                ])
+            else:
+                print(f'Wrong for {k}')
+        elif key_list[0] == 'ov_classifier':
+            text_encoder_name = 'text_encoder'
+            if key_list[1] == 'transformer':
+                layer_name = 'transformer'
+                layer_index = key_list[3]
+                paras = key_list[4:]
+                if paras[0] == 'attn':
+                    new_para_name = '.'.join(['attentions.0.attn'] + paras[1:])
+                elif paras[0] == 'ln_1':
+                    new_para_name = '.'.join(['norms.0'] + paras[1:])
+                elif paras[0] == 'ln_2':
+                    new_para_name = '.'.join(['norms.1'] + paras[1:])
+                elif paras[0] == 'mlp':
+                    if paras[1] == 'c_fc':
+                        new_para_name = '.'.join(['ffns.0.layers.0.0'] +
+                                                 paras[2:])
+                    elif paras[1] == 'c_proj':
+                        new_para_name = '.'.join(['ffns.0.layers.1'] +
+                                                 paras[2:])
+                    else:
+                        print(f'Wrong for {k}')
+                else:
+                    print(f'Wrong for {k}')
+                new_name = '.'.join([
+                    text_encoder_name, layer_name, layer_index, new_para_name
+                ])
+            elif key_list[1] in [
+                    'positional_embedding', 'text_projection', 'bg_embed',
+                    'attn_mask', 'logit_scale', 'token_embedding', 'ln_final'
+            ]:
+                new_name = k.replace('ov_classifier', 'text_encoder')
+            else:
+                print(f'Wrong for {k}')
+        elif key_list[0] == 'criterion':
+            new_name = k
+        else:
+            print(f'Wrong for {k}')
+        new_ckpt[new_name] = v
+    return new_ckpt
+
+
+def convert_tensor(ckpt):
+    cls_token = ckpt['image_encoder.cls_token']
+    new_cls_token = cls_token.unsqueeze(0).unsqueeze(0)
+    ckpt['image_encoder.cls_token'] = new_cls_token
+    pos_embed = ckpt['image_encoder.pos_embed']
+    new_pos_embed = pos_embed.unsqueeze(0)
+    ckpt['image_encoder.pos_embed'] = new_pos_embed
+    proj_weight = ckpt['decode_head.rec_with_attnbias.proj.weight']
+    new_proj_weight = proj_weight.transpose(1, 0)
+    ckpt['decode_head.rec_with_attnbias.proj.weight'] = new_proj_weight
+    return ckpt
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Convert keys in timm pretrained vit models to '
+        'MMSegmentation style.')
+    parser.add_argument('src', help='src model path or url')
+    # The dst path must be a full path of the new checkpoint.
+    parser.add_argument('dst', help='save path')
+    args = parser.parse_args()
+
+    checkpoint = CheckpointLoader.load_checkpoint(args.src, map_location='cpu')
+    if 'state_dict' in checkpoint:
+        # timm checkpoint
+        state_dict = checkpoint['state_dict']
+    elif 'model' in checkpoint:
+        # deit checkpoint
+        state_dict = checkpoint['model']
+    else:
+        state_dict = checkpoint
+    weight = convert_key_name(state_dict)
+    weight = convert_tensor(weight)
+    mmengine.mkdir_or_exist(osp.dirname(args.dst))
+    torch.save(weight, args.dst)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/model_converters/stdc2mmseg.py b/mmsegmentation/tools/model_converters/stdc2mmseg.py
new file mode 100644
index 0000000..6ea3b83
--- /dev/null
+++ b/mmsegmentation/tools/model_converters/stdc2mmseg.py
@@ -0,0 +1,71 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os.path as osp
+
+import mmengine
+import torch
+from mmengine.runner import CheckpointLoader
+
+
+def convert_stdc(ckpt, stdc_type):
+    new_state_dict = {}
+    if stdc_type == 'STDC1':
+        stage_lst = ['0', '1', '2.0', '2.1', '3.0', '3.1', '4.0', '4.1']
+    else:
+        stage_lst = [
+            '0', '1', '2.0', '2.1', '2.2', '2.3', '3.0', '3.1', '3.2', '3.3',
+            '3.4', '4.0', '4.1', '4.2'
+        ]
+    for k, v in ckpt.items():
+        ori_k = k
+        flag = False
+        if 'cp.' in k:
+            k = k.replace('cp.', '')
+        if 'features.' in k:
+            num_layer = int(k.split('.')[1])
+            feature_key_lst = 'features.' + str(num_layer) + '.'
+            stages_key_lst = 'stages.' + stage_lst[num_layer] + '.'
+            k = k.replace(feature_key_lst, stages_key_lst)
+            flag = True
+        if 'conv_list' in k:
+            k = k.replace('conv_list', 'layers')
+            flag = True
+        if 'avd_layer.' in k:
+            if 'avd_layer.0' in k:
+                k = k.replace('avd_layer.0', 'downsample.conv')
+            elif 'avd_layer.1' in k:
+                k = k.replace('avd_layer.1', 'downsample.bn')
+            flag = True
+        if flag:
+            new_state_dict[k] = ckpt[ori_k]
+
+    return new_state_dict
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Convert keys in official pretrained STDC1/2 to '
+        'MMSegmentation style.')
+    parser.add_argument('src', help='src model path')
+    # The dst path must be a full path of the new checkpoint.
+    parser.add_argument('dst', help='save path')
+    parser.add_argument('type', help='model type: STDC1 or STDC2')
+    args = parser.parse_args()
+
+    checkpoint = CheckpointLoader.load_checkpoint(args.src, map_location='cpu')
+    if 'state_dict' in checkpoint:
+        state_dict = checkpoint['state_dict']
+    elif 'model' in checkpoint:
+        state_dict = checkpoint['model']
+    else:
+        state_dict = checkpoint
+
+    assert args.type in ['STDC1',
+                         'STDC2'], 'STD type should be STDC1 or STDC2!'
+    weight = convert_stdc(state_dict, args.type)
+    mmengine.mkdir_or_exist(osp.dirname(args.dst))
+    torch.save(weight, args.dst)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/model_converters/swin2mmseg.py b/mmsegmentation/tools/model_converters/swin2mmseg.py
new file mode 100644
index 0000000..d434f94
--- /dev/null
+++ b/mmsegmentation/tools/model_converters/swin2mmseg.py
@@ -0,0 +1,87 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os.path as osp
+from collections import OrderedDict
+
+import mmengine
+import torch
+from mmengine.runner import CheckpointLoader
+
+
+def convert_swin(ckpt):
+    new_ckpt = OrderedDict()
+
+    def correct_unfold_reduction_order(x):
+        out_channel, in_channel = x.shape
+        x = x.reshape(out_channel, 4, in_channel // 4)
+        x = x[:, [0, 2, 1, 3], :].transpose(1,
+                                            2).reshape(out_channel, in_channel)
+        return x
+
+    def correct_unfold_norm_order(x):
+        in_channel = x.shape[0]
+        x = x.reshape(4, in_channel // 4)
+        x = x[[0, 2, 1, 3], :].transpose(0, 1).reshape(in_channel)
+        return x
+
+    for k, v in ckpt.items():
+        if k.startswith('head'):
+            continue
+        elif k.startswith('layers'):
+            new_v = v
+            if 'attn.' in k:
+                new_k = k.replace('attn.', 'attn.w_msa.')
+            elif 'mlp.' in k:
+                if 'mlp.fc1.' in k:
+                    new_k = k.replace('mlp.fc1.', 'ffn.layers.0.0.')
+                elif 'mlp.fc2.' in k:
+                    new_k = k.replace('mlp.fc2.', 'ffn.layers.1.')
+                else:
+                    new_k = k.replace('mlp.', 'ffn.')
+            elif 'downsample' in k:
+                new_k = k
+                if 'reduction.' in k:
+                    new_v = correct_unfold_reduction_order(v)
+                elif 'norm.' in k:
+                    new_v = correct_unfold_norm_order(v)
+            else:
+                new_k = k
+            new_k = new_k.replace('layers', 'stages', 1)
+        elif k.startswith('patch_embed'):
+            new_v = v
+            if 'proj' in k:
+                new_k = k.replace('proj', 'projection')
+            else:
+                new_k = k
+        else:
+            new_v = v
+            new_k = k
+
+        new_ckpt[new_k] = new_v
+
+    return new_ckpt
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Convert keys in official pretrained swin models to'
+        'MMSegmentation style.')
+    parser.add_argument('src', help='src model path or url')
+    # The dst path must be a full path of the new checkpoint.
+    parser.add_argument('dst', help='save path')
+    args = parser.parse_args()
+
+    checkpoint = CheckpointLoader.load_checkpoint(args.src, map_location='cpu')
+    if 'state_dict' in checkpoint:
+        state_dict = checkpoint['state_dict']
+    elif 'model' in checkpoint:
+        state_dict = checkpoint['model']
+    else:
+        state_dict = checkpoint
+    weight = convert_swin(state_dict)
+    mmengine.mkdir_or_exist(osp.dirname(args.dst))
+    torch.save(weight, args.dst)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/model_converters/twins2mmseg.py b/mmsegmentation/tools/model_converters/twins2mmseg.py
new file mode 100644
index 0000000..647d417
--- /dev/null
+++ b/mmsegmentation/tools/model_converters/twins2mmseg.py
@@ -0,0 +1,87 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os.path as osp
+from collections import OrderedDict
+
+import mmengine
+import torch
+from mmengine.runner import CheckpointLoader
+
+
+def convert_twins(args, ckpt):
+
+    new_ckpt = OrderedDict()
+
+    for k, v in list(ckpt.items()):
+        new_v = v
+        if k.startswith('head'):
+            continue
+        elif k.startswith('patch_embeds'):
+            if 'proj.' in k:
+                new_k = k.replace('proj.', 'projection.')
+            else:
+                new_k = k
+        elif k.startswith('blocks'):
+            # Union
+            if 'attn.q.' in k:
+                new_k = k.replace('q.', 'attn.in_proj_')
+                new_v = torch.cat([v, ckpt[k.replace('attn.q.', 'attn.kv.')]],
+                                  dim=0)
+            elif 'mlp.fc1' in k:
+                new_k = k.replace('mlp.fc1', 'ffn.layers.0.0')
+            elif 'mlp.fc2' in k:
+                new_k = k.replace('mlp.fc2', 'ffn.layers.1')
+            # Only pcpvt
+            elif args.model == 'pcpvt':
+                if 'attn.proj.' in k:
+                    new_k = k.replace('proj.', 'attn.out_proj.')
+                else:
+                    new_k = k
+
+            # Only svt
+            else:
+                if 'attn.proj.' in k:
+                    k_lst = k.split('.')
+                    if int(k_lst[2]) % 2 == 1:
+                        new_k = k.replace('proj.', 'attn.out_proj.')
+                    else:
+                        new_k = k
+                else:
+                    new_k = k
+            new_k = new_k.replace('blocks.', 'layers.')
+        elif k.startswith('pos_block'):
+            new_k = k.replace('pos_block', 'position_encodings')
+            if 'proj.0.' in new_k:
+                new_k = new_k.replace('proj.0.', 'proj.')
+        else:
+            new_k = k
+        if 'attn.kv.' not in k:
+            new_ckpt[new_k] = new_v
+    return new_ckpt
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Convert keys in timm pretrained vit models to '
+        'MMSegmentation style.')
+    parser.add_argument('src', help='src model path or url')
+    # The dst path must be a full path of the new checkpoint.
+    parser.add_argument('dst', help='save path')
+    parser.add_argument('model', help='model: pcpvt or svt')
+    args = parser.parse_args()
+
+    checkpoint = CheckpointLoader.load_checkpoint(args.src, map_location='cpu')
+
+    if 'state_dict' in checkpoint:
+        # timm checkpoint
+        state_dict = checkpoint['state_dict']
+    else:
+        state_dict = checkpoint
+
+    weight = convert_twins(args, state_dict)
+    mmengine.mkdir_or_exist(osp.dirname(args.dst))
+    torch.save(weight, args.dst)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/model_converters/vit2mmseg.py b/mmsegmentation/tools/model_converters/vit2mmseg.py
new file mode 100644
index 0000000..1d1f8a4
--- /dev/null
+++ b/mmsegmentation/tools/model_converters/vit2mmseg.py
@@ -0,0 +1,70 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os.path as osp
+from collections import OrderedDict
+
+import mmengine
+import torch
+from mmengine.runner import CheckpointLoader
+
+
+def convert_vit(ckpt):
+
+    new_ckpt = OrderedDict()
+
+    for k, v in ckpt.items():
+        if k.startswith('head'):
+            continue
+        if k.startswith('norm'):
+            new_k = k.replace('norm.', 'ln1.')
+        elif k.startswith('patch_embed'):
+            if 'proj' in k:
+                new_k = k.replace('proj', 'projection')
+            else:
+                new_k = k
+        elif k.startswith('blocks'):
+            if 'norm' in k:
+                new_k = k.replace('norm', 'ln')
+            elif 'mlp.fc1' in k:
+                new_k = k.replace('mlp.fc1', 'ffn.layers.0.0')
+            elif 'mlp.fc2' in k:
+                new_k = k.replace('mlp.fc2', 'ffn.layers.1')
+            elif 'attn.qkv' in k:
+                new_k = k.replace('attn.qkv.', 'attn.attn.in_proj_')
+            elif 'attn.proj' in k:
+                new_k = k.replace('attn.proj', 'attn.attn.out_proj')
+            else:
+                new_k = k
+            new_k = new_k.replace('blocks.', 'layers.')
+        else:
+            new_k = k
+        new_ckpt[new_k] = v
+
+    return new_ckpt
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Convert keys in timm pretrained vit models to '
+        'MMSegmentation style.')
+    parser.add_argument('src', help='src model path or url')
+    # The dst path must be a full path of the new checkpoint.
+    parser.add_argument('dst', help='save path')
+    args = parser.parse_args()
+
+    checkpoint = CheckpointLoader.load_checkpoint(args.src, map_location='cpu')
+    if 'state_dict' in checkpoint:
+        # timm checkpoint
+        state_dict = checkpoint['state_dict']
+    elif 'model' in checkpoint:
+        # deit checkpoint
+        state_dict = checkpoint['model']
+    else:
+        state_dict = checkpoint
+    weight = convert_vit(state_dict)
+    mmengine.mkdir_or_exist(osp.dirname(args.dst))
+    torch.save(weight, args.dst)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/model_converters/vitjax2mmseg.py b/mmsegmentation/tools/model_converters/vitjax2mmseg.py
new file mode 100644
index 0000000..81bc2ea
--- /dev/null
+++ b/mmsegmentation/tools/model_converters/vitjax2mmseg.py
@@ -0,0 +1,123 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os.path as osp
+
+import mmengine
+import numpy as np
+import torch
+
+
+def vit_jax_to_torch(jax_weights, num_layer=12):
+    torch_weights = dict()
+
+    # patch embedding
+    conv_filters = jax_weights['embedding/kernel']
+    conv_filters = conv_filters.permute(3, 2, 0, 1)
+    torch_weights['patch_embed.projection.weight'] = conv_filters
+    torch_weights['patch_embed.projection.bias'] = jax_weights[
+        'embedding/bias']
+
+    # pos embedding
+    torch_weights['pos_embed'] = jax_weights[
+        'Transformer/posembed_input/pos_embedding']
+
+    # cls token
+    torch_weights['cls_token'] = jax_weights['cls']
+
+    # head
+    torch_weights['ln1.weight'] = jax_weights['Transformer/encoder_norm/scale']
+    torch_weights['ln1.bias'] = jax_weights['Transformer/encoder_norm/bias']
+
+    # transformer blocks
+    for i in range(num_layer):
+        jax_block = f'Transformer/encoderblock_{i}'
+        torch_block = f'layers.{i}'
+
+        # attention norm
+        torch_weights[f'{torch_block}.ln1.weight'] = jax_weights[
+            f'{jax_block}/LayerNorm_0/scale']
+        torch_weights[f'{torch_block}.ln1.bias'] = jax_weights[
+            f'{jax_block}/LayerNorm_0/bias']
+
+        # attention
+        query_weight = jax_weights[
+            f'{jax_block}/MultiHeadDotProductAttention_1/query/kernel']
+        query_bias = jax_weights[
+            f'{jax_block}/MultiHeadDotProductAttention_1/query/bias']
+        key_weight = jax_weights[
+            f'{jax_block}/MultiHeadDotProductAttention_1/key/kernel']
+        key_bias = jax_weights[
+            f'{jax_block}/MultiHeadDotProductAttention_1/key/bias']
+        value_weight = jax_weights[
+            f'{jax_block}/MultiHeadDotProductAttention_1/value/kernel']
+        value_bias = jax_weights[
+            f'{jax_block}/MultiHeadDotProductAttention_1/value/bias']
+
+        qkv_weight = torch.from_numpy(
+            np.stack((query_weight, key_weight, value_weight), 1))
+        qkv_weight = torch.flatten(qkv_weight, start_dim=1)
+        qkv_bias = torch.from_numpy(
+            np.stack((query_bias, key_bias, value_bias), 0))
+        qkv_bias = torch.flatten(qkv_bias, start_dim=0)
+
+        torch_weights[f'{torch_block}.attn.attn.in_proj_weight'] = qkv_weight
+        torch_weights[f'{torch_block}.attn.attn.in_proj_bias'] = qkv_bias
+        to_out_weight = jax_weights[
+            f'{jax_block}/MultiHeadDotProductAttention_1/out/kernel']
+        to_out_weight = torch.flatten(to_out_weight, start_dim=0, end_dim=1)
+        torch_weights[
+            f'{torch_block}.attn.attn.out_proj.weight'] = to_out_weight
+        torch_weights[f'{torch_block}.attn.attn.out_proj.bias'] = jax_weights[
+            f'{jax_block}/MultiHeadDotProductAttention_1/out/bias']
+
+        # mlp norm
+        torch_weights[f'{torch_block}.ln2.weight'] = jax_weights[
+            f'{jax_block}/LayerNorm_2/scale']
+        torch_weights[f'{torch_block}.ln2.bias'] = jax_weights[
+            f'{jax_block}/LayerNorm_2/bias']
+
+        # mlp
+        torch_weights[f'{torch_block}.ffn.layers.0.0.weight'] = jax_weights[
+            f'{jax_block}/MlpBlock_3/Dense_0/kernel']
+        torch_weights[f'{torch_block}.ffn.layers.0.0.bias'] = jax_weights[
+            f'{jax_block}/MlpBlock_3/Dense_0/bias']
+        torch_weights[f'{torch_block}.ffn.layers.1.weight'] = jax_weights[
+            f'{jax_block}/MlpBlock_3/Dense_1/kernel']
+        torch_weights[f'{torch_block}.ffn.layers.1.bias'] = jax_weights[
+            f'{jax_block}/MlpBlock_3/Dense_1/bias']
+
+    # transpose weights
+    for k, v in torch_weights.items():
+        if 'weight' in k and 'patch_embed' not in k and 'ln' not in k:
+            v = v.permute(1, 0)
+        torch_weights[k] = v
+
+    return torch_weights
+
+
+def main():
+    # stole refactoring code from Robin Strudel, thanks
+    parser = argparse.ArgumentParser(
+        description='Convert keys from jax official pretrained vit models to '
+        'MMSegmentation style.')
+    parser.add_argument('src', help='src model path or url')
+    # The dst path must be a full path of the new checkpoint.
+    parser.add_argument('dst', help='save path')
+    args = parser.parse_args()
+
+    jax_weights = np.load(args.src)
+    jax_weights_tensor = {}
+    for key in jax_weights.files:
+        value = torch.from_numpy(jax_weights[key])
+        jax_weights_tensor[key] = value
+    if 'L_16-i21k' in args.src:
+        num_layer = 24
+    else:
+        num_layer = 12
+    torch_weights = vit_jax_to_torch(jax_weights_tensor, num_layer)
+    mmengine.mkdir_or_exist(osp.dirname(args.dst))
+    torch.save(torch_weights, args.dst)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/slurm_test.sh b/mmsegmentation/tools/slurm_test.sh
new file mode 100755
index 0000000..4e6f7bf
--- /dev/null
+++ b/mmsegmentation/tools/slurm_test.sh
@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+
+set -x
+
+PARTITION=$1
+JOB_NAME=$2
+CONFIG=$3
+CHECKPOINT=$4
+GPUS=${GPUS:-4}
+GPUS_PER_NODE=${GPUS_PER_NODE:-4}
+CPUS_PER_TASK=${CPUS_PER_TASK:-5}
+PY_ARGS=${@:5}
+SRUN_ARGS=${SRUN_ARGS:-""}
+
+PYTHONPATH="$(dirname $0)/..":$PYTHONPATH \
+srun -p ${PARTITION} \
+    --job-name=${JOB_NAME} \
+    --gres=gpu:${GPUS_PER_NODE} \
+    --ntasks=${GPUS} \
+    --ntasks-per-node=${GPUS_PER_NODE} \
+    --cpus-per-task=${CPUS_PER_TASK} \
+    --kill-on-bad-exit=1 \
+    ${SRUN_ARGS} \
+    python -u tools/test.py ${CONFIG} ${CHECKPOINT} --launcher="slurm" ${PY_ARGS}
diff --git a/mmsegmentation/tools/slurm_train.sh b/mmsegmentation/tools/slurm_train.sh
new file mode 100755
index 0000000..ab23210
--- /dev/null
+++ b/mmsegmentation/tools/slurm_train.sh
@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+
+set -x
+
+PARTITION=$1
+JOB_NAME=$2
+CONFIG=$3
+GPUS=${GPUS:-4}
+GPUS_PER_NODE=${GPUS_PER_NODE:-4}
+CPUS_PER_TASK=${CPUS_PER_TASK:-5}
+SRUN_ARGS=${SRUN_ARGS:-""}
+PY_ARGS=${@:4}
+
+PYTHONPATH="$(dirname $0)/..":$PYTHONPATH \
+srun -p ${PARTITION} \
+    --job-name=${JOB_NAME} \
+    --gres=gpu:${GPUS_PER_NODE} \
+    --ntasks=${GPUS} \
+    --ntasks-per-node=${GPUS_PER_NODE} \
+    --cpus-per-task=${CPUS_PER_TASK} \
+    --kill-on-bad-exit=1 \
+    ${SRUN_ARGS} \
+    python -u tools/train.py ${CONFIG} --launcher="slurm" ${PY_ARGS}
diff --git a/mmsegmentation/tools/test.py b/mmsegmentation/tools/test.py
new file mode 100644
index 0000000..0d7f39b
--- /dev/null
+++ b/mmsegmentation/tools/test.py
@@ -0,0 +1,123 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os
+import os.path as osp
+
+from mmengine.config import Config, DictAction
+from mmengine.runner import Runner
+
+
+# TODO: support fuse_conv_bn, visualization, and format_only
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='MMSeg test (and eval) a model')
+    parser.add_argument('config', help='train config file path')
+    parser.add_argument('checkpoint', help='checkpoint file')
+    parser.add_argument(
+        '--work-dir',
+        help=('if specified, the evaluation metric results will be dumped'
+              'into the directory as json'))
+    parser.add_argument(
+        '--out',
+        type=str,
+        help='The directory to save output prediction for offline evaluation')
+    parser.add_argument(
+        '--show', action='store_true', help='show prediction results')
+    parser.add_argument(
+        '--show-dir',
+        help='directory where painted images will be saved. '
+        'If specified, it will be automatically saved '
+        'to the work_dir/timestamp/show_dir')
+    parser.add_argument(
+        '--wait-time', type=float, default=2, help='the interval of show (s)')
+    parser.add_argument(
+        '--cfg-options',
+        nargs='+',
+        action=DictAction,
+        help='override some settings in the used config, the key-value pair '
+        'in xxx=yyy format will be merged into config file. If the value to '
+        'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
+        'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
+        'Note that the quotation marks are necessary and that no white space '
+        'is allowed.')
+    parser.add_argument(
+        '--launcher',
+        choices=['none', 'pytorch', 'slurm', 'mpi'],
+        default='none',
+        help='job launcher')
+    parser.add_argument(
+        '--tta', action='store_true', help='Test time augmentation')
+    # When using PyTorch version >= 2.0.0, the `torch.distributed.launch`
+    # will pass the `--local-rank` parameter to `tools/train.py` instead
+    # of `--local_rank`.
+    parser.add_argument('--local_rank', '--local-rank', type=int, default=0)
+    args = parser.parse_args()
+    if 'LOCAL_RANK' not in os.environ:
+        os.environ['LOCAL_RANK'] = str(args.local_rank)
+
+    return args
+
+
+def trigger_visualization_hook(cfg, args):
+    default_hooks = cfg.default_hooks
+    if 'visualization' in default_hooks:
+        visualization_hook = default_hooks['visualization']
+        # Turn on visualization
+        visualization_hook['draw'] = True
+        if args.show:
+            visualization_hook['show'] = True
+            visualization_hook['wait_time'] = args.wait_time
+        if args.show_dir:
+            visualizer = cfg.visualizer
+            visualizer['save_dir'] = args.show_dir
+    else:
+        raise RuntimeError(
+            'VisualizationHook must be included in default_hooks.'
+            'refer to usage '
+            '"visualization=dict(type=\'VisualizationHook\')"')
+
+    return cfg
+
+
+def main():
+    args = parse_args()
+
+    # load config
+    cfg = Config.fromfile(args.config)
+    cfg.launcher = args.launcher
+    if args.cfg_options is not None:
+        cfg.merge_from_dict(args.cfg_options)
+
+    # work_dir is determined in this priority: CLI > segment in file > filename
+    if args.work_dir is not None:
+        # update configs according to CLI args if args.work_dir is not None
+        cfg.work_dir = args.work_dir
+    elif cfg.get('work_dir', None) is None:
+        # use config filename as default work_dir if cfg.work_dir is None
+        cfg.work_dir = osp.join('./work_dirs',
+                                osp.splitext(osp.basename(args.config))[0])
+
+    cfg.load_from = args.checkpoint
+
+    if args.show or args.show_dir:
+        cfg = trigger_visualization_hook(cfg, args)
+
+    if args.tta:
+        cfg.test_dataloader.dataset.pipeline = cfg.tta_pipeline
+        cfg.tta_model.module = cfg.model
+        cfg.model = cfg.tta_model
+
+    # add output_dir in metric
+    if args.out is not None:
+        cfg.test_evaluator['output_dir'] = args.out
+        cfg.test_evaluator['keep_results'] = True
+
+    # build the runner from config
+    runner = Runner.from_cfg(cfg)
+
+    # start testing
+    runner.test()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmsegmentation/tools/torchserve/mmseg2torchserve.py b/mmsegmentation/tools/torchserve/mmseg2torchserve.py
new file mode 100644
index 0000000..23f9963
--- /dev/null
+++ b/mmsegmentation/tools/torchserve/mmseg2torchserve.py
@@ -0,0 +1,112 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from argparse import ArgumentParser, Namespace
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+from mmengine import Config
+from mmengine.utils import mkdir_or_exist
+
+try:
+    from model_archiver.model_packaging import package_model
+    from model_archiver.model_packaging_utils import ModelExportUtils
+except ImportError:
+    package_model = None
+
+
+def mmseg2torchserve(
+    config_file: str,
+    checkpoint_file: str,
+    output_folder: str,
+    model_name: str,
+    model_version: str = '1.0',
+    force: bool = False,
+):
+    """Converts mmsegmentation model (config + checkpoint) to TorchServe
+    `.mar`.
+
+    Args:
+        config_file:
+            In MMSegmentation config format.
+            The contents vary for each task repository.
+        checkpoint_file:
+            In MMSegmentation checkpoint format.
+            The contents vary for each task repository.
+        output_folder:
+            Folder where `{model_name}.mar` will be created.
+            The file created will be in TorchServe archive format.
+        model_name:
+            If not None, used for naming the `{model_name}.mar` file
+            that will be created under `output_folder`.
+            If None, `{Path(checkpoint_file).stem}` will be used.
+        model_version:
+            Model's version.
+        force:
+            If True, if there is an existing `{model_name}.mar`
+            file under `output_folder` it will be overwritten.
+    """
+    mkdir_or_exist(output_folder)
+
+    config = Config.fromfile(config_file)
+
+    with TemporaryDirectory() as tmpdir:
+        config.dump(f'{tmpdir}/config.py')
+
+        args = Namespace(
+            **{
+                'model_file': f'{tmpdir}/config.py',
+                'serialized_file': checkpoint_file,
+                'handler': f'{Path(__file__).parent}/mmseg_handler.py',
+                'model_name': model_name or Path(checkpoint_file).stem,
+                'version': model_version,
+                'export_path': output_folder,
+                'force': force,
+                'requirements_file': None,
+                'extra_files': None,
+                'runtime': 'python',
+                'archive_format': 'default'
+            })
+        manifest = ModelExportUtils.generate_manifest_json(args)
+        package_model(args, manifest)
+
+
+def parse_args():
+    parser = ArgumentParser(
+        description='Convert mmseg models to TorchServe `.mar` format.')
+    parser.add_argument('config', type=str, help='config file path')
+    parser.add_argument('checkpoint', type=str, help='checkpoint file path')
+    parser.add_argument(
+        '--output-folder',
+        type=str,
+        required=True,
+        help='Folder where `{model_name}.mar` will be created.')
+    parser.add_argument(
+        '--model-name',
+        type=str,
+        default=None,
+        help='If not None, used for naming the `{model_name}.mar`'
+        'file that will be created under `output_folder`.'
+        'If None, `{Path(checkpoint_file).stem}` will be used.')
+    parser.add_argument(
+        '--model-version',
+        type=str,
+        default='1.0',
+        help='Number used for versioning.')
+    parser.add_argument(
+        '-f',
+        '--force',
+        action='store_true',
+        help='overwrite the existing `{model_name}.mar`')
+    args = parser.parse_args()
+
+    return args
+
+
+if __name__ == '__main__':
+    args = parse_args()
+
+    if package_model is None:
+        raise ImportError('`torch-model-archiver` is required.'
+                          'Try: pip install torch-model-archiver')
+
+    mmseg2torchserve(args.config, args.checkpoint, args.output_folder,
+                     args.model_name, args.model_version, args.force)
diff --git a/mmsegmentation/tools/torchserve/mmseg_handler.py b/mmsegmentation/tools/torchserve/mmseg_handler.py
new file mode 100644
index 0000000..dbe5ded
--- /dev/null
+++ b/mmsegmentation/tools/torchserve/mmseg_handler.py
@@ -0,0 +1,56 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import base64
+import os
+
+import cv2
+import mmcv
+import torch
+from mmengine.model.utils import revert_sync_batchnorm
+from ts.torch_handler.base_handler import BaseHandler
+
+from mmseg.apis import inference_model, init_model
+
+
+class MMsegHandler(BaseHandler):
+
+    def initialize(self, context):
+        properties = context.system_properties
+        self.map_location = 'cuda' if torch.cuda.is_available() else 'cpu'
+        self.device = torch.device(self.map_location + ':' +
+                                   str(properties.get('gpu_id')) if torch.cuda.
+                                   is_available() else self.map_location)
+        self.manifest = context.manifest
+
+        model_dir = properties.get('model_dir')
+        serialized_file = self.manifest['model']['serializedFile']
+        checkpoint = os.path.join(model_dir, serialized_file)
+        self.config_file = os.path.join(model_dir, 'config.py')
+
+        self.model = init_model(self.config_file, checkpoint, self.device)
+        self.model = revert_sync_batchnorm(self.model)
+        self.initialized = True
+
+    def preprocess(self, data):
+        images = []
+
+        for row in data:
+            image = row.get('data') or row.get('body')
+            if isinstance(image, str):
+                image = base64.b64decode(image)
+            image = mmcv.imfrombytes(image)
+            images.append(image)
+
+        return images
+
+    def inference(self, data, *args, **kwargs):
+        results = [inference_model(self.model, img) for img in data]
+        return results
+
+    def postprocess(self, data):
+        output = []
+
+        for image_result in data:
+            _, buffer = cv2.imencode('.png', image_result[0].astype('uint8'))
+            content = buffer.tobytes()
+            output.append(content)
+        return output
diff --git a/mmsegmentation/tools/torchserve/test_torchserve.py b/mmsegmentation/tools/torchserve/test_torchserve.py
new file mode 100644
index 0000000..b015b66
--- /dev/null
+++ b/mmsegmentation/tools/torchserve/test_torchserve.py
@@ -0,0 +1,58 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from argparse import ArgumentParser
+from io import BytesIO
+
+import matplotlib.pyplot as plt
+import mmcv
+import requests
+
+from mmseg.apis import inference_model, init_model
+
+
+def parse_args():
+    parser = ArgumentParser(
+        description='Compare result of torchserve and pytorch,'
+        'and visualize them.')
+    parser.add_argument('img', help='Image file')
+    parser.add_argument('config', help='Config file')
+    parser.add_argument('checkpoint', help='Checkpoint file')
+    parser.add_argument('model_name', help='The model name in the server')
+    parser.add_argument(
+        '--inference-addr',
+        default='127.0.0.1:8080',
+        help='Address and port of the inference server')
+    parser.add_argument(
+        '--result-image',
+        type=str,
+        default=None,
+        help='save server output in result-image')
+    parser.add_argument(
+        '--device', default='cuda:0', help='Device used for inference')
+
+    args = parser.parse_args()
+    return args
+
+
+def main(args):
+    url = 'http://' + args.inference_addr + '/predictions/' + args.model_name
+    with open(args.img, 'rb') as image:
+        tmp_res = requests.post(url, image)
+    content = tmp_res.content
+    if args.result_image:
+        with open(args.result_image, 'wb') as out_image:
+            out_image.write(content)
+        plt.imshow(mmcv.imread(args.result_image, 'grayscale'))
+        plt.show()
+    else:
+        plt.imshow(plt.imread(BytesIO(content)))
+        plt.show()
+    model = init_model(args.config, args.checkpoint, args.device)
+    image = mmcv.imread(args.img)
+    result = inference_model(model, image)
+    plt.imshow(result[0])
+    plt.show()
+
+
+if __name__ == '__main__':
+    args = parse_args()
+    main(args)
diff --git a/mmsegmentation/tools/train.py b/mmsegmentation/tools/train.py
new file mode 100644
index 0000000..10fdaa1
--- /dev/null
+++ b/mmsegmentation/tools/train.py
@@ -0,0 +1,104 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import logging
+import os
+import os.path as osp
+
+from mmengine.config import Config, DictAction
+from mmengine.logging import print_log
+from mmengine.runner import Runner
+
+from mmseg.registry import RUNNERS
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Train a segmentor')
+    parser.add_argument('config', help='train config file path')
+    parser.add_argument('--work-dir', help='the dir to save logs and models')
+    parser.add_argument(
+        '--resume',
+        action='store_true',
+        default=False,
+        help='resume from the latest checkpoint in the work_dir automatically')
+    parser.add_argument(
+        '--amp',
+        action='store_true',
+        default=False,
+        help='enable automatic-mixed-precision training')
+    parser.add_argument(
+        '--cfg-options',
+        nargs='+',
+        action=DictAction,
+        help='override some settings in the used config, the key-value pair '
+        'in xxx=yyy format will be merged into config file. If the value to '
+        'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
+        'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
+        'Note that the quotation marks are necessary and that no white space '
+        'is allowed.')
+    parser.add_argument(
+        '--launcher',
+        choices=['none', 'pytorch', 'slurm', 'mpi'],
+        default='none',
+        help='job launcher')
+    # When using PyTorch version >= 2.0.0, the `torch.distributed.launch`
+    # will pass the `--local-rank` parameter to `tools/train.py` instead
+    # of `--local_rank`.
+    parser.add_argument('--local_rank', '--local-rank', type=int, default=0)
+    args = parser.parse_args()
+    if 'LOCAL_RANK' not in os.environ:
+        os.environ['LOCAL_RANK'] = str(args.local_rank)
+
+    return args
+
+
+def main():
+    args = parse_args()
+
+    # load config
+    cfg = Config.fromfile(args.config)
+    cfg.launcher = args.launcher
+    if args.cfg_options is not None:
+        cfg.merge_from_dict(args.cfg_options)
+
+    # work_dir is determined in this priority: CLI > segment in file > filename
+    if args.work_dir is not None:
+        # update configs according to CLI args if args.work_dir is not None
+        cfg.work_dir = args.work_dir
+    elif cfg.get('work_dir', None) is None:
+        # use config filename as default work_dir if cfg.work_dir is None
+        cfg.work_dir = osp.join('./work_dirs',
+                                osp.splitext(osp.basename(args.config))[0])
+
+    # enable automatic-mixed-precision training
+    if args.amp is True:
+        optim_wrapper = cfg.optim_wrapper.type
+        if optim_wrapper == 'AmpOptimWrapper':
+            print_log(
+                'AMP training is already enabled in your config.',
+                logger='current',
+                level=logging.WARNING)
+        else:
+            assert optim_wrapper == 'OptimWrapper', (
+                '`--amp` is only supported when the optimizer wrapper type is '
+                f'`OptimWrapper` but got {optim_wrapper}.')
+            cfg.optim_wrapper.type = 'AmpOptimWrapper'
+            cfg.optim_wrapper.loss_scale = 'dynamic'
+
+    # resume training
+    cfg.resume = args.resume
+
+    # build the runner from config
+    if 'runner_type' not in cfg:
+        # build the default runner
+        runner = Runner.from_cfg(cfg)
+    else:
+        # build customized runner from the registry
+        # if 'runner_type' is set in the cfg
+        runner = RUNNERS.build(cfg)
+
+    # start training
+    runner.train()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/utils/ufo_to_cityscapes.py b/utils/ufo_to_cityscapes.py
new file mode 100644
index 0000000..d11a4f0
--- /dev/null
+++ b/utils/ufo_to_cityscapes.py
@@ -0,0 +1,168 @@
+import os
+import shutil
+import json
+from PIL import Image, ImageDraw
+from sklearn.model_selection import GroupKFold
+from tqdm import tqdm
+
+# 기본 경로 설정
+input_dir = '/data/ephemeral/home/data'
+output_dir = '/data/ephemeral/home/cityscapes_format_xlay'
+n_splits = 5  # GroupKFold의 분할 개수
+
+CLASSES = [
+    'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
+    'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
+    'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
+    'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
+    'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
+    'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
+]
+CLASS2IND = {v: i+1 for i, v in enumerate(CLASSES)}
+IND2CLASS = {v: k for k, v in CLASS2IND.items()}
+PALETTE = [
+    (220, 20, 60), (119, 11, 32), (0, 0, 142), (0, 0, 230), (106, 0, 228),
+    (0, 60, 100), (0, 80, 100), (0, 0, 70), (0, 0, 192), (250, 170, 30),
+    (100, 170, 30), (220, 220, 0), (175, 116, 175), (250, 0, 30), (165, 42, 42),
+    (255, 77, 255), (0, 226, 252), (182, 182, 255), (0, 82, 0), (120, 166, 157),
+    (110, 76, 0), (174, 57, 255), (199, 100, 0), (72, 0, 118), (255, 179, 240),
+    (0, 125, 92), (209, 0, 151), (188, 208, 182), (0, 220, 176),
+]
+
+# 경로 생성
+def create_cityscapes_dirs():
+    for split in ['train', 'val', 'test']:
+        os.makedirs(os.path.join(output_dir, 'leftImg8bit', split), exist_ok=True)
+        os.makedirs(os.path.join(output_dir, 'gtFine', split), exist_ok=True)
+
+# JSON 파일을 읽어 label 및 instance 마스크 생성
+def create_masks(json_file, img_shape, label_map):
+    with open(json_file, 'r') as f:
+        annotations = json.load(f)["annotations"]
+    
+    label_mask = Image.new("L", img_shape, 0)
+    instance_mask = Image.new("I", img_shape, 0)  # "I" 모드는 32비트 정수 이미지를 생성합니다.
+    color_mask = Image.new("RGB", img_shape, (0, 0, 0))
+    instance_id = 1
+
+    for ann in annotations:
+        label = ann['label']
+        if label not in label_map:
+            continue  # 정의된 클래스에 없는 경우 무시
+        points = ann['points']
+        
+        draw_label = ImageDraw.Draw(label_mask)
+        draw_instance = ImageDraw.Draw(instance_mask)
+        draw_color = ImageDraw.Draw(color_mask)
+        
+        # 폴리곤으로 그리기
+        label_id = label_map[label]
+        polygon = [tuple(p) for p in points]
+        draw_label.polygon(polygon, fill=label_map[label])
+        draw_instance.polygon(polygon, fill=instance_id)
+        draw_color.polygon(polygon, fill=tuple(PALETTE[label_id-1]))
+        instance_id += 1
+        
+    return label_mask, instance_mask, color_mask
+
+# 데이터 수집 함수
+def collect_data():
+    img_paths = []
+    json_paths = []
+    groups = []
+
+    train_image_dir = os.path.join(input_dir, 'train', 'DCM')
+    train_json_dir = os.path.join(input_dir, 'train', 'outputs_json')
+    
+    for id_folder in tqdm(os.listdir(train_image_dir), desc="Collecting Train Data"):
+        img_folder_path = os.path.join(train_image_dir, id_folder)
+        json_folder_path = os.path.join(train_json_dir, id_folder)
+
+        if not os.path.isdir(img_folder_path):
+            continue
+
+        for img_file in os.listdir(img_folder_path):
+            if img_file.endswith('.png'):
+                img_path = os.path.join(img_folder_path, img_file)
+                json_path = os.path.join(json_folder_path, f"{os.path.splitext(img_file)[0]}.json")
+                if os.path.exists(json_path):
+                    img_paths.append(img_path)
+                    json_paths.append(json_path)
+                    groups.append(id_folder)  # 그룹 ID로 폴더명을 사용
+
+    return img_paths, json_paths, groups
+
+# 데이터 분할 및 마스크 생성
+def split_and_create_masks(img_paths, json_paths, groups, label_map):
+    gkf = GroupKFold(n_splits=n_splits)
+    
+    for fold, (train_idx, val_idx) in enumerate(gkf.split(img_paths, groups=groups), start=1):
+        print(f"Processing fold {fold}")
+
+        for idx, split in zip([train_idx, val_idx], ['train', 'val']):
+            for i in tqdm(idx, desc=f"Creating masks for {split} in fold {fold}"):
+                img_path = img_paths[i]
+                json_path = json_paths[i]
+                id_folder = groups[i]
+                img_filename = os.path.basename(img_path)
+                
+                img = Image.open(img_path)
+                img_shape = img.size
+
+                # 마스크 생성
+                label_mask, instance_mask, color_mask = create_masks(json_path, img_shape, label_map)
+
+                # 저장 경로 설정
+                base_name = f"{id_folder}_{os.path.splitext(img_filename)[0]}_gtFine"
+                img_output_path = os.path.join(output_dir, 'leftImg8bit', split, f"{id_folder}_{img_filename}")
+                label_output_path = os.path.join(output_dir, 'gtFine', split, f"{base_name}_labelIds.png")
+                instance_output_path = os.path.join(output_dir, 'gtFine', split, f"{base_name}_instanceIds.png")
+                color_output_path = os.path.join(output_dir, 'gtFine', split, f"{base_name}_color.png")
+
+                # 파일 저장
+                img.save(img_output_path)
+                label_mask.save(label_output_path)
+                instance_mask.save(instance_output_path)
+                color_mask.save(color_output_path)
+        
+        break
+
+# 테스트 데이터 복사
+def copy_test_files():
+    test_image_dir = os.path.join(input_dir, 'test', 'DCM')
+    
+    for id_folder in tqdm(os.listdir(test_image_dir), desc="Copying Test Data"):
+        img_folder_path = os.path.join(test_image_dir, id_folder)
+        if not os.path.isdir(img_folder_path):
+            continue
+        
+        for img_file in os.listdir(img_folder_path):
+            if img_file.endswith('.png'):
+                img_path = os.path.join(img_folder_path, img_file)
+                
+                # Cityscapes 형식에 맞는 저장 경로 설정
+                img_output_path = os.path.join(output_dir, 'leftImg8bit', 'test', f"{id_folder}_{img_file}")
+                
+                # 파일 복사
+                shutil.copy(img_path, img_output_path)
+
+# 전체 실행 함수
+def convert_dataset():
+    # 클래스 이름과 ID 매핑
+    label_map = CLASS2IND
+
+    create_cityscapes_dirs()
+    
+    # Train 이미지, JSON 파일 경로 및 그룹 수집
+    img_paths, json_paths, groups = collect_data()
+    
+    # Train 데이터를 GroupKFold로 나누고 마스크 생성
+    split_and_create_masks(img_paths, json_paths, groups, label_map)
+    
+    # Test 데이터를 Cityscapes 구조로 복사
+    copy_test_files()
+    
+    print("Dataset conversion complete!")
+
+# 실행
+convert_dataset()

From 3015224c684824bc168946b594ae3d90721b970b Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Thu, 14 Nov 2024 15:13:08 +0000
Subject: [PATCH 017/106] =?UTF-8?q?[Feat]=20:=20=EC=9D=B4=EB=AF=B8?=
 =?UTF-8?q?=EC=A7=80=20=EC=8B=9C=EA=B0=81=ED=99=94=20=EA=B0=9C=EC=88=98=20?=
 =?UTF-8?q?=EC=B6=94=EA=B0=80?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 streamlit/main.py      |  8 ++--
 streamlit/visualize.py | 92 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 97 insertions(+), 3 deletions(-)
 create mode 100644 streamlit/visualize.py

diff --git a/streamlit/main.py b/streamlit/main.py
index 89beb52..930c932 100644
--- a/streamlit/main.py
+++ b/streamlit/main.py
@@ -1,5 +1,5 @@
 import streamlit as st
-import load, visualize_v1, visualize_v2
+import load, visualize
 
 info = {
     'image_root': "../../data/train/DCM",
@@ -45,11 +45,13 @@
         st.session_state.text = st.selectbox("select text", ["None", "Text"])
         st.session_state.anno = st.selectbox("select annotation", ['All'] + info['classes'])
         submit_button = st.form_submit_button("OK")
+    image_count = st.sidebar.slider('Select image count', 1, 4, 1)
     image_index = st.sidebar.slider('Select image index', 0, len(st.session_state.images)-2, 0)
-    image_index_input = st.sidebar.number_input('Enter image index', min_value=0, max_value=len(st.session_state.images)-2, value=image_index, step=2)
+    image_index_input = st.sidebar.number_input('Enter image index', min_value=0, max_value=len(st.session_state.images)-(2*image_count), value=image_index, step=2*image_count)
     if image_index != image_index_input:
         image_index = image_index_input
-    visualize_v2.show(info, st.session_state.images, st.session_state.labels, image_index, st.session_state.text, st.session_state.anno)
+    for i in range(image_index, image_index + 2 * image_count, 2):
+        visualize.show(info, st.session_state.images, st.session_state.labels, i, st.session_state.text, st.session_state.anno)
 
 if option == "validation":
     st.write("개발중입니다...")
diff --git a/streamlit/visualize.py b/streamlit/visualize.py
new file mode 100644
index 0000000..1a0fd4b
--- /dev/null
+++ b/streamlit/visualize.py
@@ -0,0 +1,92 @@
+import os
+import json
+import cv2
+import numpy as np
+import streamlit as st
+from PIL import Image
+
+def show(info, images, labels, id, text='None', anno='All'):
+    cols = st.columns(2)
+
+    image_path_left = os.path.join(info['image_root'].format('train'), images[id + 1])
+    image_left = Image.open(image_path_left).convert("RGB")
+    label_path_left = os.path.join(info['label_root'], labels[id + 1])
+    label_left = json.load(open(label_path_left))
+
+    image_path_right = os.path.join(info['image_root'].format('train'), images[id])
+    image_right = Image.open(image_path_right).convert("RGB")
+    label_path_right = os.path.join(info['label_root'], labels[id])
+    label_right = json.load(open(label_path_right))
+
+    mask_left = np.zeros((*image_left.size[::-1], 3), dtype=np.uint8)
+    for annot in label_left['annotations']:
+        points = np.array(annot['points'], dtype=np.int32)
+        class_name = annot['label']
+        if anno != 'All' and anno != class_name:
+            continue
+        if class_name.startswith('finger'):
+            color = info['color']['finger']
+        elif class_name in ['Trapezoid', 'Pisiform', 'Radius', 'Ulna']:
+            color = info['color'][class_name]
+        else:
+            color = info['color']['wrist']
+        
+        single_channel_mask = np.zeros(image_left.size[::-1], dtype=np.uint8)
+        cv2.fillPoly(single_channel_mask, [points], 1)
+
+        mask_left[single_channel_mask == 1] = color
+
+        if text == 'Text':
+            centroid_x = int(np.mean(points[:, 0]))
+            centroid_y = int(np.mean(points[:, 1]))
+            cv2.putText(
+                mask_left,
+                class_name,
+                (centroid_x, centroid_y),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                1,
+                (255, 255, 255),
+                4,
+                cv2.LINE_AA  # Line type
+            )
+        
+    overlay_image = cv2.addWeighted(np.array(image_left), 0.5, mask_left, 0.5, 0)
+    with cols[0]:
+        st.image(overlay_image, caption=images[id], use_container_width=True)
+
+    mask_right = np.zeros((*image_right.size[::-1], 3), dtype=np.uint8)
+    for annot in label_right['annotations']:
+        points = np.array(annot['points'], dtype=np.int32)
+        class_name = annot['label']
+        if anno != 'All' and anno != class_name:
+            continue
+        if class_name.startswith('finger'):
+            color = info['color']['finger']
+        elif class_name in ['Trapezoid', 'Pisiform', 'Radius', 'Ulna']:
+            color = info['color'][class_name]
+        else:
+            color = info['color']['wrist']
+        
+        single_channel_mask = np.zeros(image_right.size[::-1], dtype=np.uint8)
+        cv2.fillPoly(single_channel_mask, [points], 1)
+
+        mask_right[single_channel_mask == 1] = color
+
+        if text == 'Text':
+            centroid_x = int(np.mean(points[:, 0]))
+            centroid_y = int(np.mean(points[:, 1]))
+
+            cv2.putText(
+                mask_right,
+                class_name,
+                (centroid_x, centroid_y),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                1,
+                (255, 255, 255),
+                4,
+                cv2.LINE_AA  # Line type
+            )
+
+    overlay_image = cv2.addWeighted(np.array(image_right), 0.5, mask_right, 0.5, 0)
+    with cols[1]:
+        st.image(overlay_image, caption=images[id], use_container_width=True)
\ No newline at end of file

From 99196d0ce66ee3cf8eced64e8646b5bcb1ff86e7 Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Thu, 14 Nov 2024 15:13:43 +0000
Subject: [PATCH 018/106] =?UTF-8?q?[Refactor]=20:=20plotly=EB=A5=BC=20cv2?=
 =?UTF-8?q?=EB=A1=9C=20=EC=8B=9C=EA=B0=81=ED=99=94?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 streamlit/visualize_v1.py | 87 ---------------------------------------
 streamlit/visualize_v2.py | 86 --------------------------------------
 2 files changed, 173 deletions(-)
 delete mode 100644 streamlit/visualize_v1.py
 delete mode 100644 streamlit/visualize_v2.py

diff --git a/streamlit/visualize_v1.py b/streamlit/visualize_v1.py
deleted file mode 100644
index 30cd9ac..0000000
--- a/streamlit/visualize_v1.py
+++ /dev/null
@@ -1,87 +0,0 @@
-import os
-import cv2
-import json
-import torch
-import numpy as np
-import matplotlib.pyplot as plt
-import streamlit as st
-
-def label2rgb(label, palette):
-    image_size = label.shape[1:] + (3, )
-    image = np.zeros(image_size, dtype=np.uint8)
-
-    for i, class_label in enumerate(label):
-        image[class_label == 1] = palette[i]
-
-    return image
-
-def show(info, images, labels, id):
-    try:
-        cols = st.columns(2)
-        CLASS2IND = {v: i for i, v in enumerate(info['classes'])}
-        IND2CLASS = {v: k for k, v in CLASS2IND.items()}
-
-        image_path = os.path.join(info['image_root'], images[id])
-        image_left = cv2.imread(image_path)
-        image_left = cv2.cvtColor(image_left, cv2.COLOR_BGR2RGB)
-        image_left = image_left / 255.
-
-        image_path = os.path.join(info['image_root'], images[id + 1])
-        image_right = cv2.imread(image_path)
-        image_right = cv2.cvtColor(image_right, cv2.COLOR_BGR2RGB)
-        image_right = image_right / 255.
-
-        label_path_left = os.path.join(info['label_root'], labels[id])
-        label_shape = tuple(image_left.shape[:2]) + (len(info['classes']), )
-        label_left = np.zeros(label_shape, dtype=np.uint8)
-
-        label_path_right = os.path.join(info['label_root'], labels[id + 1])
-        label_shape = tuple(image_right.shape[:2]) + (len(info['classes']), )
-        label_right = np.zeros(label_shape, dtype=np.uint8)
-
-        with open(label_path_left, "r") as f:
-            annotations_left = json.load(f)
-        annotations_left = annotations_left["annotations"]
-
-        with open(label_path_right, "r") as f:
-            annotations_right = json.load(f)
-        annotations_right = annotations_right["annotations"]
-
-        for ann in annotations_left:
-            c = ann["label"]
-            class_ind = CLASS2IND[c]
-            points = np.array(ann["points"])
-
-            class_label_left = np.zeros(image_left.shape[:2], dtype=np.uint8)
-            cv2.fillPoly(class_label_left, [points], 1)
-            label_left[..., class_ind] = class_label_left
-        
-        for ann in annotations_right:
-            c = ann["label"]
-            class_ind = CLASS2IND[c]
-            points = np.array(ann["points"])
-            
-            class_label_right = np.zeros(image_right.shape[:2], dtype=np.uint8)
-            cv2.fillPoly(class_label_right, [points], 1)
-            label_right[..., class_ind] = class_label_right
-        
-        label_left = label_left.transpose(2, 0, 1)
-        label_right = label_right.transpose(2, 0, 1)
-
-        label_left = torch.from_numpy(label_left).float()
-        label_right = torch.from_numpy(label_right).float()
-
-        fig_left, ax_left = plt.subplots()
-        ax_left.imshow(label2rgb(label_left, info['palette']))
-        ax_left.set_axis_off()
-
-        fig_right, ax_right = plt.subplots()
-        ax_right.imshow(label2rgb(label_right, info['palette']))
-        ax_right.set_axis_off()
-
-        with cols[0]:
-            st.pyplot(fig_left)
-        with cols[1]:
-            st.pyplot(fig_right)
-    except Exception as e:
-        st.write(e)
diff --git a/streamlit/visualize_v2.py b/streamlit/visualize_v2.py
deleted file mode 100644
index 19f1197..0000000
--- a/streamlit/visualize_v2.py
+++ /dev/null
@@ -1,86 +0,0 @@
-import os
-import json
-import streamlit as st
-from PIL import Image
-import matplotlib.pyplot as plt
-import matplotlib.patches as patches
-
-def get_poly(points, label, color):
-    if label.startswith('finger'):
-        label = 'finger'
-    elif label not in color:
-        label = 'wrist'
-        
-    poly = patches.Polygon(
-        points, 
-        closed=True, 
-        facecolor=[ck/255 for ck in color[label]], 
-        edgecolor='black',
-        alpha=0.7
-    )
-    return poly
-
-def show(info, images, labels, id, text='None', anno='All'):
-    cols = st.columns(2)
-
-    image_path_right = os.path.join(info['image_root'], images[id])
-    label_path_right = os.path.join(info['label_root'], labels[id])
-
-    image_path_left = os.path.join(info['image_root'], images[id + 1])
-    label_path_left = os.path.join(info['label_root'], labels[id + 1])
-        
-    image_right = Image.open(image_path_right).convert("RGB")
-    label_right = json.load(open(label_path_right))
-
-    image_left = Image.open(image_path_left).convert("RGB")
-    label_left = json.load(open(label_path_left))
-    
-    fig_left, ax_left = plt.subplots()
-    
-    ax_left.imshow(image_left)
-    ax_left.set_title(images[id + 1])
-    ax_left.axis('off')
-    for annot in label_left['annotations']:
-        points = [tuple(pts) for pts in annot['points']]
-        orin_label = annot['label'] 
-        label = orin_label
-        if anno == 'All':
-            poly = get_poly(points, label, info['color'])
-            ax_left.add_patch(poly)
-            cx, cy = sum([p[0] for p in points]) / len(points), sum([p[1] for p in points]) / len(points)
-            if text == 'Text':
-                ax_left.text(cx, cy, orin_label, fontsize=5, color='white')
-        else:
-            if label == anno:
-                poly = get_poly(points, label, info['color'])
-                ax_left.add_patch(poly)
-                cx, cy = sum([p[0] for p in points]) / len(points), sum([p[1] for p in points]) / len(points)
-                if text == 'Text':
-                    ax_left.text(cx, cy, orin_label, fontsize=5, color='white')
-    with cols[0]:
-        st.pyplot(fig_left)
-
-    fig_right, ax_right = plt.subplots()
-
-    ax_right.imshow(image_right)
-    ax_right.set_title(images[id])
-    ax_right.axis('off')
-    for annot in label_right['annotations']:
-        points = [tuple(pts) for pts in annot['points']]
-        orin_label = annot['label'] 
-        label = orin_label
-        if anno == 'All':
-            poly = get_poly(points, label, info['color'])
-            ax_right.add_patch(poly)
-            cx, cy = sum([p[0] for p in points]) / len(points), sum([p[1] for p in points]) / len(points)
-            if text == 'Text':
-                ax_right.text(cx, cy, orin_label, fontsize=5, color='white')
-        else:
-            if label == anno:
-                poly = get_poly(points, label, info['color'])
-                ax_right.add_patch(poly)
-                cx, cy = sum([p[0] for p in points]) / len(points), sum([p[1] for p in points]) / len(points)
-                if text == 'Text':
-                    ax_right.text(cx, cy, orin_label, fontsize=5, color='white')
-    with cols[1]:
-        st.pyplot(fig_right)
\ No newline at end of file

From 30cc75fff7b85c204b564738069657f72282c475 Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Fri, 15 Nov 2024 02:10:51 +0900
Subject: [PATCH 019/106] [Feature]:add new config for mask2former

---
 .../_custom_/mask2former/default_runtime.py   |  37 ++++
 .../_custom_/mask2former/mask2former.py       | 185 ++++++++++++++++++
 .../_custom_/mask2former/schedule_160k.py     |  48 +++++
 .../configs/_custom_/mask2former/xraydata.py  |  98 ++++++++++
 .../configs/_custom_/mask2former/xraydata2.py |  61 ++++++
 5 files changed, 429 insertions(+)
 create mode 100644 mmsegmentation/configs/_custom_/mask2former/default_runtime.py
 create mode 100644 mmsegmentation/configs/_custom_/mask2former/mask2former.py
 create mode 100644 mmsegmentation/configs/_custom_/mask2former/schedule_160k.py
 create mode 100644 mmsegmentation/configs/_custom_/mask2former/xraydata.py
 create mode 100644 mmsegmentation/configs/_custom_/mask2former/xraydata2.py

diff --git a/mmsegmentation/configs/_custom_/mask2former/default_runtime.py b/mmsegmentation/configs/_custom_/mask2former/default_runtime.py
new file mode 100644
index 0000000..61a91aa
--- /dev/null
+++ b/mmsegmentation/configs/_custom_/mask2former/default_runtime.py
@@ -0,0 +1,37 @@
+default_scope = 'mmseg'
+fp16 = dict(loss_scale=512.)
+
+env_cfg = dict(
+    cudnn_benchmark=True,
+    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+    dist_cfg=dict(backend='nccl'),
+)
+vis_backends = [dict(type='LocalVisBackend'),
+                dict(type='WandbVisBackend')
+                ]
+visualizer = dict(
+    type='SegLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+log_processor = dict(by_epoch=False)
+log_level = 'INFO'
+load_from = None
+resume = False
+
+log_config = dict(
+    interval=1,
+    hooks=[
+        dict(type='TextLoggerHook', by_epoch=False),
+        dict(
+            type='MMSegWandbHook',
+            by_epoch=False,
+            interval=1,
+            with_step=False,
+            init_kwargs=dict(
+                entity='frostings',
+                project='Boost Camp Lv2-3',
+                name='mmsegtest'),
+            log_checkpoint=True,
+            log_checkpoint_metadata=True,
+            num_eval_images=10)
+    ])
+
+tta_model = dict(type='SegTTAModel')
\ No newline at end of file
diff --git a/mmsegmentation/configs/_custom_/mask2former/mask2former.py b/mmsegmentation/configs/_custom_/mask2former/mask2former.py
new file mode 100644
index 0000000..6204258
--- /dev/null
+++ b/mmsegmentation/configs/_custom_/mask2former/mask2former.py
@@ -0,0 +1,185 @@
+_base_ = [
+    './xraydata.py',
+    './default_runtime.py', './schedule_160k.py'
+]
+
+crop_size = _base_.crop_size
+load_from = 'https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221202_141901-28ad20f1.pth'
+# load_from = '/data/ephemeral/home/parkjunil/work_dir/mask2former/iter_12800.pth'
+pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_large_patch4_window12_384_22k_20220412-6580f57d.pth'
+depths = [2, 2, 18, 2]
+num_classes = 30
+
+
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255,
+    size=crop_size,
+    test_cfg=dict(size_divisor=32))
+
+
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='SwinTransformer',
+        pretrain_img_size=384,
+        embed_dims=192,
+        depths=depths,
+        num_heads=[6, 12, 24, 48],
+        window_size=12,
+        mlp_ratio=4,
+        qkv_bias=True,
+        qk_scale=None,
+        drop_rate=0.,
+        attn_drop_rate=0.,
+        drop_path_rate=0.3,
+        patch_norm=True,
+        out_indices=(0, 1, 2, 3),
+        with_cp=False,
+        frozen_stages=-1,
+        init_cfg=dict(type='Pretrained', checkpoint=pretrained)),
+    decode_head=dict(
+        type='Mask2FormerHead',
+        in_channels=[192, 384, 768, 1536],
+        strides=[4, 8, 16, 32],
+        feat_channels=256,
+        out_channels=256,
+        num_classes=num_classes,
+        num_queries=100,
+        num_transformer_feat_level=3,
+        align_corners=False,
+        pixel_decoder=dict(
+            type='mmdet.MSDeformAttnPixelDecoder',
+            num_outs=3,
+            norm_cfg=dict(type='GN', num_groups=32),
+            act_cfg=dict(type='ReLU'),
+            encoder=dict(  # DeformableDetrTransformerEncoder
+                num_layers=6,
+                layer_cfg=dict(  # DeformableDetrTransformerEncoderLayer
+                    self_attn_cfg=dict(  # MultiScaleDeformableAttention
+                        embed_dims=256,
+                        num_heads=8,
+                        num_levels=3,
+                        num_points=4,
+                        im2col_step=64,
+                        dropout=0.0,
+                        batch_first=True,
+                        norm_cfg=None,
+                        init_cfg=None),
+                    ffn_cfg=dict(
+                        embed_dims=256,
+                        feedforward_channels=1024,
+                        num_fcs=2,
+                        ffn_drop=0.0,
+                        act_cfg=dict(type='ReLU', inplace=True))),
+                init_cfg=None),
+            positional_encoding=dict(  # SinePositionalEncoding
+                num_feats=128, normalize=True),
+            init_cfg=None),
+        enforce_decoder_input_project=False,
+        positional_encoding=dict(  # SinePositionalEncoding
+            num_feats=128, normalize=True),
+        transformer_decoder=dict(  # Mask2FormerTransformerDecoder
+            return_intermediate=True,
+            num_layers=9,
+            layer_cfg=dict(  # Mask2FormerTransformerDecoderLayer
+                self_attn_cfg=dict(  # MultiheadAttention
+                    embed_dims=256,
+                    num_heads=8,
+                    attn_drop=0.0,
+                    proj_drop=0.0,
+                    dropout_layer=None,
+                    batch_first=True),
+                cross_attn_cfg=dict(  # MultiheadAttention
+                    embed_dims=256,
+                    num_heads=8,
+                    attn_drop=0.0,
+                    proj_drop=0.0,
+                    dropout_layer=None,
+                    batch_first=True),
+                ffn_cfg=dict(
+                    embed_dims=256,
+                    feedforward_channels=2048,
+                    num_fcs=2,
+                    act_cfg=dict(type='ReLU', inplace=True),
+                    ffn_drop=0.0,
+                    dropout_layer=None,
+                    add_identity=True)),
+            init_cfg=None),
+        loss_cls=dict(
+            type='mmdet.CrossEntropyLoss',
+            use_sigmoid=False,
+            loss_weight=2.0,
+            reduction='mean',
+            class_weight=[1.0] * num_classes + [0.1]),
+        loss_mask=dict(
+            type='mmdet.CrossEntropyLoss',
+            use_sigmoid=True,
+            reduction='mean',
+            loss_weight=5.0),
+        loss_dice=dict(
+            type='mmdet.DiceLoss',
+            use_sigmoid=True,
+            activate=True,
+            reduction='mean',
+            naive_dice=True,
+            eps=1.0,
+            loss_weight=5.0),
+        train_cfg=dict(
+            num_points=12544,
+            oversample_ratio=3.0,
+            importance_sample_ratio=0.75,
+            assigner=dict(
+                type='mmdet.HungarianAssigner',
+                match_costs=[
+                    dict(type='mmdet.ClassificationCost', weight=2.0),
+                    dict(
+                        type='mmdet.CrossEntropyLossCost',
+                        weight=5.0,
+                        use_sigmoid=True),
+                    dict(
+                        type='mmdet.DiceCost',
+                        weight=5.0,
+                        pred_act=True,
+                        eps=1.0)
+                ]),
+            sampler=dict(type='mmdet.MaskPseudoSampler'))),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+
+# set all layers in backbone to lr_mult=0.1
+# set all norm layers, position_embeding,
+# query_embeding, level_embeding to decay_multi=0.0
+backbone_norm_multi = dict(lr_mult=0.1, decay_mult=0.0)
+backbone_embed_multi = dict(lr_mult=0.1, decay_mult=0.0)
+embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
+custom_keys = {
+    'backbone': dict(lr_mult=0.1, decay_mult=1.0),
+    'backbone.patch_embed.norm': backbone_norm_multi,
+    'backbone.norm': backbone_norm_multi,
+    'absolute_pos_embed': backbone_embed_multi,
+    'relative_position_bias_table': backbone_embed_multi,
+    'query_embed': embed_multi,
+    'query_feat': embed_multi,
+    'level_embed': embed_multi
+}
+custom_keys.update({
+    f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi
+    for stage_id, num_blocks in enumerate(depths)
+    for block_id in range(num_blocks)
+})
+custom_keys.update({
+    f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi
+    for stage_id in range(len(depths) - 1)
+})
+# optimizer
+optim_wrapper = dict(
+    paramwise_cfg=dict(custom_keys=custom_keys, norm_decay_mult=0.0))
+
+
+auto_scale_lr = dict(enable=False, base_batch_size=16)
\ No newline at end of file
diff --git a/mmsegmentation/configs/_custom_/mask2former/schedule_160k.py b/mmsegmentation/configs/_custom_/mask2former/schedule_160k.py
new file mode 100644
index 0000000..73923d6
--- /dev/null
+++ b/mmsegmentation/configs/_custom_/mask2former/schedule_160k.py
@@ -0,0 +1,48 @@
+val_save_interval = 3000
+
+# optimizer
+embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
+optimizer = dict(
+    type='AdamW', lr=0.0001, weight_decay=0.05, eps=1e-8, betas=(0.9, 0.999))
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=optimizer,
+    clip_grad=dict(max_norm=0.01, norm_type=2),
+    paramwise_cfg=dict(
+        custom_keys={
+            'backbone': dict(lr_mult=0.1, decay_mult=1.0),
+            'query_embed': embed_multi,
+            'query_feat': embed_multi,
+            'level_embed': embed_multi,
+        },
+        norm_decay_mult=0.0))
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=0,
+        power=0.9,
+        begin=0,
+        end=90000,
+        by_epoch=False)
+]
+
+# training schedule for 90k
+train_cfg = dict(type='IterBasedTrainLoop', 
+                 max_iters=90000, 
+                 val_interval=val_save_interval
+                 )
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=100, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', 
+                    by_epoch=False, 
+                    interval=val_save_interval,
+                    max_keep_ckpts=3,
+                    save_best='mDice',
+                    rule='greater'),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))
\ No newline at end of file
diff --git a/mmsegmentation/configs/_custom_/mask2former/xraydata.py b/mmsegmentation/configs/_custom_/mask2former/xraydata.py
new file mode 100644
index 0000000..7ff37a4
--- /dev/null
+++ b/mmsegmentation/configs/_custom_/mask2former/xraydata.py
@@ -0,0 +1,98 @@
+resize_size = (1748, 1748)
+crop_size = (1536, 1536)
+test_size = (2048, 2048)
+
+dataset_type = 'XRayDataset'
+data_root = '/data/ephemeral/home/cityscapes_format_xlay/'
+
+
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    # dict(
+    #     type='RandomChoiceResize',
+    #     scales=[int(1024 * x * 0.1) for x in range(5, 21)],
+    #     resize_type='ResizeShortestEdge',
+    #     max_size=4096),
+    dict(type='Resize', scale=resize_size, keep_ratio=True),
+    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+
+train_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(img_path='leftImg8bit/train', seg_map_path='gtFine/train'),
+        img_suffix='.png',
+        seg_map_suffix='_gtFine_labelIds.png',
+        pipeline=train_pipeline))
+
+val_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=test_size, keep_ratio=True),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=test_size, keep_ratio=True),
+    dict(type='PackSegInputs')
+]
+
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(img_path='leftImg8bit/val', seg_map_path='gtFine/val'),
+        img_suffix='.png',
+        seg_map_suffix='_gtFine_labelIds.png',
+        pipeline=val_pipeline))
+
+test_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(img_path='leftImg8bit/test'),
+        img_suffix='.png',
+        pipeline=test_pipeline))
+
+
+val_evaluator = dict(type='DiceMetric')
+test_evaluator = dict(type='SubmissionMetric', save_path = "/data/ephemeral/home/submission")
+# val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+# test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='PackSegInputs')]
+        ])
+]
\ No newline at end of file
diff --git a/mmsegmentation/configs/_custom_/mask2former/xraydata2.py b/mmsegmentation/configs/_custom_/mask2former/xraydata2.py
new file mode 100644
index 0000000..fa9bbca
--- /dev/null
+++ b/mmsegmentation/configs/_custom_/mask2former/xraydata2.py
@@ -0,0 +1,61 @@
+# dataset settings
+dataset_type = 'XRayDataset'
+resize_size = (1024, 1024)
+data_root = "/data/ephemeral/home/data"
+
+
+train_pipeline = [
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadXRayAnnotations'),
+            dict(type='Resize', scale=resize_size),
+            dict(type='TransposeAnnotations'),
+            dict(type='PackSegInputs')
+        ]
+test_pipeline = [
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadXRayAnnotations'),
+            dict(type='TransposeAnnotations'),
+            dict(type='PackSegInputs')
+        ]
+
+
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
+        ])
+]
+
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=1,
+    # persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        is_train = True,
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=1,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        is_train = False,
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+
+val_evaluator = dict(type='DiceMetric')
+test_evaluator = dict(type='DiceMetric')
\ No newline at end of file

From 1dd792ee4a52d92d94b9d79ce7b04c7eec7618fd Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Fri, 15 Nov 2024 02:23:42 +0900
Subject: [PATCH 020/106] [Refactor] : add model.py

---
 module_base/inference.py |  2 +-
 module_base/model.py     | 62 ++++++++++++++++++++++++++++++++++++++++
 module_base/train.py     | 30 +++++++++++++------
 3 files changed, 84 insertions(+), 10 deletions(-)
 create mode 100644 module_base/model.py

diff --git a/module_base/inference.py b/module_base/inference.py
index 77b6191..89d02f3 100644
--- a/module_base/inference.py
+++ b/module_base/inference.py
@@ -13,7 +13,7 @@
 def parse_args():
     parser = ArgumentParser()
     
-    parser.add_argument('--image_root', type=str, default='//data/ephemeral/home/data/test/DCM',
+    parser.add_argument('--image_root', type=str, default='/data/ephemeral/home/data/test/DCM',
                         help='Path to the root directory containing images')
     parser.add_argument('--save_dir', type=str, default="/data/ephemeral/home/data/train/result",
                         help='Path to the root directory containing save direction')
diff --git a/module_base/model.py b/module_base/model.py
new file mode 100644
index 0000000..b4dcb3a
--- /dev/null
+++ b/module_base/model.py
@@ -0,0 +1,62 @@
+import torch.nn as nn
+from torchvision import models
+import segmentation_models_pytorch as smp
+
+'''
+model_selector = ModelSelector(
+        model_type=model_type, 
+        num_classes=num_classes,
+        model_name=model_name,
+        encoder_weights=encoder_weights,
+        pretrained=True
+    )
+model = model_selector.get_model()
+'''
+
+class TorchvisionModel(nn.Module):
+    def __init__(self, model_name, num_classes, pretrained):
+        super(TorchvisionModel, self).__init__()
+        self.model = models.segmentation.__dict__[model_name](pretrained=pretrained)
+        self.model.classifier[-1] = nn.Conv2d(512, num_classes, kernel_size=1)
+
+    def forward(self, x):
+        return self.model(x)
+
+class SMP(nn.Module):
+    """
+    SMP에서 제공하는 사전 훈련된 모델을 사용하는 클래스
+    """
+    def __init__(self, model_name, encoder_weights, num_classes):
+        super(SMP, self).__init__()
+        self.model = smp.Unet(
+            encoder_name=model_name,
+            encoder_weights=encoder_weights,
+            in_channels=3,
+            classes=num_classes
+        )
+
+    def forward(self, x):
+        
+        return self.model(x)
+
+class ModelSelector:
+    """
+    사용할 모델 유형을 선택하는 클래스
+    """
+    def __init__(self, model_type, num_classes, **kwargs):
+        
+        # 모델 유형에 따라 적절한 모델 객체를 생성
+        if model_type == 'torchvision':
+            self.model = TorchvisionModel(num_classes=num_classes, **kwargs)
+        
+        elif model_type == 'smp':
+            pass
+            self.model = SMP(num_classes=num_classes, **kwargs)
+        
+        else:
+            raise ValueError("Unknown model type specified.")
+        
+    def get_model(self) -> nn.Module:
+        
+        # 생성된 모델 객체 반환
+        return self.model
\ No newline at end of file
diff --git a/module_base/train.py b/module_base/train.py
index 5a5760d..99762cb 100644
--- a/module_base/train.py
+++ b/module_base/train.py
@@ -12,6 +12,7 @@
 from torch.utils.data import DataLoader
 from torchvision import models
 from dataset import XRayDataset
+from model import ModelSelector
 from argparse import ArgumentParser
 
 def parse_args():
@@ -24,16 +25,18 @@ def parse_args():
                         help='Path to the root directory containing labels')
     parser.add_argument('--save_dir', type=str, default="/data/ephemeral/home/data/result",
                         help='Path to the root directory containing save direction')
-    parser.add_argument('--batch_size', type=int, default=8)
+    parser.add_argument('--batch_size', type=int, default=1)
     parser.add_argument('--learning_rate', type=float, default=1e-4)
-    parser.add_argument('--max_epoch', type=int, default=30)
+    parser.add_argument('--max_epoch', type=int, default=1)
     parser.add_argument('--val_every', type=int, default=5)
-    parser.add_argument('--random_seed', type=int, default=21)
+    parser.add_argument('--random_seed', type=int, default=2024)
+    parser.add_argument('--model_type', type=str, default='smp')
+    parser.add_argument('--model_name', type=str, default='efficientnet-b0')
+    parser.add_argument('--encoder_weights', type=str, default='imagenet')
     args = parser.parse_args()
     
     return args
 
-
 CLASSES = [
     'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
     'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
@@ -80,7 +83,8 @@ def validation(epoch, model, data_loader, criterion, thr=0.5):
             images, masks = images.cuda(), masks.cuda()         
             model = model.cuda()
             
-            outputs = model(images)['out']
+            # outputs = model(images)['out']
+            outputs = model(images)
             
             output_h, output_w = outputs.size(-2), outputs.size(-1)
             mask_h, mask_w = masks.size(-2), masks.size(-1)
@@ -141,6 +145,7 @@ def train(model, train_loader, valid_loader, criterion, optimizer, save_dir, ran
 
             # Mixed Precision Training 적용
             with torch.cuda.amp.autocast():
+                # outputs = model(images)['out']
                 outputs = model(images)
                 loss = criterion(outputs, masks)
             
@@ -171,7 +176,8 @@ def train(model, train_loader, valid_loader, criterion, optimizer, save_dir, ran
                 best_dice = dice
                 save_model(model, save_dir)
 
-def do_training(image_root, label_root, save_dir, batch_size, learning_rate, max_epoch, val_every, random_seed):
+def do_training(image_root, label_root, save_dir, batch_size, learning_rate, max_epoch, val_every, random_seed,
+                model_type, model_name, encoder_weights):
     pngs = {
         os.path.relpath(os.path.join(root, fname), start=image_root)
         for root, _dirs, files in os.walk(image_root)
@@ -213,8 +219,14 @@ def do_training(image_root, label_root, save_dir, batch_size, learning_rate, max
         drop_last=False
     )
     
-    model = models.segmentation.fcn_resnet50(pretrained=True)
-
+    model_selector = ModelSelector(
+        model_type=model_type,
+        num_classes=len(CLASSES),
+        model_name=model_name,
+        encoder_weights=encoder_weights,
+    )
+    model = model_selector.get_model()
+    
     # output class 개수를 dataset에 맞도록 수정합니다.
     model.classifier[4] = nn.Conv2d(512, len(CLASSES), kernel_size=1)
 
@@ -226,7 +238,7 @@ def do_training(image_root, label_root, save_dir, batch_size, learning_rate, max
 
     # 시드를 설정합니다.
     set_seed(random_seed)
-
+    
     train(model, train_loader, valid_loader, criterion, optimizer, save_dir, random_seed, max_epoch, val_every)
 
 def main(args):

From b520e28d3aed678e589eafbab6e15950a5e328bf Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Fri, 15 Nov 2024 02:42:38 +0900
Subject: [PATCH 021/106] [Refactor] : modified (train.py, inference.py)

---
 baseline_code.ipynb      | 551 +++++++++++++++++++++++++++++++++++++--
 module_base/inference.py |   5 +-
 module_base/model.py     |   3 +-
 module_base/train.py     |   3 -
 4 files changed, 540 insertions(+), 22 deletions(-)

diff --git a/baseline_code.ipynb b/baseline_code.ipynb
index 4378ae4..5a94b29 100644
--- a/baseline_code.ipynb
+++ b/baseline_code.ipynb
@@ -173,16 +173,16 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "BATCH_SIZE = 8\n",
-    "LR = 1e-4\n",
+    "BATCH_SIZE = 2\n",
+    "LR = 3e-4\n",
     "RANDOM_SEED = 2024\n",
     "\n",
-    "NUM_EPOCHS = 24\n",
+    "NUM_EPOCHS = 60\n",
     "VAL_EVERY = 3\n",
     "\n",
     "SAVED_DIR = \"/data/ephemeral/home/data/result\"\n",
     "\n",
-    "if not os.path.exists(SAVED_DIR):                                                           \n",
+    "if not os.path.exists(SAVED_DIR):                                    \n",
     "    os.makedirs(SAVED_DIR)"
    ]
   },
@@ -737,6 +737,7 @@
     "\n",
     "            # Mixed Precision Training 적용\n",
     "            with torch.cuda.amp.autocast():\n",
+    "                # outputs = model(images)['out']\n",
     "                outputs = model(images)\n",
     "                loss = criterion(outputs, masks)\n",
     "            \n",
@@ -783,7 +784,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "model = models.segmentation.fcn_resnet50(pretrained=True)\n",
+    "model = models.segmentation.fcn_resnet101(pretrained=True)\n",
     "\n",
     "# output class 개수를 dataset에 맞도록 수정합니다.\n",
     "model.classifier[4] = nn.Conv2d(512, len(CLASSES), kernel_size=1)"
@@ -792,16 +793,24 @@
   {
    "cell_type": "code",
    "execution_count": 27,
-   "id": "063b93e9",
+   "id": "497da034",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Unexpected keys (downsamp_modules.0.0.bias, downsamp_modules.0.0.weight, downsamp_modules.0.1.bias, downsamp_modules.0.1.num_batches_tracked, downsamp_modules.0.1.running_mean, downsamp_modules.0.1.running_var, downsamp_modules.0.1.weight, downsamp_modules.1.0.bias, downsamp_modules.1.0.weight, downsamp_modules.1.1.bias, downsamp_modules.1.1.num_batches_tracked, downsamp_modules.1.1.running_mean, downsamp_modules.1.1.running_var, downsamp_modules.1.1.weight, downsamp_modules.2.0.bias, downsamp_modules.2.0.weight, downsamp_modules.2.1.bias, downsamp_modules.2.1.num_batches_tracked, downsamp_modules.2.1.running_mean, downsamp_modules.2.1.running_var, downsamp_modules.2.1.weight, final_layer.0.bias, final_layer.0.weight, final_layer.1.bias, final_layer.1.num_batches_tracked, final_layer.1.running_mean, final_layer.1.running_var, final_layer.1.weight, classifier.bias, classifier.weight) found while loading pretrained weights. This may be expected if model is being adapted.\n"
+     ]
+    }
+   ],
    "source": [
     "import segmentation_models_pytorch as smp\n",
     "\n",
-    "model = smp.Unet(\n",
-    "    encoder_name = \"efficientnet-b0\",\n",
-    "    encoder_weights = \"imagenet\",\n",
-    "    in_channels = 3,\n",
+    "model = smp.UPerNet(\n",
+    "    encoder_name=\"tu-hrnet_w48\",\n",
+    "    encoder_weights=\"imagenet\",\n",
+    "    in_channels=3,\n",
     "    classes=29\n",
     ")"
    ]
@@ -841,7 +850,511 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Start training..\n"
+      "Start training..\n",
+      "2024-11-15 01:31:48 | Epoch [1/60], Step [25/320], Loss: 0.554\n",
+      "2024-11-15 01:31:56 | Epoch [1/60], Step [50/320], Loss: 0.486\n",
+      "2024-11-15 01:32:04 | Epoch [1/60], Step [75/320], Loss: 0.427\n",
+      "2024-11-15 01:32:12 | Epoch [1/60], Step [100/320], Loss: 0.3694\n",
+      "2024-11-15 01:32:20 | Epoch [1/60], Step [125/320], Loss: 0.3164\n",
+      "2024-11-15 01:32:28 | Epoch [1/60], Step [150/320], Loss: 0.2669\n",
+      "2024-11-15 01:32:36 | Epoch [1/60], Step [175/320], Loss: 0.2212\n",
+      "2024-11-15 01:32:44 | Epoch [1/60], Step [200/320], Loss: 0.1857\n",
+      "2024-11-15 01:32:52 | Epoch [1/60], Step [225/320], Loss: 0.1555\n",
+      "2024-11-15 01:33:00 | Epoch [1/60], Step [250/320], Loss: 0.1337\n",
+      "2024-11-15 01:33:08 | Epoch [1/60], Step [275/320], Loss: 0.1136\n",
+      "2024-11-15 01:33:16 | Epoch [1/60], Step [300/320], Loss: 0.0968\n",
+      "2024-11-15 01:33:34 | Epoch [2/60], Step [25/320], Loss: 0.0754\n",
+      "2024-11-15 01:33:42 | Epoch [2/60], Step [50/320], Loss: 0.0652\n",
+      "2024-11-15 01:33:50 | Epoch [2/60], Step [75/320], Loss: 0.0576\n",
+      "2024-11-15 01:33:58 | Epoch [2/60], Step [100/320], Loss: 0.0517\n",
+      "2024-11-15 01:34:06 | Epoch [2/60], Step [125/320], Loss: 0.0458\n",
+      "2024-11-15 01:34:14 | Epoch [2/60], Step [150/320], Loss: 0.0415\n",
+      "2024-11-15 01:34:22 | Epoch [2/60], Step [175/320], Loss: 0.0371\n",
+      "2024-11-15 01:34:30 | Epoch [2/60], Step [200/320], Loss: 0.0331\n",
+      "2024-11-15 01:34:38 | Epoch [2/60], Step [225/320], Loss: 0.0311\n",
+      "2024-11-15 01:34:46 | Epoch [2/60], Step [250/320], Loss: 0.0293\n",
+      "2024-11-15 01:34:54 | Epoch [2/60], Step [275/320], Loss: 0.0251\n",
+      "2024-11-15 01:35:02 | Epoch [2/60], Step [300/320], Loss: 0.0241\n",
+      "2024-11-15 01:35:19 | Epoch [3/60], Step [25/320], Loss: 0.0202\n",
+      "2024-11-15 01:35:27 | Epoch [3/60], Step [50/320], Loss: 0.0192\n",
+      "2024-11-15 01:35:35 | Epoch [3/60], Step [75/320], Loss: 0.0177\n",
+      "2024-11-15 01:35:43 | Epoch [3/60], Step [100/320], Loss: 0.0167\n",
+      "2024-11-15 01:35:51 | Epoch [3/60], Step [125/320], Loss: 0.0156\n",
+      "2024-11-15 01:35:59 | Epoch [3/60], Step [150/320], Loss: 0.0145\n",
+      "2024-11-15 01:36:08 | Epoch [3/60], Step [175/320], Loss: 0.0138\n",
+      "2024-11-15 01:36:16 | Epoch [3/60], Step [200/320], Loss: 0.0132\n",
+      "2024-11-15 01:36:24 | Epoch [3/60], Step [225/320], Loss: 0.0117\n",
+      "2024-11-15 01:36:32 | Epoch [3/60], Step [250/320], Loss: 0.0114\n",
+      "2024-11-15 01:36:40 | Epoch [3/60], Step [275/320], Loss: 0.0108\n",
+      "2024-11-15 01:36:49 | Epoch [3/60], Step [300/320], Loss: 0.0099\n",
+      "Start validation # 3\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 40/40 [05:37<00:00,  8.43s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "finger-1    : 0.8588\n",
+      "finger-2    : 0.9149\n",
+      "finger-3    : 0.9549\n",
+      "finger-4    : 0.8309\n",
+      "finger-5    : 0.9058\n",
+      "finger-6    : 0.9383\n",
+      "finger-7    : 0.9564\n",
+      "finger-8    : 0.8517\n",
+      "finger-9    : 0.9133\n",
+      "finger-10   : 0.9360\n",
+      "finger-11   : 0.9526\n",
+      "finger-12   : 0.8273\n",
+      "finger-13   : 0.8683\n",
+      "finger-14   : 0.9192\n",
+      "finger-15   : 0.9329\n",
+      "finger-16   : 0.7633\n",
+      "finger-17   : 0.8339\n",
+      "finger-18   : 0.9216\n",
+      "finger-19   : 0.9447\n",
+      "Trapezium   : 0.8803\n",
+      "Trapezoid   : 0.8271\n",
+      "Capitate    : 0.8975\n",
+      "Hamate      : 0.8750\n",
+      "Scaphoid    : 0.8985\n",
+      "Lunate      : 0.8147\n",
+      "Triquetrum  : 0.8580\n",
+      "Pisiform    : 0.8028\n",
+      "Radius      : 0.9772\n",
+      "Ulna        : 0.9546\n",
+      "Best performance at epoch: 3, 0.0000 -> 0.8900\n",
+      "Save model in /data/ephemeral/home/data/result\n",
+      "2024-11-15 01:42:45 | Epoch [4/60], Step [25/320], Loss: 0.0092\n",
+      "2024-11-15 01:42:53 | Epoch [4/60], Step [50/320], Loss: 0.0091\n",
+      "2024-11-15 01:43:01 | Epoch [4/60], Step [75/320], Loss: 0.0085\n",
+      "2024-11-15 01:43:09 | Epoch [4/60], Step [100/320], Loss: 0.0084\n",
+      "2024-11-15 01:43:17 | Epoch [4/60], Step [125/320], Loss: 0.0077\n",
+      "2024-11-15 01:43:25 | Epoch [4/60], Step [150/320], Loss: 0.0071\n",
+      "2024-11-15 01:43:33 | Epoch [4/60], Step [175/320], Loss: 0.007\n",
+      "2024-11-15 01:43:41 | Epoch [4/60], Step [200/320], Loss: 0.0067\n",
+      "2024-11-15 01:43:50 | Epoch [4/60], Step [225/320], Loss: 0.0067\n",
+      "2024-11-15 01:43:58 | Epoch [4/60], Step [250/320], Loss: 0.0062\n",
+      "2024-11-15 01:44:06 | Epoch [4/60], Step [275/320], Loss: 0.0059\n",
+      "2024-11-15 01:44:14 | Epoch [4/60], Step [300/320], Loss: 0.0062\n",
+      "2024-11-15 01:44:32 | Epoch [5/60], Step [25/320], Loss: 0.0059\n",
+      "2024-11-15 01:44:40 | Epoch [5/60], Step [50/320], Loss: 0.0057\n",
+      "2024-11-15 01:44:49 | Epoch [5/60], Step [75/320], Loss: 0.0054\n",
+      "2024-11-15 01:44:58 | Epoch [5/60], Step [100/320], Loss: 0.005\n",
+      "2024-11-15 01:45:06 | Epoch [5/60], Step [125/320], Loss: 0.0048\n",
+      "2024-11-15 01:45:14 | Epoch [5/60], Step [150/320], Loss: 0.0045\n",
+      "2024-11-15 01:45:21 | Epoch [5/60], Step [175/320], Loss: 0.0049\n",
+      "2024-11-15 01:45:29 | Epoch [5/60], Step [200/320], Loss: 0.0048\n",
+      "2024-11-15 01:45:38 | Epoch [5/60], Step [225/320], Loss: 0.0045\n",
+      "2024-11-15 01:45:46 | Epoch [5/60], Step [250/320], Loss: 0.0044\n",
+      "2024-11-15 01:45:54 | Epoch [5/60], Step [275/320], Loss: 0.0042\n",
+      "2024-11-15 01:46:02 | Epoch [5/60], Step [300/320], Loss: 0.0039\n",
+      "2024-11-15 01:46:19 | Epoch [6/60], Step [25/320], Loss: 0.0037\n",
+      "2024-11-15 01:46:28 | Epoch [6/60], Step [50/320], Loss: 0.0036\n",
+      "2024-11-15 01:46:36 | Epoch [6/60], Step [75/320], Loss: 0.0035\n",
+      "2024-11-15 01:46:44 | Epoch [6/60], Step [100/320], Loss: 0.0035\n",
+      "2024-11-15 01:46:52 | Epoch [6/60], Step [125/320], Loss: 0.0036\n",
+      "2024-11-15 01:47:00 | Epoch [6/60], Step [150/320], Loss: 0.0035\n",
+      "2024-11-15 01:47:08 | Epoch [6/60], Step [175/320], Loss: 0.0035\n",
+      "2024-11-15 01:47:16 | Epoch [6/60], Step [200/320], Loss: 0.0031\n",
+      "2024-11-15 01:47:25 | Epoch [6/60], Step [225/320], Loss: 0.0032\n",
+      "2024-11-15 01:47:34 | Epoch [6/60], Step [250/320], Loss: 0.0029\n",
+      "2024-11-15 01:47:42 | Epoch [6/60], Step [275/320], Loss: 0.0028\n",
+      "2024-11-15 01:47:50 | Epoch [6/60], Step [300/320], Loss: 0.003\n",
+      "Start validation # 6\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 40/40 [05:39<00:00,  8.50s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "finger-1    : 0.9218\n",
+      "finger-2    : 0.9520\n",
+      "finger-3    : 0.9634\n",
+      "finger-4    : 0.9117\n",
+      "finger-5    : 0.9380\n",
+      "finger-6    : 0.9628\n",
+      "finger-7    : 0.9589\n",
+      "finger-8    : 0.9004\n",
+      "finger-9    : 0.9417\n",
+      "finger-10   : 0.9611\n",
+      "finger-11   : 0.9579\n",
+      "finger-12   : 0.9169\n",
+      "finger-13   : 0.9433\n",
+      "finger-14   : 0.9619\n",
+      "finger-15   : 0.9497\n",
+      "finger-16   : 0.8903\n",
+      "finger-17   : 0.8997\n",
+      "finger-18   : 0.9542\n",
+      "finger-19   : 0.9587\n",
+      "Trapezium   : 0.9034\n",
+      "Trapezoid   : 0.8639\n",
+      "Capitate    : 0.9391\n",
+      "Hamate      : 0.9169\n",
+      "Scaphoid    : 0.9286\n",
+      "Lunate      : 0.9161\n",
+      "Triquetrum  : 0.9017\n",
+      "Pisiform    : 0.8326\n",
+      "Radius      : 0.9778\n",
+      "Ulna        : 0.9666\n",
+      "Best performance at epoch: 6, 0.8900 -> 0.9307\n",
+      "Save model in /data/ephemeral/home/data/result\n",
+      "2024-11-15 01:53:50 | Epoch [7/60], Step [25/320], Loss: 0.0027\n",
+      "2024-11-15 01:53:58 | Epoch [7/60], Step [50/320], Loss: 0.0029\n",
+      "2024-11-15 01:54:07 | Epoch [7/60], Step [75/320], Loss: 0.0026\n",
+      "2024-11-15 01:54:15 | Epoch [7/60], Step [100/320], Loss: 0.0027\n",
+      "2024-11-15 01:54:23 | Epoch [7/60], Step [125/320], Loss: 0.0026\n",
+      "2024-11-15 01:54:31 | Epoch [7/60], Step [150/320], Loss: 0.0023\n",
+      "2024-11-15 01:54:39 | Epoch [7/60], Step [175/320], Loss: 0.0023\n",
+      "2024-11-15 01:54:47 | Epoch [7/60], Step [200/320], Loss: 0.0023\n",
+      "2024-11-15 01:54:55 | Epoch [7/60], Step [225/320], Loss: 0.0024\n",
+      "2024-11-15 01:55:03 | Epoch [7/60], Step [250/320], Loss: 0.0022\n",
+      "2024-11-15 01:55:10 | Epoch [7/60], Step [275/320], Loss: 0.0021\n",
+      "2024-11-15 01:55:19 | Epoch [7/60], Step [300/320], Loss: 0.0024\n",
+      "2024-11-15 01:55:37 | Epoch [8/60], Step [25/320], Loss: 0.0021\n",
+      "2024-11-15 01:55:45 | Epoch [8/60], Step [50/320], Loss: 0.0021\n",
+      "2024-11-15 01:55:53 | Epoch [8/60], Step [75/320], Loss: 0.0021\n",
+      "2024-11-15 01:56:01 | Epoch [8/60], Step [100/320], Loss: 0.002\n",
+      "2024-11-15 01:56:09 | Epoch [8/60], Step [125/320], Loss: 0.002\n",
+      "2024-11-15 01:56:17 | Epoch [8/60], Step [150/320], Loss: 0.0018\n",
+      "2024-11-15 01:56:26 | Epoch [8/60], Step [175/320], Loss: 0.0024\n",
+      "2024-11-15 01:56:34 | Epoch [8/60], Step [200/320], Loss: 0.0023\n",
+      "2024-11-15 01:56:42 | Epoch [8/60], Step [225/320], Loss: 0.0024\n",
+      "2024-11-15 01:56:50 | Epoch [8/60], Step [250/320], Loss: 0.0027\n",
+      "2024-11-15 01:56:59 | Epoch [8/60], Step [275/320], Loss: 0.0022\n",
+      "2024-11-15 01:57:06 | Epoch [8/60], Step [300/320], Loss: 0.002\n",
+      "2024-11-15 01:57:24 | Epoch [9/60], Step [25/320], Loss: 0.0018\n",
+      "2024-11-15 01:57:32 | Epoch [9/60], Step [50/320], Loss: 0.0018\n",
+      "2024-11-15 01:57:40 | Epoch [9/60], Step [75/320], Loss: 0.0018\n",
+      "2024-11-15 01:57:49 | Epoch [9/60], Step [100/320], Loss: 0.0017\n",
+      "2024-11-15 01:57:57 | Epoch [9/60], Step [125/320], Loss: 0.0018\n",
+      "2024-11-15 01:58:05 | Epoch [9/60], Step [150/320], Loss: 0.0027\n",
+      "2024-11-15 01:58:13 | Epoch [9/60], Step [175/320], Loss: 0.002\n",
+      "2024-11-15 01:58:21 | Epoch [9/60], Step [200/320], Loss: 0.0016\n",
+      "2024-11-15 01:58:29 | Epoch [9/60], Step [225/320], Loss: 0.0018\n",
+      "2024-11-15 01:58:37 | Epoch [9/60], Step [250/320], Loss: 0.0015\n",
+      "2024-11-15 01:58:45 | Epoch [9/60], Step [275/320], Loss: 0.0015\n",
+      "2024-11-15 01:58:54 | Epoch [9/60], Step [300/320], Loss: 0.0016\n",
+      "Start validation # 9\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 40/40 [05:38<00:00,  8.45s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "finger-1    : 0.9257\n",
+      "finger-2    : 0.9492\n",
+      "finger-3    : 0.9640\n",
+      "finger-4    : 0.9243\n",
+      "finger-5    : 0.9403\n",
+      "finger-6    : 0.9645\n",
+      "finger-7    : 0.9619\n",
+      "finger-8    : 0.9221\n",
+      "finger-9    : 0.9397\n",
+      "finger-10   : 0.9667\n",
+      "finger-11   : 0.9615\n",
+      "finger-12   : 0.9227\n",
+      "finger-13   : 0.9432\n",
+      "finger-14   : 0.9650\n",
+      "finger-15   : 0.9539\n",
+      "finger-16   : 0.9120\n",
+      "finger-17   : 0.9234\n",
+      "finger-18   : 0.9578\n",
+      "finger-19   : 0.9617\n",
+      "Trapezium   : 0.9152\n",
+      "Trapezoid   : 0.8870\n",
+      "Capitate    : 0.9418\n",
+      "Hamate      : 0.9300\n",
+      "Scaphoid    : 0.9384\n",
+      "Lunate      : 0.9258\n",
+      "Triquetrum  : 0.9165\n",
+      "Pisiform    : 0.8513\n",
+      "Radius      : 0.9758\n",
+      "Ulna        : 0.9612\n",
+      "Best performance at epoch: 9, 0.9307 -> 0.9380\n",
+      "Save model in /data/ephemeral/home/data/result\n",
+      "2024-11-15 02:04:52 | Epoch [10/60], Step [25/320], Loss: 0.0014\n",
+      "2024-11-15 02:05:00 | Epoch [10/60], Step [50/320], Loss: 0.0017\n",
+      "2024-11-15 02:05:08 | Epoch [10/60], Step [75/320], Loss: 0.0014\n",
+      "2024-11-15 02:05:16 | Epoch [10/60], Step [100/320], Loss: 0.0015\n",
+      "2024-11-15 02:05:24 | Epoch [10/60], Step [125/320], Loss: 0.0014\n",
+      "2024-11-15 02:05:32 | Epoch [10/60], Step [150/320], Loss: 0.0012\n",
+      "2024-11-15 02:05:40 | Epoch [10/60], Step [175/320], Loss: 0.0012\n",
+      "2024-11-15 02:05:49 | Epoch [10/60], Step [200/320], Loss: 0.0013\n",
+      "2024-11-15 02:05:56 | Epoch [10/60], Step [225/320], Loss: 0.0014\n",
+      "2024-11-15 02:06:04 | Epoch [10/60], Step [250/320], Loss: 0.0013\n",
+      "2024-11-15 02:06:12 | Epoch [10/60], Step [275/320], Loss: 0.0012\n",
+      "2024-11-15 02:06:21 | Epoch [10/60], Step [300/320], Loss: 0.0014\n",
+      "2024-11-15 02:06:38 | Epoch [11/60], Step [25/320], Loss: 0.0012\n",
+      "2024-11-15 02:06:46 | Epoch [11/60], Step [50/320], Loss: 0.0012\n",
+      "2024-11-15 02:06:54 | Epoch [11/60], Step [75/320], Loss: 0.0013\n",
+      "2024-11-15 02:07:03 | Epoch [11/60], Step [100/320], Loss: 0.0011\n",
+      "2024-11-15 02:07:11 | Epoch [11/60], Step [125/320], Loss: 0.0012\n",
+      "2024-11-15 02:07:19 | Epoch [11/60], Step [150/320], Loss: 0.0011\n",
+      "2024-11-15 02:07:27 | Epoch [11/60], Step [175/320], Loss: 0.0017\n",
+      "2024-11-15 02:07:36 | Epoch [11/60], Step [200/320], Loss: 0.0014\n",
+      "2024-11-15 02:07:44 | Epoch [11/60], Step [225/320], Loss: 0.0014\n",
+      "2024-11-15 02:07:52 | Epoch [11/60], Step [250/320], Loss: 0.0013\n",
+      "2024-11-15 02:08:01 | Epoch [11/60], Step [275/320], Loss: 0.0012\n",
+      "2024-11-15 02:08:08 | Epoch [11/60], Step [300/320], Loss: 0.0011\n",
+      "2024-11-15 02:08:27 | Epoch [12/60], Step [25/320], Loss: 0.001\n",
+      "2024-11-15 02:08:36 | Epoch [12/60], Step [50/320], Loss: 0.0011\n",
+      "2024-11-15 02:08:44 | Epoch [12/60], Step [75/320], Loss: 0.0011\n",
+      "2024-11-15 02:08:52 | Epoch [12/60], Step [100/320], Loss: 0.001\n",
+      "2024-11-15 02:09:01 | Epoch [12/60], Step [125/320], Loss: 0.0012\n",
+      "2024-11-15 02:09:09 | Epoch [12/60], Step [150/320], Loss: 0.0012\n",
+      "2024-11-15 02:09:17 | Epoch [12/60], Step [175/320], Loss: 0.0013\n",
+      "2024-11-15 02:09:25 | Epoch [12/60], Step [200/320], Loss: 0.001\n",
+      "2024-11-15 02:09:34 | Epoch [12/60], Step [225/320], Loss: 0.0011\n",
+      "2024-11-15 02:09:43 | Epoch [12/60], Step [250/320], Loss: 0.0014\n",
+      "2024-11-15 02:09:51 | Epoch [12/60], Step [275/320], Loss: 0.0014\n",
+      "2024-11-15 02:09:59 | Epoch [12/60], Step [300/320], Loss: 0.0016\n",
+      "Start validation #12\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 40/40 [05:42<00:00,  8.55s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "finger-1    : 0.8662\n",
+      "finger-2    : 0.9435\n",
+      "finger-3    : 0.9627\n",
+      "finger-4    : 0.7809\n",
+      "finger-5    : 0.9005\n",
+      "finger-6    : 0.9436\n",
+      "finger-7    : 0.9616\n",
+      "finger-8    : 0.8524\n",
+      "finger-9    : 0.9067\n",
+      "finger-10   : 0.9551\n",
+      "finger-11   : 0.9522\n",
+      "finger-12   : 0.5254\n",
+      "finger-13   : 0.7696\n",
+      "finger-14   : 0.9558\n",
+      "finger-15   : 0.9386\n",
+      "finger-16   : 0.7976\n",
+      "finger-17   : 0.8231\n",
+      "finger-18   : 0.9434\n",
+      "finger-19   : 0.9518\n",
+      "Trapezium   : 0.9067\n",
+      "Trapezoid   : 0.8829\n",
+      "Capitate    : 0.9206\n",
+      "Hamate      : 0.9222\n",
+      "Scaphoid    : 0.9274\n",
+      "Lunate      : 0.9046\n",
+      "Triquetrum  : 0.9116\n",
+      "Pisiform    : 0.8255\n",
+      "Radius      : 0.9762\n",
+      "Ulna        : 0.9696\n",
+      "2024-11-15 02:15:59 | Epoch [13/60], Step [25/320], Loss: 0.0011\n",
+      "2024-11-15 02:16:08 | Epoch [13/60], Step [50/320], Loss: 0.0013\n",
+      "2024-11-15 02:16:16 | Epoch [13/60], Step [75/320], Loss: 0.0011\n",
+      "2024-11-15 02:16:24 | Epoch [13/60], Step [100/320], Loss: 0.0011\n",
+      "2024-11-15 02:16:32 | Epoch [13/60], Step [125/320], Loss: 0.001\n",
+      "2024-11-15 02:16:40 | Epoch [13/60], Step [150/320], Loss: 0.0008\n",
+      "2024-11-15 02:16:49 | Epoch [13/60], Step [175/320], Loss: 0.0009\n",
+      "2024-11-15 02:16:58 | Epoch [13/60], Step [200/320], Loss: 0.0009\n",
+      "2024-11-15 02:17:06 | Epoch [13/60], Step [225/320], Loss: 0.001\n",
+      "2024-11-15 02:17:14 | Epoch [13/60], Step [250/320], Loss: 0.0009\n",
+      "2024-11-15 02:17:22 | Epoch [13/60], Step [275/320], Loss: 0.0008\n",
+      "2024-11-15 02:17:30 | Epoch [13/60], Step [300/320], Loss: 0.0011\n",
+      "2024-11-15 02:17:47 | Epoch [14/60], Step [25/320], Loss: 0.0009\n",
+      "2024-11-15 02:17:56 | Epoch [14/60], Step [50/320], Loss: 0.0009\n",
+      "2024-11-15 02:18:04 | Epoch [14/60], Step [75/320], Loss: 0.0009\n",
+      "2024-11-15 02:18:12 | Epoch [14/60], Step [100/320], Loss: 0.0008\n",
+      "2024-11-15 02:18:20 | Epoch [14/60], Step [125/320], Loss: 0.0009\n",
+      "2024-11-15 02:18:28 | Epoch [14/60], Step [150/320], Loss: 0.0008\n",
+      "2024-11-15 02:18:37 | Epoch [14/60], Step [175/320], Loss: 0.0016\n",
+      "2024-11-15 02:18:45 | Epoch [14/60], Step [200/320], Loss: 0.0011\n",
+      "2024-11-15 02:18:53 | Epoch [14/60], Step [225/320], Loss: 0.001\n",
+      "2024-11-15 02:19:01 | Epoch [14/60], Step [250/320], Loss: 0.001\n",
+      "2024-11-15 02:19:09 | Epoch [14/60], Step [275/320], Loss: 0.0009\n",
+      "2024-11-15 02:19:18 | Epoch [14/60], Step [300/320], Loss: 0.0008\n",
+      "2024-11-15 02:19:36 | Epoch [15/60], Step [25/320], Loss: 0.0008\n",
+      "2024-11-15 02:19:44 | Epoch [15/60], Step [50/320], Loss: 0.0008\n",
+      "2024-11-15 02:19:52 | Epoch [15/60], Step [75/320], Loss: 0.0008\n",
+      "2024-11-15 02:20:00 | Epoch [15/60], Step [100/320], Loss: 0.0007\n",
+      "2024-11-15 02:20:08 | Epoch [15/60], Step [125/320], Loss: 0.0009\n",
+      "2024-11-15 02:20:17 | Epoch [15/60], Step [150/320], Loss: 0.0008\n",
+      "2024-11-15 02:20:25 | Epoch [15/60], Step [175/320], Loss: 0.001\n",
+      "2024-11-15 02:20:33 | Epoch [15/60], Step [200/320], Loss: 0.0009\n",
+      "2024-11-15 02:20:41 | Epoch [15/60], Step [225/320], Loss: 0.0009\n",
+      "2024-11-15 02:20:50 | Epoch [15/60], Step [250/320], Loss: 0.0007\n",
+      "2024-11-15 02:20:58 | Epoch [15/60], Step [275/320], Loss: 0.0007\n",
+      "2024-11-15 02:21:06 | Epoch [15/60], Step [300/320], Loss: 0.0008\n",
+      "Start validation #15\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 40/40 [05:37<00:00,  8.44s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "finger-1    : 0.9274\n",
+      "finger-2    : 0.9557\n",
+      "finger-3    : 0.9674\n",
+      "finger-4    : 0.9288\n",
+      "finger-5    : 0.9491\n",
+      "finger-6    : 0.9644\n",
+      "finger-7    : 0.9656\n",
+      "finger-8    : 0.9275\n",
+      "finger-9    : 0.9531\n",
+      "finger-10   : 0.9680\n",
+      "finger-11   : 0.9616\n",
+      "finger-12   : 0.9381\n",
+      "finger-13   : 0.9510\n",
+      "finger-14   : 0.9637\n",
+      "finger-15   : 0.9539\n",
+      "finger-16   : 0.9222\n",
+      "finger-17   : 0.9359\n",
+      "finger-18   : 0.9616\n",
+      "finger-19   : 0.9665\n",
+      "Trapezium   : 0.9262\n",
+      "Trapezoid   : 0.8951\n",
+      "Capitate    : 0.9464\n",
+      "Hamate      : 0.9293\n",
+      "Scaphoid    : 0.9485\n",
+      "Lunate      : 0.9340\n",
+      "Triquetrum  : 0.9293\n",
+      "Pisiform    : 0.8605\n",
+      "Radius      : 0.9785\n",
+      "Ulna        : 0.9728\n",
+      "Best performance at epoch: 15, 0.9380 -> 0.9442\n",
+      "Save model in /data/ephemeral/home/data/result\n",
+      "2024-11-15 02:27:04 | Epoch [16/60], Step [25/320], Loss: 0.0007\n",
+      "2024-11-15 02:27:12 | Epoch [16/60], Step [50/320], Loss: 0.001\n",
+      "2024-11-15 02:27:21 | Epoch [16/60], Step [75/320], Loss: 0.0008\n",
+      "2024-11-15 02:27:29 | Epoch [16/60], Step [100/320], Loss: 0.0019\n",
+      "2024-11-15 02:27:37 | Epoch [16/60], Step [125/320], Loss: 0.002\n",
+      "2024-11-15 02:27:45 | Epoch [16/60], Step [150/320], Loss: 0.001\n",
+      "2024-11-15 02:27:53 | Epoch [16/60], Step [175/320], Loss: 0.0009\n",
+      "2024-11-15 02:28:01 | Epoch [16/60], Step [200/320], Loss: 0.0009\n",
+      "2024-11-15 02:28:09 | Epoch [16/60], Step [225/320], Loss: 0.0009\n",
+      "2024-11-15 02:28:17 | Epoch [16/60], Step [250/320], Loss: 0.0008\n",
+      "2024-11-15 02:28:25 | Epoch [16/60], Step [275/320], Loss: 0.0007\n",
+      "2024-11-15 02:28:33 | Epoch [16/60], Step [300/320], Loss: 0.0009\n",
+      "2024-11-15 02:28:50 | Epoch [17/60], Step [25/320], Loss: 0.0008\n",
+      "2024-11-15 02:28:58 | Epoch [17/60], Step [50/320], Loss: 0.0007\n",
+      "2024-11-15 02:29:07 | Epoch [17/60], Step [75/320], Loss: 0.0008\n",
+      "2024-11-15 02:29:15 | Epoch [17/60], Step [100/320], Loss: 0.0009\n",
+      "2024-11-15 02:29:23 | Epoch [17/60], Step [125/320], Loss: 0.0008\n",
+      "2024-11-15 02:29:31 | Epoch [17/60], Step [150/320], Loss: 0.0006\n",
+      "2024-11-15 02:29:39 | Epoch [17/60], Step [175/320], Loss: 0.0012\n",
+      "2024-11-15 02:29:47 | Epoch [17/60], Step [200/320], Loss: 0.001\n",
+      "2024-11-15 02:29:55 | Epoch [17/60], Step [225/320], Loss: 0.001\n",
+      "2024-11-15 02:30:03 | Epoch [17/60], Step [250/320], Loss: 0.0009\n",
+      "2024-11-15 02:30:11 | Epoch [17/60], Step [275/320], Loss: 0.0007\n",
+      "2024-11-15 02:30:19 | Epoch [17/60], Step [300/320], Loss: 0.0007\n",
+      "2024-11-15 02:30:36 | Epoch [18/60], Step [25/320], Loss: 0.0006\n",
+      "2024-11-15 02:30:45 | Epoch [18/60], Step [50/320], Loss: 0.0007\n",
+      "2024-11-15 02:30:53 | Epoch [18/60], Step [75/320], Loss: 0.0007\n",
+      "2024-11-15 02:31:01 | Epoch [18/60], Step [100/320], Loss: 0.0006\n",
+      "2024-11-15 02:31:09 | Epoch [18/60], Step [125/320], Loss: 0.0007\n",
+      "2024-11-15 02:31:17 | Epoch [18/60], Step [150/320], Loss: 0.0007\n",
+      "2024-11-15 02:31:25 | Epoch [18/60], Step [175/320], Loss: 0.0008\n",
+      "2024-11-15 02:31:33 | Epoch [18/60], Step [200/320], Loss: 0.0007\n",
+      "2024-11-15 02:31:42 | Epoch [18/60], Step [225/320], Loss: 0.001\n",
+      "2024-11-15 02:31:49 | Epoch [18/60], Step [250/320], Loss: 0.0006\n",
+      "2024-11-15 02:31:58 | Epoch [18/60], Step [275/320], Loss: 0.0006\n",
+      "2024-11-15 02:32:05 | Epoch [18/60], Step [300/320], Loss: 0.0007\n",
+      "Start validation #18\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 40/40 [05:45<00:00,  8.65s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "finger-1    : 0.9375\n",
+      "finger-2    : 0.9577\n",
+      "finger-3    : 0.9707\n",
+      "finger-4    : 0.9349\n",
+      "finger-5    : 0.9513\n",
+      "finger-6    : 0.9686\n",
+      "finger-7    : 0.9687\n",
+      "finger-8    : 0.9272\n",
+      "finger-9    : 0.9381\n",
+      "finger-10   : 0.9688\n",
+      "finger-11   : 0.9642\n",
+      "finger-12   : 0.9362\n",
+      "finger-13   : 0.9478\n",
+      "finger-14   : 0.9673\n",
+      "finger-15   : 0.9614\n",
+      "finger-16   : 0.9146\n",
+      "finger-17   : 0.9291\n",
+      "finger-18   : 0.9435\n",
+      "finger-19   : 0.9671\n",
+      "Trapezium   : 0.9281\n",
+      "Trapezoid   : 0.8982\n",
+      "Capitate    : 0.9469\n",
+      "Hamate      : 0.9285\n",
+      "Scaphoid    : 0.9526\n",
+      "Lunate      : 0.9384\n",
+      "Triquetrum  : 0.9269\n",
+      "Pisiform    : 0.8527\n",
+      "Radius      : 0.9807\n",
+      "Ulna        : 0.9750\n",
+      "Best performance at epoch: 18, 0.9442 -> 0.9442\n",
+      "Save model in /data/ephemeral/home/data/result\n",
+      "2024-11-15 02:38:12 | Epoch [19/60], Step [25/320], Loss: 0.0006\n",
+      "2024-11-15 02:38:21 | Epoch [19/60], Step [50/320], Loss: 0.0009\n",
+      "2024-11-15 02:38:29 | Epoch [19/60], Step [75/320], Loss: 0.0007\n",
+      "2024-11-15 02:38:38 | Epoch [19/60], Step [100/320], Loss: 0.0007\n",
+      "2024-11-15 02:38:49 | Epoch [19/60], Step [125/320], Loss: 0.0006\n",
+      "2024-11-15 02:39:06 | Epoch [19/60], Step [150/320], Loss: 0.0005\n",
+      "2024-11-15 02:39:14 | Epoch [19/60], Step [175/320], Loss: 0.0005\n",
+      "2024-11-15 02:39:22 | Epoch [19/60], Step [200/320], Loss: 0.0006\n",
+      "2024-11-15 02:39:30 | Epoch [19/60], Step [225/320], Loss: 0.0006\n",
+      "2024-11-15 02:39:38 | Epoch [19/60], Step [250/320], Loss: 0.0006\n",
+      "2024-11-15 02:39:47 | Epoch [19/60], Step [275/320], Loss: 0.0006\n",
+      "2024-11-15 02:39:56 | Epoch [19/60], Step [300/320], Loss: 0.0007\n",
+      "2024-11-15 02:40:13 | Epoch [20/60], Step [25/320], Loss: 0.0006\n",
+      "2024-11-15 02:40:22 | Epoch [20/60], Step [50/320], Loss: 0.0005\n",
+      "2024-11-15 02:40:30 | Epoch [20/60], Step [75/320], Loss: 0.0006\n",
+      "2024-11-15 02:40:38 | Epoch [20/60], Step [100/320], Loss: 0.0005\n",
+      "2024-11-15 02:40:46 | Epoch [20/60], Step [125/320], Loss: 0.0006\n",
+      "2024-11-15 02:40:54 | Epoch [20/60], Step [150/320], Loss: 0.0005\n",
+      "2024-11-15 02:41:04 | Epoch [20/60], Step [175/320], Loss: 0.0006\n",
+      "2024-11-15 02:41:12 | Epoch [20/60], Step [200/320], Loss: 0.0007\n"
      ]
     }
    ],
@@ -1005,8 +1518,8 @@
     "\n",
     "        for step, (images, image_names) in tqdm(enumerate(data_loader), total=len(data_loader)):\n",
     "            images = images.cuda()    \n",
-    "            # outputs = model(images)['out']\n",
-    "            outputs = model(images)\n",
+    "            outputs = model(images)['out']\n",
+    "            # outputs = model(images)\n",
     "            \n",
     "            outputs = F.interpolate(outputs, size=(2048, 2048), mode=\"bilinear\")\n",
     "            outputs = torch.sigmoid(outputs)\n",
@@ -1183,8 +1696,16 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df.to_csv(\"smp_Unet_efficient-b0.csv\", index=False)"
+    "df.to_csv(\"torchvision_fcn_resnet101.csv\", index=False)"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3af293a9",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
diff --git a/module_base/inference.py b/module_base/inference.py
index 89d02f3..40efa9b 100644
--- a/module_base/inference.py
+++ b/module_base/inference.py
@@ -15,7 +15,7 @@ def parse_args():
     
     parser.add_argument('--image_root', type=str, default='/data/ephemeral/home/data/test/DCM',
                         help='Path to the root directory containing images')
-    parser.add_argument('--save_dir', type=str, default="/data/ephemeral/home/data/train/result",
+    parser.add_argument('--save_dir', type=str, default="/data/ephemeral/home/data/result",
                         help='Path to the root directory containing save direction')
     parser.add_argument('--random_seed', type=int, default=21)
     args = parser.parse_args()
@@ -79,7 +79,8 @@ def test(model, data_loader, thr=0.5):
 
         for step, (images, image_names) in tqdm(enumerate(data_loader), total=len(data_loader)):
             images = images.cuda()    
-            outputs = model(images)['out']
+            # outputs = model(images)['out']
+            outputs = model(images)
             
             outputs = F.interpolate(outputs, size=(2048, 2048), mode="bilinear")
             outputs = torch.sigmoid(outputs)
diff --git a/module_base/model.py b/module_base/model.py
index b4dcb3a..8a59f70 100644
--- a/module_base/model.py
+++ b/module_base/model.py
@@ -14,7 +14,7 @@
 '''
 
 class TorchvisionModel(nn.Module):
-    def __init__(self, model_name, num_classes, pretrained):
+    def __init__(self, model_name, num_classes, pretrained=True):
         super(TorchvisionModel, self).__init__()
         self.model = models.segmentation.__dict__[model_name](pretrained=pretrained)
         self.model.classifier[-1] = nn.Conv2d(512, num_classes, kernel_size=1)
@@ -50,7 +50,6 @@ def __init__(self, model_type, num_classes, **kwargs):
             self.model = TorchvisionModel(num_classes=num_classes, **kwargs)
         
         elif model_type == 'smp':
-            pass
             self.model = SMP(num_classes=num_classes, **kwargs)
         
         else:
diff --git a/module_base/train.py b/module_base/train.py
index 99762cb..c32c333 100644
--- a/module_base/train.py
+++ b/module_base/train.py
@@ -227,9 +227,6 @@ def do_training(image_root, label_root, save_dir, batch_size, learning_rate, max
     )
     model = model_selector.get_model()
     
-    # output class 개수를 dataset에 맞도록 수정합니다.
-    model.classifier[4] = nn.Conv2d(512, len(CLASSES), kernel_size=1)
-
     # Loss function을 정의합니다.
     criterion = nn.BCEWithLogitsLoss()
 

From 69b145d9bef0f62a986bb665ffd81735716f64cd Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Fri, 15 Nov 2024 12:06:49 +0900
Subject: [PATCH 022/106] [Feature] : model types select outputs

---
 module_base/inference.py | 17 ++++++++++-------
 module_base/train.py     | 36 +++++++++++++++++++++++++-----------
 2 files changed, 35 insertions(+), 18 deletions(-)

diff --git a/module_base/inference.py b/module_base/inference.py
index 40efa9b..a173498 100644
--- a/module_base/inference.py
+++ b/module_base/inference.py
@@ -17,7 +17,8 @@ def parse_args():
                         help='Path to the root directory containing images')
     parser.add_argument('--save_dir', type=str, default="/data/ephemeral/home/data/result",
                         help='Path to the root directory containing save direction')
-    parser.add_argument('--random_seed', type=int, default=21)
+    parser.add_argument('--random_seed', type=int, default=2024)
+    parser.add_argument('--model_type', type=str, default='smp')
     args = parser.parse_args()
     
     return args
@@ -68,7 +69,7 @@ def decode_rle_to_mask(rle, height, width):
     
     return img.reshape(height, width)
 
-def test(model, data_loader, thr=0.5):
+def test(model, data_loader, model_type, thr=0.5):
     model = model.cuda()
     model.eval()
 
@@ -78,9 +79,11 @@ def test(model, data_loader, thr=0.5):
         n_class = len(CLASSES)
 
         for step, (images, image_names) in tqdm(enumerate(data_loader), total=len(data_loader)):
-            images = images.cuda()    
-            # outputs = model(images)['out']
-            outputs = model(images)
+            images = images.cuda()  
+            if model_type == 'torchvision':
+                outputs = model(images)['out']
+            elif model_type == 'smp':
+                outputs = model(images)  
             
             outputs = F.interpolate(outputs, size=(2048, 2048), mode="bilinear")
             outputs = torch.sigmoid(outputs)
@@ -94,7 +97,7 @@ def test(model, data_loader, thr=0.5):
                     
     return rles, filename_and_class
 
-def do_inference(image_root, save_dir, random_seed):
+def do_inference(image_root, save_dir, random_seed, model_type):
     set_seed(random_seed)
     pngs = {
         os.path.relpath(os.path.join(root, fname), start=image_root)
@@ -115,7 +118,7 @@ def do_inference(image_root, save_dir, random_seed):
         drop_last=False
     )
     
-    rles, filename_and_class = test(model, test_loader)
+    rles, filename_and_class = test(model, test_loader, model_type)
     
     classes, filename = zip(*[x.split("_") for x in filename_and_class])
     
diff --git a/module_base/train.py b/module_base/train.py
index c32c333..bf6c878 100644
--- a/module_base/train.py
+++ b/module_base/train.py
@@ -33,6 +33,7 @@ def parse_args():
     parser.add_argument('--model_type', type=str, default='smp')
     parser.add_argument('--model_name', type=str, default='efficientnet-b0')
     parser.add_argument('--encoder_weights', type=str, default='imagenet')
+    # parser.add_argument('--pretrained', type=str, default='True')
     args = parser.parse_args()
     
     return args
@@ -69,7 +70,7 @@ def save_model(model, save_dir, file_name='fcn_resnet50_best_model.pt'):
     output_path = os.path.join(save_dir, file_name)
     torch.save(model, output_path)
 
-def validation(epoch, model, data_loader, criterion, thr=0.5):
+def validation(epoch, model, data_loader, criterion, model_type, thr=0.5):
     print(f'Start validation #{epoch:2d}')
     model.eval()
 
@@ -83,8 +84,10 @@ def validation(epoch, model, data_loader, criterion, thr=0.5):
             images, masks = images.cuda(), masks.cuda()         
             model = model.cuda()
             
-            # outputs = model(images)['out']
-            outputs = model(images)
+            if model_type == 'torchvision':
+                outputs = model(images)['out']
+            elif model_type == 'smp':
+                outputs = model(images)
             
             output_h, output_w = outputs.size(-2), outputs.size(-1)
             mask_h, mask_w = masks.size(-2), masks.size(-1)
@@ -110,14 +113,14 @@ def validation(epoch, model, data_loader, criterion, thr=0.5):
         f"{c:<12}: {d.item():.4f}"
         for c, d in zip(CLASSES, dices_per_class)
     ]
-    dice_str = "\n".join(dice_str)
+    dice_str = "\n".join(dice_str) 
     print(dice_str)
     
     avg_dice = torch.mean(dices_per_class).item()
     
     return avg_dice
 
-def train(model, train_loader, valid_loader, criterion, optimizer, save_dir, random_seed, max_epoch, val_every):
+def train(model, train_loader, valid_loader, criterion, optimizer, save_dir, random_seed, max_epoch, val_every, model_type):
     print(f'Start training..')
     
     n_class = len(CLASSES)
@@ -134,8 +137,10 @@ def train(model, train_loader, valid_loader, criterion, optimizer, save_dir, ran
             images, masks = images.cuda(), masks.cuda()
             model = model.cuda()
             
-            # outputs = model(images)['out']
-            # outputs = model(images)
+            # if model_type == 'torchvision':
+            #     outputs = model(images)['out']
+            # elif model_type == 'smp':
+            #     outputs = model(images)
             
             # loss를 계산합니다.
             # loss = criterion(outputs, masks)
@@ -145,8 +150,10 @@ def train(model, train_loader, valid_loader, criterion, optimizer, save_dir, ran
 
             # Mixed Precision Training 적용
             with torch.cuda.amp.autocast():
-                # outputs = model(images)['out']
-                outputs = model(images)
+                if model_type == 'torchvision':
+                    outputs = model(images)['out']
+                elif model_type == 'smp':
+                    outputs = model(images)
                 loss = criterion(outputs, masks)
             
             # 스케일된 loss를 사용해 backward 및 optimizer step
@@ -168,7 +175,7 @@ def train(model, train_loader, valid_loader, criterion, optimizer, save_dir, ran
         if (epoch + 1) % val_every == 0:
             # 캐시된 메모리를 해제하여 PyTorch의 메모리 누수를 방지
             torch.cuda.empty_cache()
-            dice = validation(epoch + 1, model, valid_loader, criterion)
+            dice = validation(epoch + 1, model, valid_loader, criterion, model_type)
             
             if best_dice < dice:
                 print(f"Best performance at epoch: {epoch + 1}, {best_dice:.4f} -> {dice:.4f}")
@@ -199,6 +206,13 @@ def do_training(image_root, label_root, save_dir, batch_size, learning_rate, max
         os.makedirs(save_dir)
     
     tf = A.Resize(512, 512)
+    '''
+    ************************************** augmentatoin도 모듈화 할 것 **************************************
+    train_tf = A.Compose([
+        A.Resize(512, 512),      
+        A.HorizontalFlip(p=0.3),
+    ])
+    '''
     
     train_dataset = XRayDataset(pngs, jsons, CLASS2IND, CLASSES, image_root, label_root, is_train=True, transforms=tf)
     valid_dataset = XRayDataset(pngs, jsons, CLASS2IND, CLASSES, image_root, label_root, is_train=False, transforms=tf)
@@ -236,7 +250,7 @@ def do_training(image_root, label_root, save_dir, batch_size, learning_rate, max
     # 시드를 설정합니다.
     set_seed(random_seed)
     
-    train(model, train_loader, valid_loader, criterion, optimizer, save_dir, random_seed, max_epoch, val_every)
+    train(model, train_loader, valid_loader, criterion, optimizer, save_dir, random_seed, max_epoch, val_every, model_type)
 
 def main(args):
     do_training(**args.__dict__)

From f321857af3d8b02cff8d6b787a18c6ef84db9d7f Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Sat, 16 Nov 2024 16:17:30 +0900
Subject: [PATCH 023/106] [Refactor]:mmsegmentation custom config folder
 structure refactoring

---
 .../default_runtime.py                        |  1 -
 .../{mask2former => _base_}/schedule_160k.py  | 31 ++++++++++++-------
 .../{mask2former => _base_}/xraydata.py       | 14 ++++-----
 .../{mask2former => _base_}/xraydata2.py      |  0
 .../_custom_/mask2former/mask2former.py       | 10 +++---
 5 files changed, 32 insertions(+), 24 deletions(-)
 rename mmsegmentation/configs/_custom_/{mask2former => _base_}/default_runtime.py (97%)
 rename mmsegmentation/configs/_custom_/{mask2former => _base_}/schedule_160k.py (65%)
 rename mmsegmentation/configs/_custom_/{mask2former => _base_}/xraydata.py (86%)
 rename mmsegmentation/configs/_custom_/{mask2former => _base_}/xraydata2.py (100%)

diff --git a/mmsegmentation/configs/_custom_/mask2former/default_runtime.py b/mmsegmentation/configs/_custom_/_base_/default_runtime.py
similarity index 97%
rename from mmsegmentation/configs/_custom_/mask2former/default_runtime.py
rename to mmsegmentation/configs/_custom_/_base_/default_runtime.py
index 61a91aa..7ba44fe 100644
--- a/mmsegmentation/configs/_custom_/mask2former/default_runtime.py
+++ b/mmsegmentation/configs/_custom_/_base_/default_runtime.py
@@ -24,7 +24,6 @@
             type='MMSegWandbHook',
             by_epoch=False,
             interval=1,
-            with_step=False,
             init_kwargs=dict(
                 entity='frostings',
                 project='Boost Camp Lv2-3',
diff --git a/mmsegmentation/configs/_custom_/mask2former/schedule_160k.py b/mmsegmentation/configs/_custom_/_base_/schedule_160k.py
similarity index 65%
rename from mmsegmentation/configs/_custom_/mask2former/schedule_160k.py
rename to mmsegmentation/configs/_custom_/_base_/schedule_160k.py
index 73923d6..c804b84 100644
--- a/mmsegmentation/configs/_custom_/mask2former/schedule_160k.py
+++ b/mmsegmentation/configs/_custom_/_base_/schedule_160k.py
@@ -1,13 +1,17 @@
-val_save_interval = 3000
+val_save_interval = 2000
+warm_up_step = 1000
+max_iters = 30000
+T_max = max_iters-warm_up_step
 
 # optimizer
 embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
 optimizer = dict(
-    type='AdamW', lr=0.0001, weight_decay=0.05, eps=1e-8, betas=(0.9, 0.999))
+    type='AdamW', lr=0.001, weight_decay=0.05, eps=1e-8, betas=(0.9, 0.999))
 optim_wrapper = dict(
     type='OptimWrapper',
     optimizer=optimizer,
     clip_grad=dict(max_norm=0.01, norm_type=2),
+    accumulative_counts=2,
     paramwise_cfg=dict(
         custom_keys={
             'backbone': dict(lr_mult=0.1, decay_mult=1.0),
@@ -18,18 +22,22 @@
         norm_decay_mult=0.0))
 # learning policy
 param_scheduler = [
-    dict(
-        type='PolyLR',
-        eta_min=0,
-        power=0.9,
-        begin=0,
-        end=90000,
-        by_epoch=False)
+    dict(type='LinearLR',
+         start_factor=0.001,
+         by_epoch=False,
+         begin=0,
+         end=warm_up_step),
+    dict(type='CosineAnnealingLR',
+         T_max=T_max,
+         by_epoch=False,
+         begin=warm_up_step,
+         end=max_iters)
 ]
+optimizer_config = dict(type="GradientCumulativeOptimizerHook", cumulative_iters=2)
 
 # training schedule for 90k
 train_cfg = dict(type='IterBasedTrainLoop', 
-                 max_iters=90000, 
+                 max_iters=max_iters, 
                  val_interval=val_save_interval
                  )
 val_cfg = dict(type='ValLoop')
@@ -45,4 +53,5 @@
                     save_best='mDice',
                     rule='greater'),
     sampler_seed=dict(type='DistSamplerSeedHook'),
-    visualization=dict(type='SegVisualizationHook'))
\ No newline at end of file
+    visualization=dict(type='SegVisualizationHook')
+    )
\ No newline at end of file
diff --git a/mmsegmentation/configs/_custom_/mask2former/xraydata.py b/mmsegmentation/configs/_custom_/_base_/xraydata.py
similarity index 86%
rename from mmsegmentation/configs/_custom_/mask2former/xraydata.py
rename to mmsegmentation/configs/_custom_/_base_/xraydata.py
index 7ff37a4..f09252d 100644
--- a/mmsegmentation/configs/_custom_/mask2former/xraydata.py
+++ b/mmsegmentation/configs/_custom_/_base_/xraydata.py
@@ -1,9 +1,10 @@
-resize_size = (1748, 1748)
+resize_size = (2048, 2048)
 crop_size = (1536, 1536)
 test_size = (2048, 2048)
 
 dataset_type = 'XRayDataset'
-data_root = '/data/ephemeral/home/cityscapes_format_xlay/'
+data_root = '/data/ephemeral/home/cityscapes_format_xlay_kfold/'
+fold = 2
 
 
 train_pipeline = [
@@ -13,7 +14,7 @@
     #     type='RandomChoiceResize',
     #     scales=[int(1024 * x * 0.1) for x in range(5, 21)],
     #     resize_type='ResizeShortestEdge',
-    #     max_size=4096),
+    #     max_size=1536),
     dict(type='Resize', scale=resize_size, keep_ratio=True),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
@@ -29,7 +30,7 @@
     dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        data_prefix=dict(img_path='leftImg8bit/train', seg_map_path='gtFine/train'),
+        data_prefix=dict(img_path=f'leftImg8bit/train/fold_{fold}', seg_map_path=f'gtFine/train/fold_{fold}'),
         img_suffix='.png',
         seg_map_suffix='_gtFine_labelIds.png',
         pipeline=train_pipeline))
@@ -57,7 +58,7 @@
     dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        data_prefix=dict(img_path='leftImg8bit/val', seg_map_path='gtFine/val'),
+        data_prefix=dict(img_path=f'leftImg8bit/val/fold_{fold}', seg_map_path=f'gtFine/val/fold_{fold}'),
         img_suffix='.png',
         seg_map_suffix='_gtFine_labelIds.png',
         pipeline=val_pipeline))
@@ -77,8 +78,7 @@
 
 val_evaluator = dict(type='DiceMetric')
 test_evaluator = dict(type='SubmissionMetric', save_path = "/data/ephemeral/home/submission")
-# val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
-# test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+
 
 img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
 tta_pipeline = [
diff --git a/mmsegmentation/configs/_custom_/mask2former/xraydata2.py b/mmsegmentation/configs/_custom_/_base_/xraydata2.py
similarity index 100%
rename from mmsegmentation/configs/_custom_/mask2former/xraydata2.py
rename to mmsegmentation/configs/_custom_/_base_/xraydata2.py
diff --git a/mmsegmentation/configs/_custom_/mask2former/mask2former.py b/mmsegmentation/configs/_custom_/mask2former/mask2former.py
index 6204258..d415437 100644
--- a/mmsegmentation/configs/_custom_/mask2former/mask2former.py
+++ b/mmsegmentation/configs/_custom_/mask2former/mask2former.py
@@ -1,14 +1,14 @@
 _base_ = [
-    './xraydata.py',
-    './default_runtime.py', './schedule_160k.py'
+    '../_base_/xraydata.py',
+    '../_base_/default_runtime.py', '../_base_/schedule_160k.py'
 ]
 
-crop_size = _base_.crop_size
+crop_size = (512, 1024)
 load_from = 'https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221202_141901-28ad20f1.pth'
-# load_from = '/data/ephemeral/home/parkjunil/work_dir/mask2former/iter_12800.pth'
 pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_large_patch4_window12_384_22k_20220412-6580f57d.pth'
 depths = [2, 2, 18, 2]
 num_classes = 30
+class_weight = [1.0] * 20 + [1.3] * 7 + [1.5] + [1.0] * 2 + [0.1]
 
 
 data_preprocessor = dict(
@@ -116,7 +116,7 @@
             use_sigmoid=False,
             loss_weight=2.0,
             reduction='mean',
-            class_weight=[1.0] * num_classes + [0.1]),
+            class_weight=class_weight),
         loss_mask=dict(
             type='mmdet.CrossEntropyLoss',
             use_sigmoid=True,

From b87850504378720dd8c5b4b9c4f64ded22e4eaad Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Sat, 16 Nov 2024 16:18:37 +0900
Subject: [PATCH 024/106] [Feature]:add kfold_split with grouping same patient

---
 utils/ufo_to_cityscapes.py | 24 +++++++++++++++---------
 1 file changed, 15 insertions(+), 9 deletions(-)

diff --git a/utils/ufo_to_cityscapes.py b/utils/ufo_to_cityscapes.py
index d11a4f0..946d6c2 100644
--- a/utils/ufo_to_cityscapes.py
+++ b/utils/ufo_to_cityscapes.py
@@ -7,7 +7,7 @@
 
 # 기본 경로 설정
 input_dir = '/data/ephemeral/home/data'
-output_dir = '/data/ephemeral/home/cityscapes_format_xlay'
+output_dir = '/data/ephemeral/home/cityscapes_format_xlay_kfold'
 n_splits = 5  # GroupKFold의 분할 개수
 
 CLASSES = [
@@ -32,8 +32,15 @@
 # 경로 생성
 def create_cityscapes_dirs():
     for split in ['train', 'val', 'test']:
-        os.makedirs(os.path.join(output_dir, 'leftImg8bit', split), exist_ok=True)
-        os.makedirs(os.path.join(output_dir, 'gtFine', split), exist_ok=True)
+        
+        if split == 'test':
+            os.makedirs(os.path.join(output_dir, 'leftImg8bit', split), exist_ok=True)
+            os.makedirs(os.path.join(output_dir, 'gtFine', split), exist_ok=True)
+        
+        else:
+            for fold in range(1, n_splits+1):
+                os.makedirs(os.path.join(output_dir, 'leftImg8bit', split, f"fold_{fold}"), exist_ok=True)
+                os.makedirs(os.path.join(output_dir, 'gtFine', split, f"fold_{fold}"), exist_ok=True)
 
 # JSON 파일을 읽어 label 및 instance 마스크 생성
 def create_masks(json_file, img_shape, label_map):
@@ -114,18 +121,17 @@ def split_and_create_masks(img_paths, json_paths, groups, label_map):
 
                 # 저장 경로 설정
                 base_name = f"{id_folder}_{os.path.splitext(img_filename)[0]}_gtFine"
-                img_output_path = os.path.join(output_dir, 'leftImg8bit', split, f"{id_folder}_{img_filename}")
-                label_output_path = os.path.join(output_dir, 'gtFine', split, f"{base_name}_labelIds.png")
-                instance_output_path = os.path.join(output_dir, 'gtFine', split, f"{base_name}_instanceIds.png")
-                color_output_path = os.path.join(output_dir, 'gtFine', split, f"{base_name}_color.png")
+                img_output_path = os.path.join(output_dir, 'leftImg8bit', split, f"fold_{fold}", f"{id_folder}_{img_filename}")
+                label_output_path = os.path.join(output_dir, 'gtFine', split, f"fold_{fold}", f"{base_name}_labelIds.png")
+                instance_output_path = os.path.join(output_dir, 'gtFine', split, f"fold_{fold}", f"{base_name}_instanceIds.png")
+                color_output_path = os.path.join(output_dir, 'gtFine', split, f"fold_{fold}", f"{base_name}_color.png")
 
                 # 파일 저장
                 img.save(img_output_path)
                 label_mask.save(label_output_path)
                 instance_mask.save(instance_output_path)
                 color_mask.save(color_output_path)
-        
-        break
+                
 
 # 테스트 데이터 복사
 def copy_test_files():

From 3a771480abcf6cfa2b6ca11332b1fdc40799fa05 Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Mon, 18 Nov 2024 15:41:37 +0900
Subject: [PATCH 025/106] [#21] Feature : add transform.py

---
 module_base/dataset.py   | 16 +++++++++++++---
 module_base/inference.py |  2 +-
 module_base/model.py     |  1 -
 module_base/train.py     | 41 ++++++++++++++++++----------------------
 module_base/transform.py | 36 +++++++++++++++++++++++++++++++++++
 5 files changed, 68 insertions(+), 28 deletions(-)
 create mode 100644 module_base/transform.py

diff --git a/module_base/dataset.py b/module_base/dataset.py
index ce0a90c..8e9b755 100644
--- a/module_base/dataset.py
+++ b/module_base/dataset.py
@@ -7,8 +7,19 @@
 from torch.utils.data import Dataset
 from sklearn.model_selection import GroupKFold
 
+CLASSES = [
+    'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
+    'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
+    'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
+    'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
+    'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
+    'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
+]
+
+CLASS2IND = {v: i for i, v in enumerate(CLASSES)}
+
 class XRayDataset(Dataset):
-    def __init__(self, pngs, jsons, class2ind, classes, image_root, label_root, is_train=True, transforms=None):
+    def __init__(self, pngs, jsons, classes, image_root, label_root, is_train=True, transforms=None):
         self.pngs = pngs
         self.jsons = jsons
         _filenames = np.array(self.pngs)
@@ -49,7 +60,6 @@ def __init__(self, pngs, jsons, class2ind, classes, image_root, label_root, is_t
         self.labelnames = labelnames
         self.is_train = is_train
         self.transforms = transforms
-        self.class2ind = class2ind
         self.classes = classes
         self.image_root = image_root
         self.label_root = label_root
@@ -79,7 +89,7 @@ def __getitem__(self, item):
         # 클래스 별로 처리합니다.
         for ann in annotations:
             c = ann["label"]
-            class_ind = self.class2ind[c]
+            class_ind = CLASS2IND[c]
             points = np.array(ann["points"])
             
             # polygon 포맷을 dense한 mask 포맷으로 바꿉니다.
diff --git a/module_base/inference.py b/module_base/inference.py
index a173498..94f4a2b 100644
--- a/module_base/inference.py
+++ b/module_base/inference.py
@@ -76,7 +76,7 @@ def test(model, data_loader, model_type, thr=0.5):
     rles = []
     filename_and_class = []
     with torch.no_grad():
-        n_class = len(CLASSES)
+        # n_class = len(CLASSES)
 
         for step, (images, image_names) in tqdm(enumerate(data_loader), total=len(data_loader)):
             images = images.cuda()  
diff --git a/module_base/model.py b/module_base/model.py
index 8a59f70..d96be5f 100644
--- a/module_base/model.py
+++ b/module_base/model.py
@@ -36,7 +36,6 @@ def __init__(self, model_name, encoder_weights, num_classes):
         )
 
     def forward(self, x):
-        
         return self.model(x)
 
 class ModelSelector:
diff --git a/module_base/train.py b/module_base/train.py
index bf6c878..f26fac3 100644
--- a/module_base/train.py
+++ b/module_base/train.py
@@ -13,6 +13,7 @@
 from torchvision import models
 from dataset import XRayDataset
 from model import ModelSelector
+from transform import TransformSelector
 from argparse import ArgumentParser
 
 def parse_args():
@@ -30,10 +31,10 @@ def parse_args():
     parser.add_argument('--max_epoch', type=int, default=1)
     parser.add_argument('--val_every', type=int, default=5)
     parser.add_argument('--random_seed', type=int, default=2024)
-    parser.add_argument('--model_type', type=str, default='smp')
-    parser.add_argument('--model_name', type=str, default='efficientnet-b0')
-    parser.add_argument('--encoder_weights', type=str, default='imagenet')
-    # parser.add_argument('--pretrained', type=str, default='True')
+    parser.add_argument('--model_type', type=str, default='torchvision')
+    parser.add_argument('--model_name', type=str, default='fcn_resnet101')
+    # parser.add_argument('--encoder_weights', type=str, default='imagenet')
+    parser.add_argument('--pretrained', type=str, default='True')
     args = parser.parse_args()
     
     return args
@@ -47,9 +48,6 @@ def parse_args():
     'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
 ]
 
-CLASS2IND = {v: i for i, v in enumerate(CLASSES)}
-IND2CLASS = {v: k for k, v in CLASS2IND.items()}
-
 def dice_coef(y_true, y_pred):
     y_true_f = y_true.flatten(2)
     y_pred_f = y_pred.flatten(2)
@@ -66,7 +64,7 @@ def set_seed(random_seed):
     np.random.seed(random_seed)
     random.seed(random_seed)
 
-def save_model(model, save_dir, file_name='fcn_resnet50_best_model.pt'):
+def save_model(model, save_dir, file_name='best_model.pt'):
     output_path = os.path.join(save_dir, file_name)
     torch.save(model, output_path)
 
@@ -76,7 +74,7 @@ def validation(epoch, model, data_loader, criterion, model_type, thr=0.5):
 
     dices = []
     with torch.no_grad():
-        n_class = len(CLASSES)
+        # n_class = len(CLASSES)
         total_loss = 0
         cnt = 0
 
@@ -123,7 +121,7 @@ def validation(epoch, model, data_loader, criterion, model_type, thr=0.5):
 def train(model, train_loader, valid_loader, criterion, optimizer, save_dir, random_seed, max_epoch, val_every, model_type):
     print(f'Start training..')
     
-    n_class = len(CLASSES)
+    # n_class = len(CLASSES)
     best_dice = 0.
 
     # GradScaler를 사용해 Mixed Precision Training을 설정
@@ -184,7 +182,7 @@ def train(model, train_loader, valid_loader, criterion, optimizer, save_dir, ran
                 save_model(model, save_dir)
 
 def do_training(image_root, label_root, save_dir, batch_size, learning_rate, max_epoch, val_every, random_seed,
-                model_type, model_name, encoder_weights):
+                model_type, model_name, pretrained):
     pngs = {
         os.path.relpath(os.path.join(root, fname), start=image_root)
         for root, _dirs, files in os.walk(image_root)
@@ -205,17 +203,13 @@ def do_training(image_root, label_root, save_dir, batch_size, learning_rate, max
     if not os.path.exists(save_dir):
         os.makedirs(save_dir)
     
-    tf = A.Resize(512, 512)
-    '''
-    ************************************** augmentatoin도 모듈화 할 것 **************************************
-    train_tf = A.Compose([
-        A.Resize(512, 512),      
-        A.HorizontalFlip(p=0.3),
-    ])
-    '''
-    
-    train_dataset = XRayDataset(pngs, jsons, CLASS2IND, CLASSES, image_root, label_root, is_train=True, transforms=tf)
-    valid_dataset = XRayDataset(pngs, jsons, CLASS2IND, CLASSES, image_root, label_root, is_train=False, transforms=tf)
+    train_trans = TransformSelector('albumentation')
+    val_trans = TransformSelector('albumentation')
+    train_tf = train_trans.get_transform(True, 512)
+    val_tf = val_trans.get_transform(False, 512)
+
+    train_dataset = XRayDataset(pngs, jsons, CLASSES, image_root, label_root, is_train=True, transforms=train_tf)
+    valid_dataset = XRayDataset(pngs, jsons, CLASSES, image_root, label_root, is_train=False, transforms=val_tf)
     
     train_loader = DataLoader(
         dataset=train_dataset, 
@@ -237,7 +231,8 @@ def do_training(image_root, label_root, save_dir, batch_size, learning_rate, max
         model_type=model_type,
         num_classes=len(CLASSES),
         model_name=model_name,
-        encoder_weights=encoder_weights,
+        # encoder_weights=encoder_weights,
+        pretrained=pretrained
     )
     model = model_selector.get_model()
     
diff --git a/module_base/transform.py b/module_base/transform.py
new file mode 100644
index 0000000..d08dc59
--- /dev/null
+++ b/module_base/transform.py
@@ -0,0 +1,36 @@
+import albumentations as A
+
+class AlbumentationTransform:
+    def __init__(self, is_train, resize):
+        common_transform = [A.Resize(resize, resize)]
+        
+        if is_train:
+            self.transform = A.Compose(
+                [
+                    A.HorizontalFlip(0.2)
+                ]+ common_transform)
+        else:
+            self.transform = A.Compose(common_transform)
+    
+    def __call__(self, **kwargs):
+        return self.transform(**kwargs)
+
+class TransformSelector:
+    """
+    이미지 변환 라이브러리를 선택하기 위한 클래스.
+    """
+    def __init__(self, transform_type):
+
+        # 지원하는 변환 라이브러리인지 확인
+        if transform_type in ["albumentation"]:
+            self.transform_type = transform_type
+        else:
+            raise ValueError("Unknown transformation library specified.")
+        
+    def get_transform(self, is_train, resize):
+        
+        # 선택된 라이브러리에 따라 적절한 변환 객체를 생성
+        if self.transform_type == 'albumentation':
+            transform = AlbumentationTransform(is_train, resize)
+        
+        return transform
\ No newline at end of file

From 753ec52ed8161c9dfe62a1df997e010708436e98 Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Mon, 18 Nov 2024 15:48:42 +0900
Subject: [PATCH 026/106] [#21] Refactor : modify train, inference

---
 module_base/inference.py | 6 ++++--
 module_base/train.py     | 2 +-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/module_base/inference.py b/module_base/inference.py
index 94f4a2b..e18c12e 100644
--- a/module_base/inference.py
+++ b/module_base/inference.py
@@ -9,6 +9,7 @@
 from torch.utils.data import DataLoader
 from argparse import ArgumentParser
 from dataset import XRayInferenceDataset
+from transform import TransformSelector
 
 def parse_args():
     parser = ArgumentParser()
@@ -107,8 +108,9 @@ def do_inference(image_root, save_dir, random_seed, model_type):
     }
     model = torch.load(os.path.join(save_dir, "best_model.pt"))
     
-    tf = A.Resize(512, 512)
-    test_dataset = XRayInferenceDataset(pngs, image_root,transforms=tf)
+    test_trans = TransformSelector('albumentation')
+    test_tf = test_trans.get_transform(False, 512)
+    test_dataset = XRayInferenceDataset(pngs, image_root,transforms=test_tf)
     
     test_loader = DataLoader(
         dataset=test_dataset, 
diff --git a/module_base/train.py b/module_base/train.py
index f26fac3..a8e7056 100644
--- a/module_base/train.py
+++ b/module_base/train.py
@@ -204,8 +204,8 @@ def do_training(image_root, label_root, save_dir, batch_size, learning_rate, max
         os.makedirs(save_dir)
     
     train_trans = TransformSelector('albumentation')
-    val_trans = TransformSelector('albumentation')
     train_tf = train_trans.get_transform(True, 512)
+    val_trans = TransformSelector('albumentation')
     val_tf = val_trans.get_transform(False, 512)
 
     train_dataset = XRayDataset(pngs, jsons, CLASSES, image_root, label_root, is_train=True, transforms=train_tf)

From 077880b6560f7798a2fddc755d040bca0b11f040 Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Mon, 18 Nov 2024 18:42:36 +0900
Subject: [PATCH 027/106] =?UTF-8?q?[Remove]=20:=20copy=20all=20png=20?=
 =?UTF-8?q?=ED=8C=8C=EC=9D=BC=20=EC=A0=9C=EA=B1=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 copy_all_png.py | 25 -------------------------
 1 file changed, 25 deletions(-)
 delete mode 100644 copy_all_png.py

diff --git a/copy_all_png.py b/copy_all_png.py
deleted file mode 100644
index 864fce4..0000000
--- a/copy_all_png.py
+++ /dev/null
@@ -1,25 +0,0 @@
-import os
-import shutil
-
-# 기본 디렉토리와 새 폴더 정의
-base_dir = 'data/test/DCM'
-new_folder = os.path.join(base_dir, 'all_pngs')
-
-# 새 폴더가 없으면 생성
-if not os.path.exists(new_folder):
-    os.makedirs(new_folder)
-
-# ID*** 폴더를 순회하며 PNG 파일을 새 폴더로 복사
-for subdir, dirs, files in os.walk(base_dir):
-    if os.path.basename(subdir) == 'all_pngs':
-        continue  # 새 폴더는 건너뛰기
-    for file in files:
-        if file.endswith('.png'):
-            src_path = os.path.join(subdir, file)
-            dst_path = os.path.join(new_folder, file)
-            shutil.copy(src_path, dst_path)
-            print(f'복사됨: {src_path} -> {dst_path}')
-
-# 결과 확인
-png_files = [f for f in os.listdir(new_folder) if f.endswith('.png')]
-print(f'복사된 PNG 파일 수: {len(png_files)}')
\ No newline at end of file

From 99a8f02d8f4df90f65f8fd511b2899bf4cb64d22 Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Tue, 19 Nov 2024 00:54:02 +0900
Subject: [PATCH 028/106] [#21] Refator : modify python files

---
 module_base/config.yaml  |  32 +++++++++++
 module_base/dataset.py   |  69 ++++++++++--------------
 module_base/inference.py |  15 ++----
 module_base/model.py     |  22 +++-----
 module_base/train.py     | 112 ++++++++++++++++-----------------------
 5 files changed, 118 insertions(+), 132 deletions(-)
 create mode 100644 module_base/config.yaml

diff --git a/module_base/config.yaml b/module_base/config.yaml
new file mode 100644
index 0000000..b27855f
--- /dev/null
+++ b/module_base/config.yaml
@@ -0,0 +1,32 @@
+# 데이터 및 모델 저장 경로
+IMAGE_ROOT: "/data/ephemeral/home/data/train/DCM"
+LABEL_ROOT: "/data/ephemeral/home/data/train/outputs_json"
+SAVED_DIR: "/data/ephemeral/home/data/result"
+
+CLASSES = [
+    'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
+    'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
+    'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
+    'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
+    'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
+    'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
+]
+
+CLASS2IND = {v: i for i, v in enumerate(CLASSES)}
+IND2CLASS = {v: k for k, v in CLASS2IND.items()}
+
+CLASSES = [
+    'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
+    'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
+    'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
+    'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
+    'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
+    'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
+]
+
+TRAIN_BATCH_SIZE = 2
+VALID_BATCH_SIZE = 4
+LR = 2e-4
+RANDOM_SEED = 2024
+NUM_EPOCHS = 50
+VAL_EVERY = 2
\ No newline at end of file
diff --git a/module_base/dataset.py b/module_base/dataset.py
index 8e9b755..c47725b 100644
--- a/module_base/dataset.py
+++ b/module_base/dataset.py
@@ -16,53 +16,41 @@
     'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
 ]
 
-CLASS2IND = {v: i for i, v in enumerate(CLASSES)}
-
 class XRayDataset(Dataset):
-    def __init__(self, pngs, jsons, classes, image_root, label_root, is_train=True, transforms=None):
-        self.pngs = pngs
-        self.jsons = jsons
-        _filenames = np.array(self.pngs)
-        _labelnames = np.array(self.jsons)
+    def __init__(self, fnames, labels, image_root, label_root, k=0, is_train=True, transforms=None):
+        self.is_train = is_train
+        self.transforms = transforms
+        self.image_root = image_root
+        self.label_root = label_root
+        self.k = k
+        self.class2ind = {v: i for i, v in enumerate(CLASSES)}
+        self.ind2class = {v: k for k, v in self.class2ind.items()}
+        self.num_classes = len(CLASSES)
         
-        # split train-valid
-        # 한 폴더 안에 한 인물의 양손에 대한 `.dcm` 파일이 존재하기 때문에
-        # 폴더 이름을 그룹으로 해서 GroupKFold를 수행합니다.
-        # 동일 인물의 손이 train, valid에 따로 들어가는 것을 방지합니다.
-        groups = [os.path.dirname(fname) for fname in _filenames]
+        groups = [os.path.dirname(fname) for fname in fnames]
         
         # dummy label
-        ys = [0 for fname in _filenames]
+        ys = [0 for fname in fnames]
         
-        # 전체 데이터의 20%를 validation data로 쓰기 위해 `n_splits`를
-        # 5으로 설정하여 KFold를 수행합니다.
         gkf = GroupKFold(n_splits=5)
         
         filenames = []
         labelnames = []
-        for i, (x, y) in enumerate(gkf.split(_filenames, ys, groups)):
-            if is_train:
-                # 0번을 validation dataset으로 사용합니다.
-                if i == 0:
+        for i, (x, y) in enumerate(gkf.split(fnames, ys, groups)):
+            if self.is_train: # k번 빼고 학습
+                if i == self.k:
                     continue
-                    
-                filenames += list(_filenames[y])
-                labelnames += list(_labelnames[y])
+                filenames += list(fnames[y])
+                labelnames += list(labels[y])
             
-            else:
-                filenames = list(_filenames[y])
-                labelnames = list(_labelnames[y])
-                
-                # skip i > 0
-                break
+            else:  # k번은 검증
+                if i != self.k:
+                    continue
+                filenames = list(fnames[y])
+                labelnames = list(labels[y])
         
         self.filenames = filenames
         self.labelnames = labelnames
-        self.is_train = is_train
-        self.transforms = transforms
-        self.classes = classes
-        self.image_root = image_root
-        self.label_root = label_root
     
     def __len__(self):
         return len(self.filenames)
@@ -78,7 +66,7 @@ def __getitem__(self, item):
         label_path = os.path.join(self.label_root, label_name)
         
         # (H, W, NC) 모양의 label을 생성합니다.
-        label_shape = tuple(image.shape[:2]) + (len(self.classes), )
+        label_shape = tuple(image.shape[:2]) + (len(CLASSES), )
         label = np.zeros(label_shape, dtype=np.uint8)
         
         # label 파일을 읽습니다.
@@ -89,7 +77,7 @@ def __getitem__(self, item):
         # 클래스 별로 처리합니다.
         for ann in annotations:
             c = ann["label"]
-            class_ind = CLASS2IND[c]
+            class_ind = self.class2ind[c]
             points = np.array(ann["points"])
             
             # polygon 포맷을 dense한 mask 포맷으로 바꿉니다.
@@ -114,17 +102,14 @@ def __getitem__(self, item):
         return image, label
 
 class XRayInferenceDataset(Dataset):
-    def __init__(self, pngs, image_root, transforms=None):
-        self.pngs = pngs
+    def __init__(self, fnames, image_root, transforms=None):
+        self.fnames = np.array(sorted(fnames))
         self.image_root = image_root
-        _filenames = self.pngs
-        _filenames = np.array(sorted(_filenames))
-
-        self.filenames = _filenames
         self.transforms = transforms
+        self.ind2class = {i: v for i, v in enumerate(CLASSES)}
 
     def __len__(self):
-        return len(self.filenames)
+        return len(self.fnames)
 
     def __getitem__(self, item):
         image_name = self.filenames[item]
diff --git a/module_base/inference.py b/module_base/inference.py
index e18c12e..ee5801e 100644
--- a/module_base/inference.py
+++ b/module_base/inference.py
@@ -33,9 +33,6 @@ def parse_args():
     'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
 ]
 
-CLASS2IND = {v: i for i, v in enumerate(CLASSES)}
-IND2CLASS = {v: k for k, v in CLASS2IND.items()}
-
 def set_seed(random_seed):
     torch.manual_seed(random_seed)
     torch.cuda.manual_seed(random_seed)
@@ -70,16 +67,14 @@ def decode_rle_to_mask(rle, height, width):
     
     return img.reshape(height, width)
 
-def test(model, data_loader, model_type, thr=0.5):
+def test(model, test_loader, model_type, thr=0.5):
     model = model.cuda()
     model.eval()
 
     rles = []
     filename_and_class = []
     with torch.no_grad():
-        # n_class = len(CLASSES)
-
-        for step, (images, image_names) in tqdm(enumerate(data_loader), total=len(data_loader)):
+        for step, (images, image_names) in tqdm(enumerate(test_loader), total=len(test_loader)):
             images = images.cuda()  
             if model_type == 'torchvision':
                 outputs = model(images)['out']
@@ -94,13 +89,13 @@ def test(model, data_loader, model_type, thr=0.5):
                 for c, segm in enumerate(output):
                     rle = encode_mask_to_rle(segm)
                     rles.append(rle)
-                    filename_and_class.append(f"{IND2CLASS[c]}_{image_name}")
+                    filename_and_class.append(f"{test_loader.dataset.ind2class[c]}_{image_name}")
                     
     return rles, filename_and_class
 
 def do_inference(image_root, save_dir, random_seed, model_type):
     set_seed(random_seed)
-    pngs = {
+    fnames = {
         os.path.relpath(os.path.join(root, fname), start=image_root)
         for root, _dirs, files in os.walk(image_root)
         for fname in files
@@ -110,7 +105,7 @@ def do_inference(image_root, save_dir, random_seed, model_type):
     
     test_trans = TransformSelector('albumentation')
     test_tf = test_trans.get_transform(False, 512)
-    test_dataset = XRayInferenceDataset(pngs, image_root,transforms=test_tf)
+    test_dataset = XRayInferenceDataset(fnames, image_root,transforms=test_tf)
     
     test_loader = DataLoader(
         dataset=test_dataset, 
diff --git a/module_base/model.py b/module_base/model.py
index d96be5f..7dae6ee 100644
--- a/module_base/model.py
+++ b/module_base/model.py
@@ -2,18 +2,10 @@
 from torchvision import models
 import segmentation_models_pytorch as smp
 
-'''
-model_selector = ModelSelector(
-        model_type=model_type, 
-        num_classes=num_classes,
-        model_name=model_name,
-        encoder_weights=encoder_weights,
-        pretrained=True
-    )
-model = model_selector.get_model()
-'''
-
 class TorchvisionModel(nn.Module):
+    '''
+    Torchvision에서 제공하는 사전 훈련된 모델을 사용하는 클래스
+    '''
     def __init__(self, model_name, num_classes, pretrained=True):
         super(TorchvisionModel, self).__init__()
         self.model = models.segmentation.__dict__[model_name](pretrained=pretrained)
@@ -23,9 +15,9 @@ def forward(self, x):
         return self.model(x)
 
 class SMP(nn.Module):
-    """
+    '''
     SMP에서 제공하는 사전 훈련된 모델을 사용하는 클래스
-    """
+    '''
     def __init__(self, model_name, encoder_weights, num_classes):
         super(SMP, self).__init__()
         self.model = smp.Unet(
@@ -39,9 +31,9 @@ def forward(self, x):
         return self.model(x)
 
 class ModelSelector:
-    """
+    '''
     사용할 모델 유형을 선택하는 클래스
-    """
+    '''
     def __init__(self, model_type, num_classes, **kwargs):
         
         # 모델 유형에 따라 적절한 모델 객체를 생성
diff --git a/module_base/train.py b/module_base/train.py
index a8e7056..6543cfa 100644
--- a/module_base/train.py
+++ b/module_base/train.py
@@ -2,20 +2,26 @@
 import os
 import random
 import datetime
+
 import numpy as np
 from tqdm.auto import tqdm
 import albumentations as A
+
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
 import torch.optim as optim
 from torch.utils.data import DataLoader
-from torchvision import models
+
 from dataset import XRayDataset
 from model import ModelSelector
 from transform import TransformSelector
-from argparse import ArgumentParser
 
+import warnings
+warnings.filterwarnings('ignore')
+
+'''
+from argparse import ArgumentParser
 def parse_args():
     parser = ArgumentParser()
 
@@ -38,22 +44,7 @@ def parse_args():
     args = parser.parse_args()
     
     return args
-
-CLASSES = [
-    'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
-    'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
-    'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
-    'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
-    'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
-    'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
-]
-
-def dice_coef(y_true, y_pred):
-    y_true_f = y_true.flatten(2)
-    y_pred_f = y_pred.flatten(2)
-    intersection = torch.sum(y_true_f * y_pred_f, -1)
-    eps = 0.0001
-    return (2. * intersection + eps) / (torch.sum(y_true_f, -1) + torch.sum(y_pred_f, -1) + eps)
+'''
 
 def set_seed(random_seed):
     torch.manual_seed(random_seed)
@@ -64,21 +55,43 @@ def set_seed(random_seed):
     np.random.seed(random_seed)
     random.seed(random_seed)
 
+def dice_coef(y_true, y_pred):
+    y_true_f = y_true.flatten(2)
+    y_pred_f = y_pred.flatten(2)
+    intersection = torch.sum(y_true_f * y_pred_f, -1)
+    eps = 0.0001
+    return (2. * intersection + eps) / (torch.sum(y_true_f, -1) + torch.sum(y_pred_f, -1) + eps)
+
+def set_data(cfg):
+    pngs = {
+        os.path.relpath(os.path.join(root, fname), start=cfg.image_root)
+        for root, _dirs, files in os.walk(cfg.image_root)
+        for fname in files
+        if os.path.splitext(fname)[1].lower() == ".png"
+    }
+
+    jsons = {
+        os.path.relpath(os.path.join(root, fname), start=cfg.label_root)
+        for root, _dirs, files in os.walk(cfg.label_root)
+        for fname in files
+        if os.path.splitext(fname)[1].lower() == ".json"
+    }
+    return np.array(sorted(pngs)), np.array(sorted(jsons))
+
 def save_model(model, save_dir, file_name='best_model.pt'):
     output_path = os.path.join(save_dir, file_name)
     torch.save(model, output_path)
 
-def validation(epoch, model, data_loader, criterion, model_type, thr=0.5):
+def validation(epoch, model, val_loader, criterion, model_type, thr=0.5):
     print(f'Start validation #{epoch:2d}')
     model.eval()
 
     dices = []
     with torch.no_grad():
-        # n_class = len(CLASSES)
         total_loss = 0
         cnt = 0
 
-        for step, (images, masks) in tqdm(enumerate(data_loader), total=len(data_loader)):
+        for step, (images, masks) in tqdm(enumerate(val_loader), total=len(val_loader)):
             images, masks = images.cuda(), masks.cuda()         
             model = model.cuda()
             
@@ -109,7 +122,7 @@ def validation(epoch, model, data_loader, criterion, model_type, thr=0.5):
     dices_per_class = torch.mean(dices, 0)
     dice_str = [
         f"{c:<12}: {d.item():.4f}"
-        for c, d in zip(CLASSES, dices_per_class)
+        for c, d in zip(val_loader.dataset.num_classes, dices_per_class)
     ]
     dice_str = "\n".join(dice_str) 
     print(dice_str)
@@ -118,34 +131,18 @@ def validation(epoch, model, data_loader, criterion, model_type, thr=0.5):
     
     return avg_dice
 
-def train(model, train_loader, valid_loader, criterion, optimizer, save_dir, random_seed, max_epoch, val_every, model_type):
+def train(model, train_loader, val_loader, criterion, optimizer, save_dir, random_seed, max_epoch, val_every, model_type):
     print(f'Start training..')
-    
-    # n_class = len(CLASSES)
     best_dice = 0.
-
-    # GradScaler를 사용해 Mixed Precision Training을 설정
     scaler = torch.cuda.amp.GradScaler()
     
     for epoch in range(max_epoch):
         model.train()
-
-        for step, (images, masks) in enumerate(train_loader):            
+        for step, (images, masks) in enumerate(train_loader):
             # gpu 연산을 위해 device 할당합니다.
             images, masks = images.cuda(), masks.cuda()
             model = model.cuda()
             
-            # if model_type == 'torchvision':
-            #     outputs = model(images)['out']
-            # elif model_type == 'smp':
-            #     outputs = model(images)
-            
-            # loss를 계산합니다.
-            # loss = criterion(outputs, masks)
-            # optimizer.zero_grad()
-            # loss.backward()
-            # optimizer.step()
-
             # Mixed Precision Training 적용
             with torch.cuda.amp.autocast():
                 if model_type == 'torchvision':
@@ -153,7 +150,6 @@ def train(model, train_loader, valid_loader, criterion, optimizer, save_dir, ran
                 elif model_type == 'smp':
                     outputs = model(images)
                 loss = criterion(outputs, masks)
-            
             # 스케일된 loss를 사용해 backward 및 optimizer step
             optimizer.zero_grad()
             scaler.scale(loss).backward()
@@ -168,12 +164,11 @@ def train(model, train_loader, valid_loader, criterion, optimizer, save_dir, ran
                     f'Step [{step+1}/{len(train_loader)}], '
                     f'Loss: {round(loss.item(),4)}'
                 )
-                
         # validation 주기에 따라 loss를 출력하고 best model을 저장합니다.
         if (epoch + 1) % val_every == 0:
             # 캐시된 메모리를 해제하여 PyTorch의 메모리 누수를 방지
             torch.cuda.empty_cache()
-            dice = validation(epoch + 1, model, valid_loader, criterion, model_type)
+            dice = validation(epoch + 1, model, val_loader, criterion, model_type)
             
             if best_dice < dice:
                 print(f"Best performance at epoch: {epoch + 1}, {best_dice:.4f} -> {dice:.4f}")
@@ -182,24 +177,10 @@ def train(model, train_loader, valid_loader, criterion, optimizer, save_dir, ran
                 save_model(model, save_dir)
 
 def do_training(image_root, label_root, save_dir, batch_size, learning_rate, max_epoch, val_every, random_seed,
-                model_type, model_name, pretrained):
-    pngs = {
-        os.path.relpath(os.path.join(root, fname), start=image_root)
-        for root, _dirs, files in os.walk(image_root)
-        for fname in files
-        if os.path.splitext(fname)[1].lower() == ".png"
-    }
-
-    jsons = {
-        os.path.relpath(os.path.join(root, fname), start=label_root)
-        for root, _dirs, files in os.walk(label_root)
-        for fname in files
-        if os.path.splitext(fname)[1].lower() == ".json"
-    }
-    
-    pngs = sorted(pngs)
-    jsons = sorted(jsons)
+                model_type, model_name, pretrained, cfg):
     
+    fnames, labels = set_data(cfg)
+
     if not os.path.exists(save_dir):
         os.makedirs(save_dir)
     
@@ -208,8 +189,8 @@ def do_training(image_root, label_root, save_dir, batch_size, learning_rate, max
     val_trans = TransformSelector('albumentation')
     val_tf = val_trans.get_transform(False, 512)
 
-    train_dataset = XRayDataset(pngs, jsons, CLASSES, image_root, label_root, is_train=True, transforms=train_tf)
-    valid_dataset = XRayDataset(pngs, jsons, CLASSES, image_root, label_root, is_train=False, transforms=val_tf)
+    train_dataset = XRayDataset(fnames, labels, image_root, label_root, is_train=True, transforms=train_tf)
+    valid_dataset = XRayDataset(fnames, labels, image_root, label_root, is_train=False, transforms=val_tf)
     
     train_loader = DataLoader(
         dataset=train_dataset, 
@@ -229,7 +210,7 @@ def do_training(image_root, label_root, save_dir, batch_size, learning_rate, max
     
     model_selector = ModelSelector(
         model_type=model_type,
-        num_classes=len(CLASSES),
+        num_classes=len(valid_loader.dataset.num_classes),
         model_name=model_name,
         # encoder_weights=encoder_weights,
         pretrained=pretrained
@@ -251,5 +232,6 @@ def main(args):
     do_training(**args.__dict__)
 
 if __name__ == '__main__':
-    args = parse_args()
-    main(args)
\ No newline at end of file
+    pass
+    # args = parse_args()
+    # main(args)
\ No newline at end of file

From 7f45b8bef0e57a5fea7202f0b46c7666b7fed23d Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Tue, 19 Nov 2024 01:51:20 +0900
Subject: [PATCH 029/106] [#21] Feature : use config.yaml

---
 module_base/config.yaml | 47 +++++++++++++++--------------
 module_base/dataset.py  |  2 +-
 module_base/train.py    | 65 +++++++++++++++++++++++------------------
 3 files changed, 60 insertions(+), 54 deletions(-)

diff --git a/module_base/config.yaml b/module_base/config.yaml
index b27855f..6f0d2d1 100644
--- a/module_base/config.yaml
+++ b/module_base/config.yaml
@@ -3,30 +3,29 @@ IMAGE_ROOT: "/data/ephemeral/home/data/train/DCM"
 LABEL_ROOT: "/data/ephemeral/home/data/train/outputs_json"
 SAVED_DIR: "/data/ephemeral/home/data/result"
 
-CLASSES = [
-    'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
-    'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
-    'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
-    'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
-    'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
-    'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
-]
+# 모델 라이브러리 및 사용 모델 정의
+model_type: 'torchvision'
+model_name: 'fcn_resnet101'
 
-CLASS2IND = {v: i for i, v in enumerate(CLASSES)}
-IND2CLASS = {v: k for k, v in CLASS2IND.items()}
+# batch_size
+train_batch_size: 2
+valid_batch_size: 4
 
-CLASSES = [
-    'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
-    'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
-    'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
-    'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
-    'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
-    'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
-]
+# hyperparameter
+lr: 2e-4
+weight_decay: 1e-6
+train_num_workers: 8
+valid_num_workers: 0
+max_epoch: 30
 
-TRAIN_BATCH_SIZE = 2
-VALID_BATCH_SIZE = 4
-LR = 2e-4
-RANDOM_SEED = 2024
-NUM_EPOCHS = 50
-VAL_EVERY = 2
\ No newline at end of file
+# loss
+loss: BCEWithLogitsLoss
+
+# validation 인자
+k: 0
+val_every: 2
+threshold: 0.5
+pretrained: True
+
+# random seed 
+random_seed: 2024
\ No newline at end of file
diff --git a/module_base/dataset.py b/module_base/dataset.py
index c47725b..70669cb 100644
--- a/module_base/dataset.py
+++ b/module_base/dataset.py
@@ -17,7 +17,7 @@
 ]
 
 class XRayDataset(Dataset):
-    def __init__(self, fnames, labels, image_root, label_root, k=0, is_train=True, transforms=None):
+    def __init__(self, fnames, labels, image_root, label_root, k=0, transforms=None, is_train=True):
         self.is_train = is_train
         self.transforms = transforms
         self.image_root = image_root
diff --git a/module_base/train.py b/module_base/train.py
index 6543cfa..892258f 100644
--- a/module_base/train.py
+++ b/module_base/train.py
@@ -20,6 +20,9 @@
 import warnings
 warnings.filterwarnings('ignore')
 
+from omegaconf import OmegaConf
+from argparse import ArgumentParser
+
 '''
 from argparse import ArgumentParser
 def parse_args():
@@ -32,9 +35,9 @@ def parse_args():
                         help='Path to the root directory containing labels')
     parser.add_argument('--save_dir', type=str, default="/data/ephemeral/home/data/result",
                         help='Path to the root directory containing save direction')
-    parser.add_argument('--batch_size', type=int, default=1)
+    parser.add_argument('--batch_size', type=int, default=2)
     parser.add_argument('--learning_rate', type=float, default=1e-4)
-    parser.add_argument('--max_epoch', type=int, default=1)
+    parser.add_argument('--max_epoch', type=int, default=30)
     parser.add_argument('--val_every', type=int, default=5)
     parser.add_argument('--random_seed', type=int, default=2024)
     parser.add_argument('--model_type', type=str, default='torchvision')
@@ -134,16 +137,18 @@ def validation(epoch, model, val_loader, criterion, model_type, thr=0.5):
 def train(model, train_loader, val_loader, criterion, optimizer, save_dir, random_seed, max_epoch, val_every, model_type):
     print(f'Start training..')
     best_dice = 0.
+
     scaler = torch.cuda.amp.GradScaler()
+    model = model.cuda()
     
     for epoch in range(max_epoch):
         model.train()
+        torch.cuda.empty_cache() # 학습 시작 전 캐시 삭제
         for step, (images, masks) in enumerate(train_loader):
             # gpu 연산을 위해 device 할당합니다.
             images, masks = images.cuda(), masks.cuda()
-            model = model.cuda()
             
-            # Mixed Precision Training 적용
+            # Mixed Precision Training으로 loss 계산에서만 FP32 사용
             with torch.cuda.amp.autocast():
                 if model_type == 'torchvision':
                     outputs = model(images)['out']
@@ -176,44 +181,45 @@ def train(model, train_loader, val_loader, criterion, optimizer, save_dir, rando
                 best_dice = dice
                 save_model(model, save_dir)
 
-def do_training(image_root, label_root, save_dir, batch_size, learning_rate, max_epoch, val_every, random_seed,
-                model_type, model_name, pretrained, cfg):
-    
+def do_training(cfg):
+    set_seed(cfg.random_seed)
     fnames, labels = set_data(cfg)
 
-    if not os.path.exists(save_dir):
-        os.makedirs(save_dir)
+    if not os.path.exists(cfg.save_dir):
+        os.makedirs(cfg.save_dir)
     
     train_trans = TransformSelector('albumentation')
     train_tf = train_trans.get_transform(True, 512)
     val_trans = TransformSelector('albumentation')
     val_tf = val_trans.get_transform(False, 512)
 
-    train_dataset = XRayDataset(fnames, labels, image_root, label_root, is_train=True, transforms=train_tf)
-    valid_dataset = XRayDataset(fnames, labels, image_root, label_root, is_train=False, transforms=val_tf)
+    train_dataset = XRayDataset(fnames, labels, cfg.image_root, cfg.label_root, 
+                                fold=cfg.val_fold, transforms=train_tf, is_train=True)
+    valid_dataset = XRayDataset(fnames, labels, cfg.image_root, cfg.label_root, 
+                                fold=cfg.val_fold, transforms=val_tf, is_train=False)
     
     train_loader = DataLoader(
         dataset=train_dataset, 
-        batch_size=batch_size,
+        batch_size=cfg.train_batch_size,
         shuffle=True,
-        num_workers=8,
+        num_workers=cfg.train_num_workers,
         drop_last=True,
     )
     
     valid_loader = DataLoader(
         dataset=valid_dataset, 
-        batch_size=8,
+        batch_size=cfg.valid_batch_size,
         shuffle=False,
-        num_workers=0,
+        num_workers=cfg.valid_num_workers,
         drop_last=False
     )
     
     model_selector = ModelSelector(
-        model_type=model_type,
+        model_type=cfg.model_type,
         num_classes=len(valid_loader.dataset.num_classes),
-        model_name=model_name,
+        model_name=cfg.model_name,
         # encoder_weights=encoder_weights,
-        pretrained=pretrained
+        pretrained=cfg.pretrained
     )
     model = model_selector.get_model()
     
@@ -221,17 +227,18 @@ def do_training(image_root, label_root, save_dir, batch_size, learning_rate, max
     criterion = nn.BCEWithLogitsLoss()
 
     # Optimizer를 정의합니다.
-    optimizer = optim.Adam(params=model.parameters(), lr=learning_rate, weight_decay=1e-6)
-
-    # 시드를 설정합니다.
-    set_seed(random_seed)
+    optimizer = optim.Adam(params=model.parameters(), lr=cfg.lr, weight_decay=1e-6)
     
-    train(model, train_loader, valid_loader, criterion, optimizer, save_dir, random_seed, max_epoch, val_every, model_type)
-
-def main(args):
-    do_training(**args.__dict__)
+    train(model, train_loader, valid_loader, criterion, optimizer,
+        cfg.save_dir, cfg.random_seed, cfg.max_epoch, cfg.val_every, cfg.model_type)
 
 if __name__ == '__main__':
-    pass
-    # args = parse_args()
-    # main(args)
\ No newline at end of file
+    parser = ArgumentParser()
+    parser.add_argument('--config', type=str, default='config.yaml')
+
+    args = parser.parse_args()
+
+    with open(args.config, 'r') as f:
+        cfg = OmegaConf.load(f)
+    
+    do_training(cfg)
\ No newline at end of file

From 909533567eb181151d12fbb312cc493ddfca92cd Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Tue, 19 Nov 2024 11:50:01 +0900
Subject: [PATCH 030/106] [#21] Refactor : debugging

---
 baseline_code.ipynb     | 730 +++++-----------------------------------
 module_base/config.yaml |  21 +-
 module_base/dataset.py  |  10 +-
 module_base/model.py    |   6 +-
 module_base/train.py    |  59 +---
 5 files changed, 113 insertions(+), 713 deletions(-)

diff --git a/baseline_code.ipynb b/baseline_code.ipynb
index 5a94b29..9726ab2 100644
--- a/baseline_code.ipynb
+++ b/baseline_code.ipynb
@@ -73,21 +73,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "c8295cb6",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/opt/conda/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
-      "  from .autonotebook import tqdm as notebook_tqdm\n",
-      "/opt/conda/lib/python3.10/site-packages/albumentations/__init__.py:13: UserWarning: A new version of Albumentations is available: 1.4.21 (you have 1.4.18). Upgrade using: pip install -U albumentations. To disable automatic update checks, set the environment variable NO_ALBUMENTATIONS_UPDATE to 1.\n",
-      "  check_for_updates()\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# python native\n",
     "import os\n",
@@ -103,6 +92,8 @@
     "from tqdm.auto import tqdm\n",
     "from sklearn.model_selection import GroupKFold\n",
     "import albumentations as A\n",
+    "import time\n",
+    "from datetime import timedelta\n",
     "\n",
     "# torch\n",
     "import torch\n",
@@ -118,7 +109,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "1d6746cc",
    "metadata": {},
    "outputs": [],
@@ -131,7 +122,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "819e163c",
    "metadata": {},
    "outputs": [],
@@ -148,7 +139,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "id": "3192cd81",
    "metadata": {},
    "outputs": [],
@@ -158,7 +149,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "id": "1aef86f9",
    "metadata": {},
    "outputs": [],
@@ -168,17 +159,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "id": "cb199e3d",
    "metadata": {},
    "outputs": [],
    "source": [
-    "BATCH_SIZE = 2\n",
-    "LR = 3e-4\n",
+    "TRAIN_BATCH_SIZE = 2\n",
+    "VALID_BATCH_SIZE = 4\n",
+    "LR = 2e-4\n",
     "RANDOM_SEED = 2024\n",
     "\n",
-    "NUM_EPOCHS = 60\n",
-    "VAL_EVERY = 3\n",
+    "NUM_EPOCHS = 50\n",
+    "VAL_EVERY = 2\n",
     "\n",
     "SAVED_DIR = \"/data/ephemeral/home/data/result\"\n",
     "\n",
@@ -204,7 +196,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "id": "a0782493",
    "metadata": {},
    "outputs": [],
@@ -219,21 +211,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "id": "91a88b61",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "800"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "len(pngs)"
    ]
@@ -248,7 +229,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "id": "be21a515",
    "metadata": {},
    "outputs": [],
@@ -263,21 +244,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "id": "eb99fd10",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "800"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "len(jsons)"
    ]
@@ -292,7 +262,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "id": "51eba0f1",
    "metadata": {},
    "outputs": [],
@@ -314,7 +284,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "id": "f589a513",
    "metadata": {},
    "outputs": [],
@@ -333,7 +303,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "id": "7b0d5bf7",
    "metadata": {},
    "outputs": [],
@@ -439,7 +409,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "id": "89defc8c",
    "metadata": {},
    "outputs": [],
@@ -467,28 +437,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "id": "e1f1eb8a",
    "metadata": {},
    "outputs": [],
    "source": [
-    "tf = A.Resize(512, 512)"
+    "train_tf = A.Compose([\n",
+    "    A.Resize(1536, 1536),\n",
+    "    A.HorizontalFlip(p=0.3),\n",
+    "])\n",
+    "val_tf = A.Resize(1536, 1536)\n",
+    "# tf = A.Resize(1536, 1536)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "id": "f17abc75",
    "metadata": {},
    "outputs": [],
    "source": [
-    "train_dataset = XRayDataset(is_train=True, transforms=tf)\n",
-    "valid_dataset = XRayDataset(is_train=False, transforms=tf)"
+    "train_dataset = XRayDataset(is_train=True, transforms=train_tf)\n",
+    "valid_dataset = XRayDataset(is_train=False, transforms=val_tf)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "id": "c193e92b",
    "metadata": {},
    "outputs": [],
@@ -498,60 +473,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "id": "5dd474b2",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "torch.Size([3, 512, 512]) torch.Size([29, 512, 512])\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(image.shape, label.shape)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "id": "bc100cf6",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "640"
-      ]
-     },
-     "execution_count": 19,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "len(train_dataset)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "id": "f9845fe3",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 2400x1200 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "fig, ax = plt.subplots(1, 2, figsize=(24, 12))\n",
     "ax[0].imshow(image[0])    # color map 적용을 위해 channel 차원을 생략합니다.\n",
@@ -570,25 +515,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "id": "d5b43501",
    "metadata": {},
    "outputs": [],
    "source": [
     "train_loader = DataLoader(\n",
     "    dataset=train_dataset, \n",
-    "    batch_size=BATCH_SIZE,\n",
+    "    batch_size=TRAIN_BATCH_SIZE,\n",
     "    shuffle=True,\n",
-    "    num_workers=8,\n",
+    "    num_workers=4,\n",
     "    drop_last=True,\n",
     ")\n",
     "\n",
     "# 주의: validation data는 이미지 크기가 크기 때문에 `num_wokers`는 커지면 메모리 에러가 발생할 수 있습니다.\n",
     "valid_loader = DataLoader(\n",
     "    dataset=valid_dataset, \n",
-    "    batch_size=4,\n",
+    "    batch_size=VALID_BATCH_SIZE,\n",
     "    shuffle=False,\n",
-    "    num_workers=0,\n",
+    "    num_workers=1,\n",
     "    drop_last=False\n",
     ")"
    ]
@@ -603,7 +548,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": null,
    "id": "687f29a3",
    "metadata": {},
    "outputs": [],
@@ -619,7 +564,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": null,
    "id": "19be0316",
    "metadata": {},
    "outputs": [],
@@ -631,7 +576,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": null,
    "id": "dd22e901",
    "metadata": {},
    "outputs": [],
@@ -648,7 +593,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": null,
    "id": "40c3a306",
    "metadata": {},
    "outputs": [],
@@ -657,15 +602,15 @@
     "    print(f'Start validation #{epoch:2d}')\n",
     "    set_seed()\n",
     "    model.eval()\n",
+    "    \n",
     "    dices = []\n",
+    "    model = model.cuda()\n",
     "    with torch.no_grad():\n",
-    "        n_class = len(CLASSES)\n",
     "        total_loss = 0\n",
     "        cnt = 0\n",
     "\n",
     "        for step, (images, masks) in tqdm(enumerate(data_loader), total=len(data_loader)):\n",
     "            images, masks = images.cuda(), masks.cuda()         \n",
-    "            model = model.cuda()\n",
     "            \n",
     "            # outputs = model(images)['out']\n",
     "            outputs = model(images)\n",
@@ -687,7 +632,10 @@
     "            \n",
     "            dice = dice_coef(outputs, masks)\n",
     "            dices.append(dice)\n",
-    "                \n",
+    "\n",
+    "            # 텐서 삭제 및 메모리 캐시 해제\n",
+    "            del outputs, masks, dice\n",
+    "            \n",
     "    dices = torch.cat(dices, 0)\n",
     "    dices_per_class = torch.mean(dices, 0)\n",
     "    dice_str = [\n",
@@ -704,7 +652,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": null,
    "id": "3acde59b",
    "metadata": {},
    "outputs": [],
@@ -712,19 +660,20 @@
     "def train(model, data_loader, val_loader, criterion, optimizer):\n",
     "    print(f'Start training..')\n",
     "    set_seed()\n",
-    "    n_class = len(CLASSES)\n",
     "    best_dice = 0.\n",
     "\n",
     "    # GradScaler를 사용해 Mixed Precision Training을 설정\n",
-    "    scaler = torch.cuda.amp.GradScaler()\n",
-    "\n",
+    "    scaler = torch.cuda.amp.GradScaler(enabled=True)\n",
+    "    model = model.cuda()\n",
     "    for epoch in range(NUM_EPOCHS):\n",
+    "        # 매 epoch마다 cache를 삭제하여 PyTorch의 메모리 누수를 방지\n",
+    "        torch.cuda.empty_cache()\n",
     "        model.train()\n",
-    "\n",
+    "        \n",
     "        for step, (images, masks) in enumerate(data_loader):            \n",
     "            # gpu 연산을 위해 device 할당합니다.\n",
     "            images, masks = images.cuda(), masks.cuda()\n",
-    "            model = model.cuda()\n",
+    "            # model = model.cuda()\n",
     "            \n",
     "            # outputs = model(images)['out']\n",
     "            # outputs = model(images)\n",
@@ -735,14 +684,15 @@
     "            # loss.backward()\n",
     "            # optimizer.step()\n",
     "\n",
+    "            # 스케일된 loss를 사용해 backward 및 optimizer step\n",
+    "            optimizer.zero_grad()\n",
+    "            \n",
     "            # Mixed Precision Training 적용\n",
     "            with torch.cuda.amp.autocast():\n",
     "                # outputs = model(images)['out']\n",
     "                outputs = model(images)\n",
     "                loss = criterion(outputs, masks)\n",
     "            \n",
-    "            # 스케일된 loss를 사용해 backward 및 optimizer step\n",
-    "            optimizer.zero_grad()\n",
     "            scaler.scale(loss).backward()\n",
     "            scaler.step(optimizer)\n",
     "            scaler.update()\n",
@@ -758,8 +708,6 @@
     "                \n",
     "        # validation 주기에 따라 loss를 출력하고 best model을 저장합니다.\n",
     "        if (epoch + 1) % VAL_EVERY == 0:\n",
-    "            # 캐시된 메모리를 해제하여 PyTorch의 메모리 누수를 방지\n",
-    "            torch.cuda.empty_cache()\n",
     "            dice = validation(epoch + 1, model, val_loader, criterion)\n",
     "            \n",
     "            if best_dice < dice:\n",
@@ -792,23 +740,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": null,
    "id": "497da034",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Unexpected keys (downsamp_modules.0.0.bias, downsamp_modules.0.0.weight, downsamp_modules.0.1.bias, downsamp_modules.0.1.num_batches_tracked, downsamp_modules.0.1.running_mean, downsamp_modules.0.1.running_var, downsamp_modules.0.1.weight, downsamp_modules.1.0.bias, downsamp_modules.1.0.weight, downsamp_modules.1.1.bias, downsamp_modules.1.1.num_batches_tracked, downsamp_modules.1.1.running_mean, downsamp_modules.1.1.running_var, downsamp_modules.1.1.weight, downsamp_modules.2.0.bias, downsamp_modules.2.0.weight, downsamp_modules.2.1.bias, downsamp_modules.2.1.num_batches_tracked, downsamp_modules.2.1.running_mean, downsamp_modules.2.1.running_var, downsamp_modules.2.1.weight, final_layer.0.bias, final_layer.0.weight, final_layer.1.bias, final_layer.1.num_batches_tracked, final_layer.1.running_mean, final_layer.1.running_var, final_layer.1.weight, classifier.bias, classifier.weight) found while loading pretrained weights. This may be expected if model is being adapted.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import segmentation_models_pytorch as smp\n",
     "\n",
-    "model = smp.UPerNet(\n",
-    "    encoder_name=\"tu-hrnet_w48\",\n",
+    "model = smp.UnetPlusPlus(\n",
+    "    encoder_name=\"tu-hrnet_w64\",\n",
     "    encoder_weights=\"imagenet\",\n",
     "    in_channels=3,\n",
     "    classes=29\n",
@@ -817,7 +757,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": null,
    "id": "801e9a3a",
    "metadata": {},
    "outputs": [],
@@ -831,7 +771,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": null,
    "id": "a11d1b92",
    "metadata": {},
    "outputs": [],
@@ -845,519 +785,7 @@
    "execution_count": null,
    "id": "7564c751",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Start training..\n",
-      "2024-11-15 01:31:48 | Epoch [1/60], Step [25/320], Loss: 0.554\n",
-      "2024-11-15 01:31:56 | Epoch [1/60], Step [50/320], Loss: 0.486\n",
-      "2024-11-15 01:32:04 | Epoch [1/60], Step [75/320], Loss: 0.427\n",
-      "2024-11-15 01:32:12 | Epoch [1/60], Step [100/320], Loss: 0.3694\n",
-      "2024-11-15 01:32:20 | Epoch [1/60], Step [125/320], Loss: 0.3164\n",
-      "2024-11-15 01:32:28 | Epoch [1/60], Step [150/320], Loss: 0.2669\n",
-      "2024-11-15 01:32:36 | Epoch [1/60], Step [175/320], Loss: 0.2212\n",
-      "2024-11-15 01:32:44 | Epoch [1/60], Step [200/320], Loss: 0.1857\n",
-      "2024-11-15 01:32:52 | Epoch [1/60], Step [225/320], Loss: 0.1555\n",
-      "2024-11-15 01:33:00 | Epoch [1/60], Step [250/320], Loss: 0.1337\n",
-      "2024-11-15 01:33:08 | Epoch [1/60], Step [275/320], Loss: 0.1136\n",
-      "2024-11-15 01:33:16 | Epoch [1/60], Step [300/320], Loss: 0.0968\n",
-      "2024-11-15 01:33:34 | Epoch [2/60], Step [25/320], Loss: 0.0754\n",
-      "2024-11-15 01:33:42 | Epoch [2/60], Step [50/320], Loss: 0.0652\n",
-      "2024-11-15 01:33:50 | Epoch [2/60], Step [75/320], Loss: 0.0576\n",
-      "2024-11-15 01:33:58 | Epoch [2/60], Step [100/320], Loss: 0.0517\n",
-      "2024-11-15 01:34:06 | Epoch [2/60], Step [125/320], Loss: 0.0458\n",
-      "2024-11-15 01:34:14 | Epoch [2/60], Step [150/320], Loss: 0.0415\n",
-      "2024-11-15 01:34:22 | Epoch [2/60], Step [175/320], Loss: 0.0371\n",
-      "2024-11-15 01:34:30 | Epoch [2/60], Step [200/320], Loss: 0.0331\n",
-      "2024-11-15 01:34:38 | Epoch [2/60], Step [225/320], Loss: 0.0311\n",
-      "2024-11-15 01:34:46 | Epoch [2/60], Step [250/320], Loss: 0.0293\n",
-      "2024-11-15 01:34:54 | Epoch [2/60], Step [275/320], Loss: 0.0251\n",
-      "2024-11-15 01:35:02 | Epoch [2/60], Step [300/320], Loss: 0.0241\n",
-      "2024-11-15 01:35:19 | Epoch [3/60], Step [25/320], Loss: 0.0202\n",
-      "2024-11-15 01:35:27 | Epoch [3/60], Step [50/320], Loss: 0.0192\n",
-      "2024-11-15 01:35:35 | Epoch [3/60], Step [75/320], Loss: 0.0177\n",
-      "2024-11-15 01:35:43 | Epoch [3/60], Step [100/320], Loss: 0.0167\n",
-      "2024-11-15 01:35:51 | Epoch [3/60], Step [125/320], Loss: 0.0156\n",
-      "2024-11-15 01:35:59 | Epoch [3/60], Step [150/320], Loss: 0.0145\n",
-      "2024-11-15 01:36:08 | Epoch [3/60], Step [175/320], Loss: 0.0138\n",
-      "2024-11-15 01:36:16 | Epoch [3/60], Step [200/320], Loss: 0.0132\n",
-      "2024-11-15 01:36:24 | Epoch [3/60], Step [225/320], Loss: 0.0117\n",
-      "2024-11-15 01:36:32 | Epoch [3/60], Step [250/320], Loss: 0.0114\n",
-      "2024-11-15 01:36:40 | Epoch [3/60], Step [275/320], Loss: 0.0108\n",
-      "2024-11-15 01:36:49 | Epoch [3/60], Step [300/320], Loss: 0.0099\n",
-      "Start validation # 3\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 40/40 [05:37<00:00,  8.43s/it]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "finger-1    : 0.8588\n",
-      "finger-2    : 0.9149\n",
-      "finger-3    : 0.9549\n",
-      "finger-4    : 0.8309\n",
-      "finger-5    : 0.9058\n",
-      "finger-6    : 0.9383\n",
-      "finger-7    : 0.9564\n",
-      "finger-8    : 0.8517\n",
-      "finger-9    : 0.9133\n",
-      "finger-10   : 0.9360\n",
-      "finger-11   : 0.9526\n",
-      "finger-12   : 0.8273\n",
-      "finger-13   : 0.8683\n",
-      "finger-14   : 0.9192\n",
-      "finger-15   : 0.9329\n",
-      "finger-16   : 0.7633\n",
-      "finger-17   : 0.8339\n",
-      "finger-18   : 0.9216\n",
-      "finger-19   : 0.9447\n",
-      "Trapezium   : 0.8803\n",
-      "Trapezoid   : 0.8271\n",
-      "Capitate    : 0.8975\n",
-      "Hamate      : 0.8750\n",
-      "Scaphoid    : 0.8985\n",
-      "Lunate      : 0.8147\n",
-      "Triquetrum  : 0.8580\n",
-      "Pisiform    : 0.8028\n",
-      "Radius      : 0.9772\n",
-      "Ulna        : 0.9546\n",
-      "Best performance at epoch: 3, 0.0000 -> 0.8900\n",
-      "Save model in /data/ephemeral/home/data/result\n",
-      "2024-11-15 01:42:45 | Epoch [4/60], Step [25/320], Loss: 0.0092\n",
-      "2024-11-15 01:42:53 | Epoch [4/60], Step [50/320], Loss: 0.0091\n",
-      "2024-11-15 01:43:01 | Epoch [4/60], Step [75/320], Loss: 0.0085\n",
-      "2024-11-15 01:43:09 | Epoch [4/60], Step [100/320], Loss: 0.0084\n",
-      "2024-11-15 01:43:17 | Epoch [4/60], Step [125/320], Loss: 0.0077\n",
-      "2024-11-15 01:43:25 | Epoch [4/60], Step [150/320], Loss: 0.0071\n",
-      "2024-11-15 01:43:33 | Epoch [4/60], Step [175/320], Loss: 0.007\n",
-      "2024-11-15 01:43:41 | Epoch [4/60], Step [200/320], Loss: 0.0067\n",
-      "2024-11-15 01:43:50 | Epoch [4/60], Step [225/320], Loss: 0.0067\n",
-      "2024-11-15 01:43:58 | Epoch [4/60], Step [250/320], Loss: 0.0062\n",
-      "2024-11-15 01:44:06 | Epoch [4/60], Step [275/320], Loss: 0.0059\n",
-      "2024-11-15 01:44:14 | Epoch [4/60], Step [300/320], Loss: 0.0062\n",
-      "2024-11-15 01:44:32 | Epoch [5/60], Step [25/320], Loss: 0.0059\n",
-      "2024-11-15 01:44:40 | Epoch [5/60], Step [50/320], Loss: 0.0057\n",
-      "2024-11-15 01:44:49 | Epoch [5/60], Step [75/320], Loss: 0.0054\n",
-      "2024-11-15 01:44:58 | Epoch [5/60], Step [100/320], Loss: 0.005\n",
-      "2024-11-15 01:45:06 | Epoch [5/60], Step [125/320], Loss: 0.0048\n",
-      "2024-11-15 01:45:14 | Epoch [5/60], Step [150/320], Loss: 0.0045\n",
-      "2024-11-15 01:45:21 | Epoch [5/60], Step [175/320], Loss: 0.0049\n",
-      "2024-11-15 01:45:29 | Epoch [5/60], Step [200/320], Loss: 0.0048\n",
-      "2024-11-15 01:45:38 | Epoch [5/60], Step [225/320], Loss: 0.0045\n",
-      "2024-11-15 01:45:46 | Epoch [5/60], Step [250/320], Loss: 0.0044\n",
-      "2024-11-15 01:45:54 | Epoch [5/60], Step [275/320], Loss: 0.0042\n",
-      "2024-11-15 01:46:02 | Epoch [5/60], Step [300/320], Loss: 0.0039\n",
-      "2024-11-15 01:46:19 | Epoch [6/60], Step [25/320], Loss: 0.0037\n",
-      "2024-11-15 01:46:28 | Epoch [6/60], Step [50/320], Loss: 0.0036\n",
-      "2024-11-15 01:46:36 | Epoch [6/60], Step [75/320], Loss: 0.0035\n",
-      "2024-11-15 01:46:44 | Epoch [6/60], Step [100/320], Loss: 0.0035\n",
-      "2024-11-15 01:46:52 | Epoch [6/60], Step [125/320], Loss: 0.0036\n",
-      "2024-11-15 01:47:00 | Epoch [6/60], Step [150/320], Loss: 0.0035\n",
-      "2024-11-15 01:47:08 | Epoch [6/60], Step [175/320], Loss: 0.0035\n",
-      "2024-11-15 01:47:16 | Epoch [6/60], Step [200/320], Loss: 0.0031\n",
-      "2024-11-15 01:47:25 | Epoch [6/60], Step [225/320], Loss: 0.0032\n",
-      "2024-11-15 01:47:34 | Epoch [6/60], Step [250/320], Loss: 0.0029\n",
-      "2024-11-15 01:47:42 | Epoch [6/60], Step [275/320], Loss: 0.0028\n",
-      "2024-11-15 01:47:50 | Epoch [6/60], Step [300/320], Loss: 0.003\n",
-      "Start validation # 6\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 40/40 [05:39<00:00,  8.50s/it]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "finger-1    : 0.9218\n",
-      "finger-2    : 0.9520\n",
-      "finger-3    : 0.9634\n",
-      "finger-4    : 0.9117\n",
-      "finger-5    : 0.9380\n",
-      "finger-6    : 0.9628\n",
-      "finger-7    : 0.9589\n",
-      "finger-8    : 0.9004\n",
-      "finger-9    : 0.9417\n",
-      "finger-10   : 0.9611\n",
-      "finger-11   : 0.9579\n",
-      "finger-12   : 0.9169\n",
-      "finger-13   : 0.9433\n",
-      "finger-14   : 0.9619\n",
-      "finger-15   : 0.9497\n",
-      "finger-16   : 0.8903\n",
-      "finger-17   : 0.8997\n",
-      "finger-18   : 0.9542\n",
-      "finger-19   : 0.9587\n",
-      "Trapezium   : 0.9034\n",
-      "Trapezoid   : 0.8639\n",
-      "Capitate    : 0.9391\n",
-      "Hamate      : 0.9169\n",
-      "Scaphoid    : 0.9286\n",
-      "Lunate      : 0.9161\n",
-      "Triquetrum  : 0.9017\n",
-      "Pisiform    : 0.8326\n",
-      "Radius      : 0.9778\n",
-      "Ulna        : 0.9666\n",
-      "Best performance at epoch: 6, 0.8900 -> 0.9307\n",
-      "Save model in /data/ephemeral/home/data/result\n",
-      "2024-11-15 01:53:50 | Epoch [7/60], Step [25/320], Loss: 0.0027\n",
-      "2024-11-15 01:53:58 | Epoch [7/60], Step [50/320], Loss: 0.0029\n",
-      "2024-11-15 01:54:07 | Epoch [7/60], Step [75/320], Loss: 0.0026\n",
-      "2024-11-15 01:54:15 | Epoch [7/60], Step [100/320], Loss: 0.0027\n",
-      "2024-11-15 01:54:23 | Epoch [7/60], Step [125/320], Loss: 0.0026\n",
-      "2024-11-15 01:54:31 | Epoch [7/60], Step [150/320], Loss: 0.0023\n",
-      "2024-11-15 01:54:39 | Epoch [7/60], Step [175/320], Loss: 0.0023\n",
-      "2024-11-15 01:54:47 | Epoch [7/60], Step [200/320], Loss: 0.0023\n",
-      "2024-11-15 01:54:55 | Epoch [7/60], Step [225/320], Loss: 0.0024\n",
-      "2024-11-15 01:55:03 | Epoch [7/60], Step [250/320], Loss: 0.0022\n",
-      "2024-11-15 01:55:10 | Epoch [7/60], Step [275/320], Loss: 0.0021\n",
-      "2024-11-15 01:55:19 | Epoch [7/60], Step [300/320], Loss: 0.0024\n",
-      "2024-11-15 01:55:37 | Epoch [8/60], Step [25/320], Loss: 0.0021\n",
-      "2024-11-15 01:55:45 | Epoch [8/60], Step [50/320], Loss: 0.0021\n",
-      "2024-11-15 01:55:53 | Epoch [8/60], Step [75/320], Loss: 0.0021\n",
-      "2024-11-15 01:56:01 | Epoch [8/60], Step [100/320], Loss: 0.002\n",
-      "2024-11-15 01:56:09 | Epoch [8/60], Step [125/320], Loss: 0.002\n",
-      "2024-11-15 01:56:17 | Epoch [8/60], Step [150/320], Loss: 0.0018\n",
-      "2024-11-15 01:56:26 | Epoch [8/60], Step [175/320], Loss: 0.0024\n",
-      "2024-11-15 01:56:34 | Epoch [8/60], Step [200/320], Loss: 0.0023\n",
-      "2024-11-15 01:56:42 | Epoch [8/60], Step [225/320], Loss: 0.0024\n",
-      "2024-11-15 01:56:50 | Epoch [8/60], Step [250/320], Loss: 0.0027\n",
-      "2024-11-15 01:56:59 | Epoch [8/60], Step [275/320], Loss: 0.0022\n",
-      "2024-11-15 01:57:06 | Epoch [8/60], Step [300/320], Loss: 0.002\n",
-      "2024-11-15 01:57:24 | Epoch [9/60], Step [25/320], Loss: 0.0018\n",
-      "2024-11-15 01:57:32 | Epoch [9/60], Step [50/320], Loss: 0.0018\n",
-      "2024-11-15 01:57:40 | Epoch [9/60], Step [75/320], Loss: 0.0018\n",
-      "2024-11-15 01:57:49 | Epoch [9/60], Step [100/320], Loss: 0.0017\n",
-      "2024-11-15 01:57:57 | Epoch [9/60], Step [125/320], Loss: 0.0018\n",
-      "2024-11-15 01:58:05 | Epoch [9/60], Step [150/320], Loss: 0.0027\n",
-      "2024-11-15 01:58:13 | Epoch [9/60], Step [175/320], Loss: 0.002\n",
-      "2024-11-15 01:58:21 | Epoch [9/60], Step [200/320], Loss: 0.0016\n",
-      "2024-11-15 01:58:29 | Epoch [9/60], Step [225/320], Loss: 0.0018\n",
-      "2024-11-15 01:58:37 | Epoch [9/60], Step [250/320], Loss: 0.0015\n",
-      "2024-11-15 01:58:45 | Epoch [9/60], Step [275/320], Loss: 0.0015\n",
-      "2024-11-15 01:58:54 | Epoch [9/60], Step [300/320], Loss: 0.0016\n",
-      "Start validation # 9\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 40/40 [05:38<00:00,  8.45s/it]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "finger-1    : 0.9257\n",
-      "finger-2    : 0.9492\n",
-      "finger-3    : 0.9640\n",
-      "finger-4    : 0.9243\n",
-      "finger-5    : 0.9403\n",
-      "finger-6    : 0.9645\n",
-      "finger-7    : 0.9619\n",
-      "finger-8    : 0.9221\n",
-      "finger-9    : 0.9397\n",
-      "finger-10   : 0.9667\n",
-      "finger-11   : 0.9615\n",
-      "finger-12   : 0.9227\n",
-      "finger-13   : 0.9432\n",
-      "finger-14   : 0.9650\n",
-      "finger-15   : 0.9539\n",
-      "finger-16   : 0.9120\n",
-      "finger-17   : 0.9234\n",
-      "finger-18   : 0.9578\n",
-      "finger-19   : 0.9617\n",
-      "Trapezium   : 0.9152\n",
-      "Trapezoid   : 0.8870\n",
-      "Capitate    : 0.9418\n",
-      "Hamate      : 0.9300\n",
-      "Scaphoid    : 0.9384\n",
-      "Lunate      : 0.9258\n",
-      "Triquetrum  : 0.9165\n",
-      "Pisiform    : 0.8513\n",
-      "Radius      : 0.9758\n",
-      "Ulna        : 0.9612\n",
-      "Best performance at epoch: 9, 0.9307 -> 0.9380\n",
-      "Save model in /data/ephemeral/home/data/result\n",
-      "2024-11-15 02:04:52 | Epoch [10/60], Step [25/320], Loss: 0.0014\n",
-      "2024-11-15 02:05:00 | Epoch [10/60], Step [50/320], Loss: 0.0017\n",
-      "2024-11-15 02:05:08 | Epoch [10/60], Step [75/320], Loss: 0.0014\n",
-      "2024-11-15 02:05:16 | Epoch [10/60], Step [100/320], Loss: 0.0015\n",
-      "2024-11-15 02:05:24 | Epoch [10/60], Step [125/320], Loss: 0.0014\n",
-      "2024-11-15 02:05:32 | Epoch [10/60], Step [150/320], Loss: 0.0012\n",
-      "2024-11-15 02:05:40 | Epoch [10/60], Step [175/320], Loss: 0.0012\n",
-      "2024-11-15 02:05:49 | Epoch [10/60], Step [200/320], Loss: 0.0013\n",
-      "2024-11-15 02:05:56 | Epoch [10/60], Step [225/320], Loss: 0.0014\n",
-      "2024-11-15 02:06:04 | Epoch [10/60], Step [250/320], Loss: 0.0013\n",
-      "2024-11-15 02:06:12 | Epoch [10/60], Step [275/320], Loss: 0.0012\n",
-      "2024-11-15 02:06:21 | Epoch [10/60], Step [300/320], Loss: 0.0014\n",
-      "2024-11-15 02:06:38 | Epoch [11/60], Step [25/320], Loss: 0.0012\n",
-      "2024-11-15 02:06:46 | Epoch [11/60], Step [50/320], Loss: 0.0012\n",
-      "2024-11-15 02:06:54 | Epoch [11/60], Step [75/320], Loss: 0.0013\n",
-      "2024-11-15 02:07:03 | Epoch [11/60], Step [100/320], Loss: 0.0011\n",
-      "2024-11-15 02:07:11 | Epoch [11/60], Step [125/320], Loss: 0.0012\n",
-      "2024-11-15 02:07:19 | Epoch [11/60], Step [150/320], Loss: 0.0011\n",
-      "2024-11-15 02:07:27 | Epoch [11/60], Step [175/320], Loss: 0.0017\n",
-      "2024-11-15 02:07:36 | Epoch [11/60], Step [200/320], Loss: 0.0014\n",
-      "2024-11-15 02:07:44 | Epoch [11/60], Step [225/320], Loss: 0.0014\n",
-      "2024-11-15 02:07:52 | Epoch [11/60], Step [250/320], Loss: 0.0013\n",
-      "2024-11-15 02:08:01 | Epoch [11/60], Step [275/320], Loss: 0.0012\n",
-      "2024-11-15 02:08:08 | Epoch [11/60], Step [300/320], Loss: 0.0011\n",
-      "2024-11-15 02:08:27 | Epoch [12/60], Step [25/320], Loss: 0.001\n",
-      "2024-11-15 02:08:36 | Epoch [12/60], Step [50/320], Loss: 0.0011\n",
-      "2024-11-15 02:08:44 | Epoch [12/60], Step [75/320], Loss: 0.0011\n",
-      "2024-11-15 02:08:52 | Epoch [12/60], Step [100/320], Loss: 0.001\n",
-      "2024-11-15 02:09:01 | Epoch [12/60], Step [125/320], Loss: 0.0012\n",
-      "2024-11-15 02:09:09 | Epoch [12/60], Step [150/320], Loss: 0.0012\n",
-      "2024-11-15 02:09:17 | Epoch [12/60], Step [175/320], Loss: 0.0013\n",
-      "2024-11-15 02:09:25 | Epoch [12/60], Step [200/320], Loss: 0.001\n",
-      "2024-11-15 02:09:34 | Epoch [12/60], Step [225/320], Loss: 0.0011\n",
-      "2024-11-15 02:09:43 | Epoch [12/60], Step [250/320], Loss: 0.0014\n",
-      "2024-11-15 02:09:51 | Epoch [12/60], Step [275/320], Loss: 0.0014\n",
-      "2024-11-15 02:09:59 | Epoch [12/60], Step [300/320], Loss: 0.0016\n",
-      "Start validation #12\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 40/40 [05:42<00:00,  8.55s/it]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "finger-1    : 0.8662\n",
-      "finger-2    : 0.9435\n",
-      "finger-3    : 0.9627\n",
-      "finger-4    : 0.7809\n",
-      "finger-5    : 0.9005\n",
-      "finger-6    : 0.9436\n",
-      "finger-7    : 0.9616\n",
-      "finger-8    : 0.8524\n",
-      "finger-9    : 0.9067\n",
-      "finger-10   : 0.9551\n",
-      "finger-11   : 0.9522\n",
-      "finger-12   : 0.5254\n",
-      "finger-13   : 0.7696\n",
-      "finger-14   : 0.9558\n",
-      "finger-15   : 0.9386\n",
-      "finger-16   : 0.7976\n",
-      "finger-17   : 0.8231\n",
-      "finger-18   : 0.9434\n",
-      "finger-19   : 0.9518\n",
-      "Trapezium   : 0.9067\n",
-      "Trapezoid   : 0.8829\n",
-      "Capitate    : 0.9206\n",
-      "Hamate      : 0.9222\n",
-      "Scaphoid    : 0.9274\n",
-      "Lunate      : 0.9046\n",
-      "Triquetrum  : 0.9116\n",
-      "Pisiform    : 0.8255\n",
-      "Radius      : 0.9762\n",
-      "Ulna        : 0.9696\n",
-      "2024-11-15 02:15:59 | Epoch [13/60], Step [25/320], Loss: 0.0011\n",
-      "2024-11-15 02:16:08 | Epoch [13/60], Step [50/320], Loss: 0.0013\n",
-      "2024-11-15 02:16:16 | Epoch [13/60], Step [75/320], Loss: 0.0011\n",
-      "2024-11-15 02:16:24 | Epoch [13/60], Step [100/320], Loss: 0.0011\n",
-      "2024-11-15 02:16:32 | Epoch [13/60], Step [125/320], Loss: 0.001\n",
-      "2024-11-15 02:16:40 | Epoch [13/60], Step [150/320], Loss: 0.0008\n",
-      "2024-11-15 02:16:49 | Epoch [13/60], Step [175/320], Loss: 0.0009\n",
-      "2024-11-15 02:16:58 | Epoch [13/60], Step [200/320], Loss: 0.0009\n",
-      "2024-11-15 02:17:06 | Epoch [13/60], Step [225/320], Loss: 0.001\n",
-      "2024-11-15 02:17:14 | Epoch [13/60], Step [250/320], Loss: 0.0009\n",
-      "2024-11-15 02:17:22 | Epoch [13/60], Step [275/320], Loss: 0.0008\n",
-      "2024-11-15 02:17:30 | Epoch [13/60], Step [300/320], Loss: 0.0011\n",
-      "2024-11-15 02:17:47 | Epoch [14/60], Step [25/320], Loss: 0.0009\n",
-      "2024-11-15 02:17:56 | Epoch [14/60], Step [50/320], Loss: 0.0009\n",
-      "2024-11-15 02:18:04 | Epoch [14/60], Step [75/320], Loss: 0.0009\n",
-      "2024-11-15 02:18:12 | Epoch [14/60], Step [100/320], Loss: 0.0008\n",
-      "2024-11-15 02:18:20 | Epoch [14/60], Step [125/320], Loss: 0.0009\n",
-      "2024-11-15 02:18:28 | Epoch [14/60], Step [150/320], Loss: 0.0008\n",
-      "2024-11-15 02:18:37 | Epoch [14/60], Step [175/320], Loss: 0.0016\n",
-      "2024-11-15 02:18:45 | Epoch [14/60], Step [200/320], Loss: 0.0011\n",
-      "2024-11-15 02:18:53 | Epoch [14/60], Step [225/320], Loss: 0.001\n",
-      "2024-11-15 02:19:01 | Epoch [14/60], Step [250/320], Loss: 0.001\n",
-      "2024-11-15 02:19:09 | Epoch [14/60], Step [275/320], Loss: 0.0009\n",
-      "2024-11-15 02:19:18 | Epoch [14/60], Step [300/320], Loss: 0.0008\n",
-      "2024-11-15 02:19:36 | Epoch [15/60], Step [25/320], Loss: 0.0008\n",
-      "2024-11-15 02:19:44 | Epoch [15/60], Step [50/320], Loss: 0.0008\n",
-      "2024-11-15 02:19:52 | Epoch [15/60], Step [75/320], Loss: 0.0008\n",
-      "2024-11-15 02:20:00 | Epoch [15/60], Step [100/320], Loss: 0.0007\n",
-      "2024-11-15 02:20:08 | Epoch [15/60], Step [125/320], Loss: 0.0009\n",
-      "2024-11-15 02:20:17 | Epoch [15/60], Step [150/320], Loss: 0.0008\n",
-      "2024-11-15 02:20:25 | Epoch [15/60], Step [175/320], Loss: 0.001\n",
-      "2024-11-15 02:20:33 | Epoch [15/60], Step [200/320], Loss: 0.0009\n",
-      "2024-11-15 02:20:41 | Epoch [15/60], Step [225/320], Loss: 0.0009\n",
-      "2024-11-15 02:20:50 | Epoch [15/60], Step [250/320], Loss: 0.0007\n",
-      "2024-11-15 02:20:58 | Epoch [15/60], Step [275/320], Loss: 0.0007\n",
-      "2024-11-15 02:21:06 | Epoch [15/60], Step [300/320], Loss: 0.0008\n",
-      "Start validation #15\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 40/40 [05:37<00:00,  8.44s/it]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "finger-1    : 0.9274\n",
-      "finger-2    : 0.9557\n",
-      "finger-3    : 0.9674\n",
-      "finger-4    : 0.9288\n",
-      "finger-5    : 0.9491\n",
-      "finger-6    : 0.9644\n",
-      "finger-7    : 0.9656\n",
-      "finger-8    : 0.9275\n",
-      "finger-9    : 0.9531\n",
-      "finger-10   : 0.9680\n",
-      "finger-11   : 0.9616\n",
-      "finger-12   : 0.9381\n",
-      "finger-13   : 0.9510\n",
-      "finger-14   : 0.9637\n",
-      "finger-15   : 0.9539\n",
-      "finger-16   : 0.9222\n",
-      "finger-17   : 0.9359\n",
-      "finger-18   : 0.9616\n",
-      "finger-19   : 0.9665\n",
-      "Trapezium   : 0.9262\n",
-      "Trapezoid   : 0.8951\n",
-      "Capitate    : 0.9464\n",
-      "Hamate      : 0.9293\n",
-      "Scaphoid    : 0.9485\n",
-      "Lunate      : 0.9340\n",
-      "Triquetrum  : 0.9293\n",
-      "Pisiform    : 0.8605\n",
-      "Radius      : 0.9785\n",
-      "Ulna        : 0.9728\n",
-      "Best performance at epoch: 15, 0.9380 -> 0.9442\n",
-      "Save model in /data/ephemeral/home/data/result\n",
-      "2024-11-15 02:27:04 | Epoch [16/60], Step [25/320], Loss: 0.0007\n",
-      "2024-11-15 02:27:12 | Epoch [16/60], Step [50/320], Loss: 0.001\n",
-      "2024-11-15 02:27:21 | Epoch [16/60], Step [75/320], Loss: 0.0008\n",
-      "2024-11-15 02:27:29 | Epoch [16/60], Step [100/320], Loss: 0.0019\n",
-      "2024-11-15 02:27:37 | Epoch [16/60], Step [125/320], Loss: 0.002\n",
-      "2024-11-15 02:27:45 | Epoch [16/60], Step [150/320], Loss: 0.001\n",
-      "2024-11-15 02:27:53 | Epoch [16/60], Step [175/320], Loss: 0.0009\n",
-      "2024-11-15 02:28:01 | Epoch [16/60], Step [200/320], Loss: 0.0009\n",
-      "2024-11-15 02:28:09 | Epoch [16/60], Step [225/320], Loss: 0.0009\n",
-      "2024-11-15 02:28:17 | Epoch [16/60], Step [250/320], Loss: 0.0008\n",
-      "2024-11-15 02:28:25 | Epoch [16/60], Step [275/320], Loss: 0.0007\n",
-      "2024-11-15 02:28:33 | Epoch [16/60], Step [300/320], Loss: 0.0009\n",
-      "2024-11-15 02:28:50 | Epoch [17/60], Step [25/320], Loss: 0.0008\n",
-      "2024-11-15 02:28:58 | Epoch [17/60], Step [50/320], Loss: 0.0007\n",
-      "2024-11-15 02:29:07 | Epoch [17/60], Step [75/320], Loss: 0.0008\n",
-      "2024-11-15 02:29:15 | Epoch [17/60], Step [100/320], Loss: 0.0009\n",
-      "2024-11-15 02:29:23 | Epoch [17/60], Step [125/320], Loss: 0.0008\n",
-      "2024-11-15 02:29:31 | Epoch [17/60], Step [150/320], Loss: 0.0006\n",
-      "2024-11-15 02:29:39 | Epoch [17/60], Step [175/320], Loss: 0.0012\n",
-      "2024-11-15 02:29:47 | Epoch [17/60], Step [200/320], Loss: 0.001\n",
-      "2024-11-15 02:29:55 | Epoch [17/60], Step [225/320], Loss: 0.001\n",
-      "2024-11-15 02:30:03 | Epoch [17/60], Step [250/320], Loss: 0.0009\n",
-      "2024-11-15 02:30:11 | Epoch [17/60], Step [275/320], Loss: 0.0007\n",
-      "2024-11-15 02:30:19 | Epoch [17/60], Step [300/320], Loss: 0.0007\n",
-      "2024-11-15 02:30:36 | Epoch [18/60], Step [25/320], Loss: 0.0006\n",
-      "2024-11-15 02:30:45 | Epoch [18/60], Step [50/320], Loss: 0.0007\n",
-      "2024-11-15 02:30:53 | Epoch [18/60], Step [75/320], Loss: 0.0007\n",
-      "2024-11-15 02:31:01 | Epoch [18/60], Step [100/320], Loss: 0.0006\n",
-      "2024-11-15 02:31:09 | Epoch [18/60], Step [125/320], Loss: 0.0007\n",
-      "2024-11-15 02:31:17 | Epoch [18/60], Step [150/320], Loss: 0.0007\n",
-      "2024-11-15 02:31:25 | Epoch [18/60], Step [175/320], Loss: 0.0008\n",
-      "2024-11-15 02:31:33 | Epoch [18/60], Step [200/320], Loss: 0.0007\n",
-      "2024-11-15 02:31:42 | Epoch [18/60], Step [225/320], Loss: 0.001\n",
-      "2024-11-15 02:31:49 | Epoch [18/60], Step [250/320], Loss: 0.0006\n",
-      "2024-11-15 02:31:58 | Epoch [18/60], Step [275/320], Loss: 0.0006\n",
-      "2024-11-15 02:32:05 | Epoch [18/60], Step [300/320], Loss: 0.0007\n",
-      "Start validation #18\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 40/40 [05:45<00:00,  8.65s/it]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "finger-1    : 0.9375\n",
-      "finger-2    : 0.9577\n",
-      "finger-3    : 0.9707\n",
-      "finger-4    : 0.9349\n",
-      "finger-5    : 0.9513\n",
-      "finger-6    : 0.9686\n",
-      "finger-7    : 0.9687\n",
-      "finger-8    : 0.9272\n",
-      "finger-9    : 0.9381\n",
-      "finger-10   : 0.9688\n",
-      "finger-11   : 0.9642\n",
-      "finger-12   : 0.9362\n",
-      "finger-13   : 0.9478\n",
-      "finger-14   : 0.9673\n",
-      "finger-15   : 0.9614\n",
-      "finger-16   : 0.9146\n",
-      "finger-17   : 0.9291\n",
-      "finger-18   : 0.9435\n",
-      "finger-19   : 0.9671\n",
-      "Trapezium   : 0.9281\n",
-      "Trapezoid   : 0.8982\n",
-      "Capitate    : 0.9469\n",
-      "Hamate      : 0.9285\n",
-      "Scaphoid    : 0.9526\n",
-      "Lunate      : 0.9384\n",
-      "Triquetrum  : 0.9269\n",
-      "Pisiform    : 0.8527\n",
-      "Radius      : 0.9807\n",
-      "Ulna        : 0.9750\n",
-      "Best performance at epoch: 18, 0.9442 -> 0.9442\n",
-      "Save model in /data/ephemeral/home/data/result\n",
-      "2024-11-15 02:38:12 | Epoch [19/60], Step [25/320], Loss: 0.0006\n",
-      "2024-11-15 02:38:21 | Epoch [19/60], Step [50/320], Loss: 0.0009\n",
-      "2024-11-15 02:38:29 | Epoch [19/60], Step [75/320], Loss: 0.0007\n",
-      "2024-11-15 02:38:38 | Epoch [19/60], Step [100/320], Loss: 0.0007\n",
-      "2024-11-15 02:38:49 | Epoch [19/60], Step [125/320], Loss: 0.0006\n",
-      "2024-11-15 02:39:06 | Epoch [19/60], Step [150/320], Loss: 0.0005\n",
-      "2024-11-15 02:39:14 | Epoch [19/60], Step [175/320], Loss: 0.0005\n",
-      "2024-11-15 02:39:22 | Epoch [19/60], Step [200/320], Loss: 0.0006\n",
-      "2024-11-15 02:39:30 | Epoch [19/60], Step [225/320], Loss: 0.0006\n",
-      "2024-11-15 02:39:38 | Epoch [19/60], Step [250/320], Loss: 0.0006\n",
-      "2024-11-15 02:39:47 | Epoch [19/60], Step [275/320], Loss: 0.0006\n",
-      "2024-11-15 02:39:56 | Epoch [19/60], Step [300/320], Loss: 0.0007\n",
-      "2024-11-15 02:40:13 | Epoch [20/60], Step [25/320], Loss: 0.0006\n",
-      "2024-11-15 02:40:22 | Epoch [20/60], Step [50/320], Loss: 0.0005\n",
-      "2024-11-15 02:40:30 | Epoch [20/60], Step [75/320], Loss: 0.0006\n",
-      "2024-11-15 02:40:38 | Epoch [20/60], Step [100/320], Loss: 0.0005\n",
-      "2024-11-15 02:40:46 | Epoch [20/60], Step [125/320], Loss: 0.0006\n",
-      "2024-11-15 02:40:54 | Epoch [20/60], Step [150/320], Loss: 0.0005\n",
-      "2024-11-15 02:41:04 | Epoch [20/60], Step [175/320], Loss: 0.0006\n",
-      "2024-11-15 02:41:12 | Epoch [20/60], Step [200/320], Loss: 0.0007\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "train(model, train_loader, valid_loader, criterion, optimizer)"
    ]
@@ -1518,8 +946,8 @@
     "\n",
     "        for step, (images, image_names) in tqdm(enumerate(data_loader), total=len(data_loader)):\n",
     "            images = images.cuda()    \n",
-    "            outputs = model(images)['out']\n",
-    "            # outputs = model(images)\n",
+    "            # outputs = model(images)['out']\n",
+    "            outputs = model(images)\n",
     "            \n",
     "            outputs = F.interpolate(outputs, size=(2048, 2048), mode=\"bilinear\")\n",
     "            outputs = torch.sigmoid(outputs)\n",
@@ -1541,7 +969,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "tf = A.Resize(512, 512)"
+    "tf = A.Resize(1536, 1536)"
    ]
   },
   {
@@ -1631,7 +1059,7 @@
    "outputs": [],
    "source": [
     "fig, ax = plt.subplots(1, 2, figsize=(24, 12))\n",
-    "ax[0].imshow(image)    # remove channel dimension\n",
+    "ax[0].imshow(image) # remove channel dimension\n",
     "ax[1].imshow(label2rgb(preds))\n",
     "\n",
     "plt.show()"
@@ -1696,13 +1124,13 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df.to_csv(\"torchvision_fcn_resnet101.csv\", index=False)"
+    "df.to_csv(\"smp_unet++_hrnet_w64_re(1536).csv\", index=False)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "3af293a9",
+   "id": "3363ff1f",
    "metadata": {},
    "outputs": [],
    "source": []
diff --git a/module_base/config.yaml b/module_base/config.yaml
index 6f0d2d1..b03858d 100644
--- a/module_base/config.yaml
+++ b/module_base/config.yaml
@@ -1,11 +1,14 @@
 # 데이터 및 모델 저장 경로
-IMAGE_ROOT: "/data/ephemeral/home/data/train/DCM"
-LABEL_ROOT: "/data/ephemeral/home/data/train/outputs_json"
-SAVED_DIR: "/data/ephemeral/home/data/result"
+image_root: /data/ephemeral/home/data/train/DCM
+label_root: /data/ephemeral/home/data/train/outputs_json
+save_dir: /data/ephemeral/home/data/result
 
 # 모델 라이브러리 및 사용 모델 정의
-model_type: 'torchvision'
-model_name: 'fcn_resnet101'
+model_type: smp
+model_name: Unet
+encoder_name: vgg11
+encoder_weights: imagenet
+pretrained: True
 
 # batch_size
 train_batch_size: 2
@@ -22,10 +25,12 @@ max_epoch: 30
 loss: BCEWithLogitsLoss
 
 # validation 인자
-k: 0
+kfold: 0
 val_every: 2
 threshold: 0.5
-pretrained: True
 
 # random seed 
-random_seed: 2024
\ No newline at end of file
+random_seed: 2024
+
+# augmentation
+size: 512
\ No newline at end of file
diff --git a/module_base/dataset.py b/module_base/dataset.py
index 70669cb..a0eb08b 100644
--- a/module_base/dataset.py
+++ b/module_base/dataset.py
@@ -17,15 +17,15 @@
 ]
 
 class XRayDataset(Dataset):
-    def __init__(self, fnames, labels, image_root, label_root, k=0, transforms=None, is_train=True):
+    def __init__(self, fnames, labels, image_root, label_root, kfold=0, transforms=None, is_train=True):
         self.is_train = is_train
         self.transforms = transforms
         self.image_root = image_root
         self.label_root = label_root
-        self.k = k
+        self.kfold = kfold
         self.class2ind = {v: i for i, v in enumerate(CLASSES)}
         self.ind2class = {v: k for k, v in self.class2ind.items()}
-        self.num_classes = len(CLASSES)
+        self.classes = CLASSES
         
         groups = [os.path.dirname(fname) for fname in fnames]
         
@@ -38,13 +38,13 @@ def __init__(self, fnames, labels, image_root, label_root, k=0, transforms=None,
         labelnames = []
         for i, (x, y) in enumerate(gkf.split(fnames, ys, groups)):
             if self.is_train: # k번 빼고 학습
-                if i == self.k:
+                if i == self.kfold:
                     continue
                 filenames += list(fnames[y])
                 labelnames += list(labels[y])
             
             else:  # k번은 검증
-                if i != self.k:
+                if i != self.kfold:
                     continue
                 filenames = list(fnames[y])
                 labelnames = list(labels[y])
diff --git a/module_base/model.py b/module_base/model.py
index 7dae6ee..e409ce0 100644
--- a/module_base/model.py
+++ b/module_base/model.py
@@ -18,10 +18,10 @@ class SMP(nn.Module):
     '''
     SMP에서 제공하는 사전 훈련된 모델을 사용하는 클래스
     '''
-    def __init__(self, model_name, encoder_weights, num_classes):
+    def __init__(self, model_name, encoder_name, encoder_weights, num_classes):
         super(SMP, self).__init__()
-        self.model = smp.Unet(
-            encoder_name=model_name,
+        self.model = smp.__dict__[model_name](
+            encoder_name=encoder_name,
             encoder_weights=encoder_weights,
             in_channels=3,
             classes=num_classes
diff --git a/module_base/train.py b/module_base/train.py
index 892258f..4374d42 100644
--- a/module_base/train.py
+++ b/module_base/train.py
@@ -23,32 +23,6 @@
 from omegaconf import OmegaConf
 from argparse import ArgumentParser
 
-'''
-from argparse import ArgumentParser
-def parse_args():
-    parser = ArgumentParser()
-
-    # Conventional args
-    parser.add_argument('--image_root', type=str, default='/data/ephemeral/home/data/train/DCM',
-                        help='Path to the root directory containing images')
-    parser.add_argument('--label_root', type=str, default='/data/ephemeral/home/data/train/outputs_json',
-                        help='Path to the root directory containing labels')
-    parser.add_argument('--save_dir', type=str, default="/data/ephemeral/home/data/result",
-                        help='Path to the root directory containing save direction')
-    parser.add_argument('--batch_size', type=int, default=2)
-    parser.add_argument('--learning_rate', type=float, default=1e-4)
-    parser.add_argument('--max_epoch', type=int, default=30)
-    parser.add_argument('--val_every', type=int, default=5)
-    parser.add_argument('--random_seed', type=int, default=2024)
-    parser.add_argument('--model_type', type=str, default='torchvision')
-    parser.add_argument('--model_name', type=str, default='fcn_resnet101')
-    # parser.add_argument('--encoder_weights', type=str, default='imagenet')
-    parser.add_argument('--pretrained', type=str, default='True')
-    args = parser.parse_args()
-    
-    return args
-'''
-
 def set_seed(random_seed):
     torch.manual_seed(random_seed)
     torch.cuda.manual_seed(random_seed)
@@ -125,7 +99,7 @@ def validation(epoch, model, val_loader, criterion, model_type, thr=0.5):
     dices_per_class = torch.mean(dices, 0)
     dice_str = [
         f"{c:<12}: {d.item():.4f}"
-        for c, d in zip(val_loader.dataset.num_classes, dices_per_class)
+        for c, d in zip(val_loader.dataset.claases, dices_per_class)
     ]
     dice_str = "\n".join(dice_str) 
     print(dice_str)
@@ -142,8 +116,8 @@ def train(model, train_loader, val_loader, criterion, optimizer, save_dir, rando
     model = model.cuda()
     
     for epoch in range(max_epoch):
-        model.train()
         torch.cuda.empty_cache() # 학습 시작 전 캐시 삭제
+        model.train()
         for step, (images, masks) in enumerate(train_loader):
             # gpu 연산을 위해 device 할당합니다.
             images, masks = images.cuda(), masks.cuda()
@@ -171,8 +145,6 @@ def train(model, train_loader, val_loader, criterion, optimizer, save_dir, rando
                 )
         # validation 주기에 따라 loss를 출력하고 best model을 저장합니다.
         if (epoch + 1) % val_every == 0:
-            # 캐시된 메모리를 해제하여 PyTorch의 메모리 누수를 방지
-            torch.cuda.empty_cache()
             dice = validation(epoch + 1, model, val_loader, criterion, model_type)
             
             if best_dice < dice:
@@ -181,7 +153,7 @@ def train(model, train_loader, val_loader, criterion, optimizer, save_dir, rando
                 best_dice = dice
                 save_model(model, save_dir)
 
-def do_training(cfg):
+def main(cfg):
     set_seed(cfg.random_seed)
     fnames, labels = set_data(cfg)
 
@@ -189,14 +161,12 @@ def do_training(cfg):
         os.makedirs(cfg.save_dir)
     
     train_trans = TransformSelector('albumentation')
-    train_tf = train_trans.get_transform(True, 512)
+    train_tf = train_trans.get_transform(True, cfg.size)
     val_trans = TransformSelector('albumentation')
-    val_tf = val_trans.get_transform(False, 512)
+    val_tf = val_trans.get_transform(False, cfg.size)
 
-    train_dataset = XRayDataset(fnames, labels, cfg.image_root, cfg.label_root, 
-                                fold=cfg.val_fold, transforms=train_tf, is_train=True)
-    valid_dataset = XRayDataset(fnames, labels, cfg.image_root, cfg.label_root, 
-                                fold=cfg.val_fold, transforms=val_tf, is_train=False)
+    train_dataset = XRayDataset(fnames, labels, cfg.image_root, cfg.label_root, cfg.kfold, train_tf, is_train=True)
+    valid_dataset = XRayDataset(fnames, labels, cfg.image_root, cfg.label_root, cfg.kfold, val_tf, is_train=False)
     
     train_loader = DataLoader(
         dataset=train_dataset, 
@@ -216,18 +186,17 @@ def do_training(cfg):
     
     model_selector = ModelSelector(
         model_type=cfg.model_type,
-        num_classes=len(valid_loader.dataset.num_classes),
+        num_classes=len(valid_loader.dataset.classes),
         model_name=cfg.model_name,
-        # encoder_weights=encoder_weights,
-        pretrained=cfg.pretrained
+        encoder_name=cfg.encoder_name,
+        encoder_weights=cfg.encoder_weights
+        # pretrained=cfg.pretrained
     )
     model = model_selector.get_model()
     
-    # Loss function을 정의합니다.
     criterion = nn.BCEWithLogitsLoss()
 
-    # Optimizer를 정의합니다.
-    optimizer = optim.Adam(params=model.parameters(), lr=cfg.lr, weight_decay=1e-6)
+    optimizer = optim.Adam(params=model.parameters(), lr=cfg.lr, weight_decay=cfg.weight_decay)
     
     train(model, train_loader, valid_loader, criterion, optimizer,
         cfg.save_dir, cfg.random_seed, cfg.max_epoch, cfg.val_every, cfg.model_type)
@@ -235,10 +204,8 @@ def do_training(cfg):
 if __name__ == '__main__':
     parser = ArgumentParser()
     parser.add_argument('--config', type=str, default='config.yaml')
-
     args = parser.parse_args()
 
     with open(args.config, 'r') as f:
         cfg = OmegaConf.load(f)
-    
-    do_training(cfg)
\ No newline at end of file
+    main(cfg)
\ No newline at end of file

From 519febb70242ad3bb163f6abc0b8ed84b165789b Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Tue, 19 Nov 2024 12:15:39 +0900
Subject: [PATCH 031/106] [#21] Refactor : complete debugging

---
 .gitignore              |  2 +-
 module_base/config.yaml |  4 +++-
 module_base/dataset.py  |  2 +-
 module_base/loss.py     | 28 ++++++++++++++++++++++++++++
 module_base/train.py    |  2 +-
 5 files changed, 34 insertions(+), 4 deletions(-)
 create mode 100644 module_base/loss.py

diff --git a/.gitignore b/.gitignore
index 29e4376..2d31e07 100644
--- a/.gitignore
+++ b/.gitignore
@@ -19,5 +19,5 @@ __pycache__
 *.tar.gz
 *.xlsx
 
-#wandb
+# wandb
 wandb/
\ No newline at end of file
diff --git a/module_base/config.yaml b/module_base/config.yaml
index b03858d..3a310de 100644
--- a/module_base/config.yaml
+++ b/module_base/config.yaml
@@ -24,9 +24,11 @@ max_epoch: 30
 # loss
 loss: BCEWithLogitsLoss
 
+# optimizer
+
 # validation 인자
 kfold: 0
-val_every: 2
+val_every: 1
 threshold: 0.5
 
 # random seed 
diff --git a/module_base/dataset.py b/module_base/dataset.py
index a0eb08b..a7ebebd 100644
--- a/module_base/dataset.py
+++ b/module_base/dataset.py
@@ -112,7 +112,7 @@ def __len__(self):
         return len(self.fnames)
 
     def __getitem__(self, item):
-        image_name = self.filenames[item]
+        image_name = self.fnames[item]
         image_path = os.path.join(self.image_root, image_name)
 
         image = cv2.imread(image_path)
diff --git a/module_base/loss.py b/module_base/loss.py
new file mode 100644
index 0000000..226fe97
--- /dev/null
+++ b/module_base/loss.py
@@ -0,0 +1,28 @@
+# python native
+import os
+import json
+import random
+import datetime
+from functools import partial
+
+# external library
+import cv2
+import numpy as np
+import pandas as pd
+from tqdm.auto import tqdm
+from sklearn.model_selection import GroupKFold
+import albumentations as A
+import time
+from datetime import timedelta
+
+# torch
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+from torchvision import models
+
+# visualization
+import matplotlib.pyplot as plt
+
diff --git a/module_base/train.py b/module_base/train.py
index 4374d42..f23a2c2 100644
--- a/module_base/train.py
+++ b/module_base/train.py
@@ -99,7 +99,7 @@ def validation(epoch, model, val_loader, criterion, model_type, thr=0.5):
     dices_per_class = torch.mean(dices, 0)
     dice_str = [
         f"{c:<12}: {d.item():.4f}"
-        for c, d in zip(val_loader.dataset.claases, dices_per_class)
+        for c, d in zip(val_loader.dataset.classes, dices_per_class)
     ]
     dice_str = "\n".join(dice_str) 
     print(dice_str)

From c2940a3548d85e847f4b063dcae507c91777379e Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Tue, 19 Nov 2024 15:31:39 +0900
Subject: [PATCH 032/106] [#21] Feature : add LossSelector

---
 module_base/config.yaml  |  4 +++-
 module_base/loss.py      | 37 +++++++++++++------------------------
 module_base/train.py     |  8 +++++++-
 module_base/transform.py |  3 ++-
 4 files changed, 25 insertions(+), 27 deletions(-)

diff --git a/module_base/config.yaml b/module_base/config.yaml
index 3a310de..7e8a6d9 100644
--- a/module_base/config.yaml
+++ b/module_base/config.yaml
@@ -22,7 +22,9 @@ valid_num_workers: 0
 max_epoch: 30
 
 # loss
-loss: BCEWithLogitsLoss
+loss:
+    name: BCEWithLogitsLoss
+    params: null
 
 # optimizer
 
diff --git a/module_base/loss.py b/module_base/loss.py
index 226fe97..d8319d8 100644
--- a/module_base/loss.py
+++ b/module_base/loss.py
@@ -1,28 +1,17 @@
-# python native
-import os
-import json
-import random
-import datetime
-from functools import partial
+import torch.nn as nn
 
-# external library
-import cv2
-import numpy as np
-import pandas as pd
-from tqdm.auto import tqdm
-from sklearn.model_selection import GroupKFold
-import albumentations as A
-import time
-from datetime import timedelta
+class BCE(nn.Module):
+    def __init__(self, **kwargs):
+        super(BCE, self).__init__()
+        self.loss = nn.BCEWithLogitsLoss(**kwargs)
 
-# torch
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torch.optim as optim
-from torch.utils.data import Dataset, DataLoader
-from torchvision import models
+    def forward(self, preds, targets):
+        return self.loss(preds, targets)
 
-# visualization
-import matplotlib.pyplot as plt
+class LossSelector:
+    def __init__(self, loss, **kwargs):
+        if loss == 'BCEWithLogitsLoss':
+            self.loss = BCE(**kwargs)
 
+    def get_loss(self):
+        return self.loss
\ No newline at end of file
diff --git a/module_base/train.py b/module_base/train.py
index f23a2c2..e93fa6d 100644
--- a/module_base/train.py
+++ b/module_base/train.py
@@ -16,6 +16,7 @@
 from dataset import XRayDataset
 from model import ModelSelector
 from transform import TransformSelector
+from loss import LossSelector
 
 import warnings
 warnings.filterwarnings('ignore')
@@ -194,7 +195,12 @@ def main(cfg):
     )
     model = model_selector.get_model()
     
-    criterion = nn.BCEWithLogitsLoss()
+    # criterion = nn.BCEWithLogitsLoss()
+    if cfg.loss.params:
+        loss = LossSelector(cfg.loss.name, **cfg.loss.params)
+    else:
+        loss = LossSelector(cfg.loss.name)
+    criterion = loss.get_loss()
 
     optimizer = optim.Adam(params=model.parameters(), lr=cfg.lr, weight_decay=cfg.weight_decay)
     
diff --git a/module_base/transform.py b/module_base/transform.py
index d08dc59..cc2b6fa 100644
--- a/module_base/transform.py
+++ b/module_base/transform.py
@@ -7,7 +7,8 @@ def __init__(self, is_train, resize):
         if is_train:
             self.transform = A.Compose(
                 [
-                    A.HorizontalFlip(0.2)
+                    A.HorizontalFlip(0.2),
+                    A.CLAHE(clip_limit=4.0, tile_grid_size=(8, 8), always_apply=False, p=1.0)
                 ]+ common_transform)
         else:
             self.transform = A.Compose(common_transform)

From f8d101973c5d3e02c8b4e8646df012bc88a0fe0b Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Tue, 19 Nov 2024 19:59:42 +0900
Subject: [PATCH 033/106] [#21] Feature : validation optimal

---
 module_base/config.yaml | 4 ++--
 module_base/train.py    | 9 +++++----
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/module_base/config.yaml b/module_base/config.yaml
index 7e8a6d9..812d2ba 100644
--- a/module_base/config.yaml
+++ b/module_base/config.yaml
@@ -6,7 +6,7 @@ save_dir: /data/ephemeral/home/data/result
 # 모델 라이브러리 및 사용 모델 정의
 model_type: smp
 model_name: Unet
-encoder_name: vgg11
+encoder_name: vgg19
 encoder_weights: imagenet
 pretrained: True
 
@@ -33,7 +33,7 @@ kfold: 0
 val_every: 1
 threshold: 0.5
 
-# random seed 
+# random seed
 random_seed: 2024
 
 # augmentation
diff --git a/module_base/train.py b/module_base/train.py
index e93fa6d..0acbed3 100644
--- a/module_base/train.py
+++ b/module_base/train.py
@@ -90,11 +90,12 @@ def validation(epoch, model, val_loader, criterion, model_type, thr=0.5):
             cnt += 1
             
             outputs = torch.sigmoid(outputs)
-            outputs = (outputs > thr).detach().cpu()
-            masks = masks.detach().cpu()
-            
+            # outputs = (outputs > thr).detach().cpu()
+            # masks = masks.detach().cpu()
+            outputs = (outputs > thr)
             dice = dice_coef(outputs, masks)
-            dices.append(dice)
+            # dices.append(dice)
+            dices.append(dice.detach().cpu())
                 
     dices = torch.cat(dices, 0)
     dices_per_class = torch.mean(dices, 0)

From 746345dc5df840a60270b2fc15a893add39788a5 Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Wed, 20 Nov 2024 13:00:25 +0900
Subject: [PATCH 034/106] [#21] Feature & Refactor: add wandb, modify
 wandb_train.py to fit the current file

---
 module_base/config.yaml     |  11 +-
 module_base/wandb_logger.py |  82 ++++++++++++
 module_base/wandb_train.py  | 243 ++++++++++++++++++++++++++++++++++++
 3 files changed, 333 insertions(+), 3 deletions(-)
 create mode 100644 module_base/wandb_logger.py
 create mode 100644 module_base/wandb_train.py

diff --git a/module_base/config.yaml b/module_base/config.yaml
index 812d2ba..86f90de 100644
--- a/module_base/config.yaml
+++ b/module_base/config.yaml
@@ -5,8 +5,8 @@ save_dir: /data/ephemeral/home/data/result
 
 # 모델 라이브러리 및 사용 모델 정의
 model_type: smp
-model_name: Unet
-encoder_name: vgg19
+model_name: UnetPlusPlus
+encoder_name: efficientnet-b5
 encoder_weights: imagenet
 pretrained: True
 
@@ -27,6 +27,7 @@ loss:
     params: null
 
 # optimizer
+optim: Adam
 
 # validation 인자
 kfold: 0
@@ -37,4 +38,8 @@ threshold: 0.5
 random_seed: 2024
 
 # augmentation
-size: 512
\ No newline at end of file
+size: 512
+
+# wandb
+wandb_run_name: yoon_unet++_efficientnet
+wandb_run_id: None
\ No newline at end of file
diff --git a/module_base/wandb_logger.py b/module_base/wandb_logger.py
new file mode 100644
index 0000000..603ce06
--- /dev/null
+++ b/module_base/wandb_logger.py
@@ -0,0 +1,82 @@
+import wandb
+
+class WandbLogger:
+    def __init__(self, project_name="Hand Bone Image Segmentation", name=None):
+        """
+        Args:
+            project_name (str): wandb project name (default: "Hand Bone Image Segmentation")
+            name (str): wandb run name (optional)
+        """
+        self.project_name = project_name
+        self.name = name
+        self.run = None
+
+    def initialize(self, config):
+        """Initialize wandb run with config"""
+        self.run = wandb.init(
+            project=self.project_name,
+            name=self.name,
+            config=config
+        )
+
+    def log_metric(self, metrics, step=None):
+        """
+        Log metrics to wandb
+        
+        Args:
+            metrics (dict): metrics to log
+            step (int, optional): step number
+        """
+        if self.run is not None:
+            wandb.log(metrics, step=step)
+
+    def log_batch_metrics(self, loss, extra_info, learning_rate, step=None):
+        """
+        Log batch-level metrics
+        
+        Args:
+            loss (float): total loss value
+            extra_info (dict): dictionary containing detailed losses
+            learning_rate (float): current learning rate
+            step (int, optional): step number
+        """
+        metrics = {
+            "loss": loss,
+            "learning_rate": learning_rate,
+            **extra_info
+        }
+        self.log_metric(metrics, step)
+
+    def log_epoch_metrics(self, metrics):
+        """
+        Log epoch-level metrics
+        
+        Args:
+            metrics (dict): Dictionary containing all metrics to log
+                Expected keys: epoch, loss, cls_loss, angle_loss, iou_loss,
+                            learning_rate, epoch_time
+        """
+        if self.run is not None:
+            self.log_metric(metrics)
+
+    def log_model(self, model_path, model_name):
+        """
+        Log model checkpoint
+        
+        Args:
+            model_path (str): path to model checkpoint
+            model_name (str): name of model artifact
+        """
+        if self.run is not None:
+            artifact = wandb.Artifact(
+                model_name, 
+                type='model',
+                description=f"Model checkpoint at {model_path}"
+            )
+            artifact.add_file(model_path)
+            self.run.log_artifact(artifact)
+
+    def finish(self):
+        """End the wandb run"""
+        if self.run is not None:
+            wandb.finish()
\ No newline at end of file
diff --git a/module_base/wandb_train.py b/module_base/wandb_train.py
new file mode 100644
index 0000000..80e7d1a
--- /dev/null
+++ b/module_base/wandb_train.py
@@ -0,0 +1,243 @@
+# python native
+import os
+import random
+import time
+import datetime
+
+import numpy as np
+from tqdm.auto import tqdm
+import albumentations as A
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from torch.utils.data import DataLoader
+
+from dataset import XRayDataset
+from model import ModelSelector
+from transform import TransformSelector
+from loss import LossSelector
+
+import warnings
+warnings.filterwarnings('ignore')
+
+from omegaconf import OmegaConf
+from argparse import ArgumentParser
+from wandb_logger import WandbLogger
+
+def set_seed(random_seed):
+    torch.manual_seed(random_seed)
+    torch.cuda.manual_seed(random_seed)
+    torch.cuda.manual_seed_all(random_seed) # if use multi-GPU
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+    np.random.seed(random_seed)
+    random.seed(random_seed)
+
+def dice_coef(y_true, y_pred):
+    y_true_f = y_true.flatten(2)
+    y_pred_f = y_pred.flatten(2)
+    intersection = torch.sum(y_true_f * y_pred_f, -1)
+    eps = 0.0001
+    return (2. * intersection + eps) / (torch.sum(y_true_f, -1) + torch.sum(y_pred_f, -1) + eps)
+
+def set_data(cfg):
+    pngs = {
+        os.path.relpath(os.path.join(root, fname), start=cfg.image_root)
+        for root, _dirs, files in os.walk(cfg.image_root)
+        for fname in files
+        if os.path.splitext(fname)[1].lower() == ".png"
+    }
+
+    jsons = {
+        os.path.relpath(os.path.join(root, fname), start=cfg.label_root)
+        for root, _dirs, files in os.walk(cfg.label_root)
+        for fname in files
+        if os.path.splitext(fname)[1].lower() == ".json"
+    }
+    return np.array(sorted(pngs)), np.array(sorted(jsons))
+
+def save_model(model, save_dir, file_name='best_model.pt'):
+    output_path = os.path.join(save_dir, file_name)
+    torch.save(model, output_path)
+
+def validation(epoch, model, val_loader, criterion, model_type, thr=0.5):
+    print(f'Start validation #{epoch:2d}')
+    model.eval()
+
+    dices = []
+    with torch.no_grad():
+        total_loss = 0
+        cnt = 0
+
+        for step, (images, masks) in tqdm(enumerate(val_loader), total=len(val_loader)):
+            images, masks = images.cuda(), masks.cuda()         
+            model = model.cuda()
+            
+            if model_type == 'torchvision':
+                outputs = model(images)['out']
+            elif model_type == 'smp':
+                outputs = model(images)
+            
+            output_h, output_w = outputs.size(-2), outputs.size(-1)
+            mask_h, mask_w = masks.size(-2), masks.size(-1)
+            
+            # gt와 prediction의 크기가 다른 경우 prediction을 gt에 맞춰 interpolation 합니다.
+            if output_h != mask_h or output_w != mask_w:
+                outputs = F.interpolate(outputs, size=(mask_h, mask_w), mode="bilinear")
+            
+            loss = criterion(outputs, masks)
+            total_loss += loss
+            cnt += 1
+            
+            outputs = torch.sigmoid(outputs)
+            outputs = (outputs > thr)
+            dice = dice_coef(outputs, masks)
+            dices.append(dice.detach().cpu())
+                
+    dices = torch.cat(dices, 0)
+    dices_per_class = torch.mean(dices, 0)
+    dice_str = [
+        f"{c:<12}: {d.item():.4f}"
+        for c, d in zip(val_loader.dataset.classes, dices_per_class)
+    ]
+    dice_str = "\n".join(dice_str) 
+    print(dice_str)
+    
+    avg_dice = torch.mean(dices_per_class).item()
+    val_loss = total_loss / len(val_loader.dataset)
+    
+    return avg_dice, val_loss
+
+def train(model, train_loader, val_loader, criterion, optimizer, cfg):
+    print(f'Start training..')
+    logger = WandbLogger(name=cfg.wandb_run_name)
+    
+    wandb_config = {
+        "model_name": cfg.model_name,
+        "model_backbone": cfg.encoder_name,
+        "learning_rate": cfg.lr,
+        "max_epoch": cfg.max_epoch,
+        "optimizer": cfg.optim,
+        "criterion": cfg.loss.name
+    }
+    best_dice = 0.
+    scaler = torch.cuda.amp.GradScaler()
+    model = model.cuda()
+    logger.initialize(wandb_config)
+    
+    for epoch in range(cfg.max_epoch):
+        epoch_start = time.time()
+        epoch_loss = 0
+        torch.cuda.empty_cache() # 학습 시작 전 캐시 삭제
+        model.train()
+        for step, (images, masks) in enumerate(train_loader):
+            # gpu 연산을 위해 device 할당합니다.
+            images, masks = images.cuda(), masks.cuda()
+            
+            # Mixed Precision Training으로 loss 계산에서만 FP32 사용
+            with torch.cuda.amp.autocast():
+                if cfg.model_type == 'torchvision':
+                    outputs = model(images)['out']
+                elif cfg.model_type == 'smp':
+                    outputs = model(images)
+                loss = criterion(outputs, masks)
+            # 스케일된 loss를 사용해 backward 및 optimizer step
+            optimizer.zero_grad()
+            scaler.scale(loss).backward()
+            scaler.step(optimizer)
+            scaler.update()
+            
+            # step 주기에 따라 loss를 출력합니다.
+            if (step + 1) % 25 == 0:
+                print(
+                    f'{datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")} | '
+                    f'Epoch [{epoch+1}/{cfg.max_epoch}], '
+                    f'Step [{step+1}/{len(train_loader)}], '
+                    f'Loss: {round(loss.item(),4)}'
+                )
+        epoch_time = datetime.timedelta(seconds=time.time() - epoch_start)
+        dataset_size = len(train_loader.dataset)
+        epoch_loss = epoch_loss / dataset_size
+        # validation 주기에 따라 loss를 출력하고 best model을 저장합니다.
+        if (epoch + 1) % cfg.val_every == 0:
+            dice, val_loss = validation(epoch + 1, model, val_loader, criterion, cfg.model_type)
+            
+            if best_dice < dice:
+                print(f"Best performance at epoch: {epoch + 1}, {best_dice:.4f} -> {dice:.4f}")
+                print(f"Save model in {cfg.save_dir}")
+                best_dice = dice
+                ckpt_path = save_model(model, cfg.save_dir)
+            logger.log_model(ckpt_path, f'model-epoch-{epoch+1}')
+            logger.log_epoch_metrics(
+                {
+                    "epoch": epoch,
+                    "loss": epoch_loss,
+                    "dice": dice,
+                    "val_loss": val_loss,
+                    "epoch_time": epoch_time.total_seconds()
+                }
+            )
+    logger.finish()
+
+def main(cfg):
+    set_seed(cfg.random_seed)
+    fnames, labels = set_data(cfg)
+
+    if not os.path.exists(cfg.save_dir):
+        os.makedirs(cfg.save_dir)
+    
+    train_trans = TransformSelector('albumentation')
+    train_tf = train_trans.get_transform(True, cfg.size)
+    val_trans = TransformSelector('albumentation')
+    val_tf = val_trans.get_transform(False, cfg.size)
+
+    train_dataset = XRayDataset(fnames, labels, cfg.image_root, cfg.label_root, cfg.kfold, train_tf, is_train=True)
+    valid_dataset = XRayDataset(fnames, labels, cfg.image_root, cfg.label_root, cfg.kfold, val_tf, is_train=False)
+    
+    train_loader = DataLoader(
+        dataset=train_dataset, 
+        batch_size=cfg.train_batch_size,
+        shuffle=True,
+        num_workers=cfg.train_num_workers,
+        drop_last=True,
+    )
+    
+    valid_loader = DataLoader(
+        dataset=valid_dataset, 
+        batch_size=cfg.valid_batch_size,
+        shuffle=False,
+        num_workers=cfg.valid_num_workers,
+        drop_last=False
+    )
+    
+    model_selector = ModelSelector(
+        model_type=cfg.model_type,
+        num_classes=len(valid_loader.dataset.classes),
+        model_name=cfg.model_name,
+        encoder_name=cfg.encoder_name,
+        encoder_weights=cfg.encoder_weights
+        # pretrained=cfg.pretrained
+    )
+    model = model_selector.get_model()
+    
+    # criterion = nn.BCEWithLogitsLoss()
+    if cfg.loss.params:
+        loss = LossSelector(cfg.loss.name, **cfg.loss.params)
+    else:
+        loss = LossSelector(cfg.loss.name)
+    criterion = loss.get_loss()
+
+    optimizer = optim.Adam(params=model.parameters(), lr=cfg.lr, weight_decay=cfg.weight_decay)
+    
+    train(model, train_loader, valid_loader, criterion, optimizer, cfg)
+
+if __name__ == '__main__':
+    parser = ArgumentParser()
+    parser.add_argument('--config', type=str, default='config.yaml')
+    args = parser.parse_args()
+
+    with open(args.config, 'r') as f:
+        cfg = OmegaConf.load(f)
+    main(cfg)
\ No newline at end of file

From 37078a3cd569355ccd11b6da9fd5ea28ab41a8dd Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Wed, 20 Nov 2024 15:34:55 +0900
Subject: [PATCH 035/106] [#38] Fix : debugging wandb_train.py

---
 module_base/config.yaml    | 6 +++---
 module_base/wandb_train.py | 1 +
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/module_base/config.yaml b/module_base/config.yaml
index 86f90de..b3e0a06 100644
--- a/module_base/config.yaml
+++ b/module_base/config.yaml
@@ -31,15 +31,15 @@ optim: Adam
 
 # validation 인자
 kfold: 0
-val_every: 1
+val_every: 2
 threshold: 0.5
 
 # random seed
 random_seed: 2024
 
 # augmentation
-size: 512
+size: 1024
 
 # wandb
-wandb_run_name: yoon_unet++_efficientnet
+wandb_run_name: Test
 wandb_run_id: None
\ No newline at end of file
diff --git a/module_base/wandb_train.py b/module_base/wandb_train.py
index 80e7d1a..b7346d9 100644
--- a/module_base/wandb_train.py
+++ b/module_base/wandb_train.py
@@ -61,6 +61,7 @@ def set_data(cfg):
 def save_model(model, save_dir, file_name='best_model.pt'):
     output_path = os.path.join(save_dir, file_name)
     torch.save(model, output_path)
+    return output_path
 
 def validation(epoch, model, val_loader, criterion, model_type, thr=0.5):
     print(f'Start validation #{epoch:2d}')

From c2b0aa8517ac502467baae7fb3246eff11392d26 Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Wed, 20 Nov 2024 22:10:21 +0900
Subject: [PATCH 036/106] [Fix] : fix error dataloader get wrong mask

---
 .../configs/_custom_/_base_/schedule_160k.py  |  4 +-
 .../configs/_custom_/_base_/xraydata.py       |  8 +-
 .../_custom_/mask2former/mask2former.py       |  2 +-
 .../configs/_custom_/segnext/segnext.py       | 87 +++++++++++++++++++
 mmsegmentation/mmseg/datasets/xray2.py        | 69 ++++++++++++++-
 5 files changed, 162 insertions(+), 8 deletions(-)
 create mode 100644 mmsegmentation/configs/_custom_/segnext/segnext.py

diff --git a/mmsegmentation/configs/_custom_/_base_/schedule_160k.py b/mmsegmentation/configs/_custom_/_base_/schedule_160k.py
index c804b84..4bf3092 100644
--- a/mmsegmentation/configs/_custom_/_base_/schedule_160k.py
+++ b/mmsegmentation/configs/_custom_/_base_/schedule_160k.py
@@ -1,4 +1,4 @@
-val_save_interval = 2000
+val_save_interval = 1000
 warm_up_step = 1000
 max_iters = 30000
 T_max = max_iters-warm_up_step
@@ -6,7 +6,7 @@
 # optimizer
 embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
 optimizer = dict(
-    type='AdamW', lr=0.001, weight_decay=0.05, eps=1e-8, betas=(0.9, 0.999))
+    type='AdamW', lr=0.0001, weight_decay=0.05, eps=1e-8, betas=(0.9, 0.999))
 optim_wrapper = dict(
     type='OptimWrapper',
     optimizer=optimizer,
diff --git a/mmsegmentation/configs/_custom_/_base_/xraydata.py b/mmsegmentation/configs/_custom_/_base_/xraydata.py
index f09252d..0e6fff0 100644
--- a/mmsegmentation/configs/_custom_/_base_/xraydata.py
+++ b/mmsegmentation/configs/_custom_/_base_/xraydata.py
@@ -1,4 +1,4 @@
-resize_size = (2048, 2048)
+resize_size = (1536, 1536)
 crop_size = (1536, 1536)
 test_size = (2048, 2048)
 
@@ -16,9 +16,9 @@
     #     resize_type='ResizeShortestEdge',
     #     max_size=1536),
     dict(type='Resize', scale=resize_size, keep_ratio=True),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
+    # dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+    # dict(type='RandomFlip', prob=0.5),
+    # dict(type='PhotoMetricDistortion'),
     dict(type='PackSegInputs')
 ]
 
diff --git a/mmsegmentation/configs/_custom_/mask2former/mask2former.py b/mmsegmentation/configs/_custom_/mask2former/mask2former.py
index d415437..adc73dd 100644
--- a/mmsegmentation/configs/_custom_/mask2former/mask2former.py
+++ b/mmsegmentation/configs/_custom_/mask2former/mask2former.py
@@ -48,7 +48,7 @@
         in_channels=[192, 384, 768, 1536],
         strides=[4, 8, 16, 32],
         feat_channels=256,
-        out_channels=256,
+        out_channels=num_classes,
         num_classes=num_classes,
         num_queries=100,
         num_transformer_feat_level=3,
diff --git a/mmsegmentation/configs/_custom_/segnext/segnext.py b/mmsegmentation/configs/_custom_/segnext/segnext.py
new file mode 100644
index 0000000..cba76ce
--- /dev/null
+++ b/mmsegmentation/configs/_custom_/segnext/segnext.py
@@ -0,0 +1,87 @@
+_base_ = [
+    '../_base_/xraydata2.py',
+    '../_base_/default_runtime.py', '../_base_/schedule_160k.py'
+]
+
+# model settings
+checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segnext/mscan_l_20230227-cef260d4.pth'  # noqa
+load_from = 'https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-l_1x16_512x512_adamw_160k_ade20k/segnext_mscan-l_1x16_512x512_adamw_160k_ade20k_20230209_172055-19b14b63.pth'
+num_classes = 29
+
+ham_norm_cfg = dict(type='GN', num_groups=32, requires_grad=True)
+crop_size = (512, 512)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255,
+    size=(512, 512),
+    test_cfg=dict(size_divisor=32))
+model = dict(
+    type='EncoderDecoderWithoutArgmax',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        type='MSCAN',
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file),
+        embed_dims=[64, 128, 320, 512],
+        mlp_ratios=[8, 8, 4, 4],
+        drop_rate=0.0,
+        drop_path_rate=0.3,
+        depths=[3, 5, 27, 3],
+        attention_kernel_sizes=[5, [1, 7], [1, 11], [1, 21]],
+        attention_kernel_paddings=[2, [0, 3], [0, 5], [0, 10]],
+        act_cfg=dict(type='GELU'),
+        norm_cfg=dict(type='BN', requires_grad=True)),
+    decode_head=dict(
+        type='LightHamHeadWithoutAccuracy',
+        in_channels=[128, 320, 512],
+        in_index=[1, 2, 3],
+        channels=1024,
+        ham_channels=1024,
+        dropout_ratio=0.1,
+        num_classes=num_classes,
+        norm_cfg=ham_norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
+        ham_kwargs=dict(
+            MD_S=1,
+            MD_R=16,
+            train_steps=6,
+            eval_steps=7,
+            inv_t=100,
+            rand_init=True)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+
+
+
+# optimizer
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
+    paramwise_cfg=dict(
+        custom_keys={
+            'pos_block': dict(decay_mult=0.),
+            'norm': dict(decay_mult=0.),
+            'head': dict(lr_mult=10.)
+        }))
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        power=1.0,
+        begin=1500,
+        end=30000,
+        eta_min=0.0,
+        by_epoch=False,
+    )
+]
\ No newline at end of file
diff --git a/mmsegmentation/mmseg/datasets/xray2.py b/mmsegmentation/mmseg/datasets/xray2.py
index eafe94a..92c4161 100644
--- a/mmsegmentation/mmseg/datasets/xray2.py
+++ b/mmsegmentation/mmseg/datasets/xray2.py
@@ -138,4 +138,71 @@ class TransposeAnnotations(BaseTransform):
     def transform(self, result):
         result["gt_seg_map"] = np.transpose(result["gt_seg_map"], (2, 0, 1))
         
-        return result
\ No newline at end of file
+        return result
+
+
+
+# MMCV의 LoadAnnotation을 활용해본 버전인데 잘 동작하지 않는듯함
+# @TRANSFORMS.register_module()
+# class LoadXRayAnnotations(MMCV_LoadAnnotations):
+#     def __init__(
+#         self,
+#         reduce_zero_label=None,
+#         backend_args=None,
+#         imdecode_backend='pillow',
+#     ) -> None:
+#         super().__init__(
+#             with_bbox=False,
+#             with_label=False,
+#             with_seg=True,
+#             with_keypoints=False,
+#             imdecode_backend=imdecode_backend,
+#             backend_args=backend_args)
+#         self.reduce_zero_label = reduce_zero_label
+#         if self.reduce_zero_label is not None:
+#             warnings.warn('`reduce_zero_label` will be deprecated, '
+#                           'if you would like to ignore the zero label, please '
+#                           'set `reduce_zero_label=True` when dataset '
+#                           'initialized')
+#         self.imdecode_backend = imdecode_backend
+    
+    
+#     def _load_seg_map(self, results):
+#         label_path = results["seg_map_path"]
+        
+#         image_size = (2048, 2048)
+        
+#         # process a label of shape (H, W, NC)
+#         label_shape = image_size + (len(CLASSES), )
+#         label = np.zeros(label_shape, dtype=np.uint8)
+        
+#         # read label file
+#         with open(label_path, "r") as f:
+#             annotations = json.load(f)
+#         annotations = annotations["annotations"]
+        
+#         # iterate each class
+#         for ann in annotations:
+#             c = ann["label"]
+#             class_ind = CLASS2IND[c]
+#             points = np.array(ann["points"])
+            
+#             # polygon to mask
+#             class_label = np.zeros(image_size, dtype=np.uint8)
+#             cv2.fillPoly(class_label, [points], 1)
+#             label[..., class_ind] = class_label
+        
+#         results["gt_seg_map"] = label
+        
+#         try:
+#             results['seg_fields'].append('gt_seg_map')
+#         except:
+#             results['seg_fields'] = ['gt_seg_map']
+    
+    
+#     def __repr__(self) -> str:
+#         repr_str = self.__class__.__name__
+#         repr_str += f'(reduce_zero_label={self.reduce_zero_label}, '
+#         repr_str += f"imdecode_backend='{self.imdecode_backend}', "
+#         repr_str += f'backend_args={self.backend_args})'
+#         return repr_str
\ No newline at end of file

From f8890aaa13d4d2a01ea6455f0e257d2b02c0683f Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Wed, 20 Nov 2024 22:10:38 +0900
Subject: [PATCH 037/106] [Feature] : add sam2 unet base

---
 sam2_unet/SAM2UNet.py                         | 181 ++++
 sam2_unet/config.yaml                         |  47 +
 sam2_unet/sam2/__init__.py                    |   9 +
 sam2_unet/sam2/build_sam.py                   |  89 ++
 sam2_unet/sam2/modeling/__init__.py           |   5 +
 sam2_unet/sam2/modeling/backbones/__init__.py |   5 +
 sam2_unet/sam2/modeling/backbones/hieradet.py | 295 +++++++
 .../sam2/modeling/backbones/image_encoder.py  | 133 +++
 sam2_unet/sam2/modeling/backbones/utils.py    |  95 ++
 sam2_unet/sam2/modeling/memory_attention.py   | 169 ++++
 sam2_unet/sam2/modeling/memory_encoder.py     | 181 ++++
 sam2_unet/sam2/modeling/position_encoding.py  | 216 +++++
 sam2_unet/sam2/modeling/sam/__init__.py       |   5 +
 sam2_unet/sam2/modeling/sam/mask_decoder.py   | 295 +++++++
 sam2_unet/sam2/modeling/sam/prompt_encoder.py | 182 ++++
 sam2_unet/sam2/modeling/sam/transformer.py    | 332 +++++++
 sam2_unet/sam2/modeling/sam2_base.py          | 829 ++++++++++++++++++
 sam2_unet/sam2/modeling/sam2_utils.py         | 149 ++++
 sam2_unet/sam2/utils/__init__.py              |   5 +
 sam2_unet/sam2/utils/amg.py                   | 348 ++++++++
 sam2_unet/sam2/utils/misc.py                  | 238 +++++
 sam2_unet/sam2/utils/transforms.py            |  99 +++
 sam2_unet/sam2_configs/__init__.py            |   5 +
 sam2_unet/sam2_configs/sam2_hiera_b+.yaml     | 113 +++
 sam2_unet/sam2_configs/sam2_hiera_l.yaml      | 117 +++
 sam2_unet/sam2_configs/sam2_hiera_s.yaml      | 116 +++
 sam2_unet/sam2_configs/sam2_hiera_t.yaml      | 118 +++
 sam2_unet/test.py                             | 139 +++
 sam2_unet/test.sh                             |   6 +
 sam2_unet/train.py                            |  77 ++
 sam2_unet/train.sh                            |   9 +
 sam2_unet/train_v1.py                         |  97 ++
 sam2_unet/trainer.py                          | 180 ++++
 sam2_unet/utils/checkpoint.py                 |  21 +
 sam2_unet/utils/dataset.py                    | 224 +++++
 sam2_unet/utils/loss.py                       |  12 +
 sam2_unet/utils/optimizer.py                  |  26 +
 sam2_unet/utils/scheduler.py                  |  17 +
 sam2_unet/utils/wandb_logger.py               |  82 ++
 39 files changed, 5266 insertions(+)
 create mode 100644 sam2_unet/SAM2UNet.py
 create mode 100644 sam2_unet/config.yaml
 create mode 100644 sam2_unet/sam2/__init__.py
 create mode 100644 sam2_unet/sam2/build_sam.py
 create mode 100644 sam2_unet/sam2/modeling/__init__.py
 create mode 100644 sam2_unet/sam2/modeling/backbones/__init__.py
 create mode 100644 sam2_unet/sam2/modeling/backbones/hieradet.py
 create mode 100644 sam2_unet/sam2/modeling/backbones/image_encoder.py
 create mode 100644 sam2_unet/sam2/modeling/backbones/utils.py
 create mode 100644 sam2_unet/sam2/modeling/memory_attention.py
 create mode 100644 sam2_unet/sam2/modeling/memory_encoder.py
 create mode 100644 sam2_unet/sam2/modeling/position_encoding.py
 create mode 100644 sam2_unet/sam2/modeling/sam/__init__.py
 create mode 100644 sam2_unet/sam2/modeling/sam/mask_decoder.py
 create mode 100644 sam2_unet/sam2/modeling/sam/prompt_encoder.py
 create mode 100644 sam2_unet/sam2/modeling/sam/transformer.py
 create mode 100644 sam2_unet/sam2/modeling/sam2_base.py
 create mode 100644 sam2_unet/sam2/modeling/sam2_utils.py
 create mode 100644 sam2_unet/sam2/utils/__init__.py
 create mode 100644 sam2_unet/sam2/utils/amg.py
 create mode 100644 sam2_unet/sam2/utils/misc.py
 create mode 100644 sam2_unet/sam2/utils/transforms.py
 create mode 100644 sam2_unet/sam2_configs/__init__.py
 create mode 100644 sam2_unet/sam2_configs/sam2_hiera_b+.yaml
 create mode 100644 sam2_unet/sam2_configs/sam2_hiera_l.yaml
 create mode 100644 sam2_unet/sam2_configs/sam2_hiera_s.yaml
 create mode 100644 sam2_unet/sam2_configs/sam2_hiera_t.yaml
 create mode 100644 sam2_unet/test.py
 create mode 100644 sam2_unet/test.sh
 create mode 100644 sam2_unet/train.py
 create mode 100644 sam2_unet/train.sh
 create mode 100644 sam2_unet/train_v1.py
 create mode 100644 sam2_unet/trainer.py
 create mode 100644 sam2_unet/utils/checkpoint.py
 create mode 100644 sam2_unet/utils/dataset.py
 create mode 100644 sam2_unet/utils/loss.py
 create mode 100644 sam2_unet/utils/optimizer.py
 create mode 100644 sam2_unet/utils/scheduler.py
 create mode 100644 sam2_unet/utils/wandb_logger.py

diff --git a/sam2_unet/SAM2UNet.py b/sam2_unet/SAM2UNet.py
new file mode 100644
index 0000000..426b553
--- /dev/null
+++ b/sam2_unet/SAM2UNet.py
@@ -0,0 +1,181 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from sam2.build_sam import build_sam2
+
+
+class DoubleConv(nn.Module):
+    """(convolution => [BN] => ReLU) * 2"""
+
+    def __init__(self, in_channels, out_channels, mid_channels=None):
+        super().__init__()
+        if not mid_channels:
+            mid_channels = out_channels
+        self.double_conv = nn.Sequential(
+            nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(mid_channels),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(out_channels),
+            nn.ReLU(inplace=True)
+        )
+
+    def forward(self, x):
+        return self.double_conv(x)
+    
+    
+class Up(nn.Module):
+    """Upscaling then double conv"""
+
+    def __init__(self, in_channels, out_channels):
+        super().__init__()
+
+        self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
+        self.conv = DoubleConv(in_channels, out_channels, in_channels // 2)
+
+    def forward(self, x1, x2):
+        x1 = self.up(x1)
+        # input is CHW
+        diffY = x2.size()[2] - x1.size()[2]
+        diffX = x2.size()[3] - x1.size()[3]
+
+        x1 = F.pad(x1, [diffX // 2, diffX - diffX // 2,
+                        diffY // 2, diffY - diffY // 2])
+        # if you have padding issues, see
+        # https://github.com/HaiyongJiang/U-Net-Pytorch-Unstructured-Buggy/commit/0e854509c2cea854e247a9c615f175f76fbb2e3a
+        # https://github.com/xiaopeng-liao/Pytorch-UNet/commit/8ebac70e633bac59fc22bb5195e513d5832fb3bd
+        x = torch.cat([x2, x1], dim=1)
+        return self.conv(x)
+
+
+class Adapter(nn.Module):
+    def __init__(self, blk) -> None:
+        super(Adapter, self).__init__()
+        self.block = blk
+        dim = blk.attn.qkv.in_features
+        self.prompt_learn = nn.Sequential(
+            nn.Linear(dim, 32),
+            nn.GELU(),
+            nn.Linear(32, dim),
+            nn.GELU()
+        )
+
+    def forward(self, x):
+        prompt = self.prompt_learn(x)
+        promped = x + prompt
+        net = self.block(promped)
+        return net
+    
+
+class BasicConv2d(nn.Module):
+    def __init__(self, in_planes, out_planes, kernel_size, stride=1, padding=0, dilation=1):
+        super(BasicConv2d, self).__init__()
+        self.conv = nn.Conv2d(in_planes, out_planes,
+                              kernel_size=kernel_size, stride=stride,
+                              padding=padding, dilation=dilation, bias=False)
+        self.bn = nn.BatchNorm2d(out_planes)
+        self.relu = nn.ReLU(inplace=True)
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.bn(x)
+        return x
+    
+
+class RFB_modified(nn.Module):
+    def __init__(self, in_channel, out_channel):
+        super(RFB_modified, self).__init__()
+        self.relu = nn.ReLU(True)
+        self.branch0 = nn.Sequential(
+            BasicConv2d(in_channel, out_channel, 1),
+        )
+        self.branch1 = nn.Sequential(
+            BasicConv2d(in_channel, out_channel, 1),
+            BasicConv2d(out_channel, out_channel, kernel_size=(1, 3), padding=(0, 1)),
+            BasicConv2d(out_channel, out_channel, kernel_size=(3, 1), padding=(1, 0)),
+            BasicConv2d(out_channel, out_channel, 3, padding=3, dilation=3)
+        )
+        self.branch2 = nn.Sequential(
+            BasicConv2d(in_channel, out_channel, 1),
+            BasicConv2d(out_channel, out_channel, kernel_size=(1, 5), padding=(0, 2)),
+            BasicConv2d(out_channel, out_channel, kernel_size=(5, 1), padding=(2, 0)),
+            BasicConv2d(out_channel, out_channel, 3, padding=5, dilation=5)
+        )
+        self.branch3 = nn.Sequential(
+            BasicConv2d(in_channel, out_channel, 1),
+            BasicConv2d(out_channel, out_channel, kernel_size=(1, 7), padding=(0, 3)),
+            BasicConv2d(out_channel, out_channel, kernel_size=(7, 1), padding=(3, 0)),
+            BasicConv2d(out_channel, out_channel, 3, padding=7, dilation=7)
+        )
+        self.conv_cat = BasicConv2d(4*out_channel, out_channel, 3, padding=1)
+        self.conv_res = BasicConv2d(in_channel, out_channel, 1)
+
+    def forward(self, x):
+        x0 = self.branch0(x)
+        x1 = self.branch1(x)
+        x2 = self.branch2(x)
+        x3 = self.branch3(x)
+        x_cat = self.conv_cat(torch.cat((x0, x1, x2, x3), 1))
+
+        x = self.relu(x_cat + self.conv_res(x))
+        return x
+
+
+class SAM2UNet(nn.Module):
+    def __init__(self, checkpoint_path=None) -> None:
+        super(SAM2UNet, self).__init__()    
+        model_cfg = "sam2_hiera_l.yaml"
+        if checkpoint_path:
+            model = build_sam2(model_cfg, checkpoint_path)
+        else:
+            model = build_sam2(model_cfg)
+        del model.sam_mask_decoder
+        del model.sam_prompt_encoder
+        del model.memory_encoder
+        del model.memory_attention
+        del model.mask_downsample
+        del model.obj_ptr_tpos_proj
+        del model.obj_ptr_proj
+        del model.image_encoder.neck
+        self.encoder = model.image_encoder.trunk
+
+        for param in self.encoder.parameters():
+            param.requires_grad = False
+        blocks = []
+        for block in self.encoder.blocks:
+            blocks.append(
+                Adapter(block)
+            )
+        self.encoder.blocks = nn.Sequential(
+            *blocks
+        )
+        self.rfb1 = RFB_modified(144, 64)
+        self.rfb2 = RFB_modified(288, 64)
+        self.rfb3 = RFB_modified(576, 64)
+        self.rfb4 = RFB_modified(1152, 64)
+        self.up1 = (Up(128, 64))
+        self.up2 = (Up(128, 64))
+        self.up3 = (Up(128, 64))
+        self.up4 = (Up(128, 64))
+        self.side1 = nn.Conv2d(64, 29, kernel_size=1)
+        self.side2 = nn.Conv2d(64, 29, kernel_size=1)
+        self.head = nn.Conv2d(64, 29, kernel_size=1)
+
+    def forward(self, x):
+        x1, x2, x3, x4 = self.encoder(x)
+        x1, x2, x3, x4 = self.rfb1(x1), self.rfb2(x2), self.rfb3(x3), self.rfb4(x4)
+        x = self.up1(x4, x3)
+        out1 = F.interpolate(self.side1(x), scale_factor=16, mode='bilinear')
+        x = self.up2(x, x2)
+        out2 = F.interpolate(self.side2(x), scale_factor=8, mode='bilinear')
+        x = self.up3(x, x1)
+        out = F.interpolate(self.head(x), scale_factor=4, mode='bilinear')
+        return out, out1, out2
+
+
+if __name__ == "__main__":
+    with torch.no_grad():
+        model = SAM2UNet().cuda()
+        x = torch.randn(1, 3, 352, 352).cuda()
+        out, out1, out2 = model(x)
+        print(out.shape, out1.shape, out2.shape)
\ No newline at end of file
diff --git a/sam2_unet/config.yaml b/sam2_unet/config.yaml
new file mode 100644
index 0000000..f80eef5
--- /dev/null
+++ b/sam2_unet/config.yaml
@@ -0,0 +1,47 @@
+# paths
+train_image_path: /data/ephemeral/home/data/train/DCM
+train_mask_path: /data/ephemeral/home/data/train/outputs_json
+test_image_path: /data/ephemeral/home/data/test/DCM
+hiera_path: /data/ephemeral/home/sam2_hiera_large.pt
+
+# train
+train_batch_size: 8
+train_num_workers: 8
+
+# valid
+valid_batch_size: 2
+valid_num_workers: 2
+kfold: 0
+val_every: 1
+threshold: 0.5
+
+# hyperparameter
+lr: 1e-3
+max_epoch: 30
+
+# optimizer
+optimizer: adamw
+optimizer_parameters:
+  weight_decay: 0.01
+  betas: [0.9, 0.999]
+
+# scheduler
+scheduler: multisteplr
+scheduler_paramters:
+  milestones: [8, 16]
+  gamma: 0.1
+
+# random seed 
+random_seed: 2024
+
+# augmentation
+size: 512
+
+# wandb
+wandb_name: 
+wandb_id: 
+
+# resume
+resume: False
+ckpt_path: ./checkpoints/
+start_epoch: 0
\ No newline at end of file
diff --git a/sam2_unet/sam2/__init__.py b/sam2_unet/sam2/__init__.py
new file mode 100644
index 0000000..ff90d10
--- /dev/null
+++ b/sam2_unet/sam2/__init__.py
@@ -0,0 +1,9 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+from hydra import initialize_config_module
+
+initialize_config_module("sam2_configs", version_base="1.2")
diff --git a/sam2_unet/sam2/build_sam.py b/sam2_unet/sam2/build_sam.py
new file mode 100644
index 0000000..39defc4
--- /dev/null
+++ b/sam2_unet/sam2/build_sam.py
@@ -0,0 +1,89 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import logging
+
+import torch
+from hydra import compose
+from hydra.utils import instantiate
+from omegaconf import OmegaConf
+
+
+def build_sam2(
+    config_file,
+    ckpt_path=None,
+    device="cuda",
+    mode="eval",
+    hydra_overrides_extra=[],
+    apply_postprocessing=True,
+):
+
+    if apply_postprocessing:
+        hydra_overrides_extra = hydra_overrides_extra.copy()
+        hydra_overrides_extra += [
+            # dynamically fall back to multi-mask if the single mask is not stable
+            "++model.sam_mask_decoder_extra_args.dynamic_multimask_via_stability=true",
+            "++model.sam_mask_decoder_extra_args.dynamic_multimask_stability_delta=0.05",
+            "++model.sam_mask_decoder_extra_args.dynamic_multimask_stability_thresh=0.98",
+        ]
+    # Read config and init model
+    cfg = compose(config_name=config_file, overrides=hydra_overrides_extra)
+    OmegaConf.resolve(cfg)
+    model = instantiate(cfg.model, _recursive_=True)
+    _load_checkpoint(model, ckpt_path)
+    model = model.to(device)
+    if mode == "eval":
+        model.eval()
+    return model
+
+
+def build_sam2_video_predictor(
+    config_file,
+    ckpt_path=None,
+    device="cuda",
+    mode="eval",
+    hydra_overrides_extra=[],
+    apply_postprocessing=True,
+):
+    hydra_overrides = [
+        "++model._target_=sam2.sam2_video_predictor.SAM2VideoPredictor",
+    ]
+    if apply_postprocessing:
+        hydra_overrides_extra = hydra_overrides_extra.copy()
+        hydra_overrides_extra += [
+            # dynamically fall back to multi-mask if the single mask is not stable
+            "++model.sam_mask_decoder_extra_args.dynamic_multimask_via_stability=true",
+            "++model.sam_mask_decoder_extra_args.dynamic_multimask_stability_delta=0.05",
+            "++model.sam_mask_decoder_extra_args.dynamic_multimask_stability_thresh=0.98",
+            # the sigmoid mask logits on interacted frames with clicks in the memory encoder so that the encoded masks are exactly as what users see from clicking
+            "++model.binarize_mask_from_pts_for_mem_enc=true",
+            # fill small holes in the low-res masks up to `fill_hole_area` (before resizing them to the original video resolution)
+            "++model.fill_hole_area=8",
+        ]
+    hydra_overrides.extend(hydra_overrides_extra)
+
+    # Read config and init model
+    cfg = compose(config_name=config_file, overrides=hydra_overrides)
+    OmegaConf.resolve(cfg)
+    model = instantiate(cfg.model, _recursive_=True)
+    _load_checkpoint(model, ckpt_path)
+    model = model.to(device)
+    if mode == "eval":
+        model.eval()
+    return model
+
+
+def _load_checkpoint(model, ckpt_path):
+    if ckpt_path is not None:
+        sd = torch.load(ckpt_path, map_location="cpu")["model"]
+        missing_keys, unexpected_keys = model.load_state_dict(sd)
+        if missing_keys:
+            logging.error(missing_keys)
+            raise RuntimeError()
+        if unexpected_keys:
+            logging.error(unexpected_keys)
+            raise RuntimeError()
+        logging.info("Loaded checkpoint sucessfully")
diff --git a/sam2_unet/sam2/modeling/__init__.py b/sam2_unet/sam2/modeling/__init__.py
new file mode 100644
index 0000000..5277f46
--- /dev/null
+++ b/sam2_unet/sam2/modeling/__init__.py
@@ -0,0 +1,5 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
diff --git a/sam2_unet/sam2/modeling/backbones/__init__.py b/sam2_unet/sam2/modeling/backbones/__init__.py
new file mode 100644
index 0000000..5277f46
--- /dev/null
+++ b/sam2_unet/sam2/modeling/backbones/__init__.py
@@ -0,0 +1,5 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
diff --git a/sam2_unet/sam2/modeling/backbones/hieradet.py b/sam2_unet/sam2/modeling/backbones/hieradet.py
new file mode 100644
index 0000000..1ae7d4c
--- /dev/null
+++ b/sam2_unet/sam2/modeling/backbones/hieradet.py
@@ -0,0 +1,295 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+from functools import partial
+from typing import List, Tuple, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from sam2.modeling.backbones.utils import (
+    PatchEmbed,
+    window_partition,
+    window_unpartition,
+)
+
+from sam2.modeling.sam2_utils import DropPath, MLP
+
+
+def do_pool(x: torch.Tensor, pool: nn.Module, norm: nn.Module = None) -> torch.Tensor:
+    if pool is None:
+        return x
+    # (B, H, W, C) -> (B, C, H, W)
+    x = x.permute(0, 3, 1, 2)
+    x = pool(x)
+    # (B, C, H', W') -> (B, H', W', C)
+    x = x.permute(0, 2, 3, 1)
+    if norm:
+        x = norm(x)
+
+    return x
+
+
+class MultiScaleAttention(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        dim_out: int,
+        num_heads: int,
+        q_pool: nn.Module = None,
+    ):
+        super().__init__()
+
+        self.dim = dim
+        self.dim_out = dim_out
+
+        self.num_heads = num_heads
+        head_dim = dim_out // num_heads
+        self.scale = head_dim**-0.5
+
+        self.q_pool = q_pool
+        self.qkv = nn.Linear(dim, dim_out * 3)
+        self.proj = nn.Linear(dim_out, dim_out)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        B, H, W, _ = x.shape
+        # qkv with shape (B, H * W, 3, nHead, C)
+        qkv = self.qkv(x).reshape(B, H * W, 3, self.num_heads, -1)
+        # q, k, v with shape (B, H * W, nheads, C)
+        q, k, v = torch.unbind(qkv, 2)
+
+        # Q pooling (for downsample at stage changes)
+        if self.q_pool:
+            q = do_pool(q.reshape(B, H, W, -1), self.q_pool)
+            H, W = q.shape[1:3]  # downsampled shape
+            q = q.reshape(B, H * W, self.num_heads, -1)
+
+        # Torch's SDPA expects [B, nheads, H*W, C] so we transpose
+        x = F.scaled_dot_product_attention(
+            q.transpose(1, 2),
+            k.transpose(1, 2),
+            v.transpose(1, 2),
+        )
+        # Transpose back
+        x = x.transpose(1, 2)
+        x = x.reshape(B, H, W, -1)
+
+        x = self.proj(x)
+
+        return x
+
+
+class MultiScaleBlock(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        dim_out: int,
+        num_heads: int,
+        mlp_ratio: float = 4.0,
+        drop_path: float = 0.0,
+        norm_layer: Union[nn.Module, str] = "LayerNorm",
+        q_stride: Tuple[int, int] = None,
+        act_layer: nn.Module = nn.GELU,
+        window_size: int = 0,
+    ):
+        super().__init__()
+
+        if isinstance(norm_layer, str):
+            norm_layer = partial(getattr(nn, norm_layer), eps=1e-6)
+
+        self.dim = dim
+        self.dim_out = dim_out
+        self.norm1 = norm_layer(dim)
+
+        self.window_size = window_size
+
+        self.pool, self.q_stride = None, q_stride
+        if self.q_stride:
+            self.pool = nn.MaxPool2d(
+                kernel_size=q_stride, stride=q_stride, ceil_mode=False
+            )
+
+        self.attn = MultiScaleAttention(
+            dim,
+            dim_out,
+            num_heads=num_heads,
+            q_pool=self.pool,
+        )
+        self.drop_path = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
+
+        self.norm2 = norm_layer(dim_out)
+        self.mlp = MLP(
+            dim_out,
+            int(dim_out * mlp_ratio),
+            dim_out,
+            num_layers=2,
+            activation=act_layer,
+        )
+
+        if dim != dim_out:
+            self.proj = nn.Linear(dim, dim_out)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        shortcut = x  # B, H, W, C
+        x = self.norm1(x)
+
+        # Skip connection
+        if self.dim != self.dim_out:
+            shortcut = do_pool(self.proj(x), self.pool)
+
+        # Window partition
+        window_size = self.window_size
+        if window_size > 0:
+            H, W = x.shape[1], x.shape[2]
+            x, pad_hw = window_partition(x, window_size)
+
+        # Window Attention + Q Pooling (if stage change)
+        x = self.attn(x)
+        if self.q_stride:
+            # Shapes have changed due to Q pooling
+            window_size = self.window_size // self.q_stride[0]
+            H, W = shortcut.shape[1:3]
+
+            pad_h = (window_size - H % window_size) % window_size
+            pad_w = (window_size - W % window_size) % window_size
+            pad_hw = (H + pad_h, W + pad_w)
+
+        # Reverse window partition
+        if self.window_size > 0:
+            x = window_unpartition(x, window_size, pad_hw, (H, W))
+
+        x = shortcut + self.drop_path(x)
+        # MLP
+        x = x + self.drop_path(self.mlp(self.norm2(x)))
+        return x
+
+
+class Hiera(nn.Module):
+    """
+    Reference: https://arxiv.org/abs/2306.00989
+    """
+
+    def __init__(
+        self,
+        embed_dim: int = 96,  # initial embed dim
+        num_heads: int = 1,  # initial number of heads
+        drop_path_rate: float = 0.0,  # stochastic depth
+        q_pool: int = 3,  # number of q_pool stages
+        q_stride: Tuple[int, int] = (2, 2),  # downsample stride bet. stages
+        stages: Tuple[int, ...] = (2, 3, 16, 3),  # blocks per stage
+        dim_mul: float = 2.0,  # dim_mul factor at stage shift
+        head_mul: float = 2.0,  # head_mul factor at stage shift
+        window_pos_embed_bkg_spatial_size: Tuple[int, int] = (14, 14),
+        # window size per stage, when not using global att.
+        window_spec: Tuple[int, ...] = (
+            8,
+            4,
+            14,
+            7,
+        ),
+        # global attn in these blocks
+        global_att_blocks: Tuple[int, ...] = (
+            12,
+            16,
+            20,
+        ),
+        return_interm_layers=True,  # return feats from every stage
+    ):
+        super().__init__()
+
+        assert len(stages) == len(window_spec)
+        self.window_spec = window_spec
+
+        depth = sum(stages)
+        self.q_stride = q_stride
+        self.stage_ends = [sum(stages[:i]) - 1 for i in range(1, len(stages) + 1)]
+        assert 0 <= q_pool <= len(self.stage_ends[:-1])
+        self.q_pool_blocks = [x + 1 for x in self.stage_ends[:-1]][:q_pool]
+        self.return_interm_layers = return_interm_layers
+
+        self.patch_embed = PatchEmbed(
+            embed_dim=embed_dim,
+        )
+        # Which blocks have global att?
+        self.global_att_blocks = global_att_blocks
+
+        # Windowed positional embedding (https://arxiv.org/abs/2311.05613)
+        self.window_pos_embed_bkg_spatial_size = window_pos_embed_bkg_spatial_size
+        self.pos_embed = nn.Parameter(
+            torch.zeros(1, embed_dim, *self.window_pos_embed_bkg_spatial_size)
+        )
+        self.pos_embed_window = nn.Parameter(
+            torch.zeros(1, embed_dim, self.window_spec[0], self.window_spec[0])
+        )
+
+        dpr = [
+            x.item() for x in torch.linspace(0, drop_path_rate, depth)
+        ]  # stochastic depth decay rule
+
+        cur_stage = 1
+        self.blocks = nn.ModuleList()
+
+        for i in range(depth):
+            dim_out = embed_dim
+            # lags by a block, so first block of
+            # next stage uses an initial window size
+            # of previous stage and final window size of current stage
+            window_size = self.window_spec[cur_stage - 1]
+
+            if self.global_att_blocks is not None:
+                window_size = 0 if i in self.global_att_blocks else window_size
+
+            if i - 1 in self.stage_ends:
+                dim_out = int(embed_dim * dim_mul)
+                num_heads = int(num_heads * head_mul)
+                cur_stage += 1
+
+            block = MultiScaleBlock(
+                dim=embed_dim,
+                dim_out=dim_out,
+                num_heads=num_heads,
+                drop_path=dpr[i],
+                q_stride=self.q_stride if i in self.q_pool_blocks else None,
+                window_size=window_size,
+            )
+
+            embed_dim = dim_out
+            self.blocks.append(block)
+
+        self.channel_list = (
+            [self.blocks[i].dim_out for i in self.stage_ends[::-1]]
+            if return_interm_layers
+            else [self.blocks[-1].dim_out]
+        )
+
+    def _get_pos_embed(self, hw: Tuple[int, int]) -> torch.Tensor:
+        h, w = hw
+        window_embed = self.pos_embed_window
+        pos_embed = F.interpolate(self.pos_embed, size=(h, w), mode="bicubic")
+        pos_embed = pos_embed + window_embed.tile(
+            [x // y for x, y in zip(pos_embed.shape, window_embed.shape)]
+        )
+        pos_embed = pos_embed.permute(0, 2, 3, 1)
+        return pos_embed
+
+    def forward(self, x: torch.Tensor) -> List[torch.Tensor]:
+        x = self.patch_embed(x)
+        # x: (B, H, W, C)
+
+        # Add pos embed
+        x = x + self._get_pos_embed(x.shape[1:3])
+
+        outputs = []
+        for i, blk in enumerate(self.blocks):
+            x = blk(x)
+            if (i == self.stage_ends[-1]) or (
+                i in self.stage_ends and self.return_interm_layers
+            ):
+                feats = x.permute(0, 3, 1, 2)
+                outputs.append(feats)
+
+        return outputs
diff --git a/sam2_unet/sam2/modeling/backbones/image_encoder.py b/sam2_unet/sam2/modeling/backbones/image_encoder.py
new file mode 100644
index 0000000..5f92baf
--- /dev/null
+++ b/sam2_unet/sam2/modeling/backbones/image_encoder.py
@@ -0,0 +1,133 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+from typing import List, Optional
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class ImageEncoder(nn.Module):
+    def __init__(
+        self,
+        trunk: nn.Module,
+        neck: nn.Module,
+        scalp: int = 0,
+    ):
+        super().__init__()
+        self.trunk = trunk
+        self.neck = neck
+        self.scalp = scalp
+        assert (
+            self.trunk.channel_list == self.neck.backbone_channel_list
+        ), f"Channel dims of trunk and neck do not match. Trunk: {self.trunk.channel_list}, neck: {self.neck.backbone_channel_list}"
+
+    def forward(self, sample: torch.Tensor):
+        # Forward through backbone
+        features, pos = self.neck(self.trunk(sample))
+        if self.scalp > 0:
+            # Discard the lowest resolution features
+            features, pos = features[: -self.scalp], pos[: -self.scalp]
+
+        src = features[-1]
+        output = {
+            "vision_features": src,
+            "vision_pos_enc": pos,
+            "backbone_fpn": features,
+        }
+        return output
+
+
+class FpnNeck(nn.Module):
+    """
+    A modified variant of Feature Pyramid Network (FPN) neck
+    (we remove output conv and also do bicubic interpolation similar to ViT
+    pos embed interpolation)
+    """
+
+    def __init__(
+        self,
+        position_encoding: nn.Module,
+        d_model: int,
+        backbone_channel_list: List[int],
+        kernel_size: int = 1,
+        stride: int = 1,
+        padding: int = 0,
+        fpn_interp_model: str = "bilinear",
+        fuse_type: str = "sum",
+        fpn_top_down_levels: Optional[List[int]] = None,
+    ):
+        """Initialize the neck
+        :param trunk: the backbone
+        :param position_encoding: the positional encoding to use
+        :param d_model: the dimension of the model
+        :param neck_norm: the normalization to use
+        """
+        super().__init__()
+        self.position_encoding = position_encoding
+        self.convs = nn.ModuleList()
+        self.backbone_channel_list = backbone_channel_list
+        for dim in backbone_channel_list:
+            current = nn.Sequential()
+            current.add_module(
+                "conv",
+                nn.Conv2d(
+                    in_channels=dim,
+                    out_channels=d_model,
+                    kernel_size=kernel_size,
+                    stride=stride,
+                    padding=padding,
+                ),
+            )
+
+            self.convs.append(current)
+        self.fpn_interp_model = fpn_interp_model
+        assert fuse_type in ["sum", "avg"]
+        self.fuse_type = fuse_type
+
+        # levels to have top-down features in its outputs
+        # e.g. if fpn_top_down_levels is [2, 3], then only outputs of level 2 and 3
+        # have top-down propagation, while outputs of level 0 and level 1 have only
+        # lateral features from the same backbone level.
+        if fpn_top_down_levels is None:
+            # default is to have top-down features on all levels
+            fpn_top_down_levels = range(len(self.convs))
+        self.fpn_top_down_levels = list(fpn_top_down_levels)
+
+    def forward(self, xs: List[torch.Tensor]):
+
+        out = [None] * len(self.convs)
+        pos = [None] * len(self.convs)
+        assert len(xs) == len(self.convs)
+        # fpn forward pass
+        # see https://github.com/facebookresearch/detectron2/blob/main/detectron2/modeling/backbone/fpn.py
+        prev_features = None
+        # forward in top-down order (from low to high resolution)
+        n = len(self.convs) - 1
+        for i in range(n, -1, -1):
+            x = xs[i]
+            lateral_features = self.convs[n - i](x)
+            if i in self.fpn_top_down_levels and prev_features is not None:
+                top_down_features = F.interpolate(
+                    prev_features.to(dtype=torch.float32),
+                    scale_factor=2.0,
+                    mode=self.fpn_interp_model,
+                    align_corners=(
+                        None if self.fpn_interp_model == "nearest" else False
+                    ),
+                    antialias=False,
+                )
+                prev_features = lateral_features + top_down_features
+                if self.fuse_type == "avg":
+                    prev_features /= 2
+            else:
+                prev_features = lateral_features
+            x_out = prev_features
+            out[i] = x_out
+            pos[i] = self.position_encoding(x_out).to(x_out.dtype)
+
+        return out, pos
diff --git a/sam2_unet/sam2/modeling/backbones/utils.py b/sam2_unet/sam2/modeling/backbones/utils.py
new file mode 100644
index 0000000..32d55c7
--- /dev/null
+++ b/sam2_unet/sam2/modeling/backbones/utils.py
@@ -0,0 +1,95 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Some utilities for backbones, in particular for windowing"""
+
+from typing import Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+def window_partition(x, window_size):
+    """
+    Partition into non-overlapping windows with padding if needed.
+    Args:
+        x (tensor): input tokens with [B, H, W, C].
+        window_size (int): window size.
+    Returns:
+        windows: windows after partition with [B * num_windows, window_size, window_size, C].
+        (Hp, Wp): padded height and width before partition
+    """
+    B, H, W, C = x.shape
+
+    pad_h = (window_size - H % window_size) % window_size
+    pad_w = (window_size - W % window_size) % window_size
+    if pad_h > 0 or pad_w > 0:
+        x = F.pad(x, (0, 0, 0, pad_w, 0, pad_h))
+    Hp, Wp = H + pad_h, W + pad_w
+
+    x = x.view(B, Hp // window_size, window_size, Wp // window_size, window_size, C)
+    windows = (
+        x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)
+    )
+    return windows, (Hp, Wp)
+
+
+def window_unpartition(windows, window_size, pad_hw, hw):
+    """
+    Window unpartition into original sequences and removing padding.
+    Args:
+        x (tensor): input tokens with [B * num_windows, window_size, window_size, C].
+        window_size (int): window size.
+        pad_hw (Tuple): padded height and width (Hp, Wp).
+        hw (Tuple): original height and width (H, W) before padding.
+    Returns:
+        x: unpartitioned sequences with [B, H, W, C].
+    """
+    Hp, Wp = pad_hw
+    H, W = hw
+    B = windows.shape[0] // (Hp * Wp // window_size // window_size)
+    x = windows.view(
+        B, Hp // window_size, Wp // window_size, window_size, window_size, -1
+    )
+    x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, Hp, Wp, -1)
+
+    if Hp > H or Wp > W:
+        x = x[:, :H, :W, :].contiguous()
+    return x
+
+
+class PatchEmbed(nn.Module):
+    """
+    Image to Patch Embedding.
+    """
+
+    def __init__(
+        self,
+        kernel_size: Tuple[int, ...] = (7, 7),
+        stride: Tuple[int, ...] = (4, 4),
+        padding: Tuple[int, ...] = (3, 3),
+        in_chans: int = 3,
+        embed_dim: int = 768,
+    ):
+        """
+        Args:
+            kernel_size (Tuple): kernel size of the projection layer.
+            stride (Tuple): stride of the projection layer.
+            padding (Tuple): padding size of the projection layer.
+            in_chans (int): Number of input image channels.
+            embed_dim (int):  embed_dim (int): Patch embedding dimension.
+        """
+        super().__init__()
+        self.proj = nn.Conv2d(
+            in_chans, embed_dim, kernel_size=kernel_size, stride=stride, padding=padding
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.proj(x)
+        # B C H W -> B H W C
+        x = x.permute(0, 2, 3, 1)
+        return x
diff --git a/sam2_unet/sam2/modeling/memory_attention.py b/sam2_unet/sam2/modeling/memory_attention.py
new file mode 100644
index 0000000..0b07f9d
--- /dev/null
+++ b/sam2_unet/sam2/modeling/memory_attention.py
@@ -0,0 +1,169 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+from typing import Optional
+
+import torch
+from torch import nn, Tensor
+
+from sam2.modeling.sam.transformer import RoPEAttention
+
+from sam2.modeling.sam2_utils import get_activation_fn, get_clones
+
+
+class MemoryAttentionLayer(nn.Module):
+
+    def __init__(
+        self,
+        activation: str,
+        cross_attention: nn.Module,
+        d_model: int,
+        dim_feedforward: int,
+        dropout: float,
+        pos_enc_at_attn: bool,
+        pos_enc_at_cross_attn_keys: bool,
+        pos_enc_at_cross_attn_queries: bool,
+        self_attention: nn.Module,
+    ):
+        super().__init__()
+        self.d_model = d_model
+        self.dim_feedforward = dim_feedforward
+        self.dropout_value = dropout
+        self.self_attn = self_attention
+        self.cross_attn_image = cross_attention
+
+        # Implementation of Feedforward model
+        self.linear1 = nn.Linear(d_model, dim_feedforward)
+        self.dropout = nn.Dropout(dropout)
+        self.linear2 = nn.Linear(dim_feedforward, d_model)
+
+        self.norm1 = nn.LayerNorm(d_model)
+        self.norm2 = nn.LayerNorm(d_model)
+        self.norm3 = nn.LayerNorm(d_model)
+        self.dropout1 = nn.Dropout(dropout)
+        self.dropout2 = nn.Dropout(dropout)
+        self.dropout3 = nn.Dropout(dropout)
+
+        self.activation_str = activation
+        self.activation = get_activation_fn(activation)
+
+        # Where to add pos enc
+        self.pos_enc_at_attn = pos_enc_at_attn
+        self.pos_enc_at_cross_attn_queries = pos_enc_at_cross_attn_queries
+        self.pos_enc_at_cross_attn_keys = pos_enc_at_cross_attn_keys
+
+    def _forward_sa(self, tgt, query_pos):
+        # Self-Attention
+        tgt2 = self.norm1(tgt)
+        q = k = tgt2 + query_pos if self.pos_enc_at_attn else tgt2
+        tgt2 = self.self_attn(q, k, v=tgt2)
+        tgt = tgt + self.dropout1(tgt2)
+        return tgt
+
+    def _forward_ca(self, tgt, memory, query_pos, pos, num_k_exclude_rope=0):
+        kwds = {}
+        if num_k_exclude_rope > 0:
+            assert isinstance(self.cross_attn_image, RoPEAttention)
+            kwds = {"num_k_exclude_rope": num_k_exclude_rope}
+
+        # Cross-Attention
+        tgt2 = self.norm2(tgt)
+        tgt2 = self.cross_attn_image(
+            q=tgt2 + query_pos if self.pos_enc_at_cross_attn_queries else tgt2,
+            k=memory + pos if self.pos_enc_at_cross_attn_keys else memory,
+            v=memory,
+            **kwds,
+        )
+        tgt = tgt + self.dropout2(tgt2)
+        return tgt
+
+    def forward(
+        self,
+        tgt,
+        memory,
+        pos: Optional[Tensor] = None,
+        query_pos: Optional[Tensor] = None,
+        num_k_exclude_rope: int = 0,
+    ) -> torch.Tensor:
+
+        # Self-Attn, Cross-Attn
+        tgt = self._forward_sa(tgt, query_pos)
+        tgt = self._forward_ca(tgt, memory, query_pos, pos, num_k_exclude_rope)
+        # MLP
+        tgt2 = self.norm3(tgt)
+        tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt2))))
+        tgt = tgt + self.dropout3(tgt2)
+        return tgt
+
+
+class MemoryAttention(nn.Module):
+    def __init__(
+        self,
+        d_model: int,
+        pos_enc_at_input: bool,
+        layer: nn.Module,
+        num_layers: int,
+        batch_first: bool = True,  # Do layers expect batch first input?
+    ):
+        super().__init__()
+        self.d_model = d_model
+        self.layers = get_clones(layer, num_layers)
+        self.num_layers = num_layers
+        self.norm = nn.LayerNorm(d_model)
+        self.pos_enc_at_input = pos_enc_at_input
+        self.batch_first = batch_first
+
+    def forward(
+        self,
+        curr: torch.Tensor,  # self-attention inputs
+        memory: torch.Tensor,  # cross-attention inputs
+        curr_pos: Optional[Tensor] = None,  # pos_enc for self-attention inputs
+        memory_pos: Optional[Tensor] = None,  # pos_enc for cross-attention inputs
+        num_obj_ptr_tokens: int = 0,  # number of object pointer *tokens*
+    ):
+        if isinstance(curr, list):
+            assert isinstance(curr_pos, list)
+            assert len(curr) == len(curr_pos) == 1
+            curr, curr_pos = (
+                curr[0],
+                curr_pos[0],
+            )
+
+        assert (
+            curr.shape[1] == memory.shape[1]
+        ), "Batch size must be the same for curr and memory"
+
+        output = curr
+        if self.pos_enc_at_input and curr_pos is not None:
+            output = output + 0.1 * curr_pos
+
+        if self.batch_first:
+            # Convert to batch first
+            output = output.transpose(0, 1)
+            curr_pos = curr_pos.transpose(0, 1)
+            memory = memory.transpose(0, 1)
+            memory_pos = memory_pos.transpose(0, 1)
+
+        for layer in self.layers:
+            kwds = {}
+            if isinstance(layer.cross_attn_image, RoPEAttention):
+                kwds = {"num_k_exclude_rope": num_obj_ptr_tokens}
+
+            output = layer(
+                tgt=output,
+                memory=memory,
+                pos=memory_pos,
+                query_pos=curr_pos,
+                **kwds,
+            )
+        normed_output = self.norm(output)
+
+        if self.batch_first:
+            # Convert back to seq first
+            normed_output = normed_output.transpose(0, 1)
+            curr_pos = curr_pos.transpose(0, 1)
+
+        return normed_output
diff --git a/sam2_unet/sam2/modeling/memory_encoder.py b/sam2_unet/sam2/modeling/memory_encoder.py
new file mode 100644
index 0000000..f60202d
--- /dev/null
+++ b/sam2_unet/sam2/modeling/memory_encoder.py
@@ -0,0 +1,181 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import math
+from typing import Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from sam2.modeling.sam2_utils import DropPath, get_clones, LayerNorm2d
+
+
+class MaskDownSampler(nn.Module):
+    """
+    Progressively downsample a mask by total_stride, each time by stride.
+    Note that LayerNorm is applied per *token*, like in ViT.
+
+    With each downsample (by a factor stride**2), channel capacity increases by the same factor.
+    In the end, we linearly project to embed_dim channels.
+    """
+
+    def __init__(
+        self,
+        embed_dim=256,
+        kernel_size=4,
+        stride=4,
+        padding=0,
+        total_stride=16,
+        activation=nn.GELU,
+    ):
+        super().__init__()
+        num_layers = int(math.log2(total_stride) // math.log2(stride))
+        assert stride**num_layers == total_stride
+        self.encoder = nn.Sequential()
+        mask_in_chans, mask_out_chans = 1, 1
+        for _ in range(num_layers):
+            mask_out_chans = mask_in_chans * (stride**2)
+            self.encoder.append(
+                nn.Conv2d(
+                    mask_in_chans,
+                    mask_out_chans,
+                    kernel_size=kernel_size,
+                    stride=stride,
+                    padding=padding,
+                )
+            )
+            self.encoder.append(LayerNorm2d(mask_out_chans))
+            self.encoder.append(activation())
+            mask_in_chans = mask_out_chans
+
+        self.encoder.append(nn.Conv2d(mask_out_chans, embed_dim, kernel_size=1))
+
+    def forward(self, x):
+        return self.encoder(x)
+
+
+# Lightly adapted from ConvNext (https://github.com/facebookresearch/ConvNeXt)
+class CXBlock(nn.Module):
+    r"""ConvNeXt Block. There are two equivalent implementations:
+    (1) DwConv -> LayerNorm (channels_first) -> 1x1 Conv -> GELU -> 1x1 Conv; all in (N, C, H, W)
+    (2) DwConv -> Permute to (N, H, W, C); LayerNorm (channels_last) -> Linear -> GELU -> Linear; Permute back
+    We use (2) as we find it slightly faster in PyTorch
+
+    Args:
+        dim (int): Number of input channels.
+        drop_path (float): Stochastic depth rate. Default: 0.0
+        layer_scale_init_value (float): Init value for Layer Scale. Default: 1e-6.
+    """
+
+    def __init__(
+        self,
+        dim,
+        kernel_size=7,
+        padding=3,
+        drop_path=0.0,
+        layer_scale_init_value=1e-6,
+        use_dwconv=True,
+    ):
+        super().__init__()
+        self.dwconv = nn.Conv2d(
+            dim,
+            dim,
+            kernel_size=kernel_size,
+            padding=padding,
+            groups=dim if use_dwconv else 1,
+        )  # depthwise conv
+        self.norm = LayerNorm2d(dim, eps=1e-6)
+        self.pwconv1 = nn.Linear(
+            dim, 4 * dim
+        )  # pointwise/1x1 convs, implemented with linear layers
+        self.act = nn.GELU()
+        self.pwconv2 = nn.Linear(4 * dim, dim)
+        self.gamma = (
+            nn.Parameter(layer_scale_init_value * torch.ones((dim)), requires_grad=True)
+            if layer_scale_init_value > 0
+            else None
+        )
+        self.drop_path = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
+
+    def forward(self, x):
+        input = x
+        x = self.dwconv(x)
+        x = self.norm(x)
+        x = x.permute(0, 2, 3, 1)  # (N, C, H, W) -> (N, H, W, C)
+        x = self.pwconv1(x)
+        x = self.act(x)
+        x = self.pwconv2(x)
+        if self.gamma is not None:
+            x = self.gamma * x
+        x = x.permute(0, 3, 1, 2)  # (N, H, W, C) -> (N, C, H, W)
+
+        x = input + self.drop_path(x)
+        return x
+
+
+class Fuser(nn.Module):
+    def __init__(self, layer, num_layers, dim=None, input_projection=False):
+        super().__init__()
+        self.proj = nn.Identity()
+        self.layers = get_clones(layer, num_layers)
+
+        if input_projection:
+            assert dim is not None
+            self.proj = nn.Conv2d(dim, dim, kernel_size=1)
+
+    def forward(self, x):
+        # normally x: (N, C, H, W)
+        x = self.proj(x)
+        for layer in self.layers:
+            x = layer(x)
+        return x
+
+
+class MemoryEncoder(nn.Module):
+    def __init__(
+        self,
+        out_dim,
+        mask_downsampler,
+        fuser,
+        position_encoding,
+        in_dim=256,  # in_dim of pix_feats
+    ):
+        super().__init__()
+
+        self.mask_downsampler = mask_downsampler
+
+        self.pix_feat_proj = nn.Conv2d(in_dim, in_dim, kernel_size=1)
+        self.fuser = fuser
+        self.position_encoding = position_encoding
+        self.out_proj = nn.Identity()
+        if out_dim != in_dim:
+            self.out_proj = nn.Conv2d(in_dim, out_dim, kernel_size=1)
+
+    def forward(
+        self,
+        pix_feat: torch.Tensor,
+        masks: torch.Tensor,
+        skip_mask_sigmoid: bool = False,
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        ## Process masks
+        # sigmoid, so that less domain shift from gt masks which are bool
+        if not skip_mask_sigmoid:
+            masks = F.sigmoid(masks)
+        masks = self.mask_downsampler(masks)
+
+        ## Fuse pix_feats and downsampled masks
+        # in case the visual features are on CPU, cast them to CUDA
+        pix_feat = pix_feat.to(masks.device)
+
+        x = self.pix_feat_proj(pix_feat)
+        x = x + masks
+        x = self.fuser(x)
+        x = self.out_proj(x)
+
+        pos = self.position_encoding(x).to(x.dtype)
+
+        return {"vision_features": x, "vision_pos_enc": [pos]}
diff --git a/sam2_unet/sam2/modeling/position_encoding.py b/sam2_unet/sam2/modeling/position_encoding.py
new file mode 100644
index 0000000..f4b57ae
--- /dev/null
+++ b/sam2_unet/sam2/modeling/position_encoding.py
@@ -0,0 +1,216 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import math
+from typing import Any, Optional, Tuple
+
+import numpy as np
+
+import torch
+from torch import nn
+
+
+class PositionEmbeddingSine(nn.Module):
+    """
+    This is a more standard version of the position embedding, very similar to the one
+    used by the Attention is all you need paper, generalized to work on images.
+    """
+
+    def __init__(
+        self,
+        num_pos_feats,
+        temperature: int = 10000,
+        normalize: bool = True,
+        scale: Optional[float] = None,
+    ):
+        super().__init__()
+        assert num_pos_feats % 2 == 0, "Expecting even model width"
+        self.num_pos_feats = num_pos_feats // 2
+        self.temperature = temperature
+        self.normalize = normalize
+        if scale is not None and normalize is False:
+            raise ValueError("normalize should be True if scale is passed")
+        if scale is None:
+            scale = 2 * math.pi
+        self.scale = scale
+
+        self.cache = {}
+
+    def _encode_xy(self, x, y):
+        # The positions are expected to be normalized
+        assert len(x) == len(y) and x.ndim == y.ndim == 1
+        x_embed = x * self.scale
+        y_embed = y * self.scale
+
+        dim_t = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device)
+        dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_pos_feats)
+
+        pos_x = x_embed[:, None] / dim_t
+        pos_y = y_embed[:, None] / dim_t
+        pos_x = torch.stack(
+            (pos_x[:, 0::2].sin(), pos_x[:, 1::2].cos()), dim=2
+        ).flatten(1)
+        pos_y = torch.stack(
+            (pos_y[:, 0::2].sin(), pos_y[:, 1::2].cos()), dim=2
+        ).flatten(1)
+        return pos_x, pos_y
+
+    @torch.no_grad()
+    def encode_boxes(self, x, y, w, h):
+        pos_x, pos_y = self._encode_xy(x, y)
+        pos = torch.cat((pos_y, pos_x, h[:, None], w[:, None]), dim=1)
+        return pos
+
+    encode = encode_boxes  # Backwards compatibility
+
+    @torch.no_grad()
+    def encode_points(self, x, y, labels):
+        (bx, nx), (by, ny), (bl, nl) = x.shape, y.shape, labels.shape
+        assert bx == by and nx == ny and bx == bl and nx == nl
+        pos_x, pos_y = self._encode_xy(x.flatten(), y.flatten())
+        pos_x, pos_y = pos_x.reshape(bx, nx, -1), pos_y.reshape(by, ny, -1)
+        pos = torch.cat((pos_y, pos_x, labels[:, :, None]), dim=2)
+        return pos
+
+    @torch.no_grad()
+    def forward(self, x: torch.Tensor):
+        cache_key = (x.shape[-2], x.shape[-1])
+        if cache_key in self.cache:
+            return self.cache[cache_key][None].repeat(x.shape[0], 1, 1, 1)
+        y_embed = (
+            torch.arange(1, x.shape[-2] + 1, dtype=torch.float32, device=x.device)
+            .view(1, -1, 1)
+            .repeat(x.shape[0], 1, x.shape[-1])
+        )
+        x_embed = (
+            torch.arange(1, x.shape[-1] + 1, dtype=torch.float32, device=x.device)
+            .view(1, 1, -1)
+            .repeat(x.shape[0], x.shape[-2], 1)
+        )
+
+        if self.normalize:
+            eps = 1e-6
+            y_embed = y_embed / (y_embed[:, -1:, :] + eps) * self.scale
+            x_embed = x_embed / (x_embed[:, :, -1:] + eps) * self.scale
+
+        dim_t = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device)
+        dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_pos_feats)
+
+        pos_x = x_embed[:, :, :, None] / dim_t
+        pos_y = y_embed[:, :, :, None] / dim_t
+        pos_x = torch.stack(
+            (pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4
+        ).flatten(3)
+        pos_y = torch.stack(
+            (pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4
+        ).flatten(3)
+        pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2)
+        self.cache[cache_key] = pos[0]
+        return pos
+
+
+class PositionEmbeddingRandom(nn.Module):
+    """
+    Positional encoding using random spatial frequencies.
+    """
+
+    def __init__(self, num_pos_feats: int = 64, scale: Optional[float] = None) -> None:
+        super().__init__()
+        if scale is None or scale <= 0.0:
+            scale = 1.0
+        self.register_buffer(
+            "positional_encoding_gaussian_matrix",
+            scale * torch.randn((2, num_pos_feats)),
+        )
+
+    def _pe_encoding(self, coords: torch.Tensor) -> torch.Tensor:
+        """Positionally encode points that are normalized to [0,1]."""
+        # assuming coords are in [0, 1]^2 square and have d_1 x ... x d_n x 2 shape
+        coords = 2 * coords - 1
+        coords = coords @ self.positional_encoding_gaussian_matrix
+        coords = 2 * np.pi * coords
+        # outputs d_1 x ... x d_n x C shape
+        return torch.cat([torch.sin(coords), torch.cos(coords)], dim=-1)
+
+    def forward(self, size: Tuple[int, int]) -> torch.Tensor:
+        """Generate positional encoding for a grid of the specified size."""
+        h, w = size
+        device: Any = self.positional_encoding_gaussian_matrix.device
+        grid = torch.ones((h, w), device=device, dtype=torch.float32)
+        y_embed = grid.cumsum(dim=0) - 0.5
+        x_embed = grid.cumsum(dim=1) - 0.5
+        y_embed = y_embed / h
+        x_embed = x_embed / w
+
+        pe = self._pe_encoding(torch.stack([x_embed, y_embed], dim=-1))
+        return pe.permute(2, 0, 1)  # C x H x W
+
+    def forward_with_coords(
+        self, coords_input: torch.Tensor, image_size: Tuple[int, int]
+    ) -> torch.Tensor:
+        """Positionally encode points that are not normalized to [0,1]."""
+        coords = coords_input.clone()
+        coords[:, :, 0] = coords[:, :, 0] / image_size[1]
+        coords[:, :, 1] = coords[:, :, 1] / image_size[0]
+        return self._pe_encoding(coords.to(torch.float))  # B x N x C
+
+
+# Rotary Positional Encoding, adapted from:
+# 1. https://github.com/meta-llama/codellama/blob/main/llama/model.py
+# 2. https://github.com/naver-ai/rope-vit
+# 3. https://github.com/lucidrains/rotary-embedding-torch
+
+
+def init_t_xy(end_x: int, end_y: int):
+    t = torch.arange(end_x * end_y, dtype=torch.float32)
+    t_x = (t % end_x).float()
+    t_y = torch.div(t, end_x, rounding_mode="floor").float()
+    return t_x, t_y
+
+
+def compute_axial_cis(dim: int, end_x: int, end_y: int, theta: float = 10000.0):
+    freqs_x = 1.0 / (theta ** (torch.arange(0, dim, 4)[: (dim // 4)].float() / dim))
+    freqs_y = 1.0 / (theta ** (torch.arange(0, dim, 4)[: (dim // 4)].float() / dim))
+
+    t_x, t_y = init_t_xy(end_x, end_y)
+    freqs_x = torch.outer(t_x, freqs_x)
+    freqs_y = torch.outer(t_y, freqs_y)
+    freqs_cis_x = torch.polar(torch.ones_like(freqs_x), freqs_x)
+    freqs_cis_y = torch.polar(torch.ones_like(freqs_y), freqs_y)
+    return torch.cat([freqs_cis_x, freqs_cis_y], dim=-1)
+
+
+def reshape_for_broadcast(freqs_cis: torch.Tensor, x: torch.Tensor):
+    ndim = x.ndim
+    assert 0 <= 1 < ndim
+    assert freqs_cis.shape == (x.shape[-2], x.shape[-1])
+    shape = [d if i >= ndim - 2 else 1 for i, d in enumerate(x.shape)]
+    return freqs_cis.view(*shape)
+
+
+def apply_rotary_enc(
+    xq: torch.Tensor,
+    xk: torch.Tensor,
+    freqs_cis: torch.Tensor,
+    repeat_freqs_k: bool = False,
+):
+    xq_ = torch.view_as_complex(xq.float().reshape(*xq.shape[:-1], -1, 2))
+    xk_ = (
+        torch.view_as_complex(xk.float().reshape(*xk.shape[:-1], -1, 2))
+        if xk.shape[-2] != 0
+        else None
+    )
+    freqs_cis = reshape_for_broadcast(freqs_cis, xq_)
+    xq_out = torch.view_as_real(xq_ * freqs_cis).flatten(3)
+    if xk_ is None:
+        # no keys to rotate, due to dropout
+        return xq_out.type_as(xq).to(xq.device), xk
+    # repeat freqs along seq_len dim to match k seq_len
+    if repeat_freqs_k:
+        r = xk_.shape[-2] // xq_.shape[-2]
+        freqs_cis = freqs_cis.repeat(*([1] * (freqs_cis.ndim - 2)), r, 1)
+    xk_out = torch.view_as_real(xk_ * freqs_cis).flatten(3)
+    return xq_out.type_as(xq).to(xq.device), xk_out.type_as(xk).to(xk.device)
diff --git a/sam2_unet/sam2/modeling/sam/__init__.py b/sam2_unet/sam2/modeling/sam/__init__.py
new file mode 100644
index 0000000..5277f46
--- /dev/null
+++ b/sam2_unet/sam2/modeling/sam/__init__.py
@@ -0,0 +1,5 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
diff --git a/sam2_unet/sam2/modeling/sam/mask_decoder.py b/sam2_unet/sam2/modeling/sam/mask_decoder.py
new file mode 100644
index 0000000..b7c7dfd
--- /dev/null
+++ b/sam2_unet/sam2/modeling/sam/mask_decoder.py
@@ -0,0 +1,295 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+from typing import List, Optional, Tuple, Type
+
+import torch
+from torch import nn
+
+from sam2.modeling.sam2_utils import LayerNorm2d, MLP
+
+
+class MaskDecoder(nn.Module):
+    def __init__(
+        self,
+        *,
+        transformer_dim: int,
+        transformer: nn.Module,
+        num_multimask_outputs: int = 3,
+        activation: Type[nn.Module] = nn.GELU,
+        iou_head_depth: int = 3,
+        iou_head_hidden_dim: int = 256,
+        use_high_res_features: bool = False,
+        iou_prediction_use_sigmoid=False,
+        dynamic_multimask_via_stability=False,
+        dynamic_multimask_stability_delta=0.05,
+        dynamic_multimask_stability_thresh=0.98,
+        pred_obj_scores: bool = False,
+        pred_obj_scores_mlp: bool = False,
+        use_multimask_token_for_obj_ptr: bool = False,
+    ) -> None:
+        """
+        Predicts masks given an image and prompt embeddings, using a
+        transformer architecture.
+
+        Arguments:
+          transformer_dim (int): the channel dimension of the transformer
+          transformer (nn.Module): the transformer used to predict masks
+          num_multimask_outputs (int): the number of masks to predict
+            when disambiguating masks
+          activation (nn.Module): the type of activation to use when
+            upscaling masks
+          iou_head_depth (int): the depth of the MLP used to predict
+            mask quality
+          iou_head_hidden_dim (int): the hidden dimension of the MLP
+            used to predict mask quality
+        """
+        super().__init__()
+        self.transformer_dim = transformer_dim
+        self.transformer = transformer
+
+        self.num_multimask_outputs = num_multimask_outputs
+
+        self.iou_token = nn.Embedding(1, transformer_dim)
+        self.num_mask_tokens = num_multimask_outputs + 1
+        self.mask_tokens = nn.Embedding(self.num_mask_tokens, transformer_dim)
+
+        self.pred_obj_scores = pred_obj_scores
+        if self.pred_obj_scores:
+            self.obj_score_token = nn.Embedding(1, transformer_dim)
+        self.use_multimask_token_for_obj_ptr = use_multimask_token_for_obj_ptr
+
+        self.output_upscaling = nn.Sequential(
+            nn.ConvTranspose2d(
+                transformer_dim, transformer_dim // 4, kernel_size=2, stride=2
+            ),
+            LayerNorm2d(transformer_dim // 4),
+            activation(),
+            nn.ConvTranspose2d(
+                transformer_dim // 4, transformer_dim // 8, kernel_size=2, stride=2
+            ),
+            activation(),
+        )
+        self.use_high_res_features = use_high_res_features
+        if use_high_res_features:
+            self.conv_s0 = nn.Conv2d(
+                transformer_dim, transformer_dim // 8, kernel_size=1, stride=1
+            )
+            self.conv_s1 = nn.Conv2d(
+                transformer_dim, transformer_dim // 4, kernel_size=1, stride=1
+            )
+
+        self.output_hypernetworks_mlps = nn.ModuleList(
+            [
+                MLP(transformer_dim, transformer_dim, transformer_dim // 8, 3)
+                for i in range(self.num_mask_tokens)
+            ]
+        )
+
+        self.iou_prediction_head = MLP(
+            transformer_dim,
+            iou_head_hidden_dim,
+            self.num_mask_tokens,
+            iou_head_depth,
+            sigmoid_output=iou_prediction_use_sigmoid,
+        )
+        if self.pred_obj_scores:
+            self.pred_obj_score_head = nn.Linear(transformer_dim, 1)
+            if pred_obj_scores_mlp:
+                self.pred_obj_score_head = MLP(transformer_dim, transformer_dim, 1, 3)
+
+        # When outputting a single mask, optionally we can dynamically fall back to the best
+        # multimask output token if the single mask output token gives low stability scores.
+        self.dynamic_multimask_via_stability = dynamic_multimask_via_stability
+        self.dynamic_multimask_stability_delta = dynamic_multimask_stability_delta
+        self.dynamic_multimask_stability_thresh = dynamic_multimask_stability_thresh
+
+    def forward(
+        self,
+        image_embeddings: torch.Tensor,
+        image_pe: torch.Tensor,
+        sparse_prompt_embeddings: torch.Tensor,
+        dense_prompt_embeddings: torch.Tensor,
+        multimask_output: bool,
+        repeat_image: bool,
+        high_res_features: Optional[List[torch.Tensor]] = None,
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        Predict masks given image and prompt embeddings.
+
+        Arguments:
+          image_embeddings (torch.Tensor): the embeddings from the image encoder
+          image_pe (torch.Tensor): positional encoding with the shape of image_embeddings
+          sparse_prompt_embeddings (torch.Tensor): the embeddings of the points and boxes
+          dense_prompt_embeddings (torch.Tensor): the embeddings of the mask inputs
+          multimask_output (bool): Whether to return multiple masks or a single
+            mask.
+
+        Returns:
+          torch.Tensor: batched predicted masks
+          torch.Tensor: batched predictions of mask quality
+          torch.Tensor: batched SAM token for mask output
+        """
+        masks, iou_pred, mask_tokens_out, object_score_logits = self.predict_masks(
+            image_embeddings=image_embeddings,
+            image_pe=image_pe,
+            sparse_prompt_embeddings=sparse_prompt_embeddings,
+            dense_prompt_embeddings=dense_prompt_embeddings,
+            repeat_image=repeat_image,
+            high_res_features=high_res_features,
+        )
+
+        # Select the correct mask or masks for output
+        if multimask_output:
+            masks = masks[:, 1:, :, :]
+            iou_pred = iou_pred[:, 1:]
+        elif self.dynamic_multimask_via_stability and not self.training:
+            masks, iou_pred = self._dynamic_multimask_via_stability(masks, iou_pred)
+        else:
+            masks = masks[:, 0:1, :, :]
+            iou_pred = iou_pred[:, 0:1]
+
+        if multimask_output and self.use_multimask_token_for_obj_ptr:
+            sam_tokens_out = mask_tokens_out[:, 1:]  # [b, 3, c] shape
+        else:
+            # Take the mask output token. Here we *always* use the token for single mask output.
+            # At test time, even if we track after 1-click (and using multimask_output=True),
+            # we still take the single mask token here. The rationale is that we always track
+            # after multiple clicks during training, so the past tokens seen during training
+            # are always the single mask token (and we'll let it be the object-memory token).
+            sam_tokens_out = mask_tokens_out[:, 0:1]  # [b, 1, c] shape
+
+        # Prepare output
+        return masks, iou_pred, sam_tokens_out, object_score_logits
+
+    def predict_masks(
+        self,
+        image_embeddings: torch.Tensor,
+        image_pe: torch.Tensor,
+        sparse_prompt_embeddings: torch.Tensor,
+        dense_prompt_embeddings: torch.Tensor,
+        repeat_image: bool,
+        high_res_features: Optional[List[torch.Tensor]] = None,
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """Predicts masks. See 'forward' for more details."""
+        # Concatenate output tokens
+        s = 0
+        if self.pred_obj_scores:
+            output_tokens = torch.cat(
+                [
+                    self.obj_score_token.weight,
+                    self.iou_token.weight,
+                    self.mask_tokens.weight,
+                ],
+                dim=0,
+            )
+            s = 1
+        else:
+            output_tokens = torch.cat(
+                [self.iou_token.weight, self.mask_tokens.weight], dim=0
+            )
+        output_tokens = output_tokens.unsqueeze(0).expand(
+            sparse_prompt_embeddings.size(0), -1, -1
+        )
+        tokens = torch.cat((output_tokens, sparse_prompt_embeddings), dim=1)
+
+        # Expand per-image data in batch direction to be per-mask
+        if repeat_image:
+            src = torch.repeat_interleave(image_embeddings, tokens.shape[0], dim=0)
+        else:
+            assert image_embeddings.shape[0] == tokens.shape[0]
+            src = image_embeddings
+        src = src + dense_prompt_embeddings
+        assert (
+            image_pe.size(0) == 1
+        ), "image_pe should have size 1 in batch dim (from `get_dense_pe()`)"
+        pos_src = torch.repeat_interleave(image_pe, tokens.shape[0], dim=0)
+        b, c, h, w = src.shape
+
+        # Run the transformer
+        hs, src = self.transformer(src, pos_src, tokens)
+        iou_token_out = hs[:, s, :]
+        mask_tokens_out = hs[:, s + 1 : (s + 1 + self.num_mask_tokens), :]
+
+        # Upscale mask embeddings and predict masks using the mask tokens
+        src = src.transpose(1, 2).view(b, c, h, w)
+        if not self.use_high_res_features:
+            upscaled_embedding = self.output_upscaling(src)
+        else:
+            dc1, ln1, act1, dc2, act2 = self.output_upscaling
+            feat_s0, feat_s1 = high_res_features
+            upscaled_embedding = act1(ln1(dc1(src) + feat_s1))
+            upscaled_embedding = act2(dc2(upscaled_embedding) + feat_s0)
+
+        hyper_in_list: List[torch.Tensor] = []
+        for i in range(self.num_mask_tokens):
+            hyper_in_list.append(
+                self.output_hypernetworks_mlps[i](mask_tokens_out[:, i, :])
+            )
+        hyper_in = torch.stack(hyper_in_list, dim=1)
+        b, c, h, w = upscaled_embedding.shape
+        masks = (hyper_in @ upscaled_embedding.view(b, c, h * w)).view(b, -1, h, w)
+
+        # Generate mask quality predictions
+        iou_pred = self.iou_prediction_head(iou_token_out)
+        if self.pred_obj_scores:
+            assert s == 1
+            object_score_logits = self.pred_obj_score_head(hs[:, 0, :])
+        else:
+            # Obj scores logits - default to 10.0, i.e. assuming the object is present, sigmoid(10)=1
+            object_score_logits = 10.0 * iou_pred.new_ones(iou_pred.shape[0], 1)
+
+        return masks, iou_pred, mask_tokens_out, object_score_logits
+
+    def _get_stability_scores(self, mask_logits):
+        """
+        Compute stability scores of the mask logits based on the IoU between upper and
+        lower thresholds, similar to https://github.com/fairinternal/onevision/pull/568.
+        """
+        mask_logits = mask_logits.flatten(-2)
+        stability_delta = self.dynamic_multimask_stability_delta
+        area_i = torch.sum(mask_logits > stability_delta, dim=-1).float()
+        area_u = torch.sum(mask_logits > -stability_delta, dim=-1).float()
+        stability_scores = torch.where(area_u > 0, area_i / area_u, 1.0)
+        return stability_scores
+
+    def _dynamic_multimask_via_stability(self, all_mask_logits, all_iou_scores):
+        """
+        When outputting a single mask, if the stability score from the current single-mask
+        output (based on output token 0) falls below a threshold, we instead select from
+        multi-mask outputs (based on output token 1~3) the mask with the highest predicted
+        IoU score. This is intended to ensure a valid mask for both clicking and tracking.
+        """
+        # The best mask from multimask output tokens (1~3)
+        multimask_logits = all_mask_logits[:, 1:, :, :]
+        multimask_iou_scores = all_iou_scores[:, 1:]
+        best_scores_inds = torch.argmax(multimask_iou_scores, dim=-1)
+        batch_inds = torch.arange(
+            multimask_iou_scores.size(0), device=all_iou_scores.device
+        )
+        best_multimask_logits = multimask_logits[batch_inds, best_scores_inds]
+        best_multimask_logits = best_multimask_logits.unsqueeze(1)
+        best_multimask_iou_scores = multimask_iou_scores[batch_inds, best_scores_inds]
+        best_multimask_iou_scores = best_multimask_iou_scores.unsqueeze(1)
+
+        # The mask from singlemask output token 0 and its stability score
+        singlemask_logits = all_mask_logits[:, 0:1, :, :]
+        singlemask_iou_scores = all_iou_scores[:, 0:1]
+        stability_scores = self._get_stability_scores(singlemask_logits)
+        is_stable = stability_scores >= self.dynamic_multimask_stability_thresh
+
+        # Dynamically fall back to best multimask output upon low stability scores.
+        mask_logits_out = torch.where(
+            is_stable[..., None, None].expand_as(singlemask_logits),
+            singlemask_logits,
+            best_multimask_logits,
+        )
+        iou_scores_out = torch.where(
+            is_stable.expand_as(singlemask_iou_scores),
+            singlemask_iou_scores,
+            best_multimask_iou_scores,
+        )
+        return mask_logits_out, iou_scores_out
diff --git a/sam2_unet/sam2/modeling/sam/prompt_encoder.py b/sam2_unet/sam2/modeling/sam/prompt_encoder.py
new file mode 100644
index 0000000..6b3bbb9
--- /dev/null
+++ b/sam2_unet/sam2/modeling/sam/prompt_encoder.py
@@ -0,0 +1,182 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+from typing import Optional, Tuple, Type
+
+import torch
+from torch import nn
+
+from sam2.modeling.position_encoding import PositionEmbeddingRandom
+
+from sam2.modeling.sam2_utils import LayerNorm2d
+
+
+class PromptEncoder(nn.Module):
+    def __init__(
+        self,
+        embed_dim: int,
+        image_embedding_size: Tuple[int, int],
+        input_image_size: Tuple[int, int],
+        mask_in_chans: int,
+        activation: Type[nn.Module] = nn.GELU,
+    ) -> None:
+        """
+        Encodes prompts for input to SAM's mask decoder.
+
+        Arguments:
+          embed_dim (int): The prompts' embedding dimension
+          image_embedding_size (tuple(int, int)): The spatial size of the
+            image embedding, as (H, W).
+          input_image_size (int): The padded size of the image as input
+            to the image encoder, as (H, W).
+          mask_in_chans (int): The number of hidden channels used for
+            encoding input masks.
+          activation (nn.Module): The activation to use when encoding
+            input masks.
+        """
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.input_image_size = input_image_size
+        self.image_embedding_size = image_embedding_size
+        self.pe_layer = PositionEmbeddingRandom(embed_dim // 2)
+
+        self.num_point_embeddings: int = 4  # pos/neg point + 2 box corners
+        point_embeddings = [
+            nn.Embedding(1, embed_dim) for i in range(self.num_point_embeddings)
+        ]
+        self.point_embeddings = nn.ModuleList(point_embeddings)
+        self.not_a_point_embed = nn.Embedding(1, embed_dim)
+
+        self.mask_input_size = (
+            4 * image_embedding_size[0],
+            4 * image_embedding_size[1],
+        )
+        self.mask_downscaling = nn.Sequential(
+            nn.Conv2d(1, mask_in_chans // 4, kernel_size=2, stride=2),
+            LayerNorm2d(mask_in_chans // 4),
+            activation(),
+            nn.Conv2d(mask_in_chans // 4, mask_in_chans, kernel_size=2, stride=2),
+            LayerNorm2d(mask_in_chans),
+            activation(),
+            nn.Conv2d(mask_in_chans, embed_dim, kernel_size=1),
+        )
+        self.no_mask_embed = nn.Embedding(1, embed_dim)
+
+    def get_dense_pe(self) -> torch.Tensor:
+        """
+        Returns the positional encoding used to encode point prompts,
+        applied to a dense set of points the shape of the image encoding.
+
+        Returns:
+          torch.Tensor: Positional encoding with shape
+            1x(embed_dim)x(embedding_h)x(embedding_w)
+        """
+        return self.pe_layer(self.image_embedding_size).unsqueeze(0)
+
+    def _embed_points(
+        self,
+        points: torch.Tensor,
+        labels: torch.Tensor,
+        pad: bool,
+    ) -> torch.Tensor:
+        """Embeds point prompts."""
+        points = points + 0.5  # Shift to center of pixel
+        if pad:
+            padding_point = torch.zeros((points.shape[0], 1, 2), device=points.device)
+            padding_label = -torch.ones((labels.shape[0], 1), device=labels.device)
+            points = torch.cat([points, padding_point], dim=1)
+            labels = torch.cat([labels, padding_label], dim=1)
+        point_embedding = self.pe_layer.forward_with_coords(
+            points, self.input_image_size
+        )
+        point_embedding[labels == -1] = 0.0
+        point_embedding[labels == -1] += self.not_a_point_embed.weight
+        point_embedding[labels == 0] += self.point_embeddings[0].weight
+        point_embedding[labels == 1] += self.point_embeddings[1].weight
+        point_embedding[labels == 2] += self.point_embeddings[2].weight
+        point_embedding[labels == 3] += self.point_embeddings[3].weight
+        return point_embedding
+
+    def _embed_boxes(self, boxes: torch.Tensor) -> torch.Tensor:
+        """Embeds box prompts."""
+        boxes = boxes + 0.5  # Shift to center of pixel
+        coords = boxes.reshape(-1, 2, 2)
+        corner_embedding = self.pe_layer.forward_with_coords(
+            coords, self.input_image_size
+        )
+        corner_embedding[:, 0, :] += self.point_embeddings[2].weight
+        corner_embedding[:, 1, :] += self.point_embeddings[3].weight
+        return corner_embedding
+
+    def _embed_masks(self, masks: torch.Tensor) -> torch.Tensor:
+        """Embeds mask inputs."""
+        mask_embedding = self.mask_downscaling(masks)
+        return mask_embedding
+
+    def _get_batch_size(
+        self,
+        points: Optional[Tuple[torch.Tensor, torch.Tensor]],
+        boxes: Optional[torch.Tensor],
+        masks: Optional[torch.Tensor],
+    ) -> int:
+        """
+        Gets the batch size of the output given the batch size of the input prompts.
+        """
+        if points is not None:
+            return points[0].shape[0]
+        elif boxes is not None:
+            return boxes.shape[0]
+        elif masks is not None:
+            return masks.shape[0]
+        else:
+            return 1
+
+    def _get_device(self) -> torch.device:
+        return self.point_embeddings[0].weight.device
+
+    def forward(
+        self,
+        points: Optional[Tuple[torch.Tensor, torch.Tensor]],
+        boxes: Optional[torch.Tensor],
+        masks: Optional[torch.Tensor],
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        Embeds different types of prompts, returning both sparse and dense
+        embeddings.
+
+        Arguments:
+          points (tuple(torch.Tensor, torch.Tensor) or none): point coordinates
+            and labels to embed.
+          boxes (torch.Tensor or none): boxes to embed
+          masks (torch.Tensor or none): masks to embed
+
+        Returns:
+          torch.Tensor: sparse embeddings for the points and boxes, with shape
+            BxNx(embed_dim), where N is determined by the number of input points
+            and boxes.
+          torch.Tensor: dense embeddings for the masks, in the shape
+            Bx(embed_dim)x(embed_H)x(embed_W)
+        """
+        bs = self._get_batch_size(points, boxes, masks)
+        sparse_embeddings = torch.empty(
+            (bs, 0, self.embed_dim), device=self._get_device()
+        )
+        if points is not None:
+            coords, labels = points
+            point_embeddings = self._embed_points(coords, labels, pad=(boxes is None))
+            sparse_embeddings = torch.cat([sparse_embeddings, point_embeddings], dim=1)
+        if boxes is not None:
+            box_embeddings = self._embed_boxes(boxes)
+            sparse_embeddings = torch.cat([sparse_embeddings, box_embeddings], dim=1)
+
+        if masks is not None:
+            dense_embeddings = self._embed_masks(masks)
+        else:
+            dense_embeddings = self.no_mask_embed.weight.reshape(1, -1, 1, 1).expand(
+                bs, -1, self.image_embedding_size[0], self.image_embedding_size[1]
+            )
+
+        return sparse_embeddings, dense_embeddings
diff --git a/sam2_unet/sam2/modeling/sam/transformer.py b/sam2_unet/sam2/modeling/sam/transformer.py
new file mode 100644
index 0000000..ba3519b
--- /dev/null
+++ b/sam2_unet/sam2/modeling/sam/transformer.py
@@ -0,0 +1,332 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import math
+import warnings
+from functools import partial
+from typing import Tuple, Type
+
+import torch
+import torch.nn.functional as F
+from torch import nn, Tensor
+
+from sam2.modeling.position_encoding import apply_rotary_enc, compute_axial_cis
+
+from sam2.modeling.sam2_utils import MLP
+from sam2.utils.misc import get_sdpa_settings
+
+warnings.simplefilter(action="ignore", category=FutureWarning)
+OLD_GPU, USE_FLASH_ATTN, MATH_KERNEL_ON = get_sdpa_settings()
+
+# CUSTOM SETTING
+USE_FLASH_ATTN = False
+MATH_KERNEL_ON = True
+OLD_GPU = True
+
+
+class TwoWayTransformer(nn.Module):
+    def __init__(
+        self,
+        depth: int,
+        embedding_dim: int,
+        num_heads: int,
+        mlp_dim: int,
+        activation: Type[nn.Module] = nn.ReLU,
+        attention_downsample_rate: int = 2,
+    ) -> None:
+        """
+        A transformer decoder that attends to an input image using
+        queries whose positional embedding is supplied.
+
+        Args:
+          depth (int): number of layers in the transformer
+          embedding_dim (int): the channel dimension for the input embeddings
+          num_heads (int): the number of heads for multihead attention. Must
+            divide embedding_dim
+          mlp_dim (int): the channel dimension internal to the MLP block
+          activation (nn.Module): the activation to use in the MLP block
+        """
+        super().__init__()
+        self.depth = depth
+        self.embedding_dim = embedding_dim
+        self.num_heads = num_heads
+        self.mlp_dim = mlp_dim
+        self.layers = nn.ModuleList()
+
+        for i in range(depth):
+            self.layers.append(
+                TwoWayAttentionBlock(
+                    embedding_dim=embedding_dim,
+                    num_heads=num_heads,
+                    mlp_dim=mlp_dim,
+                    activation=activation,
+                    attention_downsample_rate=attention_downsample_rate,
+                    skip_first_layer_pe=(i == 0),
+                )
+            )
+
+        self.final_attn_token_to_image = Attention(
+            embedding_dim, num_heads, downsample_rate=attention_downsample_rate
+        )
+        self.norm_final_attn = nn.LayerNorm(embedding_dim)
+
+    def forward(
+        self,
+        image_embedding: Tensor,
+        image_pe: Tensor,
+        point_embedding: Tensor,
+    ) -> Tuple[Tensor, Tensor]:
+        """
+        Args:
+          image_embedding (torch.Tensor): image to attend to. Should be shape
+            B x embedding_dim x h x w for any h and w.
+          image_pe (torch.Tensor): the positional encoding to add to the image. Must
+            have the same shape as image_embedding.
+          point_embedding (torch.Tensor): the embedding to add to the query points.
+            Must have shape B x N_points x embedding_dim for any N_points.
+
+        Returns:
+          torch.Tensor: the processed point_embedding
+          torch.Tensor: the processed image_embedding
+        """
+        # BxCxHxW -> BxHWxC == B x N_image_tokens x C
+        bs, c, h, w = image_embedding.shape
+        image_embedding = image_embedding.flatten(2).permute(0, 2, 1)
+        image_pe = image_pe.flatten(2).permute(0, 2, 1)
+
+        # Prepare queries
+        queries = point_embedding
+        keys = image_embedding
+
+        # Apply transformer blocks and final layernorm
+        for layer in self.layers:
+            queries, keys = layer(
+                queries=queries,
+                keys=keys,
+                query_pe=point_embedding,
+                key_pe=image_pe,
+            )
+
+        # Apply the final attention layer from the points to the image
+        q = queries + point_embedding
+        k = keys + image_pe
+        attn_out = self.final_attn_token_to_image(q=q, k=k, v=keys)
+        queries = queries + attn_out
+        queries = self.norm_final_attn(queries)
+
+        return queries, keys
+
+
+class TwoWayAttentionBlock(nn.Module):
+    def __init__(
+        self,
+        embedding_dim: int,
+        num_heads: int,
+        mlp_dim: int = 2048,
+        activation: Type[nn.Module] = nn.ReLU,
+        attention_downsample_rate: int = 2,
+        skip_first_layer_pe: bool = False,
+    ) -> None:
+        """
+        A transformer block with four layers: (1) self-attention of sparse
+        inputs, (2) cross attention of sparse inputs to dense inputs, (3) mlp
+        block on sparse inputs, and (4) cross attention of dense inputs to sparse
+        inputs.
+
+        Arguments:
+          embedding_dim (int): the channel dimension of the embeddings
+          num_heads (int): the number of heads in the attention layers
+          mlp_dim (int): the hidden dimension of the mlp block
+          activation (nn.Module): the activation of the mlp block
+          skip_first_layer_pe (bool): skip the PE on the first layer
+        """
+        super().__init__()
+        self.self_attn = Attention(embedding_dim, num_heads)
+        self.norm1 = nn.LayerNorm(embedding_dim)
+
+        self.cross_attn_token_to_image = Attention(
+            embedding_dim, num_heads, downsample_rate=attention_downsample_rate
+        )
+        self.norm2 = nn.LayerNorm(embedding_dim)
+
+        self.mlp = MLP(
+            embedding_dim, mlp_dim, embedding_dim, num_layers=2, activation=activation
+        )
+        self.norm3 = nn.LayerNorm(embedding_dim)
+
+        self.norm4 = nn.LayerNorm(embedding_dim)
+        self.cross_attn_image_to_token = Attention(
+            embedding_dim, num_heads, downsample_rate=attention_downsample_rate
+        )
+
+        self.skip_first_layer_pe = skip_first_layer_pe
+
+    def forward(
+        self, queries: Tensor, keys: Tensor, query_pe: Tensor, key_pe: Tensor
+    ) -> Tuple[Tensor, Tensor]:
+        # Self attention block
+        if self.skip_first_layer_pe:
+            queries = self.self_attn(q=queries, k=queries, v=queries)
+        else:
+            q = queries + query_pe
+            attn_out = self.self_attn(q=q, k=q, v=queries)
+            queries = queries + attn_out
+        queries = self.norm1(queries)
+
+        # Cross attention block, tokens attending to image embedding
+        q = queries + query_pe
+        k = keys + key_pe
+        attn_out = self.cross_attn_token_to_image(q=q, k=k, v=keys)
+        queries = queries + attn_out
+        queries = self.norm2(queries)
+
+        # MLP block
+        mlp_out = self.mlp(queries)
+        queries = queries + mlp_out
+        queries = self.norm3(queries)
+
+        # Cross attention block, image embedding attending to tokens
+        q = queries + query_pe
+        k = keys + key_pe
+        attn_out = self.cross_attn_image_to_token(q=k, k=q, v=queries)
+        keys = keys + attn_out
+        keys = self.norm4(keys)
+
+        return queries, keys
+
+
+class Attention(nn.Module):
+    """
+    An attention layer that allows for downscaling the size of the embedding
+    after projection to queries, keys, and values.
+    """
+
+    def __init__(
+        self,
+        embedding_dim: int,
+        num_heads: int,
+        downsample_rate: int = 1,
+        dropout: float = 0.0,
+        kv_in_dim: int = None,
+    ) -> None:
+        super().__init__()
+        self.embedding_dim = embedding_dim
+        self.kv_in_dim = kv_in_dim if kv_in_dim is not None else embedding_dim
+        self.internal_dim = embedding_dim // downsample_rate
+        self.num_heads = num_heads
+        assert (
+            self.internal_dim % num_heads == 0
+        ), "num_heads must divide embedding_dim."
+
+        self.q_proj = nn.Linear(embedding_dim, self.internal_dim)
+        self.k_proj = nn.Linear(self.kv_in_dim, self.internal_dim)
+        self.v_proj = nn.Linear(self.kv_in_dim, self.internal_dim)
+        self.out_proj = nn.Linear(self.internal_dim, embedding_dim)
+
+        self.dropout_p = dropout
+
+    def _separate_heads(self, x: Tensor, num_heads: int) -> Tensor:
+        b, n, c = x.shape
+        x = x.reshape(b, n, num_heads, c // num_heads)
+        return x.transpose(1, 2)  # B x N_heads x N_tokens x C_per_head
+
+    def _recombine_heads(self, x: Tensor) -> Tensor:
+        b, n_heads, n_tokens, c_per_head = x.shape
+        x = x.transpose(1, 2)
+        return x.reshape(b, n_tokens, n_heads * c_per_head)  # B x N_tokens x C
+
+    def forward(self, q: Tensor, k: Tensor, v: Tensor) -> Tensor:
+        # Input projections
+        q = self.q_proj(q)
+        k = self.k_proj(k)
+        v = self.v_proj(v)
+
+        # Separate into heads
+        q = self._separate_heads(q, self.num_heads)
+        k = self._separate_heads(k, self.num_heads)
+        v = self._separate_heads(v, self.num_heads)
+
+        dropout_p = self.dropout_p if self.training else 0.0
+        # Attention
+        with torch.backends.cuda.sdp_kernel(
+            enable_flash=USE_FLASH_ATTN,
+            # if Flash attention kernel is off, then math kernel needs to be enabled
+            enable_math=(OLD_GPU and dropout_p > 0.0) or MATH_KERNEL_ON,
+            enable_mem_efficient=OLD_GPU,
+        ):
+            out = F.scaled_dot_product_attention(q, k, v, dropout_p=dropout_p)
+
+        out = self._recombine_heads(out)
+        out = self.out_proj(out)
+
+        return out
+
+
+class RoPEAttention(Attention):
+    """Attention with rotary position encoding."""
+
+    def __init__(
+        self,
+        *args,
+        rope_theta=10000.0,
+        # whether to repeat q rope to match k length
+        # this is needed for cross-attention to memories
+        rope_k_repeat=False,
+        feat_sizes=(32, 32),  # [w, h] for stride 16 feats at 512 resolution
+        **kwargs,
+    ):
+        super().__init__(*args, **kwargs)
+
+        self.compute_cis = partial(
+            compute_axial_cis, dim=self.internal_dim // self.num_heads, theta=rope_theta
+        )
+        freqs_cis = self.compute_cis(end_x=feat_sizes[0], end_y=feat_sizes[1])
+        self.freqs_cis = freqs_cis
+        self.rope_k_repeat = rope_k_repeat
+
+    def forward(
+        self, q: Tensor, k: Tensor, v: Tensor, num_k_exclude_rope: int = 0
+    ) -> Tensor:
+        # Input projections
+        q = self.q_proj(q)
+        k = self.k_proj(k)
+        v = self.v_proj(v)
+
+        # Separate into heads
+        q = self._separate_heads(q, self.num_heads)
+        k = self._separate_heads(k, self.num_heads)
+        v = self._separate_heads(v, self.num_heads)
+
+        # Apply rotary position encoding
+        w = h = math.sqrt(q.shape[-2])
+        self.freqs_cis = self.freqs_cis.to(q.device)
+        if self.freqs_cis.shape[0] != q.shape[-2]:
+            self.freqs_cis = self.compute_cis(end_x=w, end_y=h).to(q.device)
+        if q.shape[-2] != k.shape[-2]:
+            assert self.rope_k_repeat
+
+        num_k_rope = k.size(-2) - num_k_exclude_rope
+        q, k[:, :, :num_k_rope] = apply_rotary_enc(
+            q,
+            k[:, :, :num_k_rope],
+            freqs_cis=self.freqs_cis,
+            repeat_freqs_k=self.rope_k_repeat,
+        )
+
+        dropout_p = self.dropout_p if self.training else 0.0
+        # Attention
+        with torch.backends.cuda.sdp_kernel(
+            enable_flash=USE_FLASH_ATTN,
+            # if Flash attention kernel is off, then math kernel needs to be enabled
+            enable_math=(OLD_GPU and dropout_p > 0.0) or MATH_KERNEL_ON,
+            enable_mem_efficient=OLD_GPU,
+        ):
+            out = F.scaled_dot_product_attention(q, k, v, dropout_p=dropout_p)
+
+        out = self._recombine_heads(out)
+        out = self.out_proj(out)
+
+        return out
diff --git a/sam2_unet/sam2/modeling/sam2_base.py b/sam2_unet/sam2/modeling/sam2_base.py
new file mode 100644
index 0000000..2b5251f
--- /dev/null
+++ b/sam2_unet/sam2/modeling/sam2_base.py
@@ -0,0 +1,829 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch
+import torch.distributed
+import torch.nn.functional as F
+
+from torch.nn.init import trunc_normal_
+
+from sam2.modeling.sam.mask_decoder import MaskDecoder
+from sam2.modeling.sam.prompt_encoder import PromptEncoder
+from sam2.modeling.sam.transformer import TwoWayTransformer
+from sam2.modeling.sam2_utils import get_1d_sine_pe, MLP, select_closest_cond_frames
+
+# a large negative value as a placeholder score for missing objects
+NO_OBJ_SCORE = -1024.0
+
+
+class SAM2Base(torch.nn.Module):
+    def __init__(
+        self,
+        image_encoder,
+        memory_attention,
+        memory_encoder,
+        num_maskmem=7,  # default 1 input frame + 6 previous frames
+        image_size=512,
+        backbone_stride=16,  # stride of the image backbone output
+        sigmoid_scale_for_mem_enc=1.0,  # scale factor for mask sigmoid prob
+        sigmoid_bias_for_mem_enc=0.0,  # bias factor for mask sigmoid prob
+        # During evaluation, whether to binarize the sigmoid mask logits on interacted frames with clicks
+        binarize_mask_from_pts_for_mem_enc=False,
+        use_mask_input_as_output_without_sam=False,  # on frames with mask input, whether to directly output the input mask without using a SAM prompt encoder + mask decoder
+        # The maximum number of conditioning frames to participate in the memory attention (-1 means no limit; if there are more conditioning frames than this limit,
+        # we only cross-attend to the temporally closest `max_cond_frames_in_attn` conditioning frames in the encoder when tracking each frame). This gives the model
+        # a temporal locality when handling a large number of annotated frames (since closer frames should be more important) and also avoids GPU OOM.
+        max_cond_frames_in_attn=-1,
+        # on the first frame, whether to directly add the no-memory embedding to the image feature
+        # (instead of using the transformer encoder)
+        directly_add_no_mem_embed=False,
+        # whether to use high-resolution feature maps in the SAM mask decoder
+        use_high_res_features_in_sam=False,
+        # whether to output multiple (3) masks for the first click on initial conditioning frames
+        multimask_output_in_sam=False,
+        # the minimum and maximum number of clicks to use multimask_output_in_sam (only relevant when `multimask_output_in_sam=True`;
+        # default is 1 for both, meaning that only the first click gives multimask output; also note that a box counts as two points)
+        multimask_min_pt_num=1,
+        multimask_max_pt_num=1,
+        # whether to also use multimask output for tracking (not just for the first click on initial conditioning frames; only relevant when `multimask_output_in_sam=True`)
+        multimask_output_for_tracking=False,
+        # Whether to use multimask tokens for obj ptr; Only relevant when both
+        # use_obj_ptrs_in_encoder=True and multimask_output_for_tracking=True
+        use_multimask_token_for_obj_ptr: bool = False,
+        # whether to use sigmoid to restrict ious prediction to [0-1]
+        iou_prediction_use_sigmoid=False,
+        # The memory bank's temporal stride during evaluation (i.e. the `r` parameter in XMem and Cutie; XMem and Cutie use r=5).
+        # For r>1, the (self.num_maskmem - 1) non-conditioning memory frames consist of
+        # (self.num_maskmem - 2) nearest frames from every r-th frames, plus the last frame.
+        memory_temporal_stride_for_eval=1,
+        # if `add_all_frames_to_correct_as_cond` is True, we also append to the conditioning frame list any frame that receives a later correction click
+        # if `add_all_frames_to_correct_as_cond` is False, we conditioning frame list to only use those initial conditioning frames
+        add_all_frames_to_correct_as_cond=False,
+        # whether to apply non-overlapping constraints on the object masks in the memory encoder during evaluation (to avoid/alleviate superposing masks)
+        non_overlap_masks_for_mem_enc=False,
+        # whether to cross-attend to object pointers from other frames (based on SAM output tokens) in the encoder
+        use_obj_ptrs_in_encoder=False,
+        # the maximum number of object pointers from other frames in encoder cross attention (only relevant when `use_obj_ptrs_in_encoder=True`)
+        max_obj_ptrs_in_encoder=16,
+        # whether to add temporal positional encoding to the object pointers in the encoder (only relevant when `use_obj_ptrs_in_encoder=True`)
+        add_tpos_enc_to_obj_ptrs=True,
+        # whether to add an extra linear projection layer for the temporal positional encoding in the object pointers to avoid potential interference
+        # with spatial positional encoding (only relevant when both `use_obj_ptrs_in_encoder=True` and `add_tpos_enc_to_obj_ptrs=True`)
+        proj_tpos_enc_in_obj_ptrs=False,
+        # whether to only attend to object pointers in the past (before the current frame) in the encoder during evaluation
+        # (only relevant when `use_obj_ptrs_in_encoder=True`; this might avoid pointer information too far in the future to distract the initial tracking)
+        only_obj_ptrs_in_the_past_for_eval=False,
+        # Whether to predict if there is an object in the frame
+        pred_obj_scores: bool = False,
+        # Whether to use an MLP to predict object scores
+        pred_obj_scores_mlp: bool = False,
+        # Only relevant if pred_obj_scores=True and use_obj_ptrs_in_encoder=True;
+        # Whether to have a fixed no obj pointer when there is no object present
+        # or to use it as an additive embedding with obj_ptr produced by decoder
+        fixed_no_obj_ptr: bool = False,
+        # Soft no object, i.e. mix in no_obj_ptr softly,
+        # hope to make recovery easier if there is a mistake and mitigate accumulation of errors
+        soft_no_obj_ptr: bool = False,
+        use_mlp_for_obj_ptr_proj: bool = False,
+        # extra arguments used to construct the SAM mask decoder; if not None, it should be a dict of kwargs to be passed into `MaskDecoder` class.
+        sam_mask_decoder_extra_args=None,
+        compile_image_encoder: bool = False,
+    ):
+        super().__init__()
+
+        # Part 1: the image backbone
+        self.image_encoder = image_encoder
+        # Use level 0, 1, 2 for high-res setting, or just level 2 for the default setting
+        self.use_high_res_features_in_sam = use_high_res_features_in_sam
+        self.num_feature_levels = 3 if use_high_res_features_in_sam else 1
+        self.use_obj_ptrs_in_encoder = use_obj_ptrs_in_encoder
+        self.max_obj_ptrs_in_encoder = max_obj_ptrs_in_encoder
+        if use_obj_ptrs_in_encoder:
+            # A conv layer to downsample the mask prompt to stride 4 (the same stride as
+            # low-res SAM mask logits) and to change its scales from 0~1 to SAM logit scale,
+            # so that it can be fed into the SAM mask decoder to generate a pointer.
+            self.mask_downsample = torch.nn.Conv2d(1, 1, kernel_size=4, stride=4)
+        self.add_tpos_enc_to_obj_ptrs = add_tpos_enc_to_obj_ptrs
+        if proj_tpos_enc_in_obj_ptrs:
+            assert add_tpos_enc_to_obj_ptrs  # these options need to be used together
+        self.proj_tpos_enc_in_obj_ptrs = proj_tpos_enc_in_obj_ptrs
+        self.only_obj_ptrs_in_the_past_for_eval = only_obj_ptrs_in_the_past_for_eval
+
+        # Part 2: memory attention to condition current frame's visual features
+        # with memories (and obj ptrs) from past frames
+        self.memory_attention = memory_attention
+        self.hidden_dim = memory_attention.d_model
+
+        # Part 3: memory encoder for the previous frame's outputs
+        self.memory_encoder = memory_encoder
+        self.mem_dim = self.hidden_dim
+        if hasattr(self.memory_encoder, "out_proj") and hasattr(
+            self.memory_encoder.out_proj, "weight"
+        ):
+            # if there is compression of memories along channel dim
+            self.mem_dim = self.memory_encoder.out_proj.weight.shape[0]
+        self.num_maskmem = num_maskmem  # Number of memories accessible
+        # Temporal encoding of the memories
+        self.maskmem_tpos_enc = torch.nn.Parameter(
+            torch.zeros(num_maskmem, 1, 1, self.mem_dim)
+        )
+        trunc_normal_(self.maskmem_tpos_enc, std=0.02)
+        # a single token to indicate no memory embedding from previous frames
+        self.no_mem_embed = torch.nn.Parameter(torch.zeros(1, 1, self.hidden_dim))
+        self.no_mem_pos_enc = torch.nn.Parameter(torch.zeros(1, 1, self.hidden_dim))
+        trunc_normal_(self.no_mem_embed, std=0.02)
+        trunc_normal_(self.no_mem_pos_enc, std=0.02)
+        self.directly_add_no_mem_embed = directly_add_no_mem_embed
+        # Apply sigmoid to the output raw mask logits (to turn them from
+        # range (-inf, +inf) to range (0, 1)) before feeding them into the memory encoder
+        self.sigmoid_scale_for_mem_enc = sigmoid_scale_for_mem_enc
+        self.sigmoid_bias_for_mem_enc = sigmoid_bias_for_mem_enc
+        self.binarize_mask_from_pts_for_mem_enc = binarize_mask_from_pts_for_mem_enc
+        self.non_overlap_masks_for_mem_enc = non_overlap_masks_for_mem_enc
+        self.memory_temporal_stride_for_eval = memory_temporal_stride_for_eval
+        # On frames with mask input, whether to directly output the input mask without
+        # using a SAM prompt encoder + mask decoder
+        self.use_mask_input_as_output_without_sam = use_mask_input_as_output_without_sam
+        self.multimask_output_in_sam = multimask_output_in_sam
+        self.multimask_min_pt_num = multimask_min_pt_num
+        self.multimask_max_pt_num = multimask_max_pt_num
+        self.multimask_output_for_tracking = multimask_output_for_tracking
+        self.use_multimask_token_for_obj_ptr = use_multimask_token_for_obj_ptr
+        self.iou_prediction_use_sigmoid = iou_prediction_use_sigmoid
+
+        # Part 4: SAM-style prompt encoder (for both mask and point inputs)
+        # and SAM-style mask decoder for the final mask output
+        self.image_size = image_size
+        self.backbone_stride = backbone_stride
+        self.sam_mask_decoder_extra_args = sam_mask_decoder_extra_args
+        self.pred_obj_scores = pred_obj_scores
+        self.pred_obj_scores_mlp = pred_obj_scores_mlp
+        self.fixed_no_obj_ptr = fixed_no_obj_ptr
+        self.soft_no_obj_ptr = soft_no_obj_ptr
+        if self.fixed_no_obj_ptr:
+            assert self.pred_obj_scores
+            assert self.use_obj_ptrs_in_encoder
+        if self.pred_obj_scores and self.use_obj_ptrs_in_encoder:
+            self.no_obj_ptr = torch.nn.Parameter(torch.zeros(1, self.hidden_dim))
+            trunc_normal_(self.no_obj_ptr, std=0.02)
+        self.use_mlp_for_obj_ptr_proj = use_mlp_for_obj_ptr_proj
+
+        self._build_sam_heads()
+        self.add_all_frames_to_correct_as_cond = add_all_frames_to_correct_as_cond
+        self.max_cond_frames_in_attn = max_cond_frames_in_attn
+
+        # Model compilation
+        if compile_image_encoder:
+            # Compile the forward function (not the full module) to allow loading checkpoints.
+            print(
+                "Image encoder compilation is enabled. First forward pass will be slow."
+            )
+            self.image_encoder.forward = torch.compile(
+                self.image_encoder.forward,
+                mode="max-autotune",
+                fullgraph=True,
+                dynamic=False,
+            )
+
+    @property
+    def device(self):
+        return next(self.parameters()).device
+
+    def forward(self, *args, **kwargs):
+        raise NotImplementedError(
+            "Please use the corresponding methods in SAM2VideoPredictor for inference."
+            "See notebooks/video_predictor_example.ipynb for an example."
+        )
+
+    def _build_sam_heads(self):
+        """Build SAM-style prompt encoder and mask decoder."""
+        self.sam_prompt_embed_dim = self.hidden_dim
+        self.sam_image_embedding_size = self.image_size // self.backbone_stride
+
+        # build PromptEncoder and MaskDecoder from SAM
+        # (their hyperparameters like `mask_in_chans=16` are from SAM code)
+        self.sam_prompt_encoder = PromptEncoder(
+            embed_dim=self.sam_prompt_embed_dim,
+            image_embedding_size=(
+                self.sam_image_embedding_size,
+                self.sam_image_embedding_size,
+            ),
+            input_image_size=(self.image_size, self.image_size),
+            mask_in_chans=16,
+        )
+        self.sam_mask_decoder = MaskDecoder(
+            num_multimask_outputs=3,
+            transformer=TwoWayTransformer(
+                depth=2,
+                embedding_dim=self.sam_prompt_embed_dim,
+                mlp_dim=2048,
+                num_heads=8,
+            ),
+            transformer_dim=self.sam_prompt_embed_dim,
+            iou_head_depth=3,
+            iou_head_hidden_dim=256,
+            use_high_res_features=self.use_high_res_features_in_sam,
+            iou_prediction_use_sigmoid=self.iou_prediction_use_sigmoid,
+            pred_obj_scores=self.pred_obj_scores,
+            pred_obj_scores_mlp=self.pred_obj_scores_mlp,
+            use_multimask_token_for_obj_ptr=self.use_multimask_token_for_obj_ptr,
+            **(self.sam_mask_decoder_extra_args or {}),
+        )
+        if self.use_obj_ptrs_in_encoder:
+            # a linear projection on SAM output tokens to turn them into object pointers
+            self.obj_ptr_proj = torch.nn.Linear(self.hidden_dim, self.hidden_dim)
+            if self.use_mlp_for_obj_ptr_proj:
+                self.obj_ptr_proj = MLP(
+                    self.hidden_dim, self.hidden_dim, self.hidden_dim, 3
+                )
+        else:
+            self.obj_ptr_proj = torch.nn.Identity()
+        if self.proj_tpos_enc_in_obj_ptrs:
+            # a linear projection on temporal positional encoding in object pointers to
+            # avoid potential interference with spatial positional encoding
+            self.obj_ptr_tpos_proj = torch.nn.Linear(self.hidden_dim, self.mem_dim)
+        else:
+            self.obj_ptr_tpos_proj = torch.nn.Identity()
+
+    def _forward_sam_heads(
+        self,
+        backbone_features,
+        point_inputs=None,
+        mask_inputs=None,
+        high_res_features=None,
+        multimask_output=False,
+    ):
+        """
+        Forward SAM prompt encoders and mask heads.
+
+        Inputs:
+        - backbone_features: image features of [B, C, H, W] shape
+        - point_inputs: a dictionary with "point_coords" and "point_labels", where
+          1) "point_coords" has [B, P, 2] shape and float32 dtype and contains the
+             absolute pixel-unit coordinate in (x, y) format of the P input points
+          2) "point_labels" has shape [B, P] and int32 dtype, where 1 means
+             positive clicks, 0 means negative clicks, and -1 means padding
+        - mask_inputs: a mask of [B, 1, H*16, W*16] shape, float or bool, with the
+          same spatial size as the image.
+        - high_res_features: either 1) None or 2) or a list of length 2 containing
+          two feature maps of [B, C, 4*H, 4*W] and [B, C, 2*H, 2*W] shapes respectively,
+          which will be used as high-resolution feature maps for SAM decoder.
+        - multimask_output: if it's True, we output 3 candidate masks and their 3
+          corresponding IoU estimates, and if it's False, we output only 1 mask and
+          its corresponding IoU estimate.
+
+        Outputs:
+        - low_res_multimasks: [B, M, H*4, W*4] shape (where M = 3 if
+          `multimask_output=True` and M = 1 if `multimask_output=False`), the SAM
+          output mask logits (before sigmoid) for the low-resolution masks, with 4x
+          the resolution (1/4 stride) of the input backbone_features.
+        - high_res_multimasks: [B, M, H*16, W*16] shape (where M = 3
+          if `multimask_output=True` and M = 1 if `multimask_output=False`),
+          upsampled from the low-resolution masks, with shape size as the image
+          (stride is 1 pixel).
+        - ious, [B, M] shape, where (where M = 3 if `multimask_output=True` and M = 1
+          if `multimask_output=False`), the estimated IoU of each output mask.
+        - low_res_masks: [B, 1, H*4, W*4] shape, the best mask in `low_res_multimasks`.
+          If `multimask_output=True`, it's the mask with the highest IoU estimate.
+          If `multimask_output=False`, it's the same as `low_res_multimasks`.
+        - high_res_masks: [B, 1, H*16, W*16] shape, the best mask in `high_res_multimasks`.
+          If `multimask_output=True`, it's the mask with the highest IoU estimate.
+          If `multimask_output=False`, it's the same as `high_res_multimasks`.
+        - obj_ptr: [B, C] shape, the object pointer vector for the output mask, extracted
+          based on the output token from the SAM mask decoder.
+        """
+        B = backbone_features.size(0)
+        device = backbone_features.device
+        assert backbone_features.size(1) == self.sam_prompt_embed_dim
+        assert backbone_features.size(2) == self.sam_image_embedding_size
+        assert backbone_features.size(3) == self.sam_image_embedding_size
+
+        # a) Handle point prompts
+        if point_inputs is not None:
+            sam_point_coords = point_inputs["point_coords"]
+            sam_point_labels = point_inputs["point_labels"]
+            assert sam_point_coords.size(0) == B and sam_point_labels.size(0) == B
+        else:
+            # If no points are provide, pad with an empty point (with label -1)
+            sam_point_coords = torch.zeros(B, 1, 2, device=device)
+            sam_point_labels = -torch.ones(B, 1, dtype=torch.int32, device=device)
+
+        # b) Handle mask prompts
+        if mask_inputs is not None:
+            # If mask_inputs is provided, downsize it into low-res mask input if needed
+            # and feed it as a dense mask prompt into the SAM mask encoder
+            assert len(mask_inputs.shape) == 4 and mask_inputs.shape[:2] == (B, 1)
+            if mask_inputs.shape[-2:] != self.sam_prompt_encoder.mask_input_size:
+                sam_mask_prompt = F.interpolate(
+                    mask_inputs.float(),
+                    size=self.sam_prompt_encoder.mask_input_size,
+                    align_corners=False,
+                    mode="bilinear",
+                    antialias=True,  # use antialias for downsampling
+                )
+            else:
+                sam_mask_prompt = mask_inputs
+        else:
+            # Otherwise, simply feed None (and SAM's prompt encoder will add
+            # a learned `no_mask_embed` to indicate no mask input in this case).
+            sam_mask_prompt = None
+
+        sparse_embeddings, dense_embeddings = self.sam_prompt_encoder(
+            points=(sam_point_coords, sam_point_labels),
+            boxes=None,
+            masks=sam_mask_prompt,
+        )
+        (
+            low_res_multimasks,
+            ious,
+            sam_output_tokens,
+            object_score_logits,
+        ) = self.sam_mask_decoder(
+            image_embeddings=backbone_features,
+            image_pe=self.sam_prompt_encoder.get_dense_pe(),
+            sparse_prompt_embeddings=sparse_embeddings,
+            dense_prompt_embeddings=dense_embeddings,
+            multimask_output=multimask_output,
+            repeat_image=False,  # the image is already batched
+            high_res_features=high_res_features,
+        )
+        if self.pred_obj_scores:
+            is_obj_appearing = object_score_logits > 0
+
+            # Mask used for spatial memories is always a *hard* choice between obj and no obj,
+            # consistent with the actual mask prediction
+            low_res_multimasks = torch.where(
+                is_obj_appearing[:, None, None],
+                low_res_multimasks,
+                NO_OBJ_SCORE,
+            )
+
+        # convert masks from possibly bfloat16 (or float16) to float32
+        # (older PyTorch versions before 2.1 don't support `interpolate` on bf16)
+        low_res_multimasks = low_res_multimasks.float()
+        high_res_multimasks = F.interpolate(
+            low_res_multimasks,
+            size=(self.image_size, self.image_size),
+            mode="bilinear",
+            align_corners=False,
+        )
+
+        sam_output_token = sam_output_tokens[:, 0]
+        if multimask_output:
+            # take the best mask prediction (with the highest IoU estimation)
+            best_iou_inds = torch.argmax(ious, dim=-1)
+            batch_inds = torch.arange(B, device=device)
+            low_res_masks = low_res_multimasks[batch_inds, best_iou_inds].unsqueeze(1)
+            high_res_masks = high_res_multimasks[batch_inds, best_iou_inds].unsqueeze(1)
+            if sam_output_tokens.size(1) > 1:
+                sam_output_token = sam_output_tokens[batch_inds, best_iou_inds]
+        else:
+            low_res_masks, high_res_masks = low_res_multimasks, high_res_multimasks
+
+        # Extract object pointer from the SAM output token (with occlusion handling)
+        obj_ptr = self.obj_ptr_proj(sam_output_token)
+        if self.pred_obj_scores:
+            # Allow *soft* no obj ptr, unlike for masks
+            if self.soft_no_obj_ptr:
+                # Only hard possible with gt
+                assert not self.teacher_force_obj_scores_for_mem
+                lambda_is_obj_appearing = object_score_logits.sigmoid()
+            else:
+                lambda_is_obj_appearing = is_obj_appearing.float()
+
+            if self.fixed_no_obj_ptr:
+                obj_ptr = lambda_is_obj_appearing * obj_ptr
+            obj_ptr = obj_ptr + (1 - lambda_is_obj_appearing) * self.no_obj_ptr
+
+        return (
+            low_res_multimasks,
+            high_res_multimasks,
+            ious,
+            low_res_masks,
+            high_res_masks,
+            obj_ptr,
+            object_score_logits,
+        )
+
+    def _use_mask_as_output(self, backbone_features, high_res_features, mask_inputs):
+        """
+        Directly turn binary `mask_inputs` into a output mask logits without using SAM.
+        (same input and output shapes as in _forward_sam_heads above).
+        """
+        # Use -10/+10 as logits for neg/pos pixels (very close to 0/1 in prob after sigmoid).
+        out_scale, out_bias = 20.0, -10.0  # sigmoid(-10.0)=4.5398e-05
+        mask_inputs_float = mask_inputs.float()
+        high_res_masks = mask_inputs_float * out_scale + out_bias
+        low_res_masks = F.interpolate(
+            high_res_masks,
+            size=(high_res_masks.size(-2) // 4, high_res_masks.size(-1) // 4),
+            align_corners=False,
+            mode="bilinear",
+            antialias=True,  # use antialias for downsampling
+        )
+        # a dummy IoU prediction of all 1's under mask input
+        ious = mask_inputs.new_ones(mask_inputs.size(0), 1).float()
+        if not self.use_obj_ptrs_in_encoder:
+            # all zeros as a dummy object pointer (of shape [B, C])
+            obj_ptr = torch.zeros(
+                mask_inputs.size(0), self.hidden_dim, device=mask_inputs.device
+            )
+        else:
+            # produce an object pointer using the SAM decoder from the mask input
+            _, _, _, _, _, obj_ptr, _ = self._forward_sam_heads(
+                backbone_features=backbone_features,
+                mask_inputs=self.mask_downsample(mask_inputs_float),
+                high_res_features=high_res_features,
+            )
+        # In this method, we are treating mask_input as output, e.g. using it directly to create spatial mem;
+        # Below, we follow the same design axiom to use mask_input to decide if obj appears or not instead of relying
+        # on the object_scores from the SAM decoder.
+        is_obj_appearing = torch.any(mask_inputs.flatten(1).float() > 0.0, dim=1)
+        is_obj_appearing = is_obj_appearing[..., None]
+        lambda_is_obj_appearing = is_obj_appearing.float()
+        object_score_logits = out_scale * lambda_is_obj_appearing + out_bias
+        if self.pred_obj_scores:
+            if self.fixed_no_obj_ptr:
+                obj_ptr = lambda_is_obj_appearing * obj_ptr
+            obj_ptr = obj_ptr + (1 - lambda_is_obj_appearing) * self.no_obj_ptr
+
+        return (
+            low_res_masks,
+            high_res_masks,
+            ious,
+            low_res_masks,
+            high_res_masks,
+            obj_ptr,
+            object_score_logits,
+        )
+
+    def forward_image(self, img_batch: torch.Tensor):
+        """Get the image feature on the input batch."""
+        backbone_out = self.image_encoder(img_batch)
+        if self.use_high_res_features_in_sam:
+            # precompute projected level 0 and level 1 features in SAM decoder
+            # to avoid running it again on every SAM click
+            backbone_out["backbone_fpn"][0] = self.sam_mask_decoder.conv_s0(
+                backbone_out["backbone_fpn"][0]
+            )
+            backbone_out["backbone_fpn"][1] = self.sam_mask_decoder.conv_s1(
+                backbone_out["backbone_fpn"][1]
+            )
+        return backbone_out
+
+    def _prepare_backbone_features(self, backbone_out):
+        """Prepare and flatten visual features."""
+        backbone_out = backbone_out.copy()
+        assert len(backbone_out["backbone_fpn"]) == len(backbone_out["vision_pos_enc"])
+        assert len(backbone_out["backbone_fpn"]) >= self.num_feature_levels
+
+        feature_maps = backbone_out["backbone_fpn"][-self.num_feature_levels :]
+        vision_pos_embeds = backbone_out["vision_pos_enc"][-self.num_feature_levels :]
+
+        feat_sizes = [(x.shape[-2], x.shape[-1]) for x in vision_pos_embeds]
+        # flatten NxCxHxW to HWxNxC
+        vision_feats = [x.flatten(2).permute(2, 0, 1) for x in feature_maps]
+        vision_pos_embeds = [x.flatten(2).permute(2, 0, 1) for x in vision_pos_embeds]
+
+        return backbone_out, vision_feats, vision_pos_embeds, feat_sizes
+
+    def _prepare_memory_conditioned_features(
+        self,
+        frame_idx,
+        is_init_cond_frame,
+        current_vision_feats,
+        current_vision_pos_embeds,
+        feat_sizes,
+        output_dict,
+        num_frames,
+        track_in_reverse=False,  # tracking in reverse time order (for demo usage)
+    ):
+        """Fuse the current frame's visual feature map with previous memory."""
+        B = current_vision_feats[-1].size(1)  # batch size on this frame
+        C = self.hidden_dim
+        H, W = feat_sizes[-1]  # top-level (lowest-resolution) feature size
+        device = current_vision_feats[-1].device
+        # The case of `self.num_maskmem == 0` below is primarily used for reproducing SAM on images.
+        # In this case, we skip the fusion with any memory.
+        if self.num_maskmem == 0:  # Disable memory and skip fusion
+            pix_feat = current_vision_feats[-1].permute(1, 2, 0).view(B, C, H, W)
+            return pix_feat
+
+        num_obj_ptr_tokens = 0
+        # Step 1: condition the visual features of the current frame on previous memories
+        if not is_init_cond_frame:
+            # Retrieve the memories encoded with the maskmem backbone
+            to_cat_memory, to_cat_memory_pos_embed = [], []
+            # Add conditioning frames's output first (all cond frames have t_pos=0 for
+            # when getting temporal positional embedding below)
+            assert len(output_dict["cond_frame_outputs"]) > 0
+            # Select a maximum number of temporally closest cond frames for cross attention
+            cond_outputs = output_dict["cond_frame_outputs"]
+            selected_cond_outputs, unselected_cond_outputs = select_closest_cond_frames(
+                frame_idx, cond_outputs, self.max_cond_frames_in_attn
+            )
+            t_pos_and_prevs = [(0, out) for out in selected_cond_outputs.values()]
+            # Add last (self.num_maskmem - 1) frames before current frame for non-conditioning memory
+            # the earliest one has t_pos=1 and the latest one has t_pos=self.num_maskmem-1
+            # We also allow taking the memory frame non-consecutively (with r>1), in which case
+            # we take (self.num_maskmem - 2) frames among every r-th frames plus the last frame.
+            r = self.memory_temporal_stride_for_eval
+            for t_pos in range(1, self.num_maskmem):
+                t_rel = self.num_maskmem - t_pos  # how many frames before current frame
+                if t_rel == 1:
+                    # for t_rel == 1, we take the last frame (regardless of r)
+                    if not track_in_reverse:
+                        # the frame immediately before this frame (i.e. frame_idx - 1)
+                        prev_frame_idx = frame_idx - t_rel
+                    else:
+                        # the frame immediately after this frame (i.e. frame_idx + 1)
+                        prev_frame_idx = frame_idx + t_rel
+                else:
+                    # for t_rel >= 2, we take the memory frame from every r-th frames
+                    if not track_in_reverse:
+                        # first find the nearest frame among every r-th frames before this frame
+                        # for r=1, this would be (frame_idx - 2)
+                        prev_frame_idx = ((frame_idx - 2) // r) * r
+                        # then seek further among every r-th frames
+                        prev_frame_idx = prev_frame_idx - (t_rel - 2) * r
+                    else:
+                        # first find the nearest frame among every r-th frames after this frame
+                        # for r=1, this would be (frame_idx + 2)
+                        prev_frame_idx = -(-(frame_idx + 2) // r) * r
+                        # then seek further among every r-th frames
+                        prev_frame_idx = prev_frame_idx + (t_rel - 2) * r
+                out = output_dict["non_cond_frame_outputs"].get(prev_frame_idx, None)
+                if out is None:
+                    # If an unselected conditioning frame is among the last (self.num_maskmem - 1)
+                    # frames, we still attend to it as if it's a non-conditioning frame.
+                    out = unselected_cond_outputs.get(prev_frame_idx, None)
+                t_pos_and_prevs.append((t_pos, out))
+
+            for t_pos, prev in t_pos_and_prevs:
+                if prev is None:
+                    continue  # skip padding frames
+                # "maskmem_features" might have been offloaded to CPU in demo use cases,
+                # so we load it back to GPU (it's a no-op if it's already on GPU).
+                feats = prev["maskmem_features"].cuda(non_blocking=True)
+                to_cat_memory.append(feats.flatten(2).permute(2, 0, 1))
+                # Spatial positional encoding (it might have been offloaded to CPU in eval)
+                maskmem_enc = prev["maskmem_pos_enc"][-1].cuda()
+                maskmem_enc = maskmem_enc.flatten(2).permute(2, 0, 1)
+                # Temporal positional encoding
+                maskmem_enc = (
+                    maskmem_enc + self.maskmem_tpos_enc[self.num_maskmem - t_pos - 1]
+                )
+                to_cat_memory_pos_embed.append(maskmem_enc)
+
+            # Construct the list of past object pointers
+            if self.use_obj_ptrs_in_encoder:
+                max_obj_ptrs_in_encoder = min(num_frames, self.max_obj_ptrs_in_encoder)
+                # First add those object pointers from selected conditioning frames
+                # (optionally, only include object pointers in the past during evaluation)
+                if not self.training and self.only_obj_ptrs_in_the_past_for_eval:
+                    ptr_cond_outputs = {
+                        t: out
+                        for t, out in selected_cond_outputs.items()
+                        if (t >= frame_idx if track_in_reverse else t <= frame_idx)
+                    }
+                else:
+                    ptr_cond_outputs = selected_cond_outputs
+                pos_and_ptrs = [
+                    # Temporal pos encoding contains how far away each pointer is from current frame
+                    (abs(frame_idx - t), out["obj_ptr"])
+                    for t, out in ptr_cond_outputs.items()
+                ]
+                # Add up to (max_obj_ptrs_in_encoder - 1) non-conditioning frames before current frame
+                for t_diff in range(1, max_obj_ptrs_in_encoder):
+                    t = frame_idx + t_diff if track_in_reverse else frame_idx - t_diff
+                    if t < 0 or (num_frames is not None and t >= num_frames):
+                        break
+                    out = output_dict["non_cond_frame_outputs"].get(
+                        t, unselected_cond_outputs.get(t, None)
+                    )
+                    if out is not None:
+                        pos_and_ptrs.append((t_diff, out["obj_ptr"]))
+                # If we have at least one object pointer, add them to the across attention
+                if len(pos_and_ptrs) > 0:
+                    pos_list, ptrs_list = zip(*pos_and_ptrs)
+                    # stack object pointers along dim=0 into [ptr_seq_len, B, C] shape
+                    obj_ptrs = torch.stack(ptrs_list, dim=0)
+                    # a temporal positional embedding based on how far each object pointer is from
+                    # the current frame (sine embedding normalized by the max pointer num).
+                    if self.add_tpos_enc_to_obj_ptrs:
+                        t_diff_max = max_obj_ptrs_in_encoder - 1
+                        tpos_dim = C if self.proj_tpos_enc_in_obj_ptrs else self.mem_dim
+                        obj_pos = torch.tensor(pos_list, device=device)
+                        obj_pos = get_1d_sine_pe(obj_pos / t_diff_max, dim=tpos_dim)
+                        obj_pos = self.obj_ptr_tpos_proj(obj_pos)
+                        obj_pos = obj_pos.unsqueeze(1).expand(-1, B, self.mem_dim)
+                    else:
+                        obj_pos = obj_ptrs.new_zeros(len(pos_list), B, self.mem_dim)
+                    if self.mem_dim < C:
+                        # split a pointer into (C // self.mem_dim) tokens for self.mem_dim < C
+                        obj_ptrs = obj_ptrs.reshape(
+                            -1, B, C // self.mem_dim, self.mem_dim
+                        )
+                        obj_ptrs = obj_ptrs.permute(0, 2, 1, 3).flatten(0, 1)
+                        obj_pos = obj_pos.repeat_interleave(C // self.mem_dim, dim=0)
+                    to_cat_memory.append(obj_ptrs)
+                    to_cat_memory_pos_embed.append(obj_pos)
+                    num_obj_ptr_tokens = obj_ptrs.shape[0]
+                else:
+                    num_obj_ptr_tokens = 0
+        else:
+            # for initial conditioning frames, encode them without using any previous memory
+            if self.directly_add_no_mem_embed:
+                # directly add no-mem embedding (instead of using the transformer encoder)
+                pix_feat_with_mem = current_vision_feats[-1] + self.no_mem_embed
+                pix_feat_with_mem = pix_feat_with_mem.permute(1, 2, 0).view(B, C, H, W)
+                return pix_feat_with_mem
+
+            # Use a dummy token on the first frame (to avoid emtpy memory input to tranformer encoder)
+            to_cat_memory = [self.no_mem_embed.expand(1, B, self.mem_dim)]
+            to_cat_memory_pos_embed = [self.no_mem_pos_enc.expand(1, B, self.mem_dim)]
+
+        # Step 2: Concatenate the memories and forward through the transformer encoder
+        memory = torch.cat(to_cat_memory, dim=0)
+        memory_pos_embed = torch.cat(to_cat_memory_pos_embed, dim=0)
+
+        pix_feat_with_mem = self.memory_attention(
+            curr=current_vision_feats,
+            curr_pos=current_vision_pos_embeds,
+            memory=memory,
+            memory_pos=memory_pos_embed,
+            num_obj_ptr_tokens=num_obj_ptr_tokens,
+        )
+        # reshape the output (HW)BC => BCHW
+        pix_feat_with_mem = pix_feat_with_mem.permute(1, 2, 0).view(B, C, H, W)
+        return pix_feat_with_mem
+
+    def _encode_new_memory(
+        self,
+        current_vision_feats,
+        feat_sizes,
+        pred_masks_high_res,
+        is_mask_from_pts,
+    ):
+        """Encode the current image and its prediction into a memory feature."""
+        B = current_vision_feats[-1].size(1)  # batch size on this frame
+        C = self.hidden_dim
+        H, W = feat_sizes[-1]  # top-level (lowest-resolution) feature size
+        # top-level feature, (HW)BC => BCHW
+        pix_feat = current_vision_feats[-1].permute(1, 2, 0).view(B, C, H, W)
+        if self.non_overlap_masks_for_mem_enc and not self.training:
+            # optionally, apply non-overlapping constraints to the masks (it's applied
+            # in the batch dimension and should only be used during eval, where all
+            # the objects come from the same video under batch size 1).
+            pred_masks_high_res = self._apply_non_overlapping_constraints(
+                pred_masks_high_res
+            )
+        # scale the raw mask logits with a temperature before applying sigmoid
+        binarize = self.binarize_mask_from_pts_for_mem_enc and is_mask_from_pts
+        if binarize and not self.training:
+            mask_for_mem = (pred_masks_high_res > 0).float()
+        else:
+            # apply sigmoid on the raw mask logits to turn them into range (0, 1)
+            mask_for_mem = torch.sigmoid(pred_masks_high_res)
+        # apply scale and bias terms to the sigmoid probabilities
+        if self.sigmoid_scale_for_mem_enc != 1.0:
+            mask_for_mem = mask_for_mem * self.sigmoid_scale_for_mem_enc
+        if self.sigmoid_bias_for_mem_enc != 0.0:
+            mask_for_mem = mask_for_mem + self.sigmoid_bias_for_mem_enc
+        maskmem_out = self.memory_encoder(
+            pix_feat, mask_for_mem, skip_mask_sigmoid=True  # sigmoid already applied
+        )
+        maskmem_features = maskmem_out["vision_features"]
+        maskmem_pos_enc = maskmem_out["vision_pos_enc"]
+
+        return maskmem_features, maskmem_pos_enc
+
+    def track_step(
+        self,
+        frame_idx,
+        is_init_cond_frame,
+        current_vision_feats,
+        current_vision_pos_embeds,
+        feat_sizes,
+        point_inputs,
+        mask_inputs,
+        output_dict,
+        num_frames,
+        track_in_reverse=False,  # tracking in reverse time order (for demo usage)
+        # Whether to run the memory encoder on the predicted masks. Sometimes we might want
+        # to skip the memory encoder with `run_mem_encoder=False`. For example,
+        # in demo we might call `track_step` multiple times for each user click,
+        # and only encode the memory when the user finalizes their clicks. And in ablation
+        # settings like SAM training on static images, we don't need the memory encoder.
+        run_mem_encoder=True,
+        # The previously predicted SAM mask logits (which can be fed together with new clicks in demo).
+        prev_sam_mask_logits=None,
+    ):
+        current_out = {"point_inputs": point_inputs, "mask_inputs": mask_inputs}
+        # High-resolution feature maps for the SAM head, reshape (HW)BC => BCHW
+        if len(current_vision_feats) > 1:
+            high_res_features = [
+                x.permute(1, 2, 0).view(x.size(1), x.size(2), *s)
+                for x, s in zip(current_vision_feats[:-1], feat_sizes[:-1])
+            ]
+        else:
+            high_res_features = None
+        if mask_inputs is not None and self.use_mask_input_as_output_without_sam:
+            # When use_mask_input_as_output_without_sam=True, we directly output the mask input
+            # (see it as a GT mask) without using a SAM prompt encoder + mask decoder.
+            pix_feat = current_vision_feats[-1].permute(1, 2, 0)
+            pix_feat = pix_feat.view(-1, self.hidden_dim, *feat_sizes[-1])
+            sam_outputs = self._use_mask_as_output(
+                pix_feat, high_res_features, mask_inputs
+            )
+        else:
+            # fused the visual feature with previous memory features in the memory bank
+            pix_feat_with_mem = self._prepare_memory_conditioned_features(
+                frame_idx=frame_idx,
+                is_init_cond_frame=is_init_cond_frame,
+                current_vision_feats=current_vision_feats[-1:],
+                current_vision_pos_embeds=current_vision_pos_embeds[-1:],
+                feat_sizes=feat_sizes[-1:],
+                output_dict=output_dict,
+                num_frames=num_frames,
+                track_in_reverse=track_in_reverse,
+            )
+            # apply SAM-style segmentation head
+            # here we might feed previously predicted low-res SAM mask logits into the SAM mask decoder,
+            # e.g. in demo where such logits come from earlier interaction instead of correction sampling
+            # (in this case, any `mask_inputs` shouldn't reach here as they are sent to _use_mask_as_output instead)
+            if prev_sam_mask_logits is not None:
+                assert point_inputs is not None and mask_inputs is None
+                mask_inputs = prev_sam_mask_logits
+            multimask_output = self._use_multimask(is_init_cond_frame, point_inputs)
+            sam_outputs = self._forward_sam_heads(
+                backbone_features=pix_feat_with_mem,
+                point_inputs=point_inputs,
+                mask_inputs=mask_inputs,
+                high_res_features=high_res_features,
+                multimask_output=multimask_output,
+            )
+        (
+            _,
+            _,
+            _,
+            low_res_masks,
+            high_res_masks,
+            obj_ptr,
+            _,
+        ) = sam_outputs
+
+        current_out["pred_masks"] = low_res_masks
+        current_out["pred_masks_high_res"] = high_res_masks
+        current_out["obj_ptr"] = obj_ptr
+
+        # Finally run the memory encoder on the predicted mask to encode
+        # it into a new memory feature (that can be used in future frames)
+        if run_mem_encoder and self.num_maskmem > 0:
+            high_res_masks_for_mem_enc = high_res_masks
+            maskmem_features, maskmem_pos_enc = self._encode_new_memory(
+                current_vision_feats=current_vision_feats,
+                feat_sizes=feat_sizes,
+                pred_masks_high_res=high_res_masks_for_mem_enc,
+                is_mask_from_pts=(point_inputs is not None),
+            )
+            current_out["maskmem_features"] = maskmem_features
+            current_out["maskmem_pos_enc"] = maskmem_pos_enc
+        else:
+            current_out["maskmem_features"] = None
+            current_out["maskmem_pos_enc"] = None
+
+        return current_out
+
+    def _use_multimask(self, is_init_cond_frame, point_inputs):
+        """Whether to use multimask output in the SAM head."""
+        num_pts = 0 if point_inputs is None else point_inputs["point_labels"].size(1)
+        multimask_output = (
+            self.multimask_output_in_sam
+            and (is_init_cond_frame or self.multimask_output_for_tracking)
+            and (self.multimask_min_pt_num <= num_pts <= self.multimask_max_pt_num)
+        )
+        return multimask_output
+
+    def _apply_non_overlapping_constraints(self, pred_masks):
+        """
+        Apply non-overlapping constraints to the object scores in pred_masks. Here we
+        keep only the highest scoring object at each spatial location in pred_masks.
+        """
+        batch_size = pred_masks.size(0)
+        if batch_size == 1:
+            return pred_masks
+
+        device = pred_masks.device
+        # "max_obj_inds": object index of the object with the highest score at each location
+        max_obj_inds = torch.argmax(pred_masks, dim=0, keepdim=True)
+        # "batch_obj_inds": object index of each object slice (along dim 0) in `pred_masks`
+        batch_obj_inds = torch.arange(batch_size, device=device)[:, None, None, None]
+        keep = max_obj_inds == batch_obj_inds
+        # suppress overlapping regions' scores below -10.0 so that the foreground regions
+        # don't overlap (here sigmoid(-10.0)=4.5398e-05)
+        pred_masks = torch.where(keep, pred_masks, torch.clamp(pred_masks, max=-10.0))
+        return pred_masks
diff --git a/sam2_unet/sam2/modeling/sam2_utils.py b/sam2_unet/sam2/modeling/sam2_utils.py
new file mode 100644
index 0000000..6d97059
--- /dev/null
+++ b/sam2_unet/sam2/modeling/sam2_utils.py
@@ -0,0 +1,149 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+import copy
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+def select_closest_cond_frames(frame_idx, cond_frame_outputs, max_cond_frame_num):
+    """
+    Select up to `max_cond_frame_num` conditioning frames from `cond_frame_outputs`
+    that are temporally closest to the current frame at `frame_idx`. Here, we take
+    - a) the closest conditioning frame before `frame_idx` (if any);
+    - b) the closest conditioning frame after `frame_idx` (if any);
+    - c) any other temporally closest conditioning frames until reaching a total
+         of `max_cond_frame_num` conditioning frames.
+
+    Outputs:
+    - selected_outputs: selected items (keys & values) from `cond_frame_outputs`.
+    - unselected_outputs: items (keys & values) not selected in `cond_frame_outputs`.
+    """
+    if max_cond_frame_num == -1 or len(cond_frame_outputs) <= max_cond_frame_num:
+        selected_outputs = cond_frame_outputs
+        unselected_outputs = {}
+    else:
+        assert max_cond_frame_num >= 2, "we should allow using 2+ conditioning frames"
+        selected_outputs = {}
+
+        # the closest conditioning frame before `frame_idx` (if any)
+        idx_before = max((t for t in cond_frame_outputs if t < frame_idx), default=None)
+        if idx_before is not None:
+            selected_outputs[idx_before] = cond_frame_outputs[idx_before]
+
+        # the closest conditioning frame after `frame_idx` (if any)
+        idx_after = min((t for t in cond_frame_outputs if t >= frame_idx), default=None)
+        if idx_after is not None:
+            selected_outputs[idx_after] = cond_frame_outputs[idx_after]
+
+        # add other temporally closest conditioning frames until reaching a total
+        # of `max_cond_frame_num` conditioning frames.
+        num_remain = max_cond_frame_num - len(selected_outputs)
+        inds_remain = sorted(
+            (t for t in cond_frame_outputs if t not in selected_outputs),
+            key=lambda x: abs(x - frame_idx),
+        )[:num_remain]
+        selected_outputs.update((t, cond_frame_outputs[t]) for t in inds_remain)
+        unselected_outputs = {
+            t: v for t, v in cond_frame_outputs.items() if t not in selected_outputs
+        }
+
+    return selected_outputs, unselected_outputs
+
+
+def get_1d_sine_pe(pos_inds, dim, temperature=10000):
+    """
+    Get 1D sine positional embedding as in the original Transformer paper.
+    """
+    pe_dim = dim // 2
+    dim_t = torch.arange(pe_dim, dtype=torch.float32, device=pos_inds.device)
+    dim_t = temperature ** (2 * (dim_t // 2) / pe_dim)
+
+    pos_embed = pos_inds.unsqueeze(-1) / dim_t
+    pos_embed = torch.cat([pos_embed.sin(), pos_embed.cos()], dim=-1)
+    return pos_embed
+
+
+def get_activation_fn(activation):
+    """Return an activation function given a string"""
+    if activation == "relu":
+        return F.relu
+    if activation == "gelu":
+        return F.gelu
+    if activation == "glu":
+        return F.glu
+    raise RuntimeError(f"activation should be relu/gelu, not {activation}.")
+
+
+def get_clones(module, N):
+    return nn.ModuleList([copy.deepcopy(module) for i in range(N)])
+
+
+class DropPath(nn.Module):
+    # adapted from https://github.com/huggingface/pytorch-image-models/blob/main/timm/layers/drop.py
+    def __init__(self, drop_prob=0.0, scale_by_keep=True):
+        super(DropPath, self).__init__()
+        self.drop_prob = drop_prob
+        self.scale_by_keep = scale_by_keep
+
+    def forward(self, x):
+        if self.drop_prob == 0.0 or not self.training:
+            return x
+        keep_prob = 1 - self.drop_prob
+        shape = (x.shape[0],) + (1,) * (x.ndim - 1)
+        random_tensor = x.new_empty(shape).bernoulli_(keep_prob)
+        if keep_prob > 0.0 and self.scale_by_keep:
+            random_tensor.div_(keep_prob)
+        return x * random_tensor
+
+
+# Lightly adapted from
+# https://github.com/facebookresearch/MaskFormer/blob/main/mask_former/modeling/transformer/transformer_predictor.py # noqa
+class MLP(nn.Module):
+    def __init__(
+        self,
+        input_dim: int,
+        hidden_dim: int,
+        output_dim: int,
+        num_layers: int,
+        activation: nn.Module = nn.ReLU,
+        sigmoid_output: bool = False,
+    ) -> None:
+        super().__init__()
+        self.num_layers = num_layers
+        h = [hidden_dim] * (num_layers - 1)
+        self.layers = nn.ModuleList(
+            nn.Linear(n, k) for n, k in zip([input_dim] + h, h + [output_dim])
+        )
+        self.sigmoid_output = sigmoid_output
+        self.act = activation()
+
+    def forward(self, x):
+        for i, layer in enumerate(self.layers):
+            x = self.act(layer(x)) if i < self.num_layers - 1 else layer(x)
+        if self.sigmoid_output:
+            x = F.sigmoid(x)
+        return x
+
+
+# From https://github.com/facebookresearch/detectron2/blob/main/detectron2/layers/batch_norm.py # noqa
+# Itself from https://github.com/facebookresearch/ConvNeXt/blob/d1fa8f6fef0a165b27399986cc2bdacc92777e40/models/convnext.py#L119  # noqa
+class LayerNorm2d(nn.Module):
+    def __init__(self, num_channels: int, eps: float = 1e-6) -> None:
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(num_channels))
+        self.bias = nn.Parameter(torch.zeros(num_channels))
+        self.eps = eps
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        u = x.mean(1, keepdim=True)
+        s = (x - u).pow(2).mean(1, keepdim=True)
+        x = (x - u) / torch.sqrt(s + self.eps)
+        x = self.weight[:, None, None] * x + self.bias[:, None, None]
+        return x
diff --git a/sam2_unet/sam2/utils/__init__.py b/sam2_unet/sam2/utils/__init__.py
new file mode 100644
index 0000000..5277f46
--- /dev/null
+++ b/sam2_unet/sam2/utils/__init__.py
@@ -0,0 +1,5 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
diff --git a/sam2_unet/sam2/utils/amg.py b/sam2_unet/sam2/utils/amg.py
new file mode 100644
index 0000000..9868429
--- /dev/null
+++ b/sam2_unet/sam2/utils/amg.py
@@ -0,0 +1,348 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import math
+from copy import deepcopy
+from itertools import product
+from typing import Any, Dict, Generator, ItemsView, List, Tuple
+
+import numpy as np
+import torch
+
+# Very lightly adapted from https://github.com/facebookresearch/segment-anything/blob/main/segment_anything/utils/amg.py
+
+
+class MaskData:
+    """
+    A structure for storing masks and their related data in batched format.
+    Implements basic filtering and concatenation.
+    """
+
+    def __init__(self, **kwargs) -> None:
+        for v in kwargs.values():
+            assert isinstance(
+                v, (list, np.ndarray, torch.Tensor)
+            ), "MaskData only supports list, numpy arrays, and torch tensors."
+        self._stats = dict(**kwargs)
+
+    def __setitem__(self, key: str, item: Any) -> None:
+        assert isinstance(
+            item, (list, np.ndarray, torch.Tensor)
+        ), "MaskData only supports list, numpy arrays, and torch tensors."
+        self._stats[key] = item
+
+    def __delitem__(self, key: str) -> None:
+        del self._stats[key]
+
+    def __getitem__(self, key: str) -> Any:
+        return self._stats[key]
+
+    def items(self) -> ItemsView[str, Any]:
+        return self._stats.items()
+
+    def filter(self, keep: torch.Tensor) -> None:
+        for k, v in self._stats.items():
+            if v is None:
+                self._stats[k] = None
+            elif isinstance(v, torch.Tensor):
+                self._stats[k] = v[torch.as_tensor(keep, device=v.device)]
+            elif isinstance(v, np.ndarray):
+                self._stats[k] = v[keep.detach().cpu().numpy()]
+            elif isinstance(v, list) and keep.dtype == torch.bool:
+                self._stats[k] = [a for i, a in enumerate(v) if keep[i]]
+            elif isinstance(v, list):
+                self._stats[k] = [v[i] for i in keep]
+            else:
+                raise TypeError(f"MaskData key {k} has an unsupported type {type(v)}.")
+
+    def cat(self, new_stats: "MaskData") -> None:
+        for k, v in new_stats.items():
+            if k not in self._stats or self._stats[k] is None:
+                self._stats[k] = deepcopy(v)
+            elif isinstance(v, torch.Tensor):
+                self._stats[k] = torch.cat([self._stats[k], v], dim=0)
+            elif isinstance(v, np.ndarray):
+                self._stats[k] = np.concatenate([self._stats[k], v], axis=0)
+            elif isinstance(v, list):
+                self._stats[k] = self._stats[k] + deepcopy(v)
+            else:
+                raise TypeError(f"MaskData key {k} has an unsupported type {type(v)}.")
+
+    def to_numpy(self) -> None:
+        for k, v in self._stats.items():
+            if isinstance(v, torch.Tensor):
+                self._stats[k] = v.float().detach().cpu().numpy()
+
+
+def is_box_near_crop_edge(
+    boxes: torch.Tensor, crop_box: List[int], orig_box: List[int], atol: float = 20.0
+) -> torch.Tensor:
+    """Filter masks at the edge of a crop, but not at the edge of the original image."""
+    crop_box_torch = torch.as_tensor(crop_box, dtype=torch.float, device=boxes.device)
+    orig_box_torch = torch.as_tensor(orig_box, dtype=torch.float, device=boxes.device)
+    boxes = uncrop_boxes_xyxy(boxes, crop_box).float()
+    near_crop_edge = torch.isclose(boxes, crop_box_torch[None, :], atol=atol, rtol=0)
+    near_image_edge = torch.isclose(boxes, orig_box_torch[None, :], atol=atol, rtol=0)
+    near_crop_edge = torch.logical_and(near_crop_edge, ~near_image_edge)
+    return torch.any(near_crop_edge, dim=1)
+
+
+def box_xyxy_to_xywh(box_xyxy: torch.Tensor) -> torch.Tensor:
+    box_xywh = deepcopy(box_xyxy)
+    box_xywh[2] = box_xywh[2] - box_xywh[0]
+    box_xywh[3] = box_xywh[3] - box_xywh[1]
+    return box_xywh
+
+
+def batch_iterator(batch_size: int, *args) -> Generator[List[Any], None, None]:
+    assert len(args) > 0 and all(
+        len(a) == len(args[0]) for a in args
+    ), "Batched iteration must have inputs of all the same size."
+    n_batches = len(args[0]) // batch_size + int(len(args[0]) % batch_size != 0)
+    for b in range(n_batches):
+        yield [arg[b * batch_size : (b + 1) * batch_size] for arg in args]
+
+
+def mask_to_rle_pytorch(tensor: torch.Tensor) -> List[Dict[str, Any]]:
+    """
+    Encodes masks to an uncompressed RLE, in the format expected by
+    pycoco tools.
+    """
+    # Put in fortran order and flatten h,w
+    b, h, w = tensor.shape
+    tensor = tensor.permute(0, 2, 1).flatten(1)
+
+    # Compute change indices
+    diff = tensor[:, 1:] ^ tensor[:, :-1]
+    change_indices = diff.nonzero()
+
+    # Encode run length
+    out = []
+    for i in range(b):
+        cur_idxs = change_indices[change_indices[:, 0] == i, 1]
+        cur_idxs = torch.cat(
+            [
+                torch.tensor([0], dtype=cur_idxs.dtype, device=cur_idxs.device),
+                cur_idxs + 1,
+                torch.tensor([h * w], dtype=cur_idxs.dtype, device=cur_idxs.device),
+            ]
+        )
+        btw_idxs = cur_idxs[1:] - cur_idxs[:-1]
+        counts = [] if tensor[i, 0] == 0 else [0]
+        counts.extend(btw_idxs.detach().cpu().tolist())
+        out.append({"size": [h, w], "counts": counts})
+    return out
+
+
+def rle_to_mask(rle: Dict[str, Any]) -> np.ndarray:
+    """Compute a binary mask from an uncompressed RLE."""
+    h, w = rle["size"]
+    mask = np.empty(h * w, dtype=bool)
+    idx = 0
+    parity = False
+    for count in rle["counts"]:
+        mask[idx : idx + count] = parity
+        idx += count
+        parity ^= True
+    mask = mask.reshape(w, h)
+    return mask.transpose()  # Put in C order
+
+
+def area_from_rle(rle: Dict[str, Any]) -> int:
+    return sum(rle["counts"][1::2])
+
+
+def calculate_stability_score(
+    masks: torch.Tensor, mask_threshold: float, threshold_offset: float
+) -> torch.Tensor:
+    """
+    Computes the stability score for a batch of masks. The stability
+    score is the IoU between the binary masks obtained by thresholding
+    the predicted mask logits at high and low values.
+    """
+    # One mask is always contained inside the other.
+    # Save memory by preventing unnecessary cast to torch.int64
+    intersections = (
+        (masks > (mask_threshold + threshold_offset))
+        .sum(-1, dtype=torch.int16)
+        .sum(-1, dtype=torch.int32)
+    )
+    unions = (
+        (masks > (mask_threshold - threshold_offset))
+        .sum(-1, dtype=torch.int16)
+        .sum(-1, dtype=torch.int32)
+    )
+    return intersections / unions
+
+
+def build_point_grid(n_per_side: int) -> np.ndarray:
+    """Generates a 2D grid of points evenly spaced in [0,1]x[0,1]."""
+    offset = 1 / (2 * n_per_side)
+    points_one_side = np.linspace(offset, 1 - offset, n_per_side)
+    points_x = np.tile(points_one_side[None, :], (n_per_side, 1))
+    points_y = np.tile(points_one_side[:, None], (1, n_per_side))
+    points = np.stack([points_x, points_y], axis=-1).reshape(-1, 2)
+    return points
+
+
+def build_all_layer_point_grids(
+    n_per_side: int, n_layers: int, scale_per_layer: int
+) -> List[np.ndarray]:
+    """Generates point grids for all crop layers."""
+    points_by_layer = []
+    for i in range(n_layers + 1):
+        n_points = int(n_per_side / (scale_per_layer**i))
+        points_by_layer.append(build_point_grid(n_points))
+    return points_by_layer
+
+
+def generate_crop_boxes(
+    im_size: Tuple[int, ...], n_layers: int, overlap_ratio: float
+) -> Tuple[List[List[int]], List[int]]:
+    """
+    Generates a list of crop boxes of different sizes. Each layer
+    has (2**i)**2 boxes for the ith layer.
+    """
+    crop_boxes, layer_idxs = [], []
+    im_h, im_w = im_size
+    short_side = min(im_h, im_w)
+
+    # Original image
+    crop_boxes.append([0, 0, im_w, im_h])
+    layer_idxs.append(0)
+
+    def crop_len(orig_len, n_crops, overlap):
+        return int(math.ceil((overlap * (n_crops - 1) + orig_len) / n_crops))
+
+    for i_layer in range(n_layers):
+        n_crops_per_side = 2 ** (i_layer + 1)
+        overlap = int(overlap_ratio * short_side * (2 / n_crops_per_side))
+
+        crop_w = crop_len(im_w, n_crops_per_side, overlap)
+        crop_h = crop_len(im_h, n_crops_per_side, overlap)
+
+        crop_box_x0 = [int((crop_w - overlap) * i) for i in range(n_crops_per_side)]
+        crop_box_y0 = [int((crop_h - overlap) * i) for i in range(n_crops_per_side)]
+
+        # Crops in XYWH format
+        for x0, y0 in product(crop_box_x0, crop_box_y0):
+            box = [x0, y0, min(x0 + crop_w, im_w), min(y0 + crop_h, im_h)]
+            crop_boxes.append(box)
+            layer_idxs.append(i_layer + 1)
+
+    return crop_boxes, layer_idxs
+
+
+def uncrop_boxes_xyxy(boxes: torch.Tensor, crop_box: List[int]) -> torch.Tensor:
+    x0, y0, _, _ = crop_box
+    offset = torch.tensor([[x0, y0, x0, y0]], device=boxes.device)
+    # Check if boxes has a channel dimension
+    if len(boxes.shape) == 3:
+        offset = offset.unsqueeze(1)
+    return boxes + offset
+
+
+def uncrop_points(points: torch.Tensor, crop_box: List[int]) -> torch.Tensor:
+    x0, y0, _, _ = crop_box
+    offset = torch.tensor([[x0, y0]], device=points.device)
+    # Check if points has a channel dimension
+    if len(points.shape) == 3:
+        offset = offset.unsqueeze(1)
+    return points + offset
+
+
+def uncrop_masks(
+    masks: torch.Tensor, crop_box: List[int], orig_h: int, orig_w: int
+) -> torch.Tensor:
+    x0, y0, x1, y1 = crop_box
+    if x0 == 0 and y0 == 0 and x1 == orig_w and y1 == orig_h:
+        return masks
+    # Coordinate transform masks
+    pad_x, pad_y = orig_w - (x1 - x0), orig_h - (y1 - y0)
+    pad = (x0, pad_x - x0, y0, pad_y - y0)
+    return torch.nn.functional.pad(masks, pad, value=0)
+
+
+def remove_small_regions(
+    mask: np.ndarray, area_thresh: float, mode: str
+) -> Tuple[np.ndarray, bool]:
+    """
+    Removes small disconnected regions and holes in a mask. Returns the
+    mask and an indicator of if the mask has been modified.
+    """
+    import cv2  # type: ignore
+
+    assert mode in ["holes", "islands"]
+    correct_holes = mode == "holes"
+    working_mask = (correct_holes ^ mask).astype(np.uint8)
+    n_labels, regions, stats, _ = cv2.connectedComponentsWithStats(working_mask, 8)
+    sizes = stats[:, -1][1:]  # Row 0 is background label
+    small_regions = [i + 1 for i, s in enumerate(sizes) if s < area_thresh]
+    if len(small_regions) == 0:
+        return mask, False
+    fill_labels = [0] + small_regions
+    if not correct_holes:
+        fill_labels = [i for i in range(n_labels) if i not in fill_labels]
+        # If every region is below threshold, keep largest
+        if len(fill_labels) == 0:
+            fill_labels = [int(np.argmax(sizes)) + 1]
+    mask = np.isin(regions, fill_labels)
+    return mask, True
+
+
+def coco_encode_rle(uncompressed_rle: Dict[str, Any]) -> Dict[str, Any]:
+    from pycocotools import mask as mask_utils  # type: ignore
+
+    h, w = uncompressed_rle["size"]
+    rle = mask_utils.frPyObjects(uncompressed_rle, h, w)
+    rle["counts"] = rle["counts"].decode("utf-8")  # Necessary to serialize with json
+    return rle
+
+
+def batched_mask_to_box(masks: torch.Tensor) -> torch.Tensor:
+    """
+    Calculates boxes in XYXY format around masks. Return [0,0,0,0] for
+    an empty mask. For input shape C1xC2x...xHxW, the output shape is C1xC2x...x4.
+    """
+    # torch.max below raises an error on empty inputs, just skip in this case
+    if torch.numel(masks) == 0:
+        return torch.zeros(*masks.shape[:-2], 4, device=masks.device)
+
+    # Normalize shape to CxHxW
+    shape = masks.shape
+    h, w = shape[-2:]
+    if len(shape) > 2:
+        masks = masks.flatten(0, -3)
+    else:
+        masks = masks.unsqueeze(0)
+
+    # Get top and bottom edges
+    in_height, _ = torch.max(masks, dim=-1)
+    in_height_coords = in_height * torch.arange(h, device=in_height.device)[None, :]
+    bottom_edges, _ = torch.max(in_height_coords, dim=-1)
+    in_height_coords = in_height_coords + h * (~in_height)
+    top_edges, _ = torch.min(in_height_coords, dim=-1)
+
+    # Get left and right edges
+    in_width, _ = torch.max(masks, dim=-2)
+    in_width_coords = in_width * torch.arange(w, device=in_width.device)[None, :]
+    right_edges, _ = torch.max(in_width_coords, dim=-1)
+    in_width_coords = in_width_coords + w * (~in_width)
+    left_edges, _ = torch.min(in_width_coords, dim=-1)
+
+    # If the mask is empty the right edge will be to the left of the left edge.
+    # Replace these boxes with [0, 0, 0, 0]
+    empty_filter = (right_edges < left_edges) | (bottom_edges < top_edges)
+    out = torch.stack([left_edges, top_edges, right_edges, bottom_edges], dim=-1)
+    out = out * (~empty_filter).unsqueeze(-1)
+
+    # Return to original shape
+    if len(shape) > 2:
+        out = out.reshape(*shape[:-2], 4)
+    else:
+        out = out[0]
+
+    return out
diff --git a/sam2_unet/sam2/utils/misc.py b/sam2_unet/sam2/utils/misc.py
new file mode 100644
index 0000000..bf6a179
--- /dev/null
+++ b/sam2_unet/sam2/utils/misc.py
@@ -0,0 +1,238 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import os
+import warnings
+from threading import Thread
+
+import numpy as np
+import torch
+from PIL import Image
+from tqdm import tqdm
+
+
+def get_sdpa_settings():
+    if torch.cuda.is_available():
+        old_gpu = torch.cuda.get_device_properties(0).major < 7
+        # only use Flash Attention on Ampere (8.0) or newer GPUs
+        use_flash_attn = torch.cuda.get_device_properties(0).major >= 8
+        if not use_flash_attn:
+            warnings.warn(
+                "Flash Attention is disabled as it requires a GPU with Ampere (8.0) CUDA capability.",
+                category=UserWarning,
+                stacklevel=2,
+            )
+        # keep math kernel for PyTorch versions before 2.2 (Flash Attention v2 is only
+        # available on PyTorch 2.2+, while Flash Attention v1 cannot handle all cases)
+        pytorch_version = tuple(int(v) for v in torch.__version__.split(".")[:2])
+        if pytorch_version < (2, 2):
+            warnings.warn(
+                f"You are using PyTorch {torch.__version__} without Flash Attention v2 support. "
+                "Consider upgrading to PyTorch 2.2+ for Flash Attention v2 (which could be faster).",
+                category=UserWarning,
+                stacklevel=2,
+            )
+        math_kernel_on = pytorch_version < (2, 2) or not use_flash_attn
+    else:
+        old_gpu = True
+        use_flash_attn = False
+        math_kernel_on = True
+
+    return old_gpu, use_flash_attn, math_kernel_on
+
+
+def get_connected_components(mask):
+    """
+    Get the connected components (8-connectivity) of binary masks of shape (N, 1, H, W).
+
+    Inputs:
+    - mask: A binary mask tensor of shape (N, 1, H, W), where 1 is foreground and 0 is
+            background.
+
+    Outputs:
+    - labels: A tensor of shape (N, 1, H, W) containing the connected component labels
+              for foreground pixels and 0 for background pixels.
+    - counts: A tensor of shape (N, 1, H, W) containing the area of the connected
+              components for foreground pixels and 0 for background pixels.
+    """
+    from sam2 import _C
+
+    return _C.get_connected_componnets(mask.to(torch.uint8).contiguous())
+
+
+def mask_to_box(masks: torch.Tensor):
+    """
+    compute bounding box given an input mask
+
+    Inputs:
+    - masks: [B, 1, H, W] boxes, dtype=torch.Tensor
+
+    Returns:
+    - box_coords: [B, 1, 4], contains (x, y) coordinates of top left and bottom right box corners, dtype=torch.Tensor
+    """
+    B, _, h, w = masks.shape
+    device = masks.device
+    xs = torch.arange(w, device=device, dtype=torch.int32)
+    ys = torch.arange(h, device=device, dtype=torch.int32)
+    grid_xs, grid_ys = torch.meshgrid(xs, ys, indexing="xy")
+    grid_xs = grid_xs[None, None, ...].expand(B, 1, h, w)
+    grid_ys = grid_ys[None, None, ...].expand(B, 1, h, w)
+    min_xs, _ = torch.min(torch.where(masks, grid_xs, w).flatten(-2), dim=-1)
+    max_xs, _ = torch.max(torch.where(masks, grid_xs, -1).flatten(-2), dim=-1)
+    min_ys, _ = torch.min(torch.where(masks, grid_ys, h).flatten(-2), dim=-1)
+    max_ys, _ = torch.max(torch.where(masks, grid_ys, -1).flatten(-2), dim=-1)
+    bbox_coords = torch.stack((min_xs, min_ys, max_xs, max_ys), dim=-1)
+
+    return bbox_coords
+
+
+def _load_img_as_tensor(img_path, image_size):
+    img_pil = Image.open(img_path)
+    img_np = np.array(img_pil.convert("RGB").resize((image_size, image_size)))
+    if img_np.dtype == np.uint8:  # np.uint8 is expected for JPEG images
+        img_np = img_np / 255.0
+    else:
+        raise RuntimeError(f"Unknown image dtype: {img_np.dtype} on {img_path}")
+    img = torch.from_numpy(img_np).permute(2, 0, 1)
+    video_width, video_height = img_pil.size  # the original video size
+    return img, video_height, video_width
+
+
+class AsyncVideoFrameLoader:
+    """
+    A list of video frames to be load asynchronously without blocking session start.
+    """
+
+    def __init__(self, img_paths, image_size, offload_video_to_cpu, img_mean, img_std):
+        self.img_paths = img_paths
+        self.image_size = image_size
+        self.offload_video_to_cpu = offload_video_to_cpu
+        self.img_mean = img_mean
+        self.img_std = img_std
+        # items in `self._images` will be loaded asynchronously
+        self.images = [None] * len(img_paths)
+        # catch and raise any exceptions in the async loading thread
+        self.exception = None
+        # video_height and video_width be filled when loading the first image
+        self.video_height = None
+        self.video_width = None
+
+        # load the first frame to fill video_height and video_width and also
+        # to cache it (since it's most likely where the user will click)
+        self.__getitem__(0)
+
+        # load the rest of frames asynchronously without blocking the session start
+        def _load_frames():
+            try:
+                for n in tqdm(range(len(self.images)), desc="frame loading (JPEG)"):
+                    self.__getitem__(n)
+            except Exception as e:
+                self.exception = e
+
+        self.thread = Thread(target=_load_frames, daemon=True)
+        self.thread.start()
+
+    def __getitem__(self, index):
+        if self.exception is not None:
+            raise RuntimeError("Failure in frame loading thread") from self.exception
+
+        img = self.images[index]
+        if img is not None:
+            return img
+
+        img, video_height, video_width = _load_img_as_tensor(
+            self.img_paths[index], self.image_size
+        )
+        self.video_height = video_height
+        self.video_width = video_width
+        # normalize by mean and std
+        img -= self.img_mean
+        img /= self.img_std
+        if not self.offload_video_to_cpu:
+            img = img.cuda(non_blocking=True)
+        self.images[index] = img
+        return img
+
+    def __len__(self):
+        return len(self.images)
+
+
+def load_video_frames(
+    video_path,
+    image_size,
+    offload_video_to_cpu,
+    img_mean=(0.485, 0.456, 0.406),
+    img_std=(0.229, 0.224, 0.225),
+    async_loading_frames=False,
+):
+    """
+    Load the video frames from a directory of JPEG files ("<frame_index>.jpg" format).
+
+    The frames are resized to image_size x image_size and are loaded to GPU if
+    `offload_video_to_cpu` is `False` and to CPU if `offload_video_to_cpu` is `True`.
+
+    You can load a frame asynchronously by setting `async_loading_frames` to `True`.
+    """
+    if isinstance(video_path, str) and os.path.isdir(video_path):
+        jpg_folder = video_path
+    else:
+        raise NotImplementedError("Only JPEG frames are supported at this moment")
+
+    frame_names = [
+        p
+        for p in os.listdir(jpg_folder)
+        if os.path.splitext(p)[-1] in [".jpg", ".jpeg", ".JPG", ".JPEG"]
+    ]
+    frame_names.sort(key=lambda p: int(os.path.splitext(p)[0]))
+    num_frames = len(frame_names)
+    if num_frames == 0:
+        raise RuntimeError(f"no images found in {jpg_folder}")
+    img_paths = [os.path.join(jpg_folder, frame_name) for frame_name in frame_names]
+    img_mean = torch.tensor(img_mean, dtype=torch.float32)[:, None, None]
+    img_std = torch.tensor(img_std, dtype=torch.float32)[:, None, None]
+
+    if async_loading_frames:
+        lazy_images = AsyncVideoFrameLoader(
+            img_paths, image_size, offload_video_to_cpu, img_mean, img_std
+        )
+        return lazy_images, lazy_images.video_height, lazy_images.video_width
+
+    images = torch.zeros(num_frames, 3, image_size, image_size, dtype=torch.float32)
+    for n, img_path in enumerate(tqdm(img_paths, desc="frame loading (JPEG)")):
+        images[n], video_height, video_width = _load_img_as_tensor(img_path, image_size)
+    if not offload_video_to_cpu:
+        images = images.cuda()
+        img_mean = img_mean.cuda()
+        img_std = img_std.cuda()
+    # normalize by mean and std
+    images -= img_mean
+    images /= img_std
+    return images, video_height, video_width
+
+
+def fill_holes_in_mask_scores(mask, max_area):
+    """
+    A post processor to fill small holes in mask scores with area under `max_area`.
+    """
+    # Holes are those connected components in background with area <= self.max_area
+    # (background regions are those with mask scores <= 0)
+    assert max_area > 0, "max_area must be positive"
+    labels, areas = get_connected_components(mask <= 0)
+    is_hole = (labels > 0) & (areas <= max_area)
+    # We fill holes with a small positive mask score (0.1) to change them to foreground.
+    mask = torch.where(is_hole, 0.1, mask)
+    return mask
+
+
+def concat_points(old_point_inputs, new_points, new_labels):
+    """Add new points and labels to previous point inputs (add at the end)."""
+    if old_point_inputs is None:
+        points, labels = new_points, new_labels
+    else:
+        points = torch.cat([old_point_inputs["point_coords"], new_points], dim=1)
+        labels = torch.cat([old_point_inputs["point_labels"], new_labels], dim=1)
+
+    return {"point_coords": points, "point_labels": labels}
diff --git a/sam2_unet/sam2/utils/transforms.py b/sam2_unet/sam2/utils/transforms.py
new file mode 100644
index 0000000..d05cd3e
--- /dev/null
+++ b/sam2_unet/sam2/utils/transforms.py
@@ -0,0 +1,99 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torchvision.transforms import Normalize, Resize, ToTensor
+
+
+class SAM2Transforms(nn.Module):
+    def __init__(
+        self, resolution, mask_threshold, max_hole_area=0.0, max_sprinkle_area=0.0
+    ):
+        """
+        Transforms for SAM2.
+        """
+        super().__init__()
+        self.resolution = resolution
+        self.mask_threshold = mask_threshold
+        self.max_hole_area = max_hole_area
+        self.max_sprinkle_area = max_sprinkle_area
+        self.mean = [0.485, 0.456, 0.406]
+        self.std = [0.229, 0.224, 0.225]
+        self.to_tensor = ToTensor()
+        self.transforms = torch.jit.script(
+            nn.Sequential(
+                Resize((self.resolution, self.resolution)),
+                Normalize(self.mean, self.std),
+            )
+        )
+
+    def __call__(self, x):
+        x = self.to_tensor(x)
+        return self.transforms(x)
+
+    def forward_batch(self, img_list):
+        img_batch = [self.transforms(self.to_tensor(img)) for img in img_list]
+        img_batch = torch.stack(img_batch, dim=0)
+        return img_batch
+
+    def transform_coords(
+        self, coords: torch.Tensor, normalize=False, orig_hw=None
+    ) -> torch.Tensor:
+        """
+        Expects a torch tensor with length 2 in the last dimension. The coordinates can be in absolute image or normalized coordinates,
+        If the coords are in absolute image coordinates, normalize should be set to True and original image size is required.
+
+        Returns
+            Un-normalized coordinates in the range of [0, 1] which is expected by the SAM2 model.
+        """
+        if normalize:
+            assert orig_hw is not None
+            h, w = orig_hw
+            coords = coords.clone()
+            coords[..., 0] = coords[..., 0] / w
+            coords[..., 1] = coords[..., 1] / h
+
+        coords = coords * self.resolution  # unnormalize coords
+        return coords
+
+    def transform_boxes(
+        self, boxes: torch.Tensor, normalize=False, orig_hw=None
+    ) -> torch.Tensor:
+        """
+        Expects a tensor of shape Bx4. The coordinates can be in absolute image or normalized coordinates,
+        if the coords are in absolute image coordinates, normalize should be set to True and original image size is required.
+        """
+        boxes = self.transform_coords(boxes.reshape(-1, 2, 2), normalize, orig_hw)
+        return boxes
+
+    def postprocess_masks(self, masks: torch.Tensor, orig_hw) -> torch.Tensor:
+        """
+        Perform PostProcessing on output masks.
+        """
+        from sam2.utils.misc import get_connected_components
+
+        masks = masks.float()
+        if self.max_hole_area > 0:
+            # Holes are those connected components in background with area <= self.fill_hole_area
+            # (background regions are those with mask scores <= self.mask_threshold)
+            mask_flat = masks.flatten(0, 1).unsqueeze(1)  # flatten as 1-channel image
+            labels, areas = get_connected_components(mask_flat <= self.mask_threshold)
+            is_hole = (labels > 0) & (areas <= self.max_hole_area)
+            is_hole = is_hole.reshape_as(masks)
+            # We fill holes with a small positive mask score (10.0) to change them to foreground.
+            masks = torch.where(is_hole, self.mask_threshold + 10.0, masks)
+
+        if self.max_sprinkle_area > 0:
+            labels, areas = get_connected_components(mask_flat > self.mask_threshold)
+            is_hole = (labels > 0) & (areas <= self.max_sprinkle_area)
+            is_hole = is_hole.reshape_as(masks)
+            # We fill holes with negative mask score (-10.0) to change them to background.
+            masks = torch.where(is_hole, self.mask_threshold - 10.0, masks)
+
+        masks = F.interpolate(masks, orig_hw, mode="bilinear", align_corners=False)
+        return masks
diff --git a/sam2_unet/sam2_configs/__init__.py b/sam2_unet/sam2_configs/__init__.py
new file mode 100644
index 0000000..5277f46
--- /dev/null
+++ b/sam2_unet/sam2_configs/__init__.py
@@ -0,0 +1,5 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
diff --git a/sam2_unet/sam2_configs/sam2_hiera_b+.yaml b/sam2_unet/sam2_configs/sam2_hiera_b+.yaml
new file mode 100644
index 0000000..58f3eb8
--- /dev/null
+++ b/sam2_unet/sam2_configs/sam2_hiera_b+.yaml
@@ -0,0 +1,113 @@
+# @package _global_
+
+# Model
+model:
+  _target_: sam2.modeling.sam2_base.SAM2Base
+  image_encoder:
+    _target_: sam2.modeling.backbones.image_encoder.ImageEncoder
+    scalp: 1
+    trunk:
+      _target_: sam2.modeling.backbones.hieradet.Hiera
+      embed_dim: 112
+      num_heads: 2
+    neck:
+      _target_: sam2.modeling.backbones.image_encoder.FpnNeck
+      position_encoding:
+        _target_: sam2.modeling.position_encoding.PositionEmbeddingSine
+        num_pos_feats: 256
+        normalize: true
+        scale: null
+        temperature: 10000
+      d_model: 256
+      backbone_channel_list: [896, 448, 224, 112]
+      fpn_top_down_levels: [2, 3]  # output level 0 and 1 directly use the backbone features
+      fpn_interp_model: nearest
+
+  memory_attention:
+    _target_: sam2.modeling.memory_attention.MemoryAttention
+    d_model: 256
+    pos_enc_at_input: true
+    layer:
+      _target_: sam2.modeling.memory_attention.MemoryAttentionLayer
+      activation: relu
+      dim_feedforward: 2048
+      dropout: 0.1
+      pos_enc_at_attn: false
+      self_attention:
+        _target_: sam2.modeling.sam.transformer.RoPEAttention
+        rope_theta: 10000.0
+        feat_sizes: [32, 32]
+        embedding_dim: 256
+        num_heads: 1
+        downsample_rate: 1
+        dropout: 0.1
+      d_model: 256
+      pos_enc_at_cross_attn_keys: true
+      pos_enc_at_cross_attn_queries: false
+      cross_attention:
+        _target_: sam2.modeling.sam.transformer.RoPEAttention
+        rope_theta: 10000.0
+        feat_sizes: [32, 32]
+        rope_k_repeat: True
+        embedding_dim: 256
+        num_heads: 1
+        downsample_rate: 1
+        dropout: 0.1
+        kv_in_dim: 64
+    num_layers: 4
+
+  memory_encoder:
+      _target_: sam2.modeling.memory_encoder.MemoryEncoder
+      out_dim: 64
+      position_encoding:
+        _target_: sam2.modeling.position_encoding.PositionEmbeddingSine
+        num_pos_feats: 64
+        normalize: true
+        scale: null
+        temperature: 10000
+      mask_downsampler:
+        _target_: sam2.modeling.memory_encoder.MaskDownSampler
+        kernel_size: 3
+        stride: 2
+        padding: 1
+      fuser:
+        _target_: sam2.modeling.memory_encoder.Fuser
+        layer:
+          _target_: sam2.modeling.memory_encoder.CXBlock
+          dim: 256
+          kernel_size: 7
+          padding: 3
+          layer_scale_init_value: 1e-6
+          use_dwconv: True  # depth-wise convs
+        num_layers: 2
+
+  num_maskmem: 7
+  image_size: 1024
+  # apply scaled sigmoid on mask logits for memory encoder, and directly feed input mask as output mask
+  sigmoid_scale_for_mem_enc: 20.0
+  sigmoid_bias_for_mem_enc: -10.0
+  use_mask_input_as_output_without_sam: true
+  # Memory
+  directly_add_no_mem_embed: true
+  # use high-resolution feature map in the SAM mask decoder
+  use_high_res_features_in_sam: true
+  # output 3 masks on the first click on initial conditioning frames
+  multimask_output_in_sam: true
+  # SAM heads
+  iou_prediction_use_sigmoid: True
+  # cross-attend to object pointers from other frames (based on SAM output tokens) in the encoder
+  use_obj_ptrs_in_encoder: true
+  add_tpos_enc_to_obj_ptrs: false
+  only_obj_ptrs_in_the_past_for_eval: true
+  # object occlusion prediction
+  pred_obj_scores: true
+  pred_obj_scores_mlp: true
+  fixed_no_obj_ptr: true
+  # multimask tracking settings
+  multimask_output_for_tracking: true
+  use_multimask_token_for_obj_ptr: true
+  multimask_min_pt_num: 0
+  multimask_max_pt_num: 1
+  use_mlp_for_obj_ptr_proj: true
+  # Compilation flag
+  compile_image_encoder: False
diff --git a/sam2_unet/sam2_configs/sam2_hiera_l.yaml b/sam2_unet/sam2_configs/sam2_hiera_l.yaml
new file mode 100644
index 0000000..918667f
--- /dev/null
+++ b/sam2_unet/sam2_configs/sam2_hiera_l.yaml
@@ -0,0 +1,117 @@
+# @package _global_
+
+# Model
+model:
+  _target_: sam2.modeling.sam2_base.SAM2Base
+  image_encoder:
+    _target_: sam2.modeling.backbones.image_encoder.ImageEncoder
+    scalp: 1
+    trunk:
+      _target_: sam2.modeling.backbones.hieradet.Hiera
+      embed_dim: 144
+      num_heads: 2
+      stages: [2, 6, 36, 4]
+      global_att_blocks: [23, 33, 43]
+      window_pos_embed_bkg_spatial_size: [7, 7]
+      window_spec: [8, 4, 16, 8]
+    neck:
+      _target_: sam2.modeling.backbones.image_encoder.FpnNeck
+      position_encoding:
+        _target_: sam2.modeling.position_encoding.PositionEmbeddingSine
+        num_pos_feats: 256
+        normalize: true
+        scale: null
+        temperature: 10000
+      d_model: 256
+      backbone_channel_list: [1152, 576, 288, 144]
+      fpn_top_down_levels: [2, 3]  # output level 0 and 1 directly use the backbone features
+      fpn_interp_model: nearest
+
+  memory_attention:
+    _target_: sam2.modeling.memory_attention.MemoryAttention
+    d_model: 256
+    pos_enc_at_input: true
+    layer:
+      _target_: sam2.modeling.memory_attention.MemoryAttentionLayer
+      activation: relu
+      dim_feedforward: 2048
+      dropout: 0.1
+      pos_enc_at_attn: false
+      self_attention:
+        _target_: sam2.modeling.sam.transformer.RoPEAttention
+        rope_theta: 10000.0
+        feat_sizes: [32, 32]
+        embedding_dim: 256
+        num_heads: 1
+        downsample_rate: 1
+        dropout: 0.1
+      d_model: 256
+      pos_enc_at_cross_attn_keys: true
+      pos_enc_at_cross_attn_queries: false
+      cross_attention:
+        _target_: sam2.modeling.sam.transformer.RoPEAttention
+        rope_theta: 10000.0
+        feat_sizes: [32, 32]
+        rope_k_repeat: True
+        embedding_dim: 256
+        num_heads: 1
+        downsample_rate: 1
+        dropout: 0.1
+        kv_in_dim: 64
+    num_layers: 4
+
+  memory_encoder:
+      _target_: sam2.modeling.memory_encoder.MemoryEncoder
+      out_dim: 64
+      position_encoding:
+        _target_: sam2.modeling.position_encoding.PositionEmbeddingSine
+        num_pos_feats: 64
+        normalize: true
+        scale: null
+        temperature: 10000
+      mask_downsampler:
+        _target_: sam2.modeling.memory_encoder.MaskDownSampler
+        kernel_size: 3
+        stride: 2
+        padding: 1
+      fuser:
+        _target_: sam2.modeling.memory_encoder.Fuser
+        layer:
+          _target_: sam2.modeling.memory_encoder.CXBlock
+          dim: 256
+          kernel_size: 7
+          padding: 3
+          layer_scale_init_value: 1e-6
+          use_dwconv: True  # depth-wise convs
+        num_layers: 2
+
+  num_maskmem: 7
+  image_size: 1024
+  # apply scaled sigmoid on mask logits for memory encoder, and directly feed input mask as output mask
+  sigmoid_scale_for_mem_enc: 20.0
+  sigmoid_bias_for_mem_enc: -10.0
+  use_mask_input_as_output_without_sam: true
+  # Memory
+  directly_add_no_mem_embed: true
+  # use high-resolution feature map in the SAM mask decoder
+  use_high_res_features_in_sam: true
+  # output 3 masks on the first click on initial conditioning frames
+  multimask_output_in_sam: true
+  # SAM heads
+  iou_prediction_use_sigmoid: True
+  # cross-attend to object pointers from other frames (based on SAM output tokens) in the encoder
+  use_obj_ptrs_in_encoder: true
+  add_tpos_enc_to_obj_ptrs: false
+  only_obj_ptrs_in_the_past_for_eval: true
+  # object occlusion prediction
+  pred_obj_scores: true
+  pred_obj_scores_mlp: true
+  fixed_no_obj_ptr: true
+  # multimask tracking settings
+  multimask_output_for_tracking: true
+  use_multimask_token_for_obj_ptr: true
+  multimask_min_pt_num: 0
+  multimask_max_pt_num: 1
+  use_mlp_for_obj_ptr_proj: true
+  # Compilation flag
+  compile_image_encoder: False
diff --git a/sam2_unet/sam2_configs/sam2_hiera_s.yaml b/sam2_unet/sam2_configs/sam2_hiera_s.yaml
new file mode 100644
index 0000000..26e5d4d
--- /dev/null
+++ b/sam2_unet/sam2_configs/sam2_hiera_s.yaml
@@ -0,0 +1,116 @@
+# @package _global_
+
+# Model
+model:
+  _target_: sam2.modeling.sam2_base.SAM2Base
+  image_encoder:
+    _target_: sam2.modeling.backbones.image_encoder.ImageEncoder
+    scalp: 1
+    trunk:
+      _target_: sam2.modeling.backbones.hieradet.Hiera
+      embed_dim: 96
+      num_heads: 1
+      stages: [1, 2, 11, 2]
+      global_att_blocks: [7, 10, 13]
+      window_pos_embed_bkg_spatial_size: [7, 7]
+    neck:
+      _target_: sam2.modeling.backbones.image_encoder.FpnNeck
+      position_encoding:
+        _target_: sam2.modeling.position_encoding.PositionEmbeddingSine
+        num_pos_feats: 256
+        normalize: true
+        scale: null
+        temperature: 10000
+      d_model: 256
+      backbone_channel_list: [768, 384, 192, 96]
+      fpn_top_down_levels: [2, 3]  # output level 0 and 1 directly use the backbone features
+      fpn_interp_model: nearest
+
+  memory_attention:
+    _target_: sam2.modeling.memory_attention.MemoryAttention
+    d_model: 256
+    pos_enc_at_input: true
+    layer:
+      _target_: sam2.modeling.memory_attention.MemoryAttentionLayer
+      activation: relu
+      dim_feedforward: 2048
+      dropout: 0.1
+      pos_enc_at_attn: false
+      self_attention:
+        _target_: sam2.modeling.sam.transformer.RoPEAttention
+        rope_theta: 10000.0
+        feat_sizes: [32, 32]
+        embedding_dim: 256
+        num_heads: 1
+        downsample_rate: 1
+        dropout: 0.1
+      d_model: 256
+      pos_enc_at_cross_attn_keys: true
+      pos_enc_at_cross_attn_queries: false
+      cross_attention:
+        _target_: sam2.modeling.sam.transformer.RoPEAttention
+        rope_theta: 10000.0
+        feat_sizes: [32, 32]
+        rope_k_repeat: True
+        embedding_dim: 256
+        num_heads: 1
+        downsample_rate: 1
+        dropout: 0.1
+        kv_in_dim: 64
+    num_layers: 4
+
+  memory_encoder:
+      _target_: sam2.modeling.memory_encoder.MemoryEncoder
+      out_dim: 64
+      position_encoding:
+        _target_: sam2.modeling.position_encoding.PositionEmbeddingSine
+        num_pos_feats: 64
+        normalize: true
+        scale: null
+        temperature: 10000
+      mask_downsampler:
+        _target_: sam2.modeling.memory_encoder.MaskDownSampler
+        kernel_size: 3
+        stride: 2
+        padding: 1
+      fuser:
+        _target_: sam2.modeling.memory_encoder.Fuser
+        layer:
+          _target_: sam2.modeling.memory_encoder.CXBlock
+          dim: 256
+          kernel_size: 7
+          padding: 3
+          layer_scale_init_value: 1e-6
+          use_dwconv: True  # depth-wise convs
+        num_layers: 2
+
+  num_maskmem: 7
+  image_size: 1024
+  # apply scaled sigmoid on mask logits for memory encoder, and directly feed input mask as output mask
+  sigmoid_scale_for_mem_enc: 20.0
+  sigmoid_bias_for_mem_enc: -10.0
+  use_mask_input_as_output_without_sam: true
+  # Memory
+  directly_add_no_mem_embed: true
+  # use high-resolution feature map in the SAM mask decoder
+  use_high_res_features_in_sam: true
+  # output 3 masks on the first click on initial conditioning frames
+  multimask_output_in_sam: true
+  # SAM heads
+  iou_prediction_use_sigmoid: True
+  # cross-attend to object pointers from other frames (based on SAM output tokens) in the encoder
+  use_obj_ptrs_in_encoder: true
+  add_tpos_enc_to_obj_ptrs: false
+  only_obj_ptrs_in_the_past_for_eval: true
+  # object occlusion prediction
+  pred_obj_scores: true
+  pred_obj_scores_mlp: true
+  fixed_no_obj_ptr: true
+  # multimask tracking settings
+  multimask_output_for_tracking: true
+  use_multimask_token_for_obj_ptr: true
+  multimask_min_pt_num: 0
+  multimask_max_pt_num: 1
+  use_mlp_for_obj_ptr_proj: true
+  # Compilation flag
+  compile_image_encoder: False
diff --git a/sam2_unet/sam2_configs/sam2_hiera_t.yaml b/sam2_unet/sam2_configs/sam2_hiera_t.yaml
new file mode 100644
index 0000000..a62c903
--- /dev/null
+++ b/sam2_unet/sam2_configs/sam2_hiera_t.yaml
@@ -0,0 +1,118 @@
+# @package _global_
+
+# Model
+model:
+  _target_: sam2.modeling.sam2_base.SAM2Base
+  image_encoder:
+    _target_: sam2.modeling.backbones.image_encoder.ImageEncoder
+    scalp: 1
+    trunk:
+      _target_: sam2.modeling.backbones.hieradet.Hiera
+      embed_dim: 96
+      num_heads: 1
+      stages: [1, 2, 7, 2]
+      global_att_blocks: [5, 7, 9]
+      window_pos_embed_bkg_spatial_size: [7, 7]
+    neck:
+      _target_: sam2.modeling.backbones.image_encoder.FpnNeck
+      position_encoding:
+        _target_: sam2.modeling.position_encoding.PositionEmbeddingSine
+        num_pos_feats: 256
+        normalize: true
+        scale: null
+        temperature: 10000
+      d_model: 256
+      backbone_channel_list: [768, 384, 192, 96]
+      fpn_top_down_levels: [2, 3]  # output level 0 and 1 directly use the backbone features
+      fpn_interp_model: nearest
+
+  memory_attention:
+    _target_: sam2.modeling.memory_attention.MemoryAttention
+    d_model: 256
+    pos_enc_at_input: true
+    layer:
+      _target_: sam2.modeling.memory_attention.MemoryAttentionLayer
+      activation: relu
+      dim_feedforward: 2048
+      dropout: 0.1
+      pos_enc_at_attn: false
+      self_attention:
+        _target_: sam2.modeling.sam.transformer.RoPEAttention
+        rope_theta: 10000.0
+        feat_sizes: [32, 32]
+        embedding_dim: 256
+        num_heads: 1
+        downsample_rate: 1
+        dropout: 0.1
+      d_model: 256
+      pos_enc_at_cross_attn_keys: true
+      pos_enc_at_cross_attn_queries: false
+      cross_attention:
+        _target_: sam2.modeling.sam.transformer.RoPEAttention
+        rope_theta: 10000.0
+        feat_sizes: [32, 32]
+        rope_k_repeat: True
+        embedding_dim: 256
+        num_heads: 1
+        downsample_rate: 1
+        dropout: 0.1
+        kv_in_dim: 64
+    num_layers: 4
+
+  memory_encoder:
+      _target_: sam2.modeling.memory_encoder.MemoryEncoder
+      out_dim: 64
+      position_encoding:
+        _target_: sam2.modeling.position_encoding.PositionEmbeddingSine
+        num_pos_feats: 64
+        normalize: true
+        scale: null
+        temperature: 10000
+      mask_downsampler:
+        _target_: sam2.modeling.memory_encoder.MaskDownSampler
+        kernel_size: 3
+        stride: 2
+        padding: 1
+      fuser:
+        _target_: sam2.modeling.memory_encoder.Fuser
+        layer:
+          _target_: sam2.modeling.memory_encoder.CXBlock
+          dim: 256
+          kernel_size: 7
+          padding: 3
+          layer_scale_init_value: 1e-6
+          use_dwconv: True  # depth-wise convs
+        num_layers: 2
+
+  num_maskmem: 7
+  image_size: 1024
+  # apply scaled sigmoid on mask logits for memory encoder, and directly feed input mask as output mask
+  # SAM decoder
+  sigmoid_scale_for_mem_enc: 20.0
+  sigmoid_bias_for_mem_enc: -10.0
+  use_mask_input_as_output_without_sam: true
+  # Memory
+  directly_add_no_mem_embed: true
+  # use high-resolution feature map in the SAM mask decoder
+  use_high_res_features_in_sam: true
+  # output 3 masks on the first click on initial conditioning frames
+  multimask_output_in_sam: true
+  # SAM heads
+  iou_prediction_use_sigmoid: True
+  # cross-attend to object pointers from other frames (based on SAM output tokens) in the encoder
+  use_obj_ptrs_in_encoder: true
+  add_tpos_enc_to_obj_ptrs: false
+  only_obj_ptrs_in_the_past_for_eval: true
+  # object occlusion prediction
+  pred_obj_scores: true
+  pred_obj_scores_mlp: true
+  fixed_no_obj_ptr: true
+  # multimask tracking settings
+  multimask_output_for_tracking: true
+  use_multimask_token_for_obj_ptr: true
+  multimask_min_pt_num: 0
+  multimask_max_pt_num: 1
+  use_mlp_for_obj_ptr_proj: true
+  # Compilation flag
+  # HieraT does not currently support compilation, should always be set to False
+  compile_image_encoder: False
diff --git a/sam2_unet/test.py b/sam2_unet/test.py
new file mode 100644
index 0000000..8e87edd
--- /dev/null
+++ b/sam2_unet/test.py
@@ -0,0 +1,139 @@
+import argparse
+import os
+import torch
+import imageio
+import numpy as np
+import pandas as pd
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+from tqdm.auto import tqdm
+from SAM2UNet import SAM2UNet
+from utils.dataset import TestDataset
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--checkpoint", type=str, required=True,
+                help="path to the checkpoint of sam2-unet")
+parser.add_argument("--test_image_path", type=str, required=True, 
+                    help="path to the image files for testing")
+parser.add_argument("--test_gt_path", type=str, required=True,
+                    help="path to the mask files for testing")
+parser.add_argument("--save_path", type=str, required=True,
+                    help="path to save the predicted masks")
+# args = parser.parse_args()
+
+def encode_mask_to_rle(mask):
+    '''
+    mask: numpy array binary mask 
+    1 - mask 
+    0 - background
+    Returns encoded run length 
+    '''
+    pixels = mask.flatten()
+    pixels = np.concatenate([[0], pixels, [0]])
+    runs = np.where(pixels[1:] != pixels[:-1])[0] + 1
+    runs[1::2] -= runs[::2]
+    return ' '.join(str(x) for x in runs)
+
+def decode_rle_to_mask(rle, height, width):
+    s = rle.split()
+    starts, lengths = [np.asarray(x, dtype=int) for x in (s[0:][::2], s[1:][::2])]
+    starts -= 1
+    ends = starts + lengths
+    img = np.zeros(height * width, dtype=np.uint8)
+    
+    for lo, hi in zip(starts, ends):
+        img[lo:hi] = 1
+    
+    return img.reshape(height, width)
+
+def test(model, args, thr=0.5):
+    CLASSES = [
+        'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
+        'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
+        'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
+        'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
+        'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
+        'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
+    ]
+    CLASS2IND = {v: i for i, v in enumerate(CLASSES)}
+    IND2CLASS = {v: k for k, v in CLASS2IND.items()}
+
+    test_dataset = TestDataset(args.test_image_path, 512)
+    test_loader = DataLoader(
+        dataset=test_dataset, 
+        batch_size=2,
+        shuffle=False,
+        num_workers=2,
+        drop_last=False
+    )
+    model.eval()
+    model.cuda()
+    os.makedirs(args.save_path, exist_ok=True)
+
+    rles = []
+    filename_and_class = []
+    with torch.no_grad():
+        n_class = len(CLASSES)
+
+        for step, (images, image_names) in tqdm(enumerate(test_loader), total=len(test_loader)):
+            images = images.cuda()    
+            outputs, _, _ = model(images)
+            
+            outputs = F.interpolate(outputs, size=(2048, 2048), mode="bilinear")
+            outputs = torch.sigmoid(outputs)
+            outputs = (outputs > thr).detach().cpu().numpy()
+            
+            for output, image_name in zip(outputs, image_names):
+                for c, segm in enumerate(output):
+                    rle = encode_mask_to_rle(segm)
+                    rles.append(rle)
+                    filename_and_class.append(f"{IND2CLASS[c]}_{image_name}")
+                    
+    return rles, filename_and_class
+
+def main(args):
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = SAM2UNet().to(device)
+    model.load_state_dict(torch.load(args.checkpoint), strict=True)
+    rles, filename_and_class = test(model, args)
+    classes, filename = zip(*[x.split("_") for x in filename_and_class])
+    image_name = [os.path.basename(f) for f in filename]
+    df = pd.DataFrame({
+        "image_name": image_name,
+        "class": classes,
+        "rle": rles,
+    })
+    df.to_csv("output1.csv", index=False)
+
+if __name__ == "__main__":
+    args = argparse.Namespace(
+        checkpoint="/data/ephemeral/home/jongmin/level2-cv-semanticsegmentation-cv-19-lv3/sam2_unet/checkpoints/SAM2-UNet-30.pth", 
+        test_image_path="/data/ephemeral/home/data/test/DCM", 
+        test_gt_path="/data/ephemeral/home/data/test/DCM",
+        save_path="./outputs", 
+    )
+    main(args)
+
+# device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+# test_loader = TestDataset(args.test_image_path, args.test_gt_path, 352)
+# model = SAM2UNet().to(device)
+# model.load_state_dict(torch.load(args.checkpoint), strict=True)
+# model.eval()
+# model.cuda()
+# os.makedirs(args.save_path, exist_ok=True)
+# for i in range(test_loader.size):
+#     with torch.no_grad():
+#         image, gt, name = test_loader.load_data()
+#         gt = np.asarray(gt, np.float32)
+#         image = image.to(device)
+#         res, _, _ = model(image)
+#         # fix: duplicate sigmoid
+#         # res = torch.sigmoid(res)
+#         res = F.upsample(res, size=gt.shape, mode='bilinear', align_corners=False)
+#         res = res.sigmoid().data.cpu()
+#         res = res.numpy().squeeze()
+#         res = (res - res.min()) / (res.max() - res.min() + 1e-8)
+#         res = (res * 255).astype(np.uint8)
+#         print("Saving " + name)
+#         imageio.imsave(os.path.join(args.save_path, name[:-4] + ".png"), res)
diff --git a/sam2_unet/test.sh b/sam2_unet/test.sh
new file mode 100644
index 0000000..d4867a2
--- /dev/null
+++ b/sam2_unet/test.sh
@@ -0,0 +1,6 @@
+CUDA_VISIBLE_DEVICES="0" \
+python test.py \
+--checkpoint "/data/ephemeral/home/jongmin/level2-cv-semanticsegmentation-cv-19-lv3/sam2_unet/checkpoints/SAM2-UNet-20.pth" \
+--test_image_path "/data/ephemeral/home/data/test" \
+--test_gt_path "/data/ephemeral/home/data/test" \
+--save_path "./outputs"
\ No newline at end of file
diff --git a/sam2_unet/train.py b/sam2_unet/train.py
new file mode 100644
index 0000000..f4908d8
--- /dev/null
+++ b/sam2_unet/train.py
@@ -0,0 +1,77 @@
+import os
+import random
+import numpy as np
+import torch
+import torch.optim as opt
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+from torch.optim.lr_scheduler import CosineAnnealingLR, MultiStepLR
+from utils.dataset import FullDataset
+from SAM2UNet import SAM2UNet
+from omegaconf import OmegaConf
+from argparse import ArgumentParser
+
+
+def set_seed(RANDOM_SEED):
+    torch.manual_seed(RANDOM_SEED)
+    torch.cuda.manual_seed(RANDOM_SEED)
+    torch.cuda.manual_seed_all(RANDOM_SEED) # if use multi-GPU
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+    np.random.seed(RANDOM_SEED)
+    random.seed(RANDOM_SEED)
+
+
+def structure_loss(pred, mask):
+    weit = 1 + 5*torch.abs(F.avg_pool2d(mask, kernel_size=31, stride=1, padding=15) - mask)
+    wbce = F.binary_cross_entropy_with_logits(pred, mask, reduce='none')
+    wbce = (weit*wbce).sum(dim=(2, 3)) / weit.sum(dim=(2, 3))
+    pred = torch.sigmoid(pred)
+    inter = ((pred * mask)*weit).sum(dim=(2, 3))
+    union = ((pred + mask)*weit).sum(dim=(2, 3))
+    wiou = 1 - (inter + 1)/(union - inter+1)
+    return (wbce + wiou).mean()
+
+
+def main(cfg):    
+    dataset = FullDataset(cfg.train_image_path, cfg.train_mask_path, 512, mode='train')
+    dataloader = DataLoader(dataset, batch_size=cfg.train_batch_size, shuffle=True, num_workers=2)
+    device = torch.device("cuda")
+    model = SAM2UNet(cfg.hiera_path)
+    model.to(device)
+    optim = opt.AdamW([{"params":model.parameters(), "initia_lr": cfg.lr}], lr=cfg.lr, weight_decay=cfg.weight_decay)
+    scheduler = CosineAnnealingLR(optim, cfg.max_epoch, eta_min=1.0e-7)
+    # scheduler = MultiStepLR(optim, milestones=[8, 16], gamma=0.1, last_epoch=cfg.epoch)
+    os.makedirs("./checkpoints", exist_ok=True)
+    for epoch in range(cfg.max_epoch):
+        for i, batch in enumerate(dataloader):
+            x = batch['image']
+            target = batch['label']
+            x = x.to(device)
+            target = target.to(device)
+            optim.zero_grad()
+            pred0, pred1, pred2 = model(x)
+            loss0 = structure_loss(pred0, target)
+            loss1 = structure_loss(pred1, target)
+            loss2 = structure_loss(pred2, target)
+            loss = loss0 + loss1 + loss2
+            loss.backward()
+            optim.step()
+            if i % 50 == 0:
+                print("epoch:{}-{}: loss:{}".format(epoch + 1, i + 1, loss.item()))
+                
+        scheduler.step()
+        if (epoch+1) % 5 == 0 or (epoch+1) == cfg.max_epoch:
+            torch.save(model.state_dict(), os.path.join('./checkpoints', 'SAM2-UNet-%d.pth' % (epoch + 1)))
+            print('[Saving Snapshot:]', os.path.join('./checkpoints', 'SAM2-UNet-%d.pth'% (epoch + 1)))
+
+if __name__ == "__main__":
+    set_seed(2024)
+    parser = ArgumentParser()
+    parser.add_argument('--config', type=str, default='config.yaml')
+    args = parser.parse_args()
+
+    with open(args.config, 'r') as f:
+        cfg = OmegaConf.load(f)
+    
+    main(cfg)
\ No newline at end of file
diff --git a/sam2_unet/train.sh b/sam2_unet/train.sh
new file mode 100644
index 0000000..0cb933a
--- /dev/null
+++ b/sam2_unet/train.sh
@@ -0,0 +1,9 @@
+CUDA_VISIBLE_DEVICES="0" \
+python train.py \
+--hiera_path "/data/ephemeral/home/jongmin/level2-cv-semanticsegmentation-cv-19-lv3/sam2_unet/sam2_hiera_large.pt" \
+--train_image_path "/data/ephemeral/home/data/train/DCM" \
+--train_mask_path "/data/ephemeral/home/data/train/outputs_json" \
+--save_path "./checkpoints" \
+--epoch 20 \
+--lr 0.001 \
+--batch_size 12
\ No newline at end of file
diff --git a/sam2_unet/train_v1.py b/sam2_unet/train_v1.py
new file mode 100644
index 0000000..79ae0f2
--- /dev/null
+++ b/sam2_unet/train_v1.py
@@ -0,0 +1,97 @@
+import os
+import random
+import datetime
+import numpy as np
+import torch
+from torch.utils.data import DataLoader
+from utils.loss import structure_loss
+from utils.dataset import FullDataset
+from utils.optimizer import OptimizerSelector
+from utils.scheduler import SchedulerSelector
+from trainer import Trainer
+from SAM2UNet import SAM2UNet
+from omegaconf import OmegaConf
+from argparse import ArgumentParser
+
+def set_seed(RANDOM_SEED):
+    torch.manual_seed(RANDOM_SEED)
+    torch.cuda.manual_seed(RANDOM_SEED)
+    torch.cuda.manual_seed_all(RANDOM_SEED) # if use multi-GPU
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+    np.random.seed(RANDOM_SEED)
+    random.seed(RANDOM_SEED)
+
+def main(cfg):    
+    device = torch.device("cuda")
+    model = SAM2UNet(cfg.hiera_path)
+
+    train_dataset = FullDataset(
+        cfg.train_image_path, 
+        cfg.train_mask_path, 
+        cfg.image_size, 
+        mode='train')
+    
+    valid_dataset = FullDataset(
+        cfg.train_image_path, 
+        cfg.train_mask_path, 
+        cfg.image_size, 
+        mode='valid')
+
+    train_loader = DataLoader(
+        train_dataset, 
+        batch_size=cfg.train_batch_size, 
+        num_workers=cfg.train_num_workers,
+        shuffle=True)
+    
+    valid_loader = DataLoader(
+        valid_dataset, 
+        batch_size=cfg.valid_batch_size, 
+        num_workers=cfg.valid_num_workers,
+        shuffle=False)
+    
+    optimizer_selector = OptimizerSelector(model, cfg.lr)
+    optimizer = optimizer_selector.get_optimizer(cfg.optimizer, **cfg.optimizer_parameters)
+
+    scheduler_selector = SchedulerSelector(optimizer)
+    scheduler = scheduler_selector.get_scheduler(cfg.scheduler, **cfg.scheduler_parameters)
+
+    loss_fn = structure_loss()
+
+    os.makedirs("./checkpoints", exist_ok=True)
+    now = datetime.now()
+    time = now.strftime('%Y-%m-%d_%H:%M:%S')
+    save_dir = os.path.join('./checkpoints', time)
+    with open(os.path.join(save_dir, "config.txt"), "w") as f:
+        for arg, value in vars(cfg).items():
+            f.write(f"{arg}: {value} \n")
+
+    trainer = Trainer(
+        model=model,
+        device=device,
+        train_loader=train_loader,
+        valid_loader=valid_loader,
+        optimizer=optimizer,
+        scheduler=scheduler,
+        loss_fn=loss_fn,
+        epochs=cfg.max_epoch,
+        save_dir=save_dir,
+        wandb_id=,
+        wandb_name=,
+        resume=cfg.resume,
+        ckpt_path=cfg.ckpt_path,
+        start_epoch=cfg.start_epoch
+    )
+
+    trainer.train()
+    
+if __name__ == "__main__":
+    set_seed(2024)
+    parser = ArgumentParser()
+    parser.add_argument('--config', type=str, default='config.yaml')
+    args = parser.parse_args()
+
+    with open(args.config, 'r') as f:
+        cfg = OmegaConf.load(f)
+    
+    main(cfg)
\ No newline at end of file
diff --git a/sam2_unet/trainer.py b/sam2_unet/trainer.py
new file mode 100644
index 0000000..d4dec31
--- /dev/null
+++ b/sam2_unet/trainer.py
@@ -0,0 +1,180 @@
+import os
+from tqdm.auto import tqdm
+from utils.checkpoint import save_checkpoint
+
+import torch
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+
+class Trainer:
+    def __init__(
+        self,
+        model,
+        device,
+        train_loader,
+        valid_loader,
+        optimizer,
+        scheduler,
+        loss_fn,
+        epochs,
+        save_dir,
+        wandb_id,
+        wandb_name,
+        resume=False,
+        ckpt_path="",
+        start_epoch=0
+        ):
+        self.model = model  # 훈련할 모델
+        self.device = device  # 연산을 수행할 디바이스 (CPU or GPU)
+        self.train_loader = train_loader  # 훈련 데이터 로더
+        self.valid_loader = valid_loader  # 검증 데이터 로더
+        self.optimizer = optimizer  # 최적화 알고리즘
+        self.scheduler = scheduler # 학습률 스케줄러
+        self.loss_fn = loss_fn  # 손실 함수
+        self.epochs = epochs  # 총 훈련 에폭 수
+        self.save_dir = save_dir
+        self.wandb_id = wandb_id
+        self.wandb_name = wandb_name
+        self.resume = resume # 학습 재개를 위한 것인지
+        self.ckpt_file = ckpt_path # 학습 재개를 위해 불러와야할 가중치 주소
+        self.start_epoch = start_epoch # 재개
+        self.classes = [
+            'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
+            'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
+            'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
+            'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
+            'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
+            'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
+        ]
+
+    def save_checkpoint_epoch(self, epoch: int, valid_loss: float, valid_dice: float) -> None:
+        ckpt_path = os.path.join(self.save_dir, f'epoch-{epoch + 1}-loss-{valid_loss}-dice-{valid_dice:.4f}.pth')
+        save_checkpoint(self.model, self.optimizer, self.scheduler, epoch+1, valid_dice, ckpt_path)
+        print(f"Checkpoint updated at epoch {epoch + 1} and saved as {ckpt_path}")
+    
+    def dice_coef(y_true, y_pred):
+        y_true_f = y_true.flatten(2)
+        y_pred_f = y_pred.flatten(2)
+        intersection = torch.sum(y_true_f * y_pred_f, -1)
+
+        eps = 0.0001
+        return (2. * intersection + eps) / (torch.sum(y_true_f, -1) + torch.sum(y_pred_f, -1) + eps)
+
+    def train_epoch(self, train_loader: DataLoader, thr=0.5):
+        self.model.train()
+        
+        train_loss = 0.
+        train_dices = []
+        progress_bar = tqdm(train_loader, desc="Training", leave=False)
+        
+        for images, masks in progress_bar:
+            images, masks = images.to(self.device), masks.to(self.device)
+            self.optimizer.zero_grad()
+
+            pred0, pred1, pred2 = self.model(images)
+            loss0 = self.loss_fn(pred0, masks)
+            loss1 = self.loss_fn(pred1, masks)
+            loss2 = self.loss_fn(pred2, masks)
+            loss = loss0 + loss1 + loss2
+            loss.backward()
+            self.optimizer.step()
+            
+            train_loss += loss.item() * masks.shape[0]
+
+            outputs = torch.sigmoid(pred0)
+            outputs = (outputs > thr).detach().cpu()
+            masks = masks.detach().cpu()
+
+            dice = self.dice_coef(outputs, masks)
+            train_dices.append(dice)
+
+            del outputs, masks, dice
+
+            progress_bar.set_postfix(loss=loss.item())
+        progress_bar.close()
+
+        dices = torch.cat(train_dices, 0)
+        dices_per_class = torch.mean(dices, 0)
+        train_dice = torch.mean(dices_per_class).item()
+
+        return train_loss, train_dice
+
+    def validate(self, val_loader: DataLoader, thr=0.5) -> tuple[float, float]:
+        self.model.eval()
+
+        valid_loss = 0.
+        valid_dices = []
+
+        progress_bar = tqdm(val_loader, desc="Validating", leave=False)
+        
+        with torch.no_grad():
+            for batch_idx, (images, masks) in enumerate(progress_bar):
+                images, masks = images.to(self.device), masks.to(self.device)
+                
+                outputs, _, _ = self.model(images)
+
+                output_h, output_w = outputs.size(-2), outputs.size(-1)
+                mask_h, mask_w = masks.size(-2), masks.size(-1)
+                
+                if output_h != mask_h or output_w != mask_w:
+                    outputs = F.interpolate(outputs, size=(mask_h, mask_w), mode="bilinear")
+            
+                loss = self.loss_fn(outputs, masks)
+                valid_loss += loss.item() * masks.shape[0]
+
+                outputs = torch.sigmoid(outputs)
+                outputs = (outputs > thr).detach().cpu()
+                masks = masks.detach().cpu()
+
+                
+                dice = self.dice_coef(outputs, masks)
+                valid_dices.append(dice)
+                
+                del outputs, masks, dice
+
+                progress_bar.set_postfix(loss=loss.item())
+        progress_bar.close()
+
+        dices = torch.cat(valid_dices, 0)
+        dices_per_class = torch.mean(dices, 0)
+        dice_str = [
+            f"{c:<12}: {d.item():.4f}"
+            for c, d in zip(self.classes, dices_per_class)
+        ]
+        dice_str = "\n".join(dice_str)
+        print(dice_str)
+        valid_dice = torch.mean(dices_per_class).item()
+
+        return valid_loss, valid_dice, dices_per_class
+
+    def train(self) -> None:
+        if self.resume:
+            self.load_settings()
+        print(f"training start")
+        print(f"checkpoints saved in {self.save_dir}")
+
+        self.model.to(self.device)
+        for epoch in range(self.start_epoch, self.epochs):
+            train_loss, train_dice = 0.0, 0.0
+            train_dice, valid_dice = 0.0, 0.0
+            print(f"Epoch {epoch+1}/{self.epochs}")
+            
+            train_loss, train_dice = self.train_epoch(self.train_loader)
+            valid_loss, valid_dice, dices_per_class = self.validate(self.valid_loader)
+
+            train_loss, train_acc = train_loss / self.train_total, train_acc / self.train_total
+            val_loss, val_acc = val_loss / self.val_total, val_acc / self.val_total
+            
+            print(f"Epoch {epoch+1}, Train Loss: {train_loss:.8f} | Train Dice: {train_dice:.8f} \nVaild Loss: {valid_loss:.8f} | Vaild Dice: {valid_dice:.8f}\n")
+            
+            self.save_checkpoint_epoch(epoch, valid_loss, valid_dice)
+            
+        self.save_checkpoint_epoch(epoch, train_loss, train_acc, val_loss, val_acc)
+        
+    def load_settings(self) -> None:
+        print("loading prev training setttings")
+        try:
+            self.epochs, self.model, self.optimizer, self.scheduler, self.loss = load_checkpoint(self.ckpt_path, self.model, self.optimizer, self.scheduler)
+            print("loading successful")
+        except:
+            raise Exception('loading failed')
\ No newline at end of file
diff --git a/sam2_unet/utils/checkpoint.py b/sam2_unet/utils/checkpoint.py
new file mode 100644
index 0000000..22db4db
--- /dev/null
+++ b/sam2_unet/utils/checkpoint.py
@@ -0,0 +1,21 @@
+import torch
+
+def save_checkpoint(model, optimizer, scheduler, epoch, loss, filepath):
+    checkpoint = {
+        'epoch': epoch,
+        'model_state_dict': model.state_dict(),
+        'optimizer_state_dict': optimizer.state_dict(),
+        'scheduler_state_dict': scheduler.state_dict(),
+        'loss': loss
+    }
+    torch.save(checkpoint, filepath) 
+
+def load_checkpoint(filepath, model, optimizer, scheduler):
+    checkpoint = torch.load(filepath, map_location='cpu')
+    epoch = checkpoint['epoch']
+    model.load_state_dict(checkpoint['model_state_dict'])
+    optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
+    scheduler.load_state_dice(checkpoint['scheduler_state_dict'])
+    loss = checkpoint['loss']
+
+    return epoch, model, optimizer, scheduler, loss
\ No newline at end of file
diff --git a/sam2_unet/utils/dataset.py b/sam2_unet/utils/dataset.py
new file mode 100644
index 0000000..14d2778
--- /dev/null
+++ b/sam2_unet/utils/dataset.py
@@ -0,0 +1,224 @@
+import torchvision.transforms.functional as F
+import numpy as np
+import random
+import os
+import cv2
+import json
+import torch
+import albumentations as A
+from PIL import Image
+from torchvision.transforms import InterpolationMode
+from torch.utils.data import Dataset
+from PIL import Image
+
+CLASSES = [
+    'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
+    'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
+    'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
+    'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
+    'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
+    'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
+]
+CLASS2IND = {v: i for i, v in enumerate(CLASSES)}
+
+class ToTensor(object):
+
+    def __call__(self, data):
+        image, label = data['image'], data['label']
+        return {'image': F.to_tensor(image), 'label': F.to_tensor(label)}
+
+class Resize(object):
+
+    def __init__(self, size):
+        self.size = size
+
+    def __call__(self, data):
+        image, label = data['image'], data['label']
+
+        return {'image': F.resize(image, self.size), 'label': F.resize(label, self.size, interpolation=InterpolationMode.BICUBIC)}
+
+
+class RandomHorizontalFlip(object):
+    def __init__(self, p=0.5):
+        self.p = p
+
+    def __call__(self, data):
+        image, label = data['image'], data['label']
+
+        if random.random() < self.p:
+            return {'image': F.hflip(image), 'label': F.hflip(label)}
+
+        return {'image': image, 'label': label}
+
+class RandomVerticalFlip(object):
+    def __init__(self, p=0.5):
+        self.p = p
+
+    def __call__(self, data):
+        image, label = data['image'], data['label']
+
+        if random.random() < self.p:
+            return {'image': F.vflip(image), 'label': F.vflip(label)}
+
+        return {'image': image, 'label': label}
+
+class Normalize(object):
+    def __init__(self, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]):
+        self.mean = mean
+        self.std = std
+
+    def __call__(self, sample):
+        image, label = sample['image'], sample['label']
+        image = F.normalize(image, self.mean, self.std)
+        return {'image': image, 'label': label}
+    
+
+class FullDataset(Dataset):
+    def __init__(self, image_root, gt_root, size, mode):
+        self.image_root = image_root
+        self.gt_root = gt_root
+        self.is_train = True if mode == 'train' else False
+        self.images = {
+            os.path.relpath(os.path.join(root, fname), start=image_root)
+            for root, _dirs, files in os.walk(image_root)
+            for fname in files
+            if os.path.splitext(fname)[1].lower() == ".png"
+        }
+        self.gts = {
+            os.path.relpath(os.path.join(root, fname), start=gt_root)
+            for root, _dirs, files in os.walk(gt_root)
+            for fname in files
+            if os.path.splitext(fname)[1].lower() == ".json"
+        }
+
+        self.images = sorted(self.images)
+        self.gts = sorted(self.gts)
+        if mode == 'train':
+            self.transform = A.Resize(size, size)
+        else:
+            self.transform = A.Resize(size, size)
+
+    def __getitem__(self, idx):
+        # Image and label paths
+        image_name = self.images[idx]
+        image_path = os.path.join(self.image_root, image_name)
+        
+        # Read and normalize image
+        image = cv2.imread(image_path)
+        image = image.astype(np.float32) / 255.0
+        
+        # Get image height and width
+        image_height, image_width = image.shape[:2]
+        
+        # Label path
+        label_name = self.gts[idx]
+        label_path = os.path.join(self.gt_root, label_name)
+        
+        # Initialize label with the shape (H, W, num_classes)
+        label_shape = (image_height, image_width, len(CLASSES),)
+        label = np.zeros(label_shape, dtype=np.uint8)
+        
+        # Read annotations from label file
+        try:
+            with open(label_path, "r") as f:
+                annotations = json.load(f)
+        except FileNotFoundError:
+            raise FileNotFoundError(f"Label file not found at path: {label_path}")
+        
+        annotations = annotations.get("annotations", [])
+        
+        # Fill polygons in label
+        for ann in annotations:
+            c = ann.get("label")
+            if c not in CLASS2IND:
+                continue
+            
+            class_ind = CLASS2IND[c]
+            points = np.array(ann.get("points", []), dtype=np.int32)
+            
+            if points.size == 0:
+                continue
+            
+            class_label = np.zeros((image_height, image_width), dtype=np.uint8)
+            cv2.fillPoly(class_label, [points], 1)
+            label[..., class_ind] = class_label
+        
+        inputs = {"image": image, "mask": label} if self.is_train else {"image": image}
+        result = self.transform(**inputs)
+        
+        image = result["image"]
+        label = result["mask"] if self.is_train else label
+
+        # to tenser will be done later
+        image = image.transpose(2, 0, 1)    # channel first 포맷으로 변경합니다.
+        label = label.transpose(2, 0, 1)
+        
+        image = torch.from_numpy(image).float()
+        label = torch.from_numpy(label).float()
+        
+        return image, label
+
+    def __len__(self):
+        return len(self.images)
+
+    def rgb_loader(self, path):
+        with open(path, 'rb') as f:
+            img = Image.open(f)
+            return img.convert('RGB')
+
+class TestDataset:
+    def __init__(self, image_root, size):
+        self.image_root = image_root
+        self.images = {
+            os.path.relpath(os.path.join(root, fname), start=image_root)
+            for root, _dirs, files in os.walk(image_root)
+            for fname in files
+            if os.path.splitext(fname)[1].lower() == ".png"
+        }
+        
+        self.images = sorted(self.images)
+        self.transform = A.Resize(size, size)
+    
+    def __len__(self):
+        return len(self.images)
+    
+    def __getitem__(self, idx):
+        image_name = self.images[idx]
+        image_path = os.path.join(self.image_root, image_name)
+        
+        # Read and normalize image
+        image = cv2.imread(image_path)
+        image = image.astype(np.float32) / 255.0
+        
+        if self.transform is not None:
+            inputs = {"image": image}
+            result = self.transform(**inputs)
+            image = result["image"]
+
+        image = image.transpose(2, 0, 1)  
+        
+        image = torch.from_numpy(image).float()
+            
+        return image, image_name
+
+    def load_data(self):
+        image = self.rgb_loader(self.images[self.index])
+        image = self.transform(image).unsqueeze(0)
+
+        gt = self.binary_loader(self.gts[self.index])
+        gt = np.array(gt)
+
+        name = self.images[self.index].split('/')[-1]
+
+        self.index += 1
+        return image, gt, name
+
+    def rgb_loader(self, path):
+        with open(path, 'rb') as f:
+            img = Image.open(f)
+            return img.convert('RGB')
+
+    def binary_loader(self, path):
+        with open(path, 'rb') as f:
+            img = Image.open(f)
+            return img.convert('L')
\ No newline at end of file
diff --git a/sam2_unet/utils/loss.py b/sam2_unet/utils/loss.py
new file mode 100644
index 0000000..4c8e8ad
--- /dev/null
+++ b/sam2_unet/utils/loss.py
@@ -0,0 +1,12 @@
+import torch
+import torch.nn.functional as F
+
+def structure_loss(pred, mask):
+    weit = 1 + 5*torch.abs(F.avg_pool2d(mask, kernel_size=31, stride=1, padding=15) - mask)
+    wbce = F.binary_cross_entropy_with_logits(pred, mask, reduce='none')
+    wbce = (weit*wbce).sum(dim=(2, 3)) / weit.sum(dim=(2, 3))
+    pred = torch.sigmoid(pred)
+    inter = ((pred * mask)*weit).sum(dim=(2, 3))
+    union = ((pred + mask)*weit).sum(dim=(2, 3))
+    wiou = 1 - (inter + 1)/(union - inter+1)
+    return (wbce + wiou).mean()
\ No newline at end of file
diff --git a/sam2_unet/utils/optimizer.py b/sam2_unet/utils/optimizer.py
new file mode 100644
index 0000000..576a959
--- /dev/null
+++ b/sam2_unet/utils/optimizer.py
@@ -0,0 +1,26 @@
+import torch.optim as optim
+
+class OptimizerSelector():
+    def __init__(self, model, lr=1e-3):
+        self.model = model
+        self.lr = lr
+
+    def get_optimizer(self, optimizer, **kargs):
+        if optimizer == "adam":
+            return optim.Adam(self.model.parameters(), self.lr, **kargs)
+        elif optimizer == "adamw":
+            return optim.AdamW(self.model.parameters(), self.lr, **kargs)
+        elif optimizer == "sgd":
+            return optim.SGD(self.model.parameters(), self.lr, **kargs)
+        elif optimizer == "rmsprop":
+            return optim.RMSprop(self.model.parameters(), self.lr, **kargs)
+        elif optimizer == "nadam":
+            return optim.NAdam(self.model.parameters(), self.lr, **kargs)
+        elif optimizer == "radam":
+            return optim.RAdam(self.model.parameters(), self.lr, **kargs)
+        elif optimizer == "adagrad":
+            return optim.Adagrad(self.model.parameters(), self.lr, **kargs)
+        elif optimizer == "adadelta":
+            return optim.Adadelta(self.model.parameters(), self.lr, **kargs)
+        else:
+            raise ValueError(f"Unsupported optimizer: {optimizer}")
\ No newline at end of file
diff --git a/sam2_unet/utils/scheduler.py b/sam2_unet/utils/scheduler.py
new file mode 100644
index 0000000..3525242
--- /dev/null
+++ b/sam2_unet/utils/scheduler.py
@@ -0,0 +1,17 @@
+from torch.optim import lr_scheduler
+
+class SchedulerSelector():
+    def __init__(self, optimizer):
+        self.optimizer = optimizer
+
+    def get_scheduler(self, scheduler, **kargs):
+        if scheduler == "steplr":
+            return lr_scheduler.StepLR(self.optimizer, **kargs)
+        elif scheduler == "multisteplr":
+            return lr_scheduler.MultiStepLR(self.optimizer, **kargs)
+        elif scheduler == "reducelronplateau":
+            return lr_scheduler.ReduceLROnPlateau(self.optimizer, **kargs)
+        elif scheduler == "cosineannealinglr":
+            return lr_scheduler.CosineAnnealingLR(self.optimizer, **kargs)
+        else:
+            raise ValueError(f"Unsupported scheduler: {scheduler}")
\ No newline at end of file
diff --git a/sam2_unet/utils/wandb_logger.py b/sam2_unet/utils/wandb_logger.py
new file mode 100644
index 0000000..603ce06
--- /dev/null
+++ b/sam2_unet/utils/wandb_logger.py
@@ -0,0 +1,82 @@
+import wandb
+
+class WandbLogger:
+    def __init__(self, project_name="Hand Bone Image Segmentation", name=None):
+        """
+        Args:
+            project_name (str): wandb project name (default: "Hand Bone Image Segmentation")
+            name (str): wandb run name (optional)
+        """
+        self.project_name = project_name
+        self.name = name
+        self.run = None
+
+    def initialize(self, config):
+        """Initialize wandb run with config"""
+        self.run = wandb.init(
+            project=self.project_name,
+            name=self.name,
+            config=config
+        )
+
+    def log_metric(self, metrics, step=None):
+        """
+        Log metrics to wandb
+        
+        Args:
+            metrics (dict): metrics to log
+            step (int, optional): step number
+        """
+        if self.run is not None:
+            wandb.log(metrics, step=step)
+
+    def log_batch_metrics(self, loss, extra_info, learning_rate, step=None):
+        """
+        Log batch-level metrics
+        
+        Args:
+            loss (float): total loss value
+            extra_info (dict): dictionary containing detailed losses
+            learning_rate (float): current learning rate
+            step (int, optional): step number
+        """
+        metrics = {
+            "loss": loss,
+            "learning_rate": learning_rate,
+            **extra_info
+        }
+        self.log_metric(metrics, step)
+
+    def log_epoch_metrics(self, metrics):
+        """
+        Log epoch-level metrics
+        
+        Args:
+            metrics (dict): Dictionary containing all metrics to log
+                Expected keys: epoch, loss, cls_loss, angle_loss, iou_loss,
+                            learning_rate, epoch_time
+        """
+        if self.run is not None:
+            self.log_metric(metrics)
+
+    def log_model(self, model_path, model_name):
+        """
+        Log model checkpoint
+        
+        Args:
+            model_path (str): path to model checkpoint
+            model_name (str): name of model artifact
+        """
+        if self.run is not None:
+            artifact = wandb.Artifact(
+                model_name, 
+                type='model',
+                description=f"Model checkpoint at {model_path}"
+            )
+            artifact.add_file(model_path)
+            self.run.log_artifact(artifact)
+
+    def finish(self):
+        """End the wandb run"""
+        if self.run is not None:
+            wandb.finish()
\ No newline at end of file

From fb9188fc28ed4c149a3b1e0c11855b4916952827 Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Wed, 20 Nov 2024 22:12:05 +0900
Subject: [PATCH 038/106] [Feature] : now inference will predict maximum 2
 classes per pixel

---
 .../mmseg/models/segmentors/custom.py         | 25 +++++++++++++++++--
 1 file changed, 23 insertions(+), 2 deletions(-)

diff --git a/mmsegmentation/mmseg/models/segmentors/custom.py b/mmsegmentation/mmseg/models/segmentors/custom.py
index 3a03d50..9f585aa 100644
--- a/mmsegmentation/mmseg/models/segmentors/custom.py
+++ b/mmsegmentation/mmseg/models/segmentors/custom.py
@@ -4,6 +4,7 @@
 from mmseg.models.utils.wrappers import resize
 
 from mmengine.structures import PixelData
+import torch
 
 
 class PostProcessResultMixin:
@@ -68,9 +69,29 @@ def postprocess_result(self, seg_logits, data_samples):
             else:
                 i_seg_logits = seg_logits[i]
 
-            i_seg_logits = i_seg_logits.sigmoid()
-            i_seg_pred = (i_seg_logits > 0.5).to(i_seg_logits)
+            # i_seg_logits = i_seg_logits.sigmoid()
+            # i_seg_pred = (i_seg_logits > self.decode_head.threshold).to(i_seg_logits)
+            # Sigmoid로 변환하여 confidence 계산
+            i_seg_logits = i_seg_logits.sigmoid()  # [C, H, W]
 
+            # 각 픽셀별로 상위 2개의 클래스의 confidence 값과 인덱스 추출
+            topk_values, topk_indices = i_seg_logits.topk(2, dim=0)  # topk_values, topk_indices: [2, H, W]
+
+            # Threshold 기준을 적용하여 confidence 값이 threshold 이상인 경우만 남김
+            threshold_mask = topk_values > self.decode_head.threshold  # [2, H, W]
+
+            # i_seg_pred 초기화
+            i_seg_pred = torch.zeros_like(i_seg_logits)  # [C, H, W]
+
+            # threshold를 만족하는 상위 2개 클래스만 유지하고, 나머지는 0으로 처리
+            for j in range(2):  # 최대 2개의 클래스만 선택
+                # topk_indices는 [2, H, W]에서 i번째 인덱스 추출, 이를 [1, H, W]로 유지
+                class_indices = topk_indices[j:j+1, :, :]  # [1, H, W]
+                class_mask = threshold_mask[j:j+1, :, :].to(i_seg_logits.dtype)  # [1, H, W]
+                
+                # 선택된 클래스 위치에 값을 설정
+                i_seg_pred.scatter_(0, class_indices, class_mask)
+                
             data_samples[i].set_data(
                 {
                     "seg_logits": PixelData(**{"data": i_seg_logits}),

From 42f9adcd956d0a0069e8154b293917628545b2c0 Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Wed, 20 Nov 2024 22:16:35 +0900
Subject: [PATCH 039/106] [Feature]: add new head for segnext

---
 mmsegmentation/mmseg/models/decode_heads/__init__.py | 3 ++-
 mmsegmentation/mmseg/models/decode_heads/custom.py   | 6 +++++-
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/mmsegmentation/mmseg/models/decode_heads/__init__.py b/mmsegmentation/mmseg/models/decode_heads/__init__.py
index eef905a..8876164 100644
--- a/mmsegmentation/mmseg/models/decode_heads/__init__.py
+++ b/mmsegmentation/mmseg/models/decode_heads/__init__.py
@@ -40,6 +40,7 @@
     FCNHeadWithoutAccuracy,
     SegformerHeadWithoutAccuracy,
     UPerHeadWithoutAccuracy,
+    LightHamHeadWithoutAccuracy
 )
 
 __all__ = [
@@ -53,5 +54,5 @@
     'LightHamHead', 'PIDHead', 'DDRHead', 'VPDDepthHead', 'SideAdapterCLIPHead', "ASPPHeadWithoutAccuracy",
     "FCNHeadWithoutAccuracy",
     "SegformerHeadWithoutAccuracy",
-    "UPerHeadWithoutAccuracy",
+    "UPerHeadWithoutAccuracy", "LightHamHeadWithoutAccuracy"
 ]
diff --git a/mmsegmentation/mmseg/models/decode_heads/custom.py b/mmsegmentation/mmseg/models/decode_heads/custom.py
index 8995296..b698d9b 100644
--- a/mmsegmentation/mmseg/models/decode_heads/custom.py
+++ b/mmsegmentation/mmseg/models/decode_heads/custom.py
@@ -2,7 +2,7 @@
 
 from mmseg.registry import MODELS
 from mmseg.models.utils.wrappers import resize
-from mmseg.models.decode_heads import ASPPHead, FCNHead, SegformerHead, UPerHead
+from mmseg.models.decode_heads import ASPPHead, FCNHead, SegformerHead, UPerHead, LightHamHead
 
 
 class LossByFeatMixIn:
@@ -71,4 +71,8 @@ class SegformerHeadWithoutAccuracy(LossByFeatMixIn, SegformerHead):
 
 @MODELS.register_module()
 class UPerHeadWithoutAccuracy(LossByFeatMixIn, UPerHead):
+    pass
+
+@MODELS.register_module()
+class LightHamHeadWithoutAccuracy(LossByFeatMixIn, LightHamHead):
     pass
\ No newline at end of file

From bd6e2a29922a2ed828f9c6a56a82c064fd9814d4 Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Wed, 20 Nov 2024 22:24:13 +0900
Subject: [PATCH 040/106] [Feature]:add result visualization and add metric for
 multi label

---
 .../mmseg/evaluation/metrics/__init__.py      |  4 +-
 .../mmseg/evaluation/metrics/dice_metric.py   | 90 +++++++++++++++++++
 .../evaluation/metrics/submission_metric.py   | 44 ++++++++-
 3 files changed, 135 insertions(+), 3 deletions(-)

diff --git a/mmsegmentation/mmseg/evaluation/metrics/__init__.py b/mmsegmentation/mmseg/evaluation/metrics/__init__.py
index 0814de4..9ef2afa 100644
--- a/mmsegmentation/mmseg/evaluation/metrics/__init__.py
+++ b/mmsegmentation/mmseg/evaluation/metrics/__init__.py
@@ -2,7 +2,7 @@
 from .citys_metric import CityscapesMetric
 from .depth_metric import DepthMetric
 from .iou_metric import IoUMetric
-from .dice_metric import DiceMetric
+from .dice_metric import DiceMetric, DiceMetricForMultiLabel
 from .submission_metric import SubmissionMetric
 
-__all__ = ['IoUMetric', 'CityscapesMetric', 'DepthMetric', 'DiceMetric', 'SubmissionMetric']
+__all__ = ['IoUMetric', 'CityscapesMetric', 'DepthMetric', 'DiceMetric', 'SubmissionMetric', 'DiceMetricForMultiLabel']
diff --git a/mmsegmentation/mmseg/evaluation/metrics/dice_metric.py b/mmsegmentation/mmseg/evaluation/metrics/dice_metric.py
index 6ae18cb..629e25f 100644
--- a/mmsegmentation/mmseg/evaluation/metrics/dice_metric.py
+++ b/mmsegmentation/mmseg/evaluation/metrics/dice_metric.py
@@ -116,4 +116,94 @@ def compute_metrics(self, results):
             "mDice": torch.mean(dices_per_class).item(),
         }
 
+        return metrics
+
+
+
+
+
+
+@METRICS.register_module()
+class DiceMetricForMultiLabel(BaseMetric):
+    def __init__(self,
+                 collect_device='cpu',
+                 prefix=None,
+                 max_cnt_per_px = 2,
+                 threshold=0.4,
+                 **kwargs):
+        super().__init__(collect_device=collect_device, prefix=prefix)
+        
+    @staticmethod
+    def dice_coef(y_true, y_pred):        
+        y_true_f = y_true.flatten(-2)
+        y_pred_f = y_pred.flatten(-2)
+        intersection = torch.sum(y_true_f * y_pred_f, -1)
+
+        eps = 0.0001
+        return (2. * intersection + eps) / (torch.sum(y_true_f, -1) + torch.sum(y_pred_f, -1) + eps)
+
+    def post_process_pred_label(self, pred_label):
+        pass
+    
+    def process(self, data_batch, data_samples):
+        """Process one batch of data and data_samples.
+
+        The processed results should be stored in ``self.results``, which will
+        be used to compute the metrics when all batches have been processed.
+
+        Args:
+            data_batch (dict): A batch of data from the dataloader.
+            data_samples (Sequence[dict]): A batch of outputs from the model.
+        """
+        for data_sample in data_samples:
+            pred_label = data_sample['pred_sem_seg']['data']
+            
+            label = data_sample['gt_sem_seg']['data'].to(pred_label)
+            self.results.append(
+                self.dice_coef(label, pred_label)
+            )
+
+    def compute_metrics(self, results):
+        """Compute the metrics from processed results.
+
+        Args:
+            results (list): The processed results of each batch.
+
+        Returns:
+            Dict[str, float]: The computed metrics. The keys are the names of
+                the metrics, and the values are corresponding results.
+        """
+        logger: MMLogger = MMLogger.get_current_instance()
+            
+        results = torch.stack(self.results, 0)        
+        dices_per_class = torch.mean(results, 0)
+        avg_dice = torch.mean(dices_per_class)
+            
+        ret_metrics = {
+            "Dice": dices_per_class.detach().cpu().numpy(),
+        }
+        # summary table
+        ret_metrics_summary = OrderedDict({
+            ret_metric: np.round(np.nanmean(ret_metric_value) * 100, 2)
+            for ret_metric, ret_metric_value in ret_metrics.items()
+        })
+
+        # each class table
+        ret_metrics.pop('aAcc', None)
+        ret_metrics_class = OrderedDict({
+            ret_metric: np.round(ret_metric_value, 2)
+            for ret_metric, ret_metric_value in ret_metrics.items()
+        })
+        ret_metrics_class.update({'Class': CLASSES})
+        ret_metrics_class.move_to_end('Class', last=False)
+        class_table_data = PrettyTable()
+        for key, val in ret_metrics_class.items():
+            class_table_data.add_column(key, val)
+
+        print(class_table_data)
+        
+        metrics = {
+            "mDice": torch.mean(dices_per_class).item(),
+        }
+
         return metrics
\ No newline at end of file
diff --git a/mmsegmentation/mmseg/evaluation/metrics/submission_metric.py b/mmsegmentation/mmseg/evaluation/metrics/submission_metric.py
index 4829511..6ecff5b 100644
--- a/mmsegmentation/mmseg/evaluation/metrics/submission_metric.py
+++ b/mmsegmentation/mmseg/evaluation/metrics/submission_metric.py
@@ -4,6 +4,7 @@
 import numpy as np
 import pandas as pd
 from prettytable import PrettyTable
+import cv2
 
 import torch
 import torch.nn.functional as F
@@ -25,6 +26,15 @@
     'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
     'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
 ]
+PALETTE = [
+    (220, 20, 60), (119, 11, 32), (0, 0, 142), (0, 0, 230), (106, 0, 228),
+    (0, 60, 100), (0, 80, 100), (0, 0, 70), (0, 0, 192), (250, 170, 30),
+    (100, 170, 30), (220, 220, 0), (175, 116, 175), (250, 0, 30), (165, 42, 42),
+    (255, 77, 255), (0, 226, 252), (182, 182, 255), (0, 82, 0), (120, 166, 157),
+    (110, 76, 0), (174, 57, 255), (199, 100, 0), (72, 0, 118), (255, 179, 240),
+    (0, 125, 92), (209, 0, 151), (188, 208, 182), (0, 220, 176),
+]
+
 num_classes = len(CLASSES) + 1
 
 
@@ -34,6 +44,8 @@ def __init__(self,
                  collect_device='cpu',
                  prefix=None,
                  save_path='',
+                 max_vis_cnt=10,
+                 multi_label=True,
                  **kwargs):
         super().__init__(collect_device=collect_device, prefix=prefix)
         self.save_path = save_path
@@ -41,12 +53,25 @@ def __init__(self,
             self.save_path = '/data/ephemeral/home/submission'
         
         os.makedirs(self.save_path, exist_ok=True)
+        os.makedirs(os.path.join(self.save_path, 'img'), exist_ok=True)
         self.cnt = 0
+        self.max_vis_cnt = max_vis_cnt
+        self.multi_label=False
         
         # self.rles = []
         # self.filename_and_class = []
         
+    def label2rgb(self, label):
+        label = np.array(label)
+        image_size = label.shape[1:] + (3, )
+        image = np.zeros(image_size, dtype=np.uint8)
+        
+        for i, class_label in enumerate(label):
+            image[class_label == 1] = PALETTE[i]
             
+        return image
+    
+    
     def encode_mask_to_rle(self, mask):
         '''
         mask: numpy array binary mask 
@@ -109,11 +134,28 @@ def process(self, data_batch, data_samples):
             #     pred_label = F.interpolate(pred_label, size=ori_shape, mode="bilinear")
             pred_label = pred_label.cpu().numpy()
             
+            # 시각화를 위한 세팅
+            preds = []
             
-            pred_label = self.convert_to_class_masks(pred_label)
+            if not self.multi_label:
+                pred_label = self.convert_to_class_masks(pred_label)
+                
             for i, pred in enumerate(pred_label):
                 rle = self.encode_mask_to_rle(pred)
+                pred = self.decode_rle_to_mask(rle, height=2048, width=2048)
+                preds.append(pred)
                 self.results.append((rle, f"{CLASSES[i]}_{img_name}"))
+            
+            
+            if self.cnt < self.max_vis_cnt:
+                self.cnt += 1
+                fig, ax = plt.subplots(1, 2, figsize=(24, 12))
+                image = cv2.imread(img_path)
+                ax[0].imshow(image)
+                ax[1].imshow(self.label2rgb(preds))
+                plt.savefig(os.path.join(self.save_path, 'img', f"{img_name}_visualization.png"))
+                plt.close()
+            
         
             
     def compute_metrics(self, results):

From 9fcd45419812d265b095677adac1a9ea66250303 Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Wed, 20 Nov 2024 23:53:20 +0900
Subject: [PATCH 041/106] [Feature] : add validation

---
 sam2_unet/config.yaml      |   9 +--
 sam2_unet/train_v1.py      |  43 +++++++++-----
 sam2_unet/trainer.py       |  24 ++++----
 sam2_unet/utils/dataset.py | 117 ++++++++++++++++++-------------------
 4 files changed, 100 insertions(+), 93 deletions(-)

diff --git a/sam2_unet/config.yaml b/sam2_unet/config.yaml
index f80eef5..ddec3fb 100644
--- a/sam2_unet/config.yaml
+++ b/sam2_unet/config.yaml
@@ -11,8 +11,9 @@ train_num_workers: 8
 # valid
 valid_batch_size: 2
 valid_num_workers: 2
-kfold: 0
-val_every: 1
+kfold: 5
+k: 0
+val_every: 5
 threshold: 0.5
 
 # hyperparameter
@@ -27,7 +28,7 @@ optimizer_parameters:
 
 # scheduler
 scheduler: multisteplr
-scheduler_paramters:
+scheduler_parameters:
   milestones: [8, 16]
   gamma: 0.1
 
@@ -35,7 +36,7 @@ scheduler_paramters:
 random_seed: 2024
 
 # augmentation
-size: 512
+image_size: 512
 
 # wandb
 wandb_name: 
diff --git a/sam2_unet/train_v1.py b/sam2_unet/train_v1.py
index 79ae0f2..04ab071 100644
--- a/sam2_unet/train_v1.py
+++ b/sam2_unet/train_v1.py
@@ -1,8 +1,9 @@
 import os
+import yaml
+import torch
 import random
-import datetime
 import numpy as np
-import torch
+from datetime import datetime
 from torch.utils.data import DataLoader
 from utils.loss import structure_loss
 from utils.dataset import FullDataset
@@ -25,18 +26,24 @@ def set_seed(RANDOM_SEED):
 def main(cfg):    
     device = torch.device("cuda")
     model = SAM2UNet(cfg.hiera_path)
+    
+    transform = 
 
     train_dataset = FullDataset(
-        cfg.train_image_path, 
-        cfg.train_mask_path, 
-        cfg.image_size, 
-        mode='train')
+        image_root=cfg.train_image_path, 
+        gt_root=cfg.train_mask_path, 
+        is_train=True,
+        transforms=transform,
+        kfold=cfg.kfold,
+        k=cfg.k)
     
     valid_dataset = FullDataset(
-        cfg.train_image_path, 
-        cfg.train_mask_path, 
-        cfg.image_size, 
-        mode='valid')
+        image_root=cfg.train_image_path, 
+        gt_root=cfg.train_mask_path, 
+        is_train=False,
+        transforms=None,
+        kfold=cfg.kfold,
+        k=cfg.k)
 
     train_loader = DataLoader(
         train_dataset, 
@@ -56,15 +63,19 @@ def main(cfg):
     scheduler_selector = SchedulerSelector(optimizer)
     scheduler = scheduler_selector.get_scheduler(cfg.scheduler, **cfg.scheduler_parameters)
 
-    loss_fn = structure_loss()
+    loss_fn = structure_loss
 
     os.makedirs("./checkpoints", exist_ok=True)
     now = datetime.now()
     time = now.strftime('%Y-%m-%d_%H:%M:%S')
     save_dir = os.path.join('./checkpoints', time)
-    with open(os.path.join(save_dir, "config.txt"), "w") as f:
-        for arg, value in vars(cfg).items():
-            f.write(f"{arg}: {value} \n")
+    os.makedirs(save_dir, exist_ok=True)
+
+    # Config 저장
+    save_path = os.path.join(save_dir, "config.yaml")
+    OmegaConf.save(cfg, save_path)
+
+    print(f"Config saved at {save_path}")
 
     trainer = Trainer(
         model=model,
@@ -76,8 +87,8 @@ def main(cfg):
         loss_fn=loss_fn,
         epochs=cfg.max_epoch,
         save_dir=save_dir,
-        wandb_id=,
-        wandb_name=,
+        wandb_id=cfg.wandb_id,
+        wandb_name=cfg.wandb_name,
         resume=cfg.resume,
         ckpt_path=cfg.ckpt_path,
         start_epoch=cfg.start_epoch
diff --git a/sam2_unet/trainer.py b/sam2_unet/trainer.py
index d4dec31..d9f96b2 100644
--- a/sam2_unet/trainer.py
+++ b/sam2_unet/trainer.py
@@ -1,6 +1,6 @@
 import os
 from tqdm.auto import tqdm
-from utils.checkpoint import save_checkpoint
+from utils.checkpoint import save_checkpoint, load_checkpoint
 
 import torch
 import torch.nn.functional as F
@@ -18,6 +18,7 @@ def __init__(
         loss_fn,
         epochs,
         save_dir,
+        val_every,
         wandb_id,
         wandb_name,
         resume=False,
@@ -33,6 +34,7 @@ def __init__(
         self.loss_fn = loss_fn  # 손실 함수
         self.epochs = epochs  # 총 훈련 에폭 수
         self.save_dir = save_dir
+        self.val_every = val_every
         self.wandb_id = wandb_id
         self.wandb_name = wandb_name
         self.resume = resume # 학습 재개를 위한 것인지
@@ -52,7 +54,7 @@ def save_checkpoint_epoch(self, epoch: int, valid_loss: float, valid_dice: float
         save_checkpoint(self.model, self.optimizer, self.scheduler, epoch+1, valid_dice, ckpt_path)
         print(f"Checkpoint updated at epoch {epoch + 1} and saved as {ckpt_path}")
     
-    def dice_coef(y_true, y_pred):
+    def dice_coef(self, y_true, y_pred):
         y_true_f = y_true.flatten(2)
         y_pred_f = y_pred.flatten(2)
         intersection = torch.sum(y_true_f * y_pred_f, -1)
@@ -82,11 +84,9 @@ def train_epoch(self, train_loader: DataLoader, thr=0.5):
             train_loss += loss.item() * masks.shape[0]
 
             outputs = torch.sigmoid(pred0)
-            outputs = (outputs > thr).detach().cpu()
-            masks = masks.detach().cpu()
-
+            outputs = (outputs > thr)
             dice = self.dice_coef(outputs, masks)
-            train_dices.append(dice)
+            train_dices.append(dice.detach().cpu())
 
             del outputs, masks, dice
 
@@ -151,7 +151,6 @@ def train(self) -> None:
         if self.resume:
             self.load_settings()
         print(f"training start")
-        print(f"checkpoints saved in {self.save_dir}")
 
         self.model.to(self.device)
         for epoch in range(self.start_epoch, self.epochs):
@@ -160,16 +159,17 @@ def train(self) -> None:
             print(f"Epoch {epoch+1}/{self.epochs}")
             
             train_loss, train_dice = self.train_epoch(self.train_loader)
+            train_loss = train_loss / len(self.train_loader.dataset)
+
             valid_loss, valid_dice, dices_per_class = self.validate(self.valid_loader)
+            val_loss = val_loss / len(self.valid_loader.dataset)
 
-            train_loss, train_acc = train_loss / self.train_total, train_acc / self.train_total
-            val_loss, val_acc = val_loss / self.val_total, val_acc / self.val_total
-            
             print(f"Epoch {epoch+1}, Train Loss: {train_loss:.8f} | Train Dice: {train_dice:.8f} \nVaild Loss: {valid_loss:.8f} | Vaild Dice: {valid_dice:.8f}\n")
             
-            self.save_checkpoint_epoch(epoch, valid_loss, valid_dice)
+            if (epoch + 1) % self.val_every == 0:
+                self.save_checkpoint_epoch(epoch, valid_loss, valid_dice)
             
-        self.save_checkpoint_epoch(epoch, train_loss, train_acc, val_loss, val_acc)
+        self.save_checkpoint_epoch(epoch, valid_loss, valid_dice)
         
     def load_settings(self) -> None:
         print("loading prev training setttings")
diff --git a/sam2_unet/utils/dataset.py b/sam2_unet/utils/dataset.py
index 14d2778..74ad515 100644
--- a/sam2_unet/utils/dataset.py
+++ b/sam2_unet/utils/dataset.py
@@ -9,7 +9,7 @@
 from PIL import Image
 from torchvision.transforms import InterpolationMode
 from torch.utils.data import Dataset
-from PIL import Image
+from sklearn.model_selection import GroupKFold
 
 CLASSES = [
     'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
@@ -74,51 +74,68 @@ def __call__(self, sample):
     
 
 class FullDataset(Dataset):
-    def __init__(self, image_root, gt_root, size, mode):
-        self.image_root = image_root
-        self.gt_root = gt_root
-        self.is_train = True if mode == 'train' else False
-        self.images = {
+    def __init__(self, image_root, gt_root, is_train=True, transforms=None, kfold=5, k=0):
+        pngs = {
             os.path.relpath(os.path.join(root, fname), start=image_root)
             for root, _dirs, files in os.walk(image_root)
             for fname in files
             if os.path.splitext(fname)[1].lower() == ".png"
         }
-        self.gts = {
+        jsons = {
             os.path.relpath(os.path.join(root, fname), start=gt_root)
             for root, _dirs, files in os.walk(gt_root)
             for fname in files
             if os.path.splitext(fname)[1].lower() == ".json"
         }
+        self.image_root = image_root
+        self.gt_root = gt_root
+        self.is_train = is_train
+        pngs = sorted(pngs)
+        jsons = sorted(jsons)
+
+        _filenames = np.array(pngs)
+        _labelnames = np.array(jsons)
+        
+        groups = [os.path.dirname(fname) for fname in _filenames]
+        
+        ys = [0 for fname in _filenames]
+        
+        gkf = GroupKFold(n_splits=kfold)
+        
+        filenames = []
+        labelnames = []
+        for i, (x, y) in enumerate(gkf.split(_filenames, ys, groups)):
+            if is_train:
+                if i == k:
+                    continue
+                filenames += list(_filenames[y])
+                labelnames += list(_labelnames[y])
+            
+            else:
+                if i != k:
+                    continue
+                filenames = list(_filenames[y])
+                labelnames = list(_labelnames[y])
+                break
 
-        self.images = sorted(self.images)
-        self.gts = sorted(self.gts)
-        if mode == 'train':
-            self.transform = A.Resize(size, size)
-        else:
-            self.transform = A.Resize(size, size)
+        self.images = filenames
+        self.labels = labelnames
+        self.transform = transforms
 
     def __getitem__(self, idx):
-        # Image and label paths
         image_name = self.images[idx]
         image_path = os.path.join(self.image_root, image_name)
         
-        # Read and normalize image
         image = cv2.imread(image_path)
-        image = image.astype(np.float32) / 255.0
+        image = image / 255.
         
-        # Get image height and width
-        image_height, image_width = image.shape[:2]
-        
-        # Label path
         label_name = self.gts[idx]
         label_path = os.path.join(self.gt_root, label_name)
         
-        # Initialize label with the shape (H, W, num_classes)
+        image_height, image_width = image.shape[:2]
         label_shape = (image_height, image_width, len(CLASSES),)
         label = np.zeros(label_shape, dtype=np.uint8)
         
-        # Read annotations from label file
         try:
             with open(label_path, "r") as f:
                 annotations = json.load(f)
@@ -143,14 +160,14 @@ def __getitem__(self, idx):
             cv2.fillPoly(class_label, [points], 1)
             label[..., class_ind] = class_label
         
-        inputs = {"image": image, "mask": label} if self.is_train else {"image": image}
-        result = self.transform(**inputs)
-        
-        image = result["image"]
-        label = result["mask"] if self.is_train else label
+        if self.transform is not None:
+            inputs = {"image": image, "mask": label} if self.is_train else {"image": image}
+            result = self.transform(**inputs)
+            
+            image = result["image"]
+            label = result["mask"] if self.is_train else label
 
-        # to tenser will be done later
-        image = image.transpose(2, 0, 1)    # channel first 포맷으로 변경합니다.
+        image = image.transpose(2, 0, 1)
         label = label.transpose(2, 0, 1)
         
         image = torch.from_numpy(image).float()
@@ -167,17 +184,18 @@ def rgb_loader(self, path):
             return img.convert('RGB')
 
 class TestDataset:
-    def __init__(self, image_root, size):
-        self.image_root = image_root
-        self.images = {
+    def __init__(self, image_root, transform=None):
+        pngs = {
             os.path.relpath(os.path.join(root, fname), start=image_root)
             for root, _dirs, files in os.walk(image_root)
             for fname in files
             if os.path.splitext(fname)[1].lower() == ".png"
         }
-        
-        self.images = sorted(self.images)
-        self.transform = A.Resize(size, size)
+        pngs = sorted(pngs)
+
+        self.image_root = image_root
+        self.images = np.array(pngs)
+        self.transform = transform
     
     def __len__(self):
         return len(self.images)
@@ -186,39 +204,16 @@ def __getitem__(self, idx):
         image_name = self.images[idx]
         image_path = os.path.join(self.image_root, image_name)
         
-        # Read and normalize image
         image = cv2.imread(image_path)
-        image = image.astype(np.float32) / 255.0
+        image = image / 255.
         
         if self.transform is not None:
             inputs = {"image": image}
             result = self.transform(**inputs)
             image = result["image"]
 
-        image = image.transpose(2, 0, 1)  
+        image = image.transpose(2, 0, 1)
         
         image = torch.from_numpy(image).float()
             
-        return image, image_name
-
-    def load_data(self):
-        image = self.rgb_loader(self.images[self.index])
-        image = self.transform(image).unsqueeze(0)
-
-        gt = self.binary_loader(self.gts[self.index])
-        gt = np.array(gt)
-
-        name = self.images[self.index].split('/')[-1]
-
-        self.index += 1
-        return image, gt, name
-
-    def rgb_loader(self, path):
-        with open(path, 'rb') as f:
-            img = Image.open(f)
-            return img.convert('RGB')
-
-    def binary_loader(self, path):
-        with open(path, 'rb') as f:
-            img = Image.open(f)
-            return img.convert('L')
\ No newline at end of file
+        return image, image_name
\ No newline at end of file

From e581702b44c3f7f94e09f58caec1726b3dccaf8b Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Thu, 21 Nov 2024 00:03:44 +0900
Subject: [PATCH 042/106] [Fix]:revise some error based on mmengine 0.10.5 docs

---
 .../_custom_/_base_/default_runtime.py        |  4 +--
 .../_custom_/_base_/runtime_for_test.py       | 24 +++++++++++++
 .../configs/_custom_/_base_/schedule_160k.py  | 18 ++++------
 .../configs/_custom_/_base_/xraydata2.py      | 35 ++++++++++++++-----
 4 files changed, 58 insertions(+), 23 deletions(-)
 create mode 100644 mmsegmentation/configs/_custom_/_base_/runtime_for_test.py

diff --git a/mmsegmentation/configs/_custom_/_base_/default_runtime.py b/mmsegmentation/configs/_custom_/_base_/default_runtime.py
index 7ba44fe..b299fdc 100644
--- a/mmsegmentation/configs/_custom_/_base_/default_runtime.py
+++ b/mmsegmentation/configs/_custom_/_base_/default_runtime.py
@@ -1,5 +1,4 @@
 default_scope = 'mmseg'
-fp16 = dict(loss_scale=512.)
 
 env_cfg = dict(
     cudnn_benchmark=True,
@@ -33,4 +32,5 @@
             num_eval_images=10)
     ])
 
-tta_model = dict(type='SegTTAModel')
\ No newline at end of file
+tta_model = dict(type='SegTTAModel')
+randomness=dict(seed=42)
\ No newline at end of file
diff --git a/mmsegmentation/configs/_custom_/_base_/runtime_for_test.py b/mmsegmentation/configs/_custom_/_base_/runtime_for_test.py
new file mode 100644
index 0000000..768a457
--- /dev/null
+++ b/mmsegmentation/configs/_custom_/_base_/runtime_for_test.py
@@ -0,0 +1,24 @@
+default_scope = 'mmseg'
+fp16 = dict(loss_scale=512.)
+
+env_cfg = dict(
+    cudnn_benchmark=True,
+    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+    dist_cfg=dict(backend='nccl'),
+)
+vis_backends = [dict(type='LocalVisBackend')
+                ]
+visualizer = dict(
+    type='SegLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+log_processor = dict(by_epoch=False)
+log_level = 'INFO'
+load_from = None
+resume = False
+
+log_config = dict(
+    interval=1,
+    hooks=[
+        dict(type='TextLoggerHook', by_epoch=False)
+    ])
+
+tta_model = dict(type='SegTTAModel')
\ No newline at end of file
diff --git a/mmsegmentation/configs/_custom_/_base_/schedule_160k.py b/mmsegmentation/configs/_custom_/_base_/schedule_160k.py
index 4bf3092..33a9da2 100644
--- a/mmsegmentation/configs/_custom_/_base_/schedule_160k.py
+++ b/mmsegmentation/configs/_custom_/_base_/schedule_160k.py
@@ -4,22 +4,16 @@
 T_max = max_iters-warm_up_step
 
 # optimizer
-embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
 optimizer = dict(
     type='AdamW', lr=0.0001, weight_decay=0.05, eps=1e-8, betas=(0.9, 0.999))
 optim_wrapper = dict(
-    type='OptimWrapper',
+    type='AmpOptimWrapper',
     optimizer=optimizer,
     clip_grad=dict(max_norm=0.01, norm_type=2),
-    accumulative_counts=2,
-    paramwise_cfg=dict(
-        custom_keys={
-            'backbone': dict(lr_mult=0.1, decay_mult=1.0),
-            'query_embed': embed_multi,
-            'query_feat': embed_multi,
-            'level_embed': embed_multi,
-        },
-        norm_decay_mult=0.0))
+    accumulative_counts=1
+    )
+
+
 # learning policy
 param_scheduler = [
     dict(type='LinearLR',
@@ -33,7 +27,7 @@
          begin=warm_up_step,
          end=max_iters)
 ]
-optimizer_config = dict(type="GradientCumulativeOptimizerHook", cumulative_iters=2)
+
 
 # training schedule for 90k
 train_cfg = dict(type='IterBasedTrainLoop', 
diff --git a/mmsegmentation/configs/_custom_/_base_/xraydata2.py b/mmsegmentation/configs/_custom_/_base_/xraydata2.py
index fa9bbca..cb6aab7 100644
--- a/mmsegmentation/configs/_custom_/_base_/xraydata2.py
+++ b/mmsegmentation/configs/_custom_/_base_/xraydata2.py
@@ -1,22 +1,28 @@
 # dataset settings
-dataset_type = 'XRayDataset'
-resize_size = (1024, 1024)
-data_root = "/data/ephemeral/home/data"
+dataset_type = 'XRayDataset2'
 
 
 train_pipeline = [
             dict(type='LoadImageFromFile'),
             dict(type='LoadXRayAnnotations'),
-            dict(type='Resize', scale=resize_size),
+            dict(type='Resize', scale=(1280, 1280)),
+            dict(type='RandomFlip', prob=0.5),
+            dict(type='RandomRotate', prob=0.5, degree=15),
+            dict(type='PhotoMetricDistortion'),
             dict(type='TransposeAnnotations'),
             dict(type='PackSegInputs')
         ]
-test_pipeline = [
+val_pipeline = [
             dict(type='LoadImageFromFile'),
             dict(type='LoadXRayAnnotations'),
             dict(type='TransposeAnnotations'),
             dict(type='PackSegInputs')
         ]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 2048), keep_ratio=True),
+    dict(type='PackSegInputs')
+]
 
 
 img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
@@ -51,11 +57,22 @@
     sampler=dict(type='DefaultSampler', shuffle=False),
     dataset=dict(
         type=dataset_type,
-        data_root=data_root,
         is_train = False,
+        pipeline=val_pipeline))
+
+
+test_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='XRayDataset',
+        data_root='/data/ephemeral/home/cityscapes_format_xlay_kfold',
+        data_prefix=dict(img_path='leftImg8bit/test'),
+        img_suffix='.png',
         pipeline=test_pipeline))
-test_dataloader = val_dataloader
 
 
-val_evaluator = dict(type='DiceMetric')
-test_evaluator = dict(type='DiceMetric')
\ No newline at end of file
+val_evaluator = dict(type='DiceMetricForMultiLabel')
+test_evaluator = dict(type='SubmissionMetric')
\ No newline at end of file

From b2f7f11313bab2c53f5c64e12c86b4b078df5091 Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Thu, 21 Nov 2024 00:11:40 +0900
Subject: [PATCH 043/106] [Feature]:add segformer config

---
 .../segformer/segformer_cityscapes.py         | 90 +++++++++++++++++++
 1 file changed, 90 insertions(+)
 create mode 100644 mmsegmentation/configs/_custom_/segformer/segformer_cityscapes.py

diff --git a/mmsegmentation/configs/_custom_/segformer/segformer_cityscapes.py b/mmsegmentation/configs/_custom_/segformer/segformer_cityscapes.py
new file mode 100644
index 0000000..a691a4b
--- /dev/null
+++ b/mmsegmentation/configs/_custom_/segformer/segformer_cityscapes.py
@@ -0,0 +1,90 @@
+_base_ = [
+    '../_base_/xraydata2.py',
+    '../_base_/default_runtime.py', '../_base_/schedule_160k.py'
+]
+
+
+checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b5_20220624-658746d9.pth'  # noqa
+load_from = 'https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_8x1_1024x1024_160k_cityscapes/segformer_mit-b5_8x1_1024x1024_160k_cityscapes_20211206_072934-87a052ec.pth'
+resume = False
+
+crop_size = (1024, 1024)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    size=crop_size,
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+
+model = dict(
+    type='EncoderDecoderWithoutArgmax',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='MixVisionTransformer',
+        in_channels=3,
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        embed_dims=64,
+        num_stages=4,
+        num_layers=[3, 6, 40, 3],
+        num_heads=[1, 2, 5, 8],
+        patch_sizes=[7, 3, 3, 3],
+        sr_ratios=[8, 4, 2, 1],
+        out_indices=(0, 1, 2, 3),
+        mlp_ratio=4,
+        qkv_bias=True,
+        drop_rate=0.0,
+        attn_drop_rate=0.0,
+        drop_path_rate=0.1
+        ),
+    decode_head=dict(
+        type='SegformerHeadWithoutAccuracy',
+        in_channels=[64, 128, 320, 512],
+        in_index=[0, 1, 2, 3],
+        channels=256,
+        dropout_ratio=0.1,
+        num_classes=29,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        threshold=0.4,
+        loss_decode=[
+            dict(type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
+            dict(type='FocalLoss', use_sigmoid=True, loss_weight=1.0),
+            dict(type='DiceLoss', use_sigmoid=True, loss_weight=1.0)
+        ]
+        ),
+    train_cfg=dict(),
+    test_cfg=dict(mode='slide', crop_size=(1024, 1024), stride=(768, 768))
+    )
+
+
+
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
+    paramwise_cfg=dict(
+        custom_keys={
+            'pos_block': dict(decay_mult=0.),
+            'norm': dict(decay_mult=0.),
+            'head': dict(lr_mult=10.)
+        }))
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        eta_min=0.0,
+        power=1.0,
+        begin=1500,
+        end=30000,
+        by_epoch=False,
+    )
+]
+
+train_dataloader = dict(batch_size=1, num_workers=4)
+val_dataloader = dict(batch_size=1, num_workers=4)
\ No newline at end of file

From 1a939a41ece0effe068c1370553f61a3214f756b Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Thu, 21 Nov 2024 01:05:03 +0900
Subject: [PATCH 044/106] [Feature]:git ignore nohup.out

---
 .gitignore | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index 2d31e07..a81f52b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -20,4 +20,7 @@ __pycache__
 *.xlsx
 
 # wandb
-wandb/
\ No newline at end of file
+wandb/
+
+# mmsegmentation 제외
+.out
\ No newline at end of file

From 485aa830efb0d47fc343320e665d0430b9cc3d4a Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Thu, 21 Nov 2024 04:25:13 +0900
Subject: [PATCH 045/106] [Feature]:add baselind

---
 mmsegmentation/baseline.py                    |  246 ++
 .../_baseline_/config_for_this_example.py     |   71 +
 .../configs/_baseline_/dataset_setting.py     |   49 +
 .../segformer/segformer_cityscapes.py         |    4 +-
 mmsegmentation/mmseg/datasets/xray2.py        |  112 +-
 .../mmseg/evaluation/metrics/dice_metric.py   |    4 -
 mmsegmentation/nohup.out                      | 2216 -----------------
 7 files changed, 395 insertions(+), 2307 deletions(-)
 create mode 100644 mmsegmentation/baseline.py
 create mode 100644 mmsegmentation/configs/_baseline_/config_for_this_example.py
 create mode 100644 mmsegmentation/configs/_baseline_/dataset_setting.py
 delete mode 100644 mmsegmentation/nohup.out

diff --git a/mmsegmentation/baseline.py b/mmsegmentation/baseline.py
new file mode 100644
index 0000000..9657ecb
--- /dev/null
+++ b/mmsegmentation/baseline.py
@@ -0,0 +1,246 @@
+import os
+import json
+from collections import OrderedDict, defaultdict
+import numpy as np
+import pandas as pd
+import cv2
+from sklearn.model_selection import GroupKFold
+import matplotlib.pyplot as plt
+from prettytable import PrettyTable
+from tqdm.auto import tqdm
+
+import torch
+from torch import nn
+import torch.nn.functional as F
+from mmseg.registry import DATASETS, TRANSFORMS, MODELS, METRICS
+from mmseg.datasets import BaseSegDataset
+from mmseg.models.segmentors import EncoderDecoder
+from mmseg.models.decode_heads import ASPPHead, FCNHead, SegformerHead
+from mmseg.models.utils.wrappers import resize
+from mmseg.structures import SegDataSample
+
+
+from mmengine.config import Config
+from mmengine.dataset import Compose
+from mmengine.runner import Runner, load_checkpoint
+from mmengine.evaluator import BaseMetric
+from mmengine.logging import MMLogger, print_log
+from mmengine.structures import PixelData
+
+from mmcv.transforms import BaseTransform
+
+
+
+
+##############################
+# 데이터 경로를 입력하세요
+
+IMAGE_ROOT = "/data/ephemeral/home/data/train/DCM"
+TEST_IMAGE_ROOT = "/data/ephemeral/home/data/test/DCM"
+LABEL_ROOT = "/data/ephemeral/home/data/train/outputs_json"
+CONFIG_PATH = "/data/ephemeral/home/parkjunil/level2-cv-semanticsegmentation-cv-19-lv3/mmsegmentation/configs/_baseline_/config_for_this_example.py"
+
+CLASSES = [
+    'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
+    'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
+    'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
+    'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
+    'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
+    'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
+]
+CLASS2IND = {v: i for i, v in enumerate(CLASSES)}
+IND2CLASS = {v: k for k, v in CLASS2IND.items()}
+pngs = {
+    os.path.relpath(os.path.join(root, fname), start=IMAGE_ROOT)
+    for root, _dirs, files in os.walk(IMAGE_ROOT)
+    for fname in files
+    if os.path.splitext(fname)[1].lower() == ".png"
+}
+
+jsons = {
+    os.path.relpath(os.path.join(root, fname), start=LABEL_ROOT)
+    for root, _dirs, files in os.walk(LABEL_ROOT)
+    for fname in files
+    if os.path.splitext(fname)[1].lower() == ".json"
+}
+
+pngs = sorted(pngs)
+jsons = sorted(jsons)
+    
+
+# define colors
+PALETTE = [
+    (220, 20, 60), (119, 11, 32), (0, 0, 142), (0, 0, 230), (106, 0, 228),
+    (0, 60, 100), (0, 80, 100), (0, 0, 70), (0, 0, 192), (250, 170, 30),
+    (100, 170, 30), (220, 220, 0), (175, 116, 175), (250, 0, 30), (165, 42, 42),
+    (255, 77, 255), (0, 226, 252), (182, 182, 255), (0, 82, 0), (120, 166, 157),
+    (110, 76, 0), (174, 57, 255), (199, 100, 0), (72, 0, 118), (255, 179, 240),
+    (0, 125, 92), (209, 0, 151), (188, 208, 182), (0, 220, 176),
+]
+
+# utility function
+# this does not care overlap
+def label2rgb(label):
+    image_size = label.shape[1:] + (3, )
+    image = np.zeros(image_size, dtype=np.uint8)
+
+    for i, class_label in enumerate(label):
+        image[class_label == 1] = PALETTE[i]
+
+    return image
+
+def _preprare_data(imgs, model, cfg):
+    for t in cfg.test_pipeline:
+        if t.get('type') in ['LoadXRayAnnotations', 'TransposeAnnotations']:
+            cfg.test_pipeline.remove(t)
+
+    is_batch = True
+    if not isinstance(imgs, (list, tuple)):
+        imgs = [imgs]
+        is_batch = False
+
+    if isinstance(imgs[0], np.ndarray):
+        cfg.test_pipeline[0]['type'] = 'LoadImageFromNDArray'
+
+    # TODO: Consider using the singleton pattern to avoid building
+    # a pipeline for each inference
+    pipeline = Compose(cfg.test_pipeline)
+
+    data = defaultdict(list)
+    for img in imgs:
+        if isinstance(img, np.ndarray):
+            data_ = dict(img=img)
+        else:
+            data_ = dict(img_path=img)
+        data_ = pipeline(data_)
+        data['inputs'].append(data_['inputs'])
+        data['data_samples'].append(data_['data_samples'])
+
+    return data, is_batch
+
+
+def encode_mask_to_rle(mask):
+    '''
+    mask: numpy array binary mask
+    1 - mask
+    0 - background
+    Returns encoded run length
+    '''
+    pixels = mask.flatten()
+    pixels = np.concatenate([[0], pixels, [0]])
+    runs = np.where(pixels[1:] != pixels[:-1])[0] + 1
+    runs[1::2] -= runs[::2]
+    return ' '.join(str(x) for x in runs)
+
+
+def decode_rle_to_mask(rle, height, width):
+    s = rle.split()
+    starts, lengths = [np.asarray(x, dtype=int) for x in (s[0:][::2], s[1:][::2])]
+    starts -= 1
+    ends = starts + lengths
+    img = np.zeros(height * width, dtype=np.uint8)
+
+    for lo, hi in zip(starts, ends):
+        img[lo:hi] = 1
+
+    return img.reshape(height, width)
+
+
+def test(model, image_paths, thr=0.5):
+    rles = []
+    filename_and_class = []
+    with torch.no_grad():
+        n_class = len(CLASSES)
+
+        for step, image_path in tqdm(enumerate(image_paths), total=len(image_paths)):
+            img = cv2.imread(os.path.join(IMAGE_ROOT,image_path))
+
+            # prepare data
+            data, is_batch = _preprare_data(img, model)
+
+            # forward the model
+            with torch.no_grad():
+                outputs = model.test_step(data)
+
+            outputs = outputs[0].pred_sem_seg.data
+            outputs = outputs[None]
+
+            # restore original size
+            outputs = F.interpolate(outputs, size=(2048, 2048), mode="bilinear")
+            outputs = torch.sigmoid(outputs)
+            outputs = (outputs > thr).detach().cpu().numpy()
+
+            output = outputs[0]
+            image_name = os.path.basename(image_path)
+            for c, segm in enumerate(output):
+                rle = encode_mask_to_rle(segm)
+                rles.append(rle)
+                filename_and_class.append(f"{IND2CLASS[c]}_{image_name}")
+
+    return rles, filename_and_class
+
+
+def load_config():
+    # load config
+    cfg = Config.fromfile(CONFIG_PATH)
+    cfg.launcher = "none"
+    cfg.work_dir = "/data/ephemeral/home/parkjunil/work_dir/baseline"
+
+    # resume training
+    cfg.resume = False
+    return cfg
+
+def train():
+    # load config
+    cfg =load_config()
+    
+    runner = Runner.from_cfg(cfg)
+
+    # start training
+    runner.train()
+
+
+def visualize():
+    cfg =load_config()
+    model = MODELS.build(cfg.model)
+    
+    checkpoint = load_checkpoint(
+        model,
+        "baseline2/iter_20000.pth",
+        map_location='cpu'
+    )
+    img = cv2.imread(os.path.join(IMAGE_ROOT, "ID001", "image1661130828152_R.png"))
+    # prepare data
+    data, is_batch = _preprare_data(img, model)
+
+    # forward the model
+    with torch.no_grad():
+        results = model.test_step(data)
+    plt.imshow(label2rgb(results[0].pred_sem_seg.data))
+
+
+def inference():
+    cfg = load_config()
+    model = MODELS.build(cfg.model)
+    
+    pngs = {
+        os.path.relpath(os.path.join(root, fname), start=TEST_IMAGE_ROOT)
+        for root, _dirs, files in os.walk(IMAGE_ROOT)
+        for fname in files
+        if os.path.splitext(fname)[1].lower() == ".png"
+    }
+    
+    rles, filename_and_class = test(model, pngs)
+    classes, filename = zip(*[x.split("_") for x in filename_and_class])
+    
+    df = pd.DataFrame({
+        "image_name": filename,
+        "class": classes,
+        "rle": rles,
+    })
+    df.tail(30)
+    df.to_csv("submission.csv", index=False)
+
+
+if __name__ == "__main__":
+    train()
\ No newline at end of file
diff --git a/mmsegmentation/configs/_baseline_/config_for_this_example.py b/mmsegmentation/configs/_baseline_/config_for_this_example.py
new file mode 100644
index 0000000..173866d
--- /dev/null
+++ b/mmsegmentation/configs/_baseline_/config_for_this_example.py
@@ -0,0 +1,71 @@
+# Train Segformer Mit B3
+_base_ = [
+    "../_base_/models/segformer_mit-b0.py",
+    "./dataset_setting.py",
+    "../_base_/default_runtime.py"
+]
+
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[0., 0., 0.],
+    std=[255., 255., 255.],
+    bgr_to_rgb=True,
+    size=(512, 512),
+    pad_val=0,
+    seg_pad_val=255,
+)
+
+checkpoint="https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b3_20220624-13b1141c.pth"
+model = dict(
+    type='EncoderDecoderWithoutArgmax',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
+        embed_dims=64,
+        num_heads=[1, 2, 5, 8],
+        num_layers=[3, 4, 18, 3]),
+    decode_head=dict(
+        type='SegformerHeadWithoutAccuracy',
+        in_channels=[64, 128, 320, 512],
+        num_classes=29,
+        loss_decode=dict(
+            type='CrossEntropyLoss',
+            use_sigmoid=True,
+            loss_weight=1.0,
+        ),
+    ),
+)
+
+# optimizer
+optimizer = dict(type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
+
+# mixed precision
+fp16 = dict(loss_scale='dynamic')
+
+# learning policy
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500
+    ),
+    dict(
+        type='PolyLR',
+        eta_min=0.0,
+        power=1.0,
+        begin=1500,
+        end=20000,
+        by_epoch=False,
+    )
+]
+# training schedule for 20k
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=20000, val_interval=2000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=2000),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook')
+)
\ No newline at end of file
diff --git a/mmsegmentation/configs/_baseline_/dataset_setting.py b/mmsegmentation/configs/_baseline_/dataset_setting.py
new file mode 100644
index 0000000..1f5a9b1
--- /dev/null
+++ b/mmsegmentation/configs/_baseline_/dataset_setting.py
@@ -0,0 +1,49 @@
+# dataset settings
+dataset_type = 'XRayDataset2'
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadXRayAnnotations'),
+    dict(type='Resize', scale=(512, 512)),
+    dict(type='TransposeAnnotations'),
+    dict(type='PackSegInputs')
+]
+val_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(512, 512)),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadXRayAnnotations'),
+    dict(type='TransposeAnnotations'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(512, 512)),
+    dict(type='PackSegInputs')
+]
+
+train_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        is_train=True,
+        pipeline=train_pipeline
+    )
+)
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=0,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        is_train=False,
+        pipeline=val_pipeline
+    )
+)
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='DiceMetricForMultiLabel')
+test_evaluator = val_evaluator
\ No newline at end of file
diff --git a/mmsegmentation/configs/_custom_/segformer/segformer_cityscapes.py b/mmsegmentation/configs/_custom_/segformer/segformer_cityscapes.py
index a691a4b..a5f8971 100644
--- a/mmsegmentation/configs/_custom_/segformer/segformer_cityscapes.py
+++ b/mmsegmentation/configs/_custom_/segformer/segformer_cityscapes.py
@@ -51,8 +51,8 @@
         threshold=0.4,
         loss_decode=[
             dict(type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
-            dict(type='FocalLoss', use_sigmoid=True, loss_weight=1.0),
-            dict(type='DiceLoss', use_sigmoid=True, loss_weight=1.0)
+            # dict(type='FocalLoss', use_sigmoid=True, loss_weight=1.0),
+            # dict(type='DiceLoss', use_sigmoid=True, loss_weight=1.0)
         ]
         ),
     train_cfg=dict(),
diff --git a/mmsegmentation/mmseg/datasets/xray2.py b/mmsegmentation/mmseg/datasets/xray2.py
index 92c4161..9396f74 100644
--- a/mmsegmentation/mmseg/datasets/xray2.py
+++ b/mmsegmentation/mmseg/datasets/xray2.py
@@ -74,23 +74,32 @@ def __init__(self, is_train, **kwargs):
         super().__init__(**kwargs)
         
     def load_data_list(self):
+        _filenames = np.array(pngs)
+        _labelnames = np.array(jsons)
+
+        groups = [os.path.dirname(fname) for fname in _filenames]
+
+        # dummy label
+        ys = [0 for fname in _filenames]
+
+        gkf = GroupKFold(n_splits=5)
+
         filenames = []
         labelnames = []
-        valid_set_num = 2
         for i, (x, y) in enumerate(gkf.split(_filenames, ys, groups)):
             if self.is_train:
-                if i == valid_set_num:
+                if i == 0:
                     continue
-                    
+
                 filenames += list(_filenames[y])
                 labelnames += list(_labelnames[y])
-            
+
             else:
-                if i == valid_set_num:
-                    filenames = list(_filenames[y])
-                    labelnames = list(_labelnames[y])
-                    break
-        
+                filenames = list(_filenames[y])
+                labelnames = list(_labelnames[y])
+
+                break
+
         data_list = []
         for i, (img_path, ann_path) in enumerate(zip(filenames, labelnames)):
             data_info = dict(
@@ -98,7 +107,7 @@ def load_data_list(self):
                 seg_map_path=os.path.join(LABEL_ROOT, ann_path),
             )
             data_list.append(data_info)
-        
+
         return data_list
         
 
@@ -106,31 +115,31 @@ def load_data_list(self):
 class LoadXRayAnnotations(BaseTransform):
     def transform(self, result):
         label_path = result["seg_map_path"]
-        
+
         image_size = (2048, 2048)
-        
+
         # process a label of shape (H, W, NC)
         label_shape = image_size + (len(CLASSES), )
         label = np.zeros(label_shape, dtype=np.uint8)
-        
+
         # read label file
         with open(label_path, "r") as f:
             annotations = json.load(f)
         annotations = annotations["annotations"]
-        
+
         # iterate each class
         for ann in annotations:
             c = ann["label"]
             class_ind = CLASS2IND[c]
             points = np.array(ann["points"])
-            
+
             # polygon to mask
             class_label = np.zeros(image_size, dtype=np.uint8)
             cv2.fillPoly(class_label, [points], 1)
             label[..., class_ind] = class_label
-        
+
         result["gt_seg_map"] = label
-        
+
         return result
     
 @TRANSFORMS.register_module()
@@ -138,71 +147,4 @@ class TransposeAnnotations(BaseTransform):
     def transform(self, result):
         result["gt_seg_map"] = np.transpose(result["gt_seg_map"], (2, 0, 1))
         
-        return result
-
-
-
-# MMCV의 LoadAnnotation을 활용해본 버전인데 잘 동작하지 않는듯함
-# @TRANSFORMS.register_module()
-# class LoadXRayAnnotations(MMCV_LoadAnnotations):
-#     def __init__(
-#         self,
-#         reduce_zero_label=None,
-#         backend_args=None,
-#         imdecode_backend='pillow',
-#     ) -> None:
-#         super().__init__(
-#             with_bbox=False,
-#             with_label=False,
-#             with_seg=True,
-#             with_keypoints=False,
-#             imdecode_backend=imdecode_backend,
-#             backend_args=backend_args)
-#         self.reduce_zero_label = reduce_zero_label
-#         if self.reduce_zero_label is not None:
-#             warnings.warn('`reduce_zero_label` will be deprecated, '
-#                           'if you would like to ignore the zero label, please '
-#                           'set `reduce_zero_label=True` when dataset '
-#                           'initialized')
-#         self.imdecode_backend = imdecode_backend
-    
-    
-#     def _load_seg_map(self, results):
-#         label_path = results["seg_map_path"]
-        
-#         image_size = (2048, 2048)
-        
-#         # process a label of shape (H, W, NC)
-#         label_shape = image_size + (len(CLASSES), )
-#         label = np.zeros(label_shape, dtype=np.uint8)
-        
-#         # read label file
-#         with open(label_path, "r") as f:
-#             annotations = json.load(f)
-#         annotations = annotations["annotations"]
-        
-#         # iterate each class
-#         for ann in annotations:
-#             c = ann["label"]
-#             class_ind = CLASS2IND[c]
-#             points = np.array(ann["points"])
-            
-#             # polygon to mask
-#             class_label = np.zeros(image_size, dtype=np.uint8)
-#             cv2.fillPoly(class_label, [points], 1)
-#             label[..., class_ind] = class_label
-        
-#         results["gt_seg_map"] = label
-        
-#         try:
-#             results['seg_fields'].append('gt_seg_map')
-#         except:
-#             results['seg_fields'] = ['gt_seg_map']
-    
-    
-#     def __repr__(self) -> str:
-#         repr_str = self.__class__.__name__
-#         repr_str += f'(reduce_zero_label={self.reduce_zero_label}, '
-#         repr_str += f"imdecode_backend='{self.imdecode_backend}', "
-#         repr_str += f'backend_args={self.backend_args})'
-#         return repr_str
\ No newline at end of file
+        return result
\ No newline at end of file
diff --git a/mmsegmentation/mmseg/evaluation/metrics/dice_metric.py b/mmsegmentation/mmseg/evaluation/metrics/dice_metric.py
index 629e25f..a48c1ef 100644
--- a/mmsegmentation/mmseg/evaluation/metrics/dice_metric.py
+++ b/mmsegmentation/mmseg/evaluation/metrics/dice_metric.py
@@ -119,10 +119,6 @@ def compute_metrics(self, results):
         return metrics
 
 
-
-
-
-
 @METRICS.register_module()
 class DiceMetricForMultiLabel(BaseMetric):
     def __init__(self,
diff --git a/mmsegmentation/nohup.out b/mmsegmentation/nohup.out
deleted file mode 100644
index 5856e6a..0000000
--- a/mmsegmentation/nohup.out
+++ /dev/null
@@ -1,2216 +0,0 @@
-/bin/sh: 1: gcc: not found
-11/14 21:28:56 - mmengine - INFO - 
-------------------------------------------------------------
-System environment:
-    sys.platform: linux
-    Python: 3.10.13 (main, Sep 11 2023, 13:44:35) [GCC 11.2.0]
-    CUDA available: True
-    MUSA available: False
-    numpy_random_seed: 586206344
-    GPU 0: Tesla V100-SXM2-32GB
-    CUDA_HOME: None
-    GCC: n/a
-    PyTorch: 2.1.0
-    PyTorch compiling details: PyTorch built with:
-  - GCC 9.3
-  - C++ Version: 201703
-  - Intel(R) oneAPI Math Kernel Library Version 2023.1-Product Build 20230303 for Intel(R) 64 architecture applications
-  - Intel(R) MKL-DNN v3.1.1 (Git Hash 64f6bcbcbab628e96f33a62c3e975f8535a7bde4)
-  - OpenMP 201511 (a.k.a. OpenMP 4.5)
-  - LAPACK is enabled (usually provided by MKL)
-  - NNPACK is enabled
-  - CPU capability usage: AVX512
-  - CUDA Runtime 11.8
-  - NVCC architecture flags: -gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_61,code=sm_61;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_37,code=compute_37
-  - CuDNN 8.7
-  - Magma 2.6.1
-  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, CUDA_VERSION=11.8, CUDNN_VERSION=8.7.0, CXX_COMPILER=/opt/rh/devtoolset-9/root/usr/bin/c++, CXX_FLAGS= -D_GLIBCXX_USE_CXX11_ABI=0 -fabi-version=11 -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-unused-parameter -Wno-unused-function -Wno-unused-result -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=old-style-cast -Wno-invalid-partial-specialization -Wno-unused-private-field -Wno-aligned-allocation-unavailable -Wno-missing-braces -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Werror=cast-function-type -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, TORCH_DISABLE_GPU_ASSERTS=ON, TORCH_VERSION=2.1.0, USE_CUDA=ON, USE_CUDNN=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, 
-
-    TorchVision: 0.16.0
-    OpenCV: 4.10.0
-    MMEngine: 0.10.5
-
-Runtime environment:
-    cudnn_benchmark: True
-    mp_cfg: {'mp_start_method': 'fork', 'opencv_num_threads': 0}
-    dist_cfg: {'backend': 'nccl'}
-    seed: 586206344
-    Distributed launcher: none
-    Distributed training: False
-    GPU number: 1
-------------------------------------------------------------
-
-11/14 21:28:57 - mmengine - INFO - Config:
-auto_scale_lr = dict(base_batch_size=16, enable=False)
-backbone_embed_multi = dict(decay_mult=0.0, lr_mult=0.1)
-backbone_norm_multi = dict(decay_mult=0.0, lr_mult=0.1)
-crop_size = (
-    1536,
-    1536,
-)
-custom_keys = dict({
-    'absolute_pos_embed':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone':
-    dict(decay_mult=1.0, lr_mult=0.1),
-    'backbone.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.patch_embed.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.0.blocks.0.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.0.blocks.1.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.0.downsample.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.1.blocks.0.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.1.blocks.1.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.1.downsample.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.2.blocks.0.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.2.blocks.1.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.2.blocks.10.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.2.blocks.11.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.2.blocks.12.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.2.blocks.13.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.2.blocks.14.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.2.blocks.15.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.2.blocks.16.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.2.blocks.17.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.2.blocks.2.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.2.blocks.3.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.2.blocks.4.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.2.blocks.5.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.2.blocks.6.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.2.blocks.7.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.2.blocks.8.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.2.blocks.9.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.2.downsample.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.3.blocks.0.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'backbone.stages.3.blocks.1.norm':
-    dict(decay_mult=0.0, lr_mult=0.1),
-    'level_embed':
-    dict(decay_mult=0.0, lr_mult=1.0),
-    'query_embed':
-    dict(decay_mult=0.0, lr_mult=1.0),
-    'query_feat':
-    dict(decay_mult=0.0, lr_mult=1.0),
-    'relative_position_bias_table':
-    dict(decay_mult=0.0, lr_mult=0.1)
-})
-data_preprocessor = dict(
-    bgr_to_rgb=True,
-    mean=[
-        123.675,
-        116.28,
-        103.53,
-    ],
-    pad_val=0,
-    seg_pad_val=255,
-    size=(
-        1536,
-        1536,
-    ),
-    std=[
-        58.395,
-        57.12,
-        57.375,
-    ],
-    test_cfg=dict(size_divisor=32),
-    type='SegDataPreProcessor')
-data_root = '/data/ephemeral/home/cityscapes_format_xlay/'
-dataset_type = 'XRayDataset'
-default_hooks = dict(
-    checkpoint=dict(
-        by_epoch=False,
-        interval=3000,
-        rule='greater',
-        save_best='mDice',
-        type='CheckpointHook'),
-    logger=dict(interval=100, log_metric_by_epoch=False, type='LoggerHook'),
-    param_scheduler=dict(type='ParamSchedulerHook'),
-    sampler_seed=dict(type='DistSamplerSeedHook'),
-    timer=dict(type='IterTimerHook'),
-    visualization=dict(type='SegVisualizationHook'))
-default_scope = 'mmseg'
-depths = [
-    2,
-    2,
-    18,
-    2,
-]
-embed_multi = dict(decay_mult=0.0, lr_mult=1.0)
-env_cfg = dict(
-    cudnn_benchmark=True,
-    dist_cfg=dict(backend='nccl'),
-    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0))
-fp16 = dict(loss_scale=512.0)
-img_ratios = [
-    0.5,
-    0.75,
-    1.0,
-    1.25,
-    1.5,
-    1.75,
-]
-launcher = 'none'
-load_from = 'https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221202_141901-28ad20f1.pth'
-log_config = dict(
-    hooks=[
-        dict(by_epoch=False, type='TextLoggerHook'),
-        dict(
-            by_epoch=False,
-            init_kwargs=dict(
-                entity='frostings',
-                name='mmsegtest',
-                project='Boost Camp Lv2-3'),
-            interval=1,
-            log_checkpoint=True,
-            log_checkpoint_metadata=True,
-            num_eval_images=10,
-            type='MMSegWandbHook',
-            with_step=False),
-    ],
-    interval=1)
-log_level = 'INFO'
-log_processor = dict(by_epoch=False)
-model = dict(
-    backbone=dict(
-        attn_drop_rate=0.0,
-        depths=[
-            2,
-            2,
-            18,
-            2,
-        ],
-        drop_path_rate=0.3,
-        drop_rate=0.0,
-        embed_dims=192,
-        frozen_stages=-1,
-        init_cfg=dict(
-            checkpoint=
-            'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_large_patch4_window12_384_22k_20220412-6580f57d.pth',
-            type='Pretrained'),
-        mlp_ratio=4,
-        num_heads=[
-            6,
-            12,
-            24,
-            48,
-        ],
-        out_indices=(
-            0,
-            1,
-            2,
-            3,
-        ),
-        patch_norm=True,
-        pretrain_img_size=384,
-        qk_scale=None,
-        qkv_bias=True,
-        type='SwinTransformer',
-        window_size=12,
-        with_cp=False),
-    data_preprocessor=dict(
-        bgr_to_rgb=True,
-        mean=[
-            123.675,
-            116.28,
-            103.53,
-        ],
-        pad_val=0,
-        seg_pad_val=255,
-        size=(
-            1536,
-            1536,
-        ),
-        std=[
-            58.395,
-            57.12,
-            57.375,
-        ],
-        test_cfg=dict(size_divisor=32),
-        type='SegDataPreProcessor'),
-    decode_head=dict(
-        align_corners=False,
-        enforce_decoder_input_project=False,
-        feat_channels=256,
-        in_channels=[
-            192,
-            384,
-            768,
-            1536,
-        ],
-        loss_cls=dict(
-            class_weight=[
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                1.0,
-                0.1,
-            ],
-            loss_weight=2.0,
-            reduction='mean',
-            type='mmdet.CrossEntropyLoss',
-            use_sigmoid=False),
-        loss_dice=dict(
-            activate=True,
-            eps=1.0,
-            loss_weight=5.0,
-            naive_dice=True,
-            reduction='mean',
-            type='mmdet.DiceLoss',
-            use_sigmoid=True),
-        loss_mask=dict(
-            loss_weight=5.0,
-            reduction='mean',
-            type='mmdet.CrossEntropyLoss',
-            use_sigmoid=True),
-        num_classes=30,
-        num_queries=100,
-        num_transformer_feat_level=3,
-        out_channels=256,
-        pixel_decoder=dict(
-            act_cfg=dict(type='ReLU'),
-            encoder=dict(
-                init_cfg=None,
-                layer_cfg=dict(
-                    ffn_cfg=dict(
-                        act_cfg=dict(inplace=True, type='ReLU'),
-                        embed_dims=256,
-                        feedforward_channels=1024,
-                        ffn_drop=0.0,
-                        num_fcs=2),
-                    self_attn_cfg=dict(
-                        batch_first=True,
-                        dropout=0.0,
-                        embed_dims=256,
-                        im2col_step=64,
-                        init_cfg=None,
-                        norm_cfg=None,
-                        num_heads=8,
-                        num_levels=3,
-                        num_points=4)),
-                num_layers=6),
-            init_cfg=None,
-            norm_cfg=dict(num_groups=32, type='GN'),
-            num_outs=3,
-            positional_encoding=dict(normalize=True, num_feats=128),
-            type='mmdet.MSDeformAttnPixelDecoder'),
-        positional_encoding=dict(normalize=True, num_feats=128),
-        strides=[
-            4,
-            8,
-            16,
-            32,
-        ],
-        train_cfg=dict(
-            assigner=dict(
-                match_costs=[
-                    dict(type='mmdet.ClassificationCost', weight=2.0),
-                    dict(
-                        type='mmdet.CrossEntropyLossCost',
-                        use_sigmoid=True,
-                        weight=5.0),
-                    dict(
-                        eps=1.0,
-                        pred_act=True,
-                        type='mmdet.DiceCost',
-                        weight=5.0),
-                ],
-                type='mmdet.HungarianAssigner'),
-            importance_sample_ratio=0.75,
-            num_points=12544,
-            oversample_ratio=3.0,
-            sampler=dict(type='mmdet.MaskPseudoSampler')),
-        transformer_decoder=dict(
-            init_cfg=None,
-            layer_cfg=dict(
-                cross_attn_cfg=dict(
-                    attn_drop=0.0,
-                    batch_first=True,
-                    dropout_layer=None,
-                    embed_dims=256,
-                    num_heads=8,
-                    proj_drop=0.0),
-                ffn_cfg=dict(
-                    act_cfg=dict(inplace=True, type='ReLU'),
-                    add_identity=True,
-                    dropout_layer=None,
-                    embed_dims=256,
-                    feedforward_channels=2048,
-                    ffn_drop=0.0,
-                    num_fcs=2),
-                self_attn_cfg=dict(
-                    attn_drop=0.0,
-                    batch_first=True,
-                    dropout_layer=None,
-                    embed_dims=256,
-                    num_heads=8,
-                    proj_drop=0.0)),
-            num_layers=9,
-            return_intermediate=True),
-        type='Mask2FormerHead'),
-    test_cfg=dict(mode='whole'),
-    train_cfg=dict(),
-    type='EncoderDecoder')
-num_classes = 30
-optim_wrapper = dict(
-    clip_grad=dict(max_norm=0.01, norm_type=2),
-    optimizer=dict(
-        betas=(
-            0.9,
-            0.999,
-        ),
-        eps=1e-08,
-        lr=0.0001,
-        type='AdamW',
-        weight_decay=0.05),
-    paramwise_cfg=dict(
-        custom_keys=dict({
-            'absolute_pos_embed':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone':
-            dict(decay_mult=1.0, lr_mult=0.1),
-            'backbone.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.patch_embed.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.0.blocks.0.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.0.blocks.1.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.0.downsample.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.1.blocks.0.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.1.blocks.1.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.1.downsample.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.2.blocks.0.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.2.blocks.1.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.2.blocks.10.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.2.blocks.11.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.2.blocks.12.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.2.blocks.13.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.2.blocks.14.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.2.blocks.15.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.2.blocks.16.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.2.blocks.17.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.2.blocks.2.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.2.blocks.3.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.2.blocks.4.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.2.blocks.5.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.2.blocks.6.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.2.blocks.7.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.2.blocks.8.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.2.blocks.9.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.2.downsample.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.3.blocks.0.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'backbone.stages.3.blocks.1.norm':
-            dict(decay_mult=0.0, lr_mult=0.1),
-            'level_embed':
-            dict(decay_mult=0.0, lr_mult=1.0),
-            'query_embed':
-            dict(decay_mult=0.0, lr_mult=1.0),
-            'query_feat':
-            dict(decay_mult=0.0, lr_mult=1.0),
-            'relative_position_bias_table':
-            dict(decay_mult=0.0, lr_mult=0.1)
-        }),
-        norm_decay_mult=0.0),
-    type='OptimWrapper')
-optimizer = dict(
-    betas=(
-        0.9,
-        0.999,
-    ),
-    eps=1e-08,
-    lr=0.0001,
-    type='AdamW',
-    weight_decay=0.05)
-param_scheduler = [
-    dict(
-        begin=0,
-        by_epoch=False,
-        end=90000,
-        eta_min=0,
-        power=0.9,
-        type='PolyLR'),
-]
-pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_large_patch4_window12_384_22k_20220412-6580f57d.pth'
-resize_size = (
-    1748,
-    1748,
-)
-resume = False
-test_cfg = dict(type='TestLoop')
-test_dataloader = dict(
-    batch_size=1,
-    dataset=dict(
-        data_prefix=dict(img_path='leftImg8bit/test'),
-        data_root='/data/ephemeral/home/cityscapes_format_xlay/',
-        img_suffix='.png',
-        pipeline=[
-            dict(type='LoadImageFromFile'),
-            dict(keep_ratio=True, scale=(
-                2048,
-                2048,
-            ), type='Resize'),
-            dict(type='PackSegInputs'),
-        ],
-        type='XRayDataset'),
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(shuffle=False, type='DefaultSampler'))
-test_evaluator = dict(
-    save_path='/data/ephemeral/home/submission', type='SubmissionMetric')
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(keep_ratio=True, scale=(
-        2048,
-        2048,
-    ), type='Resize'),
-    dict(type='PackSegInputs'),
-]
-test_size = (
-    2048,
-    2048,
-)
-train_cfg = dict(max_iters=90000, type='IterBasedTrainLoop', val_interval=3000)
-train_dataloader = dict(
-    batch_size=1,
-    dataset=dict(
-        data_prefix=dict(
-            img_path='leftImg8bit/train', seg_map_path='gtFine/train'),
-        data_root='/data/ephemeral/home/cityscapes_format_xlay/',
-        img_suffix='.png',
-        pipeline=[
-            dict(type='LoadImageFromFile'),
-            dict(type='LoadAnnotations'),
-            dict(keep_ratio=True, scale=(
-                1748,
-                1748,
-            ), type='Resize'),
-            dict(
-                cat_max_ratio=0.75,
-                crop_size=(
-                    1536,
-                    1536,
-                ),
-                type='RandomCrop'),
-            dict(prob=0.5, type='RandomFlip'),
-            dict(type='PhotoMetricDistortion'),
-            dict(type='PackSegInputs'),
-        ],
-        seg_map_suffix='_gtFine_labelIds.png',
-        type='XRayDataset'),
-    num_workers=2,
-    persistent_workers=True,
-    sampler=dict(shuffle=True, type='InfiniteSampler'))
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(keep_ratio=True, scale=(
-        1748,
-        1748,
-    ), type='Resize'),
-    dict(cat_max_ratio=0.75, crop_size=(
-        1536,
-        1536,
-    ), type='RandomCrop'),
-    dict(prob=0.5, type='RandomFlip'),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs'),
-]
-tta_model = dict(type='SegTTAModel')
-tta_pipeline = [
-    dict(backend_args=None, type='LoadImageFromFile'),
-    dict(
-        transforms=[
-            [
-                dict(keep_ratio=True, scale_factor=0.5, type='Resize'),
-                dict(keep_ratio=True, scale_factor=0.75, type='Resize'),
-                dict(keep_ratio=True, scale_factor=1.0, type='Resize'),
-                dict(keep_ratio=True, scale_factor=1.25, type='Resize'),
-                dict(keep_ratio=True, scale_factor=1.5, type='Resize'),
-                dict(keep_ratio=True, scale_factor=1.75, type='Resize'),
-            ],
-            [
-                dict(direction='horizontal', prob=0.0, type='RandomFlip'),
-                dict(direction='horizontal', prob=1.0, type='RandomFlip'),
-            ],
-            [
-                dict(type='PackSegInputs'),
-            ],
-        ],
-        type='TestTimeAug'),
-]
-val_cfg = dict(type='ValLoop')
-val_dataloader = dict(
-    batch_size=1,
-    dataset=dict(
-        data_prefix=dict(
-            img_path='leftImg8bit/val', seg_map_path='gtFine/val'),
-        data_root='/data/ephemeral/home/cityscapes_format_xlay/',
-        img_suffix='.png',
-        pipeline=[
-            dict(type='LoadImageFromFile'),
-            dict(keep_ratio=True, scale=(
-                2048,
-                2048,
-            ), type='Resize'),
-            dict(type='LoadAnnotations'),
-            dict(type='PackSegInputs'),
-        ],
-        seg_map_suffix='_gtFine_labelIds.png',
-        type='XRayDataset'),
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(shuffle=False, type='DefaultSampler'))
-val_evaluator = dict(type='DiceMetric')
-val_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(keep_ratio=True, scale=(
-        2048,
-        2048,
-    ), type='Resize'),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs'),
-]
-val_save_interval = 3000
-vis_backends = [
-    dict(type='LocalVisBackend'),
-    dict(type='WandbVisBackend'),
-]
-visualizer = dict(
-    name='visualizer',
-    type='SegLocalVisualizer',
-    vis_backends=[
-        dict(type='LocalVisBackend'),
-        dict(type='WandbVisBackend'),
-    ])
-work_dir = '/data/ephemeral/home/parkjunil/mask2former_base_1748_1536'
-
-wandb: Using wandb-core as the SDK backend.  Please refer to https://wandb.me/wandb-core for more information.
-wandb: Currently logged in as: june21a (june21a-chung-ang-university). Use `wandb login --relogin` to force relogin
-wandb: Tracking run with wandb version 0.18.6
-wandb: Run data is saved locally in /data/ephemeral/home/parkjunil/mask2former_base_1748_1536/20241114_212855/vis_data/wandb/run-20241114_212900-v5mxuanf
-wandb: Run `wandb offline` to turn off syncing.
-wandb: Syncing run faithful-wave-6
-wandb: ⭐️ View project at https://wandb.ai/june21a-chung-ang-university/mmsegmentation-tools
-wandb: 🚀 View run at https://wandb.ai/june21a-chung-ang-university/mmsegmentation-tools/runs/v5mxuanf
-/opt/conda/lib/python3.10/site-packages/albumentations/__init__.py:13: UserWarning: A new version of Albumentations is available: 1.4.21 (you have 1.4.18). Upgrade using: pip install -U albumentations. To disable automatic update checks, set the environment variable NO_ALBUMENTATIONS_UPDATE to 1.
-  check_for_updates()
-11/14 21:29:07 - mmengine - INFO - Distributed training is not used, all SyncBatchNorm (SyncBN) layers in the model will be automatically reverted to BatchNormXd layers if they are used.
-/data/ephemeral/home/mmsegmentation/mmseg/engine/hooks/visualization_hook.py:60: UserWarning: The draw is False, it means that the hook for visualization will not take effect. The results will NOT be visualized or stored.
-  warnings.warn('The draw is False, it means that the '
-11/14 21:29:07 - mmengine - INFO - Hooks will be executed in the following order:
-before_run:
-(VERY_HIGH   ) RuntimeInfoHook                    
-(BELOW_NORMAL) LoggerHook                         
- -------------------- 
-before_train:
-(VERY_HIGH   ) RuntimeInfoHook                    
-(NORMAL      ) IterTimerHook                      
-(VERY_LOW    ) CheckpointHook                     
- -------------------- 
-before_train_epoch:
-(VERY_HIGH   ) RuntimeInfoHook                    
-(NORMAL      ) IterTimerHook                      
-(NORMAL      ) DistSamplerSeedHook                
- -------------------- 
-before_train_iter:
-(VERY_HIGH   ) RuntimeInfoHook                    
-(NORMAL      ) IterTimerHook                      
- -------------------- 
-after_train_iter:
-(VERY_HIGH   ) RuntimeInfoHook                    
-(NORMAL      ) IterTimerHook                      
-(BELOW_NORMAL) LoggerHook                         
-(LOW         ) ParamSchedulerHook                 
-(VERY_LOW    ) CheckpointHook                     
- -------------------- 
-after_train_epoch:
-(NORMAL      ) IterTimerHook                      
-(LOW         ) ParamSchedulerHook                 
-(VERY_LOW    ) CheckpointHook                     
- -------------------- 
-before_val:
-(VERY_HIGH   ) RuntimeInfoHook                    
- -------------------- 
-before_val_epoch:
-(NORMAL      ) IterTimerHook                      
- -------------------- 
-before_val_iter:
-(NORMAL      ) IterTimerHook                      
- -------------------- 
-after_val_iter:
-(NORMAL      ) IterTimerHook                      
-(NORMAL      ) SegVisualizationHook               
-(BELOW_NORMAL) LoggerHook                         
- -------------------- 
-after_val_epoch:
-(VERY_HIGH   ) RuntimeInfoHook                    
-(NORMAL      ) IterTimerHook                      
-(BELOW_NORMAL) LoggerHook                         
-(LOW         ) ParamSchedulerHook                 
-(VERY_LOW    ) CheckpointHook                     
- -------------------- 
-after_val:
-(VERY_HIGH   ) RuntimeInfoHook                    
- -------------------- 
-after_train:
-(VERY_HIGH   ) RuntimeInfoHook                    
-(VERY_LOW    ) CheckpointHook                     
- -------------------- 
-before_test:
-(VERY_HIGH   ) RuntimeInfoHook                    
- -------------------- 
-before_test_epoch:
-(NORMAL      ) IterTimerHook                      
- -------------------- 
-before_test_iter:
-(NORMAL      ) IterTimerHook                      
- -------------------- 
-after_test_iter:
-(NORMAL      ) IterTimerHook                      
-(NORMAL      ) SegVisualizationHook               
-(BELOW_NORMAL) LoggerHook                         
- -------------------- 
-after_test_epoch:
-(VERY_HIGH   ) RuntimeInfoHook                    
-(NORMAL      ) IterTimerHook                      
-(BELOW_NORMAL) LoggerHook                         
- -------------------- 
-after_test:
-(VERY_HIGH   ) RuntimeInfoHook                    
- -------------------- 
-after_run:
-(BELOW_NORMAL) LoggerHook                         
- -------------------- 
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.projection.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.projection.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.projection.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.projection.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.projection.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.projection.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.projection.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.projection.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.norm.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.norm.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.norm.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.norm.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.norm.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.norm.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.norm.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.patch_embed.norm.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.0.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.blocks.1.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.norm.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.norm.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.norm.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.norm.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.norm.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.norm.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.norm.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.norm.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.reduction.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.reduction.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.reduction.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.0.downsample.reduction.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.0.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.blocks.1.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.norm.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.norm.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.norm.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.norm.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.norm.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.norm.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.norm.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.norm.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.reduction.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.reduction.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.reduction.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.1.downsample.reduction.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.0.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.1.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.2.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.3.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.4.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.5.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.6.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.7.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.8.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.9.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.10.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.11.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.12.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.13.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.14.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.15.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.16.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.blocks.17.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.norm.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.norm.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.norm.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.norm.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.norm.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.norm.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.norm.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.norm.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.reduction.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.reduction.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.reduction.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.2.downsample.reduction.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.0.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.relative_position_bias_table:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.relative_position_bias_table:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.relative_position_bias_table:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.relative_position_bias_table:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.qkv.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.qkv.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.qkv.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.qkv.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.qkv.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.qkv.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.qkv.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.qkv.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.proj.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.proj.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.proj.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.proj.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.proj.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.proj.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.proj.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.attn.w_msa.proj.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.0.0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.0.0.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.0.0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.0.0.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.0.0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.0.0.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.0.0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.0.0.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.1.weight:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.1.weight:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.1.bias:weight_decay=0.05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.stages.3.blocks.1.ffn.layers.1.bias:decay_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm0.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm0.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm0.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm0.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm0.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm0.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm0.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm0.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm1.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm1.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm1.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm1.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm1.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm1.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm2.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm2.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm2.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm2.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm2.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm2.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm3.weight:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm3.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm3.weight:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm3.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm3.bias:lr=1e-05
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm3.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm3.bias:lr_mult=0.1
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- backbone.norm3.bias:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.input_convs.0.gn.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.input_convs.0.gn.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.input_convs.1.gn.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.input_convs.1.gn.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.input_convs.2.gn.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.input_convs.2.gn.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.0.norms.0.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.0.norms.0.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.0.norms.1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.0.norms.1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.1.norms.0.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.1.norms.0.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.1.norms.1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.1.norms.1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.2.norms.0.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.2.norms.0.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.2.norms.1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.2.norms.1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.3.norms.0.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.3.norms.0.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.3.norms.1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.3.norms.1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.4.norms.0.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.4.norms.0.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.4.norms.1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.4.norms.1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.5.norms.0.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.5.norms.0.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.5.norms.1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.encoder.layers.5.norms.1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.lateral_convs.0.gn.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.lateral_convs.0.gn.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.output_convs.0.gn.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.pixel_decoder.output_convs.0.gn.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.0.norms.0.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.0.norms.0.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.0.norms.1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.0.norms.1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.0.norms.2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.0.norms.2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.1.norms.0.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.1.norms.0.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.1.norms.1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.1.norms.1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.1.norms.2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.1.norms.2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.2.norms.0.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.2.norms.0.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.2.norms.1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.2.norms.1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.2.norms.2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.2.norms.2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.3.norms.0.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.3.norms.0.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.3.norms.1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.3.norms.1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.3.norms.2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.3.norms.2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.4.norms.0.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.4.norms.0.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.4.norms.1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.4.norms.1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.4.norms.2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.4.norms.2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.5.norms.0.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.5.norms.0.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.5.norms.1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.5.norms.1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.5.norms.2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.5.norms.2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.6.norms.0.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.6.norms.0.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.6.norms.1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.6.norms.1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.6.norms.2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.6.norms.2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.7.norms.0.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.7.norms.0.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.7.norms.1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.7.norms.1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.7.norms.2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.7.norms.2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.8.norms.0.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.8.norms.0.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.8.norms.1.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.8.norms.1.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.8.norms.2.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.layers.8.norms.2.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.post_norm.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.transformer_decoder.post_norm.bias:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.query_embed.weight:lr=0.0001
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.query_embed.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.query_embed.weight:lr_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.query_embed.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.query_feat.weight:lr=0.0001
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.query_feat.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.query_feat.weight:lr_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.query_feat.weight:decay_mult=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.level_embed.weight:lr=0.0001
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.level_embed.weight:weight_decay=0.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.level_embed.weight:lr_mult=1.0
-11/14 21:29:08 - mmengine - INFO - paramwise_options -- decode_head.level_embed.weight:decay_mult=0.0
-11/14 21:29:09 - mmengine - WARNING - The prefix is not set in metric class DiceMetric.
-Loads checkpoint by http backend from path: https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_large_patch4_window12_384_22k_20220412-6580f57d.pth
-Loads checkpoint by http backend from path: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221202_141901-28ad20f1.pth
-The model and loaded state dict do not match exactly
-
-size mismatch for decode_head.cls_embed.weight: copying a param with shape torch.Size([20, 256]) from checkpoint, the shape in current model is torch.Size([31, 256]).
-size mismatch for decode_head.cls_embed.bias: copying a param with shape torch.Size([20]) from checkpoint, the shape in current model is torch.Size([31]).
-11/14 21:29:11 - mmengine - INFO - Load checkpoint from https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221202_141901-28ad20f1.pth
-11/14 21:29:11 - mmengine - WARNING - "FileClient" will be deprecated in future. Please use io functions in https://mmengine.readthedocs.io/en/latest/api/fileio.html#file-io
-11/14 21:29:11 - mmengine - WARNING - "HardDiskBackend" is the alias of "LocalBackend" and the former will be deprecated in future.
-11/14 21:29:11 - mmengine - INFO - Checkpoints will be saved to /data/ephemeral/home/parkjunil/mask2former_base_1748_1536.
-/opt/conda/lib/python3.10/site-packages/torch/functional.py:504: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at /opt/conda/conda-bld/pytorch_1695392020201/work/aten/src/ATen/native/TensorShape.cpp:3526.)
-  return _VF.meshgrid(tensors, **kwargs)  # type: ignore[attr-defined]
-11/14 21:31:54 - mmengine - INFO - Iter(train) [  100/90000]  base_lr: 9.9901e-05 lr: 9.9901e-06  eta: 1 day, 16:33:54  time: 1.5990  data_time: 0.0178  memory: 28594  grad_norm: 305.1580  loss: 37.3849  decode.loss_cls: 1.7073  decode.loss_mask: 0.1344  decode.loss_dice: 0.9270  decode.d0.loss_cls: 6.4599  decode.d0.loss_mask: 0.1695  decode.d0.loss_dice: 1.5017  decode.d1.loss_cls: 3.7023  decode.d1.loss_mask: 0.1622  decode.d1.loss_dice: 1.1506  decode.d2.loss_cls: 2.6918  decode.d2.loss_mask: 0.1256  decode.d2.loss_dice: 1.0338  decode.d3.loss_cls: 2.2764  decode.d3.loss_mask: 0.1170  decode.d3.loss_dice: 0.8932  decode.d4.loss_cls: 2.0114  decode.d4.loss_mask: 0.1265  decode.d4.loss_dice: 0.9013  decode.d5.loss_cls: 1.9429  decode.d5.loss_mask: 0.1322  decode.d5.loss_dice: 0.9058  decode.d6.loss_cls: 1.8207  decode.d6.loss_mask: 0.1260  decode.d6.loss_dice: 0.8958  decode.d7.loss_cls: 1.7324  decode.d7.loss_mask: 0.1306  decode.d7.loss_dice: 0.9058  decode.d8.loss_cls: 1.6652  decode.d8.loss_mask: 0.1336  decode.d8.loss_dice: 0.9021
-11/14 21:34:34 - mmengine - INFO - Iter(train) [  200/90000]  base_lr: 9.9801e-05 lr: 9.9801e-06  eta: 1 day, 16:17:27  time: 1.6043  data_time: 0.0178  memory: 28552  grad_norm: 139.1402  loss: 14.3850  decode.loss_cls: 0.3627  decode.loss_mask: 0.0540  decode.loss_dice: 0.4288  decode.d0.loss_cls: 5.4133  decode.d0.loss_mask: 0.0604  decode.d0.loss_dice: 0.5897  decode.d1.loss_cls: 0.6901  decode.d1.loss_mask: 0.0603  decode.d1.loss_dice: 0.4657  decode.d2.loss_cls: 0.4056  decode.d2.loss_mask: 0.0563  decode.d2.loss_dice: 0.4811  decode.d3.loss_cls: 0.4355  decode.d3.loss_mask: 0.0544  decode.d3.loss_dice: 0.4227  decode.d4.loss_cls: 0.3797  decode.d4.loss_mask: 0.0569  decode.d4.loss_dice: 0.4430  decode.d5.loss_cls: 0.3940  decode.d5.loss_mask: 0.0556  decode.d5.loss_dice: 0.4528  decode.d6.loss_cls: 0.3936  decode.d6.loss_mask: 0.0548  decode.d6.loss_dice: 0.4532  decode.d7.loss_cls: 0.3870  decode.d7.loss_mask: 0.0567  decode.d7.loss_dice: 0.4517  decode.d8.loss_cls: 0.3207  decode.d8.loss_mask: 0.0563  decode.d8.loss_dice: 0.4482
-11/14 21:37:14 - mmengine - INFO - Iter(train) [  300/90000]  base_lr: 9.9701e-05 lr: 9.9701e-06  eta: 1 day, 16:07:08  time: 1.5979  data_time: 0.0175  memory: 28552  grad_norm: 108.5796  loss: 10.2965  decode.loss_cls: 0.2175  decode.loss_mask: 0.0544  decode.loss_dice: 0.4410  decode.d0.loss_cls: 3.4332  decode.d0.loss_mask: 0.0485  decode.d0.loss_dice: 0.4727  decode.d1.loss_cls: 0.2831  decode.d1.loss_mask: 0.0563  decode.d1.loss_dice: 0.4471  decode.d2.loss_cls: 0.1703  decode.d2.loss_mask: 0.0640  decode.d2.loss_dice: 0.4391  decode.d3.loss_cls: 0.1884  decode.d3.loss_mask: 0.0668  decode.d3.loss_dice: 0.4280  decode.d4.loss_cls: 0.1928  decode.d4.loss_mask: 0.0648  decode.d4.loss_dice: 0.4329  decode.d5.loss_cls: 0.2099  decode.d5.loss_mask: 0.0605  decode.d5.loss_dice: 0.4298  decode.d6.loss_cls: 0.2080  decode.d6.loss_mask: 0.0552  decode.d6.loss_dice: 0.4343  decode.d7.loss_cls: 0.1973  decode.d7.loss_mask: 0.0557  decode.d7.loss_dice: 0.4426  decode.d8.loss_cls: 0.2031  decode.d8.loss_mask: 0.0561  decode.d8.loss_dice: 0.4430
-11/14 21:39:54 - mmengine - INFO - Iter(train) [  400/90000]  base_lr: 9.9601e-05 lr: 9.9601e-06  eta: 1 day, 16:00:23  time: 1.5985  data_time: 0.0177  memory: 28552  grad_norm: 140.5457  loss: 9.6174  decode.loss_cls: 0.2714  decode.loss_mask: 0.0582  decode.loss_dice: 0.4477  decode.d0.loss_cls: 2.0169  decode.d0.loss_mask: 0.0622  decode.d0.loss_dice: 0.5964  decode.d1.loss_cls: 0.2883  decode.d1.loss_mask: 0.0685  decode.d1.loss_dice: 0.5144  decode.d2.loss_cls: 0.2179  decode.d2.loss_mask: 0.0604  decode.d2.loss_dice: 0.5060  decode.d3.loss_cls: 0.2298  decode.d3.loss_mask: 0.0559  decode.d3.loss_dice: 0.4529  decode.d4.loss_cls: 0.2189  decode.d4.loss_mask: 0.0567  decode.d4.loss_dice: 0.4637  decode.d5.loss_cls: 0.2093  decode.d5.loss_mask: 0.0571  decode.d5.loss_dice: 0.4727  decode.d6.loss_cls: 0.2620  decode.d6.loss_mask: 0.0600  decode.d6.loss_dice: 0.4539  decode.d7.loss_cls: 0.2354  decode.d7.loss_mask: 0.0614  decode.d7.loss_dice: 0.4600  decode.d8.loss_cls: 0.2377  decode.d8.loss_mask: 0.0633  decode.d8.loss_dice: 0.4584
-11/14 21:42:34 - mmengine - INFO - Iter(train) [  500/90000]  base_lr: 9.9501e-05 lr: 9.9501e-06  eta: 1 day, 15:54:55  time: 1.5954  data_time: 0.0170  memory: 28552  grad_norm: 37.0008  loss: 5.2917  decode.loss_cls: 0.0460  decode.loss_mask: 0.0408  decode.loss_dice: 0.3249  decode.d0.loss_cls: 1.0061  decode.d0.loss_mask: 0.0421  decode.d0.loss_dice: 0.3511  decode.d1.loss_cls: 0.0856  decode.d1.loss_mask: 0.0433  decode.d1.loss_dice: 0.3465  decode.d2.loss_cls: 0.0669  decode.d2.loss_mask: 0.0411  decode.d2.loss_dice: 0.3340  decode.d3.loss_cls: 0.0478  decode.d3.loss_mask: 0.0427  decode.d3.loss_dice: 0.3442  decode.d4.loss_cls: 0.0357  decode.d4.loss_mask: 0.0421  decode.d4.loss_dice: 0.3434  decode.d5.loss_cls: 0.0388  decode.d5.loss_mask: 0.0418  decode.d5.loss_dice: 0.3501  decode.d6.loss_cls: 0.0374  decode.d6.loss_mask: 0.0410  decode.d6.loss_dice: 0.3282  decode.d7.loss_cls: 0.0376  decode.d7.loss_mask: 0.0424  decode.d7.loss_dice: 0.3410  decode.d8.loss_cls: 0.0670  decode.d8.loss_mask: 0.0414  decode.d8.loss_dice: 0.3405
-11/14 21:45:14 - mmengine - INFO - Iter(train) [  600/90000]  base_lr: 9.9401e-05 lr: 9.9401e-06  eta: 1 day, 15:49:52  time: 1.5952  data_time: 0.0172  memory: 28552  grad_norm: 52.8307  loss: 4.5907  decode.loss_cls: 0.0382  decode.loss_mask: 0.0405  decode.loss_dice: 0.3034  decode.d0.loss_cls: 0.6743  decode.d0.loss_mask: 0.0415  decode.d0.loss_dice: 0.3407  decode.d1.loss_cls: 0.1023  decode.d1.loss_mask: 0.0421  decode.d1.loss_dice: 0.3323  decode.d2.loss_cls: 0.0785  decode.d2.loss_mask: 0.0378  decode.d2.loss_dice: 0.3112  decode.d3.loss_cls: 0.0388  decode.d3.loss_mask: 0.0367  decode.d3.loss_dice: 0.2940  decode.d4.loss_cls: 0.0358  decode.d4.loss_mask: 0.0373  decode.d4.loss_dice: 0.3112  decode.d5.loss_cls: 0.0471  decode.d5.loss_mask: 0.0362  decode.d5.loss_dice: 0.2931  decode.d6.loss_cls: 0.0415  decode.d6.loss_mask: 0.0384  decode.d6.loss_dice: 0.3013  decode.d7.loss_cls: 0.0353  decode.d7.loss_mask: 0.0380  decode.d7.loss_dice: 0.2944  decode.d8.loss_cls: 0.0375  decode.d8.loss_mask: 0.0389  decode.d8.loss_dice: 0.2922
-11/14 21:46:17 - mmengine - INFO - Exp name: mask2former_20241114_212855
-11/14 21:47:53 - mmengine - INFO - Iter(train) [  700/90000]  base_lr: 9.9301e-05 lr: 9.9301e-06  eta: 1 day, 15:45:39  time: 1.5983  data_time: 0.0172  memory: 28552  grad_norm: 23.3135  loss: 4.0187  decode.loss_cls: 0.0280  decode.loss_mask: 0.0343  decode.loss_dice: 0.2815  decode.d0.loss_cls: 0.4558  decode.d0.loss_mask: 0.0355  decode.d0.loss_dice: 0.2945  decode.d1.loss_cls: 0.0485  decode.d1.loss_mask: 0.0348  decode.d1.loss_dice: 0.2924  decode.d2.loss_cls: 0.0629  decode.d2.loss_mask: 0.0361  decode.d2.loss_dice: 0.2880  decode.d3.loss_cls: 0.0411  decode.d3.loss_mask: 0.0348  decode.d3.loss_dice: 0.2779  decode.d4.loss_cls: 0.0184  decode.d4.loss_mask: 0.0358  decode.d4.loss_dice: 0.2872  decode.d5.loss_cls: 0.0197  decode.d5.loss_mask: 0.0351  decode.d5.loss_dice: 0.2766  decode.d6.loss_cls: 0.0346  decode.d6.loss_mask: 0.0348  decode.d6.loss_dice: 0.2810  decode.d7.loss_cls: 0.0356  decode.d7.loss_mask: 0.0348  decode.d7.loss_dice: 0.2891  decode.d8.loss_cls: 0.0675  decode.d8.loss_mask: 0.0355  decode.d8.loss_dice: 0.2872
-11/14 21:50:33 - mmengine - INFO - Iter(train) [  800/90000]  base_lr: 9.9201e-05 lr: 9.9201e-06  eta: 1 day, 15:41:40  time: 1.5919  data_time: 0.0167  memory: 28552  grad_norm: 35.1899  loss: 4.5128  decode.loss_cls: 0.0478  decode.loss_mask: 0.0494  decode.loss_dice: 0.3324  decode.d0.loss_cls: 0.2883  decode.d0.loss_mask: 0.0474  decode.d0.loss_dice: 0.3263  decode.d1.loss_cls: 0.0650  decode.d1.loss_mask: 0.0483  decode.d1.loss_dice: 0.3340  decode.d2.loss_cls: 0.0824  decode.d2.loss_mask: 0.0490  decode.d2.loss_dice: 0.3390  decode.d3.loss_cls: 0.0920  decode.d3.loss_mask: 0.0490  decode.d3.loss_dice: 0.3177  decode.d4.loss_cls: 0.0293  decode.d4.loss_mask: 0.0464  decode.d4.loss_dice: 0.3208  decode.d5.loss_cls: 0.0670  decode.d5.loss_mask: 0.0472  decode.d5.loss_dice: 0.3292  decode.d6.loss_cls: 0.0268  decode.d6.loss_mask: 0.0477  decode.d6.loss_dice: 0.3305  decode.d7.loss_cls: 0.0261  decode.d7.loss_mask: 0.0472  decode.d7.loss_dice: 0.3233  decode.d8.loss_cls: 0.0262  decode.d8.loss_mask: 0.0480  decode.d8.loss_dice: 0.3291

From f03e91eb3e69905009d8a2389a9f150f73b03d60 Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Thu, 21 Nov 2024 10:18:49 +0900
Subject: [PATCH 046/106] [Fix] : bug fix

---
 sam2_unet/config.yaml        |  6 ++-
 sam2_unet/test.py            | 73 ++++++++++++------------------------
 sam2_unet/train.py           |  1 +
 sam2_unet/train_v1.py        | 10 +++--
 sam2_unet/trainer.py         | 21 +++++------
 sam2_unet/utils/dataset.py   |  7 ++--
 sam2_unet/utils/transform.py | 17 +++++++++
 7 files changed, 64 insertions(+), 71 deletions(-)
 create mode 100644 sam2_unet/utils/transform.py

diff --git a/sam2_unet/config.yaml b/sam2_unet/config.yaml
index ddec3fb..d29434c 100644
--- a/sam2_unet/config.yaml
+++ b/sam2_unet/config.yaml
@@ -13,7 +13,6 @@ valid_batch_size: 2
 valid_num_workers: 2
 kfold: 5
 k: 0
-val_every: 5
 threshold: 0.5
 
 # hyperparameter
@@ -35,7 +34,10 @@ scheduler_parameters:
 # random seed 
 random_seed: 2024
 
-# augmentation
+# save
+save_every: 5
+
+# resize
 image_size: 512
 
 # wandb
diff --git a/sam2_unet/test.py b/sam2_unet/test.py
index 8e87edd..368c4f5 100644
--- a/sam2_unet/test.py
+++ b/sam2_unet/test.py
@@ -1,26 +1,23 @@
 import argparse
 import os
 import torch
-import imageio
 import numpy as np
 import pandas as pd
 import torch.nn.functional as F
 from torch.utils.data import DataLoader
+from utils.dataset import TestDataset
+from utils.transform import TransformSelector
+from utils.checkpoint import load_checkpoint
 from tqdm.auto import tqdm
 from SAM2UNet import SAM2UNet
-from utils.dataset import TestDataset
-
 
 parser = argparse.ArgumentParser()
 parser.add_argument("--checkpoint", type=str, required=True,
-                help="path to the checkpoint of sam2-unet")
-parser.add_argument("--test_image_path", type=str, required=True, 
+                    help="path to the checkpoint of sam2-unet")
+parser.add_argument("--test_image_path", type=str, default="/data/ephemeral/home/data/test/DCM",
                     help="path to the image files for testing")
-parser.add_argument("--test_gt_path", type=str, required=True,
-                    help="path to the mask files for testing")
-parser.add_argument("--save_path", type=str, required=True,
-                    help="path to save the predicted masks")
-# args = parser.parse_args()
+parser.add_argument("--image_size", type=int, default=512)
+args = parser.parse_args()
 
 def encode_mask_to_rle(mask):
     '''
@@ -48,7 +45,7 @@ def decode_rle_to_mask(rle, height, width):
     return img.reshape(height, width)
 
 def test(model, args, thr=0.5):
-    CLASSES = [
+    classes = [
         'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
         'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
         'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
@@ -56,10 +53,17 @@ def test(model, args, thr=0.5):
         'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
         'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
     ]
-    CLASS2IND = {v: i for i, v in enumerate(CLASSES)}
-    IND2CLASS = {v: k for k, v in CLASS2IND.items()}
+    class2ind = {v: i for i, v in enumerate(classes)}
+    ind2class = {v: k for k, v in class2ind.items()}
+
+    transform_selector = TransformSelector(args.image_size)
+    transform = transform_selector.get_transform(is_train=False)
+
+    test_dataset = TestDataset(
+        args.test_image_path,
+        transform
+    )
 
-    test_dataset = TestDataset(args.test_image_path, 512)
     test_loader = DataLoader(
         dataset=test_dataset, 
         batch_size=2,
@@ -67,15 +71,14 @@ def test(model, args, thr=0.5):
         num_workers=2,
         drop_last=False
     )
+
     model.eval()
     model.cuda()
-    os.makedirs(args.save_path, exist_ok=True)
+    os.makedirs("./outputs", exist_ok=True)
 
     rles = []
     filename_and_class = []
     with torch.no_grad():
-        n_class = len(CLASSES)
-
         for step, (images, image_names) in tqdm(enumerate(test_loader), total=len(test_loader)):
             images = images.cuda()    
             outputs, _, _ = model(images)
@@ -88,14 +91,15 @@ def test(model, args, thr=0.5):
                 for c, segm in enumerate(output):
                     rle = encode_mask_to_rle(segm)
                     rles.append(rle)
-                    filename_and_class.append(f"{IND2CLASS[c]}_{image_name}")
+                    filename_and_class.append(f"{ind2class[c]}_{image_name}")
                     
     return rles, filename_and_class
 
 def main(args):
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     model = SAM2UNet().to(device)
-    model.load_state_dict(torch.load(args.checkpoint), strict=True)
+    checkpoint = torch.load(os.path.join(args.checkpoint))
+    model.load_state_dict(checkpoint['model_state_dict'])
     rles, filename_and_class = test(model, args)
     classes, filename = zip(*[x.split("_") for x in filename_and_class])
     image_name = [os.path.basename(f) for f in filename]
@@ -104,36 +108,7 @@ def main(args):
         "class": classes,
         "rle": rles,
     })
-    df.to_csv("output1.csv", index=False)
+    df.to_csv("./outputs/output1.csv", index=False)
 
 if __name__ == "__main__":
-    args = argparse.Namespace(
-        checkpoint="/data/ephemeral/home/jongmin/level2-cv-semanticsegmentation-cv-19-lv3/sam2_unet/checkpoints/SAM2-UNet-30.pth", 
-        test_image_path="/data/ephemeral/home/data/test/DCM", 
-        test_gt_path="/data/ephemeral/home/data/test/DCM",
-        save_path="./outputs", 
-    )
     main(args)
-
-# device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-# test_loader = TestDataset(args.test_image_path, args.test_gt_path, 352)
-# model = SAM2UNet().to(device)
-# model.load_state_dict(torch.load(args.checkpoint), strict=True)
-# model.eval()
-# model.cuda()
-# os.makedirs(args.save_path, exist_ok=True)
-# for i in range(test_loader.size):
-#     with torch.no_grad():
-#         image, gt, name = test_loader.load_data()
-#         gt = np.asarray(gt, np.float32)
-#         image = image.to(device)
-#         res, _, _ = model(image)
-#         # fix: duplicate sigmoid
-#         # res = torch.sigmoid(res)
-#         res = F.upsample(res, size=gt.shape, mode='bilinear', align_corners=False)
-#         res = res.sigmoid().data.cpu()
-#         res = res.numpy().squeeze()
-#         res = (res - res.min()) / (res.max() - res.min() + 1e-8)
-#         res = (res * 255).astype(np.uint8)
-#         print("Saving " + name)
-#         imageio.imsave(os.path.join(args.save_path, name[:-4] + ".png"), res)
diff --git a/sam2_unet/train.py b/sam2_unet/train.py
index f4908d8..53d2c98 100644
--- a/sam2_unet/train.py
+++ b/sam2_unet/train.py
@@ -65,6 +65,7 @@ def main(cfg):
             torch.save(model.state_dict(), os.path.join('./checkpoints', 'SAM2-UNet-%d.pth' % (epoch + 1)))
             print('[Saving Snapshot:]', os.path.join('./checkpoints', 'SAM2-UNet-%d.pth'% (epoch + 1)))
 
+
 if __name__ == "__main__":
     set_seed(2024)
     parser = ArgumentParser()
diff --git a/sam2_unet/train_v1.py b/sam2_unet/train_v1.py
index 04ab071..9eca69c 100644
--- a/sam2_unet/train_v1.py
+++ b/sam2_unet/train_v1.py
@@ -1,5 +1,4 @@
 import os
-import yaml
 import torch
 import random
 import numpy as np
@@ -9,6 +8,7 @@
 from utils.dataset import FullDataset
 from utils.optimizer import OptimizerSelector
 from utils.scheduler import SchedulerSelector
+from utils.transform import TransformSelector
 from trainer import Trainer
 from SAM2UNet import SAM2UNet
 from omegaconf import OmegaConf
@@ -17,7 +17,7 @@
 def set_seed(RANDOM_SEED):
     torch.manual_seed(RANDOM_SEED)
     torch.cuda.manual_seed(RANDOM_SEED)
-    torch.cuda.manual_seed_all(RANDOM_SEED) # if use multi-GPU
+    torch.cuda.manual_seed_all(RANDOM_SEED)
     torch.backends.cudnn.deterministic = True
     torch.backends.cudnn.benchmark = False
     np.random.seed(RANDOM_SEED)
@@ -27,7 +27,8 @@ def main(cfg):
     device = torch.device("cuda")
     model = SAM2UNet(cfg.hiera_path)
     
-    transform = 
+    transform_selector = TransformSelector(image_size=cfg.image_size)
+    transform = transform_selector.get_transform(is_train=True)
 
     train_dataset = FullDataset(
         image_root=cfg.train_image_path, 
@@ -87,6 +88,7 @@ def main(cfg):
         loss_fn=loss_fn,
         epochs=cfg.max_epoch,
         save_dir=save_dir,
+        save_every=cfg.save_every,
         wandb_id=cfg.wandb_id,
         wandb_name=cfg.wandb_name,
         resume=cfg.resume,
@@ -97,7 +99,6 @@ def main(cfg):
     trainer.train()
     
 if __name__ == "__main__":
-    set_seed(2024)
     parser = ArgumentParser()
     parser.add_argument('--config', type=str, default='config.yaml')
     args = parser.parse_args()
@@ -105,4 +106,5 @@ def main(cfg):
     with open(args.config, 'r') as f:
         cfg = OmegaConf.load(f)
     
+    set_seed(cfg.random_seed)
     main(cfg)
\ No newline at end of file
diff --git a/sam2_unet/trainer.py b/sam2_unet/trainer.py
index d9f96b2..9d532be 100644
--- a/sam2_unet/trainer.py
+++ b/sam2_unet/trainer.py
@@ -18,7 +18,7 @@ def __init__(
         loss_fn,
         epochs,
         save_dir,
-        val_every,
+        save_every,
         wandb_id,
         wandb_name,
         resume=False,
@@ -34,7 +34,7 @@ def __init__(
         self.loss_fn = loss_fn  # 손실 함수
         self.epochs = epochs  # 총 훈련 에폭 수
         self.save_dir = save_dir
-        self.val_every = val_every
+        self.save_every = save_every
         self.wandb_id = wandb_id
         self.wandb_name = wandb_name
         self.resume = resume # 학습 재개를 위한 것인지
@@ -50,7 +50,7 @@ def __init__(
         ]
 
     def save_checkpoint_epoch(self, epoch: int, valid_loss: float, valid_dice: float) -> None:
-        ckpt_path = os.path.join(self.save_dir, f'epoch-{epoch + 1}-loss-{valid_loss}-dice-{valid_dice:.4f}.pth')
+        ckpt_path = os.path.join(self.save_dir, f'epoch-{epoch + 1}-loss-{valid_loss:.4f}-dice-{valid_dice:.4f}.pth')
         save_checkpoint(self.model, self.optimizer, self.scheduler, epoch+1, valid_dice, ckpt_path)
         print(f"Checkpoint updated at epoch {epoch + 1} and saved as {ckpt_path}")
     
@@ -123,12 +123,9 @@ def validate(self, val_loader: DataLoader, thr=0.5) -> tuple[float, float]:
                 valid_loss += loss.item() * masks.shape[0]
 
                 outputs = torch.sigmoid(outputs)
-                outputs = (outputs > thr).detach().cpu()
-                masks = masks.detach().cpu()
-
-                
+                outputs = (outputs > thr)
                 dice = self.dice_coef(outputs, masks)
-                valid_dices.append(dice)
+                valid_dices.append(dice.detach().cpu())
                 
                 del outputs, masks, dice
 
@@ -145,7 +142,7 @@ def validate(self, val_loader: DataLoader, thr=0.5) -> tuple[float, float]:
         print(dice_str)
         valid_dice = torch.mean(dices_per_class).item()
 
-        return valid_loss, valid_dice, dices_per_class
+        return valid_loss, valid_dice
 
     def train(self) -> None:
         if self.resume:
@@ -161,12 +158,12 @@ def train(self) -> None:
             train_loss, train_dice = self.train_epoch(self.train_loader)
             train_loss = train_loss / len(self.train_loader.dataset)
 
-            valid_loss, valid_dice, dices_per_class = self.validate(self.valid_loader)
-            val_loss = val_loss / len(self.valid_loader.dataset)
+            valid_loss, valid_dice = self.validate(self.valid_loader)
+            valid_loss = valid_loss / len(self.valid_loader.dataset)
 
             print(f"Epoch {epoch+1}, Train Loss: {train_loss:.8f} | Train Dice: {train_dice:.8f} \nVaild Loss: {valid_loss:.8f} | Vaild Dice: {valid_dice:.8f}\n")
             
-            if (epoch + 1) % self.val_every == 0:
+            if (epoch + 1) % self.save_every == 0:
                 self.save_checkpoint_epoch(epoch, valid_loss, valid_dice)
             
         self.save_checkpoint_epoch(epoch, valid_loss, valid_dice)
diff --git a/sam2_unet/utils/dataset.py b/sam2_unet/utils/dataset.py
index 74ad515..a10aa0c 100644
--- a/sam2_unet/utils/dataset.py
+++ b/sam2_unet/utils/dataset.py
@@ -5,7 +5,6 @@
 import cv2
 import json
 import torch
-import albumentations as A
 from PIL import Image
 from torchvision.transforms import InterpolationMode
 from torch.utils.data import Dataset
@@ -119,7 +118,7 @@ def __init__(self, image_root, gt_root, is_train=True, transforms=None, kfold=5,
                 break
 
         self.images = filenames
-        self.labels = labelnames
+        self.gts = labelnames
         self.transform = transforms
 
     def __getitem__(self, idx):
@@ -127,7 +126,7 @@ def __getitem__(self, idx):
         image_path = os.path.join(self.image_root, image_name)
         
         image = cv2.imread(image_path)
-        image = image / 255.
+        image = image.astype(np.float32) / 255.
         
         label_name = self.gts[idx]
         label_path = os.path.join(self.gt_root, label_name)
@@ -205,7 +204,7 @@ def __getitem__(self, idx):
         image_path = os.path.join(self.image_root, image_name)
         
         image = cv2.imread(image_path)
-        image = image / 255.
+        image = image.astype(np.float32) / 255.
         
         if self.transform is not None:
             inputs = {"image": image}
diff --git a/sam2_unet/utils/transform.py b/sam2_unet/utils/transform.py
new file mode 100644
index 0000000..488c4fb
--- /dev/null
+++ b/sam2_unet/utils/transform.py
@@ -0,0 +1,17 @@
+import albumentations as A
+
+class TransformSelector:
+    def __init__(self, image_size):
+        self.common_transform = [A.Resize(image_size, image_size)]
+
+    def get_transform(self, is_train=True):
+        if is_train:
+            transform = A.Compose(
+                [
+                    A.ColorJitter()
+                ]+ self.common_transform)
+        else:
+            transform = A.Compose(self.common_transform)
+
+        return transform
+

From a89cd6a26e354fa0b06dbf7cf14556e7eab03b32 Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Thu, 21 Nov 2024 11:03:50 +0900
Subject: [PATCH 047/106] [Fix}:fix error in inference of baseline code

---
 mmsegmentation/baseline.py                    |  47 +----
 .../_baseline_/config_for_this_example.py     |  11 +-
 .../configs/_baseline_/dataset_setting.py     |  14 +-
 .../evaluation/metrics/submission_metric.py   |   6 +-
 .../mmseg/models/segmentors/custom.py         | 172 +++++++++++++-----
 5 files changed, 145 insertions(+), 105 deletions(-)

diff --git a/mmsegmentation/baseline.py b/mmsegmentation/baseline.py
index 9657ecb..3ad37f0 100644
--- a/mmsegmentation/baseline.py
+++ b/mmsegmentation/baseline.py
@@ -30,8 +30,6 @@
 from mmcv.transforms import BaseTransform
 
 
-
-
 ##############################
 # 데이터 경로를 입력하세요
 
@@ -39,6 +37,8 @@
 TEST_IMAGE_ROOT = "/data/ephemeral/home/data/test/DCM"
 LABEL_ROOT = "/data/ephemeral/home/data/train/outputs_json"
 CONFIG_PATH = "/data/ephemeral/home/parkjunil/level2-cv-semanticsegmentation-cv-19-lv3/mmsegmentation/configs/_baseline_/config_for_this_example.py"
+CHECKPOINT_PATH = "/data/ephemeral/home/parkjunil/work_dir/baseline/iter_20000.pth"
+SUBMISSION_PATH = "/data/ephemeral/home/submission"
 
 CLASSES = [
     'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
@@ -200,47 +200,12 @@ def train():
     runner.train()
 
 
-def visualize():
-    cfg =load_config()
-    model = MODELS.build(cfg.model)
-    
-    checkpoint = load_checkpoint(
-        model,
-        "baseline2/iter_20000.pth",
-        map_location='cpu'
-    )
-    img = cv2.imread(os.path.join(IMAGE_ROOT, "ID001", "image1661130828152_R.png"))
-    # prepare data
-    data, is_batch = _preprare_data(img, model)
-
-    # forward the model
-    with torch.no_grad():
-        results = model.test_step(data)
-    plt.imshow(label2rgb(results[0].pred_sem_seg.data))
-
-
 def inference():
     cfg = load_config()
-    model = MODELS.build(cfg.model)
-    
-    pngs = {
-        os.path.relpath(os.path.join(root, fname), start=TEST_IMAGE_ROOT)
-        for root, _dirs, files in os.walk(IMAGE_ROOT)
-        for fname in files
-        if os.path.splitext(fname)[1].lower() == ".png"
-    }
-    
-    rles, filename_and_class = test(model, pngs)
-    classes, filename = zip(*[x.split("_") for x in filename_and_class])
-    
-    df = pd.DataFrame({
-        "image_name": filename,
-        "class": classes,
-        "rle": rles,
-    })
-    df.tail(30)
-    df.to_csv("submission.csv", index=False)
+    cfg.load_from = CHECKPOINT_PATH
+    runner = Runner.from_cfg(cfg)
+    runner.test()
 
 
 if __name__ == "__main__":
-    train()
\ No newline at end of file
+    inference()
\ No newline at end of file
diff --git a/mmsegmentation/configs/_baseline_/config_for_this_example.py b/mmsegmentation/configs/_baseline_/config_for_this_example.py
index 173866d..19e7ec6 100644
--- a/mmsegmentation/configs/_baseline_/config_for_this_example.py
+++ b/mmsegmentation/configs/_baseline_/config_for_this_example.py
@@ -1,3 +1,4 @@
+_scope_ = ['mmengine', 'mmseg']
 # Train Segformer Mit B3
 _base_ = [
     "../_base_/models/segformer_mit-b0.py",
@@ -60,12 +61,4 @@
 # training schedule for 20k
 train_cfg = dict(type='IterBasedTrainLoop', max_iters=20000, val_interval=2000)
 val_cfg = dict(type='ValLoop')
-test_cfg = dict(type='TestLoop')
-default_hooks = dict(
-    timer=dict(type='IterTimerHook'),
-    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
-    param_scheduler=dict(type='ParamSchedulerHook'),
-    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=2000),
-    sampler_seed=dict(type='DistSamplerSeedHook'),
-    visualization=dict(type='SegVisualizationHook')
-)
\ No newline at end of file
+test_cfg = dict(type='TestLoop')
\ No newline at end of file
diff --git a/mmsegmentation/configs/_baseline_/dataset_setting.py b/mmsegmentation/configs/_baseline_/dataset_setting.py
index 1f5a9b1..9a102b7 100644
--- a/mmsegmentation/configs/_baseline_/dataset_setting.py
+++ b/mmsegmentation/configs/_baseline_/dataset_setting.py
@@ -43,7 +43,17 @@
         pipeline=val_pipeline
     )
 )
-test_dataloader = val_dataloader
+test_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='XRayDataset',
+        data_root='/data/ephemeral/home/cityscapes_format_xlay_kfold',
+        data_prefix=dict(img_path='leftImg8bit/test'),
+        img_suffix='.png',
+        pipeline=test_pipeline))
 
 val_evaluator = dict(type='DiceMetricForMultiLabel')
-test_evaluator = val_evaluator
\ No newline at end of file
+test_evaluator = dict(type='SubmissionMetric')
\ No newline at end of file
diff --git a/mmsegmentation/mmseg/evaluation/metrics/submission_metric.py b/mmsegmentation/mmseg/evaluation/metrics/submission_metric.py
index 6ecff5b..2185e15 100644
--- a/mmsegmentation/mmseg/evaluation/metrics/submission_metric.py
+++ b/mmsegmentation/mmseg/evaluation/metrics/submission_metric.py
@@ -35,7 +35,7 @@
     (0, 125, 92), (209, 0, 151), (188, 208, 182), (0, 220, 176),
 ]
 
-num_classes = len(CLASSES) + 1
+num_classes = len(CLASSES)
 
 
 @METRICS.register_module()
@@ -56,7 +56,7 @@ def __init__(self,
         os.makedirs(os.path.join(self.save_path, 'img'), exist_ok=True)
         self.cnt = 0
         self.max_vis_cnt = max_vis_cnt
-        self.multi_label=False
+        self.multi_label=multi_label
         
         # self.rles = []
         # self.filename_and_class = []
@@ -130,8 +130,6 @@ def process(self, data_batch, data_samples):
             img_shape = data_sample['img_shape']
             ori_shape = data_sample['ori_shape']
             
-            # if img_shape != ori_shape:
-            #     pred_label = F.interpolate(pred_label, size=ori_shape, mode="bilinear")
             pred_label = pred_label.cpu().numpy()
             
             # 시각화를 위한 세팅
diff --git a/mmsegmentation/mmseg/models/segmentors/custom.py b/mmsegmentation/mmseg/models/segmentors/custom.py
index 9f585aa..bef7330 100644
--- a/mmsegmentation/mmseg/models/segmentors/custom.py
+++ b/mmsegmentation/mmseg/models/segmentors/custom.py
@@ -7,9 +7,12 @@
 import torch
 
 
+
 class PostProcessResultMixin:
-    def postprocess_result(self, seg_logits, data_samples):
-        """Convert results list to `SegDataSample`.
+    def postprocess_result(self,
+                           seg_logits,
+                           data_samples):
+        """ Convert results list to `SegDataSample`.
         Args:
             seg_logits (Tensor): The segmentation results, seg_logits from
                 model of each input image.
@@ -36,70 +39,141 @@ def postprocess_result(self, seg_logits, data_samples):
             if not only_prediction:
                 img_meta = data_samples[i].metainfo
                 # remove padding area
-                if "img_padding_size" not in img_meta:
-                    padding_size = img_meta.get("padding_size", [0] * 4)
+                if 'img_padding_size' not in img_meta:
+                    padding_size = img_meta.get('padding_size', [0] * 4)
                 else:
-                    padding_size = img_meta["img_padding_size"]
-                padding_left, padding_right, padding_top, padding_bottom = padding_size
+                    padding_size = img_meta['img_padding_size']
+                padding_left, padding_right, padding_top, padding_bottom =\
+                    padding_size
                 # i_seg_logits shape is 1, C, H, W after remove padding
-                i_seg_logits = seg_logits[
-                    i : i + 1,
-                    :,
-                    padding_top : H - padding_bottom,
-                    padding_left : W - padding_right,
-                ]
-
-                flip = img_meta.get("flip", None)
+                i_seg_logits = seg_logits[i:i + 1, :,
+                                          padding_top:H - padding_bottom,
+                                          padding_left:W - padding_right]
+
+                flip = img_meta.get('flip', None)
                 if flip:
-                    flip_direction = img_meta.get("flip_direction", None)
-                    assert flip_direction in ["horizontal", "vertical"]
-                    if flip_direction == "horizontal":
-                        i_seg_logits = i_seg_logits.flip(dims=(3,))
+                    flip_direction = img_meta.get('flip_direction', None)
+                    assert flip_direction in ['horizontal', 'vertical']
+                    if flip_direction == 'horizontal':
+                        i_seg_logits = i_seg_logits.flip(dims=(3, ))
                     else:
-                        i_seg_logits = i_seg_logits.flip(dims=(2,))
+                        i_seg_logits = i_seg_logits.flip(dims=(2, ))
 
                 # resize as original shape
                 i_seg_logits = resize(
                     i_seg_logits,
-                    size=img_meta["ori_shape"],
-                    mode="bilinear",
+                    size=img_meta['ori_shape'],
+                    mode='bilinear',
                     align_corners=self.align_corners,
-                    warning=False,
-                ).squeeze(0)
+                    warning=False).squeeze(0)
             else:
                 i_seg_logits = seg_logits[i]
 
-            # i_seg_logits = i_seg_logits.sigmoid()
-            # i_seg_pred = (i_seg_logits > self.decode_head.threshold).to(i_seg_logits)
-            # Sigmoid로 변환하여 confidence 계산
-            i_seg_logits = i_seg_logits.sigmoid()  # [C, H, W]
-
-            # 각 픽셀별로 상위 2개의 클래스의 confidence 값과 인덱스 추출
-            topk_values, topk_indices = i_seg_logits.topk(2, dim=0)  # topk_values, topk_indices: [2, H, W]
+            i_seg_logits = i_seg_logits.sigmoid()
+            i_seg_pred = (i_seg_logits > 0.5).to(i_seg_logits)
 
-            # Threshold 기준을 적용하여 confidence 값이 threshold 이상인 경우만 남김
-            threshold_mask = topk_values > self.decode_head.threshold  # [2, H, W]
+            data_samples[i].set_data({
+                'seg_logits':
+                PixelData(**{'data': i_seg_logits}),
+                'pred_sem_seg':
+                PixelData(**{'data': i_seg_pred})
+            })
 
-            # i_seg_pred 초기화
-            i_seg_pred = torch.zeros_like(i_seg_logits)  # [C, H, W]
+        return data_samples
 
-            # threshold를 만족하는 상위 2개 클래스만 유지하고, 나머지는 0으로 처리
-            for j in range(2):  # 최대 2개의 클래스만 선택
-                # topk_indices는 [2, H, W]에서 i번째 인덱스 추출, 이를 [1, H, W]로 유지
-                class_indices = topk_indices[j:j+1, :, :]  # [1, H, W]
-                class_mask = threshold_mask[j:j+1, :, :].to(i_seg_logits.dtype)  # [1, H, W]
+# class PostProcessResultMixin:
+#     def postprocess_result(self, seg_logits, data_samples):
+#         """Convert results list to `SegDataSample`.
+#         Args:
+#             seg_logits (Tensor): The segmentation results, seg_logits from
+#                 model of each input image.
+#             data_samples (list[:obj:`SegDataSample`]): The seg data samples.
+#                 It usually includes information such as `metainfo` and
+#                 `gt_sem_seg`. Default to None.
+#         Returns:
+#             list[:obj:`SegDataSample`]: Segmentation results of the
+#             input images. Each SegDataSample usually contain:
+
+#             - ``pred_sem_seg``(PixelData): Prediction of semantic segmentation.
+#             - ``seg_logits``(PixelData): Predicted logits of semantic
+#                 segmentation before normalization.
+#         """
+#         batch_size, C, H, W = seg_logits.shape
+
+#         if data_samples is None:
+#             data_samples = [SegDataSample() for _ in range(batch_size)]
+#             only_prediction = True
+#         else:
+#             only_prediction = False
+
+#         for i in range(batch_size):
+#             if not only_prediction:
+#                 img_meta = data_samples[i].metainfo
+#                 # remove padding area
+#                 if "img_padding_size" not in img_meta:
+#                     padding_size = img_meta.get("padding_size", [0] * 4)
+#                 else:
+#                     padding_size = img_meta["img_padding_size"]
+#                 padding_left, padding_right, padding_top, padding_bottom = padding_size
+#                 # i_seg_logits shape is 1, C, H, W after remove padding
+#                 i_seg_logits = seg_logits[
+#                     i : i + 1,
+#                     :,
+#                     padding_top : H - padding_bottom,
+#                     padding_left : W - padding_right,
+#                 ]
+
+#                 flip = img_meta.get("flip", None)
+#                 if flip:
+#                     flip_direction = img_meta.get("flip_direction", None)
+#                     assert flip_direction in ["horizontal", "vertical"]
+#                     if flip_direction == "horizontal":
+#                         i_seg_logits = i_seg_logits.flip(dims=(3,))
+#                     else:
+#                         i_seg_logits = i_seg_logits.flip(dims=(2,))
+
+#                 # resize as original shape
+#                 i_seg_logits = resize(
+#                     i_seg_logits,
+#                     size=img_meta["ori_shape"],
+#                     mode="bilinear",
+#                     align_corners=self.align_corners,
+#                     warning=False,
+#                 ).squeeze(0)
+#             else:
+#                 i_seg_logits = seg_logits[i]
+
+#             # i_seg_logits = i_seg_logits.sigmoid()
+#             # i_seg_pred = (i_seg_logits > self.decode_head.threshold).to(i_seg_logits)
+#             # Sigmoid로 변환하여 confidence 계산
+#             i_seg_logits = i_seg_logits.sigmoid()  # [C, H, W]
+
+#             # 각 픽셀별로 상위 2개의 클래스의 confidence 값과 인덱스 추출
+#             topk_values, topk_indices = i_seg_logits.topk(2, dim=0)  # topk_values, topk_indices: [2, H, W]
+
+#             # Threshold 기준을 적용하여 confidence 값이 threshold 이상인 경우만 남김
+#             threshold_mask = topk_values > self.decode_head.threshold  # [2, H, W]
+
+#             # i_seg_pred 초기화
+#             i_seg_pred = torch.zeros_like(i_seg_logits)  # [C, H, W]
+
+#             # threshold를 만족하는 상위 2개 클래스만 유지하고, 나머지는 0으로 처리
+#             for j in range(2):  # 최대 2개의 클래스만 선택
+#                 # topk_indices는 [2, H, W]에서 i번째 인덱스 추출, 이를 [1, H, W]로 유지
+#                 class_indices = topk_indices[j:j+1, :, :]  # [1, H, W]
+#                 class_mask = threshold_mask[j:j+1, :, :].to(i_seg_logits.dtype)  # [1, H, W]
                 
-                # 선택된 클래스 위치에 값을 설정
-                i_seg_pred.scatter_(0, class_indices, class_mask)
+#                 # 선택된 클래스 위치에 값을 설정
+#                 i_seg_pred.scatter_(0, class_indices, class_mask)
                 
-            data_samples[i].set_data(
-                {
-                    "seg_logits": PixelData(**{"data": i_seg_logits}),
-                    "pred_sem_seg": PixelData(**{"data": i_seg_pred}),
-                }
-            )
-
-        return data_samples
+#             data_samples[i].set_data(
+#                 {
+#                     "seg_logits": PixelData(**{"data": i_seg_logits}),
+#                     "pred_sem_seg": PixelData(**{"data": i_seg_pred}),
+#                 }
+#             )
+
+#         return data_samples
 
 
 @MODELS.register_module()

From d2e18fecfcf333de2598572a6aeeb7bfa245f4ec Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Thu, 21 Nov 2024 11:23:10 +0900
Subject: [PATCH 048/106] [Feature] : add wandb

---
 .gitignore                   |   1 +
 sam2_unet/test.sh            |   6 --
 sam2_unet/train.py           | 126 ++++++++++++++++++++++-------------
 sam2_unet/train.sh           |   9 ---
 sam2_unet/train_v1.py        | 110 ------------------------------
 sam2_unet/trainer.py         |  70 +++++++++++++------
 sam2_unet/utils/transform.py |   2 +-
 7 files changed, 131 insertions(+), 193 deletions(-)
 delete mode 100644 sam2_unet/test.sh
 delete mode 100644 sam2_unet/train.sh
 delete mode 100644 sam2_unet/train_v1.py

diff --git a/.gitignore b/.gitignore
index 29e4376..6f60f27 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,6 +5,7 @@
 
 
 # 결과 파일 제외
+*.yaml
 *.csv
 
 # python cache 제외
diff --git a/sam2_unet/test.sh b/sam2_unet/test.sh
deleted file mode 100644
index d4867a2..0000000
--- a/sam2_unet/test.sh
+++ /dev/null
@@ -1,6 +0,0 @@
-CUDA_VISIBLE_DEVICES="0" \
-python test.py \
---checkpoint "/data/ephemeral/home/jongmin/level2-cv-semanticsegmentation-cv-19-lv3/sam2_unet/checkpoints/SAM2-UNet-20.pth" \
---test_image_path "/data/ephemeral/home/data/test" \
---test_gt_path "/data/ephemeral/home/data/test" \
---save_path "./outputs"
\ No newline at end of file
diff --git a/sam2_unet/train.py b/sam2_unet/train.py
index 53d2c98..2bfc436 100644
--- a/sam2_unet/train.py
+++ b/sam2_unet/train.py
@@ -1,73 +1,106 @@
 import os
+import torch
 import random
 import numpy as np
-import torch
-import torch.optim as opt
-import torch.nn.functional as F
+from datetime import datetime
 from torch.utils.data import DataLoader
-from torch.optim.lr_scheduler import CosineAnnealingLR, MultiStepLR
+from utils.loss import structure_loss
 from utils.dataset import FullDataset
+from utils.optimizer import OptimizerSelector
+from utils.scheduler import SchedulerSelector
+from utils.transform import TransformSelector
+from trainer import Trainer
 from SAM2UNet import SAM2UNet
 from omegaconf import OmegaConf
 from argparse import ArgumentParser
 
-
 def set_seed(RANDOM_SEED):
     torch.manual_seed(RANDOM_SEED)
     torch.cuda.manual_seed(RANDOM_SEED)
-    torch.cuda.manual_seed_all(RANDOM_SEED) # if use multi-GPU
+    torch.cuda.manual_seed_all(RANDOM_SEED)
     torch.backends.cudnn.deterministic = True
     torch.backends.cudnn.benchmark = False
     np.random.seed(RANDOM_SEED)
     random.seed(RANDOM_SEED)
 
-
-def structure_loss(pred, mask):
-    weit = 1 + 5*torch.abs(F.avg_pool2d(mask, kernel_size=31, stride=1, padding=15) - mask)
-    wbce = F.binary_cross_entropy_with_logits(pred, mask, reduce='none')
-    wbce = (weit*wbce).sum(dim=(2, 3)) / weit.sum(dim=(2, 3))
-    pred = torch.sigmoid(pred)
-    inter = ((pred * mask)*weit).sum(dim=(2, 3))
-    union = ((pred + mask)*weit).sum(dim=(2, 3))
-    wiou = 1 - (inter + 1)/(union - inter+1)
-    return (wbce + wiou).mean()
-
-
 def main(cfg):    
-    dataset = FullDataset(cfg.train_image_path, cfg.train_mask_path, 512, mode='train')
-    dataloader = DataLoader(dataset, batch_size=cfg.train_batch_size, shuffle=True, num_workers=2)
     device = torch.device("cuda")
     model = SAM2UNet(cfg.hiera_path)
-    model.to(device)
-    optim = opt.AdamW([{"params":model.parameters(), "initia_lr": cfg.lr}], lr=cfg.lr, weight_decay=cfg.weight_decay)
-    scheduler = CosineAnnealingLR(optim, cfg.max_epoch, eta_min=1.0e-7)
-    # scheduler = MultiStepLR(optim, milestones=[8, 16], gamma=0.1, last_epoch=cfg.epoch)
+    
+    transform_selector = TransformSelector(image_size=cfg.image_size)
+    train_transform = transform_selector.get_transform(is_train=True)
+    valid_transform = transform_selector.get_transform(is_train=False)
+
+    train_dataset = FullDataset(
+        image_root=cfg.train_image_path, 
+        gt_root=cfg.train_mask_path, 
+        is_train=True,
+        transforms=train_transform,
+        kfold=cfg.kfold,
+        k=cfg.k)
+    
+    valid_dataset = FullDataset(
+        image_root=cfg.train_image_path, 
+        gt_root=cfg.train_mask_path, 
+        is_train=False,
+        transforms=valid_transform,
+        kfold=cfg.kfold,
+        k=cfg.k)
+
+    train_loader = DataLoader(
+        train_dataset, 
+        batch_size=cfg.train_batch_size, 
+        num_workers=cfg.train_num_workers,
+        shuffle=True)
+    
+    valid_loader = DataLoader(
+        valid_dataset, 
+        batch_size=cfg.valid_batch_size, 
+        num_workers=cfg.valid_num_workers,
+        shuffle=False)
+    
+    optimizer_selector = OptimizerSelector(model, cfg.lr)
+    optimizer = optimizer_selector.get_optimizer(cfg.optimizer, **cfg.optimizer_parameters)
+
+    scheduler_selector = SchedulerSelector(optimizer)
+    scheduler = scheduler_selector.get_scheduler(cfg.scheduler, **cfg.scheduler_parameters)
+
+    loss_fn = structure_loss
+
     os.makedirs("./checkpoints", exist_ok=True)
-    for epoch in range(cfg.max_epoch):
-        for i, batch in enumerate(dataloader):
-            x = batch['image']
-            target = batch['label']
-            x = x.to(device)
-            target = target.to(device)
-            optim.zero_grad()
-            pred0, pred1, pred2 = model(x)
-            loss0 = structure_loss(pred0, target)
-            loss1 = structure_loss(pred1, target)
-            loss2 = structure_loss(pred2, target)
-            loss = loss0 + loss1 + loss2
-            loss.backward()
-            optim.step()
-            if i % 50 == 0:
-                print("epoch:{}-{}: loss:{}".format(epoch + 1, i + 1, loss.item()))
-                
-        scheduler.step()
-        if (epoch+1) % 5 == 0 or (epoch+1) == cfg.max_epoch:
-            torch.save(model.state_dict(), os.path.join('./checkpoints', 'SAM2-UNet-%d.pth' % (epoch + 1)))
-            print('[Saving Snapshot:]', os.path.join('./checkpoints', 'SAM2-UNet-%d.pth'% (epoch + 1)))
+    now = datetime.now()
+    time = now.strftime('%Y-%m-%d_%H:%M:%S')
+    save_dir = os.path.join('./checkpoints', time)
+    os.makedirs(save_dir, exist_ok=True)
+
+    # Config 저장
+    save_path = os.path.join(save_dir, "config.yaml")
+    OmegaConf.save(cfg, save_path)
 
+    print(f"Config saved at {save_path}")
 
+    trainer = Trainer(
+        model=model,
+        device=device,
+        train_loader=train_loader,
+        valid_loader=valid_loader,
+        optimizer=optimizer,
+        scheduler=scheduler,
+        loss_fn=loss_fn,
+        epochs=cfg.max_epoch,
+        threshold=cfg.threshold,
+        save_dir=save_dir,
+        save_every=cfg.save_every,
+        wandb_id=cfg.wandb_id,
+        wandb_name=cfg.wandb_name,
+        resume=cfg.resume,
+        ckpt_path=cfg.ckpt_path,
+        start_epoch=cfg.start_epoch
+    )
+
+    trainer.train()
+    
 if __name__ == "__main__":
-    set_seed(2024)
     parser = ArgumentParser()
     parser.add_argument('--config', type=str, default='config.yaml')
     args = parser.parse_args()
@@ -75,4 +108,5 @@ def main(cfg):
     with open(args.config, 'r') as f:
         cfg = OmegaConf.load(f)
     
+    set_seed(cfg.random_seed)
     main(cfg)
\ No newline at end of file
diff --git a/sam2_unet/train.sh b/sam2_unet/train.sh
deleted file mode 100644
index 0cb933a..0000000
--- a/sam2_unet/train.sh
+++ /dev/null
@@ -1,9 +0,0 @@
-CUDA_VISIBLE_DEVICES="0" \
-python train.py \
---hiera_path "/data/ephemeral/home/jongmin/level2-cv-semanticsegmentation-cv-19-lv3/sam2_unet/sam2_hiera_large.pt" \
---train_image_path "/data/ephemeral/home/data/train/DCM" \
---train_mask_path "/data/ephemeral/home/data/train/outputs_json" \
---save_path "./checkpoints" \
---epoch 20 \
---lr 0.001 \
---batch_size 12
\ No newline at end of file
diff --git a/sam2_unet/train_v1.py b/sam2_unet/train_v1.py
deleted file mode 100644
index 9eca69c..0000000
--- a/sam2_unet/train_v1.py
+++ /dev/null
@@ -1,110 +0,0 @@
-import os
-import torch
-import random
-import numpy as np
-from datetime import datetime
-from torch.utils.data import DataLoader
-from utils.loss import structure_loss
-from utils.dataset import FullDataset
-from utils.optimizer import OptimizerSelector
-from utils.scheduler import SchedulerSelector
-from utils.transform import TransformSelector
-from trainer import Trainer
-from SAM2UNet import SAM2UNet
-from omegaconf import OmegaConf
-from argparse import ArgumentParser
-
-def set_seed(RANDOM_SEED):
-    torch.manual_seed(RANDOM_SEED)
-    torch.cuda.manual_seed(RANDOM_SEED)
-    torch.cuda.manual_seed_all(RANDOM_SEED)
-    torch.backends.cudnn.deterministic = True
-    torch.backends.cudnn.benchmark = False
-    np.random.seed(RANDOM_SEED)
-    random.seed(RANDOM_SEED)
-
-def main(cfg):    
-    device = torch.device("cuda")
-    model = SAM2UNet(cfg.hiera_path)
-    
-    transform_selector = TransformSelector(image_size=cfg.image_size)
-    transform = transform_selector.get_transform(is_train=True)
-
-    train_dataset = FullDataset(
-        image_root=cfg.train_image_path, 
-        gt_root=cfg.train_mask_path, 
-        is_train=True,
-        transforms=transform,
-        kfold=cfg.kfold,
-        k=cfg.k)
-    
-    valid_dataset = FullDataset(
-        image_root=cfg.train_image_path, 
-        gt_root=cfg.train_mask_path, 
-        is_train=False,
-        transforms=None,
-        kfold=cfg.kfold,
-        k=cfg.k)
-
-    train_loader = DataLoader(
-        train_dataset, 
-        batch_size=cfg.train_batch_size, 
-        num_workers=cfg.train_num_workers,
-        shuffle=True)
-    
-    valid_loader = DataLoader(
-        valid_dataset, 
-        batch_size=cfg.valid_batch_size, 
-        num_workers=cfg.valid_num_workers,
-        shuffle=False)
-    
-    optimizer_selector = OptimizerSelector(model, cfg.lr)
-    optimizer = optimizer_selector.get_optimizer(cfg.optimizer, **cfg.optimizer_parameters)
-
-    scheduler_selector = SchedulerSelector(optimizer)
-    scheduler = scheduler_selector.get_scheduler(cfg.scheduler, **cfg.scheduler_parameters)
-
-    loss_fn = structure_loss
-
-    os.makedirs("./checkpoints", exist_ok=True)
-    now = datetime.now()
-    time = now.strftime('%Y-%m-%d_%H:%M:%S')
-    save_dir = os.path.join('./checkpoints', time)
-    os.makedirs(save_dir, exist_ok=True)
-
-    # Config 저장
-    save_path = os.path.join(save_dir, "config.yaml")
-    OmegaConf.save(cfg, save_path)
-
-    print(f"Config saved at {save_path}")
-
-    trainer = Trainer(
-        model=model,
-        device=device,
-        train_loader=train_loader,
-        valid_loader=valid_loader,
-        optimizer=optimizer,
-        scheduler=scheduler,
-        loss_fn=loss_fn,
-        epochs=cfg.max_epoch,
-        save_dir=save_dir,
-        save_every=cfg.save_every,
-        wandb_id=cfg.wandb_id,
-        wandb_name=cfg.wandb_name,
-        resume=cfg.resume,
-        ckpt_path=cfg.ckpt_path,
-        start_epoch=cfg.start_epoch
-    )
-
-    trainer.train()
-    
-if __name__ == "__main__":
-    parser = ArgumentParser()
-    parser.add_argument('--config', type=str, default='config.yaml')
-    args = parser.parse_args()
-
-    with open(args.config, 'r') as f:
-        cfg = OmegaConf.load(f)
-    
-    set_seed(cfg.random_seed)
-    main(cfg)
\ No newline at end of file
diff --git a/sam2_unet/trainer.py b/sam2_unet/trainer.py
index 9d532be..a21c7a1 100644
--- a/sam2_unet/trainer.py
+++ b/sam2_unet/trainer.py
@@ -1,6 +1,9 @@
 import os
+import time
+import datetime
 from tqdm.auto import tqdm
 from utils.checkpoint import save_checkpoint, load_checkpoint
+from utils.wandb_logger import WandbLogger
 
 import torch
 import torch.nn.functional as F
@@ -17,6 +20,7 @@ def __init__(
         scheduler,
         loss_fn,
         epochs,
+        threshold,
         save_dir,
         save_every,
         wandb_id,
@@ -25,21 +29,22 @@ def __init__(
         ckpt_path="",
         start_epoch=0
         ):
-        self.model = model  # 훈련할 모델
-        self.device = device  # 연산을 수행할 디바이스 (CPU or GPU)
-        self.train_loader = train_loader  # 훈련 데이터 로더
-        self.valid_loader = valid_loader  # 검증 데이터 로더
-        self.optimizer = optimizer  # 최적화 알고리즘
-        self.scheduler = scheduler # 학습률 스케줄러
-        self.loss_fn = loss_fn  # 손실 함수
-        self.epochs = epochs  # 총 훈련 에폭 수
+        self.model = model
+        self.device = device
+        self.train_loader = train_loader
+        self.valid_loader = valid_loader
+        self.optimizer = optimizer
+        self.scheduler = scheduler
+        self.loss_fn = loss_fn
+        self.epochs = epochs
+        self.threshold = threshold
         self.save_dir = save_dir
         self.save_every = save_every
         self.wandb_id = wandb_id
         self.wandb_name = wandb_name
-        self.resume = resume # 학습 재개를 위한 것인지
-        self.ckpt_file = ckpt_path # 학습 재개를 위해 불러와야할 가중치 주소
-        self.start_epoch = start_epoch # 재개
+        self.resume = resume
+        self.ckpt_file = ckpt_path
+        self.start_epoch = start_epoch
         self.classes = [
             'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
             'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
@@ -62,7 +67,7 @@ def dice_coef(self, y_true, y_pred):
         eps = 0.0001
         return (2. * intersection + eps) / (torch.sum(y_true_f, -1) + torch.sum(y_pred_f, -1) + eps)
 
-    def train_epoch(self, train_loader: DataLoader, thr=0.5):
+    def train_epoch(self, train_loader: DataLoader):
         self.model.train()
         
         train_loss = 0.
@@ -84,7 +89,7 @@ def train_epoch(self, train_loader: DataLoader, thr=0.5):
             train_loss += loss.item() * masks.shape[0]
 
             outputs = torch.sigmoid(pred0)
-            outputs = (outputs > thr)
+            outputs = (outputs > self.threshold)
             dice = self.dice_coef(outputs, masks)
             train_dices.append(dice.detach().cpu())
 
@@ -99,13 +104,13 @@ def train_epoch(self, train_loader: DataLoader, thr=0.5):
 
         return train_loss, train_dice
 
-    def validate(self, val_loader: DataLoader, thr=0.5) -> tuple[float, float]:
+    def validate(self, valid_loader: DataLoader) -> tuple[float, float]:
         self.model.eval()
 
         valid_loss = 0.
         valid_dices = []
 
-        progress_bar = tqdm(val_loader, desc="Validating", leave=False)
+        progress_bar = tqdm(valid_loader, desc="Validating", leave=False)
         
         with torch.no_grad():
             for batch_idx, (images, masks) in enumerate(progress_bar):
@@ -123,7 +128,7 @@ def validate(self, val_loader: DataLoader, thr=0.5) -> tuple[float, float]:
                 valid_loss += loss.item() * masks.shape[0]
 
                 outputs = torch.sigmoid(outputs)
-                outputs = (outputs > thr)
+                outputs = (outputs > self.threshold)
                 dice = self.dice_coef(outputs, masks)
                 valid_dices.append(dice.detach().cpu())
                 
@@ -145,27 +150,50 @@ def validate(self, val_loader: DataLoader, thr=0.5) -> tuple[float, float]:
         return valid_loss, valid_dice
 
     def train(self) -> None:
+        logger = WandbLogger(name=self.wandb_name)
+        logger.initialize({
+            "model_type": "SAM2-UNet",
+            "model_name": "SAM2-UNet",
+            "criterion": "BCEWithLogitLoss",
+            "learning_rate": self.optimizer.param_groups[0]['lr'],
+            "max_epoch": self.epochs,
+            "optimizer": type(self.optimizer).__name__,
+            "scheduler": type(self.scheduler).__name__
+        })
         if self.resume:
             self.load_settings()
         print(f"training start")
 
         self.model.to(self.device)
         for epoch in range(self.start_epoch, self.epochs):
-            train_loss, train_dice = 0.0, 0.0
-            train_dice, valid_dice = 0.0, 0.0
+            epoch_start = time.time()
+            train_loss, train_dice = 0., 0.
+            train_dice, valid_dice = 0., 0.
             print(f"Epoch {epoch+1}/{self.epochs}")
             
             train_loss, train_dice = self.train_epoch(self.train_loader)
             train_loss = train_loss / len(self.train_loader.dataset)
 
+            torch.cuda.empty_cache()
             valid_loss, valid_dice = self.validate(self.valid_loader)
             valid_loss = valid_loss / len(self.valid_loader.dataset)
 
-            print(f"Epoch {epoch+1}, Train Loss: {train_loss:.8f} | Train Dice: {train_dice:.8f} \nVaild Loss: {valid_loss:.8f} | Vaild Dice: {valid_dice:.8f}\n")
-            
+            epoch_time = datetime.timedelta(seconds=time.time() - epoch_start)
+            print(f"Epoch {epoch+1}, Train Loss: {train_loss:.6f} | Train Dice: {train_dice:.6f} \nVaild Loss: {valid_loss:.6f} | Vaild Dice: {valid_dice:.6f}\n")
+            logger.log_epoch_metrics(
+                {
+                    "epoch": epoch,
+                    "epoch_time": epoch_time.total_seconds(),
+                    "train_loss": train_loss,
+                    "train_dice": train_dice,
+                    "valid_loss": valid_loss,
+                    "valid_dice": valid_dice,
+                    "learning_rate": self.scheduler.get_last_lr()[0]
+                }
+            )
             if (epoch + 1) % self.save_every == 0:
                 self.save_checkpoint_epoch(epoch, valid_loss, valid_dice)
-            
+
         self.save_checkpoint_epoch(epoch, valid_loss, valid_dice)
         
     def load_settings(self) -> None:
diff --git a/sam2_unet/utils/transform.py b/sam2_unet/utils/transform.py
index 488c4fb..44fa8c4 100644
--- a/sam2_unet/utils/transform.py
+++ b/sam2_unet/utils/transform.py
@@ -8,7 +8,7 @@ def get_transform(self, is_train=True):
         if is_train:
             transform = A.Compose(
                 [
-                    A.ColorJitter()
+                    A.HorizontalFlip(p=0.5)
                 ]+ self.common_transform)
         else:
             transform = A.Compose(self.common_transform)

From f068bef30d2a0eec53161b3dfd51e9c18f62b343 Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Thu, 21 Nov 2024 12:47:30 +0900
Subject: [PATCH 049/106] add dice loss

---
 module_base/config.yaml |  8 ++++----
 module_base/loss.py     | 35 +++++++++++++++++++++++++++++++++++
 2 files changed, 39 insertions(+), 4 deletions(-)

diff --git a/module_base/config.yaml b/module_base/config.yaml
index b3e0a06..3d0d52c 100644
--- a/module_base/config.yaml
+++ b/module_base/config.yaml
@@ -6,7 +6,7 @@ save_dir: /data/ephemeral/home/data/result
 # 모델 라이브러리 및 사용 모델 정의
 model_type: smp
 model_name: UnetPlusPlus
-encoder_name: efficientnet-b5
+encoder_name: tu-hrnet_w64
 encoder_weights: imagenet
 pretrained: True
 
@@ -19,11 +19,11 @@ lr: 2e-4
 weight_decay: 1e-6
 train_num_workers: 8
 valid_num_workers: 0
-max_epoch: 30
+max_epoch: 50
 
 # loss
 loss:
-    name: BCEWithLogitsLoss
+    name: DiceBCELoss
     params: null
 
 # optimizer
@@ -37,7 +37,7 @@ threshold: 0.5
 # random seed
 random_seed: 2024
 
-# augmentation
+# resize
 size: 1024
 
 # wandb
diff --git a/module_base/loss.py b/module_base/loss.py
index d8319d8..938af30 100644
--- a/module_base/loss.py
+++ b/module_base/loss.py
@@ -1,4 +1,6 @@
+import torch
 import torch.nn as nn
+import torch.nn.functional as F
 
 class BCE(nn.Module):
     def __init__(self, **kwargs):
@@ -8,10 +10,43 @@ def __init__(self, **kwargs):
     def forward(self, preds, targets):
         return self.loss(preds, targets)
 
+class DiceLoss(nn.Module):
+    def __init__(self, eps=1e-6):
+        super(DiceLoss, self).__init__()
+        self.eps = eps
+
+    def forward(self, preds, targets):
+        preds = F.sigmoid(preds)
+
+        preds_f = preds.flatten(2)
+        targets_f = targets.flatten(2)
+        intersection = torch.sum(preds_f * targets_f, -1)
+
+        dice = (2. * intersection + self.eps) / (torch.sum(preds_f, -1) + torch.sum(targets_f, -1) + self.eps)
+        loss = 1 - dice
+        
+        return loss.mean()
+
+class DiceBCELoss(nn.Module):
+    def __init__(self, **kwargs):
+        super(DiceBCELoss, self).__init__(**kwargs)
+        self.bceWithLogitLoss = nn.BCEWithLogitsLoss(**kwargs)
+        self.diceLoss = DiceLoss()
+
+    def forward(self, preds, targets):
+        bce_loss = self.bceWithLogitLoss(preds, targets)
+        dice_loss = self.diceLoss(preds, targets)
+        dice_bce_loss = bce_loss + dice_loss
+
+        return dice_bce_loss
+
+
 class LossSelector:
     def __init__(self, loss, **kwargs):
         if loss == 'BCEWithLogitsLoss':
             self.loss = BCE(**kwargs)
+        elif loss == 'DiceBCELoss':
+            self.loss = DiceBCELoss(**kwargs)
 
     def get_loss(self):
         return self.loss
\ No newline at end of file

From 1ee5c6bd35626bd8d40f056ec5abfa628e7da334 Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Thu, 21 Nov 2024 15:28:34 +0900
Subject: [PATCH 050/106] [#21, #39] Feature : add scheduler

---
 module_base/config.yaml    |  5 ++++-
 module_base/loss.py        |  8 ++++++--
 module_base/scheduler.py   | 13 +++++++++++++
 module_base/train.py       |  3 ++-
 module_base/transform.py   |  2 +-
 module_base/wandb_train.py |  9 +++++++--
 6 files changed, 33 insertions(+), 7 deletions(-)
 create mode 100644 module_base/scheduler.py

diff --git a/module_base/config.yaml b/module_base/config.yaml
index 3d0d52c..3569725 100644
--- a/module_base/config.yaml
+++ b/module_base/config.yaml
@@ -23,12 +23,15 @@ max_epoch: 50
 
 # loss
 loss:
-    name: DiceBCELoss
+    name: BCEWithLogitsLoss
     params: null
 
 # optimizer
 optim: Adam
 
+# scheduler
+scheduler: cosine
+
 # validation 인자
 kfold: 0
 val_every: 2
diff --git a/module_base/loss.py b/module_base/loss.py
index 938af30..9716b46 100644
--- a/module_base/loss.py
+++ b/module_base/loss.py
@@ -24,12 +24,16 @@ def forward(self, preds, targets):
 
         dice = (2. * intersection + self.eps) / (torch.sum(preds_f, -1) + torch.sum(targets_f, -1) + self.eps)
         loss = 1 - dice
-        
+
         return loss.mean()
 
+class IoULoss(nn.Module):
+    def __init__(self, **kwargs):
+        super(IoULoss, self).__init__()
+
 class DiceBCELoss(nn.Module):
     def __init__(self, **kwargs):
-        super(DiceBCELoss, self).__init__(**kwargs)
+        super(DiceBCELoss, self).__init__()
         self.bceWithLogitLoss = nn.BCEWithLogitsLoss(**kwargs)
         self.diceLoss = DiceLoss()
 
diff --git a/module_base/scheduler.py b/module_base/scheduler.py
new file mode 100644
index 0000000..9aa167c
--- /dev/null
+++ b/module_base/scheduler.py
@@ -0,0 +1,13 @@
+from torch.optim import lr_scheduler
+
+class SchedulerSelector:
+    def __init__(self, sched, optimizer, epoch):
+        self.optimizer = optimizer
+        self.epoch = epoch
+        if sched == 'step':
+            self.scheduler = lr_scheduler.StepLR(self.optimizer, step=5, gamma=0.6)
+        elif sched == 'cosine':
+            self.scheduler = lr_scheduler.CosineAnnealingLR(self.optimizer, T_max=self.epoch, eta_min=1e-6)
+            
+    def get_sched(self):
+        return self.scheduler
\ No newline at end of file
diff --git a/module_base/train.py b/module_base/train.py
index 0acbed3..d567e97 100644
--- a/module_base/train.py
+++ b/module_base/train.py
@@ -17,6 +17,7 @@
 from model import ModelSelector
 from transform import TransformSelector
 from loss import LossSelector
+from scheduler import SchedulerSelector
 
 import warnings
 warnings.filterwarnings('ignore')
@@ -138,7 +139,7 @@ def train(model, train_loader, val_loader, criterion, optimizer, save_dir, rando
             scaler.update()
             
             # step 주기에 따라 loss를 출력합니다.
-            if (step + 1) % 25 == 0:
+            if (step + 1) % 80 == 0:
                 print(
                     f'{datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")} | '
                     f'Epoch [{epoch+1}/{max_epoch}], '
diff --git a/module_base/transform.py b/module_base/transform.py
index cc2b6fa..37952bc 100644
--- a/module_base/transform.py
+++ b/module_base/transform.py
@@ -8,7 +8,7 @@ def __init__(self, is_train, resize):
             self.transform = A.Compose(
                 [
                     A.HorizontalFlip(0.2),
-                    A.CLAHE(clip_limit=4.0, tile_grid_size=(8, 8), always_apply=False, p=1.0)
+                    # A.CLAHE(clip_limit=4.0, tile_grid_size=(8, 8), always_apply=False, p=1.0)
                 ]+ common_transform)
         else:
             self.transform = A.Compose(common_transform)
diff --git a/module_base/wandb_train.py b/module_base/wandb_train.py
index b7346d9..0ec1cdc 100644
--- a/module_base/wandb_train.py
+++ b/module_base/wandb_train.py
@@ -18,6 +18,7 @@
 from model import ModelSelector
 from transform import TransformSelector
 from loss import LossSelector
+from scheduler import SchedulerSelector
 
 import warnings
 warnings.filterwarnings('ignore')
@@ -111,7 +112,7 @@ def validation(epoch, model, val_loader, criterion, model_type, thr=0.5):
     
     return avg_dice, val_loss
 
-def train(model, train_loader, val_loader, criterion, optimizer, cfg):
+def train(model, train_loader, val_loader, criterion, optimizer, scheduler, cfg):
     print(f'Start training..')
     logger = WandbLogger(name=cfg.wandb_run_name)
     
@@ -158,6 +159,7 @@ def train(model, train_loader, val_loader, criterion, optimizer, cfg):
                     f'Step [{step+1}/{len(train_loader)}], '
                     f'Loss: {round(loss.item(),4)}'
                 )
+        scheduler.step()
         epoch_time = datetime.timedelta(seconds=time.time() - epoch_start)
         dataset_size = len(train_loader.dataset)
         epoch_loss = epoch_loss / dataset_size
@@ -231,8 +233,11 @@ def main(cfg):
     criterion = loss.get_loss()
 
     optimizer = optim.Adam(params=model.parameters(), lr=cfg.lr, weight_decay=cfg.weight_decay)
+
+    sched = SchedulerSelector(cfg.scheduler, optimizer, cfg.max_epoch)
+    scheduler = sched.get_sched()
     
-    train(model, train_loader, valid_loader, criterion, optimizer, cfg)
+    train(model, train_loader, valid_loader, criterion, optimizer, scheduler, cfg)
 
 if __name__ == '__main__':
     parser = ArgumentParser()

From c3a6ef5b8bcc3a074f0c2c73629c8337c167bff5 Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Thu, 21 Nov 2024 15:30:37 +0900
Subject: [PATCH 051/106] [Refactor]:refactorization the structure of config

---
 mmsegmentation/baseline.py                                | 5 +++--
 .../configs/_baseline_/config_for_this_example.py         | 7 ++-----
 mmsegmentation/configs/_baseline_/dataset_setting.py      | 8 +++++---
 mmsegmentation/configs/_custom_/_base_/default_runtime.py | 6 +++---
 mmsegmentation/configs/_custom_/_base_/schedule_160k.py   | 2 ++
 5 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/mmsegmentation/baseline.py b/mmsegmentation/baseline.py
index 3ad37f0..96177b1 100644
--- a/mmsegmentation/baseline.py
+++ b/mmsegmentation/baseline.py
@@ -39,6 +39,7 @@
 CONFIG_PATH = "/data/ephemeral/home/parkjunil/level2-cv-semanticsegmentation-cv-19-lv3/mmsegmentation/configs/_baseline_/config_for_this_example.py"
 CHECKPOINT_PATH = "/data/ephemeral/home/parkjunil/work_dir/baseline/iter_20000.pth"
 SUBMISSION_PATH = "/data/ephemeral/home/submission"
+WORK_DIR = "/data/ephemeral/home/parkjunil/work_dir/baseline_1024"
 
 CLASSES = [
     'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
@@ -184,7 +185,7 @@ def load_config():
     # load config
     cfg = Config.fromfile(CONFIG_PATH)
     cfg.launcher = "none"
-    cfg.work_dir = "/data/ephemeral/home/parkjunil/work_dir/baseline"
+    cfg.work_dir = WORK_DIR
 
     # resume training
     cfg.resume = False
@@ -208,4 +209,4 @@ def inference():
 
 
 if __name__ == "__main__":
-    inference()
\ No newline at end of file
+    train()
\ No newline at end of file
diff --git a/mmsegmentation/configs/_baseline_/config_for_this_example.py b/mmsegmentation/configs/_baseline_/config_for_this_example.py
index 19e7ec6..07c676e 100644
--- a/mmsegmentation/configs/_baseline_/config_for_this_example.py
+++ b/mmsegmentation/configs/_baseline_/config_for_this_example.py
@@ -1,9 +1,9 @@
-_scope_ = ['mmengine', 'mmseg']
 # Train Segformer Mit B3
 _base_ = [
     "../_base_/models/segformer_mit-b0.py",
     "./dataset_setting.py",
-    "../_base_/default_runtime.py"
+    "../_custom_/_base_/schedule_160k.py",
+    "../_custom_/_base_/default_runtime.py"
 ]
 
 data_preprocessor = dict(
@@ -41,9 +41,6 @@
 optimizer = dict(type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01)
 optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
 
-# mixed precision
-fp16 = dict(loss_scale='dynamic')
-
 # learning policy
 param_scheduler = [
     dict(
diff --git a/mmsegmentation/configs/_baseline_/dataset_setting.py b/mmsegmentation/configs/_baseline_/dataset_setting.py
index 9a102b7..4b1e90b 100644
--- a/mmsegmentation/configs/_baseline_/dataset_setting.py
+++ b/mmsegmentation/configs/_baseline_/dataset_setting.py
@@ -1,15 +1,17 @@
+IMAGE_SIZE = (1024, 1024)
+
 # dataset settings
 dataset_type = 'XRayDataset2'
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadXRayAnnotations'),
-    dict(type='Resize', scale=(512, 512)),
+    dict(type='Resize', scale=IMAGE_SIZE),
     dict(type='TransposeAnnotations'),
     dict(type='PackSegInputs')
 ]
 val_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(512, 512)),
+    dict(type='Resize', scale=IMAGE_SIZE),
     # add loading annotation after ``Resize`` because ground truth
     # does not need to do resize data transform
     dict(type='LoadXRayAnnotations'),
@@ -18,7 +20,7 @@
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(512, 512)),
+    dict(type='Resize', scale=IMAGE_SIZE),
     dict(type='PackSegInputs')
 ]
 
diff --git a/mmsegmentation/configs/_custom_/_base_/default_runtime.py b/mmsegmentation/configs/_custom_/_base_/default_runtime.py
index b299fdc..106207f 100644
--- a/mmsegmentation/configs/_custom_/_base_/default_runtime.py
+++ b/mmsegmentation/configs/_custom_/_base_/default_runtime.py
@@ -24,9 +24,9 @@
             by_epoch=False,
             interval=1,
             init_kwargs=dict(
-                entity='frostings',
-                project='Boost Camp Lv2-3',
-                name='mmsegtest'),
+                project='MMsegmentation_segformer',
+                name='no_augmentation_1024'
+                ),
             log_checkpoint=True,
             log_checkpoint_metadata=True,
             num_eval_images=10)
diff --git a/mmsegmentation/configs/_custom_/_base_/schedule_160k.py b/mmsegmentation/configs/_custom_/_base_/schedule_160k.py
index 33a9da2..3b3a85f 100644
--- a/mmsegmentation/configs/_custom_/_base_/schedule_160k.py
+++ b/mmsegmentation/configs/_custom_/_base_/schedule_160k.py
@@ -13,6 +13,8 @@
     accumulative_counts=1
     )
 
+# mixed precision
+fp16 = dict(loss_scale='dynamic')
 
 # learning policy
 param_scheduler = [

From 48e20be59bfbc1729952f3af8039c910eab2ca6d Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Thu, 21 Nov 2024 15:36:08 +0900
Subject: [PATCH 052/106] [Fix}:remake dataset config to have same image size
 at train and validation

---
 .../configs/_custom_/_base_/xraydata2.py      | 58 ++++++++++---------
 1 file changed, 31 insertions(+), 27 deletions(-)

diff --git a/mmsegmentation/configs/_custom_/_base_/xraydata2.py b/mmsegmentation/configs/_custom_/_base_/xraydata2.py
index cb6aab7..b2b4ecc 100644
--- a/mmsegmentation/configs/_custom_/_base_/xraydata2.py
+++ b/mmsegmentation/configs/_custom_/_base_/xraydata2.py
@@ -1,3 +1,5 @@
+IMAGE_SIZE = (1024, 1024)
+
 # dataset settings
 dataset_type = 'XRayDataset2'
 
@@ -5,46 +7,26 @@
 train_pipeline = [
             dict(type='LoadImageFromFile'),
             dict(type='LoadXRayAnnotations'),
-            dict(type='Resize', scale=(1280, 1280)),
-            dict(type='RandomFlip', prob=0.5),
-            dict(type='RandomRotate', prob=0.5, degree=15),
-            dict(type='PhotoMetricDistortion'),
+            dict(type='Resize', scale=IMAGE_SIZE),
             dict(type='TransposeAnnotations'),
             dict(type='PackSegInputs')
         ]
 val_pipeline = [
             dict(type='LoadImageFromFile'),
+            dict(type='Resize', scale=IMAGE_SIZE),
             dict(type='LoadXRayAnnotations'),
             dict(type='TransposeAnnotations'),
             dict(type='PackSegInputs')
         ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(2048, 2048), keep_ratio=True),
+    dict(type='Resize', scale=IMAGE_SIZE),
     dict(type='PackSegInputs')
 ]
 
-
-img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
-tta_pipeline = [
-    dict(type='LoadImageFromFile', backend_args=None),
-    dict(
-        type='TestTimeAug',
-        transforms=[
-            [
-                dict(type='Resize', scale_factor=r, keep_ratio=True)
-                for r in img_ratios
-            ],
-            [
-                dict(type='RandomFlip', prob=0., direction='horizontal'),
-                dict(type='RandomFlip', prob=1., direction='horizontal')
-            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
-        ])
-]
-
 train_dataloader = dict(
-    batch_size=2,
-    num_workers=1,
+    batch_size=1,
+    num_workers=2,
     # persistent_workers=True,
     sampler=dict(type='InfiniteSampler', shuffle=True),
     dataset=dict(
@@ -62,7 +44,7 @@
 
 
 test_dataloader = dict(
-    batch_size=1,
+    batch_size=8,
     num_workers=4,
     persistent_workers=True,
     sampler=dict(type='DefaultSampler', shuffle=False),
@@ -75,4 +57,26 @@
 
 
 val_evaluator = dict(type='DiceMetricForMultiLabel')
-test_evaluator = dict(type='SubmissionMetric')
\ No newline at end of file
+test_evaluator = dict(type='SubmissionMetric')
+
+
+
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale_factor=r, keep_ratio=True)
+                for r in img_ratios
+            ],
+            [
+                dict(type='RandomFlip', prob=0., direction='horizontal'),
+                dict(type='RandomFlip', prob=1., direction='horizontal')
+            ], 
+            [
+                dict(type='PackSegInputs')
+            ]
+        ])
+]
\ No newline at end of file

From a4f2324106851f3a470b3f24bcd82caf2c783f28 Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Thu, 21 Nov 2024 15:53:59 +0900
Subject: [PATCH 053/106] [Feature] : scheduler update

---
 sam2_unet/test.py            |  8 +++++---
 sam2_unet/trainer.py         |  8 +++++++-
 sam2_unet/utils/dataset.py   |  2 +-
 sam2_unet/utils/transform.py | 19 ++++++++++++++++---
 4 files changed, 29 insertions(+), 8 deletions(-)

diff --git a/sam2_unet/test.py b/sam2_unet/test.py
index 368c4f5..788ac6c 100644
--- a/sam2_unet/test.py
+++ b/sam2_unet/test.py
@@ -60,8 +60,8 @@ def test(model, args, thr=0.5):
     transform = transform_selector.get_transform(is_train=False)
 
     test_dataset = TestDataset(
-        args.test_image_path,
-        transform
+        image_root=args.test_image_path,
+        transform=transform
     )
 
     test_loader = DataLoader(
@@ -108,7 +108,9 @@ def main(args):
         "class": classes,
         "rle": rles,
     })
-    df.to_csv("./outputs/output1.csv", index=False)
+    df.to_csv("./outputs/output.csv", index=False)
 
 if __name__ == "__main__":
     main(args)
+
+# python test.py --checkpoint <checkpoint_path>  
diff --git a/sam2_unet/trainer.py b/sam2_unet/trainer.py
index a21c7a1..b360dec 100644
--- a/sam2_unet/trainer.py
+++ b/sam2_unet/trainer.py
@@ -8,6 +8,7 @@
 import torch
 import torch.nn.functional as F
 from torch.utils.data import DataLoader
+from torch.optim.lr_scheduler import ReduceLROnPlateau
 
 class Trainer:
     def __init__(
@@ -178,8 +179,13 @@ def train(self) -> None:
             valid_loss, valid_dice = self.validate(self.valid_loader)
             valid_loss = valid_loss / len(self.valid_loader.dataset)
 
+            if isinstance(self.scheduler, ReduceLROnPlateau):
+                self.scheduler.step(valid_loss)
+            else:
+                self.scheduler.step()
+
             epoch_time = datetime.timedelta(seconds=time.time() - epoch_start)
-            print(f"Epoch {epoch+1}, Train Loss: {train_loss:.6f} | Train Dice: {train_dice:.6f} \nVaild Loss: {valid_loss:.6f} | Vaild Dice: {valid_dice:.6f}\n")
+            print(f"Epoch {epoch+1}, Train Loss: {train_loss:.6f} | Train Dice: {train_dice:.6f} | Vaild Loss: {valid_loss:.6f} | Vaild Dice: {valid_dice:.6f}\n")
             logger.log_epoch_metrics(
                 {
                     "epoch": epoch,
diff --git a/sam2_unet/utils/dataset.py b/sam2_unet/utils/dataset.py
index a10aa0c..88c2fa1 100644
--- a/sam2_unet/utils/dataset.py
+++ b/sam2_unet/utils/dataset.py
@@ -111,7 +111,7 @@ def __init__(self, image_root, gt_root, is_train=True, transforms=None, kfold=5,
                 labelnames += list(_labelnames[y])
             
             else:
-                if i != k:
+                if k >= 0 and i != k:
                     continue
                 filenames = list(_filenames[y])
                 labelnames = list(_labelnames[y])
diff --git a/sam2_unet/utils/transform.py b/sam2_unet/utils/transform.py
index 44fa8c4..0203c68 100644
--- a/sam2_unet/utils/transform.py
+++ b/sam2_unet/utils/transform.py
@@ -1,17 +1,30 @@
 import albumentations as A
 
+"""
+augmentation list
+
+A.HorizontalFlip(p=0.5)
+A.Rotate(limit=(-10, 10), border_mode=cv2.BORDER_CONSTANT, value=(255, 255, 255), p=0.5)
+A.CLAHE(clip_limit=4.0, tile_grid_size=(8, 8), always_apply=None, p=0.5)
+A.ColorJitter(brightness=(0.8, 1.2), contrast=(0.8, 1.2), saturation=(0.8, 1.2), hue=(-0.5, 0.5), p=0.5, always_apply=None)
+A.GaussNoise(var_limit=None, mean=None, std_range=(0.2, 0.44), mean_range=(0.0, 0.0), per_channel=True, noise_scale_factor=1, always_apply=None, p=0.5)
+A.RandomBrightnessContrast(brightness_limit=(-0.2, 0.2), contrast_limit=(-0.2, 0.2), brightness_by_max=True, ensure_safe_range=False, always_apply=None, p=0.5),
+A.Morphological(scale=(2, 3), operation='dilation' or 'erosion', p=0.5, always_apply=None)
+A.PixelDropout(dropout_prob=0.01, per_channel=False, drop_value=0, mask_drop_value=None, p=0.5, always_apply=None)
+A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0, normalization='standard', always_apply=None, p=1.0)
+
+"""
 class TransformSelector:
-    def __init__(self, image_size):
+    def __init__(self, image_size, ):
         self.common_transform = [A.Resize(image_size, image_size)]
 
     def get_transform(self, is_train=True):
         if is_train:
             transform = A.Compose(
                 [
-                    A.HorizontalFlip(p=0.5)
+                    A.HorizontalFlip()
                 ]+ self.common_transform)
         else:
             transform = A.Compose(self.common_transform)
 
         return transform
-

From 97228c4af4c4fbe258bf0cd29494a0268645d048 Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Thu, 21 Nov 2024 21:25:58 +0900
Subject: [PATCH 054/106] [Feature] : add scaler

---
 sam2_unet/train.py           |  2 +-
 sam2_unet/trainer.py         | 26 +++++++++++++++-----------
 sam2_unet/utils/transform.py |  3 ++-
 3 files changed, 18 insertions(+), 13 deletions(-)

diff --git a/sam2_unet/train.py b/sam2_unet/train.py
index 2bfc436..efc0a57 100644
--- a/sam2_unet/train.py
+++ b/sam2_unet/train.py
@@ -98,7 +98,7 @@ def main(cfg):
         start_epoch=cfg.start_epoch
     )
 
-    trainer.train()
+    trainer.do_train()
     
 if __name__ == "__main__":
     parser = ArgumentParser()
diff --git a/sam2_unet/trainer.py b/sam2_unet/trainer.py
index b360dec..58f7f41 100644
--- a/sam2_unet/trainer.py
+++ b/sam2_unet/trainer.py
@@ -46,6 +46,7 @@ def __init__(
         self.resume = resume
         self.ckpt_file = ckpt_path
         self.start_epoch = start_epoch
+        self.scaler = torch.cuda.amp.GradScaler()
         self.classes = [
             'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
             'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
@@ -68,7 +69,7 @@ def dice_coef(self, y_true, y_pred):
         eps = 0.0001
         return (2. * intersection + eps) / (torch.sum(y_true_f, -1) + torch.sum(y_pred_f, -1) + eps)
 
-    def train_epoch(self, train_loader: DataLoader):
+    def train(self, train_loader: DataLoader):
         self.model.train()
         
         train_loss = 0.
@@ -79,13 +80,16 @@ def train_epoch(self, train_loader: DataLoader):
             images, masks = images.to(self.device), masks.to(self.device)
             self.optimizer.zero_grad()
 
-            pred0, pred1, pred2 = self.model(images)
-            loss0 = self.loss_fn(pred0, masks)
-            loss1 = self.loss_fn(pred1, masks)
-            loss2 = self.loss_fn(pred2, masks)
-            loss = loss0 + loss1 + loss2
-            loss.backward()
-            self.optimizer.step()
+            with torch.cuda.amp.autocast():
+                pred0, pred1, pred2 = self.model(images)
+                loss0 = self.loss_fn(pred0, masks)
+                loss1 = self.loss_fn(pred1, masks)
+                loss2 = self.loss_fn(pred2, masks)
+                loss = loss0 + loss1 + loss2
+
+            self.scaler.scale(loss).backward()
+            self.scaler.step(self.optimizer)
+            self.scaler.update()
             
             train_loss += loss.item() * masks.shape[0]
 
@@ -150,7 +154,7 @@ def validate(self, valid_loader: DataLoader) -> tuple[float, float]:
 
         return valid_loss, valid_dice
 
-    def train(self) -> None:
+    def do_train(self) -> None:
         logger = WandbLogger(name=self.wandb_name)
         logger.initialize({
             "model_type": "SAM2-UNet",
@@ -172,7 +176,7 @@ def train(self) -> None:
             train_dice, valid_dice = 0., 0.
             print(f"Epoch {epoch+1}/{self.epochs}")
             
-            train_loss, train_dice = self.train_epoch(self.train_loader)
+            train_loss, train_dice = self.train(self.train_loader)
             train_loss = train_loss / len(self.train_loader.dataset)
 
             torch.cuda.empty_cache()
@@ -194,7 +198,7 @@ def train(self) -> None:
                     "train_dice": train_dice,
                     "valid_loss": valid_loss,
                     "valid_dice": valid_dice,
-                    "learning_rate": self.scheduler.get_last_lr()[0]
+                    "learning_rate": self.optimizer.param_groups[0]['lr']
                 }
             )
             if (epoch + 1) % self.save_every == 0:
diff --git a/sam2_unet/utils/transform.py b/sam2_unet/utils/transform.py
index 0203c68..af03e70 100644
--- a/sam2_unet/utils/transform.py
+++ b/sam2_unet/utils/transform.py
@@ -22,7 +22,8 @@ def get_transform(self, is_train=True):
         if is_train:
             transform = A.Compose(
                 [
-                    A.HorizontalFlip()
+                    A.HorizontalFlip(),
+                    A.ColorJitter()
                 ]+ self.common_transform)
         else:
             transform = A.Compose(self.common_transform)

From a4a024de03becbf38ea40165aaeb1af3b562f26b Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Thu, 21 Nov 2024 22:33:17 +0900
Subject: [PATCH 055/106] [Refactor]:refactor code to set image, label root in
 config

---
 custom_inference.py                           |   0
 mmsegmentation/baseline.py                    | 173 +-----------------
 .../_baseline_/config_for_this_example.py     |   2 +-
 .../configs/_baseline_/dataset_setting.py     |   6 +
 .../configs/_custom_/_base_/xraydata2.py      |  25 ++-
 mmsegmentation/custom_trian.py                |   0
 mmsegmentation/mmseg/datasets/xray2.py        |  82 ++++-----
 .../mmseg/models/segmentors/custom.py         |   2 +-
 8 files changed, 65 insertions(+), 225 deletions(-)
 create mode 100644 custom_inference.py
 create mode 100644 mmsegmentation/custom_trian.py

diff --git a/custom_inference.py b/custom_inference.py
new file mode 100644
index 0000000..e69de29
diff --git a/mmsegmentation/baseline.py b/mmsegmentation/baseline.py
index 96177b1..f9657b4 100644
--- a/mmsegmentation/baseline.py
+++ b/mmsegmentation/baseline.py
@@ -1,33 +1,5 @@
-import os
-import json
-from collections import OrderedDict, defaultdict
-import numpy as np
-import pandas as pd
-import cv2
-from sklearn.model_selection import GroupKFold
-import matplotlib.pyplot as plt
-from prettytable import PrettyTable
-from tqdm.auto import tqdm
-
-import torch
-from torch import nn
-import torch.nn.functional as F
-from mmseg.registry import DATASETS, TRANSFORMS, MODELS, METRICS
-from mmseg.datasets import BaseSegDataset
-from mmseg.models.segmentors import EncoderDecoder
-from mmseg.models.decode_heads import ASPPHead, FCNHead, SegformerHead
-from mmseg.models.utils.wrappers import resize
-from mmseg.structures import SegDataSample
-
-
 from mmengine.config import Config
-from mmengine.dataset import Compose
-from mmengine.runner import Runner, load_checkpoint
-from mmengine.evaluator import BaseMetric
-from mmengine.logging import MMLogger, print_log
-from mmengine.structures import PixelData
-
-from mmcv.transforms import BaseTransform
+from mmengine.runner import Runner
 
 
 ##############################
@@ -37,148 +9,9 @@
 TEST_IMAGE_ROOT = "/data/ephemeral/home/data/test/DCM"
 LABEL_ROOT = "/data/ephemeral/home/data/train/outputs_json"
 CONFIG_PATH = "/data/ephemeral/home/parkjunil/level2-cv-semanticsegmentation-cv-19-lv3/mmsegmentation/configs/_baseline_/config_for_this_example.py"
-CHECKPOINT_PATH = "/data/ephemeral/home/parkjunil/work_dir/baseline/iter_20000.pth"
+CHECKPOINT_PATH = "/data/ephemeral/home/parkjunil/work_dir/baseline_1024/best_mDice_iter_20000.pth"
 SUBMISSION_PATH = "/data/ephemeral/home/submission"
-WORK_DIR = "/data/ephemeral/home/parkjunil/work_dir/baseline_1024"
-
-CLASSES = [
-    'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
-    'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
-    'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
-    'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
-    'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
-    'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
-]
-CLASS2IND = {v: i for i, v in enumerate(CLASSES)}
-IND2CLASS = {v: k for k, v in CLASS2IND.items()}
-pngs = {
-    os.path.relpath(os.path.join(root, fname), start=IMAGE_ROOT)
-    for root, _dirs, files in os.walk(IMAGE_ROOT)
-    for fname in files
-    if os.path.splitext(fname)[1].lower() == ".png"
-}
-
-jsons = {
-    os.path.relpath(os.path.join(root, fname), start=LABEL_ROOT)
-    for root, _dirs, files in os.walk(LABEL_ROOT)
-    for fname in files
-    if os.path.splitext(fname)[1].lower() == ".json"
-}
-
-pngs = sorted(pngs)
-jsons = sorted(jsons)
-    
-
-# define colors
-PALETTE = [
-    (220, 20, 60), (119, 11, 32), (0, 0, 142), (0, 0, 230), (106, 0, 228),
-    (0, 60, 100), (0, 80, 100), (0, 0, 70), (0, 0, 192), (250, 170, 30),
-    (100, 170, 30), (220, 220, 0), (175, 116, 175), (250, 0, 30), (165, 42, 42),
-    (255, 77, 255), (0, 226, 252), (182, 182, 255), (0, 82, 0), (120, 166, 157),
-    (110, 76, 0), (174, 57, 255), (199, 100, 0), (72, 0, 118), (255, 179, 240),
-    (0, 125, 92), (209, 0, 151), (188, 208, 182), (0, 220, 176),
-]
-
-# utility function
-# this does not care overlap
-def label2rgb(label):
-    image_size = label.shape[1:] + (3, )
-    image = np.zeros(image_size, dtype=np.uint8)
-
-    for i, class_label in enumerate(label):
-        image[class_label == 1] = PALETTE[i]
-
-    return image
-
-def _preprare_data(imgs, model, cfg):
-    for t in cfg.test_pipeline:
-        if t.get('type') in ['LoadXRayAnnotations', 'TransposeAnnotations']:
-            cfg.test_pipeline.remove(t)
-
-    is_batch = True
-    if not isinstance(imgs, (list, tuple)):
-        imgs = [imgs]
-        is_batch = False
-
-    if isinstance(imgs[0], np.ndarray):
-        cfg.test_pipeline[0]['type'] = 'LoadImageFromNDArray'
-
-    # TODO: Consider using the singleton pattern to avoid building
-    # a pipeline for each inference
-    pipeline = Compose(cfg.test_pipeline)
-
-    data = defaultdict(list)
-    for img in imgs:
-        if isinstance(img, np.ndarray):
-            data_ = dict(img=img)
-        else:
-            data_ = dict(img_path=img)
-        data_ = pipeline(data_)
-        data['inputs'].append(data_['inputs'])
-        data['data_samples'].append(data_['data_samples'])
-
-    return data, is_batch
-
-
-def encode_mask_to_rle(mask):
-    '''
-    mask: numpy array binary mask
-    1 - mask
-    0 - background
-    Returns encoded run length
-    '''
-    pixels = mask.flatten()
-    pixels = np.concatenate([[0], pixels, [0]])
-    runs = np.where(pixels[1:] != pixels[:-1])[0] + 1
-    runs[1::2] -= runs[::2]
-    return ' '.join(str(x) for x in runs)
-
-
-def decode_rle_to_mask(rle, height, width):
-    s = rle.split()
-    starts, lengths = [np.asarray(x, dtype=int) for x in (s[0:][::2], s[1:][::2])]
-    starts -= 1
-    ends = starts + lengths
-    img = np.zeros(height * width, dtype=np.uint8)
-
-    for lo, hi in zip(starts, ends):
-        img[lo:hi] = 1
-
-    return img.reshape(height, width)
-
-
-def test(model, image_paths, thr=0.5):
-    rles = []
-    filename_and_class = []
-    with torch.no_grad():
-        n_class = len(CLASSES)
-
-        for step, image_path in tqdm(enumerate(image_paths), total=len(image_paths)):
-            img = cv2.imread(os.path.join(IMAGE_ROOT,image_path))
-
-            # prepare data
-            data, is_batch = _preprare_data(img, model)
-
-            # forward the model
-            with torch.no_grad():
-                outputs = model.test_step(data)
-
-            outputs = outputs[0].pred_sem_seg.data
-            outputs = outputs[None]
-
-            # restore original size
-            outputs = F.interpolate(outputs, size=(2048, 2048), mode="bilinear")
-            outputs = torch.sigmoid(outputs)
-            outputs = (outputs > thr).detach().cpu().numpy()
-
-            output = outputs[0]
-            image_name = os.path.basename(image_path)
-            for c, segm in enumerate(output):
-                rle = encode_mask_to_rle(segm)
-                rles.append(rle)
-                filename_and_class.append(f"{IND2CLASS[c]}_{image_name}")
-
-    return rles, filename_and_class
+WORK_DIR = "/data/ephemeral/home/parkjunil/work_dir/baseline_1536_flip"
 
 
 def load_config():
diff --git a/mmsegmentation/configs/_baseline_/config_for_this_example.py b/mmsegmentation/configs/_baseline_/config_for_this_example.py
index 07c676e..fba8d54 100644
--- a/mmsegmentation/configs/_baseline_/config_for_this_example.py
+++ b/mmsegmentation/configs/_baseline_/config_for_this_example.py
@@ -1,7 +1,7 @@
 # Train Segformer Mit B3
 _base_ = [
     "../_base_/models/segformer_mit-b0.py",
-    "./dataset_setting.py",
+    "../_custom_/_base_/xraydata2.py",
     "../_custom_/_base_/schedule_160k.py",
     "../_custom_/_base_/default_runtime.py"
 ]
diff --git a/mmsegmentation/configs/_baseline_/dataset_setting.py b/mmsegmentation/configs/_baseline_/dataset_setting.py
index 4b1e90b..a6a2efa 100644
--- a/mmsegmentation/configs/_baseline_/dataset_setting.py
+++ b/mmsegmentation/configs/_baseline_/dataset_setting.py
@@ -1,4 +1,6 @@
 IMAGE_SIZE = (1024, 1024)
+IMAGE_ROOT = '/data/ephemeral/home/data/train/DCM'
+LABEL_ROOT = '/data/ephemeral/home/data/train/outputs_json'
 
 # dataset settings
 dataset_type = 'XRayDataset2'
@@ -32,6 +34,8 @@
     dataset=dict(
         type=dataset_type,
         is_train=True,
+        image_root=IMAGE_ROOT,
+        label_root=LABEL_ROOT,
         pipeline=train_pipeline
     )
 )
@@ -42,6 +46,8 @@
     dataset=dict(
         type=dataset_type,
         is_train=False,
+        image_root=IMAGE_ROOT,
+        label_root=LABEL_ROOT,
         pipeline=val_pipeline
     )
 )
diff --git a/mmsegmentation/configs/_custom_/_base_/xraydata2.py b/mmsegmentation/configs/_custom_/_base_/xraydata2.py
index b2b4ecc..e793c02 100644
--- a/mmsegmentation/configs/_custom_/_base_/xraydata2.py
+++ b/mmsegmentation/configs/_custom_/_base_/xraydata2.py
@@ -1,4 +1,6 @@
-IMAGE_SIZE = (1024, 1024)
+IMAGE_SIZE = (1536, 1536)
+IMAGE_ROOT = '/data/ephemeral/home/data/train/DCM'
+LABEL_ROOT = '/data/ephemeral/home/data/train/outputs_json'
 
 # dataset settings
 dataset_type = 'XRayDataset2'
@@ -8,6 +10,7 @@
             dict(type='LoadImageFromFile'),
             dict(type='LoadXRayAnnotations'),
             dict(type='Resize', scale=IMAGE_SIZE),
+            # dict(type='RandomRotFlip', rotate_prob=0.2, flip_prob=0.4),
             dict(type='TransposeAnnotations'),
             dict(type='PackSegInputs')
         ]
@@ -26,21 +29,29 @@
 
 train_dataloader = dict(
     batch_size=1,
-    num_workers=2,
-    # persistent_workers=True,
+    num_workers=4,
+    persistent_workers=True,
     sampler=dict(type='InfiniteSampler', shuffle=True),
     dataset=dict(
         type=dataset_type,
-        is_train = True,
-        pipeline=train_pipeline))
+        is_train=True,
+        image_root=IMAGE_ROOT,
+        label_root=LABEL_ROOT,
+        pipeline=train_pipeline
+    )
+    )
 val_dataloader = dict(
     batch_size=1,
     num_workers=1,
     sampler=dict(type='DefaultSampler', shuffle=False),
     dataset=dict(
         type=dataset_type,
-        is_train = False,
-        pipeline=val_pipeline))
+        is_train=False,
+        image_root=IMAGE_ROOT,
+        label_root=LABEL_ROOT,
+        pipeline=val_pipeline
+    )
+    )
 
 
 test_dataloader = dict(
diff --git a/mmsegmentation/custom_trian.py b/mmsegmentation/custom_trian.py
new file mode 100644
index 0000000..e69de29
diff --git a/mmsegmentation/mmseg/datasets/xray2.py b/mmsegmentation/mmseg/datasets/xray2.py
index 9396f74..d151008 100644
--- a/mmsegmentation/mmseg/datasets/xray2.py
+++ b/mmsegmentation/mmseg/datasets/xray2.py
@@ -12,9 +12,6 @@
 
 # 데이터 경로를 입력하세요
 
-IMAGE_ROOT = '/data/ephemeral/home/data/train/DCM'
-LABEL_ROOT = '/data/ephemeral/home/data/train/outputs_json'
-
 CLASSES = [
     'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
     'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
@@ -27,55 +24,48 @@
 CLASS2IND = {v: i for i, v in enumerate(CLASSES)}
 IND2CLASS = {v: k for k, v in CLASS2IND.items()}
 
-pngs = {
-    os.path.relpath(os.path.join(root, fname), start=IMAGE_ROOT)
-    for root, _dirs, files in os.walk(IMAGE_ROOT)
-    for fname in files
-    if os.path.splitext(fname)[1].lower() == ".png"
-}
-
-jsons = {
-    os.path.relpath(os.path.join(root, fname), start=LABEL_ROOT)
-    for root, _dirs, files in os.walk(LABEL_ROOT)
-    for fname in files
-    if os.path.splitext(fname)[1].lower() == ".json"
-}
-
-jsons_fn_prefix = {os.path.splitext(fname)[0] for fname in jsons}
-pngs_fn_prefix = {os.path.splitext(fname)[0] for fname in pngs}
-
-assert len(jsons_fn_prefix - pngs_fn_prefix) == 0
-assert len(pngs_fn_prefix - jsons_fn_prefix) == 0
-
-pngs = sorted(pngs)
-jsons = sorted(jsons)
-
-_filenames = np.array(pngs)
-_labelnames = np.array(jsons)
-    
-# split train-valid
-# 한 폴더 안에 한 인물의 양손에 대한 `.dcm` 파일이 존재하기 때문에
-# 폴더 이름을 그룹으로 해서 GroupKFold를 수행합니다.
-# 동일 인물의 손이 train, valid에 따로 들어가는 것을 방지합니다.
-groups = [os.path.dirname(fname) for fname in _filenames]
-
-# dummy label
-ys = [0 for fname in _filenames]
-
-# 전체 데이터의 20%를 validation data로 쓰기 위해 `n_splits`를
-# 5으로 설정하여 KFold를 수행합니다.
-gkf = GroupKFold(n_splits=5)
 
 @DATASETS.register_module()
 class XRayDataset2(BaseSegDataset):
-    def __init__(self, is_train, **kwargs):
+    def __init__(self, 
+                 is_train, 
+                 image_root='/data/ephemeral/home/data/train/DCM',
+                 label_root='/data/ephemeral/home/data/train/outputs_json',
+                 **kwargs):
+        
+        self.image_root = image_root
+        self.label_root = label_root
         self.is_train = is_train
         
+        
+        pngs = {
+            os.path.relpath(os.path.join(root, fname), start=self.image_root)
+            for root, _dirs, files in os.walk(self.image_root)
+            for fname in files
+            if os.path.splitext(fname)[1].lower() == ".png"
+        }
+
+        jsons = {
+            os.path.relpath(os.path.join(root, fname), start=self.label_root)
+            for root, _dirs, files in os.walk(self.label_root)
+            for fname in files
+            if os.path.splitext(fname)[1].lower() == ".json"
+        }
+
+        jsons_fn_prefix = {os.path.splitext(fname)[0] for fname in jsons}
+        pngs_fn_prefix = {os.path.splitext(fname)[0] for fname in pngs}
+
+        assert len(jsons_fn_prefix - pngs_fn_prefix) == 0
+        assert len(pngs_fn_prefix - jsons_fn_prefix) == 0
+
+        self.pngs = sorted(pngs)
+        self.jsons = sorted(jsons)
+        
         super().__init__(**kwargs)
         
     def load_data_list(self):
-        _filenames = np.array(pngs)
-        _labelnames = np.array(jsons)
+        _filenames = np.array(self.pngs)
+        _labelnames = np.array(self.jsons)
 
         groups = [os.path.dirname(fname) for fname in _filenames]
 
@@ -103,8 +93,8 @@ def load_data_list(self):
         data_list = []
         for i, (img_path, ann_path) in enumerate(zip(filenames, labelnames)):
             data_info = dict(
-                img_path=os.path.join(IMAGE_ROOT, img_path),
-                seg_map_path=os.path.join(LABEL_ROOT, ann_path),
+                img_path=os.path.join(self.image_root, img_path),
+                seg_map_path=os.path.join(self.label_root, ann_path),
             )
             data_list.append(data_info)
 
diff --git a/mmsegmentation/mmseg/models/segmentors/custom.py b/mmsegmentation/mmseg/models/segmentors/custom.py
index bef7330..fb4e9c6 100644
--- a/mmsegmentation/mmseg/models/segmentors/custom.py
+++ b/mmsegmentation/mmseg/models/segmentors/custom.py
@@ -63,7 +63,7 @@ def postprocess_result(self,
                 i_seg_logits = resize(
                     i_seg_logits,
                     size=img_meta['ori_shape'],
-                    mode='bilinear',
+                    mode='bicubic',
                     align_corners=self.align_corners,
                     warning=False).squeeze(0)
             else:

From 7266178f4ead8e9b8943d625a9cc29f0d3bd454f Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Thu, 21 Nov 2024 22:49:09 +0900
Subject: [PATCH 056/106] [Refactor]:Refactor the baseline code into infer and
 train

---
 custom_inference.py                           | 33 +++++++++++++++++++
 mmsegmentation/baseline.py                    |  3 --
 .../configs/_custom_/_base_/xraydata2.py      |  3 +-
 mmsegmentation/custom_trian.py                | 30 +++++++++++++++++
 4 files changed, 65 insertions(+), 4 deletions(-)

diff --git a/custom_inference.py b/custom_inference.py
index e69de29..eb54337 100644
--- a/custom_inference.py
+++ b/custom_inference.py
@@ -0,0 +1,33 @@
+from mmengine.config import Config
+from mmengine.runner import Runner
+import argparse
+
+
+def parse_arguments():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--config_path', help='config의 경로', default='./configs/_baseline_/config_for_this_example.py')
+    parser.add_argument('--checkpoint_path', help='.pth파일 위치', default='./work_dir/best_mDice_iter_20000.pth')
+    parser.add_argument('--work_dir', help='실험 결과를 저장할 경로', default='./work_dir')
+    parser.add_argument('--submission_path', help='inference 결과를 저장할 경로', default='./result')
+    args = parser.parse_args()
+    return args
+
+    
+def main(config_path, checkpoint_path, work_dir, submission_path):
+     # load config
+    cfg = Config.fromfile(config_path)
+    cfg.launcher = "none"
+    cfg.work_dir = work_dir
+
+    # resume training
+    cfg.resume = False
+    cfg.load_from = checkpoint_path
+    cfg.test_evaluator.save_path = submission_path
+    
+    runner = Runner.from_cfg(cfg)
+    runner.test()
+
+
+if __name__ == "__main__":
+    args = parse_arguments()
+    main(args.config_path, args.checkpoint_path, args.work_dir, args.submission_path)
\ No newline at end of file
diff --git a/mmsegmentation/baseline.py b/mmsegmentation/baseline.py
index f9657b4..46be871 100644
--- a/mmsegmentation/baseline.py
+++ b/mmsegmentation/baseline.py
@@ -5,9 +5,6 @@
 ##############################
 # 데이터 경로를 입력하세요
 
-IMAGE_ROOT = "/data/ephemeral/home/data/train/DCM"
-TEST_IMAGE_ROOT = "/data/ephemeral/home/data/test/DCM"
-LABEL_ROOT = "/data/ephemeral/home/data/train/outputs_json"
 CONFIG_PATH = "/data/ephemeral/home/parkjunil/level2-cv-semanticsegmentation-cv-19-lv3/mmsegmentation/configs/_baseline_/config_for_this_example.py"
 CHECKPOINT_PATH = "/data/ephemeral/home/parkjunil/work_dir/baseline_1024/best_mDice_iter_20000.pth"
 SUBMISSION_PATH = "/data/ephemeral/home/submission"
diff --git a/mmsegmentation/configs/_custom_/_base_/xraydata2.py b/mmsegmentation/configs/_custom_/_base_/xraydata2.py
index e793c02..bc3907f 100644
--- a/mmsegmentation/configs/_custom_/_base_/xraydata2.py
+++ b/mmsegmentation/configs/_custom_/_base_/xraydata2.py
@@ -1,6 +1,7 @@
 IMAGE_SIZE = (1536, 1536)
 IMAGE_ROOT = '/data/ephemeral/home/data/train/DCM'
 LABEL_ROOT = '/data/ephemeral/home/data/train/outputs_json'
+SUBMISSION_PATH = '/data/ephemeral/home/submission'
 
 # dataset settings
 dataset_type = 'XRayDataset2'
@@ -68,7 +69,7 @@
 
 
 val_evaluator = dict(type='DiceMetricForMultiLabel')
-test_evaluator = dict(type='SubmissionMetric')
+test_evaluator = dict(type='SubmissionMetric', save_path=SUBMISSION_PATH, max_vis_cnt=20)
 
 
 
diff --git a/mmsegmentation/custom_trian.py b/mmsegmentation/custom_trian.py
index e69de29..ec53487 100644
--- a/mmsegmentation/custom_trian.py
+++ b/mmsegmentation/custom_trian.py
@@ -0,0 +1,30 @@
+from mmengine.config import Config
+from mmengine.runner import Runner
+import argparse
+
+
+def parse_arguments():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--config_path', help='config의 경로', default='./configs/_baseline_/config_for_this_example.py')
+    parser.add_argument('--work_dir', help='실험 결과를 저장할 경로', default='./work_dir')
+    args = parser.parse_args()
+    return args
+
+    
+def main(config_path, work_dir):
+     # load config
+    cfg = Config.fromfile(config_path)
+    cfg.launcher = "none"
+    cfg.work_dir = work_dir
+
+    # resume training
+    cfg.resume = False
+    runner = Runner.from_cfg(cfg)
+
+    # start training
+    runner.train()
+
+
+if __name__ == "__main__":
+    args = parse_arguments()
+    main(args.config_path, args.work_dir)
\ No newline at end of file

From e17fb62f30fd8c86a4f89f6460a846e784f45ab0 Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Thu, 21 Nov 2024 23:02:15 +0900
Subject: [PATCH 057/106] [#21] Feature : optimal

---
 module_base/config.yaml    | 4 ++--
 module_base/inference.py   | 4 ++--
 module_base/scheduler.py   | 8 ++++++--
 module_base/train.py       | 1 +
 module_base/transform.py   | 1 +
 module_base/wandb_train.py | 4 ++--
 6 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/module_base/config.yaml b/module_base/config.yaml
index 3569725..49dbe5c 100644
--- a/module_base/config.yaml
+++ b/module_base/config.yaml
@@ -23,7 +23,7 @@ max_epoch: 50
 
 # loss
 loss:
-    name: BCEWithLogitsLoss
+    name: DiceBCELoss
     params: null
 
 # optimizer
@@ -44,5 +44,5 @@ random_seed: 2024
 size: 1024
 
 # wandb
-wandb_run_name: Test
+wandb_run_name: DiceBCELoss_exp
 wandb_run_id: None
\ No newline at end of file
diff --git a/module_base/inference.py b/module_base/inference.py
index ee5801e..15cadc9 100644
--- a/module_base/inference.py
+++ b/module_base/inference.py
@@ -101,10 +101,10 @@ def do_inference(image_root, save_dir, random_seed, model_type):
         for fname in files
         if os.path.splitext(fname)[1].lower() == ".png"
     }
-    model = torch.load(os.path.join(save_dir, "best_model.pt"))
+    model = torch.load(os.path.join(save_dir, "cosine.pt"))
     
     test_trans = TransformSelector('albumentation')
-    test_tf = test_trans.get_transform(False, 512)
+    test_tf = test_trans.get_transform(False, 1024)
     test_dataset = XRayInferenceDataset(fnames, image_root,transforms=test_tf)
     
     test_loader = DataLoader(
diff --git a/module_base/scheduler.py b/module_base/scheduler.py
index 9aa167c..f8c0e11 100644
--- a/module_base/scheduler.py
+++ b/module_base/scheduler.py
@@ -4,10 +4,14 @@ class SchedulerSelector:
     def __init__(self, sched, optimizer, epoch):
         self.optimizer = optimizer
         self.epoch = epoch
-        if sched == 'step':
+        if sched == 'step': # step size마다 gamma 비율로 lr을 감소
             self.scheduler = lr_scheduler.StepLR(self.optimizer, step=5, gamma=0.6)
-        elif sched == 'cosine':
+        elif sched == 'cosine': # learing rate가 cos함수를 따라서 감소 및 증가
             self.scheduler = lr_scheduler.CosineAnnealingLR(self.optimizer, T_max=self.epoch, eta_min=1e-6)
+        elif sched == 'exp': # learing rate decay가 exponential함수를 따름
+            self.scheduler = lr_scheduler.ExponentialLR(optimizer, gamma=0.6)
+        elif sched == 'plateau': # 성능이 향상이 없을 때 learning rate를 감소
+            self.scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, 'min')
             
     def get_sched(self):
         return self.scheduler
\ No newline at end of file
diff --git a/module_base/train.py b/module_base/train.py
index d567e97..3bbbe15 100644
--- a/module_base/train.py
+++ b/module_base/train.py
@@ -146,6 +146,7 @@ def train(model, train_loader, val_loader, criterion, optimizer, save_dir, rando
                     f'Step [{step+1}/{len(train_loader)}], '
                     f'Loss: {round(loss.item(),4)}'
                 )
+        # scheduler.step()
         # validation 주기에 따라 loss를 출력하고 best model을 저장합니다.
         if (epoch + 1) % val_every == 0:
             dice = validation(epoch + 1, model, val_loader, criterion, model_type)
diff --git a/module_base/transform.py b/module_base/transform.py
index 37952bc..5737047 100644
--- a/module_base/transform.py
+++ b/module_base/transform.py
@@ -8,6 +8,7 @@ def __init__(self, is_train, resize):
             self.transform = A.Compose(
                 [
                     A.HorizontalFlip(0.2),
+                    # A.Rotate(limit=(-15, 15), p=0.5)
                     # A.CLAHE(clip_limit=4.0, tile_grid_size=(8, 8), always_apply=False, p=1.0)
                 ]+ common_transform)
         else:
diff --git a/module_base/wandb_train.py b/module_base/wandb_train.py
index 0ec1cdc..612bd0d 100644
--- a/module_base/wandb_train.py
+++ b/module_base/wandb_train.py
@@ -152,14 +152,14 @@ def train(model, train_loader, val_loader, criterion, optimizer, scheduler, cfg)
             scaler.update()
             
             # step 주기에 따라 loss를 출력합니다.
-            if (step + 1) % 25 == 0:
+            if (step + 1) % 80 == 0:
                 print(
                     f'{datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")} | '
                     f'Epoch [{epoch+1}/{cfg.max_epoch}], '
                     f'Step [{step+1}/{len(train_loader)}], '
                     f'Loss: {round(loss.item(),4)}'
                 )
-        scheduler.step()
+        # scheduler.step()
         epoch_time = datetime.timedelta(seconds=time.time() - epoch_start)
         dataset_size = len(train_loader.dataset)
         epoch_loss = epoch_loss / dataset_size

From 36732449579c1fc08292acc2c7323050e58c525e Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Fri, 22 Nov 2024 11:04:26 +0900
Subject: [PATCH 058/106] [Refactor] : edit

---
 sam2_unet/config.yaml      | 34 ++++++++++++++---------
 sam2_unet/utils/dataset.py | 55 --------------------------------------
 2 files changed, 22 insertions(+), 67 deletions(-)

diff --git a/sam2_unet/config.yaml b/sam2_unet/config.yaml
index d29434c..e227520 100644
--- a/sam2_unet/config.yaml
+++ b/sam2_unet/config.yaml
@@ -5,19 +5,19 @@ test_image_path: /data/ephemeral/home/data/test/DCM
 hiera_path: /data/ephemeral/home/sam2_hiera_large.pt
 
 # train
-train_batch_size: 8
-train_num_workers: 8
+train_batch_size: 4
+train_num_workers: 4
 
 # valid
 valid_batch_size: 2
 valid_num_workers: 2
 kfold: 5
-k: 0
+k: -1
 threshold: 0.5
 
 # hyperparameter
-lr: 1e-3
-max_epoch: 30
+lr: 0.001
+max_epoch: 100
 
 # optimizer
 optimizer: adamw
@@ -26,22 +26,32 @@ optimizer_parameters:
   betas: [0.9, 0.999]
 
 # scheduler
-scheduler: multisteplr
+scheduler: cosineannealinglr
 scheduler_parameters:
-  milestones: [8, 16]
-  gamma: 0.1
+  # step: 40
+  # gamma: 0.1
+
+  # milestones: [10, 20]
+  # gamma: 0.1
+  
+  T_max: 100
+  eta_min: 0.00005
+  
+  # factor: 0.1
+  # patience: 10
+
 
 # random seed 
 random_seed: 2024
 
 # save
-save_every: 5
+save_every: 10
 
-# resize
-image_size: 512
+# augmentation
+image_size: 1024
 
 # wandb
-wandb_name: 
+wandb_name: sam2unet_1024_100_hflip_colorjitter
 wandb_id: 
 
 # resume
diff --git a/sam2_unet/utils/dataset.py b/sam2_unet/utils/dataset.py
index 88c2fa1..2f557ff 100644
--- a/sam2_unet/utils/dataset.py
+++ b/sam2_unet/utils/dataset.py
@@ -1,12 +1,9 @@
-import torchvision.transforms.functional as F
 import numpy as np
-import random
 import os
 import cv2
 import json
 import torch
 from PIL import Image
-from torchvision.transforms import InterpolationMode
 from torch.utils.data import Dataset
 from sklearn.model_selection import GroupKFold
 
@@ -20,58 +17,6 @@
 ]
 CLASS2IND = {v: i for i, v in enumerate(CLASSES)}
 
-class ToTensor(object):
-
-    def __call__(self, data):
-        image, label = data['image'], data['label']
-        return {'image': F.to_tensor(image), 'label': F.to_tensor(label)}
-
-class Resize(object):
-
-    def __init__(self, size):
-        self.size = size
-
-    def __call__(self, data):
-        image, label = data['image'], data['label']
-
-        return {'image': F.resize(image, self.size), 'label': F.resize(label, self.size, interpolation=InterpolationMode.BICUBIC)}
-
-
-class RandomHorizontalFlip(object):
-    def __init__(self, p=0.5):
-        self.p = p
-
-    def __call__(self, data):
-        image, label = data['image'], data['label']
-
-        if random.random() < self.p:
-            return {'image': F.hflip(image), 'label': F.hflip(label)}
-
-        return {'image': image, 'label': label}
-
-class RandomVerticalFlip(object):
-    def __init__(self, p=0.5):
-        self.p = p
-
-    def __call__(self, data):
-        image, label = data['image'], data['label']
-
-        if random.random() < self.p:
-            return {'image': F.vflip(image), 'label': F.vflip(label)}
-
-        return {'image': image, 'label': label}
-
-class Normalize(object):
-    def __init__(self, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]):
-        self.mean = mean
-        self.std = std
-
-    def __call__(self, sample):
-        image, label = sample['image'], sample['label']
-        image = F.normalize(image, self.mean, self.std)
-        return {'image': image, 'label': label}
-    
-
 class FullDataset(Dataset):
     def __init__(self, image_root, gt_root, is_train=True, transforms=None, kfold=5, k=0):
         pngs = {

From a7be6a1c9be3f00bd8d3e396ace7fee70c811553 Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Fri, 22 Nov 2024 14:55:08 +0900
Subject: [PATCH 059/106] [#21] Feature : save parameter

---
 module_base/config.yaml    |  6 +++---
 module_base/inference.py   |  4 ++--
 module_base/train.py       | 26 ++++++++++++++------------
 module_base/transform.py   |  2 +-
 module_base/wandb_train.py |  3 +--
 5 files changed, 21 insertions(+), 20 deletions(-)

diff --git a/module_base/config.yaml b/module_base/config.yaml
index 49dbe5c..2930bd8 100644
--- a/module_base/config.yaml
+++ b/module_base/config.yaml
@@ -6,7 +6,7 @@ save_dir: /data/ephemeral/home/data/result
 # 모델 라이브러리 및 사용 모델 정의
 model_type: smp
 model_name: UnetPlusPlus
-encoder_name: tu-hrnet_w64
+encoder_name: densenet201
 encoder_weights: imagenet
 pretrained: True
 
@@ -19,7 +19,7 @@ lr: 2e-4
 weight_decay: 1e-6
 train_num_workers: 8
 valid_num_workers: 0
-max_epoch: 50
+max_epoch: 60
 
 # loss
 loss:
@@ -44,5 +44,5 @@ random_seed: 2024
 size: 1024
 
 # wandb
-wandb_run_name: DiceBCELoss_exp
+wandb_run_name: smp_unet++_densenet161_DiceBCELoss_cosine_flip+rotate
 wandb_run_id: None
\ No newline at end of file
diff --git a/module_base/inference.py b/module_base/inference.py
index 15cadc9..dc2624c 100644
--- a/module_base/inference.py
+++ b/module_base/inference.py
@@ -101,7 +101,7 @@ def do_inference(image_root, save_dir, random_seed, model_type):
         for fname in files
         if os.path.splitext(fname)[1].lower() == ".png"
     }
-    model = torch.load(os.path.join(save_dir, "cosine.pt"))
+    model = torch.load(os.path.join(save_dir, "smp_unet++_hrnetW64_best.pt"))
     
     test_trans = TransformSelector('albumentation')
     test_tf = test_trans.get_transform(False, 1024)
@@ -127,7 +127,7 @@ def do_inference(image_root, save_dir, random_seed, model_type):
         "rle": rles,
     })
     
-    df.to_csv("output.csv", index=False)
+    df.to_csv("smp_unet++_hrnetW64_best.csv", index=False)
 
 def main(args):
     do_inference(**args.__dict__)
diff --git a/module_base/train.py b/module_base/train.py
index 3bbbe15..bb9eff9 100644
--- a/module_base/train.py
+++ b/module_base/train.py
@@ -111,14 +111,14 @@ def validation(epoch, model, val_loader, criterion, model_type, thr=0.5):
     
     return avg_dice
 
-def train(model, train_loader, val_loader, criterion, optimizer, save_dir, random_seed, max_epoch, val_every, model_type):
+def train(model, train_loader, val_loader, criterion, optimizer, scheduler, cfg):
     print(f'Start training..')
     best_dice = 0.
 
     scaler = torch.cuda.amp.GradScaler()
     model = model.cuda()
     
-    for epoch in range(max_epoch):
+    for epoch in range(cfg.max_epoch):
         torch.cuda.empty_cache() # 학습 시작 전 캐시 삭제
         model.train()
         for step, (images, masks) in enumerate(train_loader):
@@ -127,9 +127,9 @@ def train(model, train_loader, val_loader, criterion, optimizer, save_dir, rando
             
             # Mixed Precision Training으로 loss 계산에서만 FP32 사용
             with torch.cuda.amp.autocast():
-                if model_type == 'torchvision':
+                if cfg.model_type == 'torchvision':
                     outputs = model(images)['out']
-                elif model_type == 'smp':
+                elif cfg.model_type == 'smp':
                     outputs = model(images)
                 loss = criterion(outputs, masks)
             # 스케일된 loss를 사용해 backward 및 optimizer step
@@ -142,20 +142,20 @@ def train(model, train_loader, val_loader, criterion, optimizer, save_dir, rando
             if (step + 1) % 80 == 0:
                 print(
                     f'{datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")} | '
-                    f'Epoch [{epoch+1}/{max_epoch}], '
+                    f'Epoch [{epoch+1}/{cfg.max_epoch}], '
                     f'Step [{step+1}/{len(train_loader)}], '
                     f'Loss: {round(loss.item(),4)}'
                 )
-        # scheduler.step()
+        scheduler.step()
         # validation 주기에 따라 loss를 출력하고 best model을 저장합니다.
-        if (epoch + 1) % val_every == 0:
-            dice = validation(epoch + 1, model, val_loader, criterion, model_type)
+        if (epoch + 1) % cfg.val_every == 0:
+            dice = validation(epoch + 1, model, val_loader, criterion, cfg.model_type)
             
             if best_dice < dice:
                 print(f"Best performance at epoch: {epoch + 1}, {best_dice:.4f} -> {dice:.4f}")
-                print(f"Save model in {save_dir}")
+                print(f"Save model in {cfg.save_dir}")
                 best_dice = dice
-                save_model(model, save_dir)
+                save_model(model, cfg.save_dir)
 
 def main(cfg):
     set_seed(cfg.random_seed)
@@ -207,8 +207,10 @@ def main(cfg):
 
     optimizer = optim.Adam(params=model.parameters(), lr=cfg.lr, weight_decay=cfg.weight_decay)
     
-    train(model, train_loader, valid_loader, criterion, optimizer,
-        cfg.save_dir, cfg.random_seed, cfg.max_epoch, cfg.val_every, cfg.model_type)
+    train(model, train_loader, valid_loader, criterion, optimizer, scheduler, cfg)
+    
+    sched = SchedulerSelector(cfg.scheduler, optimizer, cfg.max_epoch)
+    scheduler = sched.get_sched()
 
 if __name__ == '__main__':
     parser = ArgumentParser()
diff --git a/module_base/transform.py b/module_base/transform.py
index 5737047..c97f19d 100644
--- a/module_base/transform.py
+++ b/module_base/transform.py
@@ -8,7 +8,7 @@ def __init__(self, is_train, resize):
             self.transform = A.Compose(
                 [
                     A.HorizontalFlip(0.2),
-                    # A.Rotate(limit=(-15, 15), p=0.5)
+                    A.Rotate(limit=(-15, 15), p=0.5)
                     # A.CLAHE(clip_limit=4.0, tile_grid_size=(8, 8), always_apply=False, p=1.0)
                 ]+ common_transform)
         else:
diff --git a/module_base/wandb_train.py b/module_base/wandb_train.py
index 612bd0d..745d51f 100644
--- a/module_base/wandb_train.py
+++ b/module_base/wandb_train.py
@@ -159,7 +159,7 @@ def train(model, train_loader, val_loader, criterion, optimizer, scheduler, cfg)
                     f'Step [{step+1}/{len(train_loader)}], '
                     f'Loss: {round(loss.item(),4)}'
                 )
-        # scheduler.step()
+        scheduler.step()
         epoch_time = datetime.timedelta(seconds=time.time() - epoch_start)
         dataset_size = len(train_loader.dataset)
         epoch_loss = epoch_loss / dataset_size
@@ -225,7 +225,6 @@ def main(cfg):
     )
     model = model_selector.get_model()
     
-    # criterion = nn.BCEWithLogitsLoss()
     if cfg.loss.params:
         loss = LossSelector(cfg.loss.name, **cfg.loss.params)
     else:

From e94ccf305e386e450f7d92ade00f0eb374da9d6b Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Fri, 22 Nov 2024 15:41:39 +0900
Subject: [PATCH 060/106] [Feature] : edit outlier

---
 augmentation/copy_data.py |   6 +++
 augmentation/outlier.py   | 109 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 115 insertions(+)
 create mode 100644 augmentation/copy_data.py
 create mode 100644 augmentation/outlier.py

diff --git a/augmentation/copy_data.py b/augmentation/copy_data.py
new file mode 100644
index 0000000..c62c35f
--- /dev/null
+++ b/augmentation/copy_data.py
@@ -0,0 +1,6 @@
+import shutil
+
+src = '/data/ephemeral/home/data'
+dst = '/data/ephemeral/home/data_v1'
+
+shutil.copytree(src, dst)
\ No newline at end of file
diff --git a/augmentation/outlier.py b/augmentation/outlier.py
new file mode 100644
index 0000000..b8e045b
--- /dev/null
+++ b/augmentation/outlier.py
@@ -0,0 +1,109 @@
+import os
+import json
+import shutil
+
+"""
+ID363 오른손 약지 반지 삭제
+ID487 왼손목 물체 삭제
+ID058 이미지 annotation 수정
+ID089 이미지 annotation 수정 or 삭제
+"""
+
+def delete_folder(folder_path):
+    if os.path.exists(folder_path):
+        shutil.rmtree(folder_path)
+        print(f"Delete '{folder_path}'")
+    else:
+        print(f"No Exist '{folder_path}'")
+
+def change_label_ID058():
+    """
+    finger1 <-> finger3
+    Trapezium <-> Hamate
+    Trapezoid <-> Capitate
+    Pisiform -> Scaphoid
+    Scaphoid -> Triquetrum
+    Triquetrum -> Lundate
+    Lundate -> Pisiform
+    Radius <-> Ulna
+    """
+    file_path = "/data/ephemeral/home/data_v1/train/outputs_json/ID058/image1661392103627.json"
+
+    with open(file_path, 'r') as file:
+        data = json.load(file)
+    
+    for annotation in data.get('annotations', []):
+        if annotation['label'] == 'finger1':
+            annotation['label'] = 'finger3_'
+        if annotation['label'] == 'finger3':
+            annotation['label'] = 'finger1_'
+        if annotation['label'] == 'Trapezium':
+            annotation['label'] = 'Hamate_'
+        if annotation['label'] == 'Hamate':
+            annotation['label'] = 'Trapezium_'
+        if annotation['label'] == 'Trapezoid':
+            annotation['label'] = 'Capitate_'
+        if annotation['label'] == 'Capitate':
+            annotation['label'] = 'Trapezoid_'
+        if annotation['label'] == 'Pisiform':
+            annotation['label'] = 'Scaphoid_'
+        if annotation['label'] == 'Scaphoid':
+            annotation['label'] = 'Triquetrum_'
+        if annotation['label'] == 'Triquetrum':
+            annotation['label'] = 'Lunate_'
+        if annotation['label'] == 'Lunate':
+            annotation['label'] = 'Pisiform_'
+        if annotation['label'] == 'Radius':
+            annotation['label'] = 'Ulna_'
+        if annotation['label'] == 'Ulna':
+            annotation['label'] = 'Radius_'
+    
+    for annotation in data.get('annotations', []):
+        if annotation['label'][-1] == '_':
+            annotation['label'] = annotation['label'][:-1]
+
+    with open(file_path, 'w') as file:
+        json.dump(data, file, indent=4)
+
+    print(f"Edit '{file_path}'")
+
+def change_label_ID089():
+    """
+    Trapezium <-> Trapezoid
+    """
+    file_path = "/data/ephemeral/home/data_v1/train/outputs_json/ID089/image1661821711879.json"
+    with open(file_path, 'r') as file:
+        data = json.load(file)
+    
+    for annotation in data.get('annotations', []):
+        if annotation['label'] == 'Trapezium':
+            annotation['label'] = 'Trapezoid_'
+        if annotation['label'] == 'Trapezoid':
+            annotation['label'] = 'Trapezium_'
+    
+    for annotation in data.get('annotations', []):
+        if annotation['label'][-1] == '_':
+            annotation['label'] = annotation['label'][:-1]
+
+    with open(file_path, 'w') as file:
+        json.dump(data, file, indent=4)
+
+    print(f"Edit '{file_path}'")
+
+if __name__ == "__main__":
+    # ID363 오른손 약지 반지 삭제
+    delete_folder("/data/ephemeral/home/data_v1/train/DCM/ID363")
+    delete_folder("/data/ephemeral/home/data_v1/train/outputs_json/ID363")
+
+    # ID487 왼손목 물체 삭제
+    delete_folder("/data/ephemeral/home/data_v1/train/DCM/ID487")
+    delete_folder("/data/ephemeral/home/data_v1/train/outputs_json/ID487")
+
+    # ID058 이미지 annotation 수정
+    change_label_ID058()
+
+    # ID089 이미지 annotation 수정 or 삭제 or 그대로두기
+    # change_label_ID089()
+    # delete_folder("/data/ephemeral/home/data_v1/train/DCM/ID089")
+    # delete_folder("/data/ephemeral/home/data_v1/train/outputs_json/ID089")
+    
\ No newline at end of file

From ffdebc3319db927532bb009b8f75697649ea53ee Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Fri, 22 Nov 2024 15:41:59 +0900
Subject: [PATCH 061/106] [Feature] : offline augmentation horizantal flip

---
 augmentation/hflip.py | 69 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 augmentation/hflip.py

diff --git a/augmentation/hflip.py b/augmentation/hflip.py
new file mode 100644
index 0000000..9b978c2
--- /dev/null
+++ b/augmentation/hflip.py
@@ -0,0 +1,69 @@
+import os
+import cv2
+import json
+
+CLASSES = [
+    'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
+    'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
+    'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
+    'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
+    'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
+    'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
+]
+CLASS2IND = {v: i for i, v in enumerate(CLASSES)}
+
+def flip_annotation(label_path, image_size):
+    with open(label_path, 'r') as f:
+        data = json.load(f)
+    
+    for ann in data['annotations']:
+        if ann['type'] == 'poly_seg':
+            flipped_points = []
+            for point in ann['points']:
+                x, y = point
+                flipped_x = image_size - x - 1
+                flipped_points.append([flipped_x, y])
+            
+            ann['points'] = flipped_points
+    
+    return data
+
+def save_annotation(data, output_file_path):
+    with open(output_file_path, 'w') as f:
+        json.dump(data, f, indent=4)
+
+def create_offline_horizantal_flip(image_root, label_root):
+    images = {
+        os.path.relpath(os.path.join(root, fname), start=image_root)
+        for root, _dirs, files in os.walk(image_root)
+        for fname in files
+        if os.path.splitext(fname)[1].lower() == ".png"
+    }
+    labels = {
+        os.path.relpath(os.path.join(root, fname), start=label_root)
+        for root, _dirs, files in os.walk(label_root)
+        for fname in files
+        if os.path.splitext(fname)[1].lower() == ".json"
+    }
+    
+    images = sorted(images)
+    labels = sorted(labels)
+
+    for image_name, label_name in zip(images, labels):
+        image_path = os.path.join(image_root, image_name)
+        image = cv2.imread(image_path)
+        flipped_image = cv2.flip(image, 1)
+        flipped_image_path = os.path.join(image_root, ''.join(image_name.split('.')[:-1]) + '_flip.png')
+        cv2.imwrite(flipped_image_path, flipped_image)
+        print(f"save '{flipped_image_path}'")
+
+        label_path = os.path.join(label_root, label_name)
+        flipped_label = flip_annotation(label_path, image.shape[1])
+        flipped_label_path = os.path.join(label_root, ''.join(label_name.split('.')[:-1]) + '_flip.json')
+        save_annotation(flipped_label, flipped_label_path)
+        print(f"save '{flipped_label_path}'")
+        
+if __name__ == "__main__":
+    image_root = "/data/ephemeral/home/data_v1/train/DCM"
+    label_root = "/data/ephemeral/home/data_v1/train/outputs_json"
+    create_offline_horizantal_flip(image_root, label_root)
\ No newline at end of file

From d5b6f9fae71a84247e4db8ca668f91d954d980f1 Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Fri, 22 Nov 2024 16:45:51 +0900
Subject: [PATCH 062/106] [Fix] : edit steplr parameter

---
 sam2_unet/config.yaml        | 28 ++++++++++++++--------------
 sam2_unet/utils/transform.py |  4 ++--
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/sam2_unet/config.yaml b/sam2_unet/config.yaml
index e227520..cee9c40 100644
--- a/sam2_unet/config.yaml
+++ b/sam2_unet/config.yaml
@@ -1,23 +1,23 @@
 # paths
-train_image_path: /data/ephemeral/home/data/train/DCM
-train_mask_path: /data/ephemeral/home/data/train/outputs_json
+train_image_path: /data/ephemeral/home/data_v1/train/DCM
+train_mask_path: /data/ephemeral/home/data_v1/train/outputs_json
 test_image_path: /data/ephemeral/home/data/test/DCM
 hiera_path: /data/ephemeral/home/sam2_hiera_large.pt
 
 # train
-train_batch_size: 4
-train_num_workers: 4
+train_batch_size: 8
+train_num_workers: 8
 
 # valid
 valid_batch_size: 2
 valid_num_workers: 2
 kfold: 5
-k: -1
+k: 0
 threshold: 0.5
 
 # hyperparameter
 lr: 0.001
-max_epoch: 100
+max_epoch: 30
 
 # optimizer
 optimizer: adamw
@@ -26,16 +26,16 @@ optimizer_parameters:
   betas: [0.9, 0.999]
 
 # scheduler
-scheduler: cosineannealinglr
+scheduler: steplr
 scheduler_parameters:
-  # step: 40
-  # gamma: 0.1
+  step_size: 40
+  gamma: 0.1
 
   # milestones: [10, 20]
   # gamma: 0.1
   
-  T_max: 100
-  eta_min: 0.00005
+  # T_max: 100
+  # eta_min: 5e-5
   
   # factor: 0.1
   # patience: 10
@@ -45,13 +45,13 @@ scheduler_parameters:
 random_seed: 2024
 
 # save
-save_every: 10
+save_every: 5
 
 # augmentation
-image_size: 1024
+image_size: 512
 
 # wandb
-wandb_name: sam2unet_1024_100_hflip_colorjitter
+wandb_name: 
 wandb_id: 
 
 # resume
diff --git a/sam2_unet/utils/transform.py b/sam2_unet/utils/transform.py
index af03e70..6aa4218 100644
--- a/sam2_unet/utils/transform.py
+++ b/sam2_unet/utils/transform.py
@@ -22,8 +22,8 @@ def get_transform(self, is_train=True):
         if is_train:
             transform = A.Compose(
                 [
-                    A.HorizontalFlip(),
-                    A.ColorJitter()
+                    # A.HorizontalFlip(),
+                    # A.ColorJitter()
                 ]+ self.common_transform)
         else:
             transform = A.Compose(self.common_transform)

From 54eb5a3b9d880c8c2b5d615d2f68f317f675d491 Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Sun, 24 Nov 2024 09:37:52 +0900
Subject: [PATCH 063/106] [Feature]: add TTA and fix auigmentation error

---
 mmsegmentation/baseline.py                    |  13 ++-
 .../_baseline_/config_for_this_example.py     |  18 ++-
 .../_custom_/_base_/default_runtime.py        |   2 +-
 .../configs/_custom_/_base_/xraydata2.py      |  15 +--
 .../configs/_custom_/pidnet/pidnet_l.py       | 106 ++++++++++++++++++
 .../mmseg/datasets/transforms/transforms.py   |  11 +-
 mmsegmentation/mmseg/datasets/xray2.py        |   1 +
 .../mmseg/models/segmentors/__init__.py       |   5 +-
 .../mmseg/models/segmentors/custom.py         |   2 +-
 .../mmseg/models/segmentors/seg_tta.py        |  34 ++++++
 10 files changed, 186 insertions(+), 21 deletions(-)
 create mode 100644 mmsegmentation/configs/_custom_/pidnet/pidnet_l.py

diff --git a/mmsegmentation/baseline.py b/mmsegmentation/baseline.py
index 46be871..21d01fe 100644
--- a/mmsegmentation/baseline.py
+++ b/mmsegmentation/baseline.py
@@ -6,9 +6,10 @@
 # 데이터 경로를 입력하세요
 
 CONFIG_PATH = "/data/ephemeral/home/parkjunil/level2-cv-semanticsegmentation-cv-19-lv3/mmsegmentation/configs/_baseline_/config_for_this_example.py"
-CHECKPOINT_PATH = "/data/ephemeral/home/parkjunil/work_dir/baseline_1024/best_mDice_iter_20000.pth"
+CHECKPOINT_PATH = "/data/ephemeral/home/parkjunil/work_dir/baseline_dice_1480_hflip/best_mDice_iter_16000.pth"
 SUBMISSION_PATH = "/data/ephemeral/home/submission"
-WORK_DIR = "/data/ephemeral/home/parkjunil/work_dir/baseline_1536_flip"
+WORK_DIR = "/data/ephemeral/home/parkjunil/work_dir/baseline_dice_1480_hflip"
+TTA = True
 
 
 def load_config():
@@ -34,9 +35,15 @@ def train():
 def inference():
     cfg = load_config()
     cfg.load_from = CHECKPOINT_PATH
+    if TTA:
+        cfg.test_dataloader.dataset.pipeline = cfg.tta_pipeline
+        cfg.tta_model.module = cfg.model
+        cfg.model = cfg.tta_model
+    
+    
     runner = Runner.from_cfg(cfg)
     runner.test()
 
 
 if __name__ == "__main__":
-    train()
\ No newline at end of file
+    inference()
\ No newline at end of file
diff --git a/mmsegmentation/configs/_baseline_/config_for_this_example.py b/mmsegmentation/configs/_baseline_/config_for_this_example.py
index fba8d54..8e0c264 100644
--- a/mmsegmentation/configs/_baseline_/config_for_this_example.py
+++ b/mmsegmentation/configs/_baseline_/config_for_this_example.py
@@ -29,11 +29,19 @@
         type='SegformerHeadWithoutAccuracy',
         in_channels=[64, 128, 320, 512],
         num_classes=29,
-        loss_decode=dict(
-            type='CrossEntropyLoss',
-            use_sigmoid=True,
-            loss_weight=1.0,
-        ),
+        threshold=0.5,
+        loss_decode=[
+            dict(
+                type='CrossEntropyLoss',
+                use_sigmoid=True,
+                loss_weight=1.0
+            ),
+            dict(
+                type='DiceLoss',
+                use_sigmoid=True,
+                loss_weight=1.0
+            )
+        ]
     ),
 )
 
diff --git a/mmsegmentation/configs/_custom_/_base_/default_runtime.py b/mmsegmentation/configs/_custom_/_base_/default_runtime.py
index 106207f..207046d 100644
--- a/mmsegmentation/configs/_custom_/_base_/default_runtime.py
+++ b/mmsegmentation/configs/_custom_/_base_/default_runtime.py
@@ -32,5 +32,5 @@
             num_eval_images=10)
     ])
 
-tta_model = dict(type='SegTTAModel')
+tta_model = dict(type='SegTTAModelWithoutArgMax')
 randomness=dict(seed=42)
\ No newline at end of file
diff --git a/mmsegmentation/configs/_custom_/_base_/xraydata2.py b/mmsegmentation/configs/_custom_/_base_/xraydata2.py
index bc3907f..d55802b 100644
--- a/mmsegmentation/configs/_custom_/_base_/xraydata2.py
+++ b/mmsegmentation/configs/_custom_/_base_/xraydata2.py
@@ -1,4 +1,4 @@
-IMAGE_SIZE = (1536, 1536)
+IMAGE_SIZE = (1480, 1480)
 IMAGE_ROOT = '/data/ephemeral/home/data/train/DCM'
 LABEL_ROOT = '/data/ephemeral/home/data/train/outputs_json'
 SUBMISSION_PATH = '/data/ephemeral/home/submission'
@@ -11,7 +11,7 @@
             dict(type='LoadImageFromFile'),
             dict(type='LoadXRayAnnotations'),
             dict(type='Resize', scale=IMAGE_SIZE),
-            # dict(type='RandomRotFlip', rotate_prob=0.2, flip_prob=0.4),
+            dict(type='RandomFlip', prob=0.5, direction='horizontal'),
             dict(type='TransposeAnnotations'),
             dict(type='PackSegInputs')
         ]
@@ -56,7 +56,7 @@
 
 
 test_dataloader = dict(
-    batch_size=8,
+    batch_size=4,
     num_workers=4,
     persistent_workers=True,
     sampler=dict(type='DefaultSampler', shuffle=False),
@@ -79,10 +79,11 @@
     dict(
         type='TestTimeAug',
         transforms=[
-            [
-                dict(type='Resize', scale_factor=r, keep_ratio=True)
-                for r in img_ratios
-            ],
+            # [
+            #     dict(type='Resize', scale_factor=r, keep_ratio=True)
+            #     for r in img_ratios
+            # ],
+            [dict(type='Resize', scale=IMAGE_SIZE)],
             [
                 dict(type='RandomFlip', prob=0., direction='horizontal'),
                 dict(type='RandomFlip', prob=1., direction='horizontal')
diff --git a/mmsegmentation/configs/_custom_/pidnet/pidnet_l.py b/mmsegmentation/configs/_custom_/pidnet/pidnet_l.py
new file mode 100644
index 0000000..f851fa2
--- /dev/null
+++ b/mmsegmentation/configs/_custom_/pidnet/pidnet_l.py
@@ -0,0 +1,106 @@
+_base_ = [
+    '../_base_/xraydata2.py',
+    '../_base_/default_runtime.py', '../_base_/schedule_160k.py'
+]
+
+crop_size = (1024, 1024)
+num_classes = 29
+load_from = "https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-l_2xb6-120k_1024x1024-cityscapes/pidnet-l_2xb6-120k_1024x1024-cityscapes_20230303_114514-0783ca6b.pth"
+checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/pidnet/pidnet-l_imagenet1k_20230306-67889109.pth'  # noqa
+class_weight = [
+    0.81, 0.80, 0.80, 0.80, 0.80, 
+    0.80, 0.80, 0.80, 0.80, 0.80, 
+    0.80, 0.80, 0.80, 0.80, 0.80, 
+    0.81, 0.81, 0.80, 0.80, 0.82, 
+    0.88, 0.81, 0.82, 0.81, 0.82, 
+    0.82, 0.92, 0.80, 0.80
+]
+
+
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255,
+    size=crop_size)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='PIDNet',
+        in_channels=3,
+        channels=64,
+        ppm_channels=112,
+        num_stem_blocks=3,
+        num_branch_blocks=4,
+        align_corners=False,
+        norm_cfg=norm_cfg,
+        act_cfg=dict(type='ReLU', inplace=True),
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file)),
+    decode_head=dict(
+        type='PIDHead',
+        in_channels=256,
+        channels=256,
+        num_classes=num_classes,
+        norm_cfg=norm_cfg,
+        act_cfg=dict(type='ReLU', inplace=True),
+        align_corners=True,
+        loss_decode=[
+            dict(
+                type='CrossEntropyLoss',
+                use_sigmoid=False,
+                class_weight=class_weight,
+                loss_weight=0.4),
+            dict(
+                type='OhemCrossEntropy',
+                thres=0.9,
+                min_kept=131072,
+                class_weight=class_weight,
+                loss_weight=1.0),
+            dict(type='BoundaryLoss', loss_weight=20.0),
+            dict(
+                type='OhemCrossEntropy',
+                thres=0.9,
+                min_kept=131072,
+                class_weight=class_weight,
+                loss_weight=1.0)
+        ]),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+
+
+IMAGE_SIZE = (1480, 1480)
+train_pipeline = [
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadXRayAnnotations'),
+            dict(type='Resize', scale=IMAGE_SIZE),
+            dict(type='RandomFlip', prob=0.5, direction='horizontal'),
+            dict(type='TransposeAnnotations'),
+            dict(type='GenerateEdge', edge_width=4),
+            dict(type='PackSegInputs')
+        ]
+train_dataloader = dict(batch_size=1, dataset=dict(pipeline=train_pipeline))
+
+
+iters = 30000
+# optimizer
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=0,
+        power=0.9,
+        begin=0,
+        end=iters,
+        by_epoch=False)
+]
+# training schedule for 120k
+train_cfg = dict(
+    type='IterBasedTrainLoop', max_iters=iters, val_interval=iters // 10)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
\ No newline at end of file
diff --git a/mmsegmentation/mmseg/datasets/transforms/transforms.py b/mmsegmentation/mmseg/datasets/transforms/transforms.py
index 64e2323..e4dc928 100644
--- a/mmsegmentation/mmseg/datasets/transforms/transforms.py
+++ b/mmsegmentation/mmseg/datasets/transforms/transforms.py
@@ -2359,7 +2359,7 @@ def __init__(self,
         self.bgr_to_rgb = bgr_to_rgb
 
         self.aug = Compose([self.albu_builder(t) for t in self.transforms],
-                           additional_targets=self.additional_targets)
+                           additional_targets=self.additional_targets, is_check_shapes=False)
 
         if not keymap:
             self.keymap_to_albu = {'img': 'image', 'gt_seg_map': 'mask'}
@@ -2435,7 +2435,14 @@ def transform(self, results):
                                                     cv2.COLOR_BGR2RGB)
 
         # Apply Transform
-        results = self.aug(**results)
+        target_keys = ['image', 'mask']
+        filtered_dict = {key: results[key] for key in target_keys if key in results}
+        filtered_dict = self.aug(**filtered_dict)
+        
+        for k in target_keys:
+            results[k] = filtered_dict[k]
+        del filtered_dict
+        
 
         # Convert back to BGR
         if self.bgr_to_rgb:
diff --git a/mmsegmentation/mmseg/datasets/xray2.py b/mmsegmentation/mmseg/datasets/xray2.py
index d151008..f25c357 100644
--- a/mmsegmentation/mmseg/datasets/xray2.py
+++ b/mmsegmentation/mmseg/datasets/xray2.py
@@ -129,6 +129,7 @@ def transform(self, result):
             label[..., class_ind] = class_label
 
         result["gt_seg_map"] = label
+        result['seg_fields'] = ['gt_seg_map']
 
         return result
     
diff --git a/mmsegmentation/mmseg/models/segmentors/__init__.py b/mmsegmentation/mmseg/models/segmentors/__init__.py
index 80bced1..5353e0a 100644
--- a/mmsegmentation/mmseg/models/segmentors/__init__.py
+++ b/mmsegmentation/mmseg/models/segmentors/__init__.py
@@ -4,10 +4,11 @@
 from .depth_estimator import DepthEstimator
 from .encoder_decoder import EncoderDecoder
 from .multimodal_encoder_decoder import MultimodalEncoderDecoder
-from .seg_tta import SegTTAModel
+from .seg_tta import SegTTAModel, SegTTAModelWithoutArgMax
 from .custom import EncoderDecoderWithoutArgmax
 
 __all__ = [
     'BaseSegmentor', 'EncoderDecoder', 'CascadeEncoderDecoder', 'SegTTAModel',
-    'MultimodalEncoderDecoder', 'DepthEstimator', 'EncoderDecoderWithoutArgmax'
+    'MultimodalEncoderDecoder', 'DepthEstimator', 'EncoderDecoderWithoutArgmax',
+    'SegTTAModelWithoutArgMax'
 ]
diff --git a/mmsegmentation/mmseg/models/segmentors/custom.py b/mmsegmentation/mmseg/models/segmentors/custom.py
index fb4e9c6..2733cab 100644
--- a/mmsegmentation/mmseg/models/segmentors/custom.py
+++ b/mmsegmentation/mmseg/models/segmentors/custom.py
@@ -71,7 +71,7 @@ def postprocess_result(self,
 
             i_seg_logits = i_seg_logits.sigmoid()
             i_seg_pred = (i_seg_logits > 0.5).to(i_seg_logits)
-
+            
             data_samples[i].set_data({
                 'seg_logits':
                 PixelData(**{'data': i_seg_logits}),
diff --git a/mmsegmentation/mmseg/models/segmentors/seg_tta.py b/mmsegmentation/mmseg/models/segmentors/seg_tta.py
index 63ef61d..5cea8c3 100644
--- a/mmsegmentation/mmseg/models/segmentors/seg_tta.py
+++ b/mmsegmentation/mmseg/models/segmentors/seg_tta.py
@@ -45,3 +45,37 @@ def merge_preds(self, data_samples_list: List[SampleList]) -> SampleList:
             data_sample.set_metainfo({'img_path': data_samples[0].img_path})
             predictions.append(data_sample)
         return predictions
+
+
+
+@MODELS.register_module()
+class SegTTAModelWithoutArgMax(BaseTTAModel):
+
+    def merge_preds(self, data_samples_list: List[SampleList]) -> SampleList:
+        """Merge predictions of enhanced data to one prediction.
+
+        Args:
+            data_samples_list (List[SampleList]): List of predictions
+                of all enhanced data.
+
+        Returns:
+            SampleList: Merged prediction.
+        """
+        predictions = []
+        for data_samples in data_samples_list:
+            seg_logits = data_samples[0].seg_logits.data
+            logits = torch.zeros(seg_logits.shape).to(seg_logits)
+            for data_sample in data_samples:
+                seg_logit = data_sample.seg_logits.data
+                logits += seg_logit
+            logits /= len(data_samples)
+            
+            seg_pred = (logits > self.module.decode_head.threshold
+                        ).to(logits)
+            data_sample.set_data({'pred_sem_seg': PixelData(data=seg_pred)})
+            if hasattr(data_samples[0], 'gt_sem_seg'):
+                data_sample.set_data(
+                    {'gt_sem_seg': data_samples[0].gt_sem_seg})
+            data_sample.set_metainfo({'img_path': data_samples[0].img_path})
+            predictions.append(data_sample)
+        return predictions
\ No newline at end of file

From f81df659e2fb4b295d1c3b402c5889cea6fd9678 Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Sun, 24 Nov 2024 14:05:53 +0900
Subject: [PATCH 064/106] [#21, #42] Feature : add focal loss

---
 module_base/config.yaml  |  8 ++++----
 module_base/inference.py |  4 ++--
 module_base/loss.py      | 34 +++++++++++++++++++++++++++++-----
 3 files changed, 35 insertions(+), 11 deletions(-)

diff --git a/module_base/config.yaml b/module_base/config.yaml
index 2930bd8..1a25b31 100644
--- a/module_base/config.yaml
+++ b/module_base/config.yaml
@@ -6,12 +6,12 @@ save_dir: /data/ephemeral/home/data/result
 # 모델 라이브러리 및 사용 모델 정의
 model_type: smp
 model_name: UnetPlusPlus
-encoder_name: densenet201
+encoder_name: tu-hrnet_w64
 encoder_weights: imagenet
 pretrained: True
 
 # batch_size
-train_batch_size: 2
+train_batch_size: 4
 valid_batch_size: 4
 
 # hyperparameter
@@ -23,7 +23,7 @@ max_epoch: 60
 
 # loss
 loss:
-    name: DiceBCELoss
+    name: DiceFocalLoss
     params: null
 
 # optimizer
@@ -44,5 +44,5 @@ random_seed: 2024
 size: 1024
 
 # wandb
-wandb_run_name: smp_unet++_densenet161_DiceBCELoss_cosine_flip+rotate
+wandb_run_name: smp_unet++_efficientnetv2_xl_DiceBCELoss_cosine_flip+rotate
 wandb_run_id: None
\ No newline at end of file
diff --git a/module_base/inference.py b/module_base/inference.py
index dc2624c..9a0ceec 100644
--- a/module_base/inference.py
+++ b/module_base/inference.py
@@ -101,7 +101,7 @@ def do_inference(image_root, save_dir, random_seed, model_type):
         for fname in files
         if os.path.splitext(fname)[1].lower() == ".png"
     }
-    model = torch.load(os.path.join(save_dir, "smp_unet++_hrnetW64_best.pt"))
+    model = torch.load(os.path.join(save_dir, "best_model.pt"))
     
     test_trans = TransformSelector('albumentation')
     test_tf = test_trans.get_transform(False, 1024)
@@ -127,7 +127,7 @@ def do_inference(image_root, save_dir, random_seed, model_type):
         "rle": rles,
     })
     
-    df.to_csv("smp_unet++_hrnetW64_best.csv", index=False)
+    df.to_csv("best_hrnet2.csv", index=False)
 
 def main(args):
     do_inference(**args.__dict__)
diff --git a/module_base/loss.py b/module_base/loss.py
index 9716b46..4bb06dd 100644
--- a/module_base/loss.py
+++ b/module_base/loss.py
@@ -17,19 +17,29 @@ def __init__(self, eps=1e-6):
 
     def forward(self, preds, targets):
         preds = F.sigmoid(preds)
-
         preds_f = preds.flatten(2)
         targets_f = targets.flatten(2)
         intersection = torch.sum(preds_f * targets_f, -1)
 
         dice = (2. * intersection + self.eps) / (torch.sum(preds_f, -1) + torch.sum(targets_f, -1) + self.eps)
         loss = 1 - dice
-
+        
         return loss.mean()
 
-class IoULoss(nn.Module):
-    def __init__(self, **kwargs):
-        super(IoULoss, self).__init__()
+class FocalLoss(nn.Module):
+    def __init__(self, alpha=0.25, gamma=2):
+        super(FocalLoss, self).__init__()
+        self.alpha = alpha # 각 클래스에 대한 가중치 조정
+        self.gamma = gamma # Easy sample에 대한 loss 조절 (커질수록 loss가 줄어듦)
+
+    def forward(self, preds, targets):
+        # CE() -> -log(pt), FL() -> -a*((1-pt)^r) * log(pt)
+        BCE = F.binary_cross_entropy_with_logits(preds, targets) # CE
+        BCE_EXP = torch.exp(-BCE)
+        loss = self.alpha * (1-BCE_EXP)**self.gamma * BCE
+
+        return loss
+
 
 class DiceBCELoss(nn.Module):
     def __init__(self, **kwargs):
@@ -44,6 +54,18 @@ def forward(self, preds, targets):
 
         return dice_bce_loss
 
+class DiceFocalLoss(nn.Module):
+    def __init__(self):
+        super(DiceFocalLoss).__init__()
+        self.diceLoss = DiceLoss()
+        self.focalLoss = FocalLoss()
+    
+    def forward(self, preds, targets):
+        dice_loss = self.diceLoss(preds, targets)
+        focal_loss = self.focalLoss(preds, targets)
+        dice_focal_loss = dice_loss + focal_loss
+
+        return dice_focal_loss
 
 class LossSelector:
     def __init__(self, loss, **kwargs):
@@ -51,6 +73,8 @@ def __init__(self, loss, **kwargs):
             self.loss = BCE(**kwargs)
         elif loss == 'DiceBCELoss':
             self.loss = DiceBCELoss(**kwargs)
+        elif loss == 'DiceFocalLoss':
+            self.loss = DiceFocalLoss()
 
     def get_loss(self):
         return self.loss
\ No newline at end of file

From 006201155316f453388381c3fefcb5cf668892d2 Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Sun, 24 Nov 2024 14:15:59 +0900
Subject: [PATCH 065/106] [#21] Fix : debugging

---
 module_base/config.yaml | 2 +-
 module_base/loss.py     | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/module_base/config.yaml b/module_base/config.yaml
index 1a25b31..2f47b12 100644
--- a/module_base/config.yaml
+++ b/module_base/config.yaml
@@ -44,5 +44,5 @@ random_seed: 2024
 size: 1024
 
 # wandb
-wandb_run_name: smp_unet++_efficientnetv2_xl_DiceBCELoss_cosine_flip+rotate
+wandb_run_name: smp_unet++_hrnet64_DiceFocalLoss_cosine_flip+rotate
 wandb_run_id: None
\ No newline at end of file
diff --git a/module_base/loss.py b/module_base/loss.py
index 4bb06dd..fecd633 100644
--- a/module_base/loss.py
+++ b/module_base/loss.py
@@ -23,7 +23,7 @@ def forward(self, preds, targets):
 
         dice = (2. * intersection + self.eps) / (torch.sum(preds_f, -1) + torch.sum(targets_f, -1) + self.eps)
         loss = 1 - dice
-        
+
         return loss.mean()
 
 class FocalLoss(nn.Module):
@@ -56,7 +56,7 @@ def forward(self, preds, targets):
 
 class DiceFocalLoss(nn.Module):
     def __init__(self):
-        super(DiceFocalLoss).__init__()
+        super(DiceFocalLoss, self).__init__()
         self.diceLoss = DiceLoss()
         self.focalLoss = FocalLoss()
     

From f229d541cd83ef602c88090814e0b396ba4609cf Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Mon, 25 Nov 2024 00:15:37 +0900
Subject: [PATCH 066/106] =?UTF-8?q?[Comment]=20:=20config=20=EC=A3=BC?=
 =?UTF-8?q?=EC=84=9D=20=EC=B6=94=EA=B0=80?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 sam2_unet/config.yaml        | 29 ++++++++++++++++-------------
 sam2_unet/utils/transform.py |  5 +++--
 2 files changed, 19 insertions(+), 15 deletions(-)

diff --git a/sam2_unet/config.yaml b/sam2_unet/config.yaml
index cee9c40..9a7a483 100644
--- a/sam2_unet/config.yaml
+++ b/sam2_unet/config.yaml
@@ -5,38 +5,41 @@ test_image_path: /data/ephemeral/home/data/test/DCM
 hiera_path: /data/ephemeral/home/sam2_hiera_large.pt
 
 # train
-train_batch_size: 8
-train_num_workers: 8
+train_batch_size: 4
+train_num_workers: 4
 
 # valid
 valid_batch_size: 2
 valid_num_workers: 2
 kfold: 5
-k: 0
+k: -1
 threshold: 0.5
 
 # hyperparameter
 lr: 0.001
-max_epoch: 30
+max_epoch: 40
 
 # optimizer
 optimizer: adamw
 optimizer_parameters:
-  weight_decay: 0.01
-  betas: [0.9, 0.999]
+  weight_decay: 1e-6
 
 # scheduler
-scheduler: steplr
+scheduler: cosineannealinglr
 scheduler_parameters:
-  step_size: 40
-  gamma: 0.1
+  # steplr
+  # step_size: 40
+  # gamma: 0.1
 
+  # multisteplr
   # milestones: [10, 20]
   # gamma: 0.1
   
-  # T_max: 100
-  # eta_min: 5e-5
+  # cosineannealinglr
+  T_max: 40
+  eta_min: 5e-5
   
+  # reducelronplateau
   # factor: 0.1
   # patience: 10
 
@@ -48,10 +51,10 @@ random_seed: 2024
 save_every: 5
 
 # augmentation
-image_size: 512
+image_size: 1024
 
 # wandb
-wandb_name: 
+wandb_name: sam2unet_rotate_colorjitter
 wandb_id: 
 
 # resume
diff --git a/sam2_unet/utils/transform.py b/sam2_unet/utils/transform.py
index 6aa4218..b8f000d 100644
--- a/sam2_unet/utils/transform.py
+++ b/sam2_unet/utils/transform.py
@@ -22,8 +22,9 @@ def get_transform(self, is_train=True):
         if is_train:
             transform = A.Compose(
                 [
-                    # A.HorizontalFlip(),
-                    # A.ColorJitter()
+                    A.HorizontalFlip(p=0.2),
+                    A.Rotate((-15, 15), p=0.5),
+                    A.ColorJitter()
                 ]+ self.common_transform)
         else:
             transform = A.Compose(self.common_transform)

From 64a5eb6aba683d471aea8695072a295e4ae86b84 Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Mon, 25 Nov 2024 00:15:58 +0900
Subject: [PATCH 067/106] [Feature] : psnr

---
 augmentation/psnr.py | 66 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)
 create mode 100644 augmentation/psnr.py

diff --git a/augmentation/psnr.py b/augmentation/psnr.py
new file mode 100644
index 0000000..c80352c
--- /dev/null
+++ b/augmentation/psnr.py
@@ -0,0 +1,66 @@
+import os
+import cv2
+import math
+import numpy as np
+import albumentations as A
+
+image_root = "/data/ephemeral/home/data/train/DCM"
+pngs = {
+    os.path.relpath(os.path.join(root, fname), start=image_root)
+    for root, _dirs, files in os.walk(image_root)
+    for fname in files
+    if os.path.splitext(fname)[1].lower() == ".png"
+}
+pngs = sorted(pngs)
+
+modes = ['NEAREST', 'LINEAR', 'CUBIC', 'AREA', 'LANCZOS4']
+
+def compare_interpolation(image_path, image_size: int = 512, interpolation: int = 0):
+    ori_image = cv2.imread(image_path)
+    ori_image = ori_image.astype(np.float32) / 255.0
+
+    original_height, original_width = ori_image.shape[:2]
+
+    transformer = A.Resize(height=image_size, width=image_size, interpolation=interpolation, always_apply=True)
+    resized_image = transformer(image=ori_image)['image']
+
+    revert_transformer = A.Resize(height=original_height, width=original_width, interpolation=interpolation, always_apply=True)
+    reverted_image = revert_transformer(image=resized_image)['image']
+    
+    psnr_value = psnr(ori_image, reverted_image)
+    return psnr_value
+    
+
+def psnr(ori_img, con_img):
+    max_pixel = 255.0
+    mse = np.mean((ori_img - con_img)**2)
+
+    if mse == 0:
+        return 100
+    
+    psnr = 20 * math.log10(max_pixel / math.sqrt(mse))
+
+    return psnr
+
+if __name__ == "__main__":
+    # image_size = 512
+    # for i in range(len(modes)):
+    #     psnrs = []
+    #     interpolation = i
+    #     for png in pngs:
+    #         image_path = os.path.join(image_root, png)
+    #         psnrs.append(compare_interpolation(image_path, image_size, interpolation))
+    #     print(f"PSNR mean {modes[i]}: {sum(psnrs) / len(psnrs)}")
+
+    same = []
+    for i in range(len(pngs)):
+        image1_path = os.path.join(image_root, pngs[i])
+        image1 = cv2.imread(image1_path)
+        print(f"{pngs[i]} start")
+        for j in range(i + 1, len(pngs)):
+            image2_path = os.path.join(image_root, pngs[j])
+            image2 = cv2.imread(image2_path)
+            if psnr(image1, image2) == 100:
+                same.append((pngs[i], pngs[j]))
+                print(f"same {pngs[i]} & {pngs[j]}")
+    print(same)
\ No newline at end of file

From f241342092b6c49117a8d16940b43facaffd53f6 Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Mon, 25 Nov 2024 15:28:01 +0900
Subject: [PATCH 068/106] [Feature] : csv to train pngs and jsons

---
 pseudo_labeling.py | 82 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 82 insertions(+)
 create mode 100644 pseudo_labeling.py

diff --git a/pseudo_labeling.py b/pseudo_labeling.py
new file mode 100644
index 0000000..2026797
--- /dev/null
+++ b/pseudo_labeling.py
@@ -0,0 +1,82 @@
+import os
+import cv2
+import json
+import shutil
+import argparse
+import numpy as np
+import pandas as pd
+
+def decode_rle_to_polygon(rle, img_width=2048, img_height=2048):
+    s = rle.split()
+    starts, lengths = [np.asarray(x, dtype=int) for x in (s[0:][::2], s[1:][::2])]
+    starts -= 1
+    ends = starts + lengths
+    mask = np.zeros(img_height * img_width, dtype=np.uint8)
+    
+    for lo, hi in zip(starts, ends):
+        mask[lo:hi] = 1
+    
+    mask = mask.reshape(img_height, img_width)
+
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    
+    polygons = []
+    for contour in contours:
+        polygon = [[int(point[0][0]), int(point[0][1])] for point in contour]
+        polygons.append(polygon)
+
+    return polygons
+
+def main():
+    parser = argparse.ArgumentParser(description='Pseudo Labeling')
+    parser.add_argument('--result', required=True, help='result csv file path')
+    parser.add_argument('--src_image_path', default='/data/ephemeral/home/data_v3/test/DCM', help='from pngs directory')
+    parser.add_argument('--dst_image_path', default='/data/ephemeral/home/data_v3/train/DCM', help='to pngs directory')
+    parser.add_argument('--dst_label_path', default='/data/ephemeral/home/data_v3/train/outputs_json', help='to jsons directory')
+    args = parser.parse_args()
+
+    pngs = {
+        os.path.relpath(os.path.join(root, fname), start=args.src_image_path)
+        for root, _dirs, files in os.walk(args.src_image_path)
+        for fname in files
+        if os.path.splitext(fname)[1].lower() == ".png"
+    }
+    pngs = sorted(pngs)
+    image_dict = {png.split('/')[-1]: png.split('.')[0] for png in pngs}
+    
+    df = pd.read_csv(args.result)
+
+    annotations = []
+
+    for image_name, group in df.groupby('image_name'):
+        for idx, row in group.iterrows():
+            class_name = row['class']
+            rle = row['rle']
+
+            points = decode_rle_to_polygon(rle)
+
+            annotation = {
+                "id": f"{idx}-{image_name}",
+                "type": "poly_seg",
+                "attributes": {},
+                "points": points,
+                "label": class_name
+            }
+
+            annotations.append(annotation)
+
+        from_image_path = os.path.join(args.src_image_path, image_dict[image_name] + '.png')
+        to_image_path = os.path.join(args.dst_image_path, image_dict[image_name] + '.png')
+
+        os.makedirs(os.path.dirname(to_image_path), exist_ok=True)
+        shutil.copy(from_image_path, to_image_path)
+        print(f"save image '{to_image_path}'")
+
+        to_label_path = os.path.join(args.dst_label_path, image_dict[image_name] + '.json')
+        os.makedirs(os.path.dirname(to_label_path), exist_ok=True)
+        with open(to_label_path, 'w') as json_file:
+            json.dump({"annotations": annotations, "filename": image_name,}, json_file)
+        print(f"save label '{to_label_path}'")
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file

From cfcd83738c0b5b34d666f66f5a133600602818bc Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Mon, 25 Nov 2024 16:44:54 +0900
Subject: [PATCH 069/106] [Fix] : Edit array dimention

---
 pseudo_labeling.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pseudo_labeling.py b/pseudo_labeling.py
index 2026797..02c7dc1 100644
--- a/pseudo_labeling.py
+++ b/pseudo_labeling.py
@@ -22,8 +22,8 @@ def decode_rle_to_polygon(rle, img_width=2048, img_height=2048):
     
     polygons = []
     for contour in contours:
-        polygon = [[int(point[0][0]), int(point[0][1])] for point in contour]
-        polygons.append(polygon)
+        for point in contour:
+            polygons.append([int(point[0][0]), int(point[0][1])])
 
     return polygons
 

From 858905202ae8f6d4bec899a4a4b3cc5664683e5f Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Mon, 25 Nov 2024 18:45:56 +0900
Subject: [PATCH 070/106] [feature]: add some config for 2048 models

---
 mmsegmentation/baseline.py                    |  7 +-
 .../configs/_custom_/_base_/schedule_160k.py  |  2 +-
 .../configs/_custom_/_base_/xraydata2.py      |  3 +-
 ...0-d8_4xb2-300k_mapillay_v1_65-1280x1280.py | 97 +++++++++++++++++++
 .../fcn_hr18s_4xb2-40k_cityscapes-512x1024.py | 70 +++++++++++++
 .../fcn_hr48_4xb2-40k_cityscapes-512x1024.py  | 70 +++++++++++++
 .../configs/_custom_/unet/unet_s5_d16_fcn.py  | 68 +++++++++++++
 .../configs/_custom_/upernet/upernet_hr48.py  | 83 ++++++++++++++++
 ...pernet_r101_4xb2-40k_cityscapes-769x769.py | 62 ++++++++++++
 .../mmseg/models/decode_heads/custom.py       |  6 +-
 10 files changed, 460 insertions(+), 8 deletions(-)
 create mode 100644 mmsegmentation/configs/_custom_/deeplabV3+/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280.py
 create mode 100644 mmsegmentation/configs/_custom_/hrnet/fcn_hr18s_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/_custom_/hrnet/fcn_hr48_4xb2-40k_cityscapes-512x1024.py
 create mode 100644 mmsegmentation/configs/_custom_/unet/unet_s5_d16_fcn.py
 create mode 100644 mmsegmentation/configs/_custom_/upernet/upernet_hr48.py
 create mode 100644 mmsegmentation/configs/_custom_/upernet/upernet_r101_4xb2-40k_cityscapes-769x769.py

diff --git a/mmsegmentation/baseline.py b/mmsegmentation/baseline.py
index 21d01fe..c76dec5 100644
--- a/mmsegmentation/baseline.py
+++ b/mmsegmentation/baseline.py
@@ -5,10 +5,10 @@
 ##############################
 # 데이터 경로를 입력하세요
 
-CONFIG_PATH = "/data/ephemeral/home/parkjunil/level2-cv-semanticsegmentation-cv-19-lv3/mmsegmentation/configs/_baseline_/config_for_this_example.py"
+CONFIG_PATH = "/data/ephemeral/home/parkjunil/level2-cv-semanticsegmentation-cv-19-lv3/mmsegmentation/configs/_custom_/hrnet/fcn_hr18s_4xb2-40k_cityscapes-512x1024.py"
 CHECKPOINT_PATH = "/data/ephemeral/home/parkjunil/work_dir/baseline_dice_1480_hflip/best_mDice_iter_16000.pth"
 SUBMISSION_PATH = "/data/ephemeral/home/submission"
-WORK_DIR = "/data/ephemeral/home/parkjunil/work_dir/baseline_dice_1480_hflip"
+WORK_DIR = "/data/ephemeral/home/parkjunil/work_dir/hrnet18_fpn_2048_noaug"
 TTA = True
 
 
@@ -25,7 +25,6 @@ def load_config():
 def train():
     # load config
     cfg =load_config()
-    
     runner = Runner.from_cfg(cfg)
 
     # start training
@@ -46,4 +45,4 @@ def inference():
 
 
 if __name__ == "__main__":
-    inference()
\ No newline at end of file
+    train()
\ No newline at end of file
diff --git a/mmsegmentation/configs/_custom_/_base_/schedule_160k.py b/mmsegmentation/configs/_custom_/_base_/schedule_160k.py
index 3b3a85f..bc034a2 100644
--- a/mmsegmentation/configs/_custom_/_base_/schedule_160k.py
+++ b/mmsegmentation/configs/_custom_/_base_/schedule_160k.py
@@ -1,4 +1,4 @@
-val_save_interval = 1000
+val_save_interval = 2000
 warm_up_step = 1000
 max_iters = 30000
 T_max = max_iters-warm_up_step
diff --git a/mmsegmentation/configs/_custom_/_base_/xraydata2.py b/mmsegmentation/configs/_custom_/_base_/xraydata2.py
index d55802b..71123d9 100644
--- a/mmsegmentation/configs/_custom_/_base_/xraydata2.py
+++ b/mmsegmentation/configs/_custom_/_base_/xraydata2.py
@@ -1,4 +1,4 @@
-IMAGE_SIZE = (1480, 1480)
+IMAGE_SIZE = (2048, 2048)
 IMAGE_ROOT = '/data/ephemeral/home/data/train/DCM'
 LABEL_ROOT = '/data/ephemeral/home/data/train/outputs_json'
 SUBMISSION_PATH = '/data/ephemeral/home/submission'
@@ -11,7 +11,6 @@
             dict(type='LoadImageFromFile'),
             dict(type='LoadXRayAnnotations'),
             dict(type='Resize', scale=IMAGE_SIZE),
-            dict(type='RandomFlip', prob=0.5, direction='horizontal'),
             dict(type='TransposeAnnotations'),
             dict(type='PackSegInputs')
         ]
diff --git a/mmsegmentation/configs/_custom_/deeplabV3+/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280.py b/mmsegmentation/configs/_custom_/deeplabV3+/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280.py
new file mode 100644
index 0000000..60fb2c7
--- /dev/null
+++ b/mmsegmentation/configs/_custom_/deeplabV3+/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280.py
@@ -0,0 +1,97 @@
+_base_ = [
+    '../_base_/xraydata2.py',
+    '../_base_/default_runtime.py', '../_base_/schedule_160k.py'
+]
+
+crop_size = (1280, 1280)
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    size=crop_size,
+    seg_pad_val=255)
+num_classes = 29
+
+model = dict(
+    type='EncoderDecoderWithoutArgmax',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='DepthwiseSeparableASPPHeadWithoutAccuracy',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        dilations=(1, 12, 24, 36),
+        c1_in_channels=256,
+        c1_channels=48,
+        dropout_ratio=0.1,
+        num_classes=num_classes,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=num_classes,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+
+
+iters = 30000
+# optimizer
+optimizer = dict(
+    type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.0001)
+# optimizer
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=optimizer,
+    clip_grad=dict(max_norm=0.01, norm_type=2),
+    paramwise_cfg=dict(
+        custom_keys={'backbone': dict(lr_mult=0.1, decay_mult=1.0)}))
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=0,
+        power=0.9,
+        begin=0,
+        end=iters,
+        by_epoch=False)
+]
+
+# training schedule for 300k
+train_cfg = dict(
+    type='IterBasedTrainLoop', max_iters=iters, val_interval=iters // 15)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+
+# train_dataloader = dict(batch_size=2)
+# Default setting for scaling LR automatically
+#   - `enable` means enable scaling LR automatically
+#       or not by default.
+#   - `base_batch_size` = (4 GPUs) x (2 samples per GPU).
+auto_scale_lr = dict(enable=False, base_batch_size=2)
\ No newline at end of file
diff --git a/mmsegmentation/configs/_custom_/hrnet/fcn_hr18s_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/_custom_/hrnet/fcn_hr18s_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..39fb9aa
--- /dev/null
+++ b/mmsegmentation/configs/_custom_/hrnet/fcn_hr18s_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,70 @@
+_base_ = [
+    '../_base_/xraydata2.py',
+    '../_base_/default_runtime.py', '../_base_/schedule_160k.py'
+]
+
+crop_size = (512, 1024)
+
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    size=crop_size,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoderWithoutArgmax',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://msra/hrnetv2_w18',
+    backbone=dict(
+        type='HRNet',
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        extra=dict(
+            stage1=dict(
+                num_modules=1,
+                num_branches=1,
+                block='BOTTLENECK',
+                num_blocks=(2, ),
+                num_channels=(64, )),
+            stage2=dict(
+                num_modules=1,
+                num_branches=2,
+                block='BASIC',
+                num_blocks=(2, 2),
+                num_channels=(18, 36)),
+            stage3=dict(
+                num_modules=4,
+                num_branches=3,
+                block='BASIC',
+                num_blocks=(2, 2, 2),
+                num_channels=(18, 36, 72)),
+            stage4=dict(
+                num_modules=3,
+                num_branches=4,
+                block='BASIC',
+                num_blocks=(2, 2, 2, 2),
+                num_channels=(18, 36, 72, 144)))),
+    decode_head=dict(
+        type='FCNHeadWithoutAccuracy',
+        in_channels=[18, 36, 72, 144],
+        in_index=(0, 1, 2, 3),
+        channels=sum([18, 36, 72, 144]),
+        input_transform='resize_concat',
+        kernel_size=1,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=-1,
+        num_classes=29,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+
+train_dataloader = dict(batch_size = 2)
\ No newline at end of file
diff --git a/mmsegmentation/configs/_custom_/hrnet/fcn_hr48_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/_custom_/hrnet/fcn_hr48_4xb2-40k_cityscapes-512x1024.py
new file mode 100644
index 0000000..9f01a82
--- /dev/null
+++ b/mmsegmentation/configs/_custom_/hrnet/fcn_hr48_4xb2-40k_cityscapes-512x1024.py
@@ -0,0 +1,70 @@
+_base_ = [
+    '../_base_/xraydata2.py',
+    '../_base_/default_runtime.py', '../_base_/schedule_160k.py'
+]
+
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+crop_size = (512, 1024)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    size=crop_size,
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+
+
+
+model = dict(
+    type='EncoderDecoderWithoutArgmax',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        type='HRNet',
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        extra=dict(
+            stage1=dict(
+                num_modules=1,
+                num_branches=1,
+                block='BOTTLENECK',
+                num_blocks=(4, ),
+                num_channels=(64, )),
+            stage2=dict(
+                num_modules=1,
+                num_branches=2,
+                block='BASIC',
+                num_blocks=(4, 4),
+                num_channels=(48, 96)),
+            stage3=dict(
+                num_modules=4,
+                num_branches=3,
+                block='BASIC',
+                num_blocks=(4, 4, 4),
+                num_channels=(48, 96, 192)),
+            stage4=dict(
+                num_modules=3,
+                num_branches=4,
+                block='BASIC',
+                num_blocks=(4, 4, 4, 4),
+                num_channels=(48, 96, 192, 384)))),
+    decode_head=dict(
+        type='FCNHeadWithoutAccuracy',
+        in_channels=[48, 96, 192, 384],
+        in_index=(0, 1, 2, 3),
+        channels=sum([48, 96, 192, 384]),
+        input_transform='resize_concat',
+        kernel_size=1,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=-1,
+        num_classes=29,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
\ No newline at end of file
diff --git a/mmsegmentation/configs/_custom_/unet/unet_s5_d16_fcn.py b/mmsegmentation/configs/_custom_/unet/unet_s5_d16_fcn.py
new file mode 100644
index 0000000..b5a3772
--- /dev/null
+++ b/mmsegmentation/configs/_custom_/unet/unet_s5_d16_fcn.py
@@ -0,0 +1,68 @@
+_base_ = [
+    '../_base_/xraydata2.py',
+    '../_base_/default_runtime.py', '../_base_/schedule_160k.py'
+]
+
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[0., 0., 0.],
+    std=[255., 255., 255.],
+    bgr_to_rgb=True,
+    size=(1024, 1024),
+    pad_val=0,
+    seg_pad_val=255,
+)
+
+model = dict(
+    type='EncoderDecoderWithoutArgmax',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        type='UNet',
+        in_channels=3,
+        base_channels=64,
+        num_stages=5,
+        strides=(1, 1, 1, 1, 1),
+        enc_num_convs=(2, 2, 2, 2, 2),
+        dec_num_convs=(2, 2, 2, 2),
+        downsamples=(True, True, True, True),
+        enc_dilations=(1, 1, 1, 1, 1),
+        dec_dilations=(1, 1, 1, 1),
+        with_cp=False,
+        conv_cfg=None,
+        norm_cfg=norm_cfg,
+        act_cfg=dict(type='ReLU'),
+        upsample_cfg=dict(type='InterpConv'),
+        norm_eval=False),
+    decode_head=dict(
+        type='FCNHeadWithoutAccuracy',
+        in_channels=64,
+        in_index=4,
+        channels=64,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=29,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=[
+        dict(type='CrossEntropyLoss', loss_name='loss_ce', use_sigmoid=True, loss_weight=1.0),
+        dict(type='DiceLoss', loss_name='loss_dice', use_sigmoid=True, loss_weight=3.0)]
+        ),
+    auxiliary_head=dict(
+        type='FCNHeadWithoutAccuracy',
+        in_channels=128,
+        in_index=3,
+        channels=64,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=29,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
\ No newline at end of file
diff --git a/mmsegmentation/configs/_custom_/upernet/upernet_hr48.py b/mmsegmentation/configs/_custom_/upernet/upernet_hr48.py
new file mode 100644
index 0000000..a5f01a0
--- /dev/null
+++ b/mmsegmentation/configs/_custom_/upernet/upernet_hr48.py
@@ -0,0 +1,83 @@
+_base_ = [
+    '../_base_/xraydata2.py',
+    '../_base_/default_runtime.py', '../_base_/schedule_160k.py'
+]
+
+# model settings
+num_classes = 29
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+crop_size = (769, 769)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    size=crop_size,
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+
+
+model = dict(
+    type='EncoderDecoderWithoutArgmax',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://msra/hrnetv2_w48',
+    backbone=dict(
+        type='HRNet',
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        extra=dict(
+            stage1=dict(
+                num_modules=1,
+                num_branches=1,
+                block='BOTTLENECK',
+                num_blocks=(4, ),
+                num_channels=(64, )),
+            stage2=dict(
+                num_modules=1,
+                num_branches=2,
+                block='BASIC',
+                num_blocks=(4, 4),
+                num_channels=(48, 96)),
+            stage3=dict(
+                num_modules=4,
+                num_branches=3,
+                block='BASIC',
+                num_blocks=(4, 4, 4),
+                num_channels=(48, 96, 192)),
+            stage4=dict(
+                num_modules=3,
+                num_branches=4,
+                block='BASIC',
+                num_blocks=(4, 4, 4, 4),
+                num_channels=(48, 96, 192, 384)))),
+    decode_head=dict(
+        type='UPerHeadWithoutAccuracy',
+        in_channels=[48, 96, 192, 384],
+        in_index=[0, 1, 2, 3],
+        pool_scales=(1, 2, 3, 6),
+        channels=sum([48, 96, 192, 384]),
+        dropout_ratio=0.1,
+        num_classes=num_classes,
+        norm_cfg=norm_cfg,
+        align_corners=True,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHeadWithoutAccuracy',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=num_classes,
+        norm_cfg=norm_cfg,
+        align_corners=True,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.4)),
+    # model training and testing settings
+    
+    train_cfg=dict(),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
+
+
diff --git a/mmsegmentation/configs/_custom_/upernet/upernet_r101_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/_custom_/upernet/upernet_r101_4xb2-40k_cityscapes-769x769.py
new file mode 100644
index 0000000..923173b
--- /dev/null
+++ b/mmsegmentation/configs/_custom_/upernet/upernet_r101_4xb2-40k_cityscapes-769x769.py
@@ -0,0 +1,62 @@
+_base_ = [
+    '../_base_/xraydata2.py',
+    '../_base_/default_runtime.py', '../_base_/schedule_160k.py'
+]
+
+# model settings
+num_classes = 29
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+crop_size = (769, 769)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    size=crop_size,
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+
+
+model = dict(
+    type='EncoderDecoderWithoutArgmax',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet101_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=101,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 1, 1),
+        strides=(1, 2, 2, 2),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='UPerHeadWithoutAccuracy',
+        in_channels=[256, 512, 1024, 2048],
+        in_index=[0, 1, 2, 3],
+        pool_scales=(1, 2, 3, 6),
+        channels=512,
+        dropout_ratio=0.1,
+        num_classes=num_classes,
+        norm_cfg=norm_cfg,
+        align_corners=True,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHeadWithoutAccuracy',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=num_classes,
+        norm_cfg=norm_cfg,
+        align_corners=True,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
\ No newline at end of file
diff --git a/mmsegmentation/mmseg/models/decode_heads/custom.py b/mmsegmentation/mmseg/models/decode_heads/custom.py
index b698d9b..396ff82 100644
--- a/mmsegmentation/mmseg/models/decode_heads/custom.py
+++ b/mmsegmentation/mmseg/models/decode_heads/custom.py
@@ -2,7 +2,7 @@
 
 from mmseg.registry import MODELS
 from mmseg.models.utils.wrappers import resize
-from mmseg.models.decode_heads import ASPPHead, FCNHead, SegformerHead, UPerHead, LightHamHead
+from mmseg.models.decode_heads import ASPPHead, FCNHead, SegformerHead, UPerHead, LightHamHead, DepthwiseSeparableASPPHead
 
 
 class LossByFeatMixIn:
@@ -75,4 +75,8 @@ class UPerHeadWithoutAccuracy(LossByFeatMixIn, UPerHead):
 
 @MODELS.register_module()
 class LightHamHeadWithoutAccuracy(LossByFeatMixIn, LightHamHead):
+    pass
+
+@MODELS.register_module()
+class DepthwiseSeparableASPPHeadWithoutAccuracy(LossByFeatMixIn, DepthwiseSeparableASPPHead):
     pass
\ No newline at end of file

From e8466a7b04133822fa78d02cb2abac2ab3ee44c9 Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Mon, 25 Nov 2024 23:23:53 +0900
Subject: [PATCH 071/106] refine

---
 module_base/config.yaml    | 10 +++++-----
 module_base/inference.py   |  2 +-
 module_base/loss.py        |  3 +--
 module_base/transform.py   |  2 +-
 module_base/wandb_train.py |  4 ++--
 5 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/module_base/config.yaml b/module_base/config.yaml
index 2f47b12..8d63dba 100644
--- a/module_base/config.yaml
+++ b/module_base/config.yaml
@@ -11,7 +11,7 @@ encoder_weights: imagenet
 pretrained: True
 
 # batch_size
-train_batch_size: 4
+train_batch_size: 2
 valid_batch_size: 4
 
 # hyperparameter
@@ -19,15 +19,15 @@ lr: 2e-4
 weight_decay: 1e-6
 train_num_workers: 8
 valid_num_workers: 0
-max_epoch: 60
+max_epoch: 50
 
 # loss
 loss:
-    name: DiceFocalLoss
+    name: DiceBCELoss
     params: null
 
 # optimizer
-optim: Adam
+optim: AdamW
 
 # scheduler
 scheduler: cosine
@@ -44,5 +44,5 @@ random_seed: 2024
 size: 1024
 
 # wandb
-wandb_run_name: smp_unet++_hrnet64_DiceFocalLoss_cosine_flip+rotate
+wandb_run_name: smp_unet++_hrnet64_DiceBCELoss_cosine_flip+rotate_adamW_batch2
 wandb_run_id: None
\ No newline at end of file
diff --git a/module_base/inference.py b/module_base/inference.py
index 9a0ceec..b1cac75 100644
--- a/module_base/inference.py
+++ b/module_base/inference.py
@@ -127,7 +127,7 @@ def do_inference(image_root, save_dir, random_seed, model_type):
         "rle": rles,
     })
     
-    df.to_csv("best_hrnet2.csv", index=False)
+    df.to_csv("best_hrnet_adamw.csv", index=False)
 
 def main(args):
     do_inference(**args.__dict__)
diff --git a/module_base/loss.py b/module_base/loss.py
index fecd633..b9b4716 100644
--- a/module_base/loss.py
+++ b/module_base/loss.py
@@ -27,7 +27,7 @@ def forward(self, preds, targets):
         return loss.mean()
 
 class FocalLoss(nn.Module):
-    def __init__(self, alpha=0.25, gamma=2):
+    def __init__(self, alpha=0.4, gamma=1):
         super(FocalLoss, self).__init__()
         self.alpha = alpha # 각 클래스에 대한 가중치 조정
         self.gamma = gamma # Easy sample에 대한 loss 조절 (커질수록 loss가 줄어듦)
@@ -40,7 +40,6 @@ def forward(self, preds, targets):
 
         return loss
 
-
 class DiceBCELoss(nn.Module):
     def __init__(self, **kwargs):
         super(DiceBCELoss, self).__init__()
diff --git a/module_base/transform.py b/module_base/transform.py
index c97f19d..6bcee72 100644
--- a/module_base/transform.py
+++ b/module_base/transform.py
@@ -8,7 +8,7 @@ def __init__(self, is_train, resize):
             self.transform = A.Compose(
                 [
                     A.HorizontalFlip(0.2),
-                    A.Rotate(limit=(-15, 15), p=0.5)
+                    A.Rotate(limit=(-15, 15), p=0.5),
                     # A.CLAHE(clip_limit=4.0, tile_grid_size=(8, 8), always_apply=False, p=1.0)
                 ]+ common_transform)
         else:
diff --git a/module_base/wandb_train.py b/module_base/wandb_train.py
index 745d51f..0db0083 100644
--- a/module_base/wandb_train.py
+++ b/module_base/wandb_train.py
@@ -30,7 +30,7 @@
 def set_seed(random_seed):
     torch.manual_seed(random_seed)
     torch.cuda.manual_seed(random_seed)
-    torch.cuda.manual_seed_all(random_seed) # if use multi-GPU
+    torch.cuda.manual_seed_all(random_seed)
     torch.backends.cudnn.deterministic = True
     torch.backends.cudnn.benchmark = False
     np.random.seed(random_seed)
@@ -231,7 +231,7 @@ def main(cfg):
         loss = LossSelector(cfg.loss.name)
     criterion = loss.get_loss()
 
-    optimizer = optim.Adam(params=model.parameters(), lr=cfg.lr, weight_decay=cfg.weight_decay)
+    optimizer = optim.AdamW(params=model.parameters(), lr=cfg.lr, weight_decay=cfg.weight_decay)
 
     sched = SchedulerSelector(cfg.scheduler, optimizer, cfg.max_epoch)
     scheduler = sched.get_sched()

From 5a03586fa6d88ac4432b61f1aca8d259b5a98080 Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Mon, 25 Nov 2024 23:44:41 +0900
Subject: [PATCH 072/106] [#21] Feature : add optimizer.py

---
 module_base/config.yaml    |  6 +++---
 module_base/optimizer.py   | 17 +++++++++++++++++
 module_base/wandb_train.py |  6 +++---
 3 files changed, 23 insertions(+), 6 deletions(-)
 create mode 100644 module_base/optimizer.py

diff --git a/module_base/config.yaml b/module_base/config.yaml
index 8d63dba..7fd28ff 100644
--- a/module_base/config.yaml
+++ b/module_base/config.yaml
@@ -27,7 +27,7 @@ loss:
     params: null
 
 # optimizer
-optim: AdamW
+optim: Adam
 
 # scheduler
 scheduler: cosine
@@ -41,8 +41,8 @@ threshold: 0.5
 random_seed: 2024
 
 # resize
-size: 1024
+size: 512
 
 # wandb
-wandb_run_name: smp_unet++_hrnet64_DiceBCELoss_cosine_flip+rotate_adamW_batch2
+wandb_run_name: smp_unet++_vgg19_DiceBCELoss_cosine_flip+rotate_adam_2048
 wandb_run_id: None
\ No newline at end of file
diff --git a/module_base/optimizer.py b/module_base/optimizer.py
new file mode 100644
index 0000000..e91ceb9
--- /dev/null
+++ b/module_base/optimizer.py
@@ -0,0 +1,17 @@
+import torch.optim as optim
+from lion_pytorch import Lion
+
+class OptimizerSelector:
+    def __init__(self, opt, model, lr, weight_decay):
+        self.model = model
+        self.lr = lr
+        self.weight_decay = weight_decay
+        if opt == 'Adam': 
+            self.optimizer = optim.Adam(params=self.model.parameters(), lr=self.lr, weight_decay=self.weight_decay)
+        elif opt == 'AdamW': 
+            self.optimizer = optim.AdamW(params=self.model.parameters(), lr=self.lr, weight_decay=self.weight_decay)
+        elif opt == 'Lion': 
+            self.optimizer = Lion(params=self.model.parameters(), lr=self.lr, weight_decay=self.weight_decay)
+            
+    def get_optim(self):
+        return self.optimizer
\ No newline at end of file
diff --git a/module_base/wandb_train.py b/module_base/wandb_train.py
index 0db0083..447ee91 100644
--- a/module_base/wandb_train.py
+++ b/module_base/wandb_train.py
@@ -6,12 +6,10 @@
 
 import numpy as np
 from tqdm.auto import tqdm
-import albumentations as A
 
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-import torch.optim as optim
 from torch.utils.data import DataLoader
 
 from dataset import XRayDataset
@@ -19,6 +17,7 @@
 from transform import TransformSelector
 from loss import LossSelector
 from scheduler import SchedulerSelector
+from optimizer import OptimizerSelector
 
 import warnings
 warnings.filterwarnings('ignore')
@@ -231,7 +230,8 @@ def main(cfg):
         loss = LossSelector(cfg.loss.name)
     criterion = loss.get_loss()
 
-    optimizer = optim.AdamW(params=model.parameters(), lr=cfg.lr, weight_decay=cfg.weight_decay)
+    optim = OptimizerSelector(cfg.optim, model, cfg.lr, cfg.weight_decay)
+    optimizer = optim.get_optim()
 
     sched = SchedulerSelector(cfg.scheduler, optimizer, cfg.max_epoch)
     scheduler = sched.get_sched()

From 3caa7fcf60a1893c789856e2421a97dcaa20e900 Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Tue, 26 Nov 2024 11:05:26 +0900
Subject: [PATCH 073/106] [#21] Feature : add gradient accumulation

---
 module_base/config.yaml    | 13 +++++++------
 module_base/wandb_train.py | 27 +++++++++++++++++----------
 2 files changed, 24 insertions(+), 16 deletions(-)

diff --git a/module_base/config.yaml b/module_base/config.yaml
index 7fd28ff..6c51a1a 100644
--- a/module_base/config.yaml
+++ b/module_base/config.yaml
@@ -6,20 +6,21 @@ save_dir: /data/ephemeral/home/data/result
 # 모델 라이브러리 및 사용 모델 정의
 model_type: smp
 model_name: UnetPlusPlus
-encoder_name: tu-hrnet_w64
+encoder_name: vgg19_bn
 encoder_weights: imagenet
 pretrained: True
 
 # batch_size
-train_batch_size: 2
-valid_batch_size: 4
+train_batch_size: 1
+valid_batch_size: 1
 
 # hyperparameter
 lr: 2e-4
 weight_decay: 1e-6
-train_num_workers: 8
+train_num_workers: 4
 valid_num_workers: 0
-max_epoch: 50
+max_epoch: 60
+step: 2 # batch_size 효과
 
 # loss
 loss:
@@ -41,7 +42,7 @@ threshold: 0.5
 random_seed: 2024
 
 # resize
-size: 512
+size: 2048
 
 # wandb
 wandb_run_name: smp_unet++_vgg19_DiceBCELoss_cosine_flip+rotate_adam_2048
diff --git a/module_base/wandb_train.py b/module_base/wandb_train.py
index 447ee91..09a30d4 100644
--- a/module_base/wandb_train.py
+++ b/module_base/wandb_train.py
@@ -144,12 +144,24 @@ def train(model, train_loader, val_loader, criterion, optimizer, scheduler, cfg)
                 elif cfg.model_type == 'smp':
                     outputs = model(images)
                 loss = criterion(outputs, masks)
+                # 아래 부터는 gradient accumulation
+                loss = loss / cfg.step
+            '''
             # 스케일된 loss를 사용해 backward 및 optimizer step
             optimizer.zero_grad()
             scaler.scale(loss).backward()
             scaler.step(optimizer)
             scaler.update()
-            
+            '''
+            scaler.scale(loss).backward()
+            epoch_loss += loss.item() * cfg.step
+
+            # gradient accumulation
+            if (step + 1) % cfg.step == 0:
+                scaler.step(optimizer)
+                scaler.update()
+                optimizer.zero_grad()
+
             # step 주기에 따라 loss를 출력합니다.
             if (step + 1) % 80 == 0:
                 print(
@@ -159,26 +171,21 @@ def train(model, train_loader, val_loader, criterion, optimizer, scheduler, cfg)
                     f'Loss: {round(loss.item(),4)}'
                 )
         scheduler.step()
-        epoch_time = datetime.timedelta(seconds=time.time() - epoch_start)
-        dataset_size = len(train_loader.dataset)
-        epoch_loss = epoch_loss / dataset_size
         # validation 주기에 따라 loss를 출력하고 best model을 저장합니다.
         if (epoch + 1) % cfg.val_every == 0:
             dice, val_loss = validation(epoch + 1, model, val_loader, criterion, cfg.model_type)
-            
             if best_dice < dice:
-                print(f"Best performance at epoch: {epoch + 1}, {best_dice:.4f} -> {dice:.4f}")
-                print(f"Save model in {cfg.save_dir}")
                 best_dice = dice
                 ckpt_path = save_model(model, cfg.save_dir)
+                print(f"Best performance at epoch: {epoch + 1}, {best_dice:.4f} -> {dice:.4f}")
+                print(f"Save model in {cfg.save_dir}")
             logger.log_model(ckpt_path, f'model-epoch-{epoch+1}')
             logger.log_epoch_metrics(
                 {
                     "epoch": epoch,
-                    "loss": epoch_loss,
+                    "loss": epoch_loss / len(train_loader.dataset),
                     "dice": dice,
-                    "val_loss": val_loss,
-                    "epoch_time": epoch_time.total_seconds()
+                    "val_loss": val_loss
                 }
             )
     logger.finish()

From dce04e997c64693fadb4061148c4040cc9fea98d Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Tue, 26 Nov 2024 14:03:03 +0900
Subject: [PATCH 074/106] [Feature] : add label smoothing

---
 sam2_unet/config.yaml         | 22 ++++++++++++----------
 sam2_unet/test.py             |  2 +-
 sam2_unet/train.py            |  2 ++
 sam2_unet/trainer.py          | 33 ++++++++++++++++++++-------------
 sam2_unet/utils/checkpoint.py |  4 ++--
 sam2_unet/utils/loss.py       |  3 ++-
 sam2_unet/utils/transform.py  | 18 ++----------------
 7 files changed, 41 insertions(+), 43 deletions(-)

diff --git a/sam2_unet/config.yaml b/sam2_unet/config.yaml
index 9a7a483..41855ab 100644
--- a/sam2_unet/config.yaml
+++ b/sam2_unet/config.yaml
@@ -1,23 +1,25 @@
 # paths
-train_image_path: /data/ephemeral/home/data_v1/train/DCM
-train_mask_path: /data/ephemeral/home/data_v1/train/outputs_json
+train_image_path: /data/ephemeral/home/data_v2/train/DCM
+train_mask_path: /data/ephemeral/home/data_v2/train/outputs_json
 test_image_path: /data/ephemeral/home/data/test/DCM
 hiera_path: /data/ephemeral/home/sam2_hiera_large.pt
 
 # train
-train_batch_size: 4
-train_num_workers: 4
+train_batch_size: 2
+train_num_workers: 2
 
 # valid
 valid_batch_size: 2
 valid_num_workers: 2
 kfold: 5
-k: -1
+k: 0
 threshold: 0.5
+valid_every: 2
 
 # hyperparameter
-lr: 0.001
+lr: 2e-4
 max_epoch: 40
+smooth_factor: 0
 
 # optimizer
 optimizer: adamw
@@ -36,12 +38,12 @@ scheduler_parameters:
   # gamma: 0.1
   
   # cosineannealinglr
-  T_max: 40
-  eta_min: 5e-5
+  T_max: 30
+  eta_min: 1e-6
   
   # reducelronplateau
   # factor: 0.1
-  # patience: 10
+  # patience: 5
 
 
 # random seed 
@@ -54,7 +56,7 @@ save_every: 5
 image_size: 1024
 
 # wandb
-wandb_name: sam2unet_rotate_colorjitter
+wandb_name: sam2unet_1024_best
 wandb_id: 
 
 # resume
diff --git a/sam2_unet/test.py b/sam2_unet/test.py
index 788ac6c..bd29410 100644
--- a/sam2_unet/test.py
+++ b/sam2_unet/test.py
@@ -16,7 +16,7 @@
                     help="path to the checkpoint of sam2-unet")
 parser.add_argument("--test_image_path", type=str, default="/data/ephemeral/home/data/test/DCM",
                     help="path to the image files for testing")
-parser.add_argument("--image_size", type=int, default=512)
+parser.add_argument("--image_size", type=int, default=1024)
 args = parser.parse_args()
 
 def encode_mask_to_rle(mask):
diff --git a/sam2_unet/train.py b/sam2_unet/train.py
index efc0a57..4dc0605 100644
--- a/sam2_unet/train.py
+++ b/sam2_unet/train.py
@@ -87,10 +87,12 @@ def main(cfg):
         optimizer=optimizer,
         scheduler=scheduler,
         loss_fn=loss_fn,
+        smooth_factor=cfg.smooth_factor,
         epochs=cfg.max_epoch,
         threshold=cfg.threshold,
         save_dir=save_dir,
         save_every=cfg.save_every,
+        valid_every=cfg.valid_every,
         wandb_id=cfg.wandb_id,
         wandb_name=cfg.wandb_name,
         resume=cfg.resume,
diff --git a/sam2_unet/trainer.py b/sam2_unet/trainer.py
index 58f7f41..071838e 100644
--- a/sam2_unet/trainer.py
+++ b/sam2_unet/trainer.py
@@ -20,10 +20,12 @@ def __init__(
         optimizer,
         scheduler,
         loss_fn,
+        smooth_factor,
         epochs,
         threshold,
         save_dir,
         save_every,
+        valid_every,
         wandb_id,
         wandb_name,
         resume=False,
@@ -37,10 +39,12 @@ def __init__(
         self.optimizer = optimizer
         self.scheduler = scheduler
         self.loss_fn = loss_fn
+        self.smooth_factor = smooth_factor
         self.epochs = epochs
         self.threshold = threshold
         self.save_dir = save_dir
         self.save_every = save_every
+        self.valid_every = valid_every
         self.wandb_id = wandb_id
         self.wandb_name = wandb_name
         self.resume = resume
@@ -80,16 +84,18 @@ def train(self, train_loader: DataLoader):
             images, masks = images.to(self.device), masks.to(self.device)
             self.optimizer.zero_grad()
 
-            with torch.cuda.amp.autocast():
-                pred0, pred1, pred2 = self.model(images)
-                loss0 = self.loss_fn(pred0, masks)
-                loss1 = self.loss_fn(pred1, masks)
-                loss2 = self.loss_fn(pred2, masks)
-                loss = loss0 + loss1 + loss2
-
-            self.scaler.scale(loss).backward()
-            self.scaler.step(self.optimizer)
-            self.scaler.update()
+            # with torch.cuda.amp.autocast():
+            pred0, pred1, pred2 = self.model(images)
+            loss0 = self.loss_fn(pred0, masks, self.smooth_factor)
+            loss1 = self.loss_fn(pred1, masks, self.smooth_factor)
+            loss2 = self.loss_fn(pred2, masks, self.smooth_factor)
+            loss = loss0 + loss1 + loss2
+
+            # self.scaler.scale(loss).backward()
+            # self.scaler.step(self.optimizer)
+            # self.scaler.update()
+            loss.backward()
+            self.optimizer.step()
             
             train_loss += loss.item() * masks.shape[0]
 
@@ -129,7 +135,7 @@ def validate(self, valid_loader: DataLoader) -> tuple[float, float]:
                 if output_h != mask_h or output_w != mask_w:
                     outputs = F.interpolate(outputs, size=(mask_h, mask_w), mode="bilinear")
             
-                loss = self.loss_fn(outputs, masks)
+                loss = self.loss_fn(outputs, masks, self.smooth_factor)
                 valid_loss += loss.item() * masks.shape[0]
 
                 outputs = torch.sigmoid(outputs)
@@ -180,8 +186,9 @@ def do_train(self) -> None:
             train_loss = train_loss / len(self.train_loader.dataset)
 
             torch.cuda.empty_cache()
-            valid_loss, valid_dice = self.validate(self.valid_loader)
-            valid_loss = valid_loss / len(self.valid_loader.dataset)
+            if epoch % self.valid_every == 0:
+                valid_loss, valid_dice = self.validate(self.valid_loader)
+                valid_loss = valid_loss / len(self.valid_loader.dataset)
 
             if isinstance(self.scheduler, ReduceLROnPlateau):
                 self.scheduler.step(valid_loss)
diff --git a/sam2_unet/utils/checkpoint.py b/sam2_unet/utils/checkpoint.py
index 22db4db..fe86cf8 100644
--- a/sam2_unet/utils/checkpoint.py
+++ b/sam2_unet/utils/checkpoint.py
@@ -12,10 +12,10 @@ def save_checkpoint(model, optimizer, scheduler, epoch, loss, filepath):
 
 def load_checkpoint(filepath, model, optimizer, scheduler):
     checkpoint = torch.load(filepath, map_location='cpu')
-    epoch = checkpoint['epoch']
     model.load_state_dict(checkpoint['model_state_dict'])
     optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
     scheduler.load_state_dice(checkpoint['scheduler_state_dict'])
+    epoch = checkpoint['epoch']
     loss = checkpoint['loss']
 
-    return epoch, model, optimizer, scheduler, loss
\ No newline at end of file
+    return model, optimizer, scheduler, epoch, loss
\ No newline at end of file
diff --git a/sam2_unet/utils/loss.py b/sam2_unet/utils/loss.py
index 4c8e8ad..4a66c21 100644
--- a/sam2_unet/utils/loss.py
+++ b/sam2_unet/utils/loss.py
@@ -1,7 +1,8 @@
 import torch
 import torch.nn.functional as F
 
-def structure_loss(pred, mask):
+def structure_loss(pred, mask, smooth_factor=0):
+    mask = mask * (1 - smooth_factor) + smooth_factor / 29
     weit = 1 + 5*torch.abs(F.avg_pool2d(mask, kernel_size=31, stride=1, padding=15) - mask)
     wbce = F.binary_cross_entropy_with_logits(pred, mask, reduce='none')
     wbce = (weit*wbce).sum(dim=(2, 3)) / weit.sum(dim=(2, 3))
diff --git a/sam2_unet/utils/transform.py b/sam2_unet/utils/transform.py
index b8f000d..9de2176 100644
--- a/sam2_unet/utils/transform.py
+++ b/sam2_unet/utils/transform.py
@@ -1,19 +1,5 @@
 import albumentations as A
 
-"""
-augmentation list
-
-A.HorizontalFlip(p=0.5)
-A.Rotate(limit=(-10, 10), border_mode=cv2.BORDER_CONSTANT, value=(255, 255, 255), p=0.5)
-A.CLAHE(clip_limit=4.0, tile_grid_size=(8, 8), always_apply=None, p=0.5)
-A.ColorJitter(brightness=(0.8, 1.2), contrast=(0.8, 1.2), saturation=(0.8, 1.2), hue=(-0.5, 0.5), p=0.5, always_apply=None)
-A.GaussNoise(var_limit=None, mean=None, std_range=(0.2, 0.44), mean_range=(0.0, 0.0), per_channel=True, noise_scale_factor=1, always_apply=None, p=0.5)
-A.RandomBrightnessContrast(brightness_limit=(-0.2, 0.2), contrast_limit=(-0.2, 0.2), brightness_by_max=True, ensure_safe_range=False, always_apply=None, p=0.5),
-A.Morphological(scale=(2, 3), operation='dilation' or 'erosion', p=0.5, always_apply=None)
-A.PixelDropout(dropout_prob=0.01, per_channel=False, drop_value=0, mask_drop_value=None, p=0.5, always_apply=None)
-A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0, normalization='standard', always_apply=None, p=1.0)
-
-"""
 class TransformSelector:
     def __init__(self, image_size, ):
         self.common_transform = [A.Resize(image_size, image_size)]
@@ -23,8 +9,8 @@ def get_transform(self, is_train=True):
             transform = A.Compose(
                 [
                     A.HorizontalFlip(p=0.2),
-                    A.Rotate((-15, 15), p=0.5),
-                    A.ColorJitter()
+                    A.ColorJitter(),
+                    A.Rotate((-15, 15), p=0.5)
                 ]+ self.common_transform)
         else:
             transform = A.Compose(self.common_transform)

From d6f21271b225bfaf753a7329329d9736e681ce14 Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Tue, 26 Nov 2024 14:43:57 +0900
Subject: [PATCH 075/106] [Refactor] : refactoring

---
 sam2_unet/config.yaml         | 13 ++++-----
 sam2_unet/test.py             | 16 ++++++-----
 sam2_unet/train.py            |  3 --
 sam2_unet/trainer.py          | 52 +++++++++++++++++++++--------------
 sam2_unet/utils/checkpoint.py | 10 +++----
 5 files changed, 50 insertions(+), 44 deletions(-)

diff --git a/sam2_unet/config.yaml b/sam2_unet/config.yaml
index 41855ab..2f45fda 100644
--- a/sam2_unet/config.yaml
+++ b/sam2_unet/config.yaml
@@ -1,6 +1,6 @@
 # paths
-train_image_path: /data/ephemeral/home/data_v2/train/DCM
-train_mask_path: /data/ephemeral/home/data_v2/train/outputs_json
+train_image_path: /data/ephemeral/home/data/train/DCM
+train_mask_path: /data/ephemeral/home/data/train/outputs_json
 test_image_path: /data/ephemeral/home/data/test/DCM
 hiera_path: /data/ephemeral/home/sam2_hiera_large.pt
 
@@ -17,9 +17,11 @@ threshold: 0.5
 valid_every: 2
 
 # hyperparameter
+random_seed: 2024
 lr: 2e-4
 max_epoch: 40
 smooth_factor: 0
+scaler: False
 
 # optimizer
 optimizer: adamw
@@ -45,10 +47,6 @@ scheduler_parameters:
   # factor: 0.1
   # patience: 5
 
-
-# random seed 
-random_seed: 2024
-
 # save
 save_every: 5
 
@@ -61,5 +59,4 @@ wandb_id:
 
 # resume
 resume: False
-ckpt_path: ./checkpoints/
-start_epoch: 0
\ No newline at end of file
+ckpt_path: ./checkpoints/checkpoint.pth
\ No newline at end of file
diff --git a/sam2_unet/test.py b/sam2_unet/test.py
index bd29410..3bc4d9c 100644
--- a/sam2_unet/test.py
+++ b/sam2_unet/test.py
@@ -1,13 +1,12 @@
-import argparse
 import os
-import torch
+import argparse
 import numpy as np
 import pandas as pd
+import torch
 import torch.nn.functional as F
 from torch.utils.data import DataLoader
 from utils.dataset import TestDataset
 from utils.transform import TransformSelector
-from utils.checkpoint import load_checkpoint
 from tqdm.auto import tqdm
 from SAM2UNet import SAM2UNet
 
@@ -17,6 +16,7 @@
 parser.add_argument("--test_image_path", type=str, default="/data/ephemeral/home/data/test/DCM",
                     help="path to the image files for testing")
 parser.add_argument("--image_size", type=int, default=1024)
+parser.add_argument("--save_file", type=str, default='output.csv')
 args = parser.parse_args()
 
 def encode_mask_to_rle(mask):
@@ -69,7 +69,6 @@ def test(model, args, thr=0.5):
         batch_size=2,
         shuffle=False,
         num_workers=2,
-        drop_last=False
     )
 
     model.eval()
@@ -108,9 +107,12 @@ def main(args):
         "class": classes,
         "rle": rles,
     })
-    df.to_csv("./outputs/output.csv", index=False)
+    
+    save_file = args.save_file
+    if len(save_file) < 5 or save_file[-4:] != '.csv':
+        save_file += '.csv'
+    save_path = os.path.join('./outputs', save_file)
+    df.to_csv(save_path, index=False)
 
 if __name__ == "__main__":
     main(args)
-
-# python test.py --checkpoint <checkpoint_path>  
diff --git a/sam2_unet/train.py b/sam2_unet/train.py
index 4dc0605..f0f4cf4 100644
--- a/sam2_unet/train.py
+++ b/sam2_unet/train.py
@@ -76,7 +76,6 @@ def main(cfg):
     # Config 저장
     save_path = os.path.join(save_dir, "config.yaml")
     OmegaConf.save(cfg, save_path)
-
     print(f"Config saved at {save_path}")
 
     trainer = Trainer(
@@ -97,9 +96,7 @@ def main(cfg):
         wandb_name=cfg.wandb_name,
         resume=cfg.resume,
         ckpt_path=cfg.ckpt_path,
-        start_epoch=cfg.start_epoch
     )
-
     trainer.do_train()
     
 if __name__ == "__main__":
diff --git a/sam2_unet/trainer.py b/sam2_unet/trainer.py
index 071838e..5155417 100644
--- a/sam2_unet/trainer.py
+++ b/sam2_unet/trainer.py
@@ -23,14 +23,14 @@ def __init__(
         smooth_factor,
         epochs,
         threshold,
+        scaler,
         save_dir,
         save_every,
         valid_every,
         wandb_id,
         wandb_name,
         resume=False,
-        ckpt_path="",
-        start_epoch=0
+        ckpt_path=""
         ):
         self.model = model
         self.device = device
@@ -49,8 +49,11 @@ def __init__(
         self.wandb_name = wandb_name
         self.resume = resume
         self.ckpt_file = ckpt_path
-        self.start_epoch = start_epoch
-        self.scaler = torch.cuda.amp.GradScaler()
+        self.start_epoch = 0
+        if scaler:
+            self.scaler = torch.cuda.amp.GradScaler()
+        else:
+            self.scaler = None
         self.classes = [
             'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
             'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
@@ -61,9 +64,9 @@ def __init__(
         ]
 
     def save_checkpoint_epoch(self, epoch: int, valid_loss: float, valid_dice: float) -> None:
-        ckpt_path = os.path.join(self.save_dir, f'epoch-{epoch + 1}-loss-{valid_loss:.4f}-dice-{valid_dice:.4f}.pth')
-        save_checkpoint(self.model, self.optimizer, self.scheduler, epoch+1, valid_dice, ckpt_path)
-        print(f"Checkpoint updated at epoch {epoch + 1} and saved as {ckpt_path}")
+        ckpt_path = os.path.join(self.save_dir, f'epoch-{epoch+1}-loss-{valid_loss:.4f}-dice-{valid_dice:.4f}.pth')
+        save_checkpoint(ckpt_path, self.model, self.optimizer, self.scheduler, epoch+1)
+        print(f"Checkpoint updated at epoch {epoch+1} and saved as {ckpt_path}")
     
     def dice_coef(self, y_true, y_pred):
         y_true_f = y_true.flatten(2)
@@ -84,18 +87,27 @@ def train(self, train_loader: DataLoader):
             images, masks = images.to(self.device), masks.to(self.device)
             self.optimizer.zero_grad()
 
-            # with torch.cuda.amp.autocast():
-            pred0, pred1, pred2 = self.model(images)
-            loss0 = self.loss_fn(pred0, masks, self.smooth_factor)
-            loss1 = self.loss_fn(pred1, masks, self.smooth_factor)
-            loss2 = self.loss_fn(pred2, masks, self.smooth_factor)
-            loss = loss0 + loss1 + loss2
-
-            # self.scaler.scale(loss).backward()
-            # self.scaler.step(self.optimizer)
-            # self.scaler.update()
-            loss.backward()
-            self.optimizer.step()
+            if self.scaler:
+                with torch.cuda.amp.autocast():
+                    pred0, pred1, pred2 = self.model(images)
+                    loss0 = self.loss_fn(pred0, masks, self.smooth_factor)
+                    loss1 = self.loss_fn(pred1, masks, self.smooth_factor)
+                    loss2 = self.loss_fn(pred2, masks, self.smooth_factor)
+                    loss = loss0 + loss1 + loss2
+
+                self.scaler.scale(loss).backward()
+                self.scaler.step(self.optimizer)
+                self.scaler.update()
+
+            if not self.scaler:
+                pred0, pred1, pred2 = self.model(images)
+                loss0 = self.loss_fn(pred0, masks, self.smooth_factor)
+                loss1 = self.loss_fn(pred1, masks, self.smooth_factor)
+                loss2 = self.loss_fn(pred2, masks, self.smooth_factor)
+                loss = loss0 + loss1 + loss2
+                
+                loss.backward()
+                self.optimizer.step()
             
             train_loss += loss.item() * masks.shape[0]
 
@@ -216,7 +228,7 @@ def do_train(self) -> None:
     def load_settings(self) -> None:
         print("loading prev training setttings")
         try:
-            self.epochs, self.model, self.optimizer, self.scheduler, self.loss = load_checkpoint(self.ckpt_path, self.model, self.optimizer, self.scheduler)
+            self.model, self.optimizer, self.scheduler, self.start_epochs = load_checkpoint(self.ckpt_path, self.model, self.optimizer, self.scheduler)
             print("loading successful")
         except:
             raise Exception('loading failed')
\ No newline at end of file
diff --git a/sam2_unet/utils/checkpoint.py b/sam2_unet/utils/checkpoint.py
index fe86cf8..4f6fe1d 100644
--- a/sam2_unet/utils/checkpoint.py
+++ b/sam2_unet/utils/checkpoint.py
@@ -1,21 +1,19 @@
 import torch
 
-def save_checkpoint(model, optimizer, scheduler, epoch, loss, filepath):
+def save_checkpoint(filepath, model, optimizer, scheduler, epoch):
     checkpoint = {
-        'epoch': epoch,
         'model_state_dict': model.state_dict(),
         'optimizer_state_dict': optimizer.state_dict(),
         'scheduler_state_dict': scheduler.state_dict(),
-        'loss': loss
+        'epoch': epoch
     }
     torch.save(checkpoint, filepath) 
 
 def load_checkpoint(filepath, model, optimizer, scheduler):
-    checkpoint = torch.load(filepath, map_location='cpu')
+    checkpoint = torch.load(filepath)
     model.load_state_dict(checkpoint['model_state_dict'])
     optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
     scheduler.load_state_dice(checkpoint['scheduler_state_dict'])
     epoch = checkpoint['epoch']
-    loss = checkpoint['loss']
 
-    return model, optimizer, scheduler, epoch, loss
\ No newline at end of file
+    return model, optimizer, scheduler, epoch
\ No newline at end of file

From d514d4d2a9a3912d5ce2d78b40c9e9ea610a6486 Mon Sep 17 00:00:00 2001
From: wonjeongjeong <wj3714@naver.com>
Date: Tue, 26 Nov 2024 21:54:02 +0900
Subject: [PATCH 076/106] [#37] Feature : stratified group k-fold

---
 meta_data_set.py       | 62 ++++++++++++++++++++++++++++++++++++++++++
 module_base/dataset.py | 25 +++++++++++------
 2 files changed, 79 insertions(+), 8 deletions(-)
 create mode 100644 meta_data_set.py

diff --git a/meta_data_set.py b/meta_data_set.py
new file mode 100644
index 0000000..e998a51
--- /dev/null
+++ b/meta_data_set.py
@@ -0,0 +1,62 @@
+import numpy as np
+import pandas as pd
+import os
+
+### 아래 세 개의 경로 맞는지 확인해주세요 !!! ###
+excel_file = "meta_data.xlsx"
+test_dir = "data/ephemeral/home/data/test/DCM/"
+train_dir = "data/ephemeral/home/data/train/DCM/"
+
+df = pd.read_excel(excel_file)
+counts = len(df)
+
+columns_to_initialize = {
+    "train": 1,         # 기본값 1
+    "rotate": 0,        # 기본값 0
+    "image_path": None  # 기본값 None
+}
+
+# 열 추가 또는 초기화
+for i, (column, default_value) in enumerate(columns_to_initialize.items()):
+    if column not in df.columns:
+        # 열이 없으면 삽입
+        df.insert(4 + i + 1, column, default_value)
+    else:
+        # 열이 있으면 초기화
+        df[column] = default_value
+
+# test 데이터 ID*** 폴더 목록 가져오기
+existing_folders = [f for f in os.listdir(test_dir) if f.startswith("ID") and f[2:].isdigit()]
+# ID274~ID319 + ID321
+ids_to_update = list(range(274, 320)) + [321]
+
+# 폴더 이름에서 숫자 부분 추출 및 -1 인덱스 처리
+indices_to_update_train = [int(folder[2:]) - 1 for folder in existing_folders]
+# -1 인덱스 처리
+indices_to_update_rotate = [id_num - 1 for id_num in ids_to_update]
+
+# train 컬럼 값을 0으로 변경
+df.loc[indices_to_update_train, "train"] = 0
+# rotate 컬럼 값을 1로 변경
+df.loc[indices_to_update_rotate, "rotate"] = 1
+
+def get_image_paths(row):
+    folder_id = f"ID{row.name + 1:03d}"  # 인덱스 + 1을 ID*** 형식으로 변환
+    base_dir = test_dir if row["train"] == 0 else train_dir  # 디렉토리 선택
+    folder_path = os.path.join(base_dir, folder_id)
+    try:
+        images = [os.path.join(folder_path, f) for f in os.listdir(folder_path) if f.endswith(".png")]
+        right_image = images[0]
+        left_image = images[1]
+        return [left_image, right_image]
+    except FileNotFoundError:  # 제외된 메타데이터일 때
+        return [None, None]
+    
+# image_path 업데이트
+df["image_path"] = df.apply(get_image_paths, axis=1)
+
+# 변경된 데이터프레임 저장
+output_path = "update_meta_data.xlsx"
+df.to_excel(output_path, index=False)
+
+print("작업 완료!")
\ No newline at end of file
diff --git a/module_base/dataset.py b/module_base/dataset.py
index a7ebebd..007b0e8 100644
--- a/module_base/dataset.py
+++ b/module_base/dataset.py
@@ -4,8 +4,9 @@
 import cv2
 import numpy as np
 import torch
+import pandas as pd
 from torch.utils.data import Dataset
-from sklearn.model_selection import GroupKFold
+from sklearn.model_selection import StratifiedGroupKFold
 
 CLASSES = [
     'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
@@ -29,10 +30,18 @@ def __init__(self, fnames, labels, image_root, label_root, kfold=0, transforms=N
         
         groups = [os.path.dirname(fname) for fname in fnames]
         
+        meta_data = pd.read_excel('update_meta_data.xlsx')
+        
         # dummy label
-        ys = [0 for fname in fnames]
+        ys = []
+        for fname in fnames:
+            folder_name = os.path.dirname(fname)
+            id_number = int(folder_name[2:])
+            
+            row = meta_data.iloc[id_number - 1]
+            ys.append(row['rotate'])
         
-        gkf = GroupKFold(n_splits=5)
+        gkf = StratifiedGroupKFold(n_splits=5)
         
         filenames = []
         labelnames = []
@@ -44,11 +53,11 @@ def __init__(self, fnames, labels, image_root, label_root, kfold=0, transforms=N
                 labelnames += list(labels[y])
             
             else:  # k번은 검증
-                if i != self.kfold:
-                    continue
-                filenames = list(fnames[y])
-                labelnames = list(labels[y])
-        
+                if i == self.kfold:
+                    filenames = list(fnames[y])
+                    labelnames = list(labels[y])
+                    break
+                
         self.filenames = filenames
         self.labelnames = labelnames
     

From 9fb6505d88974b97df2af3f9d0c72884f75dfaa9 Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Wed, 27 Nov 2024 10:24:31 +0900
Subject: [PATCH 077/106] [Refactor] : loss, dice

---
 sam2_unet/train.py           | 1 +
 sam2_unet/trainer.py         | 4 ++--
 sam2_unet/utils/transform.py | 2 +-
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/sam2_unet/train.py b/sam2_unet/train.py
index f0f4cf4..476a79b 100644
--- a/sam2_unet/train.py
+++ b/sam2_unet/train.py
@@ -89,6 +89,7 @@ def main(cfg):
         smooth_factor=cfg.smooth_factor,
         epochs=cfg.max_epoch,
         threshold=cfg.threshold,
+        scaler=cfg.scaler,
         save_dir=save_dir,
         save_every=cfg.save_every,
         valid_every=cfg.valid_every,
diff --git a/sam2_unet/trainer.py b/sam2_unet/trainer.py
index 5155417..e7d5cca 100644
--- a/sam2_unet/trainer.py
+++ b/sam2_unet/trainer.py
@@ -188,10 +188,10 @@ def do_train(self) -> None:
         print(f"training start")
 
         self.model.to(self.device)
+        train_loss, train_dice = 0., 0.
+        train_dice, valid_dice = 0., 0.
         for epoch in range(self.start_epoch, self.epochs):
             epoch_start = time.time()
-            train_loss, train_dice = 0., 0.
-            train_dice, valid_dice = 0., 0.
             print(f"Epoch {epoch+1}/{self.epochs}")
             
             train_loss, train_dice = self.train(self.train_loader)
diff --git a/sam2_unet/utils/transform.py b/sam2_unet/utils/transform.py
index 9de2176..02150e1 100644
--- a/sam2_unet/utils/transform.py
+++ b/sam2_unet/utils/transform.py
@@ -8,7 +8,7 @@ def get_transform(self, is_train=True):
         if is_train:
             transform = A.Compose(
                 [
-                    A.HorizontalFlip(p=0.2),
+                    # A.HorizontalFlip(p=0.2),
                     A.ColorJitter(),
                     A.Rotate((-15, 15), p=0.5)
                 ]+ self.common_transform)

From c3fc3c0cd8da9b491ff0b5de7f0aa501ae185c55 Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Wed, 27 Nov 2024 11:13:10 +0900
Subject: [PATCH 078/106] [Feature]: add dataset for cleansed data.

---
 mmsegmentation/baseline.py                    |  21 ++-
 .../_baseline_/config_for_this_example.py     |  46 +++---
 .../_custom_/_base_/cleansed_xraydata2.py     | 141 ++++++++++++++++++
 .../configs/_custom_/_base_/schedule_160k.py  |   4 +-
 .../configs/_custom_/upernet/upernet_hr48.py  |  14 +-
 .../configs/_custom_/upernet/upernet_hr_18.py |  92 ++++++++++++
 .../_custom_/upernet/upernet_swin-T.py        | 106 +++++++++++++
 .../mmseg/datasets/transforms/transforms.py   |  12 +-
 mmsegmentation/mmseg/datasets/xray2.py        |   6 +-
 streamlit/main.py                             |   6 +-
 10 files changed, 401 insertions(+), 47 deletions(-)
 create mode 100644 mmsegmentation/configs/_custom_/_base_/cleansed_xraydata2.py
 create mode 100644 mmsegmentation/configs/_custom_/upernet/upernet_hr_18.py
 create mode 100644 mmsegmentation/configs/_custom_/upernet/upernet_swin-T.py

diff --git a/mmsegmentation/baseline.py b/mmsegmentation/baseline.py
index c76dec5..28da90c 100644
--- a/mmsegmentation/baseline.py
+++ b/mmsegmentation/baseline.py
@@ -5,11 +5,11 @@
 ##############################
 # 데이터 경로를 입력하세요
 
-CONFIG_PATH = "/data/ephemeral/home/parkjunil/level2-cv-semanticsegmentation-cv-19-lv3/mmsegmentation/configs/_custom_/hrnet/fcn_hr18s_4xb2-40k_cityscapes-512x1024.py"
-CHECKPOINT_PATH = "/data/ephemeral/home/parkjunil/work_dir/baseline_dice_1480_hflip/best_mDice_iter_16000.pth"
+CONFIG_PATH = "/data/ephemeral/home/parkjunil/level2-cv-semanticsegmentation-cv-19-lv3/mmsegmentation/configs/_baseline_/config_for_this_example.py"
+CHECKPOINT_PATH = "/data/ephemeral/home/parkjunil/work_dir/hrnet18_upernet_2048_elas_rotate_hflip_whole/best_mDice_iter_18000.pth"
 SUBMISSION_PATH = "/data/ephemeral/home/submission"
-WORK_DIR = "/data/ephemeral/home/parkjunil/work_dir/hrnet18_fpn_2048_noaug"
-TTA = True
+WORK_DIR = "/data/ephemeral/home/parkjunil/work_dir/hrnet18_upernet_2048_elas_rotate_hflip_whole_inference"
+TTA = False
 
 
 def load_config():
@@ -25,6 +25,7 @@ def load_config():
 def train():
     # load config
     cfg =load_config()
+    # cfg.load_from = CHECKPOINT_PATH
     runner = Runner.from_cfg(cfg)
 
     # start training
@@ -39,10 +40,20 @@ def inference():
         cfg.tta_model.module = cfg.model
         cfg.model = cfg.tta_model
     
+    # inference시에는 wandb 비활성화
+    cfg.vis_backends = [dict(type='LocalVisBackend')]
+    cfg.log_config = dict(
+        interval=1,
+        hooks=[
+            dict(type='TextLoggerHook', by_epoch=False)
+        ]
+        )
+    
     
     runner = Runner.from_cfg(cfg)
     runner.test()
 
 
 if __name__ == "__main__":
-    train()
\ No newline at end of file
+    train()
+    # inference()
\ No newline at end of file
diff --git a/mmsegmentation/configs/_baseline_/config_for_this_example.py b/mmsegmentation/configs/_baseline_/config_for_this_example.py
index 8e0c264..319afc9 100644
--- a/mmsegmentation/configs/_baseline_/config_for_this_example.py
+++ b/mmsegmentation/configs/_baseline_/config_for_this_example.py
@@ -1,7 +1,7 @@
 # Train Segformer Mit B3
 _base_ = [
     "../_base_/models/segformer_mit-b0.py",
-    "../_custom_/_base_/xraydata2.py",
+    "../_custom_/_base_/cleansed_xraydata2.py",
     "../_custom_/_base_/schedule_160k.py",
     "../_custom_/_base_/default_runtime.py"
 ]
@@ -39,31 +39,31 @@
             dict(
                 type='DiceLoss',
                 use_sigmoid=True,
-                loss_weight=1.0
+                loss_weight=3.0
             )
         ]
     ),
 )
 
-# optimizer
-optimizer = dict(type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
+# # optimizer
+# optimizer = dict(type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01)
+# optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
 
-# learning policy
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500
-    ),
-    dict(
-        type='PolyLR',
-        eta_min=0.0,
-        power=1.0,
-        begin=1500,
-        end=20000,
-        by_epoch=False,
-    )
-]
-# training schedule for 20k
-train_cfg = dict(type='IterBasedTrainLoop', max_iters=20000, val_interval=2000)
-val_cfg = dict(type='ValLoop')
-test_cfg = dict(type='TestLoop')
\ No newline at end of file
+# # learning policy
+# param_scheduler = [
+#     dict(
+#         type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500
+#     ),
+#     dict(
+#         type='PolyLR',
+#         eta_min=0.0,
+#         power=1.0,
+#         begin=1500,
+#         end=20000,
+#         by_epoch=False,
+#     )
+# ]
+# # training schedule for 20k
+# train_cfg = dict(type='IterBasedTrainLoop', max_iters=20000, val_interval=2000)
+# val_cfg = dict(type='ValLoop')
+# test_cfg = dict(type='TestLoop')
\ No newline at end of file
diff --git a/mmsegmentation/configs/_custom_/_base_/cleansed_xraydata2.py b/mmsegmentation/configs/_custom_/_base_/cleansed_xraydata2.py
new file mode 100644
index 0000000..e8e820b
--- /dev/null
+++ b/mmsegmentation/configs/_custom_/_base_/cleansed_xraydata2.py
@@ -0,0 +1,141 @@
+IMAGE_SIZE = (1536, 1536)
+IMAGE_ROOT = '/data/ephemeral/home/cleansed_data/train/DCM'
+LABEL_ROOT = '/data/ephemeral/home/cleansed_data/train/outputs_json'
+SUBMISSION_PATH = '/data/ephemeral/home/submission'
+
+# dataset settings
+dataset_type = 'XRayDataset2'
+
+
+train_pipeline = [
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadXRayAnnotations'),
+            dict(type='Resize', scale=IMAGE_SIZE),
+            dict(
+                type='Albu',  # Albumentations를 이용한 변환
+                transforms=[
+                    dict(type='HorizontalFlip', p=0.5),  # 수평 뒤집기
+                    dict(type='ShiftScaleRotate', shift_limit=0.0, scale_limit=0.0, rotate_limit=20, p=0.5),  # 회전
+                    dict(
+                        type='ElasticTransform',  # 탄성 변환
+                        alpha=10,
+                        sigma=100,
+                        p=0.8,
+                    ),
+                ]
+            ),
+            dict(type='TransposeAnnotations'),
+            dict(type='PackSegInputs')
+        ]
+val_pipeline = [
+            dict(type='LoadImageFromFile'),
+            dict(type='Resize', scale=IMAGE_SIZE),
+            dict(type='LoadXRayAnnotations'),
+            dict(type='TransposeAnnotations'),
+            dict(type='PackSegInputs')
+        ]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=IMAGE_SIZE),
+    dict(type='PackSegInputs')
+]
+
+train_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        is_train=True,
+        image_root=IMAGE_ROOT,
+        label_root=LABEL_ROOT,
+        pipeline=train_pipeline
+    )
+    )
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=1,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        is_train=False,
+        image_root=IMAGE_ROOT,
+        label_root=LABEL_ROOT,
+        pipeline=val_pipeline
+    )
+    )
+
+
+test_dataloader = dict(
+    batch_size=1,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='XRayDataset',
+        data_root='/data/ephemeral/home/cityscapes_format_xlay_kfold',
+        data_prefix=dict(img_path='leftImg8bit/test'),
+        img_suffix='.png',
+        pipeline=test_pipeline))
+
+
+val_evaluator = dict(type='DiceMetricForMultiLabel')
+test_evaluator = dict(type='SubmissionMetric', save_path=SUBMISSION_PATH, max_vis_cnt=20)
+
+
+
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(type='Resize', scale=IMAGE_SIZE),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(
+                    type='Albu',  # Albumentations를 이용한 변환
+                    transforms=[
+                        dict(type='HorizontalFlip', p=0.5),  # 수평 뒤집기
+                        dict(type='ShiftScaleRotate', shift_limit=0.0, scale_limit=0.0, rotate_limit=20, p=0.5),  # 회전
+                        dict(
+                            type='ElasticTransform',  # 탄성 변환
+                            alpha=10,
+                            sigma=100,
+                            p=0.8,
+                        ),
+                    ],
+                    keymap={'img': 'image'}
+                ),
+                # dict(
+                #     type='Albu',  # Albumentations를 이용한 변환
+                #     transforms=[
+                #         dict(type='HorizontalFlip', p=0.5),  # 수평 뒤집기
+                #         dict(type='ShiftScaleRotate', shift_limit=0.0, scale_limit=0.0, rotate_limit=20, p=0.5),  # 회전
+                #         dict(
+                #             type='ElasticTransform',  # 탄성 변환
+                #             alpha=10,
+                #             sigma=100,
+                #             p=0.8,
+                #         ),
+                #     ],
+                #     keymap={'img': 'image'}
+                # ),
+                # dict(
+                #     type='Albu',  # Albumentations를 이용한 변환
+                #     transforms=[
+                #         dict(type='HorizontalFlip', p=0.5),  # 수평 뒤집기
+                #         dict(type='ShiftScaleRotate', shift_limit=0.0, scale_limit=0.0, rotate_limit=20, p=0.5),  # 회전
+                #         dict(
+                #             type='ElasticTransform',  # 탄성 변환
+                #             alpha=10,
+                #             sigma=100,
+                #             p=0.8,
+                #         ),
+                #     ],
+                #     keymap={'img': 'image'}
+                # ),
+            ],
+            [dict(type='PackSegInputs')]
+        ])
+]
\ No newline at end of file
diff --git a/mmsegmentation/configs/_custom_/_base_/schedule_160k.py b/mmsegmentation/configs/_custom_/_base_/schedule_160k.py
index bc034a2..13238b4 100644
--- a/mmsegmentation/configs/_custom_/_base_/schedule_160k.py
+++ b/mmsegmentation/configs/_custom_/_base_/schedule_160k.py
@@ -5,12 +5,12 @@
 
 # optimizer
 optimizer = dict(
-    type='AdamW', lr=0.0001, weight_decay=0.05, eps=1e-8, betas=(0.9, 0.999))
+    type='Lion', lr=0.0001, weight_decay=0.05, betas=(0.9, 0.999))
 optim_wrapper = dict(
     type='AmpOptimWrapper',
     optimizer=optimizer,
     clip_grad=dict(max_norm=0.01, norm_type=2),
-    accumulative_counts=1
+    accumulative_counts=4
     )
 
 # mixed precision
diff --git a/mmsegmentation/configs/_custom_/upernet/upernet_hr48.py b/mmsegmentation/configs/_custom_/upernet/upernet_hr48.py
index a5f01a0..e6e269e 100644
--- a/mmsegmentation/configs/_custom_/upernet/upernet_hr48.py
+++ b/mmsegmentation/configs/_custom_/upernet/upernet_hr48.py
@@ -60,8 +60,11 @@
         num_classes=num_classes,
         norm_cfg=norm_cfg,
         align_corners=True,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)),
+        loss_decode=[
+            dict(type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
+            dict(type='DiceLoss', use_sigmoid=True, loss_weight=3.0)
+        ]
+        ),
     auxiliary_head=dict(
         type='FCNHeadWithoutAccuracy',
         in_channels=1024,
@@ -73,8 +76,11 @@
         num_classes=num_classes,
         norm_cfg=norm_cfg,
         align_corners=True,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.4)),
+        loss_decode=[
+            dict(type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.4),
+            dict(type='DiceLoss', use_sigmoid=True, loss_weight=1.0)
+        ]
+        ),
     # model training and testing settings
     
     train_cfg=dict(),
diff --git a/mmsegmentation/configs/_custom_/upernet/upernet_hr_18.py b/mmsegmentation/configs/_custom_/upernet/upernet_hr_18.py
new file mode 100644
index 0000000..c03269d
--- /dev/null
+++ b/mmsegmentation/configs/_custom_/upernet/upernet_hr_18.py
@@ -0,0 +1,92 @@
+_base_ = [
+    '../_base_/cleansed_xraydata2.py',
+    '../_base_/default_runtime.py', '../_base_/schedule_160k.py'
+]
+
+# model settings
+num_classes = 29
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+crop_size = (769, 769)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    size=crop_size,
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+
+model = dict(
+    type='EncoderDecoderWithoutArgmax',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://msra/hrnetv2_w18',
+    backbone=dict(
+        type='HRNet',
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        extra=dict(
+            stage1=dict(
+                num_modules=1,
+                num_branches=1,
+                block='BOTTLENECK',
+                num_blocks=(2, ),
+                num_channels=(64, )),
+            stage2=dict(
+                num_modules=1,
+                num_branches=2,
+                block='BASIC',
+                num_blocks=(2, 2),
+                num_channels=(18, 36)),
+            stage3=dict(
+                num_modules=4,
+                num_branches=3,
+                block='BASIC',
+                num_blocks=(2, 2, 2),
+                num_channels=(18, 36, 72)),
+            stage4=dict(
+                num_modules=3,
+                num_branches=4,
+                block='BASIC',
+                num_blocks=(2, 2, 2, 2),
+                num_channels=(18, 36, 72, 144)))),
+    decode_head=dict(
+        type='UPerHeadWithoutAccuracy',
+        in_channels=[18, 36, 72, 144],
+        in_index=[0, 1, 2, 3],
+        pool_scales=(1, 2, 3, 6),
+        channels=sum([18, 36, 72, 144]),
+        dropout_ratio=0.1,
+        num_classes=num_classes,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        threshold=0.5,
+        loss_decode=[
+            dict(type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
+            dict(type='DiceLoss', use_sigmoid=True, loss_weight=3.0)
+        ]
+        ),
+    auxiliary_head=dict(
+        type='FCNHeadWithoutAccuracy',
+        in_channels=[18, 36, 72, 144],
+        in_index=(0, 1, 2, 3),
+        channels=sum([18, 36, 72, 144]),
+        input_transform='resize_concat',
+        kernel_size=1,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=-1,
+        num_classes=num_classes,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=[
+            dict(type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.4),
+            dict(type='DiceLoss', use_sigmoid=True, loss_weight=1.0)
+        ]
+        ),
+    # model training and testing settings
+    
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+
+
+train_dataloader = dict(batch_size = 2)
\ No newline at end of file
diff --git a/mmsegmentation/configs/_custom_/upernet/upernet_swin-T.py b/mmsegmentation/configs/_custom_/upernet/upernet_swin-T.py
new file mode 100644
index 0000000..d8090f0
--- /dev/null
+++ b/mmsegmentation/configs/_custom_/upernet/upernet_swin-T.py
@@ -0,0 +1,106 @@
+_base_ = [
+    '../_base_/cleansed_xraydata2.py',
+    '../_base_/default_runtime.py', '../_base_/schedule_160k.py'
+]
+
+num_classes = 29
+crop_size = (512, 512)
+checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_tiny_patch4_window7_224_20220317-1cdeb081.pth'  # noqa
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+backbone_norm_cfg = dict(type='LN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    size=crop_size,
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+
+
+model = dict(
+    type='EncoderDecoderWithoutArgmax',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        type='SwinTransformer',
+        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file),
+        pretrain_img_size=224,
+        embed_dims=96,
+        patch_size=4,
+        window_size=7,
+        mlp_ratio=4,
+        depths=[2, 2, 6, 2],
+        num_heads=[3, 6, 12, 24],
+        strides=(4, 2, 2, 2),
+        out_indices=(0, 1, 2, 3),
+        qkv_bias=True,
+        qk_scale=None,
+        patch_norm=True,
+        drop_rate=0.,
+        attn_drop_rate=0.,
+        drop_path_rate=0.3,
+        use_abs_pos_embed=False,
+        act_cfg=dict(type='GELU'),
+        norm_cfg=backbone_norm_cfg),
+    decode_head=dict(
+        type='UPerHeadWithoutAccuracy',
+        in_channels=[96, 192, 384, 768],
+        in_index=[0, 1, 2, 3],
+        pool_scales=(1, 2, 3, 6),
+        channels=512,
+        dropout_ratio=0.1,
+        num_classes=num_classes,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHeadWithoutAccuracy',
+        in_channels=384,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=num_classes,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+
+
+# AdamW optimizer, no weight decay for position embedding & layer norm
+# in backbone
+max_epochs = 20000
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
+    paramwise_cfg=dict(
+        custom_keys={
+            'absolute_pos_embed': dict(decay_mult=0.),
+            'relative_position_bias_table': dict(decay_mult=0.),
+            'norm': dict(decay_mult=0.)
+        }))
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type='PolyLR',
+        eta_min=0.0,
+        power=1.0,
+        begin=1500,
+        end=max_epochs,
+        by_epoch=False,
+    )
+]
+
+# By default, models are trained on 8 GPUs with 2 images per GPU
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=1)
\ No newline at end of file
diff --git a/mmsegmentation/mmseg/datasets/transforms/transforms.py b/mmsegmentation/mmseg/datasets/transforms/transforms.py
index e4dc928..6c37e57 100644
--- a/mmsegmentation/mmseg/datasets/transforms/transforms.py
+++ b/mmsegmentation/mmseg/datasets/transforms/transforms.py
@@ -2359,7 +2359,7 @@ def __init__(self,
         self.bgr_to_rgb = bgr_to_rgb
 
         self.aug = Compose([self.albu_builder(t) for t in self.transforms],
-                           additional_targets=self.additional_targets, is_check_shapes=False)
+                           additional_targets=self.additional_targets, is_check_shapes=True, strict=False)
 
         if not keymap:
             self.keymap_to_albu = {'img': 'image', 'gt_seg_map': 'mask'}
@@ -2434,14 +2434,8 @@ def transform(self, results):
                         results[key] = cv2.cvtColor(results[key],
                                                     cv2.COLOR_BGR2RGB)
 
-        # Apply Transform
-        target_keys = ['image', 'mask']
-        filtered_dict = {key: results[key] for key in target_keys if key in results}
-        filtered_dict = self.aug(**filtered_dict)
-        
-        for k in target_keys:
-            results[k] = filtered_dict[k]
-        del filtered_dict
+        # # Apply Transform
+        results = self.aug(**results)
         
 
         # Convert back to BGR
diff --git a/mmsegmentation/mmseg/datasets/xray2.py b/mmsegmentation/mmseg/datasets/xray2.py
index f25c357..5be6e43 100644
--- a/mmsegmentation/mmseg/datasets/xray2.py
+++ b/mmsegmentation/mmseg/datasets/xray2.py
@@ -23,6 +23,7 @@
 
 CLASS2IND = {v: i for i, v in enumerate(CLASSES)}
 IND2CLASS = {v: k for k, v in CLASS2IND.items()}
+val_fold_num = 2
 
 
 @DATASETS.register_module()
@@ -78,13 +79,16 @@ def load_data_list(self):
         labelnames = []
         for i, (x, y) in enumerate(gkf.split(_filenames, ys, groups)):
             if self.is_train:
-                if i == 0:
+                if i == val_fold_num:
                     continue
 
                 filenames += list(_filenames[y])
                 labelnames += list(_labelnames[y])
 
             else:
+                if i != val_fold_num:
+                    continue
+                
                 filenames = list(_filenames[y])
                 labelnames = list(_labelnames[y])
 
diff --git a/streamlit/main.py b/streamlit/main.py
index dca9b85..fadf1e0 100644
--- a/streamlit/main.py
+++ b/streamlit/main.py
@@ -8,9 +8,9 @@
 
 
 info = {
-    'image_root': "../../data/{}/DCM",
-    'all_image_root': "../../data/test/DCM/all_pngs",
-    'label_root': "../../data/train/outputs_json",
+    'image_root': "/data/ephemeral/home/cleansed_data/train/DCM",
+    'all_image_root': "/data/ephemeral/home/all_pngs",
+    'label_root': "/data/ephemeral/home/cleansed_data/train/outputs_json",
     'classes': [
         'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
         'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',

From 65892f7ff16f62ec36c1c9fad05c7fae975c1cae Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Wed, 27 Nov 2024 15:04:56 +0900
Subject: [PATCH 079/106] =?UTF-8?q?[Refactor]=20:=20dataset=20=EC=BD=94?=
 =?UTF-8?q?=EB=93=9C=20=ED=9A=A8=EC=9C=A8=EC=A0=81=EC=9C=BC=EB=A1=9C=20?=
 =?UTF-8?q?=EC=88=98=EC=A0=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 sam2_unet/config.yaml      |  10 +-
 sam2_unet/test.py          |  66 +++++++-----
 sam2_unet/train.py         |  36 ++++---
 sam2_unet/trainer.py       |   7 +-
 sam2_unet/utils/dataset.py | 209 +++++++++++++------------------------
 5 files changed, 140 insertions(+), 188 deletions(-)

diff --git a/sam2_unet/config.yaml b/sam2_unet/config.yaml
index 2f45fda..8bb3ede 100644
--- a/sam2_unet/config.yaml
+++ b/sam2_unet/config.yaml
@@ -1,7 +1,6 @@
 # paths
-train_image_path: /data/ephemeral/home/data/train/DCM
-train_mask_path: /data/ephemeral/home/data/train/outputs_json
-test_image_path: /data/ephemeral/home/data/test/DCM
+train_data_path: /data/ephemeral/home/data/train
+test_data_path: /data/ephemeral/home/data/test
 hiera_path: /data/ephemeral/home/sam2_hiera_large.pt
 
 # train
@@ -16,6 +15,11 @@ k: 0
 threshold: 0.5
 valid_every: 2
 
+# test
+test_batch_size: 2
+test_num_workers: 2
+save_file: output.csv
+
 # hyperparameter
 random_seed: 2024
 lr: 2e-4
diff --git a/sam2_unet/test.py b/sam2_unet/test.py
index 3bc4d9c..87bfb1e 100644
--- a/sam2_unet/test.py
+++ b/sam2_unet/test.py
@@ -1,23 +1,25 @@
 import os
-import argparse
+import random
 import numpy as np
 import pandas as pd
 import torch
 import torch.nn.functional as F
 from torch.utils.data import DataLoader
-from utils.dataset import TestDataset
+from utils.dataset import *
 from utils.transform import TransformSelector
 from tqdm.auto import tqdm
 from SAM2UNet import SAM2UNet
+from omegaconf import OmegaConf
+from argparse import ArgumentParser
 
-parser = argparse.ArgumentParser()
-parser.add_argument("--checkpoint", type=str, required=True,
-                    help="path to the checkpoint of sam2-unet")
-parser.add_argument("--test_image_path", type=str, default="/data/ephemeral/home/data/test/DCM",
-                    help="path to the image files for testing")
-parser.add_argument("--image_size", type=int, default=1024)
-parser.add_argument("--save_file", type=str, default='output.csv')
-args = parser.parse_args()
+def set_seed(RANDOM_SEED):
+    torch.manual_seed(RANDOM_SEED)
+    torch.cuda.manual_seed(RANDOM_SEED)
+    torch.cuda.manual_seed_all(RANDOM_SEED)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+    np.random.seed(RANDOM_SEED)
+    random.seed(RANDOM_SEED)
 
 def encode_mask_to_rle(mask):
     '''
@@ -56,29 +58,29 @@ def test(model, args, thr=0.5):
     class2ind = {v: i for i, v in enumerate(classes)}
     ind2class = {v: k for k, v in class2ind.items()}
 
+
+    image_root = os.path.join(args.test_data_path, 'DCM')
+    pngs = get_sorted_files_by_type(image_root, 'png')
+
     transform_selector = TransformSelector(args.image_size)
     transform = transform_selector.get_transform(is_train=False)
 
-    test_dataset = TestDataset(
-        image_root=args.test_image_path,
-        transform=transform
-    )
+    test_dataset = FullDataset(
+        image_files=np.array(pngs), 
+        transforms=transform)
 
     test_loader = DataLoader(
         dataset=test_dataset, 
-        batch_size=2,
-        shuffle=False,
-        num_workers=2,
-    )
-
-    model.eval()
-    model.cuda()
-    os.makedirs("./outputs", exist_ok=True)
+        batch_size=cfg.test_batch_size,
+        num_workers=cfg.test_workers,
+        shuffle=False)
 
     rles = []
     filename_and_class = []
+
+    model.eval()
     with torch.no_grad():
-        for step, (images, image_names) in tqdm(enumerate(test_loader), total=len(test_loader)):
+        for step, (image_names, images) in tqdm(enumerate(test_loader), total=len(test_loader)):
             images = images.cuda()    
             outputs, _, _ = model(images)
             
@@ -94,12 +96,12 @@ def test(model, args, thr=0.5):
                     
     return rles, filename_and_class
 
-def main(args):
+def main(cfg):
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     model = SAM2UNet().to(device)
-    checkpoint = torch.load(os.path.join(args.checkpoint))
+    checkpoint = torch.load(os.path.join(cfg.checkpoint))
     model.load_state_dict(checkpoint['model_state_dict'])
-    rles, filename_and_class = test(model, args)
+    rles, filename_and_class = test(model, cfg)
     classes, filename = zip(*[x.split("_") for x in filename_and_class])
     image_name = [os.path.basename(f) for f in filename]
     df = pd.DataFrame({
@@ -108,11 +110,19 @@ def main(args):
         "rle": rles,
     })
     
-    save_file = args.save_file
+    os.makedirs("./outputs", exist_ok=True)
+    save_file = cfg.save_file
     if len(save_file) < 5 or save_file[-4:] != '.csv':
         save_file += '.csv'
     save_path = os.path.join('./outputs', save_file)
     df.to_csv(save_path, index=False)
 
 if __name__ == "__main__":
-    main(args)
+    parser = ArgumentParser()
+    parser.add_argument('--config', type=str, default='config.yaml')
+    parser.add_argument('--checkpoint', type=str, required=True)
+    args = parser.parse_args()
+
+    with open(args.config, 'r') as f:
+        cfg = OmegaConf.load(f)
+    main(cfg)
diff --git a/sam2_unet/train.py b/sam2_unet/train.py
index 476a79b..66d9172 100644
--- a/sam2_unet/train.py
+++ b/sam2_unet/train.py
@@ -5,7 +5,7 @@
 from datetime import datetime
 from torch.utils.data import DataLoader
 from utils.loss import structure_loss
-from utils.dataset import FullDataset
+from utils.dataset import *
 from utils.optimizer import OptimizerSelector
 from utils.scheduler import SchedulerSelector
 from utils.transform import TransformSelector
@@ -24,28 +24,31 @@ def set_seed(RANDOM_SEED):
     random.seed(RANDOM_SEED)
 
 def main(cfg):    
-    device = torch.device("cuda")
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     model = SAM2UNet(cfg.hiera_path)
-    
+
+    image_root = os.path.join(cfg.train_data_path, 'DCM')
+    label_root = os.path.join(cfg.train_data_path, 'outputs_json')
+
+    pngs = get_sorted_files_by_type(image_root, 'png')
+    jsons = get_sorted_files_by_type(label_root, 'json')
+    train_files, valid_files = split_data(pngs, jsons, cfg.kfold, cfg.k)
+
     transform_selector = TransformSelector(image_size=cfg.image_size)
     train_transform = transform_selector.get_transform(is_train=True)
     valid_transform = transform_selector.get_transform(is_train=False)
 
     train_dataset = FullDataset(
-        image_root=cfg.train_image_path, 
-        gt_root=cfg.train_mask_path, 
-        is_train=True,
-        transforms=train_transform,
-        kfold=cfg.kfold,
-        k=cfg.k)
+        image_files=train_files['filenames'],
+        label_files=train_files['labelnames'], 
+        transforms=train_transform
+    )
     
     valid_dataset = FullDataset(
-        image_root=cfg.train_image_path, 
-        gt_root=cfg.train_mask_path, 
-        is_train=False,
-        transforms=valid_transform,
-        kfold=cfg.kfold,
-        k=cfg.k)
+        image_files=valid_files['filenames'],
+        label_files=valid_files['labelnames'], 
+        transforms=valid_transform
+    )
 
     train_loader = DataLoader(
         train_dataset, 
@@ -72,12 +75,11 @@ def main(cfg):
     time = now.strftime('%Y-%m-%d_%H:%M:%S')
     save_dir = os.path.join('./checkpoints', time)
     os.makedirs(save_dir, exist_ok=True)
-
-    # Config 저장
     save_path = os.path.join(save_dir, "config.yaml")
     OmegaConf.save(cfg, save_path)
     print(f"Config saved at {save_path}")
 
+
     trainer = Trainer(
         model=model,
         device=device,
diff --git a/sam2_unet/trainer.py b/sam2_unet/trainer.py
index e7d5cca..aec353d 100644
--- a/sam2_unet/trainer.py
+++ b/sam2_unet/trainer.py
@@ -4,7 +4,6 @@
 from tqdm.auto import tqdm
 from utils.checkpoint import save_checkpoint, load_checkpoint
 from utils.wandb_logger import WandbLogger
-
 import torch
 import torch.nn.functional as F
 from torch.utils.data import DataLoader
@@ -50,10 +49,12 @@ def __init__(
         self.resume = resume
         self.ckpt_file = ckpt_path
         self.start_epoch = 0
+        
         if scaler:
             self.scaler = torch.cuda.amp.GradScaler()
         else:
             self.scaler = None
+
         self.classes = [
             'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
             'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
@@ -83,7 +84,7 @@ def train(self, train_loader: DataLoader):
         train_dices = []
         progress_bar = tqdm(train_loader, desc="Training", leave=False)
         
-        for images, masks in progress_bar:
+        for image_name, images, masks in progress_bar:
             images, masks = images.to(self.device), masks.to(self.device)
             self.optimizer.zero_grad()
 
@@ -136,7 +137,7 @@ def validate(self, valid_loader: DataLoader) -> tuple[float, float]:
         progress_bar = tqdm(valid_loader, desc="Validating", leave=False)
         
         with torch.no_grad():
-            for batch_idx, (images, masks) in enumerate(progress_bar):
+            for batch_idx, (image_name, images, masks) in enumerate(progress_bar):
                 images, masks = images.to(self.device), masks.to(self.device)
                 
                 outputs, _, _ = self.model(images)
diff --git a/sam2_unet/utils/dataset.py b/sam2_unet/utils/dataset.py
index 2f557ff..f4af6fe 100644
--- a/sam2_unet/utils/dataset.py
+++ b/sam2_unet/utils/dataset.py
@@ -3,7 +3,6 @@
 import cv2
 import json
 import torch
-from PIL import Image
 from torch.utils.data import Dataset
 from sklearn.model_selection import GroupKFold
 
@@ -17,147 +16,83 @@
 ]
 CLASS2IND = {v: i for i, v in enumerate(CLASSES)}
 
-class FullDataset(Dataset):
-    def __init__(self, image_root, gt_root, is_train=True, transforms=None, kfold=5, k=0):
-        pngs = {
-            os.path.relpath(os.path.join(root, fname), start=image_root)
-            for root, _dirs, files in os.walk(image_root)
-            for fname in files
-            if os.path.splitext(fname)[1].lower() == ".png"
-        }
-        jsons = {
-            os.path.relpath(os.path.join(root, fname), start=gt_root)
-            for root, _dirs, files in os.walk(gt_root)
-            for fname in files
-            if os.path.splitext(fname)[1].lower() == ".json"
-        }
-        self.image_root = image_root
-        self.gt_root = gt_root
-        self.is_train = is_train
-        pngs = sorted(pngs)
-        jsons = sorted(jsons)
-
-        _filenames = np.array(pngs)
-        _labelnames = np.array(jsons)
-        
-        groups = [os.path.dirname(fname) for fname in _filenames]
-        
-        ys = [0 for fname in _filenames]
-        
-        gkf = GroupKFold(n_splits=kfold)
-        
-        filenames = []
-        labelnames = []
-        for i, (x, y) in enumerate(gkf.split(_filenames, ys, groups)):
-            if is_train:
-                if i == k:
-                    continue
-                filenames += list(_filenames[y])
-                labelnames += list(_labelnames[y])
-            
-            else:
-                if k >= 0 and i != k:
-                    continue
-                filenames = list(_filenames[y])
-                labelnames = list(_labelnames[y])
-                break
-
-        self.images = filenames
-        self.gts = labelnames
-        self.transform = transforms
-
-    def __getitem__(self, idx):
-        image_name = self.images[idx]
-        image_path = os.path.join(self.image_root, image_name)
-        
-        image = cv2.imread(image_path)
-        image = image.astype(np.float32) / 255.
-        
-        label_name = self.gts[idx]
-        label_path = os.path.join(self.gt_root, label_name)
-        
-        image_height, image_width = image.shape[:2]
-        label_shape = (image_height, image_width, len(CLASSES),)
-        label = np.zeros(label_shape, dtype=np.uint8)
-        
-        try:
-            with open(label_path, "r") as f:
-                annotations = json.load(f)
-        except FileNotFoundError:
-            raise FileNotFoundError(f"Label file not found at path: {label_path}")
-        
-        annotations = annotations.get("annotations", [])
-        
-        # Fill polygons in label
-        for ann in annotations:
-            c = ann.get("label")
-            if c not in CLASS2IND:
-                continue
-            
-            class_ind = CLASS2IND[c]
-            points = np.array(ann.get("points", []), dtype=np.int32)
-            
-            if points.size == 0:
-                continue
-            
-            class_label = np.zeros((image_height, image_width), dtype=np.uint8)
-            cv2.fillPoly(class_label, [points], 1)
-            label[..., class_ind] = class_label
-        
-        if self.transform is not None:
-            inputs = {"image": image, "mask": label} if self.is_train else {"image": image}
-            result = self.transform(**inputs)
-            
-            image = result["image"]
-            label = result["mask"] if self.is_train else label
+def get_sorted_files_by_type(root_path, file_type='json'):
+    files = {
+        os.path.relpath(os.path.join(root, fname), start=root_path)
+        for root, _dirs, files in os.walk(root_path)
+        for fname in files
+        if os.path.splitext(fname)[1].lower() == '.' + file_type
+    }
+    files = sorted(files)
 
-        image = image.transpose(2, 0, 1)
-        label = label.transpose(2, 0, 1)
-        
-        image = torch.from_numpy(image).float()
-        label = torch.from_numpy(label).float()
-        
-        return image, label
+    return files
 
-    def __len__(self):
-        return len(self.images)
-
-    def rgb_loader(self, path):
-        with open(path, 'rb') as f:
-            img = Image.open(f)
-            return img.convert('RGB')
-
-class TestDataset:
-    def __init__(self, image_root, transform=None):
-        pngs = {
-            os.path.relpath(os.path.join(root, fname), start=image_root)
-            for root, _dirs, files in os.walk(image_root)
-            for fname in files
-            if os.path.splitext(fname)[1].lower() == ".png"
-        }
-        pngs = sorted(pngs)
-
-        self.image_root = image_root
-        self.images = np.array(pngs)
-        self.transform = transform
+def split_data(pngs, jsons, kfold=5, k=0):
+    assert k < kfold
+
+    _filenames = np.array(pngs)
+    _labelnames = np.array(jsons)
+
+    groups = [os.path.dirname(fname) for fname in _filenames]
+
+    ys = [0 for fname in _filenames]
+
+    gkf = GroupKFold(n_splits=kfold)
+
+    train_datalist, valid_datalist = dict(filenames = [], labelnames = []), dict(filenames = [], labelnames = [])
+
+    for idx, (x, y) in enumerate(gkf.split(_filenames, ys, groups)):
+        if idx != k:
+            train_datalist['filenames'] += list(_filenames[y])
+            train_datalist['labelnames'] += list(_labelnames[y])
+        elif idx == k:
+            valid_datalist['filenames'] += list(_filenames[y])
+            valid_datalist['labelnames'] += list(_labelnames[y])
+
+    return train_datalist, valid_datalist
+
+class FullDataset(Dataset):
+    def __init__(self, image_files, label_files=None, transforms=None):
+        self.image_files = image_files
+        self.label_files = label_files
+        self.transforms = transforms
     
     def __len__(self):
-        return len(self.images)
-    
-    def __getitem__(self, idx):
-        image_name = self.images[idx]
-        image_path = os.path.join(self.image_root, image_name)
-        
+        return len(self.image_files)
+
+    def __getitem__(self, item):
+        image_path = self.image_files[item]
+        image_name = os.path.basename(image_path)
+
         image = cv2.imread(image_path)
-        image = image.astype(np.float32) / 255.
+        image = image / 255.0
         
-        if self.transform is not None:
-            inputs = {"image": image}
-            result = self.transform(**inputs)
+        if self.label_files:
+            label_path = self.label_files[item]
+            label_shape = tuple(image.shape[:2]) + (len(CLASSES), )
+            label = np.zeros(label_shape, dtype=np.uint8)
+            
+            with open(label_path, "r") as f:
+                annotations = json.load(f)["annotations"]
+
+            for ann in annotations:
+                c = ann["label"]
+                class_ind = CLASS2IND[c]
+                points = np.array(ann["points"])
+                
+                class_label = np.zeros(image.shape[:2], dtype=np.uint8)
+                cv2.fillPoly(class_label, [points], 1)
+                label[..., class_ind] = class_label
+        else:
+            label = np.zeros((len(CLASSES), *image.shape[:2]), dtype=np.uint8)
+        
+        if self.transforms:
+            inputs = {"image": image, "mask": label} if self.label_files else {"image": image}
+            result = self.transforms(**inputs)
             image = result["image"]
+            label = result["mask"] if self.label_files else label
 
-        image = image.transpose(2, 0, 1)
-        
-        image = torch.from_numpy(image).float()
-            
-        return image, image_name
\ No newline at end of file
+        image = torch.from_numpy(image.transpose(2, 0, 1)).float()
+        label = torch.from_numpy(label.transpose(2, 0, 1)).float() if self.label_files else None
+
+        return (image_name, image, label) if label is not None else (image_name, image)
\ No newline at end of file

From ff70bfa3f1481beed658588ea1ba93bd646ae274 Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Wed, 27 Nov 2024 16:31:38 +0900
Subject: [PATCH 080/106] [Fix] : files path

---
 sam2_unet/config.yaml      |  8 ++++----
 sam2_unet/test.py          | 30 +++++++++++++++---------------
 sam2_unet/utils/dataset.py |  5 +++--
 3 files changed, 22 insertions(+), 21 deletions(-)

diff --git a/sam2_unet/config.yaml b/sam2_unet/config.yaml
index 8bb3ede..d6559de 100644
--- a/sam2_unet/config.yaml
+++ b/sam2_unet/config.yaml
@@ -22,9 +22,9 @@ save_file: output.csv
 
 # hyperparameter
 random_seed: 2024
-lr: 2e-4
+lr: 1e-3
 max_epoch: 40
-smooth_factor: 0
+smooth_factor: 0.1
 scaler: False
 
 # optimizer
@@ -44,8 +44,8 @@ scheduler_parameters:
   # gamma: 0.1
   
   # cosineannealinglr
-  T_max: 30
-  eta_min: 1e-6
+  T_max: 40
+  eta_min: 5e-5
   
   # reducelronplateau
   # factor: 0.1
diff --git a/sam2_unet/test.py b/sam2_unet/test.py
index 87bfb1e..59f35bc 100644
--- a/sam2_unet/test.py
+++ b/sam2_unet/test.py
@@ -12,6 +12,11 @@
 from omegaconf import OmegaConf
 from argparse import ArgumentParser
 
+parser = ArgumentParser()
+parser.add_argument('--config', type=str, default='config.yaml')
+parser.add_argument('--checkpoint', type=str, required=True)
+args = parser.parse_args()
+
 def set_seed(RANDOM_SEED):
     torch.manual_seed(RANDOM_SEED)
     torch.cuda.manual_seed(RANDOM_SEED)
@@ -46,7 +51,7 @@ def decode_rle_to_mask(rle, height, width):
     
     return img.reshape(height, width)
 
-def test(model, args, thr=0.5):
+def test(model, cfg, thr=0.5):
     classes = [
         'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
         'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
@@ -58,11 +63,10 @@ def test(model, args, thr=0.5):
     class2ind = {v: i for i, v in enumerate(classes)}
     ind2class = {v: k for k, v in class2ind.items()}
 
-
-    image_root = os.path.join(args.test_data_path, 'DCM')
+    image_root = os.path.join(cfg.test_data_path, 'DCM')
     pngs = get_sorted_files_by_type(image_root, 'png')
 
-    transform_selector = TransformSelector(args.image_size)
+    transform_selector = TransformSelector(cfg.image_size)
     transform = transform_selector.get_transform(is_train=False)
 
     test_dataset = FullDataset(
@@ -72,7 +76,7 @@ def test(model, args, thr=0.5):
     test_loader = DataLoader(
         dataset=test_dataset, 
         batch_size=cfg.test_batch_size,
-        num_workers=cfg.test_workers,
+        num_workers=cfg.test_num_workers,
         shuffle=False)
 
     rles = []
@@ -96,10 +100,13 @@ def test(model, args, thr=0.5):
                     
     return rles, filename_and_class
 
-def main(cfg):
+def main(args):
+    with open(args.config, 'r') as f:
+        cfg = OmegaConf.load(f)
+
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     model = SAM2UNet().to(device)
-    checkpoint = torch.load(os.path.join(cfg.checkpoint))
+    checkpoint = torch.load(args.checkpoint)
     model.load_state_dict(checkpoint['model_state_dict'])
     rles, filename_and_class = test(model, cfg)
     classes, filename = zip(*[x.split("_") for x in filename_and_class])
@@ -118,11 +125,4 @@ def main(cfg):
     df.to_csv(save_path, index=False)
 
 if __name__ == "__main__":
-    parser = ArgumentParser()
-    parser.add_argument('--config', type=str, default='config.yaml')
-    parser.add_argument('--checkpoint', type=str, required=True)
-    args = parser.parse_args()
-
-    with open(args.config, 'r') as f:
-        cfg = OmegaConf.load(f)
-    main(cfg)
+    main(args)
diff --git a/sam2_unet/utils/dataset.py b/sam2_unet/utils/dataset.py
index f4af6fe..0837d37 100644
--- a/sam2_unet/utils/dataset.py
+++ b/sam2_unet/utils/dataset.py
@@ -17,8 +17,9 @@
 CLASS2IND = {v: i for i, v in enumerate(CLASSES)}
 
 def get_sorted_files_by_type(root_path, file_type='json'):
+    current_dir = os.getcwd()
     files = {
-        os.path.relpath(os.path.join(root, fname), start=root_path)
+        os.path.relpath(os.path.join(root, fname), start=current_dir)
         for root, _dirs, files in os.walk(root_path)
         for fname in files
         if os.path.splitext(fname)[1].lower() == '.' + file_type
@@ -65,7 +66,7 @@ def __getitem__(self, item):
         image_name = os.path.basename(image_path)
 
         image = cv2.imread(image_path)
-        image = image / 255.0
+        image = image.astype(np.float32) / 255.0
         
         if self.label_files:
             label_path = self.label_files[item]

From ebca88054c31a998c414932010646a67c96bf284 Mon Sep 17 00:00:00 2001
From: Soy17 <thdudlee0617@naver.com>
Date: Wed, 27 Nov 2024 17:01:25 +0900
Subject: [PATCH 081/106] [#11] UNet++ code update

---
 RECcode/._baseline_code.ipynb              |  Bin 0 -> 643 bytes
 RECcode/._eda.ipynb                        |  Bin 0 -> 578 bytes
 RECcode/baseline_code.ipynb                | 1252 +++++++++++++++++++
 RECcode/cv/configs/base_train copy.yaml    |   59 +
 RECcode/cv/configs/base_train.yaml         |   59 +
 RECcode/cv/dataset.py                      |  133 ++
 RECcode/cv/inference.py                    |  113 ++
 RECcode/cv/loss/base_loss.py               |   13 +
 RECcode/cv/loss/loss_selector.py           |   17 +
 RECcode/cv/models/base_model.py            |   15 +
 RECcode/cv/models/model_selector.py        |   17 +
 RECcode/cv/scheduler/scheduler_selector.py |   28 +
 RECcode/cv/train.py                        |  143 +++
 RECcode/cv/trainer.py                      |  178 +++
 RECcode/cv/unet.sh                         |    4 +
 RECcode/cv/utils/wandb.py                  |   18 +
 RECcode/eda.ipynb                          | 1280 ++++++++++++++++++++
 RECcode/requirements.txt                   |   10 +
 module_base/config.yaml                    |    8 +-
 streamlit/main.py                          |    5 +-
 20 files changed, 3345 insertions(+), 7 deletions(-)
 create mode 100644 RECcode/._baseline_code.ipynb
 create mode 100644 RECcode/._eda.ipynb
 create mode 100644 RECcode/baseline_code.ipynb
 create mode 100644 RECcode/cv/configs/base_train copy.yaml
 create mode 100644 RECcode/cv/configs/base_train.yaml
 create mode 100644 RECcode/cv/dataset.py
 create mode 100644 RECcode/cv/inference.py
 create mode 100644 RECcode/cv/loss/base_loss.py
 create mode 100644 RECcode/cv/loss/loss_selector.py
 create mode 100644 RECcode/cv/models/base_model.py
 create mode 100644 RECcode/cv/models/model_selector.py
 create mode 100644 RECcode/cv/scheduler/scheduler_selector.py
 create mode 100644 RECcode/cv/train.py
 create mode 100644 RECcode/cv/trainer.py
 create mode 100644 RECcode/cv/unet.sh
 create mode 100644 RECcode/cv/utils/wandb.py
 create mode 100644 RECcode/eda.ipynb
 create mode 100644 RECcode/requirements.txt

diff --git a/RECcode/._baseline_code.ipynb b/RECcode/._baseline_code.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..145423b9e1121768ed3b32cff894d6956e359d79
GIT binary patch
literal 643
zcmb_ZJxjwt7=9D+3kO{k-HLEHD9v3>lS_+~Hm#^2;s@#$F1ZUWUXz%dsI!x^gQFlF
zo%~Jy3Ma2sP{cvO2k!lR9`5CRVSHf{On_Y$mG%xxr=<@JYcQ=}1;E_bUgzeG_P;>$
z=;+{`Hd4F*7!TiMV>;J$*aDc1(tep`nH1$di{yxCtZ7XH0Db8R#W+)}cDCEzR-%8>
z6}i~V(|(~9=9xB&0P~;x^9z=<MD-E@6R>)RZ(mn-;`^s%)fgNnqfh>9!c6uGh4G_d
z26Kb1Qd!NiWEwHqO$$|{8dltsqOjWOWg=6?3(G$aP^XDn6tytw_^4$gN>QhUsE??w
zw2{};u@$mHNIh&2rCgMI*>w^&f~z8rH!8^Wg-0k^x2rmIY+fbnq)I%S+g|Ka%DESF
z97Z&*2shFc;u06zRhQskj{iKSWTB;UA^vAln1UI2e&45QeC&02;x90k&Mk~7sXLA%
O9GB6$-__R>b$A0GWQLmn

literal 0
HcmV?d00001

diff --git a/RECcode/._eda.ipynb b/RECcode/._eda.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..aef2d5d4f9d0f1d76f48b473c0003d0619e8b518
GIT binary patch
literal 578
zcmbVJ%T6Le6upfxqi%G=WR`5~g%Kzkx|@P@3~G!-!57+$nMew%kPdWL(^UIh`yIwl
za5eK6?p(R_6I>fFKBAe`WKL3b>)w0LN!2Zw{QeCR05#T0ZSAF+sdtQPFpbLqNX%ix
zJh6=NA5dvDcHd~PibnwL=r7p>=2(YyfZ2}pGb{`TBIC2p;FYK?Vt59a|I!nRai&<Q
zUt6sz;k!K%iM2@jBcvu4aQgv}{NxW~7O_Bifxy<npR45M{)YGa`q%yKeDVoP|ABTm
z@J5P|8?7~W*HbDSm9kkLc_$(hk3`gwff9kr97}nOkHM>CxjYR9lJO;vJGp-CeEa9A
zU0APgy1U)LxM&XDtvcP4Et}S@oef=_g)&mkhe&6!>Wz&ZLr3qf7x|9T;~2dNZBv#n
zm}y2hPZtb}rfD8e)S%p?w3s)#L}$vWY#;6i4Y$#6@tyF1gokF;3n~W}ZnIr2<?NhI
qiEUbiV$qzMc^inPy$@#m|6lPi%o0+}l`YFM^Tg_wS9&;nQHB=_dwggB

literal 0
HcmV?d00001

diff --git a/RECcode/baseline_code.ipynb b/RECcode/baseline_code.ipynb
new file mode 100644
index 0000000..2af9fc7
--- /dev/null
+++ b/RECcode/baseline_code.ipynb
@@ -0,0 +1,1252 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "5af8a2c0-45fe-4d13-bebd-0dca87a7b71f",
+   "metadata": {},
+   "source": [
+    "# Library import"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "a4c611c8-2226-433c-bf5f-343cc0b094af",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 필요 library들을 import합니다.\n",
+    "import os\n",
+    "from typing import Tuple, Any, Callable, List, Optional, Union\n",
+    "\n",
+    "import cv2\n",
+    "import timm\n",
+    "import torch\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import albumentations as A\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "import torch.optim as optim\n",
+    "from torchvision import models, datasets, transforms\n",
+    "from tqdm.auto import tqdm\n",
+    "from torch.utils.data import DataLoader, Dataset\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from albumentations.pytorch import ToTensorV2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a2d69e6a-a719-4a97-92ca-6354c873313f",
+   "metadata": {},
+   "source": [
+    "# Dataset Class"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "56f97229-e29f-479d-abab-0db8219d1803",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class CustomDataset(Dataset):\n",
+    "    def __init__(\n",
+    "        self, \n",
+    "        root_dir: str, \n",
+    "        info_df: pd.DataFrame, \n",
+    "        transform: Callable,\n",
+    "        is_inference: bool = False\n",
+    "    ):\n",
+    "        # 데이터셋의 기본 경로, 이미지 변환 방법, 이미지 경로 및 레이블을 초기화합니다.\n",
+    "        self.root_dir = root_dir  # 이미지 파일들이 저장된 기본 디렉토리\n",
+    "        self.transform = transform  # 이미지에 적용될 변환 처리\n",
+    "        self.is_inference = is_inference # 추론인지 확인\n",
+    "        self.image_paths = info_df['image_path'].tolist()  # 이미지 파일 경로 목록\n",
+    "        \n",
+    "        if not self.is_inference:\n",
+    "            self.targets = info_df['target'].tolist()  # 각 이미지에 대한 레이블 목록\n",
+    "\n",
+    "    def __len__(self) -> int:\n",
+    "        # 데이터셋의 총 이미지 수를 반환합니다.\n",
+    "        return len(self.image_paths)\n",
+    "\n",
+    "    def __getitem__(self, index: int) -> Union[Tuple[torch.Tensor, int], torch.Tensor]:\n",
+    "        # 주어진 인덱스에 해당하는 이미지를 로드하고 변환을 적용한 후, 이미지와 레이블을 반환합니다.\n",
+    "        img_path = os.path.join(self.root_dir, self.image_paths[index])  # 이미지 경로 조합\n",
+    "        image = cv2.imread(img_path, cv2.IMREAD_COLOR)  # 이미지를 BGR 컬러 포맷의 numpy array로 읽어옵니다.\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)  # BGR 포맷을 RGB 포맷으로 변환합니다.\n",
+    "        image = self.transform(image)  # 설정된 이미지 변환을 적용합니다.\n",
+    "\n",
+    "        if self.is_inference:\n",
+    "            return image\n",
+    "        else:\n",
+    "            target = self.targets[index]  # 해당 이미지의 레이블\n",
+    "            return image, target  # 변환된 이미지와 레이블을 튜플 형태로 반환합니다. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6c07d2d0-9585-45ce-8ece-4f69b98f6dd4",
+   "metadata": {},
+   "source": [
+    "# Transform Class"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "9b1855c1-cf13-476d-aabd-d78e9e082ddf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class TorchvisionTransform:\n",
+    "    def __init__(self, is_train: bool = True):\n",
+    "        # 공통 변환 설정: 이미지 리사이즈, 텐서 변환, 정규화\n",
+    "        common_transforms = [\n",
+    "            transforms.Resize((224, 224)),  # 이미지를 224x224 크기로 리사이즈\n",
+    "            transforms.ToTensor(),  # 이미지를 PyTorch 텐서로 변환\n",
+    "            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # 정규화\n",
+    "        ]\n",
+    "        \n",
+    "        if is_train:\n",
+    "            # 훈련용 변환: 랜덤 수평 뒤집기, 랜덤 회전, 색상 조정 추가\n",
+    "            self.transform = transforms.Compose(\n",
+    "                [\n",
+    "                    transforms.RandomHorizontalFlip(p=0.5),  # 50% 확률로 이미지를 수평 뒤집기\n",
+    "                    transforms.RandomRotation(15),  # 최대 15도 회전\n",
+    "                    transforms.ColorJitter(brightness=0.2, contrast=0.2),  # 밝기 및 대비 조정\n",
+    "                ] + common_transforms\n",
+    "            )\n",
+    "        else:\n",
+    "            # 검증/테스트용 변환: 공통 변환만 적용\n",
+    "            self.transform = transforms.Compose(common_transforms)\n",
+    "\n",
+    "    def __call__(self, image: np.ndarray) -> torch.Tensor:\n",
+    "        image = Image.fromarray(image)  # numpy 배열을 PIL 이미지로 변환\n",
+    "        \n",
+    "        transformed = self.transform(image)  # 설정된 변환을 적용\n",
+    "        \n",
+    "        return transformed  # 변환된 이미지 반환"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "0a683988-0f73-4e43-907b-0d5209550abb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class AlbumentationsTransform:\n",
+    "    def __init__(self, is_train: bool = True):\n",
+    "        # 공통 변환 설정: 이미지 리사이즈, 정규화, 텐서 변환\n",
+    "        common_transforms = [\n",
+    "            A.Resize(224, 224),  # 이미지를 224x224 크기로 리사이즈\n",
+    "            A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),  # 정규화\n",
+    "            ToTensorV2()  # albumentations에서 제공하는 PyTorch 텐서 변환\n",
+    "        ]\n",
+    "        \n",
+    "        if is_train:\n",
+    "            # 훈련용 변환: 랜덤 수평 뒤집기, 랜덤 회전, 랜덤 밝기 및 대비 조정 추가\n",
+    "            self.transform = A.Compose(\n",
+    "                [\n",
+    "                    A.HorizontalFlip(p=0.5),  # 50% 확률로 이미지를 수평 뒤집기\n",
+    "                    A.Rotate(limit=15),  # 최대 15도 회전\n",
+    "                    A.RandomBrightnessContrast(p=0.2),  # 밝기 및 대비 무작위 조정\n",
+    "                ] + common_transforms\n",
+    "            )\n",
+    "        else:\n",
+    "            # 검증/테스트용 변환: 공통 변환만 적용\n",
+    "            self.transform = A.Compose(common_transforms)\n",
+    "\n",
+    "    def __call__(self, image) -> torch.Tensor:\n",
+    "        # 이미지가 NumPy 배열인지 확인\n",
+    "        if not isinstance(image, np.ndarray):\n",
+    "            raise TypeError(\"Image should be a NumPy array (OpenCV format).\")\n",
+    "        \n",
+    "        # 이미지에 변환 적용 및 결과 반환\n",
+    "        transformed = self.transform(image=image)  # 이미지에 설정된 변환을 적용\n",
+    "        \n",
+    "        return transformed['image']  # 변환된 이미지의 텐서를 반환"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "e82f3416-86f2-430f-9260-d23904e757e4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class TransformSelector:\n",
+    "    \"\"\"\n",
+    "    이미지 변환 라이브러리를 선택하기 위한 클래스.\n",
+    "    \"\"\"\n",
+    "    def __init__(self, transform_type: str):\n",
+    "\n",
+    "        # 지원하는 변환 라이브러리인지 확인\n",
+    "        if transform_type in [\"torchvision\", \"albumentations\"]:\n",
+    "            self.transform_type = transform_type\n",
+    "        \n",
+    "        else:\n",
+    "            raise ValueError(\"Unknown transformation library specified.\")\n",
+    "\n",
+    "    def get_transform(self, is_train: bool):\n",
+    "        \n",
+    "        # 선택된 라이브러리에 따라 적절한 변환 객체를 생성\n",
+    "        if self.transform_type == 'torchvision':\n",
+    "            transform = TorchvisionTransform(is_train=is_train)\n",
+    "        \n",
+    "        elif self.transform_type == 'albumentations':\n",
+    "            transform = AlbumentationsTransform(is_train=is_train)\n",
+    "        \n",
+    "        return transform"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c938bcb2-9257-49cb-8d05-dd4a7bb25665",
+   "metadata": {},
+   "source": [
+    "# Model Class"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "f16fb24a-8d34-4ed6-8a33-2d153d12d190",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class SimpleCNN(nn.Module):\n",
+    "    \"\"\"\n",
+    "    간단한 CNN 아키텍처를 정의하는 클래스.\n",
+    "    \"\"\"\n",
+    "    def __init__(self, num_classes: int):\n",
+    "        super(SimpleCNN, self).__init__()\n",
+    "        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)\n",
+    "        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)\n",
+    "        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)\n",
+    "        self.pool = nn.MaxPool2d(2, 2)\n",
+    "        self.fc1 = nn.Linear(128 * 4 * 4, 512)\n",
+    "        self.fc2 = nn.Linear(512, num_classes)\n",
+    "        self.relu = nn.ReLU()\n",
+    "\n",
+    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
+    "        \n",
+    "        # 순전파 함수 정의\n",
+    "        x = self.pool(self.relu(self.conv1(x)))\n",
+    "        x = self.pool(self.relu(self.conv2(x)))\n",
+    "        x = self.pool(self.relu(self.conv3(x)))\n",
+    "        x = torch.flatten(x, 1)\n",
+    "        x = self.relu(self.fc1(x))\n",
+    "        x = self.fc2(x)\n",
+    "        \n",
+    "        return x"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "f91493ca-c5c2-4950-916a-cc4304c7ad4a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class TorchvisionModel(nn.Module):\n",
+    "    \"\"\"\n",
+    "    Torchvision에서 제공하는 사전 훈련된 모델을 사용하는 클래스.\n",
+    "    \"\"\"\n",
+    "    def __init__(\n",
+    "        self, \n",
+    "        model_name: str, \n",
+    "        num_classes: int, \n",
+    "        pretrained: bool\n",
+    "    ):\n",
+    "        super(TorchvisionModel, self).__init__()\n",
+    "        self.model = models.__dict__[model_name](pretrained=pretrained)\n",
+    "        \n",
+    "        # 모델의 최종 분류기 부분을 사용자 정의 클래스 수에 맞게 조정\n",
+    "        if 'fc' in dir(self.model):\n",
+    "            num_ftrs = self.model.fc.in_features\n",
+    "            self.model.fc = nn.Linear(num_ftrs, num_classes)\n",
+    "        \n",
+    "        elif 'classifier' in dir(self.model):\n",
+    "            num_ftrs = self.model.classifier[-1].in_features\n",
+    "            self.model.classifier[-1] = nn.Linear(num_ftrs, num_classes)\n",
+    "\n",
+    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
+    "        \n",
+    "        return self.model(x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "f28c8e4f-a914-4b12-982e-d4a58863c717",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class TimmModel(nn.Module):\n",
+    "    \"\"\"\n",
+    "    Timm 라이브러리를 사용하여 다양한 사전 훈련된 모델을 제공하는 클래스.\n",
+    "    \"\"\"\n",
+    "    def __init__(\n",
+    "        self, \n",
+    "        model_name: str, \n",
+    "        num_classes: int, \n",
+    "        pretrained: bool\n",
+    "    ):\n",
+    "        super(TimmModel, self).__init__()\n",
+    "        self.model = timm.create_model(\n",
+    "            model_name, \n",
+    "            pretrained=pretrained, \n",
+    "            num_classes=num_classes\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
+    "        \n",
+    "        return self.model(x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "3f2da081-9010-431d-a049-835d7bbea4a5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class ModelSelector:\n",
+    "    \"\"\"\n",
+    "    사용할 모델 유형을 선택하는 클래스.\n",
+    "    \"\"\"\n",
+    "    def __init__(\n",
+    "        self, \n",
+    "        model_type: str, \n",
+    "        num_classes: int, \n",
+    "        **kwargs\n",
+    "    ):\n",
+    "        \n",
+    "        # 모델 유형에 따라 적절한 모델 객체를 생성\n",
+    "        if model_type == 'simple':\n",
+    "            self.model = SimpleCNN(num_classes=num_classes)\n",
+    "        \n",
+    "        elif model_type == 'torchvision':\n",
+    "            self.model = TorchvisionModel(num_classes=num_classes, **kwargs)\n",
+    "        \n",
+    "        elif model_type == 'timm':\n",
+    "            self.model = TimmModel(num_classes=num_classes, **kwargs)\n",
+    "        \n",
+    "        else:\n",
+    "            raise ValueError(\"Unknown model type specified.\")\n",
+    "\n",
+    "    def get_model(self) -> nn.Module:\n",
+    "\n",
+    "        # 생성된 모델 객체 반환\n",
+    "        return self.model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c2977c7b-bc39-48f7-8155-ef6b6a03d6f8",
+   "metadata": {},
+   "source": [
+    "# Loss Class"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "97471eb3-a979-4fb3-b976-6c3177c79f76",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Loss(nn.Module):\n",
+    "    \"\"\"\n",
+    "    모델의 손실함수를 계산하는 클래스.\n",
+    "    \"\"\"\n",
+    "    def __init__(self):\n",
+    "        super(Loss, self).__init__()\n",
+    "        self.loss_fn = nn.CrossEntropyLoss()\n",
+    "\n",
+    "    def forward(\n",
+    "        self, \n",
+    "        outputs: torch.Tensor, \n",
+    "        targets: torch.Tensor\n",
+    "    ) -> torch.Tensor:\n",
+    "    \n",
+    "        return self.loss_fn(outputs, targets)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5f3e3d21-5ab8-41b0-aa5c-e62ace8dc6a6",
+   "metadata": {},
+   "source": [
+    "# Trainer Class"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "6a90c673-6672-4066-a9ec-9975d7842be4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Trainer:\n",
+    "    def __init__(\n",
+    "        self, \n",
+    "        model: nn.Module, \n",
+    "        device: torch.device, \n",
+    "        train_loader: DataLoader, \n",
+    "        val_loader: DataLoader, \n",
+    "        optimizer: optim.Optimizer,\n",
+    "        scheduler: optim.lr_scheduler,\n",
+    "        loss_fn: torch.nn.modules.loss._Loss, \n",
+    "        epochs: int,\n",
+    "        result_path: str\n",
+    "    ):\n",
+    "        # 클래스 초기화: 모델, 디바이스, 데이터 로더 등 설정\n",
+    "        self.model = model  # 훈련할 모델\n",
+    "        self.device = device  # 연산을 수행할 디바이스 (CPU or GPU)\n",
+    "        self.train_loader = train_loader  # 훈련 데이터 로더\n",
+    "        self.val_loader = val_loader  # 검증 데이터 로더\n",
+    "        self.optimizer = optimizer  # 최적화 알고리즘\n",
+    "        self.scheduler = scheduler # 학습률 스케줄러\n",
+    "        self.loss_fn = loss_fn  # 손실 함수\n",
+    "        self.epochs = epochs  # 총 훈련 에폭 수\n",
+    "        self.result_path = result_path  # 모델 저장 경로\n",
+    "        self.best_models = [] # 가장 좋은 상위 3개 모델의 정보를 저장할 리스트\n",
+    "        self.lowest_loss = float('inf') # 가장 낮은 Loss를 저장할 변수\n",
+    "\n",
+    "    def save_model(self, epoch, loss):\n",
+    "        # 모델 저장 경로 설정\n",
+    "        os.makedirs(self.result_path, exist_ok=True)\n",
+    "\n",
+    "        # 현재 에폭 모델 저장\n",
+    "        current_model_path = os.path.join(self.result_path, f'model_epoch_{epoch}_loss_{loss:.4f}.pt')\n",
+    "        torch.save(self.model.state_dict(), current_model_path)\n",
+    "\n",
+    "        # 최상위 3개 모델 관리\n",
+    "        self.best_models.append((loss, epoch, current_model_path))\n",
+    "        self.best_models.sort()\n",
+    "        if len(self.best_models) > 3:\n",
+    "            _, _, path_to_remove = self.best_models.pop(-1)  # 가장 높은 손실 모델 삭제\n",
+    "            if os.path.exists(path_to_remove):\n",
+    "                os.remove(path_to_remove)\n",
+    "\n",
+    "        # 가장 낮은 손실의 모델 저장\n",
+    "        if loss < self.lowest_loss:\n",
+    "            self.lowest_loss = loss\n",
+    "            best_model_path = os.path.join(self.result_path, 'best_model.pt')\n",
+    "            torch.save(self.model.state_dict(), best_model_path)\n",
+    "            print(f\"Save {epoch}epoch result. Loss = {loss:.4f}\")\n",
+    "\n",
+    "    def train_epoch(self) -> float:\n",
+    "        # 한 에폭 동안의 훈련을 진행\n",
+    "        self.model.train()\n",
+    "        \n",
+    "        total_loss = 0.0\n",
+    "        progress_bar = tqdm(self.train_loader, desc=\"Training\", leave=False)\n",
+    "        \n",
+    "        for images, targets in progress_bar:\n",
+    "            images, targets = images.to(self.device), targets.to(self.device)\n",
+    "            self.optimizer.zero_grad()\n",
+    "            outputs = self.model(images)\n",
+    "            loss = self.loss_fn(outputs, targets)\n",
+    "            loss.backward()\n",
+    "            self.optimizer.step()\n",
+    "            self.scheduler.step()\n",
+    "            total_loss += loss.item()\n",
+    "            progress_bar.set_postfix(loss=loss.item())\n",
+    "        \n",
+    "        return total_loss / len(self.train_loader)\n",
+    "\n",
+    "    def validate(self) -> float:\n",
+    "        # 모델의 검증을 진행\n",
+    "        self.model.eval()\n",
+    "        \n",
+    "        total_loss = 0.0\n",
+    "        progress_bar = tqdm(self.val_loader, desc=\"Validating\", leave=False)\n",
+    "        \n",
+    "        with torch.no_grad():\n",
+    "            for images, targets in progress_bar:\n",
+    "                images, targets = images.to(self.device), targets.to(self.device)\n",
+    "                outputs = self.model(images)    \n",
+    "                loss = self.loss_fn(outputs, targets)\n",
+    "                total_loss += loss.item()\n",
+    "                progress_bar.set_postfix(loss=loss.item())\n",
+    "        \n",
+    "        return total_loss / len(self.val_loader)\n",
+    "\n",
+    "    def train(self) -> None:\n",
+    "        # 전체 훈련 과정을 관리\n",
+    "        for epoch in range(self.epochs):\n",
+    "            print(f\"Epoch {epoch+1}/{self.epochs}\")\n",
+    "            \n",
+    "            train_loss = self.train_epoch()\n",
+    "            val_loss = self.validate()\n",
+    "            print(f\"Epoch {epoch+1}, Train Loss: {train_loss:.4f}, Validation Loss: {val_loss:.4f}\\n\")\n",
+    "\n",
+    "            self.save_model(epoch, val_loss)\n",
+    "            self.scheduler.step()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "22f41c09-318a-4f2e-bdca-68d8a07e9938",
+   "metadata": {},
+   "source": [
+    "# Model Training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "698783c4-ac2a-4e66-82aa-637df06ce012",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 학습에 사용할 장비를 선택.\n",
+    "# torch라이브러리에서 gpu를 인식할 경우, cuda로 설정.\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "76cfe17e-fb14-42e4-84ae-b6773f0b78fb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 학습 데이터의 경로와 정보를 가진 파일의 경로를 설정.\n",
+    "traindata_dir = \"./data/train\"\n",
+    "traindata_info_file = \"./data/train.csv\"\n",
+    "save_result_path = \"./train_result\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "42a4778f-bfd0-4638-8972-f366cd6b0a4f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 학습 데이터의 class, image path, target에 대한 정보가 들어있는 csv파일을 읽기.\n",
+    "train_info = pd.read_csv(traindata_info_file)\n",
+    "\n",
+    "# 총 class의 수를 측정.\n",
+    "num_classes = len(train_info['target'].unique())\n",
+    "\n",
+    "# 각 class별로 8:2의 비율이 되도록 학습과 검증 데이터를 분리.\n",
+    "train_df, val_df = train_test_split(\n",
+    "    train_info, \n",
+    "    test_size=0.2,\n",
+    "    stratify=train_info['target']\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "a0889892-5f63-4dcf-bcab-9ff2659ad28d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 학습에 사용할 Transform을 선언.\n",
+    "transform_selector = TransformSelector(\n",
+    "    transform_type = \"albumentations\"\n",
+    ")\n",
+    "train_transform = transform_selector.get_transform(is_train=True)\n",
+    "val_transform = transform_selector.get_transform(is_train=False)\n",
+    "\n",
+    "# 학습에 사용할 Dataset을 선언.\n",
+    "train_dataset = CustomDataset(\n",
+    "    root_dir=traindata_dir,\n",
+    "    info_df=train_df,\n",
+    "    transform=train_transform\n",
+    ")\n",
+    "val_dataset = CustomDataset(\n",
+    "    root_dir=traindata_dir,\n",
+    "    info_df=val_df,\n",
+    "    transform=val_transform\n",
+    ")\n",
+    "\n",
+    "# 학습에 사용할 DataLoader를 선언.\n",
+    "train_loader = DataLoader(\n",
+    "    train_dataset, \n",
+    "    batch_size=64, \n",
+    "    shuffle=True\n",
+    ")\n",
+    "val_loader = DataLoader(\n",
+    "    val_dataset, \n",
+    "    batch_size=64, \n",
+    "    shuffle=False\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "9447ca16-a1ff-4da4-b5a1-4cf239ebcf80",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "TimmModel(\n",
+       "  (model): ResNet(\n",
+       "    (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
+       "    (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "    (act1): ReLU(inplace=True)\n",
+       "    (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
+       "    (layer1): Sequential(\n",
+       "      (0): BasicBlock(\n",
+       "        (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (drop_block): Identity()\n",
+       "        (act1): ReLU(inplace=True)\n",
+       "        (aa): Identity()\n",
+       "        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "        (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (act2): ReLU(inplace=True)\n",
+       "      )\n",
+       "      (1): BasicBlock(\n",
+       "        (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (drop_block): Identity()\n",
+       "        (act1): ReLU(inplace=True)\n",
+       "        (aa): Identity()\n",
+       "        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "        (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (act2): ReLU(inplace=True)\n",
+       "      )\n",
+       "    )\n",
+       "    (layer2): Sequential(\n",
+       "      (0): BasicBlock(\n",
+       "        (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
+       "        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (drop_block): Identity()\n",
+       "        (act1): ReLU(inplace=True)\n",
+       "        (aa): Identity()\n",
+       "        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (act2): ReLU(inplace=True)\n",
+       "        (downsample): Sequential(\n",
+       "          (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
+       "          (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        )\n",
+       "      )\n",
+       "      (1): BasicBlock(\n",
+       "        (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (drop_block): Identity()\n",
+       "        (act1): ReLU(inplace=True)\n",
+       "        (aa): Identity()\n",
+       "        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (act2): ReLU(inplace=True)\n",
+       "      )\n",
+       "    )\n",
+       "    (layer3): Sequential(\n",
+       "      (0): BasicBlock(\n",
+       "        (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
+       "        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (drop_block): Identity()\n",
+       "        (act1): ReLU(inplace=True)\n",
+       "        (aa): Identity()\n",
+       "        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (act2): ReLU(inplace=True)\n",
+       "        (downsample): Sequential(\n",
+       "          (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
+       "          (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        )\n",
+       "      )\n",
+       "      (1): BasicBlock(\n",
+       "        (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (drop_block): Identity()\n",
+       "        (act1): ReLU(inplace=True)\n",
+       "        (aa): Identity()\n",
+       "        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (act2): ReLU(inplace=True)\n",
+       "      )\n",
+       "    )\n",
+       "    (layer4): Sequential(\n",
+       "      (0): BasicBlock(\n",
+       "        (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
+       "        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (drop_block): Identity()\n",
+       "        (act1): ReLU(inplace=True)\n",
+       "        (aa): Identity()\n",
+       "        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (act2): ReLU(inplace=True)\n",
+       "        (downsample): Sequential(\n",
+       "          (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
+       "          (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        )\n",
+       "      )\n",
+       "      (1): BasicBlock(\n",
+       "        (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (drop_block): Identity()\n",
+       "        (act1): ReLU(inplace=True)\n",
+       "        (aa): Identity()\n",
+       "        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (act2): ReLU(inplace=True)\n",
+       "      )\n",
+       "    )\n",
+       "    (global_pool): SelectAdaptivePool2d(pool_type=avg, flatten=Flatten(start_dim=1, end_dim=-1))\n",
+       "    (fc): Linear(in_features=512, out_features=500, bias=True)\n",
+       "  )\n",
+       ")"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# 학습에 사용할 Model을 선언.\n",
+    "model_selector = ModelSelector(\n",
+    "    model_type='timm', \n",
+    "    num_classes=num_classes,\n",
+    "    model_name='resnet18', \n",
+    "    pretrained=True\n",
+    ")\n",
+    "model = model_selector.get_model()\n",
+    "\n",
+    "# 선언된 모델을 학습에 사용할 장비로 셋팅.\n",
+    "model.to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "3c32f36d-4031-4cf4-8914-6e01d8861837",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 학습에 사용할 optimizer를 선언하고, learning rate를 지정\n",
+    "optimizer = optim.Adam(\n",
+    "    model.parameters(), \n",
+    "    lr=0.001\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "a2bd831e-39a7-4f10-a3a5-aefde280fa89",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 스케줄러 초기화\n",
+    "scheduler_step_size = 30  # 매 30step마다 학습률 감소\n",
+    "scheduler_gamma = 0.1  # 학습률을 현재의 10%로 감소\n",
+    "\n",
+    "# 한 epoch당 step 수 계산\n",
+    "steps_per_epoch = len(train_loader)\n",
+    "\n",
+    "# 2 epoch마다 학습률을 감소시키는 스케줄러 선언\n",
+    "epochs_per_lr_decay = 2\n",
+    "scheduler_step_size = steps_per_epoch * epochs_per_lr_decay\n",
+    "\n",
+    "scheduler = optim.lr_scheduler.StepLR(\n",
+    "    optimizer, \n",
+    "    step_size=scheduler_step_size, \n",
+    "    gamma=scheduler_gamma\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "32715cca-5a4a-49d5-8fd9-f84da4581523",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 학습에 사용할 Loss를 선언.\n",
+    "loss_fn = Loss()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "d17e2556-efcf-42c6-9d73-dc27813e7dff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 앞서 선언한 필요 class와 변수들을 조합해, 학습을 진행할 Trainer를 선언. \n",
+    "trainer = Trainer(\n",
+    "    model=model, \n",
+    "    device=device, \n",
+    "    train_loader=train_loader,\n",
+    "    val_loader=val_loader, \n",
+    "    optimizer=optimizer,\n",
+    "    scheduler=scheduler,\n",
+    "    loss_fn=loss_fn, \n",
+    "    epochs=5,\n",
+    "    result_path=save_result_path\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "0ac1110e-558f-4170-ad8d-42ac8eb5c3c4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/5\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                      \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1, Train Loss: 4.7797, Validation Loss: 2.8981\n",
+      "\n",
+      "Save 0epoch result. Loss = 2.8981\n",
+      "Epoch 2/5\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                      \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 2, Train Loss: 2.0138, Validation Loss: 1.8324\n",
+      "\n",
+      "Save 1epoch result. Loss = 1.8324\n",
+      "Epoch 3/5\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                       \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 3, Train Loss: 1.0609, Validation Loss: 1.4165\n",
+      "\n",
+      "Save 2epoch result. Loss = 1.4165\n",
+      "Epoch 4/5\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                       \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 4, Train Loss: 0.8974, Validation Loss: 1.3568\n",
+      "\n",
+      "Save 3epoch result. Loss = 1.3568\n",
+      "Epoch 5/5\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                       "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 5, Train Loss: 0.8140, Validation Loss: 1.3479\n",
+      "\n",
+      "Save 4epoch result. Loss = 1.3479\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\r"
+     ]
+    }
+   ],
+   "source": [
+    "# 모델 학습.\n",
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "11087088-9b1f-4f7d-8eb5-72008cc88a50",
+   "metadata": {},
+   "source": [
+    "# Inference"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "6bf92c3c-7b38-4f89-af2a-5dfbabf51926",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 모델 추론을 위한 함수\n",
+    "def inference(\n",
+    "    model: nn.Module, \n",
+    "    device: torch.device, \n",
+    "    test_loader: DataLoader\n",
+    "):\n",
+    "    # 모델을 평가 모드로 설정\n",
+    "    model.to(device)\n",
+    "    model.eval()\n",
+    "    \n",
+    "    predictions = []\n",
+    "    with torch.no_grad():  # Gradient 계산을 비활성화\n",
+    "        for images in tqdm(test_loader):\n",
+    "            # 데이터를 같은 장치로 이동\n",
+    "            images = images.to(device)\n",
+    "            \n",
+    "            # 모델을 통해 예측 수행\n",
+    "            logits = model(images)\n",
+    "            logits = F.softmax(logits, dim=1)\n",
+    "            preds = logits.argmax(dim=1)\n",
+    "            \n",
+    "            # 예측 결과 저장\n",
+    "            predictions.extend(preds.cpu().detach().numpy())  # 결과를 CPU로 옮기고 리스트에 추가\n",
+    "    \n",
+    "    return predictions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "b407c24c-785d-4ffc-b17b-84ae7dc4ecae",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 추론 데이터의 경로와 정보를 가진 파일의 경로를 설정.\n",
+    "testdata_dir = \"./data/test\"\n",
+    "testdata_info_file = \"./data/test.csv\"\n",
+    "save_result_path = \"./train_result\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "cbb89c12-3b5d-4647-a8c2-83650dce6281",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 추론 데이터의 class, image path, target에 대한 정보가 들어있는 csv파일을 읽기.\n",
+    "test_info = pd.read_csv(testdata_info_file)\n",
+    "\n",
+    "# 총 class 수.\n",
+    "num_classes = 500"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "ecec8773-6045-401e-b307-0a9758374c4c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 추론에 사용할 Transform을 선언.\n",
+    "transform_selector = TransformSelector(\n",
+    "    transform_type = \"albumentations\"\n",
+    ")\n",
+    "test_transform = transform_selector.get_transform(is_train=False)\n",
+    "\n",
+    "# 추론에 사용할 Dataset을 선언.\n",
+    "test_dataset = CustomDataset(\n",
+    "    root_dir=testdata_dir,\n",
+    "    info_df=test_info,\n",
+    "    transform=test_transform,\n",
+    "    is_inference=True\n",
+    ")\n",
+    "\n",
+    "# 추론에 사용할 DataLoader를 선언.\n",
+    "test_loader = DataLoader(\n",
+    "    test_dataset, \n",
+    "    batch_size=64, \n",
+    "    shuffle=False,\n",
+    "    drop_last=False\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "99cc06c1-ce65-476b-8d5b-b8025fcde443",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 추론에 사용할 장비를 선택.\n",
+    "# torch라이브러리에서 gpu를 인식할 경우, cuda로 설정.\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "\n",
+    "# 추론에 사용할 Model을 선언.\n",
+    "model_selector = ModelSelector(\n",
+    "    model_type='timm', \n",
+    "    num_classes=num_classes,\n",
+    "    model_name='resnet18', \n",
+    "    pretrained=False\n",
+    ")\n",
+    "model = model_selector.get_model()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "id": "317b966a-254c-4ac6-b9b4-1d39f59d524a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<All keys matched successfully>"
+      ]
+     },
+     "execution_count": 52,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# best epoch 모델을 불러오기.\n",
+    "model.load_state_dict(\n",
+    "    torch.load(\n",
+    "        os.path.join(save_result_path, \"best_model.pt\"),\n",
+    "        map_location='cpu'\n",
+    "    )\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "514852af-f338-4b27-a5a5-8b65406a8023",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|█████████████████████████████████████████| 157/157 [04:53<00:00,  1.87s/it]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# predictions를 CSV에 저장할 때 형식을 맞춰서 저장\n",
+    "# 테스트 함수 호출\n",
+    "predictions = inference(\n",
+    "    model=model, \n",
+    "    device=device, \n",
+    "    test_loader=test_loader\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "cc96c889-2423-42b2-8c3c-4b1d364ece71",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>ID</th>\n",
+       "      <th>image_path</th>\n",
+       "      <th>target</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.JPEG</td>\n",
+       "      <td>314</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1</td>\n",
+       "      <td>1.JPEG</td>\n",
+       "      <td>287</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2</td>\n",
+       "      <td>2.JPEG</td>\n",
+       "      <td>314</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>3</td>\n",
+       "      <td>3.JPEG</td>\n",
+       "      <td>314</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>4</td>\n",
+       "      <td>4.JPEG</td>\n",
+       "      <td>158</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10009</th>\n",
+       "      <td>10009</td>\n",
+       "      <td>10009.JPEG</td>\n",
+       "      <td>158</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10010</th>\n",
+       "      <td>10010</td>\n",
+       "      <td>10010.JPEG</td>\n",
+       "      <td>314</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10011</th>\n",
+       "      <td>10011</td>\n",
+       "      <td>10011.JPEG</td>\n",
+       "      <td>314</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10012</th>\n",
+       "      <td>10012</td>\n",
+       "      <td>10012.JPEG</td>\n",
+       "      <td>314</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10013</th>\n",
+       "      <td>10013</td>\n",
+       "      <td>10013.JPEG</td>\n",
+       "      <td>287</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>10014 rows × 3 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "          ID  image_path  target\n",
+       "0          0      0.JPEG     314\n",
+       "1          1      1.JPEG     287\n",
+       "2          2      2.JPEG     314\n",
+       "3          3      3.JPEG     314\n",
+       "4          4      4.JPEG     158\n",
+       "...      ...         ...     ...\n",
+       "10009  10009  10009.JPEG     158\n",
+       "10010  10010  10010.JPEG     314\n",
+       "10011  10011  10011.JPEG     314\n",
+       "10012  10012  10012.JPEG     314\n",
+       "10013  10013  10013.JPEG     287\n",
+       "\n",
+       "[10014 rows x 3 columns]"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# 모든 클래스에 대한 예측 결과를 하나의 문자열로 합침\n",
+    "test_info['target'] = predictions\n",
+    "test_info = test_info.reset_index().rename(columns={\"index\": \"ID\"})\n",
+    "test_info"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "c4efd2f6-d74a-491b-a7b1-fd7cf96f45a4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# DataFrame 저장\n",
+    "test_info.to_csv(\"output.csv\", index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ac79e3df-e5c3-4a49-b37e-0dea1300c317",
+   "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.18"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/RECcode/cv/configs/base_train copy.yaml b/RECcode/cv/configs/base_train copy.yaml
new file mode 100644
index 0000000..c2b4d1b
--- /dev/null
+++ b/RECcode/cv/configs/base_train copy.yaml	
@@ -0,0 +1,59 @@
+# data 관련 설정
+image_root: /data/ephemeral/home/data/train/DCM
+label_root: /data/ephemeral/home/data/train/outputs_json
+
+# 모델명 및 사전 학습 여부
+model_name: Unet
+model_parameter:
+  encoder_name: efficientnet-b0
+  classes: 29
+
+# batch_size
+train_batch_size: 4
+val_batch_size: 4
+
+# image resize
+image_size: &image_size 512
+
+# transform 관련
+transform:
+  Resize:
+    width: *image_size
+    height: *image_size
+
+# 학습 관련 하이퍼파라미터
+lr: 1e-3
+weight_decay: 1e-6
+
+max_epoch: &max_epoch 40
+
+# loss 관련 설정
+loss_name: BCEWithLogitsLoss
+
+# loss에 필요한 parameter -> dict 형태로 작성
+loss_parameter: {}
+
+# scheduler 관련 설정
+scheduler_name: CosineAnnealingLR
+
+# scheduler 필요한 parameter -> dict 형태로 작성
+scheduler_parameter:
+  T_max: *max_epoch
+  eta_min: 1e-6
+
+# random seed값
+seed: 42
+
+# validation 관련 인자
+val_fold: 0
+val_interval: 2
+threshold: 0.5
+
+# checkpoint 저장 경로
+save_dir: ./checkpoints/Unet
+
+# wandb
+api_key: 7363797140af326caa051190a07bd49ce5341c67
+team_name: cv19-eternalpaperbox
+project_name: UNet
+experiment_detail: base
diff --git a/RECcode/cv/configs/base_train.yaml b/RECcode/cv/configs/base_train.yaml
new file mode 100644
index 0000000..0feeb64
--- /dev/null
+++ b/RECcode/cv/configs/base_train.yaml
@@ -0,0 +1,59 @@
+# data 관련 설정
+image_root: /data/ephemeral/home/data/train/DCM
+label_root: /data/ephemeral/home/data/train/outputs_json
+
+# 모델명 및 사전 학습 여부
+model_name: Unet
+model_parameter:
+  encoder_name: efficientnet-b4
+  classes: 29
+
+# batch_size
+train_batch_size: 2
+val_batch_size: 2
+
+# image resize
+image_size: &image_size 1024
+
+# transform 관련
+transform:
+  Resize:
+    width: *image_size
+    height: *image_size
+
+# 학습 관련 하이퍼파라미터
+lr: 1e-3
+weight_decay: 1e-6
+
+max_epoch: &max_epoch 60
+
+# loss 관련 설정
+loss_name: BCEWithLogitsLoss
+
+# loss에 필요한 parameter -> dict 형태로 작성
+loss_parameter: {}
+
+# scheduler 관련 설정
+scheduler_name: CosineAnnealingLR
+
+# scheduler 필요한 parameter -> dict 형태로 작성
+scheduler_parameter:
+  T_max: *max_epoch
+  eta_min: 1e-6
+
+# random seed값
+seed: 42
+
+# validation 관련 인자
+val_fold: 0
+val_interval: 2
+threshold: 0.5
+
+# checkpoint 저장 경로
+save_dir: ./checkpoints/Unet
+
+# wandb
+api_key: 7363797140af326caa051190a07bd49ce5341c67
+team_name: cv19-eternalpaperbox
+project_name: UNet
+experiment_detail: cos_2048_epo60
diff --git a/RECcode/cv/dataset.py b/RECcode/cv/dataset.py
new file mode 100644
index 0000000..9503371
--- /dev/null
+++ b/RECcode/cv/dataset.py
@@ -0,0 +1,133 @@
+import os
+import cv2
+import json
+import torch
+import numpy as np
+import os.path as osp
+import albumentations as A
+
+from torch.utils.data import Dataset
+from sklearn.model_selection import GroupKFold
+
+CLASSES = [
+    'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
+    'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
+    'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
+    'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
+    'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
+    'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
+]
+
+class XRayDataset(Dataset):
+    def __init__(self, fnames, labels, image_root, label_root, fold=0, transforms=None, is_train=True):
+        self.transforms = A.Compose(transforms)
+        self.is_train = is_train
+        self.image_root = image_root
+        self.label_root = label_root
+        self.validation_fold = fold
+        self.class2ind = {v: i for i, v in enumerate(CLASSES)}
+        self.ind2class = {v: k for k, v in self.class2ind.items()}
+        self.num_classes = len(CLASSES)
+        
+        groups = [osp.dirname(fname) for fname in fnames]
+        
+        # dummy label
+        ys = [0] * len(fnames)
+        
+        gkf = GroupKFold(n_splits=5)
+        
+        filenames = []
+        labelnames = []
+        for i, (x, y) in enumerate(gkf.split(fnames, ys, groups)):
+            if self.is_train:
+                if i == self.validation_fold:
+                    continue        
+                filenames += list(fnames[y])
+                labelnames += list(labels[y])
+            
+            else:
+                filenames = list(fnames[y])
+                labelnames = list(labels[y])
+                break
+        
+        self.fnames = filenames
+        self.labels = labelnames
+    
+    def __len__(self):
+        return len(self.fnames)
+    
+    def __getitem__(self, item):
+        image_name = self.fnames[item]
+        image_path = osp.join(self.image_root, image_name)
+        
+        image = cv2.imread(image_path)
+        image = image / 255.
+        
+        label_name = self.labels[item]
+        label_path = osp.join(self.label_root, label_name)
+        
+        # (H, W, NC) 모양의 label을 생성합니다.
+        label_shape = tuple(image.shape[:2]) + (len(CLASSES), )
+        label = np.zeros(label_shape, dtype=np.uint8)
+        
+        # label 파일을 읽습니다.
+        with open(label_path, "r") as f:
+            annotations = json.load(f)
+        annotations = annotations["annotations"]
+        
+        # 클래스 별로 처리합니다.
+        for ann in annotations:
+            c = ann["label"]
+            class_ind = self.class2ind[c]
+            points = np.array(ann["points"])
+            
+            # polygon 포맷을 dense한 mask 포맷으로 바꿉니다.
+            class_label = np.zeros(image.shape[:2], dtype=np.uint8)
+            cv2.fillPoly(class_label, [points], 1)
+            label[..., class_ind] = class_label
+        
+        if self.transforms is not None:
+            inputs = {"image": image, "mask": label} if self.is_train else {"image": image}
+            result = self.transforms(**inputs)
+            
+            image = result["image"]
+            label = result["mask"] if self.is_train else label
+
+        # to tenser will be done later
+        image = image.transpose(2, 0, 1)    # channel first 포맷으로 변경합니다.
+        label = label.transpose(2, 0, 1)
+        
+        image = torch.from_numpy(image).float()
+        label = torch.from_numpy(label).float()
+            
+        return image, label
+    
+
+class XRayInferenceDataset(Dataset):
+    def __init__(self, fnames, image_root, transforms=None):
+        self.fnames = np.array(sorted(fnames))
+        self.image_root = image_root
+        self.transforms = transforms
+        self.ind2class = {i: v for i, v in enumerate(CLASSES)}
+    
+    def __len__(self):
+        return len(self.fnames)
+    
+    def __getitem__(self, item):
+        image_name = self.fnames[item]
+        image_path = osp.join(self.image_root, image_name)
+        
+        image = cv2.imread(image_path)
+        image = image / 255.
+        
+        if self.transforms is not None:
+            inputs = {"image": image}
+            result = self.transforms(**inputs)
+            image = result["image"]
+
+        # to tenser will be done later
+        image = image.transpose(2, 0, 1)  
+        
+        image = torch.from_numpy(image).float()
+            
+        return image, image_name
\ No newline at end of file
diff --git a/RECcode/cv/inference.py b/RECcode/cv/inference.py
new file mode 100644
index 0000000..e164fe6
--- /dev/null
+++ b/RECcode/cv/inference.py
@@ -0,0 +1,113 @@
+import os
+import torch
+import argparse
+import numpy as np
+import pandas as pd
+import os.path as osp
+import albumentations as A
+import torch.nn.functional as F
+
+from tqdm.auto import tqdm
+from torch.utils.data import DataLoader
+from dataset import XRayInferenceDataset
+
+# mask map으로 나오는 인퍼런스 결과를 RLE로 인코딩 합니다.
+def encode_mask_to_rle(mask):
+    '''
+    mask: numpy array binary mask 
+    1 - mask 
+    0 - background
+    Returns encoded run length 
+    '''
+    pixels = mask.flatten()
+    pixels = np.concatenate([[0], pixels, [0]])
+    runs = np.where(pixels[1:] != pixels[:-1])[0] + 1
+    runs[1::2] -= runs[::2]
+    return ' '.join(str(x) for x in runs)
+
+
+# RLE로 인코딩된 결과를 mask map으로 복원합니다.
+def decode_rle_to_mask(rle, height, width):
+    s = rle.split()
+    starts, lengths = [np.asarray(x, dtype=int) for x in (s[0:][::2], s[1:][::2])]
+    starts -= 1
+    ends = starts + lengths
+    img = np.zeros(height * width, dtype=np.uint8)
+    
+    for lo, hi in zip(starts, ends):
+        img[lo:hi] = 1
+    
+    return img.reshape(height, width)
+
+
+def inference(args, data_loader):
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    model = torch.load(args.model).to(device)
+    model.eval()
+    
+    rles = []
+    filename_and_class = []
+    with torch.no_grad():
+        with tqdm(total=len(data_loader), desc="[Inference...]", disable=False) as pbar:
+            for images, image_names in data_loader:
+                images = images.to(device)    
+                outputs = model(images)
+                
+                outputs = F.interpolate(outputs, size=(2048, 2048), mode="bilinear")
+                outputs = torch.sigmoid(outputs)
+                outputs = (outputs > args.thr).detach().cpu().numpy()
+                
+                for output, image_name in zip(outputs, image_names):
+                    for c, segm in enumerate(output):
+                        rle = encode_mask_to_rle(segm)
+                        rles.append(rle)
+                        filename_and_class.append(f"{data_loader.dataset.ind2class[c]}_{image_name}")
+                
+                pbar.update(1)
+                    
+    return rles, filename_and_class
+
+
+if __name__=="__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("model", type=str, help="Path to the model to use")
+    parser.add_argument("--image_root", type=str, default="/data/ephemeral/home/data/test/DCM")
+    parser.add_argument("--thr", type=float, default=0.5)
+    parser.add_argument("--output", type=str, default="./output.csv")
+    parser.add_argument("--resize", type=int, default=1024, help="Size to resize images (both width and height)")
+    args = parser.parse_args()
+
+    fnames = {
+        osp.relpath(osp.join(root, fname), start=args.image_root)
+        for root, _, files in os.walk(args.image_root)
+        for fname in files
+        if osp.splitext(fname)[1].lower() == ".png"
+    }
+
+    tf = A.Resize(height=args.resize, width=args.resize)
+
+    test_dataset = XRayInferenceDataset(fnames,
+                                        args.image_root,
+                                        transforms=tf)
+    
+    test_loader = DataLoader(
+        dataset=test_dataset, 
+        batch_size=2,
+        shuffle=False,
+        num_workers=2,
+        drop_last=False
+    )
+
+    rles, filename_and_class = inference(args, test_loader)
+
+    classes, filename = zip(*[x.split("_") for x in filename_and_class])
+    
+    image_name = [os.path.basename(f) for f in filename]
+
+    df = pd.DataFrame({
+        "image_name": image_name,
+        "class": classes,
+        "rle": rles,
+    })
+
+    df.to_csv(args.output, index=False)
\ No newline at end of file
diff --git a/RECcode/cv/loss/base_loss.py b/RECcode/cv/loss/base_loss.py
new file mode 100644
index 0000000..86b14aa
--- /dev/null
+++ b/RECcode/cv/loss/base_loss.py
@@ -0,0 +1,13 @@
+import torch.nn as nn
+
+class CustomBCEWithLogitsLoss(nn.Module):
+    """
+    Base Code에서 사용된 BCEWithLogitsLoss
+    """
+    def __init__(self, **kwargs):
+        super(CustomBCEWithLogitsLoss, self).__init__()
+        self.loss = nn.BCEWithLogitsLoss(**kwargs)
+
+    def forward(self, predictions, targets):
+        return self.loss(predictions, targets)
+
diff --git a/RECcode/cv/loss/loss_selector.py b/RECcode/cv/loss/loss_selector.py
new file mode 100644
index 0000000..f2de7f4
--- /dev/null
+++ b/RECcode/cv/loss/loss_selector.py
@@ -0,0 +1,17 @@
+from .base_loss import CustomBCEWithLogitsLoss
+
+class LossSelector():
+    """
+    loss를 새롭게 추가하기 위한 방법
+        1. loss 폴더 내부에 사용하고자하는 custom loss 구현
+        2. 구현한 Loss Class를 loss_selector.py 내부로 import
+        3. self.loss_classes에 아래와 같은 형식으로 추가
+        4. yaml파일의 loss_name을 설정한 key값으로 변경
+    """
+    def __init__(self) -> None:
+        self.loss_classes = {
+            "BCEWithLogitsLoss" : CustomBCEWithLogitsLoss,
+        }
+
+    def get_loss(self, loss_name, **loss_parameter):
+        return self.loss_classes.get(loss_name, None)(**loss_parameter)
\ No newline at end of file
diff --git a/RECcode/cv/models/base_model.py b/RECcode/cv/models/base_model.py
new file mode 100644
index 0000000..63f17ad
--- /dev/null
+++ b/RECcode/cv/models/base_model.py
@@ -0,0 +1,15 @@
+import torch
+import torch.nn as nn
+import segmentation_models_pytorch as smp
+
+class UnetModel(nn.Module):
+    """
+    Base Model Unet
+    """
+    def __init__(self,
+                 **kwargs):
+        super(UnetModel, self).__init__()
+        self.model = smp.Unet(**kwargs)
+
+    def forward(self, x: torch.Tensor):
+        return self.model(x)
\ No newline at end of file
diff --git a/RECcode/cv/models/model_selector.py b/RECcode/cv/models/model_selector.py
new file mode 100644
index 0000000..83b6db2
--- /dev/null
+++ b/RECcode/cv/models/model_selector.py
@@ -0,0 +1,17 @@
+from .base_model import UnetModel
+
+class ModelSelector():
+    """
+    model을 새롭게 추가하기 위한 방법
+        1. model 폴더 내부에 사용하고자하는 custom model 구현
+        2. 구현한 Model Class를 model_selector.py 내부로 import
+        3. self.model_classes에 아래와 같은 형식으로 추가
+        4. yaml파일의 model_name을 설정한 key값으로 변경
+    """
+    def __init__(self) -> None:
+        self.model_classes = {
+            "Unet" : UnetModel,
+        }
+
+    def get_model(self, model_name, **model_parameter):
+        return self.model_classes.get(model_name, None)(**model_parameter)
\ No newline at end of file
diff --git a/RECcode/cv/scheduler/scheduler_selector.py b/RECcode/cv/scheduler/scheduler_selector.py
new file mode 100644
index 0000000..2177a47
--- /dev/null
+++ b/RECcode/cv/scheduler/scheduler_selector.py
@@ -0,0 +1,28 @@
+from torch.optim import lr_scheduler
+
+# MultiStepLR
+def multi_step_lr(optimizer, **scheduler_parameter):
+    return lr_scheduler.MultiStepLR(optimizer, **scheduler_parameter)
+
+# CosineAnnealingLR
+def cosine_annealing_lr(optimizer, **scheduler_parameter):
+    return lr_scheduler.CosineAnnealingLR(optimizer, **scheduler_parameter)
+
+class SchedulerSelector():
+    """
+    scheduler를 새롭게 추가하기 위한 방법
+        1. torch에서 제공하는 scheduler는 scheduler_selector.py에 함수로 구현
+        2. 직접 구현해야하는 scheduler는 scheduler 폴더 내부에 class로 구현
+        2. 구현한 Scheduler Class를 scheduler_selector.py 내부로 import
+        3. self.scheduler_classes에 아래와 같은 형식으로 추가
+        4. yaml파일의 scheduler_name을 설정한 key값으로 변경
+    """
+    def __init__(self, optimizer) -> None:
+        self.scheduler_classes = {
+            "MultiStepLR" : multi_step_lr,
+            "CosineAnnealingLR" : cosine_annealing_lr
+        }
+        self.optimizer = optimizer
+
+    def get_scheduler(self, scheduler_name, **scheduler_parameter):
+        return self.scheduler_classes.get(scheduler_name, None)(self.optimizer, **scheduler_parameter)
\ No newline at end of file
diff --git a/RECcode/cv/train.py b/RECcode/cv/train.py
new file mode 100644
index 0000000..ee19df1
--- /dev/null
+++ b/RECcode/cv/train.py
@@ -0,0 +1,143 @@
+import os
+import os.path as osp
+
+import torch
+import random
+import warnings
+import numpy as np
+import albumentations as A
+
+import argparse
+import torch.optim as optim
+
+from tqdm.auto import tqdm
+from trainer import Trainer
+from dataset import XRayDataset
+from omegaconf import OmegaConf
+from utils.wandb import set_wandb
+from torch.utils.data import DataLoader
+from loss.loss_selector import LossSelector
+from scheduler.scheduler_selector import SchedulerSelector
+from models.model_selector import ModelSelector
+
+warnings.filterwarnings('ignore')
+
+def set_seed(seed):
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed) # if use multi-GPU
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+    np.random.seed(seed)
+    random.seed(seed)
+
+def setup(cfg):
+    # 이미지 파일명
+    fnames = {
+        osp.relpath(osp.join(root, fname), start=cfg.image_root)
+        for root, _, files in os.walk(cfg.image_root)
+        for fname in files
+        if osp.splitext(fname)[1].lower() == ".png"
+    }
+
+    # label json 파일명
+    labels = {
+        osp.relpath(osp.join(root, fname), start=cfg.label_root)
+        for root, _, files in os.walk(cfg.label_root)
+        for fname in files
+        if osp.splitext(fname)[1].lower() == ".json"
+    }
+
+    return np.array(sorted(fnames)), np.array(sorted(labels))
+
+
+def main(cfg):
+    set_wandb(cfg)
+    set_seed(cfg.seed)
+
+    fnames, labels = setup(cfg)
+
+    transform = [getattr(A, aug)(**params) 
+                                         for aug, params in cfg.transform.items()]
+
+    train_dataset = XRayDataset(fnames,
+                                labels,
+                                cfg.image_root,
+                                cfg.label_root,
+                                fold=cfg.val_fold,
+                                transforms=transform,
+                                is_train=True)
+    
+    valid_dataset = XRayDataset(fnames,
+                                labels,
+                                cfg.image_root,
+                                cfg.label_root,
+                                fold=cfg.val_fold,
+                                transforms=transform,
+                                is_train=False)
+    
+    train_loader = DataLoader(
+        dataset=train_dataset, 
+        batch_size=cfg.train_batch_size,
+        shuffle=True,
+        num_workers=8,
+        drop_last=True,
+    )
+
+    # 주의: validation data는 이미지 크기가 크기 때문에 `num_wokers`는 커지면 메모리 에러가 발생할 수 있습니다.
+    valid_loader = DataLoader(
+        dataset=valid_dataset, 
+        batch_size=cfg.val_batch_size,
+        shuffle=False,
+        num_workers=0,
+        drop_last=False
+    )
+
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+    # model 선택
+    model_selector = ModelSelector()
+    model = model_selector.get_model(cfg.model_name, **cfg.model_parameter)
+
+    model.to(device)
+
+    # optimizer는 고정
+    optimizer = optim.Adam(params=model.parameters(),
+                           lr=cfg.lr,
+                           weight_decay=cfg.weight_decay)
+    
+    # scheduler 선택
+    scheduler_selector = SchedulerSelector(optimizer)
+    scheduler = scheduler_selector.get_scheduler(cfg.scheduler_name, **cfg.scheduler_parameter)
+    
+    # loss 선택
+    loss_selector = LossSelector()
+    criterion = loss_selector.get_loss(cfg.loss_name, **cfg.loss_parameter)
+
+    trainer = Trainer(
+        model=model,
+        device=device,
+        train_loader=train_loader,
+        val_loader=valid_loader,
+        threshold=cfg.threshold,
+        optimizer=optimizer,
+        scheduler=scheduler,
+        criterion=criterion,
+        max_epoch=cfg.max_epoch,
+        save_dir=cfg.save_dir,
+        val_interval=cfg.val_interval
+    )
+
+    trainer.train()
+
+
+if __name__=='__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--config", type=str, default="configs/base_train.yaml")
+
+    args = parser.parse_args()
+    
+    with open(args.config, 'r') as f:
+        cfg = OmegaConf.load(f)
+    
+    main(cfg)
\ No newline at end of file
diff --git a/RECcode/cv/trainer.py b/RECcode/cv/trainer.py
new file mode 100644
index 0000000..7c680ef
--- /dev/null
+++ b/RECcode/cv/trainer.py
@@ -0,0 +1,178 @@
+import os
+import time
+import wandb
+import torch
+import torch.nn as nn
+import os.path as osp
+import torch.optim as optim
+import torch.nn.functional as F
+
+from tqdm.auto import tqdm
+from datetime import timedelta
+from torch.utils.data import DataLoader
+
+
+def dice_coef(y_true, y_pred):
+        y_true_f = y_true.flatten(2)
+        y_pred_f = y_pred.flatten(2)
+        intersection = torch.sum(y_true_f * y_pred_f, -1)
+
+        eps = 0.0001
+        return (2. * intersection + eps) / (torch.sum(y_true_f, -1) + torch.sum(y_pred_f, -1) + eps)
+
+class Trainer:
+    def __init__(self, 
+                 model: nn.Module,
+                 device: torch.device,
+                 train_loader: DataLoader,
+                 val_loader: DataLoader,
+                 threshold: float,
+                 optimizer: optim.Optimizer,
+                 scheduler: optim.lr_scheduler,
+                 criterion: torch.nn.modules.loss._Loss,
+                 max_epoch: int,
+                 save_dir: str,
+                 val_interval: int):
+        self.model = model
+        self.device = device
+        self.train_loader = train_loader
+        self.val_loader = val_loader
+        self.optimizer = optimizer
+        self.scheduler = scheduler
+        self.criterion = criterion
+        self.max_epoch = max_epoch
+        self.save_dir = save_dir
+        self.threshold = threshold
+        self.val_interval = val_interval
+
+
+    def save_model(self, epoch, dice_score, before_path):
+        # checkpoint 저장 폴더 생성
+        if not osp.isdir(self.save_dir):
+            os.makedirs(self.save_dir, exist_ok=True)
+
+        if before_path != "" and osp.exists(before_path):
+            os.remove(before_path)
+
+        output_path = osp.join(self.save_dir, f"best_{epoch}epoch_{dice_score:.4f}.pt")
+        torch.save(self.model, output_path)
+        return output_path
+
+
+    def train_epoch(self, epoch):
+        train_start = time.time()
+        self.model.train()
+        total_loss = 0.0
+
+        with tqdm(total=len(self.train_loader), desc=f"[Training Epoch {epoch}]", disable=False) as pbar:
+            for images, masks in self.train_loader:
+                images, masks = images.to(self.device), masks.to(self.device)
+                outputs = self.model(images)
+
+                loss = self.criterion(outputs, masks)
+                self.optimizer.zero_grad()
+                loss.backward()
+                self.optimizer.step()
+
+                total_loss += loss.item()
+                pbar.update(1)
+                pbar.set_postfix(loss=loss.item())
+
+        train_end = time.time() - train_start 
+        print("Epoch {}, Train Loss: {:.4f} || Elapsed time: {} || ETA: {}\n".format(
+            epoch,
+            total_loss / len(self.train_loader),
+            timedelta(seconds=train_end),
+            timedelta(seconds=train_end * (self.max_epoch - epoch))
+        ))
+        return total_loss / len(self.train_loader)
+    
+
+    def validation(self, epoch):
+        val_start = time.time()
+        self.model.eval()
+
+        total_loss = 0
+        dices = []
+
+        with torch.no_grad():
+            with tqdm(total=len(self.val_loader), desc=f'[Validation Epoch {epoch}]', disable=False) as pbar:
+                for images, masks in self.val_loader:
+                    images, masks = images.to(self.device), masks.to(self.device)
+                    outputs = self.model(images)
+
+                    output_h, output_w = outputs.size(-2), outputs.size(-1)
+                    mask_h, mask_w = masks.size(-2), masks.size(-1)
+
+                    # gt와 prediction의 크기가 다른 경우 prediction을 gt에 맞춰 interpolation 합니다.
+                    if output_h != mask_h or output_w != mask_w:
+                        outputs = F.interpolate(outputs, size=(mask_h, mask_w), mode="bilinear")
+                    
+                    loss = self.criterion(outputs, masks)
+                    total_loss += loss.item()
+
+                    outputs = torch.sigmoid(outputs)
+                    outputs = (outputs > self.threshold).detach().cpu()
+                    masks = masks.detach().cpu()
+
+                    dice = dice_coef(outputs, masks)
+                    dices.append(dice)
+
+                    pbar.update(1)
+                    pbar.set_postfix(dice=torch.mean(dice).item(), loss=loss.item())
+
+        val_end = time.time() - val_start
+        dices = torch.cat(dices, 0)
+        dices_per_class = torch.mean(dices, 0)
+        dice_str = [
+            f"{c:<12}: {d.item():.4f}"
+            for c, d in zip(self.val_loader.dataset.class2ind, dices_per_class)
+        ]
+
+        dice_str = "\n".join(dice_str)
+        print(dice_str)
+        
+        avg_dice = torch.mean(dices_per_class).item()
+        print("avg_dice: {:.4f}".format(avg_dice))
+        print("Validation Loss: {:.4f} || Elapsed time: {}\n".format(
+            total_loss / len(self.val_loader),
+            timedelta(seconds=val_end),
+        ))
+
+        class_dice_dict = {f"{c}'s dice score" : d for c, d in zip(self.val_loader.dataset.class2ind, dices_per_class)}
+        
+        return avg_dice, class_dice_dict, total_loss / len(self.val_loader)
+    
+
+
+    def train(self):
+        print(f'Start training..')
+
+        best_dice = 0.
+        before_path = ""
+        
+        for epoch in range(1, self.max_epoch + 1):
+
+            train_loss = self.train_epoch(epoch)
+
+            wandb.log({
+                "Epoch" : epoch,
+                "Train Loss" : train_loss,
+                "Learning Rate": self.scheduler.get_last_lr()[0]
+            }, step=epoch)
+
+            # validation 주기에 따라 loss를 출력하고 best model을 저장합니다.
+            if epoch % self.val_interval == 0:
+                avg_dice, dices_per_class, val_loss = self.validation(epoch)
+                wandb.log({
+                    "Validation Loss" : val_loss,
+                    "Avg Dice Score" : avg_dice,
+                    **dices_per_class
+                }, step=epoch)
+                
+                if best_dice < avg_dice:
+                    print(f"Best performance at epoch: {epoch}, {best_dice:.4f} -> {avg_dice:.4f}\n")
+                    best_dice = avg_dice
+                    before_path = self.save_model(epoch, best_dice, before_path)
+
+            self.scheduler.step()
\ No newline at end of file
diff --git a/RECcode/cv/unet.sh b/RECcode/cv/unet.sh
new file mode 100644
index 0000000..324bc58
--- /dev/null
+++ b/RECcode/cv/unet.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python train.py
+python inference.py
\ No newline at end of file
diff --git a/RECcode/cv/utils/wandb.py b/RECcode/cv/utils/wandb.py
new file mode 100644
index 0000000..775f4eb
--- /dev/null
+++ b/RECcode/cv/utils/wandb.py
@@ -0,0 +1,18 @@
+import wandb
+
+def set_wandb(configs):
+    wandb.login(key=configs['api_key'])
+    wandb.init(
+        entity=configs['team_name'],
+        project=configs['project_name'],
+        name=configs['experiment_detail'],
+        config={
+                'model': configs['model_name'],
+                'resize': configs['image_size'],
+                'batch_size': configs['train_batch_size'],
+                'loss_name': configs['loss_name'],
+                'scheduler_name': configs['scheduler_name'],
+                'learning_rate': configs['lr'],
+                'epoch': configs['max_epoch']
+            }
+    )
\ No newline at end of file
diff --git a/RECcode/eda.ipynb b/RECcode/eda.ipynb
new file mode 100644
index 0000000..368f91d
--- /dev/null
+++ b/RECcode/eda.ipynb
@@ -0,0 +1,1280 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 356,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "\n",
+    "from glob import glob\n",
+    "from collections import defaultdict\n",
+    "from PIL import Image\n",
+    "import numpy as np\n",
+    "import cv2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 1. Images Metadata"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 304,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 학습 데이터의 경로와 정보를 가진 파일의 경로를 설정\n",
+    "traindata_dir = \"./data/train\"\n",
+    "traindata_info_file = \"./data/train.csv\"\n",
+    "\n",
+    "# 테스트 데이터의 경로와 정보를 가진 파일의 경로를 설정\n",
+    "testdata_dir = \"./data/test\"\n",
+    "testdata_info_file = \"./data/test.csv\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 315,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 학습 데이터의 class, image path, target에 대한 정보가 들어있는 csv파일을 읽기\n",
+    "train_data = pd.read_csv(traindata_info_file)\n",
+    "\n",
+    "# 테스트 데이터\n",
+    "test_data = pd.read_csv(testdata_info_file)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 316,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'pandas.core.frame.DataFrame'>\n",
+      "RangeIndex: 15021 entries, 0 to 15020\n",
+      "Data columns (total 3 columns):\n",
+      " #   Column      Non-Null Count  Dtype \n",
+      "---  ------      --------------  ----- \n",
+      " 0   class_name  15021 non-null  object\n",
+      " 1   image_path  15021 non-null  object\n",
+      " 2   target      15021 non-null  int64 \n",
+      "dtypes: int64(1), object(2)\n",
+      "memory usage: 352.2+ KB\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(None,\n",
+       "   class_name                image_path  target\n",
+       " 0  n01872401  n01872401/sketch_50.JPEG      59\n",
+       " 1  n02417914  n02417914/sketch_11.JPEG     202\n",
+       " 2  n02106166   n02106166/sketch_3.JPEG     138\n",
+       " 3  n04235860   n04235860/sketch_2.JPEG     382\n",
+       " 4  n02056570  n02056570/sketch_40.JPEG      80)"
+      ]
+     },
+     "execution_count": 316,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# 학습 데이터의 정보를 출력\n",
+    "train_info = train_data.info()\n",
+    "train_head = train_data.head()\n",
+    "\n",
+    "train_info, train_head\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "주어진 학습 데이터셋은 15021개의 항목과 3개의 컬럼으로 구성되어 있다.\n",
+    "1. class_name: 클래스 이름, string\n",
+    "2. image_path: 이미지 파일의 경로, string\n",
+    "3. target: 클래스를 의미하는 숫자아이디, integer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 317,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'pandas.core.frame.DataFrame'>\n",
+      "RangeIndex: 10014 entries, 0 to 10013\n",
+      "Data columns (total 1 columns):\n",
+      " #   Column      Non-Null Count  Dtype \n",
+      "---  ------      --------------  ----- \n",
+      " 0   image_path  10014 non-null  object\n",
+      "dtypes: object(1)\n",
+      "memory usage: 78.4+ KB\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(None,\n",
+       "   image_path\n",
+       " 0     0.JPEG\n",
+       " 1     1.JPEG\n",
+       " 2     2.JPEG\n",
+       " 3     3.JPEG\n",
+       " 4     4.JPEG)"
+      ]
+     },
+     "execution_count": 317,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# 테스트 데이터의 정보를 출력.\n",
+    "test_info = test_data.info()\n",
+    "test_head = test_data.head()\n",
+    "\n",
+    "test_info, test_head"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "주어진 테스트 데이터셋은 10014개의 항목과 1개의 컬럼으로 구성되어 있다.\n",
+    "1. image_path: 이미지 파일의 경로, string"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 326,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(       class_name                image_path        target\n",
+       " count       15021                     15021  15021.000000\n",
+       " unique        500                     15021           NaN\n",
+       " top     n04532106  n01872401/sketch_50.JPEG           NaN\n",
+       " freq           31                         1           NaN\n",
+       " mean          NaN                       NaN    249.989082\n",
+       " std           NaN                       NaN    144.471752\n",
+       " min           NaN                       NaN      0.000000\n",
+       " 25%           NaN                       NaN    125.000000\n",
+       " 50%           NaN                       NaN    250.000000\n",
+       " 75%           NaN                       NaN    375.000000\n",
+       " max           NaN                       NaN    499.000000,\n",
+       " 500,\n",
+       " 500)"
+      ]
+     },
+     "execution_count": 326,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# 데이터의 기본적인 통계 정보를 출력\n",
+    "data_description = train_data.describe(include='all')\n",
+    "\n",
+    "# class_name의 unique한 값의 개수를 출력\n",
+    "unique_classes = train_data['class_name'].nunique()\n",
+    "\n",
+    "# target의 unique한 값의 개수를 출력\n",
+    "unique_targets = train_data['target'].nunique()\n",
+    "\n",
+    "data_description, unique_classes, unique_targets"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "기본 통계\n",
+    "- 데이터셋에는 15,021개의 항목이 있음\n",
+    "- 500개의 고유한 클래스 이름과 15021개의 고유한 이미지 경로가 존재\n",
+    "- Target값은 0에서 499까지 500개의 값을 가지고 있음"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 329,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/h6/61flrrfj1l38_nn873r977580000gn/T/ipykernel_38155/2909061321.py:3: FutureWarning: \n",
+      "\n",
+      "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `y` variable to `hue` and set `legend=False` for the same effect.\n",
+      "\n",
+      "  sns.countplot(y=train_data['class_name'], order=train_data['class_name'].value_counts().index, palette='viridis')\n",
+      "/var/folders/h6/61flrrfj1l38_nn873r977580000gn/T/ipykernel_38155/2909061321.py:10: UserWarning: Ignoring `palette` because no `hue` variable has been assigned.\n",
+      "  sns.histplot(train_data['target'], bins=500, kde=False, palette='viridis')\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1600x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1600x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(16, 10))\n",
+    "\n",
+    "# class_name별로 샘플의 개수를 출력\n",
+    "sns.countplot(y=train_data['class_name'], order=train_data['class_name'].value_counts().index, palette='viridis')\n",
+    "plt.title('Distribution of Samples per Class')\n",
+    "plt.xlabel('Number of Samples')\n",
+    "plt.ylabel('Class Name')\n",
+    "\n",
+    "# target 값의 분포를 출력\n",
+    "plt.figure(figsize=(16, 10))\n",
+    "sns.histplot(train_data['target'], bins=500, kde=False, palette='viridis')\n",
+    "plt.title('Distribution of Target Values')\n",
+    "plt.xlabel('Target Value')\n",
+    "plt.ylabel('Number of Samples')\n",
+    "\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Class name 분포\n",
+    "- 대부분 29에서 31 사이의 값을 가지고 있음\n",
+    "\n",
+    "Target 분포\n",
+    "- 대부분 29에서 31 사이의 값을 가지고 있음\n",
+    "\n",
+    "데이터 셋 전반적으로 Class name, Target에 대해서 29~31개의 값을 가지고 있음."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 2. Images - Exploration and processing"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 334,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of train images: 15021\n",
+      "Number of test images: 10014\n"
+     ]
+    }
+   ],
+   "source": [
+    "# glob을 이용하여 이미지 파일의 경로를 읽어옴\n",
+    "train_images = glob(traindata_dir + \"/*/*\")\n",
+    "test_images = glob(testdata_dir + \"/*\")\n",
+    "print(f\"Number of train images: {len(train_images)}\")\n",
+    "print(f\"Number of test images: {len(test_images)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2.1 Getting Image's statistics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 339,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image_prop = defaultdict(list)\n",
+    "\n",
+    "for i, path in enumerate(train_images):\n",
+    "    with Image.open(path) as img:\n",
+    "        image_prop['height'].append(img.height)\n",
+    "        image_prop['width'].append(img.width)\n",
+    "        image_prop['img_aspect_ratio'] = img.width / img.height\n",
+    "        image_prop['mode'].append(img.mode)\n",
+    "        image_prop['format'].append(img.format)\n",
+    "        image_prop['size'].append(round(os.path.getsize(path) / 1e6, 2))\n",
+    "    image_prop['path'].append(path)\n",
+    "    image_prop['image_path'].append(path.split('/')[-2] + \"/\" + path.split('/')[-1])\n",
+    "\n",
+    "image_data = pd.DataFrame(image_prop)\n",
+    "\n",
+    "image_data = image_data.merge(train_data, on='image_path')\n",
+    "#image_data.sort_values(by='target', inplace=True)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 358,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 이미지의 특징을 추출하는 함수\n",
+    "def extract_image_features(image_path):\n",
+    "    \"\"\"\n",
+    "    Extracts features from an image.\n",
+    "    Args:\n",
+    "        image_path (str): Path to the image file.\n",
+    "    Returns:\n",
+    "        width (int): Width of the image.\n",
+    "        height (int): Height of the image.\n",
+    "        mode (str): Mode of the image.\n",
+    "        format (str): Format of the image.\n",
+    "        size (int): Size of the image.\n",
+    "        mean_red (float): Mean of red channel.\n",
+    "        mean_green (float): Mean of green channel.\n",
+    "        mean_blue (float): Mean of blue channel.\n",
+    "    \"\"\"\n",
+    "    try:\n",
+    "        with Image.open(image_path) as img:\n",
+    "            img = img.convert('RGB')\n",
+    "            width, height = img.size\n",
+    "            img_array = np.array(img)\n",
+    "            mean_red = np.mean(img_array[:, :, 0])\n",
+    "            mean_green = np.mean(img_array[:, :, 1])\n",
+    "            mean_blue = np.mean(img_array[:, :, 2])\n",
+    "            format = image_path.split('.')[-1].upper()\n",
+    "            return width, height, img.mode, format, os.path.getsize(image_path), mean_red, mean_green, mean_blue\n",
+    "    except Exception as e:\n",
+    "        return None, None, None, None, None, None, None, None\n",
+    "\n",
+    "image_prop = defaultdict(list)\n",
+    "\n",
+    "for i, path in enumerate(train_images):\n",
+    "    width, height, mode, format, size, mean_red, mean_green, mean_blue = extract_image_features(path)\n",
+    "    image_prop['height'].append(height)\n",
+    "    image_prop['width'].append(width)\n",
+    "    image_prop['mode'].append(mode)\n",
+    "    image_prop['format'].append(format)\n",
+    "    image_prop['size'].append(round(size / 1e6, 2) if size else None)\n",
+    "    image_prop['mean_red'].append(mean_red)\n",
+    "    image_prop['mean_green'].append(mean_green)\n",
+    "    image_prop['mean_blue'].append(mean_blue)\n",
+    "    image_prop['path'].append(path)\n",
+    "    image_prop['image_path'].append(path.split('/')[-2] + \"/\" + path.split('/')[-1])\n",
+    "\n",
+    "image_data = pd.DataFrame(image_prop)\n",
+    "image_data['img_aspect_ratio'] = image_data['width'] / image_data['height']\n",
+    "\n",
+    "image_data = image_data.merge(train_data, on='image_path')\n",
+    "image_data.sort_values(by='target', inplace=True)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 359,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>height</th>\n",
+       "      <th>width</th>\n",
+       "      <th>mode</th>\n",
+       "      <th>format</th>\n",
+       "      <th>size</th>\n",
+       "      <th>mean_red</th>\n",
+       "      <th>mean_green</th>\n",
+       "      <th>mean_blue</th>\n",
+       "      <th>path</th>\n",
+       "      <th>image_path</th>\n",
+       "      <th>img_aspect_ratio</th>\n",
+       "      <th>class_name</th>\n",
+       "      <th>target</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>1803</th>\n",
+       "      <td>356</td>\n",
+       "      <td>450</td>\n",
+       "      <td>RGB</td>\n",
+       "      <td>JPEG</td>\n",
+       "      <td>0.07</td>\n",
+       "      <td>227.089925</td>\n",
+       "      <td>227.089925</td>\n",
+       "      <td>227.089925</td>\n",
+       "      <td>./data/train/n01443537/sketch_27.JPEG</td>\n",
+       "      <td>n01443537/sketch_27.JPEG</td>\n",
+       "      <td>1.264045</td>\n",
+       "      <td>n01443537</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1783</th>\n",
+       "      <td>470</td>\n",
+       "      <td>450</td>\n",
+       "      <td>RGB</td>\n",
+       "      <td>JPEG</td>\n",
+       "      <td>0.05</td>\n",
+       "      <td>234.881868</td>\n",
+       "      <td>234.881868</td>\n",
+       "      <td>234.881868</td>\n",
+       "      <td>./data/train/n01443537/sketch_6.JPEG</td>\n",
+       "      <td>n01443537/sketch_6.JPEG</td>\n",
+       "      <td>0.957447</td>\n",
+       "      <td>n01443537</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1784</th>\n",
+       "      <td>483</td>\n",
+       "      <td>590</td>\n",
+       "      <td>RGB</td>\n",
+       "      <td>JPEG</td>\n",
+       "      <td>0.07</td>\n",
+       "      <td>239.440720</td>\n",
+       "      <td>239.440720</td>\n",
+       "      <td>239.440720</td>\n",
+       "      <td>./data/train/n01443537/sketch_14.JPEG</td>\n",
+       "      <td>n01443537/sketch_14.JPEG</td>\n",
+       "      <td>1.221532</td>\n",
+       "      <td>n01443537</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1785</th>\n",
+       "      <td>800</td>\n",
+       "      <td>800</td>\n",
+       "      <td>RGB</td>\n",
+       "      <td>JPEG</td>\n",
+       "      <td>0.08</td>\n",
+       "      <td>237.483253</td>\n",
+       "      <td>236.771539</td>\n",
+       "      <td>237.349350</td>\n",
+       "      <td>./data/train/n01443537/sketch_34.JPEG</td>\n",
+       "      <td>n01443537/sketch_34.JPEG</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>n01443537</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1786</th>\n",
+       "      <td>800</td>\n",
+       "      <td>800</td>\n",
+       "      <td>RGB</td>\n",
+       "      <td>JPEG</td>\n",
+       "      <td>0.05</td>\n",
+       "      <td>245.134653</td>\n",
+       "      <td>245.134653</td>\n",
+       "      <td>245.134653</td>\n",
+       "      <td>./data/train/n01443537/sketch_35.JPEG</td>\n",
+       "      <td>n01443537/sketch_35.JPEG</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>n01443537</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      height  width mode format  size    mean_red  mean_green   mean_blue  \\\n",
+       "1803     356    450  RGB   JPEG  0.07  227.089925  227.089925  227.089925   \n",
+       "1783     470    450  RGB   JPEG  0.05  234.881868  234.881868  234.881868   \n",
+       "1784     483    590  RGB   JPEG  0.07  239.440720  239.440720  239.440720   \n",
+       "1785     800    800  RGB   JPEG  0.08  237.483253  236.771539  237.349350   \n",
+       "1786     800    800  RGB   JPEG  0.05  245.134653  245.134653  245.134653   \n",
+       "\n",
+       "                                       path                image_path  \\\n",
+       "1803  ./data/train/n01443537/sketch_27.JPEG  n01443537/sketch_27.JPEG   \n",
+       "1783   ./data/train/n01443537/sketch_6.JPEG   n01443537/sketch_6.JPEG   \n",
+       "1784  ./data/train/n01443537/sketch_14.JPEG  n01443537/sketch_14.JPEG   \n",
+       "1785  ./data/train/n01443537/sketch_34.JPEG  n01443537/sketch_34.JPEG   \n",
+       "1786  ./data/train/n01443537/sketch_35.JPEG  n01443537/sketch_35.JPEG   \n",
+       "\n",
+       "      img_aspect_ratio class_name  target  \n",
+       "1803          1.264045  n01443537       0  \n",
+       "1783          0.957447  n01443537       0  \n",
+       "1784          1.221532  n01443537       0  \n",
+       "1785          1.000000  n01443537       0  \n",
+       "1786          1.000000  n01443537       0  "
+      ]
+     },
+     "execution_count": 359,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "image_data.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.1.1 이미지 파일크기 분석"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 346,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1600x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(16, 10))\n",
+    "\n",
+    "# 이미지 파일의 크기 분포를 출력\n",
+    "sns.histplot(image_data['size'], bins=30, kde=True, color='green')\n",
+    "plt.title('Distribution of Image File Sizes')\n",
+    "plt.xlabel('Size (MB)')\n",
+    "plt.ylabel('Frequency')\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "이미지 파일 크기 분포\n",
+    "- 대부분 이미지 파일 크기는 0.05 ~ 0.1 MB 사이에 분포"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.1.2 이미지 파일크기 분석"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 345,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1600x1000 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(16, 10))\n",
+    "# Image height의 분포를 출력\n",
+    "plt.subplot(1, 2, 1)\n",
+    "sns.histplot(image_data['height'], bins=30, kde=True, color='skyblue')\n",
+    "plt.title('Distribution of Image Height')\n",
+    "plt.xlabel('Height')\n",
+    "plt.ylabel('Frequency')\n",
+    "\n",
+    "# Image width의 분포를 출력\n",
+    "plt.subplot(1, 2, 2)\n",
+    "sns.histplot(image_data['width'], bins=30, kde=True, color='orange')\n",
+    "plt.title('Distribution of Image Width')\n",
+    "plt.xlabel('Width')\n",
+    "plt.ylabel('Frequency')\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "이미지의 높이와 너비 분포\n",
+    "- 이미지 높이: 대부분 이미지 높이는 400에서 800 픽셀 사이에 분포\n",
+    "- 이미지 너비: 대부분 이미지 너비는 400에서 800 픽셀 사이에 분포"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 347,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(10, 6))\n",
+    "\n",
+    "# 이미지의 가로 세로 비율을 출력\n",
+    "sns.histplot(image_data['img_aspect_ratio'], bins=30, kde=True, color='purple')\n",
+    "plt.title('Distribution of Image Aspect Ratios')\n",
+    "plt.xlabel('Aspect Ratio')\n",
+    "plt.ylabel('Frequency')\n",
+    "\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "가로세로 비율 분포\n",
+    "- 대부분의 이미지 가로세로 비율을 0.8에서 1.2사이에 분포"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 348,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABSMAAAOLCAYAAACrKZYFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAACbF0lEQVR4nOzde/zXg/3///ur87lEJxQRCzMlkww5V5pt2NCYSszI5vAxZjanoQ37bAxrtim2pTlkGz4OySEMc57THJscSoiSqPR+/v7w8/5666B493zXu+v1cnlfLr2ez+fr+X68Xs93yq3n6/msFEVRBAAAAABgBWtQ1wMAAAAAAKsHMRIAAAAAKIUYCQAAAACUQowEAAAAAEohRgIAAAAApRAjAQAAAIBSiJEAAAAAQCnESAAAAACgFGIkAAAAAFAKMRIAgJXeqaeemkqlUtdj1Bs77rhjdtxxx7oeAwBYDYmRAMBqYezYsalUKqlUKrnrrrsWWV8URbp27ZpKpZKvfvWrdTDhslt//fWrX0ulUknLli2z9dZb57LLLlvic2bMmJEf/ehH2XzzzdOqVas0a9YsPXr0yPDhwxd5Pz7+Xn301bFjx+y000654YYbljrbjBkz0qhRoxx44IFL3Oadd95J8+bNs/feey/fC+dTvfbaaznuuOPSs2fPtGjRIi1btkyfPn1yxhln5O23367r8QAA0qiuBwAAKFOzZs0ybty4bLfddjWW33HHHXn55ZfTtGnTOpps+fTq1Sv/8z//kySZNm1a/vCHP2To0KGZN29eDj300Brb/utf/8rgwYPzzjvvZP/998/3vve9NG3aNFOmTMnf/va3jB07NnfccUd22GGHGs87/fTT07179xRFkddeey1jx47NHnvskWuvvXaJwbZjx47Zbbfd8ve//z1z585NixYtFtlmwoQJef/995caLFl+999/f/bYY4/MmTMnBx54YPr06ZMkeeCBB/Lzn/88kydPzs0331zHUwIAqzsxEgBYreyxxx658sorc/7556dRo//3V6Fx48alT58+eeONN+pwumW3zjrr1Ih5w4YNywYbbJBf/epXNWLkW2+9lW984xtp1KhRHnnkkfTs2bPGfs4444yMHz8+zZs3X+R7DBo0KFtttVX14xEjRqRTp065/PLLl3r26AEHHJAbb7wx//jHP7L//vsvsn7cuHFp27ZtBg8evFyveXX37rvvpmXLlotd9/bbb2evvfZKw4YN8/DDDy9ynM8888z8/ve/L2NMAICl8jFtAGC1MmTIkLz55puZOHFi9bL58+fnqquuyre//e3FPqeqqiq//vWvs9lmm6VZs2bp1KlTDjvssLz11ls1tvv73/+ewYMHZ+21107Tpk2z4YYb5mc/+1kWLlxYY7sdd9wxX/ziF/Pkk09mp512SosWLbLOOuvk7LPP/syvq0OHDunZs2eef/75GstHjx6dadOm5de//vUigSpJKpVKhgwZki9/+cuf+j3atWuX5s2b14i4i7PXXnulZcuWGTdu3CLrZsyYkUmTJuWb3/xmmjZtmjvvvDPf+ta30q1btzRt2jRdu3bNMccck/fee2+p3+O///1vKpVKxo4du9jXdOqpp9ZY9sorr+Tggw9Op06d0rRp02y22Wa55JJLFnnub37zm2y22WZp0aJF1lhjjWy11VaLfR0fd/vtt6dSqeSvf/1rfvzjH6dz585p2bJlvva1r+Wll15aZPv77rsvAwcOTNu2bdOiRYv0798/d999d41tPrpG5pNPPplvf/vbWWONNRY5m/fjfve73+WVV17J//7v/y72OHfq1Ck/+clPlvj8+fPn5+STT06fPn3Stm3btGzZMttvv31uu+22RbYdP358+vTpk9atW6dNmzbZfPPNc95551WvX7BgQU477bRstNFGadasWdZcc81st912NX7PAQCrL2dGAgCrlfXXXz/9+vXL5ZdfnkGDBiVJbrjhhsyaNSv7779/zj///EWec9hhh2Xs2LEZPnx4fvCDH2TKlCm54IIL8vDDD+fuu+9O48aNk3x4rcVWrVrl2GOPTatWrXLrrbfm5JNPzuzZs3POOefU2Odbb72VgQMHZu+9986+++6bq666KieccEI233zz6rmWxwcffJCXX345a6yxRo3l11577We+PuOsWbPyxhtvpCiKzJgxI7/5zW+qPwK8NC1btszXv/71XHXVVZk5c2bat29fve6vf/1rFi5cmAMOOCBJcuWVV2bu3Lk5/PDDs+aaa+Zf//pXfvOb3+Tll1/OlVdeudwzL85rr72WbbbZJpVKJUceeWQ6dOiQG264ISNGjMjs2bNz9NFHJ0l+//vf5wc/+EG++c1v5qijjsr777+ff//737nvvvuWGKo/7swzz0ylUskJJ5yQGTNm5Ne//nV23XXXPPLII9Vnnt56660ZNGhQ+vTpk1NOOSUNGjTImDFjsvPOO+fOO+/M1ltvXWOf3/rWt7LRRhvlrLPOSlEUS/ze//jHP9K8efN885vf/Ezv0ezZs/OHP/whQ4YMyaGHHpp33nknf/zjHzNgwID861//Sq9evZIkEydOzJAhQ7LLLrvkF7/4RZLkqaeeyt13352jjjoqyYchddSoUTnkkEOy9dZbZ/bs2XnggQfy0EMPZbfddvtM8wEA9UgBALAaGDNmTJGkuP/++4sLLrigaN26dTF37tyiKIriW9/6VrHTTjsVRVEU6623XjF48ODq5915551FkuIvf/lLjf3deOONiyz/aH8fd9hhhxUtWrQo3n///epl/fv3L5IUl112WfWyefPmFZ07dy722WefT30t6623XrH77rsXr7/+evH6668Xjz32WPGd73ynSFKMHDmyxrZrrLFG0atXr0X2MXv27Ornv/7668WcOXMWea8++dW0adNi7NixnzpfURTF9ddfXyQpfve739VYvs022xTrrLNOsXDhwqIoFv+ejRo1qqhUKsWLL75YveyUU04pPv5X1ylTphRJijFjxizy/CTFKaecUv14xIgRRZcuXYo33nijxnb7779/0bZt2+oZvv71rxebbbbZMr2+j7vtttuKJMU666xTzJ49u3r5FVdcUSQpzjvvvKIoiqKqqqrYaKONigEDBhRVVVXV282dO7fo3r17sdtuuy3yeocMGbJMM6yxxhrFFltsscwz9+/fv+jfv3/14w8++KCYN29ejW3eeuutolOnTsXBBx9cveyoo44q2rRpU3zwwQdL3PcWW2xR4/cQAMDH+Zg2ALDa2XffffPee+/luuuuyzvvvJPrrrtuiWe+XXnllWnbtm122223vPHGG9Vfffr0SatWrWp8jPXj111855138sYbb2T77bfP3Llz85///KfGflu1alXjDMMmTZpk6623zgsvvLBMr+Hmm29Ohw4d0qFDh2y++eb505/+lOHDhy9yBubs2bPTqlWrRZ7/ne98p/r5HTp0yAknnLDINhdeeGEmTpyYiRMn5s9//nN22mmnHHLIIZkwYcKnzrf77runQ4cONT7iPGXKlNx7770ZMmRIGjT48K+hH3/P3n333bzxxhvZdtttUxRFHn744WV6L5amKIpcffXV2XPPPVMURY1jOGDAgMyaNSsPPfRQkg8/hv7yyy/n/vvv/0zf66CDDkrr1q2rH3/zm99Mly5d8n//939JkkceeSTPPvtsvv3tb+fNN9+snuPdd9/NLrvsksmTJ6eqqqrGPr/3ve8t0/eePXt2je+9vBo2bJgmTZok+fCyBDNnzswHH3yQrbbaqvr9ST58j959992lfuS6Xbt2eeKJJ/Lss89+5nkAgPrLx7QBgNVOhw4dsuuuu2bcuHGZO3duFi5cuMSPtz777LOZNWtWOnbsuNj1M2bMqP71E088kZ/85Ce59dZbM3v27BrbzZo1q8bjddddN5VKpcayNdZYI//+97+X6TX07ds3Z5xxRhYuXJjHH388Z5xxRt56663qoPSR1q1bZ86cOYs8//TTT8+RRx6ZJEv86OzWW29d4wY2Q4YMSe/evXPkkUfmq1/96iLf6+MaNWqU/fbbLxdddFFeeeWVrLPOOtVh8qOPaCfJ1KlTc/LJJ+cf//jHItfg/OR79lm8/vrrefvtt3PxxRfn4osvXuw2Hx3DE044Ibfccku23nrr9OjRI7vvvnu+/e1v5ytf+coyfa+NNtqoxuNKpZIePXrkv//9b5JUx7mhQ4cucR+zZs2q8VH77t27L9P3btOmTd55551l2nZJLr300vzyl7/Mf/7znyxYsGCxMxxxxBG54oorMmjQoKyzzjrZfffds++++2bgwIHV25x++un5+te/no033jhf/OIXM3DgwHznO9/Jl770pc81HwBQP4iRAMBq6dvf/nYOPfTQTJ8+PYMGDUq7du0Wu11VVVU6duyYv/zlL4td36FDhyQf3s24f//+adOmTU4//fRsuOGGadasWR566KGccMIJi5zx1rBhw8Xur1jKdQE/bq211squu+6aJBkwYEB69uyZr371qznvvPNy7LHHVm/Xs2fPPProo1mwYEH1tS2TfKYw1KBBg+y0004577zz8uyzz2azzTZb6vYHHnhgLrjgglx++eU57rjjcvnll2fTTTetvv7gwoULs9tuu2XmzJk54YQT0rNnz7Rs2TKvvPJKhg0btsh79nGfDLkf+eTNgj7ax4EHHrjECPjRe7HJJpvk6aefznXXXZcbb7wxV199dS666KKcfPLJOe2005b6WpfFR7Occ8451e/BJ33yLNbF3eV8cXr27JlHHnkk8+fPX2okXpI///nPGTZsWL7xjW/khz/8YTp27JiGDRtm1KhRNW6K1LFjxzzyyCO56aabcsMNN+SGG27ImDFjctBBB+XSSy9Nkuywww55/vnn8/e//z0333xz/vCHP+RXv/pVRo8enUMOOWS5ZwMA6hcxEgBYLe2111457LDDcu+99+avf/3rErfbcMMNc8stt+QrX/nKUsPQ7bffnjfffDMTJkzIDjvsUL18ypQptTr3kgwePDj9+/fPWWedlcMOOywtW7ZMknz1q1/Nvffem2uuuSb77rvv5/4+H3zwQZIs9mzLT+rbt2823HDDjBs3LrvttlueeOKJnHnmmdXrH3vssTzzzDO59NJLc9BBB1UvX5a7Ln909uDbb79dY/mLL75Y43GHDh3SunXrLFy4sDreLk3Lli2z3377Zb/99sv8+fOz995758wzz8yJJ56YZs2aLfW5n/xYclEUee6556pj54Ybbpjkw7MYl2WW5bHnnnvmnnvuydVXX50hQ4Ys9/OvuuqqbLDBBpkwYUKN0HvKKacssm2TJk2y5557Zs8990xVVVWOOOKI/O53v8tPf/rT9OjRI0nSvn37DB8+PMOHD8+cOXOyww475NRTTxUjAYC4ZiQAsFpq1apVfvvb3+bUU0/NnnvuucTt9t133yxcuDA/+9nPFln3wQcfVMewj850/PiZjfPnz89FF11Uu4MvxQknnJA333wzv//976uXHX744enUqVOOOeaYPPPMM4s8Z1nPxEySBQsW5Oabb06TJk2yySabLNNzDjjggDz88MM55ZRTUqlUalybc3HvWVEUOe+88z51v23atMlaa62VyZMn11j+yfe7YcOG2WeffXL11Vfn8ccfX2Q/r7/+evWv33zzzRrrmjRpkk033TRFUdT42PKSXHbZZTU+Kn3VVVdl2rRp1XdH79OnTzbccMOce+65i425H59leX3ve99Lly5d8j//8z+LPc4zZszIGWecscTnL+5Y3HfffbnnnntqbPfJ96hBgwbVsXXevHmL3aZVq1bp0aNH9XoAYPXmzEgAYLW1tGv3faR///457LDDMmrUqDzyyCPZfffd07hx4zz77LO58sorc9555+Wb3/xmtt1226yxxhoZOnRofvCDH6RSqeRPf/rTcsW+z2vQoEH54he/mP/93//NyJEj07hx47Rv3z7XXHNN9txzz2yxxRbZf//98+UvfzmNGzfOSy+9lCuvvDJJ0q1bt0X2d8MNN1TfeGfGjBkZN25cnn322fzoRz9KmzZtlmmmAw88MKeffnr+/ve/5ytf+UrWX3/96nU9e/bMhhtumOOOOy6vvPJK2rRpk6uvvnqRa0cuySGHHJKf//znOeSQQ7LVVltl8uTJiw1xP//5z3Pbbbelb9++OfTQQ7Pppptm5syZeeihh3LLLbdk5syZST686U7nzp3zla98JZ06dcpTTz2VCy64IIMHD16mm8O0b98+2223XYYPH57XXnstv/71r9OjR48ceuihST4Md3/4wx8yaNCgbLbZZhk+fHjWWWedvPLKK7ntttvSpk2bXHvttcv02j9pjTXWyDXXXJM99tgjvXr1yoEHHpg+ffokSR566KFcfvnl6dev3xKf/9WvfjUTJkzIXnvtlcGDB2fKlCkZPXp0Nt100xrh9JBDDsnMmTOz8847Z911182LL76Y3/zmN+nVq1d1oN50002z4447pk+fPmnfvn0eeOCBXHXVVdXXKAUAVnN1cxNvAIByjRkzpkhS3H///Uvdbr311isGDx68yPKLL7646NOnT9G8efOidevWxeabb14cf/zxxauvvlq9zd13311ss802RfPmzYu11167OP7444ubbrqpSFLcdttt1dv179+/2GyzzRb5HkOHDi3WW2+9T30tS5qxKIpi7NixRZJizJgxNZZPmzat+OEPf1hsuummRfPmzYumTZsWG2ywQXHQQQcVkydPrrHtR+/Vx7+aNWtW9OrVq/jtb39bVFVVfeqMH/flL3+5SFJcdNFFi6x78skni1133bVo1apVsdZaaxWHHnpo8eijjy7yGk455ZTik391nTt3bjFixIiibdu2RevWrYt99923mDFjRpGkOOWUU2ps+9prrxUjR44sunbtWjRu3Ljo3LlzscsuuxQXX3xx9Ta/+93vih122KFYc801i6ZNmxYbbrhh8cMf/rCYNWvWUl/fbbfdViQpLr/88uLEE08sOnbsWDRv3rwYPHhw8eKLLy6y/cMPP1zsvffe1d9nvfXWK/bdd99i0qRJi7ze119/fanf+5NeffXV4phjjik23njjolmzZkWLFi2KPn36FGeeeWaN19G/f/+if//+1Y+rqqqKs846q1hvvfWKpk2bFr179y6uu+66RX4mr7rqqmL33XcvOnbsWDRp0qTo1q1bcdhhhxXTpk2r3uaMM84ott5666Jdu3ZF8+bNi549exZnnnlmMX/+/OV6LQBA/VQpihL/uR4AAOqZ22+/PTvttFOuvPLKJd6VHQCAD7lmJAAAAABQCjESAAAAACiFGAkAAAAAlMI1IwEAAACAUjgzEgAAAAAohRgJAAAAAJSiUV0PsDKoqqrKq6++mtatW6dSqdT1OAAAAACwSimKIu+8807WXnvtNGiw5PMfxcgkr776arp27VrXYwAAAADAKu2ll17Kuuuuu8T1YmSS1q1bJ/nwzWrTpk0dTwMAAAAAq5bZs2ena9eu1Z1tScTIpPqj2W3atBEjAQAAAOAz+rRLILqBDQAAAABQCjESAAAAACiFGAkAAAAAlMI1IwEAAABYRFEU+eCDD7Jw4cK6HoWVQMOGDdOoUaNPvSbkpxEjAQAAAKhh/vz5mTZtWubOnVvXo7ASadGiRbp06ZImTZp85n2IkQAAAABUq6qqypQpU9KwYcOsvfbaadKkyec+G45VW1EUmT9/fl5//fVMmTIlG220URo0+GxXfxQjAQAAAKg2f/78VFVVpWvXrmnRokVdj8NKonnz5mncuHFefPHFzJ8/P82aNftM+3EDGwAAAAAW8VnPfKP+qo2fCT9VAAAAAEApxEgAAAAAoBRiJAAAAADLplIp94vlVqlU8re//a2ux1giMRIAAACAemHYsGGpVCr53ve+t8i6kSNHplKpZNiwYeUP9gljx45NpVJJpVJJgwYN0qVLl+y3336ZOnVqXY+2womRAAAAANQbXbt2zfjx4/Pee+9VL3v//fczbty4dOvWrQ4nq6lNmzaZNm1aXnnllVx99dV5+umn861vfauux1rhxEgAAAAA6o0tt9wyXbt2zYQJE6qXTZgwId26dUvv3r1rbFtVVZVRo0ale/fuad68ebbYYotcddVV1esXLlyYESNGVK//whe+kPPOO6/GPoYNG5ZvfOMbOffcc9OlS5esueaaGTlyZBYsWLDUOSuVSjp37pwuXbpk2223zYgRI/Kvf/0rs2fPrt7m73//e7bccss0a9YsG2ywQU477bR88MEH1eufffbZ7LDDDmnWrFk23XTTTJw48TO9Z2VqVNcDAAAAAEBtOvjggzNmzJgccMABSZJLLrkkw4cPz+23315ju1GjRuXPf/5zRo8enY022iiTJ0/OgQcemA4dOqR///6pqqrKuuuumyuvvDJrrrlm/vnPf+a73/1uunTpkn333bd6P7fddlu6dOmS2267Lc8991z222+/9OrVK4ceeugyzTtjxoxcc801adiwYRo2bJgkufPOO3PQQQfl/PPPz/bbb5/nn38+3/3ud5Mkp5xySqqqqrL33nunU6dOue+++zJr1qwcffTRn//NW8HESAAAAADqlQMPPDAnnnhiXnzxxSTJ3XffnfHjx9eIkfPmzctZZ52VW265Jf369UuSbLDBBrnrrrvyu9/9Lv3790/jxo1z2mmnVT+ne/fuueeee3LFFVfUiJFrrLFGLrjggjRs2DA9e/bM4MGDM2nSpKXGyFmzZqVVq1YpiiJz585NkvzgBz9Iy5YtkySnnXZafvSjH2Xo0KHVs/3sZz/L8ccfn1NOOSW33HJL/vOf/+Smm27K2muvnSQ566yzMmjQoFp4B1ccMRIAAACAeqVDhw4ZPHhwxo4dm6IoMnjw4Ky11lo1tnnuuecyd+7c7LbbbjWWz58/v8bHuS+88MJccsklmTp1at57773Mnz8/vXr1qvGczTbbrPqMxiTp0qVLHnvssaXO2Lp16zz00ENZsGBBbrjhhvzlL3/JmWeeWb3+0Ucfzd13311j2cKFC/P+++9n7ty5eeqpp9K1a9fqEJmkOqquzMRIAAAAAOqdgw8+OEceeWSSD4PiJ82ZMydJcv3112edddapsa5p06ZJkvHjx+e4447LL3/5y/Tr1y+tW7fOOeeck/vuu6/G9o0bN67xuFKppKqqaqnzNWjQID169EiSbLLJJnn++edz+OGH509/+lP1fKeddlr23nvvRZ7brFmzpe57ZSZGAgAAAFDvDBw4MPPnz0+lUsmAAQMWWb/pppumadOmmTp1avr377/Yfdx9993Zdtttc8QRR1Qve/7551fIvD/60Y+y4YYb5phjjsmWW26ZLbfcMk8//XR1sPykTTbZJC+99FKmTZuWLl26JEnuvffeFTJbbRIjAQAAAKh3GjZsmKeeeqr615/UunXrHHfccTnmmGNSVVWV7bbbLrNmzcrdd9+dNm3aZOjQodloo41y2WWX5aabbkr37t3zpz/9Kffff3+6d+9e6/N27do1e+21V04++eRcd911Ofnkk/PVr3413bp1yze/+c00aNAgjz76aB5//PGcccYZ2XXXXbPxxhtn6NChOeecczJ79uycdNJJtT5XbWtQ1wMAAAAAsIooinK/Pqc2bdqkTZs2S1z/s5/9LD/96U8zatSobLLJJhk4cGCuv/766th42GGHZe+9985+++2Xvn375s0336xxlmRtO+aYY3L99dfnX//6VwYMGJDrrrsuN998c7785S9nm222ya9+9aust956ST78mPc111yT9957L1tvvXUOOeSQGteXXFlViqIWjuwqbvbs2Wnbtm1mzZq11B9QAAAAgPru/fffz5QpU9K9e/dV+tqE1L6l/Wwsa19zZiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUIpGdT0AAAAAAKuGymmVUr9fcUpR6vdjxXNmJAAAAAD1wrBhw1KpVPK9731vkXUjR45MpVLJsGHDyh9sMebPn59zzjknW265ZVq2bJm2bdtmiy22yE9+8pO8+uqrdT3eCiNGAqzmKpXa/wIAAKgrXbt2zfjx4/Pee+9VL3v//fczbty4dOvWrQ4n+3/mzZuX3XbbLWeddVaGDRuWyZMn57HHHsv555+fN954I7/5zW+W+Nz58+eXOGntEyMBAAAAqDe23HLLdO3aNRMmTKheNmHChHTr1i29e/eusW1VVVVGjRqV7t27p3nz5tliiy1y1VVXVa9fuHBhRowYUb3+C1/4Qs4777wa+xg2bFi+8Y1v5Nxzz02XLl2y5pprZuTIkVmwYMESZ/zVr36Vu+66K7feemt+8IMfpE+fPunWrVv69++f0aNH56yzzqredscdd8yRRx6Zo48+OmuttVYGDBiQJHn88cczaNCgtGrVKp06dcp3vvOdvPHGG8v82m6//fZUKpVMmjQpW221VVq0aJFtt902Tz/99HK+48tHjAQAAACgXjn44IMzZsyY6seXXHJJhg8fvsh2o0aNymWXXZbRo0fniSeeyDHHHJMDDzwwd9xxR5IPg966666bK6+8Mk8++WROPvnk/PjHP84VV1xRYz+33XZbnn/++dx222259NJLM3bs2IwdO3aJ811++eXZbbfdFomjH6l84iNnl156aZo0aZK77747o0ePzttvv52dd945vXv3zgMPPJAbb7wxr732Wvbdd99lfm0fOemkk/LLX/4yDzzwQBo1apSDDz54iXPXhkpRFKv9lUBnz56dtm3bZtasWWnTpk1djwNQqhXxsWp/sgAAwKrr/fffz5QpU9K9e/c0a9asxrqV/QY2w4YNy9tvv53f//736dq1a/VZfj179sxLL72UQw45JO3atcvYsWMzb968tG/fPrfcckv69etXvY9DDjkkc+fOzbhx4xb7PY488shMnz69+izDYcOG5fbbb8/zzz+fhg0bJkn23XffNGjQIOPHj1/sPpo3b57vfve7Nc6y3GuvvTJx4sQkyZe+9KX885//TPLhmZGzZ8/OQw89VL3tGWeckTvvvDM33XRT9bKXX365+jWvt956n/rabr/99uy000655ZZbsssuuyRJ/u///i+DBw/Oe++9t8ixT5b+s7Gsfc3dtAFWISvmD37lEAAAqF86dOiQwYMHZ+zYsSmKIoMHD85aa61VY5vnnnsuc+fOzW677VZj+fz582ucsXjhhRfmkksuydSpU/Pee+9l/vz56dWrV43nbLbZZtUhMkm6dOmSxx57bLlmvuiii/Luu+/m/PPPz+TJk2us69OnT43Hjz76aG677ba0atVqkf08//zzWbBgwTK9tuTD8PnxuZNkxowZK+z6mmIkAAAAAPXOwQcfnCOPPDLJh0Hxk+bMmZMkuf7667POOuvUWNe0adMkyfjx43Pcccfll7/8Zfr165fWrVvnnHPOyX333Vdj+8aNG9d4XKlUUlVVtcTZNtpoo0WuzfhRCGzfvv0i27ds2XKR2ffcc8/84he/WGTbLl265PHHH//U17a42T/6ePjSZv+8xEgAAAAA6p2BAwdm/vz5qVQq1Td9+bhNN900TZs2zdSpU9O/f//F7uPuu+/OtttumyOOOKJ62fPPP/+5ZxsyZEh+8pOf5OGHH17idSOXZsstt8zVV1+d9ddfP40aLZr3luW11RUxEgAAPk0tX2C3cmqt7u5Dp9b+ZTdcAxiAVVnDhg3z1FNPVf/6k1q3bp3jjjsuxxxzTKqqqrLddttl1qxZufvuu9OmTZsMHTo0G220US677LLcdNNN6d69e/70pz/l/vvvT/fu3T/XbMccc0yuv/767LLLLjnllFOy/fbbZ4011sgzzzyTG264YbHzftzIkSPz+9//PkOGDMnxxx+f9u3b57nnnsv48ePzhz/8YZleW10RIwEAAABYJst7Q5m69mk3Kv7Zz36WDh06ZNSoUXnhhRfSrl27bLnllvnxj3+cJDnssMPy8MMPZ7/99kulUsmQIUNyxBFH5IYbbvhcczVr1iyTJk3Kr3/964wZMyYnnnhiqqqq0r179wwaNCjHHHPMUp+/9tpr5+67784JJ5yQ3XffPfPmzct6662XgQMHpkGDBsv02uqKu2nH3bSBVccKuYGNM2kAPp0zIwFYjSztjsms3mrjbtoNVvSQAAAAAACJGAkAAAAAlESMBAAAAABKIUYCrEiVSu1+AQAAwCpMjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKRrV9QCk9m9KURS1u7+smPtmrIAxAQAAAFiJiZH1UOW0FXHHXeUQAAAAVncr4mSlpVndT2Raf/31c/TRR+foo4+u61FqjRgJAPBZ1PLfxCun1uruPnRq7f/tfXX/HwIAYOU2bNiwXHrppTnssMMyevToGutGjhyZiy66KEOHDs3YsWPrZsD/39ixYzN8+PDqxy1btswXvvCFnHTSSdl7773rcLIVzzUjAQAAAKg3unbtmvHjx+e9996rXvb+++9n3Lhx6datWx1OVlObNm0ybdq0TJs2LQ8//HAGDBiQfffdN08//XRdj7ZCiZEAAAAA1BtbbrllunbtmgkTJlQvmzBhQrp165bevXvX2LaqqiqjRo1K9+7d07x582yxxRa56qqrqtcvXLgwI0aMqF7/hS98Ieedd16NfQwbNizf+MY3cu6556ZLly5Zc801M3LkyCxYsGCpc1YqlXTu3DmdO3fORhttlDPOOCMNGjTIv//978Vu/9///jeVSiWPPPJI9bK33347lUolt99+e/Wyxx9/PIMGDUqrVq3SqVOnfOc738kbb7zxaW9bacRIAAAAAOqVgw8+OGPGjKl+fMkll9T4WPRHRo0alcsuuyyjR4/OE088kWOOOSYHHnhg7rjjjiQfxsp11103V155ZZ588smcfPLJ+fGPf5wrrriixn5uu+22PP/887ntttty6aWXZuzYscv1UfCFCxfm0ksvTfJhTP2s3n777ey8887p3bt3Hnjggdx444157bXXsu+++37mfdY214wEAAAAoF458MADc+KJJ+bFF19Mktx9990ZP358jTMI582bl7POOiu33HJL+vXrlyTZYIMNctddd+V3v/td+vfvn8aNG+e0006rfk737t1zzz335IorrqgR+NZYY41ccMEFadiwYXr27JnBgwdn0qRJOfTQQ5c446xZs9KqVaskyXvvvZfGjRvn4osvzoYbbviZX/cFF1yQ3r1756yzzqpedskll6Rr16555plnsvHGG3/mfdcWMRIAaktt31rQnUIAAOAz6dChQwYPHpyxY8emKIoMHjw4a621Vo1tnnvuucydOze77bZbjeXz58+v8XHuCy+8MJdcckmmTp2a9957L/Pnz0+vXr1qPGezzTZLw4YNqx936dIljz322FJnbN26dR566KEkydy5c3PLLbfke9/7XtZcc83sueeen+Vl59FHH81tt91WHTk/7vnnnxcjAYAlq5xWy3EzSXGKwAkAwOrh4IMPzpFHHpnkw6D4SXPmzEmSXH/99VlnnXVqrGvatGmSZPz48TnuuOPyy1/+Mv369Uvr1q1zzjnn5L777quxfePGjWs8rlQqqaqqWup8DRo0SI8ePaoff+lLX8rNN9+cX/ziF4uNkQ0afHi1xeJjJy188rqUc+bMyZ577plf/OIXizy/S5cuS52nLGIkAAAAAPXOwIEDM3/+/FQqlQwYMGCR9ZtuummaNm2aqVOnpn///ovdx913351tt902RxxxRPWy559/foXN3LBhwxp3Af+4Dh06JEmmTZtWfebmx29mk3x4vcmrr74666+/fho1Wjmz38o5FQCwQtT2J8kTnyYHAGDl1LBhwzz11FPVv/6k1q1b57jjjssxxxyTqqqqbLfddpk1a1buvvvutGnTJkOHDs1GG22Uyy67LDfddFO6d++eP/3pT7n//vvTvXv3zz1fURSZPn16kg+vGTlx4sTcdNNNOfnkkxe7ffPmzbPNNtvk5z//ebp3754ZM2bkJz/5SY1tRo4cmd///vcZMmRIjj/++LRv3z7PPfdcxo8fnz/84Q+LfR/KJkYCAAAAsExWtX+IbtOmzVLX/+xnP0uHDh0yatSovPDCC2nXrl223HLL/PjHP06SHHbYYXn44Yez3377pVKpZMiQITniiCNyww03fO7ZZs+eXf3R6aZNm2a99dbL6aefnhNOOGGJz7nkkksyYsSI9OnTJ1/4whdy9tlnZ/fdd69ev/baa+fuu+/OCSeckN133z3z5s3Leuutl4EDB1Z/zLuuVYpiVfsxqn2zZ89O27ZtM2vWrE/9IV0havk0lcqptbq7D51a+z8mfvJYLfj9vXpxvFcvjvfqxfEGYDXy/vvvZ8qUKenevXuaNWtW1+OwElnaz8ay9rWVI4kCAAAAAPWeGAkAAAAAlEKMBAAAAABKIUYCAAAAAKVwN20AAABg9eCGZMv5PHcyo6ba+JlwZiQAAAAA1Ro3bpwkmTt3bh1Pwsrmo5+Jj35GPgtnRgIAAABQrWHDhmnXrl1mzJiRJGnRokUqtXxWKauWoigyd+7czJgxI+3atUvDhg0/877ESAAAAABq6Ny5c5JUB0lIknbt2lX/bHxWYiQAAAAANVQqlXTp0iUdO3bMggUL6nocVgKNGzf+XGdEfkSMBAAAAGCxGjZsWCsBCj7iBjYAAAAAQCnESAAAAACgFGIkAAAAAFAK14wEAABg9VWp1O7+iqJ29wdQz4iRAAAAUEsqp9Vy3EySU2s/cGqmQF3xMW0AAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABK4W7aAAAAANQ/lVq+u73b0NcKMRIAAAAAPkXltFqOm0mKU1a/wClGAgAAAEAdqO2TN5OV/wRO14wEAAAAAEohRgIAAAAApRAjAQAAAIBSiJEAAAAAQCncwAbKVstXp62cWqu7+9CptX+125X9AroAAADAiidGAgAAfNwq8I/HxSn+pReAVZOPaQMAAAAApXBmJAAAwCqmlk/eTOKyOgCUw5mRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBR1GiNHjRqVL3/5y2ndunU6duyYb3zjG3n66adrbPP+++9n5MiRWXPNNdOqVavss88+ee2112psM3Xq1AwePDgtWrRIx44d88Mf/jAffPBBmS8FAAAAAPgUdRoj77jjjowcOTL33ntvJk6cmAULFmT33XfPu+++W73NMccck2uvvTZXXnll7rjjjrz66qvZe++9q9cvXLgwgwcPzvz58/PPf/4zl156acaOHZuTTz65Ll4SAAAAALAEjerym9944401Ho8dOzYdO3bMgw8+mB122CGzZs3KH//4x4wbNy4777xzkmTMmDHZZJNNcu+992abbbbJzTffnCeffDK33HJLOnXqlF69euVnP/tZTjjhhJx66qlp0qRJXbw0AAAAAOATVqprRs6aNStJ0r59+yTJgw8+mAULFmTXXXet3qZnz57p1q1b7rnnniTJPffck8033zydOnWq3mbAgAGZPXt2nnjiicV+n3nz5mX27Nk1vgAAAACAFWuliZFVVVU5+uij85WvfCVf/OIXkyTTp09PkyZN0q5duxrbdurUKdOnT6/e5uMh8qP1H61bnFGjRqVt27bVX127dq3lVwMAAAAAfNJKEyNHjhyZxx9/POPHj1/h3+vEE0/MrFmzqr9eeumlFf49AQAAAGB1V6fXjPzIkUcemeuuuy6TJ0/OuuuuW728c+fOmT9/ft5+++0aZ0e+9tpr6dy5c/U2//rXv2rs76O7bX+0zSc1bdo0TZs2reVXAQAAAAAsTZ2eGVkURY488shcc801ufXWW9O9e/ca6/v06ZPGjRtn0qRJ1cuefvrpTJ06Nf369UuS9OvXL4899lhmzJhRvc3EiRPTpk2bbLrppuW8EAAAAADgU9XpmZEjR47MuHHj8ve//z2tW7euvsZj27Zt07x587Rt2zYjRozIsccem/bt26dNmzb5/ve/n379+mWbbbZJkuy+++7ZdNNN853vfCdnn312pk+fnp/85CcZOXKksx8BAAAAYCVSpzHyt7/9bZJkxx13rLF8zJgxGTZsWJLkV7/6VRo0aJB99tkn8+bNy4ABA3LRRRdVb9uwYcNcd911Ofzww9OvX7+0bNkyQ4cOzemnn17WywAAAAAAlkGdxsiiKD51m2bNmuXCCy/MhRdeuMRt1ltvvfzf//1fbY4GAAAAANSyleZu2gAAAABA/SZGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAoRZ3GyMmTJ2fPPffM2muvnUqlkr/97W811g8bNiyVSqXG18CBA2tsM3PmzBxwwAFp06ZN2rVrlxEjRmTOnDklvgoAAAAAYFnUaYx89913s8UWW+TCCy9c4jYDBw7MtGnTqr8uv/zyGusPOOCAPPHEE5k4cWKuu+66TJ48Od/97ndX9OgAAAAAwHJqVJfffNCgQRk0aNBSt2natGk6d+682HVPPfVUbrzxxtx///3ZaqutkiS/+c1vsscee+Tcc8/N2muvXeszAwAAAACfzUp/zcjbb789HTt2zBe+8IUcfvjhefPNN6vX3XPPPWnXrl11iEySXXfdNQ0aNMh99923xH3Omzcvs2fPrvEFAAAAAKxYK3WMHDhwYC677LJMmjQpv/jFL3LHHXdk0KBBWbhwYZJk+vTp6dixY43nNGrUKO3bt8/06dOXuN9Ro0albdu21V9du3Zdoa8DAAAAAKjjj2l/mv3337/615tvvnm+9KUvZcMNN8ztt9+eXXbZ5TPv98QTT8yxxx5b/Xj27NmCJAAAAACsYCv1mZGftMEGG2SttdbKc889lyTp3LlzZsyYUWObDz74IDNnzlzidSaTD69D2aZNmxpfAAAAAMCKtUrFyJdffjlvvvlmunTpkiTp169f3n777Tz44IPV29x6662pqqpK375962pMAAAAAGAx6vRj2nPmzKk+yzFJpkyZkkceeSTt27dP+/btc9ppp2WfffZJ586d8/zzz+f4449Pjx49MmDAgCTJJptskoEDB+bQQw/N6NGjs2DBghx55JHZf//93UkbAAAAAFYydXpm5AMPPJDevXund+/eSZJjjz02vXv3zsknn5yGDRvm3//+d772ta9l4403zogRI9KnT5/ceeedadq0afU+/vKXv6Rnz57ZZZddsscee2S77bbLxRdfXFcvCQAAAABYgjo9M3LHHXdMURRLXH/TTTd96j7at2+fcePG1eZYAAAAAMAKsEpdMxIAAAAAWHWJkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAACl+Fwx8v3336+tOQAAAACAem65Y2RVVVV+9rOfZZ111kmrVq3ywgsvJEl++tOf5o9//GOtDwgAAAAA1A/LHSPPOOOMjB07NmeffXaaNGlSvfyLX/xi/vCHP9TqcAAAAABA/bHcMfKyyy7LxRdfnAMOOCANGzasXr7FFlvkP//5T60OBwAAAADUH8sdI1955ZX06NFjkeVVVVVZsGBBrQwFAAAAANQ/yx0jN91009x5552LLL/qqqvSu3fvWhkKAAAAAKh/Gi3vE04++eQMHTo0r7zySqqqqjJhwoQ8/fTTueyyy3LdddetiBkBAAAAgHpguc+M/PrXv55rr702t9xyS1q2bJmTTz45Tz31VK699trstttuK2JGAAAAAKAeWO4zI5Nk++23z8SJE2t7FgAAAACgHlvuMyMBAAAAAD6L5T4zskGDBqlUKktcv3Dhws81EAAAAABQPy13jLzmmmtqPF6wYEEefvjhXHrppTnttNNqbTAAAAAAoH5Z7hj59a9/fZFl3/zmN7PZZpvlr3/9a0aMGFErgwEAAAAA9UutXTNym222yaRJk2prdwAAAABAPVMrMfK9997L+eefn3XWWac2dgcAAAAA1EPL/THtNdZYo8YNbIqiyDvvvJMWLVrkz3/+c60OBwAAAADUH8sdI3/1q1/ViJENGjRIhw4d0rdv36yxxhq1OhwAAAAAUH8sd4wcNmzYChgDAAAAAKjvlilG/vvf/17mHX7pS1/6zMMAAAAAAPXXMsXIXr16pVKppCiKpW5XqVSycOHCWhkMAAAAAKhflilGTpkyZUXPAQAAAADUc8sUI9dbb70VPQcAAAAAUM8t9w1sPvLkk09m6tSpmT9/fo3lX/va1z73UAAAAABA/bPcMfKFF17IXnvtlccee6zGdSQrlUqSuGYkAAAAALBYDZb3CUcddVS6d++eGTNmpEWLFnniiScyefLkbLXVVrn99ttXwIgAAAAAQH2w3GdG3nPPPbn11luz1lprpUGDBmnQoEG22267jBo1Kj/4wQ/y8MMPr4g5AQAAAIBV3HKfGblw4cK0bt06SbLWWmvl1VdfTfLhTW6efvrp2p0OAAAAAKg3lvvMyC9+8Yt59NFH07179/Tt2zdnn312mjRpkosvvjgbbLDBipgRAAAAAKgHljtG/uQnP8m7776bJDn99NPz1a9+Ndtvv33WXHPN/PWvf631AQEAAACA+mGZY+RWW22VQw45JN/+9rfTpk2bJEmPHj3yn//8JzNnzswaa6xRfUdtAAAAAIBPWuZrRm6xxRY5/vjj06VLlxx00EE17pzdvn17IRIAAAAAWKpljpF//OMfM3369Fx44YWZOnVqdtlll/To0SNnnXVWXnnllRU5IwAAAABQDyzX3bRbtGiRYcOG5fbbb88zzzyT/fffP7/73e+y/vrrZ/DgwZkwYcKKmhMAAAAAWMUtV4z8uA033DBnnHFG/vvf/+byyy/Pvffem29961u1ORsAAAAAUI8s9920P+7222/PmDFjcvXVV6dRo0Y59NBDa2suAAAAAKCeWe4Y+fLLL2fs2LEZO3ZsXnjhhWy//fa56KKL8q1vfSvNmzdfETMCAAAAAPXAMsfIK664IpdcckkmTZqUjh07ZujQoTn44IPTo0ePFTkfAAAAAFBPLHOMPPDAAzN48OBcc8012WOPPdKgwWe+3CQAAAAAsBpa5hj58ssvp2PHjityFgAAAACgHlvm0xuFSAAAAADg8/BZawAAAACgFGIkAAAAAFAKMRIAAAAAKMXnjpEvvPBCnnjiiVRVVdXGPAAAAABAPbXMMXLBggU55ZRTsueee+bMM8/MwoULM2TIkGy00Ub50pe+lC9+8Yv573//uwJHBQAAAABWZcscI3/0ox/lt7/9bTp37pxLLrkke++9dx5++OGMGzcu48ePT6NGjXLSSSetyFkBAAAAgFVYo2Xd8KqrrsrYsWOzxx575JlnnknPnj1z/fXXZ9CgQUmSjh075oADDlhhgwIAAAAAq7ZlPjPy1VdfzRZbbJEk2XjjjdO0adP06NGjev3GG2+c6dOn1/6EAAAAAEC9sMwxcuHChWncuHH140aNGqVhw4b/b0cNGqQoitqdDgAAAACoN5b5Y9pJctNNN6Vt27ZJkqqqqkyaNCmPP/54kuTtt9+u9eEAAAAAgPpjuWLk0KFDazw+7LDDajyuVCqffyIAAAAAoF5a5hhZVVW1IucAAAAAAOq5Zb5mJAAAAADA57HMZ0YuXLgwTz75ZDbffPMkyejRozN//vzq9Q0bNszhhx+eBg30TQAAAABgUcscI//6179m9OjRmTx5cpLkhz/8Ydq1a5dGjT7cxRtvvJFmzZplxIgRK2ZSAAAAAGCVtsynMY4ZMyYjR46sseyOO+7IlClTMmXKlJxzzjn585//XOsDAgAAAAD1wzLHyP/85z/Zaqutlri+f//+efTRR2tlKAAAAACg/lnmj2m//vrrNR6/8MILWXPNNasfN27cOO+++27tTQYAAAAA1CvLfGZkp06d8vTTT1c/7tChQ42b1Tz11FPp3Llz7U4HAAAAANQbyxwjd9lll5x55pmLXVcURUaNGpVddtml1gYDAAAAAOqXZf6Y9kknnZQtt9wyffv2zXHHHZeNN944SfL000/n3HPPzdNPP53LLrtshQ0KAAAAAKzaljlGbrjhhpk4cWKGDRuW/fbbL5VKJcmHZ0X27NkzN998c3r06LHCBgUAAAAAVm3LHCOTZOutt86TTz6ZRx55JM8880ySZKONNkrv3r1XyHAAAAAAQP2xXDHyI7169UqvXr0WWf7AAw9kq622+rwzAQAAAAD10DLfwOYjc+bMyXvvvVdj2SOPPJI999wzffv2rbXBAAAAAID6ZZlj5EsvvZR+/fqlbdu2adu2bY499tjMnTs3Bx10UPr27ZuWLVvmn//854qcFQAAAABYhS3zx7R/+MMf5v333895552XCRMm5Lzzzsudd96Zvn375vnnn8+66667IucEAAAAAFZxyxwjJ0+enAkTJmSbbbbJvvvum86dO+eAAw7I0UcfvQLHAwAAAADqi2X+mPZrr72W7t27J0k6duyYFi1aZNCgQStsMAAAAACgflmuG9g0aNCgxq+bNGlS6wMBAAAAAPXTMn9MuyiKbLzxxqlUKkk+vKt27969awTKJJk5c2btTggAAAAA1AvLHCPHjBmzIucAAAAAAOq5ZY6RQ4cOXZFzAAAAAAD13HJdMxIAAAAA4LMSIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQimW+m/ZHFi5cmLFjx2bSpEmZMWNGqqqqaqy/9dZba204AAAAAKD+WO4YedRRR2Xs2LEZPHhwvvjFL6ZSqayIuQAAAACAema5Y+T48eNzxRVXZI899lgR8wAAAAAA9dRyXzOySZMm6dGjx4qYBQAAAACox5Y7Rv7P//xPzjvvvBRFsSLmAQAAAADqqeX+mPZdd92V2267LTfccEM222yzNG7cuMb6CRMm1NpwAAAAAED9sdwxsl27dtlrr71WxCwAAAAAQD223DFyzJgxK2IOAAAAAKCeW+5rRgIAAAAAfBbLfWZkklx11VW54oorMnXq1MyfP7/GuoceeqhWBgMAAAAA6pflPjPy/PPPz/Dhw9OpU6c8/PDD2XrrrbPmmmvmhRdeyKBBg1bEjAAAAABAPbDcMfKiiy7KxRdfnN/85jdp0qRJjj/++EycODE/+MEPMmvWrBUxIwAAAABQDyx3jJw6dWq23XbbJEnz5s3zzjvvJEm+853v5PLLL6/d6QAAAACAemO5Y2Tnzp0zc+bMJEm3bt1y7733JkmmTJmSoihqdzoAAAAAoN5Y7hi588475x//+EeSZPjw4TnmmGOy2267Zb/99stee+1V6wMCAAAAAPXDct9N++KLL05VVVWSZOTIkVlzzTXzz3/+M1/72tdy2GGH1fqAAAAAAED9sNwxskGDBmnQ4P+dULn//vtn//33r9WhAAAAAID6Z7k/pp0kd955Zw488MD069cvr7zySpLkT3/6U+66665aHQ4AAAAAqD+WO0ZeffXVGTBgQJo3b56HH3448+bNS5LMmjUrZ511Vq0PCAAAAADUD8sdI88444yMHj06v//979O4cePq5V/5ylfy0EMP1epwAAAAAED9sdwx8umnn84OO+ywyPK2bdvm7bffro2ZAAAAAIB6aLljZOfOnfPcc88tsvyuu+7KBhtsUCtDAQAAAAD1z3LHyEMPPTRHHXVU7rvvvlQqlbz66qv5y1/+kuOOOy6HH374ipgRAAAAAKgHGi3vE370ox+lqqoqu+yyS+bOnZsddtghTZs2zXHHHZfvf//7K2JGAAAAAKAeWO4YWalUctJJJ+WHP/xhnnvuucyZMyebbrppWrVqtSLmAwAAAADqieWOkR9p0qRJNt1009qcBQAAAACox5Y5Rh588MHLtN0ll1zymYcBAAAAAOqvZY6RY8eOzXrrrZfevXunKIoVORMAAAAAUA8tc4w8/PDDc/nll2fKlCkZPnx4DjzwwLRv335FzgYAAAAA1CMNlnXDCy+8MNOmTcvxxx+fa6+9Nl27ds2+++6bm266yZmSAAAAAMCnWuYYmSRNmzbNkCFDMnHixDz55JPZbLPNcsQRR2T99dfPnDlzVtSMAAAAAEA9sFwxssYTGzRIpVJJURRZuHBhbc4EAAAAANRDyxUj582bl8svvzy77bZbNt544zz22GO54IILMnXq1LRq1WpFzQgAAAAA1APLfAObI444IuPHj0/Xrl1z8MEH5/LLL89aa621ImcDAAAAAOqRZY6Ro0ePTrdu3bLBBhvkjjvuyB133LHY7SZMmFBrwwEAAAAA9ccyx8iDDjoolUplRc4CAAAAANRjyxwjx44duwLHAAAAAADqu898N20AAAAAgOUhRgIAAAAApRAjAQAAAIBSiJEAAAAAQCnESAAAAACgFGIkAAAAAFAKMRIAAAAAKIUYCQAAAACUQowEAAAAAEohRgIAAAAApRAjAQAAAIBSiJEAAAAAQCnESAAAAACgFHUaIydPnpw999wza6+9diqVSv72t7/VWF8URU4++eR06dIlzZs3z6677ppnn322xjYzZ87MAQcckDZt2qRdu3YZMWJE5syZU+KrAAAAAACWRZ3GyHfffTdbbLFFLrzwwsWuP/vss3P++edn9OjRue+++9KyZcsMGDAg77//fvU2BxxwQJ544olMnDgx1113XSZPnpzvfve7Zb0EAAAAAGAZNarLbz5o0KAMGjRoseuKosivf/3r/OQnP8nXv/71JMlll12WTp065W9/+1v233//PPXUU7nxxhtz//33Z6uttkqS/OY3v8kee+yRc889N2uvvXZprwUAAAAAWLqV9pqRU6ZMyfTp07PrrrtWL2vbtm369u2be+65J0lyzz33pF27dtUhMkl23XXXNGjQIPfdd98S9z1v3rzMnj27xhcAAAAAsGKttDFy+vTpSZJOnTrVWN6pU6fqddOnT0/Hjh1rrG/UqFHat29fvc3ijBo1Km3btq3+6tq1ay1PDwAAAAB80kobI1ekE088MbNmzar+eumll+p6JAAAAACo91baGNm5c+ckyWuvvVZj+WuvvVa9rnPnzpkxY0aN9R988EFmzpxZvc3iNG3aNG3atKnxBQAAAACsWCttjOzevXs6d+6cSZMmVS+bPXt27rvvvvTr1y9J0q9fv7z99tt58MEHq7e59dZbU1VVlb59+5Y+MwAAAACwZHV6N+05c+bkueeeq348ZcqUPPLII2nfvn26deuWo48+OmeccUY22mijdO/ePT/96U+z9tpr5xvf+EaSZJNNNsnAgQNz6KGHZvTo0VmwYEGOPPLI7L///u6kDQAAAAArmTqNkQ888EB22mmn6sfHHntskmTo0KEZO3Zsjj/++Lz77rv57ne/m7fffjvbbbddbrzxxjRr1qz6OX/5y19y5JFHZpdddkmDBg2yzz775Pzzzy/9tQAAAAAAS1enMXLHHXdMURRLXF+pVHL66afn9NNPX+I27du3z7hx41bEeAAAAABALVpprxkJAAAAANQvYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKs1DHy1FNPTaVSqfHVs2fP6vXvv/9+Ro4cmTXXXDOtWrXKPvvsk9dee60OJwYAAAAAlmSljpFJstlmm2XatGnVX3fddVf1umOOOSbXXnttrrzyytxxxx159dVXs/fee9fhtAAAAADAkjSq6wE+TaNGjdK5c+dFls+aNSt//OMfM27cuOy8885JkjFjxmSTTTbJvffem2222absUQEAAACApVjpz4x89tlns/baa2eDDTbIAQcckKlTpyZJHnzwwSxYsCC77rpr9bY9e/ZMt27dcs899yx1n/Pmzcvs2bNrfAEAAAAAK9ZKHSP79u2bsWPH5sYbb8xvf/vbTJkyJdtvv33eeeedTJ8+PU2aNEm7du1qPKdTp06ZPn36Uvc7atSotG3btvqra9euK/BVAAAAAADJSv4x7UGDBlX/+ktf+lL69u2b9dZbL1dccUWaN2/+mfd74okn5thjj61+PHv2bEESAAAAAFawlfrMyE9q165dNt544zz33HPp3Llz5s+fn7fffrvGNq+99tpirzH5cU2bNk2bNm1qfAEAAAAAK9YqFSPnzJmT559/Pl26dEmfPn3SuHHjTJo0qXr9008/nalTp6Zfv351OCUAAAAAsDgr9ce0jzvuuOy5555Zb7318uqrr+aUU05Jw4YNM2TIkLRt2zYjRozIsccem/bt26dNmzb5/ve/n379+rmTNgAAAACshFbqGPnyyy9nyJAhefPNN9OhQ4dst912uffee9OhQ4ckya9+9as0aNAg++yzT+bNm5cBAwbkoosuquOpAQAAAIDFWalj5Pjx45e6vlmzZrnwwgtz4YUXljQRAAAAAPBZrVLXjAQAAAAAVl1iJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEAp6k2MvPDCC7P++uunWbNm6du3b/71r3/V9UgAAAAAwMfUixj517/+Nccee2xOOeWUPPTQQ9liiy0yYMCAzJgxo65HAwAAAAD+f/UiRv7v//5vDj300AwfPjybbrppRo8enRYtWuSSSy6p69EAAAAAgP9fo7oe4POaP39+HnzwwZx44onVyxo0aJBdd90199xzz2KfM2/evMybN6/68axZs5Iks2fPXrHDluX9FbHT2n9v6svbXecc79WL4716cbxXL4736sXxXr043qsXx3v14nivXhzvT/m+H37joiiWul2l+LQtVnKvvvpq1llnnfzzn/9Mv379qpcff/zxueOOO3Lfffct8pxTTz01p512WpljAgAAAEC999JLL2Xddddd4vpV/szIz+LEE0/MscceW/24qqoqM2fOzJprrplKpVKHk5Vr9uzZ6dq1a1566aW0adOmrsdhBXO8Vy+O9+rF8V69ON6rF8d79eJ4r14c79WL4716WV2Pd1EUeeedd7L22msvdbtVPkautdZaadiwYV577bUay1977bV07tx5sc9p2rRpmjZtWmNZu3btVtSIK702bdqsVr85VneO9+rF8V69ON6rF8d79eJ4r14c79WL4716cbxXL6vj8W7btu2nbrPK38CmSZMm6dOnTyZNmlS9rKqqKpMmTarxsW0AAAAAoG6t8mdGJsmxxx6boUOHZquttsrWW2+dX//613n33XczfPjwuh4NAAAAAPj/1YsYud9+++X111/PySefnOnTp6dXr1658cYb06lTp7oebaXWtGnTnHLKKYt8ZJ36yfFevTjeqxfHe/XieK9eHO/Vi+O9enG8Vy+O9+rF8V66Vf5u2gAAAADAqmGVv2YkAAAAALBqECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxkhWmqqqqrkcAAAAAYCUiRlLrpk2bltmzZ6dBAz9eq5uiKOp6BABqgX9QXL043qsPf1db/SxcuLCuR6BEfo+zqlCLqFVPPfVUtt9++/z2t79N4i+39d3MmTPz1FNP5cUXX8x7772XSqXimNdjDz74YI488si6HoOSfPDBB0n8pXZ1MWXKlPz2t7/Nj370ozz55JNp0KCB/57XY4736uXBBx/MT3/60yRJpVKp42lY0aZOnZpx48bl/PPPz7Rp09KwYUNBsh6bPXt2Xnnllbz11luZP3++/x+r59555528/PLLeeutt1b539diJLXmkUceSZ8+ffLf//43N998c5I4O7Ie+/e//53+/ftn8ODB2XnnnTNo0KA8++yzjnk99eijj+YrX/mK47uaeOaZZ3L44Yfn2WefTaVSESTrucceeyzbb799Lr/88lxzzTXp169fnn76ab/f6ynHe/Xy0Z/f77zzTl2PQgkee+yx7LDDDvnVr36Vc889N717985rr72Whg0b1vVorACPPfZYdttttwwYMCC77rprhgwZkldeecV/z+upJ554Il/72tey6667Zuedd87vf//7VTpI+imlVnz0F52TTjopTz31VB588MFcdtlldT0WK8grr7ySQYMGZY899shVV12V008/Pc2aNctWW21VHaKpPz76/f2DH/wg559//mK38S+w9ccLL7yQnXfeOVdddVVOPfXUPPfcc4JkPfbqq69mr732ymGHHZabbropjzzySDbZZJP861//quvRWAEc79XLo48+mm233Tbf//738+tf/3qx2/jzu/546aWXMnjw4Bx88MGZOHFiJk2alA4dOuTRRx+t69FYAZ5//vnssssu6d+/f8aOHZuRI0dmypQp2XbbbfPwww8n8fu7PnniiSeyww475Etf+lLOP//8bLrppvntb3+b9957r3qbVe3v6mIkn9tjjz2Wvn375uijj85JJ52Utm3bZosttsgdd9yRxH8E66MXX3wxa665Zo466qhsueWWOeCAA/LXv/41e++9d775zW/mnnvuSeLY1wfTp0/PVlttlf333z9nn312FixYkBNOOCHf+MY3svvuu+fnP/95Zs6c6SN+9cTcuXPz05/+tPofl15++eWcdNJJgmQ99uyzz6Zdu3Y5+OCD07x58zRv3jxrrbVWHn/88RxyyCH5xz/+kRkzZtT1mNQSx3v18corr2TrrbfOwQcfnHPOOSfz5s3L6aefnoMOOihDhgzJ+PHj884776RBgwb+215PPPDAA1l//fVz7LHHpl27dtloo43SuXPnPProozn55JNz3333rdJnUVHTNddck1122SVnn312ttpqqxx88MEZNGhQXnrppQwcODDPPPOMv5/XE9OnT88BBxyQ4cOH57zzzsvuu++eM888M507d87UqVMzffr0VfKSaWIkn0tRFBk9enROPPHEnHnmmUmSjh07ZsSIEbnsssty//33O028Hpo5c2aefPLJNG/ePMmH0bFt27b53e9+l8GDB2fvvffOjBkzHPt6YO7cudl2221z11135YUXXsiee+6Zu+66KxtssEHatm2bq6++OoccckhmzZrleNcDLVq0yI477pgBAwbkuOOOy/DhwzN9+vQlBkn/A7vqe/PNN/PQQw/lrbfeSpKce+65ueWWW/LSSy9lxowZ2X///XPppZcmcbzrgzfeeMPxruc+Om7PP/98evbsmX//+9956623stdee+WGG25IVVVVXnrppZx99tk59dRTM3fuXNeRrCfeeOON3HvvvdXXfD7nnHNyxx135NZbb80dd9yRr3zlK7nqqquSOGGgPnjllVcyZcqU6uOdJL169cohhxySzTffPEOGDHFT2XripZdeyl577ZUjjjiietkll1ySf/7znxk0aFAGDx6cIUOGVJ8gssoo4HOaN29e9a8XLlxYFEVRzJw5s9hxxx2Lww8/vJg3b15RVVVVV+NRSz744IPqX8+dO7fYcssti0MOOaSYO3duURT/79g/99xzxZe//OXil7/8ZVEUhWO/ipo1a1ZRFB8evylTphQ777xzUalUiq9+9avFjBkzqrf74x//WPTs2bO47rrr6mpUasnHf69+/NeXXHJJscMOOxT77rtv8dxzzxVFURTvv/9+9c8Iq56P/7ldFEWxxx57FJVKpRg4cGDRqFGj4qabbqr+b/pZZ51VtG3btpg2bVpdjEotmD59evXv3aqqKse7npszZ05RFEWxYMGC4o477ii23nrrxf75/dOf/rT4whe+UDz66KN1NSq14M033yxmz55dFEVRTJs2rdh6662LRo0aFV//+teLhg0bFjfeeGP1f/OPOuqoYt11163enlXTR/9PdsEFFxTbbLNN8fe//7149913i+eee65o3759cc455xQTJ04sevbsWTz22GN1PC21YcGCBdV/jhdFUfzyl78sKpVK8ac//al44okniksvvbTYcsstiwsuuKAOp1x+q1A2ZWUyb968JB/ezalJkyZJPvyX2I9K/BprrJG+ffvm2muvrb6rV+Ff2FdZTzzxRM4999zMmTMnSdKkSZPst99+efzxx3PBBRdk/vz51cd+ww03TLNmzfL0008ncdfGVdETTzyRbt265W9/+1sqlUrWX3/9XHzxxTn++OPzve99Lx06dKj+F/Xhw4fn9ddfzyOPPFK3Q/OZzZ49O2+//XZefvnlJP/vrJqP/qV9+PDhGTp0aKZPn54f//jHeeqpp3LUUUdlm222yQcffOC/7auYp556Kt/5znfy1FNPVS+7/vrrc8stt+S73/1udtppp+ywww7Vf8736dMn66yzjo/2raIef/zxbLbZZhk/fnySD/9MdrzrryeffDIbbrhhJk+enEaNGmW77bbLqFGjcvjhh+fYY49Nhw4dqo/tT3/600yZMiX//Oc/63hqPqsnnngiPXr0yBVXXJHkw0+nXX/99Rk/fnz22GOP7LPPPtl9992r/5zecssts+aaazorchX10d/LPjp+Bx54YNq2bZsTTjghvXv3Tq9evbLvvvvmuOOOy6677ppXX321+tqRrHo+3lsaNWqUDTfcsHrddtttl1tuuSX/X3v3HRbF2bUB/F5AQEAELIAIKghGmggKKBIbGFFREWMDsX5GA7bYiIhGI8ZCNPYWWzTGGHuMEkUsCLGFDqJIFLEg2LBQd/d8f/AykViiQFjXOb/ryvXCzKw5eW9nduaZp/j7+8Pa2hoBAQEoLi7G1atXFVVupXBjJHtnly9fxsiRI9GxY0eMGjVKmB+wvNGp/AsvJCQEqqqqmDdvXoX9TLkkJibCzs4OMpkMOjo6ICKoqqoiMDAQ1tbW2LNnDxYuXFjhxqZRo0bQ19cHEXFDhZJJSEiAu7s7CgoKcODAAaEB2sLCAlOmTIGnpycAQEVFBTKZDA8fPoSNjQ1sbGwUWTarpNTUVPTt2xddu3aFk5MTdu3aBYlEAolEAjU1NeG8HjlyJIYPH468vDx07twZu3btwpYtW6CmpsbXdiWSnJwMNzc3GBgYoKSkBMDfDzVdunRBSUkJMjIyoKmpKUzDERkZibp160JHR0dhdbPKKV98TEdHB1u3bq3wkNKlSxdIpVLO+wNS/v2dm5uL06dPQy6XQ0VFBZ06dcLkyZPh5uYGAFBVVYVMJsOdO3dga2uLjz76SMGVs8pISEgQMt22bRvu3r0LFRUV1K9fH76+vigtLUV6ejokEgk0NDSEzzRo0IBX1lZCV65cweTJk4VpdGJiYlC3bl3s2bMH8+fPR3BwMH788UesXbsWcrkcmZmZsLKyQosWLRRdOquE17W3AGVtLc7OzujSpQuAsvu458+fw9LSEra2tsIxyoAbI9k7SUlJgZubG/T09ODi4oKioiKsWLECxcXFwl/68l6QGhoa6N27N86cOSPMTcSUS3JyMtq3b48ZM2Zg5syZAMryLSoqgra2NpYtWwZXV1ccPHgQrq6uCAsLQ0BAAI4cOYJhw4YJjRpMOZSvujlx4kSsWrUKBw8erHDuNmjQQOgJDZQ90KxcuRK3b9+Go6OjIkpmVZCamooOHTrA0dER06ZNw7BhwzBx4kTk5eUJx5Q3OgNlPSRLSkpQUlKCs2fPwsXFRVGls0rIz8/HqFGj4O/vj7Vr16JVq1Z4/vw5srOzhWM+/vhj1KlTB+7u7li2bBlGjx6NzZs3Y926dahbt64Cq2fvKikpCe3atcP48eOxb98+lJaWCj1kynvXuLq6Qk9Pj/P+ACQmJqJdu3aYMmUKZs+ejTVr1uD58+cAyq7jzZs3f+n7e/PmzSguLoalpaWiymaVVH6/NmHCBGzfvh2pqanC6Iby7+y2bdtCTU0N/v7+2LFjB4KCgrBt2zYsXbqUXzYomZSUFLRv3x5FRUUwNDTEtWvXEBoaihs3bkBHRwe+vr4YMWIEevfuDaCscWrLli3Iz89H48aNFVw9e1dvam+Ry+UvLVKjoqKCRYsWITExER4eHgCUqBOYQgaHM6V0/fp1at68OYWEhAjbli5dSkOGDKHS0tIKc8yVzz106tQpql+/PuXk5CikZlZ5mZmZpK2tTf7+/sK2hQsXUkBAAA0ePJj27t1LRESFhYV0+PBhGjJkCHXu3Jk+/fRTSkpKUlTZrJLi4+NJIpHQzJkzhW22trY0fPjwV877eeLECRo7dizp6elRfHx8DVbKqsPNmzfJ1taWvvzyS2FbbGws9erVi+7cuVNhXhoiopKSEpoyZQppaGjw/GJK6saNG+Tk5CTMBejj40MuLi5Uq1YtGjFiBEVFRRER0ZEjR6h79+7UqlUr8vHx4fmmlFD59XzWrFnCNh8fH7Kzs6twnFQqpUOHDpGXlxfnrcTi4+NJVVVVuJ7fvXuXLC0tafbs2a88/sSJEzRhwgTS1dXl728lVH5+v/g81r59e/L09Kxwv1ZUVEQrVqwgV1dXsrS0JE9PT/7+VkJ37twhR0dHmj59urAtMjKSLCws6OzZs0RUcZ7v5ORk8vPzI319fYqLi6vxelnVvG17S7mTJ0/S5MmTSV9fXymv59wzkr215ORkuLu7IzAwUNh29+5dxMXFoU2bNujatSt27twp9IaTy+Xo2LEjMjIyYGhoqMDKWWXk5uYCAAwMDBAXFwd3d3dEREQgPz8fxcXF6N+/P7755htoamqiZ8+e+PHHHxEZGYmdO3fCzs5OwdWzd1FcXIzNmzcjODgYYWFhICJIpVL06tULiYmJyMnJAVBxLsGUlBQ8evQI0dHRcHBwUGD1rDKePHkCe3t7jBgxQtgWERGBM2fOwNPTE05OTpgwYQLy8/MBALVq1YK5uTn++OMP2NvbK6psVgVFRUV4+vQpnj17hn79+qGoqAhffvkldu7ciaSkJISHh+PKlSvw8vLC0aNHcebMGezcuVMY8sOUR2JiImbMmIGvv/5a6D0xfvx4PH/+HL/88guAst5Tqqqq8Pb2xpEjRzhvJfXs2TOEhYVh+vTpWLBgAQCgbt26cHJywsmTJ186vrS0FKdOnUJ6ejrOnj3L399KRi6XIyIiAsHBwZg/f36F+btv3bqFCxcuACjLWUNDA0FBQTh+/Diio6Oxf/9+/v5WQklJSTAyMsLQoUOF+/CuXbuiXr16SEpKeul4PT092Nvb4+zZs2jdunVNl8uq6G3bW4Cy57eYmBhcv34dZ86cUc7ruYIbQ5kSyc/Pp4yMDOH3JUuWUO3atWn16tW0bds2+vLLL0lVVZViYmIUWCWrTseOHSMzMzOqV68e9e3bl+7cuSPsW7VqFUkkEuGtHFNuL/ZeLn/DevPmTapTpw4tWLDgpX2lpaW8GqOSezHzzZs3U+3atWnHjh2UlJREERERpKqqSlu2bFFcgaxa3bp1i4yNjWnRokU0fPjwCj3gkpOTycTEhBYvXqzACtl/KT8/nxwcHGjIkCHCtlf1emfK58We7OUjk5KTk6lWrVq0adOml44vLi6mhw8f1lh9rHoVFBQIP5efw7m5udSoUSOaOHHiS/uYcouLi6MffvhB+F0qlZJcLicXF5dXfme/OEKRKZ+3bW8pf/4uKSmhx48fK6rcKuOekeyNbt26Jbx10dXVRfPmzQGUvZm7c+cODh06hM8//xwBAQEIDAyEiYkJUlNTFVkyq4KCggLcv38fJSUlkMvl8PT0xObNm9GqVStMmjQJxsbGwrH9+vWDsbEx0tPTFVgxq4pHjx4J8wO+2HtZIpFAJpPB1NQU48aNw4EDB3Dz5k1hHxFBTU0NderUUUjdrHJKS0uFlfmAvzOXy+VQV1dHVFQU/Pz8YGdnh08++QQuLi44f/68osplVZSRkYHt27cLv5uYmGDy5MkIDg7Gjh07hMWp5HI5bG1t4eHhgUuXLimqXFZFT548QVZWFh48eCDMGUf/60Ujl8uhq6uLr776CocPH8bx48cBKNGcUuwlt27dQkJCAgBUWGFVRUUFcrkc5ubm6NevH44ePYqnT58KfxeICOrq6tDX11dE2awKys/r8sWmAAgj0Ro0aICQkBDs27dPmBuWz2/lVVxcjKdPnwIAWrdujaFDhwIou5arqqpCIpGgXr16FT4THh6O6OhoSCQSqKhwE48yefr0qdDL+W3bW9LS0gCUjVxS5jme+W8qe634+HjY2NggMzOzwvby1fmWLl0KDw+PCgvXGBkZwdTUVBHlsipKTU1Fv3790KlTJ3Tr1g0nTpwAUDYUYOvWrXB2dgbw98ONTCaDkZERT4yspK5duwY7OzusWrUKDx48eGl/+UqLnTp1QmpqKi5fvgygLH++wVU+6enpGDFiBDw8PDBgwADhuk5EUFFRgZ+fH1xdXYXjnzx5Ai0tLR7io6SSkpLg7u6OY8eOCS8SAMDf3x9BQUGQyWQ4ceIEiouLhYeWwsJCNGvWTFElsypISUlBz5494eHhgW7dumHLli0VrtXlGdvZ2cHS0hKnT58G8HfjBlMu5ffn169ff+V+FRUVaGlpoUePHjh06BAyMjKEF4n8/a187t69C6lUClVV1QqLVpQrP7/btm0LmUyGuLg4AHjlsez9d/nyZfj5+cHDwwM+Pj64du0agL+fv8upq6sLz2QhISGYMWMG9PT0FFEyq4L09HTY2tpi27ZtFVbALr8//9DbW7gxkr1SYmIiPv74Y4wcORI+Pj4V9pWvrlr+JVd+Y1O+ch/PR6J8Ll++jI8//hjm5uaYPXs2CgoKsHjxYmG/qamp8Cb2xbyLioo4byUVFRWFO3fuIDw8HMuXL6+wajYRCQ+pXl5e8Pb2xsyZM/HkyRN+kFFCycnJ6NChA9TU1NC7d2+cO3cO06dPB/B3T9d/PrQsWbIEf/31F7p166aIklkVZGdnw9vbG/7+/ti+fTvMzMyEfcbGxpg+fTrGjBmD0NBQTJgwAfPmzcPkyZMRGRmJYcOGKbByVhlXrlxBx44d0bZtW6xduxYWFhbYvHkzSktLhWPKz29zc3N8+umnWLhwIXJycoSXTkx5vOn+HCjLuvyhNSAgAJ06dcL8+fNRWFjI399KKD09HSYmJujcuTNkMpnQ8/VV2rZti/79+2PWrFl4+PAh945TQmlpaXB3d4euri78/PwQFxeHWbNmAfi70bn8/vzRo0dQV1fH0qVLsXTpUly8eJHn7FdC+/btQ3Z2NiZMmIBNmzYJ28t7PZfn/aG2t6gpugD2/im/EI4dOxZLliyBTCbD6dOn8fjxY9SuXRteXl4VbmDT0tKwceNGbNu2DVFRUWjUqJECq2fvqqioCLNmzcLgwYOxatUqAEDjxo3x7bff4t69e6hbty5q1aolZH7q1Cns3LkTe/bsQVRUVIWh20x5ODs744svvoCzszMGDRoEmUyGkJAQaGlpoaSkBBoaGsJb2Pbt2yMjI6PCwy1TDjdv3kT//v0xevRoLFy4EADQpEkTHDp0CM+ePYOOjo6w6BgAnDlzBj/99BN2796NyMhING3aVIHVs8q4fPky7OzsEB4ejtLSUsycORN//fUXiAgDBw5E3759sW7dOri5uWHLli1ISUlB/fr1cfLkSbRs2VLR5bN3UFpaioULF8LX1xdLly4FUHZ+T5w4EVlZWdDR0YGBgQE0NDRQWlqKWrVqwdvbG7/99luFKRuYcnib+/N/NkDZ2toiKioKUqlUQVWzyrp37x4+++wzeHh44Nq1a+jatStOnDgh9JB8MevyXq/dunXD+fPn+fxWQs+fP8ekSZPg7++P7777DkDZC8SjR4+ioKAAWlpaAP4euWRgYIA5c+ZALpcjOjoajo6OiiqdVYGDgwM+//xzWFtb47PPPoNMJsNnn30GoKzhuVatWgA+3PYWboxkFcjlcsyaNQtSqRSDBw9GaWkp+vTpg9zcXGRlZaGgoAC9evXC1q1bUbt2baSlpWHXrl24cOECTp069cG00ouJuro6njx5glatWgnb9u/fj5iYGLi4uMDY2BidO3dGaGgopFIprly5goyMDJw+fZrfwCkxbW1t7Nq1C+Hh4Xj8+DHGjh2LOnXqIC0tDfXr18fSpUuFBqqgoCD069fvpflp2Pvv5MmT8PDwwLRp04RtMTExiI2NhYuLC0xNTeHj44MRI0agoKAAmZmZuHnzJk6fPs2r6iqptLQ03Lp1CzKZDF5eXpBKpXBzc0NsbCyWLFmCpKQkhIaGYujQofDx8YGOjg4KCwsrzEPGlEOtWrWQn5+PevXqCY0R27ZtQ0xMDLp27Yr69evDysoKGzduFOb4tba2xsGDB3nOQCXzrvfnUqkUampqWLx4MbKzs3mOZyUUHx+Pxo0bY8yYMdDS0sLAgQNf2yBZfr/Ws2dPtG3bFg0bNlRk6ayS8vPzKzyPRUdH49SpU3B0dETjxo0xaNAgBAQEQF1dHQYGBlBTU8OpU6f4eUyJGRkZISoqCkuWLMGdO3cQGBgIPT09nDt3DiYmJpgyZQquXLnywba3SOjFwemMAcjNzUX//v0hl8vx9OlTNGrUCIsXL4a2trbQy6Zv3774/vvvAZRNkq+vr4/69esruHL2ruRyOUpLS+Hl5QWZTIYBAwYgKysLq1atwqpVq2BjY4NDhw7h+PHjmD9/Prp164YnT54AKJtglymX8odVuVwOuVyOLl26YP369WjZsiV2796NQYMGQUtLC0eOHMHHH38MAMIDDVNOBQUFSE9PF96YL168GMHBwVi0aBFsbGywdetWpKenY/fu3fjoo4/w/PlzyOVyfnBVQuUPphEREfjmm28wefJkrFu3Dlu3boWRkRGAsnmlIiIi8PPPP6N58+bCZ3guOeVTPl3O2LFjceXKFbi6ukIqlWLdunXYsmULWrVqhXPnzmHDhg0YPnw4xo4dC5lMxkOzlVheXh58fX3f+v6c81ZuhYWFiI2NRdeuXQEA58+fx+DBg2FmZobIyEioqalBLpcL126+hiu3oqIi2NnZwcbGBmPGjEFMTAyWLVuGhQsXokWLFti8eTMyMzPxww8/wNraGidPnoSFhUWFqViYcii/5yIi5OXlwcvLC0eOHIGhoSG+/fZbTJs2DVpaWjh//jxsbGwAAFevXoWBgcGH195SU8t2M+Vy7949cnFxIVdXV7px40aFfRs3biQTE5MKy84z5fLkyZMKv9+9e5c6duxIw4YNI0tLS1qzZo2wr6SkhExMTOjLL7+s6TJZNXkxb7lcLvzct29f2r59OxERjRkzhvT19UkikdC8efPo/v37NV4nqx7Z2dmUkJBAhYWFFbY/ffqUli5dSsePHxe2FRUVkbq6Oq1du7amy2TV5J/X8wcPHlCjRo3IxMSEXFxc6Pnz58K+oqIiqlOnDq1fv76my2TVpLi4uML/5ubm0siRIykoKIhcXV0pPDxcOFYqlZKjoyONGzdOIbWy6nfv3j1ydnZ+4/15Zmamgqpj1UUmk71y+4ULF6hZs2bUsWNHkkqlRES0fPlyOnnyZA1Wx/4riYmJZGFhQb6+vmRoaEibN28W9hUVFZG2tjYtXbpUgRWyqigoKBB+fvF5zMPDg86ePUtERAEBAVS3bl1SUVGhbdu21XiNNY1ntmXIysrCjh078PXXX+Pq1asoKSlBw4YNERERgalTp740J6BcLkfdunV5CICSunLlCrp3747169cL24yMjHDs2DFs3boVpqamQuYymQxEBHt7+w9m1S6x+WfeEokEJSUlAAAzMzPk5uZi4sSJ+PXXX5Gamopt27Zhzpw5WL9+Pa/EqISSkpLg7OyMgwcPCr2Y6X8DIHR0dBAYGAgPDw8AZef33bt34eTkxHMFKqlXXc8NDAywa9cuSCQS3Lx5E8nJycI+IoKzszNfz5VUeno6xo0bh+7duyMkJASpqalo0KABNmzYgJUrV6Jhw4ZQV1cXjldVVYW5ubnQM5Z4MJRSycrKwsGDB7Fhwwbcvn0bT548QcOGDXH06FFMmTLltffnH1zPGZEoLCwUfn7d4jNt2rTBzz//jJs3b8LT0xPjxo3DpEmT0Lhx45oqk1WTnJwcREdHY/fu3SgqKgIA2NvbC/fi5ubmwvDrkpISFBYWonXr1py1krpy5Qr8/f1x9OhRAGXPY+Vz8detWxd//fUXJkyYgOPHj+Ps2bMICwvD8OHDsX37dkWW/Z/jsXcil5ycjF69eqFJkyb466+/sGrVKsTGxsLCwgJ6enrw9fV96TNpaWlo0aIFD/1QQkSE7du34/z58zA0NIS6ujpGjBgBoOzGRyqV4tmzZ/j999/h7e2N/Px8rFq1CvHx8Vi5cqWCq2fv6nV5lz+sduzYEf3794eJiQl+/fVXGBsbY+jQoVBRUUHr1q15JUYlk5mZiW7duiEgIAAzZsyAhoYGgIpDt168bquqqmLz5s0oKCiApaVljdfLquZN1/M2bdpgxYoVGDVqFKZOnYoJEyagRYsW+OWXX3D58mVYW1sruHr2rlJSUtCxY0f4+vqiYcOGiI2NRb169YQsy1fcjIyMRO/evaGqqorvv/8ep06dwoIFCwDwME5lkpSUBE9PTxgbG+POnTuYNWsWxowZAz8/P7Rs2RL9+vV76Tua78+VV2pqKoYMGYKwsDD06tXrtcdJJBK0bdsWO3bsQIcOHZCYmIhLly6hefPmNVgtq6rk5GQMHjwYEokE2dnZCA0NFa7p5ffoeXl5iIiIQJs2bVBaWopVq1YhKysLzs7OCq6evSupVIr58+dj//79qFWrFjQ0NNClSxdhcZpOnTph1KhRMDIywuHDh2FrawtbW1uoqqqiTZs2Cq7+P6bAXplMwa5cuUKGhoYUGhpK+fn5RERkZWX12uFbV69epZkzZ5Kenh4lJyfXZKmsGm3atInc3Nyob9++5ObmRt9//32F/UePHiUdHR1q3LgxOTk5UbNmzSguLk5B1bKqelPed+/epalTp1JiYiIRVRwywJTPt99+S3369CGisuGZ69ato0mTJtHy5cspISGhwrGxsbH05Zdfkq6u7kv7mPL4t+v5n3/+SY6OjtS0aVOysLAga2trvp4roUePHpG7uzvNmDFD2DZu3DgKCgoior+HfqWmppKBgQEZGhqSjY0NWVlZcd5K6PHjx+Ti4kLTpk2jhw8fEhHR3LlzydXVlQYMGEBpaWkVjuf7c+WWlZVF1tbWVLduXTIwMKDffvvtjcfLZDIaM2YMaWlpUWpqag1VyarL1atXycjIiGbOnEmZmZmUlZVFLi4u1Lt3byL6e4j+mjVrSF1dnVq2bEkdOnSgxo0b8/VciS1btoz69OlDrVu3pi5dutCxY8eEfUlJSeTn5yfK+3HuGSlSBQUFWLx4MT799FPMnj1beItqbW2N7OxsBAUFoXv37mjdujVMTEyQnJyMb7/9FqdPn8bJkyd5lVUlZmhoiJYtW2LJkiUYOXIkduzYAX19fRw8eBCjR49G9+7dcfHiRezduxdmZmZwd3dH06ZNFV02q6RX5a2np4dDhw5h4sSJWLBggfBmjnvNKLfk5GQ0adIEAODu7g4NDQ2UlpbiwoULWLZsGbZs2YJOnTrh0aNH2LRpE+Lj4xEdHf1BrconNm86v0eOHImOHTvi7NmzuHXrFkpLS9GwYUMewqmECgoKkJOTgw4dOgjb1NTUkJKSgnbt2sHU1BT/93//B09PTyQnJ+Po0aNo0KCBsAIrUy6FhYXIzc2Fm5ubsOr57NmzYWZmhk2bNmHJkiX4+uuv+f78AyCVSnHw4EFYWlpi9+7dWL58OQYOHIjdu3fDy8vrlZ85d+4cEhIScPr0ae7lrmQKCwuxePFi9OrVC3PnzhUWiBw+fDg2bdoE4O8h+sOGDYONjQ327duH5s2bw8vLCxYWFgqrnVUO/W+xGg0NDVhYWOD777+Hh4cHvv32W9SrVw/bt29HYGAgvv/+e2hqaiq63Jqn6NZQpjgHDx6kP/74Q/h93rx5VKtWLRo0aBB17dqVmjZtSnPmzCGisrfyZ8+epaysLAVVy6rLvXv3qEOHDlRSUkL37t2jgQMHUqNGjUgikfAbtw/Q2+T9uonSmXJZsGABeXp60rJly8jT05NycnKIiCg5OZmGDRtGrq6udOfOHSIiun//vrCfKS++notDdnY2ubi4UGBgIMXFxdFXX31Fmpqa9N1331FYWJiw+FxKSoqiS2XVICcnh1q1akXr1q0jIqLS0lJh39q1a6lFixa0c+dOIipbsIrvz5XbmTNnaP/+/cLvo0ePJh0dndf2kCwsLORFBpXYlClTKCwsrMK28+fPk7GxMeXm5gqLk7EPy5UrV8jLy4uIiG7evElOTk5kYmJC2trawne3GEeo8YRgIvPighS9e/eGq6srgLJ5Zg4cOID9+/djx44diIyMxKBBg7Bp0yY8evQIenp6cHNzg5mZmaJKZ9VAKpVCLpcjLy8PN27cQMOGDSGTyfDw4UM4OjoiLS1N0SWyavS2efPckMqN/rcoRYsWLfD48WMcO3YMVlZWMDQ0BADY2tpi8ODBuHnzJvLy8gAA9erVE/Yz5UEvLEBCRHw9F4nGjRujf//+uHTpEmbMmIGVK1fihx9+wMSJEzFz5kwEBgaisLAQGRkZii6VVQNDQ0PY2NggPDwcOTk5UFNTg1QqBQCMHTsWrVu3Rnh4OICyBav4/ly5ubu7o2/fvsLvGzduxKBBgzBw4EBhsQupVIqjR4/izp070NTURL169RRULauqRYsWYebMmQAqfqerq6tDW1tbmDMyKytLOO+ZcqP/9Y5MT09HTk4OTE1N0aRJE+Tl5cHOzg6PHj0CIM4RavwEKiKXL1/GlClTcOfOHQAVGyabNm2KI0eOoGfPnsKF0cHBAQYGBgqplVXdjRs3sHz5cixduhSHDx8GUDasy8jICG5ubpDL5Rg1ahT++OMPHDhwABYWFli8eDF27typ4MpZZeTl5SElJQUJCQl48OABAM77Q/aqvPv164eWLVsiIiICly5dwsOHD4XjbW1tUb9+fb6xVVLFxcUAym5Uy7+jJRIJn98fqPK8AQjn7NSpU3Hw4EGsWbMGdevWRbNmzYRjzMzMoK+vLwz5Y8rl3r17OHXqFE6ePImsrCwAZQ1StWvXRp8+ffDkyZMK2Xbp0gXq6uooKSlRVMmsCl7MOzs7W9j+YsPUxo0bMXjwYAwYMAC//vorgoKCEBgYyC+PlVB53lFRUcjOzhamRpPL5RUan1RUVIRpk6ZNm4b+/fsLq2wz5fHi+X3r1i0AZfdr5ubmcHJygqamJkaPHo0LFy5g7969kMlkmDJlCqKjoxVcuYIorlMmq0klJSXk6upK+vr6NGLECLp9+zYRVRye+c+uwePHj6e+ffsKE6Mz5ZGUlETGxsbUqVMnatmyJbVq1YqioqKE/YMHDyaJREKNGjWiixcvElHZMDB/f3+6ceOGospmlZSYmEjNmjWjdu3aka6uLnl6etLatWuF/QMHDuS8PyCvynvlypXC/oEDB5KqqioFBQVRRkYG5efnU0hICLVs2ZJyc3MVWDmrjMuXL9PYsWMpNjb2lfv9/Pz4/P6AvCrvF4fp3rt3j5ydnenw4cPC/dmsWbPI0tKSbt26VeP1sqpJSkoiKysrcnJyIk1NTRo2bJiQY2JiIrVo0YIcHBwoISGBnj59SkREn332GXXt2pUKCwsVWTqrhFflXT59yqv83//9H0kkEqpTp45wfWfK423zjo+PJyMjIyooKKCZM2eSlpYWnTt3TgEVs6r4t7x79epFampqZGRkJJzP165dI3d3d9FOtcGNkSJRXFxMnTt3Jk9PT+ratSsFBAQIf+n/2Qj59OlTmjVrFtWrV49XaVNCt2/fpmbNmlFwcDAREaWkpJCDgwMdPHhQOObSpUs0aNAgunTpEhH93SgtlUprvmBWJdnZ2WRmZkbTp0+n+/fvU3R0tNDYvHDhQiIqW1F38ODBnPcH4E15vzgH0fjx48nBwYHU1NTI1dWVDA0NeQ5BJZSZmUmNGzcmiURC/v7+FR5Gy8/fCxcukL+/P5/fH4A35f3ivZqPjw+ZmppSp06dqE+fPtSwYUM+v5VQWloaNWjQgGbMmEH37t2j/fv3k7q6Ol24cEE45vr16+Tq6kpmZmbUqlUr8vLyojp16ohy1VVl96q8NTQ0XmpkLL+Gl5aW0meffUYGBgb8PKaE3jZvorLGSBsbG/r8889JXV1d+D5nyuNt8v7ll1+od+/eQr7l92klJSUKqfl9ICF6oU84+6AtWLAAjRo1AhFh3bp1sLW1xbp163DgwAH07t0bGhoaiIqKQnh4ONLT07F37160bt1a0WWzd3T48GHMmzcPUVFR0NHRAVA2fNPCwgJaWlpo2rQpRowYgaKiInGu2vWB2blzJzZs2IDIyEhhGNeePXswcOBAAGXn/YwZM1BQUAAtLS1Flsqqwb/lPWfOHMyePRsAcO3aNaSkpKBOnTqwsrKCqampwupm7664uBjBwcG4e/cufH19ERwcjDZt2mDatGlo06aNcFxpaSlKSkqgra2twGpZVb1N3lKpVDjvv/76a9y+fRsGBgYYMWIELC0tFVk+e0f5+fnw8/ODmZkZ1qxZI2zv2bMn/P39Ubt2bZiYmKBt27YAgM2bN+POnTtQVVWFr68vrKysFFU6q4Q35T106FDUrl0bxsbGcHZ2BlA2hHfXrl0YPnw4/vjjDzg5OSmqdFYJ75p3dHQ0OnbsCH19fURGRvLzt5L5t7w1NTXRrFkztGrVCvn5+ahbt26Fz9P/5pQUI55cRkRKSkpw+vRpbNmyBYWFhfjll19gZWWFu3fvIi8vDxoaGvj444+RkZGBFStWoHnz5ooumVWCmpoaMjIycOLECfTp0wdhYWE4cOAABg4ciKKiIoSFheHatWsICwtTdKmsGhQUFCAnJwf37t2DiYkJAKBhw4bo1q0bWrVqha1bt6Jr164VGi+Y8vq3vHft2oVu3brB1dUVzZs35+u4EpNIJOjSpQvy8/Px6aefwszMDEOGDMGSJUsqNFDVqlVLmGdKLpfznGJK6m3yVlNTQ2lpKWrVqoXQ0FBFl8yqoKioCL6+vkJjBACEhYXh6NGjePbsGfLy8iCRSDB16lSMGDECI0eOVGC1rKreNu/g4GAMHToUKioqsLe3x7Vr13hxIiX0rnk7Ozujf//+mDVrFuzt7RVYOauMf8s7NzcXEokEISEh8PPze+nzYm2IBMBzRn7o5HK5MLTn5MmT1KtXL2Gfs7MzaWlpUa9evSgvL09RJbJqlpGRQQMHDiRdXV3q2bMnSSQSOnDggLB/9erV1KRJE7p69aoCq2TV5dixY9SgQQNasWIF/fnnn5SamkoGBgYUFhZGt2/fpiZNmtDu3bsVXSarJpz3h+/FuZz/OWdzTEwMmZub04ABA4RhPnK5nP78888arZFVn8rkzXPHKa8X83706JHw82+//UYSiYT27dtHxcXFdP36dRowYAANGDCAnj9/LtzL/3NqJfZ+q2zeTDlVJu/yuWB5ahXlU5m8eS2Oivj1+QfoypUr+O233wBUbGk3NTXFjRs3UFxcjBEjRiA7OxtBQUF49uwZxowZg5ycHEWVzKrgxbwBoHnz5liwYAF+++03DBw4EF26dIG3t7ewv379+tDU1ESdOnUUUS6ron/m7enpialTp2LhwoXo27cv3N3d4e/vj5kzZ6JRo0aoV68e4uLiFFgxqwrOW1zi4+Mxd+5cFBYWAgBq164NoGwIj1wuR/v27bF9+3ZcunQJixcvxrlz5zB58mQMHz4cjx8/VmDlrDIqm/fIkSM5byX0z7z19PSEfT169EBKSgp8fHygrq6Opk2bwsjICNnZ2dDU1BTu50Xdg0bJVCVvpnwqm3f5db98lW2mHCqbt4aGhoIqfj9xY+QH5tGjR7C1tYW3tzd27NgBoOzGRSqVQl9fH9ra2ujatSsiIyMRGRmJRYsWoUePHigsLIRcLldw9exdvSpvADA3N0eHDh1gaGiI/Px83Lp1S9iXkJAAIyMjvtlRQq/Le/r06Thw4AB2796NgwcPYvny5QCAhw8fQlNTE3Z2dooqmVUB5y0uiYmJcHJywvPnz4WHk3ISiQQqKioVGqgSEhLg4+ODDRs2YOvWrRVuhNn7j/MWlzflLZPJAADW1tYA/m6MLigoQNu2bUE8vb/S4bzFpSp5M+XD53c1UlifTPafkMvl1KFDBxo2bBjp6enR5s2bK+wPDAykZs2avTSk6+HDhzVZJqsm/5Z3fHw8WVhY0OjRo2nu3Lk0fvx40tPTo8TERAVVzKri3/J+0aNHjyg0NJRMTEzo+vXrNVckqzact3gkJiaStrY2BQcHC9v+ORyzfAhX+XYfHx/S19en5OTkmiuUVQvOW1zeJu/S0lLhZ6lUSqGhoWRsbEyXL1+usTpZ9eC8xYXzFhfOu3rxAjYfGIlEAolEgrZt26Jx48aYMGECNDQ0MGTIEMTGxiI4OBghISEwNjYG8Pdk9/r6+gqunFXGv+Xdvn17zJ07Fz/88APOnz+P5s2b48yZM9xzSkm9Ke+YmBg4ODhAW1sb6enpWLVqFX766SdERkaiadOmii6dVQLnLQ63b9+Gg4MDRo0ahW+++QZEhNmzZyM5ORlqampwdHTEzJkzoaqqCplMBhUVFXz55Zc4cOAA4uPjYWtrq+j/BPYOOG9xedu81dTUIJfLcejQIURERODAgQM4evQoPvroI0X/J7B3wHmLC+ctLpx39ePGyA+IVCqFmpoaWrVqBSMjIwwfPhxyuRzjxo3DkiVLoKenh71798LAwED4DK+6qbzelHd4eDi0tbVx6NAh+Pn5oUePHqhduzbkcjm0tLQUXTqrhH/LW1dXF/v27YO2tjbq16+Pbt26YdKkSbyaspLivMVDTU0NLVq0wNWrV3Ht2jWMHj0aUqkU9vb2ePDgAbZu3Yq4uDjs2bNHmFPK29sbQ4YM4RdLSojzFpd3yVtFRQV6enrQ0dHB6dOn0aJFC0WXz94R5y0unLe4cN7/AUV2y2T/jcWLF9PIkSOJiOjp06dka2tLampqFBoaKhzDq/F9ON4mb16h7cPxNnmzDwfnLQ45OTnUqlUrkkgk5OPjQzk5OURUNtTnxx9/JHNzc9q/fz8R8ff3h4DzFpe3yXvv3r3C8cXFxYoqlVUDzltcOG9x4byrF3eLU3L0iklQGzRogLy8PADAxIkTkZeXB39/f6xevRrr168HwKvxKavK5s0rtCmnyubNlBPnLS4v5m1oaIijR49i1KhRCAgIgKGhIYgIampq6N69O/Lz83H9+nUA/P2trDhvcXnXvLOysoTj1dXVFVEyqwLOW1w4b3HhvP87PExbSWVlZeHZs2ewsbEBEVW4WfX09ERERAS8vLyQkJCAyMhINGzYENra2ggLC8OgQYOgq6vLN7hKhPMWF85bXDhvcXld3sbGxli6dKlw4yqRSIQbYBsbG5ibmyusZlZ5nLe4cN7iwnmLC+ctLpx3DfjvO1+y6paenk4GBgbUrFkzunjxIhFVHMaTlZVFBgYGZGZmRnFxccL227dv071792q8XlY1nLe4cN7iwnmLy7/l/SqzZs0iCwsLunnzZk2UyKoR5y0unLe4cN7iwnmLC+ddMyRErxgXxt5bOTk5GDp0KKRSKXR1dXHr1i2sXbsWzs7OICIQEVRUVJCWlgYigo2NjaJLZlXAeYsL5y0unLe4/Fve/+zdGhMTg61bt2Lfvn04ceIEHBwcFFM4qxTOW1w4b3HhvMWF8xYXzrvm8JyRSubGjRtQVVXFV199hS+++AJNmjTB2LFjceHCBaGLsEwmg7W1NT+4fgA4b3HhvMWF8xaXf8tbLpcLxz59+hQJCQnIz8/H6dOn+cZWCXHe4sJ5iwvnLS6ct7hw3jWHe0YqoT///BNOTk4AgJMnT2LFihXIysrC2rVr4eLiUqFHDVN+nLe4cN7iwnmLy9vkLZfLoaqqiqdPnwIA6tSpo8iSWRVw3uLCeYsL5y0unLe4cN415L8bAc5qysmTJ6lv377UunVrOn/+PBERzZgxg6KjoxVcGfsvcN7iwnmLC+ctLq/Ke/r06XTmzBkFV8b+C5y3uHDe4sJ5iwvnLS6c93+De0a+565du4Y9e/YgPz8f9vb28Pb2ho6ODgBAKpVCTa1sQfRTp05hxYoVyM7ORpMmTbBv3z4kJibCzs5OkeWzd8R5iwvnLS6ct7hw3uLCeYsL5y0unLe4cN7iwnkrkKJbQ9nrpaSkkJ6eHnXs2JE+/vhjUlNTI19fX4qIiBCOKS0tFX4+fvw4NWjQgPT09CghIUERJbMq4LzFhfMWF85bXDhvceG8xYXzFhfOW1w4b3HhvBWLGyPfUwUFBdSrVy8KDAwUtv3555/Upk0b8vDwoH379gnbZTIZERFNmjSJateuTcnJyTVeL6sazltcOG9x4bzFhfMWF85bXDhvceG8xYXzFhfOW/F4Rvz3VO3atfHw4UPUr18fACCXy+Ho6Ijt27dDKpViw4YNSExMBACoqKggISEBUVFROHv2LGxtbRVZOqsEzltcOG9x4bzFhfMWF85bXDhvceG8xYXzFhfOW/G4MfI9RER4/vw5NDQ0kJubK2yTSqX46KOPsHr1aqSkpGDLli3CZxwcHHDmzBk4OjoqqmxWSZy3uHDe4sJ5iwvnLS6ct7hw3uLCeYsL5y0unPd7omY7YrJ38fPPP5NEIqE9e/YQUVn34JKSEiIi2rlzJ+nr61NWVhZJpVJFlsmqCectLpy3uHDe4sJ5iwvnLS6ct7hw3uLCeYsL561YaopuDGV/IyJIJBLcv38fmpqa8PX1xbRp0+Dv7w91dXV4e3tDRaWsM6uenh6MjIygra0NVVVVBVfOKoPzFhfOW1w4b3HhvMWF8xYXzltcOG9x4bzFhfN+v3Bj5HtEIpHgwIEDCA8PR15eHoYOHQpXV1cQEXx9fbFixQr07dsXenp6OHPmDNTV1YWThSkfzltcOG9x4bzFhfMWF85bXDhvceG8xYXzFhfO+/0iISJSdBGsTFxcHLp06YIpU6bg/v37iI2NhYWFBXx9fZGXl4fJkyejUaNG0NXVxd27d/H777+jdevWii6bVRLnLS6ct7hw3uLCeYsL5y0unLe4cN7iwnmLC+f9fuHGyPdEZmYmfvrpJ0gkEoSEhAAAfv31Vyxfvhy6uroICwuDlpYWzp8/D5lMhvbt26NJkyYKrppVFuctLpy3uHDe4sJ5iwvnLS6ct7hw3uLCeYsL5/0eqrnpKdnr5OfnU5s2bahhw4YUHBxcYd+vv/5KHTt2JB8fH4qJiVFQhaw6cd7iwnmLC+ctLpy3uHDe4sJ5iwvnLS6ct7hw3u8nHgD/HtDV1cWGDRugp6eH6OhopKamCvt69eqF6dOn4/r161izZg0KCgpA3JlVqXHe4sJ5iwvnLS6ct7hw3uLCeYsL5y0unLe4cN7vJx6m/R5JSkrCsGHD4OzsjAkTJsDGxkbYd+zYMbRo0YK7Cn9AOG9x4bzFhfMWF85bXDhvceG8xYXzFhfOW1w47/cLN0a+Z+Lj4zF69Gg4Ojpi8uTJsLa2VnRJ7D/EeYsL5y0unLe4cN7iwnmLC+ctLpy3uHDe4sJ5vz+4MfI9FB8fj7Fjx8Lc3Bxz5szBRx99pOiS2H+I8xYXzltcOG9x4bzFhfMWF85bXDhvceG8xYXzfj/wnJHvodatW2PVqlW4e/cu6tatq+hy2H+M8xYXzltcOG9x4bzFhfMWF85bXDhvceG8xYXzfj9wz8j3WFFRETQ1NRVdBqshnLe4cN7iwnmLC+ctLpy3uHDe4sJ5iwvnLS6ct2JxYyRjjDHGGGOMMcYYY6xG8DBtxhhjjDHGGGOMMcZYjeDGSMYYY4wxxhhjjDHGWI3gxkjGGGOMMcYYY4wxxliN4MZIxhhjjDHGGGOMMcZYjeDGSMYYY4wxxhhjjDHGWI3gxkjGGGOMMcYYY4wxxliN4MZIxhhjjDH2TiQSCQ4cOKDoMhhjjDHGmBLixkjGGGOMMSbIycnB+PHjYW5uDg0NDZiamsLb2xsnTpxQdGkAgE6dOkEikWDXrl0Vtn/33Xdo2rSpYopijDHGGGNvjRsjGWOMMcYYAODGjRtwcnJCVFQUlixZguTkZERERKBz584IDAxUdHkCTU1NzJo1C6WlpYouhTHGGGOMvSNujGSMMcYYYwCAzz//HBKJBBcuXICvry+srKxgY2ODL774AufOnXvt52bMmAErKytoaWnB3NwcoaGhFRoKExMT0blzZ9SpUwe6urpwcnLCpUuXAABZWVnw9vaGvr4+tLW1YWNjgyNHjryxzsGDB+Px48fYuHHja4/JzMxEnz59YGhoCB0dHbRt2xaRkZEVjmnatCnmz5+PgIAA6OjooEmTJjh06BDy8vLQp08f6OjowN7eXqi13NmzZ+Hu7o7atWvD1NQUEyZMwPPnz99YM2OMMcYYK8ONkYwxxhhjDA8fPkRERAQCAwOhra390n49Pb3XfrZOnTrYunUr0tLSsHz5cmzcuBHLli0T9vv5+aFx48a4ePEi/vzzTwQHB6NWrVoAgMDAQBQXF+PMmTNITk7GokWLoKOj88ZadXV1ERISgnnz5r22EfDZs2fo0aMHTpw4gfj4eHTv3h3e3t64efNmheOWLVsGNzc3xMfHo2fPnhg6dCgCAgLg7++PuLg4WFhYICAgAEQEoKyRs3v37vD19UVSUhJ+/vlnnD17FkFBQW+smTHGGGOMlZFQ+Z0VY4wxxhgTrQsXLsDFxQX79u2Dj4/PG4+VSCTYv38/+vbt+8r94eHh2LVrl9CjUFdXFytXrsSwYcNeOtbe3h6+vr6YM2fOW9XZqVMnODg4YNGiRWjRogVGjRqF0NBQfPfdd/juu+9w48aN137W1tYWY8eOFRoOmzZtCnd3d2zfvh1A2XyZxsbGCA0Nxbx58wAA586dQ7t27XD37l0YGRlh9OjRUFVVxfr164U/9+zZs+jYsSOeP38OTU3Nt/rvYIwxxhgTK+4ZyRhjjDHGUJX30z///DPc3NxgZGQEHR0dzJo1q0IPxC+++AKjR4+Gh4cHFi5ciMzMTGHfhAkTMH/+fLi5uWHOnDlISkp6q3+nhoYG5s2bh/DwcNy/f/+l/c+ePcPUqVPRsmVL6OnpQUdHB5cvX36pZ6S9vb3ws6GhIQDAzs7upW25ubkAyoacb926FTo6OsI/n3zyCeRyOa5fv/5WtTPGGGOMiRk3RjLGGGOMMVhaWkIikSA9Pf2dPvfHH3/Az88PPXr0wOHDhxEfH4+QkBCUlJQIx3z11VdITU1Fz549ERUVBWtra+zfvx8AMHr0aPz1118YOnQokpOT0aZNG6xcufKt/t3+/v5o0qQJ5s+f/9K+qVOnYv/+/ViwYAGio6ORkJAAOzu7CnUBEIaLA2U9Pl+3TS6XAyhr5Pzss8+QkJAg/JOYmIiMjAxYWFi8Vd2MMcYYY2LGjZGMMcYYYwwGBgb45JNPsHr16lfOw/j48eNXfi42NhZNmjRBSEgI2rRpA0tLS2RlZb10nJWVFSZPnoxjx46hX79+2LJli7DP1NQUY8eOxb59+zBlypQ3LkzzIhUVFXzzzTdYu3btS8OzY2JiMHz4cPj4+MDOzg5GRkZvHML9thwdHZGWlobmzZu/9I+6unqV/3zGGGOMsQ8dN0YyxhhjjDEAwOrVqyGTyeDs7Iy9e/ciIyMDly9fxooVK9CuXbtXfsbS0hI3b97Erl27kJmZiRUrVgi9HgGgsLAQQUFBOHXqFLKyshATE4OLFy+iZcuWAIBJkybh999/x/Xr1xEXF4eTJ08K+95Gz5494eLiUmEOx/K69u3bJ/RcHDJkiNC7sSpmzJiB2NhYBAUFISEhARkZGTh48CAvYMMYY4wx9pa4MZIxxhhjjAEAzM3NERcXh86dO2PKlCmwtbWFp6cnTpw4gbVr177yM71798bkyZMRFBQEBwcHxMbGIjQ0VNivqqqKBw8eICAgAFZWVhgwYAC8vLwwd+5cAIBMJkNgYCBatmyJ7t27w8rKCmvWrHmnuhctWoSioqIK25YuXQp9fX20b98e3t7e+OSTT+Do6PiO/4+8zN7eHqdPn8bVq1fh7u6O1q1bY/bs2WjUqFGV/2zGGGOMMTHg1bQZY4wxxhhjjDHGGGM1gntGMsYYY4wxxhhjjDHGagQ3RjLGGGOMMcYYY4wxxmoEN0YyxhhjjDHGGGOMMcZqBDdGMsYYY4wxxhhjjDHGagQ3RjLGGGOMMcYYY4wxxmoEN0YyxhhjjDHGGGOMMcZqBDdGMsYYY4wxxhhjjDHGagQ3RjLGGGOMMcYYY4wxxmoEN0YyxhhjjDHGGGOMMcZqBDdGMsYYY4wxxhhjjDHGagQ3RjLGGGOMMcYYY4wxxmrE/wNnkIuLx8YozAAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 1600x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# 10개의 샘플 선택\n",
+    "sample_classes = image_data['class_name'].unique()[:10]\n",
+    "\n",
+    "# 각 클래스별로 RGB값의 평균을 계산\n",
+    "mean_rgb_per_class = image_data[image_data['class_name'].isin(sample_classes)].groupby('class_name')[['mean_red', 'mean_green', 'mean_blue']].mean()\n",
+    "\n",
+    "# 클래스별로 RGB값의 평균을 출력\n",
+    "mean_rgb_per_class.plot(kind='bar', figsize=(16, 10), color=['red', 'green', 'blue'])\n",
+    "plt.title('Mean RGB Values per Class')\n",
+    "plt.xlabel('Class Name')\n",
+    "plt.ylabel('Mean RGB Value')\n",
+    "plt.xticks(rotation=45)\n",
+    "plt.legend(['Mean Red', 'Mean Green', 'Mean Blue'])\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 349,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x600 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# RGB값의 평균 분포를 출력\n",
+    "plt.figure(figsize=(14, 6))\n",
+    "\n",
+    "# mean_red 값의 분포를 출력\n",
+    "plt.subplot(1, 3, 1)\n",
+    "sns.histplot(image_data['mean_red'], bins=30, kde=True, color='red')\n",
+    "plt.title('Distribution of Mean Red Values')\n",
+    "plt.xlabel('Mean Red Value')\n",
+    "plt.ylabel('Frequency')\n",
+    "\n",
+    "# mean_green 값의 분포를 출력\n",
+    "plt.subplot(1, 3, 2)\n",
+    "sns.histplot(image_data['mean_green'], bins=30, kde=True, color='green')\n",
+    "plt.title('Distribution of Mean Green Values')\n",
+    "plt.xlabel('Mean Green Value')\n",
+    "plt.ylabel('Frequency')\n",
+    "\n",
+    "# mean_blue 값의 분포를 출력\n",
+    "plt.subplot(1, 3, 3)\n",
+    "sns.histplot(image_data['mean_blue'], bins=30, kde=True, color='blue')\n",
+    "plt.title('Distribution of Mean Blue Values')\n",
+    "plt.xlabel('Mean Blue Value')\n",
+    "plt.ylabel('Frequency')\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "색상 분포 분석\n",
+    "- 대부분 RGB, Green, Blue값이 200~250사이에 분포\n",
+    "- 전박적으로 이미지의 밝기와 채도가 높은 편"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 352,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/h6/61flrrfj1l38_nn873r977580000gn/T/ipykernel_38155/2640141684.py:9: FutureWarning: \n",
+      "\n",
+      "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `y` variable to `hue` and set `legend=False` for the same effect.\n",
+      "\n",
+      "  sns.barplot(x='height', y='class_name', data=class_size_stats.sort_values(by='height', ascending=False), palette='viridis')\n",
+      "/var/folders/h6/61flrrfj1l38_nn873r977580000gn/T/ipykernel_38155/2640141684.py:16: FutureWarning: \n",
+      "\n",
+      "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `y` variable to `hue` and set `legend=False` for the same effect.\n",
+      "\n",
+      "  sns.barplot(x='width', y='class_name', data=class_size_stats.sort_values(by='width', ascending=False), palette='viridis')\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1600x1000 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# 각 클래스별로 이미지의 평균 높이와 너비를 계산\n",
+    "class_size_stats = image_data.groupby('class_name')[['height', 'width']].mean().reset_index()\n",
+    "\n",
+    "# 각 클래스별로 이미지의 평균 높이와 너비를 출력\n",
+    "plt.figure(figsize=(16, 10))\n",
+    "\n",
+    "# 클래스별 이미지의 평균 높이를 출력\n",
+    "plt.subplot(1, 2, 1)\n",
+    "sns.barplot(x='height', y='class_name', data=class_size_stats.sort_values(by='height', ascending=False), palette='viridis')\n",
+    "plt.title('Mean Image Height by Class')\n",
+    "plt.xlabel('Mean Height')\n",
+    "plt.ylabel('Class Name')\n",
+    "\n",
+    "# 클래스별 이미지의 평균 너비를 출력\n",
+    "plt.subplot(1, 2, 2)\n",
+    "sns.barplot(x='width', y='class_name', data=class_size_stats.sort_values(by='width', ascending=False), palette='viridis')\n",
+    "plt.title('Mean Image Width by Class')\n",
+    "plt.xlabel('Mean Width')\n",
+    "plt.ylabel('Class Name')\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "클래스별 이미지 크기 분포\n",
+    "- 대부분 클래스는 300에서 800 픽셀 사이의 평균 높이를 가지고 있음\n",
+    "- 대부분 클래스느 300에서 800 픽셀 사이의 평균 너비를 가지고 있음"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 355,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/h6/61flrrfj1l38_nn873r977580000gn/T/ipykernel_38155/3931341571.py:5: FutureWarning: \n",
+      "\n",
+      "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n",
+      "\n",
+      "  sns.boxplot(x='target', y='mean_red', data=image_data, palette='Reds')\n",
+      "/var/folders/h6/61flrrfj1l38_nn873r977580000gn/T/ipykernel_38155/3931341571.py:13: FutureWarning: \n",
+      "\n",
+      "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n",
+      "\n",
+      "  sns.boxplot(x='target', y='mean_green', data=image_data, palette='Greens')\n",
+      "/var/folders/h6/61flrrfj1l38_nn873r977580000gn/T/ipykernel_38155/3931341571.py:21: FutureWarning: \n",
+      "\n",
+      "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n",
+      "\n",
+      "  sns.boxplot(x='target', y='mean_blue', data=image_data, palette='Blues')\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1600x1000 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(16, 10))\n",
+    "\n",
+    "# mean_red 값의 분포를 출력\n",
+    "plt.subplot(1, 3, 1)\n",
+    "sns.boxplot(x='target', y='mean_red', data=image_data, palette='Reds')\n",
+    "plt.title('Mean Red Value Distribution by Target')\n",
+    "plt.xlabel('Target')\n",
+    "plt.ylabel('Mean Red Value')\n",
+    "plt.xticks(rotation=90)\n",
+    "\n",
+    "# mean_green 값의 분포를 출력\n",
+    "plt.subplot(1, 3, 2)\n",
+    "sns.boxplot(x='target', y='mean_green', data=image_data, palette='Greens')\n",
+    "plt.title('Mean Green Value Distribution by Target')\n",
+    "plt.xlabel('Target')\n",
+    "plt.ylabel('Mean Green Value')\n",
+    "plt.xticks(rotation=90)\n",
+    "\n",
+    "# mean_blue 값의 분포를 출력\n",
+    "plt.subplot(1, 3, 3)\n",
+    "sns.boxplot(x='target', y='mean_blue', data=image_data, palette='Blues')\n",
+    "plt.title('Mean Blue Value Distribution by Target')\n",
+    "plt.xlabel('Target')\n",
+    "plt.ylabel('Mean Blue Value')\n",
+    "plt.xticks(rotation=90)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "클래스별 이미지 색상의 분포\n",
+    "- 대부분 Red, Green, Blue 값은 200에서 250 사이에 분포"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2.2 Displaying images"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 360,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1600x1000 with 30 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# 같은 target을 가진 이미지 전체 출력\n",
+    "def display_images(data, target):\n",
+    "    len_data = len(data[data['target'] == target])\n",
+    "    fig, axs = plt.subplots((len_data // 5)+1, 5, figsize=(16, 10))\n",
+    "    images = data[data['target'] == target]['path'].values\n",
+    "    for i, path in enumerate(images):\n",
+    "        img = Image.open(path)\n",
+    "        ax = axs[i // 5, i % 5]  # Use double indexing for 2D subplots\n",
+    "        ax.imshow(img)\n",
+    "        ax.axis('off')\n",
+    "    plt.show()\n",
+    "\n",
+    "# target이 0인 이미지 출력\n",
+    "display_images(image_data, target=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.2.1 Displying random images using PIL"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 275,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1600x1000 with 10 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# 이미지를 랜덤으로 5개 출력\n",
+    "plt.style.use('default')\n",
+    "fig, axex = plt.subplots(2, 5, figsize=(16, 10))\n",
+    "for ax in axex.reshape(-1):\n",
+    "    img_path = np.random.choice(train_images)\n",
+    "    img = Image.open(img_path)\n",
+    "    ax.imshow(img)\n",
+    "    ax.set_title(f\"Image name: {img_path.split('/')[-1]}\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 276,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# 가장 큰 이미지를 출력\n",
+    "biggest_img_path = image_data.iloc[image_data['size'].idxmax(),:]['path']\n",
+    "\n",
+    "img = Image.open(biggest_img_path)\n",
+    "plt.title(f\"Biggest image: {biggest_img_path.split('/')[-1]}\")\n",
+    "plt.imshow(img)\n",
+    "del img"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 277,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array(['./data/train/n04127249/sketch_9.JPEG',\n",
+       "       './data/train/n01484850/sketch_34.JPEG',\n",
+       "       './data/train/n01484850/sketch_0.JPEG',\n",
+       "       './data/train/n01494475/sketch_33.JPEG'], dtype=object)"
+      ]
+     },
+     "execution_count": 277,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# 4개의 작은 이미지를 출력\n",
+    "smallest_img_paths = image_data.nsmallest(4, 'size')['path']\n",
+    "smallest_img_paths.values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 278,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1600x1000 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.image as mpimg\n",
+    "\n",
+    "# 4개의 작은 이미지를 출력\n",
+    "fig, axes = plt.subplots(1, 4, figsize=(16, 10))\n",
+    "for i, ax in enumerate(axes.reshape(-1)):\n",
+    "    img = mpimg.imread(smallest_img_paths.values[i])\n",
+    "    ax.title.set_text(f\"Smallest image: {smallest_img_paths.values[i].split('/')[-1]}\")\n",
+    "    ax.imshow(img)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 279,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x3076219d0>"
+      ]
+     },
+     "execution_count": 279,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1600x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# 이미지의 종횡비가 가장 큰 이미지를 출력\n",
+    "biggest_aspect_ratio_img_path = image_data.iloc[image_data['img_aspect_ratio'].idxmax(),:]['path']\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 1, figsize=(16, 10))\n",
+    "img = Image.open(biggest_aspect_ratio_img_path)\n",
+    "plt.title(f\"Biggest aspect ratio image: {biggest_aspect_ratio_img_path.split('/')[-1]}\")\n",
+    "plt.imshow(img)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.2.2 Diplaying, resizing and manipulation using CV2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 280,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>height</th>\n",
+       "      <th>width</th>\n",
+       "      <th>mode</th>\n",
+       "      <th>format</th>\n",
+       "      <th>size</th>\n",
+       "      <th>class_name_x</th>\n",
+       "      <th>path</th>\n",
+       "      <th>image_path</th>\n",
+       "      <th>img_aspect_ratio</th>\n",
+       "      <th>class_name_y</th>\n",
+       "      <th>target</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>800</td>\n",
+       "      <td>752</td>\n",
+       "      <td>RGB</td>\n",
+       "      <td>JPEG</td>\n",
+       "      <td>0.1</td>\n",
+       "      <td>n02795169</td>\n",
+       "      <td>./data/train/n02795169/sketch_12.JPEG</td>\n",
+       "      <td>n02795169/sketch_12.JPEG</td>\n",
+       "      <td>0.94</td>\n",
+       "      <td>n02795169</td>\n",
+       "      <td>237</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "    height  width mode format  size class_name_x  \\\n",
+       "10     800    752  RGB   JPEG   0.1    n02795169   \n",
+       "\n",
+       "                                     path                image_path  \\\n",
+       "10  ./data/train/n02795169/sketch_12.JPEG  n02795169/sketch_12.JPEG   \n",
+       "\n",
+       "    img_aspect_ratio class_name_y  target  \n",
+       "10              0.94    n02795169     237  "
+      ]
+     },
+     "execution_count": 280,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "img_path = train_images[10]\n",
+    "selected_img = image_data[image_data['path'] == img_path]\n",
+    "selected_img"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 281,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "img = mpimg.imread(img_path)\n",
+    "plt.imshow(img)\n",
+    "plt.axis('off')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 282,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1600x1000 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "img = cv2.imread(img_path, cv2.IMREAD_COLOR)\n",
+    "resized_img = cv2.resize(img, (0,0), fx=0.5, fy=0.5)\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 2, figsize=(16, 10))\n",
+    "ax[0].imshow(img)\n",
+    "ax[0].set_title(\"Original image\")\n",
+    "ax[1].imshow(resized_img)\n",
+    "ax[1].set_title(\"Resized image\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "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.11.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/RECcode/requirements.txt b/RECcode/requirements.txt
new file mode 100644
index 0000000..2f78761
--- /dev/null
+++ b/RECcode/requirements.txt
@@ -0,0 +1,10 @@
+pandas==2.1.4
+matplotlib==3.8.4
+seaborn==0.13.2
+Pillow==10.3.0
+numpy==1.26.3
+timm==0.9.16
+albumentations==1.4.4
+tqdm==4.66.1
+scikit-learn==1.4.2
+opencv-python==4.9.0.80
diff --git a/module_base/config.yaml b/module_base/config.yaml
index 1a25b31..4663db5 100644
--- a/module_base/config.yaml
+++ b/module_base/config.yaml
@@ -6,7 +6,7 @@ save_dir: /data/ephemeral/home/data/result
 # 모델 라이브러리 및 사용 모델 정의
 model_type: smp
 model_name: UnetPlusPlus
-encoder_name: tu-hrnet_w64
+encoder_name: efficientnet-b2
 encoder_weights: imagenet
 pretrained: True
 
@@ -23,7 +23,7 @@ max_epoch: 60
 
 # loss
 loss:
-    name: DiceFocalLoss
+    name: BCE
     params: null
 
 # optimizer
@@ -41,8 +41,8 @@ threshold: 0.5
 random_seed: 2024
 
 # resize
-size: 1024
+size: 2048
 
 # wandb
-wandb_run_name: smp_unet++_efficientnetv2_xl_DiceBCELoss_cosine_flip+rotate
+wandb_run_name: UNet++_eff_2048
 wandb_run_id: None
\ No newline at end of file
diff --git a/streamlit/main.py b/streamlit/main.py
index dca9b85..867cc46 100644
--- a/streamlit/main.py
+++ b/streamlit/main.py
@@ -8,9 +8,8 @@
 
 
 info = {
-    'image_root': "../../data/{}/DCM",
-    'all_image_root': "../../data/test/DCM/all_pngs",
-    'label_root': "../../data/train/outputs_json",
+    'image_root': "/data/ephemeral/home/sy/level2-cv-semanticsegmentation-cv-19-lv3/data/test/DCM",
+    'label_root': "/data/ephemeral/home/sy/level2-cv-semanticsegmentation-cv-19-lv3/data/train/outputs_json",
     'classes': [
         'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
         'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',

From ee042fcaa0f712b5a1650804b8a578a21d309588 Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Wed, 27 Nov 2024 22:39:42 +0900
Subject: [PATCH 082/106] [Feature]: add config for decoder head threshold

---
 mmsegmentation/baseline.py                    |  6 +-
 .../_custom_/_base_/cleansed_xraydata2.py     |  2 +-
 .../configs/_custom_/_base_/schedule_160k.py  |  2 +-
 .../_custom_/upernet/upernet_convnext.py      | 81 +++++++++++++++++++
 .../_custom_/upernet/upernet_swin-T.py        |  2 +-
 .../mmseg/models/segmentors/custom.py         |  7 +-
 .../mmseg/models/segmentors/seg_tta.py        |  7 +-
 7 files changed, 100 insertions(+), 7 deletions(-)
 create mode 100644 mmsegmentation/configs/_custom_/upernet/upernet_convnext.py

diff --git a/mmsegmentation/baseline.py b/mmsegmentation/baseline.py
index 28da90c..4ac4de6 100644
--- a/mmsegmentation/baseline.py
+++ b/mmsegmentation/baseline.py
@@ -1,14 +1,16 @@
 from mmengine.config import Config
 from mmengine.runner import Runner
+import sys
+sys.path.append("/data/ephemeral/home/mmpretrain")
 
 
 ##############################
 # 데이터 경로를 입력하세요
 
-CONFIG_PATH = "/data/ephemeral/home/parkjunil/level2-cv-semanticsegmentation-cv-19-lv3/mmsegmentation/configs/_baseline_/config_for_this_example.py"
+CONFIG_PATH = "/data/ephemeral/home/parkjunil/level2-cv-semanticsegmentation-cv-19-lv3/mmsegmentation/configs/_custom_/upernet/upernet_convnext.py"
 CHECKPOINT_PATH = "/data/ephemeral/home/parkjunil/work_dir/hrnet18_upernet_2048_elas_rotate_hflip_whole/best_mDice_iter_18000.pth"
 SUBMISSION_PATH = "/data/ephemeral/home/submission"
-WORK_DIR = "/data/ephemeral/home/parkjunil/work_dir/hrnet18_upernet_2048_elas_rotate_hflip_whole_inference"
+WORK_DIR = "/data/ephemeral/home/parkjunil/work_dir/convnext-B_upernet_1580_elas_rotate_hflip_whole"
 TTA = False
 
 
diff --git a/mmsegmentation/configs/_custom_/_base_/cleansed_xraydata2.py b/mmsegmentation/configs/_custom_/_base_/cleansed_xraydata2.py
index e8e820b..33e4232 100644
--- a/mmsegmentation/configs/_custom_/_base_/cleansed_xraydata2.py
+++ b/mmsegmentation/configs/_custom_/_base_/cleansed_xraydata2.py
@@ -1,4 +1,4 @@
-IMAGE_SIZE = (1536, 1536)
+IMAGE_SIZE = (1580, 1580)
 IMAGE_ROOT = '/data/ephemeral/home/cleansed_data/train/DCM'
 LABEL_ROOT = '/data/ephemeral/home/cleansed_data/train/outputs_json'
 SUBMISSION_PATH = '/data/ephemeral/home/submission'
diff --git a/mmsegmentation/configs/_custom_/_base_/schedule_160k.py b/mmsegmentation/configs/_custom_/_base_/schedule_160k.py
index 13238b4..dcf4414 100644
--- a/mmsegmentation/configs/_custom_/_base_/schedule_160k.py
+++ b/mmsegmentation/configs/_custom_/_base_/schedule_160k.py
@@ -10,7 +10,7 @@
     type='AmpOptimWrapper',
     optimizer=optimizer,
     clip_grad=dict(max_norm=0.01, norm_type=2),
-    accumulative_counts=4
+    accumulative_counts=2
     )
 
 # mixed precision
diff --git a/mmsegmentation/configs/_custom_/upernet/upernet_convnext.py b/mmsegmentation/configs/_custom_/upernet/upernet_convnext.py
new file mode 100644
index 0000000..048dd41
--- /dev/null
+++ b/mmsegmentation/configs/_custom_/upernet/upernet_convnext.py
@@ -0,0 +1,81 @@
+_base_ = [
+    '../_base_/cleansed_xraydata2.py',
+    '../_base_/default_runtime.py', '../_base_/schedule_160k.py'
+]
+
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+custom_imports = dict(imports='mmpretrain.models', allow_failed_imports=False)
+checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-base_3rdparty_32xb128-noema_in1k_20220301-2a0ee547.pth'  # noqa
+crop_size = (512, 512)
+num_classes = 29
+
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    size=crop_size,
+    seg_pad_val=255)
+
+model = dict(
+    type='EncoderDecoderWithoutArgmax',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        type='mmpretrain.ConvNeXt',
+        arch='base',
+        out_indices=[0, 1, 2, 3],
+        drop_path_rate=0.4,
+        layer_scale_init_value=1.0,
+        gap_before_final_norm=False,
+        init_cfg=dict(
+            type='Pretrained', checkpoint=checkpoint_file,
+            prefix='backbone.')),
+    decode_head=dict(
+        type='UPerHeadWithoutAccuracy',
+        in_channels=[128, 256, 512, 1024],
+        in_index=[0, 1, 2, 3],
+        pool_scales=(1, 2, 3, 6),
+        channels=512,
+        dropout_ratio=0.1,
+        num_classes=num_classes,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=[
+            dict(type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
+            dict(type='DiceLoss', use_sigmoid=True, loss_weight=3.0)
+        ]),
+    auxiliary_head=dict(
+        type='FCNHeadWithoutAccuracy',
+        in_channels=512,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=num_classes,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=[
+            dict(type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.4),
+            dict(type='DiceLoss', use_sigmoid=True, loss_weight=1.0)
+        ]),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+
+
+optim_wrapper = dict(
+    paramwise_cfg={
+        'decay_rate': 0.9,
+        'decay_type': 'stage_wise',
+        'num_layers': 12
+    },
+    constructor='LearningRateDecayOptimizerConstructor',
+    loss_scale='dynamic')
+
+# By default, models are trained on 8 GPUs with 2 images per GPU
+train_dataloader = dict(batch_size=2)
+# val_dataloader = dict(batch_size=1)
+# test_dataloader = val_dataloader
\ No newline at end of file
diff --git a/mmsegmentation/configs/_custom_/upernet/upernet_swin-T.py b/mmsegmentation/configs/_custom_/upernet/upernet_swin-T.py
index d8090f0..24a5a76 100644
--- a/mmsegmentation/configs/_custom_/upernet/upernet_swin-T.py
+++ b/mmsegmentation/configs/_custom_/upernet/upernet_swin-T.py
@@ -102,5 +102,5 @@
 ]
 
 # By default, models are trained on 8 GPUs with 2 images per GPU
-train_dataloader = dict(batch_size=2)
+# train_dataloader = dict(batch_size=2)
 val_dataloader = dict(batch_size=1)
\ No newline at end of file
diff --git a/mmsegmentation/mmseg/models/segmentors/custom.py b/mmsegmentation/mmseg/models/segmentors/custom.py
index 2733cab..2aafb33 100644
--- a/mmsegmentation/mmseg/models/segmentors/custom.py
+++ b/mmsegmentation/mmseg/models/segmentors/custom.py
@@ -69,8 +69,13 @@ def postprocess_result(self,
             else:
                 i_seg_logits = seg_logits[i]
 
+            if self.module.decode_head.threshold:
+                threshold = self.module.decode_head.threshold
+            else:
+                threshold = 0.5
+            
             i_seg_logits = i_seg_logits.sigmoid()
-            i_seg_pred = (i_seg_logits > 0.5).to(i_seg_logits)
+            i_seg_pred = (i_seg_logits > threshold).to(i_seg_logits)
             
             data_samples[i].set_data({
                 'seg_logits':
diff --git a/mmsegmentation/mmseg/models/segmentors/seg_tta.py b/mmsegmentation/mmseg/models/segmentors/seg_tta.py
index 5cea8c3..fed8d6e 100644
--- a/mmsegmentation/mmseg/models/segmentors/seg_tta.py
+++ b/mmsegmentation/mmseg/models/segmentors/seg_tta.py
@@ -70,7 +70,12 @@ def merge_preds(self, data_samples_list: List[SampleList]) -> SampleList:
                 logits += seg_logit
             logits /= len(data_samples)
             
-            seg_pred = (logits > self.module.decode_head.threshold
+            if self.module.decode_head.threshold:
+                threshold = self.module.decode_head.threshold
+            else:
+                threshold = 0.5
+            
+            seg_pred = (logits > threshold
                         ).to(logits)
             data_sample.set_data({'pred_sem_seg': PixelData(data=seg_pred)})
             if hasattr(data_samples[0], 'gt_sem_seg'):

From 0aba7b355666494b6e3b47ec4deae9200269b3e6 Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Thu, 28 Nov 2024 10:46:44 +0900
Subject: [PATCH 083/106] [#21] Feature : add MixupDataset

---
 module_base/config.yaml    | 14 ++++++-------
 module_base/dataset.py     | 41 +++++++++++++++++++++++++++++++-------
 module_base/inference.py   |  2 +-
 module_base/transform.py   |  7 +++++--
 module_base/wandb_train.py | 14 ++++++-------
 5 files changed, 53 insertions(+), 25 deletions(-)

diff --git a/module_base/config.yaml b/module_base/config.yaml
index 6c51a1a..54d4407 100644
--- a/module_base/config.yaml
+++ b/module_base/config.yaml
@@ -6,21 +6,21 @@ save_dir: /data/ephemeral/home/data/result
 # 모델 라이브러리 및 사용 모델 정의
 model_type: smp
 model_name: UnetPlusPlus
-encoder_name: vgg19_bn
+encoder_name: tu-hrnet_w64
 encoder_weights: imagenet
 pretrained: True
 
 # batch_size
-train_batch_size: 1
-valid_batch_size: 1
+train_batch_size: 2
+valid_batch_size: 4
 
 # hyperparameter
-lr: 2e-4
+lr: 1e-4
 weight_decay: 1e-6
 train_num_workers: 4
 valid_num_workers: 0
 max_epoch: 60
-step: 2 # batch_size 효과
+step: 4 # batch_size 효과
 
 # loss
 loss:
@@ -42,8 +42,8 @@ threshold: 0.5
 random_seed: 2024
 
 # resize
-size: 2048
+size: 1024
 
 # wandb
-wandb_run_name: smp_unet++_vgg19_DiceBCELoss_cosine_flip+rotate_adam_2048
+wandb_run_name: smp_unet++_hrnet_DiceBCELoss_cosine_flip+rotate+mixup+brightnesscontrast+clahe
 wandb_run_id: None
\ No newline at end of file
diff --git a/module_base/dataset.py b/module_base/dataset.py
index a7ebebd..28e5797 100644
--- a/module_base/dataset.py
+++ b/module_base/dataset.py
@@ -32,7 +32,7 @@ def __init__(self, fnames, labels, image_root, label_root, kfold=0, transforms=N
         # dummy label
         ys = [0 for fname in fnames]
         
-        gkf = GroupKFold(n_splits=5)
+        gkf = GroupKFold(n_splits=8)
         
         filenames = []
         labelnames = []
@@ -66,7 +66,7 @@ def __getitem__(self, item):
         label_path = os.path.join(self.label_root, label_name)
         
         # (H, W, NC) 모양의 label을 생성합니다.
-        label_shape = tuple(image.shape[:2]) + (len(CLASSES), )
+        label_shape = tuple(image.shape[:2]) + (len(CLASSES), ) # (2048, 2048, 29)
         label = np.zeros(label_shape, dtype=np.uint8)
         
         # label 파일을 읽습니다.
@@ -76,13 +76,13 @@ def __getitem__(self, item):
         
         # 클래스 별로 처리합니다.
         for ann in annotations:
-            c = ann["label"]
-            class_ind = self.class2ind[c]
-            points = np.array(ann["points"])
+            c = ann["label"] # class name
+            class_ind = self.class2ind[c] # to index
+            points = np.array(ann["points"]) # mask
             
             # polygon 포맷을 dense한 mask 포맷으로 바꿉니다.
-            class_label = np.zeros(image.shape[:2], dtype=np.uint8)
-            cv2.fillPoly(class_label, [points], 1)
+            class_label = np.zeros(image.shape[:2], dtype=np.uint8) # (2048, 2048)
+            cv2.fillPoly(class_label, [points], 1) # points 좌표의 점을 1로 채우기
             label[..., class_ind] = class_label
         
         if self.transforms is not None:
@@ -101,6 +101,33 @@ def __getitem__(self, item):
         
         return image, label
 
+class XRayDatasetWithMixup(XRayDataset):
+    def __init__(self, fnames, labels, image_root, label_root, kfold=0, transforms=None, 
+                is_train=True, mixup_prob=0.5, mixup_alpha=0.5):
+        super().__init__(fnames, labels, image_root, label_root, kfold, transforms, is_train)
+        self.mixup_prob = mixup_prob  # mixup을 적용할 확률
+        self.mixup_alpha = mixup_alpha  # Beta 분포의 알파 값
+        
+    def __getitem__(self, item):
+        image, label = super().__getitem__(item)
+        
+        # 학습 시에만 mixup을 적용하고, mixup_prob 확률로 적용
+        if self.is_train and torch.rand(1) < self.mixup_prob:
+            # 랜덤하게 다른 인덱스 선택
+            other_idx = torch.randint(len(self), size=(1,)).item()
+            other_image, other_label = super().__getitem__(other_idx)
+            
+            # Beta 분포에서 혼합 비율 샘플링
+            lam = np.random.beta(self.mixup_alpha, self.mixup_alpha)
+            
+            # 이미지와 라벨 혼합
+            mixed_image = lam * image + (1 - lam) * other_image
+            mixed_label = lam * label + (1 - lam) * other_label
+            
+            return mixed_image, mixed_label
+        
+        return image, label
+
 class XRayInferenceDataset(Dataset):
     def __init__(self, fnames, image_root, transforms=None):
         self.fnames = np.array(sorted(fnames))
diff --git a/module_base/inference.py b/module_base/inference.py
index b1cac75..9cb7523 100644
--- a/module_base/inference.py
+++ b/module_base/inference.py
@@ -127,7 +127,7 @@ def do_inference(image_root, save_dir, random_seed, model_type):
         "rle": rles,
     })
     
-    df.to_csv("best_hrnet_adamw.csv", index=False)
+    df.to_csv("best_hrnet_prepro(BrightnessContrast&CLAHE).csv", index=False)
 
 def main(args):
     do_inference(**args.__dict__)
diff --git a/module_base/transform.py b/module_base/transform.py
index 6bcee72..f81b8bf 100644
--- a/module_base/transform.py
+++ b/module_base/transform.py
@@ -2,14 +2,17 @@
 
 class AlbumentationTransform:
     def __init__(self, is_train, resize):
-        common_transform = [A.Resize(resize, resize)]
+        common_transform = [
+            A.Resize(resize, resize),
+            A.RandomBrightnessContrast(brightness_limit=(0.1, 0.1), contrast_limit=(0.1, 0.1), p=1),
+            A.CLAHE(clip_limit=2.0, tile_grid_size=(8, 8), always_apply=False, p=1.0),
+                            ]
         
         if is_train:
             self.transform = A.Compose(
                 [
                     A.HorizontalFlip(0.2),
                     A.Rotate(limit=(-15, 15), p=0.5),
-                    # A.CLAHE(clip_limit=4.0, tile_grid_size=(8, 8), always_apply=False, p=1.0)
                 ]+ common_transform)
         else:
             self.transform = A.Compose(common_transform)
diff --git a/module_base/wandb_train.py b/module_base/wandb_train.py
index 09a30d4..3dfea10 100644
--- a/module_base/wandb_train.py
+++ b/module_base/wandb_train.py
@@ -1,7 +1,6 @@
 # python native
 import os
 import random
-import time
 import datetime
 
 import numpy as np
@@ -12,7 +11,7 @@
 import torch.nn.functional as F
 from torch.utils.data import DataLoader
 
-from dataset import XRayDataset
+from dataset import XRayDataset, XRayDatasetWithMixup
 from model import ModelSelector
 from transform import TransformSelector
 from loss import LossSelector
@@ -129,7 +128,6 @@ def train(model, train_loader, val_loader, criterion, optimizer, scheduler, cfg)
     logger.initialize(wandb_config)
     
     for epoch in range(cfg.max_epoch):
-        epoch_start = time.time()
         epoch_loss = 0
         torch.cuda.empty_cache() # 학습 시작 전 캐시 삭제
         model.train()
@@ -145,9 +143,9 @@ def train(model, train_loader, val_loader, criterion, optimizer, scheduler, cfg)
                     outputs = model(images)
                 loss = criterion(outputs, masks)
                 # 아래 부터는 gradient accumulation
-                loss = loss / cfg.step
-            '''
+                # loss = loss / cfg.step
             # 스케일된 loss를 사용해 backward 및 optimizer step
+            epoch_loss += loss.item()
             optimizer.zero_grad()
             scaler.scale(loss).backward()
             scaler.step(optimizer)
@@ -161,7 +159,7 @@ def train(model, train_loader, val_loader, criterion, optimizer, scheduler, cfg)
                 scaler.step(optimizer)
                 scaler.update()
                 optimizer.zero_grad()
-
+            '''
             # step 주기에 따라 loss를 출력합니다.
             if (step + 1) % 80 == 0:
                 print(
@@ -175,9 +173,9 @@ def train(model, train_loader, val_loader, criterion, optimizer, scheduler, cfg)
         if (epoch + 1) % cfg.val_every == 0:
             dice, val_loss = validation(epoch + 1, model, val_loader, criterion, cfg.model_type)
             if best_dice < dice:
+                print(f"Best performance at epoch: {epoch + 1}, {best_dice:.4f} -> {dice:.4f}")
                 best_dice = dice
                 ckpt_path = save_model(model, cfg.save_dir)
-                print(f"Best performance at epoch: {epoch + 1}, {best_dice:.4f} -> {dice:.4f}")
                 print(f"Save model in {cfg.save_dir}")
             logger.log_model(ckpt_path, f'model-epoch-{epoch+1}')
             logger.log_epoch_metrics(
@@ -202,7 +200,7 @@ def main(cfg):
     val_trans = TransformSelector('albumentation')
     val_tf = val_trans.get_transform(False, cfg.size)
 
-    train_dataset = XRayDataset(fnames, labels, cfg.image_root, cfg.label_root, cfg.kfold, train_tf, is_train=True)
+    train_dataset = XRayDatasetWithMixup(fnames, labels, cfg.image_root, cfg.label_root, cfg.kfold, train_tf, is_train=True)
     valid_dataset = XRayDataset(fnames, labels, cfg.image_root, cfg.label_root, cfg.kfold, val_tf, is_train=False)
     
     train_loader = DataLoader(

From efb17ee46d05ad38cf859c83ceb1b2b942b56481 Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Thu, 28 Nov 2024 10:54:11 +0900
Subject: [PATCH 084/106] modified

---
 module_base/dataset.py   | 2 +-
 module_base/transform.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/module_base/dataset.py b/module_base/dataset.py
index 28e5797..fc6cd95 100644
--- a/module_base/dataset.py
+++ b/module_base/dataset.py
@@ -32,7 +32,7 @@ def __init__(self, fnames, labels, image_root, label_root, kfold=0, transforms=N
         # dummy label
         ys = [0 for fname in fnames]
         
-        gkf = GroupKFold(n_splits=8)
+        gkf = GroupKFold(n_splits=20)
         
         filenames = []
         labelnames = []
diff --git a/module_base/transform.py b/module_base/transform.py
index f81b8bf..c1e3c85 100644
--- a/module_base/transform.py
+++ b/module_base/transform.py
@@ -6,7 +6,7 @@ def __init__(self, is_train, resize):
             A.Resize(resize, resize),
             A.RandomBrightnessContrast(brightness_limit=(0.1, 0.1), contrast_limit=(0.1, 0.1), p=1),
             A.CLAHE(clip_limit=2.0, tile_grid_size=(8, 8), always_apply=False, p=1.0),
-                            ]
+            ]
         
         if is_train:
             self.transform = A.Compose(

From 9d62e2ab49dd6228a21cfc1b22e0d406ca8c8c57 Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Thu, 28 Nov 2024 11:45:28 +0900
Subject: [PATCH 085/106] [Refactor] : refactoring

---
 sam2_unet/test.py            | 4 ++--
 sam2_unet/utils/dataset.py   | 2 +-
 sam2_unet/utils/loss.py      | 3 ++-
 sam2_unet/utils/transform.py | 2 +-
 4 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/sam2_unet/test.py b/sam2_unet/test.py
index 59f35bc..dcc9c1a 100644
--- a/sam2_unet/test.py
+++ b/sam2_unet/test.py
@@ -51,7 +51,7 @@ def decode_rle_to_mask(rle, height, width):
     
     return img.reshape(height, width)
 
-def test(model, cfg, thr=0.5):
+def test(model, cfg):
     classes = [
         'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
         'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
@@ -90,7 +90,7 @@ def test(model, cfg, thr=0.5):
             
             outputs = F.interpolate(outputs, size=(2048, 2048), mode="bilinear")
             outputs = torch.sigmoid(outputs)
-            outputs = (outputs > thr).detach().cpu().numpy()
+            outputs = (outputs > cfg.threshold).detach().cpu().numpy()
             
             for output, image_name in zip(outputs, image_names):
                 for c, segm in enumerate(output):
diff --git a/sam2_unet/utils/dataset.py b/sam2_unet/utils/dataset.py
index 0837d37..b34d76b 100644
--- a/sam2_unet/utils/dataset.py
+++ b/sam2_unet/utils/dataset.py
@@ -46,7 +46,7 @@ def split_data(pngs, jsons, kfold=5, k=0):
         if idx != k:
             train_datalist['filenames'] += list(_filenames[y])
             train_datalist['labelnames'] += list(_labelnames[y])
-        elif idx == k:
+        if (k < 0 and idx == 0) or (idx == k):
             valid_datalist['filenames'] += list(_filenames[y])
             valid_datalist['labelnames'] += list(_labelnames[y])
 
diff --git a/sam2_unet/utils/loss.py b/sam2_unet/utils/loss.py
index 4a66c21..528f100 100644
--- a/sam2_unet/utils/loss.py
+++ b/sam2_unet/utils/loss.py
@@ -2,7 +2,8 @@
 import torch.nn.functional as F
 
 def structure_loss(pred, mask, smooth_factor=0):
-    mask = mask * (1 - smooth_factor) + smooth_factor / 29
+    if smooth_factor > 0:
+        mask = mask * (1 - smooth_factor) + smooth_factor / 29
     weit = 1 + 5*torch.abs(F.avg_pool2d(mask, kernel_size=31, stride=1, padding=15) - mask)
     wbce = F.binary_cross_entropy_with_logits(pred, mask, reduce='none')
     wbce = (weit*wbce).sum(dim=(2, 3)) / weit.sum(dim=(2, 3))
diff --git a/sam2_unet/utils/transform.py b/sam2_unet/utils/transform.py
index 02150e1..9de2176 100644
--- a/sam2_unet/utils/transform.py
+++ b/sam2_unet/utils/transform.py
@@ -8,7 +8,7 @@ def get_transform(self, is_train=True):
         if is_train:
             transform = A.Compose(
                 [
-                    # A.HorizontalFlip(p=0.2),
+                    A.HorizontalFlip(p=0.2),
                     A.ColorJitter(),
                     A.Rotate((-15, 15), p=0.5)
                 ]+ self.common_transform)

From 61034754c86f9615d9b2c7caf6634023affb603b Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Thu, 28 Nov 2024 14:58:41 +0900
Subject: [PATCH 086/106] [Feature] : find image name

---
 streamlit/main.py | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/streamlit/main.py b/streamlit/main.py
index dca9b85..5a842e5 100644
--- a/streamlit/main.py
+++ b/streamlit/main.py
@@ -132,5 +132,13 @@
     image_index_input = st.sidebar.number_input('Enter image index', min_value=0, max_value=len(st.session_state.images)-image_count*image_line, value=image_index, step=image_count*image_line)
     if image_index != image_index_input:
         image_index = image_index_input
+    with st.sidebar.form(key="image name form"):
+        image_name = st.text_input("Enter image name")
+        submit_button = st.form_submit_button("OK")
+        if submit_button:
+            try:
+                image_index = st.session_state.images.index(image_name)
+            except Exception as e:
+                st.sidebar.error("failed :(")
     for i in range(image_index, image_index + image_line*image_count, image_count):
         visualize_rle.show(info, st.session_state.df, st.session_state.images[i:i+image_count], st.session_state.anno)
\ No newline at end of file

From a1cdc7d76bbc9b4a5454feb222e75cd91c4179c4 Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Fri, 29 Nov 2024 09:42:19 +0900
Subject: [PATCH 087/106] [Feature]:add inference and train code for mmseg

---
 custom_inference.py                           | 11 ++-
 mmsegmentation/baseline.py                    | 10 +-
 .../_custom_/_base_/cleansed_xraydata2.py     |  8 +-
 ...0-d8_4xb2-300k_mapillay_v1_65-1280x1280.py | 36 +------
 .../_custom_/upernet/upernet_hr_18_test.py    | 94 +++++++++++++++++++
 mmsegmentation/mmseg/datasets/xray2.py        |  6 +-
 .../mmseg/models/segmentors/custom.py         |  9 +-
 7 files changed, 123 insertions(+), 51 deletions(-)
 create mode 100644 mmsegmentation/configs/_custom_/upernet/upernet_hr_18_test.py

diff --git a/custom_inference.py b/custom_inference.py
index eb54337..b676702 100644
--- a/custom_inference.py
+++ b/custom_inference.py
@@ -9,11 +9,13 @@ def parse_arguments():
     parser.add_argument('--checkpoint_path', help='.pth파일 위치', default='./work_dir/best_mDice_iter_20000.pth')
     parser.add_argument('--work_dir', help='실험 결과를 저장할 경로', default='./work_dir')
     parser.add_argument('--submission_path', help='inference 결과를 저장할 경로', default='./result')
+    parser.add_argument(
+        '--tta', action='store_true', help='Test time augmentation')
     args = parser.parse_args()
     return args
 
     
-def main(config_path, checkpoint_path, work_dir, submission_path):
+def main(config_path, checkpoint_path, work_dir, submission_path, tta):
      # load config
     cfg = Config.fromfile(config_path)
     cfg.launcher = "none"
@@ -24,10 +26,15 @@ def main(config_path, checkpoint_path, work_dir, submission_path):
     cfg.load_from = checkpoint_path
     cfg.test_evaluator.save_path = submission_path
     
+    if tta:
+        cfg.test_dataloader.dataset.pipeline = cfg.tta_pipeline
+        cfg.tta_model.module = cfg.model
+        cfg.model = cfg.tta_model
+    
     runner = Runner.from_cfg(cfg)
     runner.test()
 
 
 if __name__ == "__main__":
     args = parse_arguments()
-    main(args.config_path, args.checkpoint_path, args.work_dir, args.submission_path)
\ No newline at end of file
+    main(args.config_path, args.checkpoint_path, args.work_dir, args.submission_path, args.tta)
\ No newline at end of file
diff --git a/mmsegmentation/baseline.py b/mmsegmentation/baseline.py
index 4ac4de6..8aa84d0 100644
--- a/mmsegmentation/baseline.py
+++ b/mmsegmentation/baseline.py
@@ -7,10 +7,10 @@
 ##############################
 # 데이터 경로를 입력하세요
 
-CONFIG_PATH = "/data/ephemeral/home/parkjunil/level2-cv-semanticsegmentation-cv-19-lv3/mmsegmentation/configs/_custom_/upernet/upernet_convnext.py"
-CHECKPOINT_PATH = "/data/ephemeral/home/parkjunil/work_dir/hrnet18_upernet_2048_elas_rotate_hflip_whole/best_mDice_iter_18000.pth"
+CONFIG_PATH = "/data/ephemeral/home/parkjunil/work_dir/convnext-B_upernet_1580_elas_rotate_hflip_whole/upernet_convnext.py"
+CHECKPOINT_PATH = "/data/ephemeral/home/parkjunil/work_dir/convnext-B_upernet_1580_elas_rotate_hflip_whole/best_mDice_iter_10000.pth"
 SUBMISSION_PATH = "/data/ephemeral/home/submission"
-WORK_DIR = "/data/ephemeral/home/parkjunil/work_dir/convnext-B_upernet_1580_elas_rotate_hflip_whole"
+WORK_DIR = "/data/ephemeral/home/parkjunil/work_dir/infer"
 TTA = False
 
 
@@ -57,5 +57,5 @@ def inference():
 
 
 if __name__ == "__main__":
-    train()
-    # inference()
\ No newline at end of file
+    # train()
+    inference()
\ No newline at end of file
diff --git a/mmsegmentation/configs/_custom_/_base_/cleansed_xraydata2.py b/mmsegmentation/configs/_custom_/_base_/cleansed_xraydata2.py
index 33e4232..decee5d 100644
--- a/mmsegmentation/configs/_custom_/_base_/cleansed_xraydata2.py
+++ b/mmsegmentation/configs/_custom_/_base_/cleansed_xraydata2.py
@@ -1,4 +1,4 @@
-IMAGE_SIZE = (1580, 1580)
+IMAGE_SIZE = (2048, 2048)
 IMAGE_ROOT = '/data/ephemeral/home/cleansed_data/train/DCM'
 LABEL_ROOT = '/data/ephemeral/home/cleansed_data/train/outputs_json'
 SUBMISSION_PATH = '/data/ephemeral/home/submission'
@@ -15,12 +15,12 @@
                 type='Albu',  # Albumentations를 이용한 변환
                 transforms=[
                     dict(type='HorizontalFlip', p=0.5),  # 수평 뒤집기
-                    dict(type='ShiftScaleRotate', shift_limit=0.0, scale_limit=0.0, rotate_limit=20, p=0.5),  # 회전
+                    dict(type='ShiftScaleRotate', shift_limit=0.0, scale_limit=0.0, rotate_limit=15, p=0.5),  # 회전
                     dict(
                         type='ElasticTransform',  # 탄성 변환
                         alpha=10,
-                        sigma=100,
-                        p=0.8,
+                        sigma=50,
+                        p=0.5,
                     ),
                 ]
             ),
diff --git a/mmsegmentation/configs/_custom_/deeplabV3+/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280.py b/mmsegmentation/configs/_custom_/deeplabV3+/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280.py
index 60fb2c7..9ae153d 100644
--- a/mmsegmentation/configs/_custom_/deeplabV3+/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280.py
+++ b/mmsegmentation/configs/_custom_/deeplabV3+/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280.py
@@ -1,5 +1,5 @@
 _base_ = [
-    '../_base_/xraydata2.py',
+    '../_base_/cleansed_xraydata2.py',
     '../_base_/default_runtime.py', '../_base_/schedule_160k.py'
 ]
 
@@ -45,7 +45,7 @@
         loss_decode=dict(
             type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)),
     auxiliary_head=dict(
-        type='FCNHead',
+        type='FCNHeadWithoutAccuracy',
         in_channels=1024,
         in_index=2,
         channels=256,
@@ -62,36 +62,6 @@
     test_cfg=dict(mode='whole'))
 
 
-iters = 30000
-# optimizer
-optimizer = dict(
-    type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.0001)
-# optimizer
-optim_wrapper = dict(
-    type='OptimWrapper',
-    optimizer=optimizer,
-    clip_grad=dict(max_norm=0.01, norm_type=2),
-    paramwise_cfg=dict(
-        custom_keys={'backbone': dict(lr_mult=0.1, decay_mult=1.0)}))
-param_scheduler = [
-    dict(
-        type='PolyLR',
-        eta_min=0,
-        power=0.9,
-        begin=0,
-        end=iters,
-        by_epoch=False)
-]
-
-# training schedule for 300k
-train_cfg = dict(
-    type='IterBasedTrainLoop', max_iters=iters, val_interval=iters // 15)
-val_cfg = dict(type='ValLoop')
-test_cfg = dict(type='TestLoop')
 
 # train_dataloader = dict(batch_size=2)
-# Default setting for scaling LR automatically
-#   - `enable` means enable scaling LR automatically
-#       or not by default.
-#   - `base_batch_size` = (4 GPUs) x (2 samples per GPU).
-auto_scale_lr = dict(enable=False, base_batch_size=2)
\ No newline at end of file
+# auto_scale_lr = dict(enable=False, base_batch_size=2)
\ No newline at end of file
diff --git a/mmsegmentation/configs/_custom_/upernet/upernet_hr_18_test.py b/mmsegmentation/configs/_custom_/upernet/upernet_hr_18_test.py
new file mode 100644
index 0000000..e4b16a4
--- /dev/null
+++ b/mmsegmentation/configs/_custom_/upernet/upernet_hr_18_test.py
@@ -0,0 +1,94 @@
+_base_ = [
+    '../_base_/cleansed_xraydata2.py',
+    '../_base_/default_runtime.py', '../_base_/schedule_160k.py'
+]
+
+# model settings
+num_classes = 29
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+crop_size = (769, 769)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    size=crop_size,
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+
+model = dict(
+    type='EncoderDecoderWithoutArgmax',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://msra/hrnetv2_w18',
+    backbone=dict(
+        type='HRNet',
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        extra=dict(
+            stage1=dict(
+                num_modules=1,
+                num_branches=1,
+                block='BOTTLENECK',
+                num_blocks=(2, ),
+                num_channels=(64, )),
+            stage2=dict(
+                num_modules=1,
+                num_branches=2,
+                block='BASIC',
+                num_blocks=(2, 2),
+                num_channels=(18, 36)),
+            stage3=dict(
+                num_modules=4,
+                num_branches=3,
+                block='BASIC',
+                num_blocks=(2, 2, 2),
+                num_channels=(18, 36, 72)),
+            stage4=dict(
+                num_modules=3,
+                num_branches=4,
+                block='BASIC',
+                num_blocks=(2, 2, 2, 2),
+                num_channels=(18, 36, 72, 144)))),
+    decode_head=dict(
+        type='UPerHeadWithoutAccuracy',
+        in_channels=[18, 36, 72, 144],
+        in_index=[0, 1, 2, 3],
+        pool_scales=(1, 2, 3, 6),
+        channels=sum([18, 36, 72, 144]),
+        dropout_ratio=0.1,
+        num_classes=num_classes,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        threshold=0.5,
+        loss_decode=[
+            dict(type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
+            dict(type='DiceLoss', use_sigmoid=True, loss_weight=3.0)
+        ]
+        ),
+    auxiliary_head=dict(
+        type='FCNHeadWithoutAccuracy',
+        in_channels=[18, 36, 72, 144],
+        in_index=(0, 1, 2, 3),
+        channels=sum([18, 36, 72, 144]),
+        input_transform='resize_concat',
+        kernel_size=1,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=-1,
+        num_classes=num_classes,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=[
+            dict(type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.4),
+            dict(type='DiceLoss', use_sigmoid=True, loss_weight=1.0)
+        ]
+        ),
+    # model training and testing settings
+    
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+
+
+train_dataloader = dict(batch_size = 2)
+test_dataloader = _base_.val_dataloader
+test_evaluator = _base_.val_evaluator
\ No newline at end of file
diff --git a/mmsegmentation/mmseg/datasets/xray2.py b/mmsegmentation/mmseg/datasets/xray2.py
index 5be6e43..a4a2e85 100644
--- a/mmsegmentation/mmseg/datasets/xray2.py
+++ b/mmsegmentation/mmseg/datasets/xray2.py
@@ -23,7 +23,7 @@
 
 CLASS2IND = {v: i for i, v in enumerate(CLASSES)}
 IND2CLASS = {v: k for k, v in CLASS2IND.items()}
-val_fold_num = 2
+val_fold_num = 0
 
 
 @DATASETS.register_module()
@@ -79,8 +79,8 @@ def load_data_list(self):
         labelnames = []
         for i, (x, y) in enumerate(gkf.split(_filenames, ys, groups)):
             if self.is_train:
-                if i == val_fold_num:
-                    continue
+                # if i == val_fold_num:
+                #     continue
 
                 filenames += list(_filenames[y])
                 labelnames += list(_labelnames[y])
diff --git a/mmsegmentation/mmseg/models/segmentors/custom.py b/mmsegmentation/mmseg/models/segmentors/custom.py
index 2aafb33..a53b4a0 100644
--- a/mmsegmentation/mmseg/models/segmentors/custom.py
+++ b/mmsegmentation/mmseg/models/segmentors/custom.py
@@ -69,10 +69,11 @@ def postprocess_result(self,
             else:
                 i_seg_logits = seg_logits[i]
 
-            if self.module.decode_head.threshold:
-                threshold = self.module.decode_head.threshold
-            else:
-                threshold = 0.5
+            # if self.module.decode_head.threshold:
+            #     threshold = self.module.decode_head.threshold
+            # else:
+            #     threshold = 0.5
+            threshold = 0.45
             
             i_seg_logits = i_seg_logits.sigmoid()
             i_seg_pred = (i_seg_logits > threshold).to(i_seg_logits)

From ecdc41a30dbfebeb6912584dac73d0fe1529157e Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Fri, 29 Nov 2024 09:42:45 +0900
Subject: [PATCH 088/106] [Refactor]:change path to custom_inference.py

---
 custom_inference.py => mmsegmentation/custom_inference.py | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename custom_inference.py => mmsegmentation/custom_inference.py (100%)

diff --git a/custom_inference.py b/mmsegmentation/custom_inference.py
similarity index 100%
rename from custom_inference.py
rename to mmsegmentation/custom_inference.py

From 4dfee22faacd07b52a288d8f246181fd5356a61b Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Fri, 29 Nov 2024 09:59:40 +0900
Subject: [PATCH 089/106] [Refactor]: delete baseline code

---
 baseline_code.ipynb | 1160 -------------------------------------------
 1 file changed, 1160 deletions(-)
 delete mode 100644 baseline_code.ipynb

diff --git a/baseline_code.ipynb b/baseline_code.ipynb
deleted file mode 100644
index 9726ab2..0000000
--- a/baseline_code.ipynb
+++ /dev/null
@@ -1,1160 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "fe5f1ca7",
-   "metadata": {},
-   "source": [
-    "# Table of Contents\n",
-    "\n",
-    "1. [Imports & Global Constants](#Imports-&-Global-Constants)\n",
-    "<br>&emsp;- 학습에 필요한 라이브러리들을 임포트 하고 미션 안에서 이루어지는 학습 전반을 컨트롤 하기 위한 파라미터들을 설정합니다.\n",
-    "<br>\n",
-    "\n",
-    "2. [Check the Size of the Dataset](#Check-the-Size-of-the-Dataset)\n",
-    "<br>&emsp;- 학습에 사용될 데이터가 잘 준비되어있는지 확인합니다.\n",
-    "<br>\n",
-    "\n",
-    "3. [Define Dataset Class](#Define-Dataset-Class)\n",
-    "<br>&emsp;- 데이터를 원하는 형태로 불러오기 위한 Dataset 클래스를 정의하고, validation을 위한 데이터 스플릿을 진행합니다.\n",
-    "<br>\n",
-    "\n",
-    "4. [Check Data Sample](#Check-Data-Sample)\n",
-    "<br>&emsp;- 제공된 데이터가 어떤 모습인지 확인합니다.\n",
-    "<br>\n",
-    "\n",
-    "5. [Setup Dataloader](#Setup-Dataloader)\n",
-    "<br>&emsp;- 학습을 위해 데이터를 배치로 불러오기 위한 Dataloader를 만듭니다.\n",
-    "<br>\n",
-    "\n",
-    "6. [Define Functions for Training](#Define-Functions-for-Training)\n",
-    "<br>&emsp;- 학습을 도와주는 함수들을 정의합니다.\n",
-    "<br>\n",
-    "\n",
-    "7. [Training](#Training)\n",
-    "<br>&emsp;- 학습을 진행합니다.\n",
-    "<br>\n",
-    "\n",
-    "8. [Inference](#Inference)\n",
-    "<br>&emsp;- 인퍼런스에 필요한 함수들을 정의하고, 인퍼런스를 진행합니다.\n",
-    "<br>\n",
-    "\n",
-    "9. [Result Visualization](#Result-Visualization)\n",
-    "<br>&emsp;- 인퍼런스 결과를 확인해봅니다.\n",
-    "<br>\n",
-    "\n",
-    "10. [To CSV](#To-CSV)\n",
-    "<br>&emsp;- 인퍼런스 결과를 제출을 위한 포맷으로 변경합니다."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "2c2d2121",
-   "metadata": {},
-   "source": [
-    "# Imports & Global Constants"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a3907598-e3f4-4c30-b1fe-759870903ecf",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 노트북 실행에 필요한 라이브러리를 설치합니다\n",
-    "\n",
-    "# !pip install opencv-python-headless==4.10.0.84\n",
-    "# !pip install pandas==2.2.3\n",
-    "# !pip install -U scikit-learn==1.5.2\n",
-    "# !pip install albumentations==1.4.18\n",
-    "# !pip install matplotlib==3.9.2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c8295cb6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# python native\n",
-    "import os\n",
-    "import json\n",
-    "import random\n",
-    "import datetime\n",
-    "from functools import partial\n",
-    "\n",
-    "# external library\n",
-    "import cv2\n",
-    "import numpy as np\n",
-    "import pandas as pd\n",
-    "from tqdm.auto import tqdm\n",
-    "from sklearn.model_selection import GroupKFold\n",
-    "import albumentations as A\n",
-    "import time\n",
-    "from datetime import timedelta\n",
-    "\n",
-    "# torch\n",
-    "import torch\n",
-    "import torch.nn as nn\n",
-    "import torch.nn.functional as F\n",
-    "import torch.optim as optim\n",
-    "from torch.utils.data import Dataset, DataLoader\n",
-    "from torchvision import models\n",
-    "\n",
-    "# visualization\n",
-    "import matplotlib.pyplot as plt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "1d6746cc",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 데이터 경로를 입력하세요\n",
-    "\n",
-    "IMAGE_ROOT = \"/data/ephemeral/home/data/train/DCM\"\n",
-    "LABEL_ROOT = \"/data/ephemeral/home/data/train/outputs_json\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "819e163c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "CLASSES = [\n",
-    "    'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',\n",
-    "    'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',\n",
-    "    'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',\n",
-    "    'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',\n",
-    "    'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',\n",
-    "    'Triquetrum', 'Pisiform', 'Radius', 'Ulna',\n",
-    "]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3192cd81",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "CLASS2IND = {v: i for i, v in enumerate(CLASSES)}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "1aef86f9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "IND2CLASS = {v: k for k, v in CLASS2IND.items()}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cb199e3d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "TRAIN_BATCH_SIZE = 2\n",
-    "VALID_BATCH_SIZE = 4\n",
-    "LR = 2e-4\n",
-    "RANDOM_SEED = 2024\n",
-    "\n",
-    "NUM_EPOCHS = 50\n",
-    "VAL_EVERY = 2\n",
-    "\n",
-    "SAVED_DIR = \"/data/ephemeral/home/data/result\"\n",
-    "\n",
-    "if not os.path.exists(SAVED_DIR):                                    \n",
-    "    os.makedirs(SAVED_DIR)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "52cc2a79",
-   "metadata": {},
-   "source": [
-    "# Check the Size of the Dataset"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "93533655",
-   "metadata": {},
-   "source": [
-    "`IMAGE_ROOT` 아래에 있는 모든 폴더를 재귀적으로 순회하면서 확장자가 `.png`인 파일들을 찾습니다."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a0782493",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pngs = {\n",
-    "    os.path.relpath(os.path.join(root, fname), start=IMAGE_ROOT)\n",
-    "    for root, _dirs, files in os.walk(IMAGE_ROOT)\n",
-    "    for fname in files\n",
-    "    if os.path.splitext(fname)[1].lower() == \".png\"\n",
-    "}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "91a88b61",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "len(pngs)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d2247d10",
-   "metadata": {},
-   "source": [
-    "마찬가지로 `LABEL_ROOT` 아래에 있는 모든 폴더를 재귀적으로 순회하면서 확장자가 `.json`인 파일들을 찾습니다."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "be21a515",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "jsons = {\n",
-    "    os.path.relpath(os.path.join(root, fname), start=LABEL_ROOT)\n",
-    "    for root, _dirs, files in os.walk(LABEL_ROOT)\n",
-    "    for fname in files\n",
-    "    if os.path.splitext(fname)[1].lower() == \".json\"\n",
-    "}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "eb99fd10",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "len(jsons)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "653c3526",
-   "metadata": {},
-   "source": [
-    "모든 `.png` 파일에 대해 `.json` pair가 존재하는지 체크합니다. 파일명에서 확장자를 제거한 set을 생성하고 두 집합의 차집합의 크기가 0인지 확인합니다."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "51eba0f1",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "jsons_fn_prefix = {os.path.splitext(fname)[0] for fname in jsons}\n",
-    "pngs_fn_prefix = {os.path.splitext(fname)[0] for fname in pngs}\n",
-    "\n",
-    "assert len(jsons_fn_prefix - pngs_fn_prefix) == 0\n",
-    "assert len(pngs_fn_prefix - jsons_fn_prefix) == 0"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b13ee425",
-   "metadata": {},
-   "source": [
-    "모든 `.png` 파일에 대해 label이 존재하는 것을 확인했습니다. 이름 순으로 정렬해서 짝이 맞도록 합니다."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f589a513",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pngs = sorted(pngs)\n",
-    "jsons = sorted(jsons)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "662f69ee",
-   "metadata": {},
-   "source": [
-    "# Define Dataset Class"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "7b0d5bf7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class XRayDataset(Dataset):\n",
-    "    def __init__(self, is_train=True, transforms=None):\n",
-    "        _filenames = np.array(pngs)\n",
-    "        _labelnames = np.array(jsons)\n",
-    "        \n",
-    "        # split train-valid\n",
-    "        # 한 폴더 안에 한 인물의 양손에 대한 `.dcm` 파일이 존재하기 때문에\n",
-    "        # 폴더 이름을 그룹으로 해서 GroupKFold를 수행합니다.\n",
-    "        # 동일 인물의 손이 train, valid에 따로 들어가는 것을 방지합니다.\n",
-    "        groups = [os.path.dirname(fname) for fname in _filenames]\n",
-    "        \n",
-    "        # dummy label\n",
-    "        ys = [0 for fname in _filenames]\n",
-    "        \n",
-    "        # 전체 데이터의 20%를 validation data로 쓰기 위해 `n_splits`를\n",
-    "        # 5으로 설정하여 KFold를 수행합니다.\n",
-    "        gkf = GroupKFold(n_splits=5)\n",
-    "        \n",
-    "        filenames = []\n",
-    "        labelnames = []\n",
-    "        for i, (x, y) in enumerate(gkf.split(_filenames, ys, groups)):\n",
-    "            if is_train:\n",
-    "                # 0번을 validation dataset으로 사용합니다.\n",
-    "                if i == 0:\n",
-    "                    continue\n",
-    "                    \n",
-    "                filenames += list(_filenames[y])\n",
-    "                labelnames += list(_labelnames[y])\n",
-    "            \n",
-    "            else:\n",
-    "                filenames = list(_filenames[y])\n",
-    "                labelnames = list(_labelnames[y])\n",
-    "                \n",
-    "                # skip i > 0\n",
-    "                break\n",
-    "        \n",
-    "        self.filenames = filenames\n",
-    "        self.labelnames = labelnames\n",
-    "        self.is_train = is_train\n",
-    "        self.transforms = transforms\n",
-    "    \n",
-    "    def __len__(self):\n",
-    "        return len(self.filenames)\n",
-    "    \n",
-    "    def __getitem__(self, item):\n",
-    "        image_name = self.filenames[item]\n",
-    "        image_path = os.path.join(IMAGE_ROOT, image_name)\n",
-    "        \n",
-    "        image = cv2.imread(image_path)\n",
-    "        image = image / 255.\n",
-    "        \n",
-    "        label_name = self.labelnames[item]\n",
-    "        label_path = os.path.join(LABEL_ROOT, label_name)\n",
-    "        \n",
-    "        # (H, W, NC) 모양의 label을 생성합니다.\n",
-    "        label_shape = tuple(image.shape[:2]) + (len(CLASSES), )\n",
-    "        label = np.zeros(label_shape, dtype=np.uint8)\n",
-    "        \n",
-    "        # label 파일을 읽습니다.\n",
-    "        with open(label_path, \"r\") as f:\n",
-    "            annotations = json.load(f)\n",
-    "        annotations = annotations[\"annotations\"]\n",
-    "        \n",
-    "        # 클래스 별로 처리합니다.\n",
-    "        for ann in annotations:\n",
-    "            c = ann[\"label\"]\n",
-    "            class_ind = CLASS2IND[c]\n",
-    "            points = np.array(ann[\"points\"])\n",
-    "            \n",
-    "            # polygon 포맷을 dense한 mask 포맷으로 바꿉니다.\n",
-    "            class_label = np.zeros(image.shape[:2], dtype=np.uint8)\n",
-    "            cv2.fillPoly(class_label, [points], 1)\n",
-    "            label[..., class_ind] = class_label\n",
-    "        \n",
-    "        if self.transforms is not None:\n",
-    "            inputs = {\"image\": image, \"mask\": label} if self.is_train else {\"image\": image}\n",
-    "            result = self.transforms(**inputs)\n",
-    "            \n",
-    "            image = result[\"image\"]\n",
-    "            label = result[\"mask\"] if self.is_train else label\n",
-    "\n",
-    "        # to tenser will be done later\n",
-    "        image = image.transpose(2, 0, 1)    # channel first 포맷으로 변경합니다.\n",
-    "        label = label.transpose(2, 0, 1)\n",
-    "        \n",
-    "        image = torch.from_numpy(image).float()\n",
-    "        label = torch.from_numpy(label).float()\n",
-    "            \n",
-    "        return image, label"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "302e7742",
-   "metadata": {},
-   "source": [
-    "# Check Data Sample"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "89defc8c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 시각화를 위한 팔레트를 설정합니다.\n",
-    "PALETTE = [\n",
-    "    (220, 20, 60), (119, 11, 32), (0, 0, 142), (0, 0, 230), (106, 0, 228),\n",
-    "    (0, 60, 100), (0, 80, 100), (0, 0, 70), (0, 0, 192), (250, 170, 30),\n",
-    "    (100, 170, 30), (220, 220, 0), (175, 116, 175), (250, 0, 30), (165, 42, 42),\n",
-    "    (255, 77, 255), (0, 226, 252), (182, 182, 255), (0, 82, 0), (120, 166, 157),\n",
-    "    (110, 76, 0), (174, 57, 255), (199, 100, 0), (72, 0, 118), (255, 179, 240),\n",
-    "    (0, 125, 92), (209, 0, 151), (188, 208, 182), (0, 220, 176),\n",
-    "]\n",
-    "\n",
-    "# 시각화 함수입니다. 클래스가 2개 이상인 픽셀을 고려하지는 않습니다.\n",
-    "def label2rgb(label):\n",
-    "    image_size = label.shape[1:] + (3, )\n",
-    "    image = np.zeros(image_size, dtype=np.uint8)\n",
-    "    \n",
-    "    for i, class_label in enumerate(label):\n",
-    "        image[class_label == 1] = PALETTE[i]\n",
-    "        \n",
-    "    return image"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e1f1eb8a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "train_tf = A.Compose([\n",
-    "    A.Resize(1536, 1536),\n",
-    "    A.HorizontalFlip(p=0.3),\n",
-    "])\n",
-    "val_tf = A.Resize(1536, 1536)\n",
-    "# tf = A.Resize(1536, 1536)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f17abc75",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "train_dataset = XRayDataset(is_train=True, transforms=train_tf)\n",
-    "valid_dataset = XRayDataset(is_train=False, transforms=val_tf)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c193e92b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "image, label = train_dataset[146]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "5dd474b2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(image.shape, label.shape)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "bc100cf6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "len(train_dataset)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f9845fe3",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "fig, ax = plt.subplots(1, 2, figsize=(24, 12))\n",
-    "ax[0].imshow(image[0])    # color map 적용을 위해 channel 차원을 생략합니다.\n",
-    "ax[1].imshow(label2rgb(label))\n",
-    "\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "22480ad8",
-   "metadata": {},
-   "source": [
-    "# Setup Dataloader"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d5b43501",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "train_loader = DataLoader(\n",
-    "    dataset=train_dataset, \n",
-    "    batch_size=TRAIN_BATCH_SIZE,\n",
-    "    shuffle=True,\n",
-    "    num_workers=4,\n",
-    "    drop_last=True,\n",
-    ")\n",
-    "\n",
-    "# 주의: validation data는 이미지 크기가 크기 때문에 `num_wokers`는 커지면 메모리 에러가 발생할 수 있습니다.\n",
-    "valid_loader = DataLoader(\n",
-    "    dataset=valid_dataset, \n",
-    "    batch_size=VALID_BATCH_SIZE,\n",
-    "    shuffle=False,\n",
-    "    num_workers=1,\n",
-    "    drop_last=False\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "75925001",
-   "metadata": {},
-   "source": [
-    "# Define Functions for Training"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "687f29a3",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def dice_coef(y_true, y_pred):\n",
-    "    y_true_f = y_true.flatten(2)\n",
-    "    y_pred_f = y_pred.flatten(2)\n",
-    "    intersection = torch.sum(y_true_f * y_pred_f, -1)\n",
-    "    \n",
-    "    eps = 0.0001\n",
-    "    return (2. * intersection + eps) / (torch.sum(y_true_f, -1) + torch.sum(y_pred_f, -1) + eps)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "19be0316",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def save_model(model, file_name='best_model.pt'):\n",
-    "    output_path = os.path.join(SAVED_DIR, file_name)\n",
-    "    torch.save(model, output_path)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "dd22e901",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def set_seed():\n",
-    "    torch.manual_seed(RANDOM_SEED)\n",
-    "    torch.cuda.manual_seed(RANDOM_SEED)\n",
-    "    torch.cuda.manual_seed_all(RANDOM_SEED) # if use multi-GPU\n",
-    "    torch.backends.cudnn.deterministic = True\n",
-    "    torch.backends.cudnn.benchmark = False\n",
-    "    np.random.seed(RANDOM_SEED)\n",
-    "    random.seed(RANDOM_SEED)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "40c3a306",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def validation(epoch, model, data_loader, criterion, thr=0.5):\n",
-    "    print(f'Start validation #{epoch:2d}')\n",
-    "    set_seed()\n",
-    "    model.eval()\n",
-    "    \n",
-    "    dices = []\n",
-    "    model = model.cuda()\n",
-    "    with torch.no_grad():\n",
-    "        total_loss = 0\n",
-    "        cnt = 0\n",
-    "\n",
-    "        for step, (images, masks) in tqdm(enumerate(data_loader), total=len(data_loader)):\n",
-    "            images, masks = images.cuda(), masks.cuda()         \n",
-    "            \n",
-    "            # outputs = model(images)['out']\n",
-    "            outputs = model(images)\n",
-    "            \n",
-    "            output_h, output_w = outputs.size(-2), outputs.size(-1)\n",
-    "            mask_h, mask_w = masks.size(-2), masks.size(-1)\n",
-    "            \n",
-    "            # gt와 prediction의 크기가 다른 경우 prediction을 gt에 맞춰 interpolation 합니다.\n",
-    "            if output_h != mask_h or output_w != mask_w:\n",
-    "                outputs = F.interpolate(outputs, size=(mask_h, mask_w), mode=\"bilinear\")\n",
-    "            \n",
-    "            loss = criterion(outputs, masks)\n",
-    "            total_loss += loss\n",
-    "            cnt += 1\n",
-    "            \n",
-    "            outputs = torch.sigmoid(outputs)\n",
-    "            outputs = (outputs > thr).detach().cpu()\n",
-    "            masks = masks.detach().cpu()\n",
-    "            \n",
-    "            dice = dice_coef(outputs, masks)\n",
-    "            dices.append(dice)\n",
-    "\n",
-    "            # 텐서 삭제 및 메모리 캐시 해제\n",
-    "            del outputs, masks, dice\n",
-    "            \n",
-    "    dices = torch.cat(dices, 0)\n",
-    "    dices_per_class = torch.mean(dices, 0)\n",
-    "    dice_str = [\n",
-    "        f\"{c:<12}: {d.item():.4f}\"\n",
-    "        for c, d in zip(CLASSES, dices_per_class)\n",
-    "    ]\n",
-    "    dice_str = \"\\n\".join(dice_str)\n",
-    "    print(dice_str)\n",
-    "    \n",
-    "    avg_dice = torch.mean(dices_per_class).item()\n",
-    "    \n",
-    "    return avg_dice"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3acde59b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def train(model, data_loader, val_loader, criterion, optimizer):\n",
-    "    print(f'Start training..')\n",
-    "    set_seed()\n",
-    "    best_dice = 0.\n",
-    "\n",
-    "    # GradScaler를 사용해 Mixed Precision Training을 설정\n",
-    "    scaler = torch.cuda.amp.GradScaler(enabled=True)\n",
-    "    model = model.cuda()\n",
-    "    for epoch in range(NUM_EPOCHS):\n",
-    "        # 매 epoch마다 cache를 삭제하여 PyTorch의 메모리 누수를 방지\n",
-    "        torch.cuda.empty_cache()\n",
-    "        model.train()\n",
-    "        \n",
-    "        for step, (images, masks) in enumerate(data_loader):            \n",
-    "            # gpu 연산을 위해 device 할당합니다.\n",
-    "            images, masks = images.cuda(), masks.cuda()\n",
-    "            # model = model.cuda()\n",
-    "            \n",
-    "            # outputs = model(images)['out']\n",
-    "            # outputs = model(images)\n",
-    "            \n",
-    "            # loss를 계산합니다.\n",
-    "            # loss = criterion(outputs, masks)\n",
-    "            # optimizer.zero_grad()\n",
-    "            # loss.backward()\n",
-    "            # optimizer.step()\n",
-    "\n",
-    "            # 스케일된 loss를 사용해 backward 및 optimizer step\n",
-    "            optimizer.zero_grad()\n",
-    "            \n",
-    "            # Mixed Precision Training 적용\n",
-    "            with torch.cuda.amp.autocast():\n",
-    "                # outputs = model(images)['out']\n",
-    "                outputs = model(images)\n",
-    "                loss = criterion(outputs, masks)\n",
-    "            \n",
-    "            scaler.scale(loss).backward()\n",
-    "            scaler.step(optimizer)\n",
-    "            scaler.update()\n",
-    "            \n",
-    "            # step 주기에 따라 loss를 출력합니다.\n",
-    "            if (step + 1) % 25 == 0:\n",
-    "                print(\n",
-    "                    f'{datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")} | '\n",
-    "                    f'Epoch [{epoch+1}/{NUM_EPOCHS}], '\n",
-    "                    f'Step [{step+1}/{len(train_loader)}], '\n",
-    "                    f'Loss: {round(loss.item(),4)}'\n",
-    "                )\n",
-    "                \n",
-    "        # validation 주기에 따라 loss를 출력하고 best model을 저장합니다.\n",
-    "        if (epoch + 1) % VAL_EVERY == 0:\n",
-    "            dice = validation(epoch + 1, model, val_loader, criterion)\n",
-    "            \n",
-    "            if best_dice < dice:\n",
-    "                print(f\"Best performance at epoch: {epoch + 1}, {best_dice:.4f} -> {dice:.4f}\")\n",
-    "                print(f\"Save model in {SAVED_DIR}\")\n",
-    "                best_dice = dice\n",
-    "                save_model(model)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c10b856b",
-   "metadata": {},
-   "source": [
-    "# Training"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "73b106ab",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "model = models.segmentation.fcn_resnet101(pretrained=True)\n",
-    "\n",
-    "# output class 개수를 dataset에 맞도록 수정합니다.\n",
-    "model.classifier[4] = nn.Conv2d(512, len(CLASSES), kernel_size=1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "497da034",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import segmentation_models_pytorch as smp\n",
-    "\n",
-    "model = smp.UnetPlusPlus(\n",
-    "    encoder_name=\"tu-hrnet_w64\",\n",
-    "    encoder_weights=\"imagenet\",\n",
-    "    in_channels=3,\n",
-    "    classes=29\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "801e9a3a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Loss function을 정의합니다.\n",
-    "criterion = nn.BCEWithLogitsLoss()\n",
-    "\n",
-    "# Optimizer를 정의합니다.\n",
-    "optimizer = optim.Adam(params=model.parameters(), lr=LR, weight_decay=1e-6)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a11d1b92",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 시드를 설정합니다.\n",
-    "set_seed()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "7564c751",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "train(model, train_loader, valid_loader, criterion, optimizer)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "85f36ce9",
-   "metadata": {},
-   "source": [
-    "# Inference"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8b438c65",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "model = torch.load(os.path.join(SAVED_DIR, \"best_model.pt\"))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "da6dd353",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 테스트 데이터 경로를 입력하세요\n",
-    "\n",
-    "IMAGE_ROOT = \"/data/ephemeral/home/data/test/DCM\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "463d5c19",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pngs = {\n",
-    "    os.path.relpath(os.path.join(root, fname), start=IMAGE_ROOT)\n",
-    "    for root, _dirs, files in os.walk(IMAGE_ROOT)\n",
-    "    for fname in files\n",
-    "    if os.path.splitext(fname)[1].lower() == \".png\"\n",
-    "}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ecb5c065-b44b-4f82-ba6d-b41e3e7f6ad2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "len(pngs)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3b2794ea",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# mask map으로 나오는 인퍼런스 결과를 RLE로 인코딩 합니다.\n",
-    "\n",
-    "def encode_mask_to_rle(mask):\n",
-    "    '''\n",
-    "    mask: numpy array binary mask \n",
-    "    1 - mask \n",
-    "    0 - background\n",
-    "    Returns encoded run length \n",
-    "    '''\n",
-    "    pixels = mask.flatten()\n",
-    "    pixels = np.concatenate([[0], pixels, [0]])\n",
-    "    runs = np.where(pixels[1:] != pixels[:-1])[0] + 1\n",
-    "    runs[1::2] -= runs[::2]\n",
-    "    return ' '.join(str(x) for x in runs)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "1db55005",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# RLE로 인코딩된 결과를 mask map으로 복원합니다.\n",
-    "\n",
-    "def decode_rle_to_mask(rle, height, width):\n",
-    "    s = rle.split()\n",
-    "    starts, lengths = [np.asarray(x, dtype=int) for x in (s[0:][::2], s[1:][::2])]\n",
-    "    starts -= 1\n",
-    "    ends = starts + lengths\n",
-    "    img = np.zeros(height * width, dtype=np.uint8)\n",
-    "    \n",
-    "    for lo, hi in zip(starts, ends):\n",
-    "        img[lo:hi] = 1\n",
-    "    \n",
-    "    return img.reshape(height, width)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8e98506f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class XRayInferenceDataset(Dataset):\n",
-    "    def __init__(self, transforms=None):\n",
-    "        _filenames = pngs\n",
-    "        _filenames = np.array(sorted(_filenames))\n",
-    "        \n",
-    "        self.filenames = _filenames\n",
-    "        self.transforms = transforms\n",
-    "    \n",
-    "    def __len__(self):\n",
-    "        return len(self.filenames)\n",
-    "    \n",
-    "    def __getitem__(self, item):\n",
-    "        image_name = self.filenames[item]\n",
-    "        image_path = os.path.join(IMAGE_ROOT, image_name)\n",
-    "        \n",
-    "        image = cv2.imread(image_path)\n",
-    "        image = image / 255.\n",
-    "        \n",
-    "        if self.transforms is not None:\n",
-    "            inputs = {\"image\": image}\n",
-    "            result = self.transforms(**inputs)\n",
-    "            image = result[\"image\"]\n",
-    "\n",
-    "        # to tenser will be done later\n",
-    "        image = image.transpose(2, 0, 1)  \n",
-    "        \n",
-    "        image = torch.from_numpy(image).float()\n",
-    "            \n",
-    "        return image, image_name"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "112a73a3",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def test(model, data_loader, thr=0.5):\n",
-    "    model = model.cuda()\n",
-    "    model.eval()\n",
-    "\n",
-    "    rles = []\n",
-    "    filename_and_class = []\n",
-    "    with torch.no_grad():\n",
-    "        n_class = len(CLASSES)\n",
-    "\n",
-    "        for step, (images, image_names) in tqdm(enumerate(data_loader), total=len(data_loader)):\n",
-    "            images = images.cuda()    \n",
-    "            # outputs = model(images)['out']\n",
-    "            outputs = model(images)\n",
-    "            \n",
-    "            outputs = F.interpolate(outputs, size=(2048, 2048), mode=\"bilinear\")\n",
-    "            outputs = torch.sigmoid(outputs)\n",
-    "            outputs = (outputs > thr).detach().cpu().numpy()\n",
-    "            \n",
-    "            for output, image_name in zip(outputs, image_names):\n",
-    "                for c, segm in enumerate(output):\n",
-    "                    rle = encode_mask_to_rle(segm)\n",
-    "                    rles.append(rle)\n",
-    "                    filename_and_class.append(f\"{IND2CLASS[c]}_{image_name}\")\n",
-    "                    \n",
-    "    return rles, filename_and_class"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8011f0cd",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "tf = A.Resize(1536, 1536)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "bcb091af",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test_dataset = XRayInferenceDataset(transforms=tf)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "62aff8c2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test_loader = DataLoader(\n",
-    "    dataset=test_dataset, \n",
-    "    batch_size=2,\n",
-    "    shuffle=False,\n",
-    "    num_workers=2,\n",
-    "    drop_last=False\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "fa7c963b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "rles, filename_and_class = test(model, test_loader)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "28e9e8a2",
-   "metadata": {},
-   "source": [
-    "# Result Visualization"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "eeedc485",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "filename_and_class[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "faa6b4a2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "image = cv2.imread(os.path.join(IMAGE_ROOT, filename_and_class[0].split(\"_\")[1]))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "5997f748",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "preds = []\n",
-    "for rle in rles[:len(CLASSES)]:\n",
-    "    pred = decode_rle_to_mask(rle, height=2048, width=2048)\n",
-    "    preds.append(pred)\n",
-    "\n",
-    "preds = np.stack(preds, 0)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "679f5401",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "fig, ax = plt.subplots(1, 2, figsize=(24, 12))\n",
-    "ax[0].imshow(image) # remove channel dimension\n",
-    "ax[1].imshow(label2rgb(preds))\n",
-    "\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "65f9b574",
-   "metadata": {},
-   "source": [
-    "# To CSV"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e6c58f80",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "classes, filename = zip(*[x.split(\"_\") for x in filename_and_class])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "4f489c54",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "image_name = [os.path.basename(f) for f in filename]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a33cd628",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df = pd.DataFrame({\n",
-    "    \"image_name\": image_name,\n",
-    "    \"class\": classes,\n",
-    "    \"rle\": rles,\n",
-    "})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "9b8ddbe2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df.head(30)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "4e3829b6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df.to_csv(\"smp_unet++_hrnet_w64_re(1536).csv\", index=False)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3363ff1f",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "base",
-   "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.10.13"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

From ab49af2a05bd685a792d7207756ececeb1d4b803 Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Fri, 29 Nov 2024 10:24:24 +0900
Subject: [PATCH 090/106] [Refactor]:Delete mmsegmentation library code except
 for custom code

---
 mmsegmentation/.circleci/config.yml           |   34 -
 mmsegmentation/.circleci/docker/Dockerfile    |   12 -
 mmsegmentation/.circleci/test.yml             |  196 ---
 .../.dev_scripts/batch_test_list.py           |  133 --
 .../.dev_scripts/batch_train_list.txt         |   19 -
 .../.dev_scripts/benchmark_evaluation.sh      |   41 -
 .../.dev_scripts/benchmark_full_models.txt    |   57 -
 .../.dev_scripts/benchmark_inference.py       |  149 --
 .../.dev_scripts/benchmark_options.py         |   10 -
 .../.dev_scripts/benchmark_train.sh           |   40 -
 .../.dev_scripts/benchmark_train_models.txt   |   26 -
 mmsegmentation/.dev_scripts/check_urls.py     |  100 --
 .../gather_benchmark_evaluation_results.py    |   91 --
 .../gather_benchmark_train_results.py         |  100 --
 mmsegmentation/.dev_scripts/gather_models.py  |  213 ---
 .../generate_benchmark_evaluation_script.py   |  114 --
 .../generate_benchmark_train_script.py        |   91 --
 .../log_collector/example_config.py           |   18 -
 .../log_collector/log_collector.py            |  143 --
 .../.dev_scripts/log_collector/readme.md      |  144 --
 .../.dev_scripts/log_collector/utils.py       |   20 -
 .../.dev_scripts/update_model_index.py        |  301 ----
 .../.dev_scripts/upload_modelzoo.py           |   45 -
 mmsegmentation/.github/CODE_OF_CONDUCT.md     |   76 -
 mmsegmentation/.github/CONTRIBUTING.md        |   59 -
 .../.github/ISSUE_TEMPLATE/config.yml         |    6 -
 .../.github/ISSUE_TEMPLATE/error-report.md    |   48 -
 .../.github/ISSUE_TEMPLATE/feature_request.md |   21 -
 .../ISSUE_TEMPLATE/general_questions.md       |    7 -
 .../reimplementation_questions.md             |   69 -
 .../.github/pull_request_template.md          |   25 -
 mmsegmentation/.github/workflows/deploy.yml   |   26 -
 mmsegmentation/.gitignore                     |  120 --
 mmsegmentation/.owners.yml                    |    7 -
 mmsegmentation/.pre-commit-config.yaml        |   67 -
 mmsegmentation/CITATION.cff                   |    8 -
 mmsegmentation/LICENSE                        |  203 ---
 mmsegmentation/MANIFEST.in                    |    5 -
 mmsegmentation/README.md                      |  420 ------
 mmsegmentation/README_zh-CN.md                |  426 ------
 mmsegmentation/configs/ann/README.md          |   68 -
 ...nn_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 -
 ...ann_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 -
 ...nn_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...ann_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 -
 .../ann_r101-d8_4xb4-160k_ade20k-512x512.py   |    2 -
 .../ann_r101-d8_4xb4-20k_voc12aug-512x512.py  |    2 -
 .../ann_r101-d8_4xb4-40k_voc12aug-512x512.py  |    2 -
 .../ann_r101-d8_4xb4-80k_ade20k-512x512.py    |    2 -
 ...ann_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 -
 .../ann_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 -
 ...ann_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 -
 .../ann_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 -
 .../ann_r50-d8_4xb4-160k_ade20k-512x512.py    |   10 -
 .../ann_r50-d8_4xb4-20k_voc12aug-512x512.py   |   10 -
 .../ann_r50-d8_4xb4-40k_voc12aug-512x512.py   |   10 -
 .../ann/ann_r50-d8_4xb4-80k_ade20k-512x512.py |   10 -
 mmsegmentation/configs/ann/metafile.yaml      |  391 -----
 mmsegmentation/configs/apcnet/README.md       |   59 -
 ...et_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 -
 ...net_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 -
 ...et_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...net_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 -
 ...apcnet_r101-d8_4xb4-160k_ade20k-512x512.py |    2 -
 .../apcnet_r101-d8_4xb4-80k_ade20k-512x512.py |    2 -
 ...net_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 -
 ...cnet_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 -
 ...net_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 -
 ...cnet_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 -
 .../apcnet_r50-d8_4xb4-160k_ade20k-512x512.py |   10 -
 .../apcnet_r50-d8_4xb4-80k_ade20k-512x512.py  |   10 -
 mmsegmentation/configs/apcnet/metafile.yaml   |  296 ----
 mmsegmentation/configs/beit/README.md         |   85 --
 ...t-base_upernet_8xb2-160k_ade20k-640x640.py |   36 -
 ...ase_upernet_8xb2-160k_ade20k-640x640_ms.py |   16 -
 ...ge_upernet_8xb1-amp-160k_ade20k-640x640.py |   50 -
 ...upernet_8xb1-amp-160k_ade20k-640x640_ms.py |   16 -
 mmsegmentation/configs/beit/metafile.yaml     |   49 -
 mmsegmentation/configs/bisenetv1/README.md    |   64 -
 ...1k-pre_4xb4-160k_coco-stuff164k-512x512.py |    6 -
 ...01-d32_4xb4-160k_coco-stuff164k-512x512.py |   58 -
 ...in1k-pre_4xb4-160k_cityscapes-1024x1024.py |   29 -
 ...1k-pre_4xb4-160k_coco-stuff164k-512x512.py |   10 -
 ...in1k-pre_4xb8-160k_cityscapes-1024x1024.py |    4 -
 ..._r18-d32_4xb4-160k_cityscapes-1024x1024.py |   24 -
 ...18-d32_4xb4-160k_coco-stuff164k-512x512.py |   53 -
 ...in1k-pre_4xb4-160k_cityscapes-1024x1024.py |    7 -
 ...1k-pre_4xb4-160k_coco-stuff164k-512x512.py |    7 -
 ..._r50-d32_4xb4-160k_cityscapes-1024x1024.py |   55 -
 ...50-d32_4xb4-160k_coco-stuff164k-512x512.py |   58 -
 .../configs/bisenetv1/metafile.yaml           |  275 ----
 mmsegmentation/configs/bisenetv2/README.md    |   53 -
 ...etv2_fcn_4xb4-160k_cityscapes-1024x1024.py |   24 -
 ..._fcn_4xb4-amp-160k_cityscapes-1024x1024.py |    6 -
 ...fcn_4xb4-ohem-160k_cityscapes-1024x1024.py |   83 --
 ...etv2_fcn_4xb8-160k_cityscapes-1024x1024.py |   24 -
 .../configs/bisenetv2/metafile.yaml           |  114 --
 mmsegmentation/configs/ccnet/README.md        |   67 -
 ...et_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 -
 ...net_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 -
 ...et_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...net_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 -
 .../ccnet_r101-d8_4xb4-160k_ade20k-512x512.py |    2 -
 ...ccnet_r101-d8_4xb4-20k_voc12aug-512x512.py |    2 -
 ...ccnet_r101-d8_4xb4-40k_voc12aug-512x512.py |    2 -
 .../ccnet_r101-d8_4xb4-80k_ade20k-512x512.py  |    2 -
 ...net_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 -
 ...cnet_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 -
 ...net_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 -
 ...cnet_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 -
 .../ccnet_r50-d8_4xb4-160k_ade20k-512x512.py  |   10 -
 .../ccnet_r50-d8_4xb4-20k_voc12aug-512x512.py |   11 -
 .../ccnet_r50-d8_4xb4-40k_voc12aug-512x512.py |   11 -
 .../ccnet_r50-d8_4xb4-80k_ade20k-512x512.py   |   10 -
 mmsegmentation/configs/ccnet/metafile.yaml    |  391 -----
 mmsegmentation/configs/cgnet/README.md        |   46 -
 .../cgnet_fcn_4xb4-60k_cityscapes-680x680.py  |   59 -
 .../cgnet_fcn_4xb8-60k_cityscapes-512x1024.py |   38 -
 mmsegmentation/configs/cgnet/metafile.yaml    |   61 -
 mmsegmentation/configs/convnext/README.md     |   74 -
 ...se_upernet_8xb2-amp-160k_ade20k-512x512.py |   43 -
 ...se_upernet_8xb2-amp-160k_ade20k-640x640.py |   58 -
 ...ge_upernet_8xb2-amp-160k_ade20k-640x640.py |   58 -
 ...ll_upernet_8xb2-amp-160k_ade20k-512x512.py |   57 -
 ...ny_upernet_8xb2-amp-160k_ade20k-512x512.py |   57 -
 ...ge_upernet_8xb2-amp-160k_ade20k-640x640.py |   58 -
 mmsegmentation/configs/convnext/metafile.yaml |  145 --
 mmsegmentation/configs/danet/README.md        |   67 -
 ...et_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 -
 ...net_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 -
 ...et_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...net_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 -
 .../danet_r101-d8_4xb4-160k_ade20k-512x512.py |    2 -
 ...danet_r101-d8_4xb4-20k_voc12aug-512x512.py |    2 -
 ...danet_r101-d8_4xb4-40k_voc12aug-512x512.py |    2 -
 .../danet_r101-d8_4xb4-80k_ade20k-512x512.py  |    2 -
 ...net_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 -
 ...anet_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 -
 ...net_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 -
 ...anet_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 -
 .../danet_r50-d8_4xb4-160k_ade20k-512x512.py  |   10 -
 .../danet_r50-d8_4xb4-20k_voc12aug-512x512.py |   11 -
 .../danet_r50-d8_4xb4-40k_voc12aug-512x512.py |   11 -
 .../danet_r50-d8_4xb4-80k_ade20k-512x512.py   |   10 -
 mmsegmentation/configs/danet/metafile.yaml    |  387 -----
 mmsegmentation/configs/ddrnet/README.md       |   46 -
 ...in1k-pre_2xb6-120k_cityscapes-1024x1024.py |   93 --
 ...in1k-pre_2xb6-120k_cityscapes-1024x1024.py |   93 --
 mmsegmentation/configs/ddrnet/metafile.yaml   |   64 -
 mmsegmentation/configs/deeplabv3/README.md    |  118 --
 ...-d16-mg124_4xb2-40k_cityscapes-512x1024.py |   11 -
 ...-d16-mg124_4xb2-80k_cityscapes-512x1024.py |   11 -
 ...v3_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 -
 ...bv3_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 -
 ...v3_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...bv3_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 -
 ...101-d8_4xb2-amp-80k_cityscapes-512x1024.py |    7 -
 ...plabv3_r101-d8_4xb4-160k_ade20k-512x512.py |    2 -
 ...101-d8_4xb4-160k_coco-stuff164k-512x512.py |    2 -
 ..._r101-d8_4xb4-20k_coco-stuff10k-512x512.py |    2 -
 ...labv3_r101-d8_4xb4-20k_voc12aug-512x512.py |    2 -
 ...101-d8_4xb4-320k_coco-stuff164k-512x512.py |    2 -
 ..._r101-d8_4xb4-40k_coco-stuff10k-512x512.py |    2 -
 ...r101-d8_4xb4-40k_pascal-context-480x480.py |    2 -
 ...1-d8_4xb4-40k_pascal-context-59-480x480.py |    2 -
 ...labv3_r101-d8_4xb4-40k_voc12aug-512x512.py |    2 -
 ...eplabv3_r101-d8_4xb4-80k_ade20k-512x512.py |    2 -
 ...r101-d8_4xb4-80k_coco-stuff164k-512x512.py |    2 -
 ...r101-d8_4xb4-80k_pascal-context-480x480.py |    2 -
 ...1-d8_4xb4-80k_pascal-context-59-480x480.py |    2 -
 ...3_r101b-d8_4xb2-80k_cityscapes-512x1024.py |    4 -
 ...v3_r101b-d8_4xb2-80k_cityscapes-769x769.py |    4 -
 ...bv3_r18-d8_4xb2-80k_cityscapes-512x1024.py |    9 -
 ...abv3_r18-d8_4xb2-80k_cityscapes-769x769.py |    9 -
 ...v3_r18b-d8_4xb2-80k_cityscapes-512x1024.py |    9 -
 ...bv3_r18b-d8_4xb2-80k_cityscapes-769x769.py |    9 -
 ...bv3_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 -
 ...abv3_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 -
 ...bv3_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 -
 ...abv3_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 -
 ...eplabv3_r50-d8_4xb4-160k_ade20k-512x512.py |   10 -
 ...r50-d8_4xb4-160k_coco-stuff164k-512x512.py |   11 -
 ...3_r50-d8_4xb4-20k_coco-stuff10k-512x512.py |   11 -
 ...plabv3_r50-d8_4xb4-20k_voc12aug-512x512.py |   11 -
 ...r50-d8_4xb4-320k_coco-stuff164k-512x512.py |   11 -
 ...3_r50-d8_4xb4-40k_coco-stuff10k-512x512.py |   11 -
 ..._r50-d8_4xb4-40k_pascal-context-480x480.py |   14 -
 ...0-d8_4xb4-40k_pascal-context-59-480x480.py |   14 -
 ...plabv3_r50-d8_4xb4-40k_voc12aug-512x512.py |   11 -
 ...eeplabv3_r50-d8_4xb4-80k_ade20k-512x512.py |   10 -
 ..._r50-d8_4xb4-80k_coco-stuff164k-512x512.py |   11 -
 ..._r50-d8_4xb4-80k_pascal-context-480x480.py |   14 -
 ...0-d8_4xb4-80k_pascal-context-59-480x480.py |   14 -
 ...v3_r50b-d8_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...bv3_r50b-d8_4xb2-80k_cityscapes-769x769.py |    2 -
 .../configs/deeplabv3/metafile.yaml           |  985 -------------
 .../configs/deeplabv3plus/README.md           |  138 --
 ...-d16-mg124_4xb2-40k_cityscapes-512x1024.py |   11 -
 ...-d16-mg124_4xb2-80k_cityscapes-512x1024.py |   11 -
 ...us_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 -
 ...lus_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 -
 ...us_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...lus_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 -
 ...101-d8_4xb2-amp-80k_cityscapes-512x1024.py |    7 -
 ...v3plus_r101-d8_4xb4-160k_ade20k-512x512.py |    2 -
 ...3plus_r101-d8_4xb4-20k_voc12aug-512x512.py |    2 -
 ...r101-d8_4xb4-40k_pascal-context-480x480.py |    2 -
 ...1-d8_4xb4-40k_pascal-context-59-480x480.py |    2 -
 ...3plus_r101-d8_4xb4-40k_voc12aug-512x512.py |    2 -
 ...bv3plus_r101-d8_4xb4-80k_ade20k-512x512.py |    2 -
 ...bv3plus_r101-d8_4xb4-80k_loveda-512x512.py |    2 -
 ...r101-d8_4xb4-80k_pascal-context-480x480.py |    2 -
 ...1-d8_4xb4-80k_pascal-context-59-480x480.py |    2 -
 ...v3plus_r101-d8_4xb4-80k_potsdam-512x512.py |    2 -
 ...plus_r101-d8_4xb4-80k_vaihingen-512x512.py |    2 -
 ...s_r101b-d8_4xb2-80k_cityscapes-512x1024.py |    4 -
 ...us_r101b-d8_4xb2-80k_cityscapes-769x769.py |    4 -
 ...lus_r18-d8_4xb2-80k_cityscapes-512x1024.py |   11 -
 ...plus_r18-d8_4xb2-80k_cityscapes-769x769.py |   11 -
 ...labv3plus_r18-d8_4xb4-80k_isaid-896x896.py |   11 -
 ...abv3plus_r18-d8_4xb4-80k_loveda-512x512.py |   11 -
 ...bv3plus_r18-d8_4xb4-80k_potsdam-512x512.py |   11 -
 ...3plus_r18-d8_4xb4-80k_vaihingen-512x512.py |   11 -
 ...us_r18b-d8_4xb2-80k_cityscapes-512x1024.py |   11 -
 ...lus_r18b-d8_4xb2-80k_cityscapes-769x769.py |   11 -
 ...0-d8_4xb2-300k_mapillay_v1_65-1280x1280.py |   58 -
 ...lus_r50-d8_4xb2-40k_cityscapes-512x1024.py |    8 -
 ...plus_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 -
 ...lus_r50-d8_4xb2-80k_cityscapes-512x1024.py |    8 -
 ...plus_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 -
 ...bv3plus_r50-d8_4xb4-160k_ade20k-512x512.py |   10 -
 ...v3plus_r50-d8_4xb4-20k_voc12aug-512x512.py |   11 -
 ..._r50-d8_4xb4-40k_pascal-context-480x480.py |   14 -
 ...0-d8_4xb4-40k_pascal-context-59-480x480.py |   14 -
 ...v3plus_r50-d8_4xb4-40k_voc12aug-512x512.py |   11 -
 ...abv3plus_r50-d8_4xb4-80k_ade20k-512x512.py |   10 -
 ...labv3plus_r50-d8_4xb4-80k_isaid-896x896.py |   10 -
 ...abv3plus_r50-d8_4xb4-80k_loveda-512x512.py |   10 -
 ..._r50-d8_4xb4-80k_pascal-context-480x480.py |   14 -
 ...0-d8_4xb4-80k_pascal-context-59-480x480.py |   14 -
 ...bv3plus_r50-d8_4xb4-80k_potsdam-512x512.py |   11 -
 ...3plus_r50-d8_4xb4-80k_vaihingen-512x512.py |   11 -
 ...us_r50b-d8_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...lus_r50b-d8_4xb2-80k_cityscapes-769x769.py |    2 -
 .../configs/deeplabv3plus/metafile.yaml       | 1041 -------------
 mmsegmentation/configs/dmnet/README.md        |   59 -
 ...et_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 -
 ...net_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 -
 ...et_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...net_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 -
 .../dmnet_r101-d8_4xb4-160k_ade20k-512x512.py |    2 -
 .../dmnet_r101-d8_4xb4-80k_ade20k-512x512.py  |    2 -
 ...net_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 -
 ...mnet_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 -
 ...net_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 -
 ...mnet_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 -
 .../dmnet_r50-d8_4xb4-160k_ade20k-512x512.py  |   10 -
 .../dmnet_r50-d8_4xb4-80k_ade20k-512x512.py   |   10 -
 mmsegmentation/configs/dmnet/metafile.yaml    |  296 ----
 mmsegmentation/configs/dnlnet/README.md       |   62 -
 ...nl_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 -
 ...dnl_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 -
 ...nl_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...dnl_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 -
 .../dnl_r101-d8_4xb4-160k_ade20k-512x512.py   |    2 -
 .../dnl_r101-d8_4xb4-80k_ade20k-512x512.py    |    2 -
 ...dnl_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 -
 .../dnl_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 -
 ...dnl_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 -
 .../dnl_r50-d8_4xb2-80k_cityscapes-769x769.py |   16 -
 .../dnl_r50-d8_4xb4-160k_ade20k-512x512.py    |   10 -
 .../dnl_r50-d8_4xb4-80k_ade20k-512x512.py     |   10 -
 mmsegmentation/configs/dnlnet/metafile.yaml   |  292 ----
 mmsegmentation/configs/dpt/README.md          |   67 -
 .../dpt_vit-b16_8xb2-160k_ade20k-512x512.py   |   39 -
 mmsegmentation/configs/dpt/metafile.yaml      |   37 -
 mmsegmentation/configs/dsdl/README.md         |  103 --
 mmsegmentation/configs/dsdl/cityscapes.py     |   70 -
 mmsegmentation/configs/dsdl/voc.py            |   65 -
 mmsegmentation/configs/emanet/README.md       |   46 -
 ...et_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...net_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 -
 ...net_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 -
 ...anet_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 -
 mmsegmentation/configs/emanet/metafile.yaml   |  109 --
 mmsegmentation/configs/encnet/README.md       |   59 -
 ...et_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 -
 ...net_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 -
 ...et_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...net_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 -
 ...encnet_r101-d8_4xb4-160k_ade20k-512x512.py |    2 -
 ...ncnet_r101-d8_4xb4-20k_voc12aug-512x512.py |    2 -
 ...ncnet_r101-d8_4xb4-40k_voc12aug-512x512.py |    2 -
 .../encnet_r101-d8_4xb4-80k_ade20k-512x512.py |    2 -
 ...net_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 -
 ...cnet_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 -
 ...net_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 -
 ...cnet_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 -
 .../encnet_r50-d8_4xb4-160k_ade20k-512x512.py |   10 -
 ...encnet_r50-d8_4xb4-20k_voc12aug-512x512.py |   11 -
 ...encnet_r50-d8_4xb4-40k_voc12aug-512x512.py |   11 -
 .../encnet_r50-d8_4xb4-80k_ade20k-512x512.py  |   10 -
 .../encnet_r50s-d8_4xb4-80k_ade20k-512x512.py |   11 -
 mmsegmentation/configs/encnet/metafile.yaml   |  296 ----
 mmsegmentation/configs/erfnet/README.md       |   54 -
 ...rfnet_fcn_4xb4-160k_cityscapes-512x1024.py |   10 -
 mmsegmentation/configs/erfnet/metafile.yaml   |   37 -
 mmsegmentation/configs/fastfcn/README.md      |   63 -
 ...2_jpu_aspp_4xb2-80k_cityscapes-512x1024.py |   20 -
 ...0-d32_jpu_aspp_4xb4-160k_ade20k-512x512.py |   20 -
 ...50-d32_jpu_aspp_4xb4-80k_ade20k-512x512.py |   20 -
 ...2_jpu_aspp_4xb4-80k_cityscapes-512x1024.py |    5 -
 ...32_jpu_enc_4xb2-80k_cityscapes-512x1024.py |   24 -
 ...50-d32_jpu_enc_4xb4-160k_ade20k-512x512.py |   24 -
 ...r50-d32_jpu_enc_4xb4-80k_ade20k-512x512.py |   24 -
 ...32_jpu_enc_4xb4-80k_cityscapes-512x1024.py |    5 -
 ...32_jpu_psp_4xb2-80k_cityscapes-512x1024.py |    8 -
 ...50-d32_jpu_psp_4xb4-160k_ade20k-512x512.py |   11 -
 ...r50-d32_jpu_psp_4xb4-80k_ade20k-512x512.py |   11 -
 ...32_jpu_psp_4xb4-80k_cityscapes-512x1024.py |   11 -
 mmsegmentation/configs/fastfcn/metafile.yaml  |  311 ----
 mmsegmentation/configs/fastscnn/README.md     |   42 -
 ...fast_scnn_8xb4-160k_cityscapes-512x1024.py |   15 -
 mmsegmentation/configs/fastscnn/metafile.yaml |   37 -
 mmsegmentation/configs/fcn/README.md          |  111 --
 ...6_r101-d16_4xb2-40k_cityscapes-512x1024.py |    2 -
 ...d6_r101-d16_4xb2-40k_cityscapes-769x769.py |    2 -
 ...6_r101-d16_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...d6_r101-d16_4xb2-80k_cityscapes-769x769.py |    2 -
 ..._r101b-d16_4xb2-80k_cityscapes-512x1024.py |    4 -
 ...6_r101b-d16_4xb2-80k_cityscapes-769x769.py |    4 -
 ...d6_r50-d16_4xb2-40k_cityscapes-512x1024.py |   11 -
 ...-d6_r50-d16_4xb2-40k_cityscapes-769x769.py |   13 -
 ...d6_r50-d16_4xb2-80k_cityscapes-512x1024.py |   11 -
 ...-d6_r50-d16_4xb2-80k_cityscapes-769x769.py |   13 -
 ...6_r50b-d16_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...d6_r50b-d16_4xb2-80k_cityscapes-769x769.py |    2 -
 ...cn_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 -
 ...fcn_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 -
 ...cn_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...fcn_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 -
 ...101-d8_4xb2-amp-80k_cityscapes-512x1024.py |    6 -
 .../fcn_r101-d8_4xb4-160k_ade20k-512x512.py   |    2 -
 .../fcn_r101-d8_4xb4-20k_voc12aug-512x512.py  |    2 -
 ...r101-d8_4xb4-40k_pascal-context-480x480.py |    2 -
 ...1-d8_4xb4-40k_pascal-context-59-480x480.py |    2 -
 .../fcn_r101-d8_4xb4-40k_voc12aug-512x512.py  |    2 -
 .../fcn_r101-d8_4xb4-80k_ade20k-512x512.py    |    2 -
 ...r101-d8_4xb4-80k_pascal-context-480x480.py |    2 -
 ...1-d8_4xb4-80k_pascal-context-59-480x480.py |    2 -
 ...n_r101b-d8_4xb2-80k_cityscapes-512x1024.py |    4 -
 ...cn_r101b-d8_4xb2-80k_cityscapes-769x769.py |    4 -
 ...fcn_r18-d8_4xb2-80k_cityscapes-512x1024.py |    9 -
 .../fcn_r18-d8_4xb2-80k_cityscapes-769x769.py |    9 -
 ...cn_r18b-d8_4xb2-80k_cityscapes-512x1024.py |    9 -
 ...fcn_r18b-d8_4xb2-80k_cityscapes-769x769.py |    9 -
 ...fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 -
 .../fcn_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 -
 ...fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 -
 .../fcn_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 -
 .../fcn_r50-d8_4xb4-160k_ade20k-512x512.py    |   10 -
 .../fcn_r50-d8_4xb4-20k_voc12aug-512x512.py   |   10 -
 ..._r50-d8_4xb4-40k_pascal-context-480x480.py |   13 -
 ...0-d8_4xb4-40k_pascal-context-59-480x480.py |   14 -
 .../fcn_r50-d8_4xb4-40k_voc12aug-512x512.py   |   10 -
 .../fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py |   10 -
 ..._r50-d8_4xb4-80k_pascal-context-480x480.py |   13 -
 ...0-d8_4xb4-80k_pascal-context-59-480x480.py |   14 -
 ...cn_r50b-d8_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...fcn_r50b-d8_4xb2-80k_cityscapes-769x769.py |    2 -
 mmsegmentation/configs/fcn/metafile.yaml      |  997 -------------
 mmsegmentation/configs/gcnet/README.md        |   68 -
 ...et_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 -
 ...net_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 -
 ...et_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...net_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 -
 .../gcnet_r101-d8_4xb4-160k_ade20k-512x512.py |    2 -
 ...gcnet_r101-d8_4xb4-20k_voc12aug-512x512.py |    2 -
 ...gcnet_r101-d8_4xb4-40k_voc12aug-512x512.py |    2 -
 .../gcnet_r101-d8_4xb4-80k_ade20k-512x512.py  |    2 -
 ...net_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 -
 ...cnet_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 -
 ...net_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 -
 ...cnet_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 -
 .../gcnet_r50-d8_4xb4-160k_ade20k-512x512.py  |   10 -
 .../gcnet_r50-d8_4xb4-20k_voc12aug-512x512.py |   11 -
 .../gcnet_r50-d8_4xb4-40k_voc12aug-512x512.py |   11 -
 .../gcnet_r50-d8_4xb4-80k_ade20k-512x512.py   |   10 -
 mmsegmentation/configs/gcnet/metafile.yaml    |  391 -----
 mmsegmentation/configs/hrnet/README.md        |  122 --
 .../fcn_hr18_4xb2-160k_cityscapes-512x1024.py |    7 -
 .../fcn_hr18_4xb2-40k_cityscapes-512x1024.py  |    7 -
 .../fcn_hr18_4xb2-80k_cityscapes-512x1024.py  |    7 -
 .../fcn_hr18_4xb4-160k_ade20k-512x512.py      |    8 -
 .../fcn_hr18_4xb4-20k_voc12aug-512x512.py     |    8 -
 ...cn_hr18_4xb4-40k_pascal-context-480x480.py |   12 -
 ...hr18_4xb4-40k_pascal-context-59-480x480.py |   12 -
 .../fcn_hr18_4xb4-40k_voc12aug-512x512.py     |    8 -
 .../hrnet/fcn_hr18_4xb4-80k_ade20k-512x512.py |    8 -
 .../hrnet/fcn_hr18_4xb4-80k_isaid-896x896.py  |    8 -
 .../hrnet/fcn_hr18_4xb4-80k_loveda-512x512.py |    8 -
 ...cn_hr18_4xb4-80k_pascal-context-480x480.py |   12 -
 ...hr18_4xb4-80k_pascal-context-59-480x480.py |   12 -
 .../fcn_hr18_4xb4-80k_potsdam-512x512.py      |    8 -
 .../fcn_hr18_4xb4-80k_vaihingen-512x512.py    |    8 -
 ...fcn_hr18s_4xb2-160k_cityscapes-512x1024.py |    9 -
 .../fcn_hr18s_4xb2-40k_cityscapes-512x1024.py |    9 -
 .../fcn_hr18s_4xb2-80k_cityscapes-512x1024.py |    9 -
 .../fcn_hr18s_4xb4-160k_ade20k-512x512.py     |    9 -
 .../fcn_hr18s_4xb4-20k_voc12aug-512x512.py    |    9 -
 ...n_hr18s_4xb4-40k_pascal-context-480x480.py |    9 -
 ...r18s_4xb4-40k_pascal-context-59-480x480.py |    9 -
 .../fcn_hr18s_4xb4-40k_voc12aug-512x512.py    |    9 -
 .../fcn_hr18s_4xb4-80k_ade20k-512x512.py      |    9 -
 .../hrnet/fcn_hr18s_4xb4-80k_isaid-896x896.py |    9 -
 .../fcn_hr18s_4xb4-80k_loveda-512x512.py      |    9 -
 ...n_hr18s_4xb4-80k_pascal-context-480x480.py |    9 -
 ...r18s_4xb4-80k_pascal-context-59-480x480.py |    9 -
 .../fcn_hr18s_4xb4-80k_potsdam-512x512.py     |    9 -
 .../fcn_hr18s_4xb4-80k_vaihingen-512x512.py   |    9 -
 .../fcn_hr48_4xb2-160k_cityscapes-512x1024.py |   10 -
 .../fcn_hr48_4xb2-40k_cityscapes-512x1024.py  |   10 -
 .../fcn_hr48_4xb2-80k_cityscapes-512x1024.py  |   10 -
 .../fcn_hr48_4xb4-160k_ade20k-512x512.py      |   10 -
 .../fcn_hr48_4xb4-20k_voc12aug-512x512.py     |   10 -
 ...cn_hr48_4xb4-40k_pascal-context-480x480.py |   10 -
 ...hr48_4xb4-40k_pascal-context-59-480x480.py |   10 -
 .../fcn_hr48_4xb4-40k_voc12aug-512x512.py     |   10 -
 .../hrnet/fcn_hr48_4xb4-80k_ade20k-512x512.py |   10 -
 .../hrnet/fcn_hr48_4xb4-80k_isaid-896x896.py  |   10 -
 .../hrnet/fcn_hr48_4xb4-80k_loveda-512x512.py |   10 -
 ...cn_hr48_4xb4-80k_pascal-context-480x480.py |   10 -
 ...hr48_4xb4-80k_pascal-context-59-480x480.py |   10 -
 .../fcn_hr48_4xb4-80k_potsdam-512x512.py      |   10 -
 .../fcn_hr48_4xb4-80k_vaihingen-512x512.py    |   10 -
 mmsegmentation/configs/hrnet/metafile.yaml    |  874 -----------
 mmsegmentation/configs/icnet/README.md        |   56 -
 ...8-in1k-pre_4xb2-160k_cityscapes-832x832.py |    7 -
 ...d8-in1k-pre_4xb2-80k_cityscapes-832x832.py |    7 -
 ...et_r101-d8_4xb2-160k_cityscapes-832x832.py |    2 -
 ...net_r101-d8_4xb2-80k_cityscapes-832x832.py |    2 -
 ...8-in1k-pre_4xb2-160k_cityscapes-832x832.py |    8 -
 ...d8-in1k-pre_4xb2-80k_cityscapes-832x832.py |    8 -
 ...net_r18-d8_4xb2-160k_cityscapes-832x832.py |    3 -
 ...cnet_r18-d8_4xb2-80k_cityscapes-832x832.py |    3 -
 ...8-in1k-pre_4xb2-160k_cityscapes-832x832.py |    6 -
 ...d8-in1k-pre_4xb2-80k_cityscapes-832x832.py |    6 -
 ...net_r50-d8_4xb2-160k_cityscapes-832x832.py |    8 -
 ...cnet_r50-d8_4xb2-80k_cityscapes-832x832.py |    8 -
 mmsegmentation/configs/icnet/metafile.yaml    |  298 ----
 mmsegmentation/configs/isanet/README.md       |   80 -
 ...et_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 -
 ...net_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 -
 ...et_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...net_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 -
 ...isanet_r101-d8_4xb4-160k_ade20k-512x512.py |    2 -
 ...sanet_r101-d8_4xb4-20k_voc12aug-512x512.py |    2 -
 ...sanet_r101-d8_4xb4-40k_voc12aug-512x512.py |    2 -
 .../isanet_r101-d8_4xb4-80k_ade20k-512x512.py |    2 -
 ...net_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 -
 ...anet_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 -
 ...net_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 -
 ...anet_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 -
 .../isanet_r50-d8_4xb4-160k_ade20k-512x512.py |   10 -
 ...isanet_r50-d8_4xb4-20k_voc12aug-512x512.py |   11 -
 ...isanet_r50-d8_4xb4-40k_voc12aug-512x512.py |   11 -
 .../isanet_r50-d8_4xb4-80k_ade20k-512x512.py  |   10 -
 mmsegmentation/configs/isanet/metafile.yaml   |  399 -----
 mmsegmentation/configs/knet/README.md         |   52 -
 ...deeplabv3_8xb2-adamw-80k_ade20k-512x512.py |  111 --
 ...50-d8_fcn_8xb2-adamw-80k_ade20k-512x512.py |  112 --
 ...d8_pspnet_8xb2-adamw-80k_ade20k-512x512.py |  110 --
 ...8_upernet_8xb2-adamw-80k_ade20k-512x512.py |  111 --
 ...l_upernet_8xb2-adamw-80k_ade20k-512x512.py |   21 -
 ...l_upernet_8xb2-adamw-80k_ade20k-640x640.py |   57 -
 ...t_upernet_8xb2-adamw-80k_ade20k-512x512.py |   63 -
 mmsegmentation/configs/knet/metafile.yaml     |  188 ---
 mmsegmentation/configs/mae/README.md          |   82 --
 ...upernet_8xb2-amp-160k_ade20k-512x512-ms.py |   16 -
 ...se_upernet_8xb2-amp-160k_ade20k-512x512.py |   54 -
 mmsegmentation/configs/mae/metafile.yaml      |   25 -
 mmsegmentation/configs/mask2former/README.md  |   74 -
 ...sk2former_r101_8xb2-160k_ade20k-512x512.py |    7 -
 ...ormer_r101_8xb2-90k_cityscapes-512x1024.py |    7 -
 ...ask2former_r50_8xb2-160k_ade20k-512x512.py |  200 ---
 ...former_r50_8xb2-90k_cityscapes-512x1024.py |  197 ---
 ...1k-384x384-pre_8xb2-160k_ade20k-640x640.py |  229 ---
 ...2k-384x384-pre_8xb2-160k_ade20k-640x640.py |    5 -
 ...84x384-pre_8xb2-90k_cityscapes-512x1024.py |   42 -
 ...2k-384x384-pre_8xb2-160k_ade20k-640x640.py |    9 -
 ...84x384-pre_8xb2-90k_cityscapes-512x1024.py |   42 -
 ...2former_swin-s_8xb2-160k_ade20k-512x512.py |   37 -
 ...mer_swin-s_8xb2-90k_cityscapes-512x1024.py |   37 -
 ...2former_swin-t_8xb2-160k_ade20k-512x512.py |   52 -
 ...mer_swin-t_8xb2-90k_cityscapes-512x1024.py |   52 -
 .../configs/mask2former/metafile.yaml         |  314 ----
 mmsegmentation/configs/maskformer/README.md   |   62 -
 ...ormer_r101-d32_8xb2-160k_ade20k-512x512.py |    7 -
 ...former_r50-d32_8xb2-160k_ade20k-512x512.py |  141 --
 ...swin-s_upernet_8xb2-160k_ade20k-512x512.py |   79 -
 ...swin-t_upernet_8xb2-160k_ade20k-512x512.py |   81 -
 .../configs/maskformer/metafile.yaml          |  111 --
 mmsegmentation/configs/mobilenet_v2/README.md |   56 -
 .../configs/mobilenet_v2/metafile.yaml        |  186 ---
 ..._deeplabv3_4xb2-80k_cityscapes-512x1024.py |   13 -
 ...2-d8_deeplabv3_4xb4-160k_ade20k-512x512.py |   13 -
 ...plabv3plus_4xb2-80k_cityscapes-512x1024.py |   15 -
 ..._deeplabv3plus_4xb4-160k_ade20k-512x512.py |   13 -
 ...-v2-d8_fcn_4xb2-80k_cityscapes-512x1024.py |   13 -
 ...enet-v2-d8_fcn_4xb4-160k_ade20k-512x512.py |   13 -
 ...-d8_pspnet_4xb2-80k_cityscapes-512x1024.py |   13 -
 ...t-v2-d8_pspnet_4xb4-160k_ade20k-512x512.py |   13 -
 mmsegmentation/configs/mobilenet_v3/README.md |   50 -
 .../configs/mobilenet_v3/metafile.yaml        |  109 --
 ...-s_lraspp_4xb4-320k_cityscapes-512x1024.py |   23 -
 ...-s_lraspp_4xb4-320k_cityscapes-512x1024.py |   22 -
 ...ch_lraspp_4xb4-320k_cityscapes-512x1024.py |   13 -
 ...d8_lraspp_4xb4-320k_cityscapes-512x1024.py |   16 -
 mmsegmentation/configs/nonlocal_net/README.md |   68 -
 .../configs/nonlocal_net/metafile.yaml        |  387 -----
 ...al_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 -
 ...cal_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 -
 ...al_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...cal_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 -
 ...nlocal_r101-d8_4xb4-160k_ade20k-512x512.py |    2 -
 ...local_r101-d8_4xb4-20k_voc12aug-512x512.py |    2 -
 ...local_r101-d8_4xb4-40k_voc12aug-512x512.py |    2 -
 ...onlocal_r101-d8_4xb4-80k_ade20k-512x512.py |    2 -
 ...cal_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 -
 ...ocal_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 -
 ...cal_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 -
 ...ocal_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 -
 ...onlocal_r50-d8_4xb4-160k_ade20k-512x512.py |   10 -
 ...nlocal_r50-d8_4xb4-20k_voc12aug-512x512.py |   11 -
 ...nlocal_r50-d8_4xb4-40k_voc12aug-512x512.py |   11 -
 ...nonlocal_r50-d8_4xb4-80k_ade20k-512x512.py |   10 -
 mmsegmentation/configs/ocrnet/README.md       |   89 --
 mmsegmentation/configs/ocrnet/metafile.yaml   |  577 --------
 ...rnet_hr18_4xb2-160k_cityscapes-512x1024.py |    7 -
 ...crnet_hr18_4xb2-40k_cityscapes-512x1024.py |    7 -
 ...crnet_hr18_4xb2-80k_cityscapes-512x1024.py |    7 -
 .../ocrnet_hr18_4xb4-160k_ade20k-512x512.py   |   39 -
 .../ocrnet_hr18_4xb4-20k_voc12aug-512x512.py  |   40 -
 .../ocrnet_hr18_4xb4-40k_voc12aug-512x512.py  |   40 -
 .../ocrnet_hr18_4xb4-80k_ade20k-512x512.py    |   39 -
 ...net_hr18s_4xb2-160k_cityscapes-512x1024.py |    9 -
 ...rnet_hr18s_4xb2-40k_cityscapes-512x1024.py |    9 -
 ...rnet_hr18s_4xb2-80k_cityscapes-512x1024.py |    9 -
 .../ocrnet_hr18s_4xb4-160k_ade20k-512x512.py  |    9 -
 .../ocrnet_hr18s_4xb4-20k_voc12aug-512x512.py |    9 -
 .../ocrnet_hr18s_4xb4-40k_voc12aug-512x512.py |    9 -
 .../ocrnet_hr18s_4xb4-80k_ade20k-512x512.py   |    9 -
 ...rnet_hr48_4xb2-160k_cityscapes-512x1024.py |   39 -
 ...crnet_hr48_4xb2-40k_cityscapes-512x1024.py |   39 -
 ...crnet_hr48_4xb2-80k_cityscapes-512x1024.py |   39 -
 .../ocrnet_hr48_4xb4-160k_ade20k-512x512.py   |   39 -
 .../ocrnet_hr48_4xb4-20k_voc12aug-512x512.py  |   39 -
 .../ocrnet_hr48_4xb4-40k_voc12aug-512x512.py  |   39 -
 .../ocrnet_hr48_4xb4-80k_ade20k-512x512.py    |   39 -
 ...et_r101-d8_4xb2-40k_cityscapes-512x1024.py |   10 -
 ...et_r101-d8_8xb2-40k_cityscapes-512x1024.py |   21 -
 ...et_r101-d8_8xb2-80k_cityscapes-512x1024.py |   21 -
 mmsegmentation/configs/pidnet/README.md       |   50 -
 mmsegmentation/configs/pidnet/metafile.yaml   |   85 --
 ...pidnet-l_2xb6-120k_1024x1024-cityscapes.py |   10 -
 ...pidnet-m_2xb6-120k_1024x1024-cityscapes.py |    5 -
 ...pidnet-s_2xb6-120k_1024x1024-cityscapes.py |  113 --
 mmsegmentation/configs/point_rend/README.md   |   51 -
 .../configs/point_rend/metafile.yaml          |  110 --
 ...trend_r101_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...pointrend_r101_4xb4-160k_ade20k-512x512.py |    2 -
 ...ntrend_r50_4xb2-80k_cityscapes-512x1024.py |   18 -
 .../pointrend_r50_4xb4-160k_ade20k-512x512.py |   46 -
 mmsegmentation/configs/poolformer/README.md   |   65 -
 ..._poolformer_m36_8xb4-40k_ade20k-512x512.py |   11 -
 ..._poolformer_m48_8xb4-40k_ade20k-512x512.py |   11 -
 ..._poolformer_s12_8xb4-40k_ade20k-512x512.py |   91 --
 ..._poolformer_s24_8xb4-40k_ade20k-512x512.py |    9 -
 ...n_poolformer_s36_8x4_512x512_40k_ade20k.py |   10 -
 .../configs/poolformer/metafile.yaml          |  116 --
 mmsegmentation/configs/psanet/README.md       |   68 -
 mmsegmentation/configs/psanet/metafile.yaml   |  391 -----
 ...et_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 -
 ...net_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 -
 ...et_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...net_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 -
 ...psanet_r101-d8_4xb4-160k_ade20k-512x512.py |    2 -
 ...sanet_r101-d8_4xb4-20k_voc12aug-512x512.py |    2 -
 ...sanet_r101-d8_4xb4-40k_voc12aug-512x512.py |    2 -
 .../psanet_r101-d8_4xb4-80k_ade20k-512x512.py |    2 -
 ...net_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 -
 ...anet_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 -
 ...net_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 -
 ...anet_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 -
 .../psanet_r50-d8_4xb4-160k_ade20k-512x512.py |   10 -
 ...psanet_r50-d8_4xb4-20k_voc12aug-512x512.py |   11 -
 ...psanet_r50-d8_4xb4-40k_voc12aug-512x512.py |   11 -
 .../psanet_r50-d8_4xb4-80k_ade20k-512x512.py  |   10 -
 mmsegmentation/configs/pspnet/README.md       |  182 ---
 mmsegmentation/configs/pspnet/metafile.yaml   | 1303 -----------------
 ...et_r101-d8_4xb2-40k_cityscapes-512x1024.py |    2 -
 ...tyscapes-512x1024_dark-zurich-1920x1080.py |    2 -
 ...scapes-512x1024_night-driving-1920x1080.py |    2 -
 ...net_r101-d8_4xb2-40k_cityscapes-769x769.py |    2 -
 ...et_r101-d8_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...net_r101-d8_4xb2-80k_cityscapes-769x769.py |    2 -
 ...101-d8_4xb2-amp-80k_cityscapes-512x1024.py |    6 -
 ...pspnet_r101-d8_4xb4-160k_ade20k-512x512.py |    2 -
 ...101-d8_4xb4-160k_coco-stuff164k-512x512.py |    2 -
 ..._r101-d8_4xb4-20k_coco-stuff10k-512x512.py |    2 -
 ...spnet_r101-d8_4xb4-20k_voc12aug-512x512.py |    2 -
 ...101-d8_4xb4-320k_coco-stuff164k-512x512.py |    2 -
 ..._r101-d8_4xb4-40k_coco-stuff10k-512x512.py |    2 -
 ...r101-d8_4xb4-40k_pascal-context-480x480.py |    2 -
 ...1-d8_4xb4-40k_pascal-context-59-480x480.py |    2 -
 ...spnet_r101-d8_4xb4-40k_voc12aug-512x512.py |    2 -
 .../pspnet_r101-d8_4xb4-80k_ade20k-512x512.py |    2 -
 ...r101-d8_4xb4-80k_coco-stuff164k-512x512.py |    2 -
 .../pspnet_r101-d8_4xb4-80k_loveda-512x512.py |    2 -
 ...r101-d8_4xb4-80k_pascal-context-480x480.py |    2 -
 ...1-d8_4xb4-80k_pascal-context-59-480x480.py |    2 -
 ...pspnet_r101-d8_4xb4-80k_potsdam-512x512.py |    2 -
 ...pnet_r101-d8_4xb4-80k_vaihingen-512x512.py |    2 -
 ...t_r101b-d8_4xb2-80k_cityscapes-512x1024.py |    4 -
 ...tyscapes-512x1024_dark-zurich-1920x1080.py |    4 -
 ...scapes-512x1024_night-driving-1920x1080.py |    4 -
 ...et_r101b-d8_4xb2-80k_cityscapes-769x769.py |    4 -
 ...net_r18-d8_4xb2-80k_cityscapes-512x1024.py |    9 -
 ...pnet_r18-d8_4xb2-80k_cityscapes-769x769.py |    9 -
 .../pspnet_r18-d8_4xb4-80k_isaid-896x896.py   |    9 -
 .../pspnet_r18-d8_4xb4-80k_loveda-512x512.py  |    9 -
 .../pspnet_r18-d8_4xb4-80k_potsdam-512x512.py |    9 -
 ...spnet_r18-d8_4xb4-80k_vaihingen-512x512.py |    9 -
 ...et_r18b-d8_4xb2-80k_cityscapes-512x1024.py |    9 -
 ...net_r18b-d8_4xb2-80k_cityscapes-769x769.py |    9 -
 ...et_r50-d32_4xb2-80k_cityscapes-512x1024.py |    9 -
 ..._rsb_4xb2-adamw-80k_cityscapes-512x1024.py |   35 -
 ...-rsb_4xb2-adamw-80k_cityscapes-512x1024.py |   33 -
 ...net_r50-d8_4xb2-40k_cityscapes-512x1024.py |    7 -
 ...tyscapes-512x1024_dark-zurich-1920x1080.py |   24 -
 ...scapes-512x1024_night-driving-1920x1080.py |   25 -
 ...pnet_r50-d8_4xb2-40k_cityscapes-769x769.py |   12 -
 ...net_r50-d8_4xb2-80k_cityscapes-512x1024.py |    7 -
 ...tyscapes-512x1024_dark-zurich-1920x1080.py |   25 -
 ...scapes-512x1024_night-driving-1920x1080.py |   25 -
 ...pnet_r50-d8_4xb2-80k_cityscapes-769x769.py |   12 -
 .../pspnet_r50-d8_4xb4-160k_ade20k-512x512.py |   10 -
 ...r50-d8_4xb4-160k_coco-stuff164k-512x512.py |   11 -
 ...t_r50-d8_4xb4-20k_coco-stuff10k-512x512.py |   10 -
 ...pspnet_r50-d8_4xb4-20k_voc12aug-512x512.py |   11 -
 ...r50-d8_4xb4-320k_coco-stuff164k-512x512.py |   11 -
 ...t_r50-d8_4xb4-40k_coco-stuff10k-512x512.py |   10 -
 ..._r50-d8_4xb4-40k_pascal-context-480x480.py |   14 -
 ...0-d8_4xb4-40k_pascal-context-59-480x480.py |   14 -
 ...pspnet_r50-d8_4xb4-40k_voc12aug-512x512.py |   11 -
 .../pspnet_r50-d8_4xb4-80k_ade20k-512x512.py  |   10 -
 ..._r50-d8_4xb4-80k_coco-stuff164k-512x512.py |   11 -
 .../pspnet_r50-d8_4xb4-80k_isaid-896x896.py   |   10 -
 .../pspnet_r50-d8_4xb4-80k_loveda-512x512.py  |   10 -
 ..._r50-d8_4xb4-80k_pascal-context-480x480.py |   14 -
 ...0-d8_4xb4-80k_pascal-context-59-480x480.py |   14 -
 .../pspnet_r50-d8_4xb4-80k_potsdam-512x512.py |   10 -
 ...spnet_r50-d8_4xb4-80k_vaihingen-512x512.py |   10 -
 ...t_r50b-d32_4xb2-80k_cityscapes-512x1024.py |   10 -
 ...et_r50b-d8_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...net_r50b-d8_4xb2-80k_cityscapes-769x769.py |    2 -
 mmsegmentation/configs/resnest/README.md      |   54 -
 mmsegmentation/configs/resnest/metafile.yaml  |  193 ---
 ..._deeplabv3_4xb2-80k_cityscapes-512x1024.py |    9 -
 ...1-d8_deeplabv3_4xb4-160k_ade20k-512x512.py |    9 -
 ...plabv3plus_4xb2-80k_cityscapes-512x1024.py |    9 -
 ..._deeplabv3plus_4xb4-160k_ade20k-512x512.py |    9 -
 ...101-d8_fcn_4xb2-80k_cityscapes-512x1024.py |    9 -
 ...st_s101-d8_fcn_4xb4-160k_ade20k-512x512.py |    9 -
 ...1-d8_pspnet_4xb2-80k_cityscapes512x1024.py |    9 -
 ...s101-d8_pspnet_4xb4-160k_ade20k-512x512.py |    9 -
 mmsegmentation/configs/san/README.md          |   47 -
 mmsegmentation/configs/san/metafile.yaml      |   61 -
 .../san/san-vit-b16_coco-stuff164k-640x640.py |   82 --
 .../san/san-vit-b16_pascal_context-640x640.py |   56 -
 .../san/san-vit-b16_voc12aug-640x640.py       |   65 -
 .../san/san-vit-l14_coco-stuff164k-640x640.py |   36 -
 .../san/san-vit-l14_pascal_context-640x640.py |   32 -
 .../san/san-vit-l14_voc12aug-640x640.py       |   32 -
 mmsegmentation/configs/segformer/README.md    |  101 --
 .../configs/segformer/metafile.yaml           |  340 -----
 ...r_mit-b0_8xb1-160k_cityscapes-1024x1024.py |   41 -
 ...gformer_mit-b0_8xb2-160k_ade20k-512x512.py |   39 -
 ...r_mit-b1_8xb1-160k_cityscapes-1024x1024.py |    9 -
 ...gformer_mit-b1_8xb2-160k_ade20k-512x512.py |   12 -
 ...r_mit-b2_8xb1-160k_cityscapes-1024x1024.py |   10 -
 ...gformer_mit-b2_8xb2-160k_ade20k-512x512.py |   12 -
 ...r_mit-b3_8xb1-160k_cityscapes-1024x1024.py |   10 -
 ...gformer_mit-b3_8xb2-160k_ade20k-512x512.py |   12 -
 ...r_mit-b4_8xb1-160k_cityscapes-1024x1024.py |   10 -
 ...gformer_mit-b4_8xb2-160k_ade20k-512x512.py |   12 -
 ...r_mit-b5_8xb1-160k_cityscapes-1024x1024.py |   10 -
 ...gformer_mit-b5_8xb2-160k_ade20k-512x512.py |   12 -
 ...gformer_mit-b5_8xb2-160k_ade20k-640x640.py |   41 -
 mmsegmentation/configs/segmenter/README.md    |   76 -
 .../configs/segmenter/metafile.yaml           |  138 --
 ...ter_vit-b_mask_8xb1-160k_ade20k-512x512.py |   14 -
 ...ter_vit-l_mask_8xb1-160k_ade20k-512x512.py |   32 -
 ...nter_vit-s_fcn_8xb1-160k_ade20k-512x512.py |   14 -
 ...ter_vit-s_mask_8xb1-160k_ade20k-512x512.py |   36 -
 ...ter_vit-t_mask_8xb1-160k_ade20k-512x512.py |   26 -
 mmsegmentation/configs/segnext/README.md      |   63 -
 mmsegmentation/configs/segnext/metafile.yaml  |  109 --
 ...mscan-b_1xb16-adamw-160k_ade20k-512x512.py |   28 -
 ...mscan-l_1xb16-adamw-160k_ade20k-512x512.py |   27 -
 ...mscan-s_1xb16-adamw-160k_ade20k-512x512.py |   27 -
 ...mscan-t_1xb16-adamw-160k_ade20k-512x512.py |   84 --
 mmsegmentation/configs/sem_fpn/README.md      |   51 -
 .../fpn_r101_4xb2-80k_cityscapes-512x1024.py  |    2 -
 .../fpn_r101_4xb4-160k_ade20k-512x512.py      |    5 -
 .../fpn_r50_4xb2-80k_cityscapes-512x1024.py   |    7 -
 .../fpn_r50_4xb4-160k_ade20k-512x512.py       |    8 -
 mmsegmentation/configs/sem_fpn/metafile.yaml  |  110 --
 mmsegmentation/configs/setr/README.md         |   74 -
 mmsegmentation/configs/setr/metafile.yaml     |  197 ---
 ...setr_vit-l-mla_8xb1-160k_ade20k-512x512.py |   90 --
 ...r_vit-l_mla_8xb1-80k_cityscapes-768x768.py |   23 -
 ...setr_vit-l_mla_8xb2-160k_ade20k-512x512.py |    6 -
 ...vit-l_naive_8xb1-80k_cityscapes-768x768.py |   24 -
 ...tr_vit-l_naive_8xb2-160k_ade20k-512x512.py |   72 -
 ...r_vit-l_pup_8xb1-80k_cityscapes-768x768.py |   70 -
 ...setr_vit-l_pup_8xb2-160k_ade20k-512x512.py |   72 -
 mmsegmentation/configs/stdc/README.md         |   73 -
 mmsegmentation/configs/stdc/metafile.yaml     |  107 --
 .../stdc1_4xb12-80k_cityscapes-512x1024.py    |   21 -
 ..._in1k-pre_4xb12-80k_cityscapes-512x1024.py |    6 -
 .../stdc2_4xb12-80k_cityscapes-512x1024.py    |    2 -
 ..._in1k-pre_4xb12-80k_cityscapes-512x1024.py |    6 -
 mmsegmentation/configs/swin/README.md         |   76 -
 mmsegmentation/configs/swin/metafile.yaml     |  143 --
 ...84-pre_upernet_8xb2-160k_ade20k-512x512.py |   14 -
 ...84-pre_upernet_8xb2-160k_ade20k-512x512.py |    7 -
 ...1k-pre_upernet_8xb2-160k_ade20k-512x512.py |   12 -
 ...2k-pre_upernet_8xb2-160k_ade20k-512x512.py |    7 -
 ...84-pre_upernet_8xb2-160k_ade20k-512x512.py |   10 -
 ...2k-pre_upernet_8xb2-160k_ade20k-512x512.py |   15 -
 ...1k-pre_upernet_8xb2-160k_ade20k-512x512.py |   10 -
 ...1k-pre_upernet_8xb2-160k_ade20k-512x512.py |   52 -
 ...-window7_upernet_1xb8-20k_levir-256x256.py |   57 -
 mmsegmentation/configs/twins/README.md        |   76 -
 mmsegmentation/configs/twins/metafile.yaml    |  289 ----
 ...t-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py |    8 -
 ...pvt-b_uperhead_8xb2-160k_ade20k-512x512.py |   13 -
 ...t-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py |    8 -
 ...pvt-l_uperhead_8xb2-160k_ade20k-512x512.py |   13 -
 ...t-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py |   12 -
 ...pvt-s_uperhead_8xb4-160k_ade20k-512x512.py |   31 -
 ...t-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py |   12 -
 ...svt-b_uperhead_8xb2-160k_ade20k-512x512.py |   12 -
 ...t-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py |   13 -
 ...svt-l_uperhead_8xb2-160k_ade20k-512x512.py |   13 -
 ...t-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py |   28 -
 ...svt-s_uperhead_8xb2-160k_ade20k-512x512.py |   49 -
 mmsegmentation/configs/unet/README.md         |   92 --
 mmsegmentation/configs/unet/metafile.yaml     |  642 --------
 ...t-s5-d16_deeplabv3_4xb4-40k_drive-64x64.py |    9 -
 ...t-s5-d16_deeplabv3_4xb4-40k_hrf-256x256.py |    9 -
 ...s5-d16_deeplabv3_4xb4-40k_stare-128x128.py |    9 -
 ...4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py |    6 -
 ...v3_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py |    6 -
 ...v3_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py |    6 -
 ..._4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py |    6 -
 ...5-d16_fcn_4xb4-160k_cityscapes-512x1024.py |   16 -
 ...t-s5-d16_fcn_4xb4-160k_hsidrive-192x384.py |   36 -
 ...t-s5-d16_fcn_4xb4-40k_chase-db1-128x128.py |    9 -
 .../unet-s5-d16_fcn_4xb4-40k_drive-64x64.py   |    9 -
 .../unet-s5-d16_fcn_4xb4-40k_hrf-256x256.py   |    9 -
 .../unet-s5-d16_fcn_4xb4-40k_stare-128x128.py |    9 -
 ...4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py |    6 -
 ...cn_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py |    6 -
 ...cn_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py |    6 -
 ..._4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py |    6 -
 ...5-d16_pspnet_4xb4-40k_chase-db1-128x128.py |   10 -
 ...unet-s5-d16_pspnet_4xb4-40k_drive-64x64.py |    9 -
 ...unet-s5-d16_pspnet_4xb4-40k_hrf-256x256.py |    9 -
 ...et-s5-d16_pspnet_4xb4-40k_stare-128x128.py |    9 -
 ...4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py |    6 -
 ...et_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py |    6 -
 ...et_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py |    6 -
 ..._4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py |    6 -
 ...16_deeplabv3_4xb4-40k_chase-db1-128x128.py |   10 -
 mmsegmentation/configs/upernet/README.md      |   68 -
 mmsegmentation/configs/upernet/metafile.yaml  |  391 -----
 ...ernet_r101_4xb2-40k_cityscapes-512x1024.py |    2 -
 ...pernet_r101_4xb2-40k_cityscapes-769x769.py |    2 -
 ...ernet_r101_4xb2-80k_cityscapes-512x1024.py |    2 -
 ...pernet_r101_4xb2-80k_cityscapes-769x769.py |    2 -
 .../upernet_r101_4xb4-160k_ade20k-512x512.py  |    2 -
 .../upernet_r101_4xb4-20k_voc12aug-512x512.py |    2 -
 .../upernet_r101_4xb4-40k_voc12aug-512x512.py |    2 -
 .../upernet_r101_4xb4-80k_ade20k-512x512.py   |    2 -
 ...pernet_r18_4xb2-40k_cityscapes-512x1024.py |    6 -
 ...pernet_r18_4xb2-80k_cityscapes-512x1024.py |    6 -
 .../upernet_r18_4xb4-160k_ade20k-512x512.py   |    9 -
 .../upernet_r18_4xb4-20k_voc12aug-512x512.py  |   10 -
 .../upernet_r18_4xb4-40k_voc12aug-512x512.py  |   10 -
 .../upernet_r18_4xb4-80k_ade20k-512x512.py    |    9 -
 ...pernet_r50_4xb2-40k_cityscapes-512x1024.py |    7 -
 ...upernet_r50_4xb2-40k_cityscapes-769x769.py |   12 -
 ...pernet_r50_4xb2-80k_cityscapes-512x1024.py |    7 -
 ...upernet_r50_4xb2-80k_cityscapes-769x769.py |   12 -
 .../upernet_r50_4xb4-160k_ade20k-512x512.py   |   10 -
 .../upernet_r50_4xb4-20k_voc12aug-512x512.py  |   11 -
 .../upernet_r50_4xb4-40k_voc12aug-512x512.py  |   11 -
 .../upernet_r50_4xb4-80k_ade20k-512x512.py    |   10 -
 mmsegmentation/configs/vit/README.md          |   70 -
 mmsegmentation/configs/vit/metafile.yaml      |  265 ----
 ...ln_mln_upernet_8xb2-160k_ade20k-512x512.py |    5 -
 ...16_mln_upernet_8xb2-160k_ade20k-512x512.py |    6 -
 ...it-b16_upernet_8xb2-160k_ade20k-512x512.py |    6 -
 ...eit-b16_upernet_8xb2-80k_ade20k-512x512.py |    6 -
 ...ln_mln_upernet_8xb2-160k_ade20k-512x512.py |    9 -
 ...16_mln_upernet_8xb2-160k_ade20k-512x512.py |    8 -
 ...it-s16_upernet_8xb2-160k_ade20k-512x512.py |    8 -
 ...eit-s16_upernet_8xb2-80k_ade20k-512x512.py |    8 -
 ...ln_mln_upernet_8xb2-160k_ade20k-512x512.py |   45 -
 ...16_mln_upernet_8xb2-160k_ade20k-512x512.py |   44 -
 ...b16_mln_upernet_8xb2-80k_ade20k-512x512.py |   44 -
 mmsegmentation/configs/vpd/README.md          |   50 -
 mmsegmentation/configs/vpd/metafile.yaml      |   56 -
 .../vpd/vpd_sd_4xb8-25k_nyu-480x480.py        |   38 -
 .../vpd/vpd_sd_4xb8-25k_nyu-512x512.py        |   37 -
 mmsegmentation/dataset-index.yml              |   80 -
 .../demo/MMSegmentation_Tutorial.ipynb        |  555 -------
 mmsegmentation/demo/image_demo.py             |   51 -
 .../demo/image_demo_with_inferencer.py        |   54 -
 mmsegmentation/demo/inference_demo.ipynb      |  120 --
 mmsegmentation/demo/rs_image_inference.py     |   50 -
 mmsegmentation/demo/video_demo.py             |  112 --
 mmsegmentation/docker/Dockerfile              |   35 -
 mmsegmentation/docker/serve/Dockerfile        |   51 -
 mmsegmentation/docker/serve/config.properties |    5 -
 mmsegmentation/docker/serve/entrypoint.sh     |   12 -
 mmsegmentation/docs/en/.readthedocs.yaml      |   17 -
 mmsegmentation/docs/en/Makefile               |   20 -
 .../docs/en/_static/css/readthedocs.css       |    6 -
 .../docs/en/advanced_guides/add_datasets.md   |  199 ---
 .../docs/en/advanced_guides/add_metrics.md    |   81 -
 .../docs/en/advanced_guides/add_models.md     |  260 ----
 .../docs/en/advanced_guides/add_transforms.md |   52 -
 .../en/advanced_guides/customize_runtime.md   |  168 ---
 .../docs/en/advanced_guides/data_flow.md      |   87 --
 .../docs/en/advanced_guides/datasets.md       |  386 -----
 .../docs/en/advanced_guides/engine.md         |  279 ----
 .../docs/en/advanced_guides/evaluation.md     |  155 --
 .../docs/en/advanced_guides/index.rst         |   26 -
 .../docs/en/advanced_guides/models.md         |  164 ---
 .../docs/en/advanced_guides/structures.md     |  104 --
 .../en/advanced_guides/training_tricks.md     |   75 -
 .../docs/en/advanced_guides/transforms.md     |  119 --
 mmsegmentation/docs/en/api.rst                |   95 --
 mmsegmentation/docs/en/conf.py                |  133 --
 mmsegmentation/docs/en/device/npu.md          |   39 -
 mmsegmentation/docs/en/get_started.md         |  211 ---
 mmsegmentation/docs/en/index.rst              |   63 -
 mmsegmentation/docs/en/make.bat               |   35 -
 mmsegmentation/docs/en/migration/index.rst    |    8 -
 mmsegmentation/docs/en/migration/interface.md |  525 -------
 mmsegmentation/docs/en/migration/package.md   |  113 --
 mmsegmentation/docs/en/model_zoo.md           |  186 ---
 mmsegmentation/docs/en/modelzoo_statistics.md |  102 --
 mmsegmentation/docs/en/notes/changelog.md     |  506 -------
 .../docs/en/notes/changelog_v0.x.md           |  720 ---------
 mmsegmentation/docs/en/notes/faq.md           |  132 --
 mmsegmentation/docs/en/overview.md            |   85 --
 mmsegmentation/docs/en/stat.py                |   67 -
 mmsegmentation/docs/en/switch_language.md     |    3 -
 .../docs/en/user_guides/1_config.md           |  588 --------
 .../docs/en/user_guides/2_dataset_prepare.md  |  806 ----------
 .../docs/en/user_guides/3_inference.md        |  244 ---
 .../docs/en/user_guides/4_train_test.md       |  315 ----
 .../docs/en/user_guides/5_deployment.md       |  255 ----
 mmsegmentation/docs/en/user_guides/index.rst  |   21 -
 .../docs/en/user_guides/useful_tools.md       |  245 ----
 .../docs/en/user_guides/visualization.md      |  174 ---
 .../user_guides/visualization_feature_map.md  |  201 ---
 mmsegmentation/docs/zh_cn/.readthedocs.yaml   |   17 -
 mmsegmentation/docs/zh_cn/Makefile            |   20 -
 .../docs/zh_cn/_static/css/readthedocs.css    |    6 -
 .../zh_cn/advanced_guides/add_datasets.md     |  199 ---
 .../docs/zh_cn/advanced_guides/add_metrics.md |   81 -
 .../docs/zh_cn/advanced_guides/add_models.md  |  260 ----
 .../zh_cn/advanced_guides/add_transforms.md   |   51 -
 .../advanced_guides/contribute_dataset.md     |  461 ------
 .../advanced_guides/customize_runtime.md      |  162 --
 .../docs/zh_cn/advanced_guides/data_flow.md   |   90 --
 .../docs/zh_cn/advanced_guides/datasets.md    |  363 -----
 .../docs/zh_cn/advanced_guides/engine.md      |  281 ----
 .../docs/zh_cn/advanced_guides/evaluation.md  |  158 --
 .../docs/zh_cn/advanced_guides/index.rst      |   26 -
 .../docs/zh_cn/advanced_guides/models.md      |  177 ---
 .../docs/zh_cn/advanced_guides/structures.md  |  102 --
 .../zh_cn/advanced_guides/training_tricks.md  |   74 -
 .../docs/zh_cn/advanced_guides/transforms.md  |  119 --
 mmsegmentation/docs/zh_cn/api.rst             |   95 --
 mmsegmentation/docs/zh_cn/conf.py             |  133 --
 mmsegmentation/docs/zh_cn/device/npu.md       |   39 -
 mmsegmentation/docs/zh_cn/get_started.md      |  209 ---
 mmsegmentation/docs/zh_cn/index.rst           |   57 -
 mmsegmentation/docs/zh_cn/make.bat            |   35 -
 mmsegmentation/docs/zh_cn/migration/index.rst |    8 -
 .../docs/zh_cn/migration/interface.md         |  523 -------
 .../docs/zh_cn/migration/package.md           |  113 --
 mmsegmentation/docs/zh_cn/model_zoo.md        |  152 --
 .../docs/zh_cn/modelzoo_statistics.md         |  102 --
 mmsegmentation/docs/zh_cn/notes/faq.md        |  125 --
 mmsegmentation/docs/zh_cn/overview.md         |   75 -
 mmsegmentation/docs/zh_cn/stat.py             |   67 -
 mmsegmentation/docs/zh_cn/switch_language.md  |    3 -
 .../docs/zh_cn/user_guides/1_config.md        |  577 --------
 .../zh_cn/user_guides/2_dataset_prepare.md    |  802 ----------
 .../docs/zh_cn/user_guides/3_inference.md     |  244 ---
 .../docs/zh_cn/user_guides/4_train_test.md    |  317 ----
 .../docs/zh_cn/user_guides/5_deployment.md    |  243 ---
 .../docs/zh_cn/user_guides/deploy_jetson.md   |  372 -----
 .../docs/zh_cn/user_guides/index.rst          |   21 -
 .../docs/zh_cn/user_guides/useful_tools.md    |  368 -----
 .../docs/zh_cn/user_guides/visualization.md   |  173 ---
 .../user_guides/visualization_feature_map.md  |  201 ---
 mmsegmentation/mmseg/apis/__init__.py         |    9 -
 mmsegmentation/mmseg/apis/inference.py        |  189 ---
 mmsegmentation/mmseg/apis/mmseg_inferencer.py |  382 -----
 .../mmseg/apis/remote_sense_inferencer.py     |  279 ----
 mmsegmentation/mmseg/apis/utils.py            |   41 -
 .../mmseg/configs/_base_/datasets/loveda.py   |   79 -
 .../mmseg/configs/_base_/datasets/potsdam.py  |   81 -
 .../mmseg/configs/_base_/default_runtime.py   |   22 -
 .../configs/_base_/schedules/schedule_160k.py |   43 -
 .../configs/_base_/schedules/schedule_20k.py  |   36 -
 .../configs/_base_/schedules/schedule_240k.py |   34 -
 .../configs/_base_/schedules/schedule_25k.py  |   43 -
 .../configs/_base_/schedules/schedule_320k.py |   36 -
 .../configs/_base_/schedules/schedule_40k.py  |   34 -
 .../configs/_base_/schedules/schedule_80k.py  |   42 -
 mmsegmentation/mmseg/datasets/ade.py          |   92 --
 .../mmseg/datasets/basesegdataset.py          |  552 -------
 mmsegmentation/mmseg/datasets/bdd100k.py      |   30 -
 mmsegmentation/mmseg/datasets/chase_db1.py    |   32 -
 mmsegmentation/mmseg/datasets/cityscapes.py   |   30 -
 mmsegmentation/mmseg/datasets/coco_stuff.py   |   99 --
 mmsegmentation/mmseg/datasets/dark_zurich.py  |   15 -
 .../mmseg/datasets/dataset_wrappers.py        |  136 --
 mmsegmentation/mmseg/datasets/decathlon.py    |   96 --
 mmsegmentation/mmseg/datasets/drive.py        |   32 -
 mmsegmentation/mmseg/datasets/dsdl.py         |  116 --
 mmsegmentation/mmseg/datasets/hrf.py          |   32 -
 mmsegmentation/mmseg/datasets/hsi_drive.py    |   42 -
 mmsegmentation/mmseg/datasets/isaid.py        |   39 -
 mmsegmentation/mmseg/datasets/isprs.py        |   29 -
 mmsegmentation/mmseg/datasets/levir.py        |   31 -
 mmsegmentation/mmseg/datasets/lip.py          |   47 -
 mmsegmentation/mmseg/datasets/loveda.py       |   29 -
 mmsegmentation/mmseg/datasets/mapillary.py    |  176 ---
 .../mmseg/datasets/night_driving.py           |   15 -
 mmsegmentation/mmseg/datasets/nyu.py          |  123 --
 .../mmseg/datasets/pascal_context.py          |  116 --
 mmsegmentation/mmseg/datasets/potsdam.py      |   29 -
 mmsegmentation/mmseg/datasets/refuge.py       |   28 -
 mmsegmentation/mmseg/datasets/stare.py        |   32 -
 mmsegmentation/mmseg/datasets/synapse.py      |   28 -
 mmsegmentation/mmseg/datasets/voc.py          |   40 -
 mmsegmentation/mmseg/engine/__init__.py       |   12 -
 mmsegmentation/mmseg/engine/hooks/__init__.py |    4 -
 .../mmseg/engine/hooks/visualization_hook.py  |  129 --
 .../mmseg/engine/optimizers/__init__.py       |    9 -
 .../optimizers/force_default_constructor.py   |  255 ----
 .../layer_decay_optimizer_constructor.py      |  207 ---
 .../mmseg/engine/schedulers/__init__.py       |    4 -
 .../engine/schedulers/poly_ratio_scheduler.py |   62 -
 mmsegmentation/mmseg/registry/__init__.py     |   15 -
 mmsegmentation/mmseg/registry/registry.py     |  118 --
 mmsegmentation/mmseg/structures/__init__.py   |    8 -
 .../mmseg/structures/sampler/__init__.py      |    6 -
 .../structures/sampler/base_pixel_sampler.py  |   13 -
 .../mmseg/structures/sampler/builder.py       |   14 -
 .../structures/sampler/ohem_pixel_sampler.py  |   85 --
 .../mmseg/structures/seg_data_sample.py       |   92 --
 mmsegmentation/mmseg/utils/__init__.py        |   72 -
 .../mmseg/utils/bpe_simple_vocab_16e6.txt.gz  |  Bin 1356917 -> 0 bytes
 mmsegmentation/mmseg/utils/class_names.py     |  570 -------
 mmsegmentation/mmseg/utils/collect_env.py     |   18 -
 mmsegmentation/mmseg/utils/get_templates.py   |  109 --
 mmsegmentation/mmseg/utils/io.py              |   42 -
 .../mmseg/utils/mask_classification.py        |  205 ---
 mmsegmentation/mmseg/utils/misc.py            |  128 --
 mmsegmentation/mmseg/utils/set_env.py         |   40 -
 mmsegmentation/mmseg/utils/tokenizer.py       |  240 ---
 mmsegmentation/mmseg/utils/typing_utils.py    |   25 -
 .../mmseg/visualization/__init__.py           |    4 -
 .../mmseg/visualization/local_visualizer.py   |  349 -----
 mmsegmentation/model-index.yml                |   53 -
 mmsegmentation/projects/Adabins/README.md     |   46 -
 .../projects/Adabins/backbones/__init__.py    |    4 -
 .../Adabins/backbones/adabins_backbone.py     |  141 --
 .../Adabins/configs/_base_/datasets/nyu.py    |   32 -
 .../Adabins/configs/_base_/default_runtime.py |   15 -
 .../Adabins/configs/_base_/models/Adabins.py  |   35 -
 ...abins_efficient_b5_4x16_25e_NYU_416x544.py |   15 -
 ...ins_efficient_b5_4x16_25e_kitti_352x704.py |   12 -
 .../projects/Adabins/decode_head/__init__.py  |    4 -
 .../Adabins/decode_head/adabins_head.py       |  179 ---
 mmsegmentation/projects/CAT-Seg/README.md     |   92 --
 .../projects/CAT-Seg/cat_seg/__init__.py      |    2 -
 .../CAT-Seg/cat_seg/models/__init__.py        |   10 -
 .../CAT-Seg/cat_seg/models/cat_aggregator.py  |  763 ----------
 .../CAT-Seg/cat_seg/models/cat_head.py        |  116 --
 .../CAT-Seg/cat_seg/models/clip_ovseg.py      |  293 ----
 .../CAT-Seg/cat_seg/utils/__init__.py         |   10 -
 .../bpe_vocab/bpe_simple_vocab_16e6.txt.gz    |  Bin 1356917 -> 0 bytes
 .../CAT-Seg/cat_seg/utils/clip_model.py       |  651 --------
 .../CAT-Seg/cat_seg/utils/clip_templates.py   |  204 ---
 .../CAT-Seg/cat_seg/utils/clip_wrapper.py     |  275 ----
 .../cat_seg/utils/self_attention_block.py     |   79 -
 .../CAT-Seg/cat_seg/utils/tokenizer.py        |  160 --
 .../configs/_base_/datasets/ade20k_384x384.py |   68 -
 .../_base_/datasets/coco-stuff164k_384x384.py |   62 -
 .../datasets/pascal_context_59_384x384.py     |   72 -
 .../CAT-Seg/configs/_base_/default_runtime.py |   15 -
 .../configs/_base_/schedules/schedule_80k.py  |   24 -
 ...-warmcoslr2e-4-adamw-80k_ade20k-384x384.py |  103 --
 ...e-4-adamw-80k_pascal-context-59-384x384.py |  103 --
 ...lr2e-4-adamw-80k_coco-stuff164k-384x384.py |  102 --
 ...lr2e-4_adamw-80k_coco-stuff164k_384x384.py |   11 -
 ...lr2e-4_adamw-80k_coco-stuff164k_384x384.py |   11 -
 ...lr2e-4_adamw-80k_coco-stuff164k_384x384.py |   72 -
 .../projects/CAT-Seg/utils/__init__.py        |    7 -
 mmsegmentation/projects/README.md             |   19 -
 mmsegmentation/projects/XDecoder/README.md    |   17 -
 .../projects/bdd100k_dataset/README.md        |   50 -
 .../configs/_base_/datasets/bdd100k.py        |   70 -
 ...pspnet_r50-d8_4xb2-80k_bdd100k-512x1024.py |   11 -
 .../docs/en/user_guides/2_dataset_prepare.md  |   40 -
 .../zh_cn/user_guides/2_dataset_prepare.md    |   42 -
 .../bdd100k_dataset/mmseg/datasets/bdd100k.py |   31 -
 .../projects/example_project/README.md        |  134 --
 ...mmy-r50-d8_4xb2-40k_cityscapes-512x1024.py |    8 -
 .../example_project/dummy/__init__.py         |    3 -
 .../example_project/dummy/dummy_resnet.py     |   14 -
 mmsegmentation/projects/faq.md                |   19 -
 .../configs/_base_/datasets/gid.py            |   67 -
 ...labv3plus_r101-d8_4xb2-240k_gid-256x256.py |   15 -
 .../gid_dataset/mmseg/datasets/gid.py         |   55 -
 .../tools/dataset_converters/gid.py           |  181 ---
 .../gid_select15imgFromAll.py                 |   75 -
 .../user_guides/2_dataset_prepare.md          |   53 -
 .../projects/hsidrive20_dataset/README.md     |   34 -
 .../configs/_base_/datasets/hsi_drive.py      |   50 -
 ...t-s5-d16_fcn_4xb4-160k_hsidrive-192x384.py |   58 -
 .../docs/en/user_guides/2_dataset_prepare.md  |   42 -
 .../zh_cn/user_guides/2_dataset_prepare.md    |   42 -
 .../mmseg/datasets/hsi_drive.py               |   23 -
 mmsegmentation/projects/hssn/README.md        |   91 --
 .../configs/_base_/datasets/cityscapes.py     |   67 -
 .../hssn/configs/_base_/default_runtime.py    |   15 -
 .../deeplabv3plus_r50-d8_vd_contrast.py       |   55 -
 .../configs/_base_/schedules/schedule_80k.py  |   24 -
 ...us_r101-d8_4xb2-80l_cityscapes-512x1024.py |   21 -
 .../projects/hssn/decode_head/__init__.py     |    4 -
 .../decode_head/sep_aspp_contrast_head.py     |  193 ---
 .../projects/hssn/losses/__init__.py          |    4 -
 .../losses/hiera_triplet_loss_cityscape.py    |  218 ---
 .../projects/hssn/losses/tree_triplet_loss.py |   86 --
 mmsegmentation/projects/isnet/README.md       |  117 --
 ...et_r50-d8_8xb2-160k_cityscapes-512x1024.py |   80 -
 .../projects/isnet/decode_heads/__init__.py   |    3 -
 .../projects/isnet/decode_heads/isnet_head.py |  337 -----
 .../projects/mapillary_dataset/README.md      |   86 --
 .../configs/_base_/datasets/mapillary_v1.py   |   68 -
 .../_base_/datasets/mapillary_v1_65.py        |   37 -
 .../configs/_base_/datasets/mapillary_v2.py   |   68 -
 ..._r101-d8_4xb2-240k_mapillay_v1-512x1024.py |   17 -
 ..._r101-d8_4xb2-240k_mapillay_v2-512x1024.py |   16 -
 ..._r101-d8_4xb2-240k_mapillay_v1-512x1024.py |   16 -
 ..._r101-d8_4xb2-240k_mapillay_v2-512x1024.py |   16 -
 .../docs/en/user_guides/2_dataset_prepare.md  |  255 ----
 .../mmseg/datasets/mapillary.py               |  177 ---
 .../medical/2d_image/ct/cranium/README.md     |  142 --
 .../ct/cranium/configs/cranium_512x512.py     |   42 -
 ...sigmoid}_1xb16-0.01-20k_cranium-512x512.py |   18 -
 ...6_unet_1xb16-0.0001-20k_cranium-512x512.py |   17 -
 ...16_unet_1xb16-0.001-20k_cranium-512x512.py |   17 -
 ...d16_unet_1xb16-0.01-20k_cranium-512x512.py |   17 -
 .../ct/cranium/datasets/cranium_dataset.py    |   31 -
 .../ct/cranium/tools/prepare_dataset.py       |   66 -
 .../dermoscopy/isic2016_task1/README.md       |  149 --
 ...1xb16-0.0001-20k_isic2016-task1-512x512.py |   17 -
 ..._1xb16-0.001-20k_isic2016-task1-512x512.py |   17 -
 ...t_1xb16-0.01-20k_isic2016-task1-512x512.py |   17 -
 .../configs/isic2016-task1_512x512.py         |   42 -
 .../datasets/isic2016-task1_dataset.py        |   30 -
 .../isic2016_task1/tools/prepare_dataset.py   |  120 --
 .../dermoscopy/isic2017_task1/README.md       |  158 --
 ...1xb16-0.0001-20k_isic2017-task1-512x512.py |   17 -
 ..._1xb16-0.001-20k_isic2017-task1-512x512.py |   17 -
 ...t_1xb16-0.01-20k_isic2017-task1-512x512.py |   17 -
 .../configs/isic2017-task1_512x512.py         |   41 -
 .../datasets/isic2017-task1_dataset.py        |   30 -
 .../isic2017_task1/tools/prepare_dataset.py   |  127 --
 .../2d_image/endoscopy/kvasir_seg/README.md   |  145 --
 ...moid}_1xb16-0.01-20k_kvasir-seg-512x512.py |   18 -
 ...net_1xb16-0.0001-20k_kvasir-seg-512x512.py |   17 -
 ...unet_1xb16-0.001-20k_kvasir-seg-512x512.py |   17 -
 ..._unet_1xb16-0.01-20k_kvasir-seg-512x512.py |   17 -
 .../kvasir_seg/configs/kvasir-seg_512x512.py  |   42 -
 .../kvasir_seg/datasets/kvasir-seg_dataset.py |   30 -
 .../kvasir_seg/tools/prepare_dataset.py       |   87 --
 .../endoscopy/kvasir_seg_aliyun/README.md     |  145 --
 ...16-0.0001-20k_kvasir-seg-aliyun-512x512.py |   17 -
 ...b16-0.001-20k_kvasir-seg-aliyun-512x512.py |   17 -
 ...xb16-0.01-20k_kvasir-seg-aliyun-512x512.py |   17 -
 ...r-sigmoid-20k_kvasir-seg-aliyun-512x512.py |   18 -
 .../configs/kvasir-seg-aliyun_512x512.py      |   42 -
 .../datasets/kvasir-seg-aliyun_dataset.py     |   30 -
 .../tools/prepare_dataset.py                  |   86 --
 .../fluorescein_angriogram/vampire/README.md  |  158 --
 ...6_unet_1xb16-0.0001-20k_vampire-512x512.py |   19 -
 ...16_unet_1xb16-0.001-20k_vampire-512x512.py |   19 -
 ...d16_unet_1xb16-0.01-20k_vampire-512x512.py |   22 -
 .../vampire/configs/vampire_512x512.py        |   42 -
 .../vampire/datasets/__init__.py              |    3 -
 .../vampire/datasets/vampire_dataset.py       |   28 -
 .../vampire/tools/prepare_dataset.py          |   44 -
 .../fundus_photography/dr_hagis/README.md     |  155 --
 .../dr_hagis/configs/dr-hagis_512x512.py      |   42 -
 ..._unet_1xb16-0.0001-20k_dr-hagis-512x512.py |   17 -
 ...6_unet_1xb16-0.001-20k_dr-hagis-512x512.py |   17 -
 ...16_unet_1xb16-0.01-20k_dr-hagis-512x512.py |   17 -
 .../dr_hagis/datasets/dr-hagis_dataset.py     |   27 -
 .../dr_hagis/tools/prepare_dataset.py         |   41 -
 .../fundus_photography/gamma3/README.md       |  167 ---
 ...16_unet_1xb16-0.0001-20k_gamma3-512x512.py |   17 -
 ...d16_unet_1xb16-0.001-20k_gamma3-512x512.py |   17 -
 ...-d16_unet_1xb16-0.01-20k_gamma3-512x512.py |   17 -
 .../gamma3/configs/gamma3_512x512.py          |   42 -
 .../gamma3/datasets/gamma3_dataset.py         |   30 -
 .../gamma3/tools/prepare_dataset.py           |  107 --
 .../fundus_photography/orvs/README.md         |  140 --
 ...-d16_unet_1xb16-0.0001-20k_orvs-512x512.py |   17 -
 ...5-d16_unet_1xb16-0.001-20k_orvs-512x512.py |   17 -
 ...s5-d16_unet_1xb16-0.01-20k_orvs-512x512.py |   17 -
 .../orvs/configs/orvs_512x512.py              |   42 -
 .../orvs/datasets/orvs_dataset.py             |   27 -
 .../orvs/tools/prepare_dataset.py             |   55 -
 .../fundus_photography/rite/README.md         |  135 --
 ...-d16_unet_1xb16-0.0001-20k_rite-512x512.py |   17 -
 ...5-d16_unet_1xb16-0.001-20k_rite-512x512.py |   17 -
 ...s5-d16_unet_1xb16-0.01-20k_rite-512x512.py |   17 -
 ...t_1xb16-0.01lr-sigmoid-20k_rite-512x512.py |   18 -
 .../rite/configs/rite_512x512.py              |   42 -
 .../rite/datasets/rite_dataset.py             |   31 -
 .../rite/tools/prepare_dataset.py             |   98 --
 .../breastCancerCellSegmentation/README.md    |  123 --
 .../breastCancerCellSegmentation_512x512.py   |   42 -
 ...0k_breastCancerCellSegmentation-512x512.py |   18 -
 ...0k_breastCancerCellSegmentation-512x512.py |   18 -
 ...0k_breastCancerCellSegmentation-512x512.py |   18 -
 .../breastCancerCellSegmentation_dataset.py   |   30 -
 .../tools/prepare_dataset.py                  |   36 -
 .../breast_cancer_cell_seg/README.md          |  147 --
 .../configs/breast-cancer-cell-seg_512x512.py |   42 -
 ...0001-20k_breast-cancer-cell-seg-512x512.py |   18 -
 ....001-20k_breast-cancer-cell-seg-512x512.py |   18 -
 ...0.01-20k_breast-cancer-cell-seg-512x512.py |   18 -
 .../breast-cancer-cell-seg_dataset.py         |   29 -
 .../tools/prepare_dataset.py                  |   47 -
 .../histopathology/conic2022_seg/README.md    |  207 ---
 .../configs/conic2022-seg_512x512.py          |   42 -
 ...unet_1xb16-0.0001-20k_conic2022-512x512.py |   17 -
 ..._unet_1xb16-0.001-20k_conic2022-512x512.py |   17 -
 ...6_unet_1xb16-0.01-20k_conic2022-512x512.py |   17 -
 .../datasets/conic2022-seg_dataset.py         |   29 -
 .../conic2022_seg/tools/prepare_dataset.py    |   65 -
 .../2d_image/histopathology/consep/README.md  |  147 --
 .../consep/configs/consep_512x512.py          |   42 -
 ...16_unet_1xb16-0.0001-20k_consep-512x512.py |   17 -
 ...d16_unet_1xb16-0.001-20k_consep-512x512.py |   17 -
 ...-d16_unet_1xb16-0.01-20k_consep-512x512.py |   17 -
 .../consep/datasets/consep_dataset.py         |   30 -
 .../consep/tools/prepare_dataset.py           |   54 -
 .../histopathology/fusc2021/README.md         |  136 --
 ..._unet_1xb16-0.0001-20k_fusc2021-512x512.py |   17 -
 ...6_unet_1xb16-0.001-20k_fusc2021-512x512.py |   17 -
 ...16_unet_1xb16-0.01-20k_fusc2021-512x512.py |   17 -
 ...b16-0.01lr-sigmoid-20k_fusc2021-512x512.py |   18 -
 .../fusc2021/configs/fusc2021_512x512.py      |   42 -
 .../fusc2021/datasets/fusc2021_dataset.py     |   30 -
 .../fusc2021/tools/prepare_dataset.py         |  114 --
 .../2d_image/histopathology/pannuke/README.md |  146 --
 ...16-0.01-20k_bactteria-detection-512x512.py |   18 -
 ...6_unet_1xb16-0.0001-20k_pannuke-512x512.py |   17 -
 ...16_unet_1xb16-0.001-20k_pannuke-512x512.py |   17 -
 ...d16_unet_1xb16-0.01-20k_pannuke-512x512.py |   17 -
 .../pannuke/configs/pannuke_512x512.py        |   42 -
 .../pannuke/datasets/pannuke_dataset.py       |   33 -
 .../pannuke/tools/prepare_dataset.py          |   49 -
 .../2d_image/histopathology/pcam/README.md    |  153 --
 ...-d16_unet_1xb16-0.0001-20k_pcam-512x512.py |   17 -
 ...5-d16_unet_1xb16-0.001-20k_pcam-512x512.py |   17 -
 ...s5-d16_unet_1xb16-0.01-20k_pcam-512x512.py |   17 -
 ...t_1xb16-0.01lr-sigmoid-20k_pcam-512x512.py |   18 -
 .../pcam/configs/pcam_512x512.py              |   42 -
 .../pcam/datasets/pcam_dataset.py             |   31 -
 .../pcam/tools/prepare_dataset.py             |   49 -
 .../ravir/README.md                           |  167 ---
 ...d16_unet_1xb16-0.0001-20k_ravir-512x512.py |   19 -
 ...-d16_unet_1xb16-0.001-20k_ravir-512x512.py |   19 -
 ...5-d16_unet_1xb16-0.01-20k_ravir-512x512.py |   19 -
 .../ravir/configs/ravir_512x512.py            |   42 -
 .../ravir/datasets/__init__.py                |    3 -
 .../ravir/datasets/ravir_dataset.py           |   28 -
 .../ravir/tools/prepare_dataset.py            |   33 -
 .../microscopy_images/2pm_vessel/README.md    |  153 --
 .../2pm_vessel/configs/2pm-vessel_512x512.py  |   42 -
 ...net_1xb16-0.0001-20k_2pm-vessel-512x512.py |   17 -
 ...unet_1xb16-0.001-20k_2pm-vessel-512x512.py |   17 -
 ..._unet_1xb16-0.01-20k_2pm-vessel-512x512.py |   17 -
 ...sigmoid-20k_bactteria-detection-512x512.py |   18 -
 .../2pm_vessel/datasets/2pm-vessel_dataset.py |   31 -
 .../2pm_vessel/tools/prepare_dataset.py       |   46 -
 .../bactteria_detection/README.md             |  160 --
 .../configs/bactteria-detection_512x512.py    |   42 -
 ...-0.0001-20k_bactteria-detection-512x512.py |   18 -
 ...6-0.001-20k_bactteria-detection-512x512.py |   18 -
 ...16-0.01-20k_bactteria-detection-512x512.py |   18 -
 .../datasets/bactteria-detection_dataset.py   |   27 -
 .../tools/prepare_dataset.py                  |   33 -
 .../2d_image/tools/split_seg_dataset.py       |   42 -
 .../x_ray/chest_image_pneum/README.md         |  147 --
 .../configs/chest-image-pneum_512x512.py      |   42 -
 ...16-0.0001-20k_chest-image-pneum-512x512.py |   18 -
 ...b16-0.001-20k_chest-image-pneum-512x512.py |   18 -
 ...xb16-0.01-20k_chest-image-pneum-512x512.py |   18 -
 .../datasets/chest-image-pneum_dataset.py     |   27 -
 .../tools/prepare_dataset.py                  |   73 -
 .../README.md                                 |  119 --
 ...-images-with-pneumothorax-masks_512x512.py |   42 -
 ...-images-with-pneumothorax-masks-512x512.py |   20 -
 ...-images-with-pneumothorax-masks-512x512.py |   19 -
 ...-images-with-pneumothorax-masks-512x512.py |   19 -
 ...-images-with-pneumothorax-masks-512x512.py |   19 -
 ...-images-with-pneumothorax-masks_dataset.py |   31 -
 .../tools/prepare_dataset.py                  |   36 -
 .../2d_image/x_ray/covid_19_ct_cxr/README.md  |  158 --
 .../configs/covid-19-ct-cxr_512x512.py        |   42 -
 ..._1xb16-0.01-20k_covid-19-ct-cxr-512x512.py |   18 -
 ...xb16-0.0001-20k_covid-19-ct-cxr-512x512.py |   17 -
 ...1xb16-0.001-20k_covid-19-ct-cxr-512x512.py |   17 -
 ..._1xb16-0.01-20k_covid-19-ct-cxr-512x512.py |   17 -
 .../datasets/covid-19-ct-cxr_dataset.py       |   31 -
 .../covid_19_ct_cxr/tools/prepare_dataset.py  |   52 -
 .../medical/2d_image/x_ray/crass/README.md    |  144 --
 .../x_ray/crass/configs/crass_512x512.py      |   42 -
 ...d16_unet_1xb16-0.0001-20k_crass-512x512.py |   17 -
 ...-d16_unet_1xb16-0.001-20k_crass-512x512.py |   17 -
 ...5-d16_unet_1xb16-0.01-20k_crass-512x512.py |   17 -
 ..._1xb16-lr0.01-sigmoid-20k_crass-512x512.py |   18 -
 .../x_ray/crass/datasets/crass_dataset.py     |   30 -
 .../x_ray/crass/tools/prepare_dataset.py      |   84 --
 .../projects/nvidia_jetson/README.md          |  372 -----
 .../projects/pp_mobileseg/README.md           |  123 --
 .../pp_mobileseg/backbones/__init__.py        |    4 -
 .../pp_mobileseg/backbones/strideformer.py    |  958 ------------
 .../configs/_base_/datasets/ade20k.py         |   68 -
 .../configs/_base_/default_runtime.py         |   15 -
 .../configs/_base_/models/pp_mobile.py        |   47 -
 .../configs/_base_/schedules/schedule_80k.py  |   24 -
 ...obilenetv3_2x16_80k_ade20k_512x512_base.py |   18 -
 ...obilenetv3_2x16_80k_ade20k_512x512_tiny.py |   45 -
 .../pp_mobileseg/decode_head/__init__.py      |    6 -
 .../decode_head/pp_mobileseg_head.py          |   94 --
 .../projects/pp_mobileseg/inference_onnx.py   |  203 ---
 .../projects/sam_inference_demo/README.md     |   40 -
 .../sam_inference_demo/sam/__init__.py        |    2 -
 .../sam/modeling/__init__.py                  |   12 -
 .../sam_inference_demo/sam/modeling/common.py |   45 -
 .../sam/modeling/mask_decoder.py              |  196 ---
 .../sam/modeling/prompt_encoder.py            |  227 ---
 .../sam_inference_demo/sam/modeling/sam.py    |  188 ---
 .../sam/modeling/transformer.py               |  241 ---
 .../sam_inference_demo/sam/sam_inferencer.py  |  688 ---------
 .../sam_inference_demo/sam/utils/__init__.py  |    2 -
 .../sam_inference_demo/sam/utils/amg.py       |  355 -----
 .../sam/utils/transforms.py                   |  110 --
 .../sam_inference_demo/sam_image_demo.ipynb   |  122 --
 mmsegmentation/projects/van/README.md         |  101 --
 .../projects/van/backbones/__init__.py        |    4 -
 mmsegmentation/projects/van/backbones/van.py  |  124 --
 .../van/configs/_base_/datasets/ade20k.py     |   14 -
 .../van/configs/_base_/models/van_fpn.py      |   43 -
 .../van/configs/_base_/models/van_upernet.py  |   51 -
 .../van/van-b0_fpn_8xb4-40k_ade20k-512x512.py |    8 -
 .../van/van-b1_fpn_8xb4-40k_ade20k-512x512.py |    6 -
 .../van/van-b2_fpn_8xb4-40k_ade20k-512x512.py |   53 -
 ...van-b2_upernet_4xb2-160k_ade20k-512x512.py |   46 -
 .../van/van-b3_fpn_8xb4-40k_ade20k-512x512.py |   11 -
 ...van-b3_upernet_4xb2-160k_ade20k-512x512.py |    8 -
 ...22kpre_upernet_4xb4-160k_ade20k-512x512.py |   10 -
 ...van-b4_upernet_4xb4-160k_ade20k-512x512.py |   10 -
 ...22kpre_upernet_4xb2-160k_ade20k-512x512.py |   10 -
 ...22kpre_upernet_4xb2-160k_ade20k-512x512.py |   10 -
 ...net_r50-d8_4xb2-40k_cityscapes-512x1024.py |  292 ----
 mmsegmentation/requirements.txt               |    4 -
 mmsegmentation/requirements/albu.txt          |    1 -
 mmsegmentation/requirements/docs.txt          |    7 -
 mmsegmentation/requirements/mminstall.txt     |    2 -
 mmsegmentation/requirements/multimodal.txt    |    2 -
 mmsegmentation/requirements/optional.txt      |   22 -
 mmsegmentation/requirements/readthedocs.txt   |    6 -
 mmsegmentation/requirements/runtime.txt       |    5 -
 mmsegmentation/requirements/tests.txt         |    8 -
 mmsegmentation/resources/seg_demo.gif         |  Bin 951973 -> 0 bytes
 mmsegmentation/setup.cfg                      |   19 -
 mmsegmentation/setup.py                       |  200 ---
 mmsegmentation/test.ipynb                     |  194 ---
 mmsegmentation/tests/__init__.py              |    1 -
 .../tests/test_apis/test_inferencer.py        |   60 -
 .../tests/test_apis/test_rs_inferencer.py     |   73 -
 mmsegmentation/tests/test_apis/utils.py       |   38 -
 mmsegmentation/tests/test_config.py           |  175 ---
 .../tests/test_datasets/test_dataset.py       |  475 ------
 .../test_datasets/test_dataset_builder.py     |  152 --
 .../tests/test_datasets/test_formatting.py    |   61 -
 .../tests/test_datasets/test_loading.py       |  295 ----
 .../tests/test_datasets/test_transform.py     | 1273 ----------------
 .../tests/test_datasets/test_tta.py           |  131 --
 mmsegmentation/tests/test_digit_version.py    |   21 -
 .../test_layer_decay_optimizer_constructor.py |  300 ----
 .../tests/test_engine/test_optimizer.py       |   33 -
 .../test_engine/test_visualization_hook.py    |   64 -
 .../test_metrics/test_citys_metric.py         |  119 --
 .../test_metrics/test_depth_metric.py         |   85 --
 .../test_metrics/test_iou_metric.py           |  104 --
 mmsegmentation/tests/test_models/__init__.py  |    1 -
 .../test_assigners/test_hungarian_assigner.py |   77 -
 .../test_models/test_backbones/__init__.py    |    1 -
 .../test_models/test_backbones/test_beit.py   |  185 ---
 .../test_backbones/test_bisenetv1.py          |  109 --
 .../test_backbones/test_bisenetv2.py          |   57 -
 .../test_models/test_backbones/test_blocks.py |  187 ---
 .../test_models/test_backbones/test_cgnet.py  |  151 --
 .../test_backbones/test_clip_text_encoder.py  |   43 -
 .../test_models/test_backbones/test_erfnet.py |  146 --
 .../test_backbones/test_fast_scnn.py          |   42 -
 .../test_models/test_backbones/test_hrnet.py  |  144 --
 .../test_models/test_backbones/test_icnet.py  |   50 -
 .../test_models/test_backbones/test_mae.py    |  186 ---
 .../test_models/test_backbones/test_mit.py    |  122 --
 .../test_backbones/test_mobilenet_v3.py       |   67 -
 .../test_models/test_backbones/test_mscan.py  |   69 -
 .../test_models/test_backbones/test_pidnet.py |   87 --
 .../test_backbones/test_resnest.py            |   44 -
 .../test_models/test_backbones/test_resnet.py |  575 --------
 .../test_backbones/test_resnext.py            |   62 -
 .../test_models/test_backbones/test_stdc.py   |  131 --
 .../test_models/test_backbones/test_swin.py   |  100 --
 .../test_backbones/test_timm_backbone.py      |  133 --
 .../test_models/test_backbones/test_twins.py  |  171 ---
 .../test_models/test_backbones/test_unet.py   |  825 -----------
 .../test_models/test_backbones/test_vit.py    |  185 ---
 .../test_models/test_backbones/test_vpd.py    |   51 -
 .../tests/test_models/test_backbones/utils.py |   43 -
 .../test_models/test_data_preprocessor.py     |   64 -
 .../tests/test_models/test_forward.py         |  229 ---
 .../tests/test_models/test_heads/__init__.py  |    1 -
 .../test_models/test_heads/test_ann_head.py   |   20 -
 .../test_models/test_heads/test_apc_head.py   |   59 -
 .../test_models/test_heads/test_aspp_head.py  |   76 -
 .../test_models/test_heads/test_cc_head.py    |   18 -
 .../test_heads/test_decode_head.py            |  193 ---
 .../test_models/test_heads/test_dm_head.py    |   59 -
 .../test_models/test_heads/test_dnl_head.py   |   44 -
 .../test_models/test_heads/test_dpt_head.py   |   49 -
 .../test_models/test_heads/test_ema_head.py   |   23 -
 .../test_models/test_heads/test_fcn_head.py   |  131 --
 .../test_models/test_heads/test_gc_head.py    |   16 -
 .../test_models/test_heads/test_ham_head.py   |   44 -
 .../test_models/test_heads/test_isa_head.py   |   20 -
 .../test_heads/test_lraspp_head.py            |   68 -
 .../test_heads/test_mask2former_head.py       |  153 --
 .../test_heads/test_maskformer_head.py        |   54 -
 .../test_models/test_heads/test_nl_head.py    |   16 -
 .../test_models/test_heads/test_ocr_head.py   |   19 -
 .../test_heads/test_pidnet_head.py            |   89 --
 .../test_models/test_heads/test_psa_head.py   |  122 --
 .../test_models/test_heads/test_psp_head.py   |   36 -
 .../test_models/test_heads/test_san_head.py   |  126 --
 .../test_heads/test_segformer_head.py         |   40 -
 .../test_heads/test_segmenter_mask_head.py    |   24 -
 .../test_heads/test_setr_mla_head.py          |   63 -
 .../test_heads/test_setr_up_head.py           |   56 -
 .../test_models/test_heads/test_uper_head.py  |   35 -
 .../test_heads/test_vpd_depth_head.py         |   50 -
 .../tests/test_models/test_heads/utils.py     |   31 -
 .../test_losses/test_cross_entropy_loss.py    |   28 -
 .../test_models/test_losses/test_dice_loss.py |   96 --
 .../test_huasdorff_distance_loss.py           |   29 -
 .../test_losses/test_kldiv_loss.py            |   40 -
 .../test_losses/test_silog_loss.py            |   20 -
 .../test_losses/test_tversky_loss.py          |   77 -
 .../tests/test_models/test_necks/__init__.py  |    1 -
 .../test_necks/test_feature2pyramid.py        |   38 -
 .../tests/test_models/test_necks/test_fpn.py  |   30 -
 .../test_models/test_necks/test_ic_neck.py    |   53 -
 .../tests/test_models/test_necks/test_jpu.py  |   46 -
 .../test_models/test_necks/test_mla_neck.py   |   16 -
 .../test_necks/test_multilevel_neck.py        |   32 -
 .../test_models/test_segmentors/__init__.py   |    1 -
 .../test_cascade_encoder_decoder.py           |   57 -
 .../test_segmentors/test_depth_estimator.py   |   64 -
 .../test_segmentors/test_encoder_decoder.py   |  100 --
 .../test_multimodal_encoder_decoder.py        |   24 -
 .../test_segmentors/test_seg_tta_model.py     |   63 -
 .../test_models/test_segmentors/utils.py      |  182 ---
 .../tests/test_models/test_utils/__init__.py  |    1 -
 .../test_models/test_utils/test_embed.py      |  461 ------
 .../test_utils/test_shape_convert.py          |   89 --
 mmsegmentation/tests/test_sampler.py          |   78 -
 .../test_structures/test_seg_data_sample.py   |   77 -
 mmsegmentation/tests/test_utils/test_io.py    |   33 -
 .../tests/test_utils/test_set_env.py          |   39 -
 .../test_local_visualizer.py                  |  213 ---
 .../tools/analysis_tools/analyze_logs.py      |  130 --
 .../tools/analysis_tools/benchmark.py         |  121 --
 .../tools/analysis_tools/browse_dataset.py    |   77 -
 .../tools/analysis_tools/confusion_matrix.py  |  197 ---
 .../tools/analysis_tools/get_flops.py         |  124 --
 .../tools/analysis_tools/visualization_cam.py |  127 --
 .../tools/dataset_converters/chase_db1.py     |   89 --
 .../tools/dataset_converters/cityscapes.py    |   56 -
 .../tools/dataset_converters/coco_stuff10k.py |  308 ----
 .../dataset_converters/coco_stuff164k.py      |  265 ----
 .../tools/dataset_converters/drive.py         |  114 --
 .../tools/dataset_converters/hrf.py           |  112 --
 .../tools/dataset_converters/isaid.py         |  246 ----
 .../tools/dataset_converters/levircd.py       |   99 --
 .../tools/dataset_converters/loveda.py        |   73 -
 .../tools/dataset_converters/nyu.py           |   89 --
 .../dataset_converters/pascal_context.py      |   87 --
 .../tools/dataset_converters/potsdam.py       |  158 --
 .../tools/dataset_converters/refuge.py        |  110 --
 .../tools/dataset_converters/stare.py         |  167 ---
 .../tools/dataset_converters/synapse.py       |  155 --
 .../tools/dataset_converters/vaihingen.py     |  156 --
 .../tools/dataset_converters/voc_aug.py       |   92 --
 .../tools/deployment/pytorch2torchscript.py   |  185 ---
 mmsegmentation/tools/dist_test.sh             |   20 -
 mmsegmentation/tools/dist_train.sh            |   17 -
 mmsegmentation/tools/misc/browse_dataset.py   |   73 -
 mmsegmentation/tools/misc/print_config.py     |   69 -
 mmsegmentation/tools/misc/publish_model.py    |   50 -
 .../tools/model_converters/beit2mmseg.py      |   56 -
 .../tools/model_converters/clip2mmseg.py      |  163 ---
 .../tools/model_converters/mit2mmseg.py       |   82 --
 .../tools/model_converters/san2mmseg.py       |  220 ---
 .../tools/model_converters/stdc2mmseg.py      |   71 -
 .../tools/model_converters/swin2mmseg.py      |   87 --
 .../tools/model_converters/twins2mmseg.py     |   87 --
 .../tools/model_converters/vit2mmseg.py       |   70 -
 .../tools/model_converters/vitjax2mmseg.py    |  123 --
 mmsegmentation/tools/slurm_test.sh            |   24 -
 mmsegmentation/tools/slurm_train.sh           |   23 -
 .../tools/torchserve/mmseg2torchserve.py      |  112 --
 .../tools/torchserve/mmseg_handler.py         |   56 -
 .../tools/torchserve/test_torchserve.py       |   58 -
 1469 files changed, 93332 deletions(-)
 delete mode 100644 mmsegmentation/.circleci/config.yml
 delete mode 100644 mmsegmentation/.circleci/docker/Dockerfile
 delete mode 100644 mmsegmentation/.circleci/test.yml
 delete mode 100644 mmsegmentation/.dev_scripts/batch_test_list.py
 delete mode 100644 mmsegmentation/.dev_scripts/batch_train_list.txt
 delete mode 100755 mmsegmentation/.dev_scripts/benchmark_evaluation.sh
 delete mode 100644 mmsegmentation/.dev_scripts/benchmark_full_models.txt
 delete mode 100644 mmsegmentation/.dev_scripts/benchmark_inference.py
 delete mode 100644 mmsegmentation/.dev_scripts/benchmark_options.py
 delete mode 100755 mmsegmentation/.dev_scripts/benchmark_train.sh
 delete mode 100644 mmsegmentation/.dev_scripts/benchmark_train_models.txt
 delete mode 100644 mmsegmentation/.dev_scripts/check_urls.py
 delete mode 100644 mmsegmentation/.dev_scripts/gather_benchmark_evaluation_results.py
 delete mode 100644 mmsegmentation/.dev_scripts/gather_benchmark_train_results.py
 delete mode 100644 mmsegmentation/.dev_scripts/gather_models.py
 delete mode 100644 mmsegmentation/.dev_scripts/generate_benchmark_evaluation_script.py
 delete mode 100644 mmsegmentation/.dev_scripts/generate_benchmark_train_script.py
 delete mode 100644 mmsegmentation/.dev_scripts/log_collector/example_config.py
 delete mode 100644 mmsegmentation/.dev_scripts/log_collector/log_collector.py
 delete mode 100644 mmsegmentation/.dev_scripts/log_collector/readme.md
 delete mode 100644 mmsegmentation/.dev_scripts/log_collector/utils.py
 delete mode 100755 mmsegmentation/.dev_scripts/update_model_index.py
 delete mode 100644 mmsegmentation/.dev_scripts/upload_modelzoo.py
 delete mode 100644 mmsegmentation/.github/CODE_OF_CONDUCT.md
 delete mode 100644 mmsegmentation/.github/CONTRIBUTING.md
 delete mode 100644 mmsegmentation/.github/ISSUE_TEMPLATE/config.yml
 delete mode 100644 mmsegmentation/.github/ISSUE_TEMPLATE/error-report.md
 delete mode 100644 mmsegmentation/.github/ISSUE_TEMPLATE/feature_request.md
 delete mode 100644 mmsegmentation/.github/ISSUE_TEMPLATE/general_questions.md
 delete mode 100644 mmsegmentation/.github/ISSUE_TEMPLATE/reimplementation_questions.md
 delete mode 100644 mmsegmentation/.github/pull_request_template.md
 delete mode 100644 mmsegmentation/.github/workflows/deploy.yml
 delete mode 100644 mmsegmentation/.gitignore
 delete mode 100644 mmsegmentation/.owners.yml
 delete mode 100644 mmsegmentation/.pre-commit-config.yaml
 delete mode 100644 mmsegmentation/CITATION.cff
 delete mode 100644 mmsegmentation/LICENSE
 delete mode 100644 mmsegmentation/MANIFEST.in
 delete mode 100644 mmsegmentation/README.md
 delete mode 100644 mmsegmentation/README_zh-CN.md
 delete mode 100644 mmsegmentation/configs/ann/README.md
 delete mode 100644 mmsegmentation/configs/ann/ann_r101-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/ann/ann_r101-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/ann/ann_r101-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/ann/ann_r101-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/ann/ann_r101-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/ann/ann_r101-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/ann/ann_r101-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/ann/ann_r101-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/ann/ann_r50-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/ann/ann_r50-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/ann/ann_r50-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/ann/ann_r50-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/ann/ann_r50-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/ann/ann_r50-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/ann/ann_r50-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/ann/ann_r50-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/ann/metafile.yaml
 delete mode 100644 mmsegmentation/configs/apcnet/README.md
 delete mode 100644 mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/apcnet/metafile.yaml
 delete mode 100644 mmsegmentation/configs/beit/README.md
 delete mode 100644 mmsegmentation/configs/beit/beit-base_upernet_8xb2-160k_ade20k-640x640.py
 delete mode 100644 mmsegmentation/configs/beit/beit-base_upernet_8xb2-160k_ade20k-640x640_ms.py
 delete mode 100644 mmsegmentation/configs/beit/beit-large_upernet_8xb1-amp-160k_ade20k-640x640.py
 delete mode 100644 mmsegmentation/configs/beit/beit-large_upernet_8xb1-amp-160k_ade20k-640x640_ms.py
 delete mode 100644 mmsegmentation/configs/beit/metafile.yaml
 delete mode 100644 mmsegmentation/configs/bisenetv1/README.md
 delete mode 100644 mmsegmentation/configs/bisenetv1/bisenetv1_r101-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
 delete mode 100644 mmsegmentation/configs/bisenetv1/bisenetv1_r101-d32_4xb4-160k_coco-stuff164k-512x512.py
 delete mode 100644 mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py
 delete mode 100644 mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
 delete mode 100644 mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb8-160k_cityscapes-1024x1024.py
 delete mode 100644 mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_cityscapes-1024x1024.py
 delete mode 100644 mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_coco-stuff164k-512x512.py
 delete mode 100644 mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py
 delete mode 100644 mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
 delete mode 100644 mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024.py
 delete mode 100644 mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_coco-stuff164k-512x512.py
 delete mode 100644 mmsegmentation/configs/bisenetv1/metafile.yaml
 delete mode 100644 mmsegmentation/configs/bisenetv2/README.md
 delete mode 100644 mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-160k_cityscapes-1024x1024.py
 delete mode 100644 mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024.py
 delete mode 100644 mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-ohem-160k_cityscapes-1024x1024.py
 delete mode 100644 mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb8-160k_cityscapes-1024x1024.py
 delete mode 100644 mmsegmentation/configs/bisenetv2/metafile.yaml
 delete mode 100644 mmsegmentation/configs/ccnet/README.md
 delete mode 100644 mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/ccnet/metafile.yaml
 delete mode 100644 mmsegmentation/configs/cgnet/README.md
 delete mode 100644 mmsegmentation/configs/cgnet/cgnet_fcn_4xb4-60k_cityscapes-680x680.py
 delete mode 100644 mmsegmentation/configs/cgnet/cgnet_fcn_4xb8-60k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/cgnet/metafile.yaml
 delete mode 100644 mmsegmentation/configs/convnext/README.md
 delete mode 100644 mmsegmentation/configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-640x640.py
 delete mode 100644 mmsegmentation/configs/convnext/convnext-large_upernet_8xb2-amp-160k_ade20k-640x640.py
 delete mode 100644 mmsegmentation/configs/convnext/convnext-small_upernet_8xb2-amp-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/convnext/convnext-tiny_upernet_8xb2-amp-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/convnext/convnext-xlarge_upernet_8xb2-amp-160k_ade20k-640x640.py
 delete mode 100644 mmsegmentation/configs/convnext/metafile.yaml
 delete mode 100644 mmsegmentation/configs/danet/README.md
 delete mode 100644 mmsegmentation/configs/danet/danet_r101-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/danet/danet_r101-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/danet/danet_r101-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/danet/danet_r101-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/danet/danet_r101-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/danet/danet_r101-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/danet/danet_r101-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/danet/danet_r101-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/danet/danet_r50-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/danet/danet_r50-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/danet/danet_r50-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/danet/danet_r50-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/danet/danet_r50-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/danet/danet_r50-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/danet/danet_r50-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/danet/danet_r50-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/danet/metafile.yaml
 delete mode 100644 mmsegmentation/configs/ddrnet/README.md
 delete mode 100644 mmsegmentation/configs/ddrnet/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024.py
 delete mode 100644 mmsegmentation/configs/ddrnet/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024.py
 delete mode 100644 mmsegmentation/configs/ddrnet/metafile.yaml
 delete mode 100644 mmsegmentation/configs/deeplabv3/README.md
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_coco-stuff164k-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_coco-stuff10k-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-320k_coco-stuff164k-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_coco-stuff10k-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-480x480.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-59-480x480.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_coco-stuff164k-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-480x480.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-59-480x480.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_coco-stuff164k-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_coco-stuff10k-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-320k_coco-stuff164k-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_coco-stuff10k-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_pascal-context-480x480.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_pascal-context-59-480x480.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_coco-stuff164k-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_pascal-context-480x480.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_pascal-context-59-480x480.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/deeplabv3/metafile.yaml
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/README.md
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_pascal-context-480x480.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_pascal-context-59-480x480.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_loveda-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_pascal-context-480x480.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_pascal-context-59-480x480.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_vaihingen-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_isaid-896x896.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_loveda-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_potsdam-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_vaihingen-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_pascal-context-480x480.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_pascal-context-59-480x480.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_isaid-896x896.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_loveda-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_pascal-context-480x480.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_pascal-context-59-480x480.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_potsdam-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_vaihingen-512x512.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/deeplabv3plus/metafile.yaml
 delete mode 100644 mmsegmentation/configs/dmnet/README.md
 delete mode 100644 mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/dmnet/metafile.yaml
 delete mode 100644 mmsegmentation/configs/dnlnet/README.md
 delete mode 100644 mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/dnlnet/metafile.yaml
 delete mode 100644 mmsegmentation/configs/dpt/README.md
 delete mode 100644 mmsegmentation/configs/dpt/dpt_vit-b16_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/dpt/metafile.yaml
 delete mode 100644 mmsegmentation/configs/dsdl/README.md
 delete mode 100644 mmsegmentation/configs/dsdl/cityscapes.py
 delete mode 100644 mmsegmentation/configs/dsdl/voc.py
 delete mode 100644 mmsegmentation/configs/emanet/README.md
 delete mode 100644 mmsegmentation/configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/emanet/emanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/emanet/emanet_r50-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/emanet/metafile.yaml
 delete mode 100644 mmsegmentation/configs/encnet/README.md
 delete mode 100644 mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/encnet/encnet_r50s-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/encnet/metafile.yaml
 delete mode 100644 mmsegmentation/configs/erfnet/README.md
 delete mode 100644 mmsegmentation/configs/erfnet/erfnet_fcn_4xb4-160k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/erfnet/metafile.yaml
 delete mode 100644 mmsegmentation/configs/fastfcn/README.md
 delete mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/fastfcn/metafile.yaml
 delete mode 100644 mmsegmentation/configs/fastscnn/README.md
 delete mode 100644 mmsegmentation/configs/fastscnn/fast_scnn_8xb4-160k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/fastscnn/metafile.yaml
 delete mode 100644 mmsegmentation/configs/fcn/README.md
 delete mode 100644 mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-480x480.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-59-480x480.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-480x480.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-59-480x480.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_pascal-context-480x480.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_pascal-context-59-480x480.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_pascal-context-480x480.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_pascal-context-59-480x480.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/fcn/metafile.yaml
 delete mode 100644 mmsegmentation/configs/gcnet/README.md
 delete mode 100644 mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/gcnet/metafile.yaml
 delete mode 100644 mmsegmentation/configs/hrnet/README.md
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb2-160k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_pascal-context-480x480.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_pascal-context-59-480x480.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_isaid-896x896.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_loveda-512x512.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_pascal-context-480x480.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_pascal-context-59-480x480.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_potsdam-512x512.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_vaihingen-512x512.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-160k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_pascal-context-480x480.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_pascal-context-59-480x480.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_isaid-896x896.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_loveda-512x512.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_pascal-context-480x480.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_pascal-context-59-480x480.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_potsdam-512x512.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_vaihingen-512x512.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb2-160k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-480x480.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-59-480x480.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_isaid-896x896.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_loveda-512x512.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-480x480.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-59-480x480.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_potsdam-512x512.py
 delete mode 100644 mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_vaihingen-512x512.py
 delete mode 100644 mmsegmentation/configs/hrnet/metafile.yaml
 delete mode 100644 mmsegmentation/configs/icnet/README.md
 delete mode 100644 mmsegmentation/configs/icnet/icnet_r101-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
 delete mode 100644 mmsegmentation/configs/icnet/icnet_r101-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
 delete mode 100644 mmsegmentation/configs/icnet/icnet_r101-d8_4xb2-160k_cityscapes-832x832.py
 delete mode 100644 mmsegmentation/configs/icnet/icnet_r101-d8_4xb2-80k_cityscapes-832x832.py
 delete mode 100644 mmsegmentation/configs/icnet/icnet_r18-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
 delete mode 100644 mmsegmentation/configs/icnet/icnet_r18-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
 delete mode 100644 mmsegmentation/configs/icnet/icnet_r18-d8_4xb2-160k_cityscapes-832x832.py
 delete mode 100644 mmsegmentation/configs/icnet/icnet_r18-d8_4xb2-80k_cityscapes-832x832.py
 delete mode 100644 mmsegmentation/configs/icnet/icnet_r50-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
 delete mode 100644 mmsegmentation/configs/icnet/icnet_r50-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
 delete mode 100644 mmsegmentation/configs/icnet/icnet_r50-d8_4xb2-160k_cityscapes-832x832.py
 delete mode 100644 mmsegmentation/configs/icnet/icnet_r50-d8_4xb2-80k_cityscapes-832x832.py
 delete mode 100644 mmsegmentation/configs/icnet/metafile.yaml
 delete mode 100644 mmsegmentation/configs/isanet/README.md
 delete mode 100644 mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/isanet/metafile.yaml
 delete mode 100644 mmsegmentation/configs/knet/README.md
 delete mode 100644 mmsegmentation/configs/knet/knet-s3_r50-d8_deeplabv3_8xb2-adamw-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/knet/knet-s3_r50-d8_fcn_8xb2-adamw-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/knet/knet-s3_r50-d8_pspnet_8xb2-adamw-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/knet/knet-s3_r50-d8_upernet_8xb2-adamw-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-640x640.py
 delete mode 100644 mmsegmentation/configs/knet/knet-s3_swin-t_upernet_8xb2-adamw-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/knet/metafile.yaml
 delete mode 100644 mmsegmentation/configs/mae/README.md
 delete mode 100644 mmsegmentation/configs/mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512-ms.py
 delete mode 100644 mmsegmentation/configs/mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/mae/metafile.yaml
 delete mode 100644 mmsegmentation/configs/mask2former/README.md
 delete mode 100644 mmsegmentation/configs/mask2former/mask2former_r101_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/mask2former/mask2former_r101_8xb2-90k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/mask2former/mask2former_r50_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/mask2former/mask2former_r50_8xb2-90k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/mask2former/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640.py
 delete mode 100644 mmsegmentation/configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py
 delete mode 100644 mmsegmentation/configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py
 delete mode 100644 mmsegmentation/configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/mask2former/mask2former_swin-s_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/mask2former/mask2former_swin-s_8xb2-90k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/mask2former/mask2former_swin-t_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/mask2former/mask2former_swin-t_8xb2-90k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/mask2former/metafile.yaml
 delete mode 100644 mmsegmentation/configs/maskformer/README.md
 delete mode 100644 mmsegmentation/configs/maskformer/maskformer_r101-d32_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/maskformer/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/maskformer/metafile.yaml
 delete mode 100644 mmsegmentation/configs/mobilenet_v2/README.md
 delete mode 100644 mmsegmentation/configs/mobilenet_v2/metafile.yaml
 delete mode 100644 mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/mobilenet_v3/README.md
 delete mode 100644 mmsegmentation/configs/mobilenet_v3/metafile.yaml
 delete mode 100644 mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-s_lraspp_4xb4-320k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-scratch-s_lraspp_4xb4-320k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-scratch_lraspp_4xb4-320k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8_lraspp_4xb4-320k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/nonlocal_net/README.md
 delete mode 100644 mmsegmentation/configs/nonlocal_net/metafile.yaml
 delete mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/ocrnet/README.md
 delete mode 100644 mmsegmentation/configs/ocrnet/metafile.yaml
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-160k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-160k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-160k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_r101-d8_8xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/ocrnet/ocrnet_r101-d8_8xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/pidnet/README.md
 delete mode 100644 mmsegmentation/configs/pidnet/metafile.yaml
 delete mode 100644 mmsegmentation/configs/pidnet/pidnet-l_2xb6-120k_1024x1024-cityscapes.py
 delete mode 100644 mmsegmentation/configs/pidnet/pidnet-m_2xb6-120k_1024x1024-cityscapes.py
 delete mode 100644 mmsegmentation/configs/pidnet/pidnet-s_2xb6-120k_1024x1024-cityscapes.py
 delete mode 100644 mmsegmentation/configs/point_rend/README.md
 delete mode 100644 mmsegmentation/configs/point_rend/metafile.yaml
 delete mode 100644 mmsegmentation/configs/point_rend/pointrend_r101_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/point_rend/pointrend_r101_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/point_rend/pointrend_r50_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/point_rend/pointrend_r50_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/poolformer/README.md
 delete mode 100644 mmsegmentation/configs/poolformer/fpn_poolformer_m36_8xb4-40k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/poolformer/fpn_poolformer_m48_8xb4-40k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/poolformer/fpn_poolformer_s12_8xb4-40k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/poolformer/fpn_poolformer_s24_8xb4-40k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/poolformer/fpn_poolformer_s36_8x4_512x512_40k_ade20k.py
 delete mode 100644 mmsegmentation/configs/poolformer/metafile.yaml
 delete mode 100644 mmsegmentation/configs/psanet/README.md
 delete mode 100644 mmsegmentation/configs/psanet/metafile.yaml
 delete mode 100644 mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/README.md
 delete mode 100644 mmsegmentation/configs/pspnet/metafile.yaml
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024_dark-zurich-1920x1080.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024_night-driving-1920x1080.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-160k_coco-stuff164k-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-20k_coco-stuff10k-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-320k_coco-stuff164k-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_coco-stuff10k-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-480x480.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-59-480x480.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_coco-stuff164k-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_loveda-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-480x480.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-59-480x480.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_potsdam-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_vaihingen-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024_dark-zurich-1920x1080.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024_night-driving-1920x1080.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_isaid-896x896.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_loveda-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_potsdam-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_vaihingen-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d32_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d32_rsb_4xb2-adamw-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8-rsb_4xb2-adamw-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_dark-zurich-1920x1080.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_night-driving-1920x1080.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024_dark-zurich-1920x1080.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024_night-driving-1920x1080.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-160k_coco-stuff164k-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-20k_coco-stuff10k-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-320k_coco-stuff164k-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_coco-stuff10k-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_pascal-context-480x480.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_pascal-context-59-480x480.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_coco-stuff164k-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_isaid-896x896.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_loveda-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_pascal-context-480x480.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_pascal-context-59-480x480.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_potsdam-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_vaihingen-512x512.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50b-d32_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/resnest/README.md
 delete mode 100644 mmsegmentation/configs/resnest/metafile.yaml
 delete mode 100644 mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/resnest/resnest_s101-d8_fcn_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/resnest/resnest_s101-d8_fcn_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/resnest/resnest_s101-d8_pspnet_4xb2-80k_cityscapes512x1024.py
 delete mode 100644 mmsegmentation/configs/resnest/resnest_s101-d8_pspnet_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/san/README.md
 delete mode 100644 mmsegmentation/configs/san/metafile.yaml
 delete mode 100644 mmsegmentation/configs/san/san-vit-b16_coco-stuff164k-640x640.py
 delete mode 100644 mmsegmentation/configs/san/san-vit-b16_pascal_context-640x640.py
 delete mode 100644 mmsegmentation/configs/san/san-vit-b16_voc12aug-640x640.py
 delete mode 100644 mmsegmentation/configs/san/san-vit-l14_coco-stuff164k-640x640.py
 delete mode 100644 mmsegmentation/configs/san/san-vit-l14_pascal_context-640x640.py
 delete mode 100644 mmsegmentation/configs/san/san-vit-l14_voc12aug-640x640.py
 delete mode 100644 mmsegmentation/configs/segformer/README.md
 delete mode 100644 mmsegmentation/configs/segformer/metafile.yaml
 delete mode 100644 mmsegmentation/configs/segformer/segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py
 delete mode 100644 mmsegmentation/configs/segformer/segformer_mit-b0_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/segformer/segformer_mit-b1_8xb1-160k_cityscapes-1024x1024.py
 delete mode 100644 mmsegmentation/configs/segformer/segformer_mit-b1_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/segformer/segformer_mit-b2_8xb1-160k_cityscapes-1024x1024.py
 delete mode 100644 mmsegmentation/configs/segformer/segformer_mit-b2_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/segformer/segformer_mit-b3_8xb1-160k_cityscapes-1024x1024.py
 delete mode 100644 mmsegmentation/configs/segformer/segformer_mit-b3_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/segformer/segformer_mit-b4_8xb1-160k_cityscapes-1024x1024.py
 delete mode 100644 mmsegmentation/configs/segformer/segformer_mit-b4_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/segformer/segformer_mit-b5_8xb1-160k_cityscapes-1024x1024.py
 delete mode 100644 mmsegmentation/configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-640x640.py
 delete mode 100644 mmsegmentation/configs/segmenter/README.md
 delete mode 100644 mmsegmentation/configs/segmenter/metafile.yaml
 delete mode 100644 mmsegmentation/configs/segmenter/segmenter_vit-b_mask_8xb1-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/segmenter/segmenter_vit-l_mask_8xb1-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/segmenter/segmenter_vit-s_fcn_8xb1-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/segmenter/segmenter_vit-s_mask_8xb1-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/segmenter/segmenter_vit-t_mask_8xb1-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/segnext/README.md
 delete mode 100644 mmsegmentation/configs/segnext/metafile.yaml
 delete mode 100644 mmsegmentation/configs/segnext/segnext_mscan-b_1xb16-adamw-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/segnext/segnext_mscan-l_1xb16-adamw-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/segnext/segnext_mscan-s_1xb16-adamw-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/segnext/segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/sem_fpn/README.md
 delete mode 100644 mmsegmentation/configs/sem_fpn/fpn_r101_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/sem_fpn/fpn_r101_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/sem_fpn/fpn_r50_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/sem_fpn/fpn_r50_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/sem_fpn/metafile.yaml
 delete mode 100644 mmsegmentation/configs/setr/README.md
 delete mode 100644 mmsegmentation/configs/setr/metafile.yaml
 delete mode 100644 mmsegmentation/configs/setr/setr_vit-l-mla_8xb1-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/setr/setr_vit-l_mla_8xb1-80k_cityscapes-768x768.py
 delete mode 100644 mmsegmentation/configs/setr/setr_vit-l_mla_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/setr/setr_vit-l_naive_8xb1-80k_cityscapes-768x768.py
 delete mode 100644 mmsegmentation/configs/setr/setr_vit-l_naive_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/setr/setr_vit-l_pup_8xb1-80k_cityscapes-768x768.py
 delete mode 100644 mmsegmentation/configs/setr/setr_vit-l_pup_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/stdc/README.md
 delete mode 100644 mmsegmentation/configs/stdc/metafile.yaml
 delete mode 100644 mmsegmentation/configs/stdc/stdc1_4xb12-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/stdc/stdc1_in1k-pre_4xb12-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/stdc/stdc2_4xb12-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/stdc/stdc2_in1k-pre_4xb12-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/swin/README.md
 delete mode 100644 mmsegmentation/configs/swin/metafile.yaml
 delete mode 100644 mmsegmentation/configs/swin/swin-base-patch4-window12-in1k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/swin/swin-base-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/swin/swin-base-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/swin/swin-base-patch4-window7-in22k-pre_upernet_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/swin/swin-large-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/swin/swin-large-patch4-window7-in22k-pre_upernet_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/swin/swin-small-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/swin/swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/swin/swin-tiny-patch4-window7_upernet_1xb8-20k_levir-256x256.py
 delete mode 100644 mmsegmentation/configs/twins/README.md
 delete mode 100644 mmsegmentation/configs/twins/metafile.yaml
 delete mode 100644 mmsegmentation/configs/twins/twins_pcpvt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/twins/twins_pcpvt-b_uperhead_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/twins/twins_pcpvt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/twins/twins_pcpvt-l_uperhead_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/twins/twins_pcpvt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/twins/twins_pcpvt-s_uperhead_8xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/twins/twins_svt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/twins/twins_svt-b_uperhead_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/twins/twins_svt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/twins/twins_svt-l_uperhead_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/twins/twins_svt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/twins/twins_svt-s_uperhead_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/unet/README.md
 delete mode 100644 mmsegmentation/configs/unet/metafile.yaml
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_drive-64x64.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_hrf-256x256.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_stare-128x128.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-160k_hsidrive-192x384.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_chase-db1-128x128.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_drive-64x64.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_hrf-256x256.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_stare-128x128.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_chase-db1-128x128.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_drive-64x64.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_hrf-256x256.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_stare-128x128.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
 delete mode 100644 mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
 delete mode 100644 mmsegmentation/configs/unet/unet_s5-d16_deeplabv3_4xb4-40k_chase-db1-128x128.py
 delete mode 100644 mmsegmentation/configs/upernet/README.md
 delete mode 100644 mmsegmentation/configs/upernet/metafile.yaml
 delete mode 100644 mmsegmentation/configs/upernet/upernet_r101_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/upernet/upernet_r101_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/upernet/upernet_r101_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/upernet/upernet_r101_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/upernet/upernet_r101_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/upernet/upernet_r101_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/upernet/upernet_r101_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/upernet/upernet_r101_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/upernet/upernet_r18_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/upernet/upernet_r18_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/upernet/upernet_r18_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/upernet/upernet_r18_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/upernet/upernet_r18_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/upernet/upernet_r18_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/upernet/upernet_r50_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/upernet/upernet_r50_4xb2-40k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/upernet/upernet_r50_4xb2-80k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/configs/upernet/upernet_r50_4xb2-80k_cityscapes-769x769.py
 delete mode 100644 mmsegmentation/configs/upernet/upernet_r50_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/upernet/upernet_r50_4xb4-20k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/upernet/upernet_r50_4xb4-40k_voc12aug-512x512.py
 delete mode 100644 mmsegmentation/configs/upernet/upernet_r50_4xb4-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/vit/README.md
 delete mode 100644 mmsegmentation/configs/vit/metafile.yaml
 delete mode 100644 mmsegmentation/configs/vit/vit_deit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/vit/vit_deit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/vit/vit_deit-b16_upernet_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/vit/vit_deit-b16_upernet_8xb2-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/vit/vit_deit-s16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/vit/vit_deit-s16_mln_upernet_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/vit/vit_deit-s16_upernet_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/vit/vit_deit-s16_upernet_8xb2-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/vit/vit_vit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/vit/vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/vit/vit_vit-b16_mln_upernet_8xb2-80k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/configs/vpd/README.md
 delete mode 100644 mmsegmentation/configs/vpd/metafile.yaml
 delete mode 100644 mmsegmentation/configs/vpd/vpd_sd_4xb8-25k_nyu-480x480.py
 delete mode 100644 mmsegmentation/configs/vpd/vpd_sd_4xb8-25k_nyu-512x512.py
 delete mode 100644 mmsegmentation/dataset-index.yml
 delete mode 100644 mmsegmentation/demo/MMSegmentation_Tutorial.ipynb
 delete mode 100644 mmsegmentation/demo/image_demo.py
 delete mode 100644 mmsegmentation/demo/image_demo_with_inferencer.py
 delete mode 100644 mmsegmentation/demo/inference_demo.ipynb
 delete mode 100644 mmsegmentation/demo/rs_image_inference.py
 delete mode 100644 mmsegmentation/demo/video_demo.py
 delete mode 100644 mmsegmentation/docker/Dockerfile
 delete mode 100644 mmsegmentation/docker/serve/Dockerfile
 delete mode 100644 mmsegmentation/docker/serve/config.properties
 delete mode 100644 mmsegmentation/docker/serve/entrypoint.sh
 delete mode 100644 mmsegmentation/docs/en/.readthedocs.yaml
 delete mode 100644 mmsegmentation/docs/en/Makefile
 delete mode 100644 mmsegmentation/docs/en/_static/css/readthedocs.css
 delete mode 100644 mmsegmentation/docs/en/advanced_guides/add_datasets.md
 delete mode 100644 mmsegmentation/docs/en/advanced_guides/add_metrics.md
 delete mode 100644 mmsegmentation/docs/en/advanced_guides/add_models.md
 delete mode 100644 mmsegmentation/docs/en/advanced_guides/add_transforms.md
 delete mode 100644 mmsegmentation/docs/en/advanced_guides/customize_runtime.md
 delete mode 100644 mmsegmentation/docs/en/advanced_guides/data_flow.md
 delete mode 100644 mmsegmentation/docs/en/advanced_guides/datasets.md
 delete mode 100644 mmsegmentation/docs/en/advanced_guides/engine.md
 delete mode 100644 mmsegmentation/docs/en/advanced_guides/evaluation.md
 delete mode 100644 mmsegmentation/docs/en/advanced_guides/index.rst
 delete mode 100644 mmsegmentation/docs/en/advanced_guides/models.md
 delete mode 100644 mmsegmentation/docs/en/advanced_guides/structures.md
 delete mode 100644 mmsegmentation/docs/en/advanced_guides/training_tricks.md
 delete mode 100644 mmsegmentation/docs/en/advanced_guides/transforms.md
 delete mode 100644 mmsegmentation/docs/en/api.rst
 delete mode 100644 mmsegmentation/docs/en/conf.py
 delete mode 100644 mmsegmentation/docs/en/device/npu.md
 delete mode 100644 mmsegmentation/docs/en/get_started.md
 delete mode 100644 mmsegmentation/docs/en/index.rst
 delete mode 100644 mmsegmentation/docs/en/make.bat
 delete mode 100644 mmsegmentation/docs/en/migration/index.rst
 delete mode 100644 mmsegmentation/docs/en/migration/interface.md
 delete mode 100644 mmsegmentation/docs/en/migration/package.md
 delete mode 100644 mmsegmentation/docs/en/model_zoo.md
 delete mode 100644 mmsegmentation/docs/en/modelzoo_statistics.md
 delete mode 100644 mmsegmentation/docs/en/notes/changelog.md
 delete mode 100644 mmsegmentation/docs/en/notes/changelog_v0.x.md
 delete mode 100644 mmsegmentation/docs/en/notes/faq.md
 delete mode 100644 mmsegmentation/docs/en/overview.md
 delete mode 100755 mmsegmentation/docs/en/stat.py
 delete mode 100644 mmsegmentation/docs/en/switch_language.md
 delete mode 100644 mmsegmentation/docs/en/user_guides/1_config.md
 delete mode 100644 mmsegmentation/docs/en/user_guides/2_dataset_prepare.md
 delete mode 100644 mmsegmentation/docs/en/user_guides/3_inference.md
 delete mode 100644 mmsegmentation/docs/en/user_guides/4_train_test.md
 delete mode 100644 mmsegmentation/docs/en/user_guides/5_deployment.md
 delete mode 100644 mmsegmentation/docs/en/user_guides/index.rst
 delete mode 100644 mmsegmentation/docs/en/user_guides/useful_tools.md
 delete mode 100644 mmsegmentation/docs/en/user_guides/visualization.md
 delete mode 100644 mmsegmentation/docs/en/user_guides/visualization_feature_map.md
 delete mode 100644 mmsegmentation/docs/zh_cn/.readthedocs.yaml
 delete mode 100644 mmsegmentation/docs/zh_cn/Makefile
 delete mode 100644 mmsegmentation/docs/zh_cn/_static/css/readthedocs.css
 delete mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/add_datasets.md
 delete mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/add_metrics.md
 delete mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/add_models.md
 delete mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/add_transforms.md
 delete mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/contribute_dataset.md
 delete mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/customize_runtime.md
 delete mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/data_flow.md
 delete mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/datasets.md
 delete mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/engine.md
 delete mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/evaluation.md
 delete mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/index.rst
 delete mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/models.md
 delete mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/structures.md
 delete mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/training_tricks.md
 delete mode 100644 mmsegmentation/docs/zh_cn/advanced_guides/transforms.md
 delete mode 100644 mmsegmentation/docs/zh_cn/api.rst
 delete mode 100644 mmsegmentation/docs/zh_cn/conf.py
 delete mode 100644 mmsegmentation/docs/zh_cn/device/npu.md
 delete mode 100644 mmsegmentation/docs/zh_cn/get_started.md
 delete mode 100644 mmsegmentation/docs/zh_cn/index.rst
 delete mode 100644 mmsegmentation/docs/zh_cn/make.bat
 delete mode 100644 mmsegmentation/docs/zh_cn/migration/index.rst
 delete mode 100644 mmsegmentation/docs/zh_cn/migration/interface.md
 delete mode 100644 mmsegmentation/docs/zh_cn/migration/package.md
 delete mode 100644 mmsegmentation/docs/zh_cn/model_zoo.md
 delete mode 100644 mmsegmentation/docs/zh_cn/modelzoo_statistics.md
 delete mode 100644 mmsegmentation/docs/zh_cn/notes/faq.md
 delete mode 100644 mmsegmentation/docs/zh_cn/overview.md
 delete mode 100755 mmsegmentation/docs/zh_cn/stat.py
 delete mode 100644 mmsegmentation/docs/zh_cn/switch_language.md
 delete mode 100644 mmsegmentation/docs/zh_cn/user_guides/1_config.md
 delete mode 100644 mmsegmentation/docs/zh_cn/user_guides/2_dataset_prepare.md
 delete mode 100644 mmsegmentation/docs/zh_cn/user_guides/3_inference.md
 delete mode 100644 mmsegmentation/docs/zh_cn/user_guides/4_train_test.md
 delete mode 100644 mmsegmentation/docs/zh_cn/user_guides/5_deployment.md
 delete mode 100644 mmsegmentation/docs/zh_cn/user_guides/deploy_jetson.md
 delete mode 100644 mmsegmentation/docs/zh_cn/user_guides/index.rst
 delete mode 100644 mmsegmentation/docs/zh_cn/user_guides/useful_tools.md
 delete mode 100644 mmsegmentation/docs/zh_cn/user_guides/visualization.md
 delete mode 100644 mmsegmentation/docs/zh_cn/user_guides/visualization_feature_map.md
 delete mode 100644 mmsegmentation/mmseg/apis/__init__.py
 delete mode 100644 mmsegmentation/mmseg/apis/inference.py
 delete mode 100644 mmsegmentation/mmseg/apis/mmseg_inferencer.py
 delete mode 100644 mmsegmentation/mmseg/apis/remote_sense_inferencer.py
 delete mode 100644 mmsegmentation/mmseg/apis/utils.py
 delete mode 100644 mmsegmentation/mmseg/configs/_base_/datasets/loveda.py
 delete mode 100644 mmsegmentation/mmseg/configs/_base_/datasets/potsdam.py
 delete mode 100644 mmsegmentation/mmseg/configs/_base_/default_runtime.py
 delete mode 100644 mmsegmentation/mmseg/configs/_base_/schedules/schedule_160k.py
 delete mode 100644 mmsegmentation/mmseg/configs/_base_/schedules/schedule_20k.py
 delete mode 100644 mmsegmentation/mmseg/configs/_base_/schedules/schedule_240k.py
 delete mode 100644 mmsegmentation/mmseg/configs/_base_/schedules/schedule_25k.py
 delete mode 100644 mmsegmentation/mmseg/configs/_base_/schedules/schedule_320k.py
 delete mode 100644 mmsegmentation/mmseg/configs/_base_/schedules/schedule_40k.py
 delete mode 100644 mmsegmentation/mmseg/configs/_base_/schedules/schedule_80k.py
 delete mode 100644 mmsegmentation/mmseg/datasets/ade.py
 delete mode 100644 mmsegmentation/mmseg/datasets/basesegdataset.py
 delete mode 100644 mmsegmentation/mmseg/datasets/bdd100k.py
 delete mode 100644 mmsegmentation/mmseg/datasets/chase_db1.py
 delete mode 100644 mmsegmentation/mmseg/datasets/cityscapes.py
 delete mode 100644 mmsegmentation/mmseg/datasets/coco_stuff.py
 delete mode 100644 mmsegmentation/mmseg/datasets/dark_zurich.py
 delete mode 100644 mmsegmentation/mmseg/datasets/dataset_wrappers.py
 delete mode 100644 mmsegmentation/mmseg/datasets/decathlon.py
 delete mode 100644 mmsegmentation/mmseg/datasets/drive.py
 delete mode 100644 mmsegmentation/mmseg/datasets/dsdl.py
 delete mode 100644 mmsegmentation/mmseg/datasets/hrf.py
 delete mode 100644 mmsegmentation/mmseg/datasets/hsi_drive.py
 delete mode 100644 mmsegmentation/mmseg/datasets/isaid.py
 delete mode 100644 mmsegmentation/mmseg/datasets/isprs.py
 delete mode 100644 mmsegmentation/mmseg/datasets/levir.py
 delete mode 100644 mmsegmentation/mmseg/datasets/lip.py
 delete mode 100644 mmsegmentation/mmseg/datasets/loveda.py
 delete mode 100644 mmsegmentation/mmseg/datasets/mapillary.py
 delete mode 100644 mmsegmentation/mmseg/datasets/night_driving.py
 delete mode 100644 mmsegmentation/mmseg/datasets/nyu.py
 delete mode 100644 mmsegmentation/mmseg/datasets/pascal_context.py
 delete mode 100644 mmsegmentation/mmseg/datasets/potsdam.py
 delete mode 100644 mmsegmentation/mmseg/datasets/refuge.py
 delete mode 100644 mmsegmentation/mmseg/datasets/stare.py
 delete mode 100644 mmsegmentation/mmseg/datasets/synapse.py
 delete mode 100644 mmsegmentation/mmseg/datasets/voc.py
 delete mode 100644 mmsegmentation/mmseg/engine/__init__.py
 delete mode 100644 mmsegmentation/mmseg/engine/hooks/__init__.py
 delete mode 100644 mmsegmentation/mmseg/engine/hooks/visualization_hook.py
 delete mode 100644 mmsegmentation/mmseg/engine/optimizers/__init__.py
 delete mode 100644 mmsegmentation/mmseg/engine/optimizers/force_default_constructor.py
 delete mode 100644 mmsegmentation/mmseg/engine/optimizers/layer_decay_optimizer_constructor.py
 delete mode 100644 mmsegmentation/mmseg/engine/schedulers/__init__.py
 delete mode 100644 mmsegmentation/mmseg/engine/schedulers/poly_ratio_scheduler.py
 delete mode 100644 mmsegmentation/mmseg/registry/__init__.py
 delete mode 100644 mmsegmentation/mmseg/registry/registry.py
 delete mode 100644 mmsegmentation/mmseg/structures/__init__.py
 delete mode 100644 mmsegmentation/mmseg/structures/sampler/__init__.py
 delete mode 100644 mmsegmentation/mmseg/structures/sampler/base_pixel_sampler.py
 delete mode 100644 mmsegmentation/mmseg/structures/sampler/builder.py
 delete mode 100644 mmsegmentation/mmseg/structures/sampler/ohem_pixel_sampler.py
 delete mode 100644 mmsegmentation/mmseg/structures/seg_data_sample.py
 delete mode 100644 mmsegmentation/mmseg/utils/__init__.py
 delete mode 100644 mmsegmentation/mmseg/utils/bpe_simple_vocab_16e6.txt.gz
 delete mode 100644 mmsegmentation/mmseg/utils/class_names.py
 delete mode 100644 mmsegmentation/mmseg/utils/collect_env.py
 delete mode 100644 mmsegmentation/mmseg/utils/get_templates.py
 delete mode 100644 mmsegmentation/mmseg/utils/io.py
 delete mode 100644 mmsegmentation/mmseg/utils/mask_classification.py
 delete mode 100644 mmsegmentation/mmseg/utils/misc.py
 delete mode 100644 mmsegmentation/mmseg/utils/set_env.py
 delete mode 100644 mmsegmentation/mmseg/utils/tokenizer.py
 delete mode 100644 mmsegmentation/mmseg/utils/typing_utils.py
 delete mode 100644 mmsegmentation/mmseg/visualization/__init__.py
 delete mode 100644 mmsegmentation/mmseg/visualization/local_visualizer.py
 delete mode 100644 mmsegmentation/model-index.yml
 delete mode 100644 mmsegmentation/projects/Adabins/README.md
 delete mode 100644 mmsegmentation/projects/Adabins/backbones/__init__.py
 delete mode 100644 mmsegmentation/projects/Adabins/backbones/adabins_backbone.py
 delete mode 100644 mmsegmentation/projects/Adabins/configs/_base_/datasets/nyu.py
 delete mode 100644 mmsegmentation/projects/Adabins/configs/_base_/default_runtime.py
 delete mode 100644 mmsegmentation/projects/Adabins/configs/_base_/models/Adabins.py
 delete mode 100644 mmsegmentation/projects/Adabins/configs/adabins/adabins_efficient_b5_4x16_25e_NYU_416x544.py
 delete mode 100644 mmsegmentation/projects/Adabins/configs/adabins/adabins_efficient_b5_4x16_25e_kitti_352x704.py
 delete mode 100644 mmsegmentation/projects/Adabins/decode_head/__init__.py
 delete mode 100644 mmsegmentation/projects/Adabins/decode_head/adabins_head.py
 delete mode 100644 mmsegmentation/projects/CAT-Seg/README.md
 delete mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/__init__.py
 delete mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/models/__init__.py
 delete mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/models/cat_aggregator.py
 delete mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/models/cat_head.py
 delete mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/models/clip_ovseg.py
 delete mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/utils/__init__.py
 delete mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/utils/bpe_vocab/bpe_simple_vocab_16e6.txt.gz
 delete mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_model.py
 delete mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_templates.py
 delete mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_wrapper.py
 delete mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/utils/self_attention_block.py
 delete mode 100644 mmsegmentation/projects/CAT-Seg/cat_seg/utils/tokenizer.py
 delete mode 100644 mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/ade20k_384x384.py
 delete mode 100644 mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/coco-stuff164k_384x384.py
 delete mode 100644 mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/pascal_context_59_384x384.py
 delete mode 100644 mmsegmentation/projects/CAT-Seg/configs/_base_/default_runtime.py
 delete mode 100644 mmsegmentation/projects/CAT-Seg/configs/_base_/schedules/schedule_80k.py
 delete mode 100644 mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb1-warmcoslr2e-4-adamw-80k_ade20k-384x384.py
 delete mode 100644 mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb1-warmcoslr2e-4-adamw-80k_pascal-context-59-384x384.py
 delete mode 100644 mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb2-warmcoslr2e-4-adamw-80k_coco-stuff164k-384x384.py
 delete mode 100644 mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitg-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py
 delete mode 100644 mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vith-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py
 delete mode 100644 mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitl-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py
 delete mode 100644 mmsegmentation/projects/CAT-Seg/utils/__init__.py
 delete mode 100644 mmsegmentation/projects/README.md
 delete mode 100644 mmsegmentation/projects/XDecoder/README.md
 delete mode 100644 mmsegmentation/projects/bdd100k_dataset/README.md
 delete mode 100644 mmsegmentation/projects/bdd100k_dataset/configs/_base_/datasets/bdd100k.py
 delete mode 100644 mmsegmentation/projects/bdd100k_dataset/configs/pspnet_r50-d8_4xb2-80k_bdd100k-512x1024.py
 delete mode 100644 mmsegmentation/projects/bdd100k_dataset/docs/en/user_guides/2_dataset_prepare.md
 delete mode 100644 mmsegmentation/projects/bdd100k_dataset/docs/zh_cn/user_guides/2_dataset_prepare.md
 delete mode 100644 mmsegmentation/projects/bdd100k_dataset/mmseg/datasets/bdd100k.py
 delete mode 100644 mmsegmentation/projects/example_project/README.md
 delete mode 100644 mmsegmentation/projects/example_project/configs/fcn_dummy-r50-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/projects/example_project/dummy/__init__.py
 delete mode 100644 mmsegmentation/projects/example_project/dummy/dummy_resnet.py
 delete mode 100644 mmsegmentation/projects/faq.md
 delete mode 100644 mmsegmentation/projects/gid_dataset/configs/_base_/datasets/gid.py
 delete mode 100644 mmsegmentation/projects/gid_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_gid-256x256.py
 delete mode 100644 mmsegmentation/projects/gid_dataset/mmseg/datasets/gid.py
 delete mode 100644 mmsegmentation/projects/gid_dataset/tools/dataset_converters/gid.py
 delete mode 100644 mmsegmentation/projects/gid_dataset/tools/dataset_converters/gid_select15imgFromAll.py
 delete mode 100644 mmsegmentation/projects/gid_dataset/user_guides/2_dataset_prepare.md
 delete mode 100644 mmsegmentation/projects/hsidrive20_dataset/README.md
 delete mode 100644 mmsegmentation/projects/hsidrive20_dataset/configs/_base_/datasets/hsi_drive.py
 delete mode 100644 mmsegmentation/projects/hsidrive20_dataset/configs/unet-s5-d16_fcn_4xb4-160k_hsidrive-192x384.py
 delete mode 100644 mmsegmentation/projects/hsidrive20_dataset/docs/en/user_guides/2_dataset_prepare.md
 delete mode 100644 mmsegmentation/projects/hsidrive20_dataset/docs/zh_cn/user_guides/2_dataset_prepare.md
 delete mode 100644 mmsegmentation/projects/hsidrive20_dataset/mmseg/datasets/hsi_drive.py
 delete mode 100644 mmsegmentation/projects/hssn/README.md
 delete mode 100644 mmsegmentation/projects/hssn/configs/_base_/datasets/cityscapes.py
 delete mode 100644 mmsegmentation/projects/hssn/configs/_base_/default_runtime.py
 delete mode 100644 mmsegmentation/projects/hssn/configs/_base_/models/deeplabv3plus_r50-d8_vd_contrast.py
 delete mode 100644 mmsegmentation/projects/hssn/configs/_base_/schedules/schedule_80k.py
 delete mode 100644 mmsegmentation/projects/hssn/configs/hssn/hieraseg_deeplabv3plus_r101-d8_4xb2-80l_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/projects/hssn/decode_head/__init__.py
 delete mode 100644 mmsegmentation/projects/hssn/decode_head/sep_aspp_contrast_head.py
 delete mode 100644 mmsegmentation/projects/hssn/losses/__init__.py
 delete mode 100644 mmsegmentation/projects/hssn/losses/hiera_triplet_loss_cityscape.py
 delete mode 100644 mmsegmentation/projects/hssn/losses/tree_triplet_loss.py
 delete mode 100644 mmsegmentation/projects/isnet/README.md
 delete mode 100644 mmsegmentation/projects/isnet/configs/isnet_r50-d8_8xb2-160k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/projects/isnet/decode_heads/__init__.py
 delete mode 100644 mmsegmentation/projects/isnet/decode_heads/isnet_head.py
 delete mode 100644 mmsegmentation/projects/mapillary_dataset/README.md
 delete mode 100644 mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v1.py
 delete mode 100644 mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v1_65.py
 delete mode 100644 mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v2.py
 delete mode 100644 mmsegmentation/projects/mapillary_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_mapillay_v1-512x1024.py
 delete mode 100644 mmsegmentation/projects/mapillary_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_mapillay_v2-512x1024.py
 delete mode 100644 mmsegmentation/projects/mapillary_dataset/configs/pspnet_r101-d8_4xb2-240k_mapillay_v1-512x1024.py
 delete mode 100644 mmsegmentation/projects/mapillary_dataset/configs/pspnet_r101-d8_4xb2-240k_mapillay_v2-512x1024.py
 delete mode 100644 mmsegmentation/projects/mapillary_dataset/docs/en/user_guides/2_dataset_prepare.md
 delete mode 100644 mmsegmentation/projects/mapillary_dataset/mmseg/datasets/mapillary.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/ct/cranium/README.md
 delete mode 100644 mmsegmentation/projects/medical/2d_image/ct/cranium/configs/cranium_512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_cranium-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_cranium-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_cranium-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_cranium-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/ct/cranium/datasets/cranium_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/ct/cranium/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/README.md
 delete mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_isic2016-task1-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_isic2016-task1-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_isic2016-task1-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/isic2016-task1_512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/datasets/isic2016-task1_dataset.py
 delete mode 100755 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/README.md
 delete mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_isic2017-task1-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_isic2017-task1-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_isic2017-task1-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/isic2017-task1_512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/datasets/isic2017-task1_dataset.py
 delete mode 100755 mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/README.md
 delete mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_kvasir-seg-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_kvasir-seg-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_kvasir-seg-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_kvasir-seg-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/kvasir-seg_512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/datasets/kvasir-seg_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/README.md
 delete mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_kvasir-seg-aliyun-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_kvasir-seg-aliyun-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_kvasir-seg-aliyun-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_kvasir-seg-aliyun-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/kvasir-seg-aliyun_512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/datasets/kvasir-seg-aliyun_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/README.md
 delete mode 100755 mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_vampire-512x512.py
 delete mode 100755 mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_vampire-512x512.py
 delete mode 100755 mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_vampire-512x512.py
 delete mode 100755 mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/vampire_512x512.py
 delete mode 100755 mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/datasets/__init__.py
 delete mode 100755 mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/datasets/vampire_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/README.md
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/dr-hagis_512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_dr-hagis-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_dr-hagis-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_dr-hagis-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/datasets/dr-hagis_dataset.py
 delete mode 100755 mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/README.md
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_gamma3-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_gamma3-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_gamma3-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/gamma3_512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/datasets/gamma3_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/README.md
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_orvs-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_orvs-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_orvs-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/orvs_512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/datasets/orvs_dataset.py
 delete mode 100755 mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/rite/README.md
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_rite-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_rite-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_rite-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_rite-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/rite_512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/rite/datasets/rite_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/fundus_photography/rite/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/README.md
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/breastCancerCellSegmentation_512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_breastCancerCellSegmentation-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_breastCancerCellSegmentation-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_breastCancerCellSegmentation-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/datasets/breastCancerCellSegmentation_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/README.md
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/breast-cancer-cell-seg_512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_breast-cancer-cell-seg-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_breast-cancer-cell-seg-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_breast-cancer-cell-seg-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/datasets/breast-cancer-cell-seg_dataset.py
 delete mode 100755 mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/README.md
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/conic2022-seg_512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_conic2022-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_conic2022-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_conic2022-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/datasets/conic2022-seg_dataset.py
 delete mode 100755 mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/consep/README.md
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/consep_512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_consep-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_consep-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_consep-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/consep/datasets/consep_dataset.py
 delete mode 100755 mmsegmentation/projects/medical/2d_image/histopathology/consep/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/README.md
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_fusc2021-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_fusc2021-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_fusc2021-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_fusc2021-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fusc2021_512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/datasets/fusc2021_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pannuke/README.md
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_bactteria-detection-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_pannuke-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_pannuke-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_pannuke-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/pannuke_512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pannuke/datasets/pannuke_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pannuke/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pcam/README.md
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_pcam-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_pcam-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_pcam-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_pcam-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/pcam_512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pcam/datasets/pcam_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/histopathology/pcam/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/README.md
 delete mode 100755 mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_ravir-512x512.py
 delete mode 100755 mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_ravir-512x512.py
 delete mode 100755 mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_ravir-512x512.py
 delete mode 100755 mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/ravir_512x512.py
 delete mode 100755 mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/datasets/__init__.py
 delete mode 100755 mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/datasets/ravir_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/README.md
 delete mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/2pm-vessel_512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_2pm-vessel-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_2pm-vessel-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_2pm-vessel-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_bactteria-detection-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/datasets/2pm-vessel_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/README.md
 delete mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/bactteria-detection_512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_bactteria-detection-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_bactteria-detection-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_bactteria-detection-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/datasets/bactteria-detection_dataset.py
 delete mode 100755 mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/tools/split_seg_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/README.md
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/chest-image-pneum_512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_chest-image-pneum-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_chest-image-pneum-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_chest-image-pneum-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/datasets/chest-image-pneum_dataset.py
 delete mode 100755 mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/README.md
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/chest-x-ray-images-with-pneumothorax-masks_512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/datasets/chest-x-ray-images-with-pneumothorax-masks_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/README.md
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/covid-19-ct-cxr_512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_covid-19-ct-cxr-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_covid-19-ct-cxr-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_covid-19-ct-cxr-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_covid-19-ct-cxr-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/datasets/covid-19-ct-cxr_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/crass/README.md
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/crass_512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_crass-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_crass-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_crass-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-lr0.01-sigmoid-20k_crass-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/crass/datasets/crass_dataset.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/crass/tools/prepare_dataset.py
 delete mode 100644 mmsegmentation/projects/nvidia_jetson/README.md
 delete mode 100644 mmsegmentation/projects/pp_mobileseg/README.md
 delete mode 100644 mmsegmentation/projects/pp_mobileseg/backbones/__init__.py
 delete mode 100644 mmsegmentation/projects/pp_mobileseg/backbones/strideformer.py
 delete mode 100644 mmsegmentation/projects/pp_mobileseg/configs/_base_/datasets/ade20k.py
 delete mode 100644 mmsegmentation/projects/pp_mobileseg/configs/_base_/default_runtime.py
 delete mode 100644 mmsegmentation/projects/pp_mobileseg/configs/_base_/models/pp_mobile.py
 delete mode 100644 mmsegmentation/projects/pp_mobileseg/configs/_base_/schedules/schedule_80k.py
 delete mode 100644 mmsegmentation/projects/pp_mobileseg/configs/pp_mobileseg/pp_mobileseg_mobilenetv3_2x16_80k_ade20k_512x512_base.py
 delete mode 100644 mmsegmentation/projects/pp_mobileseg/configs/pp_mobileseg/pp_mobileseg_mobilenetv3_2x16_80k_ade20k_512x512_tiny.py
 delete mode 100644 mmsegmentation/projects/pp_mobileseg/decode_head/__init__.py
 delete mode 100644 mmsegmentation/projects/pp_mobileseg/decode_head/pp_mobileseg_head.py
 delete mode 100644 mmsegmentation/projects/pp_mobileseg/inference_onnx.py
 delete mode 100644 mmsegmentation/projects/sam_inference_demo/README.md
 delete mode 100644 mmsegmentation/projects/sam_inference_demo/sam/__init__.py
 delete mode 100644 mmsegmentation/projects/sam_inference_demo/sam/modeling/__init__.py
 delete mode 100644 mmsegmentation/projects/sam_inference_demo/sam/modeling/common.py
 delete mode 100644 mmsegmentation/projects/sam_inference_demo/sam/modeling/mask_decoder.py
 delete mode 100644 mmsegmentation/projects/sam_inference_demo/sam/modeling/prompt_encoder.py
 delete mode 100644 mmsegmentation/projects/sam_inference_demo/sam/modeling/sam.py
 delete mode 100644 mmsegmentation/projects/sam_inference_demo/sam/modeling/transformer.py
 delete mode 100644 mmsegmentation/projects/sam_inference_demo/sam/sam_inferencer.py
 delete mode 100644 mmsegmentation/projects/sam_inference_demo/sam/utils/__init__.py
 delete mode 100644 mmsegmentation/projects/sam_inference_demo/sam/utils/amg.py
 delete mode 100644 mmsegmentation/projects/sam_inference_demo/sam/utils/transforms.py
 delete mode 100644 mmsegmentation/projects/sam_inference_demo/sam_image_demo.ipynb
 delete mode 100644 mmsegmentation/projects/van/README.md
 delete mode 100644 mmsegmentation/projects/van/backbones/__init__.py
 delete mode 100644 mmsegmentation/projects/van/backbones/van.py
 delete mode 100644 mmsegmentation/projects/van/configs/_base_/datasets/ade20k.py
 delete mode 100644 mmsegmentation/projects/van/configs/_base_/models/van_fpn.py
 delete mode 100644 mmsegmentation/projects/van/configs/_base_/models/van_upernet.py
 delete mode 100644 mmsegmentation/projects/van/configs/van/van-b0_fpn_8xb4-40k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/projects/van/configs/van/van-b1_fpn_8xb4-40k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/projects/van/configs/van/van-b2_fpn_8xb4-40k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/projects/van/configs/van/van-b2_upernet_4xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/projects/van/configs/van/van-b3_fpn_8xb4-40k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/projects/van/configs/van/van-b3_upernet_4xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/projects/van/configs/van/van-b4-in22kpre_upernet_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/projects/van/configs/van/van-b4_upernet_4xb4-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/projects/van/configs/van/van-b5-in22kpre_upernet_4xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/projects/van/configs/van/van-b6-in22kpre_upernet_4xb2-160k_ade20k-512x512.py
 delete mode 100644 mmsegmentation/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
 delete mode 100644 mmsegmentation/requirements.txt
 delete mode 100644 mmsegmentation/requirements/albu.txt
 delete mode 100644 mmsegmentation/requirements/docs.txt
 delete mode 100644 mmsegmentation/requirements/mminstall.txt
 delete mode 100644 mmsegmentation/requirements/multimodal.txt
 delete mode 100644 mmsegmentation/requirements/optional.txt
 delete mode 100644 mmsegmentation/requirements/readthedocs.txt
 delete mode 100644 mmsegmentation/requirements/runtime.txt
 delete mode 100644 mmsegmentation/requirements/tests.txt
 delete mode 100644 mmsegmentation/resources/seg_demo.gif
 delete mode 100644 mmsegmentation/setup.cfg
 delete mode 100755 mmsegmentation/setup.py
 delete mode 100644 mmsegmentation/test.ipynb
 delete mode 100644 mmsegmentation/tests/__init__.py
 delete mode 100644 mmsegmentation/tests/test_apis/test_inferencer.py
 delete mode 100644 mmsegmentation/tests/test_apis/test_rs_inferencer.py
 delete mode 100644 mmsegmentation/tests/test_apis/utils.py
 delete mode 100644 mmsegmentation/tests/test_config.py
 delete mode 100644 mmsegmentation/tests/test_datasets/test_dataset.py
 delete mode 100644 mmsegmentation/tests/test_datasets/test_dataset_builder.py
 delete mode 100644 mmsegmentation/tests/test_datasets/test_formatting.py
 delete mode 100644 mmsegmentation/tests/test_datasets/test_loading.py
 delete mode 100644 mmsegmentation/tests/test_datasets/test_transform.py
 delete mode 100644 mmsegmentation/tests/test_datasets/test_tta.py
 delete mode 100644 mmsegmentation/tests/test_digit_version.py
 delete mode 100644 mmsegmentation/tests/test_engine/test_layer_decay_optimizer_constructor.py
 delete mode 100644 mmsegmentation/tests/test_engine/test_optimizer.py
 delete mode 100644 mmsegmentation/tests/test_engine/test_visualization_hook.py
 delete mode 100644 mmsegmentation/tests/test_evaluation/test_metrics/test_citys_metric.py
 delete mode 100644 mmsegmentation/tests/test_evaluation/test_metrics/test_depth_metric.py
 delete mode 100644 mmsegmentation/tests/test_evaluation/test_metrics/test_iou_metric.py
 delete mode 100644 mmsegmentation/tests/test_models/__init__.py
 delete mode 100644 mmsegmentation/tests/test_models/test_assigners/test_hungarian_assigner.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/__init__.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_beit.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_bisenetv1.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_bisenetv2.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_blocks.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_cgnet.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_clip_text_encoder.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_erfnet.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_fast_scnn.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_hrnet.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_icnet.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_mae.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_mit.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_mobilenet_v3.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_mscan.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_pidnet.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_resnest.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_resnet.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_resnext.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_stdc.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_swin.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_timm_backbone.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_twins.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_unet.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_vit.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/test_vpd.py
 delete mode 100644 mmsegmentation/tests/test_models/test_backbones/utils.py
 delete mode 100644 mmsegmentation/tests/test_models/test_data_preprocessor.py
 delete mode 100644 mmsegmentation/tests/test_models/test_forward.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/__init__.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_ann_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_apc_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_aspp_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_cc_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_decode_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_dm_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_dnl_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_dpt_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_ema_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_fcn_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_gc_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_ham_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_isa_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_lraspp_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_mask2former_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_maskformer_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_nl_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_ocr_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_pidnet_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_psa_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_psp_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_san_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_segformer_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_segmenter_mask_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_setr_mla_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_setr_up_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_uper_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/test_vpd_depth_head.py
 delete mode 100644 mmsegmentation/tests/test_models/test_heads/utils.py
 delete mode 100644 mmsegmentation/tests/test_models/test_losses/test_cross_entropy_loss.py
 delete mode 100644 mmsegmentation/tests/test_models/test_losses/test_dice_loss.py
 delete mode 100644 mmsegmentation/tests/test_models/test_losses/test_huasdorff_distance_loss.py
 delete mode 100644 mmsegmentation/tests/test_models/test_losses/test_kldiv_loss.py
 delete mode 100644 mmsegmentation/tests/test_models/test_losses/test_silog_loss.py
 delete mode 100644 mmsegmentation/tests/test_models/test_losses/test_tversky_loss.py
 delete mode 100644 mmsegmentation/tests/test_models/test_necks/__init__.py
 delete mode 100644 mmsegmentation/tests/test_models/test_necks/test_feature2pyramid.py
 delete mode 100644 mmsegmentation/tests/test_models/test_necks/test_fpn.py
 delete mode 100644 mmsegmentation/tests/test_models/test_necks/test_ic_neck.py
 delete mode 100644 mmsegmentation/tests/test_models/test_necks/test_jpu.py
 delete mode 100644 mmsegmentation/tests/test_models/test_necks/test_mla_neck.py
 delete mode 100644 mmsegmentation/tests/test_models/test_necks/test_multilevel_neck.py
 delete mode 100644 mmsegmentation/tests/test_models/test_segmentors/__init__.py
 delete mode 100644 mmsegmentation/tests/test_models/test_segmentors/test_cascade_encoder_decoder.py
 delete mode 100644 mmsegmentation/tests/test_models/test_segmentors/test_depth_estimator.py
 delete mode 100644 mmsegmentation/tests/test_models/test_segmentors/test_encoder_decoder.py
 delete mode 100644 mmsegmentation/tests/test_models/test_segmentors/test_multimodal_encoder_decoder.py
 delete mode 100644 mmsegmentation/tests/test_models/test_segmentors/test_seg_tta_model.py
 delete mode 100644 mmsegmentation/tests/test_models/test_segmentors/utils.py
 delete mode 100644 mmsegmentation/tests/test_models/test_utils/__init__.py
 delete mode 100644 mmsegmentation/tests/test_models/test_utils/test_embed.py
 delete mode 100644 mmsegmentation/tests/test_models/test_utils/test_shape_convert.py
 delete mode 100644 mmsegmentation/tests/test_sampler.py
 delete mode 100644 mmsegmentation/tests/test_structures/test_seg_data_sample.py
 delete mode 100644 mmsegmentation/tests/test_utils/test_io.py
 delete mode 100644 mmsegmentation/tests/test_utils/test_set_env.py
 delete mode 100644 mmsegmentation/tests/test_visualization/test_local_visualizer.py
 delete mode 100644 mmsegmentation/tools/analysis_tools/analyze_logs.py
 delete mode 100644 mmsegmentation/tools/analysis_tools/benchmark.py
 delete mode 100644 mmsegmentation/tools/analysis_tools/browse_dataset.py
 delete mode 100644 mmsegmentation/tools/analysis_tools/confusion_matrix.py
 delete mode 100644 mmsegmentation/tools/analysis_tools/get_flops.py
 delete mode 100644 mmsegmentation/tools/analysis_tools/visualization_cam.py
 delete mode 100644 mmsegmentation/tools/dataset_converters/chase_db1.py
 delete mode 100644 mmsegmentation/tools/dataset_converters/cityscapes.py
 delete mode 100644 mmsegmentation/tools/dataset_converters/coco_stuff10k.py
 delete mode 100644 mmsegmentation/tools/dataset_converters/coco_stuff164k.py
 delete mode 100644 mmsegmentation/tools/dataset_converters/drive.py
 delete mode 100644 mmsegmentation/tools/dataset_converters/hrf.py
 delete mode 100644 mmsegmentation/tools/dataset_converters/isaid.py
 delete mode 100644 mmsegmentation/tools/dataset_converters/levircd.py
 delete mode 100644 mmsegmentation/tools/dataset_converters/loveda.py
 delete mode 100644 mmsegmentation/tools/dataset_converters/nyu.py
 delete mode 100644 mmsegmentation/tools/dataset_converters/pascal_context.py
 delete mode 100644 mmsegmentation/tools/dataset_converters/potsdam.py
 delete mode 100644 mmsegmentation/tools/dataset_converters/refuge.py
 delete mode 100644 mmsegmentation/tools/dataset_converters/stare.py
 delete mode 100644 mmsegmentation/tools/dataset_converters/synapse.py
 delete mode 100644 mmsegmentation/tools/dataset_converters/vaihingen.py
 delete mode 100644 mmsegmentation/tools/dataset_converters/voc_aug.py
 delete mode 100644 mmsegmentation/tools/deployment/pytorch2torchscript.py
 delete mode 100755 mmsegmentation/tools/dist_test.sh
 delete mode 100755 mmsegmentation/tools/dist_train.sh
 delete mode 100644 mmsegmentation/tools/misc/browse_dataset.py
 delete mode 100644 mmsegmentation/tools/misc/print_config.py
 delete mode 100644 mmsegmentation/tools/misc/publish_model.py
 delete mode 100644 mmsegmentation/tools/model_converters/beit2mmseg.py
 delete mode 100644 mmsegmentation/tools/model_converters/clip2mmseg.py
 delete mode 100644 mmsegmentation/tools/model_converters/mit2mmseg.py
 delete mode 100644 mmsegmentation/tools/model_converters/san2mmseg.py
 delete mode 100644 mmsegmentation/tools/model_converters/stdc2mmseg.py
 delete mode 100644 mmsegmentation/tools/model_converters/swin2mmseg.py
 delete mode 100644 mmsegmentation/tools/model_converters/twins2mmseg.py
 delete mode 100644 mmsegmentation/tools/model_converters/vit2mmseg.py
 delete mode 100644 mmsegmentation/tools/model_converters/vitjax2mmseg.py
 delete mode 100755 mmsegmentation/tools/slurm_test.sh
 delete mode 100755 mmsegmentation/tools/slurm_train.sh
 delete mode 100644 mmsegmentation/tools/torchserve/mmseg2torchserve.py
 delete mode 100644 mmsegmentation/tools/torchserve/mmseg_handler.py
 delete mode 100644 mmsegmentation/tools/torchserve/test_torchserve.py

diff --git a/mmsegmentation/.circleci/config.yml b/mmsegmentation/.circleci/config.yml
deleted file mode 100644
index 635a984..0000000
--- a/mmsegmentation/.circleci/config.yml
+++ /dev/null
@@ -1,34 +0,0 @@
-version: 2.1
-
-# this allows you to use CircleCI's dynamic configuration feature
-setup: true
-
-# the path-filtering orb is required to continue a pipeline based on
-# the path of an updated fileset
-orbs:
-  path-filtering: circleci/path-filtering@0.1.2
-
-workflows:
-  # the always-run workflow is always triggered, regardless of the pipeline parameters.
-  always-run:
-    jobs:
-      # the path-filtering/filter job determines which pipeline
-      # parameters to update.
-      - path-filtering/filter:
-          name: check-updated-files
-          # 3-column, whitespace-delimited mapping. One mapping per
-          # line:
-          # <regex path-to-test> <parameter-to-set> <value-of-pipeline-parameter>
-          mapping: |
-            mmseg/.* lint_only false
-            requirements/.* lint_only false
-            tests/.* lint_only false
-            tools/.* lint_only false
-            configs/.* lint_only false
-            .circleci/.* lint_only false
-          base-revision: main
-          # this is the path of the configuration we should trigger once
-          # path filtering and pipeline parameter value updates are
-          # complete. In this case, we are using the parent dynamic
-          # configuration itself.
-          config-path: .circleci/test.yml
diff --git a/mmsegmentation/.circleci/docker/Dockerfile b/mmsegmentation/.circleci/docker/Dockerfile
deleted file mode 100644
index b1d40e0..0000000
--- a/mmsegmentation/.circleci/docker/Dockerfile
+++ /dev/null
@@ -1,12 +0,0 @@
-
-ARG PYTORCH="1.8.1"
-ARG CUDA="10.2"
-ARG CUDNN="7"
-
-FROM pytorch/pytorch:${PYTORCH}-cuda${CUDA}-cudnn${CUDNN}-devel
-
-# To fix GPG key error when running apt-get update
-RUN apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/3bf863cc.pub
-RUN apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64/7fa2af80.pub
-
-RUN apt-get update && apt-get install -y ninja-build libglib2.0-0 libsm6 libxrender-dev libxext6 libgl1-mesa-glx
diff --git a/mmsegmentation/.circleci/test.yml b/mmsegmentation/.circleci/test.yml
deleted file mode 100644
index 622cdf9..0000000
--- a/mmsegmentation/.circleci/test.yml
+++ /dev/null
@@ -1,196 +0,0 @@
-version: 2.1
-
-# the default pipeline parameters, which will be updated according to
-# the results of the path-filtering orb
-parameters:
-  lint_only:
-    type: boolean
-    default: true
-
-jobs:
-  lint:
-    docker:
-      - image: cimg/python:3.7.4
-    steps:
-      - checkout
-      - run:
-          name: Install pre-commit hook
-          command: |
-            pip install pre-commit
-            pre-commit install
-      - run:
-          name: Linting
-          command: pre-commit run --all-files
-      - run:
-          name: Check docstring coverage
-          command: |
-            pip install interrogate
-            interrogate -v --ignore-init-method --ignore-module --ignore-nested-functions --ignore-magic --ignore-regex "__repr__" --fail-under 75 mmseg
-  build_cpu:
-    parameters:
-      # The python version must match available image tags in
-      # https://circleci.com/developer/images/image/cimg/python
-      python:
-        type: string
-      torch:
-        type: string
-      torchvision:
-        type: string
-    docker:
-      - image: cimg/python:<< parameters.python >>
-    resource_class: large
-    steps:
-      - checkout
-      - run:
-          name: Install Libraries
-          command: |
-            sudo apt-get update
-            sudo apt-get install -y ninja-build libglib2.0-0 libsm6 libxrender-dev libxext6 libgl1-mesa-glx libjpeg-dev zlib1g-dev libtinfo-dev libncurses5
-      - run:
-          name: Configure Python & pip
-          command: |
-            pip install --upgrade pip
-            pip install wheel
-      - run:
-          name: Install PyTorch
-          command: |
-            python -V
-            pip install torch==<< parameters.torch >>+cpu torchvision==<< parameters.torchvision >>+cpu -f https://download.pytorch.org/whl/torch_stable.html
-      - run:
-          name: Install mmseg dependencies
-          command: |
-            pip install git+https://github.com/open-mmlab/mmengine.git@main
-            pip install -U openmim
-            mim install mmcv>=2.0.0
-            pip install mmpretrain>=1.0.0rc7
-            pip install mmdet>=3.0.0
-            pip install -r requirements/tests.txt -r requirements/optional.txt
-            python -m pip install albumentations>=0.3.2 --no-binary qudida,albumentations
-      - run:
-          name: Build and install
-          command: |
-            pip install -e .
-      - run:
-          name: Skip timm unittests and generate coverage report
-          command: |
-            python -m coverage run --branch --source mmseg -m pytest tests/ --ignore tests/test_models/test_backbones/test_timm_backbone.py --ignore tests/test_apis/test_rs_inferencer.py
-            python -m coverage xml
-            python -m coverage report -m
-  build_cuda:
-    parameters:
-      torch:
-        type: string
-      cuda:
-        type: enum
-        enum: ["10.1", "10.2", "11.1"]
-      cudnn:
-        type: integer
-        default: 7
-    machine:
-      image: linux-cuda-11:default
-      docker_layer_caching: true
-    resource_class: gpu.nvidia.small.multi
-    steps:
-      - checkout
-      - run:
-          name: Install nvidia-container-toolkit and Restart Docker
-          command: |
-            sudo apt-get update
-            sudo apt-get install -y nvidia-container-toolkit
-            sudo systemctl restart docker
-      - run:
-          # Cloning repos in VM since Docker doesn't have access to the private key
-          name: Clone Repos
-          command: |
-            git clone -b main --depth 1 https://github.com/open-mmlab/mmengine.git /home/circleci/mmengine
-      - run:
-          name: Build Docker image
-          command: |
-            docker build .circleci/docker -t mmseg:gpu --build-arg PYTORCH=<< parameters.torch >> --build-arg CUDA=<< parameters.cuda >> --build-arg CUDNN=<< parameters.cudnn >>
-            docker run --gpus all -t -d -v /home/circleci/project:/mmseg -v /home/circleci/mmengine:/mmengine -v /home/circleci/mmpretrain:/mmpretrain -v /home/circleci/mmdetection:/mmdetection -w /mmseg --name mmseg mmseg:gpu
-      - run:
-          name: Install mmseg dependencies
-          command: |
-            docker exec mmseg pip install -e /mmengine
-            docker exec mmseg pip install -U openmim
-            docker exec mmseg mim install mmcv>=2.0.0
-            docker exec mmseg pip install mmpretrain>=1.0.0rc7
-            docker exec mmseg mim install mmdet>=3.0.0
-            docker exec mmseg apt-get update
-            docker exec mmseg apt-get install -y git
-            docker exec mmseg pip install -r requirements/tests.txt -r requirements/optional.txt
-            docker exec mmseg python -m pip install albumentations>=0.3.2 --no-binary qudida,albumentations
-      - run:
-          name: Build and install
-          command: |
-            docker exec mmseg pip install -e .
-      - run:
-          name: Run unittests but skip timm unittests
-          command: |
-            docker exec mmseg pytest tests/ --ignore tests/test_models/test_backbones/test_timm_backbone.py --ignore tests/test_models/test_backbones/test_timm_backbone.py --ignore tests/test_apis/test_rs_inferencer.py
-workflows:
-  pr_stage_lint:
-    when: << pipeline.parameters.lint_only >>
-    jobs:
-      - lint:
-          name: lint
-          filters:
-            branches:
-              ignore:
-                - dev-1.x
-                - main
-  pr_stage_test:
-    when:
-      not:
-        << pipeline.parameters.lint_only >>
-    jobs:
-      - lint:
-          name: lint
-          filters:
-            branches:
-              ignore:
-                - dev-1.x
-                - main
-      - build_cpu:
-          name: minimum_version_cpu
-          torch: 1.8.1
-          torchvision: 0.9.1
-          python: "3.7"
-          requires:
-            - lint
-      - build_cpu:
-          name: maximum_version_cpu
-          # TODO: Fix torch 1.13 forward crush
-          torch: 1.12.0
-          torchvision: 0.13.0
-          python: 3.9.0
-          requires:
-            - minimum_version_cpu
-      - hold:
-          type: approval
-          requires:
-            - maximum_version_cpu
-      - build_cuda:
-          name: mainstream_version_gpu
-          torch: 1.8.1
-          # Use double quotation mark to explicitly specify its type
-          # as string instead of number
-          cuda: "10.2"
-          requires:
-            - hold
-  merge_stage_test:
-    when:
-      not:
-        << pipeline.parameters.lint_only >>
-    jobs:
-      - build_cuda:
-          name: minimum_version_gpu
-          torch: 1.8.1
-          # Use double quotation mark to explicitly specify its type
-          # as string instead of number
-          cuda: "10.2"
-          filters:
-            branches:
-              only:
-                - dev-1.x
-                - main
diff --git a/mmsegmentation/.dev_scripts/batch_test_list.py b/mmsegmentation/.dev_scripts/batch_test_list.py
deleted file mode 100644
index 0d096ed..0000000
--- a/mmsegmentation/.dev_scripts/batch_test_list.py
+++ /dev/null
@@ -1,133 +0,0 @@
-# yapf: disable
-# Inference Speed is tested on NVIDIA V100
-hrnet = [
-    dict(
-        config='configs/hrnet/fcn_hr18s_4xb4-160k_ade20k-512x512.py',
-        checkpoint='fcn_hr18s_512x512_160k_ade20k_20200614_214413-870f65ac.pth', # noqa
-        eval='mIoU',
-        metric=dict(mIoU=33.0),
-    ),
-    dict(
-        config='configs/hrnet/fcn_hr18s_4xb2-160k_cityscapes-512x1024.py',
-        checkpoint='fcn_hr18s_512x1024_160k_cityscapes_20200602_190901-4a0797ea.pth', # noqa
-        eval='mIoU',
-        metric=dict(mIoU=76.31),
-    ),
-    dict(
-        config='configs/hrnet/fcn_hr48_4xb4-160k_ade20k-512x512.py',
-        checkpoint='fcn_hr48_512x512_160k_ade20k_20200614_214407-a52fc02c.pth',
-        eval='mIoU',
-        metric=dict(mIoU=42.02),
-    ),
-    dict(
-        config='configs/hrnet/fcn_hr48_4xb2-160k_cityscapes-512x1024.py',
-        checkpoint='fcn_hr48_512x1024_160k_cityscapes_20200602_190946-59b7973e.pth', # noqa
-        eval='mIoU',
-        metric=dict(mIoU=80.65),
-    ),
-]
-pspnet = [
-    dict(
-        config='configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py',
-        checkpoint='pspnet_r50-d8_512x1024_80k_cityscapes_20200606_112131-2376f12b.pth', # noqa
-        eval='mIoU',
-        metric=dict(mIoU=78.55),
-    ),
-    dict(
-        config='configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-512x1024.py',
-        checkpoint='pspnet_r101-d8_512x1024_80k_cityscapes_20200606_112211-e1e1100f.pth', # noqa
-        eval='mIoU',
-        metric=dict(mIoU=79.76),
-    ),
-    dict(
-        config='configs/pspnet/pspnet_r101-d8_4xb4-160k_ade20k-512x512.py',
-        checkpoint='pspnet_r101-d8_512x512_160k_ade20k_20200615_100650-967c316f.pth', # noqa
-        eval='mIoU',
-        metric=dict(mIoU=44.39),
-    ),
-    dict(
-        config='configs/pspnet/pspnet_r50-d8_4xb4-160k_ade20k-512x512.py',
-        checkpoint='pspnet_r50-d8_512x512_160k_ade20k_20200615_184358-1890b0bd.pth', # noqa
-        eval='mIoU',
-        metric=dict(mIoU=42.48),
-    ),
-]
-resnest = [
-    dict(
-        config='configs/resnest/resnest_s101-d8_pspnet_4xb4-160k_ade20k-512x512.py', # noqa
-        checkpoint='pspnet_s101-d8_512x512_160k_ade20k_20200807_145416-a6daa92a.pth', # noqa
-        eval='mIoU',
-        metric=dict(mIoU=45.44),
-    ),
-    dict(
-        config='configs/resnest/resnest_s101-d8_pspnet_4xb2-80k_cityscapes512x1024.py', # noqa
-        checkpoint='pspnet_s101-d8_512x1024_80k_cityscapes_20200807_140631-c75f3b99.pth', # noqa
-        eval='mIoU',
-        metric=dict(mIoU=78.57),
-    ),
-]
-fastscnn = [
-    dict(
-        config='configs/fastscnn/fast_scnn_8xb4-160k_cityscapes-512x1024.py',
-        checkpoint='fast_scnn_8x4_160k_lr0.12_cityscapes-0cec9937.pth',
-        eval='mIoU',
-        metric=dict(mIoU=70.96),
-    )
-]
-deeplabv3plus = [
-    dict(
-        config='configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-769x769.py', # noqa
-        checkpoint='deeplabv3plus_r101-d8_769x769_80k_cityscapes_20200607_000405-a7573d20.pth', # noqa
-        eval='mIoU',
-        metric=dict(mIoU=80.98),
-    ),
-    dict(
-        config='configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024.py', # noqa
-        checkpoint='deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143-068fcfe9.pth', # noqa
-        eval='mIoU',
-        metric=dict(mIoU=80.97),
-    ),
-    dict(
-        config='configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py', # noqa
-        checkpoint='deeplabv3plus_r50-d8_512x1024_80k_cityscapes_20200606_114049-f9fb496d.pth', # noqa
-        eval='mIoU',
-        metric=dict(mIoU=80.09),
-    ),
-    dict(
-        config='configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py', # noqa
-        checkpoint='deeplabv3plus_r50-d8_769x769_80k_cityscapes_20200606_210233-0e9dfdc4.pth', # noqa
-        eval='mIoU',
-        metric=dict(mIoU=79.83),
-    ),
-]
-vit = [
-    dict(
-        config='configs/vit/vit_vit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py', # noqa
-        checkpoint='upernet_vit-b16_ln_mln_512x512_160k_ade20k-f444c077.pth',
-        eval='mIoU',
-        metric=dict(mIoU=47.73),
-    ),
-    dict(
-        config='configs/vit/vit_deit-s16-ln_mln_upernet_512x512_160k_ade20k-512x512.py', # noqa
-        checkpoint='upernet_deit-s16_ln_mln_512x512_160k_ade20k-c0cd652f.pth',
-        eval='mIoU',
-        metric=dict(mIoU=43.52),
-    ),
-]
-fp16 = [
-    dict(
-        config='configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py', # noqa
-        checkpoint='deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230920-f1104f4b.pth', # noqa
-        eval='mIoU',
-        metric=dict(mIoU=80.46),
-    )
-]
-swin = [
-    dict(
-        config='configs/swin/swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py', # noqa
-        checkpoint='upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210531_112542-e380ad3e.pth', # noqa
-        eval='mIoU',
-        metric=dict(mIoU=44.41),
-    )
-]
-# yapf: enable
diff --git a/mmsegmentation/.dev_scripts/batch_train_list.txt b/mmsegmentation/.dev_scripts/batch_train_list.txt
deleted file mode 100644
index 6c1a122..0000000
--- a/mmsegmentation/.dev_scripts/batch_train_list.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-configs/hrnet/fcn_hr18s_4xb4-160k_ade20k-512x512.py
-configs/hrnet/fcn_hr18s_4xb2-160k_cityscapes-512x1024.py
-configs/hrnet/fcn_hr48_4xb4-160k_ade20k-512x512.py
-configs/hrnet/fcn_hr48_4xb2-160k_cityscapes-512x1024.py
-configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
-configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
-configs/pspnet/pspnet_r101-d8_4xb4-160k_ade20k-512x512.py
-configs/pspnet/pspnet_r50-d8_4xb4-160k_ade20k-512x512.py
-configs/resnest/resnest_s101-d8_pspnet_4xb4-160k_ade20k-512x512.py
-configs/resnest/resnest_s101-d8_pspnet_4xb2-80k_cityscapes512x1024.py
-configs/fastscnn/fast_scnn_8xb4-160k_cityscapes-512x1024.py
-configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-769x769.py
-configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024.py
-configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py
-configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py
-configs/vit/vit_vit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
-configs/vit/vit_deit-s16-ln_mln_upernet_512x512_160k_ade20k-512x512.py
-configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
-configs/swin/swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
diff --git a/mmsegmentation/.dev_scripts/benchmark_evaluation.sh b/mmsegmentation/.dev_scripts/benchmark_evaluation.sh
deleted file mode 100755
index 68dc272..0000000
--- a/mmsegmentation/.dev_scripts/benchmark_evaluation.sh
+++ /dev/null
@@ -1,41 +0,0 @@
-PARTITION=$1
-CHECKPOINT_DIR=$2
-
-echo 'configs/hrnet/fcn_hr18s_512x512_160k_ade20k.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION fcn_hr18s_512x512_160k_ade20k configs/hrnet/fcn_hr18s_512x512_160k_ade20k.py $CHECKPOINT_DIR/fcn_hr18s_512x512_160k_ade20k_20200614_214413-870f65ac.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/fcn_hr18s_512x512_160k_ade20k --cfg-options dist_params.port=28171 &
-echo 'configs/hrnet/fcn_hr18s_512x1024_160k_cityscapes.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION fcn_hr18s_512x1024_160k_cityscapes configs/hrnet/fcn_hr18s_512x1024_160k_cityscapes.py $CHECKPOINT_DIR/fcn_hr18s_512x1024_160k_cityscapes_20200602_190901-4a0797ea.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/fcn_hr18s_512x1024_160k_cityscapes --cfg-options dist_params.port=28172 &
-echo 'configs/hrnet/fcn_hr48_512x512_160k_ade20k.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION fcn_hr48_512x512_160k_ade20k configs/hrnet/fcn_hr48_512x512_160k_ade20k.py $CHECKPOINT_DIR/fcn_hr48_512x512_160k_ade20k_20200614_214407-a52fc02c.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/fcn_hr48_512x512_160k_ade20k --cfg-options dist_params.port=28173 &
-echo 'configs/hrnet/fcn_hr48_512x1024_160k_cityscapes.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION fcn_hr48_512x1024_160k_cityscapes configs/hrnet/fcn_hr48_512x1024_160k_cityscapes.py $CHECKPOINT_DIR/fcn_hr48_512x1024_160k_cityscapes_20200602_190946-59b7973e.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/fcn_hr48_512x1024_160k_cityscapes --cfg-options dist_params.port=28174 &
-echo 'configs/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION pspnet_r50-d8_512x1024_80k_cityscapes configs/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes.py $CHECKPOINT_DIR/pspnet_r50-d8_512x1024_80k_cityscapes_20200606_112131-2376f12b.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/pspnet_r50-d8_512x1024_80k_cityscapes --cfg-options dist_params.port=28175 &
-echo 'configs/pspnet/pspnet_r101-d8_512x1024_80k_cityscapes.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION pspnet_r101-d8_512x1024_80k_cityscapes configs/pspnet/pspnet_r101-d8_512x1024_80k_cityscapes.py $CHECKPOINT_DIR/pspnet_r101-d8_512x1024_80k_cityscapes_20200606_112211-e1e1100f.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/pspnet_r101-d8_512x1024_80k_cityscapes --cfg-options dist_params.port=28176 &
-echo 'configs/pspnet/pspnet_r101-d8_512x512_160k_ade20k.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION pspnet_r101-d8_512x512_160k_ade20k configs/pspnet/pspnet_r101-d8_512x512_160k_ade20k.py $CHECKPOINT_DIR/pspnet_r101-d8_512x512_160k_ade20k_20200615_100650-967c316f.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/pspnet_r101-d8_512x512_160k_ade20k --cfg-options dist_params.port=28177 &
-echo 'configs/pspnet/pspnet_r50-d8_512x512_160k_ade20k.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION pspnet_r50-d8_512x512_160k_ade20k configs/pspnet/pspnet_r50-d8_512x512_160k_ade20k.py $CHECKPOINT_DIR/pspnet_r50-d8_512x512_160k_ade20k_20200615_184358-1890b0bd.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/pspnet_r50-d8_512x512_160k_ade20k --cfg-options dist_params.port=28178 &
-echo 'configs/resnest/pspnet_s101-d8_512x512_160k_ade20k.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION pspnet_s101-d8_512x512_160k_ade20k configs/resnest/pspnet_s101-d8_512x512_160k_ade20k.py $CHECKPOINT_DIR/pspnet_s101-d8_512x512_160k_ade20k_20200807_145416-a6daa92a.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/pspnet_s101-d8_512x512_160k_ade20k --cfg-options dist_params.port=28179 &
-echo 'configs/resnest/pspnet_s101-d8_512x1024_80k_cityscapes.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION pspnet_s101-d8_512x1024_80k_cityscapes configs/resnest/pspnet_s101-d8_512x1024_80k_cityscapes.py $CHECKPOINT_DIR/pspnet_s101-d8_512x1024_80k_cityscapes_20200807_140631-c75f3b99.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/pspnet_s101-d8_512x1024_80k_cityscapes --cfg-options dist_params.port=28180 &
-echo 'configs/fastscnn/fast_scnn_lr0.12_8x4_160k_cityscapes.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION fast_scnn_lr0.12_8x4_160k_cityscapes configs/fastscnn/fast_scnn_lr0.12_8x4_160k_cityscapes.py $CHECKPOINT_DIR/fast_scnn_8x4_160k_lr0.12_cityscapes-0cec9937.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/fast_scnn_lr0.12_8x4_160k_cityscapes --cfg-options dist_params.port=28181 &
-echo 'configs/deeplabv3plus/deeplabv3plus_r101-d8_769x769_80k_cityscapes.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION deeplabv3plus_r101-d8_769x769_80k_cityscapes configs/deeplabv3plus/deeplabv3plus_r101-d8_769x769_80k_cityscapes.py $CHECKPOINT_DIR/deeplabv3plus_r101-d8_769x769_80k_cityscapes_20200607_000405-a7573d20.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/deeplabv3plus_r101-d8_769x769_80k_cityscapes --cfg-options dist_params.port=28182 &
-echo 'configs/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_80k_cityscapes.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION deeplabv3plus_r101-d8_512x1024_80k_cityscapes configs/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_80k_cityscapes.py $CHECKPOINT_DIR/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143-068fcfe9.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/deeplabv3plus_r101-d8_512x1024_80k_cityscapes --cfg-options dist_params.port=28183 &
-echo 'configs/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_80k_cityscapes.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION deeplabv3plus_r50-d8_512x1024_80k_cityscapes configs/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_80k_cityscapes.py $CHECKPOINT_DIR/deeplabv3plus_r50-d8_512x1024_80k_cityscapes_20200606_114049-f9fb496d.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/deeplabv3plus_r50-d8_512x1024_80k_cityscapes --cfg-options dist_params.port=28184 &
-echo 'configs/deeplabv3plus/deeplabv3plus_r50-d8_769x769_80k_cityscapes.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION deeplabv3plus_r50-d8_769x769_80k_cityscapes configs/deeplabv3plus/deeplabv3plus_r50-d8_769x769_80k_cityscapes.py $CHECKPOINT_DIR/deeplabv3plus_r50-d8_769x769_80k_cityscapes_20200606_210233-0e9dfdc4.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/deeplabv3plus_r50-d8_769x769_80k_cityscapes --cfg-options dist_params.port=28185 &
-echo 'configs/vit/upernet_vit-b16_ln_mln_512x512_160k_ade20k.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION upernet_vit-b16_ln_mln_512x512_160k_ade20k configs/vit/upernet_vit-b16_ln_mln_512x512_160k_ade20k.py $CHECKPOINT_DIR/upernet_vit-b16_ln_mln_512x512_160k_ade20k-f444c077.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/upernet_vit-b16_ln_mln_512x512_160k_ade20k --cfg-options dist_params.port=28186 &
-echo 'configs/vit/upernet_deit-s16_ln_mln_512x512_160k_ade20k.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION upernet_deit-s16_ln_mln_512x512_160k_ade20k configs/vit/upernet_deit-s16_ln_mln_512x512_160k_ade20k.py $CHECKPOINT_DIR/upernet_deit-s16_ln_mln_512x512_160k_ade20k-c0cd652f.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/upernet_deit-s16_ln_mln_512x512_160k_ade20k --cfg-options dist_params.port=28187 &
-echo 'configs/deeplabv3plus/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes configs/deeplabv3plus/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes.py $CHECKPOINT_DIR/deeplabv3plus_r101-d8_512x1024_80k_fp16_cityscapes-cc58bc8d.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/deeplabv3plus_r101-d8_512x1024_80k_fp16_cityscapes --cfg-options dist_params.port=28188 &
-echo 'configs/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K configs/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K.py $CHECKPOINT_DIR/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210531_112542-e380ad3e.pth --eval mIoU --work-dir work_dirs/benchmark_evaluation/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K --cfg-options dist_params.port=28189 &
diff --git a/mmsegmentation/.dev_scripts/benchmark_full_models.txt b/mmsegmentation/.dev_scripts/benchmark_full_models.txt
deleted file mode 100644
index 64b968d..0000000
--- a/mmsegmentation/.dev_scripts/benchmark_full_models.txt
+++ /dev/null
@@ -1,57 +0,0 @@
-ann/ann_r50-d8_4xb2-40k_cityscapes-512x1024.py
-apcnet/apcnet_r50-d8_4xb4-80k_ade20k-512x512.py
-beit/beit-large_upernet_8xb1-amp-160k_ade20k-640x640.py
-bisenetv1/bisenetv1_r18-d32_4xb4-160k_coco-stuff164k-512x512.py
-bisenetv2/bisenetv2_fcn_4xb4-ohem-160k_cityscapes-1024x1024.py
-ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
-cgnet/cgnet_fcn_4xb4-60k_cityscapes-680x680.py
-convnext/convnext-tiny_upernet_8xb2-amp-160k_ade20k-512x512.py
-danet/danet_r50-d8_4xb2-40k_cityscapes-512x1024.py
-deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py
-deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-769x769.py
-dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
-dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-512x1024.py
-dpt/dpt_vit-b16_8xb2-160k_ade20k-512x512.py
-emanet/eemanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
-encnet/encnet_r50-d8_4xb4-80k_ade20k-512x512.py
-erfnet/erfnet_fcn_4xb4-160k_cityscapes-512x1024.py
-fastfcn/fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024.py
-fastscnn/fast_scnn_8xb4-160k_cityscapes-512x1024.py
-fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py
-gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-769x769.py
-hrnet/fcn_hr18s_4xb4-80k_ade20k-512x512.py
-icnet/icnet_r50-d8_4xb2-80k_cityscapes-832x832.py
-isanet/isanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
-knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-640x640.py
-mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512.py
-mask2former/mask2former_r50_8xb2-90k_cityscapes-512x1024.py
-mask2former/mask2former_swin-t_8xb2-90k_cityscapes-512x1024.py
-mask2former/mask2former_swin-s_8xb2-160k_ade20k-512x512.py
-mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py
-maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512.py
-maskformer/maskformer_r101-d32_8xb2-160k_ade20k-512x512.py
-maskformer/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512.py
-maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512.py
-mobilenet_v2/mobilenet-v2-d8_pspnet_4xb2-80k_cityscapes-512x1024.py
-mobilenet_v3/mobilenet-v3-d8-scratch_lraspp_4xb4-320k_cityscapes-512x1024.py
-nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-512x1024.py
-ocrnet/ocrnet_hr18_4xb4-80k_ade20k-512x512.py
-pidnet/pidnet-l_2xb6-120k_1024x1024-cityscapes.py
-point_rend/pointrend_r50_4xb2-80k_cityscapes-512x1024.py
-poolformer/fpn_poolformer_m48_8xb4-40k_ade20k-512x512.py
-psanet/psanet_r101-d8_4xb4-80k_ade20k-512x512.py
-pspnet/pspnet_r50-d8-rsb_4xb2-adamw-80k_cityscapes-512x1024.py
-resnest/resnest_s101-d8_deeplabv3_4xb4-160k_ade20k-512x512.py
-segformer/segformer_mit-b5_8xb1-160k_cityscapes-1024x1024.py
-segformer/segformer_mit-b5_8xb2-160k_ade20k-512x512.py
-segmenter/segmenter_vit-t_mask_8xb1-160k_ade20k-512x512.py
-segnext/segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512.py
-sem_fpn/fpn_r101_4xb2-80k_cityscapes-512x1024.py
-setr/setr_vit-l-mla_8xb1-160k_ade20k-512x512.py
-stdc/stdc1_in1k-pre_4xb12-80k_cityscapes-512x1024.py
-swin/swin-small-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
-twins/twins_pcpvt-s_uperhead_8xb4-160k_ade20k-512x512.py
-unet/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py
-upernet/upernet_r50_4xb2-40k_cityscapes-769x769.py
-vit/vit_deit-s16_upernet_8xb2-80k_ade20k-512x512.py
-san/san-vit-b16_coco-stuff164k-640x640.py
diff --git a/mmsegmentation/.dev_scripts/benchmark_inference.py b/mmsegmentation/.dev_scripts/benchmark_inference.py
deleted file mode 100644
index b17c144..0000000
--- a/mmsegmentation/.dev_scripts/benchmark_inference.py
+++ /dev/null
@@ -1,149 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import hashlib
-import logging
-import os
-import os.path as osp
-import warnings
-from argparse import ArgumentParser
-
-import requests
-from mmengine import Config
-
-from mmseg.apis import inference_model, init_model, show_result_pyplot
-from mmseg.utils import get_root_logger
-
-# ignore warnings when segmentors inference
-warnings.filterwarnings('ignore')
-
-
-def download_checkpoint(checkpoint_name, model_name, config_name, collect_dir):
-    """Download checkpoint and check if hash code is true."""
-    url = f'https://download.openmmlab.com/mmsegmentation/v0.5/{model_name}/{config_name}/{checkpoint_name}'  # noqa
-
-    r = requests.get(url)
-    assert r.status_code != 403, f'{url} Access denied.'
-
-    with open(osp.join(collect_dir, checkpoint_name), 'wb') as code:
-        code.write(r.content)
-
-    true_hash_code = osp.splitext(checkpoint_name)[0].split('-')[1]
-
-    # check hash code
-    with open(osp.join(collect_dir, checkpoint_name), 'rb') as fp:
-        sha256_cal = hashlib.sha256()
-        sha256_cal.update(fp.read())
-        cur_hash_code = sha256_cal.hexdigest()[:8]
-
-    assert true_hash_code == cur_hash_code, f'{url} download failed, '
-    'incomplete downloaded file or url invalid.'
-
-    if cur_hash_code != true_hash_code:
-        os.remove(osp.join(collect_dir, checkpoint_name))
-
-
-def parse_args():
-    parser = ArgumentParser()
-    parser.add_argument('config', help='test config file path')
-    parser.add_argument('checkpoint_root', help='Checkpoint file root path')
-    parser.add_argument(
-        '-i', '--img', default='demo/demo.png', help='Image file')
-    parser.add_argument('-a', '--aug', action='store_true', help='aug test')
-    parser.add_argument('-m', '--model-name', help='model name to inference')
-    parser.add_argument(
-        '-s', '--show', action='store_true', help='show results')
-    parser.add_argument(
-        '-d', '--device', default='cuda:0', help='Device used for inference')
-    args = parser.parse_args()
-    return args
-
-
-def inference(config_name, checkpoint, args, logger=None):
-    cfg = Config.fromfile(config_name)
-    if args.aug:
-        if 'flip' in cfg.data.test.pipeline[
-                1] and 'img_scale' in cfg.data.test.pipeline[1]:
-            cfg.data.test.pipeline[1].img_ratios = [
-                0.5, 0.75, 1.0, 1.25, 1.5, 1.75
-            ]
-            cfg.data.test.pipeline[1].flip = True
-        else:
-            if logger is not None:
-                logger.error(f'{config_name}: unable to start aug test')
-            else:
-                print(f'{config_name}: unable to start aug test', flush=True)
-
-    model = init_model(cfg, checkpoint, device=args.device)
-    # test a single image
-    result = inference_model(model, args.img)
-
-    # show the results
-    if args.show:
-        show_result_pyplot(model, args.img, result)
-    return result
-
-
-# Sample test whether the inference code is correct
-def main(args):
-    config = Config.fromfile(args.config)
-
-    if not os.path.exists(args.checkpoint_root):
-        os.makedirs(args.checkpoint_root, 0o775)
-
-    # test single model
-    if args.model_name:
-        if args.model_name in config:
-            model_infos = config[args.model_name]
-            if not isinstance(model_infos, list):
-                model_infos = [model_infos]
-            for model_info in model_infos:
-                config_name = model_info['config'].strip()
-                print(f'processing: {config_name}', flush=True)
-                checkpoint = osp.join(args.checkpoint_root,
-                                      model_info['checkpoint'].strip())
-                try:
-                    # build the model from a config file and a checkpoint file
-                    inference(config_name, checkpoint, args)
-                except Exception:
-                    print(f'{config_name} test failed!')
-                    continue
-                return
-        else:
-            raise RuntimeError('model name input error.')
-
-    # test all model
-    logger = get_root_logger(
-        log_file='benchmark_inference_image.log', log_level=logging.ERROR)
-
-    for model_name in config:
-        model_infos = config[model_name]
-
-        if not isinstance(model_infos, list):
-            model_infos = [model_infos]
-        for model_info in model_infos:
-            print('processing: ', model_info['config'], flush=True)
-            config_path = model_info['config'].strip()
-            config_name = osp.splitext(osp.basename(config_path))[0]
-            checkpoint_name = model_info['checkpoint'].strip()
-            checkpoint = osp.join(args.checkpoint_root, checkpoint_name)
-
-            # ensure checkpoint exists
-            try:
-                if not osp.exists(checkpoint):
-                    download_checkpoint(checkpoint_name, model_name,
-                                        config_name.rstrip('.py'),
-                                        args.checkpoint_root)
-            except Exception:
-                logger.error(f'{checkpoint_name} download error')
-                continue
-
-            # test model inference with checkpoint
-            try:
-                # build the model from a config file and a checkpoint file
-                inference(config_path, checkpoint, args, logger)
-            except Exception as e:
-                logger.error(f'{config_path} " : {repr(e)}')
-
-
-if __name__ == '__main__':
-    args = parse_args()
-    main(args)
diff --git a/mmsegmentation/.dev_scripts/benchmark_options.py b/mmsegmentation/.dev_scripts/benchmark_options.py
deleted file mode 100644
index 51909a0..0000000
--- a/mmsegmentation/.dev_scripts/benchmark_options.py
+++ /dev/null
@@ -1,10 +0,0 @@
-third_part_libs = [
-    'pip install mmengine',
-    'pip install mmcv>=2.0.0',
-    'pip install mmcls==1.0.0rc6',
-    'pip install mmdet==3.0.0',
-    'pip install -r requirements.txt',
-    'pip install timm',
-]
-
-default_floating_range = 0.5
diff --git a/mmsegmentation/.dev_scripts/benchmark_train.sh b/mmsegmentation/.dev_scripts/benchmark_train.sh
deleted file mode 100755
index cde47a0..0000000
--- a/mmsegmentation/.dev_scripts/benchmark_train.sh
+++ /dev/null
@@ -1,40 +0,0 @@
-PARTITION=$1
-
-echo 'configs/hrnet/fcn_hr18s_512x512_160k_ade20k.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION fcn_hr18s_512x512_160k_ade20k configs/hrnet/fcn_hr18s_512x512_160k_ade20k.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24727 --work-dir work_dirs/hrnet/fcn_hr18s_512x512_160k_ade20k >/dev/null &
-echo 'configs/hrnet/fcn_hr18s_512x1024_160k_cityscapes.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION fcn_hr18s_512x1024_160k_cityscapes configs/hrnet/fcn_hr18s_512x1024_160k_cityscapes.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24728 --work-dir work_dirs/hrnet/fcn_hr18s_512x1024_160k_cityscapes >/dev/null &
-echo 'configs/hrnet/fcn_hr48_512x512_160k_ade20k.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION fcn_hr48_512x512_160k_ade20k configs/hrnet/fcn_hr48_512x512_160k_ade20k.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24729 --work-dir work_dirs/hrnet/fcn_hr48_512x512_160k_ade20k >/dev/null &
-echo 'configs/hrnet/fcn_hr48_512x1024_160k_cityscapes.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION fcn_hr48_512x1024_160k_cityscapes configs/hrnet/fcn_hr48_512x1024_160k_cityscapes.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24730 --work-dir work_dirs/hrnet/fcn_hr48_512x1024_160k_cityscapes >/dev/null &
-echo 'configs/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION pspnet_r50-d8_512x1024_80k_cityscapes configs/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24731 --work-dir work_dirs/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes >/dev/null &
-echo 'configs/pspnet/pspnet_r101-d8_512x1024_80k_cityscapes.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION pspnet_r101-d8_512x1024_80k_cityscapes configs/pspnet/pspnet_r101-d8_512x1024_80k_cityscapes.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24732 --work-dir work_dirs/pspnet/pspnet_r101-d8_512x1024_80k_cityscapes >/dev/null &
-echo 'configs/pspnet/pspnet_r101-d8_512x512_160k_ade20k.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION pspnet_r101-d8_512x512_160k_ade20k configs/pspnet/pspnet_r101-d8_512x512_160k_ade20k.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24733 --work-dir work_dirs/pspnet/pspnet_r101-d8_512x512_160k_ade20k >/dev/null &
-echo 'configs/pspnet/pspnet_r50-d8_512x512_160k_ade20k.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION pspnet_r50-d8_512x512_160k_ade20k configs/pspnet/pspnet_r50-d8_512x512_160k_ade20k.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24734 --work-dir work_dirs/pspnet/pspnet_r50-d8_512x512_160k_ade20k >/dev/null &
-echo 'configs/resnest/pspnet_s101-d8_512x512_160k_ade20k.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION pspnet_s101-d8_512x512_160k_ade20k configs/resnest/pspnet_s101-d8_512x512_160k_ade20k.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24735 --work-dir work_dirs/resnest/pspnet_s101-d8_512x512_160k_ade20k >/dev/null &
-echo 'configs/resnest/pspnet_s101-d8_512x1024_80k_cityscapes.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION pspnet_s101-d8_512x1024_80k_cityscapes configs/resnest/pspnet_s101-d8_512x1024_80k_cityscapes.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24736 --work-dir work_dirs/resnest/pspnet_s101-d8_512x1024_80k_cityscapes >/dev/null &
-echo 'configs/fastscnn/fast_scnn_lr0.12_8x4_160k_cityscapes.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION fast_scnn_lr0.12_8x4_160k_cityscapes configs/fastscnn/fast_scnn_lr0.12_8x4_160k_cityscapes.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24737 --work-dir work_dirs/fastscnn/fast_scnn_lr0.12_8x4_160k_cityscapes >/dev/null &
-echo 'configs/deeplabv3plus/deeplabv3plus_r101-d8_769x769_80k_cityscapes.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION deeplabv3plus_r101-d8_769x769_80k_cityscapes configs/deeplabv3plus/deeplabv3plus_r101-d8_769x769_80k_cityscapes.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24738 --work-dir work_dirs/deeplabv3plus/deeplabv3plus_r101-d8_769x769_80k_cityscapes >/dev/null &
-echo 'configs/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_80k_cityscapes.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION deeplabv3plus_r101-d8_512x1024_80k_cityscapes configs/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_80k_cityscapes.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24739 --work-dir work_dirs/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_80k_cityscapes >/dev/null &
-echo 'configs/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_80k_cityscapes.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION deeplabv3plus_r50-d8_512x1024_80k_cityscapes configs/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_80k_cityscapes.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24740 --work-dir work_dirs/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_80k_cityscapes >/dev/null &
-echo 'configs/deeplabv3plus/deeplabv3plus_r50-d8_769x769_80k_cityscapes.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION deeplabv3plus_r50-d8_769x769_80k_cityscapes configs/deeplabv3plus/deeplabv3plus_r50-d8_769x769_80k_cityscapes.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24741 --work-dir work_dirs/deeplabv3plus/deeplabv3plus_r50-d8_769x769_80k_cityscapes >/dev/null &
-echo 'configs/vit/upernet_vit-b16_ln_mln_512x512_160k_ade20k.py' &
-GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION upernet_vit-b16_ln_mln_512x512_160k_ade20k configs/vit/upernet_vit-b16_ln_mln_512x512_160k_ade20k.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24742 --work-dir work_dirs/vit/upernet_vit-b16_ln_mln_512x512_160k_ade20k >/dev/null &
-echo 'configs/vit/upernet_deit-s16_ln_mln_512x512_160k_ade20k.py' &
-GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION upernet_deit-s16_ln_mln_512x512_160k_ade20k configs/vit/upernet_deit-s16_ln_mln_512x512_160k_ade20k.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24743 --work-dir work_dirs/vit/upernet_deit-s16_ln_mln_512x512_160k_ade20k >/dev/null &
-echo 'configs/deeplabv3plus/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes.py' &
-GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION deeplabv3plus_r101-d8_512x1024_80k_fp16_cityscapes configs/deeplabv3plus/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24744 --work-dir work_dirs/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_80k_fp16_cityscapes >/dev/null &
-echo 'configs/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K.py' &
-GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh $PARTITION upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K configs/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K.py --cfg-options checkpoint_config.max_keep_ckpts=1 dist_params.port=24745 --work-dir work_dirs/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K >/dev/null &
diff --git a/mmsegmentation/.dev_scripts/benchmark_train_models.txt b/mmsegmentation/.dev_scripts/benchmark_train_models.txt
deleted file mode 100644
index 01f279d..0000000
--- a/mmsegmentation/.dev_scripts/benchmark_train_models.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-bisenetv1/bisenetv1_r18-d32_4xb4-160k_coco-stuff164k-512x512.py
-bisenetv2/bisenetv2_fcn_4xb4-ohem-160k_cityscapes-1024x1024.py
-deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py
-deeplabv3/deeplabv3_r101-d8_4xb4-160k_ade20k-512x512.py
-deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-769x769.py
-deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_ade20k-512x512.py
-hrnet/fcn_hr18s_4xb4-80k_ade20k-512x512.py
-hrnet/fcn_hr18_4xb2-160k_cityscapes-512x1024.py
-knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-512x512.py
-knet/knet-s3_r50-d8_pspnet_8xb2-adamw-80k_ade20k-512x512.py
-mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512.py
-mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py
-maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512.py
-mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py
-ocrnet/ocrnet_hr48_4xb4-80k_ade20k-512x512.py
-pidnet/pidnet-m_2xb6-120k_1024x1024-cityscapes.py
-pspnet/pspnet_r50-d8-rsb_4xb2-adamw-80k_cityscapes-512x1024.py
-pspnet/pspnet_r101-d8_4xb4-80k_ade20k-512x512.py
-segformer/segformer_mit-b5_8xb2-160k_ade20k-512x512.py
-segmenter/segmenter_vit-t_mask_8xb1-160k_ade20k-512x512.py
-segnext/segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512.py
-swin/swin-base-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
-twins/twins_pcpvt-l_uperhead_8xb2-160k_ade20k-512x512.py
-unet/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py
-upernet/upernet_r101_4xb2-40k_cityscapes-512x1024.py
-san/san-vit-b16_coco-stuff164k-640x640.py
diff --git a/mmsegmentation/.dev_scripts/check_urls.py b/mmsegmentation/.dev_scripts/check_urls.py
deleted file mode 100644
index 58a1354..0000000
--- a/mmsegmentation/.dev_scripts/check_urls.py
+++ /dev/null
@@ -1,100 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import logging
-import os
-from argparse import ArgumentParser
-
-import requests
-import yaml as yml
-
-from mmseg.utils import get_root_logger
-
-
-def check_url(url):
-    """Check url response status.
-
-    Args:
-        url (str): url needed to check.
-
-    Returns:
-        int, bool: status code and check flag.
-    """
-    flag = True
-    r = requests.head(url)
-    status_code = r.status_code
-    if status_code == 403 or status_code == 404:
-        flag = False
-
-    return status_code, flag
-
-
-def parse_args():
-    parser = ArgumentParser('url valid check.')
-    parser.add_argument(
-        '-m',
-        '--model-name',
-        type=str,
-        help='Select the model needed to check')
-
-    args = parser.parse_args()
-    return args
-
-
-def main():
-    args = parse_args()
-    model_name = args.model_name
-
-    # yml path generate.
-    # If model_name is not set, script will check all of the models.
-    if model_name is not None:
-        yml_list = [(model_name, f'configs/{model_name}/{model_name}.yml')]
-    else:
-        # check all
-        yml_list = [(x, f'configs/{x}/{x}.yml') for x in os.listdir('configs/')
-                    if x != '_base_']
-
-    logger = get_root_logger(log_file='url_check.log', log_level=logging.ERROR)
-
-    for model_name, yml_path in yml_list:
-        # Default yaml loader unsafe.
-        model_infos = yml.load(open(yml_path), Loader=yml.CLoader)['Models']
-        for model_info in model_infos:
-            config_name = model_info['Name']
-            checkpoint_url = model_info['Weights']
-            # checkpoint url check
-            status_code, flag = check_url(checkpoint_url)
-            if flag:
-                logger.info(f'checkpoint | {config_name} | {checkpoint_url} | '
-                            f'{status_code} valid')
-            else:
-                logger.error(
-                    f'checkpoint | {config_name} | {checkpoint_url} | '
-                    f'{status_code} | error')
-            # log_json check
-            checkpoint_name = checkpoint_url.split('/')[-1]
-            model_time = '-'.join(checkpoint_name.split('-')[:-1]).replace(
-                f'{config_name}_', '')
-            # two style of log_json name
-            # use '_' to link model_time (will be deprecated)
-            log_json_url_1 = f'https://download.openmmlab.com/mmsegmentation/v0.5/{model_name}/{config_name}/{config_name}_{model_time}.log.json'  # noqa
-            status_code_1, flag_1 = check_url(log_json_url_1)
-            # use '-' to link model_time
-            log_json_url_2 = f'https://download.openmmlab.com/mmsegmentation/v0.5/{model_name}/{config_name}/{config_name}-{model_time}.log.json'  # noqa
-            status_code_2, flag_2 = check_url(log_json_url_2)
-            if flag_1 or flag_2:
-                if flag_1:
-                    logger.info(
-                        f'log.json | {config_name} | {log_json_url_1} | '
-                        f'{status_code_1} | valid')
-                else:
-                    logger.info(
-                        f'log.json | {config_name} | {log_json_url_2} | '
-                        f'{status_code_2} | valid')
-            else:
-                logger.error(
-                    f'log.json | {config_name} | {log_json_url_1} & '
-                    f'{log_json_url_2} | {status_code_1} & {status_code_2} | '
-                    'error')
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/.dev_scripts/gather_benchmark_evaluation_results.py b/mmsegmentation/.dev_scripts/gather_benchmark_evaluation_results.py
deleted file mode 100644
index fec83f1..0000000
--- a/mmsegmentation/.dev_scripts/gather_benchmark_evaluation_results.py
+++ /dev/null
@@ -1,91 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import glob
-import os.path as osp
-
-from mmengine import Config
-from mmengine.fileio import dump, load
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Gather benchmarked model evaluation results')
-    parser.add_argument('config', help='test config file path')
-    parser.add_argument(
-        'root',
-        type=str,
-        help='root path of benchmarked models to be gathered')
-    parser.add_argument(
-        '--out',
-        type=str,
-        default='benchmark_evaluation_info.json',
-        help='output path of gathered metrics and compared '
-        'results to be stored')
-
-    args = parser.parse_args()
-    return args
-
-
-if __name__ == '__main__':
-    args = parse_args()
-
-    root_path = args.root
-    metrics_out = args.out
-    result_dict = {}
-
-    cfg = Config.fromfile(args.config)
-
-    for model_key in cfg:
-        model_infos = cfg[model_key]
-        if not isinstance(model_infos, list):
-            model_infos = [model_infos]
-        for model_info in model_infos:
-            previous_metrics = model_info['metric']
-            config = model_info['config'].strip()
-            fname, _ = osp.splitext(osp.basename(config))
-
-            # Load benchmark evaluation json
-            metric_json_dir = osp.join(root_path, fname)
-            if not osp.exists(metric_json_dir):
-                print(f'{metric_json_dir} not existed.')
-                continue
-
-            json_list = glob.glob(osp.join(metric_json_dir, '*.json'))
-            if len(json_list) == 0:
-                print(f'There is no eval json in {metric_json_dir}.')
-                continue
-
-            log_json_path = list(sorted(json_list))[-1]
-            metric = load(log_json_path)
-            if config not in metric.get('config', {}):
-                print(f'{config} not included in {log_json_path}')
-                continue
-
-            # Compare between new benchmark results and previous metrics
-            differential_results = dict()
-            new_metrics = dict()
-            for record_metric_key in previous_metrics:
-                if record_metric_key not in metric['metric']:
-                    raise KeyError('record_metric_key not exist, please '
-                                   'check your config')
-                old_metric = previous_metrics[record_metric_key]
-                new_metric = round(metric['metric'][record_metric_key] * 100,
-                                   2)
-
-                differential = new_metric - old_metric
-                flag = '+' if differential > 0 else '-'
-                differential_results[
-                    record_metric_key] = f'{flag}{abs(differential):.2f}'
-                new_metrics[record_metric_key] = new_metric
-
-            result_dict[config] = dict(
-                differential=differential_results,
-                previous=previous_metrics,
-                new=new_metrics)
-
-    if metrics_out:
-        dump(result_dict, metrics_out, indent=4)
-    print('===================================')
-    for config_name, metrics in result_dict.items():
-        print(config_name, metrics)
-    print('===================================')
diff --git a/mmsegmentation/.dev_scripts/gather_benchmark_train_results.py b/mmsegmentation/.dev_scripts/gather_benchmark_train_results.py
deleted file mode 100644
index f801a0d..0000000
--- a/mmsegmentation/.dev_scripts/gather_benchmark_train_results.py
+++ /dev/null
@@ -1,100 +0,0 @@
-import argparse
-import glob
-import os.path as osp
-
-from gather_models import get_final_results
-from mmengine import Config
-from mmengine.fileio import dump
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Gather benchmarked models train results')
-    parser.add_argument('config', help='test config file path')
-    parser.add_argument(
-        'root',
-        type=str,
-        help='root path of benchmarked models to be gathered')
-    parser.add_argument(
-        '--out',
-        type=str,
-        default='benchmark_train_info.json',
-        help='output path of gathered metrics to be stored')
-
-    args = parser.parse_args()
-    return args
-
-
-if __name__ == '__main__':
-    args = parse_args()
-
-    root_path = args.root
-    metrics_out = args.out
-
-    evaluation_cfg = Config.fromfile(args.config)
-
-    result_dict = {}
-    for model_key in evaluation_cfg:
-        model_infos = evaluation_cfg[model_key]
-        if not isinstance(model_infos, list):
-            model_infos = [model_infos]
-        for model_info in model_infos:
-            config = model_info['config']
-
-            # benchmark train dir
-            model_name = osp.split(osp.dirname(config))[1]
-            config_name = osp.splitext(osp.basename(config))[0]
-            exp_dir = osp.join(root_path, model_name, config_name)
-            if not osp.exists(exp_dir):
-                print(f'{config} hasn\'t {exp_dir}')
-                continue
-
-            # parse config
-            cfg = Config.fromfile(config)
-            total_iters = cfg.runner.max_iters
-            exp_metric = cfg.evaluation.metric
-            if not isinstance(exp_metric, list):
-                exp_metrics = [exp_metric]
-
-            # determine whether total_iters ckpt exists
-            ckpt_path = f'iter_{total_iters}.pth'
-            if not osp.exists(osp.join(exp_dir, ckpt_path)):
-                print(f'{config} hasn\'t {ckpt_path}')
-                continue
-
-            # only the last log json counts
-            log_json_path = list(
-                sorted(glob.glob(osp.join(exp_dir, '*.log.json'))))[-1]
-
-            # extract metric value
-            model_performance = get_final_results(log_json_path, total_iters)
-            if model_performance is None:
-                print(f'log file error: {log_json_path}')
-                continue
-
-            differential_results = dict()
-            old_results = dict()
-            new_results = dict()
-            for metric_key in model_performance:
-                if metric_key in ['mIoU']:
-                    metric = round(model_performance[metric_key] * 100, 2)
-                    old_metric = model_info['metric'][metric_key]
-                    old_results[metric_key] = old_metric
-                    new_results[metric_key] = metric
-                    differential = metric - old_metric
-                    flag = '+' if differential > 0 else '-'
-                    differential_results[
-                        metric_key] = f'{flag}{abs(differential):.2f}'
-            result_dict[config] = dict(
-                differential_results=differential_results,
-                old_results=old_results,
-                new_results=new_results,
-            )
-
-    # 4 save or print results
-    if metrics_out:
-        dump(result_dict, metrics_out, indent=4)
-    print('===================================')
-    for config_name, metrics in result_dict.items():
-        print(config_name, metrics)
-    print('===================================')
diff --git a/mmsegmentation/.dev_scripts/gather_models.py b/mmsegmentation/.dev_scripts/gather_models.py
deleted file mode 100644
index fe6c390..0000000
--- a/mmsegmentation/.dev_scripts/gather_models.py
+++ /dev/null
@@ -1,213 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import glob
-import hashlib
-import json
-import os
-import os.path as osp
-import shutil
-
-import torch
-from mmengine import Config
-from mmengine.fileio import dump
-from mmengine.utils import mkdir_or_exist, scandir
-
-# build schedule look-up table to automatically find the final model
-RESULTS_LUT = ['mIoU', 'mAcc', 'aAcc']
-
-
-def calculate_file_sha256(file_path):
-    """calculate file sha256 hash code."""
-    with open(file_path, 'rb') as fp:
-        sha256_cal = hashlib.sha256()
-        sha256_cal.update(fp.read())
-        return sha256_cal.hexdigest()
-
-
-def process_checkpoint(in_file, out_file):
-    checkpoint = torch.load(in_file, map_location='cpu')
-    # remove optimizer for smaller file size
-    if 'optimizer' in checkpoint:
-        del checkpoint['optimizer']
-    # if it is necessary to remove some sensitive data in checkpoint['meta'],
-    # add the code here.
-    torch.save(checkpoint, out_file)
-    # The hash code calculation and rename command differ on different system
-    # platform.
-    sha = calculate_file_sha256(out_file)
-    final_file = out_file.rstrip('.pth') + f'-{sha[:8]}.pth'
-    os.rename(out_file, final_file)
-
-    # Remove prefix and suffix
-    final_file_name = osp.split(final_file)[1]
-    final_file_name = osp.splitext(final_file_name)[0]
-
-    return final_file_name
-
-
-def get_final_iter(config):
-    iter_num = config.split('_')[-2]
-    assert iter_num.endswith('k')
-    return int(iter_num[:-1]) * 1000
-
-
-def get_final_results(log_json_path, iter_num):
-    result_dict = dict()
-    last_iter = 0
-    with open(log_json_path) as f:
-        for line in f.readlines():
-            log_line = json.loads(line)
-            if 'mode' not in log_line.keys():
-                continue
-
-            # When evaluation, the 'iter' of new log json is the evaluation
-            # steps on single gpu.
-            flag1 = ('aAcc' in log_line) or (log_line['mode'] == 'val')
-            flag2 = (last_iter == iter_num - 50) or (last_iter == iter_num)
-            if flag1 and flag2:
-                result_dict.update({
-                    key: log_line[key]
-                    for key in RESULTS_LUT if key in log_line
-                })
-                return result_dict
-
-            last_iter = log_line['iter']
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(description='Gather benchmarked models')
-    parser.add_argument(
-        '-f', '--config-name', type=str, help='Process the selected config.')
-    parser.add_argument(
-        '-w',
-        '--work-dir',
-        default='work_dirs/',
-        type=str,
-        help='Ckpt storage root folder of benchmarked models to be gathered.')
-    parser.add_argument(
-        '-c',
-        '--collect-dir',
-        default='work_dirs/gather',
-        type=str,
-        help='Ckpt collect root folder of gathered models.')
-    parser.add_argument(
-        '--all', action='store_true', help='whether include .py and .log')
-
-    args = parser.parse_args()
-    return args
-
-
-def main():
-    args = parse_args()
-    work_dir = args.work_dir
-    collect_dir = args.collect_dir
-    selected_config_name = args.config_name
-    mkdir_or_exist(collect_dir)
-
-    # find all models in the root directory to be gathered
-    raw_configs = list(scandir('./configs', '.py', recursive=True))
-
-    # filter configs that is not trained in the experiments dir
-    used_configs = []
-    for raw_config in raw_configs:
-        config_name = osp.splitext(osp.basename(raw_config))[0]
-        if osp.exists(osp.join(work_dir, config_name)):
-            if (selected_config_name is None
-                    or selected_config_name == config_name):
-                used_configs.append(raw_config)
-    print(f'Find {len(used_configs)} models to be gathered')
-
-    # find final_ckpt and log file for trained each config
-    # and parse the best performance
-    model_infos = []
-    for used_config in used_configs:
-        config_name = osp.splitext(osp.basename(used_config))[0]
-        exp_dir = osp.join(work_dir, config_name)
-        # check whether the exps is finished
-        final_iter = get_final_iter(used_config)
-        final_model = f'iter_{final_iter}.pth'
-        model_path = osp.join(exp_dir, final_model)
-
-        # skip if the model is still training
-        if not osp.exists(model_path):
-            print(f'{used_config} train not finished yet')
-            continue
-
-        # get logs
-        log_json_paths = glob.glob(osp.join(exp_dir, '*.log.json'))
-        log_json_path = log_json_paths[0]
-        model_performance = None
-        for idx, _log_json_path in enumerate(log_json_paths):
-            model_performance = get_final_results(_log_json_path, final_iter)
-            if model_performance is not None:
-                log_json_path = _log_json_path
-                break
-
-        if model_performance is None:
-            print(f'{used_config} model_performance is None')
-            continue
-
-        model_time = osp.split(log_json_path)[-1].split('.')[0]
-        model_infos.append(
-            dict(
-                config_name=config_name,
-                results=model_performance,
-                iters=final_iter,
-                model_time=model_time,
-                log_json_path=osp.split(log_json_path)[-1]))
-
-    # publish model for each checkpoint
-    publish_model_infos = []
-    for model in model_infos:
-        config_name = model['config_name']
-        model_publish_dir = osp.join(collect_dir, config_name)
-
-        publish_model_path = osp.join(model_publish_dir,
-                                      config_name + '_' + model['model_time'])
-        trained_model_path = osp.join(work_dir, config_name,
-                                      'iter_{}.pth'.format(model['iters']))
-        if osp.exists(model_publish_dir):
-            for file in os.listdir(model_publish_dir):
-                if file.endswith('.pth'):
-                    print(f'model {file} found')
-                    model['model_path'] = osp.abspath(
-                        osp.join(model_publish_dir, file))
-                    break
-            if 'model_path' not in model:
-                print(f'dir {model_publish_dir} exists, no model found')
-
-        else:
-            mkdir_or_exist(model_publish_dir)
-
-            # convert model
-            final_model_path = process_checkpoint(trained_model_path,
-                                                  publish_model_path)
-            model['model_path'] = final_model_path
-
-        new_json_path = f'{config_name}_{model["log_json_path"]}'
-        # copy log
-        shutil.copy(
-            osp.join(work_dir, config_name, model['log_json_path']),
-            osp.join(model_publish_dir, new_json_path))
-
-        if args.all:
-            new_txt_path = new_json_path.rstrip('.json')
-            shutil.copy(
-                osp.join(work_dir, config_name,
-                         model['log_json_path'].rstrip('.json')),
-                osp.join(model_publish_dir, new_txt_path))
-
-        if args.all:
-            # copy config to guarantee reproducibility
-            raw_config = osp.join('./configs', f'{config_name}.py')
-            Config.fromfile(raw_config).dump(
-                osp.join(model_publish_dir, osp.basename(raw_config)))
-
-        publish_model_infos.append(model)
-
-    models = dict(models=publish_model_infos)
-    dump(models, osp.join(collect_dir, 'model_infos.json'), indent=4)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/.dev_scripts/generate_benchmark_evaluation_script.py b/mmsegmentation/.dev_scripts/generate_benchmark_evaluation_script.py
deleted file mode 100644
index 4c48f85..0000000
--- a/mmsegmentation/.dev_scripts/generate_benchmark_evaluation_script.py
+++ /dev/null
@@ -1,114 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os.path as osp
-
-from mmengine import Config
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Convert benchmark test model list to script')
-    parser.add_argument('config', help='test config file path')
-    parser.add_argument('--port', type=int, default=28171, help='dist port')
-    parser.add_argument(
-        '--work-dir',
-        default='work_dirs/benchmark_evaluation',
-        help='the dir to save metric')
-    parser.add_argument(
-        '--out',
-        type=str,
-        default='.dev_scripts/benchmark_evaluation.sh',
-        help='path to save model benchmark script')
-
-    args = parser.parse_args()
-    return args
-
-
-def process_model_info(model_info, work_dir):
-    config = model_info['config'].strip()
-    fname, _ = osp.splitext(osp.basename(config))
-    job_name = fname
-    checkpoint = model_info['checkpoint'].strip()
-    work_dir = osp.join(work_dir, fname)
-    if not isinstance(model_info['eval'], list):
-        evals = [model_info['eval']]
-    else:
-        evals = model_info['eval']
-    eval = ' '.join(evals)
-    return dict(
-        config=config,
-        job_name=job_name,
-        checkpoint=checkpoint,
-        work_dir=work_dir,
-        eval=eval)
-
-
-def create_test_bash_info(commands, model_test_dict, port, script_name,
-                          partition):
-    config = model_test_dict['config']
-    job_name = model_test_dict['job_name']
-    checkpoint = model_test_dict['checkpoint']
-    work_dir = model_test_dict['work_dir']
-    eval = model_test_dict['eval']
-
-    echo_info = f'\necho \'{config}\' &'
-    commands.append(echo_info)
-    commands.append('\n')
-
-    command_info = f'GPUS=4  GPUS_PER_NODE=4  ' \
-                   f'CPUS_PER_TASK=2 {script_name} '
-
-    command_info += f'{partition} '
-    command_info += f'{job_name} '
-    command_info += f'{config} '
-    command_info += f'$CHECKPOINT_DIR/{checkpoint} '
-
-    command_info += f'--eval {eval} '
-    command_info += f'--work-dir {work_dir} '
-    command_info += f'--cfg-options dist_params.port={port} '
-    command_info += '&'
-
-    commands.append(command_info)
-
-
-def main():
-    args = parse_args()
-    if args.out:
-        out_suffix = args.out.split('.')[-1]
-        assert args.out.endswith('.sh'), \
-            f'Expected out file path suffix is .sh, but get .{out_suffix}'
-
-    commands = []
-    partition_name = 'PARTITION=$1'
-    commands.append(partition_name)
-    commands.append('\n')
-
-    checkpoint_root = 'CHECKPOINT_DIR=$2'
-    commands.append(checkpoint_root)
-    commands.append('\n')
-
-    script_name = osp.join('tools', 'slurm_test.sh')
-    port = args.port
-    work_dir = args.work_dir
-
-    cfg = Config.fromfile(args.config)
-
-    for model_key in cfg:
-        model_infos = cfg[model_key]
-        if not isinstance(model_infos, list):
-            model_infos = [model_infos]
-        for model_info in model_infos:
-            print('processing: ', model_info['config'])
-            model_test_dict = process_model_info(model_info, work_dir)
-            create_test_bash_info(commands, model_test_dict, port, script_name,
-                                  '$PARTITION')
-            port += 1
-
-    command_str = ''.join(commands)
-    if args.out:
-        with open(args.out, 'w') as f:
-            f.write(command_str + '\n')
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/.dev_scripts/generate_benchmark_train_script.py b/mmsegmentation/.dev_scripts/generate_benchmark_train_script.py
deleted file mode 100644
index 4bfdfbf..0000000
--- a/mmsegmentation/.dev_scripts/generate_benchmark_train_script.py
+++ /dev/null
@@ -1,91 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os.path as osp
-
-# Default using 4 gpu when training
-config_8gpu_list = [
-    'configs/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K.py',  # noqa
-    'configs/vit/upernet_vit-b16_ln_mln_512x512_160k_ade20k.py',
-    'configs/vit/upernet_deit-s16_ln_mln_512x512_160k_ade20k.py',
-]
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Convert benchmark model json to script')
-    parser.add_argument(
-        'txt_path', type=str, help='txt path output by benchmark_filter')
-    parser.add_argument('--port', type=int, default=24727, help='dist port')
-    parser.add_argument(
-        '--out',
-        type=str,
-        default='.dev_scripts/benchmark_train.sh',
-        help='path to save model benchmark script')
-
-    args = parser.parse_args()
-    return args
-
-
-def create_train_bash_info(commands, config, script_name, partition, port):
-    cfg = config.strip()
-
-    # print cfg name
-    echo_info = f'echo \'{cfg}\' &'
-    commands.append(echo_info)
-    commands.append('\n')
-
-    _, model_name = osp.split(osp.dirname(cfg))
-    config_name, _ = osp.splitext(osp.basename(cfg))
-    # default setting
-    if cfg in config_8gpu_list:
-        command_info = f'GPUS=8  GPUS_PER_NODE=8  ' \
-                        f'CPUS_PER_TASK=2 {script_name} '
-    else:
-        command_info = f'GPUS=4  GPUS_PER_NODE=4  ' \
-                        f'CPUS_PER_TASK=2 {script_name} '
-    command_info += f'{partition} '
-    command_info += f'{config_name} '
-    command_info += f'{cfg} '
-    command_info += f'--cfg-options ' \
-                    f'checkpoint_config.max_keep_ckpts=1 ' \
-                    f'dist_params.port={port} '
-    command_info += f'--work-dir work_dirs/{model_name}/{config_name} '
-    # Let the script shut up
-    command_info += '>/dev/null &'
-
-    commands.append(command_info)
-    commands.append('\n')
-
-
-def main():
-    args = parse_args()
-    if args.out:
-        out_suffix = args.out.split('.')[-1]
-        assert args.out.endswith('.sh'), \
-            f'Expected out file path suffix is .sh, but get .{out_suffix}'
-
-    root_name = './tools'
-    script_name = osp.join(root_name, 'slurm_train.sh')
-    port = args.port
-    partition_name = 'PARTITION=$1'
-
-    commands = []
-    commands.append(partition_name)
-    commands.append('\n')
-    commands.append('\n')
-
-    with open(args.txt_path) as f:
-        model_cfgs = f.readlines()
-        for i, cfg in enumerate(model_cfgs):
-            create_train_bash_info(commands, cfg, script_name, '$PARTITION',
-                                   port)
-            port += 1
-
-        command_str = ''.join(commands)
-        if args.out:
-            with open(args.out, 'w') as f:
-                f.write(command_str)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/.dev_scripts/log_collector/example_config.py b/mmsegmentation/.dev_scripts/log_collector/example_config.py
deleted file mode 100644
index bc2b4d6..0000000
--- a/mmsegmentation/.dev_scripts/log_collector/example_config.py
+++ /dev/null
@@ -1,18 +0,0 @@
-work_dir = '../../work_dirs'
-metric = 'mIoU'
-
-# specify the log files we would like to collect in `log_items`
-log_items = [
-    'segformer_mit-b5_512x512_160k_ade20k_cnn_lr_with_warmup',
-    'segformer_mit-b5_512x512_160k_ade20k_cnn_no_warmup_lr',
-    'segformer_mit-b5_512x512_160k_ade20k_mit_trans_lr',
-    'segformer_mit-b5_512x512_160k_ade20k_swin_trans_lr'
-]
-# or specify ignore_keywords, then the folders whose name contain
-# `'segformer'` won't be collected
-# ignore_keywords = ['segformer']
-
-# should not include metric
-other_info_keys = ['mAcc']
-markdown_file = 'markdowns/lr_in_trans.json.md'
-json_file = 'jsons/trans_in_cnn.json'
diff --git a/mmsegmentation/.dev_scripts/log_collector/log_collector.py b/mmsegmentation/.dev_scripts/log_collector/log_collector.py
deleted file mode 100644
index 0c2ff61..0000000
--- a/mmsegmentation/.dev_scripts/log_collector/log_collector.py
+++ /dev/null
@@ -1,143 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import datetime
-import json
-import os
-import os.path as osp
-from collections import OrderedDict
-
-from utils import load_config
-
-# automatically collect all the results
-
-# The structure of the directory:
-#     ├── work-dir
-#     │   ├── config_1
-#     │   │   ├── time1.log.json
-#     │   │   ├── time2.log.json
-#     │   │   ├── time3.log.json
-#     │   │   ├── time4.log.json
-#     │   ├── config_2
-#     │   │   ├── time5.log.json
-#     │   │   ├── time6.log.json
-#     │   │   ├── time7.log.json
-#     │   │   ├── time8.log.json
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(description='extract info from log.json')
-    parser.add_argument('config_dir')
-    args = parser.parse_args()
-    return args
-
-
-def has_keyword(name: str, keywords: list):
-    for a_keyword in keywords:
-        if a_keyword in name:
-            return True
-    return False
-
-
-def main():
-    args = parse_args()
-    cfg = load_config(args.config_dir)
-    work_dir = cfg['work_dir']
-    metric = cfg['metric']
-    log_items = cfg.get('log_items', [])
-    ignore_keywords = cfg.get('ignore_keywords', [])
-    other_info_keys = cfg.get('other_info_keys', [])
-    markdown_file = cfg.get('markdown_file', None)
-    json_file = cfg.get('json_file', None)
-
-    if json_file and osp.split(json_file)[0] != '':
-        os.makedirs(osp.split(json_file)[0], exist_ok=True)
-    if markdown_file and osp.split(markdown_file)[0] != '':
-        os.makedirs(osp.split(markdown_file)[0], exist_ok=True)
-
-    assert not (log_items and ignore_keywords), \
-        'log_items and ignore_keywords cannot be specified at the same time'
-    assert metric not in other_info_keys, \
-        'other_info_keys should not contain metric'
-
-    if ignore_keywords and isinstance(ignore_keywords, str):
-        ignore_keywords = [ignore_keywords]
-    if other_info_keys and isinstance(other_info_keys, str):
-        other_info_keys = [other_info_keys]
-    if log_items and isinstance(log_items, str):
-        log_items = [log_items]
-
-    if not log_items:
-        log_items = [
-            item for item in sorted(os.listdir(work_dir))
-            if not has_keyword(item, ignore_keywords)
-        ]
-
-    experiment_info_list = []
-    for config_dir in log_items:
-        preceding_path = os.path.join(work_dir, config_dir)
-        log_list = [
-            item for item in os.listdir(preceding_path)
-            if item.endswith('.log.json')
-        ]
-        log_list = sorted(
-            log_list,
-            key=lambda time_str: datetime.datetime.strptime(
-                time_str, '%Y%m%d_%H%M%S.log.json'))
-        val_list = []
-        last_iter = 0
-        for log_name in log_list:
-            with open(os.path.join(preceding_path, log_name)) as f:
-                # ignore the info line
-                f.readline()
-                all_lines = f.readlines()
-                val_list.extend([
-                    json.loads(line) for line in all_lines
-                    if json.loads(line)['mode'] == 'val'
-                ])
-                for index in range(len(all_lines) - 1, -1, -1):
-                    line_dict = json.loads(all_lines[index])
-                    if line_dict['mode'] == 'train':
-                        last_iter = max(last_iter, line_dict['iter'])
-                        break
-
-        new_log_dict = dict(
-            method=config_dir, metric_used=metric, last_iter=last_iter)
-        for index, log in enumerate(val_list, 1):
-            new_ordered_dict = OrderedDict()
-            new_ordered_dict['eval_index'] = index
-            new_ordered_dict[metric] = log[metric]
-            for key in other_info_keys:
-                if key in log:
-                    new_ordered_dict[key] = log[key]
-            val_list[index - 1] = new_ordered_dict
-
-        assert len(val_list) >= 1, \
-            f"work dir {config_dir} doesn't contain any evaluation."
-        new_log_dict['last eval'] = val_list[-1]
-        new_log_dict['best eval'] = max(val_list, key=lambda x: x[metric])
-        experiment_info_list.append(new_log_dict)
-        print(f'{config_dir} is processed')
-
-    if json_file:
-        with open(json_file, 'w') as f:
-            json.dump(experiment_info_list, f, indent=4)
-
-    if markdown_file:
-        lines_to_write = []
-        for index, log in enumerate(experiment_info_list, 1):
-            lines_to_write.append(
-                f"|{index}|{log['method']}|{log['best eval'][metric]}"
-                f"|{log['best eval']['eval_index']}|"
-                f"{log['last eval'][metric]}|"
-                f"{log['last eval']['eval_index']}|{log['last_iter']}|\n")
-        with open(markdown_file, 'w') as f:
-            f.write(f'|exp_num|method|{metric} best|best index|'
-                    f'{metric} last|last index|last iter num|\n')
-            f.write('|:---:|:---:|:---:|:---:|:---:|:---:|:---:|\n')
-            f.writelines(lines_to_write)
-
-    print('processed successfully')
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/.dev_scripts/log_collector/readme.md b/mmsegmentation/.dev_scripts/log_collector/readme.md
deleted file mode 100644
index 4a8b9b6..0000000
--- a/mmsegmentation/.dev_scripts/log_collector/readme.md
+++ /dev/null
@@ -1,144 +0,0 @@
-# Log Collector
-
-## Function
-
-Automatically collect logs and write the result in a json file or markdown file.
-
-If there are several `.log.json` files in one folder, Log Collector assumes that the `.log.json` files other than the first one are resume from the preceding `.log.json` file. Log Collector returns the result considering all `.log.json` files.
-
-## Usage:
-
-To use log collector, you need to write a config file to configure the log collector first.
-
-For example:
-
-example_config.py:
-
-```python
-# The work directory that contains folders that contains .log.json files.
-work_dir = '../../work_dirs'
-# The metric used to find the best evaluation.
-metric = 'mIoU'
-
-# **Don't specify the log_items and ignore_keywords at the same time.**
-# Specify the log files we would like to collect in `log_items`.
-# The folders specified should be the subdirectories of `work_dir`.
-log_items = [
-    'segformer_mit-b5_512x512_160k_ade20k_cnn_lr_with_warmup',
-    'segformer_mit-b5_512x512_160k_ade20k_cnn_no_warmup_lr',
-    'segformer_mit-b5_512x512_160k_ade20k_mit_trans_lr',
-    'segformer_mit-b5_512x512_160k_ade20k_swin_trans_lr'
-]
-# Or specify `ignore_keywords`. The folders whose name contain one
-# of the keywords in the `ignore_keywords` list(e.g., `'segformer'`)
-# won't be collected.
-# ignore_keywords = ['segformer']
-
-# Other log items in .log.json that you want to collect.
-# should not include metric.
-other_info_keys = ["mAcc"]
-# The output markdown file's name.
-markdown_file ='markdowns/lr_in_trans.json.md'
-# The output json file's name. (optional)
-json_file = 'jsons/trans_in_cnn.json'
-```
-
-The structure of the work-dir directory should be like：
-
-```text
-├── work-dir
-│   ├── folder1
-│   │   ├── time1.log.json
-│   │   ├── time2.log.json
-│   │   ├── time3.log.json
-│   │   ├── time4.log.json
-│   ├── folder2
-│   │   ├── time5.log.json
-│   │   ├── time6.log.json
-│   │   ├── time7.log.json
-│   │   ├── time8.log.json
-```
-
-Then , cd to the log collector folder.
-
-Now you can run log_collector.py by using command:
-
-```bash
-python log_collector.py ./example_config.py
-```
-
-The output markdown file is like:
-
-| exp_num |                         method                          | mIoU best | best index | mIoU last | last index | last iter num |
-| :-----: | :-----------------------------------------------------: | :-------: | :--------: | :-------: | :--------: | :-----------: |
-|    1    | segformer_mit-b5_512x512_160k_ade20k_cnn_lr_with_warmup |  0.2776   |     10     |  0.2776   |     10     |    160000     |
-|    2    |  segformer_mit-b5_512x512_160k_ade20k_cnn_no_warmup_lr  |  0.2802   |     10     |  0.2802   |     10     |    160000     |
-|    3    |    segformer_mit-b5_512x512_160k_ade20k_mit_trans_lr    |  0.4943   |     11     |  0.4943   |     11     |    160000     |
-|    4    |   segformer_mit-b5_512x512_160k_ade20k_swin_trans_lr    |  0.4883   |     11     |  0.4883   |     11     |    160000     |
-
-The output json file is like:
-
-```json
-[
-    {
-        "method": "segformer_mit-b5_512x512_160k_ade20k_cnn_lr_with_warmup",
-        "metric_used": "mIoU",
-        "last_iter": 160000,
-        "last eval": {
-            "eval_index": 10,
-            "mIoU": 0.2776,
-            "mAcc": 0.3779
-        },
-        "best eval": {
-            "eval_index": 10,
-            "mIoU": 0.2776,
-            "mAcc": 0.3779
-        }
-    },
-    {
-        "method": "segformer_mit-b5_512x512_160k_ade20k_cnn_no_warmup_lr",
-        "metric_used": "mIoU",
-        "last_iter": 160000,
-        "last eval": {
-            "eval_index": 10,
-            "mIoU": 0.2802,
-            "mAcc": 0.3764
-        },
-        "best eval": {
-            "eval_index": 10,
-            "mIoU": 0.2802,
-            "mAcc": 0.3764
-        }
-    },
-    {
-        "method": "segformer_mit-b5_512x512_160k_ade20k_mit_trans_lr",
-        "metric_used": "mIoU",
-        "last_iter": 160000,
-        "last eval": {
-            "eval_index": 11,
-            "mIoU": 0.4943,
-            "mAcc": 0.6097
-        },
-        "best eval": {
-            "eval_index": 11,
-            "mIoU": 0.4943,
-            "mAcc": 0.6097
-        }
-    },
-    {
-        "method": "segformer_mit-b5_512x512_160k_ade20k_swin_trans_lr",
-        "metric_used": "mIoU",
-        "last_iter": 160000,
-        "last eval": {
-            "eval_index": 11,
-            "mIoU": 0.4883,
-            "mAcc": 0.6061
-        },
-        "best eval": {
-            "eval_index": 11,
-            "mIoU": 0.4883,
-            "mAcc": 0.6061
-        }
-    }
-]
-```
diff --git a/mmsegmentation/.dev_scripts/log_collector/utils.py b/mmsegmentation/.dev_scripts/log_collector/utils.py
deleted file mode 100644
index 848516a..0000000
--- a/mmsegmentation/.dev_scripts/log_collector/utils.py
+++ /dev/null
@@ -1,20 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-# modified from https://github.dev/open-mmlab/mmcv
-import os.path as osp
-import sys
-from importlib import import_module
-
-
-def load_config(cfg_dir: str) -> dict:
-    assert cfg_dir.endswith('.py')
-    root_path, file_name = osp.split(cfg_dir)
-    temp_module = osp.splitext(file_name)[0]
-    sys.path.insert(0, root_path)
-    mod = import_module(temp_module)
-    sys.path.pop(0)
-    cfg_dict = {
-        k: v
-        for k, v in mod.__dict__.items() if not k.startswith('__')
-    }
-    del sys.modules[temp_module]
-    return cfg_dict
diff --git a/mmsegmentation/.dev_scripts/update_model_index.py b/mmsegmentation/.dev_scripts/update_model_index.py
deleted file mode 100755
index eb87c02..0000000
--- a/mmsegmentation/.dev_scripts/update_model_index.py
+++ /dev/null
@@ -1,301 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) OpenMMLab. All rights reserved.
-# This tool is used to update model-index.yml which is required by MIM, and
-# will be automatically called as a pre-commit hook. The updating will be
-# triggered if any change of model information (.md files in configs/) has been
-# detected before a commit.
-
-import os
-import os.path as osp
-import re
-import sys
-from typing import List, Tuple
-
-import yaml
-
-MMSEG_ROOT = osp.abspath(osp.join(osp.dirname(__file__), '..'))
-
-
-def get_collection_name_list(md_file_list: List[str]) -> List[str]:
-    """Get the list of collection names."""
-    collection_name_list: List[str] = []
-    for md_file in md_file_list:
-        with open(md_file) as f:
-            lines = f.readlines()
-            collection_name = lines[0].split('#')[1].strip()
-            collection_name_list.append(collection_name)
-    return collection_name_list
-
-
-def get_md_file_list() -> Tuple[List[str], List[str]]:
-    """Get the list of md files."""
-    md_file_list: List[str] = []
-    md_dir_list: List[str] = []
-    for root, _, files in os.walk(osp.join(MMSEG_ROOT, 'configs')):
-        for file in files:
-            if file.endswith('.md'):
-                md_file_list.append(osp.join(root, file))
-                md_dir_list.append(root)
-                break
-    return md_file_list, md_dir_list
-
-
-def get_model_info(md_file: str, config_dir: str,
-                   collection_name_list: List[str]) -> Tuple[dict, str]:
-    """Get model information from md file."""
-    datasets: List[str] = []
-    models: List[dict] = []
-    current_dataset: str = ''
-    paper_name: str = ''
-    paper_url: str = ''
-    code_url: str = ''
-    is_backbone: bool = False
-    is_dataset: bool = False
-    collection_name: str = ''
-    with open(md_file) as f:
-        lines: List[str] = f.readlines()
-        i: int = 0
-
-        while i < len(lines):
-            line: str = lines[i].strip()
-            if len(line) == 0:
-                i += 1
-                continue
-            # get paper name and url
-            if re.match(r'> \[.*\]+\([a-zA-Z]+://[^\s]*\)', line):
-                paper_info = line.split('](')
-                paper_name = paper_info[0][paper_info[0].index('[') + 1:]
-                paper_url = paper_info[1][:len(paper_info[1]) - 1]
-
-            # get code info
-            if 'Code Snippet' in line:
-                code_url = line.split('"')[1].split('"')[0]
-
-            if line.startswith('<!-- [BACKBONE]'):
-                is_backbone = True
-
-            if line.startswith('<!-- [DATASET]'):
-                is_dataset = True
-
-            if '<!-- [SKIP DEV CHECK] -->' in line:
-                return None, None
-
-            # get dataset names
-            if line.startswith('###'):
-                current_dataset = line.split('###')[1].strip()
-                datasets.append(current_dataset)
-
-            # get model info key id
-            if (line[0] == '|' and (i + 1) < len(lines)
-                    and lines[i + 1][:3] == '| -' and 'Method' in line
-                    and 'Crop Size' in line and 'Mem (GB)' in line):
-                keys: List[str] = [key.strip() for key in line.split('|')]
-                crop_size_idx: int = keys.index('Crop Size')
-                mem_idx: int = keys.index('Mem (GB)')
-                assert 'Device' in keys, f'No Device in {md_file}'
-                device_idx: int = keys.index('Device')
-
-                if 'mIoU' in keys:
-                    ss_idx = keys.index('mIoU')
-                elif 'mDice' in keys:
-                    ss_idx = keys.index('mDice')
-                else:
-                    raise ValueError(f'No mIoU or mDice in {md_file}')
-                if 'mIoU(ms+flip)' in keys:
-                    ms_idx = keys.index('mIoU(ms+flip)')
-                elif 'Dice' in keys:
-                    ms_idx = keys.index('Dice')
-                else:
-                    ms_idx = -1
-                config_idx = keys.index('config')
-                download_idx = keys.index('download')
-                j: int = i + 2
-                while j < len(lines) and lines[j][0] == '|':
-                    values = [value.strip() for value in lines[j].split('|')]
-                    # get config name
-                    try:
-                        config_url = re.findall(r'[a-zA-Z]+://[^\s]*py',
-                                                values[config_idx])[0]
-                        config_name = config_url.split('/')[-1]
-                        model_name = config_name.replace('.py', '')
-                    except IndexError:
-                        raise ValueError(
-                            f'config url is not found in {md_file}')
-
-                    # get model name
-                    try:
-                        weight_url = re.findall(r'[a-zA-Z]+://[^\s]*pth',
-                                                values[download_idx])[0]
-                        log_url = re.findall(r'[a-zA-Z]+://[^\s]*.json',
-                                             values[download_idx + 1])[0]
-                    except IndexError:
-                        raise ValueError(
-                            f'url is not found in {values[download_idx]}')
-
-                    # get batch size
-                    bs = re.findall(r'[0-9]*xb[0-9]*',
-                                    config_name)[0].split('xb')
-                    batch_size = int(bs[0]) * int(bs[1])
-
-                    # get crop size
-                    crop_size = values[crop_size_idx].split('x')
-                    crop_size = [int(crop_size[0]), int(crop_size[1])]
-
-                    mem = values[mem_idx].split('\\')[0] if values[
-                        mem_idx] != '-' and values[mem_idx] != '' else -1
-
-                    method = values[keys.index('Method')].strip()
-                    # method = [method.strip()] if '+' not in method else [
-                    #     m.strip() for m in method.split('+')
-                    # ]
-                    # split method name:
-                    if ' + ' in method:
-                        method = [m.strip() for m in method.split(' + ')]
-                    elif ' ' in method:
-                        method = [m for m in method.split(' ')]
-                    else:
-                        method = [method]
-                    backone: str = re.findall(
-                        r'[^\s]*', values[keys.index('Backbone')].strip())[0]
-                    archs = [backone] + method
-                    collection_name = method[0]
-                    config_path = osp.join('configs',
-                                           config_dir.split('/')[-1],
-                                           config_name)
-                    model = {
-                        'Name': model_name,
-                        'In Collection': collection_name,
-                        'Results': {
-                            'Task': 'Semantic Segmentation',
-                            'Dataset': current_dataset,
-                            'Metrics': {
-                                keys[ss_idx]: float(values[ss_idx])
-                            }
-                        },
-                        'Config': config_path,
-                        'Metadata': {
-                            'Training Data':
-                            current_dataset,
-                            'Batch Size':
-                            batch_size,
-                            'Architecture':
-                            archs,
-                            'Training Resources':
-                            f'{bs[0]}x {values[device_idx]} GPUS',
-                        },
-                        'Weights': weight_url,
-                        'Training log': log_url,
-                        'Paper': {
-                            'Title': paper_name,
-                            'URL': paper_url
-                        },
-                        'Code': code_url,
-                        'Framework': 'PyTorch'
-                    }
-                    if ms_idx != -1 and values[ms_idx] != '-' and values[
-                            ms_idx] != '':
-                        model['Results']['Metrics'].update(
-                            {keys[ms_idx]: float(values[ms_idx])})
-                    if mem != -1:
-                        model['Metadata']['Memory (GB)'] = float(mem)
-                    models.append(model)
-                    j += 1
-                i = j
-            i += 1
-
-    if not (is_dataset
-            or is_backbone) or collection_name not in collection_name_list:
-        collection = {
-            'Name': collection_name,
-            'License': 'Apache License 2.0',
-            'Metadata': {
-                'Training Data': datasets
-            },
-            'Paper': {
-                'Title': paper_name,
-                'URL': paper_url,
-            },
-            'README': osp.join('configs',
-                               config_dir.split('/')[-1], 'README.md'),
-            'Frameworks': ['PyTorch'],
-        }
-        results = {
-            'Collections': [collection],
-            'Models': models
-        }, collection_name
-    else:
-        results = {'Models': models}, ''
-
-    return results
-
-
-def dump_yaml_and_check_difference(model_info: dict, filename: str) -> bool:
-    """dump yaml file and check difference with the original file.
-
-    Args:
-        model_info (dict): model info dict.
-        filename (str): filename to save.
-    """
-    str_dump = yaml.dump(model_info, sort_keys=False)
-    if osp.isfile(filename):
-        file_exist = True
-        with open(filename, encoding='utf-8') as f:
-            str_orig = f.read()
-    else:
-        str_orig = None
-        file_exist = False
-
-    if file_exist and str_orig == str_dump:
-        is_different = False
-    else:
-        is_different = True
-        with open(filename, 'w', encoding='utf-8') as f:
-            f.write(str_dump)
-
-    return is_different
-
-
-def update_model_index(config_dir_list: List[str]) -> bool:
-    """update model index."""
-    yml_files = [
-        osp.join('configs',
-                 dir_name.split('/')[-1], 'metafile.yaml')
-        for dir_name in config_dir_list
-    ]
-    yml_files.sort()
-
-    model_index = {
-        'Import': [
-            osp.relpath(yml_file, MMSEG_ROOT).replace('\\', '/')
-            for yml_file in yml_files
-        ]
-    }
-    model_index_file = osp.join(MMSEG_ROOT, 'model-index.yml')
-    return dump_yaml_and_check_difference(model_index, model_index_file)
-
-
-if __name__ == '__main__':
-    # get md file list
-    md_file_list, config_dir_list = get_md_file_list()
-    file_modified = False
-    collection_name_list: List[str] = get_collection_name_list(md_file_list)
-    # hard code to add 'FPN'
-    collection_name_list.append('FPN')
-    remove_config_dir_list = []
-    # parse md file
-    for md_file, config_dir in zip(md_file_list, config_dir_list):
-        results, collection_name = get_model_info(md_file, config_dir,
-                                                  collection_name_list)
-        if results is None:
-            remove_config_dir_list.append(config_dir)
-            continue
-        filename = osp.join(config_dir, 'metafile.yaml')
-        file_modified |= dump_yaml_and_check_difference(results, filename)
-        if collection_name != '':
-            collection_name_list.append(collection_name)
-    # remove config dir
-    for config_dir in remove_config_dir_list:
-        config_dir_list.remove(config_dir)
-    file_modified |= update_model_index(config_dir_list)
-    sys.exit(1 if file_modified else 0)
diff --git a/mmsegmentation/.dev_scripts/upload_modelzoo.py b/mmsegmentation/.dev_scripts/upload_modelzoo.py
deleted file mode 100644
index 303c80d..0000000
--- a/mmsegmentation/.dev_scripts/upload_modelzoo.py
+++ /dev/null
@@ -1,45 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os
-import os.path as osp
-
-import oss2
-
-ACCESS_KEY_ID = os.getenv('OSS_ACCESS_KEY_ID', None)
-ACCESS_KEY_SECRET = os.getenv('OSS_ACCESS_KEY_SECRET', None)
-BUCKET_NAME = 'openmmlab'
-ENDPOINT = 'https://oss-accelerate.aliyuncs.com'
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(description='Upload models to OSS')
-    parser.add_argument('model_zoo', type=str, help='model_zoo input')
-    parser.add_argument(
-        '--dst-folder',
-        type=str,
-        default='mmsegmentation/v0.5',
-        help='destination folder')
-    args = parser.parse_args()
-    return args
-
-
-def main():
-    args = parse_args()
-    model_zoo = args.model_zoo
-    dst_folder = args.dst_folder
-    bucket = oss2.Bucket(
-        oss2.Auth(ACCESS_KEY_ID, ACCESS_KEY_SECRET), ENDPOINT, BUCKET_NAME)
-
-    for root, dirs, files in os.walk(model_zoo):
-        for file in files:
-            file_path = osp.relpath(osp.join(root, file), model_zoo)
-            print(f'Uploading {file_path}')
-
-            oss2.resumable_upload(bucket, osp.join(dst_folder, file_path),
-                                  osp.join(model_zoo, file_path))
-            bucket.put_object_acl(
-                osp.join(dst_folder, file_path), oss2.OBJECT_ACL_PUBLIC_READ)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/.github/CODE_OF_CONDUCT.md b/mmsegmentation/.github/CODE_OF_CONDUCT.md
deleted file mode 100644
index 92afad1..0000000
--- a/mmsegmentation/.github/CODE_OF_CONDUCT.md
+++ /dev/null
@@ -1,76 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as
-contributors and maintainers pledge to making participation in our project and
-our community a harassment-free experience for everyone, regardless of age, body
-size, disability, ethnicity, sex characteristics, gender identity and expression,
-level of experience, education, socio-economic status, nationality, personal
-appearance, race, religion, or sexual identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment
-include:
-
-- Using welcoming and inclusive language
-- Being respectful of differing viewpoints and experiences
-- Gracefully accepting constructive criticism
-- Focusing on what is best for the community
-- Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-- The use of sexualized language or imagery and unwelcome sexual attention or
-  advances
-- Trolling, insulting/derogatory comments, and personal or political attacks
-- Public or private harassment
-- Publishing others' private information, such as a physical or electronic
-  address, without explicit permission
-- Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable
-behavior and are expected to take appropriate and fair corrective action in
-response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community. Examples of
-representing a project or community include using an official project e-mail
-address, posting via an official social media account, or acting as an appointed
-representative at an online or offline event. Representation of a project may be
-further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at chenkaidev@gmail.com. All
-complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. The project team is
-obligated to maintain confidentiality with regard to the reporter of an incident.
-Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good
-faith may face temporary or permanent repercussions as determined by other
-members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
-available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
-
-For answers to common questions about this code of conduct, see
-https://www.contributor-covenant.org/faq
-
-[homepage]: https://www.contributor-covenant.org
diff --git a/mmsegmentation/.github/CONTRIBUTING.md b/mmsegmentation/.github/CONTRIBUTING.md
deleted file mode 100644
index 8865fa8..0000000
--- a/mmsegmentation/.github/CONTRIBUTING.md
+++ /dev/null
@@ -1,59 +0,0 @@
-# Contributing to MMSegmentation 1.x
-
-All kinds of contributions are welcome, including but not limited to the following.
-
-- Fix typo or bugs
-- Add documentation or translate the documentation into other languages
-- Add new features and components
-
-## Workflow
-
-1. fork and pull the latest MMSegmentation repository
-2. checkout a new branch from 'dev-1.x' (do not use master branch for PRs)
-3. commit your changes
-4. create a PR
-
-```{note}
-If you plan to add some new features that involve large changes, it is encouraged to open an issue for discussion first.
-```
-
-## Code style
-
-### Python
-
-We adopt [PEP8](https://www.python.org/dev/peps/pep-0008/) as the preferred code style.
-
-We use the following tools for linting and formatting:
-
-- [flake8](https://github.com/PyCQA/flake8): A wrapper around some linter tools.
-- [isort](https://github.com/timothycrosley/isort): A Python utility to sort imports.
-- [yapf](https://github.com/google/yapf): A formatter for Python files.
-- [codespell](https://github.com/codespell-project/codespell): A Python utility to fix common misspellings in text files.
-- [mdformat](https://github.com/executablebooks/mdformat): Mdformat is an opinionated Markdown formatter that can be used to enforce a consistent style in Markdown files.
-- [docformatter](https://github.com/myint/docformatter): A formatter to format docstring.
-
-Style configurations of yapf and isort can be found in [setup.cfg](./setup.cfg).
-
-We use [pre-commit hook](https://pre-commit.com/) that checks and formats for `flake8`, `yapf`, `isort`, `trailing whitespaces`, `markdown files`,
-fixes `end-of-files`, `double-quoted-strings`, `python-encoding-pragma`, `mixed-line-ending`, sorts `requirments.txt` automatically on every commit.
-The config for a pre-commit hook is stored in [.pre-commit-config](./.pre-commit-config.yaml).
-
-After you clone the repository, you will need to install initialize pre-commit hook.
-
-```shell
-pip install -U pre-commit
-```
-
-From the repository folder
-
-```shell
-pre-commit install
-```
-
-After this on every commit check code linters and formatter will be enforced.
-
-> Before you create a PR, make sure that your code lints and is formatted by yapf.
-
-### C++ and CUDA
-
-We follow the [Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html).
diff --git a/mmsegmentation/.github/ISSUE_TEMPLATE/config.yml b/mmsegmentation/.github/ISSUE_TEMPLATE/config.yml
deleted file mode 100644
index aa982e5..0000000
--- a/mmsegmentation/.github/ISSUE_TEMPLATE/config.yml
+++ /dev/null
@@ -1,6 +0,0 @@
-blank_issues_enabled: false
-
-contact_links:
-  - name: MMSegmentation Documentation
-    url: https://mmsegmentation.readthedocs.io
-    about: Check the docs and FAQ to see if you question is already answered.
diff --git a/mmsegmentation/.github/ISSUE_TEMPLATE/error-report.md b/mmsegmentation/.github/ISSUE_TEMPLATE/error-report.md
deleted file mode 100644
index 807781c..0000000
--- a/mmsegmentation/.github/ISSUE_TEMPLATE/error-report.md
+++ /dev/null
@@ -1,48 +0,0 @@
----
-name: Error report
-about: Create a report to help us improve
-title: ''
-labels: ''
-assignees: ''
----
-
-Thanks for your error report and we appreciate it a lot.
-
-**Checklist**
-
-1. I have searched related issues but cannot get the expected help.
-2. The bug has not been fixed in the latest version.
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**Reproduction**
-
-1. What command or script did you run?
-
-   ```none
-   A placeholder for the command.
-   ```
-
-2. Did you make any modifications on the code or config? Did you understand what you have modified?
-
-3. What dataset did you use?
-
-**Environment**
-
-1. Please run `python mmseg/utils/collect_env.py` to collect necessary environment information and paste it here.
-2. You may add addition that may be helpful for locating the problem, such as
-   - How you installed PyTorch \[e.g., pip, conda, source\]
-   - Other environment variables that may be related (such as `$PATH`, `$LD_LIBRARY_PATH`, `$PYTHONPATH`, etc.)
-
-**Error traceback**
-
-If applicable, paste the error trackback here.
-
-```none
-A placeholder for trackback.
-```
-
-**Bug fix**
-
-If you have already identified the reason, you can provide the information here. If you are willing to create a PR to fix it, please also leave a comment here and that would be much appreciated!
diff --git a/mmsegmentation/.github/ISSUE_TEMPLATE/feature_request.md b/mmsegmentation/.github/ISSUE_TEMPLATE/feature_request.md
deleted file mode 100644
index 7e3b855..0000000
--- a/mmsegmentation/.github/ISSUE_TEMPLATE/feature_request.md
+++ /dev/null
@@ -1,21 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: ''
-assignees: ''
----
-
-# Describe the feature
-
-**Motivation**
-A clear and concise description of the motivation of the feature.
-Ex1. It is inconvenient when \[....\].
-Ex2. There is a recent paper \[....\], which is very helpful for \[....\].
-
-**Related resources**
-If there is an official code release or third-party implementations, please also provide the information here, which would be very helpful.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.
-If you would like to implement the feature and create a PR, please leave a comment here and that would be much appreciated.
diff --git a/mmsegmentation/.github/ISSUE_TEMPLATE/general_questions.md b/mmsegmentation/.github/ISSUE_TEMPLATE/general_questions.md
deleted file mode 100644
index f02dd63..0000000
--- a/mmsegmentation/.github/ISSUE_TEMPLATE/general_questions.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-name: General questions
-about: Ask general questions to get help
-title: ''
-labels: ''
-assignees: ''
----
diff --git a/mmsegmentation/.github/ISSUE_TEMPLATE/reimplementation_questions.md b/mmsegmentation/.github/ISSUE_TEMPLATE/reimplementation_questions.md
deleted file mode 100644
index 63e4c3b..0000000
--- a/mmsegmentation/.github/ISSUE_TEMPLATE/reimplementation_questions.md
+++ /dev/null
@@ -1,69 +0,0 @@
----
-name: Reimplementation Questions
-about: Ask about questions during model reimplementation
-title: ''
-labels: reimplementation
-assignees: ''
----
-
-If you feel we have helped you, give us a STAR! :satisfied:
-
-**Notice**
-
-There are several common situations in the reimplementation issues as below
-
-1. Reimplement a model in the model zoo using the provided configs
-2. Reimplement a model in the model zoo on other datasets (e.g., custom datasets)
-3. Reimplement a custom model but all the components are implemented in MMSegmentation
-4. Reimplement a custom model with new modules implemented by yourself
-
-There are several things to do for different cases as below.
-
-- For cases 1 & 3, please follow the steps in the following sections thus we could help to quickly identify the issue.
-- For cases 2 & 4, please understand that we are not able to do much help here because we usually do not know the full code, and the users should be responsible for the code they write.
-- One suggestion for cases 2 & 4 is that the users should first check whether the bug lies in the self-implemented code or the original code. For example, users can first make sure that the same model runs well on supported datasets. If you still need help, please describe what you have done and what you obtain in the issue, and follow the steps in the following sections, and try as clear as possible so that we can better help you.
-
-**Checklist**
-
-1. I have searched related issues but cannot get the expected help.
-2. The issue has not been fixed in the latest version.
-
-**Describe the issue**
-
-A clear and concise description of the problem you meet and what you have done.
-
-**Reproduction**
-
-1. What command or script did you run?
-
-```
-A placeholder for the command.
-```
-
-2. What config dir you run?
-
-```
-A placeholder for the config.
-```
-
-3. Did you make any modifications to the code or config? Did you understand what you have modified?
-4. What dataset did you use?
-
-**Environment**
-
-1. Please run `PYTHONPATH=${PWD}:$PYTHONPATH python mmseg/utils/collect_env.py` to collect the necessary environment information and paste it here.
-2. You may add an addition that may be helpful for locating the problem, such as
-   1. How you installed PyTorch \[e.g., pip, conda, source\]
-   2. Other environment variables that may be related (such as `$PATH`, `$LD_LIBRARY_PATH`, `$PYTHONPATH`, etc.)
-
-**Results**
-
-If applicable, paste the related results here, e.g., what you expect and what you get.
-
-```
-A placeholder for results comparison
-```
-
-**Issue fix**
-
-If you have already identified the reason, you can provide the information here. If you are willing to create a PR to fix it, please also leave a comment here and that would be much appreciated!
diff --git a/mmsegmentation/.github/pull_request_template.md b/mmsegmentation/.github/pull_request_template.md
deleted file mode 100644
index 09d5305..0000000
--- a/mmsegmentation/.github/pull_request_template.md
+++ /dev/null
@@ -1,25 +0,0 @@
-Thanks for your contribution and we appreciate it a lot. The following instructions would make your pull request more healthy and more easily get feedback. If you do not understand some items, don't worry, just make the pull request and seek help from maintainers.
-
-## Motivation
-
-Please describe the motivation of this PR and the goal you want to achieve through this PR.
-
-## Modification
-
-Please briefly describe what modification is made in this PR.
-
-## BC-breaking (Optional)
-
-Does the modification introduce changes that break the backward-compatibility of the downstream repos?
-If so, please describe how it breaks the compatibility and how the downstream projects should modify their code to keep compatibility with this PR.
-
-## Use cases (Optional)
-
-If this PR introduces a new feature, it is better to list some use cases here, and update the documentation.
-
-## Checklist
-
-1. Pre-commit or other linting tools are used to fix the potential lint issues.
-2. The modification is covered by complete unit tests. If not, please add more unit test to ensure the correctness.
-3. If the modification has potential influence on downstream projects, this PR should be tested with downstream projects, like MMDet or MMDet3D.
-4. The documentation has been modified accordingly, like docstring or example tutorials.
diff --git a/mmsegmentation/.github/workflows/deploy.yml b/mmsegmentation/.github/workflows/deploy.yml
deleted file mode 100644
index 0e0c6c9..0000000
--- a/mmsegmentation/.github/workflows/deploy.yml
+++ /dev/null
@@ -1,26 +0,0 @@
-name: deploy
-
-on: push
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  build-n-publish:
-    runs-on: ubuntu-22.04
-    if: startsWith(github.event.ref, 'refs/tags')
-    steps:
-      - uses: actions/checkout@v3
-      - name: Set up Python 3.7
-        uses: actions/setup-python@v4
-        with:
-          python-version: 3.7
-      - name: Build MMSegmentation
-        run: |
-          pip install wheel
-          python setup.py sdist bdist_wheel
-      - name: Publish distribution to PyPI
-        run: |
-          pip install twine
-          twine upload dist/* -u __token__ -p ${{ secrets.pypi_password }}
diff --git a/mmsegmentation/.gitignore b/mmsegmentation/.gitignore
deleted file mode 100644
index 787d13e..0000000
--- a/mmsegmentation/.gitignore
+++ /dev/null
@@ -1,120 +0,0 @@
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-.hypothesis/
-.pytest_cache/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/en/_build/
-docs/zh_cn/_build/
-
-# PyBuilder
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# pyenv
-.python-version
-
-# celery beat schedule file
-celerybeat-schedule
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-.DS_Store
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-
-data
-.vscode
-.idea
-
-# custom
-*.pkl
-*.pkl.json
-*.log.json
-work_dirs/
-mmseg/.mim
-
-# Pytorch
-*.pth
diff --git a/mmsegmentation/.owners.yml b/mmsegmentation/.owners.yml
deleted file mode 100644
index 20f2070..0000000
--- a/mmsegmentation/.owners.yml
+++ /dev/null
@@ -1,7 +0,0 @@
-assign:
-  strategy:
-    # random
-    # round-robin
-    daily-shift-based
-  assignees:
-    - xiexinch
diff --git a/mmsegmentation/.pre-commit-config.yaml b/mmsegmentation/.pre-commit-config.yaml
deleted file mode 100644
index 337e90c..0000000
--- a/mmsegmentation/.pre-commit-config.yaml
+++ /dev/null
@@ -1,67 +0,0 @@
-repos:
-  - repo: https://github.com/PyCQA/flake8
-    rev: 5.0.4
-    hooks:
-      - id: flake8
-  - repo: https://github.com/zhouzaida/isort
-    rev: 5.12.1
-    hooks:
-      - id: isort
-  - repo: https://github.com/pre-commit/mirrors-yapf
-    rev: v0.32.0
-    hooks:
-      - id: yapf
-  - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.3.0
-    hooks:
-      - id: trailing-whitespace
-      - id: check-yaml
-      - id: end-of-file-fixer
-      - id: requirements-txt-fixer
-      - id: double-quote-string-fixer
-      - id: check-merge-conflict
-      - id: fix-encoding-pragma
-        args: ["--remove"]
-      - id: mixed-line-ending
-        args: ["--fix=lf"]
-  - repo: https://github.com/executablebooks/mdformat
-    rev: 0.7.9
-    hooks:
-      - id: mdformat
-        args: ["--number"]
-        additional_dependencies:
-          - mdformat-openmmlab
-          - mdformat_frontmatter
-          - linkify-it-py
-  - repo: https://github.com/codespell-project/codespell
-    rev: v2.2.1
-    hooks:
-      - id: codespell
-        args: [--ignore-words-list=hsi]
-  - repo: https://github.com/myint/docformatter
-    rev: v1.3.1
-    hooks:
-      - id: docformatter
-        args: ["--in-place", "--wrap-descriptions", "79"]
-  # temporarily remove update-model-index to avoid conflict raised
-  # by depth estimator models
-  # - repo: local
-  #   hooks:
-  #     - id: update-model-index
-  #       name: update-model-index
-  #       description: Collect model information and update model-index.yml
-  #       entry: .dev_scripts/update_model_index.py
-  #       additional_dependencies: [pyyaml]
-  #       language: python
-  #       require_serial: true
-  - repo: https://github.com/asottile/pyupgrade
-    rev: v3.0.0
-    hooks:
-      - id: pyupgrade
-        args: ["--py36-plus"]
-  - repo: https://github.com/open-mmlab/pre-commit-hooks
-    rev: v0.2.0  # Use the rev to fix revision
-    hooks:
-      - id: check-algo-readme
-      - id: check-copyright
-        args: ["mmseg", "tools", "tests", "demo"]  # the dir_to_check with expected directory to check
diff --git a/mmsegmentation/CITATION.cff b/mmsegmentation/CITATION.cff
deleted file mode 100644
index cfd7cab..0000000
--- a/mmsegmentation/CITATION.cff
+++ /dev/null
@@ -1,8 +0,0 @@
-cff-version: 1.2.0
-message: "If you use this software, please cite it as below."
-authors:
-  - name: "MMSegmentation Contributors"
-title: "OpenMMLab Semantic Segmentation Toolbox and Benchmark"
-date-released: 2020-07-10
-url: "https://github.com/open-mmlab/mmsegmentation"
-license: Apache-2.0
diff --git a/mmsegmentation/LICENSE b/mmsegmentation/LICENSE
deleted file mode 100644
index 38e625b..0000000
--- a/mmsegmentation/LICENSE
+++ /dev/null
@@ -1,203 +0,0 @@
-Copyright 2020 The MMSegmentation Authors. All rights reserved.
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2020 The MMSegmentation Authors.
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/mmsegmentation/MANIFEST.in b/mmsegmentation/MANIFEST.in
deleted file mode 100644
index 94a0fc1..0000000
--- a/mmsegmentation/MANIFEST.in
+++ /dev/null
@@ -1,5 +0,0 @@
-include requirements/*.txt
-include mmseg/.mim/model-index.yml
-include mmseg/utils/bpe_simple_vocab_16e6.txt.gz
-recursive-include mmseg/.mim/configs *.py *.yaml
-recursive-include mmseg/.mim/tools *.py *.sh
diff --git a/mmsegmentation/README.md b/mmsegmentation/README.md
deleted file mode 100644
index 79ecdb7..0000000
--- a/mmsegmentation/README.md
+++ /dev/null
@@ -1,420 +0,0 @@
-<div align="center">
-  <img src="resources/mmseg-logo.png" width="600"/>
-  <div>&nbsp;</div>
-  <div align="center">
-    <b><font size="5">OpenMMLab website</font></b>
-    <sup>
-      <a href="https://openmmlab.com">
-        <i><font size="4">HOT</font></i>
-      </a>
-    </sup>
-    &nbsp;&nbsp;&nbsp;&nbsp;
-    <b><font size="5">OpenMMLab platform</font></b>
-    <sup>
-      <a href="https://platform.openmmlab.com">
-        <i><font size="4">TRY IT OUT</font></i>
-      </a>
-    </sup>
-  </div>
-  <div>&nbsp;</div>
-
-[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mmsegmentation)](https://pypi.org/project/mmsegmentation/)
-[![PyPI](https://img.shields.io/pypi/v/mmsegmentation)](https://pypi.org/project/mmsegmentation)
-[![docs](https://img.shields.io/badge/docs-latest-blue)](https://mmsegmentation.readthedocs.io/en/latest/)
-[![badge](https://github.com/open-mmlab/mmsegmentation/workflows/build/badge.svg)](https://github.com/open-mmlab/mmsegmentation/actions)
-[![codecov](https://codecov.io/gh/open-mmlab/mmsegmentation/branch/master/graph/badge.svg)](https://codecov.io/gh/open-mmlab/mmsegmentation)
-[![license](https://img.shields.io/github/license/open-mmlab/mmsegmentation.svg)](https://github.com/open-mmlab/mmsegmentation/blob/main/LICENSE)
-[![issue resolution](https://isitmaintained.com/badge/resolution/open-mmlab/mmsegmentation.svg)](https://github.com/open-mmlab/mmsegmentation/issues)
-[![open issues](https://isitmaintained.com/badge/open/open-mmlab/mmsegmentation.svg)](https://github.com/open-mmlab/mmsegmentation/issues)
-[![Open in OpenXLab](https://cdn-static.openxlab.org.cn/app-center/openxlab_demo.svg)](https://openxlab.org.cn/apps?search=mmseg)
-
-Documentation: <https://mmsegmentation.readthedocs.io/en/latest/>
-
-English | [简体中文](README_zh-CN.md)
-
-</div>
-
-<div align="center">
-  <a href="https://openmmlab.medium.com/" style="text-decoration:none;">
-    <img src="https://user-images.githubusercontent.com/25839884/219255827-67c1a27f-f8c5-46a9-811d-5e57448c61d1.png" width="3%" alt="" /></a>
-  <img src="https://user-images.githubusercontent.com/25839884/218346358-56cc8e2f-a2b8-487f-9088-32480cceabcf.png" width="3%" alt="" />
-  <a href="https://discord.gg/raweFPmdzG" style="text-decoration:none;">
-    <img src="https://user-images.githubusercontent.com/25839884/218347213-c080267f-cbb6-443e-8532-8e1ed9a58ea9.png" width="3%" alt="" /></a>
-  <img src="https://user-images.githubusercontent.com/25839884/218346358-56cc8e2f-a2b8-487f-9088-32480cceabcf.png" width="3%" alt="" />
-  <a href="https://twitter.com/OpenMMLab" style="text-decoration:none;">
-    <img src="https://user-images.githubusercontent.com/25839884/218346637-d30c8a0f-3eba-4699-8131-512fb06d46db.png" width="3%" alt="" /></a>
-  <img src="https://user-images.githubusercontent.com/25839884/218346358-56cc8e2f-a2b8-487f-9088-32480cceabcf.png" width="3%" alt="" />
-  <a href="https://www.youtube.com/openmmlab" style="text-decoration:none;">
-    <img src="https://user-images.githubusercontent.com/25839884/218346691-ceb2116a-465a-40af-8424-9f30d2348ca9.png" width="3%" alt="" /></a>
-  <img src="https://user-images.githubusercontent.com/25839884/218346358-56cc8e2f-a2b8-487f-9088-32480cceabcf.png" width="3%" alt="" />
-  <a href="https://space.bilibili.com/1293512903" style="text-decoration:none;">
-    <img src="https://user-images.githubusercontent.com/25839884/219026751-d7d14cce-a7c9-4e82-9942-8375fca65b99.png" width="3%" alt="" /></a>
-  <img src="https://user-images.githubusercontent.com/25839884/218346358-56cc8e2f-a2b8-487f-9088-32480cceabcf.png" width="3%" alt="" />
-  <a href="https://www.zhihu.com/people/openmmlab" style="text-decoration:none;">
-    <img src="https://user-images.githubusercontent.com/25839884/219026120-ba71e48b-6e94-4bd4-b4e9-b7d175b5e362.png" width="3%" alt="" /></a>
-</div>
-
-## Introduction
-
-MMSegmentation is an open source semantic segmentation toolbox based on PyTorch.
-It is a part of the OpenMMLab project.
-
-The [main](https://github.com/open-mmlab/mmsegmentation/tree/main) branch works with PyTorch 1.6+.
-
-### 🎉 Introducing MMSegmentation v1.0.0 🎉
-
-We are thrilled to announce the official release of MMSegmentation's latest version! For this new release, the [main](https://github.com/open-mmlab/mmsegmentation/tree/main) branch serves as the primary branch, while the development branch is [dev-1.x](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x). The stable branch for the previous release remains as the [0.x](https://github.com/open-mmlab/mmsegmentation/tree/0.x) branch. Please note that the [master](https://github.com/open-mmlab/mmsegmentation/tree/master) branch will only be maintained for a limited time before being removed. We encourage you to be mindful of branch selection and updates during use. Thank you for your unwavering support and enthusiasm, and let's work together to make MMSegmentation even more robust and powerful! 💪
-
-MMSegmentation v1.x brings remarkable improvements over the 0.x release, offering a more flexible and feature-packed experience. To utilize the new features in v1.x, we kindly invite you to consult our detailed [📚 migration guide](https://mmsegmentation.readthedocs.io/en/latest/migration/interface.html), which will help you seamlessly transition your projects. Your support is invaluable, and we eagerly await your feedback!
-
-![demo image](resources/seg_demo.gif)
-
-### Major features
-
-- **Unified Benchmark**
-
-  We provide a unified benchmark toolbox for various semantic segmentation methods.
-
-- **Modular Design**
-
-  We decompose the semantic segmentation framework into different components and one can easily construct a customized semantic segmentation framework by combining different modules.
-
-- **Support of multiple methods out of box**
-
-  The toolbox directly supports popular and contemporary semantic segmentation frameworks, *e.g.* PSPNet, DeepLabV3, PSANet, DeepLabV3+, etc.
-
-- **High efficiency**
-
-  The training speed is faster than or comparable to other codebases.
-
-## What's New
-
-v1.2.0 was released on 10/12/2023, from 1.1.0 to 1.2.0, we have added or updated the following features:
-
-### Highlights
-
-- Support for the open-vocabulary semantic segmentation algorithm [SAN](configs/san/README.md)
-
-- Support monocular depth estimation task, please refer to [VPD](configs/vpd/README.md) and [Adabins](projects/Adabins/README.md) for more details.
-
-  ![depth estimation](https://github.com/open-mmlab/mmsegmentation/assets/15952744/07afd0e9-8ace-4a00-aa1e-5bf0ca92dcbc)
-
-- Add new projects: open-vocabulary semantic segmentation algorithm [CAT-Seg](projects/CAT-Seg/README.md), real-time semantic segmentation algofithm [PP-MobileSeg](projects/pp_mobileseg/README.md)
-
-## Installation
-
-Please refer to [get_started.md](docs/en/get_started.md#installation) for installation and [dataset_prepare.md](docs/en/user_guides/2_dataset_prepare.md#prepare-datasets) for dataset preparation.
-
-## Get Started
-
-Please see [Overview](docs/en/overview.md) for the general introduction of MMSegmentation.
-
-Please see [user guides](https://mmsegmentation.readthedocs.io/en/latest/user_guides/index.html#) for the basic usage of MMSegmentation.
-There are also [advanced tutorials](https://mmsegmentation.readthedocs.io/en/latest/advanced_guides/index.html) for in-depth understanding of mmseg design and implementation .
-
-A Colab tutorial is also provided. You may preview the notebook [here](demo/MMSegmentation_Tutorial.ipynb) or directly [run](https://colab.research.google.com/github/open-mmlab/mmsegmentation/blob/main/demo/MMSegmentation_Tutorial.ipynb) on Colab.
-
-To migrate from MMSegmentation 0.x, please refer to [migration](docs/en/migration).
-
-## Tutorial
-
-<div align="center">
-  <b>MMSegmentation Tutorials</b>
-</div>
-<table align="center">
-  <tbody>
-    <tr align="center" valign="center">
-      <td>
-        <b>Get Started</b>
-      </td>
-      <td>
-        <b>MMSeg Basic Tutorial</b>
-      </td>
-      <td>
-        <b>MMSeg Detail Tutorial</b>
-      </td>
-      <td>
-        <b>MMSeg Development Tutorial</b>
-      </td>
-    </tr>
-    <tr valign="top">
-      <td>
-        <ul>
-          <li><a href="docs/en/overview.md">MMSeg overview</a></li>
-          <li><a href="docs/en/get_started.md">MMSeg Installation</a></li>
-          <li><a href="docs/en/notes/faq.md">FAQ</a></li>
-        </ul>
-      </td>
-      <td>
-        <ul>
-          <li><a href="docs/en/user_guides/1_config.md">Tutorial 1: Learn about Configs</a></li>
-          <li><a href="docs/en/user_guides/2_dataset_prepare.md">Tutorial 2: Prepare datasets</a></li>
-          <li><a href="docs/en/user_guides/3_inference.md">Tutorial 3: Inference with existing models</a></li>
-          <li><a href="docs/en/user_guides/4_train_test.md">Tutorial 4: Train and test with existing models</a></li>
-          <li><a href="docs/en/user_guides/5_deployment.md">Tutorial 5: Model deployment</a></li>
-          <li><a href="docs/zh_cn/user_guides/deploy_jetson.md">Deploy mmsegmentation on Jetson platform</a></li>
-          <li><a href="docs/en/user_guides/useful_tools.md">Useful Tools</a></li>
-          <li><a href="docs/en/user_guides/visualization_feature_map.md">Feature Map Visualization</a></li>
-          <li><a href="docs/en/user_guides/visualization.md">Visualization</a></li>
-        </ul>
-      </td>
-      <td>
-        <ul>
-          <li><a href="docs/en/advanced_guides/datasets.md">MMSeg Dataset</a></li>
-          <li><a href="docs/en/advanced_guides/models.md">MMSeg Models</a></li>
-          <li><a href="docs/en/advanced_guides/structures.md">MMSeg Dataset Structures</a></li>
-          <li><a href="docs/en/advanced_guides/transforms.md">MMSeg Data Transforms</a></li>
-          <li><a href="docs/en/advanced_guides/data_flow.md">MMSeg Dataflow</a></li>
-          <li><a href="docs/en/advanced_guides/engine.md">MMSeg Training Engine</a></li>
-          <li><a href="docs/en/advanced_guides/evaluation.md">MMSeg Evaluation</a></li>
-        </ul>
-      </td>
-      <td>
-        <ul>
-          <li><a href="docs/en/advanced_guides/add_datasets.md">Add New Datasets</a></li>
-          <li><a href="docs/en/advanced_guides/add_metrics.md">Add New Metrics</a></li>
-          <li><a href="docs/en/advanced_guides/add_models.md">Add New Modules</a></li>
-          <li><a href="docs/en/advanced_guides/add_transforms.md">Add New Data Transforms</a></li>
-          <li><a href="docs/en/advanced_guides/customize_runtime.md">Customize Runtime Settings</a></li>
-          <li><a href="docs/en/advanced_guides/training_tricks.md">Training Tricks</a></li>
-          <li><a href=".github/CONTRIBUTING.md">Contribute code to MMSeg</a></li>
-          <li><a href="docs/zh_cn/advanced_guides/contribute_dataset.md">Contribute a standard dataset in projects</a></li>
-          <li><a href="docs/en/device/npu.md">NPU (HUAWEI Ascend)</a></li>
-          <li><a href="docs/en/migration/interface.md">0.x → 1.x migration</a></li>
-          <li><a href="docs/en/migration/package.md">0.x → 1.x package</a></li>
-        </ul>
-      </td>
-    </tr>
-  </tbody>
-</table>
-
-## Benchmark and model zoo
-
-Results and models are available in the [model zoo](docs/en/model_zoo.md).
-
-<div align="center">
-  <b>Overview</b>
-</div>
-<table align="center">
-  <tbody>
-    <tr align="center" valign="center">
-      <td>
-        <b>Supported backbones</b>
-      </td>
-      <td>
-        <b>Supported methods</b>
-      </td>
-      <td>
-        <b>Supported Head</b>
-      </td>
-      <td>
-        <b>Supported datasets</b>
-      </td>
-      <td>
-        <b>Other</b>
-      </td>
-    </tr>
-    <tr valign="top">
-      <td>
-        <ul>
-        <li><a href="mmseg/models/backbones/resnet.py">ResNet(CVPR'2016)</a></li>
-        <li><a href="mmseg/models/backbones/resnext.py">ResNeXt (CVPR'2017)</a></li>
-        <li><a href="configs/hrnet">HRNet (CVPR'2019)</a></li>
-        <li><a href="configs/resnest">ResNeSt (ArXiv'2020)</a></li>
-        <li><a href="configs/mobilenet_v2">MobileNetV2 (CVPR'2018)</a></li>
-        <li><a href="configs/mobilenet_v3">MobileNetV3 (ICCV'2019)</a></li>
-        <li><a href="configs/vit">Vision Transformer (ICLR'2021)</a></li>
-        <li><a href="configs/swin">Swin Transformer (ICCV'2021)</a></li>
-        <li><a href="configs/twins">Twins (NeurIPS'2021)</a></li>
-        <li><a href="configs/beit">BEiT (ICLR'2022)</a></li>
-        <li><a href="configs/convnext">ConvNeXt (CVPR'2022)</a></li>
-        <li><a href="configs/mae">MAE (CVPR'2022)</a></li>
-        <li><a href="configs/poolformer">PoolFormer (CVPR'2022)</a></li>
-        <li><a href="configs/segnext">SegNeXt (NeurIPS'2022)</a></li>
-        </ul>
-      </td>
-      <td>
-        <ul>
-          <li><a href="configs/san/">SAN (CVPR'2023)</a></li>
-          <li><a href="configs/vpd">VPD (ICCV'2023)</a></li>
-          <li><a href="configs/ddrnet">DDRNet (T-ITS'2022)</a></li>
-          <li><a href="configs/pidnet">PIDNet (ArXiv'2022)</a></li>
-          <li><a href="configs/mask2former">Mask2Former (CVPR'2022)</a></li>
-          <li><a href="configs/maskformer">MaskFormer (NeurIPS'2021)</a></li>
-          <li><a href="configs/knet">K-Net (NeurIPS'2021)</a></li>
-          <li><a href="configs/segformer">SegFormer (NeurIPS'2021)</a></li>
-          <li><a href="configs/segmenter">Segmenter (ICCV'2021)</a></li>
-          <li><a href="configs/dpt">DPT (ArXiv'2021)</a></li>
-          <li><a href="configs/setr">SETR (CVPR'2021)</a></li>
-          <li><a href="configs/stdc">STDC (CVPR'2021)</a></li>
-          <li><a href="configs/bisenetv2">BiSeNetV2 (IJCV'2021)</a></li>
-          <li><a href="configs/cgnet">CGNet (TIP'2020)</a></li>
-          <li><a href="configs/point_rend">PointRend (CVPR'2020)</a></li>
-          <li><a href="configs/dnlnet">DNLNet (ECCV'2020)</a></li>
-          <li><a href="configs/ocrnet">OCRNet (ECCV'2020)</a></li>
-          <li><a href="configs/isanet">ISANet (ArXiv'2019/IJCV'2021)</a></li>
-          <li><a href="configs/fastscnn">Fast-SCNN (ArXiv'2019)</a></li>
-          <li><a href="configs/fastfcn">FastFCN (ArXiv'2019)</a></li>
-          <li><a href="configs/gcnet">GCNet (ICCVW'2019/TPAMI'2020)</a></li>
-          <li><a href="configs/ann">ANN (ICCV'2019)</a></li>
-          <li><a href="configs/emanet">EMANet (ICCV'2019)</a></li>
-          <li><a href="configs/ccnet">CCNet (ICCV'2019)</a></li>
-          <li><a href="configs/dmnet">DMNet (ICCV'2019)</a></li>
-          <li><a href="configs/sem_fpn">Semantic FPN (CVPR'2019)</a></li>
-          <li><a href="configs/danet">DANet (CVPR'2019)</a></li>
-          <li><a href="configs/apcnet">APCNet (CVPR'2019)</a></li>
-          <li><a href="configs/nonlocal_net">NonLocal Net (CVPR'2018)</a></li>
-          <li><a href="configs/encnet">EncNet (CVPR'2018)</a></li>
-          <li><a href="configs/deeplabv3plus">DeepLabV3+ (CVPR'2018)</a></li>
-          <li><a href="configs/upernet">UPerNet (ECCV'2018)</a></li>
-          <li><a href="configs/icnet">ICNet (ECCV'2018)</a></li>
-          <li><a href="configs/psanet">PSANet (ECCV'2018)</a></li>
-          <li><a href="configs/bisenetv1">BiSeNetV1 (ECCV'2018)</a></li>
-          <li><a href="configs/deeplabv3">DeepLabV3 (ArXiv'2017)</a></li>
-          <li><a href="configs/pspnet">PSPNet (CVPR'2017)</a></li>
-          <li><a href="configs/erfnet">ERFNet (T-ITS'2017)</a></li>
-          <li><a href="configs/unet">UNet (MICCAI'2016/Nat. Methods'2019)</a></li>
-          <li><a href="configs/fcn">FCN (CVPR'2015/TPAMI'2017)</a></li>
-        </ul>
-      </td>
-      <td>
-        <ul>
-          <li><a href="mmseg/models/decode_heads/ann_head.py">ANN_Head</li>
-          <li><a href="mmseg/models/decode_heads/apc_head.py">APC_Head</li>
-          <li><a href="mmseg/models/decode_heads/aspp_head.py">ASPP_Head</li>
-          <li><a href="mmseg/models/decode_heads/cc_head.py">CC_Head</li>
-          <li><a href="mmseg/models/decode_heads/da_head.py">DA_Head</li>
-          <li><a href="mmseg/models/decode_heads/ddr_head.py">DDR_Head</li>
-          <li><a href="mmseg/models/decode_heads/dm_head.py">DM_Head</li>
-          <li><a href="mmseg/models/decode_heads/dnl_head.py">DNL_Head</li>
-          <li><a href="mmseg/models/decode_heads/dpt_head.py">DPT_HEAD</li>
-          <li><a href="mmseg/models/decode_heads/ema_head.py">EMA_Head</li>
-          <li><a href="mmseg/models/decode_heads/enc_head.py">ENC_Head</li>
-          <li><a href="mmseg/models/decode_heads/fcn_head.py">FCN_Head</li>
-          <li><a href="mmseg/models/decode_heads/fpn_head.py">FPN_Head</li>
-          <li><a href="mmseg/models/decode_heads/gc_head.py">GC_Head</li>
-          <li><a href="mmseg/models/decode_heads/ham_head.py">LightHam_Head</li>
-          <li><a href="mmseg/models/decode_heads/isa_head.py">ISA_Head</li>
-          <li><a href="mmseg/models/decode_heads/knet_head.py">Knet_Head</li>
-          <li><a href="mmseg/models/decode_heads/lraspp_head.py">LRASPP_Head</li>
-          <li><a href="mmseg/models/decode_heads/mask2former_head.py">mask2former_Head</li>
-          <li><a href="mmseg/models/decode_heads/maskformer_head.py">maskformer_Head</li>
-          <li><a href="mmseg/models/decode_heads/nl_head.py">NL_Head</li>
-          <li><a href="mmseg/models/decode_heads/ocr_head.py">OCR_Head</li>
-          <li><a href="mmseg/models/decode_heads/pid_head.py">PID_Head</li>
-          <li><a href="mmseg/models/decode_heads/point_head.py">point_Head</li>
-          <li><a href="mmseg/models/decode_heads/psa_head.py">PSA_Head</li>
-          <li><a href="mmseg/models/decode_heads/psp_head.py">PSP_Head</li>
-          <li><a href="mmseg/models/decode_heads/san_head.py">SAN_Head</li>
-          <li><a href="mmseg/models/decode_heads/segformer_head.py">segformer_Head</li>
-          <li><a href="mmseg/models/decode_heads/segmenter_mask_head.py">segmenter_mask_Head</li>
-          <li><a href="mmseg/models/decode_heads/sep_aspp_head.py">SepASPP_Head</li>
-          <li><a href="mmseg/models/decode_heads/sep_fcn_head.py">SepFCN_Head</li>
-          <li><a href="mmseg/models/decode_heads/setr_mla_head.py">SETRMLAHead_Head</li>
-          <li><a href="mmseg/models/decode_heads/setr_up_head.py">SETRUP_Head</li>
-          <li><a href="mmseg/models/decode_heads/stdc_head.py">STDC_Head</li>
-          <li><a href="mmseg/models/decode_heads/uper_head.py">Uper_Head</li>
-          <li><a href="mmseg/models/decode_heads/vpd_depth_head.py">VPDDepth_Head</li>
-        </ul>
-      </td>
-      <td>
-        <ul>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#cityscapes">Cityscapes</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#pascal-voc">PASCAL VOC</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#ade20k">ADE20K</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#pascal-context">Pascal Context</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#coco-stuff-10k">COCO-Stuff 10k</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#coco-stuff-164k">COCO-Stuff 164k</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#chase-db1">CHASE_DB1</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#drive">DRIVE</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#hrf">HRF</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#stare">STARE</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#dark-zurich">Dark Zurich</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#nighttime-driving">Nighttime Driving</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#loveda">LoveDA</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#isprs-potsdam">Potsdam</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#isprs-vaihingen">Vaihingen</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#isaid">iSAID</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#mapillary-vistas-datasets">Mapillary Vistas</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#levir-cd">LEVIR-CD</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#bdd100K">BDD100K</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#nyu">NYU</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#hsi-drive-2.0">HSIDrive20</a></li>
-        </ul>
-      </td>
-      <td>
-        <ul>
-          <li><b>Supported loss</b></li>
-        <ul>
-          <li><a href="mmseg/models/losses/boundary_loss.py">boundary_loss</a></li>
-          <li><a href="mmseg/models/losses/cross_entropy_loss.py">cross_entropy_loss</a></li>
-          <li><a href="mmseg/models/losses/dice_loss.py">dice_loss</a></li>
-          <li><a href="mmseg/models/losses/focal_loss.py">focal_loss</a></li>
-          <li><a href="mmseg/models/losses/huasdorff_distance_loss.py">huasdorff_distance_loss</a></li>
-          <li><a href="mmseg/models/losses/kldiv_loss.py">kldiv_loss</a></li>
-          <li><a href="mmseg/models/losses/lovasz_loss.py">lovasz_loss</a></li>
-          <li><a href="mmseg/models/losses/ohem_cross_entropy_loss.py">ohem_cross_entropy_loss</a></li>
-          <li><a href="mmseg/models/losses/silog_loss.py">silog_loss</a></li>
-          <li><a href="mmseg/models/losses/tversky_loss.py">tversky_loss</a></li>
-        </ul>
-        </ul>
-      </td>
-  </tbody>
-</table>
-
-Please refer to [FAQ](docs/en/notes/faq.md) for frequently asked questions.
-
-## Projects
-
-[Here](projects/README.md) are some implementations of SOTA models and solutions built on MMSegmentation, which are supported and maintained by community users. These projects demonstrate the best practices based on MMSegmentation for research and product development. We welcome and appreciate all the contributions to OpenMMLab ecosystem.
-
-## Contributing
-
-We appreciate all contributions to improve MMSegmentation. Please refer to [CONTRIBUTING.md](.github/CONTRIBUTING.md) for the contributing guideline.
-
-## Acknowledgement
-
-MMSegmentation is an open source project that welcome any contribution and feedback.
-We wish that the toolbox and benchmark could serve the growing research
-community by providing a flexible as well as standardized toolkit to reimplement existing methods
-and develop their own new semantic segmentation methods.
-
-## Citation
-
-If you find this project useful in your research, please consider cite:
-
-```bibtex
-@misc{mmseg2020,
-    title={{MMSegmentation}: OpenMMLab Semantic Segmentation Toolbox and Benchmark},
-    author={MMSegmentation Contributors},
-    howpublished = {\url{https://github.com/open-mmlab/mmsegmentation}},
-    year={2020}
-}
-```
-
-## License
-
-This project is released under the [Apache 2.0 license](LICENSE).
-
-## OpenMMLab Family
-
-- [MMEngine](https://github.com/open-mmlab/mmengine): OpenMMLab foundational library for training deep learning models.
-- [MMCV](https://github.com/open-mmlab/mmcv): OpenMMLab foundational library for computer vision.
-- [MMPreTrain](https://github.com/open-mmlab/mmpretrain): OpenMMLab pre-training toolbox and benchmark.
-- [MMagic](https://github.com/open-mmlab/mmagic): Open**MM**Lab **A**dvanced, **G**enerative and **I**ntelligent **C**reation toolbox.
-- [MMDetection](https://github.com/open-mmlab/mmdetection): OpenMMLab detection toolbox and benchmark.
-- [MMYOLO](https://github.com/open-mmlab/mmyolo): OpenMMLab YOLO series toolbox and benchmark.
-- [MMDetection3D](https://github.com/open-mmlab/mmdetection3d): OpenMMLab's next-generation platform for general 3D object detection.
-- [MMRotate](https://github.com/open-mmlab/mmrotate): OpenMMLab rotated object detection toolbox and benchmark.
-- [MMTracking](https://github.com/open-mmlab/mmtracking): OpenMMLab video perception toolbox and benchmark.
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation): OpenMMLab semantic segmentation toolbox and benchmark.
-- [MMOCR](https://github.com/open-mmlab/mmocr): OpenMMLab text detection, recognition, and understanding toolbox.
-- [MMPose](https://github.com/open-mmlab/mmpose): OpenMMLab pose estimation toolbox and benchmark.
-- [MMHuman3D](https://github.com/open-mmlab/mmhuman3d): OpenMMLab 3D human parametric model toolbox and benchmark.
-- [MMFewShot](https://github.com/open-mmlab/mmfewshot): OpenMMLab fewshot learning toolbox and benchmark.
-- [MMAction2](https://github.com/open-mmlab/mmaction2): OpenMMLab's next-generation action understanding toolbox and benchmark.
-- [MMFlow](https://github.com/open-mmlab/mmflow): OpenMMLab optical flow toolbox and benchmark.
-- [MMDeploy](https://github.com/open-mmlab/mmdeploy): OpenMMLab Model Deployment Framework.
-- [MMRazor](https://github.com/open-mmlab/mmrazor): OpenMMLab model compression toolbox and benchmark.
-- [MIM](https://github.com/open-mmlab/mim): MIM installs OpenMMLab packages.
-- [Playground](https://github.com/open-mmlab/playground): A central hub for gathering and showcasing amazing projects built upon OpenMMLab.
diff --git a/mmsegmentation/README_zh-CN.md b/mmsegmentation/README_zh-CN.md
deleted file mode 100644
index e047759..0000000
--- a/mmsegmentation/README_zh-CN.md
+++ /dev/null
@@ -1,426 +0,0 @@
-<div align="center">
-  <img src="resources/mmseg-logo.png" width="600"/>
-  <div>&nbsp;</div>
-  <div align="center">
-    <b><font size="5">OpenMMLab 官网</font></b>
-    <sup>
-      <a href="https://openmmlab.com">
-        <i><font size="4">HOT</font></i>
-      </a>
-    </sup>
-    &nbsp;&nbsp;&nbsp;&nbsp;
-    <b><font size="5">OpenMMLab 开放平台</font></b>
-    <sup>
-      <a href="https://platform.openmmlab.com">
-        <i><font size="4">TRY IT OUT</font></i>
-      </a>
-    </sup>
-  </div>
-  <div>&nbsp;</div>
-
-[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mmsegmentation)](https://pypi.org/project/mmsegmentation/)
-[![PyPI](https://img.shields.io/pypi/v/mmsegmentation)](https://pypi.org/project/mmsegmentation)
-[![docs](https://img.shields.io/badge/docs-latest-blue)](https://mmsegmentation.readthedocs.io/zh_CN/latest/)
-[![badge](https://github.com/open-mmlab/mmsegmentation/workflows/build/badge.svg)](https://github.com/open-mmlab/mmsegmentation/actions)
-[![codecov](https://codecov.io/gh/open-mmlab/mmsegmentation/branch/master/graph/badge.svg)](https://codecov.io/gh/open-mmlab/mmsegmentation)
-[![license](https://img.shields.io/github/license/open-mmlab/mmsegmentation.svg)](https://github.com/open-mmlab/mmsegmentation/blob/main/LICENSE)
-[![issue resolution](https://isitmaintained.com/badge/resolution/open-mmlab/mmsegmentation.svg)](https://github.com/open-mmlab/mmsegmentation/issues)
-[![open issues](https://isitmaintained.com/badge/open/open-mmlab/mmsegmentation.svg)](https://github.com/open-mmlab/mmsegmentation/issues)
-[![Open in OpenXLab](https://cdn-static.openxlab.org.cn/app-center/openxlab_demo.svg)](https://openxlab.org.cn/apps?search=mmseg)
-
-文档: <https://mmsegmentation.readthedocs.io/zh_CN/latest>
-
-[English](README.md) | 简体中文
-
-</div>
-
-<div align="center">
-  <a href="https://openmmlab.medium.com/" style="text-decoration:none;">
-    <img src="https://user-images.githubusercontent.com/25839884/219255827-67c1a27f-f8c5-46a9-811d-5e57448c61d1.png" width="3%" alt="" /></a>
-  <img src="https://user-images.githubusercontent.com/25839884/218346358-56cc8e2f-a2b8-487f-9088-32480cceabcf.png" width="3%" alt="" />
-  <a href="https://discord.gg/raweFPmdzG" style="text-decoration:none;">
-    <img src="https://user-images.githubusercontent.com/25839884/218347213-c080267f-cbb6-443e-8532-8e1ed9a58ea9.png" width="3%" alt="" /></a>
-  <img src="https://user-images.githubusercontent.com/25839884/218346358-56cc8e2f-a2b8-487f-9088-32480cceabcf.png" width="3%" alt="" />
-  <a href="https://twitter.com/OpenMMLab" style="text-decoration:none;">
-    <img src="https://user-images.githubusercontent.com/25839884/218346637-d30c8a0f-3eba-4699-8131-512fb06d46db.png" width="3%" alt="" /></a>
-  <img src="https://user-images.githubusercontent.com/25839884/218346358-56cc8e2f-a2b8-487f-9088-32480cceabcf.png" width="3%" alt="" />
-  <a href="https://www.youtube.com/openmmlab" style="text-decoration:none;">
-    <img src="https://user-images.githubusercontent.com/25839884/218346691-ceb2116a-465a-40af-8424-9f30d2348ca9.png" width="3%" alt="" /></a>
-  <img src="https://user-images.githubusercontent.com/25839884/218346358-56cc8e2f-a2b8-487f-9088-32480cceabcf.png" width="3%" alt="" />
-  <a href="https://space.bilibili.com/1293512903" style="text-decoration:none;">
-    <img src="https://user-images.githubusercontent.com/25839884/219026751-d7d14cce-a7c9-4e82-9942-8375fca65b99.png" width="3%" alt="" /></a>
-  <img src="https://user-images.githubusercontent.com/25839884/218346358-56cc8e2f-a2b8-487f-9088-32480cceabcf.png" width="3%" alt="" />
-  <a href="https://www.zhihu.com/people/openmmlab" style="text-decoration:none;">
-    <img src="https://user-images.githubusercontent.com/25839884/219026120-ba71e48b-6e94-4bd4-b4e9-b7d175b5e362.png" width="3%" alt="" /></a>
-</div>
-
-## 简介
-
-MMSegmentation 是一个基于 PyTorch 的语义分割开源工具箱。它是 OpenMMLab 项目的一部分。
-
-[main](https://github.com/open-mmlab/mmsegmentation/tree/main) 分支代码目前支持 PyTorch 1.6 以上的版本。
-
-### 🎉 MMSegmentation v1.0.0 简介 🎉
-
-我们非常高兴地宣布 MMSegmentation 最新版本的正式发布！在这个新版本中，主要分支是 [main](https://github.com/open-mmlab/mmsegmentation/tree/main) 分支，开发分支是 [dev-1.x](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x)。而之前版本的稳定分支保留为 [0.x](https://github.com/open-mmlab/mmsegmentation/tree/0.x) 分支。请注意，[master](https://github.com/open-mmlab/mmsegmentation/tree/master) 分支将只在有限的时间内维护，然后将被删除。我们鼓励您在使用过程中注意分支选择和更新。感谢您一如既往的支持和热情，让我们共同努力，使 MMSegmentation 变得更加健壮和强大！💪
-
-MMSegmentation v1.x 在 0.x 版本的基础上有了显著的提升，提供了更加灵活和功能丰富的体验。为了更好使用 v1.x 中的新功能，我们诚挚邀请您查阅我们详细的 [📚 迁移指南](https://mmsegmentation.readthedocs.io/zh_CN/latest/migration/interface.html)，以帮助您无缝地过渡您的项目。您的支持对我们来说非常宝贵，我们热切期待您的反馈！
-
-![示例图片](resources/seg_demo.gif)
-
-### 主要特性
-
-- **统一的基准平台**
-
-  我们将各种各样的语义分割算法集成到了一个统一的工具箱，进行基准测试。
-
-- **模块化设计**
-
-  MMSegmentation 将分割框架解耦成不同的模块组件，通过组合不同的模块组件，用户可以便捷地构建自定义的分割模型。
-
-- **丰富的即插即用的算法和模型**
-
-  MMSegmentation 支持了众多主流的和最新的检测算法，例如 PSPNet，DeepLabV3，PSANet，DeepLabV3+ 等.
-
-- **速度快**
-
-  训练速度比其他语义分割代码库更快或者相当。
-
-## 更新日志
-
-最新版本 v1.2.0 在 2023.10.12 发布。
-如果想了解更多版本更新细节和历史信息，请阅读[更新日志](docs/en/notes/changelog.md)。
-
-## 安装
-
-请参考[快速入门文档](docs/zh_cn/get_started.md#installation)进行安装，参考[数据集准备](docs/zh_cn/user_guides/2_dataset_prepare.md)处理数据。
-
-## 快速入门
-
-请参考[概述](docs/zh_cn/overview.md)对 MMSegmetation 进行初步了解
-
-请参考[用户指南](https://mmsegmentation.readthedocs.io/zh_CN/latest/user_guides/index.html)了解 mmseg 的基本使用，以及[进阶指南](https://mmsegmentation.readthedocs.io/zh_CN/latest/advanced_guides/index.html)深入了解 mmseg 设计和代码实现。
-
-同时，我们提供了 Colab 教程。你可以在[这里](demo/MMSegmentation_Tutorial.ipynb)浏览教程，或者直接在 Colab 上[运行](https://colab.research.google.com/github/open-mmlab/mmsegmentation/blob/main/demo/MMSegmentation_Tutorial.ipynb)。
-
-若需要将 0.x 版本的代码迁移至新版，请参考[迁移文档](docs/zh_cn/migration)。
-
-## 教程文档
-
-<div align="center">
-  <b>mmsegmentation 教程文档</b>
-</div>
-<table align="center">
-  <tbody>
-    <tr align="center" valign="center">
-      <td>
-        <b>开启 MMSeg 之旅</b>
-      </td>
-      <td>
-        <b>MMSeg 快速入门教程</b>
-      </td>
-      <td>
-        <b>MMSeg 细节介绍</b>
-      </td>
-      <td>
-        <b>MMSeg 开发教程</b>
-      </td>
-    </tr>
-    <tr valign="top">
-      <td>
-        <ul>
-        <li><a href="docs/zh_cn/overview.md">MMSeg 概述</a></li>
-        <li><a href="docs/zh_cn/get_started.md">安装和验证</a></li>
-        <li><a href="docs/zh_cn/notes/faq.md">常见问题解答</a></li>
-        </ul>
-      </td>
-      <td>
-        <ul>
-          <li><a href="docs/zh_cn/user_guides/1_config.md">教程1：了解配置文件</a></li>
-          <li><a href="docs/zh_cn/user_guides/2_dataset_prepare.md">教程2：准备数据集</a></li>
-          <li><a href="docs/zh_cn/user_guides/3_inference.md">教程3：使用预训练模型推理</a></li>
-          <li><a href="docs/zh_cn/user_guides/4_train_test.md">教程4：模型训练和测试</a></li>
-          <li><a href="docs/zh_cn/user_guides/5_deployment.md">教程5：模型部署</a></li>
-          <li><a href="docs/zh_cn/user_guides/deploy_jetson.md">在 Jetson 平台部署 MMSeg</a></li>
-          <li><a href="docs/zh_cn/user_guides/useful_tools.md">常用工具</a></li>
-          <li><a href="docs/zh_cn/user_guides/visualization_feature_map.md">特征图可视化</a></li>
-          <li><a href="docs/zh_cn/user_guides/visualization.md">可视化</a></li>
-        </ul>
-      </td>
-      <td>
-        <ul>
-          <li><a href="docs/zh_cn/advanced_guides/datasets.md">MMSeg 数据集介绍</a></li>
-          <li><a href="docs/zh_cn/advanced_guides/models.md">MMSeg 模型介绍</a></li>
-          <li><a href="docs/zh_cn/advanced_guides/structures.md">MMSeg 数据结构介绍</a></li>
-          <li><a href="docs/zh_cn/advanced_guides/transforms.md">MMSeg 数据增强介绍</a></li>
-          <li><a href="docs/zh_cn/advanced_guides/data_flow.md">MMSeg 数据流介绍</a></li>
-          <li><a href="docs/zh_cn/advanced_guides/engine.md">MMSeg 训练引擎介绍</a></li>
-          <li><a href="docs/zh_cn/advanced_guides/evaluation.md">MMSeg 模型评测介绍</a></li>
-        </ul>
-      </td>
-      <td>
-        <ul>
-          <li><a href="docs/zh_cn/advanced_guides/add_datasets.md">新增自定义数据集</a></li>
-          <li><a href="docs/zh_cn/advanced_guides/add_metrics.md">新增评测指标</a></li>
-          <li><a href="docs/zh_cn/advanced_guides/add_models.md">新增自定义模型</a></li>
-          <li><a href="docs/zh_cn/advanced_guides/add_transforms.md">新增自定义数据增强</a></li>
-          <li><a href="docs/zh_cn/advanced_guides/customize_runtime.md">自定义运行设定</a></li>
-          <li><a href="docs/zh_cn/advanced_guides/training_tricks.md">训练技巧</a></li>
-          <li><a href=".github/CONTRIBUTING.md">如何给 MMSeg 贡献代码</a></li>
-          <li><a href="docs/zh_cn/advanced_guides/contribute_dataset.md">给 MMSeg 贡献数据集教程</a></li>
-          <li><a href="docs/zh_cn/device/npu.md">NPU (华为 昇腾)</a></li>
-          <li><a href="docs/zh_cn/migration/interface.md">0.x → 1.x 迁移文档</a></li>
-          <li><a href="docs/zh_cn/migration/package.md">0.x → 1.x 库变更文档</a></li>
-        </ul>
-      </td>
-    </tr>
-  </tbody>
-</table>
-
-## 基准测试和模型库
-
-测试结果和模型可以在[模型库](docs/zh_cn/model_zoo.md)中找到。
-
-<div align="center">
-  <b>概览</b>
-</div>
-<table align="center">
-  <tbody>
-    <tr align="center" valign="bottom">
-      <td>
-        <b>已支持的主干网络</b>
-      </td>
-      <td>
-        <b>已支持的算法架构</b>
-      </td>
-      <td>
-        <b>已支持的分割头</b>
-      </td>
-      <td>
-        <b>已支持的数据集</b>
-      </td>
-      <td>
-        <b>其他</b>
-      </td>
-    </tr>
-    <tr valign="top">
-      <td>
-        <ul>
-        <li><a href="mmseg/models/backbones/resnet.py">ResNet(CVPR'2016)</a></li>
-        <li><a href="mmseg/models/backbones/resnext.py">ResNeXt (CVPR'2017)</a></li>
-        <li><a href="configs/hrnet">HRNet (CVPR'2019)</a></li>
-        <li><a href="configs/resnest">ResNeSt (ArXiv'2020)</a></li>
-        <li><a href="configs/mobilenet_v2">MobileNetV2 (CVPR'2018)</a></li>
-        <li><a href="configs/mobilenet_v3">MobileNetV3 (ICCV'2019)</a></li>
-        <li><a href="configs/vit">Vision Transformer (ICLR'2021)</a></li>
-        <li><a href="configs/swin">Swin Transformer (ICCV'2021)</a></li>
-        <li><a href="configs/twins">Twins (NeurIPS'2021)</a></li>
-        <li><a href="configs/beit">BEiT (ICLR'2022)</a></li>
-        <li><a href="configs/convnext">ConvNeXt (CVPR'2022)</a></li>
-        <li><a href="configs/mae">MAE (CVPR'2022)</a></li>
-        <li><a href="configs/poolformer">PoolFormer (CVPR'2022)</a></li>
-        <li><a href="configs/segnext">SegNeXt (NeurIPS'2022)</a></li>
-        </ul>
-      </td>
-      <td>
-        <ul>
-          <li><a href="configs/san/">SAN (CVPR'2023)</a></li>
-          <li><a href="configs/vpd">VPD (ICCV'2023)</a></li>
-          <li><a href="configs/ddrnet">DDRNet (T-ITS'2022)</a></li>
-          <li><a href="configs/pidnet">PIDNet (ArXiv'2022)</a></li>
-          <li><a href="configs/mask2former">Mask2Former (CVPR'2022)</a></li>
-          <li><a href="configs/maskformer">MaskFormer (NeurIPS'2021)</a></li>
-          <li><a href="configs/knet">K-Net (NeurIPS'2021)</a></li>
-          <li><a href="configs/segformer">SegFormer (NeurIPS'2021)</a></li>
-          <li><a href="configs/segmenter">Segmenter (ICCV'2021)</a></li>
-          <li><a href="configs/dpt">DPT (ArXiv'2021)</a></li>
-          <li><a href="configs/setr">SETR (CVPR'2021)</a></li>
-          <li><a href="configs/stdc">STDC (CVPR'2021)</a></li>
-          <li><a href="configs/bisenetv2">BiSeNetV2 (IJCV'2021)</a></li>
-          <li><a href="configs/cgnet">CGNet (TIP'2020)</a></li>
-          <li><a href="configs/point_rend">PointRend (CVPR'2020)</a></li>
-          <li><a href="configs/dnlnet">DNLNet (ECCV'2020)</a></li>
-          <li><a href="configs/ocrnet">OCRNet (ECCV'2020)</a></li>
-          <li><a href="configs/isanet">ISANet (ArXiv'2019/IJCV'2021)</a></li>
-          <li><a href="configs/fastscnn">Fast-SCNN (ArXiv'2019)</a></li>
-          <li><a href="configs/fastfcn">FastFCN (ArXiv'2019)</a></li>
-          <li><a href="configs/gcnet">GCNet (ICCVW'2019/TPAMI'2020)</a></li>
-          <li><a href="configs/ann">ANN (ICCV'2019)</a></li>
-          <li><a href="configs/emanet">EMANet (ICCV'2019)</a></li>
-          <li><a href="configs/ccnet">CCNet (ICCV'2019)</a></li>
-          <li><a href="configs/dmnet">DMNet (ICCV'2019)</a></li>
-          <li><a href="configs/sem_fpn">Semantic FPN (CVPR'2019)</a></li>
-          <li><a href="configs/danet">DANet (CVPR'2019)</a></li>
-          <li><a href="configs/apcnet">APCNet (CVPR'2019)</a></li>
-          <li><a href="configs/nonlocal_net">NonLocal Net (CVPR'2018)</a></li>
-          <li><a href="configs/encnet">EncNet (CVPR'2018)</a></li>
-          <li><a href="configs/deeplabv3plus">DeepLabV3+ (CVPR'2018)</a></li>
-          <li><a href="configs/upernet">UPerNet (ECCV'2018)</a></li>
-          <li><a href="configs/icnet">ICNet (ECCV'2018)</a></li>
-          <li><a href="configs/psanet">PSANet (ECCV'2018)</a></li>
-          <li><a href="configs/bisenetv1">BiSeNetV1 (ECCV'2018)</a></li>
-          <li><a href="configs/deeplabv3">DeepLabV3 (ArXiv'2017)</a></li>
-          <li><a href="configs/pspnet">PSPNet (CVPR'2017)</a></li>
-          <li><a href="configs/erfnet">ERFNet (T-ITS'2017)</a></li>
-          <li><a href="configs/unet">UNet (MICCAI'2016/Nat. Methods'2019)</a></li>
-          <li><a href="configs/fcn">FCN (CVPR'2015/TPAMI'2017)</a></li>
-        </ul>
-      </td>
-      <td>
-        <ul>
-          <li><a href="mmseg/models/decode_heads/ann_head.py">ANN_Head</li>
-          <li><a href="mmseg/models/decode_heads/apc_head.py">APC_Head</li>
-          <li><a href="mmseg/models/decode_heads/aspp_head.py">ASPP_Head</li>
-          <li><a href="mmseg/models/decode_heads/cc_head.py">CC_Head</li>
-          <li><a href="mmseg/models/decode_heads/da_head.py">DA_Head</li>
-          <li><a href="mmseg/models/decode_heads/ddr_head.py">DDR_Head</li>
-          <li><a href="mmseg/models/decode_heads/dm_head.py">DM_Head</li>
-          <li><a href="mmseg/models/decode_heads/dnl_head.py">DNL_Head</li>
-          <li><a href="mmseg/models/decode_heads/dpt_head.py">DPT_HEAD</li>
-          <li><a href="mmseg/models/decode_heads/ema_head.py">EMA_Head</li>
-          <li><a href="mmseg/models/decode_heads/enc_head.py">ENC_Head</li>
-          <li><a href="mmseg/models/decode_heads/fcn_head.py">FCN_Head</li>
-          <li><a href="mmseg/models/decode_heads/fpn_head.py">FPN_Head</li>
-          <li><a href="mmseg/models/decode_heads/gc_head.py">GC_Head</li>
-          <li><a href="mmseg/models/decode_heads/ham_head.py">LightHam_Head</li>
-          <li><a href="mmseg/models/decode_heads/isa_head.py">ISA_Head</li>
-          <li><a href="mmseg/models/decode_heads/knet_head.py">Knet_Head</li>
-          <li><a href="mmseg/models/decode_heads/lraspp_head.py">LRASPP_Head</li>
-          <li><a href="mmseg/models/decode_heads/mask2former_head.py">mask2former_Head</li>
-          <li><a href="mmseg/models/decode_heads/maskformer_head.py">maskformer_Head</li>
-          <li><a href="mmseg/models/decode_heads/nl_head.py">NL_Head</li>
-          <li><a href="mmseg/models/decode_heads/ocr_head.py">OCR_Head</li>
-          <li><a href="mmseg/models/decode_heads/pid_head.py">PID_Head</li>
-          <li><a href="mmseg/models/decode_heads/point_head.py">point_Head</li>
-          <li><a href="mmseg/models/decode_heads/psa_head.py">PSA_Head</li>
-          <li><a href="mmseg/models/decode_heads/psp_head.py">PSP_Head</li>
-          <li><a href="mmseg/models/decode_heads/san_head.py">SAN_Head</li>
-          <li><a href="mmseg/models/decode_heads/segformer_head.py">segformer_Head</li>
-          <li><a href="mmseg/models/decode_heads/segmenter_mask_head.py">segmenter_mask_Head</li>
-          <li><a href="mmseg/models/decode_heads/sep_aspp_head.py">SepASPP_Head</li>
-          <li><a href="mmseg/models/decode_heads/sep_fcn_head.py">SepFCN_Head</li>
-          <li><a href="mmseg/models/decode_heads/setr_mla_head.py">SETRMLAHead_Head</li>
-          <li><a href="mmseg/models/decode_heads/setr_up_head.py">SETRUP_Head</li>
-          <li><a href="mmseg/models/decode_heads/stdc_head.py">STDC_Head</li>
-          <li><a href="mmseg/models/decode_heads/uper_head.py">Uper_Head</li>
-          <li><a href="mmseg/models/decode_heads/vpd_depth_head.py">VPDDepth_Head</li>
-        </ul>
-      </td>
-      <td>
-        <ul>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#cityscapes">Cityscapes</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#pascal-voc">PASCAL VOC</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#ade20k">ADE20K</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#pascal-context">Pascal Context</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#coco-stuff-10k">COCO-Stuff 10k</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#coco-stuff-164k">COCO-Stuff 164k</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#chase-db1">CHASE_DB1</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#drive">DRIVE</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#hrf">HRF</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#stare">STARE</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#dark-zurich">Dark Zurich</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#nighttime-driving">Nighttime Driving</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#loveda">LoveDA</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#isprs-potsdam">Potsdam</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#isprs-vaihingen">Vaihingen</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#isaid">iSAID</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#mapillary-vistas-datasets">Mapillary Vistas</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#levir-cd">LEVIR-CD</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#bdd100K">BDD100K</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#nyu">NYU</a></li>
-          <li><a href="https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#hsi-drive-2.0">HSIDrive20</a></li>
-        </ul>
-      </td>
-      <td>
-        <ul>
-          <li><b>已支持的 loss</b></li>
-        <ul>
-          <li><a href="mmseg/models/losses/boundary_loss.py">boundary_loss</a></li>
-          <li><a href="mmseg/models/losses/cross_entropy_loss.py">cross_entropy_loss</a></li>
-          <li><a href="mmseg/models/losses/dice_loss.py">dice_loss</a></li>
-          <li><a href="mmseg/models/losses/focal_loss.py">focal_loss</a></li>
-          <li><a href="mmseg/models/losses/huasdorff_distance_loss.py">huasdorff_distance_loss</a></li>
-          <li><a href="mmseg/models/losses/kldiv_loss.py">kldiv_loss</a></li>
-          <li><a href="mmseg/models/losses/lovasz_loss.py">lovasz_loss</a></li>
-          <li><a href="mmseg/models/losses/ohem_cross_entropy_loss.py">ohem_cross_entropy_loss</a></li>
-          <li><a href="mmseg/models/losses/silog_loss.py">silog_loss</a></li>
-          <li><a href="mmseg/models/losses/tversky_loss.py">tversky_loss</a></li>
-        </ul>
-        </ul>
-      </td>
-  </tbody>
-</table>
-
-如果遇到问题，请参考 [常见问题解答](docs/zh_cn/notes/faq.md)。
-
-## 社区项目
-
-[这里](projects/README.md)有一些由社区用户支持和维护的基于 MMSegmentation 的 SOTA 模型和解决方案的实现。这些项目展示了基于 MMSegmentation 的研究和产品开发的最佳实践。
-我们欢迎并感谢对 OpenMMLab 生态系统的所有贡献。
-
-## 贡献指南
-
-我们感谢所有的贡献者为改进和提升 MMSegmentation 所作出的努力。请参考[贡献指南](.github/CONTRIBUTING.md)来了解参与项目贡献的相关指引。
-
-## 致谢
-
-MMSegmentation 是一个由来自不同高校和企业的研发人员共同参与贡献的开源项目。我们感谢所有为项目提供算法复现和新功能支持的贡献者，以及提供宝贵反馈的用户。我们希望这个工具箱和基准测试可以为社区提供灵活的代码工具，供用户复现已有算法并开发自己的新模型，从而不断为开源社区提供贡献。
-
-## 引用
-
-如果你觉得本项目对你的研究工作有所帮助，请参考如下 bibtex 引用 MMSegmentation。
-
-```bibtex
-@misc{mmseg2020,
-    title={{MMSegmentation}: OpenMMLab Semantic Segmentation Toolbox and Benchmark},
-    author={MMSegmentation Contributors},
-    howpublished = {\url{https://github.com/open-mmlab/mmsegmentation}},
-    year={2020}
-}
-```
-
-## 开源许可证
-
-该项目采用 [Apache 2.0 开源许可证](LICENSE)。
-
-## OpenMMLab 的其他项目
-
-- [MMEngine](https://github.com/open-mmlab/mmengine): OpenMMLab 深度学习模型训练基础库
-- [MMCV](https://github.com/open-mmlab/mmcv): OpenMMLab 计算机视觉基础库
-- [MMPreTrain](https://github.com/open-mmlab/mmpretrain): OpenMMLab 深度学习预训练工具箱
-- [MMagic](https://github.com/open-mmlab/mmagic): OpenMMLab 新一代人工智能内容生成（AIGC）工具箱
-- [MMDetection](https://github.com/open-mmlab/mmdetection): OpenMMLab 目标检测工具箱
-- [MMYOLO](https://github.com/open-mmlab/mmyolo): OpenMMLab YOLO 系列工具箱与测试基准
-- [MMDetection3D](https://github.com/open-mmlab/mmdetection3d): OpenMMLab 新一代通用 3D 目标检测平台
-- [MMRotate](https://github.com/open-mmlab/mmrotate): OpenMMLab 旋转框检测工具箱与测试基准
-- [MMTracking](https://github.com/open-mmlab/mmtracking): OpenMMLab 一体化视频目标感知平台
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation): OpenMMLab 语义分割工具箱
-- [MMOCR](https://github.com/open-mmlab/mmocr): OpenMMLab 全流程文字检测识别理解工具包
-- [MMPose](https://github.com/open-mmlab/mmpose): OpenMMLab 姿态估计工具箱
-- [MMHuman3D](https://github.com/open-mmlab/mmhuman3d): OpenMMLab 人体参数化模型工具箱与测试基准
-- [MMFewShot](https://github.com/open-mmlab/mmfewshot): OpenMMLab 少样本学习工具箱与测试基准
-- [MMAction2](https://github.com/open-mmlab/mmaction2): OpenMMLab 新一代视频理解工具箱
-- [MMFlow](https://github.com/open-mmlab/mmflow): OpenMMLab 光流估计工具箱与测试基准
-- [MMDeploy](https://github.com/open-mmlab/mmdeploy): OpenMMLab 模型部署框架
-- [MMRazor](https://github.com/open-mmlab/mmrazor): OpenMMLab 模型压缩工具箱与测试基准
-- [MIM](https://github.com/open-mmlab/mim): OpenMMLab 项目、算法、模型的统一入口
-- [Playground](https://github.com/open-mmlab/playground): 收集和展示 OpenMMLab 相关的前沿、有趣的社区项目
-
-## 欢迎加入 OpenMMLab 社区
-
-扫描下方的二维码可关注 OpenMMLab 团队的 [知乎官方账号](https://www.zhihu.com/people/openmmlab)，扫描下方微信二维码添加喵喵好友，进入 MMSegmentation 微信交流社群。【加好友申请格式：研究方向+地区+学校/公司+姓名】
-
-<div align="center">
-<img src="docs/zh_cn/imgs/zhihu_qrcode.jpg" height="400" />  <img src="resources/miaomiao_qrcode.jpg" height="400" />
-</div>
-
-我们会在 OpenMMLab 社区为大家
-
-- 📢 分享 AI 框架的前沿核心技术
-- 💻 解读 PyTorch 常用模块源码
-- 📰 发布 OpenMMLab 的相关新闻
-- 🚀 介绍 OpenMMLab 开发的前沿算法
-- 🏃 获取更高效的问题答疑和意见反馈
-- 🔥 提供与各行各业开发者充分交流的平台
-
-干货满满 📘，等你来撩 💗，OpenMMLab 社区期待您的加入 👬
diff --git a/mmsegmentation/configs/ann/README.md b/mmsegmentation/configs/ann/README.md
deleted file mode 100644
index 1281a9e..0000000
--- a/mmsegmentation/configs/ann/README.md
+++ /dev/null
@@ -1,68 +0,0 @@
-# ANN
-
-> [Asymmetric Non-local Neural Networks for Semantic Segmentation](https://arxiv.org/abs/1908.07678)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/MendelXu/ANN">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-The non-local module works as a particularly useful technique for semantic segmentation while criticized for its prohibitive computation and GPU memory occupation. In this paper, we present Asymmetric Non-local Neural Network to semantic segmentation, which has two prominent components: Asymmetric Pyramid Non-local Block (APNB) and Asymmetric Fusion Non-local Block (AFNB). APNB leverages a pyramid sampling module into the non-local block to largely reduce the computation and memory consumption without sacrificing the performance. AFNB is adapted from APNB to fuse the features of different levels under a sufficient consideration of long range dependencies and thus considerably improves the performance. Extensive experiments on semantic segmentation benchmarks demonstrate the effectiveness and efficiency of our work. In particular, we report the state-of-the-art performance of 81.3 mIoU on the Cityscapes test set. For a 256x128 input, APNB is around 6 times faster than a non-local block on GPU while 28 times smaller in GPU running memory occupation. Code is available at: [this https URL](https://github.com/MendelXu/ANN).
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142898322-3bbd578c-e488-4bae-9c14-7598adac5cbd.png" width="70%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                   | download                                                                                                                                                                                                                                                                                                                               |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| ANN    | R-50-D8  | 512x1024  |   40000 | 6        | 3.71           | V100   | 77.40 |         78.57 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r50-d8_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x1024_40k_cityscapes/ann_r50-d8_512x1024_40k_cityscapes_20200605_095211-049fc292.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x1024_40k_cityscapes/ann_r50-d8_512x1024_40k_cityscapes_20200605_095211.log.json)     |
-| ANN    | R-101-D8 | 512x1024  |   40000 | 9.5      | 2.55           | V100   | 76.55 |         78.85 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r101-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x1024_40k_cityscapes/ann_r101-d8_512x1024_40k_cityscapes_20200605_095243-adf6eece.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x1024_40k_cityscapes/ann_r101-d8_512x1024_40k_cityscapes_20200605_095243.log.json) |
-| ANN    | R-50-D8  | 769x769   |   40000 | 6.8      | 1.70           | V100   | 78.89 |         80.46 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r50-d8_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_769x769_40k_cityscapes/ann_r50-d8_769x769_40k_cityscapes_20200530_025712-2b46b04d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_769x769_40k_cityscapes/ann_r50-d8_769x769_40k_cityscapes_20200530_025712.log.json)         |
-| ANN    | R-101-D8 | 769x769   |   40000 | 10.7     | 1.15           | V100   | 79.32 |         80.94 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r101-d8_4xb2-40k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_769x769_40k_cityscapes/ann_r101-d8_769x769_40k_cityscapes_20200530_025720-059bff28.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_769x769_40k_cityscapes/ann_r101-d8_769x769_40k_cityscapes_20200530_025720.log.json)     |
-| ANN    | R-50-D8  | 512x1024  |   80000 | -        | -              | V100   | 77.34 |         78.65 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r50-d8_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x1024_80k_cityscapes/ann_r50-d8_512x1024_80k_cityscapes_20200607_101911-5a9ad545.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x1024_80k_cityscapes/ann_r50-d8_512x1024_80k_cityscapes_20200607_101911.log.json)     |
-| ANN    | R-101-D8 | 512x1024  |   80000 | -        | -              | V100   | 77.14 |         78.81 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r101-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x1024_80k_cityscapes/ann_r101-d8_512x1024_80k_cityscapes_20200607_013728-aceccc6e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x1024_80k_cityscapes/ann_r101-d8_512x1024_80k_cityscapes_20200607_013728.log.json) |
-| ANN    | R-50-D8  | 769x769   |   80000 | -        | -              | V100   | 78.88 |         80.57 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r50-d8_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_769x769_80k_cityscapes/ann_r50-d8_769x769_80k_cityscapes_20200607_044426-cc7ff323.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_769x769_80k_cityscapes/ann_r50-d8_769x769_80k_cityscapes_20200607_044426.log.json)         |
-| ANN    | R-101-D8 | 769x769   |   80000 | -        | -              | V100   | 78.80 |         80.34 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r101-d8_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_769x769_80k_cityscapes/ann_r101-d8_769x769_80k_cityscapes_20200607_013713-a9d4be8d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_769x769_80k_cityscapes/ann_r101-d8_769x769_80k_cityscapes_20200607_013713.log.json)     |
-
-### ADE20K
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                               | download                                                                                                                                                                                                                                                                                                               |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| ANN    | R-50-D8  | 512x512   |   80000 | 9.1      | 21.01          | V100   | 41.01 |         42.30 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_80k_ade20k/ann_r50-d8_512x512_80k_ade20k_20200615_014818-26f75e11.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_80k_ade20k/ann_r50-d8_512x512_80k_ade20k_20200615_014818.log.json)         |
-| ANN    | R-101-D8 | 512x512   |   80000 | 12.5     | 14.12          | V100   | 42.94 |         44.18 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_80k_ade20k/ann_r101-d8_512x512_80k_ade20k_20200615_014818-c0153543.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_80k_ade20k/ann_r101-d8_512x512_80k_ade20k_20200615_014818.log.json)     |
-| ANN    | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 41.74 |         42.62 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_160k_ade20k/ann_r50-d8_512x512_160k_ade20k_20200615_231733-892247bc.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_160k_ade20k/ann_r50-d8_512x512_160k_ade20k_20200615_231733.log.json)     |
-| ANN    | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 42.94 |         44.06 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_160k_ade20k/ann_r101-d8_512x512_160k_ade20k_20200615_231733-955eb1ec.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_160k_ade20k/ann_r101-d8_512x512_160k_ade20k_20200615_231733.log.json) |
-
-### Pascal VOC 2012 + Aug
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                | download                                                                                                                                                                                                                                                                                                                   |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | --------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| ANN    | R-50-D8  | 512x512   |   20000 | 6        | 20.92          | V100   | 74.86 |         76.13 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r50-d8_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_20k_voc12aug/ann_r50-d8_512x512_20k_voc12aug_20200617_222246-dfcb1c62.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_20k_voc12aug/ann_r50-d8_512x512_20k_voc12aug_20200617_222246.log.json)     |
-| ANN    | R-101-D8 | 512x512   |   20000 | 9.5      | 13.94          | V100   | 77.47 |         78.70 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r101-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_20k_voc12aug/ann_r101-d8_512x512_20k_voc12aug_20200617_222246-2fad0042.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_20k_voc12aug/ann_r101-d8_512x512_20k_voc12aug_20200617_222246.log.json) |
-| ANN    | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 76.56 |         77.51 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r50-d8_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_40k_voc12aug/ann_r50-d8_512x512_40k_voc12aug_20200613_231314-b5dac322.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_40k_voc12aug/ann_r50-d8_512x512_40k_voc12aug_20200613_231314.log.json)     |
-| ANN    | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 76.70 |         78.06 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann/ann_r101-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_40k_voc12aug/ann_r101-d8_512x512_40k_voc12aug_20200613_231314-bd205bbe.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_40k_voc12aug/ann_r101-d8_512x512_40k_voc12aug_20200613_231314.log.json) |
-
-## Citation
-
-```bibtex
-@inproceedings{zhu2019asymmetric,
-  title={Asymmetric non-local neural networks for semantic segmentation},
-  author={Zhu, Zhen and Xu, Mengde and Bai, Song and Huang, Tengteng and Bai, Xiang},
-  booktitle={Proceedings of the IEEE/CVF International Conference on Computer Vision},
-  pages={593--602},
-  year={2019}
-}
-```
diff --git a/mmsegmentation/configs/ann/ann_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/ann/ann_r101-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 0da7e0b..0000000
--- a/mmsegmentation/configs/ann/ann_r101-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './ann_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ann/ann_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/ann/ann_r101-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index 08459c0..0000000
--- a/mmsegmentation/configs/ann/ann_r101-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './ann_r50-d8_4xb2-40k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ann/ann_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/ann/ann_r101-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 46781fa..0000000
--- a/mmsegmentation/configs/ann/ann_r101-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './ann_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ann/ann_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/ann/ann_r101-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index c951d87..0000000
--- a/mmsegmentation/configs/ann/ann_r101-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './ann_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ann/ann_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/ann/ann_r101-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 9f14327..0000000
--- a/mmsegmentation/configs/ann/ann_r101-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './ann_r50-d8_4xb4-160k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ann/ann_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/ann/ann_r101-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index c3c1a3f..0000000
--- a/mmsegmentation/configs/ann/ann_r101-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './ann_r50-d8_4xb4-20k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ann/ann_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/ann/ann_r101-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index c3c1a3f..0000000
--- a/mmsegmentation/configs/ann/ann_r101-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './ann_r50-d8_4xb4-20k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ann/ann_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/ann/ann_r101-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 3cc5b8e..0000000
--- a/mmsegmentation/configs/ann/ann_r101-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './ann_r50-d8_4xb4-80k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ann/ann_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/ann/ann_r50-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 119eb76..0000000
--- a/mmsegmentation/configs/ann/ann_r50-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/ann_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/ann/ann_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/ann/ann_r50-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index 3152b92..0000000
--- a/mmsegmentation/configs/ann/ann_r50-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/ann_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/ann/ann_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/ann/ann_r50-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 793437f..0000000
--- a/mmsegmentation/configs/ann/ann_r50-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/ann_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/ann/ann_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/ann/ann_r50-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 4e392ca..0000000
--- a/mmsegmentation/configs/ann/ann_r50-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/ann_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/ann/ann_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/ann/ann_r50-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 900381d..0000000
--- a/mmsegmentation/configs/ann/ann_r50-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/ann_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/ann/ann_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/ann/ann_r50-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index 6921218..0000000
--- a/mmsegmentation/configs/ann/ann_r50-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/ann_r50-d8.py', '../_base_/datasets/pascal_voc12_aug.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_20k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/ann/ann_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/ann/ann_r50-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index e1c2360..0000000
--- a/mmsegmentation/configs/ann/ann_r50-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/ann_r50-d8.py', '../_base_/datasets/pascal_voc12_aug.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/ann/ann_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/ann/ann_r50-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 9fb26ef..0000000
--- a/mmsegmentation/configs/ann/ann_r50-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/ann_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/ann/metafile.yaml b/mmsegmentation/configs/ann/metafile.yaml
deleted file mode 100644
index 0d11868..0000000
--- a/mmsegmentation/configs/ann/metafile.yaml
+++ /dev/null
@@ -1,391 +0,0 @@
-Collections:
-- Name: ANN
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-    - ADE20K
-    - Pascal VOC 2012 + Aug
-  Paper:
-    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1908.07678
-  README: configs/ann/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: ann_r50-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: ANN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.4
-      mIoU(ms+flip): 78.57
-  Config: configs/ann/ann_r50-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - ANN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x1024_40k_cityscapes/ann_r50-d8_512x1024_40k_cityscapes_20200605_095211-049fc292.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x1024_40k_cityscapes/ann_r50-d8_512x1024_40k_cityscapes_20200605_095211.log.json
-  Paper:
-    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1908.07678
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
-  Framework: PyTorch
-- Name: ann_r101-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: ANN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.55
-      mIoU(ms+flip): 78.85
-  Config: configs/ann/ann_r101-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - ANN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x1024_40k_cityscapes/ann_r101-d8_512x1024_40k_cityscapes_20200605_095243-adf6eece.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x1024_40k_cityscapes/ann_r101-d8_512x1024_40k_cityscapes_20200605_095243.log.json
-  Paper:
-    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1908.07678
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
-  Framework: PyTorch
-- Name: ann_r50-d8_4xb2-40k_cityscapes-769x769
-  In Collection: ANN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.89
-      mIoU(ms+flip): 80.46
-  Config: configs/ann/ann_r50-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - ANN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_769x769_40k_cityscapes/ann_r50-d8_769x769_40k_cityscapes_20200530_025712-2b46b04d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_769x769_40k_cityscapes/ann_r50-d8_769x769_40k_cityscapes_20200530_025712.log.json
-  Paper:
-    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1908.07678
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
-  Framework: PyTorch
-- Name: ann_r101-d8_4xb2-40k_cityscapes-769x769
-  In Collection: ANN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.32
-      mIoU(ms+flip): 80.94
-  Config: configs/ann/ann_r101-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - ANN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.7
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_769x769_40k_cityscapes/ann_r101-d8_769x769_40k_cityscapes_20200530_025720-059bff28.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_769x769_40k_cityscapes/ann_r101-d8_769x769_40k_cityscapes_20200530_025720.log.json
-  Paper:
-    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1908.07678
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
-  Framework: PyTorch
-- Name: ann_r50-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: ANN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.34
-      mIoU(ms+flip): 78.65
-  Config: configs/ann/ann_r50-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - ANN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x1024_80k_cityscapes/ann_r50-d8_512x1024_80k_cityscapes_20200607_101911-5a9ad545.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x1024_80k_cityscapes/ann_r50-d8_512x1024_80k_cityscapes_20200607_101911.log.json
-  Paper:
-    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1908.07678
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
-  Framework: PyTorch
-- Name: ann_r101-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: ANN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.14
-      mIoU(ms+flip): 78.81
-  Config: configs/ann/ann_r101-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - ANN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x1024_80k_cityscapes/ann_r101-d8_512x1024_80k_cityscapes_20200607_013728-aceccc6e.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x1024_80k_cityscapes/ann_r101-d8_512x1024_80k_cityscapes_20200607_013728.log.json
-  Paper:
-    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1908.07678
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
-  Framework: PyTorch
-- Name: ann_r50-d8_4xb2-80k_cityscapes-769x769
-  In Collection: ANN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.88
-      mIoU(ms+flip): 80.57
-  Config: configs/ann/ann_r50-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - ANN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_769x769_80k_cityscapes/ann_r50-d8_769x769_80k_cityscapes_20200607_044426-cc7ff323.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_769x769_80k_cityscapes/ann_r50-d8_769x769_80k_cityscapes_20200607_044426.log.json
-  Paper:
-    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1908.07678
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
-  Framework: PyTorch
-- Name: ann_r101-d8_4xb2-80k_cityscapes-769x769
-  In Collection: ANN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.8
-      mIoU(ms+flip): 80.34
-  Config: configs/ann/ann_r101-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - ANN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_769x769_80k_cityscapes/ann_r101-d8_769x769_80k_cityscapes_20200607_013713-a9d4be8d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_769x769_80k_cityscapes/ann_r101-d8_769x769_80k_cityscapes_20200607_013713.log.json
-  Paper:
-    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1908.07678
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
-  Framework: PyTorch
-- Name: ann_r50-d8_4xb4-80k_ade20k-512x512
-  In Collection: ANN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 41.01
-      mIoU(ms+flip): 42.3
-  Config: configs/ann/ann_r50-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - ANN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_80k_ade20k/ann_r50-d8_512x512_80k_ade20k_20200615_014818-26f75e11.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_80k_ade20k/ann_r50-d8_512x512_80k_ade20k_20200615_014818.log.json
-  Paper:
-    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1908.07678
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
-  Framework: PyTorch
-- Name: ann_r101-d8_4xb4-80k_ade20k-512x512
-  In Collection: ANN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.94
-      mIoU(ms+flip): 44.18
-  Config: configs/ann/ann_r101-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - ANN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 12.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_80k_ade20k/ann_r101-d8_512x512_80k_ade20k_20200615_014818-c0153543.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_80k_ade20k/ann_r101-d8_512x512_80k_ade20k_20200615_014818.log.json
-  Paper:
-    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1908.07678
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
-  Framework: PyTorch
-- Name: ann_r50-d8_4xb4-160k_ade20k-512x512
-  In Collection: ANN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 41.74
-      mIoU(ms+flip): 42.62
-  Config: configs/ann/ann_r50-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - ANN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_160k_ade20k/ann_r50-d8_512x512_160k_ade20k_20200615_231733-892247bc.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_160k_ade20k/ann_r50-d8_512x512_160k_ade20k_20200615_231733.log.json
-  Paper:
-    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1908.07678
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
-  Framework: PyTorch
-- Name: ann_r101-d8_4xb4-160k_ade20k-512x512
-  In Collection: ANN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.94
-      mIoU(ms+flip): 44.06
-  Config: configs/ann/ann_r101-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - ANN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_160k_ade20k/ann_r101-d8_512x512_160k_ade20k_20200615_231733-955eb1ec.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_160k_ade20k/ann_r101-d8_512x512_160k_ade20k_20200615_231733.log.json
-  Paper:
-    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1908.07678
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
-  Framework: PyTorch
-- Name: ann_r50-d8_4xb4-20k_voc12aug-512x512
-  In Collection: ANN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 74.86
-      mIoU(ms+flip): 76.13
-  Config: configs/ann/ann_r50-d8_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - ANN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_20k_voc12aug/ann_r50-d8_512x512_20k_voc12aug_20200617_222246-dfcb1c62.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_20k_voc12aug/ann_r50-d8_512x512_20k_voc12aug_20200617_222246.log.json
-  Paper:
-    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1908.07678
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
-  Framework: PyTorch
-- Name: ann_r101-d8_4xb4-20k_voc12aug-512x512
-  In Collection: ANN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 77.47
-      mIoU(ms+flip): 78.7
-  Config: configs/ann/ann_r101-d8_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - ANN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_20k_voc12aug/ann_r101-d8_512x512_20k_voc12aug_20200617_222246-2fad0042.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_20k_voc12aug/ann_r101-d8_512x512_20k_voc12aug_20200617_222246.log.json
-  Paper:
-    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1908.07678
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
-  Framework: PyTorch
-- Name: ann_r50-d8_4xb4-40k_voc12aug-512x512
-  In Collection: ANN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 76.56
-      mIoU(ms+flip): 77.51
-  Config: configs/ann/ann_r50-d8_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - ANN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_40k_voc12aug/ann_r50-d8_512x512_40k_voc12aug_20200613_231314-b5dac322.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x512_40k_voc12aug/ann_r50-d8_512x512_40k_voc12aug_20200613_231314.log.json
-  Paper:
-    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1908.07678
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
-  Framework: PyTorch
-- Name: ann_r101-d8_4xb4-40k_voc12aug-512x512
-  In Collection: ANN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 76.7
-      mIoU(ms+flip): 78.06
-  Config: configs/ann/ann_r101-d8_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - ANN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_40k_voc12aug/ann_r101-d8_512x512_40k_voc12aug_20200613_231314-bd205bbe.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r101-d8_512x512_40k_voc12aug/ann_r101-d8_512x512_40k_voc12aug_20200613_231314.log.json
-  Paper:
-    Title: Asymmetric Non-local Neural Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1908.07678
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ann_head.py#L185
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/apcnet/README.md b/mmsegmentation/configs/apcnet/README.md
deleted file mode 100644
index 9104f3c..0000000
--- a/mmsegmentation/configs/apcnet/README.md
+++ /dev/null
@@ -1,59 +0,0 @@
-# APCNet
-
-> [Adaptive Pyramid Context Network for Semantic Segmentation](https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/Junjun2016/APCNet">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Recent studies witnessed that context features can significantly improve the performance of deep semantic segmentation networks. Current context based segmentation methods differ with each other in how to construct context features and perform differently in practice. This paper firstly introduces three desirable properties of context features in segmentation task. Specially, we find that Global-guided Local Affinity (GLA) can play a vital role in constructing effective context features, while this property has been largely ignored in previous works. Based on this analysis, this paper proposes Adaptive Pyramid Context Network (APCNet)for semantic segmentation. APCNet adaptively constructs multi-scale contextual representations with multiple welldesigned Adaptive Context Modules (ACMs). Specifically, each ACM leverages a global image representation as a guidance to estimate the local affinity coefficients for each sub-region, and then calculates a context vector with these affinities. We empirically evaluate our APCNet on three semantic segmentation and scene parsing datasets, including PASCAL VOC 2012, Pascal-Context, and ADE20K dataset. Experimental results show that APCNet achieves state-ofthe-art performance on all three benchmarks, and obtains a new record 84.2% on PASCAL VOC 2012 test set without MS COCO pre-trained and any post-processing.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142898638-e1c0c6ae-9270-448e-aa01-bbac3a236db5.png" width="70%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                         | download                                                                                                                                                                                                                                                                                                                                                 |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| APCNet | R-50-D8  | 512x1024  |   40000 | 7.7      | 3.57           | V100   | 78.02 |         79.26 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x1024_40k_cityscapes/apcnet_r50-d8_512x1024_40k_cityscapes_20201214_115717-5e88fa33.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x1024_40k_cityscapes/apcnet_r50-d8_512x1024_40k_cityscapes-20201214_115717.log.json)     |
-| APCNet | R-101-D8 | 512x1024  |   40000 | 11.2     | 2.15           | V100   | 79.08 |         80.34 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x1024_40k_cityscapes/apcnet_r101-d8_512x1024_40k_cityscapes_20201214_115716-abc9d111.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x1024_40k_cityscapes/apcnet_r101-d8_512x1024_40k_cityscapes-20201214_115716.log.json) |
-| APCNet | R-50-D8  | 769x769   |   40000 | 8.7      | 1.52           | V100   | 77.89 |         79.75 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_769x769_40k_cityscapes/apcnet_r50-d8_769x769_40k_cityscapes_20201214_115717-2a2628d7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_769x769_40k_cityscapes/apcnet_r50-d8_769x769_40k_cityscapes-20201214_115717.log.json)         |
-| APCNet | R-101-D8 | 769x769   |   40000 | 12.7     | 1.03           | V100   | 77.96 |         79.24 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_769x769_40k_cityscapes/apcnet_r101-d8_769x769_40k_cityscapes_20201214_115718-b650de90.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_769x769_40k_cityscapes/apcnet_r101-d8_769x769_40k_cityscapes-20201214_115718.log.json)     |
-| APCNet | R-50-D8  | 512x1024  |   80000 | -        | -              | V100   | 78.96 |         79.94 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x1024_80k_cityscapes/apcnet_r50-d8_512x1024_80k_cityscapes_20201214_115716-987f51e3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x1024_80k_cityscapes/apcnet_r50-d8_512x1024_80k_cityscapes-20201214_115716.log.json)     |
-| APCNet | R-101-D8 | 512x1024  |   80000 | -        | -              | V100   | 79.64 |         80.61 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x1024_80k_cityscapes/apcnet_r101-d8_512x1024_80k_cityscapes_20201214_115705-b1ff208a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x1024_80k_cityscapes/apcnet_r101-d8_512x1024_80k_cityscapes-20201214_115705.log.json) |
-| APCNet | R-50-D8  | 769x769   |   80000 | -        | -              | V100   | 78.79 |         80.35 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_769x769_80k_cityscapes/apcnet_r50-d8_769x769_80k_cityscapes_20201214_115718-7ea9fa12.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_769x769_80k_cityscapes/apcnet_r50-d8_769x769_80k_cityscapes-20201214_115718.log.json)         |
-| APCNet | R-101-D8 | 769x769   |   80000 | -        | -              | V100   | 78.45 |         79.91 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_769x769_80k_cityscapes/apcnet_r101-d8_769x769_80k_cityscapes_20201214_115716-a7fbc2ab.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_769x769_80k_cityscapes/apcnet_r101-d8_769x769_80k_cityscapes-20201214_115716.log.json)     |
-
-### ADE20K
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                     | download                                                                                                                                                                                                                                                                                                                                 |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| APCNet | R-50-D8  | 512x512   |   80000 | 10.1     | 19.61          | V100   | 42.20 |         43.30 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x512_80k_ade20k/apcnet_r50-d8_512x512_80k_ade20k_20201214_115705-a8626293.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x512_80k_ade20k/apcnet_r50-d8_512x512_80k_ade20k-20201214_115705.log.json)         |
-| APCNet | R-101-D8 | 512x512   |   80000 | 13.6     | 13.10          | V100   | 45.54 |         46.65 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x512_80k_ade20k/apcnet_r101-d8_512x512_80k_ade20k_20201214_115704-c656c3fb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x512_80k_ade20k/apcnet_r101-d8_512x512_80k_ade20k-20201214_115704.log.json)     |
-| APCNet | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 43.40 |         43.94 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x512_160k_ade20k/apcnet_r50-d8_512x512_160k_ade20k_20201214_115706-25fb92c2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x512_160k_ade20k/apcnet_r50-d8_512x512_160k_ade20k-20201214_115706.log.json)     |
-| APCNet | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 45.41 |         46.63 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet/apcnet_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x512_160k_ade20k/apcnet_r101-d8_512x512_160k_ade20k_20201214_115705-73f9a8d7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x512_160k_ade20k/apcnet_r101-d8_512x512_160k_ade20k-20201214_115705.log.json) |
-
-## Citation
-
-```bibtex
-@InProceedings{He_2019_CVPR,
-author = {He, Junjun and Deng, Zhongying and Zhou, Lei and Wang, Yali and Qiao, Yu},
-title = {Adaptive Pyramid Context Network for Semantic Segmentation},
-booktitle = {Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
-month = {June},
-year = {2019}
-}
-```
diff --git a/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 754b2d1..0000000
--- a/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './apcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index d2b5fe1..0000000
--- a/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './apcnet_r50-d8_4xb2-40k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 03b018d..0000000
--- a/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './apcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 0cbbfad..0000000
--- a/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './apcnet_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index f0aacc0..0000000
--- a/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './apcnet_r50-d8_4xb4-160k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 219d07a..0000000
--- a/mmsegmentation/configs/apcnet/apcnet_r101-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './apcnet_r50-d8_4xb4-80k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index b440771..0000000
--- a/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/apcnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index 9ff897c..0000000
--- a/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/apcnet_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 6de1033..0000000
--- a/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/apcnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index d6ec898..0000000
--- a/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/apcnet_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 37b23d1..0000000
--- a/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/apcnet_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index b0fbe27..0000000
--- a/mmsegmentation/configs/apcnet/apcnet_r50-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/apcnet_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/apcnet/metafile.yaml b/mmsegmentation/configs/apcnet/metafile.yaml
deleted file mode 100644
index 3f4072c..0000000
--- a/mmsegmentation/configs/apcnet/metafile.yaml
+++ /dev/null
@@ -1,296 +0,0 @@
-Collections:
-- Name: APCNet
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-    - ADE20K
-  Paper:
-    Title: Adaptive Pyramid Context Network for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
-  README: configs/apcnet/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: apcnet_r50-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: APCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.02
-      mIoU(ms+flip): 79.26
-  Config: configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - APCNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 7.7
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x1024_40k_cityscapes/apcnet_r50-d8_512x1024_40k_cityscapes_20201214_115717-5e88fa33.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x1024_40k_cityscapes/apcnet_r50-d8_512x1024_40k_cityscapes-20201214_115717.log.json
-  Paper:
-    Title: Adaptive Pyramid Context Network for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: apcnet_r101-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: APCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.08
-      mIoU(ms+flip): 80.34
-  Config: configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - APCNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 11.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x1024_40k_cityscapes/apcnet_r101-d8_512x1024_40k_cityscapes_20201214_115716-abc9d111.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x1024_40k_cityscapes/apcnet_r101-d8_512x1024_40k_cityscapes-20201214_115716.log.json
-  Paper:
-    Title: Adaptive Pyramid Context Network for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: apcnet_r50-d8_4xb2-40k_cityscapes-769x769
-  In Collection: APCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.89
-      mIoU(ms+flip): 79.75
-  Config: configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - APCNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.7
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_769x769_40k_cityscapes/apcnet_r50-d8_769x769_40k_cityscapes_20201214_115717-2a2628d7.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_769x769_40k_cityscapes/apcnet_r50-d8_769x769_40k_cityscapes-20201214_115717.log.json
-  Paper:
-    Title: Adaptive Pyramid Context Network for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: apcnet_r101-d8_4xb2-40k_cityscapes-769x769
-  In Collection: APCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.96
-      mIoU(ms+flip): 79.24
-  Config: configs/apcnet/apcnet_r101-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - APCNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 12.7
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_769x769_40k_cityscapes/apcnet_r101-d8_769x769_40k_cityscapes_20201214_115718-b650de90.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_769x769_40k_cityscapes/apcnet_r101-d8_769x769_40k_cityscapes-20201214_115718.log.json
-  Paper:
-    Title: Adaptive Pyramid Context Network for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: apcnet_r50-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: APCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.96
-      mIoU(ms+flip): 79.94
-  Config: configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - APCNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x1024_80k_cityscapes/apcnet_r50-d8_512x1024_80k_cityscapes_20201214_115716-987f51e3.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x1024_80k_cityscapes/apcnet_r50-d8_512x1024_80k_cityscapes-20201214_115716.log.json
-  Paper:
-    Title: Adaptive Pyramid Context Network for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: apcnet_r101-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: APCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.64
-      mIoU(ms+flip): 80.61
-  Config: configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - APCNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x1024_80k_cityscapes/apcnet_r101-d8_512x1024_80k_cityscapes_20201214_115705-b1ff208a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x1024_80k_cityscapes/apcnet_r101-d8_512x1024_80k_cityscapes-20201214_115705.log.json
-  Paper:
-    Title: Adaptive Pyramid Context Network for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: apcnet_r50-d8_4xb2-80k_cityscapes-769x769
-  In Collection: APCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.79
-      mIoU(ms+flip): 80.35
-  Config: configs/apcnet/apcnet_r50-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - APCNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_769x769_80k_cityscapes/apcnet_r50-d8_769x769_80k_cityscapes_20201214_115718-7ea9fa12.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_769x769_80k_cityscapes/apcnet_r50-d8_769x769_80k_cityscapes-20201214_115718.log.json
-  Paper:
-    Title: Adaptive Pyramid Context Network for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: apcnet_r101-d8_4xb2-80k_cityscapes-769x769
-  In Collection: APCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.45
-      mIoU(ms+flip): 79.91
-  Config: configs/apcnet/apcnet_r101-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - APCNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_769x769_80k_cityscapes/apcnet_r101-d8_769x769_80k_cityscapes_20201214_115716-a7fbc2ab.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_769x769_80k_cityscapes/apcnet_r101-d8_769x769_80k_cityscapes-20201214_115716.log.json
-  Paper:
-    Title: Adaptive Pyramid Context Network for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: apcnet_r50-d8_4xb4-80k_ade20k-512x512
-  In Collection: APCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.2
-      mIoU(ms+flip): 43.3
-  Config: configs/apcnet/apcnet_r50-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - APCNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x512_80k_ade20k/apcnet_r50-d8_512x512_80k_ade20k_20201214_115705-a8626293.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x512_80k_ade20k/apcnet_r50-d8_512x512_80k_ade20k-20201214_115705.log.json
-  Paper:
-    Title: Adaptive Pyramid Context Network for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: apcnet_r101-d8_4xb4-80k_ade20k-512x512
-  In Collection: APCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 45.54
-      mIoU(ms+flip): 46.65
-  Config: configs/apcnet/apcnet_r101-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - APCNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 13.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x512_80k_ade20k/apcnet_r101-d8_512x512_80k_ade20k_20201214_115704-c656c3fb.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x512_80k_ade20k/apcnet_r101-d8_512x512_80k_ade20k-20201214_115704.log.json
-  Paper:
-    Title: Adaptive Pyramid Context Network for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: apcnet_r50-d8_4xb4-160k_ade20k-512x512
-  In Collection: APCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 43.4
-      mIoU(ms+flip): 43.94
-  Config: configs/apcnet/apcnet_r50-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - APCNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x512_160k_ade20k/apcnet_r50-d8_512x512_160k_ade20k_20201214_115706-25fb92c2.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r50-d8_512x512_160k_ade20k/apcnet_r50-d8_512x512_160k_ade20k-20201214_115706.log.json
-  Paper:
-    Title: Adaptive Pyramid Context Network for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: apcnet_r101-d8_4xb4-160k_ade20k-512x512
-  In Collection: APCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 45.41
-      mIoU(ms+flip): 46.63
-  Config: configs/apcnet/apcnet_r101-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - APCNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x512_160k_ade20k/apcnet_r101-d8_512x512_160k_ade20k_20201214_115705-73f9a8d7.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/apcnet/apcnet_r101-d8_512x512_160k_ade20k/apcnet_r101-d8_512x512_160k_ade20k-20201214_115705.log.json
-  Paper:
-    Title: Adaptive Pyramid Context Network for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_CVPR_2019/html/He_Adaptive_Pyramid_Context_Network_for_Semantic_Segmentation_CVPR_2019_paper.html
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/beit/README.md b/mmsegmentation/configs/beit/README.md
deleted file mode 100644
index b005c88..0000000
--- a/mmsegmentation/configs/beit/README.md
+++ /dev/null
@@ -1,85 +0,0 @@
-# BEiT
-
-> [BEiT: BERT Pre-Training of Image Transformers](https://arxiv.org/abs/2106.08254)
-
-## Introduction
-
-<!-- [BACKBONE] -->
-
-<a href="https://github.com/microsoft/unilm/tree/master/beit">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.23.0/mmseg/models/backbones/beit.py#1404">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-We introduce a self-supervised vision representation model BEiT, which stands for Bidirectional Encoder representation from Image Transformers. Following BERT developed in the natural language processing area, we propose a masked image modeling task to pretrain vision Transformers. Specifically, each image has two views in our pre-training, i.e, image patches (such as 16x16 pixels), and visual tokens (i.e., discrete tokens). We first "tokenize" the original image into visual tokens. Then we randomly mask some image patches and fed them into the backbone Transformer. The pre-training objective is to recover the original visual tokens based on the corrupted image patches. After pre-training BEiT, we directly fine-tune the model parameters on downstream tasks by appending task layers upon the pretrained encoder. Experimental results on image classification and semantic segmentation show that our model achieves competitive results with previous pre-training methods. For example, base-size BEiT achieves 83.2% top-1 accuracy on ImageNet-1K, significantly outperforming from-scratch DeiT training (81.8%) with the same setup. Moreover, large-size BEiT obtains 86.3% only using ImageNet-1K, even outperforming ViT-L with supervised pre-training on ImageNet-22K (85.2%). The code and pretrained models are available at [this https URL](https://github.com/microsoft/unilm/tree/master/beit).
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/93248678/160155758-781c9a45-b1d7-4530-9015-88eca6645006.png" width="70%"/>
-</div>
-
-## Usage
-
-To use other repositories' pre-trained models, it is necessary to convert keys.
-
-We provide a script [`beit2mmseg.py`](../../tools/model_converters/beit2mmseg.py) in the tools directory to convert the key of models from [the official repo](https://github.com/microsoft/unilm/tree/master/beit/semantic_segmentation) to MMSegmentation style.
-
-```shell
-python tools/model_converters/beit2mmseg.py ${PRETRAIN_PATH} ${STORE_PATH}
-```
-
-E.g.
-
-```shell
-python tools/model_converters/beit2mmseg.py https://conversationhub.blob.core.windows.net/beit-share-public/beit/beit_base_patch16_224_pt22k_ft22k.pth pretrain/beit_base_patch16_224_pt22k_ft22k.pth
-```
-
-This script convert model from `PRETRAIN_PATH` and store the converted model in `STORE_PATH`.
-
-In our default setting, pretrained models could be defined below:
-
-| pretrained models | original models                                                                                                             |
-| ----------------- | --------------------------------------------------------------------------------------------------------------------------- |
-| BEiT_base.pth     | ['BEiT_base'](https://conversationhub.blob.core.windows.net/beit-share-public/beit/beit_base_patch16_224_pt22k_ft22k.pth)   |
-| BEiT_large.pth    | ['BEiT_large'](https://conversationhub.blob.core.windows.net/beit-share-public/beit/beit_large_patch16_224_pt22k_ft22k.pth) |
-
-Verify the single-scale results of the model:
-
-```shell
-sh tools/dist_test.sh \
-configs/beit/upernet_beit-large_fp16_8x1_640x640_160k_ade20k.py \
-upernet_beit-large_fp16_8x1_640x640_160k_ade20k-8fc0dd5d.pth $GPUS --eval mIoU
-```
-
-Since relative position embedding requires the input length and width to be equal, the sliding window is adopted for multi-scale inference. So we set min_size=640, that is, the shortest edge is 640. So the multi-scale inference of config is performed separately, instead of '--aug-test'. For multi-scale inference:
-
-```shell
-sh tools/dist_test.sh \
-configs/beit/upernet_beit-large_fp16_640x640_160k_ade20k_ms.py \
-upernet_beit-large_fp16_8x1_640x640_160k_ade20k-8fc0dd5d.pth $GPUS --eval mIoU
-```
-
-## Results and models
-
-### ADE20K
-
-| Method  | Backbone | Crop Size | pretrain     | pretrain img size | Batch Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                           | download                                                                                                                                                                                                                                                                                                                                                 |
-| ------- | -------- | --------- | ------------ | ----------------- | ---------- | ------- | -------- | -------------- | ------ | ----- | ------------: | -------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| UPerNet | BEiT-B   | 640x640   | ImageNet-22K | 224x224           | 16         | 160000  | 15.88    | 2.00           | V100   | 53.08 |         53.84 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/beit/beit-base_upernet_8xb2-160k_ade20k-640x640.py)      | [model](https://download.openmmlab.com/mmsegmentation/v0.5/beit/upernet_beit-base_8x2_640x640_160k_ade20k/upernet_beit-base_8x2_640x640_160k_ade20k-eead221d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/beit/upernet_beit-base_8x2_640x640_160k_ade20k/upernet_beit-base_8x2_640x640_160k_ade20k.log.json)                         |
-| UPerNet | BEiT-L   | 640x640   | ImageNet-22K | 224x224           | 8          | 320000  | 22.64    | 0.96           | V100   | 56.33 |         56.84 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/beit/beit-large_upernet_8xb1-amp-160k_ade20k-640x640.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/beit/upernet_beit-large_fp16_8x1_640x640_160k_ade20k/upernet_beit-large_fp16_8x1_640x640_160k_ade20k-8fc0dd5d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/beit/upernet_beit-large_fp16_8x1_640x640_160k_ade20k/upernet_beit-large_fp16_8x1_640x640_160k_ade20k.log.json) |
-
-## Citation
-
-```bibtex
-@inproceedings{beit,
-      title={{BEiT}: {BERT} Pre-Training of Image Transformers},
-      author={Hangbo Bao and Li Dong and Songhao Piao and Furu Wei},
-      booktitle={International Conference on Learning Representations},
-      year={2022},
-      url={https://openreview.net/forum?id=p-BhZSz59o4}
-}
-```
diff --git a/mmsegmentation/configs/beit/beit-base_upernet_8xb2-160k_ade20k-640x640.py b/mmsegmentation/configs/beit/beit-base_upernet_8xb2-160k_ade20k-640x640.py
deleted file mode 100644
index 1cd7d0e..0000000
--- a/mmsegmentation/configs/beit/beit-base_upernet_8xb2-160k_ade20k-640x640.py
+++ /dev/null
@@ -1,36 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_beit.py', '../_base_/datasets/ade20k_640x640.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (640, 640)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained='pretrain/beit_base_patch16_224_pt22k_ft22k.pth',
-    test_cfg=dict(mode='slide', crop_size=(640, 640), stride=(426, 426)))
-
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=3e-5, betas=(0.9, 0.999), weight_decay=0.05),
-    constructor='LayerDecayOptimizerConstructor',
-    paramwise_cfg=dict(num_layers=12, layer_decay_rate=0.9))
-
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        power=1.0,
-        begin=1500,
-        end=160000,
-        eta_min=0.0,
-        by_epoch=False,
-    )
-]
-
-# By default, models are trained on 8 GPUs with 2 images per GPU
-train_dataloader = dict(batch_size=2)
-val_dataloader = dict(batch_size=1)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/beit/beit-base_upernet_8xb2-160k_ade20k-640x640_ms.py b/mmsegmentation/configs/beit/beit-base_upernet_8xb2-160k_ade20k-640x640_ms.py
deleted file mode 100644
index 0248022..0000000
--- a/mmsegmentation/configs/beit/beit-base_upernet_8xb2-160k_ade20k-640x640_ms.py
+++ /dev/null
@@ -1,16 +0,0 @@
-_base_ = './beit-base_upernet_8xb2-160k_ade20k-640x640.py'
-
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    # TODO: Refactor 'MultiScaleFlipAug' which supports
-    # `min_size` feature in `Resize` class
-    # img_ratios is [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
-    # original image scale is (2560, 640)
-    dict(type='Resize', scale=(2560, 640), keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='PackSegInputs'),
-]
-val_dataloader = dict(batch_size=1, dataset=dict(pipeline=test_pipeline))
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/beit/beit-large_upernet_8xb1-amp-160k_ade20k-640x640.py b/mmsegmentation/configs/beit/beit-large_upernet_8xb1-amp-160k_ade20k-640x640.py
deleted file mode 100644
index 4fd5cd2..0000000
--- a/mmsegmentation/configs/beit/beit-large_upernet_8xb1-amp-160k_ade20k-640x640.py
+++ /dev/null
@@ -1,50 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_beit.py', '../_base_/datasets/ade20k_640x640.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_320k.py'
-]
-crop_size = (640, 640)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained='pretrain/beit_large_patch16_224_pt22k_ft22k.pth',
-    backbone=dict(
-        type='BEiT',
-        embed_dims=1024,
-        num_layers=24,
-        num_heads=16,
-        mlp_ratio=4,
-        qv_bias=True,
-        init_values=1e-6,
-        drop_path_rate=0.2,
-        out_indices=[7, 11, 15, 23]),
-    neck=dict(embed_dim=1024, rescales=[4, 2, 1, 0.5]),
-    decode_head=dict(
-        in_channels=[1024, 1024, 1024, 1024], num_classes=150, channels=1024),
-    auxiliary_head=dict(in_channels=1024, num_classes=150),
-    test_cfg=dict(mode='slide', crop_size=(640, 640), stride=(426, 426)))
-
-optim_wrapper = dict(
-    _delete_=True,
-    type='AmpOptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=2e-5, betas=(0.9, 0.999), weight_decay=0.05),
-    constructor='LayerDecayOptimizerConstructor',
-    paramwise_cfg=dict(num_layers=24, layer_decay_rate=0.95),
-    accumulative_counts=2)
-
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=3000),
-    dict(
-        type='PolyLR',
-        power=1.0,
-        begin=3000,
-        end=160000,
-        eta_min=0.0,
-        by_epoch=False,
-    )
-]
-
-train_dataloader = dict(batch_size=1)
-val_dataloader = dict(batch_size=1)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/beit/beit-large_upernet_8xb1-amp-160k_ade20k-640x640_ms.py b/mmsegmentation/configs/beit/beit-large_upernet_8xb1-amp-160k_ade20k-640x640_ms.py
deleted file mode 100644
index fc6f049..0000000
--- a/mmsegmentation/configs/beit/beit-large_upernet_8xb1-amp-160k_ade20k-640x640_ms.py
+++ /dev/null
@@ -1,16 +0,0 @@
-_base_ = './beit-large_upernet_8xb1-amp-160k_ade20k-640x640.py'
-
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    # TODO: Refactor 'MultiScaleFlipAug' which supports
-    # `min_size` feature in `Resize` class
-    # img_ratios is [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
-    # original image scale is (2560, 640)
-    dict(type='Resize', scale=(2560, 640), keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='PackSegInputs'),
-]
-val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/beit/metafile.yaml b/mmsegmentation/configs/beit/metafile.yaml
deleted file mode 100644
index ef6124e..0000000
--- a/mmsegmentation/configs/beit/metafile.yaml
+++ /dev/null
@@ -1,49 +0,0 @@
-Models:
-- Name: beit-base_upernet_8xb2-160k_ade20k-640x640
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 53.08
-      mIoU(ms+flip): 53.84
-  Config: configs/beit/beit-base_upernet_8xb2-160k_ade20k-640x640.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - BEiT-B
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 15.88
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/beit/upernet_beit-base_8x2_640x640_160k_ade20k/upernet_beit-base_8x2_640x640_160k_ade20k-eead221d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/beit/upernet_beit-base_8x2_640x640_160k_ade20k/upernet_beit-base_8x2_640x640_160k_ade20k.log.json
-  Paper:
-    Title: 'BEiT: BERT Pre-Training of Image Transformers'
-    URL: https://arxiv.org/abs/2106.08254
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.23.0/mmseg/models/backbones/beit.py#1404
-  Framework: PyTorch
-- Name: beit-large_upernet_8xb1-amp-160k_ade20k-640x640
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 56.33
-      mIoU(ms+flip): 56.84
-  Config: configs/beit/beit-large_upernet_8xb1-amp-160k_ade20k-640x640.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 8
-    Architecture:
-    - BEiT-L
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 22.64
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/beit/upernet_beit-large_fp16_8x1_640x640_160k_ade20k/upernet_beit-large_fp16_8x1_640x640_160k_ade20k-8fc0dd5d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/beit/upernet_beit-large_fp16_8x1_640x640_160k_ade20k/upernet_beit-large_fp16_8x1_640x640_160k_ade20k.log.json
-  Paper:
-    Title: 'BEiT: BERT Pre-Training of Image Transformers'
-    URL: https://arxiv.org/abs/2106.08254
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.23.0/mmseg/models/backbones/beit.py#1404
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/bisenetv1/README.md b/mmsegmentation/configs/bisenetv1/README.md
deleted file mode 100644
index a505895..0000000
--- a/mmsegmentation/configs/bisenetv1/README.md
+++ /dev/null
@@ -1,64 +0,0 @@
-# BiSeNetV1
-
-> [BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation](https://arxiv.org/abs/1808.00897)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/ycszen/TorchSeg/tree/master/model/bisenet">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Semantic segmentation requires both rich spatial information and sizeable receptive field. However, modern approaches usually compromise spatial resolution to achieve real-time inference speed, which leads to poor performance. In this paper, we address this dilemma with a novel Bilateral Segmentation Network (BiSeNet). We first design a Spatial Path with a small stride to preserve the spatial information and generate high-resolution features. Meanwhile, a Context Path with a fast downsampling strategy is employed to obtain sufficient receptive field. On top of the two paths, we introduce a new Feature Fusion Module to combine features efficiently. The proposed architecture makes a right balance between the speed and segmentation performance on Cityscapes, CamVid, and COCO-Stuff datasets. Specifically, for a 2048x1024 input, we achieve 68.4% Mean IOU on the Cityscapes test dataset with speed of 105 FPS on one NVIDIA Titan XP card, which is significantly faster than the existing methods with comparable performance.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142898839-a0a78148-848a-41b2-8682-b1f61ac004ba.png" width="70%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method    | Backbone               | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                          | download                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| --------- | ---------------------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| BiSeNetV1 | R-18-D32 (No Pretrain) | 1024x1024 |  160000 | 5.69     | 31.77          | V100   | 74.44 | 77.05         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_cityscapes-1024x1024.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_4x4_1024x1024_160k_cityscapes/bisenetv1_r18-d32_4x4_1024x1024_160k_cityscapes_20210922_172239-c55e78e2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_4x4_1024x1024_160k_cityscapes/bisenetv1_r18-d32_4x4_1024x1024_160k_cityscapes_20210922_172239.log.json)                                     |
-| BiSeNetV1 | R-18-D32               | 1024x1024 |  160000 | 5.69     | 31.77          | V100   | 74.37 | 76.91         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_4x4_1024x1024_160k_cityscapes/bisenetv1_r18-d32_in1k-pre_4x4_1024x1024_160k_cityscapes_20210905_220251-8ba80eff.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_4x4_1024x1024_160k_cityscapes/bisenetv1_r18-d32_in1k-pre_4x4_1024x1024_160k_cityscapes_20210905_220251.log.json) |
-| BiSeNetV1 | R-18-D32 (4x8)         | 1024x1024 |  160000 | 11.17    | 31.77          | V100   | 75.16 | 77.24         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb8-160k_cityscapes-1024x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_4x8_1024x1024_160k_cityscapes/bisenetv1_r18-d32_in1k-pre_4x8_1024x1024_160k_cityscapes_20210905_220322-bb8db75f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_4x8_1024x1024_160k_cityscapes/bisenetv1_r18-d32_in1k-pre_4x8_1024x1024_160k_cityscapes_20210905_220322.log.json) |
-| BiSeNetV1 | R-50-D32 (No Pretrain) | 1024x1024 |  160000 | 15.39    | 7.71           | V100   | 76.92 | 78.87         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_4x4_1024x1024_160k_cityscapes/bisenetv1_r50-d32_4x4_1024x1024_160k_cityscapes_20210923_222639-7b28a2a6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_4x4_1024x1024_160k_cityscapes/bisenetv1_r50-d32_4x4_1024x1024_160k_cityscapes_20210923_222639.log.json)                                     |
-| BiSeNetV1 | R-50-D32               | 1024x1024 |  160000 | 15.39    | 7.71           | V100   | 77.68 | 79.57         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_in1k-pre_4x4_1024x1024_160k_cityscapes/bisenetv1_r50-d32_in1k-pre_4x4_1024x1024_160k_cityscapes_20210917_234628-8b304447.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_in1k-pre_4x4_1024x1024_160k_cityscapes/bisenetv1_r50-d32_in1k-pre_4x4_1024x1024_160k_cityscapes_20210917_234628.log.json) |
-
-### COCO-Stuff 164k
-
-| Method    | Backbone                | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                             | download                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| --------- | ----------------------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| BiSeNetV1 | R-18-D32 (No Pretrain)  | 512x512   |  160000 | -        | -              | V100   | 25.45 | 26.15         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_coco-stuff164k-512x512.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r18-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211022_054328-046aa2f2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r18-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211022_054328.log.json)                                         |
-| BiSeNetV1 | R-18-D32                | 512x512   |  160000 | 6.33     | 74.24          | V100   | 28.55 | 29.26         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r18-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211023_013100-f700dbf7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r18-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211023_013100.log.json)     |
-| BiSeNetV1 | R-50-D32 (No Pretrain)  | 512x512   |  160000 | -        | -              | V100   | 29.82 | 30.33         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_coco-stuff164k-512x512.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r50-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_040616-d2bb0df4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r50-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_040616.log.json)                                         |
-| BiSeNetV1 | R-50-D32                | 512x512   |  160000 | 9.28     | 32.60          | V100   | 34.88 | 35.37         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r50-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_181932-66747911.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r50-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_181932.log.json)     |
-| BiSeNetV1 | R-101-D32 (No Pretrain) | 512x512   |  160000 | -        | -              | V100   | 31.14 | 31.76         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r101-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r101-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211102_164147-c6b32c3b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r101-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r101-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211102_164147.log.json)                                     |
-| BiSeNetV1 | R-101-D32               | 512x512   |  160000 | 10.36    | 25.25          | V100   | 37.38 | 37.99         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1/bisenetv1_r101-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r101-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r101-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_225220-28c8f092.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r101-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r101-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_225220.log.json) |
-
-Note:
-
-- `4x8`: Using 4 GPUs with 8 samples per GPU in training.
-- For BiSeNetV1 on Cityscapes dataset, default setting is 4 GPUs with 4 samples per GPU in training.
-- `No Pretrain` means the model is trained from scratch.
-
-## Citation
-
-```bibtex
-@inproceedings{yu2018bisenet,
-  title={Bisenet: Bilateral segmentation network for real-time semantic segmentation},
-  author={Yu, Changqian and Wang, Jingbo and Peng, Chao and Gao, Changxin and Yu, Gang and Sang, Nong},
-  booktitle={Proceedings of the European conference on computer vision (ECCV)},
-  pages={325--341},
-  year={2018}
-}
-```
diff --git a/mmsegmentation/configs/bisenetv1/bisenetv1_r101-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py b/mmsegmentation/configs/bisenetv1/bisenetv1_r101-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
deleted file mode 100644
index ac63447..0000000
--- a/mmsegmentation/configs/bisenetv1/bisenetv1_r101-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './bisenetv1_r101-d32_4xb4-160k_coco-stuff164k-512x512.py'
-model = dict(
-    backbone=dict(
-        backbone_cfg=dict(
-            init_cfg=dict(
-                type='Pretrained', checkpoint='open-mmlab://resnet101_v1c'))))
diff --git a/mmsegmentation/configs/bisenetv1/bisenetv1_r101-d32_4xb4-160k_coco-stuff164k-512x512.py b/mmsegmentation/configs/bisenetv1/bisenetv1_r101-d32_4xb4-160k_coco-stuff164k-512x512.py
deleted file mode 100644
index 02e4e9b..0000000
--- a/mmsegmentation/configs/bisenetv1/bisenetv1_r101-d32_4xb4-160k_coco-stuff164k-512x512.py
+++ /dev/null
@@ -1,58 +0,0 @@
-_base_ = [
-    '../_base_/models/bisenetv1_r18-d32.py',
-    '../_base_/datasets/coco-stuff164k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        context_channels=(512, 1024, 2048),
-        spatial_channels=(256, 256, 256, 512),
-        out_channels=1024,
-        backbone_cfg=dict(type='ResNet', depth=101)),
-    decode_head=dict(in_channels=1024, channels=1024, num_classes=171),
-    auxiliary_head=[
-        dict(
-            type='FCNHead',
-            in_channels=512,
-            channels=256,
-            num_convs=1,
-            num_classes=171,
-            in_index=1,
-            norm_cfg=norm_cfg,
-            concat_input=False,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-        dict(
-            type='FCNHead',
-            in_channels=512,
-            channels=256,
-            num_convs=1,
-            num_classes=171,
-            in_index=2,
-            norm_cfg=norm_cfg,
-            concat_input=False,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-    ])
-param_scheduler = [
-    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
-    dict(
-        type='PolyLR',
-        eta_min=1e-4,
-        power=0.9,
-        begin=1000,
-        end=160000,
-        by_epoch=False,
-    )
-]
-optimizer = dict(type='SGD', lr=0.005, momentum=0.9, weight_decay=0.0005)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
-train_dataloader = dict(batch_size=4, num_workers=4)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py
deleted file mode 100644
index da3e598..0000000
--- a/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py
+++ /dev/null
@@ -1,29 +0,0 @@
-_base_ = [
-    '../_base_/models/bisenetv1_r18-d32.py',
-    '../_base_/datasets/cityscapes_1024x1024.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (1024, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        backbone_cfg=dict(
-            init_cfg=dict(
-                type='Pretrained', checkpoint='open-mmlab://resnet18_v1c'))))
-param_scheduler = [
-    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
-    dict(
-        type='PolyLR',
-        eta_min=1e-4,
-        power=0.9,
-        begin=1000,
-        end=160000,
-        by_epoch=False,
-    )
-]
-optimizer = dict(type='SGD', lr=0.025, momentum=0.9, weight_decay=0.0005)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
-train_dataloader = dict(batch_size=4, num_workers=4)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py b/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
deleted file mode 100644
index 9de889f..0000000
--- a/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = './bisenetv1_r18-d32_4xb4-160k_coco-stuff164k-512x512.py'
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        backbone_cfg=dict(
-            init_cfg=dict(
-                type='Pretrained', checkpoint='open-mmlab://resnet18_v1c'))),
-)
diff --git a/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb8-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb8-160k_cityscapes-1024x1024.py
deleted file mode 100644
index 0580ce1..0000000
--- a/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb8-160k_cityscapes-1024x1024.py
+++ /dev/null
@@ -1,4 +0,0 @@
-_base_ = './bisenetv1_r18-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py'
-train_dataloader = dict(batch_size=8, num_workers=4)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_cityscapes-1024x1024.py
deleted file mode 100644
index 6c3e12b..0000000
--- a/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_cityscapes-1024x1024.py
+++ /dev/null
@@ -1,24 +0,0 @@
-_base_ = [
-    '../_base_/models/bisenetv1_r18-d32.py',
-    '../_base_/datasets/cityscapes_1024x1024.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (1024, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
-param_scheduler = [
-    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
-    dict(
-        type='PolyLR',
-        eta_min=1e-4,
-        power=0.9,
-        begin=1000,
-        end=160000,
-        by_epoch=False,
-    )
-]
-optimizer = dict(type='SGD', lr=0.025, momentum=0.9, weight_decay=0.0005)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
-train_dataloader = dict(batch_size=4, num_workers=4)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_coco-stuff164k-512x512.py b/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_coco-stuff164k-512x512.py
deleted file mode 100644
index 2109d68..0000000
--- a/mmsegmentation/configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_coco-stuff164k-512x512.py
+++ /dev/null
@@ -1,53 +0,0 @@
-_base_ = [
-    '../_base_/models/bisenetv1_r18-d32.py',
-    '../_base_/datasets/coco-stuff164k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=171),
-    auxiliary_head=[
-        dict(
-            type='FCNHead',
-            in_channels=128,
-            channels=64,
-            num_convs=1,
-            num_classes=171,
-            in_index=1,
-            norm_cfg=norm_cfg,
-            concat_input=False,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-        dict(
-            type='FCNHead',
-            in_channels=128,
-            channels=64,
-            num_convs=1,
-            num_classes=171,
-            in_index=2,
-            norm_cfg=norm_cfg,
-            concat_input=False,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-    ])
-param_scheduler = [
-    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
-    dict(
-        type='PolyLR',
-        eta_min=1e-4,
-        power=0.9,
-        begin=1000,
-        end=160000,
-        by_epoch=False,
-    )
-]
-optimizer = dict(type='SGD', lr=0.005, momentum=0.9, weight_decay=0.0005)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
-train_dataloader = dict(batch_size=4, num_workers=4)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py
deleted file mode 100644
index 013c4ff..0000000
--- a/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = './bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024.py'
-model = dict(
-    type='EncoderDecoder',
-    backbone=dict(
-        backbone_cfg=dict(
-            init_cfg=dict(
-                type='Pretrained', checkpoint='open-mmlab://resnet50_v1c'))))
diff --git a/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py b/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
deleted file mode 100644
index b35259c..0000000
--- a/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = './bisenetv1_r50-d32_4xb4-160k_coco-stuff164k-512x512.py'
-
-model = dict(
-    backbone=dict(
-        backbone_cfg=dict(
-            init_cfg=dict(
-                type='Pretrained', checkpoint='open-mmlab://resnet50_v1c'))))
diff --git a/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024.py
deleted file mode 100644
index 9753c10..0000000
--- a/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024.py
+++ /dev/null
@@ -1,55 +0,0 @@
-_base_ = [
-    '../_base_/models/bisenetv1_r18-d32.py',
-    '../_base_/datasets/cityscapes_1024x1024.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-crop_size = (1024, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        type='BiSeNetV1',
-        context_channels=(512, 1024, 2048),
-        spatial_channels=(256, 256, 256, 512),
-        out_channels=1024,
-        backbone_cfg=dict(type='ResNet', depth=50)),
-    decode_head=dict(
-        type='FCNHead', in_channels=1024, in_index=0, channels=1024),
-    auxiliary_head=[
-        dict(
-            type='FCNHead',
-            in_channels=512,
-            channels=256,
-            num_convs=1,
-            num_classes=19,
-            in_index=1,
-            norm_cfg=norm_cfg,
-            concat_input=False),
-        dict(
-            type='FCNHead',
-            in_channels=512,
-            channels=256,
-            num_convs=1,
-            num_classes=19,
-            in_index=2,
-            norm_cfg=norm_cfg,
-            concat_input=False),
-    ])
-param_scheduler = [
-    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
-    dict(
-        type='PolyLR',
-        eta_min=1e-4,
-        power=0.9,
-        begin=1000,
-        end=160000,
-        by_epoch=False,
-    )
-]
-optimizer = dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
-train_dataloader = dict(batch_size=4, num_workers=4)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_coco-stuff164k-512x512.py b/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_coco-stuff164k-512x512.py
deleted file mode 100644
index 8b6ef74..0000000
--- a/mmsegmentation/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_coco-stuff164k-512x512.py
+++ /dev/null
@@ -1,58 +0,0 @@
-_base_ = [
-    '../_base_/models/bisenetv1_r18-d32.py',
-    '../_base_/datasets/coco-stuff164k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        context_channels=(512, 1024, 2048),
-        spatial_channels=(256, 256, 256, 512),
-        out_channels=1024,
-        backbone_cfg=dict(type='ResNet', depth=50)),
-    decode_head=dict(in_channels=1024, channels=1024, num_classes=171),
-    auxiliary_head=[
-        dict(
-            type='FCNHead',
-            in_channels=512,
-            channels=256,
-            num_convs=1,
-            num_classes=171,
-            in_index=1,
-            norm_cfg=norm_cfg,
-            concat_input=False,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-        dict(
-            type='FCNHead',
-            in_channels=512,
-            channels=256,
-            num_convs=1,
-            num_classes=171,
-            in_index=2,
-            norm_cfg=norm_cfg,
-            concat_input=False,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-    ])
-param_scheduler = [
-    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
-    dict(
-        type='PolyLR',
-        eta_min=1e-4,
-        power=0.9,
-        begin=1000,
-        end=160000,
-        by_epoch=False,
-    )
-]
-optimizer = dict(type='SGD', lr=0.005, momentum=0.9, weight_decay=0.0005)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
-train_dataloader = dict(batch_size=4, num_workers=4)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/bisenetv1/metafile.yaml b/mmsegmentation/configs/bisenetv1/metafile.yaml
deleted file mode 100644
index e37f632..0000000
--- a/mmsegmentation/configs/bisenetv1/metafile.yaml
+++ /dev/null
@@ -1,275 +0,0 @@
-Collections:
-- Name: BiSeNetV1
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-    - COCO-Stuff 164k
-  Paper:
-    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
-    URL: https://arxiv.org/abs/1808.00897
-  README: configs/bisenetv1/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: bisenetv1_r18-d32_4xb4-160k_cityscapes-1024x1024
-  In Collection: BiSeNetV1
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 74.44
-      mIoU(ms+flip): 77.05
-  Config: configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_cityscapes-1024x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 16
-    Architecture:
-    - R-18-D32
-    - BiSeNetV1
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.69
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_4x4_1024x1024_160k_cityscapes/bisenetv1_r18-d32_4x4_1024x1024_160k_cityscapes_20210922_172239-c55e78e2.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_4x4_1024x1024_160k_cityscapes/bisenetv1_r18-d32_4x4_1024x1024_160k_cityscapes_20210922_172239.log.json
-  Paper:
-    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
-    URL: https://arxiv.org/abs/1808.00897
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266
-  Framework: PyTorch
-- Name: bisenetv1_r18-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024
-  In Collection: BiSeNetV1
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 74.37
-      mIoU(ms+flip): 76.91
-  Config: configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 16
-    Architecture:
-    - R-18-D32
-    - BiSeNetV1
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.69
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_4x4_1024x1024_160k_cityscapes/bisenetv1_r18-d32_in1k-pre_4x4_1024x1024_160k_cityscapes_20210905_220251-8ba80eff.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_4x4_1024x1024_160k_cityscapes/bisenetv1_r18-d32_in1k-pre_4x4_1024x1024_160k_cityscapes_20210905_220251.log.json
-  Paper:
-    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
-    URL: https://arxiv.org/abs/1808.00897
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266
-  Framework: PyTorch
-- Name: bisenetv1_r18-d32-in1k-pre_4xb8-160k_cityscapes-1024x1024
-  In Collection: BiSeNetV1
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 75.16
-      mIoU(ms+flip): 77.24
-  Config: configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb8-160k_cityscapes-1024x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 32
-    Architecture:
-    - R-18-D32
-    - BiSeNetV1
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 11.17
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_4x8_1024x1024_160k_cityscapes/bisenetv1_r18-d32_in1k-pre_4x8_1024x1024_160k_cityscapes_20210905_220322-bb8db75f.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_4x8_1024x1024_160k_cityscapes/bisenetv1_r18-d32_in1k-pre_4x8_1024x1024_160k_cityscapes_20210905_220322.log.json
-  Paper:
-    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
-    URL: https://arxiv.org/abs/1808.00897
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266
-  Framework: PyTorch
-- Name: bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024
-  In Collection: BiSeNetV1
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.92
-      mIoU(ms+flip): 78.87
-  Config: configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 16
-    Architecture:
-    - R-50-D32
-    - BiSeNetV1
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 15.39
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_4x4_1024x1024_160k_cityscapes/bisenetv1_r50-d32_4x4_1024x1024_160k_cityscapes_20210923_222639-7b28a2a6.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_4x4_1024x1024_160k_cityscapes/bisenetv1_r50-d32_4x4_1024x1024_160k_cityscapes_20210923_222639.log.json
-  Paper:
-    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
-    URL: https://arxiv.org/abs/1808.00897
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266
-  Framework: PyTorch
-- Name: bisenetv1_r50-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024
-  In Collection: BiSeNetV1
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.68
-      mIoU(ms+flip): 79.57
-  Config: configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_cityscapes-1024x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 16
-    Architecture:
-    - R-50-D32
-    - BiSeNetV1
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 15.39
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_in1k-pre_4x4_1024x1024_160k_cityscapes/bisenetv1_r50-d32_in1k-pre_4x4_1024x1024_160k_cityscapes_20210917_234628-8b304447.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_in1k-pre_4x4_1024x1024_160k_cityscapes/bisenetv1_r50-d32_in1k-pre_4x4_1024x1024_160k_cityscapes_20210917_234628.log.json
-  Paper:
-    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
-    URL: https://arxiv.org/abs/1808.00897
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266
-  Framework: PyTorch
-- Name: bisenetv1_r18-d32_4xb4-160k_coco-stuff164k-512x512
-  In Collection: BiSeNetV1
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 164k
-    Metrics:
-      mIoU: 25.45
-      mIoU(ms+flip): 26.15
-  Config: configs/bisenetv1/bisenetv1_r18-d32_4xb4-160k_coco-stuff164k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 164k
-    Batch Size: 16
-    Architecture:
-    - R-18-D32
-    - BiSeNetV1
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r18-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211022_054328-046aa2f2.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r18-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211022_054328.log.json
-  Paper:
-    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
-    URL: https://arxiv.org/abs/1808.00897
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266
-  Framework: PyTorch
-- Name: bisenetv1_r18-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512
-  In Collection: BiSeNetV1
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 164k
-    Metrics:
-      mIoU: 28.55
-      mIoU(ms+flip): 29.26
-  Config: configs/bisenetv1/bisenetv1_r18-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 164k
-    Batch Size: 16
-    Architecture:
-    - R-18-D32
-    - BiSeNetV1
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.33
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r18-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211023_013100-f700dbf7.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r18-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r18-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211023_013100.log.json
-  Paper:
-    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
-    URL: https://arxiv.org/abs/1808.00897
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266
-  Framework: PyTorch
-- Name: bisenetv1_r50-d32_4xb4-160k_coco-stuff164k-512x512
-  In Collection: BiSeNetV1
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 164k
-    Metrics:
-      mIoU: 29.82
-      mIoU(ms+flip): 30.33
-  Config: configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_coco-stuff164k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 164k
-    Batch Size: 16
-    Architecture:
-    - R-50-D32
-    - BiSeNetV1
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r50-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_040616-d2bb0df4.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r50-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_040616.log.json
-  Paper:
-    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
-    URL: https://arxiv.org/abs/1808.00897
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266
-  Framework: PyTorch
-- Name: bisenetv1_r50-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512
-  In Collection: BiSeNetV1
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 164k
-    Metrics:
-      mIoU: 34.88
-      mIoU(ms+flip): 35.37
-  Config: configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 164k
-    Batch Size: 16
-    Architecture:
-    - R-50-D32
-    - BiSeNetV1
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.28
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r50-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_181932-66747911.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r50-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r50-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_181932.log.json
-  Paper:
-    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
-    URL: https://arxiv.org/abs/1808.00897
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266
-  Framework: PyTorch
-- Name: bisenetv1_r50-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512
-  In Collection: BiSeNetV1
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 164k
-    Metrics:
-      mIoU: 31.14
-      mIoU(ms+flip): 31.76
-  Config: configs/bisenetv1/bisenetv1_r50-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 164k
-    Batch Size: 16
-    Architecture:
-    - R-101-D32
-    - BiSeNetV1
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r101-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r101-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211102_164147-c6b32c3b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r101-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r101-d32_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211102_164147.log.json
-  Paper:
-    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
-    URL: https://arxiv.org/abs/1808.00897
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266
-  Framework: PyTorch
-- Name: bisenetv1_r101-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512
-  In Collection: BiSeNetV1
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 164k
-    Metrics:
-      mIoU: 37.38
-      mIoU(ms+flip): 37.99
-  Config: configs/bisenetv1/bisenetv1_r101-d32-in1k-pre_4xb4-160k_coco-stuff164k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 164k
-    Batch Size: 16
-    Architecture:
-    - R-101-D32
-    - BiSeNetV1
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.36
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r101-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r101-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_225220-28c8f092.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv1/bisenetv1_r101-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k/bisenetv1_r101-d32_in1k-pre_lr5e-3_4x4_512x512_160k_coco-stuff164k_20211101_225220.log.json
-  Paper:
-    Title: 'BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation'
-    URL: https://arxiv.org/abs/1808.00897
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv1.py#L266
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/bisenetv2/README.md b/mmsegmentation/configs/bisenetv2/README.md
deleted file mode 100644
index a5871df..0000000
--- a/mmsegmentation/configs/bisenetv2/README.md
+++ /dev/null
@@ -1,53 +0,0 @@
-# BiSeNetV2
-
-> [Bisenet v2: Bilateral Network with Guided Aggregation for Real-time Semantic Segmentation](https://arxiv.org/abs/2004.02147)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv2.py#L545">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-The low-level details and high-level semantics are both essential to the semantic segmentation task. However, to speed up the model inference, current approaches almost always sacrifice the low-level details, which leads to a considerable accuracy decrease. We propose to treat these spatial details and categorical semantics separately to achieve high accuracy and high efficiency for realtime semantic segmentation. To this end, we propose an efficient and effective architecture with a good trade-off between speed and accuracy, termed Bilateral Segmentation Network (BiSeNet V2). This architecture involves: (i) a Detail Branch, with wide channels and shallow layers to capture low-level details and generate high-resolution feature representation; (ii) a Semantic Branch, with narrow channels and deep layers to obtain high-level semantic context. The Semantic Branch is lightweight due to reducing the channel capacity and a fast-downsampling strategy. Furthermore, we design a Guided Aggregation Layer to enhance mutual connections and fuse both types of feature representation. Besides, a booster training strategy is designed to improve the segmentation performance without any extra inference cost. Extensive quantitative and qualitative evaluations demonstrate that the proposed architecture performs favourably against a few state-of-the-art real-time semantic segmentation approaches. Specifically, for a 2,048x1,024 input, we achieve 72.6% Mean IoU on the Cityscapes test set with a speed of 156 FPS on one NVIDIA GeForce GTX 1080 Ti card, which is significantly faster than existing methods, yet we achieve better segmentation accuracy.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142898966-ec4a81da-b4b0-41ee-b083-1d964582c18a.png" width="70%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method    | Backbone         | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                  | download                                                                                                                                                                                                                                                                                                                                                                                               |
-| --------- | ---------------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | --------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| BiSeNetV2 | BiSeNetV2        | 1024x1024 |  160000 | 7.64     | 31.77          | V100   | 73.21 |         75.74 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv2/bisenetv2_fcn_4xb4-160k_cityscapes-1024x1024.py)      | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_4x4_1024x1024_160k_cityscapes_20210902_015551-bcf10f09.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_4x4_1024x1024_160k_cityscapes_20210902_015551.log.json)                     |
-| BiSeNetV2 | BiSeNetV2 (OHEM) | 1024x1024 |  160000 | 7.64     | -              | V100   | 73.57 |         75.80 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv2/bisenetv2_fcn_4xb4-ohem-160k_cityscapes-1024x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_ohem_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_ohem_4x4_1024x1024_160k_cityscapes_20210902_112947-5f8103b4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_ohem_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_ohem_4x4_1024x1024_160k_cityscapes_20210902_112947.log.json) |
-| BiSeNetV2 | BiSeNetV2 (4x8)  | 1024x1024 |  160000 | 15.05    | -              | V100   | 75.76 |         77.79 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv2/bisenetv2_fcn_4xb8-160k_cityscapes-1024x1024.py)      | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_4x8_1024x1024_160k_cityscapes/bisenetv2_fcn_4x8_1024x1024_160k_cityscapes_20210903_000032-e1a2eed6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_4x8_1024x1024_160k_cityscapes/bisenetv2_fcn_4x8_1024x1024_160k_cityscapes_20210903_000032.log.json)                     |
-| BiSeNetV2 | BiSeNetV2 (FP16) | 1024x1024 |  160000 | 5.77     | 36.65          | V100   | 73.07 |         75.13 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv2/bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_fp16_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_fp16_4x4_1024x1024_160k_cityscapes_20210902_045942-b979777b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_fp16_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_fp16_4x4_1024x1024_160k_cityscapes_20210902_045942.log.json) |
-
-Note:
-
-- `OHEM` means Online Hard Example Mining (OHEM) is adopted in training.
-- `FP16` means Mixed Precision (FP16) is adopted in training.
-- `4x8` means 4 GPUs with 8 samples per GPU in training.
-
-## Citation
-
-```bibtex
-@article{yu2021bisenet,
-  title={Bisenet v2: Bilateral network with guided aggregation for real-time semantic segmentation},
-  author={Yu, Changqian and Gao, Changxin and Wang, Jingbo and Yu, Gang and Shen, Chunhua and Sang, Nong},
-  journal={International Journal of Computer Vision},
-  pages={1--18},
-  year={2021},
-  publisher={Springer}
-}
-```
diff --git a/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-160k_cityscapes-1024x1024.py
deleted file mode 100644
index 6462ce7..0000000
--- a/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-160k_cityscapes-1024x1024.py
+++ /dev/null
@@ -1,24 +0,0 @@
-_base_ = [
-    '../_base_/models/bisenetv2.py',
-    '../_base_/datasets/cityscapes_1024x1024.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (1024, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
-param_scheduler = [
-    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
-    dict(
-        type='PolyLR',
-        eta_min=1e-4,
-        power=0.9,
-        begin=1000,
-        end=160000,
-        by_epoch=False,
-    )
-]
-optimizer = dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
-train_dataloader = dict(batch_size=4, num_workers=4)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024.py
deleted file mode 100644
index 8ed338c..0000000
--- a/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './bisenetv2_fcn_4xb4-160k_cityscapes-1024x1024.py'
-optim_wrapper = dict(
-    _delete_=True,
-    type='AmpOptimWrapper',
-    optimizer=dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005),
-    loss_scale=512.)
diff --git a/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-ohem-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-ohem-160k_cityscapes-1024x1024.py
deleted file mode 100644
index 8d5cbcb..0000000
--- a/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb4-ohem-160k_cityscapes-1024x1024.py
+++ /dev/null
@@ -1,83 +0,0 @@
-_base_ = [
-    '../_base_/models/bisenetv2.py',
-    '../_base_/datasets/cityscapes_1024x1024.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (1024, 1024)
-data_preprocessor = dict(size=crop_size)
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-models = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(
-        sampler=dict(type='OHEMPixelSampler', thresh=0.7, min_kept=10000)),
-    auxiliary_head=[
-        dict(
-            type='FCNHead',
-            in_channels=16,
-            channels=16,
-            num_convs=2,
-            num_classes=19,
-            in_index=1,
-            norm_cfg=norm_cfg,
-            concat_input=False,
-            align_corners=False,
-            sampler=dict(type='OHEMPixelSampler', thresh=0.7, min_kept=10000),
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-        dict(
-            type='FCNHead',
-            in_channels=32,
-            channels=64,
-            num_convs=2,
-            num_classes=19,
-            in_index=2,
-            norm_cfg=norm_cfg,
-            concat_input=False,
-            align_corners=False,
-            sampler=dict(type='OHEMPixelSampler', thresh=0.7, min_kept=10000),
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-        dict(
-            type='FCNHead',
-            in_channels=64,
-            channels=256,
-            num_convs=2,
-            num_classes=19,
-            in_index=3,
-            norm_cfg=norm_cfg,
-            concat_input=False,
-            align_corners=False,
-            sampler=dict(type='OHEMPixelSampler', thresh=0.7, min_kept=10000),
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-        dict(
-            type='FCNHead',
-            in_channels=128,
-            channels=1024,
-            num_convs=2,
-            num_classes=19,
-            in_index=4,
-            norm_cfg=norm_cfg,
-            concat_input=False,
-            align_corners=False,
-            sampler=dict(type='OHEMPixelSampler', thresh=0.7, min_kept=10000),
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-    ],
-)
-param_scheduler = [
-    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
-    dict(
-        type='PolyLR',
-        eta_min=1e-4,
-        power=0.9,
-        begin=1000,
-        end=160000,
-        by_epoch=False,
-    )
-]
-optimizer = dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
-train_dataloader = dict(batch_size=4, num_workers=4)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb8-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb8-160k_cityscapes-1024x1024.py
deleted file mode 100644
index 8fcba64..0000000
--- a/mmsegmentation/configs/bisenetv2/bisenetv2_fcn_4xb8-160k_cityscapes-1024x1024.py
+++ /dev/null
@@ -1,24 +0,0 @@
-_base_ = [
-    '../_base_/models/bisenetv2.py',
-    '../_base_/datasets/cityscapes_1024x1024.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (1024, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
-param_scheduler = [
-    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
-    dict(
-        type='PolyLR',
-        eta_min=1e-4,
-        power=0.9,
-        begin=1000,
-        end=160000,
-        by_epoch=False,
-    )
-]
-optimizer = dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
-train_dataloader = dict(batch_size=8, num_workers=4)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/bisenetv2/metafile.yaml b/mmsegmentation/configs/bisenetv2/metafile.yaml
deleted file mode 100644
index 5430ec3..0000000
--- a/mmsegmentation/configs/bisenetv2/metafile.yaml
+++ /dev/null
@@ -1,114 +0,0 @@
-Collections:
-- Name: BiSeNetV2
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-  Paper:
-    Title: 'Bisenet v2: Bilateral Network with Guided Aggregation for Real-time Semantic
-      Segmentation'
-    URL: https://arxiv.org/abs/2004.02147
-  README: configs/bisenetv2/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: bisenetv2_fcn_4xb4-160k_cityscapes-1024x1024
-  In Collection: BiSeNetV2
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 73.21
-      mIoU(ms+flip): 75.74
-  Config: configs/bisenetv2/bisenetv2_fcn_4xb4-160k_cityscapes-1024x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 16
-    Architecture:
-    - BiSeNetV2
-    - BiSeNetV2
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 7.64
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_4x4_1024x1024_160k_cityscapes_20210902_015551-bcf10f09.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_4x4_1024x1024_160k_cityscapes_20210902_015551.log.json
-  Paper:
-    Title: 'Bisenet v2: Bilateral Network with Guided Aggregation for Real-time Semantic
-      Segmentation'
-    URL: https://arxiv.org/abs/2004.02147
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv2.py#L545
-  Framework: PyTorch
-- Name: bisenetv2_fcn_4xb4-ohem-160k_cityscapes-1024x1024
-  In Collection: BiSeNetV2
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 73.57
-      mIoU(ms+flip): 75.8
-  Config: configs/bisenetv2/bisenetv2_fcn_4xb4-ohem-160k_cityscapes-1024x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 16
-    Architecture:
-    - BiSeNetV2
-    - BiSeNetV2
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 7.64
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_ohem_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_ohem_4x4_1024x1024_160k_cityscapes_20210902_112947-5f8103b4.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_ohem_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_ohem_4x4_1024x1024_160k_cityscapes_20210902_112947.log.json
-  Paper:
-    Title: 'Bisenet v2: Bilateral Network with Guided Aggregation for Real-time Semantic
-      Segmentation'
-    URL: https://arxiv.org/abs/2004.02147
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv2.py#L545
-  Framework: PyTorch
-- Name: bisenetv2_fcn_4xb8-160k_cityscapes-1024x1024
-  In Collection: BiSeNetV2
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 75.76
-      mIoU(ms+flip): 77.79
-  Config: configs/bisenetv2/bisenetv2_fcn_4xb8-160k_cityscapes-1024x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 32
-    Architecture:
-    - BiSeNetV2
-    - BiSeNetV2
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 15.05
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_4x8_1024x1024_160k_cityscapes/bisenetv2_fcn_4x8_1024x1024_160k_cityscapes_20210903_000032-e1a2eed6.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_4x8_1024x1024_160k_cityscapes/bisenetv2_fcn_4x8_1024x1024_160k_cityscapes_20210903_000032.log.json
-  Paper:
-    Title: 'Bisenet v2: Bilateral Network with Guided Aggregation for Real-time Semantic
-      Segmentation'
-    URL: https://arxiv.org/abs/2004.02147
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv2.py#L545
-  Framework: PyTorch
-- Name: bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024
-  In Collection: BiSeNetV2
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 73.07
-      mIoU(ms+flip): 75.13
-  Config: configs/bisenetv2/bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 16
-    Architecture:
-    - BiSeNetV2
-    - BiSeNetV2
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.77
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_fp16_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_fp16_4x4_1024x1024_160k_cityscapes_20210902_045942-b979777b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/bisenetv2/bisenetv2_fcn_fp16_4x4_1024x1024_160k_cityscapes/bisenetv2_fcn_fp16_4x4_1024x1024_160k_cityscapes_20210902_045942.log.json
-  Paper:
-    Title: 'Bisenet v2: Bilateral Network with Guided Aggregation for Real-time Semantic
-      Segmentation'
-    URL: https://arxiv.org/abs/2004.02147
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/backbones/bisenetv2.py#L545
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/ccnet/README.md b/mmsegmentation/configs/ccnet/README.md
deleted file mode 100644
index 64dd5f0..0000000
--- a/mmsegmentation/configs/ccnet/README.md
+++ /dev/null
@@ -1,67 +0,0 @@
-# CCNet
-
-> [CCNet: Criss-Cross Attention for Semantic Segmentation](https://arxiv.org/abs/1811.11721)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/speedinghzl/CCNet">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Contextual information is vital in visual understanding problems, such as semantic segmentation and object detection. We propose a Criss-Cross Network (CCNet) for obtaining full-image contextual information in a very effective and efficient way. Concretely, for each pixel, a novel criss-cross attention module harvests the contextual information of all the pixels on its criss-cross path. By taking a further recurrent operation, each pixel can finally capture the full-image dependencies. Besides, a category consistent loss is proposed to enforce the criss-cross attention module to produce more discriminative features. Overall, CCNet is with the following merits: 1) GPU memory friendly. Compared with the non-local block, the proposed recurrent criss-cross attention module requires 11x less GPU memory usage. 2) High computational efficiency. The recurrent criss-cross attention significantly reduces FLOPs by about 85% of the non-local block. 3) The state-of-the-art performance. We conduct extensive experiments on semantic segmentation benchmarks including Cityscapes, ADE20K, human parsing benchmark LIP, instance segmentation benchmark COCO, video segmentation benchmark CamVid. In particular, our CCNet achieves the mIoU scores of 81.9%, 45.76% and 55.47% on the Cityscapes test set, the ADE20K validation set and the LIP validation set respectively, which are the new state-of-the-art results. The source codes are available at [this https URL](https://github.com/speedinghzl/CCNet).
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142899159-b329c12a-0fde-44df-8718-def6cfb004e4.png" width="70%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                       | download                                                                                                                                                                                                                                                                                                                                           |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ---------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| CCNet  | R-50-D8  | 512x1024  |   40000 | 6        | 3.32           | V100   | 77.76 |         78.87 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x1024_40k_cityscapes/ccnet_r50-d8_512x1024_40k_cityscapes_20200616_142517-4123f401.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x1024_40k_cityscapes/ccnet_r50-d8_512x1024_40k_cityscapes_20200616_142517.log.json)     |
-| CCNet  | R-101-D8 | 512x1024  |   40000 | 9.5      | 2.31           | V100   | 76.35 |         78.19 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x1024_40k_cityscapes/ccnet_r101-d8_512x1024_40k_cityscapes_20200616_142540-a3b84ba6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x1024_40k_cityscapes/ccnet_r101-d8_512x1024_40k_cityscapes_20200616_142540.log.json) |
-| CCNet  | R-50-D8  | 769x769   |   40000 | 6.8      | 1.43           | V100   | 78.46 |         79.93 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_769x769_40k_cityscapes/ccnet_r50-d8_769x769_40k_cityscapes_20200616_145125-76d11884.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_769x769_40k_cityscapes/ccnet_r50-d8_769x769_40k_cityscapes_20200616_145125.log.json)         |
-| CCNet  | R-101-D8 | 769x769   |   40000 | 10.7     | 1.01           | V100   | 76.94 |         78.62 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_769x769_40k_cityscapes/ccnet_r101-d8_769x769_40k_cityscapes_20200617_101428-4f57c8d0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_769x769_40k_cityscapes/ccnet_r101-d8_769x769_40k_cityscapes_20200617_101428.log.json)     |
-| CCNet  | R-50-D8  | 512x1024  |   80000 | -        | -              | V100   | 79.03 |         80.16 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x1024_80k_cityscapes/ccnet_r50-d8_512x1024_80k_cityscapes_20200617_010421-869a3423.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x1024_80k_cityscapes/ccnet_r50-d8_512x1024_80k_cityscapes_20200617_010421.log.json)     |
-| CCNet  | R-101-D8 | 512x1024  |   80000 | -        | -              | V100   | 78.87 |         79.90 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x1024_80k_cityscapes/ccnet_r101-d8_512x1024_80k_cityscapes_20200617_203935-ffae8917.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x1024_80k_cityscapes/ccnet_r101-d8_512x1024_80k_cityscapes_20200617_203935.log.json) |
-| CCNet  | R-50-D8  | 769x769   |   80000 | -        | -              | V100   | 79.29 |         81.08 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_769x769_80k_cityscapes/ccnet_r50-d8_769x769_80k_cityscapes_20200617_010421-73eed8ca.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_769x769_80k_cityscapes/ccnet_r50-d8_769x769_80k_cityscapes_20200617_010421.log.json)         |
-| CCNet  | R-101-D8 | 769x769   |   80000 | -        | -              | V100   | 79.45 |         80.66 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_769x769_80k_cityscapes/ccnet_r101-d8_769x769_80k_cityscapes_20200618_011502-ad3cd481.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_769x769_80k_cityscapes/ccnet_r101-d8_769x769_80k_cityscapes_20200618_011502.log.json)     |
-
-### ADE20K
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                   | download                                                                                                                                                                                                                                                                                                                           |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| CCNet  | R-50-D8  | 512x512   |   80000 | 8.8      | 20.89          | V100   | 41.78 |         42.98 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_80k_ade20k/ccnet_r50-d8_512x512_80k_ade20k_20200615_014848-aa37f61e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_80k_ade20k/ccnet_r50-d8_512x512_80k_ade20k_20200615_014848.log.json)         |
-| CCNet  | R-101-D8 | 512x512   |   80000 | 12.2     | 14.11          | V100   | 43.97 |         45.13 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_80k_ade20k/ccnet_r101-d8_512x512_80k_ade20k_20200615_014848-1f4929a3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_80k_ade20k/ccnet_r101-d8_512x512_80k_ade20k_20200615_014848.log.json)     |
-| CCNet  | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 42.08 |         43.13 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_160k_ade20k/ccnet_r50-d8_512x512_160k_ade20k_20200616_084435-7c97193b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_160k_ade20k/ccnet_r50-d8_512x512_160k_ade20k_20200616_084435.log.json)     |
-| CCNet  | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 43.71 |         45.04 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_160k_ade20k/ccnet_r101-d8_512x512_160k_ade20k_20200616_000644-e849e007.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_160k_ade20k/ccnet_r101-d8_512x512_160k_ade20k_20200616_000644.log.json) |
-
-### Pascal VOC 2012 + Aug
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                    | download                                                                                                                                                                                                                                                                                                                               |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| CCNet  | R-50-D8  | 512x512   |   20000 | 6        | 20.45          | V100   | 76.17 |         77.51 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r50-d8_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_20k_voc12aug/ccnet_r50-d8_512x512_20k_voc12aug_20200617_193212-fad81784.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_20k_voc12aug/ccnet_r50-d8_512x512_20k_voc12aug_20200617_193212.log.json)     |
-| CCNet  | R-101-D8 | 512x512   |   20000 | 9.5      | 13.64          | V100   | 77.27 |         79.02 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r101-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_20k_voc12aug/ccnet_r101-d8_512x512_20k_voc12aug_20200617_193212-0007b61d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_20k_voc12aug/ccnet_r101-d8_512x512_20k_voc12aug_20200617_193212.log.json) |
-| CCNet  | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 75.96 |         77.04 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r50-d8_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_40k_voc12aug/ccnet_r50-d8_512x512_40k_voc12aug_20200613_232127-c2a15f02.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_40k_voc12aug/ccnet_r50-d8_512x512_40k_voc12aug_20200613_232127.log.json)     |
-| CCNet  | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 77.87 |         78.90 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet/ccnet_r101-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_40k_voc12aug/ccnet_r101-d8_512x512_40k_voc12aug_20200613_232127-c30da577.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_40k_voc12aug/ccnet_r101-d8_512x512_40k_voc12aug_20200613_232127.log.json) |
-
-## Citation
-
-```bibtex
-@article{huang2018ccnet,
-    title={CCNet: Criss-Cross Attention for Semantic Segmentation},
-    author={Huang, Zilong and Wang, Xinggang and Huang, Lichao and Huang, Chang and Wei, Yunchao and Liu, Wenyu},
-    booktitle={ICCV},
-    year={2019}
-}
-```
diff --git a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 0c49e1e..0000000
--- a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './ccnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index f24f5a7..0000000
--- a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './ccnet_r50-d8_4xb2-40k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index b358e12..0000000
--- a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './ccnet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 7575076..0000000
--- a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './ccnet_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index a29d118..0000000
--- a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './ccnet_r50-d8_4xb4-160k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index fd421a2..0000000
--- a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './ccnet_r50-d8_4xb4-20k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index 425dfcf..0000000
--- a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './ccnet_r50-d8_4xb4-40k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index f6dcb9c..0000000
--- a/mmsegmentation/configs/ccnet/ccnet_r101-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './ccnet_r50-d8_4xb4-80k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 84fc51a..0000000
--- a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/ccnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index a930794..0000000
--- a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/ccnet_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 89bfe81..0000000
--- a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/ccnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 5f7c954..0000000
--- a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/ccnet_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index cee810c..0000000
--- a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/ccnet_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index 76a90d9..0000000
--- a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/ccnet_r50-d8.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_20k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index a8aeb85..0000000
--- a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/ccnet_r50-d8.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index f7fced0..0000000
--- a/mmsegmentation/configs/ccnet/ccnet_r50-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/ccnet_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/ccnet/metafile.yaml b/mmsegmentation/configs/ccnet/metafile.yaml
deleted file mode 100644
index 62e5694..0000000
--- a/mmsegmentation/configs/ccnet/metafile.yaml
+++ /dev/null
@@ -1,391 +0,0 @@
-Collections:
-- Name: CCNet
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-    - ADE20K
-    - Pascal VOC 2012 + Aug
-  Paper:
-    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1811.11721
-  README: configs/ccnet/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: ccnet_r50-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: CCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.76
-      mIoU(ms+flip): 78.87
-  Config: configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - CCNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x1024_40k_cityscapes/ccnet_r50-d8_512x1024_40k_cityscapes_20200616_142517-4123f401.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x1024_40k_cityscapes/ccnet_r50-d8_512x1024_40k_cityscapes_20200616_142517.log.json
-  Paper:
-    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1811.11721
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: ccnet_r101-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: CCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.35
-      mIoU(ms+flip): 78.19
-  Config: configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - CCNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x1024_40k_cityscapes/ccnet_r101-d8_512x1024_40k_cityscapes_20200616_142540-a3b84ba6.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x1024_40k_cityscapes/ccnet_r101-d8_512x1024_40k_cityscapes_20200616_142540.log.json
-  Paper:
-    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1811.11721
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: ccnet_r50-d8_4xb2-40k_cityscapes-769x769
-  In Collection: CCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.46
-      mIoU(ms+flip): 79.93
-  Config: configs/ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - CCNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_769x769_40k_cityscapes/ccnet_r50-d8_769x769_40k_cityscapes_20200616_145125-76d11884.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_769x769_40k_cityscapes/ccnet_r50-d8_769x769_40k_cityscapes_20200616_145125.log.json
-  Paper:
-    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1811.11721
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: ccnet_r101-d8_4xb2-40k_cityscapes-769x769
-  In Collection: CCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.94
-      mIoU(ms+flip): 78.62
-  Config: configs/ccnet/ccnet_r101-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - CCNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.7
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_769x769_40k_cityscapes/ccnet_r101-d8_769x769_40k_cityscapes_20200617_101428-4f57c8d0.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_769x769_40k_cityscapes/ccnet_r101-d8_769x769_40k_cityscapes_20200617_101428.log.json
-  Paper:
-    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1811.11721
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: ccnet_r50-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: CCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.03
-      mIoU(ms+flip): 80.16
-  Config: configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - CCNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x1024_80k_cityscapes/ccnet_r50-d8_512x1024_80k_cityscapes_20200617_010421-869a3423.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x1024_80k_cityscapes/ccnet_r50-d8_512x1024_80k_cityscapes_20200617_010421.log.json
-  Paper:
-    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1811.11721
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: ccnet_r101-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: CCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.87
-      mIoU(ms+flip): 79.9
-  Config: configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - CCNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x1024_80k_cityscapes/ccnet_r101-d8_512x1024_80k_cityscapes_20200617_203935-ffae8917.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x1024_80k_cityscapes/ccnet_r101-d8_512x1024_80k_cityscapes_20200617_203935.log.json
-  Paper:
-    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1811.11721
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: ccnet_r50-d8_4xb2-80k_cityscapes-769x769
-  In Collection: CCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.29
-      mIoU(ms+flip): 81.08
-  Config: configs/ccnet/ccnet_r50-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - CCNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_769x769_80k_cityscapes/ccnet_r50-d8_769x769_80k_cityscapes_20200617_010421-73eed8ca.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_769x769_80k_cityscapes/ccnet_r50-d8_769x769_80k_cityscapes_20200617_010421.log.json
-  Paper:
-    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1811.11721
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: ccnet_r101-d8_4xb2-80k_cityscapes-769x769
-  In Collection: CCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.45
-      mIoU(ms+flip): 80.66
-  Config: configs/ccnet/ccnet_r101-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - CCNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_769x769_80k_cityscapes/ccnet_r101-d8_769x769_80k_cityscapes_20200618_011502-ad3cd481.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_769x769_80k_cityscapes/ccnet_r101-d8_769x769_80k_cityscapes_20200618_011502.log.json
-  Paper:
-    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1811.11721
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: ccnet_r50-d8_4xb4-80k_ade20k-512x512
-  In Collection: CCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 41.78
-      mIoU(ms+flip): 42.98
-  Config: configs/ccnet/ccnet_r50-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - CCNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_80k_ade20k/ccnet_r50-d8_512x512_80k_ade20k_20200615_014848-aa37f61e.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_80k_ade20k/ccnet_r50-d8_512x512_80k_ade20k_20200615_014848.log.json
-  Paper:
-    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1811.11721
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: ccnet_r101-d8_4xb4-80k_ade20k-512x512
-  In Collection: CCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 43.97
-      mIoU(ms+flip): 45.13
-  Config: configs/ccnet/ccnet_r101-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - CCNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 12.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_80k_ade20k/ccnet_r101-d8_512x512_80k_ade20k_20200615_014848-1f4929a3.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_80k_ade20k/ccnet_r101-d8_512x512_80k_ade20k_20200615_014848.log.json
-  Paper:
-    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1811.11721
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: ccnet_r50-d8_4xb4-160k_ade20k-512x512
-  In Collection: CCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.08
-      mIoU(ms+flip): 43.13
-  Config: configs/ccnet/ccnet_r50-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - CCNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_160k_ade20k/ccnet_r50-d8_512x512_160k_ade20k_20200616_084435-7c97193b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_160k_ade20k/ccnet_r50-d8_512x512_160k_ade20k_20200616_084435.log.json
-  Paper:
-    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1811.11721
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: ccnet_r101-d8_4xb4-160k_ade20k-512x512
-  In Collection: CCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 43.71
-      mIoU(ms+flip): 45.04
-  Config: configs/ccnet/ccnet_r101-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - CCNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_160k_ade20k/ccnet_r101-d8_512x512_160k_ade20k_20200616_000644-e849e007.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_160k_ade20k/ccnet_r101-d8_512x512_160k_ade20k_20200616_000644.log.json
-  Paper:
-    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1811.11721
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: ccnet_r50-d8_4xb4-20k_voc12aug-512x512
-  In Collection: CCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 76.17
-      mIoU(ms+flip): 77.51
-  Config: configs/ccnet/ccnet_r50-d8_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - CCNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_20k_voc12aug/ccnet_r50-d8_512x512_20k_voc12aug_20200617_193212-fad81784.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_20k_voc12aug/ccnet_r50-d8_512x512_20k_voc12aug_20200617_193212.log.json
-  Paper:
-    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1811.11721
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: ccnet_r101-d8_4xb4-20k_voc12aug-512x512
-  In Collection: CCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 77.27
-      mIoU(ms+flip): 79.02
-  Config: configs/ccnet/ccnet_r101-d8_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - CCNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_20k_voc12aug/ccnet_r101-d8_512x512_20k_voc12aug_20200617_193212-0007b61d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_20k_voc12aug/ccnet_r101-d8_512x512_20k_voc12aug_20200617_193212.log.json
-  Paper:
-    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1811.11721
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: ccnet_r50-d8_4xb4-40k_voc12aug-512x512
-  In Collection: CCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 75.96
-      mIoU(ms+flip): 77.04
-  Config: configs/ccnet/ccnet_r50-d8_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - CCNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_40k_voc12aug/ccnet_r50-d8_512x512_40k_voc12aug_20200613_232127-c2a15f02.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r50-d8_512x512_40k_voc12aug/ccnet_r50-d8_512x512_40k_voc12aug_20200613_232127.log.json
-  Paper:
-    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1811.11721
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
-- Name: ccnet_r101-d8_4xb4-40k_voc12aug-512x512
-  In Collection: CCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 77.87
-      mIoU(ms+flip): 78.9
-  Config: configs/ccnet/ccnet_r101-d8_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - CCNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_40k_voc12aug/ccnet_r101-d8_512x512_40k_voc12aug_20200613_232127-c30da577.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ccnet/ccnet_r101-d8_512x512_40k_voc12aug/ccnet_r101-d8_512x512_40k_voc12aug_20200613_232127.log.json
-  Paper:
-    Title: 'CCNet: Criss-Cross Attention for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1811.11721
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/apc_head.py#L111
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/cgnet/README.md b/mmsegmentation/configs/cgnet/README.md
deleted file mode 100644
index 96c9fcf..0000000
--- a/mmsegmentation/configs/cgnet/README.md
+++ /dev/null
@@ -1,46 +0,0 @@
-# CGNet
-
-> [CGNet: A Light-weight Context Guided Network for Semantic Segmentation](https://arxiv.org/abs/1811.08201)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/wutianyiRosun/CGNet">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/cgnet.py#L187">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-The demand of applying semantic segmentation model on mobile devices has been increasing rapidly. Current state-of-the-art networks have enormous amount of parameters hence unsuitable for mobile devices, while other small memory footprint models follow the spirit of classification network and ignore the inherent characteristic of semantic segmentation. To tackle this problem, we propose a novel Context Guided Network (CGNet), which is a light-weight and efficient network for semantic segmentation. We first propose the Context Guided (CG) block, which learns the joint feature of both local feature and surrounding context, and further improves the joint feature with the global context. Based on the CG block, we develop CGNet which captures contextual information in all stages of the network and is specially tailored for increasing segmentation accuracy. CGNet is also elaborately designed to reduce the number of parameters and save memory footprint. Under an equivalent number of parameters, the proposed CGNet significantly outperforms existing segmentation networks. Extensive experiments on Cityscapes and CamVid datasets verify the effectiveness of the proposed approach. Specifically, without any post-processing and multi-scale testing, the proposed CGNet achieves 64.8% mean IoU on Cityscapes with less than 0.5 M parameters. The source code for the complete system can be found at [this https URL](https://github.com/wutianyiRosun/CGNet).
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142900351-89559574-79cc-4f57-8f69-5d88765ec38d.png" width="80%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                   | download                                                                                                                                                                                                                                                                                                           |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| CGNet  | M3N21    | 680x680   |   60000 | 7.5      | 30.51          | V100   | 65.63 |         68.04 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/cgnet/cgnet_fcn_4xb4-60k_cityscapes-680x680.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/cgnet/cgnet_680x680_60k_cityscapes/cgnet_680x680_60k_cityscapes_20201101_110253-4c0b2f2d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/cgnet/cgnet_680x680_60k_cityscapes/cgnet_680x680_60k_cityscapes-20201101_110253.log.json)     |
-| CGNet  | M3N21    | 512x1024  |   60000 | 8.3      | 31.14          | V100   | 68.27 |         70.33 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/cgnet/cgnet_fcn_4xb8-60k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/cgnet/cgnet_512x1024_60k_cityscapes/cgnet_512x1024_60k_cityscapes_20201101_110254-124ea03b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/cgnet/cgnet_512x1024_60k_cityscapes/cgnet_512x1024_60k_cityscapes-20201101_110254.log.json) |
-
-## Citation
-
-```bibtext
-@article{wu2020cgnet,
-  title={Cgnet: A light-weight context guided network for semantic segmentation},
-  author={Wu, Tianyi and Tang, Sheng and Zhang, Rui and Cao, Juan and Zhang, Yongdong},
-  journal={IEEE Transactions on Image Processing},
-  volume={30},
-  pages={1169--1179},
-  year={2020},
-  publisher={IEEE}
-}
-```
diff --git a/mmsegmentation/configs/cgnet/cgnet_fcn_4xb4-60k_cityscapes-680x680.py b/mmsegmentation/configs/cgnet/cgnet_fcn_4xb4-60k_cityscapes-680x680.py
deleted file mode 100644
index 6a2c0ed..0000000
--- a/mmsegmentation/configs/cgnet/cgnet_fcn_4xb4-60k_cityscapes-680x680.py
+++ /dev/null
@@ -1,59 +0,0 @@
-_base_ = [
-    '../_base_/models/cgnet.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py'
-]
-
-# optimizer
-optimizer = dict(type='Adam', lr=0.001, eps=1e-08, weight_decay=0.0005)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
-# learning policy
-param_scheduler = [
-    dict(
-        type='PolyLR',
-        eta_min=1e-4,
-        power=0.9,
-        by_epoch=False,
-        begin=0,
-        end=60000)
-]
-# runtime settings
-total_iters = 60000
-train_cfg = dict(
-    type='IterBasedTrainLoop', max_iters=total_iters, val_interval=4000)
-val_cfg = dict(type='ValLoop')
-test_cfg = dict(type='TestLoop')
-default_hooks = dict(
-    timer=dict(type='IterTimerHook'),
-    logger=dict(type='LoggerHook', interval=50),
-    param_scheduler=dict(type='ParamSchedulerHook'),
-    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=4000),
-    sampler_seed=dict(type='DistSamplerSeedHook'))
-
-crop_size = (680, 680)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(
-        type='RandomResize',
-        scale=(2048, 1024),
-        ratio_range=(0.5, 2.0),
-        keep_ratio=True),
-    dict(type='RandomCrop', crop_size=crop_size),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=8, num_workers=4, dataset=dict(pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1, num_workers=4, dataset=dict(pipeline=test_pipeline))
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/cgnet/cgnet_fcn_4xb8-60k_cityscapes-512x1024.py b/mmsegmentation/configs/cgnet/cgnet_fcn_4xb8-60k_cityscapes-512x1024.py
deleted file mode 100644
index 8be29de..0000000
--- a/mmsegmentation/configs/cgnet/cgnet_fcn_4xb8-60k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,38 +0,0 @@
-_base_ = [
-    '../_base_/models/cgnet.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py'
-]
-
-# optimizer
-optimizer = dict(type='Adam', lr=0.001, eps=1e-08, weight_decay=0.0005)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
-# learning policy
-param_scheduler = [
-    dict(
-        type='PolyLR',
-        eta_min=1e-4,
-        power=0.9,
-        by_epoch=False,
-        begin=0,
-        end=60000)
-]
-# runtime settings
-total_iters = 60000
-train_cfg = dict(
-    type='IterBasedTrainLoop', max_iters=total_iters, val_interval=4000)
-val_cfg = dict(type='ValLoop')
-test_cfg = dict(type='TestLoop')
-default_hooks = dict(
-    timer=dict(type='IterTimerHook'),
-    logger=dict(type='LoggerHook', interval=50),
-    param_scheduler=dict(type='ParamSchedulerHook'),
-    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=4000),
-    sampler_seed=dict(type='DistSamplerSeedHook'))
-
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
-
-train_dataloader = dict(batch_size=8)
-val_dataloader = dict(batch_size=1)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/cgnet/metafile.yaml b/mmsegmentation/configs/cgnet/metafile.yaml
deleted file mode 100644
index 063fc8b..0000000
--- a/mmsegmentation/configs/cgnet/metafile.yaml
+++ /dev/null
@@ -1,61 +0,0 @@
-Collections:
-- Name: CGNet
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-  Paper:
-    Title: 'CGNet: A Light-weight Context Guided Network for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1811.08201
-  README: configs/cgnet/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: cgnet_fcn_4xb4-60k_cityscapes-680x680
-  In Collection: CGNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 65.63
-      mIoU(ms+flip): 68.04
-  Config: configs/cgnet/cgnet_fcn_4xb4-60k_cityscapes-680x680.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 16
-    Architecture:
-    - M3N21
-    - CGNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 7.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/cgnet/cgnet_680x680_60k_cityscapes/cgnet_680x680_60k_cityscapes_20201101_110253-4c0b2f2d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/cgnet/cgnet_680x680_60k_cityscapes/cgnet_680x680_60k_cityscapes-20201101_110253.log.json
-  Paper:
-    Title: 'CGNet: A Light-weight Context Guided Network for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1811.08201
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/cgnet.py#L187
-  Framework: PyTorch
-- Name: cgnet_fcn_4xb8-60k_cityscapes-512x1024
-  In Collection: CGNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 68.27
-      mIoU(ms+flip): 70.33
-  Config: configs/cgnet/cgnet_fcn_4xb8-60k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 32
-    Architecture:
-    - M3N21
-    - CGNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.3
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/cgnet/cgnet_512x1024_60k_cityscapes/cgnet_512x1024_60k_cityscapes_20201101_110254-124ea03b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/cgnet/cgnet_512x1024_60k_cityscapes/cgnet_512x1024_60k_cityscapes-20201101_110254.log.json
-  Paper:
-    Title: 'CGNet: A Light-weight Context Guided Network for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1811.08201
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/cgnet.py#L187
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/convnext/README.md b/mmsegmentation/configs/convnext/README.md
deleted file mode 100644
index d78fe6e..0000000
--- a/mmsegmentation/configs/convnext/README.md
+++ /dev/null
@@ -1,74 +0,0 @@
-# ConvNeXt
-
-> [A ConvNet for the 2020s](https://arxiv.org/abs/2201.03545)
-
-## Introduction
-
-<!-- [BACKBONE] -->
-
-<a href="https://github.com/facebookresearch/ConvNeXt">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmclassification/blob/v0.20.1/mmcls/models/backbones/convnext.py#L133">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-The "Roaring 20s" of visual recognition began with the introduction of Vision Transformers (ViTs), which quickly superseded ConvNets as the state-of-the-art image classification model. A vanilla ViT, on the other hand, faces difficulties when applied to general computer vision tasks such as object detection and semantic segmentation. It is the hierarchical Transformers (e.g., Swin Transformers) that reintroduced several ConvNet priors, making Transformers practically viable as a generic vision backbone and demonstrating remarkable performance on a wide variety of vision tasks. However, the effectiveness of such hybrid approaches is still largely credited to the intrinsic superiority of Transformers, rather than the inherent inductive biases of convolutions. In this work, we reexamine the design spaces and test the limits of what a pure ConvNet can achieve. We gradually "modernize" a standard ResNet toward the design of a vision Transformer, and discover several key components that contribute to the performance difference along the way. The outcome of this exploration is a family of pure ConvNet models dubbed ConvNeXt. Constructed entirely from standard ConvNet modules, ConvNeXts compete favorably with Transformers in terms of accuracy and scalability, achieving 87.8% ImageNet top-1 accuracy and outperforming Swin Transformers on COCO detection and ADE20K segmentation, while maintaining the simplicity and efficiency of standard ConvNets.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/8370623/148624004-e9581042-ea4d-4e10-b3bd-42c92b02053b.png" width="90%"/>
-</div>
-
-### Usage
-
-- ConvNeXt backbone needs to install [MMClassification](https://github.com/open-mmlab/mmclassification) first, which has abundant backbones for downstream tasks.
-
-```shell
-pip install mmpretrain>=1.0.0rc7
-```
-
-### Pre-trained Models
-
-The pre-trained models on ImageNet-1k or ImageNet-21k are used to fine-tune on the downstream tasks.
-
-|     Model     | Training Data | Params(M) | Flops(G) |                                                                     Download                                                                     |
-| :-----------: | :-----------: | :-------: | :------: | :----------------------------------------------------------------------------------------------------------------------------------------------: |
-| ConvNeXt-T\*  |  ImageNet-1k  |   28.59   |   4.46   | [model](https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-tiny_3rdparty_32xb128-noema_in1k_20220301-795e9634.pth)  |
-| ConvNeXt-S\*  |  ImageNet-1k  |   50.22   |   8.69   | [model](https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-small_3rdparty_32xb128-noema_in1k_20220301-303e75e3.pth) |
-| ConvNeXt-B\*  |  ImageNet-1k  |   88.59   |  15.36   | [model](https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-base_3rdparty_32xb128-noema_in1k_20220301-2a0ee547.pth)  |
-| ConvNeXt-B\*  | ImageNet-21k  |   88.59   |  15.36   |        [model](https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-base_3rdparty_in21k_20220301-262fd037.pth)        |
-| ConvNeXt-L\*  | ImageNet-21k  |  197.77   |  34.37   |       [model](https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-large_3rdparty_in21k_20220301-e6e0ea0a.pth)        |
-| ConvNeXt-XL\* | ImageNet-21k  |  350.20   |  60.93   |       [model](https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-xlarge_3rdparty_in21k_20220301-08aa5ddc.pth)       |
-
-*Models with* are converted from the [official repo](https://github.com/facebookresearch/ConvNeXt/tree/main/semantic_segmentation#results-and-fine-tuned-models).\*
-
-## Results and models
-
-### ADE20K
-
-| Method  | Backbone    | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                                    | download                                                                                                                                                                                                                                                                                                                                                                                             |
-| ------- | ----------- | --------- | ------- | -------- | -------------- | ------ | ----- | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| UPerNet | ConvNeXt-T  | 512x512   | 160000  | 4.23     | 19.90          | V100   | 46.11 | 46.62         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/convnext/convnext-tiny_upernet_8xb2-amp-160k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_tiny_fp16_512x512_160k_ade20k/upernet_convnext_tiny_fp16_512x512_160k_ade20k_20220227_124553-cad485de.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_tiny_fp16_512x512_160k_ade20k/upernet_convnext_tiny_fp16_512x512_160k_ade20k_20220227_124553.log.json)         |
-| UPerNet | ConvNeXt-S  | 512x512   | 160000  | 5.16     | 15.18          | V100   | 48.56 | 49.02         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/convnext/convnext-small_upernet_8xb2-amp-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_small_fp16_512x512_160k_ade20k/upernet_convnext_small_fp16_512x512_160k_ade20k_20220227_131208-1b1e394f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_small_fp16_512x512_160k_ade20k/upernet_convnext_small_fp16_512x512_160k_ade20k_20220227_131208.log.json)     |
-| UPerNet | ConvNeXt-B  | 512x512   | 160000  | 6.33     | 14.41          | V100   | 48.71 | 49.54         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_base_fp16_512x512_160k_ade20k/upernet_convnext_base_fp16_512x512_160k_ade20k_20220227_181227-02a24fc6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_base_fp16_512x512_160k_ade20k/upernet_convnext_base_fp16_512x512_160k_ade20k_20220227_181227.log.json)         |
-| UPerNet | ConvNeXt-B  | 640x640   | 160000  | 8.53     | 10.88          | V100   | 52.13 | 52.66         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-640x640.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_base_fp16_640x640_160k_ade20k/upernet_convnext_base_fp16_640x640_160k_ade20k_20220227_182859-9280e39b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_base_fp16_640x640_160k_ade20k/upernet_convnext_base_fp16_640x640_160k_ade20k_20220227_182859.log.json)         |
-| UPerNet | ConvNeXt-L  | 640x640   | 160000  | 12.08    | 7.69           | V100   | 53.16 | 53.38         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/convnext/convnext-large_upernet_8xb2-amp-160k_ade20k-640x640.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_large_fp16_640x640_160k_ade20k/upernet_convnext_large_fp16_640x640_160k_ade20k_20220226_040532-e57aa54d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_large_fp16_640x640_160k_ade20k/upernet_convnext_large_fp16_640x640_160k_ade20k_20220226_040532.log.json)     |
-| UPerNet | ConvNeXt-XL | 640x640   | 160000  | 26.16\*  | 6.33           | V100   | 53.58 | 54.11         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/convnext/convnext-xlarge_upernet_8xb2-amp-160k_ade20k-640x640.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_xlarge_fp16_640x640_160k_ade20k/upernet_convnext_xlarge_fp16_640x640_160k_ade20k_20220226_080344-95fc38c2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_xlarge_fp16_640x640_160k_ade20k/upernet_convnext_xlarge_fp16_640x640_160k_ade20k_20220226_080344.log.json) |
-
-Note:
-
-- `Mem (GB)` with * is collected when `cudnn_benchmark=True`, and hardware is V100.
-
-## Citation
-
-```bibtex
-@article{liu2022convnet,
-  title={A ConvNet for the 2020s},
-  author={Liu, Zhuang and Mao, Hanzi and Wu, Chao-Yuan and Feichtenhofer, Christoph and Darrell, Trevor and Xie, Saining},
-  journal={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
-  year={2022}
-}
-```
diff --git a/mmsegmentation/configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-512x512.py b/mmsegmentation/configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-512x512.py
deleted file mode 100644
index 09c2aa6..0000000
--- a/mmsegmentation/configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,43 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_convnext.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(in_channels=[128, 256, 512, 1024], num_classes=150),
-    auxiliary_head=dict(in_channels=512, num_classes=150),
-    test_cfg=dict(mode='slide', crop_size=crop_size, stride=(341, 341)),
-)
-
-optim_wrapper = dict(
-    _delete_=True,
-    type='AmpOptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.05),
-    paramwise_cfg={
-        'decay_rate': 0.9,
-        'decay_type': 'stage_wise',
-        'num_layers': 12
-    },
-    constructor='LearningRateDecayOptimizerConstructor',
-    loss_scale='dynamic')
-
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        power=1.0,
-        begin=1500,
-        end=160000,
-        eta_min=0.0,
-        by_epoch=False,
-    )
-]
-
-# By default, models are trained on 8 GPUs with 2 images per GPU
-train_dataloader = dict(batch_size=2)
-val_dataloader = dict(batch_size=1)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-640x640.py b/mmsegmentation/configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-640x640.py
deleted file mode 100644
index 06a8643..0000000
--- a/mmsegmentation/configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-640x640.py
+++ /dev/null
@@ -1,58 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_convnext.py',
-    '../_base_/datasets/ade20k_640x640.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (640, 640)
-data_preprocessor = dict(size=crop_size)
-checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-base_3rdparty_in21k_20220301-262fd037.pth'  # noqa
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        type='mmpretrain.ConvNeXt',
-        arch='base',
-        out_indices=[0, 1, 2, 3],
-        drop_path_rate=0.4,
-        layer_scale_init_value=1.0,
-        gap_before_final_norm=False,
-        init_cfg=dict(
-            type='Pretrained', checkpoint=checkpoint_file,
-            prefix='backbone.')),
-    decode_head=dict(
-        in_channels=[128, 256, 512, 1024],
-        num_classes=150,
-    ),
-    auxiliary_head=dict(in_channels=512, num_classes=150),
-    test_cfg=dict(mode='slide', crop_size=crop_size, stride=(426, 426)),
-)
-
-optim_wrapper = dict(
-    _delete_=True,
-    type='AmpOptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.05),
-    paramwise_cfg={
-        'decay_rate': 0.9,
-        'decay_type': 'stage_wise',
-        'num_layers': 12
-    },
-    constructor='LearningRateDecayOptimizerConstructor',
-    loss_scale='dynamic')
-
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        power=1.0,
-        begin=1500,
-        end=160000,
-        eta_min=0.0,
-        by_epoch=False,
-    )
-]
-
-# By default, models are trained on 8 GPUs with 2 images per GPU
-train_dataloader = dict(batch_size=2)
-val_dataloader = dict(batch_size=1)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/convnext/convnext-large_upernet_8xb2-amp-160k_ade20k-640x640.py b/mmsegmentation/configs/convnext/convnext-large_upernet_8xb2-amp-160k_ade20k-640x640.py
deleted file mode 100644
index 2956e86..0000000
--- a/mmsegmentation/configs/convnext/convnext-large_upernet_8xb2-amp-160k_ade20k-640x640.py
+++ /dev/null
@@ -1,58 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_convnext.py',
-    '../_base_/datasets/ade20k_640x640.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (640, 640)
-data_preprocessor = dict(size=crop_size)
-checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-large_3rdparty_in21k_20220301-e6e0ea0a.pth'  # noqa
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        type='mmpretrain.ConvNeXt',
-        arch='large',
-        out_indices=[0, 1, 2, 3],
-        drop_path_rate=0.4,
-        layer_scale_init_value=1.0,
-        gap_before_final_norm=False,
-        init_cfg=dict(
-            type='Pretrained', checkpoint=checkpoint_file,
-            prefix='backbone.')),
-    decode_head=dict(
-        in_channels=[192, 384, 768, 1536],
-        num_classes=150,
-    ),
-    auxiliary_head=dict(in_channels=768, num_classes=150),
-    test_cfg=dict(mode='slide', crop_size=crop_size, stride=(426, 426)),
-)
-
-optim_wrapper = dict(
-    _delete_=True,
-    type='AmpOptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.05),
-    paramwise_cfg={
-        'decay_rate': 0.9,
-        'decay_type': 'stage_wise',
-        'num_layers': 12
-    },
-    constructor='LearningRateDecayOptimizerConstructor',
-    loss_scale='dynamic')
-
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        power=1.0,
-        begin=1500,
-        end=160000,
-        eta_min=0.0,
-        by_epoch=False,
-    )
-]
-
-# By default, models are trained on 8 GPUs with 2 images per GPU
-train_dataloader = dict(batch_size=2)
-val_dataloader = dict(batch_size=1)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/convnext/convnext-small_upernet_8xb2-amp-160k_ade20k-512x512.py b/mmsegmentation/configs/convnext/convnext-small_upernet_8xb2-amp-160k_ade20k-512x512.py
deleted file mode 100644
index dbe45f1..0000000
--- a/mmsegmentation/configs/convnext/convnext-small_upernet_8xb2-amp-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,57 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_convnext.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-small_3rdparty_32xb128-noema_in1k_20220301-303e75e3.pth'  # noqa
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        type='mmpretrain.ConvNeXt',
-        arch='small',
-        out_indices=[0, 1, 2, 3],
-        drop_path_rate=0.3,
-        layer_scale_init_value=1.0,
-        gap_before_final_norm=False,
-        init_cfg=dict(
-            type='Pretrained', checkpoint=checkpoint_file,
-            prefix='backbone.')),
-    decode_head=dict(
-        in_channels=[96, 192, 384, 768],
-        num_classes=150,
-    ),
-    auxiliary_head=dict(in_channels=384, num_classes=150),
-    test_cfg=dict(mode='slide', crop_size=crop_size, stride=(341, 341)),
-)
-
-optim_wrapper = dict(
-    _delete_=True,
-    type='AmpOptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.05),
-    paramwise_cfg={
-        'decay_rate': 0.9,
-        'decay_type': 'stage_wise',
-        'num_layers': 12
-    },
-    constructor='LearningRateDecayOptimizerConstructor',
-    loss_scale='dynamic')
-
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        power=1.0,
-        begin=1500,
-        end=160000,
-        eta_min=0.0,
-        by_epoch=False,
-    )
-]
-
-# By default, models are trained on 8 GPUs with 2 images per GPU
-train_dataloader = dict(batch_size=2)
-val_dataloader = dict(batch_size=1)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/convnext/convnext-tiny_upernet_8xb2-amp-160k_ade20k-512x512.py b/mmsegmentation/configs/convnext/convnext-tiny_upernet_8xb2-amp-160k_ade20k-512x512.py
deleted file mode 100644
index d2e545a..0000000
--- a/mmsegmentation/configs/convnext/convnext-tiny_upernet_8xb2-amp-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,57 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_convnext.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-tiny_3rdparty_32xb128-noema_in1k_20220301-795e9634.pth'  # noqa
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        type='mmpretrain.ConvNeXt',
-        arch='tiny',
-        out_indices=[0, 1, 2, 3],
-        drop_path_rate=0.4,
-        layer_scale_init_value=1.0,
-        gap_before_final_norm=False,
-        init_cfg=dict(
-            type='Pretrained', checkpoint=checkpoint_file,
-            prefix='backbone.')),
-    decode_head=dict(
-        in_channels=[96, 192, 384, 768],
-        num_classes=150,
-    ),
-    auxiliary_head=dict(in_channels=384, num_classes=150),
-    test_cfg=dict(mode='slide', crop_size=crop_size, stride=(341, 341)),
-)
-
-optim_wrapper = dict(
-    _delete_=True,
-    type='AmpOptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.05),
-    paramwise_cfg={
-        'decay_rate': 0.9,
-        'decay_type': 'stage_wise',
-        'num_layers': 6
-    },
-    constructor='LearningRateDecayOptimizerConstructor',
-    loss_scale='dynamic')
-
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        power=1.0,
-        begin=1500,
-        end=160000,
-        eta_min=0.0,
-        by_epoch=False,
-    )
-]
-
-# By default, models are trained on 8 GPUs with 2 images per GPU
-train_dataloader = dict(batch_size=2)
-val_dataloader = dict(batch_size=1)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/convnext/convnext-xlarge_upernet_8xb2-amp-160k_ade20k-640x640.py b/mmsegmentation/configs/convnext/convnext-xlarge_upernet_8xb2-amp-160k_ade20k-640x640.py
deleted file mode 100644
index dfad734..0000000
--- a/mmsegmentation/configs/convnext/convnext-xlarge_upernet_8xb2-amp-160k_ade20k-640x640.py
+++ /dev/null
@@ -1,58 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_convnext.py',
-    '../_base_/datasets/ade20k_640x640.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (640, 640)
-data_preprocessor = dict(size=crop_size)
-checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-xlarge_3rdparty_in21k_20220301-08aa5ddc.pth'  # noqa
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        type='mmpretrain.ConvNeXt',
-        arch='xlarge',
-        out_indices=[0, 1, 2, 3],
-        drop_path_rate=0.4,
-        layer_scale_init_value=1.0,
-        gap_before_final_norm=False,
-        init_cfg=dict(
-            type='Pretrained', checkpoint=checkpoint_file,
-            prefix='backbone.')),
-    decode_head=dict(
-        in_channels=[256, 512, 1024, 2048],
-        num_classes=150,
-    ),
-    auxiliary_head=dict(in_channels=1024, num_classes=150),
-    test_cfg=dict(mode='slide', crop_size=crop_size, stride=(426, 426)),
-)
-
-optim_wrapper = dict(
-    _delete_=True,
-    type='AmpOptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.00008, betas=(0.9, 0.999), weight_decay=0.05),
-    paramwise_cfg={
-        'decay_rate': 0.9,
-        'decay_type': 'stage_wise',
-        'num_layers': 12
-    },
-    constructor='LearningRateDecayOptimizerConstructor',
-    loss_scale='dynamic')
-
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        power=1.0,
-        begin=1500,
-        end=160000,
-        eta_min=0.0,
-        by_epoch=False,
-    )
-]
-
-# By default, models are trained on 8 GPUs with 2 images per GPU
-train_dataloader = dict(batch_size=2)
-val_dataloader = dict(batch_size=1)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/convnext/metafile.yaml b/mmsegmentation/configs/convnext/metafile.yaml
deleted file mode 100644
index 8340a37..0000000
--- a/mmsegmentation/configs/convnext/metafile.yaml
+++ /dev/null
@@ -1,145 +0,0 @@
-Models:
-- Name: convnext-tiny_upernet_8xb2-amp-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 46.11
-      mIoU(ms+flip): 46.62
-  Config: configs/convnext/convnext-tiny_upernet_8xb2-amp-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - ConvNeXt-T
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 4.23
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_tiny_fp16_512x512_160k_ade20k/upernet_convnext_tiny_fp16_512x512_160k_ade20k_20220227_124553-cad485de.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_tiny_fp16_512x512_160k_ade20k/upernet_convnext_tiny_fp16_512x512_160k_ade20k_20220227_124553.log.json
-  Paper:
-    Title: A ConvNet for the 2020s
-    URL: https://arxiv.org/abs/2201.03545
-  Code: https://github.com/open-mmlab/mmclassification/blob/v0.20.1/mmcls/models/backbones/convnext.py#L133
-  Framework: PyTorch
-- Name: convnext-small_upernet_8xb2-amp-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 48.56
-      mIoU(ms+flip): 49.02
-  Config: configs/convnext/convnext-small_upernet_8xb2-amp-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - ConvNeXt-S
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 5.16
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_small_fp16_512x512_160k_ade20k/upernet_convnext_small_fp16_512x512_160k_ade20k_20220227_131208-1b1e394f.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_small_fp16_512x512_160k_ade20k/upernet_convnext_small_fp16_512x512_160k_ade20k_20220227_131208.log.json
-  Paper:
-    Title: A ConvNet for the 2020s
-    URL: https://arxiv.org/abs/2201.03545
-  Code: https://github.com/open-mmlab/mmclassification/blob/v0.20.1/mmcls/models/backbones/convnext.py#L133
-  Framework: PyTorch
-- Name: convnext-base_upernet_8xb2-amp-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 48.71
-      mIoU(ms+flip): 49.54
-  Config: configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - ConvNeXt-B
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 6.33
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_base_fp16_512x512_160k_ade20k/upernet_convnext_base_fp16_512x512_160k_ade20k_20220227_181227-02a24fc6.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_base_fp16_512x512_160k_ade20k/upernet_convnext_base_fp16_512x512_160k_ade20k_20220227_181227.log.json
-  Paper:
-    Title: A ConvNet for the 2020s
-    URL: https://arxiv.org/abs/2201.03545
-  Code: https://github.com/open-mmlab/mmclassification/blob/v0.20.1/mmcls/models/backbones/convnext.py#L133
-  Framework: PyTorch
-- Name: convnext-base_upernet_8xb2-amp-160k_ade20k-640x640
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 52.13
-      mIoU(ms+flip): 52.66
-  Config: configs/convnext/convnext-base_upernet_8xb2-amp-160k_ade20k-640x640.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - ConvNeXt-B
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 8.53
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_base_fp16_640x640_160k_ade20k/upernet_convnext_base_fp16_640x640_160k_ade20k_20220227_182859-9280e39b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_base_fp16_640x640_160k_ade20k/upernet_convnext_base_fp16_640x640_160k_ade20k_20220227_182859.log.json
-  Paper:
-    Title: A ConvNet for the 2020s
-    URL: https://arxiv.org/abs/2201.03545
-  Code: https://github.com/open-mmlab/mmclassification/blob/v0.20.1/mmcls/models/backbones/convnext.py#L133
-  Framework: PyTorch
-- Name: convnext-large_upernet_8xb2-amp-160k_ade20k-640x640
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 53.16
-      mIoU(ms+flip): 53.38
-  Config: configs/convnext/convnext-large_upernet_8xb2-amp-160k_ade20k-640x640.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - ConvNeXt-L
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 12.08
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_large_fp16_640x640_160k_ade20k/upernet_convnext_large_fp16_640x640_160k_ade20k_20220226_040532-e57aa54d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_large_fp16_640x640_160k_ade20k/upernet_convnext_large_fp16_640x640_160k_ade20k_20220226_040532.log.json
-  Paper:
-    Title: A ConvNet for the 2020s
-    URL: https://arxiv.org/abs/2201.03545
-  Code: https://github.com/open-mmlab/mmclassification/blob/v0.20.1/mmcls/models/backbones/convnext.py#L133
-  Framework: PyTorch
-- Name: convnext-xlarge_upernet_8xb2-amp-160k_ade20k-640x640
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 53.58
-      mIoU(ms+flip): 54.11
-  Config: configs/convnext/convnext-xlarge_upernet_8xb2-amp-160k_ade20k-640x640.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - ConvNeXt-XL
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 26.16
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_xlarge_fp16_640x640_160k_ade20k/upernet_convnext_xlarge_fp16_640x640_160k_ade20k_20220226_080344-95fc38c2.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_xlarge_fp16_640x640_160k_ade20k/upernet_convnext_xlarge_fp16_640x640_160k_ade20k_20220226_080344.log.json
-  Paper:
-    Title: A ConvNet for the 2020s
-    URL: https://arxiv.org/abs/2201.03545
-  Code: https://github.com/open-mmlab/mmclassification/blob/v0.20.1/mmcls/models/backbones/convnext.py#L133
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/danet/README.md b/mmsegmentation/configs/danet/README.md
deleted file mode 100644
index 90194f3..0000000
--- a/mmsegmentation/configs/danet/README.md
+++ /dev/null
@@ -1,67 +0,0 @@
-# DANet
-
-> [Dual Attention Network for Scene Segmentation](https://arxiv.org/abs/1809.02983)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/junfu1115/DANet/">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-In this paper, we address the scene segmentation task by capturing rich contextual dependencies based on the selfattention mechanism. Unlike previous works that capture contexts by multi-scale features fusion, we propose a Dual Attention Networks (DANet) to adaptively integrate local features with their global dependencies. Specifically, we append two types of attention modules on top of traditional dilated FCN, which model the semantic interdependencies in spatial and channel dimensions respectively. The position attention module selectively aggregates the features at each position by a weighted sum of the features at all positions. Similar features would be related to each other regardless of their distances. Meanwhile, the channel attention module selectively emphasizes interdependent channel maps by integrating associated features among all channel maps. We sum the outputs of the two attention modules to further improve feature representation which contributes to more precise segmentation results. We achieve new state-of-the-art segmentation performance on three challenging scene segmentation datasets, i.e., Cityscapes, PASCAL Context and COCO Stuff dataset. In particular, a Mean IoU score of 81.5% on Cityscapes test set is achieved without using coarse data. We make the code and trained model publicly available at [this https URL](https://github.com/junfu1115/DANet).
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142900467-f832fdb9-3b7d-47d3-8e80-e6ee9303bdfb.png" width="70%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                       | download                                                                                                                                                                                                                                                                                                                                           |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------- | ---------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| DANet  | R-50-D8  | 512x1024  |   40000 | 7.4      | 2.66           | V100   | 78.74 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r50-d8_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x1024_40k_cityscapes/danet_r50-d8_512x1024_40k_cityscapes_20200605_191324-c0dbfa5f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x1024_40k_cityscapes/danet_r50-d8_512x1024_40k_cityscapes_20200605_191324.log.json)     |
-| DANet  | R-101-D8 | 512x1024  |   40000 | 10.9     | 1.99           | V100   | 80.52 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r101-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x1024_40k_cityscapes/danet_r101-d8_512x1024_40k_cityscapes_20200605_200831-c57a7157.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x1024_40k_cityscapes/danet_r101-d8_512x1024_40k_cityscapes_20200605_200831.log.json) |
-| DANet  | R-50-D8  | 769x769   |   40000 | 8.8      | 1.56           | V100   | 78.88 | 80.62         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r50-d8_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_769x769_40k_cityscapes/danet_r50-d8_769x769_40k_cityscapes_20200530_025703-76681c60.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_769x769_40k_cityscapes/danet_r50-d8_769x769_40k_cityscapes_20200530_025703.log.json)         |
-| DANet  | R-101-D8 | 769x769   |   40000 | 12.8     | 1.07           | V100   | 79.88 | 81.47         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r101-d8_4xb2-40k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_769x769_40k_cityscapes/danet_r101-d8_769x769_40k_cityscapes_20200530_025717-dcb7fd4e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_769x769_40k_cityscapes/danet_r101-d8_769x769_40k_cityscapes_20200530_025717.log.json)     |
-| DANet  | R-50-D8  | 512x1024  |   80000 | -        | -              | V100   | 79.34 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r50-d8_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x1024_80k_cityscapes/danet_r50-d8_512x1024_80k_cityscapes_20200607_133029-2bfa2293.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x1024_80k_cityscapes/danet_r50-d8_512x1024_80k_cityscapes_20200607_133029.log.json)     |
-| DANet  | R-101-D8 | 512x1024  |   80000 | -        | -              | V100   | 80.41 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r101-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x1024_80k_cityscapes/danet_r101-d8_512x1024_80k_cityscapes_20200607_132918-955e6350.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x1024_80k_cityscapes/danet_r101-d8_512x1024_80k_cityscapes_20200607_132918.log.json) |
-| DANet  | R-50-D8  | 769x769   |   80000 | -        | -              | V100   | 79.27 | 80.96         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r50-d8_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_769x769_80k_cityscapes/danet_r50-d8_769x769_80k_cityscapes_20200607_132954-495689b4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_769x769_80k_cityscapes/danet_r50-d8_769x769_80k_cityscapes_20200607_132954.log.json)         |
-| DANet  | R-101-D8 | 769x769   |   80000 | -        | -              | V100   | 80.47 | 82.02         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r101-d8_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_769x769_80k_cityscapes/danet_r101-d8_769x769_80k_cityscapes_20200607_132918-f3a929e7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_769x769_80k_cityscapes/danet_r101-d8_769x769_80k_cityscapes_20200607_132918.log.json)     |
-
-### ADE20K
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                   | download                                                                                                                                                                                                                                                                                                                           |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| DANet  | R-50-D8  | 512x512   |   80000 | 11.5     | 21.20          | V100   | 41.66 |         42.90 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_80k_ade20k/danet_r50-d8_512x512_80k_ade20k_20200615_015125-edb18e08.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_80k_ade20k/danet_r50-d8_512x512_80k_ade20k_20200615_015125.log.json)         |
-| DANet  | R-101-D8 | 512x512   |   80000 | 15       | 14.18          | V100   | 43.64 |         45.19 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_80k_ade20k/danet_r101-d8_512x512_80k_ade20k_20200615_015126-d0357c73.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_80k_ade20k/danet_r101-d8_512x512_80k_ade20k_20200615_015126.log.json)     |
-| DANet  | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 42.45 |         43.25 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_160k_ade20k/danet_r50-d8_512x512_160k_ade20k_20200616_082340-9cb35dcd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_160k_ade20k/danet_r50-d8_512x512_160k_ade20k_20200616_082340.log.json)     |
-| DANet  | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 44.17 |         45.02 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_160k_ade20k/danet_r101-d8_512x512_160k_ade20k_20200616_082348-23bf12f9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_160k_ade20k/danet_r101-d8_512x512_160k_ade20k_20200616_082348.log.json) |
-
-### Pascal VOC 2012 + Aug
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                    | download                                                                                                                                                                                                                                                                                                                               |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| DANet  | R-50-D8  | 512x512   |   20000 | 6.5      | 20.94          | V100   | 74.45 |         75.69 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r50-d8_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_20k_voc12aug/danet_r50-d8_512x512_20k_voc12aug_20200618_070026-9e9e3ab3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_20k_voc12aug/danet_r50-d8_512x512_20k_voc12aug_20200618_070026.log.json)     |
-| DANet  | R-101-D8 | 512x512   |   20000 | 9.9      | 13.76          | V100   | 76.02 |         77.23 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r101-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_20k_voc12aug/danet_r101-d8_512x512_20k_voc12aug_20200618_070026-d48d23b2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_20k_voc12aug/danet_r101-d8_512x512_20k_voc12aug_20200618_070026.log.json) |
-| DANet  | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 76.37 |         77.29 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r50-d8_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_40k_voc12aug/danet_r50-d8_512x512_40k_voc12aug_20200613_235526-426e3a64.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_40k_voc12aug/danet_r50-d8_512x512_40k_voc12aug_20200613_235526.log.json)     |
-| DANet  | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 76.51 |         77.32 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet/danet_r101-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_40k_voc12aug/danet_r101-d8_512x512_40k_voc12aug_20200613_223031-788e232a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_40k_voc12aug/danet_r101-d8_512x512_40k_voc12aug_20200613_223031.log.json) |
-
-## Citation
-
-```bibtex
-@article{fu2018dual,
-  title={Dual Attention Network for Scene Segmentation},
-  author={Jun Fu, Jing Liu, Haijie Tian, Yong Li, Yongjun Bao, Zhiwei Fang,and Hanqing Lu},
-  booktitle={The IEEE Conference on Computer Vision and Pattern Recognition (CVPR)},
-  year={2019}
-}
-```
diff --git a/mmsegmentation/configs/danet/danet_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/danet/danet_r101-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 4602f33..0000000
--- a/mmsegmentation/configs/danet/danet_r101-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './danet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/danet/danet_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/danet/danet_r101-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index a08c18e..0000000
--- a/mmsegmentation/configs/danet/danet_r101-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './danet_r50-d8_4xb2-40k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/danet/danet_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/danet/danet_r101-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 98b1c64..0000000
--- a/mmsegmentation/configs/danet/danet_r101-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './danet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/danet/danet_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/danet/danet_r101-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 9affe30..0000000
--- a/mmsegmentation/configs/danet/danet_r101-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './danet_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/danet/danet_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/danet/danet_r101-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 0079ad6..0000000
--- a/mmsegmentation/configs/danet/danet_r101-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './danet_r50-d8_4xb4-160k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/danet/danet_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/danet/danet_r101-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index 4844451..0000000
--- a/mmsegmentation/configs/danet/danet_r101-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './danet_r50-d8_4xb4-20k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/danet/danet_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/danet/danet_r101-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index 2f2df7a..0000000
--- a/mmsegmentation/configs/danet/danet_r101-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './danet_r50-d8_4xb4-40k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/danet/danet_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/danet/danet_r101-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index dd75bc1..0000000
--- a/mmsegmentation/configs/danet/danet_r101-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './danet_r50-d8_4xb4-80k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/danet/danet_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/danet/danet_r50-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 3bc2a77..0000000
--- a/mmsegmentation/configs/danet/danet_r50-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/danet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/danet/danet_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/danet/danet_r50-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index 3a01fb9..0000000
--- a/mmsegmentation/configs/danet/danet_r50-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/danet_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/danet/danet_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/danet/danet_r50-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 95d5df0..0000000
--- a/mmsegmentation/configs/danet/danet_r50-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/danet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/danet/danet_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/danet/danet_r50-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 4255716..0000000
--- a/mmsegmentation/configs/danet/danet_r50-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/danet_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/danet/danet_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/danet/danet_r50-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index a8f082d..0000000
--- a/mmsegmentation/configs/danet/danet_r50-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/danet_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/danet/danet_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/danet/danet_r50-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index fab574f..0000000
--- a/mmsegmentation/configs/danet/danet_r50-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/danet_r50-d8.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_20k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/danet/danet_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/danet/danet_r50-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index 148fa39..0000000
--- a/mmsegmentation/configs/danet/danet_r50-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/danet_r50-d8.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/danet/danet_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/danet/danet_r50-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index efbd908..0000000
--- a/mmsegmentation/configs/danet/danet_r50-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/danet_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/danet/metafile.yaml b/mmsegmentation/configs/danet/metafile.yaml
deleted file mode 100644
index daff925..0000000
--- a/mmsegmentation/configs/danet/metafile.yaml
+++ /dev/null
@@ -1,387 +0,0 @@
-Collections:
-- Name: DANet
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-    - ADE20K
-    - Pascal VOC 2012 + Aug
-  Paper:
-    Title: Dual Attention Network for Scene Segmentation
-    URL: https://arxiv.org/abs/1809.02983
-  README: configs/danet/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: danet_r50-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: DANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.74
-  Config: configs/danet/danet_r50-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - DANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 7.4
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x1024_40k_cityscapes/danet_r50-d8_512x1024_40k_cityscapes_20200605_191324-c0dbfa5f.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x1024_40k_cityscapes/danet_r50-d8_512x1024_40k_cityscapes_20200605_191324.log.json
-  Paper:
-    Title: Dual Attention Network for Scene Segmentation
-    URL: https://arxiv.org/abs/1809.02983
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
-  Framework: PyTorch
-- Name: danet_r101-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: DANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 80.52
-  Config: configs/danet/danet_r101-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - DANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x1024_40k_cityscapes/danet_r101-d8_512x1024_40k_cityscapes_20200605_200831-c57a7157.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x1024_40k_cityscapes/danet_r101-d8_512x1024_40k_cityscapes_20200605_200831.log.json
-  Paper:
-    Title: Dual Attention Network for Scene Segmentation
-    URL: https://arxiv.org/abs/1809.02983
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
-  Framework: PyTorch
-- Name: danet_r50-d8_4xb2-40k_cityscapes-769x769
-  In Collection: DANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.88
-      mIoU(ms+flip): 80.62
-  Config: configs/danet/danet_r50-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - DANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_769x769_40k_cityscapes/danet_r50-d8_769x769_40k_cityscapes_20200530_025703-76681c60.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_769x769_40k_cityscapes/danet_r50-d8_769x769_40k_cityscapes_20200530_025703.log.json
-  Paper:
-    Title: Dual Attention Network for Scene Segmentation
-    URL: https://arxiv.org/abs/1809.02983
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
-  Framework: PyTorch
-- Name: danet_r101-d8_4xb2-40k_cityscapes-769x769
-  In Collection: DANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.88
-      mIoU(ms+flip): 81.47
-  Config: configs/danet/danet_r101-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - DANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 12.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_769x769_40k_cityscapes/danet_r101-d8_769x769_40k_cityscapes_20200530_025717-dcb7fd4e.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_769x769_40k_cityscapes/danet_r101-d8_769x769_40k_cityscapes_20200530_025717.log.json
-  Paper:
-    Title: Dual Attention Network for Scene Segmentation
-    URL: https://arxiv.org/abs/1809.02983
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
-  Framework: PyTorch
-- Name: danet_r50-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: DANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.34
-  Config: configs/danet/danet_r50-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - DANet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x1024_80k_cityscapes/danet_r50-d8_512x1024_80k_cityscapes_20200607_133029-2bfa2293.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x1024_80k_cityscapes/danet_r50-d8_512x1024_80k_cityscapes_20200607_133029.log.json
-  Paper:
-    Title: Dual Attention Network for Scene Segmentation
-    URL: https://arxiv.org/abs/1809.02983
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
-  Framework: PyTorch
-- Name: danet_r101-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: DANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 80.41
-  Config: configs/danet/danet_r101-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - DANet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x1024_80k_cityscapes/danet_r101-d8_512x1024_80k_cityscapes_20200607_132918-955e6350.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x1024_80k_cityscapes/danet_r101-d8_512x1024_80k_cityscapes_20200607_132918.log.json
-  Paper:
-    Title: Dual Attention Network for Scene Segmentation
-    URL: https://arxiv.org/abs/1809.02983
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
-  Framework: PyTorch
-- Name: danet_r50-d8_4xb2-80k_cityscapes-769x769
-  In Collection: DANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.27
-      mIoU(ms+flip): 80.96
-  Config: configs/danet/danet_r50-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - DANet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_769x769_80k_cityscapes/danet_r50-d8_769x769_80k_cityscapes_20200607_132954-495689b4.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_769x769_80k_cityscapes/danet_r50-d8_769x769_80k_cityscapes_20200607_132954.log.json
-  Paper:
-    Title: Dual Attention Network for Scene Segmentation
-    URL: https://arxiv.org/abs/1809.02983
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
-  Framework: PyTorch
-- Name: danet_r101-d8_4xb2-80k_cityscapes-769x769
-  In Collection: DANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 80.47
-      mIoU(ms+flip): 82.02
-  Config: configs/danet/danet_r101-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - DANet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_769x769_80k_cityscapes/danet_r101-d8_769x769_80k_cityscapes_20200607_132918-f3a929e7.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_769x769_80k_cityscapes/danet_r101-d8_769x769_80k_cityscapes_20200607_132918.log.json
-  Paper:
-    Title: Dual Attention Network for Scene Segmentation
-    URL: https://arxiv.org/abs/1809.02983
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
-  Framework: PyTorch
-- Name: danet_r50-d8_4xb4-80k_ade20k-512x512
-  In Collection: DANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 41.66
-      mIoU(ms+flip): 42.9
-  Config: configs/danet/danet_r50-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 11.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_80k_ade20k/danet_r50-d8_512x512_80k_ade20k_20200615_015125-edb18e08.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_80k_ade20k/danet_r50-d8_512x512_80k_ade20k_20200615_015125.log.json
-  Paper:
-    Title: Dual Attention Network for Scene Segmentation
-    URL: https://arxiv.org/abs/1809.02983
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
-  Framework: PyTorch
-- Name: danet_r101-d8_4xb4-80k_ade20k-512x512
-  In Collection: DANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 43.64
-      mIoU(ms+flip): 45.19
-  Config: configs/danet/danet_r101-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 15.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_80k_ade20k/danet_r101-d8_512x512_80k_ade20k_20200615_015126-d0357c73.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_80k_ade20k/danet_r101-d8_512x512_80k_ade20k_20200615_015126.log.json
-  Paper:
-    Title: Dual Attention Network for Scene Segmentation
-    URL: https://arxiv.org/abs/1809.02983
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
-  Framework: PyTorch
-- Name: danet_r50-d8_4xb4-160k_ade20k-512x512
-  In Collection: DANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.45
-      mIoU(ms+flip): 43.25
-  Config: configs/danet/danet_r50-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DANet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_160k_ade20k/danet_r50-d8_512x512_160k_ade20k_20200616_082340-9cb35dcd.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_160k_ade20k/danet_r50-d8_512x512_160k_ade20k_20200616_082340.log.json
-  Paper:
-    Title: Dual Attention Network for Scene Segmentation
-    URL: https://arxiv.org/abs/1809.02983
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
-  Framework: PyTorch
-- Name: danet_r101-d8_4xb4-160k_ade20k-512x512
-  In Collection: DANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 44.17
-      mIoU(ms+flip): 45.02
-  Config: configs/danet/danet_r101-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DANet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_160k_ade20k/danet_r101-d8_512x512_160k_ade20k_20200616_082348-23bf12f9.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_160k_ade20k/danet_r101-d8_512x512_160k_ade20k_20200616_082348.log.json
-  Paper:
-    Title: Dual Attention Network for Scene Segmentation
-    URL: https://arxiv.org/abs/1809.02983
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
-  Framework: PyTorch
-- Name: danet_r50-d8_4xb4-20k_voc12aug-512x512
-  In Collection: DANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 74.45
-      mIoU(ms+flip): 75.69
-  Config: configs/danet/danet_r50-d8_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_20k_voc12aug/danet_r50-d8_512x512_20k_voc12aug_20200618_070026-9e9e3ab3.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_20k_voc12aug/danet_r50-d8_512x512_20k_voc12aug_20200618_070026.log.json
-  Paper:
-    Title: Dual Attention Network for Scene Segmentation
-    URL: https://arxiv.org/abs/1809.02983
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
-  Framework: PyTorch
-- Name: danet_r101-d8_4xb4-20k_voc12aug-512x512
-  In Collection: DANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 76.02
-      mIoU(ms+flip): 77.23
-  Config: configs/danet/danet_r101-d8_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_20k_voc12aug/danet_r101-d8_512x512_20k_voc12aug_20200618_070026-d48d23b2.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_20k_voc12aug/danet_r101-d8_512x512_20k_voc12aug_20200618_070026.log.json
-  Paper:
-    Title: Dual Attention Network for Scene Segmentation
-    URL: https://arxiv.org/abs/1809.02983
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
-  Framework: PyTorch
-- Name: danet_r50-d8_4xb4-40k_voc12aug-512x512
-  In Collection: DANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 76.37
-      mIoU(ms+flip): 77.29
-  Config: configs/danet/danet_r50-d8_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DANet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_40k_voc12aug/danet_r50-d8_512x512_40k_voc12aug_20200613_235526-426e3a64.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r50-d8_512x512_40k_voc12aug/danet_r50-d8_512x512_40k_voc12aug_20200613_235526.log.json
-  Paper:
-    Title: Dual Attention Network for Scene Segmentation
-    URL: https://arxiv.org/abs/1809.02983
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
-  Framework: PyTorch
-- Name: danet_r101-d8_4xb4-40k_voc12aug-512x512
-  In Collection: DANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 76.51
-      mIoU(ms+flip): 77.32
-  Config: configs/danet/danet_r101-d8_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DANet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_40k_voc12aug/danet_r101-d8_512x512_40k_voc12aug_20200613_223031-788e232a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/danet/danet_r101-d8_512x512_40k_voc12aug/danet_r101-d8_512x512_40k_voc12aug_20200613_223031.log.json
-  Paper:
-    Title: Dual Attention Network for Scene Segmentation
-    URL: https://arxiv.org/abs/1809.02983
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/da_head.py#L76
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/ddrnet/README.md b/mmsegmentation/configs/ddrnet/README.md
deleted file mode 100644
index ccbfcdf..0000000
--- a/mmsegmentation/configs/ddrnet/README.md
+++ /dev/null
@@ -1,46 +0,0 @@
-# DDRNet
-
-> [Deep Dual-resolution Networks for Real-time and Accurate Semantic Segmentation of Road Scenes](http://arxiv.org/abs/2101.06085)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/ydhongHIT/DDRNet">Official Repo</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Semantic segmentation is a key technology for autonomous vehicles to understand the surrounding scenes. The appealing performances of contemporary models usually come at the expense of heavy computations and lengthy inference time, which is intolerable for self-driving. Using light-weight architectures (encoder-decoder or two-pathway) or reasoning on low-resolution images, recent methods realize very fast scene parsing, even running at more than 100 FPS on a single 1080Ti GPU. However, there is still a significant gap in performance between these real-time methods and the models based on dilation backbones. To tackle this problem, we proposed a family of efficient backbones specially designed for real-time semantic segmentation. The proposed deep dual-resolution networks (DDRNets) are composed of two deep branches between which multiple bilateral fusions are performed. Additionally, we design a new contextual information extractor named Deep Aggregation Pyramid Pooling Module (DAPPM) to enlarge effective receptive fields and fuse multi-scale context based on low-resolution feature maps. Our method achieves a new state-of-the-art trade-off between accuracy and speed on both Cityscapes and CamVid dataset. In particular, on a single 2080Ti GPU, DDRNet-23-slim yields 77.4% mIoU at 102 FPS on Cityscapes test set and 74.7% mIoU at 230 FPS on CamVid test set. With widely used test augmentation, our method is superior to most state-of-the-art models and requires much less computation. Codes and trained models are available online.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://raw.githubusercontent.com/ydhongHIT/DDRNet/main/figs/DDRNet_seg.png" width="80%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method | Backbone      | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                                    | download                                                                                                                                                                                                                                                                                                                                                                                                             |
-| ------ | ------------- | --------- | ------- | -------- | -------------- | ------ | ----- | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| DDRNet | DDRNet23-slim | 1024x1024 | 120000  | 1.70     | 85.85          | A100   | 77.84 | 80.15         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ddrnet/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ddrnet/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024_20230426_145312-6a5e5174.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ddrnet/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024_20230426_145312.json) |
-| DDRNet | DDRNet23      | 1024x1024 | 120000  | 7.26     | 33.41          | A100   | 79.99 | 81.71         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ddrnet/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024.py)      | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ddrnet/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024_20230425_162633-81601db0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ddrnet/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024_20230425_162633.json)                     |
-
-## Notes
-
-The pretrained weights in config files are converted from [the official repo](https://github.com/ydhongHIT/DDRNet#pretrained-models).
-
-## Citation
-
-```bibtex
-@article{pan2022deep,
-  title={Deep Dual-Resolution Networks for Real-Time and Accurate Semantic Segmentation of Traffic Scenes},
-  author={Pan, Huihui and Hong, Yuanduo and Sun, Weichao and Jia, Yisong},
-  journal={IEEE Transactions on Intelligent Transportation Systems},
-  year={2022},
-  publisher={IEEE}
-}
-```
diff --git a/mmsegmentation/configs/ddrnet/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024.py b/mmsegmentation/configs/ddrnet/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024.py
deleted file mode 100644
index 65b0ead..0000000
--- a/mmsegmentation/configs/ddrnet/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024.py
+++ /dev/null
@@ -1,93 +0,0 @@
-_base_ = [
-    '../_base_/datasets/cityscapes_1024x1024.py',
-    '../_base_/default_runtime.py',
-]
-
-# The class_weight is borrowed from https://github.com/openseg-group/OCNet.pytorch/issues/14 # noqa
-# Licensed under the MIT License
-class_weight = [
-    0.8373, 0.918, 0.866, 1.0345, 1.0166, 0.9969, 0.9754, 1.0489, 0.8786,
-    1.0023, 0.9539, 0.9843, 1.1116, 0.9037, 1.0865, 1.0955, 1.0865, 1.1529,
-    1.0507
-]
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/ddrnet/pretrain/ddrnet23s-in1kpre_3rdparty-1ccac5b1.pth'  # noqa
-crop_size = (1024, 1024)
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    size=crop_size,
-    mean=[123.675, 116.28, 103.53],
-    std=[58.395, 57.12, 57.375],
-    bgr_to_rgb=True,
-    pad_val=0,
-    seg_pad_val=255)
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        type='DDRNet',
-        in_channels=3,
-        channels=32,
-        ppm_channels=128,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint)),
-    decode_head=dict(
-        type='DDRHead',
-        in_channels=32 * 4,
-        channels=64,
-        dropout_ratio=0.,
-        num_classes=19,
-        align_corners=False,
-        norm_cfg=norm_cfg,
-        loss_decode=[
-            dict(
-                type='OhemCrossEntropy',
-                thres=0.9,
-                min_kept=131072,
-                class_weight=class_weight,
-                loss_weight=1.0),
-            dict(
-                type='OhemCrossEntropy',
-                thres=0.9,
-                min_kept=131072,
-                class_weight=class_weight,
-                loss_weight=0.4),
-        ]),
-
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
-
-train_dataloader = dict(batch_size=6, num_workers=4)
-
-iters = 120000
-# optimizer
-optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
-# learning policy
-param_scheduler = [
-    dict(
-        type='PolyLR',
-        eta_min=0,
-        power=0.9,
-        begin=0,
-        end=iters,
-        by_epoch=False)
-]
-
-# training schedule for 120k
-train_cfg = dict(
-    type='IterBasedTrainLoop', max_iters=iters, val_interval=iters // 10)
-val_cfg = dict(type='ValLoop')
-test_cfg = dict(type='TestLoop')
-default_hooks = dict(
-    timer=dict(type='IterTimerHook'),
-    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
-    param_scheduler=dict(type='ParamSchedulerHook'),
-    checkpoint=dict(
-        type='CheckpointHook', by_epoch=False, interval=iters // 10),
-    sampler_seed=dict(type='DistSamplerSeedHook'),
-    visualization=dict(type='SegVisualizationHook'))
-
-randomness = dict(seed=304)
diff --git a/mmsegmentation/configs/ddrnet/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024.py b/mmsegmentation/configs/ddrnet/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024.py
deleted file mode 100644
index 444efe2..0000000
--- a/mmsegmentation/configs/ddrnet/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024.py
+++ /dev/null
@@ -1,93 +0,0 @@
-_base_ = [
-    '../_base_/datasets/cityscapes_1024x1024.py',
-    '../_base_/default_runtime.py',
-]
-
-# The class_weight is borrowed from https://github.com/openseg-group/OCNet.pytorch/issues/14 # noqa
-# Licensed under the MIT License
-class_weight = [
-    0.8373, 0.918, 0.866, 1.0345, 1.0166, 0.9969, 0.9754, 1.0489, 0.8786,
-    1.0023, 0.9539, 0.9843, 1.1116, 0.9037, 1.0865, 1.0955, 1.0865, 1.1529,
-    1.0507
-]
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/ddrnet/pretrain/ddrnet23-in1kpre_3rdparty-9ca29f62.pth'  # noqa
-crop_size = (1024, 1024)
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    size=crop_size,
-    mean=[123.675, 116.28, 103.53],
-    std=[58.395, 57.12, 57.375],
-    bgr_to_rgb=True,
-    pad_val=0,
-    seg_pad_val=255)
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        type='DDRNet',
-        in_channels=3,
-        channels=64,
-        ppm_channels=128,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint)),
-    decode_head=dict(
-        type='DDRHead',
-        in_channels=64 * 4,
-        channels=128,
-        dropout_ratio=0.,
-        num_classes=19,
-        align_corners=False,
-        norm_cfg=norm_cfg,
-        loss_decode=[
-            dict(
-                type='OhemCrossEntropy',
-                thres=0.9,
-                min_kept=131072,
-                class_weight=class_weight,
-                loss_weight=1.0),
-            dict(
-                type='OhemCrossEntropy',
-                thres=0.9,
-                min_kept=131072,
-                class_weight=class_weight,
-                loss_weight=0.4),
-        ]),
-
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
-
-train_dataloader = dict(batch_size=6, num_workers=4)
-
-iters = 120000
-# optimizer
-optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
-# learning policy
-param_scheduler = [
-    dict(
-        type='PolyLR',
-        eta_min=0,
-        power=0.9,
-        begin=0,
-        end=iters,
-        by_epoch=False)
-]
-
-# training schedule for 120k
-train_cfg = dict(
-    type='IterBasedTrainLoop', max_iters=iters, val_interval=iters // 10)
-val_cfg = dict(type='ValLoop')
-test_cfg = dict(type='TestLoop')
-default_hooks = dict(
-    timer=dict(type='IterTimerHook'),
-    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
-    param_scheduler=dict(type='ParamSchedulerHook'),
-    checkpoint=dict(
-        type='CheckpointHook', by_epoch=False, interval=iters // 10),
-    sampler_seed=dict(type='DistSamplerSeedHook'),
-    visualization=dict(type='SegVisualizationHook'))
-
-randomness = dict(seed=304)
diff --git a/mmsegmentation/configs/ddrnet/metafile.yaml b/mmsegmentation/configs/ddrnet/metafile.yaml
deleted file mode 100644
index 0707470..0000000
--- a/mmsegmentation/configs/ddrnet/metafile.yaml
+++ /dev/null
@@ -1,64 +0,0 @@
-Collections:
-- Name: DDRNet
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-  Paper:
-    Title: Deep Dual-resolution Networks for Real-time and Accurate Semantic Segmentation
-      of Road Scenes
-    URL: http://arxiv.org/abs/2101.06085
-  README: configs/ddrnet/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024
-  In Collection: DDRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.84
-      mIoU(ms+flip): 80.15
-  Config: configs/ddrnet/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 12
-    Architecture:
-    - DDRNet23-slim
-    - DDRNet
-    Training Resources: 2x A100 GPUS
-    Memory (GB): 1.7
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ddrnet/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024_20230426_145312-6a5e5174.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ddrnet/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024/ddrnet_23-slim_in1k-pre_2xb6-120k_cityscapes-1024x1024_20230426_145312.json
-  Paper:
-    Title: Deep Dual-resolution Networks for Real-time and Accurate Semantic Segmentation
-      of Road Scenes
-    URL: http://arxiv.org/abs/2101.06085
-  Code: ''
-  Framework: PyTorch
-- Name: ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024
-  In Collection: DDRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.99
-      mIoU(ms+flip): 81.71
-  Config: configs/ddrnet/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 12
-    Architecture:
-    - DDRNet23
-    - DDRNet
-    Training Resources: 2x A100 GPUS
-    Memory (GB): 7.26
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ddrnet/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024_20230425_162633-81601db0.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ddrnet/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024/ddrnet_23_in1k-pre_2xb6-120k_cityscapes-1024x1024_20230425_162633.json
-  Paper:
-    Title: Deep Dual-resolution Networks for Real-time and Accurate Semantic Segmentation
-      of Road Scenes
-    URL: http://arxiv.org/abs/2101.06085
-  Code: ''
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/deeplabv3/README.md b/mmsegmentation/configs/deeplabv3/README.md
deleted file mode 100644
index df50b7f..0000000
--- a/mmsegmentation/configs/deeplabv3/README.md
+++ /dev/null
@@ -1,118 +0,0 @@
-# DeepLabV3
-
-> [Rethinking atrous convolution for semantic image segmentation](https://arxiv.org/abs/1706.05587)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/tensorflow/models/tree/master/research/deeplab">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-In this work, we revisit atrous convolution, a powerful tool to explicitly adjust filter's field-of-view as well as control the resolution of feature responses computed by Deep Convolutional Neural Networks, in the application of semantic image segmentation. To handle the problem of segmenting objects at multiple scales, we design modules which employ atrous convolution in cascade or in parallel to capture multi-scale context by adopting multiple atrous rates. Furthermore, we propose to augment our previously proposed Atrous Spatial Pyramid Pooling module, which probes convolutional features at multiple scales, with image-level features encoding global context and further boost performance. We also elaborate on implementation details and share our experience on training our system. The proposed \`DeepLabv3' system significantly improves over our previous DeepLab versions without DenseCRF post-processing and attains comparable performance with other state-of-art models on the PASCAL VOC 2012 semantic image segmentation benchmark.
-
-<!-- [IMAGE] -->
-
-<div align=center >
-<img alt="DEEPLABv3_ResNet-D8" src="https://user-images.githubusercontent.com/61172629/209305311-87ff9e36-b7cd-46d7-8b4c-9e26e10c27d0.jpg"/>
-DEEPLABv3_ResNet-D8 model structure
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method           | Backbone        | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                      | download                                                                                                                                                                                                                                                                                                                                                                                               |
-| ---------------- | --------------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| DeepLabV3        | R-50-D8         | 512x1024  |   40000 | 6.1      | 2.57           | V100   | 79.09 |         80.45 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x1024_40k_cityscapes/deeplabv3_r50-d8_512x1024_40k_cityscapes_20200605_022449-acadc2f8.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x1024_40k_cityscapes/deeplabv3_r50-d8_512x1024_40k_cityscapes_20200605_022449.log.json)                                 |
-| DeepLabV3        | R-101-D8        | 512x1024  |   40000 | 9.6      | 1.92           | V100   | 77.12 |         79.61 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-512x1024.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x1024_40k_cityscapes/deeplabv3_r101-d8_512x1024_40k_cityscapes_20200605_012241-7fd3f799.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x1024_40k_cityscapes/deeplabv3_r101-d8_512x1024_40k_cityscapes_20200605_012241.log.json)                             |
-| DeepLabV3        | R-50-D8         | 769x769   |   40000 | 6.9      | 1.11           | V100   | 78.58 |         79.89 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-769x769.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_769x769_40k_cityscapes/deeplabv3_r50-d8_769x769_40k_cityscapes_20200606_113723-7eda553c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_769x769_40k_cityscapes/deeplabv3_r50-d8_769x769_40k_cityscapes_20200606_113723.log.json)                                     |
-| DeepLabV3        | R-101-D8        | 769x769   |   40000 | 10.9     | 0.83           | V100   | 79.27 |         80.11 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-769x769.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_769x769_40k_cityscapes/deeplabv3_r101-d8_769x769_40k_cityscapes_20200606_113809-c64f889f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_769x769_40k_cityscapes/deeplabv3_r101-d8_769x769_40k_cityscapes_20200606_113809.log.json)                                 |
-| DeepLabV3        | R-18-D8         | 512x1024  |   80000 | 1.7      | 13.78          | V100   | 76.70 |         78.27 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-512x1024.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18-d8_512x1024_80k_cityscapes/deeplabv3_r18-d8_512x1024_80k_cityscapes_20201225_021506-23dffbe2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18-d8_512x1024_80k_cityscapes/deeplabv3_r18-d8_512x1024_80k_cityscapes-20201225_021506.log.json)                                 |
-| DeepLabV3        | R-50-D8         | 512x1024  |   80000 | -        | -              | V100   | 79.32 |         80.57 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x1024_80k_cityscapes/deeplabv3_r50-d8_512x1024_80k_cityscapes_20200606_113404-b92cfdd4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x1024_80k_cityscapes/deeplabv3_r50-d8_512x1024_80k_cityscapes_20200606_113404.log.json)                                 |
-| DeepLabV3        | R-101-D8        | 512x1024  |   80000 | -        | -              | V100   | 80.20 |         81.21 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-512x1024.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x1024_80k_cityscapes/deeplabv3_r101-d8_512x1024_80k_cityscapes_20200606_113503-9e428899.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x1024_80k_cityscapes/deeplabv3_r101-d8_512x1024_80k_cityscapes_20200606_113503.log.json)                             |
-| DeepLabV3 (FP16) | R-101-D8        | 512x1024  |   80000 | 5.75     | 3.86           | V100   | 80.48 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_fp16_512x1024_80k_cityscapes/deeplabv3_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230920-774d9cec.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_fp16_512x1024_80k_cityscapes/deeplabv3_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230920.log.json)         |
-| DeepLabV3        | R-18-D8         | 769x769   |   80000 | 1.9      | 5.55           | V100   | 76.60 |         78.26 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-769x769.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18-d8_769x769_80k_cityscapes/deeplabv3_r18-d8_769x769_80k_cityscapes_20201225_021506-6452126a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18-d8_769x769_80k_cityscapes/deeplabv3_r18-d8_769x769_80k_cityscapes-20201225_021506.log.json)                                     |
-| DeepLabV3        | R-50-D8         | 769x769   |   80000 | -        | -              | V100   | 79.89 |         81.06 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_769x769_80k_cityscapes/deeplabv3_r50-d8_769x769_80k_cityscapes_20200606_221338-788d6228.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_769x769_80k_cityscapes/deeplabv3_r50-d8_769x769_80k_cityscapes_20200606_221338.log.json)                                     |
-| DeepLabV3        | R-101-D8        | 769x769   |   80000 | -        | -              | V100   | 79.67 |         80.81 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-769x769.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_769x769_80k_cityscapes/deeplabv3_r101-d8_769x769_80k_cityscapes_20200607_013353-60e95418.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_769x769_80k_cityscapes/deeplabv3_r101-d8_769x769_80k_cityscapes_20200607_013353.log.json)                                 |
-| DeepLabV3        | R-101-D16-MG124 | 512x1024  |   40000 | 4.7      | 6.96           | V100   | 76.71 |         78.63 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d16-mg124_512x1024_40k_cityscapes/deeplabv3_r101-d16-mg124_512x1024_40k_cityscapes_20200908_005644-67b0c992.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d16-mg124_512x1024_40k_cityscapes/deeplabv3_r101-d16-mg124_512x1024_40k_cityscapes-20200908_005644.log.json) |
-| DeepLabV3        | R-101-D16-MG124 | 512x1024  |   80000 | -        | -              | V100   | 78.36 |         79.84 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d16-mg124_512x1024_80k_cityscapes/deeplabv3_r101-d16-mg124_512x1024_80k_cityscapes_20200908_005644-57bb8425.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d16-mg124_512x1024_80k_cityscapes/deeplabv3_r101-d16-mg124_512x1024_80k_cityscapes-20200908_005644.log.json) |
-| DeepLabV3        | R-18b-D8        | 512x1024  |   80000 | 1.6      | 13.93          | V100   | 76.26 |         77.88 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-512x1024.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18b-d8_512x1024_80k_cityscapes/deeplabv3_r18b-d8_512x1024_80k_cityscapes_20201225_094144-46040cef.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18b-d8_512x1024_80k_cityscapes/deeplabv3_r18b-d8_512x1024_80k_cityscapes-20201225_094144.log.json)                             |
-| DeepLabV3        | R-50b-D8        | 512x1024  |   80000 | 6.0      | 2.74           | V100   | 79.63 |         80.98 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-512x1024.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50b-d8_512x1024_80k_cityscapes/deeplabv3_r50b-d8_512x1024_80k_cityscapes_20201225_155148-ec368954.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50b-d8_512x1024_80k_cityscapes/deeplabv3_r50b-d8_512x1024_80k_cityscapes-20201225_155148.log.json)                             |
-| DeepLabV3        | R-101b-D8       | 512x1024  |   80000 | 9.5      | 1.81           | V100   | 80.01 |         81.21 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-512x1024.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101b-d8_512x1024_80k_cityscapes/deeplabv3_r101b-d8_512x1024_80k_cityscapes_20201226_171821-8fd49503.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101b-d8_512x1024_80k_cityscapes/deeplabv3_r101b-d8_512x1024_80k_cityscapes-20201226_171821.log.json)                         |
-| DeepLabV3        | R-18b-D8        | 769x769   |   80000 | 1.8      | 5.79           | V100   | 75.63 |         77.51 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-769x769.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18b-d8_769x769_80k_cityscapes/deeplabv3_r18b-d8_769x769_80k_cityscapes_20201225_094144-fdc985d9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18b-d8_769x769_80k_cityscapes/deeplabv3_r18b-d8_769x769_80k_cityscapes-20201225_094144.log.json)                                 |
-| DeepLabV3        | R-50b-D8        | 769x769   |   80000 | 6.8      | 1.16           | V100   | 78.80 |         80.27 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-769x769.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50b-d8_769x769_80k_cityscapes/deeplabv3_r50b-d8_769x769_80k_cityscapes_20201225_155404-87fb0cf4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50b-d8_769x769_80k_cityscapes/deeplabv3_r50b-d8_769x769_80k_cityscapes-20201225_155404.log.json)                                 |
-| DeepLabV3        | R-101b-D8       | 769x769   |   80000 | 10.7     | 0.82           | V100   | 79.41 |         80.73 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-769x769.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101b-d8_769x769_80k_cityscapes/deeplabv3_r101b-d8_769x769_80k_cityscapes_20201226_190843-9142ee57.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101b-d8_769x769_80k_cityscapes/deeplabv3_r101b-d8_769x769_80k_cityscapes-20201226_190843.log.json)                             |
-
-### ADE20K
-
-| Method    | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                           | download                                                                                                                                                                                                                                                                                                                                                   |
-| --------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| DeepLabV3 | R-50-D8  | 512x512   |   80000 | 8.9      | 14.76          | V100   | 42.42 |         43.28 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_80k_ade20k/deeplabv3_r50-d8_512x512_80k_ade20k_20200614_185028-0bb3f844.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_80k_ade20k/deeplabv3_r50-d8_512x512_80k_ade20k_20200614_185028.log.json)         |
-| DeepLabV3 | R-101-D8 | 512x512   |   80000 | 12.4     | 10.14          | V100   | 44.08 |         45.19 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_80k_ade20k/deeplabv3_r101-d8_512x512_80k_ade20k_20200615_021256-d89c7fa4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_80k_ade20k/deeplabv3_r101-d8_512x512_80k_ade20k_20200615_021256.log.json)     |
-| DeepLabV3 | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 42.66 |         44.09 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_160k_ade20k/deeplabv3_r50-d8_512x512_160k_ade20k_20200615_123227-5d0ee427.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_160k_ade20k/deeplabv3_r50-d8_512x512_160k_ade20k_20200615_123227.log.json)     |
-| DeepLabV3 | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 45.00 |         46.66 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_160k_ade20k/deeplabv3_r101-d8_512x512_160k_ade20k_20200615_105816-b1f72b3b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_160k_ade20k/deeplabv3_r101-d8_512x512_160k_ade20k_20200615_105816.log.json) |
-
-### Pascal VOC 2012 + Aug
-
-| Method    | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                            | download                                                                                                                                                                                                                                                                                                                                                       |
-| --------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | --------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| DeepLabV3 | R-50-D8  | 512x512   |   20000 | 6.1      | 13.88          | V100   | 76.17 |         77.42 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_20k_voc12aug/deeplabv3_r50-d8_512x512_20k_voc12aug_20200617_010906-596905ef.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_20k_voc12aug/deeplabv3_r50-d8_512x512_20k_voc12aug_20200617_010906.log.json)     |
-| DeepLabV3 | R-101-D8 | 512x512   |   20000 | 9.6      | 9.81           | V100   | 78.70 |         79.95 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_20k_voc12aug/deeplabv3_r101-d8_512x512_20k_voc12aug_20200617_010932-8d13832f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_20k_voc12aug/deeplabv3_r101-d8_512x512_20k_voc12aug_20200617_010932.log.json) |
-| DeepLabV3 | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 77.68 |         78.78 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_40k_voc12aug/deeplabv3_r50-d8_512x512_40k_voc12aug_20200613_161546-2ae96e7e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_40k_voc12aug/deeplabv3_r50-d8_512x512_40k_voc12aug_20200613_161546.log.json)     |
-| DeepLabV3 | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 77.92 |         79.18 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_40k_voc12aug/deeplabv3_r101-d8_512x512_40k_voc12aug_20200613_161432-0017d784.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_40k_voc12aug/deeplabv3_r101-d8_512x512_40k_voc12aug_20200613_161432.log.json) |
-
-### Pascal Context
-
-| Method    | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                  | download                                                                                                                                                                                                                                                                                                                                                                               |
-| --------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | --------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| DeepLabV3 | R-101-D8 | 480x480   |   40000 | 9.2      | 7.09           | V100   | 46.55 |         47.81 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_40k_pascal_context/deeplabv3_r101-d8_480x480_40k_pascal_context_20200911_204118-1aa27336.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_40k_pascal_context/deeplabv3_r101-d8_480x480_40k_pascal_context-20200911_204118.log.json) |
-| DeepLabV3 | R-101-D8 | 480x480   |   80000 | -        | -              | V100   | 46.42 |         47.53 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_80k_pascal_context/deeplabv3_r101-d8_480x480_80k_pascal_context_20200911_170155-2a21fff3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_80k_pascal_context/deeplabv3_r101-d8_480x480_80k_pascal_context-20200911_170155.log.json) |
-
-### Pascal Context 59
-
-| Method    | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                     | download                                                                                                                                                                                                                                                                                                                                                                                           |
-| --------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| DeepLabV3 | R-101-D8 | 480x480   |   40000 | -        | -              | V100   | 52.61 |         54.28 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-59-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_40k_pascal_context_59/deeplabv3_r101-d8_480x480_40k_pascal_context_59_20210416_110332-cb08ea46.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_40k_pascal_context_59/deeplabv3_r101-d8_480x480_40k_pascal_context_59-20210416_110332.log.json) |
-| DeepLabV3 | R-101-D8 | 480x480   |   80000 | -        | -              | V100   | 52.46 |         54.09 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-59-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_80k_pascal_context_59/deeplabv3_r101-d8_480x480_80k_pascal_context_59_20210416_113002-26303993.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_80k_pascal_context_59/deeplabv3_r101-d8_480x480_80k_pascal_context_59-20210416_113002.log.json) |
-
-### COCO-Stuff 10k
-
-| Method    | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                 | download                                                                                                                                                                                                                                                                                                                                                                                           |
-| --------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| DeepLabV3 | R-50-D8  | 512x512   |   20000 | 9.6      | 10.8           | V100   | 34.66 |         36.08 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_coco-stuff10k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_20k_coco-stuff10k/deeplabv3_r50-d8_512x512_4x4_20k_coco-stuff10k_20210821_043025-b35f789d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_20k_coco-stuff10k/deeplabv3_r50-d8_512x512_4x4_20k_coco-stuff10k_20210821_043025.log.json)     |
-| DeepLabV3 | R-101-D8 | 512x512   |   20000 | 13.2     | 8.7            | V100   | 37.30 |         38.42 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_coco-stuff10k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_20k_coco-stuff10k/deeplabv3_r101-d8_512x512_4x4_20k_coco-stuff10k_20210821_043025-c49752cb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_20k_coco-stuff10k/deeplabv3_r101-d8_512x512_4x4_20k_coco-stuff10k_20210821_043025.log.json) |
-| DeepLabV3 | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 35.73 |         37.09 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_coco-stuff10k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_40k_coco-stuff10k/deeplabv3_r50-d8_512x512_4x4_40k_coco-stuff10k_20210821_043305-dc76f3ff.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_40k_coco-stuff10k/deeplabv3_r50-d8_512x512_4x4_40k_coco-stuff10k_20210821_043305.log.json)     |
-| DeepLabV3 | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 37.81 |         38.80 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_coco-stuff10k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_40k_coco-stuff10k/deeplabv3_r101-d8_512x512_4x4_40k_coco-stuff10k_20210821_043305-636cb433.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_40k_coco-stuff10k/deeplabv3_r101-d8_512x512_4x4_40k_coco-stuff10k_20210821_043305.log.json) |
-
-### COCO-Stuff 164k
-
-| Method    | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                   | download                                                                                                                                                                                                                                                                                                                                                                                                   |
-| --------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| DeepLabV3 | R-50-D8  | 512x512   |   80000 | 9.6      | 10.8           | V100   | 39.38 |         40.03 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_coco-stuff164k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_80k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_80k_coco-stuff164k_20210709_163016-88675c24.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_80k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_80k_coco-stuff164k_20210709_163016.log.json)         |
-| DeepLabV3 | R-101-D8 | 512x512   |   80000 | 13.2     | 8.7            | V100   | 40.87 |         41.50 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_coco-stuff164k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_80k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_80k_coco-stuff164k_20210709_201252-13600dc2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_80k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_80k_coco-stuff164k_20210709_201252.log.json)     |
-| DeepLabV3 | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 41.09 |         41.69 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_coco-stuff164k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_160k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_160k_coco-stuff164k_20210709_163016-49f2812b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_160k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_160k_coco-stuff164k_20210709_163016.log.json)     |
-| DeepLabV3 | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 41.82 |         42.49 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_coco-stuff164k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_160k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_160k_coco-stuff164k_20210709_155402-f035acfd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_160k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_160k_coco-stuff164k_20210709_155402.log.json) |
-| DeepLabV3 | R-50-D8  | 512x512   |  320000 | -        | -              | V100   | 41.37 |         42.22 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r50-d8_4xb4-320k_coco-stuff164k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_320k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_320k_coco-stuff164k_20210709_155403-51b21115.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_320k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_320k_coco-stuff164k_20210709_155403.log.json)     |
-| DeepLabV3 | R-101-D8 | 512x512   |  320000 | -        | -              | V100   | 42.61 |         43.42 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3/deeplabv3_r101-d8_4xb4-320k_coco-stuff164k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_320k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_320k_coco-stuff164k_20210709_155402-3cbca14d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_320k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_320k_coco-stuff164k_20210709_155402.log.json) |
-
-Note:
-
-- `D-8` here corresponding to the output stride 8 setting for DeepLab series.
-- `FP16` means Mixed Precision (FP16) is adopted in training.
-
-## Citation
-
-```bibtext
-@article{chen2017rethinking,
-  title={Rethinking atrous convolution for semantic image segmentation},
-  author={Chen, Liang-Chieh and Papandreou, George and Schroff, Florian and Adam, Hartwig},
-  journal={arXiv preprint arXiv:1706.05587},
-  year={2017}
-}
-```
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index b9f3c17..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='open-mmlab://resnet101_v1c',
-    backbone=dict(
-        depth=101,
-        dilations=(1, 1, 1, 2),
-        strides=(1, 2, 2, 1),
-        multi_grid=(1, 2, 4)),
-    decode_head=dict(
-        dilations=(1, 6, 12, 18),
-        sampler=dict(type='OHEMPixelSampler', min_kept=100000)))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index da3a88f..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='open-mmlab://resnet101_v1c',
-    backbone=dict(
-        depth=101,
-        dilations=(1, 1, 1, 2),
-        strides=(1, 2, 2, 1),
-        multi_grid=(1, 2, 4)),
-    decode_head=dict(
-        dilations=(1, 6, 12, 18),
-        sampler=dict(type='OHEMPixelSampler', min_kept=100000)))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index d01803c..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index 7964b51..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb2-40k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 1d1a620..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 7820546..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
deleted file mode 100644
index 8417416..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = './deeplabv3_r101-d8_4xb2-40k_cityscapes-512x1024.py'
-optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
-optim_wrapper = dict(
-    _delete_=True,
-    type='AmpOptimWrapper',
-    optimizer=optimizer,
-    loss_scale=512.)
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 0ed6eee..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb4-160k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_coco-stuff164k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_coco-stuff164k-512x512.py
deleted file mode 100644
index add0083..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_coco-stuff164k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb4-160k_coco-stuff164k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_coco-stuff10k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_coco-stuff10k-512x512.py
deleted file mode 100644
index 349cc88..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_coco-stuff10k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb4-20k_coco-stuff10k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index 1c527e0..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb4-20k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-320k_coco-stuff164k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-320k_coco-stuff164k-512x512.py
deleted file mode 100644
index ea27bed..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-320k_coco-stuff164k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb4-320k_coco-stuff164k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_coco-stuff10k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_coco-stuff10k-512x512.py
deleted file mode 100644
index a43a786..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_coco-stuff10k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb4-40k_coco-stuff10k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-480x480.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-480x480.py
deleted file mode 100644
index 8879d53..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-480x480.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb4-40k_pascal-context-480x480.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-59-480x480.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-59-480x480.py
deleted file mode 100644
index 54671d4..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-59-480x480.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb4-40k_pascal-context-59-480x480.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index 1b2635d..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb4-40k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index b7bb0b6..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb4-80k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_coco-stuff164k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_coco-stuff164k-512x512.py
deleted file mode 100644
index 2d4f6f7..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_coco-stuff164k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb4-80k_coco-stuff164k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-480x480.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-480x480.py
deleted file mode 100644
index 9d64ca2..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-480x480.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb4-80k_pascal-context-480x480.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-59-480x480.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-59-480x480.py
deleted file mode 100644
index 54671d4..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-59-480x480.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb4-40k_pascal-context-59-480x480.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 708932d..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,4 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='torchvision://resnet101',
-    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index a0f634d..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,4 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(
-    pretrained='torchvision://resnet101',
-    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index bc353bb..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='open-mmlab://resnet18_v1c',
-    backbone=dict(depth=18),
-    decode_head=dict(
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 021c98c..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(
-    pretrained='open-mmlab://resnet18_v1c',
-    backbone=dict(depth=18),
-    decode_head=dict(
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index c747cd7..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='torchvision://resnet18',
-    backbone=dict(type='ResNet', depth=18),
-    decode_head=dict(
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 6506abf..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(
-    pretrained='torchvision://resnet18',
-    backbone=dict(type='ResNet', depth=18),
-    decode_head=dict(
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 4a2a971..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index a52f29e..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 1bd29b9..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 27f0fc4..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 04e15f0..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_coco-stuff164k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_coco-stuff164k-512x512.py
deleted file mode 100644
index ba76a59..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_coco-stuff164k-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_r50-d8.py',
-    '../_base_/datasets/coco-stuff164k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=171),
-    auxiliary_head=dict(num_classes=171))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_coco-stuff10k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_coco-stuff10k-512x512.py
deleted file mode 100644
index d0559c8..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_coco-stuff10k-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_r50-d8.py',
-    '../_base_/datasets/coco-stuff10k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_20k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=171),
-    auxiliary_head=dict(num_classes=171))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index c5458d9..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_r50-d8.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_20k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-320k_coco-stuff164k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-320k_coco-stuff164k-512x512.py
deleted file mode 100644
index c3b4f94..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-320k_coco-stuff164k-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_r50-d8.py',
-    '../_base_/datasets/coco-stuff164k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_320k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=171),
-    auxiliary_head=dict(num_classes=171))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_coco-stuff10k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_coco-stuff10k-512x512.py
deleted file mode 100644
index 40dbffa..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_coco-stuff10k-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_r50-d8.py',
-    '../_base_/datasets/coco-stuff10k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=171),
-    auxiliary_head=dict(num_classes=171))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_pascal-context-480x480.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_pascal-context-480x480.py
deleted file mode 100644
index 3c4e753..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_pascal-context-480x480.py
+++ /dev/null
@@ -1,14 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_r50-d8.py',
-    '../_base_/datasets/pascal_context.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (480, 480)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=60),
-    auxiliary_head=dict(num_classes=60),
-    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_pascal-context-59-480x480.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_pascal-context-59-480x480.py
deleted file mode 100644
index e3b6c36..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_pascal-context-59-480x480.py
+++ /dev/null
@@ -1,14 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_r50-d8.py',
-    '../_base_/datasets/pascal_context_59.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (480, 480)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=59),
-    auxiliary_head=dict(num_classes=59),
-    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index 8333cc6..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_r50-d8.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 0bcdab5..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_coco-stuff164k-512x512.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_coco-stuff164k-512x512.py
deleted file mode 100644
index 519df5a..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_coco-stuff164k-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_r50-d8.py',
-    '../_base_/datasets/coco-stuff164k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=171),
-    auxiliary_head=dict(num_classes=171))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_pascal-context-480x480.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_pascal-context-480x480.py
deleted file mode 100644
index ba8c7de..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_pascal-context-480x480.py
+++ /dev/null
@@ -1,14 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_r50-d8.py',
-    '../_base_/datasets/pascal_context.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (480, 480)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=60),
-    auxiliary_head=dict(num_classes=60),
-    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_pascal-context-59-480x480.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_pascal-context-59-480x480.py
deleted file mode 100644
index d34bd89..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_pascal-context-59-480x480.py
+++ /dev/null
@@ -1,14 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_r50-d8.py',
-    '../_base_/datasets/pascal_context_59.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (480, 480)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=59),
-    auxiliary_head=dict(num_classes=59),
-    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 818519f..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='torchvision://resnet50', backbone=dict(type='ResNet'))
diff --git a/mmsegmentation/configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 07a234b..0000000
--- a/mmsegmentation/configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(pretrained='torchvision://resnet50', backbone=dict(type='ResNet'))
diff --git a/mmsegmentation/configs/deeplabv3/metafile.yaml b/mmsegmentation/configs/deeplabv3/metafile.yaml
deleted file mode 100644
index 650f7d6..0000000
--- a/mmsegmentation/configs/deeplabv3/metafile.yaml
+++ /dev/null
@@ -1,985 +0,0 @@
-Collections:
-- Name: DeepLabV3
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-    - ADE20K
-    - Pascal VOC 2012 + Aug
-    - Pascal Context
-    - Pascal Context 59
-    - COCO-Stuff 10k
-    - COCO-Stuff 164k
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  README: configs/deeplabv3/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.09
-      mIoU(ms+flip): 80.45
-  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x1024_40k_cityscapes/deeplabv3_r50-d8_512x1024_40k_cityscapes_20200605_022449-acadc2f8.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x1024_40k_cityscapes/deeplabv3_r50-d8_512x1024_40k_cityscapes_20200605_022449.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r101-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.12
-      mIoU(ms+flip): 79.61
-  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x1024_40k_cityscapes/deeplabv3_r101-d8_512x1024_40k_cityscapes_20200605_012241-7fd3f799.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x1024_40k_cityscapes/deeplabv3_r101-d8_512x1024_40k_cityscapes_20200605_012241.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r50-d8_4xb2-40k_cityscapes-769x769
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.58
-      mIoU(ms+flip): 79.89
-  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_769x769_40k_cityscapes/deeplabv3_r50-d8_769x769_40k_cityscapes_20200606_113723-7eda553c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_769x769_40k_cityscapes/deeplabv3_r50-d8_769x769_40k_cityscapes_20200606_113723.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r101-d8_4xb2-40k_cityscapes-769x769
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.27
-      mIoU(ms+flip): 80.11
-  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_769x769_40k_cityscapes/deeplabv3_r101-d8_769x769_40k_cityscapes_20200606_113809-c64f889f.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_769x769_40k_cityscapes/deeplabv3_r101-d8_769x769_40k_cityscapes_20200606_113809.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r18-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.7
-      mIoU(ms+flip): 78.27
-  Config: configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-18-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.7
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18-d8_512x1024_80k_cityscapes/deeplabv3_r18-d8_512x1024_80k_cityscapes_20201225_021506-23dffbe2.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18-d8_512x1024_80k_cityscapes/deeplabv3_r18-d8_512x1024_80k_cityscapes-20201225_021506.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.32
-      mIoU(ms+flip): 80.57
-  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x1024_80k_cityscapes/deeplabv3_r50-d8_512x1024_80k_cityscapes_20200606_113404-b92cfdd4.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x1024_80k_cityscapes/deeplabv3_r50-d8_512x1024_80k_cityscapes_20200606_113404.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r101-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 80.2
-      mIoU(ms+flip): 81.21
-  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x1024_80k_cityscapes/deeplabv3_r101-d8_512x1024_80k_cityscapes_20200606_113503-9e428899.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x1024_80k_cityscapes/deeplabv3_r101-d8_512x1024_80k_cityscapes_20200606_113503.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r101-d8_4xb2-amp-80k_cityscapes-512x1024
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 80.48
-  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - DeepLabV3
-    - (FP16)
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.75
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_fp16_512x1024_80k_cityscapes/deeplabv3_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230920-774d9cec.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_fp16_512x1024_80k_cityscapes/deeplabv3_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230920.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r18-d8_4xb2-80k_cityscapes-769x769
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.6
-      mIoU(ms+flip): 78.26
-  Config: configs/deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-18-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18-d8_769x769_80k_cityscapes/deeplabv3_r18-d8_769x769_80k_cityscapes_20201225_021506-6452126a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18-d8_769x769_80k_cityscapes/deeplabv3_r18-d8_769x769_80k_cityscapes-20201225_021506.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.89
-      mIoU(ms+flip): 81.06
-  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_769x769_80k_cityscapes/deeplabv3_r50-d8_769x769_80k_cityscapes_20200606_221338-788d6228.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_769x769_80k_cityscapes/deeplabv3_r50-d8_769x769_80k_cityscapes_20200606_221338.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r101-d8_4xb2-80k_cityscapes-769x769
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.67
-      mIoU(ms+flip): 80.81
-  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_769x769_80k_cityscapes/deeplabv3_r101-d8_769x769_80k_cityscapes_20200607_013353-60e95418.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_769x769_80k_cityscapes/deeplabv3_r101-d8_769x769_80k_cityscapes_20200607_013353.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r101-d16-mg124_4xb2-40k_cityscapes-512x1024
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.71
-      mIoU(ms+flip): 78.63
-  Config: configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D16-MG124
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 4.7
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d16-mg124_512x1024_40k_cityscapes/deeplabv3_r101-d16-mg124_512x1024_40k_cityscapes_20200908_005644-67b0c992.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d16-mg124_512x1024_40k_cityscapes/deeplabv3_r101-d16-mg124_512x1024_40k_cityscapes-20200908_005644.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r101-d16-mg124_4xb2-80k_cityscapes-512x1024
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.36
-      mIoU(ms+flip): 79.84
-  Config: configs/deeplabv3/deeplabv3_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D16-MG124
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d16-mg124_512x1024_80k_cityscapes/deeplabv3_r101-d16-mg124_512x1024_80k_cityscapes_20200908_005644-57bb8425.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d16-mg124_512x1024_80k_cityscapes/deeplabv3_r101-d16-mg124_512x1024_80k_cityscapes-20200908_005644.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r18b-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.26
-      mIoU(ms+flip): 77.88
-  Config: configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-18b-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18b-d8_512x1024_80k_cityscapes/deeplabv3_r18b-d8_512x1024_80k_cityscapes_20201225_094144-46040cef.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18b-d8_512x1024_80k_cityscapes/deeplabv3_r18b-d8_512x1024_80k_cityscapes-20201225_094144.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r50b-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.63
-      mIoU(ms+flip): 80.98
-  Config: configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50b-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50b-d8_512x1024_80k_cityscapes/deeplabv3_r50b-d8_512x1024_80k_cityscapes_20201225_155148-ec368954.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50b-d8_512x1024_80k_cityscapes/deeplabv3_r50b-d8_512x1024_80k_cityscapes-20201225_155148.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r101b-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 80.01
-      mIoU(ms+flip): 81.21
-  Config: configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101b-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101b-d8_512x1024_80k_cityscapes/deeplabv3_r101b-d8_512x1024_80k_cityscapes_20201226_171821-8fd49503.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101b-d8_512x1024_80k_cityscapes/deeplabv3_r101b-d8_512x1024_80k_cityscapes-20201226_171821.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r18b-d8_4xb2-80k_cityscapes-769x769
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 75.63
-      mIoU(ms+flip): 77.51
-  Config: configs/deeplabv3/deeplabv3_r18b-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-18b-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18b-d8_769x769_80k_cityscapes/deeplabv3_r18b-d8_769x769_80k_cityscapes_20201225_094144-fdc985d9.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r18b-d8_769x769_80k_cityscapes/deeplabv3_r18b-d8_769x769_80k_cityscapes-20201225_094144.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r50b-d8_4xb2-80k_cityscapes-769x769
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.8
-      mIoU(ms+flip): 80.27
-  Config: configs/deeplabv3/deeplabv3_r50b-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50b-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50b-d8_769x769_80k_cityscapes/deeplabv3_r50b-d8_769x769_80k_cityscapes_20201225_155404-87fb0cf4.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50b-d8_769x769_80k_cityscapes/deeplabv3_r50b-d8_769x769_80k_cityscapes-20201225_155404.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r101b-d8_4xb2-80k_cityscapes-769x769
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.41
-      mIoU(ms+flip): 80.73
-  Config: configs/deeplabv3/deeplabv3_r101b-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101b-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.7
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101b-d8_769x769_80k_cityscapes/deeplabv3_r101b-d8_769x769_80k_cityscapes_20201226_190843-9142ee57.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101b-d8_769x769_80k_cityscapes/deeplabv3_r101b-d8_769x769_80k_cityscapes-20201226_190843.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r50-d8_4xb4-80k_ade20k-512x512
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.42
-      mIoU(ms+flip): 43.28
-  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_80k_ade20k/deeplabv3_r50-d8_512x512_80k_ade20k_20200614_185028-0bb3f844.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_80k_ade20k/deeplabv3_r50-d8_512x512_80k_ade20k_20200614_185028.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r101-d8_4xb4-80k_ade20k-512x512
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 44.08
-      mIoU(ms+flip): 45.19
-  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 12.4
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_80k_ade20k/deeplabv3_r101-d8_512x512_80k_ade20k_20200615_021256-d89c7fa4.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_80k_ade20k/deeplabv3_r101-d8_512x512_80k_ade20k_20200615_021256.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r50-d8_4xb4-160k_ade20k-512x512
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.66
-      mIoU(ms+flip): 44.09
-  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_160k_ade20k/deeplabv3_r50-d8_512x512_160k_ade20k_20200615_123227-5d0ee427.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_160k_ade20k/deeplabv3_r50-d8_512x512_160k_ade20k_20200615_123227.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r101-d8_4xb4-160k_ade20k-512x512
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 45.0
-      mIoU(ms+flip): 46.66
-  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_160k_ade20k/deeplabv3_r101-d8_512x512_160k_ade20k_20200615_105816-b1f72b3b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_160k_ade20k/deeplabv3_r101-d8_512x512_160k_ade20k_20200615_105816.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r50-d8_4xb4-20k_voc12aug-512x512
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 76.17
-      mIoU(ms+flip): 77.42
-  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_20k_voc12aug/deeplabv3_r50-d8_512x512_20k_voc12aug_20200617_010906-596905ef.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_20k_voc12aug/deeplabv3_r50-d8_512x512_20k_voc12aug_20200617_010906.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r101-d8_4xb4-20k_voc12aug-512x512
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 78.7
-      mIoU(ms+flip): 79.95
-  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_20k_voc12aug/deeplabv3_r101-d8_512x512_20k_voc12aug_20200617_010932-8d13832f.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_20k_voc12aug/deeplabv3_r101-d8_512x512_20k_voc12aug_20200617_010932.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r50-d8_4xb4-40k_voc12aug-512x512
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 77.68
-      mIoU(ms+flip): 78.78
-  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_40k_voc12aug/deeplabv3_r50-d8_512x512_40k_voc12aug_20200613_161546-2ae96e7e.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_40k_voc12aug/deeplabv3_r50-d8_512x512_40k_voc12aug_20200613_161546.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r101-d8_4xb4-40k_voc12aug-512x512
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 77.92
-      mIoU(ms+flip): 79.18
-  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_40k_voc12aug/deeplabv3_r101-d8_512x512_40k_voc12aug_20200613_161432-0017d784.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_40k_voc12aug/deeplabv3_r101-d8_512x512_40k_voc12aug_20200613_161432.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r101-d8_4xb4-40k_pascal-context-480x480
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal Context
-    Metrics:
-      mIoU: 46.55
-      mIoU(ms+flip): 47.81
-  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-480x480.py
-  Metadata:
-    Training Data: Pascal Context
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_40k_pascal_context/deeplabv3_r101-d8_480x480_40k_pascal_context_20200911_204118-1aa27336.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_40k_pascal_context/deeplabv3_r101-d8_480x480_40k_pascal_context-20200911_204118.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r101-d8_4xb4-80k_pascal-context-480x480
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal Context
-    Metrics:
-      mIoU: 46.42
-      mIoU(ms+flip): 47.53
-  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-480x480.py
-  Metadata:
-    Training Data: Pascal Context
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_80k_pascal_context/deeplabv3_r101-d8_480x480_80k_pascal_context_20200911_170155-2a21fff3.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_80k_pascal_context/deeplabv3_r101-d8_480x480_80k_pascal_context-20200911_170155.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r101-d8_4xb4-40k_pascal-context-59-480x480
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal Context 59
-    Metrics:
-      mIoU: 52.61
-      mIoU(ms+flip): 54.28
-  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_pascal-context-59-480x480.py
-  Metadata:
-    Training Data: Pascal Context 59
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_40k_pascal_context_59/deeplabv3_r101-d8_480x480_40k_pascal_context_59_20210416_110332-cb08ea46.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_40k_pascal_context_59/deeplabv3_r101-d8_480x480_40k_pascal_context_59-20210416_110332.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r101-d8_4xb4-80k_pascal-context-59-480x480
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal Context 59
-    Metrics:
-      mIoU: 52.46
-      mIoU(ms+flip): 54.09
-  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_pascal-context-59-480x480.py
-  Metadata:
-    Training Data: Pascal Context 59
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_80k_pascal_context_59/deeplabv3_r101-d8_480x480_80k_pascal_context_59_20210416_113002-26303993.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_480x480_80k_pascal_context_59/deeplabv3_r101-d8_480x480_80k_pascal_context_59-20210416_113002.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r50-d8_4xb4-20k_coco-stuff10k-512x512
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 10k
-    Metrics:
-      mIoU: 34.66
-      mIoU(ms+flip): 36.08
-  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb4-20k_coco-stuff10k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 10k
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_20k_coco-stuff10k/deeplabv3_r50-d8_512x512_4x4_20k_coco-stuff10k_20210821_043025-b35f789d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_20k_coco-stuff10k/deeplabv3_r50-d8_512x512_4x4_20k_coco-stuff10k_20210821_043025.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r101-d8_4xb4-20k_coco-stuff10k-512x512
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 10k
-    Metrics:
-      mIoU: 37.3
-      mIoU(ms+flip): 38.42
-  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-20k_coco-stuff10k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 10k
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 13.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_20k_coco-stuff10k/deeplabv3_r101-d8_512x512_4x4_20k_coco-stuff10k_20210821_043025-c49752cb.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_20k_coco-stuff10k/deeplabv3_r101-d8_512x512_4x4_20k_coco-stuff10k_20210821_043025.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r50-d8_4xb4-40k_coco-stuff10k-512x512
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 10k
-    Metrics:
-      mIoU: 35.73
-      mIoU(ms+flip): 37.09
-  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb4-40k_coco-stuff10k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 10k
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_40k_coco-stuff10k/deeplabv3_r50-d8_512x512_4x4_40k_coco-stuff10k_20210821_043305-dc76f3ff.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_40k_coco-stuff10k/deeplabv3_r50-d8_512x512_4x4_40k_coco-stuff10k_20210821_043305.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r101-d8_4xb4-40k_coco-stuff10k-512x512
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 10k
-    Metrics:
-      mIoU: 37.81
-      mIoU(ms+flip): 38.8
-  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-40k_coco-stuff10k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 10k
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_40k_coco-stuff10k/deeplabv3_r101-d8_512x512_4x4_40k_coco-stuff10k_20210821_043305-636cb433.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_40k_coco-stuff10k/deeplabv3_r101-d8_512x512_4x4_40k_coco-stuff10k_20210821_043305.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r50-d8_4xb4-80k_coco-stuff164k-512x512
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 164k
-    Metrics:
-      mIoU: 39.38
-      mIoU(ms+flip): 40.03
-  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb4-80k_coco-stuff164k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 164k
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_80k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_80k_coco-stuff164k_20210709_163016-88675c24.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_80k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_80k_coco-stuff164k_20210709_163016.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r101-d8_4xb4-80k_coco-stuff164k-512x512
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 164k
-    Metrics:
-      mIoU: 40.87
-      mIoU(ms+flip): 41.5
-  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-80k_coco-stuff164k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 164k
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 13.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_80k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_80k_coco-stuff164k_20210709_201252-13600dc2.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_80k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_80k_coco-stuff164k_20210709_201252.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r50-d8_4xb4-160k_coco-stuff164k-512x512
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 164k
-    Metrics:
-      mIoU: 41.09
-      mIoU(ms+flip): 41.69
-  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb4-160k_coco-stuff164k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 164k
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_160k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_160k_coco-stuff164k_20210709_163016-49f2812b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_160k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_160k_coco-stuff164k_20210709_163016.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r101-d8_4xb4-160k_coco-stuff164k-512x512
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 164k
-    Metrics:
-      mIoU: 41.82
-      mIoU(ms+flip): 42.49
-  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-160k_coco-stuff164k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 164k
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_160k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_160k_coco-stuff164k_20210709_155402-f035acfd.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_160k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_160k_coco-stuff164k_20210709_155402.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r50-d8_4xb4-320k_coco-stuff164k-512x512
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 164k
-    Metrics:
-      mIoU: 41.37
-      mIoU(ms+flip): 42.22
-  Config: configs/deeplabv3/deeplabv3_r50-d8_4xb4-320k_coco-stuff164k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 164k
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_320k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_320k_coco-stuff164k_20210709_155403-51b21115.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_4x4_320k_coco-stuff164k/deeplabv3_r50-d8_512x512_4x4_320k_coco-stuff164k_20210709_155403.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
-- Name: deeplabv3_r101-d8_4xb4-320k_coco-stuff164k-512x512
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 164k
-    Metrics:
-      mIoU: 42.61
-      mIoU(ms+flip): 43.42
-  Config: configs/deeplabv3/deeplabv3_r101-d8_4xb4-320k_coco-stuff164k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 164k
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_320k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_320k_coco-stuff164k_20210709_155402-3cbca14d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r101-d8_512x512_4x4_320k_coco-stuff164k/deeplabv3_r101-d8_512x512_4x4_320k_coco-stuff164k_20210709_155402.log.json
-  Paper:
-    Title: Rethinking atrous convolution for semantic image segmentation
-    URL: https://arxiv.org/abs/1706.05587
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/aspp_head.py#L54
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/deeplabv3plus/README.md b/mmsegmentation/configs/deeplabv3plus/README.md
deleted file mode 100644
index 04d01fa..0000000
--- a/mmsegmentation/configs/deeplabv3plus/README.md
+++ /dev/null
@@ -1,138 +0,0 @@
-# DeepLabV3+
-
-> [Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation](https://arxiv.org/abs/1802.02611)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/tensorflow/models/tree/master/research/deeplab">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Spatial pyramid pooling module or encode-decoder structure are used in deep neural networks for semantic segmentation task. The former networks are able to encode multi-scale contextual information by probing the incoming features with filters or pooling operations at multiple rates and multiple effective fields-of-view, while the latter networks can capture sharper object boundaries by gradually recovering the spatial information. In this work, we propose to combine the advantages from both methods. Specifically, our proposed model, DeepLabv3+, extends DeepLabv3 by adding a simple yet effective decoder module to refine the segmentation results especially along object boundaries. We further explore the Xception model and apply the depthwise separable convolution to both Atrous Spatial Pyramid Pooling and decoder modules, resulting in a faster and stronger encoder-decoder network. We demonstrate the effectiveness of the proposed model on PASCAL VOC 2012 and Cityscapes datasets, achieving the test set performance of 89.0% and 82.1% without any post-processing. Our paper is accompanied with a publicly available reference implementation of the proposed models in Tensorflow at [this https URL](https://github.com/tensorflow/models/tree/master/research/deeplab).
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142900680-3e2c3098-8341-4760-bbfd-b1d7d29968ea.png" width="70%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method            | Backbone        | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                                      | download                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| ----------------- | --------------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| DeepLabV3+        | R-50-D8         | 512x1024  |   40000 | 7.5      | 3.94           | V100   | 79.61 |         81.01 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024.py)                 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_40k_cityscapes/deeplabv3plus_r50-d8_512x1024_40k_cityscapes_20200605_094610-d222ffcd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_40k_cityscapes/deeplabv3plus_r50-d8_512x1024_40k_cityscapes_20200605_094610.log.json)                                 |
-| DeepLabV3+        | R-101-D8        | 512x1024  |   40000 | 11       | 2.60           | V100   | 80.21 |         81.82 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-512x1024.py)                | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_40k_cityscapes/deeplabv3plus_r101-d8_512x1024_40k_cityscapes_20200605_094614-3769eecf.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_40k_cityscapes/deeplabv3plus_r101-d8_512x1024_40k_cityscapes_20200605_094614.log.json)                             |
-| DeepLabV3+        | R-50-D8         | 769x769   |   40000 | 8.5      | 1.72           | V100   | 78.97 |         80.46 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-769x769.py)                  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_769x769_40k_cityscapes/deeplabv3plus_r50-d8_769x769_40k_cityscapes_20200606_114143-1dcb0e3c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_769x769_40k_cityscapes/deeplabv3plus_r50-d8_769x769_40k_cityscapes_20200606_114143.log.json)                                     |
-| DeepLabV3+        | R-101-D8        | 769x769   |   40000 | 12.5     | 1.15           | V100   | 79.46 |         80.50 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-769x769.py)                 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_769x769_40k_cityscapes/deeplabv3plus_r101-d8_769x769_40k_cityscapes_20200606_114304-ff414b9e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_769x769_40k_cityscapes/deeplabv3plus_r101-d8_769x769_40k_cityscapes_20200606_114304.log.json)                                 |
-| DeepLabV3+        | R-18-D8         | 512x1024  |   80000 | 2.2      | 14.27          | V100   | 76.89 |         78.76 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-512x1024.py)                 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x1024_80k_cityscapes/deeplabv3plus_r18-d8_512x1024_80k_cityscapes_20201226_080942-cff257fe.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x1024_80k_cityscapes/deeplabv3plus_r18-d8_512x1024_80k_cityscapes-20201226_080942.log.json)                                 |
-| DeepLabV3+        | R-50-D8         | 512x1024  |   80000 | -        | -              | V100   | 80.09 |         81.13 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py)                 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_80k_cityscapes/deeplabv3plus_r50-d8_512x1024_80k_cityscapes_20200606_114049-f9fb496d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_80k_cityscapes/deeplabv3plus_r50-d8_512x1024_80k_cityscapes_20200606_114049.log.json)                                 |
-| DeepLabV3+        | R-101-D8        | 512x1024  |   80000 | -        | -              | V100   | 80.97 |         82.03 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024.py)                | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_80k_cityscapes/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143-068fcfe9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_80k_cityscapes/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143.log.json)                             |
-| DeepLabV3+ (FP16) | R-101-D8        | 512x1024  |   80000 | 6.35     | 7.87           | V100   | 80.46 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py)            | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230920-f1104f4b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230920.log.json)         |
-| DeepLabV3+        | R-18-D8         | 769x769   |   80000 | 2.5      | 5.74           | V100   | 76.26 |         77.91 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-769x769.py)                  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_769x769_80k_cityscapes/deeplabv3plus_r18-d8_769x769_80k_cityscapes_20201226_083346-f326e06a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_769x769_80k_cityscapes/deeplabv3plus_r18-d8_769x769_80k_cityscapes-20201226_083346.log.json)                                     |
-| DeepLabV3+        | R-50-D8         | 769x769   |   80000 | -        | -              | V100   | 79.83 |         81.48 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py)                  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_769x769_80k_cityscapes/deeplabv3plus_r50-d8_769x769_80k_cityscapes_20200606_210233-0e9dfdc4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_769x769_80k_cityscapes/deeplabv3plus_r50-d8_769x769_80k_cityscapes_20200606_210233.log.json)                                     |
-| DeepLabV3+        | R-101-D8        | 769x769   |   80000 | -        | -              | V100   | 80.65 |         81.47 | [config<sup>\[1\]</sup>](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-769x769.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_769x769_80k_cityscapes/deeplabv3plus_r101-d8_769x769_80k_cityscapes_20220406_154720-dfcc0b68.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_769x769_80k_cityscapes/deeplabv3plus_r101-d8_769x769_80k_cityscapes_20220406_154720.log.json)                                 |
-| DeepLabV3+        | R-101-D16-MG124 | 512x1024  |   40000 | 5.8      | 7.48           | V100   | 79.09 |         80.36 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/ddeeplabv3plus_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d16-mg124_512x1024_40k_cityscapes/deeplabv3plus_r101-d16-mg124_512x1024_40k_cityscapes_20200908_005644-cf9ce186.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d16-mg124_512x1024_40k_cityscapes/deeplabv3plus_r101-d16-mg124_512x1024_40k_cityscapes-20200908_005644.log.json) |
-| DeepLabV3+        | R-101-D16-MG124 | 512x1024  |   80000 | 9.9      | -              | V100   | 79.90 |         81.33 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d16-mg124_512x1024_80k_cityscapes/deeplabv3plus_r101-d16-mg124_512x1024_80k_cityscapes_20200908_005644-ee6158e0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d16-mg124_512x1024_80k_cityscapes/deeplabv3plus_r101-d16-mg124_512x1024_80k_cityscapes-20200908_005644.log.json) |
-| DeepLabV3+        | R-18b-D8        | 512x1024  |   80000 | 2.1      | 14.95          | V100   | 75.87 |         77.52 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-512x1024.py)                | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18b-d8_512x1024_80k_cityscapes/deeplabv3plus_r18b-d8_512x1024_80k_cityscapes_20201226_090828-e451abd9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18b-d8_512x1024_80k_cityscapes/deeplabv3plus_r18b-d8_512x1024_80k_cityscapes-20201226_090828.log.json)                             |
-| DeepLabV3+        | R-50b-D8        | 512x1024  |   80000 | 7.4      | 3.94           | V100   | 80.28 |         81.44 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-512x1024.py)                | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50b-d8_512x1024_80k_cityscapes/deeplabv3plus_r50b-d8_512x1024_80k_cityscapes_20201225_213645-a97e4e43.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50b-d8_512x1024_80k_cityscapes/deeplabv3plus_r50b-d8_512x1024_80k_cityscapes-20201225_213645.log.json)                             |
-| DeepLabV3+        | R-101b-D8       | 512x1024  |   80000 | 10.9     | 2.60           | V100   | 80.16 |         81.41 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-512x1024.py)               | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101b-d8_512x1024_80k_cityscapes/deeplabv3plus_r101b-d8_512x1024_80k_cityscapes_20201226_190843-9c3c93a4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101b-d8_512x1024_80k_cityscapes/deeplabv3plus_r101b-d8_512x1024_80k_cityscapes-20201226_190843.log.json)                         |
-| DeepLabV3+        | R-18b-D8        | 769x769   |   80000 | 2.4      | 5.96           | V100   | 76.36 |         78.24 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-769x769.py)                 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18b-d8_769x769_80k_cityscapes/deeplabv3plus_r18b-d8_769x769_80k_cityscapes_20201226_151312-2c868aff.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18b-d8_769x769_80k_cityscapes/deeplabv3plus_r18b-d8_769x769_80k_cityscapes-20201226_151312.log.json)                                 |
-| DeepLabV3+        | R-50b-D8        | 769x769   |   80000 | 8.4      | 1.72           | V100   | 79.41 |         80.56 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-769x769.py)                 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50b-d8_769x769_80k_cityscapes/deeplabv3plus_r50b-d8_769x769_80k_cityscapes_20201225_224655-8b596d1c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50b-d8_769x769_80k_cityscapes/deeplabv3plus_r50b-d8_769x769_80k_cityscapes-20201225_224655.log.json)                                 |
-| DeepLabV3+        | R-101b-D8       | 769x769   |   80000 | 12.3     | 1.10           | V100   | 79.88 |         81.46 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-769x769.py)                | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101b-d8_769x769_80k_cityscapes/deeplabv3plus_r101b-d8_769x769_80k_cityscapes_20201226_205041-227cdf7c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101b-d8_769x769_80k_cityscapes/deeplabv3plus_r101b-d8_769x769_80k_cityscapes-20201226_205041.log.json)                             |
-
-\[1\] The training of the model is sensitive to random seed, and the seed to train it is 1111.
-
-### ADE20K
-
-| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                   | download                                                                                                                                                                                                                                                                                                                                                                           |
-| ---------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| DeepLabV3+ | R-50-D8  | 512x512   |   80000 | 10.6     | 21.01          | V100   | 42.72 |         43.75 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_ade20k/deeplabv3plus_r50-d8_512x512_80k_ade20k_20200614_185028-bf1400d8.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_ade20k/deeplabv3plus_r50-d8_512x512_80k_ade20k_20200614_185028.log.json)         |
-| DeepLabV3+ | R-101-D8 | 512x512   |   80000 | 14.1     | 14.16          | V100   | 44.60 |         46.06 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_ade20k/deeplabv3plus_r101-d8_512x512_80k_ade20k_20200615_014139-d5730af7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_ade20k/deeplabv3plus_r101-d8_512x512_80k_ade20k_20200615_014139.log.json)     |
-| DeepLabV3+ | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 43.95 |         44.93 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_160k_ade20k/deeplabv3plus_r50-d8_512x512_160k_ade20k_20200615_124504-6135c7e0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_160k_ade20k/deeplabv3plus_r50-d8_512x512_160k_ade20k_20200615_124504.log.json)     |
-| DeepLabV3+ | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 45.47 |         46.35 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_160k_ade20k/deeplabv3plus_r101-d8_512x512_160k_ade20k_20200615_123232-38ed86bb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_160k_ade20k/deeplabv3plus_r101-d8_512x512_160k_ade20k_20200615_123232.log.json) |
-
-### Pascal VOC 2012 + Aug
-
-| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                    | download                                                                                                                                                                                                                                                                                                                                                                               |
-| ---------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ----------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| DeepLabV3+ | R-50-D8  | 512x512   |   20000 | 7.6      | 21             | V100   | 75.93 |         77.50 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_20k_voc12aug/deeplabv3plus_r50-d8_512x512_20k_voc12aug_20200617_102323-aad58ef1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_20k_voc12aug/deeplabv3plus_r50-d8_512x512_20k_voc12aug_20200617_102323.log.json)     |
-| DeepLabV3+ | R-101-D8 | 512x512   |   20000 | 11       | 13.88          | V100   | 77.22 |         78.59 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_20k_voc12aug/deeplabv3plus_r101-d8_512x512_20k_voc12aug_20200617_102345-c7ff3d56.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_20k_voc12aug/deeplabv3plus_r101-d8_512x512_20k_voc12aug_20200617_102345.log.json) |
-| DeepLabV3+ | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 76.81 |         77.57 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_40k_voc12aug/deeplabv3plus_r50-d8_512x512_40k_voc12aug_20200613_161759-e1b43aa9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_40k_voc12aug/deeplabv3plus_r50-d8_512x512_40k_voc12aug_20200613_161759.log.json)     |
-| DeepLabV3+ | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 78.62 |         79.53 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_40k_voc12aug/deeplabv3plus_r101-d8_512x512_40k_voc12aug_20200613_205333-faf03387.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_40k_voc12aug/deeplabv3plus_r101-d8_512x512_40k_voc12aug_20200613_205333.log.json) |
-
-### Pascal Context
-
-| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                         | download                                                                                                                                                                                                                                                                                                                                                                                                       |
-| ---------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ---------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| DeepLabV3+ | R-101-D8 | 480x480   |   40000 | -        | 9.09           | V100   | 47.30 |         48.47 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_pascal-context-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_40k_pascal_context/deeplabv3plus_r101-d8_480x480_40k_pascal_context_20200911_165459-d3c8a29e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_40k_pascal_context/deeplabv3plus_r101-d8_480x480_40k_pascal_context-20200911_165459.log.json) |
-| DeepLabV3+ | R-101-D8 | 480x480   |   80000 | -        | -              | V100   | 47.23 |         48.26 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_pascal-context-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_80k_pascal_context/deeplabv3plus_r101-d8_480x480_80k_pascal_context_20200911_155322-145d3ee8.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_80k_pascal_context/deeplabv3plus_r101-d8_480x480_80k_pascal_context-20200911_155322.log.json) |
-
-### Pascal Context 59
-
-| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                             | download                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| ---------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| DeepLabV3+ | R-101-D8 | 480x480   |   40000 | -        | -              | V100   | 52.86 |         54.54 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_pascal-context-59-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_40k_pascal_context_59/deeplabv3plus_r101-d8_480x480_40k_pascal_context_59_20210416_111233-ed937f15.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_40k_pascal_context_59/deeplabv3plus_r101-d8_480x480_40k_pascal_context_59-20210416_111233.log.json) |
-| DeepLabV3+ | R-101-D8 | 480x480   |   80000 | -        | -              | V100   |  53.2 |         54.67 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_pascal-context-59-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_80k_pascal_context_59/deeplabv3plus_r101-d8_480x480_80k_pascal_context_59_20210416_111127-7ca0331d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_80k_pascal_context_59/deeplabv3plus_r101-d8_480x480_80k_pascal_context_59-20210416_111127.log.json) |
-
-### LoveDA
-
-| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                  | download                                                                                                                                                                                                                                                                                                                                                                       |
-| ---------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | --------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| DeepLabV3+ | R-18-D8  | 512x512   |   80000 | 1.93     | 25.57          | V100   | 50.28 |         50.47 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_loveda-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x512_80k_loveda/deeplabv3plus_r18-d8_512x512_80k_loveda_20211104_132800-ce0fa0ca.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x512_80k_loveda/deeplabv3plus_r18-d8_512x512_80k_loveda_20211104_132800.log.json)     |
-| DeepLabV3+ | R-50-D8  | 512x512   |   80000 | 7.37     | 6.00           | V100   | 50.99 |         50.65 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_loveda-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_loveda/deeplabv3plus_r50-d8_512x512_80k_loveda_20211105_080442-f0720392.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_loveda/deeplabv3plus_r50-d8_512x512_80k_loveda_20211105_080442.log.json)     |
-| DeepLabV3+ | R-101-D8 | 512x512   |   80000 | 10.84    | 4.33           | V100   | 51.47 |         51.32 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_loveda-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_loveda/deeplabv3plus_r101-d8_512x512_80k_loveda_20211105_110759-4c1f297e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_loveda/deeplabv3plus_r101-d8_512x512_80k_loveda_20211105_110759.log.json) |
-
-### Potsdam
-
-| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                   | download                                                                                                                                                                                                                                                                                                                                                                           |
-| ---------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| DeepLabV3+ | R-18-D8  | 512x512   |   80000 | 1.91     | 81.68          | V100   | 77.09 |         78.44 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_potsdam-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x512_80k_potsdam/deeplabv3plus_r18-d8_512x512_80k_potsdam_20211219_020601-75fd5bc3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x512_80k_potsdam/deeplabv3plus_r18-d8_512x512_80k_potsdam_20211219_020601.log.json)     |
-| DeepLabV3+ | R-50-D8  | 512x512   |   80000 | 7.36     | 26.44          | V100   | 78.33 |         79.27 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_potsdam-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_potsdam/deeplabv3plus_r50-d8_512x512_80k_potsdam_20211219_031508-7e7a2b24.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_potsdam/deeplabv3plus_r50-d8_512x512_80k_potsdam_20211219_031508.log.json)     |
-| DeepLabV3+ | R-101-D8 | 512x512   |   80000 | 10.83    | 17.56          | V100   |  78.7 |         79.47 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_potsdam/deeplabv3plus_r101-d8_512x512_80k_potsdam_20211219_031508-8b112708.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_potsdam/deeplabv3plus_r101-d8_512x512_80k_potsdam_20211219_031508.log.json) |
-
-### Vaihingen
-
-| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                     | download                                                                                                                                                                                                                                                                                                                                                                                                   |
-| ---------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| DeepLabV3+ | R-18-D8  | 512x512   |   80000 | 1.91     | 72.79          | V100   | 72.50 |         74.13 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_vaihingen-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r18-d8_4x4_512x512_80k_vaihingen_20211231_230805-7626a263.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r18-d8_4x4_512x512_80k_vaihingen_20211231_230805.log.json)     |
-| DeepLabV3+ | R-50-D8  | 512x512   |   80000 | 7.36     | 26.91          | V100   | 73.97 |         75.05 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_vaihingen-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r50-d8_4x4_512x512_80k_vaihingen_20211231_230816-5040938d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r50-d8_4x4_512x512_80k_vaihingen_20211231_230816.log.json)     |
-| DeepLabV3+ | R-101-D8 | 512x512   |   80000 | 10.83    | 18.59          | V100   | 73.06 |         74.14 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_vaihingen-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r101-d8_4x4_512x512_80k_vaihingen_20211231_230816-8a095afa.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r101-d8_4x4_512x512_80k_vaihingen_20211231_230816.log.json) |
-
-### iSAID
-
-| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                | download                                                                                                                                                                                                                                                                                                                                                                               |
-| ---------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| DeepLabV3+ | R-18-D8  | 896x896   |   80000 | 6.19     | 24.81          | V100   | 61.35 |         62.61 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_isaid-896x896.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_4x4_896x896_80k_isaid/deeplabv3plus_r18-d8_4x4_896x896_80k_isaid_20220110_180526-7059991d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_4x4_896x896_80k_isaid/deeplabv3plus_r18-d8_4x4_896x896_80k_isaid_20220110_180526.log.json) |
-| DeepLabV3+ | R-50-D8  | 896x896   |   80000 | 21.45    | 8.42           | V100   | 67.06 |         68.02 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_isaid-896x896.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4x4_896x896_80k_isaid/deeplabv3plus_r50-d8_4x4_896x896_80k_isaid_20220110_180526-598be439.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4x4_896x896_80k_isaid/deeplabv3plus_r50-d8_4x4_896x896_80k_isaid_20220110_180526.log.json) |
-
-### Mapillary Vistas v1.2
-
-| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                            | download                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| ---------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| DeepLabV3+ | R-50-D8  | 1280x1280 |  300000 | 24.04    | 17.92          | A100   | 47.35 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280_20230301_110504-655f8e43.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280_20230301_110504.json) |
-
-Note:
-
-- `D-8`/`D-16` here corresponding to the output stride 8/16 setting for DeepLab series.
-- `MG-124` stands for multi-grid dilation in the last stage of ResNet.
-- `FP16` means Mixed Precision (FP16) is adopted in training.
-- `896x896` is the Crop Size of iSAID dataset, which is followed by the implementation of [PointFlow: Flowing Semantics Through Points for Aerial Image Segmentation](https://arxiv.org/pdf/2103.06564.pdf)
-
-## Citation
-
-```bibtex
-@inproceedings{deeplabv3plus2018,
-  title={Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation},
-  author={Liang-Chieh Chen and Yukun Zhu and George Papandreou and Florian Schroff and Hartwig Adam},
-  booktitle={ECCV},
-  year={2018}
-}
-```
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 71c9118..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='open-mmlab://resnet101_v1c',
-    backbone=dict(
-        depth=101,
-        dilations=(1, 1, 1, 2),
-        strides=(1, 2, 2, 1),
-        multi_grid=(1, 2, 4)),
-    decode_head=dict(
-        dilations=(1, 6, 12, 18),
-        sampler=dict(type='OHEMPixelSampler', min_kept=100000)))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 7d1ccf0..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='open-mmlab://resnet101_v1c',
-    backbone=dict(
-        depth=101,
-        dilations=(1, 1, 1, 2),
-        strides=(1, 2, 2, 1),
-        multi_grid=(1, 2, 4)),
-    decode_head=dict(
-        dilations=(1, 6, 12, 18),
-        sampler=dict(type='OHEMPixelSampler', min_kept=100000)))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 884b526..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index debb025..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb2-40k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index bc9334e..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 4af9aa2..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
deleted file mode 100644
index 9c9883d..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = './deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024.py'
-optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
-optim_wrapper = dict(
-    _delete_=True,
-    type='AmpOptimWrapper',
-    optimizer=optimizer,
-    loss_scale=512.)
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index c38a802..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb4-160k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index 97bb827..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb4-20k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_pascal-context-480x480.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_pascal-context-480x480.py
deleted file mode 100644
index e4b4011..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_pascal-context-480x480.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb4-40k_pascal-context-480x480.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_pascal-context-59-480x480.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_pascal-context-59-480x480.py
deleted file mode 100644
index eeefae4..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_pascal-context-59-480x480.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb4-40k_pascal-context-59-480x480.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index 0755c53..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb4-40k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 844ac96..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb4-80k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_loveda-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_loveda-512x512.py
deleted file mode 100644
index 87c6da9..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_loveda-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb4-80k_loveda-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_pascal-context-480x480.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_pascal-context-480x480.py
deleted file mode 100644
index 115b1c9..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_pascal-context-480x480.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb4-80k_pascal-context-480x480.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_pascal-context-59-480x480.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_pascal-context-59-480x480.py
deleted file mode 100644
index 9aaa653..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_pascal-context-59-480x480.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb4-80k_pascal-context-59-480x480.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py
deleted file mode 100644
index 5063b13..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb4-80k_potsdam-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_vaihingen-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_vaihingen-512x512.py
deleted file mode 100644
index b99c2c7..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_vaihingen-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb4-80k_vaihingen-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index d1bcb09..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,4 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='torchvision://resnet101',
-    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index c78fc1e..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,4 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(
-    pretrained='torchvision://resnet101',
-    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 5f54913..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='open-mmlab://resnet18_v1c',
-    backbone=dict(depth=18),
-    decode_head=dict(
-        c1_in_channels=64,
-        c1_channels=12,
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 1b361d6..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(
-    pretrained='open-mmlab://resnet18_v1c',
-    backbone=dict(depth=18),
-    decode_head=dict(
-        c1_in_channels=64,
-        c1_channels=12,
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_isaid-896x896.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_isaid-896x896.py
deleted file mode 100644
index 3a1a753..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_isaid-896x896.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb4-80k_isaid-896x896.py'
-model = dict(
-    pretrained='open-mmlab://resnet18_v1c',
-    backbone=dict(depth=18),
-    decode_head=dict(
-        c1_in_channels=64,
-        c1_channels=12,
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_loveda-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_loveda-512x512.py
deleted file mode 100644
index 01bbf9b..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_loveda-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb4-80k_loveda-512x512.py'
-model = dict(
-    pretrained='open-mmlab://resnet18_v1c',
-    backbone=dict(depth=18),
-    decode_head=dict(
-        c1_in_channels=64,
-        c1_channels=12,
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_potsdam-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_potsdam-512x512.py
deleted file mode 100644
index 134f2cf..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_potsdam-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb4-80k_potsdam-512x512.py'
-model = dict(
-    pretrained='open-mmlab://resnet18_v1c',
-    backbone=dict(depth=18),
-    decode_head=dict(
-        c1_in_channels=64,
-        c1_channels=12,
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_vaihingen-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_vaihingen-512x512.py
deleted file mode 100644
index 2194838..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_vaihingen-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb4-80k_vaihingen-512x512.py'
-model = dict(
-    pretrained='open-mmlab://resnet18_v1c',
-    backbone=dict(depth=18),
-    decode_head=dict(
-        c1_in_channels=64,
-        c1_channels=12,
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index ea86219..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='torchvision://resnet18',
-    backbone=dict(type='ResNet', depth=18),
-    decode_head=dict(
-        c1_in_channels=64,
-        c1_channels=12,
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 34ee7ed..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb2-40k_cityscapes-769x769.py'
-model = dict(
-    pretrained='torchvision://resnet18',
-    backbone=dict(type='ResNet', depth=18),
-    decode_head=dict(
-        c1_in_channels=64,
-        c1_channels=12,
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280.py
deleted file mode 100644
index 133c45a..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280.py
+++ /dev/null
@@ -1,58 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3plus_r50-d8.py',
-    '../_base_/datasets/mapillary_v1_65.py',
-    '../_base_/default_runtime.py',
-]
-
-crop_size = (1280, 1280)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained='open-mmlab://resnet50_v1c',
-    backbone=dict(depth=50),
-    decode_head=dict(num_classes=65),
-    auxiliary_head=dict(num_classes=65))
-
-iters = 300000
-# optimizer
-optimizer = dict(
-    type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.0001)
-# optimizer
-optim_wrapper = dict(
-    type='OptimWrapper',
-    optimizer=optimizer,
-    clip_grad=dict(max_norm=0.01, norm_type=2),
-    paramwise_cfg=dict(
-        custom_keys={'backbone': dict(lr_mult=0.1, decay_mult=1.0)}))
-param_scheduler = [
-    dict(
-        type='PolyLR',
-        eta_min=0,
-        power=0.9,
-        begin=0,
-        end=iters,
-        by_epoch=False)
-]
-
-# training schedule for 300k
-train_cfg = dict(
-    type='IterBasedTrainLoop', max_iters=iters, val_interval=iters // 10)
-val_cfg = dict(type='ValLoop')
-test_cfg = dict(type='TestLoop')
-
-default_hooks = dict(
-    timer=dict(type='IterTimerHook'),
-    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
-    param_scheduler=dict(type='ParamSchedulerHook'),
-    checkpoint=dict(
-        type='CheckpointHook', by_epoch=False, interval=iters // 10),
-    sampler_seed=dict(type='DistSamplerSeedHook'),
-    visualization=dict(type='SegVisualizationHook'))
-
-train_dataloader = dict(batch_size=2)
-
-# Default setting for scaling LR automatically
-#   - `enable` means enable scaling LR automatically
-#       or not by default.
-#   - `base_batch_size` = (4 GPUs) x (2 samples per GPU).
-auto_scale_lr = dict(enable=False, base_batch_size=8)
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 32f994d..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3plus_r50-d8.py',
-    '../_base_/datasets/cityscapes.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index 8cdf534..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3plus_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 0d249b0..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3plus_r50-d8.py',
-    '../_base_/datasets/cityscapes.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 863a46e..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3plus_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 9a899fb..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3plus_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index 1876d0c..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3plus_r50-d8.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_20k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_pascal-context-480x480.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_pascal-context-480x480.py
deleted file mode 100644
index 95b56d0..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_pascal-context-480x480.py
+++ /dev/null
@@ -1,14 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3plus_r50-d8.py',
-    '../_base_/datasets/pascal_context.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (480, 480)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=60),
-    auxiliary_head=dict(num_classes=60),
-    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_pascal-context-59-480x480.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_pascal-context-59-480x480.py
deleted file mode 100644
index 459c62d..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_pascal-context-59-480x480.py
+++ /dev/null
@@ -1,14 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3plus_r50-d8.py',
-    '../_base_/datasets/pascal_context_59.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (480, 480)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=59),
-    auxiliary_head=dict(num_classes=59),
-    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index 0d61b50..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3plus_r50-d8.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 6f872ca..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3plus_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_isaid-896x896.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_isaid-896x896.py
deleted file mode 100644
index 7edec14..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_isaid-896x896.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3plus_r50-d8.py', '../_base_/datasets/isaid.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (896, 896)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=16),
-    auxiliary_head=dict(num_classes=16))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_loveda-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_loveda-512x512.py
deleted file mode 100644
index 64e262c..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_loveda-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3plus_r50-d8.py', '../_base_/datasets/loveda.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=7),
-    auxiliary_head=dict(num_classes=7))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_pascal-context-480x480.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_pascal-context-480x480.py
deleted file mode 100644
index 5ff7fcb..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_pascal-context-480x480.py
+++ /dev/null
@@ -1,14 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3plus_r50-d8.py',
-    '../_base_/datasets/pascal_context.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (480, 480)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=60),
-    auxiliary_head=dict(num_classes=60),
-    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_pascal-context-59-480x480.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_pascal-context-59-480x480.py
deleted file mode 100644
index 84aaf25..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_pascal-context-59-480x480.py
+++ /dev/null
@@ -1,14 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3plus_r50-d8.py',
-    '../_base_/datasets/pascal_context_59.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (480, 480)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=59),
-    auxiliary_head=dict(num_classes=59),
-    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_potsdam-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_potsdam-512x512.py
deleted file mode 100644
index 5810d6b..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_potsdam-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3plus_r50-d8.py',
-    '../_base_/datasets/potsdam.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=6),
-    auxiliary_head=dict(num_classes=6))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_vaihingen-512x512.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_vaihingen-512x512.py
deleted file mode 100644
index a7f4b2d..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_vaihingen-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3plus_r50-d8.py',
-    '../_base_/datasets/vaihingen.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=6),
-    auxiliary_head=dict(num_classes=6))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 3e28135..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='torchvision://resnet50', backbone=dict(type='ResNet'))
diff --git a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 6366bd4..0000000
--- a/mmsegmentation/configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(pretrained='torchvision://resnet50', backbone=dict(type='ResNet'))
diff --git a/mmsegmentation/configs/deeplabv3plus/metafile.yaml b/mmsegmentation/configs/deeplabv3plus/metafile.yaml
deleted file mode 100644
index b41de4d..0000000
--- a/mmsegmentation/configs/deeplabv3plus/metafile.yaml
+++ /dev/null
@@ -1,1041 +0,0 @@
-Collections:
-- Name: DeepLabV3+
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-    - ADE20K
-    - Pascal VOC 2012 + Aug
-    - Pascal Context
-    - Pascal Context 59
-    - LoveDA
-    - Potsdam
-    - Vaihingen
-    - iSAID
-    - Mapillary Vistas v1.2
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  README: configs/deeplabv3plus/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.61
-      mIoU(ms+flip): 81.01
-  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 7.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_40k_cityscapes/deeplabv3plus_r50-d8_512x1024_40k_cityscapes_20200605_094610-d222ffcd.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_40k_cityscapes/deeplabv3plus_r50-d8_512x1024_40k_cityscapes_20200605_094610.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r101-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 80.21
-      mIoU(ms+flip): 81.82
-  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 11.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_40k_cityscapes/deeplabv3plus_r101-d8_512x1024_40k_cityscapes_20200605_094614-3769eecf.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_40k_cityscapes/deeplabv3plus_r101-d8_512x1024_40k_cityscapes_20200605_094614.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r50-d8_4xb2-40k_cityscapes-769x769
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.97
-      mIoU(ms+flip): 80.46
-  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_769x769_40k_cityscapes/deeplabv3plus_r50-d8_769x769_40k_cityscapes_20200606_114143-1dcb0e3c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_769x769_40k_cityscapes/deeplabv3plus_r50-d8_769x769_40k_cityscapes_20200606_114143.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r101-d8_4xb2-40k_cityscapes-769x769
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.46
-      mIoU(ms+flip): 80.5
-  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 12.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_769x769_40k_cityscapes/deeplabv3plus_r101-d8_769x769_40k_cityscapes_20200606_114304-ff414b9e.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_769x769_40k_cityscapes/deeplabv3plus_r101-d8_769x769_40k_cityscapes_20200606_114304.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r18-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.89
-      mIoU(ms+flip): 78.76
-  Config: configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-18-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 2.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x1024_80k_cityscapes/deeplabv3plus_r18-d8_512x1024_80k_cityscapes_20201226_080942-cff257fe.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x1024_80k_cityscapes/deeplabv3plus_r18-d8_512x1024_80k_cityscapes-20201226_080942.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 80.09
-      mIoU(ms+flip): 81.13
-  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_80k_cityscapes/deeplabv3plus_r50-d8_512x1024_80k_cityscapes_20200606_114049-f9fb496d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x1024_80k_cityscapes/deeplabv3plus_r50-d8_512x1024_80k_cityscapes_20200606_114049.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 80.97
-      mIoU(ms+flip): 82.03
-  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_80k_cityscapes/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143-068fcfe9.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x1024_80k_cityscapes/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r101-d8_4xb2-amp-80k_cityscapes-512x1024
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 80.46
-  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - DeepLabV3+
-    - (FP16)
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.35
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230920-f1104f4b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes/deeplabv3plus_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230920.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r18-d8_4xb2-80k_cityscapes-769x769
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.26
-      mIoU(ms+flip): 77.91
-  Config: configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-18-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 2.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_769x769_80k_cityscapes/deeplabv3plus_r18-d8_769x769_80k_cityscapes_20201226_083346-f326e06a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_769x769_80k_cityscapes/deeplabv3plus_r18-d8_769x769_80k_cityscapes-20201226_083346.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.83
-      mIoU(ms+flip): 81.48
-  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_769x769_80k_cityscapes/deeplabv3plus_r50-d8_769x769_80k_cityscapes_20200606_210233-0e9dfdc4.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_769x769_80k_cityscapes/deeplabv3plus_r50-d8_769x769_80k_cityscapes_20200606_210233.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r101-d8_4xb2-80k_cityscapes-769x769
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 80.65
-      mIoU(ms+flip): 81.47
-  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_769x769_80k_cityscapes/deeplabv3plus_r101-d8_769x769_80k_cityscapes_20220406_154720-dfcc0b68.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_769x769_80k_cityscapes/deeplabv3plus_r101-d8_769x769_80k_cityscapes_20220406_154720.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: ddeeplabv3plus_r101-d16-mg124_4xb2-40k_cityscapes-512x1024
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.09
-      mIoU(ms+flip): 80.36
-  Config: configs/deeplabv3plus/ddeeplabv3plus_r101-d16-mg124_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D16-MG124
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d16-mg124_512x1024_40k_cityscapes/deeplabv3plus_r101-d16-mg124_512x1024_40k_cityscapes_20200908_005644-cf9ce186.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d16-mg124_512x1024_40k_cityscapes/deeplabv3plus_r101-d16-mg124_512x1024_40k_cityscapes-20200908_005644.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r101-d16-mg124_4xb2-80k_cityscapes-512x1024
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.9
-      mIoU(ms+flip): 81.33
-  Config: configs/deeplabv3plus/deeplabv3plus_r101-d16-mg124_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D16-MG124
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d16-mg124_512x1024_80k_cityscapes/deeplabv3plus_r101-d16-mg124_512x1024_80k_cityscapes_20200908_005644-ee6158e0.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d16-mg124_512x1024_80k_cityscapes/deeplabv3plus_r101-d16-mg124_512x1024_80k_cityscapes-20200908_005644.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 75.87
-      mIoU(ms+flip): 77.52
-  Config: configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-18b-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 2.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18b-d8_512x1024_80k_cityscapes/deeplabv3plus_r18b-d8_512x1024_80k_cityscapes_20201226_090828-e451abd9.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18b-d8_512x1024_80k_cityscapes/deeplabv3plus_r18b-d8_512x1024_80k_cityscapes-20201226_090828.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 80.28
-      mIoU(ms+flip): 81.44
-  Config: configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50b-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 7.4
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50b-d8_512x1024_80k_cityscapes/deeplabv3plus_r50b-d8_512x1024_80k_cityscapes_20201225_213645-a97e4e43.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50b-d8_512x1024_80k_cityscapes/deeplabv3plus_r50b-d8_512x1024_80k_cityscapes-20201225_213645.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 80.16
-      mIoU(ms+flip): 81.41
-  Config: configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101b-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101b-d8_512x1024_80k_cityscapes/deeplabv3plus_r101b-d8_512x1024_80k_cityscapes_20201226_190843-9c3c93a4.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101b-d8_512x1024_80k_cityscapes/deeplabv3plus_r101b-d8_512x1024_80k_cityscapes-20201226_190843.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-769x769
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.36
-      mIoU(ms+flip): 78.24
-  Config: configs/deeplabv3plus/deeplabv3plus_r18b-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-18b-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 2.4
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18b-d8_769x769_80k_cityscapes/deeplabv3plus_r18b-d8_769x769_80k_cityscapes_20201226_151312-2c868aff.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18b-d8_769x769_80k_cityscapes/deeplabv3plus_r18b-d8_769x769_80k_cityscapes-20201226_151312.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-769x769
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.41
-      mIoU(ms+flip): 80.56
-  Config: configs/deeplabv3plus/deeplabv3plus_r50b-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50b-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.4
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50b-d8_769x769_80k_cityscapes/deeplabv3plus_r50b-d8_769x769_80k_cityscapes_20201225_224655-8b596d1c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50b-d8_769x769_80k_cityscapes/deeplabv3plus_r50b-d8_769x769_80k_cityscapes-20201225_224655.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-769x769
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.88
-      mIoU(ms+flip): 81.46
-  Config: configs/deeplabv3plus/deeplabv3plus_r101b-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101b-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 12.3
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101b-d8_769x769_80k_cityscapes/deeplabv3plus_r101b-d8_769x769_80k_cityscapes_20201226_205041-227cdf7c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101b-d8_769x769_80k_cityscapes/deeplabv3plus_r101b-d8_769x769_80k_cityscapes-20201226_205041.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r50-d8_4xb4-80k_ade20k-512x512
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.72
-      mIoU(ms+flip): 43.75
-  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_ade20k/deeplabv3plus_r50-d8_512x512_80k_ade20k_20200614_185028-bf1400d8.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_ade20k/deeplabv3plus_r50-d8_512x512_80k_ade20k_20200614_185028.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 44.6
-      mIoU(ms+flip): 46.06
-  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 14.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_ade20k/deeplabv3plus_r101-d8_512x512_80k_ade20k_20200615_014139-d5730af7.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_ade20k/deeplabv3plus_r101-d8_512x512_80k_ade20k_20200615_014139.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r50-d8_4xb4-160k_ade20k-512x512
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 43.95
-      mIoU(ms+flip): 44.93
-  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_160k_ade20k/deeplabv3plus_r50-d8_512x512_160k_ade20k_20200615_124504-6135c7e0.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_160k_ade20k/deeplabv3plus_r50-d8_512x512_160k_ade20k_20200615_124504.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 45.47
-      mIoU(ms+flip): 46.35
-  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_160k_ade20k/deeplabv3plus_r101-d8_512x512_160k_ade20k_20200615_123232-38ed86bb.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_160k_ade20k/deeplabv3plus_r101-d8_512x512_160k_ade20k_20200615_123232.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r50-d8_4xb4-20k_voc12aug-512x512
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 75.93
-      mIoU(ms+flip): 77.5
-  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 7.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_20k_voc12aug/deeplabv3plus_r50-d8_512x512_20k_voc12aug_20200617_102323-aad58ef1.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_20k_voc12aug/deeplabv3plus_r50-d8_512x512_20k_voc12aug_20200617_102323.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r101-d8_4xb4-20k_voc12aug-512x512
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 77.22
-      mIoU(ms+flip): 78.59
-  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 11.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_20k_voc12aug/deeplabv3plus_r101-d8_512x512_20k_voc12aug_20200617_102345-c7ff3d56.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_20k_voc12aug/deeplabv3plus_r101-d8_512x512_20k_voc12aug_20200617_102345.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r50-d8_4xb4-40k_voc12aug-512x512
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 76.81
-      mIoU(ms+flip): 77.57
-  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_40k_voc12aug/deeplabv3plus_r50-d8_512x512_40k_voc12aug_20200613_161759-e1b43aa9.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_40k_voc12aug/deeplabv3plus_r50-d8_512x512_40k_voc12aug_20200613_161759.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r101-d8_4xb4-40k_voc12aug-512x512
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 78.62
-      mIoU(ms+flip): 79.53
-  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_40k_voc12aug/deeplabv3plus_r101-d8_512x512_40k_voc12aug_20200613_205333-faf03387.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_40k_voc12aug/deeplabv3plus_r101-d8_512x512_40k_voc12aug_20200613_205333.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r50-d8_4xb4-40k_pascal-context-480x480
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal Context
-    Metrics:
-      mIoU: 47.3
-      mIoU(ms+flip): 48.47
-  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-40k_pascal-context-480x480.py
-  Metadata:
-    Training Data: Pascal Context
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_40k_pascal_context/deeplabv3plus_r101-d8_480x480_40k_pascal_context_20200911_165459-d3c8a29e.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_40k_pascal_context/deeplabv3plus_r101-d8_480x480_40k_pascal_context-20200911_165459.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r50-d8_4xb4-80k_pascal-context-480x480
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal Context
-    Metrics:
-      mIoU: 47.23
-      mIoU(ms+flip): 48.26
-  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_pascal-context-480x480.py
-  Metadata:
-    Training Data: Pascal Context
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_80k_pascal_context/deeplabv3plus_r101-d8_480x480_80k_pascal_context_20200911_155322-145d3ee8.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_80k_pascal_context/deeplabv3plus_r101-d8_480x480_80k_pascal_context-20200911_155322.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r101-d8_4xb4-40k_pascal-context-59-480x480
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal Context 59
-    Metrics:
-      mIoU: 52.86
-      mIoU(ms+flip): 54.54
-  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-40k_pascal-context-59-480x480.py
-  Metadata:
-    Training Data: Pascal Context 59
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_40k_pascal_context_59/deeplabv3plus_r101-d8_480x480_40k_pascal_context_59_20210416_111233-ed937f15.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_40k_pascal_context_59/deeplabv3plus_r101-d8_480x480_40k_pascal_context_59-20210416_111233.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r101-d8_4xb4-80k_pascal-context-59-480x480
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal Context 59
-    Metrics:
-      mIoU: 53.2
-      mIoU(ms+flip): 54.67
-  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_pascal-context-59-480x480.py
-  Metadata:
-    Training Data: Pascal Context 59
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_80k_pascal_context_59/deeplabv3plus_r101-d8_480x480_80k_pascal_context_59_20210416_111127-7ca0331d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_480x480_80k_pascal_context_59/deeplabv3plus_r101-d8_480x480_80k_pascal_context_59-20210416_111127.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r18-d8_4xb4-80k_loveda-512x512
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: LoveDA
-    Metrics:
-      mIoU: 50.28
-      mIoU(ms+flip): 50.47
-  Config: configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_loveda-512x512.py
-  Metadata:
-    Training Data: LoveDA
-    Batch Size: 16
-    Architecture:
-    - R-18-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.93
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x512_80k_loveda/deeplabv3plus_r18-d8_512x512_80k_loveda_20211104_132800-ce0fa0ca.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x512_80k_loveda/deeplabv3plus_r18-d8_512x512_80k_loveda_20211104_132800.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r50-d8_4xb4-80k_loveda-512x512
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: LoveDA
-    Metrics:
-      mIoU: 50.99
-      mIoU(ms+flip): 50.65
-  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_loveda-512x512.py
-  Metadata:
-    Training Data: LoveDA
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 7.37
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_loveda/deeplabv3plus_r50-d8_512x512_80k_loveda_20211105_080442-f0720392.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_loveda/deeplabv3plus_r50-d8_512x512_80k_loveda_20211105_080442.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r101-d8_4xb4-80k_loveda-512x512
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: LoveDA
-    Metrics:
-      mIoU: 51.47
-      mIoU(ms+flip): 51.32
-  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_loveda-512x512.py
-  Metadata:
-    Training Data: LoveDA
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.84
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_loveda/deeplabv3plus_r101-d8_512x512_80k_loveda_20211105_110759-4c1f297e.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_loveda/deeplabv3plus_r101-d8_512x512_80k_loveda_20211105_110759.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r18-d8_4xb4-80k_potsdam-512x512
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Potsdam
-    Metrics:
-      mIoU: 77.09
-      mIoU(ms+flip): 78.44
-  Config: configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_potsdam-512x512.py
-  Metadata:
-    Training Data: Potsdam
-    Batch Size: 16
-    Architecture:
-    - R-18-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.91
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x512_80k_potsdam/deeplabv3plus_r18-d8_512x512_80k_potsdam_20211219_020601-75fd5bc3.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_512x512_80k_potsdam/deeplabv3plus_r18-d8_512x512_80k_potsdam_20211219_020601.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r50-d8_4xb4-80k_potsdam-512x512
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Potsdam
-    Metrics:
-      mIoU: 78.33
-      mIoU(ms+flip): 79.27
-  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_potsdam-512x512.py
-  Metadata:
-    Training Data: Potsdam
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 7.36
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_potsdam/deeplabv3plus_r50-d8_512x512_80k_potsdam_20211219_031508-7e7a2b24.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_512x512_80k_potsdam/deeplabv3plus_r50-d8_512x512_80k_potsdam_20211219_031508.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Potsdam
-    Metrics:
-      mIoU: 78.7
-      mIoU(ms+flip): 79.47
-  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py
-  Metadata:
-    Training Data: Potsdam
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.83
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_potsdam/deeplabv3plus_r101-d8_512x512_80k_potsdam_20211219_031508-8b112708.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_512x512_80k_potsdam/deeplabv3plus_r101-d8_512x512_80k_potsdam_20211219_031508.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r18-d8_4xb4-80k_vaihingen-512x512
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Vaihingen
-    Metrics:
-      mIoU: 72.5
-      mIoU(ms+flip): 74.13
-  Config: configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_vaihingen-512x512.py
-  Metadata:
-    Training Data: Vaihingen
-    Batch Size: 16
-    Architecture:
-    - R-18-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.91
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r18-d8_4x4_512x512_80k_vaihingen_20211231_230805-7626a263.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r18-d8_4x4_512x512_80k_vaihingen_20211231_230805.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r50-d8_4xb4-80k_vaihingen-512x512
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Vaihingen
-    Metrics:
-      mIoU: 73.97
-      mIoU(ms+flip): 75.05
-  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_vaihingen-512x512.py
-  Metadata:
-    Training Data: Vaihingen
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 7.36
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r50-d8_4x4_512x512_80k_vaihingen_20211231_230816-5040938d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r50-d8_4x4_512x512_80k_vaihingen_20211231_230816.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r101-d8_4xb4-80k_vaihingen-512x512
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Vaihingen
-    Metrics:
-      mIoU: 73.06
-      mIoU(ms+flip): 74.14
-  Config: configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_vaihingen-512x512.py
-  Metadata:
-    Training Data: Vaihingen
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.83
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r101-d8_4x4_512x512_80k_vaihingen_20211231_230816-8a095afa.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r101-d8_4x4_512x512_80k_vaihingen/deeplabv3plus_r101-d8_4x4_512x512_80k_vaihingen_20211231_230816.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r18-d8_4xb4-80k_isaid-896x896
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: iSAID
-    Metrics:
-      mIoU: 61.35
-      mIoU(ms+flip): 62.61
-  Config: configs/deeplabv3plus/deeplabv3plus_r18-d8_4xb4-80k_isaid-896x896.py
-  Metadata:
-    Training Data: iSAID
-    Batch Size: 16
-    Architecture:
-    - R-18-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.19
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_4x4_896x896_80k_isaid/deeplabv3plus_r18-d8_4x4_896x896_80k_isaid_20220110_180526-7059991d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r18-d8_4x4_896x896_80k_isaid/deeplabv3plus_r18-d8_4x4_896x896_80k_isaid_20220110_180526.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r50-d8_4xb4-80k_isaid-896x896
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: iSAID
-    Metrics:
-      mIoU: 67.06
-      mIoU(ms+flip): 68.02
-  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb4-80k_isaid-896x896.py
-  Metadata:
-    Training Data: iSAID
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 21.45
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4x4_896x896_80k_isaid/deeplabv3plus_r50-d8_4x4_896x896_80k_isaid_20220110_180526-598be439.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4x4_896x896_80k_isaid/deeplabv3plus_r50-d8_4x4_896x896_80k_isaid_20220110_180526.log.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
-- Name: deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Mapillary Vistas v1.2
-    Metrics:
-      mIoU: 47.35
-  Config: configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280.py
-  Metadata:
-    Training Data: Mapillary Vistas v1.2
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - DeepLabV3+
-    Training Resources: 4x A100 GPUS
-    Memory (GB): 24.04
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280_20230301_110504-655f8e43.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280/deeplabv3plus_r50-d8_4xb2-300k_mapillay_v1_65-1280x1280_20230301_110504.json
-  Paper:
-    Title: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
-    URL: https://arxiv.org/abs/1802.02611
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/sep_aspp_head.py#L30
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/dmnet/README.md b/mmsegmentation/configs/dmnet/README.md
deleted file mode 100644
index b0cf944..0000000
--- a/mmsegmentation/configs/dmnet/README.md
+++ /dev/null
@@ -1,59 +0,0 @@
-# DMNet
-
-> [Dynamic Multi-scale Filters for Semantic Segmentation](https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/Junjun2016/DMNet">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Multi-scale representation provides an effective way toaddress scale variation of objects and stuff in semantic seg-mentation. Previous works construct multi-scale represen-tation by utilizing different filter sizes, expanding filter sizeswith dilated filters or pooling grids, and the parameters ofthese filters are fixed after training. These methods oftensuffer from heavy computational cost or have more param-eters, and are not adaptive to the input image during in-ference. To address these problems, this paper proposes aDynamic Multi-scale Network (DMNet) to adaptively cap-ture multi-scale contents for predicting pixel-level semanticlabels. DMNet is composed of multiple Dynamic Convolu-tional Modules (DCMs) arranged in parallel, each of whichexploits context-aware filters to estimate semantic represen-tation for a specific scale. The outputs of multiple DCMsare further integrated for final segmentation. We conductextensive experiments to evaluate our DMNet on three chal-lenging semantic segmentation and scene parsing datasets,PASCAL VOC 2012, Pascal-Context, and ADE20K. DMNetachieves a new record 84.4% mIoU on PASCAL VOC 2012test set without MS COCO pre-trained and post-processing,and also obtains state-of-the-art performance on Pascal-Context and ADE20K.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142900781-6215763f-8b71-4e0b-a6b1-c41372db2aa0.png" width="70%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                       | download                                                                                                                                                                                                                                                                                                                                           |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ---------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| DMNet  | R-50-D8  | 512x1024  |   40000 | 7.0      | 3.66           | V100   | 77.78 |         79.14 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x1024_40k_cityscapes/dmnet_r50-d8_512x1024_40k_cityscapes_20201215_042326-615373cf.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x1024_40k_cityscapes/dmnet_r50-d8_512x1024_40k_cityscapes-20201215_042326.log.json)     |
-| DMNet  | R-101-D8 | 512x1024  |   40000 | 10.6     | 2.54           | V100   | 78.37 |         79.72 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x1024_40k_cityscapes/dmnet_r101-d8_512x1024_40k_cityscapes_20201215_043100-8291e976.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x1024_40k_cityscapes/dmnet_r101-d8_512x1024_40k_cityscapes-20201215_043100.log.json) |
-| DMNet  | R-50-D8  | 769x769   |   40000 | 7.9      | 1.57           | V100   | 78.49 |         80.27 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_769x769_40k_cityscapes/dmnet_r50-d8_769x769_40k_cityscapes_20201215_093706-e7f0e23e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_769x769_40k_cityscapes/dmnet_r50-d8_769x769_40k_cityscapes-20201215_093706.log.json)         |
-| DMNet  | R-101-D8 | 769x769   |   40000 | 12.0     | 1.01           | V100   | 77.62 |         78.94 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_769x769_40k_cityscapes/dmnet_r101-d8_769x769_40k_cityscapes_20201215_081348-a74261f6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_769x769_40k_cityscapes/dmnet_r101-d8_769x769_40k_cityscapes-20201215_081348.log.json)     |
-| DMNet  | R-50-D8  | 512x1024  |   80000 | -        | -              | V100   | 79.07 |         80.22 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x1024_80k_cityscapes/dmnet_r50-d8_512x1024_80k_cityscapes_20201215_053728-3c8893b9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x1024_80k_cityscapes/dmnet_r50-d8_512x1024_80k_cityscapes-20201215_053728.log.json)     |
-| DMNet  | R-101-D8 | 512x1024  |   80000 | -        | -              | V100   | 79.64 |         80.67 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x1024_80k_cityscapes/dmnet_r101-d8_512x1024_80k_cityscapes_20201215_031718-fa081cb8.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x1024_80k_cityscapes/dmnet_r101-d8_512x1024_80k_cityscapes-20201215_031718.log.json) |
-| DMNet  | R-50-D8  | 769x769   |   80000 | -        | -              | V100   | 79.22 |         80.55 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_769x769_80k_cityscapes/dmnet_r50-d8_769x769_80k_cityscapes_20201215_034006-6060840e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_769x769_80k_cityscapes/dmnet_r50-d8_769x769_80k_cityscapes-20201215_034006.log.json)         |
-| DMNet  | R-101-D8 | 769x769   |   80000 | -        | -              | V100   | 79.19 |         80.65 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_769x769_80k_cityscapes/dmnet_r101-d8_769x769_80k_cityscapes_20201215_082810-7f0de59a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_769x769_80k_cityscapes/dmnet_r101-d8_769x769_80k_cityscapes-20201215_082810.log.json)     |
-
-### ADE20K
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                   | download                                                                                                                                                                                                                                                                                                                           |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| DMNet  | R-50-D8  | 512x512   |   80000 | 9.4      | 20.95          | V100   | 42.37 |         43.62 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x512_80k_ade20k/dmnet_r50-d8_512x512_80k_ade20k_20201215_144744-f89092a6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x512_80k_ade20k/dmnet_r50-d8_512x512_80k_ade20k-20201215_144744.log.json)         |
-| DMNet  | R-101-D8 | 512x512   |   80000 | 13.0     | 13.88          | V100   | 45.34 |         46.13 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x512_80k_ade20k/dmnet_r101-d8_512x512_80k_ade20k_20201215_104812-bfa45311.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x512_80k_ade20k/dmnet_r101-d8_512x512_80k_ade20k-20201215_104812.log.json)     |
-| DMNet  | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 43.15 |         44.17 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x512_160k_ade20k/dmnet_r50-d8_512x512_160k_ade20k_20201215_115313-025ab3f9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x512_160k_ade20k/dmnet_r50-d8_512x512_160k_ade20k-20201215_115313.log.json)     |
-| DMNet  | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 45.42 |         46.76 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet/dmnet_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x512_160k_ade20k/dmnet_r101-d8_512x512_160k_ade20k_20201215_111145-a0bc02ef.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x512_160k_ade20k/dmnet_r101-d8_512x512_160k_ade20k-20201215_111145.log.json) |
-
-## Citation
-
-```bibtex
-@InProceedings{He_2019_ICCV,
-author = {He, Junjun and Deng, Zhongying and Qiao, Yu},
-title = {Dynamic Multi-Scale Filters for Semantic Segmentation},
-booktitle = {Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV)},
-month = {October},
-year = {2019}
-}
-```
diff --git a/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 9832b62..0000000
--- a/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './dmnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index 03346c5..0000000
--- a/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './dmnet_r50-d8_4xb2-40k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index fd7e9ac..0000000
--- a/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './dmnet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 2205e60..0000000
--- a/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './dmnet_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 23e215b..0000000
--- a/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './dmnet_r50-d8_4xb4-160k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 5c25587..0000000
--- a/mmsegmentation/configs/dmnet/dmnet_r101-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './dmnet_r50-d8_4xb4-80k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index aa86b01..0000000
--- a/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/dmnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index 8c2dbf3..0000000
--- a/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/dmnet_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index bc21606..0000000
--- a/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/dmnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index e32ae71..0000000
--- a/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/dmnet_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 71d0a04..0000000
--- a/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/dmnet_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 727bed0..0000000
--- a/mmsegmentation/configs/dmnet/dmnet_r50-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/dmnet_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/dmnet/metafile.yaml b/mmsegmentation/configs/dmnet/metafile.yaml
deleted file mode 100644
index 7f5e536..0000000
--- a/mmsegmentation/configs/dmnet/metafile.yaml
+++ /dev/null
@@ -1,296 +0,0 @@
-Collections:
-- Name: DMNet
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-    - ADE20K
-  Paper:
-    Title: Dynamic Multi-scale Filters for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
-  README: configs/dmnet/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: dmnet_r50-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: DMNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.78
-      mIoU(ms+flip): 79.14
-  Config: configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - DMNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 7.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x1024_40k_cityscapes/dmnet_r50-d8_512x1024_40k_cityscapes_20201215_042326-615373cf.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x1024_40k_cityscapes/dmnet_r50-d8_512x1024_40k_cityscapes-20201215_042326.log.json
-  Paper:
-    Title: Dynamic Multi-scale Filters for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
-  Framework: PyTorch
-- Name: dmnet_r101-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: DMNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.37
-      mIoU(ms+flip): 79.72
-  Config: configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - DMNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x1024_40k_cityscapes/dmnet_r101-d8_512x1024_40k_cityscapes_20201215_043100-8291e976.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x1024_40k_cityscapes/dmnet_r101-d8_512x1024_40k_cityscapes-20201215_043100.log.json
-  Paper:
-    Title: Dynamic Multi-scale Filters for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
-  Framework: PyTorch
-- Name: dmnet_r50-d8_4xb2-40k_cityscapes-769x769
-  In Collection: DMNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.49
-      mIoU(ms+flip): 80.27
-  Config: configs/dmnet/dmnet_r50-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - DMNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 7.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_769x769_40k_cityscapes/dmnet_r50-d8_769x769_40k_cityscapes_20201215_093706-e7f0e23e.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_769x769_40k_cityscapes/dmnet_r50-d8_769x769_40k_cityscapes-20201215_093706.log.json
-  Paper:
-    Title: Dynamic Multi-scale Filters for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
-  Framework: PyTorch
-- Name: dmnet_r101-d8_4xb2-40k_cityscapes-769x769
-  In Collection: DMNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.62
-      mIoU(ms+flip): 78.94
-  Config: configs/dmnet/dmnet_r101-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - DMNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 12.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_769x769_40k_cityscapes/dmnet_r101-d8_769x769_40k_cityscapes_20201215_081348-a74261f6.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_769x769_40k_cityscapes/dmnet_r101-d8_769x769_40k_cityscapes-20201215_081348.log.json
-  Paper:
-    Title: Dynamic Multi-scale Filters for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
-  Framework: PyTorch
-- Name: dmnet_r50-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: DMNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.07
-      mIoU(ms+flip): 80.22
-  Config: configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - DMNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x1024_80k_cityscapes/dmnet_r50-d8_512x1024_80k_cityscapes_20201215_053728-3c8893b9.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x1024_80k_cityscapes/dmnet_r50-d8_512x1024_80k_cityscapes-20201215_053728.log.json
-  Paper:
-    Title: Dynamic Multi-scale Filters for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
-  Framework: PyTorch
-- Name: dmnet_r101-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: DMNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.64
-      mIoU(ms+flip): 80.67
-  Config: configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - DMNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x1024_80k_cityscapes/dmnet_r101-d8_512x1024_80k_cityscapes_20201215_031718-fa081cb8.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x1024_80k_cityscapes/dmnet_r101-d8_512x1024_80k_cityscapes-20201215_031718.log.json
-  Paper:
-    Title: Dynamic Multi-scale Filters for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
-  Framework: PyTorch
-- Name: dmnet_r50-d8_4xb2-80k_cityscapes-769x769
-  In Collection: DMNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.22
-      mIoU(ms+flip): 80.55
-  Config: configs/dmnet/dmnet_r50-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - DMNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_769x769_80k_cityscapes/dmnet_r50-d8_769x769_80k_cityscapes_20201215_034006-6060840e.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_769x769_80k_cityscapes/dmnet_r50-d8_769x769_80k_cityscapes-20201215_034006.log.json
-  Paper:
-    Title: Dynamic Multi-scale Filters for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
-  Framework: PyTorch
-- Name: dmnet_r101-d8_4xb2-80k_cityscapes-769x769
-  In Collection: DMNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.19
-      mIoU(ms+flip): 80.65
-  Config: configs/dmnet/dmnet_r101-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - DMNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_769x769_80k_cityscapes/dmnet_r101-d8_769x769_80k_cityscapes_20201215_082810-7f0de59a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_769x769_80k_cityscapes/dmnet_r101-d8_769x769_80k_cityscapes-20201215_082810.log.json
-  Paper:
-    Title: Dynamic Multi-scale Filters for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
-  Framework: PyTorch
-- Name: dmnet_r50-d8_4xb4-80k_ade20k-512x512
-  In Collection: DMNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.37
-      mIoU(ms+flip): 43.62
-  Config: configs/dmnet/dmnet_r50-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DMNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.4
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x512_80k_ade20k/dmnet_r50-d8_512x512_80k_ade20k_20201215_144744-f89092a6.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x512_80k_ade20k/dmnet_r50-d8_512x512_80k_ade20k-20201215_144744.log.json
-  Paper:
-    Title: Dynamic Multi-scale Filters for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
-  Framework: PyTorch
-- Name: dmnet_r101-d8_4xb4-80k_ade20k-512x512
-  In Collection: DMNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 45.34
-      mIoU(ms+flip): 46.13
-  Config: configs/dmnet/dmnet_r101-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DMNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 13.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x512_80k_ade20k/dmnet_r101-d8_512x512_80k_ade20k_20201215_104812-bfa45311.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x512_80k_ade20k/dmnet_r101-d8_512x512_80k_ade20k-20201215_104812.log.json
-  Paper:
-    Title: Dynamic Multi-scale Filters for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
-  Framework: PyTorch
-- Name: dmnet_r50-d8_4xb4-160k_ade20k-512x512
-  In Collection: DMNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 43.15
-      mIoU(ms+flip): 44.17
-  Config: configs/dmnet/dmnet_r50-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DMNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x512_160k_ade20k/dmnet_r50-d8_512x512_160k_ade20k_20201215_115313-025ab3f9.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r50-d8_512x512_160k_ade20k/dmnet_r50-d8_512x512_160k_ade20k-20201215_115313.log.json
-  Paper:
-    Title: Dynamic Multi-scale Filters for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
-  Framework: PyTorch
-- Name: dmnet_r101-d8_4xb4-160k_ade20k-512x512
-  In Collection: DMNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 45.42
-      mIoU(ms+flip): 46.76
-  Config: configs/dmnet/dmnet_r101-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DMNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x512_160k_ade20k/dmnet_r101-d8_512x512_160k_ade20k_20201215_111145-a0bc02ef.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dmnet/dmnet_r101-d8_512x512_160k_ade20k/dmnet_r101-d8_512x512_160k_ade20k-20201215_111145.log.json
-  Paper:
-    Title: Dynamic Multi-scale Filters for Semantic Segmentation
-    URL: https://openaccess.thecvf.com/content_ICCV_2019/papers/He_Dynamic_Multi-Scale_Filters_for_Semantic_Segmentation_ICCV_2019_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dm_head.py#L93
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/dnlnet/README.md b/mmsegmentation/configs/dnlnet/README.md
deleted file mode 100644
index 6835ffd..0000000
--- a/mmsegmentation/configs/dnlnet/README.md
+++ /dev/null
@@ -1,62 +0,0 @@
-# DNLNet
-
-> [Disentangled Non-Local Neural Networks](https://arxiv.org/abs/2006.06668)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/yinmh17/DNL-Semantic-Segmentation">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-The non-local block is a popular module for strengthening the context modeling ability of a regular convolutional neural network. This paper first studies the non-local block in depth, where we find that its attention computation can be split into two terms, a whitened pairwise term accounting for the relationship between two pixels and a unary term representing the saliency of every pixel. We also observe that the two terms trained alone tend to model different visual clues, e.g. the whitened pairwise term learns within-region relationships while the unary term learns salient boundaries. However, the two terms are tightly coupled in the non-local block, which hinders the learning of each. Based on these findings, we present the disentangled non-local block, where the two terms are decoupled to facilitate learning for both terms. We demonstrate the effectiveness of the decoupled design on various tasks, such as semantic segmentation on Cityscapes, ADE20K and PASCAL Context, object detection on COCO, and action recognition on Kinetics.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142900944-b8d93301-d2ce-488e-a461-b0813f96be49.png" width="70%"/>
-</div>
-
-## Results and models (in progress)
-
-### Cityscapes
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                      | download                                                                                                                                                                                                                                                                                                                                     |
-| ------ | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | --------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| DNLNet | R-50-D8  | 512x1024  |   40000 |      7.3 | 2.56           | V100   | 78.61 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x1024_40k_cityscapes/dnl_r50-d8_512x1024_40k_cityscapes_20200904_233629-53d4ea93.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x1024_40k_cityscapes/dnl_r50-d8_512x1024_40k_cityscapes-20200904_233629.log.json)     |
-| DNLNet | R-101-D8 | 512x1024  |   40000 |     10.9 | 1.96           | V100   | 78.31 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x1024_40k_cityscapes/dnl_r101-d8_512x1024_40k_cityscapes_20200904_233629-9928ffef.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x1024_40k_cityscapes/dnl_r101-d8_512x1024_40k_cityscapes-20200904_233629.log.json) |
-| DNLNet | R-50-D8  | 769x769   |   40000 |      9.2 | 1.50           | V100   | 78.44 | 80.27         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_769x769_40k_cityscapes/dnl_r50-d8_769x769_40k_cityscapes_20200820_232206-0f283785.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_769x769_40k_cityscapes/dnl_r50-d8_769x769_40k_cityscapes-20200820_232206.log.json)         |
-| DNLNet | R-101-D8 | 769x769   |   40000 |     12.6 | 1.02           | V100   | 76.39 | 77.77         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_769x769_40k_cityscapes/dnl_r101-d8_769x769_40k_cityscapes_20200820_171256-76c596df.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_769x769_40k_cityscapes/dnl_r101-d8_769x769_40k_cityscapes-20200820_171256.log.json)     |
-| DNLNet | R-50-D8  | 512x1024  |   80000 |        - | -              | V100   | 79.33 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x1024_80k_cityscapes/dnl_r50-d8_512x1024_80k_cityscapes_20200904_233629-58b2f778.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x1024_80k_cityscapes/dnl_r50-d8_512x1024_80k_cityscapes-20200904_233629.log.json)     |
-| DNLNet | R-101-D8 | 512x1024  |   80000 |        - | -              | V100   | 80.41 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x1024_80k_cityscapes/dnl_r101-d8_512x1024_80k_cityscapes_20200904_233629-758e2dd4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x1024_80k_cityscapes/dnl_r101-d8_512x1024_80k_cityscapes-20200904_233629.log.json) |
-| DNLNet | R-50-D8  | 769x769   |   80000 |        - | -              | V100   | 79.36 | 80.70         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_769x769_80k_cityscapes/dnl_r50-d8_769x769_80k_cityscapes_20200820_011925-366bc4c7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_769x769_80k_cityscapes/dnl_r50-d8_769x769_80k_cityscapes-20200820_011925.log.json)         |
-| DNLNet | R-101-D8 | 769x769   |   80000 |        - | -              | V100   | 79.41 | 80.68         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_769x769_80k_cityscapes/dnl_r101-d8_769x769_80k_cityscapes_20200821_051111-95ff84ab.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_769x769_80k_cityscapes/dnl_r101-d8_769x769_80k_cityscapes-20200821_051111.log.json)     |
-
-### ADE20K
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                  | download                                                                                                                                                                                                                                                                                                                     |
-| ------ | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | ----------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| DNLNet | R-50-D8  | 512x512   |   80000 |      8.8 | 20.66          | V100   | 41.76 | 42.99         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x512_80k_ade20k/dnl_r50-d8_512x512_80k_ade20k_20200826_183354-1cf6e0c1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x512_80k_ade20k/dnl_r50-d8_512x512_80k_ade20k-20200826_183354.log.json)         |
-| DNLNet | R-101-D8 | 512x512   |   80000 |     12.8 | 12.54          | V100   | 43.76 | 44.91         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x512_80k_ade20k/dnl_r101-d8_512x512_80k_ade20k_20200826_183354-d820d6ea.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x512_80k_ade20k/dnl_r101-d8_512x512_80k_ade20k-20200826_183354.log.json)     |
-| DNLNet | R-50-D8  | 512x512   |  160000 |        - | -              | V100   | 41.87 | 43.01         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x512_160k_ade20k/dnl_r50-d8_512x512_160k_ade20k_20200826_183350-37837798.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x512_160k_ade20k/dnl_r50-d8_512x512_160k_ade20k-20200826_183350.log.json)     |
-| DNLNet | R-101-D8 | 512x512   |  160000 |        - | -              | V100   | 44.25 | 45.78         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet/dnl_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x512_160k_ade20k/dnl_r101-d8_512x512_160k_ade20k_20200826_183350-ed522c61.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x512_160k_ade20k/dnl_r101-d8_512x512_160k_ade20k-20200826_183350.log.json) |
-
-## Notes
-
-This example is to reproduce ["Disentangled Non-Local Neural Networks"](https://arxiv.org/abs/2006.06668) for semantic segmentation. It is still in progress.
-
-## Citation
-
-```bibtex
-@misc{yin2020disentangled,
-    title={Disentangled Non-Local Neural Networks},
-    author={Minghao Yin and Zhuliang Yao and Yue Cao and Xiu Li and Zheng Zhang and Stephen Lin and Han Hu},
-    year={2020},
-    booktitle={ECCV}
-}
-```
diff --git a/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 310d84e..0000000
--- a/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './dnl_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index a94dbb8..0000000
--- a/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './dnl_r50-d8_4xb2-40k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index f9b6d5e..0000000
--- a/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './dnl_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 9c7d557..0000000
--- a/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './dnl_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 1edc26f..0000000
--- a/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './dnl_r50-d8_4xb4-160k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index d29c17e..0000000
--- a/mmsegmentation/configs/dnlnet/dnl_r101-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './dnl_r50-d8_4xb4-80k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index be38992..0000000
--- a/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/dnl_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index 9eaaa63..0000000
--- a/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/dnl_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 2e43178..0000000
--- a/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/dnl_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index cb379c1..0000000
--- a/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,16 +0,0 @@
-_base_ = [
-    '../_base_/models/dnl_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
-
-optim_wrapper = dict(
-    paramwise_cfg=dict(
-        custom_keys=dict(theta=dict(wd_mult=0.), phi=dict(wd_mult=0.))))
diff --git a/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index b2ae2a8..0000000
--- a/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/dnl_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index f310a4e..0000000
--- a/mmsegmentation/configs/dnlnet/dnl_r50-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/dnl_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/dnlnet/metafile.yaml b/mmsegmentation/configs/dnlnet/metafile.yaml
deleted file mode 100644
index 22e48d3..0000000
--- a/mmsegmentation/configs/dnlnet/metafile.yaml
+++ /dev/null
@@ -1,292 +0,0 @@
-Collections:
-- Name: DNLNet
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-    - ADE20K
-  Paper:
-    Title: Disentangled Non-Local Neural Networks
-    URL: https://arxiv.org/abs/2006.06668
-  README: configs/dnlnet/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: dnl_r50-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: DNLNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.61
-  Config: configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - DNLNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 7.3
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x1024_40k_cityscapes/dnl_r50-d8_512x1024_40k_cityscapes_20200904_233629-53d4ea93.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x1024_40k_cityscapes/dnl_r50-d8_512x1024_40k_cityscapes-20200904_233629.log.json
-  Paper:
-    Title: Disentangled Non-Local Neural Networks
-    URL: https://arxiv.org/abs/2006.06668
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
-  Framework: PyTorch
-- Name: dnl_r101-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: DNLNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.31
-  Config: configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - DNLNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x1024_40k_cityscapes/dnl_r101-d8_512x1024_40k_cityscapes_20200904_233629-9928ffef.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x1024_40k_cityscapes/dnl_r101-d8_512x1024_40k_cityscapes-20200904_233629.log.json
-  Paper:
-    Title: Disentangled Non-Local Neural Networks
-    URL: https://arxiv.org/abs/2006.06668
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
-  Framework: PyTorch
-- Name: dnl_r50-d8_4xb2-40k_cityscapes-769x769
-  In Collection: DNLNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.44
-      mIoU(ms+flip): 80.27
-  Config: configs/dnlnet/dnl_r50-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - DNLNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_769x769_40k_cityscapes/dnl_r50-d8_769x769_40k_cityscapes_20200820_232206-0f283785.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_769x769_40k_cityscapes/dnl_r50-d8_769x769_40k_cityscapes-20200820_232206.log.json
-  Paper:
-    Title: Disentangled Non-Local Neural Networks
-    URL: https://arxiv.org/abs/2006.06668
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
-  Framework: PyTorch
-- Name: dnl_r101-d8_4xb2-40k_cityscapes-769x769
-  In Collection: DNLNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.39
-      mIoU(ms+flip): 77.77
-  Config: configs/dnlnet/dnl_r101-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - DNLNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 12.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_769x769_40k_cityscapes/dnl_r101-d8_769x769_40k_cityscapes_20200820_171256-76c596df.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_769x769_40k_cityscapes/dnl_r101-d8_769x769_40k_cityscapes-20200820_171256.log.json
-  Paper:
-    Title: Disentangled Non-Local Neural Networks
-    URL: https://arxiv.org/abs/2006.06668
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
-  Framework: PyTorch
-- Name: dnl_r50-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: DNLNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.33
-  Config: configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - DNLNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x1024_80k_cityscapes/dnl_r50-d8_512x1024_80k_cityscapes_20200904_233629-58b2f778.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x1024_80k_cityscapes/dnl_r50-d8_512x1024_80k_cityscapes-20200904_233629.log.json
-  Paper:
-    Title: Disentangled Non-Local Neural Networks
-    URL: https://arxiv.org/abs/2006.06668
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
-  Framework: PyTorch
-- Name: dnl_r101-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: DNLNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 80.41
-  Config: configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - DNLNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x1024_80k_cityscapes/dnl_r101-d8_512x1024_80k_cityscapes_20200904_233629-758e2dd4.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x1024_80k_cityscapes/dnl_r101-d8_512x1024_80k_cityscapes-20200904_233629.log.json
-  Paper:
-    Title: Disentangled Non-Local Neural Networks
-    URL: https://arxiv.org/abs/2006.06668
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
-  Framework: PyTorch
-- Name: dnl_r50-d8_4xb2-80k_cityscapes-769x769
-  In Collection: DNLNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.36
-      mIoU(ms+flip): 80.7
-  Config: configs/dnlnet/dnl_r50-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - DNLNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_769x769_80k_cityscapes/dnl_r50-d8_769x769_80k_cityscapes_20200820_011925-366bc4c7.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_769x769_80k_cityscapes/dnl_r50-d8_769x769_80k_cityscapes-20200820_011925.log.json
-  Paper:
-    Title: Disentangled Non-Local Neural Networks
-    URL: https://arxiv.org/abs/2006.06668
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
-  Framework: PyTorch
-- Name: dnl_r101-d8_4xb2-80k_cityscapes-769x769
-  In Collection: DNLNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.41
-      mIoU(ms+flip): 80.68
-  Config: configs/dnlnet/dnl_r101-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - DNLNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_769x769_80k_cityscapes/dnl_r101-d8_769x769_80k_cityscapes_20200821_051111-95ff84ab.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_769x769_80k_cityscapes/dnl_r101-d8_769x769_80k_cityscapes-20200821_051111.log.json
-  Paper:
-    Title: Disentangled Non-Local Neural Networks
-    URL: https://arxiv.org/abs/2006.06668
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
-  Framework: PyTorch
-- Name: dnl_r50-d8_4xb4-80k_ade20k-512x512
-  In Collection: DNLNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 41.76
-      mIoU(ms+flip): 42.99
-  Config: configs/dnlnet/dnl_r50-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DNLNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x512_80k_ade20k/dnl_r50-d8_512x512_80k_ade20k_20200826_183354-1cf6e0c1.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x512_80k_ade20k/dnl_r50-d8_512x512_80k_ade20k-20200826_183354.log.json
-  Paper:
-    Title: Disentangled Non-Local Neural Networks
-    URL: https://arxiv.org/abs/2006.06668
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
-  Framework: PyTorch
-- Name: dnl_r101-d8_4xb4-80k_ade20k-512x512
-  In Collection: DNLNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 43.76
-      mIoU(ms+flip): 44.91
-  Config: configs/dnlnet/dnl_r101-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DNLNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 12.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x512_80k_ade20k/dnl_r101-d8_512x512_80k_ade20k_20200826_183354-d820d6ea.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x512_80k_ade20k/dnl_r101-d8_512x512_80k_ade20k-20200826_183354.log.json
-  Paper:
-    Title: Disentangled Non-Local Neural Networks
-    URL: https://arxiv.org/abs/2006.06668
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
-  Framework: PyTorch
-- Name: dnl_r50-d8_4xb4-160k_ade20k-512x512
-  In Collection: DNLNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 41.87
-      mIoU(ms+flip): 43.01
-  Config: configs/dnlnet/dnl_r50-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - DNLNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x512_160k_ade20k/dnl_r50-d8_512x512_160k_ade20k_20200826_183350-37837798.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r50-d8_512x512_160k_ade20k/dnl_r50-d8_512x512_160k_ade20k-20200826_183350.log.json
-  Paper:
-    Title: Disentangled Non-Local Neural Networks
-    URL: https://arxiv.org/abs/2006.06668
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
-  Framework: PyTorch
-- Name: dnl_r101-d8_4xb4-160k_ade20k-512x512
-  In Collection: DNLNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 44.25
-      mIoU(ms+flip): 45.78
-  Config: configs/dnlnet/dnl_r101-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - DNLNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x512_160k_ade20k/dnl_r101-d8_512x512_160k_ade20k_20200826_183350-ed522c61.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dnlnet/dnl_r101-d8_512x512_160k_ade20k/dnl_r101-d8_512x512_160k_ade20k-20200826_183350.log.json
-  Paper:
-    Title: Disentangled Non-Local Neural Networks
-    URL: https://arxiv.org/abs/2006.06668
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dnl_head.py#L88
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/dpt/README.md b/mmsegmentation/configs/dpt/README.md
deleted file mode 100644
index b3a5573..0000000
--- a/mmsegmentation/configs/dpt/README.md
+++ /dev/null
@@ -1,67 +0,0 @@
-# DPT
-
-> [Vision Transformer for Dense Prediction](https://arxiv.org/abs/2103.13413)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/isl-org/DPT">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dpt_head.py#L215">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-We introduce dense vision transformers, an architecture that leverages vision transformers in place of convolutional networks as a backbone for dense prediction tasks. We assemble tokens from various stages of the vision transformer into image-like representations at various resolutions and progressively combine them into full-resolution predictions using a convolutional decoder. The transformer backbone processes representations at a constant and relatively high resolution and has a global receptive field at every stage. These properties allow the dense vision transformer to provide finer-grained and more globally coherent predictions when compared to fully-convolutional networks. Our experiments show that this architecture yields substantial improvements on dense prediction tasks, especially when a large amount of training data is available. For monocular depth estimation, we observe an improvement of up to 28% in relative performance when compared to a state-of-the-art fully-convolutional network. When applied to semantic segmentation, dense vision transformers set a new state of the art on ADE20K with 49.02% mIoU. We further show that the architecture can be fine-tuned on smaller datasets such as NYUv2, KITTI, and Pascal Context where it also sets the new state of the art. Our models are available at [this https URL](https://github.com/isl-org/DPT).
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142901057-00aabea5-dab4-43d3-a14a-5f73eb5dd9b9.png" width="80%"/>
-</div>
-
-## Usage
-
-To use other repositories' pre-trained models, it is necessary to convert keys.
-
-We provide a script [`vit2mmseg.py`](../../tools/model_converters/vit2mmseg.py) in the tools directory to convert the key of models from [timm](https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/vision_transformer.py) to MMSegmentation style.
-
-```shell
-python tools/model_converters/vit2mmseg.py ${PRETRAIN_PATH} ${STORE_PATH}
-```
-
-E.g.
-
-```shell
-python tools/model_converters/vit2mmseg.py https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-vitjx/jx_vit_base_p16_224-80ecf9dd.pth pretrain/jx_vit_base_p16_224-80ecf9dd.pth
-```
-
-This script convert model from `PRETRAIN_PATH` and store the converted model in `STORE_PATH`.
-
-## Results and models
-
-### ADE20K
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                               | download                                                                                                                                                                                                                                                                                               |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| DPT    | ViT-B    | 512x512   |  160000 | 8.09     | 10.41          | V100   | 46.97 |         48.34 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dpt/dpt_vit-b16_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/dpt/dpt_vit-b16_512x512_160k_ade20k/dpt_vit-b16_512x512_160k_ade20k-db31cf52.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/dpt/dpt_vit-b16_512x512_160k_ade20k/dpt_vit-b16_512x512_160k_ade20k-20210809_172025.log.json) |
-
-## Citation
-
-```bibtex
-@article{dosoViTskiy2020,
-  title={An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale},
-  author={DosoViTskiy, Alexey and Beyer, Lucas and Kolesnikov, Alexander and Weissenborn, Dirk and Zhai, Xiaohua and Unterthiner, Thomas and  Dehghani, Mostafa and Minderer, Matthias and Heigold, Georg and Gelly, Sylvain and Uszkoreit, Jakob and Houlsby, Neil},
-  journal={arXiv preprint arXiv:2010.11929},
-  year={2020}
-}
-
-@article{Ranftl2021,
-  author    = {Ren\'{e} Ranftl and Alexey Bochkovskiy and Vladlen Koltun},
-  title     = {Vision Transformers for Dense Prediction},
-  journal   = {ArXiv preprint},
-  year      = {2021},
-}
-```
diff --git a/mmsegmentation/configs/dpt/dpt_vit-b16_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/dpt/dpt_vit-b16_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 56b33d9..0000000
--- a/mmsegmentation/configs/dpt/dpt_vit-b16_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,39 +0,0 @@
-_base_ = [
-    '../_base_/models/dpt_vit-b16.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
-# AdamW optimizer, no weight decay for position embedding & layer norm
-# in backbone
-
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
-    paramwise_cfg=dict(
-        custom_keys={
-            'pos_embed': dict(decay_mult=0.),
-            'cls_token': dict(decay_mult=0.),
-            'norm': dict(decay_mult=0.)
-        }))
-
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        eta_min=0.0,
-        power=1.0,
-        begin=1500,
-        end=160000,
-        by_epoch=False,
-    )
-]
-
-# By default, models are trained on 8 GPUs with 2 images per GPU
-train_dataloader = dict(batch_size=2, num_workers=2)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/dpt/metafile.yaml b/mmsegmentation/configs/dpt/metafile.yaml
deleted file mode 100644
index b721e04..0000000
--- a/mmsegmentation/configs/dpt/metafile.yaml
+++ /dev/null
@@ -1,37 +0,0 @@
-Collections:
-- Name: DPT
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - ADE20K
-  Paper:
-    Title: Vision Transformer for Dense Prediction
-    URL: https://arxiv.org/abs/2103.13413
-  README: configs/dpt/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: dpt_vit-b16_8xb2-160k_ade20k-512x512
-  In Collection: DPT
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 46.97
-      mIoU(ms+flip): 48.34
-  Config: configs/dpt/dpt_vit-b16_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - ViT-B
-    - DPT
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 8.09
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/dpt/dpt_vit-b16_512x512_160k_ade20k/dpt_vit-b16_512x512_160k_ade20k-db31cf52.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/dpt/dpt_vit-b16_512x512_160k_ade20k/dpt_vit-b16_512x512_160k_ade20k-20210809_172025.log.json
-  Paper:
-    Title: Vision Transformer for Dense Prediction
-    URL: https://arxiv.org/abs/2103.13413
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/dpt_head.py#L215
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/dsdl/README.md b/mmsegmentation/configs/dsdl/README.md
deleted file mode 100644
index e564cff..0000000
--- a/mmsegmentation/configs/dsdl/README.md
+++ /dev/null
@@ -1,103 +0,0 @@
-# DSDL: Standard Description Language for DataSet
-
-<!-- [SKIP DEV CHECK] -->
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Data is the cornerstone of artificial intelligence. The efficiency of data acquisition, exchange, and application directly impacts the advances in technologies and applications. Over the long history of AI, a vast quantity of data sets have been developed and distributed. However, these datasets are defined in very different forms, which incurs significant overhead when it comes to exchange, integration, and utilization -- it is often the case that one needs to develop a new customized tool or script in order to incorporate a new dataset into a workflow.
-
-To overcome such difficulties, we develop **Data Set Description Language (DSDL)**. More details please visit our [official documents](https://opendatalab.github.io/dsdl-docs/getting_started/overview/), dsdl datasets can be downloaded from our platform [OpenDataLab](https://opendatalab.com/).
-
-<!-- [IMAGE] -->
-
-## Steps
-
-- install dsdl and opendatalab:
-
-  ```
-  pip install dsdl
-  pip install opendatalab
-  ```
-
-- install mmseg and pytorch:
-  please refer this [installation documents](https://mmsegmentation.readthedocs.io/en/latest/get_started.html).
-
-- prepare dsdl dataset (take voc2012 as an example)
-
-  - dowaload dsdl dataset (you will need an opendatalab account to do so. [register one now](https://opendatalab.com/))
-
-    ```
-    cd data
-
-    odl login
-    odl get PASCAL_VOC2012
-    ```
-
-    usually, dataset is compressed on opendatalab platform, the downloaded voc 2012 dataset should be like this:
-
-    ```
-    data/
-    ├── PASCAL_VOC2012
-    │   ├── dsdl
-    │   │   ├── dsdl_Det_full.zip
-    │   │   └── dsdl_SemSeg_full.zip
-    │   ├── raw
-    │   │   ├── VOC2012test.tar
-    │   │   ├── VOCdevkit_18-May-2011.tar
-    │   │   └── VOCtrainval_11-May-2012.tar
-    │   └── README.md
-    └── ...
-    ```
-
-  - decompress dataset
-
-    ```
-    cd dsdl
-    unzip dsdl_SemSeg_full.zip
-    ```
-
-    as we do not need detection dsdl files, we only decompress the semantic segmentation files here.
-
-    ```
-    cd ../raw
-    tar -xvf VOCtrainval_11-May-2012.tar
-    tar -xvf VOC2012test.tar
-
-    cd ../../
-    ```
-
-- change traning config
-
-  open the [voc config file](voc.py) and set some file paths as below:
-
-  ```
-  data_root = 'data/PASCAL_VOC2012'
-  img_prefix = 'raw/VOCdevkit/VOC2012'
-  train_ann = 'dsdl/dsdl_SemSeg_full/set-train/train.yaml'
-  val_ann = 'dsdl/dsdl_SemSeg_full/set-val/val.yaml'
-  ```
-
-  as dsdl datasets with one task using one dataloader, we can simplly change these file paths to train a model on a different dataset.
-
-- train:
-
-  - using single gpu:
-
-  ```
-  python tools/train.py {config_file}
-  ```
-
-  - using slrum:
-
-  ```
-  ./tools/slurm_train.sh {partition} {job_name} {config_file} {work_dir} {gpu_nums}
-  ```
-
-## Test Results
-
-|  Datasets  |                                                                                        Model                                                                                         | mIoU(%) |          Config           |
-| :--------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :-----: | :-----------------------: |
-|  voc2012   |    [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x512_20k_voc12aug/deeplabv3_r50-d8_512x512_20k_voc12aug_20200617_010906-596905ef.pth)    |  76.73  |    [config](./voc.py)     |
-| cityscapes | [model](https://download.openmmlab.com/mmsegmentation/v0.5/deeplabv3/deeplabv3_r50-d8_512x1024_40k_cityscapes/deeplabv3_r50-d8_512x1024_40k_cityscapes_20200605_022449-acadc2f8.pth) |  79.01  | [config](./cityscapes.py) |
diff --git a/mmsegmentation/configs/dsdl/cityscapes.py b/mmsegmentation/configs/dsdl/cityscapes.py
deleted file mode 100644
index 94ccc06..0000000
--- a/mmsegmentation/configs/dsdl/cityscapes.py
+++ /dev/null
@@ -1,70 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_r50-d8.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
-# dataset settings
-dataset_type = 'DSDLSegDataset'
-data_root = 'data/CityScapes'
-img_prefix = 'raw/CityScapes'
-train_ann = 'dsdl/dsdl_SemSeg_full/set-train/train.yaml'
-val_ann = 'dsdl/dsdl_SemSeg_full/set-val/val.yaml'
-
-used_labels = [
-    'road', 'sidewalk', 'building', 'wall', 'fence', 'pole', 'traffic_light',
-    'traffic_sign', 'vegetation', 'terrain', 'sky', 'person', 'rider', 'car',
-    'truck', 'bus', 'train', 'motorcycle', 'bicycle'
-]
-
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(
-        type='RandomResize',
-        scale=(2048, 1024),
-        ratio_range=(0.5, 2.0),
-        keep_ratio=True),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=2,
-    num_workers=2,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(img_path=img_prefix, seg_map_path=img_prefix),
-        ann_file=train_ann,
-        used_labels=used_labels,
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(img_path=img_prefix, seg_map_path=img_prefix),
-        ann_file=val_ann,
-        used_labels=used_labels,
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
-test_evaluator = val_evaluator
diff --git a/mmsegmentation/configs/dsdl/voc.py b/mmsegmentation/configs/dsdl/voc.py
deleted file mode 100644
index c1895f7..0000000
--- a/mmsegmentation/configs/dsdl/voc.py
+++ /dev/null
@@ -1,65 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_r50-d8.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_20k.py'
-]
-
-# dataset settings
-dataset_type = 'DSDLSegDataset'
-data_root = 'data/PASCAL_VOC2012'
-img_prefix = 'raw/VOCdevkit/VOC2012'
-train_ann = 'dsdl/dsdl_SemSeg_full/set-train/train.yaml'
-val_ann = 'dsdl/dsdl_SemSeg_full/set-val/val.yaml'
-crop_size = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(
-        type='RandomResize',
-        scale=(2048, 512),
-        ratio_range=(0.5, 2.0),
-        keep_ratio=True),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=4,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(img_path=img_prefix, seg_map_path=img_prefix),
-        ann_file=train_ann,
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(img_path=img_prefix, seg_map_path=img_prefix),
-        ann_file=val_ann,
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
-test_evaluator = val_evaluator
-
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/emanet/README.md b/mmsegmentation/configs/emanet/README.md
deleted file mode 100644
index 8ffaf47..0000000
--- a/mmsegmentation/configs/emanet/README.md
+++ /dev/null
@@ -1,46 +0,0 @@
-# EMANet
-
-> [Expectation-Maximization Attention Networks for Semantic Segmentation](https://arxiv.org/abs/1907.13426)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://xialipku.github.io/EMANet">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ema_head.py#L80">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Self-attention mechanism has been widely used for various tasks. It is designed to compute the representation of each position by a weighted sum of the features at all positions. Thus, it can capture long-range relations for computer vision tasks. However, it is computationally consuming. Since the attention maps are computed w.r.t all other positions. In this paper, we formulate the attention mechanism into an expectation-maximization manner and iteratively estimate a much more compact set of bases upon which the attention maps are computed. By a weighted summation upon these bases, the resulting representation is low-rank and deprecates noisy information from the input. The proposed Expectation-Maximization Attention (EMA) module is robust to the variance of input and is also friendly in memory and computation. Moreover, we set up the bases maintenance and normalization methods to stabilize its training procedure. We conduct extensive experiments on popular semantic segmentation benchmarks including PASCAL VOC, PASCAL Context and COCO Stuff, on which we set new records.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142901186-7bfe15e2-805a-420e-81b0-74f214f20a36.png" width="80%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                           | download                                                                                                                                                                                                                                                                                                                                                 |
-| ------ | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | -------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| EMANet | R-50-D8  | 512x1024  |   80000 |      5.4 | 4.58           | V100   | 77.59 | 79.44         | [config](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/emanet/eemanet_r50-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r50-d8_512x1024_80k_cityscapes/emanet_r50-d8_512x1024_80k_cityscapes_20200901_100301-c43fcef1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r50-d8_512x1024_80k_cityscapes/emanet_r50-d8_512x1024_80k_cityscapes-20200901_100301.log.json)     |
-| EMANet | R-101-D8 | 512x1024  |   80000 |      6.2 | 2.87           | V100   | 79.10 | 81.21         | [config](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r101-d8_512x1024_80k_cityscapes/emanet_r101-d8_512x1024_80k_cityscapes_20200901_100301-2d970745.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r101-d8_512x1024_80k_cityscapes/emanet_r101-d8_512x1024_80k_cityscapes-20200901_100301.log.json) |
-| EMANet | R-50-D8  | 769x769   |   80000 |      8.9 | 1.97           | V100   | 79.33 | 80.49         | [config](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/emanet/emanet_r50-d8_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r50-d8_769x769_80k_cityscapes/emanet_r50-d8_769x769_80k_cityscapes_20200901_100301-16f8de52.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r50-d8_769x769_80k_cityscapes/emanet_r50-d8_769x769_80k_cityscapes-20200901_100301.log.json)         |
-| EMANet | R-101-D8 | 769x769   |   80000 |     10.1 | 1.22           | V100   | 79.62 | 81.00         | [config](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r101-d8_769x769_80k_cityscapes/emanet_r101-d8_769x769_80k_cityscapes_20200901_100301-47a324ce.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r101-d8_769x769_80k_cityscapes/emanet_r101-d8_769x769_80k_cityscapes-20200901_100301.log.json)     |
-
-## Citation
-
-```bibtex
-@inproceedings{li2019expectation,
-  title={Expectation-maximization attention networks for semantic segmentation},
-  author={Li, Xia and Zhong, Zhisheng and Wu, Jianlong and Yang, Yibo and Lin, Zhouchen and Liu, Hong},
-  booktitle={Proceedings of the IEEE International Conference on Computer Vision},
-  pages={9167--9176},
-  year={2019}
-}
-```
diff --git a/mmsegmentation/configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index ee3a3b5..0000000
--- a/mmsegmentation/configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './emanet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 7319a3e..0000000
--- a/mmsegmentation/configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './emanet_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/emanet/emanet_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/emanet/emanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 6198e1f..0000000
--- a/mmsegmentation/configs/emanet/emanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/emanet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/emanet/emanet_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/emanet/emanet_r50-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index a8e4521..0000000
--- a/mmsegmentation/configs/emanet/emanet_r50-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/emanet_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/emanet/metafile.yaml b/mmsegmentation/configs/emanet/metafile.yaml
deleted file mode 100644
index b2a6b09..0000000
--- a/mmsegmentation/configs/emanet/metafile.yaml
+++ /dev/null
@@ -1,109 +0,0 @@
-Collections:
-- Name: EMANet
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-  Paper:
-    Title: Expectation-Maximization Attention Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1907.13426
-  README: configs/emanet/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: eemanet_r50-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: EMANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.59
-      mIoU(ms+flip): 79.44
-  Config: configs/emanet/eemanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - EMANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.4
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r50-d8_512x1024_80k_cityscapes/emanet_r50-d8_512x1024_80k_cityscapes_20200901_100301-c43fcef1.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r50-d8_512x1024_80k_cityscapes/emanet_r50-d8_512x1024_80k_cityscapes-20200901_100301.log.json
-  Paper:
-    Title: Expectation-Maximization Attention Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1907.13426
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ema_head.py#L80
-  Framework: PyTorch
-- Name: emanet_r101-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: EMANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.1
-      mIoU(ms+flip): 81.21
-  Config: configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - EMANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r101-d8_512x1024_80k_cityscapes/emanet_r101-d8_512x1024_80k_cityscapes_20200901_100301-2d970745.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r101-d8_512x1024_80k_cityscapes/emanet_r101-d8_512x1024_80k_cityscapes-20200901_100301.log.json
-  Paper:
-    Title: Expectation-Maximization Attention Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1907.13426
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ema_head.py#L80
-  Framework: PyTorch
-- Name: emanet_r50-d8_4xb2-80k_cityscapes-769x769
-  In Collection: EMANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.33
-      mIoU(ms+flip): 80.49
-  Config: configs/emanet/emanet_r50-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - EMANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r50-d8_769x769_80k_cityscapes/emanet_r50-d8_769x769_80k_cityscapes_20200901_100301-16f8de52.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r50-d8_769x769_80k_cityscapes/emanet_r50-d8_769x769_80k_cityscapes-20200901_100301.log.json
-  Paper:
-    Title: Expectation-Maximization Attention Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1907.13426
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ema_head.py#L80
-  Framework: PyTorch
-- Name: emanet_r101-d8_4xb2-80k_cityscapes-769x769
-  In Collection: EMANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.62
-      mIoU(ms+flip): 81.0
-  Config: configs/emanet/emanet_r101-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - EMANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r101-d8_769x769_80k_cityscapes/emanet_r101-d8_769x769_80k_cityscapes_20200901_100301-47a324ce.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/emanet/emanet_r101-d8_769x769_80k_cityscapes/emanet_r101-d8_769x769_80k_cityscapes-20200901_100301.log.json
-  Paper:
-    Title: Expectation-Maximization Attention Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1907.13426
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ema_head.py#L80
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/encnet/README.md b/mmsegmentation/configs/encnet/README.md
deleted file mode 100644
index ff09bc3..0000000
--- a/mmsegmentation/configs/encnet/README.md
+++ /dev/null
@@ -1,59 +0,0 @@
-# EncNet
-
-> [Context Encoding for Semantic Segmentation](https://arxiv.org/abs/1803.08904)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/zhanghang1989/PyTorch-Encoding">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Recent work has made significant progress in improving spatial resolution for pixelwise labeling with Fully Convolutional Network (FCN) framework by employing Dilated/Atrous convolution, utilizing multi-scale features and refining boundaries. In this paper, we explore the impact of global contextual information in semantic segmentation by introducing the Context Encoding Module, which captures the semantic context of scenes and selectively highlights class-dependent featuremaps. The proposed Context Encoding Module significantly improves semantic segmentation results with only marginal extra computation cost over FCN. Our approach has achieved new state-of-the-art results 51.7% mIoU on PASCAL-Context, 85.9% mIoU on PASCAL VOC 2012. Our single model achieves a final score of 0.5567 on ADE20K test set, which surpass the winning entry of COCO-Place Challenge in 2017. In addition, we also explore how the Context Encoding Module can improve the feature representation of relatively shallow networks for the image classification on CIFAR-10 dataset. Our 14 layer network has achieved an error rate of 3.45%, which is comparable with state-of-the-art approaches with over 10 times more layers. The source code for the complete system are publicly available.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142901276-b364fbbf-3bdb-4000-9d31-b9a135e30935.png" width="70%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                         | download                                                                                                                                                                                                                                                                                                                                                 |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| EncNet | R-50-D8  | 512x1024  |   40000 | 8.6      | 4.58           | V100   | 75.67 |         77.08 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x1024_40k_cityscapes/encnet_r50-d8_512x1024_40k_cityscapes_20200621_220958-68638a47.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x1024_40k_cityscapes/encnet_r50-d8_512x1024_40k_cityscapes-20200621_220958.log.json)     |
-| EncNet | R-101-D8 | 512x1024  |   40000 | 12.1     | 2.66           | V100   | 75.81 |         77.21 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x1024_40k_cityscapes/encnet_r101-d8_512x1024_40k_cityscapes_20200621_220933-35e0a3e8.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x1024_40k_cityscapes/encnet_r101-d8_512x1024_40k_cityscapes-20200621_220933.log.json) |
-| EncNet | R-50-D8  | 769x769   |   40000 | 9.8      | 1.82           | V100   | 76.24 |         77.85 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_769x769_40k_cityscapes/encnet_r50-d8_769x769_40k_cityscapes_20200621_220958-3bcd2884.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_769x769_40k_cityscapes/encnet_r50-d8_769x769_40k_cityscapes-20200621_220958.log.json)         |
-| EncNet | R-101-D8 | 769x769   |   40000 | 13.7     | 1.26           | V100   | 74.25 |         76.25 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_769x769_40k_cityscapes/encnet_r101-d8_769x769_40k_cityscapes_20200621_220933-2fafed55.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_769x769_40k_cityscapes/encnet_r101-d8_769x769_40k_cityscapes-20200621_220933.log.json)     |
-| EncNet | R-50-D8  | 512x1024  |   80000 | -        | -              | V100   | 77.94 |         79.13 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x1024_80k_cityscapes/encnet_r50-d8_512x1024_80k_cityscapes_20200622_003554-fc5c5624.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x1024_80k_cityscapes/encnet_r50-d8_512x1024_80k_cityscapes-20200622_003554.log.json)     |
-| EncNet | R-101-D8 | 512x1024  |   80000 | -        | -              | V100   | 78.55 |         79.47 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x1024_80k_cityscapes/encnet_r101-d8_512x1024_80k_cityscapes_20200622_003555-1de64bec.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x1024_80k_cityscapes/encnet_r101-d8_512x1024_80k_cityscapes-20200622_003555.log.json) |
-| EncNet | R-50-D8  | 769x769   |   80000 | -        | -              | V100   | 77.44 |         78.72 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_769x769_80k_cityscapes/encnet_r50-d8_769x769_80k_cityscapes_20200622_003554-55096dcb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_769x769_80k_cityscapes/encnet_r50-d8_769x769_80k_cityscapes-20200622_003554.log.json)         |
-| EncNet | R-101-D8 | 769x769   |   80000 | -        | -              | V100   | 76.10 |         76.97 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_769x769_80k_cityscapes/encnet_r101-d8_769x769_80k_cityscapes_20200622_003555-470ef79d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_769x769_80k_cityscapes/encnet_r101-d8_769x769_80k_cityscapes-20200622_003555.log.json)     |
-
-### ADE20K
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                     | download                                                                                                                                                                                                                                                                                                                                 |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| EncNet | R-50-D8  | 512x512   |   80000 | 10.1     | 22.81          | V100   | 39.53 |         41.17 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x512_80k_ade20k/encnet_r50-d8_512x512_80k_ade20k_20200622_042412-44b46b04.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x512_80k_ade20k/encnet_r50-d8_512x512_80k_ade20k-20200622_042412.log.json)         |
-| EncNet | R-101-D8 | 512x512   |   80000 | 13.6     | 14.87          | V100   | 42.11 |         43.61 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x512_80k_ade20k/encnet_r101-d8_512x512_80k_ade20k_20200622_101128-dd35e237.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x512_80k_ade20k/encnet_r101-d8_512x512_80k_ade20k-20200622_101128.log.json)     |
-| EncNet | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 40.10 |         41.71 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x512_160k_ade20k/encnet_r50-d8_512x512_160k_ade20k_20200622_101059-b2db95e0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x512_160k_ade20k/encnet_r50-d8_512x512_160k_ade20k-20200622_101059.log.json)     |
-| EncNet | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 42.61 |         44.01 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet/encnet_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x512_160k_ade20k/encnet_r101-d8_512x512_160k_ade20k_20200622_073348-7989641f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x512_160k_ade20k/encnet_r101-d8_512x512_160k_ade20k-20200622_073348.log.json) |
-
-## Citation
-
-```bibtex
-@InProceedings{Zhang_2018_CVPR,
-author = {Zhang, Hang and Dana, Kristin and Shi, Jianping and Zhang, Zhongyue and Wang, Xiaogang and Tyagi, Ambrish and Agrawal, Amit},
-title = {Context Encoding for Semantic Segmentation},
-booktitle = {The IEEE Conference on Computer Vision and Pattern Recognition (CVPR)},
-month = {June},
-year = {2018}
-}
-```
diff --git a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 13ab367..0000000
--- a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './encnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index 7810ac4..0000000
--- a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './encnet_r50-d8_4xb2-40k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index bec6bd9..0000000
--- a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './encnet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index e1f6409..0000000
--- a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './encnet_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 9599f9c..0000000
--- a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './encnet_r50-d8_4xb4-160k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index a9edfc2..0000000
--- a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './encnet_r50-d8_4xb4-20k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index d2fbab5..0000000
--- a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './encnet_r50-d8_4xb4-40k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index debe8c8..0000000
--- a/mmsegmentation/configs/encnet/encnet_r101-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './encnet_r50-d8_4xb4-80k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index d5c3027..0000000
--- a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/encnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index 045d0fe..0000000
--- a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/encnet_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 4dafcd5..0000000
--- a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/encnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index e4d0b80..0000000
--- a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/encnet_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index b916798..0000000
--- a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/encnet_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index e5c9171..0000000
--- a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/encnet_r50-d8.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_20k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index 8ca126a..0000000
--- a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/encnet_r50-d8.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 931d6c0..0000000
--- a/mmsegmentation/configs/encnet/encnet_r50-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/encnet_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/encnet/encnet_r50s-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/encnet/encnet_r50s-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index e98104d..0000000
--- a/mmsegmentation/configs/encnet/encnet_r50s-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/encnet_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(stem_channels=128),
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/encnet/metafile.yaml b/mmsegmentation/configs/encnet/metafile.yaml
deleted file mode 100644
index 0dbdcfa..0000000
--- a/mmsegmentation/configs/encnet/metafile.yaml
+++ /dev/null
@@ -1,296 +0,0 @@
-Collections:
-- Name: EncNet
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-    - ADE20K
-  Paper:
-    Title: Context Encoding for Semantic Segmentation
-    URL: https://arxiv.org/abs/1803.08904
-  README: configs/encnet/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: encnet_r50-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: EncNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 75.67
-      mIoU(ms+flip): 77.08
-  Config: configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - EncNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x1024_40k_cityscapes/encnet_r50-d8_512x1024_40k_cityscapes_20200621_220958-68638a47.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x1024_40k_cityscapes/encnet_r50-d8_512x1024_40k_cityscapes-20200621_220958.log.json
-  Paper:
-    Title: Context Encoding for Semantic Segmentation
-    URL: https://arxiv.org/abs/1803.08904
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
-  Framework: PyTorch
-- Name: encnet_r101-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: EncNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 75.81
-      mIoU(ms+flip): 77.21
-  Config: configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - EncNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 12.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x1024_40k_cityscapes/encnet_r101-d8_512x1024_40k_cityscapes_20200621_220933-35e0a3e8.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x1024_40k_cityscapes/encnet_r101-d8_512x1024_40k_cityscapes-20200621_220933.log.json
-  Paper:
-    Title: Context Encoding for Semantic Segmentation
-    URL: https://arxiv.org/abs/1803.08904
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
-  Framework: PyTorch
-- Name: encnet_r50-d8_4xb2-40k_cityscapes-769x769
-  In Collection: EncNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.24
-      mIoU(ms+flip): 77.85
-  Config: configs/encnet/encnet_r50-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - EncNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_769x769_40k_cityscapes/encnet_r50-d8_769x769_40k_cityscapes_20200621_220958-3bcd2884.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_769x769_40k_cityscapes/encnet_r50-d8_769x769_40k_cityscapes-20200621_220958.log.json
-  Paper:
-    Title: Context Encoding for Semantic Segmentation
-    URL: https://arxiv.org/abs/1803.08904
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
-  Framework: PyTorch
-- Name: encnet_r101-d8_4xb2-40k_cityscapes-769x769
-  In Collection: EncNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 74.25
-      mIoU(ms+flip): 76.25
-  Config: configs/encnet/encnet_r101-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - EncNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 13.7
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_769x769_40k_cityscapes/encnet_r101-d8_769x769_40k_cityscapes_20200621_220933-2fafed55.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_769x769_40k_cityscapes/encnet_r101-d8_769x769_40k_cityscapes-20200621_220933.log.json
-  Paper:
-    Title: Context Encoding for Semantic Segmentation
-    URL: https://arxiv.org/abs/1803.08904
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
-  Framework: PyTorch
-- Name: encnet_r50-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: EncNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.94
-      mIoU(ms+flip): 79.13
-  Config: configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - EncNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x1024_80k_cityscapes/encnet_r50-d8_512x1024_80k_cityscapes_20200622_003554-fc5c5624.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x1024_80k_cityscapes/encnet_r50-d8_512x1024_80k_cityscapes-20200622_003554.log.json
-  Paper:
-    Title: Context Encoding for Semantic Segmentation
-    URL: https://arxiv.org/abs/1803.08904
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
-  Framework: PyTorch
-- Name: encnet_r101-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: EncNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.55
-      mIoU(ms+flip): 79.47
-  Config: configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - EncNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x1024_80k_cityscapes/encnet_r101-d8_512x1024_80k_cityscapes_20200622_003555-1de64bec.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x1024_80k_cityscapes/encnet_r101-d8_512x1024_80k_cityscapes-20200622_003555.log.json
-  Paper:
-    Title: Context Encoding for Semantic Segmentation
-    URL: https://arxiv.org/abs/1803.08904
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
-  Framework: PyTorch
-- Name: encnet_r50-d8_4xb2-80k_cityscapes-769x769
-  In Collection: EncNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.44
-      mIoU(ms+flip): 78.72
-  Config: configs/encnet/encnet_r50-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - EncNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_769x769_80k_cityscapes/encnet_r50-d8_769x769_80k_cityscapes_20200622_003554-55096dcb.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_769x769_80k_cityscapes/encnet_r50-d8_769x769_80k_cityscapes-20200622_003554.log.json
-  Paper:
-    Title: Context Encoding for Semantic Segmentation
-    URL: https://arxiv.org/abs/1803.08904
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
-  Framework: PyTorch
-- Name: encnet_r101-d8_4xb2-80k_cityscapes-769x769
-  In Collection: EncNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.1
-      mIoU(ms+flip): 76.97
-  Config: configs/encnet/encnet_r101-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - EncNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_769x769_80k_cityscapes/encnet_r101-d8_769x769_80k_cityscapes_20200622_003555-470ef79d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_769x769_80k_cityscapes/encnet_r101-d8_769x769_80k_cityscapes-20200622_003555.log.json
-  Paper:
-    Title: Context Encoding for Semantic Segmentation
-    URL: https://arxiv.org/abs/1803.08904
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
-  Framework: PyTorch
-- Name: encnet_r50-d8_4xb4-80k_ade20k-512x512
-  In Collection: EncNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 39.53
-      mIoU(ms+flip): 41.17
-  Config: configs/encnet/encnet_r50-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - EncNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x512_80k_ade20k/encnet_r50-d8_512x512_80k_ade20k_20200622_042412-44b46b04.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x512_80k_ade20k/encnet_r50-d8_512x512_80k_ade20k-20200622_042412.log.json
-  Paper:
-    Title: Context Encoding for Semantic Segmentation
-    URL: https://arxiv.org/abs/1803.08904
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
-  Framework: PyTorch
-- Name: encnet_r101-d8_4xb4-80k_ade20k-512x512
-  In Collection: EncNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.11
-      mIoU(ms+flip): 43.61
-  Config: configs/encnet/encnet_r101-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - EncNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 13.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x512_80k_ade20k/encnet_r101-d8_512x512_80k_ade20k_20200622_101128-dd35e237.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x512_80k_ade20k/encnet_r101-d8_512x512_80k_ade20k-20200622_101128.log.json
-  Paper:
-    Title: Context Encoding for Semantic Segmentation
-    URL: https://arxiv.org/abs/1803.08904
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
-  Framework: PyTorch
-- Name: encnet_r50-d8_4xb4-160k_ade20k-512x512
-  In Collection: EncNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 40.1
-      mIoU(ms+flip): 41.71
-  Config: configs/encnet/encnet_r50-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - EncNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x512_160k_ade20k/encnet_r50-d8_512x512_160k_ade20k_20200622_101059-b2db95e0.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r50-d8_512x512_160k_ade20k/encnet_r50-d8_512x512_160k_ade20k-20200622_101059.log.json
-  Paper:
-    Title: Context Encoding for Semantic Segmentation
-    URL: https://arxiv.org/abs/1803.08904
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
-  Framework: PyTorch
-- Name: encnet_r101-d8_4xb4-160k_ade20k-512x512
-  In Collection: EncNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.61
-      mIoU(ms+flip): 44.01
-  Config: configs/encnet/encnet_r101-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - EncNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x512_160k_ade20k/encnet_r101-d8_512x512_160k_ade20k_20200622_073348-7989641f.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/encnet/encnet_r101-d8_512x512_160k_ade20k/encnet_r101-d8_512x512_160k_ade20k-20200622_073348.log.json
-  Paper:
-    Title: Context Encoding for Semantic Segmentation
-    URL: https://arxiv.org/abs/1803.08904
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/enc_head.py#L63
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/erfnet/README.md b/mmsegmentation/configs/erfnet/README.md
deleted file mode 100644
index 55d7197..0000000
--- a/mmsegmentation/configs/erfnet/README.md
+++ /dev/null
@@ -1,54 +0,0 @@
-# ERFNet
-
-> [ERFNet: Efficient Residual Factorized ConvNet for Real-time Semantic Segmentation](http://www.robesafe.uah.es/personal/eduardo.romera/pdfs/Romera17tits.pdf)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/Eromera/erfnet_pytorch">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/erfnet.py#L321">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Semantic segmentation is a challenging task that addresses most of the perception needs of intelligent vehicles (IVs) in an unified way. Deep neural networks excel at this task, as they can be trained end-to-end to accurately classify multiple object categories in an image at pixel level. However, a good tradeoff between high quality and computational resources is yet not present in the state-of-the-art semantic segmentation approaches, limiting their application in real vehicles. In this paper, we propose a deep architecture that is able to run in real time while providing accurate semantic segmentation. The core of our architecture is a novel layer that uses residual connections and factorized convolutions in order to remain efficient while retaining remarkable accuracy. Our approach is able to run at over 83 FPS in a single Titan X, and 7 FPS in a Jetson TX1 (embedded device). A comprehensive set of experiments on the publicly available Cityscapes data set demonstrates that our system achieves an accuracy that is similar to the state of the art, while being orders of magnitude faster to compute than other architectures that achieve top precision. The resulting tradeoff makes our model an ideal approach for scene understanding in IV applications. The code is publicly available at: https://github.com/Eromera/erfnet.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/143479729-ea7951f6-1a3c-47d6-aaee-62c5759c0638.png" width="60%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU | mIoU(ms+flip) | config                                                                                                                      | download                                                                                                                                                                                                                                                                                                                                                     |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ---: | ------------- | --------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| ERFNet | ERFNet   | 512x1024  |  160000 | 6.04     | 15.26          | V100   | 72.5 | 74.75         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/erfnet/erfnet_fcn_4xb4-160k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/erfnet/erfnet_fcn_4x4_512x1024_160k_cityscapes/erfnet_fcn_4x4_512x1024_160k_cityscapes_20220704_162145-dc90157a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/erfnet/erfnet_fcn_4x4_512x1024_160k_cityscapes/erfnet_fcn_4x4_512x1024_160k_cityscapes_20220704_162145.log.json) |
-
-Note:
-
-- The model is trained from scratch.
-
-- Last deconvolution layer in the [original paper](https://github.com/Eromera/erfnet_pytorch/blob/master/train/erfnet.py#L123) is replaced by a naive `FCNHead` decoder head and a bilinear upsampling layer, found more effective and efficient.
-
-- This model performance is sensitive to the seed values used, please refer to the log file for the specific settings of the seed. If you choose a different seed, the results might differ from the table results.
-
-## Citation
-
-```bibtex
-@article{romera2017erfnet,
-  title={Erfnet: Efficient residual factorized convnet for real-time semantic segmentation},
-  author={Romera, Eduardo and Alvarez, Jos{\'e} M and Bergasa, Luis M and Arroyo, Roberto},
-  journal={IEEE Transactions on Intelligent Transportation Systems},
-  volume={19},
-  number={1},
-  pages={263--272},
-  year={2017},
-  publisher={IEEE}
-}
-```
diff --git a/mmsegmentation/configs/erfnet/erfnet_fcn_4xb4-160k_cityscapes-512x1024.py b/mmsegmentation/configs/erfnet/erfnet_fcn_4xb4-160k_cityscapes-512x1024.py
deleted file mode 100644
index 7d65582..0000000
--- a/mmsegmentation/configs/erfnet/erfnet_fcn_4xb4-160k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/erfnet_fcn.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
-train_dataloader = dict(batch_size=4, num_workers=4)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/erfnet/metafile.yaml b/mmsegmentation/configs/erfnet/metafile.yaml
deleted file mode 100644
index bf51412..0000000
--- a/mmsegmentation/configs/erfnet/metafile.yaml
+++ /dev/null
@@ -1,37 +0,0 @@
-Collections:
-- Name: ERFNet
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-  Paper:
-    Title: 'ERFNet: Efficient Residual Factorized ConvNet for Real-time Semantic Segmentation'
-    URL: http://www.robesafe.uah.es/personal/eduardo.romera/pdfs/Romera17tits.pdf
-  README: configs/erfnet/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: erfnet_fcn_4xb4-160k_cityscapes-512x1024
-  In Collection: ERFNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 72.5
-      mIoU(ms+flip): 74.75
-  Config: configs/erfnet/erfnet_fcn_4xb4-160k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 16
-    Architecture:
-    - ERFNet
-    - ERFNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.04
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/erfnet/erfnet_fcn_4x4_512x1024_160k_cityscapes/erfnet_fcn_4x4_512x1024_160k_cityscapes_20220704_162145-dc90157a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/erfnet/erfnet_fcn_4x4_512x1024_160k_cityscapes/erfnet_fcn_4x4_512x1024_160k_cityscapes_20220704_162145.log.json
-  Paper:
-    Title: 'ERFNet: Efficient Residual Factorized ConvNet for Real-time Semantic Segmentation'
-    URL: http://www.robesafe.uah.es/personal/eduardo.romera/pdfs/Romera17tits.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/erfnet.py#L321
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/fastfcn/README.md b/mmsegmentation/configs/fastfcn/README.md
deleted file mode 100644
index 48644e5..0000000
--- a/mmsegmentation/configs/fastfcn/README.md
+++ /dev/null
@@ -1,63 +0,0 @@
-# FastFCN
-
-> [FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation](https://arxiv.org/abs/1903.11816)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/wuhuikai/FastFCN">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Modern approaches for semantic segmentation usually employ dilated convolutions in the backbone to extract high-resolution feature maps, which brings heavy computation complexity and memory footprint. To replace the time and memory consuming dilated convolutions, we propose a novel joint upsampling module named Joint Pyramid Upsampling (JPU) by formulating the task of extracting high-resolution feature maps into a joint upsampling problem. With the proposed JPU, our method reduces the computation complexity by more than three times without performance loss. Experiments show that JPU is superior to other upsampling modules, which can be plugged into many existing approaches to reduce computation complexity and improve performance. By replacing dilated convolutions with the proposed JPU module, our method achieves the state-of-the-art performance in Pascal Context dataset (mIoU of 53.13%) and ADE20K dataset (final score of 0.5584) while running 3 times faster.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142901374-6e0252ab-6e0f-4acd-86ad-1e9f49be3185.png" width="70%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method              | Backbone       | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                    | download                                                                                                                                                                                                                                                                                                                                                                                                           |
-| ------------------- | -------------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| FastFCN + DeepLabV3 | R-50-D32       | 512x1024  |   80000 | 5.67     | 2.64           | V100   | 79.12 | 80.58         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_aspp_512x1024_80k_cityscapes_20210928_053722-5d1a2648.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_aspp_512x1024_80k_cityscapes_20210928_053722.log.json)                 |
-| FastFCN + DeepLabV3 | R-50-D32 (4x4) | 512x1024  |   80000 | 9.79     | -              | V100   | 79.52 | 80.91         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_aspp_4x4_512x1024_80k_cityscapes_20210924_214357-72220849.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_aspp_4x4_512x1024_80k_cityscapes_20210924_214357.log.json) |
-| FastFCN + PSPNet    | R-50-D32       | 512x1024  |   80000 | 5.67     | 4.40           | V100   | 79.26 | 80.86         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_psp_512x1024_80k_cityscapes_20210928_053722-57749bed.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_psp_512x1024_80k_cityscapes_20210928_053722.log.json)                     |
-| FastFCN + PSPNet    | R-50-D32 (4x4) | 512x1024  |   80000 | 9.94     | -              | V100   | 78.76 | 80.03         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_psp_4x4_512x1024_80k_cityscapes_20210925_061841-77e87b0a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_psp_4x4_512x1024_80k_cityscapes_20210925_061841.log.json)     |
-| FastFCN + EncNet    | R-50-D32       | 512x1024  |   80000 | 8.15     | 4.77           | V100   | 77.97 | 79.92         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_enc_512x1024_80k_cityscapes_20210928_030036-78da5046.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_enc_512x1024_80k_cityscapes_20210928_030036.log.json)                     |
-| FastFCN + EncNet    | R-50-D32 (4x4) | 512x1024  |   80000 | 15.45    | -              | V100   |  78.6 | 80.25         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_enc_4x4_512x1024_80k_cityscapes_20210926_093217-e1eb6dbb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_enc_4x4_512x1024_80k_cityscapes_20210926_093217.log.json)     |
-
-### ADE20K
-
-| Method              | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                | download                                                                                                                                                                                                                                                                                                                                                                           |
-| ------------------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------- | ------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| FastFCN + DeepLabV3 | R-50-D32 | 512x1024  |   80000 | 8.46     | 12.06          | V100   | 41.88 | 42.91         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x512_80k_ade20k/fastfcn_r50-d32_jpu_aspp_512x512_80k_ade20k_20211013_190619-3aa40f2d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x512_80k_ade20k/fastfcn_r50-d32_jpu_aspp_512x512_80k_ade20k_20211013_190619.log.json)     |
-| FastFCN + DeepLabV3 | R-50-D32 | 512x1024  |  160000 | -        | -              | V100   | 43.58 | 44.92         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x512_160k_ade20k/fastfcn_r50-d32_jpu_aspp_512x512_160k_ade20k_20211008_152246-27036aee.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x512_160k_ade20k/fastfcn_r50-d32_jpu_aspp_512x512_160k_ade20k_20211008_152246.log.json) |
-| FastFCN + PSPNet    | R-50-D32 | 512x1024  |   80000 | 8.02     | 19.21          | V100   | 41.40 | 42.12         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x512_80k_ade20k/fastfcn_r50-d32_jpu_psp_512x512_80k_ade20k_20210930_225137-993d07c8.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x512_80k_ade20k/fastfcn_r50-d32_jpu_psp_512x512_80k_ade20k_20210930_225137.log.json)         |
-| FastFCN + PSPNet    | R-50-D32 | 512x1024  |  160000 | -        | -              | V100   | 42.63 | 43.71         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x512_160k_ade20k/fastfcn_r50-d32_jpu_psp_512x512_160k_ade20k_20211008_105455-e8f5a2fd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x512_160k_ade20k/fastfcn_r50-d32_jpu_psp_512x512_160k_ade20k_20211008_105455.log.json)     |
-| FastFCN + EncNet    | R-50-D32 | 512x1024  |   80000 | 9.67     | 17.23          | V100   | 40.88 | 42.36         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x512_80k_ade20k/fastfcn_r50-d32_jpu_enc_512x512_80k_ade20k_20210930_225214-65aef6dd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x512_80k_ade20k/fastfcn_r50-d32_jpu_enc_512x512_80k_ade20k_20210930_225214.log.json)         |
-| FastFCN + EncNet    | R-50-D32 | 512x1024  |  160000 | -        | -              | V100   | 42.50 | 44.21         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x512_160k_ade20k/fastfcn_r50-d32_jpu_enc_512x512_160k_ade20k_20211008_105456-d875ce3c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x512_160k_ade20k/fastfcn_r50-d32_jpu_enc_512x512_160k_ade20k_20211008_105456.log.json)     |
-
-Note:
-
-- `4x4` means 4 GPUs with 4 samples per GPU in training, default setting is 4 GPUs with 2 samples per GPU in training.
-- Results of [DeepLabV3 (mIoU: 79.32)](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3), [PSPNet (mIoU: 78.55)](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet) and [ENCNet (mIoU: 77.94)](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet) can be found in each original repository.
-
-## Citation
-
-```bibtex
-@article{wu2019fastfcn,
-title={Fastfcn: Rethinking dilated convolution in the backbone for semantic segmentation},
-author={Wu, Huikai and Zhang, Junge and Huang, Kaiqi and Liang, Kongming and Yu, Yizhou},
-journal={arXiv preprint arXiv:1903.11816},
-year={2019}
-}
-```
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 39e6e23..0000000
--- a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,20 +0,0 @@
-# model settings
-_base_ = './fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024.py'
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    decode_head=dict(
-        _delete_=True,
-        type='ASPPHead',
-        in_channels=2048,
-        in_index=2,
-        channels=512,
-        dilations=(1, 12, 24, 36),
-        dropout_ratio=0.1,
-        num_classes=19,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 1913544..0000000
--- a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,20 +0,0 @@
-# model settings
-_base_ = './fastfcn_r50-d32_jpu_psp_4xb4-160k_ade20k-512x512.py'
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    decode_head=dict(
-        _delete_=True,
-        type='ASPPHead',
-        in_channels=2048,
-        in_index=2,
-        channels=512,
-        dilations=(1, 12, 24, 36),
-        dropout_ratio=0.1,
-        num_classes=150,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 7516895..0000000
--- a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,20 +0,0 @@
-# model settings
-_base_ = './fastfcn_r50-d32_jpu_psp_4xb4-80k_ade20k-512x512.py'
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    decode_head=dict(
-        _delete_=True,
-        type='ASPPHead',
-        in_channels=2048,
-        in_index=2,
-        channels=512,
-        dilations=(1, 12, 24, 36),
-        dropout_ratio=0.1,
-        num_classes=150,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-80k_cityscapes-512x1024.py
deleted file mode 100644
index a8c5dc3..0000000
--- a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,5 +0,0 @@
-# model settings
-_base_ = './fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024.py'
-train_dataloader = dict(batch_size=4, num_workers=4)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 4840dd0..0000000
--- a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,24 +0,0 @@
-# model settings
-_base_ = './fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024.py'
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    decode_head=dict(
-        _delete_=True,
-        type='EncHead',
-        in_channels=[512, 1024, 2048],
-        in_index=(0, 1, 2),
-        channels=512,
-        num_codes=32,
-        use_se_loss=True,
-        add_lateral=False,
-        dropout_ratio=0.1,
-        num_classes=19,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
-        loss_se_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.2)),
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 619d086..0000000
--- a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,24 +0,0 @@
-# model settings
-_base_ = './fastfcn_r50-d32_jpu_psp_4xb4-160k_ade20k-512x512.py'
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    decode_head=dict(
-        _delete_=True,
-        type='EncHead',
-        in_channels=[512, 1024, 2048],
-        in_index=(0, 1, 2),
-        channels=512,
-        num_codes=32,
-        use_se_loss=True,
-        add_lateral=False,
-        dropout_ratio=0.1,
-        num_classes=150,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
-        loss_se_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.2)),
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index a76b026..0000000
--- a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,24 +0,0 @@
-# model settings
-_base_ = './fastfcn_r50-d32_jpu_psp_4xb4-80k_ade20k-512x512.py'
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    decode_head=dict(
-        _delete_=True,
-        type='EncHead',
-        in_channels=[512, 1024, 2048],
-        in_index=(0, 1, 2),
-        channels=512,
-        num_codes=32,
-        use_se_loss=True,
-        add_lateral=False,
-        dropout_ratio=0.1,
-        num_classes=150,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
-        loss_se_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.2)),
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-80k_cityscapes-512x1024.py
deleted file mode 100644
index 6df1527..0000000
--- a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,5 +0,0 @@
-# model settings
-_base_ = './fastfcn_r50-d32_jpu_enc_4xb2-80k_cityscapes-512x1024.py'
-train_dataloader = dict(batch_size=4, num_workers=4)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index dc5c54d..0000000
--- a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = [
-    '../_base_/models/fastfcn_r50-d32_jpu_psp.py',
-    '../_base_/datasets/cityscapes.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 887ace1..0000000
--- a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/fastfcn_r50-d32_jpu_psp.py',
-    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 3981e20..0000000
--- a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/fastfcn_r50-d32_jpu_psp.py',
-    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-80k_cityscapes-512x1024.py
deleted file mode 100644
index 2c7d504..0000000
--- a/mmsegmentation/configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/fastfcn_r50-d32_jpu_psp.py',
-    '../_base_/datasets/cityscapes.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
-train_dataloader = dict(batch_size=4, num_workers=4)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/fastfcn/metafile.yaml b/mmsegmentation/configs/fastfcn/metafile.yaml
deleted file mode 100644
index f5fe03c..0000000
--- a/mmsegmentation/configs/fastfcn/metafile.yaml
+++ /dev/null
@@ -1,311 +0,0 @@
-Collections:
-- Name: FastFCN
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-    - ADE20K
-  Paper:
-    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1903.11816
-  README: configs/fastfcn/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024
-  In Collection: FastFCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.12
-      mIoU(ms+flip): 80.58
-  Config: configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D32
-    - FastFCN
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.67
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_aspp_512x1024_80k_cityscapes_20210928_053722-5d1a2648.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_aspp_512x1024_80k_cityscapes_20210928_053722.log.json
-  Paper:
-    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1903.11816
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
-  Framework: PyTorch
-- Name: fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024
-  In Collection: FastFCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.52
-      mIoU(ms+flip): 80.91
-  Config: configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D32
-    - FastFCN
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.79
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_aspp_4x4_512x1024_80k_cityscapes_20210924_214357-72220849.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_aspp_4x4_512x1024_80k_cityscapes_20210924_214357.log.json
-  Paper:
-    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1903.11816
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
-  Framework: PyTorch
-- Name: fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024
-  In Collection: FastFCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.26
-      mIoU(ms+flip): 80.86
-  Config: configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D32
-    - FastFCN
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.67
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_psp_512x1024_80k_cityscapes_20210928_053722-57749bed.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_psp_512x1024_80k_cityscapes_20210928_053722.log.json
-  Paper:
-    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1903.11816
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
-  Framework: PyTorch
-- Name: fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024
-  In Collection: FastFCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.76
-      mIoU(ms+flip): 80.03
-  Config: configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D32
-    - FastFCN
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.94
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_psp_4x4_512x1024_80k_cityscapes_20210925_061841-77e87b0a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_psp_4x4_512x1024_80k_cityscapes_20210925_061841.log.json
-  Paper:
-    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1903.11816
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
-  Framework: PyTorch
-- Name: fastfcn_r50-d32_jpu_enc_4xb2-80k_cityscapes-512x1024
-  In Collection: FastFCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.97
-      mIoU(ms+flip): 79.92
-  Config: configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D32
-    - FastFCN
-    - EncNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.15
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_enc_512x1024_80k_cityscapes_20210928_030036-78da5046.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_enc_512x1024_80k_cityscapes_20210928_030036.log.json
-  Paper:
-    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1903.11816
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
-  Framework: PyTorch
-- Name: fastfcn_r50-d32_jpu_enc_4xb2-80k_cityscapes-512x1024
-  In Collection: FastFCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.6
-      mIoU(ms+flip): 80.25
-  Config: configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D32
-    - FastFCN
-    - EncNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 15.45
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_enc_4x4_512x1024_80k_cityscapes_20210926_093217-e1eb6dbb.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_4x4_512x1024_80k_cityscapes/fastfcn_r50-d32_jpu_enc_4x4_512x1024_80k_cityscapes_20210926_093217.log.json
-  Paper:
-    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1903.11816
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
-  Framework: PyTorch
-- Name: fastfcn_r50-d32_jpu_aspp_4xb4-80k_ade20k-512x512
-  In Collection: FastFCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 41.88
-      mIoU(ms+flip): 42.91
-  Config: configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D32
-    - FastFCN
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.46
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x512_80k_ade20k/fastfcn_r50-d32_jpu_aspp_512x512_80k_ade20k_20211013_190619-3aa40f2d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x512_80k_ade20k/fastfcn_r50-d32_jpu_aspp_512x512_80k_ade20k_20211013_190619.log.json
-  Paper:
-    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1903.11816
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
-  Framework: PyTorch
-- Name: fastfcn_r50-d32_jpu_aspp_4xb4-160k_ade20k-512x512
-  In Collection: FastFCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 43.58
-      mIoU(ms+flip): 44.92
-  Config: configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D32
-    - FastFCN
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x512_160k_ade20k/fastfcn_r50-d32_jpu_aspp_512x512_160k_ade20k_20211008_152246-27036aee.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_aspp_512x512_160k_ade20k/fastfcn_r50-d32_jpu_aspp_512x512_160k_ade20k_20211008_152246.log.json
-  Paper:
-    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1903.11816
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
-  Framework: PyTorch
-- Name: fastfcn_r50-d32_jpu_psp_4xb4-80k_ade20k-512x512
-  In Collection: FastFCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 41.4
-      mIoU(ms+flip): 42.12
-  Config: configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D32
-    - FastFCN
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.02
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x512_80k_ade20k/fastfcn_r50-d32_jpu_psp_512x512_80k_ade20k_20210930_225137-993d07c8.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x512_80k_ade20k/fastfcn_r50-d32_jpu_psp_512x512_80k_ade20k_20210930_225137.log.json
-  Paper:
-    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1903.11816
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
-  Framework: PyTorch
-- Name: fastfcn_r50-d32_jpu_psp_4xb4-160k_ade20k-512x512
-  In Collection: FastFCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.63
-      mIoU(ms+flip): 43.71
-  Config: configs/fastfcn/fastfcn_r50-d32_jpu_psp_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D32
-    - FastFCN
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x512_160k_ade20k/fastfcn_r50-d32_jpu_psp_512x512_160k_ade20k_20211008_105455-e8f5a2fd.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_psp_512x512_160k_ade20k/fastfcn_r50-d32_jpu_psp_512x512_160k_ade20k_20211008_105455.log.json
-  Paper:
-    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1903.11816
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
-  Framework: PyTorch
-- Name: fastfcn_r50-d32_jpu_enc_4xb4-80k_ade20k-512x512
-  In Collection: FastFCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 40.88
-      mIoU(ms+flip): 42.36
-  Config: configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D32
-    - FastFCN
-    - EncNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.67
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x512_80k_ade20k/fastfcn_r50-d32_jpu_enc_512x512_80k_ade20k_20210930_225214-65aef6dd.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x512_80k_ade20k/fastfcn_r50-d32_jpu_enc_512x512_80k_ade20k_20210930_225214.log.json
-  Paper:
-    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1903.11816
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
-  Framework: PyTorch
-- Name: fastfcn_r50-d32_jpu_enc_4xb4-160k_ade20k-512x512
-  In Collection: FastFCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.5
-      mIoU(ms+flip): 44.21
-  Config: configs/fastfcn/fastfcn_r50-d32_jpu_enc_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D32
-    - FastFCN
-    - EncNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x512_160k_ade20k/fastfcn_r50-d32_jpu_enc_512x512_160k_ade20k_20211008_105456-d875ce3c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fastfcn/fastfcn_r50-d32_jpu_enc_512x512_160k_ade20k/fastfcn_r50-d32_jpu_enc_512x512_160k_ade20k_20211008_105456.log.json
-  Paper:
-    Title: 'FastFCN: Rethinking Dilated Convolution in the Backbone for Semantic Segmentation'
-    URL: https://arxiv.org/abs/1903.11816
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/jpu.py#L12
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/fastscnn/README.md b/mmsegmentation/configs/fastscnn/README.md
deleted file mode 100644
index 6be9814..0000000
--- a/mmsegmentation/configs/fastscnn/README.md
+++ /dev/null
@@ -1,42 +0,0 @@
-# Fast-SCNN
-
-> [Fast-SCNN for Semantic Segmentation](https://arxiv.org/abs/1902.04502)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/fast_scnn.py#L272">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-The encoder-decoder framework is state-of-the-art for offline semantic image segmentation. Since the rise in autonomous systems, real-time computation is increasingly desirable. In this paper, we introduce fast segmentation convolutional neural network (Fast-SCNN), an above real-time semantic segmentation model on high resolution image data (1024x2048px) suited to efficient computation on embedded devices with low memory. Building on existing two-branch methods for fast segmentation, we introduce our \`learning to downsample' module which computes low-level features for multiple resolution branches simultaneously. Our network combines spatial detail at high resolution with deep features extracted at lower resolution, yielding an accuracy of 68.0% mean intersection over union at 123.5 frames per second on Cityscapes. We also show that large scale pre-training is unnecessary. We thoroughly validate our metric in experiments with ImageNet pre-training and the coarse labeled data of Cityscapes. Finally, we show even faster computation with competitive results on subsampled inputs, without any network modifications.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142901444-705b4ff4-6d1e-409b-899a-37bf3a6b69ce.png" width="80%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method   | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                       | download                                                                                                                                                                                                                                                                                                                                               |
-| -------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------- | ---------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| FastSCNN | FastSCNN | 512x1024  |  160000 | 3.3      | 56.45          | V100   | 70.96 | 72.65         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastscnn/fast_scnn_8xb4-160k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fast_scnn/fast_scnn_lr0.12_8x4_160k_cityscapes/fast_scnn_lr0.12_8x4_160k_cityscapes_20210630_164853-0cec9937.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fast_scnn/fast_scnn_lr0.12_8x4_160k_cityscapes/fast_scnn_lr0.12_8x4_160k_cityscapes_20210630_164853.log.json) |
-
-## Citation
-
-```bibtex
-@article{poudel2019fast,
-  title={Fast-scnn: Fast semantic segmentation network},
-  author={Poudel, Rudra PK and Liwicki, Stephan and Cipolla, Roberto},
-  journal={arXiv preprint arXiv:1902.04502},
-  year={2019}
-}
-```
diff --git a/mmsegmentation/configs/fastscnn/fast_scnn_8xb4-160k_cityscapes-512x1024.py b/mmsegmentation/configs/fastscnn/fast_scnn_8xb4-160k_cityscapes-512x1024.py
deleted file mode 100644
index e7f68bf..0000000
--- a/mmsegmentation/configs/fastscnn/fast_scnn_8xb4-160k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,15 +0,0 @@
-_base_ = [
-    '../_base_/models/fast_scnn.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
-# Re-config the data sampler.
-train_dataloader = dict(batch_size=4, num_workers=4)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
-
-# Re-config the optimizer.
-optimizer = dict(type='SGD', lr=0.12, momentum=0.9, weight_decay=4e-5)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/fastscnn/metafile.yaml b/mmsegmentation/configs/fastscnn/metafile.yaml
deleted file mode 100644
index 9e33c90..0000000
--- a/mmsegmentation/configs/fastscnn/metafile.yaml
+++ /dev/null
@@ -1,37 +0,0 @@
-Collections:
-- Name: FastSCNN
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-  Paper:
-    Title: Fast-SCNN for Semantic Segmentation
-    URL: https://arxiv.org/abs/1902.04502
-  README: configs/fastscnn/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: fast_scnn_8xb4-160k_cityscapes-512x1024
-  In Collection: FastSCNN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 70.96
-      mIoU(ms+flip): 72.65
-  Config: configs/fastscnn/fast_scnn_8xb4-160k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 32
-    Architecture:
-    - FastSCNN
-    - FastSCNN
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 3.3
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fast_scnn/fast_scnn_lr0.12_8x4_160k_cityscapes/fast_scnn_lr0.12_8x4_160k_cityscapes_20210630_164853-0cec9937.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fast_scnn/fast_scnn_lr0.12_8x4_160k_cityscapes/fast_scnn_lr0.12_8x4_160k_cityscapes_20210630_164853.log.json
-  Paper:
-    Title: Fast-SCNN for Semantic Segmentation
-    URL: https://arxiv.org/abs/1902.04502
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/fast_scnn.py#L272
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/fcn/README.md b/mmsegmentation/configs/fcn/README.md
deleted file mode 100644
index cf7379f..0000000
--- a/mmsegmentation/configs/fcn/README.md
+++ /dev/null
@@ -1,111 +0,0 @@
-# FCN
-
-> [Fully Convolutional Networks for Semantic Segmentation](https://arxiv.org/abs/1411.4038)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/BVLC/caffe/wiki/Model-Zoo#fcn">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Convolutional networks are powerful visual models that yield hierarchies of features. We show that convolutional networks by themselves, trained end-to-end, pixels-to-pixels, exceed the state-of-the-art in semantic segmentation. Our key insight is to build "fully convolutional" networks that take input of arbitrary size and produce correspondingly-sized output with efficient inference and learning. We define and detail the space of fully convolutional networks, explain their application to spatially dense prediction tasks, and draw connections to prior models. We adapt contemporary classification networks (AlexNet, the VGG net, and GoogLeNet) into fully convolutional networks and transfer their learned representations by fine-tuning to the segmentation task. We then define a novel architecture that combines semantic information from a deep, coarse layer with appearance information from a shallow, fine layer to produce accurate and detailed segmentations. Our fully convolutional network achieves state-of-the-art segmentation of PASCAL VOC (20% relative improvement to 62.2% mean IU on 2012), NYUDv2, and SIFT Flow, while inference takes one third of a second for a typical image.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142901525-fd0d2bf4-9a47-4143-85f5-3cee8849eaa4.png" width="70%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method     | Backbone   | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device   |  mIoU | mIoU(ms+flip) | config                                                                                                                        | download                                                                                                                                                                                                                                                                                                                                                   |
-| ---------- | ---------- | --------- | ------: | -------- | -------------- | -------- | ----: | ------------: | ----------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| FCN        | R-50-D8    | 512x1024  |   40000 | 5.7      | 4.17           | V100     | 72.25 |         73.36 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x1024_40k_cityscapes/fcn_r50-d8_512x1024_40k_cityscapes_20200604_192608-efe53f0d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x1024_40k_cityscapes/fcn_r50-d8_512x1024_40k_cityscapes_20200604_192608.log.json)                         |
-| FCN        | R-101-D8   | 512x1024  |   40000 | 9.2      | 2.66           | V100     | 75.45 |         76.58 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-512x1024.py)      | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x1024_40k_cityscapes/fcn_r101-d8_512x1024_40k_cityscapes_20200604_181852-a883d3a1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x1024_40k_cityscapes/fcn_r101-d8_512x1024_40k_cityscapes_20200604_181852.log.json)                     |
-| FCN        | R-50-D8    | 769x769   |   40000 | 6.5      | 1.80           | V100     | 71.47 |         72.54 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-769x769.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_769x769_40k_cityscapes/fcn_r50-d8_769x769_40k_cityscapes_20200606_113104-977b5d02.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_769x769_40k_cityscapes/fcn_r50-d8_769x769_40k_cityscapes_20200606_113104.log.json)                             |
-| FCN        | R-101-D8   | 769x769   |   40000 | 10.4     | 1.19           | V100     | 73.93 |         75.14 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-769x769.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_769x769_40k_cityscapes/fcn_r101-d8_769x769_40k_cityscapes_20200606_113208-7d4ab69c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_769x769_40k_cityscapes/fcn_r101-d8_769x769_40k_cityscapes_20200606_113208.log.json)                         |
-| FCN        | R-18-D8    | 512x1024  |   80000 | 1.7      | 14.65          | V100     | 71.11 |         72.91 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-512x1024.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18-d8_512x1024_80k_cityscapes/fcn_r18-d8_512x1024_80k_cityscapes_20201225_021327-6c50f8b4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18-d8_512x1024_80k_cityscapes/fcn_r18-d8_512x1024_80k_cityscapes-20201225_021327.log.json)                         |
-| FCN        | R-50-D8    | 512x1024  |   80000 | -        |                | V100     | 73.61 |         74.24 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x1024_80k_cityscapes/fcn_r50-d8_512x1024_80k_cityscapes_20200606_113019-03aa804d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x1024_80k_cityscapes/fcn_r50-d8_512x1024_80k_cityscapes_20200606_113019.log.json)                         |
-| FCN        | R-101-D8   | 512x1024  |   80000 | -        | -              | V100     | 75.13 |         75.94 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-512x1024.py)      | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x1024_80k_cityscapes/fcn_r101-d8_512x1024_80k_cityscapes_20200606_113038-3fb937eb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x1024_80k_cityscapes/fcn_r101-d8_512x1024_80k_cityscapes_20200606_113038.log.json)                     |
-| FCN (FP16) | R-101-D8   | 512x1024  |   80000 | 5.37     | 8.64           | V100     | 76.80 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_fp16_512x1024_80k_cityscapes/fcn_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230921-fb13e883.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_fp16_512x1024_80k_cityscapes/fcn_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230921.log.json) |
-| FCN        | R-18-D8    | 769x769   |   80000 | 1.9      | 6.40           | V100     | 70.80 |         73.16 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-769x769.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18-d8_769x769_80k_cityscapes/fcn_r18-d8_769x769_80k_cityscapes_20201225_021451-9739d1b8.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18-d8_769x769_80k_cityscapes/fcn_r18-d8_769x769_80k_cityscapes-20201225_021451.log.json)                             |
-| FCN        | R-50-D8    | 769x769   |   80000 | -        | -              | V100     | 72.64 |         73.32 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-769x769.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_769x769_80k_cityscapes/fcn_r50-d8_769x769_80k_cityscapes_20200606_195749-f5caeabc.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_769x769_80k_cityscapes/fcn_r50-d8_769x769_80k_cityscapes_20200606_195749.log.json)                             |
-| FCN        | R-101-D8   | 769x769   |   80000 | -        | -              | V100     | 75.52 |         76.61 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-769x769.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_769x769_80k_cityscapes/fcn_r101-d8_769x769_80k_cityscapes_20200606_214354-45cbac68.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_769x769_80k_cityscapes/fcn_r101-d8_769x769_80k_cityscapes_20200606_214354.log.json)                         |
-| FCN        | R-18b-D8   | 512x1024  |   80000 | 1.6      | 16.74          | V100     | 70.24 |         72.77 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-512x1024.py)      | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18b-d8_512x1024_80k_cityscapes/fcn_r18b-d8_512x1024_80k_cityscapes_20201225_230143-92c0f445.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18b-d8_512x1024_80k_cityscapes/fcn_r18b-d8_512x1024_80k_cityscapes-20201225_230143.log.json)                     |
-| FCN        | R-50b-D8   | 512x1024  |   80000 | 5.6      | 4.20           | V100     | 75.65 |         77.59 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-512x1024.py)      | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50b-d8_512x1024_80k_cityscapes/fcn_r50b-d8_512x1024_80k_cityscapes_20201225_094221-82957416.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50b-d8_512x1024_80k_cityscapes/fcn_r50b-d8_512x1024_80k_cityscapes-20201225_094221.log.json)                     |
-| FCN        | R-101b-D8  | 512x1024  |   80000 | 9.1      | 2.73           | V100     | 77.37 |         78.77 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-512x1024.py)     | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101b-d8_512x1024_80k_cityscapes/fcn_r101b-d8_512x1024_80k_cityscapes_20201226_160213-4543858f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101b-d8_512x1024_80k_cityscapes/fcn_r101b-d8_512x1024_80k_cityscapes-20201226_160213.log.json)                 |
-| FCN        | R-18b-D8   | 769x769   |   80000 | 1.7      | 6.70           | V100     | 69.66 |         72.07 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-769x769.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18b-d8_769x769_80k_cityscapes/fcn_r18b-d8_769x769_80k_cityscapes_20201226_004430-32d504e5.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18b-d8_769x769_80k_cityscapes/fcn_r18b-d8_769x769_80k_cityscapes-20201226_004430.log.json)                         |
-| FCN        | R-50b-D8   | 769x769   |   80000 | 6.3      | 1.82           | V100     | 73.83 |         76.60 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-769x769.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50b-d8_769x769_80k_cityscapes/fcn_r50b-d8_769x769_80k_cityscapes_20201225_094223-94552d38.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50b-d8_769x769_80k_cityscapes/fcn_r50b-d8_769x769_80k_cityscapes-20201225_094223.log.json)                         |
-| FCN        | R-101b-D8  | 769x769   |   80000 | 10.3     | 1.15           | V100     | 77.02 |         78.67 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-769x769.py)      | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101b-d8_769x769_80k_cityscapes/fcn_r101b-d8_769x769_80k_cityscapes_20201226_170012-82be37e2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101b-d8_769x769_80k_cityscapes/fcn_r101b-d8_769x769_80k_cityscapes-20201226_170012.log.json)                     |
-| FCN (D6)   | R-50-D16   | 512x1024  |   40000 | 3.4      | 10.22          | TITAN Xp | 77.06 |         78.85 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_512x1024_40k_cityscapes/fcn_d6_r50-d16_512x1024_40k_cityscapes_20210305_130133-98d5d1bc.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_512x1024_40k_cityscapes/fcn_d6_r50-d16_512x1024_40k_cityscapes-20210305_130133.log.json)         |
-| FCN (D6)   | R-50-D16   | 512x1024  |   80000 | -        | 10.35          | TITAN Xp | 77.27 |         78.88 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_512x1024_80k_cityscapes/fcn_d6_r50-d16_512x1024_80k_cityscapes_20210306_115604-133c292f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_512x1024_80k_cityscapes/fcn_d6_r50-d16_512x1024_80k_cityscapes-20210306_115604.log.json)         |
-| FCN (D6)   | R-50-D16   | 769x769   |   40000 | 3.7      | 4.17           | TITAN Xp | 76.82 |         78.22 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-769x769.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_769x769_40k_cityscapes/fcn_d6_r50-d16_769x769_40k_cityscapes_20210305_185744-1aab18ed.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_769x769_40k_cityscapes/fcn_d6_r50-d16_769x769_40k_cityscapes-20210305_185744.log.json)             |
-| FCN (D6)   | R-50-D16   | 769x769   |   80000 | -        | 4.15           | TITAN Xp | 77.04 |         78.40 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-769x769.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_769x769_80k_cityscapes/fcn_d6_r50-d16_769x769_80k_cityscapes_20210305_200413-109d88eb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_769x769_80k_cityscapes/fcn_d6_r50-d16_769x769_80k_cityscapes-20210305_200413.log.json)             |
-| FCN (D6)   | R-101-D16  | 512x1024  |   40000 | 4.5      | 8.04           | TITAN Xp | 77.36 |         79.18 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_512x1024_40k_cityscapes/fcn_d6_r101-d16_512x1024_40k_cityscapes_20210305_130337-9cf2b450.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_512x1024_40k_cityscapes/fcn_d6_r101-d16_512x1024_40k_cityscapes-20210305_130337.log.json)     |
-| FCN (D6)   | R-101-D16  | 512x1024  |   80000 | -        | 8.26           | TITAN Xp | 78.46 |         80.42 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_512x1024_80k_cityscapes/fcn_d6_r101-d16_512x1024_80k_cityscapes_20210308_102747-cb336445.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_512x1024_80k_cityscapes/fcn_d6_r101-d16_512x1024_80k_cityscapes-20210308_102747.log.json)     |
-| FCN (D6)   | R-101-D16  | 769x769   |   40000 | 5.0      | 3.12           | TITAN Xp | 77.28 |         78.95 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_769x769_40k_cityscapes/fcn_d6_r101-d16_769x769_40k_cityscapes_20210308_102453-60b114e9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_769x769_40k_cityscapes/fcn_d6_r101-d16_769x769_40k_cityscapes-20210308_102453.log.json)         |
-| FCN (D6)   | R-101-D16  | 769x769   |   80000 | -        | 3.21           | TITAN Xp | 78.06 |         79.58 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_769x769_80k_cityscapes/fcn_d6_r101-d16_769x769_80k_cityscapes_20210306_120016-e33adc4f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_769x769_80k_cityscapes/fcn_d6_r101-d16_769x769_80k_cityscapes-20210306_120016.log.json)         |
-| FCN (D6)   | R-50b-D16  | 512x1024  |   80000 | 3.2      | 10.16          | TITAN Xp | 76.99 |         79.03 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50b-d16_512x1024_80k_cityscapes/fcn_d6_r50b-d16_512x1024_80k_cityscapes_20210311_125550-6a0b62e9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50b_d16_512x1024_80k_cityscapes/fcn_d6_r50b_d16_512x1024_80k_cityscapes-20210311_125550.log.json)     |
-| FCN (D6)   | R-50b-D16  | 769x769   |   80000 | 3.6      | 4.17           | TITAN Xp | 76.86 |         78.52 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50b-d16_769x769_80k_cityscapes/fcn_d6_r50b-d16_769x769_80k_cityscapes_20210311_131012-d665f231.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50b_d16_769x769_80k_cityscapes/fcn_d6_r50b_d16_769x769_80k_cityscapes-20210311_131012.log.json)         |
-| FCN (D6)   | R-101b-D16 | 512x1024  |   80000 | 4.3      | 8.46           | TITAN Xp | 77.72 |         79.53 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101b-d16_512x1024_80k_cityscapes/fcn_d6_r101b-d16_512x1024_80k_cityscapes_20210311_144305-3f2eb5b4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101b_d16_512x1024_80k_cityscapes/fcn_d6_r101b_d16_512x1024_80k_cityscapes-20210311_144305.log.json) |
-| FCN (D6)   | R-101b-D16 | 769x769   |   80000 | 4.8      | 3.32           | TITAN Xp | 77.34 |         78.91 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101b-d16_769x769_80k_cityscapes/fcn_d6_r101b-d16_769x769_80k_cityscapes_20210311_154527-c4d8bfbc.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101b_d16_769x769_80k_cityscapes/fcn_d6_r101b_d16_769x769_80k_cityscapes-20210311_154527.log.json)     |
-
-### ADE20K
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                               | download                                                                                                                                                                                                                                                                                                               |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| FCN    | R-50-D8  | 512x512   |   80000 | 8.5      | 23.49          | V100   | 35.94 |         37.94 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_80k_ade20k/fcn_r50-d8_512x512_80k_ade20k_20200614_144016-f8ac5082.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_80k_ade20k/fcn_r50-d8_512x512_80k_ade20k_20200614_144016.log.json)         |
-| FCN    | R-101-D8 | 512x512   |   80000 | 12       | 14.78          | V100   | 39.61 |         40.83 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb4-80k_ade20k-512x512.pyy) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_80k_ade20k/fcn_r101-d8_512x512_80k_ade20k_20200615_014143-bc1809f7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_80k_ade20k/fcn_r101-d8_512x512_80k_ade20k_20200615_014143.log.json)     |
-| FCN    | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 36.10 |         38.08 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_160k_ade20k/fcn_r50-d8_512x512_160k_ade20k_20200615_100713-4edbc3b4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_160k_ade20k/fcn_r50-d8_512x512_160k_ade20k_20200615_100713.log.json)     |
-| FCN    | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 39.91 |         41.40 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_160k_ade20k/fcn_r101-d8_512x512_160k_ade20k_20200615_105816-fd192bd5.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_160k_ade20k/fcn_r101-d8_512x512_160k_ade20k_20200615_105816.log.json) |
-
-### Pascal VOC 2012 + Aug
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                | download                                                                                                                                                                                                                                                                                                                   |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | --------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| FCN    | R-50-D8  | 512x512   |   20000 | 5.7      | 23.28          | V100   | 67.08 |         69.94 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r50-d8_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_20k_voc12aug/fcn_r50-d8_512x512_20k_voc12aug_20200617_010715-52dc5306.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_20k_voc12aug/fcn_r50-d8_512x512_20k_voc12aug_20200617_010715.log.json)     |
-| FCN    | R-101-D8 | 512x512   |   20000 | 9.2      | 14.81          | V100   | 71.16 |         73.57 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_20k_voc12aug/fcn_r101-d8_512x512_20k_voc12aug_20200617_010842-0bb4e798.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_20k_voc12aug/fcn_r101-d8_512x512_20k_voc12aug_20200617_010842.log.json) |
-| FCN    | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 66.97 |         69.04 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r50-d8_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_40k_voc12aug/fcn_r50-d8_512x512_40k_voc12aug_20200613_161222-5e2dbf40.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_40k_voc12aug/fcn_r50-d8_512x512_40k_voc12aug_20200613_161222.log.json)     |
-| FCN    | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 69.91 |         72.38 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_40k_voc12aug/fcn_r101-d8_512x512_40k_voc12aug_20200613_161240-4c8bcefd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_40k_voc12aug/fcn_r101-d8_512x512_40k_voc12aug_20200613_161240.log.json) |
-
-### Pascal Context
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                      | download                                                                                                                                                                                                                                                                                                                                           |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | --------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| FCN    | R-101-D8 | 480x480   |   40000 | -        | 9.93           | V100   | 44.43 |         45.63 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_40k_pascal_context/fcn_r101-d8_480x480_40k_pascal_context_20210421_154757-b5e97937.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_40k_pascal_context/fcn_r101-d8_480x480_40k_pascal_context-20210421_154757.log.json) |
-| FCN    | R-101-D8 | 480x480   |   80000 | -        | -              | V100   | 44.13 |         45.26 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_80k_pascal_context/fcn_r101-d8_480x480_80k_pascal_context_20210421_163310-4711813f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_80k_pascal_context/fcn_r101-d8_480x480_80k_pascal_context-20210421_163310.log.json) |
-
-### Pascal Context 59
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                         | download                                                                                                                                                                                                                                                                                                                                                       |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| FCN    | R-101-D8 | 480x480   |   40000 | -        | -              | V100   | 48.42 |          50.4 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-59-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_40k_pascal_context_59/fcn_r101-d8_480x480_40k_pascal_context_59_20210415_230724-8cf83682.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_40k_pascal_context_59/fcn_r101-d8_480x480_40k_pascal_context_59-20210415_230724.log.json) |
-| FCN    | R-101-D8 | 480x480   |   80000 | -        | -              | V100   | 49.35 |         51.38 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-59-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_80k_pascal_context_59/fcn_r101-d8_480x480_80k_pascal_context_59_20210416_110804-9a6f2c94.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_80k_pascal_context_59/fcn_r101-d8_480x480_80k_pascal_context_59-20210416_110804.log.json) |
-
-Note:
-
-- `FP16` means Mixed Precision (FP16) is adopted in training.
-- `FCN D6` means dilation rate of convolution operator in FCN is 6.
-
-## Citation
-
-```bibtex
-@article{shelhamer2017fully,
-  title={Fully convolutional networks for semantic segmentation},
-  author={Shelhamer, Evan and Long, Jonathan and Darrell, Trevor},
-  journal={IEEE transactions on pattern analysis and machine intelligence},
-  volume={39},
-  number={4},
-  pages={640--651},
-  year={2017},
-  publisher={IEEE Trans Pattern Anal Mach Intell}
-}
-```
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 8f2cd02..0000000
--- a/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './fcn-d6_r50-d16_4xb2-40k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index 4782b30..0000000
--- a/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './fcn-d6_r50-d16_4xb2-40k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 5f654b4..0000000
--- a/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './fcn-d6_r50-d16_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 91eca1c..0000000
--- a/mmsegmentation/configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './fcn-d6_r50-d16_4xb2-80k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 62e6127..0000000
--- a/mmsegmentation/configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,4 +0,0 @@
-_base_ = './fcn-d6_r50-d16_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='torchvision://resnet101',
-    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 1b8d247..0000000
--- a/mmsegmentation/configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,4 +0,0 @@
-_base_ = './fcn-d6_r50b-d16_4xb2-80k_cityscapes-769x769.py'
-model = dict(
-    pretrained='torchvision://resnet101',
-    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 9a1efb4..0000000
--- a/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(dilations=(1, 1, 1, 2), strides=(1, 2, 2, 1)),
-    decode_head=dict(dilation=6),
-    auxiliary_head=dict(dilation=6))
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index 2b2a6f4..0000000
--- a/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,13 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(dilations=(1, 1, 1, 2), strides=(1, 2, 2, 1)),
-    decode_head=dict(align_corners=True, dilation=6),
-    auxiliary_head=dict(align_corners=True, dilation=6),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index e6cca00..0000000
--- a/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(dilations=(1, 1, 1, 2), strides=(1, 2, 2, 1)),
-    decode_head=dict(dilation=6),
-    auxiliary_head=dict(dilation=6))
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 990ff9c..0000000
--- a/mmsegmentation/configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,13 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(dilations=(1, 1, 1, 2), strides=(1, 2, 2, 1)),
-    decode_head=dict(align_corners=True, dilation=6),
-    auxiliary_head=dict(align_corners=True, dilation=6),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 7d470a5..0000000
--- a/mmsegmentation/configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './fcn-d6_r50-d16_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='torchvision://resnet50', backbone=dict(type='ResNet'))
diff --git a/mmsegmentation/configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index e9093ea..0000000
--- a/mmsegmentation/configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './fcn-d6_r50-d16_4xb2-80k_cityscapes-769x769.py'
-model = dict(pretrained='torchvision://resnet50', backbone=dict(type='ResNet'))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index b3ec0a7..0000000
--- a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index 1f83fe2..0000000
--- a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './fcn_r50-d8_4xb2-40k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 4527b3b..0000000
--- a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 6ce1124..0000000
--- a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './fcn_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
deleted file mode 100644
index b4d9487..0000000
--- a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './fcn_r101-d8_4xb2-80k_cityscapes-512x1024.py'
-optim_wrapper = dict(
-    _delete_=True,
-    type='AmpOptimWrapper',
-    optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005),
-    loss_scale=512.)
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index b1f5c5c..0000000
--- a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './fcn_r50-d8_4xb4-160k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index 61ee96f..0000000
--- a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './fcn_r50-d8_4xb4-20k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-480x480.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-480x480.py
deleted file mode 100644
index 1161193..0000000
--- a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-480x480.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './fcn_r50-d8_4xb4-40k_pascal-context-480x480.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-59-480x480.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-59-480x480.py
deleted file mode 100644
index f3a6dbc..0000000
--- a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-59-480x480.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './fcn_r50-d8_4xb4-40k_pascal-context-59-480x480.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index b68b6e0..0000000
--- a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './fcn_r50-d8_4xb4-40k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 3facce3..0000000
--- a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './fcn_r50-d8_4xb4-80k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-480x480.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-480x480.py
deleted file mode 100644
index 1161193..0000000
--- a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-480x480.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './fcn_r50-d8_4xb4-40k_pascal-context-480x480.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-59-480x480.py b/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-59-480x480.py
deleted file mode 100644
index cebe330..0000000
--- a/mmsegmentation/configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-59-480x480.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './fcn_r50-d8_4xb4-80k_pascal-context-59-480x480.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index e53751b..0000000
--- a/mmsegmentation/configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,4 +0,0 @@
-_base_ = './fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='torchvision://resnet101',
-    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index daa6502..0000000
--- a/mmsegmentation/configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,4 +0,0 @@
-_base_ = './fcn_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(
-    pretrained='torchvision://resnet101',
-    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 4073148..0000000
--- a/mmsegmentation/configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='open-mmlab://resnet18_v1c',
-    backbone=dict(depth=18),
-    decode_head=dict(
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 2c1d2b6..0000000
--- a/mmsegmentation/configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './fcn_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(
-    pretrained='open-mmlab://resnet18_v1c',
-    backbone=dict(depth=18),
-    decode_head=dict(
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 08ab467..0000000
--- a/mmsegmentation/configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='torchvision://resnet18',
-    backbone=dict(type='ResNet', depth=18),
-    decode_head=dict(
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index c591ebe..0000000
--- a/mmsegmentation/configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './fcn_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(
-    pretrained='torchvision://resnet18',
-    backbone=dict(type='ResNet', depth=18),
-    decode_head=dict(
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 4fba723..0000000
--- a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index d57afe1..0000000
--- a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 6b1fdae..0000000
--- a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 8a713fd..0000000
--- a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 258b9fb..0000000
--- a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index eac86d5..0000000
--- a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_r50-d8.py', '../_base_/datasets/pascal_voc12_aug.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_20k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_pascal-context-480x480.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_pascal-context-480x480.py
deleted file mode 100644
index d99cb0d..0000000
--- a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_pascal-context-480x480.py
+++ /dev/null
@@ -1,13 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_r50-d8.py', '../_base_/datasets/pascal_context.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (480, 480)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=60),
-    auxiliary_head=dict(num_classes=60),
-    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_pascal-context-59-480x480.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_pascal-context-59-480x480.py
deleted file mode 100644
index 64c9410..0000000
--- a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_pascal-context-59-480x480.py
+++ /dev/null
@@ -1,14 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_r50-d8.py',
-    '../_base_/datasets/pascal_context_59.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (480, 480)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=59),
-    auxiliary_head=dict(num_classes=59),
-    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index 42edb46..0000000
--- a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_r50-d8.py', '../_base_/datasets/pascal_voc12_aug.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 099f6af..0000000
--- a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_pascal-context-480x480.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_pascal-context-480x480.py
deleted file mode 100644
index 1eeafb8..0000000
--- a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_pascal-context-480x480.py
+++ /dev/null
@@ -1,13 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_r50-d8.py', '../_base_/datasets/pascal_context.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (480, 480)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=60),
-    auxiliary_head=dict(num_classes=60),
-    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_pascal-context-59-480x480.py b/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_pascal-context-59-480x480.py
deleted file mode 100644
index c11a9bb..0000000
--- a/mmsegmentation/configs/fcn/fcn_r50-d8_4xb4-80k_pascal-context-59-480x480.py
+++ /dev/null
@@ -1,14 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_r50-d8.py',
-    '../_base_/datasets/pascal_context_59.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (480, 480)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=59),
-    auxiliary_head=dict(num_classes=59),
-    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 44821fd..0000000
--- a/mmsegmentation/configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='torchvision://resnet50', backbone=dict(type='ResNet'))
diff --git a/mmsegmentation/configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index a85b391..0000000
--- a/mmsegmentation/configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './fcn_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(pretrained='torchvision://resnet50', backbone=dict(type='ResNet'))
diff --git a/mmsegmentation/configs/fcn/metafile.yaml b/mmsegmentation/configs/fcn/metafile.yaml
deleted file mode 100644
index f3d80f6..0000000
--- a/mmsegmentation/configs/fcn/metafile.yaml
+++ /dev/null
@@ -1,997 +0,0 @@
-Collections:
-- Name: FCN
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-    - ADE20K
-    - Pascal VOC 2012 + Aug
-    - Pascal Context
-    - Pascal Context 59
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  README: configs/fcn/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: fcn_r50-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 72.25
-      mIoU(ms+flip): 73.36
-  Config: configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.7
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x1024_40k_cityscapes/fcn_r50-d8_512x1024_40k_cityscapes_20200604_192608-efe53f0d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x1024_40k_cityscapes/fcn_r50-d8_512x1024_40k_cityscapes_20200604_192608.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r101-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 75.45
-      mIoU(ms+flip): 76.58
-  Config: configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x1024_40k_cityscapes/fcn_r101-d8_512x1024_40k_cityscapes_20200604_181852-a883d3a1.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x1024_40k_cityscapes/fcn_r101-d8_512x1024_40k_cityscapes_20200604_181852.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r50-d8_4xb2-40k_cityscapes-769x769
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 71.47
-      mIoU(ms+flip): 72.54
-  Config: configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_769x769_40k_cityscapes/fcn_r50-d8_769x769_40k_cityscapes_20200606_113104-977b5d02.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_769x769_40k_cityscapes/fcn_r50-d8_769x769_40k_cityscapes_20200606_113104.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r101-d8_4xb2-40k_cityscapes-769x769
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 73.93
-      mIoU(ms+flip): 75.14
-  Config: configs/fcn/fcn_r101-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.4
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_769x769_40k_cityscapes/fcn_r101-d8_769x769_40k_cityscapes_20200606_113208-7d4ab69c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_769x769_40k_cityscapes/fcn_r101-d8_769x769_40k_cityscapes_20200606_113208.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r18-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 71.11
-      mIoU(ms+flip): 72.91
-  Config: configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-18-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.7
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18-d8_512x1024_80k_cityscapes/fcn_r18-d8_512x1024_80k_cityscapes_20201225_021327-6c50f8b4.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18-d8_512x1024_80k_cityscapes/fcn_r18-d8_512x1024_80k_cityscapes-20201225_021327.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r50-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 73.61
-      mIoU(ms+flip): 74.24
-  Config: configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x1024_80k_cityscapes/fcn_r50-d8_512x1024_80k_cityscapes_20200606_113019-03aa804d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x1024_80k_cityscapes/fcn_r50-d8_512x1024_80k_cityscapes_20200606_113019.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r101-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 75.13
-      mIoU(ms+flip): 75.94
-  Config: configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x1024_80k_cityscapes/fcn_r101-d8_512x1024_80k_cityscapes_20200606_113038-3fb937eb.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x1024_80k_cityscapes/fcn_r101-d8_512x1024_80k_cityscapes_20200606_113038.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r101-d8_4xb2-amp-80k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.8
-  Config: configs/fcn/fcn_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - FCN
-    - (FP16)
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.37
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_fp16_512x1024_80k_cityscapes/fcn_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230921-fb13e883.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_fp16_512x1024_80k_cityscapes/fcn_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230921.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r18-d8_4xb2-80k_cityscapes-769x769
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 70.8
-      mIoU(ms+flip): 73.16
-  Config: configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-18-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18-d8_769x769_80k_cityscapes/fcn_r18-d8_769x769_80k_cityscapes_20201225_021451-9739d1b8.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18-d8_769x769_80k_cityscapes/fcn_r18-d8_769x769_80k_cityscapes-20201225_021451.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r50-d8_4xb2-80k_cityscapes-769x769
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 72.64
-      mIoU(ms+flip): 73.32
-  Config: configs/fcn/fcn_r50-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_769x769_80k_cityscapes/fcn_r50-d8_769x769_80k_cityscapes_20200606_195749-f5caeabc.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_769x769_80k_cityscapes/fcn_r50-d8_769x769_80k_cityscapes_20200606_195749.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r101-d8_4xb2-80k_cityscapes-769x769
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 75.52
-      mIoU(ms+flip): 76.61
-  Config: configs/fcn/fcn_r101-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_769x769_80k_cityscapes/fcn_r101-d8_769x769_80k_cityscapes_20200606_214354-45cbac68.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_769x769_80k_cityscapes/fcn_r101-d8_769x769_80k_cityscapes_20200606_214354.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r18b-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 70.24
-      mIoU(ms+flip): 72.77
-  Config: configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-18b-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18b-d8_512x1024_80k_cityscapes/fcn_r18b-d8_512x1024_80k_cityscapes_20201225_230143-92c0f445.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18b-d8_512x1024_80k_cityscapes/fcn_r18b-d8_512x1024_80k_cityscapes-20201225_230143.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r50b-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 75.65
-      mIoU(ms+flip): 77.59
-  Config: configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50b-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50b-d8_512x1024_80k_cityscapes/fcn_r50b-d8_512x1024_80k_cityscapes_20201225_094221-82957416.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50b-d8_512x1024_80k_cityscapes/fcn_r50b-d8_512x1024_80k_cityscapes-20201225_094221.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r101b-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.37
-      mIoU(ms+flip): 78.77
-  Config: configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101b-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101b-d8_512x1024_80k_cityscapes/fcn_r101b-d8_512x1024_80k_cityscapes_20201226_160213-4543858f.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101b-d8_512x1024_80k_cityscapes/fcn_r101b-d8_512x1024_80k_cityscapes-20201226_160213.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r18b-d8_4xb2-80k_cityscapes-769x769
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 69.66
-      mIoU(ms+flip): 72.07
-  Config: configs/fcn/fcn_r18b-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-18b-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.7
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18b-d8_769x769_80k_cityscapes/fcn_r18b-d8_769x769_80k_cityscapes_20201226_004430-32d504e5.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r18b-d8_769x769_80k_cityscapes/fcn_r18b-d8_769x769_80k_cityscapes-20201226_004430.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r50b-d8_4xb2-80k_cityscapes-769x769
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 73.83
-      mIoU(ms+flip): 76.6
-  Config: configs/fcn/fcn_r50b-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50b-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.3
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50b-d8_769x769_80k_cityscapes/fcn_r50b-d8_769x769_80k_cityscapes_20201225_094223-94552d38.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50b-d8_769x769_80k_cityscapes/fcn_r50b-d8_769x769_80k_cityscapes-20201225_094223.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r101b-d8_4xb2-80k_cityscapes-769x769
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.02
-      mIoU(ms+flip): 78.67
-  Config: configs/fcn/fcn_r101b-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101b-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.3
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101b-d8_769x769_80k_cityscapes/fcn_r101b-d8_769x769_80k_cityscapes_20201226_170012-82be37e2.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101b-d8_769x769_80k_cityscapes/fcn_r101b-d8_769x769_80k_cityscapes-20201226_170012.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn-d6_r50-d16_4xb2-40k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.06
-      mIoU(ms+flip): 78.85
-  Config: configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D16
-    - FCN
-    - (D6)
-    Training Resources: 4x TITAN Xp GPUS
-    Memory (GB): 3.4
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_512x1024_40k_cityscapes/fcn_d6_r50-d16_512x1024_40k_cityscapes_20210305_130133-98d5d1bc.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_512x1024_40k_cityscapes/fcn_d6_r50-d16_512x1024_40k_cityscapes-20210305_130133.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn-d6_r50-d16_4xb2-80k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.27
-      mIoU(ms+flip): 78.88
-  Config: configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D16
-    - FCN
-    - (D6)
-    Training Resources: 4x TITAN Xp GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_512x1024_80k_cityscapes/fcn_d6_r50-d16_512x1024_80k_cityscapes_20210306_115604-133c292f.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_512x1024_80k_cityscapes/fcn_d6_r50-d16_512x1024_80k_cityscapes-20210306_115604.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn-d6_r50-d16_4xb2-40k_cityscapes-769x769
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.82
-      mIoU(ms+flip): 78.22
-  Config: configs/fcn/fcn-d6_r50-d16_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D16
-    - FCN
-    - (D6)
-    Training Resources: 4x TITAN Xp GPUS
-    Memory (GB): 3.7
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_769x769_40k_cityscapes/fcn_d6_r50-d16_769x769_40k_cityscapes_20210305_185744-1aab18ed.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_769x769_40k_cityscapes/fcn_d6_r50-d16_769x769_40k_cityscapes-20210305_185744.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn-d6_r50-d16_4xb2-80k_cityscapes-769x769
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.04
-      mIoU(ms+flip): 78.4
-  Config: configs/fcn/fcn-d6_r50-d16_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D16
-    - FCN
-    - (D6)
-    Training Resources: 4x TITAN Xp GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_769x769_80k_cityscapes/fcn_d6_r50-d16_769x769_80k_cityscapes_20210305_200413-109d88eb.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50-d16_769x769_80k_cityscapes/fcn_d6_r50-d16_769x769_80k_cityscapes-20210305_200413.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn-d6_r101-d16_4xb2-40k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.36
-      mIoU(ms+flip): 79.18
-  Config: configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D16
-    - FCN
-    - (D6)
-    Training Resources: 4x TITAN Xp GPUS
-    Memory (GB): 4.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_512x1024_40k_cityscapes/fcn_d6_r101-d16_512x1024_40k_cityscapes_20210305_130337-9cf2b450.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_512x1024_40k_cityscapes/fcn_d6_r101-d16_512x1024_40k_cityscapes-20210305_130337.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn-d6_r101-d16_4xb2-80k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.46
-      mIoU(ms+flip): 80.42
-  Config: configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D16
-    - FCN
-    - (D6)
-    Training Resources: 4x TITAN Xp GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_512x1024_80k_cityscapes/fcn_d6_r101-d16_512x1024_80k_cityscapes_20210308_102747-cb336445.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_512x1024_80k_cityscapes/fcn_d6_r101-d16_512x1024_80k_cityscapes-20210308_102747.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn-d6_r101-d16_4xb2-40k_cityscapes-769x769
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.28
-      mIoU(ms+flip): 78.95
-  Config: configs/fcn/fcn-d6_r101-d16_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D16
-    - FCN
-    - (D6)
-    Training Resources: 4x TITAN Xp GPUS
-    Memory (GB): 5.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_769x769_40k_cityscapes/fcn_d6_r101-d16_769x769_40k_cityscapes_20210308_102453-60b114e9.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_769x769_40k_cityscapes/fcn_d6_r101-d16_769x769_40k_cityscapes-20210308_102453.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn-d6_r101-d16_4xb2-80k_cityscapes-769x769
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.06
-      mIoU(ms+flip): 79.58
-  Config: configs/fcn/fcn-d6_r101-d16_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D16
-    - FCN
-    - (D6)
-    Training Resources: 4x TITAN Xp GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_769x769_80k_cityscapes/fcn_d6_r101-d16_769x769_80k_cityscapes_20210306_120016-e33adc4f.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101-d16_769x769_80k_cityscapes/fcn_d6_r101-d16_769x769_80k_cityscapes-20210306_120016.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn-d6_r50b-d16_4xb2-80k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.99
-      mIoU(ms+flip): 79.03
-  Config: configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50b-D16
-    - FCN
-    - (D6)
-    Training Resources: 4x TITAN Xp GPUS
-    Memory (GB): 3.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50b-d16_512x1024_80k_cityscapes/fcn_d6_r50b-d16_512x1024_80k_cityscapes_20210311_125550-6a0b62e9.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50b_d16_512x1024_80k_cityscapes/fcn_d6_r50b_d16_512x1024_80k_cityscapes-20210311_125550.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn-d6_r50b-d16_4xb2-80k_cityscapes-769x769
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.86
-      mIoU(ms+flip): 78.52
-  Config: configs/fcn/fcn-d6_r50b-d16_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50b-D16
-    - FCN
-    - (D6)
-    Training Resources: 4x TITAN Xp GPUS
-    Memory (GB): 3.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50b-d16_769x769_80k_cityscapes/fcn_d6_r50b-d16_769x769_80k_cityscapes_20210311_131012-d665f231.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r50b_d16_769x769_80k_cityscapes/fcn_d6_r50b_d16_769x769_80k_cityscapes-20210311_131012.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn-d6_r101b-d16_4xb2-80k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.72
-      mIoU(ms+flip): 79.53
-  Config: configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101b-D16
-    - FCN
-    - (D6)
-    Training Resources: 4x TITAN Xp GPUS
-    Memory (GB): 4.3
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101b-d16_512x1024_80k_cityscapes/fcn_d6_r101b-d16_512x1024_80k_cityscapes_20210311_144305-3f2eb5b4.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101b_d16_512x1024_80k_cityscapes/fcn_d6_r101b_d16_512x1024_80k_cityscapes-20210311_144305.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn-d6_r101b-d16_4xb2-80k_cityscapes-769x769
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.34
-      mIoU(ms+flip): 78.91
-  Config: configs/fcn/fcn-d6_r101b-d16_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101b-D16
-    - FCN
-    - (D6)
-    Training Resources: 4x TITAN Xp GPUS
-    Memory (GB): 4.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101b-d16_769x769_80k_cityscapes/fcn_d6_r101b-d16_769x769_80k_cityscapes_20210311_154527-c4d8bfbc.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_d6_r101b_d16_769x769_80k_cityscapes/fcn_d6_r101b_d16_769x769_80k_cityscapes-20210311_154527.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r50-d8_4xb4-80k_ade20k-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 35.94
-      mIoU(ms+flip): 37.94
-  Config: configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_80k_ade20k/fcn_r50-d8_512x512_80k_ade20k_20200614_144016-f8ac5082.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_80k_ade20k/fcn_r50-d8_512x512_80k_ade20k_20200614_144016.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r101-d8_4xb4-80k_ade20k-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 39.61
-      mIoU(ms+flip): 40.83
-  Config: configs/fcn/fcn_r101-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 12.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_80k_ade20k/fcn_r101-d8_512x512_80k_ade20k_20200615_014143-bc1809f7.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_80k_ade20k/fcn_r101-d8_512x512_80k_ade20k_20200615_014143.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r50-d8_4xb4-160k_ade20k-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 36.1
-      mIoU(ms+flip): 38.08
-  Config: configs/fcn/fcn_r50-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_160k_ade20k/fcn_r50-d8_512x512_160k_ade20k_20200615_100713-4edbc3b4.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_160k_ade20k/fcn_r50-d8_512x512_160k_ade20k_20200615_100713.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r101-d8_4xb4-160k_ade20k-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 39.91
-      mIoU(ms+flip): 41.4
-  Config: configs/fcn/fcn_r101-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_160k_ade20k/fcn_r101-d8_512x512_160k_ade20k_20200615_105816-fd192bd5.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_160k_ade20k/fcn_r101-d8_512x512_160k_ade20k_20200615_105816.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r50-d8_4xb4-20k_voc12aug-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 67.08
-      mIoU(ms+flip): 69.94
-  Config: configs/fcn/fcn_r50-d8_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.7
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_20k_voc12aug/fcn_r50-d8_512x512_20k_voc12aug_20200617_010715-52dc5306.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_20k_voc12aug/fcn_r50-d8_512x512_20k_voc12aug_20200617_010715.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r101-d8_4xb4-20k_voc12aug-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 71.16
-      mIoU(ms+flip): 73.57
-  Config: configs/fcn/fcn_r101-d8_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_20k_voc12aug/fcn_r101-d8_512x512_20k_voc12aug_20200617_010842-0bb4e798.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_20k_voc12aug/fcn_r101-d8_512x512_20k_voc12aug_20200617_010842.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r50-d8_4xb4-40k_voc12aug-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 66.97
-      mIoU(ms+flip): 69.04
-  Config: configs/fcn/fcn_r50-d8_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_40k_voc12aug/fcn_r50-d8_512x512_40k_voc12aug_20200613_161222-5e2dbf40.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x512_40k_voc12aug/fcn_r50-d8_512x512_40k_voc12aug_20200613_161222.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r101-d8_4xb4-40k_voc12aug-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 69.91
-      mIoU(ms+flip): 72.38
-  Config: configs/fcn/fcn_r101-d8_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_40k_voc12aug/fcn_r101-d8_512x512_40k_voc12aug_20200613_161240-4c8bcefd.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_512x512_40k_voc12aug/fcn_r101-d8_512x512_40k_voc12aug_20200613_161240.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r101-d8_4xb4-40k_pascal-context-480x480
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal Context
-    Metrics:
-      mIoU: 44.43
-      mIoU(ms+flip): 45.63
-  Config: configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-480x480.py
-  Metadata:
-    Training Data: Pascal Context
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_40k_pascal_context/fcn_r101-d8_480x480_40k_pascal_context_20210421_154757-b5e97937.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_40k_pascal_context/fcn_r101-d8_480x480_40k_pascal_context-20210421_154757.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r101-d8_4xb4-80k_pascal-context-480x480
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal Context
-    Metrics:
-      mIoU: 44.13
-      mIoU(ms+flip): 45.26
-  Config: configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-480x480.py
-  Metadata:
-    Training Data: Pascal Context
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_80k_pascal_context/fcn_r101-d8_480x480_80k_pascal_context_20210421_163310-4711813f.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_80k_pascal_context/fcn_r101-d8_480x480_80k_pascal_context-20210421_163310.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r101-d8_4xb4-40k_pascal-context-59-480x480
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal Context 59
-    Metrics:
-      mIoU: 48.42
-      mIoU(ms+flip): 50.4
-  Config: configs/fcn/fcn_r101-d8_4xb4-40k_pascal-context-59-480x480.py
-  Metadata:
-    Training Data: Pascal Context 59
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_40k_pascal_context_59/fcn_r101-d8_480x480_40k_pascal_context_59_20210415_230724-8cf83682.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_40k_pascal_context_59/fcn_r101-d8_480x480_40k_pascal_context_59-20210415_230724.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
-- Name: fcn_r101-d8_4xb4-80k_pascal-context-59-480x480
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal Context 59
-    Metrics:
-      mIoU: 49.35
-      mIoU(ms+flip): 51.38
-  Config: configs/fcn/fcn_r101-d8_4xb4-80k_pascal-context-59-480x480.py
-  Metadata:
-    Training Data: Pascal Context 59
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_80k_pascal_context_59/fcn_r101-d8_480x480_80k_pascal_context_59_20210416_110804-9a6f2c94.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r101-d8_480x480_80k_pascal_context_59/fcn_r101-d8_480x480_80k_pascal_context_59-20210416_110804.log.json
-  Paper:
-    Title: Fully Convolutional Networks for Semantic Segmentation
-    URL: https://arxiv.org/abs/1411.4038
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fcn_head.py#L11
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/gcnet/README.md b/mmsegmentation/configs/gcnet/README.md
deleted file mode 100644
index ba1a21e..0000000
--- a/mmsegmentation/configs/gcnet/README.md
+++ /dev/null
@@ -1,68 +0,0 @@
-# GCNet
-
-> [GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond](https://arxiv.org/abs/1904.11492)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/xvjiarui/GCNet">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-The Non-Local Network (NLNet) presents a pioneering approach for capturing long-range dependencies, via aggregating query-specific global context to each query position. However, through a rigorous empirical analysis, we have found that the global contexts modeled by non-local network are almost the same for different query positions within an image. In this paper, we take advantage of this finding to create a simplified network based on a query-independent formulation, which maintains the accuracy of NLNet but with significantly less computation. We further observe that this simplified design shares similar structure with Squeeze-Excitation Network (SENet). Hence we unify them into a three-step general framework for global context modeling. Within the general framework, we design a better instantiation, called the global context (GC) block, which is lightweight and can effectively model the global context. The lightweight property allows us to apply it for multiple layers in a backbone network to construct a global context network (GCNet), which generally outperforms both simplified NLNet and SENet on major benchmarks for various recognition tasks. The code and configurations are released at [this https URL](https://github.com/xvjiarui/GCNet).
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142901601-ad17922e-2538-4b48-9f51-84a57d44b12b.png" width="80%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                        | download                                                                                                                                                                                                                                                                                                                                           |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ----------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| GCNet  | R-50-D8  | 512x1024  |   40000 | 5.8      | 3.93           | V100   | 77.69 |         78.56 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x1024_40k_cityscapes/gcnet_r50-d8_512x1024_40k_cityscapes_20200618_074436-4b0fd17b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x1024_40k_cityscapes/gcnet_r50-d8_512x1024_40k_cityscapes_20200618_074436.log.json)     |
-| GCNet  | R-101-D8 | 512x1024  |   40000 | 9.2      | 2.61           | V100   | 78.28 |         79.34 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x1024_40k_cityscapes/gcnet_r101-d8_512x1024_40k_cityscapes_20200618_074436-5e62567f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x1024_40k_cityscapes/gcnet_r101-d8_512x1024_40k_cityscapes_20200618_074436.log.json) |
-| GCNet  | R-50-D8  | 769x769   |   40000 | 6.5      | 1.67           | V100   | 78.12 |         80.09 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-769x769.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_769x769_40k_cityscapes/gcnet_r50-d8_769x769_40k_cityscapes_20200618_182814-a26f4471.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_769x769_40k_cityscapes/gcnet_r50-d8_769x769_40k_cityscapes_20200618_182814.log.json)         |
-| GCNet  | R-101-D8 | 769x769   |   40000 | 10.5     | 1.13           | V100   | 78.95 |         80.71 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_769x769_40k_cityscapes/gcnet_r101-d8_769x769_40k_cityscapes_20200619_092550-ca4f0a84.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_769x769_40k_cityscapes/gcnet_r101-d8_769x769_40k_cityscapes_20200619_092550.log.json)     |
-| GCNet  | R-50-D8  | 512x1024  |   80000 | -        | -              | V100   | 78.48 |         80.01 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x1024_80k_cityscapes/gcnet_r50-d8_512x1024_80k_cityscapes_20200618_074450-ef8f069b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x1024_80k_cityscapes/gcnet_r50-d8_512x1024_80k_cityscapes_20200618_074450.log.json)     |
-| GCNet  | R-101-D8 | 512x1024  |   80000 | -        | -              | V100   | 79.03 |         79.84 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-512x1024.pyy) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x1024_80k_cityscapes/gcnet_r101-d8_512x1024_80k_cityscapes_20200618_074450-778ebf69.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x1024_80k_cityscapes/gcnet_r101-d8_512x1024_80k_cityscapes_20200618_074450.log.json) |
-| GCNet  | R-50-D8  | 769x769   |   80000 | -        | -              | V100   | 78.68 |         80.66 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-769x769.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_769x769_80k_cityscapes/gcnet_r50-d8_769x769_80k_cityscapes_20200619_092516-4839565b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_769x769_80k_cityscapes/gcnet_r50-d8_769x769_80k_cityscapes_20200619_092516.log.json)         |
-| GCNet  | R-101-D8 | 769x769   |   80000 | -        | -              | V100   | 79.18 |         80.71 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_769x769_80k_cityscapes/gcnet_r101-d8_769x769_80k_cityscapes_20200619_092628-8e043423.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_769x769_80k_cityscapes/gcnet_r101-d8_769x769_80k_cityscapes_20200619_092628.log.json)     |
-
-### ADE20K
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                   | download                                                                                                                                                                                                                                                                                                                           |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| GCNet  | R-50-D8  | 512x512   |   80000 | 8.5      | 23.38          | V100   | 41.47 |         42.85 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_80k_ade20k/gcnet_r50-d8_512x512_80k_ade20k_20200614_185146-91a6da41.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_80k_ade20k/gcnet_r50-d8_512x512_80k_ade20k_20200614_185146.log.json)         |
-| GCNet  | R-101-D8 | 512x512   |   80000 | 12       | 15.20          | V100   | 42.82 |         44.54 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_80k_ade20k/gcnet_r101-d8_512x512_80k_ade20k_20200615_020811-c3fcb6dd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_80k_ade20k/gcnet_r101-d8_512x512_80k_ade20k_20200615_020811.log.json)     |
-| GCNet  | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 42.37 |         43.52 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_160k_ade20k/gcnet_r50-d8_512x512_160k_ade20k_20200615_224122-d95f3e1f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_160k_ade20k/gcnet_r50-d8_512x512_160k_ade20k_20200615_224122.log.json)     |
-| GCNet  | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 43.69 |         45.21 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_160k_ade20k/gcnet_r101-d8_512x512_160k_ade20k_20200615_225406-615528d7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_160k_ade20k/gcnet_r101-d8_512x512_160k_ade20k_20200615_225406.log.json) |
-
-### Pascal VOC 2012 + Aug
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                    | download                                                                                                                                                                                                                                                                                                                               |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| GCNet  | R-50-D8  | 512x512   |   20000 | 5.8      | 23.35          | V100   | 76.42 |         77.51 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r50-d8_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_20k_voc12aug/gcnet_r50-d8_512x512_20k_voc12aug_20200617_165701-3cbfdab1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_20k_voc12aug/gcnet_r50-d8_512x512_20k_voc12aug_20200617_165701.log.json)     |
-| GCNet  | R-101-D8 | 512x512   |   20000 | 9.2      | 14.80          | V100   | 77.41 |         78.56 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r101-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_20k_voc12aug/gcnet_r101-d8_512x512_20k_voc12aug_20200617_165713-6c720aa9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_20k_voc12aug/gcnet_r101-d8_512x512_20k_voc12aug_20200617_165713.log.json) |
-| GCNet  | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 76.24 |         77.63 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r50-d8_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_40k_voc12aug/gcnet_r50-d8_512x512_40k_voc12aug_20200613_195105-9797336d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_40k_voc12aug/gcnet_r50-d8_512x512_40k_voc12aug_20200613_195105.log.json)     |
-| GCNet  | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 77.84 |         78.59 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet/gcnet_r101-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_40k_voc12aug/gcnet_r101-d8_512x512_40k_voc12aug_20200613_185806-1e38208d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_40k_voc12aug/gcnet_r101-d8_512x512_40k_voc12aug_20200613_185806.log.json) |
-
-## Citation
-
-```bibtex
-@inproceedings{cao2019gcnet,
-  title={Gcnet: Non-local networks meet squeeze-excitation networks and beyond},
-  author={Cao, Yue and Xu, Jiarui and Lin, Stephen and Wei, Fangyun and Hu, Han},
-  booktitle={Proceedings of the IEEE International Conference on Computer Vision Workshops},
-  pages={0--0},
-  year={2019}
-}
-```
diff --git a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index e8f7c55..0000000
--- a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './gcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index 887d17b..0000000
--- a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './gcnet_r50-d8_4xb2-40k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index aa47578..0000000
--- a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './gcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index ddf4ad7..0000000
--- a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './gcnet_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 45285c0..0000000
--- a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './gcnet_r50-d8_4xb4-160k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index b466c40..0000000
--- a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './gcnet_r50-d8_4xb4-20k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index 9c7f741..0000000
--- a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './gcnet_r50-d8_4xb4-40k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 61337db..0000000
--- a/mmsegmentation/configs/gcnet/gcnet_r101-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './gcnet_r50-d8_4xb4-80k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index f976bd9..0000000
--- a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/gcnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index 34ce822..0000000
--- a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/gcnet_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 5088929..0000000
--- a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/gcnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index f886f17..0000000
--- a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/gcnet_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index d3f5631..0000000
--- a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/gcnet_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index 356b088..0000000
--- a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/gcnet_r50-d8.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_20k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index 802b766..0000000
--- a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/gcnet_r50-d8.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 7327934..0000000
--- a/mmsegmentation/configs/gcnet/gcnet_r50-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/gcnet_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/gcnet/metafile.yaml b/mmsegmentation/configs/gcnet/metafile.yaml
deleted file mode 100644
index 1f3c462..0000000
--- a/mmsegmentation/configs/gcnet/metafile.yaml
+++ /dev/null
@@ -1,391 +0,0 @@
-Collections:
-- Name: GCNet
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-    - ADE20K
-    - Pascal VOC 2012 + Aug
-  Paper:
-    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
-    URL: https://arxiv.org/abs/1904.11492
-  README: configs/gcnet/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: gcnet_r50-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: GCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.69
-      mIoU(ms+flip): 78.56
-  Config: configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - GCNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x1024_40k_cityscapes/gcnet_r50-d8_512x1024_40k_cityscapes_20200618_074436-4b0fd17b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x1024_40k_cityscapes/gcnet_r50-d8_512x1024_40k_cityscapes_20200618_074436.log.json
-  Paper:
-    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
-    URL: https://arxiv.org/abs/1904.11492
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
-  Framework: PyTorch
-- Name: gcnet_r101-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: GCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.28
-      mIoU(ms+flip): 79.34
-  Config: configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - GCNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x1024_40k_cityscapes/gcnet_r101-d8_512x1024_40k_cityscapes_20200618_074436-5e62567f.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x1024_40k_cityscapes/gcnet_r101-d8_512x1024_40k_cityscapes_20200618_074436.log.json
-  Paper:
-    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
-    URL: https://arxiv.org/abs/1904.11492
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
-  Framework: PyTorch
-- Name: gcnet_r50-d8_4xb2-40k_cityscapes-769x769
-  In Collection: GCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.12
-      mIoU(ms+flip): 80.09
-  Config: configs/gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - GCNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_769x769_40k_cityscapes/gcnet_r50-d8_769x769_40k_cityscapes_20200618_182814-a26f4471.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_769x769_40k_cityscapes/gcnet_r50-d8_769x769_40k_cityscapes_20200618_182814.log.json
-  Paper:
-    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
-    URL: https://arxiv.org/abs/1904.11492
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
-  Framework: PyTorch
-- Name: gcnet_r101-d8_4xb2-40k_cityscapes-769x769
-  In Collection: GCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.95
-      mIoU(ms+flip): 80.71
-  Config: configs/gcnet/gcnet_r101-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - GCNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_769x769_40k_cityscapes/gcnet_r101-d8_769x769_40k_cityscapes_20200619_092550-ca4f0a84.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_769x769_40k_cityscapes/gcnet_r101-d8_769x769_40k_cityscapes_20200619_092550.log.json
-  Paper:
-    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
-    URL: https://arxiv.org/abs/1904.11492
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
-  Framework: PyTorch
-- Name: gcnet_r50-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: GCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.48
-      mIoU(ms+flip): 80.01
-  Config: configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - GCNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x1024_80k_cityscapes/gcnet_r50-d8_512x1024_80k_cityscapes_20200618_074450-ef8f069b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x1024_80k_cityscapes/gcnet_r50-d8_512x1024_80k_cityscapes_20200618_074450.log.json
-  Paper:
-    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
-    URL: https://arxiv.org/abs/1904.11492
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
-  Framework: PyTorch
-- Name: gcnet_r101-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: GCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.03
-      mIoU(ms+flip): 79.84
-  Config: configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - GCNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x1024_80k_cityscapes/gcnet_r101-d8_512x1024_80k_cityscapes_20200618_074450-778ebf69.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x1024_80k_cityscapes/gcnet_r101-d8_512x1024_80k_cityscapes_20200618_074450.log.json
-  Paper:
-    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
-    URL: https://arxiv.org/abs/1904.11492
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
-  Framework: PyTorch
-- Name: gcnet_r50-d8_4xb2-80k_cityscapes-769x769
-  In Collection: GCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.68
-      mIoU(ms+flip): 80.66
-  Config: configs/gcnet/gcnet_r50-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - GCNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_769x769_80k_cityscapes/gcnet_r50-d8_769x769_80k_cityscapes_20200619_092516-4839565b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_769x769_80k_cityscapes/gcnet_r50-d8_769x769_80k_cityscapes_20200619_092516.log.json
-  Paper:
-    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
-    URL: https://arxiv.org/abs/1904.11492
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
-  Framework: PyTorch
-- Name: gcnet_r101-d8_4xb2-80k_cityscapes-769x769
-  In Collection: GCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.18
-      mIoU(ms+flip): 80.71
-  Config: configs/gcnet/gcnet_r101-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - GCNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_769x769_80k_cityscapes/gcnet_r101-d8_769x769_80k_cityscapes_20200619_092628-8e043423.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_769x769_80k_cityscapes/gcnet_r101-d8_769x769_80k_cityscapes_20200619_092628.log.json
-  Paper:
-    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
-    URL: https://arxiv.org/abs/1904.11492
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
-  Framework: PyTorch
-- Name: gcnet_r50-d8_4xb4-80k_ade20k-512x512
-  In Collection: GCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 41.47
-      mIoU(ms+flip): 42.85
-  Config: configs/gcnet/gcnet_r50-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - GCNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_80k_ade20k/gcnet_r50-d8_512x512_80k_ade20k_20200614_185146-91a6da41.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_80k_ade20k/gcnet_r50-d8_512x512_80k_ade20k_20200614_185146.log.json
-  Paper:
-    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
-    URL: https://arxiv.org/abs/1904.11492
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
-  Framework: PyTorch
-- Name: gcnet_r101-d8_4xb4-80k_ade20k-512x512
-  In Collection: GCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.82
-      mIoU(ms+flip): 44.54
-  Config: configs/gcnet/gcnet_r101-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - GCNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 12.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_80k_ade20k/gcnet_r101-d8_512x512_80k_ade20k_20200615_020811-c3fcb6dd.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_80k_ade20k/gcnet_r101-d8_512x512_80k_ade20k_20200615_020811.log.json
-  Paper:
-    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
-    URL: https://arxiv.org/abs/1904.11492
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
-  Framework: PyTorch
-- Name: gcnet_r50-d8_4xb4-160k_ade20k-512x512
-  In Collection: GCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.37
-      mIoU(ms+flip): 43.52
-  Config: configs/gcnet/gcnet_r50-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - GCNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_160k_ade20k/gcnet_r50-d8_512x512_160k_ade20k_20200615_224122-d95f3e1f.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_160k_ade20k/gcnet_r50-d8_512x512_160k_ade20k_20200615_224122.log.json
-  Paper:
-    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
-    URL: https://arxiv.org/abs/1904.11492
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
-  Framework: PyTorch
-- Name: gcnet_r101-d8_4xb4-160k_ade20k-512x512
-  In Collection: GCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 43.69
-      mIoU(ms+flip): 45.21
-  Config: configs/gcnet/gcnet_r101-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - GCNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_160k_ade20k/gcnet_r101-d8_512x512_160k_ade20k_20200615_225406-615528d7.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_160k_ade20k/gcnet_r101-d8_512x512_160k_ade20k_20200615_225406.log.json
-  Paper:
-    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
-    URL: https://arxiv.org/abs/1904.11492
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
-  Framework: PyTorch
-- Name: gcnet_r50-d8_4xb4-20k_voc12aug-512x512
-  In Collection: GCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 76.42
-      mIoU(ms+flip): 77.51
-  Config: configs/gcnet/gcnet_r50-d8_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - GCNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_20k_voc12aug/gcnet_r50-d8_512x512_20k_voc12aug_20200617_165701-3cbfdab1.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_20k_voc12aug/gcnet_r50-d8_512x512_20k_voc12aug_20200617_165701.log.json
-  Paper:
-    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
-    URL: https://arxiv.org/abs/1904.11492
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
-  Framework: PyTorch
-- Name: gcnet_r101-d8_4xb4-20k_voc12aug-512x512
-  In Collection: GCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 77.41
-      mIoU(ms+flip): 78.56
-  Config: configs/gcnet/gcnet_r101-d8_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - GCNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_20k_voc12aug/gcnet_r101-d8_512x512_20k_voc12aug_20200617_165713-6c720aa9.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_20k_voc12aug/gcnet_r101-d8_512x512_20k_voc12aug_20200617_165713.log.json
-  Paper:
-    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
-    URL: https://arxiv.org/abs/1904.11492
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
-  Framework: PyTorch
-- Name: gcnet_r50-d8_4xb4-40k_voc12aug-512x512
-  In Collection: GCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 76.24
-      mIoU(ms+flip): 77.63
-  Config: configs/gcnet/gcnet_r50-d8_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - GCNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_40k_voc12aug/gcnet_r50-d8_512x512_40k_voc12aug_20200613_195105-9797336d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r50-d8_512x512_40k_voc12aug/gcnet_r50-d8_512x512_40k_voc12aug_20200613_195105.log.json
-  Paper:
-    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
-    URL: https://arxiv.org/abs/1904.11492
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
-  Framework: PyTorch
-- Name: gcnet_r101-d8_4xb4-40k_voc12aug-512x512
-  In Collection: GCNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 77.84
-      mIoU(ms+flip): 78.59
-  Config: configs/gcnet/gcnet_r101-d8_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - GCNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_40k_voc12aug/gcnet_r101-d8_512x512_40k_voc12aug_20200613_185806-1e38208d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/gcnet/gcnet_r101-d8_512x512_40k_voc12aug/gcnet_r101-d8_512x512_40k_voc12aug_20200613_185806.log.json
-  Paper:
-    Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond'
-    URL: https://arxiv.org/abs/1904.11492
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/gc_head.py#L10
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/hrnet/README.md b/mmsegmentation/configs/hrnet/README.md
deleted file mode 100644
index b529fc8..0000000
--- a/mmsegmentation/configs/hrnet/README.md
+++ /dev/null
@@ -1,122 +0,0 @@
-# HRNet
-
-> [Deep High-Resolution Representation Learning for Human Pose Estimation](https://arxiv.org/abs/1908.07919)
-
-## Introduction
-
-<!-- [BACKBONE] -->
-
-<a href="https://github.com/HRNet/HRNet-Semantic-Segmentation">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-High-resolution representations are essential for position-sensitive vision problems, such as human pose estimation, semantic segmentation, and object detection. Existing state-of-the-art frameworks first encode the input image as a low-resolution representation through a subnetwork that is formed by connecting high-to-low resolution convolutions \\emph{in series} (e.g., ResNet, VGGNet), and then recover the high-resolution representation from the encoded low-resolution representation. Instead, our proposed network, named as High-Resolution Network (HRNet), maintains high-resolution representations through the whole process. There are two key characteristics: (i) Connect the high-to-low resolution convolution streams \\emph{in parallel}; (ii) Repeatedly exchange the information across resolutions. The benefit is that the resulting representation is semantically richer and spatially more precise. We show the superiority of the proposed HRNet in a wide range of applications, including human pose estimation, semantic segmentation, and object detection, suggesting that the HRNet is a stronger backbone for computer vision problems. All the codes are available at [this https URL](https://github.com/HRNet).
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142901680-64c285bc-669f-4924-b054-46a2f07c5427.png" width="80%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method | Backbone           | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                    | download                                                                                                                                                                                                                                                                                                                               |
-| ------ | ------------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| FCN    | HRNetV2p-W18-Small | 512x1024  |   40000 | 1.7      | 23.74          | V100   | 73.86 |         75.91 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18s_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_40k_cityscapes/fcn_hr18s_512x1024_40k_cityscapes_20200601_014216-93db27d0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_40k_cityscapes/fcn_hr18s_512x1024_40k_cityscapes_20200601_014216.log.json)     |
-| FCN    | HRNetV2p-W18       | 512x1024  |   40000 | 2.9      | 12.97          | V100   | 77.19 |         78.92 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18_4xb2-40k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_40k_cityscapes/fcn_hr18_512x1024_40k_cityscapes_20200601_014216-f196fb4e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_40k_cityscapes/fcn_hr18_512x1024_40k_cityscapes_20200601_014216.log.json)         |
-| FCN    | HRNetV2p-W48       | 512x1024  |   40000 | 6.2      | 6.42           | V100   | 78.48 |         79.69 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb2-40k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_40k_cityscapes/fcn_hr48_512x1024_40k_cityscapes_20200601_014240-a989b146.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_40k_cityscapes/fcn_hr48_512x1024_40k_cityscapes_20200601_014240.log.json)         |
-| FCN    | HRNetV2p-W18-Small | 512x1024  |   80000 | -        | -              | V100   | 75.31 |         77.48 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18s_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_80k_cityscapes/fcn_hr18s_512x1024_80k_cityscapes_20200601_202700-1462b75d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_80k_cityscapes/fcn_hr18s_512x1024_80k_cityscapes_20200601_202700.log.json)     |
-| FCN    | HRNetV2p-W18       | 512x1024  |   80000 | -        | -              | V100   | 78.65 |         80.35 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18_4xb2-80k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_80k_cityscapes/fcn_hr18_512x1024_80k_cityscapes_20200601_223255-4e7b345e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_80k_cityscapes/fcn_hr18_512x1024_80k_cityscapes_20200601_223255.log.json)         |
-| FCN    | HRNetV2p-W48       | 512x1024  |   80000 | -        | -              | V100   | 79.93 |         80.72 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb2-80k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_80k_cityscapes/fcn_hr48_512x1024_80k_cityscapes_20200601_202606-58ea95d6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_80k_cityscapes/fcn_hr48_512x1024_80k_cityscapes_20200601_202606.log.json)         |
-| FCN    | HRNetV2p-W18-Small | 512x1024  |  160000 | -        | -              | V100   | 76.31 |         78.31 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18s_4xb2-160k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_160k_cityscapes/fcn_hr18s_512x1024_160k_cityscapes_20200602_190901-4a0797ea.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_160k_cityscapes/fcn_hr18s_512x1024_160k_cityscapes_20200602_190901.log.json) |
-| FCN    | HRNetV2p-W18       | 512x1024  |  160000 | -        | -              | V100   | 78.80 |         80.74 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18_4xb2-160k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_160k_cityscapes/fcn_hr18_512x1024_160k_cityscapes_20200602_190822-221e4a4f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_160k_cityscapes/fcn_hr18_512x1024_160k_cityscapes_20200602_190822.log.json)     |
-| FCN    | HRNetV2p-W48       | 512x1024  |  160000 | -        | -              | V100   | 80.65 |         81.92 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb2-160k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_160k_cityscapes/fcn_hr48_512x1024_160k_cityscapes_20200602_190946-59b7973e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_160k_cityscapes/fcn_hr48_512x1024_160k_cityscapes_20200602_190946.log.json)     |
-
-### ADE20K
-
-| Method | Backbone           | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                               | download                                                                                                                                                                                                                                                                                                           |
-| ------ | ------------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| FCN    | HRNetV2p-W18-Small | 512x512   |   80000 | 3.8      | 38.66          | V100   | 31.38 |         32.45 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18s_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_ade20k/fcn_hr18s_512x512_80k_ade20k_20200614_144345-77fc814a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_ade20k/fcn_hr18s_512x512_80k_ade20k_20200614_144345.log.json)     |
-| FCN    | HRNetV2p-W18       | 512x512   |   80000 | 4.9      | 22.57          | V100   | 36.27 |         37.28 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_ade20k/fcn_hr18_512x512_80k_ade20k_20210827_114910-6c9382c0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_ade20k/fcn_hr18_512x512_80k_ade20k_20210827_114910.log.json)         |
-| FCN    | HRNetV2p-W48       | 512x512   |   80000 | 8.2      | 21.23          | V100   | 41.90 |         43.27 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_ade20k/fcn_hr48_512x512_80k_ade20k_20200614_193946-7ba5258d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_ade20k/fcn_hr48_512x512_80k_ade20k_20200614_193946.log.json)         |
-| FCN    | HRNetV2p-W18-Small | 512x512   |  160000 | -        | -              | V100   | 33.07 |         34.56 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18s_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_160k_ade20k/fcn_hr18s_512x512_160k_ade20k_20210829_174739-f1e7c2e7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_160k_ade20k/fcn_hr18s_512x512_160k_ade20k_20210829_174739.log.json) |
-| FCN    | HRNetV2p-W18       | 512x512   |  160000 | -        | -              | V100   | 36.79 |         38.58 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_160k_ade20k/fcn_hr18_512x512_160k_ade20k_20200614_214426-ca961836.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_160k_ade20k/fcn_hr18_512x512_160k_ade20k_20200614_214426.log.json)     |
-| FCN    | HRNetV2p-W48       | 512x512   |  160000 | -        | -              | V100   | 42.02 |         43.86 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_160k_ade20k/fcn_hr48_512x512_160k_ade20k_20200614_214407-a52fc02c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_160k_ade20k/fcn_hr48_512x512_160k_ade20k_20200614_214407.log.json)     |
-
-### Pascal VOC 2012 + Aug
-
-| Method | Backbone           | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                | download                                                                                                                                                                                                                                                                                                               |
-| ------ | ------------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | --------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| FCN    | HRNetV2p-W18-Small | 512x512   |   20000 | 1.8      | 43.36          | V100   |  65.5 |         68.89 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18s_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_20k_voc12aug/fcn_hr18s_512x512_20k_voc12aug_20210829_174910-0aceadb4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_20k_voc12aug/fcn_hr18s_512x512_20k_voc12aug_20210829_174910.log.json) |
-| FCN    | HRNetV2p-W18       | 512x512   |   20000 | 2.9      | 23.48          | V100   | 72.30 |         74.71 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_20k_voc12aug/fcn_hr18_512x512_20k_voc12aug_20200617_224503-488d45f7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_20k_voc12aug/fcn_hr18_512x512_20k_voc12aug_20200617_224503.log.json)     |
-| FCN    | HRNetV2p-W48       | 512x512   |   20000 | 6.2      | 22.05          | V100   | 75.87 |         78.58 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_20k_voc12aug/fcn_hr48_512x512_20k_voc12aug_20200617_224419-89de05cd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_20k_voc12aug/fcn_hr48_512x512_20k_voc12aug_20200617_224419.log.json)     |
-| FCN    | HRNetV2p-W18-Small | 512x512   |   40000 | -        | -              | V100   | 66.61 |         70.00 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18s_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_40k_voc12aug/fcn_hr18s_512x512_40k_voc12aug_20200614_000648-4f8d6e7f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_40k_voc12aug/fcn_hr18s_512x512_40k_voc12aug_20200614_000648.log.json) |
-| FCN    | HRNetV2p-W18       | 512x512   |   40000 | -        | -              | V100   | 72.90 |         75.59 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_40k_voc12aug/fcn_hr18_512x512_40k_voc12aug_20200613_224401-1b4b76cd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_40k_voc12aug/fcn_hr18_512x512_40k_voc12aug_20200613_224401.log.json)     |
-| FCN    | HRNetV2p-W48       | 512x512   |   40000 | -        | -              | V100   | 76.24 |         78.49 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_40k_voc12aug/fcn_hr48_512x512_40k_voc12aug_20200613_222111-1b0f18bc.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_40k_voc12aug/fcn_hr48_512x512_40k_voc12aug_20200613_222111.log.json)     |
-
-### Pascal Context
-
-| Method | Backbone     | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                     | download                                                                                                                                                                                                                                                                                                                                   |
-| ------ | ------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| FCN    | HRNetV2p-W48 | 480x480   |   40000 | 6.1      | 8.86           | V100   | 45.14 |         47.42 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_40k_pascal_context/fcn_hr48_480x480_40k_pascal_context_20200911_164852-667d00b0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_40k_pascal_context/fcn_hr48_480x480_40k_pascal_context-20200911_164852.log.json) |
-| FCN    | HRNetV2p-W48 | 480x480   |   80000 | -        | -              | V100   | 45.84 |         47.84 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_80k_pascal_context/fcn_hr48_480x480_80k_pascal_context_20200911_155322-847a6711.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_80k_pascal_context/fcn_hr48_480x480_80k_pascal_context-20200911_155322.log.json) |
-
-### Pascal Context 59
-
-| Method | Backbone     | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                        | download                                                                                                                                                                                                                                                                                                                                               |
-| ------ | ------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ----------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| FCN    | HRNetV2p-W48 | 480x480   |   40000 | -        | -              | V100   | 50.33 |         52.83 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-59-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_40k_pascal_context_59/fcn_hr48_480x480_40k_pascal_context_59_20210410_122738-b808b8b2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_40k_pascal_context_59/fcn_hr48_480x480_40k_pascal_context_59-20210410_122738.log.json) |
-| FCN    | HRNetV2p-W48 | 480x480   |   80000 | -        | -              | V100   | 51.12 |         53.56 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-59-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_80k_pascal_context_59/fcn_hr48_480x480_80k_pascal_context_59_20210411_003240-3ae7081e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_80k_pascal_context_59/fcn_hr48_480x480_80k_pascal_context_59-20210411_003240.log.json) |
-
-### LoveDA
-
-| Method | Backbone           | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                               | download                                                                                                                                                                                                                                                                                                       |
-| ------ | ------------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| FCN    | HRNetV2p-W18-Small | 512x512   |   80000 | 1.59     | 24.87          | V100   | 49.28 |         49.42 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18s_4xb4-80k_loveda-512x512.pyy) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_loveda/fcn_hr18s_512x512_80k_loveda_20211210_203228-60a86a7a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_loveda/fcn_hr18s_512x512_80k_loveda_20211210_203228.log.json) |
-| FCN    | HRNetV2p-W18       | 512x512   |   80000 | 2.76     | 12.92          | V100   | 50.81 |         50.95 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18_4xb4-80k_loveda-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_loveda/fcn_hr18_512x512_80k_loveda_20211210_203952-93d9c3b3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_loveda/fcn_hr18_512x512_80k_loveda_20211210_203952.log.json)     |
-| FCN    | HRNetV2p-W48       | 512x512   |   80000 | 6.20     | 9.61           | V100   | 51.42 |         51.64 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-80k_loveda-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_loveda/fcn_hr48_512x512_80k_loveda_20211211_044756-67072f55.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_loveda/fcn_hr48_512x512_80k_loveda_20211211_044756.log.json)     |
-
-### Potsdam
-
-| Method | Backbone           | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                               | download                                                                                                                                                                                                                                                                                                           |
-| ------ | ------------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| FCN    | HRNetV2p-W18-Small | 512x512   |   80000 | 1.58     | 36.00          | V100   | 77.64 |          78.8 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18s_4xb4-80k_potsdam-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_potsdam/fcn_hr18s_512x512_80k_potsdam_20211218_205517-ba32af63.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_potsdam/fcn_hr18s_512x512_80k_potsdam_20211218_205517.log.json) |
-| FCN    | HRNetV2p-W18       | 512x512   |   80000 | 2.76     | 19.25          | V100   | 78.26 |         79.24 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18_4xb4-80k_potsdam-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_potsdam/fcn_hr18_512x512_80k_potsdam_20211218_205517-5d0387ad.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_potsdam/fcn_hr18_512x512_80k_potsdam_20211218_205517.log.json)     |
-| FCN    | HRNetV2p-W48       | 512x512   |   80000 | 6.20     | 16.42          | V100   | 78.39 |         79.34 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-80k_potsdam-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_potsdam/fcn_hr48_512x512_80k_potsdam_20211219_020601-97434c78.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_potsdam/fcn_hr48_512x512_80k_potsdam_20211219_020601.log.json)     |
-
-### Vaihingen
-
-| Method | Backbone           | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                 | download                                                                                                                                                                                                                                                                                                                                   |
-| ------ | ------------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ---------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| FCN    | HRNetV2p-W18-Small | 512x512   |   80000 | 1.58     | 38.11          | V100   | 71.81 |          73.1 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18s_4xb4-80k_vaihingen-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_4x4_512x512_80k_vaihingen/fcn_hr18s_4x4_512x512_80k_vaihingen_20211231_230909-b23aae02.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_4x4_512x512_80k_vaihingen/fcn_hr18s_4x4_512x512_80k_vaihingen_20211231_230909.log.json) |
-| FCN    | HRNetV2p-W18       | 512x512   |   80000 | 2.76     | 19.55          | V100   | 72.57 |         74.09 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18_4xb4-80k_vaihingen-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_4x4_512x512_80k_vaihingen/fcn_hr18_4x4_512x512_80k_vaihingen_20211231_231216-2ec3ae8a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_4x4_512x512_80k_vaihingen/fcn_hr18_4x4_512x512_80k_vaihingen_20211231_231216.log.json)     |
-| FCN    | HRNetV2p-W48       | 512x512   |   80000 | 6.20     | 17.25          | V100   | 72.50 |         73.52 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-80k_vaihingen-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_4x4_512x512_80k_vaihingen/fcn_hr48_4x4_512x512_80k_vaihingen_20211231_231244-7133cb22.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_4x4_512x512_80k_vaihingen/fcn_hr48_4x4_512x512_80k_vaihingen_20211231_231244.log.json)     |
-
-### iSAID
-
-| Method | Backbone           | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                             | download                                                                                                                                                                                                                                                                                                                   |
-| ------ | ------------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| FCN    | HRNetV2p-W18-Small | 896x896   |   80000 | 4.95     | 13.84          | V100   | 62.30 |         62.97 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18s_4xb4-80k_isaid-896x896.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_4x4_896x896_80k_isaid/fcn_hr18s_4x4_896x896_80k_isaid_20220118_001603-3cc0769b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_4x4_896x896_80k_isaid/fcn_hr18s_4x4_896x896_80k_isaid_20220118_001603.log.json) |
-| FCN    | HRNetV2p-W18       | 896x896   |   80000 | 8.30     | 7.71           | V100   | 65.06 |         65.60 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr18_4xb4-80k_isaid-896x896.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_4x4_896x896_80k_isaid/fcn_hr18_4x4_896x896_80k_isaid_20220110_182230-49bf752e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_4x4_896x896_80k_isaid/fcn_hr18_4x4_896x896_80k_isaid_20220110_182230.log.json)     |
-| FCN    | HRNetV2p-W48       | 896x896   |   80000 | 16.89    | 7.34           | V100   | 67.80 |         68.53 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet/fcn_hr48_4xb4-80k_isaid-896x896.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_4x4_896x896_80k_isaid/fcn_hr48_4x4_896x896_80k_isaid_20220114_174643-547fc420.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_4x4_896x896_80k_isaid/fcn_hr48_4x4_896x896_80k_isaid_20220114_174643.log.json)     |
-
-Note:
-
-- `896x896` is the Crop Size of iSAID dataset, which is followed by the implementation of [PointFlow: Flowing Semantics Through Points for Aerial Image Segmentation](https://arxiv.org/pdf/2103.06564.pdf)
-
-## Citation
-
-```bibtext
-@inproceedings{SunXLW19,
-  title={Deep High-Resolution Representation Learning for Human Pose Estimation},
-  author={Ke Sun and Bin Xiao and Dong Liu and Jingdong Wang},
-  booktitle={CVPR},
-  year={2019}
-}
-```
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb2-160k_cityscapes-512x1024.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb2-160k_cityscapes-512x1024.py
deleted file mode 100644
index 0b37463..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18_4xb2-160k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_hr18.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 598b938..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_hr18.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index eb7da49..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_hr18.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index c4f732c..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_hr18.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor, decode_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index 107df6b..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_hr18.py', '../_base_/datasets/pascal_voc12_aug.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_20k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor, decode_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_pascal-context-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_pascal-context-480x480.py
deleted file mode 100644
index f744bae..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_pascal-context-480x480.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_hr18.py', '../_base_/datasets/pascal_context.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (480, 480)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=60),
-    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_pascal-context-59-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_pascal-context-59-480x480.py
deleted file mode 100644
index 0daaa35..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_pascal-context-59-480x480.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_hr18.py', '../_base_/datasets/pascal_context_59.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (480, 480)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=59),
-    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index 2aa16b1..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_hr18.py', '../_base_/datasets/pascal_voc12_aug.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor, decode_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 029b7d0..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_hr18.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor, decode_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_isaid-896x896.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_isaid-896x896.py
deleted file mode 100644
index 33a6ac7..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_isaid-896x896.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_hr18.py', '../_base_/datasets/isaid.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (896, 896)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor, decode_head=dict(num_classes=16))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_loveda-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_loveda-512x512.py
deleted file mode 100644
index 1a918b2..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_loveda-512x512.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_hr18.py', '../_base_/datasets/loveda.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor, decode_head=dict(num_classes=7))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_pascal-context-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_pascal-context-480x480.py
deleted file mode 100644
index 4f37e8a..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_pascal-context-480x480.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_hr18.py', '../_base_/datasets/pascal_context.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (480, 480)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=60),
-    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_pascal-context-59-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_pascal-context-59-480x480.py
deleted file mode 100644
index 2c35cb9..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_pascal-context-59-480x480.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_hr18.py', '../_base_/datasets/pascal_context_59.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (480, 480)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=59),
-    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_potsdam-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_potsdam-512x512.py
deleted file mode 100644
index 181c03d..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_potsdam-512x512.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_hr18.py', '../_base_/datasets/potsdam.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor, decode_head=dict(num_classes=6))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_vaihingen-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_vaihingen-512x512.py
deleted file mode 100644
index 6303bb6..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18_4xb4-80k_vaihingen-512x512.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_hr18.py', '../_base_/datasets/vaihingen.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor, decode_head=dict(num_classes=6))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-160k_cityscapes-512x1024.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-160k_cityscapes-512x1024.py
deleted file mode 100644
index 6ca631c..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-160k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './fcn_hr18_4xb2-160k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w18_small',
-    backbone=dict(
-        extra=dict(
-            stage1=dict(num_blocks=(2, )),
-            stage2=dict(num_blocks=(2, 2)),
-            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
-            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index ba7e9c6..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './fcn_hr18_4xb2-40k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w18_small',
-    backbone=dict(
-        extra=dict(
-            stage1=dict(num_blocks=(2, )),
-            stage2=dict(num_blocks=(2, 2)),
-            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
-            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 26ab621..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './fcn_hr18_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w18_small',
-    backbone=dict(
-        extra=dict(
-            stage1=dict(num_blocks=(2, )),
-            stage2=dict(num_blocks=(2, 2)),
-            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
-            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 29cbd10..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './fcn_hr18_4xb4-160k_ade20k-512x512.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w18_small',
-    backbone=dict(
-        extra=dict(
-            stage1=dict(num_blocks=(2, )),
-            stage2=dict(num_blocks=(2, 2)),
-            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
-            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index 9dd1933..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './fcn_hr18_4xb4-20k_voc12aug-512x512.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w18_small',
-    backbone=dict(
-        extra=dict(
-            stage1=dict(num_blocks=(2, )),
-            stage2=dict(num_blocks=(2, 2)),
-            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
-            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_pascal-context-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_pascal-context-480x480.py
deleted file mode 100644
index 5f88f53..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_pascal-context-480x480.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './fcn_hr18_4xb4-40k_pascal-context-480x480.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w18_small',
-    backbone=dict(
-        extra=dict(
-            stage1=dict(num_blocks=(2, )),
-            stage2=dict(num_blocks=(2, 2)),
-            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
-            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_pascal-context-59-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_pascal-context-59-480x480.py
deleted file mode 100644
index b616fad..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_pascal-context-59-480x480.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './fcn_hr18_4xb4-40k_pascal-context-59-480x480.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w18_small',
-    backbone=dict(
-        extra=dict(
-            stage1=dict(num_blocks=(2, )),
-            stage2=dict(num_blocks=(2, 2)),
-            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
-            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index b10b282..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './fcn_hr18_4xb4-40k_voc12aug-512x512.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w18_small',
-    backbone=dict(
-        extra=dict(
-            stage1=dict(num_blocks=(2, )),
-            stage2=dict(num_blocks=(2, 2)),
-            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
-            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index f9f4936..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './fcn_hr18_4xb4-80k_ade20k-512x512.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w18_small',
-    backbone=dict(
-        extra=dict(
-            stage1=dict(num_blocks=(2, )),
-            stage2=dict(num_blocks=(2, 2)),
-            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
-            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_isaid-896x896.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_isaid-896x896.py
deleted file mode 100644
index ab2d241..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_isaid-896x896.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './fcn_hr18_4xb4-80k_isaid-896x896.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w18_small',
-    backbone=dict(
-        extra=dict(
-            stage1=dict(num_blocks=(2, )),
-            stage2=dict(num_blocks=(2, 2)),
-            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
-            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_loveda-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_loveda-512x512.py
deleted file mode 100644
index dd17076..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_loveda-512x512.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './fcn_hr18_4xb4-80k_loveda-512x512.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w18_small',
-    backbone=dict(
-        extra=dict(
-            stage1=dict(num_blocks=(2, )),
-            stage2=dict(num_blocks=(2, 2)),
-            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
-            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_pascal-context-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_pascal-context-480x480.py
deleted file mode 100644
index b7b5233..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_pascal-context-480x480.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './fcn_hr18_4xb4-80k_pascal-context-480x480.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w18_small',
-    backbone=dict(
-        extra=dict(
-            stage1=dict(num_blocks=(2, )),
-            stage2=dict(num_blocks=(2, 2)),
-            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
-            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_pascal-context-59-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_pascal-context-59-480x480.py
deleted file mode 100644
index ccf1040..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_pascal-context-59-480x480.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './fcn_hr18_4xb4-80k_pascal-context-59-480x480.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w18_small',
-    backbone=dict(
-        extra=dict(
-            stage1=dict(num_blocks=(2, )),
-            stage2=dict(num_blocks=(2, 2)),
-            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
-            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_potsdam-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_potsdam-512x512.py
deleted file mode 100644
index 3a5726f..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_potsdam-512x512.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './fcn_hr18_4xb4-80k_potsdam-512x512.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w18_small',
-    backbone=dict(
-        extra=dict(
-            stage1=dict(num_blocks=(2, )),
-            stage2=dict(num_blocks=(2, 2)),
-            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
-            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_vaihingen-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_vaihingen-512x512.py
deleted file mode 100644
index 720c173..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr18s_4xb4-80k_vaihingen-512x512.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './fcn_hr18_4xb4-80k_vaihingen-512x512.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w18_small',
-    backbone=dict(
-        extra=dict(
-            stage1=dict(num_blocks=(2, )),
-            stage2=dict(num_blocks=(2, 2)),
-            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
-            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb2-160k_cityscapes-512x1024.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb2-160k_cityscapes-512x1024.py
deleted file mode 100644
index 4aa5d94..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr48_4xb2-160k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = './fcn_hr18_4xb2-160k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w48',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(48, 96)),
-            stage3=dict(num_channels=(48, 96, 192)),
-            stage4=dict(num_channels=(48, 96, 192, 384)))),
-    decode_head=dict(
-        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 7cb7952..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr48_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = './fcn_hr18_4xb2-40k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w48',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(48, 96)),
-            stage3=dict(num_channels=(48, 96, 192)),
-            stage4=dict(num_channels=(48, 96, 192, 384)))),
-    decode_head=dict(
-        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 3e2ce03..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr48_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = './fcn_hr18_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w48',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(48, 96)),
-            stage3=dict(num_channels=(48, 96, 192)),
-            stage4=dict(num_channels=(48, 96, 192, 384)))),
-    decode_head=dict(
-        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 89b1f04..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = './fcn_hr18_4xb4-160k_ade20k-512x512.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w48',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(48, 96)),
-            stage3=dict(num_channels=(48, 96, 192)),
-            stage4=dict(num_channels=(48, 96, 192, 384)))),
-    decode_head=dict(
-        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index 7ca38a9..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = './fcn_hr18_4xb4-20k_voc12aug-512x512.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w48',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(48, 96)),
-            stage3=dict(num_channels=(48, 96, 192)),
-            stage4=dict(num_channels=(48, 96, 192, 384)))),
-    decode_head=dict(
-        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-480x480.py
deleted file mode 100644
index 379be1d..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-480x480.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = './fcn_hr18_4xb4-40k_pascal-context-480x480.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w48',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(48, 96)),
-            stage3=dict(num_channels=(48, 96, 192)),
-            stage4=dict(num_channels=(48, 96, 192, 384)))),
-    decode_head=dict(
-        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-59-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-59-480x480.py
deleted file mode 100644
index 12730dd..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-59-480x480.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = './fcn_hr18_4xb4-40k_pascal-context-59-480x480.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w48',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(48, 96)),
-            stage3=dict(num_channels=(48, 96, 192)),
-            stage4=dict(num_channels=(48, 96, 192, 384)))),
-    decode_head=dict(
-        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index 3e1b920..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = './fcn_hr18_4xb4-40k_voc12aug-512x512.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w48',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(48, 96)),
-            stage3=dict(num_channels=(48, 96, 192)),
-            stage4=dict(num_channels=(48, 96, 192, 384)))),
-    decode_head=dict(
-        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 14fd663..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = './fcn_hr18_4xb4-80k_ade20k-512x512.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w48',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(48, 96)),
-            stage3=dict(num_channels=(48, 96, 192)),
-            stage4=dict(num_channels=(48, 96, 192, 384)))),
-    decode_head=dict(
-        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_isaid-896x896.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_isaid-896x896.py
deleted file mode 100644
index 81815ef..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_isaid-896x896.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = './fcn_hr18_4xb4-80k_isaid-896x896.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w48',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(48, 96)),
-            stage3=dict(num_channels=(48, 96, 192)),
-            stage4=dict(num_channels=(48, 96, 192, 384)))),
-    decode_head=dict(
-        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_loveda-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_loveda-512x512.py
deleted file mode 100644
index 34d23af..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_loveda-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = './fcn_hr18_4xb4-80k_loveda-512x512.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w48',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(48, 96)),
-            stage3=dict(num_channels=(48, 96, 192)),
-            stage4=dict(num_channels=(48, 96, 192, 384)))),
-    decode_head=dict(
-        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-480x480.py
deleted file mode 100644
index 4d193d9..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-480x480.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = './fcn_hr18_4xb4-80k_pascal-context-480x480.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w48',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(48, 96)),
-            stage3=dict(num_channels=(48, 96, 192)),
-            stage4=dict(num_channels=(48, 96, 192, 384)))),
-    decode_head=dict(
-        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-59-480x480.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-59-480x480.py
deleted file mode 100644
index d8b4c4a..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-59-480x480.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = './fcn_hr18_4xb4-80k_pascal-context-59-480x480.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w48',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(48, 96)),
-            stage3=dict(num_channels=(48, 96, 192)),
-            stage4=dict(num_channels=(48, 96, 192, 384)))),
-    decode_head=dict(
-        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_potsdam-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_potsdam-512x512.py
deleted file mode 100644
index 58a6500..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_potsdam-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = './fcn_hr18_4xb4-80k_potsdam-512x512.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w48',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(48, 96)),
-            stage3=dict(num_channels=(48, 96, 192)),
-            stage4=dict(num_channels=(48, 96, 192, 384)))),
-    decode_head=dict(
-        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_vaihingen-512x512.py b/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_vaihingen-512x512.py
deleted file mode 100644
index db91ed8..0000000
--- a/mmsegmentation/configs/hrnet/fcn_hr48_4xb4-80k_vaihingen-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = './fcn_hr18_4xb4-80k_vaihingen-512x512.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w48',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(48, 96)),
-            stage3=dict(num_channels=(48, 96, 192)),
-            stage4=dict(num_channels=(48, 96, 192, 384)))),
-    decode_head=dict(
-        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))
diff --git a/mmsegmentation/configs/hrnet/metafile.yaml b/mmsegmentation/configs/hrnet/metafile.yaml
deleted file mode 100644
index 11c3016..0000000
--- a/mmsegmentation/configs/hrnet/metafile.yaml
+++ /dev/null
@@ -1,874 +0,0 @@
-Models:
-- Name: fcn_hr18s_4xb2-40k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 73.86
-      mIoU(ms+flip): 75.91
-  Config: configs/hrnet/fcn_hr18s_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - HRNetV2p-W18-Small
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.7
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_40k_cityscapes/fcn_hr18s_512x1024_40k_cityscapes_20200601_014216-93db27d0.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_40k_cityscapes/fcn_hr18s_512x1024_40k_cityscapes_20200601_014216.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr18_4xb2-40k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.19
-      mIoU(ms+flip): 78.92
-  Config: configs/hrnet/fcn_hr18_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - HRNetV2p-W18
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 2.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_40k_cityscapes/fcn_hr18_512x1024_40k_cityscapes_20200601_014216-f196fb4e.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_40k_cityscapes/fcn_hr18_512x1024_40k_cityscapes_20200601_014216.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr48_4xb2-40k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.48
-      mIoU(ms+flip): 79.69
-  Config: configs/hrnet/fcn_hr48_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - HRNetV2p-W48
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_40k_cityscapes/fcn_hr48_512x1024_40k_cityscapes_20200601_014240-a989b146.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_40k_cityscapes/fcn_hr48_512x1024_40k_cityscapes_20200601_014240.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr18s_4xb2-80k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 75.31
-      mIoU(ms+flip): 77.48
-  Config: configs/hrnet/fcn_hr18s_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - HRNetV2p-W18-Small
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_80k_cityscapes/fcn_hr18s_512x1024_80k_cityscapes_20200601_202700-1462b75d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_80k_cityscapes/fcn_hr18s_512x1024_80k_cityscapes_20200601_202700.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr18_4xb2-80k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.65
-      mIoU(ms+flip): 80.35
-  Config: configs/hrnet/fcn_hr18_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - HRNetV2p-W18
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_80k_cityscapes/fcn_hr18_512x1024_80k_cityscapes_20200601_223255-4e7b345e.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_80k_cityscapes/fcn_hr18_512x1024_80k_cityscapes_20200601_223255.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr48_4xb2-80k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.93
-      mIoU(ms+flip): 80.72
-  Config: configs/hrnet/fcn_hr48_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - HRNetV2p-W48
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_80k_cityscapes/fcn_hr48_512x1024_80k_cityscapes_20200601_202606-58ea95d6.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_80k_cityscapes/fcn_hr48_512x1024_80k_cityscapes_20200601_202606.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr18s_4xb2-160k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.31
-      mIoU(ms+flip): 78.31
-  Config: configs/hrnet/fcn_hr18s_4xb2-160k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - HRNetV2p-W18-Small
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_160k_cityscapes/fcn_hr18s_512x1024_160k_cityscapes_20200602_190901-4a0797ea.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x1024_160k_cityscapes/fcn_hr18s_512x1024_160k_cityscapes_20200602_190901.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr18_4xb2-160k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.8
-      mIoU(ms+flip): 80.74
-  Config: configs/hrnet/fcn_hr18_4xb2-160k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - HRNetV2p-W18
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_160k_cityscapes/fcn_hr18_512x1024_160k_cityscapes_20200602_190822-221e4a4f.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x1024_160k_cityscapes/fcn_hr18_512x1024_160k_cityscapes_20200602_190822.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr48_4xb2-160k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 80.65
-      mIoU(ms+flip): 81.92
-  Config: configs/hrnet/fcn_hr48_4xb2-160k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - HRNetV2p-W48
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_160k_cityscapes/fcn_hr48_512x1024_160k_cityscapes_20200602_190946-59b7973e.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x1024_160k_cityscapes/fcn_hr48_512x1024_160k_cityscapes_20200602_190946.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr18s_4xb4-80k_ade20k-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 31.38
-      mIoU(ms+flip): 32.45
-  Config: configs/hrnet/fcn_hr18s_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18-Small
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 3.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_ade20k/fcn_hr18s_512x512_80k_ade20k_20200614_144345-77fc814a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_ade20k/fcn_hr18s_512x512_80k_ade20k_20200614_144345.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr18_4xb4-80k_ade20k-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 36.27
-      mIoU(ms+flip): 37.28
-  Config: configs/hrnet/fcn_hr18_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 4.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_ade20k/fcn_hr18_512x512_80k_ade20k_20210827_114910-6c9382c0.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_ade20k/fcn_hr18_512x512_80k_ade20k_20210827_114910.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr48_4xb4-80k_ade20k-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 41.9
-      mIoU(ms+flip): 43.27
-  Config: configs/hrnet/fcn_hr48_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W48
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_ade20k/fcn_hr48_512x512_80k_ade20k_20200614_193946-7ba5258d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_ade20k/fcn_hr48_512x512_80k_ade20k_20200614_193946.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr18s_4xb4-160k_ade20k-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 33.07
-      mIoU(ms+flip): 34.56
-  Config: configs/hrnet/fcn_hr18s_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18-Small
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_160k_ade20k/fcn_hr18s_512x512_160k_ade20k_20210829_174739-f1e7c2e7.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_160k_ade20k/fcn_hr18s_512x512_160k_ade20k_20210829_174739.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr18_4xb4-160k_ade20k-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 36.79
-      mIoU(ms+flip): 38.58
-  Config: configs/hrnet/fcn_hr18_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_160k_ade20k/fcn_hr18_512x512_160k_ade20k_20200614_214426-ca961836.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_160k_ade20k/fcn_hr18_512x512_160k_ade20k_20200614_214426.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr48_4xb4-160k_ade20k-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.02
-      mIoU(ms+flip): 43.86
-  Config: configs/hrnet/fcn_hr48_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W48
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_160k_ade20k/fcn_hr48_512x512_160k_ade20k_20200614_214407-a52fc02c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_160k_ade20k/fcn_hr48_512x512_160k_ade20k_20200614_214407.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr18s_4xb4-20k_voc12aug-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 65.5
-      mIoU(ms+flip): 68.89
-  Config: configs/hrnet/fcn_hr18s_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18-Small
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_20k_voc12aug/fcn_hr18s_512x512_20k_voc12aug_20210829_174910-0aceadb4.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_20k_voc12aug/fcn_hr18s_512x512_20k_voc12aug_20210829_174910.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr18_4xb4-20k_voc12aug-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 72.3
-      mIoU(ms+flip): 74.71
-  Config: configs/hrnet/fcn_hr18_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 2.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_20k_voc12aug/fcn_hr18_512x512_20k_voc12aug_20200617_224503-488d45f7.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_20k_voc12aug/fcn_hr18_512x512_20k_voc12aug_20200617_224503.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr48_4xb4-20k_voc12aug-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 75.87
-      mIoU(ms+flip): 78.58
-  Config: configs/hrnet/fcn_hr48_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W48
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_20k_voc12aug/fcn_hr48_512x512_20k_voc12aug_20200617_224419-89de05cd.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_20k_voc12aug/fcn_hr48_512x512_20k_voc12aug_20200617_224419.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr18s_4xb4-40k_voc12aug-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 66.61
-      mIoU(ms+flip): 70.0
-  Config: configs/hrnet/fcn_hr18s_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18-Small
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_40k_voc12aug/fcn_hr18s_512x512_40k_voc12aug_20200614_000648-4f8d6e7f.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_40k_voc12aug/fcn_hr18s_512x512_40k_voc12aug_20200614_000648.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr18_4xb4-40k_voc12aug-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 72.9
-      mIoU(ms+flip): 75.59
-  Config: configs/hrnet/fcn_hr18_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_40k_voc12aug/fcn_hr18_512x512_40k_voc12aug_20200613_224401-1b4b76cd.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_40k_voc12aug/fcn_hr18_512x512_40k_voc12aug_20200613_224401.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr48_4xb4-40k_voc12aug-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 76.24
-      mIoU(ms+flip): 78.49
-  Config: configs/hrnet/fcn_hr48_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W48
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_40k_voc12aug/fcn_hr48_512x512_40k_voc12aug_20200613_222111-1b0f18bc.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_40k_voc12aug/fcn_hr48_512x512_40k_voc12aug_20200613_222111.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr48_4xb4-40k_pascal-context-480x480
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal Context
-    Metrics:
-      mIoU: 45.14
-      mIoU(ms+flip): 47.42
-  Config: configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-480x480.py
-  Metadata:
-    Training Data: Pascal Context
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W48
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_40k_pascal_context/fcn_hr48_480x480_40k_pascal_context_20200911_164852-667d00b0.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_40k_pascal_context/fcn_hr48_480x480_40k_pascal_context-20200911_164852.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr48_4xb4-80k_pascal-context-480x480
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal Context
-    Metrics:
-      mIoU: 45.84
-      mIoU(ms+flip): 47.84
-  Config: configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-480x480.py
-  Metadata:
-    Training Data: Pascal Context
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W48
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_80k_pascal_context/fcn_hr48_480x480_80k_pascal_context_20200911_155322-847a6711.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_80k_pascal_context/fcn_hr48_480x480_80k_pascal_context-20200911_155322.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr48_4xb4-40k_pascal-context-59-480x480
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal Context 59
-    Metrics:
-      mIoU: 50.33
-      mIoU(ms+flip): 52.83
-  Config: configs/hrnet/fcn_hr48_4xb4-40k_pascal-context-59-480x480.py
-  Metadata:
-    Training Data: Pascal Context 59
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W48
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_40k_pascal_context_59/fcn_hr48_480x480_40k_pascal_context_59_20210410_122738-b808b8b2.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_40k_pascal_context_59/fcn_hr48_480x480_40k_pascal_context_59-20210410_122738.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr48_4xb4-80k_pascal-context-59-480x480
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal Context 59
-    Metrics:
-      mIoU: 51.12
-      mIoU(ms+flip): 53.56
-  Config: configs/hrnet/fcn_hr48_4xb4-80k_pascal-context-59-480x480.py
-  Metadata:
-    Training Data: Pascal Context 59
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W48
-    - FCN
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_80k_pascal_context_59/fcn_hr48_480x480_80k_pascal_context_59_20210411_003240-3ae7081e.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_480x480_80k_pascal_context_59/fcn_hr48_480x480_80k_pascal_context_59-20210411_003240.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr18s_4xb4-80k_loveda-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: LoveDA
-    Metrics:
-      mIoU: 49.28
-      mIoU(ms+flip): 49.42
-  Config: configs/hrnet/fcn_hr18s_4xb4-80k_loveda-512x512.py
-  Metadata:
-    Training Data: LoveDA
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18-Small
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.59
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_loveda/fcn_hr18s_512x512_80k_loveda_20211210_203228-60a86a7a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_loveda/fcn_hr18s_512x512_80k_loveda_20211210_203228.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr18_4xb4-80k_loveda-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: LoveDA
-    Metrics:
-      mIoU: 50.81
-      mIoU(ms+flip): 50.95
-  Config: configs/hrnet/fcn_hr18_4xb4-80k_loveda-512x512.py
-  Metadata:
-    Training Data: LoveDA
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 2.76
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_loveda/fcn_hr18_512x512_80k_loveda_20211210_203952-93d9c3b3.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_loveda/fcn_hr18_512x512_80k_loveda_20211210_203952.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr48_4xb4-80k_loveda-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: LoveDA
-    Metrics:
-      mIoU: 51.42
-      mIoU(ms+flip): 51.64
-  Config: configs/hrnet/fcn_hr48_4xb4-80k_loveda-512x512.py
-  Metadata:
-    Training Data: LoveDA
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W48
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_loveda/fcn_hr48_512x512_80k_loveda_20211211_044756-67072f55.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_loveda/fcn_hr48_512x512_80k_loveda_20211211_044756.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr18s_4xb4-80k_potsdam-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Potsdam
-    Metrics:
-      mIoU: 77.64
-      mIoU(ms+flip): 78.8
-  Config: configs/hrnet/fcn_hr18s_4xb4-80k_potsdam-512x512.py
-  Metadata:
-    Training Data: Potsdam
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18-Small
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.58
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_potsdam/fcn_hr18s_512x512_80k_potsdam_20211218_205517-ba32af63.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_512x512_80k_potsdam/fcn_hr18s_512x512_80k_potsdam_20211218_205517.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr18_4xb4-80k_potsdam-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Potsdam
-    Metrics:
-      mIoU: 78.26
-      mIoU(ms+flip): 79.24
-  Config: configs/hrnet/fcn_hr18_4xb4-80k_potsdam-512x512.py
-  Metadata:
-    Training Data: Potsdam
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 2.76
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_potsdam/fcn_hr18_512x512_80k_potsdam_20211218_205517-5d0387ad.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_512x512_80k_potsdam/fcn_hr18_512x512_80k_potsdam_20211218_205517.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr48_4xb4-80k_potsdam-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Potsdam
-    Metrics:
-      mIoU: 78.39
-      mIoU(ms+flip): 79.34
-  Config: configs/hrnet/fcn_hr48_4xb4-80k_potsdam-512x512.py
-  Metadata:
-    Training Data: Potsdam
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W48
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_potsdam/fcn_hr48_512x512_80k_potsdam_20211219_020601-97434c78.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_512x512_80k_potsdam/fcn_hr48_512x512_80k_potsdam_20211219_020601.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr18s_4xb4-80k_vaihingen-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Vaihingen
-    Metrics:
-      mIoU: 71.81
-      mIoU(ms+flip): 73.1
-  Config: configs/hrnet/fcn_hr18s_4xb4-80k_vaihingen-512x512.py
-  Metadata:
-    Training Data: Vaihingen
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18-Small
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.58
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_4x4_512x512_80k_vaihingen/fcn_hr18s_4x4_512x512_80k_vaihingen_20211231_230909-b23aae02.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_4x4_512x512_80k_vaihingen/fcn_hr18s_4x4_512x512_80k_vaihingen_20211231_230909.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr18_4xb4-80k_vaihingen-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Vaihingen
-    Metrics:
-      mIoU: 72.57
-      mIoU(ms+flip): 74.09
-  Config: configs/hrnet/fcn_hr18_4xb4-80k_vaihingen-512x512.py
-  Metadata:
-    Training Data: Vaihingen
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 2.76
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_4x4_512x512_80k_vaihingen/fcn_hr18_4x4_512x512_80k_vaihingen_20211231_231216-2ec3ae8a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_4x4_512x512_80k_vaihingen/fcn_hr18_4x4_512x512_80k_vaihingen_20211231_231216.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr48_4xb4-80k_vaihingen-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Vaihingen
-    Metrics:
-      mIoU: 72.5
-      mIoU(ms+flip): 73.52
-  Config: configs/hrnet/fcn_hr48_4xb4-80k_vaihingen-512x512.py
-  Metadata:
-    Training Data: Vaihingen
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W48
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_4x4_512x512_80k_vaihingen/fcn_hr48_4x4_512x512_80k_vaihingen_20211231_231244-7133cb22.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_4x4_512x512_80k_vaihingen/fcn_hr48_4x4_512x512_80k_vaihingen_20211231_231244.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr18s_4xb4-80k_isaid-896x896
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: iSAID
-    Metrics:
-      mIoU: 62.3
-      mIoU(ms+flip): 62.97
-  Config: configs/hrnet/fcn_hr18s_4xb4-80k_isaid-896x896.py
-  Metadata:
-    Training Data: iSAID
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18-Small
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 4.95
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_4x4_896x896_80k_isaid/fcn_hr18s_4x4_896x896_80k_isaid_20220118_001603-3cc0769b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18s_4x4_896x896_80k_isaid/fcn_hr18s_4x4_896x896_80k_isaid_20220118_001603.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr18_4xb4-80k_isaid-896x896
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: iSAID
-    Metrics:
-      mIoU: 65.06
-      mIoU(ms+flip): 65.6
-  Config: configs/hrnet/fcn_hr18_4xb4-80k_isaid-896x896.py
-  Metadata:
-    Training Data: iSAID
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.3
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_4x4_896x896_80k_isaid/fcn_hr18_4x4_896x896_80k_isaid_20220110_182230-49bf752e.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr18_4x4_896x896_80k_isaid/fcn_hr18_4x4_896x896_80k_isaid_20220110_182230.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
-- Name: fcn_hr48_4xb4-80k_isaid-896x896
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: iSAID
-    Metrics:
-      mIoU: 67.8
-      mIoU(ms+flip): 68.53
-  Config: configs/hrnet/fcn_hr48_4xb4-80k_isaid-896x896.py
-  Metadata:
-    Training Data: iSAID
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W48
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 16.89
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_4x4_896x896_80k_isaid/fcn_hr48_4x4_896x896_80k_isaid_20220114_174643-547fc420.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/hrnet/fcn_hr48_4x4_896x896_80k_isaid/fcn_hr48_4x4_896x896_80k_isaid_20220114_174643.log.json
-  Paper:
-    Title: Deep High-Resolution Representation Learning for Human Pose Estimation
-    URL: https://arxiv.org/abs/1908.07919
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/hrnet.py#L218
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/icnet/README.md b/mmsegmentation/configs/icnet/README.md
deleted file mode 100644
index fa2327f..0000000
--- a/mmsegmentation/configs/icnet/README.md
+++ /dev/null
@@ -1,56 +0,0 @@
-# ICNet
-
-> [ICNet for Real-time Semantic Segmentation on High-resolution Images](https://arxiv.org/abs/1704.08545)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/hszhao/ICNet">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-We focus on the challenging task of real-time semantic segmentation in this paper. It finds many practical applications and yet is with fundamental difficulty of reducing a large portion of computation for pixel-wise label inference. We propose an image cascade network (ICNet) that incorporates multi-resolution branches under proper label guidance to address this challenge. We provide in-depth analysis of our framework and introduce the cascade feature fusion unit to quickly achieve high-quality segmentation. Our system yields real-time inference on a single GPU card with decent quality results evaluated on challenging datasets like Cityscapes, CamVid and COCO-Stuff.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142901772-4570455d-7b27-44ae-a690-47dd9fde8445.png" width="70%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method           | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                | download                                                                                                                                                                                                                                                                                                                                                                               |
-| ---------------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| ICNet            | R-18-D8  | 832x832   |   80000 | 1.70     | 27.12          | V100   | 68.14 |         70.16 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r18-d8_4xb2-80k_cityscapes-832x832.py)            | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_832x832_80k_cityscapes/icnet_r18-d8_832x832_80k_cityscapes_20210925_225521-2e36638d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_832x832_80k_cityscapes/icnet_r18-d8_832x832_80k_cityscapes_20210925_225521.log.json)                                             |
-| ICNet            | R-18-D8  | 832x832   |  160000 | -        | -              | V100   | 71.64 |         74.18 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r18-d8_4xb2-160k_cityscapes-832x832.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_832x832_160k_cityscapes/icnet_r18-d8_832x832_160k_cityscapes_20210925_230153-2c6eb6e0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_832x832_160k_cityscapes/icnet_r18-d8_832x832_160k_cityscapes_20210925_230153.log.json)                                         |
-| ICNet (in1k-pre) | R-18-D8  | 832x832   |   80000 | -        | -              | V100   | 72.51 |         74.78 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r18-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_in1k-pre_832x832_80k_cityscapes/icnet_r18-d8_in1k-pre_832x832_80k_cityscapes_20210925_230354-1cbe3022.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_in1k-pre_832x832_80k_cityscapes/icnet_r18-d8_in1k-pre_832x832_80k_cityscapes_20210925_230354.log.json)         |
-| ICNet (in1k-pre) | R-18-D8  | 832x832   |  160000 | -        | -              | V100   | 74.43 |         76.72 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r18-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_in1k-pre_832x832_160k_cityscapes/icnet_r18-d8_in1k-pre_832x832_160k_cityscapes_20210926_052702-619c8ae1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_in1k-pre_832x832_160k_cityscapes/icnet_r18-d8_in1k-pre_832x832_160k_cityscapes_20210926_052702.log.json)     |
-| ICNet            | R-50-D8  | 832x832   |   80000 | 2.53     | 20.08          | V100   | 68.91 |         69.72 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r50-d8_4xb2-80k_cityscapes-832x832.py)            | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_832x832_80k_cityscapes/icnet_r50-d8_832x832_80k_cityscapes_20210926_044625-c6407341.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_832x832_80k_cityscapes/icnet_r50-d8_832x832_80k_cityscapes_20210926_044625.log.json)                                             |
-| ICNet            | R-50-D8  | 832x832   |  160000 | -        | -              | V100   | 73.82 |         75.67 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r50-d8_4xb2-160k_cityscapes-832x832.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_832x832_160k_cityscapes/icnet_r50-d8_832x832_160k_cityscapes_20210925_232612-a95f0d4e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_832x832_160k_cityscapes/icnet_r50-d8_832x832_160k_cityscapes_20210925_232612.log.json)                                         |
-| ICNet (in1k-pre) | R-50-D8  | 832x832   |   80000 | -        | -              | V100   | 74.58 |         76.41 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r50-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_in1k-pre_832x832_80k_cityscapes/icnet_r50-d8_in1k-pre_832x832_80k_cityscapes_20210926_032943-1743dc7b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_in1k-pre_832x832_80k_cityscapes/icnet_r50-d8_in1k-pre_832x832_80k_cityscapes_20210926_032943.log.json)         |
-| ICNet (in1k-pre) | R-50-D8  | 832x832   |  160000 | -        | -              | V100   | 76.29 |         78.09 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r50-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_in1k-pre_832x832_160k_cityscapes/icnet_r50-d8_in1k-pre_832x832_160k_cityscapes_20210926_042715-ce310aea.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_in1k-pre_832x832_160k_cityscapes/icnet_r50-d8_in1k-pre_832x832_160k_cityscapes_20210926_042715.log.json)     |
-| ICNet            | R-101-D8 | 832x832   |   80000 | 3.08     | 16.95          | V100   | 70.28 |         71.95 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r101-d8_4xb2-80k_cityscapes-832x832.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_832x832_80k_cityscapes/icnet_r101-d8_832x832_80k_cityscapes_20210926_072447-b52f936e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_832x832_80k_cityscapes/icnet_r101-d8_832x832_80k_cityscapes_20210926_072447.log.json)                                         |
-| ICNet            | R-101-D8 | 832x832   |  160000 | -        | -              | V100   | 73.80 |         76.10 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r101-d8_4xb2-160k_cityscapes-832x832.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_832x832_160k_cityscapes/icnet_r101-d8_832x832_160k_cityscapes_20210926_092350-3a1ebf1a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_832x832_160k_cityscapes/icnet_r101-d8_832x832_160k_cityscapes_20210926_092350.log.json)                                     |
-| ICNet (in1k-pre) | R-101-D8 | 832x832   |   80000 | -        | -              | V100   | 75.57 |         77.86 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r101-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_in1k-pre_832x832_80k_cityscapes/icnet_r101-d8_in1k-pre_832x832_80k_cityscapes_20210926_020414-7ceb12c5.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_in1k-pre_832x832_80k_cityscapes/icnet_r101-d8_in1k-pre_832x832_80k_cityscapes_20210926_020414.log.json)     |
-| ICNet (in1k-pre) | R-101-D8 | 832x832   |  160000 | -        | -              | V100   | 76.15 |         77.98 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet/icnet_r101-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_in1k-pre_832x832_160k_cityscapes/icnet_r101-d8_in1k-pre_832x832_160k_cityscapes_20210925_232612-9484ae8a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_in1k-pre_832x832_160k_cityscapes/icnet_r101-d8_in1k-pre_832x832_160k_cityscapes_20210925_232612.log.json) |
-
-Note: `in1k-pre` means pretrained model is used.
-
-## Citation
-
-```bibtext
-@inproceedings{zhao2018icnet,
-  title={Icnet for real-time semantic segmentation on high-resolution images},
-  author={Zhao, Hengshuang and Qi, Xiaojuan and Shen, Xiaoyong and Shi, Jianping and Jia, Jiaya},
-  booktitle={Proceedings of the European conference on computer vision (ECCV)},
-  pages={405--420},
-  year={2018}
-}
-```
diff --git a/mmsegmentation/configs/icnet/icnet_r101-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r101-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
deleted file mode 100644
index a6840a1..0000000
--- a/mmsegmentation/configs/icnet/icnet_r101-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = './icnet_r50-d8_4xb2-160k_cityscapes-832x832.py'
-model = dict(
-    backbone=dict(
-        backbone_cfg=dict(
-            depth=101,
-            init_cfg=dict(
-                type='Pretrained', checkpoint='open-mmlab://resnet101_v1c'))))
diff --git a/mmsegmentation/configs/icnet/icnet_r101-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r101-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
deleted file mode 100644
index ca81df8..0000000
--- a/mmsegmentation/configs/icnet/icnet_r101-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = './icnet_r50-d8_4xb2-80k_cityscapes-832x832.py'
-model = dict(
-    backbone=dict(
-        backbone_cfg=dict(
-            depth=101,
-            init_cfg=dict(
-                type='Pretrained', checkpoint='open-mmlab://resnet101_v1c'))))
diff --git a/mmsegmentation/configs/icnet/icnet_r101-d8_4xb2-160k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r101-d8_4xb2-160k_cityscapes-832x832.py
deleted file mode 100644
index ef60446..0000000
--- a/mmsegmentation/configs/icnet/icnet_r101-d8_4xb2-160k_cityscapes-832x832.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './icnet_r50-d8_4xb2-160k_cityscapes-832x832.py'
-model = dict(backbone=dict(backbone_cfg=dict(depth=101)))
diff --git a/mmsegmentation/configs/icnet/icnet_r101-d8_4xb2-80k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r101-d8_4xb2-80k_cityscapes-832x832.py
deleted file mode 100644
index 5173d2d..0000000
--- a/mmsegmentation/configs/icnet/icnet_r101-d8_4xb2-80k_cityscapes-832x832.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './icnet_r50-d8_4xb2-80k_cityscapes-832x832.py'
-model = dict(backbone=dict(backbone_cfg=dict(depth=101)))
diff --git a/mmsegmentation/configs/icnet/icnet_r18-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r18-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
deleted file mode 100644
index 5f72daa..0000000
--- a/mmsegmentation/configs/icnet/icnet_r18-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = './icnet_r50-d8_4xb2-160k_cityscapes-832x832.py'
-model = dict(
-    backbone=dict(
-        layer_channels=(128, 512),
-        backbone_cfg=dict(
-            depth=18,
-            init_cfg=dict(
-                type='Pretrained', checkpoint='open-mmlab://resnet18_v1c'))))
diff --git a/mmsegmentation/configs/icnet/icnet_r18-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r18-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
deleted file mode 100644
index 2fc79ab..0000000
--- a/mmsegmentation/configs/icnet/icnet_r18-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = './icnet_r50-d8_4xb2-80k_cityscapes-832x832.py'
-model = dict(
-    backbone=dict(
-        layer_channels=(128, 512),
-        backbone_cfg=dict(
-            depth=18,
-            init_cfg=dict(
-                type='Pretrained', checkpoint='open-mmlab://resnet18_v1c'))))
diff --git a/mmsegmentation/configs/icnet/icnet_r18-d8_4xb2-160k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r18-d8_4xb2-160k_cityscapes-832x832.py
deleted file mode 100644
index 2c70e94..0000000
--- a/mmsegmentation/configs/icnet/icnet_r18-d8_4xb2-160k_cityscapes-832x832.py
+++ /dev/null
@@ -1,3 +0,0 @@
-_base_ = './icnet_r50-d8_4xb2-160k_cityscapes-832x832.py'
-model = dict(
-    backbone=dict(layer_channels=(128, 512), backbone_cfg=dict(depth=18)))
diff --git a/mmsegmentation/configs/icnet/icnet_r18-d8_4xb2-80k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r18-d8_4xb2-80k_cityscapes-832x832.py
deleted file mode 100644
index 23c7ac2..0000000
--- a/mmsegmentation/configs/icnet/icnet_r18-d8_4xb2-80k_cityscapes-832x832.py
+++ /dev/null
@@ -1,3 +0,0 @@
-_base_ = './icnet_r50-d8_4xb2-80k_cityscapes-832x832.py'
-model = dict(
-    backbone=dict(layer_channels=(128, 512), backbone_cfg=dict(depth=18)))
diff --git a/mmsegmentation/configs/icnet/icnet_r50-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r50-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
deleted file mode 100644
index f9ab863..0000000
--- a/mmsegmentation/configs/icnet/icnet_r50-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './icnet_r50-d8_4xb2-160k_cityscapes-832x832.py'
-model = dict(
-    backbone=dict(
-        backbone_cfg=dict(
-            init_cfg=dict(
-                type='Pretrained', checkpoint='open-mmlab://resnet50_v1c'))))
diff --git a/mmsegmentation/configs/icnet/icnet_r50-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r50-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
deleted file mode 100644
index 9a085d4..0000000
--- a/mmsegmentation/configs/icnet/icnet_r50-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './icnet_r50-d8_4xb2-80k_cityscapes-832x832.py'
-model = dict(
-    backbone=dict(
-        backbone_cfg=dict(
-            init_cfg=dict(
-                type='Pretrained', checkpoint='open-mmlab://resnet50_v1c'))))
diff --git a/mmsegmentation/configs/icnet/icnet_r50-d8_4xb2-160k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r50-d8_4xb2-160k_cityscapes-832x832.py
deleted file mode 100644
index 1b7b188..0000000
--- a/mmsegmentation/configs/icnet/icnet_r50-d8_4xb2-160k_cityscapes-832x832.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = [
-    '../_base_/models/icnet_r50-d8.py',
-    '../_base_/datasets/cityscapes_832x832.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (832, 832)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/icnet/icnet_r50-d8_4xb2-80k_cityscapes-832x832.py b/mmsegmentation/configs/icnet/icnet_r50-d8_4xb2-80k_cityscapes-832x832.py
deleted file mode 100644
index 001dbca..0000000
--- a/mmsegmentation/configs/icnet/icnet_r50-d8_4xb2-80k_cityscapes-832x832.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = [
-    '../_base_/models/icnet_r50-d8.py',
-    '../_base_/datasets/cityscapes_832x832.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (832, 832)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/icnet/metafile.yaml b/mmsegmentation/configs/icnet/metafile.yaml
deleted file mode 100644
index 1d843ee..0000000
--- a/mmsegmentation/configs/icnet/metafile.yaml
+++ /dev/null
@@ -1,298 +0,0 @@
-Collections:
-- Name: ICNet
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-  Paper:
-    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
-    URL: https://arxiv.org/abs/1704.08545
-  README: configs/icnet/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: icnet_r18-d8_4xb2-80k_cityscapes-832x832
-  In Collection: ICNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 68.14
-      mIoU(ms+flip): 70.16
-  Config: configs/icnet/icnet_r18-d8_4xb2-80k_cityscapes-832x832.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-18-D8
-    - ICNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.7
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_832x832_80k_cityscapes/icnet_r18-d8_832x832_80k_cityscapes_20210925_225521-2e36638d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_832x832_80k_cityscapes/icnet_r18-d8_832x832_80k_cityscapes_20210925_225521.log.json
-  Paper:
-    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
-    URL: https://arxiv.org/abs/1704.08545
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
-  Framework: PyTorch
-- Name: icnet_r18-d8_4xb2-160k_cityscapes-832x832
-  In Collection: ICNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 71.64
-      mIoU(ms+flip): 74.18
-  Config: configs/icnet/icnet_r18-d8_4xb2-160k_cityscapes-832x832.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-18-D8
-    - ICNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_832x832_160k_cityscapes/icnet_r18-d8_832x832_160k_cityscapes_20210925_230153-2c6eb6e0.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_832x832_160k_cityscapes/icnet_r18-d8_832x832_160k_cityscapes_20210925_230153.log.json
-  Paper:
-    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
-    URL: https://arxiv.org/abs/1704.08545
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
-  Framework: PyTorch
-- Name: icnet_r18-d8-in1k-pre_4xb2-80k_cityscapes-832x832
-  In Collection: ICNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 72.51
-      mIoU(ms+flip): 74.78
-  Config: configs/icnet/icnet_r18-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-18-D8
-    - ICNet
-    - (in1k-pre)
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_in1k-pre_832x832_80k_cityscapes/icnet_r18-d8_in1k-pre_832x832_80k_cityscapes_20210925_230354-1cbe3022.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_in1k-pre_832x832_80k_cityscapes/icnet_r18-d8_in1k-pre_832x832_80k_cityscapes_20210925_230354.log.json
-  Paper:
-    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
-    URL: https://arxiv.org/abs/1704.08545
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
-  Framework: PyTorch
-- Name: icnet_r18-d8-in1k-pre_4xb2-160k_cityscapes-832x832
-  In Collection: ICNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 74.43
-      mIoU(ms+flip): 76.72
-  Config: configs/icnet/icnet_r18-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-18-D8
-    - ICNet
-    - (in1k-pre)
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_in1k-pre_832x832_160k_cityscapes/icnet_r18-d8_in1k-pre_832x832_160k_cityscapes_20210926_052702-619c8ae1.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r18-d8_in1k-pre_832x832_160k_cityscapes/icnet_r18-d8_in1k-pre_832x832_160k_cityscapes_20210926_052702.log.json
-  Paper:
-    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
-    URL: https://arxiv.org/abs/1704.08545
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
-  Framework: PyTorch
-- Name: icnet_r50-d8_4xb2-80k_cityscapes-832x832
-  In Collection: ICNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 68.91
-      mIoU(ms+flip): 69.72
-  Config: configs/icnet/icnet_r50-d8_4xb2-80k_cityscapes-832x832.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - ICNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 2.53
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_832x832_80k_cityscapes/icnet_r50-d8_832x832_80k_cityscapes_20210926_044625-c6407341.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_832x832_80k_cityscapes/icnet_r50-d8_832x832_80k_cityscapes_20210926_044625.log.json
-  Paper:
-    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
-    URL: https://arxiv.org/abs/1704.08545
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
-  Framework: PyTorch
-- Name: icnet_r50-d8_4xb2-160k_cityscapes-832x832
-  In Collection: ICNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 73.82
-      mIoU(ms+flip): 75.67
-  Config: configs/icnet/icnet_r50-d8_4xb2-160k_cityscapes-832x832.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - ICNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_832x832_160k_cityscapes/icnet_r50-d8_832x832_160k_cityscapes_20210925_232612-a95f0d4e.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_832x832_160k_cityscapes/icnet_r50-d8_832x832_160k_cityscapes_20210925_232612.log.json
-  Paper:
-    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
-    URL: https://arxiv.org/abs/1704.08545
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
-  Framework: PyTorch
-- Name: icnet_r50-d8-in1k-pre_4xb2-80k_cityscapes-832x832
-  In Collection: ICNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 74.58
-      mIoU(ms+flip): 76.41
-  Config: configs/icnet/icnet_r50-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - ICNet
-    - (in1k-pre)
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_in1k-pre_832x832_80k_cityscapes/icnet_r50-d8_in1k-pre_832x832_80k_cityscapes_20210926_032943-1743dc7b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_in1k-pre_832x832_80k_cityscapes/icnet_r50-d8_in1k-pre_832x832_80k_cityscapes_20210926_032943.log.json
-  Paper:
-    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
-    URL: https://arxiv.org/abs/1704.08545
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
-  Framework: PyTorch
-- Name: icnet_r50-d8-in1k-pre_4xb2-160k_cityscapes-832x832
-  In Collection: ICNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.29
-      mIoU(ms+flip): 78.09
-  Config: configs/icnet/icnet_r50-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - ICNet
-    - (in1k-pre)
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_in1k-pre_832x832_160k_cityscapes/icnet_r50-d8_in1k-pre_832x832_160k_cityscapes_20210926_042715-ce310aea.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r50-d8_in1k-pre_832x832_160k_cityscapes/icnet_r50-d8_in1k-pre_832x832_160k_cityscapes_20210926_042715.log.json
-  Paper:
-    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
-    URL: https://arxiv.org/abs/1704.08545
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
-  Framework: PyTorch
-- Name: icnet_r101-d8_4xb2-80k_cityscapes-832x832
-  In Collection: ICNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 70.28
-      mIoU(ms+flip): 71.95
-  Config: configs/icnet/icnet_r101-d8_4xb2-80k_cityscapes-832x832.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - ICNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 3.08
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_832x832_80k_cityscapes/icnet_r101-d8_832x832_80k_cityscapes_20210926_072447-b52f936e.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_832x832_80k_cityscapes/icnet_r101-d8_832x832_80k_cityscapes_20210926_072447.log.json
-  Paper:
-    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
-    URL: https://arxiv.org/abs/1704.08545
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
-  Framework: PyTorch
-- Name: icnet_r101-d8_4xb2-160k_cityscapes-832x832
-  In Collection: ICNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 73.8
-      mIoU(ms+flip): 76.1
-  Config: configs/icnet/icnet_r101-d8_4xb2-160k_cityscapes-832x832.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - ICNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_832x832_160k_cityscapes/icnet_r101-d8_832x832_160k_cityscapes_20210926_092350-3a1ebf1a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_832x832_160k_cityscapes/icnet_r101-d8_832x832_160k_cityscapes_20210926_092350.log.json
-  Paper:
-    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
-    URL: https://arxiv.org/abs/1704.08545
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
-  Framework: PyTorch
-- Name: icnet_r101-d8-in1k-pre_4xb2-80k_cityscapes-832x832
-  In Collection: ICNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 75.57
-      mIoU(ms+flip): 77.86
-  Config: configs/icnet/icnet_r101-d8-in1k-pre_4xb2-80k_cityscapes-832x832.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - ICNet
-    - (in1k-pre)
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_in1k-pre_832x832_80k_cityscapes/icnet_r101-d8_in1k-pre_832x832_80k_cityscapes_20210926_020414-7ceb12c5.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_in1k-pre_832x832_80k_cityscapes/icnet_r101-d8_in1k-pre_832x832_80k_cityscapes_20210926_020414.log.json
-  Paper:
-    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
-    URL: https://arxiv.org/abs/1704.08545
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
-  Framework: PyTorch
-- Name: icnet_r101-d8-in1k-pre_4xb2-160k_cityscapes-832x832
-  In Collection: ICNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.15
-      mIoU(ms+flip): 77.98
-  Config: configs/icnet/icnet_r101-d8-in1k-pre_4xb2-160k_cityscapes-832x832.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - ICNet
-    - (in1k-pre)
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_in1k-pre_832x832_160k_cityscapes/icnet_r101-d8_in1k-pre_832x832_160k_cityscapes_20210925_232612-9484ae8a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/icnet/icnet_r101-d8_in1k-pre_832x832_160k_cityscapes/icnet_r101-d8_in1k-pre_832x832_160k_cityscapes_20210925_232612.log.json
-  Paper:
-    Title: ICNet for Real-time Semantic Segmentation on High-resolution Images
-    URL: https://arxiv.org/abs/1704.08545
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/necks/ic_neck.py#L77
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/isanet/README.md b/mmsegmentation/configs/isanet/README.md
deleted file mode 100644
index c11744f..0000000
--- a/mmsegmentation/configs/isanet/README.md
+++ /dev/null
@@ -1,80 +0,0 @@
-# ISANet
-
-> [Interlaced Sparse Self-Attention for Semantic Segmentation](https://arxiv.org/abs/1907.12273)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/openseg-group/openseg.pytorch">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-In this paper, we present a so-called interlaced sparse self-attention approach to improve the efficiency of the \\emph{self-attention} mechanism for semantic segmentation. The main idea is that we factorize the dense affinity matrix as the product of two sparse affinity matrices. There are two successive attention modules each estimating a sparse affinity matrix. The first attention module is used to estimate the affinities within a subset of positions that have long spatial interval distances and the second attention module is used to estimate the affinities within a subset of positions that have short spatial interval distances. These two attention modules are designed so that each position is able to receive the information from all the other positions. In contrast to the original self-attention module, our approach decreases the computation and memory complexity substantially especially when processing high-resolution feature maps. We empirically verify the effectiveness of our approach on six challenging semantic segmentation benchmarks.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142901868-03d80da4-b9c0-4df9-8509-5f684ba9dadc.png" width="80%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) |                                                                                                                         config | download                                                                                                                                                                                                                                                                                                                                                 |
-| ------ | -------- | --------- | ------- | -------: | -------------- | ------ | ----- | ------------: | -----------------------------------------------------------------------------------------------------------------------------: | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| ISANet | R-50-D8  | 512x1024  | 40000   |    5.869 | 2.91           | V100   | 78.49 |         79.44 |  [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x1024_40k_cityscapes/isanet_r50-d8_512x1024_40k_cityscapes_20210901_054739-981bd763.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x1024_40k_cityscapes/isanet_r50-d8_512x1024_40k_cityscapes_20210901_054739.log.json)     |
-| ISANet | R-50-D8  | 512x1024  | 80000   |    5.869 | 2.91           | V100   | 78.68 |         80.25 |  [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x1024_80k_cityscapes/isanet_r50-d8_512x1024_80k_cityscapes_20210901_074202-89384497.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x1024_80k_cityscapes/isanet_r50-d8_512x1024_80k_cityscapes_20210901_074202.log.json)     |
-| ISANet | R-50-D8  | 769x769   | 40000   |    6.759 | 1.54           | V100   | 78.70 |         80.28 |   [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-769x769.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_769x769_40k_cityscapes/isanet_r50-d8_769x769_40k_cityscapes_20210903_050200-4ae7e65b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_769x769_40k_cityscapes/isanet_r50-d8_769x769_40k_cityscapes_20210903_050200.log.json)         |
-| ISANet | R-50-D8  | 769x769   | 80000   |    6.759 | 1.54           | V100   | 79.29 |         80.53 |   [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-769x769.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_769x769_80k_cityscapes/isanet_r50-d8_769x769_80k_cityscapes_20210903_101126-99b54519.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_769x769_80k_cityscapes/isanet_r50-d8_769x769_80k_cityscapes_20210903_101126.log.json)         |
-| ISANet | R-101-D8 | 512x1024  | 40000   |    9.425 | 2.35           | V100   | 79.58 |         81.05 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x1024_40k_cityscapes/isanet_r101-d8_512x1024_40k_cityscapes_20210901_145553-293e6bd6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x1024_40k_cityscapes/isanet_r101-d8_512x1024_40k_cityscapes_20210901_145553.log.json) |
-| ISANet | R-101-D8 | 512x1024  | 80000   |    9.425 | 2.35           | V100   | 80.32 |         81.58 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x1024_80k_cityscapes/isanet_r101-d8_512x1024_80k_cityscapes_20210901_145243-5b99c9b2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x1024_80k_cityscapes/isanet_r101-d8_512x1024_80k_cityscapes_20210901_145243.log.json) |
-| ISANet | R-101-D8 | 769x769   | 40000   |   10.815 | 0.92           | V100   | 79.68 |         80.95 |  [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-769x769.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_769x769_40k_cityscapes/isanet_r101-d8_769x769_40k_cityscapes_20210903_111320-509e7224.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_769x769_40k_cityscapes/isanet_r101-d8_769x769_40k_cityscapes_20210903_111320.log.json)     |
-| ISANet | R-101-D8 | 769x769   | 80000   |   10.815 | 0.92           | V100   | 80.61 |         81.59 |  [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-769x769.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_769x769_80k_cityscapes/isanet_r101-d8_769x769_80k_cityscapes_20210903_111319-24f71dfa.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_769x769_80k_cityscapes/isanet_r101-d8_769x769_80k_cityscapes_20210903_111319.log.json)     |
-
-### ADE20K
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) |                                                                                                                     config | download                                                                                                                                                                                                                                                                                                                                 |
-| ------ | -------- | --------- | ------- | -------: | -------------- | ------ | ----- | ------------: | -------------------------------------------------------------------------------------------------------------------------: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| ISANet | R-50-D8  | 512x512   | 80000   |      9.0 | 22.55          | V100   | 41.12 |         42.35 |   [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r50-d8_4xb4-80k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_80k_ade20k/isanet_r50-d8_512x512_80k_ade20k_20210903_124557-6ed83a0c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_80k_ade20k/isanet_r50-d8_512x512_80k_ade20k_20210903_124557.log.json)         |
-| ISANet | R-50-D8  | 512x512   | 160000  |      9.0 | 22.55          | V100   | 42.59 |         43.07 |  [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r50-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_160k_ade20k/isanet_r50-d8_512x512_160k_ade20k_20210903_104850-f752d0a3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_160k_ade20k/isanet_r50-d8_512x512_160k_ade20k_20210903_104850.log.json)     |
-| ISANet | R-101-D8 | 512x512   | 80000   |   12.562 | 10.56          | V100   | 43.51 |         44.38 |  [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r101-d8_4xb4-80k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_80k_ade20k/isanet_r101-d8_512x512_80k_ade20k_20210903_162056-68b235c2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_80k_ade20k/isanet_r101-d8_512x512_80k_ade20k_20210903_162056.log.json)     |
-| ISANet | R-101-D8 | 512x512   | 160000  |   12.562 | 10.56          | V100   | 43.80 |          45.4 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_160k_ade20k/isanet_r101-d8_512x512_160k_ade20k_20210903_211431-a7879dcd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_160k_ade20k/isanet_r101-d8_512x512_160k_ade20k_20210903_211431.log.json) |
-
-### Pascal VOC 2012 + Aug
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) |                                                                                                                      config | download                                                                                                                                                                                                                                                                                                                                     |
-| ------ | -------- | --------- | ------- | -------: | -------------- | ------ | ----- | ------------: | --------------------------------------------------------------------------------------------------------------------------: | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| ISANet | R-50-D8  | 512x512   | 20000   |      5.9 | 23.08          | V100   | 76.78 |         77.79 |  [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r50-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_20k_voc12aug/isanet_r50-d8_512x512_20k_voc12aug_20210901_164838-79d59b80.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_20k_voc12aug/isanet_r50-d8_512x512_20k_voc12aug_20210901_164838.log.json)     |
-| ISANet | R-50-D8  | 512x512   | 40000   |      5.9 | 23.08          | V100   | 76.20 |         77.22 |  [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r50-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_40k_voc12aug/isanet_r50-d8_512x512_40k_voc12aug_20210901_151349-7d08a54e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_40k_voc12aug/isanet_r50-d8_512x512_40k_voc12aug_20210901_151349.log.json)     |
-| ISANet | R-101-D8 | 512x512   | 20000   |    9.465 | 7.42           | V100   | 78.46 |         79.16 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r101-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_20k_voc12aug/isanet_r101-d8_512x512_20k_voc12aug_20210901_115805-3ccbf355.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_20k_voc12aug/isanet_r101-d8_512x512_20k_voc12aug_20210901_115805.log.json) |
-| ISANet | R-101-D8 | 512x512   | 40000   |    9.465 | 7.42           | V100   | 78.12 |         79.04 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet/isanet_r101-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_40k_voc12aug/isanet_r101-d8_512x512_40k_voc12aug_20210901_145814-bc71233b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_40k_voc12aug/isanet_r101-d8_512x512_40k_voc12aug_20210901_145814.log.json) |
-
-## Citation
-
-```bibetex
-@article{huang2019isa,
-  title={Interlaced Sparse Self-Attention for Semantic Segmentation},
-  author={Huang, Lang and Yuan, Yuhui and Guo, Jianyuan and Zhang, Chao and Chen, Xilin and Wang, Jingdong},
-  journal={arXiv preprint arXiv:1907.12273},
-  year={2019}
-}
-```
-
-The technical report above is also presented at:
-
-```bibetex
-@article{yuan2021ocnet,
-  title={OCNet: Object Context for Semantic Segmentation},
-  author={Yuan, Yuhui and Huang, Lang and Guo, Jianyuan and Zhang, Chao and Chen, Xilin and Wang, Jingdong},
-  journal={International Journal of Computer Vision},
-  pages={1--24},
-  year={2021},
-  publisher={Springer}
-}
-```
diff --git a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 6093aeb..0000000
--- a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './isanet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index dc14c76..0000000
--- a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './isanet_r50-d8_4xb2-40k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 1735f89..0000000
--- a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './isanet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index b1a6371..0000000
--- a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './isanet_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index c2fb09e..0000000
--- a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './isanet_r50-d8_4xb4-160k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index 7c225cf..0000000
--- a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './isanet_r50-d8_4xb4-20k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index 5e86ee5..0000000
--- a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './isanet_r50-d8_4xb4-40k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 090e86f..0000000
--- a/mmsegmentation/configs/isanet/isanet_r101-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './isanet_r50-d8_4xb4-80k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index f03365e..0000000
--- a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/isanet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index f073a7b..0000000
--- a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/isanet_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 4be445d..0000000
--- a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/isanet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 0278ad8..0000000
--- a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/isanet_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 1f4af8d..0000000
--- a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/isanet_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index 591df42..0000000
--- a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/isanet_r50-d8.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_20k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index a59879b..0000000
--- a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/isanet_r50-d8.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 7df05c3..0000000
--- a/mmsegmentation/configs/isanet/isanet_r50-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/isanet_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/isanet/metafile.yaml b/mmsegmentation/configs/isanet/metafile.yaml
deleted file mode 100644
index ad394ea..0000000
--- a/mmsegmentation/configs/isanet/metafile.yaml
+++ /dev/null
@@ -1,399 +0,0 @@
-Collections:
-- Name: ISANet
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-    - ADE20K
-    - Pascal VOC 2012 + Aug
-  Paper:
-    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
-    URL: https://arxiv.org/abs/1907.12273
-  README: configs/isanet/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: isanet_r50-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: ISANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.49
-      mIoU(ms+flip): 79.44
-  Config: configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - ISANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.869
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x1024_40k_cityscapes/isanet_r50-d8_512x1024_40k_cityscapes_20210901_054739-981bd763.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x1024_40k_cityscapes/isanet_r50-d8_512x1024_40k_cityscapes_20210901_054739.log.json
-  Paper:
-    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
-    URL: https://arxiv.org/abs/1907.12273
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
-  Framework: PyTorch
-- Name: isanet_r50-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: ISANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.68
-      mIoU(ms+flip): 80.25
-  Config: configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - ISANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.869
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x1024_80k_cityscapes/isanet_r50-d8_512x1024_80k_cityscapes_20210901_074202-89384497.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x1024_80k_cityscapes/isanet_r50-d8_512x1024_80k_cityscapes_20210901_074202.log.json
-  Paper:
-    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
-    URL: https://arxiv.org/abs/1907.12273
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
-  Framework: PyTorch
-- Name: isanet_r50-d8_4xb2-40k_cityscapes-769x769
-  In Collection: ISANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.7
-      mIoU(ms+flip): 80.28
-  Config: configs/isanet/isanet_r50-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - ISANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.759
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_769x769_40k_cityscapes/isanet_r50-d8_769x769_40k_cityscapes_20210903_050200-4ae7e65b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_769x769_40k_cityscapes/isanet_r50-d8_769x769_40k_cityscapes_20210903_050200.log.json
-  Paper:
-    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
-    URL: https://arxiv.org/abs/1907.12273
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
-  Framework: PyTorch
-- Name: isanet_r50-d8_4xb2-80k_cityscapes-769x769
-  In Collection: ISANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.29
-      mIoU(ms+flip): 80.53
-  Config: configs/isanet/isanet_r50-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - ISANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.759
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_769x769_80k_cityscapes/isanet_r50-d8_769x769_80k_cityscapes_20210903_101126-99b54519.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_769x769_80k_cityscapes/isanet_r50-d8_769x769_80k_cityscapes_20210903_101126.log.json
-  Paper:
-    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
-    URL: https://arxiv.org/abs/1907.12273
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
-  Framework: PyTorch
-- Name: isanet_r101-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: ISANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.58
-      mIoU(ms+flip): 81.05
-  Config: configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - ISANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.425
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x1024_40k_cityscapes/isanet_r101-d8_512x1024_40k_cityscapes_20210901_145553-293e6bd6.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x1024_40k_cityscapes/isanet_r101-d8_512x1024_40k_cityscapes_20210901_145553.log.json
-  Paper:
-    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
-    URL: https://arxiv.org/abs/1907.12273
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
-  Framework: PyTorch
-- Name: isanet_r101-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: ISANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 80.32
-      mIoU(ms+flip): 81.58
-  Config: configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - ISANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.425
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x1024_80k_cityscapes/isanet_r101-d8_512x1024_80k_cityscapes_20210901_145243-5b99c9b2.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x1024_80k_cityscapes/isanet_r101-d8_512x1024_80k_cityscapes_20210901_145243.log.json
-  Paper:
-    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
-    URL: https://arxiv.org/abs/1907.12273
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
-  Framework: PyTorch
-- Name: isanet_r101-d8_4xb2-40k_cityscapes-769x769
-  In Collection: ISANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.68
-      mIoU(ms+flip): 80.95
-  Config: configs/isanet/isanet_r101-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - ISANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.815
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_769x769_40k_cityscapes/isanet_r101-d8_769x769_40k_cityscapes_20210903_111320-509e7224.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_769x769_40k_cityscapes/isanet_r101-d8_769x769_40k_cityscapes_20210903_111320.log.json
-  Paper:
-    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
-    URL: https://arxiv.org/abs/1907.12273
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
-  Framework: PyTorch
-- Name: isanet_r101-d8_4xb2-80k_cityscapes-769x769
-  In Collection: ISANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 80.61
-      mIoU(ms+flip): 81.59
-  Config: configs/isanet/isanet_r101-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - ISANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.815
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_769x769_80k_cityscapes/isanet_r101-d8_769x769_80k_cityscapes_20210903_111319-24f71dfa.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_769x769_80k_cityscapes/isanet_r101-d8_769x769_80k_cityscapes_20210903_111319.log.json
-  Paper:
-    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
-    URL: https://arxiv.org/abs/1907.12273
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
-  Framework: PyTorch
-- Name: isanet_r50-d8_4xb4-80k_ade20k-512x512
-  In Collection: ISANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 41.12
-      mIoU(ms+flip): 42.35
-  Config: configs/isanet/isanet_r50-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - ISANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_80k_ade20k/isanet_r50-d8_512x512_80k_ade20k_20210903_124557-6ed83a0c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_80k_ade20k/isanet_r50-d8_512x512_80k_ade20k_20210903_124557.log.json
-  Paper:
-    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
-    URL: https://arxiv.org/abs/1907.12273
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
-  Framework: PyTorch
-- Name: isanet_r50-d8_4xb4-160k_ade20k-512x512
-  In Collection: ISANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.59
-      mIoU(ms+flip): 43.07
-  Config: configs/isanet/isanet_r50-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - ISANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_160k_ade20k/isanet_r50-d8_512x512_160k_ade20k_20210903_104850-f752d0a3.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_160k_ade20k/isanet_r50-d8_512x512_160k_ade20k_20210903_104850.log.json
-  Paper:
-    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
-    URL: https://arxiv.org/abs/1907.12273
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
-  Framework: PyTorch
-- Name: isanet_r101-d8_4xb4-80k_ade20k-512x512
-  In Collection: ISANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 43.51
-      mIoU(ms+flip): 44.38
-  Config: configs/isanet/isanet_r101-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - ISANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 12.562
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_80k_ade20k/isanet_r101-d8_512x512_80k_ade20k_20210903_162056-68b235c2.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_80k_ade20k/isanet_r101-d8_512x512_80k_ade20k_20210903_162056.log.json
-  Paper:
-    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
-    URL: https://arxiv.org/abs/1907.12273
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
-  Framework: PyTorch
-- Name: isanet_r101-d8_4xb4-160k_ade20k-512x512
-  In Collection: ISANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 43.8
-      mIoU(ms+flip): 45.4
-  Config: configs/isanet/isanet_r101-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - ISANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 12.562
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_160k_ade20k/isanet_r101-d8_512x512_160k_ade20k_20210903_211431-a7879dcd.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_160k_ade20k/isanet_r101-d8_512x512_160k_ade20k_20210903_211431.log.json
-  Paper:
-    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
-    URL: https://arxiv.org/abs/1907.12273
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
-  Framework: PyTorch
-- Name: isanet_r50-d8_4xb4-20k_voc12aug-512x512
-  In Collection: ISANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 76.78
-      mIoU(ms+flip): 77.79
-  Config: configs/isanet/isanet_r50-d8_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - ISANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_20k_voc12aug/isanet_r50-d8_512x512_20k_voc12aug_20210901_164838-79d59b80.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_20k_voc12aug/isanet_r50-d8_512x512_20k_voc12aug_20210901_164838.log.json
-  Paper:
-    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
-    URL: https://arxiv.org/abs/1907.12273
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
-  Framework: PyTorch
-- Name: isanet_r50-d8_4xb4-40k_voc12aug-512x512
-  In Collection: ISANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 76.2
-      mIoU(ms+flip): 77.22
-  Config: configs/isanet/isanet_r50-d8_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - ISANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_40k_voc12aug/isanet_r50-d8_512x512_40k_voc12aug_20210901_151349-7d08a54e.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r50-d8_512x512_40k_voc12aug/isanet_r50-d8_512x512_40k_voc12aug_20210901_151349.log.json
-  Paper:
-    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
-    URL: https://arxiv.org/abs/1907.12273
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
-  Framework: PyTorch
-- Name: isanet_r101-d8_4xb4-20k_voc12aug-512x512
-  In Collection: ISANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 78.46
-      mIoU(ms+flip): 79.16
-  Config: configs/isanet/isanet_r101-d8_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - ISANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.465
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_20k_voc12aug/isanet_r101-d8_512x512_20k_voc12aug_20210901_115805-3ccbf355.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_20k_voc12aug/isanet_r101-d8_512x512_20k_voc12aug_20210901_115805.log.json
-  Paper:
-    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
-    URL: https://arxiv.org/abs/1907.12273
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
-  Framework: PyTorch
-- Name: isanet_r101-d8_4xb4-40k_voc12aug-512x512
-  In Collection: ISANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 78.12
-      mIoU(ms+flip): 79.04
-  Config: configs/isanet/isanet_r101-d8_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - ISANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.465
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_40k_voc12aug/isanet_r101-d8_512x512_40k_voc12aug_20210901_145814-bc71233b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/isanet/isanet_r101-d8_512x512_40k_voc12aug/isanet_r101-d8_512x512_40k_voc12aug_20210901_145814.log.json
-  Paper:
-    Title: Interlaced Sparse Self-Attention for Semantic Segmentation
-    URL: https://arxiv.org/abs/1907.12273
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.18.0/mmseg/models/decode_heads/isa_head.py#L58
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/knet/README.md b/mmsegmentation/configs/knet/README.md
deleted file mode 100644
index 1f3f2ae..0000000
--- a/mmsegmentation/configs/knet/README.md
+++ /dev/null
@@ -1,52 +0,0 @@
-# K-Net
-
-> [K-Net: Towards Unified Image Segmentation](https://arxiv.org/abs/2106.14855)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/ZwwWayne/K-Net/">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.23.0/mmseg/models/decode_heads/knet_head.py#L392">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Semantic, instance, and panoptic segmentations have been addressed using different and specialized frameworks despite their underlying connections. This paper presents a unified, simple, and effective framework for these essentially similar tasks. The framework, named K-Net, segments both instances and semantic categories consistently by a group of learnable kernels, where each kernel is responsible for generating a mask for either a potential instance or a stuff class. To remedy the difficulties of distinguishing various instances, we propose a kernel update strategy that enables each kernel dynamic and conditional on its meaningful group in the input image. K-Net can be trained in an end-to-end manner with bipartite matching, and its training and inference are naturally NMS-free and box-free. Without bells and whistles, K-Net surpasses all previous published state-of-the-art single-model results of panoptic segmentation on MS COCO test-dev split and semantic segmentation on ADE20K val split with 55.2% PQ and 54.3% mIoU, respectively. Its instance segmentation performance is also on par with Cascade Mask R-CNN on MS COCO with 60%-90% faster inference speeds. Code and models will be released at [this https URL](https://github.com/ZwwWayne/K-Net/).
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/157008300-9f40905c-b8e8-4a2a-9593-c1177fa35b2c.png" width="90%"/>
-</div>
-
-## Results and models
-
-### ADE20K
-
-| Method           | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                                  | download                                                                                                                                                                                                                                                                                                                                                                                                         |
-| ---------------- | -------- | --------- | ------- | -------- | -------------- | ------ | ----- | ------------- | --------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| KNet + FCN       | R-50-D8  | 512x512   | 80000   | 7.01     | 19.24          | V100   | 43.60 | 45.12         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/knet/knet-s3_r50-d8_fcn_8xb2-adamw-80k_ade20k-512x512.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_fcn_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_fcn_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_043751-abcab920.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_fcn_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_fcn_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_043751.log.json)                         |
-| KNet + PSPNet    | R-50-D8  | 512x512   | 80000   | 6.98     | 20.04          | V100   | 44.18 | 45.58         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/knet/knet-s3_r50-d8_pspnet_8xb2-adamw-80k_ade20k-512x512.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_pspnet_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_pspnet_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_054634-d2c72240.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_pspnet_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_pspnet_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_054634.log.json)             |
-| KNet + DeepLabV3 | R-50-D8  | 512x512   | 80000   | 7.42     | 12.10          | V100   | 45.06 | 46.11         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/knet/knet-s3_r50-d8_deeplabv3_8xb2-adamw-80k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_deeplabv3_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_deeplabv3_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_041642-00c8fbeb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_deeplabv3_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_deeplabv3_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_041642.log.json) |
-| KNet + UperNet   | R-50-D8  | 512x512   | 80000   | 7.34     | 17.11          | V100   | 43.45 | 44.07         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/knet/knet-s3_r50-d8_upernet_8xb2-adamw-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_r50-d8_8x2_512x512_adamw_80k_ade20k_20220304_125657-215753b0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_r50-d8_8x2_512x512_adamw_80k_ade20k_20220304_125657.log.json)         |
-| KNet + UperNet   | Swin-T   | 512x512   | 80000   | 7.57     | 15.56          | V100   | 45.84 | 46.27         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/knet/knet-s3_swin-t_upernet_8xb2-adamw-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-t_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_swin-t_8x2_512x512_adamw_80k_ade20k_20220303_133059-7545e1dc.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-t_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_swin-t_8x2_512x512_adamw_80k_ade20k_20220303_133059.log.json)         |
-| KNet + UperNet   | Swin-L   | 512x512   | 80000   | 13.5     | 8.29           | V100   | 52.05 | 53.24         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-l_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_swin-l_8x2_512x512_adamw_80k_ade20k_20220303_154559-d8da9a90.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-l_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_swin-l_8x2_512x512_adamw_80k_ade20k_20220303_154559.log.json)         |
-| KNet + UperNet   | Swin-L   | 640x640   | 80000   | 13.54    | 8.29           | V100   | 52.21 | 53.34         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-640x640.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-l_8x2_640x640_adamw_80k_ade20k/knet_s3_upernet_swin-l_8x2_640x640_adamw_80k_ade20k_20220301_220747-8787fc71.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-l_8x2_640x640_adamw_80k_ade20k/knet_s3_upernet_swin-l_8x2_640x640_adamw_80k_ade20k_20220301_220747.log.json)         |
-
-Note:
-
-- All experiments of K-Net are implemented with 8 V100 (32G) GPUs with 2 samplers per GPU.
-
-# Citation
-
-```bibtex
-@inproceedings{zhang2021knet,
-    title={{K-Net: Towards} Unified Image Segmentation},
-    author={Wenwei Zhang and Jiangmiao Pang and Kai Chen and Chen Change Loy},
-    year={2021},
-    booktitle={NeurIPS},
-}
-```
diff --git a/mmsegmentation/configs/knet/knet-s3_r50-d8_deeplabv3_8xb2-adamw-80k_ade20k-512x512.py b/mmsegmentation/configs/knet/knet-s3_r50-d8_deeplabv3_8xb2-adamw-80k_ade20k-512x512.py
deleted file mode 100644
index 7946cca..0000000
--- a/mmsegmentation/configs/knet/knet-s3_r50-d8_deeplabv3_8xb2-adamw-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,111 +0,0 @@
-_base_ = [
-    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    mean=[123.675, 116.28, 103.53],
-    std=[58.395, 57.12, 57.375],
-    bgr_to_rgb=True,
-    pad_val=0,
-    size=crop_size,
-    seg_pad_val=255)
-# model settings
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-num_stages = 3
-conv_kernel_size = 1
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    pretrained='open-mmlab://resnet50_v1c',
-    backbone=dict(
-        type='ResNetV1c',
-        depth=50,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        dilations=(1, 1, 2, 4),
-        strides=(1, 2, 1, 1),
-        norm_cfg=norm_cfg,
-        norm_eval=False,
-        style='pytorch',
-        contract_dilation=True),
-    decode_head=dict(
-        type='IterativeDecodeHead',
-        num_stages=num_stages,
-        kernel_update_head=[
-            dict(
-                type='KernelUpdateHead',
-                num_classes=150,
-                num_ffn_fcs=2,
-                num_heads=8,
-                num_mask_fcs=1,
-                feedforward_channels=2048,
-                in_channels=512,
-                out_channels=512,
-                dropout=0.0,
-                conv_kernel_size=conv_kernel_size,
-                ffn_act_cfg=dict(type='ReLU', inplace=True),
-                with_ffn=True,
-                feat_transform_cfg=dict(
-                    conv_cfg=dict(type='Conv2d'), act_cfg=None),
-                kernel_updator_cfg=dict(
-                    type='KernelUpdator',
-                    in_channels=256,
-                    feat_channels=256,
-                    out_channels=256,
-                    act_cfg=dict(type='ReLU', inplace=True),
-                    norm_cfg=dict(type='LN'))) for _ in range(num_stages)
-        ],
-        kernel_generate_head=dict(
-            type='ASPPHead',
-            in_channels=2048,
-            in_index=3,
-            channels=512,
-            dilations=(1, 12, 24, 36),
-            dropout_ratio=0.1,
-            num_classes=150,
-            norm_cfg=norm_cfg,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))),
-    auxiliary_head=dict(
-        type='FCNHead',
-        in_channels=1024,
-        in_index=2,
-        channels=256,
-        num_convs=1,
-        concat_input=False,
-        dropout_ratio=0.1,
-        num_classes=150,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
-
-# optimizer
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0005),
-    clip_grad=dict(max_norm=1, norm_type=2))
-# learning policy
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0,
-        end=1000),
-    dict(
-        type='MultiStepLR',
-        begin=1000,
-        end=80000,
-        milestones=[60000, 72000],
-        by_epoch=False,
-    )
-]
-# In K-Net implementation we use batch size 2 per GPU as default
-train_dataloader = dict(batch_size=2, num_workers=2)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/knet/knet-s3_r50-d8_fcn_8xb2-adamw-80k_ade20k-512x512.py b/mmsegmentation/configs/knet/knet-s3_r50-d8_fcn_8xb2-adamw-80k_ade20k-512x512.py
deleted file mode 100644
index 497cd04..0000000
--- a/mmsegmentation/configs/knet/knet-s3_r50-d8_fcn_8xb2-adamw-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,112 +0,0 @@
-_base_ = [
-    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    mean=[123.675, 116.28, 103.53],
-    std=[58.395, 57.12, 57.375],
-    bgr_to_rgb=True,
-    pad_val=0,
-    size=crop_size,
-    seg_pad_val=255)
-# model settings
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-num_stages = 3
-conv_kernel_size = 1
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    pretrained='open-mmlab://resnet50_v1c',
-    backbone=dict(
-        type='ResNetV1c',
-        depth=50,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        dilations=(1, 1, 2, 4),
-        strides=(1, 2, 1, 1),
-        norm_cfg=norm_cfg,
-        norm_eval=False,
-        style='pytorch',
-        contract_dilation=True),
-    decode_head=dict(
-        type='IterativeDecodeHead',
-        num_stages=num_stages,
-        kernel_update_head=[
-            dict(
-                type='KernelUpdateHead',
-                num_classes=150,
-                num_ffn_fcs=2,
-                num_heads=8,
-                num_mask_fcs=1,
-                feedforward_channels=2048,
-                in_channels=512,
-                out_channels=512,
-                dropout=0.0,
-                conv_kernel_size=conv_kernel_size,
-                ffn_act_cfg=dict(type='ReLU', inplace=True),
-                with_ffn=True,
-                feat_transform_cfg=dict(
-                    conv_cfg=dict(type='Conv2d'), act_cfg=None),
-                kernel_updator_cfg=dict(
-                    type='KernelUpdator',
-                    in_channels=256,
-                    feat_channels=256,
-                    out_channels=256,
-                    act_cfg=dict(type='ReLU', inplace=True),
-                    norm_cfg=dict(type='LN'))) for _ in range(num_stages)
-        ],
-        kernel_generate_head=dict(
-            type='FCNHead',
-            in_channels=2048,
-            in_index=3,
-            channels=512,
-            num_convs=2,
-            concat_input=True,
-            dropout_ratio=0.1,
-            num_classes=150,
-            norm_cfg=norm_cfg,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))),
-    auxiliary_head=dict(
-        type='FCNHead',
-        in_channels=1024,
-        in_index=2,
-        channels=256,
-        num_convs=1,
-        concat_input=False,
-        dropout_ratio=0.1,
-        num_classes=150,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
-# optimizer
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0005),
-    clip_grad=dict(max_norm=1, norm_type=2))
-
-# learning policy
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0,
-        end=1000),
-    dict(
-        type='MultiStepLR',
-        begin=1000,
-        end=80000,
-        milestones=[60000, 72000],
-        by_epoch=False,
-    )
-]
-# In K-Net implementation we use batch size 2 per GPU as default
-train_dataloader = dict(batch_size=2, num_workers=2)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/knet/knet-s3_r50-d8_pspnet_8xb2-adamw-80k_ade20k-512x512.py b/mmsegmentation/configs/knet/knet-s3_r50-d8_pspnet_8xb2-adamw-80k_ade20k-512x512.py
deleted file mode 100644
index b918671..0000000
--- a/mmsegmentation/configs/knet/knet-s3_r50-d8_pspnet_8xb2-adamw-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,110 +0,0 @@
-_base_ = [
-    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    mean=[123.675, 116.28, 103.53],
-    std=[58.395, 57.12, 57.375],
-    bgr_to_rgb=True,
-    pad_val=0,
-    size=crop_size,
-    seg_pad_val=255)
-# model settings
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-num_stages = 3
-conv_kernel_size = 1
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    pretrained='open-mmlab://resnet50_v1c',
-    backbone=dict(
-        type='ResNetV1c',
-        depth=50,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        dilations=(1, 1, 2, 4),
-        strides=(1, 2, 1, 1),
-        norm_cfg=norm_cfg,
-        norm_eval=False,
-        style='pytorch',
-        contract_dilation=True),
-    decode_head=dict(
-        type='IterativeDecodeHead',
-        num_stages=num_stages,
-        kernel_update_head=[
-            dict(
-                type='KernelUpdateHead',
-                num_classes=150,
-                num_ffn_fcs=2,
-                num_heads=8,
-                num_mask_fcs=1,
-                feedforward_channels=2048,
-                in_channels=512,
-                out_channels=512,
-                dropout=0.0,
-                conv_kernel_size=conv_kernel_size,
-                ffn_act_cfg=dict(type='ReLU', inplace=True),
-                with_ffn=True,
-                feat_transform_cfg=dict(
-                    conv_cfg=dict(type='Conv2d'), act_cfg=None),
-                kernel_updator_cfg=dict(
-                    type='KernelUpdator',
-                    in_channels=256,
-                    feat_channels=256,
-                    out_channels=256,
-                    act_cfg=dict(type='ReLU', inplace=True),
-                    norm_cfg=dict(type='LN'))) for _ in range(num_stages)
-        ],
-        kernel_generate_head=dict(
-            type='PSPHead',
-            in_channels=2048,
-            in_index=3,
-            channels=512,
-            pool_scales=(1, 2, 3, 6),
-            dropout_ratio=0.1,
-            num_classes=150,
-            norm_cfg=norm_cfg,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))),
-    auxiliary_head=dict(
-        type='FCNHead',
-        in_channels=1024,
-        in_index=2,
-        channels=256,
-        num_convs=1,
-        concat_input=False,
-        dropout_ratio=0.1,
-        num_classes=150,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
-# optimizer
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0005),
-    clip_grad=dict(max_norm=1, norm_type=2))
-# learning policy
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0,
-        end=1000),
-    dict(
-        type='MultiStepLR',
-        begin=1000,
-        end=80000,
-        milestones=[60000, 72000],
-        by_epoch=False,
-    )
-]
-# In K-Net implementation we use batch size 2 per GPU as default
-train_dataloader = dict(batch_size=2, num_workers=2)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/knet/knet-s3_r50-d8_upernet_8xb2-adamw-80k_ade20k-512x512.py b/mmsegmentation/configs/knet/knet-s3_r50-d8_upernet_8xb2-adamw-80k_ade20k-512x512.py
deleted file mode 100644
index a0a66c5..0000000
--- a/mmsegmentation/configs/knet/knet-s3_r50-d8_upernet_8xb2-adamw-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,111 +0,0 @@
-_base_ = [
-    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    mean=[123.675, 116.28, 103.53],
-    std=[58.395, 57.12, 57.375],
-    bgr_to_rgb=True,
-    pad_val=0,
-    size=crop_size,
-    seg_pad_val=255)
-# model settings
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-num_stages = 3
-conv_kernel_size = 1
-
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    pretrained='open-mmlab://resnet50_v1c',
-    backbone=dict(
-        type='ResNetV1c',
-        depth=50,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        dilations=(1, 1, 1, 1),
-        strides=(1, 2, 2, 2),
-        norm_cfg=norm_cfg,
-        norm_eval=False,
-        style='pytorch',
-        contract_dilation=True),
-    decode_head=dict(
-        type='IterativeDecodeHead',
-        num_stages=num_stages,
-        kernel_update_head=[
-            dict(
-                type='KernelUpdateHead',
-                num_classes=150,
-                num_ffn_fcs=2,
-                num_heads=8,
-                num_mask_fcs=1,
-                feedforward_channels=2048,
-                in_channels=512,
-                out_channels=512,
-                dropout=0.0,
-                conv_kernel_size=conv_kernel_size,
-                ffn_act_cfg=dict(type='ReLU', inplace=True),
-                with_ffn=True,
-                feat_transform_cfg=dict(
-                    conv_cfg=dict(type='Conv2d'), act_cfg=None),
-                kernel_updator_cfg=dict(
-                    type='KernelUpdator',
-                    in_channels=256,
-                    feat_channels=256,
-                    out_channels=256,
-                    act_cfg=dict(type='ReLU', inplace=True),
-                    norm_cfg=dict(type='LN'))) for _ in range(num_stages)
-        ],
-        kernel_generate_head=dict(
-            type='UPerHead',
-            in_channels=[256, 512, 1024, 2048],
-            in_index=[0, 1, 2, 3],
-            pool_scales=(1, 2, 3, 6),
-            channels=512,
-            dropout_ratio=0.1,
-            num_classes=150,
-            norm_cfg=norm_cfg,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))),
-    auxiliary_head=dict(
-        type='FCNHead',
-        in_channels=1024,
-        in_index=2,
-        channels=256,
-        num_convs=1,
-        concat_input=False,
-        dropout_ratio=0.1,
-        num_classes=150,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
-# optimizer
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0005),
-    clip_grad=dict(max_norm=1, norm_type=2))
-# learning policy
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0,
-        end=1000),
-    dict(
-        type='MultiStepLR',
-        begin=1000,
-        end=80000,
-        milestones=[60000, 72000],
-        by_epoch=False,
-    )
-]
-# In K-Net implementation we use batch size 2 per GPU as default
-train_dataloader = dict(batch_size=2, num_workers=2)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-512x512.py b/mmsegmentation/configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-512x512.py
deleted file mode 100644
index c6f4eb6..0000000
--- a/mmsegmentation/configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,21 +0,0 @@
-_base_ = 'knet-s3_swin-t_upernet_8xb2-adamw-80k_ade20k-512x512.py'
-
-checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_large_patch4_window7_224_22k_20220308-d5bdebaf.pth'  # noqa
-# model settings
-model = dict(
-    pretrained=checkpoint_file,
-    backbone=dict(
-        embed_dims=192,
-        depths=[2, 2, 18, 2],
-        num_heads=[6, 12, 24, 48],
-        window_size=7,
-        use_abs_pos_embed=False,
-        drop_path_rate=0.3,
-        patch_norm=True),
-    decode_head=dict(
-        kernel_generate_head=dict(in_channels=[192, 384, 768, 1536])),
-    auxiliary_head=dict(in_channels=768))
-# In K-Net implementation we use batch size 2 per GPU as default
-train_dataloader = dict(batch_size=2, num_workers=2)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-640x640.py b/mmsegmentation/configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-640x640.py
deleted file mode 100644
index 84c3d8c..0000000
--- a/mmsegmentation/configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-640x640.py
+++ /dev/null
@@ -1,57 +0,0 @@
-_base_ = 'knet-s3_swin-t_upernet_8xb2-adamw-80k_ade20k-512x512.py'
-
-checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_large_patch4_window7_224_22k_20220308-d5bdebaf.pth'  # noqa
-# model settings
-crop_size = (640, 640)
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    mean=[123.675, 116.28, 103.53],
-    std=[58.395, 57.12, 57.375],
-    bgr_to_rgb=True,
-    pad_val=0,
-    size=crop_size,
-    seg_pad_val=255)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained=checkpoint_file,
-    backbone=dict(
-        embed_dims=192,
-        depths=[2, 2, 18, 2],
-        num_heads=[6, 12, 24, 48],
-        window_size=7,
-        use_abs_pos_embed=False,
-        drop_path_rate=0.4,
-        patch_norm=True),
-    decode_head=dict(
-        kernel_generate_head=dict(in_channels=[192, 384, 768, 1536])),
-    auxiliary_head=dict(in_channels=768))
-
-crop_size = (640, 640)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(
-        type='RandomResize',
-        scale=(2048, 640),
-        ratio_range=(0.5, 2.0),
-        keep_ratio=True),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(2048, 640), keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
-val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
-test_dataloader = val_dataloader
-# In K-Net implementation we use batch size 2 per GPU as default
-train_dataloader = dict(batch_size=2, num_workers=2)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/knet/knet-s3_swin-t_upernet_8xb2-adamw-80k_ade20k-512x512.py b/mmsegmentation/configs/knet/knet-s3_swin-t_upernet_8xb2-adamw-80k_ade20k-512x512.py
deleted file mode 100644
index a7acec4..0000000
--- a/mmsegmentation/configs/knet/knet-s3_swin-t_upernet_8xb2-adamw-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,63 +0,0 @@
-_base_ = 'knet-s3_r50-d8_upernet_8xb2-adamw-80k_ade20k-512x512.py'
-
-checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_tiny_patch4_window7_224_20220308-f41b89d3.pth'  # noqa
-
-# model settings
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-num_stages = 3
-conv_kernel_size = 1
-
-model = dict(
-    type='EncoderDecoder',
-    pretrained=checkpoint_file,
-    backbone=dict(
-        _delete_=True,
-        type='SwinTransformer',
-        embed_dims=96,
-        depths=[2, 2, 6, 2],
-        num_heads=[3, 6, 12, 24],
-        window_size=7,
-        mlp_ratio=4,
-        qkv_bias=True,
-        qk_scale=None,
-        drop_rate=0.,
-        attn_drop_rate=0.,
-        drop_path_rate=0.3,
-        use_abs_pos_embed=False,
-        patch_norm=True,
-        out_indices=(0, 1, 2, 3)),
-    decode_head=dict(
-        kernel_generate_head=dict(in_channels=[96, 192, 384, 768])),
-    auxiliary_head=dict(in_channels=384))
-
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    # modify learning rate following the official implementation of Swin Transformer # noqa
-    optimizer=dict(
-        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.0005),
-    paramwise_cfg=dict(
-        custom_keys={
-            'absolute_pos_embed': dict(decay_mult=0.),
-            'relative_position_bias_table': dict(decay_mult=0.),
-            'norm': dict(decay_mult=0.)
-        }),
-    clip_grad=dict(max_norm=1, norm_type=2))
-
-# learning policy
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0,
-        end=1000),
-    dict(
-        type='MultiStepLR',
-        begin=1000,
-        end=80000,
-        milestones=[60000, 72000],
-        by_epoch=False,
-    )
-]
-# In K-Net implementation we use batch size 2 per GPU as default
-train_dataloader = dict(batch_size=2, num_workers=2)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/knet/metafile.yaml b/mmsegmentation/configs/knet/metafile.yaml
deleted file mode 100644
index 0f4ab79..0000000
--- a/mmsegmentation/configs/knet/metafile.yaml
+++ /dev/null
@@ -1,188 +0,0 @@
-Collections:
-- Name: KNet
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - ADE20K
-  Paper:
-    Title: 'K-Net: Towards Unified Image Segmentation'
-    URL: https://arxiv.org/abs/2106.14855
-  README: configs/knet/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: knet-s3_r50-d8_fcn_8xb2-adamw-80k_ade20k-512x512
-  In Collection: KNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 43.6
-      mIoU(ms+flip): 45.12
-  Config: configs/knet/knet-s3_r50-d8_fcn_8xb2-adamw-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - KNet
-    - FCN
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 7.01
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_fcn_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_fcn_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_043751-abcab920.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_fcn_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_fcn_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_043751.log.json
-  Paper:
-    Title: 'K-Net: Towards Unified Image Segmentation'
-    URL: https://arxiv.org/abs/2106.14855
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.23.0/mmseg/models/decode_heads/knet_head.py#L392
-  Framework: PyTorch
-- Name: knet-s3_r50-d8_pspnet_8xb2-adamw-80k_ade20k-512x512
-  In Collection: KNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 44.18
-      mIoU(ms+flip): 45.58
-  Config: configs/knet/knet-s3_r50-d8_pspnet_8xb2-adamw-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - KNet
-    - PSPNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 6.98
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_pspnet_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_pspnet_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_054634-d2c72240.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_pspnet_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_pspnet_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_054634.log.json
-  Paper:
-    Title: 'K-Net: Towards Unified Image Segmentation'
-    URL: https://arxiv.org/abs/2106.14855
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.23.0/mmseg/models/decode_heads/knet_head.py#L392
-  Framework: PyTorch
-- Name: knet-s3_r50-d8_deeplabv3_8xb2-adamw-80k_ade20k-512x512
-  In Collection: KNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 45.06
-      mIoU(ms+flip): 46.11
-  Config: configs/knet/knet-s3_r50-d8_deeplabv3_8xb2-adamw-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - KNet
-    - DeepLabV3
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 7.42
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_deeplabv3_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_deeplabv3_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_041642-00c8fbeb.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_deeplabv3_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_deeplabv3_r50-d8_8x2_512x512_adamw_80k_ade20k_20220228_041642.log.json
-  Paper:
-    Title: 'K-Net: Towards Unified Image Segmentation'
-    URL: https://arxiv.org/abs/2106.14855
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.23.0/mmseg/models/decode_heads/knet_head.py#L392
-  Framework: PyTorch
-- Name: knet-s3_r50-d8_upernet_8xb2-adamw-80k_ade20k-512x512
-  In Collection: KNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 43.45
-      mIoU(ms+flip): 44.07
-  Config: configs/knet/knet-s3_r50-d8_upernet_8xb2-adamw-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - KNet
-    - UperNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 7.34
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_r50-d8_8x2_512x512_adamw_80k_ade20k_20220304_125657-215753b0.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_r50-d8_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_r50-d8_8x2_512x512_adamw_80k_ade20k_20220304_125657.log.json
-  Paper:
-    Title: 'K-Net: Towards Unified Image Segmentation'
-    URL: https://arxiv.org/abs/2106.14855
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.23.0/mmseg/models/decode_heads/knet_head.py#L392
-  Framework: PyTorch
-- Name: knet-s3_swin-t_upernet_8xb2-adamw-80k_ade20k-512x512
-  In Collection: KNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 45.84
-      mIoU(ms+flip): 46.27
-  Config: configs/knet/knet-s3_swin-t_upernet_8xb2-adamw-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - Swin-T
-    - KNet
-    - UperNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 7.57
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-t_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_swin-t_8x2_512x512_adamw_80k_ade20k_20220303_133059-7545e1dc.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-t_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_swin-t_8x2_512x512_adamw_80k_ade20k_20220303_133059.log.json
-  Paper:
-    Title: 'K-Net: Towards Unified Image Segmentation'
-    URL: https://arxiv.org/abs/2106.14855
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.23.0/mmseg/models/decode_heads/knet_head.py#L392
-  Framework: PyTorch
-- Name: knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-512x512
-  In Collection: KNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 52.05
-      mIoU(ms+flip): 53.24
-  Config: configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - Swin-L
-    - KNet
-    - UperNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 13.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-l_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_swin-l_8x2_512x512_adamw_80k_ade20k_20220303_154559-d8da9a90.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-l_8x2_512x512_adamw_80k_ade20k/knet_s3_upernet_swin-l_8x2_512x512_adamw_80k_ade20k_20220303_154559.log.json
-  Paper:
-    Title: 'K-Net: Towards Unified Image Segmentation'
-    URL: https://arxiv.org/abs/2106.14855
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.23.0/mmseg/models/decode_heads/knet_head.py#L392
-  Framework: PyTorch
-- Name: knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-640x640
-  In Collection: KNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 52.21
-      mIoU(ms+flip): 53.34
-  Config: configs/knet/knet-s3_swin-l_upernet_8xb2-adamw-80k_ade20k-640x640.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - Swin-L
-    - KNet
-    - UperNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 13.54
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-l_8x2_640x640_adamw_80k_ade20k/knet_s3_upernet_swin-l_8x2_640x640_adamw_80k_ade20k_20220301_220747-8787fc71.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/knet/knet_s3_upernet_swin-l_8x2_640x640_adamw_80k_ade20k/knet_s3_upernet_swin-l_8x2_640x640_adamw_80k_ade20k_20220301_220747.log.json
-  Paper:
-    Title: 'K-Net: Towards Unified Image Segmentation'
-    URL: https://arxiv.org/abs/2106.14855
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.23.0/mmseg/models/decode_heads/knet_head.py#L392
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/mae/README.md b/mmsegmentation/configs/mae/README.md
deleted file mode 100644
index d14e383..0000000
--- a/mmsegmentation/configs/mae/README.md
+++ /dev/null
@@ -1,82 +0,0 @@
-# MAE
-
-> [Masked Autoencoders Are Scalable Vision Learners](https://arxiv.org/abs/2111.06377)
-
-## Introduction
-
-<!-- [BACKBONE] -->
-
-<a href="https://github.com/facebookresearch/mae">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.24.0/mmseg/models/backbones/mae.py#L46">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-This paper shows that masked autoencoders (MAE) are scalable self-supervised learners for computer vision. Our MAE approach is simple: we mask random patches of the input image and reconstruct the missing pixels. It is based on two core designs. First, we develop an asymmetric encoder-decoder architecture, with an encoder that operates only on the visible subset of patches (without mask tokens), along with a lightweight decoder that reconstructs the original image from the latent representation and mask tokens. Second, we find that masking a high proportion of the input image, e.g., 75%, yields a nontrivial and meaningful self-supervisory task. Coupling these two designs enables us to train large models efficiently and effectively: we accelerate training (by 3x or more) and improve accuracy. Our scalable approach allows for learning high-capacity models that generalize well: e.g., a vanilla ViT-Huge model achieves the best accuracy (87.8%) among methods that use only ImageNet-1K data. Transfer performance in downstream tasks outperforms supervised pre-training and shows promising scaling behavior.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/165456416-1cba54bf-b1b5-4bdf-ad86-d6390de7f342.png" width="70%"/>
-</div>
-
-## Usage
-
-To use other repositories' pre-trained models, it is necessary to convert keys.
-
-We provide a script [`beit2mmseg.py`](../../tools/model_converters/beit2mmseg.py) in the tools directory to convert the key of MAE model from [the official repo](https://github.com/facebookresearch/mae) to MMSegmentation style.
-
-```shell
-python tools/model_converters/beit2mmseg.py ${PRETRAIN_PATH} ${STORE_PATH}
-```
-
-E.g.
-
-```shell
-python tools/model_converters/beit2mmseg.py https://dl.fbaipublicfiles.com/mae/pretrain/mae_pretrain_vit_base.pth pretrain/mae_pretrain_vit_base_mmcls.pth
-```
-
-This script convert model from `PRETRAIN_PATH` and store the converted model in `STORE_PATH`.
-
-In our default setting, pretrained models could be defined below:
-
-| pretrained models               | original models                                                                                  |
-| ------------------------------- | ------------------------------------------------------------------------------------------------ |
-| mae_pretrain_vit_base_mmcls.pth | ['mae_pretrain_vit_base'](https://dl.fbaipublicfiles.com/mae/pretrain/mae_pretrain_vit_base.pth) |
-
-Verify the single-scale results of the model:
-
-```shell
-sh tools/dist_test.sh \
-configs/mae/upernet_mae-base_fp16_8x2_512x512_160k_ade20k.py \
-upernet_mae-base_fp16_8x2_512x512_160k_ade20k_20220426_174752-f92a2975.pth $GPUS --eval mIoU
-```
-
-Since relative position embedding requires the input length and width to be equal, the sliding window is adopted for multi-scale inference. So we set min_size=512, that is, the shortest edge is 512. So the multi-scale inference of config is performed separately, instead of '--aug-test'. For multi-scale inference:
-
-```shell
-sh tools/dist_test.sh \
-configs/mae/upernet_mae-base_fp16_512x512_160k_ade20k_ms.py \
-upernet_mae-base_fp16_8x2_512x512_160k_ade20k_20220426_174752-f92a2975.pth $GPUS --eval mIoU
-```
-
-## Results and models
-
-### ADE20K
-
-| Method  | Backbone | Crop Size | pretrain    | pretrain img size | Batch Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                        | download                                                                                                                                                                                                                                                                                                                                                                       |
-| ------- | -------- | --------- | ----------- | ----------------- | ---------- | ------- | -------- | -------------- | ------ | ----- | ------------: | ----------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| UPerNet | ViT-B    | 512x512   | ImageNet-1K | 224x224           | 16         | 160000  | 9.96     | 7.14           | V100   | 48.13 |         48.70 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mae/upernet_mae-base_fp16_8x2_512x512_160k_ade20k/upernet_mae-base_fp16_8x2_512x512_160k_ade20k_20220426_174752-f92a2975.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mae/upernet_mae-base_fp16_8x2_512x512_160k_ade20k/upernet_mae-base_fp16_8x2_512x512_160k_ade20k_20220426_174752.log.json) |
-
-## Citation
-
-```bibtex
-@article{he2021masked,
-  title={Masked autoencoders are scalable vision learners},
-  author={He, Kaiming and Chen, Xinlei and Xie, Saining and Li, Yanghao and Doll{\'a}r, Piotr and Girshick, Ross},
-  journal={arXiv preprint arXiv:2111.06377},
-  year={2021}
-}
-```
diff --git a/mmsegmentation/configs/mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512-ms.py b/mmsegmentation/configs/mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512-ms.py
deleted file mode 100644
index ec32fea..0000000
--- a/mmsegmentation/configs/mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512-ms.py
+++ /dev/null
@@ -1,16 +0,0 @@
-_base_ = './mae-base_upernet_8xb2-amp-160k_ade20k-512x512.py'
-
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    # TODO: Refactor 'MultiScaleFlipAug' which supports
-    # `min_size` feature in `Resize` class
-    # img_ratios is [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
-    # original image scale is (2048, 512)
-    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='PackSegInputs')
-]
-val_dataloader = dict(batch_size=1, dataset=dict(pipeline=test_pipeline))
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512.py b/mmsegmentation/configs/mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512.py
deleted file mode 100644
index b8eae17..0000000
--- a/mmsegmentation/configs/mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,54 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_mae.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained='./pretrain/mae_pretrain_vit_base_mmcls.pth',
-    backbone=dict(
-        type='MAE',
-        img_size=(512, 512),
-        patch_size=16,
-        embed_dims=768,
-        num_layers=12,
-        num_heads=12,
-        mlp_ratio=4,
-        init_values=1.0,
-        drop_path_rate=0.1,
-        out_indices=[3, 5, 7, 11]),
-    neck=dict(embed_dim=768, rescales=[4, 2, 1, 0.5]),
-    decode_head=dict(
-        in_channels=[768, 768, 768, 768], num_classes=150, channels=768),
-    auxiliary_head=dict(in_channels=768, num_classes=150),
-    test_cfg=dict(mode='slide', crop_size=(512, 512), stride=(341, 341)))
-
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=1e-4, betas=(0.9, 0.999), weight_decay=0.05),
-    paramwise_cfg=dict(num_layers=12, layer_decay_rate=0.65),
-    constructor='LayerDecayOptimizerConstructor')
-
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        eta_min=0.0,
-        power=1.0,
-        begin=1500,
-        end=160000,
-        by_epoch=False,
-    )
-]
-
-# mixed precision
-fp16 = dict(loss_scale='dynamic')
-
-# By default, models are trained on 8 GPUs with 2 images per GPU
-train_dataloader = dict(batch_size=2)
-val_dataloader = dict(batch_size=1)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/mae/metafile.yaml b/mmsegmentation/configs/mae/metafile.yaml
deleted file mode 100644
index 567eafe..0000000
--- a/mmsegmentation/configs/mae/metafile.yaml
+++ /dev/null
@@ -1,25 +0,0 @@
-Models:
-- Name: mae-base_upernet_8xb2-amp-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 48.13
-      mIoU(ms+flip): 48.7
-  Config: configs/mae/mae-base_upernet_8xb2-amp-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - ViT-B
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 9.96
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mae/upernet_mae-base_fp16_8x2_512x512_160k_ade20k/upernet_mae-base_fp16_8x2_512x512_160k_ade20k_20220426_174752-f92a2975.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mae/upernet_mae-base_fp16_8x2_512x512_160k_ade20k/upernet_mae-base_fp16_8x2_512x512_160k_ade20k_20220426_174752.log.json
-  Paper:
-    Title: Masked Autoencoders Are Scalable Vision Learners
-    URL: https://arxiv.org/abs/2111.06377
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.24.0/mmseg/models/backbones/mae.py#L46
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/mask2former/README.md b/mmsegmentation/configs/mask2former/README.md
deleted file mode 100644
index c21ab0d..0000000
--- a/mmsegmentation/configs/mask2former/README.md
+++ /dev/null
@@ -1,74 +0,0 @@
-# Mask2Former
-
-> [Masked-attention Mask Transformer for Universal Image Segmentation](https://arxiv.org/abs/2112.01527)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/facebookresearch/Mask2Former">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Image segmentation is about grouping pixels with different semantics, e.g., category or instance membership, where each choice of semantics defines a task. While only the semantics of each task differ, current research focuses on designing specialized architectures for each task. We present Masked-attention Mask Transformer (Mask2Former), a new architecture capable of addressing any image segmentation task (panoptic, instance or semantic). Its key components include masked attention, which extracts localized features by constraining cross-attention within predicted mask regions. In addition to reducing the research effort by at least three times, it outperforms the best specialized architectures by a significant margin on four popular datasets. Most notably, Mask2Former sets a new state-of-the-art for panoptic segmentation (57.8 PQ on COCO), instance segmentation (50.1 AP on COCO) and semantic segmentation (57.7 mIoU on ADE20K).
-
-### Usage
-
-- Mask2Former model needs to install [MMDetection](https://github.com/open-mmlab/mmdetection) first.
-
-```shell
-pip install "mmdet>=3.0.0rc4"
-```
-
-## Results and models
-
-### Cityscapes
-
-| Method      | Backbone       | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) |                                                                                                                                                    config | download                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| ----------- | -------------- | --------- | ------- | -------: | -------------- | ------ | ----- | ------------: | --------------------------------------------------------------------------------------------------------------------------------------------------------: | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Mask2Former | R-50-D32       | 512x1024  | 90000   |     5.67 | 9.17           | A100   | 80.44 |             - |                      [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_r50_8xb2-90k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r50_8xb2-90k_cityscapes-512x1024/mask2former_r50_8xb2-90k_cityscapes-512x1024_20221202_140802-ffd9d750.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r50_8xb2-90k_cityscapes-512x1024/mask2former_r50_8xb2-90k_cityscapes-512x1024_20221202_140802.json)                                                                                      |
-| Mask2Former | R-101-D32      | 512x1024  | 90000   |     6.81 | 7.11           | A100   | 80.80 |             - |                     [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_r101_8xb2-90k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r101_8xb2-90k_cityscapes-512x1024/mask2former_r101_8xb2-90k_cityscapes-512x1024_20221130_031628-43e68666.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r101_8xb2-90k_cityscapes-512x1024/mask2former_r101_8xb2-90k_cityscapes-512x1024_20221130_031628.json))                                                                                 |
-| Mask2Former | Swin-T         | 512x1024  | 90000   |     6.36 | 7.18           | A100   | 81.71 |             - |                   [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_swin-t_8xb2-90k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-t_8xb2-90k_cityscapes-512x1024/mask2former_swin-t_8xb2-90k_cityscapes-512x1024_20221127_144501-36c59341.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-t_8xb2-90k_cityscapes-512x1024/mask2former_swin-t_8xb2-90k_cityscapes-512x1024_20221127_144501.json))                                                                         |
-| Mask2Former | Swin-S         | 512x1024  | 90000   |     8.09 | 5.57           | A100   | 82.57 |             - |                   [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_swin-s_8xb2-90k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-s_8xb2-90k_cityscapes-512x1024/mask2former_swin-s_8xb2-90k_cityscapes-512x1024_20221127_143802-9ab177f6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-s_8xb2-90k_cityscapes-512x1024/mask2former_swin-s_8xb2-90k_cityscapes-512x1024_20221127_143802.json))                                                                         |
-| Mask2Former | Swin-B (in22k) | 512x1024  | 90000   |    10.89 | 4.32           | A100   | 83.52 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221203_045030-9a86a225.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221203_045030.json)) |
-| Mask2Former | Swin-L (in22k) | 512x1024  | 90000   |    15.83 | 2.86           | A100   | 83.65 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221202_141901-28ad20f1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221202_141901.json)) |
-
-### ADE20K
-
-| Method      | Backbone       | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) |                                                                                                                                                config | download                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| ----------- | -------------- | --------- | ------- | -------: | -------------- | ------ | ----- | ------------: | ----------------------------------------------------------------------------------------------------------------------------------------------------: | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Mask2Former | R-50-D32       | 512x512   | 160000  |     3.31 | 26.59          | A100   | 47.87 |             - |                      [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_r50_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r50_8xb2-160k_ade20k-512x512/mask2former_r50_8xb2-160k_ade20k-512x512_20221204_000055-2d1f55f1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r50_8xb2-160k_ade20k-512x512/mask2former_r50_8xb2-160k_ade20k-512x512_20221204_000055.json))                                                                                     |
-| Mask2Former | R-101-D32      | 512x512   | 160000  |     4.09 | 22.97          | A100   | 48.60 |             - |                     [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_r101_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r101_8xb2-160k_ade20k-512x512/mask2former_r101_8xb2-160k_ade20k-512x512_20221203_233905-b7135890.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r101_8xb2-160k_ade20k-512x512/mask2former_r101_8xb2-160k_ade20k-512x512_20221203_233905.json))                                                                                 |
-| Mask2Former | Swin-T         | 512x512   | 160000  |     3826 | 23.82          | A100   | 48.66 |             - |                   [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_swin-t_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-t_8xb2-160k_ade20k-512x512/mask2former_swin-t_8xb2-160k_ade20k-512x512_20221203_234230-7d64e5dd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-t_8xb2-160k_ade20k-512x512/mask2former_swin-t_8xb2-160k_ade20k-512x512_20221203_234230.json))                                                                         |
-| Mask2Former | Swin-S         | 512x512   | 160000  |     3.74 | 19.69          | A100   | 51.24 |             - |                   [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_swin-s_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-s_8xb2-160k_ade20k-512x512/mask2former_swin-s_8xb2-160k_ade20k-512x512_20221204_143905-e715144e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-s_8xb2-160k_ade20k-512x512/mask2former_swin-s_8xb2-160k_ade20k-512x512_20221204_143905.json))                                                                         |
-| Mask2Former | Swin-B         | 640x640   | 160000  |     5.66 | 12.48          | A100   | 52.44 |             - |  [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640_20221129_125118-a4a086d2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640_20221129_125118.json))     |
-| Mask2Former | Swin-B (in22k) | 640x640   | 160000  |     5.66 | 12.43          | A100   | 53.90 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640_20221203_235230-7ec0f569.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640_20221203_235230.json)) |
-| Mask2Former | Swin-L (in22k) | 640x640   | 160000  |     8.86 | 8.81           | A100   | 56.01 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640_20221203_235933-7120c214.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640_20221203_235933.json)) |
-
-Note:
-
-- All experiments of Mask2Former are implemented with 8 A100 GPUs with 2 samplers per GPU.
-- As mentioned at [the official repo](https://github.com/facebookresearch/Mask2Former/issues/5), the results of Mask2Former are relatively not stable, the result of Mask2Former(swin-s) on ADE20K dataset in the table is the medium result obtained by training 5 times following the suggestion of the author.
-- The ResNet backbones utilized in MaskFormer models are standard `ResNet` rather than `ResNetV1c`.
-- Test time augmentation is not supported in MMSegmentation 1.x version yet, we would add "ms+flip" results as soon as possible.
-
-## Citation
-
-```bibtex
-@inproceedings{cheng2021mask2former,
-  title={Masked-attention Mask Transformer for Universal Image Segmentation},
-  author={Bowen Cheng and Ishan Misra and Alexander G. Schwing and Alexander Kirillov and Rohit Girdhar},
-  journal={CVPR},
-  year={2022}
-}
-@inproceedings{cheng2021maskformer,
-  title={Per-Pixel Classification is Not All You Need for Semantic Segmentation},
-  author={Bowen Cheng and Alexander G. Schwing and Alexander Kirillov},
-  journal={NeurIPS},
-  year={2021}
-}
-```
diff --git a/mmsegmentation/configs/mask2former/mask2former_r101_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/mask2former/mask2former_r101_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 48f6c12..0000000
--- a/mmsegmentation/configs/mask2former/mask2former_r101_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = ['./mask2former_r50_8xb2-160k_ade20k-512x512.py']
-
-model = dict(
-    backbone=dict(
-        depth=101,
-        init_cfg=dict(type='Pretrained',
-                      checkpoint='torchvision://resnet101')))
diff --git a/mmsegmentation/configs/mask2former/mask2former_r101_8xb2-90k_cityscapes-512x1024.py b/mmsegmentation/configs/mask2former/mask2former_r101_8xb2-90k_cityscapes-512x1024.py
deleted file mode 100644
index 275a7da..0000000
--- a/mmsegmentation/configs/mask2former/mask2former_r101_8xb2-90k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = ['./mask2former_r50_8xb2-90k_cityscapes-512x1024.py']
-
-model = dict(
-    backbone=dict(
-        depth=101,
-        init_cfg=dict(type='Pretrained',
-                      checkpoint='torchvision://resnet101')))
diff --git a/mmsegmentation/configs/mask2former/mask2former_r50_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/mask2former/mask2former_r50_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 78cf605..0000000
--- a/mmsegmentation/configs/mask2former/mask2former_r50_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,200 +0,0 @@
-_base_ = ['../_base_/default_runtime.py', '../_base_/datasets/ade20k.py']
-
-custom_imports = dict(imports='mmdet.models', allow_failed_imports=False)
-
-crop_size = (512, 512)
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    mean=[123.675, 116.28, 103.53],
-    std=[58.395, 57.12, 57.375],
-    bgr_to_rgb=True,
-    pad_val=0,
-    seg_pad_val=255,
-    size=crop_size,
-    test_cfg=dict(size_divisor=32))
-num_classes = 150
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        type='ResNet',
-        depth=50,
-        deep_stem=False,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        frozen_stages=-1,
-        norm_cfg=dict(type='SyncBN', requires_grad=False),
-        style='pytorch',
-        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
-    decode_head=dict(
-        type='Mask2FormerHead',
-        in_channels=[256, 512, 1024, 2048],
-        strides=[4, 8, 16, 32],
-        feat_channels=256,
-        out_channels=256,
-        num_classes=num_classes,
-        num_queries=100,
-        num_transformer_feat_level=3,
-        align_corners=False,
-        pixel_decoder=dict(
-            type='mmdet.MSDeformAttnPixelDecoder',
-            num_outs=3,
-            norm_cfg=dict(type='GN', num_groups=32),
-            act_cfg=dict(type='ReLU'),
-            encoder=dict(  # DeformableDetrTransformerEncoder
-                num_layers=6,
-                layer_cfg=dict(  # DeformableDetrTransformerEncoderLayer
-                    self_attn_cfg=dict(  # MultiScaleDeformableAttention
-                        embed_dims=256,
-                        num_heads=8,
-                        num_levels=3,
-                        num_points=4,
-                        im2col_step=64,
-                        dropout=0.0,
-                        batch_first=True,
-                        norm_cfg=None,
-                        init_cfg=None),
-                    ffn_cfg=dict(
-                        embed_dims=256,
-                        feedforward_channels=1024,
-                        num_fcs=2,
-                        ffn_drop=0.0,
-                        act_cfg=dict(type='ReLU', inplace=True))),
-                init_cfg=None),
-            positional_encoding=dict(  # SinePositionalEncoding
-                num_feats=128, normalize=True),
-            init_cfg=None),
-        enforce_decoder_input_project=False,
-        positional_encoding=dict(  # SinePositionalEncoding
-            num_feats=128, normalize=True),
-        transformer_decoder=dict(  # Mask2FormerTransformerDecoder
-            return_intermediate=True,
-            num_layers=9,
-            layer_cfg=dict(  # Mask2FormerTransformerDecoderLayer
-                self_attn_cfg=dict(  # MultiheadAttention
-                    embed_dims=256,
-                    num_heads=8,
-                    attn_drop=0.0,
-                    proj_drop=0.0,
-                    dropout_layer=None,
-                    batch_first=True),
-                cross_attn_cfg=dict(  # MultiheadAttention
-                    embed_dims=256,
-                    num_heads=8,
-                    attn_drop=0.0,
-                    proj_drop=0.0,
-                    dropout_layer=None,
-                    batch_first=True),
-                ffn_cfg=dict(
-                    embed_dims=256,
-                    feedforward_channels=2048,
-                    num_fcs=2,
-                    act_cfg=dict(type='ReLU', inplace=True),
-                    ffn_drop=0.0,
-                    dropout_layer=None,
-                    add_identity=True)),
-            init_cfg=None),
-        loss_cls=dict(
-            type='mmdet.CrossEntropyLoss',
-            use_sigmoid=False,
-            loss_weight=2.0,
-            reduction='mean',
-            class_weight=[1.0] * num_classes + [0.1]),
-        loss_mask=dict(
-            type='mmdet.CrossEntropyLoss',
-            use_sigmoid=True,
-            reduction='mean',
-            loss_weight=5.0),
-        loss_dice=dict(
-            type='mmdet.DiceLoss',
-            use_sigmoid=True,
-            activate=True,
-            reduction='mean',
-            naive_dice=True,
-            eps=1.0,
-            loss_weight=5.0),
-        train_cfg=dict(
-            num_points=12544,
-            oversample_ratio=3.0,
-            importance_sample_ratio=0.75,
-            assigner=dict(
-                type='mmdet.HungarianAssigner',
-                match_costs=[
-                    dict(type='mmdet.ClassificationCost', weight=2.0),
-                    dict(
-                        type='mmdet.CrossEntropyLossCost',
-                        weight=5.0,
-                        use_sigmoid=True),
-                    dict(
-                        type='mmdet.DiceCost',
-                        weight=5.0,
-                        pred_act=True,
-                        eps=1.0)
-                ]),
-            sampler=dict(type='mmdet.MaskPseudoSampler'))),
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
-
-# dataset config
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(
-        type='RandomChoiceResize',
-        scales=[int(512 * x * 0.1) for x in range(5, 21)],
-        resize_type='ResizeShortestEdge',
-        max_size=2048),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(batch_size=2, dataset=dict(pipeline=train_pipeline))
-
-# optimizer
-embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
-optimizer = dict(
-    type='AdamW', lr=0.0001, weight_decay=0.05, eps=1e-8, betas=(0.9, 0.999))
-optim_wrapper = dict(
-    type='OptimWrapper',
-    optimizer=optimizer,
-    clip_grad=dict(max_norm=0.01, norm_type=2),
-    paramwise_cfg=dict(
-        custom_keys={
-            'backbone': dict(lr_mult=0.1, decay_mult=1.0),
-            'query_embed': embed_multi,
-            'query_feat': embed_multi,
-            'level_embed': embed_multi,
-        },
-        norm_decay_mult=0.0))
-# learning policy
-param_scheduler = [
-    dict(
-        type='PolyLR',
-        eta_min=0,
-        power=0.9,
-        begin=0,
-        end=160000,
-        by_epoch=False)
-]
-
-# training schedule for 160k
-train_cfg = dict(
-    type='IterBasedTrainLoop', max_iters=160000, val_interval=5000)
-val_cfg = dict(type='ValLoop')
-test_cfg = dict(type='TestLoop')
-default_hooks = dict(
-    timer=dict(type='IterTimerHook'),
-    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
-    param_scheduler=dict(type='ParamSchedulerHook'),
-    checkpoint=dict(
-        type='CheckpointHook', by_epoch=False, interval=5000,
-        save_best='mIoU'),
-    sampler_seed=dict(type='DistSamplerSeedHook'),
-    visualization=dict(type='SegVisualizationHook'))
-
-# Default setting for scaling LR automatically
-#   - `enable` means enable scaling LR automatically
-#       or not by default.
-#   - `base_batch_size` = (8 GPUs) x (2 samples per GPU).
-auto_scale_lr = dict(enable=False, base_batch_size=16)
diff --git a/mmsegmentation/configs/mask2former/mask2former_r50_8xb2-90k_cityscapes-512x1024.py b/mmsegmentation/configs/mask2former/mask2former_r50_8xb2-90k_cityscapes-512x1024.py
deleted file mode 100644
index d2211b6..0000000
--- a/mmsegmentation/configs/mask2former/mask2former_r50_8xb2-90k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,197 +0,0 @@
-_base_ = ['../_base_/default_runtime.py', '../_base_/datasets/cityscapes.py']
-
-crop_size = (512, 1024)
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    mean=[123.675, 116.28, 103.53],
-    std=[58.395, 57.12, 57.375],
-    bgr_to_rgb=True,
-    pad_val=0,
-    seg_pad_val=255,
-    size=crop_size,
-    test_cfg=dict(size_divisor=32))
-num_classes = 19
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        type='ResNet',
-        depth=50,
-        deep_stem=False,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        frozen_stages=-1,
-        norm_cfg=dict(type='SyncBN', requires_grad=False),
-        style='pytorch',
-        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
-    decode_head=dict(
-        type='Mask2FormerHead',
-        in_channels=[256, 512, 1024, 2048],
-        strides=[4, 8, 16, 32],
-        feat_channels=256,
-        out_channels=256,
-        num_classes=num_classes,
-        num_queries=100,
-        num_transformer_feat_level=3,
-        align_corners=False,
-        pixel_decoder=dict(
-            type='mmdet.MSDeformAttnPixelDecoder',
-            num_outs=3,
-            norm_cfg=dict(type='GN', num_groups=32),
-            act_cfg=dict(type='ReLU'),
-            encoder=dict(  # DeformableDetrTransformerEncoder
-                num_layers=6,
-                layer_cfg=dict(  # DeformableDetrTransformerEncoderLayer
-                    self_attn_cfg=dict(  # MultiScaleDeformableAttention
-                        embed_dims=256,
-                        num_heads=8,
-                        num_levels=3,
-                        num_points=4,
-                        im2col_step=64,
-                        dropout=0.0,
-                        batch_first=True,
-                        norm_cfg=None,
-                        init_cfg=None),
-                    ffn_cfg=dict(
-                        embed_dims=256,
-                        feedforward_channels=1024,
-                        num_fcs=2,
-                        ffn_drop=0.0,
-                        act_cfg=dict(type='ReLU', inplace=True))),
-                init_cfg=None),
-            positional_encoding=dict(  # SinePositionalEncoding
-                num_feats=128, normalize=True),
-            init_cfg=None),
-        enforce_decoder_input_project=False,
-        positional_encoding=dict(  # SinePositionalEncoding
-            num_feats=128, normalize=True),
-        transformer_decoder=dict(  # Mask2FormerTransformerDecoder
-            return_intermediate=True,
-            num_layers=9,
-            layer_cfg=dict(  # Mask2FormerTransformerDecoderLayer
-                self_attn_cfg=dict(  # MultiheadAttention
-                    embed_dims=256,
-                    num_heads=8,
-                    attn_drop=0.0,
-                    proj_drop=0.0,
-                    dropout_layer=None,
-                    batch_first=True),
-                cross_attn_cfg=dict(  # MultiheadAttention
-                    embed_dims=256,
-                    num_heads=8,
-                    attn_drop=0.0,
-                    proj_drop=0.0,
-                    dropout_layer=None,
-                    batch_first=True),
-                ffn_cfg=dict(
-                    embed_dims=256,
-                    feedforward_channels=2048,
-                    num_fcs=2,
-                    act_cfg=dict(type='ReLU', inplace=True),
-                    ffn_drop=0.0,
-                    dropout_layer=None,
-                    add_identity=True)),
-            init_cfg=None),
-        loss_cls=dict(
-            type='mmdet.CrossEntropyLoss',
-            use_sigmoid=False,
-            loss_weight=2.0,
-            reduction='mean',
-            class_weight=[1.0] * num_classes + [0.1]),
-        loss_mask=dict(
-            type='mmdet.CrossEntropyLoss',
-            use_sigmoid=True,
-            reduction='mean',
-            loss_weight=5.0),
-        loss_dice=dict(
-            type='mmdet.DiceLoss',
-            use_sigmoid=True,
-            activate=True,
-            reduction='mean',
-            naive_dice=True,
-            eps=1.0,
-            loss_weight=5.0),
-        train_cfg=dict(
-            num_points=12544,
-            oversample_ratio=3.0,
-            importance_sample_ratio=0.75,
-            assigner=dict(
-                type='mmdet.HungarianAssigner',
-                match_costs=[
-                    dict(type='mmdet.ClassificationCost', weight=2.0),
-                    dict(
-                        type='mmdet.CrossEntropyLossCost',
-                        weight=5.0,
-                        use_sigmoid=True),
-                    dict(
-                        type='mmdet.DiceCost',
-                        weight=5.0,
-                        pred_act=True,
-                        eps=1.0)
-                ]),
-            sampler=dict(type='mmdet.MaskPseudoSampler'))),
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
-
-# dataset config
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(
-        type='RandomChoiceResize',
-        scales=[int(1024 * x * 0.1) for x in range(5, 21)],
-        resize_type='ResizeShortestEdge',
-        max_size=4096),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
-
-# optimizer
-embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
-optimizer = dict(
-    type='AdamW', lr=0.0001, weight_decay=0.05, eps=1e-8, betas=(0.9, 0.999))
-optim_wrapper = dict(
-    type='OptimWrapper',
-    optimizer=optimizer,
-    clip_grad=dict(max_norm=0.01, norm_type=2),
-    paramwise_cfg=dict(
-        custom_keys={
-            'backbone': dict(lr_mult=0.1, decay_mult=1.0),
-            'query_embed': embed_multi,
-            'query_feat': embed_multi,
-            'level_embed': embed_multi,
-        },
-        norm_decay_mult=0.0))
-# learning policy
-param_scheduler = [
-    dict(
-        type='PolyLR',
-        eta_min=0,
-        power=0.9,
-        begin=0,
-        end=90000,
-        by_epoch=False)
-]
-
-# training schedule for 90k
-train_cfg = dict(type='IterBasedTrainLoop', max_iters=90000, val_interval=5000)
-val_cfg = dict(type='ValLoop')
-test_cfg = dict(type='TestLoop')
-default_hooks = dict(
-    timer=dict(type='IterTimerHook'),
-    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
-    param_scheduler=dict(type='ParamSchedulerHook'),
-    checkpoint=dict(
-        type='CheckpointHook', by_epoch=False, interval=5000,
-        save_best='mIoU'),
-    sampler_seed=dict(type='DistSamplerSeedHook'),
-    visualization=dict(type='SegVisualizationHook'))
-
-# Default setting for scaling LR automatically
-#   - `enable` means enable scaling LR automatically
-#       or not by default.
-#   - `base_batch_size` = (8 GPUs) x (2 samples per GPU).
-auto_scale_lr = dict(enable=False, base_batch_size=16)
diff --git a/mmsegmentation/configs/mask2former/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640.py b/mmsegmentation/configs/mask2former/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640.py
deleted file mode 100644
index b8b1d6c..0000000
--- a/mmsegmentation/configs/mask2former/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640.py
+++ /dev/null
@@ -1,229 +0,0 @@
-_base_ = [
-    '../_base_/default_runtime.py', '../_base_/datasets/ade20k_640x640.py'
-]
-
-pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_base_patch4_window12_384_20220317-55b0104a.pth'  # noqa
-
-crop_size = (640, 640)
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    mean=[123.675, 116.28, 103.53],
-    std=[58.395, 57.12, 57.375],
-    bgr_to_rgb=True,
-    pad_val=0,
-    seg_pad_val=255,
-    size=crop_size)
-num_classes = 150
-
-depths = [2, 2, 18, 2]
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        type='SwinTransformer',
-        pretrain_img_size=384,
-        embed_dims=128,
-        depths=depths,
-        num_heads=[4, 8, 16, 32],
-        window_size=12,
-        mlp_ratio=4,
-        qkv_bias=True,
-        qk_scale=None,
-        drop_rate=0.,
-        attn_drop_rate=0.,
-        drop_path_rate=0.3,
-        patch_norm=True,
-        out_indices=(0, 1, 2, 3),
-        with_cp=False,
-        frozen_stages=-1,
-        init_cfg=dict(type='Pretrained', checkpoint=pretrained)),
-    decode_head=dict(
-        type='Mask2FormerHead',
-        in_channels=[128, 256, 512, 1024],
-        strides=[4, 8, 16, 32],
-        feat_channels=256,
-        out_channels=256,
-        num_classes=num_classes,
-        num_queries=100,
-        num_transformer_feat_level=3,
-        align_corners=False,
-        pixel_decoder=dict(
-            type='mmdet.MSDeformAttnPixelDecoder',
-            num_outs=3,
-            norm_cfg=dict(type='GN', num_groups=32),
-            act_cfg=dict(type='ReLU'),
-            encoder=dict(  # DeformableDetrTransformerEncoder
-                num_layers=6,
-                layer_cfg=dict(  # DeformableDetrTransformerEncoderLayer
-                    self_attn_cfg=dict(  # MultiScaleDeformableAttention
-                        embed_dims=256,
-                        num_heads=8,
-                        num_levels=3,
-                        num_points=4,
-                        im2col_step=64,
-                        dropout=0.0,
-                        batch_first=True,
-                        norm_cfg=None,
-                        init_cfg=None),
-                    ffn_cfg=dict(
-                        embed_dims=256,
-                        feedforward_channels=1024,
-                        num_fcs=2,
-                        ffn_drop=0.0,
-                        act_cfg=dict(type='ReLU', inplace=True))),
-                init_cfg=None),
-            positional_encoding=dict(  # SinePositionalEncoding
-                num_feats=128, normalize=True),
-            init_cfg=None),
-        enforce_decoder_input_project=False,
-        positional_encoding=dict(  # SinePositionalEncoding
-            num_feats=128, normalize=True),
-        transformer_decoder=dict(  # Mask2FormerTransformerDecoder
-            return_intermediate=True,
-            num_layers=9,
-            layer_cfg=dict(  # Mask2FormerTransformerDecoderLayer
-                self_attn_cfg=dict(  # MultiheadAttention
-                    embed_dims=256,
-                    num_heads=8,
-                    attn_drop=0.0,
-                    proj_drop=0.0,
-                    dropout_layer=None,
-                    batch_first=True),
-                cross_attn_cfg=dict(  # MultiheadAttention
-                    embed_dims=256,
-                    num_heads=8,
-                    attn_drop=0.0,
-                    proj_drop=0.0,
-                    dropout_layer=None,
-                    batch_first=True),
-                ffn_cfg=dict(
-                    embed_dims=256,
-                    feedforward_channels=2048,
-                    num_fcs=2,
-                    act_cfg=dict(type='ReLU', inplace=True),
-                    ffn_drop=0.0,
-                    dropout_layer=None,
-                    add_identity=True)),
-            init_cfg=None),
-        loss_cls=dict(
-            type='mmdet.CrossEntropyLoss',
-            use_sigmoid=False,
-            loss_weight=2.0,
-            reduction='mean',
-            class_weight=[1.0] * num_classes + [0.1]),
-        loss_mask=dict(
-            type='mmdet.CrossEntropyLoss',
-            use_sigmoid=True,
-            reduction='mean',
-            loss_weight=5.0),
-        loss_dice=dict(
-            type='mmdet.DiceLoss',
-            use_sigmoid=True,
-            activate=True,
-            reduction='mean',
-            naive_dice=True,
-            eps=1.0,
-            loss_weight=5.0),
-        train_cfg=dict(
-            num_points=12544,
-            oversample_ratio=3.0,
-            importance_sample_ratio=0.75,
-            assigner=dict(
-                type='mmdet.HungarianAssigner',
-                match_costs=[
-                    dict(type='mmdet.ClassificationCost', weight=2.0),
-                    dict(
-                        type='mmdet.CrossEntropyLossCost',
-                        weight=5.0,
-                        use_sigmoid=True),
-                    dict(
-                        type='mmdet.DiceCost',
-                        weight=5.0,
-                        pred_act=True,
-                        eps=1.0)
-                ]),
-            sampler=dict(type='mmdet.MaskPseudoSampler'))),
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
-
-# dataset config
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(
-        type='RandomChoiceResize',
-        scales=[int(x * 0.1 * 640) for x in range(5, 21)],
-        resize_type='ResizeShortestEdge',
-        max_size=2560),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(batch_size=2, dataset=dict(pipeline=train_pipeline))
-
-# set all layers in backbone to lr_mult=0.1
-# set all norm layers, position_embeding,
-# query_embeding, level_embeding to decay_multi=0.0
-backbone_norm_multi = dict(lr_mult=0.1, decay_mult=0.0)
-backbone_embed_multi = dict(lr_mult=0.1, decay_mult=0.0)
-embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
-custom_keys = {
-    'backbone': dict(lr_mult=0.1, decay_mult=1.0),
-    'backbone.patch_embed.norm': backbone_norm_multi,
-    'backbone.norm': backbone_norm_multi,
-    'absolute_pos_embed': backbone_embed_multi,
-    'relative_position_bias_table': backbone_embed_multi,
-    'query_embed': embed_multi,
-    'query_feat': embed_multi,
-    'level_embed': embed_multi
-}
-custom_keys.update({
-    f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi
-    for stage_id, num_blocks in enumerate(depths)
-    for block_id in range(num_blocks)
-})
-custom_keys.update({
-    f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi
-    for stage_id in range(len(depths) - 1)
-})
-# optimizer
-optimizer = dict(
-    type='AdamW', lr=0.0001, weight_decay=0.05, eps=1e-8, betas=(0.9, 0.999))
-optim_wrapper = dict(
-    type='OptimWrapper',
-    optimizer=optimizer,
-    clip_grad=dict(max_norm=0.01, norm_type=2),
-    paramwise_cfg=dict(custom_keys=custom_keys, norm_decay_mult=0.0))
-
-# learning policy
-param_scheduler = [
-    dict(
-        type='PolyLR',
-        eta_min=0,
-        power=0.9,
-        begin=0,
-        end=160000,
-        by_epoch=False)
-]
-
-# training schedule for 160k
-train_cfg = dict(
-    type='IterBasedTrainLoop', max_iters=160000, val_interval=5000)
-val_cfg = dict(type='ValLoop')
-test_cfg = dict(type='TestLoop')
-default_hooks = dict(
-    timer=dict(type='IterTimerHook'),
-    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
-    param_scheduler=dict(type='ParamSchedulerHook'),
-    checkpoint=dict(
-        type='CheckpointHook', by_epoch=False, interval=5000,
-        save_best='mIoU'),
-    sampler_seed=dict(type='DistSamplerSeedHook'),
-    visualization=dict(type='SegVisualizationHook'))
-
-# Default setting for scaling LR automatically
-#   - `enable` means enable scaling LR automatically
-#       or not by default.
-#   - `base_batch_size` = (8 GPUs) x (2 samples per GPU).
-auto_scale_lr = dict(enable=False, base_batch_size=16)
diff --git a/mmsegmentation/configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py b/mmsegmentation/configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py
deleted file mode 100644
index f39a3c5..0000000
--- a/mmsegmentation/configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py
+++ /dev/null
@@ -1,5 +0,0 @@
-_base_ = ['./mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640.py']
-
-pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_base_patch4_window12_384_22k_20220317-e5c09f74.pth'  # noqa
-model = dict(
-    backbone=dict(init_cfg=dict(type='Pretrained', checkpoint=pretrained)))
diff --git a/mmsegmentation/configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py b/mmsegmentation/configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py
deleted file mode 100644
index 0c229c1..0000000
--- a/mmsegmentation/configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,42 +0,0 @@
-_base_ = ['./mask2former_swin-t_8xb2-90k_cityscapes-512x1024.py']
-pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_base_patch4_window12_384_22k_20220317-e5c09f74.pth'  # noqa
-
-depths = [2, 2, 18, 2]
-model = dict(
-    backbone=dict(
-        pretrain_img_size=384,
-        embed_dims=128,
-        depths=depths,
-        num_heads=[4, 8, 16, 32],
-        window_size=12,
-        init_cfg=dict(type='Pretrained', checkpoint=pretrained)),
-    decode_head=dict(in_channels=[128, 256, 512, 1024]))
-
-# set all layers in backbone to lr_mult=0.1
-# set all norm layers, position_embeding,
-# query_embeding, level_embeding to decay_multi=0.0
-backbone_norm_multi = dict(lr_mult=0.1, decay_mult=0.0)
-backbone_embed_multi = dict(lr_mult=0.1, decay_mult=0.0)
-embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
-custom_keys = {
-    'backbone': dict(lr_mult=0.1, decay_mult=1.0),
-    'backbone.patch_embed.norm': backbone_norm_multi,
-    'backbone.norm': backbone_norm_multi,
-    'absolute_pos_embed': backbone_embed_multi,
-    'relative_position_bias_table': backbone_embed_multi,
-    'query_embed': embed_multi,
-    'query_feat': embed_multi,
-    'level_embed': embed_multi
-}
-custom_keys.update({
-    f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi
-    for stage_id, num_blocks in enumerate(depths)
-    for block_id in range(num_blocks)
-})
-custom_keys.update({
-    f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi
-    for stage_id in range(len(depths) - 1)
-})
-# optimizer
-optim_wrapper = dict(
-    paramwise_cfg=dict(custom_keys=custom_keys, norm_decay_mult=0.0))
diff --git a/mmsegmentation/configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py b/mmsegmentation/configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py
deleted file mode 100644
index f2657e8..0000000
--- a/mmsegmentation/configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = ['./mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640.py']
-pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_large_patch4_window12_384_22k_20220412-6580f57d.pth'  # noqa
-
-model = dict(
-    backbone=dict(
-        embed_dims=192,
-        num_heads=[6, 12, 24, 48],
-        init_cfg=dict(type='Pretrained', checkpoint=pretrained)),
-    decode_head=dict(num_queries=100, in_channels=[192, 384, 768, 1536]))
diff --git a/mmsegmentation/configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py b/mmsegmentation/configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py
deleted file mode 100644
index 01a7b99..0000000
--- a/mmsegmentation/configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,42 +0,0 @@
-_base_ = ['./mask2former_swin-t_8xb2-90k_cityscapes-512x1024.py']
-pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_large_patch4_window12_384_22k_20220412-6580f57d.pth'  # noqa
-
-depths = [2, 2, 18, 2]
-model = dict(
-    backbone=dict(
-        pretrain_img_size=384,
-        embed_dims=192,
-        depths=depths,
-        num_heads=[6, 12, 24, 48],
-        window_size=12,
-        init_cfg=dict(type='Pretrained', checkpoint=pretrained)),
-    decode_head=dict(in_channels=[192, 384, 768, 1536]))
-
-# set all layers in backbone to lr_mult=0.1
-# set all norm layers, position_embeding,
-# query_embeding, level_embeding to decay_multi=0.0
-backbone_norm_multi = dict(lr_mult=0.1, decay_mult=0.0)
-backbone_embed_multi = dict(lr_mult=0.1, decay_mult=0.0)
-embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
-custom_keys = {
-    'backbone': dict(lr_mult=0.1, decay_mult=1.0),
-    'backbone.patch_embed.norm': backbone_norm_multi,
-    'backbone.norm': backbone_norm_multi,
-    'absolute_pos_embed': backbone_embed_multi,
-    'relative_position_bias_table': backbone_embed_multi,
-    'query_embed': embed_multi,
-    'query_feat': embed_multi,
-    'level_embed': embed_multi
-}
-custom_keys.update({
-    f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi
-    for stage_id, num_blocks in enumerate(depths)
-    for block_id in range(num_blocks)
-})
-custom_keys.update({
-    f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi
-    for stage_id in range(len(depths) - 1)
-})
-# optimizer
-optim_wrapper = dict(
-    paramwise_cfg=dict(custom_keys=custom_keys, norm_decay_mult=0.0))
diff --git a/mmsegmentation/configs/mask2former/mask2former_swin-s_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/mask2former/mask2former_swin-s_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index a7796d5..0000000
--- a/mmsegmentation/configs/mask2former/mask2former_swin-s_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,37 +0,0 @@
-_base_ = ['./mask2former_swin-t_8xb2-160k_ade20k-512x512.py']
-pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_small_patch4_window7_224_20220317-7ba6d6dd.pth'  # noqa
-
-depths = [2, 2, 18, 2]
-model = dict(
-    backbone=dict(
-        depths=depths, init_cfg=dict(type='Pretrained',
-                                     checkpoint=pretrained)))
-
-# set all layers in backbone to lr_mult=0.1
-# set all norm layers, position_embeding,
-# query_embeding, level_embeding to decay_multi=0.0
-backbone_norm_multi = dict(lr_mult=0.1, decay_mult=0.0)
-backbone_embed_multi = dict(lr_mult=0.1, decay_mult=0.0)
-embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
-custom_keys = {
-    'backbone': dict(lr_mult=0.1, decay_mult=1.0),
-    'backbone.patch_embed.norm': backbone_norm_multi,
-    'backbone.norm': backbone_norm_multi,
-    'absolute_pos_embed': backbone_embed_multi,
-    'relative_position_bias_table': backbone_embed_multi,
-    'query_embed': embed_multi,
-    'query_feat': embed_multi,
-    'level_embed': embed_multi
-}
-custom_keys.update({
-    f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi
-    for stage_id, num_blocks in enumerate(depths)
-    for block_id in range(num_blocks)
-})
-custom_keys.update({
-    f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi
-    for stage_id in range(len(depths) - 1)
-})
-# optimizer
-optim_wrapper = dict(
-    paramwise_cfg=dict(custom_keys=custom_keys, norm_decay_mult=0.0))
diff --git a/mmsegmentation/configs/mask2former/mask2former_swin-s_8xb2-90k_cityscapes-512x1024.py b/mmsegmentation/configs/mask2former/mask2former_swin-s_8xb2-90k_cityscapes-512x1024.py
deleted file mode 100644
index 5f75544..0000000
--- a/mmsegmentation/configs/mask2former/mask2former_swin-s_8xb2-90k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,37 +0,0 @@
-_base_ = ['./mask2former_swin-t_8xb2-90k_cityscapes-512x1024.py']
-pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_small_patch4_window7_224_20220317-7ba6d6dd.pth'  # noqa
-
-depths = [2, 2, 18, 2]
-model = dict(
-    backbone=dict(
-        depths=depths, init_cfg=dict(type='Pretrained',
-                                     checkpoint=pretrained)))
-
-# set all layers in backbone to lr_mult=0.1
-# set all norm layers, position_embeding,
-# query_embeding, level_embeding to decay_multi=0.0
-backbone_norm_multi = dict(lr_mult=0.1, decay_mult=0.0)
-backbone_embed_multi = dict(lr_mult=0.1, decay_mult=0.0)
-embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
-custom_keys = {
-    'backbone': dict(lr_mult=0.1, decay_mult=1.0),
-    'backbone.patch_embed.norm': backbone_norm_multi,
-    'backbone.norm': backbone_norm_multi,
-    'absolute_pos_embed': backbone_embed_multi,
-    'relative_position_bias_table': backbone_embed_multi,
-    'query_embed': embed_multi,
-    'query_feat': embed_multi,
-    'level_embed': embed_multi
-}
-custom_keys.update({
-    f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi
-    for stage_id, num_blocks in enumerate(depths)
-    for block_id in range(num_blocks)
-})
-custom_keys.update({
-    f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi
-    for stage_id in range(len(depths) - 1)
-})
-# optimizer
-optim_wrapper = dict(
-    paramwise_cfg=dict(custom_keys=custom_keys, norm_decay_mult=0.0))
diff --git a/mmsegmentation/configs/mask2former/mask2former_swin-t_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/mask2former/mask2former_swin-t_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 9de3d24..0000000
--- a/mmsegmentation/configs/mask2former/mask2former_swin-t_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,52 +0,0 @@
-_base_ = ['./mask2former_r50_8xb2-160k_ade20k-512x512.py']
-pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_tiny_patch4_window7_224_20220317-1cdeb081.pth'  # noqa
-depths = [2, 2, 6, 2]
-model = dict(
-    backbone=dict(
-        _delete_=True,
-        type='SwinTransformer',
-        embed_dims=96,
-        depths=depths,
-        num_heads=[3, 6, 12, 24],
-        window_size=7,
-        mlp_ratio=4,
-        qkv_bias=True,
-        qk_scale=None,
-        drop_rate=0.,
-        attn_drop_rate=0.,
-        drop_path_rate=0.3,
-        patch_norm=True,
-        out_indices=(0, 1, 2, 3),
-        with_cp=False,
-        frozen_stages=-1,
-        init_cfg=dict(type='Pretrained', checkpoint=pretrained)),
-    decode_head=dict(in_channels=[96, 192, 384, 768]))
-
-# set all layers in backbone to lr_mult=0.1
-# set all norm layers, position_embeding,
-# query_embeding, level_embeding to decay_multi=0.0
-backbone_norm_multi = dict(lr_mult=0.1, decay_mult=0.0)
-backbone_embed_multi = dict(lr_mult=0.1, decay_mult=0.0)
-embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
-custom_keys = {
-    'backbone': dict(lr_mult=0.1, decay_mult=1.0),
-    'backbone.patch_embed.norm': backbone_norm_multi,
-    'backbone.norm': backbone_norm_multi,
-    'absolute_pos_embed': backbone_embed_multi,
-    'relative_position_bias_table': backbone_embed_multi,
-    'query_embed': embed_multi,
-    'query_feat': embed_multi,
-    'level_embed': embed_multi
-}
-custom_keys.update({
-    f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi
-    for stage_id, num_blocks in enumerate(depths)
-    for block_id in range(num_blocks)
-})
-custom_keys.update({
-    f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi
-    for stage_id in range(len(depths) - 1)
-})
-# optimizer
-optim_wrapper = dict(
-    paramwise_cfg=dict(custom_keys=custom_keys, norm_decay_mult=0.0))
diff --git a/mmsegmentation/configs/mask2former/mask2former_swin-t_8xb2-90k_cityscapes-512x1024.py b/mmsegmentation/configs/mask2former/mask2former_swin-t_8xb2-90k_cityscapes-512x1024.py
deleted file mode 100644
index 0abda64..0000000
--- a/mmsegmentation/configs/mask2former/mask2former_swin-t_8xb2-90k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,52 +0,0 @@
-_base_ = ['./mask2former_r50_8xb2-90k_cityscapes-512x1024.py']
-pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_tiny_patch4_window7_224_20220317-1cdeb081.pth'  # noqa
-depths = [2, 2, 6, 2]
-model = dict(
-    backbone=dict(
-        _delete_=True,
-        type='SwinTransformer',
-        embed_dims=96,
-        depths=depths,
-        num_heads=[3, 6, 12, 24],
-        window_size=7,
-        mlp_ratio=4,
-        qkv_bias=True,
-        qk_scale=None,
-        drop_rate=0.,
-        attn_drop_rate=0.,
-        drop_path_rate=0.3,
-        patch_norm=True,
-        out_indices=(0, 1, 2, 3),
-        with_cp=False,
-        frozen_stages=-1,
-        init_cfg=dict(type='Pretrained', checkpoint=pretrained)),
-    decode_head=dict(in_channels=[96, 192, 384, 768]))
-
-# set all layers in backbone to lr_mult=0.1
-# set all norm layers, position_embeding,
-# query_embeding, level_embeding to decay_multi=0.0
-backbone_norm_multi = dict(lr_mult=0.1, decay_mult=0.0)
-backbone_embed_multi = dict(lr_mult=0.1, decay_mult=0.0)
-embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
-custom_keys = {
-    'backbone': dict(lr_mult=0.1, decay_mult=1.0),
-    'backbone.patch_embed.norm': backbone_norm_multi,
-    'backbone.norm': backbone_norm_multi,
-    'absolute_pos_embed': backbone_embed_multi,
-    'relative_position_bias_table': backbone_embed_multi,
-    'query_embed': embed_multi,
-    'query_feat': embed_multi,
-    'level_embed': embed_multi
-}
-custom_keys.update({
-    f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi
-    for stage_id, num_blocks in enumerate(depths)
-    for block_id in range(num_blocks)
-})
-custom_keys.update({
-    f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi
-    for stage_id in range(len(depths) - 1)
-})
-# optimizer
-optim_wrapper = dict(
-    paramwise_cfg=dict(custom_keys=custom_keys, norm_decay_mult=0.0))
diff --git a/mmsegmentation/configs/mask2former/metafile.yaml b/mmsegmentation/configs/mask2former/metafile.yaml
deleted file mode 100644
index 090c95e..0000000
--- a/mmsegmentation/configs/mask2former/metafile.yaml
+++ /dev/null
@@ -1,314 +0,0 @@
-Collections:
-- Name: Mask2Former
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Usage
-    - Cityscapes
-    - ADE20K
-  Paper:
-    Title: Masked-attention Mask Transformer for Universal Image Segmentation
-    URL: https://arxiv.org/abs/2112.01527
-  README: configs/mask2former/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: mask2former_r50_8xb2-90k_cityscapes-512x1024
-  In Collection: Mask2Former
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 80.44
-  Config: configs/mask2former/mask2former_r50_8xb2-90k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 16
-    Architecture:
-    - R-50-D32
-    - Mask2Former
-    Training Resources: 8x A100 GPUS
-    Memory (GB): 5.67
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r50_8xb2-90k_cityscapes-512x1024/mask2former_r50_8xb2-90k_cityscapes-512x1024_20221202_140802-ffd9d750.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r50_8xb2-90k_cityscapes-512x1024/mask2former_r50_8xb2-90k_cityscapes-512x1024_20221202_140802.json
-  Paper:
-    Title: Masked-attention Mask Transformer for Universal Image Segmentation
-    URL: https://arxiv.org/abs/2112.01527
-  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
-  Framework: PyTorch
-- Name: mask2former_r101_8xb2-90k_cityscapes-512x1024
-  In Collection: Mask2Former
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 80.8
-  Config: configs/mask2former/mask2former_r101_8xb2-90k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 16
-    Architecture:
-    - R-101-D32
-    - Mask2Former
-    Training Resources: 8x A100 GPUS
-    Memory (GB): 6.81
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r101_8xb2-90k_cityscapes-512x1024/mask2former_r101_8xb2-90k_cityscapes-512x1024_20221130_031628-43e68666.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r101_8xb2-90k_cityscapes-512x1024/mask2former_r101_8xb2-90k_cityscapes-512x1024_20221130_031628.json
-  Paper:
-    Title: Masked-attention Mask Transformer for Universal Image Segmentation
-    URL: https://arxiv.org/abs/2112.01527
-  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
-  Framework: PyTorch
-- Name: mask2former_swin-t_8xb2-90k_cityscapes-512x1024
-  In Collection: Mask2Former
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 81.71
-  Config: configs/mask2former/mask2former_swin-t_8xb2-90k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 16
-    Architecture:
-    - Swin-T
-    - Mask2Former
-    Training Resources: 8x A100 GPUS
-    Memory (GB): 6.36
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-t_8xb2-90k_cityscapes-512x1024/mask2former_swin-t_8xb2-90k_cityscapes-512x1024_20221127_144501-36c59341.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-t_8xb2-90k_cityscapes-512x1024/mask2former_swin-t_8xb2-90k_cityscapes-512x1024_20221127_144501.json
-  Paper:
-    Title: Masked-attention Mask Transformer for Universal Image Segmentation
-    URL: https://arxiv.org/abs/2112.01527
-  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
-  Framework: PyTorch
-- Name: mask2former_swin-s_8xb2-90k_cityscapes-512x1024
-  In Collection: Mask2Former
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 82.57
-  Config: configs/mask2former/mask2former_swin-s_8xb2-90k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 16
-    Architecture:
-    - Swin-S
-    - Mask2Former
-    Training Resources: 8x A100 GPUS
-    Memory (GB): 8.09
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-s_8xb2-90k_cityscapes-512x1024/mask2former_swin-s_8xb2-90k_cityscapes-512x1024_20221127_143802-9ab177f6.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-s_8xb2-90k_cityscapes-512x1024/mask2former_swin-s_8xb2-90k_cityscapes-512x1024_20221127_143802.json
-  Paper:
-    Title: Masked-attention Mask Transformer for Universal Image Segmentation
-    URL: https://arxiv.org/abs/2112.01527
-  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
-  Framework: PyTorch
-- Name: mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024
-  In Collection: Mask2Former
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 83.52
-  Config: configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 16
-    Architecture:
-    - Swin-B
-    - Mask2Former
-    Training Resources: 8x A100 GPUS
-    Memory (GB): 10.89
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221203_045030-9a86a225.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-b-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221203_045030.json
-  Paper:
-    Title: Masked-attention Mask Transformer for Universal Image Segmentation
-    URL: https://arxiv.org/abs/2112.01527
-  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
-  Framework: PyTorch
-- Name: mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024
-  In Collection: Mask2Former
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 83.65
-  Config: configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 16
-    Architecture:
-    - Swin-L
-    - Mask2Former
-    Training Resources: 8x A100 GPUS
-    Memory (GB): 15.83
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221202_141901-28ad20f1.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024/mask2former_swin-l-in22k-384x384-pre_8xb2-90k_cityscapes-512x1024_20221202_141901.json
-  Paper:
-    Title: Masked-attention Mask Transformer for Universal Image Segmentation
-    URL: https://arxiv.org/abs/2112.01527
-  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
-  Framework: PyTorch
-- Name: mask2former_r50_8xb2-160k_ade20k-512x512
-  In Collection: Mask2Former
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 47.87
-  Config: configs/mask2former/mask2former_r50_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D32
-    - Mask2Former
-    Training Resources: 8x A100 GPUS
-    Memory (GB): 3.31
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r50_8xb2-160k_ade20k-512x512/mask2former_r50_8xb2-160k_ade20k-512x512_20221204_000055-2d1f55f1.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r50_8xb2-160k_ade20k-512x512/mask2former_r50_8xb2-160k_ade20k-512x512_20221204_000055.json
-  Paper:
-    Title: Masked-attention Mask Transformer for Universal Image Segmentation
-    URL: https://arxiv.org/abs/2112.01527
-  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
-  Framework: PyTorch
-- Name: mask2former_r101_8xb2-160k_ade20k-512x512
-  In Collection: Mask2Former
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 48.6
-  Config: configs/mask2former/mask2former_r101_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D32
-    - Mask2Former
-    Training Resources: 8x A100 GPUS
-    Memory (GB): 4.09
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r101_8xb2-160k_ade20k-512x512/mask2former_r101_8xb2-160k_ade20k-512x512_20221203_233905-b7135890.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_r101_8xb2-160k_ade20k-512x512/mask2former_r101_8xb2-160k_ade20k-512x512_20221203_233905.json
-  Paper:
-    Title: Masked-attention Mask Transformer for Universal Image Segmentation
-    URL: https://arxiv.org/abs/2112.01527
-  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
-  Framework: PyTorch
-- Name: mask2former_swin-t_8xb2-160k_ade20k-512x512
-  In Collection: Mask2Former
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 48.66
-  Config: configs/mask2former/mask2former_swin-t_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - Swin-T
-    - Mask2Former
-    Training Resources: 8x A100 GPUS
-    Memory (GB): 3826.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-t_8xb2-160k_ade20k-512x512/mask2former_swin-t_8xb2-160k_ade20k-512x512_20221203_234230-7d64e5dd.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-t_8xb2-160k_ade20k-512x512/mask2former_swin-t_8xb2-160k_ade20k-512x512_20221203_234230.json
-  Paper:
-    Title: Masked-attention Mask Transformer for Universal Image Segmentation
-    URL: https://arxiv.org/abs/2112.01527
-  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
-  Framework: PyTorch
-- Name: mask2former_swin-s_8xb2-160k_ade20k-512x512
-  In Collection: Mask2Former
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 51.24
-  Config: configs/mask2former/mask2former_swin-s_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - Swin-S
-    - Mask2Former
-    Training Resources: 8x A100 GPUS
-    Memory (GB): 3.74
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-s_8xb2-160k_ade20k-512x512/mask2former_swin-s_8xb2-160k_ade20k-512x512_20221204_143905-e715144e.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-s_8xb2-160k_ade20k-512x512/mask2former_swin-s_8xb2-160k_ade20k-512x512_20221204_143905.json
-  Paper:
-    Title: Masked-attention Mask Transformer for Universal Image Segmentation
-    URL: https://arxiv.org/abs/2112.01527
-  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
-  Framework: PyTorch
-- Name: mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640
-  In Collection: Mask2Former
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 52.44
-  Config: configs/mask2former/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - Swin-B
-    - Mask2Former
-    Training Resources: 8x A100 GPUS
-    Memory (GB): 5.66
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640_20221129_125118-a4a086d2.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-b-in1k-384x384-pre_8xb2-160k_ade20k-640x640_20221129_125118.json
-  Paper:
-    Title: Masked-attention Mask Transformer for Universal Image Segmentation
-    URL: https://arxiv.org/abs/2112.01527
-  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
-  Framework: PyTorch
-- Name: mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640
-  In Collection: Mask2Former
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 53.9
-  Config: configs/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - Swin-B
-    - Mask2Former
-    Training Resources: 8x A100 GPUS
-    Memory (GB): 5.66
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640_20221203_235230-7ec0f569.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-b-in22k-384x384-pre_8xb2-160k_ade20k-640x640_20221203_235230.json
-  Paper:
-    Title: Masked-attention Mask Transformer for Universal Image Segmentation
-    URL: https://arxiv.org/abs/2112.01527
-  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
-  Framework: PyTorch
-- Name: mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640
-  In Collection: Mask2Former
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 56.01
-  Config: configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - Swin-L
-    - Mask2Former
-    Training Resources: 8x A100 GPUS
-    Memory (GB): 8.86
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640_20221203_235933-7120c214.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640_20221203_235933.json
-  Paper:
-    Title: Masked-attention Mask Transformer for Universal Image Segmentation
-    URL: https://arxiv.org/abs/2112.01527
-  Code: https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/dense_heads/mask2former_head.py
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/maskformer/README.md b/mmsegmentation/configs/maskformer/README.md
deleted file mode 100644
index a899bac..0000000
--- a/mmsegmentation/configs/maskformer/README.md
+++ /dev/null
@@ -1,62 +0,0 @@
-# MaskFormer
-
-> [MaskFormer: Per-Pixel Classification is Not All You Need for Semantic Segmentation](https://arxiv.org/abs/2107.06278)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/facebookresearch/MaskFormer/">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmdetection/blob/dev-3.x/mmdet/models/dense_heads/maskformer_head.py#L21">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Modern approaches typically formulate semantic segmentation as a per-pixel classification task, while instance-level segmentation is handled with an alternative mask classification. Our key insight: mask classification is sufficiently general to solve both semantic- and instance-level segmentation tasks in a unified manner using the exact same model, loss, and training procedure. Following this observation, we propose MaskFormer, a simple mask classification model which predicts a set of binary masks, each associated with a single global class label prediction. Overall, the proposed mask classification-based method simplifies the landscape of effective approaches to semantic and panoptic segmentation tasks and shows excellent empirical results. In particular, we observe that MaskFormer outperforms per-pixel classification baselines when the number of classes is large. Our mask classification-based method outperforms both current state-of-the-art semantic (55.6 mIoU on ADE20K) and panoptic segmentation (52.7 PQ on COCO) models.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/199215459-ea507126-aafe-4823-8eb1-ae6487509d5c.png" width="90%"/>
-</div>
-
-### Usage
-
-- MaskFormer model needs to install [MMDetection](https://github.com/open-mmlab/mmdetection) first.
-
-```shell
-pip install "mmdet>=3.0.0rc4"
-```
-
-## Results and models
-
-### ADE20K
-
-| Method     | Backbone  | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                                    | download                                                                                                                                                                                                                                                                                                                                                                                                     |
-| ---------- | --------- | --------- | ------- | -------- | -------------- | ------ | ----- | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| MaskFormer | R-50-D32  | 512x512   | 160000  | 3.29     | A100           | 42.20  | 44.29 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512/maskformer_r50-d32_8xb2-160k_ade20k-512x512_20221030_182724-3a9cfe45.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512/maskformer_r50-d32_8xb2-160k_ade20k-512x512_20221030_182724.json)                             |
-| MaskFormer | R-101-D32 | 512x512   | 160000  | 4.12     | A100           | 34.90  | 45.11 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/maskformer/maskformer_r101-d32_8xb2-160k_ade20k-512x512.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_r101-d32_8xb2-160k_ade20k-512x512/maskformer_r101-d32_8xb2-160k_ade20k-512x512_20221031_223053-84adbfcb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_r101-d32_8xb2-160k_ade20k-512x512/maskformer_r101-d32_8xb2-160k_ade20k-512x512_20221031_223053.json)                         |
-| MaskFormer | Swin-T    | 512x512   | 160000  | 3.73     | A100           | 40.53  | 46.69 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/maskformer/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512_20221114_232813-f14e7ce0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512_20221114_232813.json) |
-| MaskFormer | Swin-S    | 512x512   | 160000  | 5.33     | A100           | 26.98  | 49.36 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512_20221115_114710-723512c7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512_20221115_114710.json) |
-
-Note:
-
-- All experiments of MaskFormer are implemented with 8 V100 (32G) GPUs with 2 samplers per GPU.
-- The results of MaskFormer are relatively not stable.  The accuracy (mIoU) of model with `R-101-D32` is from 44.7 to 46.0, and with `Swin-S` is from 49.0 to 49.8.
-- The ResNet backbones utilized in MaskFormer models are standard `ResNet` rather than `ResNetV1c`.
-- Test time augmentation is not supported in MMSegmentation 1.x version yet, we would add "ms+flip" results as soon as possible.
-
-## Citation
-
-```bibtex
-@article{cheng2021per,
-  title={Per-pixel classification is not all you need for semantic segmentation},
-  author={Cheng, Bowen and Schwing, Alex and Kirillov, Alexander},
-  journal={Advances in Neural Information Processing Systems},
-  volume={34},
-  pages={17864--17875},
-  year={2021}
-}
-```
diff --git a/mmsegmentation/configs/maskformer/maskformer_r101-d32_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/maskformer/maskformer_r101-d32_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 04bd375..0000000
--- a/mmsegmentation/configs/maskformer/maskformer_r101-d32_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = './maskformer_r50-d32_8xb2-160k_ade20k-512x512.py'
-
-model = dict(
-    backbone=dict(
-        depth=101,
-        init_cfg=dict(type='Pretrained',
-                      checkpoint='torchvision://resnet101')))
diff --git a/mmsegmentation/configs/maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 2a83746..0000000
--- a/mmsegmentation/configs/maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,141 +0,0 @@
-_base_ = [
-    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_160k.py'
-]
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-crop_size = (512, 512)
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    size=crop_size,
-    mean=[123.675, 116.28, 103.53],
-    std=[58.395, 57.12, 57.375],
-    bgr_to_rgb=True,
-    pad_val=0,
-    seg_pad_val=255)
-# model_cfg
-num_classes = 150
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        type='ResNet',
-        depth=50,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        dilations=(1, 1, 1, 1),
-        strides=(1, 2, 2, 2),
-        norm_cfg=norm_cfg,
-        norm_eval=True,
-        style='pytorch',
-        contract_dilation=True,
-        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
-    decode_head=dict(
-        type='MaskFormerHead',
-        in_channels=[256, 512, 1024,
-                     2048],  # input channels of pixel_decoder modules
-        feat_channels=256,
-        in_index=[0, 1, 2, 3],
-        num_classes=150,
-        out_channels=256,
-        num_queries=100,
-        pixel_decoder=dict(
-            type='mmdet.PixelDecoder',
-            norm_cfg=dict(type='GN', num_groups=32),
-            act_cfg=dict(type='ReLU')),
-        enforce_decoder_input_project=False,
-        positional_encoding=dict(  # SinePositionalEncoding
-            num_feats=128, normalize=True),
-        transformer_decoder=dict(  # DetrTransformerDecoder
-            return_intermediate=True,
-            num_layers=6,
-            layer_cfg=dict(  # DetrTransformerDecoderLayer
-                self_attn_cfg=dict(  # MultiheadAttention
-                    embed_dims=256,
-                    num_heads=8,
-                    attn_drop=0.1,
-                    proj_drop=0.1,
-                    dropout_layer=None,
-                    batch_first=True),
-                cross_attn_cfg=dict(  # MultiheadAttention
-                    embed_dims=256,
-                    num_heads=8,
-                    attn_drop=0.1,
-                    proj_drop=0.1,
-                    dropout_layer=None,
-                    batch_first=True),
-                ffn_cfg=dict(
-                    embed_dims=256,
-                    feedforward_channels=2048,
-                    num_fcs=2,
-                    act_cfg=dict(type='ReLU', inplace=True),
-                    ffn_drop=0.1,
-                    dropout_layer=None,
-                    add_identity=True)),
-            init_cfg=None),
-        loss_cls=dict(
-            type='mmdet.CrossEntropyLoss',
-            use_sigmoid=False,
-            loss_weight=1.0,
-            reduction='mean',
-            class_weight=[1.0] * num_classes + [0.1]),
-        loss_mask=dict(
-            type='mmdet.FocalLoss',
-            use_sigmoid=True,
-            gamma=2.0,
-            alpha=0.25,
-            reduction='mean',
-            loss_weight=20.0),
-        loss_dice=dict(
-            type='mmdet.DiceLoss',
-            use_sigmoid=True,
-            activate=True,
-            reduction='mean',
-            naive_dice=True,
-            eps=1.0,
-            loss_weight=1.0),
-        train_cfg=dict(
-            assigner=dict(
-                type='mmdet.HungarianAssigner',
-                match_costs=[
-                    dict(type='mmdet.ClassificationCost', weight=1.0),
-                    dict(
-                        type='mmdet.FocalLossCost',
-                        weight=20.0,
-                        binary_input=True),
-                    dict(
-                        type='mmdet.DiceCost',
-                        weight=1.0,
-                        pred_act=True,
-                        eps=1.0)
-                ]),
-            sampler=dict(type='mmdet.MaskPseudoSampler'))),
-    # training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'),
-)
-# optimizer
-optimizer = dict(
-    type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.0001)
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=optimizer,
-    clip_grad=dict(max_norm=0.01, norm_type=2),
-    paramwise_cfg=dict(custom_keys={
-        'backbone': dict(lr_mult=0.1),
-    }))
-# learning policy
-param_scheduler = [
-    dict(
-        type='PolyLR',
-        eta_min=0,
-        power=0.9,
-        begin=0,
-        end=160000,
-        by_epoch=False)
-]
-
-# In MaskFormer implementation we use batch size 2 per GPU as default
-train_dataloader = dict(batch_size=2, num_workers=2)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 2cbc038..0000000
--- a/mmsegmentation/configs/maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,79 +0,0 @@
-checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_small_patch4_window7_224_20220317-7ba6d6dd.pth'  # noqa
-_base_ = './maskformer_r50-d32_8xb2-160k_ade20k-512x512.py'
-backbone_norm_cfg = dict(type='LN', requires_grad=True)
-depths = [2, 2, 18, 2]
-model = dict(
-    backbone=dict(
-        _delete_=True,
-        type='SwinTransformer',
-        pretrain_img_size=224,
-        embed_dims=96,
-        patch_size=4,
-        window_size=7,
-        mlp_ratio=4,
-        depths=depths,
-        num_heads=[3, 6, 12, 24],
-        strides=(4, 2, 2, 2),
-        out_indices=(0, 1, 2, 3),
-        qkv_bias=True,
-        qk_scale=None,
-        patch_norm=True,
-        drop_rate=0.,
-        attn_drop_rate=0.,
-        drop_path_rate=0.3,
-        use_abs_pos_embed=False,
-        act_cfg=dict(type='GELU'),
-        norm_cfg=backbone_norm_cfg,
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file)),
-    decode_head=dict(
-        type='MaskFormerHead',
-        in_channels=[96, 192, 384,
-                     768],  # input channels of pixel_decoder modules
-    ))
-
-# optimizer
-optimizer = dict(
-    type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01)
-# set all layers in backbone to lr_mult=1.0
-# set all norm layers, position_embeding,
-# query_embeding to decay_multi=0.0
-backbone_norm_multi = dict(lr_mult=1.0, decay_mult=0.0)
-backbone_embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
-embed_multi = dict(decay_mult=0.0)
-custom_keys = {
-    'backbone': dict(lr_mult=1.0),
-    'backbone.patch_embed.norm': backbone_norm_multi,
-    'backbone.norm': backbone_norm_multi,
-    'relative_position_bias_table': backbone_embed_multi,
-    'query_embed': embed_multi,
-}
-custom_keys.update({
-    f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi
-    for stage_id, num_blocks in enumerate(depths)
-    for block_id in range(num_blocks)
-})
-custom_keys.update({
-    f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi
-    for stage_id in range(len(depths) - 1)
-})
-# optimizer
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=optimizer,
-    clip_grad=dict(max_norm=0.01, norm_type=2),
-    paramwise_cfg=dict(custom_keys=custom_keys))
-
-# learning policy
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        eta_min=0.0,
-        power=1.0,
-        begin=1500,
-        end=160000,
-        by_epoch=False,
-    )
-]
diff --git a/mmsegmentation/configs/maskformer/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/maskformer/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index aa242db..0000000
--- a/mmsegmentation/configs/maskformer/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,81 +0,0 @@
-_base_ = './maskformer_r50-d32_8xb2-160k_ade20k-512x512.py'
-
-checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_tiny_patch4_window7_224_20220317-1cdeb081.pth'  # noqa
-backbone_norm_cfg = dict(type='LN', requires_grad=True)
-depths = [2, 2, 6, 2]
-model = dict(
-    backbone=dict(
-        _delete_=True,
-        type='SwinTransformer',
-        pretrain_img_size=224,
-        embed_dims=96,
-        patch_size=4,
-        window_size=7,
-        mlp_ratio=4,
-        depths=depths,
-        num_heads=[3, 6, 12, 24],
-        strides=(4, 2, 2, 2),
-        out_indices=(0, 1, 2, 3),
-        qkv_bias=True,
-        qk_scale=None,
-        patch_norm=True,
-        drop_rate=0.,
-        attn_drop_rate=0.,
-        drop_path_rate=0.3,
-        use_abs_pos_embed=False,
-        act_cfg=dict(type='GELU'),
-        norm_cfg=backbone_norm_cfg,
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file)),
-    decode_head=dict(
-        type='MaskFormerHead',
-        in_channels=[96, 192, 384,
-                     768],  # input channels of pixel_decoder modules
-    ))
-
-# optimizer
-optimizer = dict(
-    type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01)
-
-# set all layers in backbone to lr_mult=1.0
-# set all norm layers, position_embeding,
-# query_embeding to decay_multi=0.0
-backbone_norm_multi = dict(lr_mult=1.0, decay_mult=0.0)
-backbone_embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
-embed_multi = dict(decay_mult=0.0)
-custom_keys = {
-    'backbone': dict(lr_mult=1.0),
-    'backbone.patch_embed.norm': backbone_norm_multi,
-    'backbone.norm': backbone_norm_multi,
-    'relative_position_bias_table': backbone_embed_multi,
-    'query_embed': embed_multi,
-}
-custom_keys.update({
-    f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi
-    for stage_id, num_blocks in enumerate(depths)
-    for block_id in range(num_blocks)
-})
-custom_keys.update({
-    f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi
-    for stage_id in range(len(depths) - 1)
-})
-# optimizer
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=optimizer,
-    clip_grad=dict(max_norm=0.01, norm_type=2),
-    paramwise_cfg=dict(custom_keys=custom_keys))
-
-# learning policy
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        eta_min=0.0,
-        power=1.0,
-        begin=1500,
-        end=160000,
-        by_epoch=False,
-    )
-]
diff --git a/mmsegmentation/configs/maskformer/metafile.yaml b/mmsegmentation/configs/maskformer/metafile.yaml
deleted file mode 100644
index c9853e1..0000000
--- a/mmsegmentation/configs/maskformer/metafile.yaml
+++ /dev/null
@@ -1,111 +0,0 @@
-Collections:
-- Name: MaskFormer
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Usage
-    - ADE20K
-  Paper:
-    Title: 'MaskFormer: Per-Pixel Classification is Not All You Need for Semantic
-      Segmentation'
-    URL: https://arxiv.org/abs/2107.06278
-  README: configs/maskformer/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: maskformer_r50-d32_8xb2-160k_ade20k-512x512
-  In Collection: MaskFormer
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 44.29
-  Config: configs/maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D32
-    - MaskFormer
-    Training Resources: 8x 42.20 GPUS
-    Memory (GB): 3.29
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512/maskformer_r50-d32_8xb2-160k_ade20k-512x512_20221030_182724-3a9cfe45.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512/maskformer_r50-d32_8xb2-160k_ade20k-512x512_20221030_182724.json
-  Paper:
-    Title: 'MaskFormer: Per-Pixel Classification is Not All You Need for Semantic
-      Segmentation'
-    URL: https://arxiv.org/abs/2107.06278
-  Code: https://github.com/open-mmlab/mmdetection/blob/dev-3.x/mmdet/models/dense_heads/maskformer_head.py#L21
-  Framework: PyTorch
-- Name: maskformer_r101-d32_8xb2-160k_ade20k-512x512
-  In Collection: MaskFormer
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 45.11
-  Config: configs/maskformer/maskformer_r101-d32_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D32
-    - MaskFormer
-    Training Resources: 8x 34.90 GPUS
-    Memory (GB): 4.12
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_r101-d32_8xb2-160k_ade20k-512x512/maskformer_r101-d32_8xb2-160k_ade20k-512x512_20221031_223053-84adbfcb.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_r101-d32_8xb2-160k_ade20k-512x512/maskformer_r101-d32_8xb2-160k_ade20k-512x512_20221031_223053.json
-  Paper:
-    Title: 'MaskFormer: Per-Pixel Classification is Not All You Need for Semantic
-      Segmentation'
-    URL: https://arxiv.org/abs/2107.06278
-  Code: https://github.com/open-mmlab/mmdetection/blob/dev-3.x/mmdet/models/dense_heads/maskformer_head.py#L21
-  Framework: PyTorch
-- Name: maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512
-  In Collection: MaskFormer
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 46.69
-  Config: configs/maskformer/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - Swin-T
-    - MaskFormer
-    Training Resources: 8x 40.53 GPUS
-    Memory (GB): 3.73
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512_20221114_232813-f14e7ce0.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512/maskformer_swin-t_upernet_8xb2-160k_ade20k-512x512_20221114_232813.json
-  Paper:
-    Title: 'MaskFormer: Per-Pixel Classification is Not All You Need for Semantic
-      Segmentation'
-    URL: https://arxiv.org/abs/2107.06278
-  Code: https://github.com/open-mmlab/mmdetection/blob/dev-3.x/mmdet/models/dense_heads/maskformer_head.py#L21
-  Framework: PyTorch
-- Name: maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512
-  In Collection: MaskFormer
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 49.36
-  Config: configs/maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - Swin-S
-    - MaskFormer
-    Training Resources: 8x 26.98 GPUS
-    Memory (GB): 5.33
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512_20221115_114710-723512c7.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/maskformer/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512/maskformer_swin-s_upernet_8xb2-160k_ade20k-512x512_20221115_114710.json
-  Paper:
-    Title: 'MaskFormer: Per-Pixel Classification is Not All You Need for Semantic
-      Segmentation'
-    URL: https://arxiv.org/abs/2107.06278
-  Code: https://github.com/open-mmlab/mmdetection/blob/dev-3.x/mmdet/models/dense_heads/maskformer_head.py#L21
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/mobilenet_v2/README.md b/mmsegmentation/configs/mobilenet_v2/README.md
deleted file mode 100644
index bff5259..0000000
--- a/mmsegmentation/configs/mobilenet_v2/README.md
+++ /dev/null
@@ -1,56 +0,0 @@
-# MobileNetV2
-
-> [MobileNetV2: Inverted Residuals and Linear Bottlenecks](https://arxiv.org/abs/1801.04381)
-
-## Introduction
-
-<!-- [BACKBONE] -->
-
-<a href="https://github.com/tensorflow/models/tree/master/research/deeplab">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v2.py#L14">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-In this paper we describe a new mobile architecture, MobileNetV2, that improves the state of the art performance of mobile models on multiple tasks and benchmarks as well as across a spectrum of different model sizes. We also describe efficient ways of applying these mobile models to object detection in a novel framework we call SSDLite. Additionally, we demonstrate how to build mobile semantic segmentation models through a reduced form of DeepLabv3 which we call Mobile DeepLabv3.
-The MobileNetV2 architecture is based on an inverted residual structure where the input and output of the residual block are thin bottleneck layers opposite to traditional residual models which use expanded representations in the input an MobileNetV2 uses lightweight depthwise convolutions to filter features in the intermediate expansion layer. Additionally, we find that it is important to remove non-linearities in the narrow layers in order to maintain representational power. We demonstrate that this improves performance and provide an intuition that led to this design. Finally, our approach allows decoupling of the input/output domains from the expressiveness of the transformation, which provides a convenient framework for further analysis. We measure our performance on Imagenet classification, COCO object detection, VOC image segmentation. We evaluate the trade-offs between accuracy, and number of operations measured by multiply-adds (MAdd), as well as the number of parameters.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142901935-fa22700e-4b77-477f-90b9-334a4197506f.png" width="50%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                              | download                                                                                                                                                                                                                                                                                                                                                                                                 |
-| ---------- | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| FCN        | M-V2-D8  | 512x1024  |   80000 |      3.4 | 14.2           | A100   | 71.19 | 73.34         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024-20230224_185436-13fef4ea.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024_20230224_185436.json) |
-| PSPNet     | M-V2-D8  | 512x1024  |   80000 |      3.6 | 11.2           | V100   | 70.23 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb2-80k_cityscapes-512x1024.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/pspnet_m-v2-d8_512x1024_80k_cityscapes/pspnet_m-v2-d8_512x1024_80k_cityscapes_20200825_124817-19e81d51.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/pspnet_m-v2-d8_512x1024_80k_cityscapes/pspnet_m-v2-d8_512x1024_80k_cityscapes-20200825_124817.log.json)                                     |
-| DeepLabV3  | M-V2-D8  | 512x1024  |   80000 |      3.9 | 8.4            | V100   | 73.84 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py)     | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3_m-v2-d8_512x1024_80k_cityscapes/deeplabv3_m-v2-d8_512x1024_80k_cityscapes_20200825_124836-bef03590.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3_m-v2-d8_512x1024_80k_cityscapes/deeplabv3_m-v2-d8_512x1024_80k_cityscapes-20200825_124836.log.json)                         |
-| DeepLabV3+ | M-V2-D8  | 512x1024  |   80000 |      5.1 | 8.4            | V100   | 75.20 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3plus_m-v2-d8_512x1024_80k_cityscapes/deeplabv3plus_m-v2-d8_512x1024_80k_cityscapes_20200825_124836-d256dd4b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3plus_m-v2-d8_512x1024_80k_cityscapes/deeplabv3plus_m-v2-d8_512x1024_80k_cityscapes-20200825_124836.log.json)         |
-
-### ADE20K
-
-| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                          | download                                                                                                                                                                                                                                                                                                                                                                         |
-| ---------- | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| FCN        | M-V2-D8  | 512x512   |  160000 |      6.5 | 64.4           | V100   | 19.71 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb4-160k_ade20k-512x512.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/fcn_m-v2-d8_512x512_160k_ade20k/fcn_m-v2-d8_512x512_160k_ade20k_20200825_214953-c40e1095.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/fcn_m-v2-d8_512x512_160k_ade20k/fcn_m-v2-d8_512x512_160k_ade20k-20200825_214953.log.json)                                         |
-| PSPNet     | M-V2-D8  | 512x512   |  160000 |      6.5 | 57.7           | V100   | 29.68 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb4-160k_ade20k-512x512.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/pspnet_m-v2-d8_512x512_160k_ade20k/pspnet_m-v2-d8_512x512_160k_ade20k_20200825_214953-f5942f7a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/pspnet_m-v2-d8_512x512_160k_ade20k/pspnet_m-v2-d8_512x512_160k_ade20k-20200825_214953.log.json)                             |
-| DeepLabV3  | M-V2-D8  | 512x512   |  160000 |      6.8 | 39.9           | V100   | 34.08 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb4-160k_ade20k-512x512.py)     | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3_m-v2-d8_512x512_160k_ade20k/deeplabv3_m-v2-d8_512x512_160k_ade20k_20200825_223255-63986343.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3_m-v2-d8_512x512_160k_ade20k/deeplabv3_m-v2-d8_512x512_160k_ade20k-20200825_223255.log.json)                 |
-| DeepLabV3+ | M-V2-D8  | 512x512   |  160000 |      8.2 | 43.1           | V100   | 34.02 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3plus_m-v2-d8_512x512_160k_ade20k/deeplabv3plus_m-v2-d8_512x512_160k_ade20k_20200825_223255-465a01d4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3plus_m-v2-d8_512x512_160k_ade20k/deeplabv3plus_m-v2-d8_512x512_160k_ade20k-20200825_223255.log.json) |
-
-## Citation
-
-```bibtex
-@inproceedings{sandler2018mobilenetv2,
-  title={Mobilenetv2: Inverted residuals and linear bottlenecks},
-  author={Sandler, Mark and Howard, Andrew and Zhu, Menglong and Zhmoginov, Andrey and Chen, Liang-Chieh},
-  booktitle={Proceedings of the IEEE conference on computer vision and pattern recognition},
-  pages={4510--4520},
-  year={2018}
-}
-```
diff --git a/mmsegmentation/configs/mobilenet_v2/metafile.yaml b/mmsegmentation/configs/mobilenet_v2/metafile.yaml
deleted file mode 100644
index 119c9ae..0000000
--- a/mmsegmentation/configs/mobilenet_v2/metafile.yaml
+++ /dev/null
@@ -1,186 +0,0 @@
-Models:
-- Name: mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 71.19
-      mIoU(ms+flip): 73.34
-  Config: configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - M-V2-D8
-    - FCN
-    Training Resources: 4x A100 GPUS
-    Memory (GB): 3.4
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024-20230224_185436-13fef4ea.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024_20230224_185436.json
-  Paper:
-    Title: 'MobileNetV2: Inverted Residuals and Linear Bottlenecks'
-    URL: https://arxiv.org/abs/1801.04381
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v2.py#L14
-  Framework: PyTorch
-- Name: mobilenet-v2-d8_pspnet_4xb2-80k_cityscapes-512x1024
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 70.23
-  Config: configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - M-V2-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 3.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/pspnet_m-v2-d8_512x1024_80k_cityscapes/pspnet_m-v2-d8_512x1024_80k_cityscapes_20200825_124817-19e81d51.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/pspnet_m-v2-d8_512x1024_80k_cityscapes/pspnet_m-v2-d8_512x1024_80k_cityscapes-20200825_124817.log.json
-  Paper:
-    Title: 'MobileNetV2: Inverted Residuals and Linear Bottlenecks'
-    URL: https://arxiv.org/abs/1801.04381
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v2.py#L14
-  Framework: PyTorch
-- Name: mobilenet-v2-d8_deeplabv3_4xb2-80k_cityscapes-512x1024
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 73.84
-  Config: configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - M-V2-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 3.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3_m-v2-d8_512x1024_80k_cityscapes/deeplabv3_m-v2-d8_512x1024_80k_cityscapes_20200825_124836-bef03590.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3_m-v2-d8_512x1024_80k_cityscapes/deeplabv3_m-v2-d8_512x1024_80k_cityscapes-20200825_124836.log.json
-  Paper:
-    Title: 'MobileNetV2: Inverted Residuals and Linear Bottlenecks'
-    URL: https://arxiv.org/abs/1801.04381
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v2.py#L14
-  Framework: PyTorch
-- Name: mobilenet-v2-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 75.2
-  Config: configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - M-V2-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3plus_m-v2-d8_512x1024_80k_cityscapes/deeplabv3plus_m-v2-d8_512x1024_80k_cityscapes_20200825_124836-d256dd4b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3plus_m-v2-d8_512x1024_80k_cityscapes/deeplabv3plus_m-v2-d8_512x1024_80k_cityscapes-20200825_124836.log.json
-  Paper:
-    Title: 'MobileNetV2: Inverted Residuals and Linear Bottlenecks'
-    URL: https://arxiv.org/abs/1801.04381
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v2.py#L14
-  Framework: PyTorch
-- Name: mobilenet-v2-d8_fcn_4xb4-160k_ade20k-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 19.71
-  Config: configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - M-V2-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/fcn_m-v2-d8_512x512_160k_ade20k/fcn_m-v2-d8_512x512_160k_ade20k_20200825_214953-c40e1095.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/fcn_m-v2-d8_512x512_160k_ade20k/fcn_m-v2-d8_512x512_160k_ade20k-20200825_214953.log.json
-  Paper:
-    Title: 'MobileNetV2: Inverted Residuals and Linear Bottlenecks'
-    URL: https://arxiv.org/abs/1801.04381
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v2.py#L14
-  Framework: PyTorch
-- Name: mobilenet-v2-d8_pspnet_4xb4-160k_ade20k-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 29.68
-  Config: configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - M-V2-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/pspnet_m-v2-d8_512x512_160k_ade20k/pspnet_m-v2-d8_512x512_160k_ade20k_20200825_214953-f5942f7a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/pspnet_m-v2-d8_512x512_160k_ade20k/pspnet_m-v2-d8_512x512_160k_ade20k-20200825_214953.log.json
-  Paper:
-    Title: 'MobileNetV2: Inverted Residuals and Linear Bottlenecks'
-    URL: https://arxiv.org/abs/1801.04381
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v2.py#L14
-  Framework: PyTorch
-- Name: mobilenet-v2-d8_deeplabv3_4xb4-160k_ade20k-512x512
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 34.08
-  Config: configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - M-V2-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3_m-v2-d8_512x512_160k_ade20k/deeplabv3_m-v2-d8_512x512_160k_ade20k_20200825_223255-63986343.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3_m-v2-d8_512x512_160k_ade20k/deeplabv3_m-v2-d8_512x512_160k_ade20k-20200825_223255.log.json
-  Paper:
-    Title: 'MobileNetV2: Inverted Residuals and Linear Bottlenecks'
-    URL: https://arxiv.org/abs/1801.04381
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v2.py#L14
-  Framework: PyTorch
-- Name: mobilenet-v2-d8_deeplabv3plus_4xb4-160k_ade20k-512x512
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 34.02
-  Config: configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - M-V2-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3plus_m-v2-d8_512x512_160k_ade20k/deeplabv3plus_m-v2-d8_512x512_160k_ade20k_20200825_223255-465a01d4.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v2/deeplabv3plus_m-v2-d8_512x512_160k_ade20k/deeplabv3plus_m-v2-d8_512x512_160k_ade20k-20200825_223255.log.json
-  Paper:
-    Title: 'MobileNetV2: Inverted Residuals and Linear Bottlenecks'
-    URL: https://arxiv.org/abs/1801.04381
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v2.py#L14
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index ece9b0b..0000000
--- a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,13 +0,0 @@
-_base_ = '../deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='mmcls://mobilenet_v2',
-    backbone=dict(
-        _delete_=True,
-        type='MobileNetV2',
-        widen_factor=1.,
-        strides=(1, 2, 2, 1, 1, 1, 1),
-        dilations=(1, 1, 1, 2, 2, 4, 4),
-        out_indices=(1, 2, 4, 6),
-        norm_cfg=dict(type='SyncBN', requires_grad=True)),
-    decode_head=dict(in_channels=320),
-    auxiliary_head=dict(in_channels=96))
diff --git a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 86eec0d..0000000
--- a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,13 +0,0 @@
-_base_ = '../deeplabv3/deeplabv3_r101-d8_4xb4-160k_ade20k-512x512.py'
-model = dict(
-    pretrained='mmcls://mobilenet_v2',
-    backbone=dict(
-        _delete_=True,
-        type='MobileNetV2',
-        widen_factor=1.,
-        strides=(1, 2, 2, 1, 1, 1, 1),
-        dilations=(1, 1, 1, 2, 2, 4, 4),
-        out_indices=(1, 2, 4, 6),
-        norm_cfg=dict(type='SyncBN', requires_grad=True)),
-    decode_head=dict(in_channels=320),
-    auxiliary_head=dict(in_channels=96))
diff --git a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 195046e..0000000
--- a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,15 +0,0 @@
-_base_ = [
-    '../deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024.py'
-]
-model = dict(
-    pretrained='mmcls://mobilenet_v2',
-    backbone=dict(
-        _delete_=True,
-        type='MobileNetV2',
-        widen_factor=1.,
-        strides=(1, 2, 2, 1, 1, 1, 1),
-        dilations=(1, 1, 1, 2, 2, 4, 4),
-        out_indices=(1, 2, 4, 6),
-        norm_cfg=dict(type='SyncBN', requires_grad=True)),
-    decode_head=dict(in_channels=320, c1_in_channels=24),
-    auxiliary_head=dict(in_channels=96))
diff --git a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index d4f669f..0000000
--- a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,13 +0,0 @@
-_base_ = '../deeplabv3plus/deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512.py'
-model = dict(
-    pretrained='mmcls://mobilenet_v2',
-    backbone=dict(
-        _delete_=True,
-        type='MobileNetV2',
-        widen_factor=1.,
-        strides=(1, 2, 2, 1, 1, 1, 1),
-        dilations=(1, 1, 1, 2, 2, 4, 4),
-        out_indices=(1, 2, 4, 6),
-        norm_cfg=dict(type='SyncBN', requires_grad=True)),
-    decode_head=dict(in_channels=320, c1_in_channels=24),
-    auxiliary_head=dict(in_channels=96))
diff --git a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 0829f43..0000000
--- a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,13 +0,0 @@
-_base_ = '../fcn/fcn_r101-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='mmcls://mobilenet_v2',
-    backbone=dict(
-        _delete_=True,
-        type='MobileNetV2',
-        widen_factor=1.,
-        strides=(1, 2, 2, 1, 1, 1, 1),
-        dilations=(1, 1, 1, 2, 2, 4, 4),
-        out_indices=(1, 2, 4, 6),
-        norm_cfg=dict(type='SyncBN', requires_grad=True)),
-    decode_head=dict(in_channels=320),
-    auxiliary_head=dict(in_channels=96))
diff --git a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 015fa6f..0000000
--- a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_fcn_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,13 +0,0 @@
-_base_ = '../fcn/fcn_r101-d8_4xb4-160k_ade20k-512x512.py'
-model = dict(
-    pretrained='mmcls://mobilenet_v2',
-    backbone=dict(
-        _delete_=True,
-        type='MobileNetV2',
-        widen_factor=1.,
-        strides=(1, 2, 2, 1, 1, 1, 1),
-        dilations=(1, 1, 1, 2, 2, 4, 4),
-        out_indices=(1, 2, 4, 6),
-        norm_cfg=dict(type='SyncBN', requires_grad=True)),
-    decode_head=dict(in_channels=320),
-    auxiliary_head=dict(in_channels=96))
diff --git a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 8542e02..0000000
--- a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,13 +0,0 @@
-_base_ = '../pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='mmcls://mobilenet_v2',
-    backbone=dict(
-        _delete_=True,
-        type='MobileNetV2',
-        widen_factor=1.,
-        strides=(1, 2, 2, 1, 1, 1, 1),
-        dilations=(1, 1, 1, 2, 2, 4, 4),
-        out_indices=(1, 2, 4, 6),
-        norm_cfg=dict(type='SyncBN', requires_grad=True)),
-    decode_head=dict(in_channels=320),
-    auxiliary_head=dict(in_channels=96))
diff --git a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 73db59b..0000000
--- a/mmsegmentation/configs/mobilenet_v2/mobilenet-v2-d8_pspnet_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,13 +0,0 @@
-_base_ = '../pspnet/pspnet_r101-d8_4xb4-160k_ade20k-512x512.py'
-model = dict(
-    pretrained='mmcls://mobilenet_v2',
-    backbone=dict(
-        _delete_=True,
-        type='MobileNetV2',
-        widen_factor=1.,
-        strides=(1, 2, 2, 1, 1, 1, 1),
-        dilations=(1, 1, 1, 2, 2, 4, 4),
-        out_indices=(1, 2, 4, 6),
-        norm_cfg=dict(type='SyncBN', requires_grad=True)),
-    decode_head=dict(in_channels=320),
-    auxiliary_head=dict(in_channels=96))
diff --git a/mmsegmentation/configs/mobilenet_v3/README.md b/mmsegmentation/configs/mobilenet_v3/README.md
deleted file mode 100644
index 8ed0a56..0000000
--- a/mmsegmentation/configs/mobilenet_v3/README.md
+++ /dev/null
@@ -1,50 +0,0 @@
-# MobileNetV3
-
-> [Searching for MobileNetV3](https://arxiv.org/abs/1905.02244)
-
-## Introduction
-
-<!-- [BACKBONE] -->
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/tensorflow/models/tree/master/research/deeplab">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v3.py#L15">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-We present the next generation of MobileNets based on a combination of complementary search techniques as well as a novel architecture design. MobileNetV3 is tuned to mobile phone CPUs through a combination of hardware-aware network architecture search (NAS) complemented by the NetAdapt algorithm and then subsequently improved through novel architecture advances. This paper starts the exploration of how automated search algorithms and network design can work together to harness complementary approaches improving the overall state of the art. Through this process we create two new MobileNet models for release: MobileNetV3-Large and MobileNetV3-Small which are targeted for high and low resource use cases. These models are then adapted and applied to the tasks of object detection and semantic segmentation. For the task of semantic segmentation (or any dense pixel prediction), we propose a new efficient segmentation decoder Lite Reduced Atrous Spatial Pyramid Pooling (LR-ASPP). We achieve new state of the art results for mobile classification, detection and segmentation. MobileNetV3-Large is 3.2% more accurate on ImageNet classification while reducing latency by 15% compared to MobileNetV2. MobileNetV3-Small is 4.6% more accurate while reducing latency by 5% compared to MobileNetV2. MobileNetV3-Large detection is 25% faster at roughly the same accuracy as MobileNetV2 on COCO detection. MobileNetV3-Large LR-ASPP is 30% faster than MobileNetV2 R-ASPP at similar accuracy for Cityscapes segmentation.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142902036-3dc2e0c0-d475-4816-b1ac-961836b41f5c.png" width="60%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method | Backbone           | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                                  | download                                                                                                                                                                                                                                                                                                                                                                                                     |
-| ------ | ------------------ | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| LRASPP | M-V3-D8            | 512x1024  |  320000 |      8.9 | 15.22          | V100   | 69.54 | 70.89         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v3/mobilenet-v3-d8_lraspp_4xb4-320k_cityscapes-512x1024.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3-d8_512x1024_320k_cityscapes/lraspp_m-v3-d8_512x1024_320k_cityscapes_20201224_220337-cfe8fb07.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3-d8_512x1024_320k_cityscapes/lraspp_m-v3-d8_512x1024_320k_cityscapes-20201224_220337.log.json)                                     |
-| LRASPP | M-V3-D8 (scratch)  | 512x1024  |  320000 |      8.9 | 14.77          | V100   | 67.87 | 69.78         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v3/mobilenet-v3-d8-scratch_lraspp_4xb4-320k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3-d8_scratch_512x1024_320k_cityscapes/lraspp_m-v3-d8_scratch_512x1024_320k_cityscapes_20201224_220337-9f29cd72.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3-d8_scratch_512x1024_320k_cityscapes/lraspp_m-v3-d8_scratch_512x1024_320k_cityscapes-20201224_220337.log.json)     |
-| LRASPP | M-V3s-D8           | 512x1024  |  320000 |      5.3 | 23.64          | V100   | 64.11 | 66.42         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v3/mobilenet-v3-d8-s_lraspp_4xb4-320k_cityscapes-512x1024.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3s-d8_512x1024_320k_cityscapes/lraspp_m-v3s-d8_512x1024_320k_cityscapes_20201224_223935-61565b34.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3s-d8_512x1024_320k_cityscapes/lraspp_m-v3s-d8_512x1024_320k_cityscapes-20201224_223935.log.json)                                 |
-| LRASPP | M-V3s-D8 (scratch) | 512x1024  |  320000 |      5.3 | 24.50          | V100   | 62.74 | 65.01         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v3/mobilenet-v3-d8-scratch-s_lraspp_4xb4-320k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3s-d8_scratch_512x1024_320k_cityscapes/lraspp_m-v3s-d8_scratch_512x1024_320k_cityscapes_20201224_223935-03daeabb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3s-d8_scratch_512x1024_320k_cityscapes/lraspp_m-v3s-d8_scratch_512x1024_320k_cityscapes-20201224_223935.log.json) |
-
-## Citation
-
-```bibtex
-@inproceedings{Howard_2019_ICCV,
-  title={Searching for MobileNetV3},
-  author={Howard, Andrew and Sandler, Mark and Chu, Grace and Chen, Liang-Chieh and Chen, Bo and Tan, Mingxing and Wang, Weijun and Zhu, Yukun and Pang, Ruoming and Vasudevan, Vijay and Le, Quoc V. and Adam, Hartwig},
-  booktitle={The IEEE International Conference on Computer Vision (ICCV)},
-  pages={1314-1324},
-  month={October},
-  year={2019},
-  doi={10.1109/ICCV.2019.00140}}
-}
-```
diff --git a/mmsegmentation/configs/mobilenet_v3/metafile.yaml b/mmsegmentation/configs/mobilenet_v3/metafile.yaml
deleted file mode 100644
index 0351d3b..0000000
--- a/mmsegmentation/configs/mobilenet_v3/metafile.yaml
+++ /dev/null
@@ -1,109 +0,0 @@
-Collections:
-- Name: LRASPP
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-  Paper:
-    Title: Searching for MobileNetV3
-    URL: https://arxiv.org/abs/1905.02244
-  README: configs/mobilenet_v3/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: mobilenet-v3-d8_lraspp_4xb4-320k_cityscapes-512x1024
-  In Collection: LRASPP
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 69.54
-      mIoU(ms+flip): 70.89
-  Config: configs/mobilenet_v3/mobilenet-v3-d8_lraspp_4xb4-320k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 16
-    Architecture:
-    - M-V3-D8
-    - LRASPP
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3-d8_512x1024_320k_cityscapes/lraspp_m-v3-d8_512x1024_320k_cityscapes_20201224_220337-cfe8fb07.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3-d8_512x1024_320k_cityscapes/lraspp_m-v3-d8_512x1024_320k_cityscapes-20201224_220337.log.json
-  Paper:
-    Title: Searching for MobileNetV3
-    URL: https://arxiv.org/abs/1905.02244
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v3.py#L15
-  Framework: PyTorch
-- Name: mobilenet-v3-d8-scratch_lraspp_4xb4-320k_cityscapes-512x1024
-  In Collection: LRASPP
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 67.87
-      mIoU(ms+flip): 69.78
-  Config: configs/mobilenet_v3/mobilenet-v3-d8-scratch_lraspp_4xb4-320k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 16
-    Architecture:
-    - M-V3-D8
-    - LRASPP
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3-d8_scratch_512x1024_320k_cityscapes/lraspp_m-v3-d8_scratch_512x1024_320k_cityscapes_20201224_220337-9f29cd72.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3-d8_scratch_512x1024_320k_cityscapes/lraspp_m-v3-d8_scratch_512x1024_320k_cityscapes-20201224_220337.log.json
-  Paper:
-    Title: Searching for MobileNetV3
-    URL: https://arxiv.org/abs/1905.02244
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v3.py#L15
-  Framework: PyTorch
-- Name: mobilenet-v3-d8-s_lraspp_4xb4-320k_cityscapes-512x1024
-  In Collection: LRASPP
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 64.11
-      mIoU(ms+flip): 66.42
-  Config: configs/mobilenet_v3/mobilenet-v3-d8-s_lraspp_4xb4-320k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 16
-    Architecture:
-    - M-V3s-D8
-    - LRASPP
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.3
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3s-d8_512x1024_320k_cityscapes/lraspp_m-v3s-d8_512x1024_320k_cityscapes_20201224_223935-61565b34.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3s-d8_512x1024_320k_cityscapes/lraspp_m-v3s-d8_512x1024_320k_cityscapes-20201224_223935.log.json
-  Paper:
-    Title: Searching for MobileNetV3
-    URL: https://arxiv.org/abs/1905.02244
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v3.py#L15
-  Framework: PyTorch
-- Name: mobilenet-v3-d8-scratch-s_lraspp_4xb4-320k_cityscapes-512x1024
-  In Collection: LRASPP
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 62.74
-      mIoU(ms+flip): 65.01
-  Config: configs/mobilenet_v3/mobilenet-v3-d8-scratch-s_lraspp_4xb4-320k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 16
-    Architecture:
-    - M-V3s-D8
-    - LRASPP
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.3
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3s-d8_scratch_512x1024_320k_cityscapes/lraspp_m-v3s-d8_scratch_512x1024_320k_cityscapes_20201224_223935-03daeabb.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/mobilenet_v3/lraspp_m-v3s-d8_scratch_512x1024_320k_cityscapes/lraspp_m-v3s-d8_scratch_512x1024_320k_cityscapes-20201224_223935.log.json
-  Paper:
-    Title: Searching for MobileNetV3
-    URL: https://arxiv.org/abs/1905.02244
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mobilenet_v3.py#L15
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-s_lraspp_4xb4-320k_cityscapes-512x1024.py b/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-s_lraspp_4xb4-320k_cityscapes-512x1024.py
deleted file mode 100644
index bc6322f..0000000
--- a/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-s_lraspp_4xb4-320k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,23 +0,0 @@
-_base_ = './mobilenet-v3-d8_lraspp_4xb4-320k_cityscapes-512x1024.py'
-norm_cfg = dict(type='SyncBN', eps=0.001, requires_grad=True)
-model = dict(
-    type='EncoderDecoder',
-    pretrained='open-mmlab://contrib/mobilenet_v3_small',
-    backbone=dict(
-        type='MobileNetV3',
-        arch='small',
-        out_indices=(0, 1, 12),
-        norm_cfg=norm_cfg),
-    decode_head=dict(
-        type='LRASPPHead',
-        in_channels=(16, 16, 576),
-        in_index=(0, 1, 2),
-        channels=128,
-        input_transform='multiple_select',
-        dropout_ratio=0.1,
-        num_classes=19,
-        norm_cfg=norm_cfg,
-        act_cfg=dict(type='ReLU'),
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)))
diff --git a/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-scratch-s_lraspp_4xb4-320k_cityscapes-512x1024.py b/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-scratch-s_lraspp_4xb4-320k_cityscapes-512x1024.py
deleted file mode 100644
index 7260936..0000000
--- a/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-scratch-s_lraspp_4xb4-320k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,22 +0,0 @@
-_base_ = './mobilenet-v3-d8-scratch_lraspp_4xb4-320k_cityscapes-512x1024.py'
-norm_cfg = dict(type='SyncBN', eps=0.001, requires_grad=True)
-model = dict(
-    type='EncoderDecoder',
-    backbone=dict(
-        type='MobileNetV3',
-        arch='small',
-        out_indices=(0, 1, 12),
-        norm_cfg=norm_cfg),
-    decode_head=dict(
-        type='LRASPPHead',
-        in_channels=(16, 16, 576),
-        in_index=(0, 1, 2),
-        channels=128,
-        input_transform='multiple_select',
-        dropout_ratio=0.1,
-        num_classes=19,
-        norm_cfg=norm_cfg,
-        act_cfg=dict(type='ReLU'),
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)))
diff --git a/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-scratch_lraspp_4xb4-320k_cityscapes-512x1024.py b/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-scratch_lraspp_4xb4-320k_cityscapes-512x1024.py
deleted file mode 100644
index 8dcbc33..0000000
--- a/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8-scratch_lraspp_4xb4-320k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,13 +0,0 @@
-_base_ = [
-    '../_base_/models/lraspp_m-v3-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-# Re-config the data sampler.
-model = dict(data_preprocessor=data_preprocessor)
-train_dataloader = dict(batch_size=4, num_workers=4)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
-
-runner = dict(type='IterBasedRunner', max_iters=320000)
diff --git a/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8_lraspp_4xb4-320k_cityscapes-512x1024.py b/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8_lraspp_4xb4-320k_cityscapes-512x1024.py
deleted file mode 100644
index cd84265..0000000
--- a/mmsegmentation/configs/mobilenet_v3/mobilenet-v3-d8_lraspp_4xb4-320k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,16 +0,0 @@
-_base_ = [
-    '../_base_/models/lraspp_m-v3-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained='open-mmlab://contrib/mobilenet_v3_large')
-
-# Re-config the data sampler.
-train_dataloader = dict(batch_size=4, num_workers=4)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
-
-runner = dict(type='IterBasedRunner', max_iters=320000)
diff --git a/mmsegmentation/configs/nonlocal_net/README.md b/mmsegmentation/configs/nonlocal_net/README.md
deleted file mode 100644
index 4c3f49f..0000000
--- a/mmsegmentation/configs/nonlocal_net/README.md
+++ /dev/null
@@ -1,68 +0,0 @@
-# NonLocal Net
-
-> [Non-local Neural Networks](https://arxiv.org/abs/1711.07971)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/facebookresearch/video-nonlocal-net">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Both convolutional and recurrent operations are building blocks that process one local neighborhood at a time. In this paper, we present non-local operations as a generic family of building blocks for capturing long-range dependencies. Inspired by the classical non-local means method in computer vision, our non-local operation computes the response at a position as a weighted sum of the features at all positions. This building block can be plugged into many computer vision architectures. On the task of video classification, even without any bells and whistles, our non-local models can compete or outperform current competition winners on both Kinetics and Charades datasets. In static image recognition, our non-local models improve object detection/segmentation and pose estimation on the COCO suite of tasks. Code is available at [this https URL](https://github.com/facebookresearch/video-nonlocal-net).
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142902128-17e29678-bf12-4ff4-b3d6-a39b47dfd253.png" width="50%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method      | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                 | download                                                                                                                                                                                                                                                                                                                                                                     |
-| ----------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------- | -------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| NonLocalNet | R-50-D8  | 512x1024  |   40000 | 7.4      | 2.72           | V100   | 78.24 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x1024_40k_cityscapes/nonlocal_r50-d8_512x1024_40k_cityscapes_20200605_210748-c75e81e3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x1024_40k_cityscapes/nonlocal_r50-d8_512x1024_40k_cityscapes_20200605_210748.log.json)     |
-| NonLocalNet | R-101-D8 | 512x1024  |   40000 | 10.9     | 1.95           | V100   | 78.66 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x1024_40k_cityscapes/nonlocal_r101-d8_512x1024_40k_cityscapes_20200605_210748-d63729fa.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x1024_40k_cityscapes/nonlocal_r101-d8_512x1024_40k_cityscapes_20200605_210748.log.json) |
-| NonLocalNet | R-50-D8  | 769x769   |   40000 | 8.9      | 1.52           | V100   | 78.33 | 79.92         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_769x769_40k_cityscapes/nonlocal_r50-d8_769x769_40k_cityscapes_20200530_045243-82ef6749.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_769x769_40k_cityscapes/nonlocal_r50-d8_769x769_40k_cityscapes_20200530_045243.log.json)         |
-| NonLocalNet | R-101-D8 | 769x769   |   40000 | 12.8     | 1.05           | V100   | 78.57 | 80.29         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_769x769_40k_cityscapes/nonlocal_r101-d8_769x769_40k_cityscapes_20200530_045348-8fe9a9dc.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_769x769_40k_cityscapes/nonlocal_r101-d8_769x769_40k_cityscapes_20200530_045348.log.json)     |
-| NonLocalNet | R-50-D8  | 512x1024  |   80000 | -        | -              | V100   | 78.01 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x1024_80k_cityscapes/nonlocal_r50-d8_512x1024_80k_cityscapes_20200607_193518-d6839fae.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x1024_80k_cityscapes/nonlocal_r50-d8_512x1024_80k_cityscapes_20200607_193518.log.json)     |
-| NonLocalNet | R-101-D8 | 512x1024  |   80000 | -        | -              | V100   | 78.93 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x1024_80k_cityscapes/nonlocal_r101-d8_512x1024_80k_cityscapes_20200607_183411-32700183.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x1024_80k_cityscapes/nonlocal_r101-d8_512x1024_80k_cityscapes_20200607_183411.log.json) |
-| NonLocalNet | R-50-D8  | 769x769   |   80000 | -        | -              | V100   | 79.05 | 80.68         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_769x769_80k_cityscapes/nonlocal_r50-d8_769x769_80k_cityscapes_20200607_193506-1f9792f6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_769x769_80k_cityscapes/nonlocal_r50-d8_769x769_80k_cityscapes_20200607_193506.log.json)         |
-| NonLocalNet | R-101-D8 | 769x769   |   80000 | -        | -              | V100   | 79.40 | 80.85         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_769x769_80k_cityscapes/nonlocal_r101-d8_769x769_80k_cityscapes_20200607_183428-0e1fa4f9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_769x769_80k_cityscapes/nonlocal_r101-d8_769x769_80k_cityscapes_20200607_183428.log.json)     |
-
-### ADE20K
-
-| Method      | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                             | download                                                                                                                                                                                                                                                                                                                                                     |
-| ----------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ---------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| NonLocalNet | R-50-D8  | 512x512   |   80000 | 9.1      | 21.37          | V100   | 40.75 |         42.05 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_80k_ade20k/nonlocal_r50-d8_512x512_80k_ade20k_20200615_015801-5ae0aa33.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_80k_ade20k/nonlocal_r50-d8_512x512_80k_ade20k_20200615_015801.log.json)         |
-| NonLocalNet | R-101-D8 | 512x512   |   80000 | 12.6     | 13.97          | V100   | 42.90 |         44.27 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_80k_ade20k/nonlocal_r101-d8_512x512_80k_ade20k_20200615_015758-24105919.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_80k_ade20k/nonlocal_r101-d8_512x512_80k_ade20k_20200615_015758.log.json)     |
-| NonLocalNet | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 42.03 |         43.04 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_160k_ade20k/nonlocal_r50-d8_512x512_160k_ade20k_20200616_005410-baef45e3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_160k_ade20k/nonlocal_r50-d8_512x512_160k_ade20k_20200616_005410.log.json)     |
-| NonLocalNet | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 44.63 |         45.79 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_160k_ade20k/nonlocal_r101-d8_512x512_160k_ade20k_20210827_221502-7881aa1a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_160k_ade20k/nonlocal_r101-d8_512x512_160k_ade20k_20210827_221502.log.json) |
-
-### Pascal VOC 2012 + Aug
-
-| Method      | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                              | download                                                                                                                                                                                                                                                                                                                                                         |
-| ----------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ----------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| NonLocalNet | R-50-D8  | 512x512   |   20000 | 6.4      | 21.21          | V100   | 76.20 |         77.12 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r50-d8_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_20k_voc12aug/nonlocal_r50-d8_512x512_20k_voc12aug_20200617_222613-07f2a57c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_20k_voc12aug/nonlocal_r50-d8_512x512_20k_voc12aug_20200617_222613.log.json)     |
-| NonLocalNet | R-101-D8 | 512x512   |   20000 | 9.8      | 14.01          | V100   | 78.15 |         78.86 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r101-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_20k_voc12aug/nonlocal_r101-d8_512x512_20k_voc12aug_20200617_222615-948c68ab.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_20k_voc12aug/nonlocal_r101-d8_512x512_20k_voc12aug_20200617_222615.log.json) |
-| NonLocalNet | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 76.65 |         77.47 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r50-d8_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_40k_voc12aug/nonlocal_r50-d8_512x512_40k_voc12aug_20200614_000028-0139d4a9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_40k_voc12aug/nonlocal_r50-d8_512x512_40k_voc12aug_20200614_000028.log.json)     |
-| NonLocalNet | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 78.27 |         79.12 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net/nonlocal_r101-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_40k_voc12aug/nonlocal_r101-d8_512x512_40k_voc12aug_20200614_000028-7e5ff470.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_40k_voc12aug/nonlocal_r101-d8_512x512_40k_voc12aug_20200614_000028.log.json) |
-
-## Citation
-
-```bibtex
-@inproceedings{wang2018non,
-  title={Non-local neural networks},
-  author={Wang, Xiaolong and Girshick, Ross and Gupta, Abhinav and He, Kaiming},
-  booktitle={Proceedings of the IEEE conference on computer vision and pattern recognition},
-  pages={7794--7803},
-  year={2018}
-}
-```
diff --git a/mmsegmentation/configs/nonlocal_net/metafile.yaml b/mmsegmentation/configs/nonlocal_net/metafile.yaml
deleted file mode 100644
index 69bd725..0000000
--- a/mmsegmentation/configs/nonlocal_net/metafile.yaml
+++ /dev/null
@@ -1,387 +0,0 @@
-Collections:
-- Name: NonLocalNet
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-    - ADE20K
-    - Pascal VOC 2012 + Aug
-  Paper:
-    Title: Non-local Neural Networks
-    URL: https://arxiv.org/abs/1711.07971
-  README: configs/nonlocal_net/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: nonlocal_r50-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: NonLocalNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.24
-  Config: configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - NonLocalNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 7.4
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x1024_40k_cityscapes/nonlocal_r50-d8_512x1024_40k_cityscapes_20200605_210748-c75e81e3.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x1024_40k_cityscapes/nonlocal_r50-d8_512x1024_40k_cityscapes_20200605_210748.log.json
-  Paper:
-    Title: Non-local Neural Networks
-    URL: https://arxiv.org/abs/1711.07971
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
-  Framework: PyTorch
-- Name: nonlocal_r101-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: NonLocalNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.66
-  Config: configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - NonLocalNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x1024_40k_cityscapes/nonlocal_r101-d8_512x1024_40k_cityscapes_20200605_210748-d63729fa.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x1024_40k_cityscapes/nonlocal_r101-d8_512x1024_40k_cityscapes_20200605_210748.log.json
-  Paper:
-    Title: Non-local Neural Networks
-    URL: https://arxiv.org/abs/1711.07971
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
-  Framework: PyTorch
-- Name: nonlocal_r50-d8_4xb2-40k_cityscapes-769x769
-  In Collection: NonLocalNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.33
-      mIoU(ms+flip): 79.92
-  Config: configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - NonLocalNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_769x769_40k_cityscapes/nonlocal_r50-d8_769x769_40k_cityscapes_20200530_045243-82ef6749.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_769x769_40k_cityscapes/nonlocal_r50-d8_769x769_40k_cityscapes_20200530_045243.log.json
-  Paper:
-    Title: Non-local Neural Networks
-    URL: https://arxiv.org/abs/1711.07971
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
-  Framework: PyTorch
-- Name: nonlocal_r101-d8_4xb2-40k_cityscapes-769x769
-  In Collection: NonLocalNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.57
-      mIoU(ms+flip): 80.29
-  Config: configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - NonLocalNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 12.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_769x769_40k_cityscapes/nonlocal_r101-d8_769x769_40k_cityscapes_20200530_045348-8fe9a9dc.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_769x769_40k_cityscapes/nonlocal_r101-d8_769x769_40k_cityscapes_20200530_045348.log.json
-  Paper:
-    Title: Non-local Neural Networks
-    URL: https://arxiv.org/abs/1711.07971
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
-  Framework: PyTorch
-- Name: nonlocal_r50-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: NonLocalNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.01
-  Config: configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - NonLocalNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x1024_80k_cityscapes/nonlocal_r50-d8_512x1024_80k_cityscapes_20200607_193518-d6839fae.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x1024_80k_cityscapes/nonlocal_r50-d8_512x1024_80k_cityscapes_20200607_193518.log.json
-  Paper:
-    Title: Non-local Neural Networks
-    URL: https://arxiv.org/abs/1711.07971
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
-  Framework: PyTorch
-- Name: nonlocal_r101-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: NonLocalNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.93
-  Config: configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - NonLocalNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x1024_80k_cityscapes/nonlocal_r101-d8_512x1024_80k_cityscapes_20200607_183411-32700183.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x1024_80k_cityscapes/nonlocal_r101-d8_512x1024_80k_cityscapes_20200607_183411.log.json
-  Paper:
-    Title: Non-local Neural Networks
-    URL: https://arxiv.org/abs/1711.07971
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
-  Framework: PyTorch
-- Name: nonlocal_r50-d8_4xb2-80k_cityscapes-769x769
-  In Collection: NonLocalNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.05
-      mIoU(ms+flip): 80.68
-  Config: configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - NonLocalNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_769x769_80k_cityscapes/nonlocal_r50-d8_769x769_80k_cityscapes_20200607_193506-1f9792f6.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_769x769_80k_cityscapes/nonlocal_r50-d8_769x769_80k_cityscapes_20200607_193506.log.json
-  Paper:
-    Title: Non-local Neural Networks
-    URL: https://arxiv.org/abs/1711.07971
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
-  Framework: PyTorch
-- Name: nonlocal_r101-d8_4xb2-80k_cityscapes-769x769
-  In Collection: NonLocalNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.4
-      mIoU(ms+flip): 80.85
-  Config: configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - NonLocalNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_769x769_80k_cityscapes/nonlocal_r101-d8_769x769_80k_cityscapes_20200607_183428-0e1fa4f9.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_769x769_80k_cityscapes/nonlocal_r101-d8_769x769_80k_cityscapes_20200607_183428.log.json
-  Paper:
-    Title: Non-local Neural Networks
-    URL: https://arxiv.org/abs/1711.07971
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
-  Framework: PyTorch
-- Name: nonlocal_r50-d8_4xb4-80k_ade20k-512x512
-  In Collection: NonLocalNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 40.75
-      mIoU(ms+flip): 42.05
-  Config: configs/nonlocal_net/nonlocal_r50-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - NonLocalNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_80k_ade20k/nonlocal_r50-d8_512x512_80k_ade20k_20200615_015801-5ae0aa33.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_80k_ade20k/nonlocal_r50-d8_512x512_80k_ade20k_20200615_015801.log.json
-  Paper:
-    Title: Non-local Neural Networks
-    URL: https://arxiv.org/abs/1711.07971
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
-  Framework: PyTorch
-- Name: nonlocal_r101-d8_4xb4-80k_ade20k-512x512
-  In Collection: NonLocalNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.9
-      mIoU(ms+flip): 44.27
-  Config: configs/nonlocal_net/nonlocal_r101-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - NonLocalNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 12.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_80k_ade20k/nonlocal_r101-d8_512x512_80k_ade20k_20200615_015758-24105919.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_80k_ade20k/nonlocal_r101-d8_512x512_80k_ade20k_20200615_015758.log.json
-  Paper:
-    Title: Non-local Neural Networks
-    URL: https://arxiv.org/abs/1711.07971
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
-  Framework: PyTorch
-- Name: nonlocal_r50-d8_4xb4-160k_ade20k-512x512
-  In Collection: NonLocalNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.03
-      mIoU(ms+flip): 43.04
-  Config: configs/nonlocal_net/nonlocal_r50-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - NonLocalNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_160k_ade20k/nonlocal_r50-d8_512x512_160k_ade20k_20200616_005410-baef45e3.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_160k_ade20k/nonlocal_r50-d8_512x512_160k_ade20k_20200616_005410.log.json
-  Paper:
-    Title: Non-local Neural Networks
-    URL: https://arxiv.org/abs/1711.07971
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
-  Framework: PyTorch
-- Name: nonlocal_r101-d8_4xb4-160k_ade20k-512x512
-  In Collection: NonLocalNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 44.63
-      mIoU(ms+flip): 45.79
-  Config: configs/nonlocal_net/nonlocal_r101-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - NonLocalNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_160k_ade20k/nonlocal_r101-d8_512x512_160k_ade20k_20210827_221502-7881aa1a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_160k_ade20k/nonlocal_r101-d8_512x512_160k_ade20k_20210827_221502.log.json
-  Paper:
-    Title: Non-local Neural Networks
-    URL: https://arxiv.org/abs/1711.07971
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
-  Framework: PyTorch
-- Name: nonlocal_r50-d8_4xb4-20k_voc12aug-512x512
-  In Collection: NonLocalNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 76.2
-      mIoU(ms+flip): 77.12
-  Config: configs/nonlocal_net/nonlocal_r50-d8_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - NonLocalNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.4
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_20k_voc12aug/nonlocal_r50-d8_512x512_20k_voc12aug_20200617_222613-07f2a57c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_20k_voc12aug/nonlocal_r50-d8_512x512_20k_voc12aug_20200617_222613.log.json
-  Paper:
-    Title: Non-local Neural Networks
-    URL: https://arxiv.org/abs/1711.07971
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
-  Framework: PyTorch
-- Name: nonlocal_r101-d8_4xb4-20k_voc12aug-512x512
-  In Collection: NonLocalNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 78.15
-      mIoU(ms+flip): 78.86
-  Config: configs/nonlocal_net/nonlocal_r101-d8_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - NonLocalNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_20k_voc12aug/nonlocal_r101-d8_512x512_20k_voc12aug_20200617_222615-948c68ab.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_20k_voc12aug/nonlocal_r101-d8_512x512_20k_voc12aug_20200617_222615.log.json
-  Paper:
-    Title: Non-local Neural Networks
-    URL: https://arxiv.org/abs/1711.07971
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
-  Framework: PyTorch
-- Name: nonlocal_r50-d8_4xb4-40k_voc12aug-512x512
-  In Collection: NonLocalNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 76.65
-      mIoU(ms+flip): 77.47
-  Config: configs/nonlocal_net/nonlocal_r50-d8_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - NonLocalNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_40k_voc12aug/nonlocal_r50-d8_512x512_40k_voc12aug_20200614_000028-0139d4a9.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r50-d8_512x512_40k_voc12aug/nonlocal_r50-d8_512x512_40k_voc12aug_20200614_000028.log.json
-  Paper:
-    Title: Non-local Neural Networks
-    URL: https://arxiv.org/abs/1711.07971
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
-  Framework: PyTorch
-- Name: nonlocal_r101-d8_4xb4-40k_voc12aug-512x512
-  In Collection: NonLocalNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 78.27
-      mIoU(ms+flip): 79.12
-  Config: configs/nonlocal_net/nonlocal_r101-d8_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - NonLocalNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_40k_voc12aug/nonlocal_r101-d8_512x512_40k_voc12aug_20200614_000028-7e5ff470.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/nonlocal_net/nonlocal_r101-d8_512x512_40k_voc12aug/nonlocal_r101-d8_512x512_40k_voc12aug_20200614_000028.log.json
-  Paper:
-    Title: Non-local Neural Networks
-    URL: https://arxiv.org/abs/1711.07971
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/nl_head.py#L10
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 5fcf7bc..0000000
--- a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './nonlocal_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index ee984c2..0000000
--- a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './nonlocal_r50-d8_4xb2-40k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index aca80d6..0000000
--- a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './nonlocal_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 8a7aeea..0000000
--- a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './nonlocal_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 0cdb3ca..0000000
--- a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './nonlocal_r50-d8_4xb4-160k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index a7cacea..0000000
--- a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './nonlocal_r50-d8_4xb4-20k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index ec47544..0000000
--- a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './nonlocal_r50-d8_4xb4-40k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index ca79f6f..0000000
--- a/mmsegmentation/configs/nonlocal_net/nonlocal_r101-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './nonlocal_r50-d8_4xb4-80k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index f4d5fd2..0000000
--- a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/nonlocal_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index 17423f2..0000000
--- a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/nonlocal_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 7cc752c..0000000
--- a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/nonlocal_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index f855a81..0000000
--- a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/nonlocal_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 848be4a..0000000
--- a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/nonlocal_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index cd840a0..0000000
--- a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/nonlocal_r50-d8.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_20k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index 0efb9d0..0000000
--- a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/nonlocal_r50-d8.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 52783bc..0000000
--- a/mmsegmentation/configs/nonlocal_net/nonlocal_r50-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/nonlocal_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/ocrnet/README.md b/mmsegmentation/configs/ocrnet/README.md
deleted file mode 100644
index 628a3b1..0000000
--- a/mmsegmentation/configs/ocrnet/README.md
+++ /dev/null
@@ -1,89 +0,0 @@
-# OCRNet
-
-> [Object-Contextual Representations for Semantic Segmentation](https://arxiv.org/abs/1909.11065)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/openseg-group/OCNet.pytorch">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-In this paper, we address the problem of semantic segmentation and focus on the context aggregation strategy for robust segmentation. Our motivation is that the label of a pixel is the category of the object that the pixel belongs to. We present a simple yet effective approach, object-contextual representations, characterizing a pixel by exploiting the representation of the corresponding object class. First, we construct object regions based on a feature map supervised by the ground-truth segmentation, and then compute the object region representations. Second, we compute the representation similarity between each pixel and each object region, and augment the representation of each pixel with an object contextual representation, which is a weighted aggregation of all the object region representations according to their similarities with the pixel. We empirically demonstrate that the proposed approach achieves competitive performance on six challenging semantic segmentation benchmarks: Cityscapes, ADE20K, LIP, PASCAL VOC 2012, PASCAL-Context and COCO-Stuff. Notably, we achieved the \\nth{2} place on the Cityscapes leader-board with a single model.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142902197-b06b1e04-57ab-44ac-adc8-cea6695bb236.png" width="70%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-#### HRNet backbone
-
-| Method | Backbone           | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                        | download                                                                                                                                                                                                                                                                                                                                                         |
-| ------ | ------------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ----------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| OCRNet | HRNetV2p-W18-Small | 512x1024  |   40000 | 3.5      | 10.45          | A100   | 76.61 |         78.01 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024_20230227_145026-6c052a14.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024_20230227_145026.json) |
-| OCRNet | HRNetV2p-W18       | 512x1024  |   40000 | 4.7      | 7.50           | V100   | 77.72 |         79.49 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18_4xb2-40k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_40k_cityscapes/ocrnet_hr18_512x1024_40k_cityscapes_20200601_033320-401c5bdd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_40k_cityscapes/ocrnet_hr18_512x1024_40k_cityscapes_20200601_033320.log.json)                     |
-| OCRNet | HRNetV2p-W48       | 512x1024  |   40000 | 8        | 4.22           | V100   | 80.58 |         81.79 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr48_4xb2-40k_cityscapes-512x1024.pyy)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_40k_cityscapes/ocrnet_hr48_512x1024_40k_cityscapes_20200601_033336-55b32491.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_40k_cityscapes/ocrnet_hr48_512x1024_40k_cityscapes_20200601_033336.log.json)                     |
-| OCRNet | HRNetV2p-W18-Small | 512x1024  |   80000 | -        | -              | V100   | 77.16 |         78.66 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18s_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x1024_80k_cityscapes/ocrnet_hr18s_512x1024_80k_cityscapes_20200601_222735-55979e63.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x1024_80k_cityscapes/ocrnet_hr18s_512x1024_80k_cityscapes_20200601_222735.log.json)                 |
-| OCRNet | HRNetV2p-W18       | 512x1024  |   80000 | -        | -              | V100   | 78.57 |         80.46 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18_4xb2-80k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_80k_cityscapes/ocrnet_hr18_512x1024_80k_cityscapes_20200614_230521-c2e1dd4a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_80k_cityscapes/ocrnet_hr18_512x1024_80k_cityscapes_20200614_230521.log.json)                     |
-| OCRNet | HRNetV2p-W48       | 512x1024  |   80000 | -        | -              | V100   | 80.70 |         81.87 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr48_4xb2-80k_cityscapes-512x1024.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_80k_cityscapes/ocrnet_hr48_512x1024_80k_cityscapes_20200601_222752-9076bcdf.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_80k_cityscapes/ocrnet_hr48_512x1024_80k_cityscapes_20200601_222752.log.json)                     |
-| OCRNet | HRNetV2p-W18-Small | 512x1024  |  160000 | -        | -              | V100   | 78.45 |         79.97 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18s_4xb2-160k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x1024_160k_cityscapes/ocrnet_hr18s_512x1024_160k_cityscapes_20200602_191005-f4a7af28.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x1024_160k_cityscapes/ocrnet_hr18s_512x1024_160k_cityscapes_20200602_191005.log.json)             |
-| OCRNet | HRNetV2p-W18       | 512x1024  |  160000 | -        | -              | V100   | 79.47 |         80.91 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18_4xb2-160k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_160k_cityscapes/ocrnet_hr18_512x1024_160k_cityscapes_20200602_191001-b9172d0c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_160k_cityscapes/ocrnet_hr18_512x1024_160k_cityscapes_20200602_191001.log.json)                 |
-| OCRNet | HRNetV2p-W48       | 512x1024  |  160000 | -        | -              | V100   | 81.35 |         82.70 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr48_4xb2-160k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_160k_cityscapes/ocrnet_hr48_512x1024_160k_cityscapes_20200602_191037-dfbf1b0c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_160k_cityscapes/ocrnet_hr48_512x1024_160k_cityscapes_20200602_191037.log.json)                 |
-
-#### ResNet backbone
-
-| Method | Backbone | Crop Size | Batch Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                         | download                                                                                                                                                                                                                                                                                                                                                                 |
-| ------ | -------- | --------- | ---------- | ------- | -------- | -------------- | ------ | ----- | ------------: | ------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| OCRNet | R-101-D8 | 512x1024  | 8          | 40000   | -        | -              | V100   | 80.09 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_r101-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_40k_b8_cityscapes/ocrnet_r101-d8_512x1024_40k_b8_cityscapes_20200717_110721-02ac0f13.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_40k_b8_cityscapes/ocrnet_r101-d8_512x1024_40k_b8_cityscapes_20200717_110721.log.json)     |
-| OCRNet | R-101-D8 | 512x1024  | 16         | 40000   | 8.8      | 3.02           | V100   | 80.30 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_r101-d8_8xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_40k_b16_cityscapes/ocrnet_r101-d8_512x1024_40k_b16_cityscapes_20200723_193726-db500f80.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_40k_b16_cityscapes/ocrnet_r101-d8_512x1024_40k_b16_cityscapes_20200723_193726.log.json) |
-| OCRNet | R-101-D8 | 512x1024  | 16         | 80000   | 8.8      | 3.02           | V100   | 80.81 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_r101-d8_8xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_80k_b16_cityscapes/ocrnet_r101-d8_512x1024_80k_b16_cityscapes_20200723_192421-78688424.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_80k_b16_cityscapes/ocrnet_r101-d8_512x1024_80k_b16_cityscapes_20200723_192421.log.json) |
-
-### ADE20K
-
-| Method | Backbone           | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                  | download                                                                                                                                                                                                                                                                                                                         |
-| ------ | ------------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ----------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| OCRNet | HRNetV2p-W18-Small | 512x512   |   80000 | 6.7      | 28.98          | V100   | 35.06 |         35.80 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18s_4xb4-80k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_80k_ade20k/ocrnet_hr18s_512x512_80k_ade20k_20200615_055600-e80b62af.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_80k_ade20k/ocrnet_hr18s_512x512_80k_ade20k_20200615_055600.log.json)     |
-| OCRNet | HRNetV2p-W18       | 512x512   |   80000 | 7.9      | 18.93          | V100   | 37.79 |         39.16 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_80k_ade20k/ocrnet_hr18_512x512_80k_ade20k_20200615_053157-d173d83b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_80k_ade20k/ocrnet_hr18_512x512_80k_ade20k_20200615_053157.log.json)         |
-| OCRNet | HRNetV2p-W48       | 512x512   |   80000 | 11.2     | 16.99          | V100   | 43.00 |         44.30 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr48_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_80k_ade20k/ocrnet_hr48_512x512_80k_ade20k_20200615_021518-d168c2d1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_80k_ade20k/ocrnet_hr48_512x512_80k_ade20k_20200615_021518.log.json)         |
-| OCRNet | HRNetV2p-W18-Small | 512x512   |  160000 | -        | -              | V100   | 37.19 |         38.40 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18s_4xb4-80k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_160k_ade20k/ocrnet_hr18s_512x512_160k_ade20k_20200615_184505-8e913058.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_160k_ade20k/ocrnet_hr18s_512x512_160k_ade20k_20200615_184505.log.json) |
-| OCRNet | HRNetV2p-W18       | 512x512   |  160000 | -        | -              | V100   | 39.32 |         40.80 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_160k_ade20k/ocrnet_hr18_512x512_160k_ade20k_20200615_200940-d8fcd9d1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_160k_ade20k/ocrnet_hr18_512x512_160k_ade20k_20200615_200940.log.json)     |
-| OCRNet | HRNetV2p-W48       | 512x512   |  160000 | -        | -              | V100   | 43.25 |         44.88 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr48_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_160k_ade20k/ocrnet_hr48_512x512_160k_ade20k_20200615_184705-a073726d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_160k_ade20k/ocrnet_hr48_512x512_160k_ade20k_20200615_184705.log.json)     |
-
-### Pascal VOC 2012 + Aug
-
-| Method | Backbone           | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                    | download                                                                                                                                                                                                                                                                                                                             |
-| ------ | ------------------ | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| OCRNet | HRNetV2p-W18-Small | 512x512   |   20000 | 3.5      | 31.55          | V100   | 71.70 |         73.84 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18s_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_20k_voc12aug/ocrnet_hr18s_512x512_20k_voc12aug_20200617_233913-02b04fcb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_20k_voc12aug/ocrnet_hr18s_512x512_20k_voc12aug_20200617_233913.log.json) |
-| OCRNet | HRNetV2p-W18       | 512x512   |   20000 | 4.7      | 19.91          | V100   | 74.75 |         77.11 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_20k_voc12aug/ocrnet_hr18_512x512_20k_voc12aug_20200617_233932-8954cbb7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_20k_voc12aug/ocrnet_hr18_512x512_20k_voc12aug_20200617_233932.log.json)     |
-| OCRNet | HRNetV2p-W48       | 512x512   |   20000 | 8.1      | 17.83          | V100   | 77.72 |         79.87 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr48_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_20k_voc12aug/ocrnet_hr48_512x512_20k_voc12aug_20200617_233932-9e82080a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_20k_voc12aug/ocrnet_hr48_512x512_20k_voc12aug_20200617_233932.log.json)     |
-| OCRNet | HRNetV2p-W18-Small | 512x512   |   40000 | -        | -              | V100   | 72.76 |         74.60 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18s_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_40k_voc12aug/ocrnet_hr18s_512x512_40k_voc12aug_20200614_002025-42b587ac.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_40k_voc12aug/ocrnet_hr18s_512x512_40k_voc12aug_20200614_002025.log.json) |
-| OCRNet | HRNetV2p-W18       | 512x512   |   40000 | -        | -              | V100   | 74.98 |         77.40 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr18_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_40k_voc12aug/ocrnet_hr18_512x512_40k_voc12aug_20200614_015958-714302be.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_40k_voc12aug/ocrnet_hr18_512x512_40k_voc12aug_20200614_015958.log.json)     |
-| OCRNet | HRNetV2p-W48       | 512x512   |   40000 | -        | -              | V100   | 77.14 |         79.71 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet/ocrnet_hr48_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_40k_voc12aug/ocrnet_hr48_512x512_40k_voc12aug_20200614_015958-255bc5ce.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_40k_voc12aug/ocrnet_hr48_512x512_40k_voc12aug_20200614_015958.log.json)     |
-
-## Citation
-
-```bibtex
-@article{YuanW18,
-  title={Ocnet: Object context network for scene parsing},
-  author={Yuhui Yuan and Jingdong Wang},
-  booktitle={arXiv preprint arXiv:1809.00916},
-  year={2018}
-}
-
-@article{YuanCW20,
-  title={Object-Contextual Representations for Semantic Segmentation},
-  author={Yuhui Yuan and Xilin Chen and Jingdong Wang},
-  booktitle={ECCV},
-  year={2020}
-}
-```
diff --git a/mmsegmentation/configs/ocrnet/metafile.yaml b/mmsegmentation/configs/ocrnet/metafile.yaml
deleted file mode 100644
index 5467feb..0000000
--- a/mmsegmentation/configs/ocrnet/metafile.yaml
+++ /dev/null
@@ -1,577 +0,0 @@
-Collections:
-- Name: OCRNet
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-    - '# HRNet backbone'
-    - '# ResNet backbone'
-    - ADE20K
-    - Pascal VOC 2012 + Aug
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  README: configs/ocrnet/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: ocrnet_hr18s_4xb2-40k_cityscapes-512x1024
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: '# HRNet backbone'
-    Metrics:
-      mIoU: 76.61
-      mIoU(ms+flip): 78.01
-  Config: configs/ocrnet/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: '# HRNet backbone'
-    Batch Size: 8
-    Architecture:
-    - HRNetV2p-W18-Small
-    - OCRNet
-    Training Resources: 4x A100 GPUS
-    Memory (GB): 3.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024_20230227_145026-6c052a14.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024_20230227_145026.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
-- Name: ocrnet_hr18_4xb2-40k_cityscapes-512x1024
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: '# HRNet backbone'
-    Metrics:
-      mIoU: 77.72
-      mIoU(ms+flip): 79.49
-  Config: configs/ocrnet/ocrnet_hr18_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: '# HRNet backbone'
-    Batch Size: 8
-    Architecture:
-    - HRNetV2p-W18
-    - OCRNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 4.7
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_40k_cityscapes/ocrnet_hr18_512x1024_40k_cityscapes_20200601_033320-401c5bdd.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_40k_cityscapes/ocrnet_hr18_512x1024_40k_cityscapes_20200601_033320.log.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
-- Name: ocrnet_hr48_4xb2-40k_cityscapes-512x1024
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: '# HRNet backbone'
-    Metrics:
-      mIoU: 80.58
-      mIoU(ms+flip): 81.79
-  Config: configs/ocrnet/ocrnet_hr48_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: '# HRNet backbone'
-    Batch Size: 8
-    Architecture:
-    - HRNetV2p-W48
-    - OCRNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_40k_cityscapes/ocrnet_hr48_512x1024_40k_cityscapes_20200601_033336-55b32491.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_40k_cityscapes/ocrnet_hr48_512x1024_40k_cityscapes_20200601_033336.log.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
-- Name: ocrnet_hr18s_4xb2-80k_cityscapes-512x1024
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: '# HRNet backbone'
-    Metrics:
-      mIoU: 77.16
-      mIoU(ms+flip): 78.66
-  Config: configs/ocrnet/ocrnet_hr18s_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: '# HRNet backbone'
-    Batch Size: 8
-    Architecture:
-    - HRNetV2p-W18-Small
-    - OCRNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x1024_80k_cityscapes/ocrnet_hr18s_512x1024_80k_cityscapes_20200601_222735-55979e63.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x1024_80k_cityscapes/ocrnet_hr18s_512x1024_80k_cityscapes_20200601_222735.log.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
-- Name: ocrnet_hr18_4xb2-80k_cityscapes-512x1024
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: '# HRNet backbone'
-    Metrics:
-      mIoU: 78.57
-      mIoU(ms+flip): 80.46
-  Config: configs/ocrnet/ocrnet_hr18_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: '# HRNet backbone'
-    Batch Size: 8
-    Architecture:
-    - HRNetV2p-W18
-    - OCRNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_80k_cityscapes/ocrnet_hr18_512x1024_80k_cityscapes_20200614_230521-c2e1dd4a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_80k_cityscapes/ocrnet_hr18_512x1024_80k_cityscapes_20200614_230521.log.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
-- Name: ocrnet_hr48_4xb2-80k_cityscapes-512x1024
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: '# HRNet backbone'
-    Metrics:
-      mIoU: 80.7
-      mIoU(ms+flip): 81.87
-  Config: configs/ocrnet/ocrnet_hr48_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: '# HRNet backbone'
-    Batch Size: 8
-    Architecture:
-    - HRNetV2p-W48
-    - OCRNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_80k_cityscapes/ocrnet_hr48_512x1024_80k_cityscapes_20200601_222752-9076bcdf.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_80k_cityscapes/ocrnet_hr48_512x1024_80k_cityscapes_20200601_222752.log.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
-- Name: ocrnet_hr18s_4xb2-160k_cityscapes-512x1024
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: '# HRNet backbone'
-    Metrics:
-      mIoU: 78.45
-      mIoU(ms+flip): 79.97
-  Config: configs/ocrnet/ocrnet_hr18s_4xb2-160k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: '# HRNet backbone'
-    Batch Size: 8
-    Architecture:
-    - HRNetV2p-W18-Small
-    - OCRNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x1024_160k_cityscapes/ocrnet_hr18s_512x1024_160k_cityscapes_20200602_191005-f4a7af28.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x1024_160k_cityscapes/ocrnet_hr18s_512x1024_160k_cityscapes_20200602_191005.log.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
-- Name: ocrnet_hr18_4xb2-160k_cityscapes-512x1024
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: '# HRNet backbone'
-    Metrics:
-      mIoU: 79.47
-      mIoU(ms+flip): 80.91
-  Config: configs/ocrnet/ocrnet_hr18_4xb2-160k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: '# HRNet backbone'
-    Batch Size: 8
-    Architecture:
-    - HRNetV2p-W18
-    - OCRNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_160k_cityscapes/ocrnet_hr18_512x1024_160k_cityscapes_20200602_191001-b9172d0c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x1024_160k_cityscapes/ocrnet_hr18_512x1024_160k_cityscapes_20200602_191001.log.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
-- Name: ocrnet_hr48_4xb2-160k_cityscapes-512x1024
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: '# HRNet backbone'
-    Metrics:
-      mIoU: 81.35
-      mIoU(ms+flip): 82.7
-  Config: configs/ocrnet/ocrnet_hr48_4xb2-160k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: '# HRNet backbone'
-    Batch Size: 8
-    Architecture:
-    - HRNetV2p-W48
-    - OCRNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_160k_cityscapes/ocrnet_hr48_512x1024_160k_cityscapes_20200602_191037-dfbf1b0c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x1024_160k_cityscapes/ocrnet_hr48_512x1024_160k_cityscapes_20200602_191037.log.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
-- Name: ocrnet_r101-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: '# ResNet backbone'
-    Metrics:
-      mIoU: 80.09
-  Config: configs/ocrnet/ocrnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: '# ResNet backbone'
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - OCRNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_40k_b8_cityscapes/ocrnet_r101-d8_512x1024_40k_b8_cityscapes_20200717_110721-02ac0f13.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_40k_b8_cityscapes/ocrnet_r101-d8_512x1024_40k_b8_cityscapes_20200717_110721.log.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
-- Name: ocrnet_r101-d8_8xb2-40k_cityscapes-512x1024
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: '# ResNet backbone'
-    Metrics:
-      mIoU: 80.3
-  Config: configs/ocrnet/ocrnet_r101-d8_8xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: '# ResNet backbone'
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - OCRNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 8.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_40k_b16_cityscapes/ocrnet_r101-d8_512x1024_40k_b16_cityscapes_20200723_193726-db500f80.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_40k_b16_cityscapes/ocrnet_r101-d8_512x1024_40k_b16_cityscapes_20200723_193726.log.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
-- Name: ocrnet_r101-d8_8xb2-80k_cityscapes-512x1024
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: '# ResNet backbone'
-    Metrics:
-      mIoU: 80.81
-  Config: configs/ocrnet/ocrnet_r101-d8_8xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: '# ResNet backbone'
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - OCRNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 8.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_80k_b16_cityscapes/ocrnet_r101-d8_512x1024_80k_b16_cityscapes_20200723_192421-78688424.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_r101-d8_512x1024_80k_b16_cityscapes/ocrnet_r101-d8_512x1024_80k_b16_cityscapes_20200723_192421.log.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
-- Name: ocrnet_hr18s_4xb4-80k_ade20k-512x512
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 35.06
-      mIoU(ms+flip): 35.8
-  Config: configs/ocrnet/ocrnet_hr18s_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18-Small
-    - OCRNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.7
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_80k_ade20k/ocrnet_hr18s_512x512_80k_ade20k_20200615_055600-e80b62af.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_80k_ade20k/ocrnet_hr18s_512x512_80k_ade20k_20200615_055600.log.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
-- Name: ocrnet_hr18_4xb4-80k_ade20k-512x512
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 37.79
-      mIoU(ms+flip): 39.16
-  Config: configs/ocrnet/ocrnet_hr18_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18
-    - OCRNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 7.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_80k_ade20k/ocrnet_hr18_512x512_80k_ade20k_20200615_053157-d173d83b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_80k_ade20k/ocrnet_hr18_512x512_80k_ade20k_20200615_053157.log.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
-- Name: ocrnet_hr48_4xb4-80k_ade20k-512x512
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 43.0
-      mIoU(ms+flip): 44.3
-  Config: configs/ocrnet/ocrnet_hr48_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W48
-    - OCRNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 11.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_80k_ade20k/ocrnet_hr48_512x512_80k_ade20k_20200615_021518-d168c2d1.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_80k_ade20k/ocrnet_hr48_512x512_80k_ade20k_20200615_021518.log.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
-- Name: ocrnet_hr18s_4xb4-80k_ade20k-512x512
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 37.19
-      mIoU(ms+flip): 38.4
-  Config: configs/ocrnet/ocrnet_hr18s_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18-Small
-    - OCRNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_160k_ade20k/ocrnet_hr18s_512x512_160k_ade20k_20200615_184505-8e913058.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_160k_ade20k/ocrnet_hr18s_512x512_160k_ade20k_20200615_184505.log.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
-- Name: ocrnet_hr18_4xb4-80k_ade20k-512x512
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 39.32
-      mIoU(ms+flip): 40.8
-  Config: configs/ocrnet/ocrnet_hr18_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18
-    - OCRNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_160k_ade20k/ocrnet_hr18_512x512_160k_ade20k_20200615_200940-d8fcd9d1.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_160k_ade20k/ocrnet_hr18_512x512_160k_ade20k_20200615_200940.log.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
-- Name: ocrnet_hr48_4xb4-160k_ade20k-512x512
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 43.25
-      mIoU(ms+flip): 44.88
-  Config: configs/ocrnet/ocrnet_hr48_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W48
-    - OCRNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_160k_ade20k/ocrnet_hr48_512x512_160k_ade20k_20200615_184705-a073726d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_160k_ade20k/ocrnet_hr48_512x512_160k_ade20k_20200615_184705.log.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
-- Name: ocrnet_hr18s_4xb4-20k_voc12aug-512x512
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 71.7
-      mIoU(ms+flip): 73.84
-  Config: configs/ocrnet/ocrnet_hr18s_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18-Small
-    - OCRNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 3.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_20k_voc12aug/ocrnet_hr18s_512x512_20k_voc12aug_20200617_233913-02b04fcb.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_20k_voc12aug/ocrnet_hr18s_512x512_20k_voc12aug_20200617_233913.log.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
-- Name: ocrnet_hr18_4xb4-20k_voc12aug-512x512
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 74.75
-      mIoU(ms+flip): 77.11
-  Config: configs/ocrnet/ocrnet_hr18_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18
-    - OCRNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 4.7
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_20k_voc12aug/ocrnet_hr18_512x512_20k_voc12aug_20200617_233932-8954cbb7.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_20k_voc12aug/ocrnet_hr18_512x512_20k_voc12aug_20200617_233932.log.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
-- Name: ocrnet_hr48_4xb4-20k_voc12aug-512x512
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 77.72
-      mIoU(ms+flip): 79.87
-  Config: configs/ocrnet/ocrnet_hr48_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W48
-    - OCRNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_20k_voc12aug/ocrnet_hr48_512x512_20k_voc12aug_20200617_233932-9e82080a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_20k_voc12aug/ocrnet_hr48_512x512_20k_voc12aug_20200617_233932.log.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
-- Name: ocrnet_hr18s_4xb4-40k_voc12aug-512x512
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 72.76
-      mIoU(ms+flip): 74.6
-  Config: configs/ocrnet/ocrnet_hr18s_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18-Small
-    - OCRNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_40k_voc12aug/ocrnet_hr18s_512x512_40k_voc12aug_20200614_002025-42b587ac.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18s_512x512_40k_voc12aug/ocrnet_hr18s_512x512_40k_voc12aug_20200614_002025.log.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
-- Name: ocrnet_hr18_4xb4-40k_voc12aug-512x512
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 74.98
-      mIoU(ms+flip): 77.4
-  Config: configs/ocrnet/ocrnet_hr18_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W18
-    - OCRNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_40k_voc12aug/ocrnet_hr18_512x512_40k_voc12aug_20200614_015958-714302be.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr18_512x512_40k_voc12aug/ocrnet_hr18_512x512_40k_voc12aug_20200614_015958.log.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
-- Name: ocrnet_hr48_4xb4-40k_voc12aug-512x512
-  In Collection: OCRNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 77.14
-      mIoU(ms+flip): 79.71
-  Config: configs/ocrnet/ocrnet_hr48_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - HRNetV2p-W48
-    - OCRNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_40k_voc12aug/ocrnet_hr48_512x512_40k_voc12aug_20200614_015958-255bc5ce.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/ocrnet/ocrnet_hr48_512x512_40k_voc12aug/ocrnet_hr48_512x512_40k_voc12aug_20200614_015958.log.json
-  Paper:
-    Title: Object-Contextual Representations for Semantic Segmentation
-    URL: https://arxiv.org/abs/1909.11065
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/ocr_head.py#L86
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-160k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-160k_cityscapes-512x1024.py
deleted file mode 100644
index 659217c..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-160k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/ocrnet_hr18.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index d401c4b..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/ocrnet_hr18.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 44426a2..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/ocrnet_hr18.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 353005b..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,39 +0,0 @@
-_base_ = [
-    '../_base_/models/ocrnet_hr18.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=[
-        dict(
-            type='FCNHead',
-            in_channels=[18, 36, 72, 144],
-            channels=sum([18, 36, 72, 144]),
-            in_index=(0, 1, 2, 3),
-            input_transform='resize_concat',
-            kernel_size=1,
-            num_convs=1,
-            concat_input=False,
-            dropout_ratio=-1,
-            num_classes=150,
-            norm_cfg=norm_cfg,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-        dict(
-            type='OCRHead',
-            in_channels=[18, 36, 72, 144],
-            in_index=(0, 1, 2, 3),
-            input_transform='resize_concat',
-            channels=512,
-            ocr_channels=256,
-            dropout_ratio=-1,
-            num_classes=150,
-            norm_cfg=norm_cfg,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-    ])
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index c696c21..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,40 +0,0 @@
-_base_ = [
-    '../_base_/models/ocrnet_hr18.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_20k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=[
-        dict(
-            type='FCNHead',
-            in_channels=[18, 36, 72, 144],
-            channels=sum([18, 36, 72, 144]),
-            in_index=(0, 1, 2, 3),
-            input_transform='resize_concat',
-            kernel_size=1,
-            num_convs=1,
-            concat_input=False,
-            dropout_ratio=-1,
-            num_classes=21,
-            norm_cfg=norm_cfg,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-        dict(
-            type='OCRHead',
-            in_channels=[18, 36, 72, 144],
-            in_index=(0, 1, 2, 3),
-            input_transform='resize_concat',
-            channels=512,
-            ocr_channels=256,
-            dropout_ratio=-1,
-            num_classes=21,
-            norm_cfg=norm_cfg,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-    ])
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index c6b69ea..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,40 +0,0 @@
-_base_ = [
-    '../_base_/models/ocrnet_hr18.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=[
-        dict(
-            type='FCNHead',
-            in_channels=[18, 36, 72, 144],
-            channels=sum([18, 36, 72, 144]),
-            in_index=(0, 1, 2, 3),
-            input_transform='resize_concat',
-            kernel_size=1,
-            num_convs=1,
-            concat_input=False,
-            dropout_ratio=-1,
-            num_classes=21,
-            norm_cfg=norm_cfg,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-        dict(
-            type='OCRHead',
-            in_channels=[18, 36, 72, 144],
-            in_index=(0, 1, 2, 3),
-            input_transform='resize_concat',
-            channels=512,
-            ocr_channels=256,
-            dropout_ratio=-1,
-            num_classes=21,
-            norm_cfg=norm_cfg,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-    ])
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index ceca8df..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_hr18_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,39 +0,0 @@
-_base_ = [
-    '../_base_/models/ocrnet_hr18.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=[
-        dict(
-            type='FCNHead',
-            in_channels=[18, 36, 72, 144],
-            channels=sum([18, 36, 72, 144]),
-            in_index=(0, 1, 2, 3),
-            input_transform='resize_concat',
-            kernel_size=1,
-            num_convs=1,
-            concat_input=False,
-            dropout_ratio=-1,
-            num_classes=150,
-            norm_cfg=norm_cfg,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-        dict(
-            type='OCRHead',
-            in_channels=[18, 36, 72, 144],
-            in_index=(0, 1, 2, 3),
-            input_transform='resize_concat',
-            channels=512,
-            ocr_channels=256,
-            dropout_ratio=-1,
-            num_classes=150,
-            norm_cfg=norm_cfg,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-    ])
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-160k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-160k_cityscapes-512x1024.py
deleted file mode 100644
index c5388fb..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-160k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './ocrnet_hr18_4xb2-160k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w18_small',
-    backbone=dict(
-        extra=dict(
-            stage1=dict(num_blocks=(2, )),
-            stage2=dict(num_blocks=(2, 2)),
-            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
-            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 2335f3b..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './ocrnet_hr18_4xb2-40k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w18_small',
-    backbone=dict(
-        extra=dict(
-            stage1=dict(num_blocks=(2, )),
-            stage2=dict(num_blocks=(2, 2)),
-            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
-            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index b2d1a8f..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './ocrnet_hr18_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w18_small',
-    backbone=dict(
-        extra=dict(
-            stage1=dict(num_blocks=(2, )),
-            stage2=dict(num_blocks=(2, 2)),
-            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
-            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index fabf582..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './ocrnet_hr18_4xb4-160k_ade20k-512x512.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w18_small',
-    backbone=dict(
-        extra=dict(
-            stage1=dict(num_blocks=(2, )),
-            stage2=dict(num_blocks=(2, 2)),
-            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
-            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index 0eca655..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './ocrnet_hr18_4xb4-20k_voc12aug-512x512.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w18_small',
-    backbone=dict(
-        extra=dict(
-            stage1=dict(num_blocks=(2, )),
-            stage2=dict(num_blocks=(2, 2)),
-            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
-            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index 13b02b9..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './ocrnet_hr18_4xb4-40k_voc12aug-512x512.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w18_small',
-    backbone=dict(
-        extra=dict(
-            stage1=dict(num_blocks=(2, )),
-            stage2=dict(num_blocks=(2, 2)),
-            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
-            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 60c79c2..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_hr18s_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './ocrnet_hr18_4xb4-80k_ade20k-512x512.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w18_small',
-    backbone=dict(
-        extra=dict(
-            stage1=dict(num_blocks=(2, )),
-            stage2=dict(num_blocks=(2, 2)),
-            stage3=dict(num_modules=3, num_blocks=(2, 2, 2)),
-            stage4=dict(num_modules=2, num_blocks=(2, 2, 2, 2)))))
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-160k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-160k_cityscapes-512x1024.py
deleted file mode 100644
index 184d38d..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-160k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,39 +0,0 @@
-_base_ = './ocrnet_hr18_4xb2-160k_cityscapes-512x1024.py'
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w48',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(48, 96)),
-            stage3=dict(num_channels=(48, 96, 192)),
-            stage4=dict(num_channels=(48, 96, 192, 384)))),
-    decode_head=[
-        dict(
-            type='FCNHead',
-            in_channels=[48, 96, 192, 384],
-            channels=sum([48, 96, 192, 384]),
-            input_transform='resize_concat',
-            in_index=(0, 1, 2, 3),
-            kernel_size=1,
-            num_convs=1,
-            norm_cfg=norm_cfg,
-            concat_input=False,
-            dropout_ratio=-1,
-            num_classes=19,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-        dict(
-            type='OCRHead',
-            in_channels=[48, 96, 192, 384],
-            channels=512,
-            ocr_channels=256,
-            input_transform='resize_concat',
-            in_index=(0, 1, 2, 3),
-            norm_cfg=norm_cfg,
-            dropout_ratio=-1,
-            num_classes=19,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
-    ])
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 7025ee9..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,39 +0,0 @@
-_base_ = './ocrnet_hr18_4xb2-40k_cityscapes-512x1024.py'
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w48',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(48, 96)),
-            stage3=dict(num_channels=(48, 96, 192)),
-            stage4=dict(num_channels=(48, 96, 192, 384)))),
-    decode_head=[
-        dict(
-            type='FCNHead',
-            in_channels=[48, 96, 192, 384],
-            channels=sum([48, 96, 192, 384]),
-            input_transform='resize_concat',
-            in_index=(0, 1, 2, 3),
-            kernel_size=1,
-            num_convs=1,
-            norm_cfg=norm_cfg,
-            concat_input=False,
-            dropout_ratio=-1,
-            num_classes=19,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-        dict(
-            type='OCRHead',
-            in_channels=[48, 96, 192, 384],
-            channels=512,
-            ocr_channels=256,
-            input_transform='resize_concat',
-            in_index=(0, 1, 2, 3),
-            norm_cfg=norm_cfg,
-            dropout_ratio=-1,
-            num_classes=19,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
-    ])
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 9c68a15..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,39 +0,0 @@
-_base_ = './ocrnet_hr18_4xb2-80k_cityscapes-512x1024.py'
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w48',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(48, 96)),
-            stage3=dict(num_channels=(48, 96, 192)),
-            stage4=dict(num_channels=(48, 96, 192, 384)))),
-    decode_head=[
-        dict(
-            type='FCNHead',
-            in_channels=[48, 96, 192, 384],
-            channels=sum([48, 96, 192, 384]),
-            input_transform='resize_concat',
-            in_index=(0, 1, 2, 3),
-            kernel_size=1,
-            num_convs=1,
-            norm_cfg=norm_cfg,
-            concat_input=False,
-            dropout_ratio=-1,
-            num_classes=19,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-        dict(
-            type='OCRHead',
-            in_channels=[48, 96, 192, 384],
-            channels=512,
-            ocr_channels=256,
-            input_transform='resize_concat',
-            in_index=(0, 1, 2, 3),
-            norm_cfg=norm_cfg,
-            dropout_ratio=-1,
-            num_classes=19,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
-    ])
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index e74976c..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,39 +0,0 @@
-_base_ = './ocrnet_hr18_4xb4-160k_ade20k-512x512.py'
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w48',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(48, 96)),
-            stage3=dict(num_channels=(48, 96, 192)),
-            stage4=dict(num_channels=(48, 96, 192, 384)))),
-    decode_head=[
-        dict(
-            type='FCNHead',
-            in_channels=[48, 96, 192, 384],
-            channels=sum([48, 96, 192, 384]),
-            input_transform='resize_concat',
-            in_index=(0, 1, 2, 3),
-            kernel_size=1,
-            num_convs=1,
-            norm_cfg=norm_cfg,
-            concat_input=False,
-            dropout_ratio=-1,
-            num_classes=150,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-        dict(
-            type='OCRHead',
-            in_channels=[48, 96, 192, 384],
-            channels=512,
-            ocr_channels=256,
-            input_transform='resize_concat',
-            in_index=(0, 1, 2, 3),
-            norm_cfg=norm_cfg,
-            dropout_ratio=-1,
-            num_classes=150,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
-    ])
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index f015b92..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,39 +0,0 @@
-_base_ = './ocrnet_hr18_4xb4-20k_voc12aug-512x512.py'
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w48',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(48, 96)),
-            stage3=dict(num_channels=(48, 96, 192)),
-            stage4=dict(num_channels=(48, 96, 192, 384)))),
-    decode_head=[
-        dict(
-            type='FCNHead',
-            in_channels=[48, 96, 192, 384],
-            channels=sum([48, 96, 192, 384]),
-            input_transform='resize_concat',
-            in_index=(0, 1, 2, 3),
-            kernel_size=1,
-            num_convs=1,
-            norm_cfg=norm_cfg,
-            concat_input=False,
-            dropout_ratio=-1,
-            num_classes=21,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-        dict(
-            type='OCRHead',
-            in_channels=[48, 96, 192, 384],
-            channels=512,
-            ocr_channels=256,
-            input_transform='resize_concat',
-            in_index=(0, 1, 2, 3),
-            norm_cfg=norm_cfg,
-            dropout_ratio=-1,
-            num_classes=21,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
-    ])
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index baafa38..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,39 +0,0 @@
-_base_ = './ocrnet_hr18_4xb4-40k_voc12aug-512x512.py'
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w48',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(48, 96)),
-            stage3=dict(num_channels=(48, 96, 192)),
-            stage4=dict(num_channels=(48, 96, 192, 384)))),
-    decode_head=[
-        dict(
-            type='FCNHead',
-            in_channels=[48, 96, 192, 384],
-            channels=sum([48, 96, 192, 384]),
-            input_transform='resize_concat',
-            in_index=(0, 1, 2, 3),
-            kernel_size=1,
-            num_convs=1,
-            norm_cfg=norm_cfg,
-            concat_input=False,
-            dropout_ratio=-1,
-            num_classes=21,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-        dict(
-            type='OCRHead',
-            in_channels=[48, 96, 192, 384],
-            channels=512,
-            ocr_channels=256,
-            input_transform='resize_concat',
-            in_index=(0, 1, 2, 3),
-            norm_cfg=norm_cfg,
-            dropout_ratio=-1,
-            num_classes=21,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
-    ])
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 85514b9..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_hr48_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,39 +0,0 @@
-_base_ = './ocrnet_hr18_4xb4-80k_ade20k-512x512.py'
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w48',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(48, 96)),
-            stage3=dict(num_channels=(48, 96, 192)),
-            stage4=dict(num_channels=(48, 96, 192, 384)))),
-    decode_head=[
-        dict(
-            type='FCNHead',
-            in_channels=[48, 96, 192, 384],
-            channels=sum([48, 96, 192, 384]),
-            input_transform='resize_concat',
-            in_index=(0, 1, 2, 3),
-            kernel_size=1,
-            num_convs=1,
-            norm_cfg=norm_cfg,
-            concat_input=False,
-            dropout_ratio=-1,
-            num_classes=150,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-        dict(
-            type='OCRHead',
-            in_channels=[48, 96, 192, 384],
-            channels=512,
-            ocr_channels=256,
-            input_transform='resize_concat',
-            in_index=(0, 1, 2, 3),
-            norm_cfg=norm_cfg,
-            dropout_ratio=-1,
-            num_classes=150,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
-    ])
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index a94597b..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/ocrnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained='open-mmlab://resnet101_v1c',
-    backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_r101-d8_8xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_r101-d8_8xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 88e5ad0..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_r101-d8_8xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,21 +0,0 @@
-_base_ = [
-    '../_base_/models/ocrnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained='open-mmlab://resnet101_v1c',
-    backbone=dict(depth=101))
-optimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0005)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
-param_scheduler = [
-    dict(
-        type='PolyLR',
-        eta_min=2e-4,
-        power=0.9,
-        begin=0,
-        end=40000,
-        by_epoch=False)
-]
diff --git a/mmsegmentation/configs/ocrnet/ocrnet_r101-d8_8xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/ocrnet/ocrnet_r101-d8_8xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index a3b4209..0000000
--- a/mmsegmentation/configs/ocrnet/ocrnet_r101-d8_8xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,21 +0,0 @@
-_base_ = [
-    '../_base_/models/ocrnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained='open-mmlab://resnet101_v1c',
-    backbone=dict(depth=101))
-optimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0005)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
-param_scheduler = [
-    dict(
-        type='PolyLR',
-        eta_min=2e-4,
-        power=0.9,
-        begin=0,
-        end=40000,
-        by_epoch=False)
-]
diff --git a/mmsegmentation/configs/pidnet/README.md b/mmsegmentation/configs/pidnet/README.md
deleted file mode 100644
index e23efbd..0000000
--- a/mmsegmentation/configs/pidnet/README.md
+++ /dev/null
@@ -1,50 +0,0 @@
-# PIDNet
-
-> [PIDNet: A Real-time Semantic Segmentation Network Inspired from PID Controller](https://arxiv.org/pdf/2206.02066.pdf)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/XuJiacong/PIDNet">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/backbones/pidnet.py">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Two-branch network architecture has shown its efficiency and effectiveness for real-time semantic segmentation tasks. However, direct fusion of low-level details and high-level semantics will lead to a phenomenon that the detailed features are easily overwhelmed by surrounding contextual information, namely overshoot in this paper, which limits the improvement of the accuracy of existed two-branch models. In this paper, we bridge a connection between Convolutional Neural Network (CNN) and Proportional-IntegralDerivative (PID) controller and reveal that the two-branch network is nothing but a Proportional-Integral (PI) controller, which inherently suffers from the similar overshoot issue. To alleviate this issue, we propose a novel threebranch network architecture: PIDNet, which possesses three branches to parse the detailed, context and boundary information (derivative of semantics), respectively, and employs boundary attention to guide the fusion of detailed and context branches in final stage. The family of PIDNets achieve the best trade-off between inference speed and accuracy and their test accuracy surpasses all the existed models with similar inference speed on Cityscapes, CamVid and COCO-Stuff datasets. Especially, PIDNet-S achieves 78.6% mIOU with inference speed of 93.2 FPS on Cityscapes test set and 80.1% mIOU with speed of 153.7 FPS on CamVid test set.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://raw.githubusercontent.com/XuJiacong/PIDNet/main/figs/pidnet.jpg" width="800"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                     | download                                                                                                                                                                                                                                                                                                                                                 |
-| ------ | -------- | --------- | ------- | -------- | -------------- | ------ | ----- | ------------- | -------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| PIDNet | PIDNet-S | 1024x1024 | 120000  | 3.38     | 80.82          | A100   | 78.74 | 80.87         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pidnet/pidnet-s_2xb6-120k_1024x1024-cityscapes.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-s_2xb6-120k_1024x1024-cityscapes/pidnet-s_2xb6-120k_1024x1024-cityscapes_20230302_191700-bb8e3bcc.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-s_2xb6-120k_1024x1024-cityscapes/pidnet-s_2xb6-120k_1024x1024-cityscapes_20230302_191700.json) |
-| PIDNet | PIDNet-M | 1024x1024 | 120000  | 5.14     | 71.98          | A100   | 80.22 | 82.05         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pidnet/pidnet-m_2xb6-120k_1024x1024-cityscapes.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-m_2xb6-120k_1024x1024-cityscapes/pidnet-m_2xb6-120k_1024x1024-cityscapes_20230301_143452-f9bcdbf3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-m_2xb6-120k_1024x1024-cityscapes/pidnet-m_2xb6-120k_1024x1024-cityscapes_20230301_143452.json) |
-| PIDNet | PIDNet-L | 1024x1024 | 120000  | 5.83     | 60.06          | A100   | 80.89 | 82.37         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pidnet/pidnet-l_2xb6-120k_1024x1024-cityscapes.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-l_2xb6-120k_1024x1024-cityscapes/pidnet-l_2xb6-120k_1024x1024-cityscapes_20230303_114514-0783ca6b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-l_2xb6-120k_1024x1024-cityscapes/pidnet-l_2xb6-120k_1024x1024-cityscapes_20230303_114514.json) |
-
-## Notes
-
-The pretrained weights in config files are converted from [the official repo](https://github.com/XuJiacong/PIDNet#models).
-
-## Citation
-
-```bibtex
-@misc{xu2022pidnet,
-      title={PIDNet: A Real-time Semantic Segmentation Network Inspired from PID Controller},
-      author={Jiacong Xu and Zixiang Xiong and Shankar P. Bhattacharyya},
-      year={2022},
-      eprint={2206.02066},
-      archivePrefix={arXiv},
-      primaryClass={cs.CV}
-}
-```
diff --git a/mmsegmentation/configs/pidnet/metafile.yaml b/mmsegmentation/configs/pidnet/metafile.yaml
deleted file mode 100644
index 51b514a..0000000
--- a/mmsegmentation/configs/pidnet/metafile.yaml
+++ /dev/null
@@ -1,85 +0,0 @@
-Collections:
-- Name: PIDNet
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-  Paper:
-    Title: 'PIDNet: A Real-time Semantic Segmentation Network Inspired from PID Controller'
-    URL: https://arxiv.org/pdf/2206.02066.pdf
-  README: configs/pidnet/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: pidnet-s_2xb6-120k_1024x1024-cityscapes
-  In Collection: PIDNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.74
-      mIoU(ms+flip): 80.87
-  Config: configs/pidnet/pidnet-s_2xb6-120k_1024x1024-cityscapes.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 12
-    Architecture:
-    - PIDNet-S
-    - PIDNet
-    Training Resources: 2x A100 GPUS
-    Memory (GB): 3.38
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-s_2xb6-120k_1024x1024-cityscapes/pidnet-s_2xb6-120k_1024x1024-cityscapes_20230302_191700-bb8e3bcc.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-s_2xb6-120k_1024x1024-cityscapes/pidnet-s_2xb6-120k_1024x1024-cityscapes_20230302_191700.json
-  Paper:
-    Title: 'PIDNet: A Real-time Semantic Segmentation Network Inspired from PID Controller'
-    URL: https://arxiv.org/pdf/2206.02066.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/backbones/pidnet.py
-  Framework: PyTorch
-- Name: pidnet-m_2xb6-120k_1024x1024-cityscapes
-  In Collection: PIDNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 80.22
-      mIoU(ms+flip): 82.05
-  Config: configs/pidnet/pidnet-m_2xb6-120k_1024x1024-cityscapes.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 12
-    Architecture:
-    - PIDNet-M
-    - PIDNet
-    Training Resources: 2x A100 GPUS
-    Memory (GB): 5.14
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-m_2xb6-120k_1024x1024-cityscapes/pidnet-m_2xb6-120k_1024x1024-cityscapes_20230301_143452-f9bcdbf3.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-m_2xb6-120k_1024x1024-cityscapes/pidnet-m_2xb6-120k_1024x1024-cityscapes_20230301_143452.json
-  Paper:
-    Title: 'PIDNet: A Real-time Semantic Segmentation Network Inspired from PID Controller'
-    URL: https://arxiv.org/pdf/2206.02066.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/backbones/pidnet.py
-  Framework: PyTorch
-- Name: pidnet-l_2xb6-120k_1024x1024-cityscapes
-  In Collection: PIDNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 80.89
-      mIoU(ms+flip): 82.37
-  Config: configs/pidnet/pidnet-l_2xb6-120k_1024x1024-cityscapes.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 12
-    Architecture:
-    - PIDNet-L
-    - PIDNet
-    Training Resources: 2x A100 GPUS
-    Memory (GB): 5.83
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-l_2xb6-120k_1024x1024-cityscapes/pidnet-l_2xb6-120k_1024x1024-cityscapes_20230303_114514-0783ca6b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pidnet/pidnet-l_2xb6-120k_1024x1024-cityscapes/pidnet-l_2xb6-120k_1024x1024-cityscapes_20230303_114514.json
-  Paper:
-    Title: 'PIDNet: A Real-time Semantic Segmentation Network Inspired from PID Controller'
-    URL: https://arxiv.org/pdf/2206.02066.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/backbones/pidnet.py
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/pidnet/pidnet-l_2xb6-120k_1024x1024-cityscapes.py b/mmsegmentation/configs/pidnet/pidnet-l_2xb6-120k_1024x1024-cityscapes.py
deleted file mode 100644
index 1955c91..0000000
--- a/mmsegmentation/configs/pidnet/pidnet-l_2xb6-120k_1024x1024-cityscapes.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = './pidnet-s_2xb6-120k_1024x1024-cityscapes.py'
-checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/pidnet/pidnet-l_imagenet1k_20230306-67889109.pth'  # noqa
-model = dict(
-    backbone=dict(
-        channels=64,
-        ppm_channels=112,
-        num_stem_blocks=3,
-        num_branch_blocks=4,
-        init_cfg=dict(checkpoint=checkpoint_file)),
-    decode_head=dict(in_channels=256, channels=256))
diff --git a/mmsegmentation/configs/pidnet/pidnet-m_2xb6-120k_1024x1024-cityscapes.py b/mmsegmentation/configs/pidnet/pidnet-m_2xb6-120k_1024x1024-cityscapes.py
deleted file mode 100644
index 38a69c1..0000000
--- a/mmsegmentation/configs/pidnet/pidnet-m_2xb6-120k_1024x1024-cityscapes.py
+++ /dev/null
@@ -1,5 +0,0 @@
-_base_ = './pidnet-s_2xb6-120k_1024x1024-cityscapes.py'
-checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/pidnet/pidnet-m_imagenet1k_20230306-39893c52.pth'  # noqa
-model = dict(
-    backbone=dict(channels=64, init_cfg=dict(checkpoint=checkpoint_file)),
-    decode_head=dict(in_channels=256))
diff --git a/mmsegmentation/configs/pidnet/pidnet-s_2xb6-120k_1024x1024-cityscapes.py b/mmsegmentation/configs/pidnet/pidnet-s_2xb6-120k_1024x1024-cityscapes.py
deleted file mode 100644
index f70ca42..0000000
--- a/mmsegmentation/configs/pidnet/pidnet-s_2xb6-120k_1024x1024-cityscapes.py
+++ /dev/null
@@ -1,113 +0,0 @@
-_base_ = [
-    '../_base_/datasets/cityscapes_1024x1024.py',
-    '../_base_/default_runtime.py'
-]
-
-# The class_weight is borrowed from https://github.com/openseg-group/OCNet.pytorch/issues/14 # noqa
-# Licensed under the MIT License
-class_weight = [
-    0.8373, 0.918, 0.866, 1.0345, 1.0166, 0.9969, 0.9754, 1.0489, 0.8786,
-    1.0023, 0.9539, 0.9843, 1.1116, 0.9037, 1.0865, 1.0955, 1.0865, 1.1529,
-    1.0507
-]
-checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/pidnet/pidnet-s_imagenet1k_20230306-715e6273.pth'  # noqa
-crop_size = (1024, 1024)
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    mean=[123.675, 116.28, 103.53],
-    std=[58.395, 57.12, 57.375],
-    bgr_to_rgb=True,
-    pad_val=0,
-    seg_pad_val=255,
-    size=crop_size)
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        type='PIDNet',
-        in_channels=3,
-        channels=32,
-        ppm_channels=96,
-        num_stem_blocks=2,
-        num_branch_blocks=3,
-        align_corners=False,
-        norm_cfg=norm_cfg,
-        act_cfg=dict(type='ReLU', inplace=True),
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file)),
-    decode_head=dict(
-        type='PIDHead',
-        in_channels=128,
-        channels=128,
-        num_classes=19,
-        norm_cfg=norm_cfg,
-        act_cfg=dict(type='ReLU', inplace=True),
-        align_corners=True,
-        loss_decode=[
-            dict(
-                type='CrossEntropyLoss',
-                use_sigmoid=False,
-                class_weight=class_weight,
-                loss_weight=0.4),
-            dict(
-                type='OhemCrossEntropy',
-                thres=0.9,
-                min_kept=131072,
-                class_weight=class_weight,
-                loss_weight=1.0),
-            dict(type='BoundaryLoss', loss_weight=20.0),
-            dict(
-                type='OhemCrossEntropy',
-                thres=0.9,
-                min_kept=131072,
-                class_weight=class_weight,
-                loss_weight=1.0)
-        ]),
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
-
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(
-        type='RandomResize',
-        scale=(2048, 1024),
-        ratio_range=(0.5, 2.0),
-        keep_ratio=True),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='GenerateEdge', edge_width=4),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(batch_size=6, dataset=dict(pipeline=train_pipeline))
-
-iters = 120000
-# optimizer
-optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
-# learning policy
-param_scheduler = [
-    dict(
-        type='PolyLR',
-        eta_min=0,
-        power=0.9,
-        begin=0,
-        end=iters,
-        by_epoch=False)
-]
-# training schedule for 120k
-train_cfg = dict(
-    type='IterBasedTrainLoop', max_iters=iters, val_interval=iters // 10)
-val_cfg = dict(type='ValLoop')
-test_cfg = dict(type='TestLoop')
-default_hooks = dict(
-    timer=dict(type='IterTimerHook'),
-    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
-    param_scheduler=dict(type='ParamSchedulerHook'),
-    checkpoint=dict(
-        type='CheckpointHook', by_epoch=False, interval=iters // 10),
-    sampler_seed=dict(type='DistSamplerSeedHook'),
-    visualization=dict(type='SegVisualizationHook'))
-
-randomness = dict(seed=304)
diff --git a/mmsegmentation/configs/point_rend/README.md b/mmsegmentation/configs/point_rend/README.md
deleted file mode 100644
index 487d3bc..0000000
--- a/mmsegmentation/configs/point_rend/README.md
+++ /dev/null
@@ -1,51 +0,0 @@
-# PointRend
-
-> [PointRend: Image Segmentation as Rendering](https://arxiv.org/abs/1912.08193)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/facebookresearch/detectron2/tree/master/projects/PointRend">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/point_head.py#L36">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-We present a new method for efficient high-quality image segmentation of objects and scenes. By analogizing classical computer graphics methods for efficient rendering with over- and undersampling challenges faced in pixel labeling tasks, we develop a unique perspective of image segmentation as a rendering problem. From this vantage, we present the PointRend (Point-based Rendering) neural network module: a module that performs point-based segmentation predictions at adaptively selected locations based on an iterative subdivision algorithm. PointRend can be flexibly applied to both instance and semantic segmentation tasks by building on top of existing state-of-the-art models. While many concrete implementations of the general idea are possible, we show that a simple design already achieves excellent results. Qualitatively, PointRend outputs crisp object boundaries in regions that are over-smoothed by previous methods. Quantitatively, PointRend yields significant gains on COCO and Cityscapes, for both instance and semantic segmentation. PointRend's efficiency enables output resolutions that are otherwise impractical in terms of memory or computation compared to existing approaches. Code has been made available at [this https URL](https://github.com/facebookresearch/detectron2/tree/main/projects/PointRend).
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142902293-5db49cdd-4b1b-4940-9067-2acd6196c700.png" width="60%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method    | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                             | download                                                                                                                                                                                                                                                                                                                                                         |
-| --------- | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | ---------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| PointRend | R-50     | 512x1024  |   80000 |      3.1 | 8.48           | V100   | 76.47 | 78.13         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/point_rend/pointrend_r50_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r50_512x1024_80k_cityscapes/pointrend_r50_512x1024_80k_cityscapes_20200711_015821-bb1ff523.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r50_512x1024_80k_cityscapes/pointrend_r50_512x1024_80k_cityscapes-20200715_214714.log.json)     |
-| PointRend | R-101    | 512x1024  |   80000 |      4.2 | 7.00           | V100   | 78.30 | 79.97         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/point_rend/pointrend_r101_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r101_512x1024_80k_cityscapes/pointrend_r101_512x1024_80k_cityscapes_20200711_170850-d0ca84be.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r101_512x1024_80k_cityscapes/pointrend_r101_512x1024_80k_cityscapes-20200715_214824.log.json) |
-
-### ADE20K
-
-| Method    | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                         | download                                                                                                                                                                                                                                                                                                                                         |
-| --------- | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | ------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| PointRend | R-50     | 512x512   |  160000 |      5.1 | 17.31          | V100   | 37.64 | 39.17         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/point_rend/pointrend_r50_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r50_512x512_160k_ade20k/pointrend_r50_512x512_160k_ade20k_20200807_232644-ac3febf2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r50_512x512_160k_ade20k/pointrend_r50_512x512_160k_ade20k-20200807_232644.log.json)     |
-| PointRend | R-101    | 512x512   |  160000 |      6.1 | 15.50          | V100   | 40.02 | 41.60         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/point_rend/pointrend_r101_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r101_512x512_160k_ade20k/pointrend_r101_512x512_160k_ade20k_20200808_030852-8834902a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r101_512x512_160k_ade20k/pointrend_r101_512x512_160k_ade20k-20200808_030852.log.json) |
-
-## Citation
-
-```bibtex
-@inproceedings{kirillov2020pointrend,
-  title={Pointrend: Image segmentation as rendering},
-  author={Kirillov, Alexander and Wu, Yuxin and He, Kaiming and Girshick, Ross},
-  booktitle={Proceedings of the IEEE/CVF conference on computer vision and pattern recognition},
-  pages={9799--9808},
-  year={2020}
-}
-```
diff --git a/mmsegmentation/configs/point_rend/metafile.yaml b/mmsegmentation/configs/point_rend/metafile.yaml
deleted file mode 100644
index 064717c..0000000
--- a/mmsegmentation/configs/point_rend/metafile.yaml
+++ /dev/null
@@ -1,110 +0,0 @@
-Collections:
-- Name: PointRend
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-    - ADE20K
-  Paper:
-    Title: 'PointRend: Image Segmentation as Rendering'
-    URL: https://arxiv.org/abs/1912.08193
-  README: configs/point_rend/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: pointrend_r50_4xb2-80k_cityscapes-512x1024
-  In Collection: PointRend
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.47
-      mIoU(ms+flip): 78.13
-  Config: configs/point_rend/pointrend_r50_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50
-    - PointRend
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 3.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r50_512x1024_80k_cityscapes/pointrend_r50_512x1024_80k_cityscapes_20200711_015821-bb1ff523.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r50_512x1024_80k_cityscapes/pointrend_r50_512x1024_80k_cityscapes-20200715_214714.log.json
-  Paper:
-    Title: 'PointRend: Image Segmentation as Rendering'
-    URL: https://arxiv.org/abs/1912.08193
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/point_head.py#L36
-  Framework: PyTorch
-- Name: pointrend_r101_4xb2-80k_cityscapes-512x1024
-  In Collection: PointRend
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.3
-      mIoU(ms+flip): 79.97
-  Config: configs/point_rend/pointrend_r101_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101
-    - PointRend
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 4.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r101_512x1024_80k_cityscapes/pointrend_r101_512x1024_80k_cityscapes_20200711_170850-d0ca84be.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r101_512x1024_80k_cityscapes/pointrend_r101_512x1024_80k_cityscapes-20200715_214824.log.json
-  Paper:
-    Title: 'PointRend: Image Segmentation as Rendering'
-    URL: https://arxiv.org/abs/1912.08193
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/point_head.py#L36
-  Framework: PyTorch
-- Name: pointrend_r50_4xb4-160k_ade20k-512x512
-  In Collection: PointRend
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 37.64
-      mIoU(ms+flip): 39.17
-  Config: configs/point_rend/pointrend_r50_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50
-    - PointRend
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r50_512x512_160k_ade20k/pointrend_r50_512x512_160k_ade20k_20200807_232644-ac3febf2.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r50_512x512_160k_ade20k/pointrend_r50_512x512_160k_ade20k-20200807_232644.log.json
-  Paper:
-    Title: 'PointRend: Image Segmentation as Rendering'
-    URL: https://arxiv.org/abs/1912.08193
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/point_head.py#L36
-  Framework: PyTorch
-- Name: pointrend_r101_4xb4-160k_ade20k-512x512
-  In Collection: PointRend
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 40.02
-      mIoU(ms+flip): 41.6
-  Config: configs/point_rend/pointrend_r101_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101
-    - PointRend
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r101_512x512_160k_ade20k/pointrend_r101_512x512_160k_ade20k_20200808_030852-8834902a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/point_rend/pointrend_r101_512x512_160k_ade20k/pointrend_r101_512x512_160k_ade20k-20200808_030852.log.json
-  Paper:
-    Title: 'PointRend: Image Segmentation as Rendering'
-    URL: https://arxiv.org/abs/1912.08193
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/point_head.py#L36
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/point_rend/pointrend_r101_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/point_rend/pointrend_r101_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index ca2a19a..0000000
--- a/mmsegmentation/configs/point_rend/pointrend_r101_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pointrend_r50_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/point_rend/pointrend_r101_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/point_rend/pointrend_r101_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 6729d3b..0000000
--- a/mmsegmentation/configs/point_rend/pointrend_r101_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pointrend_r50_4xb4-160k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/point_rend/pointrend_r50_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/point_rend/pointrend_r50_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index fb005d8..0000000
--- a/mmsegmentation/configs/point_rend/pointrend_r50_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    '../_base_/models/pointrend_r50.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
-param_scheduler = [
-    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=200),
-    dict(
-        type='PolyLR',
-        eta_min=1e-4,
-        power=0.9,
-        begin=200,
-        end=80000,
-        by_epoch=False,
-    )
-]
diff --git a/mmsegmentation/configs/point_rend/pointrend_r50_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/point_rend/pointrend_r50_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index d350fa6..0000000
--- a/mmsegmentation/configs/point_rend/pointrend_r50_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,46 +0,0 @@
-_base_ = [
-    '../_base_/models/pointrend_r50.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=[
-        dict(
-            type='FPNHead',
-            in_channels=[256, 256, 256, 256],
-            in_index=[0, 1, 2, 3],
-            feature_strides=[4, 8, 16, 32],
-            channels=128,
-            dropout_ratio=-1,
-            num_classes=150,
-            norm_cfg=norm_cfg,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-        dict(
-            type='PointHead',
-            in_channels=[256],
-            in_index=[0],
-            channels=256,
-            num_fcs=3,
-            coarse_pred_each_layer=True,
-            dropout_ratio=-1,
-            num_classes=150,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
-    ])
-param_scheduler = [
-    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=200),
-    dict(
-        type='PolyLR',
-        eta_min=1e-4,
-        power=0.9,
-        begin=200,
-        end=160000,
-        by_epoch=False,
-    )
-]
diff --git a/mmsegmentation/configs/poolformer/README.md b/mmsegmentation/configs/poolformer/README.md
deleted file mode 100644
index e6e2eac..0000000
--- a/mmsegmentation/configs/poolformer/README.md
+++ /dev/null
@@ -1,65 +0,0 @@
-# PoolFormer
-
-> [MetaFormer is Actually What You Need for Vision](https://arxiv.org/abs/2111.11418)
-
-## Introduction
-
-<!-- [BACKBONE] -->
-
-<a href="https://github.com/sail-sg/poolformer/tree/main/segmentation">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmclassification/blob/v0.23.0/mmcls/models/backbones/poolformer.py#L198">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Transformers have shown great potential in computer vision tasks. A common belief is their attention-based token mixer module contributes most to their competence. However, recent works show the attention-based module in transformers can be replaced by spatial MLPs and the resulted models still perform quite well. Based on this observation, we hypothesize that the general architecture of the transformers, instead of the specific token mixer module, is more essential to the model's performance. To verify this, we deliberately replace the attention module in transformers with an embarrassingly simple spatial pooling operator to conduct only the most basic token mixing. Surprisingly, we observe that the derived model, termed as PoolFormer, achieves competitive performance on multiple computer vision tasks. For example, on ImageNet-1K, PoolFormer achieves 82.1% top-1 accuracy, surpassing well-tuned vision transformer/MLP-like baselines DeiT-B/ResMLP-B24 by 0.3%/1.1% accuracy with 35%/52% fewer parameters and 48%/60% fewer MACs. The effectiveness of PoolFormer verifies our hypothesis and urges us to initiate the concept of "MetaFormer", a general architecture abstracted from transformers without specifying the token mixer. Based on the extensive experiments, we argue that MetaFormer is the key player in achieving superior results for recent transformer and MLP-like models on vision tasks. This work calls for more future research dedicated to improving MetaFormer instead of focusing on the token mixer modules. Additionally, our proposed PoolFormer could serve as a starting baseline for future MetaFormer architecture design. Code is available at [this https URL](https://github.com/sail-sg/poolformer)
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/15921929/144710761-1635f59a-abde-4946-984c-a2c3f22a19d2.png" width="70%"/>
-</div>
-
-## Citation
-
-```bibtex
-@inproceedings{yu2022metaformer,
-  title={Metaformer is actually what you need for vision},
-  author={Yu, Weihao and Luo, Mi and Zhou, Pan and Si, Chenyang and Zhou, Yichen and Wang, Xinchao and Feng, Jiashi and Yan, Shuicheng},
-  booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
-  pages={10819--10829},
-  year={2022}
-}
-```
-
-### Usage
-
-- PoolFormer backbone needs to install [MMClassification](https://github.com/open-mmlab/mmclassification) first, which has abundant backbones for downstream tasks.
-
-```shell
-pip install "mmpretrain>=1.0.0rc7"
-```
-
-- The pretrained models could also be downloaded from [PoolFormer config of MMClassification](https://github.com/open-mmlab/mmclassification/tree/master/configs/poolformer).
-
-## Results and models
-
-### ADE20K
-
-| Method | Backbone       | Crop Size | pretrain    | Batch Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | mIoU\* | mIoU\*(ms+flip) | config                                                                                                                            | download                                                                                                                                                                                                                                                                                                                                                                     |
-| ------ | -------------- | --------- | ----------- | ---------- | ------- | -------- | -------------- | ------ | ----- | ------------: | ------ | --------------: | --------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| FPN    | PoolFormer-S12 | 512x512   | ImageNet-1K | 32         | 40000   | 4.17     | 23.48          | V100   | 36.68 |             - | 37.07  |               - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/poolformer/fpn_poolformer_s12_8xb4-40k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s12_8x4_512x512_40k_ade20k/fpn_poolformer_s12_8x4_512x512_40k_ade20k_20220501_115154-b5aa2f49.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s12_8x4_512x512_40k_ade20k/fpn_poolformer_s12_8x4_512x512_40k_ade20k_20220501_115154.log.json) |
-| FPN    | PoolFormer-S24 | 512x512   | ImageNet-1K | 32         | 40000   | 5.47     | 15.74          | V100   | 40.12 |             - | 40.36  |               - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/poolformer/fpn_poolformer_s24_8xb4-40k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s24_8x4_512x512_40k_ade20k/fpn_poolformer_s24_8x4_512x512_40k_ade20k_20220503_222049-394a7cf7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s24_8x4_512x512_40k_ade20k/fpn_poolformer_s24_8x4_512x512_40k_ade20k_20220503_222049.log.json) |
-| FPN    | PoolFormer-S36 | 512x512   | ImageNet-1K | 32         | 40000   | 6.77     | 11.34          | V100   | 41.61 |             - | 41.81  |               - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/poolformer/fpn_poolformer_s36_8xb4-40k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s36_8x4_512x512_40k_ade20k/fpn_poolformer_s36_8x4_512x512_40k_ade20k_20220501_151122-b47e607d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s36_8x4_512x512_40k_ade20k/fpn_poolformer_s36_8x4_512x512_40k_ade20k_20220501_151122.log.json) |
-| FPN    | PoolFormer-M36 | 512x512   | ImageNet-1K | 32         | 40000   | 8.59     | 8.97           | V100   | 41.95 |             - | 42.35  |               - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/poolformer/fpn_poolformer_m36_8xb4-40k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_m36_8x4_512x512_40k_ade20k/fpn_poolformer_m36_8x4_512x512_40k_ade20k_20220501_164230-3dc83921.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_m36_8x4_512x512_40k_ade20k/fpn_poolformer_m36_8x4_512x512_40k_ade20k_20220501_164230.log.json) |
-| FPN    | PoolFormer-M48 | 512x512   | ImageNet-1K | 32         | 40000   | 10.48    | 6.69           | V100   | 42.43 |             - | 42.76  |               - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/poolformer/fpn_poolformer_m48_8xb4-40k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_m48_8x4_512x512_40k_ade20k/fpn_poolformer_m48_8x4_512x512_40k_ade20k_20220504_003923-64168d3b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_m48_8x4_512x512_40k_ade20k/fpn_poolformer_m48_8x4_512x512_40k_ade20k_20220504_003923.log.json) |
-
-Note:
-
-- We replace `AlignedResize` in original PoolFormer implementation to `Resize + ResizeToMultiple`.
-
-- `mIoU` with * is collected when `Resize + ResizeToMultiple` is adopted in `test_pipeline`, so do `mIoU` in logs.
-
-- The Test Time Augmentation i.e., "ms+flip" in MMSegmentation v1.x is developing, stay tuned!
diff --git a/mmsegmentation/configs/poolformer/fpn_poolformer_m36_8xb4-40k_ade20k-512x512.py b/mmsegmentation/configs/poolformer/fpn_poolformer_m36_8xb4-40k_ade20k-512x512.py
deleted file mode 100644
index 4100eb9..0000000
--- a/mmsegmentation/configs/poolformer/fpn_poolformer_m36_8xb4-40k_ade20k-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = './fpn_poolformer_s12_8xb4-40k_ade20k-512x512.py'
-checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/poolformer/poolformer-m36_3rdparty_32xb128_in1k_20220414-c55e0949.pth'  # noqa
-
-# model settings
-model = dict(
-    backbone=dict(
-        arch='m36',
-        init_cfg=dict(
-            type='Pretrained', checkpoint=checkpoint_file,
-            prefix='backbone.')),
-    neck=dict(in_channels=[96, 192, 384, 768]))
diff --git a/mmsegmentation/configs/poolformer/fpn_poolformer_m48_8xb4-40k_ade20k-512x512.py b/mmsegmentation/configs/poolformer/fpn_poolformer_m48_8xb4-40k_ade20k-512x512.py
deleted file mode 100644
index cfc49cc..0000000
--- a/mmsegmentation/configs/poolformer/fpn_poolformer_m48_8xb4-40k_ade20k-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = './fpn_poolformer_s12_8xb4-40k_ade20k-512x512.py'
-checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/poolformer/poolformer-m48_3rdparty_32xb128_in1k_20220414-9378f3eb.pth'  # noqa
-
-# model settings
-model = dict(
-    backbone=dict(
-        arch='m48',
-        init_cfg=dict(
-            type='Pretrained', checkpoint=checkpoint_file,
-            prefix='backbone.')),
-    neck=dict(in_channels=[96, 192, 384, 768]))
diff --git a/mmsegmentation/configs/poolformer/fpn_poolformer_s12_8xb4-40k_ade20k-512x512.py b/mmsegmentation/configs/poolformer/fpn_poolformer_s12_8xb4-40k_ade20k-512x512.py
deleted file mode 100644
index c0b1531..0000000
--- a/mmsegmentation/configs/poolformer/fpn_poolformer_s12_8xb4-40k_ade20k-512x512.py
+++ /dev/null
@@ -1,91 +0,0 @@
-_base_ = [
-    '../_base_/models/fpn_poolformer_s12.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-
-# dataset settings
-dataset_type = 'ADE20KDataset'
-data_root = 'data/ade/ADEChallengeData2016'
-img_norm_cfg = dict(
-    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(
-        type='RandomResize',
-        scale=(2048, 512),
-        ratio_range=(0.5, 2.0),
-        keep_ratio=True),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
-    dict(type='ResizeToMultiple', size_divisor=32),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='PackSegInputs')
-]
-
-train_dataloader = dict(
-    batch_size=4,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type='RepeatDataset',
-        times=50,
-        dataset=dict(
-            type=dataset_type,
-            data_root=data_root,
-            data_prefix=dict(
-                img_path='images/training',
-                seg_map_path='annotations/training'),
-            pipeline=train_pipeline)))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='images/validation',
-            seg_map_path='annotations/validation'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
-test_evaluator = val_evaluator
-
-# model settings
-model = dict(
-    data_preprocessor=data_preprocessor,
-    neck=dict(in_channels=[64, 128, 320, 512]),
-    decode_head=dict(num_classes=150))
-
-# optimizer
-# optimizer = dict(_delete_=True, type='AdamW', lr=0.0002, weight_decay=0.0001)
-# optimizer_config = dict()
-# # learning policy
-# lr_config = dict(policy='poly', power=0.9, min_lr=0.0, by_epoch=False)
-optim_wrapper = dict(
-    _delete_=True,
-    type='AmpOptimWrapper',
-    optimizer=dict(type='AdamW', lr=0.0002, weight_decay=0.0001))
-param_scheduler = [
-    dict(
-        type='PolyLR',
-        power=0.9,
-        begin=0,
-        end=40000,
-        eta_min=0.0,
-        by_epoch=False,
-    )
-]
diff --git a/mmsegmentation/configs/poolformer/fpn_poolformer_s24_8xb4-40k_ade20k-512x512.py b/mmsegmentation/configs/poolformer/fpn_poolformer_s24_8xb4-40k_ade20k-512x512.py
deleted file mode 100644
index 1f9d24c..0000000
--- a/mmsegmentation/configs/poolformer/fpn_poolformer_s24_8xb4-40k_ade20k-512x512.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './fpn_poolformer_s12_8xb4-40k_ade20k-512x512.py'
-checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/poolformer/poolformer-s24_3rdparty_32xb128_in1k_20220414-d7055904.pth'  # noqa
-# model settings
-model = dict(
-    backbone=dict(
-        arch='s24',
-        init_cfg=dict(
-            type='Pretrained', checkpoint=checkpoint_file,
-            prefix='backbone.')))
diff --git a/mmsegmentation/configs/poolformer/fpn_poolformer_s36_8x4_512x512_40k_ade20k.py b/mmsegmentation/configs/poolformer/fpn_poolformer_s36_8x4_512x512_40k_ade20k.py
deleted file mode 100644
index 231dcf6..0000000
--- a/mmsegmentation/configs/poolformer/fpn_poolformer_s36_8x4_512x512_40k_ade20k.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = './fpn_poolformer_s12_8xb4-40k_ade20k-512x512.py'
-checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/poolformer/poolformer-s36_3rdparty_32xb128_in1k_20220414-d78ff3e8.pth'  # noqa
-
-# model settings
-model = dict(
-    backbone=dict(
-        arch='s36',
-        init_cfg=dict(
-            type='Pretrained', checkpoint=checkpoint_file,
-            prefix='backbone.')))
diff --git a/mmsegmentation/configs/poolformer/metafile.yaml b/mmsegmentation/configs/poolformer/metafile.yaml
deleted file mode 100644
index 12f402b..0000000
--- a/mmsegmentation/configs/poolformer/metafile.yaml
+++ /dev/null
@@ -1,116 +0,0 @@
-Models:
-- Name: fpn_poolformer_s12_8xb4-40k_ade20k-512x512
-  In Collection: FPN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 36.68
-  Config: configs/poolformer/fpn_poolformer_s12_8xb4-40k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 32
-    Architecture:
-    - PoolFormer-S12
-    - FPN
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 4.17
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s12_8x4_512x512_40k_ade20k/fpn_poolformer_s12_8x4_512x512_40k_ade20k_20220501_115154-b5aa2f49.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s12_8x4_512x512_40k_ade20k/fpn_poolformer_s12_8x4_512x512_40k_ade20k_20220501_115154.log.json
-  Paper:
-    Title: MetaFormer is Actually What You Need for Vision
-    URL: https://arxiv.org/abs/2111.11418
-  Code: https://github.com/open-mmlab/mmclassification/blob/v0.23.0/mmcls/models/backbones/poolformer.py#L198
-  Framework: PyTorch
-- Name: fpn_poolformer_s24_8xb4-40k_ade20k-512x512
-  In Collection: FPN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 40.12
-  Config: configs/poolformer/fpn_poolformer_s24_8xb4-40k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 32
-    Architecture:
-    - PoolFormer-S24
-    - FPN
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 5.47
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s24_8x4_512x512_40k_ade20k/fpn_poolformer_s24_8x4_512x512_40k_ade20k_20220503_222049-394a7cf7.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s24_8x4_512x512_40k_ade20k/fpn_poolformer_s24_8x4_512x512_40k_ade20k_20220503_222049.log.json
-  Paper:
-    Title: MetaFormer is Actually What You Need for Vision
-    URL: https://arxiv.org/abs/2111.11418
-  Code: https://github.com/open-mmlab/mmclassification/blob/v0.23.0/mmcls/models/backbones/poolformer.py#L198
-  Framework: PyTorch
-- Name: fpn_poolformer_s36_8xb4-40k_ade20k-512x512
-  In Collection: FPN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 41.61
-  Config: configs/poolformer/fpn_poolformer_s36_8xb4-40k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 32
-    Architecture:
-    - PoolFormer-S36
-    - FPN
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 6.77
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s36_8x4_512x512_40k_ade20k/fpn_poolformer_s36_8x4_512x512_40k_ade20k_20220501_151122-b47e607d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_s36_8x4_512x512_40k_ade20k/fpn_poolformer_s36_8x4_512x512_40k_ade20k_20220501_151122.log.json
-  Paper:
-    Title: MetaFormer is Actually What You Need for Vision
-    URL: https://arxiv.org/abs/2111.11418
-  Code: https://github.com/open-mmlab/mmclassification/blob/v0.23.0/mmcls/models/backbones/poolformer.py#L198
-  Framework: PyTorch
-- Name: fpn_poolformer_m36_8xb4-40k_ade20k-512x512
-  In Collection: FPN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 41.95
-  Config: configs/poolformer/fpn_poolformer_m36_8xb4-40k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 32
-    Architecture:
-    - PoolFormer-M36
-    - FPN
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 8.59
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_m36_8x4_512x512_40k_ade20k/fpn_poolformer_m36_8x4_512x512_40k_ade20k_20220501_164230-3dc83921.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_m36_8x4_512x512_40k_ade20k/fpn_poolformer_m36_8x4_512x512_40k_ade20k_20220501_164230.log.json
-  Paper:
-    Title: MetaFormer is Actually What You Need for Vision
-    URL: https://arxiv.org/abs/2111.11418
-  Code: https://github.com/open-mmlab/mmclassification/blob/v0.23.0/mmcls/models/backbones/poolformer.py#L198
-  Framework: PyTorch
-- Name: fpn_poolformer_m48_8xb4-40k_ade20k-512x512
-  In Collection: FPN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.43
-  Config: configs/poolformer/fpn_poolformer_m48_8xb4-40k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 32
-    Architecture:
-    - PoolFormer-M48
-    - FPN
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 10.48
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_m48_8x4_512x512_40k_ade20k/fpn_poolformer_m48_8x4_512x512_40k_ade20k_20220504_003923-64168d3b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/poolformer/fpn_poolformer_m48_8x4_512x512_40k_ade20k/fpn_poolformer_m48_8x4_512x512_40k_ade20k_20220504_003923.log.json
-  Paper:
-    Title: MetaFormer is Actually What You Need for Vision
-    URL: https://arxiv.org/abs/2111.11418
-  Code: https://github.com/open-mmlab/mmclassification/blob/v0.23.0/mmcls/models/backbones/poolformer.py#L198
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/psanet/README.md b/mmsegmentation/configs/psanet/README.md
deleted file mode 100644
index 1f5680f..0000000
--- a/mmsegmentation/configs/psanet/README.md
+++ /dev/null
@@ -1,68 +0,0 @@
-# PSANet
-
-> [PSANet: Point-wise Spatial Attention Network for Scene Parsing](https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/hszhao/PSANet">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-We notice information flow in convolutional neural networksis  restricted  inside  local  neighborhood  regions  due  to  the  physical  de-sign  of  convolutional  filters,  which  limits  the  overall  understanding  ofcomplex scenes. In this paper, we propose thepoint-wise  spatial  atten-tion network(PSANet) to relax the local neighborhood constraint. Eachposition on the feature map is connected to all the other ones througha self-adaptively learned attention mask. Moreover, information propa-gation in bi-direction for scene parsing is enabled. Information at otherpositions can be collected to help the prediction of the current positionand  vice  versa,  information  at  the  current  position  can  be  distributedto assist the prediction of other ones. Our proposed approach achievestop performance on various competitive scene parsing datasets, includ-ing  ADE20K,  PASCAL  VOC  2012  and  Cityscapes,  demonstrating  itseffectiveness and generality.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142902367-0f29e8cb-5ac0-434b-98c4-b2af7c9c2e58.png" width="70%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                         | download                                                                                                                                                                                                                                                                                                                                                 |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| PSANet | R-50-D8  | 512x1024  |   40000 | 7        | 3.17           | V100   | 77.63 |         79.04 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x1024_40k_cityscapes/psanet_r50-d8_512x1024_40k_cityscapes_20200606_103117-99fac37c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x1024_40k_cityscapes/psanet_r50-d8_512x1024_40k_cityscapes_20200606_103117.log.json)     |
-| PSANet | R-101-D8 | 512x1024  |   40000 | 10.5     | 2.20           | V100   | 79.14 |         80.19 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x1024_40k_cityscapes/psanet_r101-d8_512x1024_40k_cityscapes_20200606_001418-27b9cfa7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x1024_40k_cityscapes/psanet_r101-d8_512x1024_40k_cityscapes_20200606_001418.log.json) |
-| PSANet | R-50-D8  | 769x769   |   40000 | 7.9      | 1.40           | V100   | 77.99 |         79.64 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_769x769_40k_cityscapes/psanet_r50-d8_769x769_40k_cityscapes_20200530_033717-d5365506.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_769x769_40k_cityscapes/psanet_r50-d8_769x769_40k_cityscapes_20200530_033717.log.json)         |
-| PSANet | R-101-D8 | 769x769   |   40000 | 11.9     | 0.98           | V100   | 78.43 |         80.26 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_769x769_40k_cityscapes/psanet_r101-d8_769x769_40k_cityscapes_20200530_035107-997da1e6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_769x769_40k_cityscapes/psanet_r101-d8_769x769_40k_cityscapes_20200530_035107.log.json)     |
-| PSANet | R-50-D8  | 512x1024  |   80000 | -        | -              | V100   | 77.24 |         78.69 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x1024_80k_cityscapes/psanet_r50-d8_512x1024_80k_cityscapes_20200606_161842-ab60a24f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x1024_80k_cityscapes/psanet_r50-d8_512x1024_80k_cityscapes_20200606_161842.log.json)     |
-| PSANet | R-101-D8 | 512x1024  |   80000 | -        | -              | V100   | 79.31 |         80.53 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x1024_80k_cityscapes/psanet_r101-d8_512x1024_80k_cityscapes_20200606_161823-0f73a169.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x1024_80k_cityscapes/psanet_r101-d8_512x1024_80k_cityscapes_20200606_161823.log.json) |
-| PSANet | R-50-D8  | 769x769   |   80000 | -        | -              | V100   | 79.31 |         80.91 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_769x769_80k_cityscapes/psanet_r50-d8_769x769_80k_cityscapes_20200606_225134-fe42f49e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_769x769_80k_cityscapes/psanet_r50-d8_769x769_80k_cityscapes_20200606_225134.log.json)         |
-| PSANet | R-101-D8 | 769x769   |   80000 | -        | -              | V100   | 79.69 |         80.89 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_769x769_80k_cityscapes/psanet_r101-d8_769x769_80k_cityscapes_20200606_214550-7665827b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_769x769_80k_cityscapes/psanet_r101-d8_769x769_80k_cityscapes_20200606_214550.log.json)     |
-
-### ADE20K
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                     | download                                                                                                                                                                                                                                                                                                                                 |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| PSANet | R-50-D8  | 512x512   |   80000 | 9        | 18.91          | V100   | 41.14 |         41.91 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_80k_ade20k/psanet_r50-d8_512x512_80k_ade20k_20200614_144141-835e4b97.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_80k_ade20k/psanet_r50-d8_512x512_80k_ade20k_20200614_144141.log.json)         |
-| PSANet | R-101-D8 | 512x512   |   80000 | 12.5     | 13.13          | V100   | 43.80 |         44.75 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_80k_ade20k/psanet_r101-d8_512x512_80k_ade20k_20200614_185117-1fab60d4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_80k_ade20k/psanet_r101-d8_512x512_80k_ade20k_20200614_185117.log.json)     |
-| PSANet | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 41.67 |         42.95 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_160k_ade20k/psanet_r50-d8_512x512_160k_ade20k_20200615_161258-148077dd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_160k_ade20k/psanet_r50-d8_512x512_160k_ade20k_20200615_161258.log.json)     |
-| PSANet | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 43.74 |         45.38 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_160k_ade20k/psanet_r101-d8_512x512_160k_ade20k_20200615_161537-dbfa564c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_160k_ade20k/psanet_r101-d8_512x512_160k_ade20k_20200615_161537.log.json) |
-
-### Pascal VOC 2012 + Aug
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                      | download                                                                                                                                                                                                                                                                                                                                     |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | --------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| PSANet | R-50-D8  | 512x512   |   20000 | 6.9      | 18.24          | V100   | 76.39 |         77.34 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r50-d8_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_20k_voc12aug/psanet_r50-d8_512x512_20k_voc12aug_20200617_102413-2f1bbaa1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_20k_voc12aug/psanet_r50-d8_512x512_20k_voc12aug_20200617_102413.log.json)     |
-| PSANet | R-101-D8 | 512x512   |   20000 | 10.4     | 12.63          | V100   | 77.91 |         79.30 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r101-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_20k_voc12aug/psanet_r101-d8_512x512_20k_voc12aug_20200617_110624-946fef11.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_20k_voc12aug/psanet_r101-d8_512x512_20k_voc12aug_20200617_110624.log.json) |
-| PSANet | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 76.30 |         77.35 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r50-d8_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_40k_voc12aug/psanet_r50-d8_512x512_40k_voc12aug_20200613_161946-f596afb5.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_40k_voc12aug/psanet_r50-d8_512x512_40k_voc12aug_20200613_161946.log.json)     |
-| PSANet | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 77.73 |         79.05 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet/psanet_r101-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_40k_voc12aug/psanet_r101-d8_512x512_40k_voc12aug_20200613_161946-1f560f9e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_40k_voc12aug/psanet_r101-d8_512x512_40k_voc12aug_20200613_161946.log.json) |
-
-## Citation
-
-```bibtex
-@inproceedings{zhao2018psanet,
-  title={Psanet: Point-wise spatial attention network for scene parsing},
-  author={Zhao, Hengshuang and Zhang, Yi and Liu, Shu and Shi, Jianping and Change Loy, Chen and Lin, Dahua and Jia, Jiaya},
-  booktitle={Proceedings of the European Conference on Computer Vision (ECCV)},
-  pages={267--283},
-  year={2018}
-}
-```
diff --git a/mmsegmentation/configs/psanet/metafile.yaml b/mmsegmentation/configs/psanet/metafile.yaml
deleted file mode 100644
index 3fbe6f6..0000000
--- a/mmsegmentation/configs/psanet/metafile.yaml
+++ /dev/null
@@ -1,391 +0,0 @@
-Collections:
-- Name: PSANet
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-    - ADE20K
-    - Pascal VOC 2012 + Aug
-  Paper:
-    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
-    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
-  README: configs/psanet/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: psanet_r50-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: PSANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.63
-      mIoU(ms+flip): 79.04
-  Config: configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - PSANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 7.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x1024_40k_cityscapes/psanet_r50-d8_512x1024_40k_cityscapes_20200606_103117-99fac37c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x1024_40k_cityscapes/psanet_r50-d8_512x1024_40k_cityscapes_20200606_103117.log.json
-  Paper:
-    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
-    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
-  Framework: PyTorch
-- Name: psanet_r101-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: PSANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.14
-      mIoU(ms+flip): 80.19
-  Config: configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - PSANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x1024_40k_cityscapes/psanet_r101-d8_512x1024_40k_cityscapes_20200606_001418-27b9cfa7.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x1024_40k_cityscapes/psanet_r101-d8_512x1024_40k_cityscapes_20200606_001418.log.json
-  Paper:
-    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
-    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
-  Framework: PyTorch
-- Name: psanet_r50-d8_4xb2-40k_cityscapes-769x769
-  In Collection: PSANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.99
-      mIoU(ms+flip): 79.64
-  Config: configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - PSANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 7.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_769x769_40k_cityscapes/psanet_r50-d8_769x769_40k_cityscapes_20200530_033717-d5365506.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_769x769_40k_cityscapes/psanet_r50-d8_769x769_40k_cityscapes_20200530_033717.log.json
-  Paper:
-    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
-    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
-  Framework: PyTorch
-- Name: psanet_r101-d8_4xb2-40k_cityscapes-769x769
-  In Collection: PSANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.43
-      mIoU(ms+flip): 80.26
-  Config: configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - PSANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 11.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_769x769_40k_cityscapes/psanet_r101-d8_769x769_40k_cityscapes_20200530_035107-997da1e6.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_769x769_40k_cityscapes/psanet_r101-d8_769x769_40k_cityscapes_20200530_035107.log.json
-  Paper:
-    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
-    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
-  Framework: PyTorch
-- Name: psanet_r50-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: PSANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.24
-      mIoU(ms+flip): 78.69
-  Config: configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - PSANet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x1024_80k_cityscapes/psanet_r50-d8_512x1024_80k_cityscapes_20200606_161842-ab60a24f.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x1024_80k_cityscapes/psanet_r50-d8_512x1024_80k_cityscapes_20200606_161842.log.json
-  Paper:
-    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
-    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
-  Framework: PyTorch
-- Name: psanet_r101-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: PSANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.31
-      mIoU(ms+flip): 80.53
-  Config: configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - PSANet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x1024_80k_cityscapes/psanet_r101-d8_512x1024_80k_cityscapes_20200606_161823-0f73a169.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x1024_80k_cityscapes/psanet_r101-d8_512x1024_80k_cityscapes_20200606_161823.log.json
-  Paper:
-    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
-    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
-  Framework: PyTorch
-- Name: psanet_r50-d8_4xb2-80k_cityscapes-769x769
-  In Collection: PSANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.31
-      mIoU(ms+flip): 80.91
-  Config: configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - PSANet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_769x769_80k_cityscapes/psanet_r50-d8_769x769_80k_cityscapes_20200606_225134-fe42f49e.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_769x769_80k_cityscapes/psanet_r50-d8_769x769_80k_cityscapes_20200606_225134.log.json
-  Paper:
-    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
-    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
-  Framework: PyTorch
-- Name: psanet_r101-d8_4xb2-80k_cityscapes-769x769
-  In Collection: PSANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.69
-      mIoU(ms+flip): 80.89
-  Config: configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - PSANet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_769x769_80k_cityscapes/psanet_r101-d8_769x769_80k_cityscapes_20200606_214550-7665827b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_769x769_80k_cityscapes/psanet_r101-d8_769x769_80k_cityscapes_20200606_214550.log.json
-  Paper:
-    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
-    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
-  Framework: PyTorch
-- Name: psanet_r50-d8_4xb4-80k_ade20k-512x512
-  In Collection: PSANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 41.14
-      mIoU(ms+flip): 41.91
-  Config: configs/psanet/psanet_r50-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - PSANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_80k_ade20k/psanet_r50-d8_512x512_80k_ade20k_20200614_144141-835e4b97.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_80k_ade20k/psanet_r50-d8_512x512_80k_ade20k_20200614_144141.log.json
-  Paper:
-    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
-    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
-  Framework: PyTorch
-- Name: psanet_r101-d8_4xb4-80k_ade20k-512x512
-  In Collection: PSANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 43.8
-      mIoU(ms+flip): 44.75
-  Config: configs/psanet/psanet_r101-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - PSANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 12.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_80k_ade20k/psanet_r101-d8_512x512_80k_ade20k_20200614_185117-1fab60d4.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_80k_ade20k/psanet_r101-d8_512x512_80k_ade20k_20200614_185117.log.json
-  Paper:
-    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
-    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
-  Framework: PyTorch
-- Name: psanet_r50-d8_4xb4-160k_ade20k-512x512
-  In Collection: PSANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 41.67
-      mIoU(ms+flip): 42.95
-  Config: configs/psanet/psanet_r50-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - PSANet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_160k_ade20k/psanet_r50-d8_512x512_160k_ade20k_20200615_161258-148077dd.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_160k_ade20k/psanet_r50-d8_512x512_160k_ade20k_20200615_161258.log.json
-  Paper:
-    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
-    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
-  Framework: PyTorch
-- Name: psanet_r101-d8_4xb4-160k_ade20k-512x512
-  In Collection: PSANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 43.74
-      mIoU(ms+flip): 45.38
-  Config: configs/psanet/psanet_r101-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - PSANet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_160k_ade20k/psanet_r101-d8_512x512_160k_ade20k_20200615_161537-dbfa564c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_160k_ade20k/psanet_r101-d8_512x512_160k_ade20k_20200615_161537.log.json
-  Paper:
-    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
-    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
-  Framework: PyTorch
-- Name: psanet_r50-d8_4xb4-20k_voc12aug-512x512
-  In Collection: PSANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 76.39
-      mIoU(ms+flip): 77.34
-  Config: configs/psanet/psanet_r50-d8_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - PSANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_20k_voc12aug/psanet_r50-d8_512x512_20k_voc12aug_20200617_102413-2f1bbaa1.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_20k_voc12aug/psanet_r50-d8_512x512_20k_voc12aug_20200617_102413.log.json
-  Paper:
-    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
-    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
-  Framework: PyTorch
-- Name: psanet_r101-d8_4xb4-20k_voc12aug-512x512
-  In Collection: PSANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 77.91
-      mIoU(ms+flip): 79.3
-  Config: configs/psanet/psanet_r101-d8_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - PSANet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.4
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_20k_voc12aug/psanet_r101-d8_512x512_20k_voc12aug_20200617_110624-946fef11.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_20k_voc12aug/psanet_r101-d8_512x512_20k_voc12aug_20200617_110624.log.json
-  Paper:
-    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
-    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
-  Framework: PyTorch
-- Name: psanet_r50-d8_4xb4-40k_voc12aug-512x512
-  In Collection: PSANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 76.3
-      mIoU(ms+flip): 77.35
-  Config: configs/psanet/psanet_r50-d8_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - PSANet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_40k_voc12aug/psanet_r50-d8_512x512_40k_voc12aug_20200613_161946-f596afb5.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r50-d8_512x512_40k_voc12aug/psanet_r50-d8_512x512_40k_voc12aug_20200613_161946.log.json
-  Paper:
-    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
-    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
-  Framework: PyTorch
-- Name: psanet_r101-d8_4xb4-40k_voc12aug-512x512
-  In Collection: PSANet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 77.73
-      mIoU(ms+flip): 79.05
-  Config: configs/psanet/psanet_r101-d8_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - PSANet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_40k_voc12aug/psanet_r101-d8_512x512_40k_voc12aug_20200613_161946-1f560f9e.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/psanet/psanet_r101-d8_512x512_40k_voc12aug/psanet_r101-d8_512x512_40k_voc12aug_20200613_161946.log.json
-  Paper:
-    Title: 'PSANet: Point-wise Spatial Attention Network for Scene Parsing'
-    URL: https://openaccess.thecvf.com/content_ECCV_2018/papers/Hengshuang_Zhao_PSANet_Point-wise_Spatial_ECCV_2018_paper.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psa_head.py#L18
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index e69cf42..0000000
--- a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './psanet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index e543099..0000000
--- a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './psanet_r50-d8_4xb2-40k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index b863638..0000000
--- a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './psanet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 097b1c5..0000000
--- a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './psanet_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index ac86306..0000000
--- a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './psanet_r50-d8_4xb4-160k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index abd8e56..0000000
--- a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './psanet_r50-d8_4xb4-20k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index d3154a8..0000000
--- a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './psanet_r50-d8_4xb4-40k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index b34d424..0000000
--- a/mmsegmentation/configs/psanet/psanet_r101-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './psanet_r50-d8_4xb4-80k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 82463aa..0000000
--- a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/psanet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index af44b30..0000000
--- a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/psanet_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 5e5052f..0000000
--- a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/psanet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 0eaf830..0000000
--- a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/psanet_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index de13296..0000000
--- a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/psanet_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(mask_size=(66, 66), num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index 45d8762..0000000
--- a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/psanet_r50-d8.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_20k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index b5d99d1..0000000
--- a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/psanet_r50-d8.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index c3b6528..0000000
--- a/mmsegmentation/configs/psanet/psanet_r50-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/psanet_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(mask_size=(66, 66), num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/pspnet/README.md b/mmsegmentation/configs/pspnet/README.md
deleted file mode 100644
index 4209d25..0000000
--- a/mmsegmentation/configs/pspnet/README.md
+++ /dev/null
@@ -1,182 +0,0 @@
-# PSPNet
-
-> [Pyramid Scene Parsing Network](https://arxiv.org/abs/1612.01105)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/hszhao/PSPNet">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Scene parsing is challenging for unrestricted open vocabulary and diverse scenes. In this paper, we exploit the capability of global context information by different-region-based context aggregation through our pyramid pooling module together with the proposed pyramid scene parsing network (PSPNet). Our global prior representation is effective to produce good quality results on the scene parsing task, while PSPNet provides a superior framework for pixel-level prediction tasks. The proposed approach achieves state-of-the-art performance on various datasets. It came first in ImageNet scene parsing challenge 2016, PASCAL VOC 2012 benchmark and Cityscapes benchmark. A single PSPNet yields new record of mIoU accuracy 85.4% on PASCAL VOC 2012 and accuracy 80.2% on Cityscapes.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142902444-9f93b99e-9261-443b-a0a4-17e78eefb525.png" width="70%"/>
-</div>
-
-<div align=center >
-<img alt="PSPNet-R50-D8" src="https://user-images.githubusercontent.com/47882088/209554973-66804b14-de5a-4f83-b54e-26683a91818a.jpg"/>
-PSPNet-R50 D8 model structure
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method        | Backbone      | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                   | download                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| ------------- | ------------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ---------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| PSPNet        | R-50-D8       | 512x1024  |   40000 | 6.1      | 4.07           | V100   | 77.85 |         79.18 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py)            | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338.log.json)                                                                                 |
-| PSPNet        | R-101-D8      | 512x1024  |   40000 | 9.6      | 2.68           | V100   | 78.34 |         79.74 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_40k_cityscapes/pspnet_r101-d8_512x1024_40k_cityscapes_20200604_232751-467e7cf4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_40k_cityscapes/pspnet_r101-d8_512x1024_40k_cityscapes_20200604_232751.log.json)                                                                             |
-| PSPNet        | R-50-D8       | 769x769   |   40000 | 6.9      | 1.76           | V100   | 78.26 |         79.88 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-769x769.py)             | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_769x769_40k_cityscapes/pspnet_r50-d8_769x769_40k_cityscapes_20200606_112725-86638686.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_769x769_40k_cityscapes/pspnet_r50-d8_769x769_40k_cityscapes_20200606_112725.log.json)                                                                                     |
-| PSPNet        | R-101-D8      | 769x769   |   40000 | 10.9     | 1.15           | V100   | 79.08 |         80.28 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-769x769.py)            | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_769x769_40k_cityscapes/pspnet_r101-d8_769x769_40k_cityscapes_20200606_112753-61c6f5be.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_769x769_40k_cityscapes/pspnet_r101-d8_769x769_40k_cityscapes_20200606_112753.log.json)                                                                                 |
-| PSPNet        | R-18-D8       | 512x1024  |   80000 | 1.7      | 15.71          | V100   | 74.87 |         76.04 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-512x1024.py)            | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_512x1024_80k_cityscapes/pspnet_r18-d8_512x1024_80k_cityscapes_20201225_021458-09ffa746.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_512x1024_80k_cityscapes/pspnet_r18-d8_512x1024_80k_cityscapes-20201225_021458.log.json)                                                                                 |
-| PSPNet        | R-50-D8       | 512x1024  |   80000 | -        | -              | V100   | 78.55 |         79.79 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py)            | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes/pspnet_r50-d8_512x1024_80k_cityscapes_20200606_112131-2376f12b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes/pspnet_r50-d8_512x1024_80k_cityscapes_20200606_112131.log.json)                                                                                 |
-| PSPNet        | R-50b-D8 rsb  | 512x1024  |   80000 | 6.2      | 3.82           | V100   | 78.47 |         79.45 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8-rsb_4xb2-adamw-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes/pspnet_r50-d8_rsb-pretrain_512x1024_adamw_80k_cityscapes_20220315_123238-588c30be.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes/pspnet_r50-d8_rsb-pretrain_512x1024_adamw_80k_cityscapes_20220315_123238.log.json)                                           |
-| PSPNet        | R-101-D8      | 512x1024  |   80000 | -        | -              | V100   | 79.76 |         81.01 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-512x1024.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_80k_cityscapes/pspnet_r101-d8_512x1024_80k_cityscapes_20200606_112211-e1e1100f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_80k_cityscapes/pspnet_r101-d8_512x1024_80k_cityscapes_20200606_112211.log.json)                                                                             |
-| PSPNet (FP16) | R-101-D8      | 512x1024  |   80000 | 5.34     | 8.77           | V100   | 79.46 |             - | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_fp16_512x1024_80k_cityscapes/pspnet_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230919-a0875e5c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_fp16_512x1024_80k_cityscapes/pspnet_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230919.log.json)                                                         |
-| PSPNet        | R-18-D8       | 769x769   |   80000 | 1.9      | 6.20           | V100   | 75.90 |         77.86 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-769x769.py)             | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_769x769_80k_cityscapes/pspnet_r18-d8_769x769_80k_cityscapes_20201225_021458-3deefc62.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_769x769_80k_cityscapes/pspnet_r18-d8_769x769_80k_cityscapes-20201225_021458.log.json)                                                                                     |
-| PSPNet        | R-50-D8       | 769x769   |   80000 | -        | -              | V100   | 79.59 |         80.69 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-769x769.py)             | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_769x769_80k_cityscapes/pspnet_r50-d8_769x769_80k_cityscapes_20200606_210121-5ccf03dd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_769x769_80k_cityscapes/pspnet_r50-d8_769x769_80k_cityscapes_20200606_210121.log.json)                                                                                     |
-| PSPNet        | R-101-D8      | 769x769   |   80000 | -        | -              | V100   | 79.77 |         81.06 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-769x769.py)            | [model](https://download.oz1z1penmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_769x769_80k_cityscapes/pspnet_r101-d8_769x769_80k_cityscapes_20200606_225055-dba412fa.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_769x769_80k_cityscapes/pspnet_r101-d8_769x769_80k_cityscapes_20200606_225055.log.json)                                                                             |
-| PSPNet        | R-18b-D8      | 512x1024  |   80000 | 1.5      | 16.28          | V100   | 74.23 |         75.79 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-512x1024.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18b-d8_512x1024_80k_cityscapes/pspnet_r18b-d8_512x1024_80k_cityscapes_20201226_063116-26928a60.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18b-d8_512x1024_80k_cityscapes/pspnet_r18b-d8_512x1024_80k_cityscapes-20201226_063116.log.json)                                                                             |
-| PSPNet        | R-50b-D8      | 512x1024  |   80000 | 6.0      | 4.30           | V100   | 78.22 |         79.46 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d8_512x1024_80k_cityscapes/pspnet_r50b-d8_512x1024_80k_cityscapes_20201225_094315-6344287a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d8_512x1024_80k_cityscapes/pspnet_r50b-d8_512x1024_80k_cityscapes-20201225_094315.log.json)                                                                             |
-| PSPNet        | R-101b-D8     | 512x1024  |   80000 | 9.5      | 2.76           | V100   | 79.69 |         80.79 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_512x1024_80k_cityscapes/pspnet_r101b-d8_512x1024_80k_cityscapes_20201226_170012-3a4d38ab.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_512x1024_80k_cityscapes/pspnet_r101b-d8_512x1024_80k_cityscapes-20201226_170012.log.json)                                                                         |
-| PSPNet        | R-18b-D8      | 769x769   |   80000 | 1.7      | 6.41           | V100   | 74.92 |         76.90 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-769x769.py)            | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18b-d8_769x769_80k_cityscapes/pspnet_r18b-d8_769x769_80k_cityscapes_20201226_080942-bf98d186.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18b-d8_769x769_80k_cityscapes/pspnet_r18b-d8_769x769_80k_cityscapes-20201226_080942.log.json)                                                                                 |
-| PSPNet        | R-50b-D8      | 769x769   |   80000 | 6.8      | 1.88           | V100   | 78.50 |         79.96 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-769x769.py)            | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d8_769x769_80k_cityscapes/pspnet_r50b-d8_769x769_80k_cityscapes_20201225_094316-4c643cf6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d8_769x769_80k_cityscapes/pspnet_r50b-d8_769x769_80k_cityscapes-20201225_094316.log.json)                                                                                 |
-| PSPNet        | R-101b-D8     | 769x769   |   80000 | 10.8     | 1.17           | V100   | 78.87 |         80.04 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-769x769.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_769x769_80k_cityscapes/pspnet_r101b-d8_769x769_80k_cityscapes_20201226_171823-f0e7c293.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_769x769_80k_cityscapes/pspnet_r101b-d8_769x769_80k_cityscapes-20201226_171823.log.json)                                                                             |
-| PSPNet        | R-50-D32      | 512x1024  |   80000 | 3.0      | 15.21          | V100   | 73.88 |         76.85 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50b-d32_4xb2-80k_cityscapes-512x1024.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d32_512x1024_80k_cityscapes/pspnet_r50-d32_512x1024_80k_cityscapes_20220316_224840-9092b254.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d32_512x1024_80k_cityscapes/pspnet_r50-d32_512x1024_80k_cityscapes_20220316_224840.log.json)                                                                             |
-| PSPNet        | R-50b-D32 rsb | 512x1024  |   80000 | 3.1      | 16.08          | V100   | 74.09 |         77.18 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d32_rsb_4xb2-adamw-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d32_rsb-pretrain_512x1024_adamw_80k_cityscapes/pspnet_r50-d32_rsb-pretrain_512x1024_adamw_80k_cityscapes_20220316_141229-dd9c9610.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d32_rsb-pretrain_512x1024_adamw_80k_cityscapes/pspnet_r50-d32_rsb-pretrain_512x1024_adamw_80k_cityscapes_20220316_141229.log.json) |
-| PSPNet        | R-50b-D32     | 512x1024  |   80000 | 2.9      | 15.41          | V100   | 72.61 |         75.51 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50b-d32_4xb2-80k_cityscapes-512x1024.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d32_512x1024_80k_cityscapes/pspnet_r50b-d32_512x1024_80k_cityscapes_20220311_152152-23bcaf8c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d32_512x1024_80k_cityscapes/pspnet_r50b-d32_512x1024_80k_cityscapes_20220311_152152.log.json)                                                                         |
-
-### ADE20K
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                     | download                                                                                                                                                                                                                                                                                                                                 |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| PSPNet | R-50-D8  | 512x512   |   80000 | 8.5      | 23.53          | V100   | 41.13 |         41.94 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_80k_ade20k/pspnet_r50-d8_512x512_80k_ade20k_20200615_014128-15a8b914.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_80k_ade20k/pspnet_r50-d8_512x512_80k_ade20k_20200615_014128.log.json)         |
-| PSPNet | R-101-D8 | 512x512   |   80000 | 12       | 15.30          | V100   | 43.57 |         44.35 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_80k_ade20k/pspnet_r101-d8_512x512_80k_ade20k_20200614_031423-b6e782f0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_80k_ade20k/pspnet_r101-d8_512x512_80k_ade20k_20200614_031423.log.json)     |
-| PSPNet | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 42.48 |         43.44 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_160k_ade20k/pspnet_r50-d8_512x512_160k_ade20k_20200615_184358-1890b0bd.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_160k_ade20k/pspnet_r50-d8_512x512_160k_ade20k_20200615_184358.log.json)     |
-| PSPNet | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 44.39 |         45.35 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_160k_ade20k/pspnet_r101-d8_512x512_160k_ade20k_20200615_100650-967c316f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_160k_ade20k/pspnet_r101-d8_512x512_160k_ade20k_20200615_100650.log.json) |
-
-### Pascal VOC 2012 + Aug
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                      | download                                                                                                                                                                                                                                                                                                                                     |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | --------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| PSPNet | R-50-D8  | 512x512   |   20000 | 6.1      | 23.59          | V100   | 76.78 |         77.61 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_20k_voc12aug/pspnet_r50-d8_512x512_20k_voc12aug_20200617_101958-ed5dfbd9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_20k_voc12aug/pspnet_r50-d8_512x512_20k_voc12aug_20200617_101958.log.json)     |
-| PSPNet | R-101-D8 | 512x512   |   20000 | 9.6      | 15.02          | V100   | 78.47 |         79.25 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_20k_voc12aug/pspnet_r101-d8_512x512_20k_voc12aug_20200617_102003-4aef3c9a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_20k_voc12aug/pspnet_r101-d8_512x512_20k_voc12aug_20200617_102003.log.json) |
-| PSPNet | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 77.29 |         78.48 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_40k_voc12aug/pspnet_r50-d8_512x512_40k_voc12aug_20200613_161222-ae9c1b8c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_40k_voc12aug/pspnet_r50-d8_512x512_40k_voc12aug_20200613_161222.log.json)     |
-| PSPNet | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 78.52 |         79.57 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_40k_voc12aug/pspnet_r101-d8_512x512_40k_voc12aug_20200613_161222-bc933b18.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_40k_voc12aug/pspnet_r101-d8_512x512_40k_voc12aug_20200613_161222.log.json) |
-
-### Pascal Context
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                            | download                                                                                                                                                                                                                                                                                                                                                             |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | --------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| PSPNet | R-101-D8 | 480x480   |   40000 | 8.8      | 9.68           | V100   | 46.60 |         47.78 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_40k_pascal_context/pspnet_r101-d8_480x480_40k_pascal_context_20200911_211210-bf0f5d7c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_40k_pascal_context/pspnet_r101-d8_480x480_40k_pascal_context-20200911_211210.log.json) |
-| PSPNet | R-101-D8 | 480x480   |   80000 | -        | -              | V100   | 46.03 |         47.15 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_80k_pascal_context/pspnet_r101-d8_480x480_80k_pascal_context_20200911_190530-c86d6233.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_80k_pascal_context/pspnet_r101-d8_480x480_80k_pascal_context-20200911_190530.log.json) |
-
-### Pascal Context 59
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                               | download                                                                                                                                                                                                                                                                                                                                                                         |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| PSPNet | R-101-D8 | 480x480   |   40000 | -        | -              | V100   | 52.02 |         53.54 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-59-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_40k_pascal_context_59/pspnet_r101-d8_480x480_40k_pascal_context_59_20210416_114524-86d44cd4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_40k_pascal_context_59/pspnet_r101-d8_480x480_40k_pascal_context_59-20210416_114524.log.json) |
-| PSPNet | R-101-D8 | 480x480   |   80000 | -        | -              | V100   | 52.47 |         53.99 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-59-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_80k_pascal_context_59/pspnet_r101-d8_480x480_80k_pascal_context_59_20210416_114418-fa6caaa2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_80k_pascal_context_59/pspnet_r101-d8_480x480_80k_pascal_context_59-20210416_114418.log.json) |
-
-### Dark Zurich and Nighttime Driving
-
-We support evaluation results on these two datasets using models above trained on Cityscapes training set.
-
-| Method | Backbone  | Training Dataset        | Test Dataset              | mIoU  | config                                                                                                                                                  | evaluation checkpoint                                                                                                                                                                                                                                                                                                                                        |
-| ------ | --------- | ----------------------- | ------------------------- | ----- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| PSPNet | R-50-D8   | Cityscapes Training set | Dark Zurich               | 10.91 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_dark-zurich-1920x1080.py)     | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338.log.json)         |
-| PSPNet | R-50-D8   | Cityscapes Training set | Nighttime Driving         | 23.02 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_night-driving-1920x1080.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338.log.json)         |
-| PSPNet | R-50-D8   | Cityscapes Training set | Cityscapes Validation set | 77.85 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py)                           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338.log.json)         |
-| PSPNet | R-101-D8  | Cityscapes Training set | Dark Zurich               | 10.16 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024_dark-zurich-1920x1080.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_40k_cityscapes/pspnet_r101-d8_512x1024_40k_cityscapes_20200604_232751-467e7cf4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_40k_cityscapes/pspnet_r101-d8_512x1024_40k_cityscapes_20200604_232751.log.json)     |
-| PSPNet | R-101-D8  | Cityscapes Training set | Nighttime Driving         | 20.25 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024_night-driving-1920x1080.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_40k_cityscapes/pspnet_r101-d8_512x1024_40k_cityscapes_20200604_232751-467e7cf4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_40k_cityscapes/pspnet_r101-d8_512x1024_40k_cityscapes_20200604_232751.log.json)     |
-| PSPNet | R-101-D8  | Cityscapes Training set | Cityscapes Validation set | 78.34 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024.py)                          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_40k_cityscapes/pspnet_r101-d8_512x1024_40k_cityscapes_20200604_232751-467e7cf4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_40k_cityscapes/pspnet_r101-d8_512x1024_40k_cityscapes_20200604_232751.log.json)     |
-| PSPNet | R-101b-D8 | Cityscapes Training set | Dark Zurich               | 15.54 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024_dark-zurich-1920x1080.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_512x1024_80k_cityscapes/pspnet_r101b-d8_512x1024_80k_cityscapes_20201226_170012-3a4d38ab.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_512x1024_80k_cityscapes/pspnet_r101b-d8_512x1024_80k_cityscapes-20201226_170012.log.json) |
-| PSPNet | R-101b-D8 | Cityscapes Training set | Nighttime Driving         | 22.25 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024_night-driving-1920x1080.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_512x1024_80k_cityscapes/pspnet_r101b-d8_512x1024_80k_cityscapes_20201226_170012-3a4d38ab.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_512x1024_80k_cityscapes/pspnet_r101b-d8_512x1024_80k_cityscapes-20201226_170012.log.json) |
-| PSPNet | R-101b-D8 | Cityscapes Training set | Cityscapes Validation set | 79.69 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024.py)                         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_512x1024_80k_cityscapes/pspnet_r101b-d8_512x1024_80k_cityscapes_20201226_170012-3a4d38ab.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_512x1024_80k_cityscapes/pspnet_r101b-d8_512x1024_80k_cityscapes-20201226_170012.log.json) |
-
-### COCO-Stuff 10k
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                           | download                                                                                                                                                                                                                                                                                                                                                                         |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| PSPNet | R-50-D8  | 512x512   |   20000 | 9.6      | 20.5           | V100   | 35.69 |         36.62 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-20k_coco-stuff10k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_20k_coco-stuff10k/pspnet_r50-d8_512x512_4x4_20k_coco-stuff10k_20210820_203258-b88df27f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_20k_coco-stuff10k/pspnet_r50-d8_512x512_4x4_20k_coco-stuff10k_20210820_203258.log.json)     |
-| PSPNet | R-101-D8 | 512x512   |   20000 | 13.2     | 11.1           | V100   | 37.26 |         38.52 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-20k_coco-stuff10k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_20k_coco-stuff10k/pspnet_r101-d8_512x512_4x4_20k_coco-stuff10k_20210820_232135-76aae482.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_20k_coco-stuff10k/pspnet_r101-d8_512x512_4x4_20k_coco-stuff10k_20210820_232135.log.json) |
-| PSPNet | R-50-D8  | 512x512   |   40000 | -        | -              | V100   | 36.33 |         37.24 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-40k_coco-stuff10k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_40k_coco-stuff10k/pspnet_r50-d8_512x512_4x4_40k_coco-stuff10k_20210821_030857-92e2902b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_40k_coco-stuff10k/pspnet_r50-d8_512x512_4x4_40k_coco-stuff10k_20210821_030857.log.json)     |
-| PSPNet | R-101-D8 | 512x512   |   40000 | -        | -              | V100   | 37.76 |         38.86 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-40k_coco-stuff10k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_40k_coco-stuff10k/pspnet_r101-d8_512x512_4x4_40k_coco-stuff10k_20210821_014022-831aec95.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_40k_coco-stuff10k/pspnet_r101-d8_512x512_4x4_40k_coco-stuff10k_20210821_014022.log.json) |
-
-### COCO-Stuff 164k
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                             | download                                                                                                                                                                                                                                                                                                                                                                                 |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ---------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| PSPNet | R-50-D8  | 512x512   |   80000 | 9.6      | 20.5           | V100   | 38.80 |         39.19 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-80k_coco-stuff164k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_80k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_80k_coco-stuff164k_20210707_152034-0e41b2db.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_80k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_80k_coco-stuff164k_20210707_152034.log.json)         |
-| PSPNet | R-101-D8 | 512x512   |   80000 | 13.2     | 11.1           | V100   | 40.34 |         40.79 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-80k_coco-stuff164k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_80k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_80k_coco-stuff164k_20210707_152034-7eb41789.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_80k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_80k_coco-stuff164k_20210707_152034.log.json)     |
-| PSPNet | R-50-D8  | 512x512   |  160000 | -        | -              | V100   | 39.64 |         39.97 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-160k_coco-stuff164k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_160k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_160k_coco-stuff164k_20210707_152004-51276a57.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_160k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_160k_coco-stuff164k_20210707_152004.log.json)     |
-| PSPNet | R-101-D8 | 512x512   |  160000 | -        | -              | V100   | 41.28 |         41.66 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-160k_coco-stuff164k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_160k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_160k_coco-stuff164k_20210707_152004-4af9621b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_160k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_160k_coco-stuff164k_20210707_152004.log.json) |
-| PSPNet | R-50-D8  | 512x512   |  320000 | -        | -              | V100   | 40.53 |         40.75 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-320k_coco-stuff164k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_320k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_320k_coco-stuff164k_20210707_152004-be9610cc.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_320k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_320k_coco-stuff164k_20210707_152004.log.json)     |
-| PSPNet | R-101-D8 | 512x512   |  320000 | -        | -              | V100   | 41.95 |         42.42 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-320k_coco-stuff164k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_320k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_320k_coco-stuff164k_20210707_152004-72220c60.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_320k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_320k_coco-stuff164k_20210707_152004.log.json) |
-
-### LoveDA
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                    | download                                                                                                                                                                                                                                                                                                                             |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| PSPNet | R-18-D8  | 512x512   |   80000 | 1.45     | 26.87          | V100   | 48.62 |         47.57 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r18-d8_4xb4-80k_loveda-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_512x512_80k_loveda/pspnet_r18-d8_512x512_80k_loveda_20211105_052100-b97697f1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_512x512_80k_loveda/pspnet_r18-d8_512x512_80k_loveda_20211105_052100.log.json)     |
-| PSPNet | R-50-D8  | 512x512   |   80000 | 6.14     | 6.60           | V100   | 50.46 |         50.19 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-80k_loveda-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_80k_loveda/pspnet_r50-d8_512x512_80k_loveda_20211104_155728-88610f9f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_80k_loveda/pspnet_r50-d8_512x512_80k_loveda_20211104_155728.log.json)     |
-| PSPNet | R-101-D8 | 512x512   |   80000 | 9.61     | 4.58           | V100   | 51.86 |         51.34 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-80k_loveda-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_80k_loveda/pspnet_r101-d8_512x512_80k_loveda_20211104_153212-1c06c6a8.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_80k_loveda/pspnet_r101-d8_512x512_80k_loveda_20211104_153212.log.json) |
-
-### Potsdam
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                     | download                                                                                                                                                                                                                                                                                                                                                 |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| PSPNet | R-18-D8  | 512x512   |   80000 | 1.50     | 85.12          | V100   | 77.09 |         78.30 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r18-d8_4xb4-80k_potsdam-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_512x512_80k_potsdam/pspnet_r18-d8_4x4_512x512_80k_potsdam_20211220_125612-7cd046e1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_512x512_80k_potsdam/pspnet_r18-d8_4x4_512x512_80k_potsdam_20211220_125612.log.json)     |
-| PSPNet | R-50-D8  | 512x512   |   80000 | 6.14     | 30.21          | V100   | 78.12 |         78.98 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-80k_potsdam-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_512x512_80k_potsdam/pspnet_r50-d8_4x4_512x512_80k_potsdam_20211219_043541-2dd5fe67.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_512x512_80k_potsdam/pspnet_r50-d8_4x4_512x512_80k_potsdam_20211219_043541.log.json)     |
-| PSPNet | R-101-D8 | 512x512   |   80000 | 9.61     | 19.40          | V100   | 78.62 |         79.47 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-80k_potsdam-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_4x4_512x512_80k_potsdam/pspnet_r101-d8_4x4_512x512_80k_potsdam_20211220_125612-aed036c4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_4x4_512x512_80k_potsdam/pspnet_r101-d8_4x4_512x512_80k_potsdam_20211220_125612.log.json) |
-
-### Vaihingen
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                       | download                                                                                                                                                                                                                                                                                                                                                         |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| PSPNet | R-18-D8  | 512x512   |   80000 | 1.45     | 85.06          | V100   | 71.46 |         73.36 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r18-d8_4xb4-80k_vaihingen-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_512x512_80k_vaihingen/pspnet_r18-d8_4x4_512x512_80k_vaihingen_20211228_160355-52a8a6f6.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_512x512_80k_vaihingen/pspnet_r18-d8_4x4_512x512_80k_vaihingen_20211228_160355.log.json)     |
-| PSPNet | R-50-D8  | 512x512   |   80000 | 6.14     | 30.29          | V100   | 72.36 |         73.75 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-80k_vaihingen-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_512x512_80k_vaihingen/pspnet_r50-d8_4x4_512x512_80k_vaihingen_20211228_160355-382f8f5b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_512x512_80k_vaihingen/pspnet_r50-d8_4x4_512x512_80k_vaihingen_20211228_160355.log.json)     |
-| PSPNet | R-101-D8 | 512x512   |   80000 | 9.61     | 19.97          | V100   | 72.61 |         74.18 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r101-d8_4xb4-80k_vaihingen-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_4x4_512x512_80k_vaihingen/pspnet_r101-d8_4x4_512x512_80k_vaihingen_20211231_230806-8eba0a09.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_4x4_512x512_80k_vaihingen/pspnet_r101-d8_4x4_512x512_80k_vaihingen_20211231_230806.log.json) |
-
-### iSAID
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                  | download                                                                                                                                                                                                                                                                                                                                     |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ----------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| PSPNet | R-18-D8  | 896x896   |   80000 | 4.52     | 26.91          | V100   | 60.22 |         61.25 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r18-d8_4xb4-80k_isaid-896x896.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_896x896_80k_isaid/pspnet_r18-d8_4x4_896x896_80k_isaid_20220110_180526-e84c0b6a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_896x896_80k_isaid/pspnet_r18-d8_4x4_896x896_80k_isaid_20220110_180526.log.json) |
-| PSPNet | R-50-D8  | 896x896   |   80000 | 16.58    | 8.88           | V100   | 65.36 |         66.48 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb4-80k_isaid-896x896.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_896x896_80k_isaid/pspnet_r50-d8_4x4_896x896_80k_isaid_20220110_180629-1f21dc32.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_896x896_80k_isaid/pspnet_r50-d8_4x4_896x896_80k_isaid_20220110_180629.log.json) |
-
-Note:
-
-- `FP16` means Mixed Precision (FP16) is adopted in training.
-- `896x896` is the Crop Size of iSAID dataset, which is followed by the implementation of [PointFlow: Flowing Semantics Through Points for Aerial Image Segmentation](https://arxiv.org/pdf/2103.06564.pdf)
-- `rsb` is short for 'Resnet strikes back'.
-- The `b` in `R-50b` means ResNetV1b, which is a standard ResNet backbone. In MMSegmentation, default backbone is ResNetV1c, which usually performs better in semantic segmentation task.
-
-## Citation
-
-```bibtex
-@inproceedings{zhao2017pspnet,
-  title={Pyramid Scene Parsing Network},
-  author={Zhao, Hengshuang and Shi, Jianping and Qi, Xiaojuan and Wang, Xiaogang and Jia, Jiaya},
-  booktitle={CVPR},
-  year={2017}
-}
-```
-
-```bibtex
-@article{wightman2021resnet,
-  title={Resnet strikes back: An improved training procedure in timm},
-  author={Wightman, Ross and Touvron, Hugo and J{\'e}gou, Herv{\'e}},
-  journal={arXiv preprint arXiv:2110.00476},
-  year={2021}
-}
-```
diff --git a/mmsegmentation/configs/pspnet/metafile.yaml b/mmsegmentation/configs/pspnet/metafile.yaml
deleted file mode 100644
index d00b89d..0000000
--- a/mmsegmentation/configs/pspnet/metafile.yaml
+++ /dev/null
@@ -1,1303 +0,0 @@
-Collections:
-- Name: PSPNet
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-    - ADE20K
-    - Pascal VOC 2012 + Aug
-    - Pascal Context
-    - Pascal Context 59
-    - Dark Zurich and Nighttime Driving
-    - COCO-Stuff 10k
-    - COCO-Stuff 164k
-    - LoveDA
-    - Potsdam
-    - Vaihingen
-    - iSAID
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  README: configs/pspnet/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: pspnet_r50-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.85
-      mIoU(ms+flip): 79.18
-  Config: configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r101-d8_4xb2-40k_cityscapes-512x1024
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.34
-      mIoU(ms+flip): 79.74
-  Config: configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_40k_cityscapes/pspnet_r101-d8_512x1024_40k_cityscapes_20200604_232751-467e7cf4.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_40k_cityscapes/pspnet_r101-d8_512x1024_40k_cityscapes_20200604_232751.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r50-d8_4xb2-40k_cityscapes-769x769
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.26
-      mIoU(ms+flip): 79.88
-  Config: configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_769x769_40k_cityscapes/pspnet_r50-d8_769x769_40k_cityscapes_20200606_112725-86638686.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_769x769_40k_cityscapes/pspnet_r50-d8_769x769_40k_cityscapes_20200606_112725.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r101-d8_4xb2-40k_cityscapes-769x769
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.08
-      mIoU(ms+flip): 80.28
-  Config: configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_769x769_40k_cityscapes/pspnet_r101-d8_769x769_40k_cityscapes_20200606_112753-61c6f5be.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_769x769_40k_cityscapes/pspnet_r101-d8_769x769_40k_cityscapes_20200606_112753.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r18-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 74.87
-      mIoU(ms+flip): 76.04
-  Config: configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-18-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.7
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_512x1024_80k_cityscapes/pspnet_r18-d8_512x1024_80k_cityscapes_20201225_021458-09ffa746.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_512x1024_80k_cityscapes/pspnet_r18-d8_512x1024_80k_cityscapes-20201225_021458.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r50-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.55
-      mIoU(ms+flip): 79.79
-  Config: configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes/pspnet_r50-d8_512x1024_80k_cityscapes_20200606_112131-2376f12b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes/pspnet_r50-d8_512x1024_80k_cityscapes_20200606_112131.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r50-d8-rsb_4xb2-adamw-80k_cityscapes-512x1024
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.47
-      mIoU(ms+flip): 79.45
-  Config: configs/pspnet/pspnet_r50-d8-rsb_4xb2-adamw-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50b-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes/pspnet_r50-d8_rsb-pretrain_512x1024_adamw_80k_cityscapes_20220315_123238-588c30be.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes/pspnet_r50-d8_rsb-pretrain_512x1024_adamw_80k_cityscapes_20220315_123238.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r101-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.76
-      mIoU(ms+flip): 81.01
-  Config: configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_80k_cityscapes/pspnet_r101-d8_512x1024_80k_cityscapes_20200606_112211-e1e1100f.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x1024_80k_cityscapes/pspnet_r101-d8_512x1024_80k_cityscapes_20200606_112211.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r101-d8_4xb2-amp-80k_cityscapes-512x1024
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.46
-  Config: configs/pspnet/pspnet_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - PSPNet
-    - (FP16)
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.34
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_fp16_512x1024_80k_cityscapes/pspnet_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230919-a0875e5c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_fp16_512x1024_80k_cityscapes/pspnet_r101-d8_fp16_512x1024_80k_cityscapes_20200717_230919.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r18-d8_4xb2-80k_cityscapes-769x769
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 75.9
-      mIoU(ms+flip): 77.86
-  Config: configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-18-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_769x769_80k_cityscapes/pspnet_r18-d8_769x769_80k_cityscapes_20201225_021458-3deefc62.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_769x769_80k_cityscapes/pspnet_r18-d8_769x769_80k_cityscapes-20201225_021458.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r50-d8_4xb2-80k_cityscapes-769x769
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.59
-      mIoU(ms+flip): 80.69
-  Config: configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_769x769_80k_cityscapes/pspnet_r50-d8_769x769_80k_cityscapes_20200606_210121-5ccf03dd.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_769x769_80k_cityscapes/pspnet_r50-d8_769x769_80k_cityscapes_20200606_210121.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r101-d8_4xb2-80k_cityscapes-769x769
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.77
-      mIoU(ms+flip): 81.06
-  Config: configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.oz1z1penmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_769x769_80k_cityscapes/pspnet_r101-d8_769x769_80k_cityscapes_20200606_225055-dba412fa.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_769x769_80k_cityscapes/pspnet_r101-d8_769x769_80k_cityscapes_20200606_225055.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r18b-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 74.23
-      mIoU(ms+flip): 75.79
-  Config: configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-18b-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18b-d8_512x1024_80k_cityscapes/pspnet_r18b-d8_512x1024_80k_cityscapes_20201226_063116-26928a60.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18b-d8_512x1024_80k_cityscapes/pspnet_r18b-d8_512x1024_80k_cityscapes-20201226_063116.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.22
-      mIoU(ms+flip): 79.46
-  Config: configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50b-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d8_512x1024_80k_cityscapes/pspnet_r50b-d8_512x1024_80k_cityscapes_20201225_094315-6344287a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d8_512x1024_80k_cityscapes/pspnet_r50b-d8_512x1024_80k_cityscapes-20201225_094315.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.69
-      mIoU(ms+flip): 80.79
-  Config: configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101b-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_512x1024_80k_cityscapes/pspnet_r101b-d8_512x1024_80k_cityscapes_20201226_170012-3a4d38ab.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_512x1024_80k_cityscapes/pspnet_r101b-d8_512x1024_80k_cityscapes-20201226_170012.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r18b-d8_4xb2-80k_cityscapes-769x769
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 74.92
-      mIoU(ms+flip): 76.9
-  Config: configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-18b-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.7
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18b-d8_769x769_80k_cityscapes/pspnet_r18b-d8_769x769_80k_cityscapes_20201226_080942-bf98d186.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18b-d8_769x769_80k_cityscapes/pspnet_r18b-d8_769x769_80k_cityscapes-20201226_080942.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r50b-d8_4xb2-80k_cityscapes-769x769
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.5
-      mIoU(ms+flip): 79.96
-  Config: configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50b-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d8_769x769_80k_cityscapes/pspnet_r50b-d8_769x769_80k_cityscapes_20201225_094316-4c643cf6.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d8_769x769_80k_cityscapes/pspnet_r50b-d8_769x769_80k_cityscapes-20201225_094316.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r101b-d8_4xb2-80k_cityscapes-769x769
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.87
-      mIoU(ms+flip): 80.04
-  Config: configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101b-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 10.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_769x769_80k_cityscapes/pspnet_r101b-d8_769x769_80k_cityscapes_20201226_171823-f0e7c293.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101b-d8_769x769_80k_cityscapes/pspnet_r101b-d8_769x769_80k_cityscapes-20201226_171823.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r50b-d32_4xb2-80k_cityscapes-512x1024
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 73.88
-      mIoU(ms+flip): 76.85
-  Config: configs/pspnet/pspnet_r50b-d32_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50-D32
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 3.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d32_512x1024_80k_cityscapes/pspnet_r50-d32_512x1024_80k_cityscapes_20220316_224840-9092b254.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d32_512x1024_80k_cityscapes/pspnet_r50-d32_512x1024_80k_cityscapes_20220316_224840.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r50-d32_rsb_4xb2-adamw-80k_cityscapes-512x1024
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 74.09
-      mIoU(ms+flip): 77.18
-  Config: configs/pspnet/pspnet_r50-d32_rsb_4xb2-adamw-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50b-D32
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 3.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d32_rsb-pretrain_512x1024_adamw_80k_cityscapes/pspnet_r50-d32_rsb-pretrain_512x1024_adamw_80k_cityscapes_20220316_141229-dd9c9610.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d32_rsb-pretrain_512x1024_adamw_80k_cityscapes/pspnet_r50-d32_rsb-pretrain_512x1024_adamw_80k_cityscapes_20220316_141229.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r50b-d32_4xb2-80k_cityscapes-512x1024
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 72.61
-      mIoU(ms+flip): 75.51
-  Config: configs/pspnet/pspnet_r50b-d32_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50b-D32
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 2.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d32_512x1024_80k_cityscapes/pspnet_r50b-d32_512x1024_80k_cityscapes_20220311_152152-23bcaf8c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50b-d32_512x1024_80k_cityscapes/pspnet_r50b-d32_512x1024_80k_cityscapes_20220311_152152.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r50-d8_4xb4-80k_ade20k-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 41.13
-      mIoU(ms+flip): 41.94
-  Config: configs/pspnet/pspnet_r50-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_80k_ade20k/pspnet_r50-d8_512x512_80k_ade20k_20200615_014128-15a8b914.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_80k_ade20k/pspnet_r50-d8_512x512_80k_ade20k_20200615_014128.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r101-d8_4xb4-80k_ade20k-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 43.57
-      mIoU(ms+flip): 44.35
-  Config: configs/pspnet/pspnet_r101-d8_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 12.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_80k_ade20k/pspnet_r101-d8_512x512_80k_ade20k_20200614_031423-b6e782f0.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_80k_ade20k/pspnet_r101-d8_512x512_80k_ade20k_20200614_031423.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r50-d8_4xb4-160k_ade20k-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.48
-      mIoU(ms+flip): 43.44
-  Config: configs/pspnet/pspnet_r50-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_160k_ade20k/pspnet_r50-d8_512x512_160k_ade20k_20200615_184358-1890b0bd.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_160k_ade20k/pspnet_r50-d8_512x512_160k_ade20k_20200615_184358.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r101-d8_4xb4-160k_ade20k-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 44.39
-      mIoU(ms+flip): 45.35
-  Config: configs/pspnet/pspnet_r101-d8_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_160k_ade20k/pspnet_r101-d8_512x512_160k_ade20k_20200615_100650-967c316f.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_160k_ade20k/pspnet_r101-d8_512x512_160k_ade20k_20200615_100650.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r50-d8_4xb4-20k_voc12aug-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 76.78
-      mIoU(ms+flip): 77.61
-  Config: configs/pspnet/pspnet_r50-d8_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_20k_voc12aug/pspnet_r50-d8_512x512_20k_voc12aug_20200617_101958-ed5dfbd9.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_20k_voc12aug/pspnet_r50-d8_512x512_20k_voc12aug_20200617_101958.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r101-d8_4xb4-20k_voc12aug-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 78.47
-      mIoU(ms+flip): 79.25
-  Config: configs/pspnet/pspnet_r101-d8_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_20k_voc12aug/pspnet_r101-d8_512x512_20k_voc12aug_20200617_102003-4aef3c9a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_20k_voc12aug/pspnet_r101-d8_512x512_20k_voc12aug_20200617_102003.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r50-d8_4xb4-40k_voc12aug-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 77.29
-      mIoU(ms+flip): 78.48
-  Config: configs/pspnet/pspnet_r50-d8_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_40k_voc12aug/pspnet_r50-d8_512x512_40k_voc12aug_20200613_161222-ae9c1b8c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_40k_voc12aug/pspnet_r50-d8_512x512_40k_voc12aug_20200613_161222.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r101-d8_4xb4-40k_voc12aug-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 78.52
-      mIoU(ms+flip): 79.57
-  Config: configs/pspnet/pspnet_r101-d8_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_40k_voc12aug/pspnet_r101-d8_512x512_40k_voc12aug_20200613_161222-bc933b18.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_40k_voc12aug/pspnet_r101-d8_512x512_40k_voc12aug_20200613_161222.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r101-d8_4xb4-40k_pascal-context-480x480
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal Context
-    Metrics:
-      mIoU: 46.6
-      mIoU(ms+flip): 47.78
-  Config: configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-480x480.py
-  Metadata:
-    Training Data: Pascal Context
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_40k_pascal_context/pspnet_r101-d8_480x480_40k_pascal_context_20200911_211210-bf0f5d7c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_40k_pascal_context/pspnet_r101-d8_480x480_40k_pascal_context-20200911_211210.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r101-d8_4xb4-80k_pascal-context-480x480
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal Context
-    Metrics:
-      mIoU: 46.03
-      mIoU(ms+flip): 47.15
-  Config: configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-480x480.py
-  Metadata:
-    Training Data: Pascal Context
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_80k_pascal_context/pspnet_r101-d8_480x480_80k_pascal_context_20200911_190530-c86d6233.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_80k_pascal_context/pspnet_r101-d8_480x480_80k_pascal_context-20200911_190530.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r101-d8_4xb4-40k_pascal-context-59-480x480
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal Context 59
-    Metrics:
-      mIoU: 52.02
-      mIoU(ms+flip): 53.54
-  Config: configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-59-480x480.py
-  Metadata:
-    Training Data: Pascal Context 59
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_40k_pascal_context_59/pspnet_r101-d8_480x480_40k_pascal_context_59_20210416_114524-86d44cd4.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_40k_pascal_context_59/pspnet_r101-d8_480x480_40k_pascal_context_59-20210416_114524.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r101-d8_4xb4-80k_pascal-context-59-480x480
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal Context 59
-    Metrics:
-      mIoU: 52.47
-      mIoU(ms+flip): 53.99
-  Config: configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-59-480x480.py
-  Metadata:
-    Training Data: Pascal Context 59
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_80k_pascal_context_59/pspnet_r101-d8_480x480_80k_pascal_context_59_20210416_114418-fa6caaa2.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_480x480_80k_pascal_context_59/pspnet_r101-d8_480x480_80k_pascal_context_59-20210416_114418.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r50-d8_4xb4-20k_coco-stuff10k-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 10k
-    Metrics:
-      mIoU: 35.69
-      mIoU(ms+flip): 36.62
-  Config: configs/pspnet/pspnet_r50-d8_4xb4-20k_coco-stuff10k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 10k
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_20k_coco-stuff10k/pspnet_r50-d8_512x512_4x4_20k_coco-stuff10k_20210820_203258-b88df27f.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_20k_coco-stuff10k/pspnet_r50-d8_512x512_4x4_20k_coco-stuff10k_20210820_203258.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r101-d8_4xb4-20k_coco-stuff10k-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 10k
-    Metrics:
-      mIoU: 37.26
-      mIoU(ms+flip): 38.52
-  Config: configs/pspnet/pspnet_r101-d8_4xb4-20k_coco-stuff10k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 10k
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 13.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_20k_coco-stuff10k/pspnet_r101-d8_512x512_4x4_20k_coco-stuff10k_20210820_232135-76aae482.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_20k_coco-stuff10k/pspnet_r101-d8_512x512_4x4_20k_coco-stuff10k_20210820_232135.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r50-d8_4xb4-40k_coco-stuff10k-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 10k
-    Metrics:
-      mIoU: 36.33
-      mIoU(ms+flip): 37.24
-  Config: configs/pspnet/pspnet_r50-d8_4xb4-40k_coco-stuff10k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 10k
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_40k_coco-stuff10k/pspnet_r50-d8_512x512_4x4_40k_coco-stuff10k_20210821_030857-92e2902b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_40k_coco-stuff10k/pspnet_r50-d8_512x512_4x4_40k_coco-stuff10k_20210821_030857.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r101-d8_4xb4-40k_coco-stuff10k-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 10k
-    Metrics:
-      mIoU: 37.76
-      mIoU(ms+flip): 38.86
-  Config: configs/pspnet/pspnet_r101-d8_4xb4-40k_coco-stuff10k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 10k
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_40k_coco-stuff10k/pspnet_r101-d8_512x512_4x4_40k_coco-stuff10k_20210821_014022-831aec95.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_40k_coco-stuff10k/pspnet_r101-d8_512x512_4x4_40k_coco-stuff10k_20210821_014022.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r50-d8_4xb4-80k_coco-stuff164k-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 164k
-    Metrics:
-      mIoU: 38.8
-      mIoU(ms+flip): 39.19
-  Config: configs/pspnet/pspnet_r50-d8_4xb4-80k_coco-stuff164k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 164k
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_80k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_80k_coco-stuff164k_20210707_152034-0e41b2db.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_80k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_80k_coco-stuff164k_20210707_152034.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r101-d8_4xb4-80k_coco-stuff164k-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 164k
-    Metrics:
-      mIoU: 40.34
-      mIoU(ms+flip): 40.79
-  Config: configs/pspnet/pspnet_r101-d8_4xb4-80k_coco-stuff164k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 164k
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 13.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_80k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_80k_coco-stuff164k_20210707_152034-7eb41789.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_80k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_80k_coco-stuff164k_20210707_152034.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r50-d8_4xb4-160k_coco-stuff164k-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 164k
-    Metrics:
-      mIoU: 39.64
-      mIoU(ms+flip): 39.97
-  Config: configs/pspnet/pspnet_r50-d8_4xb4-160k_coco-stuff164k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 164k
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_160k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_160k_coco-stuff164k_20210707_152004-51276a57.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_160k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_160k_coco-stuff164k_20210707_152004.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r101-d8_4xb4-160k_coco-stuff164k-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 164k
-    Metrics:
-      mIoU: 41.28
-      mIoU(ms+flip): 41.66
-  Config: configs/pspnet/pspnet_r101-d8_4xb4-160k_coco-stuff164k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 164k
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_160k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_160k_coco-stuff164k_20210707_152004-4af9621b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_160k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_160k_coco-stuff164k_20210707_152004.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r50-d8_4xb4-320k_coco-stuff164k-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 164k
-    Metrics:
-      mIoU: 40.53
-      mIoU(ms+flip): 40.75
-  Config: configs/pspnet/pspnet_r50-d8_4xb4-320k_coco-stuff164k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 164k
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_320k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_320k_coco-stuff164k_20210707_152004-be9610cc.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_4x4_320k_coco-stuff164k/pspnet_r50-d8_512x512_4x4_320k_coco-stuff164k_20210707_152004.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r101-d8_4xb4-320k_coco-stuff164k-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 164k
-    Metrics:
-      mIoU: 41.95
-      mIoU(ms+flip): 42.42
-  Config: configs/pspnet/pspnet_r101-d8_4xb4-320k_coco-stuff164k-512x512.py
-  Metadata:
-    Training Data: COCO-Stuff 164k
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_320k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_320k_coco-stuff164k_20210707_152004-72220c60.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_4x4_320k_coco-stuff164k/pspnet_r101-d8_512x512_4x4_320k_coco-stuff164k_20210707_152004.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r18-d8_4xb4-80k_loveda-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: LoveDA
-    Metrics:
-      mIoU: 48.62
-      mIoU(ms+flip): 47.57
-  Config: configs/pspnet/pspnet_r18-d8_4xb4-80k_loveda-512x512.py
-  Metadata:
-    Training Data: LoveDA
-    Batch Size: 16
-    Architecture:
-    - R-18-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.45
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_512x512_80k_loveda/pspnet_r18-d8_512x512_80k_loveda_20211105_052100-b97697f1.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_512x512_80k_loveda/pspnet_r18-d8_512x512_80k_loveda_20211105_052100.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r50-d8_4xb4-80k_loveda-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: LoveDA
-    Metrics:
-      mIoU: 50.46
-      mIoU(ms+flip): 50.19
-  Config: configs/pspnet/pspnet_r50-d8_4xb4-80k_loveda-512x512.py
-  Metadata:
-    Training Data: LoveDA
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.14
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_80k_loveda/pspnet_r50-d8_512x512_80k_loveda_20211104_155728-88610f9f.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x512_80k_loveda/pspnet_r50-d8_512x512_80k_loveda_20211104_155728.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r101-d8_4xb4-80k_loveda-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: LoveDA
-    Metrics:
-      mIoU: 51.86
-      mIoU(ms+flip): 51.34
-  Config: configs/pspnet/pspnet_r101-d8_4xb4-80k_loveda-512x512.py
-  Metadata:
-    Training Data: LoveDA
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.61
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_80k_loveda/pspnet_r101-d8_512x512_80k_loveda_20211104_153212-1c06c6a8.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_512x512_80k_loveda/pspnet_r101-d8_512x512_80k_loveda_20211104_153212.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r18-d8_4xb4-80k_potsdam-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Potsdam
-    Metrics:
-      mIoU: 77.09
-      mIoU(ms+flip): 78.3
-  Config: configs/pspnet/pspnet_r18-d8_4xb4-80k_potsdam-512x512.py
-  Metadata:
-    Training Data: Potsdam
-    Batch Size: 16
-    Architecture:
-    - R-18-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_512x512_80k_potsdam/pspnet_r18-d8_4x4_512x512_80k_potsdam_20211220_125612-7cd046e1.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_512x512_80k_potsdam/pspnet_r18-d8_4x4_512x512_80k_potsdam_20211220_125612.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r50-d8_4xb4-80k_potsdam-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Potsdam
-    Metrics:
-      mIoU: 78.12
-      mIoU(ms+flip): 78.98
-  Config: configs/pspnet/pspnet_r50-d8_4xb4-80k_potsdam-512x512.py
-  Metadata:
-    Training Data: Potsdam
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.14
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_512x512_80k_potsdam/pspnet_r50-d8_4x4_512x512_80k_potsdam_20211219_043541-2dd5fe67.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_512x512_80k_potsdam/pspnet_r50-d8_4x4_512x512_80k_potsdam_20211219_043541.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r101-d8_4xb4-80k_potsdam-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Potsdam
-    Metrics:
-      mIoU: 78.62
-      mIoU(ms+flip): 79.47
-  Config: configs/pspnet/pspnet_r101-d8_4xb4-80k_potsdam-512x512.py
-  Metadata:
-    Training Data: Potsdam
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.61
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_4x4_512x512_80k_potsdam/pspnet_r101-d8_4x4_512x512_80k_potsdam_20211220_125612-aed036c4.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_4x4_512x512_80k_potsdam/pspnet_r101-d8_4x4_512x512_80k_potsdam_20211220_125612.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r18-d8_4xb4-80k_vaihingen-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Vaihingen
-    Metrics:
-      mIoU: 71.46
-      mIoU(ms+flip): 73.36
-  Config: configs/pspnet/pspnet_r18-d8_4xb4-80k_vaihingen-512x512.py
-  Metadata:
-    Training Data: Vaihingen
-    Batch Size: 16
-    Architecture:
-    - R-18-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.45
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_512x512_80k_vaihingen/pspnet_r18-d8_4x4_512x512_80k_vaihingen_20211228_160355-52a8a6f6.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_512x512_80k_vaihingen/pspnet_r18-d8_4x4_512x512_80k_vaihingen_20211228_160355.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r50-d8_4xb4-80k_vaihingen-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Vaihingen
-    Metrics:
-      mIoU: 72.36
-      mIoU(ms+flip): 73.75
-  Config: configs/pspnet/pspnet_r50-d8_4xb4-80k_vaihingen-512x512.py
-  Metadata:
-    Training Data: Vaihingen
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.14
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_512x512_80k_vaihingen/pspnet_r50-d8_4x4_512x512_80k_vaihingen_20211228_160355-382f8f5b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_512x512_80k_vaihingen/pspnet_r50-d8_4x4_512x512_80k_vaihingen_20211228_160355.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r101-d8_4xb4-80k_vaihingen-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Vaihingen
-    Metrics:
-      mIoU: 72.61
-      mIoU(ms+flip): 74.18
-  Config: configs/pspnet/pspnet_r101-d8_4xb4-80k_vaihingen-512x512.py
-  Metadata:
-    Training Data: Vaihingen
-    Batch Size: 16
-    Architecture:
-    - R-101-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.61
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_4x4_512x512_80k_vaihingen/pspnet_r101-d8_4x4_512x512_80k_vaihingen_20211231_230806-8eba0a09.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r101-d8_4x4_512x512_80k_vaihingen/pspnet_r101-d8_4x4_512x512_80k_vaihingen_20211231_230806.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r18-d8_4xb4-80k_isaid-896x896
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: iSAID
-    Metrics:
-      mIoU: 60.22
-      mIoU(ms+flip): 61.25
-  Config: configs/pspnet/pspnet_r18-d8_4xb4-80k_isaid-896x896.py
-  Metadata:
-    Training Data: iSAID
-    Batch Size: 16
-    Architecture:
-    - R-18-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 4.52
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_896x896_80k_isaid/pspnet_r18-d8_4x4_896x896_80k_isaid_20220110_180526-e84c0b6a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r18-d8_4x4_896x896_80k_isaid/pspnet_r18-d8_4x4_896x896_80k_isaid_20220110_180526.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
-- Name: pspnet_r50-d8_4xb4-80k_isaid-896x896
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: iSAID
-    Metrics:
-      mIoU: 65.36
-      mIoU(ms+flip): 66.48
-  Config: configs/pspnet/pspnet_r50-d8_4xb4-80k_isaid-896x896.py
-  Metadata:
-    Training Data: iSAID
-    Batch Size: 16
-    Architecture:
-    - R-50-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 16.58
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_896x896_80k_isaid/pspnet_r50-d8_4x4_896x896_80k_isaid_20220110_180629-1f21dc32.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_4x4_896x896_80k_isaid/pspnet_r50-d8_4x4_896x896_80k_isaid_20220110_180629.log.json
-  Paper:
-    Title: Pyramid Scene Parsing Network
-    URL: https://arxiv.org/abs/1612.01105
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/psp_head.py#L63
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index f33d653..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024_dark-zurich-1920x1080.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024_dark-zurich-1920x1080.py
deleted file mode 100644
index 5babaa8..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024_dark-zurich-1920x1080.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_dark-zurich-1920x1080.py'  # noqa
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024_night-driving-1920x1080.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024_night-driving-1920x1080.py
deleted file mode 100644
index a9480c5..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-512x1024_night-driving-1920x1080.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_night-driving-1920x1080.py'  # noqa
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index e05cff6..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb2-40k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 6704cdd..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 3733e69..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
deleted file mode 100644
index 52f86b5..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb2-amp-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './pspnet_r101-d8_4xb2-80k_cityscapes-512x1024.py'
-optim_wrapper = dict(
-    _delete_=True,
-    type='AmpOptimWrapper',
-    optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005),
-    loss_scale=512.)
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 2231049..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb4-160k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-160k_coco-stuff164k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-160k_coco-stuff164k-512x512.py
deleted file mode 100644
index f5390f8..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-160k_coco-stuff164k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb4-160k_coco-stuff164k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-20k_coco-stuff10k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-20k_coco-stuff10k-512x512.py
deleted file mode 100644
index 84a986c..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-20k_coco-stuff10k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb4-20k_coco-stuff10k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index 71897dd..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb4-20k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-320k_coco-stuff164k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-320k_coco-stuff164k-512x512.py
deleted file mode 100644
index ebaea36..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-320k_coco-stuff164k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb4-320k_coco-stuff164k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_coco-stuff10k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_coco-stuff10k-512x512.py
deleted file mode 100644
index 2a55f53..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_coco-stuff10k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb4-40k_coco-stuff10k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-480x480.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-480x480.py
deleted file mode 100644
index 205d00b..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-480x480.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb4-40k_pascal-context-480x480.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-59-480x480.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-59-480x480.py
deleted file mode 100644
index 0d7c176..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_pascal-context-59-480x480.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb4-40k_pascal-context-59-480x480.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index 0599f31..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb4-40k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index f955603..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb4-80k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_coco-stuff164k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_coco-stuff164k-512x512.py
deleted file mode 100644
index 4a34f97..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_coco-stuff164k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb4-80k_coco-stuff164k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_loveda-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_loveda-512x512.py
deleted file mode 100644
index 7076877..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_loveda-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb4-80k_loveda-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-480x480.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-480x480.py
deleted file mode 100644
index 0ac40dc..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-480x480.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb4-80k_pascal-context-480x480.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-59-480x480.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-59-480x480.py
deleted file mode 100644
index 307188c..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_pascal-context-59-480x480.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb4-80k_pascal-context-59-480x480.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_potsdam-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_potsdam-512x512.py
deleted file mode 100644
index 31ed2f2..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_potsdam-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb4-80k_potsdam-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_vaihingen-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_vaihingen-512x512.py
deleted file mode 100644
index ac33ed7..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101-d8_4xb4-80k_vaihingen-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb4-80k_vaihingen-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index d2c0f69..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,4 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='torchvision://resnet101',
-    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024_dark-zurich-1920x1080.py b/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024_dark-zurich-1920x1080.py
deleted file mode 100644
index b181744..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024_dark-zurich-1920x1080.py
+++ /dev/null
@@ -1,4 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-512x1024_dark-zurich-1920x1080.py'  # noqa
-model = dict(
-    pretrained='torchvision://resnet101',
-    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024_night-driving-1920x1080.py b/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024_night-driving-1920x1080.py
deleted file mode 100644
index 6a8994b..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-512x1024_night-driving-1920x1080.py
+++ /dev/null
@@ -1,4 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-512x1024_night-driving-1920x1080.py'  # noqa
-model = dict(
-    pretrained='torchvision://resnet101',
-    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 891bfd5..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r101b-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,4 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(
-    pretrained='torchvision://resnet101',
-    backbone=dict(type='ResNet', depth=101))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index a4b342e..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='open-mmlab://resnet18_v1c',
-    backbone=dict(depth=18),
-    decode_head=dict(
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 0e7f3e9..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(
-    pretrained='open-mmlab://resnet18_v1c',
-    backbone=dict(depth=18),
-    decode_head=dict(
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_isaid-896x896.py b/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_isaid-896x896.py
deleted file mode 100644
index efce7a0..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_isaid-896x896.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb4-80k_isaid-896x896.py'
-model = dict(
-    pretrained='open-mmlab://resnet18_v1c',
-    backbone=dict(depth=18),
-    decode_head=dict(
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_loveda-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_loveda-512x512.py
deleted file mode 100644
index 80e2d20..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_loveda-512x512.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb4-80k_loveda-512x512.py'
-model = dict(
-    pretrained='open-mmlab://resnet18_v1c',
-    backbone=dict(depth=18),
-    decode_head=dict(
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_potsdam-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_potsdam-512x512.py
deleted file mode 100644
index 1ef0585..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_potsdam-512x512.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb4-80k_potsdam-512x512.py'
-model = dict(
-    pretrained='open-mmlab://resnet18_v1c',
-    backbone=dict(depth=18),
-    decode_head=dict(
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_vaihingen-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_vaihingen-512x512.py
deleted file mode 100644
index 51e66d2..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r18-d8_4xb4-80k_vaihingen-512x512.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb4-80k_vaihingen-512x512.py'
-model = dict(
-    pretrained='open-mmlab://resnet18_v1c',
-    backbone=dict(depth=18),
-    decode_head=dict(
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 2e356c5..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='torchvision://resnet18',
-    backbone=dict(type='ResNet', depth=18),
-    decode_head=dict(
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 831354d..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r18b-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(
-    pretrained='torchvision://resnet18',
-    backbone=dict(type='ResNet', depth=18),
-    decode_head=dict(
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d32_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r50-d32_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 5700b5b..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d32_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(dilations=(1, 1, 2, 4), strides=(1, 2, 2, 2)))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d32_rsb_4xb2-adamw-80k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r50-d32_rsb_4xb2-adamw-80k_cityscapes-512x1024.py
deleted file mode 100644
index 1390329..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d32_rsb_4xb2-adamw-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,35 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-checkpoint = 'https://download.openmmlab.com/mmclassification/v0/resnet/resnet50_8xb256-rsb-a1-600e_in1k_20211228-20e21305.pth'  # noqa
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained=None,
-    backbone=dict(
-        type='ResNet',
-        init_cfg=dict(
-            type='Pretrained', prefix='backbone.', checkpoint=checkpoint),
-        dilations=(1, 1, 2, 4),
-        strides=(1, 2, 2, 2)))
-
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(type='AdamW', lr=0.0005, weight_decay=0.05),
-    clip_grad=dict(max_norm=1, norm_type=2))
-# learning policy
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0,
-        end=1000),
-    dict(
-        type='MultiStepLR',
-        begin=1000,
-        end=80000,
-        by_epoch=False,
-        milestones=[60000, 72000],
-    )
-]
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8-rsb_4xb2-adamw-80k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8-rsb_4xb2-adamw-80k_cityscapes-512x1024.py
deleted file mode 100644
index b83a0b4..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8-rsb_4xb2-adamw-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,33 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-checkpoint = 'https://download.openmmlab.com/mmclassification/v0/resnet/resnet50_8xb256-rsb-a1-600e_in1k_20211228-20e21305.pth'  # noqa
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained=None,
-    backbone=dict(
-        type='ResNet',
-        init_cfg=dict(
-            type='Pretrained', prefix='backbone.', checkpoint=checkpoint)))
-
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(type='AdamW', lr=0.0005, weight_decay=0.05),
-    clip_grad=dict(max_norm=1, norm_type=2))
-# learning policy
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0,
-        end=1000),
-    dict(
-        type='MultiStepLR',
-        begin=1000,
-        end=80000,
-        by_epoch=False,
-        milestones=[60000, 72000],
-    )
-]
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index a9dcb52..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_dark-zurich-1920x1080.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_dark-zurich-1920x1080.py
deleted file mode 100644
index 1bf4a13..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_dark-zurich-1920x1080.py
+++ /dev/null
@@ -1,24 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
-
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(1920, 1080), keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-test_dataloader = dict(
-    dataset=dict(
-        type='DarkZurichDataset',
-        data_root='data/dark_zurich/',
-        data_prefix=dict(
-            img_path='rgb_anon/val/night/GOPR0356',
-            seg_map_path='gt/val/night/GOPR0356'),
-        pipeline=test_pipeline))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_night-driving-1920x1080.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_night-driving-1920x1080.py
deleted file mode 100644
index b912589..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024_night-driving-1920x1080.py
+++ /dev/null
@@ -1,25 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
-
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(1920, 1080), keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-test_dataloader = dict(
-    dataset=dict(
-        type='NightDrivingDataset',
-        data_root='data/NighttimeDrivingTest/',
-        data_prefix=dict(
-            img_path='leftImg8bit/test/night',
-            seg_map_path='gtCoarse_daytime_trainvaltest/test/night'),
-        pipeline=test_pipeline))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index 6baa31b..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 6ea27de..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024_dark-zurich-1920x1080.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024_dark-zurich-1920x1080.py
deleted file mode 100644
index 200679f..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024_dark-zurich-1920x1080.py
+++ /dev/null
@@ -1,25 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
-
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(1920, 1080), keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-test_dataloader = dict(
-    dataset=dict(
-        type='DarkZurichDataset',
-        data_root='data/dark_zurich/',
-        data_prefix=dict(
-            img_path='rgb_anon/val/night/GOPR0356',
-            seg_map_path='gt/val/night/GOPR0356'),
-        pipeline=test_pipeline))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024_night-driving-1920x1080.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024_night-driving-1920x1080.py
deleted file mode 100644
index 5173813..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024_night-driving-1920x1080.py
+++ /dev/null
@@ -1,25 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
-
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(1920, 1080), keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-test_dataloader = dict(
-    dataset=dict(
-        type='NightDrivingDataset',
-        data_root='data/NighttimeDrivingTest/',
-        data_prefix=dict(
-            img_path='leftImg8bit/test/night',
-            seg_map_path='gtCoarse_daytime_trainvaltest/test/night'),
-        pipeline=test_pipeline))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index d43d30a..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 3d9164f..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-160k_coco-stuff164k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-160k_coco-stuff164k-512x512.py
deleted file mode 100644
index 6185c2e..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-160k_coco-stuff164k-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py',
-    '../_base_/datasets/coco-stuff164k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=171),
-    auxiliary_head=dict(num_classes=171))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-20k_coco-stuff10k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-20k_coco-stuff10k-512x512.py
deleted file mode 100644
index 8c1ba2d..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-20k_coco-stuff10k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/coco-stuff10k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_20k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=171),
-    auxiliary_head=dict(num_classes=171))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index 0f60819..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_20k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-320k_coco-stuff164k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-320k_coco-stuff164k-512x512.py
deleted file mode 100644
index 2a9ce4c..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-320k_coco-stuff164k-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py',
-    '../_base_/datasets/coco-stuff164k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_320k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=171),
-    auxiliary_head=dict(num_classes=171))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_coco-stuff10k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_coco-stuff10k-512x512.py
deleted file mode 100644
index fae57b0..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_coco-stuff10k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/coco-stuff10k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=171),
-    auxiliary_head=dict(num_classes=171))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_pascal-context-480x480.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_pascal-context-480x480.py
deleted file mode 100644
index 08a2144..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_pascal-context-480x480.py
+++ /dev/null
@@ -1,14 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py',
-    '../_base_/datasets/pascal_context.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (480, 480)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=60),
-    auxiliary_head=dict(num_classes=60),
-    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_pascal-context-59-480x480.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_pascal-context-59-480x480.py
deleted file mode 100644
index b654495..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_pascal-context-59-480x480.py
+++ /dev/null
@@ -1,14 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py',
-    '../_base_/datasets/pascal_context_59.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (480, 480)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=59),
-    auxiliary_head=dict(num_classes=59),
-    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index c4a4611..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index bb12aed..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_coco-stuff164k-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_coco-stuff164k-512x512.py
deleted file mode 100644
index 954a653..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_coco-stuff164k-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py',
-    '../_base_/datasets/coco-stuff164k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=171),
-    auxiliary_head=dict(num_classes=171))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_isaid-896x896.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_isaid-896x896.py
deleted file mode 100644
index 63165b6..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_isaid-896x896.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/isaid.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (896, 896)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=16),
-    auxiliary_head=dict(num_classes=16))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_loveda-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_loveda-512x512.py
deleted file mode 100644
index 920729d..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_loveda-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/loveda.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=7),
-    auxiliary_head=dict(num_classes=7))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_pascal-context-480x480.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_pascal-context-480x480.py
deleted file mode 100644
index a7d8247..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_pascal-context-480x480.py
+++ /dev/null
@@ -1,14 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py',
-    '../_base_/datasets/pascal_context.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (480, 480)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=60),
-    auxiliary_head=dict(num_classes=60),
-    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_pascal-context-59-480x480.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_pascal-context-59-480x480.py
deleted file mode 100644
index b7abc1b..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_pascal-context-59-480x480.py
+++ /dev/null
@@ -1,14 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py',
-    '../_base_/datasets/pascal_context_59.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (480, 480)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=59),
-    auxiliary_head=dict(num_classes=59),
-    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_potsdam-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_potsdam-512x512.py
deleted file mode 100644
index afb3977..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_potsdam-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/potsdam.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=6),
-    auxiliary_head=dict(num_classes=6))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_vaihingen-512x512.py b/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_vaihingen-512x512.py
deleted file mode 100644
index 35322d2..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50-d8_4xb4-80k_vaihingen-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/vaihingen.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=6),
-    auxiliary_head=dict(num_classes=6))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50b-d32_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r50b-d32_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 64e5509..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50b-d32_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained='torchvision://resnet50',
-    backbone=dict(type='ResNet', dilations=(1, 1, 2, 4), strides=(1, 2, 2, 2)))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 7dd64b3..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='torchvision://resnet50', backbone=dict(type='ResNet'))
diff --git a/mmsegmentation/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 3875c09..0000000
--- a/mmsegmentation/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_4xb2-80k_cityscapes-769x769.py'
-model = dict(pretrained='torchvision://resnet50', backbone=dict(type='ResNet'))
diff --git a/mmsegmentation/configs/resnest/README.md b/mmsegmentation/configs/resnest/README.md
deleted file mode 100644
index 304791a..0000000
--- a/mmsegmentation/configs/resnest/README.md
+++ /dev/null
@@ -1,54 +0,0 @@
-# ResNeSt
-
-> [ResNeSt: Split-Attention Networks](https://arxiv.org/abs/2004.08955)
-
-## Introduction
-
-<!-- [BACKBONE] -->
-
-<a href="https://github.com/zhanghang1989/ResNeSt">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/resnest.py#L271">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-It is well known that featuremap attention and multi-path representation are important for visual recognition. In this paper, we present a modularized architecture, which applies the channel-wise attention on different network branches to leverage their success in capturing cross-feature interactions and learning diverse representations. Our design results in a simple and unified computation block, which can be parameterized using only a few variables. Our model, named ResNeSt, outperforms EfficientNet in accuracy and latency trade-off on image classification. In addition, ResNeSt has achieved superior transfer learning results on several public benchmarks serving as the backbone, and has been adopted by the winning entries of COCO-LVIS challenge. The source code for complete system and pretrained models are publicly available.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142902526-3cf33345-7e40-47a6-985e-4381857e21df.png" width="60%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                         | download                                                                                                                                                                                                                                                                                                                                                                               |
-| ---------- | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| FCN        | S-101-D8 | 512x1024  |   80000 |     11.4 | 2.39           | V100   | 77.56 | 78.98         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/resnest/resnest_s101-d8_fcn_4xb2-80k_cityscapes-512x1024.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/fcn_s101-d8_512x1024_80k_cityscapes/fcn_s101-d8_512x1024_80k_cityscapes_20200807_140631-f8d155b3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/fcn_s101-d8_512x1024_80k_cityscapes/fcn_s101-d8_512x1024_80k_cityscapes-20200807_140631.log.json)                                         |
-| PSPNet     | S-101-D8 | 512x1024  |   80000 |     11.8 | 2.52           | V100   | 78.57 | 79.19         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/resnest/resnest_s101-d8_pspnet_4xb2-80k_cityscapes512x1024.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/pspnet_s101-d8_512x1024_80k_cityscapes/pspnet_s101-d8_512x1024_80k_cityscapes_20200807_140631-c75f3b99.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/pspnet_s101-d8_512x1024_80k_cityscapes/pspnet_s101-d8_512x1024_80k_cityscapes-20200807_140631.log.json)                             |
-| DeepLabV3  | S-101-D8 | 512x1024  |   80000 |     11.9 | 1.88           | V100   | 79.67 | 80.51         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/resnest/resnest_s101-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py)     | [model](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3_s101-d8_512x1024_80k_cityscapes/deeplabv3_s101-d8_512x1024_80k_cityscapes_20200807_144429-b73c4270.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3_s101-d8_512x1024_80k_cityscapes/deeplabv3_s101-d8_512x1024_80k_cityscapes-20200807_144429.log.json)                 |
-| DeepLabV3+ | S-101-D8 | 512x1024  |   80000 |     13.2 | 2.36           | V100   | 79.62 | 80.27         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/resnest/resnest_s101-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3plus_s101-d8_512x1024_80k_cityscapes/deeplabv3plus_s101-d8_512x1024_80k_cityscapes_20200807_144429-1239eb43.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3plus_s101-d8_512x1024_80k_cityscapes/deeplabv3plus_s101-d8_512x1024_80k_cityscapes-20200807_144429.log.json) |
-
-### ADE20K
-
-| Method     | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                     | download                                                                                                                                                                                                                                                                                                                                                               |
-| ---------- | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| FCN        | S-101-D8 | 512x512   |  160000 |     14.2 | 12.86          | V100   | 45.62 | 46.16         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/resnest/resnest_s101-d8_fcn_4xb4-160k_ade20k-512x512.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/fcn_s101-d8_512x512_160k_ade20k/fcn_s101-d8_512x512_160k_ade20k_20200807_145416-d3160329.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/fcn_s101-d8_512x512_160k_ade20k/fcn_s101-d8_512x512_160k_ade20k-20200807_145416.log.json)                                         |
-| PSPNet     | S-101-D8 | 512x512   |  160000 |     14.2 | 13.02          | V100   | 45.44 | 46.28         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/resnest/resnest_s101-d8_pspnet_4xb4-160k_ade20k-512x512.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/pspnet_s101-d8_512x512_160k_ade20k/pspnet_s101-d8_512x512_160k_ade20k_20200807_145416-a6daa92a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/pspnet_s101-d8_512x512_160k_ade20k/pspnet_s101-d8_512x512_160k_ade20k-20200807_145416.log.json)                             |
-| DeepLabV3  | S-101-D8 | 512x512   |  160000 |     14.6 | 9.28           | V100   | 45.71 | 46.59         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/resnest/resnest_s101-d8_deeplabv3_4xb4-160k_ade20k-512x512.py)     | [model](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3_s101-d8_512x512_160k_ade20k/deeplabv3_s101-d8_512x512_160k_ade20k_20200807_144503-17ecabe5.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3_s101-d8_512x512_160k_ade20k/deeplabv3_s101-d8_512x512_160k_ade20k-20200807_144503.log.json)                 |
-| DeepLabV3+ | S-101-D8 | 512x512   |  160000 |     16.2 | 11.96          | V100   | 46.47 | 47.27         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/resnest/resnest_s101-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3plus_s101-d8_512x512_160k_ade20k/deeplabv3plus_s101-d8_512x512_160k_ade20k_20200807_144503-27b26226.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3plus_s101-d8_512x512_160k_ade20k/deeplabv3plus_s101-d8_512x512_160k_ade20k-20200807_144503.log.json) |
-
-## Citation
-
-```bibtex
-@article{zhang2020resnest,
-title={ResNeSt: Split-Attention Networks},
-author={Zhang, Hang and Wu, Chongruo and Zhang, Zhongyue and Zhu, Yi and Zhang, Zhi and Lin, Haibin and Sun, Yue and He, Tong and Muller, Jonas and Manmatha, R. and Li, Mu and Smola, Alexander},
-journal={arXiv preprint arXiv:2004.08955},
-year={2020}
-}
-```
diff --git a/mmsegmentation/configs/resnest/metafile.yaml b/mmsegmentation/configs/resnest/metafile.yaml
deleted file mode 100644
index 0b8d41e..0000000
--- a/mmsegmentation/configs/resnest/metafile.yaml
+++ /dev/null
@@ -1,193 +0,0 @@
-Models:
-- Name: resnest_s101-d8_fcn_4xb2-80k_cityscapes-512x1024
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.56
-      mIoU(ms+flip): 78.98
-  Config: configs/resnest/resnest_s101-d8_fcn_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - S-101-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 11.4
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/fcn_s101-d8_512x1024_80k_cityscapes/fcn_s101-d8_512x1024_80k_cityscapes_20200807_140631-f8d155b3.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/fcn_s101-d8_512x1024_80k_cityscapes/fcn_s101-d8_512x1024_80k_cityscapes-20200807_140631.log.json
-  Paper:
-    Title: 'ResNeSt: Split-Attention Networks'
-    URL: https://arxiv.org/abs/2004.08955
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/resnest.py#L271
-  Framework: PyTorch
-- Name: resnest_s101-d8_pspnet_4xb2-80k_cityscapes512x1024
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.57
-      mIoU(ms+flip): 79.19
-  Config: configs/resnest/resnest_s101-d8_pspnet_4xb2-80k_cityscapes512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - S-101-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 11.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/pspnet_s101-d8_512x1024_80k_cityscapes/pspnet_s101-d8_512x1024_80k_cityscapes_20200807_140631-c75f3b99.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/pspnet_s101-d8_512x1024_80k_cityscapes/pspnet_s101-d8_512x1024_80k_cityscapes-20200807_140631.log.json
-  Paper:
-    Title: 'ResNeSt: Split-Attention Networks'
-    URL: https://arxiv.org/abs/2004.08955
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/resnest.py#L271
-  Framework: PyTorch
-- Name: resnest_s101-d8_deeplabv3_4xb2-80k_cityscapes-512x1024
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.67
-      mIoU(ms+flip): 80.51
-  Config: configs/resnest/resnest_s101-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - S-101-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 11.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3_s101-d8_512x1024_80k_cityscapes/deeplabv3_s101-d8_512x1024_80k_cityscapes_20200807_144429-b73c4270.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3_s101-d8_512x1024_80k_cityscapes/deeplabv3_s101-d8_512x1024_80k_cityscapes-20200807_144429.log.json
-  Paper:
-    Title: 'ResNeSt: Split-Attention Networks'
-    URL: https://arxiv.org/abs/2004.08955
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/resnest.py#L271
-  Framework: PyTorch
-- Name: resnest_s101-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.62
-      mIoU(ms+flip): 80.27
-  Config: configs/resnest/resnest_s101-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - S-101-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 13.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3plus_s101-d8_512x1024_80k_cityscapes/deeplabv3plus_s101-d8_512x1024_80k_cityscapes_20200807_144429-1239eb43.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3plus_s101-d8_512x1024_80k_cityscapes/deeplabv3plus_s101-d8_512x1024_80k_cityscapes-20200807_144429.log.json
-  Paper:
-    Title: 'ResNeSt: Split-Attention Networks'
-    URL: https://arxiv.org/abs/2004.08955
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/resnest.py#L271
-  Framework: PyTorch
-- Name: resnest_s101-d8_fcn_4xb4-160k_ade20k-512x512
-  In Collection: FCN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 45.62
-      mIoU(ms+flip): 46.16
-  Config: configs/resnest/resnest_s101-d8_fcn_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - S-101-D8
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 14.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/fcn_s101-d8_512x512_160k_ade20k/fcn_s101-d8_512x512_160k_ade20k_20200807_145416-d3160329.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/fcn_s101-d8_512x512_160k_ade20k/fcn_s101-d8_512x512_160k_ade20k-20200807_145416.log.json
-  Paper:
-    Title: 'ResNeSt: Split-Attention Networks'
-    URL: https://arxiv.org/abs/2004.08955
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/resnest.py#L271
-  Framework: PyTorch
-- Name: resnest_s101-d8_pspnet_4xb4-160k_ade20k-512x512
-  In Collection: PSPNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 45.44
-      mIoU(ms+flip): 46.28
-  Config: configs/resnest/resnest_s101-d8_pspnet_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - S-101-D8
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 14.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/pspnet_s101-d8_512x512_160k_ade20k/pspnet_s101-d8_512x512_160k_ade20k_20200807_145416-a6daa92a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/pspnet_s101-d8_512x512_160k_ade20k/pspnet_s101-d8_512x512_160k_ade20k-20200807_145416.log.json
-  Paper:
-    Title: 'ResNeSt: Split-Attention Networks'
-    URL: https://arxiv.org/abs/2004.08955
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/resnest.py#L271
-  Framework: PyTorch
-- Name: resnest_s101-d8_deeplabv3_4xb4-160k_ade20k-512x512
-  In Collection: DeepLabV3
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 45.71
-      mIoU(ms+flip): 46.59
-  Config: configs/resnest/resnest_s101-d8_deeplabv3_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - S-101-D8
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 14.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3_s101-d8_512x512_160k_ade20k/deeplabv3_s101-d8_512x512_160k_ade20k_20200807_144503-17ecabe5.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3_s101-d8_512x512_160k_ade20k/deeplabv3_s101-d8_512x512_160k_ade20k-20200807_144503.log.json
-  Paper:
-    Title: 'ResNeSt: Split-Attention Networks'
-    URL: https://arxiv.org/abs/2004.08955
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/resnest.py#L271
-  Framework: PyTorch
-- Name: resnest_s101-d8_deeplabv3plus_4xb4-160k_ade20k-512x512
-  In Collection: DeepLabV3+
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 46.47
-      mIoU(ms+flip): 47.27
-  Config: configs/resnest/resnest_s101-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - S-101-D8
-    - DeepLabV3+
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 16.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3plus_s101-d8_512x512_160k_ade20k/deeplabv3plus_s101-d8_512x512_160k_ade20k_20200807_144503-27b26226.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/resnest/deeplabv3plus_s101-d8_512x512_160k_ade20k/deeplabv3plus_s101-d8_512x512_160k_ade20k-20200807_144503.log.json
-  Paper:
-    Title: 'ResNeSt: Split-Attention Networks'
-    URL: https://arxiv.org/abs/2004.08955
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/resnest.py#L271
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 7ece894..0000000
--- a/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = '../deeplabv3/deeplabv3_r101-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='open-mmlab://resnest101',
-    backbone=dict(
-        type='ResNeSt',
-        stem_channels=128,
-        radix=2,
-        reduction_factor=4,
-        avg_down_stride=True))
diff --git a/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index c285230..0000000
--- a/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = '../deeplabv3/deeplabv3_r101-d8_4xb4-160k_ade20k-512x512.py'
-model = dict(
-    pretrained='open-mmlab://resnest101',
-    backbone=dict(
-        type='ResNeSt',
-        stem_channels=128,
-        radix=2,
-        reduction_factor=4,
-        avg_down_stride=True))
diff --git a/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 5c43a95..0000000
--- a/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3plus_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = '../deeplabv3plus/deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024.py'  # noqa
-model = dict(
-    pretrained='open-mmlab://resnest101',
-    backbone=dict(
-        type='ResNeSt',
-        stem_channels=128,
-        radix=2,
-        reduction_factor=4,
-        avg_down_stride=True))
diff --git a/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index ce39d37..0000000
--- a/mmsegmentation/configs/resnest/resnest_s101-d8_deeplabv3plus_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = '../deeplabv3plus/deeplabv3plus_r101-d8_4xb4-160k_ade20k-512x512.py'
-model = dict(
-    pretrained='open-mmlab://resnest101',
-    backbone=dict(
-        type='ResNeSt',
-        stem_channels=128,
-        radix=2,
-        reduction_factor=4,
-        avg_down_stride=True))
diff --git a/mmsegmentation/configs/resnest/resnest_s101-d8_fcn_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/resnest/resnest_s101-d8_fcn_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index fc333e4..0000000
--- a/mmsegmentation/configs/resnest/resnest_s101-d8_fcn_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = '../fcn/fcn_r101-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='open-mmlab://resnest101',
-    backbone=dict(
-        type='ResNeSt',
-        stem_channels=128,
-        radix=2,
-        reduction_factor=4,
-        avg_down_stride=True))
diff --git a/mmsegmentation/configs/resnest/resnest_s101-d8_fcn_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/resnest/resnest_s101-d8_fcn_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index af12733..0000000
--- a/mmsegmentation/configs/resnest/resnest_s101-d8_fcn_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = '../fcn/fcn_r101-d8_4xb4-160k_ade20k-512x512.py'
-model = dict(
-    pretrained='open-mmlab://resnest101',
-    backbone=dict(
-        type='ResNeSt',
-        stem_channels=128,
-        radix=2,
-        reduction_factor=4,
-        avg_down_stride=True))
diff --git a/mmsegmentation/configs/resnest/resnest_s101-d8_pspnet_4xb2-80k_cityscapes512x1024.py b/mmsegmentation/configs/resnest/resnest_s101-d8_pspnet_4xb2-80k_cityscapes512x1024.py
deleted file mode 100644
index 3aab524..0000000
--- a/mmsegmentation/configs/resnest/resnest_s101-d8_pspnet_4xb2-80k_cityscapes512x1024.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = '../pspnet/pspnet_r101-d8_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='open-mmlab://resnest101',
-    backbone=dict(
-        type='ResNeSt',
-        stem_channels=128,
-        radix=2,
-        reduction_factor=4,
-        avg_down_stride=True))
diff --git a/mmsegmentation/configs/resnest/resnest_s101-d8_pspnet_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/resnest/resnest_s101-d8_pspnet_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 66e6639..0000000
--- a/mmsegmentation/configs/resnest/resnest_s101-d8_pspnet_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = '../pspnet/pspnet_r101-d8_4xb4-160k_ade20k-512x512.py'
-model = dict(
-    pretrained='open-mmlab://resnest101',
-    backbone=dict(
-        type='ResNeSt',
-        stem_channels=128,
-        radix=2,
-        reduction_factor=4,
-        avg_down_stride=True))
diff --git a/mmsegmentation/configs/san/README.md b/mmsegmentation/configs/san/README.md
deleted file mode 100644
index d9940eb..0000000
--- a/mmsegmentation/configs/san/README.md
+++ /dev/null
@@ -1,47 +0,0 @@
-# SAN
-
-> [Side Adapter Network for Open-Vocabulary Semantic Segmentation](https://arxiv.org/abs/2302.12242)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/MendelXu/SAN">Official Repo</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-This paper presents a new framework for open-vocabulary semantic segmentation with the pre-trained vision-language model, named Side Adapter Network (SAN). Our approach models the semantic segmentation task as a region recognition problem. A side network is attached to a frozen CLIP model with two branches: one for predicting mask proposals, and the other for predicting attention bias which is applied in the CLIP model to recognize the class of masks. This decoupled design has the benefit CLIP in recognizing the class of mask proposals. Since the attached side network can reuse CLIP features, it can be very light. In addition, the entire network can be trained end-to-end, allowing the side network to be adapted to the frozen CLIP model, which makes the predicted mask proposals CLIP-aware. Our approach is fast, accurate, and only adds a few additional trainable parameters. We evaluate our approach on multiple semantic segmentation benchmarks. Our method significantly outperforms other counterparts, with up to 18 times fewer trainable parameters and 19 times faster inference speed. We hope our approach will serve as a solid baseline and help ease future research in open-vocabulary semantic segmentation.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://github.com/MendelXu/SAN/blob/main/resources/arch.png" width="800"/>
-</div>
-
-## Results and models
-
-### COCO-Stuff164k
-
-| Method | Backbone | Pretrained   | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                   | download                                                                                                                                                                                    |
-| ------ | -------- | ------------ | --------- | ------- | -------- | -------------- | ------ | ----- | ------------- | -------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| SAN    | ViT-B_16 | CLIP_ViT-B16 | 640x640   | 60000   | 12.61    | -              | V100   | 41.93 | 41.77         | https://github.com/open-mmlab/mmsegmentation/blob/main/configs/san/san-vit-b16_coco-stuff164k-640x640.py | [model](https://download.openmmlab.com/mmsegmentation/v0.5/san/san-vit-b16_20230906-fd0a7684.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/san/san-vit-b16_20230906.log) |
-| SAN    | ViT-L_14 | CLIP_ViT-L14 | 640x640   | 60000   | 22.84    | -              | V100   | 45.78 | 43.99         | https://github.com/open-mmlab/mmsegmentation/blob/main/configs/san/san-vit-l14_coco-stuff164k-640x640.py | [model](https://download.openmmlab.com/mmsegmentation/v0.5/san/san-vit-l14_20230907-a11e098f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/san/san-vit-l14_20230907.log) |
-
-## Notes
-
-git push
-The pretrained weights in config files are converted from open_clip models using tools/model_converters/clip2mmseg.py.
-
-## Citation
-
-```bibtex
-@inproceedings{xu2023side,
-  title={Side adapter network for open-vocabulary semantic segmentation},
-  author={Xu, Mengde and Zhang, Zheng and Wei, Fangyun and Hu, Han and Bai, Xiang},
-  booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
-  pages={2945--2954},
-  year={2023}
-}
-```
diff --git a/mmsegmentation/configs/san/metafile.yaml b/mmsegmentation/configs/san/metafile.yaml
deleted file mode 100644
index 117d088..0000000
--- a/mmsegmentation/configs/san/metafile.yaml
+++ /dev/null
@@ -1,61 +0,0 @@
-Collections:
-- Name: SAN
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - COCO-Stuff 164k
-  Paper:
-    Title: 'Side Adapter Network for Open-Vocabulary Semantic Segmentation'
-    URL: https://arxiv.org/abs/2302.12242
-  README: configs/san/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: san-vit-b16_coco-stuff164k-640x640
-  In Collection: SAN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 164k
-    Metrics:
-      mIoU: 41.93
-      mIoU(ms+flip): 41.77
-  Config: configs/san/san-vit-b16_coco-stuff164k-640x640.py
-  Metadata:
-    Training Data: COCO-Stuff 164k
-    Batch Size: 16
-    Architecture:
-    - SAN
-    - ViT
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 12.61
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/san/san-vit-b16_20230906-fd0a7684.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/san/san-vit-b16_20230906.log
-  Paper:
-    Title: 'Side Adapter Network for Open-Vocabulary Semantic Segmentation'
-    URL: https://arxiv.org/abs/2302.12242
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/mmseg/models/decode_heads/san_head.py#L470
-  Framework: PyTorch
-- Name: san-vit-l14_coco-stuff164k-640x640
-  In Collection: SAN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: COCO-Stuff 164k
-    Metrics:
-      mIoU: 45.78
-      mIoU(ms+flip): 43.99
-  Config: configs/san/san-vit-l14_coco-stuff164k-640x640.py
-  Metadata:
-    Training Data: COCO-Stuff 164k
-    Batch Size: 16
-    Architecture:
-    - SAN
-    - ViT
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 12.61
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/san/san-vit-l14_20230907-a11e098f.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/san/san-vit-l14_20230907.log
-  Paper:
-    Title: 'Side Adapter Network for Open-Vocabulary Semantic Segmentation'
-    URL: https://arxiv.org/abs/2302.12242
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/mmseg/models/decode_heads/san_head.py#L470
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/san/san-vit-b16_coco-stuff164k-640x640.py b/mmsegmentation/configs/san/san-vit-b16_coco-stuff164k-640x640.py
deleted file mode 100644
index 4059248..0000000
--- a/mmsegmentation/configs/san/san-vit-b16_coco-stuff164k-640x640.py
+++ /dev/null
@@ -1,82 +0,0 @@
-_base_ = [
-    '../_base_/models/san_vit-b16.py', '../_base_/datasets/coco-stuff164k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (640, 640)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(
-        type='RandomChoiceResize',
-        scales=[int(640 * x * 0.1) for x in range(5, 16)],
-        resize_type='ResizeShortestEdge',
-        max_size=2560),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=1.0),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PackSegInputs')
-]
-
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='ResizeShortestEdge', scale=crop_size, max_size=2560),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-
-# By default, models are trained on 4 GPUs with 8 images per GPU
-train_dataloader = dict(batch_size=8, dataset=dict(pipeline=train_pipeline))
-val_dataloader = dict(batch_size=1, dataset=dict(pipeline=test_pipeline))
-test_dataloader = val_dataloader
-
-pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/san/clip_vit-base-patch16-224_3rdparty-d08f8887.pth'  # noqa
-data_preprocessor = dict(
-    mean=[122.7709, 116.7460, 104.0937],
-    std=[68.5005, 66.6322, 70.3232],
-    size_divisor=640,
-    test_cfg=dict(size_divisor=32))
-model = dict(
-    pretrained=pretrained,
-    text_encoder=dict(dataset_name='coco-stuff164k'),
-    decode_head=dict(num_classes=171))
-
-# training schedule for 60k
-train_cfg = dict(
-    type='IterBasedTrainLoop',
-    max_iters=60000,
-    val_interval=500,
-    val_begin=55000)
-default_hooks = dict(
-    checkpoint=dict(
-        type='CheckpointHook',
-        by_epoch=False,
-        interval=10000,
-        save_best='mIoU'))
-
-# AdamW optimizer, no weight decay for position embedding & layer norm
-# in backbone
-optim_wrapper = dict(
-    _delete_=True,
-    type='AmpOptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.0001),
-    paramwise_cfg=dict(
-        custom_keys={
-            'img_encoder': dict(lr_mult=0.1, decay_mult=1.0),
-            'pos_embed': dict(decay_mult=0.),
-            'cls_token': dict(decay_mult=0.),
-            'norm': dict(decay_mult=0.)
-        }),
-    loss_scale='dynamic',
-    clip_grad=dict(max_norm=0.01, norm_type=2))
-
-param_scheduler = [
-    dict(
-        type='PolyLR',
-        eta_min=0.0,
-        power=1.0,
-        begin=0,
-        end=60000,
-        by_epoch=False,
-    )
-]
diff --git a/mmsegmentation/configs/san/san-vit-b16_pascal_context-640x640.py b/mmsegmentation/configs/san/san-vit-b16_pascal_context-640x640.py
deleted file mode 100644
index b164fe4..0000000
--- a/mmsegmentation/configs/san/san-vit-b16_pascal_context-640x640.py
+++ /dev/null
@@ -1,56 +0,0 @@
-_base_ = [
-    '../_base_/models/san_vit-b16.py',
-    '../_base_/datasets/pascal_context_59.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (640, 640)
-
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='ResizeShortestEdge', scale=crop_size, max_size=2560),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-
-# By default, models are trained on 8 GPUs with 2 images per GPU
-train_dataloader = dict(batch_size=2)
-val_dataloader = dict(batch_size=1, dataset=dict(pipeline=test_pipeline))
-test_dataloader = val_dataloader
-
-data_preprocessor = dict(
-    mean=[122.7709, 116.7460, 104.0937],
-    std=[68.5005, 66.6322, 70.3232],
-    size_divisor=640,
-    test_cfg=dict(size_divisor=32))
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained='pretrain/vit_base_patch16_224.pth',
-    text_encoder=dict(dataset_name='pascal_context'),
-    decode_head=dict(num_classes=59))
-
-# AdamW optimizer, no weight decay for position embedding & layer norm
-# in backbone
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
-    paramwise_cfg=dict(
-        custom_keys={
-            'pos_embed': dict(decay_mult=0.),
-            'cls_token': dict(decay_mult=0.),
-            'norm': dict(decay_mult=0.)
-        }))
-
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        eta_min=0.0,
-        power=1.0,
-        begin=1500,
-        end=160000,
-        by_epoch=False,
-    )
-]
diff --git a/mmsegmentation/configs/san/san-vit-b16_voc12aug-640x640.py b/mmsegmentation/configs/san/san-vit-b16_voc12aug-640x640.py
deleted file mode 100644
index 62e9b26..0000000
--- a/mmsegmentation/configs/san/san-vit-b16_voc12aug-640x640.py
+++ /dev/null
@@ -1,65 +0,0 @@
-_base_ = [
-    '../_base_/models/san_vit-b16.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (640, 640)
-
-metainfo = dict(
-    classes=('aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car',
-             'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike',
-             'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor'),
-    palette=[[128, 0, 0], [0, 128, 0], [128, 128, 0], [0, 0, 128],
-             [128, 0, 128], [0, 128, 128], [128, 128, 128], [64, 0, 0],
-             [192, 0, 0], [64, 128, 0], [192, 128, 0], [64, 0, 128],
-             [192, 0, 128], [64, 128, 128], [192, 128, 128], [0, 64, 0],
-             [128, 64, 0], [0, 192, 0], [128, 192, 0], [0, 64, 128]])
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='ResizeShortestEdge', scale=crop_size, max_size=2560),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-# By default, models are trained on 8 GPUs with 2 images per GPU
-train_dataloader = dict(batch_size=2)
-val_dataloader = dict(
-    batch_size=1, dataset=dict(metainfo=metainfo, pipeline=test_pipeline))
-test_dataloader = val_dataloader
-
-data_preprocessor = dict(
-    mean=[122.7709, 116.7460, 104.0937],
-    std=[68.5005, 66.6322, 70.3232],
-    size_divisor=640,
-    test_cfg=dict(size_divisor=32))
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained='pretrain/vit_base_patch16_224.pth',
-    text_encoder=dict(dataset_name='voc'),
-    decode_head=dict(num_classes=20))
-
-# AdamW optimizer, no weight decay for position embedding & layer norm
-# in backbone
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
-    paramwise_cfg=dict(
-        custom_keys={
-            'pos_embed': dict(decay_mult=0.),
-            'cls_token': dict(decay_mult=0.),
-            'norm': dict(decay_mult=0.)
-        }))
-
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        eta_min=0.0,
-        power=1.0,
-        begin=1500,
-        end=160000,
-        by_epoch=False,
-    )
-]
diff --git a/mmsegmentation/configs/san/san-vit-l14_coco-stuff164k-640x640.py b/mmsegmentation/configs/san/san-vit-l14_coco-stuff164k-640x640.py
deleted file mode 100644
index c34328d..0000000
--- a/mmsegmentation/configs/san/san-vit-l14_coco-stuff164k-640x640.py
+++ /dev/null
@@ -1,36 +0,0 @@
-_base_ = ['./san-vit-b16_coco-stuff164k-640x640.py']
-
-pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/san/clip_vit-large-patch14-336_3rdparty-0b5df9cb.pth'  # noqa
-model = dict(
-    type='MultimodalEncoderDecoder',
-    pretrained=pretrained,
-    encoder_resolution=0.7,
-    image_encoder=dict(
-        type='VisionTransformer',
-        img_size=(336, 336),
-        patch_size=14,
-        patch_pad=0,
-        embed_dims=1024,
-        num_layers=18,
-        num_heads=16,
-        out_indices=(5, 11, 17),
-    ),
-    text_encoder=dict(
-        type='CLIPTextEncoder',
-        embed_dims=768,
-        num_layers=12,
-        num_heads=12,
-        output_dims=768,
-    ),
-    decode_head=dict(
-        type='SideAdapterCLIPHead',
-        san_cfg=dict(clip_channels=1024, cfg_decoder=dict(num_heads=16)),
-        maskgen_cfg=dict(
-            num_layers=6,
-            embed_dims=1024,
-            num_heads=16,
-            out_dims=768,
-        )))
-
-# By default, models are trained on 8 GPUs with 4 images per GPU
-train_dataloader = dict(batch_size=4)
diff --git a/mmsegmentation/configs/san/san-vit-l14_pascal_context-640x640.py b/mmsegmentation/configs/san/san-vit-l14_pascal_context-640x640.py
deleted file mode 100644
index a9545fa..0000000
--- a/mmsegmentation/configs/san/san-vit-l14_pascal_context-640x640.py
+++ /dev/null
@@ -1,32 +0,0 @@
-_base_ = ['./san-vit-b16_pascal_context-640x640.py']
-
-model = dict(
-    type='MultimodalEncoderDecoder',
-    pretrained='pretrain/jx_vit_base_p16_224-80ecf9dd.pth',
-    encoder_resolution=0.7,
-    image_encoder=dict(
-        type='VisionTransformer',
-        img_size=(336, 336),
-        patch_size=14,
-        patch_pad=0,
-        embed_dims=1024,
-        num_layers=18,
-        num_heads=16,
-        out_indices=(5, 11, 17),
-    ),
-    text_encoder=dict(
-        type='CLIPTextEncoder',
-        embed_dims=768,
-        num_layers=12,
-        num_heads=12,
-        output_dims=768,
-    ),
-    decode_head=dict(
-        type='SideAdapterCLIPHead',
-        san_cfg=dict(clip_channels=1024, cfg_decoder=dict(num_heads=16)),
-        maskgen_cfg=dict(
-            num_layers=6,
-            embed_dims=1024,
-            num_heads=16,
-            out_dims=768,
-        )))
diff --git a/mmsegmentation/configs/san/san-vit-l14_voc12aug-640x640.py b/mmsegmentation/configs/san/san-vit-l14_voc12aug-640x640.py
deleted file mode 100644
index 2f37715..0000000
--- a/mmsegmentation/configs/san/san-vit-l14_voc12aug-640x640.py
+++ /dev/null
@@ -1,32 +0,0 @@
-_base_ = ['./san-vit-b16_voc12aug-640x640.py']
-
-model = dict(
-    type='MultimodalEncoderDecoder',
-    pretrained='pretrain/jx_vit_base_p16_224-80ecf9dd.pth',
-    encoder_resolution=0.7,
-    image_encoder=dict(
-        type='VisionTransformer',
-        img_size=(336, 336),
-        patch_size=14,
-        patch_pad=0,
-        embed_dims=1024,
-        num_layers=18,
-        num_heads=16,
-        out_indices=(5, 11, 17),
-    ),
-    text_encoder=dict(
-        type='CLIPTextEncoder',
-        embed_dims=768,
-        num_layers=12,
-        num_heads=12,
-        output_dims=768,
-    ),
-    decode_head=dict(
-        type='SideAdapterCLIPHead',
-        san_cfg=dict(clip_channels=1024, cfg_decoder=dict(num_heads=16)),
-        maskgen_cfg=dict(
-            num_layers=6,
-            embed_dims=1024,
-            num_heads=16,
-            out_dims=768,
-        )))
diff --git a/mmsegmentation/configs/segformer/README.md b/mmsegmentation/configs/segformer/README.md
deleted file mode 100644
index f8999b0..0000000
--- a/mmsegmentation/configs/segformer/README.md
+++ /dev/null
@@ -1,101 +0,0 @@
-# SegFormer
-
-> [SegFormer: Simple and Efficient Design for Semantic Segmentation with Transformers](https://arxiv.org/abs/2105.15203)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/NVlabs/SegFormer">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-We present SegFormer, a simple, efficient yet powerful semantic segmentation framework which unifies Transformers with lightweight multilayer perception (MLP) decoders. SegFormer has two appealing features: 1) SegFormer comprises a novel hierarchically structured Transformer encoder which outputs multiscale features. It does not need positional encoding, thereby avoiding the interpolation of positional codes which leads to decreased performance when the testing resolution differs from training. 2) SegFormer avoids complex decoders. The proposed MLP decoder aggregates information from different layers, and thus combining both local attention and global attention to render powerful representations. We show that this simple and lightweight design is the key to efficient segmentation on Transformers. We scale our approach up to obtain a series of models from SegFormer-B0 to SegFormer-B5, reaching significantly better performance and efficiency than previous counterparts. For example, SegFormer-B4 achieves 50.3% mIoU on ADE20K with 64M parameters, being 5x smaller and 2.2% better than the previous best method. Our best model, SegFormer-B5, achieves 84.0% mIoU on Cityscapes validation set and shows excellent zero-shot robustness on Cityscapes-C. Code will be released at: [this http URL](https://github.com/NVlabs/SegFormer).
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142902600-e188073e-5744-4ba9-8dbf-9316e55c74aa.png" width="70%"/>
-</div>
-
-## Usage
-
-To use other repositories' pre-trained models, it is necessary to convert keys.
-
-We provide a script [`mit2mmseg.py`](../../tools/model_converters/mit2mmseg.py) in the tools directory to convert the key of models from [the official repo](https://github.com/NVlabs/SegFormer) to MMSegmentation style.
-
-```shell
-python tools/model_converters/mit2mmseg.py ${PRETRAIN_PATH} ${STORE_PATH}
-```
-
-This script convert model from `PRETRAIN_PATH` and store the converted model in `STORE_PATH`.
-
-## Results and models
-
-### ADE20K
-
-| Method    | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device   |  mIoU | mIoU(ms+flip) | config                                                                                                                          | download                                                                                                                                                                                                                                                                                                                                               |
-| --------- | -------- | --------- | ------: | -------: | -------------- | -------- | ----: | ------------- | ------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| Segformer | MIT-B0   | 512x512   |  160000 |      2.1 | 51.32          | 1080 Ti  | 37.41 | 38.34         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b0_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b0_512x512_160k_ade20k/segformer_mit-b0_512x512_160k_ade20k_20210726_101530-8ffa8fda.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b0_512x512_160k_ade20k/segformer_mit-b0_512x512_160k_ade20k_20210726_101530.log.json) |
-| Segformer | MIT-B1   | 512x512   |  160000 |      2.6 | 47.66          | TITAN Xp | 40.97 | 42.54         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b1_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b1_512x512_160k_ade20k/segformer_mit-b1_512x512_160k_ade20k_20210726_112106-d70e859d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b1_512x512_160k_ade20k/segformer_mit-b1_512x512_160k_ade20k_20210726_112106.log.json) |
-| Segformer | MIT-B2   | 512x512   |  160000 |      3.6 | 30.88          | TITAN Xp | 45.58 | 47.03         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b2_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b2_512x512_160k_ade20k/segformer_mit-b2_512x512_160k_ade20k_20210726_112103-cbd414ac.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b2_512x512_160k_ade20k/segformer_mit-b2_512x512_160k_ade20k_20210726_112103.log.json) |
-| Segformer | MIT-B3   | 512x512   |  160000 |      4.8 | 22.11          | V100     | 47.82 | 48.81         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b3_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b3_512x512_160k_ade20k/segformer_mit-b3_512x512_160k_ade20k_20210726_081410-962b98d2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b3_512x512_160k_ade20k/segformer_mit-b3_512x512_160k_ade20k_20210726_081410.log.json) |
-| Segformer | MIT-B4   | 512x512   |  160000 |      6.1 | 15.45          | V100     | 48.46 | 49.76         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b4_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b4_512x512_160k_ade20k/segformer_mit-b4_512x512_160k_ade20k_20210728_183055-7f509d7d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b4_512x512_160k_ade20k/segformer_mit-b4_512x512_160k_ade20k_20210728_183055.log.json) |
-| Segformer | MIT-B5   | 512x512   |  160000 |      7.2 | 11.89          | V100     | 49.13 | 50.22         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_512x512_160k_ade20k/segformer_mit-b5_512x512_160k_ade20k_20210726_145235-94cedf59.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_512x512_160k_ade20k/segformer_mit-b5_512x512_160k_ade20k_20210726_145235.log.json) |
-| Segformer | MIT-B5   | 640x640   |  160000 |     11.5 | 11.30          | V100     | 49.62 | 50.36         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-640x640.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_640x640_160k_ade20k/segformer_mit-b5_640x640_160k_ade20k_20210801_121243-41d2845b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_640x640_160k_ade20k/segformer_mit-b5_640x640_160k_ade20k_20210801_121243.log.json) |
-
-Evaluation with AlignedResize:
-
-| Method    | Backbone | Crop Size | Lr schd |  mIoU | mIoU(ms+flip) |
-| --------- | -------- | --------- | ------: | ----: | ------------- |
-| Segformer | MIT-B0   | 512x512   |  160000 |  38.1 | 38.57         |
-| Segformer | MIT-B1   | 512x512   |  160000 | 41.64 | 42.76         |
-| Segformer | MIT-B2   | 512x512   |  160000 | 46.53 | 47.49         |
-| Segformer | MIT-B3   | 512x512   |  160000 | 48.46 | 49.14         |
-| Segformer | MIT-B4   | 512x512   |  160000 | 49.34 | 50.29         |
-| Segformer | MIT-B5   | 512x512   |  160000 | 50.08 | 50.72         |
-| Segformer | MIT-B5   | 640x640   |  160000 | 50.58 | 50.8          |
-
-We replace `AlignedResize` in original implementatiuon to `Resize + ResizeToMultiple`. If you want to test by
-using `AlignedResize`, you can change the dataset pipeline like this:
-
-```python
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
-    # resize image to multiple of 32, improve SegFormer by 0.5-1.0 mIoU.
-    dict(type='ResizeToMultiple', size_divisor=32),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='PackSegInputs')
-]
-```
-
-### Cityscapes
-
-The lower fps result is caused by the sliding window inference scheme (window size:1024x1024).
-
-| Method    | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                                | download                                                                                                                                                                                                                                                                                                                                                                                       |
-| --------- | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | ------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Segformer | MIT-B0   | 1024x1024 |  160000 |     3.64 | 4.74           | V100   | 76.54 | 78.22         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b0_8x1_1024x1024_160k_cityscapes/segformer_mit-b0_8x1_1024x1024_160k_cityscapes_20211208_101857-e7f88502.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b0_8x1_1024x1024_160k_cityscapes/segformer_mit-b0_8x1_1024x1024_160k_cityscapes_20211208_101857.log.json) |
-| Segformer | MIT-B1   | 1024x1024 |  160000 |     4.49 | 4.3            | V100   | 78.56 | 79.73         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b1_8xb1-160k_cityscapes-1024x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b1_8x1_1024x1024_160k_cityscapes/segformer_mit-b1_8x1_1024x1024_160k_cityscapes_20211208_064213-655c7b3f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b1_8x1_1024x1024_160k_cityscapes/segformer_mit-b1_8x1_1024x1024_160k_cityscapes_20211208_064213.log.json) |
-| Segformer | MIT-B2   | 1024x1024 |  160000 |     7.42 | 3.36           | V100   | 81.08 | 82.18         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b2_8xb1-160k_cityscapes-1024x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b2_8x1_1024x1024_160k_cityscapes/segformer_mit-b2_8x1_1024x1024_160k_cityscapes_20211207_134205-6096669a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b2_8x1_1024x1024_160k_cityscapes/segformer_mit-b2_8x1_1024x1024_160k_cityscapes_20211207_134205.log.json) |
-| Segformer | MIT-B3   | 1024x1024 |  160000 |    10.86 | 2.53           | V100   | 81.94 | 83.14         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b3_8xb1-160k_cityscapes-1024x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b3_8x1_1024x1024_160k_cityscapes/segformer_mit-b3_8x1_1024x1024_160k_cityscapes_20211206_224823-a8f8a177.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b3_8x1_1024x1024_160k_cityscapes/segformer_mit-b3_8x1_1024x1024_160k_cityscapes_20211206_224823.log.json) |
-| Segformer | MIT-B4   | 1024x1024 |  160000 |    15.07 | 1.88           | V100   | 81.89 | 83.38         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b4_8xb1-160k_cityscapes-1024x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b4_8x1_1024x1024_160k_cityscapes/segformer_mit-b4_8x1_1024x1024_160k_cityscapes_20211207_080709-07f6c333.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b4_8x1_1024x1024_160k_cityscapes/segformer_mit-b4_8x1_1024x1024_160k_cityscapes_20211207_080709.log.json) |
-| Segformer | MIT-B5   | 1024x1024 |  160000 |    18.00 | 1.39           | V100   | 82.25 | 83.48         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer/segformer_mit-b5_8xb1-160k_cityscapes-1024x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_8x1_1024x1024_160k_cityscapes/segformer_mit-b5_8x1_1024x1024_160k_cityscapes_20211206_072934-87a052ec.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_8x1_1024x1024_160k_cityscapes/segformer_mit-b5_8x1_1024x1024_160k_cityscapes_20211206_072934.log.json) |
-
-## Citation
-
-```bibtex
-@article{xie2021segformer,
-  title={SegFormer: Simple and Efficient Design for Semantic Segmentation with Transformers},
-  author={Xie, Enze and Wang, Wenhai and Yu, Zhiding and Anandkumar, Anima and Alvarez, Jose M and Luo, Ping},
-  journal={arXiv preprint arXiv:2105.15203},
-  year={2021}
-}
-```
diff --git a/mmsegmentation/configs/segformer/metafile.yaml b/mmsegmentation/configs/segformer/metafile.yaml
deleted file mode 100644
index 7fb38d7..0000000
--- a/mmsegmentation/configs/segformer/metafile.yaml
+++ /dev/null
@@ -1,340 +0,0 @@
-Collections:
-- Name: Segformer
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - ADE20K
-    - Cityscapes
-  Paper:
-    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
-      Transformers'
-    URL: https://arxiv.org/abs/2105.15203
-  README: configs/segformer/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: segformer_mit-b0_8xb2-160k_ade20k-512x512
-  In Collection: Segformer
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 37.41
-      mIoU(ms+flip): 38.34
-  Config: configs/segformer/segformer_mit-b0_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - MIT-B0
-    - Segformer
-    Training Resources: 8x 1080 Ti GPUS
-    Memory (GB): 2.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b0_512x512_160k_ade20k/segformer_mit-b0_512x512_160k_ade20k_20210726_101530-8ffa8fda.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b0_512x512_160k_ade20k/segformer_mit-b0_512x512_160k_ade20k_20210726_101530.log.json
-  Paper:
-    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
-      Transformers'
-    URL: https://arxiv.org/abs/2105.15203
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
-  Framework: PyTorch
-- Name: segformer_mit-b1_8xb2-160k_ade20k-512x512
-  In Collection: Segformer
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 40.97
-      mIoU(ms+flip): 42.54
-  Config: configs/segformer/segformer_mit-b1_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - MIT-B1
-    - Segformer
-    Training Resources: 8x TITAN Xp GPUS
-    Memory (GB): 2.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b1_512x512_160k_ade20k/segformer_mit-b1_512x512_160k_ade20k_20210726_112106-d70e859d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b1_512x512_160k_ade20k/segformer_mit-b1_512x512_160k_ade20k_20210726_112106.log.json
-  Paper:
-    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
-      Transformers'
-    URL: https://arxiv.org/abs/2105.15203
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
-  Framework: PyTorch
-- Name: segformer_mit-b2_8xb2-160k_ade20k-512x512
-  In Collection: Segformer
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 45.58
-      mIoU(ms+flip): 47.03
-  Config: configs/segformer/segformer_mit-b2_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - MIT-B2
-    - Segformer
-    Training Resources: 8x TITAN Xp GPUS
-    Memory (GB): 3.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b2_512x512_160k_ade20k/segformer_mit-b2_512x512_160k_ade20k_20210726_112103-cbd414ac.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b2_512x512_160k_ade20k/segformer_mit-b2_512x512_160k_ade20k_20210726_112103.log.json
-  Paper:
-    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
-      Transformers'
-    URL: https://arxiv.org/abs/2105.15203
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
-  Framework: PyTorch
-- Name: segformer_mit-b3_8xb2-160k_ade20k-512x512
-  In Collection: Segformer
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 47.82
-      mIoU(ms+flip): 48.81
-  Config: configs/segformer/segformer_mit-b3_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - MIT-B3
-    - Segformer
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 4.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b3_512x512_160k_ade20k/segformer_mit-b3_512x512_160k_ade20k_20210726_081410-962b98d2.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b3_512x512_160k_ade20k/segformer_mit-b3_512x512_160k_ade20k_20210726_081410.log.json
-  Paper:
-    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
-      Transformers'
-    URL: https://arxiv.org/abs/2105.15203
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
-  Framework: PyTorch
-- Name: segformer_mit-b4_8xb2-160k_ade20k-512x512
-  In Collection: Segformer
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 48.46
-      mIoU(ms+flip): 49.76
-  Config: configs/segformer/segformer_mit-b4_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - MIT-B4
-    - Segformer
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 6.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b4_512x512_160k_ade20k/segformer_mit-b4_512x512_160k_ade20k_20210728_183055-7f509d7d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b4_512x512_160k_ade20k/segformer_mit-b4_512x512_160k_ade20k_20210728_183055.log.json
-  Paper:
-    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
-      Transformers'
-    URL: https://arxiv.org/abs/2105.15203
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
-  Framework: PyTorch
-- Name: segformer_mit-b5_8xb2-160k_ade20k-512x512
-  In Collection: Segformer
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 49.13
-      mIoU(ms+flip): 50.22
-  Config: configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - MIT-B5
-    - Segformer
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 7.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_512x512_160k_ade20k/segformer_mit-b5_512x512_160k_ade20k_20210726_145235-94cedf59.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_512x512_160k_ade20k/segformer_mit-b5_512x512_160k_ade20k_20210726_145235.log.json
-  Paper:
-    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
-      Transformers'
-    URL: https://arxiv.org/abs/2105.15203
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
-  Framework: PyTorch
-- Name: segformer_mit-b5_8xb2-160k_ade20k-640x640
-  In Collection: Segformer
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 49.62
-      mIoU(ms+flip): 50.36
-  Config: configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-640x640.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - MIT-B5
-    - Segformer
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 11.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_640x640_160k_ade20k/segformer_mit-b5_640x640_160k_ade20k_20210801_121243-41d2845b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_640x640_160k_ade20k/segformer_mit-b5_640x640_160k_ade20k_20210801_121243.log.json
-  Paper:
-    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
-      Transformers'
-    URL: https://arxiv.org/abs/2105.15203
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
-  Framework: PyTorch
-- Name: segformer_mit-b0_8xb1-160k_cityscapes-1024x1024
-  In Collection: Segformer
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.54
-      mIoU(ms+flip): 78.22
-  Config: configs/segformer/segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - MIT-B0
-    - Segformer
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 3.64
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b0_8x1_1024x1024_160k_cityscapes/segformer_mit-b0_8x1_1024x1024_160k_cityscapes_20211208_101857-e7f88502.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b0_8x1_1024x1024_160k_cityscapes/segformer_mit-b0_8x1_1024x1024_160k_cityscapes_20211208_101857.log.json
-  Paper:
-    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
-      Transformers'
-    URL: https://arxiv.org/abs/2105.15203
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
-  Framework: PyTorch
-- Name: segformer_mit-b1_8xb1-160k_cityscapes-1024x1024
-  In Collection: Segformer
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.56
-      mIoU(ms+flip): 79.73
-  Config: configs/segformer/segformer_mit-b1_8xb1-160k_cityscapes-1024x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - MIT-B1
-    - Segformer
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 4.49
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b1_8x1_1024x1024_160k_cityscapes/segformer_mit-b1_8x1_1024x1024_160k_cityscapes_20211208_064213-655c7b3f.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b1_8x1_1024x1024_160k_cityscapes/segformer_mit-b1_8x1_1024x1024_160k_cityscapes_20211208_064213.log.json
-  Paper:
-    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
-      Transformers'
-    URL: https://arxiv.org/abs/2105.15203
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
-  Framework: PyTorch
-- Name: segformer_mit-b2_8xb1-160k_cityscapes-1024x1024
-  In Collection: Segformer
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 81.08
-      mIoU(ms+flip): 82.18
-  Config: configs/segformer/segformer_mit-b2_8xb1-160k_cityscapes-1024x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - MIT-B2
-    - Segformer
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 7.42
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b2_8x1_1024x1024_160k_cityscapes/segformer_mit-b2_8x1_1024x1024_160k_cityscapes_20211207_134205-6096669a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b2_8x1_1024x1024_160k_cityscapes/segformer_mit-b2_8x1_1024x1024_160k_cityscapes_20211207_134205.log.json
-  Paper:
-    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
-      Transformers'
-    URL: https://arxiv.org/abs/2105.15203
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
-  Framework: PyTorch
-- Name: segformer_mit-b3_8xb1-160k_cityscapes-1024x1024
-  In Collection: Segformer
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 81.94
-      mIoU(ms+flip): 83.14
-  Config: configs/segformer/segformer_mit-b3_8xb1-160k_cityscapes-1024x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - MIT-B3
-    - Segformer
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 10.86
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b3_8x1_1024x1024_160k_cityscapes/segformer_mit-b3_8x1_1024x1024_160k_cityscapes_20211206_224823-a8f8a177.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b3_8x1_1024x1024_160k_cityscapes/segformer_mit-b3_8x1_1024x1024_160k_cityscapes_20211206_224823.log.json
-  Paper:
-    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
-      Transformers'
-    URL: https://arxiv.org/abs/2105.15203
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
-  Framework: PyTorch
-- Name: segformer_mit-b4_8xb1-160k_cityscapes-1024x1024
-  In Collection: Segformer
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 81.89
-      mIoU(ms+flip): 83.38
-  Config: configs/segformer/segformer_mit-b4_8xb1-160k_cityscapes-1024x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - MIT-B4
-    - Segformer
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 15.07
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b4_8x1_1024x1024_160k_cityscapes/segformer_mit-b4_8x1_1024x1024_160k_cityscapes_20211207_080709-07f6c333.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b4_8x1_1024x1024_160k_cityscapes/segformer_mit-b4_8x1_1024x1024_160k_cityscapes_20211207_080709.log.json
-  Paper:
-    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
-      Transformers'
-    URL: https://arxiv.org/abs/2105.15203
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
-  Framework: PyTorch
-- Name: segformer_mit-b5_8xb1-160k_cityscapes-1024x1024
-  In Collection: Segformer
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 82.25
-      mIoU(ms+flip): 83.48
-  Config: configs/segformer/segformer_mit-b5_8xb1-160k_cityscapes-1024x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - MIT-B5
-    - Segformer
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 18.0
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_8x1_1024x1024_160k_cityscapes/segformer_mit-b5_8x1_1024x1024_160k_cityscapes_20211206_072934-87a052ec.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segformer/segformer_mit-b5_8x1_1024x1024_160k_cityscapes/segformer_mit-b5_8x1_1024x1024_160k_cityscapes_20211206_072934.log.json
-  Paper:
-    Title: 'SegFormer: Simple and Efficient Design for Semantic Segmentation with
-      Transformers'
-    URL: https://arxiv.org/abs/2105.15203
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/mit.py#L246
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/segformer/segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py
deleted file mode 100644
index 1280047..0000000
--- a/mmsegmentation/configs/segformer/segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py
+++ /dev/null
@@ -1,41 +0,0 @@
-_base_ = [
-    '../_base_/models/segformer_mit-b0.py',
-    '../_base_/datasets/cityscapes_1024x1024.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (1024, 1024)
-data_preprocessor = dict(size=crop_size)
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b0_20220624-7e0fe6dd.pth'  # noqa
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(init_cfg=dict(type='Pretrained', checkpoint=checkpoint)),
-    test_cfg=dict(mode='slide', crop_size=(1024, 1024), stride=(768, 768)))
-
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
-    paramwise_cfg=dict(
-        custom_keys={
-            'pos_block': dict(decay_mult=0.),
-            'norm': dict(decay_mult=0.),
-            'head': dict(lr_mult=10.)
-        }))
-
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        eta_min=0.0,
-        power=1.0,
-        begin=1500,
-        end=160000,
-        by_epoch=False,
-    )
-]
-
-train_dataloader = dict(batch_size=1, num_workers=4)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b0_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/segformer/segformer_mit-b0_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 4a9476d..0000000
--- a/mmsegmentation/configs/segformer/segformer_mit-b0_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,39 +0,0 @@
-_base_ = [
-    '../_base_/models/segformer_mit-b0.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b0_20220624-7e0fe6dd.pth'  # noqa
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(init_cfg=dict(type='Pretrained', checkpoint=checkpoint)),
-    decode_head=dict(num_classes=150))
-
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
-    paramwise_cfg=dict(
-        custom_keys={
-            'pos_block': dict(decay_mult=0.),
-            'norm': dict(decay_mult=0.),
-            'head': dict(lr_mult=10.)
-        }))
-
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        eta_min=0.0,
-        power=1.0,
-        begin=1500,
-        end=160000,
-        by_epoch=False,
-    )
-]
-train_dataloader = dict(batch_size=2, num_workers=2)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b1_8xb1-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/segformer/segformer_mit-b1_8xb1-160k_cityscapes-1024x1024.py
deleted file mode 100644
index 85c126e..0000000
--- a/mmsegmentation/configs/segformer/segformer_mit-b1_8xb1-160k_cityscapes-1024x1024.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = ['./segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py']
-
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b1_20220624-02e5a6a1.pth'  # noqa
-
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
-        embed_dims=64),
-    decode_head=dict(in_channels=[64, 128, 320, 512]))
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b1_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/segformer/segformer_mit-b1_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 1ff21b8..0000000
--- a/mmsegmentation/configs/segformer/segformer_mit-b1_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = ['./segformer_mit-b0_8xb2-160k_ade20k-512x512.py']
-
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b1_20220624-02e5a6a1.pth'  # noqa
-
-# model settings
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
-        embed_dims=64,
-        num_heads=[1, 2, 5, 8],
-        num_layers=[2, 2, 2, 2]),
-    decode_head=dict(in_channels=[64, 128, 320, 512]))
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b2_8xb1-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/segformer/segformer_mit-b2_8xb1-160k_cityscapes-1024x1024.py
deleted file mode 100644
index c802f27..0000000
--- a/mmsegmentation/configs/segformer/segformer_mit-b2_8xb1-160k_cityscapes-1024x1024.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = ['./segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py']
-
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b2_20220624-66e8bf70.pth'  # noqa
-
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
-        embed_dims=64,
-        num_layers=[3, 4, 6, 3]),
-    decode_head=dict(in_channels=[64, 128, 320, 512]))
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b2_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/segformer/segformer_mit-b2_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 0f4c1af..0000000
--- a/mmsegmentation/configs/segformer/segformer_mit-b2_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = ['./segformer_mit-b0_8xb2-160k_ade20k-512x512.py']
-
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b2_20220624-66e8bf70.pth'  # noqa
-
-# model settings
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
-        embed_dims=64,
-        num_heads=[1, 2, 5, 8],
-        num_layers=[3, 4, 6, 3]),
-    decode_head=dict(in_channels=[64, 128, 320, 512]))
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b3_8xb1-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/segformer/segformer_mit-b3_8xb1-160k_cityscapes-1024x1024.py
deleted file mode 100644
index 9b41ad0..0000000
--- a/mmsegmentation/configs/segformer/segformer_mit-b3_8xb1-160k_cityscapes-1024x1024.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = ['./segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py']
-
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b3_20220624-13b1141c.pth'  # noqa
-
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
-        embed_dims=64,
-        num_layers=[3, 4, 18, 3]),
-    decode_head=dict(in_channels=[64, 128, 320, 512]))
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b3_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/segformer/segformer_mit-b3_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index a2cc13d..0000000
--- a/mmsegmentation/configs/segformer/segformer_mit-b3_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = ['./segformer_mit-b0_8xb2-160k_ade20k-512x512.py']
-
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b3_20220624-13b1141c.pth'  # noqa
-
-# model settings
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
-        embed_dims=64,
-        num_heads=[1, 2, 5, 8],
-        num_layers=[3, 4, 18, 3]),
-    decode_head=dict(in_channels=[64, 128, 320, 512]))
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b4_8xb1-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/segformer/segformer_mit-b4_8xb1-160k_cityscapes-1024x1024.py
deleted file mode 100644
index 5fb1608..0000000
--- a/mmsegmentation/configs/segformer/segformer_mit-b4_8xb1-160k_cityscapes-1024x1024.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = ['./segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py']
-
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b4_20220624-d588d980.pth'  # noqa
-
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
-        embed_dims=64,
-        num_layers=[3, 8, 27, 3]),
-    decode_head=dict(in_channels=[64, 128, 320, 512]))
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b4_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/segformer/segformer_mit-b4_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 5f39c30..0000000
--- a/mmsegmentation/configs/segformer/segformer_mit-b4_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = ['./segformer_mit-b0_8xb2-160k_ade20k-512x512.py']
-
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b4_20220624-d588d980.pth'  # noqa
-
-# model settings
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
-        embed_dims=64,
-        num_heads=[1, 2, 5, 8],
-        num_layers=[3, 8, 27, 3]),
-    decode_head=dict(in_channels=[64, 128, 320, 512]))
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b5_8xb1-160k_cityscapes-1024x1024.py b/mmsegmentation/configs/segformer/segformer_mit-b5_8xb1-160k_cityscapes-1024x1024.py
deleted file mode 100644
index 18c3c16..0000000
--- a/mmsegmentation/configs/segformer/segformer_mit-b5_8xb1-160k_cityscapes-1024x1024.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = ['./segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py']
-
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b5_20220624-658746d9.pth'  # noqa
-
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
-        embed_dims=64,
-        num_layers=[3, 6, 40, 3]),
-    decode_head=dict(in_channels=[64, 128, 320, 512]))
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 1e9a209..0000000
--- a/mmsegmentation/configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = ['./segformer_mit-b0_8xb2-160k_ade20k-512x512.py']
-
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b5_20220624-658746d9.pth'  # noqa
-
-# model settings
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
-        embed_dims=64,
-        num_heads=[1, 2, 5, 8],
-        num_layers=[3, 6, 40, 3]),
-    decode_head=dict(in_channels=[64, 128, 320, 512]))
diff --git a/mmsegmentation/configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-640x640.py b/mmsegmentation/configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-640x640.py
deleted file mode 100644
index a32eb7c..0000000
--- a/mmsegmentation/configs/segformer/segformer_mit-b5_8xb2-160k_ade20k-640x640.py
+++ /dev/null
@@ -1,41 +0,0 @@
-_base_ = ['./segformer_mit-b0_8xb2-160k_ade20k-512x512.py']
-
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segformer/mit_b5_20220624-658746d9.pth'  # noqa
-
-# dataset settings
-crop_size = (640, 640)
-data_preprocessor = dict(size=crop_size)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(
-        type='RandomResize',
-        scale=(2048, 640),
-        ratio_range=(0.5, 2.0),
-        keep_ratio=True),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(2048, 640), keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
-val_dataloader = dict(batch_size=1, dataset=dict(pipeline=test_pipeline))
-test_dataloader = val_dataloader
-
-# model settings
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
-        embed_dims=64,
-        num_heads=[1, 2, 5, 8],
-        num_layers=[3, 6, 40, 3]),
-    decode_head=dict(in_channels=[64, 128, 320, 512]))
diff --git a/mmsegmentation/configs/segmenter/README.md b/mmsegmentation/configs/segmenter/README.md
deleted file mode 100644
index 103b125..0000000
--- a/mmsegmentation/configs/segmenter/README.md
+++ /dev/null
@@ -1,76 +0,0 @@
-# Segmenter
-
-> [Segmenter: Transformer for Semantic Segmentation](https://arxiv.org/abs/2105.05633)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/rstrudel/segmenter">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.21.0/mmseg/models/decode_heads/segmenter_mask_head.py#L15">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Image segmentation is often ambiguous at the level of individual image patches and requires contextual information to reach label consensus. In this paper we introduce Segmenter, a transformer model for semantic segmentation. In contrast to convolution-based methods, our approach allows to model global context already at the first layer and throughout the network. We build on the recent Vision Transformer (ViT) and extend it to semantic segmentation. To do so, we rely on the output embeddings corresponding to image patches and obtain class labels from these embeddings with a point-wise linear decoder or a mask transformer decoder. We leverage models pre-trained for image classification and show that we can fine-tune them on moderate sized datasets available for semantic segmentation. The linear decoder allows to obtain excellent results already, but the performance can be further improved by a mask transformer generating class masks. We conduct an extensive ablation study to show the impact of the different parameters, in particular the performance is better for large models and small patch sizes. Segmenter attains excellent results for semantic segmentation. It outperforms the state of the art on both ADE20K and Pascal Context datasets and is competitive on Cityscapes.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/148507554-87eb80bd-02c7-4c31-b102-c6141e231ec8.png" width="70%"/>
-</div>
-
-## Usage
-
-We have provided pretrained models converted from [ViT-AugReg](https://github.com/rwightman/pytorch-image-models/blob/f55c22bebf9d8afc449d317a723231ef72e0d662/timm/models/vision_transformer.py#L54-L106).
-
-If you want to convert keys on your own to use the pre-trained ViT model from [Segmenter](https://github.com/rstrudel/segmenter), we also provide a script [`vitjax2mmseg.py`](../../tools/model_converters/vitjax2mmseg.py) in the tools directory to convert the key of models from [ViT-AugReg](https://github.com/rwightman/pytorch-image-models/blob/f55c22bebf9d8afc449d317a723231ef72e0d662/timm/models/vision_transformer.py#L54-L106) to MMSegmentation style.
-
-```shell
-python tools/model_converters/vitjax2mmseg.py ${PRETRAIN_PATH} ${STORE_PATH}
-```
-
-E.g.
-
-```shell
-python tools/model_converters/vitjax2mmseg.py \
-Ti_16-i21k-300ep-lr_0.001-aug_none-wd_0.03-do_0.0-sd_0.0--imagenet2012-steps_20k-lr_0.03-res_384.npz \
-pretrain/vit_tiny_p16_384.pth
-```
-
-This script convert model from `PRETRAIN_PATH` and store the converted model in `STORE_PATH`.
-
-In our default setting, pretrained models and their corresponding [ViT-AugReg](https://github.com/rwightman/pytorch-image-models/blob/f55c22bebf9d8afc449d317a723231ef72e0d662/timm/models/vision_transformer.py#L54-L106) models could be defined below:
-
-| pretrained models     | original models                                                                                                                                                                 |
-| --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| vit_tiny_p16_384.pth  | [vit_tiny_patch16_384](https://storage.googleapis.com/vit_models/augreg/Ti_16-i21k-300ep-lr_0.001-aug_none-wd_0.03-do_0.0-sd_0.0--imagenet2012-steps_20k-lr_0.03-res_384.npz)   |
-| vit_small_p16_384.pth | [vit_small_patch16_384](https://storage.googleapis.com/vit_models/augreg/S_16-i21k-300ep-lr_0.001-aug_light1-wd_0.03-do_0.0-sd_0.0--imagenet2012-steps_20k-lr_0.03-res_384.npz) |
-| vit_base_p16_384.pth  | [vit_base_patch16_384](https://storage.googleapis.com/vit_models/augreg/B_16-i21k-300ep-lr_0.001-aug_medium1-wd_0.1-do_0.0-sd_0.0--imagenet2012-steps_20k-lr_0.01-res_384.npz)  |
-| vit_large_p16_384.pth | [vit_large_patch16_384](https://storage.googleapis.com/vit_models/augreg/L_16-i21k-300ep-lr_0.001-aug_medium1-wd_0.1-do_0.1-sd_0.1--imagenet2012-steps_20k-lr_0.01-res_384.npz) |
-
-## Results and models
-
-### ADE20K
-
-| Method           | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                              | download                                                                                                                                                                                                                                                                                                                                                                                       |
-| ---------------- | -------- | --------- | ------- | -------- | -------------- | ------ | ----- | ------------- | ----------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Segmenter Mask   | ViT-T_16 | 512x512   | 160000  | 1.21     | 27.98          | V100   | 39.99 | 40.83         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segmenter/segmenter_vit-t_mask_8xb1-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-t_mask_8x1_512x512_160k_ade20k/segmenter_vit-t_mask_8x1_512x512_160k_ade20k_20220105_151706-ffcf7509.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-t_mask_8x1_512x512_160k_ade20k/segmenter_vit-t_mask_8x1_512x512_160k_ade20k_20220105_151706.log.json)         |
-| Segmenter Linear | ViT-S_16 | 512x512   | 160000  | 1.78     | 28.07          | V100   | 45.75 | 46.82         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segmenter/segmenter_vit-s_fcn_8xb1-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-s_linear_8x1_512x512_160k_ade20k/segmenter_vit-s_linear_8x1_512x512_160k_ade20k_20220105_151713-39658c46.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-s_linear_8x1_512x512_160k_ade20k/segmenter_vit-s_linear_8x1_512x512_160k_ade20k_20220105_151713.log.json) |
-| Segmenter Mask   | ViT-S_16 | 512x512   | 160000  | 2.03     | 24.80          | V100   | 46.19 | 47.85         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segmenter/segmenter_vit-s_mask_8xb1-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-s_mask_8x1_512x512_160k_ade20k/segmenter_vit-s_mask_8x1_512x512_160k_ade20k_20220105_151706-511bb103.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-s_mask_8x1_512x512_160k_ade20k/segmenter_vit-s_mask_8x1_512x512_160k_ade20k_20220105_151706.log.json)         |
-| Segmenter Mask   | ViT-B_16 | 512x512   | 160000  | 4.20     | 13.20          | V100   | 49.60 | 51.07         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segmenter/segmenter_vit-b_mask_8xb1-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-b_mask_8x1_512x512_160k_ade20k/segmenter_vit-b_mask_8x1_512x512_160k_ade20k_20220105_151706-bc533b08.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-b_mask_8x1_512x512_160k_ade20k/segmenter_vit-b_mask_8x1_512x512_160k_ade20k_20220105_151706.log.json)         |
-| Segmenter Mask   | ViT-L_16 | 640x640   | 160000  | 16.56    | 2.62           | V100   | 52.16 | 53.65         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segmenter/segmenter_vit-l_mask_8xb1-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-l_mask_8x1_512x512_160k_ade20k/segmenter_vit-l_mask_8x1_512x512_160k_ade20k_20220105_162750-7ef345be.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-l_mask_8x1_512x512_160k_ade20k/segmenter_vit-l_mask_8x1_512x512_160k_ade20k_20220105_162750.log.json)         |
-
-## Citation
-
-```bibtex
-@inproceedings{strudel2021segmenter,
-  title={Segmenter: Transformer for semantic segmentation},
-  author={Strudel, Robin and Garcia, Ricardo and Laptev, Ivan and Schmid, Cordelia},
-  booktitle={Proceedings of the IEEE/CVF International Conference on Computer Vision},
-  pages={7262--7272},
-  year={2021}
-}
-```
diff --git a/mmsegmentation/configs/segmenter/metafile.yaml b/mmsegmentation/configs/segmenter/metafile.yaml
deleted file mode 100644
index ff2aa44..0000000
--- a/mmsegmentation/configs/segmenter/metafile.yaml
+++ /dev/null
@@ -1,138 +0,0 @@
-Collections:
-- Name: Segmenter
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - ADE20K
-  Paper:
-    Title: 'Segmenter: Transformer for Semantic Segmentation'
-    URL: https://arxiv.org/abs/2105.05633
-  README: configs/segmenter/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: segmenter_vit-t_mask_8xb1-160k_ade20k-512x512
-  In Collection: Segmenter
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 39.99
-      mIoU(ms+flip): 40.83
-  Config: configs/segmenter/segmenter_vit-t_mask_8xb1-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 8
-    Architecture:
-    - ViT-T_16
-    - Segmenter
-    - Mask
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 1.21
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-t_mask_8x1_512x512_160k_ade20k/segmenter_vit-t_mask_8x1_512x512_160k_ade20k_20220105_151706-ffcf7509.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-t_mask_8x1_512x512_160k_ade20k/segmenter_vit-t_mask_8x1_512x512_160k_ade20k_20220105_151706.log.json
-  Paper:
-    Title: 'Segmenter: Transformer for Semantic Segmentation'
-    URL: https://arxiv.org/abs/2105.05633
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.21.0/mmseg/models/decode_heads/segmenter_mask_head.py#L15
-  Framework: PyTorch
-- Name: segmenter_vit-s_fcn_8xb1-160k_ade20k-512x512
-  In Collection: Segmenter
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 45.75
-      mIoU(ms+flip): 46.82
-  Config: configs/segmenter/segmenter_vit-s_fcn_8xb1-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 8
-    Architecture:
-    - ViT-S_16
-    - Segmenter
-    - Linear
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 1.78
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-s_linear_8x1_512x512_160k_ade20k/segmenter_vit-s_linear_8x1_512x512_160k_ade20k_20220105_151713-39658c46.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-s_linear_8x1_512x512_160k_ade20k/segmenter_vit-s_linear_8x1_512x512_160k_ade20k_20220105_151713.log.json
-  Paper:
-    Title: 'Segmenter: Transformer for Semantic Segmentation'
-    URL: https://arxiv.org/abs/2105.05633
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.21.0/mmseg/models/decode_heads/segmenter_mask_head.py#L15
-  Framework: PyTorch
-- Name: segmenter_vit-s_mask_8xb1-160k_ade20k-512x512
-  In Collection: Segmenter
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 46.19
-      mIoU(ms+flip): 47.85
-  Config: configs/segmenter/segmenter_vit-s_mask_8xb1-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 8
-    Architecture:
-    - ViT-S_16
-    - Segmenter
-    - Mask
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 2.03
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-s_mask_8x1_512x512_160k_ade20k/segmenter_vit-s_mask_8x1_512x512_160k_ade20k_20220105_151706-511bb103.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-s_mask_8x1_512x512_160k_ade20k/segmenter_vit-s_mask_8x1_512x512_160k_ade20k_20220105_151706.log.json
-  Paper:
-    Title: 'Segmenter: Transformer for Semantic Segmentation'
-    URL: https://arxiv.org/abs/2105.05633
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.21.0/mmseg/models/decode_heads/segmenter_mask_head.py#L15
-  Framework: PyTorch
-- Name: segmenter_vit-b_mask_8xb1-160k_ade20k-512x512
-  In Collection: Segmenter
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 49.6
-      mIoU(ms+flip): 51.07
-  Config: configs/segmenter/segmenter_vit-b_mask_8xb1-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 8
-    Architecture:
-    - ViT-B_16
-    - Segmenter
-    - Mask
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 4.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-b_mask_8x1_512x512_160k_ade20k/segmenter_vit-b_mask_8x1_512x512_160k_ade20k_20220105_151706-bc533b08.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-b_mask_8x1_512x512_160k_ade20k/segmenter_vit-b_mask_8x1_512x512_160k_ade20k_20220105_151706.log.json
-  Paper:
-    Title: 'Segmenter: Transformer for Semantic Segmentation'
-    URL: https://arxiv.org/abs/2105.05633
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.21.0/mmseg/models/decode_heads/segmenter_mask_head.py#L15
-  Framework: PyTorch
-- Name: segmenter_vit-l_mask_8xb1-160k_ade20k-512x512
-  In Collection: Segmenter
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 52.16
-      mIoU(ms+flip): 53.65
-  Config: configs/segmenter/segmenter_vit-l_mask_8xb1-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 8
-    Architecture:
-    - ViT-L_16
-    - Segmenter
-    - Mask
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 16.56
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-l_mask_8x1_512x512_160k_ade20k/segmenter_vit-l_mask_8x1_512x512_160k_ade20k_20220105_162750-7ef345be.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segmenter/segmenter_vit-l_mask_8x1_512x512_160k_ade20k/segmenter_vit-l_mask_8x1_512x512_160k_ade20k_20220105_162750.log.json
-  Paper:
-    Title: 'Segmenter: Transformer for Semantic Segmentation'
-    URL: https://arxiv.org/abs/2105.05633
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.21.0/mmseg/models/decode_heads/segmenter_mask_head.py#L15
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/segmenter/segmenter_vit-b_mask_8xb1-160k_ade20k-512x512.py b/mmsegmentation/configs/segmenter/segmenter_vit-b_mask_8xb1-160k_ade20k-512x512.py
deleted file mode 100644
index a4bae50..0000000
--- a/mmsegmentation/configs/segmenter/segmenter_vit-b_mask_8xb1-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,14 +0,0 @@
-_base_ = [
-    '../_base_/models/segmenter_vit-b16_mask.py',
-    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
-optimizer = dict(lr=0.001, weight_decay=0.0)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
-train_dataloader = dict(
-    # num_gpus: 8 -> batch_size: 8
-    batch_size=1)
-val_dataloader = dict(batch_size=1)
diff --git a/mmsegmentation/configs/segmenter/segmenter_vit-l_mask_8xb1-160k_ade20k-512x512.py b/mmsegmentation/configs/segmenter/segmenter_vit-l_mask_8xb1-160k_ade20k-512x512.py
deleted file mode 100644
index 302acde..0000000
--- a/mmsegmentation/configs/segmenter/segmenter_vit-l_mask_8xb1-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,32 +0,0 @@
-_base_ = [
-    '../_base_/models/segmenter_vit-b16_mask.py',
-    '../_base_/datasets/ade20k_640x640.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (640, 640)
-data_preprocessor = dict(size=crop_size)
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segmenter/vit_large_p16_384_20220308-d4efb41d.pth'  # noqa
-
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained=checkpoint,
-    backbone=dict(
-        type='VisionTransformer',
-        img_size=(640, 640),
-        embed_dims=1024,
-        num_layers=24,
-        num_heads=16),
-    decode_head=dict(
-        type='SegmenterMaskTransformerHead',
-        in_channels=1024,
-        channels=1024,
-        num_heads=16,
-        embed_dims=1024),
-    test_cfg=dict(mode='slide', crop_size=(640, 640), stride=(608, 608)))
-
-optimizer = dict(lr=0.001, weight_decay=0.0)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
-train_dataloader = dict(
-    # num_gpus: 8 -> batch_size: 8
-    batch_size=1)
-val_dataloader = dict(batch_size=1)
diff --git a/mmsegmentation/configs/segmenter/segmenter_vit-s_fcn_8xb1-160k_ade20k-512x512.py b/mmsegmentation/configs/segmenter/segmenter_vit-s_fcn_8xb1-160k_ade20k-512x512.py
deleted file mode 100644
index dc1e4c8..0000000
--- a/mmsegmentation/configs/segmenter/segmenter_vit-s_fcn_8xb1-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,14 +0,0 @@
-_base_ = './segmenter_vit-s_mask_8xb1-160k_ade20k-512x512.py'
-
-model = dict(
-    decode_head=dict(
-        _delete_=True,
-        type='FCNHead',
-        in_channels=384,
-        channels=384,
-        num_convs=0,
-        dropout_ratio=0.0,
-        concat_input=False,
-        num_classes=150,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)))
diff --git a/mmsegmentation/configs/segmenter/segmenter_vit-s_mask_8xb1-160k_ade20k-512x512.py b/mmsegmentation/configs/segmenter/segmenter_vit-s_mask_8xb1-160k_ade20k-512x512.py
deleted file mode 100644
index b19fd41..0000000
--- a/mmsegmentation/configs/segmenter/segmenter_vit-s_mask_8xb1-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,36 +0,0 @@
-_base_ = [
-    '../_base_/models/segmenter_vit-b16_mask.py',
-    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segmenter/vit_small_p16_384_20220308-410f6037.pth'  # noqa
-
-backbone_norm_cfg = dict(type='LN', eps=1e-6, requires_grad=True)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained=checkpoint,
-    backbone=dict(
-        img_size=(512, 512),
-        embed_dims=384,
-        num_heads=6,
-    ),
-    decode_head=dict(
-        type='SegmenterMaskTransformerHead',
-        in_channels=384,
-        channels=384,
-        num_classes=150,
-        num_layers=2,
-        num_heads=6,
-        embed_dims=384,
-        dropout_ratio=0.0,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)))
-
-optimizer = dict(lr=0.001, weight_decay=0.0)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
-train_dataloader = dict(
-    # num_gpus: 8 -> batch_size: 8
-    batch_size=1)
-val_dataloader = dict(batch_size=1)
diff --git a/mmsegmentation/configs/segmenter/segmenter_vit-t_mask_8xb1-160k_ade20k-512x512.py b/mmsegmentation/configs/segmenter/segmenter_vit-t_mask_8xb1-160k_ade20k-512x512.py
deleted file mode 100644
index 221a9f9..0000000
--- a/mmsegmentation/configs/segmenter/segmenter_vit-t_mask_8xb1-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,26 +0,0 @@
-_base_ = [
-    '../_base_/models/segmenter_vit-b16_mask.py',
-    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segmenter/vit_tiny_p16_384_20220308-cce8c795.pth'  # noqa
-
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained=checkpoint,
-    backbone=dict(embed_dims=192, num_heads=3),
-    decode_head=dict(
-        type='SegmenterMaskTransformerHead',
-        in_channels=192,
-        channels=192,
-        num_heads=3,
-        embed_dims=192))
-
-optimizer = dict(lr=0.001, weight_decay=0.0)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
-train_dataloader = dict(
-    # num_gpus: 8 -> batch_size: 8
-    batch_size=1)
-val_dataloader = dict(batch_size=1)
diff --git a/mmsegmentation/configs/segnext/README.md b/mmsegmentation/configs/segnext/README.md
deleted file mode 100644
index d7434a0..0000000
--- a/mmsegmentation/configs/segnext/README.md
+++ /dev/null
@@ -1,63 +0,0 @@
-# SegNeXt
-
-> [SegNeXt: Rethinking Convolutional Attention Design for Semantic Segmentation](https://arxiv.org/abs/2209.08575)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/visual-attention-network/segnext">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/backbones/mscan.py#L328">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-We present SegNeXt, a simple convolutional network architecture for semantic segmentation. Recent transformer-based models have dominated the field of semantic segmentation due to the efficiency of self-attention in encoding spatial information. In this paper, we show that convolutional attention is a more efficient and effective way to encode contextual information than the self-attention mechanism in transformers. By re-examining the characteristics owned by successful segmentation models, we discover several key components leading to the performance improvement of segmentation models. This motivates us to design a novel convolutional attention network that uses cheap convolutional operations. Without bells and whistles, our SegNeXt significantly improves the performance of previous state-of-the-art methods on popular benchmarks, including ADE20K, Cityscapes, COCO-Stuff, Pascal VOC, Pascal Context, and iSAID. Notably, SegNeXt outperforms EfficientNet-L2 w/ NAS-FPN and achieves 90.6% mIoU on the Pascal VOC 2012 test leaderboard using only 1/10 parameters of it. On average, SegNeXt achieves about 2.0% mIoU improvements compared to the state-of-the-art methods on the ADE20K datasets with the same or fewer computations. Code is available at [this https URL](https://github.com/uyzhang/JSeg) (Jittor) and [this https URL](https://github.com/Visual-Attention-Network/SegNeXt) (Pytorch).
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/215688018-5d4c8366-7793-4fdf-9397-960a09fac951.png" width="70%"/>
-</div>
-
-## Results and models
-
-### ADE20K
-
-| Method  | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                              | download                                                                                                                                                                                                                                                                                                                                                                                   |
-| ------- | -------- | --------- | ------- | -------- | -------------- | ------ | ----- | ------------- | ----------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| SegNeXt | MSCAN-T  | 512x512   | 160000  | 17.88    | 52.38          | A100   | 41.50 | 42.59         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segnext/segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-t_1x16_512x512_adamw_160k_ade20k/segnext_mscan-t_1x16_512x512_adamw_160k_ade20k_20230210_140244-05bd8466.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-t_1x16_512x512_adamw_160k_ade20k/segnext_mscan-t_1x16_512x512_adamw_160k_ade20k_20230210_140244.log.json) |
-| SegNeXt | MSCAN-S  | 512x512   | 160000  | 21.47    | 42.27          | A100   | 44.16 | 45.81         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segnext/segnext_mscan-s_1xb16-adamw-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-s_1x16_512x512_adamw_160k_ade20k/segnext_mscan-s_1x16_512x512_adamw_160k_ade20k_20230214_113014-43013668.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-s_1x16_512x512_adamw_160k_ade20k/segnext_mscan-s_1x16_512x512_adamw_160k_ade20k_20230214_113014.log.json) |
-| SegNeXt | MSCAN-B  | 512x512   | 160000  | 31.03    | 35.15          | A100   | 48.03 | 49.68         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segnext/segnext_mscan-b_1xb16-adamw-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-b_1x16_512x512_adamw_160k_ade20k/segnext_mscan-b_1x16_512x512_adamw_160k_ade20k_20230209_172053-b6f6c70c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-b_1x16_512x512_adamw_160k_ade20k/segnext_mscan-b_1x16_512x512_adamw_160k_ade20k_20230209_172053.log.json) |
-| SegNeXt | MSCAN-L  | 512x512   | 160000  | 43.32    | 22.91          | A100   | 50.99 | 52.10         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segnext/segnext_mscan-l_1xb16-adamw-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-l_1x16_512x512_adamw_160k_ade20k/segnext_mscan-l_1x16_512x512_adamw_160k_ade20k_20230209_172055-19b14b63.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-l_1x16_512x512_adamw_160k_ade20k/segnext_mscan-l_1x16_512x512_adamw_160k_ade20k_20230209_172055.log.json) |
-
-Note:
-
-- When we integrated SegNeXt into MMSegmentation, we modified some layers' names to make them more precise and concise without changing the model architecture. Therefore, the keys of pre-trained weights are different from the [original weights](https://cloud.tsinghua.edu.cn/d/c15b25a6745946618462/), but don't worry about these changes. we have converted them and uploaded the checkpoints, you might find URL of pre-trained checkpoints in config files and can use them directly for training.
-
-- The total batch size is 16. We trained for SegNeXt with a single GPU as the performance degrades significantly when using`SyncBN` (mainly in `OverlapPatchEmbed` modules of `MSCAN`) of PyTorch 1.9.
-
-- There will be subtle differences when model testing as Non-negative Matrix Factorization (NMF) in `LightHamHead` will be initialized randomly. To control this randomness, please set the random seed when model testing. You can modify [`./tools/test.py`](https://github.com/open-mmlab/mmsegmentation/blob/main/tools/test.py) like:
-
-```python
-def main():
-    from mmengine.runner import seg_random_seed
-    random_seed = xxx # set random seed recorded in training log
-    set_random_seed(random_seed, deterministic=False)
-    ...
-```
-
-- This model performance is sensitive to the seed values used, please refer to the log file for the specific settings of the seed. If you choose a different seed, the results might differ from the table results. Take SegNeXt Large for example, its results range from 49.60 to 51.0.
-
-## Citation
-
-```bibtex
-@article{guo2022segnext,
-  title={SegNeXt: Rethinking Convolutional Attention Design for Semantic Segmentation},
-  author={Guo, Meng-Hao and Lu, Cheng-Ze and Hou, Qibin and Liu, Zhengning and Cheng, Ming-Ming and Hu, Shi-Min},
-  journal={arXiv preprint arXiv:2209.08575},
-  year={2022}
-}
-```
diff --git a/mmsegmentation/configs/segnext/metafile.yaml b/mmsegmentation/configs/segnext/metafile.yaml
deleted file mode 100644
index 3c8ff5b..0000000
--- a/mmsegmentation/configs/segnext/metafile.yaml
+++ /dev/null
@@ -1,109 +0,0 @@
-Collections:
-- Name: SegNeXt
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - ADE20K
-  Paper:
-    Title: 'SegNeXt: Rethinking Convolutional Attention Design for Semantic Segmentation'
-    URL: https://arxiv.org/abs/2209.08575
-  README: configs/segnext/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512
-  In Collection: SegNeXt
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 41.5
-      mIoU(ms+flip): 42.59
-  Config: configs/segnext/segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - MSCAN-T
-    - SegNeXt
-    Training Resources: 1x A100 GPUS
-    Memory (GB): 17.88
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-t_1x16_512x512_adamw_160k_ade20k/segnext_mscan-t_1x16_512x512_adamw_160k_ade20k_20230210_140244-05bd8466.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-t_1x16_512x512_adamw_160k_ade20k/segnext_mscan-t_1x16_512x512_adamw_160k_ade20k_20230210_140244.log.json
-  Paper:
-    Title: 'SegNeXt: Rethinking Convolutional Attention Design for Semantic Segmentation'
-    URL: https://arxiv.org/abs/2209.08575
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/backbones/mscan.py#L328
-  Framework: PyTorch
-- Name: segnext_mscan-s_1xb16-adamw-160k_ade20k-512x512
-  In Collection: SegNeXt
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 44.16
-      mIoU(ms+flip): 45.81
-  Config: configs/segnext/segnext_mscan-s_1xb16-adamw-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - MSCAN-S
-    - SegNeXt
-    Training Resources: 1x A100 GPUS
-    Memory (GB): 21.47
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-s_1x16_512x512_adamw_160k_ade20k/segnext_mscan-s_1x16_512x512_adamw_160k_ade20k_20230214_113014-43013668.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-s_1x16_512x512_adamw_160k_ade20k/segnext_mscan-s_1x16_512x512_adamw_160k_ade20k_20230214_113014.log.json
-  Paper:
-    Title: 'SegNeXt: Rethinking Convolutional Attention Design for Semantic Segmentation'
-    URL: https://arxiv.org/abs/2209.08575
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/backbones/mscan.py#L328
-  Framework: PyTorch
-- Name: segnext_mscan-b_1xb16-adamw-160k_ade20k-512x512
-  In Collection: SegNeXt
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 48.03
-      mIoU(ms+flip): 49.68
-  Config: configs/segnext/segnext_mscan-b_1xb16-adamw-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - MSCAN-B
-    - SegNeXt
-    Training Resources: 1x A100 GPUS
-    Memory (GB): 31.03
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-b_1x16_512x512_adamw_160k_ade20k/segnext_mscan-b_1x16_512x512_adamw_160k_ade20k_20230209_172053-b6f6c70c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-b_1x16_512x512_adamw_160k_ade20k/segnext_mscan-b_1x16_512x512_adamw_160k_ade20k_20230209_172053.log.json
-  Paper:
-    Title: 'SegNeXt: Rethinking Convolutional Attention Design for Semantic Segmentation'
-    URL: https://arxiv.org/abs/2209.08575
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/backbones/mscan.py#L328
-  Framework: PyTorch
-- Name: segnext_mscan-l_1xb16-adamw-160k_ade20k-512x512
-  In Collection: SegNeXt
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 50.99
-      mIoU(ms+flip): 52.1
-  Config: configs/segnext/segnext_mscan-l_1xb16-adamw-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - MSCAN-L
-    - SegNeXt
-    Training Resources: 1x A100 GPUS
-    Memory (GB): 43.32
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-l_1x16_512x512_adamw_160k_ade20k/segnext_mscan-l_1x16_512x512_adamw_160k_ade20k_20230209_172055-19b14b63.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/segnext/segnext_mscan-l_1x16_512x512_adamw_160k_ade20k/segnext_mscan-l_1x16_512x512_adamw_160k_ade20k_20230209_172055.log.json
-  Paper:
-    Title: 'SegNeXt: Rethinking Convolutional Attention Design for Semantic Segmentation'
-    URL: https://arxiv.org/abs/2209.08575
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/backbones/mscan.py#L328
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/segnext/segnext_mscan-b_1xb16-adamw-160k_ade20k-512x512.py b/mmsegmentation/configs/segnext/segnext_mscan-b_1xb16-adamw-160k_ade20k-512x512.py
deleted file mode 100644
index 000f448..0000000
--- a/mmsegmentation/configs/segnext/segnext_mscan-b_1xb16-adamw-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,28 +0,0 @@
-_base_ = './segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512.py'
-
-# model settings
-checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segnext/mscan_b_20230227-3ab7d230.pth'  # noqa
-ham_norm_cfg = dict(type='GN', num_groups=32, requires_grad=True)
-model = dict(
-    type='EncoderDecoder',
-    backbone=dict(
-        embed_dims=[64, 128, 320, 512],
-        depths=[3, 3, 12, 3],
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file),
-        drop_path_rate=0.1,
-        norm_cfg=dict(type='BN', requires_grad=True)),
-    decode_head=dict(
-        type='LightHamHead',
-        in_channels=[128, 320, 512],
-        in_index=[1, 2, 3],
-        channels=512,
-        ham_channels=512,
-        dropout_ratio=0.1,
-        num_classes=150,
-        norm_cfg=ham_norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/segnext/segnext_mscan-l_1xb16-adamw-160k_ade20k-512x512.py b/mmsegmentation/configs/segnext/segnext_mscan-l_1xb16-adamw-160k_ade20k-512x512.py
deleted file mode 100644
index 212d0a8..0000000
--- a/mmsegmentation/configs/segnext/segnext_mscan-l_1xb16-adamw-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,27 +0,0 @@
-_base_ = './segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512.py'
-# model settings
-checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segnext/mscan_l_20230227-cef260d4.pth'  # noqa
-ham_norm_cfg = dict(type='GN', num_groups=32, requires_grad=True)
-model = dict(
-    type='EncoderDecoder',
-    backbone=dict(
-        embed_dims=[64, 128, 320, 512],
-        depths=[3, 5, 27, 3],
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file),
-        drop_path_rate=0.3,
-        norm_cfg=dict(type='BN', requires_grad=True)),
-    decode_head=dict(
-        type='LightHamHead',
-        in_channels=[128, 320, 512],
-        in_index=[1, 2, 3],
-        channels=1024,
-        ham_channels=1024,
-        dropout_ratio=0.1,
-        num_classes=150,
-        norm_cfg=ham_norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/segnext/segnext_mscan-s_1xb16-adamw-160k_ade20k-512x512.py b/mmsegmentation/configs/segnext/segnext_mscan-s_1xb16-adamw-160k_ade20k-512x512.py
deleted file mode 100644
index 9a90779..0000000
--- a/mmsegmentation/configs/segnext/segnext_mscan-s_1xb16-adamw-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,27 +0,0 @@
-_base_ = './segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512.py'
-# model settings
-checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segnext/mscan_s_20230227-f33ccdf2.pth'  # noqa
-ham_norm_cfg = dict(type='GN', num_groups=32, requires_grad=True)
-model = dict(
-    type='EncoderDecoder',
-    backbone=dict(
-        embed_dims=[64, 128, 320, 512],
-        depths=[2, 2, 4, 2],
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file),
-        norm_cfg=dict(type='BN', requires_grad=True)),
-    decode_head=dict(
-        type='LightHamHead',
-        in_channels=[128, 320, 512],
-        in_index=[1, 2, 3],
-        channels=256,
-        ham_channels=256,
-        ham_kwargs=dict(MD_R=16),
-        dropout_ratio=0.1,
-        num_classes=150,
-        norm_cfg=ham_norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/segnext/segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512.py b/mmsegmentation/configs/segnext/segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512.py
deleted file mode 100644
index c8d6da8..0000000
--- a/mmsegmentation/configs/segnext/segnext_mscan-t_1xb16-adamw-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,84 +0,0 @@
-_base_ = [
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py',
-    '../_base_/datasets/ade20k.py'
-]
-# model settings
-checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/segnext/mscan_t_20230227-119e8c9f.pth'  # noqa
-ham_norm_cfg = dict(type='GN', num_groups=32, requires_grad=True)
-crop_size = (512, 512)
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    mean=[123.675, 116.28, 103.53],
-    std=[58.395, 57.12, 57.375],
-    bgr_to_rgb=True,
-    pad_val=0,
-    seg_pad_val=255,
-    size=(512, 512),
-    test_cfg=dict(size_divisor=32))
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    pretrained=None,
-    backbone=dict(
-        type='MSCAN',
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file),
-        embed_dims=[32, 64, 160, 256],
-        mlp_ratios=[8, 8, 4, 4],
-        drop_rate=0.0,
-        drop_path_rate=0.1,
-        depths=[3, 3, 5, 2],
-        attention_kernel_sizes=[5, [1, 7], [1, 11], [1, 21]],
-        attention_kernel_paddings=[2, [0, 3], [0, 5], [0, 10]],
-        act_cfg=dict(type='GELU'),
-        norm_cfg=dict(type='BN', requires_grad=True)),
-    decode_head=dict(
-        type='LightHamHead',
-        in_channels=[64, 160, 256],
-        in_index=[1, 2, 3],
-        channels=256,
-        ham_channels=256,
-        dropout_ratio=0.1,
-        num_classes=150,
-        norm_cfg=ham_norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
-        ham_kwargs=dict(
-            MD_S=1,
-            MD_R=16,
-            train_steps=6,
-            eval_steps=7,
-            inv_t=100,
-            rand_init=True)),
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
-
-# dataset settings
-train_dataloader = dict(batch_size=16)
-
-# optimizer
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
-    paramwise_cfg=dict(
-        custom_keys={
-            'pos_block': dict(decay_mult=0.),
-            'norm': dict(decay_mult=0.),
-            'head': dict(lr_mult=10.)
-        }))
-
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        power=1.0,
-        begin=1500,
-        end=160000,
-        eta_min=0.0,
-        by_epoch=False,
-    )
-]
diff --git a/mmsegmentation/configs/sem_fpn/README.md b/mmsegmentation/configs/sem_fpn/README.md
deleted file mode 100644
index 697cf50..0000000
--- a/mmsegmentation/configs/sem_fpn/README.md
+++ /dev/null
@@ -1,51 +0,0 @@
-# Semantic FPN
-
-> [Panoptic Feature Pyramid Networks](https://arxiv.org/abs/1901.02446)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/facebookresearch/detectron2">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fpn_head.py#L12">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-The recently introduced panoptic segmentation task has renewed our community's interest in unifying the tasks of instance segmentation (for thing classes) and semantic segmentation (for stuff classes). However, current state-of-the-art methods for this joint task use separate and dissimilar networks for instance and semantic segmentation, without performing any shared computation. In this work, we aim to unify these methods at the architectural level, designing a single network for both tasks. Our approach is to endow Mask R-CNN, a popular instance segmentation method, with a semantic segmentation branch using a shared Feature Pyramid Network (FPN) backbone. Surprisingly, this simple baseline not only remains effective for instance segmentation, but also yields a lightweight, top-performing method for semantic segmentation. In this work, we perform a detailed study of this minimally extended version of Mask R-CNN with FPN, which we refer to as Panoptic FPN, and show it is a robust and accurate baseline for both tasks. Given its effectiveness and conceptual simplicity, we hope our method can serve as a strong baseline and aid future research in panoptic segmentation.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142902694-03ed2131-9104-467b-ace1-c74c62fb7177.png" width="60%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                    | download                                                                                                                                                                                                                                                                                                                           |
-| ------ | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | ------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| FPN    | R-50     | 512x1024  |   80000 |      2.8 | 13.54          | V100   | 74.52 | 76.08         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/sem_fpn/fpn_r50_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r50_512x1024_80k_cityscapes/fpn_r50_512x1024_80k_cityscapes_20200717_021437-94018a0d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r50_512x1024_80k_cityscapes/fpn_r50_512x1024_80k_cityscapes-20200717_021437.log.json)     |
-| FPN    | R-101    | 512x1024  |   80000 |      3.9 | 10.29          | V100   | 75.80 | 77.40         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/sem_fpn/fpn_r101_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r101_512x1024_80k_cityscapes/fpn_r101_512x1024_80k_cityscapes_20200717_012416-c5800d4c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r101_512x1024_80k_cityscapes/fpn_r101_512x1024_80k_cityscapes-20200717_012416.log.json) |
-
-### ADE20K
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                | download                                                                                                                                                                                                                                                                                                           |
-| ------ | -------- | --------- | ------: | -------: | -------------- | ------ | ----: | ------------- | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| FPN    | R-50     | 512x512   |  160000 |      4.9 | 55.77          | V100   | 37.49 | 39.09         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/sem_fpn/fpn_r50_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r50_512x512_160k_ade20k/fpn_r50_512x512_160k_ade20k_20200718_131734-5b5a6ab9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r50_512x512_160k_ade20k/fpn_r50_512x512_160k_ade20k-20200718_131734.log.json)     |
-| FPN    | R-101    | 512x512   |  160000 |      5.9 | 40.58          | V100   | 39.35 | 40.72         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/sem_fpn/fpn_r101_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r101_512x512_160k_ade20k/fpn_r101_512x512_160k_ade20k_20200718_131734-306b5004.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r101_512x512_160k_ade20k/fpn_r101_512x512_160k_ade20k-20200718_131734.log.json) |
-
-## Citation
-
-```bibtex
-@inproceedings{kirillov2019panoptic,
-  title={Panoptic feature pyramid networks},
-  author={Kirillov, Alexander and Girshick, Ross and He, Kaiming and Doll{\'a}r, Piotr},
-  booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
-  pages={6399--6408},
-  year={2019}
-}
-```
diff --git a/mmsegmentation/configs/sem_fpn/fpn_r101_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/sem_fpn/fpn_r101_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index 1e9bcfb..0000000
--- a/mmsegmentation/configs/sem_fpn/fpn_r101_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './fpn_r50_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/sem_fpn/fpn_r101_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/sem_fpn/fpn_r101_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index adad1a4..0000000
--- a/mmsegmentation/configs/sem_fpn/fpn_r101_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,5 +0,0 @@
-_base_ = './fpn_r50_4xb4-160k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/sem_fpn/fpn_r50_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/sem_fpn/fpn_r50_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index bf71d38..0000000
--- a/mmsegmentation/configs/sem_fpn/fpn_r50_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/fpn_r50.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/sem_fpn/fpn_r50_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/sem_fpn/fpn_r50_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 4e4bc57..0000000
--- a/mmsegmentation/configs/sem_fpn/fpn_r50_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = [
-    '../_base_/models/fpn_r50.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor, decode_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/sem_fpn/metafile.yaml b/mmsegmentation/configs/sem_fpn/metafile.yaml
deleted file mode 100644
index e734897..0000000
--- a/mmsegmentation/configs/sem_fpn/metafile.yaml
+++ /dev/null
@@ -1,110 +0,0 @@
-Collections:
-- Name: FPN
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-    - ADE20K
-  Paper:
-    Title: Panoptic Feature Pyramid Networks
-    URL: https://arxiv.org/abs/1901.02446
-  README: configs/sem_fpn/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: fpn_r50_4xb2-80k_cityscapes-512x1024
-  In Collection: FPN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 74.52
-      mIoU(ms+flip): 76.08
-  Config: configs/sem_fpn/fpn_r50_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50
-    - FPN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 2.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r50_512x1024_80k_cityscapes/fpn_r50_512x1024_80k_cityscapes_20200717_021437-94018a0d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r50_512x1024_80k_cityscapes/fpn_r50_512x1024_80k_cityscapes-20200717_021437.log.json
-  Paper:
-    Title: Panoptic Feature Pyramid Networks
-    URL: https://arxiv.org/abs/1901.02446
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fpn_head.py#L12
-  Framework: PyTorch
-- Name: fpn_r101_4xb2-80k_cityscapes-512x1024
-  In Collection: FPN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 75.8
-      mIoU(ms+flip): 77.4
-  Config: configs/sem_fpn/fpn_r101_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101
-    - FPN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 3.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r101_512x1024_80k_cityscapes/fpn_r101_512x1024_80k_cityscapes_20200717_012416-c5800d4c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r101_512x1024_80k_cityscapes/fpn_r101_512x1024_80k_cityscapes-20200717_012416.log.json
-  Paper:
-    Title: Panoptic Feature Pyramid Networks
-    URL: https://arxiv.org/abs/1901.02446
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fpn_head.py#L12
-  Framework: PyTorch
-- Name: fpn_r50_4xb4-160k_ade20k-512x512
-  In Collection: FPN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 37.49
-      mIoU(ms+flip): 39.09
-  Config: configs/sem_fpn/fpn_r50_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50
-    - FPN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 4.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r50_512x512_160k_ade20k/fpn_r50_512x512_160k_ade20k_20200718_131734-5b5a6ab9.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r50_512x512_160k_ade20k/fpn_r50_512x512_160k_ade20k-20200718_131734.log.json
-  Paper:
-    Title: Panoptic Feature Pyramid Networks
-    URL: https://arxiv.org/abs/1901.02446
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fpn_head.py#L12
-  Framework: PyTorch
-- Name: fpn_r101_4xb4-160k_ade20k-512x512
-  In Collection: FPN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 39.35
-      mIoU(ms+flip): 40.72
-  Config: configs/sem_fpn/fpn_r101_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101
-    - FPN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 5.9
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r101_512x512_160k_ade20k/fpn_r101_512x512_160k_ade20k_20200718_131734-306b5004.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/sem_fpn/fpn_r101_512x512_160k_ade20k/fpn_r101_512x512_160k_ade20k-20200718_131734.log.json
-  Paper:
-    Title: Panoptic Feature Pyramid Networks
-    URL: https://arxiv.org/abs/1901.02446
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/fpn_head.py#L12
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/setr/README.md b/mmsegmentation/configs/setr/README.md
deleted file mode 100644
index 15be6ec..0000000
--- a/mmsegmentation/configs/setr/README.md
+++ /dev/null
@@ -1,74 +0,0 @@
-# SETR
-
-> [Rethinking Semantic Segmentation from a Sequence-to-Sequence Perspective with Transformers](https://arxiv.org/abs/2012.15840)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/fudan-zvg/SETR">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/setr_up_head.py#L11">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Most recent semantic segmentation methods adopt a fully-convolutional network (FCN) with an encoder-decoder architecture. The encoder progressively reduces the spatial resolution and learns more abstract/semantic visual concepts with larger receptive fields. Since context modeling is critical for segmentation, the latest efforts have been focused on increasing the receptive field, through either dilated/atrous convolutions or inserting attention modules. However, the encoder-decoder based FCN architecture remains unchanged. In this paper, we aim to provide an alternative perspective by treating semantic segmentation as a sequence-to-sequence prediction task. Specifically, we deploy a pure transformer (ie, without convolution and resolution reduction) to encode an image as a sequence of patches. With the global context modeled in every layer of the transformer, this encoder can be combined with a simple decoder to provide a powerful segmentation model, termed SEgmentation TRansformer (SETR). Extensive experiments show that SETR achieves new state of the art on ADE20K (50.28% mIoU), Pascal Context (55.83% mIoU) and competitive results on Cityscapes. Particularly, we achieve the first position in the highly competitive ADE20K test server leaderboard on the day of submission.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142902777-ee2d34b7-a631-4fa7-ad68-118ff5716afe.png" width="80%"/>
-</div>
-
-```None
-This head has two version head.
-```
-
-## Usage
-
-You can download the pretrain from [here](https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-vitjx/jx_vit_large_p16_384-b3be5167.pth). Then you can convert its keys with the script `vit2mmseg.py` in the tools directory.
-
-```shell
-python tools/model_converters/vit2mmseg.py ${PRETRAIN_PATH} ${STORE_PATH}
-```
-
-E.g.
-
-```shell
-python tools/model_converters/vit2mmseg.py \
-jx_vit_large_p16_384-b3be5167.pth pretrain/vit_large_p16.pth
-```
-
-This script convert the model from `PRETRAIN_PATH` and store the converted model in `STORE_PATH`.
-
-## Results and models
-
-### ADE20K
-
-| Method     | Backbone | Crop Size | Batch Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                     | download                                                                                                                                                                                                                                                                                                                             |
-| ---------- | -------- | --------- | ---------- | ------- | -------- | -------------- | ------ | ----- | ------------: | -------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| SETR Naive | ViT-L    | 512x512   | 16         | 160000  | 18.40    | 4.72           | V100   | 48.28 |         49.56 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/setr/setr_vit-l_naive_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_naive_512x512_160k_b16_ade20k/setr_naive_512x512_160k_b16_ade20k_20210619_191258-061f24f5.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_naive_512x512_160k_b16_ade20k/setr_naive_512x512_160k_b16_ade20k_20210619_191258.log.json) |
-| SETR PUP   | ViT-L    | 512x512   | 16         | 160000  | 19.54    | 4.50           | V100   | 48.24 |         49.99 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/setr/setr_vit-l_pup_8xb2-160k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_pup_512x512_160k_b16_ade20k/setr_pup_512x512_160k_b16_ade20k_20210619_191343-7e0ce826.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_pup_512x512_160k_b16_ade20k/setr_pup_512x512_160k_b16_ade20k_20210619_191343.log.json)         |
-| SETR MLA   | ViT-L    | 512x512   | 8          | 160000  | 10.96    | -              | V100   | 47.34 |         49.05 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/setr/setr_vit-l-mla_8xb1-160k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_512x512_160k_b8_ade20k/setr_mla_512x512_160k_b8_ade20k_20210619_191118-c6d21df0.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_512x512_160k_b8_ade20k/setr_mla_512x512_160k_b8_ade20k_20210619_191118.log.json)             |
-| SETR MLA   | ViT-L    | 512x512   | 16         | 160000  | 17.30    | 5.25           | V100   | 47.39 |         49.37 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/setr/setr_vit-l_mla_8xb2-160k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_512x512_160k_b16_ade20k/setr_mla_512x512_160k_b16_ade20k_20210619_191057-f9741de7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_512x512_160k_b16_ade20k/setr_mla_512x512_160k_b16_ade20k_20210619_191057.log.json)         |
-
-### Cityscapes
-
-| Method     | Backbone | Crop Size | Batch Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                        | download                                                                                                                                                                                                                                                                                                                                                                                 |
-| ---------- | -------- | --------- | ---------- | ------- | -------- | -------------- | ------ | ----- | ------------: | ----------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| SETR Naive | ViT-L    | 768x768   | 8          | 80000   | 24.06    | 0.39           | V100   | 78.10 |         80.22 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/setr/setr_vit-l_naive_8xb1-80k_cityscapes-768x768.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_naive_vit-large_8x1_768x768_80k_cityscapes/setr_naive_vit-large_8x1_768x768_80k_cityscapes_20211123_000505-20728e80.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_naive_vit-large_8x1_768x768_80k_cityscapes/setr_naive_vit-large_8x1_768x768_80k_cityscapes_20211123_000505.log.json) |
-| SETR PUP   | ViT-L    | 768x768   | 8          | 80000   | 27.96    | 0.37           | V100   | 79.21 |         81.02 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/setr/setr_vit-l_pup_8xb1-80k_cityscapes-768x768.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_pup_vit-large_8x1_768x768_80k_cityscapes/setr_pup_vit-large_8x1_768x768_80k_cityscapes_20211122_155115-f6f37b8f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_pup_vit-large_8x1_768x768_80k_cityscapes/setr_pup_vit-large_8x1_768x768_80k_cityscapes_20211122_155115.log.json)         |
-| SETR MLA   | ViT-L    | 768x768   | 8          | 80000   | 24.10    | 0.41           | V100   | 77.00 |         79.59 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/setr/setr_vit-l_mla_8xb1-80k_cityscapes-768x768.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_vit-large_8x1_768x768_80k_cityscapes/setr_mla_vit-large_8x1_768x768_80k_cityscapes_20211119_101003-7f8dccbe.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_vit-large_8x1_768x768_80k_cityscapes/setr_mla_vit-large_8x1_768x768_80k_cityscapes_20211119_101003.log.json)         |
-
-## Citation
-
-```bibtex
-@article{zheng2020rethinking,
-  title={Rethinking Semantic Segmentation from a Sequence-to-Sequence Perspective with Transformers},
-  author={Zheng, Sixiao and Lu, Jiachen and Zhao, Hengshuang and Zhu, Xiatian and Luo, Zekun and Wang, Yabiao and Fu, Yanwei and Feng, Jianfeng and Xiang, Tao and Torr, Philip HS and others},
-  journal={arXiv preprint arXiv:2012.15840},
-  year={2020}
-}
-```
diff --git a/mmsegmentation/configs/setr/metafile.yaml b/mmsegmentation/configs/setr/metafile.yaml
deleted file mode 100644
index 8e6bc08..0000000
--- a/mmsegmentation/configs/setr/metafile.yaml
+++ /dev/null
@@ -1,197 +0,0 @@
-Collections:
-- Name: SETR
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - ADE20K
-    - Cityscapes
-  Paper:
-    Title: Rethinking Semantic Segmentation from a Sequence-to-Sequence Perspective
-      with Transformers
-    URL: https://arxiv.org/abs/2012.15840
-  README: configs/setr/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: setr_vit-l_naive_8xb2-160k_ade20k-512x512
-  In Collection: SETR
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 48.28
-      mIoU(ms+flip): 49.56
-  Config: configs/setr/setr_vit-l_naive_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - ViT-L
-    - SETR
-    - Naive
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 18.4
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_naive_512x512_160k_b16_ade20k/setr_naive_512x512_160k_b16_ade20k_20210619_191258-061f24f5.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_naive_512x512_160k_b16_ade20k/setr_naive_512x512_160k_b16_ade20k_20210619_191258.log.json
-  Paper:
-    Title: Rethinking Semantic Segmentation from a Sequence-to-Sequence Perspective
-      with Transformers
-    URL: https://arxiv.org/abs/2012.15840
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/setr_up_head.py#L11
-  Framework: PyTorch
-- Name: setr_vit-l_pup_8xb2-160k_ade20k-512x512
-  In Collection: SETR
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 48.24
-      mIoU(ms+flip): 49.99
-  Config: configs/setr/setr_vit-l_pup_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - ViT-L
-    - SETR
-    - PUP
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 19.54
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_pup_512x512_160k_b16_ade20k/setr_pup_512x512_160k_b16_ade20k_20210619_191343-7e0ce826.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_pup_512x512_160k_b16_ade20k/setr_pup_512x512_160k_b16_ade20k_20210619_191343.log.json
-  Paper:
-    Title: Rethinking Semantic Segmentation from a Sequence-to-Sequence Perspective
-      with Transformers
-    URL: https://arxiv.org/abs/2012.15840
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/setr_up_head.py#L11
-  Framework: PyTorch
-- Name: setr_vit-l-mla_8xb1-160k_ade20k-512x512
-  In Collection: SETR
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 47.34
-      mIoU(ms+flip): 49.05
-  Config: configs/setr/setr_vit-l-mla_8xb1-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 8
-    Architecture:
-    - ViT-L
-    - SETR
-    - MLA
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 10.96
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_512x512_160k_b8_ade20k/setr_mla_512x512_160k_b8_ade20k_20210619_191118-c6d21df0.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_512x512_160k_b8_ade20k/setr_mla_512x512_160k_b8_ade20k_20210619_191118.log.json
-  Paper:
-    Title: Rethinking Semantic Segmentation from a Sequence-to-Sequence Perspective
-      with Transformers
-    URL: https://arxiv.org/abs/2012.15840
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/setr_up_head.py#L11
-  Framework: PyTorch
-- Name: setr_vit-l_mla_8xb2-160k_ade20k-512x512
-  In Collection: SETR
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 47.39
-      mIoU(ms+flip): 49.37
-  Config: configs/setr/setr_vit-l_mla_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - ViT-L
-    - SETR
-    - MLA
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 17.3
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_512x512_160k_b16_ade20k/setr_mla_512x512_160k_b16_ade20k_20210619_191057-f9741de7.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_512x512_160k_b16_ade20k/setr_mla_512x512_160k_b16_ade20k_20210619_191057.log.json
-  Paper:
-    Title: Rethinking Semantic Segmentation from a Sequence-to-Sequence Perspective
-      with Transformers
-    URL: https://arxiv.org/abs/2012.15840
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/setr_up_head.py#L11
-  Framework: PyTorch
-- Name: setr_vit-l_naive_8xb1-80k_cityscapes-768x768
-  In Collection: SETR
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.1
-      mIoU(ms+flip): 80.22
-  Config: configs/setr/setr_vit-l_naive_8xb1-80k_cityscapes-768x768.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - ViT-L
-    - SETR
-    - Naive
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 24.06
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_naive_vit-large_8x1_768x768_80k_cityscapes/setr_naive_vit-large_8x1_768x768_80k_cityscapes_20211123_000505-20728e80.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_naive_vit-large_8x1_768x768_80k_cityscapes/setr_naive_vit-large_8x1_768x768_80k_cityscapes_20211123_000505.log.json
-  Paper:
-    Title: Rethinking Semantic Segmentation from a Sequence-to-Sequence Perspective
-      with Transformers
-    URL: https://arxiv.org/abs/2012.15840
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/setr_up_head.py#L11
-  Framework: PyTorch
-- Name: setr_vit-l_pup_8xb1-80k_cityscapes-768x768
-  In Collection: SETR
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.21
-      mIoU(ms+flip): 81.02
-  Config: configs/setr/setr_vit-l_pup_8xb1-80k_cityscapes-768x768.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - ViT-L
-    - SETR
-    - PUP
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 27.96
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_pup_vit-large_8x1_768x768_80k_cityscapes/setr_pup_vit-large_8x1_768x768_80k_cityscapes_20211122_155115-f6f37b8f.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_pup_vit-large_8x1_768x768_80k_cityscapes/setr_pup_vit-large_8x1_768x768_80k_cityscapes_20211122_155115.log.json
-  Paper:
-    Title: Rethinking Semantic Segmentation from a Sequence-to-Sequence Perspective
-      with Transformers
-    URL: https://arxiv.org/abs/2012.15840
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/setr_up_head.py#L11
-  Framework: PyTorch
-- Name: setr_vit-l_mla_8xb1-80k_cityscapes-768x768
-  In Collection: SETR
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.0
-      mIoU(ms+flip): 79.59
-  Config: configs/setr/setr_vit-l_mla_8xb1-80k_cityscapes-768x768.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - ViT-L
-    - SETR
-    - MLA
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 24.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_vit-large_8x1_768x768_80k_cityscapes/setr_mla_vit-large_8x1_768x768_80k_cityscapes_20211119_101003-7f8dccbe.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/setr/setr_mla_vit-large_8x1_768x768_80k_cityscapes/setr_mla_vit-large_8x1_768x768_80k_cityscapes_20211119_101003.log.json
-  Paper:
-    Title: Rethinking Semantic Segmentation from a Sequence-to-Sequence Perspective
-      with Transformers
-    URL: https://arxiv.org/abs/2012.15840
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/setr_up_head.py#L11
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/setr/setr_vit-l-mla_8xb1-160k_ade20k-512x512.py b/mmsegmentation/configs/setr/setr_vit-l-mla_8xb1-160k_ade20k-512x512.py
deleted file mode 100644
index 1c6e284..0000000
--- a/mmsegmentation/configs/setr/setr_vit-l-mla_8xb1-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,90 +0,0 @@
-_base_ = [
-    '../_base_/models/setr_mla.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained=None,
-    backbone=dict(
-        img_size=(512, 512),
-        drop_rate=0.,
-        init_cfg=dict(
-            type='Pretrained', checkpoint='pretrain/vit_large_p16.pth')),
-    decode_head=dict(num_classes=150),
-    auxiliary_head=[
-        dict(
-            type='FCNHead',
-            in_channels=256,
-            channels=256,
-            in_index=0,
-            dropout_ratio=0,
-            norm_cfg=norm_cfg,
-            act_cfg=dict(type='ReLU'),
-            num_convs=0,
-            kernel_size=1,
-            concat_input=False,
-            num_classes=150,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-        dict(
-            type='FCNHead',
-            in_channels=256,
-            channels=256,
-            in_index=1,
-            dropout_ratio=0,
-            norm_cfg=norm_cfg,
-            act_cfg=dict(type='ReLU'),
-            num_convs=0,
-            kernel_size=1,
-            concat_input=False,
-            num_classes=150,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-        dict(
-            type='FCNHead',
-            in_channels=256,
-            channels=256,
-            in_index=2,
-            dropout_ratio=0,
-            norm_cfg=norm_cfg,
-            act_cfg=dict(type='ReLU'),
-            num_convs=0,
-            kernel_size=1,
-            concat_input=False,
-            num_classes=150,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-        dict(
-            type='FCNHead',
-            in_channels=256,
-            channels=256,
-            in_index=3,
-            dropout_ratio=0,
-            norm_cfg=norm_cfg,
-            act_cfg=dict(type='ReLU'),
-            num_convs=0,
-            kernel_size=1,
-            concat_input=False,
-            num_classes=150,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-    ],
-    test_cfg=dict(mode='slide', crop_size=(512, 512), stride=(341, 341)),
-)
-
-optimizer = dict(lr=0.001, weight_decay=0.0)
-optim_wrapper = dict(
-    type='OptimWrapper',
-    optimizer=optimizer,
-    paramwise_cfg=dict(custom_keys={'head': dict(lr_mult=10.)}))
-# num_gpus: 8 -> batch_size: 8
-train_dataloader = dict(batch_size=1)
-val_dataloader = dict(batch_size=1)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/setr/setr_vit-l_mla_8xb1-80k_cityscapes-768x768.py b/mmsegmentation/configs/setr/setr_vit-l_mla_8xb1-80k_cityscapes-768x768.py
deleted file mode 100644
index 026557f..0000000
--- a/mmsegmentation/configs/setr/setr_vit-l_mla_8xb1-80k_cityscapes-768x768.py
+++ /dev/null
@@ -1,23 +0,0 @@
-_base_ = [
-    '../_base_/models/setr_mla.py', '../_base_/datasets/cityscapes_768x768.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (768, 768)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained=None,
-    backbone=dict(
-        drop_rate=0,
-        init_cfg=dict(
-            type='Pretrained', checkpoint='pretrain/vit_large_p16.pth')),
-    test_cfg=dict(mode='slide', crop_size=(768, 768), stride=(512, 512)))
-
-optimizer = dict(lr=0.002, weight_decay=0.0)
-optim_wrapper = dict(
-    type='OptimWrapper',
-    optimizer=optimizer,
-    paramwise_cfg=dict(custom_keys={'head': dict(lr_mult=10.)}))
-train_dataloader = dict(batch_size=1)
-val_dataloader = dict(batch_size=1)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/setr/setr_vit-l_mla_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/setr/setr_vit-l_mla_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 4d3fb7d..0000000
--- a/mmsegmentation/configs/setr/setr_vit-l_mla_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = ['./setr_vit-l-mla_8xb1-160k_ade20k-512x512.py']
-
-# num_gpus: 8 -> batch_size: 16
-train_dataloader = dict(batch_size=2)
-val_dataloader = dict(batch_size=1)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/setr/setr_vit-l_naive_8xb1-80k_cityscapes-768x768.py b/mmsegmentation/configs/setr/setr_vit-l_naive_8xb1-80k_cityscapes-768x768.py
deleted file mode 100644
index db49317..0000000
--- a/mmsegmentation/configs/setr/setr_vit-l_naive_8xb1-80k_cityscapes-768x768.py
+++ /dev/null
@@ -1,24 +0,0 @@
-_base_ = [
-    '../_base_/models/setr_naive.py',
-    '../_base_/datasets/cityscapes_768x768.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (768, 768)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained=None,
-    backbone=dict(
-        drop_rate=0.,
-        init_cfg=dict(
-            type='Pretrained', checkpoint='pretrain/vit_large_p16.pth')),
-    test_cfg=dict(mode='slide', crop_size=(768, 768), stride=(512, 512)))
-
-optimizer = dict(weight_decay=0.0)
-optim_wrapper = dict(
-    type='OptimWrapper',
-    optimizer=optimizer,
-    paramwise_cfg=dict(custom_keys={'head': dict(lr_mult=10.)}))
-train_dataloader = dict(batch_size=1)
-val_dataloader = dict(batch_size=1)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/setr/setr_vit-l_naive_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/setr/setr_vit-l_naive_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 109996c..0000000
--- a/mmsegmentation/configs/setr/setr_vit-l_naive_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,72 +0,0 @@
-_base_ = [
-    '../_base_/models/setr_naive.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained=None,
-    backbone=dict(
-        img_size=(512, 512),
-        drop_rate=0.,
-        init_cfg=dict(
-            type='Pretrained', checkpoint='pretrain/vit_large_p16.pth')),
-    decode_head=dict(num_classes=150),
-    auxiliary_head=[
-        dict(
-            type='SETRUPHead',
-            in_channels=1024,
-            channels=256,
-            in_index=0,
-            num_classes=150,
-            dropout_ratio=0,
-            norm_cfg=norm_cfg,
-            act_cfg=dict(type='ReLU'),
-            num_convs=2,
-            kernel_size=1,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-        dict(
-            type='SETRUPHead',
-            in_channels=1024,
-            channels=256,
-            in_index=1,
-            num_classes=150,
-            dropout_ratio=0,
-            norm_cfg=norm_cfg,
-            act_cfg=dict(type='ReLU'),
-            num_convs=2,
-            kernel_size=1,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-        dict(
-            type='SETRUPHead',
-            in_channels=1024,
-            channels=256,
-            in_index=2,
-            num_classes=150,
-            dropout_ratio=0,
-            norm_cfg=norm_cfg,
-            act_cfg=dict(type='ReLU'),
-            num_convs=2,
-            kernel_size=1,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4))
-    ],
-    test_cfg=dict(mode='slide', crop_size=(512, 512), stride=(341, 341)),
-)
-
-optimizer = dict(lr=0.01, weight_decay=0.0)
-optim_wrapper = dict(
-    type='OptimWrapper',
-    optimizer=optimizer,
-    paramwise_cfg=dict(custom_keys={'head': dict(lr_mult=10.)}))
-# num_gpus: 8 -> batch_size: 16
-train_dataloader = dict(batch_size=2)
-val_dataloader = dict(batch_size=1)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/setr/setr_vit-l_pup_8xb1-80k_cityscapes-768x768.py b/mmsegmentation/configs/setr/setr_vit-l_pup_8xb1-80k_cityscapes-768x768.py
deleted file mode 100644
index 999ab18..0000000
--- a/mmsegmentation/configs/setr/setr_vit-l_pup_8xb1-80k_cityscapes-768x768.py
+++ /dev/null
@@ -1,70 +0,0 @@
-_base_ = [
-    '../_base_/models/setr_pup.py', '../_base_/datasets/cityscapes_768x768.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (768, 768)
-data_preprocessor = dict(size=crop_size)
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-crop_size = (768, 768)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained=None,
-    backbone=dict(
-        drop_rate=0.,
-        init_cfg=dict(
-            type='Pretrained', checkpoint='pretrain/vit_large_p16.pth')),
-    auxiliary_head=[
-        dict(
-            type='SETRUPHead',
-            in_channels=1024,
-            channels=256,
-            in_index=0,
-            num_classes=19,
-            dropout_ratio=0,
-            norm_cfg=norm_cfg,
-            num_convs=2,
-            up_scale=4,
-            kernel_size=3,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-        dict(
-            type='SETRUPHead',
-            in_channels=1024,
-            channels=256,
-            in_index=1,
-            num_classes=19,
-            dropout_ratio=0,
-            norm_cfg=norm_cfg,
-            num_convs=2,
-            up_scale=4,
-            kernel_size=3,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-        dict(
-            type='SETRUPHead',
-            in_channels=1024,
-            channels=256,
-            in_index=2,
-            num_classes=19,
-            dropout_ratio=0,
-            norm_cfg=norm_cfg,
-            num_convs=2,
-            up_scale=4,
-            kernel_size=3,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4))
-    ],
-    test_cfg=dict(mode='slide', crop_size=crop_size, stride=(512, 512)))
-
-optimizer = dict(weight_decay=0.0)
-optim_wrapper = dict(
-    type='OptimWrapper',
-    optimizer=optimizer,
-    paramwise_cfg=dict(custom_keys={'head': dict(lr_mult=10.)}))
-
-train_dataloader = dict(batch_size=1)
-val_dataloader = dict(batch_size=1)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/setr/setr_vit-l_pup_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/setr/setr_vit-l_pup_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index e9bfb22..0000000
--- a/mmsegmentation/configs/setr/setr_vit-l_pup_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,72 +0,0 @@
-_base_ = [
-    '../_base_/models/setr_pup.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained=None,
-    backbone=dict(
-        img_size=(512, 512),
-        drop_rate=0.,
-        init_cfg=dict(
-            type='Pretrained', checkpoint='pretrain/vit_large_p16.pth')),
-    decode_head=dict(num_classes=150),
-    auxiliary_head=[
-        dict(
-            type='SETRUPHead',
-            in_channels=1024,
-            channels=256,
-            in_index=0,
-            num_classes=150,
-            dropout_ratio=0,
-            norm_cfg=norm_cfg,
-            act_cfg=dict(type='ReLU'),
-            num_convs=2,
-            kernel_size=3,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-        dict(
-            type='SETRUPHead',
-            in_channels=1024,
-            channels=256,
-            in_index=1,
-            num_classes=150,
-            dropout_ratio=0,
-            norm_cfg=norm_cfg,
-            act_cfg=dict(type='ReLU'),
-            num_convs=2,
-            kernel_size=3,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-        dict(
-            type='SETRUPHead',
-            in_channels=1024,
-            channels=256,
-            in_index=2,
-            num_classes=150,
-            dropout_ratio=0,
-            norm_cfg=norm_cfg,
-            act_cfg=dict(type='ReLU'),
-            num_convs=2,
-            kernel_size=3,
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-    ],
-    test_cfg=dict(mode='slide', crop_size=(512, 512), stride=(341, 341)),
-)
-
-optimizer = dict(lr=0.001, weight_decay=0.0)
-optim_wrapper = dict(
-    type='OptimWrapper',
-    optimizer=optimizer,
-    paramwise_cfg=dict(custom_keys={'head': dict(lr_mult=10.)}))
-# num_gpus: 8 -> batch_size: 16
-train_dataloader = dict(batch_size=2)
-val_dataloader = dict(batch_size=1)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/stdc/README.md b/mmsegmentation/configs/stdc/README.md
deleted file mode 100644
index 3e8bf60..0000000
--- a/mmsegmentation/configs/stdc/README.md
+++ /dev/null
@@ -1,73 +0,0 @@
-# STDC
-
-> [Rethinking BiSeNet For Real-time Semantic Segmentation](https://arxiv.org/abs/2104.13188)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/MichaelFan01/STDC-Seg">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/stdc.py#L394">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-BiSeNet has been proved to be a popular two-stream network for real-time segmentation. However, its principle of adding an extra path to encode spatial information is time-consuming, and the backbones borrowed from pretrained tasks, e.g., image classification, may be inefficient for image segmentation due to the deficiency of task-specific design. To handle these problems, we propose a novel and efficient structure named Short-Term Dense Concatenate network (STDC network) by removing structure redundancy. Specifically, we gradually reduce the dimension of feature maps and use the aggregation of them for image representation, which forms the basic module of STDC network. In the decoder, we propose a Detail Aggregation module by integrating the learning of spatial information into low-level layers in single-stream manner. Finally, the low-level features and deep features are fused to predict the final segmentation results. Extensive experiments on Cityscapes and CamVid dataset demonstrate the effectiveness of our method by achieving promising trade-off between segmentation accuracy and inference speed. On Cityscapes, we achieve 71.9% mIoU on the test set with a speed of 250.4 FPS on NVIDIA GTX 1080Ti, which is 45.2% faster than the latest methods, and achieve 76.8% mIoU with 97.0 FPS while inferring on higher resolution images.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/143640374-d0709587-edb2-4821-bb60-340035f6ad8f.png" width="60%"/>
-</div>
-
-## Usage
-
-We have provided [ImageNet Pretrained STDCNet Weights](https://drive.google.com/drive/folders/1wROFwRt8qWHD4jSo8Zu1gp1d6oYJ3ns1) models converted from [official repo](https://github.com/MichaelFan01/STDC-Seg).
-
-If you want to convert keys on your own to use official repositories' pre-trained models, we also provide a script [`stdc2mmseg.py`](../../tools/model_converters/stdc2mmseg.py) in the tools directory to convert the key of models from [the official repo](https://github.com/MichaelFan01/STDC-Seg) to MMSegmentation style.
-
-```shell
-python tools/model_converters/stdc2mmseg.py ${PRETRAIN_PATH} ${STORE_PATH} ${STDC_TYPE}
-```
-
-E.g.
-
-```shell
-python tools/model_converters/stdc2mmseg.py ./STDCNet813M_73.91.tar ./pretrained/stdc1.pth STDC1
-
-python tools/model_converters/stdc2mmseg.py ./STDCNet1446_76.47.tar ./pretrained/stdc2.pth STDC2
-```
-
-This script convert model from `PRETRAIN_PATH` and store the converted model in `STORE_PATH`.
-
-## Results and models
-
-### Cityscapes
-
-| Method | Backbone             | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                        | download                                                                                                                                                                                                                                                                                                                                             |
-| ------ | -------------------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------- | ----------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| STDC   | STDC1 (No Pretrain)  | 512x1024  |   80000 | 7.15     | 23.06          | V100   | 71.82 | 73.89         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/stdc/stdc1_4xb12-80k_cityscapes-512x1024.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc1_512x1024_80k_cityscapes/stdc1_512x1024_80k_cityscapes_20220224_073048-74e6920a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc1_512x1024_80k_cityscapes/stdc1_512x1024_80k_cityscapes_20220224_073048.log.json)                                     |
-| STDC   | STDC1                | 512x1024  |   80000 | -        | -              | V100   | 74.94 | 76.97         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/stdc/stdc1_in1k-pre_4xb12-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc1_in1k-pre_512x1024_80k_cityscapes/stdc1_in1k-pre_512x1024_80k_cityscapes_20220224_141648-3d4c2981.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc1_in1k-pre_512x1024_80k_cityscapes/stdc1_in1k-pre_512x1024_80k_cityscapes_20220224_141648.log.json) |
-| STDC   | STDC2  (No Pretrain) | 512x1024  |   80000 | 8.27     | 23.71          | V100   | 73.15 | 76.13         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/stdc/stdc2_4xb12-80k_cityscapes-512x1024.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc2_512x1024_80k_cityscapes/stdc2_512x1024_80k_cityscapes_20220222_132015-fb1e3a1a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc2_512x1024_80k_cityscapes/stdc2_512x1024_80k_cityscapes_20220222_132015.log.json)                                     |
-| STDC   | STDC2                | 512x1024  |   80000 | -        | -              | V100   | 76.67 | 78.67         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/stdc/stdc2_in1k-pre_4xb12-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc2_in1k-pre_512x1024_80k_cityscapes/stdc2_in1k-pre_512x1024_80k_cityscapes_20220224_073048-1f8f0f6c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc2_in1k-pre_512x1024_80k_cityscapes/stdc2_in1k-pre_512x1024_80k_cityscapes_20220224_073048.log.json) |
-
-Note:
-
-- For STDC on Cityscapes dataset, default setting is 4 GPUs with 12 samples per GPU in training.
-- `No Pretrain` means the model is trained from scratch.
-- The FPS is for reference only. The environment is also different from paper setting, whose input size is `512x1024` and `768x1536`, i.e., 50% and 75% of our input size, respectively and using TensorRT.
-- The parameter `fusion_kernel` in `STDCHead` is not learnable. In official repo, `find_unused_parameters=True` is set [here](https://github.com/MichaelFan01/STDC-Seg/blob/59ff37fbd693b99972c76fcefe97caa14aeb619f/train.py#L220). You may check it by printing model parameters of original repo on your own.
-
-## Citation
-
-```bibtex
-@inproceedings{fan2021rethinking,
-  title={Rethinking BiSeNet For Real-time Semantic Segmentation},
-  author={Fan, Mingyuan and Lai, Shenqi and Huang, Junshi and Wei, Xiaoming and Chai, Zhenhua and Luo, Junfeng and Wei, Xiaolin},
-  booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
-  pages={9716--9725},
-  year={2021}
-}
-```
diff --git a/mmsegmentation/configs/stdc/metafile.yaml b/mmsegmentation/configs/stdc/metafile.yaml
deleted file mode 100644
index 93cb14f..0000000
--- a/mmsegmentation/configs/stdc/metafile.yaml
+++ /dev/null
@@ -1,107 +0,0 @@
-Collections:
-- Name: STDC
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-  Paper:
-    Title: Rethinking BiSeNet For Real-time Semantic Segmentation
-    URL: https://arxiv.org/abs/2104.13188
-  README: configs/stdc/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: stdc1_4xb12-80k_cityscapes-512x1024
-  In Collection: STDC
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 71.82
-      mIoU(ms+flip): 73.89
-  Config: configs/stdc/stdc1_4xb12-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 48
-    Architecture:
-    - STDC1
-    - STDC
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 7.15
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc1_512x1024_80k_cityscapes/stdc1_512x1024_80k_cityscapes_20220224_073048-74e6920a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc1_512x1024_80k_cityscapes/stdc1_512x1024_80k_cityscapes_20220224_073048.log.json
-  Paper:
-    Title: Rethinking BiSeNet For Real-time Semantic Segmentation
-    URL: https://arxiv.org/abs/2104.13188
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/stdc.py#L394
-  Framework: PyTorch
-- Name: stdc1_in1k-pre_4xb12-80k_cityscapes-512x1024
-  In Collection: STDC
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 74.94
-      mIoU(ms+flip): 76.97
-  Config: configs/stdc/stdc1_in1k-pre_4xb12-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 48
-    Architecture:
-    - STDC1
-    - STDC
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc1_in1k-pre_512x1024_80k_cityscapes/stdc1_in1k-pre_512x1024_80k_cityscapes_20220224_141648-3d4c2981.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc1_in1k-pre_512x1024_80k_cityscapes/stdc1_in1k-pre_512x1024_80k_cityscapes_20220224_141648.log.json
-  Paper:
-    Title: Rethinking BiSeNet For Real-time Semantic Segmentation
-    URL: https://arxiv.org/abs/2104.13188
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/stdc.py#L394
-  Framework: PyTorch
-- Name: stdc2_4xb12-80k_cityscapes-512x1024
-  In Collection: STDC
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 73.15
-      mIoU(ms+flip): 76.13
-  Config: configs/stdc/stdc2_4xb12-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 48
-    Architecture:
-    - STDC2
-    - STDC
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.27
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc2_512x1024_80k_cityscapes/stdc2_512x1024_80k_cityscapes_20220222_132015-fb1e3a1a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc2_512x1024_80k_cityscapes/stdc2_512x1024_80k_cityscapes_20220222_132015.log.json
-  Paper:
-    Title: Rethinking BiSeNet For Real-time Semantic Segmentation
-    URL: https://arxiv.org/abs/2104.13188
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/stdc.py#L394
-  Framework: PyTorch
-- Name: stdc2_in1k-pre_4xb12-80k_cityscapes-512x1024
-  In Collection: STDC
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 76.67
-      mIoU(ms+flip): 78.67
-  Config: configs/stdc/stdc2_in1k-pre_4xb12-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 48
-    Architecture:
-    - STDC2
-    - STDC
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc2_in1k-pre_512x1024_80k_cityscapes/stdc2_in1k-pre_512x1024_80k_cityscapes_20220224_073048-1f8f0f6c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/stdc/stdc2_in1k-pre_512x1024_80k_cityscapes/stdc2_in1k-pre_512x1024_80k_cityscapes_20220224_073048.log.json
-  Paper:
-    Title: Rethinking BiSeNet For Real-time Semantic Segmentation
-    URL: https://arxiv.org/abs/2104.13188
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/stdc.py#L394
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/stdc/stdc1_4xb12-80k_cityscapes-512x1024.py b/mmsegmentation/configs/stdc/stdc1_4xb12-80k_cityscapes-512x1024.py
deleted file mode 100644
index 20aec3d..0000000
--- a/mmsegmentation/configs/stdc/stdc1_4xb12-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,21 +0,0 @@
-_base_ = [
-    '../_base_/models/stdc.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
-param_scheduler = [
-    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
-    dict(
-        type='PolyLR',
-        eta_min=1e-4,
-        power=0.9,
-        begin=1000,
-        end=80000,
-        by_epoch=False,
-    )
-]
-train_dataloader = dict(batch_size=12, num_workers=4)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/stdc/stdc1_in1k-pre_4xb12-80k_cityscapes-512x1024.py b/mmsegmentation/configs/stdc/stdc1_in1k-pre_4xb12-80k_cityscapes-512x1024.py
deleted file mode 100644
index 15e807f..0000000
--- a/mmsegmentation/configs/stdc/stdc1_in1k-pre_4xb12-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,6 +0,0 @@
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/stdc/stdc1_20220308-5368626c.pth'  # noqa
-_base_ = './stdc1_4xb12-80k_cityscapes-512x1024.py'
-model = dict(
-    backbone=dict(
-        backbone_cfg=dict(
-            init_cfg=dict(type='Pretrained', checkpoint=checkpoint))))
diff --git a/mmsegmentation/configs/stdc/stdc2_4xb12-80k_cityscapes-512x1024.py b/mmsegmentation/configs/stdc/stdc2_4xb12-80k_cityscapes-512x1024.py
deleted file mode 100644
index 5657351..0000000
--- a/mmsegmentation/configs/stdc/stdc2_4xb12-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './stdc1_4xb12-80k_cityscapes-512x1024.py'
-model = dict(backbone=dict(backbone_cfg=dict(stdc_type='STDCNet2')))
diff --git a/mmsegmentation/configs/stdc/stdc2_in1k-pre_4xb12-80k_cityscapes-512x1024.py b/mmsegmentation/configs/stdc/stdc2_in1k-pre_4xb12-80k_cityscapes-512x1024.py
deleted file mode 100644
index 05a202b..0000000
--- a/mmsegmentation/configs/stdc/stdc2_in1k-pre_4xb12-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,6 +0,0 @@
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/stdc/stdc2_20220308-7dbd9127.pth'  # noqa
-_base_ = './stdc2_4xb12-80k_cityscapes-512x1024.py'
-model = dict(
-    backbone=dict(
-        backbone_cfg=dict(
-            init_cfg=dict(type='Pretrained', checkpoint=checkpoint))))
diff --git a/mmsegmentation/configs/swin/README.md b/mmsegmentation/configs/swin/README.md
deleted file mode 100644
index 64f0d5f..0000000
--- a/mmsegmentation/configs/swin/README.md
+++ /dev/null
@@ -1,76 +0,0 @@
-# Swin Transformer
-
-> [Swin Transformer: Hierarchical Vision Transformer using Shifted Windows](https://arxiv.org/abs/2103.14030)
-
-## Introduction
-
-<!-- [BACKBONE] -->
-
-<a href="https://github.com/microsoft/Swin-Transformer">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/swin.py#L524">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-This paper presents a new vision Transformer, called Swin Transformer, that capably serves as a general-purpose backbone for computer vision. Challenges in adapting Transformer from language to vision arise from differences between the two domains, such as large variations in the scale of visual entities and the high resolution of pixels in images compared to words in text. To address these differences, we propose a hierarchical Transformer whose representation is computed with Shifted windows. The shifted windowing scheme brings greater efficiency by limiting self-attention computation to non-overlapping local windows while also allowing for cross-window connection. This hierarchical architecture has the flexibility to model at various scales and has linear computational complexity with respect to image size. These qualities of Swin Transformer make it compatible with a broad range of vision tasks, including image classification (87.3 top-1 accuracy on ImageNet-1K) and dense prediction tasks such as object detection (58.7 box AP and 51.1 mask AP on COCO test-dev) and semantic segmentation (53.5 mIoU on ADE20K val). Its performance surpasses the previous state-of-the-art by a large margin of +2.7 box AP and +2.6 mask AP on COCO, and +3.2 mIoU on ADE20K, demonstrating the potential of Transformer-based models as vision backbones. The hierarchical design and the shifted window approach also prove beneficial for all-MLP architectures. The code and models are publicly available at [this https URL](https://github.com/microsoft/Swin-Transformer).
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142902882-3fb9014c-11b6-47e9-aa14-500dfe7cbb1c.png" width="80%"/>
-</div>
-
-## Usage
-
-We have provided pretrained models converted from [official repo](https://github.com/microsoft/Swin-Transformer)．
-
-If you want to convert keys on your own to use official repositories' pre-trained models, we also provide a script [`swin2mmseg.py`](../../tools/model_converters/swin2mmseg.py) in the tools directory to convert the key of models from [the official repo](https://github.com/SwinTransformer/Swin-Transformer-Semantic-Segmentation) to MMSegmentation style.
-
-```shell
-python tools/model_converters/swin2mmseg.py ${PRETRAIN_PATH} ${STORE_PATH}
-```
-
-E.g.
-
-```shell
-python tools/model_converters/swin2mmseg.py https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_base_patch4_window7_224.pth pretrain/swin_base_patch4_window7_224.pth
-```
-
-This script convert model from `PRETRAIN_PATH` and store the converted model in `STORE_PATH`.
-
-In our default setting, pretrained models and their corresponding [original models](https://github.com/microsoft/Swin-Transforme) models could be defined below:
-
-| pretrained models                              | original models                                                                                                                                    |
-| ---------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
-| pretrain/swin_tiny_patch4_window7_224.pth      | [swin_tiny_patch4_window7_224.pth](https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_tiny_patch4_window7_224.pth)           |
-| pretrain/swin_small_patch4_window7_224.pth     | [swin_small_patch4_window7_224.pth](https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_small_patch4_window7_224.pth)         |
-| pretrain/swin_base_patch4_window7_224.pth      | [swin_base_patch4_window7_224.pth](https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_base_patch4_window7_224.pth)           |
-| pretrain/swin_base_patch4_window7_224_22k.pth  | [swin_base_patch4_window7_224_22k.pth](https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_base_patch4_window7_224_22k.pth)   |
-| pretrain/swin_base_patch4_window12_384.pth     | [swin_base_patch4_window12_384.pth](https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_base_patch4_window12_384.pth)         |
-| pretrain/swin_base_patch4_window12_384_22k.pth | [swin_base_patch4_window12_384_22k.pth](https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_base_patch4_window12_384_22k.pth) |
-
-## Results and models
-
-### ADE20K
-
-| Method  | Backbone | Crop Size | pretrain     | pretrain img size | Batch Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                                                        | download                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| ------- | -------- | --------- | ------------ | ----------------- | ---------- | ------- | -------- | -------------- | ------ | ----- | ------------: | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| UPerNet | Swin-T   | 512x512   | ImageNet-1K  | 224x224           | 16         | 160000  | 5.02     | 21.06          | V100   | 44.41 |         45.79 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/swin/swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210531_112542-e380ad3e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210531_112542.log.json)         |
-| UPerNet | Swin-S   | 512x512   | ImageNet-1K  | 224x224           | 16         | 160000  | 6.17     | 14.72          | V100   | 47.72 |         49.24 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/swin/swin-small-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192015-ee2fff1c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192015.log.json)     |
-| UPerNet | Swin-B   | 512x512   | ImageNet-1K  | 224x224           | 16         | 160000  | 7.61     | 12.65          | V100   | 47.99 |         49.57 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/swin/swin-base-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py)           | [model](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192340-593b0e13.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192340.log.json)         |
-| UPerNet | Swin-B   | 512x512   | ImageNet-22K | 224x224           | 16         | 160000  | -        | -              | V100   | 50.13 |          51.9 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/swin/swin-base-patch4-window7-in22k-pre_upernet_8xb2-160k_ade20k-512x512.py)          | [model](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_22K/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_22K_20210526_211650-762e2178.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_22K/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_22K_20210526_211650.log.json)     |
-| UPerNet | Swin-B   | 512x512   | ImageNet-1K  | 384x384           | 16         | 160000  | 8.52     | 12.10          | V100   | 48.35 |         49.65 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/swin/swin-base-patch4-window12-in1k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_1K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_1K_20210531_132020-05b22ea4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_1K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_1K_20210531_132020.log.json)     |
-| UPerNet | Swin-B   | 512x512   | ImageNet-22K | 384x384           | 16         | 160000  | -        | -              | V100   | 50.76 |          52.4 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/swin/swin-base-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K_20210531_125459-429057bf.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K_20210531_125459.log.json) |
-
-## Citation
-
-```bibtex
-@article{liu2021Swin,
-  title={Swin Transformer: Hierarchical Vision Transformer using Shifted Windows},
-  author={Liu, Ze and Lin, Yutong and Cao, Yue and Hu, Han and Wei, Yixuan and Zhang, Zheng and Lin, Stephen and Guo, Baining},
-  journal={arXiv preprint arXiv:2103.14030},
-  year={2021}
-}
-```
diff --git a/mmsegmentation/configs/swin/metafile.yaml b/mmsegmentation/configs/swin/metafile.yaml
deleted file mode 100644
index 67a4e07..0000000
--- a/mmsegmentation/configs/swin/metafile.yaml
+++ /dev/null
@@ -1,143 +0,0 @@
-Models:
-- Name: swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 44.41
-      mIoU(ms+flip): 45.79
-  Config: configs/swin/swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - Swin-T
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 5.02
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210531_112542-e380ad3e.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210531_112542.log.json
-  Paper:
-    Title: 'Swin Transformer: Hierarchical Vision Transformer using Shifted Windows'
-    URL: https://arxiv.org/abs/2103.14030
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/swin.py#L524
-  Framework: PyTorch
-- Name: swin-small-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 47.72
-      mIoU(ms+flip): 49.24
-  Config: configs/swin/swin-small-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - Swin-S
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 6.17
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192015-ee2fff1c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192015.log.json
-  Paper:
-    Title: 'Swin Transformer: Hierarchical Vision Transformer using Shifted Windows'
-    URL: https://arxiv.org/abs/2103.14030
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/swin.py#L524
-  Framework: PyTorch
-- Name: swin-base-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 47.99
-      mIoU(ms+flip): 49.57
-  Config: configs/swin/swin-base-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - Swin-B
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 7.61
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192340-593b0e13.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192340.log.json
-  Paper:
-    Title: 'Swin Transformer: Hierarchical Vision Transformer using Shifted Windows'
-    URL: https://arxiv.org/abs/2103.14030
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/swin.py#L524
-  Framework: PyTorch
-- Name: swin-base-patch4-window7-in22k-pre_upernet_8xb2-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 50.13
-      mIoU(ms+flip): 51.9
-  Config: configs/swin/swin-base-patch4-window7-in22k-pre_upernet_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - Swin-B
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_22K/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_22K_20210526_211650-762e2178.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_22K/upernet_swin_base_patch4_window7_512x512_160k_ade20k_pretrain_224x224_22K_20210526_211650.log.json
-  Paper:
-    Title: 'Swin Transformer: Hierarchical Vision Transformer using Shifted Windows'
-    URL: https://arxiv.org/abs/2103.14030
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/swin.py#L524
-  Framework: PyTorch
-- Name: swin-base-patch4-window12-in1k-384x384-pre_upernet_8xb2-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 48.35
-      mIoU(ms+flip): 49.65
-  Config: configs/swin/swin-base-patch4-window12-in1k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - Swin-B
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 8.52
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_1K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_1K_20210531_132020-05b22ea4.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_1K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_1K_20210531_132020.log.json
-  Paper:
-    Title: 'Swin Transformer: Hierarchical Vision Transformer using Shifted Windows'
-    URL: https://arxiv.org/abs/2103.14030
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/swin.py#L524
-  Framework: PyTorch
-- Name: swin-base-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 50.76
-      mIoU(ms+flip): 52.4
-  Config: configs/swin/swin-base-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - Swin-B
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K_20210531_125459-429057bf.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K_20210531_125459.log.json
-  Paper:
-    Title: 'Swin Transformer: Hierarchical Vision Transformer using Shifted Windows'
-    URL: https://arxiv.org/abs/2103.14030
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/swin.py#L524
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/swin/swin-base-patch4-window12-in1k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/swin/swin-base-patch4-window12-in1k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 11cea36..0000000
--- a/mmsegmentation/configs/swin/swin-base-patch4-window12-in1k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,14 +0,0 @@
-_base_ = [
-    'swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py'
-]
-checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_base_patch4_window12_384_20220317-55b0104a.pth'  # noqa
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file),
-        pretrain_img_size=384,
-        embed_dims=128,
-        depths=[2, 2, 18, 2],
-        num_heads=[4, 8, 16, 32],
-        window_size=12),
-    decode_head=dict(in_channels=[128, 256, 512, 1024], num_classes=150),
-    auxiliary_head=dict(in_channels=512, num_classes=150))
diff --git a/mmsegmentation/configs/swin/swin-base-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/swin/swin-base-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 5c11716..0000000
--- a/mmsegmentation/configs/swin/swin-base-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    './swin-base-patch4-window12-in1k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py'  # noqa
-]
-checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_base_patch4_window12_384_22k_20220317-e5c09f74.pth'  # noqa
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file)))
diff --git a/mmsegmentation/configs/swin/swin-base-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/swin/swin-base-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 73bf616..0000000
--- a/mmsegmentation/configs/swin/swin-base-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    './swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py'
-]
-checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_base_patch4_window7_224_20220317-e9b98025.pth'  # noqa
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file),
-        embed_dims=128,
-        depths=[2, 2, 18, 2],
-        num_heads=[4, 8, 16, 32]),
-    decode_head=dict(in_channels=[128, 256, 512, 1024], num_classes=150),
-    auxiliary_head=dict(in_channels=512, num_classes=150))
diff --git a/mmsegmentation/configs/swin/swin-base-patch4-window7-in22k-pre_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/swin/swin-base-patch4-window7-in22k-pre_upernet_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 96148cd..0000000
--- a/mmsegmentation/configs/swin/swin-base-patch4-window7-in22k-pre_upernet_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    './swin-base-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py'
-]
-checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_base_patch4_window7_224_22k_20220317-4f79f7c0.pth'  # noqa
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file)))
diff --git a/mmsegmentation/configs/swin/swin-large-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/swin/swin-large-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index a0a654e..0000000
--- a/mmsegmentation/configs/swin/swin-large-patch4-window12-in22k-384x384-pre_upernet_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    'swin-large-patch4-window7-in22k-pre_upernet_'
-    '8xb2-160k_ade20k-512x512.py'
-]
-checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_large_patch4_window12_384_22k_20220412-6580f57d.pth'  # noqa
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file),
-        pretrain_img_size=384,
-        window_size=12))
diff --git a/mmsegmentation/configs/swin/swin-large-patch4-window7-in22k-pre_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/swin/swin-large-patch4-window7-in22k-pre_upernet_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index c93cdfe..0000000
--- a/mmsegmentation/configs/swin/swin-large-patch4-window7-in22k-pre_upernet_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,15 +0,0 @@
-_base_ = [
-    'swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_'
-    'ade20k-512x512.py'
-]
-checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_large_patch4_window7_224_22k_20220412-aeecf2aa.pth'  # noqa
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file),
-        pretrain_img_size=224,
-        embed_dims=192,
-        depths=[2, 2, 18, 2],
-        num_heads=[6, 12, 24, 48],
-        window_size=7),
-    decode_head=dict(in_channels=[192, 384, 768, 1536], num_classes=150),
-    auxiliary_head=dict(in_channels=768, num_classes=150))
diff --git a/mmsegmentation/configs/swin/swin-small-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/swin/swin-small-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 19863df..0000000
--- a/mmsegmentation/configs/swin/swin-small-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    './swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py'
-]
-checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_small_patch4_window7_224_20220317-7ba6d6dd.pth'  # noqa
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file),
-        depths=[2, 2, 18, 2]),
-    decode_head=dict(in_channels=[96, 192, 384, 768], num_classes=150),
-    auxiliary_head=dict(in_channels=384, num_classes=150))
diff --git a/mmsegmentation/configs/swin/swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/swin/swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index f61a276..0000000
--- a/mmsegmentation/configs/swin/swin-tiny-patch4-window7-in1k-pre_upernet_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,52 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_swin.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-checkpoint_file = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_tiny_patch4_window7_224_20220317-1cdeb081.pth'  # noqa
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file),
-        embed_dims=96,
-        depths=[2, 2, 6, 2],
-        num_heads=[3, 6, 12, 24],
-        window_size=7,
-        use_abs_pos_embed=False,
-        drop_path_rate=0.3,
-        patch_norm=True),
-    decode_head=dict(in_channels=[96, 192, 384, 768], num_classes=150),
-    auxiliary_head=dict(in_channels=384, num_classes=150))
-
-# AdamW optimizer, no weight decay for position embedding & layer norm
-# in backbone
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
-    paramwise_cfg=dict(
-        custom_keys={
-            'absolute_pos_embed': dict(decay_mult=0.),
-            'relative_position_bias_table': dict(decay_mult=0.),
-            'norm': dict(decay_mult=0.)
-        }))
-
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        eta_min=0.0,
-        power=1.0,
-        begin=1500,
-        end=160000,
-        by_epoch=False,
-    )
-]
-
-# By default, models are trained on 8 GPUs with 2 images per GPU
-train_dataloader = dict(batch_size=2)
-val_dataloader = dict(batch_size=1)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/swin/swin-tiny-patch4-window7_upernet_1xb8-20k_levir-256x256.py b/mmsegmentation/configs/swin/swin-tiny-patch4-window7_upernet_1xb8-20k_levir-256x256.py
deleted file mode 100644
index 7b90686..0000000
--- a/mmsegmentation/configs/swin/swin-tiny-patch4-window7_upernet_1xb8-20k_levir-256x256.py
+++ /dev/null
@@ -1,57 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_swin.py', '../_base_/datasets/levir_256x256.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_20k.py'
-]
-crop_size = (256, 256)
-norm_cfg = dict(type='BN', requires_grad=True)
-data_preprocessor = dict(
-    size=crop_size,
-    type='SegDataPreProcessor',
-    mean=[123.675, 116.28, 103.53, 123.675, 116.28, 103.53],
-    std=[58.395, 57.12, 57.375, 58.395, 57.12, 57.375],
-    bgr_to_rgb=False)
-
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        in_channels=6,
-        embed_dims=96,
-        depths=[2, 2, 6, 2],
-        num_heads=[3, 6, 12, 24],
-        window_size=7,
-        use_abs_pos_embed=False,
-        drop_path_rate=0.3,
-        patch_norm=True),
-    decode_head=dict(in_channels=[96, 192, 384, 768], num_classes=2),
-    auxiliary_head=dict(in_channels=384, num_classes=2))
-
-# AdamW optimizer, no weight decay for position embedding & layer norm
-# in backbone
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
-    paramwise_cfg=dict(
-        custom_keys={
-            'absolute_pos_embed': dict(decay_mult=0.),
-            'relative_position_bias_table': dict(decay_mult=0.),
-            'norm': dict(decay_mult=0.)
-        }))
-
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        eta_min=0.0,
-        power=1.0,
-        begin=1500,
-        end=20000,
-        by_epoch=False,
-    )
-]
-
-train_dataloader = dict(batch_size=4)
-val_dataloader = dict(batch_size=1)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/twins/README.md b/mmsegmentation/configs/twins/README.md
deleted file mode 100644
index e4b3735..0000000
--- a/mmsegmentation/configs/twins/README.md
+++ /dev/null
@@ -1,76 +0,0 @@
-# Twins
-
-> [Twins: Revisiting the Design of Spatial Attention in Vision Transformers](https://arxiv.org/pdf/2104.13840.pdf)
-
-## Introduction
-
-<!-- [BACKBONE] -->
-
-<a href = "https://github.com/Meituan-AutoML/Twins">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Very recently, a variety of vision transformer architectures for dense prediction tasks have been proposed and they show that the design of spatial attention is critical to their success in these tasks. In this work, we revisit the design of the spatial attention and demonstrate that a carefully-devised yet simple spatial attention mechanism performs favourably against the state-of-the-art schemes. As a result, we propose two vision transformer architectures, namely, Twins-PCPVT and Twins-SVT. Our proposed architectures are highly-efficient and easy to implement, only involving matrix multiplications that are highly optimized in modern deep learning frameworks. More importantly, the proposed architectures achieve excellent performance on a wide range of visual tasks, including image level classification as well as dense detection and segmentation. The simplicity and strong performance suggest that our proposed architectures may serve as stronger backbones for many vision tasks. Our code is released at [this https URL](https://github.com/Meituan-AutoML/Twins).
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/145021310-57826cf5-5e03-4c7c-9081-ffa744bdae27.png" width="80%"/>
-</div>
-
-## Usage
-
-We have provided pretrained models converted from [official repo](https://github.com/Meituan-AutoML/Twins).
-
-If you want to convert keys on your own to use official repositories' pre-trained models, we also provide a script [`twins2mmseg.py`](../../tools/model_converters/twins2mmseg.py) in the tools directory to convert the key of models from [the official repo](https://github.com/Meituan-AutoML/Twins) to MMSegmentation style.
-
-```shell
-python tools/model_converters/twins2mmseg.py ${PRETRAIN_PATH} ${STORE_PATH} ${MODEL_TYPE}
-```
-
-This script convert `pcpvt` or `svt` pretrained model from `PRETRAIN_PATH` and store the converted model in `STORE_PATH`.
-
-For example,
-
-```shell
-python tools/model_converters/twins2mmseg.py ./alt_gvt_base.pth ./pretrained/alt_gvt_base.pth svt
-```
-
-## Results and models
-
-### ADE20K
-
-| Method  | Backbone            | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | mIoU  | mIoU(ms+flip) | config                                                                                                                              | download                                                                                                                                                                                                                                                                                                                                                                                       |
-| ------- | ------------------- | --------- | ------- | -------- | -------------- | ------ | ----- | ------------- | ----------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| FPN     | Twins-PCPVT-S       | 512x512   | 80000   | 6.60     | 27.15          | V100   | 43.26 | 44.11         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_pcpvt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-s_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-s_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_204132-41acd132.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-s_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-s_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_204132.log.json) |
-| UPerNet | Twins-PCPVT-S       | 512x512   | 160000  | 9.67     | 14.24          | V100   | 46.04 | 46.92         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_pcpvt-s_uperhead_8xb4-160k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-s_uperhead_8x4_512x512_160k_ade20k/twins_pcpvt-s_uperhead_8x4_512x512_160k_ade20k_20211201_233537-8e99c07a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-s_uperhead_8x4_512x512_160k_ade20k/twins_pcpvt-s_uperhead_8x4_512x512_160k_ade20k_20211201_233537.log.json)         |
-| FPN     | Twins-PCPVT-B       | 512x512   | 80000   | 8.41     | 19.67          | V100   | 45.66 | 46.48         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_pcpvt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-b_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-b_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141019-d396db72.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-b_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-b_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141019.log.json) |
-| UPerNet | Twins-PCPVT-B (8x2) | 512x512   | 160000  | 6.46     | 12.04          | V100   | 47.91 | 48.64         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_pcpvt-b_uperhead_8xb2-160k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-b_uperhead_8x2_512x512_160k_ade20k/twins_pcpvt-b_uperhead_8x2_512x512_160k_ade20k_20211130_141020-02094ea5.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-b_uperhead_8x2_512x512_160k_ade20k/twins_pcpvt-b_uperhead_8x2_512x512_160k_ade20k_20211130_141020.log.json)         |
-| FPN     | Twins-PCPVT-L       | 512x512   | 80000   | 10.78    | 14.32          | V100   | 45.94 | 46.70         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_pcpvt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-l_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-l_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_105226-bc6d61dc.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-l_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-l_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_105226.log.json) |
-| UPerNet | Twins-PCPVT-L (8x2) | 512x512   | 160000  | 7.82     | 10.70          | V100   | 49.35 | 50.08         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_pcpvt-l_uperhead_8xb2-160k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-l_uperhead_8x2_512x512_160k_ade20k/twins_pcpvt-l_uperhead_8x2_512x512_160k_ade20k_20211201_075053-c6095c07.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-l_uperhead_8x2_512x512_160k_ade20k/twins_pcpvt-l_uperhead_8x2_512x512_160k_ade20k_20211201_075053.log.json)         |
-| FPN     | Twins-SVT-S         | 512x512   | 80000   | 5.80     | 29.79          | V100   | 44.47 | 45.42         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_svt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-s_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-s_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141006-0a0d3317.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-s_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-s_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141006.log.json)         |
-| UPerNet | SVT-S  (8x2)        | 512x512   | 160000  | 4.93     | 15.09          | V100   | 46.08 | 46.96         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_svt-s_uperhead_8xb2-160k_ade20k-512x512.py)     | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-s_uperhead_8x2_512x512_160k_ade20k/twins_svt-s_uperhead_8x2_512x512_160k_ade20k_20211130_141005-e48a2d94.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-s_uperhead_8x2_512x512_160k_ade20k/twins_svt-s_uperhead_8x2_512x512_160k_ade20k_20211130_141005.log.json)                 |
-| FPN     | Twins-SVT-B         | 512x512   | 80000   | 8.75     | 21.10          | V100   | 46.77 | 47.47         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_svt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-b_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-b_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_113849-88b2907c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-b_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-b_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_113849.log.json)         |
-| UPerNet | Twins-SVT-B  (8x2)  | 512x512   | 160000  | 6.77     | 12.66          | V100   | 48.04 | 48.87         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_svt-b_uperhead_8xb2-160k_ade20k-512x512.py)     | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-b_uperhead_8x2_512x512_160k_ade20k/twins_svt-b_uperhead_8x2_512x512_160k_ade20k_20211202_040826-0943a1f1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-b_uperhead_8x2_512x512_160k_ade20k/twins_svt-b_uperhead_8x2_512x512_160k_ade20k_20211202_040826.log.json)                 |
-| FPN     | Twins-SVT-L         | 512x512   | 80000   | 11.20    | 17.80          | V100   | 46.55 | 47.74         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_svt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-l_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-l_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141005-1d59bee2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-l_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-l_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141005.log.json)         |
-| UPerNet | Twins-SVT-L  (8x2)  | 512x512   | 160000  | 8.41     | 10.73          | V100   | 49.65 | 50.63         | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins/twins_pcpvt-l_uperhead_8xb2-160k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-l_uperhead_8x2_512x512_160k_ade20k/twins_svt-l_uperhead_8x2_512x512_160k_ade20k_20211130_141005-3e2cae61.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-l_uperhead_8x2_512x512_160k_ade20k/twins_svt-l_uperhead_8x2_512x512_160k_ade20k_20211130_141005.log.json)                 |
-
-Note:
-
-- `8x2` means 8 GPUs with 2 samples per GPU in training. Default setting of Twins on ADE20K is 8 GPUs with 4 samples per GPU in training.
-- `UPerNet` and `FPN` are decoder heads utilized in corresponding Twins model, which is `UPerHead` and `FPNHead`, respectively. Specifically, models in [official repo](https://github.com/Meituan-AutoML/Twins) all use `UPerHead`.
-
-## Citation
-
-```bibtex
-@article{chu2021twins,
-  title={Twins: Revisiting spatial attention design in vision transformers},
-  author={Chu, Xiangxiang and Tian, Zhi and Wang, Yuqing and Zhang, Bo and Ren, Haibing and Wei, Xiaolin and Xia, Huaxia and Shen, Chunhua},
-  journal={arXiv preprint arXiv:2104.13840},
-  year={2021}altgvt
-}
-```
diff --git a/mmsegmentation/configs/twins/metafile.yaml b/mmsegmentation/configs/twins/metafile.yaml
deleted file mode 100644
index 0de78d9..0000000
--- a/mmsegmentation/configs/twins/metafile.yaml
+++ /dev/null
@@ -1,289 +0,0 @@
-Models:
-- Name: twins_pcpvt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512
-  In Collection: FPN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 43.26
-      mIoU(ms+flip): 44.11
-  Config: configs/twins/twins_pcpvt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 32
-    Architecture:
-    - Twins-PCPVT-S
-    - FPN
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 6.6
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-s_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-s_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_204132-41acd132.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-s_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-s_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_204132.log.json
-  Paper:
-    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
-    URL: https://arxiv.org/pdf/2104.13840.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
-  Framework: PyTorch
-- Name: twins_pcpvt-s_uperhead_8xb4-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 46.04
-      mIoU(ms+flip): 46.92
-  Config: configs/twins/twins_pcpvt-s_uperhead_8xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 32
-    Architecture:
-    - Twins-PCPVT-S
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 9.67
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-s_uperhead_8x4_512x512_160k_ade20k/twins_pcpvt-s_uperhead_8x4_512x512_160k_ade20k_20211201_233537-8e99c07a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-s_uperhead_8x4_512x512_160k_ade20k/twins_pcpvt-s_uperhead_8x4_512x512_160k_ade20k_20211201_233537.log.json
-  Paper:
-    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
-    URL: https://arxiv.org/pdf/2104.13840.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
-  Framework: PyTorch
-- Name: twins_pcpvt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512
-  In Collection: FPN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 45.66
-      mIoU(ms+flip): 46.48
-  Config: configs/twins/twins_pcpvt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 32
-    Architecture:
-    - Twins-PCPVT-B
-    - FPN
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 8.41
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-b_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-b_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141019-d396db72.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-b_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-b_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141019.log.json
-  Paper:
-    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
-    URL: https://arxiv.org/pdf/2104.13840.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
-  Framework: PyTorch
-- Name: twins_pcpvt-b_uperhead_8xb2-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 47.91
-      mIoU(ms+flip): 48.64
-  Config: configs/twins/twins_pcpvt-b_uperhead_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - Twins-PCPVT-B
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 6.46
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-b_uperhead_8x2_512x512_160k_ade20k/twins_pcpvt-b_uperhead_8x2_512x512_160k_ade20k_20211130_141020-02094ea5.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-b_uperhead_8x2_512x512_160k_ade20k/twins_pcpvt-b_uperhead_8x2_512x512_160k_ade20k_20211130_141020.log.json
-  Paper:
-    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
-    URL: https://arxiv.org/pdf/2104.13840.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
-  Framework: PyTorch
-- Name: twins_pcpvt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512
-  In Collection: FPN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 45.94
-      mIoU(ms+flip): 46.7
-  Config: configs/twins/twins_pcpvt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 32
-    Architecture:
-    - Twins-PCPVT-L
-    - FPN
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 10.78
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-l_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-l_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_105226-bc6d61dc.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-l_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_pcpvt-l_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_105226.log.json
-  Paper:
-    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
-    URL: https://arxiv.org/pdf/2104.13840.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
-  Framework: PyTorch
-- Name: twins_pcpvt-l_uperhead_8xb2-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 49.35
-      mIoU(ms+flip): 50.08
-  Config: configs/twins/twins_pcpvt-l_uperhead_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - Twins-PCPVT-L
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 7.82
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-l_uperhead_8x2_512x512_160k_ade20k/twins_pcpvt-l_uperhead_8x2_512x512_160k_ade20k_20211201_075053-c6095c07.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_pcpvt-l_uperhead_8x2_512x512_160k_ade20k/twins_pcpvt-l_uperhead_8x2_512x512_160k_ade20k_20211201_075053.log.json
-  Paper:
-    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
-    URL: https://arxiv.org/pdf/2104.13840.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
-  Framework: PyTorch
-- Name: twins_svt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512
-  In Collection: FPN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 44.47
-      mIoU(ms+flip): 45.42
-  Config: configs/twins/twins_svt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 32
-    Architecture:
-    - Twins-SVT-S
-    - FPN
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 5.8
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-s_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-s_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141006-0a0d3317.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-s_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-s_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141006.log.json
-  Paper:
-    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
-    URL: https://arxiv.org/pdf/2104.13840.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
-  Framework: PyTorch
-- Name: twins_svt-s_uperhead_8xb2-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 46.08
-      mIoU(ms+flip): 46.96
-  Config: configs/twins/twins_svt-s_uperhead_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - SVT-S
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 4.93
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-s_uperhead_8x2_512x512_160k_ade20k/twins_svt-s_uperhead_8x2_512x512_160k_ade20k_20211130_141005-e48a2d94.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-s_uperhead_8x2_512x512_160k_ade20k/twins_svt-s_uperhead_8x2_512x512_160k_ade20k_20211130_141005.log.json
-  Paper:
-    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
-    URL: https://arxiv.org/pdf/2104.13840.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
-  Framework: PyTorch
-- Name: twins_svt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512
-  In Collection: FPN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 46.77
-      mIoU(ms+flip): 47.47
-  Config: configs/twins/twins_svt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 32
-    Architecture:
-    - Twins-SVT-B
-    - FPN
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 8.75
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-b_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-b_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_113849-88b2907c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-b_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-b_fpn_fpnhead_8x4_512x512_80k_ade20k_20211201_113849.log.json
-  Paper:
-    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
-    URL: https://arxiv.org/pdf/2104.13840.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
-  Framework: PyTorch
-- Name: twins_svt-b_uperhead_8xb2-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 48.04
-      mIoU(ms+flip): 48.87
-  Config: configs/twins/twins_svt-b_uperhead_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - Twins-SVT-B
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 6.77
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-b_uperhead_8x2_512x512_160k_ade20k/twins_svt-b_uperhead_8x2_512x512_160k_ade20k_20211202_040826-0943a1f1.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-b_uperhead_8x2_512x512_160k_ade20k/twins_svt-b_uperhead_8x2_512x512_160k_ade20k_20211202_040826.log.json
-  Paper:
-    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
-    URL: https://arxiv.org/pdf/2104.13840.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
-  Framework: PyTorch
-- Name: twins_svt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512
-  In Collection: FPN
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 46.55
-      mIoU(ms+flip): 47.74
-  Config: configs/twins/twins_svt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 32
-    Architecture:
-    - Twins-SVT-L
-    - FPN
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 11.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-l_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-l_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141005-1d59bee2.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-l_fpn_fpnhead_8x4_512x512_80k_ade20k/twins_svt-l_fpn_fpnhead_8x4_512x512_80k_ade20k_20211130_141005.log.json
-  Paper:
-    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
-    URL: https://arxiv.org/pdf/2104.13840.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
-  Framework: PyTorch
-- Name: twins_pcpvt-l_uperhead_8xb2-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 49.65
-      mIoU(ms+flip): 50.63
-  Config: configs/twins/twins_pcpvt-l_uperhead_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - Twins-SVT-L
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 8.41
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-l_uperhead_8x2_512x512_160k_ade20k/twins_svt-l_uperhead_8x2_512x512_160k_ade20k_20211130_141005-3e2cae61.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/twins/twins_svt-l_uperhead_8x2_512x512_160k_ade20k/twins_svt-l_uperhead_8x2_512x512_160k_ade20k_20211130_141005.log.json
-  Paper:
-    Title: 'Twins: Revisiting the Design of Spatial Attention in Vision Transformers'
-    URL: https://arxiv.org/pdf/2104.13840.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.20.0/mmseg/models/backbones/twins.py#L352
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/twins/twins_pcpvt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_pcpvt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 4739ad4..0000000
--- a/mmsegmentation/configs/twins/twins_pcpvt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = ['./twins_pcpvt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py']
-
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/twins/pcpvt_base_20220308-0621964c.pth'  # noqa
-
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
-        depths=[3, 4, 18, 3]), )
diff --git a/mmsegmentation/configs/twins/twins_pcpvt-b_uperhead_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_pcpvt-b_uperhead_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index ba97485..0000000
--- a/mmsegmentation/configs/twins/twins_pcpvt-b_uperhead_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,13 +0,0 @@
-_base_ = ['./twins_pcpvt-s_uperhead_8xb4-160k_ade20k-512x512.py']
-
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/twins/pcpvt_base_20220308-0621964c.pth'  # noqa
-
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
-        depths=[3, 4, 18, 3],
-        drop_path_rate=0.3))
-
-train_dataloader = dict(batch_size=2, num_workers=2)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/twins/twins_pcpvt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_pcpvt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
deleted file mode 100644
index bff7c41..0000000
--- a/mmsegmentation/configs/twins/twins_pcpvt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = ['./twins_pcpvt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py']
-
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/twins/pcpvt_large_20220308-37579dc6.pth'  # noqa
-
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
-        depths=[3, 8, 27, 3]))
diff --git a/mmsegmentation/configs/twins/twins_pcpvt-l_uperhead_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_pcpvt-l_uperhead_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 666ff5b..0000000
--- a/mmsegmentation/configs/twins/twins_pcpvt-l_uperhead_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,13 +0,0 @@
-_base_ = ['./twins_pcpvt-s_uperhead_8xb4-160k_ade20k-512x512.py']
-
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/twins/pcpvt_large_20220308-37579dc6.pth'  # noqa
-
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
-        depths=[3, 8, 27, 3],
-        drop_path_rate=0.3))
-
-train_dataloader = dict(batch_size=2, num_workers=2)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/twins/twins_pcpvt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_pcpvt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 3b480b9..0000000
--- a/mmsegmentation/configs/twins/twins_pcpvt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/twins_pcpvt-s_fpn.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0001),
-    clip_grad=None)
diff --git a/mmsegmentation/configs/twins/twins_pcpvt-s_uperhead_8xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_pcpvt-s_uperhead_8xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 387cf60..0000000
--- a/mmsegmentation/configs/twins/twins_pcpvt-s_uperhead_8xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,31 +0,0 @@
-_base_ = [
-    '../_base_/models/twins_pcpvt-s_upernet.py',
-    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
-
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
-    paramwise_cfg=dict(custom_keys={
-        'pos_block': dict(decay_mult=0.),
-        'norm': dict(decay_mult=0.)
-    }))
-
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        eta_min=0.0,
-        power=1.0,
-        begin=1500,
-        end=160000,
-        by_epoch=False,
-    )
-]
diff --git a/mmsegmentation/configs/twins/twins_svt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_svt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 5e9fa00..0000000
--- a/mmsegmentation/configs/twins/twins_svt-b_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = ['./twins_svt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py']
-
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/twins/alt_gvt_base_20220308-1b7eb711.pth'  # noqa
-
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
-        embed_dims=[96, 192, 384, 768],
-        num_heads=[3, 6, 12, 24],
-        depths=[2, 2, 18, 2]),
-    neck=dict(in_channels=[96, 192, 384, 768]),
-)
diff --git a/mmsegmentation/configs/twins/twins_svt-b_uperhead_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_svt-b_uperhead_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 6ce2361..0000000
--- a/mmsegmentation/configs/twins/twins_svt-b_uperhead_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = ['./twins_svt-s_uperhead_8xb2-160k_ade20k-512x512.py']
-
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/twins/alt_gvt_base_20220308-1b7eb711.pth'  # noqa
-
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
-        embed_dims=[96, 192, 384, 768],
-        num_heads=[3, 6, 12, 24],
-        depths=[2, 2, 18, 2]),
-    decode_head=dict(in_channels=[96, 192, 384, 768]),
-    auxiliary_head=dict(in_channels=384))
diff --git a/mmsegmentation/configs/twins/twins_svt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_svt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
deleted file mode 100644
index b7e5f9c..0000000
--- a/mmsegmentation/configs/twins/twins_svt-l_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,13 +0,0 @@
-_base_ = ['./twins_svt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py']
-
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/twins/alt_gvt_large_20220308-fb5936f3.pth'  # noqa
-
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
-        embed_dims=[128, 256, 512, 1024],
-        num_heads=[4, 8, 16, 32],
-        depths=[2, 2, 18, 2],
-        drop_path_rate=0.3),
-    neck=dict(in_channels=[128, 256, 512, 1024]),
-)
diff --git a/mmsegmentation/configs/twins/twins_svt-l_uperhead_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_svt-l_uperhead_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 69c69df..0000000
--- a/mmsegmentation/configs/twins/twins_svt-l_uperhead_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,13 +0,0 @@
-_base_ = ['./twins_svt-s_uperhead_8xb2-160k_ade20k-512x512.py']
-
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/twins/alt_gvt_large_20220308-fb5936f3.pth'  # noqa
-
-model = dict(
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
-        embed_dims=[128, 256, 512, 1024],
-        num_heads=[4, 8, 16, 32],
-        depths=[2, 2, 18, 2],
-        drop_path_rate=0.3),
-    decode_head=dict(in_channels=[128, 256, 512, 1024]),
-    auxiliary_head=dict(in_channels=512))
diff --git a/mmsegmentation/configs/twins/twins_svt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_svt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
deleted file mode 100644
index c1aad83..0000000
--- a/mmsegmentation/configs/twins/twins_svt-s_fpn_fpnhead_8xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,28 +0,0 @@
-_base_ = [
-    '../_base_/models/twins_pcpvt-s_fpn.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/twins/alt_gvt_small_20220308-7e1c3695.pth'  # noqa
-
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        type='SVT',
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
-        embed_dims=[64, 128, 256, 512],
-        num_heads=[2, 4, 8, 16],
-        mlp_ratios=[4, 4, 4, 4],
-        depths=[2, 2, 10, 4],
-        windiow_sizes=[7, 7, 7, 7],
-        norm_after_stage=True),
-    neck=dict(in_channels=[64, 128, 256, 512], out_channels=256, num_outs=4),
-    decode_head=dict(num_classes=150),
-)
-
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0001),
-    clip_grad=None)
diff --git a/mmsegmentation/configs/twins/twins_svt-s_uperhead_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/twins/twins_svt-s_uperhead_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 3846795..0000000
--- a/mmsegmentation/configs/twins/twins_svt-s_uperhead_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,49 +0,0 @@
-_base_ = [
-    '../_base_/models/twins_pcpvt-s_upernet.py',
-    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/twins/alt_gvt_small_20220308-7e1c3695.pth'  # noqa
-
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        type='SVT',
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
-        embed_dims=[64, 128, 256, 512],
-        num_heads=[2, 4, 8, 16],
-        mlp_ratios=[4, 4, 4, 4],
-        depths=[2, 2, 10, 4],
-        windiow_sizes=[7, 7, 7, 7],
-        norm_after_stage=True),
-    decode_head=dict(in_channels=[64, 128, 256, 512]),
-    auxiliary_head=dict(in_channels=256))
-
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
-    paramwise_cfg=dict(custom_keys={
-        'pos_block': dict(decay_mult=0.),
-        'norm': dict(decay_mult=0.)
-    }))
-
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        eta_min=0.0,
-        power=1.0,
-        begin=1500,
-        end=160000,
-        by_epoch=False,
-    )
-]
-
-train_dataloader = dict(batch_size=2, num_workers=2)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/unet/README.md b/mmsegmentation/configs/unet/README.md
deleted file mode 100644
index 7225fbb..0000000
--- a/mmsegmentation/configs/unet/README.md
+++ /dev/null
@@ -1,92 +0,0 @@
-# UNet
-
-> [U-Net: Convolutional Networks for Biomedical Image Segmentation](https://arxiv.org/abs/1505.04597)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="http://lmb.informatik.uni-freiburg.de/people/ronneber/u-net">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-There is large consent that successful training of deep networks requires many thousand annotated training samples. In this paper, we present a network and training strategy that relies on the strong use of data augmentation to use the available annotated samples more efficiently. The architecture consists of a contracting path to capture context and a symmetric expanding path that enables precise localization. We show that such a network can be trained end-to-end from very few images and outperforms the prior best method (a sliding-window convolutional network) on the ISBI challenge for segmentation of neuronal structures in electron microscopic stacks. Using the same network trained on transmitted light microscopy images (phase contrast and DIC) we won the ISBI cell tracking challenge 2015 in these categories by a large margin. Moreover, the network is fast. Segmentation of a 512x512 image takes less than a second on a recent GPU. The full implementation (based on Caffe) and the trained networks are available at [this http URL](https://lmb.informatik.uni-freiburg.de/people/ronneber/u-net/).
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142902977-20fe689d-a147-4d92-9690-dbfde8b68dbe.png" width="70%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method     | Backbone    | Loss          | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                         | download                                                                                                                                                                                                                                                                                                                                                                     |
-| ---------- | ----------- | ------------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| UNet + FCN | UNet-S5-D16 | Cross Entropy | 512x1024  |  160000 | 17.91    | 3.05           | V100   | 69.10 |         71.05 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_4x4_512x1024_160k_cityscapes/fcn_unet_s5-d16_4x4_512x1024_160k_cityscapes_20211210_145204-6860854e.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_4x4_512x1024_160k_cityscapes/fcn_unet_s5-d16_4x4_512x1024_160k_cityscapes_20211210_145204.log.json) |
-
-### DRIVE
-
-| Method           | Backbone    | Loss                 | Image Size | Crop Size | Stride | Lr schd | Mem (GB) | Inf time (fps) | Device | mDice |  Dice | config                                                                                                                                      | download                                                                                                                                                                                                                                                                                                                                                                                                         |
-| ---------------- | ----------- | -------------------- | ---------- | --------- | -----: | ------- | -------- | -------------: | ------ | ----: | ----: | ------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| UNet + FCN       | UNet-S5-D16 | Cross Entropy        | 584x565    | 64x64     |  42x42 | 40000   | 0.680    |              - | V100   | 88.38 | 78.67 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_fcn_4xb4-40k_drive-64x64.py)                       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_64x64_40k_drive/fcn_unet_s5-d16_64x64_40k_drive_20201223_191051-5daf6d3b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/unet_s5-d16_64x64_40k_drive/unet_s5-d16_64x64_40k_drive-20201223_191051.log.json)                                                                                                 |
-| UNet + FCN       | UNet-S5-D16 | Cross Entropy + Dice | 584x565    | 64x64     |  42x42 | 40000   | 0.582    |              - | V100   | 88.71 | 79.32 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/fcn_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201820-785de5c2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/fcn_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201820.log.json)                         |
-| UNet + PSPNet    | UNet-S5-D16 | Cross Entropy        | 584x565    | 64x64     |  42x42 | 40000   | 0.599    |              - | V100   | 88.35 | 78.62 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_pspnet_4xb4-40k_drive-64x64.py)                    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_64x64_40k_drive/pspnet_unet_s5-d16_64x64_40k_drive_20201227_181818-aac73387.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_64x64_40k_drive/pspnet_unet_s5-d16_64x64_40k_drive-20201227_181818.log.json)                                                                             |
-| UNet + PSPNet    | UNet-S5-D16 | Cross Entropy + Dice | 584x565    | 64x64     |  42x42 | 40000   | 0.585    |              - | V100   | 88.76 | 79.42 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/pspnet_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201821-22b3e3ba.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/pspnet_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201821.log.json)             |
-| UNet + DeepLabV3 | UNet-S5-D16 | Cross Entropy        | 584x565    | 64x64     |  42x42 | 40000   | 0.596    |              - | V100   | 88.38 | 78.69 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_drive-64x64.py)                 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_64x64_40k_drive/deeplabv3_unet_s5-d16_64x64_40k_drive_20201226_094047-0671ff20.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_64x64_40k_drive/deeplabv3_unet_s5-d16_64x64_40k_drive-20201226_094047.log.json)                                                                 |
-| UNet + DeepLabV3 | UNet-S5-D16 | Cross Entropy + Dice | 584x565    | 64x64     |  42x42 | 40000   | 0.582    |              - | V100   | 88.84 | 79.56 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201825-6bf0efd7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201825.log.json) |
-
-### STARE
-
-| Method           | Backbone    | Loss                 | Image Size | Crop Size | Stride | Lr schd | Mem (GB) | Inf time (fps) | Device | mDice |  Dice | config                                                                                                                                        | download                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| ---------------- | ----------- | -------------------- | ---------- | --------- | -----: | ------- | -------- | -------------: | ------ | ----: | ----: | --------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| UNet + FCN       | UNet-S5-D16 | Cross Entropy        | 605x700    | 128x128   |  85x85 | 40000   | 0.968    |              - | V100   | 89.78 | 81.02 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_fcn_4xb4-40k_stare-128x128.py)                       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_128x128_40k_stare/fcn_unet_s5-d16_128x128_40k_stare_20201223_191051-7d77e78b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/unet_s5-d16_128x128_40k_stare/unet_s5-d16_128x128_40k_stare-20201223_191051.log.json)                                                                                                 |
-| UNet + FCN       | UNet-S5-D16 | Cross Entropy + Dice | 605x700    | 128x128   |  85x85 | 40000   | 0.986    |              - | V100   | 90.65 | 82.70 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201821-f75705a9.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201821.log.json)                         |
-| UNet + PSPNet    | UNet-S5-D16 | Cross Entropy        | 605x700    | 128x128   |  85x85 | 40000   | 0.982    |              - | V100   | 89.89 | 81.22 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_pspnet_4xb4-40k_stare-128x128.py)                    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_128x128_40k_stare/pspnet_unet_s5-d16_128x128_40k_stare_20201227_181818-3c2923c4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_128x128_40k_stare/pspnet_unet_s5-d16_128x128_40k_stare-20201227_181818.log.json)                                                                             |
-| UNet + PSPNet    | UNet-S5-D16 | Cross Entropy + Dice | 605x700    | 128x128   |  85x85 | 40000   | 1.028    |              - | V100   | 90.72 | 82.84 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201823-f1063ef7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201823.log.json)             |
-| UNet + DeepLabV3 | UNet-S5-D16 | Cross Entropy        | 605x700    | 128x128   |  85x85 | 40000   | 0.999    |              - | V100   | 89.73 | 80.93 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_stare-128x128.py)                 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_128x128_40k_stare/deeplabv3_unet_s5-d16_128x128_40k_stare_20201226_094047-93dcb93c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_128x128_40k_stare/deeplabv3_unet_s5-d16_128x128_40k_stare-20201226_094047.log.json)                                                                 |
-| UNet + DeepLabV3 | UNet-S5-D16 | Cross Entropy + Dice | 605x700    | 128x128   |  85x85 | 40000   | 1.010    |              - | V100   | 90.65 | 82.71 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201825-21db614c.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201825.log.json) |
-
-### CHASE_DB1
-
-| Method           | Backbone    | Loss                 | Image Size | Crop Size | Stride | Lr schd | Mem (GB) | Inf time (fps) | Device | mDice |  Dice | config                                                                                                                                            | download                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| ---------------- | ----------- | -------------------- | ---------- | --------- | -----: | ------- | -------- | -------------: | ------ | ----: | ----: | ------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| UNet + FCN       | UNet-S5-D16 | Cross Entropy        | 960x999    | 128x128   |  85x85 | 40000   | 0.968    |              - | V100   | 89.46 | 80.24 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_fcn_4xb4-40k_chase-db1-128x128.py)                       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_128x128_40k_chase_db1/fcn_unet_s5-d16_128x128_40k_chase_db1_20201223_191051-11543527.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/unet_s5-d16_128x128_40k_chase_db1/unet_s5-d16_128x128_40k_chase_db1-20201223_191051.log.json)                                                                                                 |
-| UNet + FCN       | UNet-S5-D16 | Cross Entropy + Dice | 960x999    | 128x128   |  85x85 | 40000   | 0.986    |              - | V100   | 89.52 | 80.40 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201821-1c4eb7cf.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201821.log.json)                         |
-| UNet + PSPNet    | UNet-S5-D16 | Cross Entropy        | 960x999    | 128x128   |  85x85 | 40000   | 0.982    |              - | V100   | 89.52 | 80.36 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_pspnet_4xb4-40k_chase-db1-128x128.py)                    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_128x128_40k_chase_db1/pspnet_unet_s5-d16_128x128_40k_chase_db1_20201227_181818-68d4e609.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_128x128_40k_chase_db1/pspnet_unet_s5-d16_128x128_40k_chase_db1-20201227_181818.log.json)                                                                             |
-| UNet + PSPNet    | UNet-S5-D16 | Cross Entropy + Dice | 960x999    | 128x128   |  85x85 | 40000   | 1.028    |              - | V100   | 89.45 | 80.28 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201823-c0802c4d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201823.log.json)             |
-| UNet + DeepLabV3 | UNet-S5-D16 | Cross Entropy        | 960x999    | 128x128   |  85x85 | 40000   | 0.999    |              - | V100   | 89.57 | 80.47 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet_s5-d16_deeplabv3_4xb4-40k_chase-db1-128x128.py)                 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_128x128_40k_chase_db1/deeplabv3_unet_s5-d16_128x128_40k_chase_db1_20201226_094047-4c5aefa3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_128x128_40k_chase_db1/deeplabv3_unet_s5-d16_128x128_40k_chase_db1-20201226_094047.log.json)                                                                 |
-| UNet + DeepLabV3 | UNet-S5-D16 | Cross Entropy + Dice | 960x999    | 128x128   |  85x85 | 40000   | 1.010    |              - | V100   | 89.49 | 80.37 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201825-4ef29df5.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201825.log.json) |
-
-### HRF
-
-| Method           | Backbone    | Loss                 | Image Size | Crop Size |  Stride | Lr schd | Mem (GB) | Inf time (fps) | Device | mDice |  Dice | config                                                                                                                                      | download                                                                                                                                                                                                                                                                                                                                                                                                         |
-| ---------------- | ----------- | -------------------- | ---------- | --------- | ------: | ------- | -------- | -------------: | ------ | ----: | ----: | ------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| UNet + FCN       | UNet-S5-D16 | Cross Entropy        | 2336x3504  | 256x256   | 170x170 | 40000   | 2.525    |              - | V100   | 88.92 | 79.45 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_fcn_4xb4-40k_hrf-256x256.py)                       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_256x256_40k_hrf/fcn_unet_s5-d16_256x256_40k_hrf_20201223_173724-d89cf1ed.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/unet_s5-d16_256x256_40k_hrf/unet_s5-d16_256x256_40k_hrf-20201223_173724.log.json)                                                                                                 |
-| UNet + FCN       | UNet-S5-D16 | Cross Entropy + Dice | 2336x3504  | 256x256   | 170x170 | 40000   | 2.623    |              - | V100   | 89.64 | 80.87 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py)       | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/fcn_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_201821-c314da8a.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/fcn_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_201821.log.json)                         |
-| UNet + PSPNet    | UNet-S5-D16 | Cross Entropy        | 2336x3504  | 256x256   | 170x170 | 40000   | 2.588    |              - | V100   | 89.24 | 80.07 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_pspnet_4xb4-40k_hrf-256x256.py)                    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_256x256_40k_hrf/pspnet_unet_s5-d16_256x256_40k_hrf_20201227_181818-fdb7e29b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_256x256_40k_hrf/pspnet_unet_s5-d16_256x256_40k_hrf-20201227_181818.log.json)                                                                             |
-| UNet + PSPNet    | UNet-S5-D16 | Cross Entropy + Dice | 2336x3504  | 256x256   | 170x170 | 40000   | 2.798    |              - | V100   | 89.69 | 80.96 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/pspnet_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_201823-53d492fa.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/pspnet_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_201823.log.json)             |
-| UNet + DeepLabV3 | UNet-S5-D16 | Cross Entropy        | 2336x3504  | 256x256   | 170x170 | 40000   | 2.604    |              - | V100   | 89.32 | 80.21 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_hrf-256x256.py)                 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_256x256_40k_hrf/deeplabv3_unet_s5-d16_256x256_40k_hrf_20201226_094047-3a1fdf85.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_256x256_40k_hrf/deeplabv3_unet_s5-d16_256x256_40k_hrf-20201226_094047.log.json)                                                                 |
-| UNet + DeepLabV3 | UNet-S5-D16 | Cross Entropy + Dice | 2336x3504  | 256x256   | 170x170 | 40000   | 2.607    |              - | V100   | 89.56 | 80.71 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_202032-59daf7a4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_202032.log.json) |
-
-Note:
-
-- In  `DRIVE`, `STARE`, `CHASE_DB1`, and `HRF` dataset, `mDice` is mean dice of background and vessel, while `Dice` is dice metric of vessel(foreground) only.
-
-## Citation
-
-```bibtex
-@inproceedings{ronneberger2015u,
-  title={U-net: Convolutional networks for biomedical image segmentation},
-  author={Ronneberger, Olaf and Fischer, Philipp and Brox, Thomas},
-  booktitle={International Conference on Medical image computing and computer-assisted intervention},
-  pages={234--241},
-  year={2015},
-  organization={Springer}
-}
-```
diff --git a/mmsegmentation/configs/unet/metafile.yaml b/mmsegmentation/configs/unet/metafile.yaml
deleted file mode 100644
index 1eafbc6..0000000
--- a/mmsegmentation/configs/unet/metafile.yaml
+++ /dev/null
@@ -1,642 +0,0 @@
-Collections:
-- Name: UNet
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-    - DRIVE
-    - STARE
-    - CHASE_DB1
-    - HRF
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  README: configs/unet/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 69.1
-      mIoU(ms+flip): 71.05
-  Config: configs/unet/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 17.91
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_4x4_512x1024_160k_cityscapes/fcn_unet_s5-d16_4x4_512x1024_160k_cityscapes_20211210_145204-6860854e.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_4x4_512x1024_160k_cityscapes/fcn_unet_s5-d16_4x4_512x1024_160k_cityscapes_20211210_145204.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet-s5-d16_fcn_4xb4-40k_drive-64x64
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: DRIVE
-    Metrics:
-      mDice: 88.38
-      Dice: 78.67
-  Config: configs/unet/unet-s5-d16_fcn_4xb4-40k_drive-64x64.py
-  Metadata:
-    Training Data: DRIVE
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 0.68
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_64x64_40k_drive/fcn_unet_s5-d16_64x64_40k_drive_20201223_191051-5daf6d3b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/unet_s5-d16_64x64_40k_drive/unet_s5-d16_64x64_40k_drive-20201223_191051.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_drive-64x64
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: DRIVE
-    Metrics:
-      mDice: 88.71
-      Dice: 79.32
-  Config: configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
-  Metadata:
-    Training Data: DRIVE
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 0.582
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/fcn_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201820-785de5c2.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/fcn_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201820.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet-s5-d16_pspnet_4xb4-40k_drive-64x64
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: DRIVE
-    Metrics:
-      mDice: 88.35
-      Dice: 78.62
-  Config: configs/unet/unet-s5-d16_pspnet_4xb4-40k_drive-64x64.py
-  Metadata:
-    Training Data: DRIVE
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 0.599
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_64x64_40k_drive/pspnet_unet_s5-d16_64x64_40k_drive_20201227_181818-aac73387.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_64x64_40k_drive/pspnet_unet_s5-d16_64x64_40k_drive-20201227_181818.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_drive-64x64
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: DRIVE
-    Metrics:
-      mDice: 88.76
-      Dice: 79.42
-  Config: configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
-  Metadata:
-    Training Data: DRIVE
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 0.585
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/pspnet_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201821-22b3e3ba.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/pspnet_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201821.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet-s5-d16_deeplabv3_4xb4-40k_drive-64x64
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: DRIVE
-    Metrics:
-      mDice: 88.38
-      Dice: 78.69
-  Config: configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_drive-64x64.py
-  Metadata:
-    Training Data: DRIVE
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 0.596
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_64x64_40k_drive/deeplabv3_unet_s5-d16_64x64_40k_drive_20201226_094047-0671ff20.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_64x64_40k_drive/deeplabv3_unet_s5-d16_64x64_40k_drive-20201226_094047.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_drive-64x64
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: DRIVE
-    Metrics:
-      mDice: 88.84
-      Dice: 79.56
-  Config: configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
-  Metadata:
-    Training Data: DRIVE
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 0.582
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201825-6bf0efd7.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_64x64_40k_drive_20211210_201825.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet-s5-d16_fcn_4xb4-40k_stare-128x128
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: STARE
-    Metrics:
-      mDice: 89.78
-      Dice: 81.02
-  Config: configs/unet/unet-s5-d16_fcn_4xb4-40k_stare-128x128.py
-  Metadata:
-    Training Data: STARE
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 0.968
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_128x128_40k_stare/fcn_unet_s5-d16_128x128_40k_stare_20201223_191051-7d77e78b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/unet_s5-d16_128x128_40k_stare/unet_s5-d16_128x128_40k_stare-20201223_191051.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_stare-128x128
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: STARE
-    Metrics:
-      mDice: 90.65
-      Dice: 82.7
-  Config: configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
-  Metadata:
-    Training Data: STARE
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 0.986
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201821-f75705a9.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201821.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet-s5-d16_pspnet_4xb4-40k_stare-128x128
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: STARE
-    Metrics:
-      mDice: 89.89
-      Dice: 81.22
-  Config: configs/unet/unet-s5-d16_pspnet_4xb4-40k_stare-128x128.py
-  Metadata:
-    Training Data: STARE
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 0.982
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_128x128_40k_stare/pspnet_unet_s5-d16_128x128_40k_stare_20201227_181818-3c2923c4.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_128x128_40k_stare/pspnet_unet_s5-d16_128x128_40k_stare-20201227_181818.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_stare-128x128
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: STARE
-    Metrics:
-      mDice: 90.72
-      Dice: 82.84
-  Config: configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
-  Metadata:
-    Training Data: STARE
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.028
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201823-f1063ef7.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201823.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet-s5-d16_deeplabv3_4xb4-40k_stare-128x128
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: STARE
-    Metrics:
-      mDice: 89.73
-      Dice: 80.93
-  Config: configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_stare-128x128.py
-  Metadata:
-    Training Data: STARE
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 0.999
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_128x128_40k_stare/deeplabv3_unet_s5-d16_128x128_40k_stare_20201226_094047-93dcb93c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_128x128_40k_stare/deeplabv3_unet_s5-d16_128x128_40k_stare-20201226_094047.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_stare-128x128
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: STARE
-    Metrics:
-      mDice: 90.65
-      Dice: 82.71
-  Config: configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
-  Metadata:
-    Training Data: STARE
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.01
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201825-21db614c.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_stare_20211210_201825.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet-s5-d16_fcn_4xb4-40k_chase-db1-128x128
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: CHASE_DB1
-    Metrics:
-      mDice: 89.46
-      Dice: 80.24
-  Config: configs/unet/unet-s5-d16_fcn_4xb4-40k_chase-db1-128x128.py
-  Metadata:
-    Training Data: CHASE_DB1
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 0.968
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_128x128_40k_chase_db1/fcn_unet_s5-d16_128x128_40k_chase_db1_20201223_191051-11543527.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/unet_s5-d16_128x128_40k_chase_db1/unet_s5-d16_128x128_40k_chase_db1-20201223_191051.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: CHASE_DB1
-    Metrics:
-      mDice: 89.52
-      Dice: 80.4
-  Config: configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
-  Metadata:
-    Training Data: CHASE_DB1
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 0.986
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201821-1c4eb7cf.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/fcn_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201821.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet-s5-d16_pspnet_4xb4-40k_chase-db1-128x128
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: CHASE_DB1
-    Metrics:
-      mDice: 89.52
-      Dice: 80.36
-  Config: configs/unet/unet-s5-d16_pspnet_4xb4-40k_chase-db1-128x128.py
-  Metadata:
-    Training Data: CHASE_DB1
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 0.982
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_128x128_40k_chase_db1/pspnet_unet_s5-d16_128x128_40k_chase_db1_20201227_181818-68d4e609.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_128x128_40k_chase_db1/pspnet_unet_s5-d16_128x128_40k_chase_db1-20201227_181818.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: CHASE_DB1
-    Metrics:
-      mDice: 89.45
-      Dice: 80.28
-  Config: configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
-  Metadata:
-    Training Data: CHASE_DB1
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.028
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201823-c0802c4d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/pspnet_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201823.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet_s5-d16_deeplabv3_4xb4-40k_chase-db1-128x128
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: CHASE_DB1
-    Metrics:
-      mDice: 89.57
-      Dice: 80.47
-  Config: configs/unet/unet_s5-d16_deeplabv3_4xb4-40k_chase-db1-128x128.py
-  Metadata:
-    Training Data: CHASE_DB1
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 0.999
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_128x128_40k_chase_db1/deeplabv3_unet_s5-d16_128x128_40k_chase_db1_20201226_094047-4c5aefa3.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_128x128_40k_chase_db1/deeplabv3_unet_s5-d16_128x128_40k_chase_db1-20201226_094047.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: CHASE_DB1
-    Metrics:
-      mDice: 89.49
-      Dice: 80.37
-  Config: configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
-  Metadata:
-    Training Data: CHASE_DB1
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 1.01
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201825-4ef29df5.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_128x128_40k_chase-db1_20211210_201825.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet-s5-d16_fcn_4xb4-40k_hrf-256x256
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: HRF
-    Metrics:
-      mDice: 88.92
-      Dice: 79.45
-  Config: configs/unet/unet-s5-d16_fcn_4xb4-40k_hrf-256x256.py
-  Metadata:
-    Training Data: HRF
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 2.525
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_256x256_40k_hrf/fcn_unet_s5-d16_256x256_40k_hrf_20201223_173724-d89cf1ed.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/unet_s5-d16_256x256_40k_hrf/unet_s5-d16_256x256_40k_hrf-20201223_173724.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: HRF
-    Metrics:
-      mDice: 89.64
-      Dice: 80.87
-  Config: configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
-  Metadata:
-    Training Data: HRF
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - FCN
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 2.623
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/fcn_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_201821-c314da8a.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/fcn_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/fcn_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_201821.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet-s5-d16_pspnet_4xb4-40k_hrf-256x256
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: HRF
-    Metrics:
-      mDice: 89.24
-      Dice: 80.07
-  Config: configs/unet/unet-s5-d16_pspnet_4xb4-40k_hrf-256x256.py
-  Metadata:
-    Training Data: HRF
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 2.588
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_256x256_40k_hrf/pspnet_unet_s5-d16_256x256_40k_hrf_20201227_181818-fdb7e29b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_256x256_40k_hrf/pspnet_unet_s5-d16_256x256_40k_hrf-20201227_181818.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: HRF
-    Metrics:
-      mDice: 89.69
-      Dice: 80.96
-  Config: configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
-  Metadata:
-    Training Data: HRF
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - PSPNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 2.798
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/pspnet_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_201823-53d492fa.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/pspnet_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/pspnet_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_201823.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet-s5-d16_deeplabv3_4xb4-40k_hrf-256x256
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: HRF
-    Metrics:
-      mDice: 89.32
-      Dice: 80.21
-  Config: configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_hrf-256x256.py
-  Metadata:
-    Training Data: HRF
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 2.604
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_256x256_40k_hrf/deeplabv3_unet_s5-d16_256x256_40k_hrf_20201226_094047-3a1fdf85.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_256x256_40k_hrf/deeplabv3_unet_s5-d16_256x256_40k_hrf-20201226_094047.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
-- Name: unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256
-  In Collection: UNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: HRF
-    Metrics:
-      mDice: 89.56
-      Dice: 80.71
-  Config: configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
-  Metadata:
-    Training Data: HRF
-    Batch Size: 16
-    Architecture:
-    - UNet-S5-D16
-    - UNet
-    - DeepLabV3
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 2.607
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_202032-59daf7a4.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/unet/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf/deeplabv3_unet_s5-d16_ce-1.0-dice-3.0_256x256_40k_hrf_20211210_202032.log.json
-  Paper:
-    Title: 'U-Net: Convolutional Networks for Biomedical Image Segmentation'
-    URL: https://arxiv.org/abs/1505.04597
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/unet.py#L225
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_drive-64x64.py b/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_drive-64x64.py
deleted file mode 100644
index e4af542..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_drive-64x64.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_unet_s5-d16.py', '../_base_/datasets/drive.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (64, 64)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    test_cfg=dict(crop_size=(64, 64), stride=(42, 42)))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_hrf-256x256.py b/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_hrf-256x256.py
deleted file mode 100644
index b45405f..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_hrf-256x256.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_unet_s5-d16.py', '../_base_/datasets/hrf.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (256, 256)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    test_cfg=dict(crop_size=(256, 256), stride=(170, 170)))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_stare-128x128.py b/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_stare-128x128.py
deleted file mode 100644
index 554caca..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-40k_stare-128x128.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_unet_s5-d16.py', '../_base_/datasets/stare.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (128, 128)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    test_cfg=dict(crop_size=(128, 128), stride=(85, 85)))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py b/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
deleted file mode 100644
index 4f30bba..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './unet_s5-d16_deeplabv3_4xb4-40k_chase-db1-128x128.py'
-model = dict(
-    decode_head=dict(loss_decode=[
-        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
-        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
-    ]))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py b/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
deleted file mode 100644
index 823fc6d..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './unet-s5-d16_deeplabv3_4xb4-40k_drive-64x64.py'
-model = dict(
-    decode_head=dict(loss_decode=[
-        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
-        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
-    ]))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py b/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
deleted file mode 100644
index 174eaf8..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './unet-s5-d16_deeplabv3_4xb4-40k_hrf-256x256.py'
-model = dict(
-    decode_head=dict(loss_decode=[
-        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
-        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
-    ]))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py b/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
deleted file mode 100644
index 35972be..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_deeplabv3_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './unet-s5-d16_deeplabv3_4xb4-40k_stare-128x128.py'
-model = dict(
-    decode_head=dict(loss_decode=[
-        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
-        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
-    ]))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py
deleted file mode 100644
index c2e995d..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,16 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_unet_s5-d16.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=19),
-    auxiliary_head=dict(num_classes=19),
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
-train_dataloader = dict(batch_size=4, num_workers=4)
-val_dataloader = dict(batch_size=1, num_workers=4)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-160k_hsidrive-192x384.py b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-160k_hsidrive-192x384.py
deleted file mode 100644
index a5768ba..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-160k_hsidrive-192x384.py
+++ /dev/null
@@ -1,36 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_unet_s5-d16.py', '../_base_/datasets/hsi_drive.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (192, 384)
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    size=crop_size,
-    mean=None,
-    std=None,
-    bgr_to_rgb=None,
-    pad_val=0,
-    seg_pad_val=255)
-
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(in_channels=25),
-    decode_head=dict(
-        ignore_index=0,
-        num_classes=11,
-        loss_decode=dict(
-            type='CrossEntropyLoss',
-            use_sigmoid=False,
-            loss_weight=1.0,
-            avg_non_ignore=True)),
-    auxiliary_head=dict(
-        ignore_index=0,
-        num_classes=11,
-        loss_decode=dict(
-            type='CrossEntropyLoss',
-            use_sigmoid=False,
-            loss_weight=1.0,
-            avg_non_ignore=True)),
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_chase-db1-128x128.py b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_chase-db1-128x128.py
deleted file mode 100644
index bfc2109..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_chase-db1-128x128.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_unet_s5-d16.py', '../_base_/datasets/chase_db1.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (128, 128)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    test_cfg=dict(crop_size=(128, 128), stride=(85, 85)))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_drive-64x64.py b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_drive-64x64.py
deleted file mode 100644
index 10a45d1..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_drive-64x64.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_unet_s5-d16.py', '../_base_/datasets/drive.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (64, 64)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    test_cfg=dict(crop_size=(64, 64), stride=(42, 42)))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_hrf-256x256.py b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_hrf-256x256.py
deleted file mode 100644
index 7de57f2..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_hrf-256x256.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_unet_s5-d16.py', '../_base_/datasets/hrf.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (256, 256)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    test_cfg=dict(crop_size=(256, 256), stride=(170, 170)))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_stare-128x128.py b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_stare-128x128.py
deleted file mode 100644
index 8eeef77..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-40k_stare-128x128.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_unet_s5-d16.py', '../_base_/datasets/stare.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (128, 128)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    test_cfg=dict(crop_size=(128, 128), stride=(85, 85)))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
deleted file mode 100644
index 5a26ccb..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './unet-s5-d16_fcn_4xb4-40k_chase-db1-128x128.py'
-model = dict(
-    decode_head=dict(loss_decode=[
-        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
-        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
-    ]))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
deleted file mode 100644
index c3b1488..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './unet-s5-d16_fcn_4xb4-40k_drive-64x64.py'
-model = dict(
-    decode_head=dict(loss_decode=[
-        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
-        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
-    ]))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
deleted file mode 100644
index dd3a6af..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './unet-s5-d16_fcn_4xb4-40k_hrf-256x256.py'
-model = dict(
-    decode_head=dict(loss_decode=[
-        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
-        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
-    ]))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py b/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
deleted file mode 100644
index c8fecf3..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_fcn_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './unet-s5-d16_fcn_4xb4-40k_stare-128x128.py'
-model = dict(
-    decode_head=dict(loss_decode=[
-        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
-        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
-    ]))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_chase-db1-128x128.py b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_chase-db1-128x128.py
deleted file mode 100644
index ca6e513..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_chase-db1-128x128.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_unet_s5-d16.py',
-    '../_base_/datasets/chase_db1.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (128, 128)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    test_cfg=dict(crop_size=(128, 128), stride=(85, 85)))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_drive-64x64.py b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_drive-64x64.py
deleted file mode 100644
index 503b901..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_drive-64x64.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_unet_s5-d16.py', '../_base_/datasets/drive.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (64, 64)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    test_cfg=dict(crop_size=(64, 64), stride=(42, 42)))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_hrf-256x256.py b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_hrf-256x256.py
deleted file mode 100644
index 245365c..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_hrf-256x256.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_unet_s5-d16.py', '../_base_/datasets/hrf.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (256, 256)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    test_cfg=dict(crop_size=(256, 256), stride=(170, 170)))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_stare-128x128.py b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_stare-128x128.py
deleted file mode 100644
index c1eeeb9..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-40k_stare-128x128.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_unet_s5-d16.py', '../_base_/datasets/stare.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (128, 128)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    test_cfg=dict(crop_size=(128, 128), stride=(85, 85)))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
deleted file mode 100644
index 69a4bba..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_chase-db1-128x128.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './unet-s5-d16_pspnet_4xb4-40k_chase-db1-128x128.py'
-model = dict(
-    decode_head=dict(loss_decode=[
-        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
-        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
-    ]))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
deleted file mode 100644
index 1abbd53..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_drive-64x64.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './unet-s5-d16_pspnet_4xb4-40k_drive-64x64.py'
-model = dict(
-    decode_head=dict(loss_decode=[
-        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
-        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
-    ]))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
deleted file mode 100644
index b3256d7..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_hrf-256x256.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './unet-s5-d16_pspnet_4xb4-40k_hrf-256x256.py'
-model = dict(
-    decode_head=dict(loss_decode=[
-        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
-        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
-    ]))
diff --git a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py b/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
deleted file mode 100644
index 82aa3da..0000000
--- a/mmsegmentation/configs/unet/unet-s5-d16_pspnet_4xb4-ce-1.0-dice-3.0-40k_stare-128x128.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './unet-s5-d16_pspnet_4xb4-40k_stare-128x128.py'
-model = dict(
-    decode_head=dict(loss_decode=[
-        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
-        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
-    ]))
diff --git a/mmsegmentation/configs/unet/unet_s5-d16_deeplabv3_4xb4-40k_chase-db1-128x128.py b/mmsegmentation/configs/unet/unet_s5-d16_deeplabv3_4xb4-40k_chase-db1-128x128.py
deleted file mode 100644
index 82494f3..0000000
--- a/mmsegmentation/configs/unet/unet_s5-d16_deeplabv3_4xb4-40k_chase-db1-128x128.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_unet_s5-d16.py',
-    '../_base_/datasets/chase_db1.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (128, 128)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    test_cfg=dict(crop_size=(128, 128), stride=(85, 85)))
diff --git a/mmsegmentation/configs/upernet/README.md b/mmsegmentation/configs/upernet/README.md
deleted file mode 100644
index c2babbd..0000000
--- a/mmsegmentation/configs/upernet/README.md
+++ /dev/null
@@ -1,68 +0,0 @@
-# UPerNet
-
-> [Unified Perceptual Parsing for Scene Understanding](https://arxiv.org/pdf/1807.10221.pdf)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/CSAILVision/unifiedparsing">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Humans recognize the visual world at multiple levels: we effortlessly categorize scenes and detect objects inside, while also identifying the textures and surfaces of the objects along with their different compositional parts. In this paper, we study a new task called Unified Perceptual Parsing, which requires the machine vision systems to recognize as many visual concepts as possible from a given image. A multi-task framework called UPerNet and a training strategy are developed to learn from heterogeneous image annotations. We benchmark our framework on Unified Perceptual Parsing and show that it is able to effectively segment a wide range of concepts from images. The trained networks are further applied to discover visual knowledge in natural scenes. Models are available at [this https URL](https://github.com/CSAILVision/unifiedparsing).
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142903077-44e8e0da-7276-4bda-bd2b-0df1680ca845.png" width="70%"/>
-</div>
-
-## Results and models
-
-### Cityscapes
-
-| Method  | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                        | download                                                                                                                                                                                                                                                                                                                                           |
-| ------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ----------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| UPerNet | R-50     | 512x1024  |   40000 | 6.4      | 4.25           | V100   | 77.10 |         78.37 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r50_4xb2-40k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x1024_40k_cityscapes/upernet_r50_512x1024_40k_cityscapes_20200605_094827-aa54cb54.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x1024_40k_cityscapes/upernet_r50_512x1024_40k_cityscapes_20200605_094827.log.json)     |
-| UPerNet | R-101    | 512x1024  |   40000 | 7.4      | 3.79           | V100   | 78.69 |         80.11 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r101_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x1024_40k_cityscapes/upernet_r101_512x1024_40k_cityscapes_20200605_094933-ebce3b10.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x1024_40k_cityscapes/upernet_r101_512x1024_40k_cityscapes_20200605_094933.log.json) |
-| UPerNet | R-50     | 769x769   |   40000 | 7.2      | 1.76           | V100   | 77.98 |         79.70 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r50_4xb2-40k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_769x769_40k_cityscapes/upernet_r50_769x769_40k_cityscapes_20200530_033048-92d21539.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_769x769_40k_cityscapes/upernet_r50_769x769_40k_cityscapes_20200530_033048.log.json)         |
-| UPerNet | R-101    | 769x769   |   40000 | 8.4      | 1.56           | V100   | 79.03 |         80.77 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r101_4xb2-40k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_769x769_40k_cityscapes/upernet_r101_769x769_40k_cityscapes_20200530_040819-83c95d01.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_769x769_40k_cityscapes/upernet_r101_769x769_40k_cityscapes_20200530_040819.log.json)     |
-| UPerNet | R-50     | 512x1024  |   80000 | -        | -              | V100   | 78.19 |         79.19 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r50_4xb2-80k_cityscapes-512x1024.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x1024_80k_cityscapes/upernet_r50_512x1024_80k_cityscapes_20200607_052207-848beca8.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x1024_80k_cityscapes/upernet_r50_512x1024_80k_cityscapes_20200607_052207.log.json)     |
-| UPerNet | R-101    | 512x1024  |   80000 | -        | -              | V100   | 79.40 |         80.46 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r101_4xb2-80k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x1024_80k_cityscapes/upernet_r101_512x1024_80k_cityscapes_20200607_002403-f05f2345.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x1024_80k_cityscapes/upernet_r101_512x1024_80k_cityscapes_20200607_002403.log.json) |
-| UPerNet | R-50     | 769x769   |   80000 | -        | -              | V100   | 79.39 |         80.92 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r50_4xb2-80k_cityscapes-769x769.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_769x769_80k_cityscapes/upernet_r50_769x769_80k_cityscapes_20200607_005107-82ae7d15.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_769x769_80k_cityscapes/upernet_r50_769x769_80k_cityscapes_20200607_005107.log.json)         |
-| UPerNet | R-101    | 769x769   |   80000 | -        | -              | V100   | 80.10 |         81.49 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r101_4xb2-80k_cityscapes-769x769.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_769x769_80k_cityscapes/upernet_r101_769x769_80k_cityscapes_20200607_001014-082fc334.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_769x769_80k_cityscapes/upernet_r101_769x769_80k_cityscapes_20200607_001014.log.json)     |
-
-### ADE20K
-
-| Method  | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                    | download                                                                                                                                                                                                                                                                                                                           |
-| ------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| UPerNet | R-50     | 512x512   |   80000 | 8.1      | 23.40          | V100   | 40.70 |         41.81 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r50_4xb4-80k_ade20k-512x512.py)   | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_80k_ade20k/upernet_r50_512x512_80k_ade20k_20200614_144127-ecc8377b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_80k_ade20k/upernet_r50_512x512_80k_ade20k_20200614_144127.log.json)         |
-| UPerNet | R-101    | 512x512   |   80000 | 9.1      | 20.34          | V100   | 42.91 |         43.96 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r101_4xb4-80k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_80k_ade20k/upernet_r101_512x512_80k_ade20k_20200614_185117-32e4db94.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_80k_ade20k/upernet_r101_512x512_80k_ade20k_20200614_185117.log.json)     |
-| UPerNet | R-50     | 512x512   |  160000 | -        | -              | V100   | 42.05 |         42.78 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r50_4xb4-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_160k_ade20k/upernet_r50_512x512_160k_ade20k_20200615_184328-8534de8d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_160k_ade20k/upernet_r50_512x512_160k_ade20k_20200615_184328.log.json)     |
-| UPerNet | R-101    | 512x512   |  160000 | -        | -              | V100   | 43.82 |         44.85 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r101_4xb4-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_160k_ade20k/upernet_r101_512x512_160k_ade20k_20200615_161951-91b32684.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_160k_ade20k/upernet_r101_512x512_160k_ade20k_20200615_161951.log.json) |
-
-### Pascal VOC 2012 + Aug
-
-| Method  | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                     | download                                                                                                                                                                                                                                                                                                                               |
-| ------- | -------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | -------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| UPerNet | R-50     | 512x512   |   20000 | 6.4      | 23.17          | V100   | 74.82 |         76.35 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r50_4xb4-20k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_20k_voc12aug/upernet_r50_512x512_20k_voc12aug_20200617_165330-5b5890a7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_20k_voc12aug/upernet_r50_512x512_20k_voc12aug_20200617_165330.log.json)     |
-| UPerNet | R-101    | 512x512   |   20000 | 7.5      | 19.98          | V100   | 77.10 |         78.29 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r101_4xb4-20k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_20k_voc12aug/upernet_r101_512x512_20k_voc12aug_20200617_165629-f14e7f27.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_20k_voc12aug/upernet_r101_512x512_20k_voc12aug_20200617_165629.log.json) |
-| UPerNet | R-50     | 512x512   |   40000 | -        | -              | V100   | 75.92 |         77.44 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r50_4xb4-40k_voc12aug-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_40k_voc12aug/upernet_r50_512x512_40k_voc12aug_20200613_162257-ca9bcc6b.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_40k_voc12aug/upernet_r50_512x512_40k_voc12aug_20200613_162257.log.json)     |
-| UPerNet | R-101    | 512x512   |   40000 | -        | -              | V100   | 77.43 |         78.56 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet/upernet_r101_4xb4-40k_voc12aug-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_40k_voc12aug/upernet_r101_512x512_40k_voc12aug_20200613_163549-e26476ac.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_40k_voc12aug/upernet_r101_512x512_40k_voc12aug_20200613_163549.log.json) |
-
-## Citation
-
-```bibtex
-@inproceedings{xiao2018unified,
-  title={Unified perceptual parsing for scene understanding},
-  author={Xiao, Tete and Liu, Yingcheng and Zhou, Bolei and Jiang, Yuning and Sun, Jian},
-  booktitle={Proceedings of the European Conference on Computer Vision (ECCV)},
-  pages={418--434},
-  year={2018}
-}
-```
diff --git a/mmsegmentation/configs/upernet/metafile.yaml b/mmsegmentation/configs/upernet/metafile.yaml
deleted file mode 100644
index f6ad818..0000000
--- a/mmsegmentation/configs/upernet/metafile.yaml
+++ /dev/null
@@ -1,391 +0,0 @@
-Collections:
-- Name: UPerNet
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - Cityscapes
-    - ADE20K
-    - Pascal VOC 2012 + Aug
-  Paper:
-    Title: Unified Perceptual Parsing for Scene Understanding
-    URL: https://arxiv.org/pdf/1807.10221.pdf
-  README: configs/upernet/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: upernet_r50_4xb2-40k_cityscapes-512x1024
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.1
-      mIoU(ms+flip): 78.37
-  Config: configs/upernet/upernet_r50_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50
-    - UPerNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.4
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x1024_40k_cityscapes/upernet_r50_512x1024_40k_cityscapes_20200605_094827-aa54cb54.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x1024_40k_cityscapes/upernet_r50_512x1024_40k_cityscapes_20200605_094827.log.json
-  Paper:
-    Title: Unified Perceptual Parsing for Scene Understanding
-    URL: https://arxiv.org/pdf/1807.10221.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
-  Framework: PyTorch
-- Name: upernet_r101_4xb2-40k_cityscapes-512x1024
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.69
-      mIoU(ms+flip): 80.11
-  Config: configs/upernet/upernet_r101_4xb2-40k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101
-    - UPerNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 7.4
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x1024_40k_cityscapes/upernet_r101_512x1024_40k_cityscapes_20200605_094933-ebce3b10.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x1024_40k_cityscapes/upernet_r101_512x1024_40k_cityscapes_20200605_094933.log.json
-  Paper:
-    Title: Unified Perceptual Parsing for Scene Understanding
-    URL: https://arxiv.org/pdf/1807.10221.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
-  Framework: PyTorch
-- Name: upernet_r50_4xb2-40k_cityscapes-769x769
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 77.98
-      mIoU(ms+flip): 79.7
-  Config: configs/upernet/upernet_r50_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50
-    - UPerNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 7.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_769x769_40k_cityscapes/upernet_r50_769x769_40k_cityscapes_20200530_033048-92d21539.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_769x769_40k_cityscapes/upernet_r50_769x769_40k_cityscapes_20200530_033048.log.json
-  Paper:
-    Title: Unified Perceptual Parsing for Scene Understanding
-    URL: https://arxiv.org/pdf/1807.10221.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
-  Framework: PyTorch
-- Name: upernet_r101_4xb2-40k_cityscapes-769x769
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.03
-      mIoU(ms+flip): 80.77
-  Config: configs/upernet/upernet_r101_4xb2-40k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101
-    - UPerNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.4
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_769x769_40k_cityscapes/upernet_r101_769x769_40k_cityscapes_20200530_040819-83c95d01.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_769x769_40k_cityscapes/upernet_r101_769x769_40k_cityscapes_20200530_040819.log.json
-  Paper:
-    Title: Unified Perceptual Parsing for Scene Understanding
-    URL: https://arxiv.org/pdf/1807.10221.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
-  Framework: PyTorch
-- Name: upernet_r50_4xb2-80k_cityscapes-512x1024
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 78.19
-      mIoU(ms+flip): 79.19
-  Config: configs/upernet/upernet_r50_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50
-    - UPerNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x1024_80k_cityscapes/upernet_r50_512x1024_80k_cityscapes_20200607_052207-848beca8.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x1024_80k_cityscapes/upernet_r50_512x1024_80k_cityscapes_20200607_052207.log.json
-  Paper:
-    Title: Unified Perceptual Parsing for Scene Understanding
-    URL: https://arxiv.org/pdf/1807.10221.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
-  Framework: PyTorch
-- Name: upernet_r101_4xb2-80k_cityscapes-512x1024
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.4
-      mIoU(ms+flip): 80.46
-  Config: configs/upernet/upernet_r101_4xb2-80k_cityscapes-512x1024.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101
-    - UPerNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x1024_80k_cityscapes/upernet_r101_512x1024_80k_cityscapes_20200607_002403-f05f2345.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x1024_80k_cityscapes/upernet_r101_512x1024_80k_cityscapes_20200607_002403.log.json
-  Paper:
-    Title: Unified Perceptual Parsing for Scene Understanding
-    URL: https://arxiv.org/pdf/1807.10221.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
-  Framework: PyTorch
-- Name: upernet_r50_4xb2-80k_cityscapes-769x769
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 79.39
-      mIoU(ms+flip): 80.92
-  Config: configs/upernet/upernet_r50_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-50
-    - UPerNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_769x769_80k_cityscapes/upernet_r50_769x769_80k_cityscapes_20200607_005107-82ae7d15.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_769x769_80k_cityscapes/upernet_r50_769x769_80k_cityscapes_20200607_005107.log.json
-  Paper:
-    Title: Unified Perceptual Parsing for Scene Understanding
-    URL: https://arxiv.org/pdf/1807.10221.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
-  Framework: PyTorch
-- Name: upernet_r101_4xb2-80k_cityscapes-769x769
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Cityscapes
-    Metrics:
-      mIoU: 80.1
-      mIoU(ms+flip): 81.49
-  Config: configs/upernet/upernet_r101_4xb2-80k_cityscapes-769x769.py
-  Metadata:
-    Training Data: Cityscapes
-    Batch Size: 8
-    Architecture:
-    - R-101
-    - UPerNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_769x769_80k_cityscapes/upernet_r101_769x769_80k_cityscapes_20200607_001014-082fc334.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_769x769_80k_cityscapes/upernet_r101_769x769_80k_cityscapes_20200607_001014.log.json
-  Paper:
-    Title: Unified Perceptual Parsing for Scene Understanding
-    URL: https://arxiv.org/pdf/1807.10221.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
-  Framework: PyTorch
-- Name: upernet_r50_4xb4-80k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 40.7
-      mIoU(ms+flip): 41.81
-  Config: configs/upernet/upernet_r50_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50
-    - UPerNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 8.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_80k_ade20k/upernet_r50_512x512_80k_ade20k_20200614_144127-ecc8377b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_80k_ade20k/upernet_r50_512x512_80k_ade20k_20200614_144127.log.json
-  Paper:
-    Title: Unified Perceptual Parsing for Scene Understanding
-    URL: https://arxiv.org/pdf/1807.10221.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
-  Framework: PyTorch
-- Name: upernet_r101_4xb4-80k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.91
-      mIoU(ms+flip): 43.96
-  Config: configs/upernet/upernet_r101_4xb4-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101
-    - UPerNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 9.1
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_80k_ade20k/upernet_r101_512x512_80k_ade20k_20200614_185117-32e4db94.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_80k_ade20k/upernet_r101_512x512_80k_ade20k_20200614_185117.log.json
-  Paper:
-    Title: Unified Perceptual Parsing for Scene Understanding
-    URL: https://arxiv.org/pdf/1807.10221.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
-  Framework: PyTorch
-- Name: upernet_r50_4xb4-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.05
-      mIoU(ms+flip): 42.78
-  Config: configs/upernet/upernet_r50_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-50
-    - UPerNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_160k_ade20k/upernet_r50_512x512_160k_ade20k_20200615_184328-8534de8d.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_160k_ade20k/upernet_r50_512x512_160k_ade20k_20200615_184328.log.json
-  Paper:
-    Title: Unified Perceptual Parsing for Scene Understanding
-    URL: https://arxiv.org/pdf/1807.10221.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
-  Framework: PyTorch
-- Name: upernet_r101_4xb4-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 43.82
-      mIoU(ms+flip): 44.85
-  Config: configs/upernet/upernet_r101_4xb4-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - R-101
-    - UPerNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_160k_ade20k/upernet_r101_512x512_160k_ade20k_20200615_161951-91b32684.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_160k_ade20k/upernet_r101_512x512_160k_ade20k_20200615_161951.log.json
-  Paper:
-    Title: Unified Perceptual Parsing for Scene Understanding
-    URL: https://arxiv.org/pdf/1807.10221.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
-  Framework: PyTorch
-- Name: upernet_r50_4xb4-20k_voc12aug-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 74.82
-      mIoU(ms+flip): 76.35
-  Config: configs/upernet/upernet_r50_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50
-    - UPerNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 6.4
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_20k_voc12aug/upernet_r50_512x512_20k_voc12aug_20200617_165330-5b5890a7.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_20k_voc12aug/upernet_r50_512x512_20k_voc12aug_20200617_165330.log.json
-  Paper:
-    Title: Unified Perceptual Parsing for Scene Understanding
-    URL: https://arxiv.org/pdf/1807.10221.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
-  Framework: PyTorch
-- Name: upernet_r101_4xb4-20k_voc12aug-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 77.1
-      mIoU(ms+flip): 78.29
-  Config: configs/upernet/upernet_r101_4xb4-20k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101
-    - UPerNet
-    Training Resources: 4x V100 GPUS
-    Memory (GB): 7.5
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_20k_voc12aug/upernet_r101_512x512_20k_voc12aug_20200617_165629-f14e7f27.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_20k_voc12aug/upernet_r101_512x512_20k_voc12aug_20200617_165629.log.json
-  Paper:
-    Title: Unified Perceptual Parsing for Scene Understanding
-    URL: https://arxiv.org/pdf/1807.10221.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
-  Framework: PyTorch
-- Name: upernet_r50_4xb4-40k_voc12aug-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 75.92
-      mIoU(ms+flip): 77.44
-  Config: configs/upernet/upernet_r50_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-50
-    - UPerNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_40k_voc12aug/upernet_r50_512x512_40k_voc12aug_20200613_162257-ca9bcc6b.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r50_512x512_40k_voc12aug/upernet_r50_512x512_40k_voc12aug_20200613_162257.log.json
-  Paper:
-    Title: Unified Perceptual Parsing for Scene Understanding
-    URL: https://arxiv.org/pdf/1807.10221.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
-  Framework: PyTorch
-- Name: upernet_r101_4xb4-40k_voc12aug-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: Pascal VOC 2012 + Aug
-    Metrics:
-      mIoU: 77.43
-      mIoU(ms+flip): 78.56
-  Config: configs/upernet/upernet_r101_4xb4-40k_voc12aug-512x512.py
-  Metadata:
-    Training Data: Pascal VOC 2012 + Aug
-    Batch Size: 16
-    Architecture:
-    - R-101
-    - UPerNet
-    Training Resources: 4x V100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_40k_voc12aug/upernet_r101_512x512_40k_voc12aug_20200613_163549-e26476ac.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/upernet/upernet_r101_512x512_40k_voc12aug/upernet_r101_512x512_40k_voc12aug_20200613_163549.log.json
-  Paper:
-    Title: Unified Perceptual Parsing for Scene Understanding
-    URL: https://arxiv.org/pdf/1807.10221.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/decode_heads/uper_head.py#L13
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/upernet/upernet_r101_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/upernet/upernet_r101_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 8f5f6ae..0000000
--- a/mmsegmentation/configs/upernet/upernet_r101_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './upernet_r50_4xb2-40k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/upernet/upernet_r101_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/upernet/upernet_r101_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index 28b5d3e..0000000
--- a/mmsegmentation/configs/upernet/upernet_r101_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './upernet_r50_4xb2-40k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/upernet/upernet_r101_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/upernet/upernet_r101_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index cafd8a2..0000000
--- a/mmsegmentation/configs/upernet/upernet_r101_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './upernet_r50_4xb2-80k_cityscapes-512x1024.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/upernet/upernet_r101_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/upernet/upernet_r101_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index e175720..0000000
--- a/mmsegmentation/configs/upernet/upernet_r101_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './upernet_r50_4xb2-80k_cityscapes-769x769.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/upernet/upernet_r101_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/upernet/upernet_r101_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 7a61527..0000000
--- a/mmsegmentation/configs/upernet/upernet_r101_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './upernet_r50_4xb4-160k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/upernet/upernet_r101_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/upernet/upernet_r101_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index be8f084..0000000
--- a/mmsegmentation/configs/upernet/upernet_r101_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './upernet_r50_4xb4-20k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/upernet/upernet_r101_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/upernet/upernet_r101_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index db1d976..0000000
--- a/mmsegmentation/configs/upernet/upernet_r101_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './upernet_r50_4xb4-40k_voc12aug-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/upernet/upernet_r101_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/upernet/upernet_r101_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 84549a4..0000000
--- a/mmsegmentation/configs/upernet/upernet_r101_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './upernet_r50_4xb4-80k_ade20k-512x512.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/mmsegmentation/configs/upernet/upernet_r18_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/upernet/upernet_r18_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index dbff0e7..0000000
--- a/mmsegmentation/configs/upernet/upernet_r18_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './upernet_r50_4xb2-40k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='open-mmlab://resnet18_v1c',
-    backbone=dict(depth=18),
-    decode_head=dict(in_channels=[64, 128, 256, 512]),
-    auxiliary_head=dict(in_channels=256))
diff --git a/mmsegmentation/configs/upernet/upernet_r18_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/upernet/upernet_r18_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index dee6349..0000000
--- a/mmsegmentation/configs/upernet/upernet_r18_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './upernet_r50_4xb2-80k_cityscapes-512x1024.py'
-model = dict(
-    pretrained='open-mmlab://resnet18_v1c',
-    backbone=dict(depth=18),
-    decode_head=dict(in_channels=[64, 128, 256, 512]),
-    auxiliary_head=dict(in_channels=256))
diff --git a/mmsegmentation/configs/upernet/upernet_r18_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/upernet/upernet_r18_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 9ac6c35..0000000
--- a/mmsegmentation/configs/upernet/upernet_r18_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_r50.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-model = dict(
-    pretrained='open-mmlab://resnet18_v1c',
-    backbone=dict(depth=18),
-    decode_head=dict(in_channels=[64, 128, 256, 512], num_classes=150),
-    auxiliary_head=dict(in_channels=256, num_classes=150))
diff --git a/mmsegmentation/configs/upernet/upernet_r18_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/upernet/upernet_r18_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index 5cae4f5..0000000
--- a/mmsegmentation/configs/upernet/upernet_r18_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_r50.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_20k.py'
-]
-model = dict(
-    pretrained='open-mmlab://resnet18_v1c',
-    backbone=dict(depth=18),
-    decode_head=dict(in_channels=[64, 128, 256, 512], num_classes=21),
-    auxiliary_head=dict(in_channels=256, num_classes=21))
diff --git a/mmsegmentation/configs/upernet/upernet_r18_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/upernet/upernet_r18_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index 652ded7..0000000
--- a/mmsegmentation/configs/upernet/upernet_r18_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_r50.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-model = dict(
-    pretrained='open-mmlab://resnet18_v1c',
-    backbone=dict(depth=18),
-    decode_head=dict(in_channels=[64, 128, 256, 512], num_classes=21),
-    auxiliary_head=dict(in_channels=256, num_classes=21))
diff --git a/mmsegmentation/configs/upernet/upernet_r18_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/upernet/upernet_r18_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 1a7956d..0000000
--- a/mmsegmentation/configs/upernet/upernet_r18_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_r50.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-model = dict(
-    pretrained='open-mmlab://resnet18_v1c',
-    backbone=dict(depth=18),
-    decode_head=dict(in_channels=[64, 128, 256, 512], num_classes=150),
-    auxiliary_head=dict(in_channels=256, num_classes=150))
diff --git a/mmsegmentation/configs/upernet/upernet_r50_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/configs/upernet/upernet_r50_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 4751fc1..0000000
--- a/mmsegmentation/configs/upernet/upernet_r50_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_r50.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/upernet/upernet_r50_4xb2-40k_cityscapes-769x769.py b/mmsegmentation/configs/upernet/upernet_r50_4xb2-40k_cityscapes-769x769.py
deleted file mode 100644
index 6f05b6c..0000000
--- a/mmsegmentation/configs/upernet/upernet_r50_4xb2-40k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_r50.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/upernet/upernet_r50_4xb2-80k_cityscapes-512x1024.py b/mmsegmentation/configs/upernet/upernet_r50_4xb2-80k_cityscapes-512x1024.py
deleted file mode 100644
index f3488c6..0000000
--- a/mmsegmentation/configs/upernet/upernet_r50_4xb2-80k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_r50.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/configs/upernet/upernet_r50_4xb2-80k_cityscapes-769x769.py b/mmsegmentation/configs/upernet/upernet_r50_4xb2-80k_cityscapes-769x769.py
deleted file mode 100644
index 6a8f48e..0000000
--- a/mmsegmentation/configs/upernet/upernet_r50_4xb2-80k_cityscapes-769x769.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_r50.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (769, 769)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/mmsegmentation/configs/upernet/upernet_r50_4xb4-160k_ade20k-512x512.py b/mmsegmentation/configs/upernet/upernet_r50_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 5d15b2a..0000000
--- a/mmsegmentation/configs/upernet/upernet_r50_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_r50.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/upernet/upernet_r50_4xb4-20k_voc12aug-512x512.py b/mmsegmentation/configs/upernet/upernet_r50_4xb4-20k_voc12aug-512x512.py
deleted file mode 100644
index 9e96b4e..0000000
--- a/mmsegmentation/configs/upernet/upernet_r50_4xb4-20k_voc12aug-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_r50.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_20k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/upernet/upernet_r50_4xb4-40k_voc12aug-512x512.py b/mmsegmentation/configs/upernet/upernet_r50_4xb4-40k_voc12aug-512x512.py
deleted file mode 100644
index cada949..0000000
--- a/mmsegmentation/configs/upernet/upernet_r50_4xb4-40k_voc12aug-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_r50.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=21),
-    auxiliary_head=dict(num_classes=21))
diff --git a/mmsegmentation/configs/upernet/upernet_r50_4xb4-80k_ade20k-512x512.py b/mmsegmentation/configs/upernet/upernet_r50_4xb4-80k_ade20k-512x512.py
deleted file mode 100644
index 322d5d8..0000000
--- a/mmsegmentation/configs/upernet/upernet_r50_4xb4-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_r50.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
diff --git a/mmsegmentation/configs/vit/README.md b/mmsegmentation/configs/vit/README.md
deleted file mode 100644
index f75326e..0000000
--- a/mmsegmentation/configs/vit/README.md
+++ /dev/null
@@ -1,70 +0,0 @@
-# Vision Transformer
-
-> [An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale](https://arxiv.org/pdf/2010.11929.pdf)
-
-## Introduction
-
-<!-- [BACKBONE] -->
-
-<a href="https://github.com/google-research/vision_transformer">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-While the Transformer architecture has become the de-facto standard for natural language processing tasks, its applications to computer vision remain limited. In vision, attention is either applied in conjunction with convolutional networks, or used to replace certain components of convolutional networks while keeping their overall structure in place. We show that this reliance on CNNs is not necessary and a pure transformer applied directly to sequences of image patches can perform very well on image classification tasks. When pre-trained on large amounts of data and transferred to multiple mid-sized or small image recognition benchmarks (ImageNet, CIFAR-100, VTAB, etc.), Vision Transformer (ViT) attains excellent results compared to state-of-the-art convolutional networks while requiring substantially fewer computational resources to train.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/142903144-f80a12cc-8698-48ab-843c-49dedf558121.png" width="70%"/>
-</div>
-
-## Usage
-
-To use other repositories' pre-trained models, it is necessary to convert keys.
-
-We provide a script [`vit2mmseg.py`](../../tools/model_converters/vit2mmseg.py) in the tools directory to convert the key of models from [timm](https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/vision_transformer.py) to MMSegmentation style.
-
-```shell
-python tools/model_converters/vit2mmseg.py ${PRETRAIN_PATH} ${STORE_PATH}
-```
-
-E.g.
-
-```shell
-python tools/model_converters/vit2mmseg.py https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-vitjx/jx_vit_base_p16_224-80ecf9dd.pth pretrain/jx_vit_base_p16_224-80ecf9dd.pth
-```
-
-This script convert model from `PRETRAIN_PATH` and store the converted model in `STORE_PATH`.
-
-## Results and models
-
-### ADE20K
-
-| Method  | Backbone          | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device |  mIoU | mIoU(ms+flip) | config                                                                                                                               | download                                                                                                                                                                                                                                                                                                                   |
-| ------- | ----------------- | --------- | ------: | -------- | -------------- | ------ | ----: | ------------: | ------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| UPerNet | ViT-B + MLN       | 512x512   |   80000 | 9.20     | 6.94           | V100   | 47.71 |         49.51 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_vit-b16_mln_upernet_8xb2-80k_ade20k-512x512.py)      | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_mln_512x512_80k_ade20k/upernet_vit-b16_mln_512x512_80k_ade20k_20210624_130547-0403cee1.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_mln_512x512_80k_ade20k/20210624_130547.log.json)                |
-| UPerNet | ViT-B + MLN       | 512x512   |  160000 | 9.20     | 7.58           | V100   | 46.75 |         48.46 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py)     | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_mln_512x512_160k_ade20k/upernet_vit-b16_mln_512x512_160k_ade20k_20210624_130547-852fa768.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_mln_512x512_160k_ade20k/20210623_192432.log.json)             |
-| UPerNet | ViT-B + LN + MLN  | 512x512   |  160000 | 9.21     | 6.82           | V100   | 47.73 |         49.95 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_vit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py)  | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_ln_mln_512x512_160k_ade20k/upernet_vit-b16_ln_mln_512x512_160k_ade20k_20210621_172828-f444c077.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_ln_mln_512x512_160k_ade20k/20210621_172828.log.json)    |
-| UPerNet | DeiT-S            | 512x512   |   80000 | 4.68     | 29.85          | V100   | 42.96 |         43.79 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_deit-s16_upernet_8xb2-80k_ade20k-512x512.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_512x512_80k_ade20k/upernet_deit-s16_512x512_80k_ade20k_20210624_095228-afc93ec2.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_512x512_80k_ade20k/20210624_095228.log.json)                         |
-| UPerNet | DeiT-S            | 512x512   |  160000 | 4.68     | 29.19          | V100   | 42.87 |         43.79 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_deit-s16_upernet_8xb2-160k_ade20k-512x512.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_512x512_160k_ade20k/upernet_deit-s16_512x512_160k_ade20k_20210621_160903-5110d916.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_512x512_160k_ade20k/20210621_160903.log.json)                      |
-| UPerNet | DeiT-S + MLN      | 512x512   |  160000 | 5.69     | 11.18          | V100   | 43.82 |         45.07 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_deit-s16_mln_upernet_8xb2-160k_ade20k-512x512.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_mln_512x512_160k_ade20k/upernet_deit-s16_mln_512x512_160k_ade20k_20210621_161021-fb9a5dfb.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_mln_512x512_160k_ade20k/20210621_161021.log.json)          |
-| UPerNet | DeiT-S + LN + MLN | 512x512   |  160000 | 5.69     | 12.39          | V100   | 43.52 |         45.01 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_deit-s16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_ln_mln_512x512_160k_ade20k/upernet_deit-s16_ln_mln_512x512_160k_ade20k_20210621_161021-c0cd652f.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_ln_mln_512x512_160k_ade20k/20210621_161021.log.json) |
-| UPerNet | DeiT-B            | 512x512   |   80000 | 7.75     | 9.69           | V100   | 45.24 |         46.73 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_deit-b16_upernet_8xb2-80k_ade20k-512x512.py)         | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_512x512_80k_ade20k/upernet_deit-b16_512x512_80k_ade20k_20210624_130529-1e090789.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_512x512_80k_ade20k/20210624_130529.log.json)                         |
-| UPerNet | DeiT-B            | 512x512   |  160000 | 7.75     | 10.39          | V100   | 45.36 |         47.16 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_deit-b16_upernet_8xb2-160k_ade20k-512x512.py)        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_512x512_160k_ade20k/upernet_deit-b16_512x512_160k_ade20k_20210621_180100-828705d7.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_512x512_160k_ade20k/20210621_180100.log.json)                      |
-| UPerNet | DeiT-B + MLN      | 512x512   |  160000 | 9.21     | 7.78           | V100   | 45.46 |         47.16 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_deit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py)    | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_mln_512x512_160k_ade20k/upernet_deit-b16_mln_512x512_160k_ade20k_20210621_191949-4e1450f3.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_mln_512x512_160k_ade20k/20210621_191949.log.json)          |
-| UPerNet | DeiT-B + LN + MLN | 512x512   |  160000 | 9.21     | 7.75           | V100   | 45.37 |         47.23 | [config](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_deit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_ln_mln_512x512_160k_ade20k/upernet_deit-b16_ln_mln_512x512_160k_ade20k_20210623_153535-8a959c14.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_ln_mln_512x512_160k_ade20k/20210623_153535.log.json) |
-
-## Citation
-
-```bibtex
-@article{dosoViTskiy2020,
-  title={An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale},
-  author={DosoViTskiy, Alexey and Beyer, Lucas and Kolesnikov, Alexander and Weissenborn, Dirk and Zhai, Xiaohua and Unterthiner, Thomas and  Dehghani, Mostafa and Minderer, Matthias and Heigold, Georg and Gelly, Sylvain and Uszkoreit, Jakob and Houlsby, Neil},
-  journal={arXiv preprint arXiv:2010.11929},
-  year={2020}
-}
-```
diff --git a/mmsegmentation/configs/vit/metafile.yaml b/mmsegmentation/configs/vit/metafile.yaml
deleted file mode 100644
index 68e254a..0000000
--- a/mmsegmentation/configs/vit/metafile.yaml
+++ /dev/null
@@ -1,265 +0,0 @@
-Models:
-- Name: vit_vit-b16_mln_upernet_8xb2-80k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 47.71
-      mIoU(ms+flip): 49.51
-  Config: configs/vit/vit_vit-b16_mln_upernet_8xb2-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - ViT-B
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 9.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_mln_512x512_80k_ade20k/upernet_vit-b16_mln_512x512_80k_ade20k_20210624_130547-0403cee1.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_mln_512x512_80k_ade20k/20210624_130547.log.json
-  Paper:
-    Title: 'An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale'
-    URL: https://arxiv.org/pdf/2010.11929.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98
-  Framework: PyTorch
-- Name: vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 46.75
-      mIoU(ms+flip): 48.46
-  Config: configs/vit/vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - ViT-B
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 9.2
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_mln_512x512_160k_ade20k/upernet_vit-b16_mln_512x512_160k_ade20k_20210624_130547-852fa768.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_mln_512x512_160k_ade20k/20210623_192432.log.json
-  Paper:
-    Title: 'An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale'
-    URL: https://arxiv.org/pdf/2010.11929.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98
-  Framework: PyTorch
-- Name: vit_vit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 47.73
-      mIoU(ms+flip): 49.95
-  Config: configs/vit/vit_vit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - ViT-B
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 9.21
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_ln_mln_512x512_160k_ade20k/upernet_vit-b16_ln_mln_512x512_160k_ade20k_20210621_172828-f444c077.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_vit-b16_ln_mln_512x512_160k_ade20k/20210621_172828.log.json
-  Paper:
-    Title: 'An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale'
-    URL: https://arxiv.org/pdf/2010.11929.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98
-  Framework: PyTorch
-- Name: vit_deit-s16_upernet_8xb2-80k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.96
-      mIoU(ms+flip): 43.79
-  Config: configs/vit/vit_deit-s16_upernet_8xb2-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - DeiT-S
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 4.68
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_512x512_80k_ade20k/upernet_deit-s16_512x512_80k_ade20k_20210624_095228-afc93ec2.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_512x512_80k_ade20k/20210624_095228.log.json
-  Paper:
-    Title: 'An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale'
-    URL: https://arxiv.org/pdf/2010.11929.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98
-  Framework: PyTorch
-- Name: vit_deit-s16_upernet_8xb2-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 42.87
-      mIoU(ms+flip): 43.79
-  Config: configs/vit/vit_deit-s16_upernet_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - DeiT-S
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 4.68
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_512x512_160k_ade20k/upernet_deit-s16_512x512_160k_ade20k_20210621_160903-5110d916.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_512x512_160k_ade20k/20210621_160903.log.json
-  Paper:
-    Title: 'An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale'
-    URL: https://arxiv.org/pdf/2010.11929.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98
-  Framework: PyTorch
-- Name: vit_deit-s16_mln_upernet_8xb2-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 43.82
-      mIoU(ms+flip): 45.07
-  Config: configs/vit/vit_deit-s16_mln_upernet_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - DeiT-S
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 5.69
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_mln_512x512_160k_ade20k/upernet_deit-s16_mln_512x512_160k_ade20k_20210621_161021-fb9a5dfb.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_mln_512x512_160k_ade20k/20210621_161021.log.json
-  Paper:
-    Title: 'An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale'
-    URL: https://arxiv.org/pdf/2010.11929.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98
-  Framework: PyTorch
-- Name: vit_deit-s16-ln_mln_upernet_8xb2-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 43.52
-      mIoU(ms+flip): 45.01
-  Config: configs/vit/vit_deit-s16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - DeiT-S
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 5.69
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_ln_mln_512x512_160k_ade20k/upernet_deit-s16_ln_mln_512x512_160k_ade20k_20210621_161021-c0cd652f.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-s16_ln_mln_512x512_160k_ade20k/20210621_161021.log.json
-  Paper:
-    Title: 'An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale'
-    URL: https://arxiv.org/pdf/2010.11929.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98
-  Framework: PyTorch
-- Name: vit_deit-b16_upernet_8xb2-80k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 45.24
-      mIoU(ms+flip): 46.73
-  Config: configs/vit/vit_deit-b16_upernet_8xb2-80k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - DeiT-B
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 7.75
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_512x512_80k_ade20k/upernet_deit-b16_512x512_80k_ade20k_20210624_130529-1e090789.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_512x512_80k_ade20k/20210624_130529.log.json
-  Paper:
-    Title: 'An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale'
-    URL: https://arxiv.org/pdf/2010.11929.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98
-  Framework: PyTorch
-- Name: vit_deit-b16_upernet_8xb2-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 45.36
-      mIoU(ms+flip): 47.16
-  Config: configs/vit/vit_deit-b16_upernet_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - DeiT-B
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 7.75
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_512x512_160k_ade20k/upernet_deit-b16_512x512_160k_ade20k_20210621_180100-828705d7.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_512x512_160k_ade20k/20210621_180100.log.json
-  Paper:
-    Title: 'An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale'
-    URL: https://arxiv.org/pdf/2010.11929.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98
-  Framework: PyTorch
-- Name: vit_deit-b16_mln_upernet_8xb2-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 45.46
-      mIoU(ms+flip): 47.16
-  Config: configs/vit/vit_deit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - DeiT-B
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 9.21
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_mln_512x512_160k_ade20k/upernet_deit-b16_mln_512x512_160k_ade20k_20210621_191949-4e1450f3.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_mln_512x512_160k_ade20k/20210621_191949.log.json
-  Paper:
-    Title: 'An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale'
-    URL: https://arxiv.org/pdf/2010.11929.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98
-  Framework: PyTorch
-- Name: vit_deit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512
-  In Collection: UPerNet
-  Results:
-    Task: Semantic Segmentation
-    Dataset: ADE20K
-    Metrics:
-      mIoU: 45.37
-      mIoU(ms+flip): 47.23
-  Config: configs/vit/vit_deit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
-  Metadata:
-    Training Data: ADE20K
-    Batch Size: 16
-    Architecture:
-    - DeiT-B
-    - UPerNet
-    Training Resources: 8x V100 GPUS
-    Memory (GB): 9.21
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_ln_mln_512x512_160k_ade20k/upernet_deit-b16_ln_mln_512x512_160k_ade20k_20210623_153535-8a959c14.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vit/upernet_deit-b16_ln_mln_512x512_160k_ade20k/20210623_153535.log.json
-  Paper:
-    Title: 'An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale'
-    URL: https://arxiv.org/pdf/2010.11929.pdf
-  Code: https://github.com/open-mmlab/mmsegmentation/blob/v0.17.0/mmseg/models/backbones/vit.py#L98
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/vit/vit_deit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/vit/vit_deit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 39d1c54..0000000
--- a/mmsegmentation/configs/vit/vit_deit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,5 +0,0 @@
-_base_ = './vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py'
-
-model = dict(
-    pretrained='pretrain/deit_base_patch16_224-b5f2ef4d.pth',
-    backbone=dict(drop_path_rate=0.1, final_norm=True))
diff --git a/mmsegmentation/configs/vit/vit_deit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/vit/vit_deit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 706673f..0000000
--- a/mmsegmentation/configs/vit/vit_deit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py'
-
-model = dict(
-    pretrained='pretrain/deit_base_patch16_224-b5f2ef4d.pth',
-    backbone=dict(drop_path_rate=0.1),
-)
diff --git a/mmsegmentation/configs/vit/vit_deit-b16_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/vit/vit_deit-b16_upernet_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 23a2358..0000000
--- a/mmsegmentation/configs/vit/vit_deit-b16_upernet_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py'
-
-model = dict(
-    pretrained='pretrain/deit_base_patch16_224-b5f2ef4d.pth',
-    backbone=dict(drop_path_rate=0.1),
-    neck=None)
diff --git a/mmsegmentation/configs/vit/vit_deit-b16_upernet_8xb2-80k_ade20k-512x512.py b/mmsegmentation/configs/vit/vit_deit-b16_upernet_8xb2-80k_ade20k-512x512.py
deleted file mode 100644
index 4c8bc93..0000000
--- a/mmsegmentation/configs/vit/vit_deit-b16_upernet_8xb2-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './vit_vit-b16_mln_upernet_8xb2-80k_ade20k-512x512.py'
-
-model = dict(
-    pretrained='pretrain/deit_base_patch16_224-b5f2ef4d.pth',
-    backbone=dict(drop_path_rate=0.1),
-    neck=None)
diff --git a/mmsegmentation/configs/vit/vit_deit-s16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/vit/vit_deit-s16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 8e626fe..0000000
--- a/mmsegmentation/configs/vit/vit_deit-s16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py'
-
-model = dict(
-    pretrained='pretrain/deit_small_patch16_224-cd65a155.pth',
-    backbone=dict(
-        num_heads=6, embed_dims=384, drop_path_rate=0.1, final_norm=True),
-    decode_head=dict(num_classes=150, in_channels=[384, 384, 384, 384]),
-    neck=dict(in_channels=[384, 384, 384, 384], out_channels=384),
-    auxiliary_head=dict(num_classes=150, in_channels=384))
diff --git a/mmsegmentation/configs/vit/vit_deit-s16_mln_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/vit/vit_deit-s16_mln_upernet_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 9a69a89..0000000
--- a/mmsegmentation/configs/vit/vit_deit-s16_mln_upernet_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = './vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py'
-
-model = dict(
-    pretrained='pretrain/deit_small_patch16_224-cd65a155.pth',
-    backbone=dict(num_heads=6, embed_dims=384, drop_path_rate=0.1),
-    decode_head=dict(num_classes=150, in_channels=[384, 384, 384, 384]),
-    neck=dict(in_channels=[384, 384, 384, 384], out_channels=384),
-    auxiliary_head=dict(num_classes=150, in_channels=384))
diff --git a/mmsegmentation/configs/vit/vit_deit-s16_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/vit/vit_deit-s16_upernet_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 9ef699d..0000000
--- a/mmsegmentation/configs/vit/vit_deit-s16_upernet_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = './vit_vit-b16_mln_upernet_8xb2-80k_ade20k-512x512.py'
-
-model = dict(
-    pretrained='pretrain/deit_small_patch16_224-cd65a155.pth',
-    backbone=dict(num_heads=6, embed_dims=384, drop_path_rate=0.1),
-    decode_head=dict(num_classes=150, in_channels=[384, 384, 384, 384]),
-    neck=None,
-    auxiliary_head=dict(num_classes=150, in_channels=384))
diff --git a/mmsegmentation/configs/vit/vit_deit-s16_upernet_8xb2-80k_ade20k-512x512.py b/mmsegmentation/configs/vit/vit_deit-s16_upernet_8xb2-80k_ade20k-512x512.py
deleted file mode 100644
index 9ef699d..0000000
--- a/mmsegmentation/configs/vit/vit_deit-s16_upernet_8xb2-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = './vit_vit-b16_mln_upernet_8xb2-80k_ade20k-512x512.py'
-
-model = dict(
-    pretrained='pretrain/deit_small_patch16_224-cd65a155.pth',
-    backbone=dict(num_heads=6, embed_dims=384, drop_path_rate=0.1),
-    decode_head=dict(num_classes=150, in_channels=[384, 384, 384, 384]),
-    neck=None,
-    auxiliary_head=dict(num_classes=150, in_channels=384))
diff --git a/mmsegmentation/configs/vit/vit_vit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/vit/vit_vit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 2dd81b4..0000000
--- a/mmsegmentation/configs/vit/vit_vit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,45 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_vit-b16_ln_mln.py',
-    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained='pretrain/vit_base_patch16_224.pth',
-    backbone=dict(drop_path_rate=0.1, final_norm=True),
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
-
-# AdamW optimizer, no weight decay for position embedding & layer norm
-# in backbone
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
-    paramwise_cfg=dict(
-        custom_keys={
-            'pos_embed': dict(decay_mult=0.),
-            'cls_token': dict(decay_mult=0.),
-            'norm': dict(decay_mult=0.)
-        }))
-
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        eta_min=0.0,
-        power=1.0,
-        begin=1500,
-        end=160000,
-        by_epoch=False,
-    )
-]
-
-# By default, models are trained on 8 GPUs with 2 images per GPU
-train_dataloader = dict(batch_size=2)
-val_dataloader = dict(batch_size=1)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/vit/vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py b/mmsegmentation/configs/vit/vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 1a7ec16..0000000
--- a/mmsegmentation/configs/vit/vit_vit-b16_mln_upernet_8xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,44 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_vit-b16_ln_mln.py',
-    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_160k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained='pretrain/vit_base_patch16_224.pth',
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
-
-# AdamW optimizer, no weight decay for position embedding & layer norm
-# in backbone
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
-    paramwise_cfg=dict(
-        custom_keys={
-            'pos_embed': dict(decay_mult=0.),
-            'cls_token': dict(decay_mult=0.),
-            'norm': dict(decay_mult=0.)
-        }))
-
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        eta_min=0.0,
-        power=1.0,
-        begin=1500,
-        end=160000,
-        by_epoch=False,
-    )
-]
-
-# By default, models are trained on 8 GPUs with 2 images per GPU
-train_dataloader = dict(batch_size=2)
-val_dataloader = dict(batch_size=1)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/vit/vit_vit-b16_mln_upernet_8xb2-80k_ade20k-512x512.py b/mmsegmentation/configs/vit/vit_vit-b16_mln_upernet_8xb2-80k_ade20k-512x512.py
deleted file mode 100644
index ef73450..0000000
--- a/mmsegmentation/configs/vit/vit_vit-b16_mln_upernet_8xb2-80k_ade20k-512x512.py
+++ /dev/null
@@ -1,44 +0,0 @@
-_base_ = [
-    '../_base_/models/upernet_vit-b16_ln_mln.py',
-    '../_base_/datasets/ade20k.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained='pretrain/vit_base_patch16_224.pth',
-    decode_head=dict(num_classes=150),
-    auxiliary_head=dict(num_classes=150))
-
-# AdamW optimizer, no weight decay for position embedding & layer norm
-# in backbone
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
-    paramwise_cfg=dict(
-        custom_keys={
-            'pos_embed': dict(decay_mult=0.),
-            'cls_token': dict(decay_mult=0.),
-            'norm': dict(decay_mult=0.)
-        }))
-
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        eta_min=0.0,
-        power=1.0,
-        begin=1500,
-        end=80000,
-        by_epoch=False,
-    )
-]
-
-# By default, models are trained on 8 GPUs with 2 images per GPU
-train_dataloader = dict(batch_size=2)
-val_dataloader = dict(batch_size=1)
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/configs/vpd/README.md b/mmsegmentation/configs/vpd/README.md
deleted file mode 100644
index e90085b..0000000
--- a/mmsegmentation/configs/vpd/README.md
+++ /dev/null
@@ -1,50 +0,0 @@
-# VPD
-
-> [Unleashing Text-to-Image Diffusion Models for Visual Perception](https://arxiv.org/abs/2303.02153)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href = "https://github.com/wl-zhao/VPD">Official Repo</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Diffusion models (DMs) have become the new trend of generative models and have demonstrated a powerful ability of conditional synthesis. Among those, text-to-image diffusion models pre-trained on large-scale image-text pairs are highly controllable by customizable prompts. Unlike the unconditional generative models that focus on low-level attributes and details, text-to-image diffusion models contain more high-level knowledge thanks to the vision-language pre-training. In this paper, we propose VPD (Visual Perception with a pre-trained Diffusion model), a new framework that exploits the semantic information of a pre-trained text-to-image diffusion model in visual perception tasks. Instead of using the pre-trained denoising autoencoder in a diffusion-based pipeline, we simply use it as a backbone and aim to study how to take full advantage of the learned knowledge. Specifically, we prompt the denoising decoder with proper textual inputs and refine the text features with an adapter, leading to a better alignment to the pre-trained stage and making the visual contents interact with the text prompts. We also propose to utilize the cross-attention maps between the visual features and the text features to provide explicit guidance. Compared with other pre-training methods, we show that vision-language pre-trained diffusion models can be faster adapted to downstream visual perception tasks using the proposed VPD. Extensive experiments on semantic segmentation, referring image segmentation and depth estimation demonstrates the effectiveness of our method. Notably, VPD attains 0.254 RMSE on NYUv2 depth estimation and 73.3% oIoU on RefCOCO-val referring image segmentation, establishing new records on these two benchmarks.
-
-<!-- [IMAGE] -->
-
-<div align=center>
-<img src="https://github.com/open-mmlab/mmsegmentation/assets/26127467/88f5752d-7fe2-4cb0-a284-8ee0680e29cd" width="80%"/>
-</div>
-
-## Usage
-
-To run training or inference with VPD model, please install the required packages via
-
-```sh
-pip install -r requirements/albu.txt
-pip install -r requirements/optional.txt
-```
-
-## Results and models
-
-### NYU
-
-| Method | Backbone              | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device | RMSE  | d1    | d2    | d3    | REL   | log_10 | config                                                                                                      | download                                                                                                                                                                                                                     |
-| ------ | --------------------- | --------- | ------- | -------- | -------------- | ------ | ----- | ----- | ----- | ----- | ----- | ------ | ----------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| VPD    | Stable-Diffusion-v1-5 | 480x480   | 25000   | -        | -              | A100   | 0.253 | 0.964 | 0.995 | 0.999 | 0.069 | 0.030  | [config](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/vpd/vpd_sd_4xb8-25k_nyu-480x480.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vpd/vpd_sd_4xb8-25k_nyu-480x480_20230908-66144bc4.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vpd/vpd_sd_4xb8-25k_nyu-480x480_20230908.json) |
-| VPD    | Stable-Diffusion-v1-5 | 512x512   | 25000   | -        | -              | A100   | 0.258 | 0.963 | 0.995 | 0.999 | 0.072 | 0.031  | [config](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/vpd/vpd_sd_4xb8-25k_nyu-512x512.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/vpd/vpd_sd_4xb8-25k_nyu-512x512_20230918-60cefcff.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/vpd/vpd_sd_4xb8-25k_nyu-512x512_20230918.json) |
-
-## Citation
-
-```bibtex
-@article{zhao2023unleashing,
-  title={Unleashing Text-to-Image Diffusion Models for Visual Perception},
-  author={Zhao, Wenliang and Rao, Yongming and Liu, Zuyan and Liu, Benlin and Zhou, Jie and Lu, Jiwen},
-  journal={ICCV},
-  year={2023}
-}
-```
diff --git a/mmsegmentation/configs/vpd/metafile.yaml b/mmsegmentation/configs/vpd/metafile.yaml
deleted file mode 100644
index ccdc0e8..0000000
--- a/mmsegmentation/configs/vpd/metafile.yaml
+++ /dev/null
@@ -1,56 +0,0 @@
-Collections:
-- Name: VPD
-  License: Apache License 2.0
-  Metadata:
-    Training Data:
-    - NYU
-  Paper:
-    Title: Unleashing Text-to-Image Diffusion Models for Visual Perception
-    URL: https://arxiv.org/abs/2303.02153
-  README: configs/vpd/README.md
-  Frameworks:
-  - PyTorch
-Models:
-- Name: vpd_sd_4xb8-25k_nyu-480x480
-  In Collection: VPD
-  Results:
-    Task: Depth Estimation
-    Dataset: NYU
-    Metrics:
-      RMSE: 0.253
-  Config: configs/vpd/vpd_sd_4xb8-25k_nyu-480x480.py
-  Metadata:
-    Training Data: NYU
-    Batch Size: 32
-    Architecture:
-    - Stable-Diffusion
-    Training Resources: 8x A100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vpd/vpd_sd_4xb8-25k_nyu-480x480_20230908-66144bc4.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vpd/vpd_sd_4xb8-25k_nyu-480x480_20230908.json
-  Paper:
-    Title: 'High-Resolution Image Synthesis with Latent Diffusion Models'
-    URL: https://arxiv.org/abs/2112.10752
-  Code: https://github.com/open-mmlab/mmsegmentation/tree/main/mmseg/models/backbones/vpd.py#L333
-  Framework: PyTorch
-- Name: vpd_sd_4xb8-25k_nyu-512x512
-  In Collection: VPD
-  Alias: vpd_depth
-  Results:
-    Task: Depth Estimation
-    Dataset: NYU
-    Metrics:
-      RMSE: 0.258
-  Config: configs/vpd/vpd_sd_4xb8-25k_nyu-512x512.py
-  Metadata:
-    Training Data: NYU
-    Batch Size: 32
-    Architecture:
-    - Stable-Diffusion
-    Training Resources: 8x A100 GPUS
-  Weights: https://download.openmmlab.com/mmsegmentation/v0.5/vpd/vpd_sd_4xb8-25k_nyu-512x512_20230918-60cefcff.pth
-  Training log: https://download.openmmlab.com/mmsegmentation/v0.5/vpd/vpd_sd_4xb8-25k_nyu-512x512_20230918.json
-  Paper:
-    Title: 'High-Resolution Image Synthesis with Latent Diffusion Models'
-    URL: https://arxiv.org/abs/2112.10752
-  Code: https://github.com/open-mmlab/mmsegmentation/tree/main/mmseg/models/backbones/vpd.py#L333
-  Framework: PyTorch
diff --git a/mmsegmentation/configs/vpd/vpd_sd_4xb8-25k_nyu-480x480.py b/mmsegmentation/configs/vpd/vpd_sd_4xb8-25k_nyu-480x480.py
deleted file mode 100644
index 0d14d8d..0000000
--- a/mmsegmentation/configs/vpd/vpd_sd_4xb8-25k_nyu-480x480.py
+++ /dev/null
@@ -1,38 +0,0 @@
-_base_ = [
-    '../_base_/models/vpd_sd.py', '../_base_/datasets/nyu.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_25k.py'
-]
-
-crop_size = (480, 480)
-
-model = dict(
-    type='DepthEstimator',
-    data_preprocessor=dict(size=crop_size),
-    backbone=dict(
-        class_embed_path='https://download.openmmlab.com/mmsegmentation/'
-        'v0.5/vpd/nyu_class_embeddings.pth',
-        class_embed_select=True,
-        pad_shape=512,
-        unet_cfg=dict(use_attn=False),
-    ),
-    decode_head=dict(
-        type='VPDDepthHead',
-        in_channels=[320, 640, 1280, 1280],
-        max_depth=10,
-        fmap_border=(1, 1),
-    ),
-    test_cfg=dict(mode='slide_flip', crop_size=crop_size, stride=(160, 160)))
-
-default_hooks = dict(
-    checkpoint=dict(save_best='rmse', rule='less', max_keep_ckpts=1))
-
-# custom optimizer
-optim_wrapper = dict(
-    constructor='ForceDefaultOptimWrapperConstructor',
-    paramwise_cfg=dict(
-        bias_decay_mult=0,
-        force_default_settings=True,
-        custom_keys={
-            'backbone.encoder_vq': dict(lr_mult=0),
-            'backbone.unet': dict(lr_mult=0.01),
-        }))
diff --git a/mmsegmentation/configs/vpd/vpd_sd_4xb8-25k_nyu-512x512.py b/mmsegmentation/configs/vpd/vpd_sd_4xb8-25k_nyu-512x512.py
deleted file mode 100644
index e89eb9c..0000000
--- a/mmsegmentation/configs/vpd/vpd_sd_4xb8-25k_nyu-512x512.py
+++ /dev/null
@@ -1,37 +0,0 @@
-_base_ = [
-    '../_base_/models/vpd_sd.py', '../_base_/datasets/nyu_512x512.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_25k.py'
-]
-
-crop_size = (512, 512)
-
-model = dict(
-    type='DepthEstimator',
-    data_preprocessor=dict(size=crop_size),
-    backbone=dict(
-        class_embed_path='https://download.openmmlab.com/mmsegmentation/'
-        'v0.5/vpd/nyu_class_embeddings.pth',
-        class_embed_select=True,
-        pad_shape=512,
-        unet_cfg=dict(use_attn=False),
-    ),
-    decode_head=dict(
-        type='VPDDepthHead',
-        in_channels=[320, 640, 1280, 1280],
-        max_depth=10,
-    ),
-    test_cfg=dict(mode='slide_flip', crop_size=crop_size, stride=(128, 128)))
-
-default_hooks = dict(
-    checkpoint=dict(save_best='rmse', rule='less', max_keep_ckpts=1))
-
-# custom optimizer
-optim_wrapper = dict(
-    constructor='ForceDefaultOptimWrapperConstructor',
-    paramwise_cfg=dict(
-        bias_decay_mult=0,
-        force_default_settings=True,
-        custom_keys={
-            'backbone.encoder_vq': dict(lr_mult=0),
-            'backbone.unet': dict(lr_mult=0.01),
-        }))
diff --git a/mmsegmentation/dataset-index.yml b/mmsegmentation/dataset-index.yml
deleted file mode 100644
index 30ff0ee..0000000
--- a/mmsegmentation/dataset-index.yml
+++ /dev/null
@@ -1,80 +0,0 @@
-openxlab: true
-ade20k:
-  dataset: OpenDataLab/ADE20K_2016
-  download_root: data
-  data_root: data/ade
-
-cityscapes:
-  dataset: OpenDataLab/CityScapes
-  download_root: data
-  data_root: data/cityscapes
-
-voc2012:
-  dataset: OpenDataLab/PASCAL_VOC2012
-  download_root: data
-  data_root: data/VOCdevkit/VOC2012
-
-cocostuff:
-  dataset: OpenDataLab/COCO-Stuff
-  download_root: data
-  data_root: data/coco_stuff164k
-
-mapillary:
-  dataset: OpenDataLab/Mapillary
-  download_root: data
-  data_root: data/mapillary
-
-pascal_context:
-  dataset: OpenDataLab/VOC2010
-  download_root: data
-  data_root: data/VOCdevkit/VOC2010
-
-isaid:
-  dataset: OpenDataLab/iSAID
-  download_root: data
-  data_root: data/iSAID
-
-isprs_potsdam:
-  dataset: OpenDataLab/ISPRS_Potsdam
-  download_root: data
-  data_root: data/potsdam
-
-loveda:
-  dataset: OpenDataLab/LoveDA
-  download_root: data
-  data_root: data/loveDA
-
-chase_db1:
-  dataset: OpenDataLab/CHASE_DB1
-  download_root: data
-  data_root: data/CHASE_DB1
-
-drive:
-  dataset: OpenDataLab/DRIVE
-  download_root: data
-  data_root: data/DRIVE
-
-hrf:
-  dataset: OpenDataLab/HRF
-  download_root: data
-  data_root: data/HRF
-
-stare:
-  dataset: OpenDataLab/STARE
-  download_root: data
-  data_root: data/STARE
-
-synapse:
-  dataset: OpenDataLab/SurgVisDom
-  download_root: data
-  data_root: data/synapse
-
-refuge:
-  dataset: OpenDataLab/REFUGE_Challenge
-  download_root: data
-  data_root: data/REFUGE
-
-lip:
-  dataset: OpenDataLab/LIP
-  download_root: data
-  data_root: data/LIP
diff --git a/mmsegmentation/demo/MMSegmentation_Tutorial.ipynb b/mmsegmentation/demo/MMSegmentation_Tutorial.ipynb
deleted file mode 100644
index ac8601b..0000000
--- a/mmsegmentation/demo/MMSegmentation_Tutorial.ipynb
+++ /dev/null
@@ -1,555 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "colab_type": "text",
-    "id": "view-in-github"
-   },
-   "source": [
-    "<a href=\"https://colab.research.google.com/github/open-mmlab/mmsegmentation/blob/main/demo/MMSegmentation_Tutorial.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "FVmnaxFJvsb8"
-   },
-   "source": [
-    "# MMSegmentation Tutorial\n",
-    "Welcome to MMSegmentation! \n",
-    "\n",
-    "In this tutorial, we demo\n",
-    "* How to do inference with MMSeg trained weight\n",
-    "* How to train on your own dataset and visualize the results. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "QS8YHrEhbpas"
-   },
-   "source": [
-    "## Install MMSegmentation\n",
-    "This step may take several minutes. \n",
-    "\n",
-    "We use PyTorch 1.12 and CUDA 11.3 for this tutorial. You may install other versions by change the version number in pip install command. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/"
-    },
-    "id": "UWyLrLYaNEaL",
-    "outputId": "32a47fe3-f10d-47a1-f6b9-b7c235abdab1"
-   },
-   "outputs": [],
-   "source": [
-    "# Check nvcc version\n",
-    "!nvcc -V\n",
-    "# Check GCC version\n",
-    "!gcc --version"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/"
-    },
-    "id": "Ki3WUBjKbutg",
-    "outputId": "14bd14b0-4d8c-4fa9-e3f9-da35c0efc0d5"
-   },
-   "outputs": [],
-   "source": [
-    "# Install PyTorch\n",
-    "!conda install pytorch==1.12.0 torchvision==0.13.0 torchaudio==0.12.0 cudatoolkit=11.3 -c pytorch\n",
-    "# Install mim\n",
-    "!pip install -U openmim\n",
-    "# Install mmengine\n",
-    "!mim install mmengine\n",
-    "# Install MMCV\n",
-    "!mim install 'mmcv >= 2.0.0rc1'\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/"
-    },
-    "id": "nR-hHRvbNJJZ",
-    "outputId": "10c3b131-d4db-458c-fc10-b94b1c6ed546"
-   },
-   "outputs": [],
-   "source": [
-    "!rm -rf mmsegmentation\n",
-    "!git clone -b main https://github.com/open-mmlab/mmsegmentation.git \n",
-    "%cd mmsegmentation\n",
-    "!pip install -e ."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/"
-    },
-    "id": "mAE_h7XhPT7d",
-    "outputId": "83bf0f8e-fc69-40b1-f9fe-0025724a217c"
-   },
-   "outputs": [],
-   "source": [
-    "# Check Pytorch installation\n",
-    "import torch, torchvision\n",
-    "print(torch.__version__, torch.cuda.is_available())\n",
-    "\n",
-    "# Check MMSegmentation installation\n",
-    "import mmseg\n",
-    "print(mmseg.__version__)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "Ta51clKX4cwM"
-   },
-   "source": [
-    "## Finetune a semantic segmentation model on a new dataset\n",
-    "\n",
-    "To finetune on a customized dataset, the following steps are necessary. \n",
-    "1. Add a new dataset class. \n",
-    "2. Create a config file accordingly. \n",
-    "3. Perform training and evaluation. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "AcZg6x_K5Zs3"
-   },
-   "source": [
-    "### Add a new dataset\n",
-    "\n",
-    "Datasets in MMSegmentation require image and semantic segmentation maps to be placed in folders with the same prefix. To support a new dataset, we may need to modify the original file structure. \n",
-    "\n",
-    "In this tutorial, we give an example of converting the dataset. You may refer to [docs](https://github.com/open-mmlab/mmsegmentation/blob/master/docs/en/tutorials/customize_datasets.md#customize-datasets-by-reorganizing-data) for details about dataset reorganization. \n",
-    "\n",
-    "We use [Stanford Background Dataset](http://dags.stanford.edu/projects/scenedataset.html) as an example. The dataset contains 715 images chosen from existing public datasets [LabelMe](http://labelme.csail.mit.edu), [MSRC](http://research.microsoft.com/en-us/projects/objectclassrecognition), [PASCAL VOC](http://pascallin.ecs.soton.ac.uk/challenges/VOC) and [Geometric Context](http://www.cs.illinois.edu/homes/dhoiem/). Images from these datasets are mainly outdoor scenes, each containing approximately 320-by-240 pixels. \n",
-    "In this tutorial, we use the region annotations as labels. There are 8 classes in total, i.e. sky, tree, road, grass, water, building, mountain, and foreground object. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/"
-    },
-    "id": "TFIt7MHq5Wls",
-    "outputId": "74a126e4-c8a4-4d2f-a910-b58b71843a23"
-   },
-   "outputs": [],
-   "source": [
-    "# download and unzip\n",
-    "!wget http://dags.stanford.edu/data/iccv09Data.tar.gz -O stanford_background.tar.gz\n",
-    "!tar xf stanford_background.tar.gz"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/",
-     "height": 377
-    },
-    "id": "78LIci7F9WWI",
-    "outputId": "c432ddac-5a50-47b1-daac-5a26b07afea2"
-   },
-   "outputs": [],
-   "source": [
-    "# Let's take a look at the dataset\n",
-    "import mmcv\n",
-    "import mmengine\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "\n",
-    "img = mmcv.imread('iccv09Data/images/6000124.jpg')\n",
-    "plt.figure(figsize=(8, 6))\n",
-    "plt.imshow(mmcv.bgr2rgb(img))\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "L5mNQuc2GsVE"
-   },
-   "source": [
-    "We need to convert the annotation into semantic map format as an image."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "id": "WnGZfribFHCx"
-   },
-   "outputs": [],
-   "source": [
-    "# define dataset root and directory for images and annotations\n",
-    "data_root = 'iccv09Data'\n",
-    "img_dir = 'images'\n",
-    "ann_dir = 'labels'\n",
-    "# define class and palette for better visualization\n",
-    "classes = ('sky', 'tree', 'road', 'grass', 'water', 'bldg', 'mntn', 'fg obj')\n",
-    "palette = [[128, 128, 128], [129, 127, 38], [120, 69, 125], [53, 125, 34], \n",
-    "           [0, 11, 123], [118, 20, 12], [122, 81, 25], [241, 134, 51]]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "id": "WnGZfribFHCx"
-   },
-   "outputs": [],
-   "source": [
-    "import os.path as osp\n",
-    "import numpy as np\n",
-    "from PIL import Image\n",
-    "\n",
-    "# convert dataset annotation to semantic segmentation map\n",
-    "for file in mmengine.scandir(osp.join(data_root, ann_dir), suffix='.regions.txt'):\n",
-    "  seg_map = np.loadtxt(osp.join(data_root, ann_dir, file)).astype(np.uint8)\n",
-    "  seg_img = Image.fromarray(seg_map).convert('P')\n",
-    "  seg_img.putpalette(np.array(palette, dtype=np.uint8))\n",
-    "  seg_img.save(osp.join(data_root, ann_dir, file.replace('.regions.txt', \n",
-    "                                                         '.png')))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/",
-     "height": 377
-    },
-    "id": "5MCSS9ABfSks",
-    "outputId": "92b9bafc-589e-48fc-c9e9-476f125d6522"
-   },
-   "outputs": [],
-   "source": [
-    "# Let's take a look at the segmentation map we got\n",
-    "import matplotlib.patches as mpatches\n",
-    "img = Image.open('iccv09Data/labels/6000124.png')\n",
-    "plt.figure(figsize=(8, 6))\n",
-    "im = plt.imshow(np.array(img.convert('RGB')))\n",
-    "\n",
-    "# create a patch (proxy artist) for every color \n",
-    "patches = [mpatches.Patch(color=np.array(palette[i])/255., \n",
-    "                          label=classes[i]) for i in range(8)]\n",
-    "# put those patched as legend-handles into the legend\n",
-    "plt.legend(handles=patches, bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0., \n",
-    "           fontsize='large')\n",
-    "\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "id": "WbeLYCp2k5hl"
-   },
-   "outputs": [],
-   "source": [
-    "# split train/val set randomly\n",
-    "split_dir = 'splits'\n",
-    "mmengine.mkdir_or_exist(osp.join(data_root, split_dir))\n",
-    "filename_list = [osp.splitext(filename)[0] for filename in mmengine.scandir(\n",
-    "    osp.join(data_root, ann_dir), suffix='.png')]\n",
-    "with open(osp.join(data_root, split_dir, 'train.txt'), 'w') as f:\n",
-    "  # select first 4/5 as train set\n",
-    "  train_length = int(len(filename_list)*4/5)\n",
-    "  f.writelines(line + '\\n' for line in filename_list[:train_length])\n",
-    "with open(osp.join(data_root, split_dir, 'val.txt'), 'w') as f:\n",
-    "  # select last 1/5 as train set\n",
-    "  f.writelines(line + '\\n' for line in filename_list[train_length:])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "HchvmGYB_rrO"
-   },
-   "source": [
-    "After downloading the data, we need to implement `load_annotations` function in the new dataset class `StanfordBackgroundDataset`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "id": "LbsWOw62_o-X"
-   },
-   "outputs": [],
-   "source": [
-    "from mmseg.registry import DATASETS\n",
-    "from mmseg.datasets import BaseSegDataset\n",
-    "\n",
-    "\n",
-    "@DATASETS.register_module()\n",
-    "class StanfordBackgroundDataset(BaseSegDataset):\n",
-    "  METAINFO = dict(classes = classes, palette = palette)\n",
-    "  def __init__(self, **kwargs):\n",
-    "    super().__init__(img_suffix='.jpg', seg_map_suffix='.png', **kwargs)\n",
-    "    "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "yUVtmn3Iq3WA"
-   },
-   "source": [
-    "### Create a config file\n",
-    "In the next step, we need to modify the config for the training. To accelerate the process, we finetune the model from trained weights."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Download config and checkpoint files\n",
-    "!mim download mmsegmentation --config pspnet_r50-d8_4xb2-40k_cityscapes-512x1024 --dest ."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "id": "Wwnj9tRzqX_A"
-   },
-   "outputs": [],
-   "source": [
-    "from mmengine import Config\n",
-    "cfg = Config.fromfile('configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py')\n",
-    "print(f'Config:\\n{cfg.pretty_text}')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "1y2oV5w97jQo"
-   },
-   "source": [
-    "Since the given config is used to train PSPNet on the cityscapes dataset, we need to modify it accordingly for our new dataset.  "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/"
-    },
-    "id": "eyKnYC1Z7iCV",
-    "outputId": "6195217b-187f-4675-994b-ba90d8bb3078"
-   },
-   "outputs": [],
-   "source": [
-    "# Since we use only one GPU, BN is used instead of SyncBN\n",
-    "cfg.norm_cfg = dict(type='BN', requires_grad=True)\n",
-    "cfg.crop_size = (256, 256)\n",
-    "cfg.model.data_preprocessor.size = cfg.crop_size\n",
-    "cfg.model.backbone.norm_cfg = cfg.norm_cfg\n",
-    "cfg.model.decode_head.norm_cfg = cfg.norm_cfg\n",
-    "cfg.model.auxiliary_head.norm_cfg = cfg.norm_cfg\n",
-    "# modify num classes of the model in decode/auxiliary head\n",
-    "cfg.model.decode_head.num_classes = 8\n",
-    "cfg.model.auxiliary_head.num_classes = 8\n",
-    "\n",
-    "# Modify dataset type and path\n",
-    "cfg.dataset_type = 'StanfordBackgroundDataset'\n",
-    "cfg.data_root = data_root\n",
-    "\n",
-    "cfg.train_dataloader.batch_size = 8\n",
-    "\n",
-    "cfg.train_pipeline = [\n",
-    "    dict(type='LoadImageFromFile'),\n",
-    "    dict(type='LoadAnnotations'),\n",
-    "    dict(type='RandomResize', scale=(320, 240), ratio_range=(0.5, 2.0), keep_ratio=True),\n",
-    "    dict(type='RandomCrop', crop_size=cfg.crop_size, cat_max_ratio=0.75),\n",
-    "    dict(type='RandomFlip', prob=0.5),\n",
-    "    dict(type='PackSegInputs')\n",
-    "]\n",
-    "\n",
-    "cfg.test_pipeline = [\n",
-    "    dict(type='LoadImageFromFile'),\n",
-    "    dict(type='Resize', scale=(320, 240), keep_ratio=True),\n",
-    "    # add loading annotation after ``Resize`` because ground truth\n",
-    "    # does not need to do resize data transform\n",
-    "    dict(type='LoadAnnotations'),\n",
-    "    dict(type='PackSegInputs')\n",
-    "]\n",
-    "\n",
-    "\n",
-    "cfg.train_dataloader.dataset.type = cfg.dataset_type\n",
-    "cfg.train_dataloader.dataset.data_root = cfg.data_root\n",
-    "cfg.train_dataloader.dataset.data_prefix = dict(img_path=img_dir, seg_map_path=ann_dir)\n",
-    "cfg.train_dataloader.dataset.pipeline = cfg.train_pipeline\n",
-    "cfg.train_dataloader.dataset.ann_file = 'splits/train.txt'\n",
-    "\n",
-    "cfg.val_dataloader.dataset.type = cfg.dataset_type\n",
-    "cfg.val_dataloader.dataset.data_root = cfg.data_root\n",
-    "cfg.val_dataloader.dataset.data_prefix = dict(img_path=img_dir, seg_map_path=ann_dir)\n",
-    "cfg.val_dataloader.dataset.pipeline = cfg.test_pipeline\n",
-    "cfg.val_dataloader.dataset.ann_file = 'splits/val.txt'\n",
-    "\n",
-    "cfg.test_dataloader = cfg.val_dataloader\n",
-    "\n",
-    "\n",
-    "# Load the pretrained weights\n",
-    "cfg.load_from = 'pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'\n",
-    "\n",
-    "# Set up working dir to save files and logs.\n",
-    "cfg.work_dir = './work_dirs/tutorial'\n",
-    "\n",
-    "cfg.train_cfg.max_iters = 200\n",
-    "cfg.train_cfg.val_interval = 200\n",
-    "cfg.default_hooks.logger.interval = 10\n",
-    "cfg.default_hooks.checkpoint.interval = 200\n",
-    "\n",
-    "# Set seed to facilitate reproducing the result\n",
-    "cfg['randomness'] = dict(seed=0)\n",
-    "\n",
-    "# Let's have a look at the final config used for training\n",
-    "print(f'Config:\\n{cfg.pretty_text}')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "QWuH14LYF2gQ"
-   },
-   "source": [
-    "### Train and Evaluation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/"
-    },
-    "id": "jYKoSfdMF12B",
-    "outputId": "422219ca-d7a5-4890-f09f-88c959942e64"
-   },
-   "outputs": [],
-   "source": [
-    "from mmengine.runner import Runner\n",
-    "\n",
-    "runner = Runner.from_cfg(cfg)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# start training\n",
-    "runner.train()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "DEkWOP-NMbc_"
-   },
-   "source": [
-    "Inference with trained model"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/",
-     "height": 645
-    },
-    "id": "ekG__UfaH_OU",
-    "outputId": "1437419c-869a-4902-df86-d4f6f8b2597a"
-   },
-   "outputs": [],
-   "source": [
-    "from mmseg.apis import init_model, inference_model, show_result_pyplot\n",
-    "\n",
-    "# Init the model from the config and the checkpoint\n",
-    "checkpoint_path = './work_dirs/tutorial/iter_200.pth'\n",
-    "model = init_model(cfg, checkpoint_path, 'cuda:0')\n",
-    "\n",
-    "img = mmcv.imread('iccv09Data/images/6000124.jpg')\n",
-    "result = inference_model(model, img)\n",
-    "plt.figure(figsize=(8, 6))\n",
-    "vis_result = show_result_pyplot(model, img, result)\n",
-    "plt.imshow(mmcv.bgr2rgb(vis_result))\n"
-   ]
-  }
- ],
- "metadata": {
-  "accelerator": "GPU",
-  "colab": {
-   "collapsed_sections": [],
-   "include_colab_link": true,
-   "name": "MMSegmentation Tutorial.ipynb",
-   "provenance": []
-  },
-  "kernelspec": {
-   "display_name": "Python 3.10.6 ('pt1.12')",
-   "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.10.6"
-  },
-  "pycharm": {
-   "stem_cell": {
-    "cell_type": "raw",
-    "metadata": {
-     "collapsed": false
-    },
-    "source": []
-   }
-  },
-  "vscode": {
-   "interpreter": {
-    "hash": "0442e67aee3d9cbb788fa6e86d60c4ffa94ad7f1943c65abfecb99a6f4696c58"
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/mmsegmentation/demo/image_demo.py b/mmsegmentation/demo/image_demo.py
deleted file mode 100644
index ebc34c8..0000000
--- a/mmsegmentation/demo/image_demo.py
+++ /dev/null
@@ -1,51 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from argparse import ArgumentParser
-
-from mmengine.model import revert_sync_batchnorm
-
-from mmseg.apis import inference_model, init_model, show_result_pyplot
-
-
-def main():
-    parser = ArgumentParser()
-    parser.add_argument('img', help='Image file')
-    parser.add_argument('config', help='Config file')
-    parser.add_argument('checkpoint', help='Checkpoint file')
-    parser.add_argument('--out-file', default=None, help='Path to output file')
-    parser.add_argument(
-        '--device', default='cuda:0', help='Device used for inference')
-    parser.add_argument(
-        '--opacity',
-        type=float,
-        default=0.5,
-        help='Opacity of painted segmentation map. In (0, 1] range.')
-    parser.add_argument(
-        '--with-labels',
-        action='store_true',
-        default=False,
-        help='Whether to display the class labels.')
-    parser.add_argument(
-        '--title', default='result', help='The image identifier.')
-    args = parser.parse_args()
-
-    # build the model from a config file and a checkpoint file
-    model = init_model(args.config, args.checkpoint, device=args.device)
-    if args.device == 'cpu':
-        model = revert_sync_batchnorm(model)
-    # test a single image
-    result = inference_model(model, args.img)
-    # show the results
-    show_result_pyplot(
-        model,
-        args.img,
-        result,
-        title=args.title,
-        opacity=args.opacity,
-        with_labels=args.with_labels,
-        draw_gt=False,
-        show=False if args.out_file is not None else True,
-        out_file=args.out_file)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/demo/image_demo_with_inferencer.py b/mmsegmentation/demo/image_demo_with_inferencer.py
deleted file mode 100644
index d1fa9de..0000000
--- a/mmsegmentation/demo/image_demo_with_inferencer.py
+++ /dev/null
@@ -1,54 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from argparse import ArgumentParser
-
-from mmseg.apis import MMSegInferencer
-
-
-def main():
-    parser = ArgumentParser()
-    parser.add_argument('img', help='Image file')
-    parser.add_argument('model', help='Config file')
-    parser.add_argument('--checkpoint', default=None, help='Checkpoint file')
-    parser.add_argument(
-        '--out-dir', default='', help='Path to save result file')
-    parser.add_argument(
-        '--show',
-        action='store_true',
-        default=False,
-        help='Whether to display the drawn image.')
-    parser.add_argument(
-        '--dataset-name',
-        default='cityscapes',
-        help='Color palette used for segmentation map')
-    parser.add_argument(
-        '--device', default='cuda:0', help='Device used for inference')
-    parser.add_argument(
-        '--opacity',
-        type=float,
-        default=0.5,
-        help='Opacity of painted segmentation map. In (0, 1] range.')
-    parser.add_argument(
-        '--with-labels',
-        action='store_true',
-        default=False,
-        help='Whether to display the class labels.')
-    args = parser.parse_args()
-
-    # build the model from a config file and a checkpoint file
-    mmseg_inferencer = MMSegInferencer(
-        args.model,
-        args.checkpoint,
-        dataset_name=args.dataset_name,
-        device=args.device)
-
-    # test a single image
-    mmseg_inferencer(
-        args.img,
-        show=args.show,
-        out_dir=args.out_dir,
-        opacity=args.opacity,
-        with_labels=args.with_labels)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/demo/inference_demo.ipynb b/mmsegmentation/demo/inference_demo.ipynb
deleted file mode 100644
index 455c5df..0000000
--- a/mmsegmentation/demo/inference_demo.ipynb
+++ /dev/null
@@ -1,120 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!mkdir ../checkpoints\n",
-    "!wget https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth -P ../checkpoints"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "is_executing": true
-    }
-   },
-   "outputs": [],
-   "source": [
-    "import torch\n",
-    "import matplotlib.pyplot as plt\n",
-    "from mmengine.model.utils import revert_sync_batchnorm\n",
-    "from mmseg.apis import init_model, inference_model, show_result_pyplot"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "is_executing": true
-    }
-   },
-   "outputs": [],
-   "source": [
-    "config_file = '../configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'\n",
-    "checkpoint_file = '../checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# build the model from a config file and a checkpoint file\n",
-    "model = init_model(config_file, checkpoint_file, device='cpu')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# test a single image\n",
-    "img = 'demo.png'\n",
-    "if not torch.cuda.is_available():\n",
-    "    model = revert_sync_batchnorm(model)\n",
-    "result = inference_model(model, img)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# show the results\n",
-    "vis_result = show_result_pyplot(model, img, result, show=False)\n",
-    "plt.imshow(vis_result)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "pt1.13",
-   "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.10.11"
-  },
-  "pycharm": {
-   "stem_cell": {
-    "cell_type": "raw",
-    "metadata": {
-     "collapsed": false
-    },
-    "source": []
-   }
-  },
-  "vscode": {
-   "interpreter": {
-    "hash": "f61d5b8fecdd960739697f6c2860080d7b76a5be5d896cb034bdb275ab3ddda0"
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/mmsegmentation/demo/rs_image_inference.py b/mmsegmentation/demo/rs_image_inference.py
deleted file mode 100644
index 799181f..0000000
--- a/mmsegmentation/demo/rs_image_inference.py
+++ /dev/null
@@ -1,50 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from argparse import ArgumentParser
-
-from mmseg.apis import RSImage, RSInferencer
-
-
-def main():
-    parser = ArgumentParser()
-    parser.add_argument('image', help='Image file path')
-    parser.add_argument('config', help='Config file')
-    parser.add_argument('checkpoint', help='Checkpoint file')
-    parser.add_argument(
-        '--output-path',
-        help='Path to save result image',
-        default='result.png')
-    parser.add_argument(
-        '--batch-size',
-        type=int,
-        default=1,
-        help='maximum number of windows inferred simultaneously')
-    parser.add_argument(
-        '--window-size',
-        help='window xsize,ysize',
-        default=(224, 224),
-        type=int,
-        nargs=2)
-    parser.add_argument(
-        '--stride',
-        help='window xstride,ystride',
-        default=(224, 224),
-        type=int,
-        nargs=2)
-    parser.add_argument(
-        '--thread', default=1, type=int, help='number of inference threads')
-    parser.add_argument(
-        '--device', default='cuda:0', help='Device used for inference')
-    args = parser.parse_args()
-    inferencer = RSInferencer.from_config_path(
-        args.config,
-        args.checkpoint,
-        batch_size=args.batch_size,
-        thread=args.thread,
-        device=args.device)
-    image = RSImage(args.image)
-
-    inferencer.run(image, args.window_size, args.stride, args.output_path)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/demo/video_demo.py b/mmsegmentation/demo/video_demo.py
deleted file mode 100644
index 7e6f3d6..0000000
--- a/mmsegmentation/demo/video_demo.py
+++ /dev/null
@@ -1,112 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from argparse import ArgumentParser
-
-import cv2
-from mmengine.model.utils import revert_sync_batchnorm
-
-from mmseg.apis import inference_model, init_model
-from mmseg.apis.inference import show_result_pyplot
-
-
-def main():
-    parser = ArgumentParser()
-    parser.add_argument('video', help='Video file or webcam id')
-    parser.add_argument('config', help='Config file')
-    parser.add_argument('checkpoint', help='Checkpoint file')
-    parser.add_argument(
-        '--device', default='cuda:0', help='Device used for inference')
-    parser.add_argument(
-        '--palette',
-        default='cityscapes',
-        help='Color palette used for segmentation map')
-    parser.add_argument(
-        '--show', action='store_true', help='Whether to show draw result')
-    parser.add_argument(
-        '--show-wait-time', default=1, type=int, help='Wait time after imshow')
-    parser.add_argument(
-        '--output-file', default=None, type=str, help='Output video file path')
-    parser.add_argument(
-        '--output-fourcc',
-        default='MJPG',
-        type=str,
-        help='Fourcc of the output video')
-    parser.add_argument(
-        '--output-fps', default=-1, type=int, help='FPS of the output video')
-    parser.add_argument(
-        '--output-height',
-        default=-1,
-        type=int,
-        help='Frame height of the output video')
-    parser.add_argument(
-        '--output-width',
-        default=-1,
-        type=int,
-        help='Frame width of the output video')
-    parser.add_argument(
-        '--opacity',
-        type=float,
-        default=0.5,
-        help='Opacity of painted segmentation map. In (0, 1] range.')
-    args = parser.parse_args()
-
-    assert args.show or args.output_file, \
-        'At least one output should be enabled.'
-
-    # build the model from a config file and a checkpoint file
-    model = init_model(args.config, args.checkpoint, device=args.device)
-    if args.device == 'cpu':
-        model = revert_sync_batchnorm(model)
-
-    # build input video
-    if args.video.isdigit():
-        args.video = int(args.video)
-    cap = cv2.VideoCapture(args.video)
-    assert (cap.isOpened())
-    input_height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT)
-    input_width = cap.get(cv2.CAP_PROP_FRAME_WIDTH)
-    input_fps = cap.get(cv2.CAP_PROP_FPS)
-
-    # init output video
-    writer = None
-    output_height = None
-    output_width = None
-    if args.output_file is not None:
-        fourcc = cv2.VideoWriter_fourcc(*args.output_fourcc)
-        output_fps = args.output_fps if args.output_fps > 0 else input_fps
-        output_height = args.output_height if args.output_height > 0 else int(
-            input_height)
-        output_width = args.output_width if args.output_width > 0 else int(
-            input_width)
-        writer = cv2.VideoWriter(args.output_file, fourcc, output_fps,
-                                 (output_width, output_height), True)
-
-    # start looping
-    try:
-        while True:
-            flag, frame = cap.read()
-            if not flag:
-                break
-
-            # test a single image
-            result = inference_model(model, frame)
-
-            # blend raw image and prediction
-            draw_img = show_result_pyplot(model, frame, result)
-
-            if args.show:
-                cv2.imshow('video_demo', draw_img)
-                cv2.waitKey(args.show_wait_time)
-            if writer:
-                if draw_img.shape[0] != output_height or draw_img.shape[
-                        1] != output_width:
-                    draw_img = cv2.resize(draw_img,
-                                          (output_width, output_height))
-                writer.write(draw_img)
-    finally:
-        if writer:
-            writer.release()
-        cap.release()
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/docker/Dockerfile b/mmsegmentation/docker/Dockerfile
deleted file mode 100644
index 26420dd..0000000
--- a/mmsegmentation/docker/Dockerfile
+++ /dev/null
@@ -1,35 +0,0 @@
-ARG PYTORCH="1.11.0"
-ARG CUDA="11.3"
-ARG CUDNN="8"
-ARG MMCV="2.0.1"
-
-FROM pytorch/pytorch:${PYTORCH}-cuda${CUDA}-cudnn${CUDNN}-devel
-
-ENV TORCH_CUDA_ARCH_LIST="6.0 6.1 7.0+PTX"
-ENV TORCH_NVCC_FLAGS="-Xfatbin -compress-all"
-ENV CMAKE_PREFIX_PATH="$(dirname $(which conda))/../"
-
-# To fix GPG key error when running apt-get update
-RUN apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/3bf863cc.pub
-RUN apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64/7fa2af80.pub
-
-RUN apt-get update && apt-get install -y git ninja-build libglib2.0-0 libsm6 libxrender-dev libxext6 libgl1-mesa-dev  \
-    && apt-get clean \
-    && rm -rf /var/lib/apt/lists/*
-
-RUN conda clean --all
-
-# Install MMCV
-ARG PYTORCH
-ARG CUDA
-ARG MMCV
-RUN ["/bin/bash", "-c", "pip install openmim"]
-RUN ["/bin/bash", "-c", "mim install mmengine"]
-RUN ["/bin/bash", "-c", "mim install mmcv==${MMCV}"]
-
-# Install MMSegmentation
-RUN git clone -b main https://github.com/open-mmlab/mmsegmentation.git /mmsegmentation
-WORKDIR /mmsegmentation
-ENV FORCE_CUDA="1"
-RUN pip install -r requirements.txt
-RUN pip install --no-cache-dir -e .
diff --git a/mmsegmentation/docker/serve/Dockerfile b/mmsegmentation/docker/serve/Dockerfile
deleted file mode 100644
index 38f91ba..0000000
--- a/mmsegmentation/docker/serve/Dockerfile
+++ /dev/null
@@ -1,51 +0,0 @@
-ARG PYTORCH="1.11.0"
-ARG CUDA="11.3"
-ARG CUDNN="8"
-FROM pytorch/pytorch:${PYTORCH}-cuda${CUDA}-cudnn${CUDNN}-devel
-
-ARG MMCV="2.0.1"
-ARG MMSEG="1.2.2"
-
-ENV PYTHONUNBUFFERED TRUE
-
-RUN apt-get update && \
-    DEBIAN_FRONTEND=noninteractive apt-get install --no-install-recommends -y \
-    ca-certificates \
-    g++ \
-    openjdk-11-jre-headless \
-    # MMDet Requirements
-    ffmpeg libsm6 libxext6 git ninja-build libglib2.0-0 libsm6 libxrender-dev libxext6 \
-    && rm -rf /var/lib/apt/lists/*
-
-ENV PATH="/opt/conda/bin:$PATH"
-RUN export FORCE_CUDA=1
-
-# TORCHSEVER
-RUN pip install torchserve torch-model-archiver
-
-# MMLAB
-ARG PYTORCH
-ARG CUDA
-RUN ["/bin/bash", "-c", "pip install openmim"]
-RUN ["/bin/bash", "-c", "mim install mmengine"]
-RUN ["/bin/bash", "-c", "mim install mmcv==${MMCV}"]
-RUN pip install mmsegmentation==${MMSEG}
-
-RUN useradd -m model-server \
-    && mkdir -p /home/model-server/tmp
-
-COPY entrypoint.sh /usr/local/bin/entrypoint.sh
-
-RUN chmod +x /usr/local/bin/entrypoint.sh \
-    && chown -R model-server /home/model-server
-
-COPY config.properties /home/model-server/config.properties
-RUN mkdir /home/model-server/model-store && chown -R model-server /home/model-server/model-store
-
-EXPOSE 8080 8081 8082
-
-USER model-server
-WORKDIR /home/model-server
-ENV TEMP=/home/model-server/tmp
-ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]
-CMD ["serve"]
diff --git a/mmsegmentation/docker/serve/config.properties b/mmsegmentation/docker/serve/config.properties
deleted file mode 100644
index efb9c47..0000000
--- a/mmsegmentation/docker/serve/config.properties
+++ /dev/null
@@ -1,5 +0,0 @@
-inference_address=http://0.0.0.0:8080
-management_address=http://0.0.0.0:8081
-metrics_address=http://0.0.0.0:8082
-model_store=/home/model-server/model-store
-load_models=all
diff --git a/mmsegmentation/docker/serve/entrypoint.sh b/mmsegmentation/docker/serve/entrypoint.sh
deleted file mode 100644
index 41ba00b..0000000
--- a/mmsegmentation/docker/serve/entrypoint.sh
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/bin/bash
-set -e
-
-if [[ "$1" = "serve" ]]; then
-    shift 1
-    torchserve --start --ts-config /home/model-server/config.properties
-else
-    eval "$@"
-fi
-
-# prevent docker exit
-tail -f /dev/null
diff --git a/mmsegmentation/docs/en/.readthedocs.yaml b/mmsegmentation/docs/en/.readthedocs.yaml
deleted file mode 100644
index 9df9fdb..0000000
--- a/mmsegmentation/docs/en/.readthedocs.yaml
+++ /dev/null
@@ -1,17 +0,0 @@
-version: 2
-
-build:
-  os: ubuntu-22.04
-  tools:
-    python: "3.8"
-
-formats:
-    - epub
-
-sphinx:
-  configuration: docs/en/conf.py
-
-python:
-  install:
-    - requirements: requirements/docs.txt
-    - requirements: requirements/readthedocs.txt
diff --git a/mmsegmentation/docs/en/Makefile b/mmsegmentation/docs/en/Makefile
deleted file mode 100644
index d4bb2cb..0000000
--- a/mmsegmentation/docs/en/Makefile
+++ /dev/null
@@ -1,20 +0,0 @@
-# Minimal makefile for Sphinx documentation
-#
-
-# You can set these variables from the command line, and also
-# from the environment for the first two.
-SPHINXOPTS    ?=
-SPHINXBUILD   ?= sphinx-build
-SOURCEDIR     = .
-BUILDDIR      = _build
-
-# Put it first so that "make" without argument is like "make help".
-help:
-	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
-
-.PHONY: help Makefile
-
-# Catch-all target: route all unknown targets to Sphinx using the new
-# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
-%: Makefile
-	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
diff --git a/mmsegmentation/docs/en/_static/css/readthedocs.css b/mmsegmentation/docs/en/_static/css/readthedocs.css
deleted file mode 100644
index 2e38d08..0000000
--- a/mmsegmentation/docs/en/_static/css/readthedocs.css
+++ /dev/null
@@ -1,6 +0,0 @@
-.header-logo {
-    background-image: url("../images/mmsegmentation.png");
-    background-size: 201px 40px;
-    height: 40px;
-    width: 201px;
-}
diff --git a/mmsegmentation/docs/en/advanced_guides/add_datasets.md b/mmsegmentation/docs/en/advanced_guides/add_datasets.md
deleted file mode 100644
index a8e3503..0000000
--- a/mmsegmentation/docs/en/advanced_guides/add_datasets.md
+++ /dev/null
@@ -1,199 +0,0 @@
-# Add New Datasets
-
-## Add new custom dataset
-
-Here we show how to develop a new custom dataset.
-
-1. Create a new file `mmseg/datasets/example.py`
-
-   ```python
-   from mmseg.registry import DATASETS
-   from .basesegdataset import BaseSegDataset
-
-
-   @DATASETS.register_module()
-   class ExampleDataset(BaseSegDataset):
-
-       METAINFO = dict(
-           classes=('xxx', 'xxx', ...),
-           palette=[[x, x, x], [x, x, x], ...])
-
-       def __init__(self, arg1, arg2):
-           pass
-   ```
-
-2. Import the module in `mmseg/datasets/__init__.py`
-
-   ```python
-   from .example import ExampleDataset
-   ```
-
-3. Use it by creating a new new dataset config file `configs/_base_/datasets/example_dataset.py`
-
-   ```python
-   dataset_type = 'ExampleDataset'
-   data_root = 'data/example/'
-   ...
-   ```
-
-4. Add dataset meta information in `mmseg/utils/class_names.py`
-
-   ```python
-   def example_classes():
-       return [
-           'xxx', 'xxx',
-           ...
-       ]
-
-   def example_palette():
-       return [
-           [x, x, x], [x, x, x],
-           ...
-       ]
-   dataset_aliases ={
-       'example': ['example', ...],
-       ...
-   }
-   ```
-
-**Note:** If the new dataset does not satisfy the mmseg requirements, a data preprocessing script needs to be prepared in `tools/dataset_converters/`
-
-## Customize datasets by reorganizing data
-
-The simplest way is to convert your dataset to organize your data into folders.
-
-An example of file structure is as followed.
-
-```none
-├── data
-│   ├── my_dataset
-│   │   ├── img_dir
-│   │   │   ├── train
-│   │   │   │   ├── xxx{img_suffix}
-│   │   │   │   ├── yyy{img_suffix}
-│   │   │   │   ├── zzz{img_suffix}
-│   │   │   ├── val
-│   │   ├── ann_dir
-│   │   │   ├── train
-│   │   │   │   ├── xxx{seg_map_suffix}
-│   │   │   │   ├── yyy{seg_map_suffix}
-│   │   │   │   ├── zzz{seg_map_suffix}
-│   │   │   ├── val
-
-```
-
-A training pair will consist of the files with same suffix in img_dir/ann_dir.
-
-Some datasets don't release the test set or don't release the ground truth of the test set, and we cannot evaluate models locally without the ground truth of the test set, so we set the validation set as the default test set in config files.
-
-About how to build your own datasets or implement a new dataset class please refer to the [datasets guide](./datasets.md) for more detailed information.
-
-**Note:** The annotations are images of shape (H, W), the value pixel should fall in range `[0, num_classes - 1]`.
-You may use `'P'` mode of [pillow](https://pillow.readthedocs.io/en/stable/handbook/concepts.html#palette) to create your annotation image with color.
-
-## Customize datasets by mixing dataset
-
-MMSegmentation also supports to mix dataset for training.
-Currently it supports to concat, repeat and multi-image mix datasets.
-
-### Repeat dataset
-
-We use `RepeatDataset` as wrapper to repeat the dataset.
-For example, suppose the original dataset is `Dataset_A`, to repeat it, the config looks like the following
-
-```python
-dataset_A_train = dict(
-    type='RepeatDataset',
-    times=N,
-    dataset=dict(  # This is the original config of Dataset_A
-        type='Dataset_A',
-        ...
-        pipeline=train_pipeline
-    )
-)
-```
-
-### Concatenate dataset
-
-In case the dataset you want to concatenate is different, you can concatenate the dataset configs like the following.
-
-```python
-dataset_A_train = dict()
-dataset_B_train = dict()
-concatenate_dataset = dict(
-    type='ConcatDataset',
-    datasets=[dataset_A_train, dataset_B_train])
-```
-
-A more complex example that repeats `Dataset_A` and `Dataset_B` by N and M times, respectively, and then concatenates the repeated datasets is as the following.
-
-```python
-dataset_A_train = dict(
-    type='RepeatDataset',
-    times=N,
-    dataset=dict(
-        type='Dataset_A',
-        ...
-        pipeline=train_pipeline
-    )
-)
-dataset_A_val = dict(
-    ...
-    pipeline=test_pipeline
-)
-dataset_A_test = dict(
-    ...
-    pipeline=test_pipeline
-)
-dataset_B_train = dict(
-    type='RepeatDataset',
-    times=M,
-    dataset=dict(
-        type='Dataset_B',
-        ...
-        pipeline=train_pipeline
-    )
-)
-train_dataloader = dict(
-    dataset=dict(
-        type='ConcatDataset',
-        datasets=[dataset_A_train, dataset_B_train]))
-
-val_dataloader = dict(dataset=dataset_A_val)
-test_dataloader = dict(dataset=dataset_A_test)
-
-```
-
-You can refer base dataset [tutorial](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/basedataset.html) from mmengine for more details
-
-### Multi-image Mix Dataset
-
-We use `MultiImageMixDataset` as a wrapper to mix images from multiple datasets.
-`MultiImageMixDataset` can be used by multiple images mixed data augmentation like mosaic and mixup.
-
-An example of using `MultiImageMixDataset` with `Mosaic` data augmentation:
-
-```python
-train_pipeline = [
-    dict(type='RandomMosaic', prob=1),
-    dict(type='Resize', img_scale=(1024, 512), keep_ratio=True),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PackSegInputs')
-]
-
-train_dataset = dict(
-    type='MultiImageMixDataset',
-    dataset=dict(
-        type=dataset_type,
-        reduce_zero_label=False,
-        img_dir=data_root + "images/train",
-        ann_dir=data_root + "annotations/train",
-        pipeline=[
-            dict(type='LoadImageFromFile'),
-            dict(type='LoadAnnotations'),
-        ]
-    ),
-    pipeline=train_pipeline
-)
-
-```
diff --git a/mmsegmentation/docs/en/advanced_guides/add_metrics.md b/mmsegmentation/docs/en/advanced_guides/add_metrics.md
deleted file mode 100644
index 0298826..0000000
--- a/mmsegmentation/docs/en/advanced_guides/add_metrics.md
+++ /dev/null
@@ -1,81 +0,0 @@
-# Add New Metrics
-
-## Develop with the source code of MMSegmentation
-
-Here we show how to develop a new metric with an example of `CustomMetric` as the following.
-
-1. Create a new file `mmseg/evaluation/metrics/custom_metric.py`.
-
-   ```python
-   from typing import List, Sequence
-
-   from mmengine.evaluator import BaseMetric
-
-   from mmseg.registry import METRICS
-
-
-   @METRICS.register_module()
-   class CustomMetric(BaseMetric):
-
-       def __init__(self, arg1, arg2):
-           """
-           The metric first processes each batch of data_samples and predictions,
-           and appends the processed results to the results list. Then it
-           collects all results together from all ranks if distributed training
-           is used. Finally, it computes the metrics of the entire dataset.
-           """
-
-       def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
-           pass
-
-       def compute_metrics(self, results: list) -> dict:
-           pass
-
-       def evaluate(self, size: int) -> dict:
-           pass
-   ```
-
-   In the above example, `CustomMetric` is a subclass of `BaseMetric`. It has three methods: `process`, `compute_metrics` and `evaluate`.
-
-   - `process()` process one batch of data samples and predictions. The processed results are stored in `self.results` which will be used to compute the metrics after all the data samples are processed. Please refer to [MMEngine documentation](https://github.com/open-mmlab/mmengine/blob/main/docs/en/design/evaluation.md) for more details.
-
-   - `compute_metrics()` is used to compute the metrics from the processed results.
-
-   - `evaluate()` is an interface to compute the metrics and return the results. It will be called by `ValLoop` or `TestLoop` in the `Runner`. In most cases, you don't need to override this method, but you can override it if you want to do some extra work.
-
-   **Note:** You might find the details of calling `evaluate()` method in the `Runner` [here](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py#L366). The `Runner` is the executor of the training and testing process, you can find more details about it at the [engine document](./engine.md).
-
-2. Import the new metric in `mmseg/evaluation/metrics/__init__.py`.
-
-   ```python
-   from .custom_metric import CustomMetric
-   __all__ = ['CustomMetric', ...]
-   ```
-
-3. Add the new metric to the config file.
-
-   ```python
-   val_evaluator = dict(type='CustomMetric', arg1=xxx, arg2=xxx)
-   test_evaluator = dict(type='CustomMetric', arg1=xxx, arg2=xxx)
-   ```
-
-## Develop with the released version of MMSegmentation
-
-The above example shows how to develop a new metric with the source code of MMSegmentation. If you want to develop a new metric with the released version of MMSegmentation, you can follow the following steps.
-
-1. Create a new file `/Path/to/metrics/custom_metric.py`, implement the `process`, `compute_metrics` and `evaluate` methods, `evaluate` method is optional.
-
-2. Import the new metric in your code or config file.
-
-   ```python
-   from path.to.metrics import CustomMetric
-   ```
-
-   or
-
-   ```python
-   custom_imports = dict(imports=['/Path/to/metrics'], allow_failed_imports=False)
-
-   val_evaluator = dict(type='CustomMetric', arg1=xxx, arg2=xxx)
-   test_evaluator = dict(type='CustomMetric', arg1=xxx, arg2=xxx)
-   ```
diff --git a/mmsegmentation/docs/en/advanced_guides/add_models.md b/mmsegmentation/docs/en/advanced_guides/add_models.md
deleted file mode 100644
index ed5c9ce..0000000
--- a/mmsegmentation/docs/en/advanced_guides/add_models.md
+++ /dev/null
@@ -1,260 +0,0 @@
-# Add New Modules
-
-## Develop new components
-
-We can customize all the components introduced at [the model documentation](./models.md), such as **backbone**, **head**, **loss function** and **data preprocessor**.
-
-### Add new backbones
-
-Here we show how to develop a new backbone with an example of MobileNet.
-
-1. Create a new file `mmseg/models/backbones/mobilenet.py`.
-
-   ```python
-   import torch.nn as nn
-
-   from mmseg.registry import MODELS
-
-
-   @MODELS.register_module()
-   class MobileNet(nn.Module):
-
-       def __init__(self, arg1, arg2):
-           pass
-
-       def forward(self, x):  # should return a tuple
-           pass
-
-       def init_weights(self, pretrained=None):
-           pass
-   ```
-
-2. Import the module in `mmseg/models/backbones/__init__.py`.
-
-   ```python
-   from .mobilenet import MobileNet
-   ```
-
-3. Use it in your config file.
-
-   ```python
-   model = dict(
-       ...
-       backbone=dict(
-           type='MobileNet',
-           arg1=xxx,
-           arg2=xxx),
-       ...
-   ```
-
-### Add new heads
-
-In MMSegmentation, we provide a [BaseDecodeHead](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/decode_heads/decode_head.py#L17) for developing all segmentation heads.
-All newly implemented decode heads should be derived from it.
-Here we show how to develop a new head with the example of [PSPNet](https://arxiv.org/abs/1612.01105) as the following.
-
-First, add a new decode head in `mmseg/models/decode_heads/psp_head.py`.
-PSPNet implements a decode head for segmentation decode.
-To implement a decode head, we need to implement three functions of the new module as the following.
-
-```python
-from mmseg.registry import MODELS
-
-@MODELS.register_module()
-class PSPHead(BaseDecodeHead):
-
-    def __init__(self, pool_scales=(1, 2, 3, 6), **kwargs):
-        super(PSPHead, self).__init__(**kwargs)
-
-    def init_weights(self):
-        pass
-
-    def forward(self, inputs):
-        pass
-```
-
-Next, the users need to add the module in the `mmseg/models/decode_heads/__init__.py`, thus the corresponding registry could find and load them.
-
-To config file of PSPNet is as the following
-
-```python
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    type='EncoderDecoder',
-    pretrained='pretrain_model/resnet50_v1c_trick-2cccc1ad.pth',
-    backbone=dict(
-        type='ResNetV1c',
-        depth=50,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        dilations=(1, 1, 2, 4),
-        strides=(1, 2, 1, 1),
-        norm_cfg=norm_cfg,
-        norm_eval=False,
-        style='pytorch',
-        contract_dilation=True),
-    decode_head=dict(
-        type='PSPHead',
-        in_channels=2048,
-        in_index=3,
-        channels=512,
-        pool_scales=(1, 2, 3, 6),
-        dropout_ratio=0.1,
-        num_classes=19,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)))
-
-```
-
-### Add new loss
-
-Assume you want to add a new loss as `MyLoss` for segmentation decode.
-To add a new loss function, the users need to implement it in `mmseg/models/losses/my_loss.py`.
-The decorator `weighted_loss` enables the loss to be weighted for each element.
-
-```python
-import torch
-import torch.nn as nn
-
-from mmseg.registry import MODELS
-from .utils import weighted_loss
-
-@weighted_loss
-def my_loss(pred, target):
-    assert pred.size() == target.size() and target.numel() > 0
-    loss = torch.abs(pred - target)
-    return loss
-
-@MODELS.register_module()
-class MyLoss(nn.Module):
-
-    def __init__(self, reduction='mean', loss_weight=1.0):
-        super(MyLoss, self).__init__()
-        self.reduction = reduction
-        self.loss_weight = loss_weight
-
-    def forward(self,
-                pred,
-                target,
-                weight=None,
-                avg_factor=None,
-                reduction_override=None):
-        assert reduction_override in (None, 'none', 'mean', 'sum')
-        reduction = (
-            reduction_override if reduction_override else self.reduction)
-        loss = self.loss_weight * my_loss(
-            pred, target, weight, reduction=reduction, avg_factor=avg_factor)
-        return loss
-```
-
-Then the users need to add it in the `mmseg/models/losses/__init__.py`.
-
-```python
-from .my_loss import MyLoss, my_loss
-
-```
-
-To use it, modify the `loss_xxx` field.
-Then you need to modify the `loss_decode` field in the head.
-`loss_weight` could be used to balance multiple losses.
-
-```python
-loss_decode=dict(type='MyLoss', loss_weight=1.0))
-```
-
-### Add new data preprocessor
-
-In MMSegmentation 1.x versions, we use [SegDataPreProcessor](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/data_preprocessor.py#L13) to copy data to the target device and preprocess the data into the model input format as default. Here we show how to develop a new data preprocessor.
-
-1. Create a new file `mmseg/models/my_datapreprocessor.py`.
-
-   ```python
-   from mmengine.model import BaseDataPreprocessor
-
-   from mmseg.registry import MODELS
-
-   @MODELS.register_module()
-   class MyDataPreProcessor(BaseDataPreprocessor):
-       def __init__(self, **kwargs):
-           super().__init__(**kwargs)
-
-       def forward(self, data: dict, training: bool=False) -> Dict[str, Any]:
-           # TODO Define the logic for data pre-processing in the forward method
-           pass
-   ```
-
-2. Import your data preprocessor in `mmseg/models/__init__.py`
-
-   ```python
-   from .my_datapreprocessor import MyDataPreProcessor
-   ```
-
-3. Use it in your config file.
-
-   ```python
-   model = dict(
-       data_preprocessor=dict(type='MyDataPreProcessor)
-       ...
-   )
-   ```
-
-## Develop new segmentors
-
-The segmentor is an algorithmic architecture in which users can customize their algorithms by adding customized components and defining the logic of algorithm execution. Please refer to [the model document](./models.md) for more details.
-
-Since the [BaseSegmentor](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/segmentors/base.py#L15) in MMSegmentation unifies three modes for a forward process, to develop a new segmentor, users need to overwrite `loss`, `predict` and `_forward` methods corresponding to the `loss`, `predict` and `tensor` modes.
-
-Here we show how to develop a new segmentor.
-
-1. Create a new file `mmseg/models/segmentors/my_segmentor.py`.
-
-   ```python
-    from typing import Dict, Optional, Union
-
-    import torch
-
-    from mmseg.registry import MODELS
-    from mmseg.models import BaseSegmentor
-
-    @MODELS.register_module()
-    class MySegmentor(BaseSegmentor):
-        def __init__(self, **kwargs):
-            super().__init__(**kwargs)
-            # TODO users should build components of the network here
-
-        def loss(self, inputs: Tensor, data_samples: SampleList) -> dict:
-            """Calculate losses from a batch of inputs and data samples."""
-            pass
-
-        def predict(self, inputs: Tensor, data_samples: OptSampleList=None) -> SampleList:
-            """Predict results from a batch of inputs and data samples with post-
-            processing."""
-            pass
-
-       def _forward(self,
-                 inputs: Tensor,
-                 data_samples: OptSampleList = None) -> Tuple[List[Tensor]]:
-            """Network forward process.
-
-            Usually includes backbone, neck and head forward without any post-
-            processing.
-            """
-            pass
-   ```
-
-2. Import your segmentor in `mmseg/models/segmentors/__init__.py`.
-
-   ```python
-   from .my_segmentor import MySegmentor
-   ```
-
-3. Use it in your config file.
-
-   ```python
-   model = dict(
-       type='MySegmentor'
-       ...
-   )
-   ```
diff --git a/mmsegmentation/docs/en/advanced_guides/add_transforms.md b/mmsegmentation/docs/en/advanced_guides/add_transforms.md
deleted file mode 100644
index ca336ce..0000000
--- a/mmsegmentation/docs/en/advanced_guides/add_transforms.md
+++ /dev/null
@@ -1,52 +0,0 @@
-# Adding New Data Transforms
-
-## Customization data transformation
-
-The customized data transformation must inherited from `BaseTransform` and implement `transform` function.
-Here we use a simple flipping transformation as example:
-
-```python
-import random
-import mmcv
-from mmcv.transforms import BaseTransform, TRANSFORMS
-
-@TRANSFORMS.register_module()
-class MyFlip(BaseTransform):
-    def __init__(self, direction: str):
-        super().__init__()
-        self.direction = direction
-
-    def transform(self, results: dict) -> dict:
-        img = results['img']
-        results['img'] = mmcv.imflip(img, direction=self.direction)
-        return results
-```
-
-Moreover, import the new class.
-
-```python
-from .my_pipeline import MyFlip
-```
-
-Thus, we can instantiate a `MyFlip` object and use it to process the data dict.
-
-```python
-import numpy as np
-
-transform = MyFlip(direction='horizontal')
-data_dict = {'img': np.random.rand(224, 224, 3)}
-data_dict = transform(data_dict)
-processed_img = data_dict['img']
-```
-
-Or, we can use `MyFlip` transformation in data pipeline in our config file.
-
-```python
-pipeline = [
-    ...
-    dict(type='MyFlip', direction='horizontal'),
-    ...
-]
-```
-
-Note that if you want to use `MyFlip` in config, you must ensure the file containing `MyFlip` is imported during runtime.
diff --git a/mmsegmentation/docs/en/advanced_guides/customize_runtime.md b/mmsegmentation/docs/en/advanced_guides/customize_runtime.md
deleted file mode 100644
index 33281bf..0000000
--- a/mmsegmentation/docs/en/advanced_guides/customize_runtime.md
+++ /dev/null
@@ -1,168 +0,0 @@
-# Customize Runtime Settings
-
-## Customize hooks
-
-### Step 1: Implement a new hook
-
-MMEngine has implemented commonly used [hooks](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/hook.md) for training and test,
-When users have requirements for customization, they can follow examples below.
-For example, if some hyper-parameter of the model needs to be changed when model training, we can implement a new hook for it:
-
-```python
-# Copyright (c) OpenMMLab. All rights reserved.
-from typing import Optional, Sequence
-
-from mmengine.hooks import Hook
-from mmengine.model import is_model_wrapper
-
-from mmseg.registry import HOOKS
-
-
-@HOOKS.register_module()
-class NewHook(Hook):
-    """Docstring for NewHook.
-    """
-
-    def __init__(self, a: int, b: int) -> None:
-        self.a = a
-        self.b = b
-
-    def before_train_iter(self,
-                          runner,
-                          batch_idx: int,
-                          data_batch: Optional[Sequence[dict]] = None) -> None:
-        cur_iter = runner.iter
-        # acquire this model when it is in a wrapper
-        if is_model_wrapper(runner.model):
-          model = runner.model.module
-        model.hyper_parameter = self.a * cur_iter + self.b
-```
-
-### Step 2: Import a new hook
-
-The module which is defined above needs to be imported into main namespace first to ensure being registered.
-We assume `NewHook` is implemented in `mmseg/engine/hooks/new_hook.py`, there are two ways to import it:
-
-- Import it by modifying `mmseg/engine/hooks/__init__.py`.
-  Modules should be imported in `mmseg/engine/hooks/__init__.py` thus these new modules can be found and added by registry.
-
-```python
-from .new_hook import NewHook
-
-__all__ = [..., NewHook]
-```
-
-- Import it manually by `custom_imports` in config file.
-
-```python
-custom_imports = dict(imports=['mmseg.engine.hooks.new_hook'], allow_failed_imports=False)
-```
-
-### Step 3: Modify config file
-
-Users can set and use customized hooks in training and test followed methods below.
-The execution priority of hooks at the same place of `Runner` can be referred [here](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/hook.md#built-in-hooks),
-Default priority of customized hook is `NORMAL`.
-
-```python
-custom_hooks = [
-    dict(type='NewHook', a=a_value, b=b_value, priority='ABOVE_NORMAL')
-]
-```
-
-## Customize optimizer
-
-### Step 1: Implement a new optimizer
-
-We recommend the customized optimizer implemented in `mmseg/engine/optimizers/my_optimizer.py`. Here is an example of a new optimizer `MyOptimizer` which has parameters `a`, `b` and `c`:
-
-```python
-from mmseg.registry import OPTIMIZERS
-from torch.optim import Optimizer
-
-
-@OPTIMIZERS.register_module()
-class MyOptimizer(Optimizer):
-
-    def __init__(self, a, b, c)
-```
-
-### Step 2: Import a new optimizer
-
-The module which is defined above needs to be imported into main namespace first to ensure being registered.
-We assume `MyOptimizer` is implemented in `mmseg/engine/optimizers/my_optimizer.py`, there are two ways to import it:
-
-- Import it by modifying `mmseg/engine/optimizers/__init__.py`.
-  Modules should be imported in `mmseg/engine/optimizers/__init__.py` thus these new modules can be found and added by registry.
-
-```python
-from .my_optimizer import MyOptimizer
-```
-
-- Import it manually by `custom_imports` in config file.
-
-```python
-custom_imports = dict(imports=['mmseg.engine.optimizers.my_optimizer'], allow_failed_imports=False)
-```
-
-### Step 3: Modify config file
-
-Then it needs to modify `optimizer` in `optim_wrapper` of config file, if users want to use customized `MyOptimizer`, it can be modified as:
-
-```python
-optim_wrapper = dict(type='OptimWrapper',
-                     optimizer=dict(type='MyOptimizer',
-                                    a=a_value, b=b_value, c=c_value),
-                     clip_grad=None)
-```
-
-## Customize optimizer constructor
-
-### Step 1: Implement a new optimizer constructor
-
-Optimizer constructor is used to create optimizer and optimizer wrapper for model training, which has powerful functions like specifying learning rate and weight decay for different model layers.
-Here is an example for a customized optimizer constructor.
-
-```python
-from mmengine.optim import DefaultOptimWrapperConstructor
-from mmseg.registry import OPTIM_WRAPPER_CONSTRUCTORS
-
-@OPTIM_WRAPPER_CONSTRUCTORS.register_module()
-class LearningRateDecayOptimizerConstructor(DefaultOptimWrapperConstructor):
-    def __init__(self, optim_wrapper_cfg, paramwise_cfg=None):
-
-    def __call__(self, model):
-
-        return my_optimizer
-```
-
-Default optimizer constructor is implemented [here](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py#L19).
-It can also be used as base class of new optimizer constructor.
-
-### Step 2: Import a new optimizer constructor
-
-The module which is defined above needs to be imported into main namespace first to ensure being registered.
-We assume `MyOptimizerConstructor` is implemented in `mmseg/engine/optimizers/my_optimizer_constructor.py`, there are two ways to import it:
-
-- Import it by modifying `mmseg/engine/optimizers/__init__.py`.
-  Modules should be imported in `mmseg/engine/optimizers/__init__.py` thus these new modules can be found and added by registry.
-
-```python
-from .my_optimizer_constructor import MyOptimizerConstructor
-```
-
-- Import it manually by `custom_imports` in config file.
-
-```python
-custom_imports = dict(imports=['mmseg.engine.optimizers.my_optimizer_constructor'], allow_failed_imports=False)
-```
-
-### Step 3: Modify config file
-
-Then it needs to modify `constructor` in `optim_wrapper` of config file, if users want to use customized `MyOptimizerConstructor`, it can be modified as:
-
-```python
-optim_wrapper = dict(type='OptimWrapper',
-                     constructor='MyOptimizerConstructor',
-                     clip_grad=None)
-```
diff --git a/mmsegmentation/docs/en/advanced_guides/data_flow.md b/mmsegmentation/docs/en/advanced_guides/data_flow.md
deleted file mode 100644
index 404035a..0000000
--- a/mmsegmentation/docs/en/advanced_guides/data_flow.md
+++ /dev/null
@@ -1,87 +0,0 @@
-# Dataflow
-
-In this chapter, we will introduce the dataflow and data format convention between the internal modules managed by the [Runner](https://mmengine.readthedocs.io/en/latest/tutorials/runner.html).
-
-## Overview of dataflow
-
-The [Runner](https://github.com/open-mmlab/mmengine/blob/main/docs/en/design/runner.md) is an "integrator" in MMEngine. It covers all aspects of the framework and shoulders the responsibility of organizing and scheduling nearly all modules, that means the dataflow between all modules also controlled by the `Runner`. As illustrated in the [Runner document of MMEngine](https://mmengine.readthedocs.io/en/latest/tutorials/runner.html), the following diagram shows the basic dataflow.
-
-![Basic dataflow](https://user-images.githubusercontent.com/112053249/199228350-5f80699e-7fd2-4b4c-ac32-0b16b1922c2e.png)
-
-The dashed border, gray filled shapes represent different data formats, while solid boxes represent modules/methods. Due to the great flexibility and extensibility of MMEngine, some critical base classes can be inherited and their methods can be overridden. The diagram above only holds when users are not customizing `TrainLoop`, `ValLoop`, and `TestLoop` in `Runner`, and are not overriding `train_step`, `val_step` and `test_step` method in their custom model. The default setting of loops in MMSegmentation is as follows, it uses `IterBasedTrainLoop` to train models with 20000 iterations in total and do evaluation each 2000 iterations.
-
-```python
-train_cfg = dict(type='IterBasedTrainLoop', max_iters=20000, val_interval=2000)
-val_cfg = dict(type='ValLoop')
-test_cfg = dict(type='TestLoop')
-```
-
-In the above diagram, the red line indicates the [train_step](./models.md#train_step). At each training iteration, dataloader loads images from storage and transfer to data preprocessor, data preprocessor would put images to the specific device and stack data to batch, then model accepts the batch data as inputs, finally the outputs of the model would be sent to optimizer. The blue line indicates [val_step](./models.md#val_step) and [test_step](./models.md#test_step). The dataflow of these two process is similar to the `train_step` except the outputs of model, since model parameters are freezed when doing evaluation, the model output would be transferred to [Evaluator](./evaluation.md#ioumetric) to compute metrics.
-
-## Dataflow convention in MMSegmentation
-
-From the diagram above, we could see the basic dataflow. In this section, we would introduce format convention of data involved in this dataflow, respectively.
-
-### DataLoader to Data Preprocessor
-
-DataLoader is an essential component in training and testing pipelines of MMEngine. Conceptually, it is derived from and consistent with [PyTorch](https://pytorch.org/). DataLoader loads data from filesystem and the original data passes through data preparation pipeline, then it would be sent to Data Preprocessor.
-
-MMSegmentation defines the default data format at [PackSegInputs](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/transforms/formatting.py#L12), it's the last component of `train_pipeline` and `test_pipeline`. Please refer to [data transform documentation](./transforms.md) for more information about data transform `pipeline`.
-
-Without any modifications, the return value of PackSegInputs is usually a `dict` and has only two keys, `inputs` and `data_samples`. The following pseudo-code shows the data types of the data loader output in mmseg, which is a batch of fetched data samples from the dataset, and data loader packs them into a dictionary of the list. `inputs` is the list of input tensors to the model and `data_samples` contains a list of input images' meta information and corresponding ground truth.
-
-```python
-dict(
-    inputs=List[torch.Tensor],
-    data_samples=List[SegDataSample]
-)
-```
-
-**Note:** [SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py) is a data structure interface of MMSegmentation, it is used as an interface between different components. `SegDataSample` implements the abstract data element `mmengine.structures.BaseDataElement`, please refer to [the SegDataSample documentation](./structures.md) and [data element documentation](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/data_element.html) in [MMEngine](https://github.com/open-mmlab/mmengine) for more information.
-
-### Data Preprocessor to Model
-
-Though drawn separately in the diagram [above](#overview-of-dataflow), data_preprocessor is a part of the model and thus can be found in [Model tutorial](./models.md) at data preprocessor chapter.
-
-The return value of data preprocessor is a dictionary, containing `inputs` and `data_samples`, `inputs` is batched images, a 4D tensor, and some additional meta info used in data preprocesses would be added to the `data_samples`. When transferred to the network, the dictionary would be unpacked to two values. The following pseudo-codes show the return value of the data preprocessor and the input values of model.
-
-```python
-dict(
-    inputs=torch.Tensor,
-    data_samples=List[SegDataSample]
-)
-```
-
-```python
-class Network(BaseSegmentor):
-
-    def forward(self, inputs: torch.Tensor, data_samples: List[SegDataSample], mode: str):
-        pass
-```
-
-**Note:** Model forward has 3 kinds of mode, which is controlled by input argumentmode, please refer [model tutorial](./models.md) for more details.
-
-### Model output
-
-As [model tutorial](./models.md#forward) mentioned 3 kinds of mode forward with 3 kinds of output. `train_step`and `test_step`(or `val_step`) correspond to `'loss'` and `'predict'` respectively.
-
-In `test_step` or `val_step`, the inference results would be transferred to `Evaluator`. You might read the [evaluation document](./evaluation.md) for more information about `Evaluator`.
-
-After inference, the [BaseSegmentor](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/segmentors/base.py#L15) in MMSegmentation would do a simple post process to pack inference results, the segmentation logits produced by the neural network, segmentation mask after the `argmax` operation and ground truth(if exists) would be packed into a similar `SegDataSample` instance. The return value of [postprocess_result](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/segmentors/base.py#L132) is a **`List` of `SegDataSample`**. Following diagram shows the key properties of these `SegDataSample` instances.
-
-![SegDataSample](https://user-images.githubusercontent.com/15952744/209912225-ab46a8d9-904a-43cb-8bf1-8bec4938ed29.png)
-
-The same as Data Preprocessor, loss function is also a part of the model, it's a property of [decode head](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/decode_heads/decode_head.py#L142).
-
-In MMSegmentation, the method [loss_by_feat](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/decode_heads/decode_head.py#L291) of `decode_head` is an unified interface used to compute loss.
-
-Parameters:
-
-- seg_logits (Tensor): The output from decode head forward function.
-- batch_data_samples (List\[:obj:`SegDataSample`\]): The seg data samples. It usually includes information such as `metainfo` and `gt_sem_seg`.
-
-Returns:
-
-- dict\[str, Tensor\]: a dictionary of loss components
-
-**Note:** The `train_step` transfers the loss into OptimWrapper to update the weights in model, please refer [train_step](./models.md#train_step) for more details.
diff --git a/mmsegmentation/docs/en/advanced_guides/datasets.md b/mmsegmentation/docs/en/advanced_guides/datasets.md
deleted file mode 100644
index 1efc334..0000000
--- a/mmsegmentation/docs/en/advanced_guides/datasets.md
+++ /dev/null
@@ -1,386 +0,0 @@
-# Dataset
-
-Dataset classes in MMSegmentation have two functions: (1) load data information after [data preparation](../user_guides/2_dataset_prepare.md)
-and (2) send data into [dataset transform pipeline](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/basesegdataset.py#L141) to do [data augmentation](./transforms.md).
-There are 2 kinds of loaded information: (1) meta information which is original dataset information such as categories (classes) of dataset and their corresponding palette information, (2) data information which includes
-the path of dataset images and labels.
-The tutorial includes some main interfaces in MMSegmentation 1.x dataset class: methods of loading data information and modifying dataset classes in base dataset class, and the relationship between dataset and the data transform pipeline.
-
-## Main Interfaces
-
-Take Cityscapes as an example, if you want to run the example, please download and [preprocess](../user_guides/2_dataset_prepare.md#cityscapes)
-Cityscapes dataset in `data` directory, before running the demo code:
-
-Instantiate Cityscapes training dataset:
-
-```python
-from mmseg.datasets import CityscapesDataset
-from mmengine.registry import init_default_scope
-init_default_scope('mmseg')
-
-data_root = 'data/cityscapes/'
-data_prefix=dict(img_path='leftImg8bit/train', seg_map_path='gtFine/train')
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='RandomCrop', crop_size=(512, 1024), cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PackSegInputs')
-]
-
-dataset = CityscapesDataset(data_root=data_root, data_prefix=data_prefix, test_mode=False, pipeline=train_pipeline)
-```
-
-Get the length of training set:
-
-```python
-print(len(dataset))
-
-2975
-```
-
-Get data information: The type of data information is `dict` which includes several keys:
-
-- `'img_path'`: path of images
-- `'seg_map_path'`: path of segmentation labels
-- `'seg_fields'`: saving label fields
-- `'sample_idx'`: the  index of the current sample
-
-There are also `'label_map'` and `'reduce_zero_label'` whose functions would be introduced in the next section.
-
-```python
-# Acquire data information of first sample in dataset
-print(dataset.get_data_info(0))
-
-{'img_path': 'data/cityscapes/leftImg8bit/train/aachen/aachen_000000_000019_leftImg8bit.png',
- 'seg_map_path': 'data/cityscapes/gtFine/train/aachen/aachen_000000_000019_gtFine_labelTrainIds.png',
- 'label_map': None,
- 'reduce_zero_label': False,
- 'seg_fields': [],
- 'sample_idx': 0}
-```
-
-Get dataset meta information: the type of MMSegmentation meta information is also `dict`, which includes `'classes'` field for dataset classes and `'palette'` field for corresponding colors in visualization, and has `'label_map'` field and `'reduce_zero_label'` filed.
-
-```python
-print(dataset.metainfo)
-
-{'classes': ('road',
-  'sidewalk',
-  'building',
-  'wall',
-  'fence',
-  'pole',
-  'traffic light',
-  'traffic sign',
-  'vegetation',
-  'terrain',
-  'sky',
-  'person',
-  'rider',
-  'car',
-  'truck',
-  'bus',
-  'train',
-  'motorcycle',
-  'bicycle'),
- 'palette': [[128, 64, 128],
-  [244, 35, 232],
-  [70, 70, 70],
-  [102, 102, 156],
-  [190, 153, 153],
-  [153, 153, 153],
-  [250, 170, 30],
-  [220, 220, 0],
-  [107, 142, 35],
-  [152, 251, 152],
-  [70, 130, 180],
-  [220, 20, 60],
-  [255, 0, 0],
-  [0, 0, 142],
-  [0, 0, 70],
-  [0, 60, 100],
-  [0, 80, 100],
-  [0, 0, 230],
-  [119, 11, 32]],
- 'label_map': None,
- 'reduce_zero_label': False}
-```
-
-The return value of dataset `__getitem__` method is the output of data samples after data augmentation, whose type is also `dict`. It has two fields: `'inputs'` corresponding to images after data augmentation,
-and `'data_samples'` corresponding to [`SegDataSample`](./structures.md) which is new data structures in MMSegmentation 1.x,
-and `gt_sem_seg` of `SegDataSample` has labels after data augmentation operations.
-
-```python
-print(dataset[0])
-
-{'inputs': tensor([[[131, 130, 130,  ...,  23,  23,  23],
-          [132, 132, 132,  ...,  23,  22,  23],
-          [134, 133, 133,  ...,  23,  23,  23],
-          ...,
-          [ 66,  67,  67,  ...,  71,  71,  71],
-          [ 66,  67,  66,  ...,  68,  68,  68],
-          [ 67,  67,  66,  ...,  70,  70,  70]],
-
-         [[143, 143, 142,  ...,  28,  28,  29],
-          [145, 145, 145,  ...,  28,  28,  29],
-          [145, 145, 145,  ...,  27,  28,  29],
-          ...,
-          [ 75,  75,  76,  ...,  80,  81,  81],
-          [ 75,  76,  75,  ...,  80,  80,  80],
-          [ 77,  76,  76,  ...,  82,  82,  82]],
-
-         [[126, 125, 126,  ...,  21,  21,  22],
-          [127, 127, 128,  ...,  21,  21,  22],
-          [127, 127, 126,  ...,  21,  21,  22],
-          ...,
-          [ 63,  63,  64,  ...,  69,  69,  70],
-          [ 64,  65,  64,  ...,  69,  69,  69],
-          [ 65,  66,  66,  ...,  72,  71,  71]]], dtype=torch.uint8),
- 'data_samples': <SegDataSample(
-
-     META INFORMATION
-     img_path: 'data/cityscapes/leftImg8bit/train/aachen/aachen_000000_000019_leftImg8bit.png'
-     seg_map_path: 'data/cityscapes/gtFine/train/aachen/aachen_000000_000019_gtFine_labelTrainIds.png'
-     img_shape: (512, 1024, 3)
-     flip_direction: None
-     ori_shape: (1024, 2048)
-     flip: False
-
-     DATA FIELDS
-     gt_sem_seg: <PixelData(
-
-             META INFORMATION
-
-             DATA FIELDS
-             data: tensor([[[2, 2, 2,  ..., 8, 8, 8],
-                          [2, 2, 2,  ..., 8, 8, 8],
-                          [2, 2, 2,  ..., 8, 8, 8],
-                          ...,
-                          [0, 0, 0,  ..., 0, 0, 0],
-                          [0, 0, 0,  ..., 0, 0, 0],
-                          [0, 0, 0,  ..., 0, 0, 0]]])
-         )>
-     _gt_sem_seg: <PixelData(
-
-             META INFORMATION
-
-             DATA FIELDS
-             data: tensor([[[2, 2, 2,  ..., 8, 8, 8],
-                          [2, 2, 2,  ..., 8, 8, 8],
-                          [2, 2, 2,  ..., 8, 8, 8],
-                          ...,
-                          [0, 0, 0,  ..., 0, 0, 0],
-                          [0, 0, 0,  ..., 0, 0, 0],
-                          [0, 0, 0,  ..., 0, 0, 0]]])
-         )>
- )}
-```
-
-## BaseSegDataset
-
-As mentioned above, dataset classes have the same functions, we implemented  [`BaseSegDataset`](https://mmsegmentation.readthedocs.io/en/latest/api.html?highlight=BaseSegDataset#mmseg.datasets.BaseSegDataset) to reues the common functions.
-It inherits [`BaseDataset` of MMEngine](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/basedataset.md) and follows unified initialization process of OpenMMLab. It supports the highly effective interior storing format, some functions like
-dataset concatenation and repeatedly sampling. In MMSegmentation `BaseSegDataset`, the **method of loading data information** (`load_data_list`) is redefined and adds new `get_label_map` method to **modify dataset classes information**.
-
-### Loading Dataset Information
-
-The loaded data information includes the path of images samples and annotations samples, the detailed implementation could be found in
-[`load_data_list`](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/basesegdataset.py#L231) of `BaseSegDataset` in MMSegmentation.
-There are two main methods to acquire the path of images and labels:
-
-1. Load file paths according to the dirictory and suffix of input images and annotations
-
-If the dataset directory structure is organized as below, the [`load_data_list`](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/basesegdataset.py#L231) can parse dataset directory Structure:
-
-```
-├── data
-│   ├── my_dataset
-│   │   ├── img_dir
-│   │   │   ├── train
-│   │   │   │   ├── xxx{img_suffix}
-│   │   │   │   ├── yyy{img_suffix}
-│   │   │   ├── val
-│   │   │   │   ├── zzz{img_suffix}
-│   │   ├── ann_dir
-│   │   │   ├── train
-│   │   │   │   ├── xxx{seg_map_suffix}
-│   │   │   │   ├── yyy{seg_map_suffix}
-│   │   │   ├── val
-│   │   │   │   ├── zzz{seg_map_suffix}
-```
-
-Here is an example pf ADE20K, and below the directory structure of the dataset:
-
-```
-├── ade
-│   ├── ADEChallengeData2016
-│   │   ├── annotations
-│   │   │   ├── training
-│   │   │   │   ├── ADE_train_00000001.png
-│   │   │   │   ├── ...
-│   │   │   │── validation
-│   │   │   │   ├── ADE_val_00000001.png
-│   │   │   │   ├── ...
-│   │   ├── images
-│   │   │   ├── training
-│   │   │   │   ├── ADE_train_00000001.jpg
-│   │   │   │   ├── ...
-│   │   │   ├── validation
-│   │   │   │   ├── ADE_val_00000001.jpg
-│   │   │   │   ├── ...
-```
-
-```python
-from mmseg.datasets import ADE20KDataset
-
-ADE20KDataset(data_root = 'data/ade/ADEChallengeData2016',
-    data_prefix=dict(img_path='images/training', seg_map_path='annotations/training'),
-    img_suffix='.jpg',
-    seg_map_suffix='.png',
-    reduce_zero_label=True)
-```
-
-2. Load file paths from annotation file
-
-Dataset also can load an annotation file which includes the data sample paths of dataset.
-Take PascalContext dataset instance as an example, its input annotation file is:
-
-```python
-2008_000008
-...
-```
-
-It needs to define `ann_file` when instantiation:
-
-```python
-PascalContextDataset(data_root='data/VOCdevkit/VOC2010/',
-    data_prefix=dict(img_path='JPEGImages', seg_map_path='SegmentationClassContext'),
-    ann_file='ImageSets/SegmentationContext/train.txt')
-```
-
-### Modification of Dataset Classes
-
-- Use `metainfo` input argument
-
-Meta information is defined as class variables, such as `METAINFO` variable of Cityscapes:
-
-```python
-class CityscapesDataset(BaseSegDataset):
-    """Cityscapes dataset.
-
-    The ``img_suffix`` is fixed to '_leftImg8bit.png' and ``seg_map_suffix`` is
-    fixed to '_gtFine_labelTrainIds.png' for Cityscapes dataset.
-    """
-    METAINFO = dict(
-        classes=('road', 'sidewalk', 'building', 'wall', 'fence', 'pole',
-                 'traffic light', 'traffic sign', 'vegetation', 'terrain',
-                 'sky', 'person', 'rider', 'car', 'truck', 'bus', 'train',
-                 'motorcycle', 'bicycle'),
-        palette=[[128, 64, 128], [244, 35, 232], [70, 70, 70], [102, 102, 156],
-                 [190, 153, 153], [153, 153, 153], [250, 170,
-                                                    30], [220, 220, 0],
-                 [107, 142, 35], [152, 251, 152], [70, 130, 180],
-                 [220, 20, 60], [255, 0, 0], [0, 0, 142], [0, 0, 70],
-                 [0, 60, 100], [0, 80, 100], [0, 0, 230], [119, 11, 32]])
-
-```
-
-Here `'classes'` defines class names of Cityscapes dataset annotations, if users only concern some classes about vehicles and **ignore other classes**,
-the meta information of dataset could be modified by defined input argument `metainfo` when instantiating Cityscapes dataset:
-
-```python
-from mmseg.datasets import CityscapesDataset
-
-data_root = 'data/cityscapes/'
-data_prefix=dict(img_path='leftImg8bit/train', seg_map_path='gtFine/train')
-# metainfo only keep classes below:
-metainfo=dict(classes=( 'car', 'truck', 'bus', 'train', 'motorcycle', 'bicycle'))
-dataset = CityscapesDataset(data_root=data_root, data_prefix=data_prefix, metainfo=metainfo)
-
-print(dataset.metainfo)
-
-{'classes': ('car', 'truck', 'bus', 'train', 'motorcycle', 'bicycle'),
- 'palette': [[0, 0, 142],
-  [0, 0, 70],
-  [0, 60, 100],
-  [0, 80, 100],
-  [0, 0, 230],
-  [119, 11, 32],
-  [128, 64, 128],
-  [244, 35, 232],
-  [70, 70, 70],
-  [102, 102, 156],
-  [190, 153, 153],
-  [153, 153, 153],
-  [250, 170, 30],
-  [220, 220, 0],
-  [107, 142, 35],
-  [152, 251, 152],
-  [70, 130, 180],
-  [220, 20, 60],
-  [255, 0, 0]],
- # pixels whose label index are 255 would be ignored when calculating loss
- 'label_map': {0: 255,
-  1: 255,
-  2: 255,
-  3: 255,
-  4: 255,
-  5: 255,
-  6: 255,
-  7: 255,
-  8: 255,
-  9: 255,
-  10: 255,
-  11: 255,
-  12: 255,
-  13: 0,
-  14: 1,
-  15: 2,
-  16: 3,
-  17: 4,
-  18: 5},
- 'reduce_zero_label': False}
-```
-
-Meta information is different from default setting of Cityscapes dataset. Moreover, `label_map` field is also defined, which is used for modifying label index of each pixel on segmentation mask.
-The segmentation label would re-map class information by `label_map`, [here](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/basesegdataset.py#L151) is detailed implementation:
-
-```python
-gt_semantic_seg_copy = gt_semantic_seg.copy()
-for old_id, new_id in results['label_map'].items():
-    gt_semantic_seg[gt_semantic_seg_copy == old_id] = new_id
-```
-
-- Using `reduce_zero_label` input argument
-
-To ignore label 0 (such as ADE20K dataset), we can use `reduce_zero_label` (default to `False`) argument of BaseSegDataset and its subclasses.
-When `reduce_zero_label` is `True`, label 0 in segmentation annotations would be set as 255 (models of MMSegmentation would ignore label 255 in calculating loss) and indices of other labels will minus 1:
-
-```python
-gt_semantic_seg[gt_semantic_seg == 0] = 255
-gt_semantic_seg = gt_semantic_seg - 1
-gt_semantic_seg[gt_semantic_seg == 254] = 255
-```
-
-## Dataset and Data Transform Pipeline
-
-If the argument `pipeline` is defined, the return value of `__getitem__` method is after data argument.
-If dataset input argument does not define pipeline, it is the same as return value of `get_data_info` method.
-
-```python
-from mmseg.datasets import CityscapesDataset
-
-data_root = 'data/cityscapes/'
-data_prefix=dict(img_path='leftImg8bit/train', seg_map_path='gtFine/train')
-dataset = CityscapesDataset(data_root=data_root, data_prefix=data_prefix, test_mode=False)
-
-print(dataset[0])
-
-{'img_path': 'data/cityscapes/leftImg8bit/train/aachen/aachen_000000_000019_leftImg8bit.png',
- 'seg_map_path': 'data/cityscapes/gtFine/train/aachen/aachen_000000_000019_gtFine_labelTrainIds.png',
- 'label_map': None,
- 'reduce_zero_label': False,
- 'seg_fields': [],
- 'sample_idx': 0}
-```
diff --git a/mmsegmentation/docs/en/advanced_guides/engine.md b/mmsegmentation/docs/en/advanced_guides/engine.md
deleted file mode 100644
index 7acfe5a..0000000
--- a/mmsegmentation/docs/en/advanced_guides/engine.md
+++ /dev/null
@@ -1,279 +0,0 @@
-# Training Engine
-
-MMEngine defined some [basic loop controllers](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py) such as epoch-based training loop (`EpochBasedTrainLoop`), iteration-based training loop (`IterBasedTrainLoop`), standard validation loop (`ValLoop`), and standard testing loop (`TestLoop`).
-
-OpenMMLab's algorithm libraries like MMSegmentation abstract model training, testing, and inference as `Runner` to handle. Users can use the default `Runner` in MMEngine directly or modify the `Runner` to meet customized needs. This document mainly introduces how users can configure existing running settings, hooks, and optimizers' basic concepts and usage methods.
-
-## Configuring Runtime Settings
-
-### Configuring Training Iterations
-
-Loop controllers refer to the execution process during training, validation, and testing. `train_cfg`, `val_cfg`, and `test_cfg` are used to build these processes in the configuration file. MMSegmentation sets commonly used training iterations in `train_cfg` under the `configs/_base_/schedules` folder.
-For example, to train for 80,000 iterations using the iteration-based training loop (`IterBasedTrainLoop`) and perform validation every 8,000 iterations, you can set it as follows:
-
-```python
-train_cfg = dict(type='IterBasedTrainLoop', max_iters=80000, val_interval=8000)
-```
-
-### Configuring Training Optimizers
-
-Here's an example of a SGD optimizer:
-
-```python
-optim_wrapper = dict(
-    type='OptimWrapper',
-    optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005),
-    clip_grad=None)
-```
-
-OpenMMLab supports all optimizers in PyTorch. For more details, please refer to the [MMEngine optimizer documentation](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/optim_wrapper.md).
-
-It is worth emphasizing that `optim_wrapper` is a variable of `runner`, so when configuring the optimizer, the field to configure is the `optim_wrapper` field. For more information on using optimizers, see the [Optimizer](#Optimizer) section below.
-
-### Configuring Training Parameter Schedulers
-
-Before configuring the training parameter scheduler, it is recommended to first understand the basic concepts of parameter schedulers in the [MMEngine documentation](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/param_scheduler.md).
-
-Here's an example of a parameter scheduler. During training, a linearly changing learning rate strategy is used for warm-up in the first 1,000 iterations. After the first 1,000 iterations until the 16,000 iterations in the end, the default polynomial learning rate decay is used:
-
-```python
-param_scheduler = [
-    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
-    dict(
-        type='PolyLR',
-        eta_min=1e-4,
-        power=0.9,
-        begin=1000,
-        end=160000,
-        by_epoch=False,
-    )
-]
-```
-
-Note: When modifying the `max_iters` in `train_cfg`, make sure the parameters in the parameter scheduler `param_scheduler` are also modified accordingly.
-
-## Hook
-
-### Introduction
-
-OpenMMLab abstracts the model training and testing process as `Runner`. Inserting hooks can implement the corresponding functionality needed at different training and testing stages (such as "before and after each training iter", "before and after each validation iter", etc.) in `Runner`. For more introduction on hook mechanisms, please refer to [here](https://www.calltutors.com/blog/what-is-hook).
-
-Hooks used in `Runner` are divided into two categories:
-
-- Default hooks:
-
-They implement essential functions during training and are defined in the configuration file by `default_hooks` and passed to `Runner`. `Runner` registers them through the [`register_default_hooks`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py#L1780) method.
-
-Hooks have corresponding priorities; the higher the priority, the earlier the runner calls them. If the priorities are the same, the calling order is consistent with the hook registration order.
-
-It is not recommended for users to modify the default hook priorities. Please refer to the [MMEngine hooks documentation](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/hook.md) to understand the hook priority definitions.
-
-The following are the default hooks used in MMSegmentation:
-
-|                                                          Hook                                                          |                                                          Function                                                          |     Priority      |
-| :--------------------------------------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------: | :---------------: |
-|          [IterTimerHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/iter_timer_hook.py)           |                                          Record the time spent on each iteration.                                          |    NORMAL (50)    |
-|              [LoggerHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/logger_hook.py)              | Collect log records from different components in `Runner` and output them to terminal, JSON file, tensorboard, wandb, etc. | BELOW_NORMAL (60) |
-|     [ParamSchedulerHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/param_scheduler_hook.py)      |                       Update some hyperparameters in the optimizer, such as learning rate momentum.                        |     LOW (70)      |
-|          [CheckpointHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/checkpoint_hook.py)          |                                              Regularly save checkpoint files.                                              |   VERY_LOW (90)   |
-|      [DistSamplerSeedHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/sampler_seed_hook.py)       |                                     Ensure the distributed sampler shuffle is enabled.                                     |    NORMAL (50)    |
-| [SegVisualizationHook](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/visualization/local_visualizer.py) |                                Visualize prediction results during validation and testing.                                 |    NORMAL (50)    |
-
-MMSegmentation registers some hooks with essential training functions in `default_hooks`:
-
-```python
-default_hooks = dict(
-    timer=dict(type='IterTimerHook'),
-    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
-    param_scheduler=dict(type='ParamSchedulerHook'),
-    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=32000),
-    sampler_seed=dict(type='DistSamplerSeedHook'),
-    visualization=dict(type='SegVisualizationHook'))
-```
-
-All the default hooks mentioned above, except for `SegVisualizationHook`, are implemented in MMEngine. The `SegVisualizationHook` is a hook implemented in MMSegmentation, which will be introduced later.
-
-- Modifying default hooks
-
-We will use the `logger` and `checkpoint` in `default_hooks` as examples to demonstrate how to modify the default hooks in `default_hooks`.
-
-(1) Model saving configuration
-
-`default_hooks` uses the `checkpoint` field to initialize the [model saving hook (CheckpointHook)](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/checkpoint_hook.py#L19).
-
-```python
-checkpoint = dict(type='CheckpointHook', interval=1)
-```
-
-Users can set `max_keep_ckpts` to save only a small number of checkpoints or use `save_optimizer` to determine whether to save optimizer information. More details on related parameters can be found [here](https://mmengine.readthedocs.io/en/latest/api/generated/mmengine.hooks.CheckpointHook.html#checkpointhook).
-
-(2) Logging configuration
-
-The `LoggerHook` is used to collect log information from different components in `Runner` and write it to terminal, JSON files, tensorboard, wandb, etc.
-
-```python
-logger=dict(type='LoggerHook', interval=10)
-```
-
-In the latest 1.x version of MMSegmentation, some logger hooks (LoggerHook) such as `TextLoggerHook`, `WandbLoggerHook`, and `TensorboardLoggerHook` will no longer be used. Instead, MMEngine uses `LogProcessor` to handle the information processed by the aforementioned hooks, which are now in [`MessageHub`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/logging/message_hub.py#L17), [`WandbVisBackend`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/visualization/vis_backend.py#L324), and [`TensorboardVisBackend`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/visualization/vis_backend.py#L472).
-
-Detailed usage is as follows, configuring the visualizer and specifying the visualization backend at the same time, here using Tensorboard as the visualizer's backend:
-
-```python
-# TensorboardVisBackend
-visualizer = dict(
-    type='SegLocalVisualizer', vis_backends=[dict(type='TensorboardVisBackend')], name='visualizer')
-```
-
-For more related usage, please refer to [MMEngine Visualization Backend User Tutorial](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/visualization.md).
-
-- Custom hooks
-
-Custom hooks are defined in the configuration through `custom_hooks`, and `Runner` registers them using the [`register_custom_hooks`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py#L1820) method.
-
-The priority of custom hooks needs to be set in the configuration file; if not, it will be set to `NORMAL` by default. The following are some custom hooks implemented in MMEngine:
-
-|                                                  Hook                                                  |                                                               Usage                                                                |
-| :----------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------: |
-|         [EMAHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/ema_hook.py)         |                                    Use Exponential Moving Average (EMA) during model training.                                     |
-| [EmptyCacheHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/empty_cache_hook.py)  |                                  Release all GPU memory not occupied by the cache during training                                  |
-| [SyncBuffersHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/sync_buffer_hook.py) | Synchronize the parameters in the model buffer, such as `running_mean` and `running_var` in BN, at the end of each training epoch. |
-
-The following is a use case for `EMAHook`, where the config file includes the configuration of the implemented custom hooks as members of the `custom_hooks` list.
-
-```python
-custom_hooks = [
-    dict(type='EMAHook', start_iters=500, priority='NORMAL')
-]
-```
-
-### SegVisualizationHook
-
-MMSegmentation implemented [`SegVisualizationHook`](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/engine/hooks/visualization_hook.py#L17), which is used to visualize prediction results during validation and testing.
-`SegVisualizationHook` overrides the `_after_iter` method in the base class `Hook`. During validation or testing, it calls the `add_datasample` method of `visualizer` to draw semantic segmentation results according to the specified iteration interval. The specific implementation is as follows:
-
-```python
-...
-@HOOKS.register_module()
-class SegVisualizationHook(Hook):
-...
-    def _after_iter(self,
-                    runner: Runner,
-                    batch_idx: int,
-                    data_batch: dict,
-                    outputs: Sequence[SegDataSample],
-                    mode: str = 'val') -> None:
-...
-        # If it's a training phase or self.draw is False, then skip it
-        if self.draw is False or mode == 'train':
-            return
-...
-        if self.every_n_inner_iters(batch_idx, self.interval):
-            for output in outputs:
-                img_path = output.img_path
-                img_bytes = self.file_client.get(img_path)
-                img = mmcv.imfrombytes(img_bytes, channel_order='rgb')
-                window_name = f'{mode}_{osp.basename(img_path)}'
-
-                self._visualizer.add_datasample(
-                    window_name,
-                    img,
-                    data_sample=output,
-                    show=self.show,
-                    wait_time=self.wait_time,
-                    step=runner.iter)
-
-```
-
-For more details about visualization, you can check [here](../user_guides/visualization.md).
-
-## Optimizer
-
-In the previous configuration and runtime settings, we provided a simple example of configuring the training optimizer. This section will further detailly introduce  how to configure optimizers in MMSegmentation.
-
-## Optimizer Wrapper
-
-OpenMMLab 2.0 introduces an optimizer wrapper that supports different training strategies, including mixed-precision training, gradient accumulation, and gradient clipping. Users can choose the appropriate training strategy according to their needs. The optimizer wrapper also defines a standard parameter update process, allowing users to switch between different training strategies within the same code. For more information, please refer to the [MMEngine optimizer wrapper documentation](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/optim_wrapper.md).
-
-Here are some common usage methods in MMSegmentation:
-
-#### Configuring PyTorch Supported Optimizers
-
-OpenMMLab 2.0 supports all native PyTorch optimizers, as referenced [here](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/optim_wrapper.md).
-
-To set the optimizer used by the `Runner` during training in the configuration file, you need to define `optim_wrapper` instead of `optimizer`. Below is an example of configuring an optimizer during training:
-
-```python
-optim_wrapper = dict(
-    type='OptimWrapper',
-    optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005),
-    clip_grad=None)
-```
-
-#### Configuring Gradient Clipping
-
-When the model training requires gradient clipping, you can configure it as shown in the following example:
-
-```python
-optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer,
-                        clip_grad=dict(max_norm=0.01, norm_type=2))
-```
-
-Here, `max_norm` refers to the maximum value of the gradient after clipping, and `norm_type` refers to the norm used when clipping the gradient. Related methods can be found in [torch.nn.utils.clip_grad_norm\_](https://pytorch.org/docs/stable/generated/torch.nn.utils.clip_grad_norm_.html).
-
-#### Configuring Mixed Precision Training
-
-When mixed precision training is needed to reduce memory usage, you can use `AmpOptimWrapper`. The specific configuration is as follows:
-
-```python
-optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='AmpOptimWrapper', optimizer=optimizer)
-```
-
-The default setting for `loss_scale` in [`AmpOptimWrapper`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/amp_optimizer_wrapper.py#L20) is `dynamic`.
-
-#### Configuring Hyperparameters for Different Layers of the Model Network
-
-In model training, if you want to set different optimization strategies for different parameters in the optimizer, such as setting different learning rates, weight decay, and other hyperparameters, you can achieve this by setting `paramwise_cfg` in the `optim_wrapper` of the configuration file.
-
-The following config file uses the [ViT `optim_wrapper`](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_vit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py#L15-L27) as an example to introduce the use of `paramwise_cfg` parameters. During training, the weight decay parameter coefficients for the `pos_embed`, `mask_token`, and `norm` modules are set to 0. That is, during training, the weight decay for these modules will be changed to `weight_decay * decay_mult`=0.
-
-```python
-optimizer = dict(
-        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01)
-optim_wrapper = dict(
-    type='OptimWrapper',
-    optimizer=optimizer,
-    paramwise_cfg=dict(
-        custom_keys={
-            'pos_embed': dict(decay_mult=0.),
-            'cls_token': dict(decay_mult=0.),
-            'norm': dict(decay_mult=0.)
-        }))
-```
-
-Here, `decay_mult` refers to the weight decay coefficient for the corresponding parameters. For more information on the usage of `paramwise_cfg`, please refer to the [MMEngine optimizer wrapper documentation](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/optim_wrapper.md).
-
-### Optimizer Wrapper Constructor
-
-The default optimizer wrapper constructor [`DefaultOptimWrapperConstructor`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py#L19) builds the optimizer used in training based on the input `optim_wrapper` and `paramwise_cfg` defined in the `optim_wrapper`. When the functionality of [`DefaultOptimWrapperConstructor`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py#L19) does not meet the requirements, you can customize the optimizer wrapper constructor to implement the configuration of hyperparameters.
-
-MMSegmentation has implemented the [`LearningRateDecayOptimizerConstructor`](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/engine/optimizers/layer_decay_optimizer_constructor.py#L104), which can decay the learning rate of model parameters in the backbone networks of ConvNeXt, BEiT, and MAE models during training according to the defined decay ratio (`decay_rate`). The configuration in the configuration file is as follows:
-
-```python
-optim_wrapper = dict(
-    _delete_=True,
-    type='AmpOptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.05),
-    paramwise_cfg={
-        'decay_rate': 0.9,
-        'decay_type': 'stage_wise',
-        'num_layers': 12
-    },
-    constructor='LearningRateDecayOptimizerConstructor',
-    loss_scale='dynamic')
-```
-
-The purpose of `_delete_=True` is to ignore the inherited configuration in the OpenMMLab Config. In this code snippet, the inherited `optim_wrapper` configuration is ignored. For more information on `_delete_` fields, please refer to the [MMEngine documentation](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/config.md#delete-key-in-dict).
diff --git a/mmsegmentation/docs/en/advanced_guides/evaluation.md b/mmsegmentation/docs/en/advanced_guides/evaluation.md
deleted file mode 100644
index ca0beee..0000000
--- a/mmsegmentation/docs/en/advanced_guides/evaluation.md
+++ /dev/null
@@ -1,155 +0,0 @@
-# Evaluation
-
-The evaluation procedure would be executed at [ValLoop](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py#L300) and [TestLoop](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py#L373), users can evaluate model performance during training or using the test script with simple settings in the configuration file. The `ValLoop` and `TestLoop` are properties of [Runner](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py#L59), they will be built the first time they are called. To build the `ValLoop` successfully, the `val_dataloader` and `val_evaluator` must be set when building `Runner` since `dataloader` and `evaluator` are required parameters, and the same goes for `TestLoop`. For more information about the Runner's design, please refer to the [documentation](https://github.com/open-mmlab/mmengine/blob/main/docs/en/design/runner.md) of [MMEngine](https://github.com/open-mmlab/mmengine).
-
-![test_step/val_step dataflow](https://user-images.githubusercontent.com/15952744/228828179-3269baa3-bebd-4c9a-9787-59e7d785fbcf.png)
-
-In MMSegmentation, we write the settings of dataloader and metrics in the config files of datasets and the configuration of the evaluation loop in the `schedule_x` config files by default.
-
-For example, in the ADE20K config file `configs/_base_/dataset/ade20k.py`, on lines 37 to 48, we configured the `val_dataloader`, on line 51, we select `IoUMetric` as the evaluator and set `mIoU` as the metric:
-
-```python
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='images/validation',
-            seg_map_path='annotations/validation'),
-        pipeline=test_pipeline))
-
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
-```
-
-To be able to evaluate the model during training, for example, we add the evaluation configuration to the file `configs/schedules/schedule_40k.py` on lines 15 to 16:
-
-```python
-train_cfg = dict(type='IterBasedTrainLoop', max_iters=40000, val_interval=4000)
-val_cfg = dict(type='ValLoop')
-```
-
-With the above two settings, MMSegmentation evaluates the **mIoU** metric of the model once every 4000 iterations during the training of 40K iterations.
-
-If we would like to test the model after training, we need to add the `test_dataloader`, `test_evaluator` and `test_cfg` configs to the config file.
-
-```python
-test_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='images/validation',
-            seg_map_path='annotations/validation'),
-        pipeline=test_pipeline))
-
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
-test_cfg = dict(type='TestLoop')
-```
-
-In MMSegmentation, the settings of `test_dataloader` and `test_evaluator` are the same as the `ValLoop`'s dataloader and evaluator by default, we can modify these settings to meet our needs.
-
-## IoUMetric
-
-MMSegmentation implements [IoUMetric](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/evaluation/metrics/iou_metric.py) and [CityscapesMetric](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/evaluation/metrics/citys_metric.py) for evaluating the performance of models, based on the [BaseMetric](https://github.com/open-mmlab/mmengine/blob/main/mmengine/evaluator/metric.py) provided by [MMEngine](https://github.com/open-mmlab/mmengine). Please refer to [the documentation](https://mmengine.readthedocs.io/en/latest/tutorials/evaluation.html) for more details about the unified evaluation interface.
-
-Here we briefly describe the arguments and the two main methods of `IoUMetric`.
-
-The constructor of `IoUMetric` has some additional parameters besides the base `collect_device` and `prefix`.
-
-The arguments of the constructor:
-
-- ignore_index (int) - Index that will be ignored in evaluation. Default: 255.
-- iou_metrics (list\[str\] | str) - Metrics to be calculated, the options includes 'mIoU', 'mDice' and 'mFscore'.
-- nan_to_num (int, optional) - If specified, NaN values will be replaced by the numbers defined by the user. Default: None.
-- beta (int) - Determines the weight of recall in the combined score. Default: 1.
-- collect_device (str) - Device name used for collecting results from different ranks during distributed training. Must be 'cpu' or 'gpu'. Defaults to 'cpu'.
-- prefix (str, optional) - The prefix that will be added in the metric names to disambiguate homonymous metrics of different evaluators. If the prefix is not provided in the argument, self.default_prefix will be used instead. Defaults to None.
-
-`IoUMetric` implements the IoU metric calculation, the core two methods of `IoUMetric` are `process` and `compute_metrics`.
-
-- `process` method processes one batch of data and data_samples.
-- `compute_metrics` method computes the metrics from processed results.
-
-### IoUMetric.process
-
-Parameters:
-
-- data_batch (Any) - A batch of data from the dataloader.
-- data_samples (Sequence\[dict\]) - A batch of outputs from the model.
-
-Returns:
-
-This method doesn't have returns since the processed results would be stored in `self.results`, which will be used to compute the metrics when all batches have been processed.
-
-### IoUMetric.compute_metrics
-
-Parameters:
-
-- results (list) - The processed results of each batch.
-
-Returns:
-
-- Dict\[str, float\] - The computed metrics. The keys are the names of the metrics, and the values are corresponding results. The key mainly includes **aAcc**, **mIoU**, **mAcc**, **mDice**, **mFscore**, **mPrecision**, **mRecall**.
-
-## CityscapesMetric
-
-`CityscapesMetric` uses the official [CityscapesScripts](https://github.com/mcordts/cityscapesScripts) provided by Cityscapes to evaluate model performance.
-
-### Usage
-
-Before using it, please install the `cityscapesscripts` package first:
-
-```shell
-pip install cityscapesscripts
-```
-
-Since the `IoUMetric` is used as the default evaluator in MMSegmentation, if you would like to use `CityscapesMetric`, customizing the config file is required. In your customized config file, you should overwrite the default evaluator as follows.
-
-```python
-val_evaluator = dict(type='CityscapesMetric', output_dir='tmp')
-test_evaluator = val_evaluator
-```
-
-### Interface
-
-The arguments of the constructor:
-
-- output_dir (str) - The directory for output prediction
-- ignore_index (int) - Index that will be ignored in evaluation. Default: 255.
-- format_only (bool) - Only format result for results commit without perform evaluation. It is useful when you want to format the result to a specific format and submit it to the test server. Defaults to False.
-- keep_results (bool) - Whether to keep the results. When `format_only` is True, `keep_results` must be True. Defaults to False.
-- collect_device (str) - Device name used for collecting results from different ranks during distributed training. Must be 'cpu' or 'gpu'. Defaults to 'cpu'.
-- prefix (str, optional) - The prefix that will be added in the metric names to disambiguate homonymous metrics of different evaluators. If prefix is not provided in the argument, self.default_prefix will be used instead. Defaults to None.
-
-#### CityscapesMetric.process
-
-This method would draw the masks on images and save the painted images to `work_dir`.
-
-Parameters:
-
-- data_batch (dict) - A batch of data from the dataloader.
-- data_samples (Sequence\[dict\]) - A batch of outputs from the model.
-
-Returns:
-
-This method doesn't have returns, the annotations' path would be stored in `self.results`, which will be used to compute the metrics when all batches have been processed.
-
-#### CityscapesMetric.compute_metrics
-
-This method would call `cityscapesscripts.evaluation.evalPixelLevelSemanticLabeling` tool to calculate metrics.
-
-Parameters:
-
-- results (list) - Testing results of the dataset.
-
-Returns:
-
-- dict\[str: float\] - Cityscapes evaluation results.
diff --git a/mmsegmentation/docs/en/advanced_guides/index.rst b/mmsegmentation/docs/en/advanced_guides/index.rst
deleted file mode 100644
index 53ef8c5..0000000
--- a/mmsegmentation/docs/en/advanced_guides/index.rst
+++ /dev/null
@@ -1,26 +0,0 @@
-Basic Concepts
-***************
-
-.. toctree::
-   :maxdepth: 1
-
-   data_flow.md
-   structures.md
-   models.md
-   datasets.md
-   transforms.md
-   evaluation.md
-   engine.md
-   training_tricks.md
-
-Component Customization
-************************
-
-.. toctree::
-   :maxdepth: 1
-
-   add_models.md
-   add_datasets.md
-   add_transforms.md
-   add_metrics.md
-   customize_runtime.md
diff --git a/mmsegmentation/docs/en/advanced_guides/models.md b/mmsegmentation/docs/en/advanced_guides/models.md
deleted file mode 100644
index b008986..0000000
--- a/mmsegmentation/docs/en/advanced_guides/models.md
+++ /dev/null
@@ -1,164 +0,0 @@
-# Models
-
-We usually define a neural network in a deep learning task as a model, and this model is the core of an algorithm. [MMEngine](https://github.com/open-mmlab/mmengine) abstracts a unified model [BaseModel](https://github.com/open-mmlab/mmengine/blob/main/mmengine/model/base_model/base_model.py#L16) to standardize the interfaces for training, testing and other processes. All models implemented by MMSegmentation inherit from `BaseModel`, and in MMSegmentation we implemented forward and added some functions for the semantic segmentation algorithm.
-
-## Common components
-
-### Segmentor
-
-In MMSegmentation, we abstract the network architecture as a **Segmentor**, it is a model that contains all components of a network. We have already implemented **EncoderDecoder** and **CascadeEncoderDecoder**, which typically consist of **Data preprocessor**, **Backbone**, **Decode head** and **Auxiliary head**.
-
-### Data preprocessor
-
-**Data preprocessor** is the part that copies data to the target device and preprocesses the data into the model input format.
-
-### Backbone
-
-**Backbone** is the part that transforms an image to feature maps, such as a **ResNet-50** without the last fully connected layer.
-
-### Neck
-
-**Neck** is the part that connects the backbone and heads. It performs some refinements or reconfigurations on the raw feature maps produced by the backbone. An example is **Feature Pyramid Network (FPN)**.
-
-### Decode head
-
-**Decode head** is the part that transforms the feature maps into a segmentation mask, such as **PSPNet**.
-
-### Auxiliary head
-
-**Auxiliary head** is an optional component that transforms the feature maps into segmentation masks which only used for computing auxiliary losses.
-
-## Basic interfaces
-
-MMSegmentation wraps `BaseModel` and implements the [BaseSegmentor](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/models/segmentors/base.py#L15) class, which mainly provides the interfaces `forward`, `train_step`, `val_step` and `test_step`. The following will introduce these interfaces in detail.
-
-### forward
-
-![EncoderDecoder dataflow](https://user-images.githubusercontent.com/15952744/228827860-c0e34875-d370-4736-84f0-9560c26c9576.png)
-![CascadeEncoderDecoder dataflow](https://user-images.githubusercontent.com/15952744/228827987-aa214507-0c6d-4a08-8ce4-679b2b200b79.png)
-
-The `forward` method returns losses or predictions of training, validation, testing, and a simple inference process.
-
-The method should accept three modes: "tensor", "predict" and "loss":
-
-- "tensor": Forward the whole network and return the tensor or tuple of tensor without any post-processing, same as a common `nn.Module`.
-- "predict": Forward and return the predictions, which are fully processed to a list of `SegDataSample`.
-- "loss": Forward and return a `dict` of losses according to the given inputs and data samples.
-
-**Note:** [SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py) is a data structure interface of MMSegmentation, it is used as an interface between different components. `SegDataSample` implements the abstract data element `mmengine.structures.BaseDataElement`, please refer to [the SegDataSample documentation](https://mmsegmentation.readthedocs.io/en/1.x/advanced_guides/structures.html) and [data element documentation](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/data_element.html) in [MMEngine](https://github.com/open-mmlab/mmengine) for more information.
-
-Note that this method doesn't handle either backpropagation or optimizer updating, which are done in the method `train_step`.
-
-Parameters:
-
-- inputs (torch.Tensor) - The input tensor with shape (N, C, ...) in general.
-- data_sample (list\[[SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py)\]) - The seg data samples. It usually includes information such as `metainfo` and `gt_sem_seg`. Default to None.
-- mode (str) - Return what kind of value. Defaults to 'tensor'.
-
-Returns:
-
-- `dict` or `list`:
-  - If `mode == "loss"`, return a `dict` of loss tensor used for backward and logging.
-  - If `mode == "predict"`, return a `list` of `SegDataSample`, the inference results will be incrementally added to the `data_sample` parameter passed to the forward method, each `SegDataSample` contains the following keys:
-    - pred_sem_seg (`PixelData`): Prediction of semantic segmentation.
-    - seg_logits (`PixelData`): Predicted logits of semantic segmentation before normalization.
-  - If `mode == "tensor"`, return a `tensor` or `tuple of tensor` or `dict` of `tensor` for custom use.
-
-### prediction modes
-
-We briefly describe the fields of the model's configuration in [the config documentation](../user_guides/1_config.md), here we elaborate on the `model.test_cfg` field. `model.test_cfg` is used to control forward behavior, the `forward` method in `"predict"` mode can run in two modes:
-
-- `whole_inference`: If `cfg.model.test_cfg.mode == 'whole'`, model will inference with full images.
-
-  An `whole_inference` mode example config:
-
-  ```python
-  model = dict(
-    type='EncoderDecoder'
-    ...
-    test_cfg=dict(mode='whole')
-  )
-  ```
-
-- `slide_inference`: If `cfg.model.test_cfg.mode == 'slide'`, model will inference by sliding-window. **Note:** if you select the `slide` mode, `cfg.model.test_cfg.stride` and `cfg.model.test_cfg.crop_size` should also be specified.
-
-  An `slide_inference` mode example config:
-
-  ```python
-  model = dict(
-    type='EncoderDecoder'
-    ...
-    test_cfg=dict(mode='slide', crop_size=256, stride=170)
-  )
-  ```
-
-### train_step
-
-The `train_step` method calls the forward interface of the `loss` mode to get the loss `dict`. The `BaseModel` class implements the default model training process including preprocessing, model forward propagation, loss calculation, optimization, and back-propagation.
-
-Parameters:
-
-- data (dict or tuple or list) - Data sampled from the dataset. In MMSegmentation, the data dict contains `inputs` and `data_samples` two fields.
-- optim_wrapper (OptimWrapper) - OptimWrapper instance used to update model parameters.
-
-**Note:** [OptimWrapper](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/optimizer_wrapper.py#L17) provides a common interface for updating parameters, please refer to optimizer wrapper [documentation](https://mmengine.readthedocs.io/en/latest/tutorials/optim_wrapper.html) in [MMEngine](https://github.com/open-mmlab/mmengine) for more information.
-
-Returns:
-
-- Dict\[str, `torch.Tensor`\]: A `dict` of tensor for logging.
-
-![train_step dataflow](https://user-images.githubusercontent.com/15952744/228828089-a9ae1225-958d-4cf7-99af-9af8576f7ef7.png)
-
-### val_step
-
-The `val_step` method calls the forward interface of the `predict` mode and returns the prediction result, which is further passed to the process interface of the evaluator and the `after_val_iter` interface of the Hook.
-
-Parameters:
-
-- data (`dict` or `tuple` or `list`) - Data sampled from the dataset. In MMSegmentation, the data dict contains `inputs` and `data_samples` two fields.
-
-Returns:
-
-- `list` - The predictions of given data.
-
-![test_step/val_step dataflow](https://user-images.githubusercontent.com/15952744/228828179-3269baa3-bebd-4c9a-9787-59e7d785fbcf.png)
-
-### test_step
-
-The `BaseModel` implements `test_step` the same as `val_step`.
-
-## Data Preprocessor
-
-The [SegDataPreProcessor](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/models/data_preprocessor.py#L13) implemented by MMSegmentation inherits from the [BaseDataPreprocessor](https://github.com/open-mmlab/mmengine/blob/main/mmengine/model/base_model/data_preprocessor.py#L18) implemented by [MMEngine](https://github.com/open-mmlab/mmengine) and provides the functions of data preprocessing and copying data to the target device.
-
-The runner carries the model to the specified device during the construction stage, while the data is carried to the specified device by the [SegDataPreProcessor](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/models/data_preprocessor.py#L13) in `train_step`, `val_step`, and `test_step`, and the processed data is further passed to the model.
-
-The parameters of the `SegDataPreProcessor` constructor:
-
-- mean (Sequence\[Number\], optional) - The pixel mean of R, G, B channels. Defaults to None.
-- std (Sequence\[Number\], optional) - The pixel standard deviation of R, G, B channels. Defaults to None.
-- size (tuple, optional) - Fixed padding size.
-- size_divisor (int, optional) - The divisor of padded size.
-- pad_val (float, optional) - Padding value. Default: 0.
-- seg_pad_val (float, optional) - Padding value of segmentation map. Default: 255.
-- bgr_to_rgb (bool) - whether to convert image from BGR to RGB. Defaults to False.
-- rgb_to_bgr (bool) - whether to convert image from RGB to BGR. Defaults to False.
-- batch_augments (list\[dict\], optional) - Batch-level augmentations. Default to None.
-
-The data will be processed as follows:
-
-- Collate and move data to the target device.
-- Pad inputs to the input size with defined `pad_val`, and pad seg map with defined `seg_pad_val`.
-- Stack inputs to batch_inputs.
-- Convert inputs from bgr to rgb if the shape of input is (3, H, W).
-- Normalize image with defined std and mean.
-- Do batch augmentations like Mixup and Cutmix during training.
-
-The parameters of the `forward` method:
-
-- data (dict) - data sampled from dataloader.
-- training (bool) - Whether to enable training time augmentation.
-
-The returns of the `forward` method:
-
-- Dict: Data in the same format as the model input.
diff --git a/mmsegmentation/docs/en/advanced_guides/structures.md b/mmsegmentation/docs/en/advanced_guides/structures.md
deleted file mode 100644
index 2607242..0000000
--- a/mmsegmentation/docs/en/advanced_guides/structures.md
+++ /dev/null
@@ -1,104 +0,0 @@
-# Structures
-
-To unify input and output interfaces  between different models and modules, OpenMMLab 2.0 MMEngine defines an abstract data structure,
-it has implemented basic functions of `Create`, `Read`, `Update`, `Delete`, supported data transferring among different types of devices
-and tensor-like or dictionary-like operations such as `.cpu()`, `.cuda()`, `.get()` and `.detach()`.
-More details can be found [here](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/data_element.md).
-
-MMSegmentation also follows this interface protocol and defines `SegDataSample` which is used to encapsulate the data of semantic segmentation task.
-
-## Semantic Segmentation Data SegDataSample
-
-[SegDataSample](mmseg.structures.SegDataSample) includes three main fields `gt_sem_seg`, `pred_sem_seg` and `seg_logits`, which are used to store the annotation information and prediction results respectively.
-
-| Field          | Type                      | Description                                |
-| -------------- | ------------------------- | ------------------------------------------ |
-| gt_sem_seg     | [`PixelData`](#pixeldata) | Annotation information.                    |
-| pred_instances | [`PixelData`](#pixeldata) | The predicted result.                      |
-| seg_logits     | [`PixelData`](#pixeldata) | The raw (non-normalized) predicted result. |
-
-The following sample code demonstrates the use of `SegDataSample`.
-
-```python
-import torch
-from mmengine.structures import PixelData
-from mmseg.structures import SegDataSample
-
-img_meta = dict(img_shape=(4, 4, 3),
-                 pad_shape=(4, 4, 3))
-data_sample = SegDataSample()
-# defining gt_segmentations for encapsulate the ground truth data
-gt_segmentations = PixelData(metainfo=img_meta)
-gt_segmentations.data = torch.randint(0, 2, (1, 4, 4))
-
-# add and process property in SegDataSample
-data_sample.gt_sem_seg = gt_segmentations
-assert 'gt_sem_seg' in data_sample
-assert 'sem_seg' in data_sample.gt_sem_seg
-assert 'img_shape' in data_sample.gt_sem_seg.metainfo_keys()
-print(data_sample.gt_sem_seg.shape)
-'''
-(4, 4)
-'''
-print(data_sample)
-'''
-<SegDataSample(
-
-    META INFORMATION
-
-    DATA FIELDS
-    gt_sem_seg: <PixelData(
-
-            META INFORMATION
-            img_shape: (4, 4, 3)
-            pad_shape: (4, 4, 3)
-
-            DATA FIELDS
-            data: tensor([[[1, 1, 1, 0],
-                         [1, 0, 1, 1],
-                         [1, 1, 1, 1],
-                         [0, 1, 0, 1]]])
-        ) at 0x1c2b4156460>
-) at 0x1c2aae44d60>
-'''
-
-# delete and change property in SegDataSample
-data_sample = SegDataSample()
-gt_segmentations = PixelData(metainfo=img_meta)
-gt_segmentations.data = torch.randint(0, 2, (1, 4, 4))
-data_sample.gt_sem_seg = gt_segmentations
-data_sample.gt_sem_seg.set_metainfo(dict(img_shape=(4,4,9), pad_shape=(4,4,9)))
-del data_sample.gt_sem_seg.img_shape
-
-# Tensor-like operations
-data_sample = SegDataSample()
-gt_segmentations = PixelData(metainfo=img_meta)
-gt_segmentations.data = torch.randint(0, 2, (1, 4, 4))
-cuda_gt_segmentations = gt_segmentations.cuda()
-cuda_gt_segmentations = gt_segmentations.to('cuda:0')
-cpu_gt_segmentations = cuda_gt_segmentations.cpu()
-cpu_gt_segmentations = cuda_gt_segmentations.to('cpu')
-```
-
-## Customize New Property in SegDataSample
-
-If you want to customize new property in `SegDataSample`, you may follow [SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py) below:
-
-```python
-class SegDataSample(BaseDataElement):
-    ...
-
-    @property
-    def xxx_property(self) -> xxxData:
-        return self._xxx_property
-
-    @xxx_property.setter
-    def xxx_property(self, value: xxxData) -> None:
-        self.set_field(value, '_xxx_property', dtype=xxxData)
-
-    @xxx_property.deleter
-    def xxx_property(self) -> None:
-        del self._xxx_property
-```
-
-Then a new property would be added to `SegDataSample`.
diff --git a/mmsegmentation/docs/en/advanced_guides/training_tricks.md b/mmsegmentation/docs/en/advanced_guides/training_tricks.md
deleted file mode 100644
index bc4f722..0000000
--- a/mmsegmentation/docs/en/advanced_guides/training_tricks.md
+++ /dev/null
@@ -1,75 +0,0 @@
-# Training Tricks
-
-MMSegmentation support following training tricks out of box.
-
-## Different Learning Rate(LR) for Backbone and Heads
-
-In semantic segmentation, some methods make the LR of heads larger than backbone to achieve better performance or faster convergence.
-
-In MMSegmentation, you may add following lines to config to make the LR of heads 10 times of backbone.
-
-```python
-optim_wrapper=dict(
-    paramwise_cfg = dict(
-        custom_keys={
-            'head': dict(lr_mult=10.)}))
-```
-
-With this modification, the LR of any parameter group with `'head'` in name will be multiplied by 10.
-You may refer to [MMEngine documentation](https://mmengine.readthedocs.io/en/latest/tutorials/optim_wrapper.html#advanced-usages) for further details.
-
-## Online Hard Example Mining (OHEM)
-
-We implement pixel sampler for training sampling, like OHEM (Online Hard Example Mining),
-which is used for remove the "easy" examples for model training.
-Here is an example config of training PSPNet with OHEM enabled.
-
-```python
-_base_ = './pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-model=dict(
-    decode_head=dict(
-        sampler=dict(type='OHEMPixelSampler', thresh=0.7, min_kept=100000)) )
-```
-
-In this way, only pixels with confidence score under 0.7 are used to train. And we keep at least 100000 pixels during training. If `thresh` is not specified, pixels of top `min_kept` loss will be selected.
-
-## Class Balanced Loss
-
-For dataset that is not balanced in classes distribution, you may change the loss weight of each class.
-Here is an example for cityscapes dataset.
-
-```python
-_base_ = './pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-model=dict(
-    decode_head=dict(
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0,
-            # DeepLab used this class weight for cityscapes
-            class_weight=[0.8373, 0.9180, 0.8660, 1.0345, 1.0166, 0.9969, 0.9754,
-                        1.0489, 0.8786, 1.0023, 0.9539, 0.9843, 1.1116, 0.9037,
-                        1.0865, 1.0955, 1.0865, 1.1529, 1.0507])))
-```
-
-`class_weight` will be passed into `CrossEntropyLoss` as `weight` argument. Please refer to [PyTorch Doc](https://pytorch.org/docs/stable/nn.html?highlight=crossentropy#torch.nn.CrossEntropyLoss) for details.
-
-## Multiple Losses
-
-For loss calculation, we support multiple losses training concurrently. Here is an example config of training `unet` on `DRIVE` dataset, whose loss function is `1:3` weighted sum of `CrossEntropyLoss` and `DiceLoss`:
-
-```python
-_base_ = './fcn_unet_s5-d16_64x64_40k_drive.py'
-model = dict(
-    decode_head=dict(loss_decode=[
-        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
-        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
-    ]),
-    auxiliary_head=dict(loss_decode=[
-        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
-        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
-    ]),
-)
-```
-
-In this way, `loss_weight` and `loss_name` will be weight and name in training log of corresponding loss, respectively.
-
-Note: If you want this loss item to be included into the backward graph, `loss_` must be the prefix of the name.
diff --git a/mmsegmentation/docs/en/advanced_guides/transforms.md b/mmsegmentation/docs/en/advanced_guides/transforms.md
deleted file mode 100644
index 68b1f44..0000000
--- a/mmsegmentation/docs/en/advanced_guides/transforms.md
+++ /dev/null
@@ -1,119 +0,0 @@
-# Data Transforms
-
-In this tutorial, we introduce the design of transforms pipeline in MMSegmentation.
-
-The structure of this guide is as follows:
-
-- [Data Transforms](#data-transforms)
-  - [Design of Data pipelines](#design-of-data-pipelines)
-    - [Data loading](#data-loading)
-    - [Pre-processing](#pre-processing)
-    - [Formatting](#formatting)
-
-## Design of Data pipelines
-
-Following typical conventions, we use `Dataset` and `DataLoader` for data loading with multiple workers. `Dataset` returns a dict of data items corresponding the arguments of models' forward method. Since the data in semantic segmentation may not be the same size, we introduce a new `DataContainer` type in MMCV to help collect and distribute data of different size. See [here](https://github.com/open-mmlab/mmcv/blob/master/mmcv/parallel/data_container.py) for more details.
-
-In 1.x version of MMSegmentation, all data transformations are inherited from [`BaseTransform`](https://github.com/open-mmlab/mmcv/blob/2.x/mmcv/transforms/base.py#L6).
-
-The input and output types of transformations are both dict. A simple example is as follows:
-
-```python
->>> from mmseg.datasets.transforms import LoadAnnotations
->>> transforms = LoadAnnotations()
->>> img_path = './data/cityscapes/leftImg8bit/train/aachen/aachen_000000_000019_leftImg8bit.png.png'
->>> gt_path = './data/cityscapes/gtFine/train/aachen/aachen_000015_000019_gtFine_instanceTrainIds.png'
->>> results = dict(
->>>     img_path=img_path,
->>>     seg_map_path=gt_path,
->>>     reduce_zero_label=False,
->>>     seg_fields=[])
->>> data_dict = transforms(results)
->>> print(data_dict.keys())
-dict_keys(['img_path', 'seg_map_path', 'reduce_zero_label', 'seg_fields', 'gt_seg_map'])
-```
-
-The data preparation pipeline and the dataset are decomposed. Usually a dataset defines how to process the annotations and a data pipeline defines all the steps to prepare a data dict. A pipeline consists of a sequence of operations. Each operation takes a dict as input and also outputs a dict for the next transform.
-
-The operations are categorized into data loading, pre-processing, formatting and test-time augmentation.
-
-Here is a pipeline example for PSPNet:
-
-```python
-crop_size = (512, 1024)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(
-        type='RandomResize',
-        scale=(2048, 1024),
-        ratio_range=(0.5, 2.0),
-        keep_ratio=True),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to resize data transform
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-```
-
-For each operation, we list the related dict fields that are `added`/`updated`/`removed`. Before pipelines, the information we can directly obtain from the datasets are `img_path` and `seg_map_path`.
-
-### Data loading
-
-`LoadImageFromFile`: Load an image from file.
-
-- add: `img`, `img_shape`, `ori_shape`
-
-`LoadAnnotations`: Load semantic segmentation maps provided by dataset.
-
-- add: `seg_fields`, `gt_seg_map`
-
-### Pre-processing
-
-`RandomResize`: Random resize image & segmentation map.
-
-- add: `scale`, `scale_factor`, `keep_ratio`
-- update: `img`, `img_shape`, `gt_seg_map`
-
-`Resize`: Resize image & segmentation map.
-
-- add: `scale`, `scale_factor`, `keep_ratio`
-- update: `img`, `gt_seg_map`, `img_shape`
-
-`RandomCrop`: Random crop image & segmentation map.
-
-- update: `img`, `gt_seg_map`, `img_shape`
-
-`RandomFlip`: Flip the image & segmentation map.
-
-- add: `flip`, `flip_direction`
-- update: `img`, `gt_seg_map`
-
-`PhotoMetricDistortion`: Apply photometric distortion to image sequentially, every transformation is applied with a probability of 0.5. The position of random contrast is in second or second to last(mode 0 or 1 below, respectively).
-
-```
-1. random brightness
-2. random contrast (mode 0)
-3. convert color from BGR to HSV
-4. random saturation
-5. random hue
-6. convert color from HSV to BGR
-7. random contrast (mode 1)
-```
-
-- update: `img`
-
-### Formatting
-
-`PackSegInputs`: Pack the inputs data for the semantic segmentation.
-
-- add: `inputs`, `data_sample`
-- remove: keys specified by `meta_keys` (merged into the metainfo of data_sample), all other keys
diff --git a/mmsegmentation/docs/en/api.rst b/mmsegmentation/docs/en/api.rst
deleted file mode 100644
index 2f1a25e..0000000
--- a/mmsegmentation/docs/en/api.rst
+++ /dev/null
@@ -1,95 +0,0 @@
-mmseg.apis
---------------
-.. automodule:: mmseg.apis
-    :members:
-
-mmseg.datasets
---------------
-
-datasets
-^^^^^^^^^^
-.. automodule:: mmseg.datasets
-    :members:
-
-transforms
-^^^^^^^^^^^^
-.. automodule:: mmseg.datasets.transforms
-    :members:
-
-mmseg.engine
---------------
-
-hooks
-^^^^^^^^^^
-.. automodule:: mmseg.engine.hooks
-    :members:
-
-optimizers
-^^^^^^^^^^^^^^^
-.. automodule:: mmseg.engine.optimizers
-    :members:
-
-mmseg.evaluation
------------------
-
-metrics
-^^^^^^^^^^
-.. automodule:: mmseg.evaluation.metrics
-    :members:
-
-mmseg.models
---------------
-
-backbones
-^^^^^^^^^^^^^^^^^^
-.. automodule:: mmseg.models.backbones
-    :members:
-
-decode_heads
-^^^^^^^^^^^^^^^
-.. automodule:: mmseg.models.decode_heads
-    :members:
-
-segmentors
-^^^^^^^^^^
-.. automodule:: mmseg.models.segmentors
-    :members:
-
-losses
-^^^^^^^^^^
-.. automodule:: mmseg.models.losses
-    :members:
-
-necks
-^^^^^^^^^^^^
-.. automodule:: mmseg.models.necks
-    :members:
-
-utils
-^^^^^^^^^^
-.. automodule:: mmseg.models.utils
-    :members:
-
-
-mmseg.structures
---------------------
-
-structures
-^^^^^^^^^^^^^^^^^
-.. automodule:: mmseg.structures
-    :members:
-
-sampler
-^^^^^^^^^^
-.. automodule:: mmseg.structures.sampler
-    :members:
-
-mmseg.visualization
---------------------
-.. automodule:: mmseg.visualization
-    :members:
-
-mmseg.utils
---------------
-.. automodule:: mmseg.utils
-    :members:
diff --git a/mmsegmentation/docs/en/conf.py b/mmsegmentation/docs/en/conf.py
deleted file mode 100644
index e20aab1..0000000
--- a/mmsegmentation/docs/en/conf.py
+++ /dev/null
@@ -1,133 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-# Configuration file for the Sphinx documentation builder.
-#
-# This file only contains a selection of the most common options. For a full
-# list see the documentation:
-# https://www.sphinx-doc.org/en/master/usage/configuration.html
-
-# -- Path setup --------------------------------------------------------------
-
-# If extensions (or modules to document with autodoc) are in another directory,
-# add these directories to sys.path here. If the directory is relative to the
-# documentation root, use os.path.abspath to make it absolute, like shown here.
-#
-import os
-import subprocess
-import sys
-
-import pytorch_sphinx_theme
-
-sys.path.insert(0, os.path.abspath('../../'))
-
-# -- Project information -----------------------------------------------------
-
-project = 'MMSegmentation'
-copyright = '2020-2021, OpenMMLab'
-author = 'MMSegmentation Authors'
-version_file = '../../mmseg/version.py'
-
-
-def get_version():
-    with open(version_file) as f:
-        exec(compile(f.read(), version_file, 'exec'))
-    return locals()['__version__']
-
-
-# The full version, including alpha/beta/rc tags
-release = get_version()
-
-# -- General configuration ---------------------------------------------------
-
-# Add any Sphinx extension module names here, as strings. They can be
-# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
-# ones.
-extensions = [
-    'sphinx.ext.autodoc', 'sphinx.ext.napoleon', 'sphinx.ext.viewcode',
-    'sphinx_markdown_tables', 'sphinx_copybutton', 'myst_parser'
-]
-
-autodoc_mock_imports = [
-    'matplotlib', 'pycocotools', 'mmseg.version', 'mmcv.ops'
-]
-
-# Ignore >>> when copying code
-copybutton_prompt_text = r'>>> |\.\.\. '
-copybutton_prompt_is_regexp = True
-
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
-
-# The suffix(es) of source filenames.
-# You can specify multiple suffix as a list of string:
-#
-source_suffix = {
-    '.rst': 'restructuredtext',
-    '.md': 'markdown',
-}
-
-# The master toctree document.
-master_doc = 'index'
-
-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-# This pattern also affects html_static_path and html_extra_path.
-exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
-
-# -- Options for HTML output -------------------------------------------------
-
-# The theme to use for HTML and HTML Help pages.  See the documentation for
-# a list of builtin themes.
-#
-# html_theme = 'sphinx_rtd_theme'
-html_theme = 'pytorch_sphinx_theme'
-html_theme_path = [pytorch_sphinx_theme.get_html_theme_path()]
-html_theme_options = {
-    'logo_url':
-    'https://mmsegmentation.readthedocs.io/en/latest/',
-    'menu': [
-        {
-            'name':
-            'Tutorial',
-            'url':
-            'https://github.com/open-mmlab/mmsegmentation/blob/master/'
-            'demo/MMSegmentation_Tutorial.ipynb'
-        },
-        {
-            'name': 'GitHub',
-            'url': 'https://github.com/open-mmlab/mmsegmentation'
-        },
-        {
-            'name':
-            'Upstream',
-            'children': [
-                {
-                    'name': 'MMCV',
-                    'url': 'https://github.com/open-mmlab/mmcv',
-                    'description': 'Foundational library for computer vision'
-                },
-            ]
-        },
-    ],
-    # Specify the language of shared menu
-    'menu_lang':
-    'en'
-}
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
-html_css_files = ['css/readthedocs.css']
-
-# Enable ::: for my_st
-myst_enable_extensions = ['colon_fence']
-
-language = 'en'
-
-
-def builder_inited_handler(app):
-    subprocess.run(['./stat.py'])
-
-
-def setup(app):
-    app.connect('builder-inited', builder_inited_handler)
diff --git a/mmsegmentation/docs/en/device/npu.md b/mmsegmentation/docs/en/device/npu.md
deleted file mode 100644
index a90d6ac..0000000
--- a/mmsegmentation/docs/en/device/npu.md
+++ /dev/null
@@ -1,39 +0,0 @@
-# NPU (HUAWEI Ascend)
-
-## Usage
-
-Please refer to the [building documentation of MMCV](https://mmcv.readthedocs.io/en/latest/get_started/build.html#build-mmcv-full-on-ascend-npu-machine) to install MMCV on NPU devices
-
-Here we use 4 NPUs on your computer to train the model with the following command:
-
-```shell
-bash tools/dist_train.sh configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py 4
-```
-
-Also, you can use only one NPU to train the model with the following command:
-
-```shell
-python tools/train.py configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py
-```
-
-## Models Results
-
-|        Model        | mIoU  | Config                                                                                                                                     | Download                                                                                                                                    |
-| :-----------------: | :---: | :----------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------ |
-|   [deeplabv3](<>)   | 78.85 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py)         | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024_20230115_205626.json)     |
-| [deeplabv3plus](<>) | 79.23 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024.py) | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024_20230116_043450.json) |
-|     [hrnet](<>)     | 78.1  | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/hrnet/fcn_hr18_4xb2-40k_cityscapes-512x1024.py)                     | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/fcn_hr18_4xb2-40k_cityscapes-512x1024_20230116_215821.json)             |
-|      [fcn](<>)      | 74.15 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py)                     | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/fcn_r50-d8_4xb2-40k_cityscapes-512x1024_20230111_083014.json)           |
-|     [icnet](<>)     | 69.25 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/icnet/icnet_r50-d8_4xb2-80k_cityscapes-832x832.py)                  | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/icnet_r50-d8_4xb2-80k_cityscapes-832x832_20230119_002929.json)          |
-|    [pspnet](<>)     | 77.21 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024.py)              | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024_20230114_042721.json)       |
-|     [unet](<>)      | 68.86 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/unet/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py)              | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024_20230129_224750.json)     |
-|    [upernet](<>)    | 77.81 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/upernet/upernet_r50_4xb2-40k_cityscapes-512x1024.py)                | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/upernet_r50_4xb2-40k_cityscapes-512x1024_20230129_014634.json)          |
-|    [apcnet](<>)     | 78.02 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py)               | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/apcnet_r50-d8_4xb2-40k_cityscapes-512x1024_20230209_212545.json)        |
-|   [bisenetv1](<>)   | 76.04 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024.py)      | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024_20230201_023946.json)  |
-|   [bisenetv2](<>)   | 72.44 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/bisenetv2/bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024.py)      | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024_20230205_215606.json)  |
-
-**Notes:**
-
-- If not specially marked, the results on NPU with amp are the basically same as those on the GPU with FP32.
-
-**All above models are provided by Huawei Ascend group.**
diff --git a/mmsegmentation/docs/en/get_started.md b/mmsegmentation/docs/en/get_started.md
deleted file mode 100644
index 3f957eb..0000000
--- a/mmsegmentation/docs/en/get_started.md
+++ /dev/null
@@ -1,211 +0,0 @@
-# Get started: Install and Run MMSeg
-
-## Prerequisites
-
-In this section we demonstrate how to prepare an environment with PyTorch.
-
-MMSegmentation works on Linux, Windows and macOS. It requires Python 3.7+, CUDA 10.2+ and PyTorch 1.8+.
-
-**Note:**
-If you are experienced with PyTorch and have already installed it, just skip this part and jump to the [next section](##installation). Otherwise, you can follow these steps for the preparation.
-
-**Step 0.** Download and install Miniconda from the [official website](https://docs.conda.io/en/latest/miniconda.html).
-
-**Step 1.** Create a conda environment and activate it.
-
-```shell
-conda create --name openmmlab python=3.8 -y
-conda activate openmmlab
-```
-
-**Step 2.** Install PyTorch following [official instructions](https://pytorch.org/get-started/locally/), e.g.
-
-On GPU platforms:
-
-```shell
-conda install pytorch torchvision -c pytorch
-```
-
-On CPU platforms:
-
-```shell
-conda install pytorch torchvision cpuonly -c pytorch
-```
-
-## Installation
-
-We recommend that users follow our best practices to install MMSegmentation. However, the whole process is highly customizable. See [Customize Installation](#customize-installation) section for more information.
-
-### Best Practices
-
-**Step 0.** Install [MMCV](https://github.com/open-mmlab/mmcv) using [MIM](https://github.com/open-mmlab/mim).
-
-```shell
-pip install -U openmim
-mim install mmengine
-mim install "mmcv>=2.0.0"
-```
-
-**Step 1.** Install MMSegmentation.
-
-Case a: If you develop and run mmseg directly, install it from source:
-
-```shell
-git clone -b main https://github.com/open-mmlab/mmsegmentation.git
-cd mmsegmentation
-pip install -v -e .
-# '-v' means verbose, or more output
-# '-e' means installing a project in editable mode,
-# thus any local modifications made to the code will take effect without reinstallation.
-```
-
-Case b: If you use mmsegmentation as a dependency or third-party package, install it with pip:
-
-```shell
-pip install "mmsegmentation>=1.0.0"
-```
-
-### Verify the installation
-
-To verify whether MMSegmentation is installed correctly, we provide some sample codes to run an inference demo.
-
-**Step 1.** We need to download config and checkpoint files.
-
-```shell
-mim download mmsegmentation --config pspnet_r50-d8_4xb2-40k_cityscapes-512x1024 --dest .
-```
-
-The downloading will take several seconds or more, depending on your network environment. When it is done, you will find two files `pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py` and `pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth` in your current folder.
-
-**Step 2.** Verify the inference demo.
-
-Option (a). If you install mmsegmentation from source, just run the following command.
-
-```shell
-python demo/image_demo.py demo/demo.png configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth --device cuda:0 --out-file result.jpg
-```
-
-You will see a new image `result.jpg` on your current folder, where segmentation masks are covered on all objects.
-
-Option (b). If you install mmsegmentation with pip, open you python interpreter and copy&paste the following codes.
-
-```python
-from mmseg.apis import inference_model, init_model, show_result_pyplot
-import mmcv
-
-config_file = 'pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-checkpoint_file = 'pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
-
-# build the model from a config file and a checkpoint file
-model = init_model(config_file, checkpoint_file, device='cuda:0')
-
-# test a single image and show the results
-img = 'demo/demo.png'  # or img = mmcv.imread(img), which will only load it once
-result = inference_model(model, img)
-# visualize the results in a new window
-show_result_pyplot(model, img, result, show=True)
-# or save the visualization results to image files
-# you can change the opacity of the painted segmentation map in (0, 1].
-show_result_pyplot(model, img, result, show=True, out_file='result.jpg', opacity=0.5)
-# test a video and show the results
-video = mmcv.VideoReader('video.mp4')
-for frame in video:
-   result = inference_model(model, frame)
-   show_result_pyplot(model, frame, result, wait_time=1)
-```
-
-You can modify the code above to test a single image or a video, both of these options can verify that the installation was successful.
-
-### Customize Installation
-
-#### CUDA versions
-
-When installing PyTorch, you need to specify the version of CUDA. If you are not clear on which to choose, follow our recommendations:
-
-- For Ampere-based NVIDIA GPUs, such as GeForce 30 series and NVIDIA A100, CUDA 11 is a must.
-- For older NVIDIA GPUs, CUDA 11 is backward compatible, but CUDA 10.2 offers better compatibility and is more lightweight.
-
-Please make sure the GPU driver satisfies the minimum version requirements. See [this table](https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html#cuda-major-component-versions__table-cuda-toolkit-driver-versions) for more information.
-
-**Note:**
-Installing CUDA runtime libraries is enough if you follow our best practices, because no CUDA code will be compiled locally. However if you hope to compile MMCV from source or develop other CUDA operators, you need to install the complete CUDA toolkit from NVIDIA's [website](https://developer.nvidia.com/cuda-downloads), and its version should match the CUDA version of PyTorch. i.e., the specified version of cudatoolkit in `conda install` command.
-
-#### Install MMCV without MIM
-
-MMCV contains C++ and CUDA extensions, thus depending on PyTorch in a complex way. MIM solves such dependencies automatically and makes the installation easier. However, it is not a must.
-
-To install MMCV with pip instead of MIM, please follow [MMCV installation guides](https://mmcv.readthedocs.io/en/latest/get_started/installation.html). This requires manually specifying a find-url based on PyTorch version and its CUDA version.
-
-For example, the following command install mmcv==2.0.0 built for PyTorch 1.10.x and CUDA 11.3.
-
-```shell
-pip install mmcv==2.0.0 -f https://download.openmmlab.com/mmcv/dist/cu113/torch1.10/index.html
-```
-
-#### Install on CPU-only platforms
-
-MMSegmentation can be built for CPU only environment. In CPU mode you can train (requires MMCV version >= 2.0.0), test or inference a model.
-
-#### Install on Google Colab
-
-[Google Colab](https://research.google.com/) usually has PyTorch installed,
-thus we only need to install MMCV and MMSegmentation with the following commands.
-
-**Step 1.** Install [MMCV](https://github.com/open-mmlab/mmcv) using [MIM](https://github.com/open-mmlab/mim).
-
-```shell
-!pip3 install openmim
-!mim install mmengine
-!mim install "mmcv>=2.0.0"
-```
-
-**Step 2.** Install MMSegmentation from the source.
-
-```shell
-!git clone https://github.com/open-mmlab/mmsegmentation.git
-%cd mmsegmentation
-!git checkout main
-!pip install -e .
-```
-
-**Step 3.** Verification.
-
-```python
-import mmseg
-print(mmseg.__version__)
-# Example output: 1.0.0
-```
-
-**Note:**
-Within Jupyter, the exclamation mark `!` is used to call external executables and `%cd` is a [magic command](https://ipython.readthedocs.io/en/stable/interactive/magics.html#magic-cd) to change the current working directory of Python.
-
-### Using MMSegmentation with Docker
-
-We provide a [Dockerfile](https://github.com/open-mmlab/mmsegmentation/blob/main/docker/Dockerfile) to build an image. Ensure that your [docker version](https://docs.docker.com/engine/install/) >=19.03.
-
-```shell
-# build an image with PyTorch 1.11, CUDA 11.3
-# If you prefer other versions, just modified the Dockerfile
-docker build -t mmsegmentation docker/
-```
-
-Run it with
-
-```shell
-docker run --gpus all --shm-size=8g -it -v {DATA_DIR}:/mmsegmentation/data mmsegmentation
-```
-
-### Optional Dependencies
-
-#### Install GDAL
-
-[GDAL](https://gdal.org/) is a translator library for raster and vector geospatial data formats. Install GDAL to read complex formats and extremely large remote sensing images.
-
-```shell
-conda install GDAL
-```
-
-## Trouble shooting
-
-If you have some issues during the installation, please first view the [FAQ](notes/faq.md) page.
-You may [open an issue](https://github.com/open-mmlab/mmsegmentation/issues/new/choose) on GitHub if no solution is found.
diff --git a/mmsegmentation/docs/en/index.rst b/mmsegmentation/docs/en/index.rst
deleted file mode 100644
index cdf8622..0000000
--- a/mmsegmentation/docs/en/index.rst
+++ /dev/null
@@ -1,63 +0,0 @@
-Welcome to MMSegmentation's documentation!
-===========================================
-
-.. toctree::
-   :maxdepth: 1
-   :caption: Get Started
-
-   overview.md
-   get_started.md
-
-.. toctree::
-   :maxdepth: 2
-   :caption: User Guides
-
-   user_guides/index.rst
-
-.. toctree::
-   :maxdepth: 2
-   :caption: Advanced Guides
-
-   advanced_guides/index.rst
-
-.. toctree::
-   :maxdepth: 1
-   :caption: Migration
-
-   migration/index.rst
-
-.. toctree::
-   :caption: API Reference
-
-   api.rst
-
-.. toctree::
-   :maxdepth: 1
-   :caption: Model Zoo
-
-   model_zoo.md
-   modelzoo_statistics.md
-
-.. toctree::
-   :maxdepth: 1
-   :caption: Notes
-
-   notes/changelog.md
-   notes/faq.md
-
-.. toctree::
-   :caption: Device Support
-
-   device/npu.md
-
-.. toctree::
-   :caption: Switch Language
-
-   switch_language.md
-
-
-Indices and tables
-==================
-
-* :ref:`genindex`
-* :ref:`search`
diff --git a/mmsegmentation/docs/en/make.bat b/mmsegmentation/docs/en/make.bat
deleted file mode 100644
index 922152e..0000000
--- a/mmsegmentation/docs/en/make.bat
+++ /dev/null
@@ -1,35 +0,0 @@
-@ECHO OFF
-
-pushd %~dp0
-
-REM Command file for Sphinx documentation
-
-if "%SPHINXBUILD%" == "" (
-	set SPHINXBUILD=sphinx-build
-)
-set SOURCEDIR=.
-set BUILDDIR=_build
-
-if "%1" == "" goto help
-
-%SPHINXBUILD% >NUL 2>NUL
-if errorlevel 9009 (
-	echo.
-	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
-	echo.installed, then set the SPHINXBUILD environment variable to point
-	echo.to the full path of the 'sphinx-build' executable. Alternatively you
-	echo.may add the Sphinx directory to PATH.
-	echo.
-	echo.If you don't have Sphinx installed, grab it from
-	echo.http://sphinx-doc.org/
-	exit /b 1
-)
-
-%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
-goto end
-
-:help
-%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
-
-:end
-popd
diff --git a/mmsegmentation/docs/en/migration/index.rst b/mmsegmentation/docs/en/migration/index.rst
deleted file mode 100644
index 2843bdb..0000000
--- a/mmsegmentation/docs/en/migration/index.rst
+++ /dev/null
@@ -1,8 +0,0 @@
-Migration
-***************
-
-.. toctree::
-   :maxdepth: 1
-
-   interface.md
-   package.md
diff --git a/mmsegmentation/docs/en/migration/interface.md b/mmsegmentation/docs/en/migration/interface.md
deleted file mode 100644
index b83eeb9..0000000
--- a/mmsegmentation/docs/en/migration/interface.md
+++ /dev/null
@@ -1,525 +0,0 @@
-# Migration from MMSegmentation 0.x
-
-## Introduction
-
-This guide describes the fundamental differences between MMSegmentation 0.x and MMSegmentation 1.x in terms of behaviors and the APIs, and how these all relate to your migration journey.
-
-## New dependencies
-
-MMSegmentation 1.x depends on some new packages, you can prepare a new clean environment and install again according to the [installation tutorial](../get_started.md).
-
-Or install the below packages manually.
-
-1. [MMEngine](https://github.com/open-mmlab/mmengine): MMEngine is the core the OpenMMLab 2.0 architecture, and we splited many compentents unrelated to computer vision from MMCV to MMEngine.
-
-2. [MMCV](https://github.com/open-mmlab/mmcv): The computer vision package of OpenMMLab. This is not a new dependency, but you need to upgrade it to **2.0.0** version or above.
-
-3. [MMClassification](https://github.com/open-mmlab/mmclassification)(Optional): The image classification toolbox and benchmark of OpenMMLab. This is not a new dependency, but you need to upgrade it to **1.0.0rc6** version.
-
-4. [MMDetection](https://github.com/open-mmlab/mmdetection)(Optional): The object detection toolbox and benchmark of OpenMMLab. This is not a new dependency, but you need to upgrade it to **3.0.0** version or above.
-
-## Train launch
-
-The main improvement of OpenMMLab 2.0 is releasing MMEngine which provides universal and powerful runner for unified interfaces to launch training jobs.
-
-Compared with MMSeg0.x, MMSeg1.x provides fewer command line arguments in `tools/train.py`
-
-<table class="docutils">
-<tr>
-<td>Function</td>
-<td>Original</td>
-<td>New</td>
-</tr>
-<tr>
-<td>Loading pre-trained checkpoint</td>
-<td>--load_from=$CHECKPOINT</td>
-<td>--cfg-options load_from=$CHECKPOINT</td>
-</tr>
-<tr>
-<td>Resuming Train from specific checkpoint</td>
-<td>--resume-from=$CHECKPOINT</td>
-<td>--resume=$CHECKPOINT</td>
-</tr>
-<tr>
-<td>Resuming Train from the latest checkpoint</td>
-<td>--auto-resume</td>
-<td>--resume='auto'</td>
-</tr>
-<tr>
-<td>Whether not to evaluate the checkpoint during training</td>
-<td>--no-validate</td>
-<td>--cfg-options val_cfg=None val_dataloader=None val_evaluator=None</td>
-</tr>
-<tr>
-<td>Training device assignment</td>
-<td>--gpu-id=$DEVICE_ID</td>
-<td>-</td>
-</tr>
-<tr>
-<td>Whether or not set different seeds for different ranks</td>
-<td>--diff-seed</td>
-<td>--cfg-options randomness.diff_rank_seed=True</td>
-</tr>
-<td>Whether to set deterministic options for CUDNN backend</td>
-<td>--deterministic</td>
-<td>--cfg-options randomness.deterministic=True</td>
-</table>
-
-## Test launch
-
-Similar to training launch, there are only common arguments in tools/test.py of MMSegmentation 1.x.
-Below is the difference in test scripts,
-please refer to [this documentation](../user_guides/4_train_test.md) for more details about test launch.
-
-<table class="docutils">
-<tr>
-<td>Function</td>
-<td>0.x</td>
-<td>1.x</td>
-</tr>
-<tr>
-<td>Evaluation metrics</td>
-<td>--eval mIoU</td>
-<td>--cfg-options test_evaluator.type=IoUMetric</td>
-</tr>
-<tr>
-<td>Whether to use test time augmentation</td>
-<td>--aug-test</td>
-<td>--tta</td>
-</tr>
-<tr>
-<td>Whether save the output results without perform evaluation</td>
-<td>--format-only</td>
-<td>--cfg-options test_evaluator.format_only=True</td>
-</tr>
-</table>
-
-## Configuration file
-
-### Model settings
-
-No changes in `model.backbone`, `model.neck`, `model.decode_head` and `model.losses` fields.
-
-Add `model.data_preprocessor` field to configure the `DataPreProcessor`, including:
-
-- `mean` (Sequence, optional): The pixel mean of R, G, B channels. Defaults to None.
-
-- `std` (Sequence, optional): The pixel standard deviation of R, G, B channels. Defaults to None.
-
-- `size` (Sequence, optional): Fixed padding size.
-
-- `size_divisor` (int, optional): The divisor of padded size.
-
-- `seg_pad_val` (float, optional): Padding value of segmentation map. Default: 255.
-
-- `padding_mode` (str): Type of padding. Default: 'constant'.
-
-  - constant: pads with a constant value, this value is specified with pad_val.
-
-- `bgr_to_rgb` (bool): whether to convert image from BGR to RGB.Defaults to False.
-
-- `rgb_to_bgr` (bool): whether to convert image from RGB to BGR. Defaults to False.
-
-**Note:**
-Please refer [models documentation](../advanced_guides/models.md) for more details.
-
-### Dataset settings
-
-Changes in **data**:
-
-The original `data` field is split to `train_dataloader`, `val_dataloader` and `test_dataloader`. This allows us to configure them in fine-grained. For example, you can specify different sampler and batch size during training and test.
-The `samples_per_gpu` is renamed to `batch_size`.
-The `workers_per_gpu` is renamed to `num_workers`.
-
-<table class="docutils">
-<tr>
-<td>Original</td>
-<td>
-
-```python
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-    train=dict(...),
-    val=dict(...),
-    test=dict(...),
-)
-```
-
-</td>
-<tr>
-<td>New</td>
-<td>
-
-```python
-train_dataloader = dict(
-    batch_size=4,
-    num_workers=4,
-    dataset=dict(...),
-    sampler=dict(type='DefaultSampler', shuffle=True)  # necessary
-)
-
-val_dataloader = dict(
-    batch_size=4,
-    num_workers=4,
-    dataset=dict(...),
-    sampler=dict(type='DefaultSampler', shuffle=False)  # necessary
-)
-
-test_dataloader = val_dataloader
-```
-
-</td>
-</tr>
-</table>
-
-Changes in **pipeline**
-
-- The original formatting transforms **`ToTensor`**、**`ImageToTensor`**、**`Collect`** are combined as [`PackSegInputs`](mmseg.datasets.transforms.PackSegInputs)
-- We don't recommend to do **`Normalize`** and **Pad** in the dataset pipeline. Please remove it from pipelines and set it in the `data_preprocessor` field.
-- The original **`Resize`** in MMSeg 1.x has been changed to **`RandomResize`** and the input arguments `img_scale` is renamed to `scale`, and the default value of `keep_ratio` is modified to False.
-- The original `test_pipeline` combines single-scale test and multi-scale test together, in MMSeg 1.x we separate it into `test_pipeline` and `tta_pipeline`.
-
-**Note:**
-We move some work of data transforms to the data preprocessor, like normalization, see [the documentation](package.md) for more details.
-
-train_pipeline
-
-<table class="docutils">
-<tr>
-<td>Original</td>
-<td>
-
-```python
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='Resize', img_scale=(2560, 640), ratio_range=(0.5, 2.0)),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
-]
-```
-
-</td>
-<tr>
-<td>New</td>
-<td>
-
-```python
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(
-        type='RandomResize',
-        scale=(2560, 640),
-        ratio_range=(0.5, 2.0),
-        keep_ratio=True),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-```
-
-</td>
-</tr>
-</table>
-
-test_pipeline
-
-<table class="docutils">
-<tr>
-<td>Original</td>
-<td>
-
-```python
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(2560, 640),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
-]
-```
-
-</td>
-<tr>
-<td>New</td>
-<td>
-
-```python
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(2560, 640), keep_ratio=True),
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='PackSegInputs')
-]
-img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
-tta_pipeline = [
-    dict(type='LoadImageFromFile', backend_args=None),
-    dict(
-        type='TestTimeAug',
-        transforms=[
-            [
-                dict(type='Resize', scale_factor=r, keep_ratio=True)
-                for r in img_ratios
-            ],
-            [
-                dict(type='RandomFlip', prob=0., direction='horizontal'),
-                dict(type='RandomFlip', prob=1., direction='horizontal')
-            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
-        ])
-]
-```
-
-</td>
-</tr>
-</table>
-
-Changes in **`evaluation`**:
-
-- The **`evaluation`** field is split to `val_evaluator` and `test_evaluator`. And it won't support `interval` and `save_best` arguments.
-  The `interval` is moved to `train_cfg.val_interval`, and the `save_best` is moved to `default_hooks.checkpoint.save_best`. `pre_eval` has been removed.
-- `'mIoU'` has been changed to `'IoUMetric'`.
-
-<table class="docutils">
-<tr>
-<td>Original</td>
-<td>
-
-```python
-evaluation = dict(interval=2000, metric='mIoU', pre_eval=True)
-```
-
-</td>
-<tr>
-<td>New</td>
-<td>
-
-```python
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
-test_evaluator = val_evaluator
-```
-
-</td>
-</tr>
-</table>
-
-### Optimizer and Schedule settings
-
-Changes in **`optimizer`** and **`optimizer_config`**:
-
-- Now we use `optim_wrapper` field to specify all configuration about the optimization process. And the `optimizer` is a sub field of `optim_wrapper` now.
-- `paramwise_cfg` is also a sub field of `optim_wrapper`, instead of `optimizer`.
-- `optimizer_config` is removed now, and all configurations of it are moved to `optim_wrapper`.
-- `grad_clip` is renamed to `clip_grad`.
-
-<table class="docutils">
-<tr>
-<td>Original</td>
-<td>
-
-```python
-optimizer = dict(type='AdamW', lr=0.0001, weight_decay=0.0005)
-optimizer_config = dict(grad_clip=dict(max_norm=1, norm_type=2))
-```
-
-</td>
-<tr>
-<td>New</td>
-<td>
-
-```python
-optim_wrapper = dict(
-    type='OptimWrapper',
-    optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0005),
-    clip_grad=dict(max_norm=1, norm_type=2))
-```
-
-</td>
-</tr>
-</table>
-
-Changes in **`lr_config`**:
-
-- The `lr_config` field is removed and we use new `param_scheduler` to replace it.
-- The `warmup` related arguments are removed, since we use schedulers combination to implement this functionality.
-
-The new schedulers combination mechanism is very flexible, and you can use it to design many kinds of learning rate / momentum curves. See [the tutorial](TODO) for more details.
-
-<table class="docutils">
-<tr>
-<td>Original</td>
-<td>
-
-```python
-lr_config = dict(
-    policy='poly',
-    warmup='linear',
-    warmup_iters=1500,
-    warmup_ratio=1e-6,
-    power=1.0,
-    min_lr=0.0,
-    by_epoch=False)
-```
-
-</td>
-<tr>
-<td>New</td>
-<td>
-
-```python
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        power=1.0,
-        begin=1500,
-        end=160000,
-        eta_min=0.0,
-        by_epoch=False,
-    )
-]
-```
-
-</td>
-</tr>
-</table>
-
-Changes in **`runner`**:
-
-Most configuration in the original `runner` field is moved to `train_cfg`, `val_cfg` and `test_cfg`, which configure the loop in training, validation and test.
-
-<table class="docutils">
-<tr>
-<td>Original</td>
-<td>
-
-```python
-runner = dict(type='IterBasedRunner', max_iters=20000)
-```
-
-</td>
-<tr>
-<td>New</td>
-<td>
-
-```python
-# The `val_interval` is the original `evaluation.interval`.
-train_cfg = dict(type='IterBasedTrainLoop', max_iters=20000, val_interval=2000)
-val_cfg = dict(type='ValLoop') # Use the default validation loop.
-test_cfg = dict(type='TestLoop') # Use the default test loop.
-```
-
-</td>
-</tr>
-</table>
-
-In fact, in OpenMMLab 2.0, we introduced `Loop` to control the behaviors in training, validation and test. The functionalities of `Runner` are also changed. You can find more details of [runner tutorial](https://github.com/open-mmlab/mmengine/blob/main/docs/en/design/runner.md) in [MMEngine](https://github.com/open-mmlab/mmengine/).
-
-### Runtime settings
-
-Changes in **`checkpoint_config`** and **`log_config`**:
-
-The `checkpoint_config` are moved to `default_hooks.checkpoint` and the `log_config` are moved to `default_hooks.logger`.
-And we move many hooks settings from the script code to the `default_hooks` field in the runtime configuration.
-
-```python
-default_hooks = dict(
-    # record the time of every iterations.
-    timer=dict(type='IterTimerHook'),
-
-    # print log every 50 iterations.
-    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
-
-    # enable the parameter scheduler.
-    param_scheduler=dict(type='ParamSchedulerHook'),
-
-    # save checkpoint every 2000 iterations.
-    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=2000),
-
-    # set sampler seed in distributed environment.
-    sampler_seed=dict(type='DistSamplerSeedHook'),
-
-    # validation results visualization.
-    visualization=dict(type='SegVisualizationHook'))
-```
-
-In addition, we split the original logger to logger and visualizer. The logger is used to record information and the visualizer is used to show the logger in different backends, like terminal and TensorBoard.
-
-<table class="docutils">
-<tr>
-<td>Original</td>
-<td>
-
-```python
-log_config = dict(
-    interval=100,
-    hooks=[
-        dict(type='TextLoggerHook'),
-        dict(type='TensorboardLoggerHook'),
-    ])
-```
-
-</td>
-<tr>
-<td>New</td>
-<td>
-
-```python
-default_hooks = dict(
-    ...
-    logger=dict(type='LoggerHook', interval=100),
-)
-vis_backends = [dict(type='LocalVisBackend'),
-                dict(type='TensorboardVisBackend')]
-visualizer = dict(
-    type='SegLocalVisualizer', vis_backends=vis_backends, name='visualizer')
-```
-
-</td>
-</tr>
-</table>
-
-Changes in **`load_from`** and **`resume_from`**:
-
-- The `resume_from` is removed. And we use `resume` and `load_from` to replace it.
-  - If `resume=True` and `load_from` is **not None**, resume training from the checkpoint in `load_from`.
-  - If `resume=True` and `load_from` is **None**, try to resume from the latest checkpoint in the work directory.
-  - If `resume=False` and `load_from` is **not None**, only load the checkpoint, not resume training.
-  - If `resume=False` and `load_from` is **None**, do not load nor resume.
-
-Changes in **`dist_params`**: The `dist_params` field is a sub field of `env_cfg` now. And there are some new configurations in the `env_cfg`.
-
-```python
-env_cfg = dict(
-    # whether to enable cudnn benchmark
-    cudnn_benchmark=False,
-
-    # set multi process parameters
-    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
-
-    # set distributed parameters
-    dist_cfg=dict(backend='nccl'),
-)
-```
-
-Changes in **`workflow`**: `workflow` related functionalities are removed.
-
-New field **`visualizer`**: The visualizer is a new design in OpenMMLab 2.0 architecture. We use a visualizer instance in the runner to handle results & log visualization and save to different backends. See the [visualization tutorial](../user_guides/visualization.md) for more details.
-
-New field **`default_scope`**: The start point to search module for all registries. The `default_scope` in MMSegmentation is `mmseg`. See [the registry tutorial](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/registry.md) for more details.
diff --git a/mmsegmentation/docs/en/migration/package.md b/mmsegmentation/docs/en/migration/package.md
deleted file mode 100644
index 728e9a9..0000000
--- a/mmsegmentation/docs/en/migration/package.md
+++ /dev/null
@@ -1,113 +0,0 @@
-# Package structures changes
-
-This section is included if you are curious about what has changed between MMSeg 0.x and 1.x.
-
-<table>
-<tr>
-<td>MMSegmentation 0.x</td>
-<td>MMSegmentation 1.x</td>
-</tr>
-<tr>
-<td>mmseg.api</td>
-<td>mmseg.api</td>
-</tr>
-<tr>
-<td bgcolor=#fcf7f7>- mmseg.core</td>
-<td bgcolor=#ecf4eb>+ mmseg.engine</td>
-</tr>
-<tr>
-<td>mmseg.datasets</td>
-<td>mmseg.datasets</td>
-</tr>
-<tr>
-<td>mmseg.models</td>
-<td>mmseg.models</td>
-</tr>
-<tr>
-<td bgcolor=#fcf7f7>- mmseg.ops</td>
-<td bgcolor=#ecf4eb>+ mmseg.structure</td>
-</tr>
-<tr>
-<td>mmseg.utils</td>
-<td>mmseg.utils</td>
-</tr>
-<tr>
-<td></td>
-<td bgcolor=#ecf4eb>+ mmseg.evaluation</td>
-</tr>
-<tr>
-<td></td>
-<td bgcolor=#ecf4eb>+ mmseg.registry</td>
-<tr>
-</table>
-
-## Removed packages
-
-### `mmseg.core`
-
-In OpenMMLab 2.0, `core` package has been removed. `hooks` and `optimizers` of `core` are moved in `mmseg.engine`, and `evaluation` in `core` is mmseg.evaluation currently.
-
-## `mmseg.ops`
-
-`ops` package included `encoding` and `wrappers`, which are moved in `mmseg.models.utils`.
-
-## Added packages
-
-### `mmseg.engine`
-
-OpenMMLab 2.0 adds a new foundational library for training deep learning, MMEngine. It servers as the training engine of all OpenMMLab codebases.
-`engine` package of mmseg is some customized modules for semantic segmentation task, like `SegVisualizationHook` which works for visualizing segmentation mask.
-
-### `mmseg.structure`
-
-In OpenMMLab 2.0, we designed data structure for computer vision task, and in mmseg, we implements `SegDataSample` in `structure` package.
-
-### `mmseg.evaluation`
-
-We move all evaluation metric in `mmseg.evaluation`.
-
-### `mmseg.registry`
-
-We moved registry implementations for all kinds of modules in MMSegmentation in `mmseg.registry`.
-
-## Modified packages
-
-### `mmseg.apis`
-
-OpenMMLab 2.0 tries to support unified interface for multitasking of Computer Vision, and releases much stronger [`Runner`](https://github.com/open-mmlab/mmengine/blob/main/docs/en/design/runner.md), so MMSeg 1.x removed modules in `train.py` and `test.py` renamed `init_segmentor` to `init_model` and `inference_segmentor` to `inference_model`.
-
-Here is the changes of `mmseg.apis`:
-
-|       Function        | Changes                                         |
-| :-------------------: | :---------------------------------------------- |
-|   `init_segmentor`    | Renamed to `init_model`                         |
-| `inference_segmentor` | Rename to `inference_model`                     |
-| `show_result_pyplot`  | Implemented based on `SegLocalVisualizer`       |
-|     `train_model`     | Removed, use `runner.train` to train.           |
-|   `multi_gpu_test`    | Removed, use `runner.test` to test.             |
-|   `single_gpu_test`   | Removed, use `runner.test` to test.             |
-|   `set_random_seed`   | Removed, use `mmengine.runner.set_random_seed`. |
-|  `init_random_seed`   | Removed, use `mmengine.dist.sync_random_seed`.  |
-
-### `mmseg.datasets`
-
-OpenMMLab 2.0 defines the `BaseDataset` to function and interface of dataset, and MMSegmentation 1.x also follow this protocol and defines the `BaseSegDataset` inherited from `BaseDataset`. MMCV 2.x collects general data transforms for multiple tasks e.g. classification, detection, segmentation, so MMSegmentation 1.x uses these data transforms and removes them from mmseg.datasets.
-
-|   Packages/Modules    | Changes                                                                                     |
-| :-------------------: | :------------------------------------------------------------------------------------------ |
-|   `mmseg.pipelines`   | Moved in `mmcv.transforms`                                                                  |
-|    `mmseg.sampler`    | Moved in `mmengine.dataset.sampler`                                                         |
-|    `CustomDataset`    | Renamed to `BaseSegDataset` and inherited from `BaseDataset` in MMEngine                    |
-| `DefaultFormatBundle` | Replaced with `PackSegInputs`                                                               |
-|  `LoadImageFromFile`  | Moved in `mmcv.transforms.LoadImageFromFile`                                                |
-|   `LoadAnnotations`   | Moved in `mmcv.transforms.LoadAnnotations`                                                  |
-|       `Resize`        | Moved in `mmcv.transforms` and split into `Resize`, `RandomResize` and `RandomChoiceResize` |
-|     `RandomFlip`      | Moved in `mmcv.transforms.RandomFlip`                                                       |
-|         `Pad`         | Moved in `mmcv.transforms.Pad`                                                              |
-|      `Normalize`      | Moved in `mmcv.transforms.Normalize`                                                        |
-|       `Compose`       | Moved in `mmcv.transforms.Compose`                                                          |
-|    `ImageToTensor`    | Moved in `mmcv.transforms.ImageToTensor`                                                    |
-
-### `mmseg.models`
-
-`models` has not changed a lot, just added the `encoding` and `wrappers` from previous `mmseg.ops`
diff --git a/mmsegmentation/docs/en/model_zoo.md b/mmsegmentation/docs/en/model_zoo.md
deleted file mode 100644
index 6717df6..0000000
--- a/mmsegmentation/docs/en/model_zoo.md
+++ /dev/null
@@ -1,186 +0,0 @@
-# Benchmark and Model Zoo
-
-## Common settings
-
-- We use distributed training with 4 GPUs by default.
-
-- All pytorch-style pretrained backbones on ImageNet are train by ourselves, with the same procedure in the [paper](https://arxiv.org/pdf/1812.01187.pdf).
-  Our ResNet style backbone are based on ResNetV1c variant, where the 7x7 conv in the input stem is replaced with three 3x3 convs.
-
-- For the consistency across different hardwares, we report the GPU memory as the maximum value of `torch.cuda.max_memory_allocated()` for all 4 GPUs with `torch.backends.cudnn.benchmark=False`.
-  Note that this value is usually less than what `nvidia-smi` shows.
-
-- We report the inference time as the total time of network forwarding and post-processing, excluding the data loading time.
-  Results are obtained with the script `tools/benchmark.py` which computes the average time on 200 images with `torch.backends.cudnn.benchmark=False`.
-
-- There are two inference modes in this framework.
-
-  - `slide` mode: The `test_cfg` will be like `dict(mode='slide', crop_size=(769, 769), stride=(513, 513))`.
-
-    In this mode, multiple patches will be cropped from input image, passed into network individually.
-    The crop size and stride between patches are specified by `crop_size` and `stride`.
-    The overlapping area will be merged by average
-
-  - `whole` mode: The `test_cfg` will be like `dict(mode='whole')`.
-
-    In this mode, the whole imaged will be passed into network directly.
-
-    By default, we use `slide` inference for 769x769 trained model, `whole` inference for the rest.
-
-- For input size of 8x+1 (e.g. 769), `align_corner=True` is adopted as a traditional practice.
-  Otherwise, for input size of 8x (e.g. 512, 1024), `align_corner=False` is adopted.
-
-## Baselines
-
-### FCN
-
-Please refer to [FCN](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn) for details.
-
-### PSPNet
-
-Please refer to [PSPNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet) for details.
-
-### DeepLabV3
-
-Please refer to [DeepLabV3](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3) for details.
-
-### PSANet
-
-Please refer to [PSANet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet) for details.
-
-### DeepLabV3+
-
-Please refer to [DeepLabV3+](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus) for details.
-
-### UPerNet
-
-Please refer to [UPerNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet) for details.
-
-### NonLocal Net
-
-Please refer to [NonLocal Net](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net) for details.
-
-### EncNet
-
-Please refer to [EncNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet) for details.
-
-### CCNet
-
-Please refer to [CCNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet) for details.
-
-### DANet
-
-Please refer to [DANet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet) for details.
-
-### APCNet
-
-Please refer to [APCNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet) for details.
-
-### HRNet
-
-Please refer to [HRNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet) for details.
-
-### GCNet
-
-Please refer to [GCNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet) for details.
-
-### DMNet
-
-Please refer to [DMNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet) for details.
-
-### ANN
-
-Please refer to [ANN](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann) for details.
-
-### OCRNet
-
-Please refer to [OCRNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet) for details.
-
-### Fast-SCNN
-
-Please refer to [Fast-SCNN](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastscnn) for details.
-
-### ResNeSt
-
-Please refer to [ResNeSt](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/resnest) for details.
-
-### Semantic FPN
-
-Please refer to [Semantic FPN](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/sem_fpn) for details.
-
-### PointRend
-
-Please refer to [PointRend](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/point_rend) for details.
-
-### MobileNetV2
-
-Please refer to [MobileNetV2](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v2) for details.
-
-### MobileNetV3
-
-Please refer to [MobileNetV3](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v3) for details.
-
-### EMANet
-
-Please refer to [EMANet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/emanet) for details.
-
-### DNLNet
-
-Please refer to [DNLNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet) for details.
-
-### CGNet
-
-Please refer to [CGNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/cgnet) for details.
-
-### Mixed Precision (FP16) Training
-
-Please refer [Mixed Precision (FP16) Training on BiSeNetV2](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv2/bisenetv2_fcn_4xb4-160k_cityscapes-1024x1024.py) for details.
-
-### U-Net
-
-Please refer to [U-Net](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet/README.md) for details.
-
-### ViT
-
-Please refer to [ViT](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/README.md) for details.
-
-### Swin
-
-Please refer to [Swin](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/swin/README.md) for details.
-
-### SETR
-
-Please refer to [SETR](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/setr/README.md) for details.
-
-## Speed benchmark
-
-### Hardware
-
-- 8 NVIDIA Tesla V100 (32G) GPUs
-- Intel(R) Xeon(R) Gold 6148 CPU @ 2.40GHz
-
-### Software environment
-
-- Python 3.7
-- PyTorch 1.5
-- CUDA 10.1
-- CUDNN 7.6.03
-- NCCL 2.4.08
-
-### Training speed
-
-For fair comparison, we benchmark all implementations with ResNet-101V1c.
-The input size is fixed to 1024x512 with batch size 2.
-
-The training speed is reported as followed, in terms of second per iter (s/iter). The lower, the better.
-
-| Implementation                                                              | PSPNet (s/iter) | DeepLabV3+ (s/iter) |
-| --------------------------------------------------------------------------- | --------------- | ------------------- |
-| [MMSegmentation](https://github.com/open-mmlab/mmsegmentation)              | **0.83**        | **0.85**            |
-| [SegmenTron](https://github.com/LikeLy-Journey/SegmenTron)                  | 0.84            | 0.85                |
-| [CASILVision](https://github.com/CSAILVision/semantic-segmentation-pytorch) | 1.15            | N/A                 |
-| [vedaseg](https://github.com/Media-Smart/vedaseg)                           | 0.95            | 1.25                |
-
-:::{note}
-The output stride of DeepLabV3+ is 8.
-:::
diff --git a/mmsegmentation/docs/en/modelzoo_statistics.md b/mmsegmentation/docs/en/modelzoo_statistics.md
deleted file mode 100644
index e5e21a1..0000000
--- a/mmsegmentation/docs/en/modelzoo_statistics.md
+++ /dev/null
@@ -1,102 +0,0 @@
-# Model Zoo Statistics
-
-- Number of papers: 47
-
-  - ALGORITHM: 36
-  - BACKBONE: 11
-
-- Number of checkpoints: 612
-
-  - \[ALGORITHM\] [ANN](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ann) (16 ckpts)
-
-  - \[ALGORITHM\] [APCNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/apcnet) (12 ckpts)
-
-  - \[BACKBONE\] [BEiT](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/beit) (2 ckpts)
-
-  - \[ALGORITHM\] [BiSeNetV1](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv1) (11 ckpts)
-
-  - \[ALGORITHM\] [BiSeNetV2](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/bisenetv2) (4 ckpts)
-
-  - \[ALGORITHM\] [CCNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ccnet) (16 ckpts)
-
-  - \[ALGORITHM\] [CGNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/cgnet) (2 ckpts)
-
-  - \[BACKBONE\] [ConvNeXt](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/convnext) (6 ckpts)
-
-  - \[ALGORITHM\] [DANet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/danet) (16 ckpts)
-
-  - \[ALGORITHM\] [DeepLabV3](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3) (41 ckpts)
-
-  - \[ALGORITHM\] [DeepLabV3+](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/deeplabv3plus) (42 ckpts)
-
-  - \[ALGORITHM\] [DMNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dmnet) (12 ckpts)
-
-  - \[ALGORITHM\] [DNLNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dnlnet) (12 ckpts)
-
-  - \[ALGORITHM\] [DPT](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/dpt) (1 ckpts)
-
-  - \[ALGORITHM\] [EMANet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/emanet) (4 ckpts)
-
-  - \[ALGORITHM\] [EncNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/encnet) (12 ckpts)
-
-  - \[ALGORITHM\] [ERFNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/erfnet) (1 ckpts)
-
-  - \[ALGORITHM\] [FastFCN](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastfcn) (12 ckpts)
-
-  - \[ALGORITHM\] [Fast-SCNN](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fastscnn) (1 ckpts)
-
-  - \[ALGORITHM\] [FCN](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn) (41 ckpts)
-
-  - \[ALGORITHM\] [GCNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/gcnet) (16 ckpts)
-
-  - \[BACKBONE\] [HRNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/hrnet) (37 ckpts)
-
-  - \[ALGORITHM\] [ICNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/icnet) (12 ckpts)
-
-  - \[ALGORITHM\] [ISANet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/isanet) (16 ckpts)
-
-  - \[ALGORITHM\] [K-Net](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/knet) (7 ckpts)
-
-  - \[BACKBONE\] [MAE](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mae) (1 ckpts)
-
-  - \[ALGORITHM\] [Mask2Former](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mask2former) (13 ckpts)
-
-  - \[ALGORITHM\] [MaskFormer](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/maskformer) (4 ckpts)
-
-  - \[BACKBONE\] [MobileNetV2](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v2) (8 ckpts)
-
-  - \[BACKBONE\] [MobileNetV3](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/mobilenet_v3) (4 ckpts)
-
-  - \[ALGORITHM\] [NonLocal Net](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/nonlocal_net) (16 ckpts)
-
-  - \[ALGORITHM\] [OCRNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/ocrnet) (24 ckpts)
-
-  - \[ALGORITHM\] [PointRend](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/point_rend) (4 ckpts)
-
-  - \[BACKBONE\] [PoolFormer](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/poolformer) (5 ckpts)
-
-  - \[ALGORITHM\] [PSANet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/psanet) (16 ckpts)
-
-  - \[ALGORITHM\] [PSPNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet) (54 ckpts)
-
-  - \[BACKBONE\] [ResNeSt](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/resnest) (8 ckpts)
-
-  - \[ALGORITHM\] [SegFormer](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segformer) (13 ckpts)
-
-  - \[ALGORITHM\] [Segmenter](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/segmenter) (5 ckpts)
-
-  - \[ALGORITHM\] [Semantic FPN](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/sem_fpn) (4 ckpts)
-
-  - \[ALGORITHM\] [SETR](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/setr) (7 ckpts)
-
-  - \[ALGORITHM\] [STDC](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/stdc) (4 ckpts)
-
-  - \[BACKBONE\] [Swin Transformer](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/swin) (6 ckpts)
-
-  - \[BACKBONE\] [Twins](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/twins) (12 ckpts)
-
-  - \[ALGORITHM\] [UNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/unet) (25 ckpts)
-
-  - \[ALGORITHM\] [UPerNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/upernet) (16 ckpts)
-
-  - \[BACKBONE\] [Vision Transformer](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit) (11 ckpts)
diff --git a/mmsegmentation/docs/en/notes/changelog.md b/mmsegmentation/docs/en/notes/changelog.md
deleted file mode 100644
index 8eaf332..0000000
--- a/mmsegmentation/docs/en/notes/changelog.md
+++ /dev/null
@@ -1,506 +0,0 @@
-# Changelog of v1.x
-
-## v1.2.2 (12/14/2023)
-
-### Bug Fixes
-
-- Fix bug in cross entropy loss ([#3457](https://github.com/open-mmlab/mmsegmentation/pull/3457))
-- Allow custom visualizer ([#3455](https://github.com/open-mmlab/mmsegmentation/pull/3455))
-- test resize with pad_shape ([#3421](https://github.com/open-mmlab/mmsegmentation/pull/3421))
-- add with-labels args to inferencer for visualization without labels ([#3466](https://github.com/open-mmlab/mmsegmentation/pull/3466))
-
-### New Contributors
-
-- @okotaku made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3421
-
-## v1.2.1 (10/17/2023)
-
-### Bug Fixes
-
-- Add bpe_simple_vocab_16e6.txt.gz to release ([#3386](https://github.com/open-mmlab/mmsegmentation/pull/3386))
-- Fix init api ([#3388](https://github.com/open-mmlab/mmsegmentation/pull/3388))
-
-## v1.2.0 (10/12/2023)
-
-### Features
-
-- Support Side Adapter Network ([#3232](https://github.com/open-mmlab/mmsegmentation/pull/3232))
-
-### Bug Fixes
-
-- fix wrong variables passing for `set_dataset_meta` ([#3348](https://github.com/open-mmlab/mmsegmentation/pull/3348))
-
-### Documentation
-
-- add documentation of Finetune ONNX Models (MMSegemetation) Inference for NVIDIA Jetson ([#3372](https://github.com/open-mmlab/mmsegmentation/pull/3372))
-
-## v1.1.2(09/20/2023)
-
-### Features
-
-- Add semantic label to the segmentation visualization results ([#3229](https://github.com/open-mmlab/mmsegmentation/pull/3229))
-- Support NYU depth estimation dataset ([#3269](https://github.com/open-mmlab/mmsegmentation/pull/3269))
-- Support Kullback-Leibler divergence Loss ([#3242](https://github.com/open-mmlab/mmsegmentation/pull/3242))
-- Support depth metrics ([#3297](https://github.com/open-mmlab/mmsegmentation/pull/3297))
-- Support Remote sensing inferencer ([#3131](https://github.com/open-mmlab/mmsegmentation/pull/3131))
-- Support VPD Depth Estimator ((#3321)(https://github.com/open-mmlab/mmsegmentation/pull/3321))
-- Support inference and visualization of VPD ([#3331](https://github.com/open-mmlab/mmsegmentation/pull/3331))
-- Support using the pytorch-grad-cam tool to visualize Class Activation Maps (CAM) ([#3324](https://github.com/open-mmlab/mmsegmentation/pull/3324))
-
-### New projects
-
-- Support PP-Mobileseg ([#3239](https://github.com/open-mmlab/mmsegmentation/pull/3239))
-- Support CAT-Seg (CVPR'2023) ([#3098](https://github.com/open-mmlab/mmsegmentation/pull/3098))
-- Support Adabins ([#3257](https://github.com/open-mmlab/mmsegmentation/pull/3257))
-- Add pp_mobileseg onnx inference script ([#3268](https://github.com/open-mmlab/mmsegmentation/pull/3268))
-
-### Bug Fixes
-
-- Fix module PascalContextDataset ([#3235](https://github.com/open-mmlab/mmsegmentation/pull/3235))
-- Fix one hot encoding for dice loss ([#3237](https://github.com/open-mmlab/mmsegmentation/pull/3237))
-- Fix confusion_matrix.py ([#3291](https://github.com/open-mmlab/mmsegmentation/pull/3291))
-- Fix inferencer visualization ([#3333](https://github.com/open-mmlab/mmsegmentation/pull/3333))
-
-### Documentation
-
-- Translate doc for docs/zh_cn/user_guides/5_deployment.md ([#3281](https://github.com/open-mmlab/mmsegmentation/pull/3281))
-
-### New Contributors
-
-- @angiecao made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3235
-- @yeedrag made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3237
-- @Yang-Changhui made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3239
-- @ooooo-create made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3261
-- @Ben-Louis made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3269
-- @crazysteeaam made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3284
-- @zen0no made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3242
-- @XiandongWang made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3291
-- @ZhaoQiiii made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3332
-- @zhen6618 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3324
-
-## v1.1.1(07/24/2023)
-
-### Features
-
-- Add bdd100K datasets ([#3158](https://github.com/open-mmlab/mmsegmentation/pull/3158))
-- Remove batch inference assertion ([#3210](https://github.com/open-mmlab/mmsegmentation/pull/3210))
-
-### Bug Fixes
-
-- Fix train map path for coco-stuff164k.py ([#3187](https://github.com/open-mmlab/mmsegmentation/pull/3187))
-- Fix mim search error ([#3194](https://github.com/open-mmlab/mmsegmentation/pull/3194))
-- Fix SegTTAModel with no attribute '\_gt_sem_seg' error ([#3152](https://github.com/open-mmlab/mmsegmentation/pull/3152))
-- Fix Albumentations default key mapping mismatch ([#3195](https://github.com/open-mmlab/mmsegmentation/pull/3195))
-
-### New Contributors
-
-- @OliverGrace made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3187
-- @ZiAn-Su made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3152
-- @CastleDream made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3158
-- @coding-famer made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3174
-- @Alias-z made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3195
-
-## v1.1.0(06/28/2023)
-
-## What's Changed
-
-### Features
-
-- Support albu transform ([#2943](https://github.com/open-mmlab/mmsegmentation/pull/2943))
-- Support DDRNet ([#2855](https://github.com/open-mmlab/mmsegmentation/pull/2855))
-- Add GDAL backend and Support LEVIR-CD Dataset ([#2903](https://github.com/open-mmlab/mmsegmentation/pull/2903))
-- Support DSDL Dataset ([#2925](https://github.com/open-mmlab/mmsegmentation/pull/2925))
-- huasdorff distance loss ([#2820](https://github.com/open-mmlab/mmsegmentation/pull/2820))
-
-### New Projects
-
-- Support SAM inferencer ([#2897](https://github.com/open-mmlab/mmsegmentation/pull/2897))
-- Added a supported for Visual Attention Network (VAN) ([#2987](https://github.com/open-mmlab/mmsegmentation/pull/2987))
-- add GID dataset ([#3038](https://github.com/open-mmlab/mmsegmentation/pull/3038))
-- add Medical semantic seg dataset: Bactteria ([#2568](https://github.com/open-mmlab/mmsegmentation/pull/2568))
-- add Medical semantic seg dataset: Vampire ([#2633](https://github.com/open-mmlab/mmsegmentation/pull/2633))
-- add Medical semantic seg dataset: Ravir ([#2635](https://github.com/open-mmlab/mmsegmentation/pull/2635))
-- add Medical semantic seg dataset: Cranium ([#2675](https://github.com/open-mmlab/mmsegmentation/pull/2675))
-- add Medical semantic seg dataset: bccs ([#2861](https://github.com/open-mmlab/mmsegmentation/pull/2861))
-- add Medical semantic seg dataset: Gamma Task3 dataset ([#2695](https://github.com/open-mmlab/mmsegmentation/pull/2695))
-- add Medical semantic seg dataset: consep ([#2724](https://github.com/open-mmlab/mmsegmentation/pull/2724))
-- add Medical semantic seg dataset: breast_cancer_cell_seg dataset ([#2726](https://github.com/open-mmlab/mmsegmentation/pull/2726))
-- add Medical semantic seg dataset: chest_image_pneum dataset ([#2727](https://github.com/open-mmlab/mmsegmentation/pull/2727))
-- add Medical semantic seg dataset: conic2022 ([#2725](https://github.com/open-mmlab/mmsegmentation/pull/2725))
-- add Medical semantic seg dataset: dr_hagis ([#2729](https://github.com/open-mmlab/mmsegmentation/pull/2729))
-- add Medical semantic seg dataset: orvs ([#2728](https://github.com/open-mmlab/mmsegmentation/pull/2728))
-- add Medical semantic seg dataset: ISIC-2016 Task1 ([#2708](https://github.com/open-mmlab/mmsegmentation/pull/2708))
-- add Medical semantic seg dataset: ISIC-2017 Task1 ([#2709](https://github.com/open-mmlab/mmsegmentation/pull/2709))
-- add Medical semantic seg dataset: Kvasir seg ([#2677](https://github.com/open-mmlab/mmsegmentation/pull/2677))
-- add Medical semantic seg dataset: Kvasir seg aliyun ([#2678](https://github.com/open-mmlab/mmsegmentation/pull/2678))
-- add Medical semantic seg dataset: Rite ([#2680](https://github.com/open-mmlab/mmsegmentation/pull/2680))
-- add Medical semantic seg dataset: Fusc2021 ([#2682](https://github.com/open-mmlab/mmsegmentation/pull/2682))
-- add Medical semantic seg dataset: 2pm vessel ([#2685](https://github.com/open-mmlab/mmsegmentation/pull/2685))
-- add Medical semantic seg dataset: Pcam ([#2684](https://github.com/open-mmlab/mmsegmentation/pull/2684))
-- add Medical semantic seg dataset: Pannuke ([#2683](https://github.com/open-mmlab/mmsegmentation/pull/2683))
-- add Medical semantic seg dataset: Covid 19 ct cxr ([#2688](https://github.com/open-mmlab/mmsegmentation/pull/2688))
-- add Medical semantic seg dataset: Crass ([#2690](https://github.com/open-mmlab/mmsegmentation/pull/2690))
-- add Medical semantic seg dataset: Chest x ray images with pneumothorax masks ([#2687](https://github.com/open-mmlab/mmsegmentation/pull/2687))
-
-### Enhancement
-
-- Robust mapping from image path to seg map path ([#3091](https://github.com/open-mmlab/mmsegmentation/pull/3091))
-- Change assertion logic inference cfg.model.test_cfg ([#3012](https://github.com/open-mmlab/mmsegmentation/pull/3012))
-- Refactor dice loss ([#3002](https://github.com/open-mmlab/mmsegmentation/pull/3002))
-- Update Dockerfile libgl1-mesa-dev ([#3095](https://github.com/open-mmlab/mmsegmentation/pull/3095))
-- Prevent passed `ann_file` from silently failing to load ([#2966](https://github.com/open-mmlab/mmsegmentation/pull/2966))
-- Update the translation of models documentation ([#2833](https://github.com/open-mmlab/mmsegmentation/pull/2833))
-- Add docs contents at README.md ([#3083](https://github.com/open-mmlab/mmsegmentation/pull/3083))
-- Enhance swin pretrained model loading ([#3097](https://github.com/open-mmlab/mmsegmentation/pull/3097))
-
-### Bug Fixes
-
-- Handle case where device is neither CPU nor CUDA in HamHead ([#2868](https://github.com/open-mmlab/mmsegmentation/pull/2868))
-- Fix bugs when out_channels==1 ([#2911](https://github.com/open-mmlab/mmsegmentation/pull/2911))
-- Fix binary C=1 focal loss & dataset fileio ([#2935](https://github.com/open-mmlab/mmsegmentation/pull/2935))
-- Fix isaid dataset pre-processing tool ([#3010](https://github.com/open-mmlab/mmsegmentation/pull/3010))
-- Fix bug cannot use both '--tta' and '--out' while testing ([#3067](https://github.com/open-mmlab/mmsegmentation/pull/3067))
-- Fix inferencer ut ([#3117](https://github.com/open-mmlab/mmsegmentation/pull/3117))
-- Fix document ([#2863](https://github.com/open-mmlab/mmsegmentation/pull/2863), [#2896](https://github.com/open-mmlab/mmsegmentation/pull/2896), [#2919](https://github.com/open-mmlab/mmsegmentation/pull/2919), [#2951](https://github.com/open-mmlab/mmsegmentation/pull/2951), [#2970](https://github.com/open-mmlab/mmsegmentation/pull/2970), [#2961](https://github.com/open-mmlab/mmsegmentation/pull/2961), [#3042](https://github.com/open-mmlab/mmsegmentation/pull/3042), )
-- Fix squeeze error when N=1 and C=1 ([#2933](https://github.com/open-mmlab/mmsegmentation/pull/2933))
-
-### New Contributors
-
-- @liu-mengyang made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2896
-- @likyoo made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2911
-- @1qh made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2902
-- @JoshuaChou2018 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2951
-- @jts250 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2833
-- @MGAMZ made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2970
-- @tianbinli made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2568
-- @Provable0816 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2633
-- @Zoulinx made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2903
-- @wufan-tb made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2925
-- @haruishi43 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2966
-- @Masaaki-75 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2675
-- @tang576225574 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2987
-- @Kedreamix made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3010
-- @nightrain01 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3067
-- @shigengtian made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3095
-- @SheffieldCao made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3097
-- @wangruohui made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3091
-- @LHamnett made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/3012
-
-## v1.0.0(04/06/2023)
-
-### Highlights
-
-- Add Mapillary Vistas Datasets support to MMSegmentation Core Package ([#2576](https://github.com/open-mmlab/mmsegmentation/pull/2576))
-- Support PIDNet ([#2609](https://github.com/open-mmlab/mmsegmentation/pull/2609))
-- Support SegNeXt ([#2654](https://github.com/open-mmlab/mmsegmentation/pull/2654))
-
-### Features
-
-- Support calculating FLOPs of segmentors ([#2706](https://github.com/open-mmlab/mmsegmentation/pull/2706))
-- Support multi-band image for Mosaic ([#2748](https://github.com/open-mmlab/mmsegmentation/pull/2748))
-- Support dump segment prediction ([#2712](https://github.com/open-mmlab/mmsegmentation/pull/2712))
-
-### Bug fix
-
-- Fix format_result and fix prefix param in cityscape metric, and rename CitysMetric to CityscapesMetric ([#2660](https://github.com/open-mmlab/mmsegmentation/pull/2660))
-- Support input gt seg map is not 2D ([#2739](https://github.com/open-mmlab/mmsegmentation/pull/2739))
-- Fix accepting an unexpected argument `local-rank` in PyTorch 2.0 ([#2812](https://github.com/open-mmlab/mmsegmentation/pull/2812))
-
-### Documentation
-
-- Add Chinese version of various documentation ([#2673](https://github.com/open-mmlab/mmsegmentation/pull/2673), [#2702](https://github.com/open-mmlab/mmsegmentation/pull/2702), [#2703](https://github.com/open-mmlab/mmsegmentation/pull/2703), [#2701](https://github.com/open-mmlab/mmsegmentation/pull/2701), [#2722](https://github.com/open-mmlab/mmsegmentation/pull/2722), [#2733](https://github.com/open-mmlab/mmsegmentation/pull/2733), [#2769](https://github.com/open-mmlab/mmsegmentation/pull/2769), [#2790](https://github.com/open-mmlab/mmsegmentation/pull/2790), [#2798](https://github.com/open-mmlab/mmsegmentation/pull/2798))
-- Update and refine various English documentation ([#2715](https://github.com/open-mmlab/mmsegmentation/pull/2715), [#2755](https://github.com/open-mmlab/mmsegmentation/pull/2755), [#2745](https://github.com/open-mmlab/mmsegmentation/pull/2745), [#2797](https://github.com/open-mmlab/mmsegmentation/pull/2797), [#2799](https://github.com/open-mmlab/mmsegmentation/pull/2799), [#2821](https://github.com/open-mmlab/mmsegmentation/pull/2821), [#2827](https://github.com/open-mmlab/mmsegmentation/pull/2827), [#2831](https://github.com/open-mmlab/mmsegmentation/pull/2831))
-- Add deeplabv3 model structure documentation ([#2426](https://github.com/open-mmlab/mmsegmentation/pull/2426))
-- Add custom metrics documentation ([#2799](https://github.com/open-mmlab/mmsegmentation/pull/2799))
-- Add faq in dev-1.x branch ([#2765](https://github.com/open-mmlab/mmsegmentation/pull/2765))
-
-### New Contributors
-
-- @liuruiqiang made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2554
-- @wangjiangben-hw made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2569
-- @jinxianwei made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2557
-- @KKIEEK made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2747
-- @Renzhihan made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2765
-
-## v1.0.0rc6(03/03/2023)
-
-### Highlights
-
-- Support MMSegInferencer ([#2413](https://github.com/open-mmlab/mmsegmentation/pull/2413), [#2658](https://github.com/open-mmlab/mmsegmentation/pull/2658))
-- Support REFUGE dataset ([#2554](https://github.com/open-mmlab/mmsegmentation/pull/2554))
-
-### Features
-
-- Support auto import modules from registry ([#2481](https://github.com/open-mmlab/mmsegmentation/pull/2481))
-- Replace numpy ascontiguousarray with torch contiguous to speed-up ([#2604](https://github.com/open-mmlab/mmsegmentation/pull/2604))
-- Add browse_dataset.py tool ([#2649](https://github.com/open-mmlab/mmsegmentation/pull/2649))
-
-### Bug fix
-
-- Rename and Fix bug of projects HieraSeg ([#2565](https://github.com/open-mmlab/mmsegmentation/pull/2565))
-- Add out_channels  in `CascadeEncoderDecoder` and update OCRNet and MobileNet v2 results ([#2656](https://github.com/open-mmlab/mmsegmentation/pull/2656))
-
-### Documentation
-
-- Add dataflow documentation of Chinese version ([#2652](https://github.com/open-mmlab/mmsegmentation/pull/2652))
-- Add custmized runtime documentation of English version ([#2533](https://github.com/open-mmlab/mmsegmentation/pull/2533))
-- Add documentation for visualizing feature map using wandb backend ([#2557](https://github.com/open-mmlab/mmsegmentation/pull/2557))
-- Add documentation for benchmark results on NPU (HUAWEI Ascend) ([#2569](https://github.com/open-mmlab/mmsegmentation/pull/2569), [#2596](https://github.com/open-mmlab/mmsegmentation/pull/2596), [#2610](https://github.com/open-mmlab/mmsegmentation/pull/2610))
-- Fix api name error in the migration doc ([#2601](https://github.com/open-mmlab/mmsegmentation/pull/2601))
-- Refine projects documentation ([#2586](https://github.com/open-mmlab/mmsegmentation/pull/2586))
-- Refine MMSegmentation documentation ([#2668](https://github.com/open-mmlab/mmsegmentation/pull/2668), [#2659](https://github.com/open-mmlab/mmsegmentation/pull/2659))
-
-### New Contributors
-
-- @zccjjj made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2548
-- @liuruiqiang made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2554
-- @wangjiangben-hw made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2569
-- @jinxianwei made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2557
-
-## v1.0.0rc5(02/01/2023)
-
-### Bug fix
-
-- Fix MaskFormer and Mask2Former when install mmdet from source ([#2532](https://github.com/open-mmlab/mmsegmentation/pull/2532))
-- Support new fileio interface in `MMCV>=2.0.0rc4` ([#2543](https://github.com/open-mmlab/mmsegmentation/pull/2543))
-- Fix ERFNet URL in dev-1.x branch ([#2537](https://github.com/open-mmlab/mmsegmentation/pull/2537))
-- Fix misleading `List[Tensor]` types ([#2546](https://github.com/open-mmlab/mmsegmentation/pull/2546))
-- Rename typing.py to typing_utils.py ([#2548](https://github.com/open-mmlab/mmsegmentation/pull/2548))
-
-## v1.0.0rc4(01/30/2023)
-
-### Highlights
-
-- Support ISNet (ICCV'2021) in projects ([#2400](https://github.com/open-mmlab/mmsegmentation/pull/2400))
-- Support HSSN (CVPR'2022) in projects ([#2444](https://github.com/open-mmlab/mmsegmentation/pull/2444))
-
-### Features
-
-- Add Gaussian Noise and Blur for biomedical data ([#2373](https://github.com/open-mmlab/mmsegmentation/pull/2373))
-- Add BioMedicalRandomGamma ([#2406](https://github.com/open-mmlab/mmsegmentation/pull/2406))
-- Add BioMedical3DPad ([#2383](https://github.com/open-mmlab/mmsegmentation/pull/2383))
-- Add BioMedical3DRandomFlip ([#2404](https://github.com/open-mmlab/mmsegmentation/pull/2404))
-- Add `gt_edge_map` field to SegDataSample ([#2466](https://github.com/open-mmlab/mmsegmentation/pull/2466))
-- Support synapse dataset ([#2432](https://github.com/open-mmlab/mmsegmentation/pull/2432), [#2465](https://github.com/open-mmlab/mmsegmentation/pull/2465))
-- Support Mapillary Vistas Dataset in projects ([#2484](https://github.com/open-mmlab/mmsegmentation/pull/2484))
-- Switch order of `reduce_zero_label` and applying `label_map` ([#2517](https://github.com/open-mmlab/mmsegmentation/pull/2517))
-
-### Documentation
-
-- Add ZN Customized_runtime Doc ([#2502](https://github.com/open-mmlab/mmsegmentation/pull/2502))
-- Add EN datasets.md ([#2464](https://github.com/open-mmlab/mmsegmentation/pull/2464))
-- Fix minor typo in migration `package.md` ([#2518](https://github.com/open-mmlab/mmsegmentation/pull/2518))
-
-### Bug fix
-
-- Fix incorrect `img_shape` value assignment in RandomCrop ([#2469](https://github.com/open-mmlab/mmsegmentation/pull/2469))
-- Fix inference api and support setting palette to SegLocalVisualizer ([#2475](https://github.com/open-mmlab/mmsegmentation/pull/2475))
-- Unfinished label conversion from `-1` to `255` ([#2516](https://github.com/open-mmlab/mmsegmentation/pull/2516))
-
-### New Contributors
-
-- @blueyo0 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2373
-- @Fivethousand5k made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2406
-- @suyanzhou626 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2383
-- @unrealMJ made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2400
-- @Dominic23331 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2432
-- @AI-Tianlong made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2444
-- @morkovka1337 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2492
-- @Leeinsn made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2404
-- @siddancha made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/2516
-
-## v1.0.0rc3(31/12/2022)
-
-### Highlights
-
-- Support test time augmentation ([#2184](https://github.com/open-mmlab/mmsegmentation/pull/2184))
-- Add 'Projects/' folder and the first example project ([#2412](https://github.com/open-mmlab/mmsegmentation/pull/2412))
-
-### Features
-
-- Add Biomedical 3D array random crop transform ([#2378](https://github.com/open-mmlab/mmsegmentation/pull/2378))
-
-### Documentation
-
-- Add Chinese version of config tutorial ([#2371](https://github.com/open-mmlab/mmsegmentation/pull/2371))
-- Add Chinese version of train & test tutorial  ([#2355](https://github.com/open-mmlab/mmsegmentation/pull/2355))
-- Add Chinese version of overview ([(#2397)](https://github.com/open-mmlab/mmsegmentation/pull/2397)))
-- Add Chinese version of get_started ([#2417](https://github.com/open-mmlab/mmsegmentation/pull/2417))
-- Add datasets in Chinese ([#2387](https://github.com/open-mmlab/mmsegmentation/pull/2387))
-- Add dataflow document ([#2403](https://github.com/open-mmlab/mmsegmentation/pull/2403))
-- Add pspnet model structure graph ([#2437](https://github.com/open-mmlab/mmsegmentation/pull/2437))
-- Update some content of engine Chinese documentation ([#2341](https://github.com/open-mmlab/mmsegmentation/pull/2341))
-- Update TTA to migration documentation ([#2335](https://github.com/open-mmlab/mmsegmentation/pull/2335))
-
-### Bug fix
-
-- Remove dependency mmdet when do not use MaskFormerHead and MMDET_Mask2FormerHead ([#2448](https://github.com/open-mmlab/mmsegmentation/pull/2448))
-
-### Enhancement
-
-- Add torch1.13 checking in CI ([#2402](https://github.com/open-mmlab/mmsegmentation/pull/2402))
-- Fix pytorch version for merge stage test  ([#2449](https://github.com/open-mmlab/mmsegmentation/pull/2449))
-
-## v1.0.0rc2(6/12/2022)
-
-### Highlights
-
-- Support MaskFormer ([#2215](https://github.com/open-mmlab/mmsegmentation/pull/2215))
-- Support Mask2Former ([#2255](https://github.com/open-mmlab/mmsegmentation/pull/2255))
-
-### Features
-
-- Add ResizeShortestEdge transform ([#2339](https://github.com/open-mmlab/mmsegmentation/pull/2339))
-- Support padding in data pre-processor for model testing([#2290](https://github.com/open-mmlab/mmsegmentation/pull/2290))
-- Fix the problem of post-processing not removing padding ([#2367](https://github.com/open-mmlab/mmsegmentation/pull/2367))
-
-### Bug fix
-
-- Fix links in README ([#2024](https://github.com/open-mmlab/mmsegmentation/pull/2024))
-- Fix swin load state_dict ([#2304](https://github.com/open-mmlab/mmsegmentation/pull/2304))
-- Fix typo of BaseSegDataset docstring ([#2322](https://github.com/open-mmlab/mmsegmentation/pull/2322))
-- Fix the bug in the visualization step ([#2326](https://github.com/open-mmlab/mmsegmentation/pull/2326))
-- Fix ignore class id from -1 to 255 in BaseSegDataset ([#2332](https://github.com/open-mmlab/mmsegmentation/pull/2332))
-- Fix KNet IterativeDecodeHead bug ([#2334](https://github.com/open-mmlab/mmsegmentation/pull/2334))
-- Add input argument for datasets ([#2379](https://github.com/open-mmlab/mmsegmentation/pull/2379))
-- Fix typo in warning on binary classification ([#2382](https://github.com/open-mmlab/mmsegmentation/pull/2382))
-
-### Enhancement
-
-- Fix ci for 1.x ([#2011](https://github.com/open-mmlab/mmsegmentation/pull/2011), [#2019](https://github.com/open-mmlab/mmsegmentation/pull/2019))
-- Fix lint and pre-commit hook ([#2308](https://github.com/open-mmlab/mmsegmentation/pull/2308))
-- Add `data` string in .gitignore file in dev-1.x branch ([#2336](https://github.com/open-mmlab/mmsegmentation/pull/2336))
-- Make scipy as a default dependency in runtime ([#2362](https://github.com/open-mmlab/mmsegmentation/pull/2362))
-- Delete mmcls in runtime.txt ([#2368](https://github.com/open-mmlab/mmsegmentation/pull/2368))
-
-### Documentation
-
-- Update configuration documentation ([#2048](https://github.com/open-mmlab/mmsegmentation/pull/2048))
-- Update inference documentation ([#2052](https://github.com/open-mmlab/mmsegmentation/pull/2052))
-- Update train test documentation ([#2061](https://github.com/open-mmlab/mmsegmentation/pull/2061))
-- Update get started documentatin ([#2148](https://github.com/open-mmlab/mmsegmentation/pull/2148))
-- Update transforms documentation ([#2088](https://github.com/open-mmlab/mmsegmentation/pull/2088))
-- Add MMEval projects like in README ([#2259](https://github.com/open-mmlab/mmsegmentation/pull/2259))
-- Translate the visualization.md ([#2298](https://github.com/open-mmlab/mmsegmentation/pull/2298))
-
-## v1.0.0rc1 (2/11/2022)
-
-### Highlights
-
-- Support PoolFormer ([#2191](https://github.com/open-mmlab/mmsegmentation/pull/2191))
-- Add Decathlon dataset ([#2227](https://github.com/open-mmlab/mmsegmentation/pull/2227))
-
-### Features
-
-- Add BioMedical data loading ([#2176](https://github.com/open-mmlab/mmsegmentation/pull/2176))
-- Add LIP dataset ([#2251](https://github.com/open-mmlab/mmsegmentation/pull/2251))
-- Add `GenerateEdge` data transform ([#2210](https://github.com/open-mmlab/mmsegmentation/pull/2210))
-
-### Bug fix
-
-- Fix segmenter-vit-s_fcn config ([#2037](https://github.com/open-mmlab/mmsegmentation/pull/2037))
-- Fix binary segmentation ([#2101](https://github.com/open-mmlab/mmsegmentation/pull/2101))
-- Fix MMSegmentation colab demo ([#2089](https://github.com/open-mmlab/mmsegmentation/pull/2089))
-- Fix ResizeToMultiple transform ([#2185](https://github.com/open-mmlab/mmsegmentation/pull/2185))
-- Use SyncBN in mobilenet_v2 ([#2198](https://github.com/open-mmlab/mmsegmentation/pull/2198))
-- Fix typo in installation ([#2175](https://github.com/open-mmlab/mmsegmentation/pull/2175))
-- Fix typo in visualization.md ([#2116](https://github.com/open-mmlab/mmsegmentation/pull/2116))
-
-### Enhancement
-
-- Add mim extras_requires in setup.py ([#2012](https://github.com/open-mmlab/mmsegmentation/pull/2012))
-- Fix CI ([#2029](https://github.com/open-mmlab/mmsegmentation/pull/2029))
-- Remove ops module ([#2063](https://github.com/open-mmlab/mmsegmentation/pull/2063))
-- Add pyupgrade pre-commit hook ([#2078](https://github.com/open-mmlab/mmsegmentation/pull/2078))
-- Add `out_file` in `add_datasample` of `SegLocalVisualizer` to directly save image ([#2090](https://github.com/open-mmlab/mmsegmentation/pull/2090))
-- Upgrade pre commit hooks ([#2154](https://github.com/open-mmlab/mmsegmentation/pull/2154))
-- Ignore test timm in CI when torch\<1.7 ([#2158](https://github.com/open-mmlab/mmsegmentation/pull/2158))
-- Update requirements ([#2186](https://github.com/open-mmlab/mmsegmentation/pull/2186))
-- Fix Windows platform CI ([#2202](https://github.com/open-mmlab/mmsegmentation/pull/2202))
-
-### Documentation
-
-- Add `Overview` documentation ([#2042](https://github.com/open-mmlab/mmsegmentation/pull/2042))
-- Add `Evaluation` documentation ([#2077](https://github.com/open-mmlab/mmsegmentation/pull/2077))
-- Add `Migration` documentation ([#2066](https://github.com/open-mmlab/mmsegmentation/pull/2066))
-- Add `Structures` documentation ([#2070](https://github.com/open-mmlab/mmsegmentation/pull/2070))
-- Add `Structures` ZN documentation ([#2129](https://github.com/open-mmlab/mmsegmentation/pull/2129))
-- Add `Engine` ZN documentation ([#2157](https://github.com/open-mmlab/mmsegmentation/pull/2157))
-- Update `Prepare datasets` and `Visualization` doc ([#2054](https://github.com/open-mmlab/mmsegmentation/pull/2054))
-- Update `Models` documentation ([#2160](https://github.com/open-mmlab/mmsegmentation/pull/2160))
-- Update `Add New Modules` documentation ([#2067](https://github.com/open-mmlab/mmsegmentation/pull/2067))
-- Fix the installation commands in get_started.md ([#2174](https://github.com/open-mmlab/mmsegmentation/pull/2174))
-- Add MMYOLO to README.md ([#2220](https://github.com/open-mmlab/mmsegmentation/pull/2220))
-
-## v1.0.0rc0 (31/8/2022)
-
-We are excited to announce the release of MMSegmentation 1.0.0rc0.
-MMSeg 1.0.0rc0 is the first version of MMSegmentation 1.x, a part of the OpenMMLab 2.0 projects.
-Built upon the new [training engine](https://github.com/open-mmlab/mmengine),
-MMSeg 1.x unifies the interfaces of dataset, models, evaluation, and visualization with faster training and testing speed.
-
-### Highlights
-
-1. **New engines** MMSeg 1.x is based on [MMEngine](https://github.com/open-mmlab/mmengine), which provides a general and powerful runner that allows more flexible customizations and significantly simplifies the entrypoints of high-level interfaces.
-
-2. **Unified interfaces** As a part of the OpenMMLab 2.0 projects, MMSeg 1.x unifies and refactors the interfaces and internal logics of train, testing, datasets, models, evaluation, and visualization. All the OpenMMLab 2.0 projects share the same design in those interfaces and logics to allow the emergence of multi-task/modality algorithms.
-
-3. **Faster speed** We optimize the training and inference speed for common models.
-
-4. **New features**:
-
-   - Support TverskyLoss function
-
-5. **More documentation and tutorials**. We add a bunch of documentation and tutorials to help users get started more smoothly. Read it [here](https://mmsegmentation.readthedocs.io/en/1.x/).
-
-### Breaking Changes
-
-We briefly list the major breaking changes here.
-We will update the [migration guide](../migration.md) to provide complete details and migration instructions.
-
-#### Training and testing
-
-- MMSeg 1.x runs on PyTorch>=1.6. We have deprecated the support of PyTorch 1.5 to embrace the mixed precision training and other new features since PyTorch 1.6. Some models can still run on PyTorch 1.5, but the full functionality of MMSeg 1.x is not guaranteed.
-
-- MMSeg 1.x uses Runner in [MMEngine](https://github.com/open-mmlab/mmengine) rather than that in MMCV. The new Runner implements and unifies the building logic of dataset, model, evaluation, and visualizer. Therefore, MMSeg 1.x no longer maintains the building logics of those modules in `mmseg.train.apis` and `tools/train.py`. Those code have been migrated into [MMEngine](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py). Please refer to the [migration guide of Runner in MMEngine](https://mmengine.readthedocs.io/en/latest/migration/runner.html) for more details.
-
-- The Runner in MMEngine also supports testing and validation. The testing scripts are also simplified, which has similar logic as that in training scripts to build the runner.
-
-- The execution points of hooks in the new Runner have been enriched to allow more flexible customization. Please refer to the [migration guide of Hook in MMEngine](https://mmengine.readthedocs.io/en/latest/migration/hook.html) for more details.
-
-- Learning rate and momentum scheduling has been migrated from `Hook` to `Parameter Scheduler` in MMEngine. Please refer to the [migration guide of Parameter Scheduler in MMEngine](https://mmengine.readthedocs.io/en/latest/migration/param_scheduler.html) for more details.
-
-#### Configs
-
-- The [Runner in MMEngine](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py) uses a different config structures to ease the understanding of the components in runner. Users can read the [config example of mmseg](../user_guides/config.md) or refer to the [migration guide in MMEngine](https://mmengine.readthedocs.io/en/latest/migration/runner.html) for migration details.
-- The file names of configs and models are also refactored to follow the new rules unified across OpenMMLab 2.0 projects. Please refer to the [user guides of config](../user_guides/1_config.md) for more details.
-
-#### Components
-
-- Dataset
-- Data Transforms
-- Model
-- Evaluation
-- Visualization
-
-### Improvements
-
-- Support mixed precision training of all the models. However, some models may got Nan results due to some numerical issues. We will update the documentation and list their results (accuracy of failure) of mixed precision training.
-
-### Bug Fixes
-
-- Fix several config file errors [#1994](https://github.com/open-mmlab/mmsegmentation/pull/1994)
-
-### New Features
-
-1. Support data structures and encapsulating `seg_logits` in data samples, which can be return from models to support more common evaluation metrics.
-
-### Ongoing changes
-
-1. Test-time augmentation: which is supported in MMSeg 0.x is not implemented in this version due to limited time slot. We will support it in the following releases with a new and simplified design.
-
-2. Inference interfaces: a unified inference interfaces will be supported in the future to ease the use of released models.
-
-3. Interfaces of useful tools that can be used in notebook: more useful tools that implemented in the `tools` directory will have their python interfaces so that they can be used through notebook and in downstream libraries.
-
-4. Documentation: we will add more design docs, tutorials, and migration guidance so that the community can deep dive into our new design, participate the future development, and smoothly migrate downstream libraries to MMSeg 1.x.
diff --git a/mmsegmentation/docs/en/notes/changelog_v0.x.md b/mmsegmentation/docs/en/notes/changelog_v0.x.md
deleted file mode 100644
index d347a44..0000000
--- a/mmsegmentation/docs/en/notes/changelog_v0.x.md
+++ /dev/null
@@ -1,720 +0,0 @@
-## Changelog
-
-### V0.24.1 (5/1/2022)
-
-**Bug Fixes**
-
-- Fix `LayerDecayOptimizerConstructor` for MAE training ([#1539](https://github.com/open-mmlab/mmsegmentation/pull/1539), [#1540](https://github.com/open-mmlab/mmsegmentation/pull/1540))
-
-### V0.24.0 (4/29/2022)
-
-**Highlights**
-
-- Support MAE: Masked Autoencoders Are Scalable Vision Learners
-- Support Resnet strikes back
-
-**New Features**
-
-- Support MAE: Masked Autoencoders Are Scalable Vision Learners ([#1307](https://github.com/open-mmlab/mmsegmentation/pull/1307), [#1523](https://github.com/open-mmlab/mmsegmentation/pull/1523))
-- Support Resnet strikes back ([#1390](https://github.com/open-mmlab/mmsegmentation/pull/1390))
-- Support extra dataloader settings in configs ([#1435](https://github.com/open-mmlab/mmsegmentation/pull/1435))
-
-**Bug Fixes**
-
-- Fix input previous results for the last cascade_decode_head ([#1450](https://github.com/open-mmlab/mmsegmentation/pull/1450))
-- Fix validation loss logging ([#1494](https://github.com/open-mmlab/mmsegmentation/pull/1494))
-- Fix the bug in binary_cross_entropy ([1527](https://github.com/open-mmlab/mmsegmentation/pull/1527))
-- Support single channel prediction for Binary Cross Entropy Loss ([#1454](https://github.com/open-mmlab/mmsegmentation/pull/1454))
-- Fix potential bugs in accuracy.py ([1496](https://github.com/open-mmlab/mmsegmentation/pull/1496))
-- Avoid converting label ids twice by label map during evaluation ([1417](https://github.com/open-mmlab/mmsegmentation/pull/1417))
-- Fix bug about label_map ([1445](https://github.com/open-mmlab/mmsegmentation/pull/1445))
-- Fix image save path bug in Windows ([1423](https://github.com/open-mmlab/mmsegmentation/pull/1423))
-- Fix MMSegmentation Colab demo ([1501](https://github.com/open-mmlab/mmsegmentation/pull/1501), [1452](https://github.com/open-mmlab/mmsegmentation/pull/1452))
-- Migrate azure blob for beit checkpoints ([1503](https://github.com/open-mmlab/mmsegmentation/pull/1503))
-- Fix bug in `tools/analyse_logs.py` caused by wrong plot_iter in some cases ([1428](https://github.com/open-mmlab/mmsegmentation/pull/1428))
-
-**Improvements**
-
-- Merge BEiT and ConvNext's LR decay optimizer constructors ([#1438](https://github.com/open-mmlab/mmsegmentation/pull/1438))
-- Register optimizer constructor with mmseg ([#1456](https://github.com/open-mmlab/mmsegmentation/pull/1456))
-- Refactor transformer encode layer in ViT and BEiT backbone ([#1481](https://github.com/open-mmlab/mmsegmentation/pull/1481))
-- Add `build_pos_embed` and `build_layers` for BEiT ([1517](https://github.com/open-mmlab/mmsegmentation/pull/1517))
-- Add `with_cp` to mit and vit ([1431](https://github.com/open-mmlab/mmsegmentation/pull/1431))
-- Fix inconsistent dtype of `seg_label` in stdc decode ([1463](https://github.com/open-mmlab/mmsegmentation/pull/1463))
-- Delete random seed for training in `dist_train.sh` ([1519](https://github.com/open-mmlab/mmsegmentation/pull/1519))
-- Revise high `workers_per_gpus` in config file ([#1506](https://github.com/open-mmlab/mmsegmentation/pull/1506))
-- Add GPG keys and del mmcv version in Dockerfile ([1534](https://github.com/open-mmlab/mmsegmentation/pull/1534))
-- Update checkpoint for model in deeplabv3plus ([#1487](https://github.com/open-mmlab/mmsegmentation/pull/1487))
-- Add `DistSamplerSeedHook` to set epoch number to dataloader when runner is `EpochBasedRunner` ([1449](https://github.com/open-mmlab/mmsegmentation/pull/1449))
-- Provide URLs of Swin Transformer pretrained models ([1389](https://github.com/open-mmlab/mmsegmentation/pull/1389))
-- Updating Dockerfiles From Docker Directory and `get_started.md` to reach latest stable version of Python, PyTorch and MMCV ([1446](https://github.com/open-mmlab/mmsegmentation/pull/1446))
-
-**Documentation**
-
-- Add more clearly statement of CPU training/inference ([1518](https://github.com/open-mmlab/mmsegmentation/pull/1518))
-
-**Contributors**
-
-- @jiangyitong made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1431
-- @kahkeng made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1447
-- @Nourollah made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1446
-- @androbaza made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1452
-- @Yzichen made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1445
-- @whu-pzhang made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1423
-- @panfeng-hover made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1417
-- @Johnson-Wang made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1496
-- @jere357 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1460
-- @mfernezir made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1494
-- @donglixp made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1503
-- @YuanLiuuuuuu made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1307
-- @Dawn-bin made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1527
-
-### V0.23.0 (4/1/2022)
-
-**Highlights**
-
-- Support BEiT: BERT Pre-Training of Image Transformers
-- Support K-Net: Towards Unified Image Segmentation
-- Add `avg_non_ignore` of CELoss to support average loss over non-ignored elements
-- Support dataset initialization with file client
-
-**New Features**
-
-- Support BEiT: BERT Pre-Training of Image Transformers ([#1404](https://github.com/open-mmlab/mmsegmentation/pull/1404))
-- Support K-Net: Towards Unified Image Segmentation ([#1289](https://github.com/open-mmlab/mmsegmentation/pull/1289))
-- Support dataset initialization with file client ([#1402](https://github.com/open-mmlab/mmsegmentation/pull/1402))
-- Add class name function for STARE datasets ([#1376](https://github.com/open-mmlab/mmsegmentation/pull/1376))
-- Support different seeds on different ranks when distributed training ([#1362](https://github.com/open-mmlab/mmsegmentation/pull/1362))
-- Add `nlc2nchw2nlc` and `nchw2nlc2nchw` to simplify tensor with different dimension operation ([#1249](https://github.com/open-mmlab/mmsegmentation/pull/1249))
-
-**Improvements**
-
-- Synchronize random seed for distributed sampler ([#1411](https://github.com/open-mmlab/mmsegmentation/pull/1411))
-- Add script and documentation for multi-machine distributed training ([#1383](https://github.com/open-mmlab/mmsegmentation/pull/1383))
-
-**Bug Fixes**
-
-- Add `avg_non_ignore` of CELoss to support average loss over non-ignored elements ([#1409](https://github.com/open-mmlab/mmsegmentation/pull/1409))
-- Fix some wrong URLs of models or logs in `./configs` ([#1336](https://github.com/open-mmlab/mmsegmentation/pull/1433))
-- Add title and color theme arguments to plot function in `tools/confusion_matrix.py` ([#1401](https://github.com/open-mmlab/mmsegmentation/pull/1401))
-- Fix outdated link in Colab demo ([#1392](https://github.com/open-mmlab/mmsegmentation/pull/1392))
-- Fix typos ([#1424](https://github.com/open-mmlab/mmsegmentation/pull/1424), [#1405](https://github.com/open-mmlab/mmsegmentation/pull/1405), [#1371](https://github.com/open-mmlab/mmsegmentation/pull/1371), [#1366](https://github.com/open-mmlab/mmsegmentation/pull/1366), [#1363](https://github.com/open-mmlab/mmsegmentation/pull/1363))
-
-**Documentation**
-
-- Add FAQ document ([#1420](https://github.com/open-mmlab/mmsegmentation/pull/1420))
-- Fix the config name style description in official docs([#1414](https://github.com/open-mmlab/mmsegmentation/pull/1414))
-
-**Contributors**
-
-- @kinglintianxia made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1371
-- @CCODING04 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1376
-- @mob5566 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1401
-- @xiongnemo made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1392
-- @Xiangxu-0103 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1405
-
-### V0.22.1 (3/9/2022)
-
-**Bug Fixes**
-
-- Fix the ZeroDivisionError that all pixels in one image is ignored. ([#1336](https://github.com/open-mmlab/mmsegmentation/pull/1336))
-
-**Improvements**
-
-- Provide URLs of STDC, Segmenter and Twins pretrained models ([#1272](https://github.com/open-mmlab/mmsegmentation/pull/1357))
-
-### V0.22 (3/04/2022)
-
-**Highlights**
-
-- Support ConvNeXt: A ConvNet for the 2020s. Please use the latest MMClassification (0.21.0) to try it out.
-- Support iSAID aerial Dataset.
-- Officially Support inference on Windows OS.
-
-**New Features**
-
-- Support ConvNeXt: A ConvNet for the 2020s. ([#1216](https://github.com/open-mmlab/mmsegmentation/pull/1216))
-- Support iSAID aerial Dataset. ([#1115](https://github.com/open-mmlab/mmsegmentation/pull/1115)
-- Generating and plotting confusion matrix. ([#1301](https://github.com/open-mmlab/mmsegmentation/pull/1301))
-
-**Improvements**
-
-- Refactor 4 decoder heads (ASPP, FCN, PSP, UPer): Split forward function into `_forward_feature` and `cls_seg`. ([#1299](https://github.com/open-mmlab/mmsegmentation/pull/1299))
-- Add `min_size` arg in `Resize` to keep the shape after resize bigger than slide window. ([#1318](https://github.com/open-mmlab/mmsegmentation/pull/1318))
-- Revise pre-commit-hooks. ([#1315](https://github.com/open-mmlab/mmsegmentation/pull/1315))
-- Add win-ci. ([#1296](https://github.com/open-mmlab/mmsegmentation/pull/1296))
-
-**Bug Fixes**
-
-- Fix `mlp_ratio` type in Swin Transformer. ([#1274](https://github.com/open-mmlab/mmsegmentation/pull/1274))
-- Fix path errors in `./demo` . ([#1269](https://github.com/open-mmlab/mmsegmentation/pull/1269))
-- Fix bug in conversion of potsdam. ([#1279](https://github.com/open-mmlab/mmsegmentation/pull/1279))
-- Make accuracy take into account `ignore_index`. ([#1259](https://github.com/open-mmlab/mmsegmentation/pull/1259))
-- Add Pytorch HardSwish assertion in unit test. ([#1294](https://github.com/open-mmlab/mmsegmentation/pull/1294))
-- Fix wrong palette value in vaihingen. ([#1292](https://github.com/open-mmlab/mmsegmentation/pull/1292))
-- Fix the bug that SETR cannot load pretrain. ([#1293](https://github.com/open-mmlab/mmsegmentation/pull/1293))
-- Update correct `In Collection` in metafile of each configs. ([#1239](https://github.com/open-mmlab/mmsegmentation/pull/1239))
-- Upload completed STDC models. ([#1332](https://github.com/open-mmlab/mmsegmentation/pull/1332))
-- Fix `DNLHead` exports onnx inference difference type Cast error. ([#1161](https://github.com/open-mmlab/mmsegmentation/pull/1332))
-
-**Contributors**
-
-- @JiaYanhao made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1269
-- @andife made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1281
-- @SBCV made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1279
-- @HJoonKwon made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1259
-- @Tsingularity made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1290
-- @Waterman0524 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1115
-- @MeowZheng made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1315
-- @linfangjian01 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1318
-
-### V0.21.1 (2/9/2022)
-
-**Bug Fixes**
-
-- Fix typos in docs. ([#1263](https://github.com/open-mmlab/mmsegmentation/pull/1263))
-- Fix repeating log by `setup_multi_processes`. ([#1267](https://github.com/open-mmlab/mmsegmentation/pull/1267))
-- Upgrade isort in pre-commit hook. ([#1270](https://github.com/open-mmlab/mmsegmentation/pull/1270))
-
-**Improvements**
-
-- Use MMCV load_state_dict func in ViT/Swin. ([#1272](https://github.com/open-mmlab/mmsegmentation/pull/1272))
-- Add exception for PointRend for support CPU-only. ([#1271](https://github.com/open-mmlab/mmsegmentation/pull/1270))
-
-### V0.21 (1/29/2022)
-
-**Highlights**
-
-- Officially Support CPUs training and inference, please use the latest MMCV (1.4.4) to try it out.
-- Support Segmenter: Transformer for Semantic Segmentation (ICCV'2021).
-- Support ISPRS Potsdam and Vaihingen Dataset.
-- Add Mosaic transform and `MultiImageMixDataset` class in `dataset_wrappers`.
-
-**New Features**
-
-- Support Segmenter: Transformer for Semantic Segmentation (ICCV'2021) ([#955](https://github.com/open-mmlab/mmsegmentation/pull/955))
-- Support ISPRS Potsdam and Vaihingen Dataset ([#1097](https://github.com/open-mmlab/mmsegmentation/pull/1097), [#1171](https://github.com/open-mmlab/mmsegmentation/pull/1171))
-- Add segformer‘s benchmark on cityscapes ([#1155](https://github.com/open-mmlab/mmsegmentation/pull/1155))
-- Add auto resume ([#1172](https://github.com/open-mmlab/mmsegmentation/pull/1172))
-- Add Mosaic transform and `MultiImageMixDataset` class in `dataset_wrappers` ([#1093](https://github.com/open-mmlab/mmsegmentation/pull/1093), [#1105](https://github.com/open-mmlab/mmsegmentation/pull/1105))
-- Add log collector ([#1175](https://github.com/open-mmlab/mmsegmentation/pull/1175))
-
-**Improvements**
-
-- New-style CPU training and inference ([#1251](https://github.com/open-mmlab/mmsegmentation/pull/1251))
-- Add UNet benchmark with multiple losses supervision ([#1143](https://github.com/open-mmlab/mmsegmentation/pull/1143))
-
-**Bug Fixes**
-
-- Fix the model statistics in doc for readthedoc ([#1153](https://github.com/open-mmlab/mmsegmentation/pull/1153))
-- Set random seed for `palette` if not given ([#1152](https://github.com/open-mmlab/mmsegmentation/pull/1152))
-- Add `COCOStuffDataset` in `class_names.py` ([#1222](https://github.com/open-mmlab/mmsegmentation/pull/1222))
-- Fix bug in non-distributed multi-gpu training/testing ([#1247](https://github.com/open-mmlab/mmsegmentation/pull/1247))
-- Delete unnecessary lines of STDCHead ([#1231](https://github.com/open-mmlab/mmsegmentation/pull/1231))
-
-**Contributors**
-
-- @jbwang1997 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1152
-- @BeaverCC made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1206
-- @Echo-minn made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1214
-- @rstrudel made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/955
-
-### V0.20.2 (12/15/2021)
-
-**Bug Fixes**
-
-- Revise --option to --options to avoid BC-breaking. ([#1140](https://github.com/open-mmlab/mmsegmentation/pull/1140))
-
-### V0.20.1 (12/14/2021)
-
-**Improvements**
-
-- Change options to cfg-options ([#1129](https://github.com/open-mmlab/mmsegmentation/pull/1129))
-
-**Bug Fixes**
-
-- Fix `<!-- [ABSTRACT] -->` in metafile. ([#1127](https://github.com/open-mmlab/mmsegmentation/pull/1127))
-- Fix correct `num_classes` of HRNet in `LoveDA` dataset ([#1136](https://github.com/open-mmlab/mmsegmentation/pull/1136))
-
-### V0.20 (12/10/2021)
-
-**Highlights**
-
-- Support Twins ([#989](https://github.com/open-mmlab/mmsegmentation/pull/989))
-- Support a real-time segmentation model STDC ([#995](https://github.com/open-mmlab/mmsegmentation/pull/995))
-- Support a widely-used segmentation model in lane detection ERFNet ([#960](https://github.com/open-mmlab/mmsegmentation/pull/960))
-- Support A Remote Sensing Land-Cover Dataset LoveDA ([#1028](https://github.com/open-mmlab/mmsegmentation/pull/1028))
-- Support focal loss ([#1024](https://github.com/open-mmlab/mmsegmentation/pull/1024))
-
-**New Features**
-
-- Support Twins ([#989](https://github.com/open-mmlab/mmsegmentation/pull/989))
-- Support a real-time segmentation model STDC ([#995](https://github.com/open-mmlab/mmsegmentation/pull/995))
-- Support a widely-used segmentation model in lane detection ERFNet ([#960](https://github.com/open-mmlab/mmsegmentation/pull/960))
-- Add SETR cityscapes benchmark ([#1087](https://github.com/open-mmlab/mmsegmentation/pull/1087))
-- Add BiSeNetV1 COCO-Stuff 164k benchmark ([#1019](https://github.com/open-mmlab/mmsegmentation/pull/1019))
-- Support focal loss ([#1024](https://github.com/open-mmlab/mmsegmentation/pull/1024))
-- Add Cutout transform ([#1022](https://github.com/open-mmlab/mmsegmentation/pull/1022))
-
-**Improvements**
-
-- Set a random seed when the user does not set a seed ([#1039](https://github.com/open-mmlab/mmsegmentation/pull/1039))
-- Add CircleCI setup ([#1086](https://github.com/open-mmlab/mmsegmentation/pull/1086))
-- Skip CI on ignoring given paths ([#1078](https://github.com/open-mmlab/mmsegmentation/pull/1078))
-- Add abstract and image for every paper ([#1060](https://github.com/open-mmlab/mmsegmentation/pull/1060))
-- Create a symbolic link on windows ([#1090](https://github.com/open-mmlab/mmsegmentation/pull/1090))
-- Support video demo using trained model ([#1014](https://github.com/open-mmlab/mmsegmentation/pull/1014))
-
-**Bug Fixes**
-
-- Fix incorrectly loading init_cfg or pretrained models of several transformer models ([#999](https://github.com/open-mmlab/mmsegmentation/pull/999), [#1069](https://github.com/open-mmlab/mmsegmentation/pull/1069), [#1102](https://github.com/open-mmlab/mmsegmentation/pull/1102))
-- Fix EfficientMultiheadAttention in SegFormer ([#1037](https://github.com/open-mmlab/mmsegmentation/pull/1037))
-- Remove `fp16` folder in `configs` ([#1031](https://github.com/open-mmlab/mmsegmentation/pull/1031))
-- Fix several typos in .yml file (Dice Metric [#1041](https://github.com/open-mmlab/mmsegmentation/pull/1041), ADE20K dataset [#1120](https://github.com/open-mmlab/mmsegmentation/pull/1120), Training Memory (GB) [#1083](https://github.com/open-mmlab/mmsegmentation/pull/1083))
-- Fix test error when using `--show-dir` ([#1091](https://github.com/open-mmlab/mmsegmentation/pull/1091))
-- Fix dist training infinite waiting issue ([#1035](https://github.com/open-mmlab/mmsegmentation/pull/1035))
-- Change the upper version of mmcv to 1.5.0 ([#1096](https://github.com/open-mmlab/mmsegmentation/pull/1096))
-- Fix symlink failure on Windows ([#1038](https://github.com/open-mmlab/mmsegmentation/pull/1038))
-- Cancel previous runs that are not completed ([#1118](https://github.com/open-mmlab/mmsegmentation/pull/1118))
-- Unified links of readthedocs in docs ([#1119](https://github.com/open-mmlab/mmsegmentation/pull/1119))
-
-**Contributors**
-
-- @Junjue-Wang made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1028
-- @ddebby made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1066
-- @del-zhenwu made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1078
-- @KangBK0120 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1106
-- @zergzzlun made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1091
-- @fingertap made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1035
-- @irvingzhang0512 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1014
-- @littleSunlxy made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/989
-- @lkm2835
-- @RockeyCoss
-- @MengzhangLI
-- @Junjun2016
-- @xiexinch
-- @xvjiarui
-
-### V0.19 (11/02/2021)
-
-**Highlights**
-
-- Support TIMMBackbone wrapper ([#998](https://github.com/open-mmlab/mmsegmentation/pull/998))
-- Support custom hook ([#428](https://github.com/open-mmlab/mmsegmentation/pull/428))
-- Add codespell pre-commit hook ([#920](https://github.com/open-mmlab/mmsegmentation/pull/920))
-- Add FastFCN benchmark on ADE20K ([#972](https://github.com/open-mmlab/mmsegmentation/pull/972))
-
-**New Features**
-
-- Support TIMMBackbone wrapper ([#998](https://github.com/open-mmlab/mmsegmentation/pull/998))
-- Support custom hook ([#428](https://github.com/open-mmlab/mmsegmentation/pull/428))
-- Add FastFCN benchmark on ADE20K ([#972](https://github.com/open-mmlab/mmsegmentation/pull/972))
-- Add codespell pre-commit hook and fix typos ([#920](https://github.com/open-mmlab/mmsegmentation/pull/920))
-
-**Improvements**
-
-- Make inputs & channels smaller in unittests ([#1004](https://github.com/open-mmlab/mmsegmentation/pull/1004))
-- Change `self.loss_decode` back to `dict` in Single Loss situation ([#1002](https://github.com/open-mmlab/mmsegmentation/pull/1002))
-
-**Bug Fixes**
-
-- Fix typo in usage example ([#1003](https://github.com/open-mmlab/mmsegmentation/pull/1003))
-- Add contiguous after permutation in ViT ([#992](https://github.com/open-mmlab/mmsegmentation/pull/992))
-- Fix the invalid link ([#985](https://github.com/open-mmlab/mmsegmentation/pull/985))
-- Fix bug in CI with python 3.9 ([#994](https://github.com/open-mmlab/mmsegmentation/pull/994))
-- Fix bug when loading class name form file in custom dataset ([#923](https://github.com/open-mmlab/mmsegmentation/pull/923))
-
-**Contributors**
-
-- @ShoupingShan made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/923
-- @RockeyCoss made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/954
-- @HarborYuan made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/992
-- @lkm2835 made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/1003
-- @gszh made their first contribution in https://github.com/open-mmlab/mmsegmentation/pull/428
-- @VVsssssk
-- @MengzhangLI
-- @Junjun2016
-
-### V0.18 (10/07/2021)
-
-**Highlights**
-
-- Support three real-time segmentation models (ICNet [#884](https://github.com/open-mmlab/mmsegmentation/pull/884), BiSeNetV1 [#851](https://github.com/open-mmlab/mmsegmentation/pull/851), and BiSeNetV2 [#804](https://github.com/open-mmlab/mmsegmentation/pull/804))
-- Support one efficient segmentation model (FastFCN [#885](https://github.com/open-mmlab/mmsegmentation/pull/885))
-- Support one efficient non-local/self-attention based segmentation model (ISANet [#70](https://github.com/open-mmlab/mmsegmentation/pull/70))
-- Support COCO-Stuff 10k and 164k datasets ([#625](https://github.com/open-mmlab/mmsegmentation/pull/625))
-- Support evaluate concated dataset separately ([#833](https://github.com/open-mmlab/mmsegmentation/pull/833))
-- Support loading GT for evaluation from multi-file backend ([#867](https://github.com/open-mmlab/mmsegmentation/pull/867))
-
-**New Features**
-
-- Support three real-time segmentation models (ICNet [#884](https://github.com/open-mmlab/mmsegmentation/pull/884), BiSeNetV1 [#851](https://github.com/open-mmlab/mmsegmentation/pull/851), and BiSeNetV2 [#804](https://github.com/open-mmlab/mmsegmentation/pull/804))
-- Support one efficient segmentation model (FastFCN [#885](https://github.com/open-mmlab/mmsegmentation/pull/885))
-- Support one efficient non-local/self-attention based segmentation model (ISANet [#70](https://github.com/open-mmlab/mmsegmentation/pull/70))
-- Support COCO-Stuff 10k and 164k datasets ([#625](https://github.com/open-mmlab/mmsegmentation/pull/625))
-- Support evaluate concated dataset separately ([#833](https://github.com/open-mmlab/mmsegmentation/pull/833))
-
-**Improvements**
-
-- Support loading GT for evaluation from multi-file backend ([#867](https://github.com/open-mmlab/mmsegmentation/pull/867))
-- Auto-convert SyncBN to BN when training on DP automatly([#772](https://github.com/open-mmlab/mmsegmentation/pull/772))
-- Refactor Swin-Transformer ([#800](https://github.com/open-mmlab/mmsegmentation/pull/800))
-
-**Bug Fixes**
-
-- Update mmcv installation in dockerfile ([#860](https://github.com/open-mmlab/mmsegmentation/pull/860))
-- Fix number of iteration bug when resuming checkpoint in distributed train ([#866](https://github.com/open-mmlab/mmsegmentation/pull/866))
-- Fix parsing parse in val_step ([#906](https://github.com/open-mmlab/mmsegmentation/pull/906))
-
-### V0.17 (09/01/2021)
-
-**Highlights**
-
-- Support SegFormer
-- Support DPT
-- Support Dark Zurich and Nighttime Driving datasets
-- Support progressive evaluation
-
-**New Features**
-
-- Support SegFormer ([#599](https://github.com/open-mmlab/mmsegmentation/pull/599))
-- Support DPT ([#605](https://github.com/open-mmlab/mmsegmentation/pull/605))
-- Support Dark Zurich and Nighttime Driving datasets ([#815](https://github.com/open-mmlab/mmsegmentation/pull/815))
-- Support progressive evaluation ([#709](https://github.com/open-mmlab/mmsegmentation/pull/709))
-
-**Improvements**
-
-- Add multiscale_output interface and unittests for HRNet ([#830](https://github.com/open-mmlab/mmsegmentation/pull/830))
-- Support inherit cityscapes dataset ([#750](https://github.com/open-mmlab/mmsegmentation/pull/750))
-- Fix some typos in README.md ([#824](https://github.com/open-mmlab/mmsegmentation/pull/824))
-- Delete convert function and add instruction to ViT/Swin README.md ([#791](https://github.com/open-mmlab/mmsegmentation/pull/791))
-- Add vit/swin/mit convert weight scripts ([#783](https://github.com/open-mmlab/mmsegmentation/pull/783))
-- Add copyright files ([#796](https://github.com/open-mmlab/mmsegmentation/pull/796))
-
-**Bug Fixes**
-
-- Fix invalid checkpoint link in inference_demo.ipynb ([#814](https://github.com/open-mmlab/mmsegmentation/pull/814))
-- Ensure that items in dataset have the same order across multi machine ([#780](https://github.com/open-mmlab/mmsegmentation/pull/780))
-- Fix the log error ([#766](https://github.com/open-mmlab/mmsegmentation/pull/766))
-
-### V0.16 (08/04/2021)
-
-**Highlights**
-
-- Support PyTorch 1.9
-- Support SegFormer backbone MiT
-- Support md2yml pre-commit hook
-- Support frozen stage for HRNet
-
-**New Features**
-
-- Support SegFormer backbone MiT ([#594](https://github.com/open-mmlab/mmsegmentation/pull/594))
-- Support md2yml pre-commit hook ([#732](https://github.com/open-mmlab/mmsegmentation/pull/732))
-- Support mim ([#717](https://github.com/open-mmlab/mmsegmentation/pull/717))
-- Add mmseg2torchserve tool ([#552](https://github.com/open-mmlab/mmsegmentation/pull/552))
-
-**Improvements**
-
-- Support hrnet frozen stage ([#743](https://github.com/open-mmlab/mmsegmentation/pull/743))
-- Add template of reimplementation questions ([#741](https://github.com/open-mmlab/mmsegmentation/pull/741))
-- Output pdf and epub formats for readthedocs ([#742](https://github.com/open-mmlab/mmsegmentation/pull/742))
-- Refine the docstring of ResNet ([#723](https://github.com/open-mmlab/mmsegmentation/pull/723))
-- Replace interpolate with resize ([#731](https://github.com/open-mmlab/mmsegmentation/pull/731))
-- Update resource limit ([#700](https://github.com/open-mmlab/mmsegmentation/pull/700))
-- Update config.md ([#678](https://github.com/open-mmlab/mmsegmentation/pull/678))
-
-**Bug Fixes**
-
-- Fix ATTENTION registry ([#729](https://github.com/open-mmlab/mmsegmentation/pull/729))
-- Fix analyze log script ([#716](https://github.com/open-mmlab/mmsegmentation/pull/716))
-- Fix doc api display ([#725](https://github.com/open-mmlab/mmsegmentation/pull/725))
-- Fix patch_embed and pos_embed mismatch error ([#685](https://github.com/open-mmlab/mmsegmentation/pull/685))
-- Fix efficient test for multi-node ([#707](https://github.com/open-mmlab/mmsegmentation/pull/707))
-- Fix init_cfg in resnet backbone ([#697](https://github.com/open-mmlab/mmsegmentation/pull/697))
-- Fix efficient test bug ([#702](https://github.com/open-mmlab/mmsegmentation/pull/702))
-- Fix url error in config docs ([#680](https://github.com/open-mmlab/mmsegmentation/pull/680))
-- Fix mmcv installation ([#676](https://github.com/open-mmlab/mmsegmentation/pull/676))
-- Fix torch version ([#670](https://github.com/open-mmlab/mmsegmentation/pull/670))
-
-**Contributors**
-
-@sshuair @xiexinch @Junjun2016 @mmeendez8 @xvjiarui @sennnnn @puhsu @BIGWangYuDong @keke1u @daavoo
-
-### V0.15 (07/04/2021)
-
-**Highlights**
-
-- Support ViT, SETR, and Swin-Transformer
-- Add Chinese documentation
-- Unified parameter initialization
-
-**Bug Fixes**
-
-- Fix typo and links ([#608](https://github.com/open-mmlab/mmsegmentation/pull/608))
-- Fix Dockerfile ([#607](https://github.com/open-mmlab/mmsegmentation/pull/607))
-- Fix ViT init ([#609](https://github.com/open-mmlab/mmsegmentation/pull/609))
-- Fix mmcv version compatible table ([#658](https://github.com/open-mmlab/mmsegmentation/pull/658))
-- Fix model links of DMNEt ([#660](https://github.com/open-mmlab/mmsegmentation/pull/660))
-
-**New Features**
-
-- Support loading DeiT weights ([#538](https://github.com/open-mmlab/mmsegmentation/pull/538))
-- Support SETR ([#531](https://github.com/open-mmlab/mmsegmentation/pull/531), [#635](https://github.com/open-mmlab/mmsegmentation/pull/635))
-- Add config and models for ViT backbone with UperHead ([#520](https://github.com/open-mmlab/mmsegmentation/pull/531), [#635](https://github.com/open-mmlab/mmsegmentation/pull/520))
-- Support Swin-Transformer ([#511](https://github.com/open-mmlab/mmsegmentation/pull/511))
-- Add higher accuracy FastSCNN ([#606](https://github.com/open-mmlab/mmsegmentation/pull/606))
-- Add Chinese documentation ([#666](https://github.com/open-mmlab/mmsegmentation/pull/666))
-
-**Improvements**
-
-- Unified parameter initialization ([#567](https://github.com/open-mmlab/mmsegmentation/pull/567))
-- Separate CUDA and CPU in  github action CI ([#602](https://github.com/open-mmlab/mmsegmentation/pull/602))
-- Support persistent dataloader worker ([#646](https://github.com/open-mmlab/mmsegmentation/pull/646))
-- Update meta file fields ([#661](https://github.com/open-mmlab/mmsegmentation/pull/661), [#664](https://github.com/open-mmlab/mmsegmentation/pull/664))
-
-### V0.14 (06/02/2021)
-
-**Highlights**
-
-- Support ONNX to TensorRT
-- Support MIM
-
-**Bug Fixes**
-
-- Fix ONNX to TensorRT verify ([#547](https://github.com/open-mmlab/mmsegmentation/pull/547))
-- Fix save best for EvalHook ([#575](https://github.com/open-mmlab/mmsegmentation/pull/575))
-
-**New Features**
-
-- Support loading DeiT weights ([#538](https://github.com/open-mmlab/mmsegmentation/pull/538))
-- Support ONNX to TensorRT ([#542](https://github.com/open-mmlab/mmsegmentation/pull/542))
-- Support output results for ADE20k ([#544](https://github.com/open-mmlab/mmsegmentation/pull/544))
-- Support MIM ([#549](https://github.com/open-mmlab/mmsegmentation/pull/549))
-
-**Improvements**
-
-- Add option for ViT output shape ([#530](https://github.com/open-mmlab/mmsegmentation/pull/530))
-- Infer batch size using len(result) ([#532](https://github.com/open-mmlab/mmsegmentation/pull/532))
-- Add compatible table between MMSeg and MMCV ([#558](https://github.com/open-mmlab/mmsegmentation/pull/558))
-
-### V0.13 (05/05/2021)
-
-**Highlights**
-
-- Support Pascal Context Class-59 dataset.
-- Support Visual Transformer Backbone.
-- Support mFscore metric.
-
-**Bug Fixes**
-
-- Fixed Colaboratory tutorial ([#451](https://github.com/open-mmlab/mmsegmentation/pull/451))
-- Fixed mIoU calculation range ([#471](https://github.com/open-mmlab/mmsegmentation/pull/471))
-- Fixed sem_fpn, unet README.md ([#492](https://github.com/open-mmlab/mmsegmentation/pull/492))
-- Fixed `num_classes` in FCN for Pascal Context 60-class dataset ([#488](https://github.com/open-mmlab/mmsegmentation/pull/488))
-- Fixed FP16 inference ([#497](https://github.com/open-mmlab/mmsegmentation/pull/497))
-
-**New Features**
-
-- Support dynamic export and visualize to pytorch2onnx ([#463](https://github.com/open-mmlab/mmsegmentation/pull/463))
-- Support export to torchscript ([#469](https://github.com/open-mmlab/mmsegmentation/pull/469), [#499](https://github.com/open-mmlab/mmsegmentation/pull/499))
-- Support Pascal Context Class-59 dataset ([#459](https://github.com/open-mmlab/mmsegmentation/pull/459))
-- Support Visual Transformer backbone ([#465](https://github.com/open-mmlab/mmsegmentation/pull/465))
-- Support UpSample Neck ([#512](https://github.com/open-mmlab/mmsegmentation/pull/512))
-- Support mFscore metric ([#509](https://github.com/open-mmlab/mmsegmentation/pull/509))
-
-**Improvements**
-
-- Add more CI for PyTorch ([#460](https://github.com/open-mmlab/mmsegmentation/pull/460))
-- Add print model graph args for tools/print_config.py ([#451](https://github.com/open-mmlab/mmsegmentation/pull/451))
-- Add cfg links in modelzoo README.md ([#468](https://github.com/open-mmlab/mmsegmentation/pull/469))
-- Add BaseSegmentor import to segmentors/__init__.py ([#495](https://github.com/open-mmlab/mmsegmentation/pull/495))
-- Add MMOCR, MMGeneration links ([#501](https://github.com/open-mmlab/mmsegmentation/pull/501), [#506](https://github.com/open-mmlab/mmsegmentation/pull/506))
-- Add Chinese QR code ([#506](https://github.com/open-mmlab/mmsegmentation/pull/506))
-- Use MMCV MODEL_REGISTRY ([#515](https://github.com/open-mmlab/mmsegmentation/pull/515))
-- Add ONNX testing tools ([#498](https://github.com/open-mmlab/mmsegmentation/pull/498))
-- Replace data_dict calling 'img' key to support MMDet3D ([#514](https://github.com/open-mmlab/mmsegmentation/pull/514))
-- Support reading class_weight from file in loss function ([#513](https://github.com/open-mmlab/mmsegmentation/pull/513))
-- Make tags as comment ([#505](https://github.com/open-mmlab/mmsegmentation/pull/505))
-- Use MMCV EvalHook ([#438](https://github.com/open-mmlab/mmsegmentation/pull/438))
-
-### V0.12 (04/03/2021)
-
-**Highlights**
-
-- Support FCN-Dilate 6 model.
-- Support Dice Loss.
-
-**Bug Fixes**
-
-- Fixed PhotoMetricDistortion Doc ([#388](https://github.com/open-mmlab/mmsegmentation/pull/388))
-- Fixed install scripts ([#399](https://github.com/open-mmlab/mmsegmentation/pull/399))
-- Fixed Dice Loss multi-class ([#417](https://github.com/open-mmlab/mmsegmentation/pull/417))
-
-**New Features**
-
-- Support Dice Loss ([#396](https://github.com/open-mmlab/mmsegmentation/pull/396))
-- Add plot logs tool ([#426](https://github.com/open-mmlab/mmsegmentation/pull/426))
-- Add opacity option to show_result ([#425](https://github.com/open-mmlab/mmsegmentation/pull/425))
-- Speed up mIoU metric ([#430](https://github.com/open-mmlab/mmsegmentation/pull/430))
-
-**Improvements**
-
-- Refactor unittest file structure ([#440](https://github.com/open-mmlab/mmsegmentation/pull/440))
-- Fix typos in the repo ([#449](https://github.com/open-mmlab/mmsegmentation/pull/449))
-- Include class-level metrics in the log ([#445](https://github.com/open-mmlab/mmsegmentation/pull/445))
-
-### V0.11 (02/02/2021)
-
-**Highlights**
-
-- Support memory efficient test, add more UNet models.
-
-**Bug Fixes**
-
-- Fixed TTA resize scale ([#334](https://github.com/open-mmlab/mmsegmentation/pull/334))
-- Fixed CI for pip 20.3 ([#307](https://github.com/open-mmlab/mmsegmentation/pull/307))
-- Fixed ADE20k test ([#359](https://github.com/open-mmlab/mmsegmentation/pull/359))
-
-**New Features**
-
-- Support memory efficient test ([#330](https://github.com/open-mmlab/mmsegmentation/pull/330))
-- Add more UNet benchmarks ([#324](https://github.com/open-mmlab/mmsegmentation/pull/324))
-- Support Lovasz Loss ([#351](https://github.com/open-mmlab/mmsegmentation/pull/351))
-
-**Improvements**
-
-- Move train_cfg/test_cfg inside model ([#341](https://github.com/open-mmlab/mmsegmentation/pull/341))
-
-### V0.10 (01/01/2021)
-
-**Highlights**
-
-- Support MobileNetV3, DMNet, APCNet. Add models of ResNet18V1b, ResNet18V1c, ResNet50V1b.
-
-**Bug Fixes**
-
-- Fixed CPU TTA ([#276](https://github.com/open-mmlab/mmsegmentation/pull/276))
-- Fixed CI for pip 20.3 ([#307](https://github.com/open-mmlab/mmsegmentation/pull/307))
-
-**New Features**
-
-- Add ResNet18V1b, ResNet18V1c, ResNet50V1b, ResNet101V1b models ([#316](https://github.com/open-mmlab/mmsegmentation/pull/316))
-- Support MobileNetV3 ([#268](https://github.com/open-mmlab/mmsegmentation/pull/268))
-- Add 4 retinal vessel segmentation benchmark  ([#315](https://github.com/open-mmlab/mmsegmentation/pull/315))
-- Support DMNet ([#313](https://github.com/open-mmlab/mmsegmentation/pull/313))
-- Support APCNet ([#299](https://github.com/open-mmlab/mmsegmentation/pull/299))
-
-**Improvements**
-
-- Refactor Documentation page ([#311](https://github.com/open-mmlab/mmsegmentation/pull/311))
-- Support resize data augmentation according to original image size ([#291](https://github.com/open-mmlab/mmsegmentation/pull/291))
-
-### V0.9 (30/11/2020)
-
-**Highlights**
-
-- Support 4 medical dataset, UNet and CGNet.
-
-**New Features**
-
-- Support RandomRotate transform ([#215](https://github.com/open-mmlab/mmsegmentation/pull/215), [#260](https://github.com/open-mmlab/mmsegmentation/pull/260))
-- Support RGB2Gray transform ([#227](https://github.com/open-mmlab/mmsegmentation/pull/227))
-- Support Rerange transform ([#228](https://github.com/open-mmlab/mmsegmentation/pull/228))
-- Support ignore_index for BCE loss ([#210](https://github.com/open-mmlab/mmsegmentation/pull/210))
-- Add modelzoo statistics ([#263](https://github.com/open-mmlab/mmsegmentation/pull/263))
-- Support Dice evaluation metric ([#225](https://github.com/open-mmlab/mmsegmentation/pull/225))
-- Support Adjust Gamma transform ([#232](https://github.com/open-mmlab/mmsegmentation/pull/232))
-- Support CLAHE transform ([#229](https://github.com/open-mmlab/mmsegmentation/pull/229))
-
-**Bug Fixes**
-
-- Fixed detail API link ([#267](https://github.com/open-mmlab/mmsegmentation/pull/267))
-
-### V0.8 (03/11/2020)
-
-**Highlights**
-
-- Support 4 medical dataset, UNet and CGNet.
-
-**New Features**
-
-- Support customize runner ([#118](https://github.com/open-mmlab/mmsegmentation/pull/118))
-- Support UNet ([#161](https://github.com/open-mmlab/mmsegmentation/pull/162))
-- Support CHASE_DB1, DRIVE, STARE, HRD ([#203](https://github.com/open-mmlab/mmsegmentation/pull/203))
-- Support CGNet ([#223](https://github.com/open-mmlab/mmsegmentation/pull/223))
-
-### V0.7 (07/10/2020)
-
-**Highlights**
-
-- Support Pascal Context dataset and customizing class dataset.
-
-**Bug Fixes**
-
-- Fixed CPU inference ([#153](https://github.com/open-mmlab/mmsegmentation/pull/153))
-
-**New Features**
-
-- Add DeepLab OS16 models ([#154](https://github.com/open-mmlab/mmsegmentation/pull/154))
-- Support Pascal Context dataset ([#133](https://github.com/open-mmlab/mmsegmentation/pull/133))
-- Support customizing dataset classes ([#71](https://github.com/open-mmlab/mmsegmentation/pull/71))
-- Support customizing dataset palette ([#157](https://github.com/open-mmlab/mmsegmentation/pull/157))
-
-**Improvements**
-
-- Support 4D tensor output in ONNX ([#150](https://github.com/open-mmlab/mmsegmentation/pull/150))
-- Remove redundancies in ONNX export ([#160](https://github.com/open-mmlab/mmsegmentation/pull/160))
-- Migrate to MMCV DepthwiseSeparableConv ([#158](https://github.com/open-mmlab/mmsegmentation/pull/158))
-- Migrate to MMCV collect_env ([#137](https://github.com/open-mmlab/mmsegmentation/pull/137))
-- Use img_prefix and seg_prefix for loading ([#153](https://github.com/open-mmlab/mmsegmentation/pull/153))
-
-### V0.6 (10/09/2020)
-
-**Highlights**
-
-- Support new methods i.e. MobileNetV2, EMANet, DNL, PointRend, Semantic FPN, Fast-SCNN, ResNeSt.
-
-**Bug Fixes**
-
-- Fixed sliding inference ONNX export ([#90](https://github.com/open-mmlab/mmsegmentation/pull/90))
-
-**New Features**
-
-- Support MobileNet v2 ([#86](https://github.com/open-mmlab/mmsegmentation/pull/86))
-- Support EMANet ([#34](https://github.com/open-mmlab/mmsegmentation/pull/34))
-- Support DNL ([#37](https://github.com/open-mmlab/mmsegmentation/pull/37))
-- Support PointRend ([#109](https://github.com/open-mmlab/mmsegmentation/pull/109))
-- Support Semantic FPN ([#94](https://github.com/open-mmlab/mmsegmentation/pull/94))
-- Support Fast-SCNN ([#58](https://github.com/open-mmlab/mmsegmentation/pull/58))
-- Support ResNeSt backbone ([#47](https://github.com/open-mmlab/mmsegmentation/pull/47))
-- Support ONNX export (experimental) ([#12](https://github.com/open-mmlab/mmsegmentation/pull/12))
-
-**Improvements**
-
-- Support Upsample in ONNX ([#100](https://github.com/open-mmlab/mmsegmentation/pull/100))
-- Support Windows install (experimental) ([#75](https://github.com/open-mmlab/mmsegmentation/pull/75))
-- Add more OCRNet results ([#20](https://github.com/open-mmlab/mmsegmentation/pull/20))
-- Add PyTorch 1.6 CI ([#64](https://github.com/open-mmlab/mmsegmentation/pull/64))
-- Get version and githash automatically ([#55](https://github.com/open-mmlab/mmsegmentation/pull/55))
-
-### v0.5.1 (11/08/2020)
-
-**Highlights**
-
-- Support FP16 and more generalized OHEM
-
-**Bug Fixes**
-
-- Fixed Pascal VOC conversion script (#19)
-- Fixed OHEM weight assign bug (#54)
-- Fixed palette type when palette is not given (#27)
-
-**New Features**
-
-- Support FP16 (#21)
-- Generalized OHEM (#54)
-
-**Improvements**
-
-- Add load-from flag (#33)
-- Fixed training tricks doc about different learning rates of model (#26)
diff --git a/mmsegmentation/docs/en/notes/faq.md b/mmsegmentation/docs/en/notes/faq.md
deleted file mode 100644
index a3f8099..0000000
--- a/mmsegmentation/docs/en/notes/faq.md
+++ /dev/null
@@ -1,132 +0,0 @@
-# Frequently Asked Questions (FAQ)
-
-We list some common troubles faced by many users and their corresponding solutions here. Feel free to enrich the list if you find any frequent issues and have ways to help others to solve them. If the contents here do not cover your issue, please create an issue using the [provided templates](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/.github/ISSUE_TEMPLATE/error-report.md/) and make sure you fill in all required information in the template.
-
-## Installation
-
-The compatible MMSegmentation, MMCV and MMEngine versions are as below. Please install the correct versions of them to avoid installation issues.
-
-| MMSegmentation version |          MMCV version          | MMEngine version  | MMClassification (optional) version | MMDetection (optional) version |
-| :--------------------: | :----------------------------: | :---------------: | :---------------------------------: | :----------------------------: |
-|     dev-1.x branch     |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
-|      main branch       |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
-|         1.2.2          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
-|         1.2.1          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
-|         1.2.0          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
-|         1.1.2          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
-|         1.1.1          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
-|         1.1.0          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
-|         1.0.0          |        mmcv >= 2.0.0rc4        | MMEngine >= 0.7.1 |           mmcls==1.0.0rc6           |         mmdet >= 3.0.0         |
-|        1.0.0rc6        |        mmcv >= 2.0.0rc4        | MMEngine >= 0.5.0 |           mmcls>=1.0.0rc0           |       mmdet >= 3.0.0rc6        |
-|        1.0.0rc5        |        mmcv >= 2.0.0rc4        | MMEngine >= 0.2.0 |           mmcls>=1.0.0rc0           |        mmdet>=3.0.0rc6         |
-|        1.0.0rc4        |        mmcv == 2.0.0rc3        | MMEngine >= 0.1.0 |           mmcls>=1.0.0rc0           |  mmdet>=3.0.0rc4, \<=3.0.0rc5  |
-|        1.0.0rc3        |        mmcv == 2.0.0rc3        | MMEngine >= 0.1.0 |           mmcls>=1.0.0rc0           |  mmdet>=3.0.0rc4, \<=3.0.0rc5  |
-|        1.0.0rc2        |        mmcv == 2.0.0rc3        | MMEngine >= 0.1.0 |           mmcls>=1.0.0rc0           |  mmdet>=3.0.0rc4, \<=3.0.0rc5  |
-|        1.0.0rc1        | mmcv >= 2.0.0rc1, \<=2.0.0rc3> | MMEngine >= 0.1.0 |           mmcls>=1.0.0rc0           |          Not required          |
-|        1.0.0rc0        | mmcv >= 2.0.0rc1, \<=2.0.0rc3> | MMEngine >= 0.1.0 |           mmcls>=1.0.0rc0           |          Not required          |
-
-Notes:
-
-- MMClassification and MMDetatction are optional for MMSegmentation. If you didn't install them, `ConvNeXt` (required MMClassification) and MaskFormer, Mask2Former (required MMDetection) cannot be used. We recommend to install them with source code. Please refer to [MMClasssication](https://github.com/open-mmlab/mmclassification) and [MMDetection](https://github.com/open-mmlab/mmdetection) for more details about their installation.
-
-- To install MMSegmentation 0.x and master branch, please refer to [the faq 0.x document](https://mmsegmentation.readthedocs.io/en/latest/faq.html#installation) to check compatible versions of MMCV.
-
-- If you have installed an incompatible version of mmcv, please run `pip uninstall mmcv` to uninstall the installed mmcv first. If you have previously installed mmcv-full (which exists in OpenMMLab 1.x), please run `pip uninstall mmcv-full` to uninstall it.
-
-- If "No module named 'mmcv'" appears, please follow the steps below;
-
-  1. Use `pip uninstall mmcv` to uninstall the existing mmcv in the environment.
-  2. Install the corresponding mmcv according to the [installation instructions](https://mmsegmentation.readthedocs.io/en/dev-1.x/get_started.html#best-practices).
-
-## How to know the number of GPUs needed to train the model
-
-- Infer from the name of the config file of the model. You can refer to the `Config Name Style` part of [Learn about Configs](../user_guides/1_config.md). For example, for config file with name `segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py`, `8xb1` means training the model corresponding to it needs 8 GPUs, and the batch size of each GPU is 1.
-- Infer from the log file. Open the log file of the model and search `nGPU` in the file. The number of figures following `nGPU` is the number of GPUs needed to train the model. For instance, searching for `nGPU` in the log file yields the record `nGPU 0,1,2,3,4,5,6,7`, which indicates that eight GPUs are needed to train the model.
-
-## What does the auxiliary head mean
-
-Briefly, it is a deep supervision trick to improve the accuracy. In the training phase, `decode_head` is for decoding semantic segmentation output, `auxiliary_head` is just adding an auxiliary loss, the segmentation result produced by it has no impact to your model's result, it just works in training. You may read this [paper](https://arxiv.org/pdf/1612.01105.pdf) for more information.
-
-## How to output the segmentation mask image when running the test script
-
-In the test script, we provide `--out` argument to control whether output the painted images. Users might run the following command:
-
-```shell
-python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} --out ${OUTPUT_DIR}
-```
-
-## How to handle binary segmentation task
-
-MMSegmentation uses `num_classes` and `out_channels` to control output of last layer `self.conv_seg`. More details could be found [here](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/mmseg/models/decode_heads/decode_head.py).
-
-`num_classes` should be the same as number of types of labels, in binary segmentation task, dataset only has two types of labels: foreground and background, so `num_classes=2`. `out_channels` controls the output channel of last layer of model, it usually equals to `num_classes`.
-But in binary segmentation task, there are two solutions:
-
-- Set `out_channels=2`, using Cross Entropy Loss in training, using `F.softmax()` and `argmax()` to get prediction of each pixel in inference.
-
-- Set `out_channels=1`, using Binary Cross Entropy Loss in training, using `F.sigmoid()` and `threshold` to get prediction of each pixel in inference. `threshold` is set 0.3 as default.
-
-In summary, to implement binary segmentation methods users should modify below parameters in the `decode_head` and `auxiliary_head` configs. Here is a modification example of [pspnet_unet_s5-d16.py](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/_base_/models/pspnet_unet_s5-d16.py):
-
-- (1) `num_classes=2`, `out_channels=2` and `use_sigmoid=False` in `CrossEntropyLoss`.
-
-```python
-decode_head=dict(
-    type='PSPHead',
-    in_channels=64,
-    in_index=4,
-    num_classes=2,
-    out_channels=2,
-    loss_decode=dict(
-        type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-auxiliary_head=dict(
-    type='FCNHead',
-    in_channels=128,
-    in_index=3,
-    num_classes=2,
-    out_channels=2,
-    loss_decode=dict(
-        type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-```
-
-- (2) `num_classes=2`, `out_channels=1` and `use_sigmoid=True` in `CrossEntropyLoss`.
-
-```python
-decode_head=dict(
-    type='PSPHead',
-    in_channels=64,
-    in_index=4,
-    num_classes=2,
-    out_channels=1,
-    loss_decode=dict(
-        type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)),
-auxiliary_head=dict(
-    type='FCNHead',
-    in_channels=128,
-    in_index=3,
-    num_classes=2,
-    out_channels=1,
-    loss_decode=dict(
-        type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.4)),
-```
-
-## Functionality of `reduce_zero_label`
-
-The parameter type of `reduce_zero_label` in dataset is Boolean, which is default to False. It is used to ignore the dataset label 0. The specific method is to change label 0 to 255, and subtract 1 from the corresponding number of all the remaining labels. At the same time, set 255 as ignore index in the decode head, which means that it will not participate in the loss calculation.
-
-Following is the specific implementation logic of `reduce_zero_label`:
-
-```python
-if self.reduce_zero_label:
-    # avoid using underflow conversion
-    gt_semantic_seg[gt_semantic_seg == 0] = 255
-    gt_semantic_seg = gt_semantic_seg - 1
-    gt_semantic_seg[gt_semantic_seg == 254] = 255
-```
-
-Whether your dataset needs to use `reduce_zero_label`, there are two types of situations:
-
-- On [Potsdam](https://github.com/open-mmlab/mmsegmentation/blob/1.x/docs/en/user_guides/2_dataset_prepare.md#isprs-potsdam) dataset, there are six classes: 0-Impervious surfaces, 1-Building, 2-Low vegetation, 3-Tree, 4-Car, 5-Clutter/background. However, this dataset provides two types of RGB labels, one with black pixels at the edges of the images, and the other without. For labels with black edges, in [dataset_converters.py](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/tools/dataset_converters/potsdam.py), it converts the black edges to label 0, and the other labels are 1-Impervious surfaces, 2-Building, 3-Low vegetation, 4-Tree, 5-Car, 6-Clutter/background. Therefore, in the dataset config [potsdam.py](https://github.com/open-mmlab/mmsegmentation/blob/ff95416c3b5ce8d62b9289f743531398efce534f/mmseg/datasets/potsdam.py#L23) `reduce_zero_label=True`。 If you are using labels without black edges, then there are only class 0-5 in the mask label. At this point, you should use `reduce_zero_label=False`. `reduce_zero_label` usage needs to be considered with your actual situation.
-- On a dataset with class 0 as the background class, if you need to separate the background from the rest of your classes ultimately then you do not need to use `reduce_zero_label`, which in the dataset config settings should be `reduce_zero_label=False`
-
-**Note:** Please confirm the number of original classes in the dataset. If there are only two classes, you should not use `reduce_zero_label` which is `reduce_zero_label=False`.
diff --git a/mmsegmentation/docs/en/overview.md b/mmsegmentation/docs/en/overview.md
deleted file mode 100644
index bbc0b8e..0000000
--- a/mmsegmentation/docs/en/overview.md
+++ /dev/null
@@ -1,85 +0,0 @@
-# Overview
-
-This chapter introduces you to the framework of MMSegmentation, and the basic conception of semantic segmentation. It also provides links to detailed tutorials about MMSegmentation.
-
-## What is semantic segmentation?
-
-Semantic segmentation is the task of clustering parts of an image together that belong to the same object class.
-It is a form of pixel-level prediction because each pixel in an image is classified according to a category.
-Some example benchmarks for this task are [Cityscapes](https://www.cityscapes-dataset.com/benchmarks/), [PASCAL VOC](http://host.robots.ox.ac.uk/pascal/VOC/voc2012/) and [ADE20K](https://groups.csail.mit.edu/vision/datasets/ADE20K/).
-Models are usually evaluated with the Mean Intersection-Over-Union (Mean IoU) and Pixel Accuracy metrics.
-
-## What is MMSegmentation?
-
-MMSegmentation is a toolbox that provides a framework for unified implementation and evaluation of semant
-ic segmentation methods,
-and contains high-quality implementations of popular semantic segmentation methods and datasets.
-
-MMSeg consists of 7 main parts including apis, structures, datasets, models, engine, evaluation and visualization.
-
-- **apis** provides high-level APIs for model inference.
-
-- **structures** provides segmentation data structure `SegDataSample`.
-
-- **datasets** supports various datasets for semantic segmentation.
-
-  - **transforms** contains a lot of useful data augmentation transforms.
-
-- **models** is the most vital part for segmentors and contains different components of a segmentor.
-
-  - **segmentors** defines all of the segmentation model classes.
-  - **data_preprocessors** works for preprocessing the input data of the model.
-  - **backbones** contains various backbone networks that transform an image to feature maps.
-  - **necks** contains various neck components that connect the backbone and heads.
-  - **decode_heads** contains various head components that take feature map as input and predict segmentation results.
-  - **losses** contains various loss functions.
-
-- **engine** is a part for runtime components that extends function of [MMEngine](https://github.com/open-mmlab/mmengine).
-
-  - **optimizers** provides optimizers and optimizer wrappers.
-  - **hooks** provides various hooks of the runner.
-
-- **evaluation** provides different metrics for evaluating model performance.
-
-- **visualization** is for visualizing segmentation results.
-
-## How to use this documentation
-
-Here is a detailed step-by-step guide to learn more about MMSegmentation:
-
-1. For installation instructions, please see [get_started](getting_started.md).
-
-2. For beginners, MMSegmentation is the best place to start the journey of semantic segmentation
-   as there are many SOTA and classic segmentation [models](model_zoo.md),
-   and it is easier to carry out a segmentation task by plugging together building blocks and convenient high-level apis.
-   Refer to the tutorials below for the basic usage of MMSegmentation:
-
-   - [Config](user_guides/1_config.md)
-   - [Dataset Preparation](user_guides/2_dataset_prepare.md)
-   - [Inference](user_guides/3_inference.md)
-   - [Train and Test](user_guides/4_train_test.md)
-
-3. If you would like to learn about the fundamental classes and features that make MMSegmentation work,
-   please refer to the tutorials below to dive deeper:
-
-   - [Data flow](advanced_guides/data_flow.md)
-   - [Structures](advanced_guides/structures.md)
-   - [Models](advanced_guides/models.md)
-   - [Datasets](advanced_guides/datasets.md)
-   - [Evaluation](advanced_guides/evaluation.md)
-
-4. MMSegmentation also provide tutorials for customization and advanced research,
-   please refer to the below guides to build your own segmentation project:
-
-   - [Add new models](advanced_guides/add_models.md)
-   - [Add new datasets](advanced_guides/add_datasets.md)
-   - [Add new transforms](advanced_guides/add_transforms.md)
-   - [Customize runtime](advanced_guides/customize_runtime.md)
-
-5. If you are more familiar with MMSegmentation v0.x, there is documentation about migration from MMSegmentation v0.x to v1.x
-
-   - [migration](migration/index.rst)
-
-## References
-
-- [Paper with code](https://paperswithcode.com/task/semantic-segmentation/codeless#task-home)
diff --git a/mmsegmentation/docs/en/stat.py b/mmsegmentation/docs/en/stat.py
deleted file mode 100755
index c458ee3..0000000
--- a/mmsegmentation/docs/en/stat.py
+++ /dev/null
@@ -1,67 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) OpenMMLab. All rights reserved.
-import functools as func
-import glob
-import os.path as osp
-import re
-
-import numpy as np
-
-url_prefix = 'https://github.com/open-mmlab/mmsegmentation/blob/master/'
-
-files = sorted(glob.glob('../../configs/*/README.md'))
-
-stats = []
-titles = []
-num_ckpts = 0
-
-for f in files:
-    url = osp.dirname(f.replace('../../', url_prefix))
-
-    with open(f) as content_file:
-        content = content_file.read()
-
-    title = content.split('\n')[0].replace('#', '').strip()
-    ckpts = {
-        x.lower().strip()
-        for x in re.findall(r'https?://download.*\.pth', content)
-        if 'mmsegmentation' in x
-    }
-    if len(ckpts) == 0:
-        continue
-
-    _papertype = [
-        x for x in re.findall(r'<!--\s*\[([A-Z]*?)\]\s*-->', content)
-    ]
-    assert len(_papertype) > 0
-    papertype = _papertype[0]
-
-    paper = {(papertype, title)}
-
-    titles.append(title)
-    num_ckpts += len(ckpts)
-    statsmsg = f"""
-\t* [{papertype}] [{title}]({url}) ({len(ckpts)} ckpts)
-"""
-    stats.append((paper, ckpts, statsmsg))
-
-allpapers = func.reduce(lambda a, b: a.union(b), [p for p, _, _ in stats])
-msglist = '\n'.join(x for _, _, x in stats)
-
-papertypes, papercounts = np.unique([t for t, _ in allpapers],
-                                    return_counts=True)
-countstr = '\n'.join(
-    [f'   - {t}: {c}' for t, c in zip(papertypes, papercounts)])
-
-modelzoo = f"""
-# Model Zoo Statistics
-
-* Number of papers: {len(set(titles))}
-{countstr}
-
-* Number of checkpoints: {num_ckpts}
-{msglist}
-"""
-
-with open('modelzoo_statistics.md', 'w') as f:
-    f.write(modelzoo)
diff --git a/mmsegmentation/docs/en/switch_language.md b/mmsegmentation/docs/en/switch_language.md
deleted file mode 100644
index f58efc4..0000000
--- a/mmsegmentation/docs/en/switch_language.md
+++ /dev/null
@@ -1,3 +0,0 @@
-## <a href='https://mmsegmentation.readthedocs.io/en/latest/'>English</a>
-
-## <a href='https://mmsegmentation.readthedocs.io/zh_CN/latest/'>简体中文</a>
diff --git a/mmsegmentation/docs/en/user_guides/1_config.md b/mmsegmentation/docs/en/user_guides/1_config.md
deleted file mode 100644
index 291c488..0000000
--- a/mmsegmentation/docs/en/user_guides/1_config.md
+++ /dev/null
@@ -1,588 +0,0 @@
-# Tutorial 1: Learn about Configs
-
-We incorporate modular and inheritance design into our config system, which is convenient to conduct various experiments.
-If you wish to inspect the config file, you may run `python tools/misc/print_config.py /PATH/TO/CONFIG` to see the complete config.
-You may also pass `--cfg-options xxx.yyy=zzz` to see updated config.
-
-## Config File Structure
-
-There are 4 basic component types under `config/_base_`, datasets, models, schedules, default_runtime.
-Many methods could be easily constructed with one of each like DeepLabV3, PSPNet.
-The configs that are composed by components from `_base_` are called _primitive_.
-
-For all configs under the same folder, it is recommended to have only **one** _primitive_ config. All other configs should inherit from the _primitive_ config. In this way, the maximum of inheritance level is 3.
-
-For easy understanding, we recommend contributors to inherit from existing methods.
-For example, if some modification is made base on DeepLabV3, user may first inherit the basic DeepLabV3 structure by specifying `_base_ = ../deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py`, then modify the necessary fields in the config files.
-
-If you are building an entirely new method that does not share the structure with any of the existing methods, you may create a folder `xxxnet` under `configs`,
-
-Please refer to [mmengine](https://mmengine.readthedocs.io/en/latest/tutorials/config.html) for detailed documentation.
-
-## Config Name Style
-
-We follow the below style to name config files. Contributors are advised to follow the same style.
-
-```text
-{algorithm name}_{model component names [component1]_[component2]_[...]}_{training settings}_{training dataset information}_{testing dataset information}
-```
-
-The file name is divided to five parts. All parts and components are connected with `_` and words of each part or component should be connected with `-`.
-
-- `{algorithm name}`: The name of the algorithm, such as `deeplabv3`, `pspnet`, etc.
-- `{model component names}`: Names of the components used in the algorithm such as backbone, head, etc. For example, `r50-d8` means using ResNet50 backbone and use output of backbone is 8 times downsampling as input.
-- `{training settings}`: Information of training settings such as batch size, augmentations, loss, learning rate scheduler, and epochs/iterations. For example: `4xb4-ce-linearlr-40K` means using 4-gpus x 4-images-per-gpu, CrossEntropy loss, Linear learning rate scheduler, and train 40K iterations.
-  Some abbreviations:
-  - `{gpu x batch_per_gpu}`: GPUs and samples per GPU. `bN` indicates N batch size per GPU. E.g. `8xb2` is the short term of 8-gpus x 2-images-per-gpu. And `4xb4` is used by default if not mentioned.
-  - `{schedule}`: training schedule, options are `20k`, `40k`, etc. `20k` and `40k` means 20000 iterations and 40000 iterations respectively.
-- `{training dataset information}`: Training dataset names like `cityscapes`, `ade20k`, etc, and input resolutions. For example: `cityscapes-768x768` means training on `cityscapes` dataset and the input shape is `768x768`.
-- `{testing dataset information}` (optional): Testing dataset name for models trained on one dataset but tested on another. If not mentioned, it means the model was trained and tested on the same dataset type.
-
-## An Example of PSPNet
-
-To help the users have a basic idea of a complete config and the modules in a modern semantic segmentation system,
-we make brief comments on the config of PSPNet using ResNet50V1c as the following.
-For more detailed usage and the corresponding alternative for each module, please refer to the API documentation.
-
-```python
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-] # base config file which we build new config file on.
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
-```
-
-`_base_/models/pspnet_r50-d8.py` is a basic model cfg file for PSPNet using ResNet50V1c
-
-```python
-# model settings
-norm_cfg = dict(type='SyncBN', requires_grad=True)  # Segmentation usually uses SyncBN
-data_preprocessor = dict(  # The config of data preprocessor, usually includes image normalization and augmentation.
-    type='SegDataPreProcessor',  # The type of data preprocessor.
-    mean=[123.675, 116.28, 103.53],  # Mean values used for normalizing the input images.
-    std=[58.395, 57.12, 57.375],  # Standard variance used for normalizing the input images.
-    bgr_to_rgb=True,  # Whether to convert image from BGR to RGB.
-    pad_val=0,  # Padding value of image.
-    seg_pad_val=255)  # Padding value of segmentation map.
-model = dict(
-    type='EncoderDecoder',  # Name of segmentor
-    data_preprocessor=data_preprocessor,
-    pretrained='open-mmlab://resnet50_v1c',  # The ImageNet pretrained backbone to be loaded
-    backbone=dict(
-        type='ResNetV1c',  # The type of backbone. Please refer to mmseg/models/backbones/resnet.py for details.
-        depth=50,  # Depth of backbone. Normally 50, 101 are used.
-        num_stages=4,  # Number of stages of backbone.
-        out_indices=(0, 1, 2, 3),  # The index of output feature maps produced in each stages.
-        dilations=(1, 1, 2, 4),  # The dilation rate of each layer.
-        strides=(1, 2, 1, 1),  # The stride of each layer.
-        norm_cfg=norm_cfg,  # The configuration of norm layer.
-        norm_eval=False,  # Whether to freeze the statistics in BN
-        style='pytorch',  # The style of backbone, 'pytorch' means that stride 2 layers are in 3x3 conv, 'caffe' means stride 2 layers are in 1x1 convs.
-        contract_dilation=True),  # When dilation > 1, whether contract first layer of dilation.
-    decode_head=dict(
-        type='PSPHead',  # Type of decode head. Please refer to mmseg/models/decode_heads for available options.
-        in_channels=2048,  # Input channel of decode head.
-        in_index=3,  # The index of feature map to select.
-        channels=512,  # The intermediate channels of decode head.
-        pool_scales=(1, 2, 3, 6),  # The avg pooling scales of PSPHead. Please refer to paper for details.
-        dropout_ratio=0.1,  # The dropout ratio before final classification layer.
-        num_classes=19,  # Number of segmentation class. Usually 19 for cityscapes, 21 for VOC, 150 for ADE20k.
-        norm_cfg=norm_cfg,  # The configuration of norm layer.
-        align_corners=False,  # The align_corners argument for resize in decoding.
-        loss_decode=dict(  # Config of loss function for the decode_head.
-            type='CrossEntropyLoss',  # Type of loss used for segmentation.
-            use_sigmoid=False,  # Whether use sigmoid activation for segmentation.
-            loss_weight=1.0)),  # Loss weight of decode_head.
-    auxiliary_head=dict(
-        type='FCNHead',  # Type of auxiliary head. Please refer to mmseg/models/decode_heads for available options.
-        in_channels=1024,  # Input channel of auxiliary head.
-        in_index=2,  # The index of feature map to select.
-        channels=256,  # The intermediate channels of decode head.
-        num_convs=1,  # Number of convs in FCNHead. It is usually 1 in auxiliary head.
-        concat_input=False,  # Whether concat output of convs with input before classification layer.
-        dropout_ratio=0.1,  # The dropout ratio before final classification layer.
-        num_classes=19,  # Number of segmentation class. Usually 19 for cityscapes, 21 for VOC, 150 for ADE20k.
-        norm_cfg=norm_cfg,  # The configuration of norm layer.
-        align_corners=False,  # The align_corners argument for resize in decoding.
-        loss_decode=dict(  # Config of loss function for the auxiliary_head.
-            type='CrossEntropyLoss',  # Type of loss used for segmentation.
-            use_sigmoid=False,  # Whether use sigmoid activation for segmentation.
-            loss_weight=0.4)),  # Loss weight of auxiliary_head.
-    # model training and testing settings
-    train_cfg=dict(),  # train_cfg is just a place holder for now.
-    test_cfg=dict(mode='whole'))  # The test mode, options are 'whole' and 'slide'. 'whole': whole image fully-convolutional test. 'slide': sliding crop window on the image.
-```
-
-`_base_/datasets/cityscapes.py` is the configuration file of the dataset
-
-```python
-# dataset settings
-dataset_type = 'CityscapesDataset'  # Dataset type, this will be used to define the dataset.
-data_root = 'data/cityscapes/'  # Root path of data.
-crop_size = (512, 1024)  # The crop size during training.
-train_pipeline = [  # Training pipeline.
-    dict(type='LoadImageFromFile'),  # First pipeline to load images from file path.
-    dict(type='LoadAnnotations'),  # Second pipeline to load annotations for current image.
-    dict(type='RandomResize',  # Augmentation pipeline that resize the images and their annotations.
-        scale=(2048, 1024),  # The scale of image.
-        ratio_range=(0.5, 2.0),  # The augmented scale range as ratio.
-        keep_ratio=True),  # Whether to keep the aspect ratio when resizing the image.
-    dict(type='RandomCrop',  # Augmentation pipeline that randomly crop a patch from current image.
-        crop_size=crop_size,  # The crop size of patch.
-        cat_max_ratio=0.75),  # The max area ratio that could be occupied by single category.
-    dict(type='RandomFlip',  # Augmentation pipeline that flip the images and their annotations
-        prob=0.5),  # The ratio or probability to flip
-    dict(type='PhotoMetricDistortion'),  # Augmentation pipeline that distort current image with several photo metric methods.
-    dict(type='PackSegInputs')  # Pack the inputs data for the semantic segmentation.
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),  # First pipeline to load images from file path
-    dict(type='Resize',  # Use resize augmentation
-        scale=(2048, 1024),  # Images scales for resizing.
-        keep_ratio=True),  # Whether to keep the aspect ratio when resizing the image.
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations'),  # Load annotations for semantic segmentation provided by dataset.
-    dict(type='PackSegInputs')  # Pack the inputs data for the semantic segmentation.
-]
-train_dataloader = dict(  # Train dataloader config
-    batch_size=2,  # Batch size of a single GPU
-    num_workers=2,  # Worker to pre-fetch data for each single GPU
-    persistent_workers=True,  # Shut down the worker processes after an epoch end, which can accelerate training speed.
-    sampler=dict(type='InfiniteSampler', shuffle=True),  # Randomly shuffle during training.
-    dataset=dict(  # Train dataset config
-        type=dataset_type,  # Type of dataset, refer to mmseg/datasets/ for details.
-        data_root=data_root,  # The root of dataset.
-        data_prefix=dict(
-            img_path='leftImg8bit/train', seg_map_path='gtFine/train'),  # Prefix for training data.
-        pipeline=train_pipeline)) # Processing pipeline. This is passed by the train_pipeline created before.
-val_dataloader = dict(
-    batch_size=1,  # Batch size of a single GPU
-    num_workers=4,  # Worker to pre-fetch data for each single GPU
-    persistent_workers=True,  # Shut down the worker processes after an epoch end, which can accelerate testing speed.
-    sampler=dict(type='DefaultSampler', shuffle=False),  # Not shuffle during validation and testing.
-    dataset=dict(  # Test dataset config
-        type=dataset_type,  # Type of dataset, refer to mmseg/datasets/ for details.
-        data_root=data_root,  # The root of dataset.
-        data_prefix=dict(
-            img_path='leftImg8bit/val', seg_map_path='gtFine/val'),  # Prefix for testing data.
-        pipeline=test_pipeline))  # Processing pipeline. This is passed by the test_pipeline created before.
-test_dataloader = val_dataloader
-# The metric to measure the accuracy. Here, we use IoUMetric.
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
-test_evaluator = val_evaluator
-```
-
-`_base_/schedules/schedule_40k.py`
-
-```python
-# optimizer
-optimizer = dict(type='SGD', # Type of optimizers, refer to https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py for more details
-                lr=0.01,  # Learning rate of optimizers, see detail usages of the parameters in the documentation of PyTorch
-                momentum=0.9,  # Momentum
-                weight_decay=0.0005)  # Weight decay of SGD
-optim_wrapper = dict(type='OptimWrapper',  # Optimizer wrapper provides a common interface for updating parameters.
-                    optimizer=optimizer,  # Optimizer used to update model parameters.
-                    clip_grad=None)  # If ``clip_grad`` is not None, it will be the arguments of ``torch.nn.utils.clip_grad``.
-# learning policy
-param_scheduler = [
-    dict(
-        type='PolyLR',  # The policy of scheduler, also support Step, CosineAnnealing, Cyclic, etc. Refer to details of supported LrUpdater from https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/scheduler/lr_scheduler.py
-        eta_min=1e-4,  # Minimum learning rate at the end of scheduling.
-        power=0.9,  # The power of polynomial decay.
-        begin=0,  # Step at which to start updating the parameters.
-        end=40000,  # Step at which to stop updating the parameters.
-        by_epoch=False)  # Whether count by epoch or not.
-]
-# training schedule for 40k iteration
-train_cfg = dict(type='IterBasedTrainLoop', max_iters=40000, val_interval=4000)
-val_cfg = dict(type='ValLoop')
-test_cfg = dict(type='TestLoop')
-# default hooks
-default_hooks = dict(
-    timer=dict(type='IterTimerHook'),  # Log the time spent during iteration.
-    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),  # Collect and write logs from different components of ``Runner``.
-    param_scheduler=dict(type='ParamSchedulerHook'),  # update some hyper-parameters in optimizer, e.g., learning rate.
-    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=4000),  # Save checkpoints periodically.
-    sampler_seed=dict(type='DistSamplerSeedHook'))  # Data-loading sampler for distributed training.
-```
-
-in `_base_/default_runtime.py`
-
-```python
-# Set the default scope of the registry to mmseg.
-default_scope = 'mmseg'
-# environment
-env_cfg = dict(
-    cudnn_benchmark=True,
-    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
-    dist_cfg=dict(backend='nccl'),
-)
-log_level = 'INFO'
-log_processor = dict(by_epoch=False)
-load_from = None  # Load checkpoint from file.
-resume = False  # Whether to resume from existed model.
-```
-
-These are all the configs for training and testing PSPNet, to load and parse them, we can use [Config](https://mmengine.readthedocs.io/en/latest/tutorials/config.html) implemented in [MMEngine](https://github.com/open-mmlab/mmengine)
-
-```python
-from mmengine.config import Config
-
-cfg = Config.fromfile('configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py')
-print(cfg.train_dataloader)
-```
-
-```shell
-{'batch_size': 2,
- 'num_workers': 2,
- 'persistent_workers': True,
- 'sampler': {'type': 'InfiniteSampler', 'shuffle': True},
- 'dataset': {'type': 'CityscapesDataset',
-  'data_root': 'data/cityscapes/',
-  'data_prefix': {'img_path': 'leftImg8bit/train',
-   'seg_map_path': 'gtFine/train'},
-  'pipeline': [{'type': 'LoadImageFromFile'},
-   {'type': 'LoadAnnotations'},
-   {'type': 'RandomResize',
-    'scale': (2048, 1024),
-    'ratio_range': (0.5, 2.0),
-    'keep_ratio': True},
-   {'type': 'RandomCrop', 'crop_size': (512, 1024), 'cat_max_ratio': 0.75},
-   {'type': 'RandomFlip', 'prob': 0.5},
-   {'type': 'PhotoMetricDistortion'},
-   {'type': 'PackSegInputs'}]}}
-```
-
-`cfg` is an instance of `mmengine.config.Config`, its interface is the same as a dict object and also allows access config values as attributes. See [config tutorial](https://mmengine.readthedocs.io/en/latest/tutorials/config.html) in [MMEngine](https://github.com/open-mmlab/mmengine) for more information.
-
-## FAQ
-
-### Ignore some fields in the base configs
-
-Sometimes, you may set `_delete_=True` to ignore some of the fields in base configs.
-See [config tutorial](https://mmengine.readthedocs.io/en/latest/tutorials/config.html) in [MMEngine](https://github.com/open-mmlab/mmengine) for simple illustration.
-
-In MMSegmentation, for example, if you would like to modify the backbone of PSPNet with the following config file `pspnet.py`:
-
-```python
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    type='EncoderDecoder',
-    pretrained='torchvision://resnet50',
-    backbone=dict(
-        type='ResNetV1c',
-        depth=50,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        dilations=(1, 1, 2, 4),
-        strides=(1, 2, 1, 1),
-        norm_cfg=norm_cfg,
-        norm_eval=False,
-        style='pytorch',
-        contract_dilation=True),
-    decode_head=dict(
-        type='PSPHead',
-        in_channels=2048,
-        in_index=3,
-        channels=512,
-        pool_scales=(1, 2, 3, 6),
-        dropout_ratio=0.1,
-        num_classes=19,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)))
-```
-
-Load and parse the config file `pspnet.py` in the code as follows:
-
-```python
-from mmengine.config import Config
-
-cfg = Config.fromfile('pspnet.py')
-print(cfg.model)
-```
-
-```shell
-{'type': 'EncoderDecoder',
- 'pretrained': 'torchvision://resnet50',
- 'backbone': {'type': 'ResNetV1c',
-  'depth': 50,
-  'num_stages': 4,
-  'out_indices': (0, 1, 2, 3),
-  'dilations': (1, 1, 2, 4),
-  'strides': (1, 2, 1, 1),
-  'norm_cfg': {'type': 'SyncBN', 'requires_grad': True},
-  'norm_eval': False,
-  'style': 'pytorch',
-  'contract_dilation': True},
- 'decode_head': {'type': 'PSPHead',
-  'in_channels': 2048,
-  'in_index': 3,
-  'channels': 512,
-  'pool_scales': (1, 2, 3, 6),
-  'dropout_ratio': 0.1,
-  'num_classes': 19,
-  'norm_cfg': {'type': 'SyncBN', 'requires_grad': True},
-  'align_corners': False,
-  'loss_decode': {'type': 'CrossEntropyLoss',
-   'use_sigmoid': False,
-   'loss_weight': 1.0}}}
-```
-
-`ResNet` and `HRNet` use different keywords to construct, write a new config file `hrnet.py` as follows:
-
-```python
-_base_ = 'pspnet.py'
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w32',
-    backbone=dict(
-        _delete_=True,
-        type='HRNet',
-        norm_cfg=norm_cfg,
-        extra=dict(
-            stage1=dict(
-                num_modules=1,
-                num_branches=1,
-                block='BOTTLENECK',
-                num_blocks=(4, ),
-                num_channels=(64, )),
-            stage2=dict(
-                num_modules=1,
-                num_branches=2,
-                block='BASIC',
-                num_blocks=(4, 4),
-                num_channels=(32, 64)),
-            stage3=dict(
-                num_modules=4,
-                num_branches=3,
-                block='BASIC',
-                num_blocks=(4, 4, 4),
-                num_channels=(32, 64, 128)),
-            stage4=dict(
-                num_modules=3,
-                num_branches=4,
-                block='BASIC',
-                num_blocks=(4, 4, 4, 4),
-                num_channels=(32, 64, 128, 256)))))
-```
-
-Load and parse the config file `hrnet.py` in the code as follows:
-
-```python
-from mmengine.config import Config
-cfg = Config.fromfile('hrnet.py')
-print(cfg.model)
-```
-
-```shell
-{'type': 'EncoderDecoder',
- 'pretrained': 'open-mmlab://msra/hrnetv2_w32',
- 'backbone': {'type': 'HRNet',
-  'norm_cfg': {'type': 'SyncBN', 'requires_grad': True},
-  'extra': {'stage1': {'num_modules': 1,
-    'num_branches': 1,
-    'block': 'BOTTLENECK',
-    'num_blocks': (4,),
-    'num_channels': (64,)},
-   'stage2': {'num_modules': 1,
-    'num_branches': 2,
-    'block': 'BASIC',
-    'num_blocks': (4, 4),
-    'num_channels': (32, 64)},
-   'stage3': {'num_modules': 4,
-    'num_branches': 3,
-    'block': 'BASIC',
-    'num_blocks': (4, 4, 4),
-    'num_channels': (32, 64, 128)},
-   'stage4': {'num_modules': 3,
-    'num_branches': 4,
-    'block': 'BASIC',
-    'num_blocks': (4, 4, 4, 4),
-    'num_channels': (32, 64, 128, 256)}}},
- 'decode_head': {'type': 'PSPHead',
-  'in_channels': 2048,
-  'in_index': 3,
-  'channels': 512,
-  'pool_scales': (1, 2, 3, 6),
-  'dropout_ratio': 0.1,
-  'num_classes': 19,
-  'norm_cfg': {'type': 'SyncBN', 'requires_grad': True},
-  'align_corners': False,
-  'loss_decode': {'type': 'CrossEntropyLoss',
-   'use_sigmoid': False,
-   'loss_weight': 1.0}}}
-```
-
-The `_delete_=True` would replace all old keys in `backbone` field with new keys.
-
-### Use intermediate variables in configs
-
-Some intermediate variables are used in the configs files, like `train_pipeline`/`test_pipeline` in datasets.
-It's worth noting that when modifying intermediate variables in the children configs, user need to pass the intermediate variables into corresponding fields again.
-For example, we would like to change multi scale strategy to train/test a PSPNet. `train_pipeline`/`test_pipeline` are intermediate variable we would like to modify.
-
-```python
-_base_ = '../pspnet/pspnet_r50-d8_4xb4-40k_cityscpaes-512x1024.py'
-crop_size = (512, 1024)
-img_norm_cfg = dict(
-    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='RandomResize',
-         img_scale=(2048, 1024),
-         ratio_range=(1., 2.),
-         keep_ration=True),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', flip_ratio=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs'),
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize',
-        scale=(2048, 1024),
-        keep_ratio=True),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='leftImg8bit/train', seg_map_path='gtFine/train'),
-        pipeline=train_pipeline)
-test_dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='leftImg8bit/val', seg_map_path='gtFine/val'),
-        pipeline=test_pipeline)
-train_dataloader = dict(dataset=train_dataset)
-val_dataloader = dict(dataset=test_dataset)
-test_dataloader = val_dataloader
-```
-
-We first define the new `train_pipeline`/`test_pipeline` and pass them into `dataset`.
-
-Similarly, if we would like to switch from `SyncBN` to `BN` or `MMSyncBN`, we need to substitute every `norm_cfg` in the config.
-
-```python
-_base_ = '../pspnet/pspnet_r50-d8_4xb4-40k_cityscpaes-512x1024.py'
-norm_cfg = dict(type='BN', requires_grad=True)
-model = dict(
-    backbone=dict(norm_cfg=norm_cfg),
-    decode_head=dict(norm_cfg=norm_cfg),
-    auxiliary_head=dict(norm_cfg=norm_cfg))
-```
-
-## Modify config through script arguments
-
-In the [training script](https://github.com/open-mmlab/mmsegmentation/blob/1.x/tools/train.py) and the [testing script](https://github.com/open-mmlab/mmsegmentation/blob/1.x/tools/test.py), we support the script argument `--cfg-options`, it may help users override some settings in the used config, the key-value pair in `xxx=yyy` format will be merged into config file.
-
-For example, this is a simplified script `demo_script.py`:
-
-```python
-import argparse
-
-from mmengine.config import Config, DictAction
-
-def parse_args():
-    parser = argparse.ArgumentParser(description='Script Example')
-    parser.add_argument('config', help='train config file path')
-    parser.add_argument(
-        '--cfg-options',
-        nargs='+',
-        action=DictAction,
-        help='override some settings in the used config, the key-value pair '
-        'in xxx=yyy format will be merged into config file. If the value to '
-        'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
-        'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
-        'Note that the quotation marks are necessary and that no white space '
-        'is allowed.')
-    args = parser.parse_args()
-    return args
-
-def main():
-    args = parse_args()
-
-    cfg = Config.fromfile(args.config)
-    if args.cfg_options is not None:
-        cfg.merge_from_dict(args.cfg_options)
-
-    print(cfg)
-
-if __name__ == '__main__':
-    main()
-```
-
-An example config file `demo_config.py` as follows:
-
-```python
-backbone = dict(
-    type='ResNetV1c',
-    depth=50,
-    num_stages=4,
-    out_indices=(0, 1, 2, 3),
-    dilations=(1, 1, 2, 4),
-    strides=(1, 2, 1, 1),
-    norm_eval=False,
-    style='pytorch',
-    contract_dilation=True)
-```
-
-Run `demo_script.py`:
-
-```shell
-python demo_script.py demo_config.py
-```
-
-```shell
-Config (path: demo_config.py): {'backbone': {'type': 'ResNetV1c', 'depth': 50, 'num_stages': 4, 'out_indices': (0, 1, 2, 3), 'dilations': (1, 1, 2, 4), 'strides': (1, 2, 1, 1), 'norm_eval': False, 'style': 'pytorch', 'contract_dilation': True}}
-```
-
-Modify config through script arguments:
-
-```shell
-python demo_script.py demo_config.py --cfg-options backbone.depth=101
-```
-
-```shell
-Config (path: demo_config.py): {'backbone': {'type': 'ResNetV1c', 'depth': 101, 'num_stages': 4, 'out_indices': (0, 1, 2, 3), 'dilations': (1, 1, 2, 4), 'strides': (1, 2, 1, 1), 'norm_eval': False, 'style': 'pytorch', 'contract_dilation': True}}
-```
-
-- Update values of list/tuples.
-
-  If the value to be updated is a list or a tuple. For example, the config file `demo_config.py` sets `strides=(1, 2, 1, 1)` in `backbone`.
-  If you want to change this key, you may specify in two ways:
-
-  1. `--cfg-options backbone.strides="(1, 1, 1, 1)"`. Note that the quotation mark " is necessary to support list/tuple data types.
-
-     ```shell
-     python demo_script.py demo_config.py --cfg-options backbone.strides="(1, 1, 1, 1)"
-     ```
-
-     ```shell
-     Config (path: demo_config.py): {'backbone': {'type': 'ResNetV1c', 'depth': 50, 'num_stages': 4, 'out_indices': (0, 1, 2, 3), 'dilations': (1, 1, 2, 4), 'strides': (1, 1, 1, 1), 'norm_eval': False, 'style': 'pytorch', 'contract_dilation': True}}
-     ```
-
-  2. `--cfg-options backbone.strides=1,1,1,1`. Note that **NO** white space is allowed in the specified value.
-     In addition, if the original type is tuple, it will be automatically converted to list after this way.
-
-     ```shell
-     python demo_script.py demo_config.py --cfg-options backbone.strides=1,1,1,1
-     ```
-
-     ```shell
-     Config (path: demo_config.py): {'backbone': {'type': 'ResNetV1c', 'depth': 50, 'num_stages': 4, 'out_indices': (0, 1, 2, 3), 'dilations': (1, 1, 2, 4), 'strides': [1, 1, 1, 1], 'norm_eval': False, 'style': 'pytorch', 'contract_dilation': True}}
-     ```
-
-```{note}
-    This modification method only supports modifying configuration items of string, int, float, boolean, None, list and tuple types.
-    More specifically, for list and tuple types, the elements inside them must also be one of the above seven types.
-```
diff --git a/mmsegmentation/docs/en/user_guides/2_dataset_prepare.md b/mmsegmentation/docs/en/user_guides/2_dataset_prepare.md
deleted file mode 100644
index 3f94a94..0000000
--- a/mmsegmentation/docs/en/user_guides/2_dataset_prepare.md
+++ /dev/null
@@ -1,806 +0,0 @@
-# Tutorial 2: Prepare datasets
-
-It is recommended to symlink the dataset root to `$MMSEGMENTATION/data`.
-If your folder structure is different, you may need to change the corresponding paths in config files.
-For users in China, we also recommend you get the dsdl dataset from our opensource platform [OpenDataLab](https://opendatalab.com/), for better download and use experience，here is an example: [DSDLReadme](../../../configs/dsdl/README.md)， welcome to try.
-
-```none
-mmsegmentation
-├── mmseg
-├── tools
-├── configs
-├── data
-│   ├── cityscapes
-│   │   ├── leftImg8bit
-│   │   │   ├── train
-│   │   │   ├── val
-│   │   ├── gtFine
-│   │   │   ├── train
-│   │   │   ├── val
-│   ├── VOCdevkit
-│   │   ├── VOC2012
-│   │   │   ├── JPEGImages
-│   │   │   ├── SegmentationClass
-│   │   │   ├── ImageSets
-│   │   │   │   ├── Segmentation
-│   │   ├── VOC2010
-│   │   │   ├── JPEGImages
-│   │   │   ├── SegmentationClassContext
-│   │   │   ├── ImageSets
-│   │   │   │   ├── SegmentationContext
-│   │   │   │   │   ├── train.txt
-│   │   │   │   │   ├── val.txt
-│   │   │   ├── trainval_merged.json
-│   │   ├── VOCaug
-│   │   │   ├── dataset
-│   │   │   │   ├── cls
-│   ├── ade
-│   │   ├── ADEChallengeData2016
-│   │   │   ├── annotations
-│   │   │   │   ├── training
-│   │   │   │   ├── validation
-│   │   │   ├── images
-│   │   │   │   ├── training
-│   │   │   │   ├── validation
-│   ├── coco_stuff10k
-│   │   ├── images
-│   │   │   ├── train2014
-│   │   │   ├── test2014
-│   │   ├── annotations
-│   │   │   ├── train2014
-│   │   │   ├── test2014
-│   │   ├── imagesLists
-│   │   │   ├── train.txt
-│   │   │   ├── test.txt
-│   │   │   ├── all.txt
-│   ├── coco_stuff164k
-│   │   ├── images
-│   │   │   ├── train2017
-│   │   │   ├── val2017
-│   │   ├── annotations
-│   │   │   ├── train2017
-│   │   │   ├── val2017
-│   ├── CHASE_DB1
-│   │   ├── images
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   ├── annotations
-│   │   │   ├── training
-│   │   │   ├── validation
-│   ├── DRIVE
-│   │   ├── images
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   ├── annotations
-│   │   │   ├── training
-│   │   │   ├── validation
-│   ├── HRF
-│   │   ├── images
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   ├── annotations
-│   │   │   ├── training
-│   │   │   ├── validation
-│   ├── STARE
-│   │   ├── images
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   ├── annotations
-│   │   │   ├── training
-│   │   │   ├── validation
-|   ├── dark_zurich
-|   │   ├── gps
-|   │   │   ├── val
-|   │   │   └── val_ref
-|   │   ├── gt
-|   │   │   └── val
-|   │   ├── LICENSE.txt
-|   │   ├── lists_file_names
-|   │   │   ├── val_filenames.txt
-|   │   │   └── val_ref_filenames.txt
-|   │   ├── README.md
-|   │   └── rgb_anon
-|   │   |   ├── val
-|   │   |   └── val_ref
-|   ├── NighttimeDrivingTest
-|   |   ├── gtCoarse_daytime_trainvaltest
-|   |   │   └── test
-|   |   │       └── night
-|   |   └── leftImg8bit
-|   |   |   └── test
-|   |   |       └── night
-│   ├── loveDA
-│   │   ├── img_dir
-│   │   │   ├── train
-│   │   │   ├── val
-│   │   │   ├── test
-│   │   ├── ann_dir
-│   │   │   ├── train
-│   │   │   ├── val
-│   ├── potsdam
-│   │   ├── img_dir
-│   │   │   ├── train
-│   │   │   ├── val
-│   │   ├── ann_dir
-│   │   │   ├── train
-│   │   │   ├── val
-│   ├── vaihingen
-│   │   ├── img_dir
-│   │   │   ├── train
-│   │   │   ├── val
-│   │   ├── ann_dir
-│   │   │   ├── train
-│   │   │   ├── val
-│   ├── iSAID
-│   │   ├── img_dir
-│   │   │   ├── train
-│   │   │   ├── val
-│   │   │   ├── test
-│   │   ├── ann_dir
-│   │   │   ├── train
-│   │   │   ├── val
-│   ├── synapse
-│   │   ├── img_dir
-│   │   │   ├── train
-│   │   │   ├── val
-│   │   ├── ann_dir
-│   │   │   ├── train
-│   │   │   ├── val
-│   ├── REFUGE
-│   │   ├── images
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   │   ├── test
-│   │   ├── annotations
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   │   ├── test
-│   ├── mapillary
-│   │   ├── training
-│   │   │   ├── images
-│   │   │   ├── v1.2
-|   │   │   │   ├── instances
-|   │   │   │   ├── labels
-|   │   │   │   └── panoptic
-│   │   │   ├── v2.0
-|   │   │   │   ├── instances
-|   │   │   │   ├── labels
-|   │   │   │   ├── panoptic
-|   │   │   │   └── polygons
-│   │   ├── validation
-│   │   │   ├── images
-|   │   │   ├── v1.2
-|   │   │   │   ├── instances
-|   │   │   │   ├── labels
-|   │   │   │   └── panoptic
-│   │   │   ├── v2.0
-|   │   │   │   ├── instances
-|   │   │   │   ├── labels
-|   │   │   │   ├── panoptic
-|   │   │   │   └── polygons
-│   ├── bdd100k
-│   │   ├── images
-│   │   │   └── 10k
-|   │   │   │   ├── test
-|   │   │   │   ├── train
-|   │   │   │   └── val
-│   │   └── labels
-│   │   │   └── sem_seg
-|   │   │   │   ├── colormaps
-|   │   │   │   │   ├──train
-|   │   │   │   │   └──val
-|   │   │   │   ├── masks
-|   │   │   │   │   ├──train
-|   │   │   │   │   └──val
-|   │   │   │   ├── polygons
-|   │   │   │   │   ├──sem_seg_train.json
-|   │   │   │   │   └──sem_seg_val.json
-|   │   │   │   └── rles
-|   │   │   │   │   ├──sem_seg_train.json
-|   │   │   │   │   └──sem_seg_val.json
-│   ├── nyu
-│   │   ├── images
-│   │   │   ├── train
-│   │   │   ├── test
-│   │   ├── annotations
-│   │   │   ├── train
-│   │   │   ├── test
-│   ├── HSIDrive20
-│   │   ├── images
-│   │   │   ├── train
-│   │   │   ├── validation
-│   │   │   ├── test
-│   │   ├── annotations
-│   │   │   ├── train
-│   │   │   ├── validation
-│   │   │   ├── test
-```
-
-## Download dataset via MIM
-
-By using [OpenXLab](https://openxlab.org.cn/datasets), you can obtain free formatted datasets in various fields. Through the search function of the platform, you may address the dataset they look for quickly and easily. Using the formatted datasets from the platform, you can efficiently conduct tasks across datasets.
-
-If you use MIM to download, make sure that the version is greater than v0.3.8. You can use the following command to update, install, login and download the dataset:
-
-```shell
-# upgrade your MIM
-pip install -U openmim
-
-# install OpenXLab CLI tools
-pip install -U openxlab
-# log in OpenXLab
-openxlab login
-
-# download ADE20K by MIM
-mim download mmsegmentation --dataset ade20k
-```
-
-## Cityscapes
-
-The data could be found [here](https://www.cityscapes-dataset.com/downloads/) after registration.
-
-By convention, `**labelTrainIds.png` are used for cityscapes training.
-We provided a [script](https://github.com/open-mmlab/mmsegmentation/blob/1.x/tools/dataset_converters/cityscapes.py) based on [cityscapesscripts](https://github.com/mcordts/cityscapesScripts)to generate `**labelTrainIds.png`.
-
-```shell
-# --nproc means 8 process for conversion, which could be omitted as well.
-python tools/dataset_converters/cityscapes.py data/cityscapes --nproc 8
-```
-
-## Pascal VOC
-
-Pascal VOC 2012 could be downloaded from [here](http://host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCtrainval_11-May-2012.tar).
-Beside, most recent works on Pascal VOC dataset usually exploit extra augmentation data, which could be found [here](http://www.eecs.berkeley.edu/Research/Projects/CS/vision/grouping/semantic_contours/benchmark.tgz).
-
-If you would like to use augmented VOC dataset, please run following command to convert augmentation annotations into proper format.
-
-```shell
-# --nproc means 8 process for conversion, which could be omitted as well.
-python tools/dataset_converters/voc_aug.py data/VOCdevkit data/VOCdevkit/VOCaug --nproc 8
-```
-
-Please refer to [concat dataset](../advanced_guides/add_datasets.md#concatenate-dataset) and [voc_aug config example](../../../configs/_base_/datasets/pascal_voc12_aug.py) for details about how to concatenate them and train them together.
-
-## ADE20K
-
-The training and validation set of ADE20K could be download from this [link](http://data.csail.mit.edu/places/ADEchallenge/ADEChallengeData2016.zip).
-We may also download test set from [here](http://data.csail.mit.edu/places/ADEchallenge/release_test.zip).
-
-## Pascal Context
-
-The training and validation set of Pascal Context could be download from [here](http://host.robots.ox.ac.uk/pascal/VOC/voc2010/VOCtrainval_03-May-2010.tar). You may also download test set from [here](http://host.robots.ox.ac.uk:8080/eval/downloads/VOC2010test.tar) after registration.
-
-To split the training and validation set from original dataset, you may download trainval_merged.json from [here](https://codalabuser.blob.core.windows.net/public/trainval_merged.json).
-
-If you would like to use Pascal Context dataset, please install [Detail](https://github.com/zhanghang1989/detail-api) and then run the following command to convert annotations into proper format.
-
-```shell
-python tools/dataset_converters/pascal_context.py data/VOCdevkit data/VOCdevkit/VOC2010/trainval_merged.json
-```
-
-## COCO Stuff 10k
-
-The data could be downloaded [here](http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/cocostuff-10k-v1.1.zip) by wget.
-
-For COCO Stuff 10k dataset, please run the following commands to download and convert the dataset.
-
-```shell
-# download
-mkdir coco_stuff10k && cd coco_stuff10k
-wget http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/cocostuff-10k-v1.1.zip
-
-# unzip
-unzip cocostuff-10k-v1.1.zip
-
-# --nproc means 8 process for conversion, which could be omitted as well.
-python tools/dataset_converters/coco_stuff10k.py /path/to/coco_stuff10k --nproc 8
-```
-
-By convention, mask labels in `/path/to/coco_stuff164k/annotations/*2014/*_labelTrainIds.png` are used for COCO Stuff 10k training and testing.
-
-## COCO Stuff 164k
-
-For COCO Stuff 164k dataset, please run the following commands to download and convert the augmented dataset.
-
-```shell
-# download
-mkdir coco_stuff164k && cd coco_stuff164k
-wget http://images.cocodataset.org/zips/train2017.zip
-wget http://images.cocodataset.org/zips/val2017.zip
-wget http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/stuffthingmaps_trainval2017.zip
-
-# unzip
-unzip train2017.zip -d images/
-unzip val2017.zip -d images/
-unzip stuffthingmaps_trainval2017.zip -d annotations/
-
-# --nproc means 8 process for conversion, which could be omitted as well.
-python tools/dataset_converters/coco_stuff164k.py /path/to/coco_stuff164k --nproc 8
-```
-
-By convention, mask labels in `/path/to/coco_stuff164k/annotations/*2017/*_labelTrainIds.png` are used for COCO Stuff 164k training and testing.
-
-The details of this dataset could be found at [here](https://github.com/nightrome/cocostuff#downloads).
-
-## CHASE DB1
-
-The training and validation set of CHASE DB1 could be download from [here](https://staffnet.kingston.ac.uk/~ku15565/CHASE_DB1/assets/CHASEDB1.zip).
-
-To convert CHASE DB1 dataset to MMSegmentation format, you should run the following command:
-
-```shell
-python tools/dataset_converters/chase_db1.py /path/to/CHASEDB1.zip
-```
-
-The script will make directory structure automatically.
-
-## DRIVE
-
-The training and validation set of DRIVE could be download from [here](https://drive.grand-challenge.org/). Before that, you should register an account. Currently '1st_manual' is not provided officially.
-
-To convert DRIVE dataset to MMSegmentation format, you should run the following command:
-
-```shell
-python tools/dataset_converters/drive.py /path/to/training.zip /path/to/test.zip
-```
-
-The script will make directory structure automatically.
-
-## HRF
-
-First, download [healthy.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/healthy.zip), [glaucoma.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/glaucoma.zip), [diabetic_retinopathy.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/diabetic_retinopathy.zip), [healthy_manualsegm.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/healthy_manualsegm.zip), [glaucoma_manualsegm.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/glaucoma_manualsegm.zip) and [diabetic_retinopathy_manualsegm.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/diabetic_retinopathy_manualsegm.zip).
-
-To convert HRF dataset to MMSegmentation format, you should run the following command:
-
-```shell
-python tools/dataset_converters/hrf.py /path/to/healthy.zip /path/to/healthy_manualsegm.zip /path/to/glaucoma.zip /path/to/glaucoma_manualsegm.zip /path/to/diabetic_retinopathy.zip /path/to/diabetic_retinopathy_manualsegm.zip
-```
-
-The script will make directory structure automatically.
-
-## STARE
-
-First, download [stare-images.tar](http://cecas.clemson.edu/~ahoover/stare/probing/stare-images.tar), [labels-ah.tar](http://cecas.clemson.edu/~ahoover/stare/probing/labels-ah.tar) and [labels-vk.tar](http://cecas.clemson.edu/~ahoover/stare/probing/labels-vk.tar).
-
-To convert STARE dataset to MMSegmentation format, you should run the following command:
-
-```shell
-python tools/dataset_converters/stare.py /path/to/stare-images.tar /path/to/labels-ah.tar /path/to/labels-vk.tar
-```
-
-The script will make directory structure automatically.
-
-## Dark Zurich
-
-Since we only support test models on this dataset, you may only download [the validation set](https://data.vision.ee.ethz.ch/csakarid/shared/GCMA_UIoU/Dark_Zurich_val_anon.zip).
-
-## Nighttime Driving
-
-Since we only support test models on this dataset, you may only download [the test set](http://data.vision.ee.ethz.ch/daid/NighttimeDriving/NighttimeDrivingTest.zip).
-
-## LoveDA
-
-The data could be downloaded from Google Drive [here](https://drive.google.com/drive/folders/1ibYV0qwn4yuuh068Rnc-w4tPi0U0c-ti?usp=sharing).
-
-Or it can be downloaded from [zenodo](https://zenodo.org/record/5706578#.YZvN7SYRXdF), you should run the following command:
-
-```shell
-# Download Train.zip
-wget https://zenodo.org/record/5706578/files/Train.zip
-# Download Val.zip
-wget https://zenodo.org/record/5706578/files/Val.zip
-# Download Test.zip
-wget https://zenodo.org/record/5706578/files/Test.zip
-```
-
-For LoveDA dataset, please run the following command to re-organize the dataset.
-
-```shell
-python tools/dataset_converters/loveda.py /path/to/loveDA
-```
-
-Using trained model to predict test set of LoveDA and submit it to server can be found [here](https://codalab.lisn.upsaclay.fr/competitions/421).
-
-More details about LoveDA can be found [here](https://github.com/Junjue-Wang/LoveDA).
-
-## ISPRS Potsdam
-
-The [Potsdam](https://www.isprs.org/education/benchmarks/UrbanSemLab/2d-sem-label-potsdam.aspx) dataset is for urban semantic segmentation used in the 2D Semantic Labeling Contest - Potsdam.
-
-The dataset can be requested at the challenge [homepage](https://www.isprs.org/education/benchmarks/UrbanSemLab/default.aspx).
-Or download on [BaiduNetdisk](https://pan.baidu.com/s/1K-cLVZnd1X7d8c26FQ-nGg?pwd=mseg)，password：mseg, [Google Drive](https://drive.google.com/drive/folders/1w3EJuyUGet6_qmLwGAWZ9vw5ogeG0zLz?usp=sharing) and [OpenDataLab](https://opendatalab.com/ISPRS_Potsdam/download).
-The '2_Ortho_RGB.zip' and '5_Labels_all_noBoundary.zip' are required.
-
-For Potsdam dataset, please run the following command to re-organize the dataset.
-
-```shell
-python tools/dataset_converters/potsdam.py /path/to/potsdam
-```
-
-In our default setting, it will generate 3456 images for training and 2016 images for validation.
-
-## ISPRS Vaihingen
-
-The [Vaihingen](https://www2.isprs.org/commissions/comm2/wg4/benchmark/2d-sem-label-vaihingen/) dataset is for urban semantic segmentation used in the 2D Semantic Labeling Contest - Vaihingen.
-
-The dataset can be requested at the challenge [homepage](https://www2.isprs.org/commissions/comm2/wg4/benchmark/data-request-form/).
-Or [BaiduNetdisk](https://pan.baidu.com/s/109D3WLrLafsuYtLeerLiiA?pwd=mseg)，password：mseg, [Google Drive](https://drive.google.com/drive/folders/1w3NhvLVA2myVZqOn2pbiDXngNC7NTP_t?usp=sharing).
-The 'ISPRS_semantic_labeling_Vaihingen.zip' and 'ISPRS_semantic_labeling_Vaihingen_ground_truth_eroded_COMPLETE.zip' are required.
-
-For Vaihingen dataset, please run the following command to re-organize the dataset.
-
-```shell
-python tools/dataset_converters/vaihingen.py /path/to/vaihingen
-```
-
-In our default setting (`clip_size`=512, `stride_size`=256), it will generate 344 images for training and 398 images for validation.
-
-## iSAID
-
-The data images could be download from [DOTA-v1.0](https://captain-whu.github.io/DOTA/dataset.html) (train/val/test)
-
-The data annotations could be download from [iSAID](https://captain-whu.github.io/iSAID/dataset.html) (train/val)
-
-The dataset is a Large-scale Dataset for Instance Segmentation (also have semantic segmentation) in Aerial Images.
-
-You may need to follow the following structure for dataset preparation after downloading iSAID dataset.
-
-```none
-├── data
-│   ├── iSAID
-│   │   ├── train
-│   │   │   ├── images
-│   │   │   │   ├── part1.zip
-│   │   │   │   ├── part2.zip
-│   │   │   │   ├── part3.zip
-│   │   │   ├── Semantic_masks
-│   │   │   │   ├── images.zip
-│   │   ├── val
-│   │   │   ├── images
-│   │   │   │   ├── part1.zip
-│   │   │   ├── Semantic_masks
-│   │   │   │   ├── images.zip
-│   │   ├── test
-│   │   │   ├── images
-│   │   │   │   ├── part1.zip
-│   │   │   │   ├── part2.zip
-```
-
-```shell
-python tools/dataset_converters/isaid.py /path/to/iSAID
-```
-
-In our default setting (`patch_width`=896, `patch_height`=896, `overlap_area`=384), it will generate 33978 images for training and 11644 images for validation.
-
-## LIP(Look Into Person) dataset
-
-This dataset could be download from [this page](https://lip.sysuhcp.com/overview.php).
-
-Please run the following commands to unzip dataset.
-
-```shell
-unzip LIP.zip
-cd LIP
-unzip TrainVal_images.zip
-unzip TrainVal_parsing_annotations.zip
-cd TrainVal_parsing_annotations
-unzip TrainVal_parsing_annotations.zip
-mv train_segmentations ../
-mv val_segmentations ../
-cd ..
-```
-
-The contents of LIP datasets include:
-
-```none
-├── data
-│   ├── LIP
-│   │   ├── train_images
-│   │   │   ├── 1000_1234574.jpg
-│   │   │   ├── ...
-│   │   ├── train_segmentations
-│   │   │   ├── 1000_1234574.png
-│   │   │   ├── ...
-│   │   ├── val_images
-│   │   │   ├── 100034_483681.jpg
-│   │   │   ├── ...
-│   │   ├── val_segmentations
-│   │   │   ├── 100034_483681.png
-│   │   │   ├── ...
-```
-
-## Synapse dataset
-
-This dataset could be download from [this page](https://www.synapse.org/#!Synapse:syn3193805/wiki/).
-
-To follow the data preparation setting of [TransUNet](https://arxiv.org/abs/2102.04306), which splits original training set (30 scans) into new training (18 scans) and validation set (12 scans). Please run the following command to prepare the dataset.
-
-```shell
-unzip RawData.zip
-cd ./RawData/Training
-```
-
-Then create `train.txt` and `val.txt` to split dataset.
-
-According to TransUnet, the following is the data set division.
-
-train.txt
-
-```none
-img0005.nii.gz
-img0006.nii.gz
-img0007.nii.gz
-img0009.nii.gz
-img0010.nii.gz
-img0021.nii.gz
-img0023.nii.gz
-img0024.nii.gz
-img0026.nii.gz
-img0027.nii.gz
-img0028.nii.gz
-img0030.nii.gz
-img0031.nii.gz
-img0033.nii.gz
-img0034.nii.gz
-img0037.nii.gz
-img0039.nii.gz
-img0040.nii.gz
-```
-
-val.txt
-
-```none
-img0008.nii.gz
-img0022.nii.gz
-img0038.nii.gz
-img0036.nii.gz
-img0032.nii.gz
-img0002.nii.gz
-img0029.nii.gz
-img0003.nii.gz
-img0001.nii.gz
-img0004.nii.gz
-img0025.nii.gz
-img0035.nii.gz
-```
-
-The contents of synapse datasets include:
-
-```none
-├── Training
-│   ├── img
-│   │   ├── img0001.nii.gz
-│   │   ├── img0002.nii.gz
-│   │   ├── ...
-│   ├── label
-│   │   ├── label0001.nii.gz
-│   │   ├── label0002.nii.gz
-│   │   ├── ...
-│   ├── train.txt
-│   ├── val.txt
-```
-
-Then, use this command to convert synapse dataset.
-
-```shell
-python tools/dataset_converters/synapse.py --dataset-path /path/to/synapse
-```
-
-Noted that MMSegmentation default evaluation metric (such as mean dice value) is calculated on 2D slice image, which is not comparable to results of 3D scan in some paper such as [TransUNet](https://arxiv.org/abs/2102.04306).
-
-## REFUGE
-
-Register in [REFUGE Challenge](https://refuge.grand-challenge.org) and download [REFUGE dataset](https://refuge.grand-challenge.org/REFUGE2Download).
-
-Then, unzip `REFUGE2.zip` and the contents of original datasets include:
-
-```none
-├── REFUGE2
-│   ├── REFUGE2
-│   │   ├── Annotation-Training400.zip
-│   │   ├── REFUGE-Test400.zip
-│   │   ├── REFUGE-Test-GT.zip
-│   │   ├── REFUGE-Training400.zip
-│   │   ├── REFUGE-Validation400.zip
-│   │   ├── REFUGE-Validation400-GT.zip
-│   ├── __MACOSX
-```
-
-Please run the following command to convert REFUGE dataset:
-
-```shell
-python tools/convert_datasets/refuge.py --raw_data_root=/path/to/refuge/REFUGE2/REFUGE2
-```
-
-The script will make directory structure below:
-
-```none
-│   ├── REFUGE
-│   │   ├── images
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   │   ├── test
-│   │   ├── annotations
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   │   ├── test
-```
-
-It includes 400 images for training, 400 images for validation and 400 images for testing which is the same as REFUGE 2018 dataset.
-
-## Mapillary Vistas Datasets
-
-- The dataset could be download [here](https://www.mapillary.com/dataset/vistas) after registration.
-
-- Mapillary Vistas Dataset use 8-bit with color-palette to store labels. No conversion operation is required.
-
-- Assumption you have put the dataset zip file in `mmsegmentation/data/mapillary`
-
-- Please run the following commands to unzip dataset.
-
-  ```bash
-  cd data/mapillary
-  unzip An-ZjB1Zm61yAZG0ozTymz8I8NqI4x0MrYrh26dq7kPgfu8vf9ImrdaOAVOFYbJ2pNAgUnVGBmbue9lTgdBOb5BbKXIpFs0fpYWqACbrQDChAA2fdX0zS9PcHu7fY8c-FOvyBVxPNYNFQuM.zip
-  ```
-
-- After unzip, you will get Mapillary Vistas Dataset like this structure. Semantic segmentation mask labels in `labels` folder.
-
-  ```none
-  mmsegmentation
-  ├── mmseg
-  ├── tools
-  ├── configs
-  ├── data
-  │   ├── mapillary
-  │   │   ├── training
-  │   │   │   ├── images
-  │   │   │   ├── v1.2
-  |   │   │   │   ├── instances
-  |   │   │   │   ├── labels
-  |   │   │   │   └── panoptic
-  │   │   │   ├── v2.0
-  |   │   │   │   ├── instances
-  |   │   │   │   ├── labels
-  |   │   │   │   ├── panoptic
-  |   │   │   │   └── polygons
-  │   │   ├── validation
-  │   │   │   ├── images
-  |   │   │   ├── v1.2
-  |   │   │   │   ├── instances
-  |   │   │   │   ├── labels
-  |   │   │   │   └── panoptic
-  │   │   │   ├── v2.0
-  |   │   │   │   ├── instances
-  |   │   │   │   ├── labels
-  |   │   │   │   ├── panoptic
-  |   │   │   │   └── polygons
-  ```
-
-- You could set Datasets version with `MapillaryDataset_v1` and `MapillaryDataset_v2` in your configs.
-  View the Mapillary Vistas Datasets config file here [V1.2](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/_base_/datasets/mapillary_v1.py) and [V2.0](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/_base_/datasets/mapillary_v2.py)
-
-## LEVIR-CD
-
-[LEVIR-CD](https://justchenhao.github.io/LEVIR/) Large-scale Remote Sensing Change Detection Dataset for Building.
-
-Download the dataset from [here](https://justchenhao.github.io/LEVIR/).
-
-The supplement version of the dataset can be requested on the [homepage](https://github.com/S2Looking/Dataset)
-
-Please download the supplement version of the dataset, then unzip `LEVIR-CD+.zip`, the contents of original datasets include:
-
-```none
-│   ├── LEVIR-CD+
-│   │   ├── train
-│   │   │   ├── A
-│   │   │   ├── B
-│   │   │   ├── label
-│   │   ├── test
-│   │   │   ├── A
-│   │   │   ├── B
-│   │   │   ├── label
-```
-
-For LEVIR-CD dataset, please run the following command to crop images without overlap:
-
-```shell
-python tools/dataset_converters/levircd.py --dataset-path /path/to/LEVIR-CD+ --out_dir /path/to/LEVIR-CD
-```
-
-The size of cropped image is 256x256, which is consistent with the original paper.
-
-## BDD100K
-
-- You could download BDD100k datasets from  [here](https://bdd-data.berkeley.edu/) after  registration.
-
-- You can download images and masks by clicking  `10K Images` button and `Segmentation` button.
-
-- After download, unzip by the following instructions:
-
-  ```bash
-  unzip ~/bdd100k_images_10k.zip -d ~/mmsegmentation/data/
-  unzip ~/bdd100k_sem_seg_labels_trainval.zip -d ~/mmsegmentation/data/
-  ```
-
-- And get
-
-```none
-mmsegmentation
-├── mmseg
-├── tools
-├── configs
-├── data
-│   ├── bdd100k
-│   │   ├── images
-│   │   │   └── 10k
-|   │   │   │   ├── test
-|   │   │   │   ├── train
-|   │   │   │   └── val
-│   │   └── labels
-│   │   │   └── sem_seg
-|   │   │   │   ├── colormaps
-|   │   │   │   │   ├──train
-|   │   │   │   │   └──val
-|   │   │   │   ├── masks
-|   │   │   │   │   ├──train
-|   │   │   │   │   └──val
-|   │   │   │   ├── polygons
-|   │   │   │   │   ├──sem_seg_train.json
-|   │   │   │   │   └──sem_seg_val.json
-|   │   │   │   └── rles
-|   │   │   │   │   ├──sem_seg_train.json
-|   │   │   │   │   └──sem_seg_val.json
-```
-
-## NYU
-
-- To access the NYU dataset, you can download it from [this link](https://drive.google.com/file/d/1wC-io-14RCIL4XTUrQLk6lBqU2AexLVp/view?usp=share_link)
-
-- Once the download is complete, you can utilize the [tools/dataset_converters/nyu.py](/tools/dataset_converters/nyu.py) script to extract and organize the data into the required format. Run the following command in your terminal:
-
-  ```bash
-  python tools/dataset_converters/nyu.py nyu.zip
-  ```
-
-## HSI Drive 2.0
-
-- You could download HSI Drive 2.0 dataset from [here](https://ipaccess.ehu.eus/HSI-Drive/#download) after just sending an email to gded@ehu.eus with the subject "download HSI-Drive". You will receive a password to uncompress the files.
-
-- After download, unzip by the following instructions:
-
-  ```bash
-  7z x -p"password" ./HSI_Drive_v2_0_Phyton.zip
-
-  mv ./HSIDrive20 path_to_mmsegmentation/data
-  mv ./HSI_Drive_v2_0_release_notes_Python_version.md path_to_mmsegmentation/data
-  mv ./image_numbering.pdf path_to_mmsegmentation/data
-  ```
-
-- After unzip, you get
-
-```none
-mmsegmentation
-├── mmseg
-├── tools
-├── configs
-├── data
-│   ├── HSIDrive20
-│   │   ├── images
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   │   ├── test
-│   │   ├── annotations
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   │   ├── test
-│   │   ├── images_MF
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   │   ├── test
-│   │   ├── RGB
-│   │   ├── training_filenames.txt
-│   │   ├── validation_filenames.txt
-│   │   ├── test_filenames.txt
-│   ├── HSI_Drive_v2_0_release_notes_Python_version.md
-│   ├── image_numbering.pdf
-```
diff --git a/mmsegmentation/docs/en/user_guides/3_inference.md b/mmsegmentation/docs/en/user_guides/3_inference.md
deleted file mode 100644
index cacebd2..0000000
--- a/mmsegmentation/docs/en/user_guides/3_inference.md
+++ /dev/null
@@ -1,244 +0,0 @@
-# Tutorial 3: Inference with existing models
-
-MMSegmentation provides pre-trained models for semantic segmentation in [Model Zoo](../model_zoo.md), and supports multiple standard datasets, including Cityscapes, ADE20K, etc.
-This note will show how to use existing models to inference on given images.
-As for how to test existing models on standard datasets, please see this [guide](./4_train_test.md)
-
-MMSegmentation provides several interfaces for users to easily use pre-trained models for inference.
-
-- [Tutorial 3: Inference with existing models](#tutorial-3-inference-with-existing-models)
-  - [Inferencer](#inferencer)
-    - [Basic Usage](#basic-usage)
-    - [Initialization](#initialization)
-    - [Visualize prediction](#visualize-prediction)
-    - [List model](#list-model)
-  - [Inference API](#inference-api)
-    - [mmseg.apis.init_model](#mmsegapisinit_model)
-    - [mmseg.apis.inference_model](#mmsegapisinference_model)
-    - [mmseg.apis.show_result_pyplot](#mmsegapisshow_result_pyplot)
-
-## Inferencer
-
-We provide the most **convenient** way to use the model in MMSegmentation `MMSegInferencer`. You can get segmentation mask for an image with only 3 lines of code.
-
-### Basic Usage
-
-The following example shows how to use `MMSegInferencer` to perform inference on a single image.
-
-```
->>> from mmseg.apis import MMSegInferencer
->>> # Load models into memory
->>> inferencer = MMSegInferencer(model='deeplabv3plus_r18-d8_4xb2-80k_cityscapes-512x1024')
->>> # Inference
->>> inferencer('demo/demo.png', show=True)
-```
-
-The visualization result should look like:
-
-<div align="center">
-    <img src='https://user-images.githubusercontent.com/76149310/221507927-ae01e3a7-016f-4425-b966-7b19cbbe494e.png' />
-</div>
-
-Moreover, you can use `MMSegInferencer` to process a list of images:
-
-```
-# Input a list of images
->>> images = [image1, image2, ...] # image1 can be a file path or a np.ndarray
->>> inferencer(images, show=True, wait_time=0.5) # wait_time is delay time, and 0 means forever
-
-# Or input image directory
->>> images = $IMAGESDIR
->>> inferencer(images, show=True, wait_time=0.5)
-
-# Save visualized rendering color maps and predicted results
-# out_dir is the directory to save the output results, img_out_dir and pred_out_dir are subdirectories of out_dir
-# to save visualized rendering color maps and predicted results
->>> inferencer(images, out_dir='outputs', img_out_dir='vis', pred_out_dir='pred')
-```
-
-There is a optional parameter of inferencer, `return_datasamples`, whose default value is False, and return value of inferencer is a `dict` type by default, including 2 keys 'visualization' and 'predictions'.
-If `return_datasamples=True` inferencer will return [`SegDataSample`](../advanced_guides/structures.md), or list of it.
-
-```
-result = inferencer('demo/demo.png')
-# result is a `dict` including 2 keys 'visualization' and 'predictions'
-# 'visualization' includes color segmentation map
-print(result['visualization'].shape)
-# (512, 683, 3)
-
-# 'predictions' includes segmentation mask with label indice
-print(result['predictions'].shape)
-# (512, 683)
-
-result = inferencer('demo/demo.png', return_datasamples=True)
-print(type(result))
-# <class 'mmseg.structures.seg_data_sample.SegDataSample'>
-
-# Input a list of images
-results = inferencer(images)
-# The output is list
-print(type(results['visualization']), results['visualization'][0].shape)
-# <class 'list'> (512, 683, 3)
-print(type(results['predictions']), results['predictions'][0].shape)
-# <class 'list'> (512, 683)
-
-results = inferencer(images, return_datasamples=True)
-# <class 'list'>
-print(type(results[0]))
-# <class 'mmseg.structures.seg_data_sample.SegDataSample'>
-```
-
-### Initialization
-
-`MMSegInferencer` must be initialized from a `model`, which can be a model name or a `Config` even a path of config file.
-The model names can be found in models' metafile (configs/xxx/metafile.yaml), like one model name of maskformer is `maskformer_r50-d32_8xb2-160k_ade20k-512x512`, and if input model name and the weights of the model will be download automatically. Below are other input parameters:
-
-- weights (str, optional) -  Path to the checkpoint. If it is not specified and model is a model name of metafile, the weights will be loaded from metafile. Defaults to None.
-- classes (list, optional) - Input classes for result rendering, as the prediction of segmentation model is a segment map with label indices, `classes` is a list which includes items responding to the label indices. If classes is not defined, visualizer will take `cityscapes` classes by default. Defaults to None.
-- palette (list, optional) - Input palette for result rendering, which is a list of colors responding to the classes. If the palette is not defined, the visualizer will take the palette of `cityscapes` by default. Defaults to None.
-- dataset_name (str, optional) - [Dataset name or alias](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/utils/class_names.py#L302-L317), visualizer will use the meta information of the dataset i.e. classes and palette, but the `classes` and `palette` have higher priority. Defaults to None.
-- device (str, optional) - Device to run inference. If None, the available device will be automatically used. Defaults to None.
-- scope (str, optional) - The scope of the model. Defaults to 'mmseg'.
-
-### Visualize prediction
-
-`MMSegInferencer` supports 4 parameters for visualize prediction, you can use them when call initialized inferencer:
-
-- show (bool) - Whether to display the image in a popup window. Defaults to False.
-- wait_time (float) - The interval of show (s). Defaults to 0.
-- img_out_dir (str) - Subdirectory of `out_dir`, used to save rendering color segmentation mask, so `out_dir` must be defined if you would like to save predicted mask. Defaults to 'vis'.
-- opacity (int, float) - The transparency of segmentation mask. Defaults to 0.8.
-
-The examples of these parameters is in [Basic Usage](#basic-usage)
-
-### List model
-
-There is a very easy to list all model names in MMSegmentation
-
-```
->>> from mmseg.apis import MMSegInferencer
-# models is a list of model names, and them will print automatically
->>> models = MMSegInferencer.list_models('mmseg')
-```
-
-## Inference API
-
-### mmseg.apis.init_model
-
-Initialize a segmentor from config file.
-
-Parameters:
-
-- config (str, `Path`, or `mmengine.Config`) - Config file path or the config object.
-- checkpoint (str, optional) - Checkpoint path. If left as None, the model will not load any weights.
-- device (str, optional) - CPU/CUDA device option. Default 'cuda:0'.
-- cfg_options (dict, optional) - Options to override some settings in the used config.
-
-Returns:
-
-- nn.Module: The constructed segmentor.
-
-Example:
-
-```python
-from mmseg.apis import init_model
-
-config_path = 'configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-checkpoint_path = 'checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
-
-# initialize model without checkpoint
-model = init_model(config_path)
-
-# init model and load checkpoint
-model = init_model(config_path, checkpoint_path)
-
-# init model and load checkpoint on CPU
-model = init_model(config_path, checkpoint_path, 'cpu')
-```
-
-### mmseg.apis.inference_model
-
-Inference image(s) with the segmentor.
-
-Parameters:
-
-- model (nn.Module) - The loaded segmentor
-- imgs (str, np.ndarray, or list\[str/np.ndarray\]) - Either image files or loaded images
-
-Returns:
-
-- `SegDataSample` or list\[`SegDataSample`\]: If imgs is a list or tuple, the same length list type results will be returned, otherwise return the segmentation results directly.
-
-**Note:** [SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py) is a data structure interface of MMSegmentation, it is used as interfaces between different components. `SegDataSample` implement the abstract data element `mmengine.structures.BaseDataElement`, please refer to data element [documentation](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/data_element.html) in [MMEngine](https://github.com/open-mmlab/mmengine) for more information.
-
-The attributes in `SegDataSample` are divided into several parts:
-
-- `gt_sem_seg` (`PixelData`) - Ground truth of semantic segmentation.
-- `pred_sem_seg` (`PixelData`) - Prediction of semantic segmentation.
-- `seg_logits` (`PixelData`) - Predicted logits of semantic segmentation.
-
-**Note** [PixelData](https://github.com/open-mmlab/mmengine/blob/main/mmengine/structures/pixel_data.py) is the data structure for pixel-level annotations or predictions, please refer to PixelData [documentation](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/data_element.html) in [MMEngine](https://github.com/open-mmlab/mmengine) for more information.
-
-Example:
-
-```python
-from mmseg.apis import init_model, inference_model
-
-config_path = 'configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-checkpoint_path = 'checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
-img_path = 'demo/demo.png'
-
-
-model = init_model(config_path, checkpoint_path)
-result = inference_model(model, img_path)
-```
-
-### mmseg.apis.show_result_pyplot
-
-Visualize the segmentation results on the image.
-
-Parameters:
-
-- model (nn.Module) - The loaded segmentor.
-- img (str or np.ndarray) - Image filename or loaded image.
-- result (`SegDataSample`) - The prediction SegDataSample result.
-- opacity (float) - Opacity of painted segmentation map. Default `0.5`, must be in `(0, 1]` range.
-- title (str) - The title of pyplot figure. Default is ''.
-- draw_gt (bool) - Whether to draw GT SegDataSample. Default to `True`.
-- draw_pred (draws_pred) - Whether to draw Prediction SegDataSample. Default to `True`.
-- wait_time (float) - The interval of show (s), 0 is the special value that means "forever". Default to `0`.
-- show (bool) - Whether to display the drawn image. Default to `True`.
-- save_dir (str, optional) - Save file dir for all storage backends. If it is `None`, the backend storage will not save any data.
-- out_file (str, optional) - Path to output file. Default to `None`.
-
-Returns:
-
-- np.ndarray: the drawn image which channel is RGB.
-
-Example:
-
-```python
-from mmseg.apis import init_model, inference_model, show_result_pyplot
-
-config_path = 'configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-checkpoint_path = 'checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
-img_path = 'demo/demo.png'
-
-
-# build the model from a config file and a checkpoint file
-model = init_model(config_path, checkpoint_path, device='cuda:0')
-
-# inference on given image
-result = inference_model(model, img_path)
-
-# display the segmentation result
-vis_image = show_result_pyplot(model, img_path, result)
-
-# save the visualization result, the output image would be found at the path `work_dirs/result.png`
-vis_iamge = show_result_pyplot(model, img_path, result, out_file='work_dirs/result.png')
-
-# Modify the time of displaying images, note that 0 is the special value that means "forever"
-vis_image = show_result_pyplot(model, img_path, result, wait_time=5)
-```
-
-**Note:** If your current device doesn't have graphical user interface, it is recommended that setting `show` to `False` and specify the `out_file` or `save_dir` to save the results. If you would like to display the result on a window, no special settings are required.
diff --git a/mmsegmentation/docs/en/user_guides/4_train_test.md b/mmsegmentation/docs/en/user_guides/4_train_test.md
deleted file mode 100644
index 9b2d17d..0000000
--- a/mmsegmentation/docs/en/user_guides/4_train_test.md
+++ /dev/null
@@ -1,315 +0,0 @@
-# Tutorial 4: Train and test with existing models
-
-MMSegmentation supports training and testing models on a variety of devices, which are described below for single-GPU, distributed, and cluster training and testing, respectively. Through this tutorial, you will learn how to train and test using the scripts provided by MMSegmentation.
-
-## Training and testing on a single GPU
-
-### Training on a single GPU
-
-We provide `tools/train.py` to launch training jobs on a single GPU.
-The basic usage is as follows.
-
-```shell
-python tools/train.py  ${CONFIG_FILE} [optional arguments]
-```
-
-This tool accepts several optional arguments, including:
-
-- `--work-dir ${WORK_DIR}`: Override the working directory.
-- `--amp`: Use auto mixed precision training.
-- `--resume`: Resume from the latest checkpoint in the work_dir automatically.
-- `--cfg-options ${OVERRIDE_CONFIGS}`: Override some settings in the used config, and the key-value pair in xxx=yyy format will be merged into the config file.
-  For example, '--cfg-option model.encoder.in_channels=6'. Please see this [guide](./1_config.md#Modify-config-through-script-arguments) for more details.
-
-Below are the optional arguments for the multi-gpu test:
-
-- `--launcher`: Items for distributed job initialization launcher. Allowed choices are `none`, `pytorch`, `slurm`, `mpi`. Especially, if set to none, it will test in a non-distributed mode.
-- `--local_rank`: ID for local rank. If not specified, it will be set to 0.
-
-**Note:** Difference between the argument `--resume` and the field `load_from` in the config file:
-
-`--resume` only determines whether to resume from the latest checkpoint in the work_dir. It is usually used for resuming the training process that is interrupted accidentally.
-
-`load_from` will specify the checkpoint to be loaded and the training iteration starts from 0. It is usually used for fine-tuning.
-
-If you would like to resume training from a specific checkpoint, you can use:
-
-```python
-python tools/train.py ${CONFIG_FILE} --resume --cfg-options load_from=${CHECKPOINT}
-```
-
-**Training on CPU**: The process of training on the CPU is consistent with single GPU training if a machine does not have GPU. If it has GPUs but not wanting to use them, we just need to disable GPUs before the training process.
-
-```shell
-export CUDA_VISIBLE_DEVICES=-1
-```
-
-And then run the script [above](#training-on-a-single-gpu).
-
-### Testing on a single GPU
-
-We provide `tools/test.py` to launch training jobs on a single GPU.
-The basic usage is as follows.
-
-```shell
-python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [optional arguments]
-```
-
-This tool accepts several optional arguments, including:
-
-- `--work-dir`: If specified, results will be saved in this directory. If not specified, the results will be automatically saved to `work_dirs/{CONFIG_NAME}`.
-- `--show`: Show prediction results at runtime, available when `--show-dir` is not specified.
-- `--show-dir`: Directory where painted images will be saved. If specified, the visualized segmentation mask will be saved to the `work_dir/timestamp/show_dir`.
-- `--wait-time`: The interval of show (s), which takes effect when `--show` is activated. Default to 2.
-- `--cfg-options`:  If specified, the key-value pair in xxx=yyy format will be merged into the config file.
-- `--tta`: Test time augmentation option.
-
-**Testing on CPU**: The process of testing on the CPU is consistent with single GPU testing if a machine does not have GPU. If it has GPUs but not wanting to use them, we just need to disable GPUs before the training process.
-
-```shell
-export CUDA_VISIBLE_DEVICES=-1
-```
-
-then run the script [above](#testing-on-a-single-gpu).
-
-## Training and testing on multiple GPUs and multiple machines
-
-### Training on multiple GPUs
-
-OpenMMLab2.0 implements **distributed** training with `MMDistributedDataParallel`.
-We provide `tools/dist_train.sh` to launch training on multiple GPUs.
-
-The basic usage is as follows:
-
-```shell
-sh tools/dist_train.sh ${CONFIG_FILE} ${GPU_NUM} [optional arguments]
-```
-
-Optional arguments remain the same as stated [above](#training-on-a-single-gpu) and have additional arguments to specify the number of GPUs.
-
-An example:
-
-```shell
-# checkpoints and logs saved in WORK_DIR=work_dirs/pspnet_r50-d8_4xb4-80k_ade20k-512x512/
-# If work_dir is not set, it will be generated automatically.
-sh tools/dist_train.sh configs/pspnet/pspnet_r50-d8_4xb4-80k_ade20k-512x512.py 8 --work-dir work_dirs/pspnet_r50-d8_4xb4-80k_ade20k-512x512
-```
-
-**Note**: During training, checkpoints and logs are saved in the same folder structure as the config file under `work_dirs/`. A custom work directory is not recommended since evaluation scripts infer work directories from the config file name. If you want to save your weights somewhere else, please use a symlink, for example:
-
-```shell
-ln -s ${YOUR_WORK_DIRS} ${MMSEG}/work_dirs
-```
-
-### Testing on multiple GPUs
-
-We provide `tools/dist_test.sh` to launch testing on multiple GPUs.
-The basic usage is as follows.
-
-```shell
-sh tools/dist_test.sh ${CONFIG_FILE} ${CHECKPOINT_FILE} ${GPU_NUM} [optional arguments]
-```
-
-Optional arguments remain the same as stated [above](#testing-on-a-single-gpu) and have additional arguments to specify the number of GPUs.
-
-An example:
-
-```shell
-./tools/dist_test.sh configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py \
-    checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth 4
-```
-
-### Launch multiple jobs on a single machine
-
-If you launch multiple jobs on a single machine, e.g., 2 jobs of 4-GPU training on a machine with 8 GPUs, you need to specify different ports (29500 by default) for each job to avoid communication conflict. Otherwise, there will be an error message saying `RuntimeError: Address already in use`.
-If you use `dist_train.sh` to launch training jobs, you can set the port in commands with the environment variable `PORT`.
-
-```shell
-CUDA_VISIBLE_DEVICES=0,1,2,3 PORT=29500 sh tools/dist_train.sh ${CONFIG_FILE} 4
-CUDA_VISIBLE_DEVICES=4,5,6,7 PORT=29501 sh tools/dist_train.sh ${CONFIG_FILE} 4
-```
-
-### Training with multiple machines
-
-MMSegmentation relies on `torch.distributed` package for distributed training.
-Thus, as a basic usage, one can launch distributed training via PyTorch's [launch utility](https://pytorch.org/docs/stable/distributed.html#launch-utility).
-
-If you launch with multiple machines simply connected with ethernet, you can simply run the following commands:
-On the first machine:
-
-```shell
-NNODES=2 NODE_RANK=0 PORT=${MASTER_PORT} MASTER_ADDR=${MASTER_ADDR} sh tools/dist_train.sh ${CONFIG_FILE} ${GPUS}
-```
-
-On the second machine:
-
-```shell
-NNODES=2 NODE_RANK=1 PORT=${MASTER_PORT} MASTER_ADDR=${MASTER_ADDR} sh tools/dist_train.sh ${CONFIG_FILE} ${GPUS}
-```
-
-Usually, it is slow if you do not have high-speed networking like InfiniBand.
-
-## Manage jobs with Slurm
-
-[Slurm](https://slurm.schedmd.com/) is a good job scheduling system for computing clusters.
-
-### Training on a cluster with Slurm
-
-On a cluster managed by Slurm, you can use `slurm_train.sh` to spawn training jobs. It supports both single-node and multi-node training.
-
-The basic usage is as follows:
-
-```shell
-[GPUS=${GPUS}] sh tools/slurm_train.sh ${PARTITION} ${JOB_NAME} ${CONFIG_FILE} [optional arguments]
-```
-
-Below is an example of using 4 GPUs to train PSPNet on a Slurm partition named _dev_, and set the work-dir to some shared file systems.
-
-```shell
-GPUS=4 sh tools/slurm_train.sh dev pspnet configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py --work-dir work_dir/pspnet
-```
-
-You can check [the source code](../../../tools/slurm_train.sh) to review full arguments and environment variables.
-
-### Testing on a cluster with Slurm
-
-Similar to the training task, MMSegmentation provides `slurm_test.sh` to launch testing jobs.
-
-The basic usage is as follows:
-
-```shell
-[GPUS=${GPUS}] sh tools/slurm_test.sh ${PARTITION} ${JOB_NAME} ${CONFIG_FILE} ${CHECKPOINT_FILE} [optional arguments]
-```
-
-You can check [the source code](../../../tools/slurm_test.sh) to review full arguments and environment variables.
-
-**Note:** When using Slurm, the port option needs to be set in one of the following ways:
-
-1. Set the port through `--cfg-options`. This is more recommended since it does not change the original configs.
-
-   ```shell
-   GPUS=4 GPUS_PER_NODE=4 sh tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config1.py ${WORK_DIR} --cfg-options env_cfg.dist_cfg.port=29500
-   GPUS=4 GPUS_PER_NODE=4 sh tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config2.py ${WORK_DIR} --cfg-options env_cfg.dist_cfg.port=29501
-   ```
-
-2. Modify the config files to set different communication ports.
-   In `config1.py`:
-
-   ```python
-   enf_cfg = dict(dist_cfg=dict(backend='nccl', port=29500))
-   ```
-
-   In `config2.py`:
-
-   ```python
-   enf_cfg = dict(dist_cfg=dict(backend='nccl', port=29501))
-   ```
-
-   Then you can launch two jobs with config1.py and config2.py.
-
-   ```shell
-   CUDA_VISIBLE_DEVICES=0,1,2,3 GPUS=4 sh tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config1.py ${WORK_DIR}
-   CUDA_VISIBLE_DEVICES=4,5,6,7 GPUS=4 sh tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config2.py ${WORK_DIR}
-   ```
-
-3. Set the port in the command using the environment variable 'MASTER_PORT':
-
-```shell
-CUDA_VISIBLE_DEVICES=0,1,2,3 GPUS=4 MASTER_PORT=29500 sh tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config1.py ${WORK_DIR}
-CUDA_VISIBLE_DEVICES=4,5,6,7 GPUS=4 MASTER_PORT=29501 sh tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config2.py ${WORK_DIR}
-```
-
-## Testing and saving segment files
-
-### Basic Usage
-
-When you want to save the results, you can use `--out` to specify the output directory.
-
-```shell
-python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} --out ${OUTPUT_DIR}
-```
-
-Here is an example to save the predicted results from model `fcn_r50-d8_4xb4-80k_ade20k-512x512` on ADE20k validatation dataset.
-
-```shell
-python tools/test.py configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py ckpt/fcn_r50-d8_512x512_80k_ade20k_20200614_144016-f8ac5082.pth --out work_dirs/format_results
-```
-
-You also can modify the config file to define `output_dir`. We also take
-`fcn_r50-d8_4xb4-80k_ade20k-512x512` as example just add
-`test_evaluator` in `configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py`
-
-```python
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'], output_dir='work_dirs/format_results')
-```
-
-then run command without `--out`:
-
-```shell
-python tools/test.py configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py ckpt/fcn_r50-d8_512x512_80k_ade20k_20200614_144016-f8ac5082.pth
-```
-
-If you would like to only save the predicted results without evaluation as annotation is not released by the official dataset, you can set `format_only=True` and modify `test_dataloader`.
-As there is no annotation in dataset, we remove `dict(type='LoadAnnotations')` from `test_dataloader` Here is the example configuration:
-
-```python
-test_evaluator = dict(
-    type='IoUMetric',
-    iou_metrics=['mIoU'],
-    format_only=True,
-    output_dir='work_dirs/format_results')
-test_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type = 'ADE20KDataset'
-        data_root='data/ade/release_test',
-        data_prefix=dict(img_path='testing'),
-        # we don't load annotation in test transform pipeline.
-        pipeline=[
-            dict(type='LoadImageFromFile'),
-            dict(type='Resize', scale=(2048, 512), keep_ratio=True),
-            dict(type='PackSegInputs')
-        ]))
-```
-
-then run test command:
-
-```shell
-python tools/test.py configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py ckpt/fcn_r50-d8_512x512_80k_ade20k_20200614_144016-f8ac5082.pth
-```
-
-### Testing Cityscape dataset and save predicted segment files
-
-We recommend `CityscapesMetric` which is the wrapper of Cityscapes'sdk, when you want to
-save the predicted results of Cityscape test dataset to submit them in [Cityscape test server](https://www.cityscapes-dataset.com/submit/). Here is the example configuration:
-
-```python
-test_evaluator = dict(
-    type='CityscapesMetric',
-    format_only=True,
-    keep_results=True,
-    output_dir='work_dirs/format_results')
-test_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type='CityscapesDataset',
-        data_root='data/cityscapes/',
-        data_prefix=dict(img_path='leftImg8bit/test'),
-        pipeline=[
-            dict(type='LoadImageFromFile'),
-            dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
-            dict(type='PackSegInputs')
-        ]))
-```
-
-then run test command, for example:
-
-```shell
-python tools/test.py configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-512x1024.py ckpt/fcn_r18-d8_512x1024_80k_cityscapes_20201225_021327-6c50f8b4.pth
-```
diff --git a/mmsegmentation/docs/en/user_guides/5_deployment.md b/mmsegmentation/docs/en/user_guides/5_deployment.md
deleted file mode 100644
index b3b8f57..0000000
--- a/mmsegmentation/docs/en/user_guides/5_deployment.md
+++ /dev/null
@@ -1,255 +0,0 @@
-# Tutorial 5: Model Deployment
-
-# MMSegmentation Model Deployment
-
-- [Tutorial 5: Model Deployment](#tutorial-5-model-deployment)
-- [MMSegmentation Model Deployment](#mmsegmentation-model-deployment)
-  - [Installation](#installation)
-    - [Install mmseg](#install-mmseg)
-    - [Install mmdeploy](#install-mmdeploy)
-  - [Convert model](#convert-model)
-  - [Model specification](#model-specification)
-  - [Model inference](#model-inference)
-    - [Backend model inference](#backend-model-inference)
-    - [SDK model inference](#sdk-model-inference)
-  - [Supported models](#supported-models)
-  - [Note](#note)
-
-______________________________________________________________________
-
-[MMSegmentation](https://github.com/open-mmlab/mmsegmentation/tree/main), also known as `mmseg`, is an open source semantic segmentation toolbox based on Pytorch. It's a part of the [OpenMMLab](<(https://openmmlab.com/)>) object.
-
-## Installation
-
-### Install mmseg
-
-Please follow the [Installation Guide](https://mmsegmentation.readthedocs.io/en/latest/get_started.html).
-
-### Install mmdeploy
-
-`mmdeploy` can be installed as follows:
-
-**Option 1:** Install precompiled package
-
-Please follow the [Installation overview](https://mmdeploy.readthedocs.io/zh_CN/latest/get_started.html#mmdeploy)
-
-**Option 2:**  Automatic Installation script
-
-If the deployment platform is **Ubuntu 18.04 +**, please follow the [scription installation](../01-how-to-build/build_from_script.md) to install.
-For example, the following commands describe how to install mmdeploy and inference engine-`ONNX Runtime`.
-
-```shell
-git clone --recursive -b main https://github.com/open-mmlab/mmdeploy.git
-cd mmdeploy
-python3 tools/scripts/build_ubuntu_x64_ort.py $(nproc)
-export PYTHONPATH=$(pwd)/build/lib:$PYTHONPATH
-export LD_LIBRARY_PATH=$(pwd)/../mmdeploy-dep/onnxruntime-linux-x64-1.8.1/lib/:$LD_LIBRARY_PATH
-```
-
-**NOTE**:
-
-- Add `$(pwd)/build/lib` to `PYTHONPATH`, can loading mmdeploy SDK python package `mmdeploy_runtime`. See [SDK model inference](#SDK-model-inference) for more information.
-- With [ONNX Runtime model inference](#Backend-model-inference), need to load custom operator library and add ONNX Runtime Library's PATH to `LD_LIBRARY_PATH`.
-
-**Option 3:**  Install with mim
-
-1. Use mim to install mmcv
-
-```shell
-pip install -U openmim
-mim install "mmcv>=2.0.0rc2"
-```
-
-2. Install mmdeploy
-
-```shell
-git clone https://github.com/open-mmlab/mmdeploy.git
-cd mmdeploy
-mim install -e .
-```
-
-**Option 4:**  Build MMDeploy from source
-
-If the first three methods aren't suitable, please [Build MMDeploy from source](<(../01-how-to-build/build_from_source.md)>)
-
-## Convert model
-
-[tools/deploy.py](https://github.com/open-mmlab/mmdeploy/tree/main/tools/deploy.py) can convert mmseg Model to backend model conveniently. See [this](https://github.com/open-mmlab/mmdeploy/tree/main/docs/en/02-how-to-run/convert_model.md#usage) for detailed information.
-
-Then convert `unet` to onnx model as follows:
-
-```shell
-cd mmdeploy
-
-# download unet model from mmseg model zoo
-mim download mmsegmentation --config unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024 --dest .
-
-# convert mmseg model to onnxruntime model with dynamic shape
-python tools/deploy.py \
-    configs/mmseg/segmentation_onnxruntime_dynamic.py \
-    unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py \
-    fcn_unet_s5-d16_4x4_512x1024_160k_cityscapes_20211210_145204-6860854e.pth \
-    demo/resources/cityscapes.png \
-    --work-dir mmdeploy_models/mmseg/ort \
-    --device cpu \
-    --show \
-    --dump-info
-```
-
-It is crucial to specify the correct deployment config during model conversion. MMDeploy has already provided builtin deployment config [files](https://github.com/open-mmlab/mmdeploy/tree/main/configs/mmseg) of all supported backends for mmsegmentation, under which the config file path follows the pattern:
-
-```
-segmentation_{backend}-{precision}_{static | dynamic}_{shape}.py
-```
-
-- **{backend}:** inference backend, such as onnxruntime, tensorrt, pplnn, ncnn, openvino, coreml etc.
-- **{precision}:** fp16, int8. When it's empty, it means fp32
-- **{static | dynamic}:** static shape or dynamic shape
-- **{shape}:** input shape or shape range of a model
-
-Therefore, in the above example, you can also convert `unet` to tensorrt-fp16 model by `segmentation_tensorrt-fp16_dynamic-512x1024-2048x2048.py`.
-
-```{tip}
-When converting mmsegmentation models to tensorrt models, --device should be set to "cuda"
-```
-
-## Model specification
-
-Before moving on to model inference chapter, let's know more about the converted model structure which is very important for model inference.
-
-The converted model locates in the working directory like `mmdeploy_models/mmseg/ort` in the previous example. It includes:
-
-```
-mmdeploy_models/mmseg/ort
-├── deploy.json
-├── detail.json
-├── end2end.onnx
-└── pipeline.json
-```
-
-in which,
-
-- **end2end.onnx**: backend model which can be inferred by ONNX Runtime
-- ***xxx*.json**: the necessary information for mmdeploy SDK
-
-The whole package **mmdeploy_models/mmseg/ort** is defined as **mmdeploy SDK model**, i.e., **mmdeploy SDK model** includes both backend model and inference meta information.
-
-## Model inference
-
-### Backend model inference
-
-Take the previous converted `end2end.onnx` model as an example, you can use the following code to inference the model and visualize the results:
-
-```python
-from mmdeploy.apis.utils import build_task_processor
-from mmdeploy.utils import get_input_shape, load_config
-import torch
-
-deploy_cfg = 'configs/mmseg/segmentation_onnxruntime_dynamic.py'
-model_cfg = './unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py'
-device = 'cpu'
-backend_model = ['./mmdeploy_models/mmseg/ort/end2end.onnx']
-image = './demo/resources/cityscapes.png'
-
-# read deploy_cfg and model_cfg
-deploy_cfg, model_cfg = load_config(deploy_cfg, model_cfg)
-
-# build task and backend model
-task_processor = build_task_processor(model_cfg, deploy_cfg, device)
-model = task_processor.build_backend_model(backend_model)
-
-# process input image
-input_shape = get_input_shape(deploy_cfg)
-model_inputs, _ = task_processor.create_input(image, input_shape)
-
-# do model inference
-with torch.no_grad():
-    result = model.test_step(model_inputs)
-
-# visualize results
-task_processor.visualize(
-    image=image,
-    model=model,
-    result=result[0],
-    window_name='visualize',
-    output_file='./output_segmentation.png')
-```
-
-### SDK model inference
-
-You can also perform SDK model inference like following:
-
-```python
-from mmdeploy_runtime import Segmentor
-import cv2
-import numpy as np
-
-img = cv2.imread('./demo/resources/cityscapes.png')
-
-# create a classifier
-segmentor = Segmentor(model_path='./mmdeploy_models/mmseg/ort', device_name='cpu', device_id=0)
-# perform inference
-seg = segmentor(img)
-
-# visualize inference result
-## random a palette with size 256x3
-palette = np.random.randint(0, 256, size=(256, 3))
-color_seg = np.zeros((seg.shape[0], seg.shape[1], 3), dtype=np.uint8)
-for label, color in enumerate(palette):
-    color_seg[seg == label, :] = color
-# convert to BGR
-color_seg = color_seg[..., ::-1]
-img = img * 0.5 + color_seg * 0.5
-img = img.astype(np.uint8)
-cv2.imwrite('output_segmentation.png', img)
-```
-
-Besides python API, mmdeploy SDK also provides other FFI (Foreign Function Interface), such as C, C++, C#, Java and so on. You can learn their usage from [demo](https://github.com/open-mmlab/mmdeploy/tree/main/demo)
-
-## Supported models
-
-| Model                                                                                                     | TorchScript | OnnxRuntime | TensorRT | ncnn | PPLNN | OpenVino |
-| :-------------------------------------------------------------------------------------------------------- | :---------: | :---------: | :------: | :--: | :---: | :------: |
-| [FCN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/fcn)                                 |      Y      |      Y      |    Y     |  Y   |   Y   |    Y     |
-| [PSPNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/pspnet)[\*](#static_shape)        |      Y      |      Y      |    Y     |  Y   |   Y   |    Y     |
-| [DeepLabV3](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/deeplabv3)                     |      Y      |      Y      |    Y     |  Y   |   Y   |    Y     |
-| [DeepLabV3+](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/deeplabv3plus)                |      Y      |      Y      |    Y     |  Y   |   Y   |    Y     |
-| [Fast-SCNN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/fastscnn)[\*](#static_shape)   |      Y      |      Y      |    Y     |  N   |   Y   |    Y     |
-| [UNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/unet)                               |      Y      |      Y      |    Y     |  Y   |   Y   |    Y     |
-| [ANN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/ann)[\*](#static_shape)              |      Y      |      Y      |    Y     |  N   |   N   |    N     |
-| [APCNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/apcnet)                           |      Y      |      Y      |    Y     |  Y   |   N   |    N     |
-| [BiSeNetV1](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/bisenetv1)                     |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
-| [BiSeNetV2](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/bisenetv2)                     |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
-| [CGNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/cgnet)                             |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
-| [DMNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/dmnet)                             |      ?      |      Y      |    N     |  N   |   N   |    N     |
-| [DNLNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/dnlnet)                           |      ?      |      Y      |    Y     |  Y   |   N   |    Y     |
-| [EMANet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/emanet)                           |      Y      |      Y      |    Y     |  N   |   N   |    Y     |
-| [EncNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/encnet)                           |      Y      |      Y      |    Y     |  N   |   N   |    Y     |
-| [ERFNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/erfnet)                           |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
-| [FastFCN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/fastfcn)                         |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
-| [GCNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/gcnet)                             |      Y      |      Y      |    Y     |  N   |   N   |    N     |
-| [ICNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/icnet)[\*](#static_shape)          |      Y      |      Y      |    Y     |  N   |   N   |    Y     |
-| [ISANet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/isanet)[\*](#static_shape)        |      N      |      Y      |    Y     |  N   |   N   |    Y     |
-| [NonLocal Net](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/nonlocal_net)               |      ?      |      Y      |    Y     |  Y   |   N   |    Y     |
-| [OCRNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/ocrnet)                           |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
-| [PointRend](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/point_rend)[\*](#static_shape) |      Y      |      Y      |    Y     |  N   |   N   |    N     |
-| [Semantic FPN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/sem_fpn)                    |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
-| [STDC](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/stdc)                               |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
-| [UPerNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/upernet)[\*](#static_shape)      |      N      |      Y      |    Y     |  N   |   N   |    N     |
-| [DANet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/danet)                             |      ?      |      Y      |    Y     |  N   |   N   |    Y     |
-| [Segmenter](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/segmenter)[\*](#static_shape)  |      N      |      Y      |    Y     |  Y   |   N   |    Y     |
-| [SegFormer](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/segformer)[\*](#static_shape)  |      ?      |      Y      |    Y     |  N   |   N   |    Y     |
-| [SETR](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/setr)                               |      ?      |      Y      |    N     |  N   |   N   |    Y     |
-| [CCNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/ccnet)                             |      ?      |      N      |    N     |  N   |   N   |    N     |
-| [PSANet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/psanet)                           |      ?      |      N      |    N     |  N   |   N   |    N     |
-| [DPT](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/dpt)                                 |      ?      |      N      |    N     |  N   |   N   |    N     |
-
-## Note
-
-- All mmseg models only support the 'whole' inference mode.
-
-- <i id=“static_shape”>PSPNet，Fast-SCNN</i> only supports static input, because most inference framework's [nn.AdaptiveAvgPool2d](https://github.com/open-mmlab/mmsegmentation/blob/0c87f7a0c9099844eff8e90fa3db5b0d0ca02fee/mmseg/models/decode_heads/psp_head.py#L38) don't support dynamic input。
-
-- For models that only support static shapes, should use the static shape deployment config file, such as `configs/mmseg/segmentation_tensorrt_static-1024x2048.py`
-
-- To deploy models to generate probabilistic feature maps, please add `codebase_config = dict(with_argmax=False)` to deployment config file.
diff --git a/mmsegmentation/docs/en/user_guides/index.rst b/mmsegmentation/docs/en/user_guides/index.rst
deleted file mode 100644
index 1feb127..0000000
--- a/mmsegmentation/docs/en/user_guides/index.rst
+++ /dev/null
@@ -1,21 +0,0 @@
-Train & Test
-**************
-
-.. toctree::
-   :maxdepth: 1
-
-   1_config.md
-   2_dataset_prepare.md
-   3_inference.md
-   4_train_test.md
-
-Useful Tools
-*************
-
-.. toctree::
-   :maxdepth: 2
-
-   visualization.md
-   useful_tools.md
-   deployment.md
-   visualization_feature_map.md
diff --git a/mmsegmentation/docs/en/user_guides/useful_tools.md b/mmsegmentation/docs/en/user_guides/useful_tools.md
deleted file mode 100644
index 0d86778..0000000
--- a/mmsegmentation/docs/en/user_guides/useful_tools.md
+++ /dev/null
@@ -1,245 +0,0 @@
-# \[WIP\] Useful Tools
-
-Apart from training/testing scripts, We provide lots of useful tools under the
-`tools/` directory.
-
-## Analysis Tools
-
-### Plot training logs
-
-`tools/analyze_logs.py` plots loss/mIoU curves given a training log file. `pip install seaborn` first to install the dependency.
-
-```shell
-python tools/analysis_tools/analyze_logs.py xxx.json [--keys ${KEYS}] [--legend ${LEGEND}] [--backend ${BACKEND}] [--style ${STYLE}] [--out ${OUT_FILE}]
-```
-
-Examples:
-
-- Plot the mIoU, mAcc, aAcc metrics.
-
-  ```shell
-  python tools/analysis_tools/analyze_logs.py log.json --keys mIoU mAcc aAcc --legend mIoU mAcc aAcc
-  ```
-
-- Plot loss metric.
-
-  ```shell
-  python tools/analysis_tools/analyze_logs.py log.json --keys loss --legend loss
-  ```
-
-### Confusion Matrix (experimental)
-
-In order to generate and plot a `nxn` confusion matrix where `n` is the number of classes, you can follow the steps:
-
-#### 1.Generate a prediction result in pkl format using `test.py`
-
-```shell
-python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${PATH_TO_RESULT_FILE}]
-```
-
-Example:
-
-```shell
-python tools/test.py \
-configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py \
-checkpoint/fcn_r50-d8_512x1024_40k_cityscapes_20200604_192608-efe53f0d.pth \
---out result/pred_result.pkl
-```
-
-#### 2. Use `confusion_matrix.py` to generate and plot a confusion matrix
-
-```shell
-python tools/confusion_matrix.py ${CONFIG_FILE} ${PATH_TO_RESULT_FILE} ${SAVE_DIR} --show
-```
-
-Description of arguments:
-
-- `config`: Path to the test config file.
-- `prediction_path`: Path to the prediction .pkl result.
-- `save_dir`: Directory where confusion matrix will be saved.
-- `--show`: Enable result visualize.
-- `--color-theme`: Theme of the matrix color map.
-- `--cfg_options`: Custom options to replace the config file.
-
-Example:
-
-```shell
-python tools/confusion_matrix.py \
-configs/fcn/fcn_r50-d8_512x1024_40k_cityscapes.py \
-result/pred_result.pkl \
-result/confusion_matrix \
---show
-```
-
-### Get the FLOPs and params (experimental)
-
-We provide a script adapted from [flops-counter.pytorch](https://github.com/sovrasov/flops-counter.pytorch) to compute the FLOPs and params of a given model.
-
-```shell
-python tools/analysis_tools/get_flops.py ${CONFIG_FILE} [--shape ${INPUT_SHAPE}]
-```
-
-You will get the result like this.
-
-```none
-==============================
-Input shape: (3, 2048, 1024)
-Flops: 1429.68 GMac
-Params: 48.98 M
-==============================
-```
-
-:::{note}
-This tool is still experimental and we do not guarantee that the number is correct. You may well use the result for simple comparisons, but double check it before you adopt it in technical reports or papers.
-:::
-
-(1) FLOPs are related to the input shape while parameters are not. The default input shape is (1, 3, 1280, 800).
-(2) Some operators are not counted into FLOPs like GN and custom operators.
-
-## Miscellaneous
-
-### Publish a model
-
-Before you upload a model to AWS, you may want to
-(1) convert model weights to CPU tensors, (2) delete the optimizer states and
-(3) compute the hash of the checkpoint file and append the hash id to the filename.
-
-```shell
-python tools/misc/publish_model.py ${INPUT_FILENAME} ${OUTPUT_FILENAME}
-```
-
-E.g.,
-
-```shell
-python tools/publish_model.py work_dirs/pspnet/latest.pth psp_r50_512x1024_40k_cityscapes.pth
-```
-
-The final output filename will be `psp_r50_512x1024_40k_cityscapes-{hash id}.pth`.
-
-### Print the entire config
-
-`tools/misc/print_config.py` prints the whole config verbatim, expanding all its
-imports.
-
-```shell
-python tools/misc/print_config.py \
-  ${CONFIG} \
-  --graph \
-  --cfg-options ${OPTIONS [OPTIONS...]} \
-```
-
-Description of arguments:
-
-- `config` : The path of a pytorch model config file.
-- `--graph` : Determines whether to print the models graph.
-- `--cfg-options`: Custom options to replace the config file.
-
-## Model conversion
-
-`tools/model_converters/` provide several scripts to convert pretrain models released by other repos to MMSegmentation style.
-
-### ViT Swin MiT Transformer Models
-
-- ViT
-
-  `tools/model_converters/vit2mmseg.py` convert keys in timm pretrained vit models to MMSegmentation style.
-
-  ```shell
-  python tools/model_converters/vit2mmseg.py ${SRC} ${DST}
-  ```
-
-- Swin
-
-  `tools/model_converters/swin2mmseg.py` convert keys in official pretrained swin models to MMSegmentation style.
-
-  ```shell
-  python tools/model_converters/swin2mmseg.py ${SRC} ${DST}
-  ```
-
-- SegFormer
-
-  `tools/model_converters/mit2mmseg.py` convert keys in official pretrained mit models to MMSegmentation style.
-
-  ```shell
-  python tools/model_converters/mit2mmseg.py ${SRC} ${DST}
-  ```
-
-## Model Serving
-
-In order to serve an `MMSegmentation` model with [`TorchServe`](https://pytorch.org/serve/), you can follow the steps:
-
-### 1. Convert model from MMSegmentation to TorchServe
-
-```shell
-python tools/torchserve/mmseg2torchserve.py ${CONFIG_FILE} ${CHECKPOINT_FILE} \
---output-folder ${MODEL_STORE} \
---model-name ${MODEL_NAME}
-```
-
-:::{note}
-${MODEL_STORE} needs to be an absolute path to a folder.
-:::
-
-### 2. Build `mmseg-serve` docker image
-
-```shell
-docker build -t mmseg-serve:latest docker/serve/
-```
-
-### 3. Run `mmseg-serve`
-
-Check the official docs for [running TorchServe with docker](https://github.com/pytorch/serve/blob/master/docker/README.md#running-torchserve-in-a-production-docker-environment).
-
-In order to run in GPU, you need to install [nvidia-docker](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html). You can omit the `--gpus` argument in order to run in CPU.
-
-Example:
-
-```shell
-docker run --rm \
---cpus 8 \
---gpus device=0 \
--p8080:8080 -p8081:8081 -p8082:8082 \
---mount type=bind,source=$MODEL_STORE,target=/home/model-server/model-store \
-mmseg-serve:latest
-```
-
-[Read the docs](https://github.com/pytorch/serve/blob/072f5d088cce9bb64b2a18af065886c9b01b317b/docs/rest_api.md) about the Inference (8080), Management (8081) and Metrics (8082) APIs
-
-### 4. Test deployment
-
-```shell
-curl -O https://raw.githubusercontent.com/open-mmlab/mmsegmentation/master/resources/3dogs.jpg
-curl http://127.0.0.1:8080/predictions/${MODEL_NAME} -T 3dogs.jpg -o 3dogs_mask.png
-```
-
-The response will be a ".png" mask.
-
-You can visualize the output as follows:
-
-```python
-import matplotlib.pyplot as plt
-import mmcv
-plt.imshow(mmcv.imread("3dogs_mask.png", "grayscale"))
-plt.show()
-```
-
-You should see something similar to:
-
-![3dogs_mask](../../resources/3dogs_mask.png)
-
-And you can use `test_torchserve.py` to compare result of torchserve and pytorch, and visualize them.
-
-```shell
-python tools/torchserve/test_torchserve.py ${IMAGE_FILE} ${CONFIG_FILE} ${CHECKPOINT_FILE} ${MODEL_NAME}
-[--inference-addr ${INFERENCE_ADDR}] [--result-image ${RESULT_IMAGE}] [--device ${DEVICE}]
-```
-
-Example:
-
-```shell
-python tools/torchserve/test_torchserve.py \
-demo/demo.png \
-configs/fcn/fcn_r50-d8_512x1024_40k_cityscapes.py \
-checkpoint/fcn_r50-d8_512x1024_40k_cityscapes_20200604_192608-efe53f0d.pth \
-fcn
-```
diff --git a/mmsegmentation/docs/en/user_guides/visualization.md b/mmsegmentation/docs/en/user_guides/visualization.md
deleted file mode 100644
index e7c3359..0000000
--- a/mmsegmentation/docs/en/user_guides/visualization.md
+++ /dev/null
@@ -1,174 +0,0 @@
-# Visualization
-
-MMSegmentation 1.x provides convenient ways for monitoring training status or visualizing data and model predictions.
-
-## Training status Monitor
-
-MMSegmentation 1.x uses TensorBoard to monitor training status.
-
-### TensorBoard Configuration
-
-Install TensorBoard following [official instructions](https://www.tensorflow.org/install) e.g.
-
-```shell
-pip install tensorboardX
-pip install future tensorboard
-```
-
-Add `TensorboardVisBackend` in `vis_backend` of `visualizer` in `default_runtime.py` config file:
-
-```python
-vis_backends = [dict(type='LocalVisBackend'),
-                dict(type='TensorboardVisBackend')]
-visualizer = dict(
-    type='SegLocalVisualizer', vis_backends=vis_backends, name='visualizer')
-```
-
-### Examining scalars in TensorBoard
-
-Launch training experiment e.g.
-
-```shell
-python tools/train.py configs/pspnet/pspnet_r50-d8_4xb4-80k_ade20k-512x512.py --work-dir work_dir/test_visual
-```
-
-Find the `vis_data` path of `work_dir` after starting training, for example, the vis_data path of this particular test is as follows:
-
-```shell
-work_dirs/test_visual/20220810_115248/vis_data
-```
-
-The scalar file in vis_data path includes learning rate, losses and data_time etc, also record metrics results and you can refer [logging tutorial](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/logging.html) in MMEngine to log custom data. The tensorboard visualization results are executed with the following command:
-
-```shell
-tensorboard --logdir work_dirs/test_visual/20220810_115248/vis_data
-```
-
-## Data and Results visualization
-
-### Visualizer Data Samples during Model Testing or Validation
-
-MMSegmentation provides `SegVisualizationHook` which is a [hook](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/hook.md) working to visualize ground truth and prediction of segmentation during model testing and evaluation. Its configuration is in `default_hooks`, please see [Runner tutorial](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/runner.md) for more details.
-
-For example, In `_base_/schedules/schedule_20k.py`, modify the `SegVisualizationHook` configuration, set `draw` to `True` to enable the storage of network inference results, `interval` indicates the sampling interval of the prediction results, and when set to 1, each inference result of the network will be saved. `interval` is set to 50 by default:
-
-```python
-default_hooks = dict(
-    timer=dict(type='IterTimerHook'),
-    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
-    param_scheduler=dict(type='ParamSchedulerHook'),
-    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=2000),
-    sampler_seed=dict(type='DistSamplerSeedHook'),
-    visualization=dict(type='SegVisualizationHook', draw=True, interval=1))
-
-```
-
-After launch training experiment, visualization results will be stored in the local folder in validation loop,
-or when launch evaluation a model on one dataset, the prediction results will be store in the local.
-The stored results of the local visualization are kept in `vis_image` under `$WORK_DIRS/vis_data`, e.g.:
-
-```shell
-work_dirs/test_visual/20220810_115248/vis_data/vis_image
-```
-
-In addition, if `TensorboardVisBackend` is add in `vis_backends`, like [above](#tensorboard-configuration),
-we can also run the following command to view them in TensorBoard:
-
-```shell
-tensorboard --logdir work_dirs/test_visual/20220810_115248/vis_data
-```
-
-### Visualize a Single Data Sample
-
-If you want to visualize a single data sample, we suggest to use `SegLocalVisualizer`.
-
-`SegLocalVisualizer` is child class inherits from `Visualizer` in MMEngine and works for MMSegmentation visualization, for more details about `Visualizer` please refer to [visualization tutorial](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/visualization.md) in MMEngine.
-
-Here is an example about `SegLocalVisualizer`, first you may download example data below by following commands:
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/189833109-eddad58f-f777-4fc0-b98a-6bd429143b06.png" width="70%"/>
-</div>
-
-```shell
-wget https://user-images.githubusercontent.com/24582831/189833109-eddad58f-f777-4fc0-b98a-6bd429143b06.png --output-document aachen_000000_000019_leftImg8bit.png
-wget https://user-images.githubusercontent.com/24582831/189833143-15f60f8a-4d1e-4cbb-a6e7-5e2233869fac.png --output-document aachen_000000_000019_gtFine_labelTrainIds.png
-```
-
-Then you can find their local path and use the scripts below to visualize:
-
-```python
-import mmcv
-import os.path as osp
-import torch
-# `PixelData` is data structure for pixel-level annotations or predictions defined in MMEngine.
-# Please refer to below tutorial file of data structures in MMEngine:
-# https://github.com/open-mmlab/mmengine/tree/main/docs/en/advanced_tutorials/data_element.md
-
-from mmengine.structures import PixelData
-
-# `SegDataSample` is data structure interface between different components
-# defined in MMSegmentation, it includes ground truth, prediction and
-# predicted logits of semantic segmentation.
-# Please refer to below tutorial file of `SegDataSample` for more details:
-# https://github.com/open-mmlab/mmsegmentation/blob/1.x/docs/en/advanced_guides/structures.md
-
-from mmseg.structures import SegDataSample
-from mmseg.visualization import SegLocalVisualizer
-
-out_file = 'out_file_cityscapes'
-save_dir = './work_dirs'
-
-image = mmcv.imread(
-    osp.join(
-        osp.dirname(__file__),
-        './aachen_000000_000019_leftImg8bit.png'
-    ),
-    'color')
-sem_seg = mmcv.imread(
-    osp.join(
-        osp.dirname(__file__),
-        './aachen_000000_000019_gtFine_labelTrainIds.png'  # noqa
-    ),
-    'unchanged')
-sem_seg = torch.from_numpy(sem_seg)
-gt_sem_seg_data = dict(data=sem_seg)
-gt_sem_seg = PixelData(**gt_sem_seg_data)
-data_sample = SegDataSample()
-data_sample.gt_sem_seg = gt_sem_seg
-
-seg_local_visualizer = SegLocalVisualizer(
-    vis_backends=[dict(type='LocalVisBackend')],
-    save_dir=save_dir)
-
-# The meta information of dataset usually includes `classes` for class names and
-# `palette` for visualization color of each foreground.
-# All class names and palettes are defined in the file:
-# https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/utils/class_names.py
-
-seg_local_visualizer.dataset_meta = dict(
-    classes=('road', 'sidewalk', 'building', 'wall', 'fence',
-             'pole', 'traffic light', 'traffic sign',
-             'vegetation', 'terrain', 'sky', 'person', 'rider',
-             'car', 'truck', 'bus', 'train', 'motorcycle',
-             'bicycle'),
-    palette=[[128, 64, 128], [244, 35, 232], [70, 70, 70],
-             [102, 102, 156], [190, 153, 153], [153, 153, 153],
-             [250, 170, 30], [220, 220, 0], [107, 142, 35],
-             [152, 251, 152], [70, 130, 180], [220, 20, 60],
-             [255, 0, 0], [0, 0, 142], [0, 0, 70],
-             [0, 60, 100], [0, 80, 100], [0, 0, 230],
-             [119, 11, 32]])
-# When `show=True`, the results would be shown directly,
-# else if `show=False`, the results would be saved in local directory folder.
-seg_local_visualizer.add_datasample(out_file, image,
-                                    data_sample, show=False)
-```
-
-Then the visualization result of image with its corresponding ground truth could be found in `./work_dirs/vis_data/vis_image/` whose name is `out_file_cityscapes_0.png`:
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/189835713-c0534054-4bfa-4b75-9254-0afbeb5ff02e.png" width="70%"/>
-</div>
-
-If you would like to know more visualization usage, you can refer to [visualization tutorial](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/visualization.html) in MMEngine.
diff --git a/mmsegmentation/docs/en/user_guides/visualization_feature_map.md b/mmsegmentation/docs/en/user_guides/visualization_feature_map.md
deleted file mode 100644
index 08398e5..0000000
--- a/mmsegmentation/docs/en/user_guides/visualization_feature_map.md
+++ /dev/null
@@ -1,201 +0,0 @@
-# Wandb Feature Map Visualization
-
-MMSegmentation 1.x provides backend support for Weights & Biases to facilitate visualization and management of project code results.
-
-## Wandb Configuration
-
-Install Weights & Biases following [official instructions](https://docs.wandb.ai/quickstart) e.g.
-
-```shell
-pip install wandb
-wandb login
-```
-
-Add `WandbVisBackend` in `vis_backend` of `visualizer` in `default_runtime.py` config file:
-
-```python
-vis_backends=[dict(type='LocalVisBackend'),
-              dict(type='TensorboardVisBackend'),
-              dict(type='WandbVisBackend')]
-```
-
-## Examining feature map visualization in Wandb
-
-`SegLocalVisualizer` is child class inherits from `Visualizer` in MMEngine and works for MMSegmentation visualization, for more details about `Visualizer` please refer to [visualization tutorial](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/visualization.md) in MMEngine.
-
-Here is an example about `SegLocalVisualizer`, first you may download example data below by following commands:
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/189833109-eddad58f-f777-4fc0-b98a-6bd429143b06.png" width="70%"/>
-</div>
-
-```shell
-wget https://user-images.githubusercontent.com/24582831/189833109-eddad58f-f777-4fc0-b98a-6bd429143b06.png --output-document aachen_000000_000019_leftImg8bit.png
-wget https://user-images.githubusercontent.com/24582831/189833143-15f60f8a-4d1e-4cbb-a6e7-5e2233869fac.png --output-document aachen_000000_000019_gtFine_labelTrainIds.png
-
-wget https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x1024_40k_cityscapes/ann_r50-d8_512x1024_40k_cityscapes_20200605_095211-049fc292.pth
-
-```
-
-```python
-# Copyright (c) OpenMMLab. All rights reserved.
-from argparse import ArgumentParser
-from typing import Type
-
-import mmcv
-import torch
-import torch.nn as nn
-
-from mmengine.model import revert_sync_batchnorm
-from mmengine.structures import PixelData
-from mmseg.apis import inference_model, init_model
-from mmseg.structures import SegDataSample
-from mmseg.utils import register_all_modules
-from mmseg.visualization import SegLocalVisualizer
-
-
-class Recorder:
-    """record the forward output feature map and save to data_buffer."""
-
-    def __init__(self) -> None:
-        self.data_buffer = list()
-
-    def __enter__(self, ):
-        self._data_buffer = list()
-
-    def record_data_hook(self, model: nn.Module, input: Type, output: Type):
-        self.data_buffer.append(output)
-
-    def __exit__(self, *args, **kwargs):
-        pass
-
-
-def visualize(args, model, recorder, result):
-    seg_visualizer = SegLocalVisualizer(
-        vis_backends=[dict(type='WandbVisBackend')],
-        save_dir='temp_dir',
-        alpha=0.5)
-    seg_visualizer.dataset_meta = dict(
-        classes=model.dataset_meta['classes'],
-        palette=model.dataset_meta['palette'])
-
-    image = mmcv.imread(args.img, 'color')
-
-    seg_visualizer.add_datasample(
-        name='predict',
-        image=image,
-        data_sample=result,
-        draw_gt=False,
-        draw_pred=True,
-        wait_time=0,
-        out_file=None,
-        show=False)
-
-    # add feature map to wandb visualizer
-    for i in range(len(recorder.data_buffer)):
-        feature = recorder.data_buffer[i][0]  # remove the batch
-        drawn_img = seg_visualizer.draw_featmap(
-            feature, image, channel_reduction='select_max')
-        seg_visualizer.add_image(f'feature_map{i}', drawn_img)
-
-    if args.gt_mask:
-        sem_seg = mmcv.imread(args.gt_mask, 'unchanged')
-        sem_seg = torch.from_numpy(sem_seg)
-        gt_mask = dict(data=sem_seg)
-        gt_mask = PixelData(**gt_mask)
-        data_sample = SegDataSample()
-        data_sample.gt_sem_seg = gt_mask
-
-        seg_visualizer.add_datasample(
-            name='gt_mask',
-            image=image,
-            data_sample=data_sample,
-            draw_gt=True,
-            draw_pred=False,
-            wait_time=0,
-            out_file=None,
-            show=False)
-
-    seg_visualizer.add_image('image', image)
-
-
-def main():
-    parser = ArgumentParser(
-        description='Draw the Feature Map During Inference')
-    parser.add_argument('img', help='Image file')
-    parser.add_argument('config', help='Config file')
-    parser.add_argument('checkpoint', help='Checkpoint file')
-    parser.add_argument('--gt_mask', default=None, help='Path of gt mask file')
-    parser.add_argument('--out-file', default=None, help='Path to output file')
-    parser.add_argument(
-        '--device', default='cuda:0', help='Device used for inference')
-    parser.add_argument(
-        '--opacity',
-        type=float,
-        default=0.5,
-        help='Opacity of painted segmentation map. In (0, 1] range.')
-    parser.add_argument(
-        '--title', default='result', help='The image identifier.')
-    args = parser.parse_args()
-
-    register_all_modules()
-
-    # build the model from a config file and a checkpoint file
-    model = init_model(args.config, args.checkpoint, device=args.device)
-    if args.device == 'cpu':
-        model = revert_sync_batchnorm(model)
-
-    # show all named module in the model and use it in source list below
-    for name, module in model.named_modules():
-        print(name)
-
-    source = [
-        'decode_head.fusion.stages.0.query_project.activate',
-        'decode_head.context.stages.0.key_project.activate',
-        'decode_head.context.bottleneck.activate'
-    ]
-    source = dict.fromkeys(source)
-
-    count = 0
-    recorder = Recorder()
-    # registry the forward hook
-    for name, module in model.named_modules():
-        if name in source:
-            count += 1
-            module.register_forward_hook(recorder.record_data_hook)
-            if count == len(source):
-                break
-
-    with recorder:
-        # test a single image, and record feature map to data_buffer
-        result = inference_model(model, args.img)
-
-    visualize(args, model, recorder, result)
-
-
-if __name__ == '__main__':
-    main()
-
-```
-
-Save the above code as feature_map_visual.py and execute the  following code in terminal
-
-```shell
-python feature_map_visual.py ${image} ${config} ${checkpoint} [optional args]
-```
-
-e.g
-
-```shell
-python feature_map_visual.py \
-aachen_000000_000019_leftImg8bit.png \
-configs/ann/ann_r50-d8_4xb2-40k_cityscapes-512x1024.py \
-ann_r50-d8_512x1024_40k_cityscapes_20200605_095211-049fc292.pth \
---gt_mask aachen_000000_000019_gtFine_labelTrainIds.png
-```
-
-The visualized image result and its corresponding feature map will appear in the wandb account.
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/76149310/217520321-647f5bf9-eef2-446d-a9e8-5ca7b621d500.png">
-</div>
diff --git a/mmsegmentation/docs/zh_cn/.readthedocs.yaml b/mmsegmentation/docs/zh_cn/.readthedocs.yaml
deleted file mode 100644
index fc3efd0..0000000
--- a/mmsegmentation/docs/zh_cn/.readthedocs.yaml
+++ /dev/null
@@ -1,17 +0,0 @@
-version: 2
-
-build:
-  os: ubuntu-22.04
-  tools:
-    python: "3.8"
-
-formats:
-    - epub
-
-sphinx:
-  configuration: docs/zh_cn/conf.py
-
-python:
-  install:
-    - requirements: requirements/docs.txt
-    - requirements: requirements/readthedocs.txt
diff --git a/mmsegmentation/docs/zh_cn/Makefile b/mmsegmentation/docs/zh_cn/Makefile
deleted file mode 100644
index d4bb2cb..0000000
--- a/mmsegmentation/docs/zh_cn/Makefile
+++ /dev/null
@@ -1,20 +0,0 @@
-# Minimal makefile for Sphinx documentation
-#
-
-# You can set these variables from the command line, and also
-# from the environment for the first two.
-SPHINXOPTS    ?=
-SPHINXBUILD   ?= sphinx-build
-SOURCEDIR     = .
-BUILDDIR      = _build
-
-# Put it first so that "make" without argument is like "make help".
-help:
-	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
-
-.PHONY: help Makefile
-
-# Catch-all target: route all unknown targets to Sphinx using the new
-# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
-%: Makefile
-	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
diff --git a/mmsegmentation/docs/zh_cn/_static/css/readthedocs.css b/mmsegmentation/docs/zh_cn/_static/css/readthedocs.css
deleted file mode 100644
index 2e38d08..0000000
--- a/mmsegmentation/docs/zh_cn/_static/css/readthedocs.css
+++ /dev/null
@@ -1,6 +0,0 @@
-.header-logo {
-    background-image: url("../images/mmsegmentation.png");
-    background-size: 201px 40px;
-    height: 40px;
-    width: 201px;
-}
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/add_datasets.md b/mmsegmentation/docs/zh_cn/advanced_guides/add_datasets.md
deleted file mode 100644
index 316feb0..0000000
--- a/mmsegmentation/docs/zh_cn/advanced_guides/add_datasets.md
+++ /dev/null
@@ -1,199 +0,0 @@
-# 新增自定义数据集
-
-## 新增自定义数据集
-
-在这里，我们展示如何构建一个新的数据集。
-
-1. 创建一个新文件 `mmseg/datasets/example.py`
-
-   ```python
-   from mmseg.registry import DATASETS
-   from .basesegdataset import BaseSegDataset
-
-
-   @DATASETS.register_module()
-   class ExampleDataset(BaseSegDataset):
-
-       METAINFO = dict(
-           classes=('xxx', 'xxx', ...),
-           palette=[[x, x, x], [x, x, x], ...])
-
-       def __init__(self, arg1, arg2):
-           pass
-   ```
-
-2. 在 `mmseg/datasets/__init__.py` 中导入模块
-
-   ```python
-   from .example import ExampleDataset
-   ```
-
-3. 通过创建一个新的数据集配置文件 `configs/_base_/datasets/example_dataset.py` 来使用它
-
-   ```python
-   dataset_type = 'ExampleDataset'
-   data_root = 'data/example/'
-   ...
-   ```
-
-4. 在 `mmseg/utils/class_names.py` 中补充数据集元信息
-
-   ```python
-   def example_classes():
-       return [
-           'xxx', 'xxx',
-           ...
-       ]
-
-   def example_palette():
-       return [
-           [x, x, x], [x, x, x],
-           ...
-       ]
-   dataset_aliases ={
-       'example': ['example', ...],
-       ...
-   }
-   ```
-
-**注意：** 如果新数据集不满足 mmseg 的要求，则需要在 `tools/dataset_converters/` 中准备一个数据集预处理脚本
-
-## 通过重新组织数据来定制数据集
-
-最简单的方法是将您的数据集进行转化，并组织成文件夹的形式。
-
-如下的文件结构就是一个例子。
-
-```none
-├── data
-│   ├── my_dataset
-│   │   ├── img_dir
-│   │   │   ├── train
-│   │   │   │   ├── xxx{img_suffix}
-│   │   │   │   ├── yyy{img_suffix}
-│   │   │   │   ├── zzz{img_suffix}
-│   │   │   ├── val
-│   │   ├── ann_dir
-│   │   │   ├── train
-│   │   │   │   ├── xxx{seg_map_suffix}
-│   │   │   │   ├── yyy{seg_map_suffix}
-│   │   │   │   ├── zzz{seg_map_suffix}
-│   │   │   ├── val
-
-```
-
-一个训练对将由 img_dir/ann_dir 里同样首缀的文件组成。
-
-有些数据集不会发布测试集或测试集的标注，如果没有测试集的标注，我们就无法在本地进行评估模型，因此我们在配置文件中将验证集设置为默认测试集。
-
-关于如何构建自己的数据集或实现新的数据集类，请参阅[数据集指南](./datasets.md)以获取更多详细信息。
-
-**注意：** 标注是跟图像同样的形状 (H, W)，其中的像素值的范围是 `[0, num_classes - 1]`。
-您也可以使用 [pillow](https://pillow.readthedocs.io/en/stable/handbook/concepts.html#palette) 的 `'P'` 模式去创建包含颜色的标注。
-
-## 通过混合数据去定制数据集
-
-MMSegmentation 同样支持混合数据集去训练。
-当前它支持拼接 (concat), 重复 (repeat) 和多图混合 (multi-image mix) 数据集。
-
-### 重复数据集
-
-我们使用 `RepeatDataset` 作为包装 (wrapper) 去重复数据集。
-例如，假设原始数据集是 `Dataset_A`，为了重复它，配置文件如下：
-
-```python
-dataset_A_train = dict(
-    type='RepeatDataset',
-    times=N,
-    dataset=dict(  # 这是 Dataset_A 数据集的原始配置
-        type='Dataset_A',
-        ...
-        pipeline=train_pipeline
-    )
-)
-```
-
-### 拼接数据集
-
-如果要拼接不同的数据集，可以按如下方式连接数据集配置。
-
-```python
-dataset_A_train = dict()
-dataset_B_train = dict()
-concatenate_dataset = dict(
-    type='ConcatDataset',
-    datasets=[dataset_A_train, dataset_B_train])
-```
-
-下面是一个更复杂的示例，它分别重复 `Dataset_A` 和 `Dataset_B` N 次和 M 次，然后连接重复的数据集。
-
-```python
-dataset_A_train = dict(
-    type='RepeatDataset',
-    times=N,
-    dataset=dict(
-        type='Dataset_A',
-        ...
-        pipeline=train_pipeline
-    )
-)
-dataset_A_val = dict(
-    ...
-    pipeline=test_pipeline
-)
-dataset_A_test = dict(
-    ...
-    pipeline=test_pipeline
-)
-dataset_B_train = dict(
-    type='RepeatDataset',
-    times=M,
-    dataset=dict(
-        type='Dataset_B',
-        ...
-        pipeline=train_pipeline
-    )
-)
-train_dataloader = dict(
-    dataset=dict(
-        type='ConcatDataset',
-        datasets=[dataset_A_train, dataset_B_train]))
-
-val_dataloader = dict(dataset=dataset_A_val)
-test_dataloader = dict(dataset=dataset_A_test)
-
-```
-
-您可以参考 mmengine 的基础数据集[教程](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/basedataset.html)以了解更多详细信息
-
-### 多图混合集
-
-我们使用 `MultiImageMixDataset` 作为包装（wrapper）去混合多个数据集的图片。
-`MultiImageMixDataset`可以被类似 mosaic 和 mixup 的多图混合数据増广使用。
-
-`MultiImageMixDataset` 与 `Mosaic` 数据増广一起使用的例子：
-
-```python
-train_pipeline = [
-    dict(type='RandomMosaic', prob=1),
-    dict(type='Resize', img_scale=(1024, 512), keep_ratio=True),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PackSegInputs')
-]
-
-train_dataset = dict(
-    type='MultiImageMixDataset',
-    dataset=dict(
-        type=dataset_type,
-        reduce_zero_label=False,
-        img_dir=data_root + "images/train",
-        ann_dir=data_root + "annotations/train",
-        pipeline=[
-            dict(type='LoadImageFromFile'),
-            dict(type='LoadAnnotations'),
-        ]
-    ),
-    pipeline=train_pipeline
-)
-
-```
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/add_metrics.md b/mmsegmentation/docs/zh_cn/advanced_guides/add_metrics.md
deleted file mode 100644
index 0637b44..0000000
--- a/mmsegmentation/docs/zh_cn/advanced_guides/add_metrics.md
+++ /dev/null
@@ -1,81 +0,0 @@
-# 新增评测指标
-
-## 使用 MMSegmentation 的源代码进行开发
-
-在这里，我们用 `CustomMetric` 作为例子来展示如何开发一个新的评测指标。
-
-1. 创建一个新文件 `mmseg/evaluation/metrics/custom_metric.py`。
-
-   ```python
-   from typing import List, Sequence
-
-   from mmengine.evaluator import BaseMetric
-
-   from mmseg.registry import METRICS
-
-
-   @METRICS.register_module()
-   class CustomMetric(BaseMetric):
-
-       def __init__(self, arg1, arg2):
-           """
-           The metric first processes each batch of data_samples and predictions,
-           and appends the processed results to the results list. Then it
-           collects all results together from all ranks if distributed training
-           is used. Finally, it computes the metrics of the entire dataset.
-           """
-
-       def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
-           pass
-
-       def compute_metrics(self, results: list) -> dict:
-           pass
-
-       def evaluate(self, size: int) -> dict:
-           pass
-   ```
-
-   在上面的示例中，`CustomMetric` 是 `BaseMetric` 的子类。它有三个方法：`process`，`compute_metrics` 和 `evaluate`。
-
-   - `process()` 处理一批数据样本和预测。处理后的结果需要显示地传给 `self.results` ，将在处理所有数据样本后用于计算指标。更多细节请参考 [MMEngine 文档](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/design/evaluation.md)
-
-   - `compute_metrics()` 用于从处理后的结果中计算指标。
-
-   - `evaluate()` 是一个接口，用于计算指标并返回结果。它将由 `ValLoop` 或 `TestLoop` 在 `Runner` 中调用。在大多数情况下，您不需要重写此方法，但如果您想做一些额外的工作，可以重写它。
-
-   **注意：** 您可以在[这里](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py#L366) 找到 `Runner` 调用 `evaluate()` 方法的过程。`Runner` 是训练和测试过程的执行器，您可以在[训练引擎文档](./engine.md)中找到有关它的详细信息。
-
-2. 在 `mmseg/evaluation/metrics/__init__.py` 中导入新的指标。
-
-   ```python
-   from .custom_metric import CustomMetric
-   __all__ = ['CustomMetric', ...]
-   ```
-
-3. 在配置文件中设置新的评测指标
-
-   ```python
-   val_evaluator = dict(type='CustomMetric', arg1=xxx, arg2=xxx)
-   test_evaluator = dict(type='CustomMetric', arg1=xxx, arg2=xxx)
-   ```
-
-## 使用发布版本的 MMSegmentation 进行开发
-
-上面的示例展示了如何使用 MMSegmentation 的源代码开发新指标。如果您想使用 MMSegmentation 的发布版本开发新指标，可以按照以下步骤操作。
-
-1. 创建一个新文件 `/Path/to/metrics/custom_metric.py`，实现 `process`，`compute_metrics` 和 `evaluate` 方法，`evaluate` 方法是可选的。
-
-2. 在代码或配置文件中导入新的指标。
-
-   ```python
-   from path.to.metrics import CustomMetric
-   ```
-
-   或者
-
-   ```python
-   custom_imports = dict(imports=['/Path/to/metrics'], allow_failed_imports=False)
-
-   val_evaluator = dict(type='CustomMetric', arg1=xxx, arg2=xxx)
-   test_evaluator = dict(type='CustomMetric', arg1=xxx, arg2=xxx)
-   ```
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/add_models.md b/mmsegmentation/docs/zh_cn/advanced_guides/add_models.md
deleted file mode 100644
index e05c07c..0000000
--- a/mmsegmentation/docs/zh_cn/advanced_guides/add_models.md
+++ /dev/null
@@ -1,260 +0,0 @@
-# 新增模块
-
-## 开发新组件
-
-我们可以自定义 [模型文档](./models.md) 中介绍的所有组件，例如**主干网络（backbone）**、**头（head）**、**损失函数（loss function）**和**数据预处理器（data preprocessor）**。
-
-### 添加新的主干网络（backbone）
-
-在这里，我们以 MobileNet 为例展示如何开发新的主干网络。
-
-1. 创建一个新文件 `mmseg/models/backbones/mobilenet.py`。
-
-   ```python
-   import torch.nn as nn
-
-   from mmseg.registry import MODELS
-
-
-   @MODELS.register_module()
-   class MobileNet(nn.Module):
-
-       def __init__(self, arg1, arg2):
-           pass
-
-       def forward(self, x):  # should return a tuple
-           pass
-
-       def init_weights(self, pretrained=None):
-           pass
-   ```
-
-2. 在 `mmseg/models/backbones/__init__.py` 中引入模块。
-
-   ```python
-   from .mobilenet import MobileNet
-   ```
-
-3. 在配置文件中使用它。
-
-   ```python
-   model = dict(
-       ...
-       backbone=dict(
-           type='MobileNet',
-           arg1=xxx,
-           arg2=xxx),
-       ...
-   ```
-
-### 添加新的头（head）
-
-在 MMSegmentation 中，我们提供 [BaseDecodeHead](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/models/decode_heads/decode_head.py#L17) 用于开发所有分割头。
-所有新实现的解码头都应该从中派生出来。
-接下来我们以 [PSPNet](https://arxiv.org/abs/1612.01105) 为例说明如何开发新的头。
-
-首先，在 `mmseg/models/decode_heads/psp_head.py` 中添加一个新的解码头。
-PSPNet 实现了用于分割解码的解码头。
-为了实现解码头，在新模块中我们需要执行以下三个函数。
-
-```python
-from mmseg.registry import MODELS
-
-@MODELS.register_module()
-class PSPHead(BaseDecodeHead):
-
-    def __init__(self, pool_scales=(1, 2, 3, 6), **kwargs):
-        super(PSPHead, self).__init__(**kwargs)
-
-    def init_weights(self):
-        pass
-
-    def forward(self, inputs):
-        pass
-```
-
-接下来，用户需要在 `mmseg/models/decode_heads/__init__.py` 中添加模块，这样相应的注册器就可以找到并加载它们。
-
-PSPNet 的配置文件如下
-
-```python
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    type='EncoderDecoder',
-    pretrained='pretrain_model/resnet50_v1c_trick-2cccc1ad.pth',
-    backbone=dict(
-        type='ResNetV1c',
-        depth=50,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        dilations=(1, 1, 2, 4),
-        strides=(1, 2, 1, 1),
-        norm_cfg=norm_cfg,
-        norm_eval=False,
-        style='pytorch',
-        contract_dilation=True),
-    decode_head=dict(
-        type='PSPHead',
-        in_channels=2048,
-        in_index=3,
-        channels=512,
-        pool_scales=(1, 2, 3, 6),
-        dropout_ratio=0.1,
-        num_classes=19,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)))
-
-```
-
-### 添加新的损失函数（loss）
-
-假设您想为分割解码添加一个叫做 `MyLoss` 的新的损失函数。
-要添加新的损失函数，用户需要在 `mmseg/models/loss/my_loss.py` 中实现它。
-修饰器 `weighted_loss` 可以对损失的每个元素进行加权。
-
-```python
-import torch
-import torch.nn as nn
-
-from mmseg.registry import MODELS
-from .utils import weighted_loss
-
-@weighted_loss
-def my_loss(pred, target):
-    assert pred.size() == target.size() and target.numel() > 0
-    loss = torch.abs(pred - target)
-    return loss
-
-@MODELS.register_module()
-class MyLoss(nn.Module):
-
-    def __init__(self, reduction='mean', loss_weight=1.0):
-        super(MyLoss, self).__init__()
-        self.reduction = reduction
-        self.loss_weight = loss_weight
-
-    def forward(self,
-                pred,
-                target,
-                weight=None,
-                avg_factor=None,
-                reduction_override=None):
-        assert reduction_override in (None, 'none', 'mean', 'sum')
-        reduction = (
-            reduction_override if reduction_override else self.reduction)
-        loss = self.loss_weight * my_loss(
-            pred, target, weight, reduction=reduction, avg_factor=avg_factor)
-        return loss
-```
-
-然后，用户需要将其添加到 `mmseg/models/loss/__init__.py` 中。
-
-```python
-from .my_loss import MyLoss, my_loss
-
-```
-
-要使用它，请修改 `loss_xx` 字段。
-然后需要修改头中的 `loss_decode` 字段。
-`loss_weight` 可用于平衡多重损失。
-
-```python
-loss_decode=dict(type='MyLoss', loss_weight=1.0))
-```
-
-### 添加新的数据预处理器（data preprocessor）
-
-在 MMSegmentation 1.x 版本中，我们使用 [SegDataPreProcessor](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/data_preprocessor.py#L13) 将数据复制到目标设备，并将数据预处理为默认的模型输入格式。这里我们将展示如何开发一个新的数据预处理器。
-
-1. 创建一个新文件 `mmseg/models/my_datapreprocessor.py`。
-
-   ```python
-   from mmengine.model import BaseDataPreprocessor
-
-   from mmseg.registry import MODELS
-
-   @MODELS.register_module()
-   class MyDataPreProcessor(BaseDataPreprocessor):
-       def __init__(self, **kwargs):
-           super().__init__(**kwargs)
-
-       def forward(self, data: dict, training: bool=False) -> Dict[str, Any]:
-           # TODO Define the logic for data pre-processing in the forward method
-           pass
-   ```
-
-2. 在 `mmseg/models/__init__.py` 中导入数据预处理器
-
-   ```python
-   from .my_datapreprocessor import MyDataPreProcessor
-   ```
-
-3. 在配置文件中使用它。
-
-   ```python
-   model = dict(
-       data_preprocessor=dict(type='MyDataPreProcessor)
-       ...
-   )
-   ```
-
-## 开发新的分割器（segmentor）
-
-分割器是一种户可以通过添加自定义组件和定义算法执行逻辑来自定义其算法的算法架构。请参考[模型文档](./models.md)了解更多详情。
-
-由于 MMSegmentation 中的 [BaseSegmenter](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/models/segmentors/base.py#L15) 统一了前向过程的三种模式，为了开发新的分割器，用户需要重写与 `loss`、`predict` 和 `tensor` 相对应的 `loss`、`predict` 和 `_forward` 方法。
-
-这里我们将展示如何开发一个新的分割器。
-
-1. 创建一个新文件 `mmseg/models/segmentors/my_segmentor.py`。
-
-   ```python
-    from typing import Dict, Optional, Union
-
-    import torch
-
-    from mmseg.registry import MODELS
-    from mmseg.models import BaseSegmentor
-
-    @MODELS.register_module()
-    class MySegmentor(BaseSegmentor):
-        def __init__(self, **kwargs):
-            super().__init__(**kwargs)
-            # TODO users should build components of the network here
-
-        def loss(self, inputs: Tensor, data_samples: SampleList) -> dict:
-            """Calculate losses from a batch of inputs and data samples."""
-            pass
-
-        def predict(self, inputs: Tensor, data_samples: OptSampleList=None) -> SampleList:
-            """Predict results from a batch of inputs and data samples with post-
-            processing."""
-            pass
-
-       def _forward(self,
-                 inputs: Tensor,
-                 data_samples: OptSampleList = None) -> Tuple[List[Tensor]]:
-            """Network forward process.
-
-            Usually includes backbone, neck and head forward without any post-
-            processing.
-            """
-            pass
-   ```
-
-2. 在 `mmseg/models/segmentors/__init__.py` 中导入分割器。
-
-   ```python
-   from .my_segmentor import MySegmentor
-   ```
-
-3. 在配置文件中使用它。
-
-   ```python
-   model = dict(
-       type='MySegmentor'
-       ...
-   )
-   ```
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/add_transforms.md b/mmsegmentation/docs/zh_cn/advanced_guides/add_transforms.md
deleted file mode 100644
index d720668..0000000
--- a/mmsegmentation/docs/zh_cn/advanced_guides/add_transforms.md
+++ /dev/null
@@ -1,51 +0,0 @@
-# 新增数据增强
-
-## 自定义数据增强
-
-自定义数据增强必须继承 `BaseTransform` 并实现 `transform` 函数。这里我们使用一个简单的翻转变换作为示例：
-
-```python
-import random
-import mmcv
-from mmcv.transforms import BaseTransform, TRANSFORMS
-
-@TRANSFORMS.register_module()
-class MyFlip(BaseTransform):
-    def __init__(self, direction: str):
-        super().__init__()
-        self.direction = direction
-
-    def transform(self, results: dict) -> dict:
-        img = results['img']
-        results['img'] = mmcv.imflip(img, direction=self.direction)
-        return results
-```
-
-此外，新的类需要被导入。
-
-```python
-from .my_pipeline import MyFlip
-```
-
-这样，我们就可以实例化一个 `MyFlip` 对象并使用它来处理数据字典。
-
-```python
-import numpy as np
-
-transform = MyFlip(direction='horizontal')
-data_dict = {'img': np.random.rand(224, 224, 3)}
-data_dict = transform(data_dict)
-processed_img = data_dict['img']
-```
-
-或者，我们可以在配置文件中的数据流程中使用 `MyFlip` 变换。
-
-```python
-pipeline = [
-    ...
-    dict(type='MyFlip', direction='horizontal'),
-    ...
-]
-```
-
-需要注意，如果要在配置文件中使用 `MyFlip`，必须确保在运行时导入了包含 `MyFlip` 的文件。
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/contribute_dataset.md b/mmsegmentation/docs/zh_cn/advanced_guides/contribute_dataset.md
deleted file mode 100644
index 4222de3..0000000
--- a/mmsegmentation/docs/zh_cn/advanced_guides/contribute_dataset.md
+++ /dev/null
@@ -1,461 +0,0 @@
-# 在 mmsegmentation projects 中贡献一个标准格式的数据集
-
-- 在开始您的贡献流程前，请先阅读[《OpenMMLab 贡献代码指南》](https://mmcv.readthedocs.io/zh_CN/latest/community/contributing.html)，以详细的了解 OpenMMLab 代码库的代码贡献流程。
-- 该教程以 [Gaofen Image Dataset (GID)](https://www.sciencedirect.com/science/article/pii/S0034425719303414) 高分 2 号卫星所拍摄的遥感图像语义分割数据集作为样例，来演示在 mmsegmentation 中的数据集贡献流程。
-
-## 步骤 1： 配置 mmsegmentation 开发所需必要环境
-
-- 开发所必需的环境安装请参考[中文快速入门指南](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/get_started.md)或[英文 get_started](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/get_started.md)。
-
-- 如果您已安装了最新版的 pytorch、mmcv、mmengine，那么您可以跳过步骤 1 至[步骤 2](<#[步骤-2](#%E6%AD%A5%E9%AA%A4-2%E4%BB%A3%E7%A0%81%E8%B4%A1%E7%8C%AE%E5%89%8D%E7%9A%84%E5%87%86%E5%A4%87%E5%B7%A5%E4%BD%9C)>)。
-
-- **注：** 在此处无需安装 mmsegmentation，只需安装开发 mmsegmentation 所必需的 pytorch、mmcv、mmengine 等即可。
-
-**新建虚拟环境（如已有合适的开发环境，可跳过）**
-
-- 从[官方网站](https://docs.conda.io/en/latest/miniconda.html)下载并安装 Miniconda
-- 创建一个 conda 环境，并激活
-
-```shell
-conda create --name openmmlab python=3.8 -y
-conda activate openmmlab
-```
-
-**安装 pytorch （如环境下已安装 pytorch，可跳过）**
-
-- 参考 [official instructions](https://pytorch.org/get-started/locally/) 安装 **PyTorch**
-
-**使用 mim 安装 mmcv、mmengine**
-
-- 使用 [MIM](https://github.com/open-mmlab/mim) 安装 [MMCV](https://github.com/open-mmlab/mmcv)
-
-```shell
-pip install -U openmim
-mim install mmengine
-mim install "mmcv>=2.0.0"
-```
-
-## 步骤 2：代码贡献前的准备工作
-
-### 2.1 Fork mmsegmentation 仓库
-
-- 通过浏览器打开[mmsegmentation 官方仓库](https://github.com/open-mmlab/mmsegmentation/tree/main)。
-- 登录您的 GitHub 账户，以下步骤均需在 GitHub 登录的情况下进行。
-- Fork mmsegmentation 仓库
-  ![image](https://user-images.githubusercontent.com/50650583/233825567-b8bf273c-38f5-4487-b4c6-75ede1e283ee.png)
-- Fork 之后，mmsegmentation 仓库将会出现在您的个人仓库中。
-
-### 2.2 在您的代码编写软件中 git clone mmsegmentation
-
-这里以 VSCODE 为例
-
-- 打开 VSCODE，新建终端窗口并激活您在[步骤 1 ](#%E6%AD%A5%E9%AA%A4-1-%E9%85%8D%E7%BD%AE-mmsegmentation-%E5%BC%80%E5%8F%91%E6%89%80%E9%9C%80%E5%BF%85%E8%A6%81%E7%8E%AF%E5%A2%83)中所安装的虚拟环境。
-- 在您 GitHub 的个人仓库中找到您 Fork 的 mmsegmentation 仓库，复制其链接。
-  ![image](https://github.com/AI-Tianlong/OpenMMLabCamp/assets/50650583/92ad555b-c5b2-4a7f-a800-ebee1e405ab6)
-- 在终端中执行命令
-  ```bash
-  git clone {您所复制的个人仓库的链接}
-  ```
-  ![image](https://github.com/AI-Tianlong/OpenMMLabCamp/assets/50650583/23ba2636-e66f-4ea5-9077-9dd6b69deb1d)
-  **注：** 如提示以下信息，请在 GitHub 中添加 [SSH 秘钥](https://docs.github.com/en/authentication/connecting-to-github-with-ssh/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent)
-  ![image](https://github.com/AI-Tianlong/OpenMMLabCamp/assets/50650583/6fcab213-0739-483c-b345-c59656027377)
-- 进入 mmsegmentation 目录（之后的操作均在 mmsegmentation 目录下）。
-  ```bash
-  cd mmsegmentation
-  ```
-- 在终端中执行以下命令，添加官方仓库为上游仓库。
-  ```bash
-  git remote add upstream git@github.com:open-mmlab/mmsegmentation.git
-  ```
-- 使用以下命令检查 remote 是否添加成功。
-  ```bash
-  git remote -v
-  ```
-  ![image](https://github.com/AI-Tianlong/OpenMMLabCamp/assets/50650583/beec7e5e-2b00-4e49-ab38-f0c79e346594)
-
-### 2.3 切换目录至 mmsegmentation 并从源码安装mmsegmentation
-
-在`mmsegmentation`目录下执行`pip install -v -e .`，通过源码构建方式安装 mmsegmentaion 库。
-安装完成后，您将能看到如下图所示的文件树。
-<img src="https://user-images.githubusercontent.com/50650583/233826064-4b111358-8f97-44dd-955c-df3204410b8b.png" alt="image" style="zoom:67%;" />
-
-### 2.4 切换分支为 dev-1.x
-
-正如您在[ mmsegmentation 官网](https://github.com/open-mmlab/mmsegmentation/tree/main)所见，该仓库有许多分支，默认分支`main`为稳定的发行版本，以及用于贡献者进行开发的`dev-1.x`分支。`dev-1.x`分支是贡献者们用来提交创意和 PR 的分支，`dev-1.x`分支的内容会被周期性的合入到`main`分支。
-![image](https://user-images.githubusercontent.com/50650583/233826225-f4b7299d-de23-47db-900d-dfb01ba0efc3.png)
-
-回到 VSCODE 中，在终端执行命令
-
-```bash
-git checkout dev-1.x
-```
-
-### 2.5 创新属于自己的新分支
-
-在基于`dev-1.x`分支下，使用如下命令，创建属于您自己的分支。
-
-```bash
-# git checkout -b 您的GitHubID/您的分支想要实现的功能的名字
-# git checkout -b AI-Tianlong/support_GID_dataset
-git checkout -b {您的GitHubID/您的分支想要实现的功能的名字}
-```
-
-### 2.6 配置 pre-commit
-
-OpenMMLab 仓库对代码质量有着较高的要求，所有提交的 PR 必须要通过代码格式检查。pre-commit 详细配置参阅[配置 pre-commit](https://mmcv.readthedocs.io/zh_CN/latest/community/contributing.html#pre-commit)。
-
-## 步骤 3：在`mmsegmentation/projects`下贡献您的代码
-
-**先对 GID 数据集进行分析**
-
-这里以贡献高分 2 号遥感图像语义分割数据集 GID 为例，GID 数据集是由我国自主研发的高分 2 号卫星所拍摄的光学遥感图像所创建，经图像预处理后共提供了 150 张 6800x7200 像素的 RGB 三通道遥感图像。并提供了两种不同类别数的数据标注，一种是包含 5 类有效物体的 RGB 标签，另一种是包含 15 类有效物体的 RGB 标签。本教程将针对 5 类标签进行数据集贡献流程讲解。
-
-GID 的 5 类有效标签分别为：0-背景-\[0,0,0\](mask 标签值-标签名称-RGB 标签值)、1-建筑-\[255,0,0\]、2-农田-\[0,255,0\]、3-森林-\[0,0,255\]、4-草地-\[255,255,0\]、5-水-\[0,0,255\]。在语义分割任务中，标签是与原图尺寸一致的单通道图像，标签图像中的像素值为真实样本图像中对应像素所包含的物体的类别。GID 数据集提供的是具有 RGB 三通道的彩色标签，为了模型的训练需要将 RGB 标签转换为 mask 标签。并且由于图像尺寸为 6800x7200 像素，对于神经网络的训练来有些过大，所以将每张图像裁切成了没有重叠的 512x512 的图像以便进行训练。
-<img align='center' src="https://user-images.githubusercontent.com/50650583/234192183-83ee4209-e181-4a18-90ca-4d71757cd2c7.png" alt="image" style="zoom:67%;" />
-
-### 3.1 在`mmsegmentation/projects`下创建新的项目文件夹
-
-在`mmsegmentation/projects`下创建文件夹`gid_dataset`
-![image](https://user-images.githubusercontent.com/50650583/233829687-8f2b6600-bc9d-48ff-a865-d462af54d55a.png)
-
-### 3.2 贡献您的数据集代码
-
-为了最终能将您在 projects 中贡献的代码更加顺畅的移入核心库中（对代码要求质量更高），非常建议按照核心库的目录来编辑您的数据集文件。
-关于数据集有 4 个必要的文件：
-
-- **1**  `mmseg/datasets/gid.py` 定义了数据集的尾缀、CLASSES、PALETTE、reduce_zero_label等
-- **2** `configs/_base_/gid.py` GID 数据集的配置文件，定义了数据集的`dataset_type`（数据集类型，`mmseg/datasets/gid.py`中注册的数据集的类名）、`data_root`(数据集所在的根目录，建议将数据集通过软连接的方式将数据集放至`mmsegmentation/data`)、`train_pipline`(训练的数据流)、`test_pipline`(测试和验证时的数据流)、`img_rations`(多尺度预测时的多尺度配置)、`tta_pipeline`（多尺度预测）、`train_dataloader`(训练集的数据加载器)、`val_dataloader`(验证集的数据加载器)、`test_dataloader`(测试集的数据加载器)、`val_evaluator`(验证集的评估器)、`test_evaluator`(测试集的评估器)。
-- **3** 使用了 GID 数据集的模型训练配置文件
-  这个是可选的，但是强烈建议您添加。在核心库中，所贡献的数据集需要和参考文献中所提出的结果精度对齐，为了后期将您贡献的代码合并入核心库。如您的算力充足，最好能提供对应的模型配置文件在您贡献的数据集上所验证的结果以及相应的权重文件，并撰写较为详细的README.md文档。[示例参考结果](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/deeplabv3plus#mapillary-vistas-v12)
-  ![image](https://user-images.githubusercontent.com/50650583/233877682-eabe8723-bce9-40e4-a303-08c8385cb6b5.png)
-- **4** 使用如下命令格式： 撰写`docs/zh_cn/user_guides/2_dataset_prepare.md`来添加您的数据集介绍，包括但不限于数据集的下载方式，数据集目录结构、数据集生成等一些必要性的文字性描述和运行命令。以更好地帮助用户能更快的实现数据集的准备工作。
-
-### 3.3 贡献`tools/dataset_converters/gid.py`
-
-由于 GID 数据集是由未经过切分的 6800x7200 图像所构成的数据集，并且没有划分训练集、验证集与测试集。以及其标签为 RGB 彩色标签，需要将标签转换为单通道的 mask label。为了方便训练，首先将 GID 数据集进行裁切和标签转换，并进行数据集划分，构建为 mmsegmentation 所支持的格式。
-
-```python
-# tools/dataset_converters/gid.py
-import argparse
-import glob
-import math
-import os
-import os.path as osp
-from PIL import Image
-
-import mmcv
-import numpy as np
-from mmengine.utils import ProgressBar, mkdir_or_exist
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Convert GID dataset to mmsegmentation format')
-    parser.add_argument('dataset_img_path', help='GID images folder path')
-    parser.add_argument('dataset_label_path', help='GID labels folder path')
-    parser.add_argument('--tmp_dir', help='path of the temporary directory')
-    parser.add_argument('-o', '--out_dir', help='output path', default='data/gid')
-    parser.add_argument(
-        '--clip_size',
-        type=int,
-        help='clipped size of image after preparation',
-        default=256)
-    parser.add_argument(
-        '--stride_size',
-        type=int,
-        help='stride of clipping original images',
-        default=256)
-    args = parser.parse_args()
-    return args
-
-GID_COLORMAP = dict(
-    Background=(0, 0, 0), #0-背景-黑色
-    Building=(255, 0, 0), #1-建筑-红色
-    Farmland=(0, 255, 0), #2-农田-绿色
-    Forest=(0, 0, 255), #3-森林-蓝色
-    Meadow=(255, 255, 0),#4-草地-黄色
-    Water=(0, 0, 255)#5-水-蓝色
-)
-palette = list(GID_COLORMAP.values())
-classes = list(GID_COLORMAP.keys())
-
-#############用列表来存一个 RGB 和一个类别的对应################
-def colormap2label(palette):
-    colormap2label_list = np.zeros(256**3, dtype = np.longlong)
-    for i, colormap in enumerate(palette):
-        colormap2label_list[(colormap[0] * 256 + colormap[1])*256+colormap[2]] = i
-    return colormap2label_list
-
-#############给定那个列表，和vis_png然后生成masks_png################
-def label_indices(RGB_label, colormap2label_list):
-    RGB_label = RGB_label.astype('int32')
-    idx = (RGB_label[:, :, 0] * 256 + RGB_label[:, :, 1]) * 256 + RGB_label[:, :, 2]
-    # print(idx.shape)
-    return colormap2label_list[idx]
-
-def RGB2mask(RGB_label, colormap2label_list):
-    # RGB_label = np.array(Image.open(RGB_label).convert('RGB')) #打开RGB_png
-    mask_label = label_indices(RGB_label, colormap2label_list) # .numpy()
-    return mask_label
-
-colormap2label_list = colormap2label(palette)
-
-def clip_big_image(image_path, clip_save_dir, args, to_label=False):
-    """
-    Original image of GID dataset is very large, thus pre-processing
-    of them is adopted. Given fixed clip size and stride size to generate
-    clipped image, the intersection　of width and height is determined.
-    For example, given one 6800 x 7200 original image, the clip size is
-    256 and stride size is 256, thus it would generate 29 x 27 = 783 images
-    whose size are all 256 x 256.
-
-    """
-
-    image = mmcv.imread(image_path, channel_order='rgb')
-    # image = mmcv.bgr2gray(image)
-
-    h, w, c = image.shape
-    clip_size = args.clip_size
-    stride_size = args.stride_size
-
-    num_rows = math.ceil((h - clip_size) / stride_size) if math.ceil(
-        (h - clip_size) /
-        stride_size) * stride_size + clip_size >= h else math.ceil(
-            (h - clip_size) / stride_size) + 1
-    num_cols = math.ceil((w - clip_size) / stride_size) if math.ceil(
-        (w - clip_size) /
-        stride_size) * stride_size + clip_size >= w else math.ceil(
-            (w - clip_size) / stride_size) + 1
-
-    x, y = np.meshgrid(np.arange(num_cols + 1), np.arange(num_rows + 1))
-    xmin = x * clip_size
-    ymin = y * clip_size
-
-    xmin = xmin.ravel()
-    ymin = ymin.ravel()
-    xmin_offset = np.where(xmin + clip_size > w, w - xmin - clip_size,
-                           np.zeros_like(xmin))
-    ymin_offset = np.where(ymin + clip_size > h, h - ymin - clip_size,
-                           np.zeros_like(ymin))
-    boxes = np.stack([
-        xmin + xmin_offset, ymin + ymin_offset,
-        np.minimum(xmin + clip_size, w),
-        np.minimum(ymin + clip_size, h)
-    ], axis=1)
-
-    if to_label:
-        image = RGB2mask(image, colormap2label_list) #这里得改一下
-
-    for count, box in enumerate(boxes):
-        start_x, start_y, end_x, end_y = box
-        clipped_image = image[start_y:end_y,
-                              start_x:end_x] if to_label else image[
-                                  start_y:end_y, start_x:end_x, :]
-        img_name = osp.basename(image_path).replace('.tif', '')
-        img_name = img_name.replace('_label', '')
-        if count % 3 == 0:
-            mmcv.imwrite(
-                clipped_image.astype(np.uint8),
-                osp.join(
-                    clip_save_dir.replace('train', 'val'),
-                    f'{img_name}_{start_x}_{start_y}_{end_x}_{end_y}.png'))
-        else:
-            mmcv.imwrite(
-                clipped_image.astype(np.uint8),
-                osp.join(
-                    clip_save_dir,
-                    f'{img_name}_{start_x}_{start_y}_{end_x}_{end_y}.png'))
-        count += 1
-
-def main():
-    args = parse_args()
-
-    """
-    According to this paper: https://ieeexplore.ieee.org/document/9343296/
-    select 15 images contained in GID, , which cover the whole six
-    categories, to generate train set and validation set.
-
-    According to Paper: https://ieeexplore.ieee.org/document/9343296/
-
-    """
-
-    if args.out_dir is None:
-        out_dir = osp.join('data', 'gid')
-    else:
-        out_dir = args.out_dir
-
-    print('Making directories...')
-    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'train'))
-    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'val'))
-    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'train'))
-    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'val'))
-
-    src_path_list = glob.glob(os.path.join(args.dataset_img_path, '*.tif'))
-    print(f'Find {len(src_path_list)} pictures')
-
-    prog_bar = ProgressBar(len(src_path_list))
-
-    dst_img_dir = osp.join(out_dir, 'img_dir', 'train')
-    dst_label_dir = osp.join(out_dir, 'ann_dir', 'train')
-
-    for i, img_path in enumerate(src_path_list):
-        label_path = osp.join(args.dataset_label_path, osp.basename(img_path.replace('.tif', '_label.tif')))
-
-        clip_big_image(img_path, dst_img_dir, args, to_label=False)
-        clip_big_image(label_path, dst_label_dir, args, to_label=True)
-        prog_bar.update()
-
-    print('Done!')
-
-if __name__ == '__main__':
-    main()
-```
-
-### 3.4 贡献`mmseg/datasets/gid.py`
-
-可参考[`projects/mapillary_dataset/mmseg/datasets/mapillary.py`](https://github.com/open-mmlab/mmsegmentation/blob/main/projects/mapillary_dataset/mmseg/datasets/mapillary.py)并在此基础上修改相应变量以适配您的数据集。
-
-```python
-# mmseg/datasets/gid.py
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmseg.datasets.basesegdataset import BaseSegDataset
-from mmseg.registry import DATASETS
-
-# 注册数据集类
-@DATASETS.register_module()
-class GID_Dataset(BaseSegDataset):
-    """Gaofen Image Dataset (GID)
-
-    Dataset paper link:
-    https://www.sciencedirect.com/science/article/pii/S0034425719303414
-    https://x-ytong.github.io/project/GID.html
-
-    GID  6 classes: background(others), built-up, farmland, forest, meadow, water
-
-    In This example, select 10 images from GID dataset as training set,
-    and select 5 images as validation set.
-    The selected images are listed as follows:
-
-    GF2_PMS1__L1A0000647767-MSS1
-    GF2_PMS1__L1A0001064454-MSS1
-    GF2_PMS1__L1A0001348919-MSS1
-    GF2_PMS1__L1A0001680851-MSS1
-    GF2_PMS1__L1A0001680853-MSS1
-    GF2_PMS1__L1A0001680857-MSS1
-    GF2_PMS1__L1A0001757429-MSS1
-    GF2_PMS2__L1A0000607681-MSS2
-    GF2_PMS2__L1A0000635115-MSS2
-    GF2_PMS2__L1A0000658637-MSS2
-    GF2_PMS2__L1A0001206072-MSS2
-    GF2_PMS2__L1A0001471436-MSS2
-    GF2_PMS2__L1A0001642620-MSS2
-    GF2_PMS2__L1A0001787089-MSS2
-    GF2_PMS2__L1A0001838560-MSS2
-
-    The ``img_suffix`` is fixed to '.tif' and ``seg_map_suffix`` is
-    fixed to '.tif' for GID.
-    """
-    METAINFO = dict(
-        classes=('Others', 'Built-up', 'Farmland', 'Forest',
-                 'Meadow', 'Water'),
-
-        palette=[[0, 0, 0], [255, 0, 0], [0, 255, 0], [0, 255, 255],
-                 [255, 255, 0], [0, 0, 255]])
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=None,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
-```
-
-### 3.5 贡献使用 GID 的训练 config file
-
-```python
-_base_ = [
-    '../../../configs/_base_/models/deeplabv3plus_r50-d8.py',
-    './_base_/datasets/gid.py',
-    '../../../configs/_base_/default_runtime.py',
-    '../../../configs/_base_/schedules/schedule_240k.py'
-]
-custom_imports = dict(
-    imports=['projects.gid_dataset.mmseg.datasets.gid'])
-
-crop_size = (256, 256)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained='open-mmlab://resnet101_v1c',
-    backbone=dict(depth=101),
-    decode_head=dict(num_classes=6),
-    auxiliary_head=dict(num_classes=6))
-
-```
-
-### 3.6 撰写`docs/zh_cn/user_guides/2_dataset_prepare.md`
-
-**Gaofen Image Dataset (GID)**
-
-- GID 数据集可在[此处](https://x-ytong.github.io/project/Five-Billion-Pixels.html)进行下载。
-- GID 数据集包含 150 张 6800x7200 的大尺寸图像，标签为 RGB 标签。
-- 此处选择 15 张图像生成训练集和验证集，该 15 张图像包含了所有六类信息。所选的图像名称如下：
-
-```None
-  GF2_PMS1__L1A0000647767-MSS1
-  GF2_PMS1__L1A0001064454-MSS1
-  GF2_PMS1__L1A0001348919-MSS1
-  GF2_PMS1__L1A0001680851-MSS1
-  GF2_PMS1__L1A0001680853-MSS1
-  GF2_PMS1__L1A0001680857-MSS1
-  GF2_PMS1__L1A0001757429-MSS1
-  GF2_PMS2__L1A0000607681-MSS2
-  GF2_PMS2__L1A0000635115-MSS2
-  GF2_PMS2__L1A0000658637-MSS2
-  GF2_PMS2__L1A0001206072-MSS2
-  GF2_PMS2__L1A0001471436-MSS2
-  GF2_PMS2__L1A0001642620-MSS2
-  GF2_PMS2__L1A0001787089-MSS2
-  GF2_PMS2__L1A0001838560-MSS2
-```
-
-执行以下命令进行裁切及标签的转换，需要修改为您所存储 15 张图像及标签的路径。
-
-```
-python projects/gid_dataset/tools/dataset_converters/gid.py [15 张图像的路径] [15 张标签的路径]
-```
-
-完成裁切后的 GID 数据结构如下：
-
-```none
-mmsegmentation
-├── mmseg
-├── tools
-├── configs
-├── data
-│   ├── gid
-│   │   ├── ann_dir
-|   │   │   │   ├── train
-|   │   │   │   ├── val
-│   │   ├── img_dir
-|   │   │   │   ├── train
-|   │   │   │   ├── val
-
-```
-
-### 3.7 贡献的代码及文档通过`pre-commit`检查
-
-使用命令
-
-```bash
-git add .
-git commit -m "添加描述"
-git push
-```
-
-### 3.8 在 GitHub 中向 mmsegmentation 提交 PR
-
-具体步骤可见[《OpenMMLab 贡献代码指南》](https://mmcv.readthedocs.io/zh_CN/latest/community/contributing.html)
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/customize_runtime.md b/mmsegmentation/docs/zh_cn/advanced_guides/customize_runtime.md
deleted file mode 100644
index a80aca6..0000000
--- a/mmsegmentation/docs/zh_cn/advanced_guides/customize_runtime.md
+++ /dev/null
@@ -1,162 +0,0 @@
-# 自定义运行设定
-
-## 实现自定义钩子
-
-### Step 1: 创建一个新的钩子
-
-MMEngine 已实现了训练和测试常用的[钩子](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/hook.md),
-当有定制化需求时, 可以按照如下示例实现适用于自身训练需求的钩子, 例如想修改一个超参数 `model.hyper_paramete` 的值, 让它随着训练迭代次数而变化:
-
-```python
-# Copyright (c) OpenMMLab. All rights reserved.
-from typing import Optional, Sequence
-
-from mmengine.hooks import Hook
-from mmengine.model import is_model_wrapper
-
-from mmseg.registry import HOOKS
-
-
-@HOOKS.register_module()
-class NewHook(Hook):
-    """Docstring for NewHook.
-    """
-
-    def __init__(self, a: int, b: int) -> None:
-        self.a = a
-        self.b = b
-
-    def before_train_iter(self,
-                          runner,
-                          batch_idx: int,
-                          data_batch: Optional[Sequence[dict]] = None) -> None:
-        cur_iter = runner.iter
-        # 当模型被包在 wrapper 里时获取这个模型
-        if is_model_wrapper(runner.model):
-          model = runner.model.module
-        model.hyper_parameter = self.a * cur_iter + self.b
-```
-
-### Step 2: 导入一个新的钩子
-
-为了让上面定义的模块可以被执行的程序发现, 这个模块需要先被导入主命名空间 (main namespace) 里面,
-假设 NewHook 在 `mmseg/engine/hooks/new_hook.py` 里面, 有两种方式去实现它:
-
-- 修改 `mmseg/engine/hooks/__init__.py` 来导入它.
-  新定义的模块应该在 `mmseg/engine/hooks/__init__.py` 里面导入, 这样注册器可以发现并添加这个新的模块:
-
-```python
-from .new_hook import NewHook
-
-__all__ = [..., NewHook]
-```
-
-- 在配置文件里使用 custom_imports 来手动导入它.
-
-```python
-custom_imports = dict(imports=['mmseg.engine.hooks.new_hook'], allow_failed_imports=False)
-```
-
-### Step 3: 修改配置文件
-
-可以按照如下方式, 在训练或测试中配置并使用自定义的钩子. 不同钩子在同一位点的优先级可以参考[这里](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/hook.md#%E5%86%85%E7%BD%AE%E9%92%A9%E5%AD%90), 自定义钩子如果没有指定优先, 默认是 `NORMAL`.
-
-```python
-custom_hooks = [
-    dict(type='NewHook', a=a_value, b=b_value, priority='ABOVE_NORMAL')
-]
-```
-
-## 实现自定义优化器
-
-### Step 1: 创建一个新的优化器
-
-如果增加一个叫作 `MyOptimizer` 的优化器, 它有参数 `a`, `b` 和 `c`. 推荐在 `mmseg/engine/optimizers/my_optimizer.py` 文件中实现
-
-```python
-from mmseg.registry import OPTIMIZERS
-from torch.optim import Optimizer
-
-
-@OPTIMIZERS.register_module()
-class MyOptimizer(Optimizer):
-
-    def __init__(self, a, b, c)
-```
-
-### Step 2: 导入一个新的优化器
-
-为了让上面定义的模块可以被执行的程序发现, 这个模块需要先被导入主命名空间 (main namespace) 里面,
-假设 `MyOptimizer` 在 `mmseg/engine/optimizers/my_optimizer.py` 里面, 有两种方式去实现它:
-
-- 修改 `mmseg/engine/optimizers/__init__.py` 来导入它.
-  新定义的模块应该在 `mmseg/engine/optimizers/__init__.py` 里面导入, 这样注册器可以发现并添加这个新的模块:
-
-```python
-from .my_optimizer import MyOptimizer
-```
-
-- 在配置文件里使用 `custom_imports` 来手动导入它.
-
-```python
-custom_imports = dict(imports=['mmseg.engine.optimizers.my_optimizer'], allow_failed_imports=False)
-```
-
-### Step 3: 修改配置文件
-
-随后需要修改配置文件 `optim_wrapper` 里的 `optimizer` 参数, 如果要使用你自己的优化器 `MyOptimizer`, 字段可以被修改成:
-
-```python
-optim_wrapper = dict(type='OptimWrapper',
-                     optimizer=dict(type='MyOptimizer',
-                                    a=a_value, b=b_value, c=c_value),
-                     clip_grad=None)
-```
-
-## 实现自定义优化器封装构造器
-
-### Step 1: 创建一个新的优化器封装构造器
-
-构造器可以用来创建优化器, 优化器包, 以及自定义模型网络不同层的超参数. 一些模型的优化器可能会根据特定的参数而调整, 例如 BatchNorm 层的 weight decay. 使用者可以通过自定义优化器构造器来精细化设定不同参数的优化策略.
-
-```python
-from mmengine.optim import DefaultOptimWrapperConstructor
-from mmseg.registry import OPTIM_WRAPPER_CONSTRUCTORS
-
-@OPTIM_WRAPPER_CONSTRUCTORS.register_module()
-class LearningRateDecayOptimizerConstructor(DefaultOptimWrapperConstructor):
-    def __init__(self, optim_wrapper_cfg, paramwise_cfg=None):
-
-    def __call__(self, model):
-
-        return my_optimizer
-```
-
-默认的优化器构造器在[这里](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py#L19) 被实现, 它也可以用来作为新的优化器构造器的模板.
-
-### Step 2: 导入一个新的优化器封装构造器
-
-为了让上面定义的模块可以被执行的程序发现, 这个模块需要先被导入主命名空间 (main namespace) 里面, 假设 `MyOptimizerConstructor` 在 `mmseg/engine/optimizers/my_optimizer_constructor.py` 里面, 有两种方式去实现它:
-
-- 修改 `mmseg/engine/optimizers/__init__.py` 来导入它.
-  新定义的模块应该在 `mmseg/engine/optimizers/__init__.py` 里面导入, 这样注册器可以发现并添加这个新的模块:
-
-```python
-from .my_optimizer_constructor import MyOptimizerConstructor
-```
-
-- 在配置文件里使用 `custom_imports` 来手动导入它.
-
-```python
-custom_imports = dict(imports=['mmseg.engine.optimizers.my_optimizer_constructor'], allow_failed_imports=False)
-```
-
-### Step 3: 修改配置文件
-
-随后需要修改配置文件 `optim_wrapper`  里的 `constructor` 参数, 如果要使用你自己的优化器封装构造器 `MyOptimizerConstructor`, 字段可以被修改成:
-
-```python
-optim_wrapper = dict(type='OptimWrapper',
-                     constructor='MyOptimizerConstructor',
-                     clip_grad=None)
-```
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/data_flow.md b/mmsegmentation/docs/zh_cn/advanced_guides/data_flow.md
deleted file mode 100644
index 20dbe07..0000000
--- a/mmsegmentation/docs/zh_cn/advanced_guides/data_flow.md
+++ /dev/null
@@ -1,90 +0,0 @@
-# 数据流
-
-在本章节中，我们将介绍 [Runner](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/runner.html) 管理的内部模块之间的数据流和数据格式约定。
-
-## 数据流概述
-
-[Runner](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/design/runner.md) 相当于 MMEngine 中的“集成器”。它覆盖了框架的所有方面，并肩负着组织和调度几乎所有模块的责任，这意味着各模块之间的数据流也由 `Runner` 控制。 如 [MMEngine 中的 Runner 文档](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/runner.html)所示，下图展示了基本的数据流。
-
-![Basic dataflow](https://user-images.githubusercontent.com/112053249/199228350-5f80699e-7fd2-4b4c-ac32-0b16b1922c2e.png)
-
-虚线边框、灰色填充形状代表不同的数据格式，而实心框表示模块/方法。由于 MMEngine 极大的灵活性和可扩展性，一些重要的基类可以被继承，并且它们的方法可以被覆写。 上图所示数据流仅适用于当用户没有自定义 `Runner` 中的 `TrainLoop`、`ValLoop` 和 `TestLoop`，并且没有在其自定义模型中覆写 `train_step`、`val_step` 和 `test_step` 方法时。MMSegmentation 中 loop 的默认设置如下：使用`IterBasedTrainLoop` 训练模型，共计 20000 次迭代，并且在每 2000 次迭代后进行一次验证。
-
-```python
-train_cfg = dict(type='IterBasedTrainLoop', max_iters=20000, val_interval=2000)
-val_cfg = dict(type='ValLoop')
-test_cfg = dict(type='TestLoop')
-```
-
-在上图中，红色线表示 [train_step](./models.md#train_step)，在每次训练迭代中，数据加载器（dataloader）从存储中加载图像并传输到数据预处理器（data preprocessor），数据预处理器会将图像放到特定的设备上，并将数据堆叠到批处理中，之后模型接受批处理数据作为输入，最后将模型的输出发送给优化器（optimizer）。蓝色线表示 [val_step](./models.md#val_step) 和 [test_step](./models.md#test_step)。这两个过程的数据流除了模型输出与 `train_step` 不同外，其余均和 `train_step` 类似。由于在评估时模型参数会被冻结，因此模型的输出将被传递给 [Evaluator](./evaluation.md#ioumetric)。
-来计算指标。
-
-## MMSegmentation 中的数据流约定
-
-在上面的图中，我们可以看到基本的数据流。在本节中，我们将分别介绍数据流中涉及的数据的格式约定。
-
-### 数据加载器到数据预处理器
-
-数据加载器（DataLoader）是 MMEngine 的训练和测试流程中的一个重要组件。
-从概念上讲，它源于 [PyTorch](https://pytorch.org/) 并保持一致。DataLoader 从文件系统加载数据，原始数据通过数据准备流程后被发送给数据预处理器。
-
-MMSegmentation 在 [PackSegInputs](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/transforms/formatting.py#L12) 中定义了默认数据格式， 它是 `train_pipeline` 和 `test_pipeline` 的最后一个组件。有关数据转换 `pipeline` 的更多信息，请参阅[数据转换文档](./transforms.md)。
-
-在没有任何修改的情况下，PackSegInputs 的返回值通常是一个包含 `inputs` 和 `data_samples` 的 `dict`。以下伪代码展示了 mmseg 中数据加载器输出的数据类型，它是从数据集中获取的一批数据样本，数据加载器将它们打包成一个字典列表。`inputs` 是输入进模型的张量列表，`data_samples` 包含了输入图像的 meta information 和相应的 ground truth。
-
-```python
-dict(
-    inputs=List[torch.Tensor],
-    data_samples=List[SegDataSample]
-)
-```
-
-**注意：** [SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py) 是 MMSegmentation 的数据结构接口，用于连接不同组件。`SegDataSample` 实现了抽象数据元素 `mmengine.structures.BaseDataElement`，更多信息请在  [MMEngine](https://github.com/open-mmlab/mmengine) 中参阅 [SegDataSample 文档](./structures.md)和[数据元素文档](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/data_element.html)。
-
-### 数据预处理器到模型
-
-虽然在[上面的图](##数据流概述)中分开绘制了数据预处理器和模型，但数据预处理器是模型的一部分，因此可以在[模型教程](./models.md)中找到数据预处理器章节。
-
-数据预处理器的返回值是一个包含 `inputs` 和 `data_samples` 的字典，其中 `inputs` 是批处理图像的 4D 张量，`data_samples` 中添加了一些用于数据预处理的额外元信息。当传递给网络时，字典将被解包为两个值。 以下伪代码展示了数据预处理器的返回值和模型的输入值。
-
-```python
-dict(
-    inputs=torch.Tensor,
-    data_samples=List[SegDataSample]
-)
-```
-
-```python
-class Network(BaseSegmentor):
-
-    def forward(self, inputs: torch.Tensor, data_samples: List[SegDataSample], mode: str):
-        pass
-```
-
-**注意：** 模型的前向传播有 3 种模式，由输入参数 mode 控制，更多信息请参阅[模型教程](./models.md)。
-
-### 模型输出
-
-如[模型教程](./models.md#forward) ***（[中文链接待更新](./models.md#forward)）*** 所提到的 3 种前向传播具有 3 种输出。
-`train_step` 和 `test_step`（或 `val_step`）分别对应于 `'loss'` 和 `'predict'`。
-
-在 `test_step` 或 `val_step` 中，推理结果会被传递给 `Evaluator` 。您可以参阅[评估文档](./evaluation.md)来获取更多关于 `Evaluator` 的信息。
-
-在推理后，MMSegmentation 中的 [BaseSegmentor](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/segmentors/base.py#L15) 会对推理结果进行简单的后处理以打包推理结果。神经网络生成的分割 logits，经过 `argmax` 操作后的分割 mask 和 ground truth（如果存在）将被打包到类似 `SegDataSample` 的实例。 [postprocess_result](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/segmentors/base.py#L132) 的返回值是一个 **`SegDataSample`的`List`**。下图显示了这些 `SegDataSample` 实例的关键属性。
-
-![SegDataSample](https://user-images.githubusercontent.com/15952744/209912225-ab46a8d9-904a-43cb-8bf1-8bec4938ed29.png)
-
-与数据预处理器一致，损失函数也是模型的一部分，它是[解码头](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/decode_heads/decode_head.py#L142)的属性之一。
-
-在 MMSegmentation 中，`decode_head` 的 [loss_by_feat](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/decode_heads/decode_head.py#L291) 方法是用于计算损失的统一接口。
-
-参数：
-
-- seg_logits (Tensor)：解码头前向函数的输出
-- batch_data_samples (List\[SegDataSample\])：分割数据样本，通常包括如 `metainfo` 和  `gt_sem_seg` 等信息
-
-返回值：
-
-- dict\[str, Tensor\]：一个损失组件的字典
-
-**注意：**  `train_step` 将损失传递进 OptimWrapper 以更新模型中的权重，更多信息请参阅 [train_step](./models.md#train_step)。
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/datasets.md b/mmsegmentation/docs/zh_cn/advanced_guides/datasets.md
deleted file mode 100644
index b45f2d2..0000000
--- a/mmsegmentation/docs/zh_cn/advanced_guides/datasets.md
+++ /dev/null
@@ -1,363 +0,0 @@
-# 数据集
-
-在 MMSegmentation 算法库中, 所有 Dataset 类的功能有两个: 加载[预处理](../user_guides/2_dataset_prepare.md) 之后的数据集的信息, 和将数据送入[数据集变换流水线](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/basesegdataset.py#L141) 中, 进行[数据变换操作](./transforms.md). 加载的数据集信息包括两类: 元信息 (meta information), 数据集本身的信息, 例如数据集总共的类别, 和它们对应调色盘信息: 数据信息 (data information) 是指每组数据中图片和对应标签的路径. 下文中介绍了 MMSegmentation 1.x 中数据集的常用接口, 和 mmseg 数据集基类中数据信息加载与修改数据集类别的逻辑, 以及数据集与数据变换流水线 (pipeline) 的关系.
-
-## 常用接口
-
-以 Cityscapes 为例, 介绍数据集常用接口. 如需运行以下示例, 请在当前工作目录下的 `data` 目录下载并[预处理](../user_guides/2_dataset_prepare.md#cityscapes) Cityscapes 数据集.
-
-实例化 Cityscapes 训练数据集:
-
-```python
-from mmengine.registry import init_default_scope
-from mmseg.datasets import CityscapesDataset
-
-init_default_scope('mmseg')
-
-data_root = 'data/cityscapes/'
-data_prefix=dict(img_path='leftImg8bit/train', seg_map_path='gtFine/train')
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='RandomCrop', crop_size=(512, 1024), cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PackSegInputs')
-]
-
-dataset = CityscapesDataset(data_root=data_root, data_prefix=data_prefix, test_mode=False, pipeline=train_pipeline)
-```
-
-查看训练数据集长度:
-
-```python
-print(len(dataset))
-
-2975
-```
-
-获取数据信息, 数据信息的类型是一个字典, 包括 `'img_path'` 字段的存放图片的路径和 `'seg_map_path'` 字段存放分割标注的路径, 以及标签重映射的字段 `'label_map'` 和 `'reduce_zero_label'`(主要功能在下文中介绍), 还有存放已加载标签字段 `'seg_fields'`, 和当前样本的索引字段 `'sample_idx'`.
-
-```python
-# 获取数据集中第一组样本的数据信息
-print(dataset.get_data_info(0))
-
-{'img_path': 'data/cityscapes/leftImg8bit/train/aachen/aachen_000000_000019_leftImg8bit.png',
- 'seg_map_path': 'data/cityscapes/gtFine/train/aachen/aachen_000000_000019_gtFine_labelTrainIds.png',
- 'label_map': None,
- 'reduce_zero_label': False,
- 'seg_fields': [],
- 'sample_idx': 0}
-```
-
-获取数据集元信息, MMSegmentation 的数据集元信息的类型同样是一个字典, 包括 `'classes'` 字段存放数据集类别, `'palette'` 存放数据集类别对应的可视化时调色盘的颜色, 以及标签重映射的字段 `'label_map'` 和 `'reduce_zero_label'`.
-
-```python
-print(dataset.metainfo)
-
-{'classes': ('road',
-  'sidewalk',
-  'building',
-  'wall',
-  'fence',
-  'pole',
-  'traffic light',
-  'traffic sign',
-  'vegetation',
-  'terrain',
-  'sky',
-  'person',
-  'rider',
-  'car',
-  'truck',
-  'bus',
-  'train',
-  'motorcycle',
-  'bicycle'),
- 'palette': [[128, 64, 128],
-  [244, 35, 232],
-  [70, 70, 70],
-  [102, 102, 156],
-  [190, 153, 153],
-  [153, 153, 153],
-  [250, 170, 30],
-  [220, 220, 0],
-  [107, 142, 35],
-  [152, 251, 152],
-  [70, 130, 180],
-  [220, 20, 60],
-  [255, 0, 0],
-  [0, 0, 142],
-  [0, 0, 70],
-  [0, 60, 100],
-  [0, 80, 100],
-  [0, 0, 230],
-  [119, 11, 32]],
- 'label_map': None,
- 'reduce_zero_label': False}
-```
-
-数据集 `__getitem__` 方法的返回值, 是经过数据增强的样本数据的输出, 同样也是一个字典, 包括两个字段, `'inputs'` 字段是当前样本经过数据增强操作的图像, 类型为 torch.Tensor, `'data_samples'` 字段存放的数据类型是 MMSegmentation 1.x 新添加的数据结构 [`Segdatasample`](./structures.md), 其中`gt_sem_seg` 字段是经过数据增强的标签数据.
-
-```python
-print(dataset[0])
-
-{'inputs': tensor([[[131, 130, 130,  ...,  23,  23,  23],
-          [132, 132, 132,  ...,  23,  22,  23],
-          [134, 133, 133,  ...,  23,  23,  23],
-          ...,
-          [ 66,  67,  67,  ...,  71,  71,  71],
-          [ 66,  67,  66,  ...,  68,  68,  68],
-          [ 67,  67,  66,  ...,  70,  70,  70]],
-
-         [[143, 143, 142,  ...,  28,  28,  29],
-          [145, 145, 145,  ...,  28,  28,  29],
-          [145, 145, 145,  ...,  27,  28,  29],
-          ...,
-          [ 75,  75,  76,  ...,  80,  81,  81],
-          [ 75,  76,  75,  ...,  80,  80,  80],
-          [ 77,  76,  76,  ...,  82,  82,  82]],
-
-         [[126, 125, 126,  ...,  21,  21,  22],
-          [127, 127, 128,  ...,  21,  21,  22],
-          [127, 127, 126,  ...,  21,  21,  22],
-          ...,
-          [ 63,  63,  64,  ...,  69,  69,  70],
-          [ 64,  65,  64,  ...,  69,  69,  69],
-          [ 65,  66,  66,  ...,  72,  71,  71]]], dtype=torch.uint8),
- 'data_samples': <SegDataSample(
-
-     META INFORMATION
-     img_path: 'data/cityscapes/leftImg8bit/train/aachen/aachen_000000_000019_leftImg8bit.png'
-     seg_map_path: 'data/cityscapes/gtFine/train/aachen/aachen_000000_000019_gtFine_labelTrainIds.png'
-     img_shape: (512, 1024, 3)
-     flip_direction: None
-     ori_shape: (1024, 2048)
-     flip: False
-
-     DATA FIELDS
-     gt_sem_seg: <PixelData(
-
-             META INFORMATION
-
-             DATA FIELDS
-             data: tensor([[[2, 2, 2,  ..., 8, 8, 8],
-                          [2, 2, 2,  ..., 8, 8, 8],
-                          [2, 2, 2,  ..., 8, 8, 8],
-                          ...,
-                          [0, 0, 0,  ..., 0, 0, 0],
-                          [0, 0, 0,  ..., 0, 0, 0],
-                          [0, 0, 0,  ..., 0, 0, 0]]])
-         )>
-     _gt_sem_seg: <PixelData(
-
-             META INFORMATION
-
-             DATA FIELDS
-             data: tensor([[[2, 2, 2,  ..., 8, 8, 8],
-                          [2, 2, 2,  ..., 8, 8, 8],
-                          [2, 2, 2,  ..., 8, 8, 8],
-                          ...,
-                          [0, 0, 0,  ..., 0, 0, 0],
-                          [0, 0, 0,  ..., 0, 0, 0],
-                          [0, 0, 0,  ..., 0, 0, 0]]])
-         )>
- )}
-```
-
-## BaseSegDataset
-
-由于 MMSegmentation 中的所有数据集的基本功能均包括(1) 加载[数据集预处理](../user_guides/2_dataset_prepare.md) 之后的数据信息和 (2) 将数据送入数据变换流水线中进行数据变换, 因此在 MMSegmentation 中将其中的共同接口抽象成 [`BaseSegDataset`](https://mmsegmentation.readthedocs.io/zh_CN/latest/api.html?highlight=BaseSegDataset#mmseg.datasets.BaseSegDataset)，它继承自 [MMEngine 的 `BaseDataset`](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/basedataset.md), 遵循 OpenMMLab 数据集初始化统一流程, 支持高效的内部数据存储格式, 支持数据集拼接、数据集重复采样等功能.
-在 MMSegmentation BaseSegDataset 中重新定义了**数据信息加载方法**（`load_data_list`）和并新增了 `get_label_map` 方法用来**修改数据集的类别信息**.
-
-### 数据信息加载
-
-数据信息加载的内容是样本数据的图片路径和标签路径, 具体实现在 MMSegmentation 的 BaseSegDataset 的 [`load_data_list`](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/basesegdataset.py#L231) 中.
-主要有两种获取图片和标签的路径方法, 如果当数据集目录按以下目录结构组织, [`load_data_list`](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/basesegdataset.py#L231)) 会根据数据路径和后缀来解析.
-
-```
-├── data
-│   ├── my_dataset
-│   │   ├── img_dir
-│   │   │   ├── train
-│   │   │   │   ├── xxx{img_suffix}
-│   │   │   │   ├── yyy{img_suffix}
-│   │   │   ├── val
-│   │   │   │   ├── zzz{img_suffix}
-│   │   ├── ann_dir
-│   │   │   ├── train
-│   │   │   │   ├── xxx{seg_map_suffix}
-│   │   │   │   ├── yyy{seg_map_suffix}
-│   │   │   ├── val
-│   │   │   │   ├── zzz{seg_map_suffix}
-```
-
-例如 ADE20k 数据集结构如下所示:
-
-```
-├── ade
-│   ├── ADEChallengeData2016
-│   │   ├── annotations
-│   │   │   ├── training
-│   │   │   │   ├── ADE_train_00000001.png
-│   │   │   │   ├── ...
-│   │   │   │── validation
-│   │   │   │   ├── ADE_val_00000001.png
-│   │   │   │   ├── ...
-│   │   ├── images
-│   │   │   ├── training
-│   │   │   │   ├── ADE_train_00000001.jpg
-│   │   │   │   ├── ...
-│   │   │   ├── validation
-│   │   │   │   ├── ADE_val_00000001.jpg
-│   │   │   │   ├── ...
-```
-
-实例化 ADE20k 数据集时，输入图片和标签的路径和后缀:
-
-```python
-from mmseg.datasets import ADE20KDataset
-
-ADE20KDataset(data_root = 'data/ade/ADEChallengeData2016',
-    data_prefix=dict(img_path='images/training', seg_map_path='annotations/training'),
-    img_suffix='.jpg',
-    seg_map_suffix='.png',
-    reduce_zero_label=True）
-```
-
-如果数据集有标注文件, 实例化数据集时会根据输入的数据集标注文件加载数据信息. 例如, PascalContext 数据集实例, 输入标注文件的内容为:
-
-```python
-2008_000008
-...
-```
-
-实例化时需要定义 `ann_file`
-
-```python
-PascalContextDataset(data_root='data/VOCdevkit/VOC2010/',
-    data_prefix=dict(img_path='JPEGImages', seg_map_path='SegmentationClassContext'),
-    ann_file='ImageSets/SegmentationContext/train.txt')
-```
-
-### 数据集类别修改
-
-- 通过输入 metainfo 修改
-  `BaseSegDataset` 的子类元信息在数据集实现时定义为类变量，例如 Cityscapes 的 `METAINFO` 变量:
-
-```python
-class CityscapesDataset(BaseSegDataset):
-    """Cityscapes dataset.
-
-    The ``img_suffix`` is fixed to '_leftImg8bit.png' and ``seg_map_suffix`` is
-    fixed to '_gtFine_labelTrainIds.png' for Cityscapes dataset.
-    """
-    METAINFO = dict(
-        classes=('road', 'sidewalk', 'building', 'wall', 'fence', 'pole',
-                 'traffic light', 'traffic sign', 'vegetation', 'terrain',
-                 'sky', 'person', 'rider', 'car', 'truck', 'bus', 'train',
-                 'motorcycle', 'bicycle'),
-        palette=[[128, 64, 128], [244, 35, 232], [70, 70, 70], [102, 102, 156],
-                 [190, 153, 153], [153, 153, 153], [250, 170,
-                                                    30], [220, 220, 0],
-                 [107, 142, 35], [152, 251, 152], [70, 130, 180],
-                 [220, 20, 60], [255, 0, 0], [0, 0, 142], [0, 0, 70],
-                 [0, 60, 100], [0, 80, 100], [0, 0, 230], [119, 11, 32]])
-
-```
-
-这里的 `'classes'` 中定义了 Cityscapes 数据集标签中的类别名, 如果训练时只关注几个交通工具类别, **忽略其他类别**,
-在实例化 Cityscapes 数据集时通过定义 `metainfo` 输入参数的 classes 的字段来修改数据集的元信息:
-
-```python
-from mmseg.datasets import CityscapesDataset
-
-data_root = 'data/cityscapes/'
-data_prefix=dict(img_path='leftImg8bit/train', seg_map_path='gtFine/train')
-# metainfo 中只保留以下 classes
-metainfo=dict(classes=( 'car', 'truck', 'bus', 'train', 'motorcycle', 'bicycle'))
-dataset = CityscapesDataset(data_root=data_root, data_prefix=data_prefix, metainfo=metainfo)
-
-print(dataset.metainfo)
-
-{'classes': ('car', 'truck', 'bus', 'train', 'motorcycle', 'bicycle'),
- 'palette': [[0, 0, 142],
-  [0, 0, 70],
-  [0, 60, 100],
-  [0, 80, 100],
-  [0, 0, 230],
-  [119, 11, 32],
-  [128, 64, 128],
-  [244, 35, 232],
-  [70, 70, 70],
-  [102, 102, 156],
-  [190, 153, 153],
-  [153, 153, 153],
-  [250, 170, 30],
-  [220, 220, 0],
-  [107, 142, 35],
-  [152, 251, 152],
-  [70, 130, 180],
-  [220, 20, 60],
-  [255, 0, 0]],
- # 类别索引为 255 的像素，在计算损失时会被忽略
- 'label_map': {0: 255,
-  1: 255,
-  2: 255,
-  3: 255,
-  4: 255,
-  5: 255,
-  6: 255,
-  7: 255,
-  8: 255,
-  9: 255,
-  10: 255,
-  11: 255,
-  12: 255,
-  13: 0,
-  14: 1,
-  15: 2,
-  16: 3,
-  17: 4,
-  18: 5},
- 'reduce_zero_label': False}
-```
-
-可以看到, 数据集元信息的类别和默认 Cityscapes 不同. 并且, 定义了标签重映射的字段 `label_map` 用来修改每个分割掩膜上的像素的类别索引, 分割标签类别会根据 `label_map`, 将类别重映射, [具体实现](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/basesegdataset.py#L151):
-
-```python
-gt_semantic_seg_copy = gt_semantic_seg.copy()
-for old_id, new_id in results['label_map'].items():
-    gt_semantic_seg[gt_semantic_seg_copy == old_id] = new_id
-```
-
-- 通过 `reduce_zero_label` 修改
-  对于常见的忽略 0 号标签的场景, `BaseSegDataset` 的子类中可以用 `reduce_zero_label` 输入参数来控制。`reduce_zero_label` (默认为 `False`)
-  用来控制是否将标签 0 忽略, 当该参数为 `True` 时(最常见的应用是 ADE20k 数据集), 对分割标签中第 0 个类别对应的类别索引改为 255 (MMSegmentation 模型中计算损失时, 默认忽略 255), 其他类别对应的类别索引减一:
-
-```python
-gt_semantic_seg[gt_semantic_seg == 0] = 255
-gt_semantic_seg = gt_semantic_seg - 1
-gt_semantic_seg[gt_semantic_seg == 254] = 255
-```
-
-## 数据集与数据变换流水线
-
-在常用接口的例子中可以看到, 输入的参数中定义了数据变换流水线参数 `pipeline`, 数据集 `__getitem__` 方法返回经过数据变换的值.
-当数据集输入参数没有定义 pipeline, 返回值和 `get_data_info` 方法返回值相同, 例如:
-
-```python
-from mmseg.datasets import CityscapesDataset
-
-data_root = 'data/cityscapes/'
-data_prefix=dict(img_path='leftImg8bit/train', seg_map_path='gtFine/train')
-dataset = CityscapesDataset(data_root=data_root, data_prefix=data_prefix, test_mode=False)
-
-print(dataset[0])
-
-{'img_path': 'data/cityscapes/leftImg8bit/train/aachen/aachen_000000_000019_leftImg8bit.png',
- 'seg_map_path': 'data/cityscapes/gtFine/train/aachen/aachen_000000_000019_gtFine_labelTrainIds.png',
- 'label_map': None,
- 'reduce_zero_label': False,
- 'seg_fields': [],
- 'sample_idx': 0}
-```
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/engine.md b/mmsegmentation/docs/zh_cn/advanced_guides/engine.md
deleted file mode 100644
index 79b4c8d..0000000
--- a/mmsegmentation/docs/zh_cn/advanced_guides/engine.md
+++ /dev/null
@@ -1,281 +0,0 @@
-# 训练引擎
-
-MMEngine 定义了一些[基础循环控制器](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py) 例如基于轮次的训练循环 (`EpochBasedTrainLoop`), 基于迭代次数的训练循环 (`IterBasedTrainLoop`), 标准的验证循环 (`ValLoop`) 和标准的测试循环 (`TestLoop`).
-OpenMMLab 的算法库如 MMSegmentation 将模型训练, 测试和推理抽象为执行器(`Runner`) 来处理. 用户可以直接使用 MMEngine 中的默认执行器, 也可以对执行器进行修改以满足定制化需求. 这个文档主要介绍用户如何配置已有的运行设定, 钩子和优化器的基本概念与使用方法.
-
-## 配置运行设定
-
-### 配置训练长度
-
-循环控制器指的是训练, 验证和测试时的执行流程, 在配置文件里面使用 `train_cfg`, `val_cfg` 和 `test_cfg` 来构建这些流程. MMSegmentation 在 `configs/_base_/schedules` 文件夹里面的 `train_cfg` 设置常用的训练长度.
-例如, 使用基于迭代次数的训练循环 (`IterBasedTrainLoop`) 去训练 80,000 个迭代次数, 并且每 8,000 iteration 做一次验证, 可以如下设置:
-
-```python
-train_cfg = dict(type='IterBasedTrainLoop', max_iters=80000, val_interval=8000)
-```
-
-### 配置训练优化器
-
-这里是一个 SGD 优化器的例子:
-
-```python
-optim_wrapper = dict(
-    type='OptimWrapper',
-    optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005),
-    clip_grad=None)
-```
-
-OpenMMLab 支持 PyTorch 里面所有的优化器, 更多细节可以参考 MMEngine [优化器文档](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/optim_wrapper.md).
-
-需要强调的是, `optim_wrapper` 是 `runner` 的变量, 所以需要配置优化器时配置的字段是 `optim_wrapper` 字段. 更多关于优化器的使用方法, 可以看下面优化器的章节.
-
-### 配置训练参数调度器
-
-在配置训练参数调度器前, 推荐先了解 [MMEngine 文档](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/param_scheduler.md) 里面关于参数调度器的基本概念.
-
-以下是一个参数调度器的例子, 训练时前 1,000 个 iteration 时采用线性变化的学习率策略作为训练预热, 从 1,000 iteration 之后直到最后 16,000 个 iteration 时则采用默认的多项式学习率衰减:
-
-```python
-param_scheduler = [
-    dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
-    dict(
-        type='PolyLR',
-        eta_min=1e-4,
-        power=0.9,
-        begin=1000,
-        end=160000,
-        by_epoch=False,
-    )
-]
-```
-
-注意: 当修改 `train_cfg` 里面 `max_iters` 的时候, 请确保参数调度器 `param_scheduler` 里面的参数也被同时修改.
-
-## 钩子 (Hook)
-
-### 介绍
-
-OpenMMLab 将模型训练和测试过程抽象为 `Runner`, 插入钩子可以实现在 `Runner` 中不同的训练和测试节点 (例如 "每个训练 iter 前后", "每个验证 iter 前后" 等不同阶段) 所需要的相应功能. 更多钩子机制的介绍可以参考[这里](https://www.calltutors.com/blog/what-is-hook).
-
-`Runner` 中所使用的钩子分为两类:
-
-- 默认钩子 (default hooks)
-
-它们实现了训练时所必需的功能, 在配置文件中用 `default_hooks` 定义传给 `Runner`, `Runner` 通过 [`register_default_hooks`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py#L1780) 方法注册.
-钩子有对应的优先级, 优先级越高, 越早被执行器调用. 如果优先级一样, 被调用的顺序和钩子注册的顺序一致.
-不建议用户修改默认钩子的优先级, 可以参考 [mmengine hooks 文档](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/hook.md) 了解钩子优先级的定义.
-下面是 MMSegmentation 中所用到的默认钩子：
-
-|                                                          钩子                                                          |                                              功能                                               |      优先级       |
-| :--------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------: | :---------------: |
-|          [IterTimerHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/iter_timer_hook.py)           |                                   记录 iteration 花费的时间.                                    |    NORMAL (50)    |
-|              [LoggerHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/logger_hook.py)              | 从 `Runner` 里不同的组件中收集日志记录, 并将其输出到终端, JSON 文件, tensorboard, wandb 等下游. | BELOW_NORMAL (60) |
-|     [ParamSchedulerHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/param_scheduler_hook.py)      |                          更新优化器里面的一些超参数, 例如学习率的动量.                          |     LOW (70)      |
-|          [CheckpointHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/checkpoint_hook.py)          |                                  规律性地保存 checkpoint 文件.                                  |   VERY_LOW (90)   |
-|      [DistSamplerSeedHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/sampler_seed_hook.py)       |                               确保分布式采样器 shuffle 是打开的.                                |    NORMAL (50)    |
-| [SegVisualizationHook](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/visualization/local_visualizer.py) |                                可视化验证和测试过程里的预测结果.                                |    NORMAL (50)    |
-
-MMSegmentation 会在 [`defualt_hooks`](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/_base_/schedules/schedule_160k.py#L19-L25) 里面注册一些训练所必需功能的钩子::
-
-```python
-default_hooks = dict(
-    timer=dict(type='IterTimerHook'),
-    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
-    param_scheduler=dict(type='ParamSchedulerHook'),
-    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=32000),
-    sampler_seed=dict(type='DistSamplerSeedHook'),
-    visualization=dict(type='SegVisualizationHook'))
-```
-
-以上默认钩子除 `SegVisualizationHook` 外都是在 MMEngine 中所实现, `SegVisualizationHook` 是在 MMSegmentation 里被实现的钩子, 之后会专门介绍.
-
-- 修改默认的钩子
-
-以 `default_hooks` 里面的 `logger` 和 `checkpoint` 为例, 我们来介绍如何修改 `default_hooks` 中默认的钩子.
-
-(1) 模型保存配置
-
-`default_hooks` 使用 `checkpoint` 字段来初始化[模型保存钩子 (CheckpointHook)](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/checkpoint_hook.py#L19).
-
-```python
-checkpoint = dict(type='CheckpointHook', interval=1)
-```
-
-用户可以设置 `max_keep_ckpts` 来只保存少量的检查点或者用 `save_optimizer` 来决定是否保存 optimizer 的信息.
-更多相关参数的细节可以参考[这里](https://mmengine.readthedocs.io/zh_CN/latest/api/generated/mmengine.hooks.CheckpointHook.html#checkpointhook).
-
-(2) 日志配置
-
-`日志钩子 (LoggerHook)` 被用来收集 `执行器 (Runner)` 里面不同组件的日志信息然后写入终端, JSON 文件, tensorboard 和 wandb 等地方.
-
-```python
-logger=dict(type='LoggerHook', interval=10)
-```
-
-在最新的 1.x 版本的 MMSegmentation 里面, 一些日志钩子 (LoggerHook) 例如 `TextLoggerHook`, `WandbLoggerHook` 和 `TensorboardLoggerHook` 将不再被使用.
-作为替代, MMEngine 使用 `LogProcessor` 来处理上述钩子处理的信息, 它们现在在 [`MessageHub`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/logging/message_hub.py#L17),
-[`WandbVisBackend`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/visualization/vis_backend.py#L324) 和 [`TensorboardVisBackend`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/visualization/vis_backend.py#L472) 里面.
-
-具体使用方法如下, 配置可视化器和同时指定可视化后端, 这里使用 Tensorboard 作为可视化器的后端:
-
-```python
-# TensorboardVisBackend
-visualizer = dict(
-    type='SegLocalVisualizer', vis_backends=[dict(type='TensorboardVisBackend')], name='visualizer')
-```
-
-关于更多相关用法, 可以参考 [MMEngine 可视化后端用户教程](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/advanced_tutorials/visualization.md).
-
-- 自定义钩子 (custom hooks)
-
-自定义钩子在配置通过 `custom_hooks` 定义, `Runner` 通过 [`register_custom_hooks`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py#L1820) 方法注册.
-自定义钩子优先级需要在配置文件里设置, 如果没有设置, 则会被默认设置为 `NORMAL`. 下面是部分 MMEngine 中实现的自定义钩子:
-
-|                                                  钩子                                                  |                                             用法                                             |
-| :----------------------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------: |
-|         [EMAHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/ema_hook.py)         |               在模型训练时使用指数滑动平均 (Exponential Moving Average, EMA).                |
-| [EmptyCacheHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/empty_cache_hook.py)  |                          在训练时释放所有没有被缓存占用的 GPU 显存.                          |
-| [SyncBuffersHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/sync_buffer_hook.py) | 在每个训练 Epoch 结束时同步模型 buffer 里的参数例如 BN 里的 `running_mean` 和 `running_var`. |
-
-以下是 `EMAHook` 的用例, 配置文件中, 将已经实现的自定义钩子的配置作为 `custom_hooks` 列表中的成员.
-
-```python
-custom_hooks = [
-    dict(type='EMAHook', start_iters=500, priority='NORMAL')
-]
-```
-
-### SegVisualizationHook
-
-MMSegmentation 实现了 [`SegVisualizationHook`](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/engine/hooks/visualization_hook.py#L17), 用来在验证和测试时可视化预测结果.
-`SegVisualizationHook` 重写了基类 `Hook` 中的 `_after_iter` 方法, 在验证或测试时, 根据指定的迭代次数间隔调用 `visualizer` 的 `add_datasample` 方法绘制语义分割结果, 具体实现如下:
-
-```python
-...
-@HOOKS.register_module()
-class SegVisualizationHook(Hook):
-...
-    def _after_iter(self,
-                    runner: Runner,
-                    batch_idx: int,
-                    data_batch: dict,
-                    outputs: Sequence[SegDataSample],
-                    mode: str = 'val') -> None:
-...
-        # 如果是训练阶段或者 self.draw 为 False 则直接跳出
-        if self.draw is False or mode == 'train':
-            return
-...
-        if self.every_n_inner_iters(batch_idx, self.interval):
-            for output in outputs:
-                img_path = output.img_path
-                img_bytes = self.file_client.get(img_path)
-                img = mmcv.imfrombytes(img_bytes, channel_order='rgb')
-                window_name = f'{mode}_{osp.basename(img_path)}'
-
-                self._visualizer.add_datasample(
-                    window_name,
-                    img,
-                    data_sample=output,
-                    show=self.show,
-                    wait_time=self.wait_time,
-                    step=runner.iter)
-
-```
-
-关于可视化更多的细节可以查看[这里](../user_guides/visualization.md).
-
-## 优化器
-
-在上面配置运行设定里, 我们给出了配置训练优化器的简单示例. 本章节将进一步详细介绍在 MMSegmentation 里如何配置优化器.
-
-### 优化器封装
-
-OpenMMLab 2.0 设计了优化器封装, 它支持不同的训练策略, 包括混合精度训练、梯度累加和梯度截断等, 用户可以根据需求选择合适的训练策略.
-优化器封装还定义了一套标准的参数更新流程, 用户可以基于这一套流程, 在同一套代码里, 实现不同训练策略的切换. 如果想了解更多, 可以参考 [MMEngine 优化器封装文档](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/optim_wrapper.md).
-
-以下是 MMSegmentation 中常用的使用方法:
-
-#### 配置 PyTorch 支持的优化器
-
-OpenMMLab 2.0 支持 PyTorch 原生所有优化器, 参考[这里](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/optim_wrapper.md#%E7%AE%80%E5%8D%95%E9%85%8D%E7%BD%AE).
-
-在配置文件中设置训练时 `Runner` 所使用的优化器, 需要定义 `optim_wrapper`, 而不是 `optimizer`, 下面是一个配置训练中优化器的例子:
-
-```python
-optim_wrapper = dict(
-    type='OptimWrapper',
-    optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005),
-    clip_grad=None)
-```
-
-#### 配置梯度裁剪
-
-当模型训练需要使用梯度裁剪的训练技巧式, 可以按照如下示例进行配置:
-
-```python
-optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer,
-                        clip_grad=dict(max_norm=0.01, norm_type=2))
-```
-
-这里 `max_norm` 指的是裁剪后梯度的最大值,  `norm_type` 指的是裁剪梯度时使用的范数. 相关方法可参考 [torch.nn.utils.clip_grad_norm\_](https://pytorch.org/docs/stable/generated/torch.nn.utils.clip_grad_norm_.html).
-
-#### 配置混合精度训练
-
-当需要使用混合精度训练降低内存时, 可以使用 `AmpOptimWrapper`, 具体配置如下:
-
-```python
-optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)
-optim_wrapper = dict(type='AmpOptimWrapper', optimizer=optimizer)
-```
-
-[`AmpOptimWrapper`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/amp_optimizer_wrapper.py#L20) 中 `loss_scale` 的默认设置是 `dynamic`.
-
-#### 配置模型网络不同层的超参数
-
-在模型训练中, 如果想在优化器里为不同参数分别设置优化策略, 例如设置不同的学习率、权重衰减等超参数, 可以通过设置配置文件里 `optim_wrapper` 中的 `paramwise_cfg` 来实现.
-
-下面的配置文件以 [ViT `optim_wrapper`](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_vit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py#L15-L27) 为例介绍 `paramwise_cfg` 参数使用.
-训练时将 `pos_embed`, `mask_token`, `norm` 模块的 weight decay 参数的系数设置成 0.
-即: 在训练时, 这些模块的 weight decay 将被变为 `weight_decay * decay_mult`=0.
-
-```python
-optimizer = dict(
-        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01)
-optim_wrapper = dict(
-    type='OptimWrapper',
-    optimizer=optimizer,
-    paramwise_cfg=dict(
-        custom_keys={
-            'pos_embed': dict(decay_mult=0.),
-            'cls_token': dict(decay_mult=0.),
-            'norm': dict(decay_mult=0.)
-        }))
-```
-
-其中 `decay_mult` 指的是对应参数的权重衰减的系数.
-关于更多 `paramwise_cfg` 的使用可以在 [MMEngine 优化器封装文档](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/optim_wrapper.md) 里面查到.
-
-### 优化器封装构造器
-
-默认的优化器封装构造器 [`DefaultOptimWrapperConstructor`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py#L19) 根据输入的 `optim_wrapper` 和 `optim_wrapper` 中定义的 `paramwise_cfg` 来构建训练中使用的优化器. 当 [`DefaultOptimWrapperConstructor`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py#L19) 功能不能满足需求时, 可以自定义优化器封装构造器来实现超参数的配置.
-
-MMSegmentation 中的实现了 [`LearningRateDecayOptimizerConstructor`](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/engine/optimizers/layer_decay_optimizer_constructor.py#L104), 可以对以 ConvNeXt, BEiT 和 MAE 为骨干网络的模型训练时, 骨干网络的模型参数的学习率按照定义的衰减比例（`decay_rate`）逐层递减, 在配置文件中的配置如下:
-
-```python
-optim_wrapper = dict(
-    _delete_=True,
-    type='AmpOptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.05),
-    paramwise_cfg={
-        'decay_rate': 0.9,
-        'decay_type': 'stage_wise',
-        'num_layers': 12
-    },
-    constructor='LearningRateDecayOptimizerConstructor',
-    loss_scale='dynamic')
-```
-
-`_delete_=True` 的作用是 OpenMMLab Config 中的忽略继承的配置, 在该代码片段中忽略继承的 `optim_wrapper` 配置, 更多 `_delete_` 字段的内容可以参考 [MMEngine 文档](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/advanced_tutorials/config.md#%E5%88%A0%E9%99%A4%E5%AD%97%E5%85%B8%E4%B8%AD%E7%9A%84-key).
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/evaluation.md b/mmsegmentation/docs/zh_cn/advanced_guides/evaluation.md
deleted file mode 100644
index dc93a46..0000000
--- a/mmsegmentation/docs/zh_cn/advanced_guides/evaluation.md
+++ /dev/null
@@ -1,158 +0,0 @@
-# 模型评测
-
-模型评测过程会分别在 [ValLoop](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py#L300) 和 [TestLoop](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py#L373) 中被执行，用户可以在训练期间或使用配置文件中简单设置的测试脚本进行模型性能评估。`ValLoop` 和 `TestLoop` 属于 [Runner](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py#L59)，它们会在第一次被调用时构建。由于 `dataloader` 与 `evaluator` 是必需的参数，所以要成功构建 `ValLoop`，在构建 `Runner` 时必须设置 `val_dataloader` 和 `val_evaluator`，`TestLoop` 亦然。有关 Runner 设计的更多信息，请参阅 [MMEngine](https://github.com/open-mmlab/mmengine) 的[文档](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/design/runner.md)。
-
-<center>
-  <img src='../../../resources/test_step.png' />
-  <center>测试/验证 数据流</center>
-</center>
-
-在 MMSegmentation 中，默认情况下，我们将 dataloader 和 metrics 的设置写在数据集配置文件中，并将 evaluation loop 的配置写在 `schedule_x` 配置文件中。
-
-例如，在 ADE20K 配置文件 `configs/_base_/dataset/ADE20K.py` 中，在第37到48行，我们配置了 `val_dataloader`，在第51行，我们选择 `IoUMetric` 作为 evaluator，并设置 `mIoU` 作为指标：
-
-```python
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='images/validation',
-            seg_map_path='annotations/validation'),
-        pipeline=test_pipeline))
-
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
-```
-
-为了能够在训练期间进行评估模型，我们将评估配置添加到了 `configs/schedules/schedule_40k.py` 文件的第15至16行：
-
-```python
-train_cfg = dict(type='IterBasedTrainLoop', max_iters=40000, val_interval=4000)
-val_cfg = dict(type='ValLoop')
-```
-
-使用以上两种设置，MMSegmentation 在 40K 迭代训练期间，每 4000 次迭代进行一次模型 **mIoU** 指标的评估。
-
-如果我们希望在训练后测试模型，则需要将 `test_dataloader`、`test_evaluator` 和 `test_cfg` 配置添加到配置文件中。
-
-```python
-test_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='images/validation',
-            seg_map_path='annotations/validation'),
-        pipeline=test_pipeline))
-
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
-test_cfg = dict(type='TestLoop')
-```
-
-在 MMSegmentation 中，默认情况下，`test_dataloader` 和 `test_evaluator` 的设置与 `ValLoop` 的 dataloader 和 evaluator 相同，我们可以修改这些设置以满足我们的需要。
-
-## IoUMetric
-
-MMSegmentation 基于 [MMEngine](https://github.com/open-mmlab/mmengine) 提供的 [BaseMetric](https://github.com/open-mmlab/mmengine/blob/main/mmengine/evaluator/metric.py) 实现 [IoUMetric](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/evaluation/metrics/iou_metric.py) 和 [CityscapesMetric](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/evaluation/metrics/citys_metric.py)，以评估模型的性能。有关统一评估接口的更多详细信息，请参阅[文档](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/evaluation.html)。
-
-这里我们简要介绍 `IoUMetric` 的参数和两种主要方法。
-
-除了 `collect_device` 和 `prefix` 之外，`IoUMetric` 的构建还包含一些其他参数。
-
-构造函数的参数：
-
-- ignore_index（int）- 将在评估中忽略的类别索引。默认值：255。
-- iou_metrics（list\[str\] | str）- 需要计算的指标，可选项包括 'mIoU'、'mDice' 和 'mFscore'。
-- nan_to_num（int，可选）- 如果指定，NaN 值将被用户定义的数字替换。默认值：None。
-- beta（int）- 决定综合评分中 recall 的权重。默认值：1。
-- collect_device（str）- 用于在分布式训练期间从不同进程收集结果的设备名称。必须是 'cpu' 或 'gpu'。默认为 'cpu'。
-- prefix（str，可选）- 将添加到指标名称中的前缀，以消除不同 evaluator 的同名指标的歧义。如果参数中未提供前缀，则将使用 self.default_prefix 进行替代。默认为 None。
-
-`IoUMetric` 实现 IoU 指标的计算，`IoUMetric` 的两个核心方法是 `process` 和 `compute_metrics`。
-
-- `process` 方法处理一批 data 和 data_samples。
-- `compute_metrics` 方法根据处理的结果计算指标。
-
-### IoUMetric.process
-
-参数：
-
-- data_batch（Any）- 来自 dataloader 的一批数据。
-- data_samples（Sequence\[dict\]）- 模型的一批输出。
-
-返回值：
-
-此方法没有返回值，因为处理的结果将存储在 `self.results` 中，以在处理完所有批次后进行指标的计算。
-
-### IoUMetric.compute_metrics
-
-参数：
-
-- results（list）- 每个批次的处理结果。
-
-返回值：
-
-- Dict\[str，float\] - 计算的指标。指标的名称为 key，值是相应的结果。key 主要包括 **aAcc**、**mIoU**、**mAcc**、**mDice**、**mFscore**、**mPrecision**、**mPrecall**。
-
-## CityscapesMetric
-
-`CityscapesMetric` 使用由 Cityscapes 官方提供的 [CityscapesScripts](https://github.com/mcordts/cityscapesScripts) 进行模型性能的评估。
-
-### 使用方法
-
-在使用之前，请先安装 `cityscapesscripts` 包：
-
-```shell
-pip install cityscapesscripts
-```
-
-由于 `IoUMetric` 在 MMSegmentation 中作为默认的 evaluator 使用，如果您想使用 `CityscapesMetric`，则需要自定义配置文件。在自定义配置文件中，应按如下方式替换默认 evaluator。
-
-```python
-val_evaluator = dict(type='CityscapesMetric', output_dir='tmp')
-test_evaluator = val_evaluator
-```
-
-### 接口
-
-构造函数的参数：
-
-- output_dir (str) - 预测结果输出的路径
-- ignore_index (int) - 将在评估中忽略的类别索引。默认值：255。
-- format_only (bool) - 只为提交进行结果格式化而不进行评估。当您希望将结果格式化为特定格式并将其提交给测试服务器时有用。默认为 False。
-- keep_results (bool) - 是否保留结果。当 `format_only` 为 True 时，`keep_results` 必须为 True。默认为 False。
-- collect_device (str) - 用于在分布式训练期间从不同进程收集结果的设备名称。必须是 'cpu' 或 'gpu'。默认为 'cpu'。
-- prefix (str，可选) - 将添加到指标名称中的前缀，以消除不同 evaluator 的同名指标的歧义。如果参数中未提供前缀，则将使用 self.default_prefix 进行替代。默认为 None。
-
-#### CityscapesMetric.process
-
-该方法将在图像上绘制 mask，并将绘制的图像保存到 `work_dir` 中。
-
-参数：
-
-- data_batch（dict）- 来自 dataloader 的一批数据。
-- data_samples（Sequence\[dict\]）- 模型的一批输出。
-
-返回值：
-
-此方法没有返回值，因为处理的结果将存储在 `self.results` 中，以在处理完所有批次后进行指标的计算。
-
-#### CityscapesMetric.compute_metrics
-
-此方法将调用 `cityscapessscripts.evaluation.evalPixelLevelSemanticLabeling` 工具来计算指标。
-
-参数：
-
-- results（list）- 数据集的测试结果。
-
-返回值：
-
-- dict\[str:float\] - Cityscapes 评测结果。
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/index.rst b/mmsegmentation/docs/zh_cn/advanced_guides/index.rst
deleted file mode 100644
index 2aec1ac..0000000
--- a/mmsegmentation/docs/zh_cn/advanced_guides/index.rst
+++ /dev/null
@@ -1,26 +0,0 @@
-基本概念
-***************
-
-.. toctree::
-   :maxdepth: 1
-
-   data_flow.md
-   structures.md
-   models.md
-   datasets.md
-   transforms.md
-   evaluation.md
-   engine.md
-   training_tricks.md
-
-自定义组件
-************************
-
-.. toctree::
-   :maxdepth: 1
-
-   add_models.md
-   add_datasets.md
-   add_transforms.md
-   add_metrics.md
-   customize_runtime.md
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/models.md b/mmsegmentation/docs/zh_cn/advanced_guides/models.md
deleted file mode 100644
index 6eb2251..0000000
--- a/mmsegmentation/docs/zh_cn/advanced_guides/models.md
+++ /dev/null
@@ -1,177 +0,0 @@
-# 模型
-
-我们通常将深度学习任务中的神经网络定义为模型，这个模型即是算法的核心。[MMEngine](https://github.com/open-mmlab/mmengine) 抽象出了一个统一模型 [BaseModel](https://github.com/open-mmlab/mmengine/blob/main/mmengine/model/base_model/base_model.py#L16) 以标准化训练、测试和其他过程。MMSegmentation 实现的所有模型都继承自 `BaseModel`，并且在 MMSegmention 中，我们实现了前向传播并为语义分割算法添加了一些功能。
-
-## 常用组件
-
-### 分割器（Segmentor）
-
-在 MMSegmentation 中，我们将网络架构抽象为**分割器**，它是一个包含网络所有组件的模型。我们已经实现了**编码器解码器（EncoderDecoder）**和**级联编码器解码器（CascadeEncoderDecoder）**，它们通常由**数据预处理器**、**骨干网络**、**解码头**和**辅助头**组成。
-
-### 数据预处理器（Data preprocessor）
-
-**数据预处理器**是将数据复制到目标设备并将数据预处理为模型输入格式的部分。
-
-### 主干网络（Backbone）
-
-**主干网络**是将图像转换为特征图的部分，例如没有最后全连接层的 **ResNet-50**。
-
-### 颈部（Neck）
-
-**颈部**是连接主干网络和头的部分。它对主干网络生成的原始特征图进行一些改进或重新配置。例如 **Feature Pyramid Network（FPN）**。
-
-### 解码头（Decode head）
-
-**解码头**是将特征图转换为分割掩膜的部分，例如 **PSPNet**。
-
-### 辅助头（Auxiliary head）
-
-**辅助头**是一个可选组件，它将特征图转换为仅用于计算辅助损失的分割掩膜。
-
-## 基本接口
-
-MMSegmentation 封装 `BaseModel` 并实现了 [BaseSegmentor](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/models/segmentors/base.py#L15) 类，主要提供 `forward`、`train_step`、`val_step` 和 `test_step` 接口。接下来将详细介绍这些接口。
-
-### forward
-
-<center>
-  <img src='https://user-images.githubusercontent.com/15952744/228827860-c0e34875-d370-4736-84f0-9560c26c9576.png' />
-  <center>编码器解码器数据流</center>
-</center>
-
-<center>
-  <center><img src='https://user-images.githubusercontent.com/15952744/228827987-aa214507-0c6d-4a08-8ce4-679b2b200b79.png' /></center>
-  <center>级联编码器解码器数据流</center>
-</center>
-
-`forward` 方法返回训练、验证、测试和简单推理过程的损失或预测。
-
-该方法应接受三种模式：“tensor”、“predict” 和 “loss”：
-
-- “tensor”：前向推理整个网络并返回张量或张量数组，无需任何后处理，与常见的 `nn.Module` 相同。
-- “predict”：前向推理并返回预测值，这些预测值将被完全处理到 `SegDataSample` 列表中。
-- “loss”：前向推理并根据给定的输入和数据样本返回损失的`字典`。
-
-**注：**[SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py) 是 MMSegmentation 的数据结构接口，用作不同组件之间的接口。`SegDataSample` 实现了抽象数据元素 `mmengine.structures.BaseDataElement`，请参阅 [MMMEngine](https://github.com/open-mmlab/mmengine) 中的 [SegDataSample 文档](https://mmsegmentation.readthedocs.io/zh_CN/1.x/advanced_guides/structures.html)和[数据元素文档](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/data_element.html)了解更多信息。
-
-注意，此方法不处理在 `train_step` 方法中完成的反向传播或优化器更新。
-
-参数：
-
-- inputs（torch.Tensor）- 通常为形状是（N, C, ...) 的输入张量。
-- data_sample（list\[[SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py)\]) - 分割数据样本。它通常包括 `metainfo` 和 `gt_sem_seg` 等信息。默认值为 None。
-- mode (str) - 返回什么类型的值。默认为 'tensor'。
-
-返回值：
-
-- `dict` 或 `list`：
-  - 如果 `mode == "loss"`，则返回用于反向过程和日志记录的损失张量`字典`。
-  - 如果 `mode == "predict"`，则返回 `SegDataSample` 的`列表`，推理结果将被递增地添加到传递给 forward 方法的 `data_sample` 参数中，每个 `SegDataSeample` 包含以下关键词：
-    - pred_sm_seg (`PixelData`)：语义分割的预测。
-    - seg_logits (`PixelData`)：标准化前语义分割的预测指标。
-  - 如果 `mode == "tensor"`，则返回`张量`或`张量数组`的`字典`以供自定义使用。
-
-### 预测模式
-
-我们在[配置文档](../user_guides/1_config.md)中简要描述了模型配置的字段，这里我们详细介绍 `model.test_cfg` 字段。`model.test_cfg` 用于控制前向行为，`"predict"` 模式下的 `forward` 方法可以在两种模式下运行：
-
-- `whole_inference`：如果 `cfg.model.test_cfg.mode == 'whole'`，则模型将使用完整图像进行推理。
-
-  `whole_inference` 模式的一个示例配置：
-
-  ```python
-  model = dict(
-    type='EncoderDecoder'
-    ...
-    test_cfg=dict(mode='whole')
-  )
-  ```
-
-- `slide_inference`：如果 `cfg.model.test_cfg.mode == ‘slide’`，则模型将通过滑动窗口进行推理。**注意：** 如果选择 `slide` 模式，还应指定 `cfg.model.test_cfg.stride` 和 `cfg.model.test_cfg.crop_size`。
-
-  `slide_inference` 模式的一个示例配置：
-
-  ```python
-  model = dict(
-    type='EncoderDecoder'
-    ...
-    test_cfg=dict(mode='slide', crop_size=256, stride=170)
-  )
-  ```
-
-### train_step
-
-`train_step` 方法调用 `loss` 模式的前向接口以获得损失`字典`。`BaseModel` 类实现默认的模型训练过程，包括预处理、模型前向传播、损失计算、优化和反向传播。
-
-参数：
-
-- data (dict or tuple or list) - 从数据集采样的数据。在 MMSegmentation 中，数据字典包含 `inputs` 和 `data_samples` 两个字段。
-- optim_wrapper (OptimWrapper) - 用于更新模型参数的 OptimWrapper 实例。
-
-**注：**[OptimWrapper](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/optimizer_wrapper.py#L17) 提供了一个用于更新参数的通用接口，请参阅 [MMMEngine](https://github.com/open-mmlab/mmengine) 中的优化器封装[文档](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/optim_wrapper.html)了解更多信息。
-
-返回值：
-
--Dict\[str, `torch.Tensor`\]：用于记录日志的张量的`字典`。
-
-<center>
-  <img src='https://user-images.githubusercontent.com/15952744/228828089-a9ae1225-958d-4cf7-99af-9af8576f7ef7.png' />
-  <center>train_step 数据流</center>
-</center>
-
-### val_step
-
-`val_step` 方法调用 `predict` 模式的前向接口并返回预测结果，预测结果将进一步被传递给评测器的进程接口和钩子的 `after_val_inter` 接口。
-
-参数：
-
-- data (`dict` or `tuple` or `list`) - 从数据集中采样的数据。在 MMSegmentation 中，数据字典包含 `inputs` 和 `data_samples` 两个字段。
-
-返回值：
-
-- `list` - 给定数据的预测结果。
-
-<center>
-  <img src='https://user-images.githubusercontent.com/15952744/228828179-3269baa3-bebd-4c9a-9787-59e7d785fbcf.png' />
-  <center>test_step/val_step 数据流</center>
-</center>
-
-### test_step
-
-`BaseModel` 中 `test_step` 与 `val_step` 的实现相同。
-
-## 数据预处理器（Data Preprocessor）
-
-MMSegmentation 实现的 [SegDataPreProcessor](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/models/data_preprocessor.py#L13) 继承自由 [MMEngine](https://github.com/open-mmlab/mmengine) 实现的 [BaseDataPreprocessor](https://github.com/open-mmlab/mmengine/blob/main/mmengine/model/base_model/data_preprocessor.py#L18)，提供数据预处理和将数据复制到目标设备的功能。
-
-Runner 在构建阶段将模型传送到指定的设备，而 [SegDataPreProcessor](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/models/data_preprocessor.py#L13) 在 `train_step`、`val_step` 和 `test_step` 中将数据传送到指定设备，之后处理后的数据将被进一步传递给模型。
-
-`SegDataPreProcessor` 构造函数的参数：
-
-- mean (Sequence\[Number\], 可选) - R、G、B 通道的像素平均值。默认为 None。
-- std (Sequence\[Number\], 可选) - R、G、B 通道的像素标准差。默认为 None。
-- size (tuple, 可选) - 固定的填充大小。
-- size_divisor (int, 可选) - 填充大小的除法因子。
-- pad_val (float, 可选) - 填充值。默认值：0。
-- seg_pad_val (float, 可选) - 分割图的填充值。默认值：255。
-- bgr_to_rgb (bool) - 是否将图像从 BGR 转换为 RGB。默认为 False。
-- rgb_to_bgr (bool) - 是否将图像从 RGB 转换为 BGR。默认为 False。
-- batch_augments (list\[dict\], 可选) - 批量化的数据增强。默认值为 None。
-
-数据将按如下方式处理：
-
-- 收集数据并将其移动到目标设备。
-- 用定义的 `pad_val` 将输入填充到输入大小，并用定义的 `seg_Pad_val` 填充分割图。
-- 将输入堆栈到 batch_input。
-- 如果输入的形状为 (3, H, W)，则将输入从 BGR 转换为 RGB。
-- 使用定义的标准差和平均值标准化图像。
-- 在训练期间进行如 Mixup 和 Cutmix 的批量化数据增强。
-
-`forward` 方法的参数：
-
-- data (dict) - 从数据加载器采样的数据。
-- training (bool) - 是否启用训练时数据增强。
-
-`forward` 方法的返回值：
-
-- Dict：与模型输入格式相同的数据。
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/structures.md b/mmsegmentation/docs/zh_cn/advanced_guides/structures.md
deleted file mode 100644
index 958e011..0000000
--- a/mmsegmentation/docs/zh_cn/advanced_guides/structures.md
+++ /dev/null
@@ -1,102 +0,0 @@
-# 数据结构
-
-为了统一模型和各功能模块之间的输入和输出的接口, 在 OpenMMLab 2.0 MMEngine 中定义了一套抽象数据结构, 实现了基础的增/删/查/改功能, 支持不同设备间的数据迁移, 也支持了如
-`.cpu()`, `.cuda()`, `.get()` 和 `.detach()` 的类字典和张量的操作。具体可以参考 [MMEngine 文档](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/data_element.md)。
-
-同样的, MMSegmentation 亦遵循了 OpenMMLab 2.0 各模块间的接口协议, 定义了 `SegDataSample` 用来封装语义分割任务所需要的数据。
-
-## 语义分割数据 SegDataSample
-
-[SegDataSample](mmseg.structures.SegDataSample) 包括了三个主要数据字段 `gt_sem_seg`, `pred_sem_seg` 和 `seg_logits`, 分别用来存放标注信息, 预测结果和预测的未归一化前的 logits 值。
-
-| 字段           | 类型                      | 描述                            |
-| -------------- | ------------------------- | ------------------------------- |
-| gt_sem_seg     | [`PixelData`](#pixeldata) | 图像标注信息.                   |
-| pred_instances | [`PixelData`](#pixeldata) | 图像预测结果.                   |
-| seg_logits     | [`PixelData`](#pixeldata) | 模型预测未归一化前的 logits 值. |
-
-以下示例代码展示了 `SegDataSample` 的使用方法：
-
-```python
-import torch
-from mmengine.structures import PixelData
-from mmseg.structures import SegDataSample
-
-img_meta = dict(img_shape=(4, 4, 3),
-                 pad_shape=(4, 4, 3))
-data_sample = SegDataSample()
-# 定义 gt_segmentations 用于封装模型的输出信息
-gt_segmentations = PixelData(metainfo=img_meta)
-gt_segmentations.data = torch.randint(0, 2, (1, 4, 4))
-
-# 增加和处理 SegDataSample　中的属性
-data_sample.gt_sem_seg = gt_segmentations
-assert 'gt_sem_seg' in data_sample
-assert 'data' in data_sample.gt_sem_seg
-assert 'img_shape' in data_sample.gt_sem_seg.metainfo_keys()
-print(data_sample.gt_sem_seg.shape)
-'''
-(4, 4)
-'''
-print(data_sample)
-'''
-<SegDataSample(
-
-    META INFORMATION
-
-    DATA FIELDS
-    gt_sem_seg: <PixelData(
-
-            META INFORMATION
-            img_shape: (4, 4, 3)
-            pad_shape: (4, 4, 3)
-
-            DATA FIELDS
-            data: tensor([[[1, 1, 1, 0],
-                         [1, 0, 1, 1],
-                         [1, 1, 1, 1],
-                         [0, 1, 0, 1]]])
-        ) at 0x1c2b4156460>
-) at 0x1c2aae44d60>
-'''
-
-# 删除和修改 SegDataSample　中的属性
-data_sample = SegDataSample()
-gt_segmentations = PixelData(metainfo=img_meta)
-gt_segmentations.data = torch.randint(0, 2, (1, 4, 4))
-data_sample.gt_sem_seg = gt_segmentations
-data_sample.gt_sem_seg.set_metainfo(dict(img_shape=(4,4,9), pad_shape=(4,4,9)))
-del data_sample.gt_sem_seg.img_shape
-
-# 类张量的操作
-data_sample = SegDataSample()
-gt_segmentations = PixelData(metainfo=img_meta)
-gt_segmentations.data = torch.randint(0, 2, (1, 4, 4))
-cuda_gt_segmentations = gt_segmentations.cuda()
-cuda_gt_segmentations = gt_segmentations.to('cuda:0')
-cpu_gt_segmentations = cuda_gt_segmentations.cpu()
-cpu_gt_segmentations = cuda_gt_segmentations.to('cpu')
-```
-
-## 在 SegDataSample 中自定义新的属性
-
-如果你想在 `SegDataSample` 中自定义新的属性，你可以参考下面的 [SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py) 示例:
-
-```python
-class SegDataSample(BaseDataElement):
-    ...
-
-    @property
-    def xxx_property(self) -> xxxData:
-        return self._xxx_property
-
-    @xxx_property.setter
-    def xxx_property(self, value: xxxData) -> None:
-        self.set_field(value, '_xxx_property', dtype=xxxData)
-
-    @xxx_property.deleter
-    def xxx_property(self) -> None:
-        del self._xxx_property
-```
-
-这样一个新的属性 `xxx_property` 就将被增加到 `SegDataSample` 里面了。
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/training_tricks.md b/mmsegmentation/docs/zh_cn/advanced_guides/training_tricks.md
deleted file mode 100644
index e5b8e4d..0000000
--- a/mmsegmentation/docs/zh_cn/advanced_guides/training_tricks.md
+++ /dev/null
@@ -1,74 +0,0 @@
-# 训练技巧
-
-MMSegmentation 支持如下训练技巧：
-
-## 主干网络和解码头组件使用不同的学习率 (Learning Rate, LR)
-
-在语义分割里，一些方法会让解码头组件的学习率大于主干网络的学习率，这样可以获得更好的表现或更快的收敛。
-
-在 MMSegmentation 里面，您也可以在配置文件里添加如下行来让解码头组件的学习率是主干组件的10倍。
-
-```python
-optim_wrapper=dict(
-    paramwise_cfg = dict(
-        custom_keys={
-            'head': dict(lr_mult=10.)}))
-```
-
-通过这种修改，任何被分组到 `'head'` 的参数的学习率都将乘以10。您也可以参照 [MMEngine 文档](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/optim_wrapper.html#id6)  获取更详细的信息。
-
-## 在线难样本挖掘 (Online Hard Example Mining, OHEM)
-
-MMSegmentation 中实现了像素采样器，训练时可以对特定像素进行采样，例如 OHEM(Online Hard Example Mining)，可以解决样本不平衡问题，
-如下例子是使用 PSPNet 训练并采用 OHEM 策略的配置：
-
-```python
-_base_ = './pspnet_r50-d8_512x1024_40k_cityscapes.py'
-model=dict(
-    decode_head=dict(
-        sampler=dict(type='OHEMPixelSampler', thresh=0.7, min_kept=100000)) )
-```
-
-通过这种方式，只有置信分数在0.7以下的像素值点会被拿来训练。在训练时我们至少要保留100000个像素值点。如果 `thresh` 并未被指定，前 `min_kept`
-个损失的像素值点才会被选择。
-
-## 类别平衡损失 (Class Balanced Loss)
-
-对于不平衡类别分布的数据集，您也许可以改变每个类别的损失权重。这里以 cityscapes 数据集为例：
-
-```python
-_base_ = './pspnet_r50-d8_512x1024_40k_cityscapes.py'
-model=dict(
-    decode_head=dict(
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0,
-            # DeepLab 对 cityscapes 使用这种权重
-            class_weight=[0.8373, 0.9180, 0.8660, 1.0345, 1.0166, 0.9969, 0.9754,
-                        1.0489, 0.8786, 1.0023, 0.9539, 0.9843, 1.1116, 0.9037,
-                        1.0865, 1.0955, 1.0865, 1.1529, 1.0507])))
-```
-
-`class_weight` 将被作为 `weight` 参数，传递给 `CrossEntropyLoss`。详细信息请参照 [PyTorch 文档](https://pytorch.org/docs/stable/nn.html?highlight=crossentropy#torch.nn.CrossEntropyLoss) 。
-
-## 同时使用多种损失函数 (Multiple Losses)
-
-对于训练时损失函数的计算，我们目前支持多个损失函数同时使用。 以 `unet` 使用 `DRIVE` 数据集训练为例，
-使用 `CrossEntropyLoss` 和 `DiceLoss` 的 `1:3` 的加权和作为损失函数。配置文件写为:
-
-```python
-_base_ = './fcn_unet_s5-d16_64x64_40k_drive.py'
-model = dict(
-    decode_head=dict(loss_decode=[
-        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
-        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
-    ]),
-    auxiliary_head=dict(loss_decode=[
-        dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
-        dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
-    ]),
-)
-```
-
-通过这种方式，确定训练过程中损失函数的权重 `loss_weight` 和在训练日志里的名字 `loss_name`。
-
-注意： `loss_name` 的名字必须带有 `loss_` 前缀，这样它才能被包括在计算图里。
diff --git a/mmsegmentation/docs/zh_cn/advanced_guides/transforms.md b/mmsegmentation/docs/zh_cn/advanced_guides/transforms.md
deleted file mode 100644
index e5f3beb..0000000
--- a/mmsegmentation/docs/zh_cn/advanced_guides/transforms.md
+++ /dev/null
@@ -1,119 +0,0 @@
-# 数据增强变化
-
-在本教程中，我们将介绍 MMSegmentation 中数据增强变化流程的设计。
-
-本指南的结构如下：
-
-- [数据增强变化](#数据增强变化)
-  - [数据增强变化流程设计](#数据增强变化流程设计)
-    - [数据加载](#数据加载)
-    - [预处理](#预处理)
-    - [格式修改](#格式修改)
-
-## 数据增强变化流程设计
-
-按照惯例，我们使用 `Dataset` 和 `DataLoader` 多进程地加载数据。`Dataset` 返回与模型 forward 方法的参数相对应的数据项的字典。由于语义分割中的数据可能大小不同，我们在 MMCV 中引入了一种新的 `DataContainer` 类型，以帮助收集和分发不同大小的数据。参见[此处](https://github.com/open-mmlab/mmcv/blob/master/mmcv/parallel/data_container.py)了解更多详情。
-
-在 MMSegmentation 的 1.x 版本中，所有数据转换都继承自 [`BaseTransform`](https://github.com/open-mmlab/mmcv/blob/2.x/mmcv/transforms/base.py#L6).
-
-转换的输入和输出类型都是字典。一个简单的示例如下：
-
-```python
->>> from mmseg.datasets.transforms import LoadAnnotations
->>> transforms = LoadAnnotations()
->>> img_path = './data/cityscapes/leftImg8bit/train/aachen/aachen_000000_000019_leftImg8bit.png.png'
->>> gt_path = './data/cityscapes/gtFine/train/aachen/aachen_000015_000019_gtFine_instanceTrainIds.png'
->>> results = dict(
->>>     img_path=img_path,
->>>     seg_map_path=gt_path,
->>>     reduce_zero_label=False,
->>>     seg_fields=[])
->>> data_dict = transforms(results)
->>> print(data_dict.keys())
-dict_keys(['img_path', 'seg_map_path', 'reduce_zero_label', 'seg_fields', 'gt_seg_map'])
-```
-
-数据准备流程和数据集是解耦的。通常，数据集定义如何处理标注，数据流程定义准备数据字典的所有步骤。流程由一系列操作组成。每个操作都将字典作为输入，并为接下来的转换输出字典。
-
-操作分为数据加载、预处理、格式修改和测试数据增强。
-
-这里是 PSPNet 的流程示例：
-
-```python
-crop_size = (512, 1024)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(
-        type='RandomResize',
-        scale=(2048, 1024),
-        ratio_range=(0.5, 2.0),
-        keep_ratio=True),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to resize data transform
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-```
-
-对于每个操作，我们列出了 `添加`/`更新`/`删除` 相关的字典字段。在流程前，我们可以从数据集直接获得的信息是 `img_path` 和 `seg_map_path`。
-
-### 数据加载
-
-`LoadImageFromFile`：从文件加载图像。
-
-- 添加：`img`，`img_shape`，`ori_shape`
-
-`LoadAnnotations`：加载数据集提供的语义分割图。
-
-- 添加：`seg_fields`，`gt_seg_map`
-
-### 预处理
-
-`RandomResize`：随机调整图像和分割图大小。
-
--添加：`scale`，`scale_factor`，`keep_ratio`
--更新：`img`，`img_shape`，`gt_seg_map`
-
-`Resize`：调整图像和分割图的大小。
-
--添加：`scale`，`scale_factor`，`keep_ratio`
--更新：`img`，`gt_seg_map`，`img_shape`
-
-`RandomCrop`：随机裁剪图像和分割图。
-
--更新：`img`，`gt_seg_map`，`img_shape`
-
-`RandomFlip`：翻转图像和分割图。
-
--添加：`flip`，`flip_direction`
--更新：`img`，`gt_seg_map`
-
-`PhotoMetricDistortion`：按顺序对图像应用光度失真，每个变换的应用概率为 0.5。随机对比度的位置是第二或倒数第二（分别为下面的模式 0 或 1）。
-
-```
-1.随机亮度
-2.随机对比度（模式 0）
-3.将颜色从 BGR 转换为 HSV
-4.随机饱和度
-5.随机色调
-6.将颜色从 HSV 转换为 BGR
-7.随机对比度（模式 1）
-```
-
-- 更新：`img`
-
-### 格式修改
-
-`PackSegInputs`：为语义分段打包输入数据。
-
-- 添加：`inputs`，`data_sample`
-- 删除：由 `meta_keys` 指定的 keys（合并到 data_sample 的 metainfo 中），所有其他 keys
diff --git a/mmsegmentation/docs/zh_cn/api.rst b/mmsegmentation/docs/zh_cn/api.rst
deleted file mode 100644
index 3478aa9..0000000
--- a/mmsegmentation/docs/zh_cn/api.rst
+++ /dev/null
@@ -1,95 +0,0 @@
-mmseg.apis
---------------
-.. automodule:: mmseg.apis
-    :members:
-
-mmseg.datasets
---------------
-
-datasets
-^^^^^^^^^^
-.. automodule:: mmseg.datasets
-    :members:
-
-transforms
-^^^^^^^^^^^^
-.. automodule:: mmseg.datasets.transforms
-    :members:
-
-mmseg.engine
---------------
-
-hooks
-^^^^^^^^^^
-.. automodule:: mmseg.engine.hooks
-    :members:
-
-optimizers
-^^^^^^^^^^^^^^^
-.. automodule:: mmseg.engine.optimizers
-    :members:
-
-mmseg.evaluation
---------------
-
-metrics
-^^^^^^^^^^
-.. automodule:: mmseg.evaluation.metrics
-    :members:
-
-mmseg.models
---------------
-
-backbones
-^^^^^^^^^^^^^^^^^^
-.. automodule:: mmseg.models.backbones
-    :members:
-
-decode_heads
-^^^^^^^^^^^^^^^
-.. automodule:: mmseg.models.decode_heads
-    :members:
-
-segmentors
-^^^^^^^^^^
-.. automodule:: mmseg.models.segmentors
-    :members:
-
-losses
-^^^^^^^^^^
-.. automodule:: mmseg.models.losses
-    :members:
-
-necks
-^^^^^^^^^^^^
-.. automodule:: mmseg.models.necks
-    :members:
-
-utils
-^^^^^^^^^^
-.. automodule:: mmseg.models.utils
-    :members:
-
-
-mmseg.structures
---------------------
-
-structures
-^^^^^^^^^^^^^^^^^
-.. automodule:: mmseg.structures
-    :members:
-
-sampler
-^^^^^^^^^^
-.. automodule:: mmseg.structures.sampler
-    :members:
-
-mmseg.visualization
---------------------
-.. automodule:: mmseg.visualization
-    :members:
-
-mmseg.utils
---------------
-.. automodule:: mmseg.utils
-    :members:
diff --git a/mmsegmentation/docs/zh_cn/conf.py b/mmsegmentation/docs/zh_cn/conf.py
deleted file mode 100644
index 1842055..0000000
--- a/mmsegmentation/docs/zh_cn/conf.py
+++ /dev/null
@@ -1,133 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-# Configuration file for the Sphinx documentation builder.
-#
-# This file only contains a selection of the most common options. For a full
-# list see the documentation:
-# https://www.sphinx-doc.org/en/master/usage/configuration.html
-
-# -- Path setup --------------------------------------------------------------
-
-# If extensions (or modules to document with autodoc) are in another directory,
-# add these directories to sys.path here. If the directory is relative to the
-# documentation root, use os.path.abspath to make it absolute, like shown here.
-#
-import os
-import subprocess
-import sys
-
-import pytorch_sphinx_theme
-
-sys.path.insert(0, os.path.abspath('../../'))
-
-# -- Project information -----------------------------------------------------
-
-project = 'MMSegmentation'
-copyright = '2020-2021, OpenMMLab'
-author = 'MMSegmentation Authors'
-version_file = '../../mmseg/version.py'
-
-
-def get_version():
-    with open(version_file) as f:
-        exec(compile(f.read(), version_file, 'exec'))
-    return locals()['__version__']
-
-
-# The full version, including alpha/beta/rc tags
-release = get_version()
-
-# -- General configuration ---------------------------------------------------
-
-# Add any Sphinx extension module names here, as strings. They can be
-# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
-# ones.
-extensions = [
-    'sphinx.ext.autodoc', 'sphinx.ext.napoleon', 'sphinx.ext.viewcode',
-    'sphinx_markdown_tables', 'sphinx_copybutton', 'myst_parser'
-]
-
-autodoc_mock_imports = [
-    'matplotlib', 'pycocotools', 'mmseg.version', 'mmcv.ops'
-]
-
-# Ignore >>> when copying code
-copybutton_prompt_text = r'>>> |\.\.\. '
-copybutton_prompt_is_regexp = True
-
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
-
-# The suffix(es) of source filenames.
-# You can specify multiple suffix as a list of string:
-#
-source_suffix = {
-    '.rst': 'restructuredtext',
-    '.md': 'markdown',
-}
-
-# The master toctree document.
-master_doc = 'index'
-
-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-# This pattern also affects html_static_path and html_extra_path.
-exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
-
-# -- Options for HTML output -------------------------------------------------
-
-# The theme to use for HTML and HTML Help pages.  See the documentation for
-# a list of builtin themes.
-#
-# html_theme = 'sphinx_rtd_theme'
-html_theme = 'pytorch_sphinx_theme'
-html_theme_path = [pytorch_sphinx_theme.get_html_theme_path()]
-html_theme_options = {
-    'logo_url':
-    'https://mmsegmentation.readthedocs.io/zh-CN/latest/',
-    'menu': [
-        {
-            'name':
-            '教程',
-            'url':
-            'https://github.com/open-mmlab/mmsegmentation/blob/master/'
-            'demo/MMSegmentation_Tutorial.ipynb'
-        },
-        {
-            'name': 'GitHub',
-            'url': 'https://github.com/open-mmlab/mmsegmentation'
-        },
-        {
-            'name':
-            '上游库',
-            'children': [
-                {
-                    'name': 'MMCV',
-                    'url': 'https://github.com/open-mmlab/mmcv',
-                    'description': '基础视觉库'
-                },
-            ]
-        },
-    ],
-    # Specify the language of shared menu
-    'menu_lang':
-    'cn',
-}
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
-html_css_files = ['css/readthedocs.css']
-
-# Enable ::: for my_st
-myst_enable_extensions = ['colon_fence']
-
-language = 'zh-CN'
-
-
-def builder_inited_handler(app):
-    subprocess.run(['./stat.py'])
-
-
-def setup(app):
-    app.connect('builder-inited', builder_inited_handler)
diff --git a/mmsegmentation/docs/zh_cn/device/npu.md b/mmsegmentation/docs/zh_cn/device/npu.md
deleted file mode 100644
index d50439d..0000000
--- a/mmsegmentation/docs/zh_cn/device/npu.md
+++ /dev/null
@@ -1,39 +0,0 @@
-# NPU (华为 昇腾)
-
-## 使用方法
-
-请参考 [MMCV 的安装文档](https://mmcv.readthedocs.io/en/latest/get_started/build.html#build-mmcv-full-on-ascend-npu-machine) 来安装 NPU 版本的 MMCV。
-
-以下展示单机四卡场景的运行指令:
-
-```shell
-bash tools/dist_train.sh configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py 4
-```
-
-以下展示单机单卡下的运行指令:
-
-```shell
-python tools/train.py configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py
-```
-
-## 模型验证结果
-
-|        Model        | mIoU  | Config                                                                                                                                     | Download                                                                                                                                    |
-| :-----------------: | :---: | :----------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------ |
-|   [deeplabv3](<>)   | 78.85 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py)         | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024_20230115_205626.json)     |
-| [deeplabv3plus](<>) | 79.23 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024.py) | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024_20230116_043450.json) |
-|     [hrnet](<>)     | 78.1  | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/hrnet/fcn_hr18_4xb2-40k_cityscapes-512x1024.py)                     | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/fcn_hr18_4xb2-40k_cityscapes-512x1024_20230116_215821.json)             |
-|      [fcn](<>)      | 74.15 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py)                     | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/fcn_r50-d8_4xb2-40k_cityscapes-512x1024_20230111_083014.json)           |
-|     [icnet](<>)     | 69.25 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/icnet/icnet_r50-d8_4xb2-80k_cityscapes-832x832.py)                  | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/icnet_r50-d8_4xb2-80k_cityscapes-832x832_20230119_002929.json)          |
-|    [pspnet](<>)     | 77.21 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024.py)              | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024_20230114_042721.json)       |
-|     [unet](<>)      | 68.86 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/unet/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py)              | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024_20230129_224750.json)     |
-|    [upernet](<>)    | 77.81 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/upernet/upernet_r50_4xb2-40k_cityscapes-512x1024.py)                | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/upernet_r50_4xb2-40k_cityscapes-512x1024_20230129_014634.json)          |
-|    [apcnet](<>)     | 78.02 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py)               | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/apcnet_r50-d8_4xb2-40k_cityscapes-512x1024_20230209_212545.json)        |
-|   [bisenetv1](<>)   | 76.04 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024.py)      | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024_20230201_023946.json)  |
-|   [bisenetv2](<>)   | 72.44 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/bisenetv2/bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024.py)      | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024_20230205_215606.json)  |
-
-**注意:**
-
-- 如果没有特别标记，NPU 上的使用混合精度训练的结果与使用 FP32 的 GPU 上的结果相同。
-
-**以上模型结果由华为昇腾团队提供**
diff --git a/mmsegmentation/docs/zh_cn/get_started.md b/mmsegmentation/docs/zh_cn/get_started.md
deleted file mode 100644
index ca375f3..0000000
--- a/mmsegmentation/docs/zh_cn/get_started.md
+++ /dev/null
@@ -1,209 +0,0 @@
-# 开始：安装和运行 MMSeg
-
-## 预备知识
-
-本教程中，我们将会演示如何使用 PyTorch 准备环境。
-
-MMSegmentation 可以在 Linux, Windows 和 macOS 系统上运行，并且需要安装 Python 3.7+, CUDA 10.2+ 和 PyTorch 1.8+
-
-**注意:**
-如果您已经安装了 PyTorch, 可以跳过该部分，直接到[下一小节](##安装)。否则，您可以按照以下步骤操作。
-
-**步骤 0.** 从[官方网站](https://docs.conda.io/en/latest/miniconda.html)下载并安装 Miniconda
-
-**步骤 1.** 创建一个 conda 环境，并激活
-
-```shell
-conda create --name openmmlab python=3.8 -y
-conda activate openmmlab
-```
-
-**Step 2.** 参考 [official instructions](https://pytorch.org/get-started/locally/) 安装 PyTorch
-
-在 GPU 平台上：
-
-```shell
-conda install pytorch torchvision -c pytorch
-```
-
-在 CPU 平台上
-
-```shell
-conda install pytorch torchvision cpuonly -c pytorch
-```
-
-## 安装
-
-我们建议用户遵循我们的最佳实践来安装 MMSegmentation 。但是整个过程是高度自定义的。更多信息请参见[自定义安装](##自定义安装)部分。
-
-### 最佳实践
-
-**步骤 0.** 使用 [MIM](https://github.com/open-mmlab/mim) 安装 [MMCV](https://github.com/open-mmlab/mmcv)
-
-```shell
-pip install -U openmim
-mim install mmengine
-mim install "mmcv>=2.0.0"
-```
-
-**步骤 1.** 安装 MMSegmentation
-
-情况 a: 如果您想立刻开发和运行 mmsegmentation，您可通过源码安装：
-
-```shell
-git clone -b main https://github.com/open-mmlab/mmsegmentation.git
-cd mmsegmentation
-pip install -v -e .
-# '-v' 表示详细模式，更多的输出
-# '-e' 表示以可编辑模式安装工程，
-# 因此对代码所做的任何修改都生效，无需重新安装
-```
-
-情况 b: 如果您把 mmsegmentation 作为依赖库或者第三方库，可以通过 pip 安装：
-
-```shell
-pip install "mmsegmentation>=1.0.0"
-```
-
-### 验证是否安装成功
-
-为了验证 MMSegmentation 是否正确安装，我们提供了一些示例代码来运行一个推理 demo 。
-
-**步骤 1.** 下载配置文件和模型文件
-
-```shell
-mim download mmsegmentation --config pspnet_r50-d8_4xb2-40k_cityscapes-512x1024 --dest .
-```
-
-该下载过程可能需要花费几分钟，这取决于您的网络环境。当下载结束，您将看到以下两个文件在您当前工作目录：`pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py` 和 `pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth`
-
-**步骤 2.** 验证推理 demo
-
-选项 (a). 如果您通过源码安装了 mmsegmentation，运行以下命令即可：
-
-```shell
-python demo/image_demo.py demo/demo.png configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth --device cuda:0 --out-file result.jpg
-```
-
-您将在当前文件夹中看到一个新图像 `result.jpg`，其中所有目标都覆盖了分割 mask
-
-选项 (b). 如果您通过 pip 安装 mmsegmentation, 打开您的 python 解释器，复制粘贴以下代码：
-
-```python
-from mmseg.apis import inference_model, init_model, show_result_pyplot
-import mmcv
-
-config_file = 'pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-checkpoint_file = 'pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
-
-# 根据配置文件和模型文件建立模型
-model = init_model(config_file, checkpoint_file, device='cuda:0')
-
-# 在单张图像上测试并可视化
-img = 'demo/demo.png'  # or img = mmcv.imread(img), 这样仅需下载一次
-result = inference_model(model, img)
-# 在新的窗口可视化结果
-show_result_pyplot(model, img, result, show=True)
-# 或者将可视化结果保存到图像文件夹中
-# 您可以修改分割 map 的透明度 (0, 1].
-show_result_pyplot(model, img, result, show=True, out_file='result.jpg', opacity=0.5)
-# 在一段视频上测试并可视化分割结果
-video = mmcv.VideoReader('video.mp4')
-for frame in video:
-   result = inference_model(model, frame)
-   show_result_pyplot(model, frame, result, wait_time=1)
-```
-
-您可以修改上面的代码来测试单个图像或视频，这两个选项都可以验证安装是否成功。
-
-### 自定义安装
-
-#### CUDA 版本
-
-当安装 PyTorch 的时候，您需要指定 CUDA 的版本， 如果您不确定选择哪个版本，请遵循我们的建议：
-
-- 对于基于 Ampere 的 NVIDIA GPUs, 例如 GeForce 30 系列和 NVIDIA A100, 必须要求是 CUDA 11.
-- 对于更老的 NVIDIA GPUs, CUDA 11 is backward compatible, but CUDA 10.2 提供了更好的兼容性，以及更加的轻量化
-
-请确保 GPU 驱动满足最小的版本需求。详情请参考这个[表格](https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html#cuda-major-component-versions__table-cuda-toolkit-driver-versions)
-
-**注意:**
-如果您按照我们的最佳实践，安装 CUDA 运行库就足够了，因为不需要 CUDA 代码在本地编译。 但是如果您希望从源码编译 MMCV 或者需要开发其他的 CUDA 算子，您需要从 NVIDIA 的[官网](https://developer.nvidia.com/cuda-downloads)安装完整的 CUDA 工具，同时它的版本需要与 PyTorch 的 CUDA 版本匹配。即 `conda install` 命令中指定的 cudatoolkit 版本。
-
-#### 不使用 MIM 安装 MMCV
-
-MMCV 包含 C++ 和 CUDA 扩展，因此与 PyTorch 的依赖方式比较复杂。MIM 自动解决了这种依赖关系，使安装更容易。然而，MIM 也并不是必须的。
-
-为了使用 pip 而不是 MIM 安装 MMCV, 请参考 [MMCV 安装指南](https://mmcv.readthedocs.io/en/latest/get_started/installation.html). 这需要手动指定一个基于 PyTorch 版本及其 CUDA 版本的 find-url.
-
-例如，以下命令可为 PyTorch 1.10.x and CUDA 11.3 安装 mmcv==2.0.0
-
-```shell
-pip install mmcv==2.0.0 -f https://download.openmmlab.com/mmcv/dist/cu113/torch1.10/index.html
-```
-
-#### 在仅有 CPU 的平台安装
-
-MMSegmentation 可以在仅有 CPU 的版本上运行。在 CPU 模式，您可以训练（需要 MMCV 版本 >= 2.0.0），测试和推理模型。
-
-#### 在 Google Colab 上安装
-
-[Google Colab](https://research.google.com/) 通常已经安装了 PyTorch，因此我们仅需要通过以下命令安装 MMCV 和 MMSegmentation。
-
-**步骤 1.** 使用 [MIM](https://github.com/open-mmlab/mim) 安装 [MMCV](https://github.com/open-mmlab/mmcv)
-
-```shell
-!pip3 install openmim
-!mim install mmengine
-!mim install "mmcv>=2.0.0"
-```
-
-**Step 2.** 通过源码安装 MMSegmentation
-
-```shell
-!git clone https://github.com/open-mmlab/mmsegmentation.git
-%cd mmsegmentation
-!git checkout main
-!pip install -e .
-```
-
-**Step 3.** 验证
-
-```python
-import mmseg
-print(mmseg.__version__)
-# 示例输出: 1.0.0
-```
-
-**注意:**
-在 Jupyter 中, 感叹号 `!` 用于调用外部可执行命令，`%cd` 是一个 [magic command](https://ipython.readthedocs.io/en/stable/interactive/magics.html#magic-cd) 可以改变当前 python 的工作目录。
-
-### 通过 Docker 使用 MMSegmentation
-
-我们提供了一个 [Dockerfile](https://github.com/open-mmlab/mmsegmentation/blob/master/docker/Dockerfile) 来建立映像。确保您的 [docker 版本](https://docs.docker.com/engine/install/) >=19.03.
-
-```shell
-# 通过 PyTorch 1.11, CUDA 11.3 建立映像
-# 如果您使用其他版本，修改 Dockerfile 即可
-docker build -t mmsegmentation docker/
-```
-
-运行：
-
-```shell
-docker run --gpus all --shm-size=8g -it -v {DATA_DIR}:/mmsegmentation/data mmsegmentation
-```
-
-### 可选依赖
-
-#### 安装 GDAL
-
-[GDAL](https://gdal.org/) 是一个用于栅格和矢量地理空间数据格式的转换库。安装 GDAL 可以读取复杂格式和极大的遥感图像。
-
-```shell
-conda install GDAL
-```
-
-## 问题解答
-
-如果您在安装过程中遇到了其他问题，请第一时间查阅 [FAQ](notes/faq.md) 文件。如果没有找到答案，您也可以在 GitHub 上提出 [issue](https://github.com/open-mmlab/mmsegmentation/issues/new/choose)
diff --git a/mmsegmentation/docs/zh_cn/index.rst b/mmsegmentation/docs/zh_cn/index.rst
deleted file mode 100644
index ce5e499..0000000
--- a/mmsegmentation/docs/zh_cn/index.rst
+++ /dev/null
@@ -1,57 +0,0 @@
-欢迎来到 MMSegmentation 的文档!
-=======================================
-
-.. toctree::
-   :maxdepth: 2
-   :caption: 开始你的第一步
-
-   get_started.md
-
-.. toctree::
-   :maxdepth: 2
-   :caption: 用户指南
-
-   user_guides/index.rst
-
-.. toctree::
-   :maxdepth: 2
-   :caption: 进阶指南
-
-   advanced_guides/index.rst
-
-.. toctree::
-   :maxdepth: 1
-   :caption: 迁移指引
-
-   migration/index.rst
-
-.. toctree::
-   :caption: 接口文档（英文）
-
-   api.rst
-
-.. toctree::
-   :maxdepth: 1
-   :caption: 模型库
-
-   model_zoo.md
-   modelzoo_statistics.md
-
-.. toctree::
-   :maxdepth: 2
-   :caption: 说明
-
-   changelog.md
-   faq.md
-
-.. toctree::
-   :caption: 语言切换
-
-   switch_language.md
-
-
-Indices and tables
-==================
-
-* :ref:`genindex`
-* :ref:`search`
diff --git a/mmsegmentation/docs/zh_cn/make.bat b/mmsegmentation/docs/zh_cn/make.bat
deleted file mode 100644
index 922152e..0000000
--- a/mmsegmentation/docs/zh_cn/make.bat
+++ /dev/null
@@ -1,35 +0,0 @@
-@ECHO OFF
-
-pushd %~dp0
-
-REM Command file for Sphinx documentation
-
-if "%SPHINXBUILD%" == "" (
-	set SPHINXBUILD=sphinx-build
-)
-set SOURCEDIR=.
-set BUILDDIR=_build
-
-if "%1" == "" goto help
-
-%SPHINXBUILD% >NUL 2>NUL
-if errorlevel 9009 (
-	echo.
-	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
-	echo.installed, then set the SPHINXBUILD environment variable to point
-	echo.to the full path of the 'sphinx-build' executable. Alternatively you
-	echo.may add the Sphinx directory to PATH.
-	echo.
-	echo.If you don't have Sphinx installed, grab it from
-	echo.http://sphinx-doc.org/
-	exit /b 1
-)
-
-%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
-goto end
-
-:help
-%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
-
-:end
-popd
diff --git a/mmsegmentation/docs/zh_cn/migration/index.rst b/mmsegmentation/docs/zh_cn/migration/index.rst
deleted file mode 100644
index 854b9e6..0000000
--- a/mmsegmentation/docs/zh_cn/migration/index.rst
+++ /dev/null
@@ -1,8 +0,0 @@
-迁移
-***************
-
-.. toctree::
-    :maxdepth: 1
-
-    interface.md
-    package.md
diff --git a/mmsegmentation/docs/zh_cn/migration/interface.md b/mmsegmentation/docs/zh_cn/migration/interface.md
deleted file mode 100644
index 42f91bf..0000000
--- a/mmsegmentation/docs/zh_cn/migration/interface.md
+++ /dev/null
@@ -1,523 +0,0 @@
-# 从 MMSegmentation 0.x 迁移
-
-## 引言
-
-本指南介绍了 MMSegmentation 0.x 和 MMSegmentation1.x 在表现和 API 方面的基本区别，以及这些与迁移过程的关系。
-
-## 新的依赖
-
-MMSegmentation 1.x 依赖于一些新的软件包，您可以准备一个新的干净环境，然后根据[安装教程](../get_started.md)重新安装。
-
-或手动安装以下软件包。
-
-1. [MMEngine](https://github.com/open-mmlab/mmengine)：MMEngine 是 OpenMMLab 2.0 架构的核心，我们将许多与计算机视觉无关的内容从 MMCV 拆分到 MMEngine 中。
-
-2. [MMCV](https://github.com/open-mmlab/mmcv)：OpenMMLab 的计算机视觉包。这不是一个新的依赖，但您需要将其升级到 **2.0.0** 或以上的版本。
-
-3. [MMClassification](https://github.com/open-mmlab/mmclassification)（可选）：OpenMMLab 的图像分类工具箱和基准。这不是一个新的依赖，但您需要将其升级到 **1.0.0rc6** 版本。
-
-4. [MMDetection](https://github.com/open-mmlab/mmdetection)(可选): OpenMMLab 的目标检测工具箱和基准。这不是一个新的依赖，但您需要将其升级到 **3.0.0** 或以上的版本。
-
-## 启动训练
-
-OpenMMLab 2.0 的主要改进是发布了 MMEngine，它为启动训练任务的统一接口提供了通用且强大的执行器。
-
-与 MMSeg 0.x 相比，MMSeg 1.x 在 `tools/train.py` 中提供的命令行参数更少
-
-<table class="docutils">
-<tr>
-<td>功能</td>
-<td>原版</td>
-<td>新版</td>
-</tr>
-<tr>
-<td>加载预训练模型</td>
-<td>--load_from=$CHECKPOINT</td>
-<td>--cfg-options load_from=$CHECKPOINT</td>
-</tr>
-<tr>
-<td>从特定检查点恢复训练</td>
-<td>--resume-from=$CHECKPOINT</td>
-<td>--resume=$CHECKPOINT</td>
-</tr>
-<tr>
-<td>从最新的检查点恢复训练</td>
-<td>--auto-resume</td>
-<td>--resume='auto'</td>
-</tr>
-<tr>
-<td>训练期间是否不评估检查点</td>
-<td>--no-validate</td>
-<td>--cfg-options val_cfg=None val_dataloader=None val_evaluator=None</td>
-</tr>
-<tr>
-<td>指定训练设备</td>
-<td>--gpu-id=$DEVICE_ID</td>
-<td>-</td>
-</tr>
-<tr>
-<td>是否为不同进程设置不同的种子</td>
-<td>--diff-seed</td>
-<td>--cfg-options randomness.diff_rank_seed=True</td>
-</tr>
-<td>是否为 CUDNN 后端设置确定性选项</td>
-<td>--deterministic</td>
-<td>--cfg-options randomness.deterministic=True</td>
-</table>
-
-## 测试启动
-
-与训练启动类似，MMSegmentation 1.x 的测试启动脚本在 tools/test.py 中仅提供关键命令行参数，以下是测试启动脚本的区别，更多关于测试启动的细节请参考[这里](../user_guides/4_train_test.md)。
-
-<table class="docutils">
-<tr>
-<td>功能</td>
-<td>0.x</td>
-<td>1.x</td>
-</tr>
-<tr>
-<td>指定评测指标</td>
-<td>--eval mIoU</td>
-<td>--cfg-options test_evaluator.type=IoUMetric</td>
-</tr>
-<tr>
-<td>测试时数据增强</td>
-<td>--aug-test</td>
-<td>--tta</td>
-</tr>
-<tr>
-<td>测试时是否只保存预测结果不计算评测指标</td>
-<td>--format-only</td>
-<td>--cfg-options test_evaluator.format_only=True</td>
-</tr>
-</table>
-
-## 配置文件
-
-### 模型设置
-
-`model.backend`、`model.neck`、`model.decode_head` 和 `model.loss` 字段没有更改。
-
-添加 `model.data_preprocessor` 字段以配置 `DataPreProcessor`，包括：
-
-- `mean`（Sequence，可选）：R、G、B 通道的像素平均值。默认为 None。
-
-- `std`（Sequence，可选）：R、G、B 通道的像素标准差。默认为 None。
-
-- `size`（Sequence，可选）：固定的填充大小。
-
-- `size_divisor`（int，可选）：填充图像可以被当前值整除。
-
-- `seg_pad_val`（float，可选）：分割图的填充值。默认值：255。
-
-- `padding_mode`（str）：填充类型。默认值：'constant'。
-
-  - constant：常量值填充，值由 pad_val 指定。
-
-- `bgr_to_rgb`（bool）：是否将图像从 BGR 转换为 RGB。默认为 False。
-
-- `rgb_to_bgr`（bool）：是否将图像从 RGB 转换为 BGR。默认为 False。
-
-**注：**
-有关详细信息，请参阅[模型文档](../advanced_guides/models.md)。
-
-### 数据集设置
-
-**data** 的更改：
-
-原版 `data` 字段被拆分为 `train_dataloader`、`val_dataloader` 和 `test_dataloader`，允许我们以细粒度配置它们。例如，您可以在训练和测试期间指定不同的采样器和批次大小。
-`samples_per_gpu` 重命名为 `batch_size`。
-`workers_per_gpu` 重命名为 `num_workers`。
-
-<table class="docutils">
-<tr>
-<td>原版</td>
-<td>
-
-```python
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-    train=dict(...),
-    val=dict(...),
-    test=dict(...),
-)
-```
-
-</td>
-<tr>
-<td>新版</td>
-<td>
-
-```python
-train_dataloader = dict(
-    batch_size=4,
-    num_workers=4,
-    dataset=dict(...),
-    sampler=dict(type='DefaultSampler', shuffle=True)  # 必须
-)
-
-val_dataloader = dict(
-    batch_size=4,
-    num_workers=4,
-    dataset=dict(...),
-    sampler=dict(type='DefaultSampler', shuffle=False)  # 必须
-)
-
-test_dataloader = val_dataloader
-```
-
-</td>
-</tr>
-</table>
-
-**数据增强变换流程**变更
-
-- 原始格式转换 **`ToTensor`**、**`ImageToTensor`**、**`Collect`** 组合为 [`PackSegInputs`](mmseg.datasets.transforms.PackSegInputs)
-- 我们不建议在数据集流程中执行 **`Normalize`** 和 **Pad**。请将其从流程中删除，并将其设置在 `data_preprocessor` 字段中。
-- MMSeg 1.x 中原始的 **`Resize`** 已更改为 **`RandomResize `**，输入参数 `img_scale` 重命名为 `scale`，`keep_ratio` 的默认值修改为 False。
-- 原始的 `test_pipeline` 将单尺度和多尺度测试结合在一起，在 MMSeg 1.x 中，我们将其分为 `test_pipeline` 和 `tta_pipeline`。
-
-**注：**
-我们将一些数据转换工作转移到数据预处理器中，如归一化，请参阅[文档](package.md)了解更多详细信息。
-
-训练流程
-
-<table class="docutils">
-<tr>
-<td>原版</td>
-<td>
-
-```python
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='Resize', img_scale=(2560, 640), ratio_range=(0.5, 2.0)),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
-]
-```
-
-</td>
-<tr>
-<td>新版</td>
-<td>
-
-```python
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(
-        type='RandomResize',
-        scale=(2560, 640),
-        ratio_range=(0.5, 2.0),
-        keep_ratio=True),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-```
-
-</td>
-</tr>
-</table>
-
-测试流程
-
-<table class="docutils">
-<tr>
-<td>原版</td>
-<td>
-
-```python
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(2560, 640),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
-]
-```
-
-</td>
-<tr>
-<td>新版</td>
-<td>
-
-```python
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(2560, 640), keep_ratio=True),
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='PackSegInputs')
-]
-img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
-tta_pipeline = [
-    dict(type='LoadImageFromFile', backend_args=None),
-    dict(
-        type='TestTimeAug',
-        transforms=[
-            [
-                dict(type='Resize', scale_factor=r, keep_ratio=True)
-                for r in img_ratios
-            ],
-            [
-                dict(type='RandomFlip', prob=0., direction='horizontal'),
-                dict(type='RandomFlip', prob=1., direction='horizontal')
-            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
-        ])
-]
-```
-
-</td>
-</tr>
-</table>
-
-**`evaluation`** 中的更改：
-
-- **`evaluation`** 字段被拆分为 `val_evaluator` 和 `test_evaluator `。而且不再支持 `interval` 和 `save_best` 参数。
-  `interval` 已移动到 `train_cfg.val_interval`，`save_best` 已移动到 `default_hooks.checkpoint.save_best`。`pre_eval` 已删除。
-- `IoU` 已更改为 `IoUMetric`。
-
-<table class="docutils">
-<tr>
-<td>原版</td>
-<td>
-
-```python
-evaluation = dict(interval=2000, metric='mIoU', pre_eval=True)
-```
-
-</td>
-<tr>
-<td>新版</td>
-<td>
-
-```python
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
-test_evaluator = val_evaluator
-```
-
-</td>
-</tr>
-</table>
-
-### Optimizer 和 Schedule 设置
-
-**`optimizer`** 和 **`optimizer_config`** 中的更改：
-
-- 现在我们使用 `optim_wrapper` 字段来指定优化过程的所有配置。以及 `optimizer` 是 `optim_wrapper` 的一个子字段。
-- `paramwise_cfg` 也是 `optim_wrapper` 的一个子字段，以替代 `optimizer`。
-- `optimizer_config` 现在被删除，它的所有配置都被移动到 `optim_wrapper` 中。
-- `grad_clip` 重命名为 `clip_grad`。
-
-<table class="docutils">
-<tr>
-<td>原版</td>
-<td>
-
-```python
-optimizer = dict(type='AdamW', lr=0.0001, weight_decay=0.0005)
-optimizer_config = dict(grad_clip=dict(max_norm=1, norm_type=2))
-```
-
-</td>
-<tr>
-<td>新版</td>
-<td>
-
-```python
-optim_wrapper = dict(
-    type='OptimWrapper',
-    optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0005),
-    clip_grad=dict(max_norm=1, norm_type=2))
-```
-
-</td>
-</tr>
-</table>
-
-**`lr_config`** 中的更改：
-
-- 我们将 `lr_config` 字段删除，并使用新的 `param_scheduler` 替代。
-- 我们删除了与 `warmup` 相关的参数，因为我们使用 scheduler 组合来实现该功能。
-
-新的 scheduler 组合机制非常灵活，您可以使用它来设计多种学习率/动量曲线。有关详细信息，请参见[教程](TODO)。
-
-<table class="docutils">
-<tr>
-<td>原版</td>
-<td>
-
-```python
-lr_config = dict(
-    policy='poly',
-    warmup='linear',
-    warmup_iters=1500,
-    warmup_ratio=1e-6,
-    power=1.0,
-    min_lr=0.0,
-    by_epoch=False)
-```
-
-</td>
-<tr>
-<td>新版</td>
-<td>
-
-```python
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        power=1.0,
-        begin=1500,
-        end=160000,
-        eta_min=0.0,
-        by_epoch=False,
-    )
-]
-```
-
-</td>
-</tr>
-</table>
-
-**`runner`** 中的更改：
-
-原版 `runner` 字段中的大多数配置被移动到 `train_cfg`、`val_cfg` 和 `test_cfg` 中，以在训练、验证和测试中配置 loop。
-
-<table class="docutils">
-<tr>
-<td>原版</td>
-<td>
-
-```python
-runner = dict(type='IterBasedRunner', max_iters=20000)
-```
-
-</td>
-<tr>
-<td>新版</td>
-<td>
-
-```python
-# `val_interval` 是旧版本的 `evaluation.interval`。
-train_cfg = dict(type='IterBasedTrainLoop', max_iters=20000, val_interval=2000)
-val_cfg = dict(type='ValLoop') # 使用默认的验证循环。
-test_cfg = dict(type='TestLoop') # 使用默认的测试循环。
-```
-
-</td>
-</tr>
-</table>
-
-事实上，在 OpenMMLab 2.0 中，我们引入了 `Loop` 来控制训练、验证和测试中的行为。`Runner` 的功能也发生了变化。您可以在 [MMMEngine](https://github.com/open-mmlab/mmengine/) 的[执行器教程](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/design/runner.md) 中找到更多的详细信息。
-
-### 运行时设置
-
-**`checkpoint_config`** 和 **`log_config`** 中的更改：
-
-`checkpoint_config` 被移动到 `default_hooks.checkpoint` 中，`log_config` 被移动到 `default_hooks.logger` 中。
-并且我们将许多钩子设置从脚本代码移动到运行时配置的 `default_hooks` 字段中。
-
-```python
-default_hooks = dict(
-    # 记录每次迭代的时间。
-    timer=dict(type='IterTimerHook'),
-
-    # 每50次迭代打印一次日志。
-    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
-
-    # 启用参数调度程序。
-    param_scheduler=dict(type='ParamSchedulerHook'),
-
-    # 每2000次迭代保存一次检查点。
-    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=2000),
-
-    # 在分布式环境中设置采样器种子。
-    sampler_seed=dict(type='DistSamplerSeedHook'),
-
-    # 验证结果可视化。
-    visualization=dict(type='SegVisualizationHook'))
-```
-
-此外，我们将原版 logger 拆分为 logger 和 visualizer。logger 用于记录信息，visualizer 用于在不同的后端显示 logger，如 terminal 和 TensorBoard。
-
-<table class="docutils">
-<tr>
-<td>原版</td>
-<td>
-
-```python
-log_config = dict(
-    interval=100,
-    hooks=[
-        dict(type='TextLoggerHook'),
-        dict(type='TensorboardLoggerHook'),
-    ])
-```
-
-</td>
-<tr>
-<td>新版</td>
-<td>
-
-```python
-default_hooks = dict(
-    ...
-    logger=dict(type='LoggerHook', interval=100),
-)
-vis_backends = [dict(type='LocalVisBackend'),
-                dict(type='TensorboardVisBackend')]
-visualizer = dict(
-    type='SegLocalVisualizer', vis_backends=vis_backends, name='visualizer')
-```
-
-</td>
-</tr>
-</table>
-
-**`load_from`** 和 **`resume_from`** 中的更改：
-
-- 删除 `resume_from`。我们使用 `resume` 和 `load_from` 来替换它。
-  - 如果 `resume=True` 且 `load_from` 为 **not None**，则从 `load_from` 中的检查点恢复训练。
-  - 如果 `resume=True` 且 `load_from` 为 **None**，则尝试从工作目录中的最新检查点恢复。
-  - 如果 `resume=False` 且 `load_from` 为 **not None**，则只加载检查点，而不继续训练。
-  - 如果 `resume=False` 且 `load_from` 为 **None**，则不加载或恢复。
-
-**`dist_params`** 中的更改：`dist_params` 字段现在是 `env_cfg` 的子字段。并且 `env_cfg` 中还有一些新的配置。
-
-```python
-env_cfg = dict(
-    # 是否启用 cudnn_benchmark
-    cudnn_benchmark=False,
-
-    # 设置多进程参数
-    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
-
-    # 设置分布式参数
-    dist_cfg=dict(backend='nccl'),
-)
-```
-
-**`workflow`** 的改动:`workflow` 相关功能被删除。
-
-新字段 **`visualizer`**：visualizer 是 OpenMMLab 2.0 体系结构中的新设计。我们在 runner 中使用 visualizer 实例来处理结果和日志可视化，并保存到不同的后端。更多详细信息，请参阅[可视化教程](../user_guides/visualization.md)。
-
-新字段 **`default_scope`**：搜索所有注册模块的起点。MMSegmentation 中的 `default_scope` 为 `mmseg`。请参见[注册器教程](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/advanced_tutorials/registry.md)了解更多详情。
diff --git a/mmsegmentation/docs/zh_cn/migration/package.md b/mmsegmentation/docs/zh_cn/migration/package.md
deleted file mode 100644
index 19e5f18..0000000
--- a/mmsegmentation/docs/zh_cn/migration/package.md
+++ /dev/null
@@ -1,113 +0,0 @@
-# 包结构更改
-
-本节包含您对 MMSeg 0.x 和 1.x 之间的变化可能感到好奇的内容。
-
-<table>
-<tr>
-<td>MMSegmentation 0.x</td>
-<td>MMSegmentation 1.x</td>
-</tr>
-<tr>
-<td>mmseg.api</td>
-<td>mmseg.api</td>
-</tr>
-<tr>
-<td bgcolor=#fcf7f7>- mmseg.core</td>
-<td bgcolor=#ecf4eb>+ mmseg.engine</td>
-</tr>
-<tr>
-<td>mmseg.datasets</td>
-<td>mmseg.datasets</td>
-</tr>
-<tr>
-<td>mmseg.models</td>
-<td>mmseg.models</td>
-</tr>
-<tr>
-<td bgcolor=#fcf7f7>- mmseg.ops</td>
-<td bgcolor=#ecf4eb>+ mmseg.structure</td>
-</tr>
-<tr>
-<td>mmseg.utils</td>
-<td>mmseg.utils</td>
-</tr>
-<tr>
-<td></td>
-<td bgcolor=#ecf4eb>+ mmseg.evaluation</td>
-</tr>
-<tr>
-<td></td>
-<td bgcolor=#ecf4eb>+ mmseg.registry</td>
-<tr>
-</table>
-
-## 已删除的包
-
-### `mmseg.core`
-
-在 OpenMMLab 2.0 中，`core` 包已被删除。`core` 的 `hooks` 和 `optimizers` 被移动到了 `mmseg.engine` 中，而 `core` 中的 `evaluation` 目前是 mmseg.evaluation。
-
-## `mmseg.ops`
-
-`ops` 包含 `encoding` 和 `wrappers`，它们被移到了 `mmseg.models.utils` 中。
-
-## 增加的包
-
-### `mmseg.engine`
-
-OpenMMLab 2.0 增加了一个新的深度学习训练基础库 MMEngine。它是所有 OpenMMLab 代码库的训练引擎。
-mmseg 的 `engine` 包是一些用于语义分割任务的定制模块，如 `SegVisualizationHook` 用于可视化分割掩膜。
-
-### `mmseg.structure`
-
-在 OpenMMLab 2.0 中，我们为计算机视觉任务设计了数据结构，在 mmseg 中，我们在 `structure` 包中实现了 `SegDataSample`。
-
-### `mmseg.evaluation`
-
-我们将所有评估指标都移动到了 `mmseg.evaluation` 中。
-
-### `mmseg.registry`
-
-我们将 MMSegmentation 中所有类型模块的注册实现移动到 `mmseg.registry` 中。
-
-## 修改的包
-
-### `mmseg.apis`
-
-OpenMMLab 2.0 尝试支持计算机视觉的多任务统一接口，并发布了更强的 [`Runner`](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/design/runner.md)，因此 MMSeg 1.x 删除了 `train.py` 和 `test.py` 中的模块，并将 `init_segmentor` 重命名为 `init_model`，将 `inference_segmentor` 重命名为 `inference_model`。
-
-以下是 `mmseg.apis` 的更改：
-
-|         函数          | 变化                                           |
-| :-------------------: | :--------------------------------------------- |
-|   `init_segmentor`    | 重命名为 `init_model`                          |
-| `inference_segmentor` | 重命名为 `inference_model`                     |
-| `show_result_pyplot`  | 基于 `SegLocalVisualizer` 实现                 |
-|     `train_model`     | 删除，使用 `runner.train` 训练。               |
-|   `multi_gpu_test`    | 删除，使用 `runner.test` 测试。                |
-|   `single_gpu_test`   | 删除，使用 `runner.test` 测试。                |
-|   `set_random_seed`   | 删除，使用 `mmengine.runner.set_random_seed`。 |
-|  `init_random_seed`   | 删除，使用 `mmengine.dist.sync_random_seed`。  |
-
-### `mmseg.datasets`
-
-OpenMMLab 2.0 将 `BaseDataset` 定义为数据集的函数和接口，MMSegmentation 1.x 也遵循此协议，并定义了从 `BaseDataset` 继承的 `BaseSegDataset`。MMCV 2.x 收集多种任务的通用数据转换，例如分类、检测、分割，因此 MMSegmentation 1.x 使用这些数据转换并将其从 mmseg.dataset 中删除。
-
-|        包/模块        | 更改                                                                                 |
-| :-------------------: | :----------------------------------------------------------------------------------- |
-|   `mmseg.pipelines`   | 移动到 `mmcv.transforms` 中                                                          |
-|    `mmseg.sampler`    | 移动到 `mmengine.dataset.sampler` 中                                                 |
-|    `CustomDataset`    | 重命名为 `BaseSegDataset` 并从 MMEngine 中的 `BaseDataset` 继承                      |
-| `DefaultFormatBundle` | 替换为 `PackSegInputs`                                                               |
-|  `LoadImageFromFile`  | 移动到 `mmcv.transforms.LoadImageFromFile` 中                                        |
-|   `LoadAnnotations`   | 移动到 `mmcv.transforms.LoadAnnotations` 中                                          |
-|       `Resize`        | 移动到 `mmcv.transforms` 中并拆分为 `Resize`，`RandomResize` 和 `RandomChoiceResize` |
-|     `RandomFlip`      | 移动到 `mmcv.transforms.RandomFlip` 中                                               |
-|         `Pad`         | 移动到 `mmcv.transforms.Pad` 中                                                      |
-|      `Normalize`      | 移动到 `mmcv.transforms.Normalize` 中                                                |
-|       `Compose`       | 移动到 `mmcv.transforms.Compose` 中                                                  |
-|    `ImageToTensor`    | 移动到 `mmcv.transforms.ImageToTensor` 中                                            |
-
-### `mmseg.models`
-
-`models` 没有太大变化，只是从以前的 `mmseg.ops` 添加了 `encoding` 和 `wrappers`
diff --git a/mmsegmentation/docs/zh_cn/model_zoo.md b/mmsegmentation/docs/zh_cn/model_zoo.md
deleted file mode 100644
index bd57215..0000000
--- a/mmsegmentation/docs/zh_cn/model_zoo.md
+++ /dev/null
@@ -1,152 +0,0 @@
-# 标准与模型库
-
-## 共同设定
-
-- 我们默认使用 4 卡分布式训练
-- 所有 PyTorch 风格的 ImageNet 预训练网络由我们自己训练，和 [论文](https://arxiv.org/pdf/1812.01187.pdf) 保持一致。
-  我们的 ResNet 网络是基于 ResNetV1c 的变种，在这里输入层的 7x7 卷积被 3个 3x3 取代
-- 为了在不同的硬件上保持一致，我们以 `torch.cuda.max_memory_allocated()` 的最大值作为 GPU 占用率，同时设置 `torch.backends.cudnn.benchmark=False`。
-  注意，这通常比 `nvidia-smi` 显示的要少
-- 我们以网络 forward 和后处理的时间加和作为推理时间，除去数据加载时间。我们使用脚本 `tools/benchmark.py` 来获取推理时间，它在 `torch.backends.cudnn.benchmark=False` 的设定下，计算 200 张图片的平均推理时间
-- 在框架中，有两种推理模式
-  - `slide` 模式（滑动模式）：测试的配置文件字段 `test_cfg` 会是 `dict(mode='slide', crop_size=(769, 769), stride=(513, 513))`.
-    在这个模式下，从原图中裁剪多个小图分别输入网络中进行推理。小图的大小和小图之间的距离由 `crop_size` 和 `stride` 决定，重合区域会进行平均
-  - `whole` 模式 （全图模式）：测试的配置文件字段 `test_cfg` 会是 `dict(mode='whole')`. 在这个模式下，全图会被直接输入到网络中进行推理。
-    对于 769x769 下训练的模型，我们默认使用 `slide` 进行推理，其余模型用 `whole` 进行推理
-- 对于输入大小为 8x+1 （比如769），我们使用 `align_corners=True`。其余情况，对于输入大小为 8x (比如 512，1024)，我们使用 `align_corners=False`
-
-## 基线
-
-### FCN
-
-请参考 [FCN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/fcn) 获得详细信息。
-
-### PSPNet
-
-请参考 [PSPNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/pspnet) 获得详细信息。
-
-### DeepLabV3
-
-请参考 [DeepLabV3](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/deeplabv3) 获得详细信息。
-
-### PSANet
-
-请参考 [PSANet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/psanet) 获得详细信息。
-
-### DeepLabV3+
-
-请参考 [DeepLabV3+](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/deeplabv3plus) 获得详细信息。
-
-### UPerNet
-
-请参考 [UPerNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/upernet) 获得详细信息。
-
-### NonLocal Net
-
-请参考 [NonLocal Net](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/nlnet) 获得详细信息。
-
-### EncNet
-
-请参考 [EncNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/encnet) 获得详细信息。
-
-### CCNet
-
-请参考 [CCNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/ccnet) 获得详细信息。
-
-### DANet
-
-请参考 [DANet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/danet) 获得详细信息。
-
-### APCNet
-
-请参考 [APCNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/apcnet) 获得详细信息。
-
-### HRNet
-
-请参考 [HRNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/hrnet) 获得详细信息。
-
-### GCNet
-
-请参考 [GCNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/gcnet) 获得详细信息。
-
-### DMNet
-
-请参考 [DMNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/dmnet) 获得详细信息。
-
-### ANN
-
-请参考 [ANN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/ann) 获得详细信息。
-
-### OCRNet
-
-请参考 [OCRNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/ocrnet) 获得详细信息。
-
-### Fast-SCNN
-
-请参考 [Fast-SCNN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/fastscnn) 获得详细信息。
-
-### ResNeSt
-
-请参考 [ResNeSt](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/resnest) 获得详细信息。
-
-### Semantic FPN
-
-请参考 [Semantic FPN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/semfpn) 获得详细信息。
-
-### PointRend
-
-请参考 [PointRend](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/point_rend) 获得详细信息。
-
-### MobileNetV2
-
-请参考 [MobileNetV2](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/mobilenet_v2) 获得详细信息。
-
-### MobileNetV3
-
-请参考 [MobileNetV3](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/mobilenet_v3) 获得详细信息。
-
-### EMANet
-
-请参考 [EMANet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/emanet) 获得详细信息。
-
-### DNLNet
-
-请参考 [DNLNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/dnlnet) 获得详细信息。
-
-### CGNet
-
-请参考 [CGNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/cgnet) 获得详细信息。
-
-### Mixed Precision (FP16) Training
-
-请参考 [Mixed Precision (FP16) Training 在 BiSeNetV2 训练的样例](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/bisenetv2/bisenetv2_fcn_fp16_4x4_1024x1024_160k_cityscapes.py) 获得详细信息。
-
-## 速度标定（待更新）
-
-### 硬件
-
-- 8 NVIDIA Tesla V100 (32G) GPUs
-- Intel(R) Xeon(R) Gold 6148 CPU @ 2.40GHz
-
-### 软件环境
-
-- Python 3.7
-- PyTorch 1.5
-- CUDA 10.1
-- CUDNN 7.6.03
-- NCCL 2.4.08
-
-### 训练速度
-
-为了公平比较，我们全部使用 ResNet-101V1c 进行标定。输入大小为 1024x512，批量样本数为 2。
-
-训练速度如下表，指标为每次迭代的时间，以秒为单位，越低越快。
-
-| Implementation                                                              | PSPNet (s/iter) | DeepLabV3+ (s/iter) |
-| --------------------------------------------------------------------------- | --------------- | ------------------- |
-| [MMSegmentation](https://github.com/open-mmlab/mmsegmentation)              | **0.83**        | **0.85**            |
-| [SegmenTron](https://github.com/LikeLy-Journey/SegmenTron)                  | 0.84            | 0.85                |
-| [CASILVision](https://github.com/CSAILVision/semantic-segmentation-pytorch) | 1.15            | N/A                 |
-| [vedaseg](https://github.com/Media-Smart/vedaseg)                           | 0.95            | 1.25                |
-
-注意：DeepLabV3+ 的输出步长为 8。
diff --git a/mmsegmentation/docs/zh_cn/modelzoo_statistics.md b/mmsegmentation/docs/zh_cn/modelzoo_statistics.md
deleted file mode 100644
index b057575..0000000
--- a/mmsegmentation/docs/zh_cn/modelzoo_statistics.md
+++ /dev/null
@@ -1,102 +0,0 @@
-# 模型库统计数据
-
-- 论文数量: 47
-
-  - ALGORITHM: 36
-  - BACKBONE: 11
-
-- 模型数量: 612
-
-  - \[ALGORITHM\] [ANN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/ann) (16 ckpts)
-
-  - \[ALGORITHM\] [APCNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/apcnet) (12 ckpts)
-
-  - \[BACKBONE\] [BEiT](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/beit) (2 ckpts)
-
-  - \[ALGORITHM\] [BiSeNetV1](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/bisenetv1) (11 ckpts)
-
-  - \[ALGORITHM\] [BiSeNetV2](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/bisenetv2) (4 ckpts)
-
-  - \[ALGORITHM\] [CCNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/ccnet) (16 ckpts)
-
-  - \[ALGORITHM\] [CGNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/cgnet) (2 ckpts)
-
-  - \[BACKBONE\] [ConvNeXt](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/convnext) (6 ckpts)
-
-  - \[ALGORITHM\] [DANet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/danet) (16 ckpts)
-
-  - \[ALGORITHM\] [DeepLabV3](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/deeplabv3) (41 ckpts)
-
-  - \[ALGORITHM\] [DeepLabV3+](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/deeplabv3plus) (42 ckpts)
-
-  - \[ALGORITHM\] [DMNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/dmnet) (12 ckpts)
-
-  - \[ALGORITHM\] [DNLNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/dnlnet) (12 ckpts)
-
-  - \[ALGORITHM\] [DPT](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/dpt) (1 ckpts)
-
-  - \[ALGORITHM\] [EMANet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/emanet) (4 ckpts)
-
-  - \[ALGORITHM\] [EncNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/encnet) (12 ckpts)
-
-  - \[ALGORITHM\] [ERFNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/erfnet) (1 ckpts)
-
-  - \[ALGORITHM\] [FastFCN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/fastfcn) (12 ckpts)
-
-  - \[ALGORITHM\] [Fast-SCNN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/fastscnn) (1 ckpts)
-
-  - \[ALGORITHM\] [FCN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/fcn) (41 ckpts)
-
-  - \[ALGORITHM\] [GCNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/gcnet) (16 ckpts)
-
-  - \[BACKBONE\] [HRNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/hrnet) (37 ckpts)
-
-  - \[ALGORITHM\] [ICNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/icnet) (12 ckpts)
-
-  - \[ALGORITHM\] [ISANet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/isanet) (16 ckpts)
-
-  - \[ALGORITHM\] [K-Net](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/knet) (7 ckpts)
-
-  - \[BACKBONE\] [MAE](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/mae) (1 ckpts)
-
-  - \[ALGORITHM\] [Mask2Former](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/mask2former) (13 ckpts)
-
-  - \[ALGORITHM\] [MaskFormer](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/maskformer) (4 ckpts)
-
-  - \[BACKBONE\] [MobileNetV2](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/mobilenet_v2) (8 ckpts)
-
-  - \[BACKBONE\] [MobileNetV3](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/mobilenet_v3) (4 ckpts)
-
-  - \[ALGORITHM\] [NonLocal Net](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/nonlocal_net) (16 ckpts)
-
-  - \[ALGORITHM\] [OCRNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/ocrnet) (24 ckpts)
-
-  - \[ALGORITHM\] [PointRend](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/point_rend) (4 ckpts)
-
-  - \[BACKBONE\] [PoolFormer](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/poolformer) (5 ckpts)
-
-  - \[ALGORITHM\] [PSANet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/psanet) (16 ckpts)
-
-  - \[ALGORITHM\] [PSPNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/pspnet) (54 ckpts)
-
-  - \[BACKBONE\] [ResNeSt](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/resnest) (8 ckpts)
-
-  - \[ALGORITHM\] [SegFormer](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/segformer) (13 ckpts)
-
-  - \[ALGORITHM\] [Segmenter](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/segmenter) (5 ckpts)
-
-  - \[ALGORITHM\] [Semantic FPN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/sem_fpn) (4 ckpts)
-
-  - \[ALGORITHM\] [SETR](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/setr) (7 ckpts)
-
-  - \[ALGORITHM\] [STDC](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/stdc) (4 ckpts)
-
-  - \[BACKBONE\] [Swin Transformer](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/swin) (6 ckpts)
-
-  - \[BACKBONE\] [Twins](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/twins) (12 ckpts)
-
-  - \[ALGORITHM\] [UNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/unet) (25 ckpts)
-
-  - \[ALGORITHM\] [UPerNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/upernet) (16 ckpts)
-
-  - \[BACKBONE\] [Vision Transformer](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/vit) (11 ckpts)
diff --git a/mmsegmentation/docs/zh_cn/notes/faq.md b/mmsegmentation/docs/zh_cn/notes/faq.md
deleted file mode 100644
index aa99c25..0000000
--- a/mmsegmentation/docs/zh_cn/notes/faq.md
+++ /dev/null
@@ -1,125 +0,0 @@
-# 常见问题解答（FAQ）
-
-我们在这里列出了使用时的一些常见问题及其相应的解决方案。 如果您发现有一些问题被遗漏，请随时提 PR 丰富这个列表。 如果您无法在此获得帮助，请使用 [issue 模板](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/.github/ISSUE_TEMPLATE/error-report.md/)创建问题，但是请在模板中填写所有必填信息，这有助于我们更快定位问题。
-
-## 安装
-
-兼容的 MMSegmentation 和 MMCV 版本如下。请安装正确版本的 MMCV 以避免安装问题。
-
-| MMSegmentation version |          MMCV version          | MMEngine version  | MMClassification (optional) version | MMDetection (optional) version |
-| :--------------------: | :----------------------------: | :---------------: | :---------------------------------: | :----------------------------: |
-|     dev-1.x branch     |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
-|      main branch       |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
-|         1.2.2          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
-|         1.2.1          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
-|         1.2.0          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
-|         1.1.2          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
-|         1.1.1          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
-|         1.1.0          |         mmcv >= 2.0.0          | MMEngine >= 0.7.4 |        mmpretrain>=1.0.0rc7         |         mmdet >= 3.0.0         |
-|         1.0.0          |        mmcv >= 2.0.0rc4        | MMEngine >= 0.7.1 |           mmcls==1.0.0rc6           |         mmdet >= 3.0.0         |
-|        1.0.0rc6        |        mmcv >= 2.0.0rc4        | MMEngine >= 0.5.0 |           mmcls>=1.0.0rc0           |       mmdet >= 3.0.0rc6        |
-|        1.0.0rc5        |        mmcv >= 2.0.0rc4        | MMEngine >= 0.2.0 |           mmcls>=1.0.0rc0           |        mmdet>=3.0.0rc6         |
-|        1.0.0rc4        |        mmcv == 2.0.0rc3        | MMEngine >= 0.1.0 |           mmcls>=1.0.0rc0           |  mmdet>=3.0.0rc4, \<=3.0.0rc5  |
-|        1.0.0rc3        |        mmcv == 2.0.0rc3        | MMEngine >= 0.1.0 |           mmcls>=1.0.0rc0           |  mmdet>=3.0.0rc4, \<=3.0.0rc5  |
-|        1.0.0rc2        |        mmcv == 2.0.0rc3        | MMEngine >= 0.1.0 |           mmcls>=1.0.0rc0           |  mmdet>=3.0.0rc4, \<=3.0.0rc5  |
-|        1.0.0rc1        | mmcv >= 2.0.0rc1, \<=2.0.0rc3> | MMEngine >= 0.1.0 |           mmcls>=1.0.0rc0           |          Not required          |
-|        1.0.0rc0        | mmcv >= 2.0.0rc1, \<=2.0.0rc3> | MMEngine >= 0.1.0 |           mmcls>=1.0.0rc0           |          Not required          |
-
-如果您已经安装了版本不合适的 mmcv，请先运行`pip uninstall mmcv`卸载已安装的 mmcv，如您先前安装的为 mmcv-full（存在于 OpenMMLab 1.x），请运行`pip uninstall mmcv-full`进行卸载。
-
-- 如出现 "No module named 'mmcv'"
-  1. 使用`pip uninstall mmcv`卸载环境中现有的 mmcv
-  2. 按照[安装说明](../get_started.md)安装对应的 mmcv
-
-## 如何获知模型训练时需要的显卡数量
-
-- 看模型的 config 文件命名。可以参考[了解配置文件](../user_guides/1_config.md)中的`配置文件命名风格`部分。比如，对于名字为`segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py`的 config 文件，`8xb1`代表训练其对应的模型需要的卡数为 8，每张卡中的 batch size 为 1。
-- 看模型的 log 文件。点开该模型的 log 文件，并在其中搜索`nGPU`，在`nGPU`后的数字个数即训练时所需的卡数。比如，在 log 文件中搜索`nGPU`得到`nGPU 0,1,2,3,4,5,6,7`的记录，则说明训练该模型需要使用八张卡。
-
-## auxiliary head 是什么
-
-简单来说，这是一个提高准确率的深度监督技术。在训练阶段，`decode_head`用于输出语义分割的结果，`auxiliary_head` 只是增加了一个辅助损失，其产生的分割结果对你的模型结果没有影响，仅在在训练中起作用。您可以阅读这篇[论文](https://arxiv.org/pdf/1612.01105.pdf)了解更多信息。
-
-## 运行测试脚本时如何输出绘制分割掩膜的图像
-
-在测试脚本中，我们提供了`--out`参数来控制是否输出保存预测的分割掩膜图像。您可以运行以下命令输出测试结果：
-
-```shell
-python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} --out ${OUTPUT_DIR}
-```
-
-更多用例细节可查阅[文档](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/docs/zh_cn/user_guides/4_train_test.md#%E6%B5%8B%E8%AF%95%E5%B9%B6%E4%BF%9D%E5%AD%98%E5%88%86%E5%89%B2%E7%BB%93%E6%9E%9C)，[PR #2712](https://github.com/open-mmlab/mmsegmentation/pull/2712) 以及[迁移文档](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/docs/zh_cn/migration/interface.md#%E6%B5%8B%E8%AF%95%E5%90%AF%E5%8A%A8)了解相关说明。
-
-## 如何处理二值分割任务?
-
-MMSegmentation 使用 `num_classes` 和 `out_channels` 来控制模型最后一层 `self.conv_seg` 的输出。更多细节可以参考 [这里](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/mmseg/models/decode_heads/decode_head.py)。
-
-`num_classes` 应该和数据集本身类别个数一致，当是二值分割时，数据集只有前景和背景两类，所以 `num_classes` 为 2. `out_channels` 控制模型最后一层的输出的通道数，通常和 `num_classes` 相等，但当二值分割时候，可以有两种处理方法, 分别是：
-
-- 设置 `out_channels=2`，在训练时以 Cross Entropy Loss 作为损失函数，在推理时使用 `F.softmax()` 归一化 logits 值，然后通过 `argmax()` 得到每个像素的预测结果。
-
-- 设置 `out_channels=1`，在训练时以 Binary Cross Entropy Loss 作为损失函数，在推理时使用 `F.sigmoid()` 和 `threshold` 得到预测结果，`threshold` 默认为 0.3。
-
-对于实现上述两种计算二值分割的方法，需要在 `decode_head` 和 `auxiliary_head` 的配置里修改。下面是对样例 [pspnet_unet_s5-d16.py](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/configs/_base_/models/pspnet_unet_s5-d16.py) 做出的对应修改。
-
-- (1) `num_classes=2`, `out_channels=2` 并在 `CrossEntropyLoss` 里面设置 `use_sigmoid=False`。
-
-```python
-decode_head=dict(
-    type='PSPHead',
-    in_channels=64,
-    in_index=4,
-    num_classes=2,
-    out_channels=2,
-    loss_decode=dict(
-        type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-auxiliary_head=dict(
-    type='FCNHead',
-    in_channels=128,
-    in_index=3,
-    num_classes=2,
-    out_channels=2,
-    loss_decode=dict(
-        type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-```
-
-- (2) `num_classes=2`, `out_channels=1` 并在 `CrossEntropyLoss` 里面设置 `use_sigmoid=True`.
-
-```python
-decode_head=dict(
-    type='PSPHead',
-    in_channels=64,
-    in_index=4,
-    num_classes=2,
-    out_channels=1,
-    loss_decode=dict(
-        type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)),
-auxiliary_head=dict(
-    type='FCNHead',
-    in_channels=128,
-    in_index=3,
-    num_classes=2,
-    out_channels=1,
-    loss_decode=dict(
-        type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.4)),
-```
-
-## `reduce_zero_label` 的作用
-
-数据集中 `reduce_zero_label` 参数类型为布尔类型，默认为 False，它的功能是为了忽略数据集 label 0。具体做法是将 label 0 改为 255，其余 label 相应编号减 1，同时 decode head 里将 255 设为 ignore index，即不参与 loss 计算。
-以下是 `reduce_zero_label` 具体实现逻辑:
-
-```python
-if self.reduce_zero_label:
-    # avoid using underflow conversion
-    gt_semantic_seg[gt_semantic_seg == 0] = 255
-    gt_semantic_seg = gt_semantic_seg - 1
-    gt_semantic_seg[gt_semantic_seg == 254] = 255
-```
-
-关于您的数据集是否需要使用 reduce_zero_label，有以下两类情况：
-
-- 例如在 [Potsdam](https://github.com/open-mmlab/mmsegmentation/blob/1.x/docs/en/user_guides/2_dataset_prepare.md#isprs-potsdam) 数据集上，有 0-不透水面、1-建筑、2-低矮植被、3-树、4-汽车、5-杂乱，六类。但该数据集提供了两种 RGB 标签，一种为图像边缘处有黑色像素的标签，另一种是没有黑色边缘的标签。对于有黑色边缘的标签，在 [dataset_converters.py](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/tools/dataset_converters/potsdam.py)中，其将黑色边缘转换为 label 0，其余标签分别为 1-不透水面、2-建筑、3-低矮植被、4-树、5-汽车、6-杂乱，那么此时，就应该在数据集 [potsdam.py](https://github.com/open-mmlab/mmsegmentation/blob/ff95416c3b5ce8d62b9289f743531398efce534f/mmseg/datasets/potsdam.py#L23) 中将`reduce_zero_label=True`。如果使用的是没有黑色边缘的标签，那么 mask label 中只有 0-5，此时就应该使`reduce_zero_label=False`。需要结合您的实际情况来使用。
-- 例如在第 0 类为 background 类别的数据集上，如果您最终是需要将背景和您的其余类别分开时，是不需要使用`reduce_zero_label`的，此时在数据集中应该将其设置为`reduce_zero_label=False`
-
-**注意:** 使用 `reduce_zero_label` 请确认数据集原始类别个数，如果只有两类，需要关闭 `reduce_zero_label` 即设置 `reduce_zero_label=False`。
diff --git a/mmsegmentation/docs/zh_cn/overview.md b/mmsegmentation/docs/zh_cn/overview.md
deleted file mode 100644
index ed14795..0000000
--- a/mmsegmentation/docs/zh_cn/overview.md
+++ /dev/null
@@ -1,75 +0,0 @@
-# 概述
-
-本章节向您介绍 MMSegmentation 框架以及语义分割相关的基本概念。我们还提供了关于 MMSegmentation 的详细教程链接。
-
-## 什么是语义分割？
-
-语义分割是将图像中属于同一目标类别的部分聚类在一起的任务。它也是一种像素级预测任务，因为图像中的每一个像素都将根据类别进行分类。该任务的一些示例基准有 [Cityscapes](https://www.cityscapes-dataset.com/benchmarks/), [PASCAL VOC](http://host.robots.ox.ac.uk/pascal/VOC/voc2012/) 和 [ADE20K](https://groups.csail.mit.edu/vision/datasets/ADE20K/) 。通常用平均交并比 (Mean IoU) 和像素准确率 (Pixel Accuracy) 这两个指标来评估模型。
-
-## 什么是 MMSegmentation?
-
-MMSegmentation 是一个工具箱，它为语义分割任务的统一实现和模型评估提供了一个框架，并且高质量实现了常用的语义分割方法和数据集。
-
-MMSeg 主要包含了 apis, structures, datasets, models, engine, evaluation 和 visualization 这七个主要部分。
-
-- **apis** 提供了模型推理的高级api
-
-- **structures** 提供了分割任务的数据结构 `SegDataSample`
-
-- **datasets** 支持用于语义分割的多种数据集
-
-  - **transforms** 包含多种数据增强变换
-
-- **models** 是分割器最重要的部分，包含了分割器的不同组件
-
-  - **segmentors** 定义了所有分割模型类
-  - **data_preprocessors** 用于预处理模型的输入数据
-  - **backbones** 包含各种骨干网络，可将图像映射为特征图
-  - **necks** 包含各种模型颈部组件，用于连接分割头和骨干网络
-  - **decode_heads** 包含各种分割头，将特征图作为输入，并预测分割结果
-  - **losses** 包含各种损失函数
-
-- **engine** 是运行时组件的一部分，扩展了 [MMEngine](https://github.com/open-mmlab/mmengine) 的功能
-
-  - **optimizers** 提供了优化器和优化器封装
-  - **hooks** 提供了 runner 的各种钩子
-
-- **evaluation** 提供了评估模型性能的不同指标
-
-- **visualization** 分割结果的可视化工具
-
-## 如何使用本指南？
-
-以下是详细步骤，将带您一步步学习如何使用 MMSegmentation :
-
-1. 有关安装说明，请参阅 [开始你的第一步](get_started.md)。
-
-2. 对于初学者来说，MMSegmentation 是开始语义分割之旅的最好选择，因为这里实现了许多 SOTA 模型以及经典的模型 [model](model_zoo.md) 。另外，将各类组件和高级 API 結合使用，可以更便捷的执行分割任务。关于 MMSegmentation 的基本用法，请参考下面的教程：
-
-   - [配置](user_guides/1_config.md)
-   - [数据预处理](user_guides/2_dataset_prepare.md)
-   - [推理](user_guides/3_inference.md)
-   - [训练和测试](user_guides/4_train_test.md)
-
-3. 如果你想了解 MMSegmentation 工作的基本类和功能，请参考下面的教程来深入研究：
-
-   - [数据流](advanced_guides/data_flow.md)
-   - [结构](advanced_guides/structures.md)
-   - [模型](advanced_guides/models.md)
-   - [数据集](advanced_guides/datasets.md)
-   - [评估](advanced_guides/evaluation.md)
-
-4. MMSegmentation 也为用户自定义和一些前沿的研究提供了教程，请参考下面的教程来建立你自己的分割项目：
-
-   - [添加新的模型](advanced_guides/add_models.md)
-   - [添加新的数据集](advanced_guides/add_datasets.md)
-   - [添加新的 transform](advanced_guides/add_transforms.md)
-   - [自定义 runtime](advanced_guides/customize_runtime.md)
-
-5. 如果您更熟悉 MMSegmentation v0.x , 以下是 MMSegmentation v0.x 迁移到 v1.x 的文档
-
-   - [迁移](migration/index.rst)
-
-## 参考来源
-
-- https://paperswithcode.com/task/semantic-segmentation/codeless#task-home
diff --git a/mmsegmentation/docs/zh_cn/stat.py b/mmsegmentation/docs/zh_cn/stat.py
deleted file mode 100755
index 7a86302..0000000
--- a/mmsegmentation/docs/zh_cn/stat.py
+++ /dev/null
@@ -1,67 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) OpenMMLab. All rights reserved.
-import functools as func
-import glob
-import os.path as osp
-import re
-
-import numpy as np
-
-url_prefix = 'https://github.com/open-mmlab/mmsegmentation/blob/master/'
-
-files = sorted(glob.glob('../../configs/*/README.md'))
-
-stats = []
-titles = []
-num_ckpts = 0
-
-for f in files:
-    url = osp.dirname(f.replace('../../', url_prefix))
-
-    with open(f) as content_file:
-        content = content_file.read()
-
-    title = content.split('\n')[0].replace('#', '').strip()
-    ckpts = {
-        x.lower().strip()
-        for x in re.findall(r'https?://download.*\.pth', content)
-        if 'mmsegmentation' in x
-    }
-    if len(ckpts) == 0:
-        continue
-
-    _papertype = [
-        x for x in re.findall(r'<!--\s*\[([A-Z]*?)\]\s*-->', content)
-    ]
-    assert len(_papertype) > 0
-    papertype = _papertype[0]
-
-    paper = {(papertype, title)}
-
-    titles.append(title)
-    num_ckpts += len(ckpts)
-    statsmsg = f"""
-\t* [{papertype}] [{title}]({url}) ({len(ckpts)} ckpts)
-"""
-    stats.append((paper, ckpts, statsmsg))
-
-allpapers = func.reduce(lambda a, b: a.union(b), [p for p, _, _ in stats])
-msglist = '\n'.join(x for _, _, x in stats)
-
-papertypes, papercounts = np.unique([t for t, _ in allpapers],
-                                    return_counts=True)
-countstr = '\n'.join(
-    [f'   - {t}: {c}' for t, c in zip(papertypes, papercounts)])
-
-modelzoo = f"""
-# 模型库统计数据
-
-* 论文数量: {len(set(titles))}
-{countstr}
-
-* 模型数量: {num_ckpts}
-{msglist}
-"""
-
-with open('modelzoo_statistics.md', 'w') as f:
-    f.write(modelzoo)
diff --git a/mmsegmentation/docs/zh_cn/switch_language.md b/mmsegmentation/docs/zh_cn/switch_language.md
deleted file mode 100644
index f58efc4..0000000
--- a/mmsegmentation/docs/zh_cn/switch_language.md
+++ /dev/null
@@ -1,3 +0,0 @@
-## <a href='https://mmsegmentation.readthedocs.io/en/latest/'>English</a>
-
-## <a href='https://mmsegmentation.readthedocs.io/zh_CN/latest/'>简体中文</a>
diff --git a/mmsegmentation/docs/zh_cn/user_guides/1_config.md b/mmsegmentation/docs/zh_cn/user_guides/1_config.md
deleted file mode 100644
index dfcf0f9..0000000
--- a/mmsegmentation/docs/zh_cn/user_guides/1_config.md
+++ /dev/null
@@ -1,577 +0,0 @@
-# 教程1：了解配置文件
-
-我们将模块化和继承性设计融入到我们的配置文件系统中，方便进行各种实验。如果您想查看配置文件，你可以运行 `python tools/misc/print_config.py /PATH/TO/CONFIG` 来查看完整的配置文件。你也可以通过传递参数 `--cfg-options xxx.yyy=zzz` 来查看更新的配置信息。
-
-## 配置文件的结构
-
-在  `config/_base_ ` 文件夹下面有4种基本组件类型： 数据集(dataset)，模型(model)，训练策略(schedule)和运行时的默认设置(default runtime)。许多模型都可以很容易地通过组合这些组件进行实现，比如 DeepLabV3，PSPNet。使用 `_base_` 下的组件构建的配置信息叫做原始配置 (primitive)。
-
-对于同一个文件夹下的所有配置文件，建议**只有一个**对应的**原始配置文件**。所有其他的配置文件都应该继承自这个原始配置文件，从而保证每个配置文件的最大继承深度为 3。
-
-为了便于理解，我们建议社区贡献者从现有的方法继承。例如，如果您在 DeepLabV3 基础上进行了一些修改，用户可以先通过指定 `_base_ = ../deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py` 继承基本的 DeepLabV3 结构，然后在配置文件中修改必要的字段。
-
-如果你正在构建一个全新的方法，它不与现有的任何方法共享基本组件，您可以在`config`下创建一个新的文件夹`xxxnet` ，详细文档请参考[mmengine](https://mmengine.readthedocs.io/en/latest/tutorials/config.html)。
-
-## 配置文件命名风格
-
-我们遵循以下格式来命名配置文件，建议社区贡献者遵循相同的风格。
-
-```text
-{algorithm name}_{model component names [component1]_[component2]_[...]}_{training settings}_{training dataset information}_{testing dataset information}
-```
-
-配置文件的文件名分为五个部分，组成文件名每一个部分和组件之间都用`_`连接，每个部分或组件中的每个单词都要用`-`连接。
-
-- `{algorithm name}`: 算法的名称，如 `deeplabv3`,  `pspnet` 等。
-- `{model component names}`: 算法中使用的组件名称，如主干(backbone)、解码头(head)等。例如，`r50-d8 `表示使用ResNet50主干网络，并使用主干网络的8倍下采样输出作为下一级的输入。
-- `{training settings}`: 训练时的参数设置，如 `batch size`、数据增强(augmentation)、损失函数(loss)、学习率调度器(learning rate scheduler)和训练轮数(epochs/iterations)。例如: `4xb4-ce-linearlr-40K` 意味着使用4个gpu，每个gpu4个图像，使用交叉熵损失函数(CrossEntropy)，线性学习率调度程序，训练40K iterations。
-  一些缩写:
-  - `{gpu x batch_per_gpu}`: GPU数量和每个GPU的样本数。`bN ` 表示每个GPU的batch size为N，如 `8xb2` 为8个gpu x 每个gpu2张图像的缩写。如果未提及，则默认使用 `4xb4 `。
-  - `{schedule}`: 训练计划，选项有`20k`，`40k`等。`20k ` 和 `40k` 分别表示20000次迭代(iterations)和40000次迭代(iterations)。
-- `{training dataset information}`: 训练数据集名称，如 `cityscapes `， `ade20k ` 等，以及输入分辨率。例如: `cityscapes-768x768  `表示使用 `cityscapes` 数据集进行训练，输入分辨率为`768x768 `。
-- `{testing dataset information}` (可选): 测试数据集名称。当您的模型在一个数据集上训练但在另一个数据集上测试时，请将测试数据集名称添加到此处。如果没有这一部分，则意味着模型是在同一个数据集上进行训练和测试的。
-
-## PSPNet 的一个例子
-
-为了帮助用户熟悉对这个现代语义分割系统的完整配置文件和模块，我们对使用ResNet50V1c作为主干网络的PSPNet的配置文件作如下的简要注释和说明。要了解更详细的用法和每个模块对应的替换方法，请参阅API文档。
-
-```python
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-] # 我们可以在基本配置文件的基础上 构建新的配置文件
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
-```
-
-`_base_/models/pspnet_r50-d8.py`是使用ResNet50V1c作为主干网络的PSPNet的基本模型配置文件。
-
-```python
-# 模型设置
-norm_cfg = dict(type='SyncBN', requires_grad=True)  # 分割框架通常使用 SyncBN
-data_preprocessor = dict(  # 数据预处理的配置项，通常包括图像的归一化和增强
-    type='SegDataPreProcessor',  # 数据预处理的类型
-    mean=[123.675, 116.28, 103.53],  # 用于归一化输入图像的平均值
-    std=[58.395, 57.12, 57.375],  # 用于归一化输入图像的标准差
-    bgr_to_rgb=True,  # 是否将图像从 BGR 转为 RGB
-    pad_val=0,  # 图像的填充值
-    seg_pad_val=255)  # 'gt_seg_map'的填充值
-model = dict(
-    type='EncoderDecoder',  # 分割器(segmentor)的名字
-    data_preprocessor=data_preprocessor,
-    pretrained='open-mmlab://resnet50_v1c',  # 加载使用 ImageNet 预训练的主干网络
-    backbone=dict(
-        type='ResNetV1c',  # 主干网络的类别，更多细节请参考 mmseg/models/backbones/resnet.py
-        depth=50,  # 主干网络的深度，通常为 50 和 101
-        num_stages=4,  # 主干网络状态(stages)的数目
-        out_indices=(0, 1, 2, 3),  # 每个状态(stage)产生的特征图输出的索引
-        dilations=(1, 1, 2, 4),  # 每一层(layer)的空心率(dilation rate)
-        strides=(1, 2, 1, 1),  # 每一层(layer)的步长(stride)
-        norm_cfg=norm_cfg,  # 归一化层(norm layer)的配置项
-        norm_eval=False,  # 是否冻结 BN 里的统计项
-        style='pytorch',  # 主干网络的风格，'pytorch' 意思是步长为2的层为 3x3 卷积， 'caffe' 意思是步长为2的层为 1x1 卷积
-        contract_dilation=True),  # 当空洞率 > 1, 是否压缩第一个空洞层
-    decode_head=dict(
-        type='PSPHead',  # 解码头(decode head)的类别。可用选项请参 mmseg/models/decode_heads
-        in_channels=2048,  # 解码头的输入通道数
-        in_index=3,  # 被选择特征图(feature map)的索引
-        channels=512,  # 解码头中间态(intermediate)的通道数
-        pool_scales=(1, 2, 3, 6),  # PSPHead 平均池化(avg pooling)的规模(scales)。 细节请参考文章内容
-        dropout_ratio=0.1,  # 进入最后分类层(classification layer)之前的 dropout 比例
-        num_classes=19,  # 分割前景的种类数目。 通常情况下，cityscapes 为19，VOC为21，ADE20k 为150
-        norm_cfg=norm_cfg,  # 归一化层的配置项
-        align_corners=False,  # 解码过程中调整大小(resize)的 align_corners 参数
-        loss_decode=dict(  # 解码头(decode_head)里的损失函数的配置项
-            type='CrossEntropyLoss',  # 分割时使用的损失函数的类别
-            use_sigmoid=False,  # 分割时是否使用 sigmoid 激活
-            loss_weight=1.0)),  # 解码头的损失权重
-    auxiliary_head=dict(
-        type='FCNHead',  # 辅助头(auxiliary head)的种类。可用选项请参考 mmseg/models/decode_heads
-        in_channels=1024,  # 辅助头的输入通道数
-        in_index=2,  # 被选择的特征图(feature map)的索引
-        channels=256,  # 辅助头中间态(intermediate)的通道数
-        num_convs=1,  # FCNHead 里卷积(convs)的数目，辅助头中通常为1
-        concat_input=False,  # 在分类层(classification layer)之前是否连接(concat)输入和卷积的输出
-        dropout_ratio=0.1,  # 进入最后分类层(classification layer)之前的 dropout 比例
-        num_classes=19,  # 分割前景的种类数目。 通常情况下，cityscapes 为19，VOC为21，ADE20k 为150
-        norm_cfg=norm_cfg,  # 归一化层的配置项
-        align_corners=False,  # 解码过程中调整大小(resize)的 align_corners 参数
-        loss_decode=dict(  # 辅助头(auxiliary head)里的损失函数的配置项
-            type='CrossEntropyLoss',  # 分割时使用的损失函数的类别
-            use_sigmoid=False,  # 分割时是否使用 sigmoid 激活
-            loss_weight=0.4)),  # 辅助头损失的权重，默认设置为0.4
-    # 模型训练和测试设置项
-    train_cfg=dict(),  # train_cfg 当前仅是一个占位符
-    test_cfg=dict(mode='whole'))  # 测试模式，可选参数为 'whole' 和 'slide'. 'whole': 在整张图像上全卷积(fully-convolutional)测试。 'slide': 在输入图像上做滑窗预测
-```
-
-`_base_/datasets/cityscapes.py`是数据集的基本配置文件。
-
-```python
-# 数据集设置
-dataset_type = 'CityscapesDataset'  # 数据集类型，这将被用来定义数据集
-data_root = 'data/cityscapes/'  # 数据的根路径
-crop_size = (512, 1024)  # 训练时的裁剪大小
-train_pipeline = [  # 训练流程
-    dict(type='LoadImageFromFile'),  # 第1个流程，从文件路径里加载图像
-    dict(type='LoadAnnotations'),  # 第2个流程，对于当前图像，加载它的标注图像
-    dict(type='RandomResize',  # 调整输入图像大小(resize)和其标注图像的数据增广流程
-        scale=(2048, 1024),  # 图像裁剪的大小
-        ratio_range=(0.5, 2.0),  # 数据增广的比例范围
-        keep_ratio=True),  # 调整图像大小时是否保持纵横比
-    dict(type='RandomCrop',  # 随机裁剪当前图像和其标注图像的数据增广流程
-        crop_size=crop_size,  # 随机裁剪的大小
-        cat_max_ratio=0.75),  # 单个类别可以填充的最大区域的比
-    dict(type='RandomFlip',  # 翻转图像和其标注图像的数据增广流程
-        prob=0.5),  # 翻转图像的概率
-    dict(type='PhotoMetricDistortion'),  # 光学上使用一些方法扭曲当前图像和其标注图像的数据增广流程
-    dict(type='PackSegInputs')  # 打包用于语义分割的输入数据
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),  # 第1个流程，从文件路径里加载图像
-    dict(type='Resize',  # 使用调整图像大小(resize)增强
-        scale=(2048, 1024),  # 图像缩放的大小
-        keep_ratio=True),  # 在调整图像大小时是否保留长宽比
-    # 在' Resize '之后添加标注图像
-    # 不需要做调整图像大小(resize)的数据变换
-    dict(type='LoadAnnotations'),  # 加载数据集提供的语义分割标注
-    dict(type='PackSegInputs')  # 打包用于语义分割的输入数据
-]
-train_dataloader = dict(  # 训练数据加载器(dataloader)的配置
-    batch_size=2,  # 每一个GPU的batch size大小
-    num_workers=2,  # 为每一个GPU预读取数据的进程个数
-    persistent_workers=True,  # 在一个epoch结束后关闭worker进程，可以加快训练速度
-    sampler=dict(type='InfiniteSampler', shuffle=True),  # 训练时进行随机洗牌(shuffle)
-    dataset=dict(  # 训练数据集配置
-        type=dataset_type,  # 数据集类型，详见mmseg/datassets/
-        data_root=data_root,  # 数据集的根目录
-        data_prefix=dict(
-            img_path='leftImg8bit/train', seg_map_path='gtFine/train'),  # 训练数据的前缀
-        pipeline=train_pipeline)) # 数据处理流程，它通过之前创建的train_pipeline传递。
-val_dataloader = dict(
-    batch_size=1,  # 每一个GPU的batch size大小
-    num_workers=4,  # 为每一个GPU预读取数据的进程个数
-    persistent_workers=True,  # 在一个epoch结束后关闭worker进程，可以加快训练速度
-    sampler=dict(type='DefaultSampler', shuffle=False),  # 训练时不进行随机洗牌(shuffle)
-    dataset=dict(  # 测试数据集配置
-        type=dataset_type,  # 数据集类型，详见mmseg/datassets/
-        data_root=data_root,  # 数据集的根目录
-        data_prefix=dict(
-            img_path='leftImg8bit/val', seg_map_path='gtFine/val'),  # 测试数据的前缀
-        pipeline=test_pipeline))  # 数据处理流程，它通过之前创建的test_pipeline传递。
-test_dataloader = val_dataloader
-# 精度评估方法，我们在这里使用 IoUMetric 进行评估
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
-test_evaluator = val_evaluator
-```
-
-`_base_/schedules/schedule_40k.py`
-
-```python
-# optimizer
-optimizer = dict(type='SGD', # 优化器种类，更多细节可参考 https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py
-                lr=0.01,  # 优化器的学习率，参数的使用细节请参照对应的 PyTorch 文档
-                momentum=0.9,  # 动量大小 (Momentum)
-                weight_decay=0.0005)  # SGD 的权重衰减 (weight decay)
-optim_wrapper = dict(type='OptimWrapper',  # 优化器包装器(Optimizer wrapper)为更新参数提供了一个公共接口
-                    optimizer=optimizer,  # 用于更新模型参数的优化器(Optimizer)
-                    clip_grad=None)  # 如果 'clip_grad' 不是None，它将是 ' torch.nn.utils.clip_grad' 的参数。
-# 学习策略
-param_scheduler = [
-    dict(
-        type='PolyLR',  # 调度流程的策略，同样支持 Step, CosineAnnealing, Cyclic 等. 请从 https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/scheduler/lr_scheduler.py 参考 LrUpdater 的细节
-        eta_min=1e-4,  # 训练结束时的最小学习率
-        power=0.9,  # 多项式衰减 (polynomial decay) 的幂
-        begin=0,  # 开始更新参数的时间步(step)
-        end=40000,  # 停止更新参数的时间步(step)
-        by_epoch=False)  # 是否按照 epoch 计算训练时间
-]
-# 40k iteration 的训练计划
-train_cfg = dict(type='IterBasedTrainLoop', max_iters=40000, val_interval=4000)
-val_cfg = dict(type='ValLoop')
-test_cfg = dict(type='TestLoop')
-# 默认钩子(hook)配置
-default_hooks = dict(
-    timer=dict(type='IterTimerHook'),  # 记录迭代过程中花费的时间
-    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),  # 从'Runner'的不同组件收集和写入日志
-    param_scheduler=dict(type='ParamSchedulerHook'),  # 更新优化器中的一些超参数，例如学习率
-    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=4000),  # 定期保存检查点(checkpoint)
-    sampler_seed=dict(type='DistSamplerSeedHook'))  # 用于分布式训练的数据加载采样器
-```
-
-in `_base_/default_runtime.py`
-
-```python
-# 将注册表的默认范围设置为mmseg
-default_scope = 'mmseg'
-# environment
-env_cfg = dict(
-    cudnn_benchmark=True,
-    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
-    dist_cfg=dict(backend='nccl'),
-)
-log_level = 'INFO'
-log_processor = dict(by_epoch=False)
-load_from = None  # 从文件中加载检查点(checkpoint)
-resume = False  # 是否从已有的模型恢复
-```
-
-这些都是用于训练和测试PSPNet的配置文件，要加载和解析它们，我们可以使用[MMEngine](https://github.com/open-mmlab/mmengine)实现的[Config](https://mmengine.readthedocs.io/en/latest/tutorials/config.html)。
-
-```python
-from mmengine.config import Config
-
-cfg = Config.fromfile('configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py')
-print(cfg.train_dataloader)
-```
-
-```shell
-{'batch_size': 2,
- 'num_workers': 2,
- 'persistent_workers': True,
- 'sampler': {'type': 'InfiniteSampler', 'shuffle': True},
- 'dataset': {'type': 'CityscapesDataset',
-  'data_root': 'data/cityscapes/',
-  'data_prefix': {'img_path': 'leftImg8bit/train',
-   'seg_map_path': 'gtFine/train'},
-  'pipeline': [{'type': 'LoadImageFromFile'},
-   {'type': 'LoadAnnotations'},
-   {'type': 'RandomResize',
-    'scale': (2048, 1024),
-    'ratio_range': (0.5, 2.0),
-    'keep_ratio': True},
-   {'type': 'RandomCrop', 'crop_size': (512, 1024), 'cat_max_ratio': 0.75},
-   {'type': 'RandomFlip', 'prob': 0.5},
-   {'type': 'PhotoMetricDistortion'},
-   {'type': 'PackSegInputs'}]}}
-```
-
-`cfg `是`mmengine.config.Config `的一个实例。它的接口与dict对象相同，也允许将配置值作为属性访问。更多信息请参见[MMEngine](https://github.com/open-mmlab/mmengine)中的[config tutorial](https://mmengine.readthedocs.io/en/latest/tutorials/config.html)。
-
-## FAQ
-
-### 忽略基础配置文件里的一些字段
-
-有时，您可以设置`_delete_=True `来忽略基本配置文件中的某些字段。您可以参考[MMEngine](https://github.com/open-mmlab/mmengine)中的[config tutorial](https://mmengine.readthedocs.io/en/latest/tutorials/config.html)来获得一些简单的指导。
-
-例如，在MMSegmentation中，如果您想在下面的配置文件`pspnet.py `中修改PSPNet的主干网络:
-
-```python
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    type='EncoderDecoder',
-    pretrained='torchvision://resnet50',
-    backbone=dict(
-        type='ResNetV1c',
-        depth=50,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        dilations=(1, 1, 2, 4),
-        strides=(1, 2, 1, 1),
-        norm_cfg=norm_cfg,
-        norm_eval=False,
-        style='pytorch',
-        contract_dilation=True),
-    decode_head=dict(
-        type='PSPHead',
-        in_channels=2048,
-        in_index=3,
-        channels=512,
-        pool_scales=(1, 2, 3, 6),
-        dropout_ratio=0.1,
-        num_classes=19,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)))
-```
-
-用以下代码加载并解析配置文件`pspnet.py`:
-
-```python
-from mmengine.config import Config
-
-cfg = Config.fromfile('pspnet.py')
-print(cfg.model)
-```
-
-```shell
-{'type': 'EncoderDecoder',
- 'pretrained': 'torchvision://resnet50',
- 'backbone': {'type': 'ResNetV1c',
-  'depth': 50,
-  'num_stages': 4,
-  'out_indices': (0, 1, 2, 3),
-  'dilations': (1, 1, 2, 4),
-  'strides': (1, 2, 1, 1),
-  'norm_cfg': {'type': 'SyncBN', 'requires_grad': True},
-  'norm_eval': False,
-  'style': 'pytorch',
-  'contract_dilation': True},
- 'decode_head': {'type': 'PSPHead',
-  'in_channels': 2048,
-  'in_index': 3,
-  'channels': 512,
-  'pool_scales': (1, 2, 3, 6),
-  'dropout_ratio': 0.1,
-  'num_classes': 19,
-  'norm_cfg': {'type': 'SyncBN', 'requires_grad': True},
-  'align_corners': False,
-  'loss_decode': {'type': 'CrossEntropyLoss',
-   'use_sigmoid': False,
-   'loss_weight': 1.0}}}
-```
-
-`ResNet`和`HRNet`使用不同的关键字构建，编写一个新的配置文件`hrnet.py`，如下所示:
-
-```python
-_base_ = 'pspnet.py'
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w32',
-    backbone=dict(
-        _delete_=True,
-        type='HRNet',
-        norm_cfg=norm_cfg,
-        extra=dict(
-            stage1=dict(
-                num_modules=1,
-                num_branches=1,
-                block='BOTTLENECK',
-                num_blocks=(4, ),
-                num_channels=(64, )),
-            stage2=dict(
-                num_modules=1,
-                num_branches=2,
-                block='BASIC',
-                num_blocks=(4, 4),
-                num_channels=(32, 64)),
-            stage3=dict(
-                num_modules=4,
-                num_branches=3,
-                block='BASIC',
-                num_blocks=(4, 4, 4),
-                num_channels=(32, 64, 128)),
-            stage4=dict(
-                num_modules=3,
-                num_branches=4,
-                block='BASIC',
-                num_blocks=(4, 4, 4, 4),
-                num_channels=(32, 64, 128, 256)))))
-```
-
-用以下代码加载并解析配置文件`hrnet.py`:
-
-```python
-from mmengine.config import Config
-cfg = Config.fromfile('hrnet.py')
-print(cfg.model)
-```
-
-```shell
-{'type': 'EncoderDecoder',
- 'pretrained': 'open-mmlab://msra/hrnetv2_w32',
- 'backbone': {'type': 'HRNet',
-  'norm_cfg': {'type': 'SyncBN', 'requires_grad': True},
-  'extra': {'stage1': {'num_modules': 1,
-    'num_branches': 1,
-    'block': 'BOTTLENECK',
-    'num_blocks': (4,),
-    'num_channels': (64,)},
-   'stage2': {'num_modules': 1,
-    'num_branches': 2,
-    'block': 'BASIC',
-    'num_blocks': (4, 4),
-    'num_channels': (32, 64)},
-   'stage3': {'num_modules': 4,
-    'num_branches': 3,
-    'block': 'BASIC',
-    'num_blocks': (4, 4, 4),
-    'num_channels': (32, 64, 128)},
-   'stage4': {'num_modules': 3,
-    'num_branches': 4,
-    'block': 'BASIC',
-    'num_blocks': (4, 4, 4, 4),
-    'num_channels': (32, 64, 128, 256)}}},
- 'decode_head': {'type': 'PSPHead',
-  'in_channels': 2048,
-  'in_index': 3,
-  'channels': 512,
-  'pool_scales': (1, 2, 3, 6),
-  'dropout_ratio': 0.1,
-  'num_classes': 19,
-  'norm_cfg': {'type': 'SyncBN', 'requires_grad': True},
-  'align_corners': False,
-  'loss_decode': {'type': 'CrossEntropyLoss',
-   'use_sigmoid': False,
-   'loss_weight': 1.0}}}
-```
-
-`_delete_=True` 将用新的键去替换 `backbone` 字段内所有旧的键。
-
-### 使用配置文件里的中间变量
-
-配置文件中会使用一些中间变量，例如数据集(datasets)字段里的 `train_pipeline`/`test_pipeline`。 需要注意的是，在子配置文件里修改中间变量时，您需要再次传递这些变量给对应的字段。例如，我们想改变在训练或测试PSPNet时采用的多尺度策略 (multi scale strategy)，`train_pipeline`/`test_pipeline` 是我们需要修改的中间变量。
-
-```python
-_base_ = '../pspnet/pspnet_r50-d8_4xb4-40k_cityscpaes-512x1024.py'
-crop_size = (512, 1024)
-img_norm_cfg = dict(
-    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='RandomResize',
-         img_scale=(2048, 1024),
-         ratio_range=(1., 2.),
-         keep_ration=True),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', flip_ratio=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs'),
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize',
-        scale=(2048, 1024),
-        keep_ratio=True),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='leftImg8bit/train', seg_map_path='gtFine/train'),
-        pipeline=train_pipeline)
-test_dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='leftImg8bit/val', seg_map_path='gtFine/val'),
-        pipeline=test_pipeline)
-train_dataloader = dict(dataset=train_dataset)
-val_dataloader = dict(dataset=test_dataset)
-test_dataloader = val_dataloader
-```
-
-我们首先需要定义新的 `train_pipeline`/`test_pipeline` 然后传递到 `dataset` 里。
-
-类似的，如果我们想从 `SyncBN` 切换到 `BN` 或者 `MMSyncBN`，我们需要替换配置文件里的每一个 `norm_cfg`。
-
-```python
-_base_ = '../pspnet/pspnet_r50-d8_4xb4-40k_cityscpaes-512x1024.py'
-norm_cfg = dict(type='BN', requires_grad=True)
-model = dict(
-    backbone=dict(norm_cfg=norm_cfg),
-    decode_head=dict(norm_cfg=norm_cfg),
-    auxiliary_head=dict(norm_cfg=norm_cfg))
-```
-
-## 通过脚本参数修改配置文件
-
-在[training script](https://github.com/open-mmlab/mmsegmentation/blob/1.x/tools/train.py)和[testing script](https://github.com/open-mmlab/mmsegmentation/blob/1.x/tools/test.py)中，我们支持脚本参数 `--cfg-options`，它可以帮助用户覆盖所使用的配置中的一些设置，`xxx=yyy` 格式的键值对将合并到配置文件中。
-
-例如，这是一个简化的脚本 `demo_script.py `:
-
-```python
-import argparse
-
-from mmengine.config import Config, DictAction
-
-def parse_args():
-    parser = argparse.ArgumentParser(description='Script Example')
-    parser.add_argument('config', help='train config file path')
-    parser.add_argument(
-        '--cfg-options',
-        nargs='+',
-        action=DictAction,
-        help='override some settings in the used config, the key-value pair '
-        'in xxx=yyy format will be merged into config file. If the value to '
-        'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
-        'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
-        'Note that the quotation marks are necessary and that no white space '
-        'is allowed.')
-    args = parser.parse_args()
-    return args
-
-def main():
-    args = parse_args()
-
-    cfg = Config.fromfile(args.config)
-    if args.cfg_options is not None:
-        cfg.merge_from_dict(args.cfg_options)
-
-    print(cfg)
-
-if __name__ == '__main__':
-    main()
-```
-
-一个配置文件示例 `demo_config.py` 如下所示:
-
-```python
-backbone = dict(
-    type='ResNetV1c',
-    depth=50,
-    num_stages=4,
-    out_indices=(0, 1, 2, 3),
-    dilations=(1, 1, 2, 4),
-    strides=(1, 2, 1, 1),
-    norm_eval=False,
-    style='pytorch',
-    contract_dilation=True)
-```
-
-运行 `demo_script.py`:
-
-```shell
-python demo_script.py demo_config.py
-```
-
-```shell
-Config (path: demo_config.py): {'backbone': {'type': 'ResNetV1c', 'depth': 50, 'num_stages': 4, 'out_indices': (0, 1, 2, 3), 'dilations': (1, 1, 2, 4), 'strides': (1, 2, 1, 1), 'norm_eval': False, 'style': 'pytorch', 'contract_dilation': True}}
-```
-
-通过脚本参数修改配置:
-
-```shell
-python demo_script.py demo_config.py --cfg-options backbone.depth=101
-```
-
-```shell
-Config (path: demo_config.py): {'backbone': {'type': 'ResNetV1c', 'depth': 101, 'num_stages': 4, 'out_indices': (0, 1, 2, 3), 'dilations': (1, 1, 2, 4), 'strides': (1, 2, 1, 1), 'norm_eval': False, 'style': 'pytorch', 'contract_dilation': True}}
-```
-
-- 更新列表/元组的值。
-
-  如果要更新的值是一个 list 或 tuple。例如，需要在配置文件 `demo_config.py ` 的 `backbone ` 中设置 `stride =(1,2,1,1) `。
-  如果您想更改这个键，你可以用两种方式进行指定:
-
-  1. `--cfg-options backbone.strides="(1, 1, 1, 1)"`. 注意引号 " 是支持 list/tuple 数据类型所必需的。
-
-     ```shell
-     python demo_script.py demo_config.py --cfg-options backbone.strides="(1, 1, 1, 1)"
-     ```
-
-     ```shell
-     Config (path: demo_config.py): {'backbone': {'type': 'ResNetV1c', 'depth': 50, 'num_stages': 4, 'out_indices': (0, 1, 2, 3), 'dilations': (1, 1, 2, 4), 'strides': (1, 1, 1, 1), 'norm_eval': False, 'style': 'pytorch', 'contract_dilation': True}}
-     ```
-
-  2. `--cfg-options backbone.strides=1,1,1,1`. 注意，在指定的值中**不允许**有空格。
-
-     另外，如果原来的类型是tuple，通过这种方式修改后会自动转换为list。
-
-     ```shell
-     python demo_script.py demo_config.py --cfg-options backbone.strides=1,1,1,1
-     ```
-
-     ```shell
-     Config (path: demo_config.py): {'backbone': {'type': 'ResNetV1c', 'depth': 50, 'num_stages': 4, 'out_indices': (0, 1, 2, 3), 'dilations': (1, 1, 2, 4), 'strides': [1, 1, 1, 1], 'norm_eval': False, 'style': 'pytorch', 'contract_dilation': True}}
-     ```
-
-```{note}
-  这种修改方法仅支持修改string、int、float、boolean、None、list和tuple类型的配置项。
-  具体来说，对于list和tuple类型的配置项，它们内部的元素也必须是上述七种类型之一。
-```
diff --git a/mmsegmentation/docs/zh_cn/user_guides/2_dataset_prepare.md b/mmsegmentation/docs/zh_cn/user_guides/2_dataset_prepare.md
deleted file mode 100644
index e32303a..0000000
--- a/mmsegmentation/docs/zh_cn/user_guides/2_dataset_prepare.md
+++ /dev/null
@@ -1,802 +0,0 @@
-# 教程2：准备数据集
-
-我们建议将数据集根目录符号链接到 `$MMSEGMENTATION/data`。
-如果您的目录结构不同，您可能需要更改配置文件中相应的路径。
-对于中国境内的用户，我们也推荐通过开源数据平台 [OpenDataLab](https://opendatalab.com/) 来下载dsdl标准数据，以获得更好的下载和使用体验，这里有一个下载dsdl数据集并进行训练的案例[DSDLReadme](../../../configs/dsdl/README.md)，欢迎尝试。
-
-```none
-mmsegmentation
-├── mmseg
-├── tools
-├── configs
-├── data
-│   ├── cityscapes
-│   │   ├── leftImg8bit
-│   │   │   ├── train
-│   │   │   ├── val
-│   │   ├── gtFine
-│   │   │   ├── train
-│   │   │   ├── val
-│   ├── VOCdevkit
-│   │   ├── VOC2012
-│   │   │   ├── JPEGImages
-│   │   │   ├── SegmentationClass
-│   │   │   ├── ImageSets
-│   │   │   │   ├── Segmentation
-│   │   ├── VOC2010
-│   │   │   ├── JPEGImages
-│   │   │   ├── SegmentationClassContext
-│   │   │   ├── ImageSets
-│   │   │   │   ├── SegmentationContext
-│   │   │   │   │   ├── train.txt
-│   │   │   │   │   ├── val.txt
-│   │   │   ├── trainval_merged.json
-│   │   ├── VOCaug
-│   │   │   ├── dataset
-│   │   │   │   ├── cls
-│   ├── ade
-│   │   ├── ADEChallengeData2016
-│   │   │   ├── annotations
-│   │   │   │   ├── training
-│   │   │   │   ├── validation
-│   │   │   ├── images
-│   │   │   │   ├── training
-│   │   │   │   ├── validation
-│   ├── coco_stuff10k
-│   │   ├── images
-│   │   │   ├── train2014
-│   │   │   ├── test2014
-│   │   ├── annotations
-│   │   │   ├── train2014
-│   │   │   ├── test2014
-│   │   ├── imagesLists
-│   │   │   ├── train.txt
-│   │   │   ├── test.txt
-│   │   │   ├── all.txt
-│   ├── coco_stuff164k
-│   │   ├── images
-│   │   │   ├── train2017
-│   │   │   ├── val2017
-│   │   ├── annotations
-│   │   │   ├── train2017
-│   │   │   ├── val2017
-│   ├── CHASE_DB1
-│   │   ├── images
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   ├── annotations
-│   │   │   ├── training
-│   │   │   ├── validation
-│   ├── DRIVE
-│   │   ├── images
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   ├── annotations
-│   │   │   ├── training
-│   │   │   ├── validation
-│   ├── HRF
-│   │   ├── images
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   ├── annotations
-│   │   │   ├── training
-│   │   │   ├── validation
-│   ├── STARE
-│   │   ├── images
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   ├── annotations
-│   │   │   ├── training
-│   │   │   ├── validation
-|   ├── dark_zurich
-|   │   ├── gps
-|   │   │   ├── val
-|   │   │   └── val_ref
-|   │   ├── gt
-|   │   │   └── val
-|   │   ├── LICENSE.txt
-|   │   ├── lists_file_names
-|   │   │   ├── val_filenames.txt
-|   │   │   └── val_ref_filenames.txt
-|   │   ├── README.md
-|   │   └── rgb_anon
-|   │   |   ├── val
-|   │   |   └── val_ref
-|   ├── NighttimeDrivingTest
-|   |   ├── gtCoarse_daytime_trainvaltest
-|   |   │   └── test
-|   |   │       └── night
-|   |   └── leftImg8bit
-|   |   |   └── test
-|   |   |       └── night
-│   ├── loveDA
-│   │   ├── img_dir
-│   │   │   ├── train
-│   │   │   ├── val
-│   │   │   ├── test
-│   │   ├── ann_dir
-│   │   │   ├── train
-│   │   │   ├── val
-│   ├── potsdam
-│   │   ├── img_dir
-│   │   │   ├── train
-│   │   │   ├── val
-│   │   ├── ann_dir
-│   │   │   ├── train
-│   │   │   ├── val
-│   ├── vaihingen
-│   │   ├── img_dir
-│   │   │   ├── train
-│   │   │   ├── val
-│   │   ├── ann_dir
-│   │   │   ├── train
-│   │   │   ├── val
-│   ├── iSAID
-│   │   ├── img_dir
-│   │   │   ├── train
-│   │   │   ├── val
-│   │   │   ├── test
-│   │   ├── ann_dir
-│   │   │   ├── train
-│   │   │   ├── val
-│   ├── synapse
-│   │   ├── img_dir
-│   │   │   ├── train
-│   │   │   ├── val
-│   │   ├── ann_dir
-│   │   │   ├── train
-│   │   │   ├── val
-│   ├── REFUGE
-│   │   ├── images
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   │   ├── test
-│   │   ├── annotations
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   │   ├── test
-│   ├── mapillary
-│   │   ├── training
-│   │   │   ├── images
-│   │   │   ├── v1.2
-|   │   │   │   ├── instances
-|   │   │   │   ├── labels
-|   │   │   │   └── panoptic
-│   │   │   ├── v2.0
-|   │   │   │   ├── instances
-|   │   │   │   ├── labels
-|   │   │   │   ├── panoptic
-|   │   │   │   └── polygons
-│   │   ├── validation
-│   │   │   ├── images
-|   │   │   ├── v1.2
-|   │   │   │   ├── instances
-|   │   │   │   ├── labels
-|   │   │   │   └── panoptic
-│   │   │   ├── v2.0
-|   │   │   │   ├── instances
-|   │   │   │   ├── labels
-|   │   │   │   ├── panoptic
-|   │   │   │   └── polygons
-│   ├── bdd100k
-│   │   ├── images
-│   │   │   └── 10k
-|   │   │   │   ├── test
-|   │   │   │   ├── train
-|   │   │   │   └── val
-│   │   └── labels
-│   │   │   └── sem_seg
-|   │   │   │   ├── colormaps
-|   │   │   │   │   ├──train
-|   │   │   │   │   └──val
-|   │   │   │   ├── masks
-|   │   │   │   │   ├──train
-|   │   │   │   │   └──val
-|   │   │   │   ├── polygons
-|   │   │   │   │   ├──sem_seg_train.json
-|   │   │   │   │   └──sem_seg_val.json
-|   │   │   │   └── rles
-|   │   │   │   │   ├──sem_seg_train.json
-|   │   │   │   │   └──sem_seg_val.json
-│   ├── nyu
-│   │   ├── images
-│   │   │   ├── train
-│   │   │   ├── test
-│   │   ├── annotations
-│   │   │   ├── train
-│   │   │   ├── test
-│   ├── HSIDrive20
-│   │   ├── images
-│   │   │   ├── train
-│   │   │   ├── validation
-│   │   │   ├── test
-│   │   ├── annotations
-│   │   │   ├── train
-│   │   │   ├── validation
-│   │   │   ├── test
-```
-
-## 用 MIM 下载数据集
-
-通过使用 [OpenXLab](https://openxlab.org.cn/datasets)，您可以直接下载开源数据集。通过平台的搜索功能，您可以快速轻松地找到他们正在寻找的数据集。使用平台上的格式化数据集，您可以高效地跨数据集执行任务。
-
-如果您使用 MIM 下载，请确保版本大于 v0.3.8。您可以使用以下命令进行更新、安装、登录和数据集下载：
-
-```shell
-# upgrade your MIM
-pip install -U openmim
-
-# install OpenXLab CLI tools
-pip install -U openxlab
-# log in OpenXLab
-openxlab login
-
-# download ADE20K by MIM
-mim download mmsegmentation --dataset ade20k
-```
-
-## Cityscapes
-
-Cityscapes [官方网站](https://www.cityscapes-dataset.com/)可以下载 Cityscapes 数据集，按照官网要求注册并登陆后，数据可以在[这里](https://www.cityscapes-dataset.com/downloads/)找到。
-
-按照惯例，`**labelTrainIds.png` 用于 cityscapes 训练。
-我们提供了一个基于 [cityscapesscripts](https://github.com/mcordts/cityscapesScripts) 的[脚本](https://github.com/open-mmlab/mmsegmentation/blob/1.x/tools/dataset_converters/cityscapes.py)用于生成 `**labelTrainIds.png`。
-
-```shell
-# --nproc 表示 8 个转换进程，也可以省略。
-python tools/dataset_converters/cityscapes.py data/cityscapes --nproc 8
-```
-
-## Pascal VOC
-
-Pascal VOC 2012 可从[此处](http://host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCtrainval_11-May-2012.tar)下载。
-此外，Pascal VOC 数据集的最新工作通常利用额外的增强数据，可以在[这里](http://www.eecs.berkeley.edu/Research/Projects/CS/vision/grouping/semantic_contours/benchmark.tgz)找到。
-
-如果您想使用增强的 VOC 数据集，请运行以下命令将增强数据的标注转换为正确的格式。
-
-```shell
-# --nproc 表示 8 个转换进程，也可以省略。
-python tools/dataset_converters/voc_aug.py data/VOCdevkit data/VOCdevkit/VOCaug --nproc 8
-```
-
-请参考[拼接数据集文档](../advanced_guides/add_datasets.md#拼接数据集)及 [voc_aug 配置示例](../../../configs/_base_/datasets/pascal_voc12_aug.py)以详细了解如何将它们拼接并合并训练。
-
-## ADE20K
-
-ADE20K 的训练和验证集可以从这个[链接](http://data.csail.mit.edu/places/ADEchallenge/ADEChallengeData2016.zip)下载。
-如果需要下载测试数据集，可以在[官网](http://host.robots.ox.ac.uk/)注册后，下载[测试集](http://host.robots.ox.ac.uk:8080/eval/downloads/VOC2010test.tar)。
-
-## Pascal Context
-
-Pascal Context 的训练和验证集可以从[此处](http://host.robots.ox.ac.uk/pascal/VOC/voc2010/VOCtrainval_03-May-2010.tar)下载。注册后，您也可以从[此处](http://host.robots.ox.ac.uk:8080/eval/downloads/VOC2010test.tar)下载测试集。
-
-从原始数据集中抽出部分数据作为验证集，您可以从[此处](https://codalabuser.blob.core.windows.net/public/trainval_merged.json)下载 trainval_merged.json 文件。
-
-请先安装 [Detail](https://github.com/zhanghang1989/detail-api) 工具然后运行以下命令将标注转换为正确的格式。
-
-```shell
-python tools/dataset_converters/pascal_context.py data/VOCdevkit data/VOCdevkit/VOC2010/trainval_merged.json
-```
-
-## COCO Stuff 10k
-
-数据可以通过 wget 在[这里](http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/cocostuff-10k-v1.1.zip)下载。
-
-对于 COCO Stuff 10k 数据集，请运行以下命令下载并转换数据集。
-
-```shell
-# 下载
-mkdir coco_stuff10k && cd coco_stuff10k
-wget http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/cocostuff-10k-v1.1.zip
-
-# 解压
-unzip cocostuff-10k-v1.1.zip
-
-# --nproc 表示 8 个转换进程，也可以省略。
-python tools/dataset_converters/coco_stuff10k.py /path/to/coco_stuff10k --nproc 8
-```
-
-按照惯例，`/path/to/coco_stuff164k/annotations/*2014/*_labelTrainIds.png` 中的 mask 标注用于 COCO Stuff 10k 的训练和测试。
-
-## COCO Stuff 164k
-
-对于 COCO Stuff 164k 数据集，请运行以下命令下载并转换增强的数据集。
-
-```shell
-# 下载
-mkdir coco_stuff164k && cd coco_stuff164k
-wget http://images.cocodataset.org/zips/train2017.zip
-wget http://images.cocodataset.org/zips/val2017.zip
-wget http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/stuffthingmaps_trainval2017.zip
-
-# 解压
-unzip train2017.zip -d images/
-unzip val2017.zip -d images/
-unzip stuffthingmaps_trainval2017.zip -d annotations/
-
-# --nproc 表示 8 个转换进程，也可以省略。
-python tools/dataset_converters/coco_stuff164k.py /path/to/coco_stuff164k --nproc 8
-```
-
-按照惯例，`/path/to/coco_stuff164k/annotations/*2017/*_labelTrainIds.png` 中的 mask 标注用于 COCO Stuff 164k 的训练和测试。
-
-此数据集的详细信息可在[此处](https://github.com/nightrome/cocostuff#downloads)找到。
-
-## CHASE DB1
-
-CHASE DB1 的训练和验证集可以从[此处](https://staffnet.kingston.ac.uk/~ku15565/CHASE_DB1/assets/CHASEDB1.zip)下载。
-
-请运行以下命令，准备 CHASE DB1 数据集：
-
-```shell
-python tools/dataset_converters/chase_db1.py /path/to/CHASEDB1.zip
-```
-
-该脚本将自动调整数据集目录结构，使其满足 MMSegmentation 数据集加载要求。
-
-## DRIVE
-
-按照[官网](https://drive.grand-challenge.org/)要求，注册并登陆后，便可以下载 DRIVE 的训练和验证数据集。
-
-要将 DRIVE 数据集转换为 MMSegmentation 的格式，请运行以下命令：
-
-```shell
-python tools/dataset_converters/drive.py /path/to/training.zip /path/to/test.zip
-```
-
-该脚本将自动调整数据集目录结构，使其满足 MMSegmentation 数据集加载要求。
-
-## HRF
-
-请下载 [health.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/healthy.zip)、[glaucoma.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/glaucoma.zip)、[diabetic_retinopathy.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/diabetic_retinopathy.zip)、[healthy_manualsegm.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/healthy_manualsegm.zip)、[glaucoma_manualsegm.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/glaucoma_manualsegm.zip) 和 [diabetic_retinopathy_manualsegm.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/diabetic_retinopathy_manualsegm.zip)，无需解压，可以直接运行以下命令，准备 HRF 数据集：
-
-```shell
-python tools/dataset_converters/hrf.py /path/to/healthy.zip /path/to/healthy_manualsegm.zip /path/to/glaucoma.zip /path/to/glaucoma_manualsegm.zip /path/to/diabetic_retinopathy.zip /path/to/diabetic_retinopathy_manualsegm.zip
-```
-
-该脚本将自动调整数据集目录结构，使其满足 MMSegmentation 数据集加载要求。
-
-## STARE
-
-请下载 [stare images.tar](http://cecas.clemson.edu/~ahoover/stare/probing/stare-images.tar)、[labels-ah.tar](http://cecas.clemson.edu/~ahoover/stare/probing/labels-ah.tar) 和 [labels-vk.tar](http://cecas.clemson.edu/~ahoover/stare/probing/labels-vk.tar)，无需解压，可以直接运行以下命令，准备 STARE 数据集：
-
-```shell
-python tools/dataset_converters/stare.py /path/to/stare-images.tar /path/to/labels-ah.tar /path/to/labels-vk.tar
-```
-
-该脚本将自动调整数据集目录结构，使其满足 MMSegmentation 数据集加载要求。
-
-## Dark Zurich
-
-由于我们只支持在此数据集上的模型测试，因此您只需要下载并解压[验证数据集](https://data.vision.ee.ethz.ch/csakarid/shared/GCMA_UIoU/Dark_Zurich_val_anon.zip)。
-
-## Nighttime Driving
-
-由于我们只支持在此数据集上的模型测试，因此您只需要下载并解压[验证数据集](http://data.vision.ee.ethz.ch/daid/NighttimeDriving/NighttimeDrivingTest.zip)。
-
-## LoveDA
-
-数据可以从[此处](https://drive.google.com/drive/folders/1ibYV0qwn4yuuh068Rnc-w4tPi0U0c-ti?usp=sharing)下载 LaveDA 数据集。
-
-或者可以从 [zenodo](https://zenodo.org/record/5706578#.YZvN7SYRXdF) 下载。下载后，无需解压，直接运行以下命令：
-
-```shell
-# 下载 Train.zip
-wget https://zenodo.org/record/5706578/files/Train.zip
-# 下载 Val.zip
-wget https://zenodo.org/record/5706578/files/Val.zip
-# 下载 Test.zip
-wget https://zenodo.org/record/5706578/files/Test.zip
-```
-
-请对于 LoveDA 数据集，请运行以下命令调整数据集目录。
-
-```shell
-python tools/dataset_converters/loveda.py /path/to/loveDA
-```
-
-可将模型对 LoveDA 的测试集的预测结果上传至到数据集[测试服务器](https://codalab.lisn.upsaclay.fr/competitions/421)，查看评测结果。
-
-有关 LoveDA 的更多详细信息，可查看[此处](https://github.com/Junjue-Wang/LoveDA).
-
-## ISPRS Potsdam
-
-[Potsdam](https://www.isprs.org/education/benchmarks/UrbanSemLab/2d-sem-label-potsdam.aspx) 城市语义分割数据集用于 2D 语义分割竞赛 —— Potsdam。
-
-数据集可以在竞赛[主页](https://www.isprs.org/education/benchmarks/UrbanSemLab/default.aspx)上请求获得。
-这里也提供了[BaiduNetdisk](https://pan.baidu.com/s/1K-cLVZnd1X7d8c26FQ-nGg?pwd=mseg)，提取码：mseg、 [Google Drive](https://drive.google.com/drive/folders/1w3EJuyUGet6_qmLwGAWZ9vw5ogeG0zLz?usp=sharing)以及[OpenDataLab](https://opendatalab.com/ISPRS_Potsdam/download)。
-实验中需要下载 '2_Ortho_RGB.zip' 和 '5_Labels_all_noBoundary.zip'。
-
-对于 Potsdam 数据集，请运行以下命令调整数据集目录。
-
-```shell
-python tools/dataset_converters/potsdam.py /path/to/potsdam
-```
-
-在我们的默认设置中，将生成 3456 张图像用于训练和 2016 张图像用于验证。
-
-## ISPRS Vaihingen
-
-[Vaihingen](https://www.isprs.org/education/benchmarks/UrbanSemLab/2d-sem-label-vaihingen.aspx) 城市语义分割数据集用于 2D 语义分割竞赛 —— Vaihingen。
-
-数据集可以在竞赛[主页](https://www.isprs.org/education/benchmarks/UrbanSemLab/default.aspx)上请求获得。
-这里也提供了[BaiduNetdisk](https://pan.baidu.com/s/109D3WLrLafsuYtLeerLiiA?pwd=mseg)，提取码：mseg 、 [Google Drive](https://drive.google.com/drive/folders/1w3NhvLVA2myVZqOn2pbiDXngNC7NTP_t?usp=sharing)。
-实验中需要下载 'ISPRS_semantic_labeling_Vaihingen.zip' 和 'ISPRS_semantic_labeling_Vaihingen_ground_truth_eroded_COMPLETE.zip'。
-
-对于 Vaihingen 数据集，请运行以下命令调整数据集目录。
-
-```shell
-python tools/dataset_converters/vaihingen.py /path/to/vaihingen
-```
-
-在我们的默认设置（`clip_size`=512, `stride_size`=256）中，将生成 344 张图像用于训练和 398 张图像用于验证。
-
-## iSAID
-
-iSAID 数据集可从 [DOTA-v1.0](https://captain-whu.github.io/DOTA/dataset.html) 下载训练/验证/测试数据集的图像数据，
-
-并从 [iSAID](https://captain-whu.github.io/iSAID/dataset.html)下载训练/验证数据集的标注数据。
-
-该数据集是航空图像实例分割和语义分割任务的大规模数据集。
-
-下载 iSAID 数据集后，您可能需要按照以下结构进行数据集准备。
-
-```none
-├── data
-│   ├── iSAID
-│   │   ├── train
-│   │   │   ├── images
-│   │   │   │   ├── part1.zip
-│   │   │   │   ├── part2.zip
-│   │   │   │   ├── part3.zip
-│   │   │   ├── Semantic_masks
-│   │   │   │   ├── images.zip
-│   │   ├── val
-│   │   │   ├── images
-│   │   │   │   ├── part1.zip
-│   │   │   ├── Semantic_masks
-│   │   │   │   ├── images.zip
-│   │   ├── test
-│   │   │   ├── images
-│   │   │   │   ├── part1.zip
-│   │   │   │   ├── part2.zip
-```
-
-```shell
-python tools/dataset_converters/isaid.py /path/to/iSAID
-```
-
-在我们的默认设置（`patch_width`=896, `patch_height`=896, `overlap_area`=384）中，将生成 33978 张图像用于训练和 11644 张图像用于验证。
-
-## LIP(Look Into Person) dataset
-
-该数据集可以从[此页面](https://lip.sysuhcp.com/overview.php)下载。
-
-请运行以下命令来解压数据集。
-
-```shell
-unzip LIP.zip
-cd LIP
-unzip TrainVal_images.zip
-unzip TrainVal_parsing_annotations.zip
-cd TrainVal_parsing_annotations
-unzip TrainVal_parsing_annotations.zip
-mv train_segmentations ../
-mv val_segmentations ../
-cd ..
-```
-
-LIP 数据集的内容包括：
-
-```none
-├── data
-│   ├── LIP
-│   │   ├── train_images
-│   │   │   ├── 1000_1234574.jpg
-│   │   │   ├── ...
-│   │   ├── train_segmentations
-│   │   │   ├── 1000_1234574.png
-│   │   │   ├── ...
-│   │   ├── val_images
-│   │   │   ├── 100034_483681.jpg
-│   │   │   ├── ...
-│   │   ├── val_segmentations
-│   │   │   ├── 100034_483681.png
-│   │   │   ├── ...
-```
-
-## Synapse dataset
-
-此数据集可以从[此页面](https://www.synapse.org/#!Synapse:syn3193805/wiki/)下载。
-
-遵循 [TransUNet](https://arxiv.org/abs/2102.04306) 的数据准备设定，将原始训练集（30 次扫描）拆分为新的训练集（18 次扫描）和验证集（12 次扫描）。请运行以下命令来准备数据集。
-
-```shell
-unzip RawData.zip
-cd ./RawData/Training
-```
-
-然后创建 `train.txt` 和 `val.txt` 以拆分数据集。
-
-根据 TransUnet，以下是数据集的划分。
-
-train.txt
-
-```none
-img0005.nii.gz
-img0006.nii.gz
-img0007.nii.gz
-img0009.nii.gz
-img0010.nii.gz
-img0021.nii.gz
-img0023.nii.gz
-img0024.nii.gz
-img0026.nii.gz
-img0027.nii.gz
-img0028.nii.gz
-img0030.nii.gz
-img0031.nii.gz
-img0033.nii.gz
-img0034.nii.gz
-img0037.nii.gz
-img0039.nii.gz
-img0040.nii.gz
-```
-
-val.txt
-
-```none
-img0008.nii.gz
-img0022.nii.gz
-img0038.nii.gz
-img0036.nii.gz
-img0032.nii.gz
-img0002.nii.gz
-img0029.nii.gz
-img0003.nii.gz
-img0001.nii.gz
-img0004.nii.gz
-img0025.nii.gz
-img0035.nii.gz
-```
-
-synapse 数据集的内容包括：
-
-```none
-├── Training
-│   ├── img
-│   │   ├── img0001.nii.gz
-│   │   ├── img0002.nii.gz
-│   │   ├── ...
-│   ├── label
-│   │   ├── label0001.nii.gz
-│   │   ├── label0002.nii.gz
-│   │   ├── ...
-│   ├── train.txt
-│   ├── val.txt
-```
-
-然后，使用此命令转换 synapse 数据集。
-
-```shell
-python tools/dataset_converters/synapse.py --dataset-path /path/to/synapse
-```
-
-注意，MMSegmentation 的默认评估指标（例如 mean dice value）是在 2D 切片图像上计算的，这与 [TransUNet](https://arxiv.org/abs/2102.04306) 等一些论文中的 3D 扫描结果是不同的。
-
-## REFUGE
-
-在 [REFUGE Challenge](https://refuge.grand-challenge.org) 官网上注册并下载 [REFUGE 数据集](https://refuge.grand-challenge.org/REFUGE2Download)。
-
-然后，解压 `REFUGE2.zip`，原始数据集的内容包括：
-
-```none
-├── REFUGE2
-│   ├── REFUGE2
-│   │   ├── Annotation-Training400.zip
-│   │   ├── REFUGE-Test400.zip
-│   │   ├── REFUGE-Test-GT.zip
-│   │   ├── REFUGE-Training400.zip
-│   │   ├── REFUGE-Validation400.zip
-│   │   ├── REFUGE-Validation400-GT.zip
-│   ├── __MACOSX
-```
-
-请运行以下命令转换 REFUGE 数据集：
-
-```shell
-python tools/convert_datasets/refuge.py --raw_data_root=/path/to/refuge/REFUGE2/REFUGE2
-```
-
-脚本会将目录结构转换如下：
-
-```none
-│   ├── REFUGE
-│   │   ├── images
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   │   ├── test
-│   │   ├── annotations
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   │   ├── test
-```
-
-包含 400 张用于训练的图像、400 张用于验证的图像和 400 张用于测试的图像，这与 REFUGE 2018 数据集相同。
-
-## Mapillary Vistas Datasets
-
-- Mapillary Vistas [官方网站](https://www.mapillary.com/dataset/vistas) 可以下载 Mapillary Vistas 数据集，按照官网要求注册并登陆后，数据可以在[这里](https://www.mapillary.com/dataset/vistas)找到。
-
-- Mapillary Vistas 数据集使用 8-bit with color-palette 来存储标签。不需要进行转换操作。
-
-- 假设您已将数据集 zip 文件放在 `mmsegmentation/data/mapillary` 中
-
-- 请运行以下命令来解压数据集。
-
-  ```bash
-  cd data/mapillary
-  unzip An-ZjB1Zm61yAZG0ozTymz8I8NqI4x0MrYrh26dq7kPgfu8vf9ImrdaOAVOFYbJ2pNAgUnVGBmbue9lTgdBOb5BbKXIpFs0fpYWqACbrQDChAA2fdX0zS9PcHu7fY8c-FOvyBVxPNYNFQuM.zip
-  ```
-
-- 解压后，您将获得类似于此结构的 Mapillary Vistas 数据集。语义分割 mask 标签在 `labels` 文件夹中。
-
-  ```none
-  mmsegmentation
-  ├── mmseg
-  ├── tools
-  ├── configs
-  ├── data
-  │   ├── mapillary
-  │   │   ├── training
-  │   │   │   ├── images
-  │   │   │   ├── v1.2
-  |   │   │   │   ├── instances
-  |   │   │   │   ├── labels
-  |   │   │   │   └── panoptic
-  │   │   │   ├── v2.0
-  |   │   │   │   ├── instances
-  |   │   │   │   ├── labels
-  |   │   │   │   ├── panoptic
-  |   │   │   │   └── polygons
-  │   │   ├── validation
-  │   │   │   ├── images
-  |   │   │   ├── v1.2
-  |   │   │   │   ├── instances
-  |   │   │   │   ├── labels
-  |   │   │   │   └── panoptic
-  │   │   │   ├── v2.0
-  |   │   │   │   ├── instances
-  |   │   │   │   ├── labels
-  |   │   │   │   ├── panoptic
-  |   │   │   │   └── polygons
-  ```
-
-- 您可以在配置中使用 `MapillaryDataset_v1` 和 `Mapillary Dataset_v2` 设置数据集版本。
-  在此处 [V1.2](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/_base_/datasets/mapillary_v1.py) 和 [V2.0](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/_base_/datasets/mapillary_v2.py) 查看 Mapillary Vistas 数据集配置文件
-
-## LEVIR-CD
-
-[LEVIR-CD](https://justchenhao.github.io/LEVIR/) 大规模遥感建筑变化检测数据集。
-
-数据集可以在[主页](https://justchenhao.github.io/LEVIR/)上请求获得。
-
-数据集的补充版本可以在[主页](https://github.com/S2Looking/Dataset)上请求获得。
-
-请下载数据集的补充版本，然后解压 `LEVIR-CD+.zip`，数据集的内容包括：
-
-```none
-│   ├── LEVIR-CD+
-│   │   ├── train
-│   │   │   ├── A
-│   │   │   ├── B
-│   │   │   ├── label
-│   │   ├── test
-│   │   │   ├── A
-│   │   │   ├── B
-│   │   │   ├── label
-```
-
-对于 LEVIR-CD 数据集，请运行以下命令无重叠裁剪影像：
-
-```shell
-python tools/dataset_converters/levircd.py --dataset-path /path/to/LEVIR-CD+ --out_dir /path/to/LEVIR-CD
-```
-
-裁剪后的影像大小为256x256，与原论文保持一致。
-
-## BDD100K
-
-- 可以从[官方网站](https://bdd-data.berkeley.edu/) 下载 BDD100K数据集（语义分割任务主要是10K数据集），按照官网要求注册并登陆后，数据可以在[这里](https://bdd-data.berkeley.edu/portal.html#download)找到。
-
-- 图像数据对应的名称是是`10K Images`, 语义分割标注对应的名称是`Segmentation`
-
-- 下载后，可以使用以下代码进行解压
-
-  ```bash
-  unzip ~/bdd100k_images_10k.zip -d ~/mmsegmentation/data/
-  unzip ~/bdd100k_sem_seg_labels_trainval.zip -d ~/mmsegmentation/data/
-  ```
-
-就可以得到以下文件结构了：
-
-```none
-mmsegmentation
-├── mmseg
-├── tools
-├── configs
-├── data
-│   ├── bdd100k
-│   │   ├── images
-│   │   │   └── 10k
-|   │   │   │   ├── test
-|   │   │   │   ├── train
-|   │   │   │   └── val
-│   │   └── labels
-│   │   │   └── sem_seg
-|   │   │   │   ├── colormaps
-|   │   │   │   │   ├──train
-|   │   │   │   │   └──val
-|   │   │   │   ├── masks
-|   │   │   │   │   ├──train
-|   │   │   │   │   └──val
-|   │   │   │   ├── polygons
-|   │   │   │   │   ├──sem_seg_train.json
-|   │   │   │   │   └──sem_seg_val.json
-|   │   │   │   └── rles
-|   │   │   │   │   ├──sem_seg_train.json
-|   │   │   │   │   └──sem_seg_val.json
-```
-
-## NYU
-
-- 您可以从 [这个链接](https://drive.google.com/file/d/1wC-io-14RCIL4XTUrQLk6lBqU2AexLVp/view?usp=share_link) 下载 NYU 数据集
-
-- 下载完成后，您可以使用 [tools/dataset_converters/nyu.py](/tools/dataset_converters/nyu.py) 脚本来解压和组织数据到所需的格式
-
-  ```bash
-  python tools/dataset_converters/nyu.py nyu.zip
-  ```
-
-## HSI Drive 2.0
-
-- 您可以从以下位置下载 HSI Drive 2.0 数据集 [here](https://ipaccess.ehu.eus/HSI-Drive/#download) 刚刚向 gded@ehu.eus 发送主题为“下载 HSI-Drive”的电子邮件后 您将收到解压缩文件的密码.
-
-- 下载后，按照以下说明解压：
-
-  ```bash
-  7z x -p"password" ./HSI_Drive_v2_0_Phyton.zip
-
-  mv ./HSIDrive20 path_to_mmsegmentation/data
-  mv ./HSI_Drive_v2_0_release_notes_Python_version.md path_to_mmsegmentation/data
-  mv ./image_numbering.pdf path_to_mmsegmentation/data
-  ```
-
-- 解压后得到:
-
-```none
-mmsegmentation
-├── mmseg
-├── tools
-├── configs
-├── data
-│   ├── HSIDrive20
-│   │   ├── images
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   │   ├── test
-│   │   ├── annotations
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   │   ├── test
-│   │   ├── images_MF
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   │   ├── test
-│   │   ├── RGB
-│   │   ├── training_filenames.txt
-│   │   ├── validation_filenames.txt
-│   │   ├── test_filenames.txt
-│   ├── HSI_Drive_v2_0_release_notes_Python_version.md
-│   ├── image_numbering.pdf
-```
diff --git a/mmsegmentation/docs/zh_cn/user_guides/3_inference.md b/mmsegmentation/docs/zh_cn/user_guides/3_inference.md
deleted file mode 100644
index 0afcb4b..0000000
--- a/mmsegmentation/docs/zh_cn/user_guides/3_inference.md
+++ /dev/null
@@ -1,244 +0,0 @@
-# 教程3：使用预训练模型推理
-
-MMSegmentation 在 [Model Zoo](../Model_Zoo.md) 中为语义分割提供了预训练的模型，并支持多个标准数据集，包括 Cityscapes、ADE20K 等。
-本说明将展示如何使用现有模型对给定图像进行推理。
-关于如何在标准数据集上测试现有模型，请参阅本[指南](./4_train_test.md)
-
-MMSegmentation 为用户提供了数个接口，以便轻松使用预训练的模型进行推理。
-
-- [教程3：使用预训练模型推理](#教程3使用预训练模型推理)
-  - [推理器](#推理器)
-    - [基本使用](#基本使用)
-    - [初始化](#初始化)
-    - [可视化预测结果](#可视化预测结果)
-    - [模型列表](#模型列表)
-  - [推理 API](#推理-api)
-    - [mmseg.apis.init_model](#mmsegapisinit_model)
-    - [mmseg.apis.inference_model](#mmsegapisinference_model)
-    - [mmseg.apis.show_result_pyplot](#mmsegapisshow_result_pyplot)
-
-## 推理器
-
-在 MMSegmentation 中，我们提供了最**方便的**方式 `MMSegInferencer` 来使用模型。您只需 3 行代码就可以获得图像的分割掩膜。
-
-### 基本使用
-
-以下示例展示了如何使用 `MMSegInferencer` 对单个图像执行推理。
-
-```
->>> from mmseg.apis import MMSegInferencer
->>> # 将模型加载到内存中
->>> inferencer = MMSegInferencer(model='deeplabv3plus_r18-d8_4xb2-80k_cityscapes-512x1024')
->>> # 推理
->>> inferencer('demo/demo.png', show=True)
-```
-
-可视化结果应如下所示：
-
-<div align="center">
-    <img src='https://user-images.githubusercontent.com/76149310/221507927-ae01e3a7-016f-4425-b966-7b19cbbe494e.png' />
-</div>
-
-此外，您可以使用 `MMSegInferencer` 来处理一个包含多张图片的 `list`：
-
-```
-# 输入一个图片 list
->>> images = [image1, image2, ...] # image1 可以是文件路径或 np.ndarray
->>> inferencer(images, show=True, wait_time=0.5) # wait_time 是延迟时间，0 表示无限
-
-# 或输入图像目录
->>> images = $IMAGESDIR
->>> inferencer(images, show=True, wait_time=0.5)
-
-# 保存可视化渲染彩色分割图和预测结果
-# out_dir 是保存输出结果的目录，img_out_dir 和 pred_out_dir 为 out_dir 的子目录
-# 以保存可视化渲染彩色分割图和预测结果
->>> inferencer(images, out_dir='outputs', img_out_dir='vis', pred_out_dir='pred')
-```
-
-推理器有一个可选参数 `return_datasamples`，其默认值为 False，推理器的返回值默认为 `dict` 类型，包括 'visualization' 和 'predictions' 两个 key。
-如果 `return_datasamples=True` 推理器将返回 [`SegDataSample`](../advanced_guides/structures.md) 或其列表。
-
-```
-result = inferencer('demo/demo.png')
-# 结果是一个包含 'visualization' 和 'predictions' 两个 key 的 `dict`
-# 'visualization' 包含彩色分割图
-print(result['visualization'].shape)
-# (512, 683, 3)
-
-# 'predictions' 包含带有标签索引的分割掩膜
-print(result['predictions'].shape)
-# (512, 683)
-
-result = inferencer('demo/demo.png', return_datasamples=True)
-print(type(result))
-# <class 'mmseg.structures.seg_data_sample.SegDataSample'>
-
-# 输入一个图片 list
-results = inferencer(images)
-# 输出为列表
-print(type(results['visualization']), results['visualization'][0].shape)
-# <class 'list'> (512, 683, 3)
-print(type(results['predictions']), results['predictions'][0].shape)
-# <class 'list'> (512, 683)
-
-results = inferencer(images, return_datasamples=True)
-# <class 'list'>
-print(type(results[0]))
-# <class 'mmseg.structures.seg_data_sample.SegDataSample'>
-```
-
-### 初始化
-
-`MMSegInferencer` 必须使用 `model` 初始化，该 `model` 可以是模型名称或一个 `Config`，甚至可以是配置文件的路径。
-模型名称可以在模型的元文件（configs/xxx/metafile.yaml）中找到，比如 maskformer 的一个模型名称是 `maskformer_r50-d32_8xb2-160k_ade20k-512x512`，如果输入模型名称，模型的权重将自动下载。以下是其他输入参数：
-
-- weights（str，可选）- 权重的路径。如果未指定，并且模型是元文件中的模型名称，则权重将从元文件加载。默认为 None。
-- classes（list，可选）- 输入类别用于结果渲染，由于分割模型的预测结构是标签索引的分割图，`classes` 是一个相应的标签索引的类别列表。若 classes 没有定义，可视化工具将默认使用 `cityscapes` 的类别。默认为 None。
-- palette（list，可选）- 输入调色盘用于结果渲染，它是对应分类的配色列表。若 palette 没有定义，可视化工具将默认使用 `cityscapes` 的调色盘。默认为 None。
-- dataset_name（str，可选）- [数据集名称或别名](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/utils/class_names.py#L302-L317)，可视化工具将使用数据集的元信息，如类别和配色，但 `classes` 和 `palette` 具有更高的优先级。默认为 None。
-- device（str，可选）- 运行推理的设备。如果无，则会自动使用可用的设备。默认为 None。
-- scope（str，可选）- 模型的作用域。默认为 'mmseg'。
-
-### 可视化预测结果
-
-`MMSegInferencer` 有4个用于可视化预测的参数，您可以在初始化推理器时使用它们：
-
-- show（bool）- 是否弹出窗口显示图像。默认为 False。
-- wait_time（float）- 显示的间隔。默认值为 0。
-- img_out_dir（str）- `out_dir` 的子目录，用于保存渲染有色分割掩膜，因此如果要保存预测掩膜，则必须定义 `out_dir`。默认为 `vis`。
-- opacity（int，float）- 分割掩膜的透明度。默认值为 0.8。
-
-这些参数的示例请参考[基本使用](#基本使用)
-
-### 模型列表
-
-在 MMSegmentation 中有一个非常容易列出所有模型名称的方法
-
-```
->>> from mmseg.apis import MMSegInferencer
-# models 是一个模型名称列表，它们将自动打印
->>> models = MMSegInferencer.list_models('mmseg')
-```
-
-## 推理 API
-
-### mmseg.apis.init_model
-
-从配置文件初始化一个分割器。
-
-参数：
-
-- config（str，`Path` 或 `mmengine.Config`）- 配置文件路径或配置对象。
-- checkpoint（str，可选）- 权重路径。如果为 None，则模型将不会加载任何权重。
-- device（str，可选）- CPU/CUDA 设备选项。默认为 'cuda:0'。
-- cfg_options（dict，可选）- 用于覆盖所用配置中的某些设置的选项。
-
-返回值：
-
-- nn.Module：构建好的分割器。
-
-示例：
-
-```python
-from mmseg.apis import init_model
-
-config_path = 'configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-checkpoint_path = 'checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
-
-# 初始化不带权重的模型
-model = init_model(config_path)
-
-# 初始化模型并加载权重
-model = init_model(config_path, checkpoint_path)
-
-# 在 CPU 上的初始化模型并加载权重
-model = init_model(config_path, checkpoint_path, 'cpu')
-```
-
-### mmseg.apis.inference_model
-
-使用分割器推理图像。
-
-参数：
-
-- model（nn.Module）- 加载的分割器
-- imgs（str，np.ndarray 或 list\[str/np.ndarray\]）- 图像文件或加载的图像
-
-返回值：
-
-- `SegDataSample` 或 list\[`SegDataSample`\]：如果 imgs 是列表或元组，则返回相同长度的列表类型结果，否则直接返回分割结果。
-
-**注意：** [SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py) 是 MMSegmentation 的数据结构接口，用作不同组件之间的接口。`SegDataSample` 实现抽象数据元素 `mmengine.structures.BaseDataElement`，请参阅 [MMEngine](https://github.com/open-mmlab/mmengine) 中的数据元素[文档](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/data_element.html)了解更多信息。
-
-`SegDataSample` 中的参数分为几个部分：
-
-- `gt_sem_seg`（`PixelData`）- 语义分割的标注。
-- `pred_sem_seg`（`PixelData`）- 语义分割的预测。
-- `seg_logits`（`PixelData`）- 模型最后一层的输出结果。
-
-**注意：** [PixelData](https://github.com/open-mmlab/mmengine/blob/main/mmengine/structures/pixel_data.py) 是像素级标注或预测的数据结构，请参阅 [MMEngine](https://github.com/open-mmlab/mmengine) 中的 PixelData [文档](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/data_element.html)了解更多信息。
-
-示例：
-
-```python
-from mmseg.apis import init_model, inference_model
-
-config_path = 'configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-checkpoint_path = 'checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
-img_path = 'demo/demo.png'
-
-
-model = init_model(config_path, checkpoint_path)
-result = inference_model(model, img_path)
-```
-
-### mmseg.apis.show_result_pyplot
-
-在图像上可视化分割结果。
-
-参数：
-
-- model（nn.Module）- 加载的分割器。
-- img（str 或 np.ndarray）- 图像文件名或加载的图像。
-- result（`SegDataSample`）- SegDataSample 预测结果。
-- opacity（float）- 绘制分割图的不透明度。默认值为 `0.5`，必须在 `(0，1]` 范围内。
-- title（str）- pyplot 图的标题。默认值为 ''。
-- draw_gt（bool）- 是否绘制 GT SegDataSample。默认为 `True`。
-- draw_pred（draws_pred）- 是否绘制预测 SegDataSample。默认为 `True`。
-- wait_time（float）- 显示的间隔，0 是表示“无限”的特殊值。默认为 `0`。
-- show（bool）- 是否展示绘制的图像。默认为 `True`。
-- save_dir（str，可选）- 为所有存储后端保存的文件路径。如果为 `None`，则后端存储将不会保存任何数据。
-- out_file（str，可选）- 输出文件的路径。默认为 `None`。
-
-返回值：
-
-- np.ndarray：通道为 RGB 的绘制图像。
-
-示例：
-
-```python
-from mmseg.apis import init_model, inference_model, show_result_pyplot
-
-config_path = 'configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
-checkpoint_path = 'checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
-img_path = 'demo/demo.png'
-
-
-# 从配置文件和权重文件构建模型
-model = init_model(config_path, checkpoint_path, device='cuda:0')
-
-# 推理给定图像
-result = inference_model(model, img_path)
-
-# 展示分割结果
-vis_image = show_result_pyplot(model, img_path, result)
-
-# 保存可视化结果，输出图像将在 `workdirs/result.png` 路径下找到
-vis_iamge = show_result_pyplot(model, img_path, result, out_file='work_dirs/result.png')
-
-# 修改展示图像的时间，注意 0 是表示“无限”的特殊值
-vis_image = show_result_pyplot(model, img_path, result, wait_time=5)
-```
-
-**注意：** 如果当前设备没有图形用户界面，建议将 `show` 设置为 `False`，并指定 `out_file` 或 `save_dir` 来保存结果。如果您想在窗口上显示结果，则不需要特殊设置。
diff --git a/mmsegmentation/docs/zh_cn/user_guides/4_train_test.md b/mmsegmentation/docs/zh_cn/user_guides/4_train_test.md
deleted file mode 100644
index f821aca..0000000
--- a/mmsegmentation/docs/zh_cn/user_guides/4_train_test.md
+++ /dev/null
@@ -1,317 +0,0 @@
-# 教程4：使用现有模型进行训练和测试
-
-MMSegmentation 支持在多种设备上训练和测试模型。如下文，具体方式分别为单GPU、分布式以及计算集群的训练和测试。通过本教程，您将知晓如何用 MMSegmentation 提供的脚本进行训练和测试。
-
-## 在单GPU上训练和测试
-
-### 在单GPU上训练
-
-`tools/train.py` 文件提供了在单GPU上部署训练任务的方法。
-
-基础用法如下:
-
-```shell
-python tools/train.py  ${配置文件} [可选参数]
-```
-
-- `--work-dir ${工作路径}`: 重新指定工作路径
-- `--amp`: 使用自动混合精度计算
-- `--resume`: 从工作路径中保存的最新检查点文件（checkpoint）恢复训练
-- `--cfg-options ${需更覆盖的配置}`: 覆盖已载入的配置中的部分设置，并且 以 xxx=yyy 格式的键值对 将被合并到配置文件中。
-  比如： '--cfg-option model.encoder.in_channels=6'， 更多细节请看[指导](./1_config.md#Modify-config-through-script-arguments)。
-
-下面是对于多GPU测试的可选参数:
-
-- `--launcher`: 执行器的启动方式。允许选择的参数值有 `none`, `pytorch`, `slurm`, `mpi`。特别的，如果设置为none，测试将非分布式模式下进行。
-- `--local_rank`: 分布式中进程的序号。如果没有指定，默认设置为0。
-
-**注意：** 命令行参数 `--resume` 和在配置文件中的参数 `load_from` 的不同之处：
-
-`--resume` 只决定是否继续使用工作路径中最新的检查点，它常常用于恢复被意外打断的训练。
-
-`load_from` 会明确指定被载入的检查点文件，且训练迭代器将从0开始，通常用于微调模型。
-
-如果您希望从指定的检查点上恢复训练您可以使用：
-
-```python
-python tools/train.py ${配置文件} --resume --cfg-options load_from=${检查点}
-```
-
-**在 CPU 上训练**: 如果机器没有 GPU，则在 CPU 上训练的过程是与单GPU训练一致的。如果机器有 GPU 但是不希望使用它们，我们只需要在训练前通过以下方式关闭 GPU 训练功能。
-
-```shell
-export CUDA_VISIBLE_DEVICES=-1
-```
-
-然后运行[上方](###在单GPU上训练)脚本。
-
-### 在单GPU上测试
-
-`tools/test.py` 文件提供了在单 GPU 上启动测试任务的方法。
-
-基础用法如下:
-
-```shell
-python tools/test.py ${配置文件} ${模型权重文件} [可选参数]
-```
-
-这个工具有几个可选参数，包括：
-
-- `--work-dir`: 如果指定了路径，结果会保存在该路径下。如果没有指定则会保存在 `work_dirs/{配置文件名}` 路径下.
-- `--show`: 当 `--show-dir` 没有指定时，可以使用该参数，在程序运行过程中显示预测结果。
-- `--show-dir`: 绘制了分割掩膜图片的存储文件夹。如果指定了该参数，则可视化的分割掩膜将被保存到 `work_dir/timestamp/{指定路径}`.
-- `--wait-time`: 多次可视化结果的时间间隔。当 `--show` 为激活状态时发挥作用。默认为2。
-- `--cfg-options`:  如果被具体指定，以 xxx=yyy 形式的键值对将被合并入配置文件中。
-
-**在CPU上测试**: 如果机器没有GPU，则在CPU上训练的过程是与单GPU训练一致的。如果机器有GPU，但是不希望使用它们，我们只需要在训练前通过以下方式关闭GPUs训练功能。
-
-```shell
-export CUDA_VISIBLE_DEVICES=-1
-```
-
-然后运行[上方](###在单GPU上测试)脚本。
-
-## 多GPU、多机器上训练和测试
-
-### 在多GPU上训练
-
-OpenMMLab2.0 通过 `MMDistributedDataParallel`实现 **分布式** 训练。
-
-`tools/dist_train.sh` 文件提供了在在多GPU上部署训练任务的方法。
-
-基础用法如下:
-
-```shell
-sh tools/dist_train.sh ${配置文件} ${GPU数量} [可选参数]
-```
-
-可选参数与[上方](###在单GPU上训练)相同并且还增加了可以指定gpu数量的参数。
-
-示例:
-
-```shell
-# 模型训练的检查点和日志保存在这个路径下： WORK_DIR=work_dirs/pspnet_r50-d8_4xb4-80k_ade20k-512x512/
-# 如果工作路径没有被设定，它将会被自动生成。
-sh tools/dist_train.sh configs/pspnet/pspnet_r50-d8_4xb4-80k_ade20k-512x512.py 8 --work-dir work_dirs/pspnet_r50-d8_4xb4-80k_ade20k-512x512
-```
-
-**注意**: 在训练过程中，检查点和日志保存在`work_dirs/`下的配置文件的相同文件夹结构下。
-不推荐自定义的工作路径，因为评估脚本依赖于源自配置文件名的路径。如果您希望将权重保存在其他地方，请用符号链接，例如：
-
-```shell
-ln -s ${您的工作路径} ${MMSEG 路径}/work_dirs
-```
-
-### 在多GPU上测试
-
-`tools/dist_test.sh` 文件提供了在多GPU上启动测试任务的方法。
-
-基础用法如下:
-
-```shell
-sh tools/dist_test.sh ${配置文件} ${检查点文件} ${GPU数量} [可选参数]
-```
-
-可选参数与[上方](###在单GPU上测试)相同并且增加了可以指定 gpu 数量的参数。
-
-示例:
-
-```shell
-./tools/dist_test.sh configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py \
-    checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth 4
-```
-
-### 在单台机器上启动多个任务
-
-如果您在单个机器上运行多个任务，比如：在8卡GPU的单个机器上执行2个各需4卡GPU的训练任务，您需要为每个任务具体指定不同端口（默认29500），从而避免通讯冲突。否则，会有报错信息——`RuntimeError: Address already in use`（运行错误：地址被使用）。
-
-如果您使用 `dist_train.sh` 来启动训练任务，您可以通过环境变量 `PORT` 设置端口。
-
-```shell
-CUDA_VISIBLE_DEVICES=0,1,2,3 PORT=29500 sh tools/dist_train.sh ${配置文件} 4
-CUDA_VISIBLE_DEVICES=4,5,6,7 PORT=29501 sh tools/dist_train.sh ${配置文件} 4
-```
-
-### 在多台机器上训练
-
-MMSegmentation 的分布式训练依赖 `torch.distributed`。
-因此， 可以通过 PyTorch 的 [运行工具 launch utility](https://pytorch.org/docs/stable/distributed.html#launch-utility) 来进行分布式训练。
-
-如果您启动的多台机器简单地通过以太网连接，您可以直接运行下方命令：
-
-在第一个机器上:
-
-```shell
-NNODES=2 NODE_RANK=0 PORT=${主节点端口} MASTER_ADDR=${主节点地址} sh tools/dist_train.sh ${配置文件} ${GPUS}
-```
-
-在第二个机器上:
-
-```shell
-NNODES=2 NODE_RANK=1 PORT=${主节点端口} MASTER_ADDR=${主节点地址} sh tools/dist_train.sh ${配置文件} ${GPUS}
-```
-
-通常，如果您没有使用像无限带宽一类的高速网络，这个会过程比较慢。
-
-## 通过 Slurm 管理任务
-
-[Slurm](https://slurm.schedmd.com/) 是一个很好的计算集群作业调度系统。
-
-### 通过 Slurm 在集群上训练
-
-在一个由Slurm管理的集群上，您可以使用`slurm_train.sh`来启动训练任务。它同时支持单节点和多节点的训练。
-
-基础用法如下：
-
-```shell
-[GPUS=${GPUS}] sh tools/slurm_train.sh ${分区} ${任务名} ${配置文件} [可选参数]
-```
-
-下方是一个通过名为 `dev` 的 Slurm 分区，调用4个 GPU 来训练 PSPNet，并设置工作路径为共享文件系统。
-
-```shell
-GPUS=4 sh tools/slurm_train.sh dev pspnet configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py --work-dir work_dir/pspnet
-```
-
-您可以检查 [源码](../../../tools/slurm_train.sh) 来查看全部的参数和环境变量。
-
-### 通过 Slurm 在集群上测试
-
-与训练任务相同， MMSegmentation 提供 `slurm_test.sh` 文件来启动测试任务。
-
-基础用法如下：
-
-```shell
-[GPUS=${GPUS}] sh tools/slurm_test.sh ${分区} ${任务名} ${配置文件} ${检查点文件} [可选参数]
-```
-
-您可以通过 [源码](../../../tools/slurm_test.sh) 来查看全部的参数和环境变量。
-
-**注意：** 使用 Slurm 时，需要设置端口，可从以下方式中选取一种。
-
-1. 我们更推荐的通过`--cfg-options`设置端口，因为这不会改变原始配置：
-
-   ```shell
-   GPUS=4 GPUS_PER_NODE=4 sh tools/slurm_train.sh ${分区} ${任务名} config1.py ${工作路径} --cfg-options env_cfg.dist_cfg.port=29500
-   GPUS=4 GPUS_PER_NODE=4 sh tools/slurm_train.sh ${任务名} ${工作路径} config2.py ${工作路径} --cfg-options env_cfg.dist_cfg.port=29501
-   ```
-
-2. 通过修改配置文件设置不同的通讯端口：
-
-   在 `config1.py`中:
-
-   ```python
-   enf_cfg = dict(dist_cfg=dict(backend='nccl', port=29500))
-   ```
-
-   在 `config2.py`中：
-
-   ```python
-   enf_cfg = dict(dist_cfg=dict(backend='nccl', port=29501))
-   ```
-
-   然后您可以通过 config1.py 和 config2.py 同时启动两个任务：
-
-   ```shell
-   CUDA_VISIBLE_DEVICES=0,1,2,3 GPUS=4 sh tools/slurm_train.sh ${分区} ${任务名} config1.py ${工作路径}
-   CUDA_VISIBLE_DEVICES=4,5,6,7 GPUS=4 sh tools/slurm_train.sh ${分区} ${任务名} config2.py ${工作路径}
-   ```
-
-3. 在命令行中通过环境变量 `MASTER_PORT` 设置端口 ：
-
-```shell
-CUDA_VISIBLE_DEVICES=0,1,2,3 GPUS=4 MASTER_PORT=29500 sh tools/slurm_train.sh ${分区} ${任务名} config1.py ${工作路径}
-CUDA_VISIBLE_DEVICES=4,5,6,7 GPUS=4 MASTER_PORT=29501 sh tools/slurm_train.sh ${分区} ${任务名} config2.py ${工作路径}
-```
-
-## 测试并保存分割结果
-
-### 基础使用
-
-当需要保存测试输出的分割结果，用 `--out` 指定分割结果输出路径
-
-```shell
-python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} --out ${OUTPUT_DIR}
-```
-
-以保存模型 `fcn_r50-d8_4xb4-80k_ade20k-512x512` 在 ADE20K 验证数据集上的结果为例：
-
-```shell
-python tools/test.py configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py ckpt/fcn_r50-d8_512x512_80k_ade20k_20200614_144016-f8ac5082.pth --out work_dirs/format_results
-```
-
-或者通过配置文件定义 `output_dir`。例如在 `configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py` 添加 `test_evaluator` 定义：
-
-```python
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'], output_dir='work_dirs/format_results')
-```
-
-然后执行相同功能的命令不需要再使用 `--out`：
-
-```shell
-python tools/test.py configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py ckpt/fcn_r50-d8_512x512_80k_ade20k_20200614_144016-f8ac5082.pth
-```
-
-当测试的数据集没有提供标注，评测时没有真值可以参与计算，因此需要设置 `format_only=True`，
-同时需要修改 `test_dataloader`，由于没有标注，我们需要在数据增强变换中删掉 `dict(type='LoadAnnotations')`，以下是一个配置示例：
-
-```python
-test_evaluator = dict(
-    type='IoUMetric',
-    iou_metrics=['mIoU'],
-    format_only=True,
-    output_dir='work_dirs/format_results')
-test_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type = 'ADE20KDataset'
-        data_root='data/ade/release_test',
-        data_prefix=dict(img_path='testing'),
-        # 测试数据变换中没有加载标注
-        pipeline=[
-            dict(type='LoadImageFromFile'),
-            dict(type='Resize', scale=(2048, 512), keep_ratio=True),
-            dict(type='PackSegInputs')
-        ]))
-```
-
-然后执行测试命令：
-
-```shell
-python tools/test.py configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py ckpt/fcn_r50-d8_512x512_80k_ade20k_20200614_144016-f8ac5082.pth
-```
-
-### 测试 Cityscapes 数据集并保存输出分割结果
-
-推荐使用 `CityscapesMetric` 来保存模型在 Cityscapes 数据集上的测试结果，以下是一个配置示例：
-
-```python
-test_evaluator = dict(
-    type='CityscapesMetric',
-    format_only=True,
-    keep_results=True,
-    output_dir='work_dirs/format_results')
-test_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type='CityscapesDataset',
-        data_root='data/cityscapes/',
-        data_prefix=dict(img_path='leftImg8bit/test'),
-        pipeline=[
-            dict(type='LoadImageFromFile'),
-            dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
-            dict(type='PackSegInputs')
-        ]))
-```
-
-然后执行相同的命令，例如：
-
-```shell
-python tools/test.py configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-512x1024.py ckpt/fcn_r18-d8_512x1024_80k_cityscapes_20201225_021327-6c50f8b4.pth
-```
diff --git a/mmsegmentation/docs/zh_cn/user_guides/5_deployment.md b/mmsegmentation/docs/zh_cn/user_guides/5_deployment.md
deleted file mode 100644
index b2bec02..0000000
--- a/mmsegmentation/docs/zh_cn/user_guides/5_deployment.md
+++ /dev/null
@@ -1,243 +0,0 @@
-# 教程5：模型部署
-
-# MMSegmentation 模型部署
-
-- [教程5：模型部署](#教程5模型部署)
-- [MMSegmentation 模型部署](#mmsegmentation-模型部署)
-  - [安装](#安装)
-    - [安装 mmseg](#安装-mmseg)
-    - [安装 mmdeploy](#安装-mmdeploy)
-  - [模型转换](#模型转换)
-  - [模型规范](#模型规范)
-  - [模型推理](#模型推理)
-    - [后端模型推理](#后端模型推理)
-    - [SDK 模型推理](#sdk-模型推理)
-  - [模型支持列表](#模型支持列表)
-  - [注意事项](#注意事项)
-
-______________________________________________________________________
-
-[MMSegmentation](https://github.com/open-mmlab/mmsegmentation/tree/main) 又称`mmseg`，是一个基于 PyTorch 的开源对象分割工具箱。它是 [OpenMMLab](https://openmmlab.com/) 项目的一部分。
-
-## 安装
-
-### 安装 mmseg
-
-请参考[官网安装指南](https://mmsegmentation.readthedocs.io/en/latest/get_started.html)。
-
-### 安装 mmdeploy
-
-mmdeploy 有以下几种安装方式:
-
-**方式一：** 安装预编译包
-
-请参考[安装概述](https://mmdeploy.readthedocs.io/zh_CN/latest/get_started.html#mmdeploy)
-
-**方式二：** 一键式脚本安装
-
-如果部署平台是 **Ubuntu 18.04 及以上版本**， 请参考[脚本安装说明](../01-how-to-build/build_from_script.md)，完成安装过程。
-比如，以下命令可以安装 mmdeploy 以及配套的推理引擎——`ONNX Runtime`.
-
-```shell
-git clone --recursive -b main https://github.com/open-mmlab/mmdeploy.git
-cd mmdeploy
-python3 tools/scripts/build_ubuntu_x64_ort.py $(nproc)
-export PYTHONPATH=$(pwd)/build/lib:$PYTHONPATH
-export LD_LIBRARY_PATH=$(pwd)/../mmdeploy-dep/onnxruntime-linux-x64-1.8.1/lib/:$LD_LIBRARY_PATH
-```
-
-**说明**:
-
-- 把 `$(pwd)/build/lib` 添加到 `PYTHONPATH`，目的是为了加载 mmdeploy SDK python 包 `mmdeploy_runtime`，在章节 [SDK模型推理](#sdk模型推理)中讲述其用法。
-- 在[使用 ONNX Runtime推理后端模型](#后端模型推理)时，需要加载自定义算子库，需要把 ONNX Runtime 库的路径加入环境变量 `LD_LIBRARY_PATH`中。
-
-**方式三：** 源码安装
-
-在方式一、二都满足不了的情况下，请参考[源码安装说明](../01-how-to-build/build_from_source.md) 安装 mmdeploy 以及所需推理引擎。
-
-## 模型转换
-
-你可以使用 [tools/deploy.py](https://github.com/open-mmlab/mmdeploy/tree/main/tools/deploy.py) 把 mmseg 模型一键式转换为推理后端模型。
-该工具的详细使用说明请参考[这里](https://github.com/open-mmlab/mmdeploy/tree/main/docs/en/02-how-to-run/convert_model.md#usage).
-
-以下，我们将演示如何把 `unet` 转换为 onnx 模型。
-
-```shell
-cd mmdeploy
-
-# download unet model from mmseg model zoo
-mim download mmsegmentation --config unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024 --dest .
-
-# convert mmseg model to onnxruntime model with dynamic shape
-python tools/deploy.py \
-    configs/mmseg/segmentation_onnxruntime_dynamic.py \
-    unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py \
-    fcn_unet_s5-d16_4x4_512x1024_160k_cityscapes_20211210_145204-6860854e.pth \
-    demo/resources/cityscapes.png \
-    --work-dir mmdeploy_models/mmseg/ort \
-    --device cpu \
-    --show \
-    --dump-info
-```
-
-转换的关键之一是使用正确的配置文件。项目中已内置了各后端部署[配置文件](https://github.com/open-mmlab/mmdeploy/tree/main/configs/mmseg)。
-文件的命名模式是：
-
-```
-segmentation_{backend}-{precision}_{static | dynamic}_{shape}.py
-```
-
-其中：
-
-- **{backend}:** 推理后端名称。比如，onnxruntime、tensorrt、pplnn、ncnn、openvino、coreml 等等
-- **{precision}:** 推理精度。比如，fp16、int8。不填表示 fp32
-- **{static | dynamic}:** 动态、静态 shape
-- **{shape}:** 模型输入的 shape 或者 shape 范围
-
-在上例中，你也可以把 `unet` 转为其他后端模型。比如使用`segmentation_tensorrt-fp16_dynamic-512x1024-2048x2048.py`，把模型转为 tensorrt-fp16 模型。
-
-```{tip}
-当转 tensorrt 模型时, --device 需要被设置为 "cuda"
-```
-
-## 模型规范
-
-在使用转换后的模型进行推理之前，有必要了解转换结果的结构。 它存放在 `--work-dir` 指定的路路径下。
-
-上例中的`mmdeploy_models/mmseg/ort`，结构如下：
-
-```
-mmdeploy_models/mmseg/ort
-├── deploy.json
-├── detail.json
-├── end2end.onnx
-└── pipeline.json
-```
-
-重要的是：
-
-- **end2end.onnx**: 推理引擎文件。可用 ONNX Runtime 推理
-- \***.json**:  mmdeploy SDK 推理所需的 meta 信息
-
-整个文件夹被定义为**mmdeploy SDK model**。换言之，**mmdeploy SDK model**既包括推理引擎，也包括推理 meta 信息。
-
-## 模型推理
-
-### 后端模型推理
-
-以上述模型转换后的 `end2end.onnx` 为例，你可以使用如下代码进行推理：
-
-```python
-from mmdeploy.apis.utils import build_task_processor
-from mmdeploy.utils import get_input_shape, load_config
-import torch
-
-deploy_cfg = 'configs/mmseg/segmentation_onnxruntime_dynamic.py'
-model_cfg = './unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py'
-device = 'cpu'
-backend_model = ['./mmdeploy_models/mmseg/ort/end2end.onnx']
-image = './demo/resources/cityscapes.png'
-
-# read deploy_cfg and model_cfg
-deploy_cfg, model_cfg = load_config(deploy_cfg, model_cfg)
-
-# build task and backend model
-task_processor = build_task_processor(model_cfg, deploy_cfg, device)
-model = task_processor.build_backend_model(backend_model)
-
-# process input image
-input_shape = get_input_shape(deploy_cfg)
-model_inputs, _ = task_processor.create_input(image, input_shape)
-
-# do model inference
-with torch.no_grad():
-    result = model.test_step(model_inputs)
-
-# visualize results
-task_processor.visualize(
-    image=image,
-    model=model,
-    result=result[0],
-    window_name='visualize',
-    output_file='./output_segmentation.png')
-```
-
-### SDK 模型推理
-
-你也可以参考如下代码，对 SDK model 进行推理：
-
-```python
-from mmdeploy_runtime import Segmentor
-import cv2
-import numpy as np
-
-img = cv2.imread('./demo/resources/cityscapes.png')
-
-# create a classifier
-segmentor = Segmentor(model_path='./mmdeploy_models/mmseg/ort', device_name='cpu', device_id=0)
-# perform inference
-seg = segmentor(img)
-
-# visualize inference result
-## random a palette with size 256x3
-palette = np.random.randint(0, 256, size=(256, 3))
-color_seg = np.zeros((seg.shape[0], seg.shape[1], 3), dtype=np.uint8)
-for label, color in enumerate(palette):
-    color_seg[seg == label, :] = color
-# convert to BGR
-color_seg = color_seg[..., ::-1]
-img = img * 0.5 + color_seg * 0.5
-img = img.astype(np.uint8)
-cv2.imwrite('output_segmentation.png', img)
-```
-
-除了python API，mmdeploy SDK 还提供了诸如 C、C++、C#、Java等多语言接口。
-你可以参考[样例](https://github.com/open-mmlab/mmdeploy/tree/main/demo)学习其他语言接口的使用方法。
-
-## 模型支持列表
-
-| Model                                                                                                     | TorchScript | OnnxRuntime | TensorRT | ncnn | PPLNN | OpenVino |
-| :-------------------------------------------------------------------------------------------------------- | :---------: | :---------: | :------: | :--: | :---: | :------: |
-| [FCN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/fcn)                                 |      Y      |      Y      |    Y     |  Y   |   Y   |    Y     |
-| [PSPNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/pspnet)[\*](#static_shape)        |      Y      |      Y      |    Y     |  Y   |   Y   |    Y     |
-| [DeepLabV3](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/deeplabv3)                     |      Y      |      Y      |    Y     |  Y   |   Y   |    Y     |
-| [DeepLabV3+](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/deeplabv3plus)                |      Y      |      Y      |    Y     |  Y   |   Y   |    Y     |
-| [Fast-SCNN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/fastscnn)[\*](#static_shape)   |      Y      |      Y      |    Y     |  N   |   Y   |    Y     |
-| [UNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/unet)                               |      Y      |      Y      |    Y     |  Y   |   Y   |    Y     |
-| [ANN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/ann)[\*](#static_shape)              |      Y      |      Y      |    Y     |  N   |   N   |    N     |
-| [APCNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/apcnet)                           |      Y      |      Y      |    Y     |  Y   |   N   |    N     |
-| [BiSeNetV1](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/bisenetv1)                     |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
-| [BiSeNetV2](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/bisenetv2)                     |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
-| [CGNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/cgnet)                             |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
-| [DMNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/dmnet)                             |      ?      |      Y      |    N     |  N   |   N   |    N     |
-| [DNLNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/dnlnet)                           |      ?      |      Y      |    Y     |  Y   |   N   |    Y     |
-| [EMANet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/emanet)                           |      Y      |      Y      |    Y     |  N   |   N   |    Y     |
-| [EncNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/encnet)                           |      Y      |      Y      |    Y     |  N   |   N   |    Y     |
-| [ERFNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/erfnet)                           |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
-| [FastFCN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/fastfcn)                         |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
-| [GCNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/gcnet)                             |      Y      |      Y      |    Y     |  N   |   N   |    N     |
-| [ICNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/icnet)[\*](#static_shape)          |      Y      |      Y      |    Y     |  N   |   N   |    Y     |
-| [ISANet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/isanet)[\*](#static_shape)        |      N      |      Y      |    Y     |  N   |   N   |    Y     |
-| [NonLocal Net](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/nonlocal_net)               |      ?      |      Y      |    Y     |  Y   |   N   |    Y     |
-| [OCRNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/ocrnet)                           |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
-| [PointRend](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/point_rend)[\*](#static_shape) |      Y      |      Y      |    Y     |  N   |   N   |    N     |
-| [Semantic FPN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/sem_fpn)                    |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
-| [STDC](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/stdc)                               |      Y      |      Y      |    Y     |  Y   |   N   |    Y     |
-| [UPerNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/upernet)[\*](#static_shape)      |      N      |      Y      |    Y     |  N   |   N   |    N     |
-| [DANet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/danet)                             |      ?      |      Y      |    Y     |  N   |   N   |    Y     |
-| [Segmenter](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/segmenter)[\*](#static_shape)  |      N      |      Y      |    Y     |  Y   |   N   |    Y     |
-| [SegFormer](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/segformer)[\*](#static_shape)  |      ?      |      Y      |    Y     |  N   |   N   |    Y     |
-| [SETR](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/setr)                               |      ?      |      Y      |    N     |  N   |   N   |    Y     |
-| [CCNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/ccnet)                             |      ?      |      N      |    N     |  N   |   N   |    N     |
-| [PSANet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/psanet)                           |      ?      |      N      |    N     |  N   |   N   |    N     |
-| [DPT](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/dpt)                                 |      ?      |      N      |    N     |  N   |   N   |    N     |
-
-## 注意事项
-
-- 所有 mmseg 模型仅支持 "whole" 推理模式。
-
-- <i id=“static_shape”>PSPNet，Fast-SCNN</i> 仅支持静态输入，因为多数推理框架的 [nn.AdaptiveAvgPool2d](https://github.com/open-mmlab/mmsegmentation/blob/0c87f7a0c9099844eff8e90fa3db5b0d0ca02fee/mmseg/models/decode_heads/psp_head.py#L38) 不支持动态输入。
-
-- 对于仅支持静态形状的模型，应使用静态形状的部署配置文件，例如 `configs/mmseg/segmentation_tensorrt_static-1024x2048.py`
-
-- 对于喜欢部署模型生成概率特征图的用户，将 `codebase_config = dict(with_argmax=False)` 放在部署配置中就足够了。
diff --git a/mmsegmentation/docs/zh_cn/user_guides/deploy_jetson.md b/mmsegmentation/docs/zh_cn/user_guides/deploy_jetson.md
deleted file mode 100644
index 6cebd9c..0000000
--- a/mmsegmentation/docs/zh_cn/user_guides/deploy_jetson.md
+++ /dev/null
@@ -1,372 +0,0 @@
-# 将 MMSeg 模型调优及部署到 NVIDIA Jetson 平台教程
-
-- 请先查阅[MMSegmentation 模型部署](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/5_deployment.md)文档。
-- **本教程所用 mmsegmentation 版本： v1.1.2**
-- **本教程所用 NVIDIA Jetson 设备： NVIDIA Jetson AGX Orin 64G**
-
-<div align="center">
-    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/b5466cfd-71a9-4e06-9823-c253a97d57b5" alt="Smiley face" width="50%">
-</div>
-
-## 1 配置 [mmsegmentation](https://github.com/open-mmlab/mmsegmentation)
-
-- 根据[安装和验证](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/get_started.md)文档，完成开发 [mmsegmentation](https://github.com/open-mmlab/mmsegmentation) 所需的 [`pytorch`](https://pytorch.org/get-started/locally/)、[`mmcv`](https://github.com/open-mmlab/mmcv)、[`mmengine`](https://github.com/open-mmlab/mmengine) 等环境依赖安装。
-- 从 GitHub 使用 git clone 命令完成 [mmsegmentation](https://github.com/open-mmlab/mmsegmentation) 下载。网络不好的同学，可通过 [MMSeg GitHub](https://github.com/open-mmlab/mmsegmentation) 页面进行 zip 的下载。
-  ```bash
-  git clone https://github.com/open-mmlab/mmsegmentation.git
-  ```
-- 使用 `pip install -v -e.` 命令动态安装 mmsegmentation 。
-  ```bash
-  cd mmsegmentation
-  pip install -v -e .
-  ```
-  提示成功安装后，可通过 `pip list` 命令查看到 mmsegmentation 已通过本地安装方式安装到了您的环境中。
-  ![mmseg-install](https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/a9c7bcc9-cdcc-40a4-bd7b-8153195549c8)
-
-## 2 准备您的数据集
-
-- 本教程使用遥感图像语义分割数据集 [potsdam](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#isprs-potsdam) 作为示例。
-- 根据 [potsdam 数据准备](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#isprs-potsdam)文档，进行数据集下载及 MMSeg 格式的准备。
-- 数据集介绍： potsdam 数据集是以德国一个典型的历史城市 Potsdam 命名的，该城市有着大建筑群、狭窄的街道和密集的建筑结构。 potsdam 数据集包含 38 幅 6000x6000 像素的图像，空间分辨率为 5cm，数据集的示例如下图：
-  ![potsdam-img](https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/3bc0a75b-1693-4ae6-aeea-ad502e955068)
-
-## 3 从 config 页面下载模型的 pth 权重文件
-
-这里以 [`deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py`](../../configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py) 配置文件举例，在 [configs](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/deeplabv3plus#potsdam) 页面下载权重文件，
-![pth](https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/8f747362-caf4-406c-808d-4ca72babb209)
-
-## 4 通过 [OpenMMLab deployee](https://platform.openmmlab.com/deploee) 以交互式方式进行模型转换及测速
-
-### 4.1 模型转换
-
-在该部分中，[OpenMMLab 官网](https://platform.openmmlab.com/deploee)提供了模型转换及模型测速的交互界面，无需任何代码，即可通过选择对应选项完成模型 ONNX 格式`xxxx.onnx` 和 TensorRT `.engine`格式的转换。
-如您的自定义 config 文件中有相对引用关系，如：
-
-```python
-# xxxx.py
-_base_ = [
-    '../_base_/models/deeplabv3plus_r50-d8.py',
-    '../_base_/datasets/potsdam.py',
-    '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-```
-
-您可以使用以下代码消除相对引用关系，以生成完整的 config 文件。
-
-```python
-import mmengine
-
-mmengine.Config.fromfile("configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py").dump("My_config.py")
-```
-
-使用上述代码后，您能够看到，在`My_config.py`包含着完整的配置文件，无相对引用。这时，上传模型 config 至网页内对应处。
-
-#### 创建转换任务
-
-按照下图提示及自己的需求，创建转换任务并提交。
-
-<div align="center">
-    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/4918d2f9-d63c-480f-97f1-054529770cfd" alt="NVIDIA-Jetson" width="80%">
-</div>
-
-### 4.2 模型测速
-
-在完成模型转换后可通过**模型测速**界面，完成在真实设备上的模型测速。
-
-#### 创建测速任务
-
-<div align="center">
-    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/27340556-c81a-4ce3-8560-2c4727d3355e" alt="NVIDIA-Jetson" width="100%">
-</div>
-
-<div align="center">
-    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/6f4fc3a9-ba9d-4829-8407-ed1470ba7bf3" alt="NVIDIA-Jetson" width="100%">
-</div>
-
-测速完成后，可在页面生成完整的测速报告。[查看测速报告示例](https://openmmlab-deploee.oss-cn-shanghai.aliyuncs.com/tmp/profile_speed/4352f5.txt)
-
-## 5 通过 OpenMMLab mmdeploy 以命令行将模型转换为ONNX格式
-
-该部分可以通过 mmdeploy 库对 mmseg 训练好的模型进行推理格式的转换。这里给出一个示例，具体文档可见[ mmdeploy 模型转换文档](../../docs/zh_cn/user_guides/5_deployment.md)。
-
-### 5.1 通过源码构建 mmdeploy 库
-
-在您安装 mmsegmentation 库的虚拟环境下，通过 `git clone`命令从 GitHub 克隆 [mmdeploy](https://github.com/open-mmlab/mmdeploy)
-
-### 5.2 模型转换
-
-如您的 config 中含有相对引用，仍需进行消除，如[4.1 模型转换](#4.1-模型转换)所述,
-进入 mmdeploy 文件夹，执行以下命令，即可完成模型转换。
-
-```bash
-python tools/deploy.py \
-    configs/mmseg/segmentation_onnxruntime_static-512x512.py \
-    ../atl_config.py \
-    ../deeplabv3plus_r18-d8_512x512_80k_potsdam_20211219_020601-75fd5bc3.pth \
-    ../2_13_1024_5488_1536_6000.png \
-    --work-dir ../atl_models \
-    --device cpu \
-    --show \
-    --dump-info
-```
-
-```bash
-# 使用方法
-python ./tools/deploy.py \
-    ${部署配置文件路径} \
-    ${模型配置文件路径} \
-    ${模型权重路径} \
-    ${输入图像路径} \
-    --work-dir ${用来保存日志和模型文件路径} \
-    --device ${cpu/cuda:0} \
-    --show \    # 是否显示检测的结果
-    --dump-info # 是否输出 SDK 信息
-
-```
-
-执行成功后，您将能够看到以下提示，即为转换成功。
-
-```bash
-10/08 17:40:44 - mmengine - INFO - visualize pytorch model success.
-10/08 17:40:44 - mmengine - INFO - All process success.
-```
-
-<div align="center">
-    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/b752ccf8-903f-4ad3-ad7c-74fc25cb89a5" alt="NVIDIA-Jetson" width="400">
-</div>
-
-# 6 在 Jetson 平台进行转换及部署
-
-## 6.1 环境准备
-
-参考[如何在 Jetson 模组上安装 MMDeploy](https://github.com/open-mmlab/mmdeploy/blob/main/docs/zh_cn/01-how-to-build/jetsons.md)文档，完成在 Jetson 上的环境准备工作。
-**注**：安装 Pytorch，可查阅 [NVIDIA Jetson Pytorch 安装文档](https://github.com/open-mmlab/mmdeploy/blob/main/docs/zh_cn/01-how-to-build/jetsons.md)安装最新的 Pytorch。
-
-### 6.1.1 创建虚拟环境
-
-```bash
-conda create -n {您虚拟环境的名字} python={python版本}
-```
-
-### 6.1.2 虚拟环境内安装Pytorch
-
-<font color="red">注意：</font>这里不要安装最新的 pytorch 2.0，因为 pyTorch 1.11 是最后一个使用 USE_DISTRIBUTED 构建的wheel，否则会在用mmdeploy进行模型转换的时候提示`AttributeError: module 'torch.distributed' has no attribute 'ReduceOp'`的错误。参考以下链接：https://forums.developer.nvidia.com/t/module-torch-distributed-has-no-attribute-reduceop/256581/6
-下载`torch-1.11.0-cp38-cp38-linux_aarch64.whl`并安装
-
-```bash
-pip install torch-1.11.0-cp38-cp38-linux_aarch64.whl
-```
-
-执行以上命令后，您将能看到以下提示，即为安装成功。
-
-```bash
-Processing ./torch-1.11.0-cp38-cp38-linux_aarch64.whl
-Requirement already satisfied: typing-extensions in /home/sirs/miniconda3/envs/openmmlab/lib/python3.8/site-packages (from torch==1.11.0) (4.7.1)
-Installing collected packages: torch
-Successfully installed torch-1.11.0
-```
-
-### 6.1.3 将 Jetson Pack 自带的 tensorrt 拷贝至虚拟环境下
-
-请参考[配置 TensorRT](https://github.com/open-mmlab/mmdeploy/blob/main/docs/zh_cn/01-how-to-build/jetsons.md#%E9%85%8D%E7%BD%AE-tensorrt)。
-JetPack SDK 自带 TensorRT。 但是为了能够在 Conda 环境中成功导入，我们需要将 TensorRT 拷贝进先前创建的 Conda 环境中。
-
-```bash
-export PYTHON_VERSION=`python3 --version | cut -d' ' -f 2 | cut -d'.' -f1,2`
-cp -r /usr/lib/python${PYTHON_VERSION}/dist-packages/tensorrt* ~/miniconda/envs/{您的虚拟环境名字}/lib/python${PYTHON_VERSION}/site-packages/
-```
-
-### 6.1.4 安装 MMCV
-
-通过`mim install mmcv`或从源码对其进行编译。
-
-```bash
-pip install openmim
-mim install mmcv
-```
-
-或者从源码对其进行编译。
-
-```bash
-sudo apt-get install -y libssl-dev
-git clone https://github.com/open-mmlab/mmcv.git
-cd mmcv
-pip install -e .
-```
-
-<font color="red">注：pytorch版本发生变动后，需要重新编译mmcv。</font>
-
-### 6.1.5 安装 ONNX
-
-<font color="red">注：以下方式二选一</font>
-
-- conda
-  ```bash
-  conda install -c conda-forge onnx
-  ```
-- pip
-  ```bash
-  python3 -m pip install onnx
-  ```
-
-### 6.1.6 安装 ONNX Runtime
-
-根据网页 [ONNX Runtime](https://elinux.org/Jetson_Zoo#ONNX_Runtime) 选择合适的ONNX Runtime版本进行下载安装。
-示例：
-
-```bash
-# Install pip wheel
-$ pip3 install onnxruntime_gpu-1.10.0-cp38-cp38-linux_aarch64.whl
-
-```
-
-## 6.2 在 Jetson AGX Orin 进行模型转换及推理
-
-### 6.2.1 ONNX 模型转换
-
-同[4.1 模型转换](#4.1-模型转换)相同，在 Jetson 平台下进入安装好的虚拟环境，以及mmdeploy 目录，进行模型ONNX转换。
-
-```bash
-python tools/deploy.py \
-    configs/mmseg/segmentation_onnxruntime_static-512x512.py \
-    ../atl_config.py \
-    ../deeplabv3plus_r18-d8_512x512_80k_potsdam_20211219_020601-75fd5bc3.pth \
-    ../2_13_3584_2560_4096_3072.png \
-    --work-dir ../atl_models \
-    --device cpu \
-    --show \
-    --dump-info
-
-```
-
-<font color="red">注：</font> 如果报错提示内容：
-
-```none
-AttributeError: module 'torch.distributed' has no attribute 'ReduceOp'
-```
-
-可参考以下链接进行解决：https://forums.developer.nvidia.com/t/module-torch-distributed-has-no-attribute-reduceop/256581/6，即安装 pytorch 1.11.0 版本。
-
-转换成功后，您将会看到如下信息以及包含 ONNX 模型的文件夹：
-
-```bash
-10/09 19:58:22 - mmengine - INFO - visualize pytorch model success.
-10/09 19:58:22 - mmengine - INFO - All process success.
-```
-
-<div align="center">
-    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/d68f1cf6-0e80-4261-91a3-6046b17de146" alt="NVIDIA-Jetson" width="400">
-    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/70470a39-6a4f-4fd5-a06d-9b9d59a768ef" alt="NVIDIA-Jetson" width="160">
-</div>
-
-### 6.2.2 TensorRT 模型转换
-
-更换部署trt配置文件，进行 TensorRT 模型转换。
-
-```bash
-python tools/deploy.py \
-    configs/mmseg/segmentation_tensorrt_static-512x512.py \
-    ../atl_config.py \
-    ../deeplabv3plus_r18-d8_512x512_80k_potsdam_20211219_020601-75fd5bc3.pth \
-    ../2_13_3584_2560_4096_3072.png \
-    --work-dir ../atl_trt_models \
-    --device cuda:0 \
-    --show \
-    --dump-info
-
-```
-
-转换成功后您将看到以下信息及 TensorRT 模型文件夹：
-
-```bash
-10/09 20:15:50 - mmengine - INFO - visualize pytorch model success.
-10/09 20:15:50 - mmengine - INFO - All process success.
-```
-
-<div align="center">
-    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/2ac1428f-b787-4fdd-beaf-6397e5b21e33" alt="NVIDIA-Jetson" width="340">
-    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/70470a39-6a4f-4fd5-a06d-9b9d59a768ef" alt="NVIDIA-Jetson" width="200">
-</div>
-
-## 6.3 模型测速
-
-执行以下命令完成模型测速，详细内容请查看[ profiler ](https://github.com/open-mmlab/mmdeploy/blob/main/docs/zh_cn/02-how-to-run/useful_tools.md#profiler)
-
-```bash
-python tools/profiler.py \
-    ${DEPLOY_CFG} \
-    ${MODEL_CFG} \
-    ${IMAGE_DIR} \
-    --model ${MODEL} \
-    --device ${DEVICE} \
-    --shape ${SHAPE} \
-    --num-iter ${NUM_ITER} \
-    --warmup ${WARMUP} \
-    --cfg-options ${CFG_OPTIONS} \
-    --batch-size ${BATCH_SIZE} \
-    --img-ext ${IMG_EXT}
-```
-
-示例：
-
-```bash
-python tools/profiler.py \
-    configs/mmseg/segmentation_tensorrt_static-512x512.py \
-    ../atl_config.py \
-    ../atl_demo_img \
-    --model /home/sirs/AI-Tianlong/OpenMMLab/atl_trt_models/end2end.engine \
-    --device cuda:0 \
-    --shape 512x512 \
-    --num-iter 100
-```
-
-测速结果
-
-![image](https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/874e9742-ee10-490c-9e69-17da0096c49b)
-
-## 6.4 模型推理
-
-根据[6.2.2](#6.2.2-TensorRT-模型转换)中生成的TensorRT模型文件夹，进行模型推理。
-
-```python
-from mmdeploy.apis.utils import build_task_processor
-from mmdeploy.utils import get_input_shape, load_config
-import torch
-
-deploy_cfg='./mmdeploy/configs/mmseg/segmentation_tensorrt_static-512x512.py'
-model_cfg='./atl_config.py'
-device='cuda:0'
-backend_model = ['./atl_trt_models/end2end.engine']
-image = './atl_demo_img/2_13_2048_1024_2560_1536.png'
-
-# read deploy_cfg and model_cfg
-deploy_cfg, model_cfg = load_config(deploy_cfg, model_cfg)
-
-# build task and backend model
-task_processor = build_task_processor(model_cfg, deploy_cfg, device)
-model = task_processor.build_backend_model(backend_model)
-
-# process input image
-input_shape = get_input_shape(deploy_cfg)
-model_inputs, _ = task_processor.create_input(image, input_shape)
-
-# do model inference
-with torch.no_grad():
-    result = model.test_step(model_inputs)
-
-# visualize results
-task_processor.visualize(
-    image=image,
-    model=model,
-    result=result[0],
-    window_name='visualize',
-    output_file='./output_segmentation.png')
-```
-
-即可得到推理结果：
-
-<div align="center">
-    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/d0ae1fa8-e223-4b3f-b699-6bfa8db38133" alt="NVIDIA-Jetson" width="40%">
-    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/6d999cbe-2101-4e1b-b4a9-13115c9d1928" alt="NVIDIA-Jetson" width="40%">
-</div>
diff --git a/mmsegmentation/docs/zh_cn/user_guides/index.rst b/mmsegmentation/docs/zh_cn/user_guides/index.rst
deleted file mode 100644
index d0a313d..0000000
--- a/mmsegmentation/docs/zh_cn/user_guides/index.rst
+++ /dev/null
@@ -1,21 +0,0 @@
-训练 & 测试
-**************
-
-.. toctree::
-   :maxdepth: 1
-
-   1_config.md
-   2_dataset_prepare.md
-   3_inference.md
-   4_train_test.md
-
-实用工具
-*************
-
-.. toctree::
-   :maxdepth: 2
-
-   visualization.md
-   useful_tools.md
-   deployment.md
-   visualization_feature_map.md
diff --git a/mmsegmentation/docs/zh_cn/user_guides/useful_tools.md b/mmsegmentation/docs/zh_cn/user_guides/useful_tools.md
deleted file mode 100644
index acbacb9..0000000
--- a/mmsegmentation/docs/zh_cn/user_guides/useful_tools.md
+++ /dev/null
@@ -1,368 +0,0 @@
-## 常用工具（待更新）
-
-除了训练和测试的脚本，我们在 `tools/` 文件夹路径下还提供许多有用的工具。
-
-### 计算参数量（params）和计算量（ FLOPs） (试验性)
-
-我们基于 [flops-counter.pytorch](https://github.com/sovrasov/flops-counter.pytorch)
-提供了一个用于计算给定模型参数量和计算量的脚本。
-
-```shell
-python tools/get_flops.py ${CONFIG_FILE} [--shape ${INPUT_SHAPE}]
-```
-
-您将得到如下的结果：
-
-```none
-==============================
-Input shape: (3, 2048, 1024)
-Flops: 1429.68 GMac
-Params: 48.98 M
-==============================
-```
-
-**注意**: 这个工具仍然是试验性的，我们无法保证数字是正确的。您可以拿这些结果做简单的实验的对照，在写技术文档报告或者论文前您需要再次确认一下。
-
-(1) 计算量与输入的形状有关，而参数量与输入的形状无关，默认的输入形状是 (1, 3, 1280, 800)；
-(2) 一些运算操作，如 GN 和其他定制的运算操作没有加入到计算量的计算中。
-
-### 发布模型
-
-在您上传一个模型到云服务器之前，您需要做以下几步：
-(1) 将模型权重转成 CPU 张量；
-(2) 删除记录优化器状态 (optimizer states)的相关信息；
-(3) 计算检查点文件 (checkpoint file) 的哈希编码（hash id）并且将哈希编码加到文件名中。
-
-```shell
-python tools/publish_model.py ${INPUT_FILENAME} ${OUTPUT_FILENAME}
-```
-
-例如，
-
-```shell
-python tools/publish_model.py work_dirs/pspnet/latest.pth psp_r50_hszhao_200ep.pth
-```
-
-最终输出文件将是 `psp_r50_512x1024_40ki_cityscapes-{hash id}.pth`。
-
-### 导出 ONNX (试验性)
-
-我们提供了一个脚本来导出模型到 [ONNX](https://github.com/onnx/onnx) 格式。被转换的模型可以通过工具 [Netron](https://github.com/lutzroeder/netron)
-来可视化。除此以外，我们同样支持对 PyTorch 和 ONNX 模型的输出结果做对比。
-
-```bash
-python tools/pytorch2onnx.py \
-    ${CONFIG_FILE} \
-    --checkpoint ${CHECKPOINT_FILE} \
-    --output-file ${ONNX_FILE} \
-    --input-img ${INPUT_IMG} \
-    --shape ${INPUT_SHAPE} \
-    --rescale-shape ${RESCALE_SHAPE} \
-    --show \
-    --verify \
-    --dynamic-export \
-    --cfg-options \
-      model.test_cfg.mode="whole"
-```
-
-各个参数的描述:
-
-- `config` : 模型配置文件的路径
-- `--checkpoint` : 模型检查点文件的路径
-- `--output-file`: 输出的 ONNX 模型的路径。如果没有专门指定，它默认是 `tmp.onnx`
-- `--input-img` : 用来转换和可视化的一张输入图像的路径
-- `--shape`: 模型的输入张量的高和宽。如果没有专门指定，它将被设置成 `test_pipeline` 的 `img_scale`
-- `--rescale-shape`: 改变输出的形状。设置这个值来避免 OOM，它仅在 `slide` 模式下可以用
-- `--show`: 是否打印输出模型的结构。如果没有被专门指定，它将被设置成 `False`
-- `--verify`: 是否验证一个输出模型的正确性 (correctness)。如果没有被专门指定，它将被设置成 `False`
-- `--dynamic-export`: 是否导出形状变化的输入与输出的 ONNX 模型。如果没有被专门指定，它将被设置成 `False`
-- `--cfg-options`: 更新配置选项
-
-**注意**: 这个工具仍然是试验性的，目前一些自定义操作还没有被支持
-
-### 评估 ONNX 模型
-
-我们提供 `tools/deploy_test.py` 去评估不同后端的 ONNX 模型。
-
-#### 先决条件
-
-- 安装 onnx 和 onnxruntime-gpu
-
-  ```shell
-  pip install onnx onnxruntime-gpu
-  ```
-
-- 参考 [如何在 MMCV 里构建 tensorrt 插件](https://mmcv.readthedocs.io/en/latest/tensorrt_plugin.html#how-to-build-tensorrt-plugins-in-mmcv) 安装TensorRT (可选)
-
-#### 使用方法
-
-```bash
-python tools/deploy_test.py \
-    ${CONFIG_FILE} \
-    ${MODEL_FILE} \
-    ${BACKEND} \
-    --out ${OUTPUT_FILE} \
-    --eval ${EVALUATION_METRICS} \
-    --show \
-    --show-dir ${SHOW_DIRECTORY} \
-    --cfg-options ${CFG_OPTIONS} \
-    --eval-options ${EVALUATION_OPTIONS} \
-    --opacity ${OPACITY} \
-```
-
-各个参数的描述:
-
-- `config`: 模型配置文件的路径
-- `model`: 被转换的模型文件的路径
-- `backend`: 推理的后端，可选项：`onnxruntime`， `tensorrt`
-- `--out`: 输出结果成 pickle 格式文件的路径
-- `--format-only` : 不评估直接给输出结果的格式。通常用在当您想把结果输出成一些测试服务器需要的特定格式时。如果没有被专门指定，它将被设置成 `False`。 注意这个参数是用 `--eval` 来 **手动添加**
-- `--eval`: 评估指标，取决于每个数据集的要求，例如 "mIoU" 是大多数据集的指标而 "cityscapes" 仅针对 Cityscapes 数据集。注意这个参数是用 `--format-only` 来 **手动添加**
-- `--show`: 是否展示结果
-- `--show-dir`: 涂上结果的图像被保存的文件夹的路径
-- `--cfg-options`: 重写配置文件里的一些设置，`xxx=yyy` 格式的键值对将被覆盖到配置文件里
-- `--eval-options`: 自定义的评估的选项， `xxx=yyy` 格式的键值对将成为  `dataset.evaluate()` 函数的参数变量
-- `--opacity`: 涂上结果的分割图的透明度，范围在 (0, 1\] 之间
-
-#### 结果和模型
-
-|    模型    |                    配置文件                     |   数据集   | 评价指标 | PyTorch | ONNXRuntime | TensorRT-fp32 | TensorRT-fp16 |
-| :--------: | :---------------------------------------------: | :--------: | :------: | :-----: | :---------: | :-----------: | :-----------: |
-|    FCN     |      fcn_r50-d8_512x1024_40k_cityscapes.py      | cityscapes |   mIoU   |  72.2   |    72.2     |     72.2      |     72.2      |
-|   PSPNet   |    pspnet_r50-d8_512x1024_40k_cityscapes.py     | cityscapes |   mIoU   |  77.8   |    77.8     |     77.8      |     77.8      |
-| deeplabv3  |   deeplabv3_r50-d8_512x1024_40k_cityscapes.py   | cityscapes |   mIoU   |  79.0   |    79.0     |     79.0      |     79.0      |
-| deeplabv3+ | deeplabv3plus_r50-d8_512x1024_40k_cityscapes.py | cityscapes |   mIoU   |  79.6   |    79.5     |     79.5      |     79.5      |
-|   PSPNet   |     pspnet_r50-d8_769x769_40k_cityscapes.py     | cityscapes |   mIoU   |  78.2   |    78.1     |               |               |
-| deeplabv3  |   deeplabv3_r50-d8_769x769_40k_cityscapes.py    | cityscapes |   mIoU   |  78.5   |    78.3     |               |               |
-| deeplabv3+ | deeplabv3plus_r50-d8_769x769_40k_cityscapes.py  | cityscapes |   mIoU   |  78.9   |    78.7     |               |               |
-
-**注意**: TensorRT 仅在使用 `whole mode` 测试模式时的配置文件里可用。
-
-### 导出 TorchScript (试验性)
-
-我们同样提供一个脚本去把模型导出成 [TorchScript](https://pytorch.org/docs/stable/jit.html) 格式。您可以使用 pytorch C++ API [LibTorch](https://pytorch.org/docs/stable/cpp_index.html) 去推理训练好的模型。
-被转换的模型能被像 [Netron](https://github.com/lutzroeder/netron) 的工具来可视化。此外，我们还支持 PyTorch 和 TorchScript 模型的输出结果的比较。
-
-```shell
-python tools/pytorch2torchscript.py \
-    ${CONFIG_FILE} \
-    --checkpoint ${CHECKPOINT_FILE} \
-    --output-file ${ONNX_FILE}
-    --shape ${INPUT_SHAPE}
-    --verify \
-    --show
-```
-
-各个参数的描述:
-
-- `config` : pytorch 模型的配置文件的路径
-- `--checkpoint` : pytorch 模型的检查点文件的路径
-- `--output-file`: TorchScript 模型输出的路径，如果没有被专门指定，它将被设置成 `tmp.pt`
-- `--input-img` : 用来转换和可视化的输入图像的路径
-- `--shape`: 模型的输入张量的宽和高。如果没有被专门指定，它将被设置成 `512 512`
-- `--show`: 是否打印输出模型的追踪图 (traced graph)，如果没有被专门指定，它将被设置成 `False`
-- `--verify`: 是否验证一个输出模型的正确性 (correctness)，如果没有被专门指定，它将被设置成 `False`
-
-**注意**: 目前仅支持 PyTorch>=1.8.0 版本
-
-**注意**: 这个工具仍然是试验性的，一些自定义操作符目前还不被支持
-
-例子:
-
-- 导出 PSPNet 在 cityscapes 数据集上的 pytorch 模型
-
-  ```shell
-  python tools/pytorch2torchscript.py configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py \
-  --checkpoint checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth \
-  --output-file checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pt \
-  --shape 512 1024
-  ```
-
-### 导出 TensorRT (试验性)
-
-一个导出 [ONNX](https://github.com/onnx/onnx) 模型成 [TensorRT](https://developer.nvidia.com/tensorrt) 格式的脚本
-
-先决条件
-
-- 按照 [ONNXRuntime in mmcv](https://mmcv.readthedocs.io/en/latest/deployment/onnxruntime_op.html) 和 [TensorRT plugin in mmcv](https://github.com/open-mmlab/mmcv/blob/master/docs/en/deployment/tensorrt_plugin.md) ，用 ONNXRuntime 自定义运算 (custom ops) 和 TensorRT 插件安装 `mmcv-full`
-- 使用 [pytorch2onnx](#convert-to-onnx-experimental) 将模型从 PyTorch 转成 ONNX
-
-使用方法
-
-```bash
-python ${MMSEG_PATH}/tools/onnx2tensorrt.py \
-    ${CFG_PATH} \
-    ${ONNX_PATH} \
-    --trt-file ${OUTPUT_TRT_PATH} \
-    --min-shape ${MIN_SHAPE} \
-    --max-shape ${MAX_SHAPE} \
-    --input-img ${INPUT_IMG} \
-    --show \
-    --verify
-```
-
-各个参数的描述:
-
-- `config` : 模型的配置文件
-- `model` : 输入的 ONNX 模型的路径
-- `--trt-file` : 输出的 TensorRT 引擎的路径
-- `--max-shape` : 模型的输入的最大形状
-- `--min-shape` : 模型的输入的最小形状
-- `--fp16` : 做 fp16 模型转换
-- `--workspace-size` : 在 GiB 里的最大工作空间大小 (Max workspace size)
-- `--input-img` : 用来可视化的图像
-- `--show` : 做结果的可视化
-- `--dataset` : Palette provider, 默认为 `CityscapesDataset`
-- `--verify` : 验证 ONNXRuntime 和 TensorRT 的输出
-- `--verbose` : 当创建 TensorRT 引擎时，是否详细做信息日志。默认为 False
-
-**注意**: 仅在全图测试模式 (whole mode) 下测试过
-
-## 其他内容
-
-### 打印完整的配置文件
-
-`tools/print_config.py` 会逐字逐句的打印整个配置文件，展开所有的导入。
-
-```shell
-python tools/print_config.py \
-  ${CONFIG} \
-  --graph \
-  --cfg-options ${OPTIONS [OPTIONS...]} \
-```
-
-各个参数的描述:
-
-- `config` : pytorch 模型的配置文件的路径
-- `--graph` : 是否打印模型的图 (models graph)
-- `--cfg-options`: 自定义替换配置文件的选项
-
-### 对训练日志 (training logs) 画图
-
-`tools/analyze_logs.py` 会画出给定的训练日志文件的 loss/mIoU 曲线，首先需要 `pip install seaborn` 安装依赖包。
-
-```shell
-python tools/analyze_logs.py xxx.log.json [--keys ${KEYS}] [--legend ${LEGEND}] [--backend ${BACKEND}] [--style ${STYLE}] [--out ${OUT_FILE}]
-```
-
-示例:
-
-- 对 mIoU, mAcc, aAcc 指标画图
-
-  ```shell
-  python tools/analyze_logs.py log.json --keys mIoU mAcc aAcc --legend mIoU mAcc aAcc
-  ```
-
-- 对 loss 指标画图
-
-  ```shell
-  python tools/analyze_logs.py log.json --keys loss --legend loss
-  ```
-
-### 转换其他仓库的权重
-
-`tools/model_converters/` 提供了若干个预训练权重转换脚本，支持将其他仓库的预训练权重的 key 转换为与 MMSegmentation 相匹配的 key。
-
-#### ViT Swin MiT Transformer 模型
-
-- ViT
-
-`tools/model_converters/vit2mmseg.py` 将 timm 预训练模型转换到 MMSegmentation。
-
-```shell
-python tools/model_converters/vit2mmseg.py ${SRC} ${DST}
-```
-
-- Swin
-
-  `tools/model_converters/swin2mmseg.py` 将官方预训练模型转换到 MMSegmentation。
-
-  ```shell
-  python tools/model_converters/swin2mmseg.py ${SRC} ${DST}
-  ```
-
-- SegFormer
-
-  `tools/model_converters/mit2mmseg.py` 将官方预训练模型转换到 MMSegmentation。
-
-  ```shell
-  python tools/model_converters/mit2mmseg.py ${SRC} ${DST}
-  ```
-
-## 模型服务
-
-为了用 [`TorchServe`](https://pytorch.org/serve/) 服务 `MMSegmentation` 的模型 ， 您可以遵循如下流程:
-
-### 1. 将 model 从　MMSegmentation 转换到 TorchServe
-
-```shell
-python tools/mmseg2torchserve.py ${CONFIG_FILE} ${CHECKPOINT_FILE} \
---output-folder ${MODEL_STORE} \
---model-name ${MODEL_NAME}
-```
-
-**注意**: ${MODEL_STORE} 需要设置为某个文件夹的绝对路径
-
-### 2. 构建 `mmseg-serve` 容器镜像 (docker image)
-
-```shell
-docker build -t mmseg-serve:latest docker/serve/
-```
-
-### 3. 运行 `mmseg-serve`
-
-请查阅官方文档: [使用容器运行 TorchServe](https://github.com/pytorch/serve/blob/master/docker/README.md#running-torchserve-in-a-production-docker-environment)
-
-为了在 GPU 环境下使用, 您需要安装 [nvidia-docker](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html). 若在 CPU 环境下使用，您可以忽略添加 `--gpus` 参数。
-
-示例:
-
-```shell
-docker run --rm \
---cpus 8 \
---gpus device=0 \
--p8080:8080 -p8081:8081 -p8082:8082 \
---mount type=bind,source=$MODEL_STORE,target=/home/model-server/model-store \
-mmseg-serve:latest
-```
-
-阅读关于推理 (8080), 管理 (8081) 和指标 (8082) APIs 的 [文档](https://github.com/pytorch/serve/blob/072f5d088cce9bb64b2a18af065886c9b01b317b/docs/rest_api.md) 。
-
-### 4. 测试部署
-
-```shell
-curl -O https://raw.githubusercontent.com/open-mmlab/mmsegmentation/master/resources/3dogs.jpg
-curl http://127.0.0.1:8080/predictions/${MODEL_NAME} -T 3dogs.jpg -o 3dogs_mask.png
-```
-
-得到的响应将是一个 ".png" 的分割掩码.
-
-您可以按照如下方法可视化输出:
-
-```python
-import matplotlib.pyplot as plt
-import mmcv
-plt.imshow(mmcv.imread("3dogs_mask.png", "grayscale"))
-plt.show()
-```
-
-看到的东西将会和下图类似:
-
-![3dogs_mask](../../resources/3dogs_mask.png)
-
-然后您可以使用 `test_torchserve.py` 比较 torchserve 和 pytorch 的结果，并将它们可视化。
-
-```shell
-python tools/torchserve/test_torchserve.py ${IMAGE_FILE} ${CONFIG_FILE} ${CHECKPOINT_FILE} ${MODEL_NAME}
-[--inference-addr ${INFERENCE_ADDR}] [--result-image ${RESULT_IMAGE}] [--device ${DEVICE}]
-```
-
-示例：
-
-```shell
-python tools/torchserve/test_torchserve.py \
-demo/demo.png \
-configs/fcn/fcn_r50-d8_512x1024_40k_cityscapes.py \
-checkpoint/fcn_r50-d8_512x1024_40k_cityscapes_20200604_192608-efe53f0d.pth \
-fcn
-```
diff --git a/mmsegmentation/docs/zh_cn/user_guides/visualization.md b/mmsegmentation/docs/zh_cn/user_guides/visualization.md
deleted file mode 100644
index 2ef020b..0000000
--- a/mmsegmentation/docs/zh_cn/user_guides/visualization.md
+++ /dev/null
@@ -1,173 +0,0 @@
-# 可视化
-
-MMSegmentation 1.x 提供了简便的方式监控训练时的状态以及可视化在模型预测时的数据。
-
-## 训练状态监控
-
-MMSegmentation 1.x 使用 TensorBoard 来监控训练时候的状态。
-
-### TensorBoard 的配置
-
-安装 TensorBoard 的过程可以按照 [官方安装指南](https://www.tensorflow.org/install) ，具体的步骤如下：
-
-```shell
-pip install tensorboardX
-pip install future tensorboard
-```
-
-在配置文件 `default_runtime.py` 的 `vis_backend` 中添加 `TensorboardVisBackend`。
-
-```python
-vis_backends = [dict(type='LocalVisBackend'),
-                dict(type='TensorboardVisBackend')]
-visualizer = dict(
-    type='SegLocalVisualizer', vis_backends=vis_backends, name='visualizer')
-```
-
-### 检查 TensorBoard 中的标量
-
-启动训练实验的命令如下
-
-```shell
-python tools/train.py configs/pspnet/pspnet_r50-d8_4xb4-80k_ade20k-512x512.py --work-dir work_dir/test_visual
-```
-
-开始训练后找到 `work_dir` 中的 `vis_data` 路径，例如：本次特定测试的 vis_data 路径如下所示：
-
-```shell
-work_dirs/test_visual/20220810_115248/vis_data
-```
-
-vis_data 路径中的标量文件包括了学习率、损失函数和 data_time 等，还记录了指标结果，您可以参考 MMEngine 中的 [记录日志教程](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/logging.html) 中的日志教程来帮助记录自己定义的数据。 Tensorboard 的可视化结果使用下面的命令执行：
-
-```shell
-tensorboard --logdir work_dirs/test_visual/20220810_115248/vis_data
-```
-
-## 数据和结果的可视化
-
-### 模型测试或验证期间的可视化数据样本
-
-MMSegmentation 提供了 `SegVisualizationHook` ，它是一个可以用于可视化 ground truth 和在模型测试和验证期间的预测分割结果的[钩子](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/hook.html) 。 它的配置在 `default_hooks` 中，更多详细信息请参见 [执行器教程](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/runner.html)。
-
-例如，在 `_base_/schedules/schedule_20k.py` 中，修改 `SegVisualizationHook` 配置，将 `draw` 设置为 `True` 以启用网络推理结果的存储，`interval` 表示预测结果的采样间隔， 设置为 1 时，将保存网络的每个推理结果。 `interval` 默认设置为 50：
-
-```python
-default_hooks = dict(
-    timer=dict(type='IterTimerHook'),
-    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
-    param_scheduler=dict(type='ParamSchedulerHook'),
-    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=2000),
-    sampler_seed=dict(type='DistSamplerSeedHook'),
-    visualization=dict(type='SegVisualizationHook', draw=True, interval=1))
-
-```
-
-启动训练实验后，可视化结果将在 validation loop 存储到本地文件夹中，或者在一个数据集上启动评估模型时，预测结果将存储在本地。本地的可视化的存储结果保存在 `$WORK_DIRS/vis_data` 下的 `vis_image` 中，例如：
-
-```shell
-work_dirs/test_visual/20220810_115248/vis_data/vis_image
-```
-
-另外，如果在 `vis_backends` 中添加 `TensorboardVisBackend` ，如 [TensorBoard 的配置](###TensorBoard的配置)，我们还可以运行下面的命令在 TensorBoard 中查看它们：
-
-```shell
-tensorboard --logdir work_dirs/test_visual/20220810_115248/vis_data
-```
-
-### 可视化单个数据样本
-
-如果你想可视化单个样本数据，我们建议使用 `SegLocalVisualizer` 。
-
-`SegLocalVisualizer`是继承自 MMEngine 中`Visualizer` 类的子类，适用于 MMSegmentation 可视化，有关`Visualizer`的详细信息请参考在 MMEngine 中的[可视化教程](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/visualization.html) 。
-
-以下是一个关于 `SegLocalVisualizer` 的示例，首先你可以使用下面的命令下载这个案例中的数据：
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/189833109-eddad58f-f777-4fc0-b98a-6bd429143b06.png" width="70%"/>
-</div>
-
-```shell
-wget https://user-images.githubusercontent.com/24582831/189833109-eddad58f-f777-4fc0-b98a-6bd429143b06.png --output-document aachen_000000_000019_leftImg8bit.png
-wget https://user-images.githubusercontent.com/24582831/189833143-15f60f8a-4d1e-4cbb-a6e7-5e2233869fac.png --output-document aachen_000000_000019_gtFine_labelTrainIds.png
-```
-
-然后你可以找到他们本地的路径和使用下面的脚本文件对其进行可视化：
-
-```python
-import mmcv
-import os.path as osp
-import torch
-
-# `PixelData` 是 MMEngine 中用于定义像素级标注或预测的数据结构。
-# 请参考下面的MMEngine数据结构教程文件：
-# https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/data_element.html#pixeldata
-
-from mmengine.structures import PixelData
-
-# `SegDataSample` 是在 MMSegmentation 中定义的不同组件之间的数据结构接口，
-# 它包括 ground truth、语义分割的预测结果和预测逻辑。
-# 详情请参考下面的 `SegDataSample` 教程文件：
-# https://github.com/open-mmlab/mmsegmentation/blob/1.x/docs/en/advanced_guides/structures.md
-
-from mmseg.structures import SegDataSample
-from mmseg.visualization import SegLocalVisualizer
-
-out_file = 'out_file_cityscapes'
-save_dir = './work_dirs'
-
-image = mmcv.imread(
-    osp.join(
-        osp.dirname(__file__),
-        './aachen_000000_000019_leftImg8bit.png'
-    ),
-    'color')
-sem_seg = mmcv.imread(
-    osp.join(
-        osp.dirname(__file__),
-        './aachen_000000_000019_gtFine_labelTrainIds.png'  # noqa
-    ),
-    'unchanged')
-sem_seg = torch.from_numpy(sem_seg)
-gt_sem_seg_data = dict(data=sem_seg)
-gt_sem_seg = PixelData(**gt_sem_seg_data)
-data_sample = SegDataSample()
-data_sample.gt_sem_seg = gt_sem_seg
-
-seg_local_visualizer = SegLocalVisualizer(
-    vis_backends=[dict(type='LocalVisBackend')],
-    save_dir=save_dir)
-
-# 数据集的元信息通常包括类名的 `classes` 和
-# 用于可视化每个前景颜色的 `palette` 。
-# 所有类名和调色板都在此文件中定义：
-# https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/utils/class_names.py
-
-seg_local_visualizer.dataset_meta = dict(
-    classes=('road', 'sidewalk', 'building', 'wall', 'fence',
-             'pole', 'traffic light', 'traffic sign',
-             'vegetation', 'terrain', 'sky', 'person', 'rider',
-             'car', 'truck', 'bus', 'train', 'motorcycle',
-             'bicycle'),
-    palette=[[128, 64, 128], [244, 35, 232], [70, 70, 70],
-             [102, 102, 156], [190, 153, 153], [153, 153, 153],
-             [250, 170, 30], [220, 220, 0], [107, 142, 35],
-             [152, 251, 152], [70, 130, 180], [220, 20, 60],
-             [255, 0, 0], [0, 0, 142], [0, 0, 70],
-             [0, 60, 100], [0, 80, 100], [0, 0, 230],
-             [119, 11, 32]])
-
-# 当`show=True`时，直接显示结果，
-# 当 `show=False`时，结果将保存在本地文件夹中。
-
-seg_local_visualizer.add_datasample(out_file, image,
-                                    data_sample, show=False)
-```
-
-可视化后的图像结果和它的对应的 ground truth 图像可以在 `./work_dirs/vis_data/vis_image/` 路径找到，文件名字是：`out_file_cityscapes_0.png` ：
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/189835713-c0534054-4bfa-4b75-9254-0afbeb5ff02e.png" width="70%"/>
-</div>
-
-如果你想知道更多的关于可视化的使用指引，你可以参考 MMEngine 中的[可视化教程](<[https://mmengine.readthedocs.io/en/latest/advanced_tutorials/visualization.html](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/advanced_tutorials/visualization.md)>)
diff --git a/mmsegmentation/docs/zh_cn/user_guides/visualization_feature_map.md b/mmsegmentation/docs/zh_cn/user_guides/visualization_feature_map.md
deleted file mode 100644
index fda99bb..0000000
--- a/mmsegmentation/docs/zh_cn/user_guides/visualization_feature_map.md
+++ /dev/null
@@ -1,201 +0,0 @@
-# wandb记录特征图可视化
-
-MMSegmentation 1.x 提供了 Weights & Biases 的后端支持，方便对项目代码结果的可视化和管理。
-
-## Wandb的配置
-
-安装 Weights & Biases 的过程可以参考 [官方安装指南](https://docs.wandb.ai/quickstart)，具体的步骤如下:
-
-```shell
-pip install wandb
-wandb login
-```
-
-在 `vis_backend` 中添加 `WandbVisBackend`。
-
-```python
-vis_backends=[dict(type='LocalVisBackend'),
-              dict(type='TensorboardVisBackend'),
-              dict(type='WandbVisBackend')]
-```
-
-## 测试数据和结果及特征图的可视化
-
-`SegLocalVisualizer` 是继承自 MMEngine 中 `Visualizer` 类的子类，适用于 MMSegmentation 可视化，有关 `Visualizer` 的详细信息请参考在 MMEngine 中的[可视化教程](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/visualization.html) 。
-
-以下是一个关于 `SegLocalVisualizer` 的示例，首先你可以使用下面的命令下载这个案例中的数据：
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/24582831/189833109-eddad58f-f777-4fc0-b98a-6bd429143b06.png" width="70%"/>
-</div>
-
-```shell
-wget https://user-images.githubusercontent.com/24582831/189833109-eddad58f-f777-4fc0-b98a-6bd429143b06.png --output-document aachen_000000_000019_leftImg8bit.png
-wget https://user-images.githubusercontent.com/24582831/189833143-15f60f8a-4d1e-4cbb-a6e7-5e2233869fac.png --output-document aachen_000000_000019_gtFine_labelTrainIds.png
-
-wget https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x1024_40k_cityscapes/ann_r50-d8_512x1024_40k_cityscapes_20200605_095211-049fc292.pth
-
-```
-
-```python
-# Copyright (c) OpenMMLab. All rights reserved.
-from argparse import ArgumentParser
-from typing import Type
-
-import mmcv
-import torch
-import torch.nn as nn
-
-from mmengine.model import revert_sync_batchnorm
-from mmengine.structures import PixelData
-from mmseg.apis import inference_model, init_model
-from mmseg.structures import SegDataSample
-from mmseg.utils import register_all_modules
-from mmseg.visualization import SegLocalVisualizer
-
-
-class Recorder:
-    """record the forward output feature map and save to data_buffer."""
-
-    def __init__(self) -> None:
-        self.data_buffer = list()
-
-    def __enter__(self, ):
-        self._data_buffer = list()
-
-    def record_data_hook(self, model: nn.Module, input: Type, output: Type):
-        self.data_buffer.append(output)
-
-    def __exit__(self, *args, **kwargs):
-        pass
-
-
-def visualize(args, model, recorder, result):
-    seg_visualizer = SegLocalVisualizer(
-        vis_backends=[dict(type='WandbVisBackend')],
-        save_dir='temp_dir',
-        alpha=0.5)
-    seg_visualizer.dataset_meta = dict(
-        classes=model.dataset_meta['classes'],
-        palette=model.dataset_meta['palette'])
-
-    image = mmcv.imread(args.img, 'color')
-
-    seg_visualizer.add_datasample(
-        name='predict',
-        image=image,
-        data_sample=result,
-        draw_gt=False,
-        draw_pred=True,
-        wait_time=0,
-        out_file=None,
-        show=False)
-
-    # add feature map to wandb visualizer
-    for i in range(len(recorder.data_buffer)):
-        feature = recorder.data_buffer[i][0]  # remove the batch
-        drawn_img = seg_visualizer.draw_featmap(
-            feature, image, channel_reduction='select_max')
-        seg_visualizer.add_image(f'feature_map{i}', drawn_img)
-
-    if args.gt_mask:
-        sem_seg = mmcv.imread(args.gt_mask, 'unchanged')
-        sem_seg = torch.from_numpy(sem_seg)
-        gt_mask = dict(data=sem_seg)
-        gt_mask = PixelData(**gt_mask)
-        data_sample = SegDataSample()
-        data_sample.gt_sem_seg = gt_mask
-
-        seg_visualizer.add_datasample(
-            name='gt_mask',
-            image=image,
-            data_sample=data_sample,
-            draw_gt=True,
-            draw_pred=False,
-            wait_time=0,
-            out_file=None,
-            show=False)
-
-    seg_visualizer.add_image('image', image)
-
-
-def main():
-    parser = ArgumentParser(
-        description='Draw the Feature Map During Inference')
-    parser.add_argument('img', help='Image file')
-    parser.add_argument('config', help='Config file')
-    parser.add_argument('checkpoint', help='Checkpoint file')
-    parser.add_argument('--gt_mask', default=None, help='Path of gt mask file')
-    parser.add_argument('--out-file', default=None, help='Path to output file')
-    parser.add_argument(
-        '--device', default='cuda:0', help='Device used for inference')
-    parser.add_argument(
-        '--opacity',
-        type=float,
-        default=0.5,
-        help='Opacity of painted segmentation map. In (0, 1] range.')
-    parser.add_argument(
-        '--title', default='result', help='The image identifier.')
-    args = parser.parse_args()
-
-    register_all_modules()
-
-    # build the model from a config file and a checkpoint file
-    model = init_model(args.config, args.checkpoint, device=args.device)
-    if args.device == 'cpu':
-        model = revert_sync_batchnorm(model)
-
-    # show all named module in the model and use it in source list below
-    for name, module in model.named_modules():
-        print(name)
-
-    source = [
-        'decode_head.fusion.stages.0.query_project.activate',
-        'decode_head.context.stages.0.key_project.activate',
-        'decode_head.context.bottleneck.activate'
-    ]
-    source = dict.fromkeys(source)
-
-    count = 0
-    recorder = Recorder()
-    # registry the forward hook
-    for name, module in model.named_modules():
-        if name in source:
-            count += 1
-            module.register_forward_hook(recorder.record_data_hook)
-            if count == len(source):
-                break
-
-    with recorder:
-        # test a single image, and record feature map to data_buffer
-        result = inference_model(model, args.img)
-
-    visualize(args, model, recorder, result)
-
-
-if __name__ == '__main__':
-    main()
-
-```
-
-将上述代码保存为 feature_map_visual.py，在终端执行如下代码
-
-```shell
-python feature_map_visual.py ${图像} ${配置文件} ${检查点文件} [可选参数]
-```
-
-样例
-
-```shell
-python feature_map_visual.py \
-aachen_000000_000019_leftImg8bit.png \
-configs/ann/ann_r50-d8_4xb2-40k_cityscapes-512x1024.py \
-ann_r50-d8_512x1024_40k_cityscapes_20200605_095211-049fc292.pth \
---gt_mask aachen_000000_000019_gtFine_labelTrainIds.png
-```
-
-可视化后的图像结果和它的对应的 feature map图像会出现在wandb账户中
-
-<div align=center>
-<img src="https://user-images.githubusercontent.com/76149310/217520321-647f5bf9-eef2-446d-a9e8-5ca7b621d500.png">
-</div>
diff --git a/mmsegmentation/mmseg/apis/__init__.py b/mmsegmentation/mmseg/apis/__init__.py
deleted file mode 100644
index b50a266..0000000
--- a/mmsegmentation/mmseg/apis/__init__.py
+++ /dev/null
@@ -1,9 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .inference import inference_model, init_model, show_result_pyplot
-from .mmseg_inferencer import MMSegInferencer
-from .remote_sense_inferencer import RSImage, RSInferencer
-
-__all__ = [
-    'init_model', 'inference_model', 'show_result_pyplot', 'MMSegInferencer',
-    'RSInferencer', 'RSImage'
-]
diff --git a/mmsegmentation/mmseg/apis/inference.py b/mmsegmentation/mmseg/apis/inference.py
deleted file mode 100644
index aab11d1..0000000
--- a/mmsegmentation/mmseg/apis/inference.py
+++ /dev/null
@@ -1,189 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import warnings
-from pathlib import Path
-from typing import Optional, Union
-
-import mmcv
-import numpy as np
-import torch
-from mmengine import Config
-from mmengine.registry import init_default_scope
-from mmengine.runner import load_checkpoint
-from mmengine.utils import mkdir_or_exist
-
-from mmseg.models import BaseSegmentor
-from mmseg.registry import MODELS
-from mmseg.structures import SegDataSample
-from mmseg.utils import SampleList, dataset_aliases, get_classes, get_palette
-from mmseg.visualization import SegLocalVisualizer
-from .utils import ImageType, _preprare_data
-
-
-def init_model(config: Union[str, Path, Config],
-               checkpoint: Optional[str] = None,
-               device: str = 'cuda:0',
-               cfg_options: Optional[dict] = None):
-    """Initialize a segmentor from config file.
-
-    Args:
-        config (str, :obj:`Path`, or :obj:`mmengine.Config`): Config file path,
-            :obj:`Path`, or the config object.
-        checkpoint (str, optional): Checkpoint path. If left as None, the model
-            will not load any weights.
-        device (str, optional) CPU/CUDA device option. Default 'cuda:0'.
-            Use 'cpu' for loading model on CPU.
-        cfg_options (dict, optional): Options to override some settings in
-            the used config.
-    Returns:
-        nn.Module: The constructed segmentor.
-    """
-    if isinstance(config, (str, Path)):
-        config = Config.fromfile(config)
-    elif not isinstance(config, Config):
-        raise TypeError('config must be a filename or Config object, '
-                        'but got {}'.format(type(config)))
-    if cfg_options is not None:
-        config.merge_from_dict(cfg_options)
-    if config.model.type == 'EncoderDecoder':
-        if 'init_cfg' in config.model.backbone:
-            config.model.backbone.init_cfg = None
-    elif config.model.type == 'MultimodalEncoderDecoder':
-        for k, v in config.model.items():
-            if isinstance(v, dict) and 'init_cfg' in v:
-                config.model[k].init_cfg = None
-    config.model.pretrained = None
-    config.model.train_cfg = None
-    init_default_scope(config.get('default_scope', 'mmseg'))
-
-    model = MODELS.build(config.model)
-    if checkpoint is not None:
-        checkpoint = load_checkpoint(model, checkpoint, map_location='cpu')
-        dataset_meta = checkpoint['meta'].get('dataset_meta', None)
-        # save the dataset_meta in the model for convenience
-        if 'dataset_meta' in checkpoint.get('meta', {}):
-            # mmseg 1.x
-            model.dataset_meta = dataset_meta
-        elif 'CLASSES' in checkpoint.get('meta', {}):
-            # < mmseg 1.x
-            classes = checkpoint['meta']['CLASSES']
-            palette = checkpoint['meta']['PALETTE']
-            model.dataset_meta = {'classes': classes, 'palette': palette}
-        else:
-            warnings.simplefilter('once')
-            warnings.warn(
-                'dataset_meta or class names are not saved in the '
-                'checkpoint\'s meta data, classes and palette will be'
-                'set according to num_classes ')
-            num_classes = model.decode_head.num_classes
-            dataset_name = None
-            for name in dataset_aliases.keys():
-                if len(get_classes(name)) == num_classes:
-                    dataset_name = name
-                    break
-            if dataset_name is None:
-                warnings.warn(
-                    'No suitable dataset found, use Cityscapes by default')
-                dataset_name = 'cityscapes'
-            model.dataset_meta = {
-                'classes': get_classes(dataset_name),
-                'palette': get_palette(dataset_name)
-            }
-    model.cfg = config  # save the config in the model for convenience
-    model.to(device)
-    model.eval()
-    return model
-
-
-def inference_model(model: BaseSegmentor,
-                    img: ImageType) -> Union[SegDataSample, SampleList]:
-    """Inference image(s) with the segmentor.
-
-    Args:
-        model (nn.Module): The loaded segmentor.
-        imgs (str/ndarray or list[str/ndarray]): Either image files or loaded
-            images.
-
-    Returns:
-        :obj:`SegDataSample` or list[:obj:`SegDataSample`]:
-        If imgs is a list or tuple, the same length list type results
-        will be returned, otherwise return the segmentation results directly.
-    """
-    # prepare data
-    data, is_batch = _preprare_data(img, model)
-
-    # forward the model
-    with torch.no_grad():
-        results = model.test_step(data)
-
-    return results if is_batch else results[0]
-
-
-def show_result_pyplot(model: BaseSegmentor,
-                       img: Union[str, np.ndarray],
-                       result: SegDataSample,
-                       opacity: float = 0.5,
-                       title: str = '',
-                       draw_gt: bool = True,
-                       draw_pred: bool = True,
-                       wait_time: float = 0,
-                       show: bool = True,
-                       with_labels: Optional[bool] = True,
-                       save_dir=None,
-                       out_file=None):
-    """Visualize the segmentation results on the image.
-
-    Args:
-        model (nn.Module): The loaded segmentor.
-        img (str or np.ndarray): Image filename or loaded image.
-        result (SegDataSample): The prediction SegDataSample result.
-        opacity(float): Opacity of painted segmentation map.
-            Default 0.5. Must be in (0, 1] range.
-        title (str): The title of pyplot figure.
-            Default is ''.
-        draw_gt (bool): Whether to draw GT SegDataSample. Default to True.
-        draw_pred (bool): Whether to draw Prediction SegDataSample.
-            Defaults to True.
-        wait_time (float): The interval of show (s). 0 is the special value
-            that means "forever". Defaults to 0.
-        show (bool): Whether to display the drawn image.
-            Default to True.
-        with_labels(bool, optional): Add semantic labels in visualization
-            result, Default to True.
-        save_dir (str, optional): Save file dir for all storage backends.
-            If it is None, the backend storage will not save any data.
-        out_file (str, optional): Path to output file. Default to None.
-
-
-
-    Returns:
-        np.ndarray: the drawn image which channel is RGB.
-    """
-    if hasattr(model, 'module'):
-        model = model.module
-    if isinstance(img, str):
-        image = mmcv.imread(img, channel_order='rgb')
-    else:
-        image = img
-    if save_dir is not None:
-        mkdir_or_exist(save_dir)
-    # init visualizer
-    visualizer = SegLocalVisualizer(
-        vis_backends=[dict(type='LocalVisBackend')],
-        save_dir=save_dir,
-        alpha=opacity)
-    visualizer.dataset_meta = dict(
-        classes=model.dataset_meta['classes'],
-        palette=model.dataset_meta['palette'])
-    visualizer.add_datasample(
-        name=title,
-        image=image,
-        data_sample=result,
-        draw_gt=draw_gt,
-        draw_pred=draw_pred,
-        wait_time=wait_time,
-        out_file=out_file,
-        show=show,
-        with_labels=with_labels)
-    vis_img = visualizer.get_image()
-
-    return vis_img
diff --git a/mmsegmentation/mmseg/apis/mmseg_inferencer.py b/mmsegmentation/mmseg/apis/mmseg_inferencer.py
deleted file mode 100644
index 02a198b..0000000
--- a/mmsegmentation/mmseg/apis/mmseg_inferencer.py
+++ /dev/null
@@ -1,382 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import os.path as osp
-import warnings
-from typing import List, Optional, Sequence, Union
-
-import mmcv
-import mmengine
-import numpy as np
-import torch
-import torch.nn as nn
-from mmcv.transforms import Compose
-from mmengine.infer.infer import BaseInferencer, ModelType
-from mmengine.model import revert_sync_batchnorm
-from mmengine.registry import init_default_scope
-from mmengine.runner.checkpoint import _load_checkpoint_to_model
-from PIL import Image
-
-from mmseg.structures import SegDataSample
-from mmseg.utils import ConfigType, SampleList, get_classes, get_palette
-from mmseg.visualization import SegLocalVisualizer
-
-InputType = Union[str, np.ndarray]
-InputsType = Union[InputType, Sequence[InputType]]
-PredType = Union[SegDataSample, SampleList]
-
-
-class MMSegInferencer(BaseInferencer):
-    """Semantic segmentation inferencer, provides inference and visualization
-    interfaces. Note: MMEngine >= 0.5.0 is required.
-
-    Args:
-        model (str, optional): Path to the config file or the model name
-            defined in metafile. Take the `mmseg metafile <https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/metafile.yaml>`_
-            as an example the `model` could be
-            "fcn_r50-d8_4xb2-40k_cityscapes-512x1024", and the weights of model
-            will be download automatically. If use config file, like
-            "configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py", the
-            `weights` should be defined.
-        weights (str, optional): Path to the checkpoint. If it is not specified
-            and model is a model name of metafile, the weights will be loaded
-            from metafile. Defaults to None.
-        classes (list, optional): Input classes for result rendering, as the
-            prediction of segmentation model is a segment map with label
-            indices, `classes` is a list which includes items responding to the
-            label indices. If classes is not defined, visualizer will take
-            `cityscapes` classes by default. Defaults to None.
-        palette (list, optional): Input palette for result rendering, which is
-            a list of color palette responding to the classes. If palette is
-            not defined, visualizer will take `cityscapes` palette by default.
-            Defaults to None.
-        dataset_name (str, optional): `Dataset name or alias <https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/utils/class_names.py#L302-L317>`_
-            visulizer will use the meta information of the dataset i.e. classes
-            and palette, but the `classes` and `palette` have higher priority.
-            Defaults to None.
-        device (str, optional): Device to run inference. If None, the available
-            device will be automatically used. Defaults to None.
-        scope (str, optional): The scope of the model. Defaults to 'mmseg'.
-    """ # noqa
-
-    preprocess_kwargs: set = set()
-    forward_kwargs: set = {'mode', 'out_dir'}
-    visualize_kwargs: set = {
-        'show', 'wait_time', 'img_out_dir', 'opacity', 'return_vis',
-        'with_labels'
-    }
-    postprocess_kwargs: set = {'pred_out_dir', 'return_datasample'}
-
-    def __init__(self,
-                 model: Union[ModelType, str],
-                 weights: Optional[str] = None,
-                 classes: Optional[Union[str, List]] = None,
-                 palette: Optional[Union[str, List]] = None,
-                 dataset_name: Optional[str] = None,
-                 device: Optional[str] = None,
-                 scope: Optional[str] = 'mmseg') -> None:
-        # A global counter tracking the number of images processes, for
-        # naming of the output images
-        self.num_visualized_imgs = 0
-        self.num_pred_imgs = 0
-        init_default_scope(scope if scope else 'mmseg')
-        super().__init__(
-            model=model, weights=weights, device=device, scope=scope)
-
-        if device == 'cpu' or not torch.cuda.is_available():
-            self.model = revert_sync_batchnorm(self.model)
-
-        assert isinstance(self.visualizer, SegLocalVisualizer)
-        self.visualizer.set_dataset_meta(classes, palette, dataset_name)
-
-    def _load_weights_to_model(self, model: nn.Module,
-                               checkpoint: Optional[dict],
-                               cfg: Optional[ConfigType]) -> None:
-        """Loading model weights and meta information from cfg and checkpoint.
-
-        Subclasses could override this method to load extra meta information
-        from ``checkpoint`` and ``cfg`` to model.
-
-        Args:
-            model (nn.Module): Model to load weights and meta information.
-            checkpoint (dict, optional): The loaded checkpoint.
-            cfg (Config or ConfigDict, optional): The loaded config.
-        """
-
-        if checkpoint is not None:
-            _load_checkpoint_to_model(model, checkpoint)
-            checkpoint_meta = checkpoint.get('meta', {})
-            # save the dataset_meta in the model for convenience
-            if 'dataset_meta' in checkpoint_meta:
-                # mmsegmentation 1.x
-                model.dataset_meta = {
-                    'classes': checkpoint_meta['dataset_meta'].get('classes'),
-                    'palette': checkpoint_meta['dataset_meta'].get('palette')
-                }
-            elif 'CLASSES' in checkpoint_meta:
-                # mmsegmentation 0.x
-                classes = checkpoint_meta['CLASSES']
-                palette = checkpoint_meta.get('PALETTE', None)
-                model.dataset_meta = {'classes': classes, 'palette': palette}
-            else:
-                warnings.warn(
-                    'dataset_meta or class names are not saved in the '
-                    'checkpoint\'s meta data, use classes of Cityscapes by '
-                    'default.')
-                model.dataset_meta = {
-                    'classes': get_classes('cityscapes'),
-                    'palette': get_palette('cityscapes')
-                }
-        else:
-            warnings.warn('Checkpoint is not loaded, and the inference '
-                          'result is calculated by the randomly initialized '
-                          'model!')
-            warnings.warn(
-                'weights is None, use cityscapes classes by default.')
-            model.dataset_meta = {
-                'classes': get_classes('cityscapes'),
-                'palette': get_palette('cityscapes')
-            }
-
-    def __call__(self,
-                 inputs: InputsType,
-                 return_datasamples: bool = False,
-                 batch_size: int = 1,
-                 return_vis: bool = False,
-                 show: bool = False,
-                 wait_time: int = 0,
-                 out_dir: str = '',
-                 img_out_dir: str = 'vis',
-                 pred_out_dir: str = 'pred',
-                 **kwargs) -> dict:
-        """Call the inferencer.
-
-        Args:
-            inputs (Union[list, str, np.ndarray]): Inputs for the inferencer.
-            return_datasamples (bool): Whether to return results as
-                :obj:`SegDataSample`. Defaults to False.
-            batch_size (int): Batch size. Defaults to 1.
-            show (bool): Whether to display the rendering color segmentation
-                mask in a popup window. Defaults to False.
-            wait_time (float): The interval of show (s). Defaults to 0.
-            out_dir (str): Output directory of inference results. Defaults
-                to ''.
-            img_out_dir (str): Subdirectory of `out_dir`, used to save
-                rendering color segmentation mask, so `out_dir` must be defined
-                if you would like to save predicted mask. Defaults to 'vis'.
-            pred_out_dir (str): Subdirectory of `out_dir`, used to save
-                predicted mask file, so `out_dir` must be defined if you would
-                like to save predicted mask. Defaults to 'pred'.
-
-            **kwargs: Other keyword arguments passed to :meth:`preprocess`,
-                :meth:`forward`, :meth:`visualize` and :meth:`postprocess`.
-                Each key in kwargs should be in the corresponding set of
-                ``preprocess_kwargs``, ``forward_kwargs``, ``visualize_kwargs``
-                and ``postprocess_kwargs``.
-
-
-        Returns:
-            dict: Inference and visualization results.
-        """
-
-        if out_dir != '':
-            pred_out_dir = osp.join(out_dir, pred_out_dir)
-            img_out_dir = osp.join(out_dir, img_out_dir)
-        else:
-            pred_out_dir = ''
-            img_out_dir = ''
-
-        return super().__call__(
-            inputs=inputs,
-            return_datasamples=return_datasamples,
-            batch_size=batch_size,
-            show=show,
-            wait_time=wait_time,
-            img_out_dir=img_out_dir,
-            pred_out_dir=pred_out_dir,
-            return_vis=return_vis,
-            **kwargs)
-
-    def visualize(self,
-                  inputs: list,
-                  preds: List[dict],
-                  return_vis: bool = False,
-                  show: bool = False,
-                  wait_time: int = 0,
-                  img_out_dir: str = '',
-                  opacity: float = 0.8,
-                  with_labels: Optional[bool] = True) -> List[np.ndarray]:
-        """Visualize predictions.
-
-        Args:
-            inputs (list): Inputs preprocessed by :meth:`_inputs_to_list`.
-            preds (Any): Predictions of the model.
-            show (bool): Whether to display the image in a popup window.
-                Defaults to False.
-            wait_time (float): The interval of show (s). Defaults to 0.
-            img_out_dir (str): Output directory of rendering prediction i.e.
-                color segmentation mask. Defaults: ''
-            opacity (int, float): The transparency of segmentation mask.
-                Defaults to 0.8.
-
-        Returns:
-            List[np.ndarray]: Visualization results.
-        """
-        if not show and img_out_dir == '' and not return_vis:
-            return None
-        if self.visualizer is None:
-            raise ValueError('Visualization needs the "visualizer" term'
-                             'defined in the config, but got None.')
-
-        self.visualizer.set_dataset_meta(**self.model.dataset_meta)
-        self.visualizer.alpha = opacity
-
-        results = []
-
-        for single_input, pred in zip(inputs, preds):
-            if isinstance(single_input, str):
-                img_bytes = mmengine.fileio.get(single_input)
-                img = mmcv.imfrombytes(img_bytes)
-                img = img[:, :, ::-1]
-                img_name = osp.basename(single_input)
-            elif isinstance(single_input, np.ndarray):
-                img = single_input.copy()
-                img_num = str(self.num_visualized_imgs).zfill(8) + '_vis'
-                img_name = f'{img_num}.jpg'
-            else:
-                raise ValueError('Unsupported input type:'
-                                 f'{type(single_input)}')
-
-            out_file = osp.join(img_out_dir, img_name) if img_out_dir != ''\
-                else None
-
-            self.visualizer.add_datasample(
-                img_name,
-                img,
-                pred,
-                show=show,
-                wait_time=wait_time,
-                draw_gt=False,
-                draw_pred=True,
-                out_file=out_file,
-                with_labels=with_labels)
-            if return_vis:
-                results.append(self.visualizer.get_image())
-            self.num_visualized_imgs += 1
-
-        return results if return_vis else None
-
-    def postprocess(self,
-                    preds: PredType,
-                    visualization: List[np.ndarray],
-                    return_datasample: bool = False,
-                    pred_out_dir: str = '') -> dict:
-        """Process the predictions and visualization results from ``forward``
-        and ``visualize``.
-
-        This method should be responsible for the following tasks:
-
-        1. Pack the predictions and visualization results and return them.
-        2. Save the predictions, if it needed.
-
-        Args:
-            preds (List[Dict]): Predictions of the model.
-            visualization (List[np.ndarray]): The list of rendering color
-                segmentation mask.
-            return_datasample (bool): Whether to return results as datasamples.
-                Defaults to False.
-            pred_out_dir: File to save the inference results w/o
-                visualization. If left as empty, no file will be saved.
-                Defaults to ''.
-
-        Returns:
-            dict: Inference and visualization results with key ``predictions``
-            and ``visualization``
-
-            - ``visualization (Any)``: Returned by :meth:`visualize`
-            - ``predictions`` (List[np.ndarray], np.ndarray): Returned by
-              :meth:`forward` and processed in :meth:`postprocess`.
-              If ``return_datasample=False``, it will be the segmentation mask
-              with label indice.
-        """
-        if return_datasample:
-            if len(preds) == 1:
-                return preds[0]
-            else:
-                return preds
-
-        results_dict = {}
-
-        results_dict['predictions'] = []
-        results_dict['visualization'] = []
-
-        for i, pred in enumerate(preds):
-            pred_data = dict()
-            if 'pred_sem_seg' in pred.keys():
-                pred_data['sem_seg'] = pred.pred_sem_seg.numpy().data[0]
-            elif 'pred_depth_map' in pred.keys():
-                pred_data['depth_map'] = pred.pred_depth_map.numpy().data[0]
-
-            if visualization is not None:
-                vis = visualization[i]
-                results_dict['visualization'].append(vis)
-            if pred_out_dir != '':
-                mmengine.mkdir_or_exist(pred_out_dir)
-                for key, data in pred_data.items():
-                    post_fix = '_pred.png' if key == 'sem_seg' else '_pred.npy'
-                    img_name = str(self.num_pred_imgs).zfill(8) + post_fix
-                    img_path = osp.join(pred_out_dir, img_name)
-                    if key == 'sem_seg':
-                        output = Image.fromarray(data.astype(np.uint8))
-                        output.save(img_path)
-                    else:
-                        np.save(img_path, data)
-            pred_data = next(iter(pred_data.values()))
-            results_dict['predictions'].append(pred_data)
-            self.num_pred_imgs += 1
-
-        if len(results_dict['predictions']) == 1:
-            results_dict['predictions'] = results_dict['predictions'][0]
-            if visualization is not None:
-                results_dict['visualization'] = \
-                    results_dict['visualization'][0]
-        return results_dict
-
-    def _init_pipeline(self, cfg: ConfigType) -> Compose:
-        """Initialize the test pipeline.
-
-        Return a pipeline to handle various input data, such as ``str``,
-        ``np.ndarray``. It is an abstract method in BaseInferencer, and should
-        be implemented in subclasses.
-
-        The returned pipeline will be used to process a single data.
-        It will be used in :meth:`preprocess` like this:
-
-        .. code-block:: python
-            def preprocess(self, inputs, batch_size, **kwargs):
-                ...
-                dataset = map(self.pipeline, dataset)
-                ...
-        """
-        pipeline_cfg = cfg.test_dataloader.dataset.pipeline
-        # Loading annotations is also not applicable
-        for transform in ('LoadAnnotations', 'LoadDepthAnnotation'):
-            idx = self._get_transform_idx(pipeline_cfg, transform)
-            if idx != -1:
-                del pipeline_cfg[idx]
-
-        load_img_idx = self._get_transform_idx(pipeline_cfg,
-                                               'LoadImageFromFile')
-        if load_img_idx == -1:
-            raise ValueError(
-                'LoadImageFromFile is not found in the test pipeline')
-        pipeline_cfg[load_img_idx]['type'] = 'InferencerLoader'
-        return Compose(pipeline_cfg)
-
-    def _get_transform_idx(self, pipeline_cfg: ConfigType, name: str) -> int:
-        """Returns the index of the transform in a pipeline.
-
-        If the transform is not found, returns -1.
-        """
-        for i, transform in enumerate(pipeline_cfg):
-            if transform['type'] == name:
-                return i
-        return -1
diff --git a/mmsegmentation/mmseg/apis/remote_sense_inferencer.py b/mmsegmentation/mmseg/apis/remote_sense_inferencer.py
deleted file mode 100644
index 6726c6a..0000000
--- a/mmsegmentation/mmseg/apis/remote_sense_inferencer.py
+++ /dev/null
@@ -1,279 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import threading
-from queue import Queue
-from typing import List, Optional, Tuple
-
-import numpy as np
-import torch
-from mmengine import Config
-from mmengine.model import BaseModel
-from mmengine.registry import init_default_scope
-from mmengine.runner import load_checkpoint
-
-try:
-    from osgeo import gdal
-except ImportError:
-    gdal = None
-
-from mmseg.registry import MODELS
-from .utils import _preprare_data
-
-
-class RSImage:
-    """Remote sensing image class.
-
-    Args:
-        img (str or gdal.Dataset): Image file path or gdal.Dataset.
-    """
-
-    def __init__(self, image):
-        self.dataset = gdal.Open(image, gdal.GA_ReadOnly) if isinstance(
-            image, str) else image
-        assert isinstance(self.dataset, gdal.Dataset), \
-            f'{image} is not a image'
-        self.width = self.dataset.RasterXSize
-        self.height = self.dataset.RasterYSize
-        self.channel = self.dataset.RasterCount
-        self.trans = self.dataset.GetGeoTransform()
-        self.proj = self.dataset.GetProjection()
-        self.band_list = []
-        self.band_list.extend(
-            self.dataset.GetRasterBand(c + 1) for c in range(self.channel))
-        self.grids = []
-
-    def read(self, grid: Optional[List] = None) -> np.ndarray:
-        """Read image data. If grid is None, read the whole image.
-
-        Args:
-            grid (Optional[List], optional): Grid to read. Defaults to None.
-        Returns:
-            np.ndarray: Image data.
-        """
-        if grid is None:
-            return np.einsum('ijk->jki', self.dataset.ReadAsArray())
-        assert len(
-            grid) >= 4, 'grid must be a list containing at least 4 elements'
-        data = self.dataset.ReadAsArray(*grid[:4])
-        if data.ndim == 2:
-            data = data[np.newaxis, ...]
-        return np.einsum('ijk->jki', data)
-
-    def write(self, data: Optional[np.ndarray], grid: Optional[List] = None):
-        """Write image data.
-
-        Args:
-            grid (Optional[List], optional): Grid to write. Defaults to None.
-            data (Optional[np.ndarray], optional): Data to write.
-                Defaults to None.
-
-        Raises:
-            ValueError: Either grid or data must be provided.
-        """
-        if grid is not None:
-            assert len(grid) == 8, 'grid must be a list of 8 elements'
-            for band in self.band_list:
-                band.WriteArray(
-                    data[grid[5]:grid[5] + grid[7], grid[4]:grid[4] + grid[6]],
-                    grid[0] + grid[4], grid[1] + grid[5])
-        elif data is not None:
-            for i in range(self.channel):
-                self.band_list[i].WriteArray(data[..., i])
-        else:
-            raise ValueError('Either grid or data must be provided.')
-
-    def create_seg_map(self, output_path: Optional[str] = None):
-        if output_path is None:
-            output_path = 'output_label.tif'
-        driver = gdal.GetDriverByName('GTiff')
-        seg_map = driver.Create(output_path, self.width, self.height, 1,
-                                gdal.GDT_Byte)
-        seg_map.SetGeoTransform(self.trans)
-        seg_map.SetProjection(self.proj)
-        seg_map_img = RSImage(seg_map)
-        seg_map_img.path = output_path
-        return seg_map_img
-
-    def create_grids(self,
-                     window_size: Tuple[int, int],
-                     stride: Tuple[int, int] = (0, 0)):
-        """Create grids for image inference.
-
-        Args:
-            window_size (Tuple[int, int]): the size of the sliding window.
-            stride (Tuple[int, int], optional): the stride of the sliding
-                window. Defaults to (0, 0).
-
-        Raises:
-            AssertionError: window_size must be a tuple of 2 elements.
-            AssertionError: stride must be a tuple of 2 elements.
-        """
-        assert len(
-            window_size) == 2, 'window_size must be a tuple of 2 elements'
-        assert len(stride) == 2, 'stride must be a tuple of 2 elements'
-        win_w, win_h = window_size
-        stride_x, stride_y = stride
-
-        stride_x = win_w if stride_x == 0 else stride_x
-        stride_y = win_h if stride_y == 0 else stride_y
-
-        x_half_overlap = (win_w - stride_x + 1) // 2
-        y_half_overlap = (win_h - stride_y + 1) // 2
-
-        for y in range(0, self.height, stride_y):
-            y_end = y + win_h >= self.height
-            y_offset = self.height - win_h if y_end else y
-            y_size = win_h
-            y_crop_off = 0 if y_offset == 0 else y_half_overlap
-            y_crop_size = y_size if y_end else win_h - y_crop_off
-
-            for x in range(0, self.width, stride_x):
-                x_end = x + win_w >= self.width
-                x_offset = self.width - win_w if x_end else x
-                x_size = win_w
-                x_crop_off = 0 if x_offset == 0 else x_half_overlap
-                x_crop_size = x_size if x_end else win_w - x_crop_off
-
-                self.grids.append([
-                    x_offset, y_offset, x_size, y_size, x_crop_off, y_crop_off,
-                    x_crop_size, y_crop_size
-                ])
-
-
-class RSInferencer:
-    """Remote sensing inference class.
-
-    Args:
-        model (BaseModel): The loaded model.
-        batch_size (int, optional): Batch size. Defaults to 1.
-        thread (int, optional): Number of threads. Defaults to 1.
-    """
-
-    def __init__(self, model: BaseModel, batch_size: int = 1, thread: int = 1):
-        self.model = model
-        self.batch_size = batch_size
-        self.END_FLAG = object()
-        self.read_buffer = Queue(self.batch_size)
-        self.write_buffer = Queue(self.batch_size)
-        self.thread = thread
-
-    @classmethod
-    def from_config_path(cls,
-                         config_path: str,
-                         checkpoint_path: str,
-                         batch_size: int = 1,
-                         thread: int = 1,
-                         device: Optional[str] = 'cpu'):
-        """Initialize a segmentor from config file.
-
-        Args:
-            config_path (str): Config file path.
-            checkpoint_path (str): Checkpoint path.
-            batch_size (int, optional): Batch size. Defaults to 1.
-        """
-        init_default_scope('mmseg')
-        cfg = Config.fromfile(config_path)
-        model = MODELS.build(cfg.model)
-        model.cfg = cfg
-        load_checkpoint(model, checkpoint_path, map_location='cpu')
-        model.to(device)
-        model.eval()
-        return cls(model, batch_size, thread)
-
-    @classmethod
-    def from_model(cls,
-                   model: BaseModel,
-                   checkpoint_path: Optional[str] = None,
-                   batch_size: int = 1,
-                   thread: int = 1,
-                   device: Optional[str] = 'cpu'):
-        """Initialize a segmentor from model.
-
-        Args:
-            model (BaseModel): The loaded model.
-            checkpoint_path (Optional[str]): Checkpoint path.
-            batch_size (int, optional): Batch size. Defaults to 1.
-        """
-        if checkpoint_path is not None:
-            load_checkpoint(model, checkpoint_path, map_location='cpu')
-        model.to(device)
-        return cls(model, batch_size, thread)
-
-    def read(self,
-             image: RSImage,
-             window_size: Tuple[int, int],
-             strides: Tuple[int, int] = (0, 0)):
-        """Load image data to read buffer.
-
-        Args:
-            image (RSImage): The image to read.
-            window_size (Tuple[int, int]): The size of the sliding window.
-            strides (Tuple[int, int], optional): The stride of the sliding
-                window. Defaults to (0, 0).
-        """
-        image.create_grids(window_size, strides)
-        for grid in image.grids:
-            self.read_buffer.put([grid, image.read(grid=grid)])
-        self.read_buffer.put(self.END_FLAG)
-
-    def inference(self):
-        """Inference image data from read buffer and put the result to write
-        buffer."""
-        while True:
-            item = self.read_buffer.get()
-            if item == self.END_FLAG:
-                self.read_buffer.put(self.END_FLAG)
-                self.write_buffer.put(item)
-                break
-            data, _ = _preprare_data(item[1], self.model)
-            with torch.no_grad():
-                result = self.model.test_step(data)
-            item[1] = result[0].pred_sem_seg.cpu().data.numpy()[0]
-            self.write_buffer.put(item)
-            self.read_buffer.task_done()
-
-    def write(self, image: RSImage, output_path: Optional[str] = None):
-        """Write image data from write buffer.
-
-        Args:
-            image (RSImage): The image to write.
-            output_path (Optional[str], optional): The path to save the
-                segmentation map. Defaults to None.
-        """
-        seg_map = image.create_seg_map(output_path)
-        while True:
-            item = self.write_buffer.get()
-            if item == self.END_FLAG:
-                break
-            seg_map.write(data=item[1], grid=item[0])
-            self.write_buffer.task_done()
-
-    def run(self,
-            image: RSImage,
-            window_size: Tuple[int, int],
-            strides: Tuple[int, int] = (0, 0),
-            output_path: Optional[str] = None):
-        """Run inference with multi-threading.
-
-        Args:
-            image (RSImage): The image to inference.
-            window_size (Tuple[int, int]): The size of the sliding window.
-            strides (Tuple[int, int], optional): The stride of the sliding
-                window. Defaults to (0, 0).
-            output_path (Optional[str], optional): The path to save the
-                segmentation map. Defaults to None.
-        """
-        read_thread = threading.Thread(
-            target=self.read, args=(image, window_size, strides))
-        read_thread.start()
-        inference_threads = []
-        for _ in range(self.thread):
-            inference_thread = threading.Thread(target=self.inference)
-            inference_thread.start()
-            inference_threads.append(inference_thread)
-        write_thread = threading.Thread(
-            target=self.write, args=(image, output_path))
-        write_thread.start()
-        read_thread.join()
-        for inference_thread in inference_threads:
-            inference_thread.join()
-        write_thread.join()
diff --git a/mmsegmentation/mmseg/apis/utils.py b/mmsegmentation/mmseg/apis/utils.py
deleted file mode 100644
index 4cf8775..0000000
--- a/mmsegmentation/mmseg/apis/utils.py
+++ /dev/null
@@ -1,41 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from collections import defaultdict
-from typing import Sequence, Union
-
-import numpy as np
-from mmengine.dataset import Compose
-from mmengine.model import BaseModel
-
-ImageType = Union[str, np.ndarray, Sequence[str], Sequence[np.ndarray]]
-
-
-def _preprare_data(imgs: ImageType, model: BaseModel):
-
-    cfg = model.cfg
-    for t in cfg.test_pipeline:
-        if t.get('type') == 'LoadAnnotations':
-            cfg.test_pipeline.remove(t)
-
-    is_batch = True
-    if not isinstance(imgs, (list, tuple)):
-        imgs = [imgs]
-        is_batch = False
-
-    if isinstance(imgs[0], np.ndarray):
-        cfg.test_pipeline[0]['type'] = 'LoadImageFromNDArray'
-
-    # TODO: Consider using the singleton pattern to avoid building
-    # a pipeline for each inference
-    pipeline = Compose(cfg.test_pipeline)
-
-    data = defaultdict(list)
-    for img in imgs:
-        if isinstance(img, np.ndarray):
-            data_ = dict(img=img)
-        else:
-            data_ = dict(img_path=img)
-        data_ = pipeline(data_)
-        data['inputs'].append(data_['inputs'])
-        data['data_samples'].append(data_['data_samples'])
-
-    return data, is_batch
diff --git a/mmsegmentation/mmseg/configs/_base_/datasets/loveda.py b/mmsegmentation/mmseg/configs/_base_/datasets/loveda.py
deleted file mode 100644
index eb3d358..0000000
--- a/mmsegmentation/mmseg/configs/_base_/datasets/loveda.py
+++ /dev/null
@@ -1,79 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmcv.transforms.loading import LoadImageFromFile
-from mmcv.transforms.processing import (RandomFlip, RandomResize, Resize,
-                                        TestTimeAug)
-from mmengine.dataset.sampler import DefaultSampler, InfiniteSampler
-
-from mmseg.datasets.loveda import LoveDADataset
-from mmseg.datasets.transforms.formatting import PackSegInputs
-from mmseg.datasets.transforms.loading import LoadAnnotations
-from mmseg.datasets.transforms.transforms import (PhotoMetricDistortion,
-                                                  RandomCrop)
-from mmseg.evaluation import IoUMetric
-
-# dataset settings
-dataset_type = LoveDADataset
-data_root = 'data/loveDA'
-crop_size = (512, 512)
-train_pipeline = [
-    dict(type=LoadImageFromFile),
-    dict(type=LoadAnnotations, reduce_zero_label=True),
-    dict(
-        type=RandomResize,
-        scale=(2048, 512),
-        ratio_range=(0.5, 2.0),
-        keep_ratio=True),
-    dict(type=RandomCrop, crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type=RandomFlip, prob=0.5),
-    dict(type=PhotoMetricDistortion),
-    dict(type=PackSegInputs)
-]
-test_pipeline = [
-    dict(type=LoadImageFromFile),
-    dict(type=Resize, scale=(1024, 1024), keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type=LoadAnnotations, reduce_zero_label=True),
-    dict(type=PackSegInputs)
-]
-img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
-tta_pipeline = [
-    dict(type=LoadImageFromFile, backend_args=None),
-    dict(
-        type=TestTimeAug,
-        transforms=[[
-            dict(type=Resize, scale_factor=r, keep_ratio=True)
-            for r in img_ratios
-        ],
-                    [
-                        dict(type=RandomFlip, prob=0., direction='horizontal'),
-                        dict(type=RandomFlip, prob=1., direction='horizontal')
-                    ], [dict(type=LoadAnnotations)],
-                    [dict(type=PackSegInputs)]])
-]
-train_dataloader = dict(
-    batch_size=2,
-    num_workers=12,
-    persistent_workers=True,
-    sampler=dict(type=InfiniteSampler, shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='img_dir/train', seg_map_path='ann_dir/train'),
-        pipeline=train_pipeline))
-
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type=DefaultSampler, shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(img_path='img_dir/val', seg_map_path='ann_dir/val'),
-        pipeline=test_pipeline))
-
-test_dataloader = val_dataloader
-val_evaluator = dict(type=IoUMetric, iou_metrics=['mIoU'])
-test_evaluator = val_evaluator
diff --git a/mmsegmentation/mmseg/configs/_base_/datasets/potsdam.py b/mmsegmentation/mmseg/configs/_base_/datasets/potsdam.py
deleted file mode 100644
index 33a4ebf..0000000
--- a/mmsegmentation/mmseg/configs/_base_/datasets/potsdam.py
+++ /dev/null
@@ -1,81 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmcv.transforms.loading import LoadImageFromFile
-from mmcv.transforms.processing import (RandomFlip, RandomResize, Resize,
-                                        TestTimeAug)
-from mmengine.dataset.sampler import DefaultSampler, InfiniteSampler
-
-from mmseg.datasets.potsdam import PotsdamDataset
-from mmseg.datasets.transforms.formatting import PackSegInputs
-from mmseg.datasets.transforms.loading import LoadAnnotations
-from mmseg.datasets.transforms.transforms import (PhotoMetricDistortion,
-                                                  RandomCrop)
-from mmseg.evaluation import IoUMetric
-
-# dataset settings
-dataset_type = PotsdamDataset
-data_root = 'data/potsdam'
-crop_size = (512, 512)
-train_pipeline = [
-    dict(type=LoadImageFromFile),
-    dict(type=LoadAnnotations, reduce_zero_label=True),
-    dict(
-        type=RandomResize,
-        scale=(512, 512),
-        ratio_range=(0.5, 2.0),
-        keep_ratio=True),
-    dict(type=RandomCrop, crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type=RandomFlip, prob=0.5),
-    dict(type=PhotoMetricDistortion),
-    dict(type=PackSegInputs)
-]
-test_pipeline = [
-    dict(type=LoadImageFromFile),
-    dict(type=Resize, scale=(512, 512), keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type=LoadAnnotations, reduce_zero_label=True),
-    dict(type=PackSegInputs)
-]
-img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
-tta_pipeline = [
-    dict(type=LoadImageFromFile, backend_args=None),
-    dict(
-        type=TestTimeAug,
-        transforms=[[
-            dict(type=Resize, scale_factor=r, keep_ratio=True)
-            for r in img_ratios
-        ],
-                    [
-                        dict(type=RandomFlip, prob=0., direction='horizontal'),
-                        dict(type=RandomFlip, prob=1., direction='horizontal')
-                    ], [dict(type=LoadAnnotations)],
-                    [dict(type=PackSegInputs)]])
-]
-
-train_dataloader = dict(
-    batch_size=2,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type=InfiniteSampler, shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='img_dir/train', seg_map_path='ann_dir/train'),
-        pipeline=train_pipeline))
-
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type=DefaultSampler, shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(img_path='img_dir/val', seg_map_path='ann_dir/val'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-
-val_evaluator = dict(
-    type=IoUMetric, iou_metrics=['mIoU'])  # 'mDice', 'mFscore'
-test_evaluator = val_evaluator
diff --git a/mmsegmentation/mmseg/configs/_base_/default_runtime.py b/mmsegmentation/mmseg/configs/_base_/default_runtime.py
deleted file mode 100644
index c905020..0000000
--- a/mmsegmentation/mmseg/configs/_base_/default_runtime.py
+++ /dev/null
@@ -1,22 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-
-from mmengine.visualization import LocalVisBackend
-
-from mmseg.models import SegTTAModel
-from mmseg.visualization import SegLocalVisualizer
-
-env_cfg = dict(
-    cudnn_benchmark=False,
-    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
-    dist_cfg=dict(backend='nccl'),
-)
-vis_backends = [dict(type=LocalVisBackend)]
-visualizer = dict(
-    type=SegLocalVisualizer, vis_backends=vis_backends, name='visualizer')
-log_processor = dict(by_epoch=False)
-log_level = 'INFO'
-load_from = None
-resume = False
-
-tta_model = dict(type=SegTTAModel)
-default_scope = None
diff --git a/mmsegmentation/mmseg/configs/_base_/schedules/schedule_160k.py b/mmsegmentation/mmseg/configs/_base_/schedules/schedule_160k.py
deleted file mode 100644
index 294d6ee..0000000
--- a/mmsegmentation/mmseg/configs/_base_/schedules/schedule_160k.py
+++ /dev/null
@@ -1,43 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmengine.hooks import (CheckpointHook, DistSamplerSeedHook, IterTimerHook,
-                            LoggerHook, ParamSchedulerHook)
-from mmengine.optim.optimizer.optimizer_wrapper import OptimWrapper
-from mmengine.optim.scheduler.lr_scheduler import PolyLR
-from mmengine.runner.loops import IterBasedTrainLoop, TestLoop, ValLoop
-from torch.optim.sgd import SGD
-
-from mmseg.engine import SegVisualizationHook
-
-# optimizer
-optimizer = dict(
-    type=SGD,
-    #  lr=0.01,
-    #  momentum=0.9,
-    #  weight_decay=0.0005
-)
-
-optim_wrapper = dict(type=OptimWrapper, optimizer=optimizer, clip_grad=None)
-
-# learning policy
-param_scheduler = [
-    dict(
-        type=PolyLR,
-        eta_min=1e-4,
-        power=0.9,
-        begin=0,
-        end=160000,
-        by_epoch=False)
-]
-# training schedule for 160k
-
-train_cfg = dict(type=IterBasedTrainLoop, max_iters=160000, val_interval=8000)
-val_cfg = dict(type=ValLoop)
-test_cfg = dict(type=TestLoop)
-
-default_hooks = dict(
-    timer=dict(type=IterTimerHook),
-    logger=dict(type=LoggerHook, interval=50, log_metric_by_epoch=False),
-    param_scheduler=dict(type=ParamSchedulerHook),
-    checkpoint=dict(type=CheckpointHook, by_epoch=False, interval=8000),
-    sampler_seed=dict(type=DistSamplerSeedHook),
-    visualization=dict(type=SegVisualizationHook))
diff --git a/mmsegmentation/mmseg/configs/_base_/schedules/schedule_20k.py b/mmsegmentation/mmseg/configs/_base_/schedules/schedule_20k.py
deleted file mode 100644
index 255300a..0000000
--- a/mmsegmentation/mmseg/configs/_base_/schedules/schedule_20k.py
+++ /dev/null
@@ -1,36 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmengine.hooks import (CheckpointHook, DistSamplerSeedHook, IterTimerHook,
-                            LoggerHook, ParamSchedulerHook)
-from mmengine.optim.optimizer.optimizer_wrapper import OptimWrapper
-from mmengine.optim.scheduler.lr_scheduler import PolyLR
-from mmengine.runner.loops import IterBasedTrainLoop, TestLoop, ValLoop
-from torch.optim.sgd import SGD
-
-from mmseg.engine import SegVisualizationHook
-
-# optimizer
-optimizer = dict(type=SGD, lr=0.01, momentum=0.9, weight_decay=0.0005)
-optim_wrapper = dict(type=OptimWrapper, optimizer=optimizer, clip_grad=None)
-
-# learning policy
-param_scheduler = [
-    dict(
-        type=PolyLR,
-        eta_min=1e-4,
-        power=0.9,
-        begin=0,
-        end=20000,
-        by_epoch=False)
-]
-# training schedule for 20k
-train_cfg = dict(type=IterBasedTrainLoop, max_iters=20000, val_interval=2000)
-val_cfg = dict(type=ValLoop)
-test_cfg = dict(type=TestLoop)
-
-default_hooks = dict(
-    timer=dict(type=IterTimerHook),
-    logger=dict(type=LoggerHook, interval=50, log_metric_by_epoch=False),
-    param_scheduler=dict(type=ParamSchedulerHook),
-    checkpoint=dict(type=CheckpointHook, by_epoch=False, interval=2000),
-    sampler_seed=dict(type=DistSamplerSeedHook),
-    visualization=dict(type=SegVisualizationHook))
diff --git a/mmsegmentation/mmseg/configs/_base_/schedules/schedule_240k.py b/mmsegmentation/mmseg/configs/_base_/schedules/schedule_240k.py
deleted file mode 100644
index cf9e5d3..0000000
--- a/mmsegmentation/mmseg/configs/_base_/schedules/schedule_240k.py
+++ /dev/null
@@ -1,34 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmengine.hooks import (CheckpointHook, DistSamplerSeedHook, IterTimerHook,
-                            LoggerHook, ParamSchedulerHook)
-from mmengine.optim.optimizer.optimizer_wrapper import OptimWrapper
-from mmengine.optim.scheduler.lr_scheduler import PolyLR
-from mmengine.runner.loops import IterBasedTrainLoop, TestLoop, ValLoop
-# from mmengine.runner.loops import EpochBasedTrainLoop
-from torch.optim.sgd import SGD
-
-from mmseg.engine import SegVisualizationHook
-
-optimizer = dict(type=SGD, lr=0.01, momentum=0.9, weight_decay=0.0005)
-optim_wrapper = dict(type=OptimWrapper, optimizer=optimizer, clip_grad=None)
-# learning policy
-param_scheduler = [
-    dict(
-        type=PolyLR,
-        eta_min=1e-4,
-        power=0.9,
-        begin=0,
-        end=240000,
-        by_epoch=False)
-]
-# training schedule for 240k
-train_cfg = dict(type=IterBasedTrainLoop, max_iters=240000, val_interval=24000)
-val_cfg = dict(type=ValLoop)
-test_cfg = dict(type=TestLoop)
-default_hooks = dict(
-    timer=dict(type=IterTimerHook),
-    logger=dict(type=LoggerHook, interval=50, log_metric_by_epoch=False),
-    param_scheduler=dict(type=ParamSchedulerHook),
-    checkpoint=dict(type=CheckpointHook, by_epoch=False, interval=24000),
-    sampler_seed=dict(type=DistSamplerSeedHook),
-    visualization=dict(type=SegVisualizationHook))
diff --git a/mmsegmentation/mmseg/configs/_base_/schedules/schedule_25k.py b/mmsegmentation/mmseg/configs/_base_/schedules/schedule_25k.py
deleted file mode 100644
index 8a3ebf4..0000000
--- a/mmsegmentation/mmseg/configs/_base_/schedules/schedule_25k.py
+++ /dev/null
@@ -1,43 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmengine.hooks import (CheckpointHook, DistSamplerSeedHook, IterTimerHook,
-                            LoggerHook, ParamSchedulerHook)
-from mmengine.optim.optimizer.optimizer_wrapper import OptimWrapper
-from mmengine.optim.scheduler.lr_scheduler import ConstantLR, LinearLR
-from mmengine.runner.loops import IterBasedTrainLoop, TestLoop, ValLoop
-# from mmengine.runner.loops import EpochBasedTrainLoop
-from torch.optim.adamw import AdamW
-
-from mmseg.engine import SegVisualizationHook
-from mmseg.engine.schedulers import PolyLRRatio
-
-# optimizer
-optimizer = dict(type=AdamW, lr=0.01, weight_decay=0.1)
-
-optim_wrapper = dict(type=OptimWrapper, optimizer=optimizer, clip_grad=None)
-# learning policy
-
-# learning policy
-param_scheduler = [
-    dict(type=LinearLR, start_factor=3e-2, begin=0, end=12000, by_epoch=False),
-    dict(
-        type=PolyLRRatio,
-        eta_min_ratio=3e-2,
-        power=0.9,
-        begin=12000,
-        end=24000,
-        by_epoch=False),
-    dict(type=ConstantLR, by_epoch=False, factor=1, begin=24000, end=25000)
-]
-
-# training schedule for 25k
-train_cfg = dict(type=IterBasedTrainLoop, max_iters=25000, val_interval=1000)
-val_cfg = dict(type=ValLoop)
-test_cfg = dict(type=TestLoop)
-
-default_hooks = dict(
-    timer=dict(type=IterTimerHook),
-    logger=dict(type=LoggerHook, interval=50, log_metric_by_epoch=False),
-    param_scheduler=dict(type=ParamSchedulerHook),
-    checkpoint=dict(type=CheckpointHook, by_epoch=False, interval=1000),
-    sampler_seed=dict(type=DistSamplerSeedHook),
-    visualization=dict(type=SegVisualizationHook))
diff --git a/mmsegmentation/mmseg/configs/_base_/schedules/schedule_320k.py b/mmsegmentation/mmseg/configs/_base_/schedules/schedule_320k.py
deleted file mode 100644
index dae323e..0000000
--- a/mmsegmentation/mmseg/configs/_base_/schedules/schedule_320k.py
+++ /dev/null
@@ -1,36 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmengine.hooks import (CheckpointHook, DistSamplerSeedHook, IterTimerHook,
-                            LoggerHook, ParamSchedulerHook)
-from mmengine.optim.optimizer.optimizer_wrapper import OptimWrapper
-from mmengine.optim.scheduler.lr_scheduler import PolyLR
-from mmengine.runner.loops import IterBasedTrainLoop, TestLoop, ValLoop
-# from mmengine.runner.loops import EpochBasedTrainLoop
-from torch.optim.sgd import SGD
-
-from mmseg.engine import SegVisualizationHook
-
-# optimizer
-optimizer = dict(type=SGD, lr=0.01, momentum=0.9, weight_decay=0.0005)
-optim_wrapper = dict(type=OptimWrapper, optimizer=optimizer, clip_grad=None)
-
-# learning policy
-param_scheduler = [
-    dict(
-        type=PolyLR,
-        eta_min=1e-4,
-        power=0.9,
-        begin=0,
-        end=320000,
-        by_epoch=False)
-]
-# training schedule for 320k
-train_cfg = dict(type=IterBasedTrainLoop, max_iters=320000, val_interval=32000)
-val_cfg = dict(type=ValLoop)
-test_cfg = dict(type=TestLoop)
-default_hooks = dict(
-    timer=dict(type=IterTimerHook),
-    logger=dict(type=LoggerHook, interval=50, log_metric_by_epoch=False),
-    param_scheduler=dict(type=ParamSchedulerHook),
-    checkpoint=dict(type=CheckpointHook, by_epoch=False, interval=32000),
-    sampler_seed=dict(type=DistSamplerSeedHook),
-    visualization=dict(type=SegVisualizationHook))
diff --git a/mmsegmentation/mmseg/configs/_base_/schedules/schedule_40k.py b/mmsegmentation/mmseg/configs/_base_/schedules/schedule_40k.py
deleted file mode 100644
index b4b2ea4..0000000
--- a/mmsegmentation/mmseg/configs/_base_/schedules/schedule_40k.py
+++ /dev/null
@@ -1,34 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmengine.hooks import (CheckpointHook, DistSamplerSeedHook, IterTimerHook,
-                            LoggerHook, ParamSchedulerHook)
-from mmengine.optim.optimizer.optimizer_wrapper import OptimWrapper
-from mmengine.optim.scheduler.lr_scheduler import PolyLR
-from mmengine.runner.loops import IterBasedTrainLoop, TestLoop, ValLoop
-from torch.optim.sgd import SGD
-
-from mmseg.engine import SegVisualizationHook
-
-# optimizer
-optimizer = dict(type=SGD, lr=0.01, momentum=0.9, weight_decay=0.0005)
-optim_wrapper = dict(type=OptimWrapper, optimizer=optimizer, clip_grad=None)
-
-param_scheduler = [
-    dict(
-        type=PolyLR,
-        eta_min=1e-4,
-        power=0.9,
-        begin=0,
-        end=40000,
-        by_epoch=False)
-]
-# training schedule for 40k
-train_cfg = dict(type=IterBasedTrainLoop, max_iters=40000, val_interval=4000)
-val_cfg = dict(type=ValLoop)
-test_cfg = dict(type=TestLoop)
-default_hooks = dict(
-    timer=dict(type=IterTimerHook),
-    logger=dict(type=LoggerHook, interval=50, log_metric_by_epoch=False),
-    param_scheduler=dict(type=ParamSchedulerHook),
-    checkpoint=dict(type=CheckpointHook, by_epoch=False, interval=4000),
-    sampler_seed=dict(type=DistSamplerSeedHook),
-    visualization=dict(type=SegVisualizationHook))
diff --git a/mmsegmentation/mmseg/configs/_base_/schedules/schedule_80k.py b/mmsegmentation/mmseg/configs/_base_/schedules/schedule_80k.py
deleted file mode 100644
index 3e711ca..0000000
--- a/mmsegmentation/mmseg/configs/_base_/schedules/schedule_80k.py
+++ /dev/null
@@ -1,42 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmengine.hooks import (CheckpointHook, DistSamplerSeedHook, IterTimerHook,
-                            LoggerHook, ParamSchedulerHook)
-from mmengine.optim.optimizer.optimizer_wrapper import OptimWrapper
-from mmengine.optim.scheduler.lr_scheduler import PolyLR
-from mmengine.runner.loops import IterBasedTrainLoop, TestLoop, ValLoop
-from torch.optim.sgd import SGD
-
-from mmseg.engine import SegVisualizationHook
-
-# optimizer
-optimizer = dict(
-    type=SGD,
-    #  lr=0.01,
-    #  momentum=0.9,
-    #  weight_decay=0.0005
-)
-
-optim_wrapper = dict(type=OptimWrapper, optimizer=optimizer, clip_grad=None)
-
-# learning policy
-param_scheduler = [
-    dict(
-        type=PolyLR,
-        eta_min=1e-4,
-        power=0.9,
-        begin=0,
-        end=80000,
-        by_epoch=False)
-]
-# training schedule for 80k
-train_cfg = dict(type=IterBasedTrainLoop, max_iters=80000, val_interval=8000)
-val_cfg = dict(type=ValLoop)
-test_cfg = dict(type=TestLoop)
-
-default_hooks = dict(
-    timer=dict(type=IterTimerHook),
-    logger=dict(type=LoggerHook, interval=50, log_metric_by_epoch=False),
-    param_scheduler=dict(type=ParamSchedulerHook),
-    checkpoint=dict(type=CheckpointHook, by_epoch=False, interval=8000),
-    sampler_seed=dict(type=DistSamplerSeedHook),
-    visualization=dict(type=SegVisualizationHook))
diff --git a/mmsegmentation/mmseg/datasets/ade.py b/mmsegmentation/mmseg/datasets/ade.py
deleted file mode 100644
index e9bdae7..0000000
--- a/mmsegmentation/mmseg/datasets/ade.py
+++ /dev/null
@@ -1,92 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmseg.registry import DATASETS
-from .basesegdataset import BaseSegDataset
-
-
-@DATASETS.register_module()
-class ADE20KDataset(BaseSegDataset):
-    """ADE20K dataset.
-
-    In segmentation map annotation for ADE20K, 0 stands for background, which
-    is not included in 150 categories. ``reduce_zero_label`` is fixed to True.
-    The ``img_suffix`` is fixed to '.jpg' and ``seg_map_suffix`` is fixed to
-    '.png'.
-    """
-    METAINFO = dict(
-        classes=('wall', 'building', 'sky', 'floor', 'tree', 'ceiling', 'road',
-                 'bed ', 'windowpane', 'grass', 'cabinet', 'sidewalk',
-                 'person', 'earth', 'door', 'table', 'mountain', 'plant',
-                 'curtain', 'chair', 'car', 'water', 'painting', 'sofa',
-                 'shelf', 'house', 'sea', 'mirror', 'rug', 'field', 'armchair',
-                 'seat', 'fence', 'desk', 'rock', 'wardrobe', 'lamp',
-                 'bathtub', 'railing', 'cushion', 'base', 'box', 'column',
-                 'signboard', 'chest of drawers', 'counter', 'sand', 'sink',
-                 'skyscraper', 'fireplace', 'refrigerator', 'grandstand',
-                 'path', 'stairs', 'runway', 'case', 'pool table', 'pillow',
-                 'screen door', 'stairway', 'river', 'bridge', 'bookcase',
-                 'blind', 'coffee table', 'toilet', 'flower', 'book', 'hill',
-                 'bench', 'countertop', 'stove', 'palm', 'kitchen island',
-                 'computer', 'swivel chair', 'boat', 'bar', 'arcade machine',
-                 'hovel', 'bus', 'towel', 'light', 'truck', 'tower',
-                 'chandelier', 'awning', 'streetlight', 'booth',
-                 'television receiver', 'airplane', 'dirt track', 'apparel',
-                 'pole', 'land', 'bannister', 'escalator', 'ottoman', 'bottle',
-                 'buffet', 'poster', 'stage', 'van', 'ship', 'fountain',
-                 'conveyer belt', 'canopy', 'washer', 'plaything',
-                 'swimming pool', 'stool', 'barrel', 'basket', 'waterfall',
-                 'tent', 'bag', 'minibike', 'cradle', 'oven', 'ball', 'food',
-                 'step', 'tank', 'trade name', 'microwave', 'pot', 'animal',
-                 'bicycle', 'lake', 'dishwasher', 'screen', 'blanket',
-                 'sculpture', 'hood', 'sconce', 'vase', 'traffic light',
-                 'tray', 'ashcan', 'fan', 'pier', 'crt screen', 'plate',
-                 'monitor', 'bulletin board', 'shower', 'radiator', 'glass',
-                 'clock', 'flag'),
-        palette=[[120, 120, 120], [180, 120, 120], [6, 230, 230], [80, 50, 50],
-                 [4, 200, 3], [120, 120, 80], [140, 140, 140], [204, 5, 255],
-                 [230, 230, 230], [4, 250, 7], [224, 5, 255], [235, 255, 7],
-                 [150, 5, 61], [120, 120, 70], [8, 255, 51], [255, 6, 82],
-                 [143, 255, 140], [204, 255, 4], [255, 51, 7], [204, 70, 3],
-                 [0, 102, 200], [61, 230, 250], [255, 6, 51], [11, 102, 255],
-                 [255, 7, 71], [255, 9, 224], [9, 7, 230], [220, 220, 220],
-                 [255, 9, 92], [112, 9, 255], [8, 255, 214], [7, 255, 224],
-                 [255, 184, 6], [10, 255, 71], [255, 41, 10], [7, 255, 255],
-                 [224, 255, 8], [102, 8, 255], [255, 61, 6], [255, 194, 7],
-                 [255, 122, 8], [0, 255, 20], [255, 8, 41], [255, 5, 153],
-                 [6, 51, 255], [235, 12, 255], [160, 150, 20], [0, 163, 255],
-                 [140, 140, 140], [250, 10, 15], [20, 255, 0], [31, 255, 0],
-                 [255, 31, 0], [255, 224, 0], [153, 255, 0], [0, 0, 255],
-                 [255, 71, 0], [0, 235, 255], [0, 173, 255], [31, 0, 255],
-                 [11, 200, 200], [255, 82, 0], [0, 255, 245], [0, 61, 255],
-                 [0, 255, 112], [0, 255, 133], [255, 0, 0], [255, 163, 0],
-                 [255, 102, 0], [194, 255, 0], [0, 143, 255], [51, 255, 0],
-                 [0, 82, 255], [0, 255, 41], [0, 255, 173], [10, 0, 255],
-                 [173, 255, 0], [0, 255, 153], [255, 92, 0], [255, 0, 255],
-                 [255, 0, 245], [255, 0, 102], [255, 173, 0], [255, 0, 20],
-                 [255, 184, 184], [0, 31, 255], [0, 255, 61], [0, 71, 255],
-                 [255, 0, 204], [0, 255, 194], [0, 255, 82], [0, 10, 255],
-                 [0, 112, 255], [51, 0, 255], [0, 194, 255], [0, 122, 255],
-                 [0, 255, 163], [255, 153, 0], [0, 255, 10], [255, 112, 0],
-                 [143, 255, 0], [82, 0, 255], [163, 255, 0], [255, 235, 0],
-                 [8, 184, 170], [133, 0, 255], [0, 255, 92], [184, 0, 255],
-                 [255, 0, 31], [0, 184, 255], [0, 214, 255], [255, 0, 112],
-                 [92, 255, 0], [0, 224, 255], [112, 224, 255], [70, 184, 160],
-                 [163, 0, 255], [153, 0, 255], [71, 255, 0], [255, 0, 163],
-                 [255, 204, 0], [255, 0, 143], [0, 255, 235], [133, 255, 0],
-                 [255, 0, 235], [245, 0, 255], [255, 0, 122], [255, 245, 0],
-                 [10, 190, 212], [214, 255, 0], [0, 204, 255], [20, 0, 255],
-                 [255, 255, 0], [0, 153, 255], [0, 41, 255], [0, 255, 204],
-                 [41, 0, 255], [41, 255, 0], [173, 0, 255], [0, 245, 255],
-                 [71, 0, 255], [122, 0, 255], [0, 255, 184], [0, 92, 255],
-                 [184, 255, 0], [0, 133, 255], [255, 214, 0], [25, 194, 194],
-                 [102, 255, 0], [92, 0, 255]])
-
-    def __init__(self,
-                 img_suffix='.jpg',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=True,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/basesegdataset.py b/mmsegmentation/mmseg/datasets/basesegdataset.py
deleted file mode 100644
index 3a5c49c..0000000
--- a/mmsegmentation/mmseg/datasets/basesegdataset.py
+++ /dev/null
@@ -1,552 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import copy
-import os.path as osp
-from typing import Callable, Dict, List, Optional, Sequence, Union
-
-import mmengine
-import mmengine.fileio as fileio
-import numpy as np
-from mmengine.dataset import BaseDataset, Compose
-
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class BaseSegDataset(BaseDataset):
-    """Custom dataset for semantic segmentation. An example of file structure
-    is as followed.
-
-    .. code-block:: none
-
-        ├── data
-        │   ├── my_dataset
-        │   │   ├── img_dir
-        │   │   │   ├── train
-        │   │   │   │   ├── xxx{img_suffix}
-        │   │   │   │   ├── yyy{img_suffix}
-        │   │   │   │   ├── zzz{img_suffix}
-        │   │   │   ├── val
-        │   │   ├── ann_dir
-        │   │   │   ├── train
-        │   │   │   │   ├── xxx{seg_map_suffix}
-        │   │   │   │   ├── yyy{seg_map_suffix}
-        │   │   │   │   ├── zzz{seg_map_suffix}
-        │   │   │   ├── val
-
-    The img/gt_semantic_seg pair of BaseSegDataset should be of the same
-    except suffix. A valid img/gt_semantic_seg filename pair should be like
-    ``xxx{img_suffix}`` and ``xxx{seg_map_suffix}`` (extension is also included
-    in the suffix). If split is given, then ``xxx`` is specified in txt file.
-    Otherwise, all files in ``img_dir/``and ``ann_dir`` will be loaded.
-    Please refer to ``docs/en/tutorials/new_dataset.md`` for more details.
-
-
-    Args:
-        ann_file (str): Annotation file path. Defaults to ''.
-        metainfo (dict, optional): Meta information for dataset, such as
-            specify classes to load. Defaults to None.
-        data_root (str, optional): The root directory for ``data_prefix`` and
-            ``ann_file``. Defaults to None.
-        data_prefix (dict, optional): Prefix for training data. Defaults to
-            dict(img_path=None, seg_map_path=None).
-        img_suffix (str): Suffix of images. Default: '.jpg'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-        filter_cfg (dict, optional): Config for filter data. Defaults to None.
-        indices (int or Sequence[int], optional): Support using first few
-            data in annotation file to facilitate training/testing on a smaller
-            dataset. Defaults to None which means using all ``data_infos``.
-        serialize_data (bool, optional): Whether to hold memory using
-            serialized objects, when enabled, data loader workers can use
-            shared RAM from master process instead of making a copy. Defaults
-            to True.
-        pipeline (list, optional): Processing pipeline. Defaults to [].
-        test_mode (bool, optional): ``test_mode=True`` means in test phase.
-            Defaults to False.
-        lazy_init (bool, optional): Whether to load annotation during
-            instantiation. In some cases, such as visualization, only the meta
-            information of the dataset is needed, which is not necessary to
-            load annotation file. ``Basedataset`` can skip load annotations to
-            save time by set ``lazy_init=True``. Defaults to False.
-        max_refetch (int, optional): If ``Basedataset.prepare_data`` get a
-            None img. The maximum extra number of cycles to get a valid
-            image. Defaults to 1000.
-        ignore_index (int): The label index to be ignored. Default: 255
-        reduce_zero_label (bool): Whether to mark label zero as ignored.
-            Default to False.
-        backend_args (dict, Optional): Arguments to instantiate a file backend.
-            See https://mmengine.readthedocs.io/en/latest/api/fileio.htm
-            for details. Defaults to None.
-            Notes: mmcv>=2.0.0rc4, mmengine>=0.2.0 required.
-    """
-    METAINFO: dict = dict()
-
-    def __init__(self,
-                 ann_file: str = '',
-                 img_suffix='.jpg',
-                 seg_map_suffix='.png',
-                 metainfo: Optional[dict] = None,
-                 data_root: Optional[str] = None,
-                 data_prefix: dict = dict(img_path='', seg_map_path=''),
-                 filter_cfg: Optional[dict] = None,
-                 indices: Optional[Union[int, Sequence[int]]] = None,
-                 serialize_data: bool = True,
-                 pipeline: List[Union[dict, Callable]] = [],
-                 test_mode: bool = False,
-                 lazy_init: bool = False,
-                 max_refetch: int = 1000,
-                 ignore_index: int = 255,
-                 reduce_zero_label: bool = False,
-                 backend_args: Optional[dict] = None) -> None:
-
-        self.img_suffix = img_suffix
-        self.seg_map_suffix = seg_map_suffix
-        self.ignore_index = ignore_index
-        self.reduce_zero_label = reduce_zero_label
-        self.backend_args = backend_args.copy() if backend_args else None
-
-        self.data_root = data_root
-        self.data_prefix = copy.copy(data_prefix)
-        self.ann_file = ann_file
-        self.filter_cfg = copy.deepcopy(filter_cfg)
-        self._indices = indices
-        self.serialize_data = serialize_data
-        self.test_mode = test_mode
-        self.max_refetch = max_refetch
-        self.data_list: List[dict] = []
-        self.data_bytes: np.ndarray
-
-        # Set meta information.
-        self._metainfo = self._load_metainfo(copy.deepcopy(metainfo))
-
-        # Get label map for custom classes
-        new_classes = self._metainfo.get('classes', None)
-        self.label_map = self.get_label_map(new_classes)
-        self._metainfo.update(
-            dict(
-                label_map=self.label_map,
-                reduce_zero_label=self.reduce_zero_label))
-        
-        # Update palette based on label map or generate palette
-        # if it is not defined
-        updated_palette = self._update_palette()
-        self._metainfo.update(dict(palette=updated_palette))
-
-        # Join paths.
-        if self.data_root is not None:
-            self._join_prefix()
-
-        # Build pipeline.
-        self.pipeline = Compose(pipeline)
-        # Full initialize the dataset.
-        if not lazy_init:
-            self.full_init()
-
-        if test_mode:
-            assert self._metainfo.get('classes') is not None, \
-                'dataset metainfo `classes` should be specified when testing'
-
-    @classmethod
-    def get_label_map(cls,
-                      new_classes: Optional[Sequence] = None
-                      ) -> Union[Dict, None]:
-        """Require label mapping.
-
-        The ``label_map`` is a dictionary, its keys are the old label ids and
-        its values are the new label ids, and is used for changing pixel
-        labels in load_annotations. If and only if old classes in cls.METAINFO
-        is not equal to new classes in self._metainfo and nether of them is not
-        None, `label_map` is not None.
-
-        Args:
-            new_classes (list, tuple, optional): The new classes name from
-                metainfo. Default to None.
-
-
-        Returns:
-            dict, optional: The mapping from old classes in cls.METAINFO to
-                new classes in self._metainfo
-        """
-        old_classes = cls.METAINFO.get('classes', None)
-        if (new_classes is not None and old_classes is not None
-                and list(new_classes) != list(old_classes)):
-
-            label_map = {}
-            if not set(new_classes).issubset(cls.METAINFO['classes']):
-                raise ValueError(
-                    f'new classes {new_classes} is not a '
-                    f'subset of classes {old_classes} in METAINFO.')
-            for i, c in enumerate(old_classes):
-                if c not in new_classes:
-                    label_map[i] = 255
-                else:
-                    label_map[i] = new_classes.index(c)
-            return label_map
-        else:
-            return None
-
-    def _update_palette(self) -> list:
-        """Update palette after loading metainfo.
-
-        If length of palette is equal to classes, just return the palette.
-        If palette is not defined, it will randomly generate a palette.
-        If classes is updated by customer, it will return the subset of
-        palette.
-
-        Returns:
-            Sequence: Palette for current dataset.
-        """
-        palette = self._metainfo.get('palette', [])
-        classes = self._metainfo.get('classes', [])
-        # palette does match classes
-        if len(palette) == len(classes):
-            return palette
-
-        if len(palette) == 0:
-            # Get random state before set seed, and restore
-            # random state later.
-            # It will prevent loss of randomness, as the palette
-            # may be different in each iteration if not specified.
-            # See: https://github.com/open-mmlab/mmdetection/issues/5844
-            state = np.random.get_state()
-            np.random.seed(42)
-            # random palette
-            new_palette = np.random.randint(
-                0, 255, size=(len(classes), 3)).tolist()
-            np.random.set_state(state)
-        elif len(palette) >= len(classes) and self.label_map is not None:
-            new_palette = []
-            # return subset of palette
-            for old_id, new_id in sorted(
-                    self.label_map.items(), key=lambda x: x[1]):
-                if new_id != 255:
-                    new_palette.append(palette[old_id])
-            new_palette = type(palette)(new_palette)
-        else:
-            raise ValueError('palette does not match classes '
-                             f'as metainfo is {self._metainfo}.')
-        return new_palette
-
-    def load_data_list(self) -> List[dict]:
-        """Load annotation from directory or annotation file.
-
-        Returns:
-            list[dict]: All data info of dataset.
-        """
-        data_list = []
-        img_dir = self.data_prefix.get('img_path', None)
-        ann_dir = self.data_prefix.get('seg_map_path', None)
-        if not osp.isdir(self.ann_file) and self.ann_file:
-            assert osp.isfile(self.ann_file), \
-                f'Failed to load `ann_file` {self.ann_file}'
-            lines = mmengine.list_from_file(
-                self.ann_file, backend_args=self.backend_args)
-            for line in lines:
-                img_name = line.strip()
-                data_info = dict(
-                    img_path=osp.join(img_dir, img_name + self.img_suffix))
-                if ann_dir is not None:
-                    seg_map = img_name + self.seg_map_suffix
-                    data_info['seg_map_path'] = osp.join(ann_dir, seg_map)
-                data_info['label_map'] = self.label_map
-                data_info['reduce_zero_label'] = self.reduce_zero_label
-                data_info['seg_fields'] = []
-                data_list.append(data_info)
-        else:
-            _suffix_len = len(self.img_suffix)
-            for img in fileio.list_dir_or_file(
-                    dir_path=img_dir,
-                    list_dir=False,
-                    suffix=self.img_suffix,
-                    recursive=True,
-                    backend_args=self.backend_args):
-                data_info = dict(img_path=osp.join(img_dir, img))
-                if ann_dir is not None:
-                    seg_map = img[:-_suffix_len] + self.seg_map_suffix
-                    data_info['seg_map_path'] = osp.join(ann_dir, seg_map)
-                data_info['label_map'] = self.label_map
-                data_info['reduce_zero_label'] = self.reduce_zero_label
-                data_info['seg_fields'] = []
-                data_list.append(data_info)
-            data_list = sorted(data_list, key=lambda x: x['img_path'])
-        return data_list
-
-
-@DATASETS.register_module()
-class BaseCDDataset(BaseDataset):
-    """Custom dataset for change detection. An example of file structure is as
-    followed.
-
-    .. code-block:: none
-
-        ├── data
-        │   ├── my_dataset
-        │   │   ├── img_dir
-        │   │   │   ├── train
-        │   │   │   │   ├── xxx{img_suffix}
-        │   │   │   │   ├── yyy{img_suffix}
-        │   │   │   │   ├── zzz{img_suffix}
-        │   │   │   ├── val
-        │   │   ├── img_dir2
-        │   │   │   ├── train
-        │   │   │   │   ├── xxx{img_suffix}
-        │   │   │   │   ├── yyy{img_suffix}
-        │   │   │   │   ├── zzz{img_suffix}
-        │   │   │   ├── val
-        │   │   ├── ann_dir
-        │   │   │   ├── train
-        │   │   │   │   ├── xxx{seg_map_suffix}
-        │   │   │   │   ├── yyy{seg_map_suffix}
-        │   │   │   │   ├── zzz{seg_map_suffix}
-        │   │   │   ├── val
-
-    The image names in img_dir and img_dir2 should be consistent.
-    The img/gt_semantic_seg pair of BaseSegDataset should be of the same
-    except suffix. A valid img/gt_semantic_seg filename pair should be like
-    ``xxx{img_suffix}`` and ``xxx{seg_map_suffix}`` (extension is also included
-    in the suffix). If split is given, then ``xxx`` is specified in txt file.
-    Otherwise, all files in ``img_dir/``and ``ann_dir`` will be loaded.
-    Please refer to ``docs/en/tutorials/new_dataset.md`` for more details.
-
-
-    Args:
-        ann_file (str): Annotation file path. Defaults to ''.
-        metainfo (dict, optional): Meta information for dataset, such as
-            specify classes to load. Defaults to None.
-        data_root (str, optional): The root directory for ``data_prefix`` and
-            ``ann_file``. Defaults to None.
-        data_prefix (dict, optional): Prefix for training data. Defaults to
-            dict(img_path=None, img_path2=None, seg_map_path=None).
-        img_suffix (str): Suffix of images. Default: '.jpg'
-        img_suffix2 (str): Suffix of images. Default: '.jpg'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-        filter_cfg (dict, optional): Config for filter data. Defaults to None.
-        indices (int or Sequence[int], optional): Support using first few
-            data in annotation file to facilitate training/testing on a smaller
-            dataset. Defaults to None which means using all ``data_infos``.
-        serialize_data (bool, optional): Whether to hold memory using
-            serialized objects, when enabled, data loader workers can use
-            shared RAM from master process instead of making a copy. Defaults
-            to True.
-        pipeline (list, optional): Processing pipeline. Defaults to [].
-        test_mode (bool, optional): ``test_mode=True`` means in test phase.
-            Defaults to False.
-        lazy_init (bool, optional): Whether to load annotation during
-            instantiation. In some cases, such as visualization, only the meta
-            information of the dataset is needed, which is not necessary to
-            load annotation file. ``Basedataset`` can skip load annotations to
-            save time by set ``lazy_init=True``. Defaults to False.
-        max_refetch (int, optional): If ``Basedataset.prepare_data`` get a
-            None img. The maximum extra number of cycles to get a valid
-            image. Defaults to 1000.
-        ignore_index (int): The label index to be ignored. Default: 255
-        reduce_zero_label (bool): Whether to mark label zero as ignored.
-            Default to False.
-        backend_args (dict, Optional): Arguments to instantiate a file backend.
-            See https://mmengine.readthedocs.io/en/latest/api/fileio.htm
-            for details. Defaults to None.
-            Notes: mmcv>=2.0.0rc4, mmengine>=0.2.0 required.
-    """
-    METAINFO: dict = dict()
-
-    def __init__(self,
-                 ann_file: str = '',
-                 img_suffix='.jpg',
-                 img_suffix2='.jpg',
-                 seg_map_suffix='.png',
-                 metainfo: Optional[dict] = None,
-                 data_root: Optional[str] = None,
-                 data_prefix: dict = dict(
-                     img_path='', img_path2='', seg_map_path=''),
-                 filter_cfg: Optional[dict] = None,
-                 indices: Optional[Union[int, Sequence[int]]] = None,
-                 serialize_data: bool = True,
-                 pipeline: List[Union[dict, Callable]] = [],
-                 test_mode: bool = False,
-                 lazy_init: bool = False,
-                 max_refetch: int = 1000,
-                 ignore_index: int = 255,
-                 reduce_zero_label: bool = False,
-                 backend_args: Optional[dict] = None) -> None:
-
-        self.img_suffix = img_suffix
-        self.img_suffix2 = img_suffix2
-        self.seg_map_suffix = seg_map_suffix
-        self.ignore_index = ignore_index
-        self.reduce_zero_label = reduce_zero_label
-        self.backend_args = backend_args.copy() if backend_args else None
-
-        self.data_root = data_root
-        self.data_prefix = copy.copy(data_prefix)
-        self.ann_file = ann_file
-        self.filter_cfg = copy.deepcopy(filter_cfg)
-        self._indices = indices
-        self.serialize_data = serialize_data
-        self.test_mode = test_mode
-        self.max_refetch = max_refetch
-        self.data_list: List[dict] = []
-        self.data_bytes: np.ndarray
-
-        # Set meta information.
-        self._metainfo = self._load_metainfo(copy.deepcopy(metainfo))
-
-        # Get label map for custom classes
-        new_classes = self._metainfo.get('classes', None)
-        self.label_map = self.get_label_map(new_classes)
-        self._metainfo.update(
-            dict(
-                label_map=self.label_map,
-                reduce_zero_label=self.reduce_zero_label))
-
-        # Update palette based on label map or generate palette
-        # if it is not defined
-        updated_palette = self._update_palette()
-        self._metainfo.update(dict(palette=updated_palette))
-
-        # Join paths.
-        if self.data_root is not None:
-            self._join_prefix()
-
-        # Build pipeline.
-        self.pipeline = Compose(pipeline)
-        # Full initialize the dataset.
-        if not lazy_init:
-            self.full_init()
-
-        if test_mode:
-            assert self._metainfo.get('classes') is not None, \
-                'dataset metainfo `classes` should be specified when testing'
-
-    @classmethod
-    def get_label_map(cls,
-                      new_classes: Optional[Sequence] = None
-                      ) -> Union[Dict, None]:
-        """Require label mapping.
-
-        The ``label_map`` is a dictionary, its keys are the old label ids and
-        its values are the new label ids, and is used for changing pixel
-        labels in load_annotations. If and only if old classes in cls.METAINFO
-        is not equal to new classes in self._metainfo and nether of them is not
-        None, `label_map` is not None.
-
-        Args:
-            new_classes (list, tuple, optional): The new classes name from
-                metainfo. Default to None.
-
-
-        Returns:
-            dict, optional: The mapping from old classes in cls.METAINFO to
-                new classes in self._metainfo
-        """
-        old_classes = cls.METAINFO.get('classes', None)
-        if (new_classes is not None and old_classes is not None
-                and list(new_classes) != list(old_classes)):
-
-            label_map = {}
-            if not set(new_classes).issubset(cls.METAINFO['classes']):
-                raise ValueError(
-                    f'new classes {new_classes} is not a '
-                    f'subset of classes {old_classes} in METAINFO.')
-            for i, c in enumerate(old_classes):
-                if c not in new_classes:
-                    label_map[i] = 255
-                else:
-                    label_map[i] = new_classes.index(c)
-            return label_map
-        else:
-            return None
-
-    def _update_palette(self) -> list:
-        """Update palette after loading metainfo.
-
-        If length of palette is equal to classes, just return the palette.
-        If palette is not defined, it will randomly generate a palette.
-        If classes is updated by customer, it will return the subset of
-        palette.
-
-        Returns:
-            Sequence: Palette for current dataset.
-        """
-        palette = self._metainfo.get('palette', [])
-        classes = self._metainfo.get('classes', [])
-        # palette does match classes
-        if len(palette) == len(classes):
-            return palette
-
-        if len(palette) == 0:
-            # Get random state before set seed, and restore
-            # random state later.
-            # It will prevent loss of randomness, as the palette
-            # may be different in each iteration if not specified.
-            # See: https://github.com/open-mmlab/mmdetection/issues/5844
-            state = np.random.get_state()
-            np.random.seed(42)
-            # random palette
-            new_palette = np.random.randint(
-                0, 255, size=(len(classes), 3)).tolist()
-            np.random.set_state(state)
-        elif len(palette) >= len(classes) and self.label_map is not None:
-            new_palette = []
-            # return subset of palette
-            for old_id, new_id in sorted(
-                    self.label_map.items(), key=lambda x: x[1]):
-                if new_id != 255:
-                    new_palette.append(palette[old_id])
-            new_palette = type(palette)(new_palette)
-        else:
-            raise ValueError('palette does not match classes '
-                             f'as metainfo is {self._metainfo}.')
-        return new_palette
-
-    def load_data_list(self) -> List[dict]:
-        """Load annotation from directory or annotation file.
-
-        Returns:
-            list[dict]: All data info of dataset.
-        """
-        data_list = []
-        img_dir = self.data_prefix.get('img_path', None)
-        img_dir2 = self.data_prefix.get('img_path2', None)
-        ann_dir = self.data_prefix.get('seg_map_path', None)
-        if osp.isfile(self.ann_file):
-            lines = mmengine.list_from_file(
-                self.ann_file, backend_args=self.backend_args)
-            for line in lines:
-                img_name = line.strip()
-                if '.' in osp.basename(img_name):
-                    img_name, img_ext = osp.splitext(img_name)
-                    self.img_suffix = img_ext
-                    self.img_suffix2 = img_ext
-                data_info = dict(
-                    img_path=osp.join(img_dir, img_name + self.img_suffix),
-                    img_path2=osp.join(img_dir2, img_name + self.img_suffix2))
-
-                if ann_dir is not None:
-                    seg_map = img_name + self.seg_map_suffix
-                    data_info['seg_map_path'] = osp.join(ann_dir, seg_map)
-                data_info['label_map'] = self.label_map
-                data_info['reduce_zero_label'] = self.reduce_zero_label
-                data_info['seg_fields'] = []
-                data_list.append(data_info)
-        else:
-            for img in fileio.list_dir_or_file(
-                    dir_path=img_dir,
-                    list_dir=False,
-                    suffix=self.img_suffix,
-                    recursive=True,
-                    backend_args=self.backend_args):
-                if '.' in osp.basename(img):
-                    img, img_ext = osp.splitext(img)
-                    self.img_suffix = img_ext
-                    self.img_suffix2 = img_ext
-                data_info = dict(
-                    img_path=osp.join(img_dir, img + self.img_suffix),
-                    img_path2=osp.join(img_dir2, img + self.img_suffix2))
-                if ann_dir is not None:
-                    seg_map = img + self.seg_map_suffix
-                    data_info['seg_map_path'] = osp.join(ann_dir, seg_map)
-                data_info['label_map'] = self.label_map
-                data_info['reduce_zero_label'] = self.reduce_zero_label
-                data_info['seg_fields'] = []
-                data_list.append(data_info)
-            data_list = sorted(data_list, key=lambda x: x['img_path'])
-        return data_list
diff --git a/mmsegmentation/mmseg/datasets/bdd100k.py b/mmsegmentation/mmseg/datasets/bdd100k.py
deleted file mode 100644
index 8ae70b5..0000000
--- a/mmsegmentation/mmseg/datasets/bdd100k.py
+++ /dev/null
@@ -1,30 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-
-from mmseg.datasets.basesegdataset import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class BDD100KDataset(BaseSegDataset):
-    METAINFO = dict(
-        classes=('road', 'sidewalk', 'building', 'wall', 'fence', 'pole',
-                 'traffic light', 'traffic sign', 'vegetation', 'terrain',
-                 'sky', 'person', 'rider', 'car', 'truck', 'bus', 'train',
-                 'motorcycle', 'bicycle'),
-        palette=[[128, 64, 128], [244, 35, 232], [70, 70, 70], [102, 102, 156],
-                 [190, 153, 153], [153, 153, 153], [250, 170,
-                                                    30], [220, 220, 0],
-                 [107, 142, 35], [152, 251, 152], [70, 130, 180],
-                 [220, 20, 60], [255, 0, 0], [0, 0, 142], [0, 0, 70],
-                 [0, 60, 100], [0, 80, 100], [0, 0, 230], [119, 11, 32]])
-
-    def __init__(self,
-                 img_suffix='.jpg',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/chase_db1.py b/mmsegmentation/mmseg/datasets/chase_db1.py
deleted file mode 100644
index 626ddf7..0000000
--- a/mmsegmentation/mmseg/datasets/chase_db1.py
+++ /dev/null
@@ -1,32 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import mmengine.fileio as fileio
-
-from mmseg.registry import DATASETS
-from .basesegdataset import BaseSegDataset
-
-
-@DATASETS.register_module()
-class ChaseDB1Dataset(BaseSegDataset):
-    """Chase_db1 dataset.
-
-    In segmentation map annotation for Chase_db1, 0 stands for background,
-    which is included in 2 categories. ``reduce_zero_label`` is fixed to False.
-    The ``img_suffix`` is fixed to '.png' and ``seg_map_suffix`` is fixed to
-    '_1stHO.png'.
-    """
-    METAINFO = dict(
-        classes=('background', 'vessel'),
-        palette=[[120, 120, 120], [6, 230, 230]])
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='_1stHO.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
-        assert fileio.exists(
-            self.data_prefix['img_path'], backend_args=self.backend_args)
diff --git a/mmsegmentation/mmseg/datasets/cityscapes.py b/mmsegmentation/mmseg/datasets/cityscapes.py
deleted file mode 100644
index f494d62..0000000
--- a/mmsegmentation/mmseg/datasets/cityscapes.py
+++ /dev/null
@@ -1,30 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmseg.registry import DATASETS
-from .basesegdataset import BaseSegDataset
-
-
-@DATASETS.register_module()
-class CityscapesDataset(BaseSegDataset):
-    """Cityscapes dataset.
-
-    The ``img_suffix`` is fixed to '_leftImg8bit.png' and ``seg_map_suffix`` is
-    fixed to '_gtFine_labelTrainIds.png' for Cityscapes dataset.
-    """
-    METAINFO = dict(
-        classes=('road', 'sidewalk', 'building', 'wall', 'fence', 'pole',
-                 'traffic light', 'traffic sign', 'vegetation', 'terrain',
-                 'sky', 'person', 'rider', 'car', 'truck', 'bus', 'train',
-                 'motorcycle', 'bicycle'),
-        palette=[[128, 64, 128], [244, 35, 232], [70, 70, 70], [102, 102, 156],
-                 [190, 153, 153], [153, 153, 153], [250, 170,
-                                                    30], [220, 220, 0],
-                 [107, 142, 35], [152, 251, 152], [70, 130, 180],
-                 [220, 20, 60], [255, 0, 0], [0, 0, 142], [0, 0, 70],
-                 [0, 60, 100], [0, 80, 100], [0, 0, 230], [119, 11, 32]])
-
-    def __init__(self,
-                 img_suffix='_leftImg8bit.png',
-                 seg_map_suffix='_gtFine_labelTrainIds.png',
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/coco_stuff.py b/mmsegmentation/mmseg/datasets/coco_stuff.py
deleted file mode 100644
index 1e1574d..0000000
--- a/mmsegmentation/mmseg/datasets/coco_stuff.py
+++ /dev/null
@@ -1,99 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmseg.registry import DATASETS
-from .basesegdataset import BaseSegDataset
-
-
-@DATASETS.register_module()
-class COCOStuffDataset(BaseSegDataset):
-    """COCO-Stuff dataset.
-
-    In segmentation map annotation for COCO-Stuff, Train-IDs of the 10k version
-    are from 1 to 171, where 0 is the ignore index, and Train-ID of COCO Stuff
-    164k is from 0 to 170, where 255 is the ignore index. So, they are all 171
-    semantic categories. ``reduce_zero_label`` is set to True and False for the
-    10k and 164k versions, respectively. The ``img_suffix`` is fixed to '.jpg',
-    and ``seg_map_suffix`` is fixed to '.png'.
-    """
-    METAINFO = dict(
-        classes=(
-            'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',
-            'train', 'truck', 'boat', 'traffic light', 'fire hydrant',
-            'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog',
-            'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe',
-            'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee',
-            'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat',
-            'baseball glove', 'skateboard', 'surfboard', 'tennis racket',
-            'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl',
-            'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot',
-            'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch',
-            'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop',
-            'mouse', 'remote', 'keyboard', 'cell phone', 'microwave', 'oven',
-            'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',
-            'scissors', 'teddy bear', 'hair drier', 'toothbrush', 'banner',
-            'blanket', 'branch', 'bridge', 'building-other', 'bush', 'cabinet',
-            'cage', 'cardboard', 'carpet', 'ceiling-other', 'ceiling-tile',
-            'cloth', 'clothes', 'clouds', 'counter', 'cupboard', 'curtain',
-            'desk-stuff', 'dirt', 'door-stuff', 'fence', 'floor-marble',
-            'floor-other', 'floor-stone', 'floor-tile', 'floor-wood', 'flower',
-            'fog', 'food-other', 'fruit', 'furniture-other', 'grass', 'gravel',
-            'ground-other', 'hill', 'house', 'leaves', 'light', 'mat', 'metal',
-            'mirror-stuff', 'moss', 'mountain', 'mud', 'napkin', 'net',
-            'paper', 'pavement', 'pillow', 'plant-other', 'plastic',
-            'platform', 'playingfield', 'railing', 'railroad', 'river', 'road',
-            'rock', 'roof', 'rug', 'salad', 'sand', 'sea', 'shelf',
-            'sky-other', 'skyscraper', 'snow', 'solid-other', 'stairs',
-            'stone', 'straw', 'structural-other', 'table', 'tent',
-            'textile-other', 'towel', 'tree', 'vegetable', 'wall-brick',
-            'wall-concrete', 'wall-other', 'wall-panel', 'wall-stone',
-            'wall-tile', 'wall-wood', 'water-other', 'waterdrops',
-            'window-blind', 'window-other', 'wood'),
-        palette=[[0, 192, 64], [0, 192, 64], [0, 64, 96], [128, 192, 192],
-                 [0, 64, 64], [0, 192, 224], [0, 192, 192], [128, 192, 64],
-                 [0, 192, 96], [128, 192, 64], [128, 32, 192], [0, 0, 224],
-                 [0, 0, 64], [0, 160, 192], [128, 0, 96], [128, 0, 192],
-                 [0, 32, 192], [128, 128, 224], [0, 0, 192], [128, 160, 192],
-                 [128, 128, 0], [128, 0, 32], [128, 32, 0], [128, 0, 128],
-                 [64, 128, 32], [0, 160, 0], [0, 0, 0], [192, 128, 160],
-                 [0, 32, 0], [0, 128, 128], [64, 128, 160], [128, 160, 0],
-                 [0, 128, 0], [192, 128, 32], [128, 96, 128], [0, 0, 128],
-                 [64, 0, 32], [0, 224, 128], [128, 0, 0], [192, 0, 160],
-                 [0, 96, 128], [128, 128, 128], [64, 0, 160], [128, 224, 128],
-                 [128, 128, 64], [192, 0, 32], [128, 96, 0], [128, 0, 192],
-                 [0, 128, 32], [64, 224, 0], [0, 0, 64], [128, 128, 160],
-                 [64, 96, 0], [0, 128, 192], [0, 128, 160], [192, 224, 0],
-                 [0, 128, 64], [128, 128, 32], [192, 32, 128], [0, 64, 192],
-                 [0, 0, 32], [64, 160, 128], [128, 64, 64], [128, 0, 160],
-                 [64, 32, 128], [128, 192, 192], [0, 0, 160], [192, 160, 128],
-                 [128, 192, 0], [128, 0, 96], [192, 32, 0], [128, 64, 128],
-                 [64, 128, 96], [64, 160, 0], [0, 64, 0], [192, 128, 224],
-                 [64, 32, 0], [0, 192, 128], [64, 128, 224], [192, 160, 0],
-                 [0, 192, 0], [192, 128, 96], [192, 96, 128], [0, 64, 128],
-                 [64, 0, 96], [64, 224, 128], [128, 64, 0], [192, 0, 224],
-                 [64, 96, 128], [128, 192, 128], [64, 0, 224], [192, 224, 128],
-                 [128, 192, 64], [192, 0, 96], [192, 96, 0], [128, 64, 192],
-                 [0, 128, 96], [0, 224, 0], [64, 64, 64], [128, 128, 224],
-                 [0, 96, 0], [64, 192, 192], [0, 128, 224], [128, 224, 0],
-                 [64, 192, 64], [128, 128, 96], [128, 32, 128], [64, 0, 192],
-                 [0, 64, 96], [0, 160, 128], [192, 0, 64], [128, 64, 224],
-                 [0, 32, 128], [192, 128, 192], [0, 64, 224], [128, 160, 128],
-                 [192, 128, 0], [128, 64, 32], [128, 32, 64], [192, 0, 128],
-                 [64, 192, 32], [0, 160, 64], [64, 0, 0], [192, 192, 160],
-                 [0, 32, 64], [64, 128, 128], [64, 192, 160], [128, 160, 64],
-                 [64, 128, 0], [192, 192, 32], [128, 96, 192], [64, 0, 128],
-                 [64, 64, 32], [0, 224, 192], [192, 0, 0], [192, 64, 160],
-                 [0, 96, 192], [192, 128, 128], [64, 64, 160], [128, 224, 192],
-                 [192, 128, 64], [192, 64, 32], [128, 96, 64], [192, 0, 192],
-                 [0, 192, 32], [64, 224, 64], [64, 0, 64], [128, 192, 160],
-                 [64, 96, 64], [64, 128, 192], [0, 192, 160], [192, 224, 64],
-                 [64, 128, 64], [128, 192, 32], [192, 32, 192], [64, 64, 192],
-                 [0, 64, 32], [64, 160, 192], [192, 64, 64], [128, 64, 160],
-                 [64, 32, 192], [192, 192, 192], [0, 64, 160], [192, 160, 192],
-                 [192, 192, 0], [128, 64, 96], [192, 32, 64], [192, 64, 128],
-                 [64, 192, 96], [64, 160, 64], [64, 64, 0]])
-
-    def __init__(self,
-                 img_suffix='.jpg',
-                 seg_map_suffix='_labelTrainIds.png',
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/dark_zurich.py b/mmsegmentation/mmseg/datasets/dark_zurich.py
deleted file mode 100644
index 9b5393f..0000000
--- a/mmsegmentation/mmseg/datasets/dark_zurich.py
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmseg.registry import DATASETS
-from .cityscapes import CityscapesDataset
-
-
-@DATASETS.register_module()
-class DarkZurichDataset(CityscapesDataset):
-    """DarkZurichDataset dataset."""
-
-    def __init__(self,
-                 img_suffix='_rgb_anon.png',
-                 seg_map_suffix='_gt_labelTrainIds.png',
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/dataset_wrappers.py b/mmsegmentation/mmseg/datasets/dataset_wrappers.py
deleted file mode 100644
index 082c116..0000000
--- a/mmsegmentation/mmseg/datasets/dataset_wrappers.py
+++ /dev/null
@@ -1,136 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import collections
-import copy
-from typing import List, Optional, Sequence, Union
-
-from mmengine.dataset import ConcatDataset, force_full_init
-
-from mmseg.registry import DATASETS, TRANSFORMS
-
-
-@DATASETS.register_module()
-class MultiImageMixDataset:
-    """A wrapper of multiple images mixed dataset.
-
-    Suitable for training on multiple images mixed data augmentation like
-    mosaic and mixup.
-
-    Args:
-        dataset (ConcatDataset or dict): The dataset to be mixed.
-        pipeline (Sequence[dict]): Sequence of transform object or
-            config dict to be composed.
-        skip_type_keys (list[str], optional): Sequence of type string to
-            be skip pipeline. Default to None.
-    """
-
-    def __init__(self,
-                 dataset: Union[ConcatDataset, dict],
-                 pipeline: Sequence[dict],
-                 skip_type_keys: Optional[List[str]] = None,
-                 lazy_init: bool = False) -> None:
-        assert isinstance(pipeline, collections.abc.Sequence)
-
-        if isinstance(dataset, dict):
-            self.dataset = DATASETS.build(dataset)
-        elif isinstance(dataset, ConcatDataset):
-            self.dataset = dataset
-        else:
-            raise TypeError(
-                'elements in datasets sequence should be config or '
-                f'`ConcatDataset` instance, but got {type(dataset)}')
-
-        if skip_type_keys is not None:
-            assert all([
-                isinstance(skip_type_key, str)
-                for skip_type_key in skip_type_keys
-            ])
-        self._skip_type_keys = skip_type_keys
-
-        self.pipeline = []
-        self.pipeline_types = []
-        for transform in pipeline:
-            if isinstance(transform, dict):
-                self.pipeline_types.append(transform['type'])
-                transform = TRANSFORMS.build(transform)
-                self.pipeline.append(transform)
-            else:
-                raise TypeError('pipeline must be a dict')
-
-        self._metainfo = self.dataset.metainfo
-        self.num_samples = len(self.dataset)
-
-        self._fully_initialized = False
-        if not lazy_init:
-            self.full_init()
-
-    @property
-    def metainfo(self) -> dict:
-        """Get the meta information of the multi-image-mixed dataset.
-
-        Returns:
-            dict: The meta information of multi-image-mixed dataset.
-        """
-        return copy.deepcopy(self._metainfo)
-
-    def full_init(self):
-        """Loop to ``full_init`` each dataset."""
-        if self._fully_initialized:
-            return
-
-        self.dataset.full_init()
-        self._ori_len = len(self.dataset)
-        self._fully_initialized = True
-
-    @force_full_init
-    def get_data_info(self, idx: int) -> dict:
-        """Get annotation by index.
-
-        Args:
-            idx (int): Global index of ``ConcatDataset``.
-
-        Returns:
-            dict: The idx-th annotation of the datasets.
-        """
-        return self.dataset.get_data_info(idx)
-
-    @force_full_init
-    def __len__(self):
-        return self.num_samples
-
-    def __getitem__(self, idx):
-        results = copy.deepcopy(self.dataset[idx])
-        for (transform, transform_type) in zip(self.pipeline,
-                                               self.pipeline_types):
-            if self._skip_type_keys is not None and \
-                    transform_type in self._skip_type_keys:
-                continue
-
-            if hasattr(transform, 'get_indices'):
-                indices = transform.get_indices(self.dataset)
-                if not isinstance(indices, collections.abc.Sequence):
-                    indices = [indices]
-                mix_results = [
-                    copy.deepcopy(self.dataset[index]) for index in indices
-                ]
-                results['mix_results'] = mix_results
-
-            results = transform(results)
-
-            if 'mix_results' in results:
-                results.pop('mix_results')
-
-        return results
-
-    def update_skip_type_keys(self, skip_type_keys):
-        """Update skip_type_keys.
-
-        It is called by an external hook.
-
-        Args:
-            skip_type_keys (list[str], optional): Sequence of type
-                string to be skip pipeline.
-        """
-        assert all([
-            isinstance(skip_type_key, str) for skip_type_key in skip_type_keys
-        ])
-        self._skip_type_keys = skip_type_keys
diff --git a/mmsegmentation/mmseg/datasets/decathlon.py b/mmsegmentation/mmseg/datasets/decathlon.py
deleted file mode 100644
index 26aa4ef..0000000
--- a/mmsegmentation/mmseg/datasets/decathlon.py
+++ /dev/null
@@ -1,96 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import copy
-import os.path as osp
-from typing import List
-
-from mmengine.fileio import load
-
-from mmseg.registry import DATASETS
-from .basesegdataset import BaseSegDataset
-
-
-@DATASETS.register_module()
-class DecathlonDataset(BaseSegDataset):
-    """Dataset for Dacathlon dataset.
-
-    The dataset.json format is shown as follows
-
-    .. code-block:: none
-
-        {
-            "name": "BRATS",
-            "tensorImageSize": "4D",
-            "modality":
-            {
-                "0": "FLAIR",
-                "1": "T1w",
-                "2": "t1gd",
-                "3": "T2w"
-            },
-            "labels": {
-                "0": "background",
-                "1": "edema",
-                "2": "non-enhancing tumor",
-                "3": "enhancing tumour"
-            },
-            "numTraining": 484,
-            "numTest": 266,
-            "training":
-            [
-                {
-                    "image": "./imagesTr/BRATS_306.nii.gz"
-                    "label": "./labelsTr/BRATS_306.nii.gz"
-                    ...
-                }
-            ]
-            "test":
-            [
-                "./imagesTs/BRATS_557.nii.gz"
-                ...
-            ]
-        }
-    """
-
-    def load_data_list(self) -> List[dict]:
-        """Load annotation from directory or annotation file.
-
-        Returns:
-            list[dict]: All data info of dataset.
-        """
-        # `self.ann_file` denotes the absolute annotation file path if
-        # `self.root=None` or relative path if `self.root=/path/to/data/`.
-        annotations = load(self.ann_file)
-        if not isinstance(annotations, dict):
-            raise TypeError(f'The annotations loaded from annotation file '
-                            f'should be a dict, but got {type(annotations)}!')
-        raw_data_list = annotations[
-            'training'] if not self.test_mode else annotations['test']
-        data_list = []
-        for raw_data_info in raw_data_list:
-            # `2:` works for removing './' in file path, which will break
-            # loading from cloud storage.
-            if isinstance(raw_data_info, dict):
-                data_info = dict(
-                    img_path=osp.join(self.data_root, raw_data_info['image']
-                                      [2:]))
-                data_info['seg_map_path'] = osp.join(
-                    self.data_root, raw_data_info['label'][2:])
-            else:
-                data_info = dict(
-                    img_path=osp.join(self.data_root, raw_data_info)[2:])
-            data_info['label_map'] = self.label_map
-            data_info['reduce_zero_label'] = self.reduce_zero_label
-            data_info['seg_fields'] = []
-            data_list.append(data_info)
-        annotations.pop('training')
-        annotations.pop('test')
-
-        metainfo = copy.deepcopy(annotations)
-        metainfo['classes'] = [*metainfo['labels'].values()]
-        # Meta information load from annotation file will not influence the
-        # existed meta information load from `BaseDataset.METAINFO` and
-        # `metainfo` arguments defined in constructor.
-        for k, v in metainfo.items():
-            self._metainfo.setdefault(k, v)
-
-        return data_list
diff --git a/mmsegmentation/mmseg/datasets/drive.py b/mmsegmentation/mmseg/datasets/drive.py
deleted file mode 100644
index 76c0160..0000000
--- a/mmsegmentation/mmseg/datasets/drive.py
+++ /dev/null
@@ -1,32 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import mmengine.fileio as fileio
-
-from mmseg.registry import DATASETS
-from .basesegdataset import BaseSegDataset
-
-
-@DATASETS.register_module()
-class DRIVEDataset(BaseSegDataset):
-    """DRIVE dataset.
-
-    In segmentation map annotation for DRIVE, 0 stands for background, which is
-    included in 2 categories. ``reduce_zero_label`` is fixed to False. The
-    ``img_suffix`` is fixed to '.png' and ``seg_map_suffix`` is fixed to
-    '_manual1.png'.
-    """
-    METAINFO = dict(
-        classes=('background', 'vessel'),
-        palette=[[120, 120, 120], [6, 230, 230]])
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='_manual1.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
-        assert fileio.exists(
-            self.data_prefix['img_path'], backend_args=self.backend_args)
diff --git a/mmsegmentation/mmseg/datasets/dsdl.py b/mmsegmentation/mmseg/datasets/dsdl.py
deleted file mode 100644
index bf7e4e6..0000000
--- a/mmsegmentation/mmseg/datasets/dsdl.py
+++ /dev/null
@@ -1,116 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import os
-from typing import Dict, List, Optional, Sequence, Union
-
-from mmseg.registry import DATASETS
-from .basesegdataset import BaseSegDataset
-
-try:
-    from dsdl.dataset import DSDLDataset
-except ImportError:
-    DSDLDataset = None
-
-
-@DATASETS.register_module()
-class DSDLSegDataset(BaseSegDataset):
-    """Dataset for dsdl segmentation.
-
-    Args:
-        specific_key_path(dict): Path of specific key which can not
-            be loaded by it's field name.
-        pre_transform(dict): pre-transform functions before loading.
-        used_labels(sequence): list of actual used classes in train steps,
-            this must be subset of class domain.
-    """
-
-    METAINFO = {}
-
-    def __init__(self,
-                 specific_key_path: Dict = {},
-                 pre_transform: Dict = {},
-                 used_labels: Optional[Sequence] = None,
-                 **kwargs) -> None:
-
-        if DSDLDataset is None:
-            raise RuntimeError(
-                'Package dsdl is not installed. Please run "pip install dsdl".'
-            )
-        self.used_labels = used_labels
-
-        loc_config = dict(type='LocalFileReader', working_dir='')
-        if kwargs.get('data_root'):
-            kwargs['ann_file'] = os.path.join(kwargs['data_root'],
-                                              kwargs['ann_file'])
-        required_fields = ['Image', 'LabelMap']
-
-        self.dsdldataset = DSDLDataset(
-            dsdl_yaml=kwargs['ann_file'],
-            location_config=loc_config,
-            required_fields=required_fields,
-            specific_key_path=specific_key_path,
-            transform=pre_transform,
-        )
-        BaseSegDataset.__init__(self, **kwargs)
-
-    def load_data_list(self) -> List[Dict]:
-        """Load data info from a dsdl yaml file named as ``self.ann_file``
-
-        Returns:
-            List[dict]: A list of data list.
-        """
-
-        if self.used_labels:
-            self._metainfo['classes'] = tuple(self.used_labels)
-            self.label_map = self.get_label_map(self.used_labels)
-        else:
-            self._metainfo['classes'] = tuple(['background'] +
-                                              self.dsdldataset.class_names)
-        data_list = []
-
-        for i, data in enumerate(self.dsdldataset):
-            datainfo = dict(
-                img_path=os.path.join(self.data_prefix['img_path'],
-                                      data['Image'][0].location),
-                seg_map_path=os.path.join(self.data_prefix['seg_map_path'],
-                                          data['LabelMap'][0].location),
-                label_map=self.label_map,
-                reduce_zero_label=self.reduce_zero_label,
-                seg_fields=[],
-            )
-            data_list.append(datainfo)
-
-        return data_list
-
-    def get_label_map(self,
-                      new_classes: Optional[Sequence] = None
-                      ) -> Union[Dict, None]:
-        """Require label mapping.
-
-        The ``label_map`` is a dictionary, its keys are the old label ids and
-        its values are the new label ids, and is used for changing pixel
-        labels in load_annotations. If and only if old classes in class_dom
-        is not equal to new classes in args and nether of them is not
-        None, `label_map` is not None.
-        Args:
-            new_classes (list, tuple, optional): The new classes name from
-                metainfo. Default to None.
-        Returns:
-            dict, optional: The mapping from old classes to new classes.
-        """
-        old_classes = ['background'] + self.dsdldataset.class_names
-        if (new_classes is not None and old_classes is not None
-                and list(new_classes) != list(old_classes)):
-
-            label_map = {}
-            if not set(new_classes).issubset(old_classes):
-                raise ValueError(
-                    f'new classes {new_classes} is not a '
-                    f'subset of classes {old_classes} in class_dom.')
-            for i, c in enumerate(old_classes):
-                if c not in new_classes:
-                    label_map[i] = 255
-                else:
-                    label_map[i] = new_classes.index(c)
-            return label_map
-        else:
-            return None
diff --git a/mmsegmentation/mmseg/datasets/hrf.py b/mmsegmentation/mmseg/datasets/hrf.py
deleted file mode 100644
index fd669cc..0000000
--- a/mmsegmentation/mmseg/datasets/hrf.py
+++ /dev/null
@@ -1,32 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import mmengine.fileio as fileio
-
-from mmseg.registry import DATASETS
-from .basesegdataset import BaseSegDataset
-
-
-@DATASETS.register_module()
-class HRFDataset(BaseSegDataset):
-    """HRF dataset.
-
-    In segmentation map annotation for HRF, 0 stands for background, which is
-    included in 2 categories. ``reduce_zero_label`` is fixed to False. The
-    ``img_suffix`` is fixed to '.png' and ``seg_map_suffix`` is fixed to
-    '.png'.
-    """
-    METAINFO = dict(
-        classes=('background', 'vessel'),
-        palette=[[120, 120, 120], [6, 230, 230]])
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
-        assert fileio.exists(
-            self.data_prefix['img_path'], backend_args=self.backend_args)
diff --git a/mmsegmentation/mmseg/datasets/hsi_drive.py b/mmsegmentation/mmseg/datasets/hsi_drive.py
deleted file mode 100644
index 3d46a86..0000000
--- a/mmsegmentation/mmseg/datasets/hsi_drive.py
+++ /dev/null
@@ -1,42 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-classes_exp = ('unlabelled', 'road', 'road marks', 'vegetation',
-               'painted metal', 'sky', 'concrete', 'pedestrian', 'water',
-               'unpainted metal', 'glass')
-palette_exp = [[0, 0, 0], [77, 77, 77], [255, 255, 255], [0, 255, 0],
-               [255, 0, 0], [0, 0, 255], [102, 51, 0], [255, 255, 0],
-               [0, 207, 250], [255, 166, 0], [0, 204, 204]]
-
-
-@DATASETS.register_module()
-class HSIDrive20Dataset(BaseSegDataset):
-    """HSI-Drive v2.0 (https://ieeexplore.ieee.org/document/10371793), the
-    updated version of HSI-Drive
-    (https://ieeexplore.ieee.org/document/9575298), is a structured dataset for
-    the research and development of automated driving systems (ADS) supported
-    by hyperspectral imaging (HSI). It contains per-pixel manually annotated
-    images selected from videos recorded in real driving conditions and has
-    been organized according to four parameters: season, daytime, road type,
-    and weather conditions.
-
-    The video sequences have been captured with a small-size 25-band VNIR
-    (Visible-NearlnfraRed) snapshot hyperspectral camera mounted on a driving
-    automobile. As a consequence, you need to modify the in_channels parameter
-    of your model from 3 (RGB images) to 25 (HSI images) as it is done in
-    configs/unet/unet-s5-d16_fcn_4xb4-160k_hsidrive-192x384.py
-
-    Apart from the abovementioned articles, additional information is provided
-    in the website (https://ipaccess.ehu.eus/HSI-Drive/) from where you can
-    download the dataset and also visualize some examples of segmented videos.
-    """
-
-    METAINFO = dict(classes=classes_exp, palette=palette_exp)
-
-    def __init__(self,
-                 img_suffix='.npy',
-                 seg_map_suffix='.png',
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/isaid.py b/mmsegmentation/mmseg/datasets/isaid.py
deleted file mode 100644
index 61942ec..0000000
--- a/mmsegmentation/mmseg/datasets/isaid.py
+++ /dev/null
@@ -1,39 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import mmengine.fileio as fileio
-
-from mmseg.registry import DATASETS
-from .basesegdataset import BaseSegDataset
-
-
-@DATASETS.register_module()
-class iSAIDDataset(BaseSegDataset):
-    """ iSAID: A Large-scale Dataset for Instance Segmentation in Aerial Images
-    In segmentation map annotation for iSAID dataset, which is included
-    in 16 categories. ``reduce_zero_label`` is fixed to False. The
-    ``img_suffix`` is fixed to '.png' and ``seg_map_suffix`` is fixed to
-    '_manual1.png'.
-    """
-
-    METAINFO = dict(
-        classes=('background', 'ship', 'store_tank', 'baseball_diamond',
-                 'tennis_court', 'basketball_court', 'Ground_Track_Field',
-                 'Bridge', 'Large_Vehicle', 'Small_Vehicle', 'Helicopter',
-                 'Swimming_pool', 'Roundabout', 'Soccer_ball_field', 'plane',
-                 'Harbor'),
-        palette=[[0, 0, 0], [0, 0, 63], [0, 63, 63], [0, 63, 0], [0, 63, 127],
-                 [0, 63, 191], [0, 63, 255], [0, 127, 63], [0, 127, 127],
-                 [0, 0, 127], [0, 0, 191], [0, 0, 255], [0, 191, 127],
-                 [0, 127, 191], [0, 127, 255], [0, 100, 155]])
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='_instance_color_RGB.png',
-                 ignore_index=255,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            ignore_index=ignore_index,
-            **kwargs)
-        assert fileio.exists(
-            self.data_prefix['img_path'], backend_args=self.backend_args)
diff --git a/mmsegmentation/mmseg/datasets/isprs.py b/mmsegmentation/mmseg/datasets/isprs.py
deleted file mode 100644
index 30af53c..0000000
--- a/mmsegmentation/mmseg/datasets/isprs.py
+++ /dev/null
@@ -1,29 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmseg.registry import DATASETS
-from .basesegdataset import BaseSegDataset
-
-
-@DATASETS.register_module()
-class ISPRSDataset(BaseSegDataset):
-    """ISPRS dataset.
-
-    In segmentation map annotation for ISPRS, 0 is the ignore index.
-    ``reduce_zero_label`` should be set to True. The ``img_suffix`` and
-    ``seg_map_suffix`` are both fixed to '.png'.
-    """
-    METAINFO = dict(
-        classes=('impervious_surface', 'building', 'low_vegetation', 'tree',
-                 'car', 'clutter'),
-        palette=[[255, 255, 255], [0, 0, 255], [0, 255, 255], [0, 255, 0],
-                 [255, 255, 0], [255, 0, 0]])
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=True,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/levir.py b/mmsegmentation/mmseg/datasets/levir.py
deleted file mode 100644
index f467481..0000000
--- a/mmsegmentation/mmseg/datasets/levir.py
+++ /dev/null
@@ -1,31 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-
-from mmseg.registry import DATASETS
-from .basesegdataset import BaseCDDataset
-
-
-@DATASETS.register_module()
-class LEVIRCDDataset(BaseCDDataset):
-    """ISPRS dataset.
-
-    In segmentation map annotation for ISPRS, 0 is to ignore index.
-    ``reduce_zero_label`` should be set to True. The ``img_suffix`` and
-    ``seg_map_suffix`` are both fixed to '.png'.
-    """
-
-    METAINFO = dict(
-        classes=('background', 'changed'),
-        palette=[[0, 0, 0], [255, 255, 255]])
-
-    def __init__(self,
-                 img_suffix='.png',
-                 img_suffix2='.png',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            img_suffix2=img_suffix2,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/lip.py b/mmsegmentation/mmseg/datasets/lip.py
deleted file mode 100644
index 3a32a19..0000000
--- a/mmsegmentation/mmseg/datasets/lip.py
+++ /dev/null
@@ -1,47 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmseg.registry import DATASETS
-from .basesegdataset import BaseSegDataset
-
-
-@DATASETS.register_module()
-class LIPDataset(BaseSegDataset):
-    """LIP dataset.
-
-    The ``img_suffix`` is fixed to '.jpg' and ``seg_map_suffix`` is fixed to
-    '.png'.
-    """
-    METAINFO = dict(
-        classes=('Background', 'Hat', 'Hair', 'Glove', 'Sunglasses',
-                 'UpperClothes', 'Dress', 'Coat', 'Socks', 'Pants',
-                 'Jumpsuits', 'Scarf', 'Skirt', 'Face', 'Left-arm',
-                 'Right-arm', 'Left-leg', 'Right-leg', 'Left-shoe',
-                 'Right-shoe'),
-        palette=(
-            [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 __init__(self,
-                 img_suffix='.jpg',
-                 seg_map_suffix='.png',
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/loveda.py b/mmsegmentation/mmseg/datasets/loveda.py
deleted file mode 100644
index 5c16db5..0000000
--- a/mmsegmentation/mmseg/datasets/loveda.py
+++ /dev/null
@@ -1,29 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmseg.registry import DATASETS
-from .basesegdataset import BaseSegDataset
-
-
-@DATASETS.register_module()
-class LoveDADataset(BaseSegDataset):
-    """LoveDA dataset.
-
-    In segmentation map annotation for LoveDA, 0 is the ignore index.
-    ``reduce_zero_label`` should be set to True. The ``img_suffix`` and
-    ``seg_map_suffix`` are both fixed to '.png'.
-    """
-    METAINFO = dict(
-        classes=('background', 'building', 'road', 'water', 'barren', 'forest',
-                 'agricultural'),
-        palette=[[255, 255, 255], [255, 0, 0], [255, 255, 0], [0, 0, 255],
-                 [159, 129, 183], [0, 255, 0], [255, 195, 128]])
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=True,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/mapillary.py b/mmsegmentation/mmseg/datasets/mapillary.py
deleted file mode 100644
index 6c29473..0000000
--- a/mmsegmentation/mmseg/datasets/mapillary.py
+++ /dev/null
@@ -1,176 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmseg.registry import DATASETS
-from .basesegdataset import BaseSegDataset
-
-
-@DATASETS.register_module()
-class MapillaryDataset_v1(BaseSegDataset):
-    """Mapillary Vistas Dataset.
-
-    Dataset paper link:
-    http://ieeexplore.ieee.org/document/8237796/
-
-    v1.2 contain 66 object classes.
-    (37 instance-specific)
-
-    v2.0 contain 124 object classes.
-    (70 instance-specific, 46 stuff, 8 void or crowd).
-
-    The ``img_suffix`` is fixed to '.jpg' and ``seg_map_suffix`` is
-    fixed to '.png' for Mapillary Vistas Dataset.
-    """
-    METAINFO = dict(
-        classes=('Bird', 'Ground Animal', 'Curb', 'Fence', 'Guard Rail',
-                 'Barrier', 'Wall', 'Bike Lane', 'Crosswalk - Plain',
-                 'Curb Cut', 'Parking', 'Pedestrian Area', 'Rail Track',
-                 'Road', 'Service Lane', 'Sidewalk', 'Bridge', 'Building',
-                 'Tunnel', 'Person', 'Bicyclist', 'Motorcyclist',
-                 'Other Rider', 'Lane Marking - Crosswalk',
-                 'Lane Marking - General', 'Mountain', 'Sand', 'Sky', 'Snow',
-                 'Terrain', 'Vegetation', 'Water', 'Banner', 'Bench',
-                 'Bike Rack', 'Billboard', 'Catch Basin', 'CCTV Camera',
-                 'Fire Hydrant', 'Junction Box', 'Mailbox', 'Manhole',
-                 'Phone Booth', 'Pothole', 'Street Light', 'Pole',
-                 'Traffic Sign Frame', 'Utility Pole', 'Traffic Light',
-                 'Traffic Sign (Back)', 'Traffic Sign (Front)', 'Trash Can',
-                 'Bicycle', 'Boat', 'Bus', 'Car', 'Caravan', 'Motorcycle',
-                 'On Rails', 'Other Vehicle', 'Trailer', 'Truck',
-                 'Wheeled Slow', 'Car Mount', 'Ego Vehicle', 'Unlabeled'),
-        palette=[[165, 42, 42], [0, 192, 0], [196, 196, 196], [190, 153, 153],
-                 [180, 165, 180], [90, 120, 150], [102, 102, 156],
-                 [128, 64, 255], [140, 140, 200], [170, 170, 170],
-                 [250, 170, 160], [96, 96, 96],
-                 [230, 150, 140], [128, 64, 128], [110, 110, 110],
-                 [244, 35, 232], [150, 100, 100], [70, 70, 70], [150, 120, 90],
-                 [220, 20, 60], [255, 0, 0], [255, 0, 100], [255, 0, 200],
-                 [200, 128, 128], [255, 255, 255], [64, 170,
-                                                    64], [230, 160, 50],
-                 [70, 130, 180], [190, 255, 255], [152, 251, 152],
-                 [107, 142, 35], [0, 170, 30], [255, 255, 128], [250, 0, 30],
-                 [100, 140, 180], [220, 220, 220], [220, 128, 128],
-                 [222, 40, 40], [100, 170, 30], [40, 40, 40], [33, 33, 33],
-                 [100, 128, 160], [142, 0, 0], [70, 100, 150], [210, 170, 100],
-                 [153, 153, 153], [128, 128, 128], [0, 0, 80], [250, 170, 30],
-                 [192, 192, 192], [220, 220, 0], [140, 140, 20], [119, 11, 32],
-                 [150, 0, 255], [0, 60, 100], [0, 0, 142], [0, 0, 90],
-                 [0, 0, 230], [0, 80, 100], [128, 64, 64], [0, 0, 110],
-                 [0, 0, 70], [0, 0, 192], [32, 32, 32], [120, 10,
-                                                         10], [0, 0, 0]])
-
-    def __init__(self,
-                 img_suffix='.jpg',
-                 seg_map_suffix='.png',
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
-
-
-@DATASETS.register_module()
-class MapillaryDataset_v2(BaseSegDataset):
-    """Mapillary Vistas Dataset.
-
-    Dataset paper link:
-    http://ieeexplore.ieee.org/document/8237796/
-
-    v1.2 contain 66 object classes.
-    (37 instance-specific)
-
-    v2.0 contain 124 object classes.
-    (70 instance-specific, 46 stuff, 8 void or crowd).
-
-    The ``img_suffix`` is fixed to '.jpg' and ``seg_map_suffix`` is
-    fixed to '.png' for Mapillary Vistas Dataset.
-    """
-    METAINFO = dict(
-        classes=(
-            'Bird', 'Ground Animal', 'Ambiguous Barrier', 'Concrete Block',
-            'Curb', 'Fence', 'Guard Rail', 'Barrier', 'Road Median',
-            'Road Side', 'Lane Separator', 'Temporary Barrier', 'Wall',
-            'Bike Lane', 'Crosswalk - Plain', 'Curb Cut', 'Driveway',
-            'Parking', 'Parking Aisle', 'Pedestrian Area', 'Rail Track',
-            'Road', 'Road Shoulder', 'Service Lane', 'Sidewalk',
-            'Traffic Island', 'Bridge', 'Building', 'Garage', 'Tunnel',
-            'Person', 'Person Group', 'Bicyclist', 'Motorcyclist',
-            'Other Rider', 'Lane Marking - Dashed Line',
-            'Lane Marking - Straight Line', 'Lane Marking - Zigzag Line',
-            'Lane Marking - Ambiguous', 'Lane Marking - Arrow (Left)',
-            'Lane Marking - Arrow (Other)', 'Lane Marking - Arrow (Right)',
-            'Lane Marking - Arrow (Split Left or Straight)',
-            'Lane Marking - Arrow (Split Right or Straight)',
-            'Lane Marking - Arrow (Straight)', 'Lane Marking - Crosswalk',
-            'Lane Marking - Give Way (Row)',
-            'Lane Marking - Give Way (Single)',
-            'Lane Marking - Hatched (Chevron)',
-            'Lane Marking - Hatched (Diagonal)', 'Lane Marking - Other',
-            'Lane Marking - Stop Line', 'Lane Marking - Symbol (Bicycle)',
-            'Lane Marking - Symbol (Other)', 'Lane Marking - Text',
-            'Lane Marking (only) - Dashed Line',
-            'Lane Marking (only) - Crosswalk', 'Lane Marking (only) - Other',
-            'Lane Marking (only) - Test', 'Mountain', 'Sand', 'Sky', 'Snow',
-            'Terrain', 'Vegetation', 'Water', 'Banner', 'Bench', 'Bike Rack',
-            'Catch Basin', 'CCTV Camera', 'Fire Hydrant', 'Junction Box',
-            'Mailbox', 'Manhole', 'Parking Meter', 'Phone Booth', 'Pothole',
-            'Signage - Advertisement', 'Signage - Ambiguous', 'Signage - Back',
-            'Signage - Information', 'Signage - Other', 'Signage - Store',
-            'Street Light', 'Pole', 'Pole Group', 'Traffic Sign Frame',
-            'Utility Pole', 'Traffic Cone', 'Traffic Light - General (Single)',
-            'Traffic Light - Pedestrians', 'Traffic Light - General (Upright)',
-            'Traffic Light - General (Horizontal)', 'Traffic Light - Cyclists',
-            'Traffic Light - Other', 'Traffic Sign - Ambiguous',
-            'Traffic Sign (Back)', 'Traffic Sign - Direction (Back)',
-            'Traffic Sign - Direction (Front)', 'Traffic Sign (Front)',
-            'Traffic Sign - Parking', 'Traffic Sign - Temporary (Back)',
-            'Traffic Sign - Temporary (Front)', 'Trash Can', 'Bicycle', 'Boat',
-            'Bus', 'Car', 'Caravan', 'Motorcycle', 'On Rails', 'Other Vehicle',
-            'Trailer', 'Truck', 'Vehicle Group', 'Wheeled Slow', 'Water Valve',
-            'Car Mount', 'Dynamic', 'Ego Vehicle', 'Ground', 'Static',
-            'Unlabeled'),
-        palette=[[165, 42, 42], [0, 192, 0], [250, 170, 31], [250, 170, 32],
-                 [196, 196, 196], [190, 153, 153], [180, 165, 180],
-                 [90, 120, 150], [250, 170, 33], [250, 170, 34],
-                 [128, 128, 128], [250, 170, 35], [102, 102, 156],
-                 [128, 64, 255], [140, 140, 200], [170, 170, 170],
-                 [250, 170, 36], [250, 170, 160], [250, 170, 37], [96, 96, 96],
-                 [230, 150, 140], [128, 64, 128], [110, 110, 110],
-                 [110, 110, 110], [244, 35, 232], [128, 196,
-                                                   128], [150, 100, 100],
-                 [70, 70, 70], [150, 150, 150], [150, 120, 90], [220, 20, 60],
-                 [220, 20, 60], [255, 0, 0], [255, 0, 100], [255, 0, 200],
-                 [255, 255, 255], [255, 255, 255], [250, 170, 29],
-                 [250, 170, 28], [250, 170, 26], [250, 170,
-                                                  25], [250, 170, 24],
-                 [250, 170, 22], [250, 170, 21], [250, 170,
-                                                  20], [255, 255, 255],
-                 [250, 170, 19], [250, 170, 18], [250, 170,
-                                                  12], [250, 170, 11],
-                 [255, 255, 255], [255, 255, 255], [250, 170, 16],
-                 [250, 170, 15], [250, 170, 15], [255, 255, 255],
-                 [255, 255, 255], [255, 255, 255], [255, 255, 255],
-                 [64, 170, 64], [230, 160, 50],
-                 [70, 130, 180], [190, 255, 255], [152, 251, 152],
-                 [107, 142, 35], [0, 170, 30], [255, 255, 128], [250, 0, 30],
-                 [100, 140, 180], [220, 128, 128], [222, 40,
-                                                    40], [100, 170, 30],
-                 [40, 40, 40], [33, 33, 33], [100, 128, 160], [20, 20, 255],
-                 [142, 0, 0], [70, 100, 150], [250, 171, 30], [250, 172, 30],
-                 [250, 173, 30], [250, 174, 30], [250, 175,
-                                                  30], [250, 176, 30],
-                 [210, 170, 100], [153, 153, 153], [153, 153, 153],
-                 [128, 128, 128], [0, 0, 80], [210, 60, 60], [250, 170, 30],
-                 [250, 170, 30], [250, 170, 30], [250, 170,
-                                                  30], [250, 170, 30],
-                 [250, 170, 30], [192, 192, 192], [192, 192, 192],
-                 [192, 192, 192], [220, 220, 0], [220, 220, 0], [0, 0, 196],
-                 [192, 192, 192], [220, 220, 0], [140, 140, 20], [119, 11, 32],
-                 [150, 0, 255], [0, 60, 100], [0, 0, 142], [0, 0, 90],
-                 [0, 0, 230], [0, 80, 100], [128, 64, 64], [0, 0, 110],
-                 [0, 0, 70], [0, 0, 142], [0, 0, 192], [170, 170, 170],
-                 [32, 32, 32], [111, 74, 0], [120, 10, 10], [81, 0, 81],
-                 [111, 111, 0], [0, 0, 0]])
-
-    def __init__(self,
-                 img_suffix='.jpg',
-                 seg_map_suffix='.png',
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/night_driving.py b/mmsegmentation/mmseg/datasets/night_driving.py
deleted file mode 100644
index 3ead91e..0000000
--- a/mmsegmentation/mmseg/datasets/night_driving.py
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmseg.registry import DATASETS
-from .cityscapes import CityscapesDataset
-
-
-@DATASETS.register_module()
-class NightDrivingDataset(CityscapesDataset):
-    """NightDrivingDataset dataset."""
-
-    def __init__(self,
-                 img_suffix='_leftImg8bit.png',
-                 seg_map_suffix='_gtCoarse_labelTrainIds.png',
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/nyu.py b/mmsegmentation/mmseg/datasets/nyu.py
deleted file mode 100644
index fcfda46..0000000
--- a/mmsegmentation/mmseg/datasets/nyu.py
+++ /dev/null
@@ -1,123 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import os.path as osp
-from typing import List
-
-import mmengine.fileio as fileio
-
-from mmseg.registry import DATASETS
-from .basesegdataset import BaseSegDataset
-
-
-@DATASETS.register_module()
-class NYUDataset(BaseSegDataset):
-    """NYU depth estimation dataset. The file structure should be.
-
-    .. code-block:: none
-
-        ├── data
-        │   ├── nyu
-        │   │   ├── images
-        │   │   │   ├── train
-        │   │   │   │   ├── scene_xxx.jpg
-        │   │   │   │   ├── ...
-        │   │   │   ├── test
-        │   │   ├── annotations
-        │   │   │   ├── train
-        │   │   │   │   ├── scene_xxx.png
-        │   │   │   │   ├── ...
-        │   │   │   ├── test
-
-    Args:
-        ann_file (str): Annotation file path. Defaults to ''.
-        metainfo (dict, optional): Meta information for dataset, such as
-            specify classes to load. Defaults to None.
-        data_root (str, optional): The root directory for ``data_prefix`` and
-            ``ann_file``. Defaults to None.
-        data_prefix (dict, optional): Prefix for training data. Defaults to
-            dict(img_path='images', depth_map_path='annotations').
-        img_suffix (str): Suffix of images. Default: '.jpg'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-        filter_cfg (dict, optional): Config for filter data. Defaults to None.
-        indices (int or Sequence[int], optional): Support using first few
-            data in annotation file to facilitate training/testing on a smaller
-            dataset. Defaults to None which means using all ``data_infos``.
-        serialize_data (bool, optional): Whether to hold memory using
-            serialized objects, when enabled, data loader workers can use
-            shared RAM from master process instead of making a copy. Defaults
-            to True.
-        pipeline (list, optional): Processing pipeline. Defaults to [].
-        test_mode (bool, optional): ``test_mode=True`` means in test phase.
-            Defaults to False.
-        lazy_init (bool, optional): Whether to load annotation during
-            instantiation. In some cases, such as visualization, only the meta
-            information of the dataset is needed, which is not necessary to
-            load annotation file. ``Basedataset`` can skip load annotations to
-            save time by set ``lazy_init=True``. Defaults to False.
-        max_refetch (int, optional): If ``Basedataset.prepare_data`` get a
-            None img. The maximum extra number of cycles to get a valid
-            image. Defaults to 1000.
-        ignore_index (int): The label index to be ignored. Default: 255
-        reduce_zero_label (bool): Whether to mark label zero as ignored.
-            Default to False.
-        backend_args (dict, Optional): Arguments to instantiate a file backend.
-            See https://mmengine.readthedocs.io/en/latest/api/fileio.htm
-            for details. Defaults to None.
-            Notes: mmcv>=2.0.0rc4, mmengine>=0.2.0 required.
-    """
-    METAINFO = dict(
-        classes=('printer_room', 'bathroom', 'living_room', 'study',
-                 'conference_room', 'study_room', 'kitchen', 'home_office',
-                 'bedroom', 'dinette', 'playroom', 'indoor_balcony',
-                 'laundry_room', 'basement', 'excercise_room', 'foyer',
-                 'home_storage', 'cafe', 'furniture_store', 'office_kitchen',
-                 'student_lounge', 'dining_room', 'reception_room',
-                 'computer_lab', 'classroom', 'office', 'bookstore'))
-
-    def __init__(self,
-                 data_prefix=dict(
-                     img_path='images', depth_map_path='annotations'),
-                 img_suffix='.jpg',
-                 depth_map_suffix='.png',
-                 **kwargs) -> None:
-        super().__init__(
-            data_prefix=data_prefix,
-            img_suffix=img_suffix,
-            seg_map_suffix=depth_map_suffix,
-            **kwargs)
-
-    def _get_category_id_from_filename(self, image_fname: str) -> int:
-        """Retrieve the category ID from the given image filename."""
-        image_fname = osp.basename(image_fname)
-        position = image_fname.find(next(filter(str.isdigit, image_fname)), 0)
-        categoty_name = image_fname[:position - 1]
-        if categoty_name not in self._metainfo['classes']:
-            return -1
-        else:
-            return self._metainfo['classes'].index(categoty_name)
-
-    def load_data_list(self) -> List[dict]:
-        """Load annotation from directory or annotation file.
-
-        Returns:
-            list[dict]: All data info of dataset.
-        """
-        data_list = []
-        img_dir = self.data_prefix.get('img_path', None)
-        ann_dir = self.data_prefix.get('depth_map_path', None)
-
-        _suffix_len = len(self.img_suffix)
-        for img in fileio.list_dir_or_file(
-                dir_path=img_dir,
-                list_dir=False,
-                suffix=self.img_suffix,
-                recursive=True,
-                backend_args=self.backend_args):
-            data_info = dict(img_path=osp.join(img_dir, img))
-            if ann_dir is not None:
-                depth_map = img[:-_suffix_len] + self.seg_map_suffix
-                data_info['depth_map_path'] = osp.join(ann_dir, depth_map)
-            data_info['seg_fields'] = []
-            data_info['category_id'] = self._get_category_id_from_filename(img)
-            data_list.append(data_info)
-        data_list = sorted(data_list, key=lambda x: x['img_path'])
-        return data_list
diff --git a/mmsegmentation/mmseg/datasets/pascal_context.py b/mmsegmentation/mmseg/datasets/pascal_context.py
deleted file mode 100644
index 82d00a9..0000000
--- a/mmsegmentation/mmseg/datasets/pascal_context.py
+++ /dev/null
@@ -1,116 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import mmengine.fileio as fileio
-
-from mmseg.registry import DATASETS
-from .basesegdataset import BaseSegDataset
-
-
-@DATASETS.register_module()
-class PascalContextDataset(BaseSegDataset):
-    """PascalContext dataset.
-
-    In segmentation map annotation for PascalContext, 0 stands for background,
-    which is included in 60 categories. ``reduce_zero_label`` is fixed to
-    False. The ``img_suffix`` is fixed to '.jpg' and ``seg_map_suffix`` is
-    fixed to '.png'.
-
-    Args:
-        ann_file (str): Annotation file path.
-    """
-
-    METAINFO = dict(
-        classes=('background', 'aeroplane', 'bag', 'bed', 'bedclothes',
-                 'bench', 'bicycle', 'bird', 'boat', 'book', 'bottle',
-                 'building', 'bus', 'cabinet', 'car', 'cat', 'ceiling',
-                 'chair', 'cloth', 'computer', 'cow', 'cup', 'curtain', 'dog',
-                 'door', 'fence', 'floor', 'flower', 'food', 'grass', 'ground',
-                 'horse', 'keyboard', 'light', 'motorbike', 'mountain',
-                 'mouse', 'person', 'plate', 'platform', 'pottedplant', 'road',
-                 'rock', 'sheep', 'shelves', 'sidewalk', 'sign', 'sky', 'snow',
-                 'sofa', 'table', 'track', 'train', 'tree', 'truck',
-                 'tvmonitor', 'wall', 'water', 'window', 'wood'),
-        palette=[[120, 120, 120], [180, 120, 120], [6, 230, 230], [80, 50, 50],
-                 [4, 200, 3], [120, 120, 80], [140, 140, 140], [204, 5, 255],
-                 [230, 230, 230], [4, 250, 7], [224, 5, 255], [235, 255, 7],
-                 [150, 5, 61], [120, 120, 70], [8, 255, 51], [255, 6, 82],
-                 [143, 255, 140], [204, 255, 4], [255, 51, 7], [204, 70, 3],
-                 [0, 102, 200], [61, 230, 250], [255, 6, 51], [11, 102, 255],
-                 [255, 7, 71], [255, 9, 224], [9, 7, 230], [220, 220, 220],
-                 [255, 9, 92], [112, 9, 255], [8, 255, 214], [7, 255, 224],
-                 [255, 184, 6], [10, 255, 71], [255, 41, 10], [7, 255, 255],
-                 [224, 255, 8], [102, 8, 255], [255, 61, 6], [255, 194, 7],
-                 [255, 122, 8], [0, 255, 20], [255, 8, 41], [255, 5, 153],
-                 [6, 51, 255], [235, 12, 255], [160, 150, 20], [0, 163, 255],
-                 [140, 140, 140], [250, 10, 15], [20, 255, 0], [31, 255, 0],
-                 [255, 31, 0], [255, 224, 0], [153, 255, 0], [0, 0, 255],
-                 [255, 71, 0], [0, 235, 255], [0, 173, 255], [31, 0, 255]])
-
-    def __init__(self,
-                 ann_file='',
-                 img_suffix='.jpg',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            ann_file=ann_file,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
-        assert fileio.exists(self.data_prefix['img_path'], self.backend_args)
-
-
-@DATASETS.register_module()
-class PascalContextDataset59(BaseSegDataset):
-    """PascalContext dataset.
-
-    In segmentation map annotation for PascalContext, 0 stands for background,
-    which is included in 60 categories. ``reduce_zero_label`` is fixed to
-    True. The ``img_suffix`` is fixed to '.jpg' and ``seg_map_suffix`` is
-    fixed to '.png'.
-    Noted: If the background is 255 and the ids of categories are from 0 to 58,
-    ``reduce_zero_label`` needs to be set to False.
-
-    Args:
-        ann_file (str): Annotation file path.
-    """
-    METAINFO = dict(
-        classes=('aeroplane', 'bag', 'bed', 'bedclothes', 'bench', 'bicycle',
-                 'bird', 'boat', 'book', 'bottle', 'building', 'bus',
-                 'cabinet', 'car', 'cat', 'ceiling', 'chair', 'cloth',
-                 'computer', 'cow', 'cup', 'curtain', 'dog', 'door', 'fence',
-                 'floor', 'flower', 'food', 'grass', 'ground', 'horse',
-                 'keyboard', 'light', 'motorbike', 'mountain', 'mouse',
-                 'person', 'plate', 'platform', 'pottedplant', 'road', 'rock',
-                 'sheep', 'shelves', 'sidewalk', 'sign', 'sky', 'snow', 'sofa',
-                 'table', 'track', 'train', 'tree', 'truck', 'tvmonitor',
-                 'wall', 'water', 'window', 'wood'),
-        palette=[[180, 120, 120], [6, 230, 230], [80, 50, 50], [4, 200, 3],
-                 [120, 120, 80], [140, 140, 140], [204, 5, 255],
-                 [230, 230, 230], [4, 250, 7], [224, 5, 255], [235, 255, 7],
-                 [150, 5, 61], [120, 120, 70], [8, 255, 51], [255, 6, 82],
-                 [143, 255, 140], [204, 255, 4], [255, 51, 7], [204, 70, 3],
-                 [0, 102, 200], [61, 230, 250], [255, 6, 51], [11, 102, 255],
-                 [255, 7, 71], [255, 9, 224], [9, 7, 230], [220, 220, 220],
-                 [255, 9, 92], [112, 9, 255], [8, 255, 214], [7, 255, 224],
-                 [255, 184, 6], [10, 255, 71], [255, 41, 10], [7, 255, 255],
-                 [224, 255, 8], [102, 8, 255], [255, 61, 6], [255, 194, 7],
-                 [255, 122, 8], [0, 255, 20], [255, 8, 41], [255, 5, 153],
-                 [6, 51, 255], [235, 12, 255], [160, 150, 20], [0, 163, 255],
-                 [140, 140, 140], [250, 10, 15], [20, 255, 0], [31, 255, 0],
-                 [255, 31, 0], [255, 224, 0], [153, 255, 0], [0, 0, 255],
-                 [255, 71, 0], [0, 235, 255], [0, 173, 255], [31, 0, 255]])
-
-    def __init__(self,
-                 ann_file='',
-                 img_suffix='.jpg',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=True,
-                 **kwargs):
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            ann_file=ann_file,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
-        assert fileio.exists(self.data_prefix['img_path'], self.backend_args)
diff --git a/mmsegmentation/mmseg/datasets/potsdam.py b/mmsegmentation/mmseg/datasets/potsdam.py
deleted file mode 100644
index 6892de3..0000000
--- a/mmsegmentation/mmseg/datasets/potsdam.py
+++ /dev/null
@@ -1,29 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmseg.registry import DATASETS
-from .basesegdataset import BaseSegDataset
-
-
-@DATASETS.register_module()
-class PotsdamDataset(BaseSegDataset):
-    """ISPRS Potsdam dataset.
-
-    In segmentation map annotation for Potsdam dataset, 0 is the ignore index.
-    ``reduce_zero_label`` should be set to True. The ``img_suffix`` and
-    ``seg_map_suffix`` are both fixed to '.png'.
-    """
-    METAINFO = dict(
-        classes=('impervious_surface', 'building', 'low_vegetation', 'tree',
-                 'car', 'clutter'),
-        palette=[[255, 255, 255], [0, 0, 255], [0, 255, 255], [0, 255, 0],
-                 [255, 255, 0], [255, 0, 0]])
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=True,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/refuge.py b/mmsegmentation/mmseg/datasets/refuge.py
deleted file mode 100644
index 4016a82..0000000
--- a/mmsegmentation/mmseg/datasets/refuge.py
+++ /dev/null
@@ -1,28 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import mmengine.fileio as fileio
-
-from mmseg.registry import DATASETS
-from .basesegdataset import BaseSegDataset
-
-
-@DATASETS.register_module()
-class REFUGEDataset(BaseSegDataset):
-    """REFUGE dataset.
-
-    In segmentation map annotation for REFUGE, 0 stands for background, which
-    is not included in 2 categories. ``reduce_zero_label`` is fixed to True.
-    The ``img_suffix`` is fixed to '.png' and ``seg_map_suffix`` is fixed to
-    '.png'.
-    """
-    METAINFO = dict(
-        classes=('background', ' Optic Cup', 'Optic Disc'),
-        palette=[[120, 120, 120], [6, 230, 230], [56, 59, 120]])
-
-    def __init__(self, **kwargs) -> None:
-        super().__init__(
-            img_suffix='.png',
-            seg_map_suffix='.png',
-            reduce_zero_label=False,
-            **kwargs)
-        assert fileio.exists(
-            self.data_prefix['img_path'], backend_args=self.backend_args)
diff --git a/mmsegmentation/mmseg/datasets/stare.py b/mmsegmentation/mmseg/datasets/stare.py
deleted file mode 100644
index 1b997bb..0000000
--- a/mmsegmentation/mmseg/datasets/stare.py
+++ /dev/null
@@ -1,32 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import mmengine.fileio as fileio
-
-from mmseg.registry import DATASETS
-from .basesegdataset import BaseSegDataset
-
-
-@DATASETS.register_module()
-class STAREDataset(BaseSegDataset):
-    """STARE dataset.
-
-    In segmentation map annotation for STARE, 0 stands for background, which is
-    included in 2 categories. ``reduce_zero_label`` is fixed to False. The
-    ``img_suffix`` is fixed to '.png' and ``seg_map_suffix`` is fixed to
-    '.ah.png'.
-    """
-    METAINFO = dict(
-        classes=('background', 'vessel'),
-        palette=[[120, 120, 120], [6, 230, 230]])
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.ah.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
-        assert fileio.exists(
-            self.data_prefix['img_path'], backend_args=self.backend_args)
diff --git a/mmsegmentation/mmseg/datasets/synapse.py b/mmsegmentation/mmseg/datasets/synapse.py
deleted file mode 100644
index 6f83b64..0000000
--- a/mmsegmentation/mmseg/datasets/synapse.py
+++ /dev/null
@@ -1,28 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmseg.registry import DATASETS
-from .basesegdataset import BaseSegDataset
-
-
-@DATASETS.register_module()
-class SynapseDataset(BaseSegDataset):
-    """Synapse dataset.
-
-    Before dataset preprocess of Synapse, there are total 13 categories of
-    foreground which does not include background. After preprocessing, 8
-    foreground categories are kept while the other 5 foreground categories are
-    handled as background. The ``img_suffix`` is fixed to '.jpg' and
-    ``seg_map_suffix`` is fixed to '.png'.
-    """
-    METAINFO = dict(
-        classes=('background', 'aorta', 'gallbladder', 'left_kidney',
-                 'right_kidney', 'liver', 'pancreas', 'spleen', 'stomach'),
-        palette=[[0, 0, 0], [0, 0, 255], [0, 255, 0], [255, 0, 0],
-                 [0, 255, 255], [255, 0, 255], [255, 255, 0], [60, 255, 255],
-                 [240, 240, 240]])
-
-    def __init__(self,
-                 img_suffix='.jpg',
-                 seg_map_suffix='.png',
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
diff --git a/mmsegmentation/mmseg/datasets/voc.py b/mmsegmentation/mmseg/datasets/voc.py
deleted file mode 100644
index 5e5d602..0000000
--- a/mmsegmentation/mmseg/datasets/voc.py
+++ /dev/null
@@ -1,40 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import os.path as osp
-
-import mmengine.fileio as fileio
-
-from mmseg.registry import DATASETS
-from .basesegdataset import BaseSegDataset
-
-
-@DATASETS.register_module()
-class PascalVOCDataset(BaseSegDataset):
-    """Pascal VOC dataset.
-
-    Args:
-        split (str): Split txt file for Pascal VOC.
-    """
-    METAINFO = dict(
-        classes=('background', 'aeroplane', 'bicycle', 'bird', 'boat',
-                 'bottle', 'bus', 'car', 'cat', 'chair', 'cow', 'diningtable',
-                 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep',
-                 'sofa', 'train', 'tvmonitor'),
-        palette=[[0, 0, 0], [128, 0, 0], [0, 128, 0], [128, 128, 0],
-                 [0, 0, 128], [128, 0, 128], [0, 128, 128], [128, 128, 128],
-                 [64, 0, 0], [192, 0, 0], [64, 128, 0], [192, 128, 0],
-                 [64, 0, 128], [192, 0, 128], [64, 128, 128], [192, 128, 128],
-                 [0, 64, 0], [128, 64, 0], [0, 192, 0], [128, 192, 0],
-                 [0, 64, 128]])
-
-    def __init__(self,
-                 ann_file,
-                 img_suffix='.jpg',
-                 seg_map_suffix='.png',
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            ann_file=ann_file,
-            **kwargs)
-        assert fileio.exists(self.data_prefix['img_path'],
-                             self.backend_args) and osp.isfile(self.ann_file)
diff --git a/mmsegmentation/mmseg/engine/__init__.py b/mmsegmentation/mmseg/engine/__init__.py
deleted file mode 100644
index 98139a0..0000000
--- a/mmsegmentation/mmseg/engine/__init__.py
+++ /dev/null
@@ -1,12 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .hooks import SegVisualizationHook
-from .optimizers import (ForceDefaultOptimWrapperConstructor,
-                         LayerDecayOptimizerConstructor,
-                         LearningRateDecayOptimizerConstructor)
-from .schedulers import PolyLRRatio
-
-__all__ = [
-    'LearningRateDecayOptimizerConstructor', 'LayerDecayOptimizerConstructor',
-    'SegVisualizationHook', 'PolyLRRatio',
-    'ForceDefaultOptimWrapperConstructor'
-]
diff --git a/mmsegmentation/mmseg/engine/hooks/__init__.py b/mmsegmentation/mmseg/engine/hooks/__init__.py
deleted file mode 100644
index c604808..0000000
--- a/mmsegmentation/mmseg/engine/hooks/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .visualization_hook import SegVisualizationHook
-
-__all__ = ['SegVisualizationHook']
diff --git a/mmsegmentation/mmseg/engine/hooks/visualization_hook.py b/mmsegmentation/mmseg/engine/hooks/visualization_hook.py
deleted file mode 100644
index 21cddde..0000000
--- a/mmsegmentation/mmseg/engine/hooks/visualization_hook.py
+++ /dev/null
@@ -1,129 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import os.path as osp
-import warnings
-from typing import Optional, Sequence
-
-import mmcv
-from mmengine.fileio import get
-from mmengine.hooks import Hook
-from mmengine.runner import Runner
-from mmengine.visualization import Visualizer
-
-from mmseg.registry import HOOKS
-from mmseg.structures import SegDataSample
-
-
-@HOOKS.register_module()
-class SegVisualizationHook(Hook):
-    """Segmentation Visualization Hook. Used to visualize validation and
-    testing process prediction results.
-
-    In the testing phase:
-
-    1. If ``show`` is True, it means that only the prediction results are
-        visualized without storing data, so ``vis_backends`` needs to
-        be excluded.
-
-    Args:
-        draw (bool): whether to draw prediction results. If it is False,
-            it means that no drawing will be done. Defaults to False.
-        interval (int): The interval of visualization. Defaults to 50.
-        show (bool): Whether to display the drawn image. Default to False.
-        wait_time (float): The interval of show (s). Defaults to 0.
-        backend_args (dict, Optional): Arguments to instantiate a file backend.
-            See https://mmengine.readthedocs.io/en/latest/api/fileio.htm
-            for details. Defaults to None.
-            Notes: mmcv>=2.0.0rc4, mmengine>=0.2.0 required.
-    """
-
-    def __init__(self,
-                 draw: bool = False,
-                 interval: int = 50,
-                 show: bool = False,
-                 wait_time: float = 0.,
-                 backend_args: Optional[dict] = None):
-        self._visualizer: Visualizer = Visualizer.get_current_instance()
-        self.interval = interval
-        self.show = show
-        if self.show:
-            # No need to think about vis backends.
-            self._visualizer._vis_backends = {}
-            warnings.warn('The show is True, it means that only '
-                          'the prediction results are visualized '
-                          'without storing data, so vis_backends '
-                          'needs to be excluded.')
-
-        self.wait_time = wait_time
-        self.backend_args = backend_args.copy() if backend_args else None
-        self.draw = draw
-        if not self.draw:
-            warnings.warn('The draw is False, it means that the '
-                          'hook for visualization will not take '
-                          'effect. The results will NOT be '
-                          'visualized or stored.')
-        self._test_index = 0
-
-    def after_val_iter(self, runner: Runner, batch_idx: int, data_batch: dict,
-                       outputs: Sequence[SegDataSample]) -> None:
-        """Run after every ``self.interval`` validation iterations.
-
-        Args:
-            runner (:obj:`Runner`): The runner of the validation process.
-            batch_idx (int): The index of the current batch in the val loop.
-            data_batch (dict): Data from dataloader.
-            outputs (Sequence[:obj:`SegDataSample`]]): A batch of data samples
-                that contain annotations and predictions.
-        """
-        if self.draw is False:
-            return
-
-        # There is no guarantee that the same batch of images
-        # is visualized for each evaluation.
-        total_curr_iter = runner.iter + batch_idx
-
-        # Visualize only the first data
-        img_path = outputs[0].img_path
-        img_bytes = get(img_path, backend_args=self.backend_args)
-        img = mmcv.imfrombytes(img_bytes, channel_order='rgb')
-        window_name = f'val_{osp.basename(img_path)}'
-
-        if total_curr_iter % self.interval == 0:
-            self._visualizer.add_datasample(
-                window_name,
-                img,
-                data_sample=outputs[0],
-                show=self.show,
-                wait_time=self.wait_time,
-                step=total_curr_iter)
-
-    def after_test_iter(self, runner: Runner, batch_idx: int, data_batch: dict,
-                        outputs: Sequence[SegDataSample]) -> None:
-        """Run after every testing iterations.
-
-        Args:
-            runner (:obj:`Runner`): The runner of the testing process.
-            batch_idx (int): The index of the current batch in the val loop.
-            data_batch (dict): Data from dataloader.
-            outputs (Sequence[:obj:`SegDataSample`]): A batch of data samples
-                that contain annotations and predictions.
-        """
-        if self.draw is False:
-            return
-
-        for data_sample in outputs:
-            self._test_index += 1
-
-            img_path = data_sample.img_path
-            window_name = f'test_{osp.basename(img_path)}'
-
-            img_path = data_sample.img_path
-            img_bytes = get(img_path, backend_args=self.backend_args)
-            img = mmcv.imfrombytes(img_bytes, channel_order='rgb')
-
-            self._visualizer.add_datasample(
-                window_name,
-                img,
-                data_sample=data_sample,
-                show=self.show,
-                wait_time=self.wait_time,
-                step=self._test_index)
diff --git a/mmsegmentation/mmseg/engine/optimizers/__init__.py b/mmsegmentation/mmseg/engine/optimizers/__init__.py
deleted file mode 100644
index e4cf587..0000000
--- a/mmsegmentation/mmseg/engine/optimizers/__init__.py
+++ /dev/null
@@ -1,9 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .force_default_constructor import ForceDefaultOptimWrapperConstructor
-from .layer_decay_optimizer_constructor import (
-    LayerDecayOptimizerConstructor, LearningRateDecayOptimizerConstructor)
-
-__all__ = [
-    'LearningRateDecayOptimizerConstructor', 'LayerDecayOptimizerConstructor',
-    'ForceDefaultOptimWrapperConstructor'
-]
diff --git a/mmsegmentation/mmseg/engine/optimizers/force_default_constructor.py b/mmsegmentation/mmseg/engine/optimizers/force_default_constructor.py
deleted file mode 100644
index 12c642a..0000000
--- a/mmsegmentation/mmseg/engine/optimizers/force_default_constructor.py
+++ /dev/null
@@ -1,255 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import logging
-from typing import List, Optional, Union
-
-import torch
-import torch.nn as nn
-from mmengine.logging import print_log
-from mmengine.optim import DefaultOptimWrapperConstructor
-from mmengine.utils.dl_utils import mmcv_full_available
-from mmengine.utils.dl_utils.parrots_wrapper import _BatchNorm, _InstanceNorm
-from torch.nn import GroupNorm, LayerNorm
-
-from mmseg.registry import OPTIM_WRAPPER_CONSTRUCTORS
-
-
-@OPTIM_WRAPPER_CONSTRUCTORS.register_module()
-class ForceDefaultOptimWrapperConstructor(DefaultOptimWrapperConstructor):
-    """Default constructor with forced optimizer settings.
-
-    This constructor extends the default constructor to add an option for
-    forcing default optimizer settings. This is useful for ensuring that
-    certain parameters or layers strictly adhere to pre-defined default
-    settings, regardless of any custom settings specified.
-
-    By default, each parameter share the same optimizer settings, and we
-    provide an argument ``paramwise_cfg`` to specify parameter-wise settings.
-    It is a dict and may contain various fields like 'custom_keys',
-    'bias_lr_mult', etc., as well as the additional field
-    `force_default_settings` which allows for enforcing default settings on
-    optimizer parameters.
-
-    - ``custom_keys`` (dict): Specified parameters-wise settings by keys. If
-      one of the keys in ``custom_keys`` is a substring of the name of one
-      parameter, then the setting of the parameter will be specified by
-      ``custom_keys[key]`` and other setting like ``bias_lr_mult`` etc. will
-      be ignored. It should be noted that the aforementioned ``key`` is the
-      longest key that is a substring of the name of the parameter. If there
-      are multiple matched keys with the same length, then the key with lower
-      alphabet order will be chosen.
-      ``custom_keys[key]`` should be a dict and may contain fields ``lr_mult``
-      and ``decay_mult``. See Example 2 below.
-    - ``bias_lr_mult`` (float): It will be multiplied to the learning
-      rate for all bias parameters (except for those in normalization
-      layers and offset layers of DCN).
-    - ``bias_decay_mult`` (float): It will be multiplied to the weight
-      decay for all bias parameters (except for those in
-      normalization layers, depthwise conv layers, offset layers of DCN).
-    - ``norm_decay_mult`` (float): It will be multiplied to the weight
-      decay for all weight and bias parameters of normalization
-      layers.
-    - ``flat_decay_mult`` (float): It will be multiplied to the weight
-      decay for all one-dimensional parameters
-    - ``dwconv_decay_mult`` (float): It will be multiplied to the weight
-      decay for all weight and bias parameters of depthwise conv
-      layers.
-    - ``dcn_offset_lr_mult`` (float): It will be multiplied to the learning
-      rate for parameters of offset layer in the deformable convs
-      of a model.
-    - ``bypass_duplicate`` (bool): If true, the duplicate parameters
-      would not be added into optimizer. Defaults to False.
-    - ``force_default_settings`` (bool): If true, this will override any
-      custom settings defined by ``custom_keys`` and enforce the use of
-      default settings for optimizer parameters like ``bias_lr_mult``.
-      This is particularly useful when you want to ensure that certain layers
-      or parameters adhere strictly to the pre-defined default settings.
-
-    Note:
-
-        1. If the option ``dcn_offset_lr_mult`` is used, the constructor will
-        override the effect of ``bias_lr_mult`` in the bias of offset layer.
-        So be careful when using both ``bias_lr_mult`` and
-        ``dcn_offset_lr_mult``. If you wish to apply both of them to the offset
-        layer in deformable convs, set ``dcn_offset_lr_mult`` to the original
-        ``dcn_offset_lr_mult`` * ``bias_lr_mult``.
-
-        2. If the option ``dcn_offset_lr_mult`` is used, the constructor will
-        apply it to all the DCN layers in the model. So be careful when the
-        model contains multiple DCN layers in places other than backbone.
-
-        3. When the option ``force_default_settings`` is true, it will override
-        any custom settings provided in ``custom_keys``. This ensures that the
-        default settings for the optimizer parameters are used.
-
-    Args:
-        optim_wrapper_cfg (dict): The config dict of the optimizer wrapper.
-
-            Required fields of ``optim_wrapper_cfg`` are
-
-            - ``type``: class name of the OptimizerWrapper
-            - ``optimizer``: The configuration of optimizer.
-
-            Optional fields of ``optim_wrapper_cfg`` are
-
-            - any arguments of the corresponding optimizer wrapper type,
-              e.g., accumulative_counts, clip_grad, etc.
-
-            Required fields of ``optimizer`` are
-
-            - `type`: class name of the optimizer.
-
-            Optional fields of ``optimizer`` are
-
-            - any arguments of the corresponding optimizer type, e.g.,
-              lr, weight_decay, momentum, etc.
-
-        paramwise_cfg (dict, optional): Parameter-wise options.
-
-    Example 1:
-        >>> model = torch.nn.modules.Conv1d(1, 1, 1)
-        >>> optim_wrapper_cfg = dict(
-        >>>     dict(type='OptimWrapper', optimizer=dict(type='SGD', lr=0.01,
-        >>>         momentum=0.9, weight_decay=0.0001))
-        >>> paramwise_cfg = dict(norm_decay_mult=0.)
-        >>> optim_wrapper_builder = DefaultOptimWrapperConstructor(
-        >>>     optim_wrapper_cfg, paramwise_cfg)
-        >>> optim_wrapper = optim_wrapper_builder(model)
-
-    Example 2:
-        >>> # assume model have attribute model.backbone and model.cls_head
-        >>> optim_wrapper_cfg = dict(type='OptimWrapper', optimizer=dict(
-        >>>     type='SGD', lr=0.01, weight_decay=0.95))
-        >>> paramwise_cfg = dict(custom_keys={
-        >>>     'backbone': dict(lr_mult=0.1, decay_mult=0.9)})
-        >>> optim_wrapper_builder = DefaultOptimWrapperConstructor(
-        >>>     optim_wrapper_cfg, paramwise_cfg)
-        >>> optim_wrapper = optim_wrapper_builder(model)
-        >>> # Then the `lr` and `weight_decay` for model.backbone is
-        >>> # (0.01 * 0.1, 0.95 * 0.9). `lr` and `weight_decay` for
-        >>> # model.cls_head is (0.01, 0.95).
-    """
-
-    def add_params(self,
-                   params: List[dict],
-                   module: nn.Module,
-                   prefix: str = '',
-                   is_dcn_module: Optional[Union[int, float]] = None) -> None:
-        """Add all parameters of module to the params list.
-
-        The parameters of the given module will be added to the list of param
-        groups, with specific rules defined by paramwise_cfg.
-
-        Args:
-            params (list[dict]): A list of param groups, it will be modified
-                in place.
-            module (nn.Module): The module to be added.
-            prefix (str): The prefix of the module
-            is_dcn_module (int|float|None): If the current module is a
-                submodule of DCN, `is_dcn_module` will be passed to
-                control conv_offset layer's learning rate. Defaults to None.
-        """
-        # get param-wise options
-        custom_keys = self.paramwise_cfg.get('custom_keys', {})
-        # first sort with alphabet order and then sort with reversed len of str
-        sorted_keys = sorted(sorted(custom_keys.keys()), key=len, reverse=True)
-
-        bias_lr_mult = self.paramwise_cfg.get('bias_lr_mult', None)
-        bias_decay_mult = self.paramwise_cfg.get('bias_decay_mult', None)
-        norm_decay_mult = self.paramwise_cfg.get('norm_decay_mult', None)
-        dwconv_decay_mult = self.paramwise_cfg.get('dwconv_decay_mult', None)
-        flat_decay_mult = self.paramwise_cfg.get('flat_decay_mult', None)
-        bypass_duplicate = self.paramwise_cfg.get('bypass_duplicate', False)
-        dcn_offset_lr_mult = self.paramwise_cfg.get('dcn_offset_lr_mult', None)
-        force_default_settings = self.paramwise_cfg.get(
-            'force_default_settings', False)
-
-        # special rules for norm layers and depth-wise conv layers
-        is_norm = isinstance(module,
-                             (_BatchNorm, _InstanceNorm, GroupNorm, LayerNorm))
-        is_dwconv = (
-            isinstance(module, torch.nn.Conv2d)
-            and module.in_channels == module.groups)
-
-        for name, param in module.named_parameters(recurse=False):
-            param_group = {'params': [param]}
-            if bypass_duplicate and self._is_in(param_group, params):
-                print_log(
-                    f'{prefix} is duplicate. It is skipped since '
-                    f'bypass_duplicate={bypass_duplicate}',
-                    logger='current',
-                    level=logging.WARNING)
-                continue
-            if not param.requires_grad:
-                params.append(param_group)
-                continue
-
-            # if the parameter match one of the custom keys, ignore other rules
-            is_custom = False
-            for key in sorted_keys:
-                if key in f'{prefix}.{name}':
-                    is_custom = True
-                    lr_mult = custom_keys[key].get('lr_mult', 1.)
-                    param_group['lr'] = self.base_lr * lr_mult
-                    if self.base_wd is not None:
-                        decay_mult = custom_keys[key].get('decay_mult', 1.)
-                        param_group['weight_decay'] = self.base_wd * decay_mult
-                    # add custom settings to param_group
-                    for k, v in custom_keys[key].items():
-                        param_group[k] = v
-                    break
-
-            if not is_custom or force_default_settings:
-                # bias_lr_mult affects all bias parameters
-                # except for norm.bias dcn.conv_offset.bias
-                if name == 'bias' and not (
-                        is_norm or is_dcn_module) and bias_lr_mult is not None:
-                    param_group['lr'] = self.base_lr * bias_lr_mult
-
-                if (prefix.find('conv_offset') != -1 and is_dcn_module
-                        and dcn_offset_lr_mult is not None
-                        and isinstance(module, torch.nn.Conv2d)):
-                    # deal with both dcn_offset's bias & weight
-                    param_group['lr'] = self.base_lr * dcn_offset_lr_mult
-
-                # apply weight decay policies
-                if self.base_wd is not None:
-                    # norm decay
-                    if is_norm and norm_decay_mult is not None:
-                        param_group[
-                            'weight_decay'] = self.base_wd * norm_decay_mult
-                    # bias lr and decay
-                    elif (name == 'bias' and not is_dcn_module
-                          and bias_decay_mult is not None):
-                        param_group[
-                            'weight_decay'] = self.base_wd * bias_decay_mult
-                    # depth-wise conv
-                    elif is_dwconv and dwconv_decay_mult is not None:
-                        param_group[
-                            'weight_decay'] = self.base_wd * dwconv_decay_mult
-                    # flatten parameters except dcn offset
-                    elif (param.ndim == 1 and not is_dcn_module
-                          and flat_decay_mult is not None):
-                        param_group[
-                            'weight_decay'] = self.base_wd * flat_decay_mult
-            params.append(param_group)
-            for key, value in param_group.items():
-                if key == 'params':
-                    continue
-                full_name = f'{prefix}.{name}' if prefix else name
-                print_log(
-                    f'paramwise_options -- {full_name}:{key}={value}',
-                    logger='current')
-
-        if mmcv_full_available():
-            from mmcv.ops import DeformConv2d, ModulatedDeformConv2d
-            is_dcn_module = isinstance(module,
-                                       (DeformConv2d, ModulatedDeformConv2d))
-        else:
-            is_dcn_module = False
-        for child_name, child_mod in module.named_children():
-            child_prefix = f'{prefix}.{child_name}' if prefix else child_name
-            self.add_params(
-                params,
-                child_mod,
-                prefix=child_prefix,
-                is_dcn_module=is_dcn_module)
diff --git a/mmsegmentation/mmseg/engine/optimizers/layer_decay_optimizer_constructor.py b/mmsegmentation/mmseg/engine/optimizers/layer_decay_optimizer_constructor.py
deleted file mode 100644
index fdae3ca..0000000
--- a/mmsegmentation/mmseg/engine/optimizers/layer_decay_optimizer_constructor.py
+++ /dev/null
@@ -1,207 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import json
-import warnings
-
-from mmengine.dist import get_dist_info
-from mmengine.logging import print_log
-from mmengine.optim import DefaultOptimWrapperConstructor
-
-from mmseg.registry import OPTIM_WRAPPER_CONSTRUCTORS
-
-
-def get_layer_id_for_convnext(var_name, max_layer_id):
-    """Get the layer id to set the different learning rates in ``layer_wise``
-    decay_type.
-
-    Args:
-        var_name (str): The key of the model.
-        max_layer_id (int): Maximum number of backbone layers.
-
-    Returns:
-        int: The id number corresponding to different learning rate in
-        ``LearningRateDecayOptimizerConstructor``.
-    """
-
-    if var_name in ('backbone.cls_token', 'backbone.mask_token',
-                    'backbone.pos_embed'):
-        return 0
-    elif var_name.startswith('backbone.downsample_layers'):
-        stage_id = int(var_name.split('.')[2])
-        if stage_id == 0:
-            layer_id = 0
-        elif stage_id == 1:
-            layer_id = 2
-        elif stage_id == 2:
-            layer_id = 3
-        elif stage_id == 3:
-            layer_id = max_layer_id
-        return layer_id
-    elif var_name.startswith('backbone.stages'):
-        stage_id = int(var_name.split('.')[2])
-        block_id = int(var_name.split('.')[3])
-        if stage_id == 0:
-            layer_id = 1
-        elif stage_id == 1:
-            layer_id = 2
-        elif stage_id == 2:
-            layer_id = 3 + block_id // 3
-        elif stage_id == 3:
-            layer_id = max_layer_id
-        return layer_id
-    else:
-        return max_layer_id + 1
-
-
-def get_stage_id_for_convnext(var_name, max_stage_id):
-    """Get the stage id to set the different learning rates in ``stage_wise``
-    decay_type.
-
-    Args:
-        var_name (str): The key of the model.
-        max_stage_id (int): Maximum number of backbone layers.
-
-    Returns:
-        int: The id number corresponding to different learning rate in
-        ``LearningRateDecayOptimizerConstructor``.
-    """
-
-    if var_name in ('backbone.cls_token', 'backbone.mask_token',
-                    'backbone.pos_embed'):
-        return 0
-    elif var_name.startswith('backbone.downsample_layers'):
-        return 0
-    elif var_name.startswith('backbone.stages'):
-        stage_id = int(var_name.split('.')[2])
-        return stage_id + 1
-    else:
-        return max_stage_id - 1
-
-
-def get_layer_id_for_vit(var_name, max_layer_id):
-    """Get the layer id to set the different learning rates.
-
-    Args:
-        var_name (str): The key of the model.
-        num_max_layer (int): Maximum number of backbone layers.
-
-    Returns:
-        int: Returns the layer id of the key.
-    """
-
-    if var_name in ('backbone.cls_token', 'backbone.mask_token',
-                    'backbone.pos_embed'):
-        return 0
-    elif var_name.startswith('backbone.patch_embed'):
-        return 0
-    elif var_name.startswith('backbone.layers'):
-        layer_id = int(var_name.split('.')[2])
-        return layer_id + 1
-    else:
-        return max_layer_id - 1
-
-
-@OPTIM_WRAPPER_CONSTRUCTORS.register_module()
-class LearningRateDecayOptimizerConstructor(DefaultOptimWrapperConstructor):
-    """Different learning rates are set for different layers of backbone.
-
-    Note: Currently, this optimizer constructor is built for ConvNeXt,
-    BEiT and MAE.
-    """
-
-    def add_params(self, params, module, **kwargs):
-        """Add all parameters of module to the params list.
-
-        The parameters of the given module will be added to the list of param
-        groups, with specific rules defined by paramwise_cfg.
-
-        Args:
-            params (list[dict]): A list of param groups, it will be modified
-                in place.
-            module (nn.Module): The module to be added.
-        """
-
-        parameter_groups = {}
-        print_log(f'self.paramwise_cfg is {self.paramwise_cfg}')
-        num_layers = self.paramwise_cfg.get('num_layers') + 2
-        decay_rate = self.paramwise_cfg.get('decay_rate')
-        decay_type = self.paramwise_cfg.get('decay_type', 'layer_wise')
-        print_log('Build LearningRateDecayOptimizerConstructor  '
-                  f'{decay_type} {decay_rate} - {num_layers}')
-        weight_decay = self.base_wd
-        for name, param in module.named_parameters():
-            if not param.requires_grad:
-                continue  # frozen weights
-            if len(param.shape) == 1 or name.endswith('.bias') or name in (
-                    'pos_embed', 'cls_token'):
-                group_name = 'no_decay'
-                this_weight_decay = 0.
-            else:
-                group_name = 'decay'
-                this_weight_decay = weight_decay
-            if 'layer_wise' in decay_type:
-                if 'ConvNeXt' in module.backbone.__class__.__name__:
-                    layer_id = get_layer_id_for_convnext(
-                        name, self.paramwise_cfg.get('num_layers'))
-                    print_log(f'set param {name} as id {layer_id}')
-                elif 'BEiT' in module.backbone.__class__.__name__ or \
-                     'MAE' in module.backbone.__class__.__name__:
-                    layer_id = get_layer_id_for_vit(name, num_layers)
-                    print_log(f'set param {name} as id {layer_id}')
-                else:
-                    raise NotImplementedError()
-            elif decay_type == 'stage_wise':
-                if 'ConvNeXt' in module.backbone.__class__.__name__:
-                    layer_id = get_stage_id_for_convnext(name, num_layers)
-                    print_log(f'set param {name} as id {layer_id}')
-                else:
-                    raise NotImplementedError()
-            group_name = f'layer_{layer_id}_{group_name}'
-
-            if group_name not in parameter_groups:
-                scale = decay_rate**(num_layers - layer_id - 1)
-
-                parameter_groups[group_name] = {
-                    'weight_decay': this_weight_decay,
-                    'params': [],
-                    'param_names': [],
-                    'lr_scale': scale,
-                    'group_name': group_name,
-                    'lr': scale * self.base_lr,
-                }
-
-            parameter_groups[group_name]['params'].append(param)
-            parameter_groups[group_name]['param_names'].append(name)
-        rank, _ = get_dist_info()
-        if rank == 0:
-            to_display = {}
-            for key in parameter_groups:
-                to_display[key] = {
-                    'param_names': parameter_groups[key]['param_names'],
-                    'lr_scale': parameter_groups[key]['lr_scale'],
-                    'lr': parameter_groups[key]['lr'],
-                    'weight_decay': parameter_groups[key]['weight_decay'],
-                }
-            print_log(f'Param groups = {json.dumps(to_display, indent=2)}')
-        params.extend(parameter_groups.values())
-
-
-@OPTIM_WRAPPER_CONSTRUCTORS.register_module()
-class LayerDecayOptimizerConstructor(LearningRateDecayOptimizerConstructor):
-    """Different learning rates are set for different layers of backbone.
-
-    Note: Currently, this optimizer constructor is built for BEiT,
-    and it will be deprecated.
-    Please use ``LearningRateDecayOptimizerConstructor`` instead.
-    """
-
-    def __init__(self, optim_wrapper_cfg, paramwise_cfg):
-        warnings.warn('DeprecationWarning: Original '
-                      'LayerDecayOptimizerConstructor of BEiT '
-                      'will be deprecated. Please use '
-                      'LearningRateDecayOptimizerConstructor instead, '
-                      'and set decay_type = layer_wise_vit in paramwise_cfg.')
-        paramwise_cfg.update({'decay_type': 'layer_wise_vit'})
-        warnings.warn('DeprecationWarning: Layer_decay_rate will '
-                      'be deleted, please use decay_rate instead.')
-        paramwise_cfg['decay_rate'] = paramwise_cfg.pop('layer_decay_rate')
-        super().__init__(optim_wrapper_cfg, paramwise_cfg)
diff --git a/mmsegmentation/mmseg/engine/schedulers/__init__.py b/mmsegmentation/mmseg/engine/schedulers/__init__.py
deleted file mode 100644
index 3cd3f62..0000000
--- a/mmsegmentation/mmseg/engine/schedulers/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .poly_ratio_scheduler import PolyLRRatio
-
-__all__ = ['PolyLRRatio']
diff --git a/mmsegmentation/mmseg/engine/schedulers/poly_ratio_scheduler.py b/mmsegmentation/mmseg/engine/schedulers/poly_ratio_scheduler.py
deleted file mode 100644
index 057203a..0000000
--- a/mmsegmentation/mmseg/engine/schedulers/poly_ratio_scheduler.py
+++ /dev/null
@@ -1,62 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from typing import Optional
-
-from mmengine.optim.scheduler import PolyLR
-
-from mmseg.registry import PARAM_SCHEDULERS
-
-
-@PARAM_SCHEDULERS.register_module()
-class PolyLRRatio(PolyLR):
-    """Implements polynomial learning rate decay with ratio.
-
-    This scheduler adjusts the learning rate of each parameter group
-    following a polynomial decay equation. The decay can occur in
-    conjunction with external parameter adjustments made outside this
-    scheduler.
-
-    Args:
-        optimizer (Optimizer or OptimWrapper): Wrapped optimizer.
-        eta_min (float): Minimum learning rate at the end of scheduling.
-            Defaults to 0.
-        eta_min_ratio (float, optional): The ratio of the minimum parameter
-            value to the base parameter value. Either `eta_min` or
-            `eta_min_ratio` should be specified. Defaults to None.
-        power (float): The power of the polynomial. Defaults to 1.0.
-        begin (int): Step at which to start updating the parameters.
-            Defaults to 0.
-        end (int): Step at which to stop updating the parameters.
-            Defaults to INF.
-        last_step (int): The index of last step. Used for resume without
-            state dict. Defaults to -1.
-        by_epoch (bool): Whether the scheduled parameters are updated by
-            epochs. Defaults to True.
-        verbose (bool): Whether to print the value for each update.
-            Defaults to False.
-    """
-
-    def __init__(self, eta_min_ratio: Optional[int] = None, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-        self.eta_min_ratio = eta_min_ratio
-
-    def _get_value(self):
-        """Compute value using chainable form of the scheduler."""
-
-        if self.last_step == 0:
-            return [
-                group[self.param_name] for group in self.optimizer.param_groups
-            ]
-
-        param_groups_value = []
-        for base_value, param_group in zip(self.base_values,
-                                           self.optimizer.param_groups):
-            eta_min = self.eta_min if self.eta_min_ratio is None else \
-                base_value * self.eta_min_ratio
-            step_ratio = (1 - 1 /
-                          (self.total_iters - self.last_step + 1))**self.power
-            step_value = (param_group[self.param_name] -
-                          eta_min) * step_ratio + eta_min
-            param_groups_value.append(step_value)
-
-        return param_groups_value
diff --git a/mmsegmentation/mmseg/registry/__init__.py b/mmsegmentation/mmseg/registry/__init__.py
deleted file mode 100644
index ee514d1..0000000
--- a/mmsegmentation/mmseg/registry/__init__.py
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .registry import (DATA_SAMPLERS, DATASETS, EVALUATOR, HOOKS, INFERENCERS,
-                       LOG_PROCESSORS, LOOPS, METRICS, MODEL_WRAPPERS, MODELS,
-                       OPTIM_WRAPPER_CONSTRUCTORS, OPTIM_WRAPPERS, OPTIMIZERS,
-                       PARAM_SCHEDULERS, RUNNER_CONSTRUCTORS, RUNNERS,
-                       TASK_UTILS, TRANSFORMS, VISBACKENDS, VISUALIZERS,
-                       WEIGHT_INITIALIZERS)
-
-__all__ = [
-    'HOOKS', 'DATASETS', 'DATA_SAMPLERS', 'TRANSFORMS', 'MODELS',
-    'WEIGHT_INITIALIZERS', 'OPTIMIZERS', 'OPTIM_WRAPPER_CONSTRUCTORS',
-    'TASK_UTILS', 'PARAM_SCHEDULERS', 'METRICS', 'MODEL_WRAPPERS',
-    'VISBACKENDS', 'VISUALIZERS', 'RUNNERS', 'RUNNER_CONSTRUCTORS', 'LOOPS',
-    'EVALUATOR', 'LOG_PROCESSORS', 'OPTIM_WRAPPERS', 'INFERENCERS'
-]
diff --git a/mmsegmentation/mmseg/registry/registry.py b/mmsegmentation/mmseg/registry/registry.py
deleted file mode 100644
index 37b6a77..0000000
--- a/mmsegmentation/mmseg/registry/registry.py
+++ /dev/null
@@ -1,118 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-"""MMSegmentation provides 21 registry nodes to support using modules across
-projects. Each node is a child of the root registry in MMEngine.
-
-More details can be found at
-https://mmengine.readthedocs.io/en/latest/advanced_tutorials/registry.html.
-"""
-
-from mmengine.registry import DATA_SAMPLERS as MMENGINE_DATA_SAMPLERS
-from mmengine.registry import DATASETS as MMENGINE_DATASETS
-from mmengine.registry import EVALUATOR as MMENGINE_EVALUATOR
-from mmengine.registry import HOOKS as MMENGINE_HOOKS
-from mmengine.registry import INFERENCERS as MMENGINE_INFERENCERS
-from mmengine.registry import LOG_PROCESSORS as MMENGINE_LOG_PROCESSORS
-from mmengine.registry import LOOPS as MMENGINE_LOOPS
-from mmengine.registry import METRICS as MMENGINE_METRICS
-from mmengine.registry import MODEL_WRAPPERS as MMENGINE_MODEL_WRAPPERS
-from mmengine.registry import MODELS as MMENGINE_MODELS
-from mmengine.registry import \
-    OPTIM_WRAPPER_CONSTRUCTORS as MMENGINE_OPTIM_WRAPPER_CONSTRUCTORS
-from mmengine.registry import OPTIM_WRAPPERS as MMENGINE_OPTIM_WRAPPERS
-from mmengine.registry import OPTIMIZERS as MMENGINE_OPTIMIZERS
-from mmengine.registry import PARAM_SCHEDULERS as MMENGINE_PARAM_SCHEDULERS
-from mmengine.registry import \
-    RUNNER_CONSTRUCTORS as MMENGINE_RUNNER_CONSTRUCTORS
-from mmengine.registry import RUNNERS as MMENGINE_RUNNERS
-from mmengine.registry import TASK_UTILS as MMENGINE_TASK_UTILS
-from mmengine.registry import TRANSFORMS as MMENGINE_TRANSFORMS
-from mmengine.registry import VISBACKENDS as MMENGINE_VISBACKENDS
-from mmengine.registry import VISUALIZERS as MMENGINE_VISUALIZERS
-from mmengine.registry import \
-    WEIGHT_INITIALIZERS as MMENGINE_WEIGHT_INITIALIZERS
-from mmengine.registry import Registry
-
-# manage all kinds of runners like `EpochBasedRunner` and `IterBasedRunner`
-RUNNERS = Registry('runner', parent=MMENGINE_RUNNERS)
-# manage runner constructors that define how to initialize runners
-RUNNER_CONSTRUCTORS = Registry(
-    'runner constructor', parent=MMENGINE_RUNNER_CONSTRUCTORS)
-# manage all kinds of loops like `EpochBasedTrainLoop`
-LOOPS = Registry('loop', parent=MMENGINE_LOOPS)
-# manage all kinds of hooks like `CheckpointHook`
-HOOKS = Registry(
-    'hook', parent=MMENGINE_HOOKS, locations=['mmseg.engine.hooks'])
-
-# manage data-related modules
-DATASETS = Registry(
-    'dataset', parent=MMENGINE_DATASETS, locations=['mmseg.datasets'])
-DATA_SAMPLERS = Registry('data sampler', parent=MMENGINE_DATA_SAMPLERS)
-TRANSFORMS = Registry(
-    'transform',
-    parent=MMENGINE_TRANSFORMS,
-    locations=['mmseg.datasets.transforms'])
-
-# mangage all kinds of modules inheriting `nn.Module`
-MODELS = Registry('model', parent=MMENGINE_MODELS, locations=['mmseg.models'])
-# mangage all kinds of model wrappers like 'MMDistributedDataParallel'
-MODEL_WRAPPERS = Registry(
-    'model_wrapper',
-    parent=MMENGINE_MODEL_WRAPPERS,
-    locations=['mmseg.models'])
-# mangage all kinds of weight initialization modules like `Uniform`
-WEIGHT_INITIALIZERS = Registry(
-    'weight initializer',
-    parent=MMENGINE_WEIGHT_INITIALIZERS,
-    locations=['mmseg.models'])
-
-# mangage all kinds of optimizers like `SGD` and `Adam`
-OPTIMIZERS = Registry(
-    'optimizer',
-    parent=MMENGINE_OPTIMIZERS,
-    locations=['mmseg.engine.optimizers'])
-# manage optimizer wrapper
-OPTIM_WRAPPERS = Registry(
-    'optim_wrapper',
-    parent=MMENGINE_OPTIM_WRAPPERS,
-    locations=['mmseg.engine.optimizers'])
-# manage constructors that customize the optimization hyperparameters.
-OPTIM_WRAPPER_CONSTRUCTORS = Registry(
-    'optimizer wrapper constructor',
-    parent=MMENGINE_OPTIM_WRAPPER_CONSTRUCTORS,
-    locations=['mmseg.engine.optimizers'])
-# mangage all kinds of parameter schedulers like `MultiStepLR`
-PARAM_SCHEDULERS = Registry(
-    'parameter scheduler',
-    parent=MMENGINE_PARAM_SCHEDULERS,
-    locations=['mmseg.engine.schedulers'])
-
-# manage all kinds of metrics
-METRICS = Registry(
-    'metric', parent=MMENGINE_METRICS, locations=['mmseg.evaluation'])
-# manage evaluator
-EVALUATOR = Registry(
-    'evaluator', parent=MMENGINE_EVALUATOR, locations=['mmseg.evaluation'])
-
-# manage task-specific modules like ohem pixel sampler
-TASK_UTILS = Registry(
-    'task util', parent=MMENGINE_TASK_UTILS, locations=['mmseg.models'])
-
-# manage visualizer
-VISUALIZERS = Registry(
-    'visualizer',
-    parent=MMENGINE_VISUALIZERS,
-    locations=['mmseg.visualization'])
-# manage visualizer backend
-VISBACKENDS = Registry(
-    'vis_backend',
-    parent=MMENGINE_VISBACKENDS,
-    locations=['mmseg.visualization'])
-
-# manage logprocessor
-LOG_PROCESSORS = Registry(
-    'log_processor',
-    parent=MMENGINE_LOG_PROCESSORS,
-    locations=['mmseg.visualization'])
-
-# manage inferencer
-INFERENCERS = Registry('inferencer', parent=MMENGINE_INFERENCERS)
diff --git a/mmsegmentation/mmseg/structures/__init__.py b/mmsegmentation/mmseg/structures/__init__.py
deleted file mode 100644
index 63d118d..0000000
--- a/mmsegmentation/mmseg/structures/__init__.py
+++ /dev/null
@@ -1,8 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .sampler import BasePixelSampler, OHEMPixelSampler, build_pixel_sampler
-from .seg_data_sample import SegDataSample
-
-__all__ = [
-    'SegDataSample', 'BasePixelSampler', 'OHEMPixelSampler',
-    'build_pixel_sampler'
-]
diff --git a/mmsegmentation/mmseg/structures/sampler/__init__.py b/mmsegmentation/mmseg/structures/sampler/__init__.py
deleted file mode 100644
index 91d762d..0000000
--- a/mmsegmentation/mmseg/structures/sampler/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .base_pixel_sampler import BasePixelSampler
-from .builder import build_pixel_sampler
-from .ohem_pixel_sampler import OHEMPixelSampler
-
-__all__ = ['build_pixel_sampler', 'BasePixelSampler', 'OHEMPixelSampler']
diff --git a/mmsegmentation/mmseg/structures/sampler/base_pixel_sampler.py b/mmsegmentation/mmseg/structures/sampler/base_pixel_sampler.py
deleted file mode 100644
index 03672cd..0000000
--- a/mmsegmentation/mmseg/structures/sampler/base_pixel_sampler.py
+++ /dev/null
@@ -1,13 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from abc import ABCMeta, abstractmethod
-
-
-class BasePixelSampler(metaclass=ABCMeta):
-    """Base class of pixel sampler."""
-
-    def __init__(self, **kwargs):
-        pass
-
-    @abstractmethod
-    def sample(self, seg_logit, seg_label):
-        """Placeholder for sample function."""
diff --git a/mmsegmentation/mmseg/structures/sampler/builder.py b/mmsegmentation/mmseg/structures/sampler/builder.py
deleted file mode 100644
index 48e1479..0000000
--- a/mmsegmentation/mmseg/structures/sampler/builder.py
+++ /dev/null
@@ -1,14 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import warnings
-
-from mmseg.registry import TASK_UTILS
-
-PIXEL_SAMPLERS = TASK_UTILS
-
-
-def build_pixel_sampler(cfg, **default_args):
-    """Build pixel sampler for segmentation map."""
-    warnings.warn(
-        '``build_pixel_sampler`` would be deprecated soon, please use '
-        '``mmseg.registry.TASK_UTILS.build()`` ')
-    return TASK_UTILS.build(cfg, default_args=default_args)
diff --git a/mmsegmentation/mmseg/structures/sampler/ohem_pixel_sampler.py b/mmsegmentation/mmseg/structures/sampler/ohem_pixel_sampler.py
deleted file mode 100644
index a974273..0000000
--- a/mmsegmentation/mmseg/structures/sampler/ohem_pixel_sampler.py
+++ /dev/null
@@ -1,85 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-from .base_pixel_sampler import BasePixelSampler
-from .builder import PIXEL_SAMPLERS
-
-
-@PIXEL_SAMPLERS.register_module()
-class OHEMPixelSampler(BasePixelSampler):
-    """Online Hard Example Mining Sampler for segmentation.
-
-    Args:
-        context (nn.Module): The context of sampler, subclass of
-            :obj:`BaseDecodeHead`.
-        thresh (float, optional): The threshold for hard example selection.
-            Below which, are prediction with low confidence. If not
-            specified, the hard examples will be pixels of top ``min_kept``
-            loss. Default: None.
-        min_kept (int, optional): The minimum number of predictions to keep.
-            Default: 100000.
-    """
-
-    def __init__(self, context, thresh=None, min_kept=100000):
-        super().__init__()
-        self.context = context
-        assert min_kept > 1
-        self.thresh = thresh
-        self.min_kept = min_kept
-
-    def sample(self, seg_logit, seg_label):
-        """Sample pixels that have high loss or with low prediction confidence.
-
-        Args:
-            seg_logit (torch.Tensor): segmentation logits, shape (N, C, H, W)
-            seg_label (torch.Tensor): segmentation label, shape (N, 1, H, W)
-
-        Returns:
-            torch.Tensor: segmentation weight, shape (N, H, W)
-        """
-        with torch.no_grad():
-            assert seg_logit.shape[2:] == seg_label.shape[2:]
-            assert seg_label.shape[1] == 1
-            seg_label = seg_label.squeeze(1).long()
-            batch_kept = self.min_kept * seg_label.size(0)
-            valid_mask = seg_label != self.context.ignore_index
-            seg_weight = seg_logit.new_zeros(size=seg_label.size())
-            valid_seg_weight = seg_weight[valid_mask]
-            if self.thresh is not None:
-                seg_prob = F.softmax(seg_logit, dim=1)
-
-                tmp_seg_label = seg_label.clone().unsqueeze(1)
-                tmp_seg_label[tmp_seg_label == self.context.ignore_index] = 0
-                seg_prob = seg_prob.gather(1, tmp_seg_label).squeeze(1)
-                sort_prob, sort_indices = seg_prob[valid_mask].sort()
-
-                if sort_prob.numel() > 0:
-                    min_threshold = sort_prob[min(batch_kept,
-                                                  sort_prob.numel() - 1)]
-                else:
-                    min_threshold = 0.0
-                threshold = max(min_threshold, self.thresh)
-                valid_seg_weight[seg_prob[valid_mask] < threshold] = 1.
-            else:
-                if not isinstance(self.context.loss_decode, nn.ModuleList):
-                    losses_decode = [self.context.loss_decode]
-                else:
-                    losses_decode = self.context.loss_decode
-                losses = 0.0
-                for loss_module in losses_decode:
-                    losses += loss_module(
-                        seg_logit,
-                        seg_label,
-                        weight=None,
-                        ignore_index=self.context.ignore_index,
-                        reduction_override='none')
-
-                # faster than topk according to https://github.com/pytorch/pytorch/issues/22812  # noqa
-                _, sort_indices = losses[valid_mask].sort(descending=True)
-                valid_seg_weight[sort_indices[:batch_kept]] = 1.
-
-            seg_weight[valid_mask] = valid_seg_weight
-
-            return seg_weight
diff --git a/mmsegmentation/mmseg/structures/seg_data_sample.py b/mmsegmentation/mmseg/structures/seg_data_sample.py
deleted file mode 100644
index ce68b54..0000000
--- a/mmsegmentation/mmseg/structures/seg_data_sample.py
+++ /dev/null
@@ -1,92 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmengine.structures import BaseDataElement, PixelData
-
-
-class SegDataSample(BaseDataElement):
-    """A data structure interface of MMSegmentation. They are used as
-    interfaces between different components.
-
-    The attributes in ``SegDataSample`` are divided into several parts:
-
-        - ``gt_sem_seg``(PixelData): Ground truth of semantic segmentation.
-        - ``pred_sem_seg``(PixelData): Prediction of semantic segmentation.
-        - ``seg_logits``(PixelData): Predicted logits of semantic segmentation.
-
-    Examples:
-         >>> import torch
-         >>> import numpy as np
-         >>> from mmengine.structures import PixelData
-         >>> from mmseg.structures import SegDataSample
-
-         >>> data_sample = SegDataSample()
-         >>> img_meta = dict(img_shape=(4, 4, 3),
-         ...                 pad_shape=(4, 4, 3))
-         >>> gt_segmentations = PixelData(metainfo=img_meta)
-         >>> gt_segmentations.data = torch.randint(0, 2, (1, 4, 4))
-         >>> data_sample.gt_sem_seg = gt_segmentations
-         >>> assert 'img_shape' in data_sample.gt_sem_seg.metainfo_keys()
-         >>> data_sample.gt_sem_seg.shape
-         (4, 4)
-         >>> print(data_sample)
-        <SegDataSample(
-
-            META INFORMATION
-
-            DATA FIELDS
-            gt_sem_seg: <PixelData(
-
-                    META INFORMATION
-                    img_shape: (4, 4, 3)
-                    pad_shape: (4, 4, 3)
-
-                    DATA FIELDS
-                    data: tensor([[[1, 1, 1, 0],
-                                 [1, 0, 1, 1],
-                                 [1, 1, 1, 1],
-                                 [0, 1, 0, 1]]])
-                ) at 0x1c2b4156460>
-        ) at 0x1c2aae44d60>
-
-        >>> data_sample = SegDataSample()
-        >>> gt_sem_seg_data = dict(sem_seg=torch.rand(1, 4, 4))
-        >>> gt_sem_seg = PixelData(**gt_sem_seg_data)
-        >>> data_sample.gt_sem_seg = gt_sem_seg
-        >>> assert 'gt_sem_seg' in data_sample
-        >>> assert 'sem_seg' in data_sample.gt_sem_seg
-    """
-
-    @property
-    def gt_sem_seg(self) -> PixelData:
-        return self._gt_sem_seg
-
-    @gt_sem_seg.setter
-    def gt_sem_seg(self, value: PixelData) -> None:
-        self.set_field(value, '_gt_sem_seg', dtype=PixelData)
-
-    @gt_sem_seg.deleter
-    def gt_sem_seg(self) -> None:
-        del self._gt_sem_seg
-
-    @property
-    def pred_sem_seg(self) -> PixelData:
-        return self._pred_sem_seg
-
-    @pred_sem_seg.setter
-    def pred_sem_seg(self, value: PixelData) -> None:
-        self.set_field(value, '_pred_sem_seg', dtype=PixelData)
-
-    @pred_sem_seg.deleter
-    def pred_sem_seg(self) -> None:
-        del self._pred_sem_seg
-
-    @property
-    def seg_logits(self) -> PixelData:
-        return self._seg_logits
-
-    @seg_logits.setter
-    def seg_logits(self, value: PixelData) -> None:
-        self.set_field(value, '_seg_logits', dtype=PixelData)
-
-    @seg_logits.deleter
-    def seg_logits(self) -> None:
-        del self._seg_logits
diff --git a/mmsegmentation/mmseg/utils/__init__.py b/mmsegmentation/mmseg/utils/__init__.py
deleted file mode 100644
index 8743e78..0000000
--- a/mmsegmentation/mmseg/utils/__init__.py
+++ /dev/null
@@ -1,72 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-# yapf: disable
-from .class_names import (ade_classes, ade_palette, bdd100k_classes,
-                          bdd100k_palette, cityscapes_classes,
-                          cityscapes_palette, cocostuff_classes,
-                          cocostuff_palette, dataset_aliases, get_classes,
-                          get_palette, isaid_classes, isaid_palette,
-                          loveda_classes, loveda_palette, potsdam_classes,
-                          potsdam_palette, stare_classes, stare_palette,
-                          synapse_classes, synapse_palette, vaihingen_classes,
-                          vaihingen_palette, voc_classes, voc_palette, xray_classes, xray_palette)
-# yapf: enable
-from .collect_env import collect_env
-from .get_templates import get_predefined_templates
-from .io import datafrombytes
-from .misc import add_prefix, stack_batch
-from .set_env import register_all_modules
-from .tokenizer import tokenize
-from .typing_utils import (ConfigType, ForwardResults, MultiConfig,
-                           OptConfigType, OptMultiConfig, OptSampleList,
-                           SampleList, TensorDict, TensorList)
-
-# isort: off
-from .mask_classification import MatchMasks, seg_data_to_instance_data
-
-__all__ = [
-    'collect_env',
-    'register_all_modules',
-    'stack_batch',
-    'add_prefix',
-    'ConfigType',
-    'OptConfigType',
-    'MultiConfig',
-    'OptMultiConfig',
-    'SampleList',
-    'OptSampleList',
-    'TensorDict',
-    'TensorList',
-    'ForwardResults',
-    'cityscapes_classes',
-    'ade_classes',
-    'voc_classes',
-    'cocostuff_classes',
-    'loveda_classes',
-    'potsdam_classes',
-    'vaihingen_classes',
-    'isaid_classes',
-    'stare_classes',
-    'cityscapes_palette',
-    'ade_palette',
-    'voc_palette',
-    'cocostuff_palette',
-    'loveda_palette',
-    'potsdam_palette',
-    'vaihingen_palette',
-    'isaid_palette',
-    'stare_palette',
-    'dataset_aliases',
-    'get_classes',
-    'get_palette',
-    'datafrombytes',
-    'synapse_palette',
-    'synapse_classes',
-    'get_predefined_templates',
-    'tokenize',
-    'seg_data_to_instance_data',
-    'MatchMasks',
-    'bdd100k_classes',
-    'bdd100k_palette',
-    'xray_classes',
-    'xray_palette'
-]
diff --git a/mmsegmentation/mmseg/utils/bpe_simple_vocab_16e6.txt.gz b/mmsegmentation/mmseg/utils/bpe_simple_vocab_16e6.txt.gz
deleted file mode 100644
index 7b5088a527f720063f044eb928eee315f63b2fc0..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1356917
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%0D-8anuzg!0hrX~L}M*$l~SOpZ7=I+%ag
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%0A|F7fvQOLDQFPf3
zPOTtwq3aIHbf`9lI>@^$v^-N>F4a^Z3{`VQz}SNgNvN%IxWZmJaA0j(TT$)qaHwaO
z8n8xqA&~Wv1$^cN0;771LQ(<j@iHdYh799FHx({UhDId@5C}x@*2yx7a}m8`gr56*
z=>1O@Hvd&ocscMBY6|FJYC0hYD<JM`IX{jQMoV~L8^+XcbBxzOu{$YR<K5te?|u?q
z{-852{3t$)Ri+8BOF{<R&yVK2y-Vd@RduyK6-AjyWv8uEY+gGO@1tJF)o6R7t6Qf_
zma1NOQu?<&N)%DVLOj6y@p0D5-rNkmOmF;B(y7TJ;>y);;Zr{ZSH`Xv9c#;8k>_po
z94=E8S<ho08?5Lhz%LT?Kb<3wMHt4XmK<a#Ec#eAMOSul<cm|1fFy@vYG+U-vOI@G
zl(7Jz6Gj`Q)M9o07Tf)sSLR8tAKCF*ALvfT5Vi<>P_n2nU9UYsL(9sdLj+(U5{Ptz
z=!dOg5W*;DPu4UTFy#&Qg9@Us<v_60x!wW886CDhcn4s)2SPX&N3&r%aL1q%3hGR~
zm7in%v<mfg#_&co<1C*?`*t|BW$iLH*&8|8^~~OTYa%Va2B<9L=JvE$uSO#9t_<9u
z-mbSg-&P0?Ocb#lv+{zZBk=!>YycFU<X(ej?>un#)=GJFIf&~DTgv5uv)Sls{>TPa
zkOg1u>Bw^V8m1EKJc6Uu-u<KQsFI?}xwB2zhqt8A)KhMBHc5bGnwdH@c~lIYPF5b;
z$bul4`+7+3m;&K&G_dJMXMCiDg-PiiGEnEHVjtu=pLPC@ppi>3^pB;^>+I?w`59*i
zqv<lUpPOp=n9uGiUBVz{-A;e|gYdWMMgt&~Zs|d<34moC;2V<e+@76?Kjr)MH6>HN
zcuh>ZZ3@^qIW<;&;_MU@nx^H+#U0RvVMnW|7$J5pvGiG&@u;+I`gXYJ*n$c$UBbnb
z`)t|(Pdj%q@>v3QiB$Q-f2-FSo<eiFNO5AKl8q#0dx-K6IJdCLV|do8j#~&C;JK?_
zM4SgK9Y9W8>zZ63l#c3+!HF|w(JGTIk$#%86}9ZUk)c2zyP<{vUjn}`qx_;8*13mv
zyg}x{9>ZVQ>i$dmJP$i;FbSlt$)GYO!+27&DRBLhlNRX=ZFtzMx+ueN*bQI2{_L$%
zGX`&E=`9N%E5(RnhD$nRapZTOgqNRN%tgjuV1A9H#ywVmMr#im9Fyk5b`nBw2>C?o
z26`3@aZi_0g>wyxm5d#;J#^Z)ZRT0c$KBX{*J$~(*N-XF|AAlm=UAQI;gkb9-P_By
z+z8@OH_@Hz1kzdMsmwqLkne6fErJZ~QqPlm(l9|)qt!E!h0tNyNwAX`ex`55E;sjK
zrN_msuM5RnWkwtLhwV)#?di!&S;d-Zh8r)4?2LMVt>y`e<YP%k;ca>I(Mfw|y>?C(
zX0dmUrW^RVc1jmeAIqm!4H;7;!?N#A7x^d1|83hs#|HiY6yoJ`!rYZO&cds5Ipe@g
ztdpwUgS#56Ld$F<j7kX64heTUSb^$YVSNVGWoR7*40<6;mMQe<Oldk`b{!P+?@c})
z!0?2_`UyPFXnu$1Q6U3KGcY^cM#+nTU$#s|Qy0kS!3z*(Vx6i>vWu$%8QMTWKDTDa
z59nCge6A1F#h9VkVda^;%?{{LoH%wz!lminVl%^sB#b~=l^dJZ10tS0x(cN@q!_@+
zNgo$8xrXQclI6vlacuH!XxjX=DlmT-#oi0|(pNQseZUYW%OkIeP+m_HE<hrK!ity%
z$d90ncHepXS1j*}Xwh0N+-1SZ8?;0sEm4UW96W<GV&$#cN~Q}+a-Oz=FU%$6ju+5~
z(GHarca@yz<vQlPM_pp*x^V*l(>h6Wu0W&mg_joXH^_kVjB4PwtB1K{Fjgq3&=#da
zlizhokj7D^dD<JkmBI_H;nZwbCDT~@sclp%pZfqUzZRaYbD$VVDkByjQ3AlM5Ng&(
zlBksqZ{RqEFIXZ7s2$uzwje|rb5yG0(Ycy_;P2bn+qn^Wy3*YAELAtXM*q>hl9VHf
zcG;o_hClFXwr5pCm=iO7=fAWn4#=AgUqB>@Hg%}6l7JxGPYTb~V8UJpQn8sr1CknU
z*`;ogxT5dN$B*sV9j2^k=9M^`JbfD+I=dv@DNn-3TaGV_s^v(Wn8s<z5a?=lL-$gN
zxezU<^U91Tw`bcg41)WXdrXmtr+cWh(r~^~d0WTaXG@Rf<M8^6WPk!;aXH{x-L}(Q
zCk!4OT+`x!77V(c2BW&vW@$x27)VF}I>;gm*HPYmw~VNw+GKln9rP`9UDEUbH4v&|
z894x<#TXg_@YFqk%vhv{g;(MA1e8g+&91t|L=jE{Q#eFSR#1w(jw^F>aB)>c*M9J-
ze-Vo`-ExN%IpEt>ojvG41ox{vUsna6bVEOR{R*0O>YDxT69TRZ!=vnSGz@#sIv0XI
z35INo45Nkz8&dxaC&qsQ8xVvh#pJF;w!j<C>W{1HELZG*+3T#Cnm8-W(Rx6kUrv<@
zm)ZX6i#9iUp>als8abOA-wO~Fx}dKCSKG`eDrEmp*<)@q3BMZv2yL&&VHtd0HKXo0
zW|SYke8dsh?-h!1pa9R&sRTfptfQP57dANHlVqRhrqgs=IT*r1N^pI4+Ey{j9j&2~
zD+M}LGgLcMp^q@uM(7?{GhA@oFLEZ!38rHpCQTAyPB%qN3^g?b0Whwg^kUGh%BI54
zlB1=wc!z}4l*r9#(T%Q@vP<&b+J<_Js125s71=2c5+AVUeYQnsmjLtom(SA_Kk+o~
za<roZ%Tgauqce4D)l5K-QG5WV+j3u@?c>$D1EB>mWJDaI1&q3o!gT&yV|adU8Ki*c
zz%jll!qF-eIV!=HC*M%B4DX^qHir9Iq3hP>f>2{pT8y(p;BiZnw^2(HgT%oHC92@P
zWoH5$;TP+NN#-R9%nyGU{>IjeJkZsws-(ou&*D})=(DrwAe5KF>z`FSaj3bl5f6+k
zl@3Q_+G_T${s3uTn~W&OhBr=M*ZK*kx9g_^uG-k<RB|Ve1*kWxgeKt-N@1|$7ZzKM
zthYtYmR-oFwdTun@FsvNQO1&uW++mnH$W%$=(ZxuN+K;}YJn1{tLlhO_#8I27<{4o
z0sknkQ{cQn!iq{v8V|mP8mbPfB`5)vYS~UFfg0!NsXi+Gl~BG(+h8Xe3cd>Z)e|_d
zwvbikDZSZ)uEOeP;^!K+A>Q|@y3;GVvaQQp&qw7&LIo2rSC4l$Jqm9+jvqol2b^bF
z1g-=wW&9*}Hh1tDtP_s=4UkTu{F5A-WYI~CxTu!(>?PG7)O{R+O?Ifp+->Y{Vf8_J
zSy%NUH>^odQcK9!Kb#)ug^#dagT)Qg@bgxyz7@&zDN1~$2&Nh%6RcH)D{fHL=(fl5
z*Wm})_fPU+7)kC~L}dYS#Ps7kh=Dbi(^+MP`LxdHsnk!Cqh%sYzisJPuq9E0;x`9q
zas}72CPf&RKTMUc-PXmAzAj1_U5`daawBjbqz-5sx77rAO3rkPrznEtQ1S!O@Zhmi
zS?pOsO`{z+$f4L|lOQVRfLxq!Z8`GPM~Pj_GS$4_`(F4_j^z;AZHXuxaeAmvX(FR2
z5<aR3O-0uQC6wD~(3j{05c^J*5Jis4X>c}G^rNDv>~f4&GLyC6ng)_2>DwLb9-aDB
zTX&02A%GZp`jln3o8L&n-j6Mlf}YN7kdTG&QHw~o^Xg_)5E8XpvKY|xvXLQjgl%@_
z@&yvR$SpOM@|ME|(qy$9bpwDXCf-B%!?{zePFl$yhS#5=#k}SDCrq^_$fjqTy&-F{
zpnZNF??>A<&smqYgH=QAy#Ge+c#sxy>GyI%wm18az`K&i0A0P7aawL;cNkGgnj}f7
z6lYQgj+>`pVeG1tw#L%u@(w*9$>wcZSTw)8K-@$1$7|*U$y9rP(>}BKC4qRp=@i~=
z5u=kD&Iis3N^Tr@4Oe^MqaNosXhZrqYfBh{XmDvaGGKeib|4>%4Aq)$0d|a)`tl;{
zxW@w$g><)Cn?xYy8oo{*je*)Lzi5ehvYU^9=~Bn?l8{LKmp&rEyGzZkFfVzE{d93Y
zynOiQXQw>1=*->GMkQKwUU6>7rak>H^qEG1MGP|3UaZv!_u!ErNLTp*N|U!xiJwwO
z(SEW+;q90R_xF@k_ts+DdT0ekK<arr?&ku})6P2FY^Fa*UL|*h#xpTGNNp#$eIg9Y
z;olJsDhnrdo<>y#w5KVnGZAASbw$LDe?r{vSQ@lb_hlm3E^O|?ouV*Er81=mAeNAw
zdR7y(uw{?6CCpH9L4^-X-cH%SN#{8CS{ZuNWx5ANq;Mz&<mv?8=n^can8!}7CgVIC
zg!~3)QZ<KMe3(^bA*6CFN9S1~1e0M8k1OQ9u75o1EcT2BZ$H{B9A>J1M7#2IO3i0*
z3A?&NCx;?>y|ol~*i6y|yMHSK_l=a^78(?YR^JT?LA>H`StMC6`a_6uWOvW`3fE@#
z9fKUX$S|N4HMN%TEogDd#@q_;r*z2;FkR6!1`<A#_Yq64a504ess9vX75$`Jg6D6*
zFC}C`cWAeQ=w6@YwJw<y2=(Jutqm>E&gvSL7S6$6o9f1M*gKQPWi^bn9O7ps%-ST%
z0lt43owK&^;Vx(6nt^j}_;5KFcRzrZAq5;<(2Y=33942vDzbW3Wpj7=?L%cvb*Y$Y
ziE&TCxvEi3n|cTjfLJ9-(K$cGueGoZB?U8SLs&vBsm+ICLEzO=DjX3Ti|cx{I8?>9
z_hap`=ZP)qWZ4-7g$UY3iGf@gE#Yt#Kh9gQpnP$9_c08WevY0`ht8D23XU;ek^4w9
zmn5rPW@RN%u*{WjX5uEh4e~y$<1p%iwo0iHK?47xvpIJUZko)b39r8gT|(jzdqA?-
zZ|oxBh_c|c0Rm}j$e<gj2<?~T##QQw-jaH-03^{;l{6tz=L^LPrUm}Q(TV>NBBO5U
zvTR9dlPkLICpoaz2XqH=101CmqR!$%@EdA6gcEg^fy;Y(^^G4x;Y>gh?;R>kFk8Cq
zhCB!=P3N|dPXH-dD#^b4mzUp!cmMkOk*rGj#akj|UkR44?_+r|2us!MAMHpxS{)@}
zTj%oB07Dud9EX<OG)Qn-5m2j&6!UUGsDPjfwP$Ha6L(FGD8;C>vmPQ-7;b<q-MTx%
z(V$AICrQi;bv_ul4rIIk9GMlyXo^3&KzL=LL{6QiD_KFhNX%)8bqSQrCw0@B$~8_#
zOGaedEeq%kZMe}G(O~^<PTV*QHMt~sev&6N@|JR()MvQ$+I4g}uwWk-?W{XybCL4;
zsRV4cIw`yl%{?^JtrQ~`aF-(gW(|XzjT&c{R)wq1!lKHh@~e@MLiw1N5sDf&d4h-8
zfvP9jqJ~6`b8uF-hfbQauYWLu9%uy0gM_;ok>@}^SsYV3J&`CdUA1BG&6S*n(#1nJ
zv};OlV6FhqE@ca+RI(oB_a5yD?fa44U<4Yjz?v5fSd*R1MD@XMu&KLDvH0g;Jjk_$
zRQ}n!x!|VFY=TJY*tx>TyI+AakT9D|!gvrefc7hvF=qcZmK`j+>f5~GQ4t4Z1Vxxz
z^emM(aZ8d1lCB^k4;&%f4|=h~hO>j)3zjo%N_T)r)Ti;u$)K`mYAOL72&^&V1>gN7
zeEauc3vbXvBryQqp#W@kmct*U40Ocj-$|mn6pZZ)W-Ch(z0?Gw5AmNM@}*u6ULD8*
z_>d!xGwz`ZQCwLKQW8*790itCuI9=1@)=0|zraxh1dj==G)~j6D}{7gL~3ig$R@QV
zDk%(5$tLTw?&ZpFITbNr&+E_9j*{S7cj`W54=~9~+uG{t%-`k5DDu4OVUE#O9LSUK
z=_hOfw~SJjNOkDz6<h8Fy8a%N##|(?8}GiY%A|ohOKgx7_|6V6xbIY!z`Z)Hx#$HE
z_xbdL@a`Y2Ijp+B2}zP}d%Y&<XlrF{%1D#!rnesXkMO&H;hAcC`Krru)iumq5uTwv
z@h<TKdnMBtLH;Bs)VcM%w~8F-0*7WN{?Ee8pH9XdONy6kR0|;HFvSK341@VjK&=2w
zHgo!0)rs7chvI55>G4?SVJ;`LIM73)F&J%5fdL_kYA-mn=1WxH6*DbQ@8$C^fO-xx
zws-QUpd(;-g@cryY*)BhTL6W~Se4~FRQtYn<tl{9tx=uZJJm__>fRoAjUKJ;SH8AN
zVznIjVt(b?V8`eRGsbPm!^(34WMLA=c^Y6rKG>Jjwc1qz0u4hw2<gLmFm-<SvzMQ}
z{0Y40pT7P&!D0#KfK<7xmaRKU@RHCnx2o<povN@rd=vh~-nn<aV*#CH+540F=kQo)
z(9KL1m2H_N?ZSmgk)zO5fiCS2Eumenu!gT%l`22mSR2Q)C7i1>@8)I-mQ<`=T9q_$
zDTF<O;)AYXE5|`oC-ql{BL(NWVx%%?qkC$Pt#v8xK2EPB0mR@i59ax6c3SK(hy^6d
zj^@d`3~G($p$4%*E$1R-*b$lNud9g6F4uM*rMi~d&sU;8<@HOTyU`|X8dnLEBhoS&
zh&+_EaM@klbXC%ry+r6nQ(V$kj(QO8;rYnc|Kjye{FBH*vyF#(#;4)?=~J}i{J@|D
zT7^=w(yA|<4FI0?jnGcwXvu7aylq?qkMoA;-l~k9l#Z)66;=m#%r==ZWZ=ZHQO14V
zu(J}DFSl7AIrl?ND#7d~iPZ`4App&3w`=szkDac?&;BKF&iaROa@x^RBgr({;2oW|
zUf!Yy`Mv-GS#*WIw?owB6J#7^$HM}QQ(M@>PO~7_2vfP7($D8VTR7_=pOz6RK$;?l
zPrri}$$2Aym$G?irUY_Rq<n(K>k^L7qg1EdVc;S4Fx%1z^Sm2d-AJ1E45k3;%@f*{
zay}AzEKoPI!t9MS3QNUk2)PPqKnC*-+-O$R`*1)PEtdqqC!TxD(DXSydq1W7EPb>>
zVZ^dzNLw%3MTKpN)cRR;7yWk5)ow=#Iu)<VCJ9{y!A*}qfb$T0koK0tMaxS9;CG|p
zwWZK<eX~{`K`gzii=gVNup`P-YYB5?Rhve{2!Z5S^$?V0@&gzzyK8WB>*H=8q;sL@
zzJ#;0(+1EZA$Jz7<m&K&=Sx<7KptWm_Ng(Ie*0la#!JF=IqGbt*DMtNHmf#%DF4_v
z#&+AM-gZp8filieK0OF2>BhHX8=3Z|DyvOh<NkCdHK@?bO_y^A7DK|^u(>;66)reE
zw_^2;P{m$PgWc^C+l>Cd?KB4(7li!X%YaKwCS@nDT1YJ>>yg>a0=Gcc@Yg-i#KFc`
z8)u}P1u-bgt%uZ%`fl4+m=8RTaOpJDp-5;|lZ&FBOwOk&3fujgB3QU>Q3?dWr8r}k
z!*yI8hJ*nvfFkvp8z<AjBpWa^sU$)5LMPg5W=#?fb3m-Q3^|k3r=7NgLUn^x&$*Rs
z+RJFX8#Ja>-fnKMTO8=m)8yuiWVH6to&lh`Yz|<a)e1Ckal;-!MS`VJe88~!5hiO$
zJ-c^^B#F#63(!IgN(#TSM{9@5UF$jApR?paNdxGTh~Xga7fwpPs6oP<n5C+aK-g#u
z*%E4%6v>hRvY$Z=yWq9z<#Y*G`FYsVQg>s-nG-M0qVJQuq#QR*t}YN`7D%_&Dz)9P
zND5C1N06vdYB^>PJO?saC=eK0PJa`A_*d!kqN7nd7MQgt@`{CtI+#m9s~X^aN#e${
znG8I+q{E>8r5Sf9HTPEfR2)EGNNc(uSOIY{dR)m>MrN)6&cxCx@nIy#zk&=ZscDEb
zUc*anD`!@3(WxJ|VO8zRjWhG`l(HB=84>sv@4`u%tNsGxfTHR>UKr31s?A*j3%#qp
zfDHuI)R#K|%x(yRWh-Vm?c!>4MT})>R5Y)!OD(fHB-)`VZq#7Sl>|6I-X<%xwp|Ok
zL~F*JlaQkwpOQ_GW&uh!@tOf67?p-31quolCt1ZQ@YEYRY2IppZhqFLNtRYUv#=!Q
zYEdY>`|-Cwwu$NUGZfG*x~-aEvl*>70ZI2%`%J)KjXd}uYSKO*QV*yEq|fpMtKHTK
zSE~wBt`wlTv<L`Iw@dl8xn~kCl8}QLQ(;w4lZEYXpynNDrk@E=;>34>XI|!-L)Zf{
zJo#58+13Kq0>m@aKF07&&=|}uwb}|dI8CbN3!WLExlGv$TGRt=mcD9qW{}mWwYiTX
zMaj<T%0RJ{NNlaK+YZgiybxT{W!+UkKJm6667Fd%3B4w}LDK=M@F0v8Rka^VsL!m6
ziHF{2kLEUv_Sye7{Iwl$hhqQ=RT4egOyPnm1=ki>`T%*+ID1fhXQi1tAXQMWGnrwC
zPpcCTd2>&(X%fwi$_1bSsmbZPe^D#c?OClt0Pjc%$N*YCmLA3=7&F?0J!$rx>Wc@_
zlJ27*<BX@RXwg;knDOqvhu38K2rf3nC6UrP@-ivSxgC1HhvhwM?37{fK9ho<9Nb(a
zqjN<C$m6h<h8&Zd+m=f0Oa{@{7XK@6)L=C8@{=T)B*B=EA3XwZLzs4voyqK0!x=KY
zMjB}ToCvEw*g}9g6y`&~Y7(j2C)3eU{XQiV!n|(f>^*`{uOss_doXg2l<3_pj@FVq
z)bi7+1pu;SwZG($)`Pw6+)cQELS6C<3Hodn1kpIv|M7q^d)ChE(VAYhJyzLB`Jk5E
zxr7V|s~>b_#!Xp;vT+I(8ayrfiBrT>xcI3j!!0$qQ~{|76UMqx5-bz&#!=(44suZ6
z;X<!&M-xRp$29n4b0-mvBw<=L)m~1>HcmFD30E78gP^e?7wQXBzV5~mDk{$=$LdOO
z+GHxn>7<>WSjp2QE=E0S92e7j6Sc%nj0V0^5coBgBO7p#Gl0@}*7&Z0qAhUUz2s?b
zg`{gyHA8V*)P&LcTM*G^WfsA+a&P8%Oniw4{7KrUEE;jUE@Q!?M+#~)#k_$zwGdwc
z9p1jTMV{_aPoH1ao@r;oZ^rI+#35EQ%n_VJxS+U`ttmB>4krC^j#PRC-i*N^LT}ev
zL=DJ*#4^OSQ=BErznV!9rc~{L04(dlDw<Fy*zdR|?Mv8Ll7p4_?sJ0Qd+ybTVMA$J
z*y58Seydc@7riv}LIx+9#Rbadcc)v)i$fAD*+aHvHf!wYy;;>*jgG4KnkcIB^Ru&o
zuKFQcRWpNQ^TPhK6!8vJa|`69Z<*z3Lq!5OOV}!@qQ)4mQPpUgR)V|gR$%0~sL=!Y
zH6`YHIH)t|3)IWZ=uK%~eIW3b<8VE|fA$fw<2q?^6+0M;X&GZLGOQ}K^&vlMJky!0
z2pNk{+f&*3>ClUJl~<IMxUr?PJ%t3H@{J-j$Jt(>mrdV1!ahi3terI(AMt>W0~f%4
zcjggmj|t0s#dbvK_YG582Hio@&iZzZBAl$v3gEZF7n1I(oglJtLM}NV2q8hp8o$Z7
z-0r3xk@Q)@8m0`xL@RVfA43lCpa$5(_`28@MwfLph{n{GV8Vp)ESK-Cl^Z7Er(K)X
zU}M)jhNlGSt)-4I|GAcvKoHkJXu;?!`3$sv7c*W6@Oy2BNYT)Rp`})?Y(msaRp#nN
z+KWn2G*hG{_`xOz*uu*NC7{=nFwX{*3R=yhjcovQuzb3O%n=i6v}p!CQgST(b$I#2
z4rN&$11aGvDAN(*p{g*BgR-5O8aA!o^_lH1xxCTs)1>aSZ0w;^45?V8AhJddn9&)@
zDLc$y91+yx1Ma$l9K0i=&!BR6jZ$}Y@{oftfx2cozNtbjgC`7la$0PuX^V}$p|7z}
z*t3d`78+Ce<`YAB+@=2nND0F(Cl(L9;;Q5dDHW8;l<t|FlxhIV(HPRusy#~}ce>40
z1@_Xt_^a@PAJ~nTB!s{bALuUGmih`7Y3I3eeca~?U`=aaBa#5Fz`())rt{v$P0>Qw
zg6M`L>7eexR<RCLg&q>modRhZ`|JPNJb7Fw!E_c<8y^)3a<0|QU)2P%#ehdvdc*P#
zz*1rmHh21pYAZ&psL7vCR89e%%k=k0Nps4PA{<gWQQ5ar#G_sHP<a<14zeI6b4Cp?
z=-{d31R3^rY|m_&qH<0Nm7f{)Qqoqle#-d5TWpmOoPI{L4ZKIkiP6yTJbEOWwk((k
zks!M}s4N!mO^k5UNK4-}<<fU>n!AjYPiQ3lu!mM0Ss_SR^2r2MY=WQ|F{@S;SlP{x
zv{f=2w+y(Tr|PC85EpDHj#mW9vJ<EC=i&7eUjr{6ynN;I06N9_HFW=9-#-XaFWdR7
zj1y9cu*5gp;VxEzPC5@bXiio0mb^7a;8=^Tl4l^n$jL?+BaA*dkHwC$3&bmtYXHw<
zGp<^fpgl#&0Lz@j|L{0CbUQ0s;Gewy48jVa^!-sD8X5w*G+4mwisU)Li~?e^Ft8na
zDf@h@*H}?5!Nqzbx}a+^i6Tnpx)q(|By3J9X-D@qW0GoY^2n0lsJhW4a?i)(RDH#e
zFBM^N%8+UX4leT7GpwOy2Ger3)}s&j7TE?GtQ5I?>IVzqa&plg4ISj6wWhfzJ(2?&
ztzOpD5+0XPpLK&Wd{%Qv7f6<Jhj-(l^6e0n*k&rlw}hghCYiGSevJ`F<=B~aI%8(<
zB~f~uFCVh7{eZ`t&$E|(ZjaE&Z^G;Q=<Ct^w2CXRuH$-O`&Jl|BIPN40uOfv@`2Et
zhJOq3uQhbEZOIJmphxUXboyiwEOi!~L?7>-$Is2iG3*W5Wkwrr3RRgTM1}V(yNBYx
zfha%M*_-MlYLixukekb_;yBurX~(P%wHuZ#Jz^y%hF0)O5x={uu=Gp}q4L#_+9Qr!
z3=5WNKb^k)`*7I!?<7=wgbW*RvGqx@Tyc&Ha}0;a)ok#1%W@<VL?J=5jw)ZctKzTO
znbiC$b}A0fzC0Co6q^g)9%fLT>YQ}!z!6ej`}*66qLaiPsw1QG71zKtNPTZAw#unC
z3J+Y?|2r*`X8KiVLt1L7&B`4BdVQ=WA4vPky}4#abq0`kncVJgR!+>|f@xA})$YYr
zAjhz8V5g>LUFkkP0J}LAa&|TK$Zp+Zu%29}_!G1XE5Fs}86BmNorY817wbR?#oH54
zH1$L`yeQAmvpXLZ&`q#M)7fhIU&DV+pC^<B*37N$l)GaOn;)-g)rw11D5!x2>VIv?
zCVIETJz)YlXZtC$43*DxhfNS5Yxet7i=MOEJK{@q)M(tyWuQUMdF42uH8Okp*x-ZP
zFm=P2%+HNjs-m~otUz!{5|R}Gr>q;)*ABpz<loxufZ9uDZ^NRQmGB7ARF^Rnc7qFd
zhI;~Vu=UdglkyeZP;^L?m>q3IC<$MMRFJ)paTpX9apx6cp)QMJ;ARPf=nAMyB~>r5
z`g_%LM1E!1_K&4XfMir@#vALrC5oIyZz&EuOu>#c0Ge?^;S^2h&Q@@IZ<E!vS!Zq^
zf%9gw0Xd+#dB99U@kL-E+i^asb`jD^+FG2cN8NVFD^gncqqlJ%8r;hz$&>U}WN!m{
zc=ESX$IKEan3hm*j1)>uUL1d;G7_pH5z?-)gBszt9RLktzr_z4eKu&iNyuiC2=AK>
zorgQxB9zG7(0sR{M3ynERP4%o(w#O7>;P_5DZ}2DJH8mLcu)6x7+UCQ<yPi1>74R@
zbDRA?HJ-wCF+5H+@Y(|az`o2ed$q@;oTJ>)D95?=BW?jozCNqWq@tlr(PY{ri2$1x
zi;<BQuwTh@3ZzkNb)kX_l&eTq#0<-gNBqmd7NDw&=pq{Dc1E*h969A%l(ko%06RJy
zPu2ze%&M7h{~_=T3&A{T=6ID2k~ZmCmE#RWa92~vxnf>h<>+;X{-=EzX#Bf80MY=O
z(F!dnRr`k=i2c;|UX~hz=Aa8CjB;+ELgt{-CFi>OMohaUKfnFXCfF7=W?wuJUC5{F
z;x?2QxiH?%zzw&cjiOk#(O&l39}~OvrJZz=3InoXj1jc%cT^fKBmY1<OK$&~?8jYb
z!urzShJ<L(v>s;krd9%xl25VHg#xkRa8Hw9-9fz0bR}TB^nUtx@?c7`Guk6I-r7=U
zp<3ndccX(j%6$k2M^f5G^npF?R)uXBIk?~@0W0maP_Jy>I~MVWwiJL8h1K-L@dH}l
z$(AhrZUYxlJN)FzY~QxB$K<UF3$X6eI#TfTDC<!JT2du1iaH;fMqM408VysL6~=ap
zEUO(}7bbQVUVeSry}Jy$Jwyy)HRL*geQ2coTH})h-O<E{kb0-k0nVX1e%YxA30oD&
zoGG9HEG)~Jgb;T#9r<qSPESw7rhypU5Mm@7Puop%7Tt%&P7mj&LWe-<H401_v^z!V
zU-|IYG)_(TSiX115in6Ub5D({O5wVpR;%XSq`0lF@%ipkd8E*GJ^@*EbQ`&jHzfWR
z!lXdOK%6LGm>_D*rjLXK?@6=r`W#kwNl0#)?(%Zp2tut1MM+a@_d<VPYH!Mr5$Acy
zQYd|ijQ_6GhWGeU*BVu(Wb804HUdY?Zh$&pvo-^wF4@#eSC41M7DMNDwSxCvXOx4S
zTesS=AaVvs6`4@SH`d>huqWi+x=?FR3hURev@dTjS?}OAcbwZ{6%NgIf)Y#Y+|2#6
z)7pfJ0zpzN$vJaC5zI;4n1S)2FM885HnQykz=*BTP!$$vo)S6%q_P^_T+~g($G~cV
zNQ_&QCAQ@~|Eut7vJxxKy2A_~1_#!APm(w!l^m2F(dlMTsxW1$9pKlz2`yhjHo~|{
zM3~?lu-0!Y_hYo=uWPee5k`is6hR#%Y)G;<WZZ8Ej0@lWi*$#vt_(wp=0ZcIepqfm
zxX!l0MdvgHWTu^fuC1>0UjO6eSL*z5sgK?%DMKg|e$q}kP@ABK5b27n6587MlN=Q>
z{v(pwo@-*5A8}VL5IJil#Bp;%D_*rw*b2WS@KXsu@Dh6M0)u>DcTZlx*~6_;1T7S7
znC361X~Z_6ju6~gX$yeCyWvSM3SmL!-fJDh-qeGv8VF3RM-&6#o-|pIkmsI5Q*drt
zX!Aaw56W8*xhPMQNwq>)-B}<29V2hEO1dvJ3YUDHc&=RudO{yW#hX#i?x(ho<Z|I-
zt{x)rCW!=HSETFK9CjDp3NXO1nXa5W7XvEBb!FDE2bL+&QMa4ElnHqXdKfgK$4-rp
zM?&nBLjK8HB~n<Gtm6@qd<&$7K{y>OhRp;AH&{Zo<7{hKmgUds?<&=r)XIaz=2a4+
z5n>DJ@@u%9%XQ6TnLpj<!K6%=F}q#e04j$|mmEhx8A^<7f={f%w5c|kD#?*>UMDrG
z&LVGE9^_B8Xj_1l`ixG@0%V~*bMoL2blyjMMRL~*8VO77jw|47q%bYNrj!<Q$OcK4
z$IMd0#dF2@=GZR#_Q(IxpW*-O2V}u`8HG6NEpol9jnaqU;B9k%h;=qwK8jH!^H97b
zAy6(+wFO48y6{#(ekOJkCer-edKq6ii4QsYno+Ju<gM6z_sQ!gfV+J9`ZKwOKwL(E
zK_U&Ta44yTf<=Z@+F=;lcp0P4<y(W}yQvS_D^g<~3X%?{J%(Gs=i_Uhu_SHdD7r*4
zCyZvP^nmu2-8%G1Y<#IUi=LUi`vqbun(FSg@eJc?DS6QQ30*et9m7?XL7^0Tnzj2g
z4oZC^eKY$YjXl%^j)2Ufwnf>@pnVWm1Ife0njPITu(pBX0;Q4c%;$m@W2vop8sw;K
zFUcYQ<K=ViMu~!xN@6<SJ0<Q!5-U(5-BqX`&F-WF)yie$O9IO-A7o=`hV4IAV8CV4
z;!UdXPK(|?Qtc(1)~N*R5Ne+Yu5<3eVXEd578w8eas$ekN*YLM!1U%D{@r)}3E%w-
zou)x>`7k|6@E54<*nLD>*?C82=$~hq_pYW9J;wZ&IT)sFhUB&FDb6u*tC3^cn$@9K
zX177As8Wx>mBd->A5BFrXu<d8(Wj&(G8%$jy`LRdLa@$p*2E4S6PQU;{|V1u7IbQ8
zy!+Si^5;|EK8MX>HM;03rfsc4FfNE)P~2JM)QFT9B)^hc(#gQ-+@PPhF<!mg=*eEo
z-Ynbc2=&r#+6f?y3ne1(Xuh^bqp~I2tcmO5om1Hu!1v1<Xy*X|ms|swNZW#jlFi*Z
znL0S4@D9Usgz4GldaVf-3DT96tgB?Z_9{}DS#1I1MQ~lPC~;J`o(3|D2oF3GIS!i<
zVr{?|#oe!1k6MOa>nkkUS5SE&`4RkH;cDg$c(<-ubp;geT;Dl@1!qJR#w~n@^+~;<
z;jxw|i5Mh)iiGx$xW<E?5I_>)fTAgZ{mH(50DGaw2!A816fvDB-2yru5Y{6@qYBni
z&>h|>bc;l#4aG;Trs&8~=?vhk0#eOM&75jq-yw(ap@N*!!nbpfk_zTSFabJ8XfHr*
zOC?VY1Jgb`;YDYK!{Q@6r5s&1T>F8TG8AQ~&IYM%-7d>&A`6<ElxprEN)WpS3O5Re
z=}F~7eN{x&uXgmDaqwl0+ewl57U*cSbPnek$PVjSys(vqEZrs|#4O#g4M4xLetkTX
z4F=lpU$m`JUUV9gOK?m()=bltoJ@kXWMH;az_mc0dsotBK8EWqW@*8BHIZRM$;dL_
zfE#{RV2}PC{8O?t`%pI{#_Zl$m1ydfOX4J^KhpM)2jd1f+IdTNM%~~76vLCIVuZ_5
zoCrz_yGek;l2JuXke|p)Kr2oS!LbZ5+Rb8_^g-Pa+*AAk7H}Tr=*QOiOsjB^lq3@&
z)?|?Cb5N3K?P8h*6k_QM^CX$+Lki1%<C!TjID;H!pyh2OC6C6mx58uv8W1lwDy1iY
zd|_->6Dq?riUI*M48ZD#k}0g8HkyM7^BXjY!QW#RA=^)-UR)Y_<jvCplyKd<x5cVE
z@Y@nZQJ-6AtdmFNq-Xicw;BQ)WHB3mmI;dF1=)J>bVUKk*R5ALCxJ^ty@L+sgHU8Q
zyF3aXl~K6OUe5b^%K-1&qjbF4`HtztD6oJI<#Q_w6+%<)0t)uv#73sRg=Hl(*uqQw
zwy;E|y&e1g3W^Fo_LW8bOG%bt*d76$XD_~8w(xA-y)lzM(Bg$MlHJO?S~6O|zmB;h
zK~zv`3`=#>z#x;1el>A}ZdTXo`8*$_8GeUJF<t*Yw@oms)jLKaav>)u7v;2Q>>=_~
zjK0j<s&U1E2Ta*rG)ZHIyDGXrozet&qP3ci`mnXN#Zrxpo)J+E47kXl#;2`x*|whW
zt8zu2<;$VCW5-AId7F*z521jb_<-0bQf_?aP4>webl0*`D`cbWIF093+lsEl3KtBN
zCv@}0*v+P~7~G{*`NQy63Dt6qwi6}UDcM9myF<0A|9Mspc^V1Rg<1;R(^fc$thp8H
zg?V{#WApnfJ<1fGRe{!oR&+|TcWB1-z&>gtGD3<&^^PWnUd_k{6SYB_k1=QZB;a>`
zFWsYC8z>*Mf{rrA^PxZ6R-+MM6lLxFS`6ls<C8kg9rZ!J0DQr|(2n#tsko+dkSE~j
zy@frXry)y57H0-w>YO#=q$IB^wgyaCQKY4@w?g-=8V9&;(1|(lik-^06ez<S$*O+D
zxLc)-On_EhF8_w%YJyMTj<7qMsrn%C_KHyP5f$VZ>0}^BK9kjhOZOR?+Owf@zh^|8
zyAJFuNUW$W9mAqF@}AJ$A&{4HA17I(-_0UwuFD;=0;*$WHJvVCR}KZXAAVkP^?j=X
z<6ED?6MWxXRJeAbzDlCz`lbt89z;WnD9M04oK@@kX6sn?uez+K=w6EX#z!rd<-9*N
z_b|=zM%5rielBoT8MqUjP$%)-R<E4KfXUYAyJ6C5)EHd-*4ahFtcG*>H2ScwCBC_t
z)%!1hOyMsazX1v8Ng3AOzpPwBra(YLcNF603dBmE7U_GftX5{Nz@`CWat5ksKIBt4
zf^4<|g@^&J&h~5<3ROZDU|Ev>3c<k-v_gqvt8D`y__?0Qsx6hQn%tuaB<ZOS+|FZI
zb{4tl)3Cz8eDIBE^Vi6SmTgHkn$A>*ZLy(Zf#}9r(!(Au1)(}u`uCWWPV+1No{T8@
z!gaBKWucC)GO#v~S|J_eH^913F3ucPt1Ys_G5?bd2Ib*>$Trow5t5E(IBl{pEOkwz
zpd=v2$JMTT1?f-aVA)#LG~UrdTe5Ga#!I-9ls$N?m(&KpA)dkrlG~vl^O>tYgq~`S
z<;^pKQi`D`UX+J}1;o}{rko@7JfeJxajQIS9@-MAI2MAh16lHfswvq>tuooH1_1^s
zwr-xi&s$VV-*YTc3$A(JXVxx=U)|~Z-w)saKBRWX4jC332pby6<2<uR@c{fJ%SKAs
z%H&y==-}r?f2TSUq^Z~gQJpoj&eW4FE#-v-BZ*Fm1aa7EG4A2wbfEQMmnL<B8k<wV
zGwC*wY>!!n)B<PZ&M<GWFo@0}=cTge*DPnTADmeRcN6a*b_z<(g|&+6MNgKwJCqnr
z0zI!GH#)k#H`r}<F8_7-Z}vXpNZ>%nkByoXd~=S|WMcwQrJm^(2$>ScG3kMMaOo~3
zd@t|&0KBuPb4Y~7&iPD6x1Ns9p?v@KPvPaa79J(u-_aMj1S&X4R4Wd+*<w3dIu&rc
zivu@>vLsJxz#Dh9&+A$h;j@{30BglwW_HgA6<&Y+KzoFMHK{|9if5iK^1J41Tu;#W
zfo9wc>_l6;8dlLcjtH$c%5p*u%*%oHLa~iCD1h9W<6vYhe!y4b*0`%OGEKQpri_$)
z9(P)Y6h}q|#9|jDw1wX$jiqz0w88wd9AgB$ra$yvhU^%8j^3P{RQbG*m<`S<iZADh
zRhIH~1M7J>S~8mk9LQqLrJbgl_78=`RIaK9mGXl`8Rkn6Bes<>r2K=xJ$d7%IWV>G
z1f<de2^wy6;A$cvQugLet`*Y?&5T&=NHQTSR*j_6;Oa`Hg_7DOcks}mUV@gKZC>=f
z8Fn#xw+#;m&dXS`!}ORHwe4_xrJC{d#Yo)v{on!^#6!j7({{UK<Rw)>>i}>V{79&S
zk<OVIN!1bWcQn#0<(Dv1qr|EhMPPeDe0opQ;WN70)+I(<u9eU*sFHyOV8ZABqd&uU
z|02C?J7a!tNAiaJ_=c>z-!Rvw=rP{V6n;WUCraoRPPSZKAQJn<A~f3f@_duk5OgeB
z$d{_$L%LzL8i9h@l*0Q6V&NP^ysCTeml!Q)#89spsE(RFs6qh^fDBc`%j+Mo6-zu|
z7v9WnxURAqgyccN$4RnMpJQ(;l84w3*kaY(liD-0Q+Dk}5M?FV_L=T91^VGBuT5oK
z=oGYgRaU~7&@c%G5wxp$#yA;l3{q17SL&b*HLH^&F|&gd5g5<R7H*;LU@arqN`09~
zDCv9i1~tpx9W+tSIOW;Z$-e{Cdi|?3={XVrK|sF0QkvZk)24lv4`f$8!T}*d;K@FF
zPX!(cQcrl=bMk2^74$jMj3J_A*Osn?T+7Ze8H@*5Y{!?Xz%2p57Wsdg3ObYrfy@cV
zLsA=)TcuMV$|Ia9&JiB8Fc0+xAVO5vXZUtwC<yaEWkoEPu&H9rJf2lZLRQ`qRHmHq
z6UnpX)anjw=SZ?2t0mi##Bn^SkOt;mpf)uodM&p)-S<n2G<7FDs->iaTs)BRgLXg<
z?S-oyS8A37gfpc0ZYi6#Uj&S8=ht94_2Vt8Dplbk@$e3qOLrRYX6T!?RFWCr>>#UG
zZ*G?{c}l;x9neXw@@~zfbOcy{X`w2J%?EbH`3Qq#?D^(3CGhEK5*qZLeZb4+&#pzI
z6{>?$Tgh^_cq+H&f-IZZt)xXxC-<f9&N&;9#p0liZB<hnZlL<HDAD`W47NmSHy|lh
z<HkD`M&zr9JB*byG{nv*D0Bjb^12k}Z`2zeO4dA(2($a<qA{<$5arc(g=FZF5b7?v
zcW1Q?XgK%I&?ulq<Kapx2d}=8pyQeeTm~erPiG*N|9Fb;F<prT^pj{s^1bhU&-hl4
znCW_w)&^7jTzD~ZKGjLzxU-#m-R^H7Me@U0%&F8v%3ir4JY`j9;Z>!fEhwP7dm7!K
zp_j#-nGhJ1tuWiTWAwJtE4hg0vllrXve^YpQVGc(BOZu!=<C<(8wH6_4PeB&pg(dx
zc^pOnm@=J3m4_kga%Nv<?MaCQqs1EPb$EWJo5SGK6I`&YGFy!oh?w`sp!}<JyjeF%
zDxj5zhh);|5-%D&tr48V+S-PjsV>ToRg4VN=&7UTTU;`u0vPDMJE%Tgc69j@00tfM
z?b$|kQYRVg@vOH`GFNSh1u9q|NKs7{FJ>#@JMu*sd)abV4W0Dvn`fdL>7)o8FIiCG
zy9l`de-Jt4PB9V|yr6d<1FZNBp!MrayxWnEs&X{YCy-!etsXf=JO8SLw;EKFW^1<8
z_cva!^3dHORI4Y;lUj()W!oiy4%HsUM)BngkoT^`^mL*B^70F4+9W(v$Hbs<t#AOi
z*tb@FGg%7M7`w2JpO0?FNMXs-8IYCOf~*%cnoCZ;K(^;B>W)Lm5S*jK*z~CAMwh2o
z_mir1^w#f@cx|o+9xvPymsSa}-nIE{y4;xlb_6&JkqPA#eOW181S>Xpe5)*(>~e|0
zm8s-BBm=o!Vn-)*K+kr0$%^ChZM~>KPnnM*D6asie%atk<271RiB9%99CqqlRZg6<
zDz4{aO+xH1!|TVVgK<O>kx3F9AjVBTsu<+POTv2TT+^={CrM%FTth>X$zm7`D0O;(
zo-=q)ocMyeS<_szE}>7pw6HpJT=$wLk&C-i1EyDH2l@uBJT+4sx5AsWkVHp<KT1w%
z@eb(?a?<;_A{)1rbw6m<U_`miE<q7?E$YrtH-`0{wJkzf9S#I?!7~YXbtarft2ry3
zslg@i3!19b7F?du+Kn`;hcd-M<~?Ocz|-L^Bn_n~!&$}2Xowcd*2~v$Cy@AwGR9Nr
zQz`>zZ^@};->Wxs+JSPy(|Ki*^fV8sQ$ivCXX0PTX}W^;e~uJE1vnQ+nB|63p0P_p
z8A}h7)EOG|=tbS9M&^bQk}9T$T{xV9W-3boGq`L%W6|a61s4poeMx-RJ3a{n%zJgn
zq$f1=dglVSASVopYU|tr#9hc5b&HLF4z^9mzm@DDO^pY%NL)fnK&($&OG)Bh>@&&t
zsw1P%7Nx?b9HfY}zeZ<aq0fsdUm*Eu%!}&3TEe2WQk`fG=@ToLJoTN9Ux)wbKODc-
zS9l5?=Mf`%yN8q!oL_K<NIQO%fwG$eB(j`aR%~h}Yh~7@PD+m0z0-7v0&3sDY^I`q
zF7(4?)hLtN_MhS*YZV|>hPhQ;Fgt@%zN}n~I;-s<u`GxCxBrmbnpMk?GHgl-H1$4-
z<R#=n*{d}Zc2z{GpM2kSc~}%Bu3Pkf|JxtGe$IQCzYhP=e>i?^YdgC4q@=PI{Vz2&
z9+E(X2YLyVRSLThgInD=80dOpGnT~GS26qCK33~Fm(W>@;JE7zO-H4sxyplNm1u{!
z(Xq;=aJ;N+AvI%z3UD@~#u1rr*JdlCtr+a~aZ}n6I;o@x4laM*x6MK3?%Az7FvzZ2
zh{zw!L6HhK-<`Vr@|0SC>Gv>C_aBjilVlU^uIC^G?4KN5%hkdUL>?%7!}2>;a!{=Y
zK*K$E-Z8l$_zdS6r?XbKncbi2a-~lOA5ue+?4z1CGlfYCY&yb|LVx0xUusLKThAF)
zWZW5fa+-U`ohAXMCM~6a#AHb?Ws8wwU&+<eAPIq~8xzWRLTN1Vvvpa~Ib6r3o~W&$
zlYVrFC2iS<q&1L_0yIc_m4}15C+|}?k|?$vyNOqD;_YaXkEH;|IWw*x>O`*vh?ti0
zn<MWBJfH#gwIehoE4GcHDFLre?+n)}!I6m6c4{Jst32!;FC%L)%*AD^SZF|P;0`6%
zdc^&yT4X5?i3oXiv6KprbpFveWU94k^7+{gJ3@n-V=uy?Y=^+!EuN_ze}x8^?chok
zIVB|kc0JK3rrG`dqB3~K@c<Y2`t<{L7E%U%8@cAs@UQU}APSO&rUq{m1(7khUe&Ee
zp8(CZ29~|C;hvQmQ31b_$Lu2n^dL^)8arvd7b82B(f9vayB~_W_eSpr#Lg%1BVdql
zf#ac$*|oQaFcyFJ>Fb|JdXP0G6}Z7JE)HsKM(uQRe@tK=XEyXD4e`sCb3(vLpvD<}
zh3t8A;Xr2<kgV*Qi`7pIdesJ<4D`xS_F}eWdHA(P3R2@N{+*Kn$_s{WlzJTl(YKB2
z#PA{;<W0JHi6CD{Em!gAES03Le<a;vB@(8A{)}lFM<CW6q}_CN?R8?A2(o1?Akf6D
z`vI(@eP)$#SO%#cwC85`tPR)GyZ;+bsH;l*P+eK}V}^rYkquEq4QGsXT~x6kt;bQ4
z1)SQdwCyVq=*0|FUv9F)*?7Bqouc~AmUqO}<6GRC?Eve8+<pl)cuw+ESj(R1MaNxB
zZhSYJs(_~Jd<ye)DwXt0wJ3GjrOdX9(I$5y_+#3rRU(ZNhV+)x{usmKIZ`k4GQL&J
z!k}|?-;9fkeSlWgwaG-7)3AUMb(^fyh;6*=kh7V_2Z1useJt7<LQzqB%AB2|<BKsp
zymh-fvwxM9kr1&-sPz4c$%|5Cai=9*ZJc>24{VRd?nX*qvUtUCA=xY0Ii>7qn+9G8
z_mYr*FO)i4LOucf%@o7_6kd`iiMlfEL@OdfbV*3|+;OEPSGljS0egQ#N!ih%rN*f&
zXSwghShrF^xF+7EUfvAo8>O|UA5<S!<&enPAqhc+F+yVk31E&n&HIp6D~s7IRU}!t
zZH605e}PtlJzSU0Mrb+Pu;K%>5PqKkL*Ef!)|8AI?-E&)_3+-EjMR-X)2Kjq=qnn}
zYjki%Bgd8m0XZ})n$wr#f+JB5m=fnYS;3M)ZnCZ=WoHWn>fKQfVPxnwFz-Odv&>oT
z%OxYN*C;XF*(o~ua%a~~!cB4(gbzu|h!|ia)KHF1Ni{{3BS2*`Zlr6=S!VJtfR5p*
z+)fQ7kuKvpD$3diUOLL?%zadfZF51K>N@xp>5s5(#0unj(w4~?I+DaK<<~@#Mx`TB
z{c=zm5MXe?NEx6ad$5#QHJ~gFS7UzJ?p#!)JjYZCf=X{$1kj-jktQmJx4)5ed1fOq
ziE;Q4V|_^Uu}z9RN1~adaB#DXi`UNU_MKIRJo|187xWd@OeexT(}o+ntdECwWOM>#
zZCYq(v@@lm-rL-0p#q#F$r2nIo1ceo|4}^><=`y9Z-uI<gDranATAIlqOOHJj|$pr
z&^LupLp*?Ej{_t*Lt4nkM%xZrQP@lDot(6ir7El0*=We?_}$wqisOrI(xS#*MF|xL
zC;A)eU}|C1DytaEobrW=%<4KiKCP#81lZ6}Ktoo8SP-9i4`ipQr1~Y^!bR44lg2Fv
zbMbO)0Q9i}ap53Zo34@%bkl|W7)e7N6)Z1g^vfYQ=Es#RP?cNgk2txr8j{l|fAF1u
z!gv3IUThg<VdIbl0MCkh^kY;54T?uWtgv-)5zvDyS`A5QTY|72yYZaJFmzGCU}R@Z
z{&RTwh23f%W!R&2B5nWW<)@^INcvqrt94U*(y@~^Wo_lQNiLnmFpR35)e2r>E;5Eg
zHr1Q;KzfZ`qR&L21TM14N%ES3mB{++O|>)~86CpH$rOfUu~rzDwa*vGqG8*)Jan&m
z2`<lk2&r999Y<)lDS<j-EjT%EWg|uEu)-nR>zK5TSPZUi+lQp$Owt%-c9CSQRIRv=
z4(kG8k{D2|4s=30b$gYh>ZH@bq#V_-uNMaUX+S{LY|-@0<gm$=3tErf>-svperb<Y
zzWe>lm+2vY=7#`=KSo|vV+3Zppd3Q6m8<~yPY+^hmFsV(DXO=FC5ckVlB*rG5o+g%
z0L{gH3H`?c({au((1EWQRcCbU(glU<1~lYCKI~NvEiYkZ>7ITh{{;De3jT0$HFv7k
zg?*LS-9gTDhw@fuJ?nCmwSQr&3LLH999mD1?orWuwg;AWEL>G-sljQbHl$7O<tZV{
zTDX~2k~-J9XemgN6)tr_8(8Ry-Yl42TvAM}kZnkkSyaiGW3}7fm*r-1#pw<zv1Hg;
z?nfZ()ji75c321&BX!<XKY@^9<p>blKG7V4%Jrh1Zfv*+VApCJY6s;`=RP;e>E4t^
z)~TWOdfJIbQluorRKmvdTU(1mb4o_-)*SE;+10oZ#J35p%-ik?2njvmYY7v7M<6C`
zchF<mF=~~AZJ$=hAlr1b2bei60=Yj!!*Q$}^we*tM<2D_@*5afA)4!Nc3#lNHqk$d
z-Ak`^G$T^0Wp4GvOWDIR^S=?8(bO}>!>+M*j_%R1>JZY~^>5quUzlI&y}kO8zpCOV
zCg-sNN<oS)S+=SlY6qf(&Q_VknNu{Wd;|oq=?$Uitc4b}l4b!8?v!C>@tV{bixtKl
zOXd-jVWS(sp)<K;cVmLSQ_vYFxeAC_-uSFkzd3z833?6Yd5!~(#j<L1Py$NYgsKz(
zTC7_LLm6b?FuXF~r*kHoUS%hjJ7jd{!`THi80Jh=QIxtxHzt1M&_ll}26Iv^s#LJ3
zSnW?=e*VAN-N@wLYlHzdM0aN2hkC5pg~rVINXhFoxAzufIy+7w_?U|%h$C;q>Z|pd
z+cweNbl^+!-o~1K>kCO3!-|g4f#r79ZjnU}NfhB}9NRpoj~I)N745NP7gYREo$F*E
z?Wox%O8*O_WS?7w^3sE{Ql#}jN{cG0oeuK9P-0h(u^mhOxVHCyCy7Qv2fcpV;~hl=
z8q|M^H<qIx&_VRE&vlYaIIY^Uo(#rqYac_5eh=4?a!x3Y!Su7VMC(6{KP6Wye2cGY
zI>{5cs@PzXE0^qE1)t<rOZtSinw$-Cm|S=|v>8TK`5dc=#lGl@x0s_4IdU#LH_)i6
zEPW$86fAU#4XyP9p*5)vtrwMnt$~G=XKXm$2(Zs@49wX(#-_)nIl+^9*$5p!qa&7~
z-7)!`P;Qvlg|3@>!O0uS_rU+Dk1!h$YE25~Cpb!FdCN@I1)5!gdPdIM+;B(wG!ebq
z)#Ygi;J2qXJVwvy1*Dj^woP|XIZ|5*%hKi4?w!Dd9tMN~ZT74P7B@pv&EMXQISM%@
zV4#dXv^9Id{xp5fy1Wc-p1FW3JO`?ep)YZXcU3E*tAsoV4C(f9yA76&DDWYzBozkQ
zm{Q`H+^MbRD%@y8POPp5bO?RN*E$vB%5JpAaad5bJEj`>bWhYsCqD+~Tq<<kDK3J<
znri`%$ELYTYXK~=b|xoui5{USfj0mO#BRPT3_xdrMZ>nXORrXVx%moMWDBo`=z+<}
z8%cl-Q)6F?Gdf8f6p<jNUaMjOQ`g(BE;~OWopP>0tE-7Cn!*k8ma-R}RHu5saAfPZ
zg#&BtmAcOGh+4~3T*$SL8C3+)LCp3n(ju{-Mm>mr*$`oY_-*HB59mC08Z==^a>Ej>
z;#PqlmkmrVl7dP4TE(3f0N%Z5(XmWx2cN)rcUuw^y8*N?#SVfh>k)V?LDu@`d$_66
z3`Sn@%1sS}1nP|@1pxH&oivU%ZFS&D58fSZ<-Xo)1?fOhls}@3&>tRL34R?+zf+4|
zM%q49P71K2bEq?juN|P9U{85)*{Z9P-y?_tD!O5tE!C5<TwF45f(oOY4YU@Mf@PrB
ztwo=zP6JuncZ7hVC18-QLQWCWMN$Q<GuRcAS4&xQ|KHcze?}?MNFjOCnG<IRniWIq
zBDxm996`5v_I5syk!J}6yVVdaU<D3|tt!X_8NnVY^TcU!3q+UF>uaSw?1xblraU=J
zNM&x#z#@|mB*V)V?j_A`B#74D^MP~M<b46{BevGReP6q-w&2ETJ&qmI)W$44<Zh5f
zgdVX;U^37Bt>O95^aLZMXq~6n(F4llAb#i{?2#RO8`HX%8w!017iexE6U~$xAdQAn
znX@NV?>>I{2)fEh0T#kg&z)6=Ns<~MYhLolrr!DbQ?yXzz)CQ_e|`OVkbnI`iN5r$
z2e4@-sjsLrc6m};DMM*O9Is5RAWI>7h%q|XsF9)w;6ZqESz6wPUPplpqQokXIL|1c
zF9-A4o*I;QWcLid|79QVP<^%Y6HFt9a8$=Qt}*eaw2PV#$TNIqG63J!fy_k^U2=;b
zEZma<ciDQLZ#q829JZv_0=zGBD!Yyghi}oH<}n2^wnEetX~o&Z8l`sN16poaGDQpL
zHC2Ro_lYc(*FQrS4k!;DczIG<xy4Kbft(X&!0c)zo2A?OpTggz%h+Z(C%8(CV(K^B
z!?N!((%}ZvTCn4=^ZBBWHaUZVaUf|*ZB^|=(Wj1gE|nbeQ`tZhKyj&D7|@lHiM)w`
zmZnYuCTX?JgvmW(@|xgX+!p8**H7g}5jQkA5iii<yQmZd+o0vq?+<xX)#9GXfo6=S
zo`6QR7x<H$jin=KKt8>4;L@rN2X3D#6nBcMt0!4H*L+y~_Vq(&&!3*3gB2EI@zzEj
z`mlD&$)o*1_UpTkm7z0b3B68=zm+NzW9Q9WDI!3U;_-jRjIxNAP_mn&te<2Pl?RGa
zG_S6b*oUb@att>=^9FXd5iritk|Jp2a-GPdD&*0_n3HU-2=i_TvahZFmJQWDl1TdU
zna(%id@4^2PcotmQdQuY<kmH0Mw^_{7O7%*l6-qtceVj*ua5kg`v?$p&ohL}R)zf?
zIk19%SzCQX0o{jM|Dmx6VGwg3Tqr9nQMI)9*j8sW!`;O-w-;3nAMFUa;oL)lW?>3=
zanD^lM_kEcvY>DSBq*2ZH%;s9j9QTtE=%z7v6hKxk2(g<Bx`@4URe+0JZ*x#Dq|_;
z$jd>5@r&1=zI7~LwnYc%u4aq4M2C@ioDk}AhS7tCP<I{B8Fb^S`%GKu11H!B0uEN~
zwkMR&Dz%X!M>1T{#WIjI|KGy@WNQwB4NPFs)>&P?G56p5x18llm5+$}F5xwQKMcyt
zR=q}+gL1<~QrcFL&(=5Z=*KXd)OuOF*7<id&x!j+NAha78cB|9BGWxg+YZufF7sO~
zDj{s`_n7%ca-Z)QD6<TVP?BbyJa)b>HmG*oTi=<LwtBT_^}sj6tU3KO9%`D)wFf&1
z*~aU$LtubMv#@dvZnvy08mI$Vz(EspgLa4yL2IATe2>k%uMSJ|^_ToJeD^O-$|u{I
ziK)F&x@QB_{32>UPI-JHxq(Vkp;qpJPg=l~_4RiLZhKa@t1jLNK#vXubHNfxeg_L5
z?|%0B%hzwhyI;Ki`P+XuEmff3*DSYwc2D)&1&Sl5J6KeNtWnMf$o_V*7Dxq^dD-et
z<pmU&eP&P-rJj-72-4++@F^*X<N=z#7L<zRFz<#vTndLgqld{b`n&M$kJFE~#JM6R
z^jZsSf3nm-S+fJU?IDp-)m3&r1wb{`@4$UVjx9*uF)($#)c8y;*FF$e-zy55Wm6xG
zF@4D*FZDErr=15-oDTxQ1^R3D>?N3>GMwKU5X~7?QrqW*3}s2jM@7=!Tt~>EM?;)T
zRY+Vi<a@REQW#LD3WYVp#hM$JsQQw|mD@&SQ#wggTB4b6=;Fe5JWx9+z$@3Zs({cO
z;cp&H-yKu`?X>Q&4w(<wOI7L}<Pe?E8C4uXy2ri44O5$%GdD;l%oI;Ua~!3ioWLq|
zd#Tyc8PGvf>q{WE?W_UxY9$orQFFd@gLRQ@<}%FcusESt|BvD2_ooq2*Y%gOFo+_Z
zRCb_#s>|)rWUJ5GsAN%v{J?^7(Pa{+S|(Hu3}xd%)u0vFqC$6hk^oA!Wk$bx{rvTd
zkp4(=nLhd5kf+`cAOiHMR-<0R?aey8-m9%*R@^RNVUC0kw4ZPP9?}w!vZr46l63U?
z1GHjuR&ke=4&f;!$z%Z?M7xY<%w#DPw&3;<F(<1HofFxTyse$?G?gi^!Q7nZ?nRu@
z*xxFLkyRr)Pt4(_n!Rm_O_$JEcP_EOxf?(M_ZH?Nx%Fu(eHuj5(Rfyf=;@IW{Ibw?
zz#3@93gK!~nHbsZfWcBEhgufuvZC4?iDH>I^}aE(>uRkWvMH6`1QQdCO0}D5Jeic2
zq@Q^}XHmzEbS<1ye~MMIeDc#9m9S!~Y?nS@cZf=+%-b)&y9CHClThB<fJ91E;tM6y
zhj`myDA6WiGAh+W?x7eL<!mc~A>G0md8+fWCtJzL(McZ4LM|mj!!36rT1RDFfs?Nh
zLK@`shve_4uRn!ao%|uEDH5$`6n0mYH?afU`|Nf$f5Suij|pdIC&?r77@cMLUfSD%
zu3dWu%j#Rb?Ax%j>l0{XC7HLv(pU8x=U{HodsyeGk(S8#y{0yf-A|$FdFCk%idw%R
z1!&==t;Ddi3v&R&J+}#(P!y%?$#E^HJ|ZE}ZsL2PRJYXtP%0-uYD>C8^-vx7(g#x)
z<d${L7(gYV;z3RG6tvTc7K4{~!8`gX@93xe(*i<OD9_La*gpv`-=yLz;~^%u&YiLr
z<ye-9g=r52xLb}Ubht|3!V@TK2CM*Bx!O;Xtu~U6RL~QcWE(u1*$5~-EC5co&5JbT
z#T3q2Mx?BVqA;=TIgC%%A57SjF?G729cC<d+a$IshuW=L`h%XjoU@R~C7FIpWpAx^
zmGK(cas2tQ<9H-3p-yeB3;RQPX7UWyEjuwN($%R0QVNgNcC4%c_9Ti>g?QxNQ8`>?
zb298~mS9aO{4**Ad**uYHI2!41DhQY&Ll#B!ZD)-)OeI%u63-g)m^7vIto}l64=5^
zN}3h6AyE+d1m)7f`RNbg%*Uq6D1&2;&u+lwmXrIvPy?c_P8V|1Fmqm%@yU>xfDN|9
z0b2~Y{Q_{Np)y(s-%1ryW)zGf<?TRK=feq_Q4si$6<^@2$n5%7xnTKIe(q3tEec7E
zz)FL~?3{bT4lc*OR$YU1aAEu(Db#F58sOK#We%mXKiggEYXy)f5Z?V|BmnH_Q^iws
zb~{RlqMlcRpaJB^FL9@V>gLisk`0?1M%t|#hK?h2jX3A-S2WZC7%T0Wjz@%%d5-x!
zMIy{~yhy?iE~Qs^xI;xNaT#+rDL?C{QBl2sBvCANZrZE~reZ9PsZGF@UK4IQrNWAR
zGrpeMU9BfQ2}AELu_OU>H3xM!t!wR<#_W5eR%g`tik2YMlp>RYC4mu$t5YMn(;bFM
zc~34|S;}_sEJ>GayI@Vfw;gL;c{sP4e7E5_-1USc2uV9ONlBfBb5!NUxx7eVrGS(U
zWEyI$1y?guwY5f;D<pTbBtxmdGFwxS6juvmYfH6yC^59jD+8K2+X$z$kc&H~Mk9}C
z)r;nK%p>GpIm$n(SNd6L(#MUidWUVs=U`|J{*oQYn0=pS1*V>`1wHW2XkA%CG{~!@
z{rBO^XTiSs%9c98>kEppf?G~knnd6~X6&7!Uu;E4evq9C<O-J+(g@B5N62W)qhdz#
zP#=$Q+&_kwFL*HBTIJEY>c<7=J&Y~byj%S;A=F7C-lWrfJHalSYMMzTwuQS~4kCtK
zcQ~M;gU_|{uCo^^5^2}QPQK=nhz>Ye6pTPP$I!@*F6{Cp4zU7-Qx{BS*3JH_iWWP@
zdQkZ_2t*8fWdB56$nN~;@}DFJ%?8l$&6S&666~`^sh=<phW4~APi+fASnQ25vw9QC
z3w710qO4WXj#F5u0IK}<vL);i!l70~T-t72M&#Ho6h2fe3<h*X(o3lB0L#hFwU3by
zJ`Sga6O3UztcS)N&3p2SV&?hTY6pp6JB*oe)-E)ZQDYXk6CAZ|01z?>RANsq&@#Ts
zzfx%m?gBhfJJR$?hNz;uQrwZmyBz(B{zNs~QNHX0+>d23n?j0R44Rzq7;bN}4Q%>>
zvi62`<)IAD5OsL=VL#@`kf5~<vU*xRxlTK*QsuOI(6by8*{xdLCxvb2v^^BNYmo_!
zRKUdhlaj6Fbza^N7|#K1({E&IKzWt{bQ!|D`Y?ZU*SBj#LT)@G;BAU=c7Wz%)Jhe^
z)7Bvmv-0w19BovX7?j+$>6G^3Mjbs6QngZzSxhdEHhHRHGWiFZo56yFLzXqWkCvzl
z3%aRE@W+vTN*<l3QM<o~7B9|Xgi|1uiCXqW+b@AWePl^*%bAWIvcE3uH7)3n7!LUt
zP{-H?Se3ee<INPR(qn0*Tq#U3IX&48DK$(Ey1K!VBN_m$%OPv&SG7-33C8l-yw3N&
z{YM?Qo4MOzkGBv7po>hG4Cv{~QL5j0`Wz#4Czur2a+r@q{fG522jmz~_Ag!bT?#A|
z?B$J`96*)$99`8q>m+piL?-(KElwB}OWZwU-rv_;gdh}h3NnVvX&hC<ky@U88!<4V
zSPsI#S-XP}6^2BbJtMGLU6x)?@+>xyH0oJkp^aow<0^Oh?w<5|H_}p<G!Y$UrGB&4
z&3X`swWFq>97zG_lC2E8P6x?z7{)G@)Gxoo(jTtwvbew{F?iFVQhOrnvfO6OXn2ZA
zy*MgZ7EePTA@vsI$<`|Rl1@~BSd$p2YXpocX>A|;sg+O*y(BroN;!GmHl*8!I>TF+
zEqUbT;%A}UGI+ugyMf!GN{`whpS0JPgs=E13WX56Jhe{Y9do-R<vGYS$YI*ZGks=T
zmpTY_HzMI1=x&qUP^Phh?OKRcMQ1G?kz4Hm(?{Qe50%`ri)hDl7@smA)vpgd6qm)q
z6kQHrV_flsL+Wt5Se+q7Q+LSTp*&s>+H-Rs$p;D$JFq2y7=NN4(HyqW%7#oj1)NNW
zjE~jQHmWa%e)m08!QZ?jRP-DHjXf2iCtUoQJqh@4hh`+a0pN#t0~4`I2v`<HVQEH{
zva)%1jSAPfLj%RG<hRUd6ipMfa@2%)IBB=bQkp1HP-0zqTMlig@cIYPK>aXoI>H~r
z*+83xmm*Q^c#Iuab8d@p89k>SeL^_Mxf;1^pO7G1kXL2dxuHll7n8)YMLkk3I6po(
zH4vw7(E?Srk-e?dWFVoqPgS~zOR7`iFb;cvPzi@V&|owB#rCHk^$;RklMXRuZl^k9
z=jGX_I|nK{yUwm>aKK_mMS9yE>XHw4T2sEun<Q~SdeKF)$OI%jO$gy!Z1rFhFRZ9m
z^^Pkx<R|0_DK3Hey~rVO0O?8o;|M5-64$C+Ew@6h4u!fUttzfd@-3vUb|hcTMsO!&
zUOm5wu&}WL@yU$e`~Z;v|8D?C77P2Zp@2gWlUG?y7YCVqT3Rq9w;^9WTvYu&%bFGn
z${X|yX}S@%RVZj){^XiC{&hHhW9LwpatQtIe-3}+n(BXk{Z+<sNZ{USzPM*baE%TV
z1=()n#T`PFtRWX#`@j;IiFkTOVLeWEk0b$13;&L?C0q^OJA3<8?nsMtP^yN4$bfln
z*Fy%R>ZNBIhDLDL>?Bfx3p%hjm4+@=!j-dfQ&wv0>QJfuHoT<V?5;LX*~JGcl2&ZQ
zd!U;34YLgWQi9X0I@8YL$t{Wtq0SAaj;XnZVvI{(QCX_|Aa#=A<CnTTTAI#sb0FNA
zmU2npXiu+kS?2S2(rKTPNBPolc`VrG$V6_;M)gt_Xwp6scIOUuF5wr5pQ-CC_1-W_
zddTJ@aAO%`j?>))SO`&zpw6GxJ(wzXgYL+gL{2z|Hld;)&IpDmx}d?FHuhRlC6(~7
zBL;!OmV)|@T8Fg?RYi!2s{0cidB7B47iZHi`SsMRfWFC%rynfTs*~jU>~>Id8rI74
z7&<O!%tj@#2d2PIq#JIMBPx|P<YEt{gd47WMC;SLe}cQ$KfiwZ?w{O-i0HE$XP5R7
z5+e_|3Qd}?<OK)ky{mVuA#-0pJw1Z;db-NuMYX{dJ`+K;i<chHeFPthEBoE200Wsa
zAa$9iz!nU6H6!Ulx-|PX%@yoQ5IoqiSyt!|FFdYmLj54uqC7(e!fsS94Z#eZ)`eM+
zCRQVBg8zphQfsoXIKvCZh@1AQT(*sM4Fp)gE9UVEPGJNE2NL&GxKHq1M*-;5%Xspp
zaiz0&{~g|mXp|l@qlmGE{VZNyMN?$=+2pJO9cXY!vgFjvhi}jyS|wJa*Eo?}B$WbB
zJ&epud0FC&LH?7Ix^EyD7^nS%=I%fbuMVdNss~%i==H~)Y`w@pFt?c5_7<f9r8xa4
zeD7~829RO#2<2&^lJR+TROz`*lLkO6vMwN8<I~ciOaRD`w#Ry43n5u*RUw+n7z>VE
zseFVA3DELKiaoo#c;LAWrX#9SL6mI`jQd69zAwB=9=!wm*;x36-5(UTpMigUHQa$N
zdXuPXP~YFi$70M50H{&y9AKsff+DqE(yhJbT(BD@8Wc%!@({V34c)-mAvyJuY-iHs
z=jG=pc57wtvabVx{l=E)fLZSZ0*4NkLCyz*j$<)EBGQja(ROgG%ie3?Bwyq{^??jK
zm0QH;y5k2~+HF&UH>j7b<H-hC`^*RE@m#CFk4`y3({{ea<Ts)pqS{11C;>GO+MZe_
zH3Fa$NAlf1#ii6f&g0TDKP}NdxFuw@Z8pb=0;w5xOv`Q94TAqIKb$YZ>nG{TRojE?
znW0h6!@M;G`++JvJloL^3z)7;r<pvU|1-S&Bw5nfM`|HWOuQQeWLyHM1E2-7pVstP
zBu|Kvh{3UMpm?BSCev*OT#+L#M@Y)OBgCQuEg^l~vWYW=!E6rl&>Vh*1h=5QaUVO!
zb@#~|slW;FkTB;u)G%bP8FWEg9;ZA)jDEmhHu<;{85cll=j?n@5}kIVjh|Ay?b%)t
zP$E!Fl$Q5mR7Em~t=YqQd_qvNrqeBYypWg<FL?Ad%@zsbX(nCBIu0ltMfhG?i2g)!
zk1mH|1U|N%eI(qJv8ByB>NBQfpdFrdf|8aWykF9F%%g;vjpg&BW@ouq9KBT?mE?RV
zBYGO@C>G0_YVqzA;|anVtc-if8xAm6<svkB?s%!6WCwu+pDmP1Vw<C?$mBII3BWHb
z)*P5i6*ybN(S;@Mn!lJ5>`GV)s=d}{0+6vdjn8@dGl2f(#8J>JT_?4Yb7b+Ue5F<k
z=Wb+d+S*bX+bG-9Qn|^gSWm3mI1h@D_#2{~O^T4koaB6J>Tzy>y<|ou>5186v!PKj
zO)zAzX{Jl@ncKEFohiVMKEZ(+a~*k*Ua&T?K-tw-Pmc-`Z?fDqOHB{1w-!bZBp#4<
zryCAJ^6yp#<f21DQH(Q{-et*cC~WQy{9K`5e3sBH`47U)&c0xG15U?~EGWZ1VHx&k
z<s_%iJeINrCWi>C4|GmHwO4NSykf5G2}9Ovs)r%%X|?W-6<x*9^xC@I2>@~NIm09X
z@Zq;J%oQYRKzO7d2{bDw740foSqYM6WS#2{JSHH!BtXFQwmzxTByZL{DwB?3B8*RI
z13l!<U-pfxJsX`2I|vC3gx*NLBW<jB*rG(VK^mZww?Gy74Py-{5?i9T)g{rRM^fTd
zFb(?q<m+_pGcXG7BVZ^=Kmecx%r-g50F-!isNEDDtI?Z4C=#eN4XNil*(&4W&NRvz
zNbe=_X>p5>a#vv!sT27Z2$UF}0|z@C@|4e^<qh{8=*%XsgV<L70l@gOo8wM464tCK
zIMXBqoUG`<9h$#~u$Al+EEYh<*2;(f`gh^K<O})w<wN(WNv{$XSq|v25jF16`?^O$
zPv!a%tx;z8w>A&xAeI%b5?P1nw3!}-Wyq>3TKJ{U&}LxRHG+>k$GZ*Tpg@|*ba5EQ
zHJ{9|vRn^}PhSRO4@}_PMz+^sNhMp1sT5R?h&zI!oqxC$I+;3Tl6~*Ag?^jiCsk2y
zCqfMR6alBTUSid^L$bo*d?(PlTKU-=xFf>5Y2@;7jgSR{6FY>U=6QIU6<rx6{pxoq
zg1WOrqs?kzuzj9Ubd{~|gSpniiSbms*Q@ucX%9b*N^I#UU=?NSS}||~o^DaB21;tV
zaV~(1F2J|{$ek#M+=wc&Ws3*~b!c@K@SfOtvql%{;P9gyB}TGeYuGoI50G7<f|V7C
ze(E+pj4ai^8q)JQBCFhp#T<7kPm4(EMi_jqK28VF+$eEMwdU@sD|~)9hVJzU?Kl?v
zCb?w~MjPF8vfP<4#||)VR4lGRpOQY*hm3BSpaa#go0BMd^?y8IEVSnZZKv{(H2*HV
z=?AK=kZUSJDS^CtNFR7QF@yH@94~CtJW^Xo^NHC@ZxukZzzg<1)x6pR_yE%t`9C|c
z>Lz8lb44Vx!2-VN?pS_F3`luyYMu<5egwxy%Hi-HD%lYptvF`;qxe{TPF_|7zKoND
zhGpfazLu*(Z$qbWSGE*TJZX(kN)}No>U-eEYdZ<$U@KUBXu}1O4aimxm~udu2L+RN
zKYjh#>sRvc4^VrkG@{Q<lh_G0E^&y?CNHAc;gEfDubA$sieRSqs94`Bhq8(6egbVF
zwp1iVnO)NWYG$%9ZSEL~PBneHteJ5>+fKP^WZrocoT<H5)qw9XeO3jHan2Tk-@N?f
zIO@sFdVE}_0<DC9PCHTK_>Q_$J${CdeXAA#5QR|oevf5KAWHpIDxF!f=(o=t0-q|x
zQWDGn)N;Yo8BI>JzR05LpnkzIM(gg3IO%o@o)n2)`+)wgr&*BsM#ItdUi*zS$WoP|
z0M}K04DFp#{z8GQ!F8)j6x)IBf<4GKmK1D(TJ(hM7U~xP)yKfGxCG9^o{M~H9~+kv
zT|Ay+G<<Zi`5OA2P|7d4^8a7P-mFQM<T?|3&tKsnB@;LrK<^+;<PRAm6pLp>RL0h^
zWLDGzZ3yUb9;CP7Jdxdv#?lQm8tBH-*v#ry|1X{I`1y{<B~2zZji_7qR%J#;xF0{u
zw`?P)TWzZCWa~cz`<N9>e-U0kmK9^lzLGPqE03WW@}xa_w;4t_Q+*QCgDjH;9+W(q
zJR<77&G_yUiFc-!{A?dxBa1=uw`nMsA~zxdwt&DL^?bla?%cvQW9=d3X%-LK04$Fv
zQ7++%Ar2=eZt~Gkx{JzzGF3nijW0O6m@bOP2Vp`;JSO|36J!iHH*J+R#eNKwX}E)d
z<>4r%KOv3)5SuVow1o@RxKUoka{?Tft3;LJCAf%jC>x%}y%kRBMsr>XNagC-;OYRG
zT;AiJ0`>#<(_N+4YLD)vp}d@n{Jbo;tIFjSuAEDEngZ$l1v+51_s|Ek?J<?f<432X
zeyl=M#<tX$;ogdhohMof7EqXiag}{XLrV#4zYnH%Id@@}JA&~$^lkXS<dP-zhhonq
ziM7Tx^#E6UHB3{1)yGv`i|0$7G^z=d081MKVoC5Gg{iTmkZp-ANT)P?2Uu7#1DBHn
zmV^i!`8HdK!Wz6kCGL`C{x%7Z)Uf#Wr7)@;R;U}rgh5KhY@IszpWqa&yFRNv7aqY_
z4y4@m@X3m7pAL9dD{Y%J4nEB=%2@17_~#5A8#0NgJ;Hud{z-ZWG2@mBZCN|taa2F7
zF6mTm63ZZ9KNQ;TesT0>Y&7%YLT%t3!uC~4f&E--sKs(jP3~PmqUB*{RIAIxHr7k)
zY87Z$Nj%uqlw_&)*(cQ%;Kw&q4@kz0S)mfM7A;UL+qF$ngM|m4In@(7$hBD=gKnp+
z{`%0q?QCGml9FZ#I`bKZs$GBL8pZ@-wC^m?A@$n>2{M}=#K7-Wddla`WV^ltqg5~a
z$mnWPCz4#H!TkZoAtklhr9|pfBL_64OT8ljc#*RKmHUwp)Ob<3KYf(6kL=l^TV%sL
z3a3Qbu%BHa$y4O$W?)Y40nApRVR!kv@W0y%qfqVu#ib5(ui^k<DUR;OVLx%JXk7_q
z2Pv|Oj2WGw8FppcY*Aq`Kx?9x)K3y_(JygZkgDjwvXQL~a1VJ-6~P*}bApihq|08y
zEy-rGlk0+k{lq$6?u^Gbz<Sis#J+|3m)x8W?8SJ7K!r*|GHgt20UU)>=y8sKIXPCm
zBP13KIf-c1R}2i4vgn@uHuP!@3OGKk#6gmk1n_=}WFK9I3}Q_}lz*{@GODDv>jey6
z95>qWO{BnrcN7Llsvrho|B*P05@G_jZ5QW^q#m6G_=aFK(8k*=8DnAU8P7AVC5(=t
zDA-4*Yd~-X%U8lo$1ngTENX$KM(~Y}$iSjA7pS45Xfe4`9o=$&VS1rsZUuCj?pNUq
zh$p~0RH}X`d>4LS{tNQ|3`&5wt#Xve&ILEY@}Ky;nb3fRY}hQ|rQ1D;m6Q3nd6IUI
z7$+ky<aJD@KGyHVKw`iSVpOLNcXoCyc3i;SMPr{lijHwjGL?xYW~lE~<-<^0Ak4ys
zmA&(gbVI9dCN5m`rEOzp6F2$in*|tLj5}Y}QFXEG;v@}+FqXyYhB3SV-(*w<OLZwm
zaOI!|Spj=~m%n<%Qt5>X97dAIoOE?7S7qNEAo1g%Pq$!H*HhDJWLv%L<ZW*U?kE);
z2A^`M^%tbR<WwdW^3?l&inF(TfWR{Hqg*=(CtUi9kvJf>G&#HhC3Bcv{WOd#1c;=h
zvx$3Epe`#aVu68BvuJ5PZ9Nc!%q8RU5~Y5+b4@ppBpN;QfA{mZ&t88QBvtyu+lO+5
zB!x_moZ98Ea`2j+zX64jg>ADmmFBu6D{e~e!0;=2mwryvgokJGQmh#b!YEOTf-br>
z78D`|*7)#sOd47@ma13`wV{~Dc@;7_q-q0tw~{K!Dw8W1i~!AwOI9e>>L7nRGi?P;
zYImi`t3=(#A`CqyI5&<i^Ej!I_X0_Ob%0J`@tYqQS;X8%c@S*sz~DMEJv+s?D|aSG
zz4~OgU8z&@tWeN|rlIOO>>N+cVVcF$y;aVnwb;#aMxvFXdzPC!p9J+ai<Bru&(qqi
zYr@I(ptE#X(XPWcFh;L4Me0;<W9~=>Z6=HZ`KbF$<u28WxTrA~-horL6XdhEpD`=H
zyKw>d8`1HiC2@*S;bkXdCrGh#uL4MtQfm3|&Hx)6WL-;PUdgSc64;%<o{6t0g(4(G
zGAHss8en|+mc$^Solc!n2{BR=L*Wg53kVTB>1;h&2RpvBxU&Z^z}xZW!D2<xG%*;=
zsv)3`RY;EIAVTNFbnxXrD3JXGOkq@?T6~79A>!6n0g2R~gd*Fi#U}^4-M9iZ442L`
z*-68!XWon5y&dazR5c{vIhka5J*pr+hq3H{vDj}y|H;%j!DiZAh7FaK0X;y9a7$^p
zYlgZe5e-d7+vJ<?0)k9RN(##_>7c4oEe&D^V4KxSz>>@?OJ#wk#IA3z=!T7>w?#()
zl);lQY(;G`XAPe@+)ePSLs^Yr-;l;0Ggw(x+c-T;^<5dx-b|JAH!lO`!w*GQMzvvq
zD6hrZMQ@C)%!Ml)&+N7*)HZ8Ulr53nszY9BPUgrKRHS-xO}U#+)S|_2QZp*&W<Gap
z#a3sE5rUKr)+R_m#|uD`OJ-Z5)8;dLm^2VmG?s+|!(HgSSTdyKNu6g-^VwgA*N@ZE
zfvYl$OchG^#yN4&eE}&OIVhp4aLb9}lw#Il*u;Lg7Qq=6Pg$r3{ZzW}yi6QxJ;L0m
zf+gndo2(c__Uv;psr=EUo`4*Ea?^%UNdpwJ%%WutHncSsRWHm_T)3je4ZV=frwh0@
zFFdmMK<cHOg4ML2(n)|&u1<*qma?}Fh8&SKUIu{3ZA(aYtFm?@AzEOTHDQ|R6X-A;
z;6iaGE!7c-73{nYvdmsQVGD6m7JCR4qa8Fsp=X5#U?!dzOD%u8_$(=8c2I&`O0h{8
z9u^xgWmYnx0!$aXxGYHnkkmd0%EKJf`<{wxfLBIT8CV{n+Wk^&zW)><N4?Gv3~aX3
zw<h-Ly{4o1g9E=nyw|ZKPl0M}P;xS7!_`fpLmV^R<O=Kr#`u;q>s`AYi}Fc(?-A~s
z`k5{)Mw3dQp8;`R-EOysH50c%H(urPHwfw*4s%twuF3{{65c*Rse{b1qy$#7%yT&T
z9I_=XB;zc{N!+oM=e4Gy>j_DYaqpn0Sn%r{^^b(rf)Hn)-n6)bVe%}opbD!wUX04%
z3(0wp)+x_;&<hY|lA&HNL+?;g*#lFF@aSD>a66<ZxKs#7i`zcPF&+Ne?j69JonIkD
zgJj$E-dK=lDV2iix>$7r`5HSvAR?QE`<r-*0<wr-cKT9`j5FGJ?c7@@ef{Q#oNIq<
zn{5I7Ru3vyYCuj|Q9_HgP{a(vHB}Yj@t1HK!2vH?EQjUmDP2d_{+HJ;<$pi3FbXz9
zsL4x@3Gd5b1Lhrp5d+LLa5TXUSYie#6)M7P=M}WGNMn$=UGnT%xIl4}rlqI}+AMe1
zY)Dv_VPYA(!ot?>X5t)2bUUtUbv{tq34#T3Nw+cUSZCCOLac6b$0S=RR|5oqBX%H-
zl!R&9m6^t&+sN6EEZtH<acM_6-ftOsLZdU&sqhx7Q&bHI-qWm3m$k8E8OGFZzzHLe
zma_w~*fBh$kGXDZUr&$XEb2H}O?*|J2tlb2_rgt<+ELjGZV#}iBQ~mCDm?T%ylCS<
zrUfb}xeZdi=xl@BH2K>*BRE(q8#9Fk5dMs?z9y-K^eJJ01nHwOVnB`l2pEU7FGg9^
zSdXZ*Yz8UCBC!zP(p3Ty($2BOR*={iCEUv0!Rc5MK&Vfi7NrS}Wmm{Fq(4wMdwz}t
zu{l{Gwh_L$1ZM(9o&F#n=#hirFJYcze*l+CGThED7GBqSvm|XLYeC5qr;Ut!0M(o<
z%3(rVz$h00W8CSnEa{M(D_yiB28JH1HThwivzcm#0{m6N+0yO<EJ1WY9vPos795)G
zK>k%s<sjLJL)fkkR=xd%(^B@|O1a+JNjSxrlUjM#m?PVI;@WS>&MLc9K9uxLPu!*U
zPA2Z0^id?|f%t8c%B-hpZ2?v=gjNJhAv=e`AVDq_at$XLokD7##p1&@_3`AFyhIS=
zt|vQnJ;*nS<-o1o4p{QY1DKjU`u+DDWS$5IgiDv4Km=DxmAsP_+8h*D1d}k_Vw@d^
zfK^RkZ-aAC;_q+6+pne8A>VFG@?<U!Tm;s_5)V)h8lirZLp5xBPg3lLqKo3JQghKy
zxIRCV2U<C9Xr?m=DJm$-nl$8m!1?a~gpO1p_v>Is3OL#9%LlEQm0c+!MgQW#7g*3$
zPUzs(9iV_!q{Ga&!ry$)9tyZ+8<M`KSizcllv>Z5KePJ5s0|;_o|dv~fQL}F42Vtz
z<H)Ac!M>9<So2Sqpxh0B*&)B|Y{ZiQU*$AV^JJt(hUzjCwXrywc&y;0)9L+z<P5$v
zrnG+38mpteZ;jd-bv%R*WUa!YY$FgkSeE|G3BaSvS@6<nD}c}k7c8R&xk(|vFNu8m
z3#skv;+jCY?Szs*_THJP4){HW5`&@<DsrP0d55IJ1@LJO3CMRuCJHhgogWW~F{Y!{
zibkW2=aY5=SMfdj$|&bvt6d6OGeIYLNAGBI^`VWvpH;V1`=CO{?56e#iui8$oBwR@
zS-662h0%*w%5ua;jzrpI!JIzS4!zX$8^;1xs3aB|j*C;u`^)h5Q(H!8zK2!WW@bY_
zxs?c1uy!qLQJ?Z)M#6p39vpZ5mA;dAmC1nydYa_1Nw5^1Ht7d!Jc)zqoI~A~&hTO@
zkUcJ%RV4@}x=s+Uq6tR>=$>YxmL3#xZ?o_e2KH{PhnwlS-MW`9><)!Kh(X7ec@tX+
z7=KFoT1V>|ReGYViltv~Y!?G&ZcqF_g}<`H4?L?ls6d+U@-+z;OmxabMC9}by49y8
z|K;0<{K{_Hhv}6ggyhsO80{VgPRRhehVEd1FoF?*p7TEHERlBvPZK8z&=#^xIf%j`
z3XN>qDtycS3-}*~h34#bs#qS%;42dGMw501g{fT6e#(&PupZ?#RMkadd(8;ZIn(Bz
zpe{G%d-JJU>jeV>YHP-80{)aI3(l$-v_Z^d%2hgH%E%=w2S7<w4rWEx)p++AEQCMA
zk<Oa{c*vDxG+<gW6B~{j01@_veW4IK+rOB<p);z|_v{OGjd~nn-rwnNfLf(SZ%fFZ
zfM<@X=;cP-EmS9mB4N(br4Fp39FlssEvhC1@@UPIyy|8OGe#{d8BRuRHrO$D1V;gk
z>K<}IcIA@`C=SMK%-fA<O2cF+`6W2%zIYTjq|g9WIO(-_O}hx_{|GTMz<C*HClp+2
zphLSA^^F=M1lQf^isA)D{{od-L_&-f-E?JK_aqK{Y3YRm&@jZ3_uO_%WN?EHRq#Sg
zfop%>QO|V<F$WQOXsv1o1^$bE20e;r8ZSHwid|gM(Ab@qJ)Lwl0I{`&Eg9PkEGd0>
zvn${PZi;+@>&cV^O<Ei=7gX}ubM=}xS_vBq9fH+_bbxN9Kq^P%Lh_to7?>C?#L`2|
zOg&~<5?uRT5wqZ;S=I;qc`kvQ2gX)gys{asXh(MOR_CrEV;x;bMqM1BM#}kx4#mGp
zG-No>7$g8}cB#D5BCOpOs8`RMZbh|B?LN4+`q;eKCKZ3S#=&pcLHLdBxc;7oXE0)%
z8VsE!8xA(`ek5_G&X1Pe#i^Ua?+rY}uyiuqZ>*KW<s1U2&T!WH;tjuNs3@a}=q8vm
z)q@mmnvZOde&e~fsrFiGp>9zC%qv61L~HY}Ng7_^@8r_Sl6bb~xlPZhgUP^pWE$eT
zpN4OKs9j?pOMyWLHA)s08)QRn9WoHxJ0#D+DcMO;$PHeU+o3Y#C)Hfpp6KSP(&E(9
zg9{QPZXsQCYYV%!LynL>wB|e^tEy8o8FtW~tKy#Lh?QDVkup`xXor+Ew<?BGjy^Ya
zTq5Q{r`bBN3e99cd}|%yaZN^x90f{AW?dZkPj}#g!aISJe_})s|0XFXR!-Tkb~aUz
zY4J&XrEELPu3mqNVqsFz;q(}v>_mfPZ3HJYS8H;J0j8LKa7V;$8BDNWxZ`@ov65}K
z-hlaaP`)Gswt*okHp2O;_X!K;e^wrK)q$(VgQG3$yMKL^3r-adI!)HNnjW%^(s2X-
z@u|mh?T9p5$i`9_uIK&e_JNp5yfc*7C11j=v4>U4b34cwk{yCcvP}po)pIDuoHf+4
zI^pzd<#rfddU1(;df=_>o|CwZ5-7T=gRc`*iP9sJx)DleWIL8X3J~H70XK-8AlBs8
z?Nv%3_wlh{^Akp$pYUrslreVNa;pv2TiPVCo*z2n>C<$1l3gz9Ys;a})hwa8jR0Ce
zrN0;T#@cdcuy8SNpm#AlEN$r`4YLutM)r}4ICY?Gz=-{gJo~bifr)~0BPxw9bj#>n
zkx<oeWGyfuJD}l}>R*h<p%!z?6FiA<%E@v-ed+5y>jz6D1Th6phLM6O4(7ZmTBDWs
zJOUjlYV~RxF1HhpwoEVziE_t57B3@Z2?Dqs7fbFZDbD&WiDbO&ghN$D5}`wOU&qTX
z{{{RH#?SoFKzg1ep54pqP<%v3+TqFp3Sc@ohrF75_vzbT!s{PZa2^A2d%EfFVn9Wy
zj~35Vu~7FeW{wi1wCv`=VJaMm&vwQjwINx4$;ws#7{32~$HS)eIjt6YP}_oenW%&e
z&m@2wi>0Nc^AK0eA>94&7HN#3ttX|Q5PgqNJrd9WYy-|JS;V<h|EFLkD04AGT-Swj
zAK>n(#AAQBqUpqWwghEZFnV8ZCsb<2FmUb4GXnT)TBv<(-oam+W$*!~OttB4C!}Nr
zGyy=wBmz#7W>*2sY=I=$d*Xd{sgQoj(~}0R22DD2s>Gb22AAJQJ(VgRr%wytOUFOm
zllatL^$6b#sH%WXNTS@WnB_eNoEr>vPG=tWO{ES^bvi5j+zUCx_5nvA>C|ZRciWEh
z7sDI1pBRvMtw1z@2xU-Q(ENb|cCy0fBoaIdhoEfj-sF+=P$5sm$~|V5U+?}U@F932
zy%cbs8I*(pWY-leO9w(!SU?rlogMa7g_;5&=(SKLGxdzXHvqDx#@(~J0<Q&`6?+bH
z4yJ{quwVU0{r<0mOFaGP^&>9QKfe9>JWg8aT7*sEj+~vJ9fNA@kOQpf`b7)#dcu~k
zCifkKY~y=uk++ZE_rZ~pZMx?{^fZ95<aP8`3@Ykdv=HBed1zlaBLcp~<P^p6#5x5=
zW(U74VqOr*+y^&oA(*favwfH{vk0c}0(q_;TyRk2#;l-z2XPCk&ZIZ#Nc&`-4dp%q
z6k);%T!4C_ruV~h21q&?qx-FiD%H#cL6Zo4M5qlHPAMJb{0T2R-jS;9nzNTqhC-cu
zSqV%WqWs$eFgdvK-V!SGDPagLdGM+zXR-sU@N$^3+o23eAgh*Sk7GesKI#i%Z-=T1
z2udZ_CGn{-!?z>E^9r9A>p)w|BNDV^hw~wIyAwUs+lW1Dyu~$}-BsFzx+zq6!A#g~
zU27DA$EvOJox8xt+^!%i!P~@xJ2|P{(j3r9XmBc=*1ExvQGH0=$g^2dEm)g987h15
zNqyje;I4*#l)_7hVyGq>>^Uy#2WJUGjStdC=Vd;$&SL$#YR2AB-xH@WJ?}ApUQFa|
z1Fo!rJP%^VfB=dihg}+$M)!RAK<aPhGuqN#LL<pb1QuNX2BxS6iLX!#PHOPdB5!Hb
zM`yF+P~xNuMK*hZws-O5r1`M|EU>$?2T^P)xUX_(+aiC!y+KPt&Tm;!TA|zuOB%1c
zUEX`K;q~L!kCFx}PdsoNEl2`&OlKZ=UmJ*R&|{#@c%IU{BxGCM>5raWqiZ6%(j>N8
z$bz2L<Af1L<z3PbDklQ)?~X+?nij@8$H8#p0+>#`-j(j033Qi9Cs<g?##XW7k~`4s
zXOY8q3eRdHMm+*FSY_jNBm8lZWaD?5<fJxG*$E5X1K^e?<NK<<R%}=y5KU^g37Y@<
zo+|eA42!T1aL$%I7!<yM=44%ZtVKuAM>PBB#W8kl^eLR`?dR%}^fhh@a1ONO#W`~6
zQCrb;0tsLh(OOYL3v-FPoOBXiMiSyvztQ`I(4p<rONBQ<c3(Z|6^&U$Q3q`<Un1-E
zq>WVo-M;tg6pkTC!PriP|KY%1Kq^MX1{lB(w!6E!n>>DaSBHa!pFrhU0n^3+as^h%
zm84|_al^zZdzy~uB!e3tD$K=^!<<vrH#Hvqvt_yc$;MH_Qm^3n2t3Q4_048g;vGrF
zc=nDX>W|*;9%wG~ZYw+$yPibKqq1{a=2UWo-PF~`ST?<aAa&$#g$|w}6!<;ZS(tuA
zjsUc4S6pO`8EN&Pc09VskSm8QX{GE+Q|^-mlF-O4A3Fev7<+B1hRX-ifOMG4+N?D%
zkN1h<n3#S)=bQVR@b-)J_j8apt&%;WLs)5Lta)eeR7<37Qs+zV2+F2HT1!IJ<(efJ
zNm`eiN9&YyKFOJfD8j)&Hg_t{Z5V~CU0gD-82!)KG9#K*P=2xdCH0tOW^&MN%DjEh
zKBwuj#mA~hqI!usVWm3VQy8Bt%mElcuvbGd@UvRuptf3ajo5vp)(l-DkYMBoW2@V>
za7;mVM*i=wzgMmC#wSx~V*pn$F*vlrxkey9k^7GIN<s_UQ0uNLG2j&uh%n*UA!Y+m
z3nq4eR@zU&et^gYwHVS-pj>!1xxo}OX<QA#fdG;iS?2+0>(SMA{tyiOEhn5|WxBA-
zE<|Uzb%h{I<3Y3Gd~Ay<&Meu~+`|q<4u^qbMRkE{reySHFoX_h84F5roeL?Tz6fS9
z{ep7pk7zWw(AWy7>fkF^i4KOXt;`Wjmi}{hlJUI*%*h98zCUzkM`o;DP^mHUB)=^d
z2;)o_%w!a1O>3;71Jc0)ru+yay8Nu_9rWmk$JzP8$K?IO*uAjOk<cB~FboZ4sHoj|
zHESiw8+ZqVlr1M6i&-JBH#^72!ZE_C@s?IZNB`mf3+&mglv7cHEDvY}%E0t=EHcr0
zsZeEj`ylCta;>f)GxW&OE)Ptl!5+dh$CLSu9=q^0)bz&_D^yC*#p`%O_o4tVsNigD
z1MF*3vXZqd<t-#vU@uSuLAUfuOOrD-LX~+;XfY`-Yp_b$y)6dW?7=d~b<pD4Kr~Rf
z!|>GJHThNTi?!g;?izJ$HPJ>7$IOwag$0o{dg>b1L~}3Oqq+06#*;P^s4420m);Vt
zp0-fkKc$Cm`gE0=q?aPydk4h~zul!fXD+Gyv-6%QDZx;kCZr3L1KC1&lFzhN+-p#7
z;j!Gg521!h3S65L^_?MIu6JgGObu}OPtZS7<-FAvQYcK@4I;8H1fh(F!<$BQ|NR3K
zjjx*V_JPtsAmPKXZ;CuGTMM+p?Un+)XX2Dnx_|-fCk~FkeEv1l3BX!+oTo{xN!Hd}
zAnj@B&wLB2bMQE|c2rD*Bk>x#DU*ur+3i!Yr9}UvL<-dLqSt@Ly6$e=ShyF4r0a1*
z@|&!9Eh`7aMrup#INmIUFhz8qJtbIC=k&Bedn*@RmfGG&=g*_|@59>{muD9%ks9(Q
z)d|MnHR0vR2PNp(5^dzubEFR-#*RtooTg;NhHo9_SXK!^82h{5wMTrDb7bd}g$rM#
zumK>Zgyloxl@ezV452yobh6UGVtA5GuJQ%1zfAYyq4rg*_1D}gT2!k)Ep$kvf+7le
z>2xhx-g^IUfE4-D<*8FGj4Jt+WhnLA@3SDdf5W3q*<%Hd4#)yd&nlL&!2+$j$-kEr
ztm<R8f~RT64k*sR)qpn|E#W{-b~1qb1q5~RYE^sbcM6ywN410*k{AGPqn()bK*|Y7
zrT-kh%||?U7wCVoMK*$N40?2wxLTip_S=-F{<;zAyew-DC{xcAZosCufF4cW?|PA{
zyw`a@oqb^9r*h?opYE`D4C_h15yG@mkX_X&S6-%y>_=j_Bnk3k^(6obL-utBx7U79
zHsGNfqiiMOtx8X{$kL;T=_ih^YAo}#&a@?E^T4&zOwSbpN5BwOtd0Z#6*0u#bTrPE
z(wd5fsYt=5g7ov~=Bw9T-BE1DA)imuhaNaH(%n@mdh}l48b8SHI}&c@VW+?Ws<qpp
zVVHh7Xr^(T0|+%`$)C{5GiJ90=CqX|brB`SlVc_3U3J9>)LLp$D(LI`elo?Fh98b^
z@S_jL00sBS@4{=cn+N8@)zvW01JZ0G$E-nmB#E2TEwyRtVO{p%BEdm1v&{ppB-Zq3
zk|hi;`UALd+a<{w2I?>U9LlcoFf8U7Wr)L5b?RK>NYg<sr)g1Cg{xscTB8TbCH8lS
z1w8;>@h}d0%gaR@CHDHgPV7CGMm4D2&$ND^H--T+Ni>DePr5-xo?Tqc<aKN*UagS=
zRJ=1>WwSUHf1<vFtcgBR_=3Z3fwVf*m5+^?b`Om!a7CoLmqanv=V0*=Kpq|0TxF#)
zEwXe+d9An1pJ0}wzK(gPLJx}yWLcmC(0<FI_fh-mwDkt_;vSh+4j}zuvINBvwh>@D
zbC~R8dbuU4&~250$#A)~u5v$Nh~V~d+~V*vbff~z%q;nnrPkF%PN9F?6N99%sO`iC
zg6X?#!z)@G>Ajw8J^%f;!ry-jqWrRNb4b<h?mVM;3a`*ax%=?)Px4>D|Hzi9ou&($
z8A<$~_EpE)jzp3aN6|8b?*BKMV?9jo#kyXSkbspGZX*ctQ1-d@4$J_vg2?{K$~x%7
z6G|=bY+Zi%8;wMe*3({QJ0P7=Np2xeucvHNQ<RH3^l~?ad6$#tmgnwk>?K8Uvb?rG
zc7O@Ae9A1_o2sZh+a}{WQ!(zw%^H&15+A!Pl6j(C7WCw79qG!2<EO>s)KiDe0pwiZ
zJK-Embpgl#^IEn*v(MH^d{F?Z5$-gGTBAJqu2|er_p#1Lg?n{&Y-6p^qXpq2EyipN
zkM2@+clg4;oC2?rzvVA%P%@R^k;{%9l!9T;5i0PWWBkwIdme<dd8=tU;5UIf(BzOg
zakY3kS1EKUEd{AjF@bVC{4Z!0`L%uhoe|8`#0sIrG^4?yv!~P&JyOO1!4oQQ0ZgKr
zR*xH+H8qDOi^aNkKMdde^W_nSbOW~si>kJ}7xW!PU3R^cI2-e@K+akF=fo$AfUl2@
z>bmK~KxMEcBd~_T1JY?s%%8)94^~bQ31C(O6yE5CUY?6tPUBh36tKgvy4z*ybVHWF
zjm_}9Rn0b4fSrfb8z6%n@p`g%=IKP@dH3n-=dXVZ?|%OFwH>hch=YEahTKTpD5wL`
ze-}f7K;Q;wt&MBrZnyww*_9O4gpD~)u9=8Gb^4fTtTmsQF}e%0koAO3xa`(tFzWK#
zujI+ef(F$;?cy2^M`=uICHWPtOeBG76yc&9#(g&Gg~TmY2`)MlBaz$0%#yD(Ozzrv
z?US&m2^~Xh4$Fc2^9E^C$vh4Es{U%|jWfvKBs7<rjZ5yg9)avxDQj0cpe(zj>}>%z
zIy+Jv<b++6`3Obn97@S#FiJqJLsC8@L7<Qp5j9!=p|-V$)7KJhPhuCv)v5zoyAW4!
zb=$(iBxLLM9G|h(JZEke2$2B7o1sn-`5Xzkn4wvIUX!F#P6;a$uDePT5FvLB56biV
z<Wo)E;KE~(e^fN|kbCZ4^8sp?p)zQN%ON7gJ2+-6mXm(Wm6J%VT8Mf9n#0ZhLfavl
z$-nlOCS>y&^=wu-B%9<<6$G-@lLfUTdT<)Z-Mq=AP?TnnkqB44nvz4zsPKwYgszqO
z4c{8H5N3mNb<0T_&Xk=$r4`1f=)(>>rWI&;dwfl2`PyZkwd7<HG+bb|a3u9{GMZji
zngJ||L~=9{91_;TNA_|+j$nI1qF(O9PP0mIKzkx4B(n#3q*F>A@n@hkH?8&05^!UI
zm4lL{FDi$z0L>qvCD=}`S_BFEDmenyoxNQdx9mTKLSDA}iKi>OiznSs?lrplPU5t=
zKy!q7J<NWL^rHg+nl<WN?Bv<5Evb%7!kc!F0Hg=Xjq+Q4Y*hJo(R5C7FFT^v#I8UC
z#xoGOufhD(HW~PGc#4>uRz>MOgGxO_PR196wAR3$qdtx3(IO$0?4C?)075A+sBOdz
z#f#Tj5CXqqhHh<Yr9mhmHofT`qdMBOt~1cPBoSe;*Q~(7=#__qy1;mP5M_x&^0Mo4
z*L-}>-z4^DKS)Vne@uyr@}%!6#c#`g=89tu-SI4e;Nz+2j&aaJBZTkoX{h#s^4At0
zj`tlOs7|UtoGrCWJiu0&*472(eH;f9<NK87eoBe4KR-dK-)ed^twt#Ljp%2{fll->
z;5fk4=cuws9xr)x0v{@*%~H&EIOLeMoj<t>WZB)oL~_$dFMmUoK~7Q`<b!6HD7~*F
zktv}Hjm*h&o09b|4#kI$D2lO07ivYrI^BsxOnS7FdN98J4F3x#E51?XWSjKisk~4^
z6~3MsErq~llev_bE?Mc}-47+2^?C8+JREKRj#bS2c8JONY}!<l+y$&z#wH=3BI$yv
z00_$e9WeF>Bb}_8j;a?X!29}@${P%*tP@HWq#7jkmttNNzd>B#W9qMo=D-`QD#X*(
zZtfCzu)xUNp`>s|4J3X6j?oc@51TwyN3y%pcIYX>TmD)}jI#scQ5n#qFCOSo!4c0{
zN{p2ds*LG%SN`(?6w4r)swA+c7F@?`cb@OJs?WMmgmwbI`U0d6GZ&=<OBEgKG&)Yi
zg7iLEO*@_jvOhrce8T<@DO$D%>V@=S6<dCx$Fr14-Y-<xtu{WDG`=ZLd{sya*fI`h
zzB!TkL1j-Pt)U4|#{ryP3zRag)>7{`?^8i0#wcwT0+H8Ts$e6@awm|zNZ4g0=(1{&
zB|sd?K8uy?k|(Giqt#9K*k~`ufJQ*Vw|wY4Ddbu*hqZ*I4)A27w|o#zY)}MBU~Yox
zY}rbwFJAwwj#h7<V}$zl;i;XR=EXFrQGGDUQmSG`30Y5<5l3FFZB%F~WYQPBU(B=v
zR+>8fH<JUy-4F{l7kVYokZ+<2e7n;epmU0t<unmc8gAyrTaY(71CfcD;tc3qY%a)p
zIo9oQoPd602i*Y$<(h$vIK^BfLIUHI4ug|Wk3w8t<VNC*v-Ua=^N@IDn@SG-YLXQ3
zfHDH)hEko-=sbpPB~?7Lr+_A*Kdq>O%ITHEqf*ai;K6KDJ{1^>RTzf2NJpvWM~akG
zh}8oY6zTI#C;5x_0-yR}_8?|u7cIH+mzPUR<cB0+06S6<BGwpD{W};Y2su}m+Ua`)
zii5aEq;*n?^mab<dzODIl6v$tG?jHDR41^JYq3x;s|gk>$f;r-<T{<%DFnR;icpkY
zQx=LYj}w0)s%@w}{nxMGL)IemuqohLsN``c_vXPy{V*l0h@Y2Gl2;*Uz$*?o6_6d*
zLsf#)t1(bwYWK%<jphS_hSn9?fICYhPQ)YfnA(sdt5K;#jnvON(kT#GMb>hXbaL9V
zO!m-$#+TJf28eC4;DkD5-4SS5$*!zC+TfsHz{hc99I(g~eSA@{eM`M=ZD={AYz;%H
zDf*Qtmv{d|r$kXXUk<PYT7{T~+cX>O>ZbN>c<p(1aU0dgaABlRFRAKqsd<U|yBu6f
zgr}zS3tG@nVc;02hY|aB4(tl}HzlN<;Bf8A?6x&I{sr<CP^cO_sX{^xklO^AcGgA1
z$iJwQguKppM#z{h`-|QA<m=n)XVj)vf>RIO#NDh{l48j`#cerw?^i}MRp4pa>FcLa
z;mb<_HK_C)7q_a#LUIe4&bhGtiJ2D_*4OgMmEi;6q*zytNQ9QB-O4vf$=@6Ny?ueB
zN75#s>w7jifH|us)l8H3q*~Q&_YM`B+*DnTtJ>G6cQe6ou1@u<Cq|q7p-QVk+bP}I
zF7S`x^~d?Uuj#Y(wFy?Pd#RKi9?c_woXU{M2wJ7DURm1G#_<I*35I}>l0?#m5uuL2
zO6C4w4bFB;gBwiWi&W0J?mD)4cbVqIUFO(FufjRbeK$<|>RsjTCG1wOD6T9Cn%OBL
zXJ!u(LF>|Pux*))_W^Q&9f0U65hb_oSl<hovu>|47gd_7rN;%7+#w$h<seBQofCRM
z)HpdZhLv5fWNzy745?c7@L0Odr{8jlOp-NbvV2dK26;RtxzxHqBiaRo$8N=;AdC}K
z4>J(OH%(d89b!Y%vwc^E=0L)Y!L4N6kbprs|8uD_lC|UqF7P=K|0yYH<2FWRf=vLF
zW6cc7RPm@h$zl|S%JSmV`f!^rH}$RLq~}CdFICg7vA|m*oU9Xu7Yy1iHn9{lkAHJD
zlh-_OIJY?D(I;Nds)VC9k^D3+`7gTcFr%$#ktZ)>lF+J|(e%_SLdC;ymg;N8uI&hC
zP(;ekuPb&=WE58QKUtcn=D{ViZVbfqP87l-yVoUgFB9d4%z39~c0iU;#zsk(q!Y<8
zm~fFwFjlFdk+{U6Vgn^SO})y#U^dsE!5J`YwSY~Gg`Aud;khlS6?Lq%uT8$M9ztm^
z|C7xU9?AgcAZ#zS64P(s5K|*NF+_2o=MQFezP+nZS_5gDa$de*w&UtvT#9pN`67_@
zMAM;ZUUsBpDz6P}SC05cgN<X-UiO8SfuT&&m!UdyM}HY!e<4Bl8Da;N6MiaQ!pm{-
zcKo9arv@6~GtF^wC#)yn5gD$MaXRnMwz^G2j5xaFuviJkTK6>1=Crzio{Ei8r)`rQ
zeX1=fsv8ahC3r2zMLqM{6HD{~s2JwiHlynU1!mKzz%;#dXm3l)FlPM(@G<)o?j>Fj
zU#sLe#lWgqFPFRIcvFLcDABUP+-s7&QALi+0Nbx#s(%UVvfTHEEb67~k`Auq6?W^Y
zDz%dB5?><f9lMc|;}-ya9a4Zk71ZTKw}7e<O4bWD8vqi|7Z(btKH==H@&lJvHLh(N
zwpbO38En~Wk9!I2%=CG1_qI+g1B$+lMGxsxru;?Bu)%UVNkxD3_7MhTszVNHone(E
z5B%DW&8|TmF0t7R3sHeWUJRm1b|-P}R;Rg{>h6TOu>Afi#kO}Ym(9iJ)Q>KsKE9@A
z^{PVWr9?7SO6E;e=}}O&eE_{LXrf_-Ne;=~+O0|xQ;Nl!Mb0phz2!SK%;3;Uo_|q&
zQo7*AV&71?)p!Xc(yyOp#MU2Qe|9cI_5~0jP0B8Izh%$!oR%n@Xgth5sY;XDag<(8
z%Y7jRM^DP)=8g0%!)+^-e9n4AC>c21ofKNh{$2xy7=bDK3#d5{o>Z|X?M%mLm2(Kb
zmC~@^m`~UW?;Ke^NMiS_%({mgkSDge9$k)%0N}Hw)x(~2G|AmU(P_5!m1PGTy9yVg
zjx68&bGkpOc}Tb5EhipBw?-YlS*KNrc~#V*>8)G+fS;!|+k{lTj;XV=Y{dc{_G+~Q
zd3yPTpgGwVqw8S}N4t)%+(!;jr3fst$cH>)Df3+ia&=7Ltoq6*J40!_mL0jArN-ew
zuo(p9k&^-pR$_=3Nm)*xRUWFc8&@f+U3xuqOmXfU1ZSu>$*beOsR4Y}Y=TIOH|=V<
z{qnA(vj`l(sz%mr`W#P5x)+Z#`dppjS&y!--|M-o5JIRI`dh1<tW?6Z?vbr5r&uwo
zfIaC28*f?Jffb`7Ea{DayLb5;h_2p<d^}V#E)4=el~Ju0W06JHc&lUxW1TA|pi-SZ
z)#ucuJQ=UJz^sbiroa0M99@x+*=OvbzNBRUErX!WhRNpWXadw)I_lp}bGu)@eHzZ9
z_vv#*TFRk~Q+Th7xO>S!H^67pEhz)IZi(I}<+b$y|7aV%Q&rU^Hl03Ldt8!e*}eWC
z%!?!?NIh-A)>1;Eqf_odNwZ4h%W3-~Y9L(-ARA`13M~-BY?}~eNJCO`0iea5r(zv3
zxL#e%9C-6WgOu$Z1Nt%rc@&{d+Yr6_Ohnier4GI)xo7C7G78Rm$%_a1jkGGj4&*q@
zzCoyVJwo<2)=p<Y=fUa4_oYp=3W8FX;wjL;R-0s}2@?LPH!!g*mg#CEjVaiSK~km^
z2Ie}r2O{vXoY%isAb<V(A-{6c`=Q-=tl>T#!&SF?yBqoMQ50j6B`_rfBzxN-_f>5h
zv}-tCre`^M>~^JTX)wLxPcf*p<n1Ktk8}C;>l14Ez4e=X8dI#gBjH1SGT_t#v1*yd
z$uV>ddLMY+Nv=eaYtwp{#AcQa-XP2}C>-%*nqWb*jB;T7TX_4~Wkc{%$IWE3ZM`}q
zW#eUN<N{Jj$80ebJoXqzi8QjmW?H6WLL@~X$Yg*&+Y^0ub;89DFJem40Xgs9>5<Rq
zg(z|>@Rcr7Z^A4w0`V#jYqb>xJxypMsMFL3d#A*d?xf^7F7~<rytf1xqYokRGd<IE
zVNrXCM&p7;&cheJlH8MR>7)#rLcs^L6VSG;PZUbP6|;r$hG}qcr)2D@M~tu`>(I5c
zL`nO?kusz5N6w4kiS=TuNbR66#SXy+u(<5rmdV1z`8leqQBXHyjqVP!N@AC&Kdyy5
zgpDH<`NYo_`qUzW&*z&TXnX$%^G-lc<D+qW90}Dos9K;nF>aoA#3dImiYGZ<Z$z$1
ziZAsp)lnDqXR=lh$Sa^YIg$cJ;-<t+q(sE=%SVBDgA&Rmky*9Q*bcRE+0^>1M99?^
z0T4_KDT^kSTxgsv#06N&kSDn#ftR<98Ds}1qx9Z#a$F=0r+%1ck{h^svMQ%u>ce@L
z)m4mgpMNabSMF5PrtLkuhAD~J7d=KtQY7t*L(MT%f4I@^q<#tm7wg(-8+c{Vp!;E=
ztxt05B8xsyd$g+oO-`*hEUF_9fUGd@I2p2l>yzj~p_wEqo_+5kdDXyju`dg*>vdp|
zW~mh_o2J|_qd^nj-bl`k1tRvygKqKi{qVQxwI_A<P`oWTV)lB2Pam&647E>9*<azL
zP=m9`^WRQUSWHe7sMG}AVdVg7Hd21-xtYE9Ty0Q6sXJ?tjfGMjuZm0IvuQzeDO%h8
zoWwFSM4Q<H;}$sTs292oD~DEohh@#=s$xxqPL34*Kxc45_mF?j`l^bK(!fo;S5kK6
zm?4nBe=BrcYjE|Gi>*9QovE;Ax<v&?=JxrVeHT?xCgmZyQFsHk4pGYIHo!)q6|=&Y
ztcL=iPlDi|VPjX!LDS8s;Q6|#nQVmVg5*ZUayz?5>2M}oUC&Bxq|T&laW|5{8=1Rs
zvf91#))0~!DF|}UNrKGHmhLq5nHJ!N=Sprmc&?8pZ672m@UBT8;<*Z3OXK@+V1Ng^
z%ex=F{^<2jit+e7VLX1OPFve~0<FSEcmK_svSO)z03Dbpcc%}=*lS(FYc3StYj*)W
z{(ipzFHAn25*6XZ(i!@xSk4-^Fz@{FWt0MW)N!7otZuB^0Tr+}dUWfF=Z#uZHFyTe
zfMM)rN&0iR7DKX4AfX&bn#5)(ev|q#$Q#|9AyC6w<92fIy-GQp;3!!O8gPHIoi~L|
z*ha+w)#AtyUjlbftAbi`7Cgce1zeK#r>##wTqOh>AO~C7=yVcN(ouT_at!+j9*VG}
zFfhoj+=I&~8P$t_9LbtcciwIJgWtLsO$zn=*o{!rogL!%<a+eS1pfy$o=ES%L(c{V
z!|2z*a2i^OlA;XkbD!YR-3VEM0Vg8n8rCkphKE%M1=ERpbWebr6m8})pXRsZvQO%I
zU`zMzE)>vXWlLJsGwpVNFZ|=*<k<Tq){&|wbZe`~`0eOrkxQD`cSISKFm-0`f5vIf
z-OEcTbf%NfVeIwXI*u@xw$NEq9UZ8*KAJI)M2e7f!{3(;Z@YOu<FWN#w`wQImuqIS
zf+3tgY9|Ob5ZI*-WbUkG;33<woKWly8B*{BIB$AsVuq2m4(x8Bes)x-ihfy0Qf(Pu
z+l#UnFq|>^N42AE+WQ4i;ufJY%ZW*WZ`T-StB^_zrY7n;7pB#eLtY=WW7kA_outle
z$hu`X4!Wpleqy4M-tl4^O0}Y?Vx=;HPkUM!Uxn8sY%Z$<cnqmp*<zEpd+ZmObp+;i
zW5ohrlF5FGX%(!+HEtyOxsF20FnNeYi3@UTUCDKllJR|v#-=vry{_rm&nblsT>u>$
zwMlwp<UQ=bwoENv8=KNAsp=#i_N!pBw?zW05^+YRBxse%McUFP*n$A5>l*5-<|?BK
zv4IVq1nb%EA@M9|rbw-P;Dc&E=y+P-kAP}yE)O;<Sf`*cDg^Ayc1LFk`IZqU3N(0S
zYlPjI(%%c;{x&RN9O2vnFw|erK{_tU5=j=$M(~C_{|bblre|!2Blbmq%oZ@cHvnpv
ztWQs2vl6?Ztm_)oq$OAFq%2K#!Ph;Zst9J(j?g+_?0Y&`c4huak}h}O$^|KTUpmY`
ze-qw5k(xZ!1zXX1Yed$~=}3tqC;(8PP+MygQ$mAR5)RuTJMavfw@*;UIUiHDle0gc
zy{j`uQ$(Ik?Axl1$br{$s0?J7qzi2kE;=`NVcMR~(FKa^-Ikqf8cW{N@ZpCjEg_^m
z#)lOC48Zu6M)k^$n5W;x<`;SI?(ufkdzCC)c`}>YT{)mB7};Ht&sLLYIEFz`!Mc7b
zFZtD}sj&gDn%mlvJRX-0&=#8<$qRwB$mBW!3GaS;Wnq;CdB^+v_BI}d;SuM|%E!d2
z7QN-*@2zSk7B<nM8z~mpy9J(Rn&o86`cYDvIt@HW?R46z)wWAV!<rJ(0*=YX!4LGN
z`KUm|Nk``CwLsr$$Z%h;2A@~d4s2#19JG2DZ&g;0MVx;Dy5nEoeu8KPI?+XiuqYu=
zb&4*8_Fh)lkl)rneK*ibK*HWux*Ei);17@f0cEJ+EF=@~lN1v)sFfRzNVbFR7!7U~
z<ngJAQ9!k071)YUkW>gz4t3BM$<xnOiLL<VUW$k=e>ju72Q@lT*s+BcRnn?l1ZKJg
z;wzIO*{Lf08bV(Zq`H=Oc#c40N${u-g$ZJ-DRzKha*!f5Ws>amGSM9rlVDpb<~@EH
zcN_7doN6vWS*@9*xF#)q8^sof7ZBm)h2<Og!8GD-vQWu+-U!{#h++&5^0tl92SYc*
zntP5vYBYeSPjTa`K?)H%=c)~5xfReP63a_XZOQ+U40Y92p7>dz-pK{3pl7>u2x35a
zJ;f011bqTzigYXGUXm|SLl$8&-lrsLwC~td+00fKo#d0wDJN_n5Yv0cFeJ4G&?zk*
zFNn1ANhaBNsEBie-hqmo5>WZ<<IB6xzWJ}{6Uf>N7|>ca+Nw(#G;UIC*e$o3Zr;|I
zP))(}gR^7$y-DtZAnBYHqED=21c@CBGU%qRI6csKWR;kZaqm8T{dIW#QpMrvvIus4
zVFTd-22^*pa;g@MRnk3v9Nzw*igrnO4fI5(r0Ss)ogs)egVa|;p>JAit!&4@;>|G>
zCqSUp);@gN7YLeET9n(_9@%?cRA5v|(@^`BFRpg{JEGQqMQznzVI(0t4}Cv1t%-_>
zDQ=gVA_xXt`zaA@mORc842Z&J9}p_5b^6TaT9go3yzt?zwECSH3$9u>t)BL&I1cIT
zVH(|{>?EZMk^3yIxf6zjW*}@l$Eb1zcW<?vz<u4?OZ`}#gtFDH9@rF2X|Rr6A7)56
zNFy=e@Tb~M2Q3=*jMw)Z(4iiPu@ke1heB}OX2hZ8NepSXz){Khqv`0hp4!FpzChx@
zg-_J?m<c7}GJmi@huWT5(6a1J22>jH_}A$xd7^qs5qA$;-Lac3a=;ghhT&)(xzgPy
z_K`!?7o95v%zadt`i3T-Dye#Tg1$IgHLA+1$}@z}N|+uai*?D0(ymqM5ef-u1J5Q^
z;L@mSjf?X9CA@uwjN-xbT9%1*k04iCqY-?)vNMHZ#_B(`F4V6wP1T@Jd{I9%e~fd+
z5)P?-1NOn|CuDCYVS)7Lz6)8x8!nUEX~uy*5QmB5$;;qo{{{X*yUM$@gOZnSMd4D-
z!P5;{rbm71w=KneVj=|hW+I+^th%Z^kJ_+V)aal;;w_gaC<0z|etAhAB<Ur-6Oysk
zyMKNCNqGIUE#K9u$KSkuMGVE4cJ#|VP`Q0Cr{4XL^P`P8W=zbEOP|Q9lc9Ow)<uG9
z#KZ_2nVpF#q(+o|tGYMSRWcEb<kM$ev#=_jCiEXNqE<E_TcjAD8X2RTF$uM3Qig&m
z;5<42@YpaY^TMc6k9s>Awy^9_ThWq2qC}?64wIz40c*gL-(DpL-0ahhX&MMOr8oO7
z349I0xvopk2Ed0|BI<eD4k*=gDpO#uE+|~(L^4vdj>>3X1j>=T=Ita%%tSn@^&0(m
zX|}bfgNS<QxU?V8WA~}wylvt_escKQEAOsVig~3+(MCn$?dDu}NyMBLoHUE5kR}@r
zy*1lW@>4e2-VrUfq+e~}4KlVj;wRNElm(uSN-djXQG~*RBF;)U2H~r4;gglS_^tx-
z&O9tUcPkGLo>T_x_0Jc~_Mr)Jhj~&|F1>Ab-&-kQk0;Idq`*yDq{OjjJ;#!l2X`Xn
z9M60mDZ!q33L&}i22o3;1q<+YH2?JVXL7uLz*kCe{PZ0VK+xUl)e<<oeQvR)Q`vYA
zp@ki&{R#MPJur{?(6d&_v>TQ0do>1BmF2lGAX|ByQ?o%f^WJM4s`fBm!n;#_fH@F(
zVE7|PEl*n=Msk3iylnepJVClq8dW>$l=W(_aPk=kttmafp2Ch#P(hZ}+hw}Os+|LS
z5)T}4bf!YTce3RDCdG!==PO297fcuPnkg1liz?VtNBv4E8u`!|45-VQl`d7Fd-;?a
zueQQvCERm(D&ysWKrn%e&u&q7S3|55c>pLj*#J8WUEn<iIDknqCxzZEbcP%n0F#jP
zJmJP}J3Ty$XUh2B;F>df^HPF4d)UR0ZERtVN=<xJY`o&;G-H4EhzfWW(4wKZ@q^V9
zCvj?f%C&~hyp2!mN0@ghA+qApb*lEPq941EsEQ*b`kfYZ1t=Esp?*&8eU?ywu=ilG
zExJg<Her1hmw5))8~2D0y4R_jDb1<yTZ+sU%Ypx2PF9ZaZd@VvMDjl<u2t0d)c8be
zj2p@!3ML+2kwWXnI*aHKTp}YB40~9-OpfW=z1!5I)836XKzjWxK~sM?@g~oJ7Sxrq
z-STAzf>lx`DR+T5w3`zdXp_<H_Q1=365f7$IZO`~PJ~P&(d-%()OTD)$+wbpLLdMx
zDR^WFf!&qdZn@t$RGRrL-c@EX;G=%Xo!^|bfSYgavSfY5LImRclK4;FO43|>TIlEX
z(1TMlUtni_$OV+NH3|D9l3PCx&xznRL>cIcvtvn+eiz<;e_8KPtlIlR@+lh#N{%hX
zQRT=0)t6eK)=Vww4YU%K0$~*Y%+mC4ewcoz!@~A1C>qkXM<Y6rO{9&s>`J!?D)HH1
z2Nfu8pIaLx7FGJ|4|e1LELBQm_30Tr5uOHsQQ;(D9QoiMRt`i5+{lo8*3^0XeTty1
zI>B4P3^TPXFEqG17D@;QsiRQ-Eml9zI+fPvy<2E9W>O;-$p<Lpv7nbcC!REQzMwzo
z7v>L&G4QG&AxH`HV3P`d;nWAUHHqXL<*FV+hlggEib6r)XPgwP;x8;urZ|c1vzCq`
z7@16qiiD}myDL{ecj}{H8|4YOdU;n9r~@BOTQOk%HQ@QzVRex>$*Adehd#z*%CJ{u
z+WQHv+QH$hb_t6Tn0+5om_3xGG<46=RYtxJuODAtpvj?jLN_PE_H3L00|I5ZNcmo!
zz^oTcWnJx1E#?x=`|@4;FQhN_ROAW5FBw9$**u}-{PQT)RAb9s(S2~|+NFECtpI66
z3%0;69xe@37MI1QADm>#&$`{_&_RD_t)|%$+Z)>N9P42*bP!a4`U=f{QaWjALQIYk
z=t~x*9JEcU!&2kdaT?WrHa-SDCZw}EAJy`Slx0AY{g@m7Yn3hJcBpF*^}Is|XUU|N
z(Liz7_PwKj)q1*XB~job12KEDJtH3-ZC3yhO!uS;cN_CS0evwXtP0dGgfSLSk<O{-
z>yLmN2Kaz#{pfPXD<6?WLwGr{+Urz%s$f7xB9~ZW@yZ6<qP7Hp@5+NwiKhm}UTWZG
zIUzU!>~HD{BKCDE%M;nBlgh?Aooo{WD=pugID5cK>ys>YdEy%fcIqF5qOeZoyrq+r
z^lwNsM!O5aPL|4D&yt<^87bPaeJF9hrsS;Vo5E4;Qeaf7BzOJm?|moyCtKxZaLtM$
z`Ex7Nw#dDvrE8R6!+kRiV<Kscw!lZpc@BBP{j@q=6Aib52WZoG!|d&<s61~AJJVwf
zSvuS}RK=+o_$%ZA$r~ce_r>@88V?@dRSW4TmUjpzTtT`A;UPkUY1F_)W#nA>60oya
zPe3TQ&JE?QtM(IhI9b)rl5fGQ#;vb!x`VJoVbg&r%mjt--bBqBB^^-YcQ`f8zIgkH
zC&))CDPPi+aOgspdV<}UbFw<BQxvJT^4QcTglO0ugmIEDq4Pp1v0Ka%da@KJn@z3C
z60?N=>>qZMI{td)`fu0?RqcUQvNr1*;oi&((6^X68qFNK1$F1Y`rug{n%<R6YxPHD
ziUrP*&D@F;2S)YF@Rqgp30lmB2bcuv)>Sv3vUR2QQX2v4iRG^`&3m5_MTN373yX=H
zLKoGp>CTV6)R36*p}Lvjp^lQ2T>_)Zb6^6b)T_>C=4_V!9y?T0imavu=^eSMc|BB~
zn_fW)O?KVK>O@`Y<q5J!+60>CG+Cs0mF<RU&T{Axrn8H*E3`DOin*vxG=LXZ$6SH2
z<!7ps{0!bATaK8f!5rLrNZ~4&1LJkU26&99w>g%1;B;SMc}De&?kHZ|ioDxAhl1O#
zSIh5y5?+6$QqYXidd(IT#vS%(>_$9czcIX7^U7LXk`(`#{RQo-D22(rldEaCLg(t5
z8L01m_{|SF+h&4#?Fs*qMEwY-5tgJwTHX@w0T<=BU*IT!Beanm#sZ#I-Nu>tklYV!
z<(r!rD#IJ3Z-~c5JRYH+vPGu)kj$paKb{}EX7jY2(B!D$RNhtAk<ZMZoXx9J7Jh(L
zYN+Y3bXiUA$1aCmshPG<q7?2X>*77)1hoW=HNK<qHzf)QKd*0A6lvCA?ZdsZRae!O
zgUz*quK|*<vrD3XN(3Hq1ASF3N(zHhX6}hZCE7*8p@w3)W!e4?w)59mh4;)C0OmT8
z&nwA3mW#GEPx26!lCpZtwnf?nGSc7;f=~}rbU&tRn2T=A_$YAyAszgK*I$P3+9z1w
z6SR`^Ub|1w@~Aah@A43u#x;1>1AymkaTxF_#iDW@6^KMA|CVLbq&R=B+^t8_Lo=&e
zpb)dk6{7LVgarhIT92qnCx(B5SEP@$6lhcKNf`;ce8)xo&nH8i9?;gQp%h+c_+eFB
zxIn?sbAx;YD4?TgFzXx`wiH%3u9X8_TbHFpyL8#Pn$`KO!+Mn?0#dyzKO-(*)|N2<
z<H_;8cZCMY<{&TL>llDx{sd}ynqYdibOdV2zZ{nh0_OH6Fm!;7D#kN;Bc*c%WyXR6
z!}6ys2~niqY!gDV<IG<U{6kGvD1GBqCpddkqd13^yT6K*%IoCuvBxC;V8}%b3smrk
zf)jEKuzOr#F?46C*FOfMI3d)2g#t|KFO>@GD8z?m>jTLK<P|I1x!@J+36rI~pk`wS
zX)vLd?ggr39rYUiHvDaZ?L*hkb`Q>NU`N;k$5CbditCh}h8J~OQkJ4aL&p)WB8I|4
zi)$E@<FAdlAh0rdu{0FW3??fPggCNPB$t`Ix~)Lu<SZB7^>RNeummU{I-*aAz$RI&
zg%H(MwCi7F1-QrCQrtA_p`YT@zPK-V3st&>N6s~>orSw{$<lkl${o5sL3?<ERLA`U
zd)dcr+R-M@8W*yBQ08rDr2BzWfs|41<mOK|^vYf9R-#I}1J7z(uVYB2Wh6`k23(Me
z4^{ECgBym1FSNTk0ej%m)5^{8qymR0NiJ}NN!Qvr@c=zNq$SOv&K8R5qY?m8i;Yk2
z-l-_0)Hf3P?(y&&Ix=aIY?>I0yfOPk94Vt}_Sy3-cPpb*rqSU{V^q$}WeBT1^ysqo
z$R@!aEB9gcp^U^D&-yC~-#kdzvPPFM4wtf%)p?iuduJM2Yabp%!wRSQo%scrX(r7J
zui_Wt&*Z0{W%p?3(xv8?oc8~9I9cO%V0aNM=LYfB0tVSt<EB;6m|_x>_stL9KK%dx
zzaf1|F;4abTIxo1YE_Q87)_rVg5^qWKXo65LGG|SKxz(RR;$4BVIn>k;RS@=nlPoO
zNk_w391bFgOb*S6aR|5e^3)|`Ux-t<6*I6`e$t@<o^3DzEhH3bP?+uL$<mF@HVIUc
z2*<3dQRC$mN{foZ_ELB@k#kB@#jIHk5mA%Q0vgES2*`O!{DPb|@DOMgxtoa^RrZIr
zp6?x*W$&wuBX52EQoamR0<dQ-Txec1nxjzkc7^KfrRmWPLG|pC)!Dvkkl!vR<w*cw
zOl9%!gZIwlwEJK54@y(9>EWuTot9Zvc8f~Iz}SE-X^e9236!Y)?lf-(?oCE0Hn(Ow
zIL$CsPHI9{WlWW{7{On#l&X=CQoIy>WNCoHDNpN$!SU)+dtgHBN-gTvh?L1T^sJaF
zxD2P~q@FkZbV!C%900BpP!yqPGJ5g&f^ZTM_l`v20)5c#kNlH`{NSaX9)e8CDtN;|
zba_(5)<QLf9qw`3ULn=_<}izTat|fh1E6#bnIJf*s<h)~(N?pOGN>S_J?<2bIrP>P
zYF%8fNGig>L_^;w4V#p7s2zx!CVsoAcro?t>RMHq<g;1#vp_}oV(~wqB6R~5Rq}dt
zav}_!>ca#Fa^96n3i$?zCjeC3O-d%_Dw5{}?ZAXSw>$$SbQ*Ab_)#th>>k-@NPw^C
zY&{sgSV{Ns>(|gi1T*U=?|%IH`?sGfS?d?7#QPck{LMe>-+W@HbPuJ#bTvvLUb;CK
z9c|n|B8KjmZ0Ow&K@h{ivsMw&{~lgH*B;*bz(j9XwLcva`NA47AOc~D>yCh<JFu5_
zkI~)Il-}SbsuKeSK`Uv3)K0P?Y%Sc?T7)egAB~v0g=2*fnax8*{tNgY*$d8g9YA|K
zH5Mub7|4N%?F8Wc?(*+oaN)_{*n8Tvw%mA<uLmquF3<y(Cw@sTSEr`mm#=>?tBhE9
zA6;pM0Ogh)6rno>3elerg|t<MI@l-v4X8!=5Y}O?A<~-Gx<dS!!$2B67+_kB=f5&}
z%*#V{*wRzj-IR5WjqbeDkq2gvHGz8!zsSK=-$kfCY^|DbpXxOm4qsyj{Fn{FcRCte
z)jaZ2VDxJ3cMz<2(NHLi1jCL5p8$C{o&@e2H@B^z{^4q5T@MB&EiTlt7%d8^u%Q}_
zF7`0+1mECWzxIJf4-l^?ckcAyP1yzlM(}%-T<Fkzs!?-Y2E0|_l^0N)7gWD)I05h)
zz;Pol2P2Vjy-}WK0yPoc!tTYg2;L(^ycy$E>wb=L$EZb0XU=vpn#kMJX&R*z2TV#<
z39vTbObxoggcfmVYoVXaQ}y93ETDjPU>0CqVXGQlt1Y!A)PKwg!-Lk16TzZ#gwLG4
z)Ga4TAMCoJ_>5*_$7>H1<0FHJ_PANApOh$4{I1vlP+NQROrPAiW&N{zr@^3OT<Ehu
z$u*5}ir%ylY|X7WI3`!0{{SMMv^2xMrpMaNZP6MC5^v@LpKG5sYz^uMv`S_`QGs~@
za7JA_<*<4p!Bvio8%z7q8?(sU8jw5H=b&DA(lvX3MI$&W7c$K-(#lb+tv`TaBL1&a
zD}-<+PG2E+&Riemv>(#F8{iD3JM3Z@M7f2+;R8}_Jm7ob{PAwgGne*2insT8AqW%|
z<7tM|PGwFE77UJ^7Z}(Uxj}Qfg4j}AN(v9F#ygV2oxcIl96qhog${wC$V8fo{*`?M
z1&W^85?{c|=0C_^C%I>btm>T9anD*J?@RXh8W^qK{oCtT;q6P+a+h@DP)>nloU+>`
zoBinp#U7lrYV0v>fB^2B-UL;s{D2CZtKHYOse}TTDyATkpkT$)?<RUzeV*2>-G`Hh
z@Z6u6mH5<7>vTOq*s8H+FB9kxF+GsoqtFy3CK-gSk(V*Zyh^>T4xe12>=7WWy#U70
zk_QEjAPzm`>FLn`4O_tAWV4S)1)wmDPPsDRko(X@V@Y-oafTFe65j{2tT7qf5>c%<
zI%1_T@F)+pr6{07O6E<ssB}ix_vr#JSJ!>2aPtdaP&K|aV1k@&YULv*h!nTe6qLnm
z5l~hGdTU&~=yXVc9?1WIOI$A7PW4}!^}YTk@DKJV(G+oY(z%uzuG>!3)Orf%rB|v5
zOkw<z2bF0b0RQt*Arp~YQw`az27^|;RZ;M*C*@Ir8m?J(oh(22zmdtoW;y-Fj4oQH
ziJ}l}J%}SwDas4%$7cC3Q0upjREOltSsXeEiRy#C(6HMn!JeSC28Vi@G|MEKx%NW2
zYCEVFNtJeUN&i@;M$UF*YqSl+K!Pb2J*!|%C^cBDJz&LbBn`(|CoQ2LDAl+ml1<F>
z|H@K(&NF~F0W_<Fj%tget)Q@xmO+P}`(2+@vc}Uh9aO5sG%BI&has^EN&&5tKJ`nm
z17g)fcOrgG65=I;T=1dOPl3(5#G9KbS^!<WVlGwCigk5~7U(jWyMyHKpMcTQPh}Yn
zN3{cX&9z?fm@4<vpsQ4S^`xE%M>Ld=Q6(nx$Hnj<J*wiC+th>Fh%m@fiv}L4**Om2
zt1jz<e;G`=Yz<|FxiK26lK$c&ce9@E#=bzt<yBRzsvgFC7`fC)Q6+n{QYp-wDg(cU
z?xa_WI+%!hz*+qst@+nN^aBz?DOY~?DG*mG)$Zu5;Uv-w!onykrQRu+hZM|q@E8tS
zSMBPOR26PeG8k+gDsC%3jNXVpg|}bl?|vU%(|5;?oR2yxp<8&Cqs1I+cmxoJtiunU
z49B!Ufh<Fu+rwKxQWChYrVbh0F#H+*2D^!4JcB<hSw~3_BXn&@g<oNhVh;|sO?{t6
zo;E{OLw2BBSnAgkjY?}tj&mziWiy~ouWonLraG(k$~yj?^2~r`(VjXK7l^mG0W>7_
zx8`rPn{p%bzKz*p23EV26H%d11>a<4Pzdf$Qmf%?PJbacxHLflNM7KduC^33SB>h~
z(HE;hlWPe^nBOfFqg=F4EtRU}`NIZKyiV@irW)BE2BqE+v2px2KQ!><&n*{F&VST(
zS9efZv&aFrc|ILE5pMA=nV0w3F&ER(jO~26JfKIKa80W|!Uaj9U1lrDf_|~(1T1N0
zf;!B+mYUfXNOzSy+{DcfNlk5Hgl-+|24q3(H#?(bvDW~d+Aw46;7(QYjBE?gV9%PD
zSUsvWzp=N6Hr+BQeBmq%uY*R(2)h>_rJ*zBBSt89`JW*>;a%Wa=P@KSKRL^~l_0=G
zUg{sonpcWBOZ`_>AY}d^y!|;nq1WGE9uMw(z?~$~A6hDR>~+Y#wy-OD7yunGKG`)8
zH0g=vujSM$-5SG7oO{fACMxCz^*l-IO&pXE<2q$hm*S>Qgrn<oB4u4v1*XhQ0!S0X
zKh;+BJtT8s{Z=xc#@t<WJ)uu#P$#DhZTBqA3hB$yDP1+=N=FMx6prmg6%Y(otVl<@
zyg%WU-LM2K`KgL%H@T%kBwQY?3Bnj+m?0gGJ|Eegz`#@r78sjW;d#AgDPYuH)~8^t
zZ#e>5Mt=5Uqr`OY`Eke(dUgfut;Gcuu1S{};mdatox+Y8lL7;?u}SCP6+vh|`|MQQ
z=gL;sh_;#p<=T}ix0GAWOqwN_Zxp^!%~OYboQT&FT}~FZkifd2`^7b0)L?XG;>sX5
zXQZIBY|sWh&a^q2KIuuY8Yxw~esR_1Yc}5*7#ltS0MDRzA<K_HO|3ervgQG#Og;}(
zQj8ijDYKSigN7j7$>%ZP{<jNg8M1iDAi`;0n<=*o^ETPSyP1|$rIizOlw8WBN-{NE
zY*4cEL9YBz0Liy4@@i~w3=aMdy`l+Le-ONzWt`FeK7+nrKYmNK0sf%JC!|fJW|jg;
ztA7F{fcqqfQsv$3#z2B>)#EHY4who$cz{OK04zq3&!=xcmjplkS*qaI06{>$zkdt*
z<wtUIg@^95qUKcjdV;WFJ=ow`X$(jUyz>wIvuWa&;d;G%_pib~S@`yh)P=Qcsqh)3
z4tkCaJDBEbscBez_#TfrtlYWYI(4SX%}|RX>RG)?Y1!JtS{B3=kN)WT>=y-0$tzfI
zuHH|p568W;^WI59{3GaJ_tWkwX;9@{dF~AAdTNbW*eH#TX@-Lxy3~6=FOG#x(i>7}
z+!)0$N+Y0IRk&>Af1s<lTC4yTz>pIXT6{GD@hhuul)uXz$PLnJ*+_3q%w6N5>{R7~
z@1gvzbH~GzcE2@W*y-@7WPZ?IcQwYlp(qPa^1x5HIoYX_RkX^p1stfzmJ#=}zdE2e
zgU)gXD~Ev?CpAxjchyv1-u)ctGo8wGjsw~XjLN<KmdJY|Wuxt7UA3Dk!syX#!>E_2
z4<U2hllA%MXzCh}S7n0H<d-FNb$!H1fn$^ILi$a?Rn?ngxWa+@M-pv{Ovzt&)bErY
zUt{r5KO?qDv7vj2ZkVdq*`y|o^mNiQQOp_ke{zxs=qh-QrKeiuO>>`+uktC}7-X3J
zECD5Q#5e*|$s}9h(5@9WbPdT48`>x}l>h7HgzQF32V$o<cO{|F+~pBzgGKQRU}85-
zJ0Y={QbU}nGd)$dPL<|(7!frKl32-VsaKP;ZmdoSL4bm)1KbhI8r7KB;BB>Ae!!`?
zlT#&$*{WRWzNKbGy4izE7ezLh%3Y-jWut6%0q}EyHZ1C6lU-3<B!mqC`kki5{lE>b
zF?%9|5qbv#8+&D4xTZJ49o4}ZhDBSV*zN@E=nY-vmUK@!d0t=$!A{Z*I25SD0(4av
zdrA(gm*~ho$hI&(OWw`Dj}=T0%-8AltBXE=32IlM{bsFtnFL52h)H6&+$@7q)M|qj
zSPYZA2kzC4Ki+w3p?fL9ojWB<0YC6oKC%X*--7*`RC-mVB3mQRiU87yC`O)S?shP|
z;7o2&<m>`Y`=Dc1Tls)bny3i?oPA=hwKf77)pDK)-t3vSc9^WG&l1tsgn-rYj+t5O
z+(#$}ne13sX;rDl(@SI+ICIpbaFdkJ<j4wbq)1jBtClq{R$U{@v7)0}mHK`h;OOwN
zWkLmT=3ObH6%Yb7G6VNZKd1;Qf4;SW62)>vszop7qM%Psy+S?NE-%m(nZYW$aZRg~
z;sH47ngPlZ5sa(U?rJc?0|#Oos)`PY0qd+TMR$__l{)(}o~#*CHxA7>YoGLcXfBOr
zUFqg3gup^SFmXL{;es!>6}N=YcLZ4BnKG2a-JVgA=iu4eaHeRrc5FGrzjg%2TwO>P
zMiJJzE#YPbh01XUlz2cYZ*wg8lvwbvG7#id>llCs;%f##jBdn>P16m?9kiH6+2_s(
z1v0HwU94{L2D_}7PHs38HZAV|Wb0g_V@yC%?s}w(9MTqUNEY|1XM6&P-HxNXYPjZk
zUd0~cIBlSoDj!;#5kMx>jYeLUW$jISFMLDmR$F|%5)H0BeMws@H=Qh1RVIC&#L)Z|
zg;WyR59+RapQd3w&-S7*@DGOmgbILNlie;Ks+Z1V+2M@KgaV2)oFvs*b`Y_W2rfDM
zKFCRdP9sN%NI~2qfIc;{JxbiAN%?74oGxKH%M^|gWY!guL$YHIDabDHEeLe*mAAWj
zMI3=w>EZb70v5|MJ#vE<23>OU>=-H-U-O|O1jlY~puJ9;Vs$wp9g$)$mbYzmvzXC9
zz%YAF5Jdm!6%qHnNYffLw%=6%?$+*p{p}?8<+|thx}NanV9wi?co6t-_puPvG~~!b
zP#PlO{p6?I+I~{M3T2@bq^Y9bX$uw2TQaEiJsE1m<Em30Y1t!RmdugMYg8@Z2S}Y+
z*h3kO3Mwm-NS>VPkX)cpi4NejJ(`MQ{p<e{{)>I4rn1jee6WKx2qVo5CRvRz{Roru
z3h@)xZa}Ux7OVx~9|NhXOQl0wsou$j2JmQC0{Y<tFq4leBXWj{N{O<~d-v&BvV|fl
zLQc=e?gn6-(bT4zp)o$choc3Vl4jp<+K_t;_sbGaY!8X=3w2l!1EAk)u&Q41i<j~#
zo!=<(J)y%ScYyK}FA)rL^G8MbH!7k8K;x^NUPR<gIJzf{j^JtrVJ^vf=rPmigvwQ5
z?vmdDgX+++6_ZoQvvh7j`K0d4lEzpabMir*wN7V3B~^tAV_M3jS03R{+;C%@CW$Q?
zW}Z=HE9NSZE8gqKN|yCA#-lO8vh`b)2Q(7BM2HVe%NeHJCl>Ut!s|y#SHu*iV9JL<
zTKWi>7Z#TTGR<~12WWn#ftoIxmPAdm-cf;x0>i6}r8}5DBr$i{(-m?k^n6#29Z<ea
z99dwXQbXS9dX?IVmIiQt^ze__C*U2)tCuEiMJ9fvU6rjSktB_PMHXscWvaqUi!BRJ
z#~uh8B(t+b8eY0`Dx!hhA}WRJ$v0C{{26OaZmYKlieq1u0Am<{@cL=muDE#1n6Ld2
z^jY#eP?F&ah5vPv1PJ}<rsJ@A40nlZ7=6}-@*h^eN!_4umfd@9lDb;-9Dx!uPl_UG
zTQ>{>k_?eqy~;DQj_}e#;k>qKR?6TylUl`!q*#_B3sIsv`Ua}8>Cf0saJmD|N3Kl;
zPgVcS&Mz=dprQuyA1B~?N}x%?-0@K?_{kFC{1_#%eiX#4EY>8wrh}^SS4eysoB`>M
z0uvz#DC3VE?24DKc~Gm-3bE-BQncEB9WvB##pLaJr8qRum$%4F1vg@40G2C&tP!nP
zi<c8Cssq^X<T40n@-FYf&%-zWHH93^eMn#k`(^3YTW|o=r1D#kvccFzjySS$CH0nt
zD7z9RKPv<|UoCOG!AQ_z<1Nsg0*4Fm^yrfEz*dDl){qTK8^dt?-QR`3`@5v3_F;JU
z-yo0BRcVV26?JCXI$YVA9<N=qJ3vm^{Hf`*+Zn1p4U_6tuQy64>D<ek1@67I!p3KE
z#0IuPto)Q#MXF2Twh9dlwF#cO7s(va-W0+C)ICwd8i^O`vi-ukWdzX64V-mB+sUCq
zBz6R1Fco<+gPbf6M={*?^#0fIKjlvenOiwyCHS1k5Ly;@9IV$;<AHHO=rB^^sZqsf
zsi5d@&TDDpemLp_kavkB>`~WVBNQ9XgcG(ML()pBEBZKWQN27&8ySlk7>U%kao7TS
z%<+Dyi+iW0OUU`;Tu<AcdNvEP3W-Z4Pa=6&dy_ug6%n&;Mrlx-PMujR7XLwsi@jtH
zW@(&#;UIS)>$K`A-za&ym)Z|>d)2qw!1;EVgjLxQ(UnGqzQpnECW~$IxJ`Fo*_xi8
z=+s#9l3gja)`6VW!j+jR1m4zp%4lDgDchMUm%Wz0n~y0toGB&8QJSQF_gCS22|)Jl
zGe{$Tje1}xFR+V*f-2MNM+7jXR%J9#dCE8<%-BPKxPnSz?_&>~Z|;XG3dW6jk^GTu
zt9}q1bV*c}BVb;*L6Q{_l{J9`Ovcl84i?+4=c6U2J@ha-)Q>-6!ymcbV9^XX925w0
z^gYOK2KFC95@gt{Pu%f?Do^#GF4*#X!U!k*mf`g6EZsc!nv|+<Hy=?O&E}52zzd|J
zR*pYEU{&<K2O%Z`)Lg_mUAGF+W68q7>7Tr3pf01f4PYiLvG6jH0DVRG$bMrBwDkt<
z!wPnJ!tC5KjVj&P@!cmFwr|T>8F42icq}XQ8t)T5T|g{2fw%6;ue8(U^{aFuoF!FS
zWb`kxG}4obscw@8`;^BWjXd*3J_X?9QXShFdNd;wnPO0Ehb&4MVshB1<M0P)$3DDY
zv~6TVn0Ug!!XHv%Lc7CzZERdK4?T0k>;h9@HBY@-hy1&kB7I~8u15!6TBKA0kk85m
zZ6~hfaYr?@@J%H@SvsW+N+D1w*!`JP6A+4ungGr}g#W0+rG);%9&thw?@Qv!Pl?QG
zYP%oXO@tbT(iYc(E?|EMrp5b$NtNYkvfGG32Zkj*SM(jzL8B^#sW)Lx>%ax`kzZ*m
zg}%OmynSp@Do>1HwQ_n6k%FaY&Ij$Eq&Gt|eL7i)Sy1d@c!whec;+a-Z#xkrpr+1%
zbQFUtAlpr?q;y}J)YFsv<vi<;16au%FrpXE`EPirSpVj&CU9czEQu6EU7VCKN1(yF
z5l37$z6AM}oyWrAP!ga%VYPGLV|cP<t414yV}#ubfGI(U)ccj~)@uj7Qc_USth`I8
zLra*$|0zp%!2xa8(}qX%4i!;&GA^EjXJccXY!%h!#gjU~p1b$cQjb{{Z-94{^&CBN
z0H8WyO_q|$8&sonAxnTVfgDETD3w?R#fk@O=U}1&Qg_yBbQ2SIW=JD!1ok1CbQ=}F
z;cra@MzT3|K!KtHr35Gg$F704&Ck!%n0%<xjm2aeg#wtYk)Ic@X2jO?eI2}u;ft~|
z3M>%bON3aol)?tpOyjdGO!#chD+qJ)Pf`sLG=+|boo(_Gd!BpYD75rrpRwlGOf%R)
zV_4i~MxUO6g0K&OrKt1qUF=(T1?i%=bt|EC&*5&}#tt(UBm}E#EUvrz!rY719@iDa
z>%q|zrVsun`}#);hX297{@D*_+n^gn0g&3kb<8~%*2+>dOrfpce3iRE!Anq`sam6)
zXN)X4U)YMHSJNeXu@AzufkV+L+OJ3FQc`%dm${1u68&L_F)0{g*6h@Gd6lF)Gc+8E
zw#oU0L2x>u^I+UbM?uJs=;$YfQs5@mmKabcU|gjF1n_E*jnf)x7plVQk(pkz!(4=c
zVAI9C6c__fd(S3jc<FpRJLm<T1mmkbolq)ua3MGei~ruv8o3A#4ICXi;he=@;dFH1
zE@AW2R%GwB6@{QH<R$L}JJcsGr}7A9bY22`uHrIS-HNX9T<0cvzn9FEuFHp|GFm8}
z|7rN<2X8-<Yog&Y@aa}N@3m(;h*Wy&Pp)Ex^Kp71FQ{<THuMM)1bE9cao{YJ{_9|Z
zD%(OAbI`E@L7xD%k$O-+g;V?N%eUY1Yxwtnp+5z~mz;4wg;s+30ktevFj!^|m^lhN
ztylPSp!rH0!roiegH%oo7n|w>*nR^T4Vz64NIR?LMym=-B`bTUa&VgOSSVMU-*g=d
zCYNlFYB$gt@037k&khhO0|;jdfEu`KhkYoe<dmY^jb<w-x7u6$efSP{yALMhVPzZ1
zCmrB!l%4GrbtWa9lE_Xx$0g3x^#B>H4h3a4%=`(Ku3@u*_||3J09cN&w7fY9b;ck}
z0=D%Lz@ooN!L+FXEjs(F(|I)dLlC2J8U1d3PpYs;3JVzYRn`!K+8Kr^CV`JdD96zI
z%vqcRo~<+-lD5Tz2fyS^$QG3m8Qy+(5_Nq5c(FPD%Mq0Y5eQw<4}oEnYG*eI#Pws@
zZs`IaPNex@?@kofjmFKZ(&X*(@!*x%h&>oFHzBxr2}fEi|M>myhks0$Axk~$e-{c`
zY?M4dUXq$s_G+pM9r`WDsd8LYd=Wy4^?@>SP-&)(=UAyW@3v<oo}y7u^j+qeHHAv2
zK?9NT8i2!v{xRE0RJ!i&2WBrEm`Vk=2Urdsyh6rAH8SE98bI7$`=2FUm|v)PTup{y
z@wqk-msgDE?8z%%(tw&BMS!jnB6^)xvZo^@X)68JgoR93)VhvZ4b@%1VH1`;T}Qm1
z@I0#NZnRLpd7uE<E3`Y)XFpf3*-&#ISJic}Zb1jei#<3bhlL#qk`^2st}z{kYvMv>
z<X&Nt4*3hbO<Lk}lp_lUmJrnXfSmQ^JF=uw{CMdA4jAnrFB9?l$w9|WR3uaXBD|#<
z4?>Kqicy>-suJR$^O{jtqm=#M4*&3dd+FW#Iz6#2l4wDRg0?o2%2RblUd>nvb-Z>O
zhBG<}0TW&L8uFyi;kc-E{o->T%g*mfpT<CfAZ=U!sglQICG-`{MT_N~WSOAtl-}P+
z>ZWPHWn=q1;+5^)xK0xU-L1irLUu53k_t2BthhK?fmxg^RGz_kN|=c8#TLmpRZt!w
zEL_qogm4&wTPF^@$QtoHy&MifYWP4a(sPUmcfCAb1n!MeO+7VKZc1ne#6zKljGYQ&
zO)C+~93=^fY9B~Jx8fcqq?BCRa$|ePFW((wgh^tfMsZ755?zi&V}G_g4L68ocM<dP
zY&LXb9~hIZ>po(xv4tlBaCEH#f0r)lP#^8|XGKJlvv=~7OC5E1EMfP7E$gF*Vv*xI
z9-&+F>94xAJpidLS(Os<Mp1u@6Q`O};-{3ijYipNa4m<B$;(KA(;_#dl;|QMsnLAz
z;_Bo8IoeO7B7ZQJK!72FPNwzm1$rResUB?Yurk2KrvzO5BHfd|(<NzJsaS5K1AiM?
z{KrM|tp1Sm`X#^07vc5alq6ouJzY{iAU&GNeH3n(*)N46ZVYvk{x9w0Fr*Lle*`mF
z{iz(i7f?LNnZz8DFjGawxvEFUA)&nLl@YHaj2dy;=^8U?jpT3L_ayUk(rTHR@5e3X
z87`8!p*!i?ek*)CNi|5C@H5VZk~yC&U8!R&F_ycJhv!A#mJ=@=XpN~yK>UPI7@*Be
z?xG|W4eLMs(mr!WWe4rR(JW+s8SfVgn<e{(#XrXa`V-Sgg<Wwxg#>cW5B2k41?Y=B
zD+{+0+^=@QAe^?R+1O9Q+aE8`NZ^bSWCkLnVYS}N6K4w?u7Gk-jbmQQES)i2VF_`K
z?-6wrFW|#>NPa}QXwZyYb9LR3cioZ4I68RLzGo{32@JQqX^v?Oy0Q>*QGSZ`wp(|Q
z@b(xL^jcU<jU$ocVN7!rNE}Y?hpqM^_UKz>BirdblRc*fif+ohAY~dc^13_x(B+^&
zW+ZlPVk+F91U2FnIL^9DGW(<!!dZB9-5<GxzH_LS#QYxP9E;J%q;4bVQ$v{T)Z3Me
zZMQoO#5k}T^2Y&EG<jB)*z{EAn9;?NbC%!tkcX13&t3eK`P5LJ!hp#~QxSyzM0ZP{
zedoedp=6ifmV6HV*NbXi43Y?NH1}}5NZ?rRN*_yv!aRnd6T&{K-DDga-X&zNJ4DwO
zyT|^BWYL>QNnDy;8!)kt_j8ji2@+&$wyl`6>d3Nd>&|AC%Ii-rheQ$#P>4Zi>2b9z
zz+{cXhvZ>+xpz;+u|^13o@L39-*4^8p+7+UvtqRY_0>~)1=SuK>9XU_wYm3a#Gpze
zg31Ln9SROLCO3hEPhWoqHPp}EK70N6-Ot~C^!A|wZV=bB#$Wc?nQ{+o9qmFYgxA91
znP0?-yasTW3xiSsC2{~JH%=J<{+Q>cBtVW5r(M@}n&XPu@F?KA?p^y&EgYyzVMWuO
z8$8Bw`>ZoB`H5q>KMZf5UrhDtEMSiFL+X`o&6+p3$injvb-J0+ptq?yI$>ajKkW=R
z@Lj7=9BnGH(RUYsXAhnqe}4N#NMCqlsF(`xD#VK20~C4EymTC^!D67FtWk9*6n-7p
z^?*DIy>>=6YsTrM7>mjKaoNW3c=iBjc=++`<tI@Gwy4uZAvS5L?q?BMOk1a9zva=v
zW7;yQgc;G;@C#Y1lbAYyI{<JuUYJcrBdt^nVI-oE?wosgIn4EBo$Ci7sThE~bdm{|
zkhEu;Ds(e2wRNfh41R#JZ*wygR2#iUHlICJ)0PD`A$JX+b$e<`{pR&Y|8HNz|JM(s
zw3+vAQGrY_k<sMf33CI`>ISb(jLodZD6DaI?a_L{tEkmUg`w7qWO|najWAGGwhK;o
z3F@Sej(%()V@*q?mgB(gGi0OP{GsfsBUG|dRjpv%E2&yI4+eo!P6PJ(fCtMdgmvGG
zGBqxok*NmMy!qT`t}xV6&<`pgd*%wXYC^_9QA7B{N+)%7qN0ZUOqHL@FW){5@4KMp
zul6RlSUlWwbU;2TA=N_vRJGX|M`~Wb_tjLoX*+zR25^h*XjxT$*C0UJ+epcI##FGu
zP)*s`xVT<{{?5T>Db#~E9U3g6fp{)_Db`a35y3I}E>+Y802~aKX-NLtusUL`bi=wz
z9-B!?$zC{M!k2UyPYwg8dQ@s_Aoe)!9=j{LhW2#jAhcZkWePq^c<xlw%&K0rl91Zy
z#BTLC{hmiI`W@<iG!e6*5?#1izN^3Uo$wEKIOxGr_<;D`kHXteFDfNh`|%-n0hoG&
z4FG<o!0x0pb81Ha^6e9@k{|ouzJC1r5x<6i{}&X>N-T5h7bySY5})PK;W*SLGrP%g
z=<v5Iq(gSsf>CbKQzXg{EH~M&JjrHNK}d#{jjH)tby6}%h7Oe7a`n8(*r4)IbbuS2
z6#bq(u_T&o>BJwDmB(85gvXapk$@xVJLm-2kPm7v_+Y*^)X&Qvv<p{UbJhc(jmjgI
zlCnsu?~O1ky5zV#u+^Yq8=sM}Wx=w#*Z{fM{00$+Qp&M=q6_>Qs8|GU101O=VfGdU
zz`?pMN>Xz*dALz`5^d#8<UGSpHsz1hML)^gVPLHiFCb{z4xu2VJdkJGSG{uE$j)0g
zg(js(kn!6)tc`ji_=+%fi-PxonQGtt@byE8$k1*~sbDF`J0$Txl<!F#A)34KxIlz~
z9td)-fwTW!=^2NT@&2^U(nUh7FunZuz7ziD0(HjUK*`e7)Kyd|jvbDm8^w|82m;;K
zv6MyUo#T{2s=>l$TaIHxPvSC%a#77G0(@oV9Mrr+Lx1N@?A{}75PSn|@q?97HF2q-
zhDU2hwt!?=Ha=9h5nG9ftKPM#tTKScr&OVqg-G7HCY8dqWad=V-3MT2n5-_;5}Ygr
zj9q%8|1Bgi*aPF9+F#p^M!-37kkgFAMF~F4u`rC5^VVoF=<p@LUq=nZiC9f|Mc+G%
z{3XnixWSU@{70$V6=AmvgI<defV6Ge0?xFDn`8pu>)R@N+Mi{Y&C{A;ONkNM5oM1W
znR~q9q+F_ACU?Vp!g<efQWxOzLJRS#uwIf34yi`qcg>rM#>&}k;q7yueA}KW>^?my
zHx0-o;4o}&)ZGH8g3p1Vu<eTmj9c4b>OQR6{_LTlc|ml>Gbz>s>R)4-qV}-^?%{N}
zwLg?D3L&bqsgVPtOC{)}5A?6EzkB^v;%5E9c0ErbfK>k<!rp92mgC9}eb29OvdwOj
zZ6f*3wwClG*V;UWjEKsZ5JP4~N!P3;>I0-V-TR~l34j9#4q$^MKsL<^#s9i{ZQpBq
z6l87U15Ta8b24La-@b=6JYc}fgAiDN?NUQ2ExIZJ`YH}ML85=l?b=?sg=x`5sNPzn
zT@Kl}i3MuUM6N)&sgfRsr_KwRg>1ZOPHxyPXP3R|lzYZTQZvEPigB}n!W7hi6)pZk
z1C<w9>?h&=y;r-rUnq3fj`>Li%El*7982KEq+YZk?52u}7l0(aHO3AWFgNOUD5btE
zNVhlyp*9QEV;H`$74W29ban@YC6@Kgy&Mbuz%4pp92PP3JllABj)3OKg7O~VppGQ4
zSiV99(@#y=l3jK=1Of*#GeE7UFDwcG^ko5Clulo%lhaKBn;GYVx~P>D&^F4gCfPU^
zQX{`u_W~tpaakod*r7r+BsX=8`>?2HJ9;qKUb<vWHwMR;<&jzJB^8xWM17nD2~B7?
zm|&Ly0hZhcyrSXIhSiie@2`M;eA-7CkAbaSwvLouL*KD~9j}3o)Ej|BS@Q+D4<~&u
zsrU}fX*ghgXKg$HS6W2Q`D+?&RPyIX(Aiu1lzllt&!CEue1|D}07X8?j85B%24Q;q
zsJ>jLDC?;ey74xKd7Ue#K`&1dpoV8EMFYT^J}*A0eff($@#lluNGkrywP4irttFam
zM6(i|tGWST<%C`ii&|TJk<_Yt$N?D_souG8VcP!Swa%E~ySQrYYNZ3L2K|FmN@0hL
z1S*u(e6VU2WwXYYu-`801VBN6vIgM?dQ94Z1vGWzf-%La5DY^+efak0@cL_8#5ndg
zXBoiw+csnJqR&+30Z3HYkK1tQXdZ#UkVWWnrT(Dn{Cq$B@Vlqe<@GE6N>85@m_f@t
zfe@48>ja(co+n*FTFL+}PCQGZ|L5?ZsS}l<JW#u3iXNRI0t7lRRB-6_HihMFeRziO
zuRI4z^Vgh7CIq=XgIV<vsrBD&n^(?|Tu6bgo@Pa_aH>|-7;_LUk5E<uYIno&yE>{r
zR+qWoA+NKsy;g;nS}H0|>Uwl^2p(;;9_PM*_>@2Q0uV<Yi0V=fDto$?-9=2GBxAk=
zcP*2*OOrHF%Zkc&>`f$;Me2}!>W;hmf8AA8Yn*w0fYbJJDdoum0nU0s{e<N#Nnd@x
z+kCahBF(<c-Fn%$_<-##CP^Nkk>e0Mi9ioGB7>$5#a_+&EJ2Xa#$=)j#{AVXsX2O7
z!G2XqMC0P^v@e3RYi9xuT1(1lhT41~Q(ZH7iHm&ipg#g6L~TQ0S?mIlrZzkReA+ay
z(IcD7;_O0wQg9By7UkIsoP{rIxIGNDB0|YnKB;pS(~;r71^5h3B-dMYMCqnf2}1C3
zUR?&1Hu4LYF)kfkX$8HP$-*{K<G=nn<olrGV^9#NE}+ZV@xZ@cLnDt2Qi%tWc6;TT
zsNpc4jsUN%OM(JPu0R>8GQ3k@r{RL+>^6|{k$w}ADc&#jT_-AT8BwzsPbZGuEo7-(
zJXG0nGo1%#NiO~QEg&NRe(EUzsrFfNUXmeHqIRLFVW7{5{S3gE@LDKJ3AJ5Hzn7MU
z{GCb5uPv%sd$q7iG4d}Ov`*~@M48Z@;6bkkK#^1TNTr(_IdV_%P!EMQHjuR~Di#G_
zTn;nj=!Wz`g?MV>2tN$p`ObGNN>E!^mHYC5w|6DmRFz0LW?FL8r;+*yzrgLq?m>+b
znPb$?-AO5~M<!r6<f`g$eb`z171I{)a-e<c#$!gHupqX8s*YD7`{Xj+t@}7BH>yqg
za)2t!GFjCFFb2BTBbDeH=VeRawP_<YTQOl9vH-Wb@i=nxe^S*m<;;Gdl#=;ma7I6w
z`fV#)4vkm{h|b7KW%H9ACpFq9AZ-7b9t-BglqkQ@p|Z~^!N|$l*YZrun;RUe9tI?$
z2u2Ak*1=CJ9pThUhyjhQkL*C7;Hv1L^b)v_OQZlu(iaEsm7_&(A}KwUot%~and%HN
zrN`y!Ss8;9F&%<rGwa_?_DH$xofTB;1J#E&SyxE&1CBm2liR543C<IR2_uXarsOp)
z8R}Mh>u(1YObLkKN3C#Dn>Z9Lv;K<Y@UtDPAVTR;%#|`o$<P~77SlRw4x|#R#3bv+
zds`q3Z(FQ!2(2X5hI|NjW{F3p3~Ea6wvh!oJy5r{9jHNB3b&{FWQs;4HwV1Uq61(m
z9K)0x43F=AH+=WIDG573TczS_r<6Gur+A~JpnT4-FQk4z`l&T`|E9QXz9JoVox~2R
ztT!l2zT_j#BYL>1nd4x3Iz{+EF%)U4)Tk=tgxRM~CoBb$ICQoBmYhpI2SeQzZy_$d
zP1L#sFlr%rkfLn+qT&;E866e{{O-=l8Z>f^LRU9BaXaWBSG|+^9%|J(mrL7nKt%t@
zS+4Azguk(K7L7p3AaW~YfqAAy9Gnyh%FDw8d1=<5)G`e71-7d@r(YKEK&S}zm2kzk
zB}ewdoj@U<;e4WI+O)E-)TrFfMzv87>i`=Vh>_ZkySWi-Co6Hm*q<m!DX^Q|X@an+
zK|~<oPR-cO$3d#TB3FUBZ4Gd~c1+I|5M~ATCaxV+T^7awl_-M_OxjTLNc?E2DETI*
z+0C(FTOMd(m`I3E7U95vhJ##iSdy@UJ!+}>kZRfbS5iSIiB{Y(wLybIJ;$=xW~~zW
zo;M)uvcoy52cy&}mr)k4g%(oNitWV3fUriTPGmOyZ&Ac#4MvX#3J0(s)u+BkZ=LW!
zD6ro1wW+eYN-RhYTy~&iF<643v}WYyW>GN8NfD{-6tXTjX3UMQiz7{mTP7$_@^*89
z$~|R)B9NGtrfroI{iU?&s+}im+1CKXuyx-<Eil`Tqu_9u>mzIE;&KhCsfk3!*nz54
zsoU6kgAZJ%Bc6@WC7m^c<?Hq~J%+es-9sWS4uElI8xm@Er}E~eQzh%48sLuJYH~~>
zQL`5hq%t%p&qj3MCZvD5DVCv^-P&uH+5JV}Zb!Nf4#f>9loZcUjUhFc6Ddk8I^sx+
z2^GnW+r%{SnmID^(srqMa_c|3{V6FH%vF?J6HQA=Gg%y;5DMo)-y%)Xmbyeur3UkI
zq)vmqh~hCBmkkR2oWzBfU6N1`xp*ifeLa}PxYUSdXKt2q@9toE*jqgoU*Xo8{)8ma
zPxxzE8JJ<h{3&vZJ}=xw2CV#yz{;PeGc09Uy&Pe?zv784SEN67qC%+KB@|#efCCi_
zXUY0O+C=kDa(}|r@Yx>cLvx1~Zr|0Eb_UB=5&!9L{72=<zJ6?5|D=3VkFqRb5KfaF
zd?O<{&Na-MxOFp`96Ek*-l4qYNzEP|he;dh6wpM|QaejjA|3Qy)UF+c2Vo)#b?xJC
zAnyA}7SG951BIN$;%;?-8+1>4Hrg7Dm3lY340qBjNxqN;+T#!+`(|#Z6=Ks1A#7nV
z@*Wkod<MEqa&p(aUuZJzOx!B4=jJ6EE-9-Zs}!);`53=kQWCmA8IXcCMW>7$oK`MX
z7t3-vQ?KP<wG62~WzrBkfIxYjzjBo)CcCA_a6~b15beA!84-BbbfEW;M_jXt3hzw%
z(GT5+%Q(vGr`&&sdTZR2|6$XTo}%n9W-}jJ1iao;{Zwk@t@4}K&lATcQMl8F`|R!K
za^TIdgz-`XbMKjKATJe@H4jQ4sKzrg$vJrg64U0=YD905>h6AX5#s8(Mce`=31L-~
z9??c=L!xAJb{V~XkOKIa(7FaIG%0Y-mlyRwL;FY-vX*@;$yCX5K%FgMStXj>5z+*~
z1)Oq2R~zsh(yha+N_GAKYn|$!8NRaVn7LYzqJ6oU#E(9nN-lFh3H%{xJ%5y*e>nff
z&O-DGraqT`bta|(>3OB8kUldK#BmDSR2QaBYUssizrhb|fs(IXJz4?Q4pV`o1%W-x
zXel?7;xJb@4MDg$sR~-lLwzr2(A01SPK(>x?Xp8A^+AHjulF5hs%OyGc?eBm$6Bem
zI)ISYmxCB@EuXE;?25XR*)>JGn6*OxK&|0~{1#^ojt5IM00Gk@!44RbKz}F6Nej>|
zthqu_0Q6=;;f$V=O+9l`@7^!_^E>^0ITyIUO#y^RdsO*6=<5M`g2;o>@CG<Rwmz|@
z$UkpLABdpPnWR-pRjT~%@5stua#Z^ze@!6-Y!IcOZPR6J)dSmW>142x9(9(tLRZ8<
ze~JCDNe=Dkvux8Bv;Ekb-LzA}iw@&u*fgTpz4zomcQ4tF2HkU70;_88uVra(dB!kk
z+cNz#71+@H2ze7Gp$N;+$(CTPvWF?`KnR1b^+k~+T|yd-r0bUNRBF3adbVc41TU%3
z3DimFD-IYb!|=cb1d~BDT&wIqXCOcQ9R{3Mg&5&KC$k43HVEa>kx>AZS}>5RNSp7_
zd|h_KTOt#1=zSX_t|1+vVAT7jza3JqF9bFdwF|^@$t-`U>|la1d{+YH4EVnte>mYK
z!AD6xPL4~9{o(VHLnTojiGyPYk@n<U`NGD7xRVhzpJ10}*B%zv8W9Mvu;ZdjBc4k!
zp?!XVihpqGdQp^aE{`3R+q5YXyA6m=83+eUR&ORX7FLV%)znMw*2JP9kN{;VJw|>Q
zzR%AkND17h&>5ErczjRtUtYq?OL`fP=>^wcnldlS?$Fcl6f*$$9(Sx(ue&+gE1MUv
zW7p<fXIG$KM~()j)!|wEdo46)Y3Z<FN>>14M4GPq{mR+#hu2Tjf5Z7Vk}Feg0xh?L
zhhT-X*UqIGYJ(BP7SCdkGE?6G!IJPQQg1ERjY$|uo!?%FO4h~@{+oUe7#gn;=bQdF
zoPT3S7`&uCK8<n;yB2w^wWrOko(!4LIdjI^@dP7K&gWNlZb-GbvMa9W3bu9;_8=Xe
zo+T<Y0wx}<b+hF7GsMbOveJ>XP&L@H2E2;>R@`Dri_VwvSule9-ThRjTZg$nLGYMP
zW&w7U>9Q$H3_D<LNM4MV2k_JZ^<^d_d<4LTQxr{(#(h4+q)Cs08?{Le@7mRxub_8w
zG<Hu~xo#@cjpRu-Cj)6<u+~iNf;$7hS?+u$M<1G0vhLAp&*HPFSK&f{mrS!eG*jV&
zYrWLc-J{!jO^`W@2lr6HX;lgqIpRW3w}%zQF4Y9x^BzJn<WiQCWEd)Nxp`L~J`%sh
z;6EL*Q~+a=Sal5quNc!Stx%9hW5V*_e!M|1XoZF!wd^a*b79^3w1=CqclMBndFBb7
z@y4K|9Jr2V%m%PCHYT#?^ff(T{5AK|p=A`=x~lnRt3^FM%#5R-rkmnF&@o$?QmCx$
z1!GJKWl4#Fwm;aD<oDL-(OX*iV8Xv5MRQFsL}uBPTX;$Qc!N#CmW@h?`sUI#qQ1(K
zTk2crAl2wXf2Hb2Y!?pq(t7vgt3++OsVJwBaN$v?Iv0&ugQi!AlzF8GI@=t@h+K8w
zSad>}bz&Yp(GnQspe<gY51c_)7_`A0{A7)ml$x`G2-y*`rIN!VM~OSq*Y4SZH=Y!h
z5MA^n^&<=b++In#c5iRVig;G-Cd>Ym26SctffDq`x6jibrBe!#nMAy+taNn73$vt-
zTaTVJ#3)iIkhcjbo!bRYZYCW^SYUU<u)PO-ddw0+kLjez1OKn6E<x^WkyJA*fysmN
z_5_G-rjw)@YD877XJv{pU6BO2?A1UvPmWVH;0Q18O=Da~Hf~eyPry%g#NEY|s<W|r
zHm-P5EBKK%lCnW9DEwdVx-+U-=gUBqsSYkh$i{UJI9}AG2)Y3TPLy>PV1GpQ<%tVB
zUK7g2ixxAML#cNcP8g`Y-#g2B)75EvZ2aaE>h7F9e*NiR|0%rv7Wb@jq6;-{m%X5>
z1t`guw;wRoV+$R|WvFx}mrJ^F$|mtZCHxiD`HU$^oV#bo%^-E13U-4rcI{NE(=x_H
z$ZK5=1M^+=c|>QPH-m{MQTfwQoaV^TNGx{AuAq!^nySicmXNS#{v+%H_F5j2`w*kV
zO=DwOz@=RCmXdSZXiwxS%L1qpI@OjM0SB<thNd2{s5i!ARz0CC>=b;)w<vMs^7ViF
z>wj@Gt%(ALi?)~aM-WETug9n}Jwenn4iI;mf#^0gw<R(WX^v~Bd-SNL955@{zyrky
zM`c3m8Z!D%yGzjkv7Z9+F-h`BbZ&xE4ovEzvaeJq#&Ldbj;@vkoDsIFE}vqIoZNQS
zqXVQ~j*=hlgOg-ONDJZ7tJ;8PB>T$8u6!c0g>fJu8sm*sEGl_~sL!eOSsN%i%H^UO
zJ@jjtke1UjyFAiP_lV?Q+z|2s^!@;K*{b4Q-DGog@*t(|yL>17r~d~W{}>L`qMZ}c
z<Dug#E)44qfUvBPmU1$}<J-^Qiy1=f2SinvLc>6m^Q{H&T}xjvwIjY!#{@+UA~uxQ
z;86JXd+=jEef!Jn?=G4KA_d8QzXqjh0Q{^7<p5U?NG>g>8|__49na2ct!ONZB{Py@
z#=ja$%kIc?kLvSt;2j&tctc}4y_A~#&`xQlCn9`$<``$%^U_pjy#VE6eR^mjvRB?w
zP3Z;!B3ah{+hsYvNrt|`N>G9nuC`%};S5b%8BMJc-JFfcsosp8;)~K6fOcE@>u9&o
zjcPjE_M+9(jfsH?=z~=sat_1W0Q!@*!xn1!&m}A38~AK?QY?8-H+nNef`F{MgB#;H
ziw0#1M(}L&$uSwTJR8&=fnjUmRfCQOLFD(iXThgc^>`H$)9ed?3=nun1)9lxn@&v@
zh>c;s3-Jv#CZ)9w9!s}rnw$SoY7S*d*QAtDb0!7Uh8=pNLQ3apaAfo4QCIRW|2Mt1
zM;u)gxd$&6zCG#PU}S=c1h;XY5=@SWp_s5b2#PGEj{%pE0}5JZwB_h<e65OywW3X`
za%#)M%|Z=!NFC|W#lNXaC%ZQaQ`6`~@g6+mn@gEGrgx#P=3vZm+75ySvdaU-5Q2EF
zM)|o!h)P_7{Zd^$ynR@z8Y8?VEiFr~L}`t8Oe)~5czW~Jj+o}nfxwfhd;$u}h~8-X
zj?fttuser`p(riekac-E;L$?}3t=zasb2?u3qz4t(3tb(UQuQeL0sRQa(wiUo<eD=
znTrYpSw#b2jvbitmlYzt#eCzlmP>c`EC&TUF?Gjtzo_uML(4i6W#mXIckLoFd6-G8
zkqs^9Jr(j(MNOieOSz*CA0ufY#iXgc-HP(9Hri(=83A-GZDxT0LJVx8NH3Ajc#`qj
zJPQ&m?ANQ`)uvjzEqoxBu2-=6WG_>89SU{%GN~(T60>T5O;ChRKXh*9h1|M#ku(Tw
zK9+2!e1a?66DkX8U<G4FB|+SSZQQSaf!6I$A@adai^?e>zPYWpth46~&4gs<O6&RF
zHM}4^*Nsl>P?c}xPe90T@t9Whu2e30{j3>ssU3>+O2Of?aEb#Dgn!&|?&u<F$?9IF
z{u^!}Ut!vkhF^a<MG}-%_Jj5$h+Vu-t^}lO3bPH(;@Wxz)7zzNC>16DAH@hF3r(aj
z^VHGoBWfRH)SX<g(F%}~vMBLn(HcFeuS7NnD{a9z6>5O&0z4GoetemVRgLA$17rb7
zF=AbH>sTMUAyvpPJ+vmc6V5PN+B#s?CF^di3G0KNa(%aF>d2bJ$)%nocB#Ywmv<eW
z;PRCofU0M7naWma%kU&cCo614Ief>!6%w(RZ-?*xI}0NanmYX9sPVx>sQ8qUtd-(z
zK>ILVTzmp^-O&KIxCNRFGe8V1aVQhyT07-THpe3Q#5O%f?VoJ5>n{E{FPAS#V3r>)
zN&@sr;@3ZV{nJGuZfVkB$hfuFLy1xXH4scVG%bx;_Og?T=9#Y?vvY5IKDrkqtR?Wu
z#Lmk>9$o5fy)nyDU_sSgw2FLqU3HcE?WC)*s8CM@i9Zu7#L4B53Is9M_8>$WJVj+L
znZry<#W8q+?6-rg&E&O`PV`+>m}xJmt<DjvqOc=gV#L*6)Tp9xZ2f?qf<|mzWp@4u
z1tgaOxt1Z@8Jh>jUZg&Sb`N0l1-nm_)<8^AA+T4!C(e>)@LnadtjuI*;MZJycq26j
ztf9{JIkk3n`*}?HB}KI0tL<T5<4c{qaw}sZu6bloDDu{h6*wq?X+j@B@T}5}{=mTF
z_mcx_w`I?`Mqbb~cs~D}4`c}_cTeR|Jy|PIn>FmwJR5rIa_2-z(w`54@hcU)h8wz-
zd|W(LwT53zk_t0~h2*{HO&_J}c`E>fX3nPh;_o$}B$9HcBF|1TK+tU%Lw$1eUdKxt
z2J0~nl6yFCU(U`OlS+sPn(Li5`EiCN+qEk&vi7Mf88>h`?b+Et7mb~wICR;^?>hB2
zwie5?gSW)$0}b`dFvBFNcZJnkTmW2-H|Rv+_?G98?(Xh$4!}Lw?pz@g2+6ul_U;Dt
zY}-T5t8R8R4RR&=LfaJZEC;S5`KDgIc2G8+Y_!4eNYX1P_vw5q33{gst$_@F0^%~%
z3CgF`E<ed-sauW-%P;^hWK&~JM9Uo2RGkpHJ{LevH$piV+Qax+^_+-m7BTx{0CiCF
zPs>DM9Rq0-*SOT&Lxqc6Z{glSaGj!3D-<t?eou8N@_}5s9D#xS3$ozQvqRZ5<5)K~
zD!QI8_L|`yntm!yiqv0!`1U0=Wgp#`Wo%>*N!~qShHV{BRq=H)jQVnp^7zn?1xY)p
z!Hz04hLJn$U$<~QVddPj23`;KrGYiKeC$vJ3Z~Rcck{YFUZ*9?{v5<}eG{~T``$SE
z8TXZ7V(JP0(c)y3l4J2zpehcwv|;PHU7l20v?cIy1iEIa2`O-R3J#kS87pnBsSS{S
zP)8Vf+0j7}p0r1omWT8OIC6FzowS%i)6xN}EQR+Liu<ToAhm+Sh~-^38}CRSButb&
z1IECg2=ntmZQLH}tey|f?BY8)M6c(GR!DUyAG`v=d-!3YB;fR$f$}!M8UT!0@kAXW
zq+r0|PgnHa@PFIky15E3h8l8Lsy4q^&n&}IM)?HgDzVs^-1H46nXa)KW8+m}LQIkh
z=+B+_l?6SNEFb=jWy^mG-~5Ab{ywcc#fCED+aP-Cy2@KUuBab-6O==kd4U1$^zgY;
zs}LGe*Q&bglwXrpP}iJ%ZHC>6vc>KMMxAuo+nRRBbFS?)<(Z9~vy#+i&2ihU;ISnd
zn>>tkd{k4DJCZ<b97H$Bj$1nDMm8Po$eZci2>MT$G2YPIvs-<N09Qy_rxpbYuVae!
z3_<;D?1t0_GAZdEQM-~qUdNl}j61ulMRJ|bgus1MY@vOY+z!-!L7-SE$*S#Bjz-24
z-gOC*RHI6*RXZx?=G%^u3-c$PPpRHMFaJ10qwa7!0z;vPRRXe_*g};!-gwMOthK`_
z$@$y%>lU@-$;><X8r8k><4aOl{(ta_Y`Ohv`Cq85GKR~r8gE-B3mf@scJK}>1=bp9
zD&Ik>@3XOTTF8)uOExxllwoG+hiym^R9J0WsydyhZGHl!>|EP>j;jFF8;+>MR6)Rt
zkcnPR;5zbKB{@KS*cB4LV1WXpqqS8!urzAo=mB?{0<1$MxLLg!N`pxZ64N=EY>!5#
zN``4bW=z_LtcIj4oPJwQI*U{bzt+YVQ*dgeLcZ)bgIk#Yjy65$f5D@uXON9(W?C~~
zwe4AH#seiiZd(T+Ln%fna4~q-I>}edo{>1eb1c>?iqRv?t$qYKYNaw}cSF17nhVPp
zR4#r~^pJhaq^k^!1?S|0UA|}IT<z^Aub;xI;hz*-BYQdBVth$j3pSjG(aM-o`i^|@
zo1y9%gl^$(SYKI}ribyv@b3~sYn7ytszkR#B@!<E{v2RT(@zK(Y&*4+<X#2+bc%ph
zZCv_f3Z9%CT%IH8J^BNJv_Hr-c5Yp11~$3uzHFHx9GB@CAcjn3kaJ5C67`5pzCrG$
zE=4l!=v6K0gj4)P(yKF!HC|Z^EKur58&N_fJ7GoGd-POZjuEZF6hxw;;|YmNBalZ6
z0s5pqoj#>@pU+!2xOY!Ct||yWmM7S^75c#Zyjxntu7&#2-GRZAcz}PvN?5W=xN+h{
zo4cBZLX!)C12R0YOM@PSg`{mg&VWQX`ohpx!l;Rd-p^)Rc(zu;Mhq=UCPzL1&DHd%
zBq8&6DtX3ed6H_##)%UM(9;$s$%(SdX#=oQ5+6^9iHF*O?)LwuX|*%&NA`IY)qk?;
z1oRfeJ7^X{LFwF)m+U&d_&cv?=Cc~nb4(wgFhg0=YaN_pgdxl0RNY`3SC_d8GkOrC
zPAmYOuV3;c#$Cr@1ovOj000vVBeGaRZhPfucD0!q+#8qf1pDbT8M?z*UJkEohang;
zbo-);qitEDt|B%gc0zj02Dk$%BM>r)b{y}Wqtc3~e&^E_f>(y#{fJ%2KO=PB4aMAL
zJi}8m^zs*(yIK+`Q#4mBrX0YN!!>mPEA`f0R>hNTyE_!Dxz?8Yz2%9C5v4a&!UuXI
z9q9_j5sWs`-mt!eyzUu{#`F*VCj213`k%f2(Req1{gHiDr;^P6mLOXq@8swhU`lym
zIp9>>1>XtZ|Ni$=gjAbqD3E}U_TY3Dm2V>j(=khmyPO)?F-<RH0mU9W<g^)V)!U*L
z%90gZV^)sIRlCpg5I*3<KgR_Lc{Wm#4cn_8C}w)|gj)LoN<ORi>FO?+sEOX`6aoWa
z&||3(f%1kFJJo=%YN|#JrzH&gvNy4sR?oLmZDW0?c+(AkGIy9<GLX|z$y?Vb$$p`(
zmXl;+eU}0Bps7?{snq_ufsZE&>#IxIZmpvqAoD=Nr`ju*_*itZp~(Xb16WSh07w6t
zfXezg`c2nmc5p%kXbmsSv>f$(Kr7V-axhw2kfn@OQd6_b-UINpGcu1>{RrgYvuuRW
zzm>bnLMH$fic9E26n3y^4>{eA_9P4uf)UB2Byf~R^6?|TwE)ZA?KZv}zV)qd<rV)W
zjl<*zTWmlV@grfbN1)6Ik7{*kV-hp+b=^+Z1UOieGIs4!2yw5v?0X9dqJO^Zvfhwk
z_dZKi?_DHG-&lm)8GsJi$gdxASp$4N>9sKn1ww3<{wgZj0x%R=gg8(KxQ+H5i{}C=
zGI4Jli!;=jZz_i~>CTEJrRA0^$$e$>BGvV@FUC44BzNk`xdoTi07Vd;TV<1%1=?ZV
zD#x*dBL=|UPRG%gA%#~garU9nS}%5Ww~v(B2``b#2`VpV?Nl_mp`(EvC+AbQ<;E^(
zZ))$u9v2km?BynuWH)!00nkR&z+Cf(w-hCF%Hysh-|4mh7OQaRzEVqTjuVyC>i-^~
z$ZnDqlVlVDL=82zg{61<EM+C5ylT9khG3tEzy23&I-`n04oEJVsDve+T(Bfm>H^J)
z6ZB`9K_D();k=lZZ!i#Q-MdgVtVw5Jdm%__ka2JhTrBC3SZI~C)Qv-)aH_1>daJiG
zqa_#&H26)|B!teo1nZDUY`CV{?DD^<A|8Te<A_!y5==`0`x?Q^Ue{dJnsQ`XA5xCV
zF;j3gHxl2#j#UWQp?Wd4R|5K~7daw30^)H{W!ibd#?fIHh=-NlSmT~jZR&qo1zSZG
z{Rd8H^LG!6j;}6{Ag6!@=NS{~HZ%r$>fs0HCJgd^u*M}o@TER=p*>6ykPAa)LFB<$
z7{$DAS}uPZzMu3q(P3>VJFpWi_7qF#saeOj?XXiy0FcqB<#__~w$aQm5bta(tVZ)=
zGMmU;yaxRn-_U?HRXgWRp6>lpcJ|xHXl=qxSl-)YNa#{CUR7zgut<jSj6`UAhb48r
zpLwdc<=`Ql>L;~Iir3nXKefN$^b!0aYNX2X2E2#`wcSljXVnGNwsvgytd3Axv{l#_
zMte6<((Ppc*JOcrKCobq=!xp2;>6d^X}<DG_f@^JaVkr+K>C{#%wLl)_G?LuRXuJ2
z=mf4hg!(D{JesAm-TMjY%Z&ar>t28$h=k6TW}{XE-lYF+c>QVKIuJ!_z;|MAMS>}i
zb2y9N(b~S?WhPrYY)0??>Dx;Nu9`bxogA19Fz47Mx1hGmezFX#$aO%V*i=UEiK;`g
zS8}Dcwo(SmQ|x#eUo&g^5yO+DK!9IKNrj~jZ6Er)+;O5B#<tc+;Rbvdg4n4a3Mc{<
za4q5lFv1@P&U*!5MmJv>a?1MXq`=EQ)Cv2n^$_tr^{H3&v)6wK_CunYfF*Y2KudC*
zeokJl6^Ad9u=PlLr6iajKnGNb9nPw*s7DD{qkz$srScT5-=V(TH?lgR84Q&(E?1Db
z%Xda_gX>kcIl<{CL|M1Yn3VHOoKXYC0W*rbDl*!!J*n00ENy(W%_srLX*?``2u~(p
zN10`~h#166G&&84Yx10IcG*!Dpp*dUmV1zaPMuqzlo-Bd(zO7jMmD_p&{LL8Iv}1V
zDxjyl6b#2sX<$qCU;!L|8O|dM2)8Cr_yb-@)J0gKyw+oX{n`gtH`U9LvuA<-1#}p0
z9&&hj>K&z?aN0gmadPLn>>5hVU=&HoV@mQ(UIe`UG@QCP`?xq#UJayA;{sTZ*h#vp
z`~$W_6YFeDjVIl#R-sDDcLO??B_?3a4AJEaYK5gvYsnrV3DgKxP-XGWaF1n4n2ePx
z4>+L`*=KDa+jjHqM)_o9PWKcrC1EIJjUZ~<grP+O4kZVsB-%VjPE@G~3@f9gVss~@
zT7Kt^)Z8Xyk*QRMQEmW7K)AnlJ8Oj$-SlvgE|94@DG`VVxH(+!>rY-kLML*l>suJ8
z5CC&9P_Ua24@*;ES6nG3$+rIj=F`2?RdDT`Z<|^Q9a{ae$kU>|%K2*Bwk!iNU>Ftv
zXAZw7BhDk)L62o?7a!RyNz=u5Tro*p>BdZ?LB|%o#0~?7Ma31ZaR(<5i5WL*!88^)
z+vU_HZjyUToE0p-5;={!`EVV`M27zQN3Z`(fbSkofMAKQc6YJc79Ep8)x?k<Dr7@}
zc1)Zs$B)Tl#pOPE*(zk%qG3_^kWVGBsj0dz1%#>N;xv@*WY;1|y~4`Uxi!g79N5{Y
zx*mcnF*gQbikVWS^w;Yn6H2bYnx`u|=?sDU!6Xhc5{A*e*V!IM!Z)hDgS-LxO}lf9
zp(Y7%X)`+=cO+_17IO{@COafB{V79lX45Jz0T5@4Nw5XrloNvPet<#X>;DCi>VLj|
zjz^~LZq99>WQ(<AU97oAIen{ZR|3<{9o0O_EU0~#n*W2nHUjm^l-TS&wAZ67t_ACg
zjnQGQ!N)6k-k@qD8wPds<q5)fL#^g^5E`r!doSL@wWQB4S6zjvUFCoR#E-?s5|?s0
zRLY4BsS@5S;D{__SxB6Sqe-Y=2@k^aV8#-ku+3qiU`Pes0{<dMpG7c<sjv}u{k)E2
zcjV-d6mt%*ltzYXyLY8(j(~rUMK@K43UqDqeZ4|dc}k-tV>z)z$%dQsy1OwUa&UH#
z3TWD{lXp_tNqN!R1bK*WXRh6D6cWskLan_^TSMeWGB62{*7Dhv(o6(a3<RZrutya}
z;h0BVQE!U3?#_$_*_^|yCd3!#O8tHK$G=aJG+G?mI`Ci7E#df5K3(<$Wl=0ZT;#cu
zC4q{VTS89OGOBSm;IvZ3$g8d<=eTY4P-fL(z#}jKYvF@IN>d*@m762<TOE`yQ8hp8
zp>`4v(qZ}FjXZd0LRfk4Gp%lzmN_+s>;fS*wGvMuX(BKYn;)@o&7_dbG(b+!$(s+N
zLH;&;$6nzco;<(l;jG48FW=&Zqf$%PXLWFNdMrRKNM{fPoNEEjpsm#ZF8PoA=g+|Q
z&03|v-l9YpFshX&KP4K%9+@R4t=>g`w6kM>W!_D+?&>fnblY}j>uvaeftkh-(JiA5
zZNTDbJ9{v~y-P}cLdwD8miM=2qYA=GKToerse~56H~~dA@1{WL&&kUh{h*N3GHZJw
zTW{HAokQCpFV3bO-B6=P-K|R`_Z))&cUDI+05l(KTrB7VltJE`s-1be4AXj$<w)k0
zdj*lhS<@U1|5W1Pb&?_(lge_U5X=O>YkIjT*HF^W;Dx|hq*p%Wl!)r*{x+OkgWi5c
zTYC8c`i6mV5AMLcopgLaMbVRB<&#s&_K6&g^1$*epcn2f2-@JO)<6e$FIziW<|_Ag
zx=fB#ER$3wPsI(o8$O!_*lVjL_rSTpEA8A~Kq;P%D@6{Cex>#h=md))wyVH(V0k4Y
zBU4?|w#`nYe^)H*WWR7&3Olf@@dEV(!+*p1VN;N`g?G#jFSR^F2@)^4BLi4zZqT&A
z^$t!>QJvzEyW=HGh{~2jT}(X+h_0lI{2<&_mYqcYI`i((^}S1#3beEo0+Io`Cpug=
zZNyVReQM)Z%C6fN9Q-|Ucd!d?5Vx^Mt*3y+!h$j4HsM$&Up4Cy$n&Vpg_szeWN)Fl
z=i~DA{{U;?e_Yhi5*XU6n%tE3^siyO!d`dwf66vcJY+i%VuSN`>MPBkN({KO$ZD2H
zVUD4KD_b;PIpC$$@=mH!4m#5g!o8wOClqFsYGbfhvtj_X>^Jl006Wq;l#+o(?e|-^
z91MBMzWW`vFQgAZ5nx;11+p*by7KjhZ-06HNtU(xSL+IW{r`p6UtJD4nyj#boi}yT
zytSxh)pSKSr-aH=RD>(=kMbxi!RyAOmnu<eF3w`5uwWaNs7Di@u)egc5K8-Ac^>Fx
z|2ddY7eGS>N@zUGZPhY#y|mcj0IO`&$d-)F;OA>%UQ#U;ZISya#w^rZ=u{k*C4kgh
zl>e(jK~Ah3vGy2FR?tHSfjji_*&@9HfE%)qLWdNEpDdM5OCs1cg`%`I0DC`S5+qq5
z!81eZ0B!EHV097*$kIj6nQ))k{qYL*TvUf=pTM|pFp%lCj52@;(LMs~vPoRGUJ@+R
zmnw5}#`huxda#ySt=gKyNM%Z;s|qinZOb~SP;zv-gTo~qlAtqv0rONgz1m4d79G*D
zOb|g)g-j|(C{ci;g@HOODANlHEvizZeMF(Q9(it8kedQ)vy_FsYpni`(?gms!Mx<A
zWQ-y4PmEJYdVb%zSOfLAyBpLRWb;Hq9RQzHE4aPPod&zH{M}!Y1ofq%H@|ee&f>kg
zeWqkga!DfL4Dv;0W;hk6iIn!l`bZ_ly>>6<Oy_egki$M(k<ki_1~8RqX#hA3g0{+g
zb_6?cRi!tU6jg3ryqmj@cLY=L<g#rBRytt<{Upx}@Rv=~dt`79LdI^wSb}XWOajm+
zaai}MO;#t5gBrtK#9P&KTpWCOV6H*5l8QJIKPbWM-N3e5TuKD?J!tfjDau4UY6y1y
z???Bd^1E)MB1c{<af*P|Z5f2Tji$vtW?;=29^7K3;;n5U4wYOsTqG7+SG}qWbtrLS
z<R-^kZtUokNm2`vITqQ_Ooo*~D2L)S@4Zu3(2rbLT)Y?_NYWUTY2&n2%#%tuv0`RX
zK)jc2akLJz=8*E9?b~j!vq<+5%tIW}$=yT231jLkb**86C0pFBQc}v1BWcknutvu;
zZ8|=-B^4Z!S1E3D%$K|0Fh`^od_g0O=TN1qe^Qxzi_$9DbNS(S&CO1efU!TY_bC@{
zM`AyzxJFvJk`dj33zCh$@P3OP{1oInDS!fWYOSD~9DG+$b18eNq6>1SL&Q2i*JPbJ
zkw%0vv(Npv)$vB^yoJVsBAKwA;<Eu)<ZJ^Z28xq*O6A_pa<<zAX(R1s1NhQKNmj|N
zmA#}YorX_Cs+w)|<S5wDfIQhmCT!qLk5fH+tl<;u9352c<75Mb%0JpXXsDCt#%XGC
zCjvlL0iZ_iy9mG>-NfyO$xEb8r7L?F^@P;=w=Go9;hZq*#QDzTAA9gdmAb?poK>Y$
zj@Bm^U4&zK4>jUJ%`(8nn`bGMYOG=E!NmTqU?O8DPg3yVKhDIr+YKrWh=%lpmZqge
z+R#(DIC#-26bzvj4@)rkxiUh-|CSC2DqqDG!ZkWJQW6f3wD0ydq>xR|>sqU*4DcZw
z*uneO8gI^wR+GiI-$OJKu=S+w12jZVR=O8b6~JuG2GTeZrNp{{HFGFpy>3rfy;!Uh
z-~s8vFmhm$00Qjlc5;y4u>&JHQgo^#LUm$H4a!<|Bx=?E%~$qNmuAat!xMeDT}EiE
z<#{|=nChp@KZ<&qY7R~DIQk%boNTKl6|+)rq1+4{$1l)4ctT&=j?ESsZ;FAcuhmTQ
zY-^(-KER{!3b5Tz8n>7ccg3D{$|Mby2slp0I8sg>LWMob7P5x#CX%1{MDntB?8&UE
zO+o7pHOE#vAeUqASYU-nNE1dP$l*Z+wstO*-6GNJd!@)E4vU9LGR};LyX`E<6AG4(
zt(iy~D<|gx;teJz*^y8Z$=Lj};2SKbkw)nkEW;XH_4@=XREg+`;%xL|H|MF;Yk}5I
zm2497{!)Qujh2@CB_$*8kPicerjYJ4`-k)L=fFIu17YPztqG1+ZQ{?MC^0DVbJ_3S
zi9-*GV;;z%%Nw%(V0wg7u3V9MTy6^wNhAZ5b4xfonokDy7{O&;T|;J7i8$!N;ZS{0
z!Kw-UVUrY$eV01-Xd&m)kjU4CTR!03M%eU$2!`%E$XK3cX%J0i?-BD*DTvv_+ujj!
zZB9)<3if2=`7%IZVM#Ay*-v)HT~GCLjC>?gUhNUeJ6RlEUdXOmYYyWut;<?o8)oT1
z0!iJk=%~o|>f|Q1;hkF;Fw}NIi}t-GmA4W=5`i0VaXP6r#K$xGHg(crNEiDJb+(f+
z>g$J>2SNC1?rSe_i6Ab{{tB_IvVRlEY{bS6F4{LxOS|`m82q)ndd-HMZOWCY*rnoY
zq=Lx<+9X|o>6402Lh-qNmhU2fQlTmnyayfm{Dii%uNolBvSSp?2}8B}4Im)f$a!$%
z;xb;bzzye<Xs!@xp}c}BSCIwsi`S1Sa-bd~PTCDV5gU>SmhWHaDsOvskSeF%2LpOE
zQyJ8R`|@l)zpn;b>U33ZyHi6ht`rznvr%8tZY(_TNa)n4NEL{NB*K?%4FFB#6I2i)
zrg+SgOIOl2m5QdJ@BE;>4g31Q<S@<0YqYOW=DO|migUyH8Q?}+zS>FVvXiW^$m1(W
ztDanItV9d&qOLpa5Xtf1TKy@hbv72Rg8ajEO?32GP89ooMa_|lO?}HJNi0tlDe+%`
zUtJ}RqUGXdJQ4h%W3V!HZ!8hpn7*!$&@DYDIZFo@mffdyR1Lxf<`()Wxf!GaOj2X-
zCE;}mDhb=2SAgaDD1ZSieY?K}Y<v<hmQqZ1SK)F!#Apuj32+1#?V^&as!+-)=>=57
zSfIE}`8KHmWig!TJfDLMN1nphpQ2y(+1I~NAD_2>vCjN|Osh~ied@PYuWodW`Cu61
zPKe>C&SIO2%K$aM0fcK}M_|=w%PsryTjAT^(;p6YPnTWQKP%e`sM(0QD^YXSTPli6
z6BvASE5=&yvtX4re7;P*1iBlGD|ARD<$G_<$~CmQSY89~M+bUWd$zbLk|K6>IXW0a
z5KkMy#imFOM$(JxeaQnb^&!b^4me4-3q<8z(mRQ*y#6fkhjgW-YqqFK0$VTxj$$`V
z!0}1+Q$i?|I*q5U{Ex!xS5SKlkyu8=1{~;pK7@yES+sn%jUfp|yq{4wB?JXF>&zMA
z37Yp7MeZIEpb?DGwp>HHcsb50=AE*l{uthVsXyP9nn3t*@OCPgiL?tw;B84KlB(&8
z3mO$8KkHAg|D0RU{+sj9X>Cvw@)j|lx8|!JyPX@Q=!kUj8R`u^(p$8)k`x(FDslrg
zO%$&=11+X!Y%1q=JRJ6d?C~HmKq;8iNEwvUTjx@gZM}T}RO+NXJE=8qjlRB;7ojC?
zjGtf<&@)&+kc^lZ7{*MS1@iw^vmN*)e+}RK1B5;k|BxL@qaZMyrsO}CK!dVm>f!PN
z7Y`@CB*`j<;jx2QqdNwILTmx+2R{fu_`whO>LkP@8CD4=_9T-xw_!ddZLl%6Yh_}N
zzYmJF&G|FXR2v3GCK!=zuqBJXtC1vUkSnC(x2y&*OSMW>`7yZ0Gg?S2R2t=r$kKQ+
za6^-bRa9(RuG%-F+|V%XS9SHW60}Rlu6-N05OS?!8HqiG%o<xJ=)8{FXu}NCmB+m@
z*U0b@hoX-<F6Sxw0(lNDHsquIk@--!u2ATNX&PR2W^M7JIuT?g?UQ$Wu+ayJA4<Fr
zb{>{$LF%y+o|8jy8W%_c`WbcEk6PQzc*70nJ|RaG$iV}^j-gCyUM>u2w3xU-%YCx|
zaEp#(YvbB(>cc3h6%E|y`5k&(j!ilXNOUP28M{5KCQ#5Di1Fb_=OYLrTvWutLC?~1
zlXi(!#de({V3D2!Rc$ld*7bw;1r4zBNVpX0PmS;fHBvwW2hmLYt<cU^u8W;SsE~P1
z&fU5F4)KY(@;Fu05V@M{Arysc*2AJDi%c%cO3@_BgG3W`=Jt{k5H&g?hJOSzd8P@_
z4qn2(WKX#0vl6MQDT7fc9UJNJ=%Z8x&k#{5TfmAUfE7Z*YgrhZHn?~r%nXx~P9sGb
zR5DuXg2sE-Xr^50!1A038RY_bu>&Ev>nm+6VCG5`jOIm@0i0tcbuqf(X5*{>HuukA
zs%N>_u}c(K`*^2+9k$vWB~Q3)2jciRB|MVx#Q~!n=^GfUL5m8`K#$<$Ml_b|i>kS-
zUO`HLJx+a=--g$ZE{EJfi1HLRUI5IvUD81=!cF;*RS@Vb3Fy@C*l(fpciiitdr@<P
z5#-r~dwG^aXF^SSy;4@AhU@6beSD3(9*{(U4wC#lRKb7r$Y_I0PzYP+u}Z}Uz-|ex
z1D+YB7n=~|4zCHG2Bw0dKZ}mA$qZ`Z{Q0-G|8`|6EPzZdvTo9{1gfKBqz0kpx@eP*
z3@KC6uy3pOkdNSk!|=ut8&_IG06N$wU>Rp5@H-63rPkl?5M!`%e$q5M^(XmdeOwiW
zW|vmGE5kKAE-6r%tM7^P*A;VW?<m16bZ}waRYl9u=HKZ!kEYeQ<%#P&-Bf(C0Zd$0
zILkg{f5+;?)&+Fg`l4=NSK3TH)sJivhfVN^Hgy4CfM+M@E^a@-EGRtM%L^pSm=^A+
zh$@dRiJ$G-+<>H%bOf752qV_m&Nekhx1rnkn;8dzEqK*B_d-#M6ZDSLGYoS|B_wYx
z;8qDgjM$9w=+*E(m<;?*#~}F*HokA6GJ8#P8hQJbp5HLNQa82*-V-YJ31gLJ9|0%h
zRiOII(ra?Kp_vLeiR#UI!YdU&>FNQaLbj(RL|l@xzfarcd)=DcitVn^s?da)fpv9D
z-kT*9%k-#H(Dv>L3yRd5v$kw7>_9~)zV|gDP0ltw5sG5kHk8G767T3$bJ&jBj<e4m
z8NL2|&x1xNHgygtLjz783d!{)Te*l~?Zj~l3;@t#ikR-x7gM%hh2$1;4EETQ31yOs
z0+*dryNK2kd!I@RwM)TF39?zvCmQhJ7y6z)MV>YjhOVX_haPixS{t7!8AbP@HJL;7
zHp~Zm_Z;ZTn{25kI=$<eWe4b3P3k>3X%^VjXT8-z7IcegUdyxVmi-~GyK2PeD1`xu
zANiQ=scEboc{_|N(-Q{a8U20T)~(f&*M;PXT2=}bnNdP)seRanvOg#sK}TH5+5oma
zV}p2h2=0t6&`qN1gGzI1XnyDv32g-H#iM^)XUZ}rAh7cV2OrK9NTex}1o_U;pxTv~
zX(8oN!&8{yIEjfMJi~qmU5FN78#~D)GkTJfcVsIjoh@Klp>+JY=>mQIiTugyzepYn
zs<_;hEUia!wufxF1Pop*xcCiItw+o-b+Diucv{aFop7yiP9muS*#3sAv+}tUrWRLK
zAAk{dy2wvKhx{>Uybybd3I$l92n!*_v)aQ5j)LZ%pd)o0NOTnIs7u;1NYaBBmOJdK
z`Vm#pdZ6@X(@6o;#>#3U3=pkKg8+k^P>^)42!%xE3t5e{=DJfYIvgR7C*=k8a=fzL
zcgq6RkFh>DO_S5evFG@jXM1Q>hh=MV>$=(bg8^F7wL|fDl3syShE8~4EP(1~h)*<r
zpW-bO<zWK^ZAtl~-Hu<$jL;Z<A#Qj*X>{nIa?-oZ!oLHcn;dteez#>mamw2iVcu7F
zjYA^L{wD@`Ta@pRO?yBLXJJWK=I01jLRr5TZu^{2pVJ?t!8%7@h<p_@Y8A>$cRT{U
zam{L;$u823CJ}1q*%hLHB0J*`;p<P{eh>OFcq8pZ5Q3zc7oC*Y2A0r%tDk{WrrxRi
z&)MkK>H3(B$FGt*Dg46TK0GyV(D9AsvRgk^UhLcgIR}F{Lk3FG`MY2`&kxm}O8>H3
zJIpkfhs)GKf~70v_^Ruyt-4Hy8Urj)F|lEYJa2jC5K*_95M4H3CP-hGthQt{juU?X
z(!2chu1bA+xL~47%9E&A<qTMi$WL8K)!SwoRDqnn0UDACsdad)z=n}%y1;rnT~zCK
zfiO{$^dfDK7j4H{*ze`aTekeD6`>}X7G(Zc`0J100`ih;joyJdE%as0)*NPP5(T>q
z_>iQ>M(S{?@%lu{Gk`qR7S@VeNbz#{R}R63Pg<wQ4<?P>(n*ke9xhP3gIOc7<I}7o
zna;<hYKGfqa1{i0fJ$ervUuA6w1X}vA8U+&r)&x4K2b@AzH;!T)a8<D$wr-=Im(Jx
z3tFbXTT<~aeWEM}^+G(he0t=V@Ik<eoJrY-0VO|_QP>q<Rol;T(yA?Oa2BXCooDO7
zfR-HP)gzWZ`i9)a=rFP?^=K_zZsBU{wMH+6=o(mj5PYX1GIqKTGegAF4nBSb(L(QE
zpwTu&FFR25HK|LOevk4g{d6M`eK?6T09-!GLFFGHYo1sWZCBT2uboA0uIPq}9H?S4
zWdayct6M~PpT^nXN&ZN(vHqgyEqANZ7I^J5wi1}wrbQdY>8RZnJ(V0H$}z4Zph8FW
zUu$-B8{~YkC%9OSnH<zf)W%RC3r;=l%5BT!HXNc!2IlnYqJoQ$m9|qMQKH-i9s(DO
zWH$%WZ9C?--Cl6J58B^?wf)Lvv%v~Oom6bC<iRV3b1joe6cicFByY{Rm5xOEhkpqF
zU`tBNAB(1|vgFeOhgL*dKM-O$BD?uF*z%~Yq=Ro|4b97>Qq-z=RQq%lTvD5rOU7Yx
z#CK3))3?_+c_2jwqb(@1cMhu?>g14`-MVj>&C9{63f_fp89i{(X;+;j7H=uZMSV*2
ziR759OctG4pouip8BeQGNzUgHlfcs{qq>xBB*HrJ-hD4`yA(Bb_C8m)^Qp>;p=xhv
zOf|{!$@E9zzh36vp7NxMI+JVcHBiXXkvu1+$lk7v4Z=GgLTs+5D$6Sno_zrAcMFUR
zHy5p|4_QKe%(9M?`}jfpVSs2MtswMma<<*6?UauFj~bH&y{&FcM%|=2sUDLz<RJnT
zop+6f=XS^@Rt94o9oqw%#6&PN8n+#r0u+X-cXc5mJ!A0(1b(LY*_%3-{z2zv)@!G8
zn1*Y@HIe(A>GmLqnMtVw3Dq0=gsb&`o>=(y=xewJ;4od-D85QjI-U$s<uuY1qLo$8
zX#tTt>gp;F!WO7vF_0is9k_CfWyU{x{UW?r(Kx6l(&`Fu13Va5S?!}g6-j8YeAAsE
z<HYQ(k^?H%s7G&^32v1^kD>nskD(i32vmENDX~_Zmr^84-<2WS8fPy^?GBP@GnfG;
zfeSjNQqGiRo}Rzg_(N~|bW<q_wux#^FXh5#H&7WNIpXdL?G&6f3WUC0-6=?Kc<7DW
z7XyTfUiH@2r#a6x^Cz`V$9bd>xAd=)gn*qBuxlf5Y^eRgm#DY_jZjGwf{CYR3|=k(
zg7yqSxr>8txlLn}VYRoQ!5ah4GyMiWne-x&*Kl&Vgw{J@Sn`@HfXdZDuEhM@35~^m
zy-Ga|J!wd8+e;jw-$yO*4er|Ypt#9hO-|&9QgJH2JrLk_!<zw6Me-B|LExlIPG;5(
zs;a%{a~o@u&zVr8G!#ItFvpF_^0PZ}m43qs;~M*uAuXnv-vB0F5f^~*9ArU(++)bE
zC<~-ENEj61U%$-LX8#SOu<0ANOjEM7t!oFHp~pdS;gNQ0PrxPEX3ru4#%6*v%Vap3
zVgf=dU|dwcyS3jz%zs}oisu1ZHqK_yzx7Aj0zbml)_7=4M0k2gm~chLe$pX@7D%O3
z9P3@JDTo{I%3A`JEC!kycLJoJ0FTX>v{@yovOf=}!c8j=$zU`%fffS9ijzJq+BEVX
zc?uU5gEtl_`*9cv&n>D|P^|2vNC+P@ppg`DyugdhAv#hAu=_FVnB5p#hlNpjJ&J@>
zmWG{i)56hm_8=?(<ORXC&%iiYD##aZx^Zk5c9pd#jPmoZ{55>@4{)cp{8sfDly%u2
z5&ByaK#j5YJR^=%2+GxX?{H2~uvL0vtt*t&r%?}jfp@$0J4jHM*){Kay*FEmm=h+m
zLh>sii(~c8*Pp(ALeT+G*Knqsz%v-p*CZb{nCfhkoU@Y0VSu(#_7!3qKCj&5^}kp&
z9FNpd4nw>6YqHZ5GO2ODAh#?tH4_Ita_&~5lD{2^{E#MG7Gj9M{w0*d)?@UMha9S?
zN(%xDRcq7$Eq@>WJ_(T?5*IAtLN~i+?-b!@cOoZ-c$V8^0*2ABlT9G64U&<B@3{jH
z*e#P<xcL$KgsiPnC3L$j=%i~%W=}z3G&Z#3UDc6;=>sM^=|bf-TUj~5;%M`(7aB12
zaiP*=!WOjQzNkGP(0mU!6zY1&Z37HSAld3B4X{pKTW}%zTG2W3iqXw7@eAZZ5+48h
zPbyi7dRCTJc~dcQd2gn04-Ewt*C>&L>JQkOkgDb-Z=2r&`3&&*ZooAqwF3W|K59}D
zQ>D31)!n=F1I-)SINrdcxK6A`w7Y{B!)<X_eG(}L8O}6OujSlK`>vHjjTn{!>KExU
zU%D(_y(Pbh<WR?cJ30tR2BJ;I<Qqzt3P8$x&-JZAof%`h5mYhB9!>HECN>gqi*p=+
zBWZa)vzJOv!J9=%@3O|_#GcYN#*Q)z{TI&(WO=S>QUV!5Z$JPYrA*JzWRK=uMFEzT
zPYd3xa@`9hJ$D<pA^$?-gp7jND-p@AV;cWAlgI*#(s5I=JK+N)^+s$0Nd!+FqAO*@
zdmI)Et3tV%3`8jt9ny|%s2Tvc_~W-9>wx)9JNxoWy3iUmj%;Dfv+Vf~`wKwB5xDT0
zr!;^K2x93QkOo2z6!!=}NqZVYClN+R377~ZwRroQ=A9@<RGl4JB(N&*#+7W6I~tgO
zeEU$r+i!p7!(6@Dqw{^}G5P92icIrJEV=Z2=sGMrEZM$Wa(08*)eiN0XHt>FG6ue&
zx>7aC`l1B{9Kwm{kEXE>cI;%EzP_G{CqmNTi<-9ahi`v*``FQV{&P70CheouD%W8_
zNK{ceB}K%Si)6ke3~b<NW5?j-O&N<0-z0K(lxb+!?1c|tqLPdeow6$Q7pt=K!^06O
z4hWTGS^bf%{?sP^x^Zu!9N8{<?CMO{`a$3Oo{{|akQ{G}LDtfFXF#V`w%k6TV2e_c
z{bpjX1t_;s{d_B>rOsM5S^@+g3E4Pk*g6kl3v80gF@#Z9ZJD1eVepEPWkD*D6X_+3
z48$&UDk7&-2J1C5al9#b%sWCYTwaZ91QW|reM<@eDhld&M@WSy$4r~|)>^!U+&A0O
zDn+zZ4eb#X5l0?*^w7pf?35A*Z@zRQV3b?rv*EMw_6brSuynxX9}X4UaO*(;hdBPm
z-XjqiJ;d~Rs~We%zIrSntWkTrRY^}XnF&xz!9xDMoJZ-G#E|wu{i>rpMRKXMtYeEB
z@V<<$1TFi!WNV6oQ39Qlll$6pFnKo6(5M{`ti#T*^H5tAJNO`909~J^hScFqw6ZEV
zxVhn?oMC$=*cYHIqz9y496GQ}TtJ%4>okVI(BHiNYr3v*wV@Zx(D>yKIr%X{!Z4su
zYv4(C-#EHF6YN-&fGTBK6BuD-UB>iM8^|(KiSx<^eBn(hZC}$Ca_Ew4Af}@W+b1<1
z$1_(@2UZu4S+pPUcyPwmrv^bW$kwti>dN+VvY3JoJ&Y%|_$)Olb0UbnFoD%}`|04m
zcC`_*Z$w3_T#>a|A(BM*i<-6sYQvH)0B+^5#8hf{U=0l^5^p^wNm4|Gr!ZJ6d;wzB
zvM55zsSEat^yJ5o3BAgQBP{{;W(gSTxKLQezO>9TTU^SM>;VUT!WMO_Idp_Hi8H*_
zm&953Hb4I;B$7a~n1GImwczfk*v1{}iO=?m9Ks^E*UvY(UL#Bb;W$9$bm-Uzme1Ui
zfVtMFdwA&>ysAqN-R{Mls=GCha<uIL=#Sz+=k{1BQuQba{do{ey`fB{8710v)QM)>
z8D)(pjZcA59&FufObTx~!_uCuAIXk~*<B`9<B9FG$wpi2Bim8W@FUv1v0fCNRB31&
zvq~9v4(SI8aeKe9(}4bQ_iSNp<LrfY+9zS9UsGH5*RNk#ERtwJwq>JQ4CDqQo4I_4
z)~)D!GzMW(h=d{}0>H)@YYZMlx_VIRqO)^xz7BMx==VyiX~RC;{JlH{Lx90wES8Rv
zSAFpUlaI7>&Kx46rT)}hDqerb2&)t;BUT|UOoPQ2Xzc)x#gxvd;^0Sis&fQEfC$<c
zAinH@6q^ls0K`5Ceth}%E8?aSt8A63_zp-bR0YU3sEAU73`BL;aao={s-zbUQ*Z(j
z%@1L1kldL-_hEXV^M$T03rCFFtZ8*~tvKwgF^>vCPpq2y1Ym?Mhy4W1m}S5fmD&@r
zq|$~fzi5jmAU?z(d!mb1r;5mFZvHY2>UD6VE$>w&)LI9FH;Rs+>m=`nSlGw`^{Nz8
zj=ar5IU~uNZjp**?@rag&gM$0DBu1P_(LiPz6gI~H*xe?&}==+P|R>IOzTCv{r9dm
zlefe2UHH+t4d!Zjhr)voP{?bz3P5hylYKCwYMnMvkYZ6!05%AKt@lQ26Sl&BU_a}M
z@N~Hn=wGS{@`Eo(cB53(wo+R4;6|9{viykyMDnt%<tUcmK%{wvStTXX?0kXPRcXo)
z8y2IZDLVIr0vWin$sTa+rRreS>}^P~aN?k{UY3(urAA$jbM7-z0VrnEW0TZ>M9w<9
z2KgVt>o4qCht}{2Kuq44K1n!Mc|VITA*P?CJWoHgz?M<_NSAi)<IN%#2Vz0G`4-sv
zMjoQn;%Xpm7%~tY(G`)zY@Y6%;m!cCM-Tb%r~>GQoYKi{b)gqG6JBt0iIlF@-1G|I
zu!X=n<D5#U8)<`;<6v-2jkviYdA)bNcL7R(d<=XBTV431%ga8gQ-O<HAS_Qe4rX=_
zHK=gwiXe$)@?3RJwh_RXNI>ngU6@qcABNXot0FVQ0OB@9Dy0nN^mnLnxYjI;R6<A<
zeXM9hEU}jn&awl)`|Cdi{=i@L|Gg{DEPaopnVYwI&?Hz-qGN7@CBY^A{eLhA&Uu;M
zWjMV8i>*7;NT9Q6BIYc;7Xi?2&ECSG|6AMizlYZ^;3wUoUz!G<WnSg-&oA8z9Ho6|
z9~BN@I<|oF#N*N?g(xT+TjChK4+#?j=S1f?B!$4!B*n`#pQtuyNhY3smD<8m(qke|
zaw8a3Q4*{fV1-GQw`9+-Dq@2NiI?1pEO;WUw6l=z_Y*m3l|aqH4v2p$^Q`kk=w7Yf
z!A?~xgN{3{3Zt-<Vp+=DR}h!^ImBgt1&9hpGd}DcuM3siXBeuh&|^Ai^z2j`fmeU%
zs&cnWbk4|H9vBMiWE@tN9!Tu4$53fsq#M_{14X7dvM#5co%hbSy_;Suh<)Vb+>`DO
z%6=%B%NiY(F1Pb4Bsq2syZn!CaoeKfTg#lG`bpyX<kJCQ#qLsu6;v%#<#!9}Wxew`
z)Em+`8w=>BUdYB;kXGuOUtCrAR-Xvg3R#fvI4SOw0OQGehVUDte0xa8Z6xubVbqzU
zsl;dbiyfu!uCYTE<x)LRy0Js8R(ZPeayn`rKpLD%qjK6(kKK(|litnw39B;`!*v6@
zDXnooW~G#h6xo-u?a$%@q^O_;^TBRsSi{|0fUpE=(n1p;JT9Am%%EH`Om-@=nZ6#@
z>gl$DTefXA-Vn{v6@`ifhsH_Z02VPfS2<J@pb{6+Pxp%&@w~(PssyU7#IU)lFl@;9
zu|>hwoTaA!*016J^cN84KML|I>fLR1p3=t`1D$zBcspg>NH(m05FK{iz%1knL1Yf~
z_whiAlx4Fk)$v`3H-;Sci#$7Ugt8s2><M}yt~$F;;|zcZ2x`#@m<wHOxJ<*i$Yn-w
zd$nuhJyY~;)*Ja{Gy18~6&hT7f6EZ^^`J!*q*gudIV?s?4yMi%Qp9(H;wrs;V3IK?
z&zWzKra3@RII<S@n6x9GXLKxx?@}lNs(e+tTvP$-7U5M9H`}s}D&SDsa0fKuU>96!
z8Y>h(MmXQMh>m~>u*w%1e$mXEU87h^adsnByA-f;jD+643a_6ggJ#$(+JOQPDxXR(
z1+BeA2@wOK4B<h#;{#zL0tK+Skfjd;)z)RGFMV<*kUHQB8j-uJ9FQHTa7}$=BSIUP
zt0XZ%HaqQ3@@f~I#WkJyJL-ngUo;M;)1OfZorso!plFq)Xhp|I;q}L=y|VhtC$bn`
zzn4bsMl2+l=}v-KII0ozr40t@^0kn_4C7%d)|K9ox=UnKQVKyxAm4SHqLGS_Vce2!
zs#bNn)_#&mrHcP)`~D%k{o!&*Bs#dPj*}qCTF@R?F7MK-UA*N~NZ=QXSw45J$66gQ
z*a5{E2NbZ{u|t9Hh8fa&Ru=$Q1;_PehLN~8;@2CtCge%t@^G$GU^q}gMs^J<Rkz!f
z<|(_t5|jp+D=U4V*8y*q<nvA#mn3;@E!o&rjr=-CEyJ4!(*H%+*ZKsikUHw$`ZfHY
z{zAG{m69X=0cDFM!dJ%05o6!<Djkt$dO1=_cfG=IAZ&SJMS>OnV@cR28X|2Fx<Yr_
zDWV9p%1g`&q1DvmfK<PD^q#ZvEBueVbKdDp4&Fj1mTEm>6%bJ)k$7_ncMNT;i5u0Z
zgndecCi%Xrll~^?i(^PkD|=}DvYjQNe^yDL%Q4y6*+{X6y?m#5ZW-1K2E!C`?p&PP
zCHT+p?azEaHesui)8&}SFFKdu+a9~{0n4ay@`?$eLF>*M6SbmFY3;5l;z|@oe}yCi
zh&5UH*dWUFGXy$Lur)Xo03wN&{{?E-k_^jw{6YBozZxy}013q&nsPXEz5*KA%CJ?C
zU?NpdpNL^<y^P7^w^UIkKaQ`ACi0utufjL~fC~{psc~Xyfhg0~)?t<4E}7IH()I0)
zocmVg)vfEV&Y;-$z#_uVUjOJR4laA&sAHYvq%VgO78*kl-b2r#69f`}QnS*EG3dkB
zExBXN^mH06TXg@bM=LcdY$c|Ox%4jO0*4-bcXHiQ>$RNN^^&v7(ei}OPZga~Y~_w|
z4ViJ42mJdg?`$CpT)FdZ(MRBk-=WRVo7E##H)!J;7WM9@0bgObpP!Sw_+%;QmbABA
zcs>t-mM$MSDs)HYz)khbE+87wR}SUN@{ax%Uem_d$6BREY~@y2y=8%E4t4mX=2YOt
zEX#Rgtpo~%=LNXSiH|*GRUR-QFrO(cC4H!&!l(qVX-11ZV?U=`31>}*>_34-n?5Cm
z)k-dTFBIS_7Ufp6KPsii8FZmH`ukumYS<(3#%PPq$g($<SV89F0cw440d%_zQs<J8
zpWM6iqgBC`Z2@`U=`pBWF0euj&AN)E2sLwOG!Xi_YbeM8nPl)A{1z~6BQ<6_&`Egb
zPawMtGOcb#lCZOvW;vA1e?b$+9u0_zwwa+Zmu=S)3R~R@sYQsvHpLJgI7@sv?-#`T
zJwF6F?sa~ix2jWd2|$2ra2p#qqFW%7{W7!ADoMlN**;OSOnQ=?`fWa(owg4;M!oqt
z(N~bZ2}!0eeRydO@-{%fUdafX<k0FRg>1THPOxfgf<sp@ANNHC__liF`1D}F0?^@l
z#k|{_NL3g(s=?AtuxdHgy3PIAha}^7Qyl_%AF@t}<9h(d7dxM}Lj^Uw{VBCL-#)gD
zk>Qa~DlSZz3+S@P<=fe;_($@u7Ud9*6$NmYc&pinO$g&Gdo_lqU2?~5mGw#T$P-bT
zm~F+2>Mt$w1Owj-$e9G2>$}+;v=q70)Hi^c<bY{ix*FME>)Ltlx=PhmJN&a^n+bV)
z1w-=w@SUt}BcDoX7H$F+=?l@EmvadD!XqKz0a~*gMdC7Y)>J{?Zt<+KoF<2KMl6N2
z;Im5!TB;cO^B=TmS#e|{2~>9{x}VVe2XZC0K%}OWEMkTOV&O&zgT$!TDMjc8F32=w
zrQP#1W{!J8NLgevozx_O*SqiP%^^&XzuY`;1FQkHGDZ%!OT>UHcWQru_4Nf5-hLY1
zet7|MdcUlDj|A8~$Q9psg>J2T9*qE!Ow>jKMwHhJGbhZId<q2w9zP1_Qg1LSRVCrP
zS5m-LJ5>vl&nCyv2vXR>p$ZPVt7F13JS>$x2$2YugA<QG^l?qgTFJOlBQ;&FIwk8<
zk$G1j-BdEm8c-|vLS79@jIfGKWt)F$^DrbV5;7@Dl7MBBI2#lIV$X}C)~tlTo~OC!
z&H&=b(|y^(-I^&s`|FQPTo*)4Ea``BjeT?O6-E{gRNp|2^Tc`sM$mpl5$TlwRVk9z
zf~Wr<5Zseu=E~`k;KwyB@+3E}JTys_@f(DukLdvWLa6BWP(5ENe1~>#t>M@rpu+5y
z^GhPd!c%;PiamrAFmtl(aYW8w+-gcpEPyG6LVMy=m*{%bEunF3#!_A1YUHJV2(QVf
zebI>n!B@8al71%uA|qZ15;A)qVRo+~DWO*YA%TcQB3An&ze^;r-$)>^*}X!AFLN6g
zG_)D8l|m1UHiD=`Ad4(R_b}Yb1DIGF14i)NX=0%cZ5A>iKc<?Q76oLdSvObbn7<5v
zo8E;^hV64vvDlF^trD&XEf~QbQ)|1@z4}JEL};fHhPqAzJc~+IJFfk@TV-^CLP>RB
zba6mkPfKM9iTl0Qw!Ac(wI3ywunCq@#%+FHgF#%n&~>4O`+3^)6`KF{1Ak3VcJHt2
zrY_srBoPdGr!)fT!K%;|Y~WNB)Mb&1Ts4t7Lm_`_K*QRl7}PSldeT#$+Sf>AkjF@B
zv=JqQe(;%0f&&t7eNX_1R~I!T5&^hHy3=LxK&bqu59*K9y?a;mM>T(v^W$`U$W>DI
z8K<u--S%v)y<%b-Wb<<G&eNJWr7jQAsYXd9MULbmZIra)FoZdfNdP4SH3AM23u>i@
zB&u2McB}G$tiMn@!w;1QCO?+j$<kZixp5C_{WEHl9$XI(huiv4gCx0v>6W{TQXRvJ
zg&P7iYC>$}-9ryas#}y+X}j6022$AP>V2*1wG(x!*hfvCWSVa@uIC*64M-jI9P}j+
zvjQbW?RxvPtxXtr0-3<PWq|G|=9H@a^znN1t(S_#bkzZcEVJ5AQ5}A90LKcbI~q4q
z3<I4#(Mqwe8#r@HVkQ~Zv@A9TnU{1y7XQ0x;8Ade=7^QbL%gZuuuWV0?gdJ$TkFRo
zpyC&uTwYX8VeHffd}UVCWQ7lG;)5L=NS<e;(d$oMfA6xg|AxB59`0;>ZOXh|h@wQw
zl-6Wol~Arip=E~4Pyv`SGbba3`@V_9`K1MF*wtDNh5||tzu~B9pfgX7(CedGKhtY<
zIkjC-ILr=$>3WCWs8P-ql7xvVn0&Ci$p}0<C-4v3PW1|!EaG!!{!Yv6xGE_TRtb@N
zT5aEx|Ap`UdoKPPto#5=DwOs?d*w-~9Z@AH77`bgDr-rBY-7m(`s{30C5OokDlxLp
zJbVysv8WU*aKZ}6DKRj*$)?<x9;@StJgnu+sF(p7t+O~TI@gpm#%zVdb+}yGC<p=)
zfk72A)hMJ~8e)zPNEo^}bZGg;p8BelYQNXYZ30238}I0$-D_ZMt_aV7Quvq*mgLL1
z9c`Mf?IrF_vJ=e`^wdc;FwLj$5wl6uwn1t-BKL6$joC(lB8Zw!mDUswa#B-5Voyw(
z5=EomBK97UCpYzsB|G}oslJ`b=t$&uk&34YVyy_Y%l?hKfH<E2rh>>0F_zFaM3ral
z<sZF%vG74B+Yu@0rY*RmWEeJIk6p6Oo8zt1l=?-^m{^$R%vcAi^r;}YwNd2BFF?%8
z8gJb&zC)jCh0wEwlR}Mqhz_n#TV66;Ywabm6xo^$;F<=l=^Z<DQ~4_kDYJ$Yd!AX_
zUsW;fu_B?e&LTV7AU)j(jN5D=T*JD_t`cab^r`nyQrk}6*E%P;R*tU$^GO$ihLSbp
z6Y!|@R>x2$pew8fr>rl4wy^ewAxpcqs@L=K!W^e;?<az><ln&>w%-chHa&4nV!9s0
zWyvZjIUnw_bR|KN6ne+YLBq-0ITFJRiMA0CgjW4V)+1y$a{K$v)|UEsuu&sH=Gjx@
z3Od4z+Kh9O^!2B2e+jRtp`3hH4tb^bx?%V9(6*2L1~eRdV@JqBKoA@T62qWVYpMDr
zG<0=?HtT9hmP_U;qPSJLFh1k*AESd`(WN!XJ4ssY86bgI-o^rm=Z4Yt;076chb$X1
z(@2;yYH|YR&%Xi+`hlqv;75c)YcJ_gY|gDd6zgZPa2n<i8{HGcfo*VvamEPLjncJh
zGlYabiGap72a@w-q*Ft6P9Yah=rBOIrGJMO_>kx5hnL3zrnfzmIX(xQfZQfhf^o(}
z)+w>0w?%5x?H~vYO$ABmFgUlBgsG?ekyh$2@G=GNzS$wWlHQ_kxejPEYm>r&oBo{`
z7pHIj7$xc>!Vc7>b$5wLz#3Lz9ov)ms|g8#jUut>t^!U=Gr<GK;zhyKT)|mr{t>sN
zjwMnfK`+Km?S9G?Tp>@0TIL5aWD?;KUgVgr*n3)1!?6YueYX$`w4!$|f$@rtNhl{Y
zhfnI@TC*~CDQslHWc6ukWgV6!fgn{RFMdb9XdJL=YPbSxH3DJ#;09$5V@=`&vf-)9
zjBhnNv`>l#f`YI-*R%=;uuV5hi3x4oZTtsw6*h|~qQ}PHa*{ZmRq6v~K*es&ABi(B
z>LhGCXu=+6>aj+=?#``VR@egI=!;gUK6RuNq`IE>`FG(T{}H{q#$iROk#8S6!KRV)
z1z8umKiu#G+RB#splU7mt0^g6udd8h@2aK^62|PEroRiRSNoXYoI^7lB)Fbku61;e
z=mkI#v)bNKDH{Bc(z<<(tXX~6Y^ZDG!mT^W%If?LlaXgt7eHCN*wT1`D58R9Ot9!0
zT!~&n85JK;JEqrj4O80hk2XxV%M3R(UylQEflr~d(;b<|%%DG_b$ThoVEyl^ItzG2
z6`#h?vW0uNIwz+O@os7nC@5mOtk&s~Y$K!2)&X7(bY2=Etuuf_m&ED}!kx?nP!3FY
zxI52|-Ovz~Gch=21R|TkakC+LjUbav>m&#rq(f6}W+TL-z~IGivrzb!Yu)Hr9;!!a
zm$g1rgx-O?{(VvU9y7d+Cdf+oO6_~N7di&@rrdDOle!GVXr>8|rIduiC27)D<i6aY
z+kq*NS&vOc!PPfyjxp<k0a4oer2GEi+s~nd3R4S1!y)+|AO~|rYvP1D27iidheYPK
z6!Fxet-$X`FW@1ssOBVX4ErjF7i2~kn*G2S!*Ds|KuQ#s<U}Pq-abkH4e1v<9yxQs
zC*EQwi=?rfD{R)Cdy-nR?Oertx%sZcnP;kfM~xdv|MY?WA-Sj&r9jnutP1<XLbH9)
zsbGHB1F`_r0w4&;)!=2eUm$F_bX+?x@CpQyE4|OhgYbE4fXRlM>tu^(m61FJc*QP-
zeZpKLy-%vjiYB)@Lf+K%M9+GVYq8+*V62GhAECA300K?ZjqY24q7#zYDRUfx{yFkX
zaVbmLr%kfNZ<lMS3*D{Kpr_gb!IsTLfu)wC3@Q_HwkTv9go$<4@_|BoR~?+GBT>2<
z=sea`1Odadr-FE8jbU&-nP~6T3Hp^pXR=_n9Q*x_ho-t?cIzrx;)&{?;f@pDK7RYT
zjv{cPc76|#f0vUn?I0}sXIm4fj!>mrIRbdOZ`yLgN?@T?Xa~%Nd!v3y4o>gdjS1Pv
zQwwH^EMjlSzb%=Bkz-t}^^XpiO@gp6(*sB$OCC}~RG-%09AcKTQx*y^6bfTVpFA3{
z8?GUfq?l-XZ$Y-byw|$dM$u13OLZ7Q3SjcDr$GL@x8J)XNxCbLwomM&rEWa_%twf%
z4%RL83AJB3o<N%L+U=ohQcf<%TA3uWL=nv)F1tz$D=8d`gXs`dK!$71sG{_3nkn82
znS&?#ziC&k#k9avvWEu>NX~w+qZv}eg`mq&Pzi2oQ70>sY3huU8M|#F3JcbKjvAMO
zy}TtJH%mJk9mK;MqD!Z!SE)Kw4M!(T-WI;rYCCD?XH=b{sbk>;55rZCEWlW6T4bnU
z)aaWtWH{MCzPJLWYiIyxyc*nH-n;-<pxo#*)MRwGokt6D(*t&|weWgZbOws@OVEt6
zc;6BpjB>OLgclUVifoK904OVWV;KB{MSM4+|4#b>crREJxKl(%?Rg>gI=E`-5`Oji
zm)Ads^h;v6y!{qKu%Cq2KPC$cHZoL1lV|O`FYsr+z!aIwVXl)lig&hqm};i4`CqS}
zhqr|GdO@0(+zcJyk!NcswMGE#n8WLl-e0~QzWr@;8phoJnAAKnJeHh(ly$E&AX8DC
zRhERVxOdDEsCbiXleN~CB0yF=rOV~;n&ExJp5GNc469A|9$_Olnu>UUpTAjhb=Z3u
zCT-&b8}?)@X<{@$n=(P`yM}(~Bn>lTv;5wpW?F{|CdG)rZQd6m$Y$hqR<D48E1SVi
zFWrMX<qPH8NKHZ!4=_i1r|=)zWUo%3D_Ik$PkKZICX9C7DD>;?(ho5J3FQ8)=B1+)
zRnPIq)4&w?mYy}<;x(r>x|iq(aVTHjatr!73r>Qal<G)KM2<X_yQx1}&Gla|o04#;
zNYV{>`9-!QOcZH+GZg$HA2OA%x2TKKY9e{`^b*MZu^!g7t_D@RLri&MwAN}Kym-}G
z)P1*eT;!^V3Uk0JW(|8_*x}A&X{o46icbv6sgNA7AgIY*-3sl=ZnnFgk?z<#1Gf>h
zRKpKI6{xS#pM#_*22?(u!YrBOHI+oRl`kvX+7P3a@K8)1In-QXzY$hdWN)qI(1x<J
zzj-*>T=IT1FH~bN9H;Tb@BfU%H~Aqwnr6xJjVi4p&z-tYK$y1}%Mcl@OUbF|iyrM~
zW1N!0B07R;G5>p@1xwGN$e}G}xzmu2NksMiS>6n4r}W7&r=fDjL&31MGZjMD$dOcZ
zXD$6!SD)(`s15aB5p(8I1gL^IJ$PQC%cI>PNcF<!42l=cfmCS$1AZJl5^$Yi^-$Yy
zdn`CEb0PvGKlHF%MQBCiNY%$lmyo@+<UZcgoy42R=S^3uCv6D=cQR91D?SS4NOa_V
ztcL}qo1^nUDv&K=lRFrVW3FUNu21qM$yzJ5awO#<{{y5zyI45dr*Gyq9BS`{fHJ{O
zWe?BZ^u;KnvhT<hoq6n}n?iphDIU$FiOr~uM#ud_n!UTV7&otI6ERT079Aqyn3KCO
z>N+VF%@XpinVhQ-$EYx4U4i!3?;Tq2>~w8N(Y;wq`zX~`Um>zs<>_$~X5vC2DeLxz
zDk*F7HM=Wj!0fxM^RThal(Q>lqUq8xjX!EYft#~n^$I(N(YuN@-I^*);*fA^Eqh9O
z|0PID@d)IIZMABLxjusPryGZQHVfP{vuf~53{W#qd#`<`C9YWeyFb#Zg>=Yi?|^AP
zEtq#3=)e%=$t3}-1ld6Be4pp{S4fxCK$YH|Xafwt_s}qTlT&mbW|}xiW`wu^<6%zc
zT>u`2n0~62%Q3&7g)57RsRTN#J|-<{RQ@BIK9A1okole86O21H2bbXj!s;rtlDfL`
zcQU(7KbAyW0UINwIK{U21<BV~)7v<6arNY|NQ9F^c_pBg-~%}P?^1+tj^du`X-*tB
zYcXD+F*bC)&S9jOzg;Hh*%uQ$K;;43qOQ|mm-tm|oWde8Ai+@0v6C{+%7`^3FUin<
z8s0unw-L&USFT`3HvNCjlI-XFH9hGt8(^hWIhrgtIiWkefsb1m^?uOIJU#nqS0&S}
zekQpT#xfNdvS{k`2de8oxMs(J^b1Dp@<?x&r%*gu2<&EgBpp?i2ksBLoj5~F=Ny2P
zCp!lVNMrUr7}UkuopO<sRyY{aqBNq^Ng!Biv>OO)$g$M$&z2Iq;t8$;HN+o<x8I*|
z4lm3e@W$j(J=G=X8(4I3cD4hwdUDtjnmA-EuE@CU6;n85S|T)yV(&t;OlodG!^&FU
z0L@tIXNMRT(^;JKPvP|!nhH_wMouhh+m(60OH^GjPbGvbg0(Z0^6mgVK*GOECx5r`
zMQ&x>Hv-=P?6FrB2jFW+j=pMzYK0cSz@g^TeZ)Yg9Ow8<Dn?_;*0h}T4KM&~FDFyr
zBoq`t_?TQGa9?CmBd4(tiGgFuwX#7&vM{`S`jBTNWa$-Q4uWy0O_|j1u~)!hddSpP
zh5b848~1QRhc>c&Zho@v4+#a5VtDqjE98u=Jg}d~3Vm$k@>C#*u3@e>nvAW=X(1V6
zd)et-xoYo?K<i~v%oI)W<YCpLyK_K=rF*$VfY*IZ_O30rZaSV!FTYORG@i|^i^N=$
zRss|6@tR1>9df`I#+a{OKXMH~|2dq0!;`Pv2RlHi&YD%XVW_&xSwovCZRGP@PDX}l
z*`+*51-P3FjvEYP?a&@E=VSE`yr#3pfYnuTYX8FhMv_8y=3VlfVvaZ)ON!!U-GFI^
z&=PI4Zgs5=n-bEyxy=S-7}r}!aObLZOI@2?ZA&1)?=o<zvuMkt4cg(cs~BOO3KNPe
z>tQ(#&Qq!ag@`>RbU0R&qicIH3v|_6RFXT`_*q=x%7JU`o*lKkpL)#Bxiuh+Y_mxU
z=!GpfJ>``FUU~c$_rCrpynTjzE#A0bJ5tM_u65%Ce^WI^&j}<Z*CQ_|!u`<em^AP#
zF=QwJKL;0obx3x?DE}ww{0u0>vcKnAgB!7By8jCK&qYoB7>&UrfN5a2z<YU8%mdvq
zqN;lxaL^pQw3Ls(l-WGuaK|T%ED?Ly9YPKz>*S)m0B$a|st9|}H22!?lZlrR*$MS8
zS=(!LjqP0xZ@p4$Iw-f|@=8^$u;gaLK;U7Ic&}x}U>r@h;F_y2W&M;pQPzYUsDVsJ
z77R)R>M|T?k8IN<Q5KiCU(_Xz2qeJC;ZbQ5tDf3v6PTym-U_NtaAT<x<Vd?i5utOL
z*k-Sn%*Vh>u%<lZ>qsZjcF1Kfy+}~$f$(C{`*xf<{t&ROB9j=(@6A3XN0B?=q_L`?
z2B}RlD7Fk+%*@=K0`$OfwG$vZf;mQ3U#1h?(}7gwyf~U!PKpy!qiiQnU<H$K0=`hl
zOCIvH_flldtE?8DAcL0D6!3~lKDC@$aw2&N^tg<xV?Z}IcaS7i^Q>NB5U!MelQ20M
zct)NQ28RG%o!MqUrLfS8pjn;Z+n>?s9Znj*O*`TaR&@;&JjDQ{sx+*wqvoYT@AXkq
zvgJj^R;{c}3e)J|@!CUt&}3DX?@LYdnHC8Uvpz(+E{AOVdmZw0ZU#QukfPM`Cn`J|
z3>x5f*a|~7X#5L+&mHR{)o_)?oPqIl{BEuxL9YWEF=0#R2{SCYK<ht5pEJXC#a3qr
zbb|AdTbCqw0qaK%H#yl@4wt}&`dKOi%!5s~N~J!X=rwkhs!shez(%d~fy2E%k^XyC
z{wv*P3BwiHiI=BRp7BBPak(af*GBJBqxb{w#5UryB*asJei|X*@@gkiIWS;YlUC>Z
z&he}SWd0k>sjSnYJ@l0+(&C`9>y*{Qp65DY2^^PRKQorWaZwhSf<`1}K#5^gN7#(z
z{4;o4cY6hWn38A{!|5pT$%c9uZ+!`^N}NngFS5JA;cAf}J=t18-^`K^xsqkJe>Bfh
z&pqeiQ4MZWx_6kJ+20!usGEMU6Bk;lrlsRGD*%%0#D%>&n~4A6KLiuF-=(s-JlErd
z9*WHyVKcU#zzlnyteO{1sp>mtif2V(N0{1=4e=^3!Ar01gz*_TwgMB>Q#Z&hWO+1Y
z9I$&BmtEFNAt6e>pmnnu<cE?hN=?10@V0F?fPFd0S}>~QTkji+LLExOOd;89d2D?`
z=-!U?UZUoiNGfmY+Nt>%`d~m~aXngPNaHvBBUS#3?l%TpXQvV+XcMqEDQnjjQN59p
zga(UUe!c87Wt)^ZH6~anKT|^fQ9ANTmJc3+jvijHVdh$mcjZ3ySR%t5!-otofA8-5
zxw-pNc|QSawg=#Vu(~9aSV~-|6j>_zXb<^FKxgLUc+zn=)KPgGz8Y1IeLh!~A~c^J
zY(O_IjJLn&3LQ%1r6pUKaK0`>yL4JB*+^wp3oig5pbOvkI+JMQMVmG#?w~KkfoBu$
z)KF9<5(5X)5LuPw)BmsI9o17DJJ3nB#oF)ic{m_wH9-=8Jb9U-<%O*JAmgc28D9&G
z(-Xo>p8?fB3qG!e)OOauLbTGn%-C?ZV6ux4{EFanPm3JH)(Vj2s21)UbT>ItEH&o&
z)cEU9Uw`7}9gwZE(28<C)r|?&muHmnHUa%&7KI=@DPgFZ%veiB?Agde_sL*(8uORS
z_rL%B@ICvt$S}%_E}ey4_i@MfEq3Urv4f=M9$NL0l!UswT{Y1DU{x$UG&a_CP}E1W
z-C7%JUGgFcMyj!ZpR}nB$;nU9#?CX?5TAi%i+lo`?DcU{@#o6bE}r)Bmc0VdyYo4z
zJXO>FgSTjIL~-t1LIs6CRpxu52)_>ExCZOlFsj9|bhSq(sRFc78p%C3NRAnZ@}&JZ
zOl~={S31(Y!X`6NitHf)J#C&FJc!K2R2%#`*+PcHsY$&l7;K&7IBb9{8nfQZt`666
zb%rD)>?941+L}_yN20EQw8etuO1oa!g`VBkLEe(m@7*6vw$3_3y4D4dFmsA)yiqW+
z>S~x0ZI8~;D&~u7h#!NY041)b);>+%(6LYB<n%|a0ug&C8O~|kDaU=D)0dzpc)pH_
zkvA#tA+w{G3^ZR(m`u52m-}BPxwhLj6(^qywN0hg1BPDnDd#a2_OINuEM0=i)TevC
z#|$;PtFV>qPsB!7QmWyM;jKe>HhCAgSK%-TAywK|k_<FQZComeZBZ%J1@z@?Wwk)#
zrk`aO+x)7JK;nlh8Al_C^B@!eGumBHXoaoz3{BOHb$d8_2ez8>*vFH+3DD>_@I@qK
zOQenR{|6WwMuiUEa`Oef_FWEw8(iVi`bG+8cL9(UA%sfphi!(fS)BA7A=Q~-w{NO5
zq`LOqDUZ^wkgFya{VsXztqUFfP#5QYVf)=rE39w<IOG{Gk=6rM&SE1xw9_BI?BT>i
z7?7cpnYBV`jtcx6n+Xx0+6}Sie8w;Gd*R>z@U)P^+y773yERFYTxVkM`70cx*@~b<
z@Ex)h^*`2Dw77UiMrGVOE}0c66OACaZ!#J8ZMkol3kJXp1~a&0FaXS|YW|nbcl><E
zqi3atp{uHUIx{1}{rI_jmn3wuxFcv%M3oA9ue^M^!H9d^>ega1rAV!BU+Dknr`hD-
ze^wg~Yn(oZ=Vx;?n+`TPLzt-kj~<sTn6`g!SprH@+Sv=b7RS~&303Tlho_vQn-7MU
zN<(AI@(tdwUGZRdO%1=tn@t$OvxKUO#3k3cLS+{D1iB58|AGd;oiQLMli4|^sTSHb
zI|FAPn$_?ombJ{*(2&UJg!}T={jcF~_3QV-U;VW|B$ZrDs`)z)gImE?{&L+*on;dM
z167O7o{VgOl}MmQ!4@M0-#cV4T+13rx$UHEWt9edKFOvnz)GBKG^14m#$fqTH)^WP
z-fKByh;%RVlpn#28w5aR`KaHr$}@Z)w;kgr!apZtxV?1gf-6^FsBTr~t$jajC5oIQ
z8eF?;IgGuwLIE34^`W>Bw(hEU=`+x3T)yE~+X9HMURn>KT7Xn7C7+v7K_BJ=Wl;f@
zS8Q|iel7w`wvWU7GdA)v5atV}Ezm9*J#uOL-OgwQ4;F0k*SJcI|1hYoAZuZ3et>k7
z)Kyk9-r5+R*b1MotT&Pk@~PlV=1~JdVE3=$EEzl7W<WoIR`Xmu0XuYAyo4LVK_Mbj
zPuqOJ*PEw@@Y#N9SLJh2!=aJ_C3lLeB;4=JASf0X1%fbhZGZa>RDtmHo#b({KAV|i
zfI-Kp*OT&FveTy`rOt;T_C>8oEHrOb9$&z~%V5E>4|E6HLARmO<Vi6@CijBmwjgy-
z3V;QJwaYkCgdUs&l1|V{=%U>KsV-aQd@5Izx$FQ%EJSt#P$y}tZLNR$r|?hzWcNcy
zLpwwvo{H%-e%pXcB@sD!nRaI>7jWv8+xBFKY`Dm;bVaglI@41J0l!C|n~JdArcQ@u
zxE1O-{js)FKz>gM{#p%u(%3JTlAnfeet>xi8taZtD=AfcNuQf14^z`Da)A1Jq$6HQ
zGtPP5{mv#Xx}BdLe6Z5D6>u60^QK3Z{<{OOYh8!?ICq#&oHy8eqGMMkL}Zz5xlHqq
zJ>VH*MDT#Dfq)!>WUkJASc)qBM|=^;Ee>I)ln9nf2ELE!eqL~NA*Hx0^)cANYM;8*
z%-be#mq7Iy<Uw|z0VAl;EPH5S0$zp0Oq36{<hI<2yR})cWV!2z$3NJl0yZPtAc?jd
zx7)!qDm<tLCWo3Tj||%Q09!1}c2sU~uDIB@PfkhUhxHK>atNcZqu!bFv>i|bi(J&X
z^?kRPghwCdO*YaPQidpjMmytn(f}SW|7FLTQu9BUuNAh@v=i9#U<2KW;k_6eaANKD
z){E@{OfVr^!APO@HsAt=_YH-ABd2xBuwZ#E=l)PwK*1(G@4g2l)tu-ku=L4l8rT_l
z4xP@JCoonxH_YUuGQdT4dFx_qSBD0nP?T)tJw+rm1-rN+Jr1UXd?m~d$mc>5<`xDK
zXO-n!**{fiHdKh&IaXC%>qz75Gm8`Go6iS-mEVVChZR*qqtTAJH~WnE9+FdcTAy-I
z%r-OvFnVP|hcp(&)|vf$B*rZjLKD1gF{bDuc?S@{1Jp2dWRO-i=6+X5XhokzToF3c
zt$|Ihq6Hvu&hh*P7_{}a<X?AE5|e|=)LkR|!5y(Zpq9=m9hyEbDB&gq_0`Ld0>81H
z3@vEO<z(HxgWej#G`(IVcy~pbKGzwng==OoSTFDSt*W4k6s=akU*!ma{Q6XTEJBFL
z#FDdSWu-mdJ6i??W@^{DFmC*~$TLvq!#f@iq0Z2u`{sv9jqZ=g9_7vCb2*9+?pVNG
zyJHd@*)~~(B}tGNiK||*m$+>bLu$`$#knAIiwgj>YkKbAkzeMew{*5a0X4!|7^EsV
zA-9TXEL5y9D_OM}{e~TqHBu}1Zc17^;Gg7}FrJ#d2QGKb&vb|sf~hEEqJlV!_dS8@
zv!kM6QZ;U&K0zn++Ol_%)m3_^!JQ$)&6Y$d3m|>>pRFlxg}|Q)xcW1{rdJ!G7%4#z
zBX~n>?#K}B)%NU6Bf0uOGhQTHFJEWOh5vB;-cE^m%{kp_{4XRKSNZs`4;WTRMPC(=
zDd`s`<=G%G-*?CqkewD?P75697LqwWAA`et9|)9?*IF)FSk++Ebuj7v%H^6~KYsZF
z*0B4=!#?S+bECur+JaCbWl)hb%2rU#C+bbe8l_pFWI}|5_{{p{Pr*n?tCZga$biP`
zXBK-0>N_NLD1lE1n3r$a?fjbUSKORk;_o7L8%FrBAU|CJ12U#&#mEDl|44xwS>;FE
zLK#)x1Cnb}7%BnS?u3f(QTB1`&>6FJ-SuG@TNY3%n3I)GqV~6HyfBA)@~s_eum6sj
z*uTI13`A*Q4{TF|)osOq*Dq*DM$6$Ai52@Pd7)y8H|JBpdfhdSl==w?Wp)xZ-?*^@
zaLX2Biv-Oo{tc<)x@9F<2?;wyCDVn1htR^N5+l3YiCh6BAjD<i-?#Au-(}a;969$_
zlmPX_dO5(Y`wQAX7Sf%0Je;IcpaBwNz>16BHRxTPsE0W=2eh(LDwU7wgG-*NerEPa
zP+^Cxlvm4M13u5%Dhs9xPOrp?VQcpZ)4yCm0jQQ$v?DshwkLHx{zO8##RsHn5Q|5}
zk8WnK3Zb)9n|)T-k?_?jE|7zCQ`kio)-#VUvHC7h5v=D?)nrY+2;I(lA0(-^BOJ}Z
zq-`<nI17eNnS&XR+1Ba^;aF=lt0-yNWiyi3Pl54K2KT!Y1W<N8Mg7=>Ug68Hl4{`x
z@BvpzAXkdiOhOWgu-xyFLEMV!;u7pRKW*>(LIb7VI$BhUU#WfNAd$WNWVJ7pPf^1o
zaj^UV0(@?JcXM>U6di<a)Y0KQKpbZ8X-w`wiQQITtCM#sK=IG+xY|mWgXhLxPro^;
zv|n#fv!2FDR$=aQ!`LUc)+FO@Evo)~_=j{4Ka(K#@)_>+&%?_{JXQX}iPBZcohrT9
zjoN)VZ`ON}`zt|ubeUYZ5!ojH&*ryeVe*Uj$B<H`kS!;>if4?h%QXGDv=g7ijg!Sn
zuc={bC-;x=#j>nGxos<Q?Tdzfi@Vh2#==SLAcNwe`D&2|{c7&Lv0JWks$}VU=*=z?
znW*bL<{4V=A_cCN%kEJ}&vd`|)Ct_Yg9`*9Pa-^4g$Iu+zP88>hmBX#P`3pW&gPOf
zqjM}tl_y#dAs-d3#k^7;ck5HgpSgwdNKc*%_o37vup<mlQ8IHE^2I2ea^3*xNP>KI
zCL*M!)AyI~E<KksrNYw`fs-SN037~>3e$o<uyv2-*;+u>BJcnJH**7?w$q;Usz8&)
zJ#>{QWM_vYM^-dXXfQZZLCyQn-%N{EeN?<91Fe0nV3Lu-OInWjh7V@h7PLWf(tDSR
zUYjP&OS&3Kz`!!UEa`EC&}*k|xXcCe(w3_$viUr)s{kOoBwi&(FqC&MarKJiv#<y8
zr<624SezlDnCN5+dOvnD+Xr%NaV)12Vp;vUL2OHZmlC`Eq!WFxMpb#s%}+5yOLkgP
z^+MFaz<+01hDIPs7Zt0^00v*f^74`!t9lCXB&wt=da%d@KMqJt;@Z_Fj$2@5BX1h_
z!D9$CGznuvH|qpLDq#A+1EDeRQk3dKT?~Vih)TD2)nth-slVTQr*hC4rqpMP1F3qH
z6^r{Tpb?*ae<2yyu~ULRCE66R+>Qo-NOBQcCH=p(jjAtbSImNyDx1&l{5i>8sU7S&
zjcatm2HH!29Y(h;icDRvI+15})hianPR}{Hsl!M3Ozev!G4eS|9vx~P&dsna){?D9
zcNmf*?Uoy4H<-c248sSd2$SLRiSQ(#KMBPF`JzI(wytFuIl^oRqCJCSnkD^|F{kha
zpF7vV-hi)Pjnze!Au1RpF{<|%aXfexub;ep0z(u){M79od*8<FI&-#f!-eb}NJx>P
z3|&YcFt?g8LNw5^LwZ;<ca#)!M<%bWQ8+rMVJ8vASbtc4U;%K_5#-vK!-czblVQaN
zLj#FMW{@3f1E_T9Ja6Hasv@jW$#HvKzL4DG$S(L;D?TIgZ3jh=MOKB<99lXMx>2{3
zl!Y2W7-qei1HC5IyX}1)&0m}0hxJvpt?Gkq1Q7-DLZx}(nnn-LGK>pbCd>5*M*>6=
z)HiA^-5i?Vt2T-grnEL-4_sF9c*_k~&;!YIZhRJg-hkd~Jz?A4ZD`pMh`)~KP8+1u
zAG%?52a7~V=v!Kt&2;6a^RVf4L0C5)gciDnNtwu(JC7YyXo1-|OP*z05->EI4XAmd
z2>>9TSwSz=?Twh`Y9vB$SG_2k+^H&xg<O}e)#|8CmTxC@4zD8`1$H5qVmAbzovV!w
zR4QN<IUHKUgL)i)<`e&;9jQ@eC#Tqr*2aKF9}T!6|001>I~3eJ*9dK4hLhFig&0Am
z?`k>tvVpSG{Ujt~(p|X);Th*X4A219?OITMSKV+)dy2tB%cCr^bVIv1eTzmPkrjUk
z{DxoC?TrO4hpCP#47o?QRBptkL1Vi~I(^#F@;X%gney2H$zmtUFP@S^6@KT`zEIV>
zb8$lx4Z2)q=c}$%dCHS^=}ICnAWs%~8sWs5BQ!*4=L9b>+qysx6(D!2->H)WpIT~X
z#A_(Zk@}Z%qK_*8Y@l95y9pOcpfuV<sS7Ho$d1~3fMnFsjx+DBJ&#GU%QDPQ!`tVm
zy!3pb2sU1cCUU%Cgj%B1Q*xs}#LF&^T618Y(P_Z&6GTOJfaLF=lR~B)l#9Q^a5vP$
zMYHDuo{<vv&pICWpafc0dhrirdAy~W@CvQa3E8+S=(dacG}?A3RGc6^ij{*jm}nXD
zPS-Fq3;9E6967sN&i^zD8J|zD{{=j}HB6SwZB>N|5Xc7G*D)ti07z{;=d(Es^s4@j
zq0m*1(a~FLRYG0NsT#M={ma)lhRRXG(%LSrl8rN;3E$>x34Q?>c}o>VxCXjhb)Hhp
zz>3*9wjQjsNsxm!LF6>3+)3WJfiz6nW`OpZwm7=<Wbx*2et6myPX|VLg<5dMvN&x$
z=}oI9)(uos5Tr_X>^Wd`miu_{rko>6s`Wi@siCNpJv@)y32+{+OWb|dwJl6G*m#vA
zhxHP$yrhSyF@Pnl5NQUpD@DW=2E=w?Z6wbbROjUvI#SXxO15$zo}jm$evs@yj_{i;
zs!?r)llCzH;^{0>@d!UJA&cVr18u`gk}W3zKyKkNd6&y6qXWx{ANnPC#s}f;ixZM;
zt9gbUa!*vuf_AT@3k{WUlD>rdAgE!f(=g9)`8mY`U3d=Zq34A<9+U)nYF%6~sgy_8
z`^1RaHUDII8d*}#V=RX28NuNq^&^9`;(Cr<Ls`GZK4}#?Z-@xF1k;{|F9bck;dhjJ
z$a=sq@hjYZxa@GI9Xf1Z2ea>d{Tv=?KT(_>a!OQ_km8}jD7rb;ie5(7`+%*5#F3c*
z6ZGP$%cfNJ!PxF-@!4ByZ;t5gZ+@8G_`l<An}J9JwfuBI+UmZt+JjYWHJUfT>H-;Q
z<Er&wQYMAT#S{KYot-=QJc0?qSR>_>lSQ6%*UWCRQ*>(34O})KV^k2r>xXY2hPRJ&
za>TTGJ3~D|b$Byl`??zmI6M^;;);^#anqIXGh>bpOmwR*L`G)+>B}$ES4b{AWHoh#
zJBnd0$0Oh>XZ?-GDSC=X-ff<8r`oRa+i3Z_Y<;hkPEvU*HKm}o72M0x3qDCqE#+gb
zHqHm@po4sN>zrM5e?5B)RnLg&q~Zgp>;7b~v$}{BTDT7`A<WqDnm5&zbEKVI9=o`h
z3$D3as-3=vT$%OwJ1A<}u^rVjo;YvxT<r9fGKKy>>PeTRISvSe;_*<t$JE8=6Ok3C
z21CHeD+OR!Y8q{Zmo257&!M0`tUOxF>b6E*OYJAPOq{+K{=+e1ee(mZUg$wNxOu_V
z?7FusH-JZ=l%}KFhEfbqlIfXxKE-6<bF}R&S1MH#7c<{+2X?&T?JD4tXg6g;UW|DU
z)OjuA+M?305?`lc7gMsZ^I1}X4gTy_zUf5X(G`-1w4Lt7b(`{JUhUvqt5%X#o0auy
zUk@G4Es?2+Pl1xesaC%1WQaBw(uYszEuPdjeo#pws%S!c5sY0aC{#Yh1^g*5Ep;vE
zeAgWixNWgSwNYZC)qgQKNK$InJ$tej=u=e$Mupyx4n!qQ>Kg7<Ek-Fm2$Y9ca{f(0
zn^GlbbWse2fthxdyh8;h>05|2Y(YFt&l8Re9gOI7IGip?b@yE9`Kq8770(J)x7$e$
z3cVygv|xl+m&C)4DBDprRkTWWr%8mg&RU~&l(Q2#KLvHh#6(OB`O~+bLwn=1w?Eh%
za+0fM!;bKOZE7BU!#lZrqLXg$T8?xgM3?>(luvsCTCz=jnBVlM;GFY?WtOFK5V+-h
z$O140SuPT@Riu(>;imrYQIbK76_G)kQ_%{0Wx`J7F`fyr2xt4p+TxcFP}D#eo2Egv
zhvsAl=8^dxaYbJmH_j6^2u90eEQ72Z>to9f$5_X1%cw?Ddmvc`L#vEr`vn}E@0)Wh
zaj0YKLAFX8RW8&h7rbS-1^}z2PdNJxO7aJ{8}z`o{&b~)rz+B0c|Sgf@p)tvpQyAe
zkxJFIxd~(8?4erWFHN#)PUiqR%O`61*g&ud@uFInXlUNi9k!UR0RRe#vI9CdplgP0
z@o}+4@=2{niDjE49qEY))l>8fIkWAXPZ@0`&%GUFNP*6Q;K-Z=y;is|P@OD-qK2f*
zegt{K2tPn>w%*Z@sKCXgo_B{cTkg5lOPc<43iJ2l?97RA?A19^i-TGvg1N6@T{L12
z@+GTtWNB#6Fo}>-0P+BY_y;$#P*qGXn<SoJpj5ksdQ<IynfiTzo3vG%W!F?K$44TI
zaY)OVeX&QDzgR9Kq-GSrZdK#%z;8LS3a?-jG7lDG{c5=9efF*yhMbteX9v^|BtL!o
zEkmq|#@GBQ$#H|!r*zL#KfsxTF#_1<(z3&gDwg-QVxpQuNgDYMHm|3i*csT08LV_f
zmzZlTJ_FD)pbG9bwZvm^Ks(MO-0c{JYFG3wOD5+~j%Mo;6IUzyz@)~2XSPECd2^c#
zuWqW#oD<bmtwh*VhxvGu6=bD2SOG~K$CZbWSK?|$Lm)mB>Kv1e78p4Skx*F0A}o7Q
zMZp7}@R#B3rwljpG{%mSU0b(8Dd2!@Nd`B|MrD@4y%3H$SJ^%j5v~eZlIQiOmtTjY
z+zNEs7SCnb1aBq%WSp5s2$wnuP?gzza5Qt+P=OE&s$`MS)U4KkA2Ladk=@?~`GYkT
zW*s+KDp6G!@Y@`bhj6^H?;<hVH4?{>;vuTgJK}I2mjmABgSWqMOr218e;^#s+I-=W
zW|wuVRcY4rlp2r<LY;Zl#f=w)ETShj3`#d-cGRlZlHc$*;hTSE1NAp-p#FwmZDU85
z`Fpn|#jLTDJ!cOM*eY9%MH+cNP7eqMT7|1MS5^@kRjvW3KzF%QyFEKg+DYSM3YD#j
zh1X9()~nmaDAyTFFT!8c_Ln-T%l(y<(*Sd6Ul&l_a&?7$N=Bq9bb}2P2OC$#8Z#HD
zDYl&_e1PF`W#)Mb+9)M~Vw(@q<GK-nf*Yo;aCs4eBQUq$cFQzdXZRBxr2ZsSWoElP
z=u&mZEVXZWjyx0sf5KSBdzuGR2CV6cwd5~YOQ!C~%a4K~^}rQ`0WYBLZf?A1)kD?P
zZjUc3w^?P5e<78i6?~GqNr^y#>A^n_P)&4KaEs1FZ)g=$cu=r~5=Z4^ZH&5jfJ1u5
zn+RcdvEQEJ=uisMO-|XpYfCWaHKIc0=0_=1N&!}dTUty1NBHjF=e_VHPZ_!S9{AA;
zJLpS7&CGgcs75)%d}3O9;b`1${9pK>e{4{(cJY!3W`fU2yvl37S>COoB%@iU*j08}
z!u$e%Xs>TEw1uWObHpOs#9G9D`TFEQ%8y?@4BxW{bx;Kc<H}BeXJs(B7suGMoR@+~
zlKxqt=9w)vC*_gve8*5Sm^qxaP`yLCH>)CcMOwI5jLswMI`!t#?MiibX5;#YH;am&
z;<5brbo0&|_|X%TV50*FVDG4^xaqRm9CIZ}1U3M4%k9cMKr*}`wZkZ7uOe%z=HQMA
z6SnYQg}?uMTcEi&uHl$D_kse4;}OgUW+G`c89+C6w&Utr$PpmrCwhao%;t_D+t(7h
z9?tZ<gByT>o$aHVn;#m9RI4BciD0D9Q&1=<>U)!WYr>Qy-^K@%oAolnNnRe?dJqhY
zasjGaibpfG<}b%{$J!=xu-4l6tl9M3;K81w&Ju0w6dQ~lQ+oEd1{+efcWU%*y&GHh
zk~9_)W3NQcT_rEIgX%0f4K#L0x+p7)@mOdUE)e~<o`6QcZFpLzrUK)FrC}=cq0~I~
zn&r-RI=AsWBP)EZ7cgz1*UmSP$8cpBfW{0V8nR4k8!RX-Fj~)TC=x3K8Z((zU60}Q
zU%&Z*YwZ*Z?Bt~=XE@JV*kx2TTc1F~>kLVuWRrA#nZjWJ)3~4{dft+*&o$bz$o#1j
z(%7Q9K-em}X5hBN!QFNSSfZ4g?OQwqcL9T^y$-Q^KLE=(MDJgfPBT0tk6)2q`IYVO
ztyjE)fwcPIN^9GUDU9MO0PL1`Q|%0E4uO0xD-%p9hzqh0RUFleCD#4;<%9RqNGW<9
znz^h=OYNXOrz0{Ii;@R+55;3cZ3%&{nc#p@wn8JfS?XDEmg4CSBNFGdyl0CfNxCPb
zK&#g5z@l5+0X%X$I%9!mW&IH4QX-AF&{)pdrmuilk7RNPLlycs2izEt{~SBmZT=PS
z_pg#T>_Vbdf+nNfqns4#zkDOEi6k?-OGyU~>0rt6Wv>C}fb$V1q`Op`Qis}eI20O%
z=R`VQ9Q~sK@bX7=H)}uT=?N4r#y=a%0KGpT<E%E6`|w2incV+Qt^Xt&g<$VlqGk=u
zvG?VnX9$6h7ATbtjfuO|y|6-VwwA4--Ve)CeQTD@SrjnxVSgTosPy4Kd;5yeQuV59
ziE0M;{@Th%(Hh-al8gH7)jZ*Wah)!Py^uQ!YL|=I0}%pPK#?8)<akU=0xSNWoDL-m
zsJs)mK(Ovkhh5ojcM{oEOww91vwD1RkOviDI|$IyWL*wTO$Sy%)CF;GviMb+4Z1pJ
zI+J2%E24&w&~o6SOA)@3>|IJ!Yt!`6AY2_`DLOTVfJ*cuWT^vn=fcj@0TW8q8ASiI
z@`Ie=Q6lM%_7R|TuDS;efj*vA%<ht&5ZiGOMksBM!YP8C5nVfOj#S@I+l430h;SsY
zqj<Qi?FS>F@!8Six}Fn$H)A=u1Fjb?ic0nHJ)D&k-UHV;K2NUxJVj_pxN1+NUm@l<
zL!cJcRqYAbmArd4i5uiZ7u5{6Hv#8^8mv-Zf-dA*e-Q*so@e<v0i!pW&@UR$Ks^xg
zsP;hs?%#0tiD(1O_9mr$bd`^~gaJGJAvkRT3(AN)^iWtJ{ss!qqQos;xIEyBSl+8A
z`i-m_2$eTDD(v1WBDd{N3uZpviPEE){|a=_vj&T6QlhlpPpsRqnq4OpHLmqQubYGp
zi6cG{1|p&*W_Ik+pg=X+-W+C!hXv@bf>4W#VMYIE%Y)_!sa%&rMEl++It0w<cuD0%
zxX0vqx}+ou-V2#TR=>P_U}0&7Dmp{N)=OAX3&OafT6bHoW>XxX>lF0NAHasS7z%tu
zd%DUhwxHZX8nPf<S1SQqdX$Kh&kd$|OIL;HluTsV{g#RMKvLVqJq7mFTX?0}L@grJ
zIgS5*aRTHZH)b<nL~uE8ZDdg<BpJ{W2<H-2VAl{caFsA%#tw4m3{YH*x))C91Ivf~
z9<-sp_r3STFFyR13fX6GAHV$tUa)d_yngob+qd7n{`~ECZ(reelLc2a!pmR40wf(=
zvSt`!$&q`3p2^N<aD(AQh0Ldt9OEH((R{ha(AA1yTSsn-92GkvpsJgP__~mzt~YAh
zQThea<hF`-Ix^j|S?>oJtQw~1;tZ-DL4xfX2*igach41E*k0|K!cY=TWUkw5TRQq5
z7C-$d_JRI=vkQ=I3dB2jio@imYkl}j6duT=c6v#UHte$FpU|?nbB2bd<$g+DS`hNK
z9v&fozB&q?bt;T!Z*;ApzHfnU36-*mFtvr(UFR54wUtqiFx&5RiY^t6ZfBcv`DQD0
z3hOjU5nx^KS<XcX6vXk~A?y4uES8R;Va+=(aWo5CoF$(rvY&iEIa=-Y|3<AmK?k#t
zWZmiHIJ<hz5ilA$PS|T#cdBD)A_2L$ukE&PtJRfo=59*P5dlf6E;@3x6c~YrEE=7V
z;RJ+C2qShlro4o8w8=XB2uk@~c=;Xfi7{Z;%nHMBj`AwAVr~ZZTU9{9wCGwjLIL?C
zF35bD%O!#_!7_Ks^#N>zVQ$@?ZsB5reToBG_QkpRtt)~_*3eFB&dlqP0}6-|Ibd#C
zo}x|%K|8M(JO-Cz2hD}8`Qn;&#!BmRy#CwEpI-m#+s|MBExe>g>;ucmt;;2=xN~Pd
zQC4Xg8-xyM!eo7~*iVVI2N#z36cd>;z1xb`t8I|`MeSh>7boR!1#zd|vB}e7u%kf^
zkUo?%wY10uL#q%kmvYAVES1VuL0=snv$E<uXN8y6jf8^RNbV*KfO8iw!KW88rt57~
zi6T-4LD0!{PipJy1p1djgYmC%2Y(Y@{|!+hW4G01jD1H)U2aP<9UEGo{K!S`lF9c>
zpCMwNK7(pBVki0xYJr!~j9it1*2EhD?%O-%0p!`FWw%U)9Z`)7WSs$ewSEiXMzWZ!
zPWVUp1?ykLK*LWcD|Fz949()PR;30~9^pZ4uxC&j2RL<l3+o<R=vC|Y$d{yQ!GweP
z7W!M(QH7f~+i7aK?Q*B3ggn_D>%5;CezvPDZ%F#VMN|I-ItPs$`RQ?;RGi#UK*-{F
z%q!1Wp21m_ktqVINW^ioFtx}sNrD-*{99_UoHw|LsosFQP@w6aF1&_~Ii%O@;Xh#Q
zfR=`VEnwSyxf=#1^nH<^6$@K;(~;$Y#T;vxbugCJ5CvY3JWWhFaZp$hF@$5aeIatH
za6E@ZXTWPDhxATw3yTjGI&=gxaBV|^^GPAK)4dEOl^v{q^MC$d#<IGjjpx=0$V}zI
z5%D&&3g}xo85?%zi9APDQGvl$<du}1t=uR4+*q)XlG;n>Axe4z>Iv;+;VNJ+5C=S8
z>eJrQZSn$Ow;q%P9_#P}2;QQV6VBvBqLe%Ww`X~V=s!4CsGua6dVx9QS!*oI<(Do-
zdAG~x!}0~yVo56|$Q@cz*mNU6Qzea_26j5psh>v;8W@31lT*9qJTO6<$2y1?Z9TGw
ziB?tNfR$QRCS8UTdId1lS;0B-4c4m59u<4nTwN7|mgesf*Pwjsp8{{Df?rm96}K!4
zr~;Smz|uqI2JBocoP~|{aElc;b{Wy6q$8?Ll(77vAYh@us{#}PYyNI-OT4kglXT?0
zI~E#SegllDz*UJ5V{nhRR)>6ObW)^Hkxx#I8P)BzBC-dfW8_cNPpNU`jljRWe3X6<
z#~%*U*E?4tBx+1(cFa=iaF~M%Wq&(GN8i>@8Q!*q>!_o+iKt3U)=a`w?zlBFk|GkM
z5dhWz&_dnZSa23)%51D>h>w!CP`ERhK&gC`voA+g^9Lum*7l3-vN|+IvYr@nu5O;-
zaPu0cFUdXka0h^;l=^X@V-f^=EV0w=WYOc@rp|cGr749WCk_)jFiEck<eUo1p_ve>
z3Tzo>L^WjPKa~RCiPF=&2e07<D4oZy4}eFr8LAE{EN67i(G#<}CV%NCokU-Yb=_?H
zjlg`!JMq4qBP1}9t&C|s#^+VbsaeNC6qYD-CcGzO?hky3=HG|o5B3SNgUH;1I(emo
z*`%Azw&CD@2Y_yqXjrIG6Lp=D7T@W!S!Z9NqEj!R^k5z#Z~F5LMu6H{W%+|t53DLk
z->$j-X(-9AZq2fjaPrmAqqY&j0@N7EotloVceN+9NC&5pM(Ty$eEy_drQ6DUm|Uu8
zNt+OMD<r4VfffGd`*sR%mh$$`!SMLN95V~(xw@dTp$wh^$o8;goJv@(r^+F|X*`I&
z1xwn5YUhGpZ9Oi<*v_oS<tBlw1V5l8C6TLJbnu!8jM}rUxhG;Mib--qSz7W$u(D-o
z){Qs7UVe;st80BQEh$7P|E3NnCJ?kno7*PP98PhdkkFBZNa}4tL_1omy&GA{LrrT(
z;%k2-@iY=o8`QiyTC?{U!!rhu^04K`cGRQ+G1!s1lF|jLyH2i@Cg~s&JG))YB|CCU
z9+2W3PHjIG0kOFgCjs>?P?~a2Z>i>Xk~0GRn0hp={KN&M^Z}@v*;J=Mvk-uPtyh(M
zMnmARx;|m0aAMd;z&5LLIhgeD?>NpV_TR~~OEZo1Owo%eBn{_{-Q4p4P8E0eJx6Dc
z3FaC+Oti?(=56xYN{;9lvwgMF!f?tZ5H=aw5};3Ae8z0V#(*2lPpr3CD-r?ITKc2_
z@6%I47CN}MD6cA8sB@UZ2yPNFFQvR%LA>#h2ek;*MP&*@06cg>lZ=17(+OD&Cvyd2
z`+AKj>1<R1V^4o1ZC+Y?o|5HME(~%G=gmo82e~T@@HUrP1GMCqxUidR#VS>b*1j7+
zBA91(E;p7WS3FR`?y;dy>^W37@FfPmSm*BG+6JC^LC}t{)l9w7s1v1h>)8D)=JmEf
z>XB*JO`GTG?!balwvq26H{^&u2YhdWD(T?pWh0pWh4=d5s#bJ%G-*`HMMqNCfHbt+
zCc7$hG_t(}Dj2qPwY;<2t{^5h)Bsk8LcRTrzB5%;7{-w{HrcgV#fE@rwXzKe!WpJk
zo2@UY6z$dAsg+{797CFB%H~MZjsOu@C@HxM3GpINSY43m<LnZvlCgA~`J|9qa=jPw
zkA17fKF~?1)-GU$W`!e54CJE)jD*H^21d;m^NeoD<McFY<Y8MC>X@;|0P#9xm!~*j
zzBEHsrzJpR9F)9xwEP5~kx7*Lj^1o@%OeIOC_}H2I!rp4&T5*mJ7dD^Ik-vZ7a$zX
zMDAW;W2M^=QjP618#0>VG{wv%FSmPktp}C1{jI6iz5dtm_EU7*AgUpCjuhF*7<u%c
z5l$`rLUnsLM<5q|S&9nCmtjpe&W1V8dBvWc)hMYZ`w1wGA){y{&6^-wmsWTI3NvA+
zlGHe=KpvFT)|_M^rqTwQ{^-2*n;-4xqpb^QKdP`#jI)O2yQ&<VZbh<@47pn*NzRqW
zVsgdMpN7;mX>0WyTKAJ`N?4c3g(p=me|}HBtSTB{B<;aLvSvI1+F~uZSl2p|n)CB^
zJuXDKneBM!&1ku9;(iF>s)aAd#p=LHVE4+6;bskU78i%bN@R(If&drIDYaw?)K^fj
zBeej+#Sgys6=s}$xZE=kAUEo#RzahZPCVqyQ{t6@qQG6X^0QL?YFX+8<zlG7med%^
zolqp=rw5hSdHYya^6x|XqLea|SOg6XBsL#abpQxk#o9m$-UyN@kRKEfSDf*Rj*?9_
zQnX*|j+I;t$io*tE(aTAc1i!Uyml#<dv^7l60Y^K{h{u_h%bAE+-q?1fW|PWSc|gI
zwqCHM0nM?_)mkrTj(JdM2>Pm{3cmN*q*pTBy3$6G;elU23ojqMeS$(adjp~U#1J^3
zdYB42{DJhy)1w1JhKa=<8aHuKr9h-tAV%CB0e&m`DZt=5duywaQIT+YGkkzk^=GH`
z+4NM3l_%SM2~W_Jdq3doq>rLAP&Y{m+O8++{@BQWqp6aW+fhYOA9pQrLk>}#ax0bW
z2{asCY=3~YA9R=@rftojCls-JR`<XoPZas0mKRK3Hw$|=Fg;Vr?jpZ=#=^Y)@$GZk
zXM}J6LHe&gefb>^uGbG<K70EqOVRv&IR21U6+HErQ7j!`Fmi~4U<SE&^f)D}?!fuu
zaWz&fy)k1Uq!iwdhV{;_x&%-5zCSu$D?U2QTSL`MPqG@SEl^pkt^+}F=@!+A%E9Mj
z==8TQZ0mVN0{!^{@W7T5U<D;f<WjXal7}o6`s$MBf@L?4B}0QMAs@sqQ0oOy<}HX}
z@L1GnX<AN<gHE$w2mSdyQ>!zI1!BBKSU>@jBFbZc{KykXHc8E-3j;Q0*AK0&dE4^s
zf5(qKKmy~`vl(=S{)g?;>!5Jt&1q^QRiXpsHj+Ul62JwH*hWUW=&iL)h390!vz5XD
zjhJz0{4A1GC1#xM>&H-L{0R^6g7c8xV$swBgkU0S5DFW}z(rcA4~w%s$sKkuob`vD
z^@>R;o2NUZz`Xe<M`4zjxIj?T@#^?v-Z}X8hHw7muqCwNv{C_kfqB|fVSxl@(kEHX
zS8RAmU3NytC&)!uWX4!cZf`TnZ>1Y1C3ul-?pg9rW?bb+Kd>wjp<PEs)SL|wt;n9a
z$~a;~t)U)G6|3pSBe1b<Z#z14azGW%uac8Wp{_#~c120x)Z^FB-u?sy>>l$kl9%L&
zq^x~qA5)Sgsmlr9gU>;>pu9N{MH1AM6&2+&s;LTe*77_6B4`~nNABK*9U^*1bt_Q^
z<7{wCF%27S30xuhC8-ND?od;|r75=DlR9(G4u|N$TjP<}aSxd$6o-~3*wv+l{1b7`
z9c9qure9*3yxGSbE95dZErAV~O7>d@6=B^qvmO29+%kn)qvw<bt%J!ko|P_x>MnPE
zz;H9*MOjqJ3UJ2$fWGbB6VNV#{$Pa}2#c#6ydarn)x=VLv}0#ID2b}L!j@U1JZ^ZC
znqo22=qiv*S-GpO`bt}a@y>r<46+rj#WY%r<qlODo39i^Z==gew^k2;+FQwl?x!$M
z*2>vrfdgP~KhEvr5jsp7rzv*L0didGIGFl03ehp_%}?JyFAslkdi{UG%ddf#ydfcx
z=fIBB!0CpfhP&fE?7if@M%V8<0}DilX&mg<<*F&8(bCorZbPO0b!v^LWq`xS2Obv?
z`I!6FaZ`Q$isI1)m{}{OjF3F6c6XvYQdP#F|0rCn&}N~m?isPi;^KHvh>^Y43}bGz
zV3Ieq3jvOxXxW{0U2sJ2*-o29RvVbhtJNxCEl{`^0KINJ;Lkpl!1nURDPdO?MMBJ?
zMB7TTaJdtNLJtza+8P@6{I4KNT-mn8;93rj2`Qj`juHd*BnD}rx^UCAr*pWfAGC3%
zp&tZ34Am$TgE)OiSr}hIzrswPBrR=KUwLp+zq(>tg0tSTD`6kI#KD(z<MoFxzt!@!
zsC`IK1GzbNBathnI`<%}_kNdRV_QfkluQudAn=xE6*;qFNSo$pe^6->`WgK6<a_+@
zeCb%7o@wify5h#wa|Nt&XIzI5ecJS^cJ&-{N-dm%*1z;2|C4R+DX{MdVnRpYn)11$
zLYr)zEf9##BXGd*%k*D=HvmF+c=eZ$jeT?*3Hx6mjt)s`B#?0>m9@Y^VBR^Qk{x0G
zv9ilEJV1y_SGiz<2z_bqfrhel#vrJdPPo}%%t89*JtARq^n$yXsa8P?hcV`-1k=h+
z^!<$#Ph}NY+PJa0B%2EauBl9zDi2?jh>ID$vLj`(RR^Og%Gum81#$Yg?D^HH9vO8B
z&6$n@Aq|Og*ki?zH6h>>AWM|XssJ7%qt0v~J|(aA6jjibKh+oZ*d_d!Gb8p|RQ=p}
zw2ZdsRNd4PcjR0q0|A|s2E*s{`P4^-P2(i(p^$THNg~C_O2ET#Sd?Fcm!IiR&$<d0
zRN=mDWEJe23NkX=2A0R*6^;(=U4XS+u!=aSm8D{49hgr_UY~wQ3Q!PpPp_D`N<N&H
z`+;Bf%5xQTJYrIq8tpj5fOQK(wj`wi0O;D9y4u!5j{zXpXEleiQh|`j5^)*9xm^!E
zLVQTh@KP6kZdog%%K`%)*f2TaQYz(i#DIHXpSY3|N#|S_u8>}r3$1#<U5loN;!Qjx
zWpjIiZ<UR#>QSvBEkiFO)>Szg5=Sj<ZT^#N@R%V>WI^t0;wF>oU&maf_LN<P{8exz
z{BgRh$T9m--7~mSpAeA0MspGAWrXq0pynJL(^r8Ebo9I>FJuF}2qnjD7}nFGSHs(N
zlMC_d&XSaP_vR+Am>%xPKFxVk?_FC`GY9t%7-!hU066KFrUs`OIL%&UD6Z@fR2N_1
zWq1OHT+vLr(6hbjj-*`WHEFr7`ooq*tFUQ$X;c_%q23#khX5P*dmsycnfjy_O9odk
zT8d5Y4;r1LkD~@i61&Yd4rCO{>4-~x94M&RxdQ2uFwkEXlQs1pwF$3^AaCy@S*$3#
z>XJ|2U*-eW&NMTmd_dgj&}v?N21ysia>jy45(Pz4W2_i>iyktUr3-Z`U<2e%d$$ek
z56cnZYRxXZiq~$oEw8)%=Z(q|rJaB&3EGKLEf=eTLV3hsTrniOg^Wznf}!dxxGcz1
z4I?l}V)*PkQnf(R?Hy+{aI@N0XHWdBIsbrY4RDAzy5+(pAfY$$z(me&XMvU8dqoYc
zZKkIVNN;CKDN6Qn+d3(lo$o65YFl)mJ<hHho2;ThXz0mLhH<m@#5NBV_W@^t%Mo30
z#BgJ(I2@$InUbVmf#0xt{>rkS1u97SS{I_)Mo&{Bx|8XxHt6fv+ae@o3=#$b@{!PZ
z;^V3k;v>?v?N)fSL(1hD;jXI2K*|(knSh(y!OrdmWfPikNuFp*SE@m2yQMq;@?W6`
z@b+8Pe%vjcTYOBj$gy=h0YKfO_H?E1B-D6PaY<XI7q=ctYHDuimc3E0p<*v5bG_u;
zmExGlg(^R7-<=XZ4&%J9LETFNY=4AKl{^L<zN>zira-f&Ot)-s)5|26X^{i5Fr8gi
zw<u*q+jqwEOrNXT&>?UuG(0Hh*A&|-Y1O-};LnQ*m%LAm{_@3y4nRkXoE0IvOCNB|
zh7yWz1(QkAx-RC^utdvD$}g#X!6A_2ZkANn&fJ@nJIS-V=Ip9-kQ`|G6hB`JCH`fb
z$#HhOOI23&47IvS8rmt))J1TxO2^!7?p4+8a=M4Rd3moRfCc<}iRlKWQZb>8D-b)C
zzTBBu){J>8HEepDwurNpS@l<Cz`5+lGO|}PFYbU!A&;cR!~)#J>fy}Y$+Zi0aA;9d
zVYSU!r@YN(1=`L}kM@JN-@kkn(wFp(BXXGZnxV)Ay&MjY!uev>ta?g_W@U6>q)?)j
zhjV-7ZGhw5nH{e!$s^d}NZoDzpc4%@-lH)GDB^+BjC(=K#NB+u(?7<90jUs*e0k`=
z&Q5?*IoRk~PL^F33$tQ5>tUh-h^Q(rH0T?|#k()hq0$#^Hn6;>5&rHDP2K!-pTbh9
zBtq#-sM=`<I6u991R#~pcPIf3az7TT8)wh9Y~@2;b~F}$_x9rixyNkjPnP@NK@_X!
z!b^&!x&U`>T9T@Cp{Z)lRM9+oQumOX&fjP&(5jc<X@KoaBu-cs6aMFiBQ=CjkkxWM
zHyHLvYRSy<3c0KF9lBCdB=>>Z^;mf-Z<jMT&=~vyYx6MJO1RI(!9eUjcIS+bQH-wL
zd2Jj@m9*LN8uA(6LSEQ*8A8!)VX(NV)|wq*4;@@AD$vlV^i`bAvwPuMsYVs}wS5Av
ziiMO*0^_EIO?-62vK#|37y`1QG)$%Sz0f%|2+VNygD7^|<^}+ZJXG1iD2wD%mRnuR
zu^}N+KkV`d6^Nxp_9vg?szqp8dQyN~VxG&k9%rge?XDK}F0aM~5Kwyl?IRkEl&}CX
zU4FOFu&5gl2k^X~YnEG8Zmk*wy?pli={NrjTQ;aKhs-&HEeUMZQ6!X{ZBDa+Ng%w7
zo=eYGIS_N|es0)P?PqV(soo)}BmX&wQ0bp4+M9mnBS6hLlN%R^`%)+JMj^6s_7Kn)
zfIvay2ATkOKTl`&0Cm!$u+Jr<<iQif3FAmE_;MTUpqh7hhrTBsfNpkrxwj9Kfueq)
zlFe6?5K7cQ$+3UpzN_Ga;s}9mWv{Ziwm>6#&J9bN#<kW9GNJpeOY(zG9q42|`{YnX
z5U7F@;XEn3$_F8;z2GB<7KgN*HSo|V8kP-^(U$$+AsbB*0CsBtoEy*;N2g&}Ra(j;
z9<T<v6)iUtNi#rH#M~Fz$q>oeO<5X!$P{h~9+eYV0q?%?6@eTMFQ1=u37tFc69}e*
zzL*p_A-F%sXO7XJZDZ%Ry0DS<>DeZF_&1=hM|hdqwo!#ZK$i@ec9YBJS)@v;>5bLe
zc%TKMq{eaxNxcuLn8(AyhKm)b^!&@$&|yF)#&Mc=N(16VA~>kJ;1Sq$OQ5CaBsxjG
z90?YeI~BwPc3-<ytaJ*W{l-2Co68$kq>16o*ap>uNSFJR1r1?<Xc#;sZD@L3SQWIo
zCCT1wsEs^9v$g^V%V%Rt8yf|wyS@+=&7WKtO}+9QdK4}$)LdE)a8YRiNTw)fwQSMY
zw?Qi8Fn&ynG7KxBTrSn3<ob*s^09Jfbk=kUfvCp(yjELwS7QYP*w&k@*?mx9KHN`Q
z)Sx7O(hgrS>lm^swwyTaZYl>=O?NhVimGw#=^3mLW~m|`;o$_<Gt>%P#jJ+>>4EGC
zj#E4s8Wqij07XE$zlL)q*!#Wfu)O}e#2&kWqcf0`lWw{L%Z`y=1x)s4$5WkZQjV=)
zuGMC5gTNlyHYgRxMT#W3(4I;QM!tp9fs)Hwv=WEjsb&(Pl;bv3Enu?!VU9NJgf6Wv
zl7ajOoIkJH;1`I}IZuYVvC6{{Is{y{<*NB;7j`%z%>YVy&8UJ@PHs}6PA4Q{R@IUp
zJXX~<9f^g5+?t0<ZMA0qrT7dU8*9?`BD1P-B+bED_vJ&2`ZXLM)4T4S?26XYAQ;{|
zZ*T8Z$aTTmudYegpm(oN&|?+O^PCdT1etT5VP()t80fN5^ZMW9@R8qsgM4GWV-l%w
zmLa;NbzeLuCjS*IYgYfJM4+@L<~79~kVST~p^+f#Y<|x}`&VzDv+>Xu%SEw^IJkPs
zw1BJBHuAcqnu9q=tU`Za7!6iZZjT4sXFBb;j<lU0x2_KMfu_|ixsNJh;1w=N>b7G#
z*-9;|E-*2$?G(Wwb&VaEl5n!)53?^5SS$btrBf#AcKmL`v!fA{Mcjo2yaaYzVA;c4
z1!~<J)Os|Zysz+dS2khAY!4DimTiFwYUmJ#TF4<#d+Mq(X*R?zvP;j?$Sf8lcGYxt
zk(0)UC!5ZTxCAGTY|vkRs2N+;l7I<G7c^(;JyF$JcgQ^`vCHgcp|b}RMwOfKm5*sv
z6Oy_AKZL(ZGp;U7)a330TfZpwnGdL2H&QUWInW9s&M6ywb+SXR1w_)rNDZ=9R)czY
zT^u-rwxdS}&NK`b!q5sJ35~8pBgw8F3m8n8sN~4Z>>f)^F{17Dl;Ht+S0A-&q}&8w
zBpa4VghTIoQ}Ah_v9-^(L&*lLqXGpmjZwBJohf3kvIp%Wj}m1ouBX?ZORn^m#4>fW
z6Hc$V#e-^FUt9omD2sBl<*syZOPZgY{vpv?B_IZJ%7BI^t3wh{<3^+PCZQ7Q$&sOV
zaw!y;dLzxWR2B$IyUI|`C$zDPyJLbd``YDj22#j2ajni>1>|CH#7rD08Y)h6WiPJH
zTvEVT=Tp5M=^PJ#ujEZ8Ssy?GHrm6O?I5nPM3ROiI8GKWkSkeJOucIe+&Jq`wstQd
z>mL{c)=3_)LT%?oG|to0zyO)MsfUy>B`J0?zTyfB6*bx5iszynQAw*=2(>#*$~(op
zV8HQI<h)CL<efj>Y@yjs%~+$sx4_{P{p}RDfC!(ojbqt81O!H$E1w|w__6JPIoNJ9
z0P2I4!5Z!tD1A9#rY!->TZtHpP`Ozgp>uI6|9uHJYV4o|m#I9k&78+FnVQTXyG!b0
z;$Q055#{5;<+2JF=(U*kC3;9`hfBKM$lVwzZGifpdMFU8BQ2{x$WmXy_P)B5^|hU^
z=<m!V)n3(SHgf%)D|Ed%!;1}|9kb6;fNlj`T8?4aF{-0=>g$S_8=S}TXcdJ{o?fro
z{_e|&iAd2JCS^jP>Iw0z4I-{QC1@m3b4^E1IQmKq1n`7W5ZJgwy|AqDt(p_7&)hNI
z4bEi2)@3X5s!N%~2MBpo?Md^C+FgNJacZ6UZYya0S)f0#DCY8n)~6gS@DW%~s>z*J
zWdZ&HF2Tr=*nvuD+zBh%mP~sqb>?$=`@QKHQYQMR?lhI&8A^1ll91ouICn!cU$2ka
zxN;>{Cyj8tPj@k(Cm(elBE{yqxs?8_Xl8XBw0#L6!XsM%QHEu7*Hesyfz&{oZ5Y|Y
z?J}Q30wz9?4FV;kfYN#A9ZY@`D!CF=6T#1}B}ura%j#WNtXG*#?!5CThw^gL9lxut
zOj#J0V}Wqha41R9Qkl}YP!4;zrPKIBM?GngLJ+1h8q>=c{2KU;9Z9mQ41|0c;k%If
zWcR^z{1=_J<ir7b_;bX1Lb_Oa%7N8Fz1RW7`BN{S?nfabr@&E^B9>^#g3bf=cn$|z
zxI9UTE-dX8<QRs{WfbLrhSr%+xhnlQYX9NLDyV}QLeCrgV36@e76+|JQSf<qNl4&L
z-H#Xi+r~^WRGYDIT01}?2j4-(lNcJau6=@0qGe$R^52C2>HB=6FQ^PW+e#U5?521H
zkxkdW137L~S72H~sSE}hwC!l%%!(c^Nl4=o-Nh{VH7aIRku(QUK3J2c$qY(d80E?q
zadkad&Ba00w_PvtPj8>Ue){&~WRdbGb0|}ycTaa}V18>!$mpqqBuNS)#i*@3lqJhq
zS^`}AHZ(($2`<Wl2>eYF#n}6xt>NhBqFT=<xM%WSpdHfV^A2bPs-FiBiAJ>?Rj0s$
zlpM?s9K`8aOf77<+FmE!cD9AH6N=G%UP1dAH6cXOH+s*!KRCNyK*7Gins^H?Sp~ZG
z&+OohVSDxihG6h_TRS*{b!ekviQq$T=|S!%cfelRaRW=)bNik)wgk}szpvrje_$6$
z%?s6VtfWvRJmHK>Np}eRIc>qhz>hsyc}nWwM=?7EC~p&F;$0bO-46O#%cPx2-7I#<
z0>g853_Q+5husa~Ol%cY6fN+|6RMa(!aLTVaiS8}6y_?`GjoU;tPY32-y`$>8GN>o
z#+R_i=<zEpFAT9cn>}j=y-T*(9jrzm4xXDZP|>j49$tQ%q-mV!xN6&7;+CD)5^2s+
z;=F3#<Yqaf&Rb6g);m79#Q$&Apr5k_{XGBaZ{aCn-{`1mjy+o~unv*BS3A4zvp&k6
zDPfVl4Q}^RJG4hZ|DJ4?IxLj((n|`-Fd!$+srs0`M7kF4k4@(3OT=H@3;~M6qndu$
zOz}X(QF(^Ll>5u@@^RX58_v6}CiDYy4N|z0^bnYHHf2j(vt{fS7fXD%MTfEsBmNj#
zGL&-!d)Ct})GR<x@0t9meGL{*5V5<ve(kNjX=g?v-0cADhOp&4)*B=-6fH$i0)|Pe
zjd7}o*-Gv?!f6eRHA>TAz}UMAJdl{gL~5$%#vlt6DkMNy$+2}R1LT^ogAu<=NR_nS
zIF-W08c*Q%Uvk~NYwrk(n(RZ&x@m15K5a*?#su8Z!i39aI}Hvxb<&+Va)G`4Zd3^4
zDdz*VZIBpMs5tgP#iG({qf)k>dMPV3slFM1CsK8`Zr{_st!Da}Rs{+PHI;8kPk;UJ
z?c-qJsb{7@cc3Zn$oOT^MsypGKvAv0=h!xuj$M_)NhxTF3jHyFNeo~Gao1bQDJsA$
zml%l^koCFgm%&nTz&EYbqWYD>lg4g4DLp&A(D&$Jl6nQb>JmMXZv~eq%&6)OBNm+A
zu2U^X8BWq}x)dd42#ZQ`$)n>a=m4<G#!;BgplX)|w&jp5k%CDVYE<H<C4!+RVviq(
zBV2Uf{*)+_4*kGU36eAie*;3BeLxkzu#*GqHFzg1wn7>kG9V!@z0d>V51#^Zk(^S@
zv%*d+BFlBbd6#k_aKKcSf41_)sJcflYU9~G4(e2tRy5R%io2Pls?b>a7O@e^ltdz;
z(v`>5$69W`{NTo>-wA((0HqCKrul1#&jqVMn3-|8!&632dqygkG%o4cr$aRx9y|xo
z1_mjkZRac5*J==y5|9o_d;j&*mp_EJPe5W?7ft<e2jn=@JQ~)zoO?+sTc=jpnjbaB
z(yg<~=Fs2$u<9Itkg6y@;?shZBYtoYDV#>;L>ezZD<Av}^$wO4CNA&|^DVa*v!JeY
zCocV&l)JO)@yNPIiF1L{*j1eX2*Fhcw}qDinlxKby9w@IC2TC~DMHW>zQNgRO;eQj
zY<bamg`Ea{S<5o?RL=n2Ue$Sc_!V6?2P!J5rJ(`i(2wufub{u%Rddho(Lbj`?^-P_
zDykQ$v$HV-qwDQ8VES8>moUKbR;}aoWua2ajGm>>aLO>;Es2DP8I}0Uu&q7-^{&9C
zE~%HejtA2aIgKE!%8|n!3PS88NK9CWk{TiBK@%oDh}tHX15B}23xiK+l{4de8k33!
z-vg|Rd5|<OhG#=UND(!A^)qSOeYMR2a3972q{W@pynyEPjiFGXe`k9Yc8(8<Jw1>!
zrHwGVx-XhL%VyJ8d9a9Xsn2j$0!7hLx3H5ne@tZL*ik)-Uw}UFo}Ly^ssn;fq)UXn
zojuGY+t2l*gA1Bb>4${QK|zX+8e@p^<~c|%koA#!w6YDi4BA=r3|v0-6rF?9wT;SA
z(O&@kfAE@t7tKYyBn}WOx^Qx%RjZxm>SQ)2jB|!sGeejlEK>yvDG!px!-ozR-w;;T
z5?k2}-tJd$qlLt?wRC!$b=6~P%rS>zv0Om>reM(gQrTM(HGj?9Jhk3qsd^(a?M015
z?kZ7&s%CfZ8?Ur&1Z|15f-Kc5$9V&RewWWhBuEQ6%R9pR%0l!E^zt;e#2?+*!z$Je
zJsTW|_E}+J+<P4~7*!?i2RA-QnqHI*HlPb%R9DqYB~<eUv#xPe+f|T}3RvEx*F#=F
z5(%JV7x}y-eqsThE^{`AgjOeoE0u!_=RgQIa&<uSKn`Te5I|SnYL!pvkuw@dju>>_
zN+29hDh`T%gB!Wj0Ppd9lJ!-R#ElQmYN}{FN1EXVxfB)%@H}zOO}jdMXT^e%3|}5k
zNFCDseg~Btj;Ze9PKJ-7c>ti`6R*%YvQ}+}nSJ!!C@Sj54>r}wQ~o^b)452Zr_hTZ
z(Qc}&2D{5illo^s#d@icpsp@~*e}*k1#GL%&DV^B01e9`+k<w=I!tT{OHS$VhiZXW
zjyrp8b8On+IpEMvZty<EdiLYI2kMKf8aCRVM5rGp#DLSbDUL-y&>c|z<l-aC?&4&c
z8vlBAhocg>w*{qhxAkR9h9MEo^C&yL^dYT+DQ$hGX0}b9BGt9qPNB~UPB_7ojViSH
zcqogkBqdpL?9{2u^U+{}#OVlG=R^!)>vc~=N<}sG+}f?r?Yo1EyGjQ#ub3&!RU}sc
z4A45sm0cj8<EZ5Ck+o^>a=2T1UbGHclhd=7L$~dx<i_C_cRBPp0F$Q$XiuZ{cvkk~
za8xUo2>+|JI^}SOj{t4zh=)Qy`_{^W#t6C@(Y~n;NTRD688JJhM0^3#+4+=gGWNJA
zMIaWmmSNqz$W2oZINPWa_$c;z<0M#~wcCPdGPh@oUP_**xBbhXRSqa}IFHu-jxZqK
z*du&KOSEh49>D<2UK${$krX<0NWOD85+PY2>%tM#vh~lH_%ISGSSY>YKsAY5zI%#y
zUv$_4>4VkN)ge3x*YkOuK9ZjVbFf5Kp9E(xVUH953<Z6=+t3q#2`(RmFF9LCGHbx5
zmFUBeb&M*CO>yYz#m>5vh17ghoHbdN_wbW1zvrHi3!-|GiraLYVK1l~*@!MJ<UYwG
zHXCWuC9zMg073MGmxSxatpfG{BsaAYZbdfa$cZkXAsG~4i2Lr7HdYn0h+$OaricvK
z3uP5>1)JHpYLdR#oN|C&Q3jG(=}=^7F}e?BVMy%?QA0yKI7#YsZ;KYGVuokx_FOZ>
zaL9s$DCq{t!Jfu4KrPkPBhr(F@>jZj@wti-&KJ~l!w$~5MR}AsK)c@#!NU7m$kNv6
zM{(!M!+I1Op5rWu4{Tly5UNJ(I#d2{lK-7{H~(1BY~Q-mGFwMTwld&dC-wUVwhtzn
zQbr(!fk=!*DY?`&ad_GN=mVRq)y3`J3KRrbPPAH@aM0Y)Kmvxo#|rvLF`csnmU?V*
zZP^3+;ikD!-4HE%QYgYACk*ln9DI5>^aZ<DSQXa2Qdoe)5^x6z!+8!J{p=C%m4Z@j
zM5K?d=ma*LWMY{9uX8JBznmDemd+}Z0%&TjlVe(#PfE_e`q~+97V)yFRA1o@ipG+(
zdz((A#&^<rV}C3rf;byk(4J$D&bkFUP0ilIvf`<ca%)5OshyQ?bD^ABdkyok=J^#l
z&9}B8=tiQoH5c?a!|_2_O|%}5#5=T!YAUhT$cqgik2dc5z<i~~BWgI4Ja1VA0&eM2
z>FpY})@VJ8qHiIVZt(~@=cE<&S;$vwlc-v3a+i!;v-J{n`traZlqyiJI;|<is6$j?
zCuB;>Pz98*fq<%*5H~!#Z6S<miI}>pp?%bJi}OSDv#aeO%rb6TZZU-b@Ey4EbiXQ3
zd?DOkk1zzSy%`S@(({4XO{ExAb`S>zqy)1OS4soqO*X(p0WXO4733P8Gh1-E${u&^
zk;{naMl_y0AIn;<P?HGVvEsS2N`~k{L%~6X@NjL(DP|BP6%_&dGX*uMY8Y!x(SoNN
zTx%c@t8S+xO4$ug4jT<rVUAK<a?@El>XuRWVTk~z*N@~t`~B-D5V)|x$_H<M=CFlK
zJK4AKv4KbjvI+;BFbky0wYDi;gt-H<0w^fgJtsJ+jH*n{n^<UO9@OJpeN8RmA#<?q
z-^XB5rupi9_mBX+)R8~w`Q<E>8f0==p`aYi@ZO_Bn;eB1o&ENkm*0i&8v-;mKEnWs
zM$uB+I;v&_PW75}1vNwndFWpRFFiN}OF$#!7&ICOKh+u5hysx0%2*dmrix2AsDgYU
zOUS-S36Ek1W+OK(kZn$MQP+3|=+VN5vIdF%?fNV#SV~O};y$WN2`s8Dxy_O+E%_7$
z1T9wbFR};$+Flh?>E-U7Y0~QE*!HE8&Yj$d4>*iuJu`2pc5PQlny>~nh^EPSMGWn8
z>xDTm&F$POfFIGJ+f3gKp01db&>LXvG7=`xwx?kO3!NBCJ!S88rxl(!bu9tJ(SH~8
z`-;W?C6qp_o!B<o3?0V4;K|HZHP&(8x}4<=>zKWZ3%I3|?3&~NlUuI^sa*2l@8HCx
z7^4*Uq2VX`oA4ja_(M_#3*gGFt@v&zJtC3Dz(}0>DUb&0k|D^dPle^8MB-yr{X$9`
zbXc$U`~a(pIuLFb$GCyb;FPJ0lFX5~$x>jo3EhhRlo$(7YS%kG@yu1;<ctY9rd0)D
zDlJXh3Z-Sd+fD_<DGRA-ZR;Z`8PZ(l&Wud%b^B16ki8xxfwBT9g3Nrh0+QfflUP%-
z1S*pvJFoohr!XfU7GA4W9m%y4(*$OOYEC3o^tv=)u~e)vXH-{7HP~XjtKLD!39Tjf
zLj)GSaX21ML(k1r@FK;pl^1l?qK^a=m>qh*4$|o*{RN=h=J_{7a#+MmK_nlRz^<uP
zq^{)vPt>@8z&t^8joJ!s@{p_xT<APNzx~_44Sy@Y^!x98$3%V}pqjMYr0admB69D-
z9r<V(s89!iQ}jRC%?8%bKEX^BVZ%zZ!AR5QX-MD79h%cb@lSLdY*p8u{qm_mmt&Av
zJs1|yUzIG9DlGO-C6A9B`GBc%)TKOBbL0g`+(Cj49i%QnRn~Uh*b-@=n+eUOCsX@c
zkq)e$do{l1OJ|VE<}oQdm4iEFsc=;%f^c=ZZ&^L10oc%OUUjY><yM_N3+&s|eWOai
zqJN+6jG9D`wQDB;k$5Tk3DIDoOuXEjmOP18a!YFohxu&rXE6=5#qsA51lXyu)+mGS
zsuMZy$}WIFHV3GA*^YfwE<Pcdngx*S(1T%7V|SzSYFg_;FGt;&<UWX^o(A0SHtiUf
z(F)b^8lLHEfcD@?4o5pObdi_c7NtB&j=++U*5gb;&5r32<XYHPA4ez3tcg;N1_Kyo
zhG&yQ<BDVVmcltR_DJz`B*M$ph1^OASp&p~98E%2ll#ZxuGH#oGt1dR3XAJV)ntJ0
zHB(H_6<YYGes!g+zS0oj`qZ-Lh!oY#7dl3gWpS?RlN}^_!4f=(+Q|Qn-UJb%1?(5f
zqNBBey<k5;0+@L#wq1DwQ&-AnaATxE?`=t^WU4Ff>g@dl9N`u6%|oSvm1NNcD!wec
zvJfmg-m*!P)Q&ELAAA_NQv@I-y)fdjR~(cF2fgt^B}*uSAD_X*<UCA14zy$$n>mDm
z{-s2pL%SHXV(nM7gC{u4x+Cn5cGN=5<6G9_Qq(mj14?#&)wDd6P~X;E=`E4=a++~p
zRyMuek=J!pC4|a>^=PKVyFei@p_wh$LV%3Et9=V!M0UBa5)|80187O)B<%($h#I+|
zxrE7d%zgmr$fP9WFHE{PVJ5}{y$*5+DA@_nadjoOzPVg5d2@Oyszx?+V=Z}ALWvY~
z2-V0NNGYE+3mkFS18;HTxiGgkj73Pyet@xfCYAKT)s9g<xQd*SEOV>1eR=2-$;Y<E
zg>u^HE6)>>bl|(#Tg5rt<lFNVL1^*~zuJ4-yah4@u|m8!1JlU9+ZB^D?pm5z7ywg(
zG<p(pU)3i3vT<IsgV!u~qR3Fr;cPbp9vte)gEo&E-J03$_p)N&M`#ACc`bb#pi9wq
z_)3YBiIcl-^K2Y*wtckLg0>lqFE%EMKni3X)T!lzL*~r4N+G9um?%3406!{*^*CS9
z_J{kmPO?s?+W%6|H1Cildo#W?z-yd#zx^>BO`BAJ$YRv0OeZj}yF>O!G=qHOFAwcK
zN9y;IF&#dL)P6N49qFyJttC=_pjA~4>tHgW92&PQTGYqJU@q<T3SSkT^1Y52T_**Z
z5S1IEdZG<3N-ht#94Tz1?`!uSQU+AWEDrb*lv!O{DE59n;4aBgHXj{5;^HYO`uf->
z!XnY}s4BQOkIb1{`4#XRFxluNv4K^Ms&Z*CR7kNKh}i7H3Y!W{Qq@_kH1l>T%T&zk
z^aSLHyaWg)7i}&$Ua?X?T3daRW@MWq&Da9Gk6;EAyuzzc;7JU6&KLfX)av}kPCcon
zB}27KPy?lbr{?0PCWfO+LG`q2@DQ#I%wo;>d;re<IiVCY5CycVLhZ;XNlDk#07-v<
zK^KX?Ngo7i?6w~dkTK*;gxXP=c$I7v!(&;BV>$cYO^SX1h7icn)~!^iY@y9=#He|a
zJYd%avIg*mL%cA@JIwz_z?Q7tBZ&{Z(w8-L`Bi}jRyQ;wPJ%I^*qY5i5ddvGL$;O~
zkdMn#lu|EhYQ-8p5+!d9lXvfz*%3BR!HJ901bjfl3RdyD^jOASpH&s-skq43Sb-KL
z#ml9wTrW!U*o(ST2AcOSQn1F;4xztv)T0?jSCi$AF6HGkk<zS#jhXz?ehUv-Bb+Kp
z66b?_0F_n+qrKnvEa&3Us**n|W>j|ou}DzR3o6|<Z)mAX&@0H}^b`x#2RS&oOUY2M
zK0`4I`EW)O3FxPKM<ybxrL`!!Kotka&r%;I8QXxwQ`U!y%;c6v1Nemt&ZGuBcilgJ
z>sR16DmmBf3OsCmbc_8qf>u=R?B_tbqqJif+Jcq@f?``2J33HnZf>>ff<>1ogE|Yf
zU<k50$dolT=-Z>Lz|uaOZGk<~2s;HRvA0e}0Ip=SN%X)|171&QmW!ze+*t_>kP>xj
z$qMS*Zp>ZNI-*B^A%H@;2Ji^6<`QQ9vs{%OZp}f-=KJBh-?5Of9ds_HEhzxjP$J&-
z8w;&FTf^&?3KSkTuRn#z+s2!`j-|Sxqt8_sRZ9h1tS5?vnv?y<*rV*jJ>2vB0ZC-m
zptjZj{qKhF$}jyM?E}j|RBqt6{9f{rAKB*hsnXbX2Rc!m3k2hS*@NmF!8#Wcl#Oj`
z^$P{ht{qB&*0PrGh5s#u%gYWCOFNOE8pD29sT4vVFts|$lrn-`Mb+?j!q-S#iySX#
zr>5^^g9B&kx>M%K^mi86r2Yf^J^gfn6ucs(R<{+?^Oo=N6d`z^G-GuDUhmG`>?hT)
zYTYnQ*WC^)^wHe_<OlR*2=`FkOi2{9D;Ja&n(k|@jVUUB12XXTCDhJfU<2UDs-1Cn
z1{#o&5IoE-R+F*c5T#1=lgOkF<#gK07+}kK8Rt_;OVR>H@u5$`bInGtO*L=?m)@(}
zendN;dr9JEln6+qZ9hWet8#8ZS2*aTR6-#YFdl0p2m!M`YjV$<r{n0a7v)J3#s?-R
z*7_~AIpHkM+=7!&JzVTzfAh~TKXUVy{DUw3mtQ6!ra!8!kxjRv!XY`ULpYg;=H9bO
z+#Q-id)l0Z$`-9FRMX|aRUwsDiULf^W=~3bP1Nl$*y;u7`V3!&Wlhgi>>t8+{})@L
z=z`9pp_LZ*5}1pppuzFI*r=M#W>zn$%Ok2XvXmjP^=g4Hh7zTFXv*`VT4u`0*LGru
z4;;Lu*p4Z|ACn!cBQLn4{t(`NchY_{Cc+gzYL`v2r-Z6K0S;f#Xe<J)Nd4_vm4juC
z6&>@mi`+w_a@|9AP~J{(sPi`G>km2QQ9UQw?FzT1;8-B@9}?0Nrl}aFO3ZI;blafq
z*J0|A-n9U*NtI3P&fuuxwEfvtksoXlpxBn|Z_YXTyRAjNbC(d>mp+7pSIw1`_JFN5
zLA}$2NGe4qrRS!C5e`CnLY-<yYEn5*3uvz)9GZK0m7bFoRW~5)ljv=BJUUxl)fweM
z(AasyGoymo+Pc6C&UHY~>_GRNA>H-Q!pm<IJ>%j7Nc>M=#XKj?{|FMjw}1g)aC=?!
zBDGJPZbwpU=L{M1->Hq%2tgcGw>Ec0gv_F3AWEbMwyFq9*hp(&u_PJiXS5O3nhe_=
zpf~vOh^a!y-C~=fgCB><XiEN$9nY09X`fh9a=<Pl57;ElpKc5Ni$8w(Fc_uwM=!q#
zZy#&2h_;8bJQS{0M^lX%2`7fowXKtL7grXzuRnYFRruy#WZfND&Jws^|Me}giEc4x
z1_(fiKcU+sAW?8^Q_jz*0NbIUNSNvidJvcFR8Fn`Xr_fKd{b+VR#TUuRT@C9=FSJJ
zFn~oJo^hrH(%&oc+%_p3Ro(QUgRSD|EdvnE$vwEfCrxq1xw`|4j*9aF@`g7wO2{KB
z`HcXoLY3<Ehwsq7<QF-N{R)n?_6@)0zx^DNadNB5Bn+AMr~19v2LlV1B9Ij~u(s2O
zn6W8Id4|rzRhPwbZrBI*NWjo?Tq??9KVASjphm*dx=>l8j>F@&kUN-`2-M3vsiYo}
z4G5JTi<5d9-iqAhi|S}debS!3V-RS{pG)eXVT5nE+-UxZ{2kk{#RX3arYsLTjHTx7
zxtg>g(7LtrIAyOLC_k8OMrcMFzXY37F0#m0%4$up{w-RAP%9uNC1oW-hkcGZXKxF-
z_@Ll)?Ttfx&&mL;y|i=)UHk*l4f5NF2PE~ADJRW_6<3}t`$LTfQzY_(N*6KnLS_@3
zpQrCO;yjIcZ}e(Tp=1E8Y--xj02F+bKGRn;^Ggf#)3={Xj*c&HKYRV`?GM&10o~Qa
zVb*{qa(!B6G@*fp?ICqCZL)p3Bzh^IXSXiBWCU;r-{hD6^L_Nt2-dXhbWB2SEhp1*
zSN4Ns@_Tl?XiDG><&0hr&X-V&$ed3CofP$Jl}+|^T5;Kii@Xu?t+J0iox3chR)CV}
zp>W^Bj$i5JFKDu?n5nDw#B%3E4oHaR^aPDbY8o^;Osa~mz|!ED5GaPoPRNJvD{j61
z>o-4;(CTk>cVx{1aI%4r<O!&_mu<Essy+*y-XfHE?X5uCuorkpCQb`H)pkvrVO&xp
zfT2Pi9&O^JO^!Phz%aq2N>fK3k<>HS3r$QVj5y5}vk{hN-wpra7%qSP_QxC$zXEm0
zzL5vFxQpeC$6`TIjxQLtT}@`BoHtd=Ho&c_KiHsT1xUYAbEEX}Hw@3VIR^<G5rrN9
zkX+_oYoG-x<()*B;3;oegm))obap<0eI_LpdSK_%T7}xi&46car)2=}-)i!CgbDOP
zKL8Cgf+=cTs1#yehoPPC5|tGvDk?<co`p{yGbXgTN7Zo53J>F;r-Jgu?M*6jm@p4L
z>Ufn@Apjhk<n%pw8@V2*6&O_O9)B8Mz9c&9v<DurDjGOo8&9a7?bESW*thUBM_I;E
zQC7o{wDVziT~a&dri~A@BUoRBEuRwYut-F?RfjmW*bqRgOL9IVBOv7{NLa1_rI`zj
zdh$-Y9Pg%glHmTY{}Nt4Nv|xWSd(01FA1o+Mr}o>%Ys(HlV%VM5O`OXSCjg}Z-xRJ
z9w1mV!wgcaDigxuyOi9Yy!|}=9*#foZ$EzdI*lR|zI0pBBYaR_7A`rE$#O(v%aEY9
zb&Kk)vkFpvAu{mR2U?qZWYqDjez^Hg%^5m$Z@U^fH;_JD!H~mF4{8l(OIx>O70SXt
zYWKID4+FyFH1Lr<KFJZ+8Ds+aT3~!ljFY63J#+@nXb0IN?q|-a6!>qH1ST={xT%N7
zX_b`V9-~7imI<jqHaaO9z@s{BcbGF1{9A2Z|6YR=mNB{HDK9jD-@5}05HjmQIZXDW
zq>idyaA=~Hyxjm7I<9qliq2j^-_athq$p$ZJwx0{f3}V1;7(3(I!~*t)0s@o196Zo
zO@omqAC{X1_Hvy3|3y6xs>JDLn32^Rr>v5jI!5}#yJAI5ZD%=ftSnN5fYgfivL!|r
z+@33DkQJWi1fI#Ref$OrJ5v()N)IBGBN-<_y`yA1H7rC`D;zinIW3`v<$PqtZ$XXQ
zxls_GY7qu4a$n-JMp`0|N=O(r^L|DTydK@<O!;`Z`7U8X#Rsmc(hP_iC4Z7Ohjzte
z-OaRxo<O9Tu9QE<aH!1%7fdd#W<h##LbGJyTTdA58(r*zNSv_+P|&esPT~i(&o29<
zASX$<C*x9G)G%8+#hu)~yAMTfqk&N5BS92s!fR4?VNmfXm`I?%cAz3Ir}i8Grp8Q&
zOz8`Otc{Kj*kGw6;f{D3QXxxeycTKvgeI*KKhRM%@-UJUH!r;g$(1E8VPXRl9dcoT
z${4-<0n25UeV9wRAe#Q*6+AL@qc-AB6xMTm{rv5N@bUqV&B#1%xsqBN8*~Ni_O?uE
zqmzkgV4PmNSLGgA)WEDT-v;v8t$19N^qt(ymd0(jwi%B&&<6F&?B$fVk*m<BQ#t3~
zD(1l=LGtgPsP5D!;q3#RP(mSjc53}ORc5p}P^ZrM7|FA~a51B`VCp9l{wt<R&k~N#
zJU5qN1J<a31in(-(v6yP(tOTl6v^9nj_PVKWcec%0dirPC2FVA4)?7)XJ8S|cTW8j
z=Yfb&Ja~H~Bo59vR9!Q8;khc5+9g^mN)B7AY1I}lz1NJXx{-R&;yD-3=t^I~q-==v
zdVnR%caXnA?Vo-GLhYp1LPoP<hP$fa9l@ZQc|ebv2c(MrTM^Q6D_zM4Mr%yU8I&;w
zCf!0|`>MLDUxGxs_PxILy!DcmS;D2NWJy3ZHj+>7i~x`T_90zZ{4Pg?dnB5icn&vZ
z3^>KWZLsg?5Yb+{2&_J$6O(%7J328K{Xkn@uq@m05r8XNTZ#)ykiXl@p`*bfT&;rA
z%^D6mV*Pq6=j$Zpe95^&(IL5X`c9NJc{xxvrBeOoU)1^4;Is)R+o+Qqn59m{fCC!u
z0O~M5DCJJ4kNDT&uT#|jWqA3eZH^`^(3(MCi%eAY<fvOto-V<pSFV98{-Q*7o6t)g
zG81|w$9OYxm=vnC<xp?7k`poG04%waC0aakxl$QGC<(#X)9&1|rimA3#OHH(Zf_6<
zLyvfNQ{ZWY9g-$UIk9Q(id7vBB#E!X+t>CnVt5ABJd%I}ZlC4%@3y?P1~7G4z^H`1
zXOj?ep$<ei{=gM>AsG*Y7Q4SK*E72226~;5{PP$Ms<p*h07tgradmE#zP%C?4#I==
z=~Y4tWFT(+ciXrsM8^VncfwGH*0IrtLp{Xx9iAJ`&yX#vHDLf(XjpKee+qA(yaz^N
zhZTak5)E0R&&ErXS3uf1@2asJ`u33%&{=ZYi-C7+&r9K=bxXLL!zAY01Mk4BGTY`v
z+F}3`eS$PgE!4Z9kU|Jkf~5?69ri(m4e{%wJ#`Dsk{DU4H3f9?=`O5Y6`0iP1Q-?r
zQj$}P9KtH_s!atkaG8MSoF%TL{dsN+9mQ{*u^hk}U)U4)%0z!4#?f)3oFzl?*{W(%
znzcOQf6TypgpF#P2e7(KHh;@zJv!oQW%tS_l(ZW|DufB>>Q}`z0yN-AZYVS)x#;vh
zm1<M1aOFH_yrAtvfIcl0NF<X)#wUD%R4v!fg~>W)KQF;%o@H1-*?`8jp<9!xu=6&z
z6?yms6<50)*?tlvD5ILF@9Ta-u989#^f=q>z>N(GSiW5#435CEk*w{ajdrwbveO)7
z)NN@=jA(0!$1Uq-tD#n#0^9AgFSG*KZE`jvhRfDg3M+YPXV>tLXzbXAsN|+RS(HMn
z8vIn?sOOd{f-5-$3GI&x$<k1mb6FYy3Qlo8Bx9>Q>j$5f3XB`<L_@!+4<=sF32bJ^
z*eR>01G>%P@s?%daL+6#pi#Na)5z;Av>EQtzIMZ^EJOp(+TKDH{9@v>o%?dkkmph8
zm}<xY`3q|Ce`#1;t>riv{kLFT^a+aTfQ5i$I+0Z&iHS+5x3Xr&nNor1%qmu!Kg#xS
zbSX3wFM$gFX}0t!l;h+kZk)?6S4f0s&Gr!{oQ;m$R3C2D-`jj0zk2(W6Om8()t+jk
zb*Hi~T%vTsa5nNfnAKvrwhh#rCCdmZoa8Qk1kK5_lpU^CK9uVp@WSH+tgP3fWif)t
zo<HMn1N$#XEzo<BV?b7)#OR2*Qz^;&9!TXoW6xEytU6D+bwij&;oT`3vs=l8Gc}gL
z6*m+Uu*M0))cdxBt(oU7lqfieTB|Q_w4TC}l<8p8%C@5&iBNH#l?<U=2y}{z#R14A
z`F}8Z0f+Nq?1@#6hDFMs-5-oRZ1bgTO-4vbdaTt@DFFv~jqFg?ar4O{47+heEfl3j
z9^<0p+GR+uqBMwfcjX1mun6FDF4bzhXO9L*Ti@Pi_52bv%Ks1iz(?W5q^RWiSKP8N
z$!Gy`y34ZdkGxM*7N#Gu7UA{3eDeeQ*V?qVAami;KPq^g=eAb)5F53`Vo{Y|=Mfk0
zEK9kC#o*$oS*8;j?$odtSL$7jvLQwtsHsLw`m<Thm{(pp1RvVyL`9gT?>z{n3lgAi
zENaKTLA7#LSTyGlNCaU=2w5zO5L=7>V}_ouHIbS|Hh9-9nz6I_Q!5Tu83D}P$-uEl
z3$qSBwAE)<?}xZA-snpfUedVq-YR>VUC%gOy!Dkl^+=~$imM)qcFy*wQV4@V^pBF!
zpt&<EhPwAQjBIKiCVK~=8o5>I@hojpI3^TAn-BJUWou#<aXwLh1H9byXtQ76GQy^~
zC^vGOfDK9OW`hH>99xV|7d1v1^9}i&{0sR;0T9LIgfy;p=df#Xah{=x;Wx7`HaPN;
ztyFXv2U&=KssOt|7+~~R@QRU=Giq?Xa9A>HZs8wILdligAPCq17?Us}aNvQIK&eyF
zRjHoPoJntf#WeH;H&0m?cQ*Le0$0uf(yTER?_U>P5{`ZS;Wt0@0dW9jS2Bcjt;_*5
z*GcTWnV<+sO7_f_>SEDs%s-my)KqGBk3t=^t5dZG3I`0!=Kk8ZmeMnl?o2SZcT7~z
z%3?X^)CHY!m03JpL9n!>w<$to1f<6ztQoHk$1LW4N8h6=*vim{{X1X=4nfNliBc(=
zAbOY)d<3Y{83I}n(|_b7^9WO>jAWxCikjLxBBs+0i=@d;Iv6`b*C7d??yuUCr`x15
z36A+Z1Fp-QH15bDsmOX$jSirChML>6ra*ywP}zMGZ>{W{rfFE%Hl$G5Rz-Gi9TR{G
zV$uU5*L4QRvi26>c!lYT99{3-#$Ubtg85ST_8-^>f&-5|3*emya|BxM%0ZjT5^@a5
zj;0O@BvZFUeRae6YnJdvUo=dU?k;>dqv9TB5uvP33K~aDx&Xz5=2uLOM_5^Lwo#Nd
zIH!;H!8IVq*jG{>Ey}vN6*!l(a2rrAi?;3PiKs9H)gah139G>5-;%qJFcnC1roWs_
z0F)W--3vfuq~3^~H)MyF$nQEXuphu_8kJa_RzQnGtpc}RiL@1QfNIWtYdcTFX4&R|
z^0iH6-6!M+1lUS~r8WzJE93R2__Twzf=nRZpV0Mcsn2;EuBdcPN%2N;xLA?cq5aa1
z2=fQtFWqNJ|97~MS?q+GWCM@G3jDt|Yx4%s*PQue`Z_>|uL}>0ICN_E>z#fbOg8>g
z7^%gk3EeCKb0i~hO=?>NZI`rzUQqX}-0Vj``I*9zlPc|zKN`**bePdLd@9g&fr@P5
zs?|y(!u((X>t!1xjUO{6TBo5*85>|$WgVS%DV!{3=DwbuE1+>Yk`w}e8FY`3(mo!L
zaZsprv7D}uj+r^)Z?^8Bf{3ec2R+7A-J{hvI1`gR%1cl}6m_b>Q-?4NOi95Tn_=)c
zT$NTGhdj(Mh4%M611rz3@3BEPZfqNa@G#6s$_e@$R(pSvgbgDDN!dxcgfCJ0u3!%c
zP1EjFu3&!H1Bd)}ry^sNI!^8Mg;bJvp_HBbPDiUwGQxQ*ADCm`X2UejI-KZ1>s(Sv
z!09TtL)wKVKq@s)Z=cht5>7CL3fwDaxlA<knp^T>rdCP79Cc}=7&IE%b^wFNctr4h
z3TzCc$wmJwPHm7oT8&ykE&_$vK}@KU8!KDW6;<G3YUL8_*xeO%sHkuN0RH%#Wb8nA
zy|V&u+|&lbItKR%{g6g~3?KIZGf0kT^ioW>112>#7K`14<`o3D36-0j1b*(khR5j7
z0+Sq)X}Uc66pL?K>U>kN2keI`2Lmq1@H}iY+z=B?%he_56>5xP$@>{<$wuuzN5|uz
zLtmM2MAEp3#0b@LzPM2&8jx+_&049ND1~rWG#h>RW~dRC>E_KKWl^T1f`%y0WMbq@
zgT0!!NRaidP<GR*4vFE3P=3@U)9F8j|CFAv5e1>FdPZ9Briy?Vv$0YH)l&<RO88G3
zmgGt2Lf=N%oz>NlsqujJ#XJrZo7qy$0QCs}`0+wBzp;{pfN+l<nPlU)3OiV~1Kl#A
zy-P2&wE%RH6CuzTEp)&nFOX9x|A`bA75essz+*nN9+H<Y-+n>?Su`Hp{Xt=JLo=Qw
z<PEf4Mo2BDn1I**j<NT)Nd@k;9kST1v{eoFyNZHI;X#WLU@AuV!rLeYeRe+NG6L%g
zuZWcx?h88dgSkJ!R`B{>&njyf{gz+#Zy!Klu#{i5xFZ@8xu#pNFTmK_5myK1RTqjC
zP6%{EN|$=H97?zP?6PmkcfJ$;;UCgJ?I^>s#6e{{EG-z_8S@g`><-_6<Z3b14ZV>4
z?mU?8{G{x5^kB0Y5@C}-NrJ(aNDm}`kz@`%nH`<=Si^Zj(`R1&R6oC`l|)IRb~$=a
zfji+!1`_t5Ky*&fnSwVl^;MS<3K4CQsbWiX2<8-5u-n&F-o(~A+B#?S2lgJ9jq$qM
zcYw!pD->p#>FB9hfJ_oFE_Q7p*0u1H^z>L>)bg@$5#9>Z1k`Nhc+Xfv01s{8w_#pU
zNDz4fFw}}`fEDa8mMuX)La<3>9S*T}pGpYW29y~@+>8uBmsY*E;b&M8Wzw(}4Tl&z
zoiO1iX1SE0wfmEo?7K^9-)u-rG$JK%b6-?w2XPaQC4?AGI{-mMCit1y6`1-UVSjS{
z7)*U3yCu7t*~l5{^@-bVuOH$?bxekuTAor>8?MUGaX{6!vkI7ur|aFy(gtDEO;6Of
z5fh_}R1`2>0IlbKQgxtJEmtba)tHeqkC8Q*oTs?e#(NUwv<p1*h`uUP1XVsHmnd)}
z_YXbRWjEkn_AQWXgtkUuo^xO7<r4r9Uq6P8*q26imNkT-X<@m_*kwkX)Y_NG(S6DZ
z*(dD*MZ6&SE}>!xR$LRBtt3TCLQ)pf{G0IlFE1Z{H?R1gzI<k1KMCLd1Ju!wB;hAu
zYS2SYORI&FDo6@Oz|B+`=HsMVt|$>~`~QzRv|kyQz+_v_#d2w#+BrD9bS|zJ@0-rW
zQ?V##LC&N~Rj-t@qJP;^s#oflG@VRsCC*sEOjx2Ud3;t2vn5AOS}9peVF9<&Nro=g
z#h39R?p8TI9?<K@gJQC}F&2*?6I|T4Ue>!!(`WQAGsInaaqKYWf<11*M_;2<ySr)~
z#RIG5@8nnbyF}64x0~d+Y2)880FJ;CT1gXKV?kAl)jb#T{}!r8wp`U<z#u5H0ZKCJ
zud3r?+)fM?7w$=5*hA@em?~+Nim;_`)#iok_^}1b<kcArzJX`9TmZrEbV!*#jf6+|
zd{s&*m_Z4;*vaORN6H>W784*OCq9JMz%m)4_t$lHNWlrvGEcCYlc>aj*f4;A&z^XH
zvkwV=x}?b#hviDqHr2Vu4*6Nhda_)n6zAZ4o>XK%MKD<Ml5HSKTqrZ45aRHvr)!D{
zv}Z=Y<zmyW=yJ+qyQrTyXP;-)Hw6yPR>JGgUcPwyT}ZTt|AF-&QRd^9KcV^d_6z*}
z^0V;z(aTpaU+E7&dHv+&589Ob@a=PSXWl-;_uu?L|K!KEx<W4t5Gost;OLA$kxnV4
z_68H2Vn6lQK>bA71C>WGbu*PLt4_jggqT7%e>-T=e(~}X^1(iP`+0c#^XsQTIe+~2
z)9{anhjn9LKqAzWO}{3NSW%CgY;~)}ekM-bR7KTVQE>_MT!|Aw7i*9#jIr_mrR&Xl
zWJ#_w!T0zTMt0A%rdy)k386LrV;T^AvGDK=cQ?PjL}cU)8Ui^_^Dt1qNpE7Y7Lrxs
zE*4p&ia_41|25}3cD`eNOFaeD&E?+A@NhRfc9w7XN&d*<W`jV8>}XSBSsO#u%4(l_
zOgl^#IzF&spWJK$NvB;IP6il9Sw~0voTsQBpnhVsrk#!KHGc+~qbE72wZo#EI^v$P
zU8F68XQt$vBzM-JHpGamd5JV=QX<PWFw8*m&Q)<(_F9k`vs$`(>2+?*bOEfl6=p-u
z43KQLu3FP5Kv!9PLjM%p=4+JaOCw;3krvxVmTy*Stq^tn=$jwD{W|{{@`t>S6z=(f
z+QHTo<v0rJOCH)7eyXBDmvVQ;)Y9J$jzYb|fYpddE?^DHL2wE}EoI|ka2$-m8C(Wr
z>36EdJYgx3Pu}bFAb%>g)g(s<fmGcceK_khNg)qtfSSS{5Slc$nbfu>|I5nNVS$wd
zPFQ`mwX1j|gRezF2UZi68`QYHMb$@*4GhNom@5gorV{|R+Lv6^-LR`IFgxFH9MUU{
zD#^2q2ep{L{LAo{f0_B$%Fql)Y8aSH>nu@0GL9UFo*+FS_ic8ejPMw&QB?2TfYZLB
zMp`eC`Uwa-hW&-7vCHTHR;*h3swJM;o!4E>)1-RYSzK%3K0(3F&ckz3)z`{Tu~uy#
ztf7j(D{?rHjD);+zBa6}iqDLE775u;k}A4j5*+gE*o;0dfnAdA0uW*ESP2jAg|nSq
z1DkGbuP|^(*{rP&`wZQQgV0}SUvB+PA<tgg$U#G*u3X1M6-4cyOQ@k5K^ei1g(h)H
zpg|XF5IJQBcq7W!w77n@MjkO`lJ?v@jZl-}jq9mZr^BLfDiO~Snhhp0`KhDz1YKwO
zV71bJ3|vs~sREc{?`-=@o}i-id^&JDG+Q@d;BqV;cL~e;03AihQ4t#w)cC}n01UM@
zR@mp>MGB$Kob0I%q&c6fCgw2>Usp1-8$$(*bwZw&E5&Vu>O9LLyvE|HI}7Wou~*m(
zHFadetpy^u(y|7I2T;Uz3{MUGhlM4n*H(DEt6g^0eIV!lTX=MT^!BwGJ<0VDq#>D}
z<!6Am<(iV@3OVFHHA6pe1@aY_`2|XB$yoZqax-AoAdyhH|KbF4SrL8#k6^3Ven&5`
zU991c4uWj&#ZLfPE3kL{-P@<&XZ`5yYfkVEI+UoOW9bnW4tI0~Hd##;voy-CllL{(
zR<cOtCOeuw7oa?tD3b%~x;t)w@bYqkh*@9CtrpS@9eSZu$y#>ran^}Dc<YtpK#>;7
zyKhi>x5^GA5Gw!SM;bEf(FpH#=1NHisFv(<v&(VuQqleB`S}?&&~_A9#)!W<tuw@_
zDMFeKx-?7GyQ-Z8(1vJ?C&l}^Vrv!7K9Om`JX86VenHbVzlpyJe_htxXH1b^3VY=x
z_;l=6b?^_F$huE(G0JJ;5<4owSkN4To67klUR!%*&m#K;;X@9K8K@NSiO|}stu~u+
zApA(u8a!Elf9{0sAjKLh@ubu9R`1<|J68p@EB_K1WjqmuiejAtnu>xysfTR1Zcq&X
z>Y`d6$c}mO^2<yGBf>gzac}^N$fNk0EV-oiDap+h4MXt<f+_xB>#L5NC*xbQgu4ya
zMo=fqU{X;})u43IO!mT!lL%y;aKPQz_JB^IWLwR_O1lBY)CK8K0+HgVehEyJ&4&J`
zS+PP+Bhz_-%u6t@3p{2C=PrSaAZ#qnIoz#zg&w_+0$?~??b%=1mT7}FzC;#<!k5+|
z?(jRV*A4tv3t?NO$ABu2SBtlo!$=V(B)A6E#ud@{ND2aHD)?oBoDQWWH)R<B2};#U
z*uf543Tq5sl&J)C&SZmj*@cuhRgV$d;p&gNdx?VP9A5rxZH7m<dgxKjEqV5U|9Vpd
zu7;4wU<kSOs+qU?F1lGOqf_2hFHs7Rpkr>J6xGUhEgCyH2g?iUUa3wLwI_O&-?7o~
zh;;@D#>zI?-Pa^Y3{2?)1+3c<N*RlXbVGHd89IzzHTvnXHy6c4<Yz=6d<*k<`?T+f
z{i`6`C%;>b>?srZ+3RPZqocz8`RPU!04z^)8J?lT{e~cD6Ii)xmIOb+(Iq$JQ8eI`
zHOlL`=3rQrE?n!Yb1EljcrYGe^9G8!`6p0CKOg~dVP9rMZC3eQUA6(~XQ6*0Zo?^U
z6Tn~Ao(Dl~9cWn>n%OopbO~5h#M~xe+wgx0|0O?ADAE;?okf`sh{I~CJOZQ#P91u>
zE(aGX=o4(o1mpi(_-}dV{~=gzZ*kyLHW7bj?@)>uQ{o0Z2Wr_%)m<!&nRS`54W$lO
ziE;?wn^xEg*uJg_qP~gLIPk;<#{f?5D|_HbBYuaa?6g8z@x-Nvj%}Z;ln#-}Rb6Ry
z{^4ES0d9Ehf=sfhKxqnS(ZVlm4F|#GS&<>Od!f)R%Za-BRngtZnd0aMvskLY0@N7k
zYZ7W5Y{?9vh?Z}B7#oGv8`SHT9vH+)&d?r?^zo{eGd`dmpr^>$B3804WLcs)LzWF3
zC#2nW7M@*jey46`C^|=K^d<><*HHH5?ceh4t0D$JslltM-;_lJImYBBJjrbXY9`+Z
zh?=?5w`#l>ALCt}Fb|SVn`???;b8aal0(*EK}iAxB?J0(hQ`y9EhDJ06VV5C##yVy
z@`Oo4#htl&{SISN8YhO)<Xf(&)uJXtwHDuW2ZC%Cskf>Uq-_T0ckdf)$|oII5Lyoz
zvMAL+{tYmX!((^zGdWoa%ov@}DW!WBHXIUcGHVNhmj|N8a`gQBO?dr-b$af}FJ$Q<
zhki;2Bgl++0M_iJ_R8|vKsrOu%onf{)ibKm(Oq_xrSQZaU}f8Os(|lUkBsd4i9Dq(
z99?|oRSG8T{5iErbNc)MN6XeH%+1;d!kff#<5lax-znj$@anc}^@8cl{vqc5H>dai
z6bz035?%UcFWC*$&gKa2kIynOQ@pUh%hdfmJkV#6oeSp$%4eWmH04_Y6Hs`F+H%10
zGfSeO|3bYGK^I3Gg<!cE6~BE>;Hg~z@&)80>uBAoTMv+@Y9e9w;I%>ZY<<-`6$zy-
zR!wPA&Rn=xvICp^LbJET36&EzE>;3bMfRTAYVp~way=WwH!QA7@@5_EvCt$@)$cx(
zsq4@TvG5}@_F{t_sl&g=aP!e6-#Q9vLx#A0WY<Yz#v_MnR}y?7K}!kr`!&@0*h8m<
z;DY3O1eo90X%E+4OB){q%SM2(8if)_K7<p>I*9|iXpxIST{*6vE|NH`ULY>%9GC8)
zdL3?4FvugEv_r=piIiLYc-X3ceET`!=;7Pn$nURmsfYkzK%c*R)t4j}0PtQBnUHR=
zy(PEl5tSR|;;ah$#YJ-1R1k(~$+93%`>Kij>4`)^v<BRCf_9W=)NF$`qcjV#kk?C&
z@t7o6%K`KMu(Sg70y^`^FRLF#2Gq{As);HWHoI*6dQEe9qDDpwZ~_VkiJq6;beD{c
zC5h#>JAY3WEmO|ofHypv$XP;Op^$g8@P^4vaE5sHmV~R+0K6yl3&P#mDDrk~jFA=<
zf&#G9f~Z<dL9t@ua7bauS=G%lTDbe<Hi11Ad7~0>4f+B2q7&7Wnm2R!bY7GU+BChP
zdGb8buIr`O?qS~lGg8^fwLMoy_peYzPaBQ6-(`zytAoR4m0u6=o=xa0XTQo(jh=T$
z0?Pu6*fuq&>ws0K(M7XE6^ZOkw4JSh03Kh?*=>gc$rb$4H7*V!Um*Krqg{C8R(zgx
zM3lRVjtGf$yO&0Qxg%`=iDRK-G2~NaTi8>t`*p+(a<3-jv0xrp{s7R7MKEt{J)u8l
zqs<;IAsCzn04r@FZR95_7sUCqRuQTot?j#>`14f@R^ms`1R6tN)Fzns@Sqfd5*+OF
z>H{Pv@)|XsVBd6cgs3r1KIg~q?Qa;?KCAhG20d~m!uP;~H&hS$HjC9l^$g(6sh8wm
z{<F>8VSFKHg}(oN!1NIUP8N-|T|m2@HNg#;3KN$Q8}LpC7ubhFlj9Rrb!4lCtDO*c
zo$AZ8>cLx#CG>9ID(v>fK?ohvSVI3{c6yM;s^n}rRjOUGaVV#Wk5ufEUEU?~O<<me
zYa+QEPpm*_llCWjOXK%dPUZYdR%DcpyI-GJ$Y4`?BQ(ig=?~h2vY*miq038+(PHN^
zR-wE<32z{{J2gy|2wZ%AQX{9M1QNjC6w`<PoHocj9AqNm2xAO++Y@cmE>P;X6RgGV
zX;*LW_y7Vt+faJSFkJWq;584HSj)Y{00T1eH=hCS95c2GGyu=T(6ew|b{laa0L+re
z)9LCGfn<LabHIlEZb{YQ(=bW#K!hgj&B@)+wsoWIGe`n@4GE2teE19rlMC&NVGcCf
z;qm^5ufGWkba<ZRZQOLI4gAajJ_GZ2qbO@=k&q*cyxl!4RSP1FQDjhm++>XtP+T8H
zHdJekxfKS!@r4?m4`2b{tYb68aR#D`V2pDGS&YFYof}|%r;-k*bk&@dvIuHYCz}sm
zJAEMg)Z(+`BU&jaMHUQox?fx>^h@is6#oah!75a4mkb*%m4ABs^!-1+{zgtQWE0?y
zlc&qk2|R5br2Z5q$RS9~OzuL~!Z;a62$!#;9MK2jEUUppopfwPR^GDU4^YfF<F5Vb
zJe|XniR}-;`<Rk{5aq2@FVY}TA*E+lEJ>Y75s0w$*<sjqJmlU@phEQnaT_V9_z(90
zJc{H|Ld_8xtWhqBa&0}9#pYns!RwIfjJ}|Xv}powY@M4r0_InVWP-qZI`FREvdg2P
zim!?2@C(v8S=g6q8B|r-b)ne9Q&4t3u`p*r>Zu@+)BFD?y#DfZCvsw6K`*P5O?fhy
zzadIR-d|dZT)G6DMwj{nM%XUrGX*-9j18XfkQy@0pu6Slt2{JQKf*8+(=KhdE=5cs
zS9I^c_~r)yxcuz(U%&Zb{?7lvTKpexAD?99o7xMgFx2lkROG5Gkq-LwQ(@?ilBI#k
zA?1~`BnS9GuyN6cXUX(${gTv0OWo0p_cEa`G^6`035hWue}PK;UQ<^45(>^<VPAfm
zAWbQ+TsSJJ#^7>cBXxu(rYtG8F91=AKChOgwdZ+37b!G_?YwfZfq~_EAx#bmCY#ov
z3unlItU*W=Xvs<?w#LQh&*-F30;f$uC+$sDBg^DVN=0qIc2a1$+CU~g3^;|Xb7l=X
zy9W!bNfm{2I-8Zt!o59C*_bE4qP#WBb-n<-<Rkfwcz?Y=Ye_f>ap=&Hvv&~A=hGFc
z30I@K%0-$-F*?NezPU(dHBBl8>K!ClQ|Mfw)l|5ZLUE9|F{C3r_$$a9+9%56LFS}k
zUEQU@nuA%kSN&_%pp<kZ#&VT{7$3FgmA?zqs2rDZUxrge|3~h;>PitpH^MKmh7yQN
zYW?~3_aX0P+sgOq-~k17Ckzu2upn?ETi}Kl04;b>-*m|AUZW%jnf3@x0!aoeHEUoT
zbhfjpN9<n!oHO$>G=SX5O7;VQs=alX?#ZX=nqX0-0{PF->fnRv#;E@01x?bw18}3~
z35Y2rcr`A=nlRI>+yZom8kr^Wdt=qBvY{l8DCV^oKp7#XKXk}?7-T^3INT{)>Yf7)
zu&d7JtaaXN3tpa1OFdfCS1_mJb(T|QL7`=PZq<;&lR{OeWlzIgXSLV4R#Ns!LB?bO
z!ZRuveN>F@2@^qdkfnR;3&CrtUf}sBxwy8=7jH6+Ak=Y;t)!7?>lnl?g}27zJ;}F(
z;FF4o1@&ZW$x5he8c|Ccz$_rhA79Ev4Q%0T==IU%h35~3Mmz=LRC0p|D9~eME@c?}
zZ+?((AU3Y;k?xKP-p&eQ2hpcgB@I#`UDZo%o$cg}Q&E?LKzmIMAXy^dp33Gm`hRjS
z>L<9N!FJD*H8e%$nF6$E<Tv1oPhjhJ*;ue?Cqp|(UA`L22(7;SSyC-@eig<G{F{f~
z2RfMNSl-nkI@q)rB5Tc7R5U<;a8<`&oHERVTEt)Kzk1P=k3Ee|&X66_nAG$E0=Vrd
z$qD*}?Jw|AzzO6MLVMUnu=3f>nSH&;_QVX)lW{6{sa&;1%pZZ~d&f)o{nt==TCWc@
zVlPt4p|t@XhzS-t&ndXy6N=uK-X&1LJWV^h4n90mE0z(BL|1*qjM4!h8)^%QW7H*Y
zIN^|^ECM+o#mYI{4Zgq5oWB%~11ei*oB_33kvVjS4+8O7QXVGR*rO~AV>g1Ha0dH=
z8O08I)&b0jb(>Cw81()Nh}C=zCgW_m5)>~Wcp=ZHA_ltjn%Z~<`Y^hWFFa&kcxSvZ
zv+5-Bq#!S=H&yrL9!>Z`6#-qa${?!1Dbt1etJfd#BfTSkR5tFf-ag{Tz)vhpQL_=+
zan%d*ZZ}1c_<nuphFvO4mhFc>Q9FdUU&x<-eEaxA&9!_I?N?1FdWS(M)*-*yDG<HB
zN;Necjh|E?mLefb)DBDmaxb;fo4|l$AXBF}mj!|HlOt&E-r3$vDP5b~(3sqq&H>A1
zTc-j($CAZ=1gb*<sU!{$D8%#n(B`2>J-{ih4tDYG`BODRme_+AS|jb9Aonw%4hLI^
zy5E|F^PkAB_n$y=Q2P{eCT(a{=6&AP+dIy=23)IUgV#hoSK0atnKwXyQ5)pkJJ=D5
zo-04agPqg^OG>21rQ$#L1pk9Xe^bFD3xE1N0UZNvZtMvhnW_=3z1at~@j>0QZbuXD
zflEs_j}DFEAqrs>=p0B7vgWJfK^s(}3hdp3&4qv%pf8@BH!2e{#pEEdhZ9jRe8!Mn
z=MWxM9U37Jwwhvhfb{%2yndDiLDesH>j6wB-w2!~DS0u7y)cYuTNS9xRdIn!sb@fl
zfE?U2s-8(c#_^~R3|f_i3hcANygKThyuUh(M6iHXL#jx0=)hXrdY7NJ9g!gTH11N=
zg0qm@G-{FJt-AyYl||z#&{yaMKLH)SxCUbb2Phin){3;~c3fH7v}Puj_<=FUoc$8)
z#$!UWo|K0=%Xa7p?p;s~48&|lu=7m05}m28GqF|498ggaK*U)xW;Y+EBX57?$MEfM
z=)bx_DStVsL$=%>ygwDlZ&|kE<b*zm1qTV`SZ)Ar@>D|;j=+H0-7c+_`!RdFraP`b
zJPbZ8?+F?ir0ChLg8(t{=F~4s?DjlA;A4Rt@(btKfM?jbU91GEGnP@uF~f`X4c95g
zVhcOTk;4HAQWqbz^wYT?wxvjkWZg^pz(O~eww;*1R#IreIMy=nibw}3ZN3bzzeVqL
zWIZud4rP)J5=S4$Jk|r?O^!DRgys`X9hPNBWTol64BEgMXi?E!8IXU1fc(Yj#=+Pw
z&#ua+&31T^ONHt--%ya`dQj)xHy&ESwy|p0I^%CNfXvTHEy=j`dpZ|rT?Vk_H@c51
zF+}ZHWR0OhYenv)Bo($B!n3)TV+veAxK>OS@q~@cR-gx^$i%lQPEOG!$}bY<>{@ML
z?hzerc`F2>p*Tyck3oUYlfa&ReNU(}x2hvowTFH>G~Le@$FxiBZ}qIs4m5$eWJW{p
z2r(SaO`!0=yvad*lqs8~x=S9V98F<DkVI4f*pwIoyhWJiZ0YM{mH|+96>=g)M6yH*
zMgsoaXE|(k%LxQSkJs6^XoNs{6NiR9993FI-$&;{6#GCvVee5LGu#hOp{!JHm}Sp-
zClgRE-t)~28<mFH$o780qzF1APiS8({M|ZHakWQK9+0@pyWGk(cQGptz=qL)7J7tl
zd()gEvWn2Iatj8>1r-?1`%hkf1xt-bvOe>D2zM4(aM+g8^F}9GNSpwi994^y8(G4)
z3gJVmsn;2w9p)G<U3&El+WXDJGB#Wsqa;<};K?~?Jim*?bBAg+ikw;s%;>+$e?k7&
zFCIRnx~r%OJo%*Luxf9GhUYjdM{-l;e_7DmWv~Y?F+gqa(6LF26xSA$`pInIdcLOm
z0;ngO1&tS{Ap%&TbE^eVFe(ZH9EF;(2-V(EY3-gDNOjifK{}H9?zN)oWLd%ks_W>W
z#@+??BnY8x2r05^g*)%8-2*l(hH$efZ3TZF0_EiiS@gjTw}((6w#j<&QEhy;N3{|M
zeDw-3LfbhoI6Q2dyUl@aS#z%H&Gl%Dv|ezB^4zaE)84XY-9$bJM_MC9a^s91j;%D+
zY5w%6M7CZ5elhq}?;_&>B(WhiIp}t*AXWiD4)oV0pM?1ld#{KtD*o>`b>uX(-WC31
zM}KyEDMA0&RFwGj>(}|a(5!m><g^cN=e8-I6>4lSf|rD^x>zB$PrX)oT<_Xh?W86*
zx4wNr1e@K(IYC&Xr%^dQ0r7UWLzjegJERxvq`ERj?jZWkmh7){JeUediE_Pgt!x{?
z1G9p%^GmAZxb~ZBzottq&wO>vK?|Y6pfC|u`>I{tT#yUmG?7Ynwb;F-XN6g?PD616
z72W4DPNwMxG9E*>cBz$<mCAr;$V;H89~FuWUN?~_vJni=iLN{F3WTM`7G4H?lF0>k
z#zcH6rs0UJcdn`@Hj?@!z1tHHl&&~^V6F=-rbzunA9(yyzkHDu_foN$i#A+@CR-gd
zby$wYSX5XmPXrW0Mp+SCC~<XXlxYt&+1j%lJXOY`Q4d#&5gc5pL0t=5FC|QJ{DWrA
z%~2u{R&iB5a22yCWy|#h+dEU&lJ}oe#T626t&uQnW@Ja3)5xx9q0@ils@gBag7nzl
z8G?7FFF>WT(e{?0GVu0kk!trZEZ`LN6V(Prbk#xsVSz`^i-}G|0+X(iRZ5a+^53X1
z#^M#x`nA`}+OvoDg3wClg9J;5K=kXnd!Kdz=sLe7{IR)78Bj7g%?^D@epX0T!fT`M
zse@v`yI&cI?BBw-zX4tvit1BNoz&`H4i!v~&{VB-P-Frz3V=STVTdG$jZQc%g8lII
zt3X&<r>1mUy!Dt=`T;U)+QY63T@Y6Z%Z9OY1M37bT}T$52I$eT*9*F~T*cXQ*k$$G
zp(5szoivpi7TT5lG`xK!hxMa0N|p!^lB^Y-a&TV{n0bx+8uwAziOb}Q8nBgp;H-r9
z7|+d)_7Yb&bngHPVQ7eor1oaE(s`u*Wl2>9;z<-4`}VoSXegOkYiB|LLo#eDuCtdI
z<hmi~ez6(Z6G?keKtwuarOi&^UDdP%oP`D$fP!4o;FCp!#+QhAwQa;VZmJL7Pz16C
ze8L-Kb+txyV7oXHbP4+gSr0sLADh7w`kNnSXXsqUAWtLjT$9?ih&&YM0y{V8*Q;nt
z$r?J<ljOAL&Qc$>hr0A&E=wi8MM-%R-R0yYutteI%4~5j8)`b}mLnyqYCvknhnzhR
zRkgKlSsFZ_-Ih4QFVPMal?)jn{%FDMx;#P=L6&ciiD)y7K+9^-DwN}9L}+UmVIp37
zN8lcS=CWeEYL8#VDq6S%CZ3eVZV#@0vV5C<b?t{wv%^!aXUH!CDG2GOWuBSr9jndp
z7l(uvLJjat^u)Vbl=fahCnRlnCq1j@ylNk5xtf-w(To6{Yffl#8JTK9IFmC&whM!<
z4r_ol<792Z_(L9T9iyZlP$ADh{I`D_{x%!yZdv3PV^~}Tku<%EejKRF`}%=ya}1Fa
zUnytIk;^lO290#f!_`v24bT3)OwDiK{;2bvf+z=EtBA7eW40g>9u!WHj2p+2H`Bvx
z{nhw9YeMc5tkAZn?|taKD<Ppj7;Dc8B&Q}yG2hF^ucIBuF%*6()daT1;aZS@G3??5
zH81Y#wmQo(HIk1wjvy&Gu*r{}hW-%WrulpYl8tLUtWTjqoE;Up%d9#{WyO6UN6%Rf
zI_vf<*>zMN$CGWZ_g}!gCF`t#+S$Sd;i0w|9w`$f$4|;ZldVog*C8GpHlA?cvM~*y
zP;4c-P!#0s{1T|W*0NWuAq2#~LmMPHnN=Uo5{>nthB%84hO>3g>yP;{eES<Y8ixm$
z3KAOw_!Pg(cVVK*a6e^vpT?0$+T*kxym;^b9C0P`P`3K?_Bpy_ccAUjXd&p^Q%*Ra
zx2L2=iw_mFu|i{LEy3xcZ`yN$39aKzBW|<}!paOBt!x{yMTk97(mGVRkVjTdx$sIe
zHRW0(N40DS(!nqnU%dk{DV;6f1~gE0WXlw=2mC-*sq0p>huI@U6SJB%7)^YR0P3K{
zWOP1-DHITx95zGMJCS+aA<lRNY)TP#Fd0gK_eebkf$v%KL3(?d+7Oh}ZJ%g<Yk&<W
z{wTB%zySv~LZ!dU+TnAuQwX@Cn8lf{+9r95n@L0G->u}3=JZI#u;5+|S3N`2)Oo88
z8qky425-*dY!=TiGahP?w_+_^_}mi(sFE`7iv-lF$_!bq`A@+_Ss;i?*HWqQ_oV?j
z)iV3q>vD&r<F^)B^s$<xDwFqXwE)~tlD#Cd0GxmM^|wfbQKuqYmYx0Q@Za_0gGxHv
zcElCPic#oVK^<wgLR)LKBziLhS$y6Gi2ud^E#$~hr<9h(Mb!qDTs)fqGa3$Xf!6@8
zc43bX9NFZS=mW_&VtRO8fEzK}b9&N8YPI3T(FZ`yp`NPL?W$MTf?YdHa)-T_civ^^
zMhMT^Z;+UqpYKzsaP(r=)&3^6Wr&Udn?b0umRWV<@WeSog^xCmo?DL3JK~aOlN+_F
zR)}bAJBjde#dSESlWDq_H_$XZpshbfxnMgj2Y}Uxel0`-HOpOTir5nYCC_ujFYh^h
zlC(s&kOxuOPd$4Yz%bjX2d%G_7zH4Eu}@;L?pw7rOH|!jxkcPk-I=8++zm^lbCm~O
zE0&0&8F`_-uN+9SZ>uM!VR&%OX;8h9p(k$$?OqNZ2S`Z+(*fH6&sDRQ`7afpM<k{M
zbV-EJ#j-YWKY6t}?F9FZae$U}rEIeFj3lW{3FR_p=CN`LpU)53vPF144-J_{s2J=D
zlx`YlDD?S2=l&F)nN<{XQ?0*ZMmkB{-#peOS^VaV7gyCe9C}5K+nEDhU`P_wNhhuO
zH6Ukq;HN{vg3=D;#!BvJ=2cRe^U3HbnW+jo=k1HIO5fN-w}o(;L^f@XTTdC5#}hwu
z2|g`3cATbiL*cr0Rc;pHYZzk^9wQHG;kLPwOLfuc&@C#P<wurmTay-S**BAdZ|Iw2
zm(<#Tg>seIW?a@5^e&4+ba0}fIS2@%PZDPxuNjGG?v>r`)j?s)VY|0e^i`lp^OH~a
z&Tz79hQrw}MX2?7&h{j#=As6Sa!OpxN<~&R>s)~J5E>JsMreC>4xt5*pJ7C~*I}!m
z7j(y#qeYJb8DX+3n{a{8%Yo7L0psBXa`5>@A1Xq&ST8~nS<3{Z3|MP|fIw{;R0E_Z
zV?b$v)p)Qm`Niv(fuEexGq6HzPs@8s!8Ho<snHa>R5{||h74)dl`vc>qS0}pFv8%#
z3oJWpS%S@g$4%@HbpNbcw}>>S3?^N(X=2Y|UyZg$QEh?JtM}*{+-%@5l-Ubp4XOK>
zYF1tVuSk3_v~WJ*UduC2v**34b#j#ii`~u{^MrlQGO`%u_%axG7#$XG2M7-^OBhq_
zfDs8jn5Y)}K#(Xp)p}AA$pQ!kXcxT-N4DH)sy4FuFcAhSqe2rFBF3(m@^`7gLDepa
zR0y0lgs>99nujZ)2#c!u!&#mQ0;m&CR%Pmd*GpbidH@2n=$5i*#A>3G18}xBL5Nm*
zzAz3*>T_MKsdnp;QrIC65qX|ez!Lh}Qrl@8W^_l)an~=fJ&?fF6M4jGHz6F7;JrwG
zXpJ9<)M)h{M$^9zCi*xp@OM*Tx4cI|Cc=7J{hVCUNEzJ~Lmd{q8#|-qzMiJbfDukn
zRges9I$hzaKy0}V|0Fy|mAQ-tqpDfFR!}k<NJY8urUKGG6gq-xY#zQ$eJ(F8C5Bv$
z6~JiBD%Xv&YI17guK9pbr~BmZBKZM|Zu7~~ziSa>zqR!mdI#O2Ob0F0_OvQMQ`ZI~
zJZ^ObOy<u+Gc^|0F%*gOC<%@oM6q(io^f9mSaUh88%iEI_;(4oR4Wp9m)nw46oYHE
zd|<VvC=x>D(mSZ;v0{<;vGkHezO&N`z$4S4KWYG6K@u}}vxg4g&K6EWH!0<iY7Pqd
zk<8#}$7G^lvqzLhK*pSqmrIBTt^l1VCvd@<$Z;f9gCHYyj0A$SO%yOaO{%>;hsO||
z)hL_k!Hj5eP@}w{gN<OX1yXDgcf={f^E-|X-y9C!1l8CNJ^a9B!APBk0?k@VYWuj-
zctfq{`ja-P?J{=xv4J{_ATrRl&}G;!)#2MfEfXFDt}yk`)1o607cS$tO-W!yive>r
zqx$D$^2?LDa~E9g-E(f8)D>b~WhZ}D`*{0V;3t5>W$hfT5ZDddIm(BP%<BHcpwk!r
ze8J<p!6xb*_BIBuXkq0$40iN}x1Vs&eFdnbZaM`6_RA@cs?Lao)dMW8bnv|YW%%ar
z^U72q1*}F{ciN?R$ZmQL@@P&gdT}e=*jFV%)8`C{-YBV`{1;5NJGBo4+S7G^0o4vZ
zAX@d5c|Qgn4fmW{wcd-O7*ZrBp`By1VeDdEJwO`$T)^zfZerVK3ci#E@eJjRsiUbx
zg<l|V-*C9Ds%?y4*@R5-(9cm6BGIn{lvyfHptRPUvfb*zs=V8uR9hAU?@Ji>t9QBO
z*dm=8#nh#c9K4vFt6)JK7CG0`7%us~NRc3M3KXkyzFyE<B2u+Of1UiIW=EB$3b9r?
zL3~G|>e=|-gX0kpd?_!dV=DqAvbBxoEZk61%qA5ifeh`W!E7Qj|B^7yTb&9Fk_ybB
z&`x60bZl*l;4CX<aU-Y*%;svSH!sKO|8K(EACRa|fh7HK)(8Qyc@kEU@YI#5`;Vjb
zQPdP2b%X8h=tESrY?B5A_6`O}{hTR(28|oKRm#q`$MgP+Z~h**gGab6(7F%zl_({<
zg^$2oFQQGC(!lfk3DUOq+>)wQp3d2_MBa{u#ZoDn?JAc9Qe-Kk0;ju8oYGb?F}f4z
z0QC%V>=eY@t^hK{3X@<UenwLFuCRlu7-QrC+vDwmiYQ`~nWc})VJSrmaq+r!IYjxN
zoa!dW5exn|0hz6G<UmpS_+bRv9xl1Arm)nZI2SjPr>H&z_S0OQs(C2hI=h>9NFMgW
zPO)U^BULff!?{tPKDASJ{gfVbG6R*W9r9yB7-Xr2n_zX!C$Are*Pr4|{yx0@?zBUx
zp!YT}#P^*jDY>Y7gQ9~&03e#4?r`5z9%6uUqDyljhl+q3*tNHn4t#Fx+JMFEHkgWK
zw-%{3y7Nnh=|JQfsv;VjylFC}<qr51w80i!I|#7hokFC~PT6VkOfaBo*w~yy=FnYn
z)7vK_@yb#kp*)b_!b$$n6=nyfh@15bJRboMeJj0?erWZ{uzb#@E^Mf0mOL`yhEtn9
zyhx3Z)<B*8;PP+k)#(k=ovmAl_(*;X3a=@i-k`!U=mgB-;=@CafrURIYWNc;@c-PF
z+5DkS^BS5|qz|%5t`WJRVI4?X8dds64)Axjs)tm_d8*w;7%3Ucz|b3lbd7TR2MS_h
zJbw_wSFzEPgcXFs{FddjoF!aoK&&VsKA*0m+~pYxF8<tFSo5TeW;Xe|a#OwvufK4L
z*$+=@*Of1B!Ok@CvoRIFZCM0-1WmBv!WB8g0t%;17?Z*gIW{VUp>Ipb|C!6pilrH_
z>2lw*0~J}o_N1Ts3)&?dYHp6?&G3FUEs!KQ99$FPEW@b=Q9!kTySv80+W$LJ6WeYi
zZO>iETfp8r5WSLzL44*&ooT>+4;-U1O{tMifLy|DG4<CgwF6vfw1IKw>`ko)kfzB2
z-QXzns>Fa<FM87jmM8@^l2_eM7B?YW0&-~Wp$f#t-D}J<)h{VLgP|{757F|u#?xQ_
zb@=P7Vfze$=-q0qES8c#zhGxe35<*o^L>ID6t8L_uvSTa+ryIDyJe0(U~l7OmMj@W
z7-e6oJ2h6)aQ?uwqC<zy(94)#cEm47h~t%JJ-XUQ7!XCJC?+K#|0f*T+*RIV>bzZ&
zCAO{YX2D@RpwOkJIlEHRMbXmGZ-hj&<QL$xtI<tc8vg4+uWD8iLba!{p?E`?j7zTq
zGH_}!q~w5-%N8?8_LkM%0flBwqrILaNxbB4?27EOBy;}UXKjjI`swoET%f1`U`@-B
z@FbhX%6xc-$dOSLRtQLu^>NWtp-xK8kV~x~S_lp5%Q2-hkkxOPG{`5X7XT>Pcz$GB
zZhkWwK<!>#!T=iF=*4FZ`*e+4DC-_^l?)sbpCyj~%O~yDmR+LidKGK<sjB;_NTSHi
z!oVYGaD_l|ar{kXm@1`T&X22sYUKU4B3c9}_j2$!#M+SWkX`sFy#I&SU!E}M-5`4h
z#}-#^Z1Va=(D15I_Et1EieYbIC_QoVgWeUZ_NTpdZg>puNZMJKeGaap)pnL8HUP;f
zL%H{sqD0?)T2qaVE47=eokT{}VyD4Vra!DIwq^?)ayfA-L&4g*_~&r3rFoG@OIM{A
z*9?E`JV+j^5uqfXmlMic-YR<Qn{3r#xMyFNK=~ATe(IH#Bo<IoNlgLWu_!`d=5bPo
zC&r>1A*GvI_Ogu&GIW7};fbF2;&X{ocO;gd@%a*+zy^vi@r7T!eF{1%9{T%#2r%=O
zBx*iP1a)KJu#n_midPL3`E{P_^sKSm`XZA0x2JtJ6<2ly%o0|Xq4B0K=?<7*{v34!
zn=$=)Q}1dHo!TVXCVZ&Cua#4x_qf=PI&pjeA`_J-w)=2N2XY%vinY%%_$fltZCP~A
zrn35H_b_gE7&bk?fzUAx#r^8O>uONDH*|*bOCPJp2ddZ89a-p5nP{O-9I05g>_r?4
zSOA;QLxYc|HYp$B7UF>5?HSP|p9T=tTS-#rq{jXsh<t1lU4o-_jU9nW1@-)Pc`DWu
z!gFE#NHiOk_@$_XS%sci8vx<!*+Mt<P{MW&3(P-BB27#Lz=}?rp8(^SxzVys<QkfT
zMo66=uvCa}hfV{80MWxULuPnv!usn5#o}I*XU-*bPcyFh)j{+!sXl@kaNuq5Y?X~f
zaIMbUb{5X<O3%a!NFc5M>*&yVK=(KXt8rFW>?=Mb#$4n-JHL?Eust-Ok4F`temcW#
zVl)6(uP<Wdy*s;K;DcFkZW2m+H5M#hhVMTKZ~uy1)@Cd)1og3`9LJ+!uOQH8ks;e(
zPzrI@fw?UdsID$tkeFI>I@Pv)7T4va+@Q(L*_}FJ86I$~?1aKdo-&*uc^0yxiQcpG
zntP`m0?ijvsJ{Of`SAOEZL+lpm7B}t4>_?x!qp9)pb)J1fs0y!!kvncNkZX5g#)SM
zvR5n{(R+arS8_)2Iw~|Xf8GQaOO_=0L8-n89v%s*Q&$f=z~n7tdQu6S1;7{F&=QH2
zcqdO+o*WQYZWOwCX$@?;#co*x*33?tC604{XaW?dR97u<m7(Hgm@ENDbHEo2a^Gj%
z7Fm^2hII>3suh5G*me5VcZk5eW5&|*;-1+nO#uSOM0gB3Bgldd2W5l~;8E;k_w88A
zeXZ4oM&gQAFIOgf14f<sU)-W$n;4W<@JdnosvKC$1VwI8R}9<iUSLh#^#cNpc7ehA
zhp7&%L=Bss8>>LY<W=GP=B>IaD!FJo4h6m?c|>!OTn6F^64umJd+O=dgi-egidHJN
zjW}Oaw{_@j=S4g$m*3J!K|ZmNybSF^>0gXXa7Qi-X6SXs19Bv(;G6+yWD!THhWi&r
zKAyB^^i^x?mrIDLm&d8l2a4#zN7ivyb8FoCjltjbex`@J3MqXXTqz}lj;x5Vz1MB5
z)}Y6Cej})YapLm8E#^7^4j12`8emayN+nYR*jnur=<=|t>njf|Ditq~XW>RpDA!50
zz>La1T>`89!L=}PdB^19Ea84{8vlE!^XU;03f3Orm?5`t2&-x$NQKY3lqDsbEnI5L
zu&+)4GJ$#mZ_U*rE$GV|R@K<67W6EyUAxCnqgb;XC5O}Zz8C(&4nj*dkss`X=Uh4{
zrbv2?p0xLu-v8fkKMs_<9A(eK7bL5K;66QbS}nJa-DCg&B{Zs1v}7KcDC$svN>Vlo
zI()&8;oINH%Ud}RHYwdQkE1(`itKT#NIs0}?C@1^_MOl)9H!N(#s3<tCv2xf&tdMY
zy--*v3}i@kS+ya*SRO$VnJv#-B68;(O~8>Rj!8j6P{9Q|I00EB<{?f<*j?)Y=SPmn
z0Bxn)aW+2`DGcxRfhls47X`AG@&|N&TvZ>`j=ih^GM_MhMG(8f^~!)iI@qxw4<w=0
zPUmyaf6+n+$y#&}d$D+SCthrc$guQi?@2L#7Z!9Z=RqHgV|3Bbv3G?=tB-=W?3s|)
z<Wfx-bGqXRxnnD8q-BRJi`7atNF?b_avma*)Olxw;1xhIEjPied<Hw+{c%d#q?+6m
zsj}YvkJ$$KxANWJ$RX^UsF&y>+miC(T(Bav2kr<;{Wf8K0z%hH<LT)@M!zIg3s!ep
zsMS>s4pqqLGmD3Bfn1q2r2kX+-@a!dT~gvxQK*uLzRsZ}_1AEfG$s;bba!G@c%)Mo
zHz23yekq5l?8_F~AldB04|<6tJMm*RJTwZ4k&{n*I3O~ONyCt-M9Q9!6y5bmkUckv
zpG)cj6+OG$!L4l3k`Kdf9C4Th9lgmUP441JwJ7W-TNG?u=ub%=gX|Z!Ch+5mezvb9
z2Kwfy+FNSMm<glMiE0(QgY2Ov1lG8VHjL06VoJIdrQ#;#&1hf9Kktz5ry_*k^z7F|
zKb|an9O9kktzQRNm+7pCW@tTTu3X+z!PuZYcBG)3Zf?5G96WZMH=zMEQ-DBab=wNA
zII`aA#gG^EQ!vwMoHr}1C{#Fhktm6Y$3T*gg!^ts^g!o8Hgha3h#qE%2Z;~`<nSS`
zP_waGu7+T2zU5HW!&&rw^OF9->(9-&5B0^pFXFW;klW{Np#udBIq8}SkVwQ7XP;yX
zDbZ!&?|)WVvFcReZ5(zn_0E3v`p2BAfQI%5LIqwTwYX4i?XV$kc!x*AzF_r<@hpWd
ziL8sBH?&zqEgc;48gTn2GG)NUYd=seYc!QeXd@EV2HBeY1Ap^3;cx!NLhrT`y{SOQ
ze3P^@Tj1)m_UodFf6C__r7RraqkU;O&i7G?r=3?Ja*(9uv`Uz{JPg&EfeH+<3ok3}
zKHIFMs;Z@=qX<{uska9ia!U)98wlvTf~my9@lNZ?6~}JbL=r(0)bvelO64k#YL&+-
zFEe<JAq+hrwg;DZ0X@fl2^2O#JY%nM?j8J+N^3tIJJP8RYa@a20wJrshH}pvOdsa_
zI{20luX4WXa7vWyLK|oR--ei-f}UW*z%u}Vr3mqtUEjm0#Sqj4Mrye|xrbB7EGeqA
zIyDrPyVH1EJNn73CS@#?p@xZ{f&j`=v4emXrFTZ*N2Z8m@8w9%lCq13>C+Do6k?jG
zL_(*yESk}%scNOdf_BqaSgcVrX^EHuyW8PXIrDAY2UP%9m9v5EnM~!ac!RDAx3u#T
zXQYj!FUZIq(cm_hOzq683P?Fg@~D8(03QxAgktLKn^|NMBnwL%VYf>lfjX63s#CUm
z0e5IS)ihc4qXQiP_#bf3?WjQ-;3$YCt!pPy?GHtQ=Y2bCPao}iIs5LpouK9Bnk9kx
z8=92kj3OI3^}`g(O1B>7jj)&JeQz{eb!63G9?BysyK`BB3#>ZjV`sDu<i|31S>pO^
zj2iVIVQ(vD1w7Y{hv%1fkUp0h?|1J%58wR#>6Q>O<p{A}8;#JZ5<58qb8Jx0Fwk|V
zc$q>g4V9f{)Z9#MBm;o22TFmD!t1{s#W`TF;gf?gswX{F=3=$Wo$9^e9kX4uoP{_F
z{iI4`Y#*vf?TRpRyxM%Q-XFz5rbY+0J$>gp-wEIQp5<ifx+g37iWI%aj8uvqpoa7u
zw}7*$MhqdI+Ufz2b)G9Qm>$j+x<pFi`NaAh4qWK_)v}3qyC>CWXffD3+1<7#t0mb)
zQKx-3Qvm+x?a$#ggS`M`eCA1R4QkVCkpOa4+I4T}%sAUi%Q?wuDD)Iyl+lFU{Ysni
zu2CMMp^AZ+oH1}G^Xdspm^VAByC5-({bjEJ&0|^oQXSeHzkK_Y_=F#$#nA>W=}w?K
z_G`;Nh3Yt!WjiYPtmvC}8jU8XId>O#6iz-mSY0T0-d|okO_dC+>C19OjW+fqqo~_i
ze4bUAosHWluZg`V%V+~qk?<z>@yU6}BdTtK{v8wvIgCa?TFPtXqBBx%t$_~>^4o36
zg1fG=S|Lj#RrL-sjD&|Gaj-&c23Qp5slkYi)7vgF(6muG&WBEU^S~^g+(>%ny#En2
z3N&C>wQTU{$W(1{LDpw#RP3z?jMdl$9H3!jtri|OTfu@b0a{xk5KjP_)sd~eI+xS<
zp0tQrm26TAM1kcrZRw>{HM9j<wvWI6{qX(o%LcygDt2A5SeI|)XAj*jgu|j;7q{~u
z(bvFJc`$56R%8QF#hi86eweTS_U%tZhy5E!03&5CZ%`8M3xG><3F~MoNOEn!pRk>k
zjdtzY@OQl`AXJ@tk#cKA6xPud8*2JgRcbi*{v$xTvhuX-A8mML$%O}_C>1In+XY<c
z%>nq1Q)^OT^)`@=A#_3cjM#Vw_E@z&Lg9d5tLFj)x?^Wn&(GnR`t2EkDu*yJWCLy6
zqiWX`J`{3ocO^TjyWRSwWVQRIRyg@@wiM#oO~EljB6fRLF$_!eC)q(Y>ke6X_p8)Y
z5*$ZOt?X<BbYxW1Q!MX{KxaCY;9&%}FmR491P9Bl(qR|PYhehfu8hx;kQY7kk&g^O
zB4XrtTy_0eGsJf4^Tt>sX}Sv`!@6&~s5~xiSyB4;l_s^%FT<+=Jo-7h;_)qa;u{}g
zG$$m}rLufs427dD4jnl21RelQ0_)YaOs4gY<`Y817mCW5qMVOVXV^J!-eqrlHiZpr
zv)pXtb*Ub_sQ?mkG%3~obxIy9Z=k(Z76$fkVfqC=I2%QPhj8CsqZ&1%nYu+QkuDJm
zm!SOZoEw}|rHX}4`;Yc3nv1;U)n|8g`T$MyJN7bvXFbdf9z#+L98H>5xe9q4L?!h)
zY~s;+)s9GYXPzVnV%zc@YBBkVgFNIjF9v8Ol$_jVO+F4(uZ|7>3n+;=pVv+29fV>k
z3hwk2HI=rb4gMsHWJ()nur+v;tQ9y!$Ywg-1D&ZB3;{OA^vR{+G0xN^kmDB8v>78s
z&@_xxUC&QBUiV~hTi7737haEoI<vnU1;JHq#V&3oacZ5>S=oKq0-<;OtWP=gJ!TEq
z9ZUdi?;55AstCZ90C*|y1uU}S9NE8st#2pC`=7!h>t7)>v9T4`uPXUM)A!OM0X@r4
zR;lDDX_C@4wy<^^DpxE|g+i_FKz5r)_1@grjr>LUph5lu^v1)&Xk+dRurx6vYs?kV
z6j)+K_N|;@u`g1Odjlc1%~8oXzp4-PGS5p?TD%Ddp~7|j%k!WdoMwRf$Spl2A3Tau
z(`Ph~rPgw>vLbg39jSa0^30xh<Kki)9TZZz6ioLMwW=Dq%Mr#U4k<?F6kB17V&%Fw
za9ifdaJ^9#>#A1cI61J`vbn3DdcIkKOuBdbq4kL_1$|ee`XuB<1o{S>MQ9<(-3K1{
zUT9bV0MYSIf}Kjx<gc1T>4jb#OhG|YMQFC<1Xa6p`6{eynpA+PHBl=jLDHt^<)SsR
zsH<Ib!2l^5vI%cVt<|h$4QlxHp*?kP;6^=-sdP}#agMi2=)k1{Ad-}v7I&d~IzjP1
z0qPW|P7@7zfR6u>U?d^J!eQvor)7sB5%ImFmc<70kwCoQ7I}!%=O=Gvw;TIXaIR~0
z2UOV-^#y!(`;Gfh&Kg;McLn{sWLCR`Cscp6&;4tS2lh;EN-^3)V^wa1qS6}Or5+%%
zyyRd{aZ1R}7XCD#Q_m7+SGtNI!1pc&@Pb3v5T}464D6#q&2VwIT|_K)@KrzS_4im6
z8Rwc`CplJr09PH}H1Owg5mfc5x};80Mb-RqU!t~RpYItxyB=}XSt_#%T-)0Nm-{3K
z7J>Dl9!|>U!~hLJGo7{PbuH5Fn0iFzqR9F~4+?h4Npd)lP)LT803czVxZ9=9uFOur
zkQY_6nu8C#F{7~U(##cm&cdE6=tJuXrea_PTlj!Y)x$Fi*T?!UN_s2m(ekaPC)zjK
z;nLwGnNk6%b;w|c;>T#=8d?c^wic8F%f}FsD^(SR(_i-RlB<lZ(o=>4GIK=Cb!?aH
zkb%p1g)NWj5dcB3-O+R;t_35$Nre{c#H0C0UKv4bsfH%YHrtt{^JD<fUV=G9CwlEE
zG{-`ww&^7Ov^CZH-cZryHCvGPig_Kq1_d1??^DS%q{flt1gOdWptXdiW%Lp0LURB!
zq~RugV$pF{UDJGrv8?3%LT+vdigd^u;!_l&YO6s)rEIs2$SHJb(4^7Uh#lLob@G|x
z>gWC1E4yvgHm1E1w0RfxF*VMW#HyK*dF&sMblb=<QfGvc1q_Kb>N%3Vct+0Zy`?5c
zCIwSUly2(KQrh!RuX#jq>(?FImGf3myU|-&Rcz5xp*GwNi<!6<fFE8Sr=0A{!3|!?
zl{LgD2l5HdoJOdBK1#%C%Xv7^BY*Syliaf~*z)U7t%dRO!c0->s?GG9UEFoF0|!DL
z*<mV;BuEh3t%BpH9%hW_3RbNtf<~9_Z<ne=M4*wZ3VB(J;6D)DAQ2gy1$(?I^ss=P
z7bs~r_n5sUEpj$%?mwxd|H3&kR6jtRZ%|3EJZy_FDca77-}k<D3vEEd6VvmeMouUh
z%Y!tZb+8>a?%~NJc5ZwV+X>Q?C+9F4tnbvpoZ+^_j{CT;vT9OTuW^W*KhKqom7cAH
z?|g^jHmFv!1H6J?{UZt9+p5YQ9jt0>$vhV2h)RYvW#{KdsUq)TeB}AW3N-Y<v;z){
z>GY%)JuOUsS@NI5OXXV#umB3GXtJJf<0G_m{JQk+Ib2Cf3^PP)fgs=Z?J7He@3eKZ
z0<4Zy8aK7ummQBVGH>hBI(wYKxW5SAwZ&A>lsdkqWXIR1XGr<ZmsHz}gZjb3UD7rs
zc(Uq~17kh4H>+Gt4Z(=So8pQJ8370sq!G})u}*0k`a&lLv35ee=(*;g`nma$g0lp@
z#H49~X5#V`KU2SD%8SVDy#+4>*Fc@822wVsIu|_~)d^{V1J{|;mIpf$_b`Yxb$r>!
z+G@Gj?|hQYbnS^oU6B}g$Md3gr0iX*C_D`uXufk#p#CXS=z_a*#vGN7_iFT{&b=-h
z1;w9>A_s5YB|vNXaZ*pXe2w5)!OU!u+M{|RbO0#Fm4?b7aL~M`(=?h^)jg^skf`7a
zjkA|Y4~k|kZYWGeGCWjO%(|bSzWo_2>W^Q)lKrCIb(VypqLqw63SO$~sc##4chM46
zNmFc8sIpqjud&NX&}@T48BkNhw7sZ~Qg|azL*(fJe(i_YH6lVziRim@)jE<egkH8&
zek5|*>=y8^E?DvQtMI?u;k>cs30n}<ep|K_^12!tG%OhQgWbiGLToIRmiN7LOpjFw
zF(r6YD*7k*)6RQroP3B%?O8tT>jOFyvaeTp2Y^{wsI|x-k9kQz3d;U4OI=kk^%H1L
z;MDhCrZr2C{N<A6#2DgH5#|q6N>KrD5^)+$gczCLfA;#>+mB(L{rYn(h2OvZ{{3ff
zUmA7tPKoq&40KLklt){{DP>7F+M*%`dqm6U0lAS~V(g;g56p$1AW0cP@9r^L$vzMU
z>(M2@sFvWUCflAt*PG72Ol9)Z{|R7I|Je(edKQ51kd|CQ3fhwPH`Y6P^RdEyOn_;j
zny@#d)C?f>JBOZ7_8U^~EW%|&s<x}k6vZV<YWFBj;x%K#-02QLsZqm>ftN386K%)k
zQ)o@u7?iH1r@a2O?nMLyB>ViRo&iAv-1L^zG8hReoFd$^RHfDWs9`rJ7jaj)ETRb;
zYfNkUWt>cH_g;NaG=*J-po{H&hw&2ovmIiIqy(q-8cYPinr20dS)%j=@CCNSPN?dw
zY5<9o00a>|*cy0aM4r^s4yrX9B|Us);EC5rG7qv=Ua4~CV=&Gpd{x+wa@K;*Nbbr4
z$^aN&oOZzf$4b=hL38`6s8pSo9tyFWBc(3#s@iVEK-DUmx^fAz4T4npfupx3zklIu
z3x*$VmM%$N{_eXyLQw83>7}(^c2#%=;OqqhdnN9Mn9am{J9pAu)uRc181}L#B<MoZ
z&r*P2gx4=&zN*&ZEYcfqL&4Ri&{LXJB)?aP82gd2Yp2YbYuF>iG$hc`G?N4iGOE}#
zgj<*!wg40Yq$NSy>jHW<8mb%W|8pYh-wJfg=c1Z1_)!d~J5i@OrKBhA2=224J5+Em
zwyXvmh~y_MMRX-Xw#NGs(4DUR-ggxY8Y*}3c$Q*l@XDcu(Rj=fLb3b6eFIeITK3nY
z4wG4$59kuvT9|euuokT`1j=j-yMi53yK+2Q&sL7%eM9T^f*foi!m@{KKA$*qr+VR`
zD#!X1drhFEWP=M_Lqk}VmsiK)LgI%l+&+8@{43u)S4h1aX{vdIOGL&23{(qIkOpCL
zhOSWYPEl?%7bhOrS@P?d#vRxy=pb>yZnA`6%W7Xt4<MQD{PCsAEpLFEky*&GDn&Pf
zk>#yw8=kaxiVo^n_uU>i4pnjID<gEEIwwFt#d81^Y7cq$Nu{IPPGaLkUt1X2AwPML
zK=NP0cXE_TM|)>@009>uH^^;gfg_bVqKijO0~>-JNsm(PkP2{dewg+-ByKf~7)Wt-
zB31FrKo`yT|MK=n>O?;<H8dwZ*nDmm?!?WoL(rouZs1ig%ap84=Av$+#H#8s@Wmd1
zn-d`dr$ozyc!9*{rcE5~T9D(SLJOoYTjgBf+<+a{9y|u9k$75Nwdm^EZhCgO<TZAO
zQ?*ximVcT1NOlHD{bGHyvkQgFx><ukx^1CCj3<jB<aY+4sDVvov=UfnS8F9{d#(wq
zVLJ3wfN4p!2`8fSG@*20h=;`bB9-@3x=hM6<@{7RA&0?x5B<+%wpr-5zm(YcCDAN5
zcm-n`nZK%v0me-;7qrM86g9q7yIrtq`;L_}RKNsRr&cEZkU!K<CBm3vUM)v(jnVoN
zt&=a0Ynd;ndj*Agw<(|d1Ic)*xKRe$1t~O&dBqm=ZOh((*SdqBfE#qDq1<wV0@00B
zziLyiY&k|U+t{A_%=rMkb5&-~!qd%%=MPdw?~Y-R7-$a=8jJ&km2CTB0=rP|?J&y$
z@AL$;3mn2L-C4GcaXtk{qdXCzg!!Fhg-i-H_qJFG_FnJEL1oHR$`R!^0wtx;{u^nG
zmf5EEz9ke%5dfQ0?z3Xiw2_N_owCQ`K~khe1G;joXp?QnVKh*L>8rJ&<#lFRML6D(
z>NcuHV}7ZqkFIHasta0-Etw~@1Sd4Wdv86}ioq_u0_+#4Rm__Yv{A*HK%5`8nEvKM
zE|c=zed9?D3-S$KG>1iZ8ptOpbQ`7SH-<?@qL<&o|LWj2C6L&&<|`~Z!?zb(eD($v
zvc6GeT5GPWFFJBRxw<8}K7tf3XOw7Gh`fD8pGtQzcno@DW?8KZM*hWK0xbj@GG%SD
z{5*<;7tEPFzkL7CuOF*+){>cww#_htF7npsZA+bDyI-~)`+6VD-6{%7qjgEzm!#ge
zf|O_q8UgZ>k|Us1cd9ii`CtlKlj<x9OhMz$k8?sZX<K|Wltm!>#*$biOHiN@@KJWc
zCF#nWw@pCvS@DBbq~gpuzFsQ1?cN2$pw#Y#I#ii@<dSW&4oZ)EQC%8>8)!D}a0Spp
z?MA-IQA88OilBU)Ej76tkWD!k2kpW!r4tHrrRdtzlw1kI5er6LigYJk8kOwn!M4Dv
zLozr#V5c)()M8#$n-3?%Z^CP?!{2}M`iJoP+Z^?FXD^$qmF+pKCRV1sg14;}hIvQ+
zB&s9wGN~yONN41>4}mi%2G?uvw34fw4GM|o`uV`m189S_M)cd#S&sU1QDy^n@Urks
zX)gPf3Qw8#CUqBEI@OTXYBp{Rpm~s2rtx%_Fl^#eS7!Tn!hT@^Kor-8O}g>?I0&go
z_yLN9Z#ONyy!C3(@~Ucl014%16Eus%tP%hydJY7mP#u7PoyX{^QCYh7fS;HFJb;3|
z+X`Ybi7hopP##f9wP>n1zv66>(Uy~%&S>`#6KW~QfXG%bKa#Fq{n%9oepNr6EZoDA
z@QRrxaxI(F;yCx;3^7jG$d}%A-XN=K1%BTFJ9D4ZsN5O7XB2%d`Nig4M&n7TO!ygM
ztfOg|8p>mxUNWKLAeOIV#$qXk)(s87<yUN*p2;~VyxX;tKkjIe^H~qP;wzNTlY8OL
zbVUXvh2^QD`yKbuXd$cQu_>|lwiTwLI(O3yI2W!}jv@D!Ir3%_=QLMS=je1+pA)`~
z%IjIk4VprO0WvXJM8lF5sy5dbEfW&7;#);Af$!4oakI{ZJcFG9)W%r9|4{vCb2U8l
z8oa?#@2a(we+m4+Fjr<ai)4Rb5A?nc3c*~wRw23u%V~A^dsLlwY!MDAqk<wpYJ#05
z0heezQWNqcsbIeOfo;#eSWD>a7}!f>W|IBOf=1;%6mjgfy1Oz-U592m{huL|^<Siz
zauYP9&ayQ)Bh{18fYDbFt~5t3jK4~|@$SJi$`>YM3b+QFzlsc%R2Y7Qvb(Fof7+^*
zE$&s7t$5}R7%p9-Vgi9mfmGbsyPDurrP<v{qEldxttjhvD#V)a9$2<uUdv~J6jN=s
z#tA)WwYtSKFIZP_eY_D{?024IkKU;EjamER#Qbx=tXr-nC3C5VII>P!injEB2>-FH
zx?hCXKcmK%e}0Z1ge)w2qkVu<feH6jwnR?~L5Bz{t4p&W^pI3(oL$~9+q7)b+|pfq
zB@(h3gaW=r_hg4;mMmmn$NB)Q-T|Vt4A)ypJ05PC40V%-k7Dn66w9eA%0{^3fGUM{
z6to=UkY*1JI5(YYu6l$y812mi$*W<hTpsD1b~sKNExS>9aml1+m)(GH>&)X3>Y`Db
z9EL+0YZ#TuB3|g2^+#)U@2*LDRrZJkdpS?Fzvlh#&eP8TNkF#06*XhAGt)F~jD7Za
z0oy9=1BBv9=zv@ak0oV!LEy_OP{;>Szz+IR&`EIgC9o4V{2mTM<#jHR^G`|Y=7w-n
zU+Ho`yIY(@pa-yG>*)isx%?X%{YG$TEeK&q1KY+;NupSj*GUl=j9D1ZBw(RhG9J<9
zkVM8=RU`A;C9wEkytRb(&PvrQIF1b`748ixK5a*17>!r31_!)=Zl#nX!%%g*l3?w!
z7aLl|=W`m4pi37KzGpAo{M&YDyVTS!hZglBkFU9c*blsCUI$TK2<!nqS=Qg;ZrPI@
zN+GC*nhG#b*RL=;H4t?6rdXnFQCs%#VJ-dHwNa@pQjA$K<6cG90j-9n2J6naVTi^C
z3zgjJQZervB2{j%!o%AqCkRsH2p!H$OYh-M)jCZbtNRJ;3rjRH&~VdmaOmgL9g-o9
zNk?xGUZM648bF>IB3?3Uj#(EPjFlP#YcAO?Gel@S2MY8-4FfQ1a=#i3fWtwfuB>6|
zd;j6|5-jIK4c0o8LJBp9SVP;vbnmb~rZQ3oDi|l!1D+@ykZy9cn|LYKOuqkDv>nj=
zMOpzoo3_voJ#aLFjRDj~Y#%k3v)k9p@;1=kIS||+l`j#|I(Z>xW-ShgY79gRzk2Y+
zKVZ~C0*KV(hIfNN4C4m2qz$-v3Y>k$EBojyn@KA2z~&YP27MW;SL(dr#AQfC{r2?!
zA74Lv|Bt~iNb5EbV6=|v^qB_lZc2eChg2aNp(~PyoV$Z@&u$GjK$h5Tz6o#az`2nd
z$#K=cynP7~x%<Pi*i1(z01BEX#K)=f4kpvum9QFR(jB_c-V(hZ*w>=#zCJKX9+>Bx
zRb>>G#CLZngNmt6AMs8H_YSGpRDs;PoS(9En5`muaT#ZgrPEVrW}U{yBQ*?jwUXe~
zvP8~)=dwy~l^6T(!`sgtH=kd1MkjWwntiBBU-@c9@U;*fE=do{iU`brbKVy2gu@v|
zB$Alf0&XfW6${`}?qe-)eTG7+JK$jmcHt0P;UX3Q;4BPS^w5t5JbZ^-MmFb>oTYcX
zlY)tDReQc6VHa+mAbXX3j=@8IToNUUo^4LHQfJ~gHLgJ*8^i8ty2Me-JC(@Q@4bZT
z8IVUkO1VZ9ALMGEU?;=n*YQ*mTBoA<Fh)sBNurTtetCqZy7jK$J@HoE!^_KQ)jlg#
zMhEZ^Tg-bf9Azes30!{Jx%kvJ${QZhW6spcBX!VwW?#K#_uR)jOYQcn1o+CmwT5a}
zipE&68=-g@8!WI?)WKC(Ci$)Es6(`~J$TYbzXgC@N<o#}JNw7*u+$G~a0B$ErB5)4
zrq1^U$o%GcEjAlQRToDXs?s}hsiZ?=IsKw`KWpDKoysE0-dJ|IXj=g{?cSI?7K}{h
zb>}9#c+dS2;|m{z65m#fpYLF>0mo+y{8Ruz&*G>8M=$vd##Kn25hz#kf(2rvv;o8~
zbpKox1oS?7GAN2UTpsP>Ax=&xPlPp=Y^N1?={R{6w4ej%i)M?Z`G*mVqbscQ7iZ1v
z{Ny&X>rNLDcs%u@hm!=zlGA|`d{Dmm&D+n(D)~5n_a9z=2ffzc%m2Ryw%)`-E>Q8k
zR173{wIw&%wO-z&#G#8*j)H;rvuuVPLq0TVm^E^a^ULzpufp4J^81$piFJLx`x?>R
zEDJ62EmDXJEEynZ9Sx71&&Ggg?2VG#YNQ$uCHFNm*)AF5mM<6>)j6JYj%*_i^`UO*
zcam1lCuLo1==2P#^5_U?Xi3Yxf5HnI&<rdoz)G3&V&2cV1FMp^Khvs2+a-0JI*UR(
zajq)BLu1%ki^~GfASd$*2gjMz!ACVHex-L8dKB>u7-?zGGzu+c>i!xJnyYnnq45#U
zZ=_2gkg7)gDHE62gUZ7QgxRg4&L%KO?xnF#IGa~u?WK^yz`>w1i^@R4Rqw$IoM4vP
zln!W`GEaaBA?%;qbW*QXr~pna6!#=i-0CPb1rHPi@<P67Xeaih-buN|PhE6qY*n1o
z0HM$oq#EbQ-wppYulc?S6o^N7Z{vw}aynwmZ)^WR|9n=_IZO8doiN^bQ#fYm0bkb|
z-8}Y()J=vB@H&I2psBX5+>cV$%1t;xMSdOLvUJsMvUkcEU&|84n3S_MjD`0a7Z=vb
zO&TyQM{0}7I|O=u88Ud-hJkXrl&-+0IemVMP_<ELX0m3&pf&(jVDI5^I-eOvv|#|&
z+zIG5!#&4V^AGO~>5On)k)$uShwhgcwc*^mJ$xwYo9=!Atux?t@&Q{e0^$W=mICwK
zrfDzD*hcXncEBwVcPuW7N}{3R$B*AWdHWKgbgw@O`r%^)LBayJeN<%=Vyd=7nsKS#
z?ZKguig`>vO2IMW#~h5pvA4~aBzLCbsX5osb$Yl?7~UpNjS2#xb2^ksKYjgIN{Iea
z(vh>QhFHofiA83EnQlQ1`0`hMcp4*6;di9V7y)wjtB3O%vv!fB*c-b8WAL(Sf=AM}
z(}xe{@CLVATXb@DCIlD42E4K^aYHQLSpn^RgmL()O@=tE1Xf_w;fYX%!2^IKeb^yn
zfg2`U&g{5WKJL~4dTNXkv0d87x09&1&+^i8IP505P_4Y_k*FXf9(LNs`M|ca!|IzK
zD9gedyLY;Rf)&bdqN(jND3$VP?AJq~p+}I-cK~1wmcm!IkRa0z@|4R}Xez)C11z+*
z3UIsAEkW&~GdlMw*Gl6cNs<8u^nfw$KoHumpF(n_S64%=<cN}T2x|0IFTrjFxYw7q
zh66J%_V4YA)O3yt5J?l(J~EuuUBqSpT8M$ck<7IZ-=~zlU=}c9wI4@T<^$|;6uIVs
zGeJvuBmicHHc;(pEMR0NRg7Ncx>G-{QkQTgdbfw3?-|hw-8dov4$kG-EE}YzF3ItA
z^I~1)ta~LE^I5`9?R55**tyEisPS1ANJF_JQ%bi|f%4i?iHApJ3m({IiViO|3X7LA
z_fZ5hn{J9>3{aUa;_wwRE_ml9Op%!_4V43#E2_AkD>r(4vYlq!dRtj(dW_!7lLSx;
zn@fKKOwZaHn2lPEJ;NvFc9i*RZBp>mkE4|F@+TUA#eC%q*F9Ak@wX=#oHJpeN{Jbc
zu@N8*JfckRIp=Sez|pa!!f1Q4IF!VFKdB4XU^!`>kq-HH{ng+7UHH4dD*O0f>0qh2
zr5ypRSa+^jRGZBW@IvKQE_7?}-K0$}OJ@r?%HDK1lI}i>KSy;waCJ}EvoD+pLmxt3
zT<&ZBdcW5DsxYoV>*>9g>~||5*7dS)1*tHjPaZc%GYx*lX+Yj*k3|Ys$eZ^hxn_|b
zv_A5$c~tk{=>B`JE&Y6fFnyAT56fN~?J1IoJr6~a=m-FujZMyG^<PQI-zR6W0!a${
zr3g8-u9zU5xoH~U?k}n^BpJS}_8U@r=2oB)caA2<oCi%a=I-(UMkx?GL!H4zx@zd+
zyTHfq+@H4x*jy53T8Kf|Is|UXQcetgo6YMqW}ru-<puO5R@xATLprZQSawrK&M(kH
zX+k1$ZqP}V<ughQ2U6*oyrfyxi74aQuj)?k2%=CMrt}O8%LA-7-oxfIVX3m3!=+|q
zxkJ@lW@3GeHCVm9=ZD&7%3lDDsLiuzZGNyguh90f)|$K``sR5>T|tU7paaw+Yzt~n
zE!+ImyqR@^I1{1XQVVGHnhsj{%4~l7Jr_JMAX%{*(=tgzoWZT;jBNvBZZrmc6Cu7?
zJA8K`1So+4Q`lC(;b;x8&K1z{73&fyn<Ph>l|g!d9V^v~Fm8C48HnvEJuuRgnB%#l
zL@t+G0WXt9xi)<iSq)$|5TF#^mgM5y&V5nDY$0f3U8X8iZooJ0(J`gvO;fK&0J~;L
zD|ygp!n1&bKj@+^y9FC&*tg9M3!w@%#HOOG>W-h6CjwpI0F@s|4zu&6+h+2-Pm^#R
zj!Z;);T-f7nuF0e_Jj}K3gj<qf3(##Z7vDbPac2Pqm=>1M+^J{N%z4L>kSWc$4|+n
zbl{1zLX*vZz>uLvSan>V%k+0rvtW8;;PVJd?l6Fl<vru9C3bj5GasttD%GN{BkpT@
zD`pnp&|z@js<=?^I<6{Dns0JMhiL?i;zHA67;{`AuqYv&Pnt0v<n!Y5g?*oxM`)h!
zAYZl4=dPWId!jieY?2y`I$&EKHPL~1hL$gX$Ud(>%Ny?psA}X7{GV@WL*WW|JkjbG
z0iFjELO#t(=a``Af(LkyDog<Jq`U#<5VxEtS=L9AEMyXH8AWYT4$_NMWqCIBE-+<Q
zyNB82BfJzPD8=l`J4ElBUGz1eZ+fbrav@cMwF2faE+^>!nVYJcsZOdUKSjDz$lKlR
zIZg5;ugD1O@C=WK9axgqLfWr2pPd#Mn>;SaU3FM7^|Iw*_f1_jw3PGc(?UEzrX3e3
zq~Zo5NF{{8m5#vkbzf)nyICM(RoN=-TUjM!%BekhUKE1^=ptVq7$lAm8659@@UHP1
zv-1-BE%PAx-){AfF`ZlzP1mR5gAd+-5=Iir;Dxv-fM_CkKvBbntK2l612-2KR!SV@
z2vC;5<ZX~ytrm!Ih@tdSrKrn<wzofiDBXR(sIaUlqc`YAg-jr_<uuxk$}UrG3<OAH
zRBbVeSRwgTBoPp^Q+s;<IWons-+zv#-JinSmk08k-p2(9d&*v`{AkY`q4e6yAu32J
zIEq6n1$f+5i5<E=G#7ZbLoum>k`6K>t6-_~60R$PZ9|pHiHdJJ@{@ndfb^2`e6R7Y
zB3|xJ=sw`e&MikS1Q8$WLBLD0SyyPLbS|yd(qpm0$Sm9sG5ZeYic|hD56`_1HTz9H
z2ZjnA^f9nnoTz#xY>#>eB!M?2K}G9_Ts|CZA5hK_Lf@tx-QT*hv2t!D$aZC`QqBU+
z&8>$Z|G9PT?!Y5Sif|&l*nt7YBa?}>I>+sCsG#9wdm1ELmOQ{ts9v6#!3DLSwb-Bp
z$ghPCndpe;2M;{g>nFkFM60WvM7I<k3Zj{h0-%5v0X#hv(e3nHG*%vv<6&cbN1vEE
z)`r0dS#OOtsSb^{zxb>0{d_Sxag@tBENSHTi6a~sl8n0(TDFTOuwIHN&Sg4XAv9-e
z{wi6dwume}e}bfdAE0eK@T$;LhEkC>842FXRhI=WkcQ>RL#w%A9;)i07_8UHB(i=U
z-fS)wy$`e3QkJrlyT;+BDPndMP3}At8FJ3yZg3PA^ZkDKi*K8qu+R4A9D06w`oHuq
zUagAMQ3n}LnUAx07K4uYIqrdj#&ZSVY?~@I4~!)21}x~^E3+y+j_8vDsiO_oQ&?T2
z!K@l9CssFf^ICV+pmpzFc+K;Hj8My|Q%ifnE3$=vkA5+d1nhh^N{@!T6f27VZoT5%
z)ra5~7{miwbgOdyCDj?#8JTPh9FR$t%%FGQyc1wqK<>|kJSeKjptr*JvFLS3#d|%y
z|5<qb725Cv%6mH<S8Jb0!rcxquBjF;!v`elrzqQuiCu(_y6nHl`yamkX|WBil8+$K
zLI{PE&;`Cd7b73MV0c)KGY~7)$Y$^R&%*2Hr<btg<MmmxKoho8McHB&DA8zzTuSLp
z+0{Rx*@lRVw!b&&6b$9muMBb@B+1|dix8=zg=uJQ&qeg+!5he54aH)xRYe(;j9E>c
z_cU0|_nq&A|CG-TZUfi_<k!80n?+10W_w1ERFO6Z>66*Mgh}#QYtkedt~5G^#o?6$
zu;fgOi6Uj(zf$O~Z0z;LIB;=&<|TRS9jHlz)$RwU9dvxm;{$y=c2Q(?8W|3ND@jnu
zafKJA6?$O0Y|j22Wlbx3w`Z@is#ln3u&y-<w`Ac;!}fRbPTO%YQ2t!;DKKf@dDymr
z)N`%LI4A46(BWxKBtA_m4yLvs-2f}W7|R<Kn0LwzVWyOMjP^{|zDTLO|9@e~sET=3
z?(aR6<qx(s3wS1``!H$m-uAF6%y1EonZ_((`iwNZ!xY<7SwJzVdI$V~K_hl#s;%#4
zgr=!i)0U|k9_&VJdhoHgD+_^*xC>hFev>fktR57h(F~7jZ%-6bEzY4REL&Zc0b;@2
z4`|+yw+q-?OZb%B+MDcnWRf<9kiR}c$BQ@2*I?uZC!i&K)k|jV-qpj=01AlJr9xqV
zRCC^Kq?6X{AG^C@ab5B4NIn;?Wm(<T_^I+#e8!RPI~a4gr~LyyjzydsMDx<RdG|H8
zK1Dw3sL4tPuvof?JK_=^y`*`5+C1=j5Vxp^tluA!9@vm`d)CR(BD*)Xcb_CfU6sYG
zsx(F<%U3JluW}&(_`;~hn^!g~tseV&(ExcEcgj)!b-tPmdnr2Bx&J|&lFGoW-28AM
z)nmtjrdEaInlK!-ASH~_L^%!xD~H@#YL*R<;*Z|GHh3He+POGoM{U$Y?;v@0?+O20
zvh&43(b=g|RZ(-iWGiCRT?p-TitQ-DTrvtCh8@+U_qCi3crA1mk#~Eth&0}tGFQds
zm7~CB2CAQy7vmm=9FUWO1uWrQz$Qxbmd3ahCwG)5Y@RO2F04X<`Gy32sERX^0!FGb
zvKuEf)m3GOi!d7mN5IJ<v`-gyaC|fRsg8b|)n^gVm@PRz`|*qlOs>%3lkg?Y|D7)B
z;5U825n}bjJ#1>%rej)Kx>S$s$|qNjJ#6Pj4c9|tqT0)2#ND7sV6DCN9Ojk}H{$|<
zd%YjK|M7;9S>iiJbX&RC_1=W0$AGzU$vRC*3^6tAY=faEwHE&OC}q|O9v&=8)V3Hx
zQg(6$;D1l|%^o$Rwc<!Q4iMr<eH^PmzQvi|%oo+&$e+sIIyWcK`T`m)o7bk$OlW9-
z*|0%}MjuanILm7$ESGx$8IXEclp$NyuR?8itFyu7HwTnK#|OjYS@9UQ?R~dGr1bWn
zZUmR+HN~lyRUbPl^Qljr%2Pt^OI20*^62_5J>@6|Oy?v`EeQJ9oK&`HF@5=2IbZqn
zA^5EGA?XXq$#xVzIA&I@Q<Gg!aEQ~hY@N>Ji|6jXtmE@JMuy$%uK)PXYO3uHE`s2s
z0jbv0P3Drk2ybw{8u>*c!i!3ma}Ft4e6&j8?s9!NWz50DzpgJPMW?MzYmcGP=vqG$
z&?JP6kNjP|HUO3~iKJ^qs|95KopOU+F?y9>!$Wsbv|#JcHrp22rrkr5^T+PTRwx>3
zJvkzY3<HUqL~F}u=N@jLm<&fH1=_q$D*C70e%Xkrv8AK~kgawIreLG={HU`?qUmln
z(X!k3KYsfxy!{f>2wX_ds$_d0woj)Gc7NGa*YUKn?YU4#uq$wEdvz>VW~U_Zhy6jw
z%-Tr`9MbdwVh&JB<RvO-p}LW*4bxFz^Auuo^#~>DpHw5;vX8~DW@L=5u=o#AafSk#
zO{y~y6fJh*exJj>O2P?xTIF0Csbmxm+i#o8g=Ipt_XD$$5k`mPRLVZG9Il(#)Wnha
zq7!6WfM?mn4eEE8`(U_|%Sbq`^==ENjk!ufffRHPu09Z(nX9jw$arhY)%?eeX{6@&
zRm06T$r{><9_$6Uv`7#wWLI`KSZcDWseYdA2?o?p*4vf`?dZ+afCSmlr+8l+Yk*4A
zE)Vihk>Ix7TUC#72GEl`V~MwHKQg1(wFSNhi=-U}QfEjJb_4uAw<VSIu~Vs+GaB&+
zEk3X|T<95{pLRU~1;Qrgi1=fq94gyk`iOytjV5GiRJ4zg$F*BDeZd&gv?oJVF<tBe
z?6u&nc~FMQ)~oPGL1qE?SZ~egX6Q%drO3jzOu2rj3TUJTP_;RfOUglmPF-A<O*NC?
zXMQd&<(z3XJ$XfWu7jbk)@x+Jy#MI+i?^TV)>$}yk^lCe<<ma}e0cpe{>+;E7VK0v
zp3^les%Dx^K==Sm=d0$0o1DK=5I2NmK$7ojkrK3H+Sq_q11A&=et6Hr-OeW%Tr5zJ
znJ5w)?g@laB+XhqaFsXi9HvQUpeDSE>}Z?X-u({)kisEJR+O6w`K?8`kgjMF8IBAl
z2w^_Wdqk2a>vMqmSB@$X*}*B>Vbg#kIrkL?3E=5L3_LAf!C>&d@oYPT@7<swA@BPG
zCHe}PEuU&tW5OoUw~miwd-m?c4kQ*;X1F*2LsjW`3NM$Q(de4!iq|cNW@g(rTM3CR
zhx4^^RBUANRq+*-Cqa@eBKMV)Q>+m-IF2fMXp#@!?4@LsY6`33Xns{KBW!-B!U}3~
z1#O?%VfTg(KM)LFKXJV=B**)N_9^nI()xhMs`{jvRvdzQoK(D&#o`by)`;3M%buY8
zyTGn9&X-`=WXUc{@YmuK0~W1B=$NP!oQ6Ep;p#4_`y^!?D3yLqGjsDbRkOEs6?|et
zZQ#J*<Q*wPgPgYN*(PtH-O_t$EG5LSyO#;PhbhBLm2NIA5GxKG5NPy_C>%CWRpU5P
z6Gi3F*0s2$AX}EhGdNTu^v{w=HW>LvZUJ;gOoaKPx36Bm3i(6+Grvc7{+gu%Eoy&b
zo>+BhXf-kD;4r}HjpRUQ%UTw7C~oDI2nf9OXqH9NH8R?TUZm?qHCHTjNm}Q!XG_#!
z9pON_k#kc`X;)JG5HSVfnPaShFOmTA%@1v1XepmFNQmo6GNk>JPAelTY0|t8W!OGR
z2KWN0ExW7{HNi>oZk99p#05&-JwMA&RLz!($`LxRSk6)=0Lx}cXs>4VowBDb)YNv^
zNg$+~nZ(O?dtx`vG7%KJ%=O=Y^v&N>f(*@6NwGE+K)*Bh2xpF}eQ-4*{Yggs=m7L(
z2GvOZ+qh&tlT=AX7A#VAX!dbch1$}Z_aG=fVor?TzJPQoSe5Wp0~_VuudSu<cL-+N
zJ-@4tJxmm}l>-1hK^n06c1(a`tK`?nYB#(mNX}C_e9<#yo~=1!?=!6Pq7!Ub&?~XU
z`4rrzPqLoCGGa=N@lxxEBM@(w$&HDI-ip?$_p#HV@3NxHd1h_4N<8R2zMidNj?k5*
zx~#gMy!u6OT4)rYcEA)BUI5CgP~e-eL)OF8;d_CzU=&iRqt8{MHHzp7%?vW#U4TjF
z=^T~EMNPJ1tH!$MH9NeKsc*Ft3cp?>p(S!>YKFvEs*bS^&8c5ygUc2>U4rWyK{m;u
zc}YU=nJqMpnUsu233A0daUUDZLuDZW1vIXpmfhG84iL7;&mhBxA*eA$W<iV2*|W~b
z*?O1pzE)*k)Wapmn*aTzsD0SevCRSFIKD4vfD;_IYiC-$g1gR@5(xadLo~pQNZ?lh
z5{pzA8T(eGE|84#eoO{3+Yw_q4BpE*Dz(DSYE#yZl6pt3lY^9XvqRvT(=}CgT3p6E
zIF&K!@td6ATP-jwtQ?vH&@^hNT9TH;G!=3~)qGK3_~-#T+=1i^*VBwNiVeqbNvHnG
z2?|nXMRZ9*zwD+nBspBoSInvfXEvg=VR-_(-B55jfhEK>?{GW9zIgk|+t1&B{`T41
zM?t>$myD$N90p;ktOVRMlPFDmC-h(w_-yF8T6<X~Wsin}2ZveN1yuzuafCwYNi{s}
zB$YtiVnSdwkUV&a36;BT-V$IcX!N8Oje~>qWLv3&p_3lJqVAw3C3ni6t&lQxjgqBr
zTaP-he*zhW$Yv#r2M+F@?X#=G{9W;&_ib-vg|BFU`MJFwJm4&ehguR4#1-TdH*VZ;
zb$9HkLbn4z{xUyZUC=ET<A5llGZ&!VWCv2s$6VyWpY{+t5<?^!wXrZlR9rRRHI$$S
z)U52Fm!gCUITv*uu$F4w1PBh`0bY#XnK2rdatD4MUVnB1n#vWs@Oy|^Rb@<{6OK78
z&39P2`zk)4FM6YF40<7pOI=Vdwu9EH)j<2XF@*l6_8e6|$u_$>>!COZNujBnB|e+*
zWM+~P88=&_NwY;3IGS=UQnsAYQqTeqAi!NsSi0(kGv#W>VAE0*unIo#*n0i=^-C`&
z4$|HqAMJ8+qSSTKzLO*=aS8(UG+F#(bB)2ZCm-$$;&zA5^}+sNcS9Zl$5kl!&|0iq
zrB0Fx2r?GE7Nk9~<Gr(I*X!7z(G@Lg21E;Z8~k3CZ^)pL`*D&;)XJTD3i|>qcX(ot
zCqBoGrnM})o+@2v2N}~C%jqwf%$_wZCt`pV7@V@6<kLR-TzlRZNz7tH9eG8%7;}U|
z;l)wO01|R<K~UV?<E=h;h*ippH8F*UPTPD?ba7zZ+~Y3%ifd(6v@wJB-b(HnZ606s
zIop2$VB+4t;52nSmiJQidh(0RkhL!*UCN#}c1#@LmC(C|;0L>V5GrF@3JbHoyCC1b
zMaHr_qgsXbl^hN@sulixgIYJ*Gu&h_$^oEvf@shH5{l&d(5Hs71f!sd_Iyh9o=^EP
zzc+<)XsI>#ksY`7u4FfRsvBbnX87Rj(8n#@o0H079JzF|sBT8Cc8!jvk~HJt#HM=D
z0iZ%_KQJi%>_aIrG{+3olTRo+3u+{~#!A#<=G3cdAa4wZ{(yC&fpc*Mk*NY+Q5G(F
z#ML0F1`Ri54b;1OGFP}U)DBYfa%M?O^=*?@*-SlUVHPcsA%f4DN{>lLSJR-r2Lg^g
zuO{1x<a?58u-zyy)~I-lQa$;$<-Gq|o}L``pBmzLg~~OcrW{+hy|$%8@3PBNp`ySX
zssiFp-Qs=UqYi0u=&7rM#D-3|Njy?ld8@!Lv$Gj-1n_RO_Gxd0a$Qw`?EE?7T1Y5v
zlT#hrGW7=R{cQWVi8F{0HomLcG;d7A6_8qGWE7O6=>7`B<^5~{D?(Um1V{#@s}z0t
z#Skyollq~t2!hIE58U&G_QvxJdD+$pl5*dGNoj*@1yje8mprGm)y&(V(V{JRc8pb^
zI^TCtoFw-{YV0SS&ORcz<Fvy3@!MywAOHJ5!~fr3C`f{*HBfj}2RQ*gY&Zz?wlfWx
zGK3lSq~MfU%t)PQmg)qtL`w}`e;fD-%IqJ!eU$$U`GbZ08eH174(?kaK}kZP1nacu
zazi<_`Y0Y(<gy7^8CGi4v?`H1I-mvV<>48&7%+CbaGcOC)N!+=&_j?`vUMf;tAP0l
zKE)Kd9Oa<jM^1tQtLPE>0U*RRwlAwQQf;(htEr)b5KI89N7fj`*p_1*ZZv~=|4DfL
zS`Jh<%K{{{<75`ZpZ#=gIdLk|1&WLw(L<DC1$s8LuhjTk<O9}7m1U^ALXiGip(xCc
zRB@#2Q$J;ar&Bf)`H)}!{-4o|{FhuA$d5C+%g;pRWWu$@Mzoj0<iQNc8ze`L%)^T<
z@Ze$bBKIHq;}(6EX3z4Wgns~Wck87}V58~mqZEvX8*QInZB2YP{OA1UCo8m9buDBd
zL!MZG^O9!`=qMrB;`k{@tvF%*6;M}HDf66h@rVM7!Z`x253V859qJ__l)+EduYeFb
zsHvNF<QX1O8%wkqM>i<(F7A0z?d0hc$N5t5V{$C9F)=9v#L@Z95EXc`%s%?s6xwCi
zB&#uIKTyj$FmEUR1}f#XK@VZ#+3v*bpc!M{gqS>9!2`g0kD$#?IJ!izd<@zxWNHJM
z*V<DKuu0J;%J(DRw|()ogQPtwQ2hn?EUeUPjB|E8a)%crj<TYYoyxF{U>7baTLK$I
zB0>zE-Ka|`x3{}aQ@t*f^AF?xE-D6rg2NL!Ud*$kG`pk;NG&hFY(mhW$0ccBbJ-#1
zHJ}53pBM_{Y~28VfD^I<>Tz@()*@z;79zeEzWZHn=Q>L_<uAdAg)!^Jm@Y?oM`MKA
z_s7DL9l<mjNQ6KiilX{Z6S48hz7Zx8Z$JafX$Od`^E<I2iIRYL?*aO>qzKKzemzhm
zXL-kCS*VaeN5&1U)fHJAejO7V74TEFE!#?RGV8%9aTQs7nHE7v$NCqNynHU_%Uu_B
zry5{X&>s)3ViGJN9c@7ak?X(_h`XH~z`A+Yf+##iL|DZ>NcgO^A>d;-xuYb+yQbFm
z|B?14OV%XUdEov&g+pyEg6bx<*I?9p&?H(6ej_4pOcleu8Mz{XrPwlYNA5s?g{ndo
zh@rp&0Tc>mnThx6^Bq6m@%SNO(+!FB-~5Nn7~K6#-;gwmrda}XSL>-2pE1c8Y2r4w
zIx#Y{bMV`|ImO&hgDF8zb?%&Q&!JUamkbczbgEKR=ClrdW^(zUM8-j%%DC8P^^0Nc
z0*PZ;Qxhj!O-p+?)R_~y7@n>w7o{=2dedq13`+A5sDhtg1MfCY-NQ^l4>>I*3s&rm
z{RYG|T{5&79XoZOoT?;+0Ky0xmQuPjg<8&JPqW)26hI%~$cUTzl452VpHEi7K*Cb3
ztS(|p`AEx7e#KvzuKX%JR7^i7f1;9%6~nY!YZsL}m5{S(#I(5{{YX!y>rN@iT8UsO
zeWWJ%s=y>nZ>7L39H0O{#lDboytckLup9ETZQ`SR>X3lD_C8&t6bgL)T!F6(lac?m
z8|8v>*xnGfV?RTYZaR$|>!hshWdho3CPXFYR)69sw@eG0?z)9$XC2by^-|w$PN)5I
zW*NhDNFBk^%>XS^IR_lS40{ys%bmc5C7Q@PHYcRhi0;~H_`R>8vF?=`n@(dE^g(9*
zP**uS1E##K$81Ets_He9Q8{8y#=Q~(3XU9XjwQ!gM<vz9=Z0{tDkmw~?fNzxf;t~1
z_#4Hl(N)a7^|RN1!IS=-Wb282^!A<C-+=x38~y5K$~M&N0WUU}_(UipH*!^R976(u
z6AoEbd7hKR#{}dh*Jp6#iJUX-1$qAqIWENlAfTED866A4aO_adIvD}*+l|m&y<h5-
zC!H7g=4b|g{Fp?ty`@uVPm+gy%m|NNE<mzo1}ZQVBq`f4^rt)h#GAiD>D5~Kb*L%~
z`RE=Z>6T9yaISKMRvj8l(=q||iVBg-0dAWUH}PZKCpc;<Ecs?cGGQ{qXy6*92|)IH
zSASp$eC<r@MfI%uOT1z+*|pjN`V0AAz<=z`YA}u!Po1kmK6m;cqo7WY^QMin2}Q`<
zLC?tuO6{alx_GG#^Rfb5?-8r($KgFeqYorz4={a`h@_fe?BxpEz!!)4N96@HE{nAK
zvM;jzp>hT{XL}?Kc>=GR4vcFl+kxA??vw(7+s5Wlfd^`rteyi&`AQ-jE>WAdw2_CQ
zHP^ZN2H49fZY@WEB{qpBylm5|>jKnvMxAnIw#FEPbDt@P48;N6$*4tcoW7gTF=vW)
zT*|w!;aPm*5eGuGli%TjWusn5TU}}F5f%2(q&A_Z>osJ*(~$!->7t9CCsIExb#icD
z94v0sJc)GA&~L7F@aT1r;`)7T*%nC!j8XvD3hJo_L8q*+Qw-z^?D7;^8$X~{gPyQf
z-7xm;w7j{fW%cC=mpNT+;eiUfU7$vI(gTR$32I4>H!oD(iU-_J!~d-xk!n)BShoJ7
zPyxT(8HUiBe9OyI7<S;oo!~EF13+g<j?N9VQbLWLv;(*<xeb+i^Rys=CL;ZWRaAnS
z->Qe?=vY)xaK2`|zz>y-60ci(wydTq*)3X9EjNNYi@uI0T@ERhCV8G&_jz)sb@1J7
zZ#{=+IiFP-X&UBfb#BNMhT+gW;$%93slNdnB6J1_FW8n2#1%S4^_)X)>}9V-a@f$`
z0d2J~hV03U1;q&eA9&wEPn2C{(<xrkICewMme0fMC(!urGmaVxw;-+P;lFkUjJ&}U
z2oB?xjJ7#}l7~#c^bv$v_PJo7fElOS%#Yy?YYUrT-X*BD?t-=Vr+zq6&J!YOj&Rr^
z39;wI9I`w(6^N0+_{kO>qV%nU7+l8Y-sDQG>#^H6L;r}>2?>-)gVPtK+5q_lfaPlE
z!RUaso!KZdmav<ZtJl{GNoI)wJt0Rq;W;;y7M8tNQl2@z5ZEof{?p~{AJ7B;``4dc
zAm*QrCMoDB{C8w;OMpe`I0%bCuO<MsvgVQYq1!#7MA)=1hA10iq$V2#Jhu}BhBkl@
zTueF7FX-?gA5t_LP3#IXi3?ETP&1M9W=djvX)&VnMyEEcTR2~&jd7K$HAzm$U$OxX
zi-xpn2;9(Waw)CxCGRI3Nr=UHH?yuaXAAT@QSR|M3A<*VHqe&CDLpJ+D40}eT4C`A
zZ~d@Hp>wS0m?$aOW&1ujhLf-f3B9L5nR{uCO|9gx#YzRQE2(hm7j}93(d)m2*Dn;!
zih<+zUVmksd_9Ekq-CNNzjN9ND8osGTOLrOt?#Rf+ZL25QHu$wp%)r?GB4b?zA@#e
z_@NY<J0ox)8&Gjfub-#O`@tD(D+LDA*Fvgpn2r<4D%TxXyWKlTkkbHp8;{%I*Y3S`
z(6At&Zc=zs*@chNBJ5oB_XhORsI7-cm`|lG4~2#AN?*6|`}RYKtb<4D>ZsG`wrcVm
z@!1ZF9sVd#T399H1JRaTx317+A2;N=l;ZHZ?9r{u|Lgbf^Vh%+-1JQ(=~rG<izH!&
zy3zvV|3TP`?0^FAXlCnB(`t5dSQSC3=*4avNfVDFNk`2ka_F4KBX8%Q!|Tr&DcCMh
zHwEr^$w*&dvLUC3?Yf&3)jbb@CpCT<SB_~gO7%k>EIry~O;NTFL@KE$AY1PkF@1&R
z#=zqTnjq7TUMXC@ZT74JSFQpHk}1)Pt0F!)flG2Tb}7gpkqqvo@>G2wwM2=Ow=CBp
z|ECp$I|c!{AX!$Ev1t`$?$p%JIx}*_8Awes*e;a<cDbFsf(3`E1MH%s=p;X_4opbL
zj*a9op3(6b9MHHfX`Xyv&9ddM-5JkS4aO#`l1E<VNyjMA(k16pRn2KRuMCQ1pS{hr
zKn35*q!Oq#c44o8Z~0T*CfNHby{<T@Xum$f<alITgi{ts&`6lBtye+hOx^5GG76o}
zbPR!#P?70$1XohAzRHQgE3vqx-o75;JxPN>y1~toaII_7KZOn)3wOAy$cL-2s3e+M
zZ)TLF`M8|?1-2+>w(Fx$*-?1dqpDciJzxsmu){OYFx;{4*e!cazs%aD&?cC2X5jRW
zwz=mpa(S{4d|0)#6N4o%rO_vhQz?5pZN@najl?SjWyvc8ToGZkpa|0GkWZ3p4|)yH
zDh6Q>5U8|kapIcFw^XV)$9=Ge8^Md94Na%nUIF(V^OY^U)%B3v)i4j{$I@ZRfG(0?
z^%Vdmv{UZQ+>D30A?h1|$0R8OF6ZpYbBRe?5!H`tc&naPQU(4U@}N(H{O3m(?Hv+V
zjcF?zXFE>WCwc-YhccU&B!9!V&%^KkT0x29sC**os#fjjYCit`EI=SWK-Ypq$rb||
zTQ~){Q<w-;QWr?fsg>L?oT%e1(5Oideeq+g0F;*cd>FD6`K-(Wf^z7%2-ThKo}q_?
zd#7+=7!<lcp=2FT>}5@^xDBz9aMD6nKp^q+Qnu&x2c4J5HGh)P`)@XeLq$A2R!8Q8
zT{id-Wc{dz^v2!WaI8j$RmaLb=uq~Beh!ZZC2bUVm|cSuw49z@I^p~+Ucos`%SMq4
z`3O=jMlJwl2Tyfyd}Vo)H4o<sNX%hIi5Gy`hCH(mI0^{Jb7(Q4n=$jWB5$B*0Qy`t
zJF#{aK2YdjdNoheq8J=?5o6jpLi#)7?CS}vwv1PmyHn0%XGKfuCI0@qY$_&3!d;u4
zJSpsdVVZb(<?{AjbFUatL>B3U868C=H(a5|yt65rFmn`$?GeW>Ft;%9)5slGlt{>F
z05xt|5)p{>o~`{A>$|IqbQbKJ1xp7*VySuFd0S)&KOK_)Z4Z)BIyI21FHI}eY3BpZ
zYY)+P2^oBNbL<<r*MAy)g#)_FJzFTQfAS~!`Y|0!-@bU4-0*k$8FD}i)u<2k#Tpcs
zats%YX<#{>+e8%WK?X=*Vwpjn@>+DxIBFp}Oc<JCkO2&VH|NVCJX?+ZL*f-WE$Xv3
zC+5-fGSz$58olXU8!iZt&Vi2BWgp5V4HuTq%_*<DqAaoruY}ZXYNCtK>3HAXJX8jp
z64^IyO{sd#MXgq4>D~|MD{MH?2$%iIS)O4BjsCJ7n8~|f?wy*O6CUZ}$-@HXib>Lw
z(w+);zG}5ru}7WMx#dWb1!Pl#WWz}N?=?@j<Xb{CP`*2k#EfA^M^}PSrgJxt0nrXH
z>p$0FE}e~}>%{VBC9VK|Kt2uz>JOhTNZJeE+I&Ou3cD>&(<8X$ppbG4HVP>0)8x<o
zO|QN|MdhHNC$vDU7B18l&+|#VpSiPsQ}HY(2TcloY*(bc`&eJJttAgQ=@4QSuN2Y^
z4a+dKs@9GtO${LhT#_oM{2V;zLalk9CLa+<X(LB-1E)>7#=C^?gZ}RiciV!Y=aPV~
zj`o1p(wN_2uV$`FRB-we=ID-!mSm}xb3DR!hnYU=uwDmdF-zCV7QjA?*&qT=)V;yT
z253-ugR+k&)Tr#h!J{Fp7MMv&onN=?B0yD|OdwPX7c-8}C-zUn>-V{Sz5rnB$L~M9
zynX!sP5Axa*x4z$c|R4_Bi}P(98+cWy|70xD)E`a8Z>fz28Q7l$@g`wsg&IX`(kxB
zPHTZqP1(sSvy#3TZ*o|}K!mv6hb+d85>}9dju&LM#gU9B_DoWS!RS4B1_>=j*q$@G
zfj}ZJ4IELxW0fu7V56T06K{JQegH}4xD*ex6w#6&T}7^!MCu7Oon<NotIp_YNh0c0
zmWiNm=t|#sfHs{_m5V?R5qrjx5M9=;zbDIR9wF7u=>%$NY^(4p^>If-qNv9)TAq8)
z#Hm~*aWcq(#C@w%0Oyk<ms9J<0waQqQUE`vgDOL#Gb@a@X!RY~tGg*YNSVnX4@qJ$
zWt8i+SKDRIrbY=c%9|XOS4o6X=bC2_8Xi^H)}JI~*Dv+qbWk~5qIRO#=7{KE>Yye)
zqwsRbT00O`Yn>Y9mC>uQ=0#DG>6NJlF)>hze7%x|*M!w*M18EA+?$Ux)-F}P)u&5|
zSUA5dcD(?DkwSH`@}PLM6ZBc0UHS+djgTi_ll#`Mvm|{4xIjhCS|Z@WRLBA45rlN^
z@YtE#Q0KX(fo}k)o;algbsAyW_**zO4}bhMs6HF>b@hM9iWctVk&HZ?rU>%DvIA7O
zuWs7(I~*rphu6=LJACv0BPYY>FYF!(LWdA9KNTv`XOZb~*2U_Ec`;+}#AZe2b)_&v
z3<hhd<>A~;_8g^8DvIkBN)Jxp`MdD`GtK;zT8b)v({U@>G+B7G1N2@NTfsB>?71<3
zHoennE!_9mZ=4S<w1KO;b&Lm|6!|K3RMuL}2-X3437)=wDK$(er81p~;TSadrXNz#
zu05$qCSP@W$i!XpdFwxntwK922Sq!q;Dbf~aPSdaRiVR$KHu9v0%r-gkf`+c2^<Jp
zN~lbDo0N8sa2B7P9#OXohZEHS{*#=0lIOBAMB-$FFH6jRLHCtk@YnRG-+%v6u+Qkg
z$U9;0ahtY8<#JIE$W7Ql6czS5a4J*Ba5E-mjlrb*rf~9vGba+MegGM!)TZ=vphy4&
zPqCus3;Stxr=V#Pyh3l9IQA3t+c7bitkW<`2$NU#97tM~os=qz8-SD(56vSGnSrpe
zApI`x*-f<SlB*rD+&U#LD(Z&6edqPl^Z$iE{0()Z;T#0%^8|rPyL=W$vx;n8ojeBA
zWThC`sFQ0d;<$O~O+BSdg9d_;n-c77bv8SO>T)`G?rMi%q++=ok_}Oyh4#?w@I!AL
zRn%Yy9U7sQY({H6HQ-!9?R;UBhc|@O%xThZZ+*=A_VC0;lS5g+j2%YMshA{<+S*GO
z*Tbujnrc$Bp`<hHW=dLLzX|+6D%$VAn~r%%mZ*kSN7k)EnIE(qlNEP`Nb}lunHi6E
zEonVr01bqQ3g|K#0;83~BXe+{b!<c+N*R_ehy4S<pbU3dy6GGybs&ns%&=R?gS!=8
zw!Zx>)H_yWva08aBzIT`=yhc@wxlf92*e#P#tUsH_cT4BXiE%yklR1Y$$fd2OE*1+
z2WF>?K7%ajv_BfPcW{C+v_)($OTOlK)*a(`Y&nwH6{-o^Z&tfk1)~686rYQ(H?>*R
z_ICOWxOM00Lhm`2>a$Ix0ijV0@Ms*S+#IZr5$-!lPmMYqkT@`8{r`OZipGg>Q2gfY
z@817OvnV*T*n&q=w{ZTHeu`yvuv9VuxfY2~B2rHW1c2!q{{#Kw7ZYaN_I0KGkes~E
zFI}NZF>rhUM%Ok;rVzE^KpbeXDZ|t%xi}{BkL33a<q}%W$2#u@p;VVh=>2o4DmSJ6
z`%Jy$@Kdk%E67P(F`j?-pXCABuLMD+$t)(scZ-Z_^l1A9K<t|;e_B2?Et+$sw>F^}
zVl;Qji)tyHZAMX}tLm##)e!wTexYIv@BjM0{x|%wKhVs<m?Us^9GxkmniZ412FMrK
zFb&9wha=Z+1+4)Rj#)BEGAs-DXq^>gBIFz~BfyZ<jI1HSS-Bp0311nT3XQ0O7^EO1
zAXV_c3IFA<{wh6IoawqpE|{bcM(1AZD#MqOuB^1wIo42B?Du3rveD@j={>y*m3Du+
z_!50b`n||%XVvoXz@ic|*~?&cp-;*6AbkSiJBjKIqYI@A<1&?Qiv9M<>%YAIOL+U?
z`_Ckwo1rIj&~ZieB+~|qO=|D6(Q@OoK*xMghE6}a!JvW*-3_XMqlBBfm5FLty-<~3
z)!5S;RGZC94P;@4n!SB4N$*#0pF{NHH)!Omw0%zdC&~2@bYV;~OsBl&F!K+NDsw=8
zQAnVi%m-%Cxq+4G-$YJFt#o0xBr!z0{*vjnA4$~fh-E9gsGNItTOuo|1Px^ZuN&CH
zog~G-AgfJ^V%GF`t%a(~J=BIKoEO(X0Q&{3U?>7dNLKAc+0`f}AqIT{xl1|>g<CsL
zv{&dTc>v<9;iHrmiE|0FvRq)bl^!7aGnW=t;!;b=awqOL4keh@*1rRtkG;GpS=h9w
zj%{w06n<ZSL&p8bDcC3Zv4b53%w`O0v4`7D{Tm=e%WNiA+5xiQAxQ}Z5!t70v%j_l
zLHYM~KEncg$^(5|p==B2cvU>r6HX249k++AAHeNU50ozWDEVJsWF@as|JgK9#Q5`I
zAAZDF|68|&IfXMuGlaF@%7-7zum57F_NFIC&+VL&^}3@i+&U`^&@I3qKtS2m6=TDe
z2rgns#vSyWMdjixhc4Bdw8ZJwLt_2?=NI|08jB6g7_M2a(Mly&n&=w16P~<hms))3
z2)dPRaXyj|GJX86;+~WekUNp@U{Ma^Kx=U*I+3|UFg1JCt-PKJ8O%_vxUSKopIp>W
z_Ro-}l?I5nW5T%1&XQfj-P+`m!8O@Ro&IfT$51kO$K1Ek-ZeW{oYZPNW!BANDjMiY
zSvWbelg?N#;YG?q6(dYnq^>`Hib1;FG0@AZvZbltWA9QPUMXpl3q#>t9|1Cbi9JOe
z6UPu>PM1@tW1ktVIy3_aw2V+2x=Kj3U{@(@5uG?IFC1+>?t>zstzw7lZG!96Ns!UY
zkqX3u@dC@UjVayLWovbH1AMtyvkpT4oOy=4M4)z`bf;}Y-=Y`H@H2OlH+2Nxdyiuk
zTDgAs4RiL9uR>YsduiIsf42Vxez^SkAN();;cr|Fw<c9B#-F*lw^q|hwSR?(?{wl#
zN$mgV(%&t<cTl5PPr_nRb^y7pyIYbkV3l2JiE(oJVxl>yS%T@^ma6_KK}?J7OoV9N
z2<00f2lbZ=M1F`)ZMC1y>1B9Qq|pS+Iq=vBl3ex%qwDTPYD4;$*3Lfyi$qd%iRx3+
zGS>CQO8^Hf{ru0~KU2Y0SU&g6I}xx=`eQZD);gk<+fMP+%g1hCxcugp+{|ImLWocM
zP=aX07_V{zPK}VV2E{bc(t!#CQe`-nQI@om(Kero7GcUNX%x%t5N@mkJ+)z_(<izJ
zL`d<X%A!?(S6cD+uG9q7HNAA~yy754X-B!q4mzs@F0;XSg$)Npu}i0}sh)v-uWyI{
zmVQL)XUn(TRPD(EQXkJFCa3_x6RiN0KS|tf%)X%EVn#>F$xJPok|3Tp8~uy(=M=qN
z7z?9Oi9po?Cie<_x+%AlP@mEZ;P*K)R_%OC<fp|U=g>^3;3$58{*m@K#A$a@f7>om
z&(ar#=X7nDhf7p-L_6*b70{o(UJ-b_V8dA)q3zIN^qOwuz=G?XF9|1{Wz6}tJ>Wad
zwbNsi3OL0@V9QtPnpEmRlTG|!mkfzys#@b@<q=Cf=i86rf*szzcy&>Sj$V)obuEd8
z0BEAha>jP{-8%g{_AsB6fX(@dT08J(ODbp0nv{-)*RK`u`T9e}+$1khmJ{+8fn0Vy
zY00dplZ&Z<HRUD%?Hk$TgRDn`XRSOuP)gI_FlXNwLKccGb6AQBIiVlB9T4q-4p{m@
zhf9Njs$gklxz|v7Np}TP&F0kU!!BJZc=F?L67u=}SxXk;(sbz4IbC;+pzuRvZ@?jW
zy~br@B?EFYW@%hdG?0Azad`h45L9#wW%a`SOh>9$A|atY^EGCe>g<%H*`N>WhHocm
zXaL8UkJY(316>|#WKECBy<ceSux`tTwq%AQ`H=%kF0whnF^Z5nR=u7)CsPBby{CVI
z?MLnZ6tx32K(RBXY*(q75@%?=i|#hEqb#9lD$cWI1F`N_NAPVor=16>Vffy(|JyXF
zWU?`-Y3<q5u;XdZa}M~_NeV*vfnjQBG97i}RbS!|F|P>;-et#AqbMblur!?#`LUZy
zcRFYsV<zjWweT+YKH0UvvbSd@Nh%K^wYyuB@zm+$DJSRL6`argW%$;AO^+kC?AO7&
zA@&(7yG4~}?C3=jA4!#XfHZ9kPPznxb5DS&%}y3M-&JMW6F}_;K;8(7Dey&Hp?If@
z6Z)Xh^jRmR6C9RTk7Xe@vazWlNkc2wFrd$EZywE2pjQ3pS8sXC%AxKORj$1PM=5Ft
zt=L+^aiG0w^C7f@DvJ&#iSFF5(p_o`QVOoXND;QPXL5E`oUE8iXx9{r3;!VprmsN5
z7E6+OkqCAQ-ILoSyacLSjnn204o&9h$0g-9bl21N2{ZZNVYc~JlxGd2!F@dG2FNuo
z=!Dpzoap($A;-<p;w*Ae5?d<?wLg>MA<Eq?-Ag)-pQKRVq4Bj;mi+=-aiaYJ{dq_!
z1GvDo_fRfZw?w#%RE~fvk$9)8d~|AunyL>_p?o|z%Z2ovysTQ^m8}<bGI2ptNo)4e
zq&QV4qK_T9RjM`COQE2cs;k<G+T#Z_2+42yIY~K<#uRNBYxXU{6ax%1xbY~OukdQi
zI}b`&U^A}Ky@hdbKx#oxC@}v4_%LFGZVl`VpD6#uhqiR{NeE!YyO5L?W%mNH&^fc%
z;Z_7|RotW8KjBylr2~3h6so7Soz@S4PVz6xR{v(_k(^Rw5oTB?D)}Sa4udTsJx)KR
zgF(3@iZ}Kjdo5z2^Z)*<vppg7qaGi;>GYye5)Sw&cAxP8sBzITGj(>y^x-4uW=h77
z*HGF#1yszDw_`*T2<upcgT=1%B_UhLdO@CGViEEYLbBXA3mObnd=uC^git8@+isjz
z?M+WS`82*>14NOnK0c`z0H35nQ!uXL7ARKKVl#Wg*qw!Yysv5uu<{Klm#1-Pd9qGO
z$3FygIV`RwN7xt2(S)KEcq|Z|1CUOIs$8c^ZK*ot^{NUvj)aV~PvyI@<)zlQK3M1m
z;8$)P`IU2z)0>F5{Uoz}k4mAn4wL)|ej-d_peE4`UXcT_YELz}Xz(i-AP=Bq-MX@{
zReVGLjia}2ULRmIBp8ikue%>V>VtKu4%FfbV)wIpEJ|0y`X|DwbQ3!@a($@I2Ad}n
z`i!m;3YmG?Ne4PfgaBDUroR)6Xg!fbdXwZgE5OOak_h<rz1N?H_g~s`hnSHiM8%w#
z^7fUoOf%3@ULu2)9iHkuP)M|NlCqq?uG0d@HfGl}4+hofmX2jd#4LNF8rcg3Vu50H
z0ARR}y8N}lMpmvwTs#F=s7L<VfwP_Qq<w-1rZA22q0W>FclM~0qy^yEI>u0Kz83{4
zOKMeAl7Z&5=_v48TAu$l|LCLoiuRbIM3Ns%e23d~OU~*i+&NJPP*sQt9ZLgY5LGhj
z@M%|at$d_od~m-*NnFwCk)luauumCV)p~7ILW6lN52bnL)a^x<L!@S{s(WzM?`hX6
zJFlo!U$5@m6Rfjcm-t@HD=~m?cG<0Jrn?eH57L4$<do57!40>|QwJar*S>?N4_f)~
zMwqENcEyqX(&1GsJg|*F?OX=c5eFt}guZ3r%yfC`V8|E`1?8BnYLwU1G7R&4QWauR
zdX<~OaTE!xsSlRx7^YgN1Tcb)5HJ)CC@y>J7vc3A3o5QOJ40R;JX&V>Sg(MGtT48A
ztjkbo0@of{WXjZO3OSxzM_9+j)x3%wp!MVOjNz;u63}LY6AsSmw(t%k50PO9pvz_`
z@By=d)&b*S7WqkWB@e=I0Q+eQ27IT&ncgG-^CLYzc9T@b9sQT0p;=qKBc$1@d&bbw
z=@km#vnAE+@IJOzSF2&0bNeJNe?Xt_qnujqaFyi5(s2X3&~+v0cnfaVp5cTbadgzN
ziR0ZTGf0x)YSuf;LN#eAGNU~Niss4(QiVSyRrpi>nh*E)FBp4h^oY%;Vu@;b4Va*c
z2?8Jl;LS^?Cb+Z+X^Zs#LW>O5)+!vPS4(tOY`T|&E8a4XMTOy+wygJLtQ(Vg8Jij-
zG^&W~0*Sog7m`f5ut*v)$pbg*?poC--#!NM;7gckIq_rNQ^8K~=@bap!9Ck}VL?rX
z5^b><C@ViL6V-AgaBc^H5>#Vo&%IbQMiVh)VWmC^8KiTvxJzzh1?*VgC9S#H;e%W=
zeMHi&xi`Z@2AfKPlu+5WDrybKd9HwI-zZ1#0PW9{S!~2XPg*UA|0m_?UxnZQ^*QmZ
z-IpZw)?If`R>LqmEpRL{MG&-CtNyxRPHHV^e@MQY{VC807)?2;nQfMy<qC>Na9`>s
zFU!~8>bRCF6LP+}$o{w{6>Mfr9nf%`dajUt;>9T@hH8PB<#s;5>6UQ6piM`7W60dx
zIzr~vXI1EN)B2}?$v{4_3qBn=QfN}VgJ#;fA2{%KsOB%YN?DgzPl<Hi23#|n0Z78w
z8k8!fJ*?gH0)A|7dDlbYkLTih57jyQLN3Q0U{Ng;8OsPy28spV10=p6mIWj1^oeh%
zTDqY-u_@{%5JB73u3#rG=3n1`6w)tfX#kBvF-hq3y8Gl#C~OUq7vNP6$?YaZVDL?;
z&q2EMgBqO(L>*MXOeS$x^&>)@)bVmpbyR2nqRGBjQ8l*g)ZAeQ!&V3o&Vx4}f|S`s
z18e#N6#pq@arX$@ESkVV4a~mnJ{V_N)hx2Ig480UxPt(S7XIw?^QmO3ygzHtcCLlh
zD62YM_XZlIb|TrO(!<C%bk_FA#TyhGiv5HHZK<6DU@=B7u9%JMTBzTrJ~A|}IWRk)
zz14#Z1N<v{A&*C7qlf)4fYS+KrC=Xg>l6kh(EyA4ii*NvIS?y<;bo$tjrE}d0Ur*O
zQR_20fRM@4LVieVoemW#Mg9=o?Npob14M>mAa0n6our_km&kLW-Y8m|l1xvOHkHR|
z5o7@O@`G?*R1m?G-==R9Ky5_N!hwQ00x*(XD-#Z0iCf4<^q1kd+(K<t;*F`OT6NF}
zr*LiCm>gZ}E8T1tS$n9ks0uWwP-*V+=%l5CRvxYC`WzpOdw01j?@e+ssdPu{|BpDY
zhlH^V++UKp4yQT`Af-`)p0`p|1iruEdNP$@iwczXEF1!H_F$fUR*$X#F>rBXYBS)Z
zo=IGRKZfO`O<a%(NCk*VH0u>xV3^<FbiA4xM0ouohquoRk@p#YcZY$GRQHXYco_MY
z#nZ$c?30y*VbCN<ZfM(?ZB1(3I#nR8t!c9)Frl2Ck-D_kZh?ZtS>;61C;JW(+&+H&
z8vhM)cFGYd7iV%}J4Vp?Q6|iGBdc_Gn*o#FPmlD*MXpJM{8Y<QwBliqyQ$#&h+u=%
zkp^kVBV`dQ!jJ11x&Y8KVsHVWd|-r&$UZ8k7>>|GAa44qOv(oIQG%(jDlRC6Hs;8y
zb&Jxpp+hhLYYmf_f5iCmo)4~2M)&9J<B|P&&;-i!sT)LK-8W6W3p>lEKrDlzeA*Hu
zFqP`?R1Ce^h1vKXO!YA>m0tz}YpUkY`@dRvRWi88wrPahbc7fwHeTmrk)92>D=9YM
zlVNbo;1{80+o7<fZ9-S(%~?D_fI5AwF)p;*{LAnyn??|=W{JFA;3Etpwo~Ek4xovQ
z9@DK;bBx`&DI@RN7RI)+S<+6xS<l@<$yD&rBoElMm7eL{;VK9DK#^B~dS%65wS!m|
z9QDcFU9=g#TaZYXMSy5hh_BeheL@q$3|BT=%N=?Mvy*&VNf;n-%u@;SzsjpDR1Duv
zDoNLh%6a<5;A#t-vrEwxW`P4$ZSQUtN^OzT9Yv1i@rqDqJ0I<)bZxgBaGxTmd-e!B
zwV42*Q#Nd`(Pw0osds2vkg8m$IW$f1p#9@!d^+%O`ypI-$GZS9=|BUy4rQOY!ScOI
zu+=D_j13AQK|6&=34>ZpP}88hDvndh78<YFTf1pl&S83C5obSP!m7Q_86aG|ZxP1I
zC@84=beHGGiR_$gN#V|F0a!5wX<I(o2=c0KNN!}R`X4M*Fn6>_)9Bc4fZ{IBBufi0
zR(6qpcd(NqyOpigWlnc0XJrc#uPCqCA0Z0=M`0)D4U%_s{84kYs6A3JjCNmBf1-$_
z^v*CQ*H&e2pWY?yv_y8ohS*03#e5Wor`D8DQ~^CjU(9<6YaFH(cmfu{12f1zcc^aD
zTA}DN@eY{Am}U^kG|1owt-?$_RV(y>|E7qF$$4lfcL2zog38?FMKWb5B+%ariN(HT
z6rsEuEB>L;5A|aAKIYH`(AAXcraM;-n1oN{H!lWZ242k+!sLDJmz$(3Rti=M?*xg!
z#h(5LRRng$+pZ5=-V@9N&@^eI%PWIaEjg<(mXHI&uZ$CFcO69VyP;Qq!Zab3lS-&B
z=B_@~K?TJSljd?BS|x%I{LEOre(&{5Duiy6`Zp_(l&2GJDQ0~;)#y|6o$97kjp+&k
zRjnd2K88@-G(4giPjEYDqp;mxM-y`br^wQ2zdW!#cs+n6P=Q{}V7nLffwiVSMu{CC
zqU7XmhSoVkA6wr3dXv;kMoyOFkc<?xUH+^p?Cr6&^7@N<$w<898z5IURC07K(*f%$
zZ0&)4bEH%$M!)@ic>O*)!u8}mKbXVi1vlq`5H!sVhYFKj+fu~~!?OfA80%uLqRKm9
z5abkBvZBZ66D0%`+YhNB@rfKI1(fO6?Scuq93Gf?D0;F{qX*lbz10&<MLmOrME;VH
z<S%U@Ob=Cx;u!{@KwT`3;glCJ+H7fvkFY%mMHzvy1zYK9uQ4NgQc+fWBWNF1(~@nk
zi+yXo&xtOM+o9LVO|F{ml4qGRIyCnwrwJ67Jx<9H5D71Gt9lkY%Cms>Ly_G@<Tqjk
z*sBk(5;f)h2f;oh5$wkrO!QQzgk)h4fj0~h5`gt??4=>IGp7I;=veL2LaoiQGid}#
z)Xc40Ir7AoLT_3n99|}gFD^Ivf*EDHlD))y1O4gSW!}+k>s&S+1K22KoNUn|+hfW(
zDKR~hdSKp#qVx1XS|4EO^u_SEk~I;bsLxNAxcY?+l%3yo1}(+3wM^yVFl@qNLQ>ZX
zN;u`l-M?-Q=|W8;NfNR%d)aOBM5Y}EPJ)uGffF`&47PBvZ17`V9Jn@3mp>1GnJ#})
z%rLOGc003_g6b#8%5O~im-OC2RAgd5s%mw5u2eZwm5Km?I3-Tn2^OEjNoM{h;r(-9
z^S*-N((6CIe-j|$1`RjZVm5?<sQ8bB_&R&;sSEhXb3#2%<<No$?FVX<&`Gb=$tX8R
zZV}`#+uOy`uM*N*=6zjoUYo4p)l;au0XpT}-ajBfh2A|yAYx%BajB_7ayExH|7=qm
zG|AW<glo^n!_l?7U+_vB<r{2{3s`Iu!SMB(MIq-tqqS$X`xw-NmGi<7rC2O(P}i+t
z#<x>-r(K}7tY%F>b+PSwQf`pC4h7}f-GDi|5h@qhPlad9u7)9a`!D8SP-06{Ou!uV
zvc22UTl+I>;>mtcF;8U9Jk#WTxSBxMfb+W|`pl%%bvWdeW7h8_*W55Iq&xMyc03*G
z+-H4i^vFB`X_Q{VK-WVe+}`AVcEPDsRGUqcO3MEAw2NqT8U73JN0Q{aI1mf$$n9&b
z#1(E6N%VyfmU}A#@kC)Sj7U1HOTg+>!N!&#PznT~Uil)Ts!`OP`EL-8MQE$a$S5@e
zN>+KkbX=b0Km<9EsNpM$Evf)@ZU-m7i2!R2+C-XX5WNA^kTG=a#Ec8j@<>$i7<k@;
z2_1U)Gs#)ixOJH%%S)&1D!KDMsx&uhUUph`RnShCuI&^m*?k5PRUkLe@Rb}1wrCkd
zFoHQX=5Yr@%~Y!Hw|*Yuqs{XKiGwexgQ3!yXrJ}Kli<QE&nbY)upa8vV-L`OTJ?rF
zJeEp*JG;J{P()8(-lCEFXTj2q)w*V<ou;+aPLjo&tfiR^Cxww45n1wew=*x0uUfJo
zN9nHvgk;-zEHSy4<Y7roiE8j9?53*}cG@_oLiz#I5gtWlXwz-Kc-QaQ$u&n0MSI|F
zJ7`6)^Et>tHrAwyVM1n~kVsw{l??S>ge6L)uQz4(Q8*ZmJ>jF>5SlyM73OyAt}ob9
zGZNcdCP86*5bslu&b*8L-a^&eh18*mavstb9qB_=EKXeLs8Rg(MUbTckym+dK6aT@
z$7ht2M6Pw(Q^NBU+EQyUHHHLMo)r53GyFw9CVov0+pjHUS}=1pz38J->E`rAMyZ62
zBqnLvoNny)&{E4Q!j+LqeUBepJy`Pws#eA!<w>Lf-}Ge{YA+|@Cru1IG(&BeB{90;
zJbD&X!#kaeFcwCJNJ)lavksCv3|L0+1ROPmv$bDX0+KGfgmz(f=orBEMOFxPbKtUN
zDHe)7tvZfXO{x^cXp3A{C@QC95mQ69xg(u?(~Twt*SahDeSzu|A#l@dI}7k$iBd|R
zmC#sC%yHB~#dR`2e*G-zWWpBkV<dRKY1jUAG)rEgTFN>qC<{wmF+WVV4;GT4QjP|y
zyO*}=>0yIPbxZn@bSp`saTZapVKd&I%ZS{e5o2eg9GO5mZ>~Vq%58&%x!P22Z<GqU
zveOV+r}khT;KCRMTsVNSJJd!EQ17dWA=Gze#a6nraX!ltP6nQmz97FtI>68PYxu+8
z(0`yKr|`jGXzMmr=uN)qh(uDO+u{#OY_aJ{(wUUidqq#xq)<;4$ycye{QmpbuZiIC
z;+i1O@ZTLh5xJ{tkcR3!*ay=GCImY%2<wN&#`43PhB0YA_-<FH%piM~1PTHZ%B`L~
z!%@NDL@v$9jwKA%L5<Ily`)}OGT>o<4eGv6>doXV9mydO{?k9!xgK3bKptglPt(^I
zLL{d>L#;<35KOBhJlh*qlX&RxRTj_yg-&HDs#1C7diS(qYvRe!TM0MrcL1jz>u4v7
zo;_iid+$=B`|7#b;2y$HcmZo_dGaS=Am62)MAuLBk_Cm2#(g!nhr|#cb49g@wruBy
z$4{u=&4>L*vYk@-FbgItRJfq$mM(M;I~7G*D;6Lh;Euztx{dmpKqTmf@i0@McW$?<
z=`EYcn7%hB6o+<^BjUPT#pOSSWN`P;j!!zY_Bn7aJ!NITDwGfERR-Fn0KDr{b-*%`
zZd*S4bnL-07$6D|7}d761-^4LS)wN#FBWck_g_uJu#==swM)FE%XY8DdQRP*08Aw0
zAheQ=%AHy<R7ja@h5927C8k4ip*6AkdiU`xKZhRK?m#Kvy#iap$r9nzNbfHY0<%-F
zgTxw0Ese!7Fe56de_aI79GBB!$Pbc%$y;Vky&xDR{eNT$7Trqk4ok|8U{>2{6kb0$
zZHlu-!Ovg6@;?dhKeh7*1$9L$E2XDeta%t7a;QMpu$r*Lwj$(gbaJ#c5*_DqxMY8^
zt7cIi?V!HnJH1Oy1x5k+q-yKneaG4LKx7wV$lcMmv_;F_&nw_YHYxF~9Sp#Qb*Z`}
z_m}s*0tgP3IgJ^Du#qXcsSmXpToy}4J4g}OI*xQe#Vt93jc@kQ?)GG!;-#srvr^-z
z+F9aC@NiZej40J{DgUV)351vzZa#SIfynNFHg%gEn4roZ)fqCiH9L6Hz>6xCFf8q1
zw*i4jIzfRegxb~e6-gzzmp9qAheoBL#K!KYEjzK6veAn}9-4&-2s$jW>bsffj}Gm4
zumj+Fn4bT}L$Fp{jzrD77L`rBJkCP?@H&^rjU#U*3SCa=t7pCF>H;ReO!n+s)flxU
z(1GE#GI6uio|4fMOpefcLi<RvOZho%S2<Zs_Vjdl`&+0G{jGNE)QLbjIr1FWWDn17
zz=+OgdLFwSDI@v~&Ps>R`823F3mRoNcs4^?%~od*t<VL{3$TeKd7zS3Qe90~bdQWk
zZ-4*#>tqtMmkQ%!C+r9mK^Z!gIL_j@U7-6_v8l6Ywniu<bYQH&_KaE$r(63^;m`i;
z&(hB{jY4awc7XEEQP#$UR-a)T0r3sK$u-nhkf4&2ooq^UKqkI@b!Zr=V6Uc=V8&Xa
zV~*$~43(V<4yH>4MNYOi#mN45l+S-UQ$AIk^yeuE?VFk^q}P<?F92UJlE|2P-cA)M
z+b_tIEZN1NfiRx}bQ$2<3~2~910Y^6vVbR!7xqB*J<P2jz`t;q`yATBdM$T3oiufk
zod=->qPtP%FKUFOof=zjPiV^DkTLPR8>M=5G;_JY=@V0HN>=po26Q)1Vp4KAK7e9O
zmU&t>75XOd3kvDS<y%aizF~y;=JiwSEvXN;B(D+$tiDe2Bdc~frSfcdm=joAm`z_a
zjBn=fMIiCdUcdPxZ*ZLh7iE7wB5s(Su@kjGl-;`U*p>A(pTySzBygKzfQ;k-Fjd9x
zhS#6UT0SOZ+ga#Db8k~3E{-+8A=>TVA!T~1_$NK8XkxQ75w60+TIRi?V$$a_u)cwA
z35s4&AF2~L<vQi?rCsD3UAi!VnRu$quKO<)5+*W)J2=R%DU!4lr-%w%>s9BL!>G1!
z<M_8vU%v|PUw|0?{;SKrsTm88m*DcEfl9WN(^I0v*hmi6cMint)MyZ4=cx3h`NOKh
z-BJ_K+r0$Xq+XqAvw^h7<w94eYFZAWKq70r%@S0!waFIatT<+N(X#E8gk(2|Ts%!h
z-`<LatC#!9@jPJcX~P-}$4NR=#-PoTF*8_I*NYQ>m9*Veh=L7w&>6DqxUD#lvR7-;
zAP1Z;4^8<(>y0}UNt{|gVupXJ>0`QAVAWi#ipa!Ubi91m!+D}+qovkXpv_h**&q%#
zfmkTW3UIVkt8O2&!@AmF^btO(gATeTZp3UqGG3J?N=#Ct0&_mo2GMPh)QQ1ZtzNg>
zseb)L$@Gd<`xLO5I~y`<4gX*^OXW0`Dgq|#a;ix901w)Z>5jT3F`Hdhdv>>yLI+!3
zLfx}07d%qyS?{&qg)Fn+;xvndo-lf<xyTxWl=DV~r7#SRp4XerUsxX>ndPH+k$SeQ
z+{P+h44o~${q6AWZ-bi$kZ*R*-Do`rKN~_kC-3#)@lZ3hTI3*5$3`Mk0cMyU(fcXW
z&ce{panSknsRFw?-V{b#xz1ACz)@V?Z*4hQOHatuOO(ntbOUYxD$TP$20Ti>8}|L1
zHpqr49^S*lPlv3DtLi2Vd6lw$mbwqRVsUoOmek{6mR2cw1thxyGeBbP+Q3$A8iM@(
zZ;bQ$A8dcOM;M=NedA_L`=tms$M!_bRv2P>^z`g;R-o-lIb3YAiI>~CQ={@rAdGo6
z0jPF$!vQ|JAUf(fOD$kbq1|A0_mKTGhsHD3P91kUhPG{VV0fdnessRzP+uv>o;ZK6
zh84@LYM&4`7(q?m8J-8JXCK}65*PPc8TMpWN%eKf4Yo&mMvy*Bi}62%|HP-p@FJ@g
z5_FOJ0P;j^kzEgt%T%91YMF|<->qUQqxW~C?TQ!7y;dHOz&gjiBFXF_sr>_^A>(#!
z2%UAGn<P4RrS<OU`OXSk-0YTthS6o-%f15y_3CVUsOuwdOZPF*DR1b^G{+N;(ROBg
z?6>e#@D|Y>ly_o+1Zr8VaG4jTnjh+U{^Io~wiq#aAkzm=5<ac_;;2AvG7UcT#~R5(
z-&(*~0DA!s7mA6$a`ibihx->PqG43gPh;)23h0@p#RR<6c9|-^wh?Izr!fzJ+)GX>
zfOo&bx?X}j(1y1FHCMve>Uht&LWP`VmVfQq3vy?Ygq9Oe*Fx$KsX3)|EZ~z|wH5as
zO<(^}{rx^huK6o`brkM&1I(2hDrr%El|{X5y`p+KQ&qN(ic~V}gx$bz|9d09w;zEP
z45K#CxHlpMH*M0W6bA>+3mmMtaz+a5gJL?Nc~AJ!2s@_L<i8_`u3+mq4F{njYP(-D
zD(Y$hsYxwf=;@O6Q9O6vO;LGfE9i_1zYx59Yq8U_h=zx&=}x>7JZzZYEAf*u_sTxK
zCyl;qbh=JA0{Tbd7}=v$T-{4g9?kvqV8i>bF<-v>mRne(F0pY6=nQc^$wY6gT)eAy
zLt|M#0e}<9iMm#S7J@+%=7p_22%(&&-oJkT4aZrj)hl_$_aRxoO>)5QJmHH(knJJS
zZ*K^IkmZ88ez$?VE_VyPBW5aBq;+WleH*gjzc8=}%5nQ}xld4v>#kdyBsbEtQt1!5
zQ?95M0#M+muIug=MhHMh;fd{Z4X|#{2G|cdoD0I_yg$`r{6Sy^o=QMm%3|5gRLf)D
z71fsxjULA%<E@GRK@x+kC896Tf5@ubrS|lV8tlyAgfoL0Fksq6f6tAoRdsQ_g*Ew)
zWJ{MPbWwv`CK1V+Y)a{z&Ug|vwKZMT$fdCs;n^&)dQ~Zgwuw}mz>vb~E33ftd%QB`
zm&zf~T@g3rR<fvjSJ^%Gh10hSDK;ZN74vDGeF=l4^udNmYDQq$@jfnHQgyX=zQ;9l
z5m$)p)2R@RXe_)*eTFZ$f;9L}>LIuc5!BNFMdP{16}l?+DMoz)SE(!b1Hp%o<$a0G
z$p)oHZY3G;ZilVpPb#Jj--H{Bk9!hnv_nYN?oEy#NZA*I3A<r(LEj??eNK=XUEQx^
zaGj8j$uNAjJZ;0f;mouocWy)XXyf#TCZ_2H;}A%viL8sTR^Z{<35&by3J}MEVq}hl
zhNCZNO>w(soGkT74u1QXHO@<Uw@#*d`{ezn@N+n(a5Gfbk%mAIIkD=qD8r)qY$+VH
zvd6$PU?XJ-kF?C>o%j(pWUCUih#QD%K(8ILO6djl0d77kV5^pcfOdF8*YA_Je|Y~P
zI)7hi#h_6MX6@|1$&t&|h1caJ<5HXiSHLu?c$$xs{K={*zdR&IsnF!;m*`LQ>X7Sp
zZZJrmc4fzYw5ykfB>*_ox|IX@HS>|zh$Ok-%wq<3n_wd>CMZO(2lvQIS_dZ?n3Z>&
zHUW-knY5(*C)tt*QpV7d_>2hdE*?Yjo1_Znj+ItL49H-SG)7q4E$&-|85jag>0bt>
z$&xmLJ0S-SCmE5Wp5o;t<5`)*d<}fay7^S>a00fhL0L%>^qzOA(J}U6`M%_KP4ftc
z?e!}WZs42%iOE?O_SK@G_0->dbP6O{{bex&+e)>?==i|kqfL(mu#Ju3m43fxb_l{1
z<yf6a(2e&3ed=VK%=sIHF3<#mto71iY<W$&s=bl@2C2ogC7y#*4@h&pqV;A<ijv**
z*0r^cvx}`4Y^|Z1cO8q8C(i+HM~ZVvTEz!YD@<?!E3&9lIrz9e7HB{cKekpaRx6D`
z0e(@yN;JUmesZ-#{Q(#Xwgc7H+d#_+*v0IaaoRPgk|A}<HoV8FhKjvEBlKjbfrnlk
zTX8|98vhyi4r<PJCp)xMRMG~apHv*pLWmNCD_~3tjmfIxYnS>TL+b87;90R%a=4)|
zqR@`I<k~U8MiX3)A)1)IrDIJ(bj&{7l|~6a%)w}#E|2UjxuO|+MFuz&_i!cxY+bUN
z;;I6AuLQ|$i6_zylwd>MMy3o4x*jf<jY0Hw055oVJ(=k#c@fK&n;!JUMF-0hfLoUV
zcoCiI9&_{RgT&HtQpu?E?K|Q1OWSolcjOK;0m|Kj3Fp(y*{5$~3{Uiwg@|v8ZE&;g
z3mtTmL(is$QkdnWy-dI&+Bytt9)wAu!4o=}K0X7PW2}I`qi5he!2k=m9Ll~lqjpc>
z)a7(wxuTAr%4xbeHL{dPXMi}>RML;np(pZi(H`apUX-%53;_f?6qr{wk%zVhIg)Rc
zN)UYhkF*16g%k_`3~nlD%M8}7ev0+1D=CkXBkvN+-QLxwd}*IvlC8?5rs5I>d)L%9
z2lzZ7gse|GXJ)iQ($j*%j<0;ce%LdXm>>7--KIS2RaG^#X2wXR*yZwF!o3C)vM(;M
zX`P@<VW}5R1qthK|2^0e^8h?&TS_<Pdiz+aeJMk>JnNCgzh|~u8+Ta^E^wRR2oChM
zM0#4Gxid>*B$=Q!+B7kcm)TwhHVP#~2Iw6}RY)f&w@bpOZQ;D8riHg@Q77n_OC5u!
zkf$;5BAEstEsThzz2Dz|2i5*pREkm38w5g$1DCw=*<Tk>;ImXVJ%--<hKQ{qxof<9
zq~qjO?sr!~;FaK^u6II}0zw&!WpP1ruV5Ri4(yefmKjpCEH#0n*7WCH5l7QAx$-p2
z3om;#SfHHDg(4G~7*3A6Q)C%%oU0EoaNceDUphSOE&|&P(5cAk2!NhA{ZswDPvX+0
z3n#$O3h_8Xljh)r3}BrVC%a^@XBkVp(L78~FAr7w<j!H&pqMcr?@o<@s(68Kmd$SW
zB;@D&Qnfqn%V%)67uFYYSdSQiky4RVbKx~Us;m|3uoWU16_l_bsf+T=cA{jV5;k_^
zDsGFc(MR?Xyg)w-)cHfN11k_+TzP@bL<uOKg88Wb62oNspuhV<1s|Y)+@KV&UqH9)
z66cA+e2uC*YWYXy;|+*#$u@adNwh4+RaPmm`|2q#`;V}fHOt_G|6Nf7?W1G_VRf$*
z_7z4_91iws6w(m_(QS9M;1)xc!~ya!ozH|TjiM(Hbm(9%E~8k|S+Y<;NKa9aCFBS7
zb7BG%pU{&kF=x~gf_gDCz)w|h$)eEpmu3tn^=xv302Gy=R6@HrT?{gudd-sVt7Vci
z=Bl+1|KgTS6gEAr3}gEMH+NE@$ERY1yw;Ie;Yg3-c<<y{B$i$#RMkuPsHhii#703A
z7kCvCz72=3qRYT9h<I6oU193YE#H42)|A{Ds9sB1+$$Lv)9T}GXlJik^|^#K0J@l&
zsw7p$@4tIdlcWIrlcXG{ap<C=kI8LXiXi6P^GQ}op0s^CWTz8^Nu|v1K-y7@H;eZ`
zVHaE%>|&`qf@O3Vc2P1ad9Ay+bpdFfwUL}eTUuW<S(E`2j!OO{6sS;{3jNZ&+J4QJ
zivtl1w*LS1*YN-M8(ba{^*h96ZB9{OnnpK1#ac!@5FgM=D!wZ|p$;qeOFi`vw+ksx
zwGE+Is`M~kFxECiVwbs4tpPaH1aRW;0<KIGdN4!?suJz9S3+n3Wjff1p%G8W0+{cE
z&15yNgQX9px&Yw-DF#Dkf|Oupi1xsez%jd4sF6N`(8v5}$Kur<PWs(ej&@BHi;V_?
zsDqF{rmFx8#HJ={Eb(PxxbqIuiEkZ@A|d$5<=HtMm!KsVOZRDL)iCcY^a+e(RPqUN
zP#^7JJJ~6lT$5}qqnL8|F*MI4TAh-L{8w){@MDy7<)M>~^n8XHNVJnNxuo#S;nDe|
z0f@qn%@(kznd?I0t6`41s9cjBvCxaPqeeZqKg5M=qrzITtt5AL@GQD%<3toVM6`7B
zpBxeGMJtQ$0vapoR1EJZWHbU<z7s|pR-Oq8x3Q8Fa_<12MwMWK?;OEI`l=uz?kJ#T
zp{4}oM)+&^!{2~Yr1{=T^8P4}3=J{le!_;xLtG?(iX5tKAb^M7;ZeiPU>WWfq#q=D
zU`Dml|D&2TD)WgVK$TFzR&y4|<@F^A`-MVzELSbuQbZ-P>|&-K43Q?17>{zgp$^Rr
z$g#8*ikFu><pzQ}6FXI2rz~tF3&6=VVHUqo`2)nr3FVUK0ZsO6y233ps`!t$gd-p&
z>feR=#-NPl6J{Aa&9Oecq+bTZ3BPo+)2^awjaSQ_h+s&>n@Pdn#79w<bx=W_iIjO+
zkp+U|7!RIypqMJ)`)+j$P7y<vNM2{6UPTjf0F_|FCTOv#6qk>-lj*%()g&jO#Q)gY
zVJTZmel$ALte*Q_bIco1J;?#xl#C_?0<&S<hP%b3{}If`OO9i>-bT{YKHAZDT_y>!
z*LYDA(LLi>qrb5Bn00PR`%d6Nvs=(rg#>8cUKQbqAV_qNmk&12SNxTm=d1juU%q}~
z@JJ;6*A6QY1l2|kW7`jdCariq>qcu}Kxlm#KBA6E#%aIPkOPh8%{XD0V-Q0c2O5pM
z|0;d@*YIu%i#xS=Bt^eD#Y92~RG-<7fs^<3N}uP@Sz3j@5jYCu*;VwJTBbBTACjrM
zBI3|<NU9u);^^b0dkRE|D^1_E;xIedr1}^vmCsBKRr>F{6oNJ`8~M%F{kDlM8#>I|
z4lu*oolPbaKz1<qjiYz?B&Y7qzYYIBy{PZMe-n%*^th78p(7V5cp9Dv2{6Bc?jwiY
z+&!zoJUF23zO3}|2vS)^<-BfaWywm0Aa%)aA`f!({#>_IY1x;+ov|@$tVhi11N&}~
z9kG>~`AMk^syPz}+hdXxhoSnaN^g5p=4?Td?8zZA4NmVib6w$;WGh|W$8Zsl8Pwk8
zlDz=mzIgvsF#><cVtD;Te)kcr5POh^v(Z--ZoXjVrZ3PD=xRe4qY~Y;8)Ji)UA-_|
zMX^|U3^5t~W50$!_6O;ra3WolY6ch66D7O$*uErkR<)eeq%cI~a0&I$y|bZ_o-JEJ
zH1MFVt*KMe#AH~2V!iH8X-Ij5k&Zy$@isdu6Pwd)iSdoxlEc1fO3d1x8pb!mTidQo
zHW7@KhhBdfAL{+#LNOh+(1C!ovf0@%3PWU-4a@JMU3nI4r!54>g_gWD)SbC&E!mc&
zR4#SZ0Z#GENC$2ETQ{!B`aL~`en&v4Bum$9r6dUh)5ko^dH*uJ|1kA<{yx0^3dJrv
z0HB%>2&gA@IuiEOCSqG7;frJ+Uzy$yG54P$6_H^mKVRgGva?^ZSsGY+`doqnYv(Oy
zAjJk#(Jw6-R511sDQ~kDVVaA*_h=WMveA$HTVNX0C5O$KtkPFEY`xU6hbCt*s@x&T
zzx+?f-Hn^MVn)Atdo;CZ@&NKco5?=QY1zX-Jy0usf~FRbN0GeAVPCx7yeS2U{=|iP
zxu$gs{7mbhMS?b1KFV__r^EfT-adW*0eYneJW?2aMsJ<0&%upI7lRqCw;&mt1s+G;
zt_PH;VAVpO#6tZI<7M<YVIKhnG)PsC2@w*<o1dcqXw#)dU39(nspR?8z)VkrR_*K}
z;%jLA5|$6Itb&~#NcN@~6>ovi_GEjKL7Up3&$*ET#qCqCt&l5(-x|s+)eDpnE#I&6
z_EZFK9NnZPd0|#zpIkm%HQ6dC%oC6p+J(%H(6I2skEO)dkO)a*bpgV+Qt4}}nV~~q
zD+4-CoT3eSPImPL?x|o}SgTa3vkWQiJ}?M?I4XwjdzR)cRr#NA_^EdsVA)Z`8c>lF
z7F(W_<`!F<2!On8b&zXK{X++omnGa>i>f6HN6v9Wh?Vxv28aL|m_IgI0qrS5exh|h
zmGT28x<(E{w$J9dfE}<ct8a&Ied}9)%9a1)@cOgMq0)9J08vB^2P>75zN;`OgMuAS
zW)ftMKy42IkV?5Ut=$=DjuFJ*^o$_SNyr%b$y+4MK00Q+QgdNhE;t8Ok(w%%ae*Sc
z{E4+>S74;Bm!dpa>c4&e_uqa0IlT$<=kUk=fI+2kUC{M_LW(Pms=VE}`R&2<VN?lW
zLI~IJVl|W!ty;;W05_ClLAJv^owZ|@9iJ9i4eX}w&H>QwM)Z12xm?ppPua28>Y5u3
z-!tzkxMCT$ag#b-wHbjHBJ4t2=`h{A=9U6gnta&tP{(8wd{ozL?E|E*!)&K?)Gmp&
z@Y+d*^khj`bgrPq1<645Hk@i~8(Mi_Kvmr6S0tCPX+PUL^jS6x4nDHOEgnsIW`-Ga
zOOi8m^&l0T&Mc{mEz3Zxb-p!JFvkLk>|IA8=pZ6iNp><&`dj%&pu$3rt55>GSz_Eh
zrmV&8gWtr4Hq;S%o(Rb=FNcaKGX&uc?AI%CR)sytBEh%NQ6ZA(d#OG9Xp0RAPqc5b
z9@`NrFIX3lYAJxbx~j~g;&lboxXO#F5jBo`dg{Dc)rOTWqGN{Z!M*%a!|a*jrP@k`
z0*D;C)CqX;=`834a-CBDceb7Hpa}GwX~X8yx!c;ZcC!r~*?gummpkwV)_G~t**uaB
z1o<Rou`xn-Qu+ht!#P!1B$*N<6)yk&&HES0*4A{DfxL%~5meD#C~#|CD&q!0Ny8vr
zWw}^Z1J@Ku=`6ERgM+#C>?W9!iBxYi>kJ<iL^k}J@PF}b{v^DAW;eZrmx*8og+|L^
z2B#cZt}FPU9V|^<+aW$z@byEV4vi#)xjY;#CFBN=x$;CtY}if9oq+%yY&|Z~(L24E
z-l%vRtt@&4k(=7dt}IRTxMryp;bLx!0}AT)UN+h_!l60H0k}wox)VO46Jy_?1i}s#
zs4%?+vvyLo3478i^y~$C9G4Cd^A5#pS8%Q(2STlS3G}i9LPV~%lDPGs)5BIi;JX=F
z$_M^x>k;)TrFYfg+tN6B(GOSkm%=j($-s0r&tTx^t6-}x*&8EW;KcxXW)a}8u=svp
zQ^h||4HRptd{+tqd;fB3*Zc@XH?;4wUAyA?p{o0g7OjQKDyp~8k{L2hw<#*9z}%}p
zH7AOpR3%c@P!%^VCZ)1g*2#@w7ijca(`1%-x^!5U*z?!k-ZP}XxvgXA=&<Dbl)r#J
zR}TVI`kU{+G!6~qhu*(Z;$4Knmy_TZppMpVbd~d|Trs|4oRYK2$k4m{LqgdK!d8;e
zr>0(<CB=o6D00NBrG?<!Noj70&7VkOlkQ$UWqy$k+1H<|d4RS`DjpvXDH=8ORqX|9
z<Zg`@c-<j18q4!8*(iIy@X!F#Q=Q#SFdFlmi`s3bi@YB^dRO!Wt+zfx$yv&Ihxlro
zK&#jmcqkd=<@K%(g_GdsomS}2S?fUwa-_%pko4H!{1JNW19G8E>H%`mxn>@wZBbPf
ziEo31D8M!=qi{-CwT*B+S-M15YXo<(oK}A$m8w**vHz#x-=)jQLqC9zCBwV(^#kzL
zbJhYNTs<`xa2o8Q-aeO``ReWS-~Tnx`#*mF<@=ZN-yfKqK4iD^7FZ!c2=U)7xgA;6
z186O`0q|yWdA$6wyWQkHcBU(HJ5HuMN#nB4mS~cy;CVKD7Zsa=I_1dPDBV(@I#(q!
z)$3_g25?ilunxesYI1<_fTo4#d??lvfE#Ugn@wbqi@r$Y0rHPz^Y;Z~oh0Jme@Vq4
z1)Mb#n+f6tBdpw2Z_w@v9J`TP%1&f?32_GAdsBf{yLJq3?Ko9wnRQ<YF6y$xiwZlZ
z#|_&%xH1-OZH^c;g{H`;=jbKH4b!vY3Pqusm{;)8s+;!tV<K{6{D1An9L(w}um!#h
z$u(1w1^DF^Wh+ba1!zDRhDl|f?y?L|vmL-X9V6!uIJ30q`U3^(GSz#P3q+JIJFSqS
zfk|s13Tn{vNSrArOi8Sj@Hk8`8L+ilb`+q%HdPPxv4V0(%m`>E9pZFdU!JO9<uSlF
zKK7S9?^xaL@v8Gf;MHvv?)Ih&%y4`V^(1T7Z~;F8aQ3$t7$)^mlsYR`uH0+mTI_S6
zk3>Ity?KMSwYC=|Q?~;G*$TOQi_1`4r)R_+FY&I6+ZU)Gu{F6XOcDRmOjJ`?|L0)B
z#B%aln*s{OCu!pupYn+|^~W%G-Y*&?rM;fW-8bcvBsj-)*$o^B8jn1xieD+P4k~)3
zA4tGYUXn*oM{&K^Pe2R%{PicVU#H*spOgdF7MK;oTW?EfI(Z&q&NfrisV=r6CCxkn
zv6O@L2C8r`d5UBO4Yc;|leGbG<Ss0}OG(OlDq|GN2xJrb2O&ws?;|C@k_Rpj*zSa~
zOefIt97jYeu!}e!2jSKIY6d0M_7vk9&F-w~W`)9A+}fp(tP1v{4nO(fx@w{G-ZhfN
zv|wV`v}|?sHp(w{`${Sa6$^%FTzA?CDIG2(2NVKF=lbczi_!!*pOw9ES50vBm1tE0
zMIrv_3F=^7UIzqB{Q)1SI+&=T=iuxbV+Q`p4ej)I4|h97la0V`c$wgMwXRg&lw;fL
z?YNV<6w~I#>3bczQL;B7TIzkBlyrt~*?An`Ty#4W9czzFv367?+2xSVktjZMSSl;_
z$YxEFQ5m^x4n4}XIc}#aeJs>UlAa#W;(X-Uy*ApX>qYhLAya^JQu0U+k=<abg4wML
zn~ftR?F#27(mN;FDJL;sUZ5RUS<(`ST8o%K!748uooa06wkuUt-!Z{x7&K@N=Y9+z
zwpv+~#g^qR<g>cb+benCAh1pdgoai|>2--EhWG44FI&bJPFdM-NP;aEJK#klKN7~P
zHXz-r0NF=~1)R!{b(eY%x|cSnXu@pOOiXB8V6Xk*V%o>4m|6%!*)CoF3$)|pkvyi{
zBL%4oW`QqGH{8QKC)1m0x>??|QRyNLn(#1RykGwmZu@Xim3kXjp#I!-^n)j#frRSn
zk~2*$bkS6^wFu30YcEDcmZ7V}n(qL#hQc^Zz`#HOm@O8Ko%aho_{P%;H~x0-`XCtk
z;&8~Jfv+2}!2;w}VLw(Hgrk@L^fu}WLpqIN$;v3B9+Xhy;uvHOt95OkLeZpq!U4s3
z2~d*#q}@&J5&CXcOFJ*`p$y#RWcE$HBUOtqfxI)=S*40HZ5z*Evdfe+%nLn8^mwCS
znA&hnO^n+J<t0KUB|SoGk%!I-3V1VmRF5`OiYjo@tNVoJ{B&GhiWi8xK%200w1q70
z8uA>FrP(%Q++#>uxF!#g^%O@P2;7!Kwc~3!3U?Q1?wy}_?QsZ$reK>GZnt43g`fw-
zM$!fk5puq5j3*$UxgL@v^cFYvR`cET1r&lzMPcup&s3|%F#CR>3b`7R6i25qp!1Pb
zVSt`kNDMfhC?HR%ax>{So&cXo8%82>UAyGc5EkQhy?q`aF@HJIBXfo6M^s0>pbT%d
z=_4kr(+N6Z699Y?Jq<VzT^eOeGY+9}dFn_JS3^<ztRp7$lz=`a$L9{n*XY#aK?%VO
z%9yDxM;7yeNl6EcA<VK<Vv4zmHEBy1(k#H2sF@gmc51_&P2~<~4F<BrI?xHX)%iE;
zJ}92MI!kDz<cM)Od55A%HxJY&7eLx0giqrkM-%kYf`@-i2o!m)vcgx%aS@Ruq?FiU
zM@E8S!dDzB*v`#(4JMBPKQ;u0pV@!|r(gR1Q|subLMmfg|3QatQY)!RvL<N8;^~)`
zZWU6}ELn&IcIUT%u1LB=WKFOl1fUCzCH18Qm}rFZJE<w7RU^h0NKZu97V8UqgLazT
z?oAz>Bj6GR;zR;ZN*R31lnwmQYO)8?gxlrG&!gH^yVYi?y8PSlC$@y;v3|sl6{`q{
zb;z4$o4a%9;52VZ&?WiZdnX5$wsqtzB#lgmq9&$o(OIu0ZgEiwUPrg-T%adysV9B3
z=x3LFGPKk$`D^&Y-?*%*(4S49_KG7vh)@=l9IpxS0AJ8WY9om+j^9(A|Exn+XpR$l
zR|&?3v^}z7*0=EJ0s3l0utz*oB*smijciA4W!k7y9v9~%qnbJ{5Kc#KYh4SiFg!r0
zzU*|q?caU~soqEY<f%~@xt9T8+gdxLRUzxhYEx>;IiuMj9l?aMlaM{i=2=+_55<{!
zCL#ZZ(z8*2nZ@;uI{YOy7N}WnK~w|1T<$oI60#S<GD@)kSP1LRQ3`L*fS{P2yJc|R
zHZ=9>zAejyQ_JX9_G(k-MbAH%h5=ZibL|YA#QQ~?^{YCmse-FFZ?1_cb8hWmuC;6R
zP`X@A+d(*p&<SO0XTyLSzHMc3ANdqgaestUo_Rw9b#$A1?DzKA`Ai|dWyy2{TOLR%
z8{TjMrr9{NE9MEAh*E1Y$F{xdhiPUIo72P*0vvZFIbaSG$56sg#1^tr3erU$VYf;E
z=n)F8p%O)Q`e1Kuj<s84_P}77!4@3InAowBY<D~dSrC$*Qer^9SM7xa`bm$@)@LJm
za!EMzvICXFnRV5BEqTZd$px(|I1@;E9EY@I`I25)W)vSB8&4YG=yokG%`v-5OT!ui
zYW$EAZvkQeiR?b*bMaAx1AA*LmXoa!!oy{%DoNsVIt9x`$tWykxzU0T?HkOJq@Yk_
z0??#c`*Q%?tc)8aV4DE^lSQa7<wESFZoA6vW*ZGa2MR{1N8ludsfrGl)3fVnqKp8B
z$ueXOB`})-d8Pq-p`dcSg=nPMJPWI&{bpal3<g(rBhE!)QUWBWi#sN8+N8d5btkGb
zs@LRpfB?hDi6DKMZgMm;aha3LEgFzl+taNwXZu|?)})wx--&u~l9E+CKl>114^OG2
zvi7>p-N`Z>K(CQFyZKNcbXN;o^$t4vLV}p$N`Oeqkp|>wHYcu96#jdQt8br%_s={*
zlm}*SF_|YLH;~K;umGyM!=pN0VGm8BJfw+$na7!I5Z@<Rinn+qbQ0y`wlu7Cx<}7^
zuIann#gG%#dg}+WOUu_A=09+4A}>nzn@Zh~f24GPFzU6Df2pWZoF!aSQs`AsU$LIJ
zWDoX1E<gew4DU@4yrtks4>u*-ABx(jv?*J;$e!Y1-BAv9VzNx*=0#g!WK&3~Et9Of
zgji9hC3`;)40Y^S@3Y<ZDiOWP&t8?eh9X(kovFMXrDY)eXwkY*mt#Uj%J9$yU(hZ^
zTLx$+L%`@m{UY=>$pS_%huuD~;tc%-r6kpb?{O-^Y)MYfi&WZylUZ<u?X%<<u(~+1
zYE7xRTJEGQ6@2PeDDJQ;u0NQl^zXg?Yxw=&*oj)$y1}Yt;dL*N99@eWL4-)ePuv62
zvY|3#f8*&xt0~w$v*MAG=ml%Kq=w#-REB0uMa%Zil^-m=-{fvT@(_V}tFx6?x(ma<
zXF;M;AHiqUeO7TvR@jd80p&0}3Y&AmisgZEG8YvtHhtK2OHzsghn|&2Z=bw=6W)L7
zgyJ7u4mnU<0S;hp$^9&QsV2pk0Tg$av!e^mv|(LOKvEgcrA`vFr~cb7-aqkyqW<o4
zs24(JlP8dJC)1-LQXomv=3pf`HF#3vM!Zw8l&Yp^@AlF95Ma+j@Y`9xTgSCXp0H?K
zXLblz%OxdFKKSDX4E^}tj&<v`LAD#1>#7qW{~?kB%eU!r*KbuVPb+|B`^oKXr^4F$
zw(=0ca=zR!A2!Y^8b}6Etd*2&$3s|47zfzv1gy-}b70Z(CH{*^g1T^HEBxyH2f86%
zKemO7zNC%I;=|8nU^=*UF|pH!?s30ZaBL^V59-`acNGzUW;NXwla49hgCcPykoU~U
z)*?KPxG3DL=sj?Q@}L%dFCBNdDpN^NLUY9yt~$X}d=FB_6}@?&F0X>27fjJtnm=v3
zCV+%v0yzuKvj){g`W;=o3!IeLH;*$~tk(1#R^p@O=7-K+OK5k59ZAvwQnN_mGZB9H
z!(Z)66_vj85k7(<oUu;Jo;8OY;Wkd0Bz!rbI{KJJt-UOlfcy$H<xXAsDHMjB>x-fE
zBcL0KB+Tan$14n_fF811M@a$oG}Vm!$Eh6!kTqJ|m$x5-S+f;wa*bJ|n^jH7kL1Tc
zO$1ZB206wC+s>3j>L^T6<0C0#T_Jf$%LFt{vRZ{gq)tRQb>Z1L2wnJk6t3_w>0z7H
zW7q65-#R)PB%aJvSzNGqlzX7{YX<=j7=czNy~`)e6AH%8VY*w_4IRXKeR%ED>{J(R
z(8gHk^`&OF<e007DY0?re-w!ZWZ(1Hbx>RL{j&8e0jmzx<SLV@6DW_m^%#wxzA#5Z
zZvcnWP@@0jB;csC3fp8lkkA&oZ7RsS!>Y~tgZ}^tlfO6H4yjlhLlNqr+->Xi++N$s
zrC14|f#6lLX_knOfFGU+zj41qDW_3P8Y0ed>XkN{ICmc)j{=*W$!*4uX_fc0FZShr
zBYd3T;&3Yt<UG(Cpc8hPVBU_{gHU&e6Tz|+0O+i2f_Iq()2MJJxwa}pGax$3;tUqK
z)0*az@Tf~RCa*uaJOKH2x5t8FD0e-~w@_t|*|i(?{^ZjOJqH$H7(TJ=*D<I&BhA_<
zG^XMzCn7QXdi5E1a7E=~c=Bi|Zj3jMBuW@Ebvl(K2)7uMF?I6Kv%^bsyMi0qhyIe2
zM1P<d9YOgK^#kXhvK&_8kAW}eP3r~QGWc_zo1c4VQCT&qU)aA;>+)7@MV8GA3^Wl2
z!ZB4T63^rkVSxw}%s~w%Y-^RhW!BJ3g!ugsoUKBKTuH<`*SMTlpTR7uUX;V3l$As9
zFPlR4qbc`>Yg$83aRddT+&4dhN3Jil$sn$rZOhoKmPgc#ZpVl?nf~c)-@bDliyB5o
zFnzP#46Xh}%`GF6cYC0}<CFazf3;Il#jgn`lb3=cxs7!b+sV4`VPqIlnyeix6CDNs
zAEx0bjEC&4rXFbFD2!^_@v5sUQgKQSLujO$6xmP`DzF}-LVHxSU~o7%THv6vMk2ZK
zxAvNGB~Uh`+38NXPykxph~r`wkq?_r!}d41)lrTUP$OtQ+8vM`i7p%nioK7jVaA=6
zQDse3-Kx}b#0x$m)YFquD51ipFh2Z^1kk?RfEP4B`yD-JSx6OR%r=k!ullqv>PR4O
zgdMmV`pXL&Mka6Ijb5FEXg_~+3BWJV&Y{Dfa*+x3SB08V-pO&Ks|2yiloz@l*s_HM
z3Cg0!;UfY0cFg2r^vU89yANRZV|Lt~7+2evbQJ7eO^cd~(xzT5C-*hqtgSJfj}@xy
zU<ExyBM4|JwUuycDgX1UvG?VJ9l8ri(L1CDG2x|XWK6hZms?yhwbYRBq&nDLjddZR
zE!>Hc$DoVU@&~4lCG{_$53inD#<t@m021A2%GF7jKqB@%oz~i&_ofDPthhPLJ=~^V
z`<i8;rbwRJ$Z}K^wsp!S=sjQ7TSRY>ypsyH5Q+OxtBzP@1jZ*hjGio9V5T(zN`VHT
zip<+iS%Pa*CF93bR(xg>iHTOdNe!`BGa@|L!46eLw}|DmXKqE3d08bYIJu}B)Rm>5
z;nc;byAgIbDcu-4!j>C=d`D1nmi{YRS^NNi*`HJ-d&3K6&Wq&haF%fSGQ9s20`{+8
zf9<3mSj?n-fyxBh?-D`o9%@llIJPBx1Rer)fRg!A+WFlmOF>0_IvT!1L!L#;)5O{x
z{zCE&CrGXUR6wi0+X(NmmNrj>w9`!zJm`1dRps(l&~U<b9Sdko09`9bp7KIiP^!Jd
zd%CHU!ox#W@(5Ge)n~AGG}Bj!Dh-c7TS$_>nC1(rW4O_PXEw2yHq0K96?TpxjAz$7
zq@-;2146B2go^lO*S%R_Ol$A)3fokP+t)Cd4*&+UGXbv9?cE8#AWtLp6uyQYowZm-
zcQkq0v+T(eo^S>hjG#yH*e>?wB$;a9s~-@B^@GdX=kK4xQ1grT-@X3g@}j0^12C7+
z2efj!3$fDah@>T`8M~7?$7AHC1nXk*38)&i*ujo8ty3(g%Zw=J-gc5CK5{c4u|k^G
z+Q5)d<B>I_Mm0>(X@)#J7FFz&{WfmYzkT}zc6=sM{_*>df=U#|n>R<d*eCH1Ca9Ew
zoeP)Vn08lbO5@Y6a7#@P9QM&ixcwk+RsAN?myo})#lK=KVp=)Co4P5q3I_yQxm3l7
z;lGsni-7_WwXaIA${sax23WiIMM~coUeXs3PNgdYuvW&%$5~EY1*pq|@MJmqRN^mI
znPxCzwkA1fq$6+B9{~4qe)YWhd|%DRAnz;xA_0c%*xHx;{R&S~<Xw%Es<mv{{s5<q
z&HW1NmnXeCO1^2Wm;T0eN7JZB>AV3c^TL${&FDl>R;_*OjeZ$kzqu&rL}TDGRfI7}
z(J4P*vjyPV_G{K~USW~qb0`h@+P*QhYK(5JEf#ToDY4C!xXPSWM51-Qsv$GjBCAJ9
zG`i{ltfjI<t<Jl*Y$1-Lo_wSZMuXOIPfQLTy0LcmaM(J@Q!oG(yf}@`4!>3+DjzE_
zbay)*7j%23p1a_oSf2|Dy}5Is1iF@K(F`GvL<7CDTm+_7s+$H|yTuX{DrfhW3p`D0
zp1aUh1pbWN3W-3Rr)|{2m{G#!j>Z6!-K=C{fc*3vZhSQc0J)+~)9$t_)Qj?hMk{Fh
zTWe3RSyYh96}&phcojd>-PxJks9|wLx+s*BO6V{|Le3#lPk#Yara7>vAP->gJ|=Z}
zTNn}#<<3*q4jve3%)m>_*|MQFmCPT-HOH<xisjN<ln>ATtj?ucH{Mk0Cj5IVq87p2
z4e!6S@TcwCjpVmZ^}CVjXSEEuIctQVMcY#?J?Wp0mzHQ(r0`2zaX=AHT6$9fDaZTA
z<TjygnzOpDzn!J#wHyL8<$9Gp#mr;CK#UIAiCypG9km)GPNZ(wld9C3Qoex;)DwRZ
z{*UyNXIR{@CD8}Y`{j*5H3Bj>>1(LU!U6hb-x(lHRd%u#CPs-88|(^h`q!WK0ZdJn
z^UZ|Q!;8vN711&f8Lf_Jl%(sH8cg=hUx4T0roro#I6V0b6qOKsW|ll71nAVx5H+=x
zUD$c}blW&tLqKUc_Ug(_R>E;ciD8saeL#6Ted{cyAt!0cluk*iWZZ30ZSS<y12;<|
z<s$cF{fjzW*_o5uoVAp5i{z?eDqf-P@8m`;_$`Zvw37B_Fc!(L_3PJ9`D^&Y-?$tH
z;Yg2IDk3XAzC((PZsOqyP#RIDvH)huO@@3_!oBN5)m0|QQY`_U2zaGK`Opa{F0K48
z;6E0`AfQTj5Ne>*i=5FTGE760RVv3jw+m?_$>1GyBB+5(f#~B&0u}e}J|@dt4?a7m
zZ|hzr|AdRhc-cjcHrg^hZADe4_H&kg?N4Fy*oP{KtvCQh7LwFP)iIJSpv&pWJqDf%
zU|1FLT2h4!14FMR5-yNbHJ!kBI@5Xor50cRcrL+g%wtm?U^#57>U`!j$X(*oepe|t
zj%A5UPGlzAjI#Y8gw3bbbQ!?c6h=<Ip42<<>Icl=v}P;C0-@24^~Gy|X;t|OD>4+f
zWjYU1baPrapy}%~p+@Q+v+{;;T5_j{*C%%XoV90Jd$lIb0D1(6u*yM8<yyt5kCz9X
zwd72mNg*GLdrri({kxchC%fB{2jA1o1Rs^uuNd}L<yRTScN7){M^if9r*_2mUjOy=
z=Q@A0HY(KSoInm)fB>%_>nKRFaCrPidwO+zFOrMRPE;sf$W!Z()#Radwe0fsM3t`*
z^$gG>@%i#C`(H@E*bf^{K9z8jx^y^x+|MsO+oxex^>SIg#ZC<%5L%G4_KC@ocIrb5
zX4^hD=(drbtg4Xi8xUr6^tx?_vePtsQ&kf7xj3y(-aCkT68l?EzA?)8nRz)F6jQao
z;>wvEWV4v=t*VtXx5Whtz0)({<u|P-H_%JM($yM@FzB2%uFy*MKQRU-sAgXQt88!}
zDq<E2x%fzeODC&b3pOwr4)x4!yB;IOyWNzI70}GW39wnWoL?utORLx)R<D3MM^OCR
z>BQI5c=q;VNUi)-iiv@al6wsg9M2*ETpg%JSgWO^#AoMvD|VGlfSV2-@=6=cH&D*#
zs+U_cK>)}z;g~pZ5?9&w1<f3m(SI9Wzq+h<koxTKC3Y8JuQ79I`wphucvKKqvZS@Z
zuxdq?Nht~V8v7al_Wf6=u~`!JEN`3mZ2<amDf#Gbz&pVuG96yQr>YVOuF$f>xNdwZ
zdMXk_*<nUkmzzO0lj6u=S74|%<i_z#;G8i=9KB~-fldE#F{(mh?j`w+16&JI-=JE2
zmY0`IN#6dSU<P6@kh}HirR1gx8c4?&93&?|6{?Aj4hr=*U0gE_>4q>)8@ytpPR|KU
zH9xJ4RDy>=nN;n564Ec}*<rX|PY0}b+NeVB7b;%any&)$JU(CuzLAzSt+~-tDfS14
zC@`auZJYw6p~3I{8(WdUSv<>kHBl7+ODi`{=tdR2bqi)l)S?_MFcCswwOUf3H74QT
z5Qsf#nyyJLYL0Gb4Btfz$1n&cD`|)|gmYrrxcxMsWn=r}D(N2@RDTHRs1)?zaugL=
z_ozHdJO`jAhGSC61O6k)d1ChJH3Wt+NMJuR)>^C<LxC2YS?Deb&5admM$FADB%2eN
zy`p=#>&99O-|k0n*LgV_E8Orp$5_*(OsP#2{p~@E{pe2EXODKBrO9ep_V6+t2gI7m
zOeN@HBXtIudd$$5^GaX!#@Ov>YP?pG`_$TTah%Vn&SnzlI+EXIIRNwKK7VBdq(DRP
z)v;lrHc>`-BrmLC0FZ9d^jnHa(2^dPHqL6h2X|#CPIjkxY7J?%Y0fl1K-M-@V_McT
zxJaLXq=2%!(RfO?g37+w)IP^Wh;@)jbedF;vN$Clx=-$LF`~z@TyF3rXf8MC@=(=b
znE=%o71%X;rU3~9{Ut@EGo%%vnXc~&Cv^4-XfK%Q!?=N~L(atJJkkMfGL2*;*S)4m
zbOhZ<j*Z20&0Ftm%-bn10bc|1hdu?}Xs6Mr#<e};zIZ-xSUL1#*KRt8?B2H9reg&t
z-{PF)n}F+`n)09w6g-4+j9}vomBuQ&IMdGPU?t{|x(-a<^CreCu5Q?fi;7wDATPZ|
zv|~aDB<|p|F!e6KJL7qgpPG`Ru|pwjj|Y%u$+-|;(biHVNpEMFEMBRMI4PTIInESN
z4T(%}H}8~3?Cu2g*mhZ4iNhvvCl^^y=+-<8D^|*%rT72)??B%sHL~Bnkdne^@woJv
z`=irAf!!6dG)ZgdIujb|l*th;DM(6H<jY}l48c>bj~ewEw&rgGSQrlr*s4hyLL^@g
ztn@#k*{g)IeP*j3;Q~VgR!S!a@KUwBZRH+XLfDE=o6s@<l{LDOV|x$P)j~o5xW2on
zF>tMSI?(aHAol__)fIiOq<GGl19(%#Rer5(RDv?;!MSD~UYKguN~=kKXUWj0rJGJ_
zHZWRrhlB}CIwm`l+fCpZqs7uS9ddJUa*zcRnWA13>iONV!Py7I??-{D?NDOW3FkLG
zcw<(|nX!Hba+5~MNABE>Lt|+_+Nf<|UZ!%=EjQ$t4cRbv$6IRQ^RuA%!_WCUpGuCJ
z_Dy3A8?>>e_0lI(H#V@^>0Eve;NlbSp<VPAz_Ed0LVce1S>aAu_excQ+&X7~T_Fk9
zphX#!X;ej)%PMJItyWMoAS&`wqBkwCFsNd?hM`2lcZuG*)M(ga>Gmbic=eTAuStO-
z{HYxn)*W17C#}Qyg`+L04a~B48c#&=WGPu#d*La;H>q8Db<SONs1j}jQc%rq*}ork
zevs3f$x02F9>!4~WR<z=PZG&n1rzcxT5yDcdgG<_zNm?ULj$*yjRV&BY|^N3QT{Pd
zplIzNL9-+PfylD&jz#$@*D`Rnp(<A8^f3SV2Y`<k$(wtaE-0z?aK&L+F*+q0?N}Xw
z<gm{wE!s52^5ES>2%%fQ31Vp#C#RT8M6A%S=~!kK;A#>n0h8u_NfTRQ4beh#I_}d3
zTBe&M<eg=Tvx<S*2?%<koe3eSysAS^U~UQtj(s)%GjNX$V7xmDcq{3_Cvjcs*xCZd
zlVpQL8ma}BivdY;3e}#zz_xu9^lR$-YzhLUQ+a}BRs78b!Y&Sxn07c>tHnWPkwF=f
z4W6hQu61V!NHOBnT<C$&(|AwK3&-s;+yZqS0!@k~KZN&`X6lw;HZCTq;Fh&Ycz4y(
zTW;fF1r}P0st}cK<{5o|>}G`lr)#<$loTq46{MYEDm!TAqPGu~UF)|E#SPxhmhQUP
zOkZTF2R(b-_eyF*sQ)oqlpQk08t93g4h`tvnBaV<X&Jb`Ku{ok25Av3NAie4_T;$;
zn-;QnZlD`)?SWx-dY&CCY=j7&PKB~?(8V&GK3nIs+uY!71Lm^3*MsrpEe${c?u4e!
zvAUgR`eOw?6@)mmy{T-s0wdXUMI(raV|8h_N*4Q_33}hxQx<rW=e@!lg{)&xWTlLK
z`v+ts{{XG){~q3x01k>@4kibc`JpBu#O`c91T`q@Ct$j`5U#h`UKuNO8!K);kCP1N
z<<cVFWS&n89hu!u_?fXA0=4;QOvY6o*j53U+Os1MUI2#|iqAH{xcav{byC~nyC&eQ
zVTRN%arb2C4j`CeP)3?_YnwrxGG=wkF0LKO0CuSE-t|KA4(%J+m_0#gtxEcsY9j3E
zm&s+ZpsbXe40WLfc2yeu*}(%1J97_122tAjSi%iL$Vn7{!=8R;Y21g0^&lj3u}_t(
zeRzZ{r!i%z_O%aZ_b6M6*a$U+&9*JQ^Wf1)s$uY}s_c30;+B_ETV=#PUuol@A~|e!
zIdr8?e0lj_*ePGzvKy)HxrKq0StM2_Sf-9=Ep#7=djOGP=s@}E<$*{Tt&h?;f|zX6
z!3Js#UjFuND@nYa<<p7vgn6$$heM^GeLJF)`(IO#{r>ycufGlHmlU|@e2qN_2W^yb
zuu0k`&7%M|o*`|>;pwX4%Rn6%c^|Fj!$J!#C&}NMng>RRUOGaOXIHHIZo@ffoybF>
zyc61$+9w<nWrs%=bfT!ftvzQRnOT7PTj6Z6fY|(_@M_2{%_I|$^^Qbs16KlBlHwM|
zt%IxVNi30IDxl(T&Tt0r^ki8E!2=-bY^6`?tb3Bq8RP#;*PATaa$Q+s^ZOMiD`}-n
zNy(g74YK}2sx0&Fy8HF^d2?@g49b+GG?b|{OIl5e=tvMC2oeNHfSp;qz<+74efHYN
z-=mUgiMSDXc;U@C`|M^l7!+YVoC3!%={TID;X%?etXHzmLqoDWYFRnrR(Fxc?vZm>
zac@1P0o<Gz;$L4uXY-qAe6WYiHhNP<BO@eF79P;>+Se^o#Cz%}A%X1D`0ZAa+|ySH
zr3M{1$lROc7S6}E-~_ZhWcft(W%TQq0_0PkNhM|2W!bre22B8XobVyYMdp1pVT_hs
zKa=Y|O)?fFMNo4oSIZ8-eVhGYg{ko64sf@fn{7QNxzSxcDC}2a1gK@H+&}73@G}z<
zQ(~tT1kr^O+}CXL*g6f98pheCQ-$$F0A2=Hk^4f@L&PvM3cusC1xv)G8XX`Dmr{jS
z%yI8J#me1>HXRG<Z4VR+S3la1Dl4Q$o$oal>vmB$8WgP6Fu+#Ok@OIeVT>#&76;$Z
zOqrXNIycF!=MxnG4KOUp-<@%E)O3|OcBLbRD8vORI~7Hua)w0z_{yML%0sMB0DxLM
zp(e8v5_|>rpR*)`ovjBXec{Qacx?;yI%u{U;~9DK<(MSDlE2t$eQb3r=wLP&Uj+(l
zms@Q42ZmxycqWyW1fr^wVrV5c|CVB$oW)Nwbe<e+)VS7sy|mXWjFMx+it;-pj4u@P
z&@u1f@$<elODupPJBfSR8k`x7e^A<}8#;L?2_pfX)Q*d9#IzsqLp!3{GBc=CqiS}t
zC`%%2Yw(NM&A48v$otf2`p;Yq&}3z^kP}>FTc$E*_DY5f7#s{9<HH6`G|Cd~Tm^g2
z#5C&rOY{ZYezx$n!Xu15rL2ssH|8xP@p^h!)xumnD|M{0q>bEoJ^}~<xJOo=SI6ju
zX{C?>OS?-oA7Ef}S%@5+?`(*z^=qKG;cw-v`P=mNzC7_(0Sczy#fG!%O#}@XZVpIV
zN&Zst;X(&0mOR?ck5J!bst@%go*0Gd<uY95)sw$JZpRv;(~Yx)D+L)@RLc&KlvNlb
zqt>9@?1Q3sp*x}F|EMCyAE560^?!=@Gc6<LKy0l-`_`er8qP_~Q;`iOJp+!Pc>TMU
zw4}uM;TR1UwLl6zaL!#7s)1m!0JJYyh*D?TJVhu+qegRCw}-1;{0Fa}gx5%B-IBcN
z7G1YY$ccy5(A#JhzXO>lV5N(8@k-m;Na6`O4Np(9R8Z63xv|womI?pp%{hp+m?ERp
z!+B_#&Zs*x7b*ZWRRUvZ(OdHr#^uUwJ+`=;I!8}R#wvl*np^5G7B4TEM&hIO`(*Ku
zCfrs?dN#FWhNwB7x1D8*Epc#{oMlQ#w8Q4@$FIK(uYb9`{b_jpUBq?8SB~}`N`r{?
zZKD-OnrcN4%$St#PSk2DwI-1>Bjrw#HuhB&tvRlg?29l7jtOPqa_2q+*(ooyH&oI-
z=)mEbQ#=4Z7R-z*7lf1Q1}SZEqPNc2D7IWT)$WKFT|3BR0-<Gc9&)9vKnyAdXs^VQ
zMPgUX59+KY`LIL*x<qL0$=OVu`r_c7PaQcWu^zc{8m;bKp?I$_=#6Y!5WB#>|8*>e
z|J6tck4Edk=(IbeDf?D4=IFsNmd@RV7qFeJor?#c$?|A$=8XW4yR0*G6(l*6ax8Jw
z^1X!NOT1SQ^plDcaA+J^6^;BFoo2hjR8)nK(#qZ(+Sy4aZK8SdFvT9C_c-PHN62Or
zZ}!$qrnN3z+!GVKYC5UJ^O+{hI?g2`WRD{pm#0L!1#;JG+&f}o0U2kg<%84Q?@#+8
zp`=3BbYqn2Gp&rGycN`~fW3$hNv`cl7Im$<oAhQxPg)^T^yg4|wI<>Q5GVqh^imtt
zlLTsXdLP6U;_OXX_SDG*!D`L+>;d<y_;JH-OjyZvSGR=>bc9R+y0Y1%-lRxCK5J2F
zGppF@`{m`aklV4l*Ez}`d2({$1NRH?$~b*5nuP{<wxTRHPK%V;Xiw`-zjPEA)|!|_
z1$-pEn|p1Qu%w<&a81eF0Yw{AWOil1@DeGG>5IdAkyrInO2Lprc2rj>7bRYOqZ%d-
zrE0yl8&n#!tXSY~f!Uno)aRB?T>&#KX+U|mHb>cFp8<+jNICXfMwCJ|>z$~MF5H{l
zl{TfsZu`?@E}AvTz5`=0!R96vBw657gXegeTi{(RM$gJ~@lB0s$L0k35$cI8Fr!@Y
z7@ODL%`9L!NA`NACoiH6ZJ%+l7l0Il<srpD^sZ#bb31{Zn@Ul~BXg=Jhd@G)U^rCf
zc6H$IGt?2e<?#D}%0x=YHp<p2G^xsi)00<N)Kii~XHc7UP@zrG!kTHNJVSv2v#dXi
zPQhjam|ek^#EO<xF?j`mE>F+pg;Y1=PFf`y%4Dmfc}il$soU_bx#PJF0U|7ns!J7H
zwjet}%pTUiMMHthMo}Spc49LCvSr}UA>$w%e!k^NTNxu;gFFXg)1wLU{f}Nhh(Qfg
zkqaRH8SgMc1o8g1a8o%cd8_4wp2Vd%)Qfp>xr<_nlEI|W0Vq^>_Mb1nITMhjvqFG<
z%gp+iQV^bJwF(Wkw;DwoS*Wai8>fWcRhG5bx7X8<(;f{?65!FhP&)^9C5e+S+5ZeS
zRRU8hM~k@sM<`c@oCRREaGJ<QE8@7XCG*N#7DM!NP7VyVq<a8Yi~^)G<ssE4Dol$K
zmiMWShsA`Vt!BEtOjGMHia2S&wzsQQFn~qHN_}|LQ<j9MEx3stK&gGo-r8rla>S)E
zBE%U<C-eE)X7wc4c{Cjk8xgOn3vEMXL~#l3cCJplD_?*h6B%Shk%k|3_uaI)c&p?L
z5csn<0^Zzm(k`ec5YTPJrKXAY5q<uchk_JotMH$~zx!Xg{k{pWzqo)lkoRZ#f-P~E
zq1_p=%}$n(vJO)?IhSmBh|?PSB1)4(pJI?R*n;GBiI!3DBTwmKyuN*feuJ+CNjRc<
zrsWn2&*MXUXl#z|R9xjClW~v&R5Kl^aaiWI9+G|MkV#s%WUjZW{AjhZv{Pr*nPbXk
zft7qZ9Vynb{tGoU{}Qneyg<Y@)U|Y>RYJlAA`z&&ZLNl$ojWO0;V59@W++Gr<LJZH
z1O$<xTbT{V1#L?)A+CU0@@p*vwfcLx=2nGvIUm@vo4i|g7}hE}KMhF8)a5?n#~8A}
zTOQeYrj#MI+&_%d*r<Q$PKa=HFaSpdl`whNKJJ>8>T1J*jqfUA(c*I6455b3_B!z8
z0{iit4H0P|VX?0U7*35-1Y|mGy$bH_#kLm)Dr|sBq0GJm<bZ9LLF&10BN-va1fR#n
z0t^f!b&#{22=~B!z1$|J5X<S(K1Uy=Nn0Y4uEuMiykY5vA7<;06rq6XE-Z6*GPhzr
zV3aPXCG9YL$Q3+oZxkkeS%7VbwZtU3VCyqiZ&02gZ}#bQEX-4MtaO?LTp{H;h6?P2
zj-&6}bepKps03>3dhAT)H6dH$-C1E==yqlVP>mcp4FS}5qTN_&QAF)?te{U{zK&mm
zsRfvdkb$9KmVCAL-sYy<ay%f=j<!+m){)lkAy$uMDgcZq?F*6y>Rn(>q|ZpRf(Rk4
z{+Rg4*<ErN3DdN)eXy4g%TURiJ?{bvaMC8v6DfU#gLohuN+RChg#Q>(C#EioLwR$^
zHH;q)I9JW-CoX5GvO@ImsAg9QLqNArlDyi04Rk0M`WtNPc3>Ra!|7;0(kO{-gk=to
z=x#!fLmMmhf>Fzk-Y6;5?kUAqByzglX>*SIwbvXP`+MaOSiG&1^(BmHFVC!ZMx}%k
z7O=|MYRM<kb3`iedpcyIx9pzepW6|}K+xKiF9@R!Vq=H2@Xel|xa9HBQ?k7(J>3BG
z)mBhaG?aDFd0Xyli`ng{?ZciFGZk$)vQei%H`U94;ASh!#qqarx?ZTO=|(%iCT#XP
zuPuZmP_cB)WQIQXK8+oBB$blaY)jyv4E`7B3(Yh2+glYYnJq(NAl=kXxsd1}kElyR
z6_M}X5a3fJh`*e$MJ7j!)U)|cX1?+)dgCZ=2VF8ibj6a5z!dAZsvUBuIZReLehWAc
zVgQg%LD~(-VhR1tn?17*7wiGZZv*7N1QHFMi3htjH!Lq}XOw%V`?=V2@7{twQah*f
zq(<-;{_NuyI^`UCuo9{GOkZnscvckf>T*BvO~OTI**rPhvL^t;YR#VF4#Q;>L|;h7
zI+~dsAumuxU$E#jmDTh={?*T*5*(0BU3YsD>eT9FxefWJK`AoFgbqGGt8*SF@}K~i
z+c$qp0Cd1R;-bbV9Qx`28`LLXXK^x+S5!1xt3s<83f;?kGaoA10Y&nDsMLnR@@Uyk
z`59)vLojV&e`+Bww2)wiW#9X2g9kS-t6<b~&nlE$erUF;MWOZeQqhA!(o-OP?R?xO
z&*s;m?UM!F4E#3+OuY}kZYHHE0kEuHvZT(g;p!PirBXo)25<34VJHyo8-UhQr#vg~
zfX6aFQ*l|x#cG$MRA+}zFK>VJ@|W;Wwx=U9h=3Y26Ty6<bD!Keg~=VGJS$L-{<J0o
zZJjE$u&|au5e`L4BRDV+OKNi1P&<z%S$XEtGr+4wjaC?tQ0oW5SKDy~=Os0vR$BHy
z&?KBxdJc%+&O3)i$jCNm=}=iWJ_d^RU=q>r&TnuykaUnl^;%w<W%yWCuChETX$8|9
z4%ufMQ4{ho1}>zm%<MK*2?#KFWQ}mpAq4(d;~m5<#}c7RqrWn;AKvpYMTa2I@&_eT
zTrIMXl{Y)PLWzB(V&yOuLH9Z~L@C<XD!Y|>3l4M#A7naIoOwjS3#CRCsUBoA)6%np
z))Q=XGq?)i=uux=L(-J(Hl4H}3UxK3-pmKDe}R9Meu?o$@&_Ykg}qcA#w$!O3Jf3z
zA2IbRNp7MJXbl#J$x~ZnO*KG$3iOxo^2O!t{}o<-YLSRIA9-sSjjwy;=r#;Mbr?_F
zpGFA*UP$6fY><M)QSvwl6a=ZH7;7Z60pvc(@eaA-@2xEjczW2Y%io9p$}9Zt^>?X>
z<lm?aD10n?G|74pxT=d<BlRbpv6(&eL6zM$e{~aw&X}08$G2oTWUQxV<z~97m&!)H
zV%g2vs_J_>#fkAIzUa({`B#8+BtduzPVRBh`W)Sqc%x8`8ZXbg1hRtR1+W(j<gwdX
zSg(8qqCN9e(&!OR%^%Q=A5ob-wJ{l)a%;Ut!k1T-m@dF}z{1W53<vAovMNw2!uz~1
zb`|VwD<}G?+nRP}IXQ-BUdtUJK~?3;d#Z6@r!gH0{Y7Pokrxy^9aO;7W{Ut>4rIzy
z#XFc2bP?PDQjT$wIWc%yvK?(hN<!7DL>uoefekNUaR6s~>Q%^EAuqp}RwM_hV}@8a
zSH$-!X)4?&w|tfa5^WgC-yD-ERV#^7ruc_Sb;2lNPs>}A&x})OosvL-ljKCT4p>$6
z*&Ez?$TA6T7kjNRBww>DQ#WN7`yi{1&pC#Da*ovM3#`2O9nQr<y=IAl?V+LNCTViX
zfz<-!omBg5zZO?Cj=*^2R)To72Vw33*=`3+k}}Etd3Yai2Sr!2<HT20LgF_6{N>y5
z^4r)y{vvjZqcGZ&{4d}i@Ja&k;lb#1*jX!UYoNHm65K@!`avf59`AUk1u%d$c`mOE
zu<Nip249`-6OS~m`F|JwA<p&XBr-){*?s6AZ~p7^s!#cuJOj3Dvq$hPi(}b)x54q!
z${hht*$R)o(r9*2Za4rjfQiaqO<7_dEC<R%F{E$=M5D-7&26_{emi6aEo&;c&utBx
z`OQh1xH^DOvL_{lp5$*-TTw_~U#+8^AChx?Oe3wcQaN5u3xpF4q2e#l1jj~Js=BV;
z<&ZNcfDB{KiHjSufdMo@Y#nA*?;(F|b*{kH4i{O`mU-Xs?s^@<9@WJ56L8W-Ub;?u
zDy8Hsmdcyt(^4@3@j0lsx~0e?T`(j>S%g%8Wb0z#SquFRTNRRoJ#mxE!W+>$1r}XO
zU3Hp?+mX|L36s~>839A4TKwKP?OO^e^dLl+(|kc+o`-rK+<r#RJ%w4Zb&;bpB~O?g
z&Y!&g0^@Lu!sDZR1{{@T2ZD&f0Z&q_Yp<q9aji<WT-#oluO!}#F5D|2TW7|E&qq?8
zK0HrJ;4hi!1Twm8$7k2Wa#+qXYnJSDQ)&Jfe-%Il)D?s6My;Zr?IN#84jn*YR0#*#
zW$MO@w5_Fx)Zd&M;@`gf`D`DAXi+gzg50#Izgp2c*Kk9Ww71}Nu}<z6t>H7d_coPs
z2U(Zf&bY~e3@L$z8>xX=vahGI(x{Po<+2<3SMe>LjwiIjm&_a2ZdRlHa+7CK1()r?
zf3?ox<e|N02edhuY2Dag0SR>A^{ESyHKeC#hSyM<6I01~VJE=Ug}-`@ary0suOCVn
z(2{qfns^jo>o33n$QjYXy;yCaJ@QHEkxju8EY%m{loGqf$^^-+jw)N!D9V8Tw${ed
z>69JWB>*K=Y%Y~xp^qgveJV2sla5M_Tg)?C)*^-(`uX3V@o9emUc^3J(A$D$6oOjG
z>~BPW@&r>x)x=g`C-FxvskY2x(8j8<{Q`^g0?os!$xY}(f7`Fv?2r$t=qp+61%emZ
zCMTIY>p}ZNYG%-Ftg-~?A!><1SEWHwOCJ9-1ZUaI0nt#ok+$!ez*M|$uc|7**B^|5
zSh>STj&<a&Txh`|qvH(i2`DuJ;18$}TjijlU62NfM$k5H$9`?2m}mU;lWS<!a?QaB
zxmd>RLSNAbPQKmuBjm<e0fbUc#~5-YRWDl|!$O*@KOD3G%$0Jl&{^x+@-l!Yk<;^8
z>gJNIf@+82)Ix??4~aD{nU&nX;<*B2Nh0JuW5=_AMs;FMYQnaTj#s<G5@MO+-?evm
z>S(@MLg;GgDxEu|yo#?=t`@#Omj#`*xbomQVt*e*!=%Eh7?A)~f|UrozA$jv9(Kxw
zVpJe;uOc0m*RsbAPW+fyI@wjxf~CuH=>q+Ips98QaDV@!iz+OhJlNy?qIR|-@E)%H
zWd~e)F$q%^yCal5Oz13HlX6^2Sdu()_)}CIN&zqC8f-hHP9@@RY?`aNz$~S4M#D)|
zl3m6jFDSCqwTCSG5*>6MXe2KPstDQA=6Piy6NZgal^I_6SeVVV3bb$aImKU|%Q+F(
z&0|_1Skm?-24>FqYeTYbM>A@4VYMbW!5fBfrhITnC9G$MDfmrol7~_;VCVzJ-#DTy
z<Ed;(%}{`NMItQJcbN0_{a(OM9odn@+a*e-1&)Q1R~|gvI_lY~<N|QXsub6u42)uv
z53=Hxtm5QdjyV<fVh$pE(0G`T{=|f*v5sDg-uG<3uu-Ho=7W8oRIVRQICvEjp`1Cm
zI|gHeiH2Mc4%F>31Pi+mC9>b@j1c_|W*Rgp9d05q&A_ylm{z*LdLO&vl3nH}kHF0M
z=I^bZ*?&bZh+F36BYqA15bs5f!7{M@rhKTb=fL$I*fw5JERD1hL6#*2d7nLJY~a+?
zRfCal8Dtwa(|u&)x`if|sbXKE3cI6+6^8rZFT!`p1{#SJU7&sf*!E9M_V_k6(7dQQ
z(!GHdWt($cl3<A%3MjR^sL~b#?2#kw9xC;fE$C;rb$GbveUvGSRz?;QljY|mfB&;}
z?WU|t5VAfhFvXX>kW>MI3anuM3pqKj*9&Ic*4SvKD@q|N8}^eZW{s-CgA;g`<wOU#
zQAr@l8dOpx8q)yP|MIQWjJz*37&AC?6vWt)XC})25<|2`?d+eFfE)L5r5=`wV%bvH
zzeez++Lc`T)n1$2mRpp=f<;qNsTFv}!)b-;!9|xnPDU6KpA6$I`~Fft09vBaA~XOM
z2gV6^n0wVVw=Uu*uYV3NKS#hVxo+0BR|O?oC?Gf~jtd3t!*1>tMfza{-V$pzxJQm9
zz8S`v5|$k`(u7sfELQzPdSG<&^yW&Gt8A{dPOUvzdtF;yqIn79=)t68lA}oujuSMi
z9pOc=q}B~azftYAmP&^H=}|+2FnCCYrghZvd6j4c*pYi>+M27^qHQ>|!63;+qg%u&
zivT5H0<1zL1<24&9w`G7Oa)SbzOkvManKIM0<uAvs?>5ufiG%AC5uP+pzO!*f0SCR
z{>^1ZJLn@|T8ehV60r_*$jz^Eharm*_3Av_VSWRP9sR-oZ2t@V0KtmBbwE;*G+I$a
zoV07DZajB71~|>5R*JtAQ#^N6E5b0MmkNg}xm`%+_LsMxzyAF7i?^Ri=rYvb2G>;f
zMzEJ;8Mu|;I-k_PS8WQ}!&kMEhUq&FD><JO^>5JzSqP7U4l8x?7qw-2qHWQ;C&zZI
zwB^NCf)uR)NVU=S+fceQ;qfqbu@g{^?@LslbVdZYJK54{Omq^mtZmg(k<@Qi*!8$M
z)oG*d*4+nPz?}mXgC%TE5!&83#&Tf^sBY?$?Av_rpw76$+Mpf@nfYN*U5*c69c0U3
zMbZRF5;VaU@KsvI|49W(2)5ByyMo)Cr@S(H<Qe!F7MkFpE0+mT8+G)J8PVa6xQE=R
zNtDYWhNGIqS@qYFGw)4STC7|*olv7|Ma0<%0H6d0z-&^V90H^d0<6&CvsT6cG)jD0
zntDGN$)>ZfVLM(S%9HSXQl8CO9O^GE=8gjjUJDcQ%E&uJph%q^bXlexM4R|jmWaHH
zPzbG!PU-od!t1Xts^dYw@f9ixk?3F2|FaElrBJI#OM!zrZ(u5;tLI>dm*@RSeE#TT
zTN;}*4Hf@L`GB6KA6has4N0c1(qbvENC4dFyWY5MSiNYGxUv%|X{jVYlY=;AALXFh
zWWin3W=eR#OJ&(tPQDfX2BT>xR%U7FUmv3`a*P1Z697DzDyj)5>to;^{Y-~}B(T5n
zUzwNzh2dM|;2{Bn4TK@D+BG0`*I?7Y5-cuJ%y_L#2E>fB?+pSkoN%OQ1Rq>8(^A7J
zj%@-88ap9Zbb5?~1V<55;f|Txe}DZ#lFea8KT)oDalU$mmYR0HXjePqm`^9~6o)zN
zrtg|txRxL0Po@|SGDD3~b#DP~-7rc*w^{Z(0Y+G|vl<53Wh;6)2Dk@d4{_8{tBzDs
zOvn1l=%=<qg(+SyR9)irWGi?BCx;YpQG(xW6E%%kkJK3R#`i19H6|(OOy8@da9*uN
zpwv#a9FnLTV@wh=jD2@<O{U>`sv(hSZ;3^mElDj6gJ$YzCU%P|*Q!XVeLti2VN-C0
z&f*D}p%U+RACbK$_B}w}#KwiHSc>N>S(8ICH=77t`zS$d*pDk4G{qsM*bex|7!L-p
zXNDuu7=X)iOlmM{lZqz%`IJ5I8_D2t)SxkYSEak{h<X!o^+#OeiD;%K4`{F^!o9}S
z>f~DjdfJum93D&i%H9otDE7Gz8`0+zX=<uJ&h;yo`KRy_0b+L$L{~@)Dzz1zzfAT;
zo!DA))S~XjoyT6Mnt&GR*LO_k6yHx^ig(1KsTSr8)?j%u8h^C#8tv?qmGq<pFAFL1
z@a4RivO+FwU>m~Sonz!|6n<fE5S!pWF&y>sFQ-zHX~~URA7$1abaHIhdN~M+%mZ^Q
z=#{D$DAdUvfbp>O6za2f+L6c5v^fxk_Kha~yBo$V*^SR+#^EdfxZJ8$0(Ei@2mF06
zFINbYv59d7NF5a*D-lgb`it_A3~kh_Q4{-LXl7ID4IJF~82?)S`>)l%!`q*~eDnG_
zy4tVb;-4>HT=sRQwF%DEooPPWMsm_j6UmgLT0f0>feP*5Ndgvt<>Ap)Q4{%iZTEmQ
z^@G>nyJ{eDcF>0{N$-X`8QO5Y!--D81C-}2)AoA|pF=N+;vlbW#@44UPFSh@3W?K1
z8n{iTvUYk$mG3G`5MV&>A!Fs*vQom!!MX)m!Z(qKImu#<h-`}794fD1kq!JLxx85d
z;oRF8EIeQ{IB2z#1U%$n5fkg!Y&l<^QDK-q$|SKPiChA7VuuWr_eZ+=!pjL&fzJ16
zc^Pi9#b-AT(h*Cch_8{$7dcX2DRo;m03e$Kl_`e_Y^XDLLJArzhO^uO3rJb4r(8qc
z<C{IzvGuOk<?@VBE;AC^w3Jh#$x7WR3AjqA#W%p{X5$#gO8yB)OJkB2Y?+YiAs-R;
z!LE$|25A`?_NZc~oEGnU>LM&U6;7NZH1Ov}>6{(=(+RhX<H;)C0$e+Y;6)Gb_;ytO
z(>AIkaed`U+QaGc4_IQl-U_ur8l*}G4>IjC%yc>jmA^Zp3GPWhJK826)ItI2vgIin
zG9&z;TVxm-h}OoG-6@+ux^mkA<;j6)GK~UsEY!2TZ|#sQkm{+D1BOy!2FKG%ScVl@
ze1SiC{V0&DoT$pJ%92>$s7<2>+2+uNv)!e*PsAGZvMoOV8B{NOqxYsfDyy!*Dd?lH
z0}ED3;Nx?EXuq6thGUj!a0RkVpJ{S4eI!2^C2b9DiH?qKBfy&N%32>)O6Cwd#cg=r
zLF*d)-OjrzqeAQe;Vo`iITQe;w^t78l@)UNK|Qz}9a}`5&ny7(#F8iRjw_24Qq~XI
zWhGKZtf?Y_blf=gS!GKH2hWCPS3<KPh%gXU09d?c>uWO^8A7LYG;c<zz>Ob*_X)|1
zt>Ae*BAs+gv(I|(6*VzeRtmPGa-k<{$~FfQn5RRk#~J@E+8)mhLpC8;;5*M1lCwq5
zMpX>`AjB^bxWnw=ky#AiQzLOxh2phYXut#6-;sE)B^!n)HxTbZb{O=VY)@2}8_;QB
zj(9f191-N8IAElBd@HCIYRhio>RPB0ya(=R8;5?xxoEU}SX>GXBW1Qxz<?<#L{k-#
zy=c08(u>b^#%v{X!a#27vF<RAI*B~Q-x=JzP!5aI|0R6SN|wUQHp#BW{v>r;G7)|r
zpdOmIUAIY2Ly3ND+}#u?ZZEyu3-@6Fp}|F4+Zz6&uI(&$V8aUVj?*O@+bddXThFL6
z-s~3Hss=b#d{QpUuBARYfW1Hwcq*rHblKfh04jK{dWoD8i$E$q44rCM+C;CZqDbq1
zu+5JNRJLLK!{{d$d9z!yBmN3?a_biqxR%bDwF$|Y!!W~N*35~ijwvbYzXZl~x1*CS
zQ|!HCcY%<q)IrE@wO86|{Fp%=qRXUYnS2BUl1;J&(etF3Cdig96%(P;qWS9e3m(OP
z)}b#gMZwE61}KQ>HPjOc$K26gt7906&wIeJxAF`d(IbSIVKV1y8u$MB-~TTBvwrxm
z!Td-L0Dg%eZMB5AM)?L@kQzp?xd6rfcEguqi!yv+wTWL1OpQ;6l;T^0aCJCdK0h6C
za_-$G7hfz+le0Xxq7(Dd4O)W)4tEg6Gt?Yf7<3qs6U&_r=6-h%V^~&0;odL~5E#QB
zT(cyO0zZLqD@d6x+f}yfYzI7sp6DsWU$f8ZM&^wkEj!)swE~W%Y^7RhduKe)<s8PA
zWEhOWvU*4AA7vYcZ4QvbFPV4CdtjGX!WFc?N^5g;YDi++562lm=@-S`*vc#?#k*n?
z-0dM1aO#mCz5V?4b17hcDgXTa+s^`2$SFepNqGH4@i@kEekgF_orct-%7J;eAVD$s
z=;TyO_Js{~QKj|=8*(PFf00a*ouM3Ik0{H6O<T;{B#T;*2SRG8mybaDW^Fy1$)uu9
zmCV3xmZ_{U6+bZ#f|<}gqaig6a4NT8kR@aqn5(U;=BQir<LNXsx)O%m1C+QHb%u3N
z)grHAN5Eekbt_Tp7vc3&OqSZ`=kt?er)dSi=}eJ<OscLYCXaQ-0*RHe92+y2%W&u*
z(<1yRRrYgm2SwR)u7(8lgK4B1uA0_>5ODe755vFLAN?=kANA`q1o15!lYKsoDx2mO
zkx9iL-70&HfGe|%RCgYm&Mz(NEwoc<2D!0zZLoapM&wNEc0D4{W-b)kZeVBiYl6J;
z$PHBh>{B89wW_qZq`8%<ZF$u`JwfA>i0-jop%NhHXGNrH2b^MKdTAhu1cH#Rkj3hC
z`c-le-ou;3hkR0$M;Js7Mfr&j<{!d;k^f!L<XD3w36vNK%7&I`bs`a9cN6$1NhT$)
za7n63O)-xsZS2N6g(9yCZ%w$a@Nroe2<dnspgJd}D+#0J!A#t4@N62=fTsrJ$@qs?
zD{OS&jhP>@?75DNIS~Smty?m={5Y#zz!r7oGq6_&H57GJR;30RRCrWfto@V$K~-Ud
zi6J9DNRe!@fzzFo8KZC$=DGF+au@}bWCuvDv_W{3@XyFW<B`Aj{d!8{HXVJitWYF>
z?PX#ML-HYbGZ0lckBPZb=_D%C?BUtu@sx!=OHD!rupW72Ns2bqzc6?vl(RsYYiAlP
z`KYrdx4T`QE6}8`<a~n_Ape-H(thCdw$)StXMyGn%eYKKBMgvbWyGJEHY!-)U6s85
z+D+3-`vzuS@<OMQ6F$jg3LwYlnVB~JI46_sIv=51Dr;$WfT?0Y*M$b)!Cmrv1~a%U
zgQ-+gDZ0S46|m@ctY4oqi@<Vn7H6diOx5Ss_1TVh2V*;MXn-CO>^F^|PjjS#v@>;H
zORRp{rWWB^yz_VEE!(Sdf!lG)It(iQ5i#QtbMyAImoLNXHy7pDz%ANc_{>dg)5hYY
zgf$=r*Cvv6>&w!>qVh5`3JeNp9?&$4x3#S*43xtKtqD1E>sC3y6+~BivSl&1)!d0Q
zgk{or6=gov8cz)*e68s~1gZ#e#i-V;TqLxpWvv{+CAr3^hLX^dLlah$6^I&BQDQ2r
z59^`B_N7-zWlMvhm>)&R9Wqq}ugJrbB3tX|T(CHwDtE|#HbBjt0?Y3qhOM&t4Nu)a
zzWj-E15KL^WE73$F-!Qv%g6D>U;@5nRTt>_sM6dvNT3~3?@Dze<|b%|b{bl9PxpsR
zmVQs0$D7J~SHA2gpi7tCo1ja=5*Cy~hmO+RMp%etQP2khIhY&Zp@z1E+yJVwyA%w4
z+iueVz~WL_pGU58ze~94cDG)r<sdl%=FQd@tezm}`Hoo)lANm&;r(&wqx>D)%IE`p
z|Kms#{XlY)0<9s~%{aqy*fp?T+6dyelM7HLoU*NPnWA33T2xhzgM0hw_y3{_%WBLR
zH`%cRZ3m;s9WqZCb<5v+*v7;T>x_^wtMGpxMV65dP%8yoKKZ#k3OM*lxICl?oe_cz
zMOf}Cr)672a{dW|`&yl1uI1V@eMFC0urQes=WFSt(jt0=E-o;t=yDAd`Wzjsn)SKr
zBNMNN4Pbq>$DK269Gpdi2Rf{{`ku;Gz~INXtWZm+(aC+8$VoLUKH7$km6T7tGjBjR
zS3H>=sBX&m2oL;^7y9lf4SrRY(Je5<ViVIS<@$}<=)?tpb?!#f@e<)?t{=yDOu6dl
z25V<2{Jfk`c7=1Xo+(~@MJ;BA?@R^klEWFqY_`drM*CO=r6v5^mtRmVHoX4>|5Gmj
z_^2=kD{+vA!79GO0)XvhK<ARm<30lJC6`WJs}b7fP8#!`KnsLv#EG7aq_1#p*>q$q
znU<~P?73R<tVIVb0UQq><o*+N=5hUBb3ng=%ng~q9rBexAXwY&%?`Q{Gj%ycB*b(*
zC!l~5J2?;qa{DCb&;6`;Z;j7d%8Xgk0K<x*vmTcms*&9XLDdj=(iees(iL&VO#0Y`
zL7$Z7>5?w3*#$#WyDSXM7g_d;r3JD9EH}Aj#gr59JFZH#PiS$C2=S91lWB>fASVG4
zvL7n%N1D;9O+d93$9d`i&@t3<r0qap*U(y~Km7wt7Tcyc*Gp=hm*=6u6#Qcc22_&g
zu2z8UOm^og^@$`&%v!(_E;eWR6zY!XZLC4H=0>Z0itwheC65FR3h3O?83zn1KOFNt
z>vX9#_@w48ZL~R);tLWE4iqin`exA)LpW_AFqI9J=1p!LkoC1xA&N}{$<+d69dxJw
z0~CxdQHhndzTbWlUVeRf9BeIVQDiS73d!0&+tvIxTJ6=LKgN;sdE`%}&OL1!)Kb<V
zldL>jsqbSX9QhDKE!tHs6|rves|!d*^;4bJ!V%nw^tttZ_u2)bs9T@|tf>UW!*v>|
z6%D+GkFNm1k)k%-T2~u&BAg<dK;gM@H&`eCp3SaEran|5%b~8xKJfr~++;wyfi*<%
z8E9^8QWO|q4^GG|BtyYLf~wD81(`y~Y^*)({np+AqKi&~CiZpK5JQKP*fLNhJhN79
z|BP*BScMpjRO%hHYtSvQIc_ur%NQzhHtgF~DpjdmvRgdhF~UCB9>J7aPWVGb$W-?r
zv+>ZaLUnXi+gEjY%Uer~t0%d&MMY}el)Y%!VF@LvK5Z2E0y>3rIEjeQ@ymj__FBy<
z)&o^qD0L}31Dx)={k7K?Q{h}9;^c^s4}u*m`@>qX@Q#r>&X$U#S`q~0U3vMe%7YRF
z3uCZP44<k%Q2<|x>_%Qt*Deyk+2qGbX_Djzv=AKv!KhSY2ZP#MCpFir{P+6;#8T*z
zryAF8l@t{s2%B+yQ~MO#ap=3X=J}H+O57pae%JIzlF|yuZ_Czz*QY9(D(BPc6prit
zK@}r(k>f{|2Drm7NU7~0Tgj18bhh)dLw!Dc76iR9+5ktB0|zITkDwQm)aGGdC82HD
zW$PW`SvkU-Mah;jla~XqFUaOBE!<;CvszWTK(!ur*Sf}Nqt8fM0e?dxudG#1YUD4t
zw@_^{7fpM)d*XC<>ZB)C81m=clXGT`II0)3CF!NYF9~!%fT6IA1)#Sr31F`+s!-LW
zf^Xay9Pky^*&Z|QF0^FF_RxT{QwtbxZgJ$o5of{E5n`kj)e);ziZxdO1x9g3{ia?l
zZX%cg`KqEE<B8YuCFMdO+q|OBU<hB;^PQN=tDw(1GZ7wI1S0^wDN71UGjjYnyEGA$
zrsBahb~27wi{xPb-kI*Vh?=<YEnyWwG-=S@d_>#JTowUQ_UeR0YM$(v0#>B9!?n-i
z;(D9ffD?#-9N(3C<op2E(GL7+8Pu=IBB3unDeVtg8|{;Oi3Te2DJhV;+QSL7jfz~}
z&xBrG&bAOtx0CPYa60F2lT)>7q=L^W!Ct(fD!D?dnT%!E;2O<Y>l!ROc)}x(qr-Z~
zSYZST4?t?dN&<S+>lWAD%>`&$mcwWjEc<&c#9Zq$OBz)P)t1r%aT$A7&%2$@TLVL%
zwQ$IZ`a(NgY*RU#(z9V8DjiU+)lFRZuzvyrSE@xh;5!QN)T#y^R}oA)pK-jm>}Fzj
zZ4Uj_1T?obS4w)tzeMVL%bWnYlFaFmMqfP!tQjA>_Kj4qGt1*F{<mlM&Id9T*zmL`
z`Xk21gcw7-WQUC&R$n$qz{j-E()Pk5zlswN8PhqGl*k}`GpkRr<wW<YMw3-G1nhs1
z2=#8165grjq4c2g_-UkHwyK&<A9C4~O7XU5p50Z>y>8^Wzx_WYL)0n&ZM!*bOw=p8
zn$DLkQ)U(Uv4cet%_!$E?>#aidzgbd87g34V*w*ehI7SC4%6d;6NHBn{>vT+a9oq+
zD|>AREo_6ZLQN=a#3`Y{k^rL#owTwty>5v4=ujbY1+Q?`k-M;&LpCU3bzzEE!sEym
zjjWknRep%6l#d+UJ|hX$Ny$RKLaT@@FhV7RBK>8aI>|E9tO7GzR<e!5OEE*i0Nch+
zqie;FMV6JEuj4U3Od?Nq?E$Pd#`PRhT-A+{*&j$q@x4`uC-c-=$&e!rWhR*emMK|H
z201gyLY*S@L;GLghj?PVqXQm=c7JEfz$vw8@ZZ~x{(69XA8PjOGSCuJNH#>XIY4(@
zLei5OQh77CQIi*lP@`Xu2)wiE(KB<rl42EAO>FJltW1=XgTM#lJikU+(|xrhZ>?HV
z7iNhBr8U8^3^%?B8o6k)&Jw7T1-h>UI&CW_fN&no(#13M!S1<4*=vysQ#AXC)V6LD
zMMBR$+5VCZ+1qL%q_VfvFVg1Kbjfxvxo(=W1KejecVJlA2!7Vq45r{xRA`bb(Tbp_
zd6}dF(|M>5+Tr-sOdMYDjX4Nto+^o%iSU9YiH=|I-&Mv*G+ZS{4N`=}r-m?)S(o&R
zXVR`wQOi!jJ8DN|zvk1Ut<-+Pg0{hh<N@iJkVzSqgw=GB$^QMn@N0Pg2mBiU^k+~@
zGY<U6@OpV90e*Q{Pn#cG+D)Ae+Bs1wz0;YWmgbGxR#nJh4FrJ~i~*69>#(1RfY|}|
zwlEF@p*Eu{z)<K|?Sgm~5ZdgZ??Y|@47dqYtap1#c&O8fSH!gg!l@;CB~j<Nf@69I
z5A_{UreD&A`ll~nhu3c}x)3Zg1Q*TxeKE!MNuQLp5^l2=jSW<VsA=wNr;VFs082o$
zzaJeTmn~U;U?fpo+EV=tdz<e7;bu+og~J-Dkrpe1vIn@-6ag=#9vwMs(Vj4)zEqZ*
z>nGlk+)psbu^EoadQ(R#65Xc}J<0L}??*)fccwc#!$XWTa@yZq`ViX|dfEw8rMQ=5
z7@O%cu%|u1_l}!SLF@BraZ0BB889Ed@E(YL+DP@uAo>7d?!8SrsA`7CO1VC&LrB@A
zt&kj*<-4PV5@!h`C4}>EE$&`w1DcOHsrmTw00cl1O2}a1Y02x?&K`*@siz8Tje;cU
z7OpxMbyd0xX=Su+`}3YpgLz@7UDTz$>bcuwF+-IwpkZZOt3v~gQj$49Wz2pLH%SI)
z&BB0GEwGNv<^>_7I2AYFy?%Jsh53pNX!)SCoz+|Gq?koCbA+YOj_`yZtiwKvB3K#>
zG2&aMnbtZs&QSOW9X2(AXgO#`ki>$eE`Tc~APSD!(CIFiiyW%!UbUC{pynWOMW}W;
zzM0V~Viu7-1vw3dBj7q*$p9W`d;%ZX6L^-_NZwMo+AI+%Y#??EwkQuzWOp|iKx*m3
z+gTrlGx;4O148I*l{AF*<8Fsd3snW=_>fywT5AQhgPd_|b&I^6xFm$#X`N<u1B|~&
z){?ueEx=xvQqETyHRq{ZRwiw>9tNn_c2Pe%S;pg~0zMPn47ebKb7L2<C;-4MQhxCI
z^YHpLG|#U}b<;gk+Bx^&AKPS=G?+84B;IZ4^O7nfyVIH}RV;|XI-c$v^Y?^^p|zd)
z0|tkJ!~O%tMf$NF?;4040tv|ja^fWZF<k&q14jW`2I#IjO#c~ZX<LgR#5&v(Fj9hM
z(6*!?{jh_KGbXxhfzY5HVaAGB99MK83O?C#_5LLWL)@*f8<FG%(`c3O$=#<quOuz0
z;KwuSVHzKCOP{(8km#gJTFDDRmwsHS5}`(^?LA2xqLwCEOV$FU%b?QYrUUrZET8i!
z&Iy!yITeypfI<w@x@%Z=3!)~H^YSP3dSEYuWOvB)(Q(2Am+4F+pKozV$g;70K1pB7
zW%LTzYSH0rpKX(%aa~;M!V{ZX8)6pSTFy$hhu4;JhbXo1BFX1Pn#C5V1jN}+V!0^v
z{xWZ3qXa}P)&kPq4(#7~Gx)aaEy@==u&3ZnU0|lybjmC!v8kBRI${1@SYtvp2Kf;P
zTc5vtViSQC{1lyLkZAM{pHb4GR`tEfEJG#%Eqe8?iROF!vn?cbO9WCwIOKHBm0B&$
zjg1<Wa%shDW)kdfMn0ex<vth+d2=Dg2~hJ#b_L-7gw&YPB8HHxMW7yV*!_t|_6T`b
zJ22sp%2Ke~9hZmVVkf<PU*Ev1)bhh-&*0T2^_<kLa{niP962V}!(PS@!{0}!w!R{+
zBTYP+cM>7GRI}F4bbTfYer}(iPh@Ka%)*XBD{*%R>BF12MB>9m=1?gX6Nlx6{t<tM
znOb~&kI2zyHX*rMtr6S4RV*<$u2z)XJ$l@E%5GV`0>J@GOuH|M{#Sc;i*`8;^fJxp
zc0yp<-i<s;OFFVpRrD9tngyX_*r9BxxE%Kg-skgh8*T~&h~+C9CbY*wN9Z$UXT1Kw
z9=$7;Y?Y6(iblC3fLqvKxnvT{f#!xhMSTA~fMZd2D8BVRX^)f@+<dCcm#hVboNzl>
zfwE}~z)g6KWPjNTbg_d4W6D`EJK8Do4&u}-2cQ*hvO0Ej3w+wYC<Bz(3yo>u0N9~C
z)BU0?Ar24IKskcRRF=DX&Vre-*ijn_nnAW5Jln37f{9T`W=^(tj{V#JSIwof@o<aU
zhfk8QR%oOKyM+GSv0vKxg!xCzs2Bbf){CS)qb+R8<X1z?GdaFE_4oa)&Sr*Xidk^b
zAnPVmh974Yg@w^IsOW`jUVw>62KEeZ5leh-yGqRQ@ky4%^S5f$y8t#dlX}uQRTvF{
zJn8>H72L@ynX1^7uGs$>Ea|9U;Gmc(x7`W=H%ftE`nY&|d&EUOICWid2vmS`W2~KK
zcS{8s3cI5$P-a_4*f^ZpWQn!V<)z5U_vGX)&KNVUW(g)A*rUW~e&P;NbEuMMocGSq
zPQnI0kRP2iozZSs-53$mHgLH0%mgRCpf89yL=+X&z;NMmf``&-5vh(KO`cRWcTAn^
z-hna=Uh5!1x4;u-m#Z(=>X20kBPwI^*2XA^-{7z?+df4}(9A+@4iF^Mn50zT{lgZ3
ztv$7CFnXM%WWc(#b7FGCp-55C3qkm+Z=e<QvcZR;v3l{8AA{?LN0l+!D%TIeDNyZq
zZ=+8dL1tJ2Y?zkR>I}(*ORw8<8^FEdr_ya<aiuB<ui#+9%+U+FVa}(StF77*g>o1;
z%tPG4lRCQvAhp_v!tbMonttxkSjh}HWg+TWHG?y=FRj_tzal$O+2ewgrfVCaRR*+v
z!tr;hwiU37ENP?`;21YfPbidKRqi^m^~cNRz=v8h;-q$Ou;_(AU6Bl!nSgT3f^mVv
z%6fB`5eRjH6HoJJ$W<%^0Q3-)O6hcNvPbb96m9vQ37nOXAMvZ9aKHbt?T5%6y*$ns
z?p=Z6uvc<-2S63=g#ZZC*$E(tz)eY1@gd58bOaTPweLZhNHm;M67&6yJyr!J$VmcK
zW-{0%3jq|)0!t=kit>~Va+2xBwj-p4(ikf?tVs0ZmWkb~aBD7+Vq_Oe=RiqhzkT^U
zy#4(9|Ks&H>H}0VCGQo(<1WLCM94Uzg*2x<;32DggFc#2SUknd!QL^Z2v_b-$<Qxw
zojkFq(M;1U_asvRhZ1X~wF{v3@X>a`{5Fj`lM-X83o(AAG-}~l9Xfuzh<pd7-f)yT
zaFGx1O@mTT%u|jeq1dV?BV)<&X?OtCqO6kMUr+zW`uey30KdkShOUEclvoD>F0cYC
zz`07BQ0LGIXsy>g1DJAjmNa6nc|lD<+!>Jy+Kz)Sg{QCW0MKEj0BVaI{gK2V5ELzD
zpuBgN8fA%X>4=ehjG||aJBZ~wWnKO*YH`Ih?%08X2qZb*p`f#Jr)lRIo<a6XBmlX+
z2M`l{39CcM)^SpccS<d(fauzmB`(C_Fc7GvNhHRE<k6Ryf>Ss=b28|#Z)cwac*+1G
zW6}?qqNw!q4bL_`tD<qOD5$F|5=nx1@X!GRBZws`rcI@Az!jKX69bMG6p6ria-Psc
zl6_0*LLeqmN&Z;iM`O|RuqKtdXxL5%zeXO(+R^DiAAI!8vC}=y3@b^@)O~83>S}XI
zVF*lBvOAOJ)tdazNFM?hA}(8}nyE{pZr}JVPE@*tLmlU^<8y+ZvK)1Ca;L_OT;#Kj
z1pyRkl_y<TFW~C%K3IkMR*xN+RLgu6UVav@N%i6no<Ada{1nlJN;axNsy$t`&*ZQL
zF!qLbd^wPyQ(v*jFg^mDR*tEe6CB@bZ+{Lusdyy@s+E<!Ie}DFE@)|ra%Q6y6Ud}9
zNDc&e09{2<I9b&yUTJ4a8Py4S!GPhr+`gt%#F)zlxLr1NJ)ka5m|OvKP?>qJkg{F{
z(!;~>I^Yyo`X_~lnn<qdx+b-9g!Ql)e@oVf?c&BKvVE=~7E}Edco<3XA^uIP<lPo8
z97p8zxX6jKYHqjNB}%qe0^){3#|hVO`ZC;o9t1Xb6mN#7z1v;qs-oqJAeIEd##h#J
z;Q+!c0oq{IN@b}C3I@o<+pwDAK7q7WDnr4_o?3Mfp4K9xCmG%aTm6t|u5f@;dMN83
z*#V{@99)<>eF6iEKgo*%8-7py%^|BLa3?49F>|vg1ocrRP3(SWduF<M-mzS3R0w@x
zAe8u1yIQcS0w#^oD;!yx%2sG~Qm9g?sH|4)_(`qjI!p?Egt;O<8kX$s7pT#`i=V-&
z`DxVQ`sw9arTa#5p242Yyv-9k584U|Dq0=mGmbRx`?cdW&~LCjpnrcFYMtF;a^-*8
zm=@SYb_%k<5i^wU!!w1>qJorljdn`nsQ|kLuv;US#pJ4Hc?*t{PniJabz3)_m(}fR
zdtr?dW=Nf+s3?_OEjc6=OiEc#a*YysCDJTbl4$Fh1xbZE&|3?#6{7>2<q}`MM{WA-
z<&*I8r7bTgrGFcHJ-?3VpV+y4MDy0G)W!|q+8g@RaPR_%-;UxQs!TxU_;f%U+0ehE
zWvE2??ovbQtIym6Z%I}z0F|Dsj3kAtlTcbV&$?r{S|vCaatXUu4f+%10z%{)X^V#|
z_ahmvd|4x4Me`g9JTScmWC@Se>Z5XkOh?~KL<fOfj-c$R2k|@UbLDml7ZUKGE?0O_
z;eBB|=5NBw=NBaw8Npd1)j?*cB4VrxbgRxaTrmw~u*WTThCY}${9!C*R)d`0PmU(M
zv6CA^Jz!6jiP!o?fqL@Y1wdrW8aAbco<<*;_Aum?doMT&y7Y%qal1Yp?O2JfB>#@(
z#oK?y02pVApFnHoT02W+t|5*Q#cUX(btz%#0XOR294@-umCllT=RywxsWvcA$q7Wx
zam&3dis{Oh!>U6t*Yc7z*r#+^5}_>_h7trlx$U`@oRaW%yc{xJLC%}xK~2uzud8uV
zmr4tXPeCh$iSp2+i$><)_s2(ehb;_du+)>pnViK4_r%L@H9t&gor<$vX2N=8iAXS!
z$}%HFevn`}0zq$q9FVU!yA9`Vk^Qa8;)`NlH>z1Q8HCL*70%VGyWBxe8ucT$ab7`v
z_q4`;Ch-G3Gfgg_`Q$7B<@Xz=2IZDKwkLHYB+5t!fh-ZBWYR)8O<s0~^q?W2sq>&*
zL3N4K&k|4p<IaaSik7kC?DAID_=o>L_^m&fm(GK5v0a<v#BM#Zf#W`Pvjz=}J<lGE
zX=lBFhXo`SKvPf|Zk2I8PfJP%uV6^0`9)a)F1b4$9o@9SpEAJMQm<RrsGky?>g`Wn
zKa~If<n6z{d?o+?J80T}4qbcHJP~soFHlwy=(dFqvcWWEuTpLJP@A-!R3(N|sH=o3
zxuRoE^770TTHvUS*Q6{AH%G<rgkH<u|9$%*xCmd`gPqBiM4i<~g!SfmtCH|MjjE`2
zR_<4~-7ZuhwuE&hW^@X*%yW0WNM)LQLf~i|a;Io}vY~)^C$DVL6t}!2)r;yGJ5Ew#
z^^7c&>rm0NNnFA0$u=xxQsvCD)guS@l`R2GjV$4~PyJoNzc%nO6&l;n*-0h_m^5$?
zEp?DfrM=5?^86|S-3`L?vxQ!e606Y)A#Cqid-#T;ZB8D!_bMqbs+11p0zs8pFDe@m
z%4N40jlSCC1-6PD`9u-}^Mh9&%ALKSLPa_F+i!A9lCoXeHZ%ZjVrXWVo)R7|0Im?X
zqTUYb=*LbaxQX#Y20Xxl!JnDlz^H6>c9PVpZ1${(7hahGpx9q+@xga!+FSyIa%HE)
z5z18ytm9TgJ2`~_UD`<n6(o{vQ0uNCfbC{81!qzZ2@IvqAGH~1XAL!NSAwvk%z3Gp
zqKysU$(^J|^z-a&huq!T$hjL_T^ho;nhvp@IN8>$o@8efXVLD`@scIrCcS|$V2omZ
zPGOdVr>|B1!6rWs#bv~Yn?eVa@XC@C>eBU{=YAg?t^wtQ2dfW=fZFC8W))NKaMJGz
zA|%%1w&!4}R=9W#+Ro0cAT+IBjjSjTgRG`+)#||R>>4)Z2}xBk0_mU~1v{5s{}NvR
z2vACAmhd1N6Eu@2vLw`6dRiBCv%Be`A1cugL0VqznEb5d4Wesu2Ob)SHP}x2FP^p~
z>QsR|!zI!wqdtmcWus#kd)PtBF^1{`Mksa`jbQ&)PRN{l(EnI0&9GEw#wVv#e}Pg_
z74<oL24+|zCO+<UXKt+GXsJ&i5ou3a-37=bwPB<H4^ojEqS_RdZouI~B?nE>P^E2>
zLKCu<u0n95K;c%oda1d6u2r!+`h1Dv8&)j9G19?`*&ZPMIZO@uQ<nksJvXc9(}=Qd
zRu|(c9RLm1lRXbrs(tyBetr&XAAOLmZ@0{$%M6!gb_SA{PK%2}Bq45jPs?%gBiSA*
z<>wAetny~mcsUpdWk@{%$m|-bT}cS`m)_*|TpaYIgM+6gM@I$vbWPp?`k)0heG77C
zSF8#7t<G|S^&2R%j&a6WZYKe%iQd*Rc%Ai>e7tXX;%w|{l_8rp&I~zJjCIL5r-2Kv
zqzL0l9~HWm60`eq&!6Np%MXkkb||!6ch=wQblpzV>fvy+liOYb9BIw01b434td|c1
zS|?BiK}$7hhyoUCXg*Ad_MSaaS?5hODjFmPp+Q<*+L=zDz;dXDE`Q~0H=6^!RE=sS
zm?b#?6;}XlHEPy2bRN26Xb7e+XB(O{YjUzOA+C|iU*<d3blI2}L!_1gI6-#oN%VJ+
zjlf8?OCCi=M&}~75Jx^M9e|=qMFc=SB+&7!MHG_Cp+32{*HzW2R9_sROiYW*<w&kk
zD4JaF0J>Rl#8jZFJ>z{=l{5{2PDyL3A={AMKmdac>KFyoxGVWH%CeTDOy{sZ@OJ%L
zOz`aEGTm^I(DSzS2NH68IC5D#rKgtQpuu56NmHp#G>F$GZ<F2J{;-_h8SIWNJ6@$6
z^r*v#KdE4(MWA_TGX1}JtKnMoUMIM%%rb#7X!EjJ|8Au`8jTfmn5!HR=+=y}x;=H4
zswa?`R<EBbJ?9R89~%{&4sBprPauPH!M1yLDiKUME-s@w&lf=R2Oj6jYNS3h2on>V
zvLl46EoSBJ135t9$9Smy1f9ubF;w0#)~M|E%J3Lf-?Is7Q0D^-Ia@scRn<%jTp5%#
zJA1K;Gx{W|zkFyHUvwPesTVZ|rKmU&DB~^c0H<Ab+nLt_(8t*Fqg*WqC8$HG&;}lY
zq37d35o9tuMwAtt_ExUE5`ZWnaVS+<c#5b*z{oCeQe0e76{8D#$}pnj^?|4su9E6K
zV=5J&W7{cbC|1xww4PK;3Ml&8Z2Jws=h-u3Lx~f^R<4{C<ZPf~m&$nU?2;kHA{W{E
zX-*zyHi9p)65)m6#103{*-iD}O+ju2ps0vb>;Ov+4^V)F!h=J!iVcTh>b2itVsOAy
zoMh3VHw{_^BgGYl9<2Dz0=U)5U}u50D+QC8CTkOt^DS5fITE4SAx`SZ0x973?NU>6
zx!OZ_!LrbvL5t=_d%}!j%J%%8ee-W#zKIJn0*hY0xIBg48t}688=j#CI!2&Y*I+kU
zxrWtb@1(+%bEP&OY6%}UmEnlE7gIUUG4tp219G%yfv_*b%XeS^mx%{<Z<lQcW$8UL
zKh0A*FC~4%rQFR2B(5RdVB23a@e@NezCBcT=&4A|EcHpw81$JoiyX!Mr0%`8WMrQ<
z4LqZkYy<Rec8WCsZ}^i7BkYm~Sk+Dso{)y{u-sX_T8PiQ%8qs2vE64=viGj1S^FPS
zpU2wUKMpUkg)LFA1q-$J<M|!v$G8(jsr82fXE*lt)cxtfL_@um-L@|qo#1_w40UMj
zM3Sh4J~T7Z-7Kr%DrC_GtQ{AG>sf_i@(Zzx<q~DY!Vgb!V%k`c47@_89gXivu2)`3
zmvx;B2To2Ko(MXZl?9e4R9+J%VsL3*scB|y$tz^%nN4YBU%SVAf2iw)WOjz>do<@J
z1zHXu4q)IZ)dg9NiS(o2qG=1aG*=YKeQ+d8qcoN5REW;;3Z$kiajsHmOA4QO><rkr
z@p9@g*aq8cfXR60z;*ygn9`Ljy7|Vx3ug572`pMw!9~MS`Pe4NI<)IrIW8o>+KcEX
zDY1{aG5XgqA(KOqj6YntxdX{z;4O(wl9CbvO0EA=$r>j%?OK&PwmAip`k|;*G>B7s
zV7aW50dQ~(uFZivc@SNvHwn1~n+C{6K~JmlpJX7wsE~lN@p6>WmVG=>>F}t9(fYCz
zH<w5Fu$|Mm64!r_x*(Zcqe0YH+Xa%0b`Qo$9x^q0>nA^s>)i$L%2jUd$zC0LIs~1S
zDz*lbpRskgPNCJ5mszo$Ruc`a8B_cXP<Jw!Rct`}weo&v0vE4Ug$5ootkT_Np}1>%
z^X&&Op9j<Wd+2=I?dX?ewuML5nau%uiYp*nQp`_2W`^}$D{mJ=NMLMsJK40Lp+pLp
z+WGE{iUJKN*<C!=t0y#Mn=C#49K-bzl9C0JR+#xF?EVA8NM=yl%Hdmu1c8e#NTD&u
zTSxa|zeqr`FxBjUz_K%>vL_xX!lREJyOzF185EGWoSK#&Q`0hrGN9>XO`isQ5*y&F
zNT6B^%2ET77Qz`+f}bs3SPT<zBMVgGK>Hji5f#Y|CwR!Ij8y=fwdBD~rRh+}+));#
z_p`l+|IMV~|1*!-Q>`ndjU1Ub63V2ig(?BG!mECo6Ce=&!s{iLcqiBk@Ff;q`;eQ$
z_5}0fDgxXZRnlr&GIg&llxF*03YemDf>Q|)PZK+-LyUH|jZgY|wq_q>*Tk-`{DIwQ
zjZ?0DcIz<AFn9rl44o=(g4Ak~W|ZLQ8W$w*qIml7#Kiz57^anSNOedqCH(wd_-9#p
z@R5@x2W_TK->G4S0A{oRhx=9rnzN|^`-?_ss@#E7CZU6CH%u;pj7w&d4~fd#s`caz
zdhyU<uTcveriBG=cSSyX-_COKpZvhVS$RgvLw8_p%THsJNw8R<si`%XGu3X&-bvPe
z!}ildU3Pn0Eq5p#5EqqvM_Q<hS?=D0sW$0}o^j9{9t$1a4))2VD6!NemorE`4esE@
zyN|mRvX!^<`eT??a-^`EzDI<PeV4}f-Qoicb!DdvxEyr`Q5X^QE>&M5v{7zB-<#zO
z5l&%iD$^b$-kLmLTQqNf{`w)PQZTRjL}G%%c=pjx26@xYIh%Y|1*<)ZfMyZ~$%F$-
z3`$G++1Xg>IEt(pC#sb%WweRQFhy9Vy(Z?SXK}RgkXRe<vrFZwDlVF!Y!>>+!8zGe
zs&iHJ8iEW-g>WAorGx7lgoay^vu0TucI1ZA(xYbgZh@-xTdV+(slrHJD_fHRQ7m`7
z3ykKl3f|~}_4;XuUm&5+*hDMxBCJ;og<KwfpVeAkvZ4iggPTe`uudJBq@qwUS;PW*
zBu%B1X0jhENDNxK1L;F`tWCg;8B=d0TAiw<^q!Lr`z@1jhn^VNr>ewwLi)+sXed;5
zSF5ZiflC}Ne;fWmzXPJWg+49BO7$mi_GD&g5r9+*6>?=RGwL5((T<dgi*tTL2L}0d
zmG{lMLqa;dv!cM(JxS4kVqqEfo!TmyHVLRIP^zQ0>mA{c1HZR2`#TWeEG>j2vO!Wd
zw5|OlpXD_{gd82J$$*+SbpSGGKhvptLgU<mq`D)_d(K#nUESLudPN(|Z=!M>plt2U
zo^z@G))R#8An@R=j_k=XFB16e+TZ@`%g=xSiQ{(FY0IIF<+z*&Izx~4*?D4UTXN2{
z4~o_#$)1`SYgH`JAIWGBJXd&_sk|8E-o19{RZwx|83|RWL@z3%t2S|~`?6KZx>Yer
zmd$~|!G(LZ((UapUcL@5pU3-<6e~){TU>7e`jGHqqJP?W9;sUdw?|2Nh(I~yDVjDQ
znwz0B0yW?tayAu3B8zwXGs}XjX&KQkE|-$K!p}f<Pz9xUnd%D~_j&CHOc+nPQ3JZX
zkEp^3@g`KkRwQ*{+&7>_BuV{{n^2bYO0cgS@iZL;hu?d8u-}7lp*{FI5LrK3*KDuW
z^ysrehy3Zd{B?N!ReZ2bl7(5p8Q)mCH!xAdApPMvo8?ydbO62MvOY+EsNe_GyB>DK
z4g&~@5eL~YNZ;K^dP&pjED{Ns?nOiwSdjK1K4sJ#T_$<WG3pSaPDhuVrIgPHNL2L(
zkq#0nKa&*E`(Ry-()&v-fx#wIWai3Yc0kC!!7UhuRM~Ohtwx)uoQrN&526J*DMkQ2
z%)$a&(S1h#{0v8hc7-pB)K-Ps-o~rYT*Vv)bjX(;gH!<as===TS2xp!Y?4q$GEFz;
z>B*2x+jOY!&1ISL%5kL#$WTdBduT}DV%P_r66Xy!m?qn}=?Pbb1R_#h*qNtKMo#G4
z+s|MB9KQci{Jjr=;Fl1OHd{~7tYvs<y#88LF0kn7jXj4kE7?qmhP&t{lPRfUL)zKt
zE4NTM)ZV}b?u*<|YshFP2?bR&(;rSWrXMEgUX9p^z_E~vKBbXpsn|dJ#f*2+HJvr9
z6G5`s`FI(c<|D=N9_T%<6Xe(^cq-uuI!V0;+cI7vC;p?qN?3BVCgxG@1!tc@r+e{s
zmaUmEQ1Q+gOcBbvW{R#zUqYmZ{BOBxDE@37YnO`tGIIAd)Zw6fazVR1Xa9GRsuub^
zk|_d~ntN9d{;s(S*IFYQ;}%aZq~s`-yw+FfA>yBs$dr2e<_6e>5wb5%DZe31w<d+^
zeA!10v-WKd!9ezDGh`ZUO(-$|0#v1Es_5%O84q)J{~?PHxI-dMGRy<eO^~y}0K!%v
zjJ#YSeufsW3(pj=N6F&JpA}QmK)Snht3;!20$_K}fYqJP;`Xr0#Zyd!Hjwg+1c8%=
z!oA(7nO8$K4Y+a8lr<R~x9f_Mi5;qvhz*Qcp|Y%Yf}CGr8m|z8xCEYoHHhzW^@Bko
zCbXz+6_(XIQmj&)f@8$)tb#Kzzg$z3wydb)P1_erS{HkS#C{xJzm1XOXZZYkEHYI;
zCczyb<GLyk)yEPNM&Yb<A!%b3l4qWL4;Tm1o$7+^5!kn!;SXT5Lmwh$bVkH^)?$B@
z?%n{c9%6PTcVj`?SUUwVuROoiVc?LZ*Y6sH7!uobwX}#lXLmH29HQCIYT2X=J3r&0
z^KprrqPK<G!fmUk1ba*x_@Jfiv^Tr=eUdMYD4qC()wLM^3@=~B4Gqx<6R70T2`_Qt
zFy1o>kkkyb_QPKI4Qy_LWB@&5aiahYFxKP%ZHb6!RA1BwY*i!YnnCWeTJ@ssWXl{T
z0)mJfess!w1oj1yxmc7{GeV46^xG#n^rolFW3)NdBPv|lXB;?oBF-uwz+o011C^w9
zFLosW7&1p!l4ZUfIxIEZBgZV<c7WJQicKzoH*o+x1ji*~OqW#=$Zc$)iil=SRHJ7+
zgF%%K0OSqgEd35#rS%vk15s)o2W9KrhkdkEvQmW=w0SpKS1TQn<=qtvr#SMTIy|+J
zf1?x<XU85o$F%V=ywv!&fKp@#P6Zy2DE{{U4kmE-?BzOwd3Hx;TO=kyx2xz7@V%Bv
zlvs4up^~i;`)&XHU&23|bQaYU4+>E|s^jdV2Ki3OW!9E*F_9(Zg4@oKlQTgP85hvt
zO$!dIiwb}6W8ZM>fcGj9X&tcO;4gYo;{k2shukZrs~tR0`f|s}?R1FbIplXcKfNKr
za9MVoBXT0KkrB|&p%%of#l+5uOV>u$(q+8%;2y#U$#&i()wzkbOUXTGJ22i6E*bwo
zgjE(6?UX03JvmI#M<Wwx3AgIRy8i9!pZPVs{{#P1Aj`#&ac?8(N&;5%Fj1bngnJ#(
zub9F?`muMReH};z*F69mesw75eL4*Sn}W*T<vz+e8S>5L&oZ*mvL*KvDT@umilaX8
zQsN(b3Vr)zFG@4enUaZ*VA^4K#fc^A#fst|Elz}65*g8p<>XV6O}Ep=&|z2V7}Z;}
z2za!mp{g^*ab7aia6gkG++A2U?WA8KTdo3iieAfIkoVgj8JD$e=ThPh>nvI0t>V^u
z*}e<MjH4t`S9HEv5avhdRW7!52w}aqDtoZHzLeL`-fUPO?GQ>w(jfnZSk;OKrAzEJ
zp}M;3#cHYlFxZD1(pflqK9g~X7S0M140@ZGV>6059ZZst8>gITr`R)Ei87eb08et4
z)wrgyzH)1fEJAHK!)sxv_Gb4~tb@pryuB{FU~p<p^j24;x=%q0S>?-DRT<$9hRVpD
zem@H|qF@&s_v)hM-8-r;vU=tz8b!nhkZdLLAv}ohl|KQo_)}DO-@pmtE)o=`Ibvym
zWFKrIG)~I{wv;#mOfzNJtlgl7&<)$lK6~y|K;&X5i)-uM@z@r$fao4PwvyW%naK&r
z@b-Va{5F^$n%V?$Xw<6uP<2uINlzIT^tgKln-Laux64olD&?u>b5}(GuU%$dKz1rQ
z5bUrP<>fq|C5?bU1IvF*o7Tu?Qp*ekw}KjqL5<-lKmnq+Io837=8E^R<z@@j2tC%A
zA1B|>Xrvaeqq0`C-0T8CgNvxIy7ikkzDWkS24tb!WjSERfjrKN{uZgMeGbQXaU*!i
z-O#UwC?-YEYDL9j3`4v+PB|8QS@0z72Z5@|u|8Y&+IpyuoIW|5c34?1ZBh6ft<h~)
zAnQnrG_-JQ=-;@bsJhg(1X30));jl~e4g=eX?8wg1Y|?*$%fA3bO$*-Zx<V`i~xbh
zV;{;y7%m@>sgngoz~!N*r<FIL3`#B~yYFgZzwx*LX;3|AiQ>lI4X!AUl{Zg3<G$nB
z_MN0v-~UKmZx0`rP}1Bttm?0AP_{Dlg6@zI`{<lrxk3s>R)LgIa_P@L_LN{{MZ;A>
z{~rTE3fWjB6@#+6Wp|51r7A|M9UhIkv|C(K`{y2p!qz^N(WCT8!g{(d%nS&4q6I8n
z@N97a8X-*y8a0!?G~o##wW*5}8KfpACWkHt2bq0aR7%>wq3><*?B*n-g51vk82%o}
znU7vRw~R^o@JXt>JjH597a2DfOb=4i5MmaJ$K(8JR1KrbWLx`<*Db35t3sotBqH;F
z1gw(Y5jiH+Xne}mBHFYzB^;4kN;NFCr924d%xNReWiOY4B?cJ7;Jfw;O1Be6@&*u8
zCo<}A#1T_bO$*X#IYsU7s&Pwwnp9lhEh3l7QIt6p0_D1CCs+D_5hwWQb=-#pXWns$
zXPhbZoN7yr28OG$UQ4cW5bK@^u7F`~=uf6vQcUJH?}Ok*>Oqv1az=WGhpCo$qsSXs
zrM_pbT1Am^w{J?@XB5c~IoqTpai)B}#H!0HJ=LkRSUVyP!r@J|n>o*xqnnZd^Bmn`
zY;k3qcK+>bp85j^Q&Ptt+YaQS_W*j5M4zBZ*U_52*H+3_YhA`4B>i4hfN!`7pd|5Y
z<p(%PiUWWZ?!ywd<%9ZUgLSLDJK2;H7rvsB6r{;xl$%&z0s&LHvNO4ecNIuzGTHH9
zSP;2&u%RHCN!(s7OxDJd1-rb138te{QJmE7ZJ|Oi;o6qvrP>-bT{;t>Rk*e-{4^Xw
z1x3@1$6@QbZ-ndQb}=vpl=6g`Wu?So6xNcxqv;z{<V9kx+`Vk;q%bF&94?83Y4o}=
zu=^pzLUK;CLyp>N21%DYd1YI|kyUNv(q_ccs?%r%&@iYq1WmmCNq8k+vVi#yhx(Wv
zm}ib86{VkT!Ah~)i8rr?z?wXvfIroT#`OQSxexw1y#Ip>gc0QM=;U(kjJ^@~iN2kU
zTk#UWq_d@6#Y3E;c~$9vwUWa|m@U_5lJJ+|<qyEQ5lOKCxRex{Fmy&PWB<vtxG0OH
z?@Lx91eYN7GnrPUWozq3t1xsBwo1y<>w$C2uz;&1P;=rumO%cN++?{D9*nD&VJc+-
z&ksRnY&&Q#8Q+>Zv*U_1!=fLX+}j0=EkL$T=}(ubee1Y!u|Ukify&V}y)6{;Y4zR?
z+MG4@m+TQ}<+)0vmxQ2Y(@EA*(Q1YvSF%Ac##j+*TM(SLcslVgEp0Mp?&_~ZsKrgC
zDzKKH<WRPv{R)NJ2dPAe91cz|TZ)ZBX;u=Y!Hc4p<b>C+E^mJcvjN$3wyH_dnX&7N
zkVMlY4=(S1whY1f6i~WKf`M_+<bnbq=h(<AKTgnby7Gqq6hlF__lX|5d63(n(mjoC
zNCB=u0cuYxg=I+)77R*Kx(DA6a)q3%F{)aBW{rAGJ1o$i<7}B>tK}`1S)L^mAnn_>
z8wNB5${UOhc9x&=hmyX>rmR>CywQ5h>2&v2&5XP#Si;?qnStORDJ9X5yGp&oguZH>
zz+E1zJntu~;o#BBgGohsmh7Fl@)f@_uEgHVldKC9ebcl6-G*AO*)_N&w6z?PzIPr&
zl%4taivB9f*-9a3Hqi||{mVeCgsE}0+@n_*bM7Ks*}sI3djwG?E@N}ioH*yNfqy$R
z7Y+;>FDs-ShyZTYEpsF45(0gMs4WTWKdFBN)yaW)nh64KDO>=kp$fdyL=xYcsa7?P
zS&NdVloQ1s@!s(wbmFkj*v=f|K{w9_gQ~y^Cs12TK=s~Pt;6-O;)AojrGobH-fLZf
zOSJ8?A&q2(2ZOl{9u6xYqVTb0PDphwQW6C%D=a<KYD6i{NpIx!(-#w+`P8uZ2PoZ)
ztLl)-H&NoRlGm5!{s8*9R|3vySjkhz^%M;u@mmsDQS2>%6B+Xaog~^uLu-TsyU`mz
zAm&ibRW;I;kP4!j)tFM3+-XxJ(cubsmx@$aGeZGNvrczzEg6gzCjhGPo1VybFW>Sj
zQL#3D`fo2^zx{72!t?)x*Plx*J>gf`G-pZ!dbO)#DvVjCmpD6c{m_h_!$V3MT3Ixx
zUTpak4$qLXdVgoQvL<0&NU>17N~(XGVX6OSJxVZ^10~dy?#XJ`O`vy6E{UTZt=a*{
zm`~Dsw-<#(>lFY(HZ$NI12n_PX*`CM6`>O6Vff&p$XDnkT^U)bfvU*1mMgW6U>`L}
zyTSRxTp%HVjtVx%jL02Wr6MZ<EMm)Kr0SH!;pqy&=8?b>7*i&V8)W9DrWeMWk}dfV
zBO38>$zr6*6c?Diqs=3Ek_{s7p+Aw`C}#5r$|(iu`W^M>3Ovt{#LT1l90~ckrIO<j
zW_fna?7?ZsfhL$wiP~?1QD>f^(hmifD+Hf#da}E_Dd5=S55C<A&_eX-FQ7_0t5Am_
z1o#cwns*f}C{m9Qs=;%Vtu6n`;`=RF2S-U!CQyR`82pS?`In^4D}Y@sPtqbnOnr8D
z(yq@{)@eIur6#fYCAB!eG_6e&ymCzgG^S@VtpKf^IkfA0a4d}onpH(ODw@Nfmn&sZ
z>KiImQJWnWsyX0>C3Mk2DuwDYs&Y5(J~i#Y?YQoGyqv7bdnk|t&j6`kz`(fS)CjqN
z-KmdYuZ7expbM~?`_BfMT&sIzrPJqX&03cv>X^HAZuXApYX;?hpg^U@nOnSJsSZqT
z4eXnB(u7)S&IhF2$RCAio~44o7_is6j@~_ihnEX6@1aJc&Q`*(QNnW4QSH{qClwjC
zGg%IXD)1R}YHA->dao^QiA?0{pof)ASkaoj$!ag62^T;q&@JYP355(JfP5^;&dbk1
zqtmGAq7|S`Vv^btuet7OF=yLCxgf46zGOE!cQ(n&u1PhVn`?~0VK{8h0xv?>(Fnef
zno?f@<(_JZy;KdnO5!|3u1Mp2hH79X7ilAvkC`PIttE?s*KXq7n#@0W8c~{iOvb8!
zXOEI<Qc`AmI9prQStkq+?Ui9zvY)7xP}l7>&sMG<1A*FAA>OE2y1|WAZnQE!q`X)u
zx?&k<D3dyze8Jwy0?*U1J~gYKLH!>u;AOUuP}p`!Xqn8Kd-tztrA#BADB2ex3CC#w
zys+JBU=P(Z+PR<6yDTROwv%3y(=?G>I-kjXW2zH^&lM(eCCXb<V^c4jQucWc<*8my
zz0q$hcH(}8b75|m)A^@dl&crbvs7GU*n!HsL1qHv5B9-BvF9YDB$kxw_9e_H2JFv(
z_U~RnWSFf1#?zz31h~xTM+sT5uOxY5jl|*7Wi9Pt$d#iOWi5CVK^>RlcT~?&I2>1Q
zl<0Fn8HZOTc3=x$*rrH5`fNxgP@}``@6-@L8~Hy&Nk7Lv+FVv{d^ZM4Nu4ycTlElQ
z7Z@766CXtt`W?8teZ;-0K7%6vO`3jfRi@Buw26Cf0)1g@h=dv{MZxf~HxpdDC>J(v
zvgsXAFBhgm7dLl>$KRKVw0Zp<9J*e9s{i~*u{U4o&p$96&d*=IdHr1Z7vJKaFJFYW
zKYRJv>xc21w;#Ry{`L27fA;!2%L*dmE)D8XJ(Za+Fb=9GZP>ckalD}^7+t-Sw2bZI
zPSvUGnM#>Bq5Lkq9KozA-oIo`s0-RVkC{n<)-(mcOm${d>kSls`5SL}#pePp*B^r_
z!o{{5=mG|p!68Uq1OySIr<r7jpuStE8-p$F6`hCmvPO2Q<X?S%VA@CIai7gPOD-nD
zMVqV%4)s#LDCaO!^s}Q>V1w+&nYobmIh3*jEU!dPvW}!0j9NQZ*(w19N~g~6ES>WM
zSaM<I=3PpxX}>GE-cuvxEULA$y}w+NjaA~Yl*->p!a=2ds5xTTDj#wU_L=OwdLr^0
zRZaup$sQn4gAc1uK;2$xtlN;Nl9O|d=?x1buvL<3UkoGY?%K7_Y9DMUXIY38c~qFH
zMZE+bp2i6ZlGbd9I`7Voi{uH3L*`vn)L1v%_GzZod9`{|!9mB4Z3+Osg0#|-l_kFb
zl9%mjFA#9kWtta^Ra@0GQhe;DwKPoZeE!mcNE3%emm^IC&_e<1?a^Q{)(f?&?y%}O
z8L??6E6GLLhTLWOT8?2rYhXSASznlu6Cen&Lp0<Tf7#W+3<xdy={`|xhTwe_J&d=B
z&OpCgHy6Eb1M&8|ni}we^0Uy5D%(m~IH4&!VvQtU7+j=elG;l3H&(h8p}KUoNr}yo
zcIX`217c@(a}L0Ct_FH&V--{j2A)fDXbZ(HaR2KuO39#I=XmXKNC<Ux`5|@tzvS=i
z@FrMUL_~}6-TU{t!LqDwyC;niRcd5RKv($I(Tz&HC{=Q-?Z2Ak9E(Q+xJ=o~mia*1
z;OM^P=$(_W1a;(iZ-eLB*NTmBz2x{Yr*u|UB@~;*(cfB9xK%28LNHMhFkO+Af#A=n
z{eZ0zuUm4WW+E151N?*y{7Eg_o64lxK;N$$no*##>8fgWcvUu^+&w>d{qyS=RQNo7
zV}})#276b3?K4L<01;R9S|XW>ImkGRwi#|2xM0ur2ti^#h^FZgWhqxGDS(e)ko?Qi
z2F5wu+o?}$7H3BMgn?9s84$*d9E9YOeaZS&?RaA2azK|^RO*BO`t?`V%eMFMHDAcr
zQmETgeN4}C-PUJ%XxCKbuWp$GVxdQQQpv`c#`<SPf(k1Pwt~7Z2;CDO^q+tNRl6+Y
zWLX|@fR+P+^Jp!o{%~qW?|mA-t`aOTg|@>YfVKx=p1I2aLDfiDhvW%J0&_!6#eIRP
z%oSsmm7w8j)~Vv)8a$)y-V`ylQQA1CXx39ITkKKHm~^P6xmtdDTm}-y=FyX;d{&k%
ztlfK+US#sv-cPEgH#pd4{XmS*CJRP#1<a^{qU(tX)?qKC@D^x&+NmiSOb^jmSlkuK
zfu!m+UPRv!8X(Rm?<W-q#)#Cm9lF`pw_GgUR$wQy-Cp$*t$zlm@g}*!#j}UPXV6JU
zV!KRwBqt<_6i665x_8eT=kCqGS?-pX)r&;>*~#Qp!VF-Jg9a1PCIwzWsR{vP6oKdK
zGK87uVPJmS54R_X8OH~reeH|0x(2PBT}xspP;(i49Ihc{8#Qh$9_^uo(#^O!(dMe^
z4ICoEryYPo*hsp3z+^K}D5S00?JV67_YNV^c#+^8R$e<dfg=6^>nP*8eW(qq1%EV+
zre);dG*-C@^EZHi)=cQ3+A){M48)e_6Kv|5iJj~YFVabV*(2)!#aSUF2}C%R5zs2J
zgbhm#6%`(~{f>uIGm>v^t4AH>p(-CL!H4eIg$_{F4=p74M$iV&HqI-$zjx<k4zh0w
z)nz(SEuz^g)uKQYJ3|9JcTw_C)=y-}!<n6f3#Z^`v0P>oT~0J><Fy#>kU_P=F9(e@
zyUiqqHY1;~Qg%ush7RE9e76XYt6%{9PI{(5*kF(BX5W>o_Q&I&&*X(rIsWyV%iB-G
z>z|S8g*&=o0C7LN2vG-ZH)7RVm~?MVZIPz~$Im+C?Kt5y0V0}HiF>;wML*R~hWFb%
zSKA3v_=6vWAN(MG3V##dIy_CR@ws#Sul;FjddX=EVZyD!!4vKoVkyesfO-c#t%krK
zxgLAkSAbOP<dM42M~{F>xIcU@k&kN3%cz3V@p<j^L{g`5^OD$Nb#7S}6aZ)vv}BPw
zKKcZ8+9cJ|fKa)@dO?^abTvB;eRw>|Up}+OYUH6E$(nFM8{T!-a|pWu1uS97u0YFl
zh+HW=Jzn4B3vyL;eTh32$&s@P_?gnc0tPznA)%#UhIyT`vZR8=2obSs#%R$i;<!zE
zDD^vY1KAfw=!X<nGf5(6XD&u6YWQen3>*?H7M45l=H)fyPz#s0@UWMoqK0`9#;6o&
z5z!@XP0<^6!_|7qZ@zo|j$gz3Kj2sW(?>=bUtpS63Jv4jf*XcnLFFkGJY{AD{`(+D
z&Kc_}RS$%0&Lz}8MOJdHRMs?RDxp&Zu*tNwcYDOarrS5EjXw&M|Gi1tLU9@!#-ztQ
z7X3Sx_43>yN(sC+6Ug1QSBfP8P?RZa1B(w{Ka}eDe~OD{QQypLo9t|b6iqnfOI9Qj
z5!BoBoVAD~1|a5gP@;P5IFdQYYO(2{%nB5ZJ(ti}N*)GOy1*quZ}wXC$y4GQ^-4L9
z%L9)MfDy?}#i&b>u^`sjy*XtmIuX?b2HOk&HCMu~fs`C5^tVFpY@l_lQd#T<$DLV$
zWTxmV6&Xo_sBbJckaI_#ih(ncdA;MPe$9H+mLwcQ@H<okvepFUM(K`*?H+lwDtn~1
z^|snaoIJR&wONQy-R9V$+qhz38gK2pG7t&i6Fg|&DZ}$HjrAL61+|1El4q|tneAAF
zCo_`fMxs$kfJu()%=S6~pfa7aQt`11gayS1|BIL31-MvC4O_Vq)doF{wuBHrY&G_Q
z`RugJ;q=<ZX|0fU5iu=KWgt5Uwj8MPESe1JpWH^D^mr|(z;hQ{Mw%P?TDw|#606~e
z^wW1(grBJo@axY*{9;EH_8?00_4Iu|)nrz}E+}J%*;x2p1`Q1hmMbL_uCnEcaxXD4
zEj&sVQ3}+)k>JKHEb*O-q0}K+22fhV^!4T)s&!wkM0%)Y0R5)wXk7_|`D#sF3jjSN
z0Vf7yR7_$D6&E$_G2zso>d)hBkA(v0+EyLuc+$tT>ui!pD2V{#uxl#Zv1^c5wiC`c
z$a(};Y@RC8LgCvjE6tdONTKW*X`g3dsW)y4nqx_GaCRJDdS3_5nP5Ood?)ISoU#LG
z+qtzdsu4NO?<aGr?%}SdvRQ7ne_XJsEe+u)@4AG?AE}{M3dQS363}j{NSYotjT5AJ
z>l~5^qDej}khehv=@`&Km58m|6bkEiFDU&+@W3zXWoSWE9ts<Q=w7Q=vzI?PtXa5t
z_8N}ItT^SX?B}(WS_HVv{(!@`ZKI*UirUzXdHc)PKOn2zRO<{dtgVsM!)JBd&N-g`
z{e=csLTwP^4OJAj@p7v$g|gPXABnhXIaCf%Uvpb#Fz;d?8r_JTMp}}3>8xdQ`;|<)
z)Hw;2`W#%F7`{`WHYtdGT~XLh`vpUQFz<3vPlm=is9qOyvpiYxO5U<iy-YLWbBE=d
zmyiFgui^b4#3iXTmz7W|_3<SMeG9cUrq!irC!7hVg5&R3NtLboE9fMxKwf!eTs0^g
z97o+(4~a^5wCUrPQ;vqZ5E>Hq2?b3uD7?N?UqN2`NqtYr^Ho(LIufEWOJQ9lmU$8i
z6><9wz((=snYUV%h!AK{tsb>@1h`_9DmD{DnL#XSSsLiz!dQ?}vg%BUMuR+t8&~%>
z^|a59%)#&fCH$>^yN_3e8DAhHYQ-9K4dcfN7iiIcI8J^aO@aq!&zJ~v(iuB#!3d{!
zlr7F1$2ig8uABDynjMp$6)sAF(7Sc6{;FVA=X93tfo=!ji^^YFHDs&}d*~XjB?OLR
z03qIvrRT6qt^P=wTfppTiDy~Mv_M7Ka+(UxT9P_k<Q?|J6obXpP}#avK3II}mE!nT
zxGG_)i>9F*AD=is6VFXn!?eq8eX!#T$CR~C-t8k&eC4RD)kRU4m=fJ8ZKPeIV?coJ
zw*t1(pbZ;xI9W#IQnC-h%{KBLu$a7^W)#hX(=Pf-XD9mYe+d8hkN>Ejen@sz9N}x{
z*UC+}7v>J-E+@wVKdf>AD403yrX+RyTp_4C9uYnZj!#wND0J~o#xu6|t`U^v_z;EV
z*KEf3&M}Tn5C?;!4V*E3_Ra=6AyGEQdn09X)+qXe+=rZ_Ov$Srl|=Y`%f_xrspbkY
zK~X7@%(X;ky!DCN1;bP(_kl{0K4``j^a!KAn6qbV5RzOQQ2mh@@1T${GmDaw5KE1K
z#9~+1coLn^zR5X5S5u3)B|rWC$FJXnx1YX#`1&<C682UgiWCzKjQ(h!w7ZU7ln1o}
zrE8ZifaEYH7ugPMeCE;Z!U!X0k|xc`foK{j`~Y4%3UG~3^2kR@1(=iMGp@u|26lj_
zcpaNxOPCAW{;+7fXT&w#^QD_1it=Qk5Q7^_9&0AWJJ@64xw3RA9X(XM=GXB45B~a3
zIT_^igZQWZhm-)XaqAyd9Uewtm-;VmDpjC{0CiZ%&b#Xzfc|i6JIwui>e`B~l^S?(
zWk!SwNhqCPDJhW+kt<blUz|)(Hes!&SbUdix1(yRg_=m5PD6-9C;|@UB!mX6lmhN8
z*O^qp5yNFPy#5w+o4g`@tCBUM8E#EDDQvK)eLH4PZZDPr4$3}6r!;&Cb`u1ZK@_@P
zLlQ@X0?9qLAS`{Y?(cM)ONl81IeH~vL$-yt#)&*CWcuuNy{lm?N8(y)qa#^)t4-dD
zy<0;{B)+}ssVdZ=(RImTct>V?4xEY$4!@Nn;CBiL`~JsTPgq!eo<en8;=`8B51LRp
z)$BETN4&Zca|WOjs*`J*hUdEGe)a!R_GUe{TvwXd`}q}HWgBR<A@zHeyZeV24P(b}
zB6gmbZVcySqzjE2P%nmItKO>KT$D&kBAe7uA}LC$0`eyRm)E!U`c}kc^@A-yyeIFF
z8N=Rdui+a&TtkV5hNvn{w9)O4pD-k2#eXNyb5>s>Gu27v=S#q)tU7081#7@U8kTh)
znphp%9U#1N0hf~BydcEh;YMMn%!BD6zJpW(Kl+iS9V--sZKMLeLOifM;Om-@DzZ&k
zi(q6z?7DsqE?=vfjT1<Z2IiKhIA~rd3p`0Uhrjz_^oi-%QU9sv`yFjs8z@LrSaf8?
zq;XMz);ywsl{2}M#3HV%&j3LRt?Ii}Ke8tWf&{YzLEXy{vX7Sv`VGK&j}Y*)HbpPd
zHGe`gr9AbwRGZ@ymgU%3%icR<1)zPPyNb>`sSC9udZ>Wbd}0+IOJtYeNj-pho;Bkt
zi%5-z2_>xIcET{RME0uW#EBL{@-CL$Ml9LD2n+}*M$UjU`EXa_Qy`AJLnqrNRpaa$
zU)7A%?fWE72u#5OMEN+JVbzMUn|(e3>HGZr?mo3Z;yRp8x_r<9g7xv+Hy`|7{;lx-
z<JWI4&nW2WhCyuSBcsJUUsdf{)K*ecLGX2Dae^W&b|V$)BAta{wUcbJA)zB>5t}%X
zR-<9;8l8M035tQ|hTX74jw<Ps<yBoI-KiO&%hTu!x1kz<g|;&{mnfPEfKwe~2_5^!
z%o{K!b2&lsHH2++1@rhWq}huAM&Qv6&?Lc@)YGVL8zu9#L_B0ql{x`OID4xg{x0q~
z3!wEWaI1p9{DWya!D%ah1{&hNc{O19Hzr-Nt2tr*=peVv?-`f7s&TBVpkyZsoTu5V
z!-@dZBh2o{%^d^OQ<ulCgc4%CRp!P?O3=Buqg<3wkf^+`XDdM6kJK$rq>(M*a)qUA
ztixHkjFTQEYwIp83oIr^Wm(x$zoCf&mJmp105w3$zbg^+i`y?DSWS!CsW$WYU?)+Q
zu`Jt_0IWniLsccU8#;vHf!4A4YE=f61hHr-PnKjk*^hwgk7o5<<X%M@Y?DjSm?VUZ
z`A6=9*?4RdAFY(}Xm4(;@F&tAYUhS8YSztqc8*U^5iTw_`w=!1h@IBdw^%{HCUKIp
z#HTR1%8sH*<caa?G-YNB^*OblXrCn$Gf4%-ieKtY-N-NMd>jwMS?IVZ<fB5XI17f@
zx+^5D1-f{kR$r8ixa!TO7!Hh13tHv;P+NDFK?-iyf3A^N=?T_;8v#2SP1zpahJi>=
z0B`mSh~0*FXzSR)VT($ORZ@R|62n{dLxJFO4s<Svwr0&+I|!}j0TW?eJ97hK71zPr
zYJd!?0+&<|6>bUBxFkGP{o4-u&{bW-I_aWnu_k%x8%x#13OWy{@qi@i$?dB?RQStV
zPAAPT7H1~OJW(OT-6^@=Oucdfgy|>rFrf24UWrlvl%Staa)kNl?d$ORYqXW5imy5F
zl{jlH?xZfTcJ#G${gp`QU2wxdQs?ldv)FtKX;o~iTnmN^p1GBCQn;#Ph!h$0`ll1@
zYUweQA>e%`<3kOUnR1~ft4^>6^f<;*EkfA=N8P%RQ9Gn115}OK6)@aVQ;^oB5{clJ
zY$4?bT}a6W40_Eg{hl54x1{@|rRI&_N05sob-PE2CEI0{Ur3_UrJjl3sZ#wS&eq~G
z1z8GgnL(E0gtG#b&Wq}8@s>JTWmY+Z*kscZV1pHj1m21Sf6JRBXwQe^HH1nlZxKKw
z*V66I9h++;0f%`RfYuztLhjn9KwUVv1l!>1dMjEnaoDqI@C<dXRXf}S+4QH`+d`_b
zHpHk<GwUFJbnPf?DoC4cG)XU0wi2k&;J>QcIFF;+v3e!2Ey10*r8q9owo=<ei{-r%
z@LHZZ;{^Oc;eyfitUW1cLDH+n$N6}sQXP)?&_y^-x&szEUIY)SW)qkr1gL;Lzl<PC
ztgD*YNU2w0JIO5}XY%?EI48pGzyWgFxO_(&2Hu?%t|zKXiquA>%#FqC!Kw+AHpR3?
zqHpZiHrgrOLnN70?Y;(Hh87B#DHyP^iz=y9W6))Q=FQdSONe*EG^x#+;+RPQ{Bu(C
zTnV4aN17cPb9fr(%1M?*XgI$?yP{zSPLiYt5X+uRY}Zm{l};-W1^JFAo^Kg_D=CoX
z4XLJyzm8G>(5?{ptY)s=Dn?F1s8901S;NB6JYeU}JX<x35ARq74Gz5rMuhfR(E4Df
z7R_lXY39SO8b^)}R*C8YSr7+gzH;aRVYF0~TyH>OBHc#p$NUKN#~LS-RH4Tt(#1u(
zY!RNT8^ln%kge#lKd@7?9`NS8=l-xPh{qAQWVORj!ZpCRSzZn|?^GY|di~a*?O-80
zTn$QmOX0pTJcX7;7*YXB(juRLoV!IN%};aO&8OFwl&~Dn0?+`Iw^qUdC3WavsFWX_
zK5JJNNe(ONl>0l6vi9qVj^)656}2O_G216)`fN>nQ!ytR(@9Nj16%p#gJz?{)>9z>
zCNcQ8Ovau@hq+xtkz`w|KcA0*@3ogO3%q}9)__1j5nb?)N96r<JHpF1B0EH|+fjM?
z!{K?ns~w&S)#SI|*fdg6&;Ob^Ex*=>Ymks_<`{IvlQdJLRi~W!z9k~7CEg(=;4CfR
zOIW}U>O5<Cs!wty`rBg4&4+o&f_l!7!)(d?0Tji5xsH%i*tN0a5cIBoP72n<!d@?j
z3Qwg5)i?)IrJfmggr(3?`hHC4mb;+}4i>bJTp0+1bLxbtvVzg6(+w$kzR5U%V8eOs
zqymP!&N}UIkaRTYssD(a2n=Wp$XkMwK!FaA#Eci)Bi^vMr7Ej98s5FmBD?G&ptWF!
zz0Q*2!^z92OQ`l~D&IW#AXih<m7=GvP}F1>qm?3Zpr||U_pd(<{E&Ya9I$UPX5wQV
zsULLfyZXc%Vos7P)!a5c1UbcX8mi^50rWDr^2jY#&)W(~G*y-A_m}rSd;K=NX5`lY
zZUA=J@o-^6pvq3TU@A-&Bhm45y8o1R7_m3-k%bZiJlN$ul+J+bhb+Y9I?z4z2s-3f
zvcPNuCKVU(L^iQTZ6Z7y2pukABc6xweI)&%Ku@4%vO#Y_SeVH-K{JceNcRojOM>s+
zFb1nyZrd<;tp~a0j_51^2NKevK8yHqTS>KN^HX`>**#t=1KgqQ474naHfq6EHYNPs
z?ePI$;zKG3nfr)+PIo`mX4T5Z_y>(+x)gL+))d8r=k$)`2C%q%Nn4fCL~aRpy&{Wf
z<(*#I)<Sc=5x7w*A(If5*-}%@IivD#^VgscUG~v6qn?#2k>Ahu2&CUllQV0UgT)M4
z6(871T?gCROApAHqVi^)Lq|x-s9d)E9tS*9h;`$x_ahg#W6p(ksvECLP{Cn;DT*?;
zZKViwK0Snc(*-6s-&}S#U3s9+YYtmXl!jNjx=KdmoVE3&>5~vi4n6?JOyyQE2}BF8
zt?$%?EOXa0Q!(-bK-a!zqo)bpNNG~nB!GN6I5I@aD4m_euXXJzL@IfZp9Ksm_lt_>
z4)(C<X7=05efN_^3E#U86xG?q0_jPMV2~mo2v?U{q+w^3++^$h{{_htBn5B)$&U)N
z!v#2F<}k2HOC@|1;QW%7_M+Z_<5iWe9K5gY0Qv2f^D+96bL7cDDkWr-<<!Z`>y9%o
zUj`bDCHP_oH)&C39aM;Bhun;%Pif@jr~ThhH%brV(0=r;GbTj4M67EUpASKkDqdN?
zl;dz`8#m7CwgS!c{2bcs8aHc*F5wV?r;aYP^GsAC2>Ojyp&ns<0j_xn4+SQZdxe8C
zK^z*0tyPmTi^e@5q%gdsloduBr+o%9U(mFU#0Uu1m1;k|q-%CoJz*C_UxjLgu+T>;
z9rjWOX#|jcBgx5j3zECv25)DpVawX${)X!83kc|p!-uMtEr3ZPW~h&bG%~u{%Oi-a
z!+FE7m7sXp{WeO3L&+m={n|SiOp!EfG>l}47F$)dM;p@BRHaaE!Fsd?-J=YJrFno4
zu9UD^_DWrOACwu!r(=wxO5g6L3JC!Huk0X6SC`Tqh@miJg`tEtE3MTc4NY=eomchc
zvmLLx;aXsG`5oQ`8^p^p_RJs>vl3y-Q=O;MuyQAhQz7J^qy{=_!Sp!umIy09&{j$v
zgJ87Ez7&`>>q)XlLNI&)mU)|e1A!dJdF28P0Juw#!;<?NQu?feq`csxFpSD~SW@R|
z!xAoK!P>*kbT7ws0D6=kG?80<A82`h%Y%Q#syH9NtF={STZ*v-kZw;~noyP(JtbVH
zqH`!FI*4}oK>>$*C8{j<5pR8*|E<|#J)^N?(dxmIWCQloVZ1m_uxX8;p=yP4=XnvG
zR#JX7z*cJ)qm^S?ZVP4`Gc|au_np>_B>nov!FLT6Lp1bE`w>%&(xoRqfBSuS{gq-h
zueHG<&`p@x_s3uwacIE|?4qM{;9ZBd12%%EdF`gTon$?`U6@*M*U0Z45M#2538x-l
z0+HYZYE#F4;^K_MYf>P=5SfkD%3o^^?0=QH;S}qr7hi&?24hJ8f@)0I{zoQHl#&&_
zzu>Ro`@fM7AMi=>{!XuNsT&nl$m>z+9rs6?)X%|Ir89PQ#C*S;Q0*=DcSF`7fUBs>
zt(OYypG8%mE73ORnvO`MXvc?dch+rjIGW@JCS@U;s08(_qsLKqF4?b|mau@mj^1v#
zy7Y<WUpCr-O3jVpv*89rI1*eEkmY~j2byni9;wi*ksn#D$VpKga4kMYDregRmZB=>
zAc$a6n42(~?27QDcNLriIYI7;T_rpN2nH9)M+HxKKi1=ada_IvmdVy$tv7<gD-|@)
z`p&+}!qtbJ2u_kA%JG!1?Vbz-35HNQM1*eeZ$ev+t!K}fAc~$xhm;g4FrGS0!1G`Y
zLX7rxOOLmw8pc+fb;g<;CMjf0ab6up%bSk&F*dM5aFHK*H9ZEXz;&eC4yt<-8ylEu
zV-IP~gOR`Y0oEQilU;yV8Ycvb+#m~D*(3?t_*rLE(JiiYF(~#r8L004$FDyFZ%#67
z%M5xfKC*zr^Lpsx_#4R&P>y~yKFAi@R&|ecxiSgV{ni`hca4jF!iTUpzi|&|-x2f6
z+5n4`gXDx)lEPq9Q91ik)|?rZCMr*~XMyf3&Rq5YfkWGfADRy@PT(giB!+B*V2`-)
zrl~t9_>67Nn4Pa{n!(&dNtslH(Jpa<)}uYbyl_$SE_zk-advg!Nu5v;FyOSG(u`x%
z)yV2L!o1u(9LQC=N!{J)Bq5SGW)}eXqP6_J-!UBBn1#lxL?_DB16nl_=^#5Os@^z7
z3}p$;P>Ph`HaSNfBd<iz2XYBVW8Fe&TF3wsO7*zAx2qZk)Q7s7_c#qr_a~KsxcZYU
z*zj6OK%^!C#NSEclDKjB^7R3*Ij&mv?d71X%ZujS-jPC+YEcn;Bo(z>w_WB96sSwR
z()z0gOKh99pjEpbI|gRxtI8^>&9k@QU@7ByJ_1g5^ub9YpA7g6YUlS+&m=h*d$-mJ
zPxfP<q2rZ~!A1!+qZZRew4L;~c8785uof+H*QC@QMm5ffTsK{b9)N)R+PV(LhUo+S
zTlm`d(`6bUPyx>Z-O--)DKUYkZmQ4;G=RFn?(JIH!G#iha^VIAfpXG8+RLg<Tb~uI
zfWpfmBgrQo9QqP-x^dQ{5FNK&Qh9PT{1yZ2PEzgJnLQR-TH0rMI2Z6?FWK6rFSEq0
zr$)`@XC#J!6Xhp304`})Qflg1kmG?tMXK1^F3i|`%*+7v+NC&tM*;GzYJ-urRVYy>
zRHTNPze2acy=|o(WBq)Rc2bnPT!HO8ry9<9vQu=r{dJt-Xg$L1&?g<3k4i0!7Ro6~
zY%|WB{R2{45fv^a$qmj}#thK1PwbCxh<Sa;F@lDw`qV#EX&;rt;!eVg(i=G4j_%~#
z0iUb50M~45we6HHDp;b1?8Lt~%N;v*NZkJD$6G7<M5$E3hW$7Ut}N6gx*|)$Y;|@w
zX8oYtQoRDp<I2kQUCH$b0g}E>EX7rs*<u>hBo*WI;QB4&jM9z$J2W8JQIA2ZB4_6P
zA9PGZ?z$m<6@{#6`L!F_d#o_~H0_$swfQ@DxP%zRmX-D)T*>)uTRT2V>MQUAs2JR+
z7<M)p^Pc%wyXK67?${^4K_7s|h{rBO^omlH4>g|pOOCS8<1ym*R3ph%ouaw&<aSVk
z6a-}~_o~J*RBD(Lik)Fjt`!0eX>s6wD6AEL8EWs>vVu>6+niWWn?u{t0`Hu8Bdbgz
zi4JB}f@Lfur7p=yte}#|?g|UfO(nE_``2vZUqi`(RP9>#^9F4{m($WYrD`@FNVgW2
zVt<rl9r#5%(J|s><FSa!I<VYU>oe6ZcBmb+f#c;Rx?cvUO~!`8qI4MYoC+v5ps(wX
zu?Iy_cKU{-^rA^7t20<u$(w}0P~HV;P|b6+WWcWg-nl;sd62UUu;lxX-adZ)Y54Pe
z6;ieX=j-$689H!*r-BA4`VYxB?OY~Cl^Gnh58=#O0jOY07RhRN=;S7DyFMI{y6g>L
z#|?xxYhIvh$AKlcU9?8YTkq$uzkK^Ty#Ms=tMC3gi>2Ahh7T^V6Gm}?p_U~fHL7BD
z(w6<iFjD}P*C9WG;)JasMGNuzZUjzdbXK#SB*<csCm9%6c|i;T2Wx^Ah6sg7y)9K;
z7U}4Db6&R|O^__a+(%yzXixg}%<9TSF^5UVd7}wJ4CDc#h3P?aph^~yx^g5?d*qr8
zvRr0F4peB;cq&nB<xSSsMi<HtFaUt(!^|?S`?%H7#T<a!hW*xoo*L)ifCZFdALy-Z
zrO#&2!ytJ@GC#0uYuAxN)zW9+8d1p+BO4M(A>l5OKEesr^$DOzdQh#adP4RZTyQPw
z8qGi8hvCoiq<+VIc(ae8#j=rq1!&Ecx}DWQ%k9T|s?RoQow_}7y-d2cy@}FGtrheR
z%-ZeewnzsRzsisBhE$Ll#ycrZtYeFeP7}I={tSmGdAZ~hX%iRI?ZJ@x5+yLGI^_Fc
zN(z$&(wN4%sX-z>(7>=Xx9u0McJ2WwxXKokGH*%tDkWR2c&KGb)jmkAXKMu~5W|+Y
zZ=Ud`YXUsfU<by!vegJV?<%#CkOHx$2nXaP@d!!cgE`yb+b4%B5h>ud%6A-2ov3f$
ze)?e_QA&nG`q2)(8GY+Jk<)CLk8t+nJH{M#jqmJ!LZO9RRQ<DC@WB~WAULSIN;oQS
zfI-#GSrh~Ol3!e&S3pZE_Uo`>uQob_QjpEXC1~ep{uFx&NH~n;JRB#$$yLt?)&VmO
zpuhr?s<O(8=$y9jdzBz3<p-sZm3y5!RfH|!3xpP%9sB^e7qY6+PY#BzJ12N@`zE3V
z;_Ui@9{YOc`IPjIg?$4k82P8BrGyH;e0Xxy9=1C{H~+JpK$5U+!&>W1&Y~e8iL9aS
zT$7L|4M>dVX#Kw&TdH^)SAu#}ucL8(>8(DA>$J|nXn7ziklFgWb*A^m50LNW4Zbs`
z`hu+H(6MZwKvC`Lr7167cK4^@Eh7-tf`^tI^2i9Ry*TV{cicC9&=MfOZwSp=+<Q{f
z()^B9#lm)hY~n#HN_DAj(|tB=rKq4>*RT8b?IXi}W**ND_^E!{<oGUlMqaJM0dYAi
zd6PpC0o>kWkDYGWTQl$zfKipCfMX*e3q93C7RbF3B)XvpENW^R61@`M|D7D(ND2)&
zKfC()KqAsEg{Yt3s)~sZ)Nj~WAVP>?fJ+@aX<$|<g3LmrEH&$I)DA#u6_0F-V14#m
zqjdqA-Gc&(A=|3;)Y6{1S?Xy=)Kl5IoYi7UrL2PAgx7EEQgQG!CVR<!yG#-&dSd33
zzl?9`(-dvSjoa*on#EZfFCUP|X7amG9r)2jY1CU;qT=KZ>dL%P2QjNaK{7iTG5q%J
zGg~M3T7`y{)M-yY&w&C*Lmy6tq~wtowG(maS`--U;)q)72QgG=CD+IvB>IB_wqLHh
zK`5}A826PrU(@0O1uCN&s&`vsfQ%Qe%UsH#luCl0@__k(0*@VLF;aNsFV%b~KZLG+
zM(j?Wrn`?TPY)U;e3p-qsKW)$Dep+)Yy;5;WPo!Ji8?^HQ7&2%bCrB1{^};nG~O=h
zU6@xYOLT!lS0oHc9Yl$y?LZGw_Zx7qt)$T(HgFG78}R*SZ$G0t*jCa`1CEbyWwVTN
z+SDT0ln&sx7+1OA2i1Ujt$AhFgbAowgSB5ViP@fPk5*1N!nZE=;qp?;B{elWGLO1~
zajYgTu0n=})@my33tHTV<P8`VI}K4dW*nr-l>=6ihJMRSiY;}j{sEXNfBdvnn3&Ek
zeVE|d7ua<|yGP+3upyJB7)w`$8w;nV74<W^Dhj96c>YCr{pIETKSDGAAKyN|yo8;M
zCK~l+Xw=nn+pJ5q$eBv7KzKidCu?b4tu`2|9W%OJk|xxbK<)sZwA6>iiw@|?FIUf`
z(hV+=_UyWIHXAL}&-GlMa-;-)Uh<ScYC<WEF&Z~?aD12prwzmat9W3dT#nsIoa&$7
z{`4WO>yTPUQnSkqAuL$@msP$)*`zxgT|$N%HVt#V50dN|WOLBeURws<!~~HP`d*=S
zrA1jkw>Zbqz2^aMu(M>YlXnU<Ki|mMlVt$PJ=QTVE$fwnq)7LgzSPpl+n>!ix{U@>
zH96oRnolgv6T7xLM>z4(zj*yR@I#hJR`hLd(vFaSvTGXk{0712MpTGa?2cK3^#k?u
zZi!&aG^jTn<jgE(mH>B=@MC)$z#oVgoP_|8a{f^=-*{IS9n8gnO1Cw54F?r;P=VqF
z+kXsXvQ*j)xHOv@vJD4lA+JN*EzKA)<v;A9t1UdS)m|#4f)_aFIo<$gZdr;det~ye
zd22sTlQz}cbouiig&+R-9Ety}VjgA=U0C{L4|f~tXAD>?mm94c)%9b<1v-({#j?Bl
z50ZTOCTP6F$AU=!JZ`PMtBnw)KvW4NUOAeNHtY=^!y}9D>K+zD*Mm*T^GQX9Ez}T*
zqWAH2c>7bnIGCLAf^_T}3zcxxGvm-dy<^NY;F|Eua0+j-sAfmCO8VGGtzP=X!}l6(
z@>_xAG`s6!gwkd$34^Os%s9p3`Pv&rF)GRIqC%z?0_6xcLhd+2oWh>HtU6=3D)2Aa
z$W#(IOM$^zPCO*do}=Np(=@6D1W1wfxki)_kQb%6aCJPCMDvnTo_JAM5RVwsG^|bl
z0<^ce%i%1=@r$KD+i;i=6R31{dzJ%4EkOqAQif(z-`@Q4cR6fAn(y8-sx=2P!fn<R
zm!i;SM5Uw&C1%E)<;r`gofWAhC)`6cIzL1uCH-a!V!wXQoFv=JNrDBTonm8Vsd;8O
zx^AmvVmR(VV$63i0HQcH&UBUnt=lf}^&$jJ7K=`CZHv3oaC7)oUt=4rgsajr)O%L9
z8ePl=hQ<7T$S6-fRfCk<cWvhaoq5!nHxs@9ljUaB-7Uc%l)PSS)kqCC<bXAiT$S>M
zVP~{;3bjQ_oScP&TErem87Gh&ZP$>^|69h)x1V12t>5|Q%eqP4>C9^dt^^e<lu}fS
zcESlUU!x*41)<fccO{jgWSddW0MwY>1tX;W)HkeEd_nSxMq5EHiQ}6QX7P^DDC8hq
zThbZhMAVX6*yL>1(OA!rqmNwj>T{&S3*u}$0Nii&rOKp!EJWrFJc*UQ>Vq2fOx`ht
z+9{4JMa3wGUhGySF69UKAHxrS_(T2lAHt7+oMSqI%aSf=4O~%h#tXdQAFjV98Cq~!
zGrIqCeVLXWWHk(zBsS2}5gG|LtF4<I5(#o>@5osfXw#0Hb+Wme!6JfANp~vn$9Txs
z^txpSrocDw0tP66prgPsa|BF%bRaD(Oq!N&3*vRI5(ox)Q~<NZ<+!?a^Q_dhRC?w_
z@hQj{ad4ybE${2BvjqF8J*Zb0^4O+M!HW)A>JB?`f(($Lgmx$wk3D<2TqCZe4xTS6
zp3N+Sk%B;grBy8M$|>t`tT0`Tc>5=`10|}+hS*IDbAdT`SF5SVVVP4Is=Sv6+Pl>L
z+++ss;#WVQ9cI$capuemgS1FYPm5h;@k@*4$XOOt>~zA=ao1Sw0rkzR3#Z=G0`G5J
z?m#C%h~9a(cHL2SsK%zH6uo4qiU`eLrY7{%Um1I6V4^YTmHU(YrG_VV*toZvh(pa{
z1qiaxz=DE-wy_Ona4gyiQuDF`ZDVq5QNk3B#F=d6dr?gVqV;p5M1>|I&o_wV)zu-}
z2X~5XqJBXM(0Z9V%=g_Ox?iPGf*3Qf*Q{JR-6axKMtdVq68?xLNFBOYy=@rir9wE-
z39l0YJSwfU(*@#7mnJ-|t?>F=KVr_Zx&t(9XE!_Ux2MpuBLtUXc-l7p1aIo1V@k*9
zy5caqNdna;cavzj$~catRo7JqqlCS|9^8$NB}lYt3$q+Ri~@QnYGnO5wXA>f`kVY~
zFuwa8c~{A&hmGln&^Dtiq4DCP4LiOtOfIjaPr?RA4sYV&!s52VAd9eePcI?f*gI%|
zHBR1y-xTgrqN#+s`=ZRK0y5{Y{v!7k1$sH}%+-JO-+58rO0oE7`S_W#>SK=dBc)Jg
zofnL9X2K4@^i<@3!8Y7&^u}Vlp**pC4w)=Hr$DG=T{4o5i~g-2&842mm-y^JfH(}g
zs98~Bu$9I8CY52ZgCq2v?6U|u5W=7itS!^2H9gIr;jcwQxc8q!vEYyP`Sn-f^>b|%
zfV}r1kt&bWAX{TOTdmE$(qcQ{Pk9xWnuuCxF9IbfAKD*1H7KFyW2gOX_Dman@CQNM
zs_G1wog9dc@4P|<p!1PtU6Cj&x7-s7UDe^%N@9RgWVE+es;bKYFe-r3<~ayQ0S?iA
zWc~ik)eEoRo}?6jdDhNo9hvz9W1Kn1BQ4UQ?12GTAg5Bbz*G^;0z84WXW(dDM@O(r
z5FF2z&A;J14$(_qL+L8VE3n}7?O3*I<b-gkfORl<pZ3XzvB&s$S!ggtjP5lx`fv`Q
zDw<`3B@fVyv90_5?=iOe$?Lb5mq;+Il=w~?x8$?--E4Z_*-yqWeKkp$sdA2Dl4Hxx
zSU|QB;7{@%>Z;C@1b-~Mv!Z^sO0=qi-0Lq7<Doykes*>&J2&~9;||2YTJxey7MF_>
zyt9u)-uK?rR~nX-1(L`O%G9+itX2Yr&fX*d0XBqAmO6qt&j*O;D?;mbeyt{Mx?Lr2
zRjZg<iIV^<xcg$}U~8+Ei?>Hwk__4oHf!aMXgH@1tOLZZ^E2F`z0BC7O0^j<KT3jN
z1cG#hcKqt=RPMD~>p`K9k*Ip@H@<xep(`7Lsf_o5@snU+03+ZXY=g~pcF19URX<wb
zVx-KLM|O}vA^mMmiw%5Ln@)Wv@-ouVW+DnLGG<5!$aCvj8NOJ%K-eF>ft6=yEVaL!
z|0J{9noEwX=x2CPSvE*1P=gX=lsj8i6Bs;6_V0Rd(j+QwFiT?un|L0}vtTRK6y+{W
zas<FN_7ImVwk7%5SRj!+Xqa1A?NmU38p3YakRQqag8V<f5XFT4PU@$7GS2#4yKH94
zL=DWSVnkDC=VX>qzr29IKRVYa`;#)4cM%pOmY9K~`zg7}Kh3q_^>M`7L%W4zLr5|>
z4=3-EKGP`yL8v+Q0w5_b+5o|ZW;~I}=djaAt!xqBphlbyyHPbTkR4aZTY6S0>CQ=_
zlCWk&r~G9Z998>48!+odmyVBrXaHBUUyW%NMeFJ$;I+g8bR1vo?@*CifL$Dn-H+>8
zUinFJ4@?ERZd4x+)ceB$>;*DzB2*@BYlbX*peOokgEIdyeE&D{_4k||-ZK`;%MrL|
z&Hw_dLJEcyl22_0x07UFa)l05wVC$6PbbdvSssz$7%+JDt;(F$k`XVbjB7n~YO9*>
zNGWQWBfzc>6w<3KkpEE@wEW6m%;1d$i4r$xP;q%;7*n~*4^|};b`&$@NR~H9@V;0w
zFilcxcU=j8u_xQ3=q<L?3tb_RMFXa?gzpMy2JCU`mI#L#Ar{1%yD~q67VcTN==~>f
zz4;Y_BQcv2r_n6P3E;a;&UIVl@{)362}N8YX9X2E4K2|lxuV^^I8f&b(55#Q>*o@1
zdG8a{m}sbjEmeDf^Er&@ixD~!o1N=$?j-CLQ@1O5Jf6oZV}Q%#q%rkGT4uf`I@lLL
z;Ya~S43l~&=8u@qC!QZ)hPN*-pbxVLAOT6Xo*eUcib=M!l)Zx;9?R7p3GAzrx*;6W
zU$DtMdflMQe~-`cq5ijOy}I!EteRR^6(S(#8gyJ6LLfg|T(wLmDz)4eOw{ZdO1_of
z?6w^2p#8{)u19l!86r-+N#f@(0s|;Kt8%IVz)L?x5@`nv6wzmt{{>Sic}nX^%`Fim
z(O?cluqlS}M8LAC3;H<xUR0Vwmd8%6s?~L0v#$H+{JWopw@)tb{|^5}CnOLKZ3ARU
z&MK&=LqWQq{K;lKw|#{68}H+h)|VRxr8)y17$}R>{af`;m8{F7Fze!H6luN;snWas
zr2nJpdb7*w)kAZa>dYWnCAHTSlAL^)I^IlM>Ua!thMHU&9Gz6aBZD0$&p8%3&~yL{
znV@<`4RrVf>t72`V}2*HqHN|t(i4Qm@5Eqr_`4bz@<q?d4O%18Ici%ZM?b}P+aap3
ztJCcRdd-J{(1Vs-Dp!DEmR!F*>3Q7QU<66PPElB8<qs<8p?V&0pfSd6Y=-aYMyG|#
zz1`+aU6P!pN;TOqWq52j1rpVm#<|j7f7cN?i}ge{%O~NxztUvIu`!U{zv#f1r4Vw|
zU4#0G1c-6AT9=GegVrtpl4N;v)=&v|+aEJTF`~@^u6i7j-VALb#flUBJG(q_scq(N
zyjX^Y2@oBvp(f1hQ^DUB&N)VaDPgD}sWhqLXpZs9A+WpBfH5r*{1U&Gl@jpPOzdc!
z)g}|yVU6&(Lunu)Idpr#JVzU>1~=NndRpAyzS>MiKJeG$Po=v2y@g$gy4K(h6^l3M
zrFqv37B1|(-yH5z$?1DfPi)bYJHS2FfwI@=BX6*YJt3%ts%*<iIlvlDXRNjYP7WT&
zjAtz@+5yhv0(Njm=ygz0QXvcB)lPs#vpJ<J+%P11w#yk7NKu?k4Ck~oYVp`wCshty
zwNF&(hKpoF&@tih_X8gKru+Cg6nuWBUTCJ?BT4D1?(~;sM^ZgEkqHx2ELA#@3m3z<
zbv($d_hk7F7+Q6yoJDySn!fUoYgqh1&4nY!%+#skCV!t>9CF+h0|-T6G7jMFbN(9m
z!Qx0$7>;_M%#16!x1eko+#2D5%Z6D+{s>8ql})oA<IIs-C0IlC?&KFR2G@(iJ-f}(
zGB*T*rImXE_B*)qj3ygKJsEv~+txeAo~`_Q`mf*yQAog#Fu%olUsjdJz7(=UN2VbE
zMtJfUuix6Q-<aFRZ}e}zU^JYUC4|oIt_Z_^mz<_>{=R@TB&%4iW?_R%wSzfEmB=0L
zbX!icfi|}HpT_$LofC?S_mZJ3Sz3EHWt+J`*=p%*ghS8y;QH$IpL56KmzS+qt5Irj
zgZ<|D@goEE?T9;RK7n1wCfR~9Pz^wa1=^%zXDzJx=H@vIAwfw$3%VGyx`RDmg$rQ8
zUG|ay-Qp~(JhJ80j_@V(yMZ%mz7W;wUHv#i_4!2Q-oZO{GrZ%lhpfjWE6Hdr5>CLw
zWjkFd3Xr|K8iW(=bMPT=Bc!>P8+++5kUcy|zb&<uYY5_O!-28|KM>8>Q{>nO|3;70
znS>(S27pU4nOm+3*)@eLIfF@%suBQUl5A9xEX(4rPFfu0>YiQ0nq+x1FPAEGRS)=u
zbQB4S)=ibA@XhO2)SuJk5BFg^i$(~XxeThxBfzI{EFBW?1cE%~*iHkxN=|Kf8ITs!
zuu**bG%?p!rd=KOvHEJ!6Kj!_>=`PjlG0o8=OaQ{mKNA$xkAg0NIPAaO`6$2g607~
zx)TFt`15Gce&_{||JARDc5z==4hH9<v;YEu+SErY@hFGYkCSa$NO4BWX{aXSf@(0J
z%Hn$gM`X2)4OX;lZP~nPD9JKN?`npd-><^kN4(dJ0Jm+13^+6#1Y!8^XlGRI&DiN_
zFxX77M-FOBwg^x8?vX!0F0CimPJPAlXV^tb-Ex|RBA;B*PP60@XU)8$dU0mH!ZbQ<
z3;WO;8vn9~)NG2vtetk!+$DgbcZpQ8RvpxEQgL_)_b`wXEN%lxaF8lw<(=&bRM%^i
z!*vh)ZewVqf7wICt~4khY2mY#B#w|l$ygW4odg0rp+V`uSh)<TWn9TSIB5=5zn!cP
z*5puFohyQ{OGh)6XFPtafR{KK1ik;s>o@OzBK6f}uMzA!I8c*cAQk#TDzFNJ8dfl>
zS7`psVExV&*@jT8S;7FOBGrC^nI$6hla5UdT_sEANfOI+4M$5_c5(b(<6jxds_2v3
zl9<O(buVQa1Dgq^bf_89-Umsw9;z8b08x(W>I9pV_OG(JTwRmnsh81Nhs((eWsz7@
zGE`w!#xO2FfZP8`c4aS{8row-r!{f*C~)0W<M=RifxOY75>SoJ6^NapKDN9LkXQ5p
z#!Qj7`mRvPVi=#ZiVW9@vCQgJ0_J{WCzu4V;t=4J6%U4#?5|WgT5Hi>Re3v@P!jjT
zO3oTizBx~`r%AV+GMXf^9lA=rJaBb@S=fVC&aa7JVk|4G`r7k^V=EE~<%16rUMvU5
zYYr}00X+mml*+Oi0G+ANxpVaM8)(ko=5nZne9s|DxNLYQ2kropA>#lw{MDTZp*$I#
zF#%1nJGFrN0|nHh;T+|kw}kviUe4ZFpSp*9n;WdH%PzZU=K$3OI|-fw(O8&x^;F|(
zD2xSVz|)ZO>S(=9*=Prn1g&lim+6y+rn)t6CHaK&Ldh;0STHm-2vCn3=Y70tXC*=T
zY^`r$V3Qu()1`P-VJ7me0)`ACwmsAldaCPzycz1c>gq#02$nG2htmZ`?h>DP<%pym
zRp7}YGx!5DL73P8n5?MZi+0dWmNyoaDt=kc@B*D7DxpL2mb&mtP4wZ831VQeZV<1w
znN{qvAS`hVFjIlrn8#Cj^ppne>w{u=RYH?dN=6-C$N_zgANqM$H5^xlJJ5IRj7f?N
znPB;Qs2208Pcy6-DPJ35OOOUb*JrjASYuxE>u8H<c5#xyjLL51feHN7y7^Cj7g9rP
z_XH9cy`Iz^k?gC{(!Se>B_<ge@)m6%NlqJ`-VMV7fPq=oDZk%vnPi&FrInr+ek6s>
zf6h@kD$D;vQMs~Cjy}dnd)&Z%ra#yqXN**6KE{P!U%pCJD9uYL0pxSJCW(68hh~>a
zq8v}1*-<S3>|xf%TyU1ijz3N-V+Sr9Vw5kg;IzX;7_BpO2S{^~mwS=~-0EzAIk0M2
zM<-dWwR3)FSWj|uWy0h^+~7IfZF&sYp19q@e9ywlpiDLMc7zBj7|3n`=RE=z$c!Cs
z;otoYnQl<q4yOt8L*AiHrCRjPE|2&uhgwAUV3ZQafSzjg>=8^s!9kIv&|0+3Z#lpW
z%y?xv;)Ek`>;VxWUR=GT#>ODp0V+<H99GpbZJ8rJv8mdoDGv>SwB3y5aNPpMr0TnD
zx|5bK{4C{fmjwnkQjXeAm)pD}-O)OLhkTw&*)3s!L9`sYuw8QOjY~mvI;!;o3TTV*
zMd2dk)I5&VU%`NecDXtaqmt;*VmM)dF8QG~kuGM1_T67!?&DfRGV4x&Q?Fer!=olS
z6CB|*LyGDisX8^oEY8o?49n-_UO_~O3QhMKMm!1%&A*cgA4p&t^%ggNzno@=`X!qW
z7>yFkyxBA!P_Fag8G(?zZk@M0BP)l07k==AAKH7ta_%l`Z%kZCN+9Ey<-$}K$Lf?@
z;9(=%?GTNZ1e6aM$)|k+oW<eVh+gd6j3Z3X;^7|B0W3ola;a~!_Q6r%jSqw@4Dpp<
zuwLH(-<VL`)3Rw7;b<GkZ@C$p0yc6Zf8IQ^ej2GTH)cHuIZkm3VeHyi<~oeGRKb9}
zalYByDAp&gU=LE%Dcz75lq_xLIS~CF(Cf&b*_(%>hTYC2D_Psf7O6}6k-h&+U2kQ-
zU)6>hgSJy?)5wp18V5-+idiSkb{VinOpg5PHusiYvxNnTmV;W1so6Vlrgfw5DKDN{
zs@sxI2}SO8T%wt>nQ>XZ+Ur%RdPEAyCh3B@588#I#EyM=_PbVr>-gZbXu!nQ0w8v&
zonpg&qy__|U}11_bPmxI=%~y;tV(wr4}h+`u_e8bPOGR<TY>;hx*Z_eCFBlt)q(@3
zg(PCd0Fj%wuoSEC7G)hCHmvHuR1fUFeMKzc*B(Cr*Uz+m5CG;=%_Hxx1$N9uv!AJW
zs*?DOe7&rC14wFFF9EyJlG`%kQr^X8O&v+}tY`lrCG?-)zShDsy#ITfZ2edC3IAX|
z^gAppca=r69BM5g234{9q?$JV;GqBn01xZr9t5pa0t{89%wk*XJZ&{t{gW;`smzYF
z1O_@h5p&$zW@lxqJ9}Pu@+io*?nC>|&iD>gwK-0!3zOAwQR5+`t;3+SXd;6TOf{x3
zv9~tS5T;6>Aw**>fT^84C&wyVw=HTIn%7I+O_*ooEyc0>oz-c*E_*O7jC#V9jB02V
zZhp@k?GtbJi}3bydkc`ngIf1!3?!xC*6U@WECSGEwo4>B(H0~QKGEv41bMy@2}_lU
zEs*Sajqvoy7Y9}cp-S~h)C%zJ!DU%W)C4ylLgum`14es~YM@GOF=QHtPOI`X))CUm
zBtwP;N1>b<8$P3wIuOtk@(=T@36PkQ@52?*qy4a>ldEJf>O9=SeZQogmVscn6fF0<
zO=U(Fn<UHrC6RikRsr;N;|p}W*F#4Ggp;}}NAlg13WUSc3hJf4L%W028C-Q6UV4fN
zUhEaZcCEu9?Zb{KmAx^{Kww-s2bduU*ja5WndR1B6zdV_AfMbH2--dr#cqkPY$)P$
z)%?AMUtV5?QvVDP8?&uaLoQBT<~Fa_<Ekpk=y>FX`O(|Igts$nQWj^sRn&tDPs8PL
zR{KGnhT#)t3yOHm(8aQqjdnV()JTZw9^_KOp&f)-FrDlxc@_s;a_rUpBXJhZ4gkbI
zq`JWAI>p02eZ5On_e_0<$g^3l1rF*qaolFjcOw&OIfDJ?gN_xAMf)O&G+O}BcAx8T
zX2`72BA1nO(bX|~buQtjUrq{D;Do0|mNE8OrPMG_hY&M|5>*_7J{Z;6AC7R$cN=cj
zi=6DuZboWJYA$2xz}ogm5ir}R#`&Vi7m&1+)9CQkWFs)hR&oTH>WyM7lE>UIYOWCt
z@3vqe9ft(Mlh)NT97#7y70+D!4--8Q8kO;6#)_IRdb6hlh1SwlV4vm)sye|94~!ew
zK7@!0^ztdPBP*&8w~<>?mYtm$k^r|CGy|D3Pw7RG^!X;BC$n`5Dml+@p5n`k@*dKi
zx|47hu&xe@40i-r6lt9!6(t#|9RL1v5Y26({_)#q;q|8qBXO}uI#H4&o9>plOEh>P
zTpA1K;oGxSy;l=MniW1uZ(t-f3xsi9GPD9+aUOV-)(kPS)S1%2(u3AVXf|**lPUF!
zosExOevriX)!mrT4wps9mIg2o3XTDOYh>H14oqW0+Oxelq5x}Xu*&63q0!njOjVdl
zt3@TLR_DCqt;id)VBKffnZ(9vRKc10DsQDXMsEuxRrgkCfSYl3eMC0ryj~#>;RYLW
zw8PzqYqK9S7~t68C14Of@+{Rx)dlb8b^M?asHT3W{OecYm7sG>DdJ!#X^`94<nQ&S
zB!P%G_{AltR??lmRCAY#7~r|SYE6738=%ZU-DNS8G?aI?g1nv4D~_gDgFuq6!!;I{
zc2`)#>1Gu@X3!WY0-#v5CsS;6Q7M%!$r1uhWNv}HKQXjn9fM&PVSh!CO*bn%g>h2S
zfY6WX1iTWQj?t{FrpHJ#XfocksIiTCgNG_e|M}f-I;XJyt(;2oKMUUEX~}~{B?&+y
zAFi?0-DfQho4g}U8uIUy>Wtx>?v)Mo8Gmh|>Vca7@DMND-wa6KK03x;{(v>@E^BCm
zNv#E|UHSSjJ&^S9uu6nCiy{HR$sUR@93xC%DZv7`#qEk#z`*CT#6gz+icVrRGQu_>
zkXUiOVPhl?1&`hvGTxSEOc0?10QtyKUw<Z53=ziY!o7Wo>Vcw7`R{%7-QUP>=zqic
zi~Ohm`1VOwB-xy+pNEP7T}n;_1wSt^#%WC_1}Fd%o}S&*)bU9te!Jg5qa!j`uv5bV
z#X8oEdBu}eM%sC%d#<{-IPWuqLGq5psMXUQ`AZN60@~S*qEu|>rY4Hd8`2+qP`qGU
z-_dUvZX8sjXsbL=B#v;BwQoo%K)`oQE)=%m{9Jk-VoWG$o7!;_K(Ut{hGeIB39FVS
zX>wOr+Vr?btEM3b@1`Z*IkQbSBS=V!SVO-ZMmO@HA!)XF&?E#}VuW=$aaf$>A7K;A
zA?4N-dxqkc)Y{tvE*~JL)y`Xqr8ba+s43l^ubo8PCng1`Qko;))C5WwTZu^ppH873
zwf0z0<8(aeDym%NS_`bU1VR6U%y770az!4ctsK^>or+jIr`1fl)_Gf)*U9tPY+|e3
z%(SN5jlkI74laep3@XNfA9%>8j9USHm^7ReIwT>~VJl0Ywl0od1ePvmb2}WxSz(uP
za+{(?BJF7^SES0p*HmZlwm=R^poiy`0Ho4=OqFAARO`Yrlx5tJ68S)KroNgQoVgkp
zB%ZNl`aJq;qfcm|O3pSiZcu9CUD9q_g+)}yoz>qd5}oRzGimoWjFK@S=N>z4o7E=?
zeRv?nrS=XGGH4Vzk$X0b*b&dBRhI8!k?fiGkO}u}yu4V!KOtG$<dm8nUe}ihI8x>S
z7^^^{(3?DPl0s-bkht0N%k}_J?Qof8KGn(rxmogsV|<9!1)%Ju#zHT<oOL6VqYFB*
zJl}M(j*<(y>sG%EfT(l_G3)nlpM1ciXff`?Ih1H#<+Ox*bmrtbqFp^Dms1OFwFxE^
z)R<}}1-by_w=CfR0y)7Ri>k9g2dO_X(fNR}>27Fh$-WD~C)C#lh$TX$p0=iOE`T0$
zs8!S8IU7ze6ZKH18H*Bl9~@Yr)Zb~j8@1)mzHyQBOROqqA*_$I8dSkeYVmauXCwYh
z>OG4az8^rHMb6&Q05(XXZ}sI+XqUG+K)9God7~tm_2oXM=ggPK?|vO#zr3tl4MB4l
zgV4Gj){@pfIINX)5M?*eNgBYY0C1=z0?@3(7}nMn<2;NUVYg?=+otR$39vPtzD#tD
zTx96tNxi*zV-D-ij!`H)59>L7gr<kL>d^MJ<FmsA?l5?LXyCVhb3cNJLIG(cFv#|c
zGk|=F8jCl;#fc9MK4xrMNnNM`(YAW;cNIIZxX_%9(!khTVrL)?>w(p>$0k*Ruj*%j
z9Fo_4nuJlQ(viUCa*K6qhd1n1^4-;e&TpK^ET*X#yTh?>TJVk!9Z2L4_9x(d93nD3
z9eqHi^hUKZLG1p}aJ$I{z8NAcTd<*Mv7-Sw!Ww4_vTD*5uVvuL9E(=9qHl8TijY~R
zk>hrsrn1kf-0$jCf=|9%C#WFhPpWckPkfLw%NQRRNkaA=4OdBr4(-0pJ&M%K^K$E=
zx7eRH_z+){htyV1G<mjG6gA$qK|FviSpAH_4{Xuv=Q5l;bg_#^reK&_vAzcU<VI40
zJgkjm_M%)vV~|9(!sYY=9s2b$wa|u`5n(u9twTw4Kgd&3YQYvy!kt28%Kef?W^XC9
z)=}P(b`)cmC=D=8JG`4rkbF5CTm{&@$Z@~Hf`Sl*p0-hny&~8D(IVR);1H7L!%0|{
z_yI7|R=aC<Z`u^YAlqy(q&$V7i~^TJ!K7@w@g7u~Z8!k9y|Jb60xhY!rspGQ${T^0
z=P?~Nq2yD#q6KmO?k^FQsvS*_a4RJ}DZz)fc7#e$Zw2f&Cm@Lr$><*Ym@RR6ehol{
z15F=+%}gHehMF<}=@>r)lD8_T)xsS*hO>7^|Ml(n2f^IGIDfX-SKey4)-I%DK5^aR
zrSvqk%)cYgU8*`%5KoT#(Pj^I?Nxx=Lxw6x^1uP!wZ2RQ<-p-d8FHnY&9CULB~thR
zfFDp^(AQVeRg*-PAOJg&3NkH86YT_GEosT{ewWj;ww~aB2>&s^D_JzO_<gCTb`P`q
zYE(!mIpe}m3AS?gFeZXaAQ)9cu}+dkcx!96jDowgZUwYItjm`MB<mS*W9dL_z{aq{
zKC38Mo)oteZV1L>nO&A&Cs3un;WAF=zrzLi&1>f5Lv-f00QGaXUZf;nfFTgJiIUBC
z(OSEGEGA3bj!l@%BdTY|!!`vv^0M4o7dDV*X-2F)L{pOv{SU7~S3=F6Qhi*#S6;-M
zyta`_#Q;e$3((4r3-}M{OWLd!xP4i6`yP_nJZ$Wq%{4kA?xrvU24N|W)HpkAW-9W=
zkO!-3a9(1Y7Q`)hBe|7b4<6rIcqUk{TOP$#;tQP%p>GSczi-49vk)^ngNi^ThBqHF
zISdV0&qw5aaSSpbL=^F_Z=OXy$!3tK0jWwqM;kq!K?(zTk)We;E46__oW%w#QSFOt
za&>_$HK6JPK-<LvUQY0w_WmGGco3`dcl-C@M?XUKWpC&)B8%KsJ(^rLOHQqo+W9kB
zFBO4GrHus#n5{SoR<@B1#WP3&-PuFwh;qVm=C4FcHXFoz*^meSwqiR$p->#<$E&kT
ze-!@Hf67|}@Me=5U=Ms7Dnfsm{pT433X1zh;ocvhVSBZmg{3W`IBUv-M2d;6RFyLe
zr>tCnj(N4qaxttN)Kyo@?Bs7o@S(W>dz|nEyK_?15TVtgUx|LeXkW^%CO@l<SrQTF
z%#Lm*UmyUJEl(_}<SeqR?W|JRXmd2Ww99o^2%$e9i2|MM)hUL8=P;CplC;#p+yaHF
z9so$Xxc^gdmr%pNfr9JWqz_<I$X~ltq6%vC9kK~OkLLQC&iavOse!%--Q^0D!oa+z
zj>gZZpc^%pNQl8IB4$rYx|bSOc5I#f_|JkVQ|#zAj@tz;%MOA#8PrXwIa5erA(38E
z&<Mr=Herauyn|IiuZfUt@D(S$+Rjv(Q8`Pr20~$I_(&@BabOr^#G5$+`LeLhQqs1`
zB&)TetZCATeg4?()yyESK_<47g^j14C<msC(Y~l*eS%*~%gNvW<n>osJqPf<ho@sN
zIF|AqPQYQ0oelmmUF^I?4&9?1yO8Drx>&15z|67+vXR=L<V+t9h0~$Yh<bK#qsT&O
zb<oFna(uT$j!Og@(}6kL5(8T)Kzv%I3@ryoippPK6QGHbtr%C#dSmr`QjYAkYt9Jm
zy1N~j(oe3OqL%IXppZQRb<*CF`H;NY@2Ud<uY_(DlXKt1LUHeLvpFP=lw&d*2Vi-7
za$|o(ZtQPNTg!?hsW<L+!`X!_zpqC)4Y;MU!a0l{e*PV>?mZL-Dz??s)`kdO=m%8@
z1FV;_15m>uLQ99}Z1NxnrAO7{1~->uE1M9==Trnab9w>%fyu(xAN1=n;{V3Z9q6B&
z96=$LWzCVcjwq*iKCg<evj<T)!fVD2oTL?&HeQ{)f#dM#J3EsGcEVD5-AK~YZr<8L
z1R<YFHHh7Jk1q8xPVKSqYRp7|)h1njjt{Rz$%<p4`XL<ZgSN}BU;ibXW*V0NWmg1B
zdHe%Op!cMH*)&6H=S<PN;D`+HxO2D>Kv}l*(|QzKgX9l6wHuzo^pKq(tCHk~+8qhd
zy`g~#{EonS7@}!(NdkNi%m^B2*+)rUlw7R#8=$dAsE)FQAsbS~{ZHvIfDiH6pTg_U
z!s}<3=Vz03KxaY%JKR@%Xt+%A5b0W!3C_K2Xn!P4(3YoMkG#_D5Rx3&y+}x>zy!l1
zb32hXEKlI*=uxR4Dyiogy_Zbvw!8=WLu-OTFWWLG8f_6ki~XV`SzkD&$jGL*+~_08
zCVRMa%zSo9krfX^vjNm*2yO2}*{TyXm-dPtBG>i}J5&!E2eR~vr@(1NO$VJpJD03n
z5-Uj+x;#>MaMkGI`fgJK^fDgcVMWO~ZS4Rdj<W$b$uL!-(;(;VLOQIZgr)IdPgU|$
zbl7rcYc2KJOTI<rOa~Pd^fQIo>K;yYhc()?LcZQ&6qwxhXkR?d+EH=RlC$n$Z-yC>
za%%Hq-)6TR1h6C8KUB4#&e2xGU_GW@5l0-PB$aBJ<skPm3?5&`hP<nfk>qibs(N&;
zVfVQ($0`R)ZIEW&)RVHsDR+pe?lqP5;G7NY?sT+N1`yYPb^rq$DtLCZ0Tyq=;oOtT
z4^v`80A!J7-<lkQTcd^sjU32X%J%53s)?8Zew-hp*2<ftJyzgBBq&F^@cOUcV}yT3
z7VsmT%)S<IW<erzv;d|HfcOw~4e<s_Do0?rVo7eVWccXcCN+;@i4QppI|86qqzg6D
zlQY4Y_xQ`Gj$@}2YN&omd0JS+LViqFbhM!n94y%+noII+uDDzq+riiu=@3Bwui=03
z<=0tV(w|h#q?`e*Re_Z*PcUvx%UlZ$u5OHkx&yX&QX}ut^uU}81tL;+d6qCTD>-z6
zy4Iytz00c;G9Z}iwU?x!i}uwe7I^2vNsy3HYHIkO<(pGUO^X0tK%u`XFZi*ShuLx5
zVa6dDTDwVA#bangVbJm94KL`mz8H=Hv(dQtQ1>2nw2M{Wc;9%FcQ;LrizD3L)}(3L
znzZ}-e|Y^=4$ANT7FiJ(zL7-MH6cXOq;=Iqw!sL%{S8uhe!eW=UgqE?(URip^3ZlQ
z^l?A~MjvBG`>fR1!G?P~peOi3vbqkg>pW7cR96xU97WfFun72%tU(xH=O->pMgA{a
zuq0k|)h2TO42j_-v55rV#!J*<l)b_K2hyoIZ2)CsMuHqENv*6`Oh*aeS@fb^K6ISS
zd&**b??Q5r%&uXa*qW!qrQ14$Z)@l!ol@VT3UcS*E(={E4H`}8NX%7|rMy`Zdg^BW
zfEnW#`sF<#qmZP72uB=;35N+JcF3#%IVdiQ?Om9lFWpAOpGxJ?qN`Sf62W(b5#i$P
zcn1PM9X=G39XKhoW2{kZB^pLpvLsb&gV-dw6rQx8!5jjy1=6q=dshgScuJ>q`FD~S
z|9KYse#lEPu7jKwvKrU=IdHtU9@5kxUSXJ|L~}ODr5seZi&53jZFNlzmY$RcNV;0<
ztc`%LuqGNER|%pCRF0a;>cbmQc7aNhEl_8&6YO!-8H8%j4w`m`6bS4nG({h-&cB+X
zREq#KLkO~zhz8l`aX$KqP!%2y*&Wpg8xmxN=CME~qzt}Zv-d&$HKrCz8^jIVGC*pM
z9hRVO3H&V%H@Gm9Bi1qXy+TB^q6l?b(EeWl-=jbmn9iG$7`f>stYa|FomY(=v%iQ2
zvQ;AQKY_;f7Z-K=dHbbWejL;PxTqrAfaMFVXw@3NV7Qw~1T2gA3p8T-)ioIE0l0F^
zJ0rbIDoqC+n2kDIwS^2d0;34yQZGvm{;sDDr5pGfYX6I>&OLfNBtF6*8?D63n%+^3
z%<#t1Ae0>cp)xks5?w-t`<eSOmk8{F!Wmp1QgaYcC7RHGdeUC-$^^1KO7I4n1oRh@
zJ(k}W7&+hw<bPc}VQK;ch3yh!{DATP2RKjV51(PO4gq!-Q_T{5$0RC+jRC)l&m^7C
zadNFe=m6Q0MkRRo12>)fRci;CqlatK^wW;kx&l;M?ufwxIfSL&X!9y;oh4&E<6nND
zhW9Pi@T{8t^!0b)^>=nJa7c%ifnvT^M+}WH^GH@RwE%iqzq%aP%x>oSvxL$9$2ihb
zm#t$kLZp*8KHw;L;qixYXycv;5;M2z;H%a{BPmy74g8`Ah2*ku7a@t{$3OmY__G}K
z{>Sj6(@FmNW%!@+mw)s6hw$SZ7qh$?MF@Hq5*(}Q0POW@n#dt;IDBSXS?xG6IXS#)
z{&>0Ct2`@tTdAjPTC)Gt#RqM46}Um`O(j4)zN2E21Nhq6%pKpxM;!n1`g5=N^1Yy6
zjBqxp!@|H)3pnw`Gmo3YW+g^lZr<*YADR`#?8_&6oULZBr2L`vSvc178v4nsKDa<@
z9Ipp)sazTW_U^UQlT^zNG#=AuN6>0)Ft2W4j>ic`Zd*E6iI`Q`$RPPD{>J7gd_f^B
ze^K8l_^MgHQ^Ovt?6#bG?|Udq6Ww_@;1<$eUjB|Vdeo8$QLh0LZb(*I*dL3hj8Y~r
zco^@l0yqHRoC!d|3(X!P*EB=~pmh(uDU+(dX|ki`diX$HwKZ>fdG(<#U4@~Cyy}@a
zyDB_^!8fxJj^0el0A14MM-ahsKjbdS@XS1CL};Gdnj4^2g+fQTOH!d9wOUUXSm}-E
z&tlQP0IN<!<kQ%~$lxIdPMZZYX_PnkG2Z}=0=m%IjIIDl;R@h)-a#*Nj9$|_$w?rK
zhK#b4tnLCqAJ%CQUmN1(?5TMhl#XB1IIgQQTAl@mY_B@I6VJgZpTsA`e)Ni7)$xtL
z^iah)XU9KkcP+X@^oZnWcP~X(Y*T_daUwZbTRRX8Fkb_Epb*>)asJZ21t37&b{N)E
z$Waa!<Ah&zB&sMv3y+wtz=hiv2LZR4=vF^2r7~1!Bpgb6r*9tADlzuSZ|dK>Bak%_
zf6ZUR_kV-G=D+>PcYi}?1)zfnyMx+zds&9$?Oxb2;ZVWuyv`${k*jvPnA05D^*~6E
ze(+>jz)`Zmp0X11#yLSN(NSc_PaERo46Q2R$4mtELyiPL%w5s1P6x!>AH#V@e*DRA
zcq+dC=)1oPufNKl|MvA$8+bi{p|W?27HYE6TgA+VLmg(tJydLzX}7^L2b_P+xI!?d
zfCC~y5a<!J(K(FTT{x7-GeX=CCU`NNxIP~9)Lu@F+#^^Tni9;l0b(l%Hp5$Slpn8x
z=lMa&aeR@-@O602)}@l`bX0C#w+1~ygLOzz2dFfb|4c0u&~{4b&RT9Zs%=|8v5uK$
zr!GuUC0?!l6&9-FLwOpi0F}SeA-QCU>??#rd#UKANYw$<!_5eP?zF8;Sz9E?uqsJ2
z?+_*+MRwg)LcHS^z9;YN*Xm_@bp2<LPG(-W${4STjl}TQ1lH0Fe+S#lvN5d+O(Re4
zR`-QtjT(u+?>3ToAVh&gbRHSWflg>7g7pB-N={Bj1KN-aYWD|O7`7?D2p{gwtnu*n
zsT^{{41A=IFwj%9V@Oi_iZ4bA2vnjRio;T#By{vJCDzJutRN#}tDq;%9HNry9*jTl
zP&Hev(xulciBn}(smv8>c>BV1Pkwt@o~Ztz{Dv9enWTIw=L01*N<sc?toaSZW=sgI
zHw>JjBa_?U#P_Ri2R#{jRVgCBys1r(8L)Nl8#bYT*oVY18$>`X8e@M#{yRJEQoX;+
zZLg8%3--UQMg=F?XPEZLWg_2KHS*CT02?Ejw}g{qmv?-~FUZSrSE`Oi9f}ezlSBGd
znLvuB22KHNfa!@SB~za&ng_=1SvJAbW^Ih?$V9N3y{ar%V(#-4(eA*!Cl@%csvSCg
zSN}Pj&Cc`s`{~<H&7St{cQ9#QWwS`Kc+eW{$G&?U*$-%_$>UrJwNoDiKGmknoS@ie
zg40sTmEd%-%)5>qOe<};S$Dwb&9LF#To|R$_ESe_TmzCctFIz%Jto8}wOb_4_Bm{*
zB<$oB&NV9E9+u%f5>2;5q_lmN;f*Vn2k^wTHz6DvUr5nTp(hx)+F=RFYK-3C&!I3n
z!=%>gqijI9Srt%fDVK?&bDS-_r()?iEvdH&$LL`0$c(j@TokPg3@(=&i-Ct6pa#$E
z;HP6N1GL;jGpx#x_Yx{t4k3=27{-=5$nMH2IY=c^<~)W2Z3&ElD`a{?fI;j{iW$k$
zjmv_uQhc&yvm1h8-XR+|E?#s4&rBL%QeRf*XWRgbbp7Dof=!l#qf4_K*f1iI*9J|=
z!aFvY9nsPaE^1o0MTBJLknts)sTm>OU|5#-0A%npWNn)!U?oZlG@-Slo&fYNL9WWh
z0Pr9?1-)jwJn5f94KXSS)h)fw+Yx+;pqguTm_)$v939-FyC{F-37%Qa$y638<Hr7h
z`~^UjN^k+JlOPqn0pKAgg(7q&py2o6^-q^=l<1lWvEK%~?M1%*J}MuPqjliJ%|Rsd
z9hg{Sak9`xrcT)hSkK@tA9l_#7$Fg{#3B_Nte>v6cXzk}6SPw-dk!4J7I8ZWg(u@Q
zUO6g$#CGCuA=5D^Gh$r52!_<5r>)xFmRvyY$U$tNkpsb5sm<e3YQKybK2*%)fcLrF
z25g7*4M}~8)Ld20#{kvE#mQgStomSJ_(v<-L#`Y^f9C*8ad@K;s9F!@bN{Nq?h_bs
z8jH>uu>(l`VL5iUYS`6ScQ%n!|I99V4I}%`WGV&>_G<81@Hkk6g&R(lM|Y`Or~X$u
zT<#8~;SGU_=x_PaH3yZl^a~Ea8jj#$?zx#;Se&Rq9*+j8iopCt7A4YfE--l>5V*4N
zDJglcNJu;lpldof9jG9)izZ1%mSt#NuzS?O9#eNoehL`I4ktM#wP_*~H4}D@sa@e+
z#9w^(w{Ks)|Am~2zkC1b>&I{3y#E+9raWZY;Vw5^p7Fe_2(2?av+Z=W>t1LGp=i5v
z>NKlUGwA6`)2tac;J4~RHam60y3Hl)yL8vQGT&z6xc~4_?m-Z94e4<|57;Gv%=@r$
znKNiX(N+M%JYcO0m5;DJh(R68u|`>k+W8!Z%LZixMN!Z6a-%!I)YWo?H!2v|!Qcnv
zIhQs7s_c@GhC|GHIpIM|MCgVeTOTs0Xn&O@qU?tixpf06DAcLMTj2-gH<#1uUwr6I
zbo!0U%i%Y%*9({<M4vAkOwZ8FI7uPD+p>89pcGYt#emV6z$=u}=bq#+V<jjRW^;(y
zB0q0<Xq7O6wxd+?mcq*<<PFR~!Q*sR@G{P_BvrGcRXyaiKGbK_VNfk<^JAMrhCR5p
zQ&#flS9Jm^a@v^4!4HJK6zQY@2Ta9-099@MF|MdT*2;4Zps}470=1&;P=v40l44a<
z>&r1HI9yJK6CUOdEQJ2RMD*{%>!)^e=u!*_>u}4!l9RwTS#X!f<HDkvUCA!L^yol$
z$sK|YMvQj5PVJZ$Ius1<-3|;8brGPhkd9d;sv0t_RO`_Cz1xg1=WQnl3)oEWQ&dZP
zvQzXCPga9V)&#X2qSnBrrRg#-Mhrj!*}knQ9g<GdrFQDWjpGM7*yIT{0J2+3jWqYf
zK<63*M1U;_C_lI)fijQz@!EL}-Rn5vfPP3+DlPcTKHUX4ZlOj|2`&}uR*1y9`o;ei
zveu_PkW~er*{=f}2*<sw6i>`x_RDhx@t;E$pjY5eeUO)@IibpHoyRpf(q5fheH+6o
zyRV<+Ny<mKC3M6SOXTdv{iN8Yr!A}+bjVm%cGSK9C#js?egWZ6I<_JGgpsCPuQ}Z)
zcg$Zmje9Ei($$lTt0FPro){8RaU)bp#wEdlpkl1w7u#U|FfnN!4^ZjzF>@)>6Sh}k
z&~^`EoRqR5_ffuKZ~Gka1lcjD)>0}PU|7y@XI6uTt|B28PV9OY@P(7n(NGBa*c&!f
zmO5%xQ^1hNvDE0VLGsDkwrI?_@i3qZvZ1;lJ4Gcu;qxAo<n}nlEZQ#Ze3SsC)G3(4
zEDW5GJ=L=P29GxFCQ+~?z4%a1BE_5(XJgNMTgeMl_e_cZ^zNvM5l{(cpd#{h%;>6@
z3G^5=#O<Bj!{Pr9rqTc$GwMxA&}T2nrRV_&h`g!|gX_H{jCWEA*Zesh{!(%(Ps&lY
zBNk{zs8!U^M!_qb6uQ953QE<MKVY72X`?9}rx%JdJKR(5Io?M(glY(Wu_;!D!ish@
zmZTCJ54+!Hgs22qxfWd&N#=3jim@Rv?MEXt?)Y0a-|>t=*@5yWV50Hn(NJa<FFU<+
zJvPv%uAs$M2N^i`9SGpRp&qoDIo!wKAPk`IJX=D2wI*is9as;{Bjgg_Sw0)ls)al@
zi~iwkV5^FVkN~Zqq+<A9M7fXtzyCM<|NRG-?dG^=NhL=g5TR9{S37n(T77vj%&9p`
z#)C)+0kF`tQVswczsS7<X_g<^8YqYwb}nt`AOU*hZYi!wUB)SEe4ZfJ_?{Dm#%b(_
zUMi4<<hW~fB=xNEI91G|1!isMtRHk|n!ICX_23Dh;kL%>9BH$xBeZqAVB)*F;{EUW
zM!rX;`^I2VDogPCuNDhCw=z<Y!#M2m7$3vQabfJ^I0_lNkHawChk^{Ev`2q125%O$
zQ$@dqvCCSqO?&}X7SC5|U_U`+Gg>ciwQ2HShQItvZWT4+o%vOu#+eFDqQigSEV97t
zBkq6#DAemv^OtR28<K3P52phKe@^Pqz&ZjWYJ1G-VXb<Vid$CoZ;(Sf&QE9Yh?7*k
zJd77I5No+ulg0yI&d{W7_Ie<BT|u@Ir)(r3MfN)0z+Be84bCoCVMBLwfp|<dax@md
zuZi_e`7eoX0K^tY(Wi__&L}ZCgv3m~+v`;ga*=it_(vwq5H<gH&1A_Q8+#nN0byUA
zylrwfg2|XfsYa5=+=^}M9=)3-xK>PyF{;W!^dPL#<rb@5vqtY10s4hm;>(d_K%e{r
z-^!=4a5l&@Dz$3Kad!fO+}s)*3z^xWmNRdqr-s<u2DE;L620@YDp|TLalq<lgA@%M
z<9w?su$>1F2jSf#Dy2i-YtfmXY1p*SkRpI;i+!CWyFHNE{npD5NWB&%veIl6qlht&
zK8h-U7dpfqR>p^G9ZL0HhoGb64OVQ0y4ek$9A5u$dH>n#muO3T{`R><jQ^%W&JYP<
z=5V;o4K5a_svahzs`ii?#sX!zBptJyExA|{{srM=a*^|)9u)_;w{+1BmKERh{wH9D
z{QcWU@BjYt*fr8i6f$+hbu1(xOs5vOWMc-<2FMwb+0HRi?Mv5cmqJrvJqyJw0H#~G
z>w*2STMQ4A|J$-CT9!*O((a*ktCQ4fD^;Izl8ZtMJl7B$BCJQrw#1eSurQl}zSsb9
zWj-c3o6ste?@7$V5ZxeGrDkm)0|N?u;+LBoN0R4_yMDrlgWUywFsNy?R&EZ|2c{fm
z8B-mce-+}D1Uk1`ImwQ@=P0U5_)L~44iHu=SP?IbG<THlFv_%^!L&`FXOXypqcy@i
z5tMS4PFD^^>*EHhgTy6Uk&JIyAt?8_vO2A!U<fwuhk@mffBZd1;J<zSr_e!9Y+@$i
z4JVu-@+wSoeHxMKKB#$y6OWZiL=|H5hOUuAD?e6jfxf<+<dAT@Nu)x?s%f!<>Gkbc
zJ3HcpveM{9iF-%?7sGVh>~cYhBd!7V@rl$Tl@4Qwl5G`?0Jh0fS}*Mik&$X#$$114
zZ>PDArV)1bN**5kv4&!o-MLF$Ss6JZ4k|zGqJn4!*iKcy^Y8v9uY}Q8%bI6O5MEjE
zKRbOfh<6xzIir;do+JZe#s1A$m|TbZsU(g9AmC~<xZ40}O9w05qTDsW<W$-L$^jiF
zXuYCwU7j5mfBQ-*+Utpm_KVjq2sr$8re%E`-afuOHXC6;2w{TKg)Iy8+1)Q;-CUv+
zDafHU7axauo`h8k@^joV50qrcYIeev^H*Ug6?4uOMK1??7g3_iQH;<z4y*%ige_t(
zyAC{Hh)u1H<oTj{(&L=<GhJRN!=Um@oj3J;u{O5sod2BNNhFQ@6Ffgu_0G;Rkft1*
zK28#RT0CYuqzgDv5nhkNcU#~`IR@3_wdVs_4H!;f1bi|cLJ~2?m4Ml__z?kUH^&!R
zFOlIhV4p2}KeeM>)D@=43B;NM(Wm*K65@S$QPc$hA<wjrPN0Acd~2JOX1v9meQ618
zIgxCL?ciU*mm)a60uZJ_eWZqY?8xLIE2n|5#w{ayt?-i6ksKqap&f#LfWpWjAlrFk
zbT<7g+lcZ`0P=D6QC>TMU4HiZo68G_ERPyAS^(JLgQX6hUP-w@6eoV*iZ0{zlIbC#
zqXPld#wIia#*=_Fyw%qiXCKSIZESu&wjgZf2m;&flOEJf*(VY#vsM-WP{f*akehP8
zxd{moTmj@8UuX}-0QZcQ$GrK%M_Eh5Ur1cv$V9hA4<DyJLt3lka#^nB13Y!x<_q`p
z<J%)fd<8p*hx$q62WFMs{Seri$Ms--tGY9Zs4p+E-2y|lYLMiog*;YI_oiN26ChgR
zNs_+}H@Bk4t~&0$@3ooYIchnooQccHE8^kj`M(+dU~>22fIdT>b<;vFr_pg!qBi30
zi(w-rJPo-G262QOW5L9hCkYKA*D%r{Tz*tP4{u+C#T{a_bo#!yoYN#rhxr+*adK86
zzV`$nnj}fD<wS6ovLSnYhYBZD2JGD-(BC>LNP@W6Mi-DMYMhGsx=NlQIqnCwWH``c
zhId?cG}qWFMEwC)@nwdW2>zqsP9M6#s+)dT65tMj>Kd<oSm`vQ<PXA#?aJQ&-FJT-
z(oMEB?UXUtxoI~oooLgqKMQZ)NWwK!0~!Wkqgz}#wHx`+>{DOMDS*#gO>q#7S0lV=
z5SS02W0rI}51ycJR>6latS*iO=G~;3q1Pof*us(*bF5s!oF<KG+$R@h>ocmemM_K6
zUOx%h>1JE0{J2bDLpiJsjz|o{8NOscaAYe18Y}T~ThV10tcJdga`sc%t7Io!nIJTl
zdzSxK#NR+j?*jFW{?zZNx7_*9UqnJ=fK|RZRCkC)I?7{6%t+wA{Ka2{zxa#1w!We3
z;2q3!U#Z&!52e*ukdOJ)m;l?{-sqs@Wj$*amAUn;J~^mNg=DR{ALW!&9~u4fi2_Lq
zAQ^Eek^&tE1%yW1XxVqwSM0sk#MzPkm^E6v??FX+m5}DUd?0*bL<P11^+9&W4M;#n
z-5UJ>h^sqN!~4!kqXaRJE9sogq00-W0-$Nj5vY>jP;*#kOCkV4<DWv*`29b;{#O3~
zHMEW8|36oeW1f1zo?cc;g3G^LL800i2*541q6?XT=}X9Azk-Kpc^7oMrgmRk-3Yen
z!28?$uWo?le5q}dsaTdP+H*8}RdwluI8lMzz%0zU^IM^f)j<jFRZY^TYVCFKdsMpk
zDTsZ^iQ)Tyk|l@2#z5Fg{E_W?!}KLQ?3JsoaI5`wIy=Oh%hdEzKUdr3sfJ%DY?%f}
zv+f6Z-Wwn|;2f)_1^m!_Z?gGoYckp)`qB5qAJp4BlOC5FRU5CElILdx=n8AnSXH1X
z*xDQ*PS!<cNgW}Tkc_p>b`OV`%?gh3J8my}`3x!wOoF~v!1hj61izK@?>eXZc!V!y
zI`)^cJOul3D&oi+7tA<-^L-*K4vKA%HJhnuyB}Ta2lNO4uaxAnbP!~gXy(wat`MZO
zn`!T-f$oBBDA_jN;YTwuRZwt9b^cD*s3hzhcHpM5&<+jOC8|%E9|!cHk}Q(oNq4Om
zNBJ?Z1heft5jk_1Mj}eoK#g4`$VR)6&Mh5|xf+TlPI0dB03p=!B#lJ6fm&-b^t1pt
zKBZ^2006_UX-y<Qe?3TIuy^|9<^BH|%<}2(5oFzG^aCV~+DPn{okS;?tQ^Ba4&&^Z
zy}G4W1Swa1wvn`d6}!9UUJ`?PYEi1=?>gF%4L7pNhwZgT=0+#Ge&<j#*Kw&GD=q*~
zIGh<fUpIa*Y2$lTBsdc9FiSB13O#E`JyYAHD1-7FyMrI!$w_#Dns>l7!QnqO-f>+M
z>Iu<~gM9iTr(%<9i2^VN3;3#RZjDV$vO9v-gB$VHl`7_&bWPMr=V7^}sRjhFE=v&>
z46wr<D+^0f4;@3%o|6>Frp#{MS9j{>B(=WmxJ&AlhFoV;>#|FhPAIi$))oi%cO@}m
z>uo-)Vp3p1+GB<QU)`%&0y|A=H@Ld)ooti3(=&);5vbHU2VxA5A**huvj^-$O2}Ci
zs<%E%9}>_6H5t%@cKf@q7K*dnklbz-_;G=1xw9+V$=A>xa8LOTg=E&4HO-rW)#X6Q
zu9lK$eG%UNbb>j{@nbUE8K<dJR17vP8ixKtlV!?B%dx(;xg(l}qt*rFFF)1Wi04Wu
ztvT`J&!Ooq)wp*$>gLh0(^L#yh|Mbo=<jXt6bqdJV<l5^cH7#}2yvU}bAOaSz{M{F
zPz~zrB0q3qvnZ+}t=-O)uZHfSsXBa&$_<thd7q9_%rEA70;zx&aGu<rW(hg#N|eRr
zJqHP7JFMMnoIz%OtqM=Z#aXtiYrso%10dzdX&^ullHFx=bQ-Wyz56gra*$5uKCssT
z$cT$@M(-qIAda<UdR20DI-e#ks4vS+kx>LWL2z{iXqxW=U2Z#6^!Q4I3swXYt7uRH
z=!mGb&Fy4ie!$5%MqJ4G28gr8dO?iDF56HwGPUeMoy)c2+qZ!qa%%9#fG%N#y(L+=
z64SSn@q^lTpf^(n2tGNB6#aJh_<>n-s!Wt~8j<sGpwXk;H{I2DTbfRivlU9oEN)b=
zm89m<`G-J{<`lv2a{P@Be(Z5NA74Nkhah8!D7@R`LDdoh({p|D%IzUb!!)ON##xUd
zhHbrBxt*LxRpE(IyFJ`Ql!BLEtcAD-QgcYJNnY<VK&@1|74_8yW!OW|-pz(4b(mPz
z&5?8w2t{^EPD_vtJES3+VMC#zt7|U@<nWQCslOy06x)4O$g~SLrn*PB{fp4p$q(!Y
z?7@7*>l~6Y(;zy2L94q^#z4n$31|+=D7Knn#EQ2Xy`U_>Aw8YoESCeH7eA#n>trvl
zb$N;RWC$>$Gk<)9*^gfTXfyWzfv05WmfMix3#E1u7NF==*@mawQmgQlkJ(UDK>Qgf
z17n$J18!t-s+xJoiMg9Wps6y3G5<z#_6FKN092#$>JllXO}DK&;?Kbil2Xxy`!Kcc
z`MnRn2S92P!8Gy(`mj7A3Uz~*BWO*FqxB!kNu#>Ny2Hgae^lWN@2tprRNzk{djgRK
z6Ki=l_Lrs=^m6STyDsIT6En${c&meRn{_&7B%FLgHV=(l-Ok)Ii*2vo!3f(-X-!Nt
z2h5o6a$hem)@s}ovd1lv9n<CPf@J&CKCaZr+Q<yk!G8Yk?`&!SNZ5LGmY?Kx(9f!c
zLIlU;m_h=%7@yNgE#bj<3Nzt;bdX`INKAWoa$sVLQ)BXi5iMIOc}~Ej1qBLVUX=Tv
z?+JP5Q4Zir8>-+-Qp2GrG>qAAD1+p0@?B;1Nd~Lt-+9H!X~jGc61JU(Ea*cF?14g7
zX3cn1*>~*v$?rnO(^G;PrPiZPv<{rd8^AR-Le0WR*Ukm@5+qgq5Q1cqqi<9)xpZ|b
z*v1n`2k$Sg#uDHMIfrZdxGMZ&Wx}Rj8H!5vw-{ZTtx;qz#twrd=FkoG$kM6FCOgY7
zvfAPiN4}+4<Zn&-=lgW#FKs_@!isj1eFIETYR#qd%HIR!3%XiwQPRuRyDZrunbRV}
ze1JEI!^|?x4ad4wE##wKWr0EJU)KMzNUou;j?h_W8$R1ba%7oy)!3_=<j8<Z1<k0M
zY<2(vYAdm&NH2#b$Ee!k*088-Ta8HHFPH=a!^+CG9}AVe<mn0RhXvVOt&R^C|0P>^
z0!|pN!g_kc+eOk2%n7>W^DpeRbvFqGIT%lv=1-8K?jtJcj&4$*kvpmmg0PUO1w+#6
zUl_|^t3R3Bt`f8cN{qtyzPiAzcfoiVh2c&~q+f?W&p%mGppVoIRW-PB0D`0IK{<yh
z5;!Tgo)2{vWb6>LlR`zwOxtvs;L9nyH@8_@$t#`BD3|e^YI={HhU$yrfet$o*EcF9
zpJHl}U<9bw{>Sk8OP-7Wf@N$<o=RiS|2=cspGg~iJVIxUX-qjSI(3*w*xf+H+pHv8
z@1g)bKJR%|JnTK7TBM~`AL4#8DLLE;vzr#qI63bwRg?A63E+pDx;zXxi5ttQ2CK5z
zQ1uVvy876TtDYc({Ofmr8@~S=`Hmil4f!MZNY!k(TIiot?WVo@hl|wpsu1?@lYUv%
zn(yl4A1hbTbU)JJW}FL!7TtNK7;z3z0J+V`KDR1rnkZKFpsX|^A^<~cTuS9gGmDDd
zF^ZPOK7BArc~#ylITb1-8FO#znr6A~1*4@IT5^?#q$<6<oJg~kgti+o2ogF}){672
z-Z|mr*bLCQ<(o;s&DFUBcYYbCL4H=)eSvDMe%gJGoZZH*u9HSkgOrU6B6ZdUA8%mv
zZqN3#0a}pKz9PiBNn~?Y5{T>;iiFcR5nG~qY0s%Yl`Rn4O^`?O_AZ4S-oBFkkV3LC
zL6?r>%BSiOdLt;Vb@lqC9FOt;=p5+*45KRJpn=0Syg?_~Wv&kE?kd%A?}rmKgAQXq
zY_Cf-D=)D^_4iblhUEjlygr(*&`jt&evT{bSAYKYhxebp{mXZM9o~QZ`tj?Zlx_Vb
z{`>mN_dk36_Vru+{PXvpzW)C0zv-WT0WS92=lJ~HU+eFDayrcKBj*xQdN{cZu#dPN
zqMCzyTtd`|v13;A+#EZUhM}#N<E8XzM(4<*y43Sq$6UVKbU2$o<7{0wGSqHh7Z^qI
zR)g60G}2A)NlJh{_uhCAz*QxYLR%`O#{N(V+H@@3Yf3#q9vUz%U@(@K%a)y1eD5rv
zm_`-8iY&y`P03=1EW;KJSyHFLrzs`(jhOop8U(YEcFpN$Uc*=#(VKVLSCoIqraMS%
z;}yblwDy{D%9u{cHy`@jp>?P#$cF`0vKe)Lm9y&I<qg@ThJdnib4j-urDtBxPiScl
zkOhJ*IUrMBv-axCwj3ESfb5tjD~U1zHBfl%tZMMR<e2H?A&cE~`7f?CbC&{B%DAFN
zovSb`2+f{&jn46$N1Uh&O`SjkNq#g>8?qL84P%#}-w{qT$02J=IXg@a{MPv3Dnm95
zyR528ZG!D=xPe+~dsQK|wzO1JK-+aW%1eU2TYnv_cfu&RZ!p+lQ|p0D&g!U#+X&@1
z(xkb=DvMqvplonOZ71%@Zh^>IENgFQ;N0L)c94gapg?AA+Fq4UB9#;YV%(T8ZnJB(
zJS!U($(Ott2%z00S6XliaKHc(Fm%DGPg*Y^il{8?3wHsIKM<R34*-8WRJNF}8%$W-
z(itPkiUn?X27pfuB8U~yiOzD^cgb#kp%&}wZzQdeGH#odSI7-2$4rOW6QH4h%;XR~
zGn*f-!0~)FlfDPq!E;tD&X?;PdIfk<#CWD+Nd~zL*Yh{2&^|m`)}^kW69Vp6h{-uY
zgU~*amv?XgVTinyr>3YRg6?fG*Xz;fRTwZO_FbJk$4a}GgK@12u#!?zIURpS$pERI
zq@=C)+QVe-=-D(ll9B|pm)BQvq7|q9Q&qEtedw%@ySIActT3&7E&mRg=+CGt2#}kk
zs3+s7R_UenWdohpOK9_6w(3M>VEa1z_n-!FHS8N;OV)Jhnqm#_$W8{065{8qd=oql
z$kgPcl$UA1oEj;rnu5LmrJRr-h4-I-_gAl<8;_cj8Zh0P#z|_;hT8stYH(0|9cc9c
z<kgV}cQyE_<DeWn%eHQ4m;irb$CpyW3hIL8q5PnZ7nSp==WwHc^&Pw#!nx#VP($jx
z0F`+pse?ps&bwdWF-Val4T||=#1@>#$_d4q2K+8)X7Gh}UYGHzK9aJS4z0F_N{{gs
zuMjSSb*v64INVjN(QuhM<U5_3!axJNOD`bR4-#8<8plfMID2B9z|+2fJUIq;0)+r^
zLtznB^YG1<D4z}KYm2LZDj7{644a(T1DYD_xuJ}aYgtsz0UOS>=1*)}wWW@L309j)
zH%U6G#3yQO%AQn#o}MS&ZR?M&)D5UlTa5{d+3v9oBLvePgTsM5Fp1?Il@(=`=Mj31
zJ$noua7Md2JeuX$fR)b@tJ8YR$oW!jJ&diQ<2@$evW%h62eJO8)~4<~NuGLjorDfh
z+BBO)?-a_znY>VO!gM)Jkt);q$Ohlku9!v+h?U6KLU!b+x?ndCYvy2LA%!dp^}2S8
zI^d%)T<;bVSg`-|#|4r8h)0+x?w6Rec-m&{G3=wY4M)jAp4m~5KvFpBsggYlVGp`S
zaQlL~T`yLmKOL>&7MMSJdP>d?HYtK8PFFk=P>Hhi6`-C>>QHK_Kca*8UR?J-q5*d`
z*n}0dpZ$02JH8BWKZi}_Ey5@iV&naG8fi!(O2F;ZL)Y3xZzm+FuozWVZ{jiCY%}t;
z!%+>s>LoA^az1pt+a6IJH&&ABQf8}Mq;(IXnx-s7#PtWi&>O+OP+(@^qLV@5EaIUj
z6pK9o4RC%2pR&6D^s*lS7%Af3*@_M|+ueA1IhkHGU&<e$YAA0@$HtLzQal5mw1rLe
z7BKKfrKUS$Kdw$>DRurt++$5=nxYKX65=EId;hQD2S511f6<SB{-f~2AO6s{qFHlF
zYORWIR50sZ4)G>G?8%mzWK`W@6*5_>g!10C4@yjnFmSM^-^ux2xN)m0^y60_KNbkf
zH&B7#ybcW_6N!i%XdqxdBbREx8(d{w84(+TKDKRuA~;TDEd2aP&BC55J4@V*zV0zt
z0RE>zFFOC&5p_ioDr;<Q=*|H&eOl|pFnwv$sQ15k{VcqFo86ruER5iNfWc?Vu1|ar
zHy#lx-FdjLG+}Xv(YvPHK3*N*j(Ri>DnLtPNk3%_SdX)hGDRz#aZ7OWGfUNhhAKQu
zL1e0aTlfW*RZ5Y9*EF}g6cGId(mgg{im32sR<=WEDJ57xOB|gD$pY%7JUm9xmCK*p
ziK0+gXugL=wHB@Ru+8=B4?E)z9S)5)L*0V)#a2CgI9M%gb<9ftgnAvS{F<Fy7`+of
zDe=SZNS!ZmpuSvg0~V*TR&iEf?r}`AS~-0FU&h|0Ns{F{6WiynaFVkisTpuDi8TEX
z*}yy^JR_nqULB9j&N3}VfR@sXmP4&b5ElS(K@d;kNzkmi?*G#Hj-T&%^o3}qYj(Rc
ztGlZ*BHWLk$M?8Rmn5g6rJIL(ROgFG?bEL38{t3Y+VO#e#zJGn__J?p`5sywvJItf
zd~)0mRz~5tcZIF_sjkH(h%E|s-%k=qU*jQ<D#J*)hNLZo)Ay2I#QM?|77#{*^ngHO
zEd?sX569x=gHb}hKt$ZlSE1%yXoPLh)KCm4_)6NqSWmrb&jqn7u=B0C0cJm_{3!70
zI4zO$GD0QQmECW!{e;FAu1M+7(-XndIEE_xY`Yt}H901s60)cW0s-#Ml~i1yo}!QU
zA-dk%5}hXZ_<hoe28fn(SMeugO#>j+yb#g$M5kGfq`Vx71KU*y$kt}hglCn^&Imw~
zE%f)$QGyhSAi9||E25X9FpwuT2C4&r99IaX&QCld$;c6Qc&gRpUB}tAUoq#1K9QES
zQ*r-v3AH`ghOGDP)5)SlV6;t%!rexlbG?Jxr?W64d!z7KUCmojS@%=qg>N>c{o3^j
zBoupLvI_h-W*j5r{TKP(x?A&OcCW%mkN9@)Q@#qEUTTiv?Uwyf%#I{Of6b$3RqR;f
z3!8x>n85pPEwB}eS$>YFkRpx~pyYdbO2Z{nIyEh|0QwSxt4jgC1<lPoRJ99-lWI@B
zm`tL!)U8!{pex$!Cy|0m@-LbWRL^abMBQ>(4Am3mu|ap_raq=DS8Z1g7{?}S(R;=^
zM95AiH>A50`=3_t1G7!yX|SmQKzA*3P6UM)I2Y$fCP!l4OM5qEa(!|<Il4J*e06O_
zs8+W+I;bQ+|McbC55wCJK2wJOi7_*e1$xT_-e^SBc9+}Pfg+U8R}1mDl|CZS%UfJl
z5-GoY3cEw|rsU!o<}G!0Fdp4=7MZ?{;-Oh!^UvNQz;!t0A_T0whGBNSk%~$l+TTYW
z5(}_NB^6K5--V4&R3p|hy!Xg@ehS}K_CZy6a3^p`tJfz6q;_J%qS`8zExCajaD4VK
z@$c0UFF#U6jEum`4>N!_iCZ)eSiHD}25#>hT#JdRa@C%uV65vQLn6FnP-(YU3}GZ4
zHtcqktzEmO-k*g(`?C^7|MBeyoXz}P76Y8`erb&;c)sif7?@#~Kyta%{jTbrwkW(6
z1g{PBG1l4TD8bi;E>=(CE>85RbS*)#Qg?QHC#%V(`EavvW>PErgyM~Ga+!C{VfP&e
zBCQTIV!i#t=Vaq&GWKi!gk9;5sr*$^4D2#57iHw3BOzJ;1XDTF2EiCDzmhU?q{AN!
z1;~R0>Hf%5DjRenZpjLD$U!rLV|Gh3Px-ia2p(3iw(Y9kVHSQKK$W;q(*c5Mkl$Qb
z6jN_iXtzeSd=^4Q(GtH5P^xA{dV{d$cqzp8-ixKSc3K3c<Upl7dfi?<jJzi`cB(Bb
zeItCctes!WYO%?}zuFesIoH798%<F>bMh$wu68;pDH3l<WNu(Sxy+BW&R0osKkgyR
z|DW?H_fZ6&=>kVBRnLkoCrv|Q6~$|Ad19+_3<j|5u)`#QOBXKIa6}j&pveX;rb2_Z
zzTI&!w&b`+v|}9<`|0l>$d!jHukc0AOHTEFt-;hw>1M0qQQQvhNX`A6+ZCYaV;C&b
zR|XfkP-JOq#t+!J*eMpsvNN>KEOm=}n`VVX*lm$hh|9F=*?LmdQ8_4EAjx4n7ijpa
zCg|*)RhS*ZbD8QS6|!fwjBi~~N*<OZYM$DeY3!GDkIjZ7hsIZHHLdF8m|x>w69q-E
z3wX@3o38lz-fqL@a!^?p8C}vnE}yk#l#$xY^HJ+diAVao70*vZr9qaTM5&vV02?yz
zEX@`rz5&IT3L+T&I+j*QIOJ162f2dGXSllU3u<-Z^ki3J0A-n-tZj*-a*IJJf`K-)
zCT7SJ9QJv2LIIqXy&uAdBda6NLvGEw{DFLv`+_|GkdHFWcfX4?jRB~&?Hr)NkB9CH
zB$8(k#7U?6*hACu$^&>**{Xq)4+y6#pQV)~(z>v?(N)#&3M4BzK$@UZLL{F`QG<Pe
zZ8b~1gn5r8myC`Q&Y;1+dn8ugoa8rI5y?PU-wGzz_e6JKe<d%v%?Ss265DD}nr%K6
zp*IT$1>|`zM{D*QLSV5~pm-J2?84r{)F+E~*#=c(cut@pIcS+DkQrg6JRD|M7oaX_
z=+(BNkfs9|>5!m6!;3z87DWHx(G-i+2CN&n)W#*>Fu0u!l7l5mjc@fELU}3?q{fte
z@iSsH)eCtkSr^RDP~CDOi=OB1TAC}`fs&vPKs6u8QzF_wOF#4ycWmFOnTy2|bc;?<
z-Kzv+iQ*Jq(tO8#CA1U-KdW-t8r}J}9CG2^(GEmmt~UUWR035^5aCF{My4eBd+bT&
z#(0S23HW|M#6=z}@~o?uJ~!z4^6;Z#Tv`Dpq$YoZrUQcrRfMZv?Z9!^+kOVs-!ra5
zP8HVS$t4`Jf2>`KA{Fxk>0e*LsFmEJ-+YGGhaw7fM}}*mN_KDVV-8Y2KCICLFJo&{
zVT7(G$C4Xt0JUWwH;dc@G()WveU|b5s{^sr&1xjD>dw3sDDwKE?jFCknX_ZM<XQ%o
zvsRNMsZH!;$D~)X<kz13pcTH1y~^`QbcLcL+iOtxLj1VJ=AuaRx+C038*ZM}%V~Oy
zCzR$dJmoO?v`44iX|FC@@+7z0GrI(8U&Qvw#~=mC#txejI$W>t?g+9GsN)e3hmrME
zmldM+q*CGjkMxZ!qM-<~K;GisOHE!4fcii_2_-S*PSi)+G~xaqDN5iIYL8`dB?pUT
zFqp)F^t`McW-%VvR&bsn1LYV5*>s<Yag9o3K<CL)fXUl10|eQ&6;kQ1^ktneoq&+N
zoK!chj-@IxC^r07v{@VhQI$MR{n7KXLgJ*rg^IY7EnCu1?ZC{mzatsYrZkYoVd?fz
z9)Rvzp0+(~vc9@8<|6TG%L=57Sy)(dEM=CuttdE7E9RhlIN27m2F?QJk{+5^xI7T>
zgYLG`C4yNKO%=&rD5g!wm<qbL^uB;~o$A<RwP8DRF%`7CjXVM?cwl9)sxdm2)Qf~^
zsAek&!Lo)W)hZZa<03R~3_nE<l$4xc3jlI))lrFSMyZ7e$tY%viPk?}=10`U_QBj6
zUH92OWJH<XuZf1BEv1oFG2UH-(4=I_hQ!-p9%vyJbk=gL7~4p-Pw=`L)o7#U>AGtp
znyy8X9hkexVNixGIMfRg=%=d-mNo_?SWUAP^P(r%GY^xsk5J*0JNzi|x93^DE3$7>
zFjrAgixP3S@US_{aC|)0Qvy4n7_mEWo6hsEj)!j5S3?hCqTQZK>J^}EynB=y*ebCJ
zR#kGIbZc@%UVA?If5+d$*T10M$~|)BA)T|n^ek^iPBs=}Q%Rx5WM_fTAz=Hgo|VAj
zT;V;u(%@sG1X}w*<vr66_z1+d%)5>VvO2PTaZt&8(-XV)`)gQdZB1}u0c~{@*Vg6-
z0y;^ELDmM+v8=$GHziDD5utLlmHXHz=cP<~5OyNzU0|9@%!96~qmO&A#DTpxR5+mW
zQv#IUEe2N2T*KV4<0+BQKAnm?(?j>gAy@DNgrZUD`2TtM8;jSLls%Bu8;Ix#*1rS?
zrK->&S!mUPq4S`|0nf`qM(>omRJtOnY$PA|s7o!=Da0yYfYPm)DrA>8BM%{_TL8h(
zT=my<vCJ4oBAgHCphrwI*nN(0e4e(;--JKSYw<^Kzk!?%3?bRvg**?nq_V!_1!^kF
zBtA6+CCbLjvOUrHK_InaLCP37G$Z>5BxkK9wAR#w95souPKq*~0e!)QH7}`~rUgAJ
z)~>g5M($vE<yh;(5!@ntB9Fpc`^Me{`BgtgVPmj+TIs`0eO40_`hIx($D#{a7Zq(q
zS6By3N`|^m#QkCfCBImQ2t+7}K7NE3giFIiElRxM%wS3T>a(zhHSGjK7ior*BbXqq
z#wii5j@NMORm8I&+3ZI{h0IytN9aJMTo_w&0FqJovg*}bOD+U`9!M~j*(TJU>^1;?
z^>Kj+qFqQ2x*YmXhAW%HHd-`Eute#Atg0=vs?a82xulWTnMPh9<%1lfKup!-GrXd7
z2Q1KV9|;a_{Z6+w%t%yll_D2EfBP4TT$r<9_f&J9M=Dya$D|T({k?QF(KKKKR|^e`
zE|a=M=QlmsG9Tb8MdNO4RF{5MH5Cd5x0uDvSLkW&=dL-Vt2ynu#z%ykNIaU3ls81C
z#$^d%APv(4ww@X^)eVt_0{QJ{S|+Ou{3J2x1NC^3ZnJ-lPw-SC?qGc884x43jFuin
zRo0>34%P~4SKvUfLETc;{c?M*?b8asTd1oGV0AXV>9|tb>qmKr^q9w7Y>#{`>r}q6
zWW|;ztNl260u>e8t!w)Swr~G{e!R2!9zlgX@}~#%%dP{wU2u(>v(_dCQ6qevnX;&h
zI9Rk^uR>~}A^jCmZ%rx~1zU4po|5|mo9}Z5FnI{eK~+6)HvtgdK{pBxcbESZzIm}V
z`LCI1^Uw0@@7}-b?e(U477Vw_nxX?(A`H5Cs`laLo#<v!0uG4jxM;6y8J?y5Q2Y*!
z-GNFWSsGx;KiV$8vqgh2H`=m^PL7vyjzh;z2dh2_?}Oa}uoU56tDVUQXuuZVh>`^?
z%DO5j#^(Lf%YUJl$o_0(PsoBGj%d}z#zqsma_(4h?cEVON#<_hONp_#@1|7^{>_63
zA*f-#eV-0fnD=em7uhwFTBB!ClC9IBjYV<H>+_ES7iV`MHAIUJi_Hqv=VASXvN8O}
zt+Gmqp&d#2SVmG(g%1fs8vElv`PzTs>t9fzRJMe!3a>k5Lk$Q$N0xNv0AIam=0|a*
z#@x_8=nbk*c0}T!jnT7>1RthVr7F|PK?cmvdDz};DqSb#H8;hZ7lpgUXa{<rjNXa#
zekJ!AnQT953fK6Y7dTw*Rp1{AjR5WQNalyc9rO$=KIvJKU-k~!0}*jqRHPj(Ck2b7
zt#W$tp#$KW=oj#GM|{fsiMI_{20QE?>X<0Cxvf$ai3gge3%nz0d49r#r1kK`7PTPt
z<77XtD4}HsTRH<n?Ck!Xw=@Lb4j^@vDO|#jwS|jFdc>2?D^LQ;ciw;f$G?Vu?+;jX
ze8Cv-2Rj~t|E~Khi)w{~QbHB52AAD|ID22G^LQP}0yt833yK7HR?rL(vCL|{u+kZ+
zpQl=yXz6c}RwC_8hmR&L=o!&$FAYc;?}Qkh_#*x{a`NfB46)IV{|frb&X1Yu;^d|(
z-C^IH_)|tha_@J0l271#B~5w&La|ugaqlIDAG<OoS@%E_&{?3zzN;5)O+%7dy{jhR
z*#J1R@H&iE5Z*ekmI3AH3FPRK+{GC~F&Dr>|Hesr0SFdVFs@Egy%1oO`06WNR=p`y
zV1kd9&SY!r?p;B||L0vkqlTH1(t;(a$U57=a5$qfqtyOQn@+m;i<}gVRu|*UM+Ux+
zg4=JG8+tbe9IBf@dVo4TZh6AgnUhTwt0y!j-O5&7hgGSbdqINL%&iTs+u?3iJU#yU
zuft#GvQ7Tk0mYA$t)^N&l|#yenN~gtu$cKG2QSQPNkdla-knNxGvvj3Yx1X$3QB<-
z=20|zz$wknk6GtUGuQD+cFOyAFOpW+pc?{&IHgQMlvB~?NtbiaXu(`tTI2!kKSk{j
z&^`f44ouHjXQ0gR3r&k0s=Wb5<>JuF%-2(6l)bXhly7+Tru0<}#4H-&jDg4m$klS6
zRoKwoLBCN%z73T8ov*(A{<DyOvoO<xu##U>U2a#&bUV%@n%;a)yUBC1+|`A^piU7~
z@gV<!kI>ODg)5`Mbfn%au$s+l6`au8M9lfg&27(a(J9q0@TTuh-C{K1=7H&Z$`Z!c
z8by9R9O`|<pd;79G^v`4JZY5<KdLZ5n4Y{w4A{fHXIBrx1O>DVkrE`WB)w=qzA}qV
zIPQ=JiRIZ>6jMA--c;G@1Ac(^s6m*zanf>o25Z0GP%?rn?+(f@b9kAz3t(y617Nw?
zA#bas;_k9Wc36#_I`SM{VNV2!f&BOWCVV6BL9P%syMAk-bk%=sX&L&ywn)g`Kv#Hr
zO73|Nr=i}m*m0r#EybtU+<UHR!Lvc$qy>63xS$XmP<lSw6m9W=2Gze_>J5F!d`(ke
zUT~(Z%eps%yb2`T6E68@B;I3p!}>V;qJ+X++A+G8bqfz;E=%noW6Cd)%ceh1$gwc?
z$O+Lzc9h|9H`krghEWBi{Up48a8idBIeF0)awC%~9$-#AI_@B8L*PanCUj{Nn{Z8p
zBb^C-tY>`0fbRs&K4+V#6us1vNXtK~Ix!$9H|`#lM+r|#A9=_g0jCe%dQaFoKsP{g
zG*_CM;Ch;0FM|Sy8o6Ot7g1X@N%EVur2_!kr^Rz*Ss8p)OeoZzLw?>(ww*)GpsZuv
zC-cW0CAL{w0te<s?j)e%_abI~GG~=t<yeslci77H{|*s?zkUC{=8lqW66_#lvqiA_
z2+p2t`%GeEJ|w%ylBz)!oo4VHsICM8?dPm%a1!&YxYjOKGNjhi9f-R)UHMu%HR>-W
zQ6iZ=<TaQSS0h!7WYgf#UyZCYoD2fwQrnhw4Kloi_<{`#$y}oYHg&&D@m|nVb*`OA
zptvSrD^iv($_ulx26PH92NO-nkvEK|ne!>t)O<29C|36t%$N2Zo`-$@VUKXHEXsIl
zen$q#4LPW>BLwo9?|_}3$P!VceSQs01PJ9$8k`mFFlBE8Wq0M%RWkoPm$D}iS^RXR
zZ{3mG+PdWGfw_t8MPeH3PU@T)@_JlepcPwOm0G~~465|;&nKmiUuTUE`3+5@--P#n
zvMZm`D`>XS4Lgxrv@J!&x95QA)<uo7oyx0nN=s6JNu7}Lr%mChMmX+=k~oi8Wdo3o
zz)6_`6sU^e0Bqe%NJZ(u!4QLhe~=X5E3GpF5Pl_kSpbMh%UznhNl3@2C(f>RTY4^E
z`$E1&-+KFTAS0l$mf4ICeln%pxIk8DTRTkSE~)2N-@d4KX2v_(vt4F(?#3oOKJr*a
z*RvnAhhq)f7s_g2$|q}>cj06mthV%ZEVvpybZx>X+s?@X4&cicctHIDe#DXnq7k+d
zVci39^`FVMXacwDLyz#DMqQ6cfRr4>*{p3)<e!CL09vp?vdE9OP%*i*!`YH8CDn&0
zkw{KkYnP&s!74}&Ka{M|Ei*bV5jwE(SKcD{p3E9_wUa4-9S2$E1yBnqWMwhhott-P
z@Yr`niqcW1dYGM4n`JiWT)XOcZBN?du4WR%8h2&gD!VQWRp$ZlDVhRKnpQrY>0Z~+
z9?h>YQ#P_zw6nLhzR7iGulA~jzQl4*riQL|E#R2RLsokq)wj?Oh^lNJPwHmLtVh^E
zLD8cM0r|bG-dmL4oJ1yPp}Bp^ZNt`*l8r6C0nFSTDrmz~`Af3<cxNA~P~R|9tY^o1
zDeo;|zM`E`DemQR?ck3p{FJ1)F@y~Cn~NNp8m?{{bx(R?8vsB+zrW^R4zEG1A$A6z
z!gDCNX%dvT#9OxmGSFFvTqU+l78Rb9wz>|`q@}>TVw8P?HeZ8;rnHUoNw~17Nj#C=
zRiQO2*EiLaHA`s5SbGdUr0d0D)OpYS6MO;)@%X81DtvFyX;roYctbyfHI|QViwkVi
zc4J+J^YAo4U;6_HD?2<MH4hIP;70#YYQSsd#&yWqPto@YRZp{NgZ_Vyzmp4KF1hkw
zz%Q7i+msm}Xp96V*LB*UfMRPBz~bJST^qFVq4DO(nvZ<3Ay<N;d-ohZqt(j7yh?mm
zc)+&HvV?{UH<SD<Q;!6`Ih|$qfSu-Mf}m2z6s^ZhuSw1Xt{~NTutV~yGF1a7P3Ral
z7c~{*v<GZnRSdMr;s2=`OFShMp+14TEIH|nmN7amM2;lMQX_jP^5CS{QW##KF7pj;
zN&w@yn#d|OL%3=C=flwhdeq;*__n>65o_)cH38GH(2xd3H^FI=(1uh@LVowcIrEN6
zsv(eLM*$$AU<oD-IjcL(G5H>nAOQt1RFKqm^cdDd0T$sZFUj~QYDHa8)g%A`!Je|Z
z3)TiUuuLC!z2CHE)ftSvOaK=ldf0_dh`x5-0U<LHoF`WTU<>ms(7dgDmRm1j41<90
zYO_UB^3fFWo=MeNuD!=4n0^A}fO&w`f?JP`Vhn~)-+uf3s<*(y#snyoD}bOb=~=z%
zpnr7k7&^qW3d^VpgGDLiOGVQMWPQx4ala-Yz7tbD6s;U*%i0P%QAbq@CwC(Bh9uuC
z`O0%frzpNs3M>LE$3EJYJyUt5lj;&vu_<XPty18wT(9MI7Z0{J=hEgtmc)!!PTCd;
z9`6HMr7OYbGa&TT*N_$U+P5te>$cYb*}6{Q6%(M7qM$6(7NN_&wYheliK=fu<?rF^
zU+}*L6R`}{|MXo9P`?D!^pv=+seyQe1|M|=+W3IvaYOE|e`TLIi*7#1fE>}2r-Pab
zg_us6B+*hQB4?iVLMI%3ED0gjD>Tv-Cg%0D+{l&4Elf+RUJ>DPlT<0vI!uxp-LitG
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%0DQu49$GwTP{0?>4l_B{}_v8!N|W%zC&9>
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%0Dk}39ByCzIU5yLcM+o6FDFaENYBu
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%0DL<K?1>h
z=!C>PsTv0mhpgc-hFb<&#v*Bb%g7Bs0usGuE&4CB>6z2BS4FR(`2z?6=432BL74z?
z+AawMJWFnos4#3ZdZ6`kx5$cT;-kw@%bRSfhElmbM(zV%Sk>>yY%cvH*ct2LqT@(C
zkUu50**qA-DZ<ueXzWSMuGsM}z(>LKzk%Bc%Rh;~>e%4?!9~`GjlUj!er`&n%q5mv
z@vcG_WDZIxZ?nFn=I>4Y=%Z6O(P06Vo442yksB%g_vU^GbhmOJHw?S5N>AIx94a#w
zzm4s|!i4#stb4bJQ3^qc7%(li*-i3CB!b$w-<^z_C2S>3{*t(zRQ8JXN?$92YW;_U
zD33hwu$_U>5BV<D)<~Vt&ie+!!^mxv$+k0RK0|^bA=ZwmCJvw)mqo4zX@g@WiNFg;
zuB(k<Dmhh8ul}P4EC6B_#&W2i2QR(R$TM#tz?-ntcBjIAVteO`YXYg3IFhN~02In`
zfZRZGn@FVR)D{m}iR9ky)=2d{`6E;$j8g++Z!B1RK2ZL1p_3b;IQh>-9Wq(XQjS}t
zikuwSE4&K^FP=hUg<d?bD^;k+5dm2#cV%(pC3r?R!Xrw6xUAz|sxO%1AZNH)tZo!m
zs+VGl@Sr1-Pyuvg(@*nwKluxf!*zqfid!NVBeKvH00K$N)1fYoht@%%I+V|+gDju^
zxXDh@s^;rP10;#n`EKeM1*TPVD$I^|5SH0cn4#}3`Hm}*L<9<ZCM6$1VxzB}b}bxN
zlo}UwOlmONSmEbLXCxrQ?K?3{@huEL+IWN=^dMvrm3P~u1KE=ey=<n;H|R+;P>>90
z9Cle~w~7`6lHF>Me8+hHL~BD*XwcoXe+6=;My>^%hp{nGo<!O+skq0Q?WACQbruZz
zmd%E5-#$2w{`%EA0<yu^<E!%DxohCN={rtHf|F2T`r6;U{!@^DzPmgR4eA{u2*}%m
z>FHN=@8l9%7~OHMmnG8C5OZGDz<x+7kpvwKM_E(f?*aBc@A^lk9GtNmRdDF!w{cf0
zT%OIgh~Jx;Wie3S7D>0{wnBW?1~%lf7_9?}UUJKleE~=s*nMeFy9#x4_54N>TuY1q
z*rjxl%1brwc^DdN<1U*lg8BG>zP3gAH9~VIZ3F1H7+DLL$gy>@MhCbvbr>NZQ~@dg
zPlR+N^2U@@Z3B1RJmAx@Y*+Icus7#Eb2AFHyCoJu(tD6PA1)WC`94ts=)*%h(ajAb
zFt9FMT*j#zcM2TLKnPAhAb3g`zZ0w29ZCt3^}s<m+l>A&@;ID=&1vWfphn7HrTEVr
zF69md5Vo|2mLFTuDw!;KDGr+3FapsJJe;eDspY_B$S8W*&#QdHegYzlSd?2UMb(Gk
zqUMNHMCq}lEfnuvl}2|EBNW0{)D!@cPe!ukmV70Lr^^Md)p$n(z!H>BCoeXENHvse
z5=5-gZk-?@R?bs(vaOOMfbB<3PuRokvIlf%4xb?@11OCUo`yo0UE#ik@cUy!|7UO&
z!e(weSa}!lC7OfF7t9#?ZY8CJV6tsAiw({YHlP40eWRw;Edzn2W0`n^y%c1HAvjJ{
zgEH>!u0DgQZ0b1z>iz=bVOWl9uA)p&SxS6<AqO#xV+sRZ4x1=ea88diJ4sbjX(eaP
zyDH8rJP;dB9(qmJ)2Rl+Lhf*oD+`!Wv$X||-EiFc*DGa-uSngCm~p~zAXOE1pr`{h
zLJ9&2<-4JJ0GOD?b0{y_raX<31jC!g*U)kV*2+PIlHcQHbo93Dw4Q*#6uOgQ3*f@c
z)qj~K)XhS%g>Y4*AZqu#GsqqKfDQzJ+MpzQ51&JLau8vXweqgc)jQUi5m;F|r3f!a
zEGN=XoedQeted(OmMa;NV1`}^NtXHtZQ|hEc#HgQ6`4avr&CcvOs*X!n#(Q35mTOr
zLOTue<;@nuY&$H6RbFkhGDz<6>d;5P9Zr5E7{=OG7$7QK$42Evnb&K_01bn1r)pq#
zSTkhF{l<P%3H-{_0zX=mQsR0Gp;n&2U)%q}U;i~NmVUux;5SEL|IO<^DZuaJb9n#3
z!Si>2;64R!e|Y;cynO}W#Xr6MKDiJ4?(+T5U;i<@C1Bw9AH06{`dRq?=Widr{o-AU
z=C{;CHem*6HhgNi0h)iSFRVMPYH_QW%!CvkZHxty30gD-se5f1dB7#Ftea$h+_;hO
zL!S0`(gsx+d3r{0H-NvyeR*i^`t;ci4?<*-Rg&6!g}LPtEpX#l_?89QwqSVg&Zihl
z<Rga=P;<)o6|C8@xn7wXU_f9G>MHRG)62Be^yC5CUjTv&efZVee~MiMW+$~?LfXKx
zeOBa6K2K>=egiQh7<hq`X6FK64(DK0U|px3X>5V2OGJ4B9Z~UCggxHQrppccbW20E
z^ChaOwl!h^s6BwhvWpQD;Tnfsk^-<gcJ=1y+SC~M43tBWpdxWiBD`xch0=VJq*_<B
zEliN9T`@t3MEMw$w3&29h)g3`MKVdsQNpj?QWOxtv}@SiX}FM##%)QWl#;bAN5$ir
zIs_Erb!!;4Z(E)86LrGSA*n(e(-wCWweZSy)CcgRlZzjN2LgpaOEn->k+JjMCww_H
z&vJ4kVyQ+%Q%5%gt+j?`^+pKbF&H^Sh%6pz#z0;Aw(}%{+zF}>F~P+F&^aRKI&f~5
zU;`<MKchXf?IuBgsU=mIRTR$h2Ki83#MGg>w8}7@IdhODGa0CaN6#Z+9Gwm%nM0%E
z9zN1Q<AfOkvilPCv}FhKuv!yCHI7J=s&PNcx?jx=rVQ-x0FRiiS5;XSp$<Zdfw15n
z<8=1$1Zx6}hQ>eKRSHVy(_bNj3Ph6qc*kkOwL97xiZxJtk!1h{MsGyD#>YV^0SX_~
zE_Ey+$w0o@`YuVne72Tn4D5Q8E7dT{dFzjWSb~0FDZqGWmX-+t<PyZF(AO}$gZ@|i
zHfy9}ObA#S3(4bgk_)WesHi9b_nD1$kg4ROZFj^B=91WK1)}>R2};zA;yqde!HgO0
z7*ez$5VaEFFMo6&e0z|@)jR>9IB1jrdB=F?hn9B^Y>b7^rB<P?Y%r-cRobQ-F~I!;
zxAO+|w(%%CS?C#&Z*nhmm#prBi^IZtoLR6kCr2o99f9==2InuJ-mhMUrgeaXfc@R4
z_XPHFZjXVhtYf9z3z=OkDIRT&2KZiXo92YYFC#?$%XdimI1nB#Ly&Zg-qD46Kq8Gu
z#uZr{hy9sKdErq#9Jn3`9de6X5&Sq{V;ujVwSCox3z7LyNqEv}5V=$XY5J1E5g<O!
z=ONJ5$Cd+n=oPTOmH?>IECcIpS<QNeJV0<cRmM1;8VD5aB|LsYz>9$N?*Yw8_Y_Db
z!mx<rXdHeo+*Fg=lA*J?Bf3m<C#WTnU~wnscN-pZZh%nUd1wZJZRB35pV){3xGEjp
z455Y2nV=dP4`+jAr8hde5t%2gjEfW#8Ej?Q*%@pBQAz`X)iID#;HYNP7*zc?{r2}9
z`VS$!xtYvZD4O&Mt2HUc?Y)oa+j<F}wF*n-kYzyr!z+Twg!aJ9VSH6v<d!7`7L9fs
zwB|e8k3A5{C~Dx<qb7ek7C<0iU|hlty01Qag4+Le>rAlT4k@DaftCkLb1Z!OA$cyL
zbu9OAYq=X%Q!wv~t7==Tw$dVTa%1o;Y9P-cJ<a<67Dz8_22AyJOytp{d$gf9${;4r
zU<?4>`jB7UW%5@l1@0D>v`XAXI%y?(=F>FUyk6}QZy%sy8$X*-bb}TFVLL6ZzoiJR
z4g|?J1Rj{sM2RPuKD4SxH9N9iDtlmAT7PzKvE4(bbrmcI41|dDLquXTBaR(1eGQCg
zB0C}~{gk!}PEWx{$R3K>8~d8vta@~f!MafeWa=Tr?MV0~``u>fGokKJ!_RO{>-D>~
z#M7MRwF47-8rD?vo@3(NW+!E)!7)Y{aL6sFyfecbj_RQ_9NhzjDcZKmDiG`daVA&I
zyxv3My%&7Yo()dzDYWu^&{sHG*_d5eVjsa3aLHgDW;@ghVg%hKX%mh2W~OanhwdU|
z04|`D7*#=WCmoCr3b!Sk;eUn^gk%hGrFHF6Ss)I%CrB+|MfawHEDk-~28lB&%WI-p
z!LcA6NeO7FC`5B5N)3qR07Jlv;2tm90Xb6HGWl=lcCm*Ny$A&Fxf=<A7^)7=CgGg8
zfR1Cc1NB<Lr?NZ;HxOt%m`Q+#*^Z+lCTHA2kRm7**SA@XR><=K$zn}c$sLm{rDf2|
zyDgaPT;700M%U)d^uQagi%=@xPt2WcgIfjb94J&2&Qns<WS%$J$VUCQZ)jiyfWei>
zx$IqUmJCu3oWtRR&>b4!6CFzr<UgV7kPjEw>A+^2sEn*A-Yr2-rtewaHaQ$``>{ly
zsLd>){HyRk>FePNothC}du!qU>udP``wM=cGxd&e#Fykue#wc(r>|dx*Uv8Be<J_B
z{wz5!eHjkpX{Dcp*UwMQlcy_kKY^TNbi{q93z3Z+(?LzrQqW8mOhdvgSXFY@!GUhd
zZDo1VHfxaD2B!tADlUNgDeYoP(GL#MkZ{{|09oMCV5mhdbYtGK<q&pCki%9gK}%UC
zJj{i9`-U55d&$uN&PvL#vb$nYklfvF%EbFPoU@lkNB&E5D3>EPlM@M5x7L%i0vYKc
zWQDTx3b`uo;(os@kQYvA%eE|ygw{Kl@a5LdZkjqT<k|oqp<{uxmmv1gbmbHf54pLv
zDKi5~c!VO(BfQS;Ou$)^%Nj&arg0{`W0I;06qYllXp+3P7}<T0O4(E?VQImta;(C@
z7Q(66l$CLNXnHOgt`jB`eRCj#A|>M$w)#i_g``eNttG23y=1+X;H2r}frm*Q1<o~K
z2)1OCjx>-BGjEZUa#21+JGwDB#MCen?k6c6Qwp-d3ba`ak0_VdWD(?TwD=eB#Y$FY
z*v?|~g$|Z0Nv`o^OVugguZT%JvbT^YpSsd%1lSZ!d6czn-Dpj2X$xl0NRF+~)v6Wn
z?gEq$a?d(YX`l{3re&AyEGTYU4hvL!YqwDX7zC)9%dE~<PmbQ6ydd7fg#t6?@j4%Q
zWiuqI#UY-o^KlpT28q~2C6BRTJ+AD40gf!U(+KMWT|*qHfwqx~T0<`~-y?vQm~lD@
zM}e2h_qkLXxY|$=vdjcN%Qsbuir}E3F(Uu5x1ExjizMWfiYmgAhTIjr#SWg|bqg<s
zwm{RTf`>BX)9|+~(Shsbl2{n&Kx!tzj<GUE`IY^+_yPx2rYz070?){DWDP+s6EahY
zk`IfXB1<-W;)j!L;{mfNpJA>q<pvkXyG=^ARz(}!1xhoYD`OpmB1j@Dp;FV#Coo-k
zlPafCn&*3)fpSYEK`yye$UOyA7jY9xKZ~6MFNPMja)fi@q$2UR^h8#H1~Ww@ac-Wd
z<4Wc>inm3X?c&m^G;TS}ysOJ3Ga3-%D(+!Hfp{BmpYjRqk{1zXls4JHIAbeVoff!Y
zd2nt(5gw8sg_E)eP#F)&g&??>kGrdqNVY9$%?kDEY1!dHm1^qrMLa)KQ@Cn|4rcJN
zZ8uK_usL!1Y6AU^g#&a+YvMnlJ3AAugn1XTS4)Mq!}b)TvOdS%mv(1lP+I6qa!>fi
z4027NXi+v{MwC>uZdsV(jd`0|SxR!XL1{G|>XUO0_tGE;gI>~P1C`LS<V0$>ge=<f
z$pY&Lw}3j)LcVzWgxw>KcA$_MUO)6X&DQ{q{uJJipS=C-?Hk)mI{`bA&%m+rXE1;I
z1hkV+^f&E0EqeAW)cfV-B+K%scUe?t7DNw}Mp$wQtSI+P-GIq=ott<_0D~7;SsH(r
zdUyuJj^K+%6~=I5xxywyTSu3kl@eo;n_#jFv31IkyKK2szb4)QiQPCDLmsV6wLl~Z
zZ=J(riBcUYHKp6vS>kxD$W(w0=3O^2!lg?^>?bJ@6psom?m;(oD^wkuzAFSe$IEhe
z*agVFDnQ)Kr_sl{m5GPc%r4UjvCHUC4#;%T0eV>u!pPKcRMS*Twkgck;HmN~D<+az
z{-R(O2ZBhQzF(|;6_Q?U`jWawJiKirk4kV84%EU)YlaObbl`0h17Z?uC2>T5iPN01
z4})QPXLY&Qmy1^Z#ECTF$haU4K1a-LGQ4a9ysaLO%n;y`clBGR)^`ph$-|L_Wvl<L
z3A!W0MT^^poYjGG%P}C!Xuf2l)SC}BM2E*BnW_Wwplc<!2a~P!+BGl8kU-Zld<ei{
zv3H*8?w*u8yp?<OOeM}81Ib>h)vW3E<YsBP*4C}fyPikARGDaMsuShx_%0-4wds2G
zYH1U#4OSG;KyL{o>6{GEZTFC#1rQpMF>F-+t}-Z?25Ns_mG##~YF23zfZeEA11<tm
zq{BltgG!Ns5~j`hBn4wb+sIqVfpDE7r~GOeU2uR?JA0J^v9}E7S|tdphUQosXvH_s
z^9Z9#NnH|wJ*YTl2W}0thN#93VQZV^sAG?9N@^^DaM+42+6n}>ddX8=N9hW6aqH4v
z(ISNck)$K*n(pNIq8<zEVN0$-)|NzakS}|NK%mm7>KH4~5=xr`MfZ@8MW?x-8zP{=
zkl|if?~+OT+_?mnLH?2@A~1}y*$%$d8c%?Vf`{V0`x4N2&ri@wF*GRdKP)E_)zbmF
zaw(7_{qq!LRlbqRY?GaWtX%$x%3Z6*HWurRK+sOde4HGiaopMOMN&5Nq!o!7U`-T>
zj~UjDU!8|RCz>%lp<4HyL@NwZ@XkR2J<7on`Sb%5NK~Ej8Dyd4Y-qs)K959mU|7@+
zqhmiZmoLllL9g;jnWpAw=l41@vZUZawOv#wv;OPBTgqEXVk{Exrj^+RJnq$F95XVc
z5NVA;cc#<vVEVoe57*fW5k5C2>)A=Bp5eK&oC3TVZ^(>;3$8<&#(hvT$)2RnB3LC4
z?L`GN!;gNXM_gg^+qVz(fbD!1k~q|H>|c;q4_nHVeSBnSkk2mPzyHS{zrFwe{@?I#
zeIfn+pZxL120MHn$=JRffMQt1rxW-RR?=GL9*Lz~M!lSS%m@|jIv4qP$O$PZ%(*BY
zot*;+b=DcvuzM!y4LCY0)r2-6wk2(|1s*h3hTpBF-O5%<tuJYcx|CivmwCfn3%zp0
z`nBOPh>sIwI`BRMhsJ1Bju^nP8NV6w7HAD{LWas^LgGbuYD{0Z&j`^V|Gh|(*WfzF
zY8h!^1$tL#K=itFD%pazMaz~Wxl#aEK&ZdbfOKG0T`xBoSv44PC#YGKjf@ve@fSm3
zFOzzFq;0GqlA@sIcZ6#L%0$|%(GG&Y1=E|(@!E?9Wr-^dcOePj`r@HWx5JE9i!3fs
z|JF9XvQ}|EBny#s1#w3TxFz`;>yH3?%V9TIIg)9rhvhEstCe4XZSW`*M?z@~_5T}I
zG<;4Ho3hkBpUE}5r(5JWY(e6{1v2Y4G6ST~IzWX=Y0<nwzEyr+l3VTa1h@4bw9mmD
zH{F~t{s2+JU>)i_kv8FnVQ^OH`<+(be!NN9f2Sf=fgZrjoI>iPtFmuV_h2;3<`004
z+`a*Pb%AMNBw416r;HQ~nUlP&%4MJ^x+oEX;8#_ruml49ALy=<DkFKQJ{1GURC`ER
zKhG`Xrd5e=DWJ{lTBR>FLn!S)*j?wlMz@l^m_d0Z@+u1{yr<Rn-P$K(x8kOeLg8Tt
zLcDs;0g>6QWTsZht$_cfov4%NLQ)Wkn3Lj0=B8ES>Xd50eu|tG+&CGO<`Xu=aVu9z
z8!T^_8!jv;k->(!M8MCjx3ST5SIMabH7`L&B{Q|T15k%&Qn__>t)8%Uq48rG1RlOP
zyZ2hs(3YDu*;F?Q0$me~Qt||-|8AI)Fd^vpU~4miZW>8m*S3RuZfJMLl7J1D#I_}6
z!_1BP+RFLbio^8^s(GFF0OS(L8#H=T4xQNXk{=8$tiU}zvYNS6bfp_tH_79M?$>#P
z0my=mACJU9k=|ShHu1W3m%KPv4S<|569)@*$n5FJ?t#E{tiMM~{KyK1D<LOqxYCv<
z>ys!qBEMVCWN?Uq6{=A{7}l|lU*H{+k#C(jJWXT#`)}WxF~^VI72ZlykvG%H{tcxg
zQh(tC0yovi^6=w${aN^T-1+A1w`VlzuQ@pR2Y7${!`qiBas!cJeS}-69iXD7Q8|O|
z12zf}CbEDAV;nh=M5UkvaKDHLhU6}^F6+X0O&Fg?W3`DvO?C;q*}D)*S%}soOmE{7
zSalTimX=k0FNjsZqvC2@;R;U<S!G*@Uv})lDy`MIPHK>B<t|i(fY;v$MuBfmb_i^d
zwkMnKWUv;29~9C~R$kQ0o+MmJpj$n7x?gnT#tk5Y%$BGwb=Z4}jdS+!;$(sE%voCk
zn(q~!<A$;GL@iJVHVXMd>3^MbN#{fLK|b55Gm5DA0tu=15YB@fPz;B}7C*9DtJEeM
zF=(D;aSyE*8*(T=E<!aL7Ra+VmZAQvg9)jXu=H3&g1dcobC2cXfI4=YnmEVgd)2Hg
zjANw*=b^?09Vb7xK+PuPQwlhk2+YUmwv`jq!mAOuLHQTvDU`=*W4A<I&D>0~1q8M<
zh}Es}auS=_?uXgkxS<^|8X~S)<Yt>KZmkM-AE@Yrk=`5&*&2(jb3-NB4R;lB-e!tH
zrTRl&m)77{NTj^q10CmjyVQ&7{aE0WTmXfaTptS^XyqQGi0cc|h_ns)$VYY_Qh+YA
z?pmg2*G(m%u19~VhTE5cF90=h9Y(N4(Wd1<tQrro{VE<xh81cfIq}DNzi#L$g8=5E
zGb{s|`B@*JYo-&GQX{Wa-6IUa=z`JQniE(KQwwXX#6w;^E+E;aRV5u59Ec(3RGkx~
z<eU!;=t1(n2z?31TY$c1@w)N?rEHLJ9vXgS)2_sMl@0uMkUzS>L=NCm>qT@4#(3bM
zuS8Co4QCvqVm2?umWB=~(n@&`)eI(Ds#LiLHw3`GBQ-F<T}O3?Mv9&q1ijz3;3{MY
z_DCIy&|lq0qd;(i0@Z@VsIUNLp*$2d>-?=sUa;heWY6F%jV8fpWFzmIR8D6T8J+b2
z1B<q<7`B6ycLN3a@HLCLa*y=HPiFIb4TmSPd_6C!he+K^D8@<2naL{Q3=fAvxPgo;
z6SFy#WXEcp)zDdR21yBg%gC`;Ci%(>-&yV{keBA){P8Dx;7`M!u@wI%oJB8>i2W6S
z78;*__?0i-KC#!I+VB8g7OFGx_Uph6|Nhqx-hN@P2__*MX+!|HsuDn6zW^-ar*9wN
z=K+WKQg=Q<PVoNQKLxkx_%D)cd=~WOi*!V7JOBRmt3>>)FKU*0kkPjVYVO4;h&wY{
zE>?wRe}krsgzadZ0Xzp9{kub-34k6_5LRV`=!$4D8<%Y3cmSeT6q}atG@{r8B%&O9
z5<}R!AGX<*B(_k`zM1FDmy^T<<`40*VALg7TVbT5F0e3oVK-@MUCz0lVInC%#ARZs
zAvR&<vaBO_z7rVM52RLvhXwhNRbzrVtSe+4<lMw7SQL#-+^5I}0`gaP+>}thsg;}S
zJB@zdYE*~CCbipPYEALX;L1_cJl@iHdvF&Eaw*0MV-x%$wmYY82cAlM_O{ASD&j!3
zCpJp8VovBx%O9j#=;@}4Ndq_B*wQ=w&Dt}aXzv$o{#sE2izFR`*lvRs$xgDSgcD#>
z3)_(ewd7_M@o&7#3$Sw5NP&Rd_D*`Kx|M)sZt})CQ-Hn`eYIz6zV|byMg6z}hkhkN
zw;xlV!gdBs=qWS}^N+Mur25|xuF#a~i_;yXCV*(4IGv-04(5a7h79oI>~>L~0whF;
z?fRuIySs7{bWOhhUyUEGU3^;m!kM}u&AZLe7B)m_(4MxzCnS}SWt7MYIotH~tbtc2
zjq?^)K%CdjP9xx>Bd`{^WM%_l6u5TYd}@Y-ZF0r5CfTc`9Fso+Cgi#r9vlfzgFwJB
zlBR09Rc~__@{Q<I$y~>Nq?V;3kqM}9q)GDqyfqFfPKKT{J$9?wIVBkTmrPY~e@OX!
zk+;@duWSLl1WHyYE}+{LO@UE8-|RK(3iS}Sf+D_5V4Fw~F7Ssf<#@S{&{`uTAfn+Q
z58TioFOiik_AX6Z?wzuum=GYRms3a;8CY|Awj`esc@92v<2eTA1S4--JY@DJ3OSW`
zg;lO$2iyP(`Wb-*;1u)`_71f{GxHgmYtT#f_^K{M+I=LPa)i*SMgL09Ag}_fc9POT
zG`q85oQclK^N>@|dP8x<L_+Rcia*e2IeSF6n#iQwYK)Bqu&m;rW)^4aqGhPe0Z3s`
z1A}_kSPFmzboRErR3DN698%6OxjvCWzIyvDTks#Bj=p|=_Q?E_<@LAcp#J6C`%chQ
zb;pk#9BD`2{_ytgAOAL_4TA@$t~NFhslN{7hyDY+w*MaLQhx^!<bQhm8PpsuPhkAg
z+kM7n^)bUP7sgd;cBu+<<3&ncO?%E#4rc-FGEB`xmSz`_ih^!pdI%3$L(=_l2feI^
zHv6{PUxZF|7Y<ASIkA!jyeLg>IVdG1c0Fm3MJ2c1yo6$ahgM~eP&ylo50GqKuK`zU
z*p*?aCT!a}<^&nb!5bK1`N+NiU<7K%cu8(I;5#uBkZ{6kWdUAdf@Tz}eAsR?sMk#f
z_n~*&0CgPtEr#0Q09Sb@T}$TM5_{Z=g@nl5k^!{lfy-0`n0s&nt1cys_wz8o->D&0
z1h<`sl9XBS$%?ZbCg!t7k(}G38C^nVhc;L6o`tLfFb{ylF-ZX0+iINmHU*-k?ND%}
z53M5~@Q<_nU2nR>`PTi3CgnO%QX6Jha#4J@Lj~ZVMpcj)ZrXpq1OxL%{eo0dm?ac7
zRI6gQUB+Bn==L{;31liW)5Of+21KO&5fzby*;TYoIdTH)R6s$@94SChE-yWr&om_i
zioq>B<bob1-b)FI>IUo-b&WrpT5%@d$4>P-F$>P4`%NJ6$Tmju0{)~YY769x)rHx?
znsUPqmkydMsD=C<Q|zE89&#ENj`q=Qb6KkgfkEiqga5zH-X(#rEF~zlQEW{PWZ2wB
zp<m!j-V^EepzgeuN&w{PP)xApEh$hyhq`=Ao+_`BGu+1A64_fO>-gnHVai*$nx(hI
z;Ovr^2a<|+(GzY1Y-;=W(iA71D0%)unxPaB4z><UcJ8&+NhpR8s2ZAF?={(Idp#;$
z|4XX*hNLhNOXPeJ=26Qp<>W#+pb~gY21|<TL+To-a}DQudp@gfM@hXe6rt$G!!5jl
z6c=PFbRI{%MipJ!vpST!uJfkKwdLiCh7Nd(>H`jIEU=5MiJ@J;$_XV@sF05Z6`xCN
z+}{wsO7Sd>2@tB=eUFe!f#;Xa7cgZbO|?PUwz!@_nI@W3W=UnKV8F9ZMGP(r2jIe?
zTvCiGwd+!s08b7y`6>VjP)Q-kT*Vh%-HuitlB#%7J>HZ39P*LPo*xtpz+GN#4~*3l
z$pp^df!GFE%3V8#2Xp)GwasDuUWnXdJf_?qpE?}weX0ULW^0nUmH;sUjj$-wcyLjX
z3^-f5Ok@jisP>GZWmY72GAtoHrU2B7a!9@N1<k6tK^w!3(SeU<c?Ni8uYF$xLyBMD
zHg9j_?<Lc9W=P<_Qe-om8EiB+`R?s~zJ?zjV0+^$A`HIz;p_2xzIprnU2X~6B$ibD
z(itbm(Jz2q_!sSwPv1U9L*>)gk2vA@==Iw`C#?@8^LqU$x)@)-{SIA>uV25Uki}1t
zFc~uQKgq}VyVu`C{0a(KU&w#IlmEW5?PNQ;k6Sy8k2F2FN62F7ag)5NRX-c44H~=i
zhG83<<*JS?Ilgz#w>DJp5MOwUt~+##sJp%<qYF!DP~@^th=CL2Wz6a`W-TyJCv8pe
z)K$n@b2TT<LKyQP%Vw(iBZ(5bA(Q4F@nPSuKqAv)u|vb5>$gbFZb^#-f#w=^%XmN?
zCyY@we{2(AZ`Za~XOfg(Y*oGow<w<D9ky8=Ep$<cWeNvcT=a6;2KshDq|hlJ6Pyd1
z6ZA09*)7R%!D>@ZC=E1L^`JDYKrEi&F_I8HAq}EzRo6?n#hQE>m3u4!SXLQ(`#Jyw
z3P7Gpt34$1oQ%znBs8K60#(j2(JNI|5R_u#%Es3Hl*XG%_c4nd0cKj^!lk-+!voBX
zLD{#NtoG4*_`?+~o=nXMJWm3%zcT%xA<wQLoSytoAl-H8$K}0E4RJ>2A*rDuqzanZ
zIvFSkws+H7h-2kRgaTt$=f)OjU#stCCm9iH1C_tl7@*G4o}-jwG4@cgvgZd3zj2mw
zl3+lbt3zB>Ex0;&?=<C#0-g!cRR~)o<DG-qF~f=6theBK%8Xq2p&P@9eny^mKBiGm
zo|@51>x6-lP4MRc+mo4#<TTYq@-x`z8U{q4d-dbCT||<N23-;>jWS%v!iDBkam!K=
zfI9vW^whi4f~)ZW(m~?N8|`w5Lf0|Zi0+?RDfHJibDK0>w{UA*67)J_Mse6|VIjc;
z)(%{QD@j}<5DuK3tgFh)T0BoYxIoHjyvGhJ7}TI_GNztfCGLF7NH)^&n_;j?le$z|
zrV+I`A;Ts@ab0pKiRw0`izP-<+7YuFRPw*6;pVNW<loA00yy=typ&rkq3&Hd`yc&L
zNfZIBsC@Jy*+Iiid^>QMQk9@-a^x@2#2FiFtCgyrDmOe#fq@b)V6G5H*D5IFM&A#I
z5aesFs|AFR+=S>2K_TcMYeGjPGAEJChq}Ukot!)Cwcx>lkOoRDVk%>JW?dpvEDC05
z3iL^&49V_3s>~j6sj|Q>fAp>zpjk=9e<?#`EpO~Zv8%z(#V5znU%dYI2MUrr{_FG_
zUVqK#{JXbbCx;6#7k>Hr#pU~7y!}C~yDb8LjClMRzy`YY3ATQAdF~xm@At)sXgdtC
zW+-R`vrhrf!9LKVM(<7vDHpPs4lAYy27hcsjMnXdn&h_B?I9>>(04fNK^w7SuR^Yt
z1VS4<s6iDBiOrE78QPP|QSNoEs!md>JRD|FM~KPf*$Lb?W7r_cKE`CKa>iBz$jt0P
zjA|WkV**eW*Sp1NP)`gwH(p&`Vvv+TIf9*!DZm+1WoT8b7!LPwDeAO!N332Z=UNdG
z+=qy@taJbrNG{>hlIRGhZ4CG@KD5UI`D=nuaICFbv~bh9sDda0ZOXzmL6zGy=}^qE
zXx%P5&cKy~6OvX@u<(WfJWm!1$oEE`iAh&oIg<wQ1J+PC@$^XI9gMqcF&(-Fmnm31
zBTuYE4jWluuI|cMU}Z$uW0jH8333;4&?}+hHs(ps+Ulr&RGS*Y^1x3u&|`ly5n@PN
zK;0tS&@>p)8kUdlU}$e7EJt;s1-eIQNYhXo3Le?^Jy7vjK?rlz3W?&f7IC(4pb<Kh
zz1}p!UmCDB*%zVf$+>~L!gHX2etHU_`{;HQ4V<xR*X?N0sBW_d!)HC-p@A-io7DDd
zUVek!5^X4!wOKcOOw1up9~fa}l=438W7XuDDFI0kugEFZSs^+i?l}$pX?-cF)3Bz&
z740b{390#M;6_O{DdICwN%^h_Kj^ad*2KJavf$Y2as`R+DfRU`sZe|wbrB8@%a1Qe
zfDy{{tj<iRwU9&Oh!-*f{g!Zy<65v`{|uyemy#RfUTZ98E1^%vPy|Dpz}S@_5a7R^
zXpoX|1MD-zsv&+LIQqGmfw`XCfV9AR0EUCJJ#-!cfK4%$M}>~T%L+krk8yJDRt;JW
z#`_MU%9WU_Ia`ABD~kIt6wAjvN6&U7;y(buZ9j|RT5ewnb81mF5?PRhhhPki@q^s(
zm>)RSLN%i@)Yypk?EXKMp`=|*SAQDHLr@`^A6>G(R7g)c*yr}JLVN-3m_r&1g^X(;
z%WZo<T)Q&30zcI*V#bgF3OBNjcZ|0fA==O~70k-tOLgr>rnLAShx;cq{})8;e~#Gs
zPLzH9JpAy$h4I%^9ieydJN@@_9rM5aR(C#1Ur68c{@eSnABI0quYaz`p3h(~2q|{u
z3@j4On7-`2q(*kG9{b?z^Hc>(X7x~VH2o^%MD&Qihc70q;a&Xsj$Q*d0j`}ccLl;o
zvX?wv?vi2~BoKN4DG&lffJkFIa_Jdwp!4dp1QmUC-9|W_OEJA>1LCCwJ*XL{uQhVf
zXRokTqp=4<AC2k~+K(RLkS)i4TK7u|6^ROf`ME|j*gEZSl|rwDAV2uJfKjE|qdh0h
zFsVR`^WiSjaBoU!okjIQ4KSpv7zV-$)UtYaOcAnxae=i(C)v7G7=|)L03bPGX`m-0
zu`DG53$snx1z!e(3ivE*cF=|s%Ug-_WFpRYrE%LHFao3=Li9?WbhZ8jIg4=DB};?T
z$jV=n9LF4vz=z)R^R-ry>O^upc!)~ofCS&%6iTp3$0ZmjkLYnIOD>9HlGV&I4EY`n
z$OdhQX|Pa|A|T&>O_kdO1yQ-=k$?tJwB|-~6kxQVu1C{O+~Vl-TUvsI1ZsKaiAf$P
z+%{6dzsV}dbr)I<Rsj`eJOcetp5g(shwEhkUoMYY`%7iXGInU-CM`9|AWPLa&s3Xq
z6jT2Q*Yvr2NlxKXZR!w6HCFV6)TGSPh>*$MYd{9rZfCSW2jN5>G~o9g8`xvrlK=xp
zjm1Yg-8Lxi?TWS44gu;cr?{vkm1u#SK2`L<laV9Sf-SLtby(iWFgz4PZ)3<EG<1_U
zx6>cv+#zYefj|p6?Sb}hN){09bP2~A)|TiH)s_v_)IkTdVmWyrVKzQZG`grm#dKr5
z%ZdP)oy60OC3iL-LSq$BFOo}09;-S~>NOYnRcKI_@|;4%LESBKdnbu3P?Ba1TMG2r
zt(_nNQ%et6QO->dpBBRr4vl^wbg}M>x8ko?rUZ8^K`dyO@dTVwL4$RCvD+DQr|Gb!
zl)H5z4<PIY15}5~!{t;hr#zY#*K7$}-`iS%gut(P0Z)5mFk}g$ePO>8zeAm>@W9$J
zAaUehZ7kS$e_Ir*aEieB=F^cpffqb$P)PHlJw?kHmNm)hcmlEVVaa9Tkbi1dNqS1U
zTV*q4p|=jAtMvs+hryY{8T9Se!%-sZY0;ZV)oHU)1#54rNiLAfV@>Sezx5jaYu|uC
z{cSLW|K9`+*YDfTf8((lJo*)ta%au8m(W{o`q<EtB#s|-r`*x(FX$PD((==Halb=w
zS#5y6wBi{JwC%Df=j5`5g5~Z*Zt*4bn~gx$M+t!+AIWdwI)K=JPgIVM@O%|tAVO4i
zj|l1mI5i#!cdYeXC|7+)pQIYQ47qpN@z_bm%AJy<(iJ=0mf$%N-!FH;^Rl`oom|@7
zjHmEy=WH%YC6R@S77y~wJR2|7VHB~dIMS+WkhWyP`%Z<}%}`23m-dXRxysHnZXSOX
z%z{~Xx1s4ND=BZr{<IX7z^QXbovtFLSyUXrrWExUSRYo$3syrofiWuYsv*}BLjWCt
zdq$f}gvcw~k2AtX2E~&#dJ|&C;C@}s`~yrYl$M8+18r#l5ixI|PpOpmv6&!#H_*-s
zz-VRiowT7LQY^vv@co+<6V^-+=YDhy&XT<`MVYV;cRO13nUpGr<bvc<DC|8T&ndAo
zEMn8jS|{P&dgLIj3;-G!HSgN#r{EtM;^P@J?L%X-Gb*G~1>P(OCt{FmUJWX$z`zZ!
z^MlYgvppbnMb@BAAb}4r`M4rbLmz<82TFe?$|@?*6m1fBlAnl?UgS`PzWY|Bl%;Ai
z5uev#R*`!PAXMFWK}L?{Ivtej<KE=$=7!JUM%d3mFsjSc)S85<Tf9m{LoJsLC&iAN
zHWlFiAW2l>Ib`j!GjOY4P9wJ|ksEa*x72We-s)=^)EKs;*)Yn-1>MbtFuq17(J*yn
zFrUujcey3qPPOW=QuQtxeGTg!!*;Zjr3~ngu|HBCEZ}~#;{a|Wp2q|glC$<CJ>rVq
zgY^T3QWY@Qi)wOOy%S+dmr0&2&k{*Jc&w-lfXdV6<;|i%J7WITB!`v}$$<^JAtwg`
zsZHeFxd{Zl`(SjK8K16{0A$ELR818(Av>nv|E|%RmNz>j^Z{LNdYV5>lFQH{q6jvu
zgYMCuNTQ7C-2`_XqVzzubqe0ROF|~8k2y?Zs4bUHLb&9&9Ywry=#PNx#l05ZmT~nj
z19h^HCD2rdqf0K8%!CFw;0?RH0D>Ek5R``dO19Hd*;tC0t%shRTBYtgS^Tng?s#da
z3vkuuI+*$0Avu&y@U>QM-ZyXWpC;1({=f3S@WTU~dH;?Syx;5Z`To<lpNF?!U%vm@
zE4Tt5zJC4sQ_Qp9K9}vUUVs1n&!yo1`1=pve*5<2_aD7}`TA|Z=$n)8|2=Tt{^Qr5
z|3Cc~et6*We5jDN{`7N0OiOpdQ`UA{3Z81(iHrjb^PTPvQV#F7!~&De%Kj16lTEUR
zZd9;FNtq!mj%>@J?Os|Z45*rTXj5&2Y62e(DhSy2?t8dF=oZ!v)?h)|kCLqck&J9#
z<zy$kie(sRA-ZGq)`LVqZ_66>@+{S~<b(y&llmM&R#o<uyjl_l09!4ZKFo<096+4~
zy10fyVS}fI2fg0DtfYN;-dDGdTQD|fw8t{hkEp|MK%=#d7v>UVPkP=9#9Ae;j`7ek
z!KjDSd~_zg89pn)$*BWoo(98)@iIeuLSnL-D5h`Gfw5J-8&+N@@KHliV*h@m##3iQ
z8>vz>k+Yx-jAIuG3Y4$B7_{%+?0}$~h~tQ1Bh#|cwNnP@@*<VGpe<+N6^Ky4=0~bQ
zz|ogZl(89P<=Oi@bLibHm+S64_#4a;C+<mYU1e;VcQ8Q8vY8hbw&1YX!t5J1@)djP
zeQG-TcG<)NAiiu1mHleapsbfZR`OO+yV`hL8D^?RD?#|IgWbX{#^rh38mh%yTH@Q_
zt=SuTbnS?FHsk~36m_Gd64r;`(2vu}>ER)E%iw(``N&Me$#of9fF=P-v+0n;K`Cjy
zo@&$)^5x84RFI2<?RrUN;DdUE@qHR$6H8#Hl;S;96D>^wBUmM%?So0h{eWR*SJs*x
zA8!|Cl`F^N3cDb>1G<S&`rka(k1&mDe0(l7wK5H@s0Ke79USrl<qe%>4Po}TT;hGk
zG}n9e8)T2IA*$$DBw$e?I;`A-;}epd(*mW#CG%1rx`)gX(i|IrRClTdzT5`c5Z=*T
zk7|gj%Vs0=(C+3lYO+J&G&q4QjZ+Vo{y+fBsu`*pJpyfLrDM=HaM7WbGD8vycW!rB
z`Yl~3C9blrhj}a~R`6ci28^)|QM96i$gAZoNvjZ2h2c;$$CH7#?QH}pj3NR`p*G`8
zAO^#*z)*@@@f=EX;QXXX!MR%?nJT#i_-lN>c|vg$s0WynBn%j6QeX%v?orGnNkVcB
zARwfUgt9&1e7o>~n$Dz6C?2M?0MhZ<JxWf2(U_$dux%&Ru<}WqtTwQ+JUPrLWx28n
zT@?f}2}AqUH83*R%@L;8N`+Eot*<=DTZ=inDnpT#_kRd~_GkZ5x15l8NCELxzy2qG
z68^;W0^Z3-zIyv*I;xz-@E6?qkk(O8Rmw;~KgQ>NF8mS8P#sw@D=C*O(l6#((fN2c
zSwLQ?-~9lZl}s^NQPke(irHv7Pm(vhTV8KPzH+HtA7<rwnxe0bWCZe410uUdUDu01
zsGs6E$vsL*!KF@}gspQ~ORRPKDavX^LlcR8P&3&>CveLp*R16g-EXqPB~5z4lk6^T
zfQ^7HZ#saIzNZytY2_Z3h_BXKy5W<*rBF(d+|0VETR<?`7ftpr1#wv|zjlEC9=22i
zK>DAn-8}B{jAPN4^XQU*u%fPXxZ<jS!4t6=qdNLTVkJytLWs3APERZX?WlXQ0p?L@
ziVJlAx?`=J#!y4|Z*;ocq$m1{^}s&JsJ3irvxf~Gp>|yZW2)tnc$qY@0PYb9ixuBW
z9Xu}00G+1A3-_i)OI_-(JNu=BRBp4ymL3MRoUm_Cxhk!a0XkR$q~`iUFAzfK)ay0+
zF$mo>SDrno@~vHqjy!<^4MNSOFH|LXS9~4ndsS3ErujEcg}^g8D1x|=w}pKGXjIwX
zmIufHcX-M`0k=*(MqTM%=pyXq!!jV?knMnxesgKxgCh^8*D65>a{xZp;1ODqpk8D0
zB-;3(l{eY}S6A5yy-Dg*nk3+mqHob04Mp?<%J|-fCX=NZat~8@K;GTFzt~Q;p8CK^
z0Nj~+=vPz@29O`KRpYd1R7#h;9&q|64X-mOWp0c+5FW6Bqb|Hh`m3D|_8V-_6|RR}
z?X}xLps-W|;48^JuF%EO$=W-4#!TMg749i1xZeX44#?+OY7itXgw^0LoZMJGL*HLY
zz>p;omI4=bMzKkFe`#>bcu65iK!FUsVRwNxpk;(0JK(a1+JIW0UnS}n;UG{z4}gA6
z1)%+9y=Rk>DNS*>#vB$z!FXr@<4ztV8tF_;DzJ%(fZDEUgSt36Q&2yKboEJfIqRom
zh+pUgId^mUe1<^Qpu-n8ftJ$h8BdN5K;?{t<0DUylK_H^9RQr=K;5PNek3~)vR3Z8
zlQ#wQWPH)gn><3FP;wHE8Rkm9`@8UzYdp>_ML37#Qz?n##tDS-a?`eg^CBP$fbMTd
zdv>@+9I6CsKQ2?9M5s_q6FLUj1u_Qat;3u`Zl;V1Nw|6dChQLfcx1psyLj<5B`*CT
zQ#d%{8KyJM0_f7fdL`?U=aa+HrS!L+3Nk^Kj~O0F2X}q{!P`HBx%lDRZz&t_!Q0Q@
zKL7rsx8MBne+lW!=db?c^*3q#B)(g3d7@#y|4DfL!{s^3na2#lgvhWsvpu@Ys<_EA
zWZY5Q3Em1;KmwR42e%s9L~(IB3V1ghG6mq0u1yjf9H~%p*M~A~0<M>pjF{juCK&C3
zqTL)tBn4H$B;<aIL`h6%YJ8_&uC|Q`StQNkJfq<3TDT=F1`X|l%74RQAh*iH3y6`m
z@+Bz4vIu}tNy)B!IF`-bi*<zF?&=f)`C#*NP!pCV9(MB!Bw=~|mk6+ZQA3qj;_;Jn
z1mHweoDalb48Lb3+M~&k45NX?TT<u$GAA4kruM2oW(h-yiaTAC_tc7)gu`xpFlX3i
z9o;*gWEvlU0i^BbB@i*V&S?N}nKF65SM#=-PS&n=0PP#wmPKY@Hx@?33nuu`^d090
zs$iCq3@Sw~`N)Wb3n0OUG#PN<snb3ng_BiL`xe%Xyrh9<G_O102V;-SAZtB#OCZ-s
zcY<2=88A8XOogN!mBNgLlSu($bh83qpEY((x<)}`M)gC=Y6F0%We9<Ok{K75RzH-1
z=|RV&cAw6vZ0TvC{}VBvZ_#;A0bW6!5~cKE)S1>$(asUj#ksTF6S01}==D|u1@t-^
zqHda|zJ^osBw2570EId!eoG++#U>vJKz4d2TTd3BHS1^=30{BS49E)>Qx!*)#IKQX
zzeC@HHr$BQuxW||CNWlngI^fWhQD#p+RPjEk}a56707dvMoR#F?34{Efi!{5gzHp*
zpPU>c&TP02rAJ1=OB{o7lKfTf17R*}xi#2#X!mvs#M{m@_z_Cw$qorOJn3(vBdb(X
zwqq2=G=GT>W6QTHJS~)s;J({~lEXSpp0q~REh-q~om^<xLn5@vjZ=*%sI$t)>NvCc
z*ypx~A%JT?<zZTtsGobrq&?!UlK`ct5eB&TLMCBKr<QEKLd>*M+nTJ(Fz1tHl98vp
zqbdLunREGak-rS>DT|XyHSg`S*At!W8yEroYlX0X^)HUyuiif3Yxv;-zNYW~@a?C8
ztg@fIej7mC2m9<p{2NH^|3Ar4`=7&qo8lMdrt{^chxBlBr8{I_fQ=zfis#}eotyO-
z^=yE$Nirc3h@+RStw)*$Z><#Ea>*ZjI3%~-sJbsJvJJj5(Tw!NS>cDZ#3}<KmK}99
z^ExEcR!tyB`amk2{Sk>HUSa$4$PTdAg6Rvz>Q?2lQdf2jw=v@7unbb>FST=K$hgeJ
zxeq%yzZV6y%<|go5M<zjyEJkm84Lyj(nu>Q&;ys01b}}piO^aw17^&=M;ngsQlb{k
z)3_P3jLwV_;#MQl%SRa@At8Cv;GQ<PNXuq@H4GyU4SkTCl8CJ=R2_ReAltJD)_J<c
zF-$@_2}I}?0LGTxyIn2i25)0eU~@>|w4@xfaETV9CD4;vdcK$(?R3)O9XHGyeL?}n
zo;B<S8<0xh*kph|5gj|gfZ;_)-fYkS32&*8A(muqWThxa6xCUC><#-6a)^5MUS1<M
zWQ}@K61rD7LDag}d4uS_%UyJM{&btx-*$?DYe(z}7J4w`t}W$FE;aHb8G}qSkWR%D
zAe<BKmRNORFn`63OL;ptt{2iaFuU$_>CCLEY?~575Xnr?s^!A)Wj9DLLY=nUrkTVs
zxiD4Zr##KZ<(a<oh6CUsn^ek?Vt=Y<Vge58>L4LBx7{#p2HC3jNwc;=S8O)ii~2CO
zt&zge^rvppjc&no9uV0N?z_%9K)D8_&yS*z_2Chk^uRAVf~A6OsJb)*?>c3r<){d~
zcdg4SOqN`ivKqS*byAh(X;A@c|AofO>JojqHXy|s(BT?Oqesv<aS5^r#P0foF@C&y
zY99+!Z;Qmmj)p>`;Ur6lCx9tSs(Ukam_S1#7cEqI;u>EFv_S4gudP*8x6bx*xViLM
ziMAC6I8f}OoNS2}t?Th=-^bpXqWC2P;uIcBtTxmE*F-hT6NSlhb0A<;jDME0azHrG
zAugGYBb@f9fqb93+H{X7P|8V7<x+i58ZN_D`sx0g8s(9J+O)nwWp~osl_kS){B;Ht
z3lj-cNLFLwLA3^}tQ4hc>-V)p^(6yz5tQ{c1O6V?l~#JzkQ;_yArj=#6GN33<Z?n4
zogawUfAscofcDM%Z|?`f+W#J-?GwTK1E}J>k0JKTQuqlO-t2H}CPOlT-pgnY^d6mM
zwrA#f_t@Vtdee0M5YA~Zv(auhg{&Tuu3(|S#9V4g027hX7=V4D{iHn1PX`{rQDr{#
za5cGG7}XVu==1N1OFGn_Ce=EXR98n4U7~`euPVaAT9&}MtJA5}Jf>iQ?s%)94()L7
zoyPeQ`1Tr@+|hnb*12=*s*p1*aL}}u@?9lhA;8xiZ(d5yvP6t8=FtXm%0UkcLGSYj
zg;jn<j#TxytX7IT5E-Kw+~SUYm!yM0ah%-}sR2gi3rK7Pys4*}1KEqZALAjJIZK&o
z^Y*zx-v}M!B%N1w^;Xqq!yBlc`j|_V^iT3Q1Myg(pGV*t(;n;sY^y_`OfFq<sMI$c
z4S|f1kNaVmiUXFVOz2W4Ewi*AA)GZ^N6cmO=4)w`xG{$&zuY5m%E>yH$Abb%=Ll|4
z3FJtU!ZDc~$locKWdhuY0bUmUa=fBi#pt9kqFQ1vGGsr;OJ9W^aa+wofK-DZ2W<1w
z_Y_hngw927_M<h{XDj?QAlk-RJ3s^S&fl@_R*}5JVlB15FMVPGBx)P%MyP=!(XYZh
z!285q2VJ{Bj;Lw~PwKAMXZ#zG@}uy*{C<1yk`{I_Vb0N=aiDMu5se1GIE*=yQ(<q^
z<~E!BNp1ntx49m|MR2)xrGP!+g6^N>!4m4@;skWbsjVlj1lE3sG)^ZKG@vB~U3wc?
z7<SXglK?+5VQNZM-|3{3j-1A-$P#4}>TE+Eibg6t-Au#=H!=-KDlq3)!rP#aPs8LP
zWd~YN54I*&IGuS`v{GX~&InXlOAAH5%R1M%Uor}B_wdn)w+ryT6zD6WBc37qwCkxv
z(cuF9i%QmHm&lhDv#@}^$+hXALo;wTt3J`L6<%g4%}B4m)dC<ybUoe`vWCfhiiwzP
z%LC8Q?WFkv>uOLj2kUsFZXmWDI@Xd1nKB)C;74b?%V7J=pdf*~Q%Z=JK2ib?sG7U+
zpo?dnI;!$1%D3w^8d4{hVv#~KXizyG4r96<FOb<o@$Vpbm_@7lKIr05(ybyk@EW)-
z<nk^~CZoBw%bk{_Wj!p!T%|G3lv_e*{gA;}NA*b}t)@~3&=a>zO*pNeoUowpbfo7>
z!mH&4ljQvD0!Zqcev=wX(HU@19G3S1!0uWyIUxfDZpsa8^3nzZmOFgSB;sqnp1=Cl
zS)1>70eX8$wC~en1pfZ(m*G#3o%h4vq@ABg>S3$NbM!^vi9}HTMPX=7sVBzyhLHn1
zGGx?<coYj%STU;ROdOK%6xu_pHM?FpA)m3Zs;Y?W#C1S1E*D{Y)X8JZvJ9BsuxpZ}
zdA0mX`xU^IFxP{8%!38Sy1g9X7p(Vcqtxz#bZrH(W<Q#-YECh^D~^u|CG(Jvca?0H
z9>-F{WVCcz$0k=po^CVc#Z_fb$_3Os_}E|6PV5Chz2T^6lmRfDCY5VaoT@HJpk<jZ
z?TKBXE!mlle@^VJ+_USv^-{jtPiK`jGS+70t(`(#%4pU`svY(xHTg^B&LYcB3(uQV
z#-VOmOgU;iXm0Cej(>jUC8Ggc%d!&;$Jr}b<le^>0+a3>NF|9zfi1bq>T3yLQK6i<
zjL*q;=qP(I*YDU3Nf3TuzpwuFSRE!vbA)zj?~f}c`B^z0*uNH3%(Y}(mF#bqs5LLO
zmpX~<&zaRUs^N@v+3S56f#;z9&Rn2{Af?slEqPm*ry#cgR6u46U}HPlaCT5>%S*pi
z)ggS}gI6}gQb00r4&65x4)>$W<0h276xz<PUqVLcAi6<pvcso^`AH}1x_YP0(G`2O
zlXD%tKY@!PVKF5P(;1tjsYyArE=LNs1%ec0Z>dIA20QO#Zh6c8Z_3_mS$gC;7rVz(
zBo$%D(TN}*K*v7vgE&Hw0I~|G!qgb5HujY)`P?}izO!WCNIh|CvN?#Px?3b8c5l9y
z*SB(g3;3H-*lq^@4OH!+3YEw;eS-`4DR;B%81=e{^j!XZst*s9j_(8bW&9lPhp2_*
zD0|`$-z!Tj)n&(_1vfQ(!0hm7^xaNPKTHOvv1aQ6J)3+eX|cKqkZvzI1YC2dUDv{h
zfiv<X8L-tY5X9j9q$?G0p)(#Yy?`=m$6$Wph2=AeumiQyFl1G!dpnhAWllR~RBnQm
zqNs%}4^ZnJO9?hdp8z-S?^Z|Q3$-ySRsFKgb~UccQ!3m-Rfs~WimF|A2|GKnyO}mO
z*7{R))Pp5&WRR^O^V2~_f5H?=@=wFPBUZ7CUrKp$8yVoCK2hTUN><i$vgcyG%cWxG
zTaF0FRZdm82bLHD+fnECfH0k5uqr_gUhxHBclhrH#&3x3uBt85x$S&>RY(QxaU=%I
zyDMAwtDDh`P{<pkt}FELRb1Jkwp8KM0sfTe4WqSrFQW37FgA;tbm4czU<~2+&mepI
z=l_QP=n3}kzhSih;t1=%R2`a=q}>0P<M99Y2lC(h-@P&M_ivx7?m*4}AXJgAoC`@p
zVA`2`Z&P-t?AvGca%nrXyr7e2Axv5KP@+9+m_N1IZCE*_u2L5Dp?+(G3Ou44-*2~Y
zvGBNMZTKUecd75m&_nsejeFIRqjU0%+yNc%UNX-l|F~+rs@A<ATG3G|%gmr3Vu8C^
zAnGw$Al_k2dBWR4Qrl(8)O}tmdQ+O0z&vHY6vk|bdiyNf&}a*=UlWY#RFK9l&w{~s
z^iDdAcdiH^t)GIY3?E*O7~&J#D}XKb7f@cy`Ya{S<G09mykrxeg<XHdTB$_!3@SPE
z?&Soebs@0Bi7W)?pdvAi7;|l^s~b43LlXgi9N4+b#UiM@N_EejVZ^JN6d@8%hkVF@
z3zJm4vbz<SR@i<lx1fBe#V{L#Olm9aB;$B@D1SDpTjGVMK^E<4%?@ybM(#Q*H+|u-
zM)oH)$D}*1&X-3&ab6pM0kJ*KVCiQk7b%`FGi8K@5!G>qhP8{~BXaG0rh-~$tNnp=
zGH~v6h}Dd{MM1PZsSGD+h2g6tgof6znD;hF?O*{kO`)<@>b+DUIeFVdUcYx8_|EKS
zNbxU0v9>h-b_>~LA^(9}8ydRif^{Lkd2ttA41S#6b%Ts!^5_glZgmjSrryb*K<@Du
zdBkKAfrflh<IsHC2YI<4yjt}8Gp`w9bm&iCPb&Lpmz-R4t}|#Kvd?s`k`EVRNk-ii
z{5n2VN#Z)<{anTus?oKweHaf->gkn5`Bj~st(PFlvDD9f=?ZpAv6V|Q!NQY#``8np
zcU56DYT*KI+(AzPk;F-SlIuN>6Veh5i#OU|y0mkW&*g+F1o3syR+@$*gF{?e04pxY
ztMWO#4P^z(K0J1tudWNK<_d2l=N>O=I+a|<Ka5jRZ@Sty$k46jrkZh-kE+!lwW!gt
za3hpjZ6P=ZIG8Y17kAtnHo!spfxq2W725_Fo4Vi}+U<7S9t=KJWFK0jAOUkDlJ(*S
zLBW=1hmM^o-_m*;U}I<`Rn6f2g(1F5x>rJM+47duxjhT8&nH!gQo9P0a0Eko#Pubt
z5B2~`4FPMUSP$fs4u&;;)vX|u2g1T`d>|>w8clf@L#K|9hDQD^rQ$;fHAlz@^FZt3
z0-WffIbJ#qtGkmyW4fw^qMg)1iboE=(6hF8EWx0W|9EV}t^Xl>|G(;i;S0VAC$#-<
zT(LH1D}VS-w(_w&^6rC;-(axuqv93w1xrs~v1pPD=GiANA5Mw|+P9Xp?}UIp(O?3q
zigL`)!KRkaMmuDwc&74{J3rBRmxz?t+cv4C#xb4Mc7kzp8Zd>X<6*5~9jbpX+t<)}
zs=9$vYPrU4i(6`=-Zo>X>KJhE0M5xZuQrwH@6D6~;m2OuDs`-RkYj8im1czyV5!0e
zy)$E&E?cQUw*$BDbh{NjU}h7kBeP6RXM?=W=h`&UopI6cI}igC1o*&I<}c_Ww}$q{
zvQafx(yk3$zA&ziJ&<KNIoTB^TL=GfiE4*rNeQ4$#1&w)zZY|JFqUVC_>cIacBr$z
zy}6P)V`0DWqb=-%O%wKmDm`slWfChmZK{K*_5E-^yU|RO&b9M#hhU`7619*rSDAeo
zP=>q}A<5`>6u1ZZVafHm1L4QA3eZVN5K=ex^Px;y;J1Cz_g?3>I$2@rAhA*v!+QvT
z9x217e`o?ut^$0IkT?AZqeJE7W{N77pCrmHuFt1pZ%@|b_w5b~6f!ICxS#R|e5cFL
zUH6lG2>UaG7epU5-o|?hA9$AEpfM`(r*@|5E!2`uwuiN1n^mXUK_VCoaJbUc0awCx
zaC@AxSIZoFFg06uk188!m;vBawa=DM0eL*I1GsS+df>kj0so_=PBpSLY@#|b+VNax
z5vO<|YybfoeEc4R#bYy7=H7D1<=2a<YC}Iq?R9cY?N3)94U#OEN<e-K?Z9f2;9Ld>
zKQXWa@F_PWxcPV9Ly+b(a6#%NS*D#IuqV)m0!=?k2_Gd0+oDLd%8A%FMm6?@Os9r%
zN!ft|+-CLsn>a)yPoEzr#3MsA&y6~vB6oFsNho#LX^~#??%jV(E~;7(Y>V##b!5^E
z{NKXH#Js66Fo8!E%Ifpbtb!FrydH4DS#CaqKtL0}+fIhb)d=eInHf+Wx=a=1C0?Mv
zdHixfj}CrYB{^#QAh7=uE{T&Dc_VV$TAu+N&kSx29N(7mDhx+3Z$vAi4v~*U_J4E%
zq^PXuXi#?X<;4H*<WpM@2j7H31RIE*y0AqFW@20*=)!jZWq^KE8dE#e5bd-61TCv|
z52Y{fBnjh7+kY^u=y$aU;29L&@?j@yj%uCiT!ZE!;Ep#%9oYDz3RP7YIq%mdVz0Ua
ze|Z1-cZ~qQ{?p$xGx+k~w+j6Fm`SLbKzRG<cRd6@rOcpt2t!88ASAC)`eI7(8e*IG
zGu4|jbZ%ooY?u2#Yasz`e*p$KuPJQ1p&H7{X3>B_xRR)v0!v+IKndXPk4i&NS4o@+
zbsPfqD>GxzKHp3ilx$d)SnQ$D-iv4GZ6+>>q76sJ?IgP?N&R-njpje|P%)}}7#x`;
z`73(sKKs}foh!(Ve@W?ZGz=H(Sim}{1f<u@>_ItvsIr6-$?Y+anmLQpH~Imj5@KNJ
z5vwwhbzI;pz<vkiG!|45h3YP#6=3%b1ddQS_36kP#*VHbfJ3^77m)iDvRxET^lDE)
z!^n={bqH-!R|b-whaVAa>C%<o-^pE0Z9-7?jeRHu+?0)njaI1io?s@TbIPbz+y<Oq
zpilTp&S8|~ls<Kk1)@_BcA7ow_rpP+8bI9v#DK;hbs<KTONMnCqAVcZM0k&2SPZf>
z;yn)%#*4(ALVZWAeIZ-Oh+W*E{824ea7){{)KPU?^qaQ9Ex(Z8wCzMX4yrJ;0-yk*
zXAkk-?le~ITkpd300h|)M05auw5+BCTE54OGy-^)W2c;BFQmWESgFO?+WKr@1t)Vj
z4A%kZptR3P|KKha6(r@QMrW~jZvl|-o(JA?cWT7l#&W?<Yi#%%Kpb|T-?CTwK=1;Z
z{w?JO<oYjz{40mGuaXw5cT0reaWTTo{q?K_3?__a8Q}j-TR%DCKS=tAibIOX)o6et
zd_41^<~=OsP}Z@Ju)*=ZEiT&)j2BKK=Ezm7lP|~tYksmz__duK_kHkMAAn`<4GBds
z+zc6j5{zfjI*o$^5+A<J)lmIHOQF^_2sHXu?G#vA0QfZqJwE2FfhIbr1TcijhZXvg
zkoq<K;J5{I0Iwqiv!y(;@06OMsGhw4V50*=y?mmh3bf(UpyKq0^|VUf)Eh?{F&ij3
zvA+Y6L|%?90DS~AM3Vf2yfNr{TeZKv28xiCqZ6=EY`{DU*whOj8C<p%cte|smu+2Z
zKF!I+eg-z69zdwiHW2y2Dp+Gpi3!zc?*xO5YFr9Qebx0Tx|#1YIBIbQ9Fb?kpq4}2
zShT5t)`R;vAXlT72B;zv6p3&>82+Kb?T$t93KGSk3@SN53Ev$6Y}3q%%Ksex>VwGt
zXBoih+4rA+_tE!1zJDF)iSx<(C-0v_0r->R!&!zV0;EO!)7w`_4&ajW&*(FJjXuM#
z=$G?(u!A2$6)4S;AGn<$bbv0*WcM*NCce23f#!h=fJYK+A_e;83dM^BUghJ-hxMXB
z$rdd+#(lXrWQTTY=TqH&<GO5&`&St6M7U8}IA58sZc_X&8=;k*5)369sXbR-A@tZ0
zkpNkbBTg$mQi)n=a0!36vyx+Ze1HgiGn`rz6c=E^xW*|;fY>Nb05Pua!~#UfyfCQO
zIx#<dh%q$wrk13mlZ{6fbPgV@f|fzbHpv@E8iBxkI@o%0cMqAEzSvJUuo;8>T+efG
z;8T6-W+_ji*RBMh!HJndpb>!r*0a7M+Z?g!4rB&Yn5j54f;7*!1(R4;9P(b<ERo`=
zQi`Li6GX@v+YLis0YH(C$8=O+VSgUGw4T!HDJv!9V<0KvsVudZJpvt+?||heFu5U-
zc8WmRP@v+ci7KxNvuOdtT@JI9TohWP1Ns8RSivhrt|-lXDs4o<#iuukK()}jZ1Wl|
zLBmXmnTLFSCc4ufe(gQ15c84RA9j8m$z|+KAwkjzXzg+~vO^(T_L`fW4=s{D0Qg?*
zk!x_LL0P?Muc%y`KGbdXvxNq@l=PNOY}I|2!~r!^Bb#VzkcUy7eGc1=E@Q>*+4de9
z@)FCepP_<B;O<EZx4Kra?Am#isQ}X!2W~T3N0`n)tG9q1s~m1VmhDq@0<Gy%l|fDV
z@|i4y-Fq-djcHkUy%e{X&|91O_Lz=7$W2mNNn0|?$X>{8khD^dux;6q_NxZR%t$c_
zKLWYz+?mwo(q=N?doL~p0<Z9%=$=NZM!V3efWWa9IN9bs-9!}+v%$(UWnT(z2$BX_
zn7yi#uqE(U@Y*S$uKq!o*r+w2y^O2WSnA14%>-aJRSE^(dK5Cbbh6(-NVrd|l`oyn
zI$8`#?A2o5j*jWZE1Xj`7MXc!Nl|A7OT1E5t(Kp<jt?WE!2|&tCiM^%TgD_x7DGk-
zBDr65Dn%Ga>PIwvF^f#vSUI*8C2pt@9{e%p<FW9Rujv??NX4qwRV}+?Qf~tDGJ;o6
z!DIre<cI{zZrpO)<}m-kE3x&dl<AsM%F5=shBI>U3|y38DQV)&6Hue=7=9A)A3zF5
zwg*rw$#z*t!4OdjgbHO6wsZ~GbTB=Dh6T>GoH4&}6d!Qti>GHOLDh<ZQy+;+?bVMl
z6q*n91_-*V5hrAUY~BcviR`1NRwMixhPI;C6R1QOMOgt;%7)ZalD3SpbY2Rz-L48K
zM;WYh0X9f!1e5nl;e|+F!?TGPJO^6R1Y=jC_|)CpHgi<5Rq;39`7iv9KKY;Q>t8^-
zQIB%7CcJ%JeEU;Lnf~;5`O(iMsrp&?_D65Oc>7&`<e%Pt65f8EkCl<~f4~1+5+~U^
zvq-Z!Fk>iT4hoCxjx*_H*-OFIlo|{Goyh-e&TJw}p&HjTko%kH4?|hLhL(Z@Bcx(o
z?ofWM6x^>i7g?b=R4QhJ@m`M=ewi|qjqT1=rIOoW+9Nz@@?&TsY!x*LTmwzvl6tgk
zRj8<^yoHzH)WU$23-OQWBu|^%^Y*l6>(+f=y3kJs?Pw4IAeAHwTRzya=Ao2u_mN7<
z*T-<?>@3Oa@1@d`>_huzd5PqJ0_IPJM?jv)j)$(2Q#`MYDg^+CP3$&kBz=qCgORG|
zsFJ(h<-jt`F&M@MuDgP{E^0o>ELMzUI#9gnvb-hSlcn4(tMg56Fre^6W|-j6Cq<2m
zD082hTI3eAu~S-!llx(20QoCsLv@V_n`B5e=O>cfaK(;;+EUxe9k?!&Wg;16SnX3p
zPkojYs8SKol?|AMvfsmNP(vS^{frM*nDQ4;QWn}GLzI9Wi}g<M>7emVd4z>SM94D9
zrTb`Wvp18Z_(hKqdWZFCNmV<@i^_wH&G;*6jW1MWl4G=T46V~2S~Y!qt?~IEeoXR1
z<K5pptmZ*}v=b<`@D0O(HE%WQ*(@K<JP<G0sg|>nA)O1^DYPyXcQCdHw7kn_u2}bb
zLO)A#6BVehpf^v*h`az<K&HR65kPz5H=8iQg88aInl-T@)1x9F2?gDsYiMUAEnqW(
z(;w%pCZ0rgpbPDfY1LiiG4FxBhSE>wO)#qgih#LG5At$zmYlpQVp;o%`5ZdQ4q(2v
zDC{KHK%A2Z-(F9WjYooh0W)#}M?_D7dokXp{PJ7-q{1S^L1ja*c&|;nZMN1@?#F2H
z#)P0n+7BFzO<r0_ct0rhzz=P6;vgBCY_mnRoi*S97v&s8G6`(>BhTcLy<{~c3+y1)
z6RH6XH_rJad9C)0)7Vrol!Fy1cE$tmCg<w>t%eFSIBe&qVC9jI!_rgoA^R#o>WPGr
z-7CgYwMMN|(qTwtJC8)^wN+(h@LvW7^7>FT+-8Vm$W39Vb$ignQ5l!81Co@bF5<iZ
ziN#cq0uXirTC7n6VmCbH>Ib>`owufpT8rxdn+)Yi1OoL4StiwCf-IMEq~ha$(b)c9
z^!R(>zds_n+7X{&oc~Uv<qOI*|29ARXYG_<a~y+q%Ev1Ekkua)`e`VOS8#laSIpL4
z3z$z}c3`H4BjOoh8aXAfEBb6-4=e`)ey^RZp2(*s+&JuLW}c*`y2A<~MSJq0CDPim
zOM<?G*SM=(Zdt7`x{y_Zw#X%_<)PGX4<r7nMG_{t;hC~na;0BB2%vZ%OUy}~u{Pl&
zm?Nz&O1wN}&rh0~TNHn)2EPNSfUqWN;~IUS3X}$?6);vBfdinj#E3}U=Uz!GmyN9x
ztYRWQS1BCI#8)9fhELo9d?a*jxhtQwkvazVr&Bq?xBu<^O9h19i=_@O%-D>8E+$Vd
zkbzI^jC9)y0@qxCGeZgnFxZwxAkVolkwZl^YCf?BpTf>fXb2^h+m<2|*tXd&K~QqX
z^N%Dre^gA6%!LnwrRzYu8M1MbACNrH`uGz}aw;Hq9V#<*C<z?U(H`J=G)1sN$)`}$
z9|Hi4)3oK8i!G-S%0>kcv+RW+^Bf8F7@-Q)+F@KQw;OgSWuq&cPq)Dwk<i06G=Pq6
znpk8{7G1ChdIT!Y&0+dBsPWUV*~$czgioNjmtWga@^M)_E$&gsjTEQqH~Hg|Q)u!Y
zsou27Cdw|4s<$RjLl#stq|n|1otMCDi!1$=EA1&RuYMYp%rJV-qgVR?SzdN3l|j~I
z%A%!w5IpZi#iuJQS#SNw8?~Oxs63{!WD91f6k~MqSoqLPMb$3u3VYSbo%;QzMe1Aj
zR+8_+cVJ0#DlsOA^Ub5n5Zu}@_QegTRtl(rZ~}!_3-vejoUAXhF1=y)Bx%tzJCVJ`
zNGQ;vJfdeiT+(4{14hoIO_QN=L`~c4aJWS?9=vJU(u!tVaivD~SumBF?PkzqNK#hl
zS!Dc$KCEQex=^)s`dFc-@|tFPGXuR6hdcTN$H?rWJwZFHph#6iD)K;#!2@hcb{tDs
zhFKj9%We=zr&Ke+fr(a;>_1t&)@^~KFz>0P^vx4NGDS^RlpJeP7gUe7dj_9blz(h^
zG+x<3s@n&o^_o$EEmAU92d!4!=MQkoO!G~1qbOS<NU}XAZr#Iqv>Kr}v@iv(#xbjm
z!pt&1(u|c_SG9#L>C-jkBTM2rLfT0}GOJF@`;$!<q*_SeRqjNka6LUPx6X7;8aJW1
zE2`mWe|TD$g(ACH`fLh(^RXxa;^t&4A#On45qn_5ueR1t+&3tO7(`XagO(>Pfal~x
z*;#?@!NJjvk?4)kxRP#%q#vN#(YlFf=z?w4^ao8goqAqa&m$A29!7G8S?wn6#}VGz
z^#F&tI2Tf@ZE48Qk=LvG9N09vLu=)G@?ZGg_fBlte|!7UfAlr{zkLI<EVG^dB?nmf
z(I1~NvtPqM`h$cEC%=9Bj9<eKj)zay)ZgSse=2_imeX*>{7TI+VMYD%`|mJdlP_;S
zFTVY6;q5n)q=mL-*0L*O*Dxjkx<H4_&W3DcOkVy|H6$c+dPeO4SgMVd44U4%>r=w+
z{bX#>q(nm}6i5(<kB8ES*%r%vgmoLsIleG)SO2VmSd&ivIwSOIjmE}7vRGyAbpZmL
zl%L0jft1G-QzdC@VCrItpXAXWStA4}UFKa_oKqw3HTPGbDj5eVU|<B*PpBc!?G;SK
z?Z;DpWQEnZ>K!>ZhwF7zb*tTlCIKs%ci>GPl=q6kpO@MijhSV2EQ;K;+gY?pG5>7Q
zjM+L`zoz*Rx0anc^-QyJTxR7u?a=-JpTfE-Tc;_|D>1aeosFOc0x>o+GA9WJH`&2a
zDNC3KTj!Fh72VE?>Rqyk7I<SYr2?`bkRhYW3;XD7ViiIw#s*kLF2!L-O^NP?`B!ba
zOe+q{0N~+H3PGr_+2$~mn82A1!T`KWzv;E_c21ZiLBig?%~GAqNrh<07KiL_H}+G;
z!*oy$-{5`%nf>GlmeuotUT%;)LO!e{`>5o?Ax=7;s^dYW-Rg{_8<5mYIuo>Kz$zlA
zmV%r>@kTAL@?oi6{f$y}_c2g}0s&}I9;p>+_a+8QEHGC(yi#DWUeT1{uA{sI#|0zH
zo|s=m9&+_=BedM(;g4|xkWg;18z48s75PpKH%Yh-?};|sH;yy&o0WnTtvYIw7A83k
zG%Nl6!-q=J5deIXduTzH#z1-)Jzx)7PO37<cdU1HMVe%TYEpU7xQNcdSt-zmjv<sW
zTMBo*9FDe<=D=UQ_NAb5UXtV}IXweUNOr%daiYaa$!8>yDzbwd>fhb5GXZk0@VaP+
zJHRrEyPIdCZ57^1d{Z9mbltdX65_KROv0ukR~TXCNid9}ue~XS8!2nl5&m-H6H#75
zPZ{ip7Ncbsv(|R4$#_-@xRxCx17hu`LvNs(aL9+1S#SP|Y0Pj~nPD~q9Jw>0ODTB|
zscT4<9oTxPa+-c;Ho>agy%Jf96FAD;o5Z}Nvj9IVlhb{XQ5;e>09iK)asY}}l}(Zi
z;F38X=-wm(pLKyK*!7{q_2~g)ynxeU2l?kdfB!vLFrUAFMa|4VYqWe#0PDvRyFUs4
zT|W8yx8DZB7$kI0Mg`yTcC0t@Je#i=gI4$0L(Z!Yi7gjO0ji!htJo**ny8+x)NXmS
z!`|tX(<6O%NS8cXjK*#Mcqoi1726s?=|j->@E;`uwtaC!zfJBmDhqCy1+nD~CWEzw
zSM-I}R$}#5qJEIjY;iwt-jwxJH83pgbu2mgc>*W5Qm<p!<pZUp^Ew1HZbl&Um=>%`
z`&kGA*4~KZ`6{`geUcZI3{#Cnf>rxIv=xhF)h&@L1j~SI(FSh~_tTu<OeonipsVRv
z@|a?|Z#L!#opTx_yRf#F1SYu=G%KqiE#h1n_1%(th_48N1!}93O6=kA#W<X);ftXp
zn2pL{l}ZdteNFV4>SbV|+ga_R>>6zfblaDp?n#F%__XYmHqd2Ho*XFvH79w1xRtw_
z<JnVyTq{JH*@4;vV!*T##Ip1h1yegMihe?(xKN9+@dJ~Y30QS6oN{u}Tj+v(1vi%Q
zgJBtH)Z2VmRVT8MhH;a<Pu`W)BJhL`BV}x$Dv5@o<O=IUlDskw-Yfw&w{fS8F=$Q7
z<lzvekrRy3INa(16x!q(rIqebeF-e^)giM|ngUcJ2M>?~u`^qS&|`9^q7JiqWy(wI
zvZ&a77^h3;ZIcQqsO)*ka(PKQup!Dm4(3pY)o3hGdph_i2hX|esG_9QU&BEb5>(~k
zLsx7bfXRh^c<-QGNHbE3dl{*!ct<0kVqyVn<(x$*)*#Gd>wn|6A>VF{9E#qHtj?XB
zVqH>){lQHG<6wnp3(A)i&uw&t=oU!u!+%Wb$LC(4fOtSf^l<20ZXwlv=B$w>fr`q#
zN>`gJh|WOtB${|gK+=XK#I`NX=pB};l5&@>ox+7#!ljkZ@B>?oAyixjxnUKYl9skf
z|F+p`NfKy-B2^l-N2PY)3$5G7)_Fe<UK&u2tmvho{u{Dto?!T7aeH7*U=#|->d}h8
z%o8&BHK6n(nj=@m+YhAu$h~OIh-z2VL*;D~Wy?}56mZl2#ZEfOQW2I%&uE~G$1MmB
zT%p@0&uM^lx@6(dc8xxGid)?v3+%}yLffPTXS9+^u~U2=JvsDTUxhyq<N`Z2Xux}7
zc2ilGJ9kXVZ9Q<hT86$BWm%=L&0{Wy^K-HsOfpvLkm$3a=aE`GMsF3$4zH08xk`A+
z^k4(g<C71>C90m2q%g88+zs&<TX2!$wze0;N8?qd;ni^bQdR5V)*2k)yNv~X*xCv|
zx36EFTN6LFhQ^QIJ~w^uZ@+l|>it*p?;qd(<=daV|LpA-;oC3XK7ap7e)g01Pr~~j
zKg@9q{QJ+6&k$d7nkfAn&VCo(t()=pZ@&)k{l12>&CTRJtohw$ZPI7U`|K&%DW$_q
zqEx#SvTfTpz{Nck4_RLMdTxu3a#xoQYY$W+Myc>Vg4@d>M@sDh<f-9ed)*2xoL$Yp
zO`{uvVpQnL*@?!qt3*duSHNMngA0iRrF(J(AC=BX@lx%-&j%V;{Sy!HZqN)Z8*DJ*
zL9d?MM<(RJzTzNhtno!+Q}3&3ja?6ry$z=J0c1OljFhG$-@%PjQXk2)*KL*(dmP8}
z`3NCwA88@jNoAG_G|3P0&el1#M*gU=ja%(C$RDvwyd)167^y-n4Dv+C^S~R%w1Pro
zVDNOiZ!n8wGf1-L(L~zduu8=*3_|KwY6wermZ?P6d>OmDp4c(KEXL^>)u)UTE&0fR
z#kaOLl8{?`LjAl7O`^{zERrN&nvqS|Z-KW}4FF64AFB9BmagPSJrl%f21nJ&K2Vl+
zjPIcRh2*xF@;kxrZOJs?+6oPML+lYqnnVhi4zrdPg3OopL{UB*#EWsseYv(iK)+Tu
zLs>Ri93So~R8h0ff<48WBMN9iMpkHzM*l7eBgAL+V|`@5y=uu1z^$}>phmh%vCcdR
zhng8Y93C)5g<krTgy?S7Nd-J~fiSRFqN9|egGv^FzUbyu92h+kvZX}_f&P%)?c0f4
zq@o|hEXZymFU#2bg!jtJ9uKI?(JJZUGr<%L)&jBxbqa&)Ak+YTI{Tw!uqoNv8Z%JX
z2FM4HDN}7}*Avh0uERs{xNnF2EyP@EPPg=47)ip`rWO+<h-c=l^M(-u(7y_nwrmRV
z=6(n#V3-98l?1FuB%&A(N=j(Z2Yh@=?FW>`VoVD~N}EpsL1B=YZQ*Cyz(Non77*;k
z)al7pe}yh>J39aEs++hS2Kt=J0+O_?<_xN%#PkJCzWlx=;SGR-=My#2!;R<&`%9?o
z)z+_4gckKKZ(4Ecv_Tmlq;_%jRagy;^DrL$E6JNKaAWpy(%_UC1@(l1tfsLZ=YxI;
zrnFCcYTV_f^iW5-*g&+^T_UTk1a@FsiPgmvXWWLB<E0*V*OPKGRrlQM>@IFU(9Vj{
zcjRrWCZm1^7-miIEp!%%uUV1Kx_GPF*#ch!o%M9UY@soC(oGplsCd=Aw`SUz(rl@F
zjKMXgOJ$tUa1__hT18;}D|LB>6)qK0f=i-;X$Vm56V01G-XL?*YO5GcDElUibfU%I
zSks$Oj;ww81NraFLHg$XWA<-sECXGVw|_oykfG2t7W?M7NU0PzbX+RSLm;rZCW#K#
zX=%gl#0*|2uBej8u+f#$7jjmuTZ48;`Qs}C!ZVcl=K*g?JPc9}+Oa~UPaU#{TBhnD
z<TGP|T8Wv9I`?8(AZN6c1U!8vBjY4hDugXh0=-gv?U~l8a~6-^x_KHk4n2`ODM0fI
z%c%#+f^h9Jxl8O5lE^ciSPyy6Wt-()JqS11R3x9-tK<(`D7}Ru5iYAe<#U+F478G5
z;MjKTlS>~oYdLX?JB<05g2=vBMiU@hAie6?*@)7<uVhutWCz6uYErt7RbZgx!#Kwq
zd|&NssP~hkJBpl({}NfPJ~oOi;I&LBmel8l^&Hu-pQRY=w<h*|tXU#xC0)$06s=)F
z23ZgNGP=-d@=X|6nu^-~=)!!UN-~3YOfxd2bOlInOAz$Z7+@De`Al1PHX;Sori&99
zgAhbHjrk_k9jE?jh)p8j2vc#|y=FHR*>MXrdhCW8^z+Gw>8aXqNW@%1TDuKlw<Lp7
zY`}6kG5OR!mONtv)KoHATQAzqQxr_HVyv$;rEsi?_9}Q1#znszh*%iAb<QTLqRT#X
zBg|vaEP+#ns;@&c-(E?F5`#$uxYtq`k`biFwmEJiZ}#4Z+#a0IG{_Fzi{cK2A^EpT
z>~Zu7UQ^4R_4F;Gg=1XrR%!z1+MhfbTHHldi!sYiVW+kRFur`XP>nXC9gmV5TG-ZH
z?aI*6w1k18_BH`A$dgmy1o|lEeggBFcr^o4sBGtlWsA3a6NeF`W;;!?7VMj%(#F@#
z0z1~?9inC6o}dOIg}I}M&LwsjDlAjB|JBD5Jmw5}^0H#aInJ`c7&JkmmcK)hcCcC`
zohuNxjk#8*2U>A<+^ga@%~jOGaztMaP?3_Cz6P>^)0)uUKvm{o9P%rJ36*SzlU<JM
z;0f7jr!s-$!9b;j$IB`yMn{s4+`}*YEGv|0wQttdF-w-TdpK&da;qUiVPSV+vQwho
zT_N-2O09C~>=z*UC~Xi54R-!C)YIfs-cOw8TJG$bT$*`p4qIs;u_T)SMxQ^AW*h#!
zUcEQ6Nxejf>w3Z;#|3^=>@r66qZ{~UF}ad#;gy!Eh!t{E?vmNsPY<dGzpzqNQIohh
zm|ZewC_{|b<ks}@3bltc8#W?p0%yPfd+wR0r+V_``@ftG*1mlI8NUV|*t1Gxe*3)m
z_NQ;Z0xsl>w;yKBlKfg;!K%xj72vcNJA!Zkl8@-uYFE;|9Won!KFwA5$yE6{t0A*{
zftG6Jnr$&GXQ{%akd5EQByeD>)4)wx;k2?Dw`Z8TY~-UMC}7Z%{aIAOWMi8{yZ$R$
z8V4_@LGg~hTU#>$!q3@=L<$NNdng3FJ(1$#aBQR*)+2aIaRWv%jCmeoSGf=f#tqgh
zF!_+fheeSK2CC?_+#=&dL3*@gA<lTY$;P)#VB_@gs#r9MX11TpBcQ<vrH!DXSxnv>
zVVfO`+;l}gMeq$SK6TmMrfN<Te5OwEI(az(9Jo}ps%Ca&<e$J9ouXVXg|IsAY1|b{
zcG$|umKdKAf|`d3%BbH%_vaD1U-A#;B2oT5;L}6eKyltDcdG2M8AqGG^uUH3M3nIg
zU4Q3+0ssng@nc_-x;<>9rGWj|@wk0O++A!jFdS#cAPSTN=;27v1+$B-QnTnBR>9xB
zM*Vt?+9}^UOYkI*t4(OV10%YpiQ4GiC<CH6hIrg6@lfWO<Eq*3iQ!V`()}454mete
zRg9q__@aUx&>iEWbk_k#<S-*NtyJZ8E9nC$Z_aGKL3g*_ES?W1sW1#V+GN6k3@0}<
zU|hPVRhPk&<7hj`oe>_V(ItjAQ)2g{?IHG}cblbJng~fEfUR8BMu4}tT1t?T<ks>^
z&6702libE07-y-Y`o8#ulH1z)57|vxlD_K(m%&-X{wssaRojcm&MXO#ViXt*_#&l9
zp)|09yf&6B7H&c9g=Y{0Q8g2KkjGZrqvYsA$w7k{`7h~yG*Z<H3QSdiG$dGYBvoT5
zhli<vHjMqjpHY|i_;eUY6F2yWw#)*u+Mg!7XHKr{A<x!T398+;_iEl=1BvsrQKQ<K
z1bvt;kHorFzy(zsAtHIk0izoEa59WzHBYKat8ENF<WfZC^O;m?Sl6ee1DQH=_<=)D
z$B3$%Y*v=}mh(8M?P_)4a!X*$s0RjdQ~97jV`_j2gzr=Umd0gKRg>Bq13_bf{Xk~a
z!tEU%;?PKkK4*@-fL6(8xVmQQc(sNc^o#JIY@3e)e80w8U=eWA;;+6R{?dS)U%Y?y
z_Qkhf{ONDse<dOJ{de!5+wkJ2@4tC7qts8{KMwCkbp11Q#=n@KN~W{iqZJdm3!sEu
z?Z@)LyZQ;KE-7xNr-cK^b!54(#TfSx2tl%DKr%kbeF;XVXtmC3R*=jO${#Es)(g94
z`!pU38@Iz$Vk;TA#vc-!pb%$qbb~x5q(Ev8G8AU9L;vv%wUDZNV%Oj*KSZb|P@#ik
zEF=b5mr!*^j!-W}n|$#V=J>}o_0aD{oP#ph)iU^1)x{j%13nFS5H{Ia5c*IoBkU(t
z`G(Io+C}EQ*6rvGNR3Exss#KJ<gStPhfB_T>=%xuT6pkDwHC<7u#jf12NsQjGvsKI
z9i7dLOj<ZFop*Ufrbp8D?k2YYxXeLEt<k1fE@-CZ$JF?c;|!SDjLMs>*%yI2=O8tS
z4r|?i1-E6oqC=qwF3sI72U)Q?4`82mBOIeXqb=TboMw!*?KtXiz5vVUkP(R`u?!7>
zqbr!|NR@NjVRLQ8In^pP_f$YBP?Y0B6w-tjHZJm`)=kJrkyC01<Y;LyTuCmJ>t<*2
zDMK-YW1J~XlT$OMa36{+5N6m7xJ?Y`9l%E3G(iTnSPWD95lO>CJt`^9rWav)+QAS@
z^?6;xZIgY}QVqFn<1-w_uJFP=VFuLT)$Lb?TFs>w%8dCV$^*8C>P+mB7~&)-@?+Zh
z;p`Y7Lk|zR04S-u!^sU!uQ`Y;M9wR^Ks{F#zFO7p+;O8dF{)@g$W^yrcbB@0?sWIe
zxa^`g$L=wtHQTAQ!!7%~&JK!{<RpU0&UOP_?edG3wP#~mKs5)|Sw$X^F4URUX2I@<
zac2)fw)mU@jH*bSk6YBCoyvMJZ@EG;A;<L@FdmE77j1+!j;@g11a#XmJS_((sX+tf
z(_J$6yQX^<>|s|BYe!{9IE^99L$2P^QAy69@vf0v)l#cjBGtaLBfoXJ!t88N;ASh)
z8k(B~D2(n8gRl+L5*5V&v&$lO7Q(O_!qAvi=pWh$P{mlnFy$iyM>Y_=2>Er5yLPr#
z>V%gaQy8(;vmPlIjmXieugKz%TKsZR8`Stf`EQS+*9WXzGysNz9##(M6o5Qii=xEv
z)BSoNPdX|v6XF#VNpHq^N$WAkloGG<994DRKHAu8Ri{gp63M49Ow*RCJE%b!c6IJS
zL{kn|!H^TpX*wqvgoFTCKl&XAch(L&)k$PBR_cqZCN23TV{GuDL93dmy%}Fa4vKF-
zd;3&D44=Gz_NTwi^ow6JllcAHuMe*kKfyC!zkhN(<0t3i{5t@Y_)*AT)PMc$<NR+p
zpA@g=da+}=HWWJuUPi(V<p5n%^})qJ4EzpcCOwR)pA9%&EfvW$<3K8pjPlXK;x96&
zW(AH>@n4p0ppL<BlniA3Kr9Rrv>=g5_K6SOS_hNj1r2%uHQZvmoIKfbkRX;Y%lB|f
zFsT5hyeN=n`_@&=Q-<>J?1EPQ*zHogS|$JqkJn;>?-znyesDthv$;~ofcYZRfeFco
zj}3ZNwdS|>KxFn7?E8}>^KuZ-FtEr5?ZJUROVXC8y=d%KP@RByDGDHo%c^4K6@$cX
zN$}cbl%qQ^|5xgzON~2kxQMuF&U2qPZS8o6a)O?iwdd!!LkDu%3E$N|`w96BL$kw@
zrOnU-1ERpGeIesk@hE_k&P*<$pNs`?=lfJ~*LIb!HJStVAbQ>-mm{d_;c53QVEhP|
z`J`^$X9U_Aagi?)2w&}yS#9?$6v$~-I)zTA3vLYR-dHo88%7Cr;MJ-KT%=g%AQ=Tl
z>^8;%%XSHm%1$J{Zd9;T@nuT2LsYWgSB%dU0g?5T$;9b_h=H@;>dr8aQ{~!^<4F?2
z;1A2u@#%ppM(ZeEkC_a_RBh4pQ1^Bx>At!`m5p<Z7tcDueQrHFFxbONQ4bY#(&msH
zE^rn%gjFY>$`Ve}N1f7~j!|O==@-BOd4qR4!X1h`CbgDT%&s^KX1}b}J~81yodi2q
z8p}&yjXENA5QFwG`UuRzIM{l>wGha+<4YI%)ipm_@Bub9K%Pn=w9&?}WC<BLy1`pv
zV((Y8FgF8g;P>1S%PF6ZjZ4%<hL9x9Q<%NT^>2%FSh>Q^o{qAcS`Qci6iUCwKY{)Y
zAthHxP$@#+WrqNHs7V|F8fRl3gFZ_f9vxMYFK7kwN%j9xoA>;Ht9D)5mjK`pgk3S!
zFyj|^lGhD#Az3Sz;)04j8;U2{@$fb{E>Yzih{$W**o-(DTHEmfF=hK9B|~V`vU1@F
zV@5DBBh>R#icgf}`f<Q01~uj4-X)O;&UO$Uv2$e-dG7?h0Kz0B>)LY;k<X!TJI*e1
zCe`?b7pp>rEb*=CMu56UW?2AFPU9I|>KKs<fRH&IKnYd0TMqen*#20P8~v5VJ}G<<
zTA-hLKB`tidD-l>og^^>GJhwbq+Cyee&sA5$iIf6R?+z8NZPJa(K#=y9OqeA(3P#1
z+|2bwjX{g$gm5v8u1a=vUm~cxaKc4=GA8XajH5}x;*u<m*OG-BJ_4N<H9V1oP#|+o
zPlQ>#JzgcpaVfbrzsUbF{3ZU=<J?aPZ+|$>e*N|%c+NtvB!f~<wsyY?kZ;Wr?_cmM
zHQ!I)_vPD9_%-k#KZ|_okH)}#`-TFrS-niZW8cEzHM3FoRWiVu7#Cph7u)t;;2H-^
zdYaibgT$fKInR3)>hVe}$Pl=-J(b@*fPCYiRDh3H_+%2in&J!tnuAC?a{lv>{nh8B
z+W`4_Rdif>Z2{QBvaTNO;Y`y3Yw9G*bytrE^RJsX?ZLb()LNE+B|&d-ArWo+py1^s
zMv9x!u!-tnyKIE1wrJJd-55x@aN8wotVtp7j(MuA$FxrAo5)t|>7>~x{E6&5>hp@j
zb##XUQY(o+g*rw~$OPB+a-d2wV|k_PP2_&KOr7c!7V1v{!EW|(AQOjw%T!>P4vz#l
zby>v*pzs~cnnvypNYhg`MMu8&XS4#52y6ML?3R!-x=`GF$&S7RfdqGCkc4fANlR^`
zG-%8^#}^fEnO-A-MR|^dHeoRXcu(ohIhZCP<YNsK^HE4kQ%ny@d1aRiuJ|xD`_kt8
z`oy168*-Yy0LU?)xHW5VHMI)9>`v2#_`>X5nxQ~5@);qHhSpy(R_969D8HwQ1bYEG
z3+dR4C1T1{wvA+H775$)=HQR8t+mal2k2kR<!Y(c4;d5^8qko4<lpXS2=}I)cB2)p
z+}a#BwVizX#%n7z5P+gm!t`*F)6Ppe0H`3@D90wa&}5&v3ajU6vGMRO6~XJP;Z(wl
z^^4Fv(W6f7d+iX&MbEWBe_u8^0C<<}n>O5x3|t=xdKY^T6}xPdYl+va*iJi+mM`B&
zpky(HI?qGyG1HCj*x%^k*UKk_3t^y9EGCMWEbtW~qPZO<&#I^=k%@+zJM}G-0!^$h
zRJDg>OpA8wvOpVlR!4JlglKdrF<EcG1P`qn`1DCzU^9nG^Xs9>3~9&_K=ko|p+pMG
z%14ZQ*&Dn7$#+%`HsJW_kv8bAYWu|pFqNQy+g`!8T@KKEf>EDZ*}MH7v{8=k>IF{m
zC-*$~qbp`t&(n)+5%Yx1s(R*^k@^<R-$jYSq!=e<`A8y#u1c&VpHd*W-0llV!leak
zNvSZYp^~g*R)<I$MCIAusa05mXw`HwsK9!Lz9WYAI=Qz;>y~&*@|n@pcb(H64FsF&
z%sWKkcm7?>g9s9VK0Q(edj?%0nCn4E1k;+UcXy8J0@GHud}CJ6j%9JQN4~)j=XZe=
zlh59Ng>2z7iRhoACGzv|{)gf<PJt+^eL15VUqWf6?sIq8=~E?xaDjc8a|ay@of3G_
zNs{IYL(dlFY)iT<BrvSqD=}BL?guAfk5*kI4sBSBPe}JeD@1Mrn9@oav5t3KLK__5
zPMQ$C_AEY@dn_6&15~>THFLKh8(wXg1Cu3-j`FeRu*zTv35%d8Fn2x4K4uKNauZ%9
zfFJ;_q-G4`vzMKzbyfltUlah*WE1-%GBUcVjan#g))N6A%;1?7Dx!ylJ_s||;o^h$
z#XbL)<1UbTVbyqOqe$wdt3#GIhvZR=H*$QEcW>wrxKdj*%c>Neju4P-NDM8;2}%tX
zicG>|y@ac&M2zd&gBh_Osjf<M9pi@efGfh0Ph$J}q)+w`FZP0l(Dykq_uxH)pk*M#
zQKk72Z4f~KLkY>gQ-wS$`F_|%>zSQ|>qwpiaxVrh^b3II;b|bxzemGf)-}%{C~}0Z
zk}tQ{jy3?r$EZRQP^55$&a=rs*ydHeegMXBc?nqnsyjZ?BL!-8Cl)~p=|O1-7%@p+
z(5{bwTv#!0mIp~-uBZW_X`;0n+kV=#sLE$eApIcrs;vYq5{lC_sPJEGJvMOflOkR1
zLyp*RKe$xalb(OZCu(Meiv7{je5I~~`>;$KVMJF{)I=$E@cpUO4}4^O9$kRrqTC)k
zbcbLdTOrrLS=1%w+0?qoU1Y%m`x11?vCl&b9(#4`p|qAzU&0*u*zXA;K}#<X)>I*w
zL8xk2HexO-jR#ccluNuQ*QUC&yoLIOm7^*aff-3fl!1Z_Tp2=z#qN=8fi9IO5PSN&
z1GcTW0HFL75a72-7S&duP{Rj8okt0vhhW6=h*n{!cS$=-;cr$OaaJq^Kg<ZSwH@7{
zH~@sZohxcBSyiiW8&<E?vGGCzfV6>1_DjRM{zdq~NgdlwO#hW|fuBh<`qSSbD*fT@
zQv($+HvK-l|K30Z)Yr6X_n+Q=6W+hX*H0lIfiL-)w;zXZ|4)fvx@F}E_6(*7y+eIf
zYEZX>@K(MBvZO*c*-d0PqK;v#A27dC;?i~Y6FEM_ZXbxgAb67!iIdqYuk9Z6^2@fc
zwU|EBHUy(#M-{k{&pON1eg;bBWg#bPR4OzRCZ9S50R5pHUm5@K00utmJz0YtegyWn
zkXPOzt9cFA>k;Bq#ZEi?Xq2Fnuh|-=u?YlZhLllqMMntC9AeAzmpBeOnzI+t^<)fH
zqKun}NF1~^xu93rBClZtl&qr3ZU4LB!j?u=i8*dandeA#&LkVX>-;Xsok-9$Y8QM3
zm(k@KweXQQb`T37KtI=ovXSubm44YXHVU~vXgo3m&i~T_eaH4>Ups5U5Y|JOQym4b
z8wUsDR<EdzrCc~~L@V91r%^k$c3)4>0o*tS0Q}O78FQ5>8)g@;Oi(aO2pr-}m;%l$
z10fnk(mYrLUP#Uor_h*CkpSz{jKKT%M|`$+_E1U8dm#DQOKNTCV<)=K5Faqy=14#m
z_6uaX@gZ2OmJfsV<1n~;7YNz$cEn(SGkB&WeE{}kt-%0(b^Y&jP<nK@U&;$%v!V|l
znXkxJ1}hMN1ZEpQjo?rEw|7adW&5g<@9k|n*ouyZyo32qDAye-^5zBt6(}+Y<p$wp
zzAIqoj!ZrE8rBI)0IX`mebf<Hs2aTxc)|h){wi7vquJ30&PEumV@Mll$v^i)3KyN7
z+CMTtM{4V|t9lb8_)Cf&Lw+0T4g)opa97z~(8Lz_1nZ%1*<jbA`c>P>wTfJ`&1{^&
z#wK~753FSiO-dJ4m;tUc;Y=Oy7)r3;!X<ZCCBPD&Q$yJ3PD~(VO;~j;Ftlr2OcMQW
zXfo!rxT7?^bo(JT*~5FMn)h(nzGn^p)mzc&5nNYB?QV9e7^q&9cAGmUaTO+0;q^7n
zP7eqY#iP7RmapXoMf~QFT2fq>eSbNGX|nOZ(qxJGQ`^|yEz2Y$hxQWC!!v+;G!)xv
z2(Jc@;98P8mOqxfn5b<Rc9~Hb65&5Y*79o0COK6Rq59}D2-o0_qi8;x^kk(zaGduy
z-hPfB%Ju(e6qFyo<#7F%;or9&{l)v|_VtIS-m&~#pk%`TDix?v-F68tjWr^66@D0M
z7L}n<If6dX?sEo`%GE8NQ6)>Lx+EV;oDxRkxX^W5u_%H8q9iv6&Qe!J_qYaB??MnA
zWe0dxV=fVEudJXXjbQ1KUrSA8WmvqOXLXrOP8oq%Ctw#AFt-wx)3WGz9#l-o0y2mc
z)poM_UK4B-w;ZACI4{IaVI4`_K%icmJag_IjL9gjJthHgS+bF$p2;2H|4l-esB@g<
zRDD3B8WzDs;HA`qLU3&<FHq?a{$h>Vuo&Ne$<k=9+lX88<dI>>D-il%fw@H0RU4Mn
zStad3R#nk3eZMvyKar`$wd_AMxR4renh^*fnm5VIroTlZPeHPqUSp>ug}0L#Sdve%
zOa0T%hE?wk3u9Awa<CpIJ3>A%dBBw5wH3p@>HB5e#AF>n$}Bj2g9#YpVtTqh#*onZ
z-eKwm!=;k~<^WI{E9PKw_r0njWdI#?a0<0NA=phy`6Xh1zl~%NBy_(x3hmQ@O@cK1
zE5kC9WOK|z<G~&cvt^PUWw1Il(-MR&%>Z;iIq2PGOK0;Gb)U6N@77|uLEc{5@DjK3
zBOCN#uxhy&Z!?-`-MvlZ+N0w@Gf}wSTAl@iiZ~Z7_HYK#p5k?_(sZG&miH3bqv4th
z2z}4;^-jKI6IP4xTCxL^?|fdVUmu`#=FRX5w_NU*Fwq#UXsG7X2CcySwyuDQE#wQq
zp=!>5Kq8d!@h<Q@=ArjOE@y!51x+t<@f6W-!(wD)MzKRLkq#EU5_g&K;bWh&cF~o|
z3|88D#89Mxj9uX9UC<A`N!$fYl9OT>W{e1(A>Ikh1B;y=))1dncsY=Bmsna6>jg2Q
zjupR$AzKwu6Du^Hqf{fuy2k|MZ%MX?07>uiZctpd6rn^56liG|U`FLW-f1cY9G(19
zC&<H}bwiMCAu7=ywiO#jgvTUzX<TJ!n;!{de7b>`vXmtJVtm1|LzLfyS;K4#9<5Aw
zyg<u((MVh4U+s;w;MmWOp_9*Tvna1l<X3Y@i$FW%Kk?Uu%bg~?U%!9$AH><O-#-mM
z_`z}hyYT*t;|#*bCZ+h9KJxadS%%^uf8Q5>`dfTg2K0X+Kk|Ef9Ci55<*V}TJ_ot~
zmkQB)`#1a>-hYL7{-a<Zh_fEiCx+~g-D{ItSzjIwpBW)=Aok^YL%Le-wHK->>Tp+k
zd`}foxZ3i2#`dy>X95Dzf1gx!R)pt)h2;TIU)0`hwHmnQflofUjQ09aL5vTbgwTqn
zin`QavMk#>b7DycrURwCs<8^;@T-c;_yl*=Y)MOURSz5|21BjV10}=Z8wwzT#OsqV
z5qyZPZ~deKbL1>ryVxJ(7fHP(Ob`i0ug&*X^m<j`(L(f7O_=lXCN;qh2zg1>fDNz?
zeD`jN_OfnedA?1-7<?Y)7pnwkkSJMGs}gXUuV%9e{ZOPQgK|k0s6Hass8l4#8W6}d
z!kxK<WMUK32RKb*1Y$+gEYbG14SO<?zj?bisGY22Zx4G>l@ww^HK&Wzq)<w*T58Ty
z2zME8`>+v-Ijj6oxLawDi3`#9As4F<7y^gJPB8zok9F$QKrJ5w#I-u%Z-T5zT!GTR
zr;{_e<c#e!fxyv~gi1-mVh{s)VssYEBnuBRgRE^P^|iCZx<>)wMqN_NTXSBei`F!`
zwCyO#=A$sUOPMV79+9gVt5J%7n+;cC;*>bIP6NaUA{U(+pm)0}I^Ov)XbMBWbXn4t
zd0-5<jxWUMO982R&^wJVdqgsHeaR2Qta+QpVdJS>w;Or^aHWfA$1n2j1C)$C4+p%T
zb18sITlZ$_F@x+Oe<`;=2E<SqSXX+I0?#H}@?@vUGxJVzGfbQLo#}9!%y`*}l0*@j
z037{7jVHeH8Tbs%W;Y6Qwk10EPNS04j*yvFeaif}q?wZJNZtbzOE6~j;agDWzi6K<
z@L&bD(Unw0ul5?)dMs%q%}`?Eo;dwQbKvj`MB2}w*c`h?gWkB)2{%QInEayT7~3n_
z_AF<wl1vqs4Z9$a$m0pyDEoBJ{wY9rH;3dY>P~LghN?plrM4%*OL2?PIm!Jtz*|}>
z7;7nX>8_XB45?CwdfGB2sM=8qPLiJv{odusf3V1KAJz(L+f4KYfIH-wEme!c%kG@T
zx_vOO)9#^}T_gzl7;G=8b307eU@bb|LxvQ|u`C1RQsXmB?!&2=2iF`JQDPe(0S$iO
zBcf?X=0{s3?SuP+4uPZPRy&lELD~bAtW)>1SRg#($c=JTQRyq~-OB!{Wx>R(YLpZo
zYT+(-55A$?=tOLnS<(9;8--_0JGxU+FmyiVL>uF-L-B=OH_RvGdU#b>s<=ZZUt9E+
z7YRYH{Dsg(B^nNDA8ar~*HKwCN%F8QxP3hKpGOPwgWNzB8_7^3dFa2gCt*G=mm6QE
zlT}7o=@=^S`Xo`Ko_9Q!s3D=hgEy!WQLR;?k{eSa3%%k4HnWe4R?LSbSZQq6m?y=r
z*aP{u<I!JwXXO2d`O%-g|3+sbKY9E0pZ@OKpT7N26%O8iZ#cVG$erXx_^KAW`7lt2
zbYJEws7bY+KDU=}Ogt1J))5-?RCmX*2hEaGd07@Vl8-}kQdYs#T|)Ubm)Q!ZPKN*^
z#E~dCsLhcnB~lSua+0KkzhVHdYJZv*EqM7rQMu{8;@!&T$buj=2SG**pnxap)JgOt
zwWbbXiTuV=eqbbhU{za2q$Gjr1)Kb;lgr=Iq?7qrgTAerA92i_Ezj9A0bf}*(>@>K
zNUh2EEanvct7He`i~=B2*Smq?{fGw2HsjvG2)D9L2nOxO$A*;{lOUvLPG&$ZJ<<0G
z`bPtX&QwWokqGtl;vt6Jlkyx`;Z4xrFQ&1E=#I__dKNE}PEHbxKfCaZbn^n$;8t6z
zFku1ZLvT{8J5tK;G!O!S!Vfdy0-&}SQWf-teE2#%s~Do@Cr4gUE5d>%TXH$q_>mld
zzUsE-UPAY62S&h?Cx`A(+Rs+jk{x8%8xHg}CAZ@n8dp2S5U_2G0G1(PQH=vf=67)h
z@Xo_JdQNv`L|AJ?-cSl3b>owGeU&VbJH`4USz^}u9uQsHvtOtDf~_xZ?JKM38>+~T
z0Oxj<&7|c*1yxXLS|~?BtHGs{v(T7f_hswPjX+S4M~w3~EIkecW}u)flr^J7phd$8
zbA)+4=#PriY<*IE-GWqe_9w3}rpia^|47N}tEzPyhWD!IL`kF!Fmsi74ei3JxXQBF
zhP&i%Pfks*#4{Bj+f*uA2u07a+YVe92DiP*Zd`O;<9dbK;o^zn;|u+D5M;r9Z8M4&
zHT{~$Ly`j|-CAx(E!wOFmsHQV0JM?&O{RM>4^hQSxz+Bi$2)cUu)iXk4KfnDf03#&
z!5Gv?Tq>!~A?Wbix&z&(##;|J6~(vROz2Rqa8JjlI(jPww~Hm()s9#txvlXYG4`jn
zvt%LjxH{y2#k9)&4**Q<SVPNFK+!-Kj?Ab+V+T_Nv{tnHeeOd`QqaI`UWeg}F@WUC
zLV(YqMpbyBF4Bkser~h;!9sB(dEJ|lkCA;mX(+BY@zpgCI=_X>L?eb$an`mf<AixL
z<{zsoqN|%Yy|Fr|bt-=0WTAm+9rKEM#4p^fjfGe)7vO&iY5;zO?ys{g)F0k{bUgMY
zVfDWx$nMAQ->9k7=kI?EFthsf?T_L8i{jh=>+Q$i{=?fZ!?*uv-}&}UP-Ua9ir1F1
zV9yz&26ydxCiqcehM7;xN}|J(d^Vev4*;hu9;16nKH9PKULvSgCs^?VeJqD-J`&n8
zb*pWXjPbVM-`$Z(OAuBi5>qf#7uGbuEnamq)v#xw<Om=q4@x<YPimR0<4CQ&Rq8+k
zoMGmK{^`unuP_GLlDo7V(7unhHgPtdI~&wWkmARi8aiQL6wEjFEj^$%<r1Q|bDpfg
zIVR{N!XA-7F#~!bh2EU1R<D%98m0uy^Mp(SB@v(!up*$`LJyHhOD#GKAShcfTsQE2
zTBiamZ4V{q!I2OEcQE!J^u^?p#w7xmlBlP>$Y(>uUvhy#00r9uj-3OXr>y;<^zpfv
zo89V+Iqr~NnH+Jj0h<r3B}^pl^yr(mu(zI1z{Ud-9k5Z9Jf$T=Qf_6)A6jMs5S9&S
zAn-9wk|@(yJXwQ5k^t>Wqyr&8w<Db30SV<hgd!jkft(SvhgL!C(a86KNzZ_+no5Zz
z!j(ehy+ljv2mp`DZbAp?GfYzI3|?(3?JWew8`Mg{{ZRQ)MUo@M^?TXs+NwF+CJ_GE
zc);8qpSPP`!B(Q#kbqR`yH4kctNb1CK9XlBka!`65HKv)o9z_HNj{<~MWX}3&8v$~
z3`1NG_`X3N(Ub|mDk$ktcb8<#`L6d4!p4Uv!Mz3Ku}nut`rgiWMQjg?4_g&ENV?&K
znT&iK=@IBEbB9LJF4>L^N^V=f1>T1kQ-%8+8AWf%FP5#i1sfvDW^~E=Yx#7LAX4e@
z64>~5*p3S;mD(yFihn0G2c}tSO=~Nlvzy?1^^hc|l&DyCtz+5ed4%m2WLiz8QLesC
zbD+po+HgoqDL@%vIbK{_$fdAVb1j4Ky#O^%3Dm=3Kj`}x74u$O$S#JvCM8Zn1IK#h
zGznf;m-up4D2B;0)00c+O*a-}9^Ts$!S9XZn^Jltof9X}?~7VzEoOp+z0h8Cz2P#P
z+&<(15Eq#z*Q#R(yT6pC!*r#ds!%Wa0wGZX!;cPIxr26r2^aDo<}Lv8&RcaS&#3}8
z?<aDVh|WN^eWAG=z#40NSft}RNZNL_S(5A!a$~vm1ym@*fuX8KwAaJos{`at+z-dD
zdbE*c1zCM$EL-P=Ocf`9_7zNQ4|I}|2j!{f1Y<jS!<MiHa=W||NCb|pP@_@68DtW<
zO-l_^d+w+lIVj+ovYI0BATyLHPRs|%KGtVZ0(?t@FR%d+Z|w|w{%csdcFjebz>l!f
z)<TEDkaz|aqAwzhb6xW=UL%%lyoN3#J*;mVOEtx<j*Kca?27y+q&#0idcklVgmsWj
zm;oWLBgAL=criT3tE2~ya2x9;#ycz8r>syKP(bSiH>Il1*kc{;6>9M+@Kkm(W<rF}
zKGFHED?3)*g(kA!`NW3W=4<gl!8aS14%!?oJ++qbXo17LOTic{tG6U$R%sl-(BzH)
zaBfxTaWg*qqh}FDpxq8ENJX+bR29^@;y{T?=G;JM?euA{%E7Y3fgjEa4pg!1kjl@I
z9)n5hR4*I2u&V<|N~sC?lzeus<1hrryDiz+=}?D)^q4KEWf*6m*E}(TcD^hwAJWJh
z&e<L2GyJQKTih<`Wjm`hK*8eT+&+1sfdmFX@6!u>CF0d=wQjOA#eq#K6bELpr40^@
z4o{~N67!K9U>am;5HM$wx^*4pm>?Y}$v<--kUby)IimfZUl`^%Nh+oG1m%=fv3d_>
zRTOOGq-Pwk>s2Q)z)6zx0v)H*IB5dX3gcbFi43N|Ca>kuB3jCAN>paNtFP&4%U1|V
z(rzggeunlAIVyC1<HU3*w^mw1h60Z(@1q!`t_95uP!YmTP`z*Lt1RKDqI<l*)$^fF
zZN7MV)#RhSW-zAOo7*$;k-t)byHBsU=qpKku1efz99>RvbaeCbLOn`!tcuJk3flZ5
zdk=i<H7ig`(zsA*Qng5(p$jSU)_^G>&@1b_(95_vbx%sp*13fDR)Vw@9QOtdi%K#S
zsQH27Ky!^d_6Z{ABri{p_?_+T$mPA}4F<FbDK0O}yOiJpw>-W+V45SFRH&on<?(Mc
zsRO*{Fc_cF08*oIaEgq0A?b!{lE53A+SLlM=n~U5G#fkK)>4*Z3_YR#wjK)bqvYbr
z8i8PjL>=$VY#q$LIFGO)+6N*U%vwmdKs{|Okq6MYax+|tv^q3U5A|PbX24_(BCUN~
ziquP)k5p{t?gGv~YaA%lc@M-^e!CpWNSe0biUyrreBbmS6D_~_$z%h_4;Bp7xb)+c
zUD=$eg>oO`JkDXV0Wy}oQaV=V4LW!G05({qNiH+k4)U$_khKaeQP{NeU`c}9Mwgl7
zb)*SsB1%qTU5HX;;;N4A8Nj08nx65q`5|}=;(Z;k9eFw^g(=dt6B&ndIME;BSVvY;
ze-@)JRfavsaF}D!{adzfNoMioKorMCZuLvJqybjG`Jp*0D=>kRf)1&|6fjsBh6MFZ
z=o-_`R+gfI0XVLTxA4>~LqaGhB&B}5He@uQ%G*C5XD6V_mlQSlJY-b^P(pqd{`9}7
zGgh|e{sfSekKcd)uHW-VQbzzm`4kY8_upr2r%&=@pJZ6dSNdJM4g&z@`aqjvr=^Fa
z8}c!v9X%BYsnD`>fpQTBXFi~Nw1?pK<LV+xz>sb)1$_MIi*+{wh-yGsr(-*N*k?{-
z#mr*CAot#I+efyS-E8SZrIt2_h&OIn3Rr?FOMFQy6^ul~J{=;~SY16N>M<y+JavJ!
zy+KUM@R8*qa&N?iX5Vm3i+SvVtVs0)%JJESm+sNFmZ`|*QYq@Ms~ssaDnf2B<r&Dt
zPkRHM_UEBCsj87|n!r-U@(jrLq?xpjYDOTYQ1qg3LRnoHg-YtjmeZ^nFm`yk1a3I9
z++M9?Mj$BpV(GvXxF?zk1k;4qboWLG`WPR0XF}(Lcn$0)vrkgy1uQ{wGiE5R%Wh$e
z#tB)XDLE<arg1~hQDY#j)kbyS=&ZITTvUZ1?2&M?og6SNnPoE`5W(#+$R0=NJGv^%
z0M+@H9hHy3G8=$6yvEr?9VO-OPD;qYk`G%CAV);V>vxbm6yfT^)ev|DyY<3JY!6%^
z?3!&J1Nndn*HAX<!wEdMr}`E~Op+R+hO=js6|%{$%GS!YS8FV_lV2%&?RX~1IyMzc
zvNH_mB!MUP6|vyX=c-;Ieo$=V=GK`zfh89}C>+dcz*~*SIqIYcP7`f$@580H1fqt6
ztQ}XcfVdjCrd1vp``l<*aFU}6$0a?V21q!x;Z`V}a4P`3wUs4dueS_jR>JJjAi<FK
z!tA33jsb{uJC%4;L4UNsCW6v5yKh<I(CYU7v|!X==69&(Hc&dEKKFH-bv?y9COs9H
z7S{yvtzaqR6*){kLL*(LH(OsqKGIk6rHe{*vK*sRn<9g|BCC+?<dRO^S+(ngsRMEI
zml&RdjcWkP7_<kQ&llA*waq*A2G)Z3Qjz5Dha=fiC1N_!%d-%v1{LjqOhYl9husuP
z?rzVB4vhLF9sn2HV#z9Vh;57rNy)(U3mf!2;#<LWv+wB-6&WZxtl2EnnI@_o8r$L3
z(gax~&}(YblL)O+K2<d2Ed_wd(}0;teVDqI?byR2x!O+l5M{YbhOn%P5R|uxewFTE
zmLI^j-POvZ-1gpJ1p0opn@KyEOcS7Fh}7VafP@zg!Dw+(V`d7X%dVlhl))|fr17l^
z7zbO<AfJU<jCZvZvItGyc#tLfL`~Ele=NcOUBN3T)0@^XERbIYSOb%Q6YAod_n*7L
zxH(6twh<1p<m91n<iJ{Et9}#yy$AW-U%!8R(whAEEJFG3Jb|D1B0z!Rl#1w=;&s1D
zRIuf^OR8rX2vn0(7F1Bp9aX*t=3w>o_=!b|k&o;NI2jIH<)cM$mRw&UP@h7ruvF`s
zbBzt$=6r;D@2r5o-9yHV6_P?sX*es6q3lSsppe7}2v&D))t9wII+>vJAZyt?H$h=c
zg=tO>7v!^kC$F&#-AQBm5gyB-&Hw@*dmaFb+Hhw*0X3#9_QfB90FP5rdXSSh_BiBS
z+c%-_O<@XUb5GPqT%=^YSz3cljT2M(7&`e8+i8{g;z(4<-4RLc1cJ5l1+>;aHTH_p
za}T3CT%h}wIs#ImM|)7!<wMkgt7RYnoLZ}4L@NqpoI`-pBp@eHL@Z-~A$Uck15E!&
zvGZJFk;LoOMgWpdKsDO9of6_7DiL{<8$%0Myme(4dx$TpS4yErSyo$B(d%0Ud1h-<
zgoSHca)&aO08&7$znq5kvezx0WDq@Cv;ElW*60bs8V*a#x<#gdjZo?rIAPEqs!vxV
ztn?U*xW~ng!4{g#NDr<V;xj7y#k_(P2eQ>nA&@;WM*u9dqm#w<0@tPdGhI$VEl!~@
z^y9XdZJSz;R|SdWgE(ZXWb<p*mc=uf)dk!@sBeM<oBs9pX6qEo%w`6}=$wNJxJV=o
zH8*%~>3Ot{Zn$3)REfHYrL5*0fNEfcu`+J6FgFqpAT8iIdEZYH0_418mxjn`U!%DE
z<r25<KKNsUr2LXq<AneiXnhj7j++UWnwbUfNmyC{Hb<{>OkGy>!tf~z%v7yGdPRH9
zI~QRsCErj|F`=bs(b;$fZ8aDgEU_$YJL8I<h$py2cbu2}U|UaJe(hmU`zZA#v@H2l
zt2wLIVgp-M^$j{v@~@I+6}eHm$0bT&5XEApH#W>I6+c9;i_X)BI^CcUFJB>btF9U#
zDCnCh9q^(3AWT>;Fq-X(Y6@5OHD>fVc~VuFCzAjx;kDfC`oJgx=qN{wE~gZ>#B>A_
z&Lyz7OhEu0FG0*PAV(7(M0GApm<i@qTT1v(yaYDVqmq4~z$16=c5)4fK>Q5sG{sBc
zGz&Bt+_r#EuLVR-CuS|VSMdJFv%mIlpk4IsXYc>=_N(yikKTX!_9f%=?-7+xd>I7g
zU)Upm#fLtA`}o`c?fr-0Z=h`W8wF(mogx1>Ud#XS_OJ5)-v{|8Gi%^1b)%!DSpnN7
z__AY5Xh!yg(HjSSb#^xIGu$f+#?XS69rhV_U@Ud6)H1v(NrY6BKt}!AQpXsow5ije
zx<(ePI=UOdc(JlxZbGPwBO;THy2-EG7*v6a1oUQcd1h5|2)-jJl7cZ907{}KkhTB}
zfl_EWoFK80OG0n83nZN*bxaqCyEOI$@)e1kMgfs+pjTstXt0PmU6E;{8b^EVFkqwN
zf*edEt&$;3joTVU`o-?SX~G0<QRh6&aTzydPu;U98XtgcK|b!b1>iWln~-C={~Ba5
z9<B2+pfb`VwT433TZ{_{e&b9P`vID;c9<gmP`jcO&*ovlH57;&1{|{O<qK*t`e+Z>
zq+C5mV$xL=kOHyVm|H5H(}%TvYVX(}B$7bXkR>qGTLu>F9k>XT(c8x?a#pB~8+t{#
z6Cc%|FMpH4-Q*KA^4fjGObueK1}A8<VTy|71u(uiH3SfnHGo#ikK(qes?BY?qU-`(
zJ;y8r&<K^G#m<945pHl>xVyDeT2+qEe4V7=(lMRqw6ZJ12u(g@l0|FPD{`zri++c!
zj{PJv2Crpnv140>_d*|Dr3ikSbTM39M$f+0H9j`v|0u6Xu5Lox9jaO^aX<ky01$id
z5E{Kj@=CL(ud_@i`Z|^F0)5%stXblttgh9m6cFy_S&Oop*_YJMreSzdtu@(E34hcE
zcDUK81ax4LXYa|wuS}}t>4e&pO<O+1ePs7NE#?X#AF__xd`<_+v|hXT`Bb$Bjvgmq
zlPYAuUv%}>9L%GEVOnV)1^f-SOniJR7i<m1!=!-7VPBwi9Or6-M-bg85~lm)YRGSr
zPs0@o>r^2{(a5UG3qD|w4UK9KTVE=Lz@sW;yX|-gZl{1UV9l;ksz+BzF{6DX?+{if
zw+A2&fCm0(BOw+tGDq+QbeAKA8RpQy$u)LU;GuBnP)LP+#uw=j1nyQV=MJIrd2@*#
zGXAm2!aRDnKsKpnqiY3xC$H)xIRk$1j0W4s1i?(j<5PEre7uEM*P@tkw^*eKTuty}
zcO1!H0M3!^l<M2ST;jGZmeGPTOT=Y%_3=4;#P())9jkc*9{eE~@AcESufqEezhgUf
zs=zI3OKQ^R_pqbYkY%9qZK8)N5o7oShzGZb+!fGh1}T8EYd%UUVDA<8Gr8~A6U#4=
z$*OMd_A6n|F)~+swDY=2u11_@h&L(B<(I~6H(G2kfs_cjN!10xVz1btqK{D`U8>Oo
zw{Q=^H!HL7)6vxoS77y+_)2;p|62e8m@F$mq2=PjZScaqQ%(0}%>u-mq~b&<K%XQ_
z0bvlZ9unXRNC5WdsN-ifC6H8gL0R!=RnT$qGn^pbORO%`xlgsk+*4|NC|RFVf$V85
zX~ahv+lfKubr1FIxJtAlK>>*{-y$}C-eo0e{btz&KE&;6p?g-kpX3}sq*{v|Cvs_C
zk%{1n=HlFL?~f!~$O*wbLJ+NWfr<bMnX)bVxSmY{C*&&IomNd_*+FF5o|B#ZR16we
z(h&+Yj{tk5ZWoobwsd6c)TxslfT*>Mu~B6aY;Jlx$tB7=tkXmD*#HKgq_Ui;4$!IX
zx-4Enn=WI0+A%CUWubGD0E0hRz8-=W!$HRwA^#nYkkX?kQUf+;iib)bOk`8^BOFRm
z^c(!WZ$j0P+EM$o9=r~@J0ZmXi9Jvm0H$+*Q3q8COT@YnBD8K%3F!z*KS>6ckD|86
zsCWT^AV9m!NjeLe6GMrsBsHXDnz_w!zlXcj<C13`_&fM2!^m@{P!s~>_~04f61!?+
z0Jz?cpv#znM+@P>*(*P!F$jZ)3R+HOAZmkrXDwP)-qfcgXFObCR6)uyzY?tnoeD{g
z1JwyP<7;vaLIjfvU|c)OmS53VTD|<98ZEd@6-zUd!_fSKsUYdNxU&}|h2&FTltq`n
zTxMFu!GbdHGN!3=(OcKD$ZSiS4~Nz*#ero8RJ&7`1k;qJ$F!24@-6dv035QFB)0z=
z*(h&JME3CsuY>1N*H;~|Ar<@*W+MVsH@OTYW<>e4(LRWpQ`NHr5EGCg^kA<brRgjh
zNM?X9m01-4=TnsG@UV<J9r6>U!7yFWK@ID8&8HnKu%Td)SDL|yplG2-Y>5GCuR^Im
z;3e5lB()IR$k&wLR>~LXWAJL13Wl+0zrZ0440^YsKv!*?K)8_mJIW`~7qQ<Kg&`bE
zE<y!dZd!BzD%?-Crvq7vo5~e`^f3SS>H9b2O#Y$BdK1|~^4ouU`$c&B4ZeN}rHNPQ
z;pQm*8peCJm;}(#ByRTJ$hyy4C@+lBfce`k`OL!3?%xE6Iojs9)a`X(yq0BmVZOg9
z%1qJI14H6Nb^J+AlCaUX*7KgA3N;=|{#OFzvf9H5MX_ox`8w~QJl0FGRvDED%Co6U
z#FmzbS<fF>7Dj?4b2Jvy1Y0x-a8e`^t5$+PpTu_kC;)zPHDQndUtV5#QsJh4ME6cu
zMyJR^&L1iSk~ejvFT7yMs{zl^KS=O-fWTIw)h4WEIDrF#YLu)fpCF-j>()i3aotEV
zN)(>xEgkxUnW46f#oU(2NFEq*QR)HwBI-cM_e|Z$9zyFLao%^g!1Pgw*J2uRZN^ip
zU3R|a8QJNcx`U`O)d#?Hg34=f1djS@mLu*j6JVHKTy~tGlIe>0Cd$yT4dea!8q{q@
z)HxV{7?R2WyuyYF)Z9VslArR@(RP>Be=1xt&NnFs#L0gKLBguc9*Y-ipLWzxOsp`h
zU&3RQv}vQ&5)gqFa?^_Wqw6kUsG_bd7JucM0~s`5x5EKI_IcOz*Etn;#vYhZH+zzN
zV&QjHd5%cv-v&2_LMNpi+^5^5KpIzbM2xkZ0BA-7_RS!Bx$M_n34)Y#M9XN)TK-gI
zj-jo|RFEr>I2F1<^(r61B|xe@Ik;TFII%`W4Lv2*Z3tJJEuc4nc0q8Bup3)<vNNgC
zj=X-?jWPtlO<sa^Y@2-=#ub2nHYlK?q-|VxRzf9a;X{r|A8BxNz(ppb0BF6WDT)2A
z@XW9Bx)D%>zQr-=xyltM>$A=15K<dKns;3m)q{kN>XnjZ5PL{IvAuK%@?dJF_0T5=
zC|IJui(i32a@W?wBtI<CvvRPYRfV;>I$Kzmedm#&v5>0NL(Jh6*Cl&c4clEq>9m)m
z;uSUeTDrU%RMkl)06ZA-0jTm3J?k;+GC&8f(HoSBz^s-R2)1nHKm!31txBPE%cJ4Y
z?ND{BBxM(58X3Ryj2p{79gm^XOWF(Im<-2v(r)AxLa0EqHdAO(z@ZdSKEI#gxkWVM
zhyWd^-d~QZTa=XJp!}!Osdy$XojUiJgp;}REU%l~DHh{Oc!<dENMb@Q37W-mc(GW)
zzCMnULEc5rjsVQUs<8m!LQ(~y0z!-hl$j1WtwWmn4(%4G%2<{j!N&!6cVsY;bq-r7
z`BKBRdbk$f3*Z0#f6a-4nNHGy`s?$fUs7c2C&#0|egAdf!SU!X-u{(e0}qa8zkD}|
z>M!3v%a48xp{(EJ<9~!~mk$#D;q5D&{YwGkFdMsLevrbRiXE#?!jRp>FY0%thfi6g
z+H9cHQQP%-7Ej_7#G;GGL-uu(!Bh>khbJ9*)F7#LgTR>|3RP8Lu%z0lK=@RZloul<
zVb*QALsxGdgR?pt%zqXMo5)k*swjGL8`2>;yvC10yF2+(y#p3-qwIlnh`oV39biHz
z*#-phVM-nF6XY!@jCZ!e8X{8bS|B4oj1=UCm%x9ae1f6bnNVyH-apucHg33bbl(C<
zl)7Tx>an|EB9R7;1{6zx4Z5-%;Q>ND$&ZR3T-*eF8mHXmef4s^Jq>iGi_<q`i*q{P
z6d%rLRxV`af*o3)*Q0AUbuG6Lp#G#pJk#RG+RM!WgG?8a+*m0O5a7+ID$5{z4^)4K
zi#k76V-Mio;qj=mPEas0ys_EMpjJ8d2P#Euo1O#Ilk<K(99d8gq3xat2E>k9LIkDa
zqB=D2e(`!mZ~CBJV*dn%&l|`+z}f?58+`zZufQN@o2+-l_bN-kpklIXR|*xguH=2h
zw7a3IbD#_qfPMGk)<Q<VmEivR8W^i?=?OfR)OqywNloaicY0GtR4c|1@zrBEhuCLe
zupM`|*lN5%O0DJ=jAI`vsMN|~uZX~~c*fqKUrpq{VhJrmqh?t-+W~*$0+tAA06@mt
zH=cd(t}tV?>JVZ4!9}C!zCa&`BuU3LPo}Pz#$L25nH<<RliaO;Q`H`91}~9!KHmcu
zl!zQ;CiS#Mgr6d(1yUKZ`;WFY3#)pLSJ{=&=vLcE!2d>n26>{+1kmHAyrpaS)$Uay
z`M<X2?WCeIObxR6t7i~PxXpf2%eLi=m-=w?0{tL@OhGw@J^_RQU&W4TlBD6=P+)qA
zY<VgwFsKL#1X*>W6*Z*q=1t*MoGT2NZY(}#s75ez=}%T2kz0P}l|F|ME42DZb?=d3
zT|2HFpavJ-*rhVtEY=Ucb(C${wc1FW8iE89D$+&0B^+v6!r%4D{y_PNP-~nd^T))X
z1kuUr3q?`Fk7AkBt&WV=h#h><jNqVI0@pxFC$fTpx?|>M#GF7=fMnMq)|<{?4)^Is
zOEdd5Rn@gU21#^XEWv{6itqm*eE%>0og6{Zf;>YwMgRAYNpJj^@%=a9{kO$_7{t81
zoD5B&ti;4i*3+g76l;k-QZR&Wm*No#n^a*XSy3<A+c!Hx0FdO`(;EyZI}GMQd6I`E
z1;E6!N{*$WZbF&Glh_AeBa{T~Fq<-;I0x~r$WRwjXkFcR1*tFx$-Tp_#KFHd9aPYs
zZ3U=uwF7hwRDkxt&ef;RKrl^5JD*irFL`ewh7ZJ$&u#E|lg+rg6JH0`pqkY;WdG?9
zK-SW$ox@Ime8TGPemL`px+(MpE)%xxo!PZsw>kBDPk^3mHH-HVVhtyNh$aC=7Bxdj
z;Q*^n%Z`=jnvYOn8W)A~9SH-ZFLx*@WOK%7u<mKL{Rd_c*jdV^-3eqxLl>Ytxwjj+
zmF(}g3bL@4eo~rAm7rt|-%;lsAo9_Ky5v4M!H^c0SI=M(P5n#xM7Ay0xoYj4kESpe
znLT=m#@1G9%IJwnSYDHhat*gYp#*Ra7b-&rYm4>S80si<ds#n?i4FI%82xic0)Zi*
zWTbKtcMPx+eE05`t-Dy!3*;Y!8PHZ3T;~Kmh6BFe$78^b<0x0OKq6`PYqvdMUu4I@
zg(0<qa(=)H+C!(kPY<oo`FMrV6ZIeDkiCR?yem2@pJ^XU^PO%bHBrqLEE7>_p~a3h
zkQfFKx2L5jQlXhS)RwLox+-2m@>TAPx0o5foDHa^N>FtcavRe@bCeI5l)?>nNt&J4
zI73zj?aiaQ)b+Y`2M};RfPiw5S^)Lx@Z6ba48i(6ux6HA-A*vu)`$S)m#a`+;BV6w
zkfWn+1f-o_c;^Dz02HF75m@WEyUc|mQxc$i%bEc71*5R69;74zLO6Pp)X=la_L_84
zPJN)rQYhy(T{u99pwnspKxzsr>9ui3B?1^sklX>7631*h?wPOvI08T>#~lTje`Hv8
zGAPFkPE#?}uAoq<%Vej>I~W?v2Md3?<iT18#XjQEJ>sKWbLWB{&0m)7T~u>>wJo<$
zFO~ZQlpX-t43~h0U1f`kDnr?Fd>@`Ok0eIHIRUnN4(nH6WLieuTGau~C#}-mo)WVc
z#i`jZtizbRdWWAnW3#!neGr)cEI=R6{ye<@2;xeL>HGZsEBZ=&_WntD`z-?XH^BSr
zm;7&j{vY3e1dv})BjbN~`&F^4Bu%a$WusY^Fm85+0XT4qbcEa`vy^<=6o+2Aa|nKc
z3$GLst2M1K1IrN~d~1AG&ynT5ly7&RXgyR4YbaF00=8cH$1wTd!S!CKsx%^TzzA?M
zO!qn?;6px)Lp)Ve+9V0UL=I+?oa&=?KV%D_x|TBqmy1-7b(bZG62N;Z$1J;-Ja8*k
zdT%N;*JsOVS<#ns5WpHA8Uv{}fP{3FCA-i_0;U;q6LQ|XbfAhu8PZaQdl>K!auxNI
z>R@OoG0%D+@{r1}%{lb|U|D&Ck{#k}nJ5vv=rng$bfHdBn3JeMIws(Bn2Kd=R93_7
z9q~SAyVA?y5IXPpxVn?pHDskJPXPiUg{mO+9dqYkA_iL3@;><0GxFq~V^_II*bqC<
zJ|tA_OiZA0qhI2|W`>Vrcx{ZF018AFhm4LZXn+`G9s-)W?J+R8#ENvNE}Sudw(LiU
zVOc1gWK+7xzx^c)rR5Ma;9-+VpQwzagjG&G)IpNm$1Y0vUbAiTLOTsez06D>n5vH9
zvK515Lz3PtV5sHPVU$XZFv|AZzkmB-7-?H50eU@#&I3en<wL3pXzSd^qL*}f1wqo1
z1xbzvRbpzOWpz1GC-I;pukxLXLuUF|U3W+%=`_N%NV-k_s#p14YJ&F=0IcVDK@v8L
z=UAH~LcH1&S&YwmMZCS*hjJ2VkA+zPKEEQr9^WR=TV7uY%kMGmPuG^Sdyul&Mwq5u
z|ACf~H6CP7ziebUH<+SG`5`w=6S(67eJ_y}8ye~6aCE%7{G){Uaz}Ij3Fq5<YG>$X
zA66L<l~p0gimH=x;-<&f(&n+SD+ebH#Z$8F1*RG0c-Uq@?1MN0h*KgDZHW(9R!NHT
zlDx<-xw>f(#4uc{BcZ{HR=Q11z!$venBS%kGYp?M)p{&Tri!q_*#Mc6JCo@l;7*iR
zNbqa8#Ee_X=>i5c%u-;+M0;U4;t|XV_TlXK1Q-WP=7YSW8;L|j*Si5~5MU<n993$v
zBGq37H<NLV%q12WI6f%Y7?piZ(WU5poD!{=<wzcY8$t7xsz%T-TZ7sy5IkOvWr+@O
zPA9Ied<EG8C@U!PA5Kik^`0>_8zaAM<~R?B(QXs)496iy*Z4&0Q-HfmH;uUm2*E7N
z<Ak0y(-2AZ$r}V&6SQW922$k_Iprf|C1zW)fBn~g9lj_3<r6*3$A9&g;jjL(_yPV4
zeC$7e=fCjX2PjK$_*osf$S=a#ljDbPztFEga?HX{-hKxM%%4fJ@;M**wTeQ1fLY9g
zir;^iZ|FXlzvf^9smnh?`~Xaae|-PKa+%-eBxRFI%37{FW>XfGcg&Z(Wnlyb08OAx
z;Uk-@wsaqkLgxw4J+J9AJe%U7a{Ku&z?8=*ge!o;#kMqEsNHXLTkL*^a@L^ck?}C!
zO4v6s+j92yI=1MFrz2T`Octb|mr9b97bn}Tx(=9eJPG9mWkD@Hh(|=Dv!{^K1x!Wi
z2f*OMxDe|#jq?@z?#OaZ{W0U9v*tuk3?*C5hb0C~@OUzT3NkW-nSw3jMV+Ml^>pCr
zH(6mJw@FS`(eu$y2Af}XCY1`p^h@#=HB1~@0wW&C80}at2pyjwj=+6<0p*ZM#KYj7
z5@n^@#%!`W)G1YTACqJ`Qk3O^ppdtR<b+KS02w7qZ2JOlo3|kt7#$p2*s9PuNoCEN
z?9c5Rd`?WRGj-7b*TTl+9tD%C-r9^~2J8zM3ifT#&$Tv2FBxq^p_>1vv~TH^=DMz%
z_pdlK0$4H(d9DDFe@GIeUR_mPk5jBi_pKfTaFk&N$;?0|kx7cCNRd?ZpiNOSaC!B=
zve!O)?W*rHgbboM->s^9c^}<X=d8W=dN_FkWRRLp3s=;$wrawrn%aA1I-YFBl}jOu
zOa1U%3jwyPaimm8Z<lkv!HE}H3E(K2;9QDjO`gv!lg`1bklzX+nJ|d!Q<4Q(+0JH6
zoh&;OOwgbu(HPc9#z_d!xe^`qf{q?b(rds$Neb)&RKF6v2zeKu>^8s<x#+ah08hnq
zwPJzNX*qsZibOOD1Yqo?eT3d7wel<59n_BM1Qh2TU52$?br6+w@%9CkDFozafe(=W
z{`QJ44lPbnALzEhYbW#GgS;S_n^X65+~tOj5BD^HJhq@`!K7*RutWl-(#@5??iu(U
z>r?1@J#a&+`*>iuy3z5t9qXV2PBnxxQtohESIe`ee^Eu>$DUGB$hg61Tp?_N`h)z3
zeIydR%2wWlI@0z4mKf&n2!XUs<KUo?{OD~Hhha5k!H{AgDu^DCi*Je5jJ18PF33ML
zQ6eTL+OD!w<lB_cQ!;<E6@aD`V~`;&^Fp&i)2FK?+oWjkIY1GJvaa4j0=+U)SCs<E
zffkAwxk6x?h;JYVN?O6>V#?Y}ky7RCi&D}62@?^?4~hyjP_Sb^C6jV_%J{1lkdM3f
zl5#4_V_is5o|#)46hKZ?Q@}pJ?&v&?;pyLaN?^|8%P|#!z^{%@pFk>;Ko96DRA7PH
zA-dp#O^yVbjxJ<=nqng8bA>0;CObzQ<T(Iw{h(BCA?8Y~+{f5k{SGe$StvOw0VDJw
zWkuo_*+qF7@$Vp52tyd+A}nU*MOQpdNwAf&o0l~{>&)uDdK{Kq>Il^v^Es2P5v?29
zyfh~iLKq`=<_pNPWRHBnaY<ri8*KS1{4kvgB>MWI)=Zx#ho(;i%!JpEFW9hcy7>ZS
zfzN>-3nou9cc@1U`%`1X+_Lb|vbFKZdhAAZOW;xj$`2o5Sd9o#g5OHw6yyjaEuOTF
z)nn)iD8}4sHCl*uwH|^B0F%LjQ`ZQ19j^=k1EcaVTWVp{eDZv3Di2v*W$l6<zAqo_
zqwI)GC}Y7Gtp{Q<AtpEaguX#+VyxObn5yg58K4#RdIB8ubc}w6mDK}dmMI=fP9l0r
z&0%^@Qa3Tszo1#FYQ;f`n`35fj!-npYck9onVcD9MI}6%Fx`YFlWgR6`=b}+(~%i$
z{tL(sM;aT-rPMV;FJ<Xm?b(FP{IUQz^20Sj$I!M_V9_cdYl~NPs$O8db>e)>uZlvt
zDxmQkaZ7-D0SDx^P=6*=|D4W7w<(L7LTsR72%IlRc$ux3XS$Rb-b?b!hFn%|0Ri-C
zlp9y+5_PohqWUnAl7V36YC2?~){D?$xNzPs6rK}?=$N}Lg<o^h?oeUSrov4F4&6B^
zyO@&+gxzt2;7ufaM(61DvDnba9%+HqS1EhS%o(#yJv1rwOcH*93IdyGEG>91{e3qn
znUyhr+sL2j!p-;*;7nrCw#@RI4n2`3W2Y+S45sEx*U+XnpMq?-X+U)=+ut=B(2%FX
zu)zkLK3V6riT6PNg6m62H|ue)g1iI@OXow3)zjMmdKa`s9wjodL1*@skYLF`SEM$j
z9}y(rrjdUD7cg^adjSXGmQ4Z-rt(TGpqAU0>rJIK8n&5cgw|3R+8Is8Fy@TSmKVCj
z#+3W0w8UUxLq^BZxG&X2WS~AWp3I*kTzzuS_Z*MNIwd|FLg-?f2k5)x#-Mm{#!P|b
zL~<%UNNG3^C>zvp@m*synBWG@5jcdBrGHKq9{j8Bg6R^H2NAt&t2W%XX71#$(*~iZ
zTA1UgB1lYuv%;w{1=<0pIIZOOn|9t!r{>mo&SwB3O|Q9E*xLp7a!9gOJ}ib_RI0?o
z=Lq}<tc)4cMlsAKA0n|L1q-phK=KvbSC1ep6^bG|RrYL1+3@9Q_k`aYc6$`9>B=mB
z2lv()obAtSgI9%x0|H<GQwr&9apQcYuU>$G1?JdfC52ddxE0=1W@F@mF!-;--`U5%
zOw@=UgdhEF+Ot1H5U3?xz-;li$#e0yyz-B4zYBkvPX2o!P2#7opI}v@r^9o@%fTWG
z4hr&nrd#W&PL-7(3oc6CpnVDlc^-p*6LfGUs-n%Qt!dlwP#6LR#;E(5`DaOGNJxr3
z59|y8h29-tA7M)08L6a)YUQqQI3nyq_6)m!<vvAu*(D}MJ1qcecW&n(X;bGRi_<d^
zCBvM28ZeVVmZuu7pShFR*=Xvw%6BtV5k6!`12qBiT%0zExCgc%;+c20Bx&a0(~9N8
zKs%&LH$QJgpl{Dc{UU{>73oUJ35z>{E`8NbQa&2MfZ~9?2lZ%3k>c`8u!$ki^rB&)
z=^Us*a4<1G!an=phK`N8sgKS)UosuMXN*Wi4Z{BGVuT_Fnr1gG^6gt?QaZItMe6x^
zjcgR~@o2zVXNv<xrYkSz3e9&Li_R5hY><>Wbg+hq|Hn`Te7GqSlvf0=SairmJ%-v*
zor&>P&vYYy2-blaMLxnx-bY+fWWytH=aoDWDLt+WTuZI6*-lYHpr&n12&<Y>F6cWJ
zz9|iUc~E6Bp%=ip@{~4FI}UV!o#bVfeV?>cc+9i|$2<KH;jcD@t4(T9G%71OoeFd*
zE)kTjaf5>wCpXAMca%A5nFpEfq0$|d2v7g0w$o`4!IRujkE{;+bgTi|n;DPXtFb{i
zz3P(~5jg_>*4ca+PezHu-f3L+80N!K5-f`aD>Y))D{Z2?cu4+W78mMaUA8mntYGFP
z;d44K1V%a(14BzgKb~}ws-bdyZl|>mfC2!`E1G_jpU`bp(e!T5(RmaI?*&!v3AAJq
zh(?tj3Zh>95={G=p*T#3YG}fgm<~+T)|49E6f9Sw)0=9<$I3Ls9h|?7&e5TUzs0eA
zH*~yxY9(?wSe{n_>_5h{ZT754WVUpweV<b-WTQEEm~NHux+Eq_p93I-;fdg~<IaL=
zWzgYNrIBKIoPAkC^M++d$|hCWLFsN9$D#)Zjos5aP<5irG~?@Qc%iAST2$^Y_?V)9
zs+URL_15hwt1Ub@HmU<%_DhtU2mPj$jS9C86G>&6^pOuT9nc4O#KF!$*5CjsK$QY3
z8$B(MOI=dRQfY%lHk*7yn`C919-T;5as}pk4<w{<N~EEyD;%CmMs0zRX04D4HV7;@
z^U7?iT{G%Qe0c_)$f9OemDNm;qhe|%fZRJ1DZz7vhqPu+dAR2YaeW3=xY<METM@M&
zE`a8cAe9+90s;B?<Vg>-yK<$=)GiCOl1TkKEhAD_;<MK;?c+({0h<W>7~a1?k;iW-
z^7!rX-+e_v$XBKi`HI4jU%q|x`o;I3zkU4nEslfvMt%SJ>n8#7kDtAM8(x3*P8%e3
zOZKhz*1-c-LUCu;qraZ|9cUmJxIr>-dVG~;g87Qdj`Xvs-?0eL5zu41Hk!8)Rkg9G
zA$5`!5SG&F{cbQMMU%%XoFrKpri2S)jyO$yRSr;V$)szzRp?S!UW^>|7|CdIP(EuW
zX8Ht_Z14Ft%2A(Il4Dwep)8vl9Xj#I5pU6s8E)<*v%qJAed0xS9Zpm#41=1B#(cp7
zm%!k`H2`E9S$$^3_cWhEF~y_^O{o~`X5R=1vT}!Z{ak^~X}QD>j_Afy%G#vxP@o<H
zz%>JklM?hlNZ}mYHMm3VR9U;1jLptfVVHi{JOfYnOeBnnkSz&g6AH6y5HKrvVzp+G
zXKrF_3lf)IMSw*5V`Y(EElX4G1XOD7K?ZZsw$?hv`tQi6>O#D;R|B54VC!s1V-02o
za%03FUOKe`F?@T}gHB`U(`K~~QxmaX4>YHOjZ8X3p0gdbVDe_GdhthCEQXPW4*3iz
z_Y&MZ7eoiTUIAuTDZX>%Mp<t5vpRXBCUbd+9%$Oho2=N~os~O<vKX!P+$u9f%L$5W
z_qNQaFU26?77^o(1|EAJa9@<o6eDy&^$f<+iTcWukqYlyc9Y7)!m`kafVEX1E^9S>
zsB%Up9vfNNFXutOW=@TDXMx}?qK$w(j3}}#7zkbSQ+HB_EVPua;dgHYl4?}9r}ZG5
zHq}jDJ{#7^8$7L)nih1dY9JY@RdCHZyT-hYM2%YISbape7QW;Z1q!MU9|5`XYKw<3
zn#cw#V|f86C>^bJe1&E-?Zi-<#EqnnaV=4^+Zl+){Y9q;%XF#Ac1&7|^-|9AUX<*$
zWTqZ4#zsU?q&+M!aeeVgiVtFx!>GZ4ejWsbv~mD?wTe#{4la6lZpwS5iQb{3KNE6S
zNHHulEwnm~S~49v%kSY?3pu>Y-1TXjkwAE8KVQ_2e?0L-1!6II6K#B(TX-V4JQYv1
zi$*WX%RsngVYhCS=V3@Jdxj=cV+e*{gUJlyhDAy17Qa+8L#f8KiDOE#ED2@dc2VG|
zCu1i&h{~D3^qEXkx&PABcRYMZkx^auOgGrf^KUa~E?^F=H9v<MI@F#ofBo0tZ}ftu
zT7C5T^S?bd_OD-m$B*It3#YFNXEN$nZ}zocA*TYw4-irRF}!`QJ(KYE$Mm)T@cM;X
zOkQ?29Ud>T52{5ZZpWk_afSS&LVv*wL{HAZ50q#xp6;z)r$ywXV~x}0F167?j#GwN
zdIh#g-Vjf%*--dLDT>%W-egV3Kk1i~TNeTH^tf2SaiRm|eE15jur`o#6g)%fQRb-0
zWGN*JJ(G0UWT_i+WtRg4?ZIV`tEnTdNNXZ_HG^+lB$*WRP;1LcsUD6<&y-!q4QW9)
zd1}4xlG_(JnM@Ew+p=RJFQ$@2GPq7uI<Cq4BT8k#EboYJS<t(*qpQYP93)yn@v`5d
zk9t@s&k;V(h=eib1SBeKIIz>Fx3m#uX2#`y2t_LYZiq@)yiV#v58zO4oM28+jBgkD
z1+)cx-DoY5{uk_Hy4bi;LCj%}@6s!zd2?Nfc+!m(v4ty%cS$J<CeP4%cohZ+I>jhh
z7|Wsr$^lrIW#&p5K^Dr~ony}V#+=9#;6wmDphQ6G6jh+1-rD3FAq!=XWCVG;4o0@r
z|I<}onwqH~vd!mVdGKZHG$!RyfpxiOvi3dP?_tfL$gwTuw%xG?na1T7cTAX|yN}*V
zgW%%P?W=9&&|BCemxdR%^8j)8)^CP<8QZqtXuIEA-P%5~FCA|%V47|3m+#L$f3pb|
znl<#dCM5(M?#hGz8mqa{!N8Ppg-c=2cLcGn>T=g}H<Jf1rCd}z4Q+R+_plAdk*U>7
zuH*9r>1f@@O*UsKc9C)k>iLJ(r>w*MVSDkYVLFh8Li(02BJ*V^hHaj$jx-1Lm3iGS
z!C7GFwPT;ic&5gBR=`!Ky-iC*fxWd;H_-;oI2n-YK%Ves%jEx@#mS^>&9ANwMw41p
zJ9i87zij8Hav0HEut3msVh{3mK$r>veMNKtp-b=Knh}w`YW}==P*tlHSvsy{A6!$w
z6_g<b`v9O+jjBn-Z*&M#5~<>#OQrZ98-m1C2^F$vT(6{3RLO@jTatj1bO;bC=<VFK
zI_s)y#!_t<tF;u4LPfH<)2C``U^Ih?0kbWm_DQ1C<a5o=;HN8$#bu=wl+bAcW7>5$
zSwBfy0&jP)%6?WxP&$UPW^~C>)=!XQSN)nzq%z38;2zPkS#}Gz{Bp}*ltg>4XbjQI
z%b_sOzNXN=ui8+nNVEnaG`UEB@WBV+ua2$!TdCOL;_&w6**p3@YNmbsBRQMjy)PX7
z4FSQoZzs_3tGD0i)z?qnKJ}}wACuqd`j-Fw`p<v*sU}6xb9y^+iFV{dAd~m9g8_R{
zS&16f+dLy#g;*Ow-aeoMms)6>pkx>(bWy94Vj9~gw*}Kt08S`SR)FIWXKyKNh&<-R
zMZhk`@)<>|f<!g0BlIAmrHj>7J;pRg0-S=YhYhaiwold5utjqcRIYI+KYLXV%9(sn
zStIc#YRuo79JYpR#z-HBu#i}<u0dRtEZGoQ3`knx*bbJLnLB4aS|6G&58NRQ&88sS
zj<noTiQ;AkSr|VmAyn|>vglNnu*B^&<uBe<9DD*}%K-BQ{$zQAZ%%Swl$3yGaXOVv
zan3jjQS@YO6?ryN&W$XcJGRht0&OR~FhKt%<)Wfvh-?C!TgV$}<4pLidfvF2VS(xy
zxCF!F$JgK)q=so9f=6M_Qql3xMM#Blxu=;ZZE6oT{sbfCX+e{NKTxR{P(_b<!InoJ
z;=^DM*61{HKwhG8G&W_g`(hCViCxryf+b-hf!dB7i$eY=5a=)qKXOH59_%NgjX8K|
z7QT5pgvSk-%*yd(S{lqQC-lk+GT8?>T61==L3NVxxTJm8usY8TSVsp-i@z?ol<WrO
z_daEhx6a6f3)iYjSGf)J3dVUgC93hxp&B0OL&pLO=4>HYf<2fW!nvqF%vHd{20&J+
zO6zpW4zex;(eS12uqN~Q@8JHWN4M=Je>Z)y;!;fw$_B!t4Y=Qq*HbGfkwE;<^_cJD
zLfr%?QteD0p&=Z2XcT}nkw2R(HL$y0+tnxc0))b0(><%5XM0FxM&|D}nka#oU$B>#
zocvKVC}u-7(7Y%weuc&bBYiM?PC?*;lj!UXg^4QU-ak*Ll^{8zj^;-Yxh5h&9~-8t
zjw+sr6_;D~NfIf{uW7x3$Eu81%rQ2Y8@DrAV{k+%;O9zraCFHx>SlV%Y%5u)YNWW%
zf}LQuHYA}InOfDj4GKx@%MlqEqIT-jg+>ZiXx{`G^$+9+)!C8!VQJ$kD0X!LD9nAv
zwuvB1D9}e{VW48;_`S?p6$4pMWC5w)eMh9$1rU=zO7K4+QJ+|*xZ-j=fT}$CNo)8w
zxEk3)eazNl9?r(fyhboXWUGs`BGw8Z+|_K?zpO&ux!ZGtHQHWs->+c9saDw54$F}y
z?lQyt;6vx&>>m5F#(d>&*C8)!WL~%?CEC-iUf%n=Sx|D#A{%p^U_&`<r(=z27^XI4
zYe`YpCK80&b)dr<2e^JNlnW#C+fbB74HPaT#eAt#!45|=F7lDx7!GPjEGsBE!Q9H^
zxUcc#I!C3~iK{zxKr_%Bq2sUu-s~{k?Q1ahTMhlmzCMKwoEmvKUncu0$qmG!A0Z?H
z%NCwNv-^KwTq1wE+kNQAKm9bke?h<AklJVbNa$vMUSGa_=@DX|y#67)ewHG>KGBhm
zIg4pP2r!qO=~!-_Sf1_(^wlFBR|^=X%NJC=yS0c^rHPtqma;HiYLRWld64D+E6i}9
zt|_MM0)hbH*h*uONVs`~JZDJyr~yf!y~uA^Ru-F1mCv|A;4|b9^e|C)QxR?M@h|H=
z(At^K&H@kx;zf8XGR{Qq1H*icvJv_O<8(%UsD7l7Y9~!Z@=F;LN)cFJ8F7Z1Wt^Z#
zDgVboCo)T!Q?6NeI&}h!IE2aqRSWV<K!h!jrL+ucYcKc<JvsIw1av*dWWPHcm%2bI
z@uI{xEt)QiJZ`cGt-ic0s;Ot=C~F1yTDbWdrZ$<6HwY?+QrI69L20rO?4D9yX(TB6
zMpC<DgfvA{mrUSaz=86X<pP>Ic}pmq2?tIZ^(FT)eJt)_n@aC+#QeG~#gQ+7q@wZ?
zF)=aVDNn6UWI)MNE9-QY8z>o3_vyIEPQ%U6mRuBg9x}PD+~TW8i4DpZr%IJqIfK9<
z$B07#A7YM=YRg%tZidr$IWiV8Mw(-+8Jq$exp^`|YgL~!9DDqDOoFJX@8J9NNPjJU
zUk_PSl?=^9!H=l~^^_U8+=$!)zk*YJoMS9_<-O95MUUpc^L?b0Va&KMzD*p^ARp`m
z8eePZVCHEs#-axZaCUHv4}C$B{$f{!TV*!y2-?!DV77Te)TD4yG6dGta-TPB0c%DH
z5Q_jCW&qYbhU+Kupt=vmC5h(xuoc87F|H@k$+buRuH&O?0l_A3wre&X)^I9wK}e3@
zd)13PjdOkigHZYS)LAN;KJ0@Ahl9JlR4;No!zW-RK$Ly5EYY<Q+~9T}^G>E^2?Gz$
z>AK72QTtcP^Jyky)zhi9)e=1|T>CbHHb4{gX(L)Rw&fKFux0ll`G?xlt$iBWwIw@n
zI*Nef37=u4UrEW*uxlfm;{hO`A9RmH%Mm{$M<5c;EjrLZQiMUd5{c*snYUf?YO?>N
zt&_$Q^mWbenX?<YAlaQ<@?1k2(nc!fa>v$=V1%6Gnhm}NQaoIt49ooa%T)BRkm0((
zC1lhPaw)Ft`^<Beqxoz%ISK<QE(j0?SeCHe)2XKq0>x_C*5ICSVjrt*H;>A=UDRY=
zQI3HC^fe7J<k)BI`TX$@!;gOC`~IoP^WFQx+&`Yb>XUF99sT<4OMVRRU*JaqhOffg
zmvA=!G`xLw*>|f|cd4H*kJ(#x1`CwaLH<XkS?WMHu>Px#O!0f4u^Dr(;IoifdAKc5
zOql9)gKkXzYx|G38Qk2#hVa{@oIO4WKvXt2s;;Sz1Ik@Zw(2H(COnZlrkc;P0YiSY
z(+^gzM6Dosn%xmLUXvY;4iX-GR_++@9M;d6EO|Ev_Kj$FuP43H8e14+by7_a2)JxG
zky5*~1-L=>4&nx|0aQjjDsc&c3YibF1l{)E|F_p)!T)4E(hinKdtLQj^nsAd+Lo!p
zvri5SjEF|LLTwIQhCtq4ox#0~^1@&{xqvbMAb?nDA(8CAJd}N@w6zWIAp<KVi4Kcq
z4)w$>sktPmVyJic@h`6X9YVdggXzX(<=Yl>k&@#cvYdrhi8ID@02Z>MXQOYAbD53d
zJb9ep6)QKKGFz_lFrC{KI$a61hoh=S=#i4rWnI6hZCV*+0bH3?qPI30I>UC+cDiu@
zM%hT}mXYp8CKXt58DU7R`Gqz?8mmWoNRCL9VGg&rH28SE3<>im8jhii71<*YG#YN0
z5uIf$eqQQQAkez%i5-(OIe=#Zb%Z;Jgwe?|DyMyD2Aj`Ype$Pi8~Kj}{~TsB&0&=)
zB}-31`w$*i2z40q*~{x;OQrrb%V9Yv&pA7f3O}TXn6lpdW>5`}N~xB2aQB-Fv{_qm
z<o61tH3zgIM2xesf!Dz~#6S=b+!&QB+V5xpHE<-mV|0B>o#c7-=FX0CfG44%)<+(1
za7(VXRJ98_`+{21Sv(z&aHwMQXBBV^BgMlmr0vXNUFz6WDyijpF8}O^Y?IqWKuqCO
zQ^hj)Tf84MLyzJCrX!@0Qw19gYh4LgdYGyRf$11wp~3~JW!>D)AD)@X4mh3ajK_mi
zFsxl8gvRR11=NITyy3*FtS&&Ag0J9d5{kBf3K(~SwOw9dwLIYEuE6$|Z(`G}G8kv0
zd{_}F@1uVAlhto2_&aln0=oHib8t)1-ox4jKB}ws%j^-xr+cia7b+gipo)D%NC{FV
z+=8+c-u!e`KbpHmEE;Xdz{82L4?sY&=d{dF0T}T$MD8Fb2p^#-Ve_6LC^49N10szA
zZ*8Q;=4!qm3D0xTb&Yc|FJ#2>ZI$7FcSdUihbBz4*Z`R^DWoe}4I>7_4j*cB(#^{u
z{3l)+oCYqh1L>^pYVmjWzrX{%`hgCbU;~n9s=rh<4NORXf5eLa+fRM`{$T2#-@c(K
z$sf*O<ZFH;82S46?AHib(eHDnzP$Yt^}E*O_#%MNqQ7ODikY+8Cr8ejd@6nIKfe9*
z>$i+%MGNHjX@q4x66L-m=aNq$5c-|nv`-+8%S#e;!QY1@7Yk+EQ~WtdQVeN<_RQEW
zSzuxihFJkbSloUCS{6N$TF}zmFW`O8Sx1nAtV`89dmXinML4Y0?NXLl@7C?ekMXyf
znIXUO#7bM+X~IgY0t^EjNeqIl2Y0$t@@%usvT}k=8Ag*Xm<}i_y2FieRZrqY9_ES{
zq-Zo^J~9v2BeY>zkyfR~YzU9BYv&laWrEGS!4r@xpRWJWWx>g`bVtURDVJ|33p=^G
z)j5Gmb6lkW<@5^KriW1)S{~qGXqF2+*ucVt<3)l#=prH>aZcP4>u{)=iP?cLrlBiQ
zx`3(46Jvc1-?3|Bgi4^Z`gX4JRE6dT%$VaC5wdqospPAzK`Y=B>yvw+C`eh76FIK{
zeE@laWV1|A2DdEh<xW!Kv}b<e*4kysi`Pr+a6*ICn=BZDOVY_vG=lv5<m?H;(!&va
ztZGyO?FHGZm2zr&4l{-gx+CysR@vO^gJ6ToE4;`HI}GacmoB5Z7HmS*YKAliPv9%q
zA~saR)W{8Y&FxhCGXPdBBq4FR9{DXJ=2(>vGY9u-8$kV1(>^p@uxky1Dap{0H{6iL
z7$1o*1p#M$aIT;QRvXHuo$R6Qnj<zBeup!LJ;81!rQ=}DJ<&sMh)Gngp<j@jD*}pi
z0!D9%^3{%4#^hp7-tFkYAlrx*AdNPvIWdBo+8jt)okRo7M$Ag{=%1-Dv34d-uZARt
zLIv|$i!!XY-l_ZoHRznJ)EgTdVG)$VdpAZNvTpFmQ<JQ=%2#=#7ka14x75EmoypTx
z`}2C8?kc#j-{h*_TbA8)CRN$)N3-Y5Ryy%Zh@*!I*`<=_)pZIL28=dDtID!HkJT#}
zw0nbvoqX7$0;c&wQC2x*fYxw<+xOzim{tXXFb|nk|1{)If$6a}XaXxbg*B&*NH^~S
z$3G#u_s3)esnd|6z(x%LS9=o2wDNMx1r<B{#X@R6nz{D!ikzL)vL^_r`~&j2as?j*
z959uwNgvOL2lPxDfSmU_wHuXGQ^aA)G^sXy9T-qSowq#VMO}Q3-AUUvae-dv#2U&o
zthUrh=2?z<t>sKasvdfXtPO%GA?fZ(&aE5IZ-wN>dOC0rv#%)B)RTnV6h#zILK`2T
z9Qi7|@J{+lqPx6)Olr&*Z{NVo?3Zs}P(t(bw_m>g47RS{ynb{^R%ic<trLY1!2rtM
zTPEuccaqBk^>ku_UZ8*+(9QM!$U|;4Da`2!a)-l1I)Wp(frvW-@_Nq21vtarBV<u<
zg^K@X>S$ncX2?U6T6>qRY^WU*6(;T4;0Lga0k4pDrCsZw(S~YRM&(VLXIpTr0HGxa
zk#vDoD{dvzBCT}Q;qZYU#+DB5nvptJ>L7An1eZI~muMh@IlVw8IA?Ci00rfT0dZk;
z<uD?ST1OFCJ#Hb|?Y_j&^bKBA`|k!Uc=#2amK*T6!|ZI4+ntwT{KKIp8c3=IyB%{C
zSzb$<Z7fpgFw&*j&?-9A$+D~YRDH?N4{PX**2{a%?|_A<@IOsfF~W^K>yt|A6caPY
zm*AnWmAud$r!m-2z^o&OMt+qxIg|AA98V9(SqV8>UG+8cHHH!}BOaousYg>c+S8t#
z(7;%ew|S;J8u}K~qC)=4+T;nF#CKkB)eD)Os=R4nPA`riVy9rUd!z+mjQfbBhz~cq
zrH{%>kTv^I)xu4T@BpgZ@x)ykt7tqG4|4@b!LmS0C)7>`Uvg-_;Um~E@-PM3r$c$;
z?1vyeLjKM3%czF#2|~D))u7<r#zI@J%++)f!;O4nK`OAxZxfaHkukdtTt!GYC`D==
zGhnEC%dAf#SSLqQF(=N!oz>D&ewLqOhrQ2E1<lFpX#Eses*D-CJ!;p&W0-&M7&O(&
z2Bo&F!(`Z?4c<6b(^@brCGD&_>}FWbkR&U+|3%i8JT-D}4<muyHc(3{&^$2mZ?Y%7
z;-!?{O?w2J^~#ZvybhRkGUF~QG)lSUs46M^q-3!H74&s_)F2$t3gAS*@mWN=Ck3Ke
zAkWT%7#@zY{HeK$Y4Gq&fjv_OR|M)Aek}t&kOaw%{9<RcpQ}+0a2AllWrM$1I)BOz
z`Tn)Xkio0)YpdDF^S%(VUgd9|!1PA^8UG^`qG7cj6B3ZE>4%`Y<)T^NHjxta+=7Wv
zn5SN)GVO)~C^+@+%&moo2>(`1K%f%1U5e_k?=7oDiKm+$+^W<YD~>+gFCn?q#9Jcw
zGHYja+eTwM7J}&;DWBG0(s#QWa$3d4SzfwHJL%?{f<6_)XrYX19sP{xxZA^!#|O0M
z*}k}0%BEA>$<E;WPHzAJE~raMFs`(Lma~A!Wjj`Tl<pAl<hpTLeB3;!CfHgrqYsA_
z2F_bq25T?E^#s%|$F`VRGwMlE$9J#4VUOgy<Lb#;{$yD8?dxZOOb}{<zF=cRz2^ns
zoMuH|z8Vqu%M@1oX?Xhr9gbhQS?TlX7P!b0DD4KqaZc+Ks4(mptKjA3<wZ6s6QMtl
zFoH)75XY7cO`HV>3>mg~moPij&)nN;93z~^=9W_6QlonBp~q5hJLa~6r64Fl%~|iQ
zbMm)dwL6+J&}<mP>?w*?o-FXq44xq60E{utau5O@gCUT1*b`S*8y*;7VesPNBij66
zJ3@11a`!&P5Qv-r==*a`k-uj!mQNRTw16s*osLNmR-SkzkXwBJ(?9*xfPes$7R=g5
zNW-UewJm}Lh(f*Qgb+1$UL15UuF_rdZKah8^j2Umlf1lSSqEw60(<rdy?d53o)kR{
z!F=wvFh?t6NWQ&>?xI>w`M0j|Y>`eQ=M`^ob^h2ORmKmeE2>H>a~L-<Up^-L7i(N-
z5(o2O=IaJIjX;*o`x^4@8DDt9)b8o|b5ibXf+yguPYbkJ?#2b$p{Cj|F+899WxV@d
zuM?WyW2(k$3hF`pWkIbmHE6>wFGAYZ0c@!lLP`*q3WU)j*+olhZt;nI8CZ-D)hXI#
zU615Qo!*=?U=U4k^>~=tvts%U&FUxVvFLGsXb4R<zZTRV`1kl-(`Sz(F;+HqsW>1j
zp7?{6M?yhyyC^^yNw95{SZu=;L7cWn$42V9Jzli6FK7{CKwHHdeGILSP?gb*0~=_p
zU2faSHY{)Y)Sj%|N2xnuNQU3eG&$;qq55?+$DA1|KlZvGEddDH=!S+Ima4-pT5Bgp
zw#%88;s|VqW?rWju+rC#)&-I!+bretyRox0B?B?RC(n>-!1TTJ25gCT4wG2)@vgKP
zFwqefBL{g<FQuk8+b%XP+o_Wv=la{*d>?|pJsPSnw0FnY6*!CW)l|#ym0yL-+~QIQ
zsE|@#Zq#R_-$ew8-1aqD!*`U|Fy6>^6&9s^=T499EIBdAq7IrQBfc?0Xlu_upX4Ph
zl1w%uDPi<khH7Z+yOjc4?Pizbt8I|Qsbc%_55ixhUcT&3uV34?_x3MFU*MSGH_*43
zgZZBuDtz(wF&r$y>lg5=urr(lIr$eB^B=u^^!7!N4<EmMgogib0(~|9;q@2t|9=aq
zE86{Ez<Yet1l_c8MZtEqtD{34_=rE`MtSH;f~jrAs(nC92%8)vXqQKJHTUv+M5{yg
zmAh;@-1$b<^q{%g=2t;uc#2y?r@!<>)olt_h+Tqin=}CJ3^=ce>rJKRIwLU2d!XRk
z7M@zZ>VkaMv7mWqt$Qf>4p6dcHlpp6qp|0(Ro-F}%Bq7(I`jxu0XeEBUsGxURvW40
z0SkYO*ZeTgoO)3qDoe^}qs^vq!^w)YVr=uW2P$lqt;By}*SCC7H)L=gu5jqUEV6FV
zIgqV|d#Qe74<o|%x47Te)B~aTn!TWy(f}DMUN&I4QxMJ4!l;=8hzgIE?Z8+VVW81f
zTt=6~E@NJ7rD-OH5Rz-~V`pz*5675dhhX2n4y26kY2ObPJQTugN}pC2@yM;)#4U3L
z64&DLnlxSKNEcf)iq3|Wq7EyLY<pP(2DXksInaFh%FpHXwYESH@7dsCdlQ6R<d9CX
z`;6J7`?ec*^%{O)WKYdRO{g54TMf5m(GUI*jj`p%Kg#<D+LeMQ4!;m*Fkmy<23VUH
zvd9i@#XYEbf$hiw(;ijkd*o2P8|^n_Pqja0HLd;A8B9ewW=&wte9JRv3y<h{6~Lr&
zfwO9GK6keZsRT60$H@t_D897-U*ql~1W1HSFi+Y`_sBeLjTWpOZa{lzJM<H?f#r0G
z_Iozj#tr*^DF|=!dG&u8)1h@OZrVqL1Q_6i)n1Dh(v$MvRiocZJ1bOMX{>*syw<un
z?IDuTwwZB7TbDUB8Tt>PFqEhY2L{Mupg~q>f0bW|ejfGK4!Rnpv#6Tebc}ao-KbMh
znmIX{wZI?yM0h;xz;Y7cOWH@G3Uve}4G2jtte9T}@2S^~aTs3I;X*F3hN$i;@hJo|
zAap>!F~umMda<$^t9~_*p@~|d=9ED#TY0kRD@ydR2O4yiO8N!0Nq$KSf(0rksCb-~
za5Uxx2CZ&js;)Gplu|_#)y%`bt^v=YooQJfMlcn;5(fInvqlvqLDs1`>uFYsm?Geg
zA(So#*-DMb?VlVZXc`Pw0xz`Vj-VZRB=2$z=xzULGJFe*y@h#IqRV^=63#QZDG<FQ
zrJz*;Q0p3JHxI?k@>>U6{w&MZ6+_oyicq8*OhetbJUakStDc55_(EsYMhEJ}kPc-L
z7bsuKqQ_9z5p-L-QQ>TwX7=e6cBZll%<W<D@gi?tcFSHsbgEoH^H<?N{@_3B(ff8@
z?^O2x8hDVde)0AT^Z<S-S8Vq1`Rgx0cF+$XHGKQ}?U{@5?VHJbPa@r)@ygeM9wC~@
z5?;T#?3lpNp>*ycS<Ap|S$L_#yzOD+%m=h<JFEv-Q@{}<?K%R0b`9~n+_z9v<n-Lt
zwmYj8`?wkgipo0P;rG>P4dZch@?bp=mxpbxH3WnrnXMGe+Zh@bEU+8l2Ud0{YsYex
z2L;`RyvpZDr@|FhoY8zxH4Bz-0PXooqne1InmCUqC&I)Tw#KW5(!s;q^t_li5?)wG
zZq1NQ*K+`|s??&gh!!Nu-!_=D0xUXpa+hx<-%~9m-B4k9$kM(iA#Yy6fiMjF!i;KJ
z*MQ6Th%B>vcP&%1hZ@>mwDy|}+3oB#xb^lTIJAR%s@c&XZKXJ9UyCee8|eLZb`KdH
zR8iGlp*|@B%z~L#k12Gk?F95U27yiX+$l=}#q!)Bb21v~T&EN3v5?K#4)=nSQef6p
zrDN&>8&l8^(n(mZX{DKvB-!ewYtRF(qa4Mfi2$KN>y%Dx8P+l=yrqTA6>VRoTrisk
z$dc@VH)E!5jj|oeqHMrvbTg&_ZBgxTmQF?JWZ}$-0@g-qab#9yEXCz-&24Hf1#DCy
zk9F&PC+Otf$*lv2KM*ugBP_~`e4VRZ4pQP_#(h~{(?TtzJscx#<P0Ng)f)x#CReeR
z5boq|mWf7GJMxW@-LZ+6X2-f$SJ9U~sQ@rnY&3JoGvej{1^qW`$YPYY#=t?K(iaQ@
zH<?B&eNl^`)?Mc6!*Ti=eG(&waQ-C?K*h%Wk@gM`NzDT&qZ)5`n;j-T(Dhu;0l5`~
z7j`%x!NOg!Dj3TgZlQ?30Igw{BMdR!{;0$dWs~Q&jQh#dd|oOwqO<)U?}aiu)9DS4
zMzL#|xQ2+N`0xNWc?O~6pf()wWw^D+jFe{pg@arRE+htV1Wv^qA0^W4=)jq^Ak#3$
zywDL0iIB?0(V8W)KY@mhMxk6iCIuL>7^<@+x;)6Tcob-A`8NaJCxaO-U<dsYf<6~_
z$Qg8wCprTVy+H=lEKFiU428T`_QK><rgSW05uj0D_Z#toJpN@Q8v;R@gL{BN`|n=n
zdZ$*_a8WjxyqX3Eq!K*rJC+cu3j&W2HYQ(3@ADGTkTgFp!1KP!A}(l;*(LH4G$EQ+
zE0a};YR{Vz@U7JdE&w?Tn4Y%9qF||@zfP8?U{E3u9QmlmJVL*)kDpTE@!6mL-a8y0
z2^=s&!c%P-?T_B&b|5veQp1t?0xKRElV=I;_i8|1oayFLg<NU!i1j&z`q7oV00*#L
zH_creGvkxpQTRDueuFDqW|KGD*vV<wObXUJRdG`bCl7COf{<)USH{F5mXD0>b#8Bh
zm0gH29nnW?#JtLAB{=b@xD}j2Yh1{FLG2ul1@TEGnO4<R19qYtkIJp@?8yb=!6V}y
zb1?ep;FU$38xqE5*OQ{Z!eNAZU&<EYarg5IPapf{T4iLpKm&Mb%YS-~Fjycj9M_Qg
z=>y4>Qdo9ld##F@WIrUSv@~&8#x&Qn{T_T8v`kvG>lqSPX&q}{FW*OYA4J?1@?Oc8
z!deg7(ICH9*0gzel9M2(z&Wu%RW+_uc!au;e<+0nL!Hf#xd=BKBP81cveVVEWpuZX
zc2RWzra;bD(HX;$E-k0tlAJSGj@f%JFAoAHX3{EQS3YHnpCWogAdvtD(5utcehVh3
zL}0x}whkTvkNb*&Z!h@yQZ$(~Rc_h#+ESP*s3Vi|NH_V(@WX1Fno)blrc!OYE?E>G
zY;t**US0%l+(DbPhDeq!c~ao82}JJFh{DV}hb=UAE5YFiBU?o*pj=ja8ku`|^Du^T
zv=&IBAe@m4Ad{o8p}=iZu$=*R;L`7hCk%4o&N31Y&qWxD8u?!O?S+nsJ-U-Sf0De|
zlN*R*9-(wW`=k3vrJU6M@*S>-X+Adf9_F3h?pBmtT%Q<Dk(MxbQQbwKcCL&ELseB1
z7!ltgxJr+7(gBB_TQjw;!2@#>Bw5&^D)p*!rx0j~4+B&K-x!m`(R(I$RM_R^9gD;O
zy9Ij%)E=@uP;l#hS`f&S5RNFJlW9tmI#{S}$yRRUJ`;cwp9Eb!iZ=TpiMnaM6y)@z
zqqxR4v3dFKkj)8K4`l-g$U?vCcbKd|n*owBgt5yuIebG$L^i|VcZ@o{rlTRtTPgR!
z`^iQan_kf!NiDqe6-9I~P;PeT*%|(3flug;AA{5~Zn?&*X^06gGAk~n1gC4r)o^b!
zxbU`WV<x}brG&%4(h7RYLr%NXZN6(G=y2@N7WWm|g@i|WXly1Ev!c1l@-9ylTT}A;
zrZ)qF6|{Y1t>@iRR5|vQjj%^u%vb&IjS9JAHA;uu9#XKCofbv#W0WW9aE8$aWZd3^
zkv|Tpx8P=y-?{1AVy%-as2^p|>P5|l1eo%Rv7=OHgtg7;rdr6qD$ugr+ZD}qhv5K$
z8E;ycJXQotM-dOT>?r?(lg7|$Pn_Ld*q|E7QRT5L$NwSx2ufGI_!pcRy-$aDN96j=
zpZgg8Ute(1(A#e?H~Pcd|4HBT^Ve@e(vf`k`ir0+K2M+d-*W!;M})!2-DD5c6Luh;
z&nd7}UMneR^z5-8VMmX+KLaDdY={(L;7uR=q!L^JdevUT%r(^USm1}?wN?s=5zUnj
zY)?e&l&!KJ7?Qm{9oz^onJR=eE4x$ncZ9+rm&jtR(^m;%fJab@hH+o!wegH%?RUTc
zLy+mP!{xyKOV}`7TZGA19xR0Kzjc5t3}0V1xDMn#c3(DSYZJu)k8nnl`3P&7jyq?O
z{Xq@lO0qrU2KyD>v`YlBVuN7hTG1>C{ur`|p^b<}XFSqvTPy%_{|_A5Y`K~&wXkKE
zI@oQ`s?wi&spcpzTuyCRZ4<Pi(g{sFGO238l42bW^+0#WATTcDgUt^m|AWtRpc>f~
zZV;U~5CZ?t+KL~-W{I?k-G?aC7V6qXB=Tp=zp`+;_gMxnc)W*4+Q`(zWzw<1LUyOM
zfHY-A_AbB|Fo`!xSVp-w%tr&3;nan|Mm-(Y;c*OTjt~=c$l(|Rt|TG?mgp*wd4g@Z
z=``e(82zZLoCyiJJ!>zik<fsEj@qnB1%Sw#A3<nI=Y_z0DQ5<C<4u?H-Y}ja5|Eoa
z4sYN!PyCAJHXO@Z>t*)xcQUC*c^9%8ZiFS(L%rNFd>~%eF2t<qH_9+$I$gmBsf!yM
z8fxKjY6*0eHjr&h)JZkgkcN@LcBSp;+CFk(i~u`ob@ZMw&6Q#p1Wf5sN}4JvNK@_8
za&MLbaI#sR#Co$o{+66MZyIU=edz_!MRw=4pvttx$@5H}v)#Pt+fnNI;vI&6D{wg`
z&JGk!HtK<`-V8NL1`{CxVtS}YVQ7yb5bSQo=-z(N)ZnE(IeW-+>XUK7E8wcZ*$jD6
zhnX3s2e3o5QWpb<jEa-0(n3tjcU}sfG^bu<Gs``k;rlopGZ2Gap}3G8msTP$FhFA&
zdRYJU@nat(SmN1WUjnVBD_rbUylR(_VkGMhR%f7}z=fcM3(>spf_<8U3RXg6ztWm)
zIp*718PfV4k94*o)E1TsD6_K8$2dhB9_gJb8jZNrwbqx~qDe8P;9K4+RcT)hd|)cX
ztT$*_hqiRLj#3T6(+M06$|#HDPBClAUoFSt9~oE|K-P7E>*}T+s12EcD-Y8_HP3^K
zvGP#%0x`h8D`3Fq%`w$n-E2Jp)2K=-hsN_Q_>dn=mZpVWSII>dv&fLWGaSw|SIrKa
zR$deQ3Sk@3Dzx`1%Qpl~uy2#gZU<L-zV8_v$@28=e)1Dy8w;iV-Rmdse>{Ks*KeQO
z>5qS)2k&cHet%s38pM}$@Hqg@r^v9Ck3ZLdmrve)8*J+I1RL+78CDwpFi$gUxgA`f
z^!UEWU8)T!M5XB!HTY@^o&L}a{!mlhBW67&%ehClVY;^v-9ysj&zr`C^ftt~Yi#So
zXFb?5(~+9*TH|C^&c)y-!&Di#A(KVEr2!)K*~s9&+77529&9rh>vMqu1@el<ecB(e
z8@*+1!|}FUndELGivyjfqvay^gvuj$q1C2%GT*@d>)#fGF#-J$0#LxXfSUtCiL%q!
z=a;Qv(pD-IGwF(!MFv^W5H8&F5gr;IuBS9lusos6vP(gJw}EoiBo=22XvVmOb4yHV
zPzkOx`E1CdJT^G!#nV$Y>q@p!%?iWB`pB!pqA0Jo)PvKqL+h5VXJ|gm3@x7MB@g9m
zh!^u3MR~~)PQ+V~j<bzCAPjG2n4}uOfoRrtL@obHu=?WUD?@~p255lRZIPX9l3K;Q
zTSw&eY$Ws#YbZyOJGHz{;cF>%Xmmoy4d6c(?uyYW=V(buY-@{<zw`-(kVhWP+#xGs
zIKtRI+|Wst3NAr~sMO7zlN1FV?xx<u<0a=i1Lqtt4f|6vY@eZh4o8;OTFYGuvd9sg
zhBlFd4K!;FP&~7)(OMdQ^9W`}UW}9;^F`B(!i~KSWTsfK+6r05MQ&sD`8rLQ<_)js
z>4G;r)R@Ox9wU_3t?Xwlm{(8`R&-Du!eD-Xtv3DAj-N(Pb2c?>jey=`Zm#l9!6=_<
z*hARToSnZ_F;Mjvcq#Oxz$7cOTO)Y4bf(JSk3<tpmLvz3+#9+Tp7b0w)SKsjz@1)h
z6Io9nn!VCZyq+tV)WdM1Wdo*ygTxUR4?Rp^us5<~<l$$eV4V%1R<J(<MJ%j<&ojs?
zN=2KLwV`cQGg2r}nN3Cp4QX3sxgIcP9q(RcHyhmN&jTI|N_f=57cd>eH48&$2m;d;
zWYif$1@2~WoViq>WYhU0L6-*h^J{!C`~rW3j|NKQ7J$P@_!4d#Em(EKK^F)<hW0H5
z(OM5iI}8|Otzc@ebT%6h>cF(#9+{3#NC(bY)*)L?BQ&sZU1ZXrS2b!_-Sdf-+Msu`
z(Q-?IVhp&H$S$yqQ!Wn-^Az7{Ze3SvH5OE{SXZF7fyr17)kE*WysPJfXv<}YM)Gtk
zDCiw3lsN`BP@^Ht!;Q?ssTJdLl)1>tHUq!aThy|pv1^b`$%=F=PBsHsBDWQ2*+63*
zPj4T<wY>0|y6o7q1kx*GcL1Gcwwiww{{0X2;4i}W|J9f%AAI2Ggdg>~yVbwvZ1&yz
zACIp-zJ(*6Ur_b(9aS&K*S~)Hr@s&X*2W}#{+DmReEm8kx$pO%zx^x!yU*S}4{txe
zBoF;F*XB3$4*40P^X$9)52$Var?GI<UzL;%b;j4sU3=w0%x({-RqIOZnV{kN@>s*w
z#1EQgIxm5P>~s+&y=vs;K6`o(DbV5zbR2@Li1`6pMwNzU7}CJJPPQv}s}?Fe-z*U}
z8K=I#n<lx9Mo7)>mI`H9)Q|W&&RPTmtJAL!!`cNKMu5$}9czj&fu9a1;y9wyr0x{y
zYPR>R+tv(L*|flyLd5%KNu0C9E8WlX#G!88=wnSAV>&@sOg9NnI9;Y-b4R%3n~@=`
z?m3%SdN>rBY5LN&h=Op!aB4CYhtj8!oqTGm;!qOH@`ik$(d+u<$|n3$$#QQ{4uF)C
zH{|NbE1LCwp>n!7LWkW3OQpkuyQWPSH9NYhV{5;V!Y1#<^=fT5xml3T0~l8$!eUAC
z9<0aQ&Sld|V^>!)rYnKN$~lKB2w}(&rRpp(U6)11kR8}V0A*}Nfmk!QxxH)$;^V2(
z$o;cuTU%c%ZoT`xW1MNP^CXp}MHRQ5TXH3-GSp-SB#}L8GrFlTJ?fN*?yz^GA>R~8
z-<m=>4;OuGbtfTlC{E}+SYu1J{Srw-@@HM!)#*CO9+E#yN1*8fz@mK)+~`c5`eRS`
zSt-i_>l&(xcKjii0g<~XaV~@Gb@L__89YP@PLpApyBf<jk|7FjtTTQ^?_*Y2^B_^p
zef(YDEH~F^PAiM|Acq3@aP-W?=9sJ|%PYALuh@brGqP1eHxaEGPRXNp6x}^6P8k*q
zMGL_$WB{1!X+Jt$t8=7NA3V?=0$}^SJCuw?FkK%q0Cu=3(uEQmkqwbLwM1X4yJxF(
zDC9fp8g4U2T<Ddir7ndaZq<CZZdxYb@{}6fVnxOLXq0!=Iabjpo*EVqZmoO%2g|Op
z<_RnRrW){j^d#vuvbLf3RcL^zT>`@|YdsOE7trlSZ|qFgniO+RK{8-ox4FOVb+$Vs
zzJdl^?UyTJEd?D87+7deaKaj}v9(q8pa7Trg|FarqZyUXP$evM+DCPljxaLnL4Jns
z3Vr}-(yhid7{dd#u-t>kA}MceCjfy==&cBx?g22$V`pcO!?&Fr)H+Gu&P$4b$O(!*
zr#Qo>$7Y8W1|4JTAx6+(0a<1qT09Mq8<XNyNFCZ~%BfSB;#h;{DL}DXlk==y2f-RL
z5j-8d6l5u+LaW#5m>R#dlS0&V9c}|iT9sEpxy7=+K)XTyHRkpGMGdyX$o^xF+wY|{
z>?p-c&^6<<WI(KJxskbcGz=NShJcC5S-!vwgb|E~ItYaaOx3fyE?nt7)q!3CLR14(
z4S2X*FG*zW(g>Ilj#}*J9cO%Xh?<lPGpfbi=G1u3fMFAw<{}%GESvTyXIGT~c^p($
zhMW77{W$y={rETXzwkF{Ao%aXf6|X1gdhJf;Y!1VUlA;xOyquT{w}|I{X=;Ff_~LA
z!w=WPee2vX5v*r@Wd_134OUP5L@xGd8!eZIU~$A(d#C}3&2}r?1%t!1z@7<YN$k)x
zqroNXH=J&-_S2Q|G)&dnuEaGPoRoUB887Pt33;W@=N=(m$vRTKmr@kn;#Qe*c9M;-
z=vck$HK)Xscyz(`oxL;^$xW>M#GvVlQEo^6a?hSza<vX9518g8mq31_QmanldOO2x
ziB@o$Te`NCQ)jyJr<0Vnys&b@ERS)DNRHW3iV!l53YV`V6DqO^HnU;8Ahi};E@mZ3
zF)fcg3DaOkM)h}_yrBeA8T(<H3M?OUr7Nba<zZXt>ZUIJ?;>(s3^2QJ$SgNH>{}E$
z9YCm)O|mT8%QU?+rI_ML8ZE!vn%NsLl@p9gDvFO)j3)1!0h7mJ28;zJ5%=tLTIDt(
ziD=d&-x>))AY_}Lifnj>c{L}f<tPqJgYh!-f!_D?hXHPfgWTWP_~nJfI_KtUS=T_c
z)UlNTs?Y8dk3PCqT=vC+*0A?VD<mb>+9i0b%=9Tq%8;=_2Mh*4Qg+G>NPjlj;s!yp
zIf*Vkh&?A`S$U>BT%bp4t4pKDK*cn$!`vc!DEfd7U8#+dCV9Hj%VRbs7(drrrD@6X
znqJyH8&M!+<C6}eg6gIgw)yZ=m7OpLFeo#<VM|ha_AqjzpHG>p=JN_i68GkBWW|(!
zuEnK(*wd$``P4+A<(k7WaA{D6nH5`u;jo$NH?VLyuvIM^aA~u-x^kFRXNwY~VT0dT
z0EC8Ff<H7{rz>Tj2A}$0d#Tvck&c87FeG$ucQE>4N6bhi=*`|H1p5?`8gK|23t|Qk
z8|Dbi&}#S3+DwocwWIRNO01fsMQ?=`c|6Mn#dgFAtC~4pH=+ZL8auw&vkeU#RC(Sa
zzj+^HPlgd5&GukmKLtWaF<WdY3;Ne?U^2DVXhou*dX*bSK-!T>?d(cKybt?MQ9US;
ztxONk0vixS8S>(hzAbw(#0>;C#ks|_ha+((8DqrW_Ad=hHlbPG7JCqoQYc=?dg}X>
z=@SQQ4dhuRpq4|p(g#`?$z1JCMe_-s9ZCq=j%b8zcK3ZHG1D=BRYyW{d_f?@sE3m=
z&|HmgkeI;Mhm!J^35$8OxjG^dfASN<0q3^NpF2JSh2Ov5RXTanenuCT&t8oT^u^mh
zg}2{*uTwPnR^NXf-ae+l{Il@(HKu7_1qjU1RQlcj|G(kSeL{bx0Jc0m-n()VY;oHw
zIzVB?O@_32+^NgTKrF&CdZi=_#;fQd&@66bKGZ$rBa(EUG?_*5Y5sg0q!@<>3)C3x
zDHjQ08Yct5byJU)RZx}jpJ%P1PloKt@FZl9Bj8yPOMy-m){oxJYiEr>nJ)qwWT{Qp
zj_mW)R04a=pMh1%Dv(aj1Q1nfow<t(D5Z0t%L{PXlTaos&|YCcg?NkEr+*cAdyoq0
za*7Br9|nd3>hih;WqMv}`9*1Gi{T$c5f9??B^HHhv{z(}TVD%q4)no;HK6^>A)q~X
hSpdDrox+^4cgglrz7rRzDPZO0{{oPT@#kp3FaTBF64n3!

diff --git a/mmsegmentation/mmseg/utils/class_names.py b/mmsegmentation/mmseg/utils/class_names.py
deleted file mode 100644
index cd4392b..0000000
--- a/mmsegmentation/mmseg/utils/class_names.py
+++ /dev/null
@@ -1,570 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmengine.utils import is_str
-
-def xray_classes():
-    return [
-        'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
-        'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
-        'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
-        'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
-        'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
-        'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
-    ]
-
-
-def xray_palette():
-    return [
-            (220, 20, 60), (119, 11, 32), (0, 0, 142), (0, 0, 230), (106, 0, 228),
-            (0, 60, 100), (0, 80, 100), (0, 0, 70), (0, 0, 192), (250, 170, 30),
-            (100, 170, 30), (220, 220, 0), (175, 116, 175), (250, 0, 30), (165, 42, 42),
-            (255, 77, 255), (0, 226, 252), (182, 182, 255), (0, 82, 0), (120, 166, 157),
-            (110, 76, 0), (174, 57, 255), (199, 100, 0), (72, 0, 118), (255, 179, 240),
-            (0, 125, 92), (209, 0, 151), (188, 208, 182), (0, 220, 176),
-        ]
-
-
-def cityscapes_classes():
-    """Cityscapes class names for external use."""
-    return [
-        'road', 'sidewalk', 'building', 'wall', 'fence', 'pole',
-        'traffic light', 'traffic sign', 'vegetation', 'terrain', 'sky',
-        'person', 'rider', 'car', 'truck', 'bus', 'train', 'motorcycle',
-        'bicycle'
-    ]
-
-
-def ade_classes():
-    """ADE20K class names for external use."""
-    return [
-        'wall', 'building', 'sky', 'floor', 'tree', 'ceiling', 'road', 'bed ',
-        'windowpane', 'grass', 'cabinet', 'sidewalk', 'person', 'earth',
-        'door', 'table', 'mountain', 'plant', 'curtain', 'chair', 'car',
-        'water', 'painting', 'sofa', 'shelf', 'house', 'sea', 'mirror', 'rug',
-        'field', 'armchair', 'seat', 'fence', 'desk', 'rock', 'wardrobe',
-        'lamp', 'bathtub', 'railing', 'cushion', 'base', 'box', 'column',
-        'signboard', 'chest of drawers', 'counter', 'sand', 'sink',
-        'skyscraper', 'fireplace', 'refrigerator', 'grandstand', 'path',
-        'stairs', 'runway', 'case', 'pool table', 'pillow', 'screen door',
-        'stairway', 'river', 'bridge', 'bookcase', 'blind', 'coffee table',
-        'toilet', 'flower', 'book', 'hill', 'bench', 'countertop', 'stove',
-        'palm', 'kitchen island', 'computer', 'swivel chair', 'boat', 'bar',
-        'arcade machine', 'hovel', 'bus', 'towel', 'light', 'truck', 'tower',
-        'chandelier', 'awning', 'streetlight', 'booth', 'television receiver',
-        'airplane', 'dirt track', 'apparel', 'pole', 'land', 'bannister',
-        'escalator', 'ottoman', 'bottle', 'buffet', 'poster', 'stage', 'van',
-        'ship', 'fountain', 'conveyer belt', 'canopy', 'washer', 'plaything',
-        'swimming pool', 'stool', 'barrel', 'basket', 'waterfall', 'tent',
-        'bag', 'minibike', 'cradle', 'oven', 'ball', 'food', 'step', 'tank',
-        'trade name', 'microwave', 'pot', 'animal', 'bicycle', 'lake',
-        'dishwasher', 'screen', 'blanket', 'sculpture', 'hood', 'sconce',
-        'vase', 'traffic light', 'tray', 'ashcan', 'fan', 'pier', 'crt screen',
-        'plate', 'monitor', 'bulletin board', 'shower', 'radiator', 'glass',
-        'clock', 'flag'
-    ]
-
-
-def voc_classes():
-    """Pascal VOC class names for external use."""
-    return [
-        'background', 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus',
-        'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse',
-        'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train',
-        'tvmonitor'
-    ]
-
-
-def pcontext_classes():
-    """Pascal Context class names for external use."""
-    return [
-        'aeroplane', 'bag', 'bed', 'bedclothes', 'bench', 'bicycle', 'bird',
-        'boat', 'book', 'bottle', 'building', 'bus', 'cabinet', 'car', 'cat',
-        'ceiling', 'chair', 'cloth', 'computer', 'cow', 'cup', 'curtain',
-        'dog', 'door', 'fence', 'floor', 'flower', 'food', 'grass', 'ground',
-        'horse', 'keyboard', 'light', 'motorbike', 'mountain', 'mouse',
-        'person', 'plate', 'platform', 'pottedplant', 'road', 'rock', 'sheep',
-        'shelves', 'sidewalk', 'sign', 'sky', 'snow', 'sofa', 'table', 'track',
-        'train', 'tree', 'truck', 'tvmonitor', 'wall', 'water', 'window',
-        'wood'
-    ]
-
-
-def cocostuff_classes():
-    """CocoStuff class names for external use."""
-    return [
-        'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train',
-        'truck', 'boat', 'traffic light', 'fire hydrant', 'stop sign',
-        'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep',
-        'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella',
-        'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard',
-        'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard',
-        'surfboard', 'tennis racket', 'bottle', 'wine glass', 'cup', 'fork',
-        'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich', 'orange',
-        'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair',
-        'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv',
-        'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',
-        'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',
-        'scissors', 'teddy bear', 'hair drier', 'toothbrush', 'banner',
-        'blanket', 'branch', 'bridge', 'building-other', 'bush', 'cabinet',
-        'cage', 'cardboard', 'carpet', 'ceiling-other', 'ceiling-tile',
-        'cloth', 'clothes', 'clouds', 'counter', 'cupboard', 'curtain',
-        'desk-stuff', 'dirt', 'door-stuff', 'fence', 'floor-marble',
-        'floor-other', 'floor-stone', 'floor-tile', 'floor-wood', 'flower',
-        'fog', 'food-other', 'fruit', 'furniture-other', 'grass', 'gravel',
-        'ground-other', 'hill', 'house', 'leaves', 'light', 'mat', 'metal',
-        'mirror-stuff', 'moss', 'mountain', 'mud', 'napkin', 'net', 'paper',
-        'pavement', 'pillow', 'plant-other', 'plastic', 'platform',
-        'playingfield', 'railing', 'railroad', 'river', 'road', 'rock', 'roof',
-        'rug', 'salad', 'sand', 'sea', 'shelf', 'sky-other', 'skyscraper',
-        'snow', 'solid-other', 'stairs', 'stone', 'straw', 'structural-other',
-        'table', 'tent', 'textile-other', 'towel', 'tree', 'vegetable',
-        'wall-brick', 'wall-concrete', 'wall-other', 'wall-panel',
-        'wall-stone', 'wall-tile', 'wall-wood', 'water-other', 'waterdrops',
-        'window-blind', 'window-other', 'wood'
-    ]
-
-
-def loveda_classes():
-    """LoveDA class names for external use."""
-    return [
-        'background', 'building', 'road', 'water', 'barren', 'forest',
-        'agricultural'
-    ]
-
-
-def potsdam_classes():
-    """Potsdam class names for external use."""
-    return [
-        'impervious_surface', 'building', 'low_vegetation', 'tree', 'car',
-        'clutter'
-    ]
-
-
-def vaihingen_classes():
-    """Vaihingen class names for external use."""
-    return [
-        'impervious_surface', 'building', 'low_vegetation', 'tree', 'car',
-        'clutter'
-    ]
-
-
-def isaid_classes():
-    """iSAID class names for external use."""
-    return [
-        'background', 'ship', 'store_tank', 'baseball_diamond', 'tennis_court',
-        'basketball_court', 'Ground_Track_Field', 'Bridge', 'Large_Vehicle',
-        'Small_Vehicle', 'Helicopter', 'Swimming_pool', 'Roundabout',
-        'Soccer_ball_field', 'plane', 'Harbor'
-    ]
-
-
-def stare_classes():
-    """stare class names for external use."""
-    return ['background', 'vessel']
-
-
-def mapillary_v1_classes():
-    """mapillary_v1 class names for external use."""
-    return [
-        'Bird', 'Ground Animal', 'Curb', 'Fence', 'Guard Rail', 'Barrier',
-        'Wall', 'Bike Lane', 'Crosswalk - Plain', 'Curb Cut', 'Parking',
-        'Pedestrian Area', 'Rail Track', 'Road', 'Service Lane', 'Sidewalk',
-        'Bridge', 'Building', 'Tunnel', 'Person', 'Bicyclist', 'Motorcyclist',
-        'Other Rider', 'Lane Marking - Crosswalk', 'Lane Marking - General',
-        'Mountain', 'Sand', 'Sky', 'Snow', 'Terrain', 'Vegetation', 'Water',
-        'Banner', 'Bench', 'Bike Rack', 'Billboard', 'Catch Basin',
-        'CCTV Camera', 'Fire Hydrant', 'Junction Box', 'Mailbox', 'Manhole',
-        'Phone Booth', 'Pothole', 'Street Light', 'Pole', 'Traffic Sign Frame',
-        'Utility Pole', 'Traffic Light', 'Traffic Sign (Back)',
-        'Traffic Sign (Front)', 'Trash Can', 'Bicycle', 'Boat', 'Bus', 'Car',
-        'Caravan', 'Motorcycle', 'On Rails', 'Other Vehicle', 'Trailer',
-        'Truck', 'Wheeled Slow', 'Car Mount', 'Ego Vehicle', 'Unlabeled'
-    ]
-
-
-def mapillary_v1_palette():
-    """mapillary_v1_ palette for external use."""
-    return [[165, 42, 42], [0, 192, 0], [196, 196, 196], [190, 153, 153],
-            [180, 165, 180], [90, 120, 150], [102, 102, 156], [128, 64, 255],
-            [140, 140, 200], [170, 170, 170], [250, 170, 160], [96, 96, 96],
-            [230, 150, 140], [128, 64, 128], [110, 110, 110], [244, 35, 232],
-            [150, 100, 100], [70, 70, 70], [150, 120, 90], [220, 20, 60],
-            [255, 0, 0], [255, 0, 100], [255, 0, 200], [200, 128, 128],
-            [255, 255, 255], [64, 170, 64], [230, 160, 50], [70, 130, 180],
-            [190, 255, 255], [152, 251, 152], [107, 142, 35], [0, 170, 30],
-            [255, 255, 128], [250, 0, 30], [100, 140, 180], [220, 220, 220],
-            [220, 128, 128], [222, 40, 40], [100, 170, 30], [40, 40, 40],
-            [33, 33, 33], [100, 128, 160], [142, 0, 0], [70, 100, 150],
-            [210, 170, 100], [153, 153, 153], [128, 128, 128], [0, 0, 80],
-            [250, 170, 30], [192, 192, 192], [220, 220, 0], [140, 140, 20],
-            [119, 11, 32], [150, 0, 255], [0, 60, 100], [0, 0, 142],
-            [0, 0, 90], [0, 0, 230], [0, 80, 100], [128, 64, 64], [0, 0, 110],
-            [0, 0, 70], [0, 0, 192], [32, 32, 32], [120, 10, 10], [0, 0, 0]]
-
-
-def mapillary_v2_classes():
-    """mapillary_v2 class names for external use."""
-    return [
-        'Bird', 'Ground Animal', 'Ambiguous Barrier', 'Concrete Block', 'Curb',
-        'Fence', 'Guard Rail', 'Barrier', 'Road Median', 'Road Side',
-        'Lane Separator', 'Temporary Barrier', 'Wall', 'Bike Lane',
-        'Crosswalk - Plain', 'Curb Cut', 'Driveway', 'Parking',
-        'Parking Aisle', 'Pedestrian Area', 'Rail Track', 'Road',
-        'Road Shoulder', 'Service Lane', 'Sidewalk', 'Traffic Island',
-        'Bridge', 'Building', 'Garage', 'Tunnel', 'Person', 'Person Group',
-        'Bicyclist', 'Motorcyclist', 'Other Rider',
-        'Lane Marking - Dashed Line', 'Lane Marking - Straight Line',
-        'Lane Marking - Zigzag Line', 'Lane Marking - Ambiguous',
-        'Lane Marking - Arrow (Left)', 'Lane Marking - Arrow (Other)',
-        'Lane Marking - Arrow (Right)',
-        'Lane Marking - Arrow (Split Left or Straight)',
-        'Lane Marking - Arrow (Split Right or Straight)',
-        'Lane Marking - Arrow (Straight)', 'Lane Marking - Crosswalk',
-        'Lane Marking - Give Way (Row)', 'Lane Marking - Give Way (Single)',
-        'Lane Marking - Hatched (Chevron)',
-        'Lane Marking - Hatched (Diagonal)', 'Lane Marking - Other',
-        'Lane Marking - Stop Line', 'Lane Marking - Symbol (Bicycle)',
-        'Lane Marking - Symbol (Other)', 'Lane Marking - Text',
-        'Lane Marking (only) - Dashed Line', 'Lane Marking (only) - Crosswalk',
-        'Lane Marking (only) - Other', 'Lane Marking (only) - Test',
-        'Mountain', 'Sand', 'Sky', 'Snow', 'Terrain', 'Vegetation', 'Water',
-        'Banner', 'Bench', 'Bike Rack', 'Catch Basin', 'CCTV Camera',
-        'Fire Hydrant', 'Junction Box', 'Mailbox', 'Manhole', 'Parking Meter',
-        'Phone Booth', 'Pothole', 'Signage - Advertisement',
-        'Signage - Ambiguous', 'Signage - Back', 'Signage - Information',
-        'Signage - Other', 'Signage - Store', 'Street Light', 'Pole',
-        'Pole Group', 'Traffic Sign Frame', 'Utility Pole', 'Traffic Cone',
-        'Traffic Light - General (Single)', 'Traffic Light - Pedestrians',
-        'Traffic Light - General (Upright)',
-        'Traffic Light - General (Horizontal)', 'Traffic Light - Cyclists',
-        'Traffic Light - Other', 'Traffic Sign - Ambiguous',
-        'Traffic Sign (Back)', 'Traffic Sign - Direction (Back)',
-        'Traffic Sign - Direction (Front)', 'Traffic Sign (Front)',
-        'Traffic Sign - Parking', 'Traffic Sign - Temporary (Back)',
-        'Traffic Sign - Temporary (Front)', 'Trash Can', 'Bicycle', 'Boat',
-        'Bus', 'Car', 'Caravan', 'Motorcycle', 'On Rails', 'Other Vehicle',
-        'Trailer', 'Truck', 'Vehicle Group', 'Wheeled Slow', 'Water Valve',
-        'Car Mount', 'Dynamic', 'Ego Vehicle', 'Ground', 'Static', 'Unlabeled'
-    ]
-
-
-def mapillary_v2_palette():
-    """mapillary_v2_ palette for external use."""
-    return [[165, 42, 42], [0, 192, 0], [250, 170, 31], [250, 170, 32],
-            [196, 196, 196], [190, 153, 153], [180, 165, 180], [90, 120, 150],
-            [250, 170, 33], [250, 170, 34], [128, 128, 128], [250, 170, 35],
-            [102, 102, 156], [128, 64, 255], [140, 140, 200], [170, 170, 170],
-            [250, 170, 36], [250, 170, 160], [250, 170, 37], [96, 96, 96],
-            [230, 150, 140], [128, 64, 128], [110, 110, 110], [110, 110, 110],
-            [244, 35, 232], [128, 196, 128], [150, 100, 100], [70, 70, 70],
-            [150, 150, 150], [150, 120, 90], [220, 20, 60], [220, 20, 60],
-            [255, 0, 0], [255, 0, 100], [255, 0, 200], [255, 255, 255],
-            [255, 255, 255], [250, 170, 29], [250, 170, 28], [250, 170, 26],
-            [250, 170, 25], [250, 170, 24], [250, 170, 22], [250, 170, 21],
-            [250, 170, 20], [255, 255, 255], [250, 170, 19], [250, 170, 18],
-            [250, 170, 12], [250, 170, 11], [255, 255, 255], [255, 255, 255],
-            [250, 170, 16], [250, 170, 15], [250, 170, 15], [255, 255, 255],
-            [255, 255, 255], [255, 255, 255], [255, 255, 255], [64, 170, 64],
-            [230, 160, 50], [70, 130, 180], [190, 255, 255], [152, 251, 152],
-            [107, 142, 35], [0, 170, 30], [255, 255, 128], [250, 0, 30],
-            [100, 140, 180], [220, 128, 128], [222, 40, 40], [100, 170, 30],
-            [40, 40, 40], [33, 33, 33], [100, 128, 160], [20, 20, 255],
-            [142, 0, 0], [70, 100, 150], [250, 171, 30], [250, 172, 30],
-            [250, 173, 30], [250, 174, 30], [250, 175, 30], [250, 176, 30],
-            [210, 170, 100], [153, 153, 153], [153, 153, 153], [128, 128, 128],
-            [0, 0, 80], [210, 60, 60], [250, 170, 30], [250, 170, 30],
-            [250, 170, 30], [250, 170, 30], [250, 170, 30], [250, 170, 30],
-            [192, 192, 192], [192, 192, 192], [192, 192, 192], [220, 220, 0],
-            [220, 220, 0], [0, 0, 196], [192, 192, 192], [220, 220, 0],
-            [140, 140, 20], [119, 11, 32], [150, 0, 255], [0, 60, 100],
-            [0, 0, 142], [0, 0, 90], [0, 0, 230], [0, 80, 100], [128, 64, 64],
-            [0, 0, 110], [0, 0, 70], [0, 0, 142], [0, 0, 192], [170, 170, 170],
-            [32, 32, 32], [111, 74, 0], [120, 10, 10], [81, 0, 81],
-            [111, 111, 0], [0, 0, 0]]
-
-
-def cityscapes_palette():
-    """Cityscapes palette for external use."""
-    return [[128, 64, 128], [244, 35, 232], [70, 70, 70], [102, 102, 156],
-            [190, 153, 153], [153, 153, 153], [250, 170, 30], [220, 220, 0],
-            [107, 142, 35], [152, 251, 152], [70, 130, 180], [220, 20, 60],
-            [255, 0, 0], [0, 0, 142], [0, 0, 70], [0, 60, 100], [0, 80, 100],
-            [0, 0, 230], [119, 11, 32]]
-
-
-def ade_palette():
-    """ADE20K palette for external use."""
-    return [[120, 120, 120], [180, 120, 120], [6, 230, 230], [80, 50, 50],
-            [4, 200, 3], [120, 120, 80], [140, 140, 140], [204, 5, 255],
-            [230, 230, 230], [4, 250, 7], [224, 5, 255], [235, 255, 7],
-            [150, 5, 61], [120, 120, 70], [8, 255, 51], [255, 6, 82],
-            [143, 255, 140], [204, 255, 4], [255, 51, 7], [204, 70, 3],
-            [0, 102, 200], [61, 230, 250], [255, 6, 51], [11, 102, 255],
-            [255, 7, 71], [255, 9, 224], [9, 7, 230], [220, 220, 220],
-            [255, 9, 92], [112, 9, 255], [8, 255, 214], [7, 255, 224],
-            [255, 184, 6], [10, 255, 71], [255, 41, 10], [7, 255, 255],
-            [224, 255, 8], [102, 8, 255], [255, 61, 6], [255, 194, 7],
-            [255, 122, 8], [0, 255, 20], [255, 8, 41], [255, 5, 153],
-            [6, 51, 255], [235, 12, 255], [160, 150, 20], [0, 163, 255],
-            [140, 140, 140], [250, 10, 15], [20, 255, 0], [31, 255, 0],
-            [255, 31, 0], [255, 224, 0], [153, 255, 0], [0, 0, 255],
-            [255, 71, 0], [0, 235, 255], [0, 173, 255], [31, 0, 255],
-            [11, 200, 200], [255, 82, 0], [0, 255, 245], [0, 61, 255],
-            [0, 255, 112], [0, 255, 133], [255, 0, 0], [255, 163, 0],
-            [255, 102, 0], [194, 255, 0], [0, 143, 255], [51, 255, 0],
-            [0, 82, 255], [0, 255, 41], [0, 255, 173], [10, 0, 255],
-            [173, 255, 0], [0, 255, 153], [255, 92, 0], [255, 0, 255],
-            [255, 0, 245], [255, 0, 102], [255, 173, 0], [255, 0, 20],
-            [255, 184, 184], [0, 31, 255], [0, 255, 61], [0, 71, 255],
-            [255, 0, 204], [0, 255, 194], [0, 255, 82], [0, 10, 255],
-            [0, 112, 255], [51, 0, 255], [0, 194, 255], [0, 122, 255],
-            [0, 255, 163], [255, 153, 0], [0, 255, 10], [255, 112, 0],
-            [143, 255, 0], [82, 0, 255], [163, 255, 0], [255, 235, 0],
-            [8, 184, 170], [133, 0, 255], [0, 255, 92], [184, 0, 255],
-            [255, 0, 31], [0, 184, 255], [0, 214, 255], [255, 0, 112],
-            [92, 255, 0], [0, 224, 255], [112, 224, 255], [70, 184, 160],
-            [163, 0, 255], [153, 0, 255], [71, 255, 0], [255, 0, 163],
-            [255, 204, 0], [255, 0, 143], [0, 255, 235], [133, 255, 0],
-            [255, 0, 235], [245, 0, 255], [255, 0, 122], [255, 245, 0],
-            [10, 190, 212], [214, 255, 0], [0, 204, 255], [20, 0, 255],
-            [255, 255, 0], [0, 153, 255], [0, 41, 255], [0, 255, 204],
-            [41, 0, 255], [41, 255, 0], [173, 0, 255], [0, 245, 255],
-            [71, 0, 255], [122, 0, 255], [0, 255, 184], [0, 92, 255],
-            [184, 255, 0], [0, 133, 255], [255, 214, 0], [25, 194, 194],
-            [102, 255, 0], [92, 0, 255]]
-
-
-def voc_palette():
-    """Pascal VOC palette for external use."""
-    return [[0, 0, 0], [128, 0, 0], [0, 128, 0], [128, 128, 0], [0, 0, 128],
-            [128, 0, 128], [0, 128, 128], [128, 128, 128], [64, 0, 0],
-            [192, 0, 0], [64, 128, 0], [192, 128, 0], [64, 0, 128],
-            [192, 0, 128], [64, 128, 128], [192, 128, 128], [0, 64, 0],
-            [128, 64, 0], [0, 192, 0], [128, 192, 0], [0, 64, 128]]
-
-
-def pcontext_palette():
-    """Pascal Context palette for external use."""
-    return [[180, 120, 120], [6, 230, 230], [80, 50, 50], [4, 200, 3],
-            [120, 120, 80], [140, 140, 140], [204, 5, 255], [230, 230, 230],
-            [4, 250, 7], [224, 5, 255], [235, 255, 7], [150, 5, 61],
-            [120, 120, 70], [8, 255, 51], [255, 6, 82], [143, 255, 140],
-            [204, 255, 4], [255, 51, 7], [204, 70, 3], [0, 102, 200],
-            [61, 230, 250], [255, 6, 51], [11, 102, 255], [255, 7, 71],
-            [255, 9, 224], [9, 7, 230], [220, 220, 220], [255, 9, 92],
-            [112, 9, 255], [8, 255, 214], [7, 255, 224], [255, 184, 6],
-            [10, 255, 71], [255, 41, 10], [7, 255, 255], [224, 255, 8],
-            [102, 8, 255], [255, 61, 6], [255, 194, 7], [255, 122, 8],
-            [0, 255, 20], [255, 8, 41], [255, 5, 153], [6, 51, 255],
-            [235, 12, 255], [160, 150, 20], [0, 163, 255], [140, 140, 140],
-            [250, 10, 15], [20, 255, 0], [31, 255, 0], [255, 31, 0],
-            [255, 224, 0], [153, 255, 0], [0, 0, 255], [255, 71, 0],
-            [0, 235, 255], [0, 173, 255], [31, 0, 255]]
-
-
-def cocostuff_palette():
-    """CocoStuff palette for external use."""
-    return [[0, 192, 64], [0, 192, 64], [0, 64, 96], [128, 192, 192],
-            [0, 64, 64], [0, 192, 224], [0, 192, 192], [128, 192, 64],
-            [0, 192, 96], [128, 192, 64], [128, 32, 192], [0, 0, 224],
-            [0, 0, 64], [0, 160, 192], [128, 0, 96], [128, 0, 192],
-            [0, 32, 192], [128, 128, 224], [0, 0, 192], [128, 160, 192],
-            [128, 128, 0], [128, 0, 32], [128, 32, 0], [128, 0, 128],
-            [64, 128, 32], [0, 160, 0], [0, 0, 0], [192, 128, 160], [0, 32, 0],
-            [0, 128, 128], [64, 128, 160], [128, 160, 0], [0, 128, 0],
-            [192, 128, 32], [128, 96, 128], [0, 0, 128], [64, 0, 32],
-            [0, 224, 128], [128, 0, 0], [192, 0, 160], [0, 96, 128],
-            [128, 128, 128], [64, 0, 160], [128, 224, 128], [128, 128, 64],
-            [192, 0, 32], [128, 96, 0], [128, 0, 192], [0, 128, 32],
-            [64, 224, 0], [0, 0, 64], [128, 128, 160], [64, 96, 0],
-            [0, 128, 192], [0, 128, 160], [192, 224, 0], [0, 128, 64],
-            [128, 128, 32], [192, 32, 128], [0, 64, 192], [0, 0, 32],
-            [64, 160, 128], [128, 64, 64], [128, 0, 160], [64, 32, 128],
-            [128, 192, 192], [0, 0, 160], [192, 160, 128], [128, 192, 0],
-            [128, 0, 96], [192, 32, 0], [128, 64, 128], [64, 128, 96],
-            [64, 160, 0], [0, 64, 0], [192, 128, 224], [64, 32, 0],
-            [0, 192, 128], [64, 128, 224], [192, 160, 0], [0, 192, 0],
-            [192, 128, 96], [192, 96, 128], [0, 64, 128], [64, 0, 96],
-            [64, 224, 128], [128, 64, 0], [192, 0, 224], [64, 96, 128],
-            [128, 192, 128], [64, 0, 224], [192, 224, 128], [128, 192, 64],
-            [192, 0, 96], [192, 96, 0], [128, 64, 192], [0, 128, 96],
-            [0, 224, 0], [64, 64, 64], [128, 128, 224], [0, 96, 0],
-            [64, 192, 192], [0, 128, 224], [128, 224, 0], [64, 192, 64],
-            [128, 128, 96], [128, 32, 128], [64, 0, 192], [0, 64, 96],
-            [0, 160, 128], [192, 0, 64], [128, 64, 224], [0, 32, 128],
-            [192, 128, 192], [0, 64, 224], [128, 160, 128], [192, 128, 0],
-            [128, 64, 32], [128, 32, 64], [192, 0, 128], [64, 192, 32],
-            [0, 160, 64], [64, 0, 0], [192, 192, 160], [0, 32, 64],
-            [64, 128, 128], [64, 192, 160], [128, 160, 64], [64, 128, 0],
-            [192, 192, 32], [128, 96, 192], [64, 0, 128], [64, 64, 32],
-            [0, 224, 192], [192, 0, 0], [192, 64, 160], [0, 96, 192],
-            [192, 128, 128], [64, 64, 160], [128, 224, 192], [192, 128, 64],
-            [192, 64, 32], [128, 96, 64], [192, 0, 192], [0, 192, 32],
-            [64, 224, 64], [64, 0, 64], [128, 192, 160], [64, 96, 64],
-            [64, 128, 192], [0, 192, 160], [192, 224, 64], [64, 128, 64],
-            [128, 192, 32], [192, 32, 192], [64, 64, 192], [0, 64, 32],
-            [64, 160, 192], [192, 64, 64], [128, 64, 160], [64, 32, 192],
-            [192, 192, 192], [0, 64, 160], [192, 160, 192], [192, 192, 0],
-            [128, 64, 96], [192, 32, 64], [192, 64, 128], [64, 192, 96],
-            [64, 160, 64], [64, 64, 0]]
-
-
-def loveda_palette():
-    """LoveDA palette for external use."""
-    return [[255, 255, 255], [255, 0, 0], [255, 255, 0], [0, 0, 255],
-            [159, 129, 183], [0, 255, 0], [255, 195, 128]]
-
-
-def potsdam_palette():
-    """Potsdam palette for external use."""
-    return [[255, 255, 255], [0, 0, 255], [0, 255, 255], [0, 255, 0],
-            [255, 255, 0], [255, 0, 0]]
-
-
-def vaihingen_palette():
-    """Vaihingen palette for external use."""
-    return [[255, 255, 255], [0, 0, 255], [0, 255, 255], [0, 255, 0],
-            [255, 255, 0], [255, 0, 0]]
-
-
-def isaid_palette():
-    """iSAID palette for external use."""
-    return [[0, 0, 0], [0, 0, 63], [0, 63, 63], [0, 63, 0], [0, 63, 127],
-            [0, 63, 191], [0, 63, 255], [0, 127, 63], [0, 127,
-                                                       127], [0, 0, 127],
-            [0, 0, 191], [0, 0, 255], [0, 191, 127], [0, 127, 191],
-            [0, 127, 255], [0, 100, 155]]
-
-
-def stare_palette():
-    """STARE palette for external use."""
-    return [[120, 120, 120], [6, 230, 230]]
-
-
-def synapse_palette():
-    """Synapse palette for external use."""
-    return [[0, 0, 0], [0, 0, 255], [0, 255, 0], [255, 0, 0], [0, 255, 255],
-            [255, 0, 255], [255, 255, 0], [60, 255, 255], [240, 240, 240]]
-
-
-def synapse_classes():
-    """Synapse class names for external use."""
-    return [
-        'background', 'aorta', 'gallbladder', 'left_kidney', 'right_kidney',
-        'liver', 'pancreas', 'spleen', 'stomach'
-    ]
-
-
-def lip_classes():
-    """LIP class names for external use."""
-    return [
-        'background', 'hat', 'hair', 'glove', 'sunglasses', 'upperclothes',
-        'dress', 'coat', 'socks', 'pants', 'jumpsuits', 'scarf', 'skirt',
-        'face', 'leftArm', 'rightArm', 'leftLeg', 'rightLeg', 'leftShoe',
-        'rightShoe'
-    ]
-
-
-def lip_palette():
-    """LIP palette for external use."""
-    return [
-        'Background', 'Hat', 'Hair', 'Glove', 'Sunglasses', 'UpperClothes',
-        'Dress', 'Coat', 'Socks', 'Pants', 'Jumpsuits', 'Scarf', 'Skirt',
-        'Face', 'Left-arm', 'Right-arm', 'Left-leg', 'Right-leg', 'Left-shoe',
-        'Right-shoe'
-    ]
-
-
-def bdd100k_classes():
-    """BDD100K class names for external use(the class name is compatible with
-    Cityscapes )."""
-    return [
-        'road', 'sidewalk', 'building', 'wall', 'fence', 'pole',
-        'traffic light', 'traffic sign', 'vegetation', 'terrain', 'sky',
-        'person', 'rider', 'car', 'truck', 'bus', 'train', 'motorcycle',
-        'bicycle'
-    ]
-
-
-def bdd100k_palette():
-    """bdd100k palette for external use(same with cityscapes)"""
-    return [[128, 64, 128], [244, 35, 232], [70, 70, 70], [102, 102, 156],
-            [190, 153, 153], [153, 153, 153], [250, 170, 30], [220, 220, 0],
-            [107, 142, 35], [152, 251, 152], [70, 130, 180], [220, 20, 60],
-            [255, 0, 0], [0, 0, 142], [0, 0, 70], [0, 60, 100], [0, 80, 100],
-            [0, 0, 230], [119, 11, 32]]
-
-
-def hsidrive_classes():
-    """HSI Drive 2.0 class names for external use."""
-    return [
-        'unlabelled', 'road', 'road marks', 'vegetation', 'painted metal',
-        'sky', 'concrete', 'pedestrian', 'water', 'unpainted metal', 'glass'
-    ]
-
-
-def hsidrive_palette():
-    """HSI Drive 2.0 palette for external use."""
-    return [[0, 0, 0], [77, 77, 77], [255, 255, 255], [0, 255, 0], [255, 0, 0],
-            [0, 0, 255], [102, 51, 0], [255, 255, 0], [0, 207, 250],
-            [255, 166, 0], [0, 204, 204]]
-
-
-dataset_aliases = {
-    'cityscapes': ['cityscapes'],
-    'ade': ['ade', 'ade20k'],
-    'voc': ['voc', 'pascal_voc', 'voc12', 'voc12aug'],
-    'pcontext': ['pcontext', 'pascal_context', 'voc2010'],
-    'loveda': ['loveda'],
-    'potsdam': ['potsdam'],
-    'vaihingen': ['vaihingen'],
-    'cocostuff': [
-        'cocostuff', 'cocostuff10k', 'cocostuff164k', 'coco-stuff',
-        'coco-stuff10k', 'coco-stuff164k', 'coco_stuff', 'coco_stuff10k',
-        'coco_stuff164k'
-    ],
-    'isaid': ['isaid', 'iSAID'],
-    'stare': ['stare', 'STARE'],
-    'lip': ['LIP', 'lip'],
-    'mapillary_v1': ['mapillary_v1'],
-    'mapillary_v2': ['mapillary_v2'],
-    'bdd100k': ['bdd100k'],
-    'hsidrive': [
-        'hsidrive', 'HSIDrive', 'HSI-Drive', 'hsidrive20', 'HSIDrive20',
-        'HSI-Drive20'
-    ],
-    'xray': ['xray', 'XRay'],
-}
-
-
-def get_classes(dataset):
-    """Get class names of a dataset."""
-    alias2name = {}
-    for name, aliases in dataset_aliases.items():
-        for alias in aliases:
-            alias2name[alias] = name
-            
-    if is_str(dataset):
-        if dataset in alias2name:
-            labels = eval(alias2name[dataset] + '_classes()')
-        else:
-            raise ValueError(f'Unrecognized dataset: {dataset}')
-    else:
-        raise TypeError(f'dataset must a str, but got {type(dataset)}')
-    return labels
-
-
-def get_palette(dataset):
-    """Get class palette (RGB) of a dataset."""
-    alias2name = {}
-    for name, aliases in dataset_aliases.items():
-        for alias in aliases:
-            alias2name[alias] = name
-
-    if is_str(dataset):
-        if dataset in alias2name:
-            labels = eval(alias2name[dataset] + '_palette()')
-        else:
-            raise ValueError(f'Unrecognized dataset: {dataset}')
-    else:
-        raise TypeError(f'dataset must a str, but got {type(dataset)}')
-    return labels
diff --git a/mmsegmentation/mmseg/utils/collect_env.py b/mmsegmentation/mmseg/utils/collect_env.py
deleted file mode 100644
index d5d6ea2..0000000
--- a/mmsegmentation/mmseg/utils/collect_env.py
+++ /dev/null
@@ -1,18 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmengine.utils import get_git_hash
-from mmengine.utils.dl_utils import collect_env as collect_base_env
-
-import mmseg
-
-
-def collect_env():
-    """Collect the information of the running environments."""
-    env_info = collect_base_env()
-    env_info['MMSegmentation'] = f'{mmseg.__version__}+{get_git_hash()[:7]}'
-
-    return env_info
-
-
-if __name__ == '__main__':
-    for name, val in collect_env().items():
-        print(f'{name}: {val}')
diff --git a/mmsegmentation/mmseg/utils/get_templates.py b/mmsegmentation/mmseg/utils/get_templates.py
deleted file mode 100644
index 7e9032b..0000000
--- a/mmsegmentation/mmseg/utils/get_templates.py
+++ /dev/null
@@ -1,109 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from typing import List
-
-PREDEFINED_TEMPLATES = {
-    'imagenet': [
-        'a bad photo of a {}.',
-        'a photo of many {}.',
-        'a sculpture of a {}.',
-        'a photo of the hard to see {}.',
-        'a low resolution photo of the {}.',
-        'a rendering of a {}.',
-        'graffiti of a {}.',
-        'a bad photo of the {}.',
-        'a cropped photo of the {}.',
-        'a tattoo of a {}.',
-        'the embroidered {}.',
-        'a photo of a hard to see {}.',
-        'a bright photo of a {}.',
-        'a photo of a clean {}.',
-        'a photo of a dirty {}.',
-        'a dark photo of the {}.',
-        'a drawing of a {}.',
-        'a photo of my {}.',
-        'the plastic {}.',
-        'a photo of the cool {}.',
-        'a close-up photo of a {}.',
-        'a black and white photo of the {}.',
-        'a painting of the {}.',
-        'a painting of a {}.',
-        'a pixelated photo of the {}.',
-        'a sculpture of the {}.',
-        'a bright photo of the {}.',
-        'a cropped photo of a {}.',
-        'a plastic {}.',
-        'a photo of the dirty {}.',
-        'a jpeg corrupted photo of a {}.',
-        'a blurry photo of the {}.',
-        'a photo of the {}.',
-        'a good photo of the {}.',
-        'a rendering of the {}.',
-        'a {} in a video game.',
-        'a photo of one {}.',
-        'a doodle of a {}.',
-        'a close-up photo of the {}.',
-        'a photo of a {}.',
-        'the origami {}.',
-        'the {} in a video game.',
-        'a sketch of a {}.',
-        'a doodle of the {}.',
-        'a origami {}.',
-        'a low resolution photo of a {}.',
-        'the toy {}.',
-        'a rendition of the {}.',
-        'a photo of the clean {}.',
-        'a photo of a large {}.',
-        'a rendition of a {}.',
-        'a photo of a nice {}.',
-        'a photo of a weird {}.',
-        'a blurry photo of a {}.',
-        'a cartoon {}.',
-        'art of a {}.',
-        'a sketch of the {}.',
-        'a embroidered {}.',
-        'a pixelated photo of a {}.',
-        'itap of the {}.',
-        'a jpeg corrupted photo of the {}.',
-        'a good photo of a {}.',
-        'a plushie {}.',
-        'a photo of the nice {}.',
-        'a photo of the small {}.',
-        'a photo of the weird {}.',
-        'the cartoon {}.',
-        'art of the {}.',
-        'a drawing of the {}.',
-        'a photo of the large {}.',
-        'a black and white photo of a {}.',
-        'the plushie {}.',
-        'a dark photo of a {}.',
-        'itap of a {}.',
-        'graffiti of the {}.',
-        'a toy {}.',
-        'itap of my {}.',
-        'a photo of a cool {}.',
-        'a photo of a small {}.',
-        'a tattoo of the {}.',
-    ],
-    'vild': [
-        'a photo of a {}.',
-        'This is a photo of a {}',
-        'There is a {} in the scene',
-        'There is the {} in the scene',
-        'a photo of a {} in the scene',
-        'a photo of a small {}.',
-        'a photo of a medium {}.',
-        'a photo of a large {}.',
-        'This is a photo of a small {}.',
-        'This is a photo of a medium {}.',
-        'This is a photo of a large {}.',
-        'There is a small {} in the scene.',
-        'There is a medium {} in the scene.',
-        'There is a large {} in the scene.',
-    ],
-}
-
-
-def get_predefined_templates(template_set_name: str) -> List[str]:
-    if template_set_name not in PREDEFINED_TEMPLATES:
-        raise ValueError(f'Template set {template_set_name} not found')
-    return PREDEFINED_TEMPLATES[template_set_name]
diff --git a/mmsegmentation/mmseg/utils/io.py b/mmsegmentation/mmseg/utils/io.py
deleted file mode 100644
index 7029c3c..0000000
--- a/mmsegmentation/mmseg/utils/io.py
+++ /dev/null
@@ -1,42 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import gzip
-import io
-import pickle
-
-import cv2
-import numpy as np
-
-
-def datafrombytes(content: bytes, backend: str = 'numpy') -> np.ndarray:
-    """Data decoding from bytes.
-
-    Args:
-        content (bytes): The data bytes got from files or other streams.
-        backend (str): The data decoding backend type. Options are 'numpy',
-            'nifti', 'cv2' and 'pickle'. Defaults to 'numpy'.
-
-    Returns:
-        numpy.ndarray: Loaded data array.
-    """
-    if backend == 'pickle':
-        data = pickle.loads(content)
-    else:
-        with io.BytesIO(content) as f:
-            if backend == 'nifti':
-                f = gzip.open(f)
-                try:
-                    from nibabel import FileHolder, Nifti1Image
-                except ImportError:
-                    print('nifti files io depends on nibabel, please run'
-                          '`pip install nibabel` to install it')
-                fh = FileHolder(fileobj=f)
-                data = Nifti1Image.from_file_map({'header': fh, 'image': fh})
-                data = Nifti1Image.from_bytes(data.to_bytes()).get_fdata()
-            elif backend == 'numpy':
-                data = np.load(f)
-            elif backend == 'cv2':
-                data = np.frombuffer(f.read(), dtype=np.uint8)
-                data = cv2.imdecode(data, cv2.IMREAD_UNCHANGED)
-            else:
-                raise ValueError
-    return data
diff --git a/mmsegmentation/mmseg/utils/mask_classification.py b/mmsegmentation/mmseg/utils/mask_classification.py
deleted file mode 100644
index 205d525..0000000
--- a/mmsegmentation/mmseg/utils/mask_classification.py
+++ /dev/null
@@ -1,205 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from typing import List, Tuple
-
-import torch
-from mmcv.ops import point_sample
-from mmengine.structures import InstanceData
-from torch import Tensor
-
-from mmseg.registry import TASK_UTILS
-from mmseg.utils import ConfigType, SampleList
-
-
-def seg_data_to_instance_data(ignore_index: int,
-                              batch_data_samples: SampleList):
-    """Convert the paradigm of ground truth from semantic segmentation to
-    instance segmentation.
-
-    Args:
-        ignore_index (int): The label index to be ignored.
-        batch_data_samples (List[SegDataSample]): The Data
-            Samples. It usually includes information such as
-            `gt_sem_seg`.
-
-    Returns:
-        tuple[Tensor]: A tuple contains two lists.
-            - batch_gt_instances (List[InstanceData]): Batch of
-                gt_instance. It usually includes ``labels``, each is
-                unique ground truth label id of images, with
-                shape (num_gt, ) and ``masks``, each is ground truth
-                masks of each instances of a image, shape (num_gt, h, w).
-            - batch_img_metas (List[Dict]): List of image meta information.
-    """
-    batch_gt_instances = []
-
-    for data_sample in batch_data_samples:
-        gt_sem_seg = data_sample.gt_sem_seg.data
-        classes = torch.unique(
-            gt_sem_seg,
-            sorted=False,
-            return_inverse=False,
-            return_counts=False)
-
-        # remove ignored region
-        gt_labels = classes[classes != ignore_index]
-
-        masks = []
-        for class_id in gt_labels:
-            masks.append(gt_sem_seg == class_id)
-
-        if len(masks) == 0:
-            gt_masks = torch.zeros(
-                (0, gt_sem_seg.shape[-2],
-                 gt_sem_seg.shape[-1])).to(gt_sem_seg).long()
-        else:
-            gt_masks = torch.stack(masks).squeeze(1).long()
-
-        instance_data = InstanceData(labels=gt_labels, masks=gt_masks)
-        batch_gt_instances.append(instance_data)
-    return batch_gt_instances
-
-
-class MatchMasks:
-    """Match the predictions to category labels.
-
-    Args:
-        num_points (int): the number of sampled points to compute cost.
-        num_queries (int): the number of prediction masks.
-        num_classes (int): the number of classes.
-        assigner (BaseAssigner): the assigner to compute matching.
-    """
-
-    def __init__(self,
-                 num_points: int,
-                 num_queries: int,
-                 num_classes: int,
-                 assigner: ConfigType = None):
-        assert assigner is not None, "\'assigner\' in decode_head.train_cfg" \
-                                     'cannot be None'
-        assert num_points > 0, 'num_points should be a positive integer.'
-        self.num_points = num_points
-        self.num_queries = num_queries
-        self.num_classes = num_classes
-        self.assigner = TASK_UTILS.build(assigner)
-
-    def get_targets(self, cls_scores: List[Tensor], mask_preds: List[Tensor],
-                    batch_gt_instances: List[InstanceData]) -> Tuple:
-        """Compute best mask matches for all images for a decoder layer.
-
-        Args:
-            cls_scores (List[Tensor]): Mask score logits from a single
-                decoder layer for all images. Each with shape (num_queries,
-                cls_out_channels).
-            mask_preds (List[Tensor]): Mask logits from a single decoder
-                layer for all images. Each with shape (num_queries, h, w).
-            batch_gt_instances (List[InstanceData]): each contains
-                ``labels`` and ``masks``.
-
-        Returns:
-            tuple: a tuple containing the following targets.
-
-                - labels (List[Tensor]): Labels of all images.\
-                    Each with shape (num_queries, ).
-                - mask_targets (List[Tensor]): Mask targets of\
-                    all images. Each with shape (num_queries, h, w).
-                - mask_weights (List[Tensor]): Mask weights of\
-                    all images. Each with shape (num_queries, ).
-                - avg_factor (int): Average factor that is used to
-                    average the loss. `avg_factor` is usually equal
-                    to the number of positive priors.
-        """
-        batch_size = cls_scores.shape[0]
-        results = dict({
-            'labels': [],
-            'mask_targets': [],
-            'mask_weights': [],
-        })
-        for i in range(batch_size):
-            labels, mask_targets, mask_weights\
-                = self._get_targets_single(cls_scores[i],
-                                           mask_preds[i],
-                                           batch_gt_instances[i])
-            results['labels'].append(labels)
-            results['mask_targets'].append(mask_targets)
-            results['mask_weights'].append(mask_weights)
-
-        # shape (batch_size, num_queries)
-        labels = torch.stack(results['labels'], dim=0)
-        # shape (batch_size, num_gts, h, w)
-        mask_targets = torch.cat(results['mask_targets'], dim=0)
-        # shape (batch_size, num_queries)
-        mask_weights = torch.stack(results['mask_weights'], dim=0)
-
-        avg_factor = sum(
-            [len(gt_instances.labels) for gt_instances in batch_gt_instances])
-
-        res = (labels, mask_targets, mask_weights, avg_factor)
-
-        return res
-
-    def _get_targets_single(self, cls_score: Tensor, mask_pred: Tensor,
-                            gt_instances: InstanceData) \
-            -> Tuple[Tensor, Tensor, Tensor]:
-        """Compute a set of best mask matches for one image.
-
-        Args:
-            cls_score (Tensor): Mask score logits from a single decoder layer
-                for one image. Shape (num_queries, cls_out_channels).
-            mask_pred (Tensor): Mask logits for a single decoder layer for one
-                image. Shape (num_queries, h, w).
-            gt_instances (:obj:`InstanceData`): It contains ``labels`` and
-                ``masks``.
-
-        Returns:
-            tuple[Tensor]: A tuple containing the following for one image.
-
-                - labels (Tensor): Labels of each image. \
-                    shape (num_queries, ).
-                - mask_targets (Tensor): Mask targets of each image. \
-                    shape (num_queries, h, w).
-                - mask_weights (Tensor): Mask weights of each image. \
-                    shape (num_queries, ).
-        """
-        gt_labels = gt_instances.labels
-        gt_masks = gt_instances.masks
-        # when "gt_labels" is empty, classify all queries to background
-        if len(gt_labels) == 0:
-            labels = gt_labels.new_full((self.num_queries, ),
-                                        self.num_classes,
-                                        dtype=torch.long)
-            mask_targets = gt_labels
-            mask_weights = gt_labels.new_zeros((self.num_queries, ))
-            return labels, mask_targets, mask_weights
-        # sample points
-        num_queries = cls_score.shape[0]
-        num_gts = gt_labels.shape[0]
-
-        point_coords = torch.rand((1, self.num_points, 2),
-                                  device=cls_score.device)
-        # shape (num_queries, num_points)
-        mask_points_pred = point_sample(
-            mask_pred.unsqueeze(1), point_coords.repeat(num_queries, 1,
-                                                        1)).squeeze(1)
-        # shape (num_gts, num_points)
-        gt_points_masks = point_sample(
-            gt_masks.unsqueeze(1).float(), point_coords.repeat(num_gts, 1,
-                                                               1)).squeeze(1)
-
-        sampled_gt_instances = InstanceData(
-            labels=gt_labels, masks=gt_points_masks)
-        sampled_pred_instances = InstanceData(
-            scores=cls_score, masks=mask_points_pred)
-        # assign and sample
-        matched_quiery_inds, matched_label_inds = self.assigner.assign(
-            pred_instances=sampled_pred_instances,
-            gt_instances=sampled_gt_instances)
-        labels = gt_labels.new_full((self.num_queries, ),
-                                    self.num_classes,
-                                    dtype=torch.long)
-        labels[matched_quiery_inds] = gt_labels[matched_label_inds]
-
-        mask_weights = gt_labels.new_zeros((self.num_queries, ))
-        mask_weights[matched_quiery_inds] = 1
-        mask_targets = gt_masks[matched_label_inds]
-
-        return labels, mask_targets, mask_weights
diff --git a/mmsegmentation/mmseg/utils/misc.py b/mmsegmentation/mmseg/utils/misc.py
deleted file mode 100644
index dfc469e..0000000
--- a/mmsegmentation/mmseg/utils/misc.py
+++ /dev/null
@@ -1,128 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from typing import List, Optional, Union
-
-import numpy as np
-import torch
-import torch.nn.functional as F
-
-from .typing_utils import SampleList
-
-
-def add_prefix(inputs, prefix):
-    """Add prefix for dict.
-
-    Args:
-        inputs (dict): The input dict with str keys.
-        prefix (str): The prefix to add.
-
-    Returns:
-
-        dict: The dict with keys updated with ``prefix``.
-    """
-
-    outputs = dict()
-    for name, value in inputs.items():
-        outputs[f'{prefix}.{name}'] = value
-
-    return outputs
-
-
-def stack_batch(inputs: List[torch.Tensor],
-                data_samples: Optional[SampleList] = None,
-                size: Optional[tuple] = None,
-                size_divisor: Optional[int] = None,
-                pad_val: Union[int, float] = 0,
-                seg_pad_val: Union[int, float] = 255) -> torch.Tensor:
-    """Stack multiple inputs to form a batch and pad the images and gt_sem_segs
-    to the max shape use the right bottom padding mode.
-
-    Args:
-        inputs (List[Tensor]): The input multiple tensors. each is a
-            CHW 3D-tensor.
-        data_samples (list[:obj:`SegDataSample`]): The list of data samples.
-            It usually includes information such as `gt_sem_seg`.
-        size (tuple, optional): Fixed padding size.
-        size_divisor (int, optional): The divisor of padded size.
-        pad_val (int, float): The padding value. Defaults to 0
-        seg_pad_val (int, float): The padding value. Defaults to 255
-
-    Returns:
-       Tensor: The 4D-tensor.
-       List[:obj:`SegDataSample`]: After the padding of the gt_seg_map.
-    """
-    assert isinstance(inputs, list), \
-        f'Expected input type to be list, but got {type(inputs)}'
-    assert len({tensor.ndim for tensor in inputs}) == 1, \
-        f'Expected the dimensions of all inputs must be the same, ' \
-        f'but got {[tensor.ndim for tensor in inputs]}'
-    assert inputs[0].ndim == 3, f'Expected tensor dimension to be 3, ' \
-        f'but got {inputs[0].ndim}'
-    assert len({tensor.shape[0] for tensor in inputs}) == 1, \
-        f'Expected the channels of all inputs must be the same, ' \
-        f'but got {[tensor.shape[0] for tensor in inputs]}'
-
-    # only one of size and size_divisor should be valid
-    assert (size is not None) ^ (size_divisor is not None), \
-        'only one of size and size_divisor should be valid'
-
-    padded_inputs = []
-    padded_samples = []
-    inputs_sizes = [(img.shape[-2], img.shape[-1]) for img in inputs]
-    max_size = np.stack(inputs_sizes).max(0)
-    if size_divisor is not None and size_divisor > 1:
-        # the last two dims are H,W, both subject to divisibility requirement
-        max_size = (max_size +
-                    (size_divisor - 1)) // size_divisor * size_divisor
-
-    for i in range(len(inputs)):
-        tensor = inputs[i]
-        if size is not None:
-            width = max(size[-1] - tensor.shape[-1], 0)
-            height = max(size[-2] - tensor.shape[-2], 0)
-            # (padding_left, padding_right, padding_top, padding_bottom)
-            padding_size = (0, width, 0, height)
-        elif size_divisor is not None:
-            width = max(max_size[-1] - tensor.shape[-1], 0)
-            height = max(max_size[-2] - tensor.shape[-2], 0)
-            padding_size = (0, width, 0, height)
-        else:
-            padding_size = [0, 0, 0, 0]
-
-        # pad img
-        pad_img = F.pad(tensor, padding_size, value=pad_val)
-        padded_inputs.append(pad_img)
-        # pad gt_sem_seg
-        if data_samples is not None:
-            data_sample = data_samples[i]
-            pad_shape = None
-            if 'gt_sem_seg' in data_sample:
-                gt_sem_seg = data_sample.gt_sem_seg.data
-                del data_sample.gt_sem_seg.data
-                data_sample.gt_sem_seg.data = F.pad(
-                    gt_sem_seg, padding_size, value=seg_pad_val)
-                pad_shape = data_sample.gt_sem_seg.shape
-            if 'gt_edge_map' in data_sample:
-                gt_edge_map = data_sample.gt_edge_map.data
-                del data_sample.gt_edge_map.data
-                data_sample.gt_edge_map.data = F.pad(
-                    gt_edge_map, padding_size, value=seg_pad_val)
-                pad_shape = data_sample.gt_edge_map.shape
-            if 'gt_depth_map' in data_sample:
-                gt_depth_map = data_sample.gt_depth_map.data
-                del data_sample.gt_depth_map.data
-                data_sample.gt_depth_map.data = F.pad(
-                    gt_depth_map, padding_size, value=seg_pad_val)
-                pad_shape = data_sample.gt_depth_map.shape
-            data_sample.set_metainfo({
-                'img_shape': tensor.shape[-2:],
-                'pad_shape': pad_shape,
-                'padding_size': padding_size
-            })
-            padded_samples.append(data_sample)
-        else:
-            padded_samples.append(
-                dict(
-                    img_padding_size=padding_size,
-                    pad_shape=pad_img.shape[-2:]))
-
-    return torch.stack(padded_inputs, dim=0), padded_samples
diff --git a/mmsegmentation/mmseg/utils/set_env.py b/mmsegmentation/mmseg/utils/set_env.py
deleted file mode 100644
index c948950..0000000
--- a/mmsegmentation/mmseg/utils/set_env.py
+++ /dev/null
@@ -1,40 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import datetime
-import warnings
-
-from mmengine import DefaultScope
-
-
-def register_all_modules(init_default_scope: bool = True) -> None:
-    """Register all modules in mmseg into the registries.
-
-    Args:
-        init_default_scope (bool): Whether initialize the mmseg default scope.
-            When `init_default_scope=True`, the global default scope will be
-            set to `mmseg`, and all registries will build modules from mmseg's
-            registry node. To understand more about the registry, please refer
-            to https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/registry.md
-            Defaults to True.
-    """  # noqa
-    import mmseg.datasets  # noqa: F401,F403
-    import mmseg.engine  # noqa: F401,F403
-    import mmseg.evaluation  # noqa: F401,F403
-    import mmseg.models  # noqa: F401,F403
-    import mmseg.structures  # noqa: F401,F403
-
-    if init_default_scope:
-        never_created = DefaultScope.get_current_instance() is None \
-                        or not DefaultScope.check_instance_created('mmseg')
-        if never_created:
-            DefaultScope.get_instance('mmseg', scope_name='mmseg')
-            return
-        current_scope = DefaultScope.get_current_instance()
-        if current_scope.scope_name != 'mmseg':
-            warnings.warn('The current default scope '
-                          f'"{current_scope.scope_name}" is not "mmseg", '
-                          '`register_all_modules` will force the current'
-                          'default scope to be "mmseg". If this is not '
-                          'expected, please set `init_default_scope=False`.')
-            # avoid name conflict
-            new_instance_name = f'mmseg-{datetime.datetime.now()}'
-            DefaultScope.get_instance(new_instance_name, scope_name='mmseg')
diff --git a/mmsegmentation/mmseg/utils/tokenizer.py b/mmsegmentation/mmseg/utils/tokenizer.py
deleted file mode 100644
index d56f5fa..0000000
--- a/mmsegmentation/mmseg/utils/tokenizer.py
+++ /dev/null
@@ -1,240 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-"""CLIP tokenizer.
-
-Copied from https://github.com/openai/CLIP. Originally MIT License, Copyright
-(c) 2021 OpenAI.
-"""
-import gzip
-import html
-import os
-from functools import lru_cache
-from typing import List, Union
-
-import ftfy
-import regex as re
-import torch
-
-os.environ['TOKENIZERS_PARALLELISM'] = 'false'
-
-
-@lru_cache()
-def default_bpe():
-    return os.path.join(
-        os.path.dirname(os.path.abspath(__file__)),
-        'bpe_simple_vocab_16e6.txt.gz')
-
-
-@lru_cache()
-def bytes_to_unicode():
-    """Returns list of utf-8 byte and a corresponding list of unicode strings.
-
-    The reversible bpe codes work on unicode strings. This means you need a
-    large # of unicode characters in your vocab if you want to avoid UNKs. When
-    you're at something like a 10B token dataset you end up needing around 5K
-    for decent coverage. This is a significant percentage of your normal, say,
-    32K bpe vocab. To avoid that, we want lookup tables between utf-8 bytes and
-    unicode strings. And avoids mapping to whitespace/control characters the
-    bpe code barfs on.
-    """
-    bs = list(range(ord('!'),
-                    ord('~') + 1)) + list(range(
-                        ord('¡'),
-                        ord('¬') + 1)) + list(range(ord('®'),
-                                                    ord('ÿ') + 1))
-    cs = bs[:]
-    n = 0
-    for b in range(2**8):
-        if b not in bs:
-            bs.append(b)
-            cs.append(2**8 + n)
-            n += 1
-    cs = [chr(n) for n in cs]
-    return dict(zip(bs, cs))
-
-
-def get_pairs(word):
-    """Return set of symbol pairs in a word.
-
-    Word is represented as tuple of symbols (symbols being variable-length
-    strings).
-    """
-    pairs = set()
-    prev_char = word[0]
-    for char in word[1:]:
-        pairs.add((prev_char, char))
-        prev_char = char
-    return pairs
-
-
-def basic_clean(text):
-    text = ftfy.fix_text(text)
-    text = html.unescape(html.unescape(text))
-    return text.strip()
-
-
-def whitespace_clean(text):
-    text = re.sub(r'\s+', ' ', text)
-    text = text.strip()
-    return text
-
-
-class SimpleTokenizer:
-
-    def __init__(self, bpe_path: str = default_bpe(), special_tokens=None):
-        self.byte_encoder = bytes_to_unicode()
-        self.byte_decoder = {v: k for k, v in self.byte_encoder.items()}
-        merges = gzip.open(bpe_path).read().decode('utf-8').split('\n')
-        merges = merges[1:49152 - 256 - 2 + 1]
-        merges = [tuple(merge.split()) for merge in merges]
-        vocab = list(bytes_to_unicode().values())
-        vocab = vocab + [v + '</w>' for v in vocab]
-        for merge in merges:
-            vocab.append(''.join(merge))
-        if not special_tokens:
-            special_tokens = ['<start_of_text>', '<end_of_text>']
-        else:
-            special_tokens = ['<start_of_text>', '<end_of_text>'
-                              ] + special_tokens
-        vocab.extend(special_tokens)
-        self.encoder = dict(zip(vocab, range(len(vocab))))
-        self.decoder = {v: k for k, v in self.encoder.items()}
-        self.bpe_ranks = dict(zip(merges, range(len(merges))))
-        self.cache = {t: t for t in special_tokens}
-        special = '|'.join(special_tokens)
-        self.pat = re.compile(
-            special +
-            r"""|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""",
-            re.IGNORECASE)
-
-        self.vocab_size = len(self.encoder)
-        self.all_special_ids = [self.encoder[t] for t in special_tokens]
-
-    def bpe(self, token):
-        if token in self.cache:
-            return self.cache[token]
-        word = tuple(token[:-1]) + (token[-1] + '</w>', )
-        pairs = get_pairs(word)
-
-        if not pairs:
-            return token + '</w>'
-
-        while True:
-            bigram = min(
-                pairs, key=lambda pair: self.bpe_ranks.get(pair, float('inf')))
-            if bigram not in self.bpe_ranks:
-                break
-            first, second = bigram
-            new_word = []
-            i = 0
-            while i < len(word):
-                try:
-                    j = word.index(first, i)
-                    new_word.extend(word[i:j])
-                    i = j
-                except:  # noqa: E722, E261
-                    new_word.extend(word[i:])
-                    break
-
-                if word[i] == first and i < len(word) - 1 and word[
-                        i + 1] == second:
-                    new_word.append(first + second)
-                    i += 2
-                else:
-                    new_word.append(word[i])
-                    i += 1
-            new_word = tuple(new_word)
-            word = new_word
-            if len(word) == 1:
-                break
-            else:
-                pairs = get_pairs(word)
-        word = ' '.join(word)
-        self.cache[token] = word
-        return word
-
-    def encode(self, text):
-        bpe_tokens = []
-        text = whitespace_clean(basic_clean(text)).lower()
-        for token in re.findall(self.pat, text):
-            token = ''.join(self.byte_encoder[b]
-                            for b in token.encode('utf-8'))
-            bpe_tokens.extend(self.encoder[bpe_token]
-                              for bpe_token in self.bpe(token).split(' '))
-        return bpe_tokens
-
-    def decode(self, tokens):
-        text = ''.join([self.decoder[token] for token in tokens])
-        text = bytearray([self.byte_decoder[c] for c in text]).decode(
-            'utf-8', errors='replace').replace('</w>', ' ')
-        return text
-
-
-_tokenizer = SimpleTokenizer()
-
-
-def decode(output_ids: torch.Tensor):
-    output_ids = output_ids.cpu().numpy()
-    return _tokenizer.decode(output_ids)
-
-
-def tokenize(texts: Union[str, List[str]],
-             context_length: int = 77) -> torch.LongTensor:
-    """Returns the tokenized representation of given input string(s)
-
-    Parameters
-    ----------
-    texts : Union[str, List[str]]
-        An input string or a list of input strings to tokenize
-    context_length : int
-        The context length to use; all CLIP models use 77 as the context length
-
-    Returns
-    -------
-    A two-dimensional tensor containing the resulting tokens,
-    shape = [number of input strings, context_length]
-    """
-    if isinstance(texts, str):
-        texts = [texts]
-
-    sot_token = _tokenizer.encoder['<start_of_text>']
-    eot_token = _tokenizer.encoder['<end_of_text>']
-    all_tokens = [[sot_token] + _tokenizer.encode(text) + [eot_token]
-                  for text in texts]
-    result = torch.zeros(len(all_tokens), context_length, dtype=torch.long)
-
-    for i, tokens in enumerate(all_tokens):
-        if len(tokens) > context_length:
-            tokens = tokens[:context_length]  # Truncate
-            tokens[-1] = eot_token
-        result[i, :len(tokens)] = torch.tensor(tokens)
-
-    return result
-
-
-class HFTokenizer:
-    """HuggingFace tokenizer wrapper."""
-
-    def __init__(self, tokenizer_name: str):
-        from transformers import AutoTokenizer
-        self.tokenizer = AutoTokenizer.from_pretrained(tokenizer_name)
-
-    def save_pretrained(self, dest):
-        self.tokenizer.save_pretrained(dest)
-
-    def __call__(self,
-                 texts: Union[str, List[str]],
-                 context_length: int = 77) -> torch.Tensor:
-        # same cleaning as for default tokenizer, except lowercasing
-        # adding lower (for case-sensitive tokenizers) will make it
-        # more robust but less sensitive to nuance
-        if isinstance(texts, str):
-            texts = [texts]
-        texts = [whitespace_clean(basic_clean(text)) for text in texts]
-        input_ids = self.tokenizer(
-            texts,
-            return_tensors='pt',
-            max_length=context_length,
-            padding='max_length',
-            truncation=True,
-        ).input_ids
-        return input_ids
diff --git a/mmsegmentation/mmseg/utils/typing_utils.py b/mmsegmentation/mmseg/utils/typing_utils.py
deleted file mode 100644
index fba7d3b..0000000
--- a/mmsegmentation/mmseg/utils/typing_utils.py
+++ /dev/null
@@ -1,25 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-"""Collecting some commonly used type hint in mmflow."""
-from typing import Dict, List, Optional, Sequence, Tuple, Union
-
-import torch
-from mmengine.config import ConfigDict
-
-from mmseg.structures import SegDataSample
-
-# Type hint of config data
-ConfigType = Union[ConfigDict, dict]
-OptConfigType = Optional[ConfigType]
-# Type hint of one or more config data
-MultiConfig = Union[ConfigType, Sequence[ConfigType]]
-OptMultiConfig = Optional[MultiConfig]
-
-SampleList = Sequence[SegDataSample]
-OptSampleList = Optional[SampleList]
-
-# Type hint of Tensor
-TensorDict = Dict[str, torch.Tensor]
-TensorList = Sequence[torch.Tensor]
-
-ForwardResults = Union[Dict[str, torch.Tensor], List[SegDataSample],
-                       Tuple[torch.Tensor], torch.Tensor]
diff --git a/mmsegmentation/mmseg/visualization/__init__.py b/mmsegmentation/mmseg/visualization/__init__.py
deleted file mode 100644
index 8cbb211..0000000
--- a/mmsegmentation/mmseg/visualization/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .local_visualizer import SegLocalVisualizer
-
-__all__ = ['SegLocalVisualizer']
diff --git a/mmsegmentation/mmseg/visualization/local_visualizer.py b/mmsegmentation/mmseg/visualization/local_visualizer.py
deleted file mode 100644
index ee3d652..0000000
--- a/mmsegmentation/mmseg/visualization/local_visualizer.py
+++ /dev/null
@@ -1,349 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from typing import Dict, List, Optional
-
-import cv2
-import mmcv
-import numpy as np
-import torch
-from mmengine.dist import master_only
-from mmengine.structures import PixelData
-from mmengine.visualization import Visualizer
-
-from mmseg.registry import VISUALIZERS
-from mmseg.structures import SegDataSample
-from mmseg.utils import get_classes, get_palette
-
-
-@VISUALIZERS.register_module()
-class SegLocalVisualizer(Visualizer):
-    """Local Visualizer.
-
-    Args:
-        name (str): Name of the instance. Defaults to 'visualizer'.
-        image (np.ndarray, optional): the origin image to draw. The format
-            should be RGB. Defaults to None.
-        vis_backends (list, optional): Visual backend config list.
-            Defaults to None.
-        save_dir (str, optional): Save file dir for all storage backends.
-            If it is None, the backend storage will not save any data.
-        classes (list, optional): Input classes for result rendering, as the
-            prediction of segmentation model is a segment map with label
-            indices, `classes` is a list which includes items responding to the
-            label indices. If classes is not defined, visualizer will take
-            `cityscapes` classes by default. Defaults to None.
-        palette (list, optional): Input palette for result rendering, which is
-            a list of color palette responding to the classes. Defaults to None.
-        dataset_name (str, optional): `Dataset name or alias <https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/utils/class_names.py#L302-L317>`_
-            visulizer will use the meta information of the dataset i.e. classes
-            and palette, but the `classes` and `palette` have higher priority.
-            Defaults to None.
-        alpha (int, float): The transparency of segmentation mask.
-                Defaults to 0.8.
-
-    Examples:
-        >>> import numpy as np
-        >>> import torch
-        >>> from mmengine.structures import PixelData
-        >>> from mmseg.structures import SegDataSample
-        >>> from mmseg.visualization import SegLocalVisualizer
-
-        >>> seg_local_visualizer = SegLocalVisualizer()
-        >>> image = np.random.randint(0, 256,
-        ...                     size=(10, 12, 3)).astype('uint8')
-        >>> gt_sem_seg_data = dict(data=torch.randint(0, 2, (1, 10, 12)))
-        >>> gt_sem_seg = PixelData(**gt_sem_seg_data)
-        >>> gt_seg_data_sample = SegDataSample()
-        >>> gt_seg_data_sample.gt_sem_seg = gt_sem_seg
-        >>> seg_local_visualizer.dataset_meta = dict(
-        >>>     classes=('background', 'foreground'),
-        >>>     palette=[[120, 120, 120], [6, 230, 230]])
-        >>> seg_local_visualizer.add_datasample('visualizer_example',
-        ...                         image, gt_seg_data_sample)
-        >>> seg_local_visualizer.add_datasample(
-        ...                        'visualizer_example', image,
-        ...                         gt_seg_data_sample, show=True)
-    """  # noqa
-
-    def __init__(self,
-                 name: str = 'visualizer',
-                 image: Optional[np.ndarray] = None,
-                 vis_backends: Optional[Dict] = None,
-                 save_dir: Optional[str] = None,
-                 classes: Optional[List] = None,
-                 palette: Optional[List] = None,
-                 dataset_name: Optional[str] = None,
-                 alpha: float = 0.8,
-                 **kwargs):
-        super().__init__(name, image, vis_backends, save_dir, **kwargs)
-        self.alpha: float = alpha
-        self.set_dataset_meta(palette, classes, dataset_name)
-
-    def _get_center_loc(self, mask: np.ndarray) -> np.ndarray:
-        """Get semantic seg center coordinate.
-
-        Args:
-            mask: np.ndarray: get from sem_seg
-        """
-        loc = np.argwhere(mask == 1)
-
-        loc_sort = np.array(
-            sorted(loc.tolist(), key=lambda row: (row[0], row[1])))
-        y_list = loc_sort[:, 0]
-        unique, indices, counts = np.unique(
-            y_list, return_index=True, return_counts=True)
-        y_loc = unique[counts.argmax()]
-        y_most_freq_loc = loc[loc_sort[:, 0] == y_loc]
-        center_num = len(y_most_freq_loc) // 2
-        x = y_most_freq_loc[center_num][1]
-        y = y_most_freq_loc[center_num][0]
-        return np.array([x, y])
-
-    def _draw_sem_seg(self,
-                      image: np.ndarray,
-                      sem_seg: PixelData,
-                      classes: Optional[List],
-                      palette: Optional[List],
-                      with_labels: Optional[bool] = True) -> np.ndarray:
-        """Draw semantic seg of GT or prediction.
-
-        Args:
-            image (np.ndarray): The image to draw.
-            sem_seg (:obj:`PixelData`): Data structure for pixel-level
-                annotations or predictions.
-            classes (list, optional): Input classes for result rendering, as
-                the prediction of segmentation model is a segment map with
-                label indices, `classes` is a list which includes items
-                responding to the label indices. If classes is not defined,
-                visualizer will take `cityscapes` classes by default.
-                Defaults to None.
-            palette (list, optional): Input palette for result rendering, which
-                is a list of color palette responding to the classes.
-                Defaults to None.
-            with_labels(bool, optional): Add semantic labels in visualization
-                result, Default to True.
-
-        Returns:
-            np.ndarray: the drawn image which channel is RGB.
-        """
-        num_classes = len(classes)
-
-        sem_seg = sem_seg.cpu().data
-        ids = np.unique(sem_seg)[::-1]
-        legal_indices = ids < num_classes
-        ids = ids[legal_indices]
-        labels = np.array(ids, dtype=np.int64)
-
-        colors = [palette[label] for label in labels]
-
-        mask = np.zeros_like(image, dtype=np.uint8)
-        for label, color in zip(labels, colors):
-            mask[sem_seg[0] == label, :] = color
-
-        if with_labels:
-            font = cv2.FONT_HERSHEY_SIMPLEX
-            # (0,1] to change the size of the text relative to the image
-            scale = 0.05
-            fontScale = min(image.shape[0], image.shape[1]) / (25 / scale)
-            fontColor = (255, 255, 255)
-            if image.shape[0] < 300 or image.shape[1] < 300:
-                thickness = 1
-                rectangleThickness = 1
-            else:
-                thickness = 2
-                rectangleThickness = 2
-            lineType = 2
-
-            if isinstance(sem_seg[0], torch.Tensor):
-                masks = sem_seg[0].numpy() == labels[:, None, None]
-            else:
-                masks = sem_seg[0] == labels[:, None, None]
-            masks = masks.astype(np.uint8)
-            for mask_num in range(len(labels)):
-                classes_id = labels[mask_num]
-                classes_color = colors[mask_num]
-                loc = self._get_center_loc(masks[mask_num])
-                text = classes[classes_id]
-                (label_width, label_height), baseline = cv2.getTextSize(
-                    text, font, fontScale, thickness)
-                mask = cv2.rectangle(mask, loc,
-                                     (loc[0] + label_width + baseline,
-                                      loc[1] + label_height + baseline),
-                                     classes_color, -1)
-                mask = cv2.rectangle(mask, loc,
-                                     (loc[0] + label_width + baseline,
-                                      loc[1] + label_height + baseline),
-                                     (0, 0, 0), rectangleThickness)
-                mask = cv2.putText(mask, text, (loc[0], loc[1] + label_height),
-                                   font, fontScale, fontColor, thickness,
-                                   lineType)
-        color_seg = (image * (1 - self.alpha) + mask * self.alpha).astype(
-            np.uint8)
-        self.set_image(color_seg)
-        return color_seg
-
-    def _draw_depth_map(self, image: np.ndarray,
-                        depth_map: PixelData) -> np.ndarray:
-        """Draws a depth map on a given image.
-
-        This function takes an image and a depth map as input,
-        renders the depth map, and concatenates it with the original image.
-        Finally, it updates the internal image state of the visualizer with
-        the concatenated result.
-
-        Args:
-            image (np.ndarray): The original image where the depth map will
-                be drawn. The array should be in the format HxWx3 where H is
-                the height, W is the width.
-
-            depth_map (PixelData): Depth map to be drawn. The depth map
-                should be in the form of a PixelData object. It will be
-                converted to a torch tensor if it is a numpy array.
-
-        Returns:
-            np.ndarray: The concatenated image with the depth map drawn.
-
-        Example:
-            >>> depth_map_data = PixelData(data=torch.rand(1, 10, 10))
-            >>> image = np.random.randint(0, 256,
-            >>>                           size=(10, 10, 3)).astype('uint8')
-            >>> visualizer = SegLocalVisualizer()
-            >>> visualizer._draw_depth_map(image, depth_map_data)
-        """
-        depth_map = depth_map.cpu().data
-        if isinstance(depth_map, np.ndarray):
-            depth_map = torch.from_numpy(depth_map)
-        if depth_map.ndim == 2:
-            depth_map = depth_map[None]
-
-        depth_map = self.draw_featmap(depth_map, resize_shape=image.shape[:2])
-        out_image = np.concatenate((image, depth_map), axis=0)
-        self.set_image(out_image)
-        return out_image
-
-    def set_dataset_meta(self,
-                         classes: Optional[List] = None,
-                         palette: Optional[List] = None,
-                         dataset_name: Optional[str] = None) -> None:
-        """Set meta information to visualizer.
-
-        Args:
-            classes (list, optional): Input classes for result rendering, as
-                the prediction of segmentation model is a segment map with
-                label indices, `classes` is a list which includes items
-                responding to the label indices. If classes is not defined,
-                visualizer will take `cityscapes` classes by default.
-                Defaults to None.
-            palette (list, optional): Input palette for result rendering, which
-                is a list of color palette responding to the classes.
-                Defaults to None.
-            dataset_name (str, optional): `Dataset name or alias <https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/utils/class_names.py#L302-L317>`_
-                visulizer will use the meta information of the dataset i.e.
-                classes and palette, but the `classes` and `palette` have
-                higher priority. Defaults to None.
-        """  # noqa
-        # Set default value. When calling
-        # `SegLocalVisualizer().dataset_meta=xxx`,
-        # it will override the default value.
-        if dataset_name is None:
-            dataset_name = 'cityscapes'
-        classes = classes if classes else get_classes(dataset_name)
-        palette = palette if palette else get_palette(dataset_name)
-        assert len(classes) == len(
-            palette), 'The length of classes should be equal to palette'
-        self.dataset_meta: dict = {'classes': classes, 'palette': palette}
-
-    @master_only
-    def add_datasample(
-            self,
-            name: str,
-            image: np.ndarray,
-            data_sample: Optional[SegDataSample] = None,
-            draw_gt: bool = True,
-            draw_pred: bool = True,
-            show: bool = False,
-            wait_time: float = 0,
-            # TODO: Supported in mmengine's Viusalizer.
-            out_file: Optional[str] = None,
-            step: int = 0,
-            with_labels: Optional[bool] = True) -> None:
-        """Draw datasample and save to all backends.
-
-        - If GT and prediction are plotted at the same time, they are
-        displayed in a stitched image where the left image is the
-        ground truth and the right image is the prediction.
-        - If ``show`` is True, all storage backends are ignored, and
-        the images will be displayed in a local window.
-        - If ``out_file`` is specified, the drawn image will be
-        saved to ``out_file``. it is usually used when the display
-        is not available.
-
-        Args:
-            name (str): The image identifier.
-            image (np.ndarray): The image to draw.
-            gt_sample (:obj:`SegDataSample`, optional): GT SegDataSample.
-                Defaults to None.
-            pred_sample (:obj:`SegDataSample`, optional): Prediction
-                SegDataSample. Defaults to None.
-            draw_gt (bool): Whether to draw GT SegDataSample. Default to True.
-            draw_pred (bool): Whether to draw Prediction SegDataSample.
-                Defaults to True.
-            show (bool): Whether to display the drawn image. Default to False.
-            wait_time (float): The interval of show (s). Defaults to 0.
-            out_file (str): Path to output file. Defaults to None.
-            step (int): Global step value to record. Defaults to 0.
-            with_labels(bool, optional): Add semantic labels in visualization
-                result, Defaults to True.
-        """
-        classes = self.dataset_meta.get('classes', None)
-        palette = self.dataset_meta.get('palette', None)
-
-        gt_img_data = None
-        pred_img_data = None
-
-        if draw_gt and data_sample is not None:
-            if 'gt_sem_seg' in data_sample:
-                assert classes is not None, 'class information is ' \
-                                            'not provided when ' \
-                                            'visualizing semantic ' \
-                                            'segmentation results.'
-                gt_img_data = self._draw_sem_seg(image, data_sample.gt_sem_seg,
-                                                 classes, palette, with_labels)
-
-            if 'gt_depth_map' in data_sample:
-                gt_img_data = gt_img_data if gt_img_data is not None else image
-                gt_img_data = self._draw_depth_map(gt_img_data,
-                                                   data_sample.gt_depth_map)
-
-        if draw_pred and data_sample is not None:
-
-            if 'pred_sem_seg' in data_sample:
-
-                assert classes is not None, 'class information is ' \
-                                            'not provided when ' \
-                                            'visualizing semantic ' \
-                                            'segmentation results.'
-                pred_img_data = self._draw_sem_seg(image,
-                                                   data_sample.pred_sem_seg,
-                                                   classes, palette,
-                                                   with_labels)
-
-            if 'pred_depth_map' in data_sample:
-                pred_img_data = pred_img_data if pred_img_data is not None \
-                    else image
-                pred_img_data = self._draw_depth_map(
-                    pred_img_data, data_sample.pred_depth_map)
-
-        if gt_img_data is not None and pred_img_data is not None:
-            drawn_img = np.concatenate((gt_img_data, pred_img_data), axis=1)
-        elif gt_img_data is not None:
-            drawn_img = gt_img_data
-        else:
-            drawn_img = pred_img_data
-
-        if show:
-            self.show(drawn_img, win_name=name, wait_time=wait_time)
-
-        if out_file is not None:
-            mmcv.imwrite(mmcv.rgb2bgr(drawn_img), out_file)
-        else:
-            self.add_image(name, drawn_img, step)
diff --git a/mmsegmentation/model-index.yml b/mmsegmentation/model-index.yml
deleted file mode 100644
index 4026bb9..0000000
--- a/mmsegmentation/model-index.yml
+++ /dev/null
@@ -1,53 +0,0 @@
-Import:
-- configs/ann/metafile.yaml
-- configs/apcnet/metafile.yaml
-- configs/beit/metafile.yaml
-- configs/bisenetv1/metafile.yaml
-- configs/bisenetv2/metafile.yaml
-- configs/ccnet/metafile.yaml
-- configs/cgnet/metafile.yaml
-- configs/convnext/metafile.yaml
-- configs/danet/metafile.yaml
-- configs/ddrnet/metafile.yaml
-- configs/deeplabv3/metafile.yaml
-- configs/deeplabv3plus/metafile.yaml
-- configs/dmnet/metafile.yaml
-- configs/dnlnet/metafile.yaml
-- configs/dpt/metafile.yaml
-- configs/emanet/metafile.yaml
-- configs/encnet/metafile.yaml
-- configs/erfnet/metafile.yaml
-- configs/fastfcn/metafile.yaml
-- configs/fastscnn/metafile.yaml
-- configs/fcn/metafile.yaml
-- configs/gcnet/metafile.yaml
-- configs/hrnet/metafile.yaml
-- configs/icnet/metafile.yaml
-- configs/isanet/metafile.yaml
-- configs/knet/metafile.yaml
-- configs/mae/metafile.yaml
-- configs/mask2former/metafile.yaml
-- configs/maskformer/metafile.yaml
-- configs/mobilenet_v2/metafile.yaml
-- configs/mobilenet_v3/metafile.yaml
-- configs/nonlocal_net/metafile.yaml
-- configs/ocrnet/metafile.yaml
-- configs/pidnet/metafile.yaml
-- configs/point_rend/metafile.yaml
-- configs/poolformer/metafile.yaml
-- configs/psanet/metafile.yaml
-- configs/pspnet/metafile.yaml
-- configs/resnest/metafile.yaml
-- configs/san/metafile.yaml
-- configs/segformer/metafile.yaml
-- configs/segmenter/metafile.yaml
-- configs/segnext/metafile.yaml
-- configs/sem_fpn/metafile.yaml
-- configs/setr/metafile.yaml
-- configs/stdc/metafile.yaml
-- configs/swin/metafile.yaml
-- configs/twins/metafile.yaml
-- configs/unet/metafile.yaml
-- configs/upernet/metafile.yaml
-- configs/vit/metafile.yaml
-- configs/vpd/metafile.yaml
diff --git a/mmsegmentation/projects/Adabins/README.md b/mmsegmentation/projects/Adabins/README.md
deleted file mode 100644
index 8a23e92..0000000
--- a/mmsegmentation/projects/Adabins/README.md
+++ /dev/null
@@ -1,46 +0,0 @@
-# AdaBins: Depth Estimation Using Adaptive Bins
-
-## Reference
-
-> [AdaBins: Depth Estimation Using Adaptive Bins](https://arxiv.org/abs/2011.14141)
-
-## Introduction
-
-<a href="https://github.com/shariqfarooq123/AdaBins">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/projects/Adabins">Code Snippet</a>
-
-## <img src="https://user-images.githubusercontent.com/34859558/190043857-bfbdaf8b-d2dc-4fff-81c7-e0aac50851f9.png" width="25"/> Abstract
-
-We address the problem of estimating a high quality dense depth map from a single RGB input image. We start out with a baseline encoder-decoder convolutional neural network architecture and pose the question of how the global processing of information can help improve overall depth estimation. To this end, we propose a transformer-based architecture block that divides the depth range into bins whose center value is estimated adaptively per image. The final depth values are estimated as linear combinations of the bin centers. We call our new building block AdaBins. Our results show a decisive improvement over the state-of-the-art on several popular depth datasets across all metrics.We also validate the effectiveness of the proposed block with an ablation study and provide the code and corresponding pre-trained weights of the new state-of-the-art model.
-
-Our main contributions are the following:
-
-- We propose an architecture building block that performs global processing of the scene’s information.We propose to divide the predicted depth range into bins where the bin widths change per image. The final depth estimation is a linear combination of the bin center values.
-- We show a decisive improvement for supervised single image depth estimation across all metrics for the two most popular datasets, NYU and KITTI.
-- We analyze our findings and investigate different modifications on the proposed AdaBins block and study their effect on the accuracy of the depth estimation.
-
-<div align="center">
-<img src="https://github.com/open-mmlab/mmsegmentation/assets/15952744/915bcd5a-9dc2-4602-a6e7-055ff5d4889f"  width = "1000" />
-</div>
-
-## <img src="https://user-images.githubusercontent.com/34859558/190044217-8f6befc2-7f20-473d-b356-148e06265205.png" width="25"/> Performance
-
-### NYU and KITTI
-
-| Model         | Encoder         | Training epoch | Batchsize | Train Resolution | δ1    | δ2    | δ3    | REL   | RMS   | RMS log | params(M) | Links                                                                                                                   |
-| ------------- | --------------- | -------------- | --------- | ---------------- | ----- | ----- | ----- | ----- | ----- | ------- | --------- | ----------------------------------------------------------------------------------------------------------------------- |
-| AdaBins_nyu   | EfficientNet-B5 | 25             | 16        | 416x544          | 0.903 | 0.984 | 0.997 | 0.103 | 0.364 | 0.044   | 78        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/adabins/adabins_efficient_b5_nyu_third-party-f68d6bd3.pth)   |
-| AdaBins_kitti | EfficientNet-B5 | 25             | 16        | 352x764          | 0.964 | 0.995 | 0.999 | 0.058 | 2.360 | 0.088   | 78        | [model](https://download.openmmlab.com/mmsegmentation/v0.5/adabins/adabins_efficient-b5_kitty_third-party-a1aa6f36.pth) |
-
-## Citation
-
-```bibtex
-@article{10.1109/cvpr46437.2021.00400,
-    author = {Bhat, S. A. and Alhashim, I. and Wonka, P.},
-    title = {Adabins: depth estimation using adaptive bins},
-    journal = {2021 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
-    year = {2021},
-    doi = {10.1109/cvpr46437.2021.00400}
-}
-```
diff --git a/mmsegmentation/projects/Adabins/backbones/__init__.py b/mmsegmentation/projects/Adabins/backbones/__init__.py
deleted file mode 100644
index 04ae180..0000000
--- a/mmsegmentation/projects/Adabins/backbones/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .adabins_backbone import AdabinsBackbone
-
-__all__ = ['AdabinsBackbone']
diff --git a/mmsegmentation/projects/Adabins/backbones/adabins_backbone.py b/mmsegmentation/projects/Adabins/backbones/adabins_backbone.py
deleted file mode 100644
index 07d7380..0000000
--- a/mmsegmentation/projects/Adabins/backbones/adabins_backbone.py
+++ /dev/null
@@ -1,141 +0,0 @@
-import timm
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from mmcv.cnn import ConvModule, build_conv_layer
-from mmengine.model import BaseModule
-
-from mmseg.registry import MODELS
-
-
-class UpSampleBN(nn.Module):
-    """ UpSample module
-    Args:
-        skip_input (int): the input feature
-        output_features (int): the output feature
-        norm_cfg (dict, optional): Config dict for normalization layer.
-            Default: dict(type='BN', requires_grad=True).
-        act_cfg (dict, optional): The activation layer of AAM:
-            Aggregate Attention Module.
-    """
-
-    def __init__(self,
-                 skip_input,
-                 output_features,
-                 norm_cfg=dict(type='BN'),
-                 act_cfg=dict(type='LeakyReLU')):
-        super().__init__()
-
-        self._net = nn.Sequential(
-            ConvModule(
-                in_channels=skip_input,
-                out_channels=output_features,
-                kernel_size=3,
-                stride=1,
-                padding=1,
-                bias=True,
-                norm_cfg=norm_cfg,
-                act_cfg=act_cfg,
-            ),
-            ConvModule(
-                in_channels=output_features,
-                out_channels=output_features,
-                kernel_size=3,
-                stride=1,
-                padding=1,
-                bias=True,
-                norm_cfg=norm_cfg,
-                act_cfg=act_cfg,
-            ))
-
-    def forward(self, x, concat_with):
-        up_x = F.interpolate(
-            x,
-            size=[concat_with.size(2),
-                  concat_with.size(3)],
-            mode='bilinear',
-            align_corners=True)
-        f = torch.cat([up_x, concat_with], dim=1)
-        return self._net(f)
-
-
-class Encoder(nn.Module):
-    """ the efficientnet_b5 model
-    Args:
-        basemodel_name (str): the name of base model
-    """
-
-    def __init__(self, basemodel_name):
-        super().__init__()
-        self.original_model = timm.create_model(
-            basemodel_name, pretrained=True)
-        # Remove last layer
-        self.original_model.global_pool = nn.Identity()
-        self.original_model.classifier = nn.Identity()
-
-    def forward(self, x):
-        features = [x]
-        for k, v in self.original_model._modules.items():
-            if k == 'blocks':
-                for ki, vi in v._modules.items():
-                    features.append(vi(features[-1]))
-            else:
-                features.append(v(features[-1]))
-        return features
-
-
-@MODELS.register_module()
-class AdabinsBackbone(BaseModule):
-    """ the backbone of the adabins
-    Args:
-        basemodel_name (str):the name of base model
-        num_features (int): the middle feature
-        num_classes (int): the classes number
-        bottleneck_features (int): the bottleneck features
-        conv_cfg (dict): Config dict for convolution layer.
-    """
-
-    def __init__(self,
-                 basemodel_name,
-                 num_features=2048,
-                 num_classes=128,
-                 bottleneck_features=2048,
-                 conv_cfg=dict(type='Conv')):
-        super().__init__()
-        self.encoder = Encoder(basemodel_name)
-        features = int(num_features)
-        self.conv2 = build_conv_layer(
-            conv_cfg,
-            bottleneck_features,
-            features,
-            kernel_size=1,
-            stride=1,
-            padding=1)
-        self.up1 = UpSampleBN(
-            skip_input=features // 1 + 112 + 64, output_features=features // 2)
-        self.up2 = UpSampleBN(
-            skip_input=features // 2 + 40 + 24, output_features=features // 4)
-        self.up3 = UpSampleBN(
-            skip_input=features // 4 + 24 + 16, output_features=features // 8)
-        self.up4 = UpSampleBN(
-            skip_input=features // 8 + 16 + 8, output_features=features // 16)
-
-        self.conv3 = build_conv_layer(
-            conv_cfg,
-            features // 16,
-            num_classes,
-            kernel_size=3,
-            stride=1,
-            padding=1)
-
-    def forward(self, x):
-        features = self.encoder(x)
-        x_block0, x_block1, x_block2, x_block3, x_block4 = features[
-            3], features[4], features[5], features[7], features[10]
-        x_d0 = self.conv2(x_block4)
-        x_d1 = self.up1(x_d0, x_block3)
-        x_d2 = self.up2(x_d1, x_block2)
-        x_d3 = self.up3(x_d2, x_block1)
-        x_d4 = self.up4(x_d3, x_block0)
-        out = self.conv3(x_d4)
-        return out
diff --git a/mmsegmentation/projects/Adabins/configs/_base_/datasets/nyu.py b/mmsegmentation/projects/Adabins/configs/_base_/datasets/nyu.py
deleted file mode 100644
index 1b49ec7..0000000
--- a/mmsegmentation/projects/Adabins/configs/_base_/datasets/nyu.py
+++ /dev/null
@@ -1,32 +0,0 @@
-dataset_type = 'NYUDataset'
-data_root = 'data/nyu'
-
-test_pipeline = [
-    dict(dict(type='LoadImageFromFile', to_float32=True)),
-    dict(dict(type='LoadDepthAnnotation', depth_rescale_factor=1e-3)),
-    dict(
-        type='PackSegInputs',
-        meta_keys=('img_path', 'depth_map_path', 'ori_shape', 'img_shape',
-                   'pad_shape', 'scale_factor', 'flip', 'flip_direction',
-                   'category_id'))
-]
-
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        test_mode=True,
-        data_prefix=dict(
-            img_path='images/test', depth_map_path='annotations/test'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-
-val_evaluator = dict(
-    type='DepthMetric', max_depth_eval=10.0, crop_type='nyu_crop')
-test_evaluator = val_evaluator
-val_cfg = dict(type='ValLoop')
-test_cfg = dict(type='TestLoop')
diff --git a/mmsegmentation/projects/Adabins/configs/_base_/default_runtime.py b/mmsegmentation/projects/Adabins/configs/_base_/default_runtime.py
deleted file mode 100644
index 272b4d2..0000000
--- a/mmsegmentation/projects/Adabins/configs/_base_/default_runtime.py
+++ /dev/null
@@ -1,15 +0,0 @@
-default_scope = 'mmseg'
-env_cfg = dict(
-    cudnn_benchmark=True,
-    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
-    dist_cfg=dict(backend='nccl'),
-)
-vis_backends = [dict(type='LocalVisBackend')]
-visualizer = dict(
-    type='SegLocalVisualizer', vis_backends=vis_backends, name='visualizer')
-log_processor = dict(by_epoch=False)
-log_level = 'INFO'
-load_from = None
-resume = False
-
-tta_model = dict(type='SegTTAModel')
diff --git a/mmsegmentation/projects/Adabins/configs/_base_/models/Adabins.py b/mmsegmentation/projects/Adabins/configs/_base_/models/Adabins.py
deleted file mode 100644
index 35cbd8c..0000000
--- a/mmsegmentation/projects/Adabins/configs/_base_/models/Adabins.py
+++ /dev/null
@@ -1,35 +0,0 @@
-# model settings
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    mean=[123.675, 116.28, 103.53],
-    std=[58.395, 57.12, 57.375],
-    bgr_to_rgb=True,
-    pad_val=0,
-    seg_pad_val=255)
-model = dict(
-    type='DepthEstimator',
-    data_preprocessor=data_preprocessor,
-    # pretrained='open-mmlab://resnet50_v1c',
-    backbone=dict(
-        type='AdabinsBackbone',
-        basemodel_name='tf_efficientnet_b5_ap',
-        num_features=2048,
-        num_classes=128,
-        bottleneck_features=2048,
-    ),
-    decode_head=dict(
-        type='AdabinsHead',
-        in_channels=128,
-        n_query_channels=128,
-        patch_size=16,
-        embedding_dim=128,
-        num_heads=4,
-        n_bins=256,
-        min_val=0.001,
-        max_val=10,
-        norm='linear'),
-
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/projects/Adabins/configs/adabins/adabins_efficient_b5_4x16_25e_NYU_416x544.py b/mmsegmentation/projects/Adabins/configs/adabins/adabins_efficient_b5_4x16_25e_NYU_416x544.py
deleted file mode 100644
index 5c00ea1..0000000
--- a/mmsegmentation/projects/Adabins/configs/adabins/adabins_efficient_b5_4x16_25e_NYU_416x544.py
+++ /dev/null
@@ -1,15 +0,0 @@
-_base_ = [
-    '../_base_/models/Adabins.py', '../_base_/datasets/nyu.py',
-    '../_base_/default_runtime.py'
-]
-custom_imports = dict(
-    imports=['projects.Adabins.backbones', 'projects.Adabins.decode_head'],
-    allow_failed_imports=False)
-crop_size = (416, 544)
-data_preprocessor = dict(size=crop_size)
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(),
-    decode_head=dict(),
-)
diff --git a/mmsegmentation/projects/Adabins/configs/adabins/adabins_efficient_b5_4x16_25e_kitti_352x704.py b/mmsegmentation/projects/Adabins/configs/adabins/adabins_efficient_b5_4x16_25e_kitti_352x704.py
deleted file mode 100644
index 330cdf4..0000000
--- a/mmsegmentation/projects/Adabins/configs/adabins/adabins_efficient_b5_4x16_25e_kitti_352x704.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = ['../_base_/models/Adabins.py']
-custom_imports = dict(
-    imports=['projects.Adabins.backbones', 'projects.Adabins.decode_head'],
-    allow_failed_imports=False)
-crop_size = (352, 704)
-data_preprocessor = dict(size=crop_size)
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(),
-    decode_head=dict(min_val=0.001, max_val=80),
-)
diff --git a/mmsegmentation/projects/Adabins/decode_head/__init__.py b/mmsegmentation/projects/Adabins/decode_head/__init__.py
deleted file mode 100644
index c7d62df..0000000
--- a/mmsegmentation/projects/Adabins/decode_head/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .adabins_head import AdabinsHead
-
-__all__ = ['AdabinsHead']
diff --git a/mmsegmentation/projects/Adabins/decode_head/adabins_head.py b/mmsegmentation/projects/Adabins/decode_head/adabins_head.py
deleted file mode 100644
index ee04317..0000000
--- a/mmsegmentation/projects/Adabins/decode_head/adabins_head.py
+++ /dev/null
@@ -1,179 +0,0 @@
-from typing import List, Tuple
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from mmcv.cnn import build_conv_layer
-from torch import Tensor
-
-from mmseg.registry import MODELS
-
-
-class PatchTransformerEncoder(nn.Module):
-    """the Patch Transformer Encoder.
-
-    Args:
-        in_channels (int): the channels of input
-        patch_size (int): the path size
-        embedding_dim (int): The feature dimension.
-        num_heads (int): the number of encoder head
-        conv_cfg (dict): Config dict for convolution layer.
-    """
-
-    def __init__(self,
-                 in_channels,
-                 patch_size=10,
-                 embedding_dim=128,
-                 num_heads=4,
-                 conv_cfg=dict(type='Conv')):
-        super().__init__()
-        encoder_layers = nn.TransformerEncoderLayer(
-            embedding_dim, num_heads, dim_feedforward=1024)
-        self.transformer_encoder = nn.TransformerEncoder(
-            encoder_layers, num_layers=4)  # takes shape S,N,E
-
-        self.embedding_convPxP = build_conv_layer(
-            conv_cfg,
-            in_channels,
-            embedding_dim,
-            kernel_size=patch_size,
-            stride=patch_size)
-        self.positional_encodings = nn.Parameter(
-            torch.rand(500, embedding_dim), requires_grad=True)
-
-    def forward(self, x):
-        embeddings = self.embedding_convPxP(x).flatten(
-            2)  # .shape = n,c,s = n, embedding_dim, s
-        embeddings = embeddings + self.positional_encodings[:embeddings.shape[
-            2], :].T.unsqueeze(0)
-
-        # change to S,N,E format required by transformer
-        embeddings = embeddings.permute(2, 0, 1)
-        x = self.transformer_encoder(embeddings)  # .shape = S, N, E
-        return x
-
-
-class PixelWiseDotProduct(nn.Module):
-    """the pixel wise dot product."""
-
-    def __init__(self):
-        super().__init__()
-
-    def forward(self, x, K):
-        n, c, h, w = x.size()
-        _, cout, ck = K.size()
-        assert c == ck, 'Number of channels in x and Embedding dimension ' \
-                        '(at dim 2) of K matrix must match'
-        y = torch.matmul(
-            x.view(n, c, h * w).permute(0, 2, 1),
-            K.permute(0, 2, 1))  # .shape = n, hw, cout
-        return y.permute(0, 2, 1).view(n, cout, h, w)
-
-
-@MODELS.register_module()
-class AdabinsHead(nn.Module):
-    """the head of the adabins,include mViT.
-
-    Args:
-        in_channels (int):the channels of the input
-        n_query_channels (int):the channels of the query
-        patch_size (int): the patch size
-        embedding_dim (int):The feature dimension.
-        num_heads (int):the number of head
-        n_bins (int):the number of bins
-        min_val (float): the min width of bin
-        max_val (float): the max width of bin
-        conv_cfg (dict): Config dict for convolution layer.
-        norm (str): the activate method
-        align_corners (bool, optional): Geometrically, we consider the pixels
-            of the input and output as squares rather than points.
-    """
-
-    def __init__(self,
-                 in_channels,
-                 n_query_channels=128,
-                 patch_size=16,
-                 embedding_dim=128,
-                 num_heads=4,
-                 n_bins=100,
-                 min_val=0.1,
-                 max_val=10,
-                 conv_cfg=dict(type='Conv'),
-                 norm='linear',
-                 align_corners=False,
-                 threshold=0):
-        super().__init__()
-        self.out_channels = n_bins
-        self.align_corners = align_corners
-        self.norm = norm
-        self.num_classes = n_bins
-        self.min_val = min_val
-        self.max_val = max_val
-        self.n_query_channels = n_query_channels
-        self.patch_transformer = PatchTransformerEncoder(
-            in_channels, patch_size, embedding_dim, num_heads)
-        self.dot_product_layer = PixelWiseDotProduct()
-        self.threshold = threshold
-        self.conv3x3 = build_conv_layer(
-            conv_cfg,
-            in_channels,
-            embedding_dim,
-            kernel_size=3,
-            stride=1,
-            padding=1)
-        self.regressor = nn.Sequential(
-            nn.Linear(embedding_dim, 256), nn.LeakyReLU(), nn.Linear(256, 256),
-            nn.LeakyReLU(), nn.Linear(256, n_bins))
-        self.conv_out = nn.Sequential(
-            build_conv_layer(conv_cfg, in_channels, n_bins, kernel_size=1),
-            nn.Softmax(dim=1))
-
-    def forward(self, x):
-        # n, c, h, w = x.size()
-        tgt = self.patch_transformer(x.clone())  # .shape = S, N, E
-
-        x = self.conv3x3(x)
-
-        regression_head, queries = tgt[0,
-                                       ...], tgt[1:self.n_query_channels + 1,
-                                                 ...]
-
-        # Change from S, N, E to N, S, E
-        queries = queries.permute(1, 0, 2)
-        range_attention_maps = self.dot_product_layer(
-            x, queries)  # .shape = n, n_query_channels, h, w
-
-        y = self.regressor(regression_head)  # .shape = N, dim_out
-        if self.norm == 'linear':
-            y = torch.relu(y)
-            eps = 0.1
-            y = y + eps
-        elif self.norm == 'softmax':
-            return torch.softmax(y, dim=1), range_attention_maps
-        else:
-            y = torch.sigmoid(y)
-        bin_widths_normed = y / y.sum(dim=1, keepdim=True)
-        out = self.conv_out(range_attention_maps)
-
-        bin_widths = (self.max_val -
-                      self.min_val) * bin_widths_normed  # .shape = N, dim_out
-        bin_widths = F.pad(
-            bin_widths, (1, 0), mode='constant', value=self.min_val)
-        bin_edges = torch.cumsum(bin_widths, dim=1)
-
-        centers = 0.5 * (bin_edges[:, :-1] + bin_edges[:, 1:])
-        n, dim_out = centers.size()
-        centers = centers.view(n, dim_out, 1, 1)
-
-        pred = torch.sum(out * centers, dim=1, keepdim=True)
-        return bin_edges, pred
-
-    def predict(self, inputs: Tuple[Tensor], batch_img_metas: List[dict],
-                test_cfg, **kwargs) -> Tensor:
-        """Forward function for testing, only ``pam_cam`` is used."""
-        pred = self.forward(inputs)[-1]
-        final = torch.clamp(pred, self.min_val, self.max_val)
-
-        final[torch.isinf(final)] = self.max_val
-        final[torch.isnan(final)] = self.min_val
-        return final
diff --git a/mmsegmentation/projects/CAT-Seg/README.md b/mmsegmentation/projects/CAT-Seg/README.md
deleted file mode 100644
index 890e461..0000000
--- a/mmsegmentation/projects/CAT-Seg/README.md
+++ /dev/null
@@ -1,92 +0,0 @@
-# CAT-Seg
-
-> [CAT-Seg: Cost Aggregation for Open-Vocabulary Semantic Segmentation](https://arxiv.org/abs/2303.11797)
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-<a href="https://github.com/KU-CVLAB/CAT-Seg">Official Repo</a>
-
-<a href="https://github.com/SheffieldCao/mmsegmentation/blob/support-cat-seg/mmseg/models/necks/cat_aggregator.py">Code Snippet</a>
-
-## Abstract
-
-<!-- [ABSTRACT] -->
-
-Existing works on open-vocabulary semantic segmentation have utilized large-scale vision-language models, such as CLIP, to leverage their exceptional open-vocabulary recognition capabilities. However, the problem of transferring these capabilities learned from image-level supervision to the pixel-level task of segmentation and addressing arbitrary unseen categories at inference makes this task challenging. To address these issues, we aim to attentively relate objects within an image to given categories by leveraging relational information among class categories and visual semantics through aggregation, while also adapting the CLIP representations to the pixel-level task. However, we observe that direct optimization of the CLIP embeddings can harm its open-vocabulary capabilities. In this regard, we propose an alternative approach to optimize the imagetext similarity map, i.e. the cost map, using a novel cost aggregation-based method. Our framework, namely CATSeg, achieves state-of-the-art performance across all benchmarks. We provide extensive ablation studies to validate our choices. [Project page](https://ku-cvlab.github.io/CAT-Seg).
-
-<!-- [IMAGE] -->
-
-<div align=center >
-<img alt="CAT-Seg" src="https://github.com/open-mmlab/mmsegmentation/assets/49406546/d54674bb-52ae-4a20-a168-e25d041111e8"/>
-CAT-Seg model structure
-</div>
-
-## Usage
-
-CAT-Seg model training needs pretrained `CLIP` model. We have implemented `ViT-B` and `ViT-L` based `CLIP` model. To further use `ViT-bigG` or `ViT-H` ones, you need additional dependencies. Please install [open_clip](https://github.com/mlfoundations/open_clip) first. The pretrained `CLIP` model state dicts are loaded from [Huggingface-OpenCLIP](https://huggingface.co/models?library=open_clip). **If you come up with `ConnectionError` when downloading CLIP weights**, you can manually download them from the given repo and use `custom_clip_weights=/path/to/you/folder` of backbone in config file. Related tools are as shown in [requirements/optional.txt](requirements/optional.txt):
-
-```shell
-pip install ftfy==6.0.1
-pip install huggingface-hub
-pip install regex
-```
-
-In addition to the necessary [data preparation](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md), you also need class texts for clip text encoder. Please download the class text json file first [cls_texts](https://github.com/open-mmlab/mmsegmentation/files/11714914/cls_texts.zip) and arrange the folder as follows:
-
-```none
-mmsegmentation
-├── mmseg
-├── tools
-├── configs
-├── data
-│   ├── VOCdevkit
-│   │   ├── VOC2012
-│   │   ├── VOC2010
-│   │   ├── VOCaug
-│   ├── ade
-│   ├── coco_stuff164k
-│   ├── coco.json
-│   ├── pc59.json
-│   ├── pc459.json
-│   ├── ade150.json
-│   ├── ade847.json
-│   ├── voc20b.json
-│   ├── voc20.json
-```
-
-```shell
-# setup PYTHONPATH
-export PYTHONPATH=`pwd`:$PYTHONPATH
-# run evaluation
-mim test mmsegmentation ${CONFIG} --checkpoint ${CHECKPOINT} --launcher pytorch --gpus=8
-```
-
-## Results and models
-
-### ADE20K-150-ZeroShot
-
-| Method  | Backbone      | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | Device  | mIoU | mIoU(ms+flip) |                                                                                      config | download                                                                                                                                      |
-| ------- | ------------- | --------- | ------- | -------: | -------------- | ------- | ---- | ------------: | ------------------------------------------------------------------------------------------: | --------------------------------------------------------------------------------------------------------------------------------------------- |
-| CAT-Seg | R-101 & ViT-B | 384x384   | 80000   |        - | -              | RTX3090 | 27.2 |             - | [config](./configs/cat_seg/catseg_vitb-r101_4xb1-warmcoslr2e-4-adamw-80k_ade20k-384x384.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/cat_seg/catseg_vitb-r101_4xb1-warmcoslr2e-4-adamw-80k_ade20k-384x384-54194d72.pth) |
-
-Note:
-
-- All experiments of CAT-Seg are implemented with 4 RTX3090 GPUs, except the last one with pretrained ViT-bigG CLIP model (GPU Memory insufficient, you may need A100).
-- Due to the feature size bottleneck of the CLIP image encoder, the inference and testing can only be done under `slide` mode, the inference time is longer since the test size is much more bigger that training size of `(384, 384)`.
-- The ResNet backbones utilized in CAT-Seg models are standard `ResNet` rather than `ResNetV1c`.
-- The zero-shot segmentation results on PASCAL VOC and ADE20K are from the original paper. Our results are coming soon. We appreatiate your contribution!
-- In additional to zero-shot segmentation performance results, we also provided the evaluation results on the `val2017` set of **COCO-stuff164k** for reference, which is the training dataset of CAT-Seg. The testing was done **without TTA**.
-- The number behind the dataset name is the category number for segmentation evaluation (except training data **COCO-stuff 164k**). **PASCAL VOC-20b** defines the "background" as classes present in **PASCAL-Context-59** but not in **PASCAL VOC-20**.
-
-## Citation
-
-```bibtex
-@inproceedings{cheng2021mask2former,
-  title={CAT-Seg: Cost Aggregation for Open-Vocabulary Semantic Segmentation},
-  author={Seokju Cho and Heeseong Shin and Sunghwan Hong and Seungjun An and Seungjun Lee and Anurag Arnab and Paul Hongsuck Seo and Seungryong Kim},
-  journal={CVPR},
-  year={2023}
-}
-```
diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/__init__.py b/mmsegmentation/projects/CAT-Seg/cat_seg/__init__.py
deleted file mode 100644
index 2c51fba..0000000
--- a/mmsegmentation/projects/CAT-Seg/cat_seg/__init__.py
+++ /dev/null
@@ -1,2 +0,0 @@
-from .models import *  # noqa: F401,F403
-from .utils import *  # noqa: F401,F403
diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/models/__init__.py b/mmsegmentation/projects/CAT-Seg/cat_seg/models/__init__.py
deleted file mode 100644
index cd0e15d..0000000
--- a/mmsegmentation/projects/CAT-Seg/cat_seg/models/__init__.py
+++ /dev/null
@@ -1,10 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .cat_aggregator import (AggregatorLayer, CATSegAggregator,
-                             ClassAggregateLayer, SpatialAggregateLayer)
-from .cat_head import CATSegHead
-from .clip_ovseg import CLIPOVCATSeg
-
-__all__ = [
-    'AggregatorLayer', 'CATSegAggregator', 'ClassAggregateLayer',
-    'SpatialAggregateLayer', 'CATSegHead', 'CLIPOVCATSeg'
-]
diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/models/cat_aggregator.py b/mmsegmentation/projects/CAT-Seg/cat_seg/models/cat_aggregator.py
deleted file mode 100644
index a0483fe..0000000
--- a/mmsegmentation/projects/CAT-Seg/cat_seg/models/cat_aggregator.py
+++ /dev/null
@@ -1,763 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from mmcv.cnn import build_norm_layer
-from mmcv.cnn.bricks.transformer import FFN, build_dropout
-from mmengine.model import BaseModule
-from mmengine.utils import to_2tuple
-
-from mmseg.registry import MODELS
-from ..utils import FullAttention, LinearAttention
-
-
-class AGWindowMSA(BaseModule):
-    """Appearance Guidance Window based multi-head self-attention (W-MSA)
-    module with relative position bias.
-
-    Args:
-        embed_dims (int): Number of input channels.
-        appearance_dims (int): Number of appearance guidance feature channels.
-        num_heads (int): Number of attention heads.
-        window_size (tuple[int]): The height and width of the window.
-        qkv_bias (bool, optional):  If True, add a learnable bias to q, k, v.
-            Default: True.
-        qk_scale (float | None, optional): Override default qk scale of
-            head_dim ** -0.5 if set. Default: None.
-        attn_drop_rate (float, optional): Dropout ratio of attention weight.
-            Default: 0.0
-        proj_drop_rate (float, optional): Dropout ratio of output. Default: 0.
-        init_cfg (dict | None, optional): The Config for initialization.
-            Default: None.
-    """
-
-    def __init__(self,
-                 embed_dims,
-                 appearance_dims,
-                 num_heads,
-                 window_size,
-                 qkv_bias=True,
-                 qk_scale=None,
-                 attn_drop_rate=0.,
-                 proj_drop_rate=0.,
-                 init_cfg=None):
-
-        super().__init__(init_cfg=init_cfg)
-        self.embed_dims = embed_dims
-        self.appearance_dims = appearance_dims
-        self.window_size = window_size  # Wh, Ww
-        self.num_heads = num_heads
-        head_embed_dims = embed_dims // num_heads
-        self.scale = qk_scale or head_embed_dims**-0.5
-
-        # About 2x faster than original impl
-        Wh, Ww = self.window_size
-        rel_index_coords = self.double_step_seq(2 * Ww - 1, Wh, 1, Ww)
-        rel_position_index = rel_index_coords + rel_index_coords.T
-        rel_position_index = rel_position_index.flip(1).contiguous()
-        self.register_buffer('relative_position_index', rel_position_index)
-
-        self.qk = nn.Linear(
-            embed_dims + appearance_dims, embed_dims * 2, bias=qkv_bias)
-        self.v = nn.Linear(embed_dims, embed_dims, bias=qkv_bias)
-        self.attn_drop = nn.Dropout(attn_drop_rate)
-        self.proj = nn.Linear(embed_dims, embed_dims)
-        self.proj_drop = nn.Dropout(proj_drop_rate)
-
-        self.softmax = nn.Softmax(dim=-1)
-
-    def forward(self, x, mask=None):
-        """
-        Args:
-            x (tensor): input features with shape of (num_windows*B, N, C),
-                C = embed_dims + appearance_dims.
-            mask (tensor | None, Optional): mask with shape of (num_windows,
-                Wh*Ww, Wh*Ww), value should be between (-inf, 0].
-        """
-        B, N, _ = x.shape
-        qk = self.qk(x).reshape(B, N, 2, self.num_heads,
-                                self.embed_dims // self.num_heads).permute(
-                                    2, 0, 3, 1,
-                                    4)  # 2 B NUM_HEADS N embed_dims//NUM_HEADS
-        v = self.v(x[:, :, :self.embed_dims]).reshape(
-            B, N, self.num_heads, self.embed_dims // self.num_heads).permute(
-                0, 2, 1, 3)  # B NUM_HEADS N embed_dims//NUM_HEADS
-        # make torchscript happy (cannot use tensor as tuple)
-        q, k = qk[0], qk[1]
-
-        q = q * self.scale
-        attn = (q @ k.transpose(-2, -1))
-
-        if mask is not None:
-            nW = mask.shape[0]
-            attn = attn.view(B // nW, nW, self.num_heads, N,
-                             N) + mask.unsqueeze(1).unsqueeze(0)
-            attn = attn.view(-1, self.num_heads, N, N)
-        attn = self.softmax(attn)
-
-        attn = self.attn_drop(attn)
-
-        x = (attn @ v).transpose(1, 2).reshape(B, N, self.embed_dims)
-        x = self.proj(x)
-        x = self.proj_drop(x)
-        return x
-
-    @staticmethod
-    def double_step_seq(step1, len1, step2, len2):
-        """Double step sequence."""
-        seq1 = torch.arange(0, step1 * len1, step1)
-        seq2 = torch.arange(0, step2 * len2, step2)
-        return (seq1[:, None] + seq2[None, :]).reshape(1, -1)
-
-
-class AGShiftWindowMSA(BaseModule):
-    """Appearance Guidance Shifted Window Multihead Self-Attention Module.
-
-    Args:
-        embed_dims (int): Number of input channels.
-        appearance_dims (int): Number of appearance guidance channels
-        num_heads (int): Number of attention heads.
-        window_size (int): The height and width of the window.
-        shift_size (int, optional): The shift step of each window towards
-            right-bottom. If zero, act as regular window-msa. Defaults to 0.
-        qkv_bias (bool, optional): If True, add a learnable bias to q, k, v.
-            Default: True
-        qk_scale (float | None, optional): Override default qk scale of
-            head_dim ** -0.5 if set. Defaults: None.
-        attn_drop_rate (float, optional): Dropout ratio of attention weight.
-            Defaults: 0.
-        proj_drop_rate (float, optional): Dropout ratio of output.
-            Defaults: 0.
-        dropout_layer (dict, optional): The dropout_layer used before output.
-            Defaults: dict(type='DropPath', drop_prob=0.).
-        init_cfg (dict, optional): The extra config for initialization.
-            Default: None.
-    """
-
-    def __init__(self,
-                 embed_dims,
-                 appearance_dims,
-                 num_heads,
-                 window_size,
-                 shift_size=0,
-                 qkv_bias=True,
-                 qk_scale=None,
-                 attn_drop_rate=0,
-                 proj_drop_rate=0,
-                 dropout_layer=dict(type='DropPath', drop_prob=0.),
-                 init_cfg=None):
-        super().__init__(init_cfg=init_cfg)
-
-        self.window_size = window_size
-        self.shift_size = shift_size
-        assert 0 <= self.shift_size < self.window_size
-
-        self.w_msa = AGWindowMSA(
-            embed_dims=embed_dims,
-            appearance_dims=appearance_dims,
-            num_heads=num_heads,
-            window_size=to_2tuple(window_size),
-            qkv_bias=qkv_bias,
-            qk_scale=qk_scale,
-            attn_drop_rate=attn_drop_rate,
-            proj_drop_rate=proj_drop_rate,
-            init_cfg=None)
-
-        self.drop = build_dropout(dropout_layer)
-
-    def forward(self, query, hw_shape):
-        """
-        Args:
-            query: The input query.
-            hw_shape: The shape of the feature height and width.
-        """
-        B, L, C = query.shape
-        H, W = hw_shape
-        assert L == H * W, 'input feature has wrong size'
-        query = query.view(B, H, W, C)
-
-        # pad feature maps to multiples of window size
-        pad_r = (self.window_size - W % self.window_size) % self.window_size
-        pad_b = (self.window_size - H % self.window_size) % self.window_size
-        query = F.pad(query, (0, 0, 0, pad_r, 0, pad_b))
-        H_pad, W_pad = query.shape[1], query.shape[2]
-
-        # cyclic shift
-        if self.shift_size > 0:
-            shifted_query = torch.roll(
-                query,
-                shifts=(-self.shift_size, -self.shift_size),
-                dims=(1, 2))
-
-            # calculate attention mask for SW-MSA
-            img_mask = torch.zeros((1, H_pad, W_pad, 1), device=query.device)
-            h_slices = (slice(0, -self.window_size),
-                        slice(-self.window_size,
-                              -self.shift_size), slice(-self.shift_size, None))
-            w_slices = (slice(0, -self.window_size),
-                        slice(-self.window_size,
-                              -self.shift_size), slice(-self.shift_size, None))
-            cnt = 0
-            for h in h_slices:
-                for w in w_slices:
-                    img_mask[:, h, w, :] = cnt
-                    cnt += 1
-
-            # nW, window_size, window_size, 1
-            mask_windows = self.window_partition(img_mask)
-            mask_windows = mask_windows.view(
-                -1, self.window_size * self.window_size)
-            attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
-            attn_mask = attn_mask.masked_fill(attn_mask != 0,
-                                              float(-100.0)).masked_fill(
-                                                  attn_mask == 0, float(0.0))
-        else:
-            shifted_query = query
-            attn_mask = None
-
-        # nW*B, window_size, window_size, C
-        query_windows = self.window_partition(shifted_query)
-        # nW*B, window_size*window_size, C
-        query_windows = query_windows.view(-1, self.window_size**2, C)
-
-        # W-MSA/SW-MSA (nW*B, window_size*window_size, C)
-        attn_windows = self.w_msa(query_windows, mask=attn_mask)
-
-        # merge windows
-        attn_windows = attn_windows.view(-1, self.window_size,
-                                         self.window_size,
-                                         self.w_msa.embed_dims)
-
-        # B H' W' self.w_msa.embed_dims
-        shifted_x = self.window_reverse(attn_windows, H_pad, W_pad)
-        # reverse cyclic shift
-        if self.shift_size > 0:
-            x = torch.roll(
-                shifted_x,
-                shifts=(self.shift_size, self.shift_size),
-                dims=(1, 2))
-        else:
-            x = shifted_x
-
-        if pad_r > 0 or pad_b:
-            x = x[:, :H, :W, :].contiguous()
-
-        x = x.view(B, H * W, self.w_msa.embed_dims)
-
-        x = self.drop(x)
-        return x
-
-    def window_reverse(self, windows, H, W):
-        """
-        Args:
-            windows: (num_windows*B, window_size, window_size, C)
-            H (int): Height of image
-            W (int): Width of image
-        Returns:
-            x: (B, H, W, C)
-        """
-        window_size = self.window_size
-        B = int(windows.shape[0] / (H * W / window_size / window_size))
-        x = windows.view(B, H // window_size, W // window_size, window_size,
-                         window_size, -1)
-        x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)
-        return x
-
-    def window_partition(self, x):
-        """
-        Args:
-            x: (B, H, W, C)
-        Returns:
-            windows: (num_windows*B, window_size, window_size, C)
-        """
-        B, H, W, C = x.shape
-        window_size = self.window_size
-        x = x.view(B, H // window_size, window_size, W // window_size,
-                   window_size, C)
-        windows = x.permute(0, 1, 3, 2, 4, 5).contiguous()
-        windows = windows.view(-1, window_size, window_size, C)
-        return windows
-
-
-class AGSwinBlock(BaseModule):
-    """Appearance Guidance Swin Transformer Block.
-
-    Args:
-        embed_dims (int): The feature dimension.
-        appearance_dims (int): The appearance guidance dimension.
-        num_heads (int): Parallel attention heads.
-        mlp_ratios (int): The hidden dimension ratio w.r.t. embed_dims
-            for FFNs.
-        window_size (int, optional): The local window scale.
-            Default: 7.
-        shift (bool, optional): whether to shift window or not.
-            Default False.
-        qkv_bias (bool, optional): enable bias for qkv if True.
-            Default: True.
-        qk_scale (float | None, optional): Override default qk scale of
-            head_dim ** -0.5 if set. Default: None.
-        drop_rate (float, optional): Dropout rate. Default: 0.
-        attn_drop_rate (float, optional): Attention dropout rate.
-            Default: 0.
-        drop_path_rate (float, optional): Stochastic depth rate.
-            Default: 0.
-        act_cfg (dict, optional): The config dict of activation function.
-            Default: dict(type='GELU').
-        norm_cfg (dict, optional): The config dict of normalization.
-            Default: dict(type='LN').
-        init_cfg (dict | list | None, optional): The init config.
-            Default: None.
-    """
-
-    def __init__(self,
-                 embed_dims,
-                 appearance_dims,
-                 num_heads,
-                 mlp_ratios=4,
-                 window_size=7,
-                 shift=False,
-                 qkv_bias=True,
-                 qk_scale=None,
-                 drop_rate=0.,
-                 attn_drop_rate=0.,
-                 drop_path_rate=0.,
-                 act_cfg=dict(type='GELU'),
-                 norm_cfg=dict(type='LN'),
-                 init_cfg=None):
-        super().__init__(init_cfg=init_cfg)
-        self.norm1 = build_norm_layer(norm_cfg, embed_dims)[1]
-        self.attn = AGShiftWindowMSA(
-            embed_dims=embed_dims,
-            appearance_dims=appearance_dims,
-            num_heads=num_heads,
-            window_size=window_size,
-            shift_size=window_size // 2 if shift else 0,
-            qkv_bias=qkv_bias,
-            qk_scale=qk_scale,
-            attn_drop_rate=attn_drop_rate,
-            proj_drop_rate=drop_rate,
-            dropout_layer=dict(type='DropPath', drop_prob=drop_path_rate),
-            init_cfg=None)
-
-        self.norm2 = build_norm_layer(norm_cfg, embed_dims)[1]
-        self.ffn = FFN(
-            embed_dims=embed_dims,
-            feedforward_channels=embed_dims * mlp_ratios,
-            num_fcs=2,
-            ffn_drop=drop_rate,
-            dropout_layer=dict(type='DropPath', drop_prob=drop_path_rate),
-            act_cfg=act_cfg,
-            add_identity=True,
-            init_cfg=None)
-
-    def forward(self, inputs, hw_shape):
-        """
-        Args:
-            inputs (list[Tensor]): appearance_guidance (B, H, W, C);
-                x (B, L, C)
-            hw_shape (tuple[int]): shape of feature.
-        """
-        x, appearance_guidance = inputs
-        B, L, C = x.shape
-        H, W = hw_shape
-        assert L == H * W, 'input feature has wrong size'
-
-        identity = x
-        x = self.norm1(x)
-
-        # appearance guidance
-        x = x.view(B, H, W, C)
-        if appearance_guidance is not None:
-            x = torch.cat([x, appearance_guidance], dim=-1).flatten(1, 2)
-
-        x = self.attn(x, hw_shape)
-
-        x = x + identity
-
-        identity = x
-        x = self.norm2(x)
-        x = self.ffn(x, identity=identity)
-
-        return x
-
-
-@MODELS.register_module()
-class SpatialAggregateLayer(BaseModule):
-    """Spatial aggregation layer of CAT-Seg.
-
-    Args:
-        embed_dims (int): The feature dimension.
-        appearance_dims (int): The appearance guidance dimension.
-        num_heads (int): Parallel attention heads.
-        mlp_ratios (int): The hidden dimension ratio w.r.t. embed_dims
-            for FFNs.
-        window_size (int, optional): The local window scale. Default: 7.
-        qk_scale (float | None, optional): Override default qk scale of
-            head_dim ** -0.5 if set. Default: None.
-        init_cfg (dict | list | None, optional): The init config.
-            Default: None.
-    """
-
-    def __init__(self,
-                 embed_dims,
-                 appearance_dims,
-                 num_heads,
-                 mlp_ratios,
-                 window_size=7,
-                 qk_scale=None,
-                 init_cfg=None):
-        super().__init__(init_cfg=init_cfg)
-        self.block_1 = AGSwinBlock(
-            embed_dims,
-            appearance_dims,
-            num_heads,
-            mlp_ratios,
-            window_size=window_size,
-            shift=False,
-            qk_scale=qk_scale)
-        self.block_2 = AGSwinBlock(
-            embed_dims,
-            appearance_dims,
-            num_heads,
-            mlp_ratios,
-            window_size=window_size,
-            shift=True,
-            qk_scale=qk_scale)
-        self.guidance_norm = nn.LayerNorm(
-            appearance_dims) if appearance_dims > 0 else None
-
-    def forward(self, x, appearance_guidance):
-        """
-        Args:
-            x (torch.Tensor): B C T H W.
-            appearance_guidance (torch.Tensor): B C H W.
-        """
-        B, C, T, H, W = x.shape
-        x = x.permute(0, 2, 3, 4, 1).flatten(0, 1).flatten(1, 2)  # BT, HW, C
-        if appearance_guidance is not None:
-            appearance_guidance = appearance_guidance.repeat(
-                T, 1, 1, 1).permute(0, 2, 3, 1)  # BT, HW, C
-            appearance_guidance = self.guidance_norm(appearance_guidance)
-        else:
-            assert self.appearance_dims == 0
-        x = self.block_1((x, appearance_guidance), (H, W))
-        x = self.block_2((x, appearance_guidance), (H, W))
-        x = x.transpose(1, 2).reshape(B, T, C, -1)
-        x = x.transpose(1, 2).reshape(B, C, T, H, W)
-        return x
-
-
-class AttentionLayer(nn.Module):
-    """Attention layer for ClassAggregration of CAT-Seg.
-
-    Source: https://github.com/KU-CVLAB/CAT-Seg/blob/main/cat_seg/modeling/transformer/model.py#L310 # noqa
-    """
-
-    def __init__(self,
-                 hidden_dim,
-                 guidance_dim,
-                 nheads=8,
-                 attention_type='linear'):
-        super().__init__()
-        self.nheads = nheads
-        self.q = nn.Linear(hidden_dim + guidance_dim, hidden_dim)
-        self.k = nn.Linear(hidden_dim + guidance_dim, hidden_dim)
-        self.v = nn.Linear(hidden_dim, hidden_dim)
-
-        if attention_type == 'linear':
-            self.attention = LinearAttention()
-        elif attention_type == 'full':
-            self.attention = FullAttention()
-        else:
-            raise NotImplementedError
-
-    def forward(self, x, guidance=None):
-        """
-        Args:
-            x: B*H_p*W_p, T, C
-            guidance: B*H_p*W_p, T, C
-        """
-        B, L, _ = x.shape
-        q = self.q(torch.cat([x, guidance],
-                             dim=-1)) if guidance is not None else self.q(x)
-        k = self.k(torch.cat([x, guidance],
-                             dim=-1)) if guidance is not None else self.k(x)
-        v = self.v(x)
-
-        q = q.reshape(B, L, self.nheads, -1)
-        k = k.reshape(B, L, self.nheads, -1)
-        v = v.reshape(B, L, self.nheads, -1)
-
-        out = self.attention(q, k, v)
-        out = out.reshape(B, L, -1)
-        return out
-
-
-@MODELS.register_module()
-class ClassAggregateLayer(BaseModule):
-    """Class aggregation layer of CAT-Seg.
-
-    Args:
-        hidden_dims (int): The feature dimension.
-        guidance_dims (int): The appearance guidance dimension.
-        num_heads (int): Parallel attention heads.
-        attention_type (str): Type of attention layer. Default: 'linear'.
-        pooling_size (tuple[int] | list[int]): Pooling size.
-        init_cfg (dict | list | None, optional): The init config.
-            Default: None.
-    """
-
-    def __init__(
-            self,
-            hidden_dims=64,
-            guidance_dims=64,
-            num_heads=8,
-            attention_type='linear',
-            pooling_size=(4, 4),
-            init_cfg=None,
-    ):
-        super().__init__(init_cfg=init_cfg)
-        self.pool = nn.AvgPool2d(pooling_size)
-        self.attention = AttentionLayer(
-            hidden_dims,
-            guidance_dims,
-            nheads=num_heads,
-            attention_type=attention_type)
-        self.MLP = FFN(
-            embed_dims=hidden_dims,
-            feedforward_channels=hidden_dims * 4,
-            num_fcs=2)
-        self.norm1 = nn.LayerNorm(hidden_dims)
-        self.norm2 = nn.LayerNorm(hidden_dims)
-
-    def pool_features(self, x):
-        """Intermediate pooling layer for computational efficiency.
-
-        Args:
-            x: B, C, T, H, W
-        """
-        B, C, T, H, W = x.shape
-        x = x.transpose(1, 2).reshape(-1, C, H, W)
-        x = self.pool(x)
-        *_, H_, W_ = x.shape
-        x = x.reshape(B, T, C, H_, W_).transpose(1, 2)
-        return x
-
-    def forward(self, x, guidance):
-        """
-        Args:
-            x: B, C, T, H, W
-            guidance: B, T, C
-        """
-        B, C, T, H, W = x.size()
-        x_pool = self.pool_features(x)
-        *_, H_pool, W_pool = x_pool.size()
-
-        x_pool = x_pool.permute(0, 3, 4, 2, 1).reshape(-1, T, C)
-        # B*H_p*W_p T C
-        if guidance is not None:
-            guidance = guidance.repeat(H_pool * W_pool, 1, 1)
-
-        x_pool = x_pool + self.attention(self.norm1(x_pool),
-                                         guidance)  # Attention
-        x_pool = x_pool + self.MLP(self.norm2(x_pool))  # MLP
-
-        x_pool = x_pool.reshape(B, H_pool * W_pool, T,
-                                C).permute(0, 2, 3, 1).reshape(
-                                    B, T, C, H_pool,
-                                    W_pool).flatten(0, 1)  # BT C H_p W_p
-        x_pool = F.interpolate(
-            x_pool, size=(H, W), mode='bilinear', align_corners=True)
-        x_pool = x_pool.reshape(B, T, C, H, W).transpose(1, 2)  # B C T H W
-        x = x + x_pool  # Residual
-
-        return x
-
-
-@MODELS.register_module()
-class AggregatorLayer(BaseModule):
-    """Single Aggregator Layer of CAT-Seg."""
-
-    def __init__(self,
-                 embed_dims=64,
-                 text_guidance_dims=512,
-                 appearance_guidance_dims=512,
-                 num_heads=4,
-                 mlp_ratios=4,
-                 window_size=7,
-                 attention_type='linear',
-                 pooling_size=(2, 2),
-                 init_cfg=None) -> None:
-        super().__init__(init_cfg=init_cfg)
-        self.spatial_agg = SpatialAggregateLayer(
-            embed_dims,
-            appearance_guidance_dims,
-            num_heads=num_heads,
-            mlp_ratios=mlp_ratios,
-            window_size=window_size)
-        self.class_agg = ClassAggregateLayer(
-            embed_dims,
-            text_guidance_dims,
-            num_heads=num_heads,
-            attention_type=attention_type,
-            pooling_size=pooling_size)
-
-    def forward(self, x, appearance_guidance, text_guidance):
-        """
-        Args:
-            x: B C T H W
-        """
-        x = self.spatial_agg(x, appearance_guidance)
-        x = self.class_agg(x, text_guidance)
-        return x
-
-
-@MODELS.register_module()
-class CATSegAggregator(BaseModule):
-    """CATSeg Aggregator.
-
-    This Aggregator is the mmseg implementation of
-    `CAT-Seg <https://arxiv.org/abs/2303.11797>`_.
-
-    Args:
-        text_guidance_dim (int): Text guidance dimensions. Default: 512.
-        text_guidance_proj_dim (int): Text guidance projection dimensions.
-            Default: 128.
-        appearance_guidance_dim (int): Appearance guidance dimensions.
-            Default: 512.
-        appearance_guidance_proj_dim (int): Appearance guidance projection
-            dimensions. Default: 128.
-        num_layers (int): Aggregator layer number. Default: 4.
-        num_heads (int): Attention layer head number. Default: 4.
-        embed_dims (int): Input feature dimensions. Default: 128.
-        pooling_size (tuple | list): Pooling size of the class aggregator
-            layer. Default: (6, 6).
-        mlp_ratios (int): The hidden dimension ratio w.r.t. input dimension.
-            Default: 4.
-        window_size (int): Swin block window size. Default:12.
-        attention_type (str): Attention type of class aggregator layer.
-            Default:'linear'.
-        prompt_channel (int): Prompt channels. Default: 80.
-    """
-
-    def __init__(self,
-                 text_guidance_dim=512,
-                 text_guidance_proj_dim=128,
-                 appearance_guidance_dim=512,
-                 appearance_guidance_proj_dim=128,
-                 num_layers=4,
-                 num_heads=4,
-                 embed_dims=128,
-                 pooling_size=(6, 6),
-                 mlp_ratios=4,
-                 window_size=12,
-                 attention_type='linear',
-                 prompt_channel=80,
-                 **kwargs):
-        super().__init__(**kwargs)
-        self.num_layers = num_layers
-        self.embed_dims = embed_dims
-
-        self.layers = nn.ModuleList([
-            AggregatorLayer(
-                embed_dims=embed_dims,
-                text_guidance_dims=text_guidance_proj_dim,
-                appearance_guidance_dims=appearance_guidance_proj_dim,
-                num_heads=num_heads,
-                mlp_ratios=mlp_ratios,
-                window_size=window_size,
-                attention_type=attention_type,
-                pooling_size=pooling_size) for _ in range(num_layers)
-        ])
-
-        self.conv1 = nn.Conv2d(
-            prompt_channel, embed_dims, kernel_size=7, stride=1, padding=3)
-
-        self.guidance_projection = nn.Sequential(
-            nn.Conv2d(
-                appearance_guidance_dim,
-                appearance_guidance_proj_dim,
-                kernel_size=3,
-                stride=1,
-                padding=1),
-            nn.ReLU(),
-        ) if appearance_guidance_dim > 0 else None
-
-        self.text_guidance_projection = nn.Sequential(
-            nn.Linear(text_guidance_dim, text_guidance_proj_dim),
-            nn.ReLU(),
-        ) if text_guidance_dim > 0 else None
-
-    def feature_map(self, img_feats, text_feats):
-        """Concatenation type cost volume.
-
-        For ablation study of cost volume type.
-        """
-        img_feats = F.normalize(img_feats, dim=1)  # B C H W
-        img_feats = img_feats.unsqueeze(2).repeat(1, 1, text_feats.shape[1], 1,
-                                                  1)
-        text_feats = F.normalize(text_feats, dim=-1)  # B T P C
-        text_feats = text_feats.mean(dim=-2)
-        text_feats = F.normalize(text_feats, dim=-1)  # B T C
-        text_feats = text_feats.unsqueeze(-1).unsqueeze(-1).repeat(
-            1, 1, 1, img_feats.shape[-2], img_feats.shape[-1]).transpose(1, 2)
-        return torch.cat((img_feats, text_feats), dim=1)  # B 2C T H W
-
-    def correlation(self, img_feats, text_feats):
-        """Correlation of image features and text features."""
-        img_feats = F.normalize(img_feats, dim=1)  # B C H W
-        text_feats = F.normalize(text_feats, dim=-1)  # B T P C
-        corr = torch.einsum('bchw, btpc -> bpthw', img_feats, text_feats)
-        return corr
-
-    def corr_embed(self, x):
-        """Correlation embeddings encoding."""
-        B = x.shape[0]
-        corr_embed = x.permute(0, 2, 1, 3, 4).flatten(0, 1)
-        corr_embed = self.conv1(corr_embed)
-        corr_embed = corr_embed.reshape(B, -1, self.embed_dims, x.shape[-2],
-                                        x.shape[-1]).transpose(1, 2)
-        return corr_embed
-
-    def forward(self, inputs):
-        """
-        Args:
-            inputs (dict): including the following keys,
-                'appearance_feat': list[torch.Tensor], w.r.t. out_indices of
-                    `self.feature_extractor`.
-                'clip_text_feat': the text feature extracted by clip text
-                    encoder.
-                'clip_text_feat_test': the text feature extracted by clip text
-                    encoder for testing.
-                'clip_img_feat': the image feature extracted clip image
-                    encoder.
-        """
-        img_feats = inputs['clip_img_feat']
-        B = img_feats.size(0)
-        appearance_guidance = inputs[
-            'appearance_feat'][::-1]  # order (out_indices) 2, 1, 0
-        text_feats = inputs['clip_text_feat'] if self.training else inputs[
-            'clip_text_feat_test']
-        text_feats = text_feats.repeat(B, 1, 1, 1)
-
-        corr = self.correlation(img_feats, text_feats)
-        # corr = self.feature_map(img_feats, text_feats)
-        corr_embed = self.corr_embed(corr)
-
-        projected_guidance, projected_text_guidance = None, None
-
-        if self.guidance_projection is not None:
-            projected_guidance = self.guidance_projection(
-                appearance_guidance[0])
-
-        if self.text_guidance_projection is not None:
-            text_feats = text_feats.mean(dim=-2)
-            text_feats = text_feats / text_feats.norm(dim=-1, keepdim=True)
-            projected_text_guidance = self.text_guidance_projection(text_feats)
-
-        for layer in self.layers:
-            corr_embed = layer(corr_embed, projected_guidance,
-                               projected_text_guidance)
-
-        return dict(
-            corr_embed=corr_embed, appearance_feats=appearance_guidance[1:])
diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/models/cat_head.py b/mmsegmentation/projects/CAT-Seg/cat_seg/models/cat_head.py
deleted file mode 100644
index 36bb1c5..0000000
--- a/mmsegmentation/projects/CAT-Seg/cat_seg/models/cat_head.py
+++ /dev/null
@@ -1,116 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-import torch.nn as nn
-from mmcv.cnn import ConvModule
-
-from mmseg.models.decode_heads.decode_head import BaseDecodeHead
-from mmseg.registry import MODELS
-
-
-class UpBlock(nn.Module):
-    """Upsample Block with two consecutive convolution layers."""
-
-    def __init__(self, in_channels, out_channels, guidance_channels):
-        super().__init__()
-        self.up = nn.ConvTranspose2d(
-            in_channels,
-            in_channels - guidance_channels,
-            kernel_size=2,
-            stride=2)
-        self.conv1 = ConvModule(
-            in_channels,
-            out_channels,
-            3,
-            padding=1,
-            bias=False,
-            norm_cfg=dict(type='GN', num_groups=out_channels // 16))
-        self.conv2 = ConvModule(
-            out_channels,
-            out_channels,
-            3,
-            padding=1,
-            bias=False,
-            norm_cfg=dict(type='GN', num_groups=out_channels // 16))
-
-    def forward(self, x, guidance=None):
-        """Forward function with visual guidance."""
-        x = self.up(x)
-        if guidance is not None:
-            T = x.size(0) // guidance.size(0)
-            # guidance = repeat(guidance, "B C H W -> (B T) C H W", T=T)
-            guidance = guidance.repeat(T, 1, 1, 1)
-            x = torch.cat([x, guidance], dim=1)
-        x = self.conv1(x)
-
-        return self.conv2(x)
-
-
-@MODELS.register_module()
-class CATSegHead(BaseDecodeHead):
-    """CATSeg Head.
-
-    This segmentation head is the mmseg implementation of
-    `CAT-Seg <https://arxiv.org/abs/2303.11797>`_.
-
-    Args:
-        embed_dims (int): The number of input dimensions.
-        decoder_dims (list): The number of decoder dimensions.
-        decoder_guidance_proj_dims (list): The number of appearance
-            guidance dimensions.
-        init_cfg
-    """
-
-    def __init__(self,
-                 embed_dims=128,
-                 decoder_dims=(64, 32),
-                 decoder_guidance_dims=(256, 128),
-                 decoder_guidance_proj_dims=(32, 16),
-                 **kwargs):
-        super().__init__(**kwargs)
-        self.decoder_guidance_projection = nn.ModuleList([
-            nn.Sequential(
-                nn.Conv2d(
-                    dec_dims,
-                    dec_dims_proj,
-                    kernel_size=3,
-                    stride=1,
-                    padding=1),
-                nn.ReLU(),
-            ) for dec_dims, dec_dims_proj in zip(decoder_guidance_dims,
-                                                 decoder_guidance_proj_dims)
-        ]) if decoder_guidance_dims[0] > 0 else None
-
-        self.decoder1 = UpBlock(embed_dims, decoder_dims[0],
-                                decoder_guidance_proj_dims[0])
-        self.decoder2 = UpBlock(decoder_dims[0], decoder_dims[1],
-                                decoder_guidance_proj_dims[1])
-        self.conv_seg = nn.Conv2d(
-            decoder_dims[1], 1, kernel_size=3, stride=1, padding=1)
-
-    def forward(self, inputs):
-        """Forward function.
-
-        Args:
-            inputs (dict): Input features including the following features,
-                corr_embed: aggregated correlation embeddings.
-                appearance_feats: decoder appearance feature guidance.
-        """
-        # decoder guidance projection
-        if self.decoder_guidance_projection is not None:
-            projected_decoder_guidance = [
-                proj(g) for proj, g in zip(self.decoder_guidance_projection,
-                                           inputs['appearance_feats'])
-            ]
-
-        # decoder layers
-        B = inputs['corr_embed'].size(0)
-        corr_embed = inputs['corr_embed'].transpose(1, 2).flatten(0, 1)
-        corr_embed = self.decoder1(corr_embed, projected_decoder_guidance[0])
-        corr_embed = self.decoder2(corr_embed, projected_decoder_guidance[1])
-
-        output = self.cls_seg(corr_embed)
-
-        # rearrange the output to (B, T, H, W)
-        H_ori, W_ori = output.shape[-2:]
-        output = output.reshape(B, -1, H_ori, W_ori)
-        return output
diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/models/clip_ovseg.py b/mmsegmentation/projects/CAT-Seg/cat_seg/models/clip_ovseg.py
deleted file mode 100644
index cb67744..0000000
--- a/mmsegmentation/projects/CAT-Seg/cat_seg/models/clip_ovseg.py
+++ /dev/null
@@ -1,293 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import json
-import os
-from typing import List
-
-import torch
-import torch.nn.functional as F
-from huggingface_hub.utils._errors import LocalEntryNotFoundError
-from mmengine.model import BaseModule
-
-from mmseg.registry import MODELS
-from mmseg.utils import ConfigType
-from ..utils import clip_wrapper
-from ..utils.clip_templates import (IMAGENET_TEMPLATES,
-                                    IMAGENET_TEMPLATES_SELECT)
-
-
-@MODELS.register_module()
-class CLIPOVCATSeg(BaseModule):
-    """CLIP based Open Vocabulary CAT-Seg model backbone.
-
-    This backbone is the modified implementation of `CAT-Seg Backbone
-    <https://arxiv.org/abs/2303.11797>`_. It combines the CLIP model and
-    another feature extractor, a.k.a the appearance guidance extractor
-    in the original `CAT-Seg`.
-
-    Args:
-        feature_extractor (ConfigType): Appearance guidance extractor
-            config dict.
-        train_class_json (str): The training class json file.
-        test_class_json (str): The path to test class json file.
-        clip_pretrained (str): The pre-trained clip type.
-        clip_finetune (str): The finetuning settings of clip model.
-        custom_clip_weights (str): The custmized clip weights directory. When
-            encountering huggingface model download errors, you can manually
-            download the pretrained weights.
-        backbone_multiplier (float): The learning rate multiplier.
-            Default: 0.01.
-        prompt_depth (int): The prompt depth. Default: 0.
-        prompt_length (int): The prompt length. Default: 0.
-        prompt_ensemble_type (str): The prompt ensemble type.
-            Default: "imagenet".
-        pixel_mean (List[float]): The pixel mean for feature extractor.
-        pxiel_std (List[float]): The pixel std for feature extractor.
-        clip_pixel_mean (List[float]): The pixel mean for clip model.
-        clip_pxiel_std (List[float]): The pixel std for clip model.
-        clip_img_feat_size: (List[int]: Clip image embedding size from
-            image encoder.
-        init_cfg (dict or list[dict], optional): Initialization config dict.
-            Default: None.
-    """
-
-    def __init__(
-            self,
-            feature_extractor: ConfigType,
-            train_class_json: str,
-            test_class_json: str,
-            clip_pretrained: str,
-            clip_finetune: str,
-            custom_clip_weights: str = None,
-            backbone_multiplier=0.01,
-            prompt_depth: int = 0,
-            prompt_length: int = 0,
-            prompt_ensemble_type: str = 'imagenet',
-            pixel_mean: List[float] = [123.675, 116.280, 103.530],
-            pixel_std: List[float] = [58.395, 57.120, 57.375],
-            clip_pixel_mean: List[float] = [
-                122.7709383, 116.7460125, 104.09373615
-            ],
-            clip_pixel_std: List[float] = [68.5005327, 66.6321579, 70.3231630],
-            clip_img_feat_size: List[int] = [24, 24],
-            init_cfg=None):
-        super().__init__(init_cfg=init_cfg)
-        # normalization parameters
-        self.register_buffer('pixel_mean',
-                             torch.Tensor(pixel_mean).view(1, -1, 1, 1), False)
-        self.register_buffer('pixel_std',
-                             torch.Tensor(pixel_std).view(1, -1, 1, 1), False)
-        self.register_buffer('clip_pixel_mean',
-                             torch.Tensor(clip_pixel_mean).view(1, -1, 1, 1),
-                             False)
-        self.register_buffer('clip_pixel_std',
-                             torch.Tensor(clip_pixel_std).view(1, -1, 1, 1),
-                             False)
-        self.clip_resolution = (
-            384, 384) if clip_pretrained == 'ViT-B/16' else (336, 336)
-        # modified clip image encoder with fixed size dense output
-        self.clip_img_feat_size = clip_img_feat_size
-
-        # prepare clip templates
-        self.prompt_ensemble_type = prompt_ensemble_type
-        if self.prompt_ensemble_type == 'imagenet_select':
-            prompt_templates = IMAGENET_TEMPLATES_SELECT
-        elif self.prompt_ensemble_type == 'imagenet':
-            prompt_templates = IMAGENET_TEMPLATES
-        elif self.prompt_ensemble_type == 'single':
-            prompt_templates = [
-                'A photo of a {} in the scene',
-            ]
-        else:
-            raise NotImplementedError
-        self.prompt_templates = prompt_templates
-
-        # build the feature extractor
-        self.feature_extractor = MODELS.build(feature_extractor)
-
-        # build CLIP model
-        with open(train_class_json) as f_in:
-            self.class_texts = json.load(f_in)
-        with open(test_class_json) as f_in:
-            self.test_class_texts = json.load(f_in)
-        assert self.class_texts is not None
-        if self.test_class_texts is None:
-            self.test_class_texts = self.class_texts
-        device = 'cuda' if torch.cuda.is_available() else 'cpu'
-        self.tokenizer = None
-        if clip_pretrained == 'ViT-G' or clip_pretrained == 'ViT-H':
-            # for OpenCLIP models
-            import open_clip
-            name, pretrain = (
-                'ViT-H-14',
-                'laion2b_s32b_b79k') if clip_pretrained == 'ViT-H' else (
-                    'ViT-bigG-14', 'laion2b_s39b_b160k')
-            try:
-                open_clip_model = open_clip.create_model_and_transforms(
-                    name,
-                    pretrained=pretrain,
-                    device=device,
-                    force_image_size=336,
-                )
-                clip_model, _, clip_preprocess = open_clip_model
-            except ConnectionError or LocalEntryNotFoundError as e:
-                print(f'Has {e} when loading weights from huggingface!')
-                print(
-                    f'Will load {pretrain} weights from {custom_clip_weights}.'
-                )
-                assert custom_clip_weights is not None, 'Please specify custom weights directory.'  # noqa
-                assert os.path.exists(
-                    os.path.join(custom_clip_weights,
-                                 'open_clip_pytorch_model.bin')
-                ), 'Please provide a valid directory for manually downloaded model.'  # noqa
-                open_clip_model = open_clip.create_model_and_transforms(
-                    name,
-                    pretrained=None,
-                    device='cpu',
-                    force_image_size=336,
-                )
-                clip_model, _, clip_preprocess = open_clip_model
-
-                open_clip.load_checkpoint(
-                    clip_model,
-                    os.path.expanduser(
-                        os.path.join(custom_clip_weights,
-                                     'open_clip_pytorch_model.bin')))
-                clip_model.to(torch.device(device))
-
-            self.tokenizer = open_clip.get_tokenizer(name)
-        else:
-            # for OpenAI models
-            clip_model, clip_preprocess = clip_wrapper.load(
-                clip_pretrained,
-                device=device,
-                jit=False,
-                prompt_depth=prompt_depth,
-                prompt_length=prompt_length)
-
-        # pre-encode classes text prompts
-        text_features = self.class_embeddings(self.class_texts,
-                                              prompt_templates, clip_model,
-                                              device).permute(1, 0, 2).float()
-        text_features_test = self.class_embeddings(self.test_class_texts,
-                                                   prompt_templates,
-                                                   clip_model,
-                                                   device).permute(1, 0,
-                                                                   2).float()
-        self.register_buffer('text_features', text_features, False)
-        self.register_buffer('text_features_test', text_features_test, False)
-
-        # prepare CLIP model finetune
-        self.clip_finetune = clip_finetune
-        self.clip_model = clip_model.float()
-        self.clip_preprocess = clip_preprocess
-
-        for name, params in self.clip_model.named_parameters():
-            if 'visual' in name:
-                if clip_finetune == 'prompt':
-                    params.requires_grad = True if 'prompt' in name else False
-                elif clip_finetune == 'attention':
-                    if 'attn' in name or 'position' in name:
-                        params.requires_grad = True
-                    else:
-                        params.requires_grad = False
-                elif clip_finetune == 'full':
-                    params.requires_grad = True
-                else:
-                    params.requires_grad = False
-            else:
-                params.requires_grad = False
-
-        finetune_backbone = backbone_multiplier > 0.
-        for name, params in self.feature_extractor.named_parameters():
-            if 'norm0' in name:
-                params.requires_grad = False
-            else:
-                params.requires_grad = finetune_backbone
-
-    @torch.no_grad()
-    def class_embeddings(self,
-                         classnames,
-                         templates,
-                         clip_model,
-                         device='cpu'):
-        """Convert class names to text embeddings by clip model.
-
-        Args:
-            classnames (list): loaded from json file.
-            templates (dict): text template.
-            clip_model (nn.Module): prepared clip model.
-            device (str | torch.device): loading device of text
-                encoder results.
-        """
-        zeroshot_weights = []
-        for classname in classnames:
-            if ', ' in classname:
-                classname_splits = classname.split(', ')
-                texts = []
-                for template in templates:
-                    for cls_split in classname_splits:
-                        texts.append(template.format(cls_split))
-            else:
-                texts = [template.format(classname)
-                         for template in templates]  # format with class
-            if self.tokenizer is not None:
-                texts = self.tokenizer(texts).to(device)
-            else:
-                texts = clip_wrapper.tokenize(texts).to(device)
-            class_embeddings = clip_model.encode_text(texts)
-            class_embeddings /= class_embeddings.norm(dim=-1, keepdim=True)
-            if len(templates) != class_embeddings.shape[0]:
-                class_embeddings = class_embeddings.reshape(
-                    len(templates), -1, class_embeddings.shape[-1]).mean(dim=1)
-                class_embeddings /= class_embeddings.norm(dim=-1, keepdim=True)
-            class_embedding = class_embeddings
-            zeroshot_weights.append(class_embedding)
-        zeroshot_weights = torch.stack(zeroshot_weights, dim=1).to(device)
-        return zeroshot_weights
-
-    def custom_normalize(self, inputs):
-        """Input normalization for clip model and feature extractor
-        respectively.
-
-        Args:
-            inputs: batched input images.
-        """
-        # clip images
-        batched_clip = (inputs - self.clip_pixel_mean) / self.clip_pixel_std
-        batched_clip = F.interpolate(
-            batched_clip,
-            size=self.clip_resolution,
-            mode='bilinear',
-            align_corners=False)
-        # feature extractor images
-        batched = (inputs - self.pixel_mean) / self.pixel_std
-        return batched, batched_clip
-
-    def forward(self, inputs):
-        """
-        Args:
-            inputs: minibatch image. (B, 3, H, W)
-        Returns:
-            outputs (dict):
-            'appearance_feat': list[torch.Tensor], w.r.t. out_indices of
-                `self.feature_extractor`.
-            'clip_text_feat': the text feature extracted by clip text encoder.
-            'clip_text_feat_test': the text feature extracted by clip text
-                encoder for testing.
-            'clip_img_feat': the image feature extracted clip image encoder.
-        """
-        inputs, clip_inputs = self.custom_normalize(inputs)
-        outputs = dict()
-        # extract appearance guidance feature
-        outputs['appearance_feat'] = self.feature_extractor(inputs)
-
-        # extract clip features
-        outputs['clip_text_feat'] = self.text_features
-        outputs['clip_text_feat_test'] = self.text_features_test
-        clip_features = self.clip_model.encode_image(
-            clip_inputs, dense=True)  # B, 577(24x24+1), C
-        B = clip_features.size(0)
-        outputs['clip_img_feat'] = clip_features[:, 1:, :].permute(
-            0, 2, 1).reshape(B, -1, *self.clip_img_feat_size)
-
-        return outputs
diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/utils/__init__.py b/mmsegmentation/projects/CAT-Seg/cat_seg/utils/__init__.py
deleted file mode 100644
index 88746b2..0000000
--- a/mmsegmentation/projects/CAT-Seg/cat_seg/utils/__init__.py
+++ /dev/null
@@ -1,10 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .clip_templates import (IMAGENET_TEMPLATES, IMAGENET_TEMPLATES_SELECT,
-                             IMAGENET_TEMPLATES_SELECT_CLIP, ViLD_templates)
-from .self_attention_block import FullAttention, LinearAttention
-
-__all__ = [
-    'FullAttention', 'LinearAttention', 'IMAGENET_TEMPLATES',
-    'IMAGENET_TEMPLATES_SELECT', 'IMAGENET_TEMPLATES_SELECT_CLIP',
-    'ViLD_templates'
-]
diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/utils/bpe_vocab/bpe_simple_vocab_16e6.txt.gz b/mmsegmentation/projects/CAT-Seg/cat_seg/utils/bpe_vocab/bpe_simple_vocab_16e6.txt.gz
deleted file mode 100644
index 7b5088a527f720063f044eb928eee315f63b2fc0..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1356917
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%0D-8anuzg!0hrX~L}M*$l~SOpZ7=I+%ag
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%0A|F7fvQOLDQFPf3
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%0D+{l&4Elf+RUJ>DPlT<0vI!uxp-LitG
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%0DQu49$GwTP{0?>4l_B{}_v8!N|W%zC&9>
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%0Dk}39ByCzIU5yLcM+o6FDFaENYBu
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%0DL<K?1>h
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

diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_model.py b/mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_model.py
deleted file mode 100644
index 977444f..0000000
--- a/mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_model.py
+++ /dev/null
@@ -1,651 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from collections import OrderedDict
-from typing import Tuple, Union
-
-import torch
-import torch.nn.functional as F
-from torch import nn
-
-
-class Bottleneck(nn.Module):
-    """Custom implementation of Bottleneck in ResNet."""
-    expansion = 4
-
-    def __init__(self, inplanes, planes, stride=1):
-        super().__init__()
-        # all conv layers have stride 1.
-        # an avgpool is performed after the second convolution when stride > 1
-        self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False)
-        self.bn1 = nn.BatchNorm2d(planes)
-
-        self.conv2 = nn.Conv2d(planes, planes, 3, padding=1, bias=False)
-        self.bn2 = nn.BatchNorm2d(planes)
-
-        self.avgpool = nn.AvgPool2d(stride) if stride > 1 else nn.Identity()
-
-        self.conv3 = nn.Conv2d(planes, planes * self.expansion, 1, bias=False)
-        self.bn3 = nn.BatchNorm2d(planes * self.expansion)
-
-        self.relu = nn.ReLU(inplace=True)
-        self.downsample = None
-        self.stride = stride
-
-        if stride > 1 or inplanes != planes * Bottleneck.expansion:
-            # downsampling layer is prepended with an avgpool,
-            # and the subsequent convolution has stride 1
-            self.downsample = nn.Sequential(
-                OrderedDict([('-1', nn.AvgPool2d(stride)),
-                             ('0',
-                              nn.Conv2d(
-                                  inplanes,
-                                  planes * self.expansion,
-                                  1,
-                                  stride=1,
-                                  bias=False)),
-                             ('1', nn.BatchNorm2d(planes * self.expansion))]))
-
-    def forward(self, x: torch.Tensor):
-        """
-        Args:
-            x (torch.Tensor): the input feature.
-        """
-        identity = x
-
-        out = self.relu(self.bn1(self.conv1(x)))
-        out = self.relu(self.bn2(self.conv2(out)))
-        out = self.avgpool(out)
-        out = self.bn3(self.conv3(out))
-
-        if self.downsample is not None:
-            identity = self.downsample(x)
-
-        out += identity
-        out = self.relu(out)
-        return out
-
-
-class AttentionPool2d(nn.Module):
-    """Attention Pool2d."""
-
-    def __init__(self,
-                 spacial_dim: int,
-                 embed_dim: int,
-                 num_heads: int,
-                 output_dim: int = None):
-        super().__init__()
-        self.positional_embedding = nn.Parameter(
-            torch.randn(spacial_dim**2 + 1, embed_dim) / embed_dim**0.5)
-        self.k_proj = nn.Linear(embed_dim, embed_dim)
-        self.q_proj = nn.Linear(embed_dim, embed_dim)
-        self.v_proj = nn.Linear(embed_dim, embed_dim)
-        self.c_proj = nn.Linear(embed_dim, output_dim or embed_dim)
-        self.num_heads = num_heads
-
-    def forward(self, x):
-        """
-        Args:
-            x (torch.Tensor): the input feature.
-        """
-        x = x.flatten(start_dim=2).permute(2, 0, 1)  # NCHW -> (HW)NC
-        x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0)  # (HW+1)NC
-        x = x + self.positional_embedding[:, None, :].to(x.dtype)  # (HW+1)NC
-        x, _ = F.multi_head_attention_forward(
-            query=x[:1],
-            key=x,
-            value=x,
-            embed_dim_to_check=x.shape[-1],
-            num_heads=self.num_heads,
-            q_proj_weight=self.q_proj.weight,
-            k_proj_weight=self.k_proj.weight,
-            v_proj_weight=self.v_proj.weight,
-            in_proj_weight=None,
-            in_proj_bias=torch.cat(
-                [self.q_proj.bias, self.k_proj.bias, self.v_proj.bias]),
-            bias_k=None,
-            bias_v=None,
-            add_zero_attn=False,
-            dropout_p=0,
-            out_proj_weight=self.c_proj.weight,
-            out_proj_bias=self.c_proj.bias,
-            use_separate_proj_weight=True,
-            training=self.training,
-            need_weights=False)
-        return x.squeeze(0)
-
-
-class ModifiedResNet(nn.Module):
-    """A ResNet class that is similar to torchvision's but contains the
-    following changes:
-
-    - There are now 3 "stem" convolutions as opposed to 1, with an average
-        pool instead of a max pool.
-    - Performs anti-aliasing strided convolutions, where an avgpool is
-        prepended to convolutions with stride > 1
-    - The final pooling layer is a QKV attention instead of an average pool
-    """
-
-    def __init__(self,
-                 layers,
-                 output_dim,
-                 heads,
-                 input_resolution=224,
-                 width=64):
-        super().__init__()
-        self.output_dim = output_dim
-        self.input_resolution = input_resolution
-
-        # the 3-layer stem
-        self.conv1 = nn.Conv2d(
-            3, width // 2, kernel_size=3, stride=2, padding=1, bias=False)
-        self.bn1 = nn.BatchNorm2d(width // 2)
-        self.relu1 = nn.ReLU(inplace=True)
-        self.conv2 = nn.Conv2d(
-            width // 2, width // 2, kernel_size=3, padding=1, bias=False)
-        self.bn2 = nn.BatchNorm2d(width // 2)
-        self.relu2 = nn.ReLU(inplace=True)
-        self.conv3 = nn.Conv2d(
-            width // 2, width, kernel_size=3, padding=1, bias=False)
-        self.bn3 = nn.BatchNorm2d(width)
-        self.relu3 = nn.ReLU(inplace=True)
-        self.avgpool = nn.AvgPool2d(2)
-
-        # residual layers
-        # this is a *mutable* variable used during construction
-        self._inplanes = width
-        self.layer1 = self._make_layer(width, layers[0])
-        self.layer2 = self._make_layer(width * 2, layers[1], stride=2)
-        self.layer3 = self._make_layer(width * 4, layers[2], stride=2)
-        self.layer4 = self._make_layer(width * 8, layers[3], stride=2)
-
-        embed_dim = width * 32  # the ResNet feature dimension
-        self.attnpool = AttentionPool2d(input_resolution // 32, embed_dim,
-                                        heads, output_dim)
-
-    def _make_layer(self, planes, blocks, stride=1):
-        """Build resnet layers."""
-        layers = [Bottleneck(self._inplanes, planes, stride)]
-
-        self._inplanes = planes * Bottleneck.expansion
-        for _ in range(1, blocks):
-            layers.append(Bottleneck(self._inplanes, planes))
-
-        return nn.Sequential(*layers)
-
-    def forward(self, x):
-        """
-        Args:
-            x (torch.Tensor): the input mini-batch images.
-        """
-
-        def stem(x):
-            x = self.relu1(self.bn1(self.conv1(x)))
-            x = self.relu2(self.bn2(self.conv2(x)))
-            x = self.relu3(self.bn3(self.conv3(x)))
-            x = self.avgpool(x)
-            return x
-
-        x = x.type(self.conv1.weight.dtype)
-        x = stem(x)
-        x = self.layer1(x)
-        x = self.layer2(x)
-        x = self.layer3(x)
-        x = self.layer4(x)
-        x = self.attnpool(x)
-
-        return x
-
-
-class LayerNorm(nn.LayerNorm):
-    """Subclass torch's LayerNorm to handle fp16."""
-
-    def forward(self, x: torch.Tensor):
-        """
-        Args:
-            x (torch.Tensor): the input feature.
-        """
-        orig_type = x.dtype
-        ret = super().forward(x.type(torch.float32))
-        return ret.type(orig_type)
-
-
-class QuickGELU(nn.Module):
-    """Wrapper of GELU activation layer."""
-
-    def forward(self, x: torch.Tensor):
-        """
-        Args:
-            x (torch.Tensor): the input feature.
-        """
-        return x * torch.sigmoid(1.702 * x)
-
-
-class ResidualAttentionBlock(nn.Module):
-    """Attention block with residual connection."""
-
-    def __init__(self,
-                 d_model: int,
-                 n_head: int,
-                 attn_mask: torch.Tensor = None):
-        super().__init__()
-
-        self.attn = nn.MultiheadAttention(d_model, n_head)
-        self.ln_1 = LayerNorm(d_model)
-        self.mlp = nn.Sequential(
-            OrderedDict([('c_fc', nn.Linear(d_model, d_model * 4)),
-                         ('gelu', QuickGELU()),
-                         ('c_proj', nn.Linear(d_model * 4, d_model))]))
-        self.ln_2 = LayerNorm(d_model)
-        self.attn_mask = attn_mask
-        self.mask_pre_mlp = True
-
-    def attention(self, x: torch.Tensor):
-        """Calculate mask multi-head-attention."""
-        self.attn_mask = self.attn_mask.to(
-            dtype=x.dtype,
-            device=x.device) if self.attn_mask is not None else None
-        return self.attn(
-            x, x, x, need_weights=False, attn_mask=self.attn_mask)[0]
-
-    def forward(self, x: torch.Tensor):
-        """
-        Args:
-            x (torch.Tensor): the input feature.
-        """
-        x = x + self.attention(self.ln_1(x))
-        x = x + self.mlp(self.ln_2(x))
-        return x
-
-    def forward_dense(self, x: torch.Tensor):
-        """Reinplementation of forward function for dense prediction of image
-        encoder in CLIP model.
-
-        Args:
-            x (torch.Tensor): the input feature.
-        """
-        y = self.ln_1(x)
-        y = F.linear(y, self.attn.in_proj_weight, self.attn.in_proj_bias)
-        L, N, D = y.shape  # L N 3D
-
-        y = y.reshape(L, N, 3, D // 3).permute(2, 1, 0,
-                                               3).reshape(3 * N, L, D // 3)
-        y = F.linear(y, self.attn.out_proj.weight, self.attn.out_proj.bias)
-
-        q, k, v = y.tensor_split(3, dim=0)
-        v = v.transpose(1, 0) + x  # L N D
-
-        v = v + self.mlp(self.ln_2(v))
-        return v
-
-
-class Transformer(nn.Module):
-    """General Transformer Architecture for both image and text encoder."""
-
-    def __init__(self,
-                 width: int,
-                 layers: int,
-                 heads: int,
-                 attn_mask: torch.Tensor = None,
-                 prompt_length=0,
-                 prompt_depth=0):
-        super().__init__()
-        self.width = width
-        self.layers = layers
-        self.resblocks = nn.Sequential(*[
-            ResidualAttentionBlock(width, heads, attn_mask)
-            for _ in range(layers)
-        ])
-
-        self.prompt_length = prompt_length
-        self.prompt_depth = prompt_depth
-        self.prompt_tokens = nn.Parameter(
-            torch.zeros(prompt_depth, prompt_length,
-                        width)) if prompt_length > 0 else None
-        if self.prompt_tokens is not None:
-            nn.init.xavier_uniform_(self.prompt_tokens)
-
-    def forward(self, x: torch.Tensor, dense=False):
-        """
-        Args:
-            x (torch.Tensor): input features.
-            dense (bool): whether use reimplemented dense forward
-                function in the last layer.
-        """
-        for i, resblock in enumerate(self.resblocks):
-            if self.prompt_length > 0 and i < self.prompt_depth:
-                length = self.prompt_length + 1 if i > 0 else 1
-                x = torch.cat((x[0:1, :, :], self.prompt_tokens[i].repeat(
-                    x.shape[1], 1, 1).permute(1, 0, 2), x[length:, :, :]))
-
-            if i == self.layers - 1 and dense:
-                x = resblock.forward_dense(x)
-                x = torch.cat((x[0:1, :, :], x[self.prompt_length + 1::, :]),
-                              dim=0)
-            else:
-                x = resblock(x)
-
-        return x
-
-
-class VisualTransformer(nn.Module):
-    """Visual encoder for CLIP model."""
-
-    def __init__(self, input_resolution: int, patch_size: int, width: int,
-                 layers: int, heads: int, output_dim: int, prompt_depth: int,
-                 prompt_length: int):
-        super().__init__()
-        self.output_dim = output_dim
-        self.conv1 = nn.Conv2d(
-            in_channels=3,
-            out_channels=width,
-            kernel_size=patch_size,
-            stride=patch_size,
-            bias=False)
-
-        scale = width**-0.5
-        self.class_embedding = nn.Parameter(scale * torch.randn(width))
-        self.positional_embedding = nn.Parameter(scale * torch.randn(
-            (input_resolution // patch_size)**2 + 1, width))
-        self.ln_pre = LayerNorm(width)
-
-        self.transformer = Transformer(
-            width,
-            layers,
-            heads,
-            prompt_depth=prompt_depth,
-            prompt_length=prompt_length)
-
-        self.ln_post = LayerNorm(width)
-        self.proj = nn.Parameter(scale * torch.randn(width, output_dim))
-
-        self.patch_size = patch_size
-        self.input_resolution = input_resolution
-
-    def forward(self, x: torch.Tensor, dense=False):
-        """
-        Args:
-            x (torch.Tensor): input features.
-            dense (bool): whether use reimplemented dense forward
-                function in the last layer.
-        """
-        x = self.conv1(x)  # shape = [*, width, grid, grid]
-        x = x.reshape(x.shape[0], x.shape[1],
-                      -1)  # shape = [*, width, grid ** 2]
-        x = x.permute(0, 2, 1)  # shape = [*, grid ** 2, width]
-        x = torch.cat([
-            self.class_embedding.to(x.dtype) + torch.zeros(
-                x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device), x
-        ],
-                      dim=1)  # shape = [*, grid ** 2 + 1, width]
-
-        if dense and (x.shape[1] != self.positional_embedding.shape[0]):
-            x = x + self.resized_pos_embed(self.input_resolution,
-                                           x.shape[1]).to(x.dtype)
-        else:
-            x = x + self.positional_embedding.to(x.dtype)
-
-        x = self.ln_pre(x)
-
-        x = x.permute(1, 0, 2)  # NLD -> LND
-        x = self.transformer(x, dense)
-        x = x.permute(1, 0, 2)  # LND -> NLD
-
-        if dense:
-            x = self.ln_post(x[:, :, :])
-        else:
-            x = self.ln_post(x[:, 0, :])
-
-        if self.proj is not None:
-            x = x @ self.proj
-
-        return x
-
-    def resized_pos_embed(self, in_res, tgt_res, mode='bicubic'):
-        """Resize the position embedding."""
-        # assert L == (input_resolution // self.patch_size) ** 2 + 1
-        L, D = self.positional_embedding.shape
-
-        in_side = in_res // self.patch_size
-        # tgt_side = tgt_res // self.patch_size
-        tgt_side = int((tgt_res - 1)**0.5)
-
-        cls_pos = self.positional_embedding[0].unsqueeze(0)  # 1 D
-        pos_embed = self.positional_embedding[1:].reshape(
-            1, in_side, in_side, D).permute(0, 3, 1, 2)  # L-1 D -> 1 D S S
-        resized_pos_embed = F.interpolate(
-            pos_embed,
-            size=(tgt_side, tgt_side),
-            mode=mode,
-            align_corners=False,
-        )  # 1 D S S -> 1 D S' S'
-        resized_pos_embed = resized_pos_embed.squeeze(0).reshape(
-            D, -1).T  # L'-1 D
-
-        return torch.cat((cls_pos, resized_pos_embed), dim=0)
-
-
-class CLIP(nn.Module):
-    """Custom implementation of CLIP model.
-
-    Refer to: https://github.com/openai/CLIP
-    """
-
-    def __init__(
-        self,
-        embed_dim: int,
-        # vision
-        image_resolution: int,
-        vision_layers: Union[Tuple[int, int, int, int], int],
-        vision_width: int,
-        vision_patch_size: int,
-        # text
-        context_length: int,
-        vocab_size: int,
-        transformer_width: int,
-        transformer_heads: int,
-        transformer_layers: int,
-        # prompt
-        prompt_depth: int = 0,
-        prompt_length: int = 0,
-    ):
-        super().__init__()
-
-        self.context_length = context_length
-
-        self.image_resolution = image_resolution
-
-        if isinstance(vision_layers, (tuple, list)):
-            assert prompt_length == 0 and prompt_depth == 0
-            vision_heads = vision_width * 32 // 64
-            self.visual = ModifiedResNet(
-                layers=vision_layers,
-                output_dim=embed_dim,
-                heads=vision_heads,
-                input_resolution=image_resolution,
-                width=vision_width)
-        else:
-            vision_heads = vision_width // 64
-            self.visual = VisualTransformer(
-                input_resolution=image_resolution,
-                patch_size=vision_patch_size,
-                width=vision_width,
-                layers=vision_layers,
-                heads=vision_heads,
-                output_dim=embed_dim,
-                prompt_depth=prompt_depth,
-                prompt_length=prompt_length,
-            )
-
-        self.transformer = Transformer(
-            width=transformer_width,
-            layers=transformer_layers,
-            heads=transformer_heads,
-            attn_mask=self.build_attention_mask())
-
-        self.vocab_size = vocab_size
-        self.token_embedding = nn.Embedding(vocab_size, transformer_width)
-        self.positional_embedding = nn.Parameter(
-            torch.empty(self.context_length, transformer_width))
-        self.ln_final = LayerNorm(transformer_width)
-
-        self.text_projection = nn.Parameter(
-            torch.empty(transformer_width, embed_dim))
-        self.logit_scale = nn.Parameter(torch.ones([]))
-
-    def build_attention_mask(self):
-        """Create causal attention mask."""
-        # lazily create causal attention mask, with full attention between
-        # the vision tokens pytorch uses additive attention mask; fill with
-        # -inf
-        mask = torch.empty(self.context_length, self.context_length)
-        mask.fill_(float('-inf'))
-        mask.triu_(1)  # zero out the lower diagonal
-        return mask
-
-    @property
-    def dtype(self):
-        """Return the dtype of the model."""
-        return self.visual.conv1.weight.dtype
-
-    def encode_image(self, image, masks=None, pool_mask=None, dense=False):
-        """Image encoding."""
-        if pool_mask is not None:
-            return self.visual(
-                image.type(self.dtype), mask=pool_mask, dense=dense)
-        if masks is None:
-            return self.visual(image.type(self.dtype), dense=dense)
-        else:
-            return self.visual(image.type(self.dtype), masks.type(self.dtype))
-
-    def encode_text(self, text):
-        """Texts encoding."""
-        x = self.token_embedding(text).type(
-            self.dtype)  # [batch_size, n_ctx, d_model]
-
-        x = x + self.positional_embedding.type(self.dtype)
-        x = x.permute(1, 0, 2)  # NLD -> LND
-        x = self.transformer(x)
-        x = x.permute(1, 0, 2)  # LND -> NLD
-        x = self.ln_final(x).type(self.dtype)
-
-        # x.shape = [batch_size, n_ctx, transformer.width]
-        # take features from the eot embedding (eot_token is the highest number
-        # in each sequence)
-        x = x[torch.arange(x.shape[0]),
-              text.argmax(dim=-1)] @ self.text_projection
-
-        return x
-
-    def forward(self, image, text):
-        """
-        Args:
-            image (torch.Tensor): input images.
-            text (torch.Tensor): input text.
-        """
-        image_features = self.encode_image(image)
-        text_features = self.encode_text(text)
-        # import pdb; pdb.set_trace()
-        # normalized features
-        # image_features shape: [1, 1024]
-        image_features = image_features / image_features.norm(
-            dim=-1, keepdim=True)
-        text_features = text_features / text_features.norm(
-            dim=-1, keepdim=True)
-
-        # cosine similarity as logits
-        logit_scale = self.logit_scale.exp()
-        logits_per_iamge = logit_scale * image_features @ text_features.t()
-        logits_per_text = logit_scale * text_features @ image_features.t()
-
-        # shape = [global_batch_size, global_batch_size]
-        return logits_per_iamge, logits_per_text
-
-
-def convert_weights(model: nn.Module):
-    """Convert applicable model parameters to fp16."""
-
-    def _convert_weights_to_fp16(layer):
-        if isinstance(layer, (nn.Conv1d, nn.Conv2d, nn.Linear)):
-            layer.weight.data = layer.weight.data.half()
-            if layer.bias is not None:
-                layer.bias.data = layer.bias.data.half()
-
-        if isinstance(layer, nn.MultiheadAttention):
-            for attr in [
-                    *[f'{s}_proj_weight' for s in ['in', 'q', 'k', 'v']],
-                    'in_proj_bias', 'bias_k', 'bias_v'
-            ]:
-                tensor = getattr(layer, attr)
-                if tensor is not None:
-                    tensor.data = tensor.data.half()
-
-        for name in ['text_projection', 'proj']:
-            if hasattr(layer, name):
-                attr = getattr(layer, name)
-                if attr is not None:
-                    attr.data = attr.data.half()
-
-    model.apply(_convert_weights_to_fp16)
-
-
-def build_model(state_dict: dict, prompt_depth=0, prompt_length=0):
-    """Build a CLIP model from given pretrained weights."""
-    vit = 'visual.proj' in state_dict
-
-    if vit:
-        vision_width = state_dict['visual.conv1.weight'].shape[0]
-        vision_layers = len([
-            k for k in state_dict.keys()
-            if k.startswith('visual.') and k.endswith('.attn.in_proj_weight')
-        ])
-        vision_patch_size = state_dict['visual.conv1.weight'].shape[-1]
-        grid_size = round(
-            (state_dict['visual.positional_embedding'].shape[0] - 1)**0.5)
-        image_resolution = vision_patch_size * grid_size
-    else:
-        counts: list = [
-            len({
-                k.split('.')[2]
-                for k in state_dict if k.startswith(f'visual.layer{b}')
-            }) for b in [1, 2, 3, 4]
-        ]
-        vision_layers = tuple(counts)
-        vision_width = state_dict['visual.layer1.0.conv1.weight'].shape[0]
-        output_width = round(
-            (state_dict['visual.attnpool.positional_embedding'].shape[0] -
-             1)**0.5)
-        vision_patch_size = None
-        assert output_width**2 + 1 == state_dict[
-            'visual.attnpool.positional_embedding'].shape[0]
-        image_resolution = output_width * 32
-
-    embed_dim = state_dict['text_projection'].shape[1]
-    context_length = state_dict['positional_embedding'].shape[0]
-    vocab_size = state_dict['token_embedding.weight'].shape[0]
-    transformer_width = state_dict['ln_final.weight'].shape[0]
-    transformer_heads = transformer_width // 64
-    transformer_layers = len({
-        k.split('.')[2]
-        for k in state_dict if k.startswith('transformer.resblocks')
-    })
-
-    model = CLIP(
-        embed_dim,
-        image_resolution,
-        vision_layers,
-        vision_width,
-        vision_patch_size,
-        context_length,
-        vocab_size,
-        transformer_width,
-        transformer_heads,
-        transformer_layers,
-        prompt_depth=prompt_depth,
-        prompt_length=prompt_length,
-    )
-
-    for key in ['input_resolution', 'context_length', 'vocab_size']:
-        del state_dict[key]
-
-    convert_weights(model)
-    model.load_state_dict(state_dict, strict=False)
-    return model.eval()
diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_templates.py b/mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_templates.py
deleted file mode 100644
index bfc32df..0000000
--- a/mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_templates.py
+++ /dev/null
@@ -1,204 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-
-# Source: https://github.com/openai/CLIP.
-
-IMAGENET_TEMPLATES = [
-    'a bad photo of a {}.',
-    'a photo of many {}.',
-    'a sculpture of a {}.',
-    'a photo of the hard to see {}.',
-    'a low resolution photo of the {}.',
-    'a rendering of a {}.',
-    'graffiti of a {}.',
-    'a bad photo of the {}.',
-    'a cropped photo of the {}.',
-    'a tattoo of a {}.',
-    'the embroidered {}.',
-    'a photo of a hard to see {}.',
-    'a bright photo of a {}.',
-    'a photo of a clean {}.',
-    'a photo of a dirty {}.',
-    'a dark photo of the {}.',
-    'a drawing of a {}.',
-    'a photo of my {}.',
-    'the plastic {}.',
-    'a photo of the cool {}.',
-    'a close-up photo of a {}.',
-    'a black and white photo of the {}.',
-    'a painting of the {}.',
-    'a painting of a {}.',
-    'a pixelated photo of the {}.',
-    'a sculpture of the {}.',
-    'a bright photo of the {}.',
-    'a cropped photo of a {}.',
-    'a plastic {}.',
-    'a photo of the dirty {}.',
-    'a jpeg corrupted photo of a {}.',
-    'a blurry photo of the {}.',
-    'a photo of the {}.',
-    'a good photo of the {}.',
-    'a rendering of the {}.',
-    'a {} in a video game.',
-    'a photo of one {}.',
-    'a doodle of a {}.',
-    'a close-up photo of the {}.',
-    'a photo of a {}.',
-    'the origami {}.',
-    'the {} in a video game.',
-    'a sketch of a {}.',
-    'a doodle of the {}.',
-    'a origami {}.',
-    'a low resolution photo of a {}.',
-    'the toy {}.',
-    'a rendition of the {}.',
-    'a photo of the clean {}.',
-    'a photo of a large {}.',
-    'a rendition of a {}.',
-    'a photo of a nice {}.',
-    'a photo of a weird {}.',
-    'a blurry photo of a {}.',
-    'a cartoon {}.',
-    'art of a {}.',
-    'a sketch of the {}.',
-    'a embroidered {}.',
-    'a pixelated photo of a {}.',
-    'itap of the {}.',
-    'a jpeg corrupted photo of the {}.',
-    'a good photo of a {}.',
-    'a plushie {}.',
-    'a photo of the nice {}.',
-    'a photo of the small {}.',
-    'a photo of the weird {}.',
-    'the cartoon {}.',
-    'art of the {}.',
-    'a drawing of the {}.',
-    'a photo of the large {}.',
-    'a black and white photo of a {}.',
-    'the plushie {}.',
-    'a dark photo of a {}.',
-    'itap of a {}.',
-    'graffiti of the {}.',
-    'a toy {}.',
-    'itap of my {}.',
-    'a photo of a cool {}.',
-    'a photo of a small {}.',
-    'a tattoo of the {}.',
-    # 'A photo of a {} in the scene.',
-]
-
-# v1: 59.0875
-IMAGENET_TEMPLATES_SELECT = [
-    'itap of a {}.',
-    'a bad photo of the {}.',
-    'a origami {}.',
-    'a photo of the large {}.',
-    'a {} in a video game.',
-    'art of the {}.',
-    'a photo of the small {}.',
-    'A photo of a {} in the scene',
-]
-
-# v9
-IMAGENET_TEMPLATES_SELECT_CLIP = [
-    'a bad photo of the {}.',
-    'a photo of the large {}.',
-    'a photo of the small {}.',
-    'a cropped photo of a {}.',
-    'This is a photo of a {}',
-    'This is a photo of a small {}',
-    'This is a photo of a medium {}',
-    'This is a photo of a large {}',
-    'This is a masked photo of a {}',
-    'This is a masked photo of a small {}',
-    'This is a masked photo of a medium {}',
-    'This is a masked photo of a large {}',
-    'This is a cropped photo of a {}',
-    'This is a cropped photo of a small {}',
-    'This is a cropped photo of a medium {}',
-    'This is a cropped photo of a large {}',
-    'A photo of a {} in the scene',
-    'a bad photo of the {} in the scene',
-    'a photo of the large {} in the scene',
-    'a photo of the small {} in the scene',
-    'a cropped photo of a {} in the scene',
-    'a photo of a masked {} in the scene',
-    'There is a {} in the scene',
-    'There is the {} in the scene',
-    'This is a {} in the scene',
-    'This is the {} in the scene',
-    'This is one {} in the scene',
-    'There is a masked {} in the scene',
-    'There is the masked {} in the scene',
-    'This is a masked {} in the scene',
-    'This is the masked {} in the scene',
-    'This is one masked {} in the scene',
-]
-
-# v10, for comparison
-# IMAGENET_TEMPLATES_SELECT_CLIP = [
-#     'a photo of a {}.',
-#
-#     'This is a photo of a {}',
-#     'This is a photo of a small {}',
-#     'This is a photo of a medium {}',
-#     'This is a photo of a large {}',
-#
-#     'This is a photo of a {}',
-#     'This is a photo of a small {}',
-#     'This is a photo of a medium {}',
-#     'This is a photo of a large {}',
-#
-#     'a photo of a {} in the scene',
-#     'a photo of a {} in the scene',
-#
-#     'There is a {} in the scene',
-#     'There is the {} in the scene',
-#     'This is a {} in the scene',
-#     'This is the {} in the scene',
-#     'This is one {} in the scene',
-# ]
-
-ViLD_templates = [
-    'There is {article} {category} in the scene.',
-    'There is the {category} in the scene.',
-    'a photo of {article} {category} in the scene.',
-    'a photo of the {category} in the scene.',
-    'a photo of one {category} in the scene.', 'itap of {article} {category}.',
-    'itap of my {category}.', 'itap of the {category}.',
-    'a photo of {article} {category}.', 'a photo of my {category}.',
-    'a photo of the {category}.', 'a photo of one {category}.',
-    'a photo of many {category}.', 'a good photo of {article} {category}.',
-    'a good photo of the {category}.', 'a bad photo of {article} {category}.',
-    'a bad photo of the {category}.', 'a photo of a nice {category}.',
-    'a photo of the nice {category}.', 'a photo of a cool {category}.',
-    'a photo of the cool {category}.', 'a photo of a weird {category}.',
-    'a photo of the weird {category}.', 'a photo of a small {category}.',
-    'a photo of the small {category}.', 'a photo of a large {category}.',
-    'a photo of the large {category}.', 'a photo of a clean {category}.',
-    'a photo of the clean {category}.', 'a photo of a dirty {category}.',
-    'a photo of the dirty {category}.',
-    'a bright photo of {article} {category}.',
-    'a bright photo of the {category}.',
-    'a dark photo of {article} {category}.', 'a dark photo of the {category}.',
-    'a photo of a hard to see {category}.',
-    'a photo of the hard to see {category}.',
-    'a low resolution photo of {article} {category}.',
-    'a low resolution photo of the {category}.',
-    'a cropped photo of {article} {category}.',
-    'a cropped photo of the {category}.',
-    'a close-up photo of {article} {category}.',
-    'a close-up photo of the {category}.',
-    'a jpeg corrupted photo of {article} {category}.',
-    'a jpeg corrupted photo of the {category}.',
-    'a blurry photo of {article} {category}.',
-    'a blurry photo of the {category}.',
-    'a pixelated photo of {article} {category}.',
-    'a pixelated photo of the {category}.',
-    'a black and white photo of the {category}.',
-    'a black and white photo of {article} {category}.',
-    'a plastic {category}.', 'the plastic {category}.', 'a toy {category}.',
-    'the toy {category}.', 'a plushie {category}.', 'the plushie {category}.',
-    'a cartoon {category}.', 'the cartoon {category}.',
-    'an embroidered {category}.', 'the embroidered {category}.',
-    'a painting of the {category}.', 'a painting of a {category}.'
-]
diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_wrapper.py b/mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_wrapper.py
deleted file mode 100644
index f809d2b..0000000
--- a/mmsegmentation/projects/CAT-Seg/cat_seg/utils/clip_wrapper.py
+++ /dev/null
@@ -1,275 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-# Referred to: https://github.com/KU-CVLAB/CAT-Seg/blob/main/cat_seg/third_party/clip.py # noqa
-import hashlib
-import os
-import urllib
-import warnings
-from typing import List, Union
-
-import torch
-from PIL import Image
-from torchvision.transforms import (CenterCrop, Compose, Normalize, Resize,
-                                    ToTensor)
-from tqdm import tqdm
-
-from .clip_model import build_model
-from .tokenizer import SimpleTokenizer as _Tokenizer
-
-__all__ = ['available_models', 'load', 'tokenize']
-_tokenizer = _Tokenizer()
-
-_MODELS = {
-    'RN50':
-    'https://openaipublic.azureedge.net/clip/models/afeb0e10f9e5a86da6080e35cf09123aca3b358a0c3e3b6c78a7b63bc04b6762/RN50.pt',  # noqa
-    'RN101':
-    'https://openaipublic.azureedge.net/clip/models/8fa8567bab74a42d41c5915025a8e4538c3bdbe8804a470a72f30b0d94fab599/RN101.pt',  # noqa
-    'RN50x4':
-    'https://openaipublic.azureedge.net/clip/models/7e526bd135e493cef0776de27d5f42653e6b4c8bf9e0f653bb11773263205fdd/RN50x4.pt',  # noqa
-    'RN50x16':
-    'https://openaipublic.azureedge.net/clip/models/52378b407f34354e150460fe41077663dd5b39c54cd0bfd2b27167a4a06ec9aa/RN50x16.pt',  # noqa
-    'RN50x64':
-    'https://openaipublic.azureedge.net/clip/models/be1cfb55d75a9666199fb2206c106743da0f6468c9d327f3e0d0a543a9919d9c/RN50x64.pt',  # noqa
-    'ViT-B/32':
-    'https://openaipublic.azureedge.net/clip/models/40d365715913c9da98579312b702a82c18be219cc2a73407c4526f58eba950af/ViT-B-32.pt',  # noqa
-    'ViT-B/16':
-    'https://openaipublic.azureedge.net/clip/models/5806e77cd80f8b59890b7e101eabd078d9fb84e6937f9e85e4ecb61988df416f/ViT-B-16.pt',  # noqa
-    'ViT-L/14':
-    'https://openaipublic.azureedge.net/clip/models/b8cca3fd41ae0c99ba7e8951adf17d267cdb84cd88be6f7c2e0eca1737a03836/ViT-L-14.pt',  # noqa
-    'ViT-L/14@336px':
-    'https://openaipublic.azureedge.net/clip/models/3035c92b350959924f9f00213499208652fc7ea050643e8b385c2dac08641f02/ViT-L-14-336px.pt',  # noqa
-}
-
-
-def _download(url: str, root: str = os.path.expanduser('~/.cache/clip')):
-    """Download clip pretrained weights."""
-    os.makedirs(root, exist_ok=True)
-    filename = os.path.basename(url)
-
-    expected_sha256 = url.split('/')[-2]
-    download_target = os.path.join(root, filename)
-
-    if os.path.exists(download_target) and not os.path.isfile(download_target):
-        raise RuntimeError(
-            f'{download_target} exists and is not a regular file')
-
-    if os.path.isfile(download_target):
-        if hashlib.sha256(open(download_target,
-                               'rb').read()).hexdigest() == expected_sha256:
-            return download_target
-        else:
-            warnings.warn(
-                f'{download_target} exists, but the SHA256 checksum does not\
-                match; re-downloading the file')
-
-    with urllib.request.urlopen(url) as source, open(download_target,
-                                                     'wb') as output:
-        with tqdm(
-                total=int(source.info().get('Content-Length')),
-                ncols=80) as loop:
-            while True:
-                buffer = source.read(8192)
-                if not buffer:
-                    break
-
-                output.write(buffer)
-                loop.update(len(buffer))
-
-    if hashlib.sha256(open(download_target,
-                           'rb').read()).hexdigest() != expected_sha256:
-        raise RuntimeError(
-            'Model has been downloaded but the SHA256 checksum does not not\
-                match')
-
-    return download_target
-
-
-def available_models():
-    """Returns a list of available models."""
-    return list(_MODELS.keys())
-
-
-def load(name: str,
-         device: Union[str, torch.device] = 'cuda'
-         if torch.cuda.is_available() else 'cpu',
-         jit=True,
-         prompt_depth=0,
-         prompt_length=0):
-    """Load target clip model."""
-    if name not in _MODELS:
-        raise RuntimeError(
-            f'Model {name} not found; available models = {available_models()}')
-
-    model_path = _download(_MODELS[name])
-    model = torch.jit.load(
-        model_path, map_location=device if jit else 'cpu').eval()
-    n_px = model.input_resolution.item()
-
-    transform = Compose([
-        Resize(n_px, interpolation=Image.BICUBIC),
-        CenterCrop(n_px),
-        lambda image: image.convert('RGB'),
-        ToTensor(),
-        Normalize((0.48145466, 0.4578275, 0.40821073),
-                  (0.26862954, 0.26130258, 0.27577711)),
-    ])
-
-    if not jit:
-        model = build_model(model.state_dict(), prompt_depth,
-                            prompt_length).to(device)
-        return model, transform
-
-    # patch the device names
-    device_holder = torch.jit.trace(
-        lambda: torch.ones([]).to(torch.device(device)), example_inputs=[])
-    device_node = [
-        n for n in device_holder.graph.findAllNodes('prim::Constant')
-        if 'Device' in repr(n)
-    ][-1]
-
-    def patch_device(module):
-        graphs = [module.graph] if hasattr(module, 'graph') else []
-        if hasattr(module, 'forward1'):
-            graphs.append(module.forward1.graph)
-
-        for graph in graphs:
-            for node in graph.findAllNodes('prim::Constant'):
-                if 'value' in node.attributeNames() and str(
-                        node['value']).startswith('cuda'):
-                    node.copyAttributes(device_node)
-
-    model.apply(patch_device)
-    patch_device(model.encode_image)
-    patch_device(model.encode_text)
-
-    # patch dtype to float32 on CPU
-    if device == 'cpu':
-        float_holder = torch.jit.trace(
-            lambda: torch.ones([]).float(), example_inputs=[])
-        float_input = list(float_holder.graph.findNode('aten::to').inputs())[1]
-        float_node = float_input.node()
-
-        def patch_float(module):
-            graphs = [module.graph] if hasattr(module, 'graph') else []
-            if hasattr(module, 'forward1'):
-                graphs.append(module.forward1.graph)
-
-            for graph in graphs:
-                for node in graph.findAllNodes('aten::to'):
-                    inputs = list(node.inputs())
-                    for i in [1, 2]:
-                        # dtype can be the second or third argument to
-                        # aten::to()
-                        if inputs[i].node()['value'] == 5:
-                            inputs[i].node().copyAttributes(float_node)
-
-        model.apply(patch_float)
-        patch_float(model.encode_image)
-        patch_float(model.encode_text)
-
-        model.float()
-
-    return model, transform
-
-
-def load_custom(name: str,
-                device: Union[str, torch.device] = 'cuda'
-                if torch.cuda.is_available() else 'cpu',
-                jit=True,
-                n_px=224):
-    """Load a customized clip model."""
-    if name not in _MODELS:
-        raise RuntimeError(
-            f'Model {name} not found; available models = {available_models()}')
-
-    model_path = _download(_MODELS[name])
-    model = torch.jit.load(
-        model_path, map_location=device if jit else 'cpu').eval()
-    # n_px = model.input_resolution.item()
-
-    transform = Compose([
-        Resize(n_px, interpolation=Image.BICUBIC),
-        CenterCrop(n_px),
-        lambda image: image.convert('RGB'),
-        ToTensor(),
-        Normalize((0.48145466, 0.4578275, 0.40821073),
-                  (0.26862954, 0.26130258, 0.27577711)),
-    ])
-
-    if not jit:
-        model = build_model(model.state_dict()).to(device)
-        return model, transform
-
-    # patch the device names
-    device_holder = torch.jit.trace(
-        lambda: torch.ones([]).to(torch.device(device)), example_inputs=[])
-    device_node = [
-        n for n in device_holder.graph.findAllNodes('prim::Constant')
-        if 'Device' in repr(n)
-    ][-1]
-
-    def patch_device(module):
-        graphs = [module.graph] if hasattr(module, 'graph') else []
-        if hasattr(module, 'forward1'):
-            graphs.append(module.forward1.graph)
-
-        for graph in graphs:
-            for node in graph.findAllNodes('prim::Constant'):
-                if 'value' in node.attributeNames() and str(
-                        node['value']).startswith('cuda'):
-                    node.copyAttributes(device_node)
-
-    model.apply(patch_device)
-    patch_device(model.encode_image)
-    patch_device(model.encode_text)
-
-    # patch dtype to float32 on CPU
-    if device == 'cpu':
-        float_holder = torch.jit.trace(
-            lambda: torch.ones([]).float(), example_inputs=[])
-        float_input = list(float_holder.graph.findNode('aten::to').inputs())[1]
-        float_node = float_input.node()
-
-        def patch_float(module):
-            graphs = [module.graph] if hasattr(module, 'graph') else []
-            if hasattr(module, 'forward1'):
-                graphs.append(module.forward1.graph)
-
-            for graph in graphs:
-                for node in graph.findAllNodes('aten::to'):
-                    inputs = list(node.inputs())
-                    for i in [
-                            1, 2
-                    ]:  # dtype can be the second or third argument to
-                        # aten::to()
-                        if inputs[i].node()['value'] == 5:
-                            inputs[i].node().copyAttributes(float_node)
-
-        model.apply(patch_float)
-        patch_float(model.encode_image)
-        patch_float(model.encode_text)
-
-        model.float()
-
-    return model, transform
-
-
-def tokenize(texts: Union[str, List[str]], context_length: int = 77):
-    """Convert texts to tokens."""
-    if isinstance(texts, str):
-        texts = [texts]
-
-    sot_token = _tokenizer.encoder['<|startoftext|>']
-    eot_token = _tokenizer.encoder['<|endoftext|>']
-    # encode each template text phrase
-    all_tokens = [[sot_token] + _tokenizer.encode(text) + [eot_token]
-                  for text in texts]
-    result = torch.zeros(len(all_tokens), context_length, dtype=torch.long)
-
-    for i, tokens in enumerate(all_tokens):
-        if len(tokens) > context_length:
-            raise RuntimeError(
-                f'Input {texts[i]} is too long for context length\
-                    {context_length}')
-        result[i, :len(tokens)] = torch.tensor(tokens)
-
-    return result
diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/utils/self_attention_block.py b/mmsegmentation/projects/CAT-Seg/cat_seg/utils/self_attention_block.py
deleted file mode 100644
index 1c06cbd..0000000
--- a/mmsegmentation/projects/CAT-Seg/cat_seg/utils/self_attention_block.py
+++ /dev/null
@@ -1,79 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-from torch import nn as nn
-from torch.nn import functional as F
-
-
-class LinearAttention(nn.Module):
-    """Multi-Head linear attention proposed in "Transformers are RNNs".
-
-    Source: https://github.com/KU-CVLAB/CAT-Seg/blob/main/cat_seg/modeling/transformer/model.py#L247 # noqa
-    """
-
-    def __init__(self, eps=1e-6):
-        super().__init__()
-        self.eps = eps
-
-    def forward(self, queries, keys, values):
-        """
-        Args:
-            queries: [N, L, H, D]
-            keys: [N, S, H, D]
-            values: [N, S, H, D]
-            q_mask: [N, L]
-            kv_mask: [N, S]
-        Returns:
-            queried_values: (N, L, H, D)
-        """
-        Q = F.elu(queries) + 1
-        K = F.elu(keys) + 1
-
-        v_length = values.size(1)
-        values = values / v_length  # prevent fp16 overflow
-        KV = torch.einsum('nshd,nshv->nhdv', K, values)  # (S,D)' @ S,V
-        Z = 1 / (torch.einsum('nlhd,nhd->nlh', Q, K.sum(dim=1)) + self.eps)
-        queried_values = torch.einsum('nlhd,nhdv,nlh->nlhv', Q, KV,
-                                      Z) * v_length
-
-        return queried_values.contiguous()
-
-
-class FullAttention(nn.Module):
-    """Multi-head scaled dot-product attention, a.k.a full attention.
-
-    Source: https://github.com/KU-CVLAB/CAT-Seg/blob/main/cat_seg/modeling/transformer/model.py#L276 # noqa
-    """
-
-    def __init__(self, use_dropout=False, attention_dropout=0.1):
-        super().__init__()
-        self.use_dropout = use_dropout
-        self.dropout = nn.Dropout(attention_dropout)
-
-    def forward(self, queries, keys, values, q_mask=None, kv_mask=None):
-        """
-        Args:
-            queries: [N, L, H, D]
-            keys: [N, S, H, D]
-            values: [N, S, H, D]
-            q_mask: [N, L]
-            kv_mask: [N, S]
-        Returns:
-            queried_values: (N, L, H, D)
-        """
-
-        # Compute the unnormalized attention and apply the masks
-        QK = torch.einsum('nlhd,nshd->nlsh', queries, keys)
-        if kv_mask is not None:
-            QK.masked_fill_(
-                ~(q_mask[:, :, None, None] * kv_mask[:, None, :, None]),
-                float('-inf'))
-
-        # Compute the attention and the weighted average
-        softmax_temp = 1. / queries.size(3)**.5  # sqrt(D)
-        A = torch.softmax(softmax_temp * QK, dim=2)
-        if self.use_dropout:
-            A = self.dropout(A)
-
-        queried_values = torch.einsum('nlsh,nshd->nlhd', A, values)
-
-        return queried_values.contiguous()
diff --git a/mmsegmentation/projects/CAT-Seg/cat_seg/utils/tokenizer.py b/mmsegmentation/projects/CAT-Seg/cat_seg/utils/tokenizer.py
deleted file mode 100644
index c84711b..0000000
--- a/mmsegmentation/projects/CAT-Seg/cat_seg/utils/tokenizer.py
+++ /dev/null
@@ -1,160 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import gzip
-import html
-import os
-from functools import lru_cache
-
-import ftfy
-import regex as re
-
-
-@lru_cache()
-def default_bpe():
-    """Return default BPE vocabulary path."""
-    return os.path.join(
-        os.path.dirname(os.path.abspath(__file__)),
-        'bpe_vocab/bpe_simple_vocab_16e6.txt.gz')
-
-
-@lru_cache()
-def bytes_to_unicode():
-    """Returns list of utf-8 byte and a corresponding list of unicode strings.
-
-    The reversible bpe codes work on unicode strings. This means you need a
-    large # of unicode characters in your vocab if you want to avoid UNKs. When
-    you're at something like a 10B token dataset you end up needing around 5K
-    for decent coverage. This is a significant percentage of your normal, say,
-    32K bpe vocab. To avoid that, we want lookup tables between utf-8 bytes and
-    unicode strings. And avoids mapping to whitespace/control characters the
-    bpe code barfs on.
-    """
-    bs = list(range(ord('!'),
-                    ord('~') + 1)) + list(range(
-                        ord('¡'),
-                        ord('¬') + 1)) + list(range(ord('®'),
-                                                    ord('ÿ') + 1))
-    cs = bs[:]
-    n = 0
-    for b in range(2**8):
-        if b not in bs:
-            bs.append(b)
-            cs.append(2**8 + n)
-            n += 1
-    cs = [chr(n) for n in cs]
-    return dict(zip(bs, cs))
-
-
-def get_pairs(word):
-    """Return set of symbol pairs in a word.
-
-    Word is represented as tuple of symbols (symbols being variable-length
-    strings).
-    """
-    pairs = set()
-    prev_char = word[0]
-    for char in word[1:]:
-        pairs.add((prev_char, char))
-        prev_char = char
-    return pairs
-
-
-def basic_clean(text):
-    """Clean string."""
-    text = ftfy.fix_text(text)
-    text = html.unescape(html.unescape(text))
-    return text.strip()
-
-
-def whitespace_clean(text):
-    """Clean whitespace in string."""
-    text = re.sub(r'\s+', ' ', text)
-    text = text.strip()
-    return text
-
-
-class SimpleTokenizer:
-    """Customized Tokenizer implementation."""
-
-    def __init__(self, bpe_path: str = default_bpe()):
-        self.byte_encoder = bytes_to_unicode()
-        self.byte_decoder = {v: k for k, v in self.byte_encoder.items()}
-        merges = gzip.open(bpe_path).read().decode('utf-8').split('\n')
-        merges = merges[1:49152 - 256 - 2 + 1]
-        merges = [tuple(merge.split()) for merge in merges]
-        vocab = list(bytes_to_unicode().values())
-        vocab = vocab + [v + '</w>' for v in vocab]
-        for merge in merges:
-            vocab.append(''.join(merge))
-        vocab.extend(['<|startoftext|>', '<|endoftext|>'])
-        self.encoder = dict(zip(vocab, range(len(vocab))))
-        self.decoder = {v: k for k, v in self.encoder.items()}
-        self.bpe_ranks = dict(zip(merges, range(len(merges))))
-        self.cache = {
-            '<|startoftext|>': '<|startoftext|>',
-            '<|endoftext|>': '<|endoftext|>'
-        }
-        self.pat = re.compile(
-            r"""<\|startoftext\|>|<\|endoftext\|>|'s|'t|'re|'ve|'m|\
-                'll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""", re.IGNORECASE)
-
-    def bpe(self, token):
-        """Refer to bpe vocabulary dictionary."""
-        if token in self.cache:
-            return self.cache[token]
-        word = tuple(token[:-1]) + (token[-1] + '</w>', )
-        pairs = get_pairs(word)
-
-        if not pairs:
-            return token + '</w>'
-
-        while True:
-            bigram = min(
-                pairs, key=lambda pair: self.bpe_ranks.get(pair, float('inf')))
-            if bigram not in self.bpe_ranks:
-                break
-            first, second = bigram
-            new_word = []
-            i = 0
-            while i < len(word):
-                try:
-                    j = word.index(first, i)
-                    new_word.extend(word[i:j])
-                    i = j
-                except ValueError:
-                    new_word.extend(word[i:])
-                    break
-
-                if word[i] == first and i < len(word) - 1 and word[
-                        i + 1] == second:
-                    new_word.append(first + second)
-                    i += 2
-                else:
-                    new_word.append(word[i])
-                    i += 1
-            new_word = tuple(new_word)
-            word = new_word
-            if len(word) == 1:
-                break
-            else:
-                pairs = get_pairs(word)
-        word = ' '.join(word)
-        self.cache[token] = word
-        return word
-
-    def encode(self, text):
-        """Encode text strings."""
-        bpe_tokens = []
-        text = whitespace_clean(basic_clean(text)).lower()
-        for token in re.findall(self.pat, text):
-            token = ''.join(self.byte_encoder[b]
-                            for b in token.encode('utf-8'))
-            bpe_tokens.extend(self.encoder[bpe_token]
-                              for bpe_token in self.bpe(token).split(' '))
-        return bpe_tokens
-
-    def decode(self, tokens):
-        """Decoder tokens to strings."""
-        text = ''.join([self.decoder[token] for token in tokens])
-        text = bytearray([self.byte_decoder[c] for c in text]).decode(
-            'utf-8', errors='replace').replace('</w>', ' ')
-        return text
diff --git a/mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/ade20k_384x384.py b/mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/ade20k_384x384.py
deleted file mode 100644
index 488ba3d..0000000
--- a/mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/ade20k_384x384.py
+++ /dev/null
@@ -1,68 +0,0 @@
-# dataset settings
-dataset_type = 'ADE20KDataset'
-data_root = 'data/ade/ADEChallengeData2016'
-crop_size = (384, 384)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(
-        type='RandomResize',
-        scale=(2048, 512),
-        ratio_range=(0.5, 2.0),
-        keep_ratio=True),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='PackSegInputs')
-]
-img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
-tta_pipeline = [
-    dict(type='LoadImageFromFile', backend_args=None),
-    dict(
-        type='TestTimeAug',
-        transforms=[
-            [
-                dict(type='Resize', scale_factor=r, keep_ratio=True)
-                for r in img_ratios
-            ],
-            [
-                dict(type='RandomFlip', prob=0., direction='horizontal'),
-                dict(type='RandomFlip', prob=1., direction='horizontal')
-            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
-        ])
-]
-train_dataloader = dict(
-    batch_size=4,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='images/training', seg_map_path='annotations/training'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='images/validation',
-            seg_map_path='annotations/validation'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
-test_evaluator = val_evaluator
diff --git a/mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/coco-stuff164k_384x384.py b/mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/coco-stuff164k_384x384.py
deleted file mode 100644
index dd05176..0000000
--- a/mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/coco-stuff164k_384x384.py
+++ /dev/null
@@ -1,62 +0,0 @@
-# dataset settings
-dataset_type = 'COCOStuffDataset'
-data_root = 'data/coco_stuff164k'
-crop_size = (384, 384)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
-tta_pipeline = [
-    dict(type='LoadImageFromFile', backend_args=None),
-    dict(
-        type='TestTimeAug',
-        transforms=[
-            [
-                dict(type='Resize', scale_factor=r, keep_ratio=True)
-                for r in img_ratios
-            ],
-            [
-                dict(type='RandomFlip', prob=0., direction='horizontal'),
-                dict(type='RandomFlip', prob=1., direction='horizontal')
-            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
-        ])
-]
-train_dataloader = dict(
-    batch_size=2,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='images/train2017', seg_map_path='annotations/train2017'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='images/val2017', seg_map_path='annotations/val2017'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
-test_evaluator = val_evaluator
diff --git a/mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/pascal_context_59_384x384.py b/mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/pascal_context_59_384x384.py
deleted file mode 100644
index 250c599..0000000
--- a/mmsegmentation/projects/CAT-Seg/configs/_base_/datasets/pascal_context_59_384x384.py
+++ /dev/null
@@ -1,72 +0,0 @@
-# dataset settings
-dataset_type = 'PascalContextDataset59'
-data_root = 'data/VOCdevkit/VOC2010/'
-
-img_scale = (520, 520)
-crop_size = (384, 384)
-
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(
-        type='RandomResize',
-        scale=img_scale,
-        ratio_range=(0.5, 2.0),
-        keep_ratio=True),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='PackSegInputs')
-]
-img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
-tta_pipeline = [
-    dict(type='LoadImageFromFile', backend_args=None),
-    dict(
-        type='TestTimeAug',
-        transforms=[
-            [
-                dict(type='Resize', scale_factor=r, keep_ratio=True)
-                for r in img_ratios
-            ],
-            [
-                dict(type='RandomFlip', prob=0., direction='horizontal'),
-                dict(type='RandomFlip', prob=1., direction='horizontal')
-            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
-        ])
-]
-train_dataloader = dict(
-    batch_size=4,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='JPEGImages', seg_map_path='SegmentationClassContext'),
-        ann_file='ImageSets/SegmentationContext/train.txt',
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='JPEGImages', seg_map_path='SegmentationClassContext'),
-        ann_file='ImageSets/SegmentationContext/val.txt',
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
-test_evaluator = val_evaluator
diff --git a/mmsegmentation/projects/CAT-Seg/configs/_base_/default_runtime.py b/mmsegmentation/projects/CAT-Seg/configs/_base_/default_runtime.py
deleted file mode 100644
index 272b4d2..0000000
--- a/mmsegmentation/projects/CAT-Seg/configs/_base_/default_runtime.py
+++ /dev/null
@@ -1,15 +0,0 @@
-default_scope = 'mmseg'
-env_cfg = dict(
-    cudnn_benchmark=True,
-    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
-    dist_cfg=dict(backend='nccl'),
-)
-vis_backends = [dict(type='LocalVisBackend')]
-visualizer = dict(
-    type='SegLocalVisualizer', vis_backends=vis_backends, name='visualizer')
-log_processor = dict(by_epoch=False)
-log_level = 'INFO'
-load_from = None
-resume = False
-
-tta_model = dict(type='SegTTAModel')
diff --git a/mmsegmentation/projects/CAT-Seg/configs/_base_/schedules/schedule_80k.py b/mmsegmentation/projects/CAT-Seg/configs/_base_/schedules/schedule_80k.py
deleted file mode 100644
index 0dcd6c4..0000000
--- a/mmsegmentation/projects/CAT-Seg/configs/_base_/schedules/schedule_80k.py
+++ /dev/null
@@ -1,24 +0,0 @@
-# optimizer
-optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
-# learning policy
-param_scheduler = [
-    dict(
-        type='PolyLR',
-        eta_min=1e-4,
-        power=0.9,
-        begin=0,
-        end=80000,
-        by_epoch=False)
-]
-# training schedule for 80k
-train_cfg = dict(type='IterBasedTrainLoop', max_iters=80000, val_interval=8000)
-val_cfg = dict(type='ValLoop')
-test_cfg = dict(type='TestLoop')
-default_hooks = dict(
-    timer=dict(type='IterTimerHook'),
-    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
-    param_scheduler=dict(type='ParamSchedulerHook'),
-    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=8000),
-    sampler_seed=dict(type='DistSamplerSeedHook'),
-    visualization=dict(type='SegVisualizationHook'))
diff --git a/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb1-warmcoslr2e-4-adamw-80k_ade20k-384x384.py b/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb1-warmcoslr2e-4-adamw-80k_ade20k-384x384.py
deleted file mode 100644
index bab43a6..0000000
--- a/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb1-warmcoslr2e-4-adamw-80k_ade20k-384x384.py
+++ /dev/null
@@ -1,103 +0,0 @@
-_base_ = [
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py',
-    '../_base_/datasets/ade20k_384x384.py'
-]
-
-custom_imports = dict(imports=['cat_seg'])
-
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-crop_size = (384, 384)
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    size=crop_size,
-    # due to the clip model, we do normalization in backbone forward()
-    bgr_to_rgb=True,
-    pad_val=0,
-    seg_pad_val=255)
-# model_cfg
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        type='CLIPOVCATSeg',
-        feature_extractor=dict(
-            type='ResNet',
-            depth=101,
-            # only use the first three layers
-            num_stages=3,
-            out_indices=(0, 1, 2),
-            dilations=(1, 1, 1),
-            strides=(1, 2, 2),
-            norm_cfg=norm_cfg,
-            norm_eval=False,
-            style='pytorch',
-            contract_dilation=True,
-            init_cfg=dict(
-                type='Pretrained', checkpoint='torchvision://resnet101'),
-        ),
-        train_class_json='data/ade150.json',
-        test_class_json='data/ade150.json',
-        clip_pretrained='ViT-B/16',
-        clip_finetune='attention',
-    ),
-    neck=dict(
-        type='CATSegAggregator',
-        appearance_guidance_dim=1024,
-        num_layers=2,
-        pooling_size=(1, 1),
-    ),
-    decode_head=dict(
-        type='CATSegHead',
-        in_channels=128,
-        channels=128,
-        num_classes=150,
-        embed_dims=128,
-        decoder_dims=(64, 32),
-        decoder_guidance_dims=(512, 256),
-        decoder_guidance_proj_dims=(32, 16),
-        loss_decode=dict(
-            type='CrossEntropyLoss',
-            use_sigmoid=False,
-            loss_weight=1.0,
-            avg_non_ignore=True)),
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='slide', stride=crop_size, crop_size=crop_size))
-
-# dataset settings
-train_dataloader = dict(
-    batch_size=2,
-    num_workers=4,
-)
-
-# training schedule for 80k
-train_cfg = dict(type='IterBasedTrainLoop', max_iters=80000, val_interval=4000)
-
-default_hooks = dict(
-    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=4000),
-    visualization=dict(type='SegVisualizationHook', draw=True, interval=4000))
-
-# optimizer
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.0002, betas=(0.9, 0.999), weight_decay=0.0001),
-    paramwise_cfg=dict(
-        custom_keys={
-            'backbone.feature_extractor': dict(lr_mult=0.01),
-            'backbone.clip_model.visual': dict(lr_mult=0.01)
-        }))
-
-# learning policy
-param_scheduler = [
-    # Use a linear warm-up at [0, 100) iterations
-    dict(type='LinearLR', start_factor=0.01, by_epoch=False, begin=0, end=500),
-    # Use a cosine learning rate at [100, 900) iterations
-    dict(
-        type='CosineAnnealingLR',
-        T_max=79500,
-        by_epoch=False,
-        begin=500,
-        end=80000),
-]
diff --git a/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb1-warmcoslr2e-4-adamw-80k_pascal-context-59-384x384.py b/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb1-warmcoslr2e-4-adamw-80k_pascal-context-59-384x384.py
deleted file mode 100644
index 8b412cb..0000000
--- a/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb1-warmcoslr2e-4-adamw-80k_pascal-context-59-384x384.py
+++ /dev/null
@@ -1,103 +0,0 @@
-_base_ = [
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py',
-    '../_base_/datasets/pascal_context_59_384x384.py'
-]
-
-custom_imports = dict(imports=['cat_seg'])
-
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-crop_size = (384, 384)
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    size=crop_size,
-    # due to the clip model, we do normalization in backbone forward()
-    bgr_to_rgb=True,
-    pad_val=0,
-    seg_pad_val=255)
-# model_cfg
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        type='CLIPOVCATSeg',
-        feature_extractor=dict(
-            type='ResNet',
-            depth=101,
-            # only use the first three layers
-            num_stages=3,
-            out_indices=(0, 1, 2),
-            dilations=(1, 1, 1),
-            strides=(1, 2, 2),
-            norm_cfg=norm_cfg,
-            norm_eval=False,
-            style='pytorch',
-            contract_dilation=True,
-            init_cfg=dict(
-                type='Pretrained', checkpoint='torchvision://resnet101'),
-        ),
-        train_class_json='data/pc59.json',
-        test_class_json='data/pc59.json',
-        clip_pretrained='ViT-B/16',
-        clip_finetune='attention',
-    ),
-    neck=dict(
-        type='CATSegAggregator',
-        appearance_guidance_dim=1024,
-        num_layers=2,
-        pooling_size=(1, 1),
-    ),
-    decode_head=dict(
-        type='CATSegHead',
-        in_channels=128,
-        channels=128,
-        num_classes=59,
-        embed_dims=128,
-        decoder_dims=(64, 32),
-        decoder_guidance_dims=(512, 256),
-        decoder_guidance_proj_dims=(32, 16),
-        loss_decode=dict(
-            type='CrossEntropyLoss',
-            use_sigmoid=False,
-            loss_weight=1.0,
-            avg_non_ignore=True)),
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='slide', stride=crop_size, crop_size=crop_size))
-
-# dataset settings
-train_dataloader = dict(
-    batch_size=2,
-    num_workers=4,
-)
-
-# training schedule for 80k
-train_cfg = dict(type='IterBasedTrainLoop', max_iters=80000, val_interval=4000)
-
-default_hooks = dict(
-    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=4000),
-    visualization=dict(type='SegVisualizationHook', draw=True, interval=4000))
-
-# optimizer
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.0002, betas=(0.9, 0.999), weight_decay=0.0001),
-    paramwise_cfg=dict(
-        custom_keys={
-            'backbone.feature_extractor': dict(lr_mult=0.01),
-            'backbone.clip_model.visual': dict(lr_mult=0.01)
-        }))
-
-# learning policy
-param_scheduler = [
-    # Use a linear warm-up at [0, 100) iterations
-    dict(type='LinearLR', start_factor=0.01, by_epoch=False, begin=0, end=500),
-    # Use a cosine learning rate at [100, 900) iterations
-    dict(
-        type='CosineAnnealingLR',
-        T_max=79500,
-        by_epoch=False,
-        begin=500,
-        end=80000),
-]
diff --git a/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb2-warmcoslr2e-4-adamw-80k_coco-stuff164k-384x384.py b/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb2-warmcoslr2e-4-adamw-80k_coco-stuff164k-384x384.py
deleted file mode 100644
index 52bf712..0000000
--- a/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitb-r101_4xb2-warmcoslr2e-4-adamw-80k_coco-stuff164k-384x384.py
+++ /dev/null
@@ -1,102 +0,0 @@
-_base_ = [
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py',
-    '../_base_/datasets/coco-stuff164k_384x384.py'
-]
-
-custom_imports = dict(imports=['cat_seg'])
-
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-crop_size = (384, 384)
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    size=crop_size,
-    # due to the clip model, we do normalization in backbone forward()
-    bgr_to_rgb=True,
-    pad_val=0,
-    seg_pad_val=255)
-# model_cfg
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        type='CLIPOVCATSeg',
-        feature_extractor=dict(
-            type='ResNet',
-            depth=101,
-            # only use the first three layers
-            num_stages=3,
-            out_indices=(0, 1, 2),
-            dilations=(1, 1, 1),
-            strides=(1, 2, 2),
-            norm_cfg=norm_cfg,
-            norm_eval=False,
-            style='pytorch',
-            contract_dilation=True,
-            init_cfg=dict(
-                type='Pretrained', checkpoint='torchvision://resnet101'),
-        ),
-        train_class_json='data/coco.json',
-        test_class_json='data/coco.json',
-        clip_pretrained='ViT-B/16',
-        clip_finetune='attention',
-    ),
-    neck=dict(
-        type='CATSegAggregator',
-        appearance_guidance_dim=1024,
-        num_layers=2,
-    ),
-    decode_head=dict(
-        type='CATSegHead',
-        in_channels=128,
-        channels=128,
-        num_classes=171,
-        embed_dims=128,
-        decoder_dims=(64, 32),
-        decoder_guidance_dims=(512, 256),
-        decoder_guidance_proj_dims=(32, 16),
-        loss_decode=dict(
-            type='CrossEntropyLoss',
-            use_sigmoid=False,
-            loss_weight=1.0,
-            avg_non_ignore=True)),
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='slide', stride=crop_size, crop_size=crop_size))
-
-# dataset settings
-train_dataloader = dict(
-    batch_size=2,
-    num_workers=4,
-)
-
-# training schedule for 80k
-train_cfg = dict(type='IterBasedTrainLoop', max_iters=80000, val_interval=4000)
-
-default_hooks = dict(
-    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=4000),
-    visualization=dict(type='SegVisualizationHook', draw=True, interval=4000))
-
-# optimizer
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.0002, betas=(0.9, 0.999), weight_decay=0.0001),
-    paramwise_cfg=dict(
-        custom_keys={
-            'backbone.feature_extractor': dict(lr_mult=0.01),
-            'backbone.clip_model.visual': dict(lr_mult=0.01)
-        }))
-
-# learning policy
-param_scheduler = [
-    # Use a linear warm-up at [0, 100) iterations
-    dict(type='LinearLR', start_factor=0.01, by_epoch=False, begin=0, end=500),
-    # Use a cosine learning rate at [100, 900) iterations
-    dict(
-        type='CosineAnnealingLR',
-        T_max=79500,
-        by_epoch=False,
-        begin=500,
-        end=80000),
-]
diff --git a/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitg-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py b/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitg-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py
deleted file mode 100644
index 345945d..0000000
--- a/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitg-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = './catseg_vitl-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py'  # noqa
-
-model = dict(
-    backbone=dict(
-        type='CLIPOVCATSeg',
-        clip_pretrained='ViT-G',
-        custom_clip_weights='~/CLIP-ViT-bigG-14-laion2B-39B-b160k'),
-    neck=dict(
-        text_guidance_dim=1280,
-        appearance_guidance_dim=512,
-    ))
diff --git a/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vith-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py b/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vith-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py
deleted file mode 100644
index 2f09b8c..0000000
--- a/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vith-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = './catseg_vitl-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py'  # noqa
-
-model = dict(
-    backbone=dict(
-        type='CLIPOVCATSeg',
-        clip_pretrained='ViT-H',
-        custom_clip_weights='~/CLIP-ViT-H-14-laion2B-s32B-b79K'),
-    neck=dict(
-        text_guidance_dim=1024,
-        appearance_guidance_dim=512,
-    ))
diff --git a/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitl-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py b/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitl-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py
deleted file mode 100644
index bb4d57a..0000000
--- a/mmsegmentation/projects/CAT-Seg/configs/cat_seg/catseg_vitl-swin-b_4xb1-warmcoslr2e-4_adamw-80k_coco-stuff164k_384x384.py
+++ /dev/null
@@ -1,72 +0,0 @@
-_base_ = './catseg_vitb-r101_4xb2-warmcoslr2e-4-adamw-80k_coco-stuff164k-384x384.py'  # noqa
-
-pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_base_patch4_window12_384_20220317-55b0104a.pth'  # noqa
-crop_size = (384, 384)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    backbone=dict(
-        type='CLIPOVCATSeg',
-        feature_extractor=dict(
-            _delete_=True,
-            type='SwinTransformer',
-            pretrain_img_size=384,
-            embed_dims=128,
-            depths=[2, 2, 18],
-            num_heads=[4, 8, 16],
-            window_size=12,
-            mlp_ratio=4,
-            qkv_bias=True,
-            qk_scale=None,
-            drop_rate=0.,
-            attn_drop_rate=0.,
-            drop_path_rate=0.3,
-            patch_norm=True,
-            out_indices=(0, 1, 2),
-            init_cfg=dict(type='Pretrained', checkpoint=pretrained)),
-        clip_pretrained='ViT-L/14@336px',
-    ),
-    neck=dict(
-        text_guidance_dim=768,
-        appearance_guidance_dim=512,
-    ),
-    decode_head=dict(
-        embed_dims=128,
-        decoder_guidance_dims=(256, 128),
-    ))
-
-# dataset settings
-train_dataloader = dict(
-    batch_size=1,
-    num_workers=2,
-)
-
-# training schedule for 80k
-train_cfg = dict(type='IterBasedTrainLoop', max_iters=80000, val_interval=4000)
-
-default_hooks = dict(
-    visualization=dict(type='SegVisualizationHook', draw=True, interval=4000))
-
-# optimizer
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.0002, betas=(0.9, 0.999), weight_decay=0.0001),
-    paramwise_cfg=dict(
-        custom_keys={
-            'backbone.feature_extractor': dict(lr_mult=0.01),
-            'backbone.clip_model.visual': dict(lr_mult=0.01)
-        }))
-
-# learning policy
-param_scheduler = [
-    # Use a linear warm-up at [0, 100) iterations
-    dict(type='LinearLR', start_factor=0.01, by_epoch=False, begin=0, end=500),
-    # Use a cosine learning rate at [100, 900) iterations
-    dict(
-        type='CosineAnnealingLR',
-        T_max=79500,
-        by_epoch=False,
-        begin=500,
-        end=80000),
-]
diff --git a/mmsegmentation/projects/CAT-Seg/utils/__init__.py b/mmsegmentation/projects/CAT-Seg/utils/__init__.py
deleted file mode 100644
index 02d85f2..0000000
--- a/mmsegmentation/projects/CAT-Seg/utils/__init__.py
+++ /dev/null
@@ -1,7 +0,0 @@
-from .clip_templates import (IMAGENET_TEMPLATES, IMAGENET_TEMPLATES_SELECT,
-                             IMAGENET_TEMPLATES_SELECT_CLIP, ViLD_templates)
-
-__all__ = [
-    'IMAGENET_TEMPLATES', 'IMAGENET_TEMPLATES_SELECT',
-    'IMAGENET_TEMPLATES_SELECT_CLIP', 'ViLD_templates'
-]
diff --git a/mmsegmentation/projects/README.md b/mmsegmentation/projects/README.md
deleted file mode 100644
index 5482c47..0000000
--- a/mmsegmentation/projects/README.md
+++ /dev/null
@@ -1,19 +0,0 @@
-# Projects
-
-The OpenMMLab ecosystem can only grow through the contributions of the community.
-Everyone is welcome to post their implementation of any great ideas in this folder! If you wish to start your own project, please go through the [example project](example_project/) for the best practice. For common questions about projects, please read our [faq](faq.md).
-
-## External Projects
-
-There are also selected external projects released in the community that use MMSegmentation:
-
-- [SegNeXt: Rethinking Convolutional Attention Design for Semantic Segmentation](https://github.com/visual-attention-network/segnext)
-- [Vision Transformer Adapter for Dense Predictions](https://github.com/czczup/ViT-Adapter)
-- [UniFormer: Unifying Convolution and Self-attention for Visual Recognition](https://github.com/Sense-X/UniFormer)
-- [Multi-Scale High-Resolution Vision Transformer for Semantic Segmentation](https://github.com/facebookresearch/HRViT)
-- [ViTAE: Vision Transformer Advanced by Exploring Intrinsic Inductive Bias](https://github.com/ViTAE-Transformer/ViTAE-Transformer)
-- [DAFormer: Improving Network Architectures and Training Strategies for Domain-Adaptive Semantic Segmentation](https://github.com/lhoyer/DAFormer)
-- [MPViT : Multi-Path Vision Transformer for Dense Prediction](https://github.com/youngwanLEE/MPViT)
-- [TopFormer: Token Pyramid Transformer for Mobile Semantic Segmentation](https://github.com/hustvl/TopFormer)
-
-Note: These projects are supported and maintained by their own contributors. The core maintainers of MMSegmentation only ensure the results are reproducible and the code quality meets its claim at the time each project was submitted, but they may not be responsible for future maintenance.
diff --git a/mmsegmentation/projects/XDecoder/README.md b/mmsegmentation/projects/XDecoder/README.md
deleted file mode 100644
index 3d55575..0000000
--- a/mmsegmentation/projects/XDecoder/README.md
+++ /dev/null
@@ -1,17 +0,0 @@
-# X-Decoder
-
-> [X-Decoder: Generalized Decoding for Pixel, Image, and Language](https://arxiv.org/pdf/2212.11270.pdf)
-
-<!-- [ALGORITHM] -->
-
-## Abstract
-
-We present X-Decoder, a generalized decoding model that can predict pixel-level segmentation and language tokens seamlessly. X-Decodert takes as input two types of queries: (i) generic non-semantic queries and (ii) semantic queries induced from text inputs, to decode different pixel-level and token-level outputs in the same semantic space. With such a novel design, X-Decoder is the first work that provides a unified way to support all types of image segmentation and a variety of vision-language (VL) tasks. Further, our design enables seamless interactions across tasks at different granularities and brings mutual benefits by learning a common and rich pixel-level visual-semantic understanding space, without any pseudo-labeling. After pretraining on a mixed set of a limited amount of segmentation data and millions of image-text pairs, X-Decoder exhibits strong transferability to a wide range of downstream tasks in both zero-shot and finetuning settings. Notably, it achieves (1) state-of-the-art results on open-vocabulary segmentation and referring segmentation on eight datasets; (2) better or competitive finetuned performance to other generalist and specialist models on segmentation and VL tasks; and (3) flexibility for efficient finetuning and novel task composition (e.g., referring captioning and image editing).
-
-<div align=center>
-<img src="https://github.com/open-mmlab/mmdetection/assets/17425982/cb126615-9402-4c19-8ea9-133722d7519c" width="70%"/>
-</div>
-
-## Usage
-
-We implement it based on [mmdetection](https://github.com/open-mmlab/mmdetection/), please refer to [mmdetection/projects/XDecoder](https://github.com/open-mmlab/mmdetection/tree/main/projects/XDecoder) for more details.
diff --git a/mmsegmentation/projects/bdd100k_dataset/README.md b/mmsegmentation/projects/bdd100k_dataset/README.md
deleted file mode 100644
index c774525..0000000
--- a/mmsegmentation/projects/bdd100k_dataset/README.md
+++ /dev/null
@@ -1,50 +0,0 @@
-# BDD100K Dataset
-
-Support **`BDD100K Dataset`**
-
-## Description
-
-Author: CastleDream
-
-This project implements **`BDD100K Dataset`**
-
-### Dataset preparing
-
-Preparing `BDD100K Dataset` dataset following [BDD100K Dataset Preparing Guide](https://github.com/open-mmlab/mmsegmentation/tree/main/projects/mapillary_dataset/docs/en/user_guides/2_dataset_prepare.md#bdd100k)
-
-```none
-mmsegmentation/data
-└── bdd100k
-    ├── images
-    │   └── 10k
-    │       ├── test [2000 entries exceeds filelimit, not opening dir]
-    │       ├── train [7000 entries exceeds filelimit, not opening dir]
-    │       └── val [1000 entries exceeds filelimit, not opening dir]
-    └── labels
-        └── sem_seg
-            ├── colormaps
-            │   ├── train [7000 entries exceeds filelimit, not opening dir]
-            │   └── val [1000 entries exceeds filelimit, not opening dir]
-            ├── masks
-            │   ├── train [7000 entries exceeds filelimit, not opening dir]
-            │   └── val [1000 entries exceeds filelimit, not opening dir]
-            ├── polygons
-            │   ├── sem_seg_train.json
-            │   └── sem_seg_val.json
-            └── rles
-                ├── sem_seg_train.json
-                └── sem_seg_val.json
-```
-
-### Training commands
-
-```bash
-%cd mmsegmentation
-!python tools/train.py projects/bdd100k_dataset/configs/pspnet_r50-d8_4xb2-80k_bdd100k-512x1024.py\
---work-dir your_work_dir
-```
-
-## Thanks
-
-- [\[Datasets\] Add Mapillary Vistas Datasets to MMSeg Core Package. #2576](https://github.com/open-mmlab/mmsegmentation/pull/2576/files)
-- [\[Feature\] Support CIHP dataset #1493](https://github.com/open-mmlab/mmsegmentation/pull/1493/files)
diff --git a/mmsegmentation/projects/bdd100k_dataset/configs/_base_/datasets/bdd100k.py b/mmsegmentation/projects/bdd100k_dataset/configs/_base_/datasets/bdd100k.py
deleted file mode 100644
index 24cec69..0000000
--- a/mmsegmentation/projects/bdd100k_dataset/configs/_base_/datasets/bdd100k.py
+++ /dev/null
@@ -1,70 +0,0 @@
-# dataset settings
-dataset_type = 'BDD100KDataset'
-data_root = 'data/bdd100k/'
-
-crop_size = (512, 1024)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(
-        type='RandomResize',
-        scale=(2048, 1024),
-        ratio_range=(0.5, 2.0),
-        keep_ratio=True),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
-tta_pipeline = [
-    dict(type='LoadImageFromFile', backend_args=None),
-    dict(
-        type='TestTimeAug',
-        transforms=[
-            [
-                dict(type='Resize', scale_factor=r, keep_ratio=True)
-                for r in img_ratios
-            ],
-            [
-                dict(type='RandomFlip', prob=0., direction='horizontal'),
-                dict(type='RandomFlip', prob=1., direction='horizontal')
-            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
-        ])
-]
-train_dataloader = dict(
-    batch_size=2,
-    num_workers=2,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='images/10k/train',
-            seg_map_path='labels/sem_seg/masks/train'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='images/10k/val',
-            seg_map_path='labels/sem_seg/masks/val'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
-test_evaluator = val_evaluator
diff --git a/mmsegmentation/projects/bdd100k_dataset/configs/pspnet_r50-d8_4xb2-80k_bdd100k-512x1024.py b/mmsegmentation/projects/bdd100k_dataset/configs/pspnet_r50-d8_4xb2-80k_bdd100k-512x1024.py
deleted file mode 100644
index 456d4c7..0000000
--- a/mmsegmentation/projects/bdd100k_dataset/configs/pspnet_r50-d8_4xb2-80k_bdd100k-512x1024.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = [
-    '../../../configs/_base_/models/pspnet_r50-d8.py',
-    './_base_/datasets/bdd100k.py',
-    '../../../configs/_base_/default_runtime.py',
-    '../../../configs/_base_/schedules/schedule_80k.py'
-]
-custom_imports = dict(
-    imports=['projects.bdd100k_dataset.mmseg.datasets.bdd100k'])
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(data_preprocessor=data_preprocessor)
diff --git a/mmsegmentation/projects/bdd100k_dataset/docs/en/user_guides/2_dataset_prepare.md b/mmsegmentation/projects/bdd100k_dataset/docs/en/user_guides/2_dataset_prepare.md
deleted file mode 100644
index f2383cf..0000000
--- a/mmsegmentation/projects/bdd100k_dataset/docs/en/user_guides/2_dataset_prepare.md
+++ /dev/null
@@ -1,40 +0,0 @@
-## BDD100K
-
-- You could download BDD100k datasets from  [here](https://bdd-data.berkeley.edu/) after  registration.
-
-- You can download images and masks by clicking  `10K Images` button and `Segmentation` button.
-
-- After download, unzip by the following instructions:
-
-  ```bash
-  unzip ~/bdd100k_images_10k.zip -d ~/mmsegmentation/data/
-  unzip ~/bdd100k_sem_seg_labels_trainval.zip -d ~/mmsegmentation/data/
-  ```
-
-```none
-mmsegmentation
-├── mmseg
-├── tools
-├── configs
-├── data
-│   ├── bdd100k
-│   │   ├── images
-│   │   │   └── 10k
-|   │   │   │   ├── test
-|   │   │   │   ├── train
-|   │   │   │   └── val
-│   │   └── labels
-│   │   │   └── sem_seg
-|   │   │   │   ├── colormaps
-|   │   │   │   │   ├──train
-|   │   │   │   │   └──val
-|   │   │   │   ├── masks
-|   │   │   │   │   ├──train
-|   │   │   │   │   └──val
-|   │   │   │   ├── polygons
-|   │   │   │   │   ├──sem_seg_train.json
-|   │   │   │   │   └──sem_seg_val.json
-|   │   │   │   └── rles
-|   │   │   │   │   ├──sem_seg_train.json
-|   │   │   │   │   └──sem_seg_val.json
-```
diff --git a/mmsegmentation/projects/bdd100k_dataset/docs/zh_cn/user_guides/2_dataset_prepare.md b/mmsegmentation/projects/bdd100k_dataset/docs/zh_cn/user_guides/2_dataset_prepare.md
deleted file mode 100644
index 64fb763..0000000
--- a/mmsegmentation/projects/bdd100k_dataset/docs/zh_cn/user_guides/2_dataset_prepare.md
+++ /dev/null
@@ -1,42 +0,0 @@
-## BDD100K
-
-- 可以从[官方网站](https://bdd-data.berkeley.edu/) 下载 BDD100K数据集（语义分割任务主要是10K数据集），按照官网要求注册并登陆后，数据可以在[这里](https://bdd-data.berkeley.edu/portal.html#download)找到。
-
-- 图像数据对应的名称是是`10K Images`, 语义分割标注对应的名称是`Segmentation`
-
-- 下载后，可以使用以下代码进行解压
-
-  ```bash
-  unzip ~/bdd100k_images_10k.zip -d ~/mmsegmentation/data/
-  unzip ~/bdd100k_sem_seg_labels_trainval.zip -d ~/mmsegmentation/data/
-  ```
-
-就可以得到以下文件结构了：
-
-```none
-mmsegmentation
-├── mmseg
-├── tools
-├── configs
-├── data
-│   ├── bdd100k
-│   │   ├── images
-│   │   │   └── 10k
-|   │   │   │   ├── test
-|   │   │   │   ├── train
-|   │   │   │   └── val
-│   │   └── labels
-│   │   │   └── sem_seg
-|   │   │   │   ├── colormaps
-|   │   │   │   │   ├──train
-|   │   │   │   │   └──val
-|   │   │   │   ├── masks
-|   │   │   │   │   ├──train
-|   │   │   │   │   └──val
-|   │   │   │   ├── polygons
-|   │   │   │   │   ├──sem_seg_train.json
-|   │   │   │   │   └──sem_seg_val.json
-|   │   │   │   └── rles
-|   │   │   │   │   ├──sem_seg_train.json
-|   │   │   │   │   └──sem_seg_val.json
-```
diff --git a/mmsegmentation/projects/bdd100k_dataset/mmseg/datasets/bdd100k.py b/mmsegmentation/projects/bdd100k_dataset/mmseg/datasets/bdd100k.py
deleted file mode 100644
index e536de7..0000000
--- a/mmsegmentation/projects/bdd100k_dataset/mmseg/datasets/bdd100k.py
+++ /dev/null
@@ -1,31 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-
-from mmseg.datasets.basesegdataset import BaseSegDataset
-
-# from mmseg.registry import DATASETS
-# @DATASETS.register_module()
-
-
-class BDD100KDataset(BaseSegDataset):
-    METAINFO = dict(
-        classes=('road', 'sidewalk', 'building', 'wall', 'fence', 'pole',
-                 'traffic light', 'traffic sign', 'vegetation', 'terrain',
-                 'sky', 'person', 'rider', 'car', 'truck', 'bus', 'train',
-                 'motorcycle', 'bicycle'),
-        palette=[[128, 64, 128], [244, 35, 232], [70, 70, 70], [102, 102, 156],
-                 [190, 153, 153], [153, 153, 153], [250, 170,
-                                                    30], [220, 220, 0],
-                 [107, 142, 35], [152, 251, 152], [70, 130, 180],
-                 [220, 20, 60], [255, 0, 0], [0, 0, 142], [0, 0, 70],
-                 [0, 60, 100], [0, 80, 100], [0, 0, 230], [119, 11, 32]])
-
-    def __init__(self,
-                 img_suffix='.jpg',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/projects/example_project/README.md b/mmsegmentation/projects/example_project/README.md
deleted file mode 100644
index e4fd03c..0000000
--- a/mmsegmentation/projects/example_project/README.md
+++ /dev/null
@@ -1,134 +0,0 @@
-# Dummy ResNet Wrapper
-
-> A README.md template for releasing a project.
->
-> All the fields in this README are **mandatory** for others to understand what you have achieved in this implementation.
-> Please read our [Projects FAQ](../faq.md) if you still feel unclear about the requirements, or raise an [issue](https://github.com/open-mmlab/mmsegmentation/issues) to us!
-
-## Description
-
-> Share any information you would like others to know. For example:
->
-> Author: @xxx.
->
-> This is an implementation of \[XXX\].
-
-Author： @xxx.
-
-This project implements a dummy ResNet wrapper, which literally does nothing new but prints "hello world" during initialization.
-
-## Usage
-
-> For a typical model, this section should contain the commands for training and testing.
-> You are also suggested to dump your environment specification to env.yml by `conda env export > env.yml`.
-
-### Prerequisites
-
-- Python 3.7
-- PyTorch 1.6 or higher
-- [MIM](https://github.com/open-mmlab/mim) v0.33 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc2 or higher
-
-All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `example_project/` root directory, run the following line to add the current directory to `PYTHONPATH`:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Training commands
-
-```shell
-mim train mmsegmentation configs/fcn_dummy-r50-d8_4xb2-40k_cityscapes-512x1024.py --work-dir work_dirs/dummy_resnet
-```
-
-To train on multiple GPUs, e.g. 8 GPUs, run the following command:
-
-```shell
-mim train mmsegmentation configs/fcn_dummy-r50-d8_4xb2-40k_cityscapes-512x1024.py --work-dir work_dirs/dummy_resnet --launcher pytorch --gpus 8
-```
-
-### Testing commands
-
-```shell
-mim test mmsegmentation configs/fcn_dummy-r50-d8_4xb2-40k_cityscapes-512x1024.py --work-dir work_dirs/dummy_resnet --checkpoint ${CHECKPOINT_PATH}
-```
-
-> List the results as usually done in other model's README. \[Example\](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/fcn#results-and-models
-> You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) |  mIoU | mIoU(ms+flip) | config                                                             | download                                                                                                                                                                                                                                                                                                                           |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ----: | ------------: | ------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| FCN    | R-50-D8  | 512x1024  |   40000 | 5.7      | 4.17           | 72.25 |         73.36 | [config](configs/fcn_dummy-r50-d8_4xb2-40k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x1024_40k_cityscapes/fcn_r50-d8_512x1024_40k_cityscapes_20200604_192608-efe53f0d.pth) \| [log](https://download.openmmlab.com/mmsegmentation/v0.5/fcn/fcn_r50-d8_512x1024_40k_cityscapes/fcn_r50-d8_512x1024_40k_cityscapes_20200604_192608.log.json) |
-
-## Citation
-
-> You may remove this section if not applicable.
-
-```bibtex
-@misc{mmseg2020,
-    title={{MMSegmentation}: OpenMMLab Semantic Segmentation Toolbox and Benchmark},
-    author={MMSegmentation Contributors},
-    howpublished = {\url{https://github.com/open-mmlab/mmsegmentation}},
-    year={2020}
-}
-```
-
-## Checklist
-
-Here is a checklist illustrating a usual development workflow of a successful project, and also serves as an overview of this project's progress.
-
-> The PIC (person in charge) or contributors of this project should check all the items that they believe have been finished, which will further be verified by codebase maintainers via a PR.
-
-> OpenMMLab's maintainer will review the code to ensure the project's quality. Reaching the first milestone means that this project suffices the minimum requirement of being merged into 'projects/'. But this project is only eligible to become a part of the core package upon attaining the last milestone.
-
-> Note that keeping this section up-to-date is crucial not only for this project's developers but the entire community, since there might be some other contributors joining this project and deciding their starting point from this list. It also helps maintainers accurately estimate time and effort on further code polishing, if needed.
-
-> A project does not necessarily have to be finished in a single PR, but it's essential for the project to at least reach the first milestone in its very first PR.
-
-- [ ] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [ ] Finish the code
-
-> The code's design shall follow existing interfaces and convention. For example, each model component should be registered into `mmseg.registry.MODELS` and configurable via a config file.
-
-- [ ] Basic docstrings & proper citation
-
-> Each major object should contain a docstring, describing its functionality and arguments. If you have adapted the code from other open-source projects, don't forget to cite the source project in docstring and make sure your behavior is not against its license. Typically, we do not accept any code snippet under GPL license. [A Short Guide to Open Source Licenses](https://medium.com/nationwide-technology/a-short-guide-to-open-source-licenses-cf5b1c329edd)
-
-- [ ] Test-time correctness
-
-> If you are reproducing the result from a paper, make sure your model's inference-time performance matches that in the original paper. The weights usually could be obtained by simply renaming the keys in the official pre-trained weights. This test could be skipped though, if you are able to prove the training-time correctness and check the second milestone.
-
-- [ ] A full README
-
-> As this template does.
-
-- [ ] Milestone 2: Indicates a successful model implementation.
-
-  - [ ] Training-time correctness
-
-> If you are reproducing the result from a paper, checking this item means that you should have trained your model from scratch based on the original paper's specification and verified that the final result matches the report within a minor error range.
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-
-> Ideally *all* the methods should have [type hints](https://www.pythontutorial.net/python-basics/python-type-hints/) and [docstrings](https://google.github.io/styleguide/pyguide.html#381-docstrings). [Example](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/utils/io.py#L9)
-
-- [ ] Unit tests
-
-> Unit tests for each module are required. [Example](https://github.com/open-mmlab/mmsegmentation/blob/main/tests/test_utils/test_io.py#L14)
-
-- [ ] Code polishing
-
-> Refactor your code according to reviewer's comment.
-
-- [ ] Metafile.yml
-
-> It will be parsed by MIM and Inferencer. [Example](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn.yml)
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-> In particular, you may have to refactor this README into a standard one. [Example](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/README.md)
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/example_project/configs/fcn_dummy-r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/projects/example_project/configs/fcn_dummy-r50-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 4301536..0000000
--- a/mmsegmentation/projects/example_project/configs/fcn_dummy-r50-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = ['mmseg::fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py']
-
-custom_imports = dict(imports=['dummy'])
-
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor, backbone=dict(type='DummyResNet'))
diff --git a/mmsegmentation/projects/example_project/dummy/__init__.py b/mmsegmentation/projects/example_project/dummy/__init__.py
deleted file mode 100644
index 70df789..0000000
--- a/mmsegmentation/projects/example_project/dummy/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-from .dummy_resnet import DummyResNet
-
-__all__ = ['DummyResNet']
diff --git a/mmsegmentation/projects/example_project/dummy/dummy_resnet.py b/mmsegmentation/projects/example_project/dummy/dummy_resnet.py
deleted file mode 100644
index a510eaf..0000000
--- a/mmsegmentation/projects/example_project/dummy/dummy_resnet.py
+++ /dev/null
@@ -1,14 +0,0 @@
-from mmseg.models.backbones import ResNetV1c
-from mmseg.registry import MODELS
-
-
-@MODELS.register_module()
-class DummyResNet(ResNetV1c):
-    """Implements a dummy ResNet wrapper for demonstration purpose.
-    Args:
-        **kwargs: All the arguments are passed to the parent class.
-    """
-
-    def __init__(self, **kwargs) -> None:
-        print('Hello world!')
-        super().__init__(**kwargs)
diff --git a/mmsegmentation/projects/faq.md b/mmsegmentation/projects/faq.md
deleted file mode 100644
index 74b292b..0000000
--- a/mmsegmentation/projects/faq.md
+++ /dev/null
@@ -1,19 +0,0 @@
-Q1: Why set up `projects/` folder?
-
-Implementing new models and features into OpenMMLab's algorithm libraries could be troublesome due to the rigorous requirements on code quality, which could hinder the fast iteration of SOTA models and might discourage our members from sharing their latest outcomes here. And that's why we have this `projects/` folder now, where some experimental features, frameworks and models are placed, only needed to satisfy the minimum requirement on the code quality, and can be used as standalone libraries. Users are welcome to use them if they [use MMSegmentation from source](https://mmsegmentation.readthedocs.io/en/latest/get_started.html#best-practices).
-
-Q2: Why should there be a checklist for a project?
-
-This checkelist is crucial not only for this project's developers but the entire community, since there might be some other contributors joining this project and deciding their starting point from this list. It also helps maintainers accurately estimate time and effort on further code polishing, if needed.
-
-Q3: What kind of PR will be merged?
-
-Reaching the first milestone means that this project suffices the minimum requirement of being merged into 'projects/'. That is, the very first PR of a project must have all the terms in the first milestone checked. We do not have any extra requirements on the project's following PRs, so they can be a minor bug fix or update, and do not have to achieve one milestone at once. But keep in mind that this project is only eligible to become a part of the core package upon attaining the last milestone.
-
-Q4: Compared to other models in the core packages, why do the model implementations in projects have different training/testing commands?
-
-Projects are organized independently from the core package, and therefore their modules cannot be directly imported by train.py and test.py. Each model implementation in projects should either use `mim` for training/testing as suggested in the example project or provide a custom train.py/test.py.
-
-Q5: How to debug a project with a debugger?
-
-Debugger makes our lives easier, but using it becomes a bit tricky if we have to train/test a model via `mim`. The way to circumvent that is that we can take advantage of relative path to import these modules. Assuming that we are developing a project X and the core modules are placed under `projects/X/modules`, then simply adding `custom_imports = dict(imports='projects.X.modules')` to the config allows us to debug from usual entrypoints (e.g. `tools/train.py`) from the root directory of the algorithm library. Just don't forget to remove 'projects.X' before project publishment.
diff --git a/mmsegmentation/projects/gid_dataset/configs/_base_/datasets/gid.py b/mmsegmentation/projects/gid_dataset/configs/_base_/datasets/gid.py
deleted file mode 100644
index f721810..0000000
--- a/mmsegmentation/projects/gid_dataset/configs/_base_/datasets/gid.py
+++ /dev/null
@@ -1,67 +0,0 @@
-# dataset settings
-dataset_type = 'GID_Dataset'  # 注册的类名
-data_root = 'data/gid/'  # 数据集根目录
-crop_size = (256, 256)  # 图像裁剪大小
-train_pipeline = [
-    dict(type='LoadImageFromFile'),  # 从文件中加载图像
-    dict(type='LoadAnnotations'),  # 从文件中加载标注
-    dict(
-        type='RandomResize',  # 随机缩放
-        scale=(512, 512),  # 缩放尺寸
-        ratio_range=(0.5, 2.0),  # 缩放比例范围
-        keep_ratio=True),  # 是否保持长宽比
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),  # 随机裁剪
-    dict(type='RandomFlip', prob=0.5),  # 随机翻转
-    dict(type='PhotoMetricDistortion'),  # 图像增强
-    dict(type='PackSegInputs')  # 打包数据
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),  # 从文件中加载图像
-    dict(type='Resize', scale=(256, 256), keep_ratio=True),  # 缩放
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations'),  # 从文件中加载标注
-    dict(type='PackSegInputs')  # 打包数据
-]
-img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]  # 多尺度预测缩放比例
-tta_pipeline = [  # 多尺度测试
-    dict(type='LoadImageFromFile', file_client_args=dict(backend='disk')),
-    dict(
-        type='TestTimeAug',
-        transforms=[
-            [
-                dict(type='Resize', scale_factor=r, keep_ratio=True)
-                for r in img_ratios
-            ],
-            [
-                dict(type='RandomFlip', prob=0., direction='horizontal'),
-                dict(type='RandomFlip', prob=1., direction='horizontal')
-            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
-        ])
-]
-train_dataloader = dict(  # 训练数据加载器
-    batch_size=2,  # 训练时的数据批量大小
-    num_workers=4,  # 数据加载线程数
-    persistent_workers=True,  # 是否持久化线程
-    sampler=dict(type='InfiniteSampler', shuffle=True),  # 无限采样器
-    dataset=dict(
-        type=dataset_type,  # 数据集类名
-        data_root=data_root,  # 数据集根目录
-        data_prefix=dict(
-            img_path='img_dir/train',
-            seg_map_path='ann_dir/train'),  # 训练集图像和标注路径
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,  # 验证时的数据批量大小
-    num_workers=4,  # 数据加载线程数
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(img_path='img_dir/val', seg_map_path='ann_dir/val'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
-test_evaluator = val_evaluator
diff --git a/mmsegmentation/projects/gid_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_gid-256x256.py b/mmsegmentation/projects/gid_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_gid-256x256.py
deleted file mode 100644
index 70cb600..0000000
--- a/mmsegmentation/projects/gid_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_gid-256x256.py
+++ /dev/null
@@ -1,15 +0,0 @@
-_base_ = [
-    '../../../configs/_base_/models/deeplabv3plus_r50-d8.py',
-    './_base_/datasets/gid.py', '../../../configs/_base_/default_runtime.py',
-    '../../../configs/_base_/schedules/schedule_240k.py'
-]
-custom_imports = dict(imports=['projects.gid_dataset.mmseg.datasets.gid'])
-
-crop_size = (256, 256)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained='open-mmlab://resnet101_v1c',
-    backbone=dict(depth=101),
-    decode_head=dict(num_classes=6),
-    auxiliary_head=dict(num_classes=6))
diff --git a/mmsegmentation/projects/gid_dataset/mmseg/datasets/gid.py b/mmsegmentation/projects/gid_dataset/mmseg/datasets/gid.py
deleted file mode 100644
index a9e8c51..0000000
--- a/mmsegmentation/projects/gid_dataset/mmseg/datasets/gid.py
+++ /dev/null
@@ -1,55 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmseg.datasets.basesegdataset import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-# 注册数据集类
-@DATASETS.register_module()
-class GID_Dataset(BaseSegDataset):
-    """Gaofen Image Dataset (GID)
-
-    Dataset paper link:
-    https://www.sciencedirect.com/science/article/pii/S0034425719303414
-    https://x-ytong.github.io/project/GID.html
-
-    GID  6 classes: others, built-up, farmland, forest, meadow, water
-
-    In this example, select 15 images from GID dataset as training set,
-    and select 5 images as validation set.
-    The selected images are listed as follows:
-
-    GF2_PMS1__L1A0000647767-MSS1
-    GF2_PMS1__L1A0001064454-MSS1
-    GF2_PMS1__L1A0001348919-MSS1
-    GF2_PMS1__L1A0001680851-MSS1
-    GF2_PMS1__L1A0001680853-MSS1
-    GF2_PMS1__L1A0001680857-MSS1
-    GF2_PMS1__L1A0001757429-MSS1
-    GF2_PMS2__L1A0000607681-MSS2
-    GF2_PMS2__L1A0000635115-MSS2
-    GF2_PMS2__L1A0000658637-MSS2
-    GF2_PMS2__L1A0001206072-MSS2
-    GF2_PMS2__L1A0001471436-MSS2
-    GF2_PMS2__L1A0001642620-MSS2
-    GF2_PMS2__L1A0001787089-MSS2
-    GF2_PMS2__L1A0001838560-MSS2
-
-    The ``img_suffix`` is fixed to '.tif' and ``seg_map_suffix`` is
-    fixed to '.tif' for GID.
-    """
-    METAINFO = dict(
-        classes=('Others', 'Built-up', 'Farmland', 'Forest', 'Meadow',
-                 'Water'),
-        palette=[[0, 0, 0], [255, 0, 0], [0, 255, 0], [0, 255, 255],
-                 [255, 255, 0], [0, 0, 255]])
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=None,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/projects/gid_dataset/tools/dataset_converters/gid.py b/mmsegmentation/projects/gid_dataset/tools/dataset_converters/gid.py
deleted file mode 100644
index d95654a..0000000
--- a/mmsegmentation/projects/gid_dataset/tools/dataset_converters/gid.py
+++ /dev/null
@@ -1,181 +0,0 @@
-import argparse
-import glob
-import math
-import os
-import os.path as osp
-
-import mmcv
-import numpy as np
-from mmengine.utils import ProgressBar, mkdir_or_exist
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Convert GID dataset to mmsegmentation format')
-    parser.add_argument('dataset_img_path', help='GID images folder path')
-    parser.add_argument('dataset_label_path', help='GID labels folder path')
-    parser.add_argument('--tmp_dir', help='path of the temporary directory')
-    parser.add_argument(
-        '-o', '--out_dir', help='output path', default='data/gid')
-    parser.add_argument(
-        '--clip_size',
-        type=int,
-        help='clipped size of image after preparation',
-        default=256)
-    parser.add_argument(
-        '--stride_size',
-        type=int,
-        help='stride of clipping original images',
-        default=256)
-    args = parser.parse_args()
-    return args
-
-
-GID_COLORMAP = dict(
-    Background=(0, 0, 0),  # 0-背景-黑色
-    Building=(255, 0, 0),  # 1-建筑-红色
-    Farmland=(0, 255, 0),  # 2-农田-绿色
-    Forest=(0, 0, 255),  # 3-森林-蓝色
-    Meadow=(255, 255, 0),  # 4-草地-黄色
-    Water=(0, 0, 255)  # 5-水-蓝色
-)
-palette = list(GID_COLORMAP.values())
-classes = list(GID_COLORMAP.keys())
-
-
-# 用列表来存一个 RGB 和一个类别的对应
-def colormap2label(palette):
-    colormap2label_list = np.zeros(256**3, dtype=np.longlong)
-    for i, colormap in enumerate(palette):
-        colormap2label_list[(colormap[0] * 256 + colormap[1]) * 256 +
-                            colormap[2]] = i
-    return colormap2label_list
-
-
-# 给定那个列表，和vis_png然后生成masks_png
-def label_indices(RGB_label, colormap2label_list):
-    RGB_label = RGB_label.astype('int32')
-    idx = (RGB_label[:, :, 0] * 256 +
-           RGB_label[:, :, 1]) * 256 + RGB_label[:, :, 2]
-    return colormap2label_list[idx]
-
-
-def RGB2mask(RGB_label, colormap2label_list):
-    mask_label = label_indices(RGB_label, colormap2label_list)
-    return mask_label
-
-
-colormap2label_list = colormap2label(palette)
-
-
-def clip_big_image(image_path, clip_save_dir, args, to_label=False):
-    """Original image of GID dataset is very large, thus pre-processing of them
-    is adopted.
-
-    Given fixed clip size and stride size to generate
-    clipped image, the intersection　of width and height is determined.
-    For example, given one 6800 x 7200 original image, the clip size is
-    256 and stride size is 256, thus it would generate 29 x 27 = 783 images
-    whose size are all 256 x 256.
-    """
-
-    image = mmcv.imread(image_path, channel_order='rgb')
-    # image = mmcv.bgr2gray(image)
-
-    h, w, c = image.shape
-    clip_size = args.clip_size
-    stride_size = args.stride_size
-
-    num_rows = math.ceil((h - clip_size) / stride_size) if math.ceil(
-        (h - clip_size) /
-        stride_size) * stride_size + clip_size >= h else math.ceil(
-            (h - clip_size) / stride_size) + 1
-    num_cols = math.ceil((w - clip_size) / stride_size) if math.ceil(
-        (w - clip_size) /
-        stride_size) * stride_size + clip_size >= w else math.ceil(
-            (w - clip_size) / stride_size) + 1
-
-    x, y = np.meshgrid(np.arange(num_cols + 1), np.arange(num_rows + 1))
-    xmin = x * clip_size
-    ymin = y * clip_size
-
-    xmin = xmin.ravel()
-    ymin = ymin.ravel()
-    xmin_offset = np.where(xmin + clip_size > w, w - xmin - clip_size,
-                           np.zeros_like(xmin))
-    ymin_offset = np.where(ymin + clip_size > h, h - ymin - clip_size,
-                           np.zeros_like(ymin))
-    boxes = np.stack([
-        xmin + xmin_offset, ymin + ymin_offset,
-        np.minimum(xmin + clip_size, w),
-        np.minimum(ymin + clip_size, h)
-    ],
-                     axis=1)
-
-    if to_label:
-        image = RGB2mask(image, colormap2label_list)
-
-    for count, box in enumerate(boxes):
-        start_x, start_y, end_x, end_y = box
-        clipped_image = image[start_y:end_y,
-                              start_x:end_x] if to_label else image[
-                                  start_y:end_y, start_x:end_x, :]
-        img_name = osp.basename(image_path).replace('.tif', '')
-        img_name = img_name.replace('_label', '')
-        if count % 3 == 0:
-            mmcv.imwrite(
-                clipped_image.astype(np.uint8),
-                osp.join(
-                    clip_save_dir.replace('train', 'val'),
-                    f'{img_name}_{start_x}_{start_y}_{end_x}_{end_y}.png'))
-        else:
-            mmcv.imwrite(
-                clipped_image.astype(np.uint8),
-                osp.join(
-                    clip_save_dir,
-                    f'{img_name}_{start_x}_{start_y}_{end_x}_{end_y}.png'))
-        count += 1
-
-
-def main():
-    args = parse_args()
-    """
-    According to this paper: https://ieeexplore.ieee.org/document/9343296/
-    select 15 images contained in GID, , which cover the whole six
-    categories, to generate train set and validation set.
-
-    """
-
-    if args.out_dir is None:
-        out_dir = osp.join('data', 'gid')
-    else:
-        out_dir = args.out_dir
-
-    print('Making directories...')
-    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'train'))
-    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'val'))
-    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'train'))
-    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'val'))
-
-    src_path_list = glob.glob(os.path.join(args.dataset_img_path, '*.tif'))
-    print(f'Find {len(src_path_list)} pictures')
-
-    prog_bar = ProgressBar(len(src_path_list))
-
-    dst_img_dir = osp.join(out_dir, 'img_dir', 'train')
-    dst_label_dir = osp.join(out_dir, 'ann_dir', 'train')
-
-    for i, img_path in enumerate(src_path_list):
-        label_path = osp.join(
-            args.dataset_label_path,
-            osp.basename(img_path.replace('.tif', '_label.tif')))
-
-        clip_big_image(img_path, dst_img_dir, args, to_label=False)
-        clip_big_image(label_path, dst_label_dir, args, to_label=True)
-        prog_bar.update()
-
-    print('Done!')
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/projects/gid_dataset/tools/dataset_converters/gid_select15imgFromAll.py b/mmsegmentation/projects/gid_dataset/tools/dataset_converters/gid_select15imgFromAll.py
deleted file mode 100644
index d3eeff2..0000000
--- a/mmsegmentation/projects/gid_dataset/tools/dataset_converters/gid_select15imgFromAll.py
+++ /dev/null
@@ -1,75 +0,0 @@
-import argparse
-import os
-import shutil
-
-# select 15 images from GID dataset
-
-img_list = [
-    'GF2_PMS1__L1A0000647767-MSS1.tif', 'GF2_PMS1__L1A0001064454-MSS1.tif',
-    'GF2_PMS1__L1A0001348919-MSS1.tif', 'GF2_PMS1__L1A0001680851-MSS1.tif',
-    'GF2_PMS1__L1A0001680853-MSS1.tif', 'GF2_PMS1__L1A0001680857-MSS1.tif',
-    'GF2_PMS1__L1A0001757429-MSS1.tif', 'GF2_PMS2__L1A0000607681-MSS2.tif',
-    'GF2_PMS2__L1A0000635115-MSS2.tif', 'GF2_PMS2__L1A0000658637-MSS2.tif',
-    'GF2_PMS2__L1A0001206072-MSS2.tif', 'GF2_PMS2__L1A0001471436-MSS2.tif',
-    'GF2_PMS2__L1A0001642620-MSS2.tif', 'GF2_PMS2__L1A0001787089-MSS2.tif',
-    'GF2_PMS2__L1A0001838560-MSS2.tif'
-]
-
-labels_list = [
-    'GF2_PMS1__L1A0000647767-MSS1_label.tif',
-    'GF2_PMS1__L1A0001064454-MSS1_label.tif',
-    'GF2_PMS1__L1A0001348919-MSS1_label.tif',
-    'GF2_PMS1__L1A0001680851-MSS1_label.tif',
-    'GF2_PMS1__L1A0001680853-MSS1_label.tif',
-    'GF2_PMS1__L1A0001680857-MSS1_label.tif',
-    'GF2_PMS1__L1A0001757429-MSS1_label.tif',
-    'GF2_PMS2__L1A0000607681-MSS2_label.tif',
-    'GF2_PMS2__L1A0000635115-MSS2_label.tif',
-    'GF2_PMS2__L1A0000658637-MSS2_label.tif',
-    'GF2_PMS2__L1A0001206072-MSS2_label.tif',
-    'GF2_PMS2__L1A0001471436-MSS2_label.tif',
-    'GF2_PMS2__L1A0001642620-MSS2_label.tif',
-    'GF2_PMS2__L1A0001787089-MSS2_label.tif',
-    'GF2_PMS2__L1A0001838560-MSS2_label.tif'
-]
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='From 150 images of GID dataset to select 15 images')
-    parser.add_argument('dataset_img_dir', help='150 GID images folder path')
-    parser.add_argument('dataset_label_dir', help='150 GID labels folder path')
-
-    parser.add_argument('dest_img_dir', help='15 GID images folder path')
-    parser.add_argument('dest_label_dir', help='15 GID labels folder path')
-
-    args = parser.parse_args()
-
-    return args
-
-
-def main():
-    """This script is used to select 15 images from GID dataset, According to
-    paper: https://ieeexplore.ieee.org/document/9343296/"""
-    args = parse_args()
-
-    img_path = args.dataset_img_dir
-    label_path = args.dataset_label_dir
-
-    dest_img_dir = args.dest_img_dir
-    dest_label_dir = args.dest_label_dir
-
-    # copy images of 'img_list' to 'desr_dir'
-    print('Copy images of img_list to desr_dir ing...')
-    for img in img_list:
-        shutil.copy(os.path.join(img_path, img), dest_img_dir)
-    print('Done!')
-
-    print('copy labels of labels_list to desr_dir ing...')
-    for label in labels_list:
-        shutil.copy(os.path.join(label_path, label), dest_label_dir)
-    print('Done!')
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/projects/gid_dataset/user_guides/2_dataset_prepare.md b/mmsegmentation/projects/gid_dataset/user_guides/2_dataset_prepare.md
deleted file mode 100644
index 63bd4d4..0000000
--- a/mmsegmentation/projects/gid_dataset/user_guides/2_dataset_prepare.md
+++ /dev/null
@@ -1,53 +0,0 @@
-## Gaofen Image Dataset (GID)
-
-- GID 数据集可在[此处](https://x-ytong.github.io/project/GID.html)进行下载。
-- GID 数据集包含 150 张 6800x7200 的大尺寸图像，标签为 RGB 标签。
-- 根据[文献](https://ieeexplore.ieee.org/document/9343296/)，此处选择 15 张图像生成训练集和验证集，该 15 张图像包含了所有六类信息。所选的图像名称如下：
-
-```None
-  GF2_PMS1__L1A0000647767-MSS1
-  GF2_PMS1__L1A0001064454-MSS1
-  GF2_PMS1__L1A0001348919-MSS1
-  GF2_PMS1__L1A0001680851-MSS1
-  GF2_PMS1__L1A0001680853-MSS1
-  GF2_PMS1__L1A0001680857-MSS1
-  GF2_PMS1__L1A0001757429-MSS1
-  GF2_PMS2__L1A0000607681-MSS2
-  GF2_PMS2__L1A0000635115-MSS2
-  GF2_PMS2__L1A0000658637-MSS2
-  GF2_PMS2__L1A0001206072-MSS2
-  GF2_PMS2__L1A0001471436-MSS2
-  GF2_PMS2__L1A0001642620-MSS2
-  GF2_PMS2__L1A0001787089-MSS2
-  GF2_PMS2__L1A0001838560-MSS2
-```
-
-这里也提供了一个脚本来方便的筛选出15张图像，
-
-```
-python projects/gid_dataset/tools/dataset_converters/gid_select15imgFromAll.py {150 张图像的路径} {150 张标签的路径} {15 张图像的路径} {15 张标签的路径}
-```
-
-在选择出 15 张图像后，执行以下命令进行裁切及标签的转换，需要修改为您所存储 15 张图像及标签的路径。
-
-```
-python projects/gid_dataset/tools/dataset_converters/gid.py {15 张图像的路径} {15 张标签的路径}
-```
-
-完成裁切后的 GID 数据结构如下：
-
-```none
-mmsegmentation
-├── mmseg
-├── tools
-├── configs
-├── data
-│   ├── gid
-│   │   ├── ann_dir
-|   │   │   │   ├── train
-|   │   │   │   ├── val
-│   │   ├── img_dir
-|   │   │   │   ├── train
-|   │   │   │   ├── val
-
-```
diff --git a/mmsegmentation/projects/hsidrive20_dataset/README.md b/mmsegmentation/projects/hsidrive20_dataset/README.md
deleted file mode 100644
index 7ee6e98..0000000
--- a/mmsegmentation/projects/hsidrive20_dataset/README.md
+++ /dev/null
@@ -1,34 +0,0 @@
-# HSI Drive 2.0 Dataset
-
-Support **`HSI Drive 2.0 Dataset`**
-
-## Description
-
-Author: Jon Gutierrez
-
-This project implements **`HSI Drive 2.0 Dataset`**
-
-### Dataset preparing
-
-Preparing `HSI Drive 2.0 Dataset` dataset following [HSI Drive 2.0 Dataset Preparing Guide](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/user_guides/2_dataset_prepare.md#hsi-drive-2.0)
-
-```none
-mmsegmentation/data
-└── HSIDrive20
-    ├── images
-    │   |── training []
-    │   |── validation []
-    │   |── test []
-    └── labels
-    │   |── training []
-    │   |── validation []
-    │   |── test []
-```
-
-### Training commands
-
-```bash
-%cd mmsegmentation
-!python tools/train.py projects/hsidrive20_dataset/configs/unet-s5-d16_fcn_4xb4-160k_hsidrive-208x400.py\
---work-dir your_work_dir
-```
diff --git a/mmsegmentation/projects/hsidrive20_dataset/configs/_base_/datasets/hsi_drive.py b/mmsegmentation/projects/hsidrive20_dataset/configs/_base_/datasets/hsi_drive.py
deleted file mode 100644
index 3114262..0000000
--- a/mmsegmentation/projects/hsidrive20_dataset/configs/_base_/datasets/hsi_drive.py
+++ /dev/null
@@ -1,50 +0,0 @@
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-
-train_dataloader = dict(
-    batch_size=1,
-    num_workers=1,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type='HSIDrive20',
-        data_root='data/HSIDrive20',
-        data_prefix=dict(
-            img_path='images/training', seg_map_path='annotations/training'),
-        pipeline=train_pipeline))
-
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=1,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type='HSIDrive20',
-        data_root='data/HSIDrive20',
-        data_prefix=dict(
-            img_path='images/validation',
-            seg_map_path='annotations/validation'),
-        pipeline=test_pipeline))
-
-test_dataloader = dict(
-    batch_size=1,
-    num_workers=1,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type='HSIDrive20',
-        data_root='data/HSIDrive20',
-        data_prefix=dict(
-            img_path='images/test', seg_map_path='annotations/test'),
-        pipeline=test_pipeline))
-
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'], ignore_index=0)
-test_evaluator = val_evaluator
diff --git a/mmsegmentation/projects/hsidrive20_dataset/configs/unet-s5-d16_fcn_4xb4-160k_hsidrive-192x384.py b/mmsegmentation/projects/hsidrive20_dataset/configs/unet-s5-d16_fcn_4xb4-160k_hsidrive-192x384.py
deleted file mode 100644
index d5eab91..0000000
--- a/mmsegmentation/projects/hsidrive20_dataset/configs/unet-s5-d16_fcn_4xb4-160k_hsidrive-192x384.py
+++ /dev/null
@@ -1,58 +0,0 @@
-_base_ = [
-    '../../../configs/_base_/models/fcn_unet_s5-d16.py',
-    './_base_/datasets/hsi_drive.py',
-    '../../../configs/_base_/default_runtime.py',
-    '../../../configs/_base_/schedules/schedule_160k.py'
-]
-
-custom_imports = dict(
-    imports=['projects.hsidrive20_dataset.mmseg.datasets.hsi_drive'])
-
-crop_size = (192, 384)
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    size=crop_size,
-    mean=None,
-    std=None,
-    bgr_to_rgb=None,
-    pad_val=0,
-    seg_pad_val=255)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(in_channels=25),
-    decode_head=dict(
-        ignore_index=0,
-        num_classes=11,
-        loss_decode=dict(
-            type='CrossEntropyLoss',
-            use_sigmoid=False,
-            loss_weight=1.0,
-            avg_non_ignore=True)),
-    auxiliary_head=dict(
-        ignore_index=0,
-        num_classes=11,
-        loss_decode=dict(
-            type='CrossEntropyLoss',
-            use_sigmoid=False,
-            loss_weight=1.0,
-            avg_non_ignore=True)),
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
-
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='RandomCrop', crop_size=crop_size),
-    dict(type='PackSegInputs')
-]
-
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='RandomCrop', crop_size=crop_size),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-
-train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
-test_dataloader = dict(dataset=dict(pipeline=test_pipeline))
diff --git a/mmsegmentation/projects/hsidrive20_dataset/docs/en/user_guides/2_dataset_prepare.md b/mmsegmentation/projects/hsidrive20_dataset/docs/en/user_guides/2_dataset_prepare.md
deleted file mode 100644
index 1d4ac8c..0000000
--- a/mmsegmentation/projects/hsidrive20_dataset/docs/en/user_guides/2_dataset_prepare.md
+++ /dev/null
@@ -1,42 +0,0 @@
-## HSI Drive 2.0
-
-- You could download HSI Drive 2.0 dataset from [here](https://ipaccess.ehu.eus/HSI-Drive/#download) after just sending an email to gded@ehu.eus with the subject "download HSI-Drive". You will receive a password to uncompress the files.
-
-- After download, unzip by the following instructions:
-
-  ```bash
-  7z x -p"password" ./HSI_Drive_v2_0_Phyton.zip
-
-  mv ./HSIDrive20 path_to_mmsegmentation/data
-  mv ./HSI_Drive_v2_0_release_notes_Python_version.md path_to_mmsegmentation/data
-  mv ./image_numbering.pdf path_to_mmsegmentation/data
-  ```
-
-- After unzip, you get
-
-```none
-mmsegmentation
-├── mmseg
-├── tools
-├── configs
-├── data
-│   ├── HSIDrive20
-│   │   ├── images
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   │   ├── test
-│   │   ├── annotations
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   │   ├── test
-│   │   ├── images_MF
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   │   ├── test
-│   │   ├── RGB
-│   │   ├── training_filenames.txt
-│   │   ├── validation_filenames.txt
-│   │   ├── test_filenames.txt
-│   ├── HSI_Drive_v2_0_release_notes_Python_version.md
-│   ├── image_numbering.pdf
-```
diff --git a/mmsegmentation/projects/hsidrive20_dataset/docs/zh_cn/user_guides/2_dataset_prepare.md b/mmsegmentation/projects/hsidrive20_dataset/docs/zh_cn/user_guides/2_dataset_prepare.md
deleted file mode 100644
index dbf704a..0000000
--- a/mmsegmentation/projects/hsidrive20_dataset/docs/zh_cn/user_guides/2_dataset_prepare.md
+++ /dev/null
@@ -1,42 +0,0 @@
-## HSI Drive 2.0
-
-- 您可以从以下位置下载 HSI Drive 2.0 数据集 [here](https://ipaccess.ehu.eus/HSI-Drive/#download) 刚刚向 gded@ehu.eus 发送主题为“下载 HSI-Drive”的电子邮件后 您将收到解压缩文件的密码.
-
-- 下载后，按照以下说明解压：
-
-  ```bash
-  7z x -p"password" ./HSI_Drive_v2_0_Phyton.zip
-
-  mv ./HSIDrive20 path_to_mmsegmentation/data
-  mv ./HSI_Drive_v2_0_release_notes_Python_version.md path_to_mmsegmentation/data
-  mv ./image_numbering.pdf path_to_mmsegmentation/data
-  ```
-
-- 解压后得到:
-
-```none
-mmsegmentation
-├── mmseg
-├── tools
-├── configs
-├── data
-│   ├── HSIDrive20
-│   │   ├── images
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   │   ├── test
-│   │   ├── annotations
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   │   ├── test
-│   │   ├── images_MF
-│   │   │   ├── training
-│   │   │   ├── validation
-│   │   │   ├── test
-│   │   ├── RGB
-│   │   ├── training_filenames.txt
-│   │   ├── validation_filenames.txt
-│   │   ├── test_filenames.txt
-│   ├── HSI_Drive_v2_0_release_notes_Python_version.md
-│   ├── image_numbering.pdf
-```
diff --git a/mmsegmentation/projects/hsidrive20_dataset/mmseg/datasets/hsi_drive.py b/mmsegmentation/projects/hsidrive20_dataset/mmseg/datasets/hsi_drive.py
deleted file mode 100644
index f8589b0..0000000
--- a/mmsegmentation/projects/hsidrive20_dataset/mmseg/datasets/hsi_drive.py
+++ /dev/null
@@ -1,23 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmseg.datasets import BaseSegDataset
-
-# from mmseg.registry import DATASETS
-
-classes_exp = ('unlabelled', 'road', 'road marks', 'vegetation',
-               'painted metal', 'sky', 'concrete', 'pedestrian', 'water',
-               'unpainted metal', 'glass')
-palette_exp = [[0, 0, 0], [77, 77, 77], [255, 255, 255], [0, 255, 0],
-               [255, 0, 0], [0, 0, 255], [102, 51, 0], [255, 255, 0],
-               [0, 207, 250], [255, 166, 0], [0, 204, 204]]
-
-
-# @DATASETS.register_module()
-class HSIDrive20Dataset(BaseSegDataset):
-    METAINFO = dict(classes=classes_exp, palette=palette_exp)
-
-    def __init__(self,
-                 img_suffix='.npy',
-                 seg_map_suffix='.png',
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
diff --git a/mmsegmentation/projects/hssn/README.md b/mmsegmentation/projects/hssn/README.md
deleted file mode 100644
index 9dcbf37..0000000
--- a/mmsegmentation/projects/hssn/README.md
+++ /dev/null
@@ -1,91 +0,0 @@
-# HSSN
-
-## Description
-
-Author: AI-Tianlong
-
-This project implements `Deep Hierarchical Semantic Segmentation`  inference on `cityscapes` dataset
-
-## Usage
-
-### Prerequisites
-
-- Python 3.8
-- PyTorch 1.6 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-- mmcv v2.0.0rc4
-- mmengine >=0.4.0
-
-### Dataset preparing
-
-Preparing `cityscapes` dataset following this [Dataset Preparing Guide](https://github.com/open-mmlab/mmsegmentation/blob/master/docs/en/dataset_prepare.md#prepare-datasets)
-
-### Testing commands
-
-Please put [`hieraseg_deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024_20230112_125023-bc59a3d1.pth`](https://download.openmmlab.com/mmsegmentation/v0.5/hieraseg/hieraseg_deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024_20230112_125023-bc59a3d1.pth) to `mmsegmentation/checkpoints`
-
-#### Multi-GPUs Test
-
-```bash
-# --tta optional, multi-scale test, need mmengine >=0.4.0
-bash tools/dist_test.sh [configs] [model weights] [number of gpu]  --tta
-```
-
-#### Example
-
-```shell
-bash tools/dist_test.sh projects/hssn/configs/hssn/hieraseg_deeplabv3plus_r101-d8_4xb2-80l_cityscapes-512x1024.py checkpoints/hieraseg_deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024_20230112_125023-bc59a3d1.pth 2 --tta
-```
-
-## Results
-
-### Cityscapes
-
-|   Method   | Backbone | Crop Size | mIoU  | mIoU (ms+flip) |                                                                               config                                                                               |                                                                             model                                                                             |
-| :--------: | :------: | :-------: | :---: | :------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------: |
-| DeeplabV3+ | R-101-D8 | 512x1024  | 81.61 |     82.71      | [config](https://github.com/open-mmlab/mmsegmentation/tree/main/projects/HieraSeg/configs/hieraseg/hieraseg_deeplabv3plus_r101-d8_4xb2-80l_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/hieraseg/hieraseg_deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024_20230112_125023-bc59a3d1.pth) |
-
-<img src="https://user-images.githubusercontent.com/50650583/210488953-e3e35ade-1132-47e1-9dfd-cf12b357ae80.png" width="50%"><img src="https://user-images.githubusercontent.com/50650583/210489746-e35ee229-3234-4292-a649-a8cd85f312ad.png" width="50%">
-
-## Citation
-
-This project is modified from [qhanghu/HSSN_pytorch](https://github.com/qhanghu/HSSN_pytorch)
-
-```bibtex
-@article{li2022deep,
-  title={Deep Hierarchical Semantic Segmentation},
-  author={Li, Liulei and Zhou, Tianfei and Wang, Wenguan and Li, Jianwu and Yang, Yi},
-  journal={CVPR},
-  year={2022}
-}
-```
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-
-  - [x] Basic docstrings & proper citation
-
-  - [x] Test-time correctness
-
-  - [x] A full README
-
-- [ ] Milestone 2: Indicates a successful model implementation.
-
-  - [ ] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-
-  - [ ] Unit tests
-
-  - [ ] Code polishing
-
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/hssn/configs/_base_/datasets/cityscapes.py b/mmsegmentation/projects/hssn/configs/_base_/datasets/cityscapes.py
deleted file mode 100644
index 1698e04..0000000
--- a/mmsegmentation/projects/hssn/configs/_base_/datasets/cityscapes.py
+++ /dev/null
@@ -1,67 +0,0 @@
-# dataset settings
-dataset_type = 'CityscapesDataset'
-data_root = 'data/cityscapes/'
-crop_size = (512, 1024)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(
-        type='RandomResize',
-        scale=(2048, 1024),
-        ratio_range=(0.5, 2.0),
-        keep_ratio=True),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
-tta_pipeline = [
-    dict(type='LoadImageFromFile', file_client_args=dict(backend='disk')),
-    dict(
-        type='TestTimeAug',
-        transforms=[
-            [
-                dict(type='Resize', scale_factor=r, keep_ratio=True)
-                for r in img_ratios
-            ],
-            [
-                dict(type='RandomFlip', prob=0., direction='horizontal'),
-                dict(type='RandomFlip', prob=1., direction='horizontal')
-            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
-        ])
-]
-train_dataloader = dict(
-    batch_size=2,
-    num_workers=2,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='leftImg8bit/train', seg_map_path='gtFine/train'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='leftImg8bit/val', seg_map_path='gtFine/val'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
-test_evaluator = val_evaluator
diff --git a/mmsegmentation/projects/hssn/configs/_base_/default_runtime.py b/mmsegmentation/projects/hssn/configs/_base_/default_runtime.py
deleted file mode 100644
index 272b4d2..0000000
--- a/mmsegmentation/projects/hssn/configs/_base_/default_runtime.py
+++ /dev/null
@@ -1,15 +0,0 @@
-default_scope = 'mmseg'
-env_cfg = dict(
-    cudnn_benchmark=True,
-    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
-    dist_cfg=dict(backend='nccl'),
-)
-vis_backends = [dict(type='LocalVisBackend')]
-visualizer = dict(
-    type='SegLocalVisualizer', vis_backends=vis_backends, name='visualizer')
-log_processor = dict(by_epoch=False)
-log_level = 'INFO'
-load_from = None
-resume = False
-
-tta_model = dict(type='SegTTAModel')
diff --git a/mmsegmentation/projects/hssn/configs/_base_/models/deeplabv3plus_r50-d8_vd_contrast.py b/mmsegmentation/projects/hssn/configs/_base_/models/deeplabv3plus_r50-d8_vd_contrast.py
deleted file mode 100644
index a6af45c..0000000
--- a/mmsegmentation/projects/hssn/configs/_base_/models/deeplabv3plus_r50-d8_vd_contrast.py
+++ /dev/null
@@ -1,55 +0,0 @@
-# model settings
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    mean=[123.675, 116.28, 103.53],
-    std=[58.395, 57.12, 57.375],
-    bgr_to_rgb=True,
-    pad_val=0,
-    seg_pad_val=255)
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    pretrained=None,
-    backbone=dict(
-        type='ResNetV1d',
-        depth=50,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        dilations=(1, 1, 2, 4),
-        strides=(1, 2, 1, 1),
-        norm_cfg=norm_cfg,
-        norm_eval=False,
-        style='pytorch',
-        contract_dilation=True),
-    decode_head=dict(
-        type='DepthwiseSeparableASPPContrastHead',
-        in_channels=2048,
-        in_index=3,
-        channels=512,
-        dilations=(1, 12, 24, 36),
-        c1_in_channels=256,
-        c1_channels=48,
-        dropout_ratio=0.1,
-        num_classes=19,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        proj='convmlp',
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-    auxiliary_head=dict(
-        type='FCNHead',
-        in_channels=1024,
-        in_index=2,
-        channels=256,
-        num_convs=1,
-        concat_input=False,
-        dropout_ratio=0.1,
-        num_classes=19,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/projects/hssn/configs/_base_/schedules/schedule_80k.py b/mmsegmentation/projects/hssn/configs/_base_/schedules/schedule_80k.py
deleted file mode 100644
index 0dcd6c4..0000000
--- a/mmsegmentation/projects/hssn/configs/_base_/schedules/schedule_80k.py
+++ /dev/null
@@ -1,24 +0,0 @@
-# optimizer
-optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
-# learning policy
-param_scheduler = [
-    dict(
-        type='PolyLR',
-        eta_min=1e-4,
-        power=0.9,
-        begin=0,
-        end=80000,
-        by_epoch=False)
-]
-# training schedule for 80k
-train_cfg = dict(type='IterBasedTrainLoop', max_iters=80000, val_interval=8000)
-val_cfg = dict(type='ValLoop')
-test_cfg = dict(type='TestLoop')
-default_hooks = dict(
-    timer=dict(type='IterTimerHook'),
-    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
-    param_scheduler=dict(type='ParamSchedulerHook'),
-    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=8000),
-    sampler_seed=dict(type='DistSamplerSeedHook'),
-    visualization=dict(type='SegVisualizationHook'))
diff --git a/mmsegmentation/projects/hssn/configs/hssn/hieraseg_deeplabv3plus_r101-d8_4xb2-80l_cityscapes-512x1024.py b/mmsegmentation/projects/hssn/configs/hssn/hieraseg_deeplabv3plus_r101-d8_4xb2-80l_cityscapes-512x1024.py
deleted file mode 100644
index 8f04a2d..0000000
--- a/mmsegmentation/projects/hssn/configs/hssn/hieraseg_deeplabv3plus_r101-d8_4xb2-80l_cityscapes-512x1024.py
+++ /dev/null
@@ -1,21 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3plus_r50-d8_vd_contrast.py',
-    '../_base_/datasets/cityscapes.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-
-custom_imports = dict(imports=[
-    'projects.hssn.decode_head.sep_aspp_contrast_head',
-    'projects.hssn.losses.hiera_triplet_loss_cityscape'
-])
-
-model = dict(
-    pretrained=None,
-    backbone=dict(depth=101),
-    decode_head=dict(
-        num_classes=26,
-        loss_decode=dict(
-            type='HieraTripletLossCityscape', num_classes=19,
-            loss_weight=1.0)),
-    auxiliary_head=dict(num_classes=19),
-    test_cfg=dict(mode='whole', is_hiera=True, hiera_num_classes=7))
diff --git a/mmsegmentation/projects/hssn/decode_head/__init__.py b/mmsegmentation/projects/hssn/decode_head/__init__.py
deleted file mode 100644
index da454ea..0000000
--- a/mmsegmentation/projects/hssn/decode_head/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .sep_aspp_contrast_head import DepthwiseSeparableASPPContrastHead
-
-__all__ = ['DepthwiseSeparableASPPContrastHead']
diff --git a/mmsegmentation/projects/hssn/decode_head/sep_aspp_contrast_head.py b/mmsegmentation/projects/hssn/decode_head/sep_aspp_contrast_head.py
deleted file mode 100644
index 331af30..0000000
--- a/mmsegmentation/projects/hssn/decode_head/sep_aspp_contrast_head.py
+++ /dev/null
@@ -1,193 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from typing import List, Tuple
-
-import torch
-import torch.nn as nn
-from mmcv.cnn import build_norm_layer
-from torch import Tensor
-
-from mmseg.models.decode_heads.sep_aspp_head import DepthwiseSeparableASPPHead
-from mmseg.models.losses import accuracy
-from mmseg.models.utils import resize
-from mmseg.registry import MODELS
-from mmseg.utils import SampleList
-
-
-class ProjectionHead(nn.Module):
-    """ProjectionHead, project feature map to specific channels.
-
-    Args:
-        dim_in (int): Input channels.
-        norm_cfg (dict): config of norm layer.
-        proj_dim (int): Output channels. Default: 256.
-        proj (str): Projection type, 'linear' or 'convmlp'. Default: 'convmlp'
-    """
-
-    def __init__(self,
-                 dim_in: int,
-                 norm_cfg: dict,
-                 proj_dim: int = 256,
-                 proj: str = 'convmlp'):
-        super().__init__()
-        assert proj in ['convmlp', 'linear']
-        if proj == 'linear':
-            self.proj = nn.Conv2d(dim_in, proj_dim, kernel_size=1)
-        elif proj == 'convmlp':
-            self.proj = nn.Sequential(
-                nn.Conv2d(dim_in, dim_in, kernel_size=1),
-                build_norm_layer(norm_cfg, dim_in)[1], nn.ReLU(inplace=True),
-                nn.Conv2d(dim_in, proj_dim, kernel_size=1))
-
-    def forward(self, x):
-        return torch.nn.functional.normalize(self.proj(x), p=2, dim=1)
-
-
-@MODELS.register_module()
-class DepthwiseSeparableASPPContrastHead(DepthwiseSeparableASPPHead):
-    """Deep Hierarchical Semantic Segmentation. This head is the implementation
-    of `<https://arxiv.org/abs/2203.14335>`_.
-
-    Based on Encoder-Decoder with Atrous Separable Convolution for
-    Semantic Image Segmentation.
-    `DeepLabV3+ <https://arxiv.org/abs/1802.02611>`_.
-
-    Args:
-        proj (str): The type of ProjectionHead, 'linear' or 'convmlp',
-            default 'convmlp'
-    """
-
-    def __init__(self, proj: str = 'convmlp', **kwargs):
-        super().__init__(**kwargs)
-        self.proj_head = ProjectionHead(
-            dim_in=2048, norm_cfg=self.norm_cfg, proj=proj)
-        self.register_buffer('step', torch.zeros(1))
-
-    def forward(self, inputs) -> Tuple[Tensor]:
-        """Forward function."""
-        output = super().forward(inputs)
-
-        self.step += 1
-        embedding = self.proj_head(inputs[-1])
-
-        return output, embedding
-
-    def predict_by_feat(self, seg_logits: Tuple[Tensor],
-                        batch_img_metas: List[dict]) -> Tensor:
-        """Transform a batch of output seg_logits to the input shape.
-
-        Args:
-            seg_logits (Tensor): The output from decode head forward function.
-            batch_img_metas (list[dict]): Meta information of each image, e.g.,
-                image size, scaling factor, etc.
-
-        Returns:
-            Tensor: Outputs segmentation logits map.
-        """
-        # HSSN decode_head output is: (out, embedding): tuple
-        # only need 'out' here.
-        if isinstance(seg_logits, tuple):
-            seg_logit = seg_logits[0]
-
-        if seg_logit.size(1) == 26:  # For cityscapes dataset，19 + 7
-            hiera_num_classes = 7
-            seg_logit[:, 0:2] += seg_logit[:, -7]
-            seg_logit[:, 2:5] += seg_logit[:, -6]
-            seg_logit[:, 5:8] += seg_logit[:, -5]
-            seg_logit[:, 8:10] += seg_logit[:, -4]
-            seg_logit[:, 10:11] += seg_logit[:, -3]
-            seg_logit[:, 11:13] += seg_logit[:, -2]
-            seg_logit[:, 13:19] += seg_logit[:, -1]
-
-        elif seg_logit.size(1) == 12:  # For Pascal_person dataset, 7 + 5
-            hiera_num_classes = 5
-            seg_logit[:, 0:1] = seg_logit[:, 0:1] + \
-                seg_logit[:, 7] + seg_logit[:, 10]
-            seg_logit[:, 1:5] = seg_logit[:, 1:5] + \
-                seg_logit[:, 8] + seg_logit[:, 11]
-            seg_logit[:, 5:7] = seg_logit[:, 5:7] + \
-                seg_logit[:, 9] + seg_logit[:, 11]
-
-        elif seg_logit.size(1) == 25:  # For LIP dataset, 20 + 5
-            hiera_num_classes = 5
-            seg_logit[:, 0:1] = seg_logit[:, 0:1] + \
-                seg_logit[:, 20] + seg_logit[:, 23]
-            seg_logit[:, 1:8] = seg_logit[:, 1:8] + \
-                seg_logit[:, 21] + seg_logit[:, 24]
-            seg_logit[:, 10:12] = seg_logit[:, 10:12] + \
-                seg_logit[:, 21] + seg_logit[:, 24]
-            seg_logit[:, 13:16] = seg_logit[:, 13:16] + \
-                seg_logit[:, 21] + seg_logit[:, 24]
-            seg_logit[:, 8:10] = seg_logit[:, 8:10] + \
-                seg_logit[:, 22] + seg_logit[:, 24]
-            seg_logit[:, 12:13] = seg_logit[:, 12:13] + \
-                seg_logit[:, 22] + seg_logit[:, 24]
-            seg_logit[:, 16:20] = seg_logit[:, 16:20] + \
-                seg_logit[:, 22] + seg_logit[:, 24]
-
-        # elif seg_logit.size(1) == 144 # For Mapillary dataset, 124+16+4
-        # unofficial repository not release mapillary until 2023/2/6
-
-        if isinstance(batch_img_metas[0]['img_shape'], torch.Size):
-            # slide inference
-            size = batch_img_metas[0]['img_shape']
-        elif 'pad_shape' in batch_img_metas[0]:
-            size = batch_img_metas[0]['pad_shape'][:2]
-        else:
-            size = batch_img_metas[0]['img_shape']
-        seg_logit = seg_logit[:, :-hiera_num_classes]
-        seg_logit = resize(
-            input=seg_logit,
-            size=size,
-            mode='bilinear',
-            align_corners=self.align_corners)
-
-        return seg_logit
-
-    def loss_by_feat(
-            self,
-            seg_logits: Tuple[Tensor],  # (out, embedding)
-            batch_data_samples: SampleList) -> dict:
-        """Compute segmentation loss. Will fix in future.
-
-        Args:
-            seg_logits (Tuple[Tensor]): The output from decode head
-                forward function.
-                For this decode_head output are (out, embedding): tuple
-            batch_data_samples (List[:obj:`SegDataSample`]): The seg
-                data samples. It usually includes information such
-                as `metainfo` and `gt_sem_seg`.
-
-        Returns:
-            dict[str, Tensor]: a dictionary of loss components
-        """
-        seg_logit_before = seg_logits[0]
-        embedding = seg_logits[1]
-        seg_label = self._stack_batch_gt(batch_data_samples)
-
-        loss = dict()
-        seg_logit = resize(
-            input=seg_logit_before,
-            size=seg_label.shape[2:],
-            mode='bilinear',
-            align_corners=self.align_corners)
-        if self.sampler is not None:
-            seg_weight = self.sampler.sample(seg_logit, seg_label)
-        else:
-            seg_weight = None
-        seg_label = seg_label.squeeze(1)
-        seg_logit_before = resize(
-            input=seg_logit_before,
-            scale_factor=0.5,
-            mode='bilinear',
-            align_corners=self.align_corners)
-
-        loss['loss_seg'] = self.loss_decode(
-            self.step,
-            embedding,
-            seg_logit_before,
-            seg_logit,
-            seg_label,
-            weight=seg_weight,
-            ignore_index=self.ignore_index)
-        loss['acc_seg'] = accuracy(seg_logit, seg_label)
-        return loss
diff --git a/mmsegmentation/projects/hssn/losses/__init__.py b/mmsegmentation/projects/hssn/losses/__init__.py
deleted file mode 100644
index 47d2686..0000000
--- a/mmsegmentation/projects/hssn/losses/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .hiera_triplet_loss_cityscape import HieraTripletLossCityscape
-
-__all__ = ['HieraTripletLossCityscape']
diff --git a/mmsegmentation/projects/hssn/losses/hiera_triplet_loss_cityscape.py b/mmsegmentation/projects/hssn/losses/hiera_triplet_loss_cityscape.py
deleted file mode 100644
index a784f13..0000000
--- a/mmsegmentation/projects/hssn/losses/hiera_triplet_loss_cityscape.py
+++ /dev/null
@@ -1,218 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import math
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-from mmseg.models.builder import LOSSES
-from mmseg.models.losses.cross_entropy_loss import CrossEntropyLoss
-from .tree_triplet_loss import TreeTripletLoss
-
-hiera_map = [0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 4, 5, 5, 6, 6, 6, 6, 6, 6]
-hiera_index = [[0, 2], [2, 5], [5, 8], [8, 10], [10, 11], [11, 13], [13, 19]]
-
-hiera = {
-    'hiera_high': {
-        'flat': [0, 2],
-        'construction': [2, 5],
-        'object': [5, 8],
-        'nature': [8, 10],
-        'sky': [10, 11],
-        'human': [11, 13],
-        'vehicle': [13, 19]
-    }
-}
-
-
-def prepare_targets(targets):
-    b, h, w = targets.shape
-    targets_high = torch.ones(
-        (b, h, w), dtype=targets.dtype, device=targets.device) * 255
-    indices_high = []
-    for index, high in enumerate(hiera['hiera_high'].keys()):
-        indices = hiera['hiera_high'][high]
-        for ii in range(indices[0], indices[1]):
-            targets_high[targets == ii] = index
-        indices_high.append(indices)
-
-    return targets, targets_high, indices_high
-
-
-def losses_hiera(predictions,
-                 targets,
-                 targets_top,
-                 num_classes,
-                 indices_high,
-                 eps=1e-8):
-    """Implementation of hiera loss.
-
-    Args:
-        predictions (torch.Tensor): seg logits produced by decode head.
-        targets (torch.Tensor): The learning label of the prediction.
-        targets_top (torch.Tensor): The hierarchy ground truth of the learning
-            label.
-        num_classes (int): Number of categories.
-        indices_high (List[List[int]]): Hierarchy indices of each hierarchy.
-        eps (float):Term added to the Logarithm to improve numerical stability.
-    """
-    b, _, h, w = predictions.shape
-    predictions = torch.sigmoid(predictions.float())
-    void_indices = (targets == 255)
-    targets[void_indices] = 0
-    targets = F.one_hot(targets, num_classes=num_classes).permute(0, 3, 1, 2)
-    void_indices2 = (targets_top == 255)
-    targets_top[void_indices2] = 0
-    targets_top = F.one_hot(targets_top, num_classes=7).permute(0, 3, 1, 2)
-
-    MCMA = predictions[:, :num_classes, :, :]
-    MCMB = torch.zeros((b, 7, h, w)).to(predictions)
-    for ii in range(7):
-        MCMB[:, ii:ii + 1, :, :] = torch.max(
-            torch.cat([
-                predictions[:, indices_high[ii][0]:indices_high[ii][1], :, :],
-                predictions[:, num_classes + ii:num_classes + ii + 1, :, :]
-            ],
-                      dim=1), 1, True)[0]
-
-    MCLB = predictions[:, num_classes:num_classes + 7, :, :]
-    MCLA = predictions[:, :num_classes, :, :].clone()
-    for ii in range(7):
-        for jj in range(indices_high[ii][0], indices_high[ii][1]):
-            MCLA[:, jj:jj + 1, :, :] = torch.min(
-                torch.cat([
-                    predictions[:, jj:jj + 1, :, :], MCLB[:, ii:ii + 1, :, :]
-                ],
-                          dim=1), 1, True)[0]
-
-    valid_indices = (~void_indices).unsqueeze(1)
-    num_valid = valid_indices.sum()
-    valid_indices2 = (~void_indices2).unsqueeze(1)
-    num_valid2 = valid_indices2.sum()
-    # channel_num*sum()/one_channel_valid already has a weight
-    loss = (
-        (-targets[:, :num_classes, :, :] * torch.log(MCLA + eps) -
-         (1.0 - targets[:, :num_classes, :, :]) * torch.log(1.0 - MCMA + eps))
-        * valid_indices).sum() / num_valid / num_classes
-    loss += ((-targets_top[:, :, :, :] * torch.log(MCLB + eps) -
-              (1.0 - targets_top[:, :, :, :]) * torch.log(1.0 - MCMB + eps)) *
-             valid_indices2).sum() / num_valid2 / 7
-
-    return 5 * loss
-
-
-def losses_hiera_focal(predictions,
-                       targets,
-                       targets_top,
-                       num_classes,
-                       indices_high,
-                       eps=1e-8,
-                       gamma=2):
-    """Implementation of hiera loss.
-
-    Args:
-        predictions (torch.Tensor): seg logits produced by decode head.
-        targets (torch.Tensor): The learning label of the prediction.
-        targets_top (torch.Tensor): The hierarchy ground truth of the learning
-            label.
-        num_classes (int): Number of categories.
-        indices_high (List[List[int]]): Hierarchy indices of each hierarchy.
-        eps (float):Term added to the Logarithm to improve numerical stability.
-            Defaults: 1e-8.
-        gamma (int): The exponent value. Defaults: 2.
-    """
-    b, _, h, w = predictions.shape
-    predictions = torch.sigmoid(predictions.float())
-    void_indices = (targets == 255)
-    targets[void_indices] = 0
-    targets = F.one_hot(targets, num_classes=num_classes).permute(0, 3, 1, 2)
-    void_indices2 = (targets_top == 255)
-    targets_top[void_indices2] = 0
-    targets_top = F.one_hot(targets_top, num_classes=7).permute(0, 3, 1, 2)
-
-    MCMA = predictions[:, :num_classes, :, :]
-    MCMB = torch.zeros((b, 7, h, w),
-                       dtype=predictions.dtype,
-                       device=predictions.device)
-    for ii in range(7):
-        MCMB[:, ii:ii + 1, :, :] = torch.max(
-            torch.cat([
-                predictions[:, indices_high[ii][0]:indices_high[ii][1], :, :],
-                predictions[:, num_classes + ii:num_classes + ii + 1, :, :]
-            ],
-                      dim=1), 1, True)[0]
-
-    MCLB = predictions[:, num_classes:num_classes + 7, :, :]
-    MCLA = predictions[:, :num_classes, :, :].clone()
-    for ii in range(7):
-        for jj in range(indices_high[ii][0], indices_high[ii][1]):
-            MCLA[:, jj:jj + 1, :, :] = torch.min(
-                torch.cat([
-                    predictions[:, jj:jj + 1, :, :], MCLB[:, ii:ii + 1, :, :]
-                ],
-                          dim=1), 1, True)[0]
-
-    valid_indices = (~void_indices).unsqueeze(1)
-    num_valid = valid_indices.sum()
-    valid_indices2 = (~void_indices2).unsqueeze(1)
-    num_valid2 = valid_indices2.sum()
-    # channel_num*sum()/one_channel_valid already has a weight
-    loss = ((-targets[:, :num_classes, :, :] * torch.pow(
-        (1.0 - MCLA), gamma) * torch.log(MCLA + eps) -
-             (1.0 - targets[:, :num_classes, :, :]) * torch.pow(MCMA, gamma) *
-             torch.log(1.0 - MCMA + eps)) *
-            valid_indices).sum() / num_valid / num_classes
-    loss += (
-        (-targets_top[:, :, :, :] * torch.pow(
-            (1.0 - MCLB), gamma) * torch.log(MCLB + eps) -
-         (1.0 - targets_top[:, :, :, :]) * torch.pow(MCMB, gamma) *
-         torch.log(1.0 - MCMB + eps)) * valid_indices2).sum() / num_valid2 / 7
-
-    return 5 * loss
-
-
-@LOSSES.register_module()
-class HieraTripletLossCityscape(nn.Module):
-    """Modified from https://github.com/qhanghu/HSSN_pytorch/blob/main/mmseg/mo
-    dels/losses/hiera_triplet_loss_cityscape.py."""
-
-    def __init__(self, num_classes, use_sigmoid=False, loss_weight=1.0):
-        super().__init__()
-        self.num_classes = num_classes
-        self.loss_weight = loss_weight
-        self.treetripletloss = TreeTripletLoss(num_classes, hiera_map,
-                                               hiera_index)
-        self.ce = CrossEntropyLoss()
-
-    def forward(self,
-                step,
-                embedding,
-                cls_score_before,
-                cls_score,
-                label,
-                weight=None,
-                **kwargs):
-        targets, targets_top, indices_top = prepare_targets(label)
-
-        loss = losses_hiera(cls_score, targets, targets_top, self.num_classes,
-                            indices_top)
-        ce_loss = self.ce(cls_score[:, :-7], label)
-        ce_loss2 = self.ce(cls_score[:, -7:], targets_top)
-        loss = loss + ce_loss + ce_loss2
-
-        loss_triplet, class_count = self.treetripletloss(embedding, label)
-        class_counts = [
-            torch.ones_like(class_count)
-            for _ in range(torch.distributed.get_world_size())
-        ]
-        torch.distributed.all_gather(class_counts, class_count, async_op=False)
-        class_counts = torch.cat(class_counts, dim=0)
-
-        if torch.distributed.get_world_size() == torch.nonzero(
-                class_counts, as_tuple=False).size(0):
-            factor = 1 / 4 * (1 + torch.cos(
-                torch.tensor((step.item() - 80000) / 80000 *
-                             math.pi))) if step.item() < 80000 else 0.5
-            loss += factor * loss_triplet
-
-        return loss * self.loss_weight
diff --git a/mmsegmentation/projects/hssn/losses/tree_triplet_loss.py b/mmsegmentation/projects/hssn/losses/tree_triplet_loss.py
deleted file mode 100644
index ccc0937..0000000
--- a/mmsegmentation/projects/hssn/losses/tree_triplet_loss.py
+++ /dev/null
@@ -1,86 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-from mmseg.models.builder import LOSSES
-
-
-@LOSSES.register_module()
-class TreeTripletLoss(nn.Module):
-    """TreeTripletLoss. Modified from https://github.com/qhanghu/HSSN_pytorch/b
-    lob/main/mmseg/models/losses/tree_triplet_loss.py.
-
-    Args:
-        num_classes (int): Number of categories.
-        hiera_map (List[int]): Hierarchy map of each category.
-        hiera_index (List[List[int]]): Hierarchy indices of each hierarchy.
-        ignore_index (int): Specifies a target value that is ignored and
-            does not contribute to the input gradients. Defaults: 255.
-
-    Examples:
-        >>> num_classes = 19
-        >>> hiera_map = [
-                0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 4, 5, 5, 6, 6, 6, 6, 6, 6]
-        >>> hiera_index = [
-                0, 2], [2, 5], [5, 8], [8, 10], [10, 11], [11, 13], [13, 19]]
-    """
-
-    def __init__(self, num_classes, hiera_map, hiera_index, ignore_index=255):
-        super().__init__()
-
-        self.ignore_label = ignore_index
-        self.num_classes = num_classes
-        self.hiera_map = hiera_map
-        self.hiera_index = hiera_index
-
-    def forward(self, feats: torch.Tensor, labels=None, max_triplet=200):
-        labels = labels.unsqueeze(1).float().clone()
-        labels = torch.nn.functional.interpolate(
-            labels, (feats.shape[2], feats.shape[3]), mode='nearest')
-        labels = labels.squeeze(1).long()
-        assert labels.shape[-1] == feats.shape[-1], '{} {}'.format(
-            labels.shape, feats.shape)
-
-        labels = labels.view(-1)
-        feats = feats.permute(0, 2, 3, 1)
-        feats = feats.contiguous().view(-1, feats.shape[-1])
-
-        triplet_loss = 0
-        exist_classes = torch.unique(labels)
-        exist_classes = [x for x in exist_classes if x != 255]
-        class_count = 0
-
-        for ii in exist_classes:
-            index_range = self.hiera_index[self.hiera_map[ii]]
-            index_anchor = labels == ii
-            index_pos = (labels >= index_range[0]) & (
-                labels < index_range[-1]) & (~index_anchor)
-            index_neg = (labels < index_range[0]) | (labels >= index_range[-1])
-
-            min_size = min(
-                torch.sum(index_anchor), torch.sum(index_pos),
-                torch.sum(index_neg), max_triplet)
-
-            feats_anchor = feats[index_anchor][:min_size]
-            feats_pos = feats[index_pos][:min_size]
-            feats_neg = feats[index_neg][:min_size]
-
-            distance = torch.zeros(min_size, 2).to(feats)
-            distance[:, 0:1] = 1 - (feats_anchor * feats_pos).sum(1, True)
-            distance[:, 1:2] = 1 - (feats_anchor * feats_neg).sum(1, True)
-
-            # margin always 0.1 + (4-2)/4 since the hierarchy is three level
-            # TODO: should include label of pos is the same as anchor
-            margin = 0.6 * torch.ones(min_size).to(feats)
-
-            tl = distance[:, 0] - distance[:, 1] + margin
-            tl = F.relu(tl)
-
-            if tl.size(0) > 0:
-                triplet_loss += tl.mean()
-                class_count += 1
-        if class_count == 0:
-            return None, torch.tensor([0]).to(feats)
-        triplet_loss /= class_count
-        return triplet_loss, torch.tensor([class_count]).to(feats)
diff --git a/mmsegmentation/projects/isnet/README.md b/mmsegmentation/projects/isnet/README.md
deleted file mode 100644
index 0a79ad6..0000000
--- a/mmsegmentation/projects/isnet/README.md
+++ /dev/null
@@ -1,117 +0,0 @@
-# ISNet
-
-[ISNet: Integrate Image-Level and Semantic-Level Context for Semantic Segmentation](https://arxiv.org/pdf/2108.12382.pdf)
-
-## Description
-
-This is an implementation of [ISNet](https://arxiv.org/pdf/2108.12382.pdf).
-[Official Repo](https://github.com/SegmentationBLWX/sssegmentation)
-
-## Usage
-
-### Prerequisites
-
-- Python 3.7
-- PyTorch 1.6 or higher
-- [MIM](https://github.com/open-mmlab/mim) v0.33 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc2 or higher
-
-All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `isnet/` root directory, run the following line to add the current directory to `PYTHONPATH`:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Training commands
-
-```shell
-mim train mmsegmentation configs/isnet_r50-d8_8xb2-160k_cityscapes-512x1024.py --work-dir work_dirs/isnet
-```
-
-To train on multiple GPUs, e.g. 8 GPUs, run the following command:
-
-```shell
-mim train mmsegmentation configs/isnet_r50-d8_8xb2-160k_cityscapes-512x1024.py --work-dir work_dirs/isnet --launcher pytorch --gpus 8
-```
-
-### Testing commands
-
-```shell
-mim test mmsegmentation configs/isnet_r50-d8_8xb2-160k_cityscapes-512x1024.py --work-dir work_dirs/isnet --checkpoint ${CHECKPOINT_PATH}
-```
-
-| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) |  mIoU | mIoU(ms+flip) | config                                                          | download                                                                                                                 |
-| ------ | -------- | --------- | ------: | -------- | -------------- | ----: | ------------: | --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
-| ISNet  | R-50-D8  | 512x1024  |       - | -        | -              | 79.32 |         80.88 | [config](configs/isnet_r50-d8_8xb2-160k_cityscapes-512x1024.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/isnet/isnet_r50-d8_cityscapes-512x1024_20230104-a7a8ccf2.pth) |
-
-## Citation
-
-```bibtex
-@article{Jin2021ISNetII,
-  title={ISNet: Integrate Image-Level and Semantic-Level Context for Semantic Segmentation},
-  author={Zhenchao Jin and B. Liu and Qi Chu and Nenghai Yu},
-  journal={2021 IEEE/CVF International Conference on Computer Vision (ICCV)},
-  year={2021},
-  pages={7169-7178}
-}
-```
-
-## Checklist
-
-The progress of ISNet.
-
-<!-- The PIC (person in charge) or contributors of this project should check all the items that they believe have been finished, which will further be verified by codebase maintainers via a PR.
-
-OpenMMLab's maintainer will review the code to ensure the project's quality. Reaching the first milestone means that this project suffices the minimum requirement of being merged into 'projects/'. But this project is only eligible to become a part of the core package upon attaining the last milestone.
-
-Note that keeping this section up-to-date is crucial not only for this project's developers but the entire community, since there might be some other contributors joining this project and deciding their starting point from this list. It also helps maintainers accurately estimate time and effort on further code polishing, if needed.
-
-A project does not necessarily have to be finished in a single PR, but it's essential for the project to at least reach the first milestone in its very first PR. -->
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-
-  <!-- The code's design shall follow existing interfaces and convention. For example, each model component should be registered into `mmseg.registry.MODELS` and configurable via a config file. -->
-
-  - [x] Basic docstrings & proper citation
-
-  <!-- Each major object should contain a docstring, describing its functionality and arguments. If you have adapted the code from other open-source projects, don't forget to cite the source project in docstring and make sure your behavior is not against its license. Typically, we do not accept any code snippet under GPL license. [A Short Guide to Open Source Licenses](https://medium.com/nationwide-technology/a-short-guide-to-open-source-licenses-cf5b1c329edd) -->
-
-  - [x] Test-time correctness
-
-  <!-- If you are reproducing the result from a paper, make sure your model's inference-time performance matches that in the original paper. The weights usually could be obtained by simply renaming the keys in the official pre-trained weights. This test could be skipped though, if you are able to prove the training-time correctness and check the second milestone. -->
-
-  - [x] A full README
-
-  <!-- As this template does. -->
-
-- [ ] Milestone 2: Indicates a successful model implementation.
-
-  - [ ] Training-time correctness
-
-  <!-- If you are reproducing the result from a paper, checking this item means that you should have trained your model from scratch based on the original paper's specification and verified that the final result matches the report within a minor error range. -->
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-
-  <!-- Ideally *all* the methods should have [type hints](https://www.pythontutorial.net/python-basics/python-type-hints/) and [docstrings](https://google.github.io/styleguide/pyguide.html#381-docstrings). [Example](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/utils/io.py#L9) -->
-
-  - [ ] Unit tests
-
-  <!-- Unit tests for each module are required. [Example](https://github.com/open-mmlab/mmsegmentation/blob/main/tests/test_utils/test_io.py#L14) -->
-
-  - [ ] Code polishing
-
-  <!-- Refactor your code according to reviewer's comment. -->
-
-  - [ ] Metafile.yml
-
-  <!-- It will be parsed by MIM and Inferencer. [Example](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn.yml) -->
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-  <!-- In particular, you may have to refactor this README into a standard one. [Example](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/README.md) -->
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/isnet/configs/isnet_r50-d8_8xb2-160k_cityscapes-512x1024.py b/mmsegmentation/projects/isnet/configs/isnet_r50-d8_8xb2-160k_cityscapes-512x1024.py
deleted file mode 100644
index a00d392..0000000
--- a/mmsegmentation/projects/isnet/configs/isnet_r50-d8_8xb2-160k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,80 +0,0 @@
-_base_ = [
-    '../../../configs/_base_/datasets/cityscapes.py',
-    '../../../configs/_base_/default_runtime.py',
-    '../../../configs/_base_/schedules/schedule_80k.py'
-]
-
-data_root = '../../data/cityscapes/'
-train_dataloader = dict(dataset=dict(data_root=data_root))
-val_dataloader = dict(dataset=dict(data_root=data_root))
-test_dataloader = dict(dataset=dict(data_root=data_root))
-
-custom_imports = dict(imports=['projects.isnet.decode_heads'])
-
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    mean=[123.675, 116.28, 103.53],
-    std=[58.395, 57.12, 57.375],
-    bgr_to_rgb=True,
-    pad_val=0,
-    seg_pad_val=255)
-
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    pretrained='open-mmlab://resnet50_v1c',
-    backbone=dict(
-        type='ResNetV1c',
-        depth=50,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        dilations=(1, 1, 2, 4),
-        strides=(1, 2, 1, 1),
-        norm_cfg=norm_cfg,
-        norm_eval=False,
-        style='pytorch',
-        contract_dilation=True),
-    decode_head=dict(
-        type='ISNetHead',
-        in_channels=(256, 512, 1024, 2048),
-        input_transform='multiple_select',
-        in_index=(0, 1, 2, 3),
-        channels=512,
-        dropout_ratio=0.1,
-        transform_channels=256,
-        concat_input=True,
-        with_shortcut=False,
-        shortcut_in_channels=256,
-        shortcut_feat_channels=48,
-        num_classes=19,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        loss_decode=[
-            dict(
-                type='CrossEntropyLoss',
-                use_sigmoid=False,
-                loss_weight=1.0,
-                loss_name='loss_o'),
-            dict(
-                type='CrossEntropyLoss',
-                use_sigmoid=False,
-                loss_weight=0.4,
-                loss_name='loss_d'),
-        ]),
-    auxiliary_head=dict(
-        type='FCNHead',
-        in_channels=1024,
-        in_index=2,
-        channels=512,
-        num_convs=1,
-        concat_input=False,
-        dropout_ratio=0.1,
-        num_classes=19,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-    train_cfg=dict(),
-    # test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513))
-    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/projects/isnet/decode_heads/__init__.py b/mmsegmentation/projects/isnet/decode_heads/__init__.py
deleted file mode 100644
index a451629..0000000
--- a/mmsegmentation/projects/isnet/decode_heads/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-from .isnet_head import ISNetHead
-
-__all__ = ['ISNetHead']
diff --git a/mmsegmentation/projects/isnet/decode_heads/isnet_head.py b/mmsegmentation/projects/isnet/decode_heads/isnet_head.py
deleted file mode 100644
index 9c8df54..0000000
--- a/mmsegmentation/projects/isnet/decode_heads/isnet_head.py
+++ /dev/null
@@ -1,337 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from typing import List
-
-import torch
-import torch.nn as nn
-from mmcv.cnn import ConvModule
-from torch import Tensor
-
-from mmseg.models.decode_heads.decode_head import BaseDecodeHead
-from mmseg.models.losses import accuracy
-from mmseg.models.utils import SelfAttentionBlock, resize
-from mmseg.registry import MODELS
-from mmseg.utils import SampleList
-
-
-class ImageLevelContext(nn.Module):
-    """ Image-Level Context Module
-    Args:
-        feats_channels (int): Input channels of query/key feature.
-        transform_channels (int): Output channels of key/query transform.
-        concat_input (bool): whether to concat input feature.
-        align_corners (bool): align_corners argument of F.interpolate.
-        conv_cfg (dict|None): Config of conv layers.
-        norm_cfg (dict|None): Config of norm layers.
-        act_cfg (dict): Config of activation layers.
-    """
-
-    def __init__(self,
-                 feats_channels,
-                 transform_channels,
-                 concat_input=False,
-                 align_corners=False,
-                 conv_cfg=None,
-                 norm_cfg=None,
-                 act_cfg=None):
-        super().__init__()
-        self.align_corners = align_corners
-        self.global_avgpool = nn.AdaptiveAvgPool2d((1, 1))
-        self.correlate_net = SelfAttentionBlock(
-            key_in_channels=feats_channels * 2,
-            query_in_channels=feats_channels,
-            channels=transform_channels,
-            out_channels=feats_channels,
-            share_key_query=False,
-            query_downsample=None,
-            key_downsample=None,
-            key_query_num_convs=2,
-            value_out_num_convs=1,
-            key_query_norm=True,
-            value_out_norm=True,
-            matmul_norm=True,
-            with_out=True,
-            conv_cfg=conv_cfg,
-            norm_cfg=norm_cfg,
-            act_cfg=act_cfg,
-        )
-        if concat_input:
-            self.bottleneck = ConvModule(
-                feats_channels * 2,
-                feats_channels,
-                kernel_size=3,
-                stride=1,
-                padding=1,
-                conv_cfg=conv_cfg,
-                norm_cfg=norm_cfg,
-                act_cfg=act_cfg,
-            )
-
-    '''forward'''
-
-    def forward(self, x):
-        x_global = self.global_avgpool(x)
-        x_global = resize(
-            x_global,
-            size=x.shape[2:],
-            mode='bilinear',
-            align_corners=self.align_corners)
-        feats_il = self.correlate_net(x, torch.cat([x_global, x], dim=1))
-        if hasattr(self, 'bottleneck'):
-            feats_il = self.bottleneck(torch.cat([x, feats_il], dim=1))
-        return feats_il
-
-
-class SemanticLevelContext(nn.Module):
-    """ Semantic-Level Context Module
-    Args:
-        feats_channels (int): Input channels of query/key feature.
-        transform_channels (int): Output channels of key/query transform.
-        concat_input (bool): whether to concat input feature.
-        conv_cfg (dict|None): Config of conv layers.
-        norm_cfg (dict|None): Config of norm layers.
-        act_cfg (dict): Config of activation layers.
-    """
-
-    def __init__(self,
-                 feats_channels,
-                 transform_channels,
-                 concat_input=False,
-                 conv_cfg=None,
-                 norm_cfg=None,
-                 act_cfg=None):
-        super().__init__()
-        self.correlate_net = SelfAttentionBlock(
-            key_in_channels=feats_channels,
-            query_in_channels=feats_channels,
-            channels=transform_channels,
-            out_channels=feats_channels,
-            share_key_query=False,
-            query_downsample=None,
-            key_downsample=None,
-            key_query_num_convs=2,
-            value_out_num_convs=1,
-            key_query_norm=True,
-            value_out_norm=True,
-            matmul_norm=True,
-            with_out=True,
-            conv_cfg=conv_cfg,
-            norm_cfg=norm_cfg,
-            act_cfg=act_cfg,
-        )
-        if concat_input:
-            self.bottleneck = ConvModule(
-                feats_channels * 2,
-                feats_channels,
-                kernel_size=3,
-                stride=1,
-                padding=1,
-                conv_cfg=conv_cfg,
-                norm_cfg=norm_cfg,
-                act_cfg=act_cfg,
-            )
-
-    '''forward'''
-
-    def forward(self, x, preds, feats_il):
-        inputs = x
-        batch_size, num_channels, h, w = x.size()
-        num_classes = preds.size(1)
-        feats_sl = torch.zeros(batch_size, h * w, num_channels).type_as(x)
-        for batch_idx in range(batch_size):
-            # (C, H, W), (num_classes, H, W) --> (H*W, C), (H*W, num_classes)
-            feats_iter, preds_iter = x[batch_idx], preds[batch_idx]
-            feats_iter, preds_iter = feats_iter.reshape(
-                num_channels, -1), preds_iter.reshape(num_classes, -1)
-            feats_iter, preds_iter = feats_iter.permute(1,
-                                                        0), preds_iter.permute(
-                                                            1, 0)
-            # (H*W, )
-            argmax = preds_iter.argmax(1)
-            for clsid in range(num_classes):
-                mask = (argmax == clsid)
-                if mask.sum() == 0:
-                    continue
-                feats_iter_cls = feats_iter[mask]
-                preds_iter_cls = preds_iter[:, clsid][mask]
-                weight = torch.softmax(preds_iter_cls, dim=0)
-                feats_iter_cls = feats_iter_cls * weight.unsqueeze(-1)
-                feats_iter_cls = feats_iter_cls.sum(0)
-                feats_sl[batch_idx][mask] = feats_iter_cls
-        feats_sl = feats_sl.reshape(batch_size, h, w, num_channels)
-        feats_sl = feats_sl.permute(0, 3, 1, 2).contiguous()
-        feats_sl = self.correlate_net(inputs, feats_sl)
-        if hasattr(self, 'bottleneck'):
-            feats_sl = self.bottleneck(torch.cat([feats_il, feats_sl], dim=1))
-        return feats_sl
-
-
-@MODELS.register_module()
-class ISNetHead(BaseDecodeHead):
-    """ISNet: Integrate Image-Level and Semantic-Level
-    Context for Semantic Segmentation
-
-    This head is the implementation of `ISNet`
-    <https://arxiv.org/pdf/2108.12382.pdf>`_.
-
-    Args:
-        transform_channels (int): Output channels of key/query transform.
-        concat_input (bool): whether to concat input feature.
-        with_shortcut (bool): whether to use shortcut connection.
-        shortcut_in_channels (int): Input channels of shortcut.
-        shortcut_feat_channels (int): Output channels of shortcut.
-        dropout_ratio (float): Ratio of dropout.
-    """
-
-    def __init__(self, transform_channels, concat_input, with_shortcut,
-                 shortcut_in_channels, shortcut_feat_channels, dropout_ratio,
-                 **kwargs):
-        super().__init__(**kwargs)
-
-        self.in_channels = self.in_channels[-1]
-
-        self.bottleneck = ConvModule(
-            self.in_channels,
-            self.channels,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            conv_cfg=self.conv_cfg,
-            norm_cfg=self.norm_cfg,
-            act_cfg=self.act_cfg)
-
-        self.ilc_net = ImageLevelContext(
-            feats_channels=self.channels,
-            transform_channels=transform_channels,
-            concat_input=concat_input,
-            norm_cfg=self.norm_cfg,
-            act_cfg=self.act_cfg,
-            align_corners=self.align_corners)
-        self.slc_net = SemanticLevelContext(
-            feats_channels=self.channels,
-            transform_channels=transform_channels,
-            concat_input=concat_input,
-            norm_cfg=self.norm_cfg,
-            act_cfg=self.act_cfg)
-
-        self.decoder_stage1 = nn.Sequential(
-            ConvModule(
-                self.channels,
-                self.channels,
-                kernel_size=1,
-                stride=1,
-                padding=0,
-                conv_cfg=self.conv_cfg,
-                norm_cfg=self.norm_cfg,
-                act_cfg=self.act_cfg),
-            nn.Dropout2d(dropout_ratio),
-            nn.Conv2d(
-                self.channels,
-                self.num_classes,
-                kernel_size=1,
-                stride=1,
-                padding=0,
-                bias=True),
-        )
-
-        if with_shortcut:
-            self.shortcut = ConvModule(
-                shortcut_in_channels,
-                shortcut_feat_channels,
-                kernel_size=1,
-                stride=1,
-                padding=0,
-                conv_cfg=self.conv_cfg,
-                norm_cfg=self.norm_cfg,
-                act_cfg=self.act_cfg)
-            self.decoder_stage2 = nn.Sequential(
-                ConvModule(
-                    self.channels + shortcut_feat_channels,
-                    self.channels,
-                    kernel_size=3,
-                    stride=1,
-                    padding=1,
-                    conv_cfg=self.conv_cfg,
-                    norm_cfg=self.norm_cfg,
-                    act_cfg=self.act_cfg),
-                nn.Dropout2d(dropout_ratio),
-                nn.Conv2d(
-                    self.channels,
-                    self.num_classes,
-                    kernel_size=1,
-                    stride=1,
-                    padding=0,
-                    bias=True),
-            )
-        else:
-            self.decoder_stage2 = nn.Sequential(
-                nn.Dropout2d(dropout_ratio),
-                nn.Conv2d(
-                    self.channels,
-                    self.num_classes,
-                    kernel_size=1,
-                    stride=1,
-                    padding=0,
-                    bias=True),
-            )
-
-        self.conv_seg = None
-        self.dropout = None
-
-    def forward(self, inputs):
-        x = self._transform_inputs(inputs)
-        feats = self.bottleneck(x[-1])
-
-        feats_il = self.ilc_net(feats)
-
-        preds_stage1 = self.decoder_stage1(feats)
-        preds_stage1 = resize(
-            preds_stage1,
-            size=feats.size()[2:],
-            mode='bilinear',
-            align_corners=self.align_corners)
-
-        feats_sl = self.slc_net(feats, preds_stage1, feats_il)
-
-        if hasattr(self, 'shortcut'):
-            shortcut_out = self.shortcut(x[0])
-            feats_sl = resize(
-                feats_sl,
-                size=shortcut_out.shape[2:],
-                mode='bilinear',
-                align_corners=self.align_corners)
-            feats_sl = torch.cat([feats_sl, shortcut_out], dim=1)
-        preds_stage2 = self.decoder_stage2(feats_sl)
-
-        return preds_stage1, preds_stage2
-
-    def loss_by_feat(self, seg_logits: Tensor,
-                     batch_data_samples: SampleList) -> dict:
-        seg_label = self._stack_batch_gt(batch_data_samples)
-        loss = dict()
-
-        if self.sampler is not None:
-            seg_weight = self.sampler.sample(seg_logits[-1], seg_label)
-        else:
-            seg_weight = None
-        seg_label = seg_label.squeeze(1)
-
-        for seg_logit, loss_decode in zip(seg_logits, self.loss_decode):
-            seg_logit = resize(
-                input=seg_logit,
-                size=seg_label.shape[2:],
-                mode='bilinear',
-                align_corners=self.align_corners)
-            loss[loss_decode.name] = loss_decode(
-                seg_logit,
-                seg_label,
-                seg_weight,
-                ignore_index=self.ignore_index)
-
-        loss['acc_seg'] = accuracy(
-            seg_logits[-1], seg_label, ignore_index=self.ignore_index)
-        return loss
-
-    def predict_by_feat(self, seg_logits: Tensor,
-                        batch_img_metas: List[dict]) -> Tensor:
-        _, seg_logits_stage2 = seg_logits
-        return super().predict_by_feat(seg_logits_stage2, batch_img_metas)
diff --git a/mmsegmentation/projects/mapillary_dataset/README.md b/mmsegmentation/projects/mapillary_dataset/README.md
deleted file mode 100644
index 44a1e33..0000000
--- a/mmsegmentation/projects/mapillary_dataset/README.md
+++ /dev/null
@@ -1,86 +0,0 @@
-# Mapillary Vistas Dataset
-
-Support **`Mapillary Vistas Dataset`**
-
-## Description
-
-Author: AI-Tianlong
-
-This project implements **`Mapillary Vistas Dataset`**
-
-### Dataset preparing
-
-Preparing `Mapillary Vistas Dataset` dataset following [Mapillary Vistas Dataset Preparing Guide](https://github.com/open-mmlab/mmsegmentation/tree/main/projects/mapillary_dataset/docs/en/user_guides/2_dataset_prepare.md)
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── tools
-  ├── configs
-  ├── data
-  │   ├── mapillary
-  │   │   ├── training
-  │   │   │   ├── images
-  │   │   │   ├── v1.2
-  |   │   │   │   ├── instances
-  |   │   │   │   ├── labels
-  |   │   │   │   ├── labels_mask
-  |   │   │   │   └── panoptic
-  │   │   │   ├── v2.0
-  |   │   │   │   ├── instances
-  |   │   │   │   ├── labels
-  |   │   │   │   ├── labels_mask
-  |   │   │   │   ├── panoptic
-  |   │   │   │   └── polygons
-  │   │   ├── validation
-  │   │   │   ├── images
-  │   │   │   ├── v1.2
-  |   │   │   │   ├── instances
-  |   │   │   │   ├── labels
-  |   │   │   │   ├── labels_mask
-  |   │   │   │   └── panoptic
-  │   │   │   ├── v2.0
-  |   │   │   │   ├── instances
-  |   │   │   │   ├── labels
-  |   │   │   │   ├── labels_mask
-  |   │   │   │   ├── panoptic
-  |   │   │   │   └── polygons
-```
-
-### Training commands
-
-```bash
-# Dataset train commands
-# at `mmsegmentation` folder
-bash tools/dist_train.sh projects/mapillary_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_mapillay_v1-512x1024.py 4
-```
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-
-  - [x] Basic docstrings & proper citation
-
-  - [ ] Test-time correctness
-
-  - [x] A full README
-
-- [x] Milestone 2: Indicates a successful model implementation.
-
-  - [x] Training-time correctness
-
-- [x] Milestone 3: Good to be a part of our core package!
-
-  - [x] Type hints and docstrings
-
-  - [x] Unit tests
-
-  - [x] Code polishing
-
-  - [x] Metafile.yml
-
-- [x] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [x] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v1.py b/mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v1.py
deleted file mode 100644
index 611aa47..0000000
--- a/mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v1.py
+++ /dev/null
@@ -1,68 +0,0 @@
-# dataset settings
-dataset_type = 'MapillaryDataset_v1'
-data_root = 'data/mapillary/'
-crop_size = (512, 1024)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(
-        type='RandomResize',
-        scale=(2048, 1024),
-        ratio_range=(0.5, 2.0),
-        keep_ratio=True),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
-tta_pipeline = [
-    dict(type='LoadImageFromFile', file_client_args=dict(backend='disk')),
-    dict(
-        type='TestTimeAug',
-        transforms=[
-            [
-                dict(type='Resize', scale_factor=r, keep_ratio=True)
-                for r in img_ratios
-            ],
-            [
-                dict(type='RandomFlip', prob=0., direction='horizontal'),
-                dict(type='RandomFlip', prob=1., direction='horizontal')
-            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
-        ])
-]
-train_dataloader = dict(
-    batch_size=2,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='training/images', seg_map_path='training/v1.2/labels'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='validation/images',
-            seg_map_path='validation/v1.2/labels'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
-test_evaluator = val_evaluator
diff --git a/mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v1_65.py b/mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v1_65.py
deleted file mode 100644
index f594f37..0000000
--- a/mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v1_65.py
+++ /dev/null
@@ -1,37 +0,0 @@
-# dataset settings
-_base_ = './mapillary_v1.py'
-metainfo = dict(
-    classes=('Bird', 'Ground Animal', 'Curb', 'Fence', 'Guard Rail', 'Barrier',
-             'Wall', 'Bike Lane', 'Crosswalk - Plain', 'Curb Cut', 'Parking',
-             'Pedestrian Area', 'Rail Track', 'Road', 'Service Lane',
-             'Sidewalk', 'Bridge', 'Building', 'Tunnel', 'Person', 'Bicyclist',
-             'Motorcyclist', 'Other Rider', 'Lane Marking - Crosswalk',
-             'Lane Marking - General', 'Mountain', 'Sand', 'Sky', 'Snow',
-             'Terrain', 'Vegetation', 'Water', 'Banner', 'Bench', 'Bike Rack',
-             'Billboard', 'Catch Basin', 'CCTV Camera', 'Fire Hydrant',
-             'Junction Box', 'Mailbox', 'Manhole', 'Phone Booth', 'Pothole',
-             'Street Light', 'Pole', 'Traffic Sign Frame', 'Utility Pole',
-             'Traffic Light', 'Traffic Sign (Back)', 'Traffic Sign (Front)',
-             'Trash Can', 'Bicycle', 'Boat', 'Bus', 'Car', 'Caravan',
-             'Motorcycle', 'On Rails', 'Other Vehicle', 'Trailer', 'Truck',
-             'Wheeled Slow', 'Car Mount', 'Ego Vehicle'),
-    palette=[[165, 42, 42], [0, 192, 0], [196, 196, 196], [190, 153, 153],
-             [180, 165, 180], [90, 120, 150], [102, 102, 156], [128, 64, 255],
-             [140, 140, 200], [170, 170, 170], [250, 170, 160], [96, 96, 96],
-             [230, 150, 140], [128, 64, 128], [110, 110, 110], [244, 35, 232],
-             [150, 100, 100], [70, 70, 70], [150, 120, 90], [220, 20, 60],
-             [255, 0, 0], [255, 0, 100], [255, 0, 200], [200, 128, 128],
-             [255, 255, 255], [64, 170, 64], [230, 160, 50], [70, 130, 180],
-             [190, 255, 255], [152, 251, 152], [107, 142, 35], [0, 170, 30],
-             [255, 255, 128], [250, 0, 30], [100, 140, 180], [220, 220, 220],
-             [220, 128, 128], [222, 40, 40], [100, 170, 30], [40, 40, 40],
-             [33, 33, 33], [100, 128, 160], [142, 0, 0], [70, 100, 150],
-             [210, 170, 100], [153, 153, 153], [128, 128, 128], [0, 0, 80],
-             [250, 170, 30], [192, 192, 192], [220, 220, 0], [140, 140, 20],
-             [119, 11, 32], [150, 0, 255], [0, 60, 100], [0, 0, 142],
-             [0, 0, 90], [0, 0, 230], [0, 80, 100], [128, 64, 64], [0, 0, 110],
-             [0, 0, 70], [0, 0, 192], [32, 32, 32], [120, 10, 10]])
-
-train_dataloader = dict(dataset=dict(metainfo=metainfo))
-val_dataloader = dict(dataset=dict(metainfo=metainfo))
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v2.py b/mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v2.py
deleted file mode 100644
index 7cb7a95..0000000
--- a/mmsegmentation/projects/mapillary_dataset/configs/_base_/datasets/mapillary_v2.py
+++ /dev/null
@@ -1,68 +0,0 @@
-# dataset settings
-dataset_type = 'MapillaryDataset_v2'
-data_root = 'data/mapillary/'
-crop_size = (512, 1024)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(
-        type='RandomResize',
-        scale=(2048, 1024),
-        ratio_range=(0.5, 2.0),
-        keep_ratio=True),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
-tta_pipeline = [
-    dict(type='LoadImageFromFile', file_client_args=dict(backend='disk')),
-    dict(
-        type='TestTimeAug',
-        transforms=[
-            [
-                dict(type='Resize', scale_factor=r, keep_ratio=True)
-                for r in img_ratios
-            ],
-            [
-                dict(type='RandomFlip', prob=0., direction='horizontal'),
-                dict(type='RandomFlip', prob=1., direction='horizontal')
-            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
-        ])
-]
-train_dataloader = dict(
-    batch_size=2,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='training/images', seg_map_path='training/v2.0/labels'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='validation/images',
-            seg_map_path='validation/v2.0/labels'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
-test_evaluator = val_evaluator
diff --git a/mmsegmentation/projects/mapillary_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_mapillay_v1-512x1024.py b/mmsegmentation/projects/mapillary_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_mapillay_v1-512x1024.py
deleted file mode 100644
index b559e0d..0000000
--- a/mmsegmentation/projects/mapillary_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_mapillay_v1-512x1024.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    '../../../configs/_base_/models/deeplabv3plus_r50-d8.py',
-    './_base_/datasets/mapillary_v1.py',
-    '../../../configs/_base_/default_runtime.py',
-    '../../../configs/_base_/schedules/schedule_240k.py'
-]
-custom_imports = dict(
-    imports=['projects.mapillary_dataset.mmseg.datasets.mapillary'])
-
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained='open-mmlab://resnet101_v1c',
-    backbone=dict(depth=101),
-    decode_head=dict(num_classes=66),
-    auxiliary_head=dict(num_classes=66))
diff --git a/mmsegmentation/projects/mapillary_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_mapillay_v2-512x1024.py b/mmsegmentation/projects/mapillary_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_mapillay_v2-512x1024.py
deleted file mode 100644
index cfe31a2..0000000
--- a/mmsegmentation/projects/mapillary_dataset/configs/deeplabv3plus_r101-d8_4xb2-240k_mapillay_v2-512x1024.py
+++ /dev/null
@@ -1,16 +0,0 @@
-_base_ = [
-    '../../../configs/_base_/models/deeplabv3plus_r50-d8.py',
-    './_base_/datasets/mapillary_v2.py',
-    '../../../configs/_base_/default_runtime.py',
-    '../../../configs/_base_/schedules/schedule_240k.py'
-]
-custom_imports = dict(
-    imports=['projects.mapillary_dataset.mmseg.datasets.mapillary'])
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained='open-mmlab://resnet101_v1c',
-    backbone=dict(depth=101),
-    decode_head=dict(num_classes=124),
-    auxiliary_head=dict(num_classes=124))
diff --git a/mmsegmentation/projects/mapillary_dataset/configs/pspnet_r101-d8_4xb2-240k_mapillay_v1-512x1024.py b/mmsegmentation/projects/mapillary_dataset/configs/pspnet_r101-d8_4xb2-240k_mapillay_v1-512x1024.py
deleted file mode 100644
index 1ca2b57..0000000
--- a/mmsegmentation/projects/mapillary_dataset/configs/pspnet_r101-d8_4xb2-240k_mapillay_v1-512x1024.py
+++ /dev/null
@@ -1,16 +0,0 @@
-_base_ = [
-    '../../../configs/_base_/models/pspnet_r50-d8.py',
-    './_base_/datasets/mapillary_v1.py',
-    '../../../configs/_base_/default_runtime.py',
-    '../../../configs/_base_/schedules/schedule_240k.py'
-]
-custom_imports = dict(
-    imports=['projects.mapillary_dataset.mmseg.datasets.mapillary'])
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained='open-mmlab://resnet101_v1c',
-    backbone=dict(depth=101),
-    decode_head=dict(num_classes=66),
-    auxiliary_head=dict(num_classes=66))
diff --git a/mmsegmentation/projects/mapillary_dataset/configs/pspnet_r101-d8_4xb2-240k_mapillay_v2-512x1024.py b/mmsegmentation/projects/mapillary_dataset/configs/pspnet_r101-d8_4xb2-240k_mapillay_v2-512x1024.py
deleted file mode 100644
index c04746a..0000000
--- a/mmsegmentation/projects/mapillary_dataset/configs/pspnet_r101-d8_4xb2-240k_mapillay_v2-512x1024.py
+++ /dev/null
@@ -1,16 +0,0 @@
-_base_ = [
-    '../../../configs/_base_/models/pspnet_r50-d8.py',
-    './_base_/datasets/mapillary_v2.py',
-    '../../../configs/_base_/default_runtime.py',
-    '../../../configs/_base_/schedules/schedule_240k.py'
-]
-custom_imports = dict(
-    imports=['projects.mapillary_dataset.mmseg.datasets.mapillary'])
-crop_size = (512, 1024)
-data_preprocessor = dict(size=crop_size)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    pretrained='open-mmlab://resnet101_v1c',
-    backbone=dict(depth=101),
-    decode_head=dict(num_classes=124),
-    auxiliary_head=dict(num_classes=124))
diff --git a/mmsegmentation/projects/mapillary_dataset/docs/en/user_guides/2_dataset_prepare.md b/mmsegmentation/projects/mapillary_dataset/docs/en/user_guides/2_dataset_prepare.md
deleted file mode 100644
index c5cbc0f..0000000
--- a/mmsegmentation/projects/mapillary_dataset/docs/en/user_guides/2_dataset_prepare.md
+++ /dev/null
@@ -1,255 +0,0 @@
-## Mapillary Vistas Datasets
-
-- The dataset could be download [here](https://www.mapillary.com/dataset/vistas) after registration.
-
-- Mapillary Vistas Dataset use 8-bit with color-palette to store labels. No conversion operation is required.
-
-- Assumption you have put the dataset zip file in `mmsegmentation/data/mapillary`
-
-- Please run the following commands to unzip dataset.
-
-  ```bash
-  cd data/mapillary
-  unzip An-ZjB1Zm61yAZG0ozTymz8I8NqI4x0MrYrh26dq7kPgfu8vf9ImrdaOAVOFYbJ2pNAgUnVGBmbue9lTgdBOb5BbKXIpFs0fpYWqACbrQDChAA2fdX0zS9PcHu7fY8c-FOvyBVxPNYNFQuM.zip
-  ```
-
-- After unzip, you will get Mapillary Vistas Dataset like this structure. Semantic segmentation mask labels in `labels` folder.
-
-  ```none
-  mmsegmentation
-  ├── mmseg
-  ├── tools
-  ├── configs
-  ├── data
-  │   ├── mapillary
-  │   │   ├── training
-  │   │   │   ├── images
-  │   │   │   ├── v1.2
-  |   │   │   │   ├── instances
-  |   │   │   │   ├── labels
-  |   │   │   │   └── panoptic
-  │   │   │   ├── v2.0
-  |   │   │   │   ├── instances
-  |   │   │   │   ├── labels
-  |   │   │   │   ├── panoptic
-  |   │   │   │   └── polygons
-  │   │   ├── validation
-  │   │   │   ├── images
-  |   │   │   ├── v1.2
-  |   │   │   │   ├── instances
-  |   │   │   │   ├── labels
-  |   │   │   │   └── panoptic
-  │   │   │   ├── v2.0
-  |   │   │   │   ├── instances
-  |   │   │   │   ├── labels
-  |   │   │   │   ├── panoptic
-  |   │   │   │   └── polygons
-  ```
-
-- You could set Datasets version with `MapillaryDataset_v1` and `MapillaryDataset_v2` in your configs.
-  View the Mapillary Vistas Datasets config file here [V1.2](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/_base_/datasets/mapillary_v1.py) and  [V2.0](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/_base_/datasets/mapillary_v2.py)
-
-- **View datasets labels index and palette**
-
-- **Mapillary Vistas Datasets labels information**
-  **v1.2 information**
-
-  ```none
-  There are 66 labels classes in v1.2
-  0--Bird--[165, 42, 42],
-  1--Ground Animal--[0, 192, 0],
-  2--Curb--[196, 196, 196],
-  3--Fence--[190, 153, 153],
-  4--Guard Rail--[180, 165, 180],
-  5--Barrier--[90, 120, 150],
-  6--Wall--[102, 102, 156],
-  7--Bike Lane--[128, 64, 255],
-  8--Crosswalk - Plain--[140, 140, 200],
-  9--Curb Cut--[170, 170, 170],
-  10--Parking--[250, 170, 160],
-  11--Pedestrian Area--[96, 96, 96],
-  12--Rail Track--[230, 150, 140],
-  13--Road--[128, 64, 128],
-  14--Service Lane--[110, 110, 110],
-  15--Sidewalk--[244, 35, 232],
-  16--Bridge--[150, 100, 100],
-  17--Building--[70, 70, 70],
-  18--Tunnel--[150, 120, 90],
-  19--Person--[220, 20, 60],
-  20--Bicyclist--[255, 0, 0],
-  21--Motorcyclist--[255, 0, 100],
-  22--Other Rider--[255, 0, 200],
-  23--Lane Marking - Crosswalk--[200, 128, 128],
-  24--Lane Marking - General--[255, 255, 255],
-  25--Mountain--[64, 170, 64],
-  26--Sand--[230, 160, 50],
-  27--Sky--[70, 130, 180],
-  28--Snow--[190, 255, 255],
-  29--Terrain--[152, 251, 152],
-  30--Vegetation--[107, 142, 35],
-  31--Water--[0, 170, 30],
-  32--Banner--[255, 255, 128],
-  33--Bench--[250, 0, 30],
-  34--Bike Rack--[100, 140, 180],
-  35--Billboard--[220, 220, 220],
-  36--Catch Basin--[220, 128, 128],
-  37--CCTV Camera--[222, 40, 40],
-  38--Fire Hydrant--[100, 170, 30],
-  39--Junction Box--[40, 40, 40],
-  40--Mailbox--[33, 33, 33],
-  41--Manhole--[100, 128, 160],
-  42--Phone Booth--[142, 0, 0],
-  43--Pothole--[70, 100, 150],
-  44--Street Light--[210, 170, 100],
-  45--Pole--[153, 153, 153],
-  46--Traffic Sign Frame--[128, 128, 128],
-  47--Utility Pole--[0, 0, 80],
-  48--Traffic Light--[250, 170, 30],
-  49--Traffic Sign (Back)--[192, 192, 192],
-  50--Traffic Sign (Front)--[220, 220, 0],
-  51--Trash Can--[140, 140, 20],
-  52--Bicycle--[119, 11, 32],
-  53--Boat--[150, 0, 255],
-  54--Bus--[0, 60, 100],
-  55--Car--[0, 0, 142],
-  56--Caravan--[0, 0, 90],
-  57--Motorcycle--[0, 0, 230],
-  58--On Rails--[0, 80, 100],
-  59--Other Vehicle--[128, 64, 64],
-  60--Trailer--[0, 0, 110],
-  61--Truck--[0, 0, 70],
-  62--Wheeled Slow--[0, 0, 192],
-  63--Car Mount--[32, 32, 32],
-  64--Ego Vehicle--[120, 10, 10],
-  65--Unlabeled--[0, 0, 0]
-  ```
-
-  **v2.0 information**
-
-  ```none
-  There are 124 labels classes in v2.0
-  0--Bird--[165, 42, 42],
-  1--Ground Animal--[0, 192, 0],
-  2--Ambiguous Barrier--[250, 170, 31],
-  3--Concrete Block--[250, 170, 32],
-  4--Curb--[196, 196, 196],
-  5--Fence--[190, 153, 153],
-  6--Guard Rail--[180, 165, 180],
-  7--Barrier--[90, 120, 150],
-  8--Road Median--[250, 170, 33],
-  9--Road Side--[250, 170, 34],
-  10--Lane Separator--[128, 128, 128],
-  11--Temporary Barrier--[250, 170, 35],
-  12--Wall--[102, 102, 156],
-  13--Bike Lane--[128, 64, 255],
-  14--Crosswalk - Plain--[140, 140, 200],
-  15--Curb Cut--[170, 170, 170],
-  16--Driveway--[250, 170, 36],
-  17--Parking--[250, 170, 160],
-  18--Parking Aisle--[250, 170, 37],
-  19--Pedestrian Area--[96, 96, 96],
-  20--Rail Track--[230, 150, 140],
-  21--Road--[128, 64, 128],
-  22--Road Shoulder--[110, 110, 110],
-  23--Service Lane--[110, 110, 110],
-  24--Sidewalk--[244, 35, 232],
-  25--Traffic Island--[128, 196, 128],
-  26--Bridge--[150, 100, 100],
-  27--Building--[70, 70, 70],
-  28--Garage--[150, 150, 150],
-  29--Tunnel--[150, 120, 90],
-  30--Person--[220, 20, 60],
-  31--Person Group--[220, 20, 60],
-  32--Bicyclist--[255, 0, 0],
-  33--Motorcyclist--[255, 0, 100],
-  34--Other Rider--[255, 0, 200],
-  35--Lane Marking - Dashed Line--[255, 255, 255],
-  36--Lane Marking - Straight Line--[255, 255, 255],
-  37--Lane Marking - Zigzag Line--[250, 170, 29],
-  38--Lane Marking - Ambiguous--[250, 170, 28],
-  39--Lane Marking - Arrow (Left)--[250, 170, 26],
-  40--Lane Marking - Arrow (Other)--[250, 170, 25],
-  41--Lane Marking - Arrow (Right)--[250, 170, 24],
-  42--Lane Marking - Arrow (Split Left or Straight)--[250, 170, 22],
-  43--Lane Marking - Arrow (Split Right or Straight)--[250, 170, 21],
-  44--Lane Marking - Arrow (Straight)--[250, 170, 20],
-  45--Lane Marking - Crosswalk--[255, 255, 255],
-  46--Lane Marking - Give Way (Row)--[250, 170, 19],
-  47--Lane Marking - Give Way (Single)--[250, 170, 18],
-  48--Lane Marking - Hatched (Chevron)--[250, 170, 12],
-  49--Lane Marking - Hatched (Diagonal)--[250, 170, 11],
-  50--Lane Marking - Other--[255, 255, 255],
-  51--Lane Marking - Stop Line--[255, 255, 255],
-  52--Lane Marking - Symbol (Bicycle)--[250, 170, 16],
-  53--Lane Marking - Symbol (Other)--[250, 170, 15],
-  54--Lane Marking - Text--[250, 170, 15],
-  55--Lane Marking (only) - Dashed Line--[255, 255, 255],
-  56--Lane Marking (only) - Crosswalk--[255, 255, 255],
-  57--Lane Marking (only) - Other--[255, 255, 255],
-  58--Lane Marking (only) - Test--[255, 255, 255],
-  59--Mountain--[64, 170, 64],
-  60--Sand--[230, 160, 50],
-  61--Sky--[70, 130, 180],
-  62--Snow--[190, 255, 255],
-  63--Terrain--[152, 251, 152],
-  64--Vegetation--[107, 142, 35],
-  65--Water--[0, 170, 30],
-  66--Banner--[255, 255, 128],
-  67--Bench--[250, 0, 30],
-  68--Bike Rack--[100, 140, 180],
-  69--Catch Basin--[220, 128, 128],
-  70--CCTV Camera--[222, 40, 40],
-  71--Fire Hydrant--[100, 170, 30],
-  72--Junction Box--[40, 40, 40],
-  73--Mailbox--[33, 33, 33],
-  74--Manhole--[100, 128, 160],
-  75--Parking Meter--[20, 20, 255],
-  76--Phone Booth--[142, 0, 0],
-  77--Pothole--[70, 100, 150],
-  78--Signage - Advertisement--[250, 171, 30],
-  79--Signage - Ambiguous--[250, 172, 30],
-  80--Signage - Back--[250, 173, 30],
-  81--Signage - Information--[250, 174, 30],
-  82--Signage - Other--[250, 175, 30],
-  83--Signage - Store--[250, 176, 30],
-  84--Street Light--[210, 170, 100],
-  85--Pole--[153, 153, 153],
-  86--Pole Group--[153, 153, 153],
-  87--Traffic Sign Frame--[128, 128, 128],
-  88--Utility Pole--[0, 0, 80],
-  89--Traffic Cone--[210, 60, 60],
-  90--Traffic Light - General (Single)--[250, 170, 30],
-  91--Traffic Light - Pedestrians--[250, 170, 30],
-  92--Traffic Light - General (Upright)--[250, 170, 30],
-  93--Traffic Light - General (Horizontal)--[250, 170, 30],
-  94--Traffic Light - Cyclists--[250, 170, 30],
-  95--Traffic Light - Other--[250, 170, 30],
-  96--Traffic Sign - Ambiguous--[192, 192, 192],
-  97--Traffic Sign (Back)--[192, 192, 192],
-  98--Traffic Sign - Direction (Back)--[192, 192, 192],
-  99--Traffic Sign - Direction (Front)--[220, 220, 0],
-  100--Traffic Sign (Front)--[220, 220, 0],
-  101--Traffic Sign - Parking--[0, 0, 196],
-  102--Traffic Sign - Temporary (Back)--[192, 192, 192],
-  103--Traffic Sign - Temporary (Front)--[220, 220, 0],
-  104--Trash Can--[140, 140, 20],
-  105--Bicycle--[119, 11, 32],
-  106--Boat--[150, 0, 255],
-  107--Bus--[0, 60, 100],
-  108--Car--[0, 0, 142],
-  109--Caravan--[0, 0, 90],
-  110--Motorcycle--[0, 0, 230],
-  111--On Rails--[0, 80, 100],
-  112--Other Vehicle--[128, 64, 64],
-  113--Trailer--[0, 0, 110],
-  114--Truck--[0, 0, 70],
-  115--Vehicle Group--[0, 0, 142],
-  116--Wheeled Slow--[0, 0, 192],
-  117--Water Valve--[170, 170, 170],
-  118--Car Mount--[32, 32, 32],
-  119--Dynamic--[111, 74, 0],
-  120--Ego Vehicle--[120, 10, 10],
-  121--Ground--[81, 0, 81],
-  122--Static--[111, 111, 0],
-  123--Unlabeled--[0, 0, 0]
-  ```
diff --git a/mmsegmentation/projects/mapillary_dataset/mmseg/datasets/mapillary.py b/mmsegmentation/projects/mapillary_dataset/mmseg/datasets/mapillary.py
deleted file mode 100644
index f49bd54..0000000
--- a/mmsegmentation/projects/mapillary_dataset/mmseg/datasets/mapillary.py
+++ /dev/null
@@ -1,177 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmseg.datasets.basesegdataset import BaseSegDataset
-
-# from mmseg.registry import DATASETS
-
-
-# @DATASETS.register_module()
-class MapillaryDataset_v1(BaseSegDataset):
-    """Mapillary Vistas Dataset.
-
-    Dataset paper link:
-    http://ieeexplore.ieee.org/document/8237796/
-
-    v1.2 contain 66 object classes.
-    (37 instance-specific)
-
-    v2.0 contain 124 object classes.
-    (70 instance-specific, 46 stuff, 8 void or crowd).
-
-    The ``img_suffix`` is fixed to '.jpg' and ``seg_map_suffix`` is
-    fixed to '.png' for Mapillary Vistas Dataset.
-    """
-    METAINFO = dict(
-        classes=('Bird', 'Ground Animal', 'Curb', 'Fence', 'Guard Rail',
-                 'Barrier', 'Wall', 'Bike Lane', 'Crosswalk - Plain',
-                 'Curb Cut', 'Parking', 'Pedestrian Area', 'Rail Track',
-                 'Road', 'Service Lane', 'Sidewalk', 'Bridge', 'Building',
-                 'Tunnel', 'Person', 'Bicyclist', 'Motorcyclist',
-                 'Other Rider', 'Lane Marking - Crosswalk',
-                 'Lane Marking - General', 'Mountain', 'Sand', 'Sky', 'Snow',
-                 'Terrain', 'Vegetation', 'Water', 'Banner', 'Bench',
-                 'Bike Rack', 'Billboard', 'Catch Basin', 'CCTV Camera',
-                 'Fire Hydrant', 'Junction Box', 'Mailbox', 'Manhole',
-                 'Phone Booth', 'Pothole', 'Street Light', 'Pole',
-                 'Traffic Sign Frame', 'Utility Pole', 'Traffic Light',
-                 'Traffic Sign (Back)', 'Traffic Sign (Front)', 'Trash Can',
-                 'Bicycle', 'Boat', 'Bus', 'Car', 'Caravan', 'Motorcycle',
-                 'On Rails', 'Other Vehicle', 'Trailer', 'Truck',
-                 'Wheeled Slow', 'Car Mount', 'Ego Vehicle', 'Unlabeled'),
-        palette=[[165, 42, 42], [0, 192, 0], [196, 196, 196], [190, 153, 153],
-                 [180, 165, 180], [90, 120, 150], [102, 102, 156],
-                 [128, 64, 255], [140, 140, 200], [170, 170, 170],
-                 [250, 170, 160], [96, 96, 96],
-                 [230, 150, 140], [128, 64, 128], [110, 110, 110],
-                 [244, 35, 232], [150, 100, 100], [70, 70, 70], [150, 120, 90],
-                 [220, 20, 60], [255, 0, 0], [255, 0, 100], [255, 0, 200],
-                 [200, 128, 128], [255, 255, 255], [64, 170,
-                                                    64], [230, 160, 50],
-                 [70, 130, 180], [190, 255, 255], [152, 251, 152],
-                 [107, 142, 35], [0, 170, 30], [255, 255, 128], [250, 0, 30],
-                 [100, 140, 180], [220, 220, 220], [220, 128, 128],
-                 [222, 40, 40], [100, 170, 30], [40, 40, 40], [33, 33, 33],
-                 [100, 128, 160], [142, 0, 0], [70, 100, 150], [210, 170, 100],
-                 [153, 153, 153], [128, 128, 128], [0, 0, 80], [250, 170, 30],
-                 [192, 192, 192], [220, 220, 0], [140, 140, 20], [119, 11, 32],
-                 [150, 0, 255], [0, 60, 100], [0, 0, 142], [0, 0, 90],
-                 [0, 0, 230], [0, 80, 100], [128, 64, 64], [0, 0, 110],
-                 [0, 0, 70], [0, 0, 192], [32, 32, 32], [120, 10,
-                                                         10], [0, 0, 0]])
-
-    def __init__(self,
-                 img_suffix='.jpg',
-                 seg_map_suffix='.png',
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
-
-
-# @DATASETS.register_module()
-class MapillaryDataset_v2(BaseSegDataset):
-    """Mapillary Vistas Dataset.
-
-    Dataset paper link:
-    http://ieeexplore.ieee.org/document/8237796/
-
-    v1.2 contain 66 object classes.
-    (37 instance-specific)
-
-    v2.0 contain 124 object classes.
-    (70 instance-specific, 46 stuff, 8 void or crowd).
-
-    The ``img_suffix`` is fixed to '.jpg' and ``seg_map_suffix`` is
-    fixed to '.png' for Mapillary Vistas Dataset.
-    """
-    METAINFO = dict(
-        classes=(
-            'Bird', 'Ground Animal', 'Ambiguous Barrier', 'Concrete Block',
-            'Curb', 'Fence', 'Guard Rail', 'Barrier', 'Road Median',
-            'Road Side', 'Lane Separator', 'Temporary Barrier', 'Wall',
-            'Bike Lane', 'Crosswalk - Plain', 'Curb Cut', 'Driveway',
-            'Parking', 'Parking Aisle', 'Pedestrian Area', 'Rail Track',
-            'Road', 'Road Shoulder', 'Service Lane', 'Sidewalk',
-            'Traffic Island', 'Bridge', 'Building', 'Garage', 'Tunnel',
-            'Person', 'Person Group', 'Bicyclist', 'Motorcyclist',
-            'Other Rider', 'Lane Marking - Dashed Line',
-            'Lane Marking - Straight Line', 'Lane Marking - Zigzag Line',
-            'Lane Marking - Ambiguous', 'Lane Marking - Arrow (Left)',
-            'Lane Marking - Arrow (Other)', 'Lane Marking - Arrow (Right)',
-            'Lane Marking - Arrow (Split Left or Straight)',
-            'Lane Marking - Arrow (Split Right or Straight)',
-            'Lane Marking - Arrow (Straight)', 'Lane Marking - Crosswalk',
-            'Lane Marking - Give Way (Row)',
-            'Lane Marking - Give Way (Single)',
-            'Lane Marking - Hatched (Chevron)',
-            'Lane Marking - Hatched (Diagonal)', 'Lane Marking - Other',
-            'Lane Marking - Stop Line', 'Lane Marking - Symbol (Bicycle)',
-            'Lane Marking - Symbol (Other)', 'Lane Marking - Text',
-            'Lane Marking (only) - Dashed Line',
-            'Lane Marking (only) - Crosswalk', 'Lane Marking (only) - Other',
-            'Lane Marking (only) - Test', 'Mountain', 'Sand', 'Sky', 'Snow',
-            'Terrain', 'Vegetation', 'Water', 'Banner', 'Bench', 'Bike Rack',
-            'Catch Basin', 'CCTV Camera', 'Fire Hydrant', 'Junction Box',
-            'Mailbox', 'Manhole', 'Parking Meter', 'Phone Booth', 'Pothole',
-            'Signage - Advertisement', 'Signage - Ambiguous', 'Signage - Back',
-            'Signage - Information', 'Signage - Other', 'Signage - Store',
-            'Street Light', 'Pole', 'Pole Group', 'Traffic Sign Frame',
-            'Utility Pole', 'Traffic Cone', 'Traffic Light - General (Single)',
-            'Traffic Light - Pedestrians', 'Traffic Light - General (Upright)',
-            'Traffic Light - General (Horizontal)', 'Traffic Light - Cyclists',
-            'Traffic Light - Other', 'Traffic Sign - Ambiguous',
-            'Traffic Sign (Back)', 'Traffic Sign - Direction (Back)',
-            'Traffic Sign - Direction (Front)', 'Traffic Sign (Front)',
-            'Traffic Sign - Parking', 'Traffic Sign - Temporary (Back)',
-            'Traffic Sign - Temporary (Front)', 'Trash Can', 'Bicycle', 'Boat',
-            'Bus', 'Car', 'Caravan', 'Motorcycle', 'On Rails', 'Other Vehicle',
-            'Trailer', 'Truck', 'Vehicle Group', 'Wheeled Slow', 'Water Valve',
-            'Car Mount', 'Dynamic', 'Ego Vehicle', 'Ground', 'Static',
-            'Unlabeled'),
-        palette=[[165, 42, 42], [0, 192, 0], [250, 170, 31], [250, 170, 32],
-                 [196, 196, 196], [190, 153, 153], [180, 165, 180],
-                 [90, 120, 150], [250, 170, 33], [250, 170, 34],
-                 [128, 128, 128], [250, 170, 35], [102, 102, 156],
-                 [128, 64, 255], [140, 140, 200], [170, 170, 170],
-                 [250, 170, 36], [250, 170, 160], [250, 170, 37], [96, 96, 96],
-                 [230, 150, 140], [128, 64, 128], [110, 110, 110],
-                 [110, 110, 110], [244, 35, 232], [128, 196,
-                                                   128], [150, 100, 100],
-                 [70, 70, 70], [150, 150, 150], [150, 120, 90], [220, 20, 60],
-                 [220, 20, 60], [255, 0, 0], [255, 0, 100], [255, 0, 200],
-                 [255, 255, 255], [255, 255, 255], [250, 170, 29],
-                 [250, 170, 28], [250, 170, 26], [250, 170,
-                                                  25], [250, 170, 24],
-                 [250, 170, 22], [250, 170, 21], [250, 170,
-                                                  20], [255, 255, 255],
-                 [250, 170, 19], [250, 170, 18], [250, 170,
-                                                  12], [250, 170, 11],
-                 [255, 255, 255], [255, 255, 255], [250, 170, 16],
-                 [250, 170, 15], [250, 170, 15], [255, 255, 255],
-                 [255, 255, 255], [255, 255, 255], [255, 255, 255],
-                 [64, 170, 64], [230, 160, 50],
-                 [70, 130, 180], [190, 255, 255], [152, 251, 152],
-                 [107, 142, 35], [0, 170, 30], [255, 255, 128], [250, 0, 30],
-                 [100, 140, 180], [220, 128, 128], [222, 40,
-                                                    40], [100, 170, 30],
-                 [40, 40, 40], [33, 33, 33], [100, 128, 160], [20, 20, 255],
-                 [142, 0, 0], [70, 100, 150], [250, 171, 30], [250, 172, 30],
-                 [250, 173, 30], [250, 174, 30], [250, 175,
-                                                  30], [250, 176, 30],
-                 [210, 170, 100], [153, 153, 153], [153, 153, 153],
-                 [128, 128, 128], [0, 0, 80], [210, 60, 60], [250, 170, 30],
-                 [250, 170, 30], [250, 170, 30], [250, 170,
-                                                  30], [250, 170, 30],
-                 [250, 170, 30], [192, 192, 192], [192, 192, 192],
-                 [192, 192, 192], [220, 220, 0], [220, 220, 0], [0, 0, 196],
-                 [192, 192, 192], [220, 220, 0], [140, 140, 20], [119, 11, 32],
-                 [150, 0, 255], [0, 60, 100], [0, 0, 142], [0, 0, 90],
-                 [0, 0, 230], [0, 80, 100], [128, 64, 64], [0, 0, 110],
-                 [0, 0, 70], [0, 0, 142], [0, 0, 192], [170, 170, 170],
-                 [32, 32, 32], [111, 74, 0], [120, 10, 10], [81, 0, 81],
-                 [111, 111, 0], [0, 0, 0]])
-
-    def __init__(self,
-                 img_suffix='.jpg',
-                 seg_map_suffix='.png',
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/ct/cranium/README.md b/mmsegmentation/projects/medical/2d_image/ct/cranium/README.md
deleted file mode 100644
index d3fa64e..0000000
--- a/mmsegmentation/projects/medical/2d_image/ct/cranium/README.md
+++ /dev/null
@@ -1,142 +0,0 @@
-# Brain CT Images with Intracranial Hemorrhage Masks (Cranium)
-
-## Description
-
-This project supports **`Brain CT Images with Intracranial Hemorrhage Masks (Cranium)`**, which can be downloaded from [here](https://www.kaggle.com/datasets/vbookshelf/computed-tomography-ct-images).
-
-### Dataset Overview
-
-This dataset consists of head CT (Computed Thomography) images in jpg format. There are 2500 brain window images and 2500 bone window images, for 82 patients. There are approximately 30 image slices per patient. 318 images have associated intracranial image masks. Also included are csv files containing hemorrhage diagnosis data and patient data.
-This is version 1.0.0 of this dataset. A full description of this dataset as well as updated versions can be found here:
-https://physionet.org/content/ct-ich/1.0.0/
-
-### Statistic Information
-
-| Dataset Name                                                                        | Anatomical Region | Task Type    | Modality | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                   |
-| ----------------------------------------------------------------------------------- | ----------------- | ------------ | -------- | ------------ | --------------------- | ---------------------- | ------------ | --------------------------------------------------------- |
-| [Cranium](https://www.kaggle.com/datasets/vbookshelf/computed-tomography-ct-images) | head_and_neck     | segmentation | ct       | 2            | 2501/-/-              | yes/-/-                | 2020         | [CC-BY 4.0](https://creativecommons.org/licenses/by/4.0/) |
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |    2501    |   99.93    |    -     |    -     |     -     |     -     |
-| hemorrhage |    318     |    0.07    |    -     |    -     |     -     |     -     |
-
-Note:
-
-- `Pct` means percentage of pixels in this category in all pixels.
-
-### Visualization
-
-![cranium](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/ct/cranium/cranium_dataset.png?raw=true)
-
-## Dataset Citation
-
-```
-@article{hssayeni2020computed,
-	title={Computed tomography images for intracranial hemorrhage detection and segmentation},
-	author={Hssayeni, Murtadha and Croock, MS and Salman, AD and Al-khafaji, HF and Yahya, ZA and Ghoraani, B},
-	journal={Intracranial Hemorrhage Segmentation Using A Deep Convolutional Model. Data},
-	volume={5},
-	number={1},
-	pages={179},
-	year={2020}
-}
-```
-
-### Prerequisites
-
-- Python v3.8
-- PyTorch v1.10.0
-- pillow(PIL) v9.3.0 9.3.0
-- scikit-learn(sklearn) v1.2.0 1.2.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-
-All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `cranium/` root directory, run the following line to add the current directory to `PYTHONPATH`:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset Preparing
-
-- download dataset from [here](https://www.kaggle.com/datasets/vbookshelf/computed-tomography-ct-images) and decompress data to path `'data/'`.
-- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
-- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set cannot be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── ct
-  │   │   │   │   ├── cranium
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── train.txt
-  │   │   │   │   │   │   ├── val.txt
-  │   │   │   │   │   │   ├── images
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   ├── masks
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-```
-
-### Divided Dataset Information
-
-***Note: The table information below is divided by ourselves.***
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |    2000    |   99.93    |   501    |  99.92   |     -     |     -     |
-| hemorrhage |    260     |    0.07    |   260    |   0.08   |     -     |     -     |
-
-### Training commands
-
-To train models on a single server with one GPU. (default)
-
-```shell
-mim train mmseg ./configs/${CONFIG_FILE}
-```
-
-### Testing commands
-
-To test models on a single server with one GPU. (default)
-
-```shell
-mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-  - [x] Basic docstrings & proper citation
-  - [ ] Test-time correctness
-  - [x] A full README
-
-- [ ] Milestone 2: Indicates a successful model implementation.
-
-  - [ ] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-  - [ ] Unit tests
-  - [ ] Code polishing
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/cranium_512x512.py b/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/cranium_512x512.py
deleted file mode 100644
index d9b4436..0000000
--- a/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/cranium_512x512.py
+++ /dev/null
@@ -1,42 +0,0 @@
-dataset_type = 'CraniumDataset'
-data_root = 'data/'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='train.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='val.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_cranium-512x512.py b/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_cranium-512x512.py
deleted file mode 100644
index ac013a2..0000000
--- a/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_cranium-512x512.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './cranium_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.cranium_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(
-        num_classes=2, loss_decode=dict(use_sigmoid=True), out_channels=1),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_cranium-512x512.py b/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_cranium-512x512.py
deleted file mode 100644
index c71110a..0000000
--- a/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_cranium-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './cranium_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.cranium_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_cranium-512x512.py b/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_cranium-512x512.py
deleted file mode 100644
index abbdac2..0000000
--- a/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_cranium-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './cranium_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.cranium_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_cranium-512x512.py b/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_cranium-512x512.py
deleted file mode 100644
index 4185952..0000000
--- a/mmsegmentation/projects/medical/2d_image/ct/cranium/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_cranium-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './cranium_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.cranium_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/ct/cranium/datasets/cranium_dataset.py b/mmsegmentation/projects/medical/2d_image/ct/cranium/datasets/cranium_dataset.py
deleted file mode 100644
index d65f1cb..0000000
--- a/mmsegmentation/projects/medical/2d_image/ct/cranium/datasets/cranium_dataset.py
+++ /dev/null
@@ -1,31 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class CraniumDataset(BaseSegDataset):
-    """CraniumDataset dataset.
-
-    In segmentation map annotation for CraniumDataset,
-    0 stands for background, which is included in 2 categories.
-    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
-    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
-
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-        reduce_zero_label (bool): Whether to mark label zero as ignored.
-            Default to False.
-    """
-    METAINFO = dict(classes=('background', 'hemorrhage'))
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/ct/cranium/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/ct/cranium/tools/prepare_dataset.py
deleted file mode 100644
index 1aa4e43..0000000
--- a/mmsegmentation/projects/medical/2d_image/ct/cranium/tools/prepare_dataset.py
+++ /dev/null
@@ -1,66 +0,0 @@
-import os
-
-import numpy as np
-from PIL import Image
-
-root_path = 'data/'
-img_suffix = '.png'
-seg_map_suffix = '.png'
-save_img_suffix = '.png'
-save_seg_map_suffix = '.png'
-tgt_img_dir = os.path.join(root_path, 'images/train/')
-tgt_mask_dir = os.path.join(root_path, 'masks/train/')
-os.system('mkdir -p ' + tgt_img_dir)
-os.system('mkdir -p ' + tgt_mask_dir)
-
-
-def read_single_array_from_pil(path):
-    return np.asarray(Image.open(path))
-
-
-def save_png_from_array(arr, save_path, mode=None):
-    Image.fromarray(arr, mode=mode).save(save_path)
-
-
-def convert_label(img, convert_dict):
-    arr = np.zeros_like(img, dtype=np.uint8)
-    for c, i in convert_dict.items():
-        arr[img == c] = i
-    return arr
-
-
-patients_dir = os.path.join(
-    root_path, 'Cranium/computed-tomography-images-for-' +
-    'intracranial-hemorrhage-detection-and-segmentation-1.0.0' +
-    '/Patients_CT')
-
-patients = sorted(os.listdir(patients_dir))
-for p in patients:
-    data_dir = os.path.join(patients_dir, p, 'brain')
-    file_names = os.listdir(data_dir)
-    img_w_mask_names = [
-        _.replace('_HGE_Seg', '') for _ in file_names if 'Seg' in _
-    ]
-    img_wo_mask_names = [
-        _ for _ in file_names if _ not in img_w_mask_names and 'Seg' not in _
-    ]
-
-    for file_name in file_names:
-        path = os.path.join(data_dir, file_name)
-        img = read_single_array_from_pil(path)
-        tgt_name = file_name.replace('.jpg', img_suffix)
-        tgt_name = p + '_' + tgt_name
-        if 'Seg' in file_name:  # is a mask
-            tgt_name = tgt_name.replace('_HGE_Seg', '')
-            mask_path = os.path.join(tgt_mask_dir, tgt_name)
-            mask = convert_label(img, convert_dict={0: 0, 255: 1})
-            save_png_from_array(mask, mask_path)
-        else:
-            img_path = os.path.join(tgt_img_dir, tgt_name)
-            pil = Image.fromarray(img).convert('RGB')
-            pil.save(img_path)
-
-            if file_name in img_wo_mask_names:
-                mask = np.zeros_like(img, dtype=np.uint8)
-                mask_path = os.path.join(tgt_mask_dir, tgt_name)
-                save_png_from_array(mask, mask_path)
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/README.md b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/README.md
deleted file mode 100644
index 6e44e41..0000000
--- a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/README.md
+++ /dev/null
@@ -1,149 +0,0 @@
-# ISIC-2016 Task1
-
-## Description
-
-This project support **`ISIC-2016 Task1 `**, and the dataset used in this project can be downloaded from [here](https://challenge.isic-archive.com/data/#2016).
-
-### Dataset Overview
-
-The overarching goal of the challenge is to develop image analysis tools to enable the automated diagnosis of melanoma from dermoscopic images.
-
-This challenge provides training data (~900 images) for participants to engage in all 3 components of lesion image analysis. A separate test dataset (~350 images) will be provided for participants to generate and submit automated results.
-
-### Original Statistic Information
-
-| Dataset name                                                     | Anatomical region | Task type    | Modality   | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                                |
-| ---------------------------------------------------------------- | ----------------- | ------------ | ---------- | ------------ | --------------------- | ---------------------- | ------------ | ---------------------------------------------------------------------- |
-| [ISIC-2016 Task1](https://challenge.isic-archive.com/data/#2016) | full body         | segmentation | dermoscopy | 2            | 900/-/379-            | yes/-/yes              | 2016         | [CC-0](https://creativecommons.org/share-your-work/public-domain/cc0/) |
-
-| Class Name  | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :---------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background  |    900     |   82.08    |    -     |    -     |    379    |   81.98   |
-| skin lesion |    900     |   17.92    |    -     |    -     |    379    |   18.02   |
-
-Note:
-
-- `Pct` means percentage of pixels in this category in all pixels.
-
-### Visualization
-
-![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/dermoscopy/isic2016_task1/isic2016_task1.png)
-
-### Prerequisites
-
-- Python 3.8
-- PyTorch 1.10.0
-- pillow(PIL) 9.3.0
-- scikit-learn(sklearn) 1.2.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-
-All the commands below rely on the correct configuration of PYTHONPATH, which should point to the project's directory so that Python can locate the module files. In isic2016_task1/ root directory, run the following line to add the current directory to PYTHONPATH:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset preparing
-
-- download dataset from [here](https://challenge.isic-archive.com/data/#2016) and decompression data to path 'data/'.
-- run script `"python tools/prepare_dataset.py"` to split dataset and change folder structure as below.
-- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt` and `test.txt`. If the label of official validation set and test set can't be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── dermoscopy
-  │   │   │   │   ├── isic2016_task1
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── train.txt
-  │   │   │   │   │   │   ├── test.txt
-  │   │   │   │   │   │   ├── images
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   │   ├── test
-  │   │   │   │   |   │   │   │   ├── yyy.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── yyy.png
-  │   │   │   │   │   │   ├── masks
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   │   ├── test
-  │   │   │   │   |   │   │   │   ├── yyy.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── yyy.png
-```
-
-### Training commands
-
-```shell
-mim train mmseg ./configs/${CONFIG_PATH}
-```
-
-To train on multiple GPUs, e.g. 8 GPUs, run the following command:
-
-```shell
-mim train mmseg ./configs/${CONFIG_PATH}  --launcher pytorch --gpus 8
-```
-
-### Testing commands
-
-```shell
-mim test mmseg ./configs/${CONFIG_PATH}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
-
-You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
-
-## Results
-
-### ISIC-2016 Task1
-
-|     Method      | Backbone | Crop Size |   lr   | mIoU | mDice |                                                                                             config                                                                                              |
-| :-------------: | :------: | :-------: | :----: | :--: | :---: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
-| fcn_unet_s5-d16 |   unet   |  512x512  |  0.01  |  -   |   -   |  [config](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_isic2016-task1-512x512.py)  |
-| fcn_unet_s5-d16 |   unet   |  512x512  | 0.001  |  -   |   -   | [config](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_isic2016-task1-512x512.py)  |
-| fcn_unet_s5-d16 |   unet   |  512x512  | 0.0001 |  -   |   -   | [config](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_isic2016-task1-512x512.py) |
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-
-  - [x] Basic docstrings & proper citation
-
-  - [x] Test-time correctness
-
-  - [x] A full README
-
-- [x] Milestone 2: Indicates a successful model implementation.
-
-  - [x] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-
-  - [ ] Unit tests
-
-  - [ ] Code polishing
-
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_isic2016-task1-512x512.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_isic2016-task1-512x512.py
deleted file mode 100644
index 5638de4..0000000
--- a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_isic2016-task1-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './isic2016-task1_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.isic2016-task1_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_isic2016-task1-512x512.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_isic2016-task1-512x512.py
deleted file mode 100644
index bf17faa..0000000
--- a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_isic2016-task1-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './isic2016-task1_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.isic2016-task1_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_isic2016-task1-512x512.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_isic2016-task1-512x512.py
deleted file mode 100644
index f7bfcf6..0000000
--- a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_isic2016-task1-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './isic2016-task1_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.isic2016-task1_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/isic2016-task1_512x512.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/isic2016-task1_512x512.py
deleted file mode 100644
index 029f5d4..0000000
--- a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/configs/isic2016-task1_512x512.py
+++ /dev/null
@@ -1,42 +0,0 @@
-dataset_type = 'ISIC2017Task1'
-data_root = 'data/'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='train.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='test.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/datasets/isic2016-task1_dataset.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/datasets/isic2016-task1_dataset.py
deleted file mode 100644
index 8f11bdd..0000000
--- a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/datasets/isic2016-task1_dataset.py
+++ /dev/null
@@ -1,30 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class ISIC2017Task1(BaseSegDataset):
-    """ISIC2017Task1 dataset.
-
-    In segmentation map annotation for ISIC2017Task1,
-    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
-    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
-
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-        reduce_zero_label (bool): Whether to mark label zero as ignored.
-            Default to False.
-    """
-    METAINFO = dict(classes=('normal', 'skin lesion'))
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/tools/prepare_dataset.py
deleted file mode 100755
index ef4dad5..0000000
--- a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2016_task1/tools/prepare_dataset.py
+++ /dev/null
@@ -1,120 +0,0 @@
-import glob
-import os
-import shutil
-
-import numpy as np
-from PIL import Image
-
-
-def check_maskid(train_imgs):
-    for i in train_masks:
-        img = Image.open(i)
-        print(np.unique(np.array(img)))
-
-
-def reformulate_file(image_list, mask_list):
-    file_list = []
-    for idx, (imgp,
-              maskp) in enumerate(zip(sorted(image_list), sorted(mask_list))):
-        item = {'image': imgp, 'label': maskp}
-        file_list.append(item)
-    return file_list
-
-
-def check_file_exist(pair_list):
-    rel_path = os.getcwd()
-    for idx, sample in enumerate(pair_list):
-        image_path = sample['image']
-        assert os.path.exists(os.path.join(rel_path, image_path))
-        if 'label' in sample:
-            mask_path = sample['label']
-            assert os.path.exists(os.path.join(rel_path, mask_path))
-    print('all file path ok!')
-
-
-def convert_maskid(mask):
-    # add mask id conversion
-    arr_mask = np.array(mask).astype(np.uint8)
-    arr_mask[arr_mask == 255] = 1
-    return Image.fromarray(arr_mask)
-
-
-def process_dataset(file_lists, part_dir_dict):
-    for ith, part in enumerate(file_lists):
-        part_dir = part_dir_dict[ith]
-        for sample in part:
-            # read image and mask
-            image_path = sample['image']
-            if 'label' in sample:
-                mask_path = sample['label']
-
-            basename = os.path.basename(image_path)
-            targetname = basename.split('.')[0]  # from image name
-
-            # check image file
-            img_save_path = os.path.join(root_path, 'images', part_dir,
-                                         targetname + save_img_suffix)
-            if not os.path.exists(img_save_path):
-                if not image_path.endswith('.png'):
-                    src = Image.open(image_path)
-                    src.save(img_save_path)
-                else:
-                    shutil.copy(image_path, img_save_path)
-
-            if mask_path is not None:
-                mask_save_path = os.path.join(root_path, 'masks', part_dir,
-                                              targetname + save_seg_map_suffix)
-                if not os.path.exists(mask_save_path):
-                    # check mask file
-                    mask = Image.open(mask_path).convert('L')
-                    # convert mask id
-                    mask = convert_maskid(mask)
-                    if not mask_path.endswith('.png'):
-                        mask.save(mask_save_path)
-                    else:
-                        mask.save(mask_save_path)
-
-        # print image num
-        part_dir_folder = os.path.join(root_path, 'images', part_dir)
-        print(
-            f'{part_dir} has {len(os.listdir(part_dir_folder))} images completed!'  # noqa
-        )
-
-
-if __name__ == '__main__':
-
-    root_path = 'data/'  # original file
-    img_suffix = '.jpg'
-    seg_map_suffix = '.png'
-    save_img_suffix = '.png'
-    save_seg_map_suffix = '.png'
-
-    train_imgs = glob.glob('data/ISBI2016_ISIC_Part1_Training_Data/*'  # noqa
-                           + img_suffix)
-    train_masks = glob.glob(
-        'data/ISBI2016_ISIC_Part1_Training_GroundTruth/*'  # noqa
-        + seg_map_suffix)
-
-    test_imgs = glob.glob('data/ISBI2016_ISIC_Part1_Test_Data/*' + img_suffix)
-    test_masks = glob.glob(
-        'data/ISBI2016_ISIC_Part1_Test_GroundTruth/*'  # noqa
-        + seg_map_suffix)
-
-    assert len(train_imgs) == len(train_masks)
-    assert len(test_imgs) == len(test_masks)
-
-    print(f'training images: {len(train_imgs)}, test images: {len(test_imgs)}')
-
-    os.system('mkdir -p ' + root_path + 'images/train/')
-    os.system('mkdir -p ' + root_path + 'images/test/')
-    os.system('mkdir -p ' + root_path + 'masks/train/')
-    os.system('mkdir -p ' + root_path + 'masks/test/')
-
-    train_pair_list = reformulate_file(train_imgs, train_masks)
-    test_pair_list = reformulate_file(test_imgs, test_masks)
-
-    check_file_exist(train_pair_list)
-    check_file_exist(test_pair_list)
-
-    part_dir_dict = {0: 'train/', 1: 'test/'}
-    process_dataset([train_pair_list, test_pair_list], part_dir_dict)
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/README.md b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/README.md
deleted file mode 100644
index c7cc270..0000000
--- a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/README.md
+++ /dev/null
@@ -1,158 +0,0 @@
-# ISIC-2017 Task1
-
-## Description
-
-This project support **`ISIC-2017 Task1 `**, and the dataset used in this project can be downloaded from [here](https://challenge.isic-archive.com/data/#2017).
-
-### Dataset Overview
-
-The goal of the challenge is to help participants develop image analysis tools to enable the automated diagnosis of melanoma from dermoscopic images.
-
-This challenge provides training data (~2000 images) for participants to engage in all 3 components of lesion image analysis. A separate public validation dataset (~150 images) and blind held-out test dataset (~600 images) will be provided for participants to generate and submit automated results.
-
-### Original Statistic Information
-
-| Dataset name                                                     | Anatomical region | Task type    | Modality   | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                                |
-| ---------------------------------------------------------------- | ----------------- | ------------ | ---------- | ------------ | --------------------- | ---------------------- | ------------ | ---------------------------------------------------------------------- |
-| [ISIC-2017 Task1](https://challenge.isic-archive.com/data/#2017) | full body         | segmentation | dermoscopy | 2            | 2000/150/600          | yes/yes/yes            | 2017         | [CC-0](https://creativecommons.org/share-your-work/public-domain/cc0/) |
-
-| Class Name  | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :---------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-|   normal    |    2000    |   82.86    |   150    |  73.88   |    600    |   70.62   |
-| skin lesion |    2000    |   17.14    |   150    |  26.12   |    600    |   29.38   |
-
-Note:
-
-- `Pct` means percentage of pixels in this category in all pixels.
-
-### Visualization
-
-![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/dermoscopy/isic2017_task1/isic2017_task1.png)
-
-### Prerequisites
-
-- Python 3.8
-- PyTorch 1.10.0
-- pillow(PIL) 9.3.0
-- scikit-learn(sklearn) 1.2.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-
-All the commands below rely on the correct configuration of PYTHONPATH, which should point to the project's directory so that Python can locate the module files. In isic2017_task1/ root directory, run the following line to add the current directory to PYTHONPATH:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset preparing
-
-- download dataset from [here](https://challenge.isic-archive.com/data/#2017) and decompression data to path 'data/'.
-- run script `"python tools/prepare_dataset.py"` to split dataset and change folder structure as below.
-- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt` and `test.txt`. If the label of official validation set and test set can't be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── dermoscopy
-  │   │   │   │   ├── isic2017_task1
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── train.txt
-  │   │   │   │   │   │   ├── val.txt
-  │   │   │   │   │   │   ├── test.txt
-  │   │   │   │   │   │   ├── images
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   │   ├── val
-  │   │   │   │   |   │   │   │   ├── yyy.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── yyy.png
-  │   │   │   │   │   │   │   ├── test
-  │   │   │   │   |   │   │   │   ├── yyy.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── yyy.png
-  │   │   │   │   │   │   ├── masks
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   │   ├── val
-  │   │   │   │   |   │   │   │   ├── yyy.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── yyy.png
-  │   │   │   │   │   │   │   ├── test
-  │   │   │   │   |   │   │   │   ├── yyy.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── yyy.png
-```
-
-### Training commands
-
-```shell
-mim train mmseg ./configs/${CONFIG_PATH}
-```
-
-To train on multiple GPUs, e.g. 8 GPUs, run the following command:
-
-```shell
-mim train mmseg ./configs/${CONFIG_PATH}  --launcher pytorch --gpus 8
-```
-
-### Testing commands
-
-```shell
-mim test mmseg ./configs/${CONFIG_PATH}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
-
-You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
-
-## Results
-
-### ISIC-2017 Task1
-
-|     Method      | Backbone | Crop Size |   lr   | mIoU | mDice |                                                                                             config                                                                                              |
-| :-------------: | :------: | :-------: | :----: | :--: | :---: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
-| fcn_unet_s5-d16 |   unet   |  512x512  |  0.01  |  -   |   -   |  [config](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_isic2017-task1-512x512.py)  |
-| fcn_unet_s5-d16 |   unet   |  512x512  | 0.001  |  -   |   -   | [config](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_isic2017-task1-512x512.py)  |
-| fcn_unet_s5-d16 |   unet   |  512x512  | 0.0001 |  -   |   -   | [config](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_isic2017-task1-512x512.py) |
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-
-  - [x] Basic docstrings & proper citation
-
-  - [ ] Test-time correctness
-
-  - [x] A full README
-
-- [ ] Milestone 2: Indicates a successful model implementation.
-
-  - [ ] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-
-  - [ ] Unit tests
-
-  - [ ] Code polishing
-
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_isic2017-task1-512x512.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_isic2017-task1-512x512.py
deleted file mode 100644
index 58d0a12..0000000
--- a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_isic2017-task1-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './isic2017-task1_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.isic2017-task1_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_isic2017-task1-512x512.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_isic2017-task1-512x512.py
deleted file mode 100644
index 3becacf..0000000
--- a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_isic2017-task1-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './isic2017-task1_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.isic2017-task1_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_isic2017-task1-512x512.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_isic2017-task1-512x512.py
deleted file mode 100644
index 654ef4d..0000000
--- a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_isic2017-task1-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './isic2017-task1_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.isic2017-task1_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/isic2017-task1_512x512.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/isic2017-task1_512x512.py
deleted file mode 100644
index 95997a1..0000000
--- a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/configs/isic2017-task1_512x512.py
+++ /dev/null
@@ -1,41 +0,0 @@
-dataset_type = 'ISIC2017Task1'
-data_root = 'data/'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='images/train/', seg_map_path='masks/train/'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(img_path='images/val/', seg_map_path='masks/val/'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/datasets/isic2017-task1_dataset.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/datasets/isic2017-task1_dataset.py
deleted file mode 100644
index 8f11bdd..0000000
--- a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/datasets/isic2017-task1_dataset.py
+++ /dev/null
@@ -1,30 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class ISIC2017Task1(BaseSegDataset):
-    """ISIC2017Task1 dataset.
-
-    In segmentation map annotation for ISIC2017Task1,
-    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
-    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
-
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-        reduce_zero_label (bool): Whether to mark label zero as ignored.
-            Default to False.
-    """
-    METAINFO = dict(classes=('normal', 'skin lesion'))
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/tools/prepare_dataset.py
deleted file mode 100755
index b3643c9..0000000
--- a/mmsegmentation/projects/medical/2d_image/dermoscopy/isic2017_task1/tools/prepare_dataset.py
+++ /dev/null
@@ -1,127 +0,0 @@
-import glob
-import os
-import shutil
-
-import numpy as np
-from PIL import Image
-
-
-def check_maskid(train_imgs):
-    for i in train_masks:
-        img = Image.open(i)
-        print(np.unique(np.array(img)))
-
-
-def reformulate_file(image_list, mask_list):
-    file_list = []
-    for idx, (imgp,
-              maskp) in enumerate(zip(sorted(image_list), sorted(mask_list))):
-        item = {'image': imgp, 'label': maskp}
-        file_list.append(item)
-    return file_list
-
-
-def convert_maskid(mask):
-    # add mask id conversion
-    arr_mask = np.array(mask).astype(np.uint8)
-    arr_mask[arr_mask == 255] = 1
-    return Image.fromarray(arr_mask)
-
-
-def check_file_exist(pair_list):
-    rel_path = os.getcwd()
-    for idx, sample in enumerate(pair_list):
-        image_path = sample['image']
-        assert os.path.exists(os.path.join(rel_path, image_path))
-        if 'label' in sample:
-            mask_path = sample['label']
-            assert os.path.exists(os.path.join(rel_path, mask_path))
-    print('all file path ok!')
-
-
-def process_dataset(file_lists, part_dir_dict):
-    for ith, part in enumerate(file_lists):
-        part_dir = part_dir_dict[ith]
-        for sample in part:
-            # read image and mask
-            image_path = sample['image']
-            if 'label' in sample:
-                mask_path = sample['label']
-
-            basename = os.path.basename(image_path)
-            targetname = basename.split('.')[0]  # from image name
-
-            # check image file
-            img_save_path = os.path.join(root_path, 'images', part_dir,
-                                         targetname + save_img_suffix)
-            if not os.path.exists(img_save_path):
-                if not image_path.endswith('.png'):
-                    src = Image.open(image_path)
-                    src.save(img_save_path)
-                else:
-                    shutil.copy(image_path, img_save_path)
-
-            if mask_path is not None:
-                mask_save_path = os.path.join(root_path, 'masks', part_dir,
-                                              targetname + save_seg_map_suffix)
-                if not os.path.exists(mask_save_path):
-                    # check mask file
-                    mask = Image.open(mask_path).convert('L')
-                    # convert mask id
-                    mask = convert_maskid(mask)
-                    if not mask_path.endswith('.png'):
-                        mask.save(mask_save_path)
-                    else:
-                        mask.save(mask_save_path)
-
-        # print image num
-        part_dir_folder = os.path.join(root_path, 'images', part_dir)
-        print(
-            f'{part_dir} has {len(os.listdir(part_dir_folder))} images completed!'  # noqa
-        )
-
-
-if __name__ == '__main__':
-
-    root_path = 'data/'  # original file
-    img_suffix = '.jpg'
-    seg_map_suffix = '.png'
-    save_img_suffix = '.png'
-    save_seg_map_suffix = '.png'
-
-    train_imgs = glob.glob('data/ISIC-2017_Training_Data/*' + img_suffix)
-    train_masks = glob.glob('data/ISIC-2017_Training_Part1_GroundTruth/*' +
-                            seg_map_suffix)
-
-    val_imgs = glob.glob('data/ISIC-2017_Validation_Data/*' + img_suffix)
-    val_masks = glob.glob('data/ISIC-2017_Validation_Part1_GroundTruth/*' +
-                          seg_map_suffix)
-
-    test_imgs = glob.glob('data/ISIC-2017_Test_v2_Data/*' + img_suffix)
-    test_masks = glob.glob('data/ISIC-2017_Test_v2_Part1_GroundTruth/*' +
-                           seg_map_suffix)
-
-    assert len(train_imgs) == len(train_masks)
-    assert len(val_imgs) == len(val_masks)
-    assert len(test_imgs) == len(test_masks)
-
-    os.system('mkdir -p ' + root_path + 'images/train/')
-    os.system('mkdir -p ' + root_path + 'images/val/')
-    os.system('mkdir -p ' + root_path + 'images/test/')
-    os.system('mkdir -p ' + root_path + 'masks/train/')
-    os.system('mkdir -p ' + root_path + 'masks/val/')
-    os.system('mkdir -p ' + root_path + 'masks/test/')
-
-    part_dir_dict = {0: 'train/', 1: 'val/', 2: 'test/'}
-
-    train_pair_list = reformulate_file(train_imgs, train_masks)
-    val_pair_list = reformulate_file(val_imgs, val_masks)
-    test_pair_list = reformulate_file(test_imgs, test_masks)
-
-    check_file_exist(train_pair_list)
-    check_file_exist(val_pair_list)
-    check_file_exist(test_pair_list)
-
-    part_dir_dict = {0: 'train/', 1: 'val/', 2: 'test/'}
-    process_dataset([train_pair_list, val_pair_list, test_pair_list],
-                    part_dir_dict)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/README.md b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/README.md
deleted file mode 100644
index ea597bc..0000000
--- a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/README.md
+++ /dev/null
@@ -1,145 +0,0 @@
-# Kvasir-Sessile Dataset (Kvasir SEG)
-
-## Description
-
-This project supports **`Kvasir-Sessile Dataset (Kvasir SEG) `**, which can be downloaded from [here](https://opendatalab.com/Kvasir-Sessile_dataset).
-
-## Dataset Overview
-
-The Kvasir-SEG dataset contains polyp images and their corresponding ground truth from the Kvasir Dataset v2. The resolution of the images contained in Kvasir-SEG varies from 332x487 to 1920x1072 pixels.
-
-<!-- For a typical model, this section should contain the commands for training and testing. You are also suggested to dump your environment specification to env.yml by `conda env export > env.yml`. -->
-
-### Information Statistics
-
-| Dataset Name                                                  | Anatomical Region | Task Type    | Modality  | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                   |
-| ------------------------------------------------------------- | ----------------- | ------------ | --------- | ------------ | --------------------- | ---------------------- | ------------ | --------------------------------------------------------- |
-| [Kvarsir-SEG](https://opendatalab.com/Kvasir-Sessile_dataset) | abdomen           | segmentation | endoscopy | 2            | 196/-/-               | yes/-/-                | 2020         | [CC-BY 4.0](https://creativecommons.org/licenses/by/4.0/) |
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |    196     |   92.31    |    -     |    -     |     -     |     -     |
-|   polyp    |    196     |    7.69    |    -     |    -     |     -     |     -     |
-
-Note:
-
-- `Pct` means percentage of pixels in this category in all pixels.
-
-### Visualization
-
-![kvasir-seg](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/endoscopy_images/kvasir_seg/kvasir_seg_dataset.png?raw=true)
-
-### Dataset Citation
-
-```
-@inproceedings{jha2020kvasir,
-	title={Kvasir-seg: A segmented polyp dataset},
-	author={Jha, Debesh and Smedsrud, Pia H and Riegler, Michael A and Halvorsen, P{\aa}l and Lange, Thomas de and Johansen, Dag and Johansen, H{\aa}vard D},
-	booktitle={International Conference on Multimedia Modeling},
-	pages={451--462},
-	year={2020},
-	organization={Springer}
- }
-```
-
-### Prerequisites
-
-- Python v3.8
-- PyTorch v1.10.0
-- pillow(PIL) v9.3.0
-- scikit-learn(sklearn) v1.2.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-
-All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `kvasir_seg/` root directory, run the following line to add the current directory to `PYTHONPATH`:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset Preparing
-
-- download dataset from [here](https://opendatalab.com/Kvasir-Sessile_dataset) and decompress data to path `'data/'`.
-- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
-- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set cannot be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── endoscopy
-  │   │   │   │   ├── kvasir_seg
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── train.txt
-  │   │   │   │   │   │   ├── val.txt
-  │   │   │   │   │   │   ├── images
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   ├── masks
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-```
-
-### Divided Dataset Information
-
-***Note: The table information below is divided by ourselves.***
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |    156     |   92.28    |    40    |  92.41   |     -     |     -     |
-|   polyp    |    156     |    7.72    |    40    |   7.59   |     -     |     -     |
-
-### Training commands
-
-To train models on a single server with one GPU. (default)
-
-```shell
-mim train mmseg .configs/${CONFIG_FILE}
-```
-
-### Testing commands
-
-To test models on a single server with one GPU. (default)
-
-```shell
-mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
-
-You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-  - [x] Basic docstrings & proper citation
-  - [ ] Test-time correctness
-  - [x] A full README
-
-- [x] Milestone 2: Indicates a successful model implementation.
-
-  - [x] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-  - [ ] Unit tests
-  - [ ] Code polishing
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_kvasir-seg-512x512.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_kvasir-seg-512x512.py
deleted file mode 100644
index 145d5a7..0000000
--- a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_kvasir-seg-512x512.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './kvasir-seg_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.kvasir-seg_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(
-        num_classes=2, loss_decode=dict(use_sigmoid=True), out_channels=1),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_kvasir-seg-512x512.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_kvasir-seg-512x512.py
deleted file mode 100644
index 3ea05c5..0000000
--- a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_kvasir-seg-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './kvasir-seg_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.kvasir-seg_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_kvasir-seg-512x512.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_kvasir-seg-512x512.py
deleted file mode 100644
index 7e064a7..0000000
--- a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_kvasir-seg-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './kvasir-seg_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.kvasir-seg_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_kvasir-seg-512x512.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_kvasir-seg-512x512.py
deleted file mode 100644
index 0fc1d6e..0000000
--- a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_kvasir-seg-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './kvasir-seg_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.kvasir-seg_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/kvasir-seg_512x512.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/kvasir-seg_512x512.py
deleted file mode 100644
index e8b2467..0000000
--- a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/configs/kvasir-seg_512x512.py
+++ /dev/null
@@ -1,42 +0,0 @@
-dataset_type = 'KvasirSEGDataset'
-data_root = 'data/'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='train.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='val.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/datasets/kvasir-seg_dataset.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/datasets/kvasir-seg_dataset.py
deleted file mode 100644
index 9d60132..0000000
--- a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/datasets/kvasir-seg_dataset.py
+++ /dev/null
@@ -1,30 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class KvasirSEGDataset(BaseSegDataset):
-    """KvasirSEGDataset dataset.
-
-    In segmentation map annotation for KvasirSEGDataset, 0 stands for
-    background, which is included in 2 categories.
-    ``reduce_zero_label`` is fixed to False. The ``img_suffix`` is
-    fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-        reduce_zero_label (bool): Whether to mark label zero as ignored.
-            Default to False..
-    """
-    METAINFO = dict(classes=('background', 'polyp'))
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/tools/prepare_dataset.py
deleted file mode 100644
index 74c43e9..0000000
--- a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg/tools/prepare_dataset.py
+++ /dev/null
@@ -1,87 +0,0 @@
-import glob
-import os
-
-import numpy as np
-from PIL import Image
-
-root_path = 'data/'
-img_suffix = '.jpg'
-seg_map_suffix = '.jpg'
-save_img_suffix = '.png'
-save_seg_map_suffix = '.png'
-tgt_img_dir = os.path.join(root_path, 'images/train/')
-tgt_mask_dir = os.path.join(root_path, 'masks/train/')
-os.system('mkdir -p ' + tgt_img_dir)
-os.system('mkdir -p ' + tgt_mask_dir)
-
-
-def filter_suffix_recursive(src_dir, suffix):
-    # filter out file names and paths in source directory
-    suffix = '.' + suffix if '.' not in suffix else suffix
-    file_paths = glob.glob(
-        os.path.join(src_dir, '**', '*' + suffix), recursive=True)
-    file_names = [_.split('/')[-1] for _ in file_paths]
-    return sorted(file_paths), sorted(file_names)
-
-
-def convert_label(img, convert_dict):
-    arr = np.zeros_like(img, dtype=np.uint8)
-    for c, i in convert_dict.items():
-        arr[img == c] = i
-    return arr
-
-
-def convert_pics_into_pngs(src_dir, tgt_dir, suffix, convert='RGB'):
-    if not os.path.exists(tgt_dir):
-        os.makedirs(tgt_dir)
-
-    src_paths, src_names = filter_suffix_recursive(src_dir, suffix=suffix)
-    for i, (src_name, src_path) in enumerate(zip(src_names, src_paths)):
-        tgt_name = src_name.replace(suffix, save_img_suffix)
-        tgt_path = os.path.join(tgt_dir, tgt_name)
-        num = len(src_paths)
-        img = np.array(Image.open(src_path))
-        if len(img.shape) == 2:
-            pil = Image.fromarray(img).convert(convert)
-        elif len(img.shape) == 3:
-            pil = Image.fromarray(img)
-        else:
-            raise ValueError('Input image not 2D/3D: ', img.shape)
-
-        pil.save(tgt_path)
-        print(f'processed {i+1}/{num}.')
-
-
-def convert_label_pics_into_pngs(src_dir,
-                                 tgt_dir,
-                                 suffix,
-                                 convert_dict={
-                                     0: 0,
-                                     255: 1
-                                 }):
-    if not os.path.exists(tgt_dir):
-        os.makedirs(tgt_dir)
-
-    src_paths, src_names = filter_suffix_recursive(src_dir, suffix=suffix)
-    num = len(src_paths)
-    for i, (src_name, src_path) in enumerate(zip(src_names, src_paths)):
-        tgt_name = src_name.replace(suffix, save_seg_map_suffix)
-        tgt_path = os.path.join(tgt_dir, tgt_name)
-
-        img = np.array(Image.open(src_path))
-        img = convert_label(img, convert_dict)
-        Image.fromarray(img).save(tgt_path)
-        print(f'processed {i+1}/{num}.')
-
-
-if __name__ == '__main__':
-
-    convert_pics_into_pngs(
-        os.path.join(root_path, 'sessile-main-Kvasir-SEG/images'),
-        tgt_img_dir,
-        suffix=img_suffix)
-
-    convert_label_pics_into_pngs(
-        os.path.join(root_path, 'sessile-main-Kvasir-SEG/masks'),
-        tgt_mask_dir,
-        suffix=seg_map_suffix)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/README.md b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/README.md
deleted file mode 100644
index 80eb00f..0000000
--- a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/README.md
+++ /dev/null
@@ -1,145 +0,0 @@
-# Kvasir-SEG Segmented Polyp Dataset from Aliyun (Kvasir SEG Aliyun)
-
-## Description
-
-This project supports **`Kvasir-SEG Segmented Polyp Dataset from Aliyun (Kvasir SEG Aliyun) `**, which can be downloaded from [here](https://tianchi.aliyun.com/dataset/84385).
-
-### Dataset Overview
-
-Colorectal cancer is the second most common cancer type among women and third most common among men. Polyps are precursors to colorectal cancer and therefore important to detect and remove at an early stage. Polyps are found in nearly half of the individuals at age 50 that undergo a colonoscopy screening, and their frequency increase with age.Polyps are abnormal tissue growth from the mucous membrane, which is lining the inside of the GI tract, and can sometimes be cancerous. Colonoscopy is the gold standard for detection and assessment of these polyps with subsequent biopsy and removal of the polyps. Early disease detection has a huge impact on survival from colorectal cancer. Increasing the detection of polyps has been shown to decrease risk of colorectal cancer. Thus, automatic detection of more polyps at an early stage can play a crucial role in prevention and survival from colorectal cancer.
-
-The Kvasir-SEG dataset is based on the previous Kvasir dataset, which is the first multi-class dataset for gastrointestinal (GI) tract disease detection and classification. It contains annotated polyp images and their corresponding masks. The pixels depicting polyp tissue, the ROI, are represented by the foreground (white mask), while the background (in black) does not contain positive pixels. These images were collected and verified by experienced gastroenterologists from Vestre Viken Health Trust in Norway. The classes include anatomical landmarks, pathological findings and endoscopic procedures.
-
-### Information Statistics
-
-| Dataset Name                                           | Anatomical Region | Task Type    | Modality  | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                   |
-| ------------------------------------------------------ | ----------------- | ------------ | --------- | ------------ | --------------------- | ---------------------- | ------------ | --------------------------------------------------------- |
-| [kvasir-seg](https://tianchi.aliyun.com/dataset/84385) | abdomen           | segmentation | endoscopy | 2            | 1000/-/-              | yes/-/-                | 2020         | [CC-BY 4.0](https://creativecommons.org/licenses/by/4.0/) |
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |    1000    |   84.72    |    -     |    -     |     -     |     -     |
-|   polyp    |    1000    |   15.28    |    -     |    -     |     -     |     -     |
-
-Note:
-
-- `Pct` means percentage of pixels in this category in all pixels.
-
-### Visualization
-
-![kvasir_seg_aliyun](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/endoscopy_images/kvasir_seg_aliyun/kvasir_seg_aliyun_dataset.png?raw=true)
-
-### Dataset Citation
-
-```
-@inproceedings{jha2020kvasir,
-	title={Kvasir-seg: A segmented polyp dataset},
-	author={Jha, Debesh and Smedsrud, Pia H and Riegler, Michael A and Halvorsen, P{\aa}l and Lange, Thomas de and Johansen, Dag and Johansen, H{\aa}vard D},
-	booktitle={International Conference on Multimedia Modeling},
-	pages={451--462},
-	year={2020},
-	organization={Springer}
- }
-```
-
-### Prerequisites
-
-- Python v3.8
-- PyTorch v1.10.0
-- pillow(PIL) v9.3.0
-- scikit-learn(sklearn) v1.2.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-
-All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `kvasir_seg_aliyun/` root directory, run the following line to add the current directory to `PYTHONPATH`:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset Preparing
-
-- download dataset from [here](https://tianchi.aliyun.com/dataset/84385) and decompression data to path 'data/.'.
-- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
-- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set cannot be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── endoscopy
-  │   │   │   │   ├── kvasir_seg_aliyun
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── train.txt
-  │   │   │   │   │   │   ├── val.txt
-  │   │   │   │   │   │   ├── images
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   ├── masks
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-```
-
-### Divided Dataset Information
-
-***Note: The table information below is divided by ourselves.***
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |    800     |   84.66    |   200    |  84.94   |     -     |     -     |
-|   polyp    |    800     |   15.34    |   200    |  15.06   |     -     |     -     |
-
-### Training commands
-
-To train models on a single server with one GPU. (default)
-
-```shell
-mim train mmseg ./configs/${CONFIG_FILE}
-```
-
-### Testing commands
-
-To test models on a single server with one GPU. (default)
-
-```shell
-mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
-
-You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-  - [x] Basic docstrings & proper citation
-  - [ ] Test-time correctness
-  - [x] A full README
-
-- [ ] Milestone 2: Indicates a successful model implementation.
-
-  - [ ] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-  - [ ] Unit tests
-  - [ ] Code polishing
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_kvasir-seg-aliyun-512x512.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_kvasir-seg-aliyun-512x512.py
deleted file mode 100644
index b59db95..0000000
--- a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_kvasir-seg-aliyun-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    './kvasir-seg-aliyun_512x512.py', 'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.kvasir-seg-aliyun_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_kvasir-seg-aliyun-512x512.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_kvasir-seg-aliyun-512x512.py
deleted file mode 100644
index 6c52668..0000000
--- a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_kvasir-seg-aliyun-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    './kvasir-seg-aliyun_512x512.py', 'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.kvasir-seg-aliyun_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_kvasir-seg-aliyun-512x512.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_kvasir-seg-aliyun-512x512.py
deleted file mode 100644
index a192a5b..0000000
--- a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_kvasir-seg-aliyun-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    './kvasir-seg-aliyun_512x512.py', 'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.kvasir-seg-aliyun_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_kvasir-seg-aliyun-512x512.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_kvasir-seg-aliyun-512x512.py
deleted file mode 100644
index 5325e1f..0000000
--- a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_kvasir-seg-aliyun-512x512.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    './kvasir-seg-aliyun_512x512.py', 'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.kvasir-seg-aliyun_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(
-        num_classes=2, loss_decode=dict(use_sigmoid=True), out_channels=1),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/kvasir-seg-aliyun_512x512.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/kvasir-seg-aliyun_512x512.py
deleted file mode 100644
index 5f86880..0000000
--- a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/configs/kvasir-seg-aliyun_512x512.py
+++ /dev/null
@@ -1,42 +0,0 @@
-dataset_type = 'KvasirSEGAliyunDataset'
-data_root = 'data/'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='train.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='val.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/datasets/kvasir-seg-aliyun_dataset.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/datasets/kvasir-seg-aliyun_dataset.py
deleted file mode 100644
index 198caf0..0000000
--- a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/datasets/kvasir-seg-aliyun_dataset.py
+++ /dev/null
@@ -1,30 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class KvasirSEGAliyunDataset(BaseSegDataset):
-    """KvasirSEGAliyunDataset dataset.
-
-    In segmentation map annotation for KvasirSEGAliyunDataset,
-    0 stands for  background,which is included in 2 categories.
-    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
-    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-        reduce_zero_label (bool): Whether to mark label zero as ignored.
-            Default to False..
-    """
-    METAINFO = dict(classes=('background', 'polyp'))
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/tools/prepare_dataset.py
deleted file mode 100644
index b230e7f..0000000
--- a/mmsegmentation/projects/medical/2d_image/endoscopy/kvasir_seg_aliyun/tools/prepare_dataset.py
+++ /dev/null
@@ -1,86 +0,0 @@
-import glob
-import os
-
-import numpy as np
-from PIL import Image
-
-root_path = 'data/'
-img_suffix = '.jpg'
-seg_map_suffix = '.jpg'
-save_img_suffix = '.png'
-save_seg_map_suffix = '.png'
-tgt_img_dir = os.path.join(root_path, 'images/train/')
-tgt_mask_dir = os.path.join(root_path, 'masks/train/')
-os.system('mkdir -p ' + tgt_img_dir)
-os.system('mkdir -p ' + tgt_mask_dir)
-
-
-def filter_suffix_recursive(src_dir, suffix):
-    # filter out file names and paths in source directory
-    suffix = '.' + suffix if '.' not in suffix else suffix
-    file_paths = glob.glob(
-        os.path.join(src_dir, '**', '*' + suffix), recursive=True)
-    file_names = [_.split('/')[-1] for _ in file_paths]
-    return sorted(file_paths), sorted(file_names)
-
-
-def convert_label(img, convert_dict):
-    arr = np.zeros_like(img, dtype=np.uint8)
-    for c, i in convert_dict.items():
-        arr[img == c] = i
-    return arr
-
-
-def convert_pics_into_pngs(src_dir, tgt_dir, suffix, convert='RGB'):
-    if not os.path.exists(tgt_dir):
-        os.makedirs(tgt_dir)
-
-    src_paths, src_names = filter_suffix_recursive(src_dir, suffix=suffix)
-    for i, (src_name, src_path) in enumerate(zip(src_names, src_paths)):
-        tgt_name = src_name.replace(suffix, save_img_suffix)
-        tgt_path = os.path.join(tgt_dir, tgt_name)
-        num = len(src_paths)
-        img = np.array(Image.open(src_path))
-        if len(img.shape) == 2:
-            pil = Image.fromarray(img).convert(convert)
-        elif len(img.shape) == 3:
-            pil = Image.fromarray(img)
-        else:
-            raise ValueError('Input image not 2D/3D: ', img.shape)
-
-        pil.save(tgt_path)
-        print(f'processed {i+1}/{num}.')
-
-
-def convert_label_pics_into_pngs(src_dir,
-                                 tgt_dir,
-                                 suffix,
-                                 convert_dict={
-                                     0: 0,
-                                     255: 1
-                                 }):
-    if not os.path.exists(tgt_dir):
-        os.makedirs(tgt_dir)
-
-    src_paths, src_names = filter_suffix_recursive(src_dir, suffix=suffix)
-    num = len(src_paths)
-    for i, (src_name, src_path) in enumerate(zip(src_names, src_paths)):
-        tgt_name = src_name.replace(suffix, save_seg_map_suffix)
-        tgt_path = os.path.join(tgt_dir, tgt_name)
-
-        img = np.array(Image.open(src_path).convert('L'))
-        img = convert_label(img, convert_dict)
-        Image.fromarray(img).save(tgt_path)
-        print(f'processed {i+1}/{num}.')
-
-
-if __name__ == '__main__':
-    convert_pics_into_pngs(
-        os.path.join(root_path, 'Kvasir-SEG/images'),
-        tgt_img_dir,
-        suffix=img_suffix)
-
-    convert_label_pics_into_pngs(
-        os.path.join(root_path, 'Kvasir-SEG/masks'),
-        tgt_mask_dir,
-        suffix=seg_map_suffix)
diff --git a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/README.md b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/README.md
deleted file mode 100644
index c2c61c4..0000000
--- a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/README.md
+++ /dev/null
@@ -1,158 +0,0 @@
-# Vessel Assessment and Measurement Platform for Images of the REtina
-
-## Description
-
-This project support **`Vessel Assessment and Measurement Platform for Images of the REtina`**, and the dataset used in this project can be downloaded from [here](https://vampire.computing.dundee.ac.uk/vesselseg.html).
-
-### Dataset Overview
-
-In order to promote evaluation of vessel segmentation on ultra-wide field-of-view (UWFV) fluorescein angriogram (FA) frames, we make public 8 frames from two different sequences, the manually annotated images and the result of our automatic vessel segmentation algorithm.
-
-### Original Statistic Information
-
-| Dataset name                                                     | Anatomical region | Task type    | Modality               | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                         |
-| ---------------------------------------------------------------- | ----------------- | ------------ | ---------------------- | ------------ | --------------------- | ---------------------- | ------------ | --------------------------------------------------------------- |
-| [Vampire](https://vampire.computing.dundee.ac.uk/vesselseg.html) | vessel            | segmentation | fluorescein angriogram | 2            | 8/-/-                 | yes/-/-                | 2017         | [CC-BY-NC 4.0](https://creativecommons.org/licenses/by-sa/4.0/) |
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |     8      |   96.75    |    -     |    -     |     -     |     -     |
-|   vessel   |     8      |    3.25    |    -     |    -     |     -     |     -     |
-
-Note:
-
-- `Pct` means percentage of pixels in this category in all pixels.
-
-### Visualization
-
-![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/fluorescein_angriogram/vampire/vampire_dataset.png)
-
-## Dataset Citation
-
-```bibtex
-
-@inproceedings{perez2011improving,
-  title={Improving vessel segmentation in ultra-wide field-of-view retinal fluorescein angiograms},
-  author={Perez-Rovira, Adria and Zutis, K and Hubschman, Jean Pierre and Trucco, Emanuele},
-  booktitle={2011 Annual International Conference of the IEEE Engineering in Medicine and Biology Society},
-  pages={2614--2617},
-  year={2011},
-  organization={IEEE}
-}
-
-@article{perez2011rerbee,
-  title={RERBEE: robust efficient registration via bifurcations and elongated elements applied to retinal fluorescein angiogram sequences},
-  author={Perez-Rovira, Adria and Cabido, Raul and Trucco, Emanuele and McKenna, Stephen J and Hubschman, Jean Pierre},
-  journal={IEEE Transactions on Medical Imaging},
-  volume={31},
-  number={1},
-  pages={140--150},
-  year={2011},
-  publisher={IEEE}
-}
-
-```
-
-### Prerequisites
-
-- Python v3.8
-- PyTorch v1.10.0
-- pillow(PIL) v9.3.0
-- scikit-learn(sklearn) v1.2.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-
-All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `vampire/` root directory, run the following line to add the current directory to `PYTHONPATH`:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset preparing
-
-- download dataset from [here](https://vampire.computing.dundee.ac.uk/vesselseg.html) and decompression data to path `'data/'`.
-- run script `"python tools/prepare_dataset.py"` to split dataset and change folder structure as below.
-- run script `python ../../tools/split_seg_dataset.py` to split dataset. For the Bacteria_detection dataset, as there is no test or validation dataset, we sample 20% samples from the whole dataset as the validation dataset and 80% samples for training data and make two filename lists `train.txt` and `val.txt`. As we set the random seed as the hard code, we eliminated the randomness, the dataset split actually can be reproducible.
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── fluorescein_angriogram
-  │   │   │   │   ├── vampire
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── train.txt
-  │   │   │   │   │   │   ├── val.txt
-  │   │   │   │   │   │   ├── images
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   ├── masks
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-```
-
-### Divided Dataset Information
-
-***Note: The table information below is divided by ourselves.***
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |     6      |   97.48    |    2     |  94.54   |     -     |     -     |
-|   vessel   |     6      |    2.52    |    2     |   5.46   |     -     |     -     |
-
-### Training commands
-
-To train models on a single server with one GPU. (default）
-
-```shell
-mim train mmseg ./configs/${CONFIG_PATH}
-```
-
-### Testing commands
-
-To test models on a single server with one GPU. (default)
-
-```shell
-mim test mmseg ./configs/${CONFIG_PATH}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-
-  - [x] Basic docstrings & proper citation
-
-  - [ ] Test-time correctness
-
-  - [x] A full README
-
-- [ ] Milestone 2: Indicates a successful model implementation.
-
-  - [ ] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-
-  - [ ] Unit tests
-
-  - [ ] Code polishing
-
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_vampire-512x512.py b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_vampire-512x512.py
deleted file mode 100755
index 7f5273a..0000000
--- a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_vampire-512x512.py
+++ /dev/null
@@ -1,19 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './vampire_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.vampire_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    pretrained=None,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_vampire-512x512.py b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_vampire-512x512.py
deleted file mode 100755
index 4382229..0000000
--- a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_vampire-512x512.py
+++ /dev/null
@@ -1,19 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './vampire_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.vampire_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=dict(size=img_scale),
-    pretrained=None,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_vampire-512x512.py b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_vampire-512x512.py
deleted file mode 100755
index 8d93e17..0000000
--- a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_vampire-512x512.py
+++ /dev/null
@@ -1,22 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './vampire_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.vampire_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    pretrained=None,
-    decode_head=dict(
-        num_classes=2,
-        loss_decode=dict(type='CrossEntropyLoss', use_sigmoid=True),
-        out_channels=1),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/vampire_512x512.py b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/vampire_512x512.py
deleted file mode 100755
index 4eda92f..0000000
--- a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/configs/vampire_512x512.py
+++ /dev/null
@@ -1,42 +0,0 @@
-dataset_type = 'VampireDataset'
-data_root = 'data'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='train.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='val.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/datasets/__init__.py b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/datasets/__init__.py
deleted file mode 100755
index 93f9cbf..0000000
--- a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/datasets/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-from .vampire_dataset import VampireDataset
-
-__all__ = ['VampireDataset']
diff --git a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/datasets/vampire_dataset.py b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/datasets/vampire_dataset.py
deleted file mode 100755
index 4d38040..0000000
--- a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/datasets/vampire_dataset.py
+++ /dev/null
@@ -1,28 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class VampireDataset(BaseSegDataset):
-    """VampireDataset dataset.
-
-    In segmentation map annotation for VampireDataset, 0 stands for background,
-    which is included in 2 categories. ``reduce_zero_label`` is fixed to
-    False. The ``img_suffix`` is fixed to '.png' and ``seg_map_suffix`` is
-    fixed to '.png'.
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-    """
-    METAINFO = dict(classes=('background', 'vessel'))
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/tools/prepare_dataset.py
deleted file mode 100644
index 2755b5d..0000000
--- a/mmsegmentation/projects/medical/2d_image/fluorescein_angriogram/vampire/tools/prepare_dataset.py
+++ /dev/null
@@ -1,44 +0,0 @@
-import os
-import shutil
-
-from PIL import Image
-
-path = 'data'
-
-if not os.path.exists(os.path.join(path, 'images', 'train')):
-    os.system(f'mkdir -p {os.path.join(path, "images", "train")}')
-
-if not os.path.exists(os.path.join(path, 'masks', 'train')):
-    os.system(f'mkdir -p {os.path.join(path, "masks", "train")}')
-
-origin_data_path = os.path.join(path, 'vesselSegmentation')
-
-imgs_amd14 = os.listdir(os.path.join(origin_data_path, 'AMD14'))
-imgs_ger7 = os.listdir(os.path.join(origin_data_path, 'GER7'))
-
-for img in imgs_amd14:
-    shutil.copy(
-        os.path.join(origin_data_path, 'AMD14', img),
-        os.path.join(path, 'images', 'train', img))
-    # copy GT
-    img_gt = img.replace('.png', '-GT.png')
-    shutil.copy(
-        os.path.join(origin_data_path, 'AMD14-GT', f'{img_gt}'),
-        os.path.join(path, 'masks', 'train', img))
-
-for img in imgs_ger7:
-    shutil.copy(
-        os.path.join(origin_data_path, 'GER7', img),
-        os.path.join(path, 'images', 'train', img))
-    # copy GT
-    img_gt = img.replace('.bmp', '-GT.png')
-    img = img.replace('bmp', 'png')
-    shutil.copy(
-        os.path.join(origin_data_path, 'GER7-GT', img_gt),
-        os.path.join(path, 'masks', 'train', img))
-
-imgs = os.listdir(os.path.join(path, 'images', 'train'))
-for img in imgs:
-    if not img.endswith('.png'):
-        im = Image.open(os.path.join(path, 'images', 'train', img))
-        im.save(os.path.join(path, 'images', 'train', img[:-4] + '.png'))
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/README.md b/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/README.md
deleted file mode 100644
index 85d8a3e..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/README.md
+++ /dev/null
@@ -1,155 +0,0 @@
-# DR HAGIS: Diabetic Retinopathy, Hypertension, Age-related macular degeneration and Glacuoma ImageS
-
-## Description
-
-This project supports **`DR HAGIS: Diabetic Retinopathy, Hypertension, Age-related macular degeneration and Glacuoma ImageS`**, which can be downloaded from [here](https://paperswithcode.com/dataset/dr-hagis).
-
-### Dataset Overview
-
-The DR HAGIS database has been created to aid the development of vessel extraction algorithms suitable for retinal screening programmes. Researchers are encouraged to test their segmentation algorithms using this database. All thirty-nine fundus images were obtained from a diabetic retinopathy screening programme in the UK. Hence, all images were taken from diabetic patients.
-
-Besides the fundus images, the manual segmentation of the retinal surface vessels is provided by an expert grader. These manually segmented images can be used as the ground truth to compare and assess the automatic vessel extraction algorithms. Masks of the FOV are provided as well to quantify the accuracy of vessel extraction within the FOV only. The images were acquired in different screening centers, therefore reflecting the range of image resolutions, digital cameras and fundus cameras used in the clinic. The fundus images were captured using a Topcon TRC-NW6s, Topcon TRC-NW8 or a Canon CR DGi fundus camera with a horizontal 45 degree field-of-view (FOV). The images are 4752x3168 pixels, 3456x2304 pixels, 3126x2136 pixels, 2896x1944 pixels or 2816x1880 pixels in size.
-
-### Original Statistic Information
-
-| Dataset name                                            | Anatomical region | Task type    | Modality           | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License |
-| ------------------------------------------------------- | ----------------- | ------------ | ------------------ | ------------ | --------------------- | ---------------------- | ------------ | ------- |
-| [DR HAGIS](https://paperswithcode.com/dataset/dr-hagis) | head and neck     | segmentation | fundus photography | 2            | 40/-/-                | yes/-/-                | 2017         | -       |
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |     40     |   96.38    |    -     |    -     |     -     |     -     |
-|   vessel   |     40     |    3.62    |    -     |    -     |     -     |     -     |
-
-Note:
-
-- `Pct` means percentage of pixels in this category in all pixels.
-
-### Visualization
-
-![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/fundus_photography/dr_hagis/dr_hagis_dataset.png)
-
-## Usage
-
-### Prerequisites
-
-- Python v3.8
-- PyTorch v1.10.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-
-All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `dr_hagis/` root directory, run the following line to add the current directory to `PYTHONPATH`:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset preparing
-
-- download dataset from [here](https://paperswithcode.com/dataset/dr-hagis) and decompress data to path `'data/'`.
-- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
-- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set can't be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── fundus_photography
-  │   │   │   │   ├── dr_hagis
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── train.txt
-  │   │   │   │   │   │   ├── val.txt
-  │   │   │   │   │   │   ├── images
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   ├── masks
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-```
-
-### Divided Dataset Information
-
-***Note: The table information below is divided by ourselves.***
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |     32     |   96.21    |    8     |  97.12   |     -     |     -     |
-|   vessel   |     32     |    3.79    |    8     |   2.88   |     -     |     -     |
-
-### Training commands
-
-Train models on a single server with one GPU.
-
-```shell
-mim train mmseg ./configs/${CONFIG_FILE}
-```
-
-### Testing commands
-
-Test models on a single server with one GPU.
-
-```shell
-mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
-
-You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
-
-## Dataset Citation
-
-If this work is helpful for your research, please consider citing the below paper.
-
-```
-@article{holm2017dr,
-  title={DR HAGIS—a fundus image database for the automatic extraction of retinal surface vessels from diabetic patients},
-  author={Holm, Sven and Russell, Greg and Nourrit, Vincent and McLoughlin, Niall},
-  journal={Journal of Medical Imaging},
-  volume={4},
-  number={1},
-  pages={014503--014503},
-  year={2017},
-  publisher={Society of Photo-Optical Instrumentation Engineers}
-}
-```
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-
-  - [x] Basic docstrings & proper citation
-
-  - [ ] Test-time correctness
-
-  - [x] A full README
-
-- [ ] Milestone 2: Indicates a successful model implementation.
-
-  - [ ] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-
-  - [ ] Unit tests
-
-  - [ ] Code polishing
-
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/dr-hagis_512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/dr-hagis_512x512.py
deleted file mode 100644
index 93b9638..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/dr-hagis_512x512.py
+++ /dev/null
@@ -1,42 +0,0 @@
-dataset_type = 'DRHAGISDataset'
-data_root = 'data/'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='train.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='val.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_dr-hagis-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_dr-hagis-512x512.py
deleted file mode 100644
index 9d14427..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_dr-hagis-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    './dr-hagis_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.dr-hagis_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_dr-hagis-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_dr-hagis-512x512.py
deleted file mode 100644
index 507ec74..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_dr-hagis-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    './dr-hagis_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.dr-hagis_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_dr-hagis-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_dr-hagis-512x512.py
deleted file mode 100644
index 092ae00..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_dr-hagis-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    './dr-hagis_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.dr-hagis_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/datasets/dr-hagis_dataset.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/datasets/dr-hagis_dataset.py
deleted file mode 100644
index 9659f0b..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/datasets/dr-hagis_dataset.py
+++ /dev/null
@@ -1,27 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class DRHAGISDataset(BaseSegDataset):
-    """DRHAGISDataset dataset.
-
-    In segmentation map annotation for DRHAGISDataset,
-    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
-    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
-
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-    """
-    METAINFO = dict(classes=('background', 'vessel'))
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=False,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/tools/prepare_dataset.py
deleted file mode 100755
index 51f4df7..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/dr_hagis/tools/prepare_dataset.py
+++ /dev/null
@@ -1,41 +0,0 @@
-import glob
-import os
-import shutil
-
-import mmengine
-import numpy as np
-from PIL import Image
-
-root_path = 'data/'
-img_suffix = '.jpg'
-seg_map_suffix = '_manual_orig.png'
-save_img_suffix = '.png'
-save_seg_map_suffix = '.png'
-
-x_train = glob.glob(os.path.join('data/DRHAGIS/**/*' + img_suffix))
-
-mmengine.mkdir_or_exist(root_path + 'images/train/')
-mmengine.mkdir_or_exist(root_path + 'masks/train/')
-
-D3_palette = {0: (0, 0, 0), 1: (1, 1, 1)}
-D3_invert_palette = {v: k for k, v in D3_palette.items()}
-D2_255_convert_dict = {0: 0, 255: 1}
-
-part_dir_dict = {0: 'train/', 1: 'val/'}
-for ith, part in enumerate([x_train]):
-    part_dir = part_dir_dict[ith]
-    for img in part:
-        basename = os.path.basename(img)
-        shutil.copy(
-            img, root_path + 'images/' + part_dir + basename.split('.')[0] +
-            save_img_suffix)
-        mask_path = root_path + 'DRHAGIS/Manual_Segmentations/' + basename.split(  # noqa
-            '.')[0] + seg_map_suffix
-        label = np.array(Image.open(mask_path))
-
-        save_mask_path = root_path + 'masks/' + part_dir + basename.split(
-            '.')[0] + save_seg_map_suffix  # noqa
-        mask = np.array(Image.open(mask_path)).astype(np.uint8)
-        mask[mask == 255] = 1
-        mask = Image.fromarray(mask)
-        mask.save(save_mask_path)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/README.md b/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/README.md
deleted file mode 100644
index e834508..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/README.md
+++ /dev/null
@@ -1,167 +0,0 @@
-# Glaucoma grAding from Multi-Modality imAges Task3
-
-## Description
-
-This project support **`Glaucoma grAding from Multi-Modality imAges Task3`**, and the dataset used in this project can be downloaded from [here](https://aistudio.baidu.com/aistudio/competition/detail/121/0/datasets).
-
-### Dataset Overview
-
-This regular-challenge dataset was provided by Sun Yat-sen Ophthalmic Center, Sun Yat-sen University, Guangzhou, China. The dataset contains 200 fundus color images: 100 pairs in the training set and 100 pairs in the test set.
-
-### Original Statistic Information
-
-| Dataset name                                                                        | Anatomical region | Task type    | Modality        | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                         |
-| ----------------------------------------------------------------------------------- | ----------------- | ------------ | --------------- | ------------ | --------------------- | ---------------------- | ------------ | --------------------------------------------------------------- |
-| [GammaTask3](https://aistudio.baidu.com/aistudio/competition/detail/121/0/datasets) | eye               | segmentation | fundus photophy | 3            | 100/-/100             | yes/-/-                | 2021         | [CC-BY-NC 4.0](https://creativecommons.org/licenses/by-sa/4.0/) |
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |    100     |   99.02    |    -     |    -     |     -     |     -     |
-| optic disc |    100     |    0.67    |    -     |    -     |     -     |     -     |
-| optic cup  |    100     |    0.31    |    -     |    -     |     -     |     -     |
-
-Note:
-
-- `Pct` means percentage of pixels in this category in all pixels.
-
-### Visualization
-
-![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/fundus_photography/gamma3/gamma3_dataset.png)
-
-## Dataset Citation
-
-```bibtex
-@article{fu2018joint,
-  title={Joint optic disc and cup segmentation based on multi-label deep network and polar transformation},
-  author={Fu, Huazhu and Cheng, Jun and Xu, Yanwu and Wong, Damon Wing Kee and Liu, Jiang and Cao, Xiaochun},
-  journal={IEEE transactions on medical imaging},
-  volume={37},
-  number={7},
-  pages={1597--1605},
-  year={2018},
-  publisher={IEEE}
-}
-
-@article{sevastopolsky2017optic,
-  title={Optic disc and cup segmentation methods for glaucoma detection with modification of U-Net convolutional neural network},
-  author={Sevastopolsky, Artem},
-  journal={Pattern Recognition and Image Analysis},
-  volume={27},
-  pages={618--624},
-  year={2017},
-  publisher={Springer}
-}
-```
-
-### Prerequisites
-
-- Python v3.8
-- PyTorch v1.10.0
-- pillow(PIL) v9.3.0
-- scikit-learn(sklearn) v1.2.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-
-All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `gammm3/` root directory, run the following line to add the current directory to `PYTHONPATH`:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset preparing
-
-- download dataset from [here](https://aistudio.baidu.com/aistudio/competition/detail/121/0/datasets) and decompression data to path `'data/'`.
-- run script `"python tools/prepare_dataset.py"` to split dataset and change folder structure as below.
-- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set can't be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── fundus_photography
-  │   │   │   │   ├── gamma3
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── train.txt
-  │   │   │   │   │   │   ├── val.txt
-  │   │   │   │   │   │   ├── images
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   │   ├── test
-  │   │   │   │   |   │   │   │   ├── yyy.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── yyy.png
-  │   │   │   │   │   │   ├── masks
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-```
-
-### Divided Dataset Information
-
-***Note: The table information below is divided by ourselves.***
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |     80     |   99.01    |    20    |  99.07   |     -     |     -     |
-| optic disc |     80     |    0.68    |    20    |   0.63   |     -     |     -     |
-| optic cup  |     80     |    0.32    |    20    |   0.31   |     -     |     -     |
-
-### Training commands
-
-To train models on a single server with one GPU. (default）
-
-```shell
-mim train mmseg ./configs/${CONFIG_PATH}
-```
-
-### Testing commands
-
-To test models on a single server with one GPU. (default）
-
-```shell
-mim test mmseg ./configs/${CONFIG_PATH}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
-
-You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-
-  - [x] Basic docstrings & proper citation
-
-  - [ ] Test-time correctness
-
-  - [x] A full README
-
-- [ ] Milestone 2: Indicates a successful model implementation.
-
-  - [ ] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-
-  - [ ] Unit tests
-
-  - [ ] Code polishing
-
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_gamma3-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_gamma3-512x512.py
deleted file mode 100644
index 0daac51..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_gamma3-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './gamma3_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.gamma3_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=3),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_gamma3-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_gamma3-512x512.py
deleted file mode 100644
index 8a25cd0..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_gamma3-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './gamma3_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.gamma3_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=3),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_gamma3-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_gamma3-512x512.py
deleted file mode 100644
index ea64843..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_gamma3-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './gamma3_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.gamma3_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=3),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/gamma3_512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/gamma3_512x512.py
deleted file mode 100644
index d23ab55..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/configs/gamma3_512x512.py
+++ /dev/null
@@ -1,42 +0,0 @@
-dataset_type = 'Gamma3Dataset'
-data_root = 'data/'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='train.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='val.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/datasets/gamma3_dataset.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/datasets/gamma3_dataset.py
deleted file mode 100644
index 56cbdd6..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/datasets/gamma3_dataset.py
+++ /dev/null
@@ -1,30 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class Gamma3Dataset(BaseSegDataset):
-    """Gamma3Dataset dataset.
-
-    In segmentation map annotation for Gamma3Dataset,
-    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
-    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
-
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-        reduce_zero_label (bool): Whether to mark label zero as ignored.
-            Default to False.
-    """
-    METAINFO = dict(classes=('background', 'disc', 'cup'))
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/tools/prepare_dataset.py
deleted file mode 100644
index eb820b6..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/gamma3/tools/prepare_dataset.py
+++ /dev/null
@@ -1,107 +0,0 @@
-import glob
-import os
-
-import numpy as np
-from PIL import Image
-
-root_path = 'data/'
-img_suffix = '.jpg'
-seg_map_suffix = '.png'
-save_img_suffix = '.png'
-save_seg_map_suffix = '.png'
-tgt_img_train_dir = os.path.join(root_path, 'images/train/')
-tgt_mask_train_dir = os.path.join(root_path, 'masks/train/')
-tgt_img_test_dir = os.path.join(root_path, 'images/test/')
-os.system('mkdir -p ' + tgt_img_train_dir)
-os.system('mkdir -p ' + tgt_mask_train_dir)
-os.system('mkdir -p ' + tgt_img_test_dir)
-
-
-def filter_suffix_recursive(src_dir, suffix):
-    # filter out file names and paths in source directory
-    suffix = '.' + suffix if '.' not in suffix else suffix
-    file_paths = glob.glob(
-        os.path.join(src_dir, '**/*' + suffix), recursive=True)
-    file_names = [_.split('/')[-1] for _ in file_paths]
-    return sorted(file_paths), sorted(file_names)
-
-
-def convert_label(img, convert_dict):
-    arr = np.zeros_like(img, dtype=np.uint8)
-    for c, i in convert_dict.items():
-        arr[img == c] = i
-    return arr
-
-
-def convert_pics_into_pngs(src_dir, tgt_dir, suffix, convert='RGB'):
-    if not os.path.exists(tgt_dir):
-        os.makedirs(tgt_dir)
-    src_paths, src_names = filter_suffix_recursive(src_dir, suffix=suffix)
-
-    for i, (src_name, src_path) in enumerate(zip(src_names, src_paths)):
-        tgt_name = src_name.replace(suffix, save_img_suffix)
-        tgt_path = os.path.join(tgt_dir, tgt_name)
-        num = len(src_paths)
-        img = np.array(Image.open(src_path))
-        if len(img.shape) == 2:
-            pil = Image.fromarray(img).convert(convert)
-        elif len(img.shape) == 3:
-            pil = Image.fromarray(img)
-        else:
-            raise ValueError('Input image not 2D/3D: ', img.shape)
-
-        pil.save(tgt_path)
-        print(f'processed {i+1}/{num}.')
-
-
-def convert_label_pics_into_pngs(src_dir,
-                                 tgt_dir,
-                                 suffix,
-                                 convert_dict={
-                                     0: 2,
-                                     128: 1,
-                                     255: 0
-                                 }):
-    if not os.path.exists(tgt_dir):
-        os.makedirs(tgt_dir)
-
-    src_paths, src_names = filter_suffix_recursive(src_dir, suffix=suffix)
-    num = len(src_paths)
-    for i, (src_name, src_path) in enumerate(zip(src_names, src_paths)):
-        tgt_name = src_name.replace(suffix, save_seg_map_suffix)
-        tgt_path = os.path.join(tgt_dir, tgt_name)
-
-        img = np.array(Image.open(src_path))
-        img = convert_label(img, convert_dict)
-        Image.fromarray(img).save(tgt_path)
-        print(f'processed {i+1}/{num}.')
-
-
-if __name__ == '__main__':
-
-    convert_pics_into_pngs(
-        os.path.join(
-            root_path,
-            'task3_disc_cup_segmentation/training/fundus color images/'),
-        tgt_img_train_dir,
-        suffix=img_suffix)
-
-    convert_pics_into_pngs(
-        os.path.join(
-            root_path,
-            'task3_disc_cup_segmentation/testing/fundus color images/'),
-        tgt_img_test_dir,
-        suffix=img_suffix)
-
-    convert_label_pics_into_pngs(
-        os.path.join(root_path,
-                     'task3_disc_cup_segmentation/training/Disc_Cup_Mask/'),
-        tgt_mask_train_dir,
-        suffix=seg_map_suffix,
-        convert_dict={
-            0: 2,
-            128: 1,
-            255: 0
-        })
-    # original: [0, 128, 255] for ['optic cup', 'optic disc', 'background']
-    # converted: [0, 1, 2] for ['background', 'optic disc', 'optic cup']
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/README.md b/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/README.md
deleted file mode 100644
index 6f09203..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/README.md
+++ /dev/null
@@ -1,140 +0,0 @@
-# ORVS (Online Retinal image for Vessel Segmentation (ORVS))
-
-## Description
-
-This project supports **`ORVS (Online Retinal image for Vessel Segmentation (ORVS))`**, which can be downloaded from [here](https://opendatalab.org.cn/ORVS).
-
-### Dataset Overview
-
-The ORVS dataset is a newly established collaboration between the Department of Computer Science and the Department of Vision Science at the University of Calgary. The dataset contains 49 images collected from a clinic in Calgary, Canada, consisting of 42 training images and 7 testing images. All images were obtained using a Zeiss Visucam 200 with a 30-degree field of view (FOV). The image size is 1444×1444 pixels with 24 bits per pixel. The images are stored in JPEG format with low compression, which is common in ophthalmic practice. All images were manually traced by an expert who has been working in the field of retinal image analysis and has been trained to mark all pixels belonging to retinal vessels. The Windows Paint 3D tool was used for manual image annotation.
-
-### Original Statistic Information
-
-| Dataset name                                           | Anatomical region | Task type    | Modality           | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License |
-| ------------------------------------------------------ | ----------------- | ------------ | ------------------ | ------------ | --------------------- | ---------------------- | ------------ | ------- |
-| [Bactteria detection](https://opendatalab.org.cn/ORVS) | bacteria          | segmentation | fundus photography | 2            | 130/-/72              | yes/-/yes              | 2020         | -       |
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |    130     |   94.83    |    -     |    -     |    72     |   94.25   |
-|   vessel   |    130     |    5.17    |    -     |    -     |    72     |   5.75    |
-
-Note:
-
-- `Pct` means percentage of pixels in this category in all pixels.
-
-### Visualization
-
-![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/fundus_photography/orvs/ORVS_dataset.png)
-
-### Prerequisites
-
-- Python v3.8
-- PyTorch v1.10.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-
-All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `orvs/` root directory, run the following line to add the current directory to `PYTHONPATH`:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset preparing
-
-- Clone this [repository](https://github.com/AbdullahSarhan/ICPRVessels), then move `Vessels-Datasets` to `data/`.
-- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
-- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set can't be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── fundus_photography
-  │   │   │   │   ├── orvs
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── train.txt
-  │   │   │   │   │   │   ├── test.txt
-  │   │   │   │   │   │   ├── images
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   ├── masks
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-```
-
-### Training commands
-
-Train models on a single server with one GPU.
-
-```shell
-mim train mmseg ./configs/${CONFIG_FILE}
-```
-
-### Testing commands
-
-Test models on a single server with one GPU.
-
-```shell
-mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
-
-You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
-
-## Dataset Citation
-
-If this work is helpful for your research, please consider citing the below paper.
-
-```
-@inproceedings{sarhan2021transfer,
-  title={Transfer learning through weighted loss function and group normalization for vessel segmentation from retinal images},
-  author={Sarhan, Abdullah and Rokne, Jon and Alhajj, Reda and Crichton, Andrew},
-  booktitle={2020 25th International Conference on Pattern Recognition (ICPR)},
-  pages={9211--9218},
-  year={2021},
-  organization={IEEE}
-}
-```
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-
-  - [x] Basic docstrings & proper citation
-
-  - [ ] Test-time correctness
-
-  - [x] A full README
-
-- [ ] Milestone 2: Indicates a successful model implementation.
-
-  - [ ] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-
-  - [ ] Unit tests
-
-  - [ ] Code polishing
-
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_orvs-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_orvs-512x512.py
deleted file mode 100644
index 662f837..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_orvs-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    './orvs_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.orvs_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_orvs-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_orvs-512x512.py
deleted file mode 100644
index c47cdb6..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_orvs-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    './orvs_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.orvs_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_orvs-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_orvs-512x512.py
deleted file mode 100644
index 1097aad..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_orvs-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    './orvs_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.orvs_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/orvs_512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/orvs_512x512.py
deleted file mode 100644
index a5594de..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/configs/orvs_512x512.py
+++ /dev/null
@@ -1,42 +0,0 @@
-dataset_type = 'ORVSDataset'
-data_root = 'data/'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='train.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='test.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/datasets/orvs_dataset.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/datasets/orvs_dataset.py
deleted file mode 100644
index e915ae4..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/datasets/orvs_dataset.py
+++ /dev/null
@@ -1,27 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class ORVSDataset(BaseSegDataset):
-    """ORVSDataset dataset.
-
-    In segmentation map annotation for ORVSDataset,
-    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
-    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
-
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-    """
-    METAINFO = dict(classes=('background', 'vessel'))
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=False,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/tools/prepare_dataset.py
deleted file mode 100755
index f902d87..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/orvs/tools/prepare_dataset.py
+++ /dev/null
@@ -1,55 +0,0 @@
-import glob
-import os
-
-import numpy as np
-from PIL import Image
-
-root_path = 'data/'
-img_suffix = '.jpg'
-seg_map_suffix_list = ['.jpg', '.png', '.tif']
-save_img_suffix = '.png'
-save_seg_map_suffix = '.png'
-
-x_train = glob.glob(
-    os.path.join('data/Vessels-Datasets/*/Train/Original/Images/*' +
-                 img_suffix))
-x_test = glob.glob(
-    os.path.join('data/Vessels-Datasets/*/Test/Original/Images/*' +
-                 img_suffix))
-
-os.system('mkdir -p ' + root_path + 'images/train/')
-os.system('mkdir -p ' + root_path + 'images/test/')
-os.system('mkdir -p ' + root_path + 'masks/train/')
-os.system('mkdir -p ' + root_path + 'masks/test/')
-
-part_dir_dict = {0: 'train/', 1: 'test/'}
-for ith, part in enumerate([x_train, x_test]):
-    part_dir = part_dir_dict[ith]
-    for img in part:
-        type_name = img.split('/')[-5]
-        basename = type_name + '_' + os.path.basename(img)
-        save_img_path = root_path + 'images/' + part_dir + basename.split(
-            '.')[0] + save_img_suffix
-        Image.open(img).save(save_img_path)
-
-        for seg_map_suffix in seg_map_suffix_list:
-            if os.path.exists('/'.join(img.split('/')[:-1]).replace(
-                    'Images', 'Labels')):
-                mask_path = img.replace('Images', 'Labels').replace(
-                    img_suffix, seg_map_suffix)
-            else:
-                mask_path = img.replace('Images', 'labels').replace(
-                    img_suffix, seg_map_suffix)
-            if os.path.exists(mask_path):
-                break
-        save_mask_path = root_path + 'masks/' + part_dir + basename.split(
-            '.')[0] + save_seg_map_suffix
-        masks = np.array(Image.open(mask_path).convert('L')).astype(np.uint8)
-        if len(np.unique(masks)) == 2 and 1 in np.unique(masks):
-            print(np.unique(masks))
-            pass
-        else:
-            masks[masks < 128] = 0
-            masks[masks >= 128] = 1
-        masks = Image.fromarray(masks)
-        masks.save(save_mask_path)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/README.md b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/README.md
deleted file mode 100644
index 0aea9b0..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/README.md
+++ /dev/null
@@ -1,135 +0,0 @@
-# Retinal Images vessel Tree Extraction (RITE)
-
-## Description
-
-This project supports **`Retinal Images vessel Tree Extraction (RITE) `**, which can be downloaded from [here](https://opendatalab.com/RITE).
-
-### Dataset Overview
-
-The RITE (Retinal Images vessel Tree Extraction) is a database that enables comparative studies on segmentation or classification of arteries and veins on retinal fundus images, which is established based on the public available DRIVE database (Digital Retinal Images for Vessel Extraction). RITE contains 40 sets of images, equally separated into a training subset and a test subset, the same as DRIVE. The two subsets are built from the corresponding two subsets in DRIVE. For each set, there is a fundus photograph, a vessel reference standard. The fundus photograph is inherited from DRIVE. For the training set, the vessel reference standard is a modified version of 1st_manual from DRIVE. For the test set, the vessel reference standard is 2nd_manual from DRIVE.
-
-### Statistic Information
-
-| Dataset Name                         | Anatomical Region | Task Type    | Modality           | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                         |
-| ------------------------------------ | ----------------- | ------------ | ------------------ | ------------ | --------------------- | ---------------------- | ------------ | --------------------------------------------------------------- |
-| [Rite](https://opendatalab.com/RITE) | head_and_neck     | segmentation | fundus_photography | 2            | 20/-/20               | yes/-/yes              | 2013         | [CC-BY-NC 4.0](https://creativecommons.org/licenses/by-sa/4.0/) |
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |     20     |   91.61    |    -     |    -     |    20     |   91.58   |
-|   vessel   |     20     |    8.39    |    -     |    -     |    20     |   8.42    |
-
-Note:
-
-- `Pct` means percentage of pixels in this category in all pixels.
-
-### Visualization
-
-![rite](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/fundus_photography/rite/rite_dataset.png?raw=true)
-
-### Dataset Citation
-
-```
-@InProceedings{10.1007/978-3-642-40763-5_54,
-	author={Hu, Qiao and Abr{\`a}moff, Michael D. and Garvin, Mona K.},
-	title={Automated Separation of Binary Overlapping Trees in Low-Contrast Color Retinal Images},
-	booktitle={Medical Image Computing and Computer-Assisted Intervention -- MICCAI 2013},
-	year={2013},
-	pages={436--443},
-}
-
-
-```
-
-### Prerequisites
-
-- Python v3.8
-- PyTorch v1.10.0
-- pillow(PIL) v9.3.0 9.3.0
-- scikit-learn(sklearn) v1.2.0 1.2.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-
-All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `rite/` root directory, run the following line to add the current directory to `PYTHONPATH`:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset Preparing
-
-- download dataset from [here](https://opendatalab.com/RITE) and decompress data to path `'data/'`.
-- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
-- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set cannot be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── fundus_photography
-  │   │   │   │   ├── rite
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── train.txt
-  │   │   │   │   │   │   ├── val.txt
-  │   │   │   │   │   │   ├── images
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   ├── masks
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-```
-
-### Training commands
-
-To train models on a single server with one GPU. (default)
-
-```shell
-mim train mmseg ./configs/${CONFIG_FILE}
-```
-
-### Testing commands
-
-To test models on a single server with one GPU. (default)
-
-```shell
-mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
-
-You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-  - [x] Basic docstrings & proper citation
-  - [ ] Test-time correctness
-  - [x] A full README
-
-- [ ] Milestone 2: Indicates a successful model implementation.
-
-  - [ ] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-  - [ ] Unit tests
-  - [ ] Code polishing
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_rite-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_rite-512x512.py
deleted file mode 100644
index 27dd436..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_rite-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './rite_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.rite_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_rite-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_rite-512x512.py
deleted file mode 100644
index 48f6f97..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_rite-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './rite_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.rite_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_rite-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_rite-512x512.py
deleted file mode 100644
index 5f5b24b..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_rite-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './rite_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.rite_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_rite-512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_rite-512x512.py
deleted file mode 100644
index bf66b6f..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_rite-512x512.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './rite_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.rite_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(
-        num_classes=2, loss_decode=dict(use_sigmoid=True), out_channels=1),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/rite_512x512.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/rite_512x512.py
deleted file mode 100644
index 02f620c..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/configs/rite_512x512.py
+++ /dev/null
@@ -1,42 +0,0 @@
-dataset_type = 'RITEDataset'
-data_root = 'data/'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='train.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='test.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/datasets/rite_dataset.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/datasets/rite_dataset.py
deleted file mode 100644
index 99f688d..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/datasets/rite_dataset.py
+++ /dev/null
@@ -1,31 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class RITEDataset(BaseSegDataset):
-    """RITEDataset dataset.
-
-    In segmentation map annotation for RITEDataset,
-    0 stands for background, which is included in 2 categories.
-    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
-    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
-
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-        reduce_zero_label (bool): Whether to mark label zero as ignored.
-            Default to False.
-    """
-    METAINFO = dict(classes=('background', 'vessel'))
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/tools/prepare_dataset.py
deleted file mode 100644
index ca7e996..0000000
--- a/mmsegmentation/projects/medical/2d_image/fundus_photography/rite/tools/prepare_dataset.py
+++ /dev/null
@@ -1,98 +0,0 @@
-import glob
-import os
-
-import numpy as np
-from PIL import Image
-
-root_path = 'data/'
-img_suffix = '.tif'
-seg_map_suffix = '.png'
-save_img_suffix = '.png'
-save_seg_map_suffix = '.png'
-src_img_train_dir = os.path.join(root_path, 'AV_groundTruth/training/images/')
-src_img_test_dir = os.path.join(root_path, 'AV_groundTruth/test/images/')
-src_mask_train_dir = os.path.join(root_path, 'AV_groundTruth/training/vessel/')
-src_mask_test_dir = os.path.join(root_path, 'AV_groundTruth/test/vessel/')
-
-tgt_img_train_dir = os.path.join(root_path, 'images/train/')
-tgt_mask_train_dir = os.path.join(root_path, 'masks/train/')
-tgt_img_test_dir = os.path.join(root_path, 'images/test/')
-tgt_mask_test_dir = os.path.join(root_path, 'masks/test/')
-os.system('mkdir -p ' + tgt_img_train_dir)
-os.system('mkdir -p ' + tgt_mask_train_dir)
-os.system('mkdir -p ' + tgt_img_test_dir)
-os.system('mkdir -p ' + tgt_mask_test_dir)
-
-
-def filter_suffix_recursive(src_dir, suffix):
-    # filter out file names and paths in source directory
-    suffix = '.' + suffix if '.' not in suffix else suffix
-    file_paths = glob.glob(
-        os.path.join(src_dir, '**', '*' + suffix), recursive=True)
-    file_names = [_.split('/')[-1] for _ in file_paths]
-    return sorted(file_paths), sorted(file_names)
-
-
-def convert_label(img, convert_dict):
-    arr = np.zeros_like(img, dtype=np.uint8)
-    for c, i in convert_dict.items():
-        arr[img == c] = i
-    return arr
-
-
-def convert_pics_into_pngs(src_dir, tgt_dir, suffix, convert='RGB'):
-    if not os.path.exists(tgt_dir):
-        os.makedirs(tgt_dir)
-
-    src_paths, src_names = filter_suffix_recursive(src_dir, suffix=suffix)
-    for i, (src_name, src_path) in enumerate(zip(src_names, src_paths)):
-        tgt_name = src_name.replace(suffix, save_img_suffix)
-        tgt_path = os.path.join(tgt_dir, tgt_name)
-        num = len(src_paths)
-        img = np.array(Image.open(src_path))
-        if len(img.shape) == 2:
-            pil = Image.fromarray(img).convert(convert)
-        elif len(img.shape) == 3:
-            pil = Image.fromarray(img)
-        else:
-            raise ValueError('Input image not 2D/3D: ', img.shape)
-
-        pil.save(tgt_path)
-        print(f'processed {i+1}/{num}.')
-
-
-def convert_label_pics_into_pngs(src_dir,
-                                 tgt_dir,
-                                 suffix,
-                                 convert_dict={
-                                     0: 0,
-                                     255: 1
-                                 }):
-    if not os.path.exists(tgt_dir):
-        os.makedirs(tgt_dir)
-
-    src_paths, src_names = filter_suffix_recursive(src_dir, suffix=suffix)
-    num = len(src_paths)
-    for i, (src_name, src_path) in enumerate(zip(src_names, src_paths)):
-        tgt_name = src_name.replace(suffix, save_seg_map_suffix)
-        tgt_path = os.path.join(tgt_dir, tgt_name)
-
-        img = np.array(Image.open(src_path))
-        img = convert_label(img, convert_dict)
-        Image.fromarray(img).save(tgt_path)
-        print(f'processed {i+1}/{num}.')
-
-
-if __name__ == '__main__':
-
-    convert_pics_into_pngs(
-        src_img_train_dir, tgt_img_train_dir, suffix=img_suffix)
-
-    convert_pics_into_pngs(
-        src_img_test_dir, tgt_img_test_dir, suffix=img_suffix)
-
-    convert_label_pics_into_pngs(
-        src_mask_train_dir, tgt_mask_train_dir, suffix=seg_map_suffix)
-
-    convert_label_pics_into_pngs(
-        src_mask_test_dir, tgt_mask_test_dir, suffix=seg_map_suffix)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/README.md b/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/README.md
deleted file mode 100644
index 97c4a0f..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/README.md
+++ /dev/null
@@ -1,123 +0,0 @@
-# breastCancerCellSegmentation
-
-## Description
-
-This project supports **`breastCancerCellSegmentation`**, which can be downloaded from [here](https://www.heywhale.com/mw/dataset/5e9e9b35ebb37f002c625423).
-
-### Dataset Overview
-
-This dataset, with 58 H&E-stained histopathology images was used for breast cancer cell detection and associated real-world data.
-Conventional histology uses a combination of hematoxylin and eosin stains, commonly referred to as H&E. These images are stained because most cells are inherently transparent with little or no intrinsic pigment.
-Certain special stains selectively bind to specific components and can be used to identify biological structures such as cells.
-
-### Original Statistic Information
-
-| Dataset name                                                                                 | Anatomical region | Task type    | Modality       | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                         |
-| -------------------------------------------------------------------------------------------- | ----------------- | ------------ | -------------- | ------------ | --------------------- | ---------------------- | ------------ | --------------------------------------------------------------- |
-| [breastCancerCellSegmentation](https://www.heywhale.com/mw/dataset/5e9e9b35ebb37f002c625423) | cell              | segmentation | histopathology | 2            | 58/-/-                | yes/-/-                | 2020         | [CC-BY-NC 4.0](https://creativecommons.org/licenses/by-sa/4.0/) |
-
-|    Class Name    | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-|    background    |     58     |   98.37    |    -     |    -     |     -     |     -     |
-| breastCancerCell |     58     |    1.63    |    -     |    -     |     -     |     -     |
-
-Note:
-
-- `Pct` means percentage of pixels in this category in all pixels.
-
-### Visualization
-
-![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/histopathology/breastCancerCellSegmentation/breastCancerCellSegmentation_dataset.png)
-
-## Usage
-
-### Prerequisites
-
-- Python v3.8
-- PyTorch v1.10.0
-- pillow (PIL) v9.3.0
-- scikit-learn (sklearn) v1.2.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0
-
-All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `breastCancerCellSegmentation/` root directory, run the following line to add the current directory to `PYTHONPATH`:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset Preparing
-
-- Download dataset from [here](https://www.heywhale.com/mw/dataset/5e9e9b35ebb37f002c625423) and save it to the `data/` directory .
-- Decompress data to path `data/`. This will create a new folder named `data/breastCancerCellSegmentation/`, which contains the original image data.
-- run script `python tools/prepare_dataset.py` to format data and change folder structure as below.
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── histopathology
-  │   │   │   │   ├── breastCancerCellSegmentation
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── breastCancerCellSegmentation
-  |   │   │   │   │   │   │   ├── train.txt
-  |   │   │   │   │   │   │   ├── val.txt
-  |   │   │   │   │   │   │   ├── images
-  |   │   │   │   │   │   │   |   ├── xxx.tif
-  |   │   │   │   │   │   │   ├── masks
-  |   │   │   │   │   │   │   |   ├── xxx.TIF
-
-```
-
-### Training commands
-
-Train models on a single server with one GPU.
-
-```shell
-mim train mmseg ./configs/${CONFIG_FILE}
-```
-
-### Testing commands
-
-Test models on a single server with one GPU.
-
-```shell
-mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-
-  - [x] Basic docstrings & proper citation
-
-  - [x] Test-time correctness
-
-  - [x] A full README
-
-- [ ] Milestone 2: Indicates a successful model implementation.
-
-  - [ ] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-
-  - [ ] Unit tests
-
-  - [ ] Code polishing
-
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/breastCancerCellSegmentation_512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/breastCancerCellSegmentation_512x512.py
deleted file mode 100644
index 1cf0fcc..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/breastCancerCellSegmentation_512x512.py
+++ /dev/null
@@ -1,42 +0,0 @@
-dataset_type = 'breastCancerCellSegmentationDataset'
-data_root = 'data/breastCancerCellSegmentation'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile', imdecode_backend='tifffile'),
-    dict(type='LoadAnnotations', imdecode_backend='tifffile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile', imdecode_backend='tifffile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations', imdecode_backend='tifffile'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='train.txt',
-        data_prefix=dict(img_path='images', seg_map_path='masks'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='val.txt',
-        data_prefix=dict(img_path='images', seg_map_path='masks'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_breastCancerCellSegmentation-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_breastCancerCellSegmentation-512x512.py
deleted file mode 100644
index 55d1708..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_breastCancerCellSegmentation-512x512.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    './breastCancerCellSegmentation_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.breastCancerCellSegmentation_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_breastCancerCellSegmentation-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_breastCancerCellSegmentation-512x512.py
deleted file mode 100644
index cf28aad..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_breastCancerCellSegmentation-512x512.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    './breastCancerCellSegmentation_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.breastCancerCellSegmentation_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_breastCancerCellSegmentation-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_breastCancerCellSegmentation-512x512.py
deleted file mode 100644
index 29aaff3..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_breastCancerCellSegmentation-512x512.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    './breastCancerCellSegmentation_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.breastCancerCellSegmentation_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/datasets/breastCancerCellSegmentation_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/datasets/breastCancerCellSegmentation_dataset.py
deleted file mode 100644
index eeceb63..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/datasets/breastCancerCellSegmentation_dataset.py
+++ /dev/null
@@ -1,30 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class breastCancerCellSegmentationDataset(BaseSegDataset):
-    """breastCancerCellSegmentationDataset dataset.
-
-    In segmentation map annotation for breastCancerCellSegmentationDataset,
-    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
-    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
-
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-        reduce_zero_label (bool): Whether to mark label zero as ignored.
-            Default to False.
-    """
-    METAINFO = dict(classes=('background', 'breastCancerCell'))
-
-    def __init__(self,
-                 img_suffix='_ccd.tif',
-                 seg_map_suffix='.TIF',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/tools/prepare_dataset.py
deleted file mode 100644
index 09cc689..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/breastCancerCellSegmentation/tools/prepare_dataset.py
+++ /dev/null
@@ -1,36 +0,0 @@
-import argparse
-import glob
-import os
-
-from sklearn.model_selection import train_test_split
-
-
-def save_anno(img_list, file_path, suffix):
-    # 只保留文件名，不保留后缀
-    img_list = [x.split('/')[-1][:-len(suffix)] for x in img_list]
-
-    with open(file_path, 'w') as file_:
-        for x in list(img_list):
-            file_.write(x + '\n')
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        '--data_root', default='data/breastCancerCellSegmentation/')
-    args = parser.parse_args()
-    data_root = args.data_root
-
-    # 1. 划分训练集、验证集
-    # 1.1 获取所有图片路径
-    img_list = glob.glob(os.path.join(data_root, 'images', '*.tif'))
-    img_list.sort()
-    mask_list = glob.glob(os.path.join(data_root, 'masks', '*.TIF'))
-    mask_list.sort()
-    assert len(img_list) == len(mask_list)
-    # 1.2 划分训练集、验证集、测试集
-    train_img_list, val_img_list, train_mask_list, val_mask_list = train_test_split(  # noqa
-        img_list, mask_list, test_size=0.2, random_state=42)
-    # 1.3 保存划分结果
-    save_anno(train_img_list, os.path.join(data_root, 'train.txt'), '_ccd.tif')
-    save_anno(val_img_list, os.path.join(data_root, 'val.txt'), '_ccd.tif')
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/README.md b/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/README.md
deleted file mode 100644
index b6f1ca6..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/README.md
+++ /dev/null
@@ -1,147 +0,0 @@
-# Breast Cancer Cell Segmentation
-
-## Description
-
-This project support **`Breast Cancer Cell Segmentation`**, and the dataset used in this project can be downloaded from [here](https://tianchi.aliyun.com/dataset/dataDetail?dataId=90152).
-
-### Dataset Overview
-
-In this dataset, there are 58 H&E stained histopathology images used in breast cancer cell detection with associated ground truth data available. Routine histology uses the stain combination of hematoxylin and eosin, commonly referred to as H&E. These images are stained since most cells are essentially transparent, with little or no intrinsic pigment. Certain special stains, which bind selectively to particular components, are be used to identify biological structures such as cells. In those images, the challenging problem is cell segmentation for subsequent classification in benign and malignant cells.
-
-### Original Statistic Information
-
-| Dataset name                                                                                  | Anatomical region | Task type    | Modality       | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                                                                |
-| --------------------------------------------------------------------------------------------- | ----------------- | ------------ | -------------- | ------------ | --------------------- | ---------------------- | ------------ | ------------------------------------------------------------------------------------------------------ |
-| [Breast Cancer Cell Segmentation](https://tianchi.aliyun.com/dataset/dataDetail?dataId=90152) | thorax            | segmentation | histopathology | 2            | 58/-/-                | yes/-/-                | 2021         | [CC-BY-SA-NC 4.0](http://creativecommons.org/licenses/by-sa/4.0/?spm=5176.12282016.0.0.3f5b5291ypBxb2) |
-
-|     Class Name     | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :----------------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-|       normal       |     58     |   98.37    |    -     |    -     |     -     |     -     |
-| breast cancer cell |     58     |    1.63    |    -     |    -     |     -     |     -     |
-
-Note:
-
-- `Pct` means percentage of pixels in this category in all pixels.
-
-### Visualization
-
-![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/histopathology/breast_cancer_cell_seg/breast_cancer_cell_seg_dataset.png)
-
-## Dataset Citation
-
-```
-@inproceedings{gelasca2008evaluation,
-  title={Evaluation and benchmark for biological image segmentation},
-  author={Gelasca, Elisa Drelie and Byun, Jiyun and Obara, Boguslaw and Manjunath, BS},
-  booktitle={2008 15th IEEE international conference on image processing},
-  pages={1816--1819},
-  year={2008},
-  organization={IEEE}
-}
-```
-
-### Prerequisites
-
-- Python v3.8
-- PyTorch v1.10.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-
-All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `breast_cancer_cell_seg/` root directory, run the following line to add the current directory to `PYTHONPATH`:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset preparing
-
-- download dataset from [here](https://tianchi.aliyun.com/dataset/dataDetail?dataId=90152) and decompression data to path `'data/'`.
-- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
-- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set can't be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── histopathology
-  │   │   │   │   ├── breast_cancer_cell_seg
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── train.txt
-  │   │   │   │   │   │   ├── val.txt
-  │   │   │   │   │   │   ├── images
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   ├── masks
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-```
-
-### Divided Dataset Information
-
-***Note: The table information below is divided by ourselves.***
-
-|  Class Name  | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :----------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-|  background  |     46     |   98.36    |    12    |  98.41   |     -     |     -     |
-| erythrocytes |     46     |    1.64    |    12    |   1.59   |     -     |     -     |
-
-### Training commands
-
-Train models on a single server with one GPU.
-
-```shell
-mim train mmseg ./configs/${CONFIG_FILE}
-```
-
-### Testing commands
-
-Test models on a single server with one GPU.
-
-```shell
-mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
-
-You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-
-  - [x] Basic docstrings & proper citation
-
-  - [x] Test-time correctness
-
-  - [x] A full README
-
-- [ ] Milestone 2: Indicates a successful model implementation.
-
-  - [ ] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-
-  - [ ] Unit tests
-
-  - [ ] Code polishing
-
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/breast-cancer-cell-seg_512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/breast-cancer-cell-seg_512x512.py
deleted file mode 100644
index ead40e4..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/breast-cancer-cell-seg_512x512.py
+++ /dev/null
@@ -1,42 +0,0 @@
-dataset_type = 'BreastCancerCellSegDataset'
-data_root = 'data/'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='train.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='val.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_breast-cancer-cell-seg-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_breast-cancer-cell-seg-512x512.py
deleted file mode 100644
index 691a0ff..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_breast-cancer-cell-seg-512x512.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    './breast-cancer-cell-seg_512x512.py',
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.breast-cancer-cell-seg_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_breast-cancer-cell-seg-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_breast-cancer-cell-seg-512x512.py
deleted file mode 100644
index 719b767..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_breast-cancer-cell-seg-512x512.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    './breast-cancer-cell-seg_512x512.py',
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.breast-cancer-cell-seg_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_breast-cancer-cell-seg-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_breast-cancer-cell-seg-512x512.py
deleted file mode 100644
index 9dfe70f..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_breast-cancer-cell-seg-512x512.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    './breast-cancer-cell-seg_512x512.py',
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.breast-cancer-cell-seg_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/datasets/breast-cancer-cell-seg_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/datasets/breast-cancer-cell-seg_dataset.py
deleted file mode 100644
index 6f27029..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/datasets/breast-cancer-cell-seg_dataset.py
+++ /dev/null
@@ -1,29 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class BreastCancerCellSegDataset(BaseSegDataset):
-    """BreastCancerCellSegDataset dataset.
-
-    In segmentation map annotation for BreastCancerCellSegDataset,
-    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
-    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
-
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-        reduce_zero_label (bool): Whether to mark label zero as ignored.
-            Default to False.
-    """
-    METAINFO = dict(classes=('normal', 'breast cancer cell'))
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=False,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/tools/prepare_dataset.py
deleted file mode 100755
index 775f2ee..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/breast_cancer_cell_seg/tools/prepare_dataset.py
+++ /dev/null
@@ -1,47 +0,0 @@
-import glob
-import os
-
-import numpy as np
-from PIL import Image
-
-root_path = 'data/'
-img_suffix = '.tif'
-seg_map_suffix = '.TIF'
-save_img_suffix = '.png'
-save_seg_map_suffix = '.png'
-
-x_train = glob.glob(
-    os.path.join('data/Breast Cancer Cell Segmentation_datasets/Images/*' +
-                 img_suffix))
-
-os.system('mkdir -p ' + root_path + 'images/train/')
-os.system('mkdir -p ' + root_path + 'masks/train/')
-
-D2_255_convert_dict = {0: 0, 255: 1}
-
-
-def convert_2d(img, convert_dict=D2_255_convert_dict):
-    arr_2d = np.zeros((img.shape[0], img.shape[1]), dtype=np.uint8)
-    for c, i in convert_dict.items():
-        arr_2d[img == c] = i
-    return arr_2d
-
-
-part_dir_dict = {0: 'train/'}
-for ith, part in enumerate([x_train]):
-    part_dir = part_dir_dict[ith]
-    for img in part:
-        basename = os.path.basename(img)
-        img_save_path = root_path + 'images/' + part_dir + basename.split(
-            '.')[0] + save_img_suffix
-        Image.open(img).save(img_save_path)
-        mask_path = root_path + 'Breast Cancer Cell Segmentation_datasets/Masks/' + '_'.join(  # noqa
-            basename.split('_')[:-1]) + seg_map_suffix
-        label = np.array(Image.open(mask_path))
-
-        save_mask_path = root_path + 'masks/' + part_dir + basename.split(
-            '.')[0] + save_seg_map_suffix
-        assert len(label.shape) == 2 and 255 in label and 1 not in label
-        mask = convert_2d(label)
-        mask = Image.fromarray(mask.astype(np.uint8))
-        mask.save(save_mask_path)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/README.md b/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/README.md
deleted file mode 100644
index 1f55b44..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/README.md
+++ /dev/null
@@ -1,207 +0,0 @@
-# CoNIC: Colon Nuclei Identification and Counting Challenge
-
-## Description
-
-This project supports **`CoNIC: Colon Nuclei Identification and Counting Challenge`**, which can be downloaded from [here](https://drive.google.com/drive/folders/1il9jG7uA4-ebQ_lNmXbbF2eOK9uNwheb).
-
-### Dataset Overview
-
-Nuclear segmentation, classification and quantification within Haematoxylin & Eosin stained histology images enables the extraction of interpretable cell-based features that can be used in downstream explainable models in computational pathology (CPath). To help drive forward research and innovation for automatic nuclei recognition in CPath, we organise the Colon Nuclei Identification and Counting (CoNIC) Challenge. The challenge requires researchers to develop algorithms that perform segmentation, classification and counting of 6 different types of nuclei within the current largest known publicly available nuclei-level dataset in CPath, containing around half a million labelled nuclei.
-
-### Task Information
-
-The CONIC challenge has 2 tasks:
-
-- Task 1: Nuclear segmentation and classification.
-
-The first task requires participants to segment nuclei within the tissue, while also classifying each nucleus into one of the following categories: epithelial, lymphocyte, plasma, eosinophil, neutrophil or connective tissue.
-
-- Task 2: Prediction of cellular composition.
-
-For the second task, we ask participants to predict how many nuclei of each class are present in each input image.
-
-The output of Task 1 can be directly used to perform Task 2, but these can be treated as independent tasks. Therefore, if it is preferred, prediction of cellular composition can be treated as a stand alone regression task.
-
-***NOTE：We only consider `Task 1` in the following sections.***
-
-### Original Statistic Information
-
-| Dataset name                                             | Anatomical region | Task type    | Modality       | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                                                                      |
-| -------------------------------------------------------- | ----------------- | ------------ | -------------- | ------------ | --------------------- | ---------------------- | ------------ | ------------------------------------------------------------------------------------------------------------ |
-| [CoNIC202](https://conic-challenge.grand-challenge.org/) | abdomen           | segmentation | histopathology | 7            | 4981/-/-              | yes/-/-                | 2022         | [Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/) |
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |    4981    |   83.97    |    -     |    -     |     -     |     -     |
-| neutrophil |    1218    |    0.13    |    -     |    -     |     -     |     -     |
-| epithelial |    4256    |   10.31    |    -     |    -     |     -     |     -     |
-| lymphocyte |    4473    |    1.85    |    -     |    -     |     -     |     -     |
-|   plasma   |    3316    |    0.55    |    -     |    -     |     -     |     -     |
-| eosinophil |    1456    |    0.1     |    -     |    -     |     -     |     -     |
-| connective |    4613    |    3.08    |    -     |    -     |     -     |     -     |
-
-Note:
-
-- `Pct` means percentage of pixels in this category in all pixels.
-
-### Visualization
-
-![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/histopathology/conic2022_seg/conic2022_seg_dataset.png)
-
-### Prerequisites
-
-- Python v3.8
-- PyTorch v1.10.0
-- pillow(PIL) v9.3.0
-- scikit-learn(sklearn) v1.2.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-
-All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `conic2022_seg/` root directory, run the following line to add the current directory to `PYTHONPATH`:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset preparing
-
-- download dataset from [here](https://drive.google.com/drive/folders/1il9jG7uA4-ebQ_lNmXbbF2eOK9uNwheb/) and move data to path `'data/CoNIC_Challenge'`. The directory should be like:
-  ```shell
-  data/CoNIC_Challenge
-        ├── README.txt
-        ├── by-nc-sa.md
-        ├── counts.csv
-        ├── images.npy
-        ├── labels.npy
-        └── patch_info.csv
-  ```
-- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
-- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set can't be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── histopathology
-  │   │   │   │   ├── conic2022_seg
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── train.txt
-  │   │   │   │   │   │   ├── val.txt
-  │   │   │   │   │   │   ├── images
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   ├── masks
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-```
-
-### Divided Dataset Information
-
-***Note: The table information below is divided by ourselves.***
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |    3984    |   84.06    |   997    |  83.65   |     -     |     -     |
-| neutrophil |    956     |    0.12    |   262    |   0.13   |     -     |     -     |
-| epithelial |    3400    |   10.26    |   856    |  10.52   |     -     |     -     |
-| lymphocyte |    3567    |    1.83    |   906    |   1.96   |     -     |     -     |
-|   plasma   |    2645    |    0.55    |   671    |   0.56   |     -     |     -     |
-| eosinophil |    1154    |    0.1     |   302    |   0.1    |     -     |     -     |
-| connective |    3680    |    3.08    |   933    |   3.08   |     -     |     -     |
-
-### Training commands
-
-Train models on a single server with one GPU.
-
-```shell
-mim train mmseg ./configs/${CONFIG_FILE}
-```
-
-### Testing commands
-
-Test models on a single server with one GPU.
-
-```shell
-mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
-
-You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
-
-## Organizers
-
-- Simon Graham (TIA, PathLAKE)
-- Mostafa Jahanifar (TIA, PathLAKE)
-- Dang Vu (TIA)
-- Giorgos Hadjigeorghiou (TIA, PathLAKE)
-- Thomas Leech (TIA, PathLAKE)
-- David Snead (UHCW, PathLAKE)
-- Shan Raza (TIA, PathLAKE)
-- Fayyaz Minhas (TIA, PathLAKE)
-- Nasir Rajpoot (TIA, PathLAKE)
-
-TIA: Tissue Image Analytics Centre, Department of Computer Science, University of Warwick, United Kingdom
-
-UHCW: Department of Pathology, University Hospitals Coventry and Warwickshire, United Kingdom
-
-PathLAKE: Pathology Image Data Lake for Analytics Knowledge & Education, , University Hospitals Coventry and Warwickshire, United Kingdom
-
-## Dataset Citation
-
-If this work is helpful for your research, please consider citing the below paper.
-
-```
-@inproceedings{graham2021lizard,
-  title={Lizard: A large-scale dataset for colonic nuclear instance segmentation and classification},
-  author={Graham, Simon and Jahanifar, Mostafa and Azam, Ayesha and Nimir, Mohammed and Tsang, Yee-Wah and Dodd, Katherine and Hero, Emily and Sahota, Harvir and Tank, Atisha and Benes, Ksenija and others},
-  booktitle={Proceedings of the IEEE/CVF International Conference on Computer Vision},
-  pages={684--693},
-  year={2021}
-}
-@article{graham2021conic,
-  title={Conic: Colon nuclei identification and counting challenge 2022},
-  author={Graham, Simon and Jahanifar, Mostafa and Vu, Quoc Dang and Hadjigeorghiou, Giorgos and Leech, Thomas and Snead, David and Raza, Shan E Ahmed and Minhas, Fayyaz and Rajpoot, Nasir},
-  journal={arXiv preprint arXiv:2111.14485},
-  year={2021}
-}
-```
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-
-  - [x] Basic docstrings & proper citation
-
-  - [x] A full README
-
-- [ ] Milestone 2: Indicates a successful model implementation.
-
-  - [ ] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-
-  - [ ] Unit tests
-
-  - [ ] Code polishing
-
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/conic2022-seg_512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/conic2022-seg_512x512.py
deleted file mode 100644
index 51b4e57..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/conic2022-seg_512x512.py
+++ /dev/null
@@ -1,42 +0,0 @@
-dataset_type = 'Conic2022SegDataset'
-data_root = 'data/'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='train.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='val.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_conic2022-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_conic2022-512x512.py
deleted file mode 100644
index 3e0248c..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_conic2022-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    './conic2022-seg_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.conic2022-seg_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=7),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_conic2022-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_conic2022-512x512.py
deleted file mode 100644
index fd0e9d8..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_conic2022-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    './conic2022-seg_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.conic2022-seg_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=7),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_conic2022-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_conic2022-512x512.py
deleted file mode 100644
index bb667f1..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_conic2022-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    './conic2022-seg_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.conic2022-seg_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=7),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/datasets/conic2022-seg_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/datasets/conic2022-seg_dataset.py
deleted file mode 100644
index 9af0958..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/datasets/conic2022-seg_dataset.py
+++ /dev/null
@@ -1,29 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class Conic2022SegDataset(BaseSegDataset):
-    """Conic2022SegDataset dataset.
-
-    In segmentation map annotation for Conic2022SegDataset,
-    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
-    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
-
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-    """
-    METAINFO = dict(
-        classes=('background', 'neutrophil', 'epithelial', 'lymphocyte',
-                 'plasma', 'eosinophil', 'connective'))
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=False,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/tools/prepare_dataset.py
deleted file mode 100755
index 89cfb4a..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/conic2022_seg/tools/prepare_dataset.py
+++ /dev/null
@@ -1,65 +0,0 @@
-import glob
-import os
-import shutil
-
-import numpy as np
-from PIL import Image
-
-img_save_root = 'data/'
-root_path = 'data/'
-img_suffix = '.png'
-seg_map_suffix = '.png'
-save_img_suffix = '.png'
-save_seg_map_suffix = '.png'
-
-label_set = set()
-
-
-def save_masks_from_npz(data, save_root, part='masks/'):
-    global label_set
-    num = data.shape[0]
-    for i in range(num):
-        # np_img = data[i, :, :, :]
-        np_mask = data[i, :, :, 1]
-        label_set = set.union(label_set, set(np.unique(np_mask)))
-        img = Image.fromarray(np_mask)
-        save_path = os.path.join(save_root, part, str(i) + save_seg_map_suffix)
-        img.save(save_path)
-
-
-def save_images_from_npz(data, save_root, part='images/'):
-    num = data.shape[0]
-    for i in range(num):
-        np_img = data[i, :, :, :]
-        img = Image.fromarray(np_img)
-        save_path = os.path.join(save_root, part, str(i) + save_img_suffix)
-        img.save(save_path)
-
-
-images_npy = np.load('data/CoNIC_Challenge/images.npy')
-labels_npy = np.load('data/CoNIC_Challenge/labels.npy')
-
-os.system('mkdir -p ' + img_save_root + 'images_ori')
-os.system('mkdir -p ' + img_save_root + 'labels')
-save_images_from_npz(images_npy, img_save_root, 'images_ori')
-save_masks_from_npz(labels_npy, img_save_root, 'labels')
-print(label_set)
-
-x_train = glob.glob(os.path.join('data/images_ori/*' + img_suffix))
-
-os.system('mkdir -p ' + root_path + 'images/train/')
-os.system('mkdir -p ' + root_path + 'masks/train/')
-
-part_dir_dict = {0: 'train/', 1: 'val/'}
-for ith, part in enumerate([x_train]):
-    part_dir = part_dir_dict[ith]
-    for img in part:
-        basename = os.path.basename(img)
-        shutil.copy(
-            img, root_path + 'images/' + part_dir + basename.split('.')[0] +
-            save_img_suffix)
-        mask_path = root_path + 'labels/' + basename.split(
-            '.')[0] + seg_map_suffix
-        save_mask_path = root_path + 'masks/' + part_dir + basename.split(
-            '.')[0] + save_seg_map_suffix
-        shutil.copy(mask_path, save_mask_path)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/consep/README.md b/mmsegmentation/projects/medical/2d_image/histopathology/consep/README.md
deleted file mode 100644
index ca3d7aa..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/consep/README.md
+++ /dev/null
@@ -1,147 +0,0 @@
-# Colorectal Nuclear Segmentation and Phenotypes (CoNSeP) Dataset
-
-## Description
-
-This project supports **`Colorectal Nuclear Segmentation and Phenotypes (CoNSeP) Dataset`**, which can be downloaded from [here](https://warwick.ac.uk/fac/cross_fac/tia/data/hovernet/).
-
-### Dataset Overview
-
-The CoNSeP (Colon Segmentation and Phenotyping) dataset consists of 41 H&E stained image tiles, each with a size of 1,000×1,000 pixels and a magnification of 40x. These images were extracted from 16 colorectal adenocarcinoma (CRA) whole slide images (WSI), each of which belonged to a separate patient and was scanned using an Omnyx VL120 scanner at the Pathology Department of the University Hospitals Coventry and Warwickshire NHS Trust, UK. This dataset was first used in  paper named, "HoVer-Net: Simultaneous Segmentation and Classification of Nuclei in Multi-Tissue Histology Images".
-
-### Original Statistic Information
-
-| Dataset name                                             | Anatomical region | Task type    | Modality       | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License |
-| -------------------------------------------------------- | ----------------- | ------------ | -------------- | ------------ | --------------------- | ---------------------- | ------------ | ------- |
-| [CoNIC202](https://conic-challenge.grand-challenge.org/) | abdomen           | segmentation | histopathology | 7            | 4981/-/-              | yes/-/-                | 2022         | -       |
-
-|           Class Name            | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :-----------------------------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-|           background            |     27     |   83.61    |    14    |   80.4   |     -     |     -     |
-|              other              |     17     |    0.17    |    9     |   0.52   |     -     |     -     |
-|          inflammatory           |     25     |    2.66    |    14    |   2.14   |     -     |     -     |
-|       healthy epithelial        |     3      |    1.47    |    2     |   1.58   |     -     |     -     |
-| dysplastic/malignant epithelial |     10     |    7.17    |    8     |   9.16   |     -     |     -     |
-|           fibroblast            |     23     |    3.84    |    14    |   4.63   |     -     |     -     |
-|             muscle              |     8      |    1.05    |    3     |   1.42   |     -     |     -     |
-|           endothelial           |     7      |    0.02    |    4     |   0.15   |     -     |     -     |
-
-Note:
-
-- `Pct` means percentage of pixels in this category in all pixels.
-
-### Visualization
-
-![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/histopathology/consep/consep_dataset.png)
-
-### Prerequisites
-
-- Python v3.8
-- PyTorch v1.10.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-
-All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `conic2022_seg/` root directory, run the following line to add the current directory to `PYTHONPATH`:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset preparing
-
-- download dataset from [here](https://opendatalab.com/CoNSeP) and decompress data to path `'data/'`.
-- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
-- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set can't be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── histopathology
-  │   │   │   │   ├── consep
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── train.txt
-  │   │   │   │   │   │   ├── val.txt
-  │   │   │   │   │   │   ├── images
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   ├── masks
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-```
-
-### Training commands
-
-Train models on a single server with one GPU.
-
-```shell
-mim train mmseg ./configs/${CONFIG_FILE}
-```
-
-### Testing commands
-
-Test models on a single server with one GPU.
-
-```shell
-mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
-
-You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
-
-## Dataset Citation
-
-If this work is helpful for your research, please consider citing the below paper.
-
-```
-@article{graham2019hover,
-  title={Hover-net: Simultaneous segmentation and classification of nuclei in multi-tissue histology images},
-  author={Graham, Simon and Vu, Quoc Dang and Raza, Shan E Ahmed and Azam, Ayesha and Tsang, Yee Wah and Kwak, Jin Tae and Rajpoot, Nasir},
-  journal={Medical Image Analysis},
-  volume={58},
-  pages={101563},
-  year={2019},
-  publisher={Elsevier}
-}
-```
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-
-  - [x] Basic docstrings & proper citation
-
-  - [x] Test-time correctness
-
-  - [x] A full README
-
-- [ ] Milestone 2: Indicates a successful model implementation.
-
-  - [ ] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-
-  - [ ] Unit tests
-
-  - [ ] Code polishing
-
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/consep_512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/consep_512x512.py
deleted file mode 100644
index 0d9b894..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/consep_512x512.py
+++ /dev/null
@@ -1,42 +0,0 @@
-dataset_type = 'ConsepDataset'
-data_root = 'data/'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='train.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='val.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_consep-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_consep-512x512.py
deleted file mode 100644
index cbcf5db..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_consep-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    './consep_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.consep_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=8),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_consep-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_consep-512x512.py
deleted file mode 100644
index b374566..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_consep-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    './consep_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.consep_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=8),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_consep-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_consep-512x512.py
deleted file mode 100644
index 35bdaa3..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/consep/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_consep-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    './consep_512x512.py', 'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.consep_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=8),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/consep/datasets/consep_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/consep/datasets/consep_dataset.py
deleted file mode 100644
index ceb2b3a..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/consep/datasets/consep_dataset.py
+++ /dev/null
@@ -1,30 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class ConsepDataset(BaseSegDataset):
-    """ConsepDataset dataset.
-
-    In segmentation map annotation for ConsepDataset,
-    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
-    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
-
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-    """
-    METAINFO = dict(
-        classes=('background', 'other', 'inflammatory', 'healthy epithelial',
-                 'dysplastic/malignant epithelial', 'fibroblast', 'muscle',
-                 'endothelial'))
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=False,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/consep/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/consep/tools/prepare_dataset.py
deleted file mode 100755
index 83a2e18..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/consep/tools/prepare_dataset.py
+++ /dev/null
@@ -1,54 +0,0 @@
-import glob
-import os
-import shutil
-
-import numpy as np
-from PIL import Image
-from scipy.io import loadmat
-
-root_path = 'data/'
-img_suffix = '.png'
-seg_map_suffix = '.mat'
-save_img_suffix = '.png'
-save_seg_map_suffix = '.png'
-
-x_train = glob.glob(os.path.join('data/CoNSeP/Train/Images/*' + img_suffix))
-x_test = glob.glob(os.path.join('data/CoNSeP/Test/Images/*' + img_suffix))
-
-os.system('mkdir -p ' + root_path + 'images/train/')
-os.system('mkdir -p ' + root_path + 'images/val/')
-os.system('mkdir -p ' + root_path + 'masks/train/')
-os.system('mkdir -p ' + root_path + 'masks/val/')
-D2_255_convert_dict = {0: 0, 255: 1}
-
-
-def convert_2d(img, convert_dict=D2_255_convert_dict):
-    arr_2d = np.zeros((img.shape[0], img.shape[1]), dtype=np.uint8)
-    for c, i in convert_dict.items():
-        arr_2d[img == c] = i
-    return arr_2d
-
-
-part_dir_dict = {0: 'CoNSeP/Train/', 1: 'CoNSeP/Test/'}
-save_dir_dict = {0: 'train/', 1: 'val/'}
-for ith, part in enumerate([x_train, x_test]):
-    part_dir = part_dir_dict[ith]
-    for img in part:
-        basename = os.path.basename(img)
-        shutil.copy(
-            img, root_path + 'images/' + save_dir_dict[ith] +
-            basename.split('.')[0] + save_img_suffix)
-
-        mask_path = root_path + part_dir + 'Labels/' + basename.split(
-            '.')[0] + seg_map_suffix
-        label_ = loadmat(mask_path)
-        label = label_['inst_map']
-        label_type = label_['inst_type']
-        label_dict = {i + 1: int(val) for i, val in enumerate(label_type)}
-
-        save_mask_path = root_path + 'masks/' + save_dir_dict[
-            ith] + basename.split('.')[0] + save_seg_map_suffix
-
-        res = convert_2d(label, convert_dict=label_dict)
-        res = Image.fromarray(res.astype(np.uint8))
-        res.save(save_mask_path)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/README.md b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/README.md
deleted file mode 100644
index 8130d59..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/README.md
+++ /dev/null
@@ -1,136 +0,0 @@
-# Foot Ulcer Segmentation Challenge 2021 (FUSC 2021)
-
-## Description
-
-This project supports **`Foot Ulcer Segmentation Challenge 2021 (FUSC 2021) `**, which can be downloaded from [here](https://fusc.grand-challenge.org/).
-
-### Dataset Overview
-
-This chronic wound dataset was collected over 2 years from October 2019 to April 2021 at the center and contains 1,210 foot ulcer images taken from 889 patients during multiple clinical visits. The raw images were taken by Canon SX 620 HS digital camera and iPad Pro under uncontrolled illumination conditions,
-with various backgrounds. The images (shown in Figure 1) are randomly split into 3 subsets: a training set with 810 images, a validation set with 200 images, and a testing set with 200 images. Of course, the annotations of the testing set are kept private. The data collected were de-identified and in accordance with relevant guidelines and regulations and the patient’s informed consent is waived by the institutional review board of the University of Wisconsin-Milwaukee.
-
-### Information Statistics
-
-| Dataset Name                                  | Anatomical Region | Task Type    | Modality       | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                       |
-| --------------------------------------------- | ----------------- | ------------ | -------------- | ------------ | --------------------- | ---------------------- | ------------ | ------------------------------------------------------------- |
-| [fusc2021](https://fusc.grand-challenge.org/) | lower limb        | segmentation | histopathology | 2            | 810/200/200           | yes/yes/no             | 2021         | [CC0 1.0](https://creativecommons.org/publicdomain/zero/1.0/) |
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |    810     |   98.71    |   200    |  98.78   |     -     |     -     |
-|   wound    |    791     |    1.29    |   195    |   1.22   |     -     |     -     |
-
-Note:
-
-- `Pct` means percentage of pixels in this category in all pixels.
-
-### Visualization
-
-![fusc2021](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/histopathology/fusc2021/fusc2021_dataset.png?raw=true)
-
-### Dataset Citation
-
-```
-@article{s41598-020-78799-w,
-	title={Fully automatic wound segmentation with deep convolutional neural networks},
-	author={Chuanbo Wang and D. M. Anisuzzaman and Victor Williamson and Mrinal Kanti Dhar and Behrouz Rostami and Jeffrey Niezgoda and Sandeep Gopalakrishnan and Zeyun Yu},
-	journal={Scientific Reports},
-	volume={10},
-	number={1},
-	pages={21897},
-	year={2020}
-}
-```
-
-### Prerequisites
-
-- Python v3.8
-- PyTorch v1.10.0
-- pillow(PIL) v9.3.0
-- scikit-learn(sklearn) v1.2.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-
-All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `fusc2021/` root directory, run the following line to add the current directory to `PYTHONPATH`:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset Preparing
-
-- download dataset from [here](https://fusc.grand-challenge.org/) and decompress data to path `'data/'`.
-- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
-- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set cannot be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── histopathology
-  │   │   │   │   ├── fusc2021
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── train.txt
-  │   │   │   │   │   │   ├── val.txt
-  │   │   │   │   │   │   ├── images
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   ├── masks
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-```
-
-### Training commands
-
-To train models on a single server with one GPU. (default)
-
-```shell
-mim train mmseg ./configs/${CONFIG_FILE}
-```
-
-### Testing commands
-
-To test models on a single server with one GPU. (default)
-
-```shell
-mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
-
-You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-  - [x] Basic docstrings & proper citation
-  - [ ] Test-time correctness
-  - [x] A full README
-
-- [ ] Milestone 2: Indicates a successful model implementation.
-
-  - [ ] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-  - [ ] Unit tests
-  - [ ] Code polishing
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_fusc2021-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_fusc2021-512x512.py
deleted file mode 100644
index c3f4275..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_fusc2021-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './fusc2021_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.fusc2021_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_fusc2021-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_fusc2021-512x512.py
deleted file mode 100644
index ed87030..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_fusc2021-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './fusc2021_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.fusc2021_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_fusc2021-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_fusc2021-512x512.py
deleted file mode 100644
index cbc09ae..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_fusc2021-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './fusc2021_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.fusc2021_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_fusc2021-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_fusc2021-512x512.py
deleted file mode 100644
index f1477ee..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_fusc2021-512x512.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './fusc2021_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.fusc2021_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(
-        num_classes=2, loss_decode=dict(use_sigmoid=True), out_channels=1),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fusc2021_512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fusc2021_512x512.py
deleted file mode 100644
index e650474..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/configs/fusc2021_512x512.py
+++ /dev/null
@@ -1,42 +0,0 @@
-dataset_type = 'FUSC2021Dataset'
-data_root = 'data/'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='train.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='val.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/datasets/fusc2021_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/datasets/fusc2021_dataset.py
deleted file mode 100644
index d331ac8..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/datasets/fusc2021_dataset.py
+++ /dev/null
@@ -1,30 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class FUSC2021Dataset(BaseSegDataset):
-    """FUSC2021Dataset dataset.
-
-    In segmentation map annotation for FUSC2021Dataset, 0 stands for background
-    , which is included in 2 categories. ``reduce_zero_label``
-    is fixed to False. The ``img_suffix`` is fixed to '.png' and
-    ``seg_map_suffix`` is fixed to '.png'.
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-        reduce_zero_label (bool): Whether to mark label zero as ignored.
-            Default to False..
-    """
-    METAINFO = dict(classes=('background', 'wound'))
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/tools/prepare_dataset.py
deleted file mode 100644
index 8f2de3d..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/fusc2021/tools/prepare_dataset.py
+++ /dev/null
@@ -1,114 +0,0 @@
-import glob
-import os
-
-import numpy as np
-from PIL import Image
-
-root_path = 'data/'
-img_suffix = '.png'
-seg_map_suffix = '.png'
-save_img_suffix = '.png'
-save_seg_map_suffix = '.png'
-src_img_train_dir = os.path.join(
-    root_path, 'wound-segmentation/data/' +
-    'Foot Ulcer Segmentation Challenge/train/images')
-src_img_val_dir = os.path.join(
-    root_path, 'wound-segmentation/data/' +
-    'Foot Ulcer Segmentation Challenge/validation/images')
-src_img_test_dir = os.path.join(
-    root_path, 'wound-segmentation/data/' +
-    'Foot Ulcer Segmentation Challenge/test/images')
-src_mask_train_dir = os.path.join(
-    root_path, 'wound-segmentation/data/' +
-    'Foot Ulcer Segmentation Challenge/train/labels')
-src_mask_val_dir = os.path.join(
-    root_path, 'wound-segmentation/data/' +
-    'Foot Ulcer Segmentation Challenge/validation/labels')
-
-tgt_img_train_dir = os.path.join(root_path, 'images/train/')
-tgt_mask_train_dir = os.path.join(root_path, 'masks/train/')
-tgt_img_val_dir = os.path.join(root_path, 'images/val/')
-tgt_mask_val_dir = os.path.join(root_path, 'masks/val/')
-tgt_img_test_dir = os.path.join(root_path, 'images/test/')
-os.system('mkdir -p ' + tgt_img_train_dir)
-os.system('mkdir -p ' + tgt_img_val_dir)
-os.system('mkdir -p ' + tgt_img_test_dir)
-os.system('mkdir -p ' + tgt_mask_train_dir)
-os.system('mkdir -p ' + tgt_mask_val_dir)
-
-
-def filter_suffix_recursive(src_dir, suffix):
-    # filter out file names and paths in source directory
-    suffix = '.' + suffix if '.' not in suffix else suffix
-    file_paths = glob.glob(
-        os.path.join(src_dir, '**', '*' + suffix), recursive=True)
-    file_names = [_.split('/')[-1] for _ in file_paths]
-    return sorted(file_paths), sorted(file_names)
-
-
-def convert_label(img, convert_dict):
-    arr = np.zeros_like(img, dtype=np.uint8)
-    for c, i in convert_dict.items():
-        arr[img == c] = i
-    return arr
-
-
-def convert_pics_into_pngs(src_dir, tgt_dir, suffix, convert='RGB'):
-    if not os.path.exists(tgt_dir):
-        os.makedirs(tgt_dir)
-
-    src_paths, src_names = filter_suffix_recursive(src_dir, suffix=suffix)
-
-    for i, (src_name, src_path) in enumerate(zip(src_names, src_paths)):
-        tgt_name = src_name.replace(suffix, save_img_suffix)
-        tgt_path = os.path.join(tgt_dir, tgt_name)
-        num = len(src_paths)
-        img = np.array(Image.open(src_path))
-        if len(img.shape) == 2:
-            pil = Image.fromarray(img).convert(convert)
-        elif len(img.shape) == 3:
-            pil = Image.fromarray(img)
-        else:
-            raise ValueError('Input image not 2D/3D: ', img.shape)
-
-        pil.save(tgt_path)
-        print(f'processed {i+1}/{num}.')
-
-
-def convert_label_pics_into_pngs(src_dir,
-                                 tgt_dir,
-                                 suffix,
-                                 convert_dict={
-                                     0: 0,
-                                     255: 1
-                                 }):
-    if not os.path.exists(tgt_dir):
-        os.makedirs(tgt_dir)
-
-    src_paths, src_names = filter_suffix_recursive(src_dir, suffix=suffix)
-    num = len(src_paths)
-    for i, (src_name, src_path) in enumerate(zip(src_names, src_paths)):
-        tgt_name = src_name.replace(suffix, save_seg_map_suffix)
-        tgt_path = os.path.join(tgt_dir, tgt_name)
-
-        img = np.array(Image.open(src_path).convert('L'))
-        img = convert_label(img, convert_dict)
-        Image.fromarray(img).save(tgt_path)
-        print(f'processed {i+1}/{num}.')
-
-
-if __name__ == '__main__':
-
-    convert_pics_into_pngs(
-        src_img_train_dir, tgt_img_train_dir, suffix=img_suffix)
-
-    convert_pics_into_pngs(src_img_val_dir, tgt_img_val_dir, suffix=img_suffix)
-
-    convert_pics_into_pngs(
-        src_img_test_dir, tgt_img_test_dir, suffix=img_suffix)
-
-    convert_label_pics_into_pngs(
-        src_mask_train_dir, tgt_mask_train_dir, suffix=seg_map_suffix)
-
-    convert_label_pics_into_pngs(
-        src_mask_val_dir, tgt_mask_val_dir, suffix=seg_map_suffix)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/README.md b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/README.md
deleted file mode 100644
index e0cade7..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/README.md
+++ /dev/null
@@ -1,146 +0,0 @@
-# Pan-Cancer Histology Dataset for Nuclei Instance Segmentation and Classification (PanNuke)
-
-## Description
-
-This project supports **`Pan-Cancer Histology Dataset for Nuclei Instance Segmentation and Classification (PanNuke)`**, which can be downloaded from [here](https://academictorrents.com/details/99f2c7b57b95500711e33f2ee4d14c9fd7c7366c).
-
-### Dataset Overview
-
-Semi automatically generated nuclei instance segmentation and classification dataset with exhaustive nuclei labels across 19 different tissue types. The dataset consists of 481 visual fields, of which 312 are randomly sampled from more than 20K whole slide images at different magnifications, from multiple data sources. In total the dataset contains 205,343 labeled nuclei, each with an instance segmentation mask. Models trained on pannuke can aid in whole slide image tissue type segmentation, and generalise to new tissues. PanNuke demonstrates one of the first successfully semi-automatically generated datasets.
-
-### Statistic Information
-
-| Dataset Name                                                                             | Anatomical Region | Task Type    | Modality       | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                         |
-| ---------------------------------------------------------------------------------------- | ----------------- | ------------ | -------------- | ------------ | --------------------- | ---------------------- | ------------ | --------------------------------------------------------------- |
-| [Pannuke](https://academictorrents.com/details/99f2c7b57b95500711e33f2ee4d14c9fd7c7366c) | full_body         | segmentation | histopathology | 6            | 7901/-/-              | yes/-/-                | 2019         | [CC-BY-NC 4.0](https://creativecommons.org/licenses/by-sa/4.0/) |
-
-|        Class Name         | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :-----------------------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-|        background         |    7901    |   83.32    |    -     |    -     |     -     |     -     |
-|        neoplastic         |    4190    |    8.64    |    -     |    -     |     -     |     -     |
-| non-neoplastic epithelial |    4126    |    1.77    |    -     |    -     |     -     |     -     |
-|       inflammatory        |    6137    |    3.73    |    -     |    -     |     -     |     -     |
-|        connective         |    232     |    0.07    |    -     |    -     |     -     |     -     |
-|           dead            |    1528    |    2.47    |    -     |    -     |     -     |     -     |
-
-Note:
-
-- `Pct` means percentage of pixels in this category in all pixels.
-
-### Visualization
-
-![pannuke](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/histopathology/pannuke/pannuke_dataset.png?raw=true)
-
-### Dataset Citation
-
-```
-@inproceedings{gamper2019pannuke,
-  title={PanNuke: an open pan-cancer histology dataset for nuclei instance segmentation and classification},
-  author={Gamper, Jevgenij and Koohbanani, Navid Alemi and Benet, Ksenija and Khuram, Ali and Rajpoot, Nasir},
-  booktitle={European Congress on Digital Pathology},
-  pages={11--19},
-  year={2019},
-}
-```
-
-### Prerequisites
-
-- Python v3.8
-- PyTorch v1.10.0
-- pillow(PIL) v9.3.0 9.3.0
-- scikit-learn(sklearn) v1.2.0 1.2.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-
-All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `pannuke/` root directory, run the following line to add the current directory to `PYTHONPATH`:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset Preparing
-
-- download dataset from [here](https://academictorrents.com/details/99f2c7b57b95500711e33f2ee4d14c9fd7c7366c) and decompress data to path `'data/'`.
-- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
-- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set cannot be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── histopathology
-  │   │   │   │   ├── pannuke
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── train.txt
-  │   │   │   │   │   │   ├── val.txt
-  │   │   │   │   │   │   ├── images
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   ├── masks
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-```
-
-### Divided Dataset Information
-
-***Note: The table information below is divided by ourselves.***
-
-|        Class Name         | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :-----------------------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-|        background         |    6320    |   83.38    |   1581   |   83.1   |     -     |     -     |
-|        neoplastic         |    3339    |    8.55    |   851    |   9.0    |     -     |     -     |
-| non-neoplastic epithelial |    3293    |    1.77    |   833    |   1.76   |     -     |     -     |
-|       inflammatory        |    4914    |    3.72    |   1223   |   3.76   |     -     |     -     |
-|        connective         |    170     |    0.06    |    62    |   0.09   |     -     |     -     |
-|           dead            |    1235    |    2.51    |   293    |   2.29   |     -     |     -     |
-
-### Training commands
-
-To train models on a single server with one GPU. (default)
-
-```shell
-mim train mmseg ./configs/${CONFIG_FILE}
-```
-
-### Testing commands
-
-To test models on a single server with one GPU. (default)
-
-```shell
-mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-  - [x] Basic docstrings & proper citation
-  - [ ] Test-time correctness
-  - [x] A full README
-
-- [ ] Milestone 2: Indicates a successful model implementation.
-
-  - [ ] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-  - [ ] Unit tests
-  - [ ] Code polishing
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_bactteria-detection-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_bactteria-detection-512x512.py
deleted file mode 100644
index 92584e9..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_bactteria-detection-512x512.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    './bactteria-detection_512x512.py', 'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.bactteria-detection_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(
-        num_classes=2, loss_decode=dict(use_sigmoid=True), out_channels=1),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_pannuke-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_pannuke-512x512.py
deleted file mode 100644
index 042a08c..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_pannuke-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './pannuke_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.pannuke_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=6),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_pannuke-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_pannuke-512x512.py
deleted file mode 100644
index e92514c..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_pannuke-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './pannuke_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.pannuke_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=6),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_pannuke-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_pannuke-512x512.py
deleted file mode 100644
index a9403c8..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_pannuke-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './pannuke_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.pannuke_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=6),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/pannuke_512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/pannuke_512x512.py
deleted file mode 100644
index 316ac1a..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/configs/pannuke_512x512.py
+++ /dev/null
@@ -1,42 +0,0 @@
-dataset_type = 'PanNukeDataset'
-data_root = 'data/'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='train.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='val.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/datasets/pannuke_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/datasets/pannuke_dataset.py
deleted file mode 100644
index 4d3c687..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/datasets/pannuke_dataset.py
+++ /dev/null
@@ -1,33 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class PanNukeDataset(BaseSegDataset):
-    """PanNukeDataset dataset.
-
-    In segmentation map annotation for PanNukeDataset,
-    0 stands for background, which is included in 6 categories.
-    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
-    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
-
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-        reduce_zero_label (bool): Whether to mark label zero as ignored.
-            Default to False.
-    """
-    METAINFO = dict(
-        classes=('background', 'neoplastic', 'non-neoplastic epithelial',
-                 'inflammatory', 'connective', 'dead'))
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/tools/prepare_dataset.py
deleted file mode 100644
index 7213b18..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/pannuke/tools/prepare_dataset.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import os
-
-import numpy as np
-from PIL import Image
-
-root_path = 'data/'
-
-tgt_img_dir = os.path.join(root_path, 'images/train')
-tgt_mask_dir = os.path.join(root_path, 'masks/train')
-os.system('mkdir -p ' + tgt_img_dir)
-os.system('mkdir -p ' + tgt_mask_dir)
-
-fold_img_paths = sorted([
-    os.path.join(root_path, 'pannuke/Fold 1/images/fold1/images.npy'),
-    os.path.join(root_path, 'pannuke/Fold 2/images/fold2/images.npy'),
-    os.path.join(root_path, 'pannuke/Fold 3/images/fold3/images.npy')
-])
-
-fold_mask_paths = sorted([
-    os.path.join(root_path, 'pannuke/Fold 1/masks/fold1/masks.npy'),
-    os.path.join(root_path, 'pannuke/Fold 2/masks/fold2/masks.npy'),
-    os.path.join(root_path, 'pannuke/Fold 3/masks/fold3/masks.npy')
-])
-
-for n, (img_path,
-        mask_path) in enumerate(zip(fold_img_paths, fold_mask_paths)):
-    fold_name = str(n + 1)
-    imgs = np.load(img_path)
-    masks = np.load(mask_path)
-
-    for i in range(imgs.shape[0]):
-        img = np.uint8(imgs[i])
-        mask_multichannel = np.minimum(np.uint8(masks[i]), 1)
-        mask = np.zeros((img.shape[0], img.shape[1]), dtype=np.uint8)
-        for j in range(mask_multichannel.shape[-1]):
-            factor = (j + 1) % mask_multichannel.shape[-1]
-            # convert [0,1,2,3,4,5] to [1,2,3,4,5,0],
-            # with the last label being background
-            mask[mask_multichannel[..., j] == 1] = factor
-
-        file_name = 'fold' + fold_name + '_' + str(i).rjust(4, '0') + '.png'
-        print('Processing: ', file_name)
-        tgt_img_path = os.path.join(tgt_img_dir, file_name)
-        tgt_mask_path = os.path.join(tgt_mask_dir, file_name)
-        Image.fromarray(img).save(tgt_img_path)
-        Image.fromarray(mask).save(tgt_mask_path)
-
-    del imgs
-    del masks
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/README.md b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/README.md
deleted file mode 100644
index 5a80949..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/README.md
+++ /dev/null
@@ -1,153 +0,0 @@
-# PCam (PatchCamelyon)
-
-## Description
-
-This project supports **`Patch Camelyon (PCam) `**, which can be downloaded from [here](https://opendatalab.com/PCam).
-
-### Dataset Overview
-
-PatchCamelyon is an image classification dataset. It consists of 327680 color images (96 x 96px) extracted from histopathologic scans of lymph node sections. Each image is annotated with a binary label indicating presence of metastatic tissue. PCam provides a new benchmark for machine learning models: bigger than CIFAR10, smaller than ImageNet, trainable on a single GPU.
-
-### Statistic Information
-
-| Dataset Name                         | Anatomical Region | Task Type    | Modality       | Num. Classes | Train/Val/Test images | Train/Val/Test Labeled | Release Date | License                                                       |
-| ------------------------------------ | ----------------- | ------------ | -------------- | ------------ | --------------------- | ---------------------- | ------------ | ------------------------------------------------------------- |
-| [Pcam](https://opendatalab.com/PCam) | throax            | segmentation | histopathology | 2            | 327680/-/-            | yes/-/-                | 2018         | [CC0 1.0](https://creativecommons.org/publicdomain/zero/1.0/) |
-
-|    Class Name     | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :---------------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-|    background     |   214849   |   63.77    |    -     |    -     |     -     |     -     |
-| metastatic tissue |   131832   |   36.22    |    -     |    -     |     -     |     -     |
-
-Note:
-
-- `Pct` means percentage of pixels in this category in all pixels.
-
-### Visualization
-
-![pcam](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/histopathology/pcam/pcam_dataset.png?raw=true)
-
-### Dataset Citation
-
-```
-@inproceedings{veeling2018rotation,
-	title={Rotation equivariant CNNs for digital pathology},
-	author={Veeling, Bastiaan S and Linmans, Jasper and Winkens, Jim and Cohen, Taco and Welling, Max},
-	booktitle={International Conference on Medical image computing and computer-assisted intervention},
-	pages={210--218},
-	year={2018},
-}
-```
-
-### Prerequisites
-
-- Python v3.8
-- PyTorch v1.10.0
-- pillow(PIL) v9.3.0 9.3.0
-- scikit-learn(sklearn) v1.2.0 1.2.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-
-All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `pcam/` root directory, run the following line to add the current directory to `PYTHONPATH`:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset Preparing
-
-- download dataset from [here](https://opendatalab.com/PCam) and decompress data to path `'data/'`.
-- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
-- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set cannot be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
-
-```shell
-mkdir data & cd data
-pip install opendatalab
-odl get PCam
-mv ./PCam/raw/pcamv1 ./
-rm -rf PCam
-cd ..
-python tools/prepare_dataset.py
-python ../../tools/split_seg_dataset.py
-```
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── histopathology
-  │   │   │   │   ├── pcam
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── train.txt
-  │   │   │   │   │   │   ├── val.txt
-  │   │   │   │   │   │   ├── images
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   ├── masks
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-```
-
-### Divided Dataset Information
-
-***Note: The table information below is divided by ourselves.***
-
-|    Class Name     | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :---------------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-|    background     |   171948   |   63.82    |  42901   |   63.6   |     -     |     -     |
-| metastatic tissue |   105371   |   36.18    |  26461   |   36.4   |     -     |     -     |
-
-### Training commands
-
-To train models on a single server with one GPU. (default)
-
-```shell
-mim train mmseg ./configs/${CONFIG_FILE}
-```
-
-### Testing commands
-
-To test models on a single server with one GPU. (default)
-
-```shell
-mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
-
-You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-  - [x] Basic docstrings & proper citation
-  - [ ] Test-time correctness
-  - [x] A full README
-
-- [ ] Milestone 2: Indicates a successful model implementation.
-
-  - [ ] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-  - [ ] Unit tests
-  - [ ] Code polishing
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_pcam-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_pcam-512x512.py
deleted file mode 100644
index 20601f1..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_pcam-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './pcam_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.pcam_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_pcam-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_pcam-512x512.py
deleted file mode 100644
index c057535..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_pcam-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './pcam_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.pcam_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_pcam-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_pcam-512x512.py
deleted file mode 100644
index 4c1d5fe..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_pcam-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './pcam_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.pcam_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_pcam-512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_pcam-512x512.py
deleted file mode 100644
index 25e3734..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_pcam-512x512.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './pcam_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.pcam_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(
-        num_classes=2, loss_decode=dict(use_sigmoid=True), out_channels=1),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/pcam_512x512.py b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/pcam_512x512.py
deleted file mode 100644
index 04efc23..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/configs/pcam_512x512.py
+++ /dev/null
@@ -1,42 +0,0 @@
-dataset_type = 'PCamDataset'
-data_root = 'data/'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='train.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='val.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/datasets/pcam_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/datasets/pcam_dataset.py
deleted file mode 100644
index 1c27de5..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/datasets/pcam_dataset.py
+++ /dev/null
@@ -1,31 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class PCamDataset(BaseSegDataset):
-    """PCamDataset dataset.
-
-    In segmentation map annotation for PCamDataset,
-    0 stands for background, which is included in 2 categories.
-    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
-    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
-
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-        reduce_zero_label (bool): Whether to mark label zero as ignored.
-            Default to False.
-    """
-    METAINFO = dict(classes=('background', 'metastatic tissue'))
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/histopathology/pcam/tools/prepare_dataset.py
deleted file mode 100644
index 75038e6..0000000
--- a/mmsegmentation/projects/medical/2d_image/histopathology/pcam/tools/prepare_dataset.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import os
-
-import h5py
-import numpy as np
-from PIL import Image
-
-root_path = 'data/'
-
-tgt_img_train_dir = os.path.join(root_path, 'images/train/')
-tgt_mask_train_dir = os.path.join(root_path, 'masks/train/')
-tgt_img_val_dir = os.path.join(root_path, 'images/val/')
-tgt_img_test_dir = os.path.join(root_path, 'images/test/')
-
-os.system('mkdir -p ' + tgt_img_train_dir)
-os.system('mkdir -p ' + tgt_mask_train_dir)
-os.system('mkdir -p ' + tgt_img_val_dir)
-os.system('mkdir -p ' + tgt_img_test_dir)
-
-
-def extract_pics_from_h5(h5_path, h5_key, save_dir):
-    f = h5py.File(h5_path, 'r')
-    for i, img in enumerate(f[h5_key]):
-        img = img.astype(np.uint8).squeeze()
-        img = Image.fromarray(img)
-        save_image_path = os.path.join(save_dir, str(i).zfill(8) + '.png')
-        img.save(save_image_path)
-
-
-if __name__ == '__main__':
-
-    extract_pics_from_h5(
-        'data/pcamv1/camelyonpatch_level_2_split_train_x.h5',
-        h5_key='x',
-        save_dir=tgt_img_train_dir)
-
-    extract_pics_from_h5(
-        'data/pcamv1/camelyonpatch_level_2_split_valid_x.h5',
-        h5_key='x',
-        save_dir=tgt_img_val_dir)
-
-    extract_pics_from_h5(
-        'data/pcamv1/camelyonpatch_level_2_split_test_x.h5',
-        h5_key='x',
-        save_dir=tgt_img_test_dir)
-
-    extract_pics_from_h5(
-        'data/pcamv1/camelyonpatch_level_2_split_train_mask.h5',
-        h5_key='mask',
-        save_dir=tgt_mask_train_dir)
diff --git a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/README.md b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/README.md
deleted file mode 100644
index ca95921..0000000
--- a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/README.md
+++ /dev/null
@@ -1,167 +0,0 @@
-# RAVIR: A Dataset and Methodology for the Semantic Segmentation and Quantitative Analysis of Retinal Arteries and Veins in Infrared Reflectance Imaging
-
-## Description
-
-This project support **`RAVIR: A Dataset and Methodology for the Semantic Segmentation and Quantitative Analysis of Retinal Arteries and Veins in Infrared Reflectance Imaging`**, and the dataset used in this project can be downloaded from [here](https://ravir.grand-challenge.org/).
-
-### Dataset Overview
-
-The retinal vasculature provides important clues in the diagnosis and monitoring of systemic diseases including hypertension and diabetes. The microvascular system is of primary involvement in such conditions, and the retina is the only anatomical site where the microvasculature can be directly observed. The objective assessment of retinal vessels has long been considered a surrogate biomarker for systemic vascular diseases, and with recent advancements in retinal imaging and computer vision technologies, this topic has become the subject of renewed attention. In this paper, we present a novel dataset, dubbed RAVIR, for the semantic segmentation of Retinal Arteries and Veins in Infrared Reflectance (IR) imaging. It enables the creation of deep learning-based models that distinguish extracted vessel type without extensive post-processing.
-
-### Original Statistic Information
-
-| Dataset name                                | Anatomical region | Task type    | Modality                     | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                         |
-| ------------------------------------------- | ----------------- | ------------ | ---------------------------- | ------------ | --------------------- | ---------------------- | ------------ | --------------------------------------------------------------- |
-| [Ravir](https://ravir.grand-challenge.org/) | eye               | segmentation | infrared reflectance imaging | 3            | 23/-/19               | yes/-/-                | 2022         | [CC-BY-NC 4.0](https://creativecommons.org/licenses/by-sa/4.0/) |
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |     23     |   87.22    |    -     |    -     |     -     |     -     |
-|   artery   |     23     |    5.45    |    -     |    -     |     -     |     -     |
-|    vein    |     23     |    7.33    |    -     |    -     |     -     |     -     |
-
-Note:
-
-- `Pct` means percentage of pixels in this category in all pixels.
-
-### Visualization
-
-![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/infrared_reflectance_imaging/ravir/ravir_dataset.png)
-
-## Dataset Citation
-
-```bibtex
-@article{hatamizadeh2022ravir,
-  title={RAVIR: A dataset and methodology for the semantic segmentation and quantitative analysis of retinal arteries and veins in infrared reflectance imaging},
-  author={Hatamizadeh, Ali and Hosseini, Hamid and Patel, Niraj and Choi, Jinseo and Pole, Cameron C and Hoeferlin, Cory M and Schwartz, Steven D and Terzopoulos, Demetri},
-  journal={IEEE Journal of Biomedical and Health Informatics},
-  volume={26},
-  number={7},
-  pages={3272--3283},
-  year={2022},
-  publisher={IEEE}
-}
-```
-
-### Prerequisites
-
-- Python v3.8
-- PyTorch v1.10.0
-- pillow(PIL) v9.3.0
-- scikit-learn(sklearn) v1.2.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-
-All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `ravir/` root directory, run the following line to add the current directory to `PYTHONPATH`:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset preparing
-
-- download dataset from [here](https://ravir.grand-challenge.org/) and decompression data to path `'data/ravir/'`.
-- run script `"python tools/prepare_dataset.py"` to split dataset and change folder structure as below.
-- run script `"python ../../tools/split_seg_dataset.py --data_root data/ravir"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set can't be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── infrared_reflectance_imaging
-  │   │   │   │   ├── ravir
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── train.txt
-  │   │   │   │   │   │   ├── val.txt
-  │   │   │   │   │   │   ├── images
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   │   ├── test
-  │   │   │   │   |   │   │   │   ├── yyy.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── yyy.png
-  │   │   │   │   │   │   ├── masks
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-```
-
-### Divided Dataset Information
-
-***Note: The table information below is divided by ourselves.***
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |     18     |   87.41    |    5     |  86.53   |     -     |     -     |
-|   artery   |     18     |    5.44    |    5     |   5.50   |     -     |     -     |
-|    vein    |     18     |    7.15    |    5     |   7.97   |     -     |     -     |
-
-### Training commands
-
-To train models on a single server with one GPU. (default）
-
-```shell
-mim train mmseg ./configs/${CONFIG_PATH}
-```
-
-### Testing commands
-
-To train models on a single server with one GPU. (default）
-
-```shell
-mim test mmseg ./configs/${CONFIG_PATH}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
-
-You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
-
-## Results
-
-### Ravir
-
-|     Method      | Backbone | Crop Size |   lr   |                                   config                                   |
-| :-------------: | :------: | :-------: | :----: | :------------------------------------------------------------------------: |
-| fcn_unet_s5-d16 |   unet   |  512x512  |  0.01  |  [config](./configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_ravir-512x512.py)  |
-| fcn_unet_s5-d16 |   unet   |  512x512  | 0.001  | [config](./configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_ravir-512x512.py)  |
-| fcn_unet_s5-d16 |   unet   |  512x512  | 0.0001 | [config](./configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_ravir-512x512.py) |
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-
-  - [x] Basic docstrings & proper citation
-
-  - [x] Test-time correctness
-
-  - [x] A full README
-
-- [x] Milestone 2: Indicates a successful model implementation.
-
-  - [x] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-
-  - [ ] Unit tests
-
-  - [ ] Code polishing
-
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_ravir-512x512.py b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_ravir-512x512.py
deleted file mode 100755
index 375ad5a..0000000
--- a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_ravir-512x512.py
+++ /dev/null
@@ -1,19 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './ravir_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.ravir_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    pretrained=None,
-    decode_head=dict(num_classes=3),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_ravir-512x512.py b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_ravir-512x512.py
deleted file mode 100755
index a7ecf6d..0000000
--- a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_ravir-512x512.py
+++ /dev/null
@@ -1,19 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './ravir_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.ravir_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=dict(size=img_scale),
-    pretrained=None,
-    decode_head=dict(num_classes=3),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_ravir-512x512.py b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_ravir-512x512.py
deleted file mode 100755
index 28556df..0000000
--- a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_ravir-512x512.py
+++ /dev/null
@@ -1,19 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './ravir_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.ravir_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    pretrained=None,
-    decode_head=dict(num_classes=3),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/ravir_512x512.py b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/ravir_512x512.py
deleted file mode 100755
index cb4c292..0000000
--- a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/configs/ravir_512x512.py
+++ /dev/null
@@ -1,42 +0,0 @@
-dataset_type = 'RAVIRDataset'
-data_root = 'data/ravir'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='train.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='val.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/datasets/__init__.py b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/datasets/__init__.py
deleted file mode 100755
index 6f1d051..0000000
--- a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/datasets/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-from .ravir_dataset import RAVIRDataset
-
-__all__ = ['RAVIRDataset']
diff --git a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/datasets/ravir_dataset.py b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/datasets/ravir_dataset.py
deleted file mode 100755
index c9e0a8e..0000000
--- a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/datasets/ravir_dataset.py
+++ /dev/null
@@ -1,28 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class RAVIRDataset(BaseSegDataset):
-    """RAVIRDataset dataset.
-
-    In segmentation map annotation for RAVIRDataset, 0 stands for background,
-    which is included in 3 categories. ``reduce_zero_label`` is fixed to
-    False. The ``img_suffix`` is fixed to '.png' and ``seg_map_suffix`` is
-    fixed to '.png'.
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-    """
-    METAINFO = dict(classes=('background', 'artery', 'vein'))
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/tools/prepare_dataset.py
deleted file mode 100644
index 068dcad..0000000
--- a/mmsegmentation/projects/medical/2d_image/infrared_reflectance_imaging/ravir/tools/prepare_dataset.py
+++ /dev/null
@@ -1,33 +0,0 @@
-import glob
-import os
-
-import numpy as np
-from PIL import Image
-from tqdm import tqdm
-
-# map = {255:2, 128:1, 0:0}
-
-os.makedirs('data/ravir/images/train', exist_ok=True)
-os.makedirs('data/ravir/images/test', exist_ok=True)
-os.makedirs('data/ravir/masks/train', exist_ok=True)
-
-os.system(
-    r'cp data/ravir/RAVIR\ Dataset/train/training_images/* data/ravir/images/train'  # noqa
-)
-os.system(
-    r'cp data/ravir/RAVIR\ Dataset/train/training_masks/* data/ravir/masks/train'  # noqa
-)
-os.system(r'cp data/ravir/RAVIR\ Dataset/test/* data/ravir/images/test')
-
-os.system(r'rm -rf data/ravir/RAVIR\ Dataset')
-
-imgs = glob.glob(os.path.join('data/ravir/masks/train', '*.png'))
-
-for im_path in tqdm(imgs):
-    im = Image.open(im_path)
-    imn = np.array(im)
-    imn[imn == 255] = 2
-    imn[imn == 128] = 1
-    imn[imn == 0] = 0
-    new_im = Image.fromarray(imn)
-    new_im.save(im_path)
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/README.md b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/README.md
deleted file mode 100644
index 1feb433..0000000
--- a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/README.md
+++ /dev/null
@@ -1,153 +0,0 @@
-# 2-PM Vessel Dataset
-
-## Description
-
-This project supports **`2-PM Vessel Dataset`**, which can be downloaded from [here](https://opendatalab.org.cn/2-PM_Vessel_Dataset).
-
-### Dataset Overview
-
-An open-source volumetric brain vasculature dataset obtained with two-photon microscopy at Focused Ultrasound Lab, at Sunnybrook Research Institute (affiliated with University of Toronto by Dr. Alison Burgess, Charissa Poon and Marc Santos).
-
-The dataset contains a total of 12 volumetric stacks consisting images of mouse brain vasculature and tumor vasculature.
-
-### Information Statistics
-
-| Dataset Name                                                 | Anatomical Region | Task Type    | Modality          | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                       |
-| ------------------------------------------------------------ | ----------------- | ------------ | ----------------- | ------------ | --------------------- | ---------------------- | ------------ | ------------------------------------------------------------- |
-| [2pm_vessel](https://opendatalab.org.cn/2-PM_Vessel_Dataset) | vessel            | segmentation | microscopy_images | 2            | 216/-/-               | yes/-/-                | 2021         | [CC0 1.0](https://creativecommons.org/publicdomain/zero/1.0/) |
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |    216     |   85.78    |    -     |    -     |     -     |     -     |
-|   vessel   |    180     |   14.22    |    -     |    -     |     -     |     -     |
-
-Note:
-
-- `Pct` means percentage of pixels in this category in all pixels.
-
-### Visualization
-
-![2pmv](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/histopathology/2pm_vessel/2pm_vessel_dataset.png?raw=true)
-
-### Dataset Citation
-
-```
-@article{teikari2016deep,
-	title={Deep learning convolutional networks for multiphoton microscopy vasculature segmentation},
-	author={Teikari, Petteri and Santos, Marc and Poon, Charissa and Hynynen, Kullervo},
-	journal={arXiv preprint arXiv:1606.02382},
-	year={2016}
-}
-```
-
-### Prerequisites
-
-- Python v3.8
-- PyTorch v1.10.0
-- pillow(PIL) v9.3.0
-- scikit-learn(sklearn) v1.2.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-
-All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `2pm_vessel/` root directory, run the following line to add the current directory to `PYTHONPATH`:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset Preparing
-
-- download dataset from [here](https://opendatalab.org.cn/2-PM_Vessel_Dataset) and decompress data to path `'data/'`.
-- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
-- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set can't be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
-
-```shell
-mkdir data & cd data
-pip install opendatalab
-odl get    2-PM_Vessel_Dataset
-cd ..
-python tools/prepare_dataset.py
-python ../../tools/split_seg_dataset.py
-```
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── microscopy_images
-  │   │   │   │   ├── 2pm_vessel
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── train.txt
-  │   │   │   │   │   │   ├── val.txt
-  │   │   │   │   │   │   ├── images
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   ├── masks
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-
-```
-
-### Divided Dataset Information
-
-***Note: The table information below is divided by ourselves.***
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |    172     |   85.88    |    44    |   85.4   |     -     |     -     |
-|   vessel   |    142     |   14.12    |    38    |   14.6   |     -     |     -     |
-
-### Training commands
-
-To train models on a single server with one GPU. (default)
-
-```shell
-mim train mmseg ./configs/${CONFIG_FILE}
-```
-
-### Testing commands
-
-To test models on a single server with one GPU. (default)
-
-```shell
-mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
-
-You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-  - [x] Basic docstrings & proper citation
-  - [ ] Test-time correctness
-  - [x] A full README
-
-- [ ] Milestone 2: Indicates a successful model implementation.
-
-  - [ ] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-  - [ ] Unit tests
-  - [ ] Code polishing
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/2pm-vessel_512x512.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/2pm-vessel_512x512.py
deleted file mode 100644
index 124403f..0000000
--- a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/2pm-vessel_512x512.py
+++ /dev/null
@@ -1,42 +0,0 @@
-dataset_type = 'TwoPMVesselDataset'
-data_root = 'data/'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='train.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='val.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_2pm-vessel-512x512.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_2pm-vessel-512x512.py
deleted file mode 100644
index 2a429e9..0000000
--- a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_2pm-vessel-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './2pm-vessel_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.2pm-vessel_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_2pm-vessel-512x512.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_2pm-vessel-512x512.py
deleted file mode 100644
index 10d9bb8..0000000
--- a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_2pm-vessel-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './2pm-vessel_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.2pm-vessel_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_2pm-vessel-512x512.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_2pm-vessel-512x512.py
deleted file mode 100644
index 65c1579..0000000
--- a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_2pm-vessel-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './2pm-vessel_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.2pm-vessel_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_bactteria-detection-512x512.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_bactteria-detection-512x512.py
deleted file mode 100644
index 91ed6ad..0000000
--- a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/configs/fcn-unet-s5-d16_unet_1xb16-0.01lr-sigmoid-20k_bactteria-detection-512x512.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './2pm-vessel_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.2pm-vessel_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(
-        num_classes=2, loss_decode=dict(use_sigmoid=True), out_channels=1),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/datasets/2pm-vessel_dataset.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/datasets/2pm-vessel_dataset.py
deleted file mode 100644
index 984b5a1..0000000
--- a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/datasets/2pm-vessel_dataset.py
+++ /dev/null
@@ -1,31 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class TwoPMVesselDataset(BaseSegDataset):
-    """TwoPMVesselDataset dataset.
-
-    In segmentation map annotation for TwoPMVesselDataset,
-    0 stands for background, which is included in 2 categories.
-    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
-    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
-
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-        reduce_zero_label (bool): Whether to mark label zero as ignored.
-            Default to False.
-    """
-    METAINFO = dict(classes=('background', 'vessel'))
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/tools/prepare_dataset.py
deleted file mode 100644
index 1b46af2..0000000
--- a/mmsegmentation/projects/medical/2d_image/microscopy_images/2pm_vessel/tools/prepare_dataset.py
+++ /dev/null
@@ -1,46 +0,0 @@
-import os
-
-import tifffile as tiff
-from PIL import Image
-
-root_path = 'data/'
-
-image_dir = os.path.join(root_path,
-                         '2-PM_Vessel_Dataset/raw/vesselNN_dataset/denoised')
-label_dir = os.path.join(root_path,
-                         '2-PM_Vessel_Dataset/raw/vesselNN_dataset/labels')
-tgt_img_train_dir = os.path.join(root_path, 'images/train/')
-tgt_mask_train_dir = os.path.join(root_path, 'masks/train/')
-os.system('mkdir -p ' + tgt_img_train_dir)
-os.system('mkdir -p ' + tgt_mask_train_dir)
-
-
-def filter_suffix(src_dir, suffix):
-    suffix = '.' + suffix if '.' not in suffix else suffix
-    file_names = [_ for _ in os.listdir(src_dir) if _.endswith(suffix)]
-    file_paths = [os.path.join(src_dir, _) for _ in file_names]
-    return sorted(file_paths), sorted(file_names)
-
-
-if __name__ == '__main__':
-
-    image_path_list, _ = filter_suffix(image_dir, suffix='tif')
-    label_path_list, _ = filter_suffix(label_dir, suffix='.tif')
-
-    for img_path, label_path in zip(image_path_list, label_path_list):
-        labels = tiff.imread(label_path)
-        images = tiff.imread(img_path)
-        assert labels.ndim == 3
-        assert images.shape == labels.shape
-        name = img_path.split('/')[-1].replace('.tif', '')
-        # a single .tif file contains multiple slices
-        # as long as it is read by tifffile package.
-        for i in range(labels.shape[0]):
-            slice_name = name + '_' + str(i).rjust(3, '0') + '.png'
-            image = images[i]
-            label = labels[i] // 255
-
-            save_path_label = os.path.join(tgt_mask_train_dir, slice_name)
-            Image.fromarray(label).save(save_path_label)
-            save_path_image = os.path.join(tgt_img_train_dir, slice_name)
-            Image.fromarray(image).convert('RGB').save(save_path_image)
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/README.md b/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/README.md
deleted file mode 100644
index 1cedda7..0000000
--- a/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/README.md
+++ /dev/null
@@ -1,160 +0,0 @@
-# Bactteria detection with darkfield microscopy
-
-## Description
-
-This project supports **`Bactteria detection with darkfield microscopy`**, which can be downloaded from [here](https://tianchi.aliyun.com/dataset/94411).
-
-### Dataset Overview
-
-Spirochaeta is a genus of bacteria classified within the phylum Spirochaetes. Included in this dataset are 366 darkfield microscopy images and manually annotated masks which can be used for classification and segmentation purposes. Detecting bacteria in blood could have a huge significance for research in both the medical and computer science field.
-
-It was gathered and annotated by students (hand-on experience)
-It has more than just one targeted class (blood cell and bacteria were annotated)
-It is highly imbalanced, so naive loss functions would work less properly
-
-### Original Statistic Information
-
-| Dataset name                                                    | Anatomical region | Task type    | Modality   | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                         |
-| --------------------------------------------------------------- | ----------------- | ------------ | ---------- | ------------ | --------------------- | ---------------------- | ------------ | --------------------------------------------------------------- |
-| [Bactteria detection](https://tianchi.aliyun.com/dataset/94411) | bacteria          | segmentation | microscopy | 3            | 366/-/-               | yes/-/-                | 2017         | [CC-BY-NC 4.0](https://creativecommons.org/licenses/by-sa/4.0/) |
-
-|  Class Name  | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :----------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-|  background  |    366     |    85.9    |    -     |    -     |     -     |     -     |
-| erythrocytes |    345     |   13.03    |    -     |    -     |     -     |     -     |
-| spirochaete  |    288     |    1.07    |    -     |    -     |     -     |     -     |
-
-Note:
-
-- `Pct` means percentage of pixels in this category in all pixels.
-
-### Visualization
-
-![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/microscopy_images/bactteria_detection/bactteria_detection_dataset.png)
-
-## Usage
-
-### Prerequisites
-
-- Python v3.8
-- PyTorch v1.10.0
-- pillow (PIL) v9.3.0
-- scikit-learn (sklearn) v1.2.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-
-All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `bactteria_detection/` root directory, run the following line to add the current directory to `PYTHONPATH`:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset Preparing
-
-- Download dataset from [here](https://tianchi.aliyun.com/dataset/94411) and save it to the `data/` directory .
-- Decompress data to path `data/`. This will create a new folder named `data/Bacteria_detection_with_darkfield_microscopy_datasets/`, which contains the original image data.
-- run script `python tools/prepare_dataset.py` to format data and change folder structure as below.
-- run script `python ../../tools/split_seg_dataset.py` to split dataset. For the Bacteria_detection dataset, as there is no test or validation dataset, we sample 20% samples from the whole dataset as the validation dataset and 80% samples for training data and make two filename lists `train.txt` and `val.txt`. As we set the random seed as the hard code, we eliminated the randomness, the dataset split actually can be reproducible.
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── microscopy_images
-  │   │   │   │   ├── bactteria_detection
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── train.txt
-  │   │   │   │   │   │   ├── val.txt
-  │   │   │   │   │   │   ├── Bacteria_detection_with_darkfield_microscopy_datasets
-  │   │   │   │   │   │   ├── images
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   ├── masks
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-```
-
-### Divided Dataset Information
-
-***Note: The table information below is divided by ourselves.***
-
-|  Class Name  | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :----------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-|  background  |    292     |   85.66    |    74    |   86.7   |     -     |     -     |
-| erythrocytes |    274     |   13.25    |    71    |  12.29   |     -     |     -     |
-| spirochaete  |    231     |    1.09    |    57    |   1.01   |     -     |     -     |
-
-### Training commands
-
-Train models on a single server with one GPU.
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-mim train mmseg ./configs/${CONFIG_FILE}
-```
-
-### Testing commands
-
-Test models on a single server with one GPU.
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
-
-You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
-
-## Results
-
-### Bactteria detection with darkfield microscopy
-
-***Note: The following experimental results are based on the data randomly partitioned according to the above method described in the dataset preparing section.***
-
-|     Method      | Backbone | Crop Size |   lr   | mIoU  | mDice |                                          config                                          |         download         |
-| :-------------: | :------: | :-------: | :----: | :---: | :---: | :--------------------------------------------------------------------------------------: | :----------------------: |
-| fcn_unet_s5-d16 |   unet   |  512x512  |  0.01  | 76.48 | 84.68 |  [config](./configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_bactteria-detection-512x512.py)  | [model](<>) \| [log](<>) |
-| fcn_unet_s5-d16 |   unet   |  512x512  | 0.001  | 61.06 | 63.69 | [config](./configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_bactteria-detection-512x512.py)  | [model](<>) \| [log](<>) |
-| fcn_unet_s5-d16 |   unet   |  512x512  | 0.0001 | 58.87 | 62.42 | [config](./configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_bactteria-detection-512x512.py) | [model](<>) \| [log](<>) |
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-
-  - [x] Basic docstrings & proper citation
-
-  - [x] Test-time correctness
-
-  - [x] A full README
-
-- [x] Milestone 2: Indicates a successful model implementation.
-
-  - [x] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-
-  - [ ] Unit tests
-
-  - [ ] Code polishing
-
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/bactteria-detection_512x512.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/bactteria-detection_512x512.py
deleted file mode 100644
index e3eab4e..0000000
--- a/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/bactteria-detection_512x512.py
+++ /dev/null
@@ -1,42 +0,0 @@
-dataset_type = 'BactteriaDetectionDataset'
-data_root = 'data/'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='train.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='val.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_bactteria-detection-512x512.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_bactteria-detection-512x512.py
deleted file mode 100644
index ede58d7..0000000
--- a/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_bactteria-detection-512x512.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    './bactteria-detection_512x512.py',
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.bactteria-detection_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=3),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_bactteria-detection-512x512.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_bactteria-detection-512x512.py
deleted file mode 100644
index bde3fa1..0000000
--- a/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_bactteria-detection-512x512.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    './bactteria-detection_512x512.py',
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.bactteria-detection_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=3),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_bactteria-detection-512x512.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_bactteria-detection-512x512.py
deleted file mode 100644
index 08e204f..0000000
--- a/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_bactteria-detection-512x512.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    './bactteria-detection_512x512.py',
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.bactteria-detection_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=3),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/datasets/bactteria-detection_dataset.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/datasets/bactteria-detection_dataset.py
deleted file mode 100644
index c95097b..0000000
--- a/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/datasets/bactteria-detection_dataset.py
+++ /dev/null
@@ -1,27 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class BactteriaDetectionDataset(BaseSegDataset):
-    """BactteriaDetectionDataset dataset.
-
-    In segmentation map annotation for BactteriaDetectionDataset,
-    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
-    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
-
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-    """
-    METAINFO = dict(classes=('background', 'erythrocytes', 'spirochaete'))
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=False,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/tools/prepare_dataset.py
deleted file mode 100755
index 8dcc719..0000000
--- a/mmsegmentation/projects/medical/2d_image/microscopy_images/bactteria_detection/tools/prepare_dataset.py
+++ /dev/null
@@ -1,33 +0,0 @@
-import glob
-import os
-import shutil
-
-from PIL import Image
-
-root_path = 'data/'
-img_suffix = '.png'
-seg_map_suffix = '.png'
-save_img_suffix = '.png'
-save_seg_map_suffix = '.png'
-
-x_train = glob.glob(
-    'data/Bacteria_detection_with_darkfield_microscopy_datasets/images/*' +
-    img_suffix)  # noqa
-
-os.system('mkdir -p ' + root_path + 'images/train/')
-os.system('mkdir -p ' + root_path + 'masks/train/')
-
-part_dir_dict = {0: 'train/'}
-for ith, part in enumerate([x_train]):
-    part_dir = part_dir_dict[ith]
-    for img in part:
-        basename = os.path.basename(img)
-        img_save_path = os.path.join(root_path, 'images', part_dir,
-                                     basename.split('.')[0] + save_img_suffix)
-        shutil.copy(img, img_save_path)
-        mask_path = 'data/Bacteria_detection_with_darkfield_microscopy_datasets/masks/' + basename  # noqa
-        mask = Image.open(mask_path).convert('L')
-        mask_save_path = os.path.join(
-            root_path, 'masks', part_dir,
-            basename.split('.')[0] + save_seg_map_suffix)
-        mask.save(mask_save_path)
diff --git a/mmsegmentation/projects/medical/2d_image/tools/split_seg_dataset.py b/mmsegmentation/projects/medical/2d_image/tools/split_seg_dataset.py
deleted file mode 100644
index 9ab2e92..0000000
--- a/mmsegmentation/projects/medical/2d_image/tools/split_seg_dataset.py
+++ /dev/null
@@ -1,42 +0,0 @@
-import argparse
-import glob
-import os
-
-from sklearn.model_selection import train_test_split
-
-
-def save_anno(img_list, file_path, remove_suffix=True):
-    if remove_suffix:
-        img_list = [
-            '/'.join(img_path.split('/')[-2:]) for img_path in img_list
-        ]
-        img_list = [
-            '.'.join(img_path.split('.')[:-1]) for img_path in img_list
-        ]
-    with open(file_path, 'w') as file_:
-        for x in list(img_list):
-            file_.write(x + '\n')
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--data_root', default='data/')
-    args = parser.parse_args()
-    data_root = args.data_root
-    if os.path.exists(os.path.join(data_root, 'masks/val')):
-        x_val = sorted(glob.glob(data_root + '/images/val/*.png'))
-        save_anno(x_val, data_root + '/val.txt')
-    if os.path.exists(os.path.join(data_root, 'masks/test')):
-        x_test = sorted(glob.glob(data_root + '/images/test/*.png'))
-        save_anno(x_test, data_root + '/test.txt')
-    if not os.path.exists(os.path.join(
-            data_root, 'masks/val')) and not os.path.exists(
-                os.path.join(data_root, 'masks/test')):
-        all_imgs = sorted(glob.glob(data_root + '/images/train/*.png'))
-        x_train, x_val = train_test_split(
-            all_imgs, test_size=0.2, random_state=0)
-        save_anno(x_train, data_root + '/train.txt')
-        save_anno(x_val, data_root + '/val.txt')
-    else:
-        x_train = sorted(glob.glob(data_root + '/images/train/*.png'))
-        save_anno(x_train, data_root + '/train.txt')
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/README.md b/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/README.md
deleted file mode 100644
index a1cd27b..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/README.md
+++ /dev/null
@@ -1,147 +0,0 @@
-# Chest Image Dataset for Pneumothorax Segmentation
-
-## Description
-
-This project supports **`Chest Image Dataset for Pneumothorax Segmentation`**, which can be downloaded from [here](https://tianchi.aliyun.com/dataset/83075).
-
-### Dataset Overview
-
-Pneumothorax can be caused by a blunt chest injury, damage from underlying lung disease, or most horrifying—it may occur for no obvious reason at all. On some occasions, a collapsed lung can be a life-threatening event.
-Pneumothorax is usually diagnosed by a radiologist on a chest x-ray, and can sometimes be very difficult to confirm. An accurate AI algorithm to detect pneumothorax would be useful in a lot of clinical scenarios. AI could be used to triage chest radiographs for priority interpretation, or to provide a more confident diagnosis for non-radiologists.
-
-The dataset is provided by the Society for Imaging Informatics in Medicine(SIIM), American College of Radiology (ACR),Society of Thoracic Radiology (STR) and MD.ai. You can develop a model to classify (and if present, segment) pneumothorax from a set of chest radiographic images. If successful, you could aid in the early recognition of pneumothoraces and save lives.
-
-### Original Statistic Information
-
-| Dataset name                                                          | Anatomical region | Task type    | Modality | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                            |
-| --------------------------------------------------------------------- | ----------------- | ------------ | -------- | ------------ | --------------------- | ---------------------- | ------------ | ------------------------------------------------------------------ |
-| [pneumothorax segmentation](https://tianchi.aliyun.com/dataset/83075) | thorax            | segmentation | x_ray    | 2            | 12089/-/3205          | yes/-/no               | -            | [CC-BY-SA-NC 4.0](https://creativecommons.org/licenses/by-sa/4.0/) |
-
-|    Class Name     | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :---------------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-|      normal       |   12089    |   99.75    |    -     |    -     |     -     |     -     |
-| pneumothorax area |    2669    |    0.25    |    -     |    -     |     -     |     -     |
-
-Note:
-
-- `Pct` means percentage of pixels in this category in all pixels.
-
-### Visualization
-
-![bac](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/x_ray/chest_image_pneum/chest_image_pneum_dataset.png)
-
-### Prerequisites
-
-- Python v3.8
-- PyTorch v1.10.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-
-All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `chest_image_pneum/` root directory, run the following line to add the current directory to `PYTHONPATH`:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset preparing
-
-- download dataset from [here](https://tianchi.aliyun.com/dataset/83075) and decompress data to path `'data/'`.
-- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
-- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set can't be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── x_ray
-  │   │   │   │   ├── chest_image_pneum
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── train.txt
-  │   │   │   │   │   │   ├── test.txt
-  │   │   │   │   │   │   ├── images
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   ├── masks
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-```
-
-### Divided Dataset Information
-
-***Note: The table information below is divided by ourselves.***
-
-|    Class Name     | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :---------------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-|      normal       |    9637    |   99.75    |   2410   |  99.74   |     -     |     -     |
-| pneumothorax area |    2137    |    0.25    |   532    |   0.26   |     -     |     -     |
-
-### Training commands
-
-Train models on a single server with one GPU.
-
-```shell
-mim train mmseg ./configs/${CONFIG_FILE}
-```
-
-### Testing commands
-
-Test models on a single server with one GPU.
-
-```shell
-mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
-
-You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
-
-## Results
-
-### Bactteria detection with darkfield microscopy
-
-|     Method      | Backbone | Crop Size |   lr   | mIoU | mDice |                                         config                                         |         download         |
-| :-------------: | :------: | :-------: | :----: | :--: | :---: | :------------------------------------------------------------------------------------: | :----------------------: |
-| fcn_unet_s5-d16 |   unet   |  512x512  |  0.01  |  -   |   -   |  [config](./configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_chest-image-pneum-512x512.py)  | [model](<>) \| [log](<>) |
-| fcn_unet_s5-d16 |   unet   |  512x512  | 0.001  |  -   |   -   | [config](./configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_chest-image-pneum-512x512.py)  | [model](<>) \| [log](<>) |
-| fcn_unet_s5-d16 |   unet   |  512x512  | 0.0001 |  -   |   -   | [config](./configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_chest-image-pneum-512x512.py) | [model](<>) \| [log](<>) |
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-
-  - [x] Basic docstrings & proper citation
-
-  - [x] Test-time correctness
-
-  - [x] A full README
-
-- [x] Milestone 2: Indicates a successful model implementation.
-
-  - [x] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-
-  - [ ] Unit tests
-
-  - [ ] Code polishing
-
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/chest-image-pneum_512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/chest-image-pneum_512x512.py
deleted file mode 100644
index 411229b..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/chest-image-pneum_512x512.py
+++ /dev/null
@@ -1,42 +0,0 @@
-dataset_type = 'ChestImagePneumDataset'
-data_root = 'data/'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='train.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='val.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_chest-image-pneum-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_chest-image-pneum-512x512.py
deleted file mode 100644
index 0f26459..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_chest-image-pneum-512x512.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    './chest-image-pneum_512x512.py',
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.chest-image-pneum_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_chest-image-pneum-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_chest-image-pneum-512x512.py
deleted file mode 100644
index 37b9188..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_chest-image-pneum-512x512.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    './chest-image-pneum_512x512.py',
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.chest-image-pneum_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_chest-image-pneum-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_chest-image-pneum-512x512.py
deleted file mode 100644
index 379e818..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_chest-image-pneum-512x512.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    './chest-image-pneum_512x512.py',
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.chest-image-pneum_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/datasets/chest-image-pneum_dataset.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/datasets/chest-image-pneum_dataset.py
deleted file mode 100644
index aeee60a..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/datasets/chest-image-pneum_dataset.py
+++ /dev/null
@@ -1,27 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class ChestImagePneumDataset(BaseSegDataset):
-    """ChestImagePneumDataset dataset.
-
-    In segmentation map annotation for ChestImagePneumDataset,
-    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
-    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
-
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-    """
-    METAINFO = dict(classes=('normal', 'pneumothorax area'))
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=False,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/tools/prepare_dataset.py
deleted file mode 100755
index 47eddc9..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/chest_image_pneum/tools/prepare_dataset.py
+++ /dev/null
@@ -1,73 +0,0 @@
-import os
-
-import numpy as np
-import pandas as pd
-import pydicom
-from PIL import Image
-
-root_path = 'data/'
-img_suffix = '.dcm'
-seg_map_suffix = '.png'
-save_img_suffix = '.png'
-save_seg_map_suffix = '.png'
-
-x_train = []
-for fpath, dirname, fnames in os.walk('data/chestimage_train_datasets'):
-    for fname in fnames:
-        if fname.endswith('.dcm'):
-            x_train.append(os.path.join(fpath, fname))
-x_test = []
-for fpath, dirname, fnames in os.walk('data/chestimage_test_datasets/'):
-    for fname in fnames:
-        if fname.endswith('.dcm'):
-            x_test.append(os.path.join(fpath, fname))
-
-os.system('mkdir -p ' + root_path + 'images/train/')
-os.system('mkdir -p ' + root_path + 'images/test/')
-os.system('mkdir -p ' + root_path + 'masks/train/')
-
-
-def rle_decode(rle, width, height):
-    mask = np.zeros(width * height, dtype=np.uint8)
-    array = np.asarray([int(x) for x in rle.split()])
-    starts = array[0::2]
-    lengths = array[1::2]
-
-    current_position = 0
-    for index, start in enumerate(starts):
-        current_position += start
-        mask[current_position:current_position + lengths[index]] = 1
-        current_position += lengths[index]
-
-    return mask.reshape(width, height, order='F')
-
-
-part_dir_dict = {0: 'train/', 1: 'test/'}
-dict_from_csv = pd.read_csv(
-    root_path + 'chestimage_train-rle_datasets.csv', sep=',',
-    index_col=0).to_dict()[' EncodedPixels']
-
-for ith, part in enumerate([x_train, x_test]):
-    part_dir = part_dir_dict[ith]
-    for img in part:
-        basename = os.path.basename(img)
-        img_id = '.'.join(basename.split('.')[:-1])
-        if ith == 0 and (img_id not in dict_from_csv.keys()):
-            continue
-        image = pydicom.read_file(img).pixel_array
-        save_img_path = root_path + 'images/' + part_dir + '.'.join(
-            basename.split('.')[:-1]) + save_img_suffix
-        print(save_img_path)
-        img_h, img_w = image.shape[:2]
-        image = Image.fromarray(image)
-        image.save(save_img_path)
-        if ith == 1:
-            continue
-        if dict_from_csv[img_id] == '-1':
-            mask = np.zeros((img_h, img_w), dtype=np.uint8)
-        else:
-            mask = rle_decode(dict_from_csv[img_id], img_h, img_w)
-        save_mask_path = root_path + 'masks/' + part_dir + '.'.join(
-            basename.split('.')[:-1]) + save_seg_map_suffix
-        mask = Image.fromarray(mask)
-        mask.save(save_mask_path)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/README.md b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/README.md
deleted file mode 100644
index 7cb099c..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/README.md
+++ /dev/null
@@ -1,119 +0,0 @@
-# Chest X-ray Images with Pneumothorax Masks
-
-## Description
-
-This project support **`Chest X-ray Images with Pneumothorax Masks `**, and the dataset used in this project can be downloaded from [here](https://www.kaggle.com/datasets/vbookshelf/pneumothorax-chest-xray-images-and-masks).
-
-### Dataset Overview
-
-A pneumothorax (noo-moe-THOR-aks) is a collapsed lung. A pneumothorax occurs when air leaks into the space between your lung and chest wall. This air pushes on the outside of your lung and makes it collapse. Pneumothorax can be a complete lung collapse or a collapse of only a portion of the lung.
-
-A pneumothorax can be caused by a blunt or penetrating chest injury, certain medical procedures, or damage from underlying lung disease. Or it may occur for no obvious reason. Symptoms usually include sudden chest pain and shortness of breath. On some occasions, a collapsed lung can be a life-threatening event.
-
-Treatment for a pneumothorax usually involves inserting a needle or chest tube between the ribs to remove the excess air. However, a small pneumothorax may heal on its own.
-
-### Statistic Information
-
-| Dataset Name                                                                                                                      | Anatomical Region | Task type    | Modality | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release date | License                                                         |
-| --------------------------------------------------------------------------------------------------------------------------------- | ----------------- | ------------ | -------- | ------------ | --------------------- | ---------------------- | ------------ | --------------------------------------------------------------- |
-| [Chest-x-ray-images-with-pneumothorax-masks](https://www.kaggle.com/datasets/vbookshelf/pneumothorax-chest-xray-images-and-masks) | throax            | segmentation | x_ray    | 2            | 10675/-/1372          | yes/-/yes              | 2020         | [CC-BY-NC 4.0](https://creativecommons.org/licenses/by-sa/4.0/) |
-
-|  Class Name  | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :----------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-|  background  |   10675    |    99.7    |    -     |    -     |   1372    |   99.71   |
-| pneumothroax |    2379    |    0.3     |    -     |    -     |    290    |   0.29    |
-
-### Visualization
-
-![chest_x_ray_images_with_pneumothorax_masks](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/x_ray/chest_x_ray_images_with_pneumothorax_masks/chest_x_ray_images_with_pneumothorax_masks_dataset.png?raw=true)
-
-### Prerequisites
-
-- Python 3.8
-- PyTorch 1.10.0
-- pillow(PIL) 9.3.0
-- scikit-learn(sklearn) 1.2.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-
-All the commands below rely on the correct configuration of PYTHONPATH, which should point to the project's directory so that Python can locate the module files. In chest_x_ray_images_with_pneumothorax_masks/ root directory, run the following line to add the current directory to PYTHONPATH:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset preparing
-
-- download dataset from [here](https://www.kaggle.com/datasets/vbookshelf/pneumothorax-chest-xray-images-and-masks) and decompression data to path 'data/'.
-- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
-- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set cannot be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── x_ray
-  │   │   │   │   ├── chest_x_ray_images_with_pneumothorax_masks
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── train.txt
-  │   │   │   │   │   │   ├── val.txt
-  │   │   │   │   │   │   ├── images
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   ├── masks
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-```
-
-### Training commands
-
-```shell
-mim train mmseg ./configs/${CONFIG_PATH}
-```
-
-To train on multiple GPUs, e.g. 8 GPUs, run the following command:
-
-```shell
-mim train mmseg ./configs/${CONFIG_PATH}  --launcher pytorch --gpus 8
-```
-
-### Testing commands
-
-```shell
-mim test mmseg ./configs/${CONFIG_PATH}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-  - [x] Basic docstrings & proper citation
-  - [x] Test-time correctness
-  - [x] A full README
-
-- [x] Milestone 2: Indicates a successful model implementation.
-
-  - [x] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-  - [ ] Unit tests
-  - [ ] Code polishing
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/chest-x-ray-images-with-pneumothorax-masks_512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/chest-x-ray-images-with-pneumothorax-masks_512x512.py
deleted file mode 100644
index 96676de..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/chest-x-ray-images-with-pneumothorax-masks_512x512.py
+++ /dev/null
@@ -1,42 +0,0 @@
-dataset_type = 'ChestPenumoMaskDataset'
-data_root = 'data/'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='train.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='val.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
deleted file mode 100644
index 76c214d..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
+++ /dev/null
@@ -1,20 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    './chest-x-ray-images-with-pneumothorax-masks_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(
-    imports='datasets.chest-x-ray-images-with-pneumothorax-masks_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(
-        num_classes=2, loss_decode=dict(use_sigmoid=True), out_channels=1),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
deleted file mode 100644
index 066996d..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
+++ /dev/null
@@ -1,19 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    './chest-x-ray-images-with-pneumothorax-masks_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(
-    imports='datasets.chest-x-ray-images-with-pneumothorax-masks_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
deleted file mode 100644
index a7065b8..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
+++ /dev/null
@@ -1,19 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    './chest-x-ray-images-with-pneumothorax-masks_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(
-    imports='datasets.chest-x-ray-images-with-pneumothorax-masks_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
deleted file mode 100644
index e5682ee..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
+++ /dev/null
@@ -1,19 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    './chest-x-ray-images-with-pneumothorax-masks_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(
-    imports='datasets.chest-x-ray-images-with-pneumothorax-masks_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/datasets/chest-x-ray-images-with-pneumothorax-masks_dataset.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/datasets/chest-x-ray-images-with-pneumothorax-masks_dataset.py
deleted file mode 100644
index d32f597..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/datasets/chest-x-ray-images-with-pneumothorax-masks_dataset.py
+++ /dev/null
@@ -1,31 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class ChestPenumoMaskDataset(BaseSegDataset):
-    """ChestPenumoMaskDataset dataset.
-
-    In segmentation map annotation for ChestPenumoMaskDataset,
-    0 stands for background, which is included in 2 categories.
-    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
-    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
-
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-        reduce_zero_label (bool): Whether to mark label zero as ignored.
-            Default to False.
-    """
-    METAINFO = dict(classes=('background', 'penumothroax'))
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/tools/prepare_dataset.py
deleted file mode 100644
index c7de1f1..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/tools/prepare_dataset.py
+++ /dev/null
@@ -1,36 +0,0 @@
-import glob
-import os
-import shutil
-
-from PIL import Image
-from sklearn.model_selection import train_test_split
-
-root_path = 'data/'
-img_suffix = '.png'
-seg_map_suffix = '.png'
-save_img_suffix = '.png'
-save_seg_map_suffix = '.png'
-
-all_imgs = glob.glob('data/siim-acr-pneumothorax/png_images/*' + img_suffix)
-x_train, x_test = train_test_split(all_imgs, test_size=0.2, random_state=0)
-
-print(len(x_train), len(x_test))
-os.system('mkdir -p ' + root_path + 'images/train/')
-os.system('mkdir -p ' + root_path + 'images/val/')
-os.system('mkdir -p ' + root_path + 'masks/train/')
-os.system('mkdir -p ' + root_path + 'masks/val/')
-
-part_dir_dict = {0: 'train/', 1: 'val/'}
-for ith, part in enumerate([x_train, x_test]):
-    part_dir = part_dir_dict[ith]
-    for img in part:
-        basename = os.path.basename(img)
-        img_save_path = os.path.join(root_path, 'images', part_dir,
-                                     basename.split('.')[0] + save_img_suffix)
-        shutil.copy(img, img_save_path)
-        mask_path = 'data/siim-acr-pneumothorax/png_masks/' + basename
-        mask = Image.open(mask_path).convert('L')
-        mask_save_path = os.path.join(
-            root_path, 'masks', part_dir,
-            basename.split('.')[0] + save_seg_map_suffix)
-        mask.save(mask_save_path)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/README.md b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/README.md
deleted file mode 100644
index 8469219..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/README.md
+++ /dev/null
@@ -1,158 +0,0 @@
-# Covid-19 CT Chest X-ray Dataset
-
-## Description
-
-This project supports **`Covid-19 CT Chest X-ray Dataset`**, which can be downloaded from [here](https://github.com/ieee8023/covid-chestxray-dataset).
-
-### Dataset Overview
-
-In the context of a COVID-19 pandemic, we want to improve prognostic predictions to triage and manage patient care. Data is the first step to developing any diagnostic/prognostic tool. While there exist large public datasets of more typical chest X-rays from the NIH \[Wang 2017\], Spain \[Bustos 2019\], Stanford \[Irvin 2019\], MIT \[Johnson 2019\] and Indiana University \[Demner-Fushman 2016\], there is no collection of COVID-19 chest X-rays or CT scans designed to be used for computational analysis.
-
-The 2019 novel coronavirus (COVID-19) presents several unique features [Fang, 2020](https://pubs.rsna.org/doi/10.1148/radiol.2020200432) and [Ai 2020](https://pubs.rsna.org/doi/10.1148/radiol.2020200642). While the diagnosis is confirmed using polymerase chain reaction (PCR), infected patients with pneumonia may present on chest X-ray and computed tomography (CT) images with a pattern that is only moderately characteristic for the human eye [Ng, 2020](https://pubs.rsna.org/doi/10.1148/ryct.2020200034). In late January, a Chinese team published a paper detailing the clinical and paraclinical features of COVID-19. They reported that patients present abnormalities in chest CT images with most having bilateral involvement [Huang 2020](<https://www.thelancet.com/journals/lancet/article/PIIS0140-6736(20)30183-5/fulltext>). Bilateral multiple lobular and subsegmental areas of consolidation constitute the typical findings in chest CT images of intensive care unit (ICU) patients on admission [Huang 2020](<https://www.thelancet.com/journals/lancet/article/PIIS0140-6736(20)30183-5/fulltext>). In comparison, non-ICU patients show bilateral ground-glass opacity and subsegmental areas of consolidation in their chest CT images [Huang 2020](<https://www.thelancet.com/journals/lancet/article/PIIS0140-6736(20)30183-5/fulltext>). In these patients, later chest CT images display bilateral ground-glass opacity with resolved consolidation [Huang 2020](<https://www.thelancet.com/journals/lancet/article/PIIS0140-6736(20)30183-5/fulltext>).
-
-### Statistic Information
-
-| Dataset Name                                                           | Anatomical Region | Task Type    | Modality | Nnum. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release date | License                                                               |
-| ---------------------------------------------------------------------- | ----------------- | ------------ | -------- | ------------- | --------------------- | ---------------------- | ------------ | --------------------------------------------------------------------- |
-| [Covid-19-ct-cxr](https://github.com/ieee8023/covid-chestxray-dataset) | thorax            | segmentation | x_ray    | 2             | 205/-/714             | yes/-/no               | 2021         | [CC-BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) |
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |    205     |   72.84    |    -     |    -     |     -     |     -     |
-|    lung    |    205     |   27.16    |    -     |    -     |     -     |     -     |
-
-Note:
-
-- `Pct` means percentage of pixels in this category in all pixels.
-
-### Visualization
-
-![cov19ctcxr](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/x_ray/covid_19_ct_cxr/covid_19_ct_cxr_dataset.png?raw=true)
-
-### Dataset Citation
-
-```
-@article{cohen2020covidProspective,
-  title={{COVID-19} Image Data Collection: Prospective Predictions Are the Future},
-  author={Joseph Paul Cohen and Paul Morrison and Lan Dao and Karsten Roth and Tim Q Duong and Marzyeh Ghassemi},
-  journal={arXiv 2006.11988},
-  year={2020}
-}
-
-@article{cohen2020covid,
-  title={COVID-19 image data collection},
-  author={Joseph Paul Cohen and Paul Morrison and Lan Dao},
-  journal={arXiv 2003.11597},
-  year={2020}
-}
-```
-
-### Prerequisites
-
-- Python v3.8
-- PyTorch v1.10.0
-- pillow(PIL) v9.3.0 9.3.0
-- scikit-learn(sklearn) v1.2.0 1.2.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-
-All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `covid_19_ct_cxr/` root directory, run the following line to add the current directory to `PYTHONPATH`:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset Preparing
-
-- download dataset from [here](https://github.com/ieee8023/covid-chestxray-dataset) and decompress data to path `'data/'`.
-- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
-- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set cannot be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
-
-```shell
-mkdir data && cd data
-git clone git@github.com:ieee8023/covid-chestxray-dataset.git
-cd ..
-python tools/prepare_dataset.py
-python ../../tools/split_seg_dataset.py
-```
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── x_ray
-  │   │   │   │   ├── covid_19_ct_cxr
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── train.txt
-  │   │   │   │   │   │   ├── val.txt
-  │   │   │   │   │   │   ├── images
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   ├── masks
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-```
-
-### Divided Dataset Information
-
-***Note: The table information below is divided by ourselves.***
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |    164     |   72.88    |    41    |  72.69   |     -     |     -     |
-|    lung    |    164     |   27.12    |    41    |  27.31   |     -     |     -     |
-
-### Training commands
-
-To train models on a single server with one GPU. (default)
-
-```shell
-mim train mmseg ./configs/${CONFIG_FILE}
-```
-
-### Testing commands
-
-To test models on a single server with one GPU. (default)
-
-```shell
-mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
-
-You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-  - [x] Basic docstrings & proper citation
-  - [x] Test-time correctness
-  - [x] A full README
-
-- [x] Milestone 2: Indicates a successful model implementation.
-
-  - [x] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-  - [ ] Unit tests
-  - [ ] Code polishing
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/covid-19-ct-cxr_512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/covid-19-ct-cxr_512x512.py
deleted file mode 100644
index 5242d06..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/covid-19-ct-cxr_512x512.py
+++ /dev/null
@@ -1,42 +0,0 @@
-dataset_type = 'Covid19CXRDataset'
-data_root = 'data/'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='train.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='val.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_covid-19-ct-cxr-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_covid-19-ct-cxr-512x512.py
deleted file mode 100644
index 59a7bed..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_covid-19-ct-cxr-512x512.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './covid-19-ct-cxr_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.covid-19-ct-cxr_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(
-        num_classes=2, loss_decode=dict(use_sigmoid=True), out_channels=1),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_covid-19-ct-cxr-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_covid-19-ct-cxr-512x512.py
deleted file mode 100644
index 83b8527..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_covid-19-ct-cxr-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './covid-19-ct-cxr_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.covid-19-ct-cxr_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_covid-19-ct-cxr-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_covid-19-ct-cxr-512x512.py
deleted file mode 100644
index 10cfcbd..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_covid-19-ct-cxr-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './covid-19-ct-cxr_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.covid-19-ct-cxr_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_covid-19-ct-cxr-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_covid-19-ct-cxr-512x512.py
deleted file mode 100644
index aaccc8f..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_covid-19-ct-cxr-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './covid-19-ct-cxr_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.covid-19-ct-cxr_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/datasets/covid-19-ct-cxr_dataset.py b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/datasets/covid-19-ct-cxr_dataset.py
deleted file mode 100644
index 68a1bb3..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/datasets/covid-19-ct-cxr_dataset.py
+++ /dev/null
@@ -1,31 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class Covid19CXRDataset(BaseSegDataset):
-    """Covid19CXRDataset dataset.
-
-    In segmentation map annotation for Covid19CXRDataset,
-    0 stands for background, which is included in 2 categories.
-    ``reduce_zero_label`` is fixed to False. The ``img_suffix``
-    is fixed to '.png' and ``seg_map_suffix`` is fixed to '.png'.
-
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-        reduce_zero_label (bool): Whether to mark label zero as ignored.
-            Default to False.
-    """
-    METAINFO = dict(classes=('background', 'lung'))
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/tools/prepare_dataset.py
deleted file mode 100644
index 72f6435..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/covid_19_ct_cxr/tools/prepare_dataset.py
+++ /dev/null
@@ -1,52 +0,0 @@
-import os
-
-import numpy as np
-from PIL import Image
-
-root_path = 'data/'
-src_img_dir = os.path.join(root_path, 'covid-chestxray-dataset', 'images')
-src_mask_dir = os.path.join(root_path, 'covid-chestxray-dataset',
-                            'annotations/lungVAE-masks')
-tgt_img_train_dir = os.path.join(root_path, 'images/train/')
-tgt_mask_train_dir = os.path.join(root_path, 'masks/train/')
-tgt_img_test_dir = os.path.join(root_path, 'images/test/')
-os.system('mkdir -p ' + tgt_img_train_dir)
-os.system('mkdir -p ' + tgt_mask_train_dir)
-os.system('mkdir -p ' + tgt_img_test_dir)
-
-
-def convert_label(img, convert_dict):
-    arr = np.zeros_like(img, dtype=np.uint8)
-    for c, i in convert_dict.items():
-        arr[img == c] = i
-    return arr
-
-
-if __name__ == '__main__':
-
-    all_img_names = os.listdir(src_img_dir)
-    all_mask_names = os.listdir(src_mask_dir)
-
-    for img_name in all_img_names:
-        base_name = img_name.replace('.png', '')
-        base_name = base_name.replace('.jpg', '')
-        base_name = base_name.replace('.jpeg', '')
-        mask_name_orig = base_name + '_mask.png'
-        if mask_name_orig in all_mask_names:
-            mask_name = base_name + '.png'
-            src_img_path = os.path.join(src_img_dir, img_name)
-            src_mask_path = os.path.join(src_mask_dir, mask_name_orig)
-            tgt_img_path = os.path.join(tgt_img_train_dir, img_name)
-            tgt_mask_path = os.path.join(tgt_mask_train_dir, mask_name)
-
-            img = Image.open(src_img_path).convert('RGB')
-            img.save(tgt_img_path)
-            mask = np.array(Image.open(src_mask_path))
-            mask = convert_label(mask, {0: 0, 255: 1})
-            mask = Image.fromarray(mask)
-            mask.save(tgt_mask_path)
-        else:
-            src_img_path = os.path.join(src_img_dir, img_name)
-            tgt_img_path = os.path.join(tgt_img_test_dir, img_name)
-            img = Image.open(src_img_path).convert('RGB')
-            img.save(tgt_img_path)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/crass/README.md b/mmsegmentation/projects/medical/2d_image/x_ray/crass/README.md
deleted file mode 100644
index 0621205..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/crass/README.md
+++ /dev/null
@@ -1,144 +0,0 @@
-# Chest Radiograph Anatomical Structure Segmentation (CRASS)
-
-## Description
-
-This project supports **`Chest Radiograph Anatomical Structure Segmentation (CRASS) `**, which can be downloaded from [here](https://crass.grand-challenge.org/).
-
-### Dataset Overview
-
-A set of consecutively obtained posterior-anterior chest radiograph were selected from a database containing images acquired at two sites in sub Saharan Africa with a high tuberculosis incidence. All subjects were 15 years or older. Images from digital chest radiography units were used (Delft Imaging Systems, The Netherlands) of varying resolutions, with a typical resolution of 1800--2000 pixels, the pixel size was 250 lm isotropic. From the total set of images, 225 were considered to be normal by an expert radiologist, while 333 of the images contained abnormalities. Of the abnormal images, 220 contained abnormalities in the upper area of the lung where the clavicle is located. The data was divided into a training and a test set. The training set consisted of 299 images, the test set of 249 images.
-The current data is still incomplete and to be added later.
-
-### Information Statistics
-
-| Dataset Name                                | Anatomical Region | Task Type    | Modality | Num. Classes | Train/Val/Test Images | Train/Val/Test Labeled | Release Date | License                                                       |
-| ------------------------------------------- | ----------------- | ------------ | -------- | ------------ | --------------------- | ---------------------- | ------------ | ------------------------------------------------------------- |
-| [crass](https://crass.grand-challenge.org/) | pulmonary         | segmentation | x_ray    | 2            | 299/-/234             | yes/-/no               | 2021         | [CC0 1.0](https://creativecommons.org/publicdomain/zero/1.0/) |
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |    299     |   98.38    |    -     |    -     |     -     |     -     |
-| clavicles  |    299     |    1.62    |    -     |    -     |     -     |     -     |
-
-Note:
-
-- `Pct` means percentage of pixels in this category in all pixels.
-
-### Visualization
-
-![crass](https://raw.githubusercontent.com/uni-medical/medical-datasets-visualization/main/2d/semantic_seg/x_ray/crass/crass_dataset.png?raw=true)
-
-### Dataset Citation
-
-```
-@article{HOGEWEG20121490,
-	title={Clavicle segmentation in chest radiographs},
-	journal={Medical Image Analysis},
-	volume={16},
-	number={8},
-	pages={1490-1502},
-	year={2012}
-}
-```
-
-### Prerequisites
-
-- Python v3.8
-- PyTorch v1.10.0
-- pillow(PIL) v9.3.0
-- scikit-learn(sklearn) v1.2.0
-- [MIM](https://github.com/open-mmlab/mim) v0.3.4
-- [MMCV](https://github.com/open-mmlab/mmcv) v2.0.0rc4
-- [MMEngine](https://github.com/open-mmlab/mmengine) v0.2.0 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
-
-All the commands below rely on the correct configuration of `PYTHONPATH`, which should point to the project's directory so that Python can locate the module files. In `crass/` root directory, run the following line to add the current directory to `PYTHONPATH`:
-
-```shell
-export PYTHONPATH=`pwd`:$PYTHONPATH
-```
-
-### Dataset Preparing
-
-- download dataset from [here](https://crass.grand-challenge.org/) and decompress data to path `'data/'`.
-- run script `"python tools/prepare_dataset.py"` to format data and change folder structure as below.
-- run script `"python ../../tools/split_seg_dataset.py"` to split dataset and generate `train.txt`, `val.txt` and `test.txt`. If the label of official validation set and test set cannot be obtained, we generate `train.txt` and `val.txt` from the training set randomly.
-
-```none
-  mmsegmentation
-  ├── mmseg
-  ├── projects
-  │   ├── medical
-  │   │   ├── 2d_image
-  │   │   │   ├── x_ray
-  │   │   │   │   ├── crass
-  │   │   │   │   │   ├── configs
-  │   │   │   │   │   ├── datasets
-  │   │   │   │   │   ├── tools
-  │   │   │   │   │   ├── data
-  │   │   │   │   │   │   ├── train.txt
-  │   │   │   │   │   │   ├── val.txt
-  │   │   │   │   │   │   ├── images
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-  │   │   │   │   │   │   ├── masks
-  │   │   │   │   │   │   │   ├── train
-  │   │   │   │   |   │   │   │   ├── xxx.png
-  │   │   │   │   |   │   │   │   ├── ...
-  │   │   │   │   |   │   │   │   └── xxx.png
-```
-
-### Divided Dataset Information
-
-***Note: The table information below is divided by ourselves.***
-
-| Class Name | Num. Train | Pct. Train | Num. Val | Pct. Val | Num. Test | Pct. Test |
-| :--------: | :--------: | :--------: | :------: | :------: | :-------: | :-------: |
-| background |    227     |   98.38    |    57    |  98.39   |     -     |     -     |
-| clavicles  |    227     |    1.62    |    57    |   1.61   |     -     |     -     |
-
-### Training commands
-
-To train models on a single server with one GPU. (default)
-
-```shell
-mim train mmseg ./configs/${CONFIG_FILE}
-```
-
-### Testing commands
-
-To test models on a single server with one GPU. (default)
-
-```shell
-mim test mmseg ./configs/${CONFIG_FILE}  --checkpoint ${CHECKPOINT_PATH}
-```
-
-<!-- List the results as usually done in other model's README. [Example](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models)
-
-You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project. -->
-
-## Checklist
-
-- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
-
-  - [x] Finish the code
-  - [x] Basic docstrings & proper citation
-  - [ ] Test-time correctness
-  - [x] A full README
-
-- [x] Milestone 2: Indicates a successful model implementation.
-
-  - [x] Training-time correctness
-
-- [ ] Milestone 3: Good to be a part of our core package!
-
-  - [ ] Type hints and docstrings
-  - [ ] Unit tests
-  - [ ] Code polishing
-  - [ ] Metafile.yml
-
-- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
-- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/crass_512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/crass_512x512.py
deleted file mode 100644
index 1425f50..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/crass_512x512.py
+++ /dev/null
@@ -1,42 +0,0 @@
-dataset_type = 'CRASSDataset'
-data_root = 'data/'
-img_scale = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=img_scale, keep_ratio=False),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs')
-]
-train_dataloader = dict(
-    batch_size=16,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='train.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        ann_file='tval.txt',
-        data_prefix=dict(img_path='images/', seg_map_path='masks/'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
-test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU', 'mDice'])
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_crass-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_crass-512x512.py
deleted file mode 100644
index b52bc78..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_crass-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './crass_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.crass_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_crass-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_crass-512x512.py
deleted file mode 100644
index 45242c6..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_crass-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './crass_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.crass_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_crass-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_crass-512x512.py
deleted file mode 100644
index bcf9d0a..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_crass-512x512.py
+++ /dev/null
@@ -1,17 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './crass_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.crass_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-lr0.01-sigmoid-20k_crass-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-lr0.01-sigmoid-20k_crass-512x512.py
deleted file mode 100644
index 0dde736..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/crass/configs/fcn-unet-s5-d16_unet_1xb16-lr0.01-sigmoid-20k_crass-512x512.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py', './crass_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(imports='datasets.crass_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(
-        num_classes=2, loss_decode=dict(use_sigmoid=True), out_channels=1),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/crass/datasets/crass_dataset.py b/mmsegmentation/projects/medical/2d_image/x_ray/crass/datasets/crass_dataset.py
deleted file mode 100644
index f6b5c52..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/crass/datasets/crass_dataset.py
+++ /dev/null
@@ -1,30 +0,0 @@
-from mmseg.datasets import BaseSegDataset
-from mmseg.registry import DATASETS
-
-
-@DATASETS.register_module()
-class CRASSDataset(BaseSegDataset):
-    """CRASSDataset dataset.
-
-    In segmentation map annotation for CRASSDataset, 0 stands for background,
-    which is included in 2 categories. ``reduce_zero_label`` is fixed to
-    False. The ``img_suffix`` is fixed to '.png' and ``seg_map_suffix`` is
-    fixed to '.png'.
-    Args:
-        img_suffix (str): Suffix of images. Default: '.png'
-        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
-        reduce_zero_label (bool): Whether to mark label zero as ignored.
-            Default to False..
-    """
-    METAINFO = dict(classes=('background', 'clavicles'))
-
-    def __init__(self,
-                 img_suffix='.png',
-                 seg_map_suffix='.png',
-                 reduce_zero_label=False,
-                 **kwargs) -> None:
-        super().__init__(
-            img_suffix=img_suffix,
-            seg_map_suffix=seg_map_suffix,
-            reduce_zero_label=reduce_zero_label,
-            **kwargs)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/crass/tools/prepare_dataset.py b/mmsegmentation/projects/medical/2d_image/x_ray/crass/tools/prepare_dataset.py
deleted file mode 100644
index bbd5d88..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/crass/tools/prepare_dataset.py
+++ /dev/null
@@ -1,84 +0,0 @@
-import glob
-import os
-
-import cv2
-import SimpleITK as sitk
-from PIL import Image
-
-root_path = 'data/'
-img_suffix = '.tif'
-seg_map_suffix = '.png'
-save_img_suffix = '.png'
-save_seg_map_suffix = '.png'
-
-src_img_train_dir = os.path.join(root_path, 'CRASS/data_train')
-src_mask_train_dir = os.path.join(root_path, 'CRASS/mask_mhd')
-src_img_test_dir = os.path.join(root_path, 'CRASS/data_test')
-
-tgt_img_train_dir = os.path.join(root_path, 'images/train/')
-tgt_mask_train_dir = os.path.join(root_path, 'masks/train/')
-tgt_img_test_dir = os.path.join(root_path, 'images/test/')
-os.system('mkdir -p ' + tgt_img_train_dir)
-os.system('mkdir -p ' + tgt_mask_train_dir)
-os.system('mkdir -p ' + tgt_img_test_dir)
-
-
-def filter_suffix_recursive(src_dir, suffix):
-    suffix = '.' + suffix if '.' not in suffix else suffix
-    file_paths = glob(
-        os.path.join(src_dir, '**', '*' + suffix), recursive=True)
-    file_names = [_.split('/')[-1] for _ in file_paths]
-    return sorted(file_paths), sorted(file_names)
-
-
-def read_single_array_from_med(path):
-    return sitk.GetArrayFromImage(sitk.ReadImage(path)).squeeze()
-
-
-def convert_meds_into_pngs(src_dir,
-                           tgt_dir,
-                           suffix='.dcm',
-                           norm_min=0,
-                           norm_max=255,
-                           convert='RGB'):
-    if not os.path.exists(tgt_dir):
-        os.makedirs(tgt_dir)
-
-    src_paths, src_names = filter_suffix_recursive(src_dir, suffix=suffix)
-    num = len(src_paths)
-    for i, (src_name, src_path) in enumerate(zip(src_names, src_paths)):
-        tgt_name = src_name.replace(suffix, '.png')
-        tgt_path = os.path.join(tgt_dir, tgt_name)
-
-        img = read_single_array_from_med(src_path)
-        if norm_min is not None and norm_max is not None:
-            img = cv2.normalize(img, None, norm_min, norm_max, cv2.NORM_MINMAX,
-                                cv2.CV_8U)
-        pil = Image.fromarray(img).convert(convert)
-        pil.save(tgt_path)
-        print(f'processed {i+1}/{num}.')
-
-
-convert_meds_into_pngs(
-    src_img_train_dir,
-    tgt_img_train_dir,
-    suffix='.mhd',
-    norm_min=0,
-    norm_max=255,
-    convert='RGB')
-
-convert_meds_into_pngs(
-    src_img_test_dir,
-    tgt_img_test_dir,
-    suffix='.mhd',
-    norm_min=0,
-    norm_max=255,
-    convert='RGB')
-
-convert_meds_into_pngs(
-    src_mask_train_dir,
-    tgt_mask_train_dir,
-    suffix='.mhd',
-    norm_min=0,
-    norm_max=1,
-    convert='L')
diff --git a/mmsegmentation/projects/nvidia_jetson/README.md b/mmsegmentation/projects/nvidia_jetson/README.md
deleted file mode 100644
index 6cebd9c..0000000
--- a/mmsegmentation/projects/nvidia_jetson/README.md
+++ /dev/null
@@ -1,372 +0,0 @@
-# 将 MMSeg 模型调优及部署到 NVIDIA Jetson 平台教程
-
-- 请先查阅[MMSegmentation 模型部署](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/5_deployment.md)文档。
-- **本教程所用 mmsegmentation 版本： v1.1.2**
-- **本教程所用 NVIDIA Jetson 设备： NVIDIA Jetson AGX Orin 64G**
-
-<div align="center">
-    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/b5466cfd-71a9-4e06-9823-c253a97d57b5" alt="Smiley face" width="50%">
-</div>
-
-## 1 配置 [mmsegmentation](https://github.com/open-mmlab/mmsegmentation)
-
-- 根据[安装和验证](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/get_started.md)文档，完成开发 [mmsegmentation](https://github.com/open-mmlab/mmsegmentation) 所需的 [`pytorch`](https://pytorch.org/get-started/locally/)、[`mmcv`](https://github.com/open-mmlab/mmcv)、[`mmengine`](https://github.com/open-mmlab/mmengine) 等环境依赖安装。
-- 从 GitHub 使用 git clone 命令完成 [mmsegmentation](https://github.com/open-mmlab/mmsegmentation) 下载。网络不好的同学，可通过 [MMSeg GitHub](https://github.com/open-mmlab/mmsegmentation) 页面进行 zip 的下载。
-  ```bash
-  git clone https://github.com/open-mmlab/mmsegmentation.git
-  ```
-- 使用 `pip install -v -e.` 命令动态安装 mmsegmentation 。
-  ```bash
-  cd mmsegmentation
-  pip install -v -e .
-  ```
-  提示成功安装后，可通过 `pip list` 命令查看到 mmsegmentation 已通过本地安装方式安装到了您的环境中。
-  ![mmseg-install](https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/a9c7bcc9-cdcc-40a4-bd7b-8153195549c8)
-
-## 2 准备您的数据集
-
-- 本教程使用遥感图像语义分割数据集 [potsdam](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#isprs-potsdam) 作为示例。
-- 根据 [potsdam 数据准备](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/user_guides/2_dataset_prepare.md#isprs-potsdam)文档，进行数据集下载及 MMSeg 格式的准备。
-- 数据集介绍： potsdam 数据集是以德国一个典型的历史城市 Potsdam 命名的，该城市有着大建筑群、狭窄的街道和密集的建筑结构。 potsdam 数据集包含 38 幅 6000x6000 像素的图像，空间分辨率为 5cm，数据集的示例如下图：
-  ![potsdam-img](https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/3bc0a75b-1693-4ae6-aeea-ad502e955068)
-
-## 3 从 config 页面下载模型的 pth 权重文件
-
-这里以 [`deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py`](../../configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py) 配置文件举例，在 [configs](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/deeplabv3plus#potsdam) 页面下载权重文件，
-![pth](https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/8f747362-caf4-406c-808d-4ca72babb209)
-
-## 4 通过 [OpenMMLab deployee](https://platform.openmmlab.com/deploee) 以交互式方式进行模型转换及测速
-
-### 4.1 模型转换
-
-在该部分中，[OpenMMLab 官网](https://platform.openmmlab.com/deploee)提供了模型转换及模型测速的交互界面，无需任何代码，即可通过选择对应选项完成模型 ONNX 格式`xxxx.onnx` 和 TensorRT `.engine`格式的转换。
-如您的自定义 config 文件中有相对引用关系，如：
-
-```python
-# xxxx.py
-_base_ = [
-    '../_base_/models/deeplabv3plus_r50-d8.py',
-    '../_base_/datasets/potsdam.py',
-    '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-```
-
-您可以使用以下代码消除相对引用关系，以生成完整的 config 文件。
-
-```python
-import mmengine
-
-mmengine.Config.fromfile("configs/deeplabv3plus/deeplabv3plus_r101-d8_4xb4-80k_potsdam-512x512.py").dump("My_config.py")
-```
-
-使用上述代码后，您能够看到，在`My_config.py`包含着完整的配置文件，无相对引用。这时，上传模型 config 至网页内对应处。
-
-#### 创建转换任务
-
-按照下图提示及自己的需求，创建转换任务并提交。
-
-<div align="center">
-    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/4918d2f9-d63c-480f-97f1-054529770cfd" alt="NVIDIA-Jetson" width="80%">
-</div>
-
-### 4.2 模型测速
-
-在完成模型转换后可通过**模型测速**界面，完成在真实设备上的模型测速。
-
-#### 创建测速任务
-
-<div align="center">
-    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/27340556-c81a-4ce3-8560-2c4727d3355e" alt="NVIDIA-Jetson" width="100%">
-</div>
-
-<div align="center">
-    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/6f4fc3a9-ba9d-4829-8407-ed1470ba7bf3" alt="NVIDIA-Jetson" width="100%">
-</div>
-
-测速完成后，可在页面生成完整的测速报告。[查看测速报告示例](https://openmmlab-deploee.oss-cn-shanghai.aliyuncs.com/tmp/profile_speed/4352f5.txt)
-
-## 5 通过 OpenMMLab mmdeploy 以命令行将模型转换为ONNX格式
-
-该部分可以通过 mmdeploy 库对 mmseg 训练好的模型进行推理格式的转换。这里给出一个示例，具体文档可见[ mmdeploy 模型转换文档](../../docs/zh_cn/user_guides/5_deployment.md)。
-
-### 5.1 通过源码构建 mmdeploy 库
-
-在您安装 mmsegmentation 库的虚拟环境下，通过 `git clone`命令从 GitHub 克隆 [mmdeploy](https://github.com/open-mmlab/mmdeploy)
-
-### 5.2 模型转换
-
-如您的 config 中含有相对引用，仍需进行消除，如[4.1 模型转换](#4.1-模型转换)所述,
-进入 mmdeploy 文件夹，执行以下命令，即可完成模型转换。
-
-```bash
-python tools/deploy.py \
-    configs/mmseg/segmentation_onnxruntime_static-512x512.py \
-    ../atl_config.py \
-    ../deeplabv3plus_r18-d8_512x512_80k_potsdam_20211219_020601-75fd5bc3.pth \
-    ../2_13_1024_5488_1536_6000.png \
-    --work-dir ../atl_models \
-    --device cpu \
-    --show \
-    --dump-info
-```
-
-```bash
-# 使用方法
-python ./tools/deploy.py \
-    ${部署配置文件路径} \
-    ${模型配置文件路径} \
-    ${模型权重路径} \
-    ${输入图像路径} \
-    --work-dir ${用来保存日志和模型文件路径} \
-    --device ${cpu/cuda:0} \
-    --show \    # 是否显示检测的结果
-    --dump-info # 是否输出 SDK 信息
-
-```
-
-执行成功后，您将能够看到以下提示，即为转换成功。
-
-```bash
-10/08 17:40:44 - mmengine - INFO - visualize pytorch model success.
-10/08 17:40:44 - mmengine - INFO - All process success.
-```
-
-<div align="center">
-    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/b752ccf8-903f-4ad3-ad7c-74fc25cb89a5" alt="NVIDIA-Jetson" width="400">
-</div>
-
-# 6 在 Jetson 平台进行转换及部署
-
-## 6.1 环境准备
-
-参考[如何在 Jetson 模组上安装 MMDeploy](https://github.com/open-mmlab/mmdeploy/blob/main/docs/zh_cn/01-how-to-build/jetsons.md)文档，完成在 Jetson 上的环境准备工作。
-**注**：安装 Pytorch，可查阅 [NVIDIA Jetson Pytorch 安装文档](https://github.com/open-mmlab/mmdeploy/blob/main/docs/zh_cn/01-how-to-build/jetsons.md)安装最新的 Pytorch。
-
-### 6.1.1 创建虚拟环境
-
-```bash
-conda create -n {您虚拟环境的名字} python={python版本}
-```
-
-### 6.1.2 虚拟环境内安装Pytorch
-
-<font color="red">注意：</font>这里不要安装最新的 pytorch 2.0，因为 pyTorch 1.11 是最后一个使用 USE_DISTRIBUTED 构建的wheel，否则会在用mmdeploy进行模型转换的时候提示`AttributeError: module 'torch.distributed' has no attribute 'ReduceOp'`的错误。参考以下链接：https://forums.developer.nvidia.com/t/module-torch-distributed-has-no-attribute-reduceop/256581/6
-下载`torch-1.11.0-cp38-cp38-linux_aarch64.whl`并安装
-
-```bash
-pip install torch-1.11.0-cp38-cp38-linux_aarch64.whl
-```
-
-执行以上命令后，您将能看到以下提示，即为安装成功。
-
-```bash
-Processing ./torch-1.11.0-cp38-cp38-linux_aarch64.whl
-Requirement already satisfied: typing-extensions in /home/sirs/miniconda3/envs/openmmlab/lib/python3.8/site-packages (from torch==1.11.0) (4.7.1)
-Installing collected packages: torch
-Successfully installed torch-1.11.0
-```
-
-### 6.1.3 将 Jetson Pack 自带的 tensorrt 拷贝至虚拟环境下
-
-请参考[配置 TensorRT](https://github.com/open-mmlab/mmdeploy/blob/main/docs/zh_cn/01-how-to-build/jetsons.md#%E9%85%8D%E7%BD%AE-tensorrt)。
-JetPack SDK 自带 TensorRT。 但是为了能够在 Conda 环境中成功导入，我们需要将 TensorRT 拷贝进先前创建的 Conda 环境中。
-
-```bash
-export PYTHON_VERSION=`python3 --version | cut -d' ' -f 2 | cut -d'.' -f1,2`
-cp -r /usr/lib/python${PYTHON_VERSION}/dist-packages/tensorrt* ~/miniconda/envs/{您的虚拟环境名字}/lib/python${PYTHON_VERSION}/site-packages/
-```
-
-### 6.1.4 安装 MMCV
-
-通过`mim install mmcv`或从源码对其进行编译。
-
-```bash
-pip install openmim
-mim install mmcv
-```
-
-或者从源码对其进行编译。
-
-```bash
-sudo apt-get install -y libssl-dev
-git clone https://github.com/open-mmlab/mmcv.git
-cd mmcv
-pip install -e .
-```
-
-<font color="red">注：pytorch版本发生变动后，需要重新编译mmcv。</font>
-
-### 6.1.5 安装 ONNX
-
-<font color="red">注：以下方式二选一</font>
-
-- conda
-  ```bash
-  conda install -c conda-forge onnx
-  ```
-- pip
-  ```bash
-  python3 -m pip install onnx
-  ```
-
-### 6.1.6 安装 ONNX Runtime
-
-根据网页 [ONNX Runtime](https://elinux.org/Jetson_Zoo#ONNX_Runtime) 选择合适的ONNX Runtime版本进行下载安装。
-示例：
-
-```bash
-# Install pip wheel
-$ pip3 install onnxruntime_gpu-1.10.0-cp38-cp38-linux_aarch64.whl
-
-```
-
-## 6.2 在 Jetson AGX Orin 进行模型转换及推理
-
-### 6.2.1 ONNX 模型转换
-
-同[4.1 模型转换](#4.1-模型转换)相同，在 Jetson 平台下进入安装好的虚拟环境，以及mmdeploy 目录，进行模型ONNX转换。
-
-```bash
-python tools/deploy.py \
-    configs/mmseg/segmentation_onnxruntime_static-512x512.py \
-    ../atl_config.py \
-    ../deeplabv3plus_r18-d8_512x512_80k_potsdam_20211219_020601-75fd5bc3.pth \
-    ../2_13_3584_2560_4096_3072.png \
-    --work-dir ../atl_models \
-    --device cpu \
-    --show \
-    --dump-info
-
-```
-
-<font color="red">注：</font> 如果报错提示内容：
-
-```none
-AttributeError: module 'torch.distributed' has no attribute 'ReduceOp'
-```
-
-可参考以下链接进行解决：https://forums.developer.nvidia.com/t/module-torch-distributed-has-no-attribute-reduceop/256581/6，即安装 pytorch 1.11.0 版本。
-
-转换成功后，您将会看到如下信息以及包含 ONNX 模型的文件夹：
-
-```bash
-10/09 19:58:22 - mmengine - INFO - visualize pytorch model success.
-10/09 19:58:22 - mmengine - INFO - All process success.
-```
-
-<div align="center">
-    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/d68f1cf6-0e80-4261-91a3-6046b17de146" alt="NVIDIA-Jetson" width="400">
-    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/70470a39-6a4f-4fd5-a06d-9b9d59a768ef" alt="NVIDIA-Jetson" width="160">
-</div>
-
-### 6.2.2 TensorRT 模型转换
-
-更换部署trt配置文件，进行 TensorRT 模型转换。
-
-```bash
-python tools/deploy.py \
-    configs/mmseg/segmentation_tensorrt_static-512x512.py \
-    ../atl_config.py \
-    ../deeplabv3plus_r18-d8_512x512_80k_potsdam_20211219_020601-75fd5bc3.pth \
-    ../2_13_3584_2560_4096_3072.png \
-    --work-dir ../atl_trt_models \
-    --device cuda:0 \
-    --show \
-    --dump-info
-
-```
-
-转换成功后您将看到以下信息及 TensorRT 模型文件夹：
-
-```bash
-10/09 20:15:50 - mmengine - INFO - visualize pytorch model success.
-10/09 20:15:50 - mmengine - INFO - All process success.
-```
-
-<div align="center">
-    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/2ac1428f-b787-4fdd-beaf-6397e5b21e33" alt="NVIDIA-Jetson" width="340">
-    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/70470a39-6a4f-4fd5-a06d-9b9d59a768ef" alt="NVIDIA-Jetson" width="200">
-</div>
-
-## 6.3 模型测速
-
-执行以下命令完成模型测速，详细内容请查看[ profiler ](https://github.com/open-mmlab/mmdeploy/blob/main/docs/zh_cn/02-how-to-run/useful_tools.md#profiler)
-
-```bash
-python tools/profiler.py \
-    ${DEPLOY_CFG} \
-    ${MODEL_CFG} \
-    ${IMAGE_DIR} \
-    --model ${MODEL} \
-    --device ${DEVICE} \
-    --shape ${SHAPE} \
-    --num-iter ${NUM_ITER} \
-    --warmup ${WARMUP} \
-    --cfg-options ${CFG_OPTIONS} \
-    --batch-size ${BATCH_SIZE} \
-    --img-ext ${IMG_EXT}
-```
-
-示例：
-
-```bash
-python tools/profiler.py \
-    configs/mmseg/segmentation_tensorrt_static-512x512.py \
-    ../atl_config.py \
-    ../atl_demo_img \
-    --model /home/sirs/AI-Tianlong/OpenMMLab/atl_trt_models/end2end.engine \
-    --device cuda:0 \
-    --shape 512x512 \
-    --num-iter 100
-```
-
-测速结果
-
-![image](https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/874e9742-ee10-490c-9e69-17da0096c49b)
-
-## 6.4 模型推理
-
-根据[6.2.2](#6.2.2-TensorRT-模型转换)中生成的TensorRT模型文件夹，进行模型推理。
-
-```python
-from mmdeploy.apis.utils import build_task_processor
-from mmdeploy.utils import get_input_shape, load_config
-import torch
-
-deploy_cfg='./mmdeploy/configs/mmseg/segmentation_tensorrt_static-512x512.py'
-model_cfg='./atl_config.py'
-device='cuda:0'
-backend_model = ['./atl_trt_models/end2end.engine']
-image = './atl_demo_img/2_13_2048_1024_2560_1536.png'
-
-# read deploy_cfg and model_cfg
-deploy_cfg, model_cfg = load_config(deploy_cfg, model_cfg)
-
-# build task and backend model
-task_processor = build_task_processor(model_cfg, deploy_cfg, device)
-model = task_processor.build_backend_model(backend_model)
-
-# process input image
-input_shape = get_input_shape(deploy_cfg)
-model_inputs, _ = task_processor.create_input(image, input_shape)
-
-# do model inference
-with torch.no_grad():
-    result = model.test_step(model_inputs)
-
-# visualize results
-task_processor.visualize(
-    image=image,
-    model=model,
-    result=result[0],
-    window_name='visualize',
-    output_file='./output_segmentation.png')
-```
-
-即可得到推理结果：
-
-<div align="center">
-    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/d0ae1fa8-e223-4b3f-b699-6bfa8db38133" alt="NVIDIA-Jetson" width="40%">
-    <img src="https://github.com/AI-Tianlong/Useful-Tools/assets/50650583/6d999cbe-2101-4e1b-b4a9-13115c9d1928" alt="NVIDIA-Jetson" width="40%">
-</div>
diff --git a/mmsegmentation/projects/pp_mobileseg/README.md b/mmsegmentation/projects/pp_mobileseg/README.md
deleted file mode 100644
index c9f9c12..0000000
--- a/mmsegmentation/projects/pp_mobileseg/README.md
+++ /dev/null
@@ -1,123 +0,0 @@
-# PP-MobileSeg: Exploring Transformer Blocks for Efficient Mobile Segmentation.
-
-## Reference
-
-> [PP-MobileSeg: Explore the Fast and Accurate Semantic Segmentation Model on Mobile Devices. ](https://arxiv.org/abs/2304.05152)
-
-## Introduction
-
-<a href="https://github.com/PaddlePaddle/PaddleSeg/tree/release/2.8">Official Repo</a>
-
-<a href="https://github.com/open-mmlab/mmsegmentation/tree/main/projects/pp_mobileseg">Code Snippet</a>
-
-## <img src="https://user-images.githubusercontent.com/34859558/190043857-bfbdaf8b-d2dc-4fff-81c7-e0aac50851f9.png" width="25"/> Abstract
-
-With the success of transformers in computer vision, several attempts have been made to adapt transformers to mobile devices. However, their performance is not satisfied for some real world applications. Therefore, we propose PP-MobileSeg, a SOTA semantic segmentation model for mobile devices.
-
-It is composed of three newly proposed parts, the strideformer backbone, the Aggregated Attention Module(AAM), and the Valid Interpolate Module(VIM):
-
-- With the four-stage MobileNetV3 block as the feature extractor, we manage to extract rich local features of different receptive fields with little parameter overhead. Also, we further efficiently empower features from the last two stages with the global view using strided sea attention.
-- To effectively fuse the features, we use AAM to filter the detail features with ensemble voting and add the semantic feature to it to enhance the semantic information to the most content.
-- At last, we use VIM to upsample the downsampled feature to the original resolution and significantly decrease latency in model inference stage. It only interpolates classes present in the final prediction which only takes around 10% in the ADE20K dataset. This is a common scenario for datasets with large classes. Therefore it significantly decreases the latency of the final upsample process which takes the greatest part of the model's overall latency.
-
-Extensive experiments show that PP-MobileSeg achieves a superior params-accuracy-latency tradeoff compared to other SOTA methods.
-
-<div align="center">
-<img src="https://user-images.githubusercontent.com/34859558/227450728-1338fcb1-3b8a-4453-a155-da60abcacb88.png"  width = "1000" />
-</div>
-
-## <img src="https://user-images.githubusercontent.com/34859558/190044217-8f6befc2-7f20-473d-b356-148e06265205.png" width="25"/> Performance
-
-### ADE20K
-
-| Model             | Backbone          | Training Iters | Batchsize | Train Resolution | mIoU(%) | latency(ms)\* | params(M) | config                                                                                                                    | Links                                                                                                                                                                                                                                |
-| ----------------- | ----------------- | -------------- | --------- | ---------------- | ------- | ------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| PP-MobileSeg-Base | StrideFormer-Base | 80000          | 32        | 512x512          | 41.57%  | 265.5         | 5.62      | [config](https://github.com/Yang-Changhui/mmsegmentation/tree/add_ppmobileseg/projects/pp_mobileseg/configs/pp_mobileseg) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pp_mobileseg/pp_mobileseg_mobilenetv3_2xb16_3rdparty-base_512x512-ade20k-f12b44f3.pth)\|[log](https://bj.bcebos.com/paddleseg/dygraph/ade20k/pp_mobileseg_base/train.log) |
-| PP-MobileSeg-Tiny | StrideFormer-Tiny | 80000          | 32        | 512x512          | 36.39%  | 215.3         | 1.61      | [config](https://github.com/Yang-Changhui/mmsegmentation/tree/add_ppmobileseg/projects/pp_mobileseg/configs/pp_mobileseg) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/pp_mobileseg/pp_mobileseg_mobilenetv3_2xb16_3rdparty-tiny_512x512-ade20k-a351ebf5.pth)\|[log](https://bj.bcebos.com/paddleseg/dygraph/ade20k/pp_mobileseg_tiny/train.log) |
-
-## Usage
-
-Same as other models in MMsegmentation, you can run the following command to test the model at ${MMSEG_ROOT}:
-
-```shell
-./tools/dist_test.sh projects/pp_mobileseg/configs/pp_mobileseg/pp_mobileseg_mobilenetv3_2x16_80k_ade20k_512x512_base.py checkpoints/pp_mobileseg_mobilenetv3_2xb16_3rdparty-base_512x512-ade20k-f12b44f3.pth 8
-```
-
-## Inference with ONNXRuntime
-
-### Prerequisites
-
-**1. Install onnxruntime inference engine.**
-
-Choose one of the following ways to install onnxruntime.
-
-- CPU version
-
-```shell
-pip install onnxruntime==1.15.1
-wget https://github.com/microsoft/onnxruntime/releases/download/v1.15.1/onnxruntime-linux-x64-1.15.1.tgz
-tar -zxvf onnxruntime-linux-x64-1.15.1.tgz
-export ONNXRUNTIME_DIR=$(pwd)/onnxruntime-linux-x64-1.15.1
-export LD_LIBRARY_PATH=$ONNXRUNTIME_DIR/lib:$LD_LIBRARY_PATH
-```
-
-**2. Convert model to onnx file**
-
-- Install `mim` and `mmdeploy`.
-
-```shell
-pip install openmim
-mim install mmdeploy
-git clone https://github.com/open-mmlab/mmdeploy.git
-```
-
-- Download pp_mobileseg model.
-
-```shell
-wget https://download.openmmlab.com/mmsegmentation/v0.5/pp_mobileseg/pp_mobileseg_mobilenetv3_2xb16_3rdparty-tiny_512x512-ade20k-a351ebf5.pth
-```
-
-- Convert model to onnx files.
-
-```shell
-python mmdeploy/tools/deploy.py mmdeploy/configs/mmseg/segmentation_onnxruntime_dynamic.py \
-    configs/pp_mobileseg/pp_mobileseg_mobilenetv3_2x16_80k_ade20k_512x512_tiny.py \
-    pp_mobileseg_mobilenetv3_2xb16_3rdparty-tiny_512x512-ade20k-a351ebf5.pth \
-    ../../demo/demo.png \
-    --work-dir mmdeploy_model/mmseg/ort \
-    --show
-```
-
-**3. Run demo**
-
-```shell
-python inference_onnx.py ${ONNX_FILE_PATH} ${IMAGE_PATH} [${MODEL_INPUT_SIZE} ${DEVICE} ${OUTPUT_IMAGE_PATH}]
-```
-
-Example:
-
-```shell
-python inference_onnx.py mmdeploy_model/mmseg/ort/end2end.onnx ../../demo/demo.png
-```
-
-## Citation
-
-If you find our project useful in your research, please consider citing:
-
-```
-@misc{liu2021paddleseg,
-      title={PaddleSeg: A High-Efficient Development Toolkit for Image Segmentation},
-      author={Yi Liu and Lutao Chu and Guowei Chen and Zewu Wu and Zeyu Chen and Baohua Lai and Yuying Hao},
-      year={2021},
-      eprint={2101.06175},
-      archivePrefix={arXiv},
-      primaryClass={cs.CV}
-}
-
-@misc{paddleseg2019,
-    title={PaddleSeg, End-to-end image segmentation kit based on PaddlePaddle},
-    author={PaddlePaddle Contributors},
-    howpublished = {\url{https://github.com/PaddlePaddle/PaddleSeg}},
-    year={2019}
-}
-```
diff --git a/mmsegmentation/projects/pp_mobileseg/backbones/__init__.py b/mmsegmentation/projects/pp_mobileseg/backbones/__init__.py
deleted file mode 100644
index 244b33d..0000000
--- a/mmsegmentation/projects/pp_mobileseg/backbones/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .strideformer import StrideFormer
-
-__all__ = ['StrideFormer']
diff --git a/mmsegmentation/projects/pp_mobileseg/backbones/strideformer.py b/mmsegmentation/projects/pp_mobileseg/backbones/strideformer.py
deleted file mode 100644
index 3f09be5..0000000
--- a/mmsegmentation/projects/pp_mobileseg/backbones/strideformer.py
+++ /dev/null
@@ -1,958 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import math
-import warnings
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from mmcv.cnn import ConvModule, build_activation_layer
-from mmcv.cnn.bricks.transformer import build_dropout
-from mmengine.logging import print_log
-from mmengine.model import BaseModule
-from mmengine.runner.checkpoint import CheckpointLoader, load_state_dict
-
-from mmseg.registry import MODELS
-
-
-@MODELS.register_module()
-class StrideFormer(BaseModule):
-    """The StrideFormer implementation based on torch.
-
-    The original article refers to:https://arxiv.org/abs/2304.05152
-    Args:
-        mobileV3_cfg(list): Each sublist describe the config for a
-            MobileNetV3 block.
-        channels(list): The input channels for each MobileNetV3 block.
-        embed_dims(list): The channels of the features input to the sea
-            attention block.
-        key_dims(list, optional): The embeding dims for each head in
-            attention.
-        depths(list, optional): describes the depth of the attention block.
-            i,e: M,N.
-        num_heads(int, optional): The number of heads of the attention
-            blocks.
-        attn_ratios(int, optional): The expand ratio of V.
-        mlp_ratios(list, optional): The ratio of mlp blocks.
-        drop_path_rate(float, optional): The drop path rate in attention
-            block.
-        act_cfg(dict, optional): The activation layer of AAM:
-            Aggregate Attention Module.
-        inj_type(string, optional): The type of injection/AAM.
-        out_channels(int, optional): The output channels of the AAM.
-        dims(list, optional): The dimension of the fusion block.
-        out_feat_chs(list, optional): The input channels of the AAM.
-        stride_attention(bool, optional): whether to stride attention in
-            each attention layer.
-        pretrained(str, optional): the path of pretrained model.
-    """
-
-    def __init__(
-        self,
-        mobileV3_cfg,
-        channels,
-        embed_dims,
-        key_dims=[16, 24],
-        depths=[2, 2],
-        num_heads=8,
-        attn_ratios=2,
-        mlp_ratios=[2, 4],
-        drop_path_rate=0.1,
-        act_cfg=dict(type='ReLU'),
-        inj_type='AAM',
-        out_channels=256,
-        dims=(128, 160),
-        out_feat_chs=None,
-        stride_attention=True,
-        pretrained=None,
-        init_cfg=None,
-    ):
-        super().__init__(init_cfg=init_cfg)
-        assert not (init_cfg and pretrained
-                    ), 'init_cfg and pretrained cannot be set at the same time'
-        if isinstance(pretrained, str):
-            warnings.warn('DeprecationWarning: pretrained is deprecated, '
-                          'please use "init_cfg" instead')
-            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
-        elif pretrained is not None:
-            raise TypeError('pretrained must be a str or None')
-
-        self.depths = depths
-        self.cfgs = mobileV3_cfg
-        self.dims = dims
-        for i in range(len(self.cfgs)):
-            smb = StackedMV3Block(
-                cfgs=self.cfgs[i],
-                stem=True if i == 0 else False,
-                in_channels=channels[i],
-            )
-            setattr(self, f'smb{i + 1}', smb)
-        for i in range(len(depths)):
-            dpr = [
-                x.item() for x in torch.linspace(0, drop_path_rate, depths[i])
-            ]
-            trans = BasicLayer(
-                block_num=depths[i],
-                embedding_dim=embed_dims[i],
-                key_dim=key_dims[i],
-                num_heads=num_heads,
-                mlp_ratio=mlp_ratios[i],
-                attn_ratio=attn_ratios,
-                drop=0,
-                attn_drop=0.0,
-                drop_path=dpr,
-                act_cfg=act_cfg,
-                stride_attention=stride_attention,
-            )
-            setattr(self, f'trans{i + 1}', trans)
-
-        self.inj_type = inj_type
-        if self.inj_type == 'AAM':
-            self.inj_module = InjectionMultiSumallmultiallsum(
-                in_channels=out_feat_chs, out_channels=out_channels)
-            self.feat_channels = [
-                out_channels,
-            ]
-        elif self.inj_type == 'AAMSx8':
-            self.inj_module = InjectionMultiSumallmultiallsumSimpx8(
-                in_channels=out_feat_chs, out_channels=out_channels)
-            self.feat_channels = [
-                out_channels,
-            ]
-        elif self.inj_type == 'origin':
-            for i in range(len(dims)):
-                fuse = FusionBlock(
-                    out_feat_chs[0] if i == 0 else dims[i - 1],
-                    out_feat_chs[i + 1],
-                    embed_dim=dims[i],
-                    act_cfg=None,
-                )
-                setattr(self, f'fuse{i + 1}', fuse)
-            self.feat_channels = [
-                dims[i],
-            ]
-        else:
-            raise NotImplementedError(self.inj_module + ' is not implemented')
-
-        self.pretrained = pretrained
-        # self.init_weights()
-
-    def init_weights(self):
-        if (isinstance(self.init_cfg, dict)
-                and self.init_cfg.get('type') == 'Pretrained'):
-            checkpoint = CheckpointLoader.load_checkpoint(
-                self.init_cfg['checkpoint'], logger=None, map_location='cpu')
-
-            if 'state_dict' in checkpoint:
-                state_dict = checkpoint['state_dict']
-            else:
-                state_dict = checkpoint
-
-            if 'pos_embed' in state_dict.keys():
-                if self.pos_embed.shape != state_dict['pos_embed'].shape:
-                    print_log(msg=f'Resize the pos_embed shape from '
-                              f'{state_dict["pos_embed"].shape} to '
-                              f'{self.pos_embed.shape}')
-                    h, w = self.img_size
-                    pos_size = int(
-                        math.sqrt(state_dict['pos_embed'].shape[1] - 1))
-                    state_dict['pos_embed'] = self.resize_pos_embed(
-                        state_dict['pos_embed'],
-                        (h // self.patch_size, w // self.patch_size),
-                        (pos_size, pos_size),
-                        self.interpolate_mode,
-                    )
-
-            load_state_dict(self, state_dict, strict=False, logger=None)
-
-    def forward(self, x):
-        x_hw = x.shape[2:]
-        outputs = []
-        num_smb_stage = len(self.cfgs)
-        num_trans_stage = len(self.depths)
-
-        for i in range(num_smb_stage):
-            smb = getattr(self, f'smb{i + 1}')
-            x = smb(x)
-
-            # 1/8 shared feat
-            if i == 1:
-                outputs.append(x)
-            if num_trans_stage + i >= num_smb_stage:
-                trans = getattr(
-                    self, f'trans{i + num_trans_stage - num_smb_stage + 1}')
-                x = trans(x)
-                outputs.append(x)
-        if self.inj_type == 'origin':
-            x_detail = outputs[0]
-            for i in range(len(self.dims)):
-                fuse = getattr(self, f'fuse{i + 1}')
-
-                x_detail = fuse(x_detail, outputs[i + 1])
-            output = x_detail
-        else:
-            output = self.inj_module(outputs)
-
-        return [output, x_hw]
-
-
-class StackedMV3Block(nn.Module):
-    """The MobileNetV3 block.
-
-    Args:
-        cfgs (list): The MobileNetV3 config list of a stage.
-        stem (bool): Whether is the first stage or not.
-        in_channels (int, optional): The channels of input image. Default: 3.
-        scale: float=1.0.
-        The coefficient that controls the size of network parameters.
-
-    Returns:
-        model: nn.Module.
-        A stage of specific MobileNetV3 model depends on args.
-    """
-
-    def __init__(self,
-                 cfgs,
-                 stem,
-                 in_channels,
-                 scale=1.0,
-                 norm_cfg=dict(type='BN')):
-        super().__init__()
-
-        self.scale = scale
-        self.stem = stem
-
-        if self.stem:
-            self.conv = ConvModule(
-                in_channels=3,
-                out_channels=_make_divisible(in_channels * self.scale),
-                kernel_size=3,
-                stride=2,
-                padding=1,
-                groups=1,
-                bias=False,
-                norm_cfg=norm_cfg,
-                act_cfg=dict(type='HSwish'),
-            )
-
-        self.blocks = nn.ModuleList()
-        for i, (k, exp, c, se, act, s) in enumerate(cfgs):
-            self.blocks.append(
-                ResidualUnit(
-                    in_channel=_make_divisible(in_channels * self.scale),
-                    mid_channel=_make_divisible(self.scale * exp),
-                    out_channel=_make_divisible(self.scale * c),
-                    kernel_size=k,
-                    stride=s,
-                    use_se=se,
-                    act=act,
-                    dilation=1,
-                ))
-            in_channels = _make_divisible(self.scale * c)
-
-    def forward(self, x):
-        if self.stem:
-            x = self.conv(x)
-        for i, block in enumerate(self.blocks):
-            x = block(x)
-
-        return x
-
-
-class ResidualUnit(nn.Module):
-    """The Residual module.
-
-    Args:
-        in_channel (int, optional): The channels of input feature.
-        mid_channel (int, optional): The channels of middle process.
-        out_channel (int, optional): The channels of output feature.
-        kernel_size (int, optional): The size of the convolving kernel.
-        stride (int, optional): The stride size.
-        use_se (bool, optional): if to use the SEModule.
-        act (string, optional): activation layer.
-        dilation (int, optional): The dilation size.
-        norm_cfg (dict): Config dict for normalization layer.
-            Default: dict(type='BN', requires_grad=True).
-    """
-
-    def __init__(
-            self,
-            in_channel,
-            mid_channel,
-            out_channel,
-            kernel_size,
-            stride,
-            use_se,
-            act=None,
-            dilation=1,
-            norm_cfg=dict(type='BN'),
-    ):
-        super().__init__()
-        self.if_shortcut = stride == 1 and in_channel == out_channel
-        self.if_se = use_se
-        self.expand_conv = ConvModule(
-            in_channels=in_channel,
-            out_channels=mid_channel,
-            kernel_size=1,
-            bias=False,
-            norm_cfg=norm_cfg,
-            act_cfg=dict(type=act) if act is not None else None,
-        )
-        self.bottleneck_conv = ConvModule(
-            in_channels=mid_channel,
-            out_channels=mid_channel,
-            kernel_size=kernel_size,
-            stride=stride,
-            padding=int((kernel_size - 1) // 2) * dilation,
-            bias=False,
-            groups=mid_channel,
-            dilation=dilation,
-            norm_cfg=norm_cfg,
-            act_cfg=dict(type=act) if act is not None else None,
-        )
-        if self.if_se:
-            self.mid_se = SEModule(mid_channel)
-        self.linear_conv = ConvModule(
-            in_channels=mid_channel,
-            out_channels=out_channel,
-            kernel_size=1,
-            bias=False,
-            norm_cfg=norm_cfg,
-            act_cfg=None,
-        )
-
-    def forward(self, x):
-        identity = x
-        x = self.expand_conv(x)
-        x = self.bottleneck_conv(x)
-        if self.if_se:
-            x = self.mid_se(x)
-        x = self.linear_conv(x)
-        if self.if_shortcut:
-            x = torch.add(identity, x)
-        return x
-
-
-class SEModule(nn.Module):
-    """SE Module.
-
-    Args:
-        channel (int, optional): The channels of input feature.
-        reduction (int, optional): The channel reduction rate.
-        act_cfg (dict): Config dict for activation layer.
-            Default: dict(type='PReLU').
-    """
-
-    def __init__(self, channel, reduction=4, act_cfg=dict(type='ReLU')):
-        super().__init__()
-        self.avg_pool = nn.AdaptiveAvgPool2d(1)
-        self.conv_act1 = ConvModule(
-            in_channels=channel,
-            out_channels=channel // reduction,
-            kernel_size=1,
-            norm_cfg=None,
-            act_cfg=act_cfg,
-        )
-
-        self.conv_act2 = ConvModule(
-            in_channels=channel // reduction,
-            out_channels=channel,
-            kernel_size=1,
-            norm_cfg=None,
-            act_cfg=dict(type='Hardsigmoid', slope=0.2, offset=0.5),
-        )
-
-    def forward(self, x):
-        identity = x
-        x = self.avg_pool(x)
-        x = self.conv_act1(x)
-        x = self.conv_act2(x)
-        return torch.mul(identity, x)
-
-
-class BasicLayer(nn.Module):
-    """The transformer basic layer.
-
-    Args:
-        block_num (int): the block nums of the transformer basic layer.
-        embedding_dim (int): The feature dimension.
-        key_dim (int): the key dim.
-        num_heads (int): Parallel attention heads.
-        mlp_ratio (float): the mlp ratio.
-        attn_ratio (float): the attention ratio.
-        drop (float): Probability of an element to be zeroed
-            after the feed forward layer.Default: 0.0.
-        attn_drop (float): The drop out rate for attention layer.
-            Default: 0.0.
-        drop_path (float): stochastic depth rate. Default 0.0.
-        act_cfg (dict): Config dict for activation layer.
-            Default: dict(type='PReLU').
-        stride_attention (bool, optional): whether to stride attention in
-            each attention layer.
-    """
-
-    def __init__(
-        self,
-        block_num,
-        embedding_dim,
-        key_dim,
-        num_heads,
-        mlp_ratio=4.0,
-        attn_ratio=2.0,
-        drop=0.0,
-        attn_drop=0.0,
-        drop_path=None,
-        act_cfg=None,
-        stride_attention=None,
-    ):
-        super().__init__()
-        self.block_num = block_num
-
-        self.transformer_blocks = nn.ModuleList()
-        for i in range(self.block_num):
-            self.transformer_blocks.append(
-                Block(
-                    embedding_dim,
-                    key_dim=key_dim,
-                    num_heads=num_heads,
-                    mlp_ratio=mlp_ratio,
-                    attn_ratio=attn_ratio,
-                    drop=drop,
-                    drop_path=drop_path[i]
-                    if isinstance(drop_path, list) else drop_path,
-                    act_cfg=act_cfg,
-                    stride_attention=stride_attention,
-                ))
-
-    def forward(self, x):
-        for i in range(self.block_num):
-            x = self.transformer_blocks[i](x)
-        return x
-
-
-class Block(nn.Module):
-    """the block of the transformer basic layer.
-
-    Args:
-        dim (int): The feature dimension.
-        key_dim (int): The key dimension.
-        num_heads (int): Parallel attention heads.
-        mlp_ratio (float): the mlp ratio.
-        attn_ratio (float): the attention ratio.
-        drop (float): Probability of an element to be zeroed
-            after the feed forward layer.Default: 0.0.
-        drop_path (float): stochastic depth rate. Default 0.0.
-        act_cfg (dict): Config dict for activation layer.
-            Default: dict(type='PReLU').
-        stride_attention (bool, optional): whether to stride attention in
-            each attention layer.
-    """
-
-    def __init__(
-        self,
-        dim,
-        key_dim,
-        num_heads,
-        mlp_ratio=4.0,
-        attn_ratio=2.0,
-        drop=0.0,
-        drop_path=0.0,
-        act_cfg=None,
-        stride_attention=None,
-    ):
-        super().__init__()
-        self.dim = dim
-        self.num_heads = num_heads
-        self.mlp_ratio = mlp_ratio
-        self.attn = SeaAttention(
-            dim,
-            key_dim=key_dim,
-            num_heads=num_heads,
-            attn_ratio=attn_ratio,
-            act_cfg=act_cfg,
-            stride_attention=stride_attention,
-        )
-        self.drop_path = (
-            build_dropout(dict(type='DropPath', drop_prob=drop_path))
-            if drop_path > 0.0 else nn.Identity())
-        mlp_hidden_dim = int(dim * mlp_ratio)
-        self.mlp = MLP(
-            in_features=dim,
-            hidden_features=mlp_hidden_dim,
-            act_cfg=act_cfg,
-            drop=drop,
-        )
-
-    def forward(self, x1):
-        x1 = x1 + self.drop_path(self.attn(x1))
-        x1 = x1 + self.drop_path(self.mlp(x1))
-
-        return x1
-
-
-class SqueezeAxialPositionalEmbedding(nn.Module):
-    """the Squeeze Axial Positional Embedding.
-
-    Args:
-        dim (int): The feature dimension.
-        shape (int): The patch size.
-    """
-
-    def __init__(self, dim, shape):
-        super().__init__()
-        self.pos_embed = nn.init.normal_(
-            nn.Parameter(torch.zeros(1, dim, shape)))
-
-    def forward(self, x):
-        B, C, N = x.shape
-        x = x + F.interpolate(
-            self.pos_embed, size=(N, ), mode='linear', align_corners=False)
-        return x
-
-
-class SeaAttention(nn.Module):
-    """The sea attention.
-
-    Args:
-        dim (int): The feature dimension.
-        key_dim (int):  The key dimension.
-        num_heads (int): number of attention heads.
-        attn_ratio (float): the attention ratio.
-        act_cfg (dict): Config dict for activation layer.
-            Default: dict(type='PReLU').
-        norm_cfg (dict): Config dict for normalization layer.
-            Default: dict(type='LN')
-        stride_attention (bool, optional): whether to stride attention in
-            each attention layer.
-    """
-
-    def __init__(
-            self,
-            dim,
-            key_dim,
-            num_heads,
-            attn_ratio=4.0,
-            act_cfg=None,
-            norm_cfg=dict(type='BN'),
-            stride_attention=False,
-    ):
-
-        super().__init__()
-        self.num_heads = num_heads
-        self.scale = key_dim**-0.5
-        self.nh_kd = nh_kd = key_dim * num_heads
-        self.d = int(attn_ratio * key_dim)
-        self.dh = int(attn_ratio * key_dim) * num_heads
-        self.attn_ratio = attn_ratio
-
-        self.to_q = ConvModule(
-            dim, nh_kd, 1, bias=False, norm_cfg=norm_cfg, act_cfg=None)
-        self.to_k = ConvModule(
-            dim, nh_kd, 1, bias=False, norm_cfg=norm_cfg, act_cfg=None)
-
-        self.to_v = ConvModule(
-            dim, self.dh, 1, bias=False, norm_cfg=norm_cfg, act_cfg=None)
-        self.stride_attention = stride_attention
-        if self.stride_attention:
-            self.stride_conv = ConvModule(
-                dim,
-                dim,
-                kernel_size=3,
-                stride=2,
-                padding=1,
-                bias=True,
-                groups=dim,
-                norm_cfg=norm_cfg,
-                act_cfg=None,
-            )
-
-        self.proj = ConvModule(
-            self.dh,
-            dim,
-            1,
-            bias=False,
-            norm_cfg=norm_cfg,
-            act_cfg=act_cfg,
-            order=('act', 'conv', 'norm'),
-        )
-        self.proj_encode_row = ConvModule(
-            self.dh,
-            self.dh,
-            1,
-            bias=False,
-            norm_cfg=norm_cfg,
-            act_cfg=act_cfg,
-            order=('act', 'conv', 'norm'),
-        )
-        self.pos_emb_rowq = SqueezeAxialPositionalEmbedding(nh_kd, 16)
-        self.pos_emb_rowk = SqueezeAxialPositionalEmbedding(nh_kd, 16)
-        self.proj_encode_column = ConvModule(
-            self.dh,
-            self.dh,
-            1,
-            bias=False,
-            norm_cfg=norm_cfg,
-            act_cfg=act_cfg,
-            order=('act', 'conv', 'norm'),
-        )
-        self.pos_emb_columnq = SqueezeAxialPositionalEmbedding(nh_kd, 16)
-        self.pos_emb_columnk = SqueezeAxialPositionalEmbedding(nh_kd, 16)
-        self.dwconv = ConvModule(
-            2 * self.dh,
-            2 * self.dh,
-            3,
-            padding=1,
-            groups=2 * self.dh,
-            bias=False,
-            norm_cfg=norm_cfg,
-            act_cfg=act_cfg,
-        )
-        self.pwconv = ConvModule(
-            2 * self.dh, dim, 1, bias=False, norm_cfg=norm_cfg, act_cfg=None)
-        self.sigmoid = build_activation_layer(dict(type='HSigmoid'))
-
-    def forward(self, x):
-        B, C, H_ori, W_ori = x.shape
-        if self.stride_attention:
-            x = self.stride_conv(x)
-        B, C, H, W = x.shape
-
-        q = self.to_q(x)  # [B, nhead*dim, H, W]
-        k = self.to_k(x)
-        v = self.to_v(x)
-
-        qkv = torch.cat([q, k, v], dim=1)
-        qkv = self.dwconv(qkv)
-        qkv = self.pwconv(qkv)
-
-        qrow = (self.pos_emb_rowq(q.mean(-1)).reshape(
-            [B, self.num_heads, -1, H]).permute(
-                (0, 1, 3, 2)))  # [B, nhead, H, dim]
-        krow = self.pos_emb_rowk(k.mean(-1)).reshape(
-            [B, self.num_heads, -1, H])  # [B, nhead, dim, H]
-        vrow = (v.mean(-1).reshape([B, self.num_heads, -1,
-                                    H]).permute([0, 1, 3, 2])
-                )  # [B, nhead, H, dim*attn_ratio]
-
-        attn_row = torch.matmul(qrow, krow) * self.scale  # [B, nhead, H, H]
-        attn_row = nn.functional.softmax(attn_row, dim=-1)
-
-        xx_row = torch.matmul(attn_row, vrow)  # [B, nhead, H, dim*attn_ratio]
-        xx_row = self.proj_encode_row(
-            xx_row.permute([0, 1, 3, 2]).reshape([B, self.dh, H, 1]))
-
-        # squeeze column
-        qcolumn = (
-            self.pos_emb_columnq(q.mean(-2)).reshape(
-                [B, self.num_heads, -1, W]).permute([0, 1, 3, 2]))
-        kcolumn = self.pos_emb_columnk(k.mean(-2)).reshape(
-            [B, self.num_heads, -1, W])
-        vcolumn = (
-            torch.mean(v, -2).reshape([B, self.num_heads, -1,
-                                       W]).permute([0, 1, 3, 2]))
-
-        attn_column = torch.matmul(qcolumn, kcolumn) * self.scale
-        attn_column = nn.functional.softmax(attn_column, dim=-1)
-
-        xx_column = torch.matmul(attn_column, vcolumn)  # B nH W C
-        xx_column = self.proj_encode_column(
-            xx_column.permute([0, 1, 3, 2]).reshape([B, self.dh, 1, W]))
-
-        xx = torch.add(xx_row, xx_column)  # [B, self.dh, H, W]
-        xx = torch.add(v, xx)
-
-        xx = self.proj(xx)
-        xx = self.sigmoid(xx) * qkv
-        if self.stride_attention:
-            xx = F.interpolate(xx, size=(H_ori, W_ori), mode='bilinear')
-
-        return xx
-
-
-class MLP(nn.Module):
-    """the Multilayer Perceptron.
-
-    Args:
-        in_features (int): the input feature.
-        hidden_features (int): the hidden feature.
-        out_features (int): the output feature.
-        act_cfg (dict): Config dict for activation layer.
-            Default: dict(type='PReLU').
-        norm_cfg (dict): Config dict for normalization layer.
-            Default: dict(type='BN')
-        drop (float): Probability of an element to be zeroed.
-            Default 0.0
-    """
-
-    def __init__(
-            self,
-            in_features,
-            hidden_features=None,
-            out_features=None,
-            act_cfg=None,
-            norm_cfg=dict(type='BN'),
-            drop=0.0,
-    ):
-        super().__init__()
-        out_features = out_features or in_features
-        hidden_features = hidden_features or in_features
-        self.fc1 = ConvModule(
-            in_features,
-            hidden_features,
-            kernel_size=1,
-            bias=False,
-            norm_cfg=norm_cfg,
-            act_cfg=None,
-        )
-        self.dwconv = ConvModule(
-            hidden_features,
-            hidden_features,
-            kernel_size=3,
-            padding=1,
-            groups=hidden_features,
-            norm_cfg=None,
-            act_cfg=act_cfg,
-        )
-
-        self.fc2 = ConvModule(
-            hidden_features,
-            out_features,
-            1,
-            bias=False,
-            norm_cfg=norm_cfg,
-            act_cfg=None,
-        )
-        self.drop = build_dropout(dict(type='Dropout', drop_prob=drop))
-
-    def forward(self, x):
-        x = self.fc1(x)
-        x = self.dwconv(x)
-        x = self.drop(x)
-        x = self.fc2(x)
-        x = self.drop(x)
-        return x
-
-
-class FusionBlock(nn.Module):
-    """The feature fusion block.
-
-    Args:
-        in_channel (int): the input channel.
-        out_channel (int): the output channel.
-        embed_dim (int): embedding dimension.
-        act_cfg (dict): Config dict for activation layer.
-            Default: dict(type='ReLU').
-        norm_cfg (dict): Config dict for normalization layer.
-            Default: dict(type='BN')
-    """
-
-    def __init__(
-            self,
-            in_channel,
-            out_channel,
-            embed_dim,
-            norm_cfg=dict(type='BN'),
-            act_cfg=dict(type='ReLU'),
-    ) -> None:
-        super().__init__()
-        self.local_embedding = ConvModule(
-            in_channels=in_channel,
-            out_channels=embed_dim,
-            kernel_size=1,
-            bias=False,
-            norm_cfg=norm_cfg,
-            act_cfg=None,
-        )
-
-        self.global_act = ConvModule(
-            in_channels=out_channel,
-            out_channels=embed_dim,
-            kernel_size=1,
-            bias=False,
-            norm_cfg=norm_cfg,
-            act_cfg=act_cfg if act_cfg is not None else None,
-        )
-
-    def forward(self, x_l, x_g):
-        """
-        x_g: global features
-        x_l: local features
-        """
-        B, C, H, W = x_l.shape
-
-        local_feat = self.local_embedding(x_l)
-        global_act = self.global_act(x_g)
-        sig_act = F.interpolate(
-            global_act, size=(H, W), mode='bilinear', align_corners=False)
-
-        out = local_feat * sig_act
-
-        return out
-
-
-class InjectionMultiSumallmultiallsum(nn.Module):
-    """the Aggregate Attention Module.
-
-    Args:
-        in_channels (tuple): the input channel.
-        out_channels (int): the output channel.
-        act_cfg (dict): Config dict for activation layer.
-            Default: dict(type='ReLU').
-        norm_cfg (dict): Config dict for normalization layer.
-            Default: dict(type='BN')
-    """
-
-    def __init__(
-            self,
-            in_channels=(64, 128, 256, 384),
-            out_channels=256,
-            act_cfg=dict(type='Sigmoid'),
-            norm_cfg=dict(type='BN'),
-    ):
-        super().__init__()
-        self.embedding_list = nn.ModuleList()
-        self.act_embedding_list = nn.ModuleList()
-        self.act_list = nn.ModuleList()
-        for i in range(len(in_channels)):
-            self.embedding_list.append(
-                ConvModule(
-                    in_channels=in_channels[i],
-                    out_channels=out_channels,
-                    kernel_size=1,
-                    bias=False,
-                    norm_cfg=norm_cfg,
-                    act_cfg=None,
-                ))
-            self.act_embedding_list.append(
-                ConvModule(
-                    in_channels=in_channels[i],
-                    out_channels=out_channels,
-                    kernel_size=1,
-                    bias=False,
-                    norm_cfg=norm_cfg,
-                    act_cfg=act_cfg,
-                ))
-
-    def forward(self, inputs):  # x_x8, x_x16, x_x32, x_x64
-        low_feat1 = F.interpolate(inputs[0], scale_factor=0.5, mode='bilinear')
-        low_feat1_act = self.act_embedding_list[0](low_feat1)
-        low_feat1 = self.embedding_list[0](low_feat1)
-
-        low_feat2 = F.interpolate(
-            inputs[1], size=low_feat1.shape[-2:], mode='bilinear')
-        low_feat2_act = self.act_embedding_list[1](low_feat2)  # x16
-        low_feat2 = self.embedding_list[1](low_feat2)
-
-        high_feat_act = F.interpolate(
-            self.act_embedding_list[2](inputs[2]),
-            size=low_feat2.shape[2:],
-            mode='bilinear',
-        )
-        high_feat = F.interpolate(
-            self.embedding_list[2](inputs[2]),
-            size=low_feat2.shape[2:],
-            mode='bilinear')
-
-        res = (
-            low_feat1_act * low_feat2_act * high_feat_act *
-            (low_feat1 + low_feat2) + high_feat)
-
-        return res
-
-
-class InjectionMultiSumallmultiallsumSimpx8(nn.Module):
-    """the Aggregate Attention Module.
-
-    Args:
-        in_channels (tuple): the input channel.
-        out_channels (int): the output channel.
-        act_cfg (dict): Config dict for activation layer.
-            Default: dict(type='ReLU').
-        norm_cfg (dict): Config dict for normalization layer.
-            Default: dict(type='BN')
-    """
-
-    def __init__(
-            self,
-            in_channels=(64, 128, 256, 384),
-            out_channels=256,
-            act_cfg=dict(type='Sigmoid'),
-            norm_cfg=dict(type='BN'),
-    ):
-        super().__init__()
-        self.embedding_list = nn.ModuleList()
-        self.act_embedding_list = nn.ModuleList()
-        self.act_list = nn.ModuleList()
-        for i in range(len(in_channels)):
-            if i != 1:
-                self.embedding_list.append(
-                    ConvModule(
-                        in_channels=in_channels[i],
-                        out_channels=out_channels,
-                        kernel_size=1,
-                        bias=False,
-                        norm_cfg=norm_cfg,
-                        act_cfg=None,
-                    ))
-            if i != 0:
-                self.act_embedding_list.append(
-                    ConvModule(
-                        in_channels=in_channels[i],
-                        out_channels=out_channels,
-                        kernel_size=1,
-                        bias=False,
-                        norm_cfg=norm_cfg,
-                        act_cfg=act_cfg,
-                    ))
-
-    def forward(self, inputs):
-        # x_x8, x_x16, x_x32
-        low_feat1 = self.embedding_list[0](inputs[0])
-
-        low_feat2 = F.interpolate(
-            inputs[1], size=low_feat1.shape[-2:], mode='bilinear')
-        low_feat2_act = self.act_embedding_list[0](low_feat2)
-
-        high_feat_act = F.interpolate(
-            self.act_embedding_list[1](inputs[2]),
-            size=low_feat2.shape[2:],
-            mode='bilinear',
-        )
-        high_feat = F.interpolate(
-            self.embedding_list[1](inputs[2]),
-            size=low_feat2.shape[2:],
-            mode='bilinear')
-
-        res = low_feat2_act * high_feat_act * low_feat1 + high_feat
-
-        return res
-
-
-def _make_divisible(v, divisor=8, min_value=None):
-    if min_value is None:
-        min_value = divisor
-    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
-    if new_v < 0.9 * v:
-        new_v += divisor
-    return new_v
-
-
-@MODELS.register_module()
-class Hardsigmoid(nn.Module):
-    """the hardsigmoid activation.
-
-    Args:
-        slope (float, optional): The slope of hardsigmoid function.
-            Default is 0.1666667.
-        offset (float, optional): The offset of hardsigmoid function.
-            Default is 0.5.
-        inplace (bool): can optionally do the operation in-place.
-            Default: ``False``
-    """
-
-    def __init__(self, slope=0.1666667, offset=0.5, inplace=False):
-        super().__init__()
-        self.slope = slope
-        self.offset = offset
-
-    def forward(self, x):
-        return (x * self.slope + self.offset).clamp(0, 1)
diff --git a/mmsegmentation/projects/pp_mobileseg/configs/_base_/datasets/ade20k.py b/mmsegmentation/projects/pp_mobileseg/configs/_base_/datasets/ade20k.py
deleted file mode 100644
index 48340d1..0000000
--- a/mmsegmentation/projects/pp_mobileseg/configs/_base_/datasets/ade20k.py
+++ /dev/null
@@ -1,68 +0,0 @@
-# dataset settings
-dataset_type = 'ADE20KDataset'
-data_root = 'data/ade/ADEChallengeData2016'
-crop_size = (512, 512)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(
-        type='RandomResize',
-        scale=(2048, 512),
-        ratio_range=(0.5, 2.0),
-        keep_ratio=True),
-    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', prob=0.5),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs')
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='PackSegInputs')
-]
-img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
-tta_pipeline = [
-    dict(type='LoadImageFromFile', backend_args=None),
-    dict(
-        type='TestTimeAug',
-        transforms=[
-            [
-                dict(type='Resize', scale_factor=r, keep_ratio=True)
-                for r in img_ratios
-            ],
-            [
-                dict(type='RandomFlip', prob=0., direction='horizontal'),
-                dict(type='RandomFlip', prob=1., direction='horizontal')
-            ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')]
-        ])
-]
-train_dataloader = dict(
-    batch_size=4,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='InfiniteSampler', shuffle=True),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='images/training', seg_map_path='annotations/training'),
-        pipeline=train_pipeline))
-val_dataloader = dict(
-    batch_size=1,
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(type='DefaultSampler', shuffle=False),
-    dataset=dict(
-        type=dataset_type,
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='images/validation',
-            seg_map_path='annotations/validation'),
-        pipeline=test_pipeline))
-test_dataloader = val_dataloader
-
-val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
-test_evaluator = val_evaluator
diff --git a/mmsegmentation/projects/pp_mobileseg/configs/_base_/default_runtime.py b/mmsegmentation/projects/pp_mobileseg/configs/_base_/default_runtime.py
deleted file mode 100644
index 272b4d2..0000000
--- a/mmsegmentation/projects/pp_mobileseg/configs/_base_/default_runtime.py
+++ /dev/null
@@ -1,15 +0,0 @@
-default_scope = 'mmseg'
-env_cfg = dict(
-    cudnn_benchmark=True,
-    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
-    dist_cfg=dict(backend='nccl'),
-)
-vis_backends = [dict(type='LocalVisBackend')]
-visualizer = dict(
-    type='SegLocalVisualizer', vis_backends=vis_backends, name='visualizer')
-log_processor = dict(by_epoch=False)
-log_level = 'INFO'
-load_from = None
-resume = False
-
-tta_model = dict(type='SegTTAModel')
diff --git a/mmsegmentation/projects/pp_mobileseg/configs/_base_/models/pp_mobile.py b/mmsegmentation/projects/pp_mobileseg/configs/_base_/models/pp_mobile.py
deleted file mode 100644
index 0c76956..0000000
--- a/mmsegmentation/projects/pp_mobileseg/configs/_base_/models/pp_mobile.py
+++ /dev/null
@@ -1,47 +0,0 @@
-# model settings
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    mean=[123.675, 116.28, 103.53],
-    std=[58.395, 57.12, 57.375],
-    bgr_to_rgb=True,
-    pad_val=0,
-    seg_pad_val=255)
-
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    # pretrained='open-mmlab://resnet50_v1c',
-    backbone=dict(
-        type='StrideFormer',
-        mobileV3_cfg=[
-            # k t c, s
-            [[3, 16, 16, True, 'ReLU', 1], [3, 64, 32, False, 'ReLU', 2],
-             [3, 96, 32, False, 'ReLU', 1]],  # cfg1
-            [[5, 128, 64, True, 'HSwish', 2], [5, 240, 64, True, 'HSwish',
-                                               1]],  # cfg2
-            [[5, 384, 128, True, 'HSwish', 2],
-             [5, 384, 128, True, 'HSwish', 1]],  # cfg3
-            [[5, 768, 192, True, 'HSwish', 2],
-             [5, 768, 192, True, 'HSwish', 1]],  # cfg4
-        ],
-        channels=[16, 32, 64, 128, 192],
-        depths=[3, 3],
-        embed_dims=[128, 192],
-        num_heads=8,
-        inj_type='AAMSx8',
-        out_feat_chs=[64, 128, 192],
-        act_cfg=dict(type='ReLU6'),
-    ),
-    decode_head=dict(
-        type='PPMobileSegHead',
-        num_classes=150,
-        in_channels=256,
-        dropout_ratio=0.1,
-        use_dw=True,
-        act_cfg=dict(type='ReLU'),
-        align_corners=False),
-
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/projects/pp_mobileseg/configs/_base_/schedules/schedule_80k.py b/mmsegmentation/projects/pp_mobileseg/configs/_base_/schedules/schedule_80k.py
deleted file mode 100644
index 0dcd6c4..0000000
--- a/mmsegmentation/projects/pp_mobileseg/configs/_base_/schedules/schedule_80k.py
+++ /dev/null
@@ -1,24 +0,0 @@
-# optimizer
-optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
-optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
-# learning policy
-param_scheduler = [
-    dict(
-        type='PolyLR',
-        eta_min=1e-4,
-        power=0.9,
-        begin=0,
-        end=80000,
-        by_epoch=False)
-]
-# training schedule for 80k
-train_cfg = dict(type='IterBasedTrainLoop', max_iters=80000, val_interval=8000)
-val_cfg = dict(type='ValLoop')
-test_cfg = dict(type='TestLoop')
-default_hooks = dict(
-    timer=dict(type='IterTimerHook'),
-    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
-    param_scheduler=dict(type='ParamSchedulerHook'),
-    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=8000),
-    sampler_seed=dict(type='DistSamplerSeedHook'),
-    visualization=dict(type='SegVisualizationHook'))
diff --git a/mmsegmentation/projects/pp_mobileseg/configs/pp_mobileseg/pp_mobileseg_mobilenetv3_2x16_80k_ade20k_512x512_base.py b/mmsegmentation/projects/pp_mobileseg/configs/pp_mobileseg/pp_mobileseg_mobilenetv3_2x16_80k_ade20k_512x512_base.py
deleted file mode 100644
index 4b68a92..0000000
--- a/mmsegmentation/projects/pp_mobileseg/configs/pp_mobileseg/pp_mobileseg_mobilenetv3_2x16_80k_ade20k_512x512_base.py
+++ /dev/null
@@ -1,18 +0,0 @@
-_base_ = [
-    '../_base_/models/pp_mobile.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-# the custom import path is determined by your workspace path (i.e., where you run the command from) # noqa
-custom_imports = dict(
-    imports=[
-        'projects.pp_mobileseg.backbones', 'projects.pp_mobileseg.decode_head'
-    ],
-    allow_failed_imports=False)
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pp_mobileseg/pp_mobileseg_mobilenetv3_3rdparty-base-ed0be681.pth'  # noqa
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size, test_cfg=dict(size_divisor=32))
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(init_cfg=dict(type='Pretrained', checkpoint=checkpoint)),
-    decode_head=dict(num_classes=150, upsample='intepolate'))
diff --git a/mmsegmentation/projects/pp_mobileseg/configs/pp_mobileseg/pp_mobileseg_mobilenetv3_2x16_80k_ade20k_512x512_tiny.py b/mmsegmentation/projects/pp_mobileseg/configs/pp_mobileseg/pp_mobileseg_mobilenetv3_2x16_80k_ade20k_512x512_tiny.py
deleted file mode 100644
index b78869e..0000000
--- a/mmsegmentation/projects/pp_mobileseg/configs/pp_mobileseg/pp_mobileseg_mobilenetv3_2x16_80k_ade20k_512x512_tiny.py
+++ /dev/null
@@ -1,45 +0,0 @@
-_base_ = [
-    '../_base_/models/pp_mobile.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-# the custom import path is determined by your workspace path (i.e., where you run the command from) # noqa
-custom_imports = dict(
-    imports=[
-        'projects.pp_mobileseg.backbones', 'projects.pp_mobileseg.decode_head'
-    ],
-    allow_failed_imports=False)
-checkpoint = 'https://download.openmmlab.com/mmsegmentation/v0.5/pp_mobileseg/pp_mobileseg_mobilenetv3_3rdparty-tiny-e4b35e96.pth'  # noqa
-crop_size = (512, 512)
-data_preprocessor = dict(size=crop_size, test_cfg=dict(size_divisor=32))
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        init_cfg=dict(type='Pretrained', checkpoint=checkpoint),
-        type='StrideFormer',
-        mobileV3_cfg=[
-            # k t c, s
-            [[3, 16, 16, True, 'ReLU', 1], [3, 64, 32, False, 'ReLU', 2],
-             [3, 48, 24, False, 'ReLU', 1]],  # cfg1
-            [[5, 96, 32, True, 'HSwish', 2], [5, 96, 32, True, 'HSwish',
-                                              1]],  # cfg2
-            [[5, 160, 64, True, 'HSwish', 2], [5, 160, 64, True, 'HSwish',
-                                               1]],  # cfg3
-            [[3, 384, 128, True, 'HSwish', 2],
-             [3, 384, 128, True, 'HSwish', 1]],  # cfg4
-        ],
-        channels=[16, 24, 32, 64, 128],
-        depths=[2, 2],
-        embed_dims=[64, 128],
-        num_heads=4,
-        inj_type='AAM',
-        out_feat_chs=[32, 64, 128],
-        act_cfg=dict(type='ReLU6'),
-    ),
-    decode_head=dict(
-        num_classes=150,
-        in_channels=256,
-        use_dw=True,
-        act_cfg=dict(type='ReLU'),
-        upsample='intepolate'),
-)
diff --git a/mmsegmentation/projects/pp_mobileseg/decode_head/__init__.py b/mmsegmentation/projects/pp_mobileseg/decode_head/__init__.py
deleted file mode 100644
index 6f71b78..0000000
--- a/mmsegmentation/projects/pp_mobileseg/decode_head/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .pp_mobileseg_head import PPMobileSegHead
-
-__all__ = [
-    'PPMobileSegHead',
-]
diff --git a/mmsegmentation/projects/pp_mobileseg/decode_head/pp_mobileseg_head.py b/mmsegmentation/projects/pp_mobileseg/decode_head/pp_mobileseg_head.py
deleted file mode 100644
index 243f026..0000000
--- a/mmsegmentation/projects/pp_mobileseg/decode_head/pp_mobileseg_head.py
+++ /dev/null
@@ -1,94 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from typing import List
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from mmcv.cnn import ConvModule, build_conv_layer
-from torch import Tensor
-
-from mmseg.registry import MODELS
-
-
-@MODELS.register_module()
-class PPMobileSegHead(nn.Module):
-    """the segmentation head.
-
-    Args:
-        num_classes (int): the classes num.
-        in_channels (int): the input channels.
-        use_dw (bool): if to use deepwith convolution.
-        dropout_ratio (float): Probability of an element to be zeroed.
-            Default 0.0。
-        align_corners (bool, optional): Geometrically, we consider the pixels
-            of the input and output as squares rather than points.
-        upsample (str): the upsample method.
-        out_channels (int): the output channel.
-        conv_cfg (dict): Config dict for convolution layer.
-        act_cfg (dict): Config dict for activation layer.
-            Default: dict(type='ReLU').
-        norm_cfg (dict): Config dict for normalization layer.
-            Default: dict(type='BN').
-    """
-
-    def __init__(self,
-                 num_classes,
-                 in_channels,
-                 use_dw=True,
-                 dropout_ratio=0.1,
-                 align_corners=False,
-                 upsample='intepolate',
-                 out_channels=None,
-                 conv_cfg=dict(type='Conv'),
-                 act_cfg=dict(type='ReLU'),
-                 norm_cfg=dict(type='BN')):
-
-        super().__init__()
-        self.align_corners = align_corners
-        self.last_channels = in_channels
-        self.upsample = upsample
-        self.num_classes = num_classes
-        self.out_channels = out_channels
-        self.linear_fuse = ConvModule(
-            in_channels=self.last_channels,
-            out_channels=self.last_channels,
-            kernel_size=1,
-            bias=False,
-            groups=self.last_channels if use_dw else 1,
-            norm_cfg=norm_cfg,
-            act_cfg=act_cfg)
-        self.dropout = nn.Dropout2d(dropout_ratio)
-        self.conv_seg = build_conv_layer(
-            conv_cfg, self.last_channels, self.num_classes, kernel_size=1)
-
-    def forward(self, x):
-        x, x_hw = x[0], x[1]
-        x = self.linear_fuse(x)
-        x = self.dropout(x)
-        x = self.conv_seg(x)
-        if self.upsample == 'intepolate' or self.training or \
-                self.num_classes < 30:
-            x = F.interpolate(
-                x, x_hw, mode='bilinear', align_corners=self.align_corners)
-        elif self.upsample == 'vim':
-            labelset = torch.unique(torch.argmax(x, 1))
-            x = torch.gather(x, 1, labelset)
-            x = F.interpolate(
-                x, x_hw, mode='bilinear', align_corners=self.align_corners)
-
-            pred = torch.argmax(x, 1)
-            pred_retrieve = torch.zeros(pred.shape, dtype=torch.int32)
-            for i, val in enumerate(labelset):
-                pred_retrieve[pred == i] = labelset[i].cast('int32')
-
-            x = pred_retrieve
-        else:
-            raise NotImplementedError(self.upsample, ' is not implemented')
-
-        return [x]
-
-    def predict(self, inputs, batch_img_metas: List[dict], test_cfg,
-                **kwargs) -> List[Tensor]:
-        """Forward function for testing, only ``pam_cam`` is used."""
-        seg_logits = self.forward(inputs)[0]
-        return seg_logits
diff --git a/mmsegmentation/projects/pp_mobileseg/inference_onnx.py b/mmsegmentation/projects/pp_mobileseg/inference_onnx.py
deleted file mode 100644
index 139d1b1..0000000
--- a/mmsegmentation/projects/pp_mobileseg/inference_onnx.py
+++ /dev/null
@@ -1,203 +0,0 @@
-import argparse
-import time
-from typing import List, Tuple
-
-import cv2
-import loguru
-import numpy as np
-import onnxruntime as ort
-
-logger = loguru.logger
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='PP_Mobileseg ONNX inference demo.')
-    parser.add_argument('onnx_file', help='ONNX file path')
-    parser.add_argument('image_file', help='Input image file path')
-    parser.add_argument(
-        '--input-size',
-        type=int,
-        nargs='+',
-        default=[512, 512],
-        help='input image size')
-    parser.add_argument(
-        '--device', help='device type for inference', default='cpu')
-    parser.add_argument(
-        '--save-path',
-        help='path to save the output image',
-        default='output.jpg')
-    args = parser.parse_args()
-    return args
-
-
-def preprocess(
-    img: np.ndarray, input_size: Tuple[int, int] = (512, 512)
-) -> Tuple[np.ndarray, np.ndarray]:
-    """Preprocess image for inference."""
-    img_shape = img.shape[:2]
-    # Resize
-    resized_img = cv2.resize(img, input_size)
-
-    # Normalize
-    mean = np.array([123.575, 116.28, 103.53], dtype=np.float32)
-    std = np.array([58.395, 57.12, 57.375], dtype=np.float32)
-    resized_img = (resized_img - mean) / std
-
-    return resized_img, img_shape
-
-
-def build_session(onnx_file: str, device: str = 'cpu') -> ort.InferenceSession:
-    """Build onnxruntime session.
-
-    Args:
-        onnx_file (str): ONNX file path.
-        device (str): Device type for inference.
-
-    Returns:
-        sess (ort.InferenceSession): ONNXRuntime session.
-    """
-    providers = ['CPUExecutionProvider'
-                 ] if device == 'cpu' else ['CUDAExecutionProvider']
-    sess = ort.InferenceSession(path_or_bytes=onnx_file, providers=providers)
-
-    return sess
-
-
-def inference(sess: ort.InferenceSession, img: np.ndarray) -> np.ndarray:
-    """Inference RTMPose model.
-
-    Args:
-        sess (ort.InferenceSession): ONNXRuntime session.
-        img (np.ndarray): Input image in shape.
-
-    Returns:
-        outputs (np.ndarray): Output of RTMPose model.
-    """
-    # build input
-    input_img = [img.transpose(2, 0, 1).astype(np.float32)]
-
-    # build output
-    sess_input = {sess.get_inputs()[0].name: input_img}
-    sess_output = []
-    for out in sess.get_outputs():
-        sess_output.append(out.name)
-
-    # inference
-    outputs = sess.run(output_names=sess_output, input_feed=sess_input)
-
-    return outputs
-
-
-def postprocess(outputs: List[np.ndarray],
-                origin_shape: Tuple[int, int]) -> np.ndarray:
-    """Postprocess outputs of PP_Mobileseg model.
-
-    Args:
-        outputs (List[np.ndarray]): Outputs of PP_Mobileseg model.
-        origin_shape (Tuple[int, int]): Input size of PP_Mobileseg model.
-
-    Returns:
-        seg_map (np.ndarray): Segmentation map.
-    """
-    seg_map = outputs[0][0][0]
-    seg_map = cv2.resize(seg_map.astype(np.float32), origin_shape)
-    return seg_map
-
-
-def visualize(img: np.ndarray,
-              seg_map: np.ndarray,
-              filename: str = 'output.jpg',
-              opacity: float = 0.8) -> np.ndarray:
-    assert 0.0 <= opacity <= 1.0, 'opacity should be in range [0, 1]'
-    palette = np.array(PALETTE)
-    color_seg = np.zeros((seg_map.shape[0], seg_map.shape[1], 3),
-                         dtype=np.uint8)
-    for label, color in enumerate(palette):
-        color_seg[seg_map == label, :] = color
-    # convert to BGR
-    color_seg = color_seg[..., ::-1]
-
-    img = img * (1 - opacity) + color_seg * opacity
-    cv2.imwrite(filename, img)
-
-    return img
-
-
-def main():
-    args = parse_args()
-    logger.info('Start running model inference...')
-
-    # read image from file
-    logger.info(f'1. Read image from file {args.image_file}...')
-    img = cv2.imread(args.image_file)
-
-    # build onnx model
-    logger.info(f'2. Build onnx model from {args.onnx_file}...')
-    sess = build_session(args.onnx_file, args.device)
-
-    # preprocess
-    logger.info('3. Preprocess image...')
-    model_input_size = tuple(args.input_size)
-    assert len(model_input_size) == 2
-    resized_img, origin_shape = preprocess(img, model_input_size)
-
-    # inference
-    logger.info('4. Inference...')
-    start = time.time()
-    outputs = inference(sess, resized_img)
-    logger.info(f'Inference time: {time.time() - start:.4f}s')
-
-    # postprocess
-    logger.info('5. Postprocess...')
-    h, w = origin_shape
-    seg_map = postprocess(outputs, (w, h))
-
-    # visualize
-    logger.info('6. Visualize...')
-    visualize(img, seg_map, args.save_path)
-
-    logger.info('Done...')
-
-
-PALETTE = [[120, 120, 120], [180, 120, 120], [6, 230, 230], [80, 50, 50],
-           [4, 200, 3], [120, 120, 80], [140, 140, 140], [204, 5, 255],
-           [230, 230, 230], [4, 250, 7], [224, 5, 255], [235, 255, 7],
-           [150, 5, 61], [120, 120, 70], [8, 255, 51], [255, 6, 82],
-           [143, 255, 140], [204, 255, 4], [255, 51, 7], [204, 70, 3],
-           [0, 102, 200], [61, 230, 250], [255, 6, 51], [11, 102, 255],
-           [255, 7, 71], [255, 9, 224], [9, 7, 230], [220, 220, 220],
-           [255, 9, 92], [112, 9, 255], [8, 255, 214], [7, 255, 224],
-           [255, 184, 6], [10, 255, 71], [255, 41, 10], [7, 255, 255],
-           [224, 255, 8], [102, 8, 255], [255, 61, 6], [255, 194, 7],
-           [255, 122, 8], [0, 255, 20], [255, 8, 41], [255, 5, 153],
-           [6, 51, 255], [235, 12, 255], [160, 150, 20], [0, 163, 255],
-           [140, 140, 140], [250, 10, 15], [20, 255, 0], [31, 255, 0],
-           [255, 31, 0], [255, 224, 0], [153, 255, 0], [0, 0, 255],
-           [255, 71, 0], [0, 235, 255], [0, 173, 255], [31, 0, 255],
-           [11, 200, 200], [255, 82, 0], [0, 255, 245], [0, 61, 255],
-           [0, 255, 112], [0, 255, 133], [255, 0, 0], [255, 163, 0],
-           [255, 102, 0], [194, 255, 0], [0, 143, 255], [51, 255, 0],
-           [0, 82, 255], [0, 255, 41], [0, 255, 173], [10, 0, 255],
-           [173, 255, 0], [0, 255, 153], [255, 92, 0], [255, 0, 255],
-           [255, 0, 245], [255, 0, 102], [255, 173, 0], [255, 0, 20],
-           [255, 184, 184], [0, 31, 255], [0, 255, 61], [0, 71, 255],
-           [255, 0, 204], [0, 255, 194], [0, 255, 82], [0, 10, 255],
-           [0, 112, 255], [51, 0, 255], [0, 194, 255], [0, 122, 255],
-           [0, 255, 163], [255, 153, 0], [0, 255, 10], [255, 112, 0],
-           [143, 255, 0], [82, 0, 255], [163, 255, 0], [255, 235, 0],
-           [8, 184, 170], [133, 0, 255], [0, 255, 92], [184, 0, 255],
-           [255, 0, 31], [0, 184, 255], [0, 214, 255], [255, 0, 112],
-           [92, 255, 0], [0, 224, 255], [112, 224, 255], [70, 184, 160],
-           [163, 0, 255], [153, 0, 255], [71, 255, 0], [255, 0, 163],
-           [255, 204, 0], [255, 0, 143], [0, 255, 235], [133, 255, 0],
-           [255, 0, 235], [245, 0, 255], [255, 0, 122], [255, 245, 0],
-           [10, 190, 212], [214, 255, 0], [0, 204, 255], [20, 0, 255],
-           [255, 255, 0], [0, 153, 255], [0, 41, 255], [0, 255, 204],
-           [41, 0, 255], [41, 255, 0], [173, 0, 255], [0, 245, 255],
-           [71, 0, 255], [122, 0, 255], [0, 255, 184], [0, 92, 255],
-           [184, 255, 0], [0, 133, 255], [255, 214, 0], [25, 194, 194],
-           [102, 255, 0], [92, 0, 255]]
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/projects/sam_inference_demo/README.md b/mmsegmentation/projects/sam_inference_demo/README.md
deleted file mode 100644
index f8077b8..0000000
--- a/mmsegmentation/projects/sam_inference_demo/README.md
+++ /dev/null
@@ -1,40 +0,0 @@
-# Introducing the Segment Anything Model (SAM) Inference Demo!
-
-Welcome to the Segment Anything (SA) Inference Demo, a user-friendly implementation based on the original Segment Anything project. Our demo allows you to experience the power and versatility of the Segment Anything Model (SAM) through an easy-to-use API.
-
-With this inference demo, you can explore the capabilities of the Segment Anything Model and witness its effectiveness in various tasks and image distributions. For more information on the original project, dataset, and model, please visit the official website at https://segment-anything.com.
-
-### Prerequisites
-
-- Python 3.10
-- PyTorch 1.13
-- MMEngine >= v0.7.2
-- MMCV >= v2.0.0
-
-### Installation
-
-We assume that you have already installed PyTorch. If not, please follow the instructions on the [PyTorch website](https://pytorch.org/).
-
-**1. Install MMEngine & MMCV**
-
-```shell
-pip install openmim
-mim install mmengine
-mim install 'mmcv>=2.0.0'
-```
-
-**2. Install MMPretrain**
-
-```shell
-pip install git+https://github.com/open-mmlab/mmpretrain.git@dev
-```
-
-**3. Install MMSegmentation**
-
-```shell
-pip install mmsegmentation
-```
-
-### Usage
-
-Open the `sam_image_demo.ipynb` notebook and follow the instructions to run the demo.
diff --git a/mmsegmentation/projects/sam_inference_demo/sam/__init__.py b/mmsegmentation/projects/sam_inference_demo/sam/__init__.py
deleted file mode 100644
index 82b6b78..0000000
--- a/mmsegmentation/projects/sam_inference_demo/sam/__init__.py
+++ /dev/null
@@ -1,2 +0,0 @@
-from .modeling import *  # noqa
-from .utils import *  # noqa
diff --git a/mmsegmentation/projects/sam_inference_demo/sam/modeling/__init__.py b/mmsegmentation/projects/sam_inference_demo/sam/modeling/__init__.py
deleted file mode 100644
index 9892a6b..0000000
--- a/mmsegmentation/projects/sam_inference_demo/sam/modeling/__init__.py
+++ /dev/null
@@ -1,12 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-from .mask_decoder import MaskDecoder
-from .prompt_encoder import PromptEncoder
-from .sam import SAM
-from .transformer import TwoWayTransformer
-
-__all__ = ['SAM', 'MaskDecoder', 'PromptEncoder', 'TwoWayTransformer']
diff --git a/mmsegmentation/projects/sam_inference_demo/sam/modeling/common.py b/mmsegmentation/projects/sam_inference_demo/sam/modeling/common.py
deleted file mode 100644
index d289276..0000000
--- a/mmsegmentation/projects/sam_inference_demo/sam/modeling/common.py
+++ /dev/null
@@ -1,45 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-from typing import Type
-
-import torch
-import torch.nn as nn
-
-
-class MLPBlock(nn.Module):
-
-    def __init__(
-        self,
-        embedding_dim: int,
-        mlp_dim: int,
-        act: Type[nn.Module] = nn.GELU,
-    ) -> None:
-        super().__init__()
-        self.lin1 = nn.Linear(embedding_dim, mlp_dim)
-        self.lin2 = nn.Linear(mlp_dim, embedding_dim)
-        self.act = act()
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        return self.lin2(self.act(self.lin1(x)))
-
-
-# From https://github.com/facebookresearch/detectron2/blob/main/detectron2/layers/batch_norm.py # noqa
-# Itself from https://github.com/facebookresearch/ConvNeXt/blob/d1fa8f6fef0a165b27399986cc2bdacc92777e40/models/convnext.py#L119  # noqa
-class LayerNorm2d(nn.Module):
-
-    def __init__(self, num_channels: int, eps: float = 1e-6) -> None:
-        super().__init__()
-        self.weight = nn.Parameter(torch.ones(num_channels))
-        self.bias = nn.Parameter(torch.zeros(num_channels))
-        self.eps = eps
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        u = x.mean(1, keepdim=True)
-        s = (x - u).pow(2).mean(1, keepdim=True)
-        x = (x - u) / torch.sqrt(s + self.eps)
-        x = self.weight[:, None, None] * x + self.bias[:, None, None]
-        return x
diff --git a/mmsegmentation/projects/sam_inference_demo/sam/modeling/mask_decoder.py b/mmsegmentation/projects/sam_inference_demo/sam/modeling/mask_decoder.py
deleted file mode 100644
index 9ad616b..0000000
--- a/mmsegmentation/projects/sam_inference_demo/sam/modeling/mask_decoder.py
+++ /dev/null
@@ -1,196 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-# Borrowed from https://github.com/facebookresearch/segment-anything
-
-from typing import List, Tuple
-
-import torch
-from torch import Tensor, nn
-from torch.nn import functional as F
-
-from mmseg.registry import MODELS
-from .common import LayerNorm2d
-
-
-@MODELS.register_module()
-class MaskDecoder(nn.Module):
-
-    def __init__(
-        self,
-        *,
-        transformer_dim: int,
-        transformer: dict,
-        num_multimask_outputs: int = 3,
-        act_cfg: dict = dict(type='GELU'),
-        iou_head_depth: int = 3,
-        iou_head_hidden_dim: int = 256,
-    ) -> None:
-        """Predicts masks given an image and prompt embeddings, using a
-        tranformer architecture.
-
-        Borrowed from https://github.com/facebookresearch/segment-anything
-
-        Arguments:
-          transformer_dim (int): the channel dimension of the transformer
-          transformer (nn.Module): the transformer used to predict masks
-          num_multimask_outputs (int): the number of masks to predict
-            when disambiguating masks
-          activation (nn.Module): the type of activation to use when
-            upscaling masks
-          iou_head_depth (int): the depth of the MLP used to predict
-            mask quality
-          iou_head_hidden_dim (int): the hidden dimension of the MLP
-            used to predict mask quality
-        """
-        super().__init__()
-        self.transformer_dim = transformer_dim
-        self.transformer = MODELS.build(transformer)
-
-        self.num_multimask_outputs = num_multimask_outputs
-
-        self.iou_token = nn.Embedding(1, transformer_dim)
-        self.num_mask_tokens = num_multimask_outputs + 1
-        self.mask_tokens = nn.Embedding(self.num_mask_tokens, transformer_dim)
-
-        activation = MODELS.build(act_cfg)
-        self.output_upscaling = nn.Sequential(
-            nn.ConvTranspose2d(
-                transformer_dim, transformer_dim // 4, kernel_size=2,
-                stride=2),
-            LayerNorm2d(transformer_dim // 4),
-            activation,
-            nn.ConvTranspose2d(
-                transformer_dim // 4,
-                transformer_dim // 8,
-                kernel_size=2,
-                stride=2),
-            activation,
-        )
-        self.output_hypernetworks_mlps = nn.ModuleList([
-            MLP(transformer_dim, transformer_dim, transformer_dim // 8, 3)
-            for i in range(self.num_mask_tokens)
-        ])
-
-        self.iou_prediction_head = MLP(transformer_dim, iou_head_hidden_dim,
-                                       self.num_mask_tokens, iou_head_depth)
-
-    def forward(
-        self,
-        image_embeddings: Tensor,
-        image_pe: Tensor,
-        sparse_prompt_embeddings: Tensor,
-        dense_prompt_embeddings: Tensor,
-        multimask_output: bool,
-    ) -> Tuple[Tensor, Tensor]:
-        """Predict masks given image and prompt embeddings.
-
-        Borrowed from https://github.com/facebookresearch/segment-anything
-
-        Arguments:
-          image_embeddings (Tensor): the embeddings from the image encoder
-          image_pe (Tensor): positional encoding with the shape of
-            image_embeddings
-          sparse_prompt_embeddings (Tensor): the embeddings of
-            the points and boxes
-          dense_prompt_embeddings (Tensor): the embeddings of the mask inputs
-          multimask_output (bool): Whether to return multiple masks or a single
-            mask.
-
-        Returns:
-          Tensor: batched predicted masks
-          Tensor: batched predictions of mask quality
-        """
-        masks, iou_pred = self.predict_masks(
-            image_embeddings=image_embeddings,
-            image_pe=image_pe,
-            sparse_prompt_embeddings=sparse_prompt_embeddings,
-            dense_prompt_embeddings=dense_prompt_embeddings,
-        )
-
-        # Select the correct mask or masks for output
-        if multimask_output:
-            mask_slice = slice(1, None)
-        else:
-            mask_slice = slice(0, 1)
-        masks = masks[:, mask_slice, :, :]
-        iou_pred = iou_pred[:, mask_slice]
-
-        # Prepare output
-        return masks, iou_pred
-
-    def predict_masks(
-        self,
-        image_embeddings: Tensor,
-        image_pe: Tensor,
-        sparse_prompt_embeddings: Tensor,
-        dense_prompt_embeddings: Tensor,
-    ) -> Tuple[Tensor, Tensor]:
-        """Predicts masks.
-
-        See 'forward' for more details.
-        """
-        # Concatenate output tokens
-        output_tokens = torch.cat(
-            [self.iou_token.weight, self.mask_tokens.weight], dim=0)
-        output_tokens = output_tokens.unsqueeze(0).expand(
-            sparse_prompt_embeddings.size(0), -1, -1)
-        tokens = torch.cat((output_tokens, sparse_prompt_embeddings), dim=1)
-
-        # Expand per-image data in batch direction to be per-mask
-        src = torch.repeat_interleave(image_embeddings, tokens.shape[0], dim=0)
-        src = src + dense_prompt_embeddings
-        pos_src = torch.repeat_interleave(image_pe, tokens.shape[0], dim=0)
-        b, c, h, w = src.shape
-
-        # Run the transformer
-        hs, src = self.transformer(src, pos_src, tokens)
-        iou_token_out = hs[:, 0, :]
-        mask_tokens_out = hs[:, 1:(1 + self.num_mask_tokens), :]
-
-        # Upscale mask embeddings and predict masks using the mask tokens
-        src = src.transpose(1, 2).view(b, c, h, w)
-        upscaled_embedding = self.output_upscaling(src)
-        hyper_in_list: List[Tensor] = []
-        for i in range(self.num_mask_tokens):
-            hyper_in_list.append(self.output_hypernetworks_mlps[i](
-                mask_tokens_out[:, i, :]))
-        hyper_in = torch.stack(hyper_in_list, dim=1)
-        b, c, h, w = upscaled_embedding.shape
-        masks = (hyper_in @ upscaled_embedding.view(b, c, h * w)).view(
-            b, -1, h, w)
-
-        # Generate mask quality predictions
-        iou_pred = self.iou_prediction_head(iou_token_out)
-
-        return masks, iou_pred
-
-
-# Lightly adapted from
-# https://github.com/facebookresearch/MaskFormer/blob/main/mask_former/modeling/transformer/transformer_predictor.py # noqa
-class MLP(nn.Module):
-
-    def __init__(
-        self,
-        input_dim: int,
-        hidden_dim: int,
-        output_dim: int,
-        num_layers: int,
-        sigmoid_output: bool = False,
-    ) -> None:
-        super().__init__()
-        self.num_layers = num_layers
-        h = [hidden_dim] * (num_layers - 1)
-        self.layers = nn.ModuleList(
-            nn.Linear(n, k) for n, k in zip([input_dim] + h, h + [output_dim]))
-        self.sigmoid_output = sigmoid_output
-
-    def forward(self, x):
-        for i, layer in enumerate(self.layers):
-            x = F.relu(layer(x)) if i < self.num_layers - 1 else layer(x)
-        if self.sigmoid_output:
-            x = F.sigmoid(x)
-        return x
diff --git a/mmsegmentation/projects/sam_inference_demo/sam/modeling/prompt_encoder.py b/mmsegmentation/projects/sam_inference_demo/sam/modeling/prompt_encoder.py
deleted file mode 100644
index 6b7c083..0000000
--- a/mmsegmentation/projects/sam_inference_demo/sam/modeling/prompt_encoder.py
+++ /dev/null
@@ -1,227 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-# Borrowed from https://github.com/facebookresearch/segment-anything
-
-from typing import Any, Optional, Tuple, Type
-
-import numpy as np
-import torch
-from torch import nn
-
-from mmseg.registry import MODELS
-from .common import LayerNorm2d
-
-
-@MODELS.register_module()
-class PromptEncoder(nn.Module):
-
-    def __init__(
-        self,
-        embed_dim: int,
-        image_embedding_size: Tuple[int, int],
-        input_image_size: Tuple[int, int],
-        mask_in_chans: int,
-        activation: Type[nn.Module] = nn.GELU,
-    ) -> None:
-        """Encodes prompts for input to SAM's mask decoder.
-
-        Arguments:
-          embed_dim (int): The prompts' embedding dimension
-          image_embedding_size (tuple(int, int)): The spatial size of the
-            image embedding, as (H, W).
-          input_image_size (int): The padded size of the image as input
-            to the image encoder, as (H, W).
-          mask_in_chans (int): The number of hidden channels used for
-            encoding input masks.
-          activation (nn.Module): The activation to use when encoding
-            input masks.
-        """
-        super().__init__()
-        self.embed_dim = embed_dim
-        self.input_image_size = input_image_size
-        self.image_embedding_size = image_embedding_size
-        self.pe_layer = PositionEmbeddingRandom(embed_dim // 2)
-
-        self.num_point_embeddings: int = 4  # pos/neg point + 2 box corners
-        point_embeddings = [
-            nn.Embedding(1, embed_dim)
-            for i in range(self.num_point_embeddings)
-        ]
-        self.point_embeddings = nn.ModuleList(point_embeddings)
-        self.not_a_point_embed = nn.Embedding(1, embed_dim)
-
-        self.mask_input_size = (4 * image_embedding_size[0],
-                                4 * image_embedding_size[1])
-        self.mask_downscaling = nn.Sequential(
-            nn.Conv2d(1, mask_in_chans // 4, kernel_size=2, stride=2),
-            LayerNorm2d(mask_in_chans // 4),
-            activation(),
-            nn.Conv2d(
-                mask_in_chans // 4, mask_in_chans, kernel_size=2, stride=2),
-            LayerNorm2d(mask_in_chans),
-            activation(),
-            nn.Conv2d(mask_in_chans, embed_dim, kernel_size=1),
-        )
-        self.no_mask_embed = nn.Embedding(1, embed_dim)
-
-    def get_dense_pe(self) -> torch.Tensor:
-        """Returns the positional encoding used to encode point prompts,
-        applied to a dense set of points the shape of the image encoding.
-
-        Returns:
-          torch.Tensor: Positional encoding with shape
-            1x(embed_dim)x(embedding_h)x(embedding_w)
-        """
-        return self.pe_layer(self.image_embedding_size).unsqueeze(0)
-
-    def _embed_points(
-        self,
-        points: torch.Tensor,
-        labels: torch.Tensor,
-        pad: bool,
-    ) -> torch.Tensor:
-        """Embeds point prompts."""
-        points = points + 0.5  # Shift to center of pixel
-        if pad:
-            padding_point = torch.zeros((points.shape[0], 1, 2),
-                                        device=points.device)
-            padding_label = -torch.ones(
-                (labels.shape[0], 1), device=labels.device)
-            points = torch.cat([points, padding_point], dim=1)
-            labels = torch.cat([labels, padding_label], dim=1)
-        point_embedding = self.pe_layer.forward_with_coords(
-            points, self.input_image_size)
-        point_embedding[labels == -1] = 0.0
-        point_embedding[labels == -1] += self.not_a_point_embed.weight
-        point_embedding[labels == 0] += self.point_embeddings[0].weight
-        point_embedding[labels == 1] += self.point_embeddings[1].weight
-        return point_embedding
-
-    def _embed_boxes(self, boxes: torch.Tensor) -> torch.Tensor:
-        """Embeds box prompts."""
-        boxes = boxes + 0.5  # Shift to center of pixel
-        coords = boxes.reshape(-1, 2, 2)
-        corner_embedding = self.pe_layer.forward_with_coords(
-            coords, self.input_image_size)
-        corner_embedding[:, 0, :] += self.point_embeddings[2].weight
-        corner_embedding[:, 1, :] += self.point_embeddings[3].weight
-        return corner_embedding
-
-    def _embed_masks(self, masks: torch.Tensor) -> torch.Tensor:
-        """Embeds mask inputs."""
-        mask_embedding = self.mask_downscaling(masks)
-        return mask_embedding
-
-    def _get_batch_size(
-        self,
-        points: Optional[Tuple[torch.Tensor, torch.Tensor]],
-        boxes: Optional[torch.Tensor],
-        masks: Optional[torch.Tensor],
-    ) -> int:
-        """Gets the batch size of the output given the batch size of the input
-        prompts."""
-        if points is not None:
-            return points[0].shape[0]
-        elif boxes is not None:
-            return boxes.shape[0]
-        elif masks is not None:
-            return masks.shape[0]
-        else:
-            return 1
-
-    def _get_device(self) -> torch.device:
-        return self.point_embeddings[0].weight.device
-
-    def forward(
-        self,
-        points: Optional[Tuple[torch.Tensor, torch.Tensor]],
-        boxes: Optional[torch.Tensor],
-        masks: Optional[torch.Tensor],
-    ) -> Tuple[torch.Tensor, torch.Tensor]:
-        """Embeds different types of prompts, returning both sparse and dense
-        embeddings.
-
-        Arguments:
-          points (tuple(torch.Tensor, torch.Tensor) or none): point coordinates
-            and labels to embed.
-          boxes (torch.Tensor or none): boxes to embed
-          masks (torch.Tensor or none): masks to embed
-
-        Returns:
-          torch.Tensor: sparse embeddings for the points and boxes, with shape
-            BxNx(embed_dim), where N is determined by the number of input points
-            and boxes.
-          torch.Tensor: dense embeddings for the masks, in the shape
-            Bx(embed_dim)x(embed_H)x(embed_W)
-        """ # noqa
-        bs = self._get_batch_size(points, boxes, masks)
-        sparse_embeddings = torch.empty((bs, 0, self.embed_dim),
-                                        device=self._get_device())
-        if points is not None:
-            coords, labels = points
-            point_embeddings = self._embed_points(
-                coords, labels, pad=(boxes is None))
-            sparse_embeddings = torch.cat(
-                [sparse_embeddings, point_embeddings], dim=1)
-        if boxes is not None:
-            box_embeddings = self._embed_boxes(boxes)
-            sparse_embeddings = torch.cat([sparse_embeddings, box_embeddings],
-                                          dim=1)
-
-        if masks is not None:
-            dense_embeddings = self._embed_masks(masks)
-        else:
-            dense_embeddings = self.no_mask_embed.weight.reshape(
-                1, -1, 1, 1).expand(bs, -1, self.image_embedding_size[0],
-                                    self.image_embedding_size[1])
-
-        return sparse_embeddings, dense_embeddings
-
-
-class PositionEmbeddingRandom(nn.Module):
-    """Positional encoding using random spatial frequencies."""
-
-    def __init__(self,
-                 num_pos_feats: int = 64,
-                 scale: Optional[float] = None) -> None:
-        super().__init__()
-        if scale is None or scale <= 0.0:
-            scale = 1.0
-        self.register_buffer(
-            'positional_encoding_gaussian_matrix',
-            scale * torch.randn((2, num_pos_feats)),
-        )
-
-    def _pe_encoding(self, coords: torch.Tensor) -> torch.Tensor:
-        """Positionally encode points that are normalized to [0,1]."""
-        # assuming coords are in [0, 1]^2 square and have d_1 x ... x d_n x 2 shape # noqa
-        coords = 2 * coords - 1
-        coords = coords @ self.positional_encoding_gaussian_matrix
-        coords = 2 * np.pi * coords
-        # outputs d_1 x ... x d_n x C shape
-        return torch.cat([torch.sin(coords), torch.cos(coords)], dim=-1)
-
-    def forward(self, size: Tuple[int, int]) -> torch.Tensor:
-        """Generate positional encoding for a grid of the specified size."""
-        h, w = size
-        device: Any = self.positional_encoding_gaussian_matrix.device
-        grid = torch.ones((h, w), device=device, dtype=torch.float32)
-        y_embed = grid.cumsum(dim=0) - 0.5
-        x_embed = grid.cumsum(dim=1) - 0.5
-        y_embed = y_embed / h
-        x_embed = x_embed / w
-
-        pe = self._pe_encoding(torch.stack([x_embed, y_embed], dim=-1))
-        return pe.permute(2, 0, 1)  # C x H x W
-
-    def forward_with_coords(self, coords_input: torch.Tensor,
-                            image_size: Tuple[int, int]) -> torch.Tensor:
-        """Positionally encode points that are not normalized to [0,1]."""
-        coords = coords_input.clone()
-        coords[:, :, 0] = coords[:, :, 0] / image_size[1]
-        coords[:, :, 1] = coords[:, :, 1] / image_size[0]
-        return self._pe_encoding(coords.to(torch.float))  # B x N x C
diff --git a/mmsegmentation/projects/sam_inference_demo/sam/modeling/sam.py b/mmsegmentation/projects/sam_inference_demo/sam/modeling/sam.py
deleted file mode 100644
index c61c1ec..0000000
--- a/mmsegmentation/projects/sam_inference_demo/sam/modeling/sam.py
+++ /dev/null
@@ -1,188 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-# Borrowed from https://github.com/facebookresearch/segment-anything
-
-from typing import Any, Dict, List, Tuple
-
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-from mmseg.registry import MODELS
-from .mask_decoder import MaskDecoder
-from .prompt_encoder import PromptEncoder
-
-
-@MODELS.register_module()
-class SAM(nn.Module):
-    mask_threshold: float = 0.0
-    image_format: str = 'RGB'
-
-    def __init__(
-        self,
-        image_encoder_cfg: dict,
-        prompt_encoder_cfg: dict,
-        mask_decoder_cfg: dict,
-        pixel_mean: List[float] = [123.675, 116.28, 103.53],
-        pixel_std: List[float] = [58.395, 57.12, 57.375],
-    ) -> None:
-        """SAM predicts object masks from an image and input prompts. Borrowed
-        from https://github.com/facebookresearch/segment-anything.
-
-        Arguments:
-          image_encoder (ViTSAM): The backbone used to encode the
-            image into image embeddings that allow for efficient mask
-            prediction.
-          prompt_encoder (PromptEncoder): Encodes various types of input
-            prompts.
-          mask_decoder (MaskDecoder): Predicts masks from the image embeddings
-            and encoded prompts.
-          pixel_mean (list(float)): Mean values for normalizing pixels in the
-            input image.
-          pixel_std (list(float)): Std values for normalizing pixels in the
-            input image.
-        """
-        super().__init__()
-        self.image_encoder = MODELS.build(image_encoder_cfg)
-        self.prompt_encoder: PromptEncoder = MODELS.build(prompt_encoder_cfg)
-        self.mask_decoder: MaskDecoder = MODELS.build(mask_decoder_cfg)
-        self.register_buffer('pixel_mean',
-                             torch.Tensor(pixel_mean).view(-1, 1, 1), False)
-        self.register_buffer('pixel_std',
-                             torch.Tensor(pixel_std).view(-1, 1, 1), False)
-
-    @property
-    def device(self) -> Any:
-        return self.pixel_mean.device
-
-    @torch.no_grad()
-    def forward(
-        self,
-        batched_input: List[Dict[str, Any]],
-        multimask_output: bool,
-    ) -> List[Dict[str, torch.Tensor]]:
-        """Predicts masks end-to-end from provided images and prompts. If
-        prompts are not known in advance, using SamPredictor is recommended
-        over calling the model directly.
-
-        Borrowed from https://github.com/facebookresearch/segment-anything
-
-        Arguments:
-          batched_input (list(dict)): A list over input images, each a
-            dictionary with the following keys. A prompt key can be
-            excluded if it is not present.
-              'image': The image as a torch tensor in 3xHxW format,
-                already transformed for input to the model.
-              'original_size': (tuple(int, int)) The original size of
-                the image before transformation, as (H, W).
-              'point_coords': (torch.Tensor) Batched point prompts for
-                this image, with shape BxNx2. Already transformed to the
-                input frame of the model.
-              'point_labels': (torch.Tensor) Batched labels for point prompts,
-                with shape BxN.
-              'boxes': (torch.Tensor) Batched box inputs, with shape Bx4.
-                Already transformed to the input frame of the model.
-              'mask_inputs': (torch.Tensor) Batched mask inputs to the model,
-                in the form Bx1xHxW.
-          multimask_output (bool): Whether the model should predict multiple
-            disambiguating masks, or return a single mask.
-
-        Returns:
-          (list(dict)): A list over input images, where each element is
-            as dictionary with the following keys.
-              'masks': (torch.Tensor) Batched binary mask predictions,
-                with shape BxCxHxW, where B is the number of input prompts,
-                C is determiend by multimask_output, and (H, W) is the
-                original size of the image.
-              'iou_predictions': (torch.Tensor) The model's predictions
-                of mask quality, in shape BxC.
-              'low_res_logits': (torch.Tensor) Low resolution logits with
-                shape BxCxHxW, where H=W=256. Can be passed as mask input
-                to subsequent iterations of prediction.
-        """
-        input_images = torch.stack(
-            [self.preprocess(x['image']) for x in batched_input], dim=0)
-        image_embeddings = self.image_encoder(input_images)
-
-        outputs = []
-        for image_record, curr_embedding in zip(batched_input,
-                                                image_embeddings):
-            if 'point_coords' in image_record:
-                points = (image_record['point_coords'],
-                          image_record['point_labels'])
-            else:
-                points = None
-            sparse_embeddings, dense_embeddings = self.prompt_encoder(
-                points=points,
-                boxes=image_record.get('boxes', None),
-                masks=image_record.get('mask_inputs', None),
-            )
-            low_res_masks, iou_predictions = self.mask_decoder(
-                image_embeddings=curr_embedding.unsqueeze(0),
-                image_pe=self.prompt_encoder.get_dense_pe(),
-                sparse_prompt_embeddings=sparse_embeddings,
-                dense_prompt_embeddings=dense_embeddings,
-                multimask_output=multimask_output,
-            )
-            masks = self.postprocess_masks(
-                low_res_masks,
-                input_size=image_record['image'].shape[-2:],
-                original_size=image_record['original_size'],
-            )
-            masks = masks > self.mask_threshold
-            outputs.append({
-                'masks': masks,
-                'iou_predictions': iou_predictions,
-                'low_res_logits': low_res_masks,
-            })
-        return outputs
-
-    def postprocess_masks(
-        self,
-        masks: torch.Tensor,
-        input_size: Tuple[int, ...],
-        original_size: Tuple[int, ...],
-    ) -> torch.Tensor:
-        """Remove padding and upscale masks to the original image size.
-
-        Borrowed from https://github.com/facebookresearch/segment-anything
-
-        Arguments:
-          masks (torch.Tensor): Batched masks from the mask_decoder,
-            in BxCxHxW format.
-          input_size (tuple(int, int)): The size of the image input to the
-            model, in (H, W) format. Used to remove padding.
-          original_size (tuple(int, int)): The original size of the image
-            before resizing for input to the model, in (H, W) format.
-
-        Returns:
-          (torch.Tensor): Batched masks in BxCxHxW format, where (H, W)
-            is given by original_size.
-        """
-        masks = F.interpolate(
-            masks,
-            self.image_encoder.img_size,
-            mode='bilinear',
-            align_corners=False,
-        )
-        masks = masks[..., :input_size[0], :input_size[1]]
-        masks = F.interpolate(
-            masks, original_size, mode='bilinear', align_corners=False)
-        return masks
-
-    def preprocess(self, x: torch.Tensor) -> torch.Tensor:
-        """Normalize pixel values and pad to a square input."""
-        # Normalize colors
-        x = (x - self.pixel_mean) / self.pixel_std
-
-        # Pad
-        h, w = x.shape[-2:]
-        img_size = max(self.image_encoder.img_size)
-        padh = img_size - h
-        padw = img_size - w
-        x = F.pad(x, (0, padw, 0, padh))
-        return x
diff --git a/mmsegmentation/projects/sam_inference_demo/sam/modeling/transformer.py b/mmsegmentation/projects/sam_inference_demo/sam/modeling/transformer.py
deleted file mode 100644
index c56f602..0000000
--- a/mmsegmentation/projects/sam_inference_demo/sam/modeling/transformer.py
+++ /dev/null
@@ -1,241 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-import math
-from typing import Tuple, Type
-
-import torch
-from torch import Tensor, nn
-
-from mmseg.registry import MODELS
-from .common import MLPBlock
-
-
-@MODELS.register_module()
-class TwoWayTransformer(nn.Module):
-
-    def __init__(
-        self,
-        depth: int,
-        embedding_dim: int,
-        num_heads: int,
-        mlp_dim: int,
-        activation: Type[nn.Module] = nn.ReLU,
-        attention_downsample_rate: int = 2,
-    ) -> None:
-        """A transformer decoder that attends to an input image using queries
-        whose positional embedding is supplied.
-
-        Args:
-          depth (int): number of layers in the transformer
-          embedding_dim (int): the channel dimension for the input embeddings
-          num_heads (int): the number of heads for multihead attention. Must
-            divide embedding_dim
-          mlp_dim (int): the channel dimension internal to the MLP block
-          activation (nn.Module): the activation to use in the MLP block
-        """
-        super().__init__()
-        self.depth = depth
-        self.embedding_dim = embedding_dim
-        self.num_heads = num_heads
-        self.mlp_dim = mlp_dim
-        self.layers = nn.ModuleList()
-
-        for i in range(depth):
-            self.layers.append(
-                TwoWayAttentionBlock(
-                    embedding_dim=embedding_dim,
-                    num_heads=num_heads,
-                    mlp_dim=mlp_dim,
-                    activation=activation,
-                    attention_downsample_rate=attention_downsample_rate,
-                    skip_first_layer_pe=(i == 0),
-                ))
-
-        self.final_attn_token_to_image = Attention(
-            embedding_dim,
-            num_heads,
-            downsample_rate=attention_downsample_rate)
-        self.norm_final_attn = nn.LayerNorm(embedding_dim)
-
-    def forward(
-        self,
-        image_embedding: Tensor,
-        image_pe: Tensor,
-        point_embedding: Tensor,
-    ) -> Tuple[Tensor, Tensor]:
-        """
-        Args:
-          image_embedding (torch.Tensor): image to attend to. Should be shape
-            B x embedding_dim x h x w for any h and w.
-          image_pe (torch.Tensor): the positional encoding to add to the image. Must
-            have the same shape as image_embedding.
-          point_embedding (torch.Tensor): the embedding to add to the query points.
-            Must have shape B x N_points x embedding_dim for any N_points.
-
-        Returns:
-          torch.Tensor: the processed point_embedding
-          torch.Tensor: the processed image_embedding
-        """ # noqa E501
-        # BxCxHxW -> BxHWxC == B x N_image_tokens x C
-        bs, c, h, w = image_embedding.shape
-        image_embedding = image_embedding.flatten(2).permute(0, 2, 1)
-        image_pe = image_pe.flatten(2).permute(0, 2, 1)
-
-        # Prepare queries
-        queries = point_embedding
-        keys = image_embedding
-
-        # Apply transformer blocks and final layernorm
-        for layer in self.layers:
-            queries, keys = layer(
-                queries=queries,
-                keys=keys,
-                query_pe=point_embedding,
-                key_pe=image_pe,
-            )
-
-        # Apply the final attenion layer from the points to the image
-        q = queries + point_embedding
-        k = keys + image_pe
-        attn_out = self.final_attn_token_to_image(q=q, k=k, v=keys)
-        queries = queries + attn_out
-        queries = self.norm_final_attn(queries)
-
-        return queries, keys
-
-
-class TwoWayAttentionBlock(nn.Module):
-
-    def __init__(
-        self,
-        embedding_dim: int,
-        num_heads: int,
-        mlp_dim: int = 2048,
-        activation: Type[nn.Module] = nn.ReLU,
-        attention_downsample_rate: int = 2,
-        skip_first_layer_pe: bool = False,
-    ) -> None:
-        """A transformer block with four layers: (1) self-attention of sparse
-        inputs, (2) cross attention of sparse inputs to dense inputs, (3) mlp
-        block on sparse inputs, and (4) cross attention of dense inputs to
-        sparse inputs.
-
-        Arguments:
-          embedding_dim (int): the channel dimension of the embeddings
-          num_heads (int): the number of heads in the attention layers
-          mlp_dim (int): the hidden dimension of the mlp block
-          activation (nn.Module): the activation of the mlp block
-          skip_first_layer_pe (bool): skip the PE on the first layer
-        """
-        super().__init__()
-        self.self_attn = Attention(embedding_dim, num_heads)
-        self.norm1 = nn.LayerNorm(embedding_dim)
-
-        self.cross_attn_token_to_image = Attention(
-            embedding_dim,
-            num_heads,
-            downsample_rate=attention_downsample_rate)
-        self.norm2 = nn.LayerNorm(embedding_dim)
-
-        self.mlp = MLPBlock(embedding_dim, mlp_dim, activation)
-        self.norm3 = nn.LayerNorm(embedding_dim)
-
-        self.norm4 = nn.LayerNorm(embedding_dim)
-        self.cross_attn_image_to_token = Attention(
-            embedding_dim,
-            num_heads,
-            downsample_rate=attention_downsample_rate)
-
-        self.skip_first_layer_pe = skip_first_layer_pe
-
-    def forward(self, queries: Tensor, keys: Tensor, query_pe: Tensor,
-                key_pe: Tensor) -> Tuple[Tensor, Tensor]:
-        # Self attention block
-        if self.skip_first_layer_pe:
-            queries = self.self_attn(q=queries, k=queries, v=queries)
-        else:
-            q = queries + query_pe
-            attn_out = self.self_attn(q=q, k=q, v=queries)
-            queries = queries + attn_out
-        queries = self.norm1(queries)
-
-        # Cross attention block, tokens attending to image embedding
-        q = queries + query_pe
-        k = keys + key_pe
-        attn_out = self.cross_attn_token_to_image(q=q, k=k, v=keys)
-        queries = queries + attn_out
-        queries = self.norm2(queries)
-
-        # MLP block
-        mlp_out = self.mlp(queries)
-        queries = queries + mlp_out
-        queries = self.norm3(queries)
-
-        # Cross attention block, image embedding attending to tokens
-        q = queries + query_pe
-        k = keys + key_pe
-        attn_out = self.cross_attn_image_to_token(q=k, k=q, v=queries)
-        keys = keys + attn_out
-        keys = self.norm4(keys)
-
-        return queries, keys
-
-
-class Attention(nn.Module):
-    """An attention layer that allows for downscaling the size of the embedding
-    after projection to queries, keys, and values."""
-
-    def __init__(
-        self,
-        embedding_dim: int,
-        num_heads: int,
-        downsample_rate: int = 1,
-    ) -> None:
-        super().__init__()
-        self.embedding_dim = embedding_dim
-        self.internal_dim = embedding_dim // downsample_rate
-        self.num_heads = num_heads
-        assert self.internal_dim % num_heads == 0, 'num_heads must divide embedding_dim.'  # noqa E501
-
-        self.q_proj = nn.Linear(embedding_dim, self.internal_dim)
-        self.k_proj = nn.Linear(embedding_dim, self.internal_dim)
-        self.v_proj = nn.Linear(embedding_dim, self.internal_dim)
-        self.out_proj = nn.Linear(self.internal_dim, embedding_dim)
-
-    def _separate_heads(self, x: Tensor, num_heads: int) -> Tensor:
-        b, n, c = x.shape
-        x = x.reshape(b, n, num_heads, c // num_heads)
-        return x.transpose(1, 2)  # B x N_heads x N_tokens x C_per_head
-
-    def _recombine_heads(self, x: Tensor) -> Tensor:
-        b, n_heads, n_tokens, c_per_head = x.shape
-        x = x.transpose(1, 2)
-        return x.reshape(b, n_tokens, n_heads * c_per_head)  # B x N_tokens x C
-
-    def forward(self, q: Tensor, k: Tensor, v: Tensor) -> Tensor:
-        # Input projections
-        q = self.q_proj(q)
-        k = self.k_proj(k)
-        v = self.v_proj(v)
-
-        # Separate into heads
-        q = self._separate_heads(q, self.num_heads)
-        k = self._separate_heads(k, self.num_heads)
-        v = self._separate_heads(v, self.num_heads)
-
-        # Attention
-        _, _, _, c_per_head = q.shape
-        attn = q @ k.permute(0, 1, 3, 2)  # B x N_heads x N_tokens x N_tokens
-        attn = attn / math.sqrt(c_per_head)
-        attn = torch.softmax(attn, dim=-1)
-
-        # Get output
-        out = attn @ v
-        out = self._recombine_heads(out)
-        out = self.out_proj(out)
-
-        return out
diff --git a/mmsegmentation/projects/sam_inference_demo/sam/sam_inferencer.py b/mmsegmentation/projects/sam_inference_demo/sam/sam_inferencer.py
deleted file mode 100644
index 2da2e95..0000000
--- a/mmsegmentation/projects/sam_inference_demo/sam/sam_inferencer.py
+++ /dev/null
@@ -1,688 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from typing import Any, Dict, List, Optional, Tuple
-
-import numpy as np
-import torch
-from mmengine.runner.checkpoint import load_checkpoint
-# yapf: disable
-from sam.utils import (MaskData, area_from_rle, batch_iterator,
-                       batched_mask_to_box, box_xyxy_to_xywh,
-                       build_all_layer_point_grids, calculate_stability_score,
-                       coco_encode_rle, generate_crop_boxes,
-                       is_box_near_crop_edge, mask_to_rle_pytorch,
-                       remove_small_regions, rle_to_mask, uncrop_boxes_xyxy,
-                       uncrop_masks, uncrop_points)
-from torchvision.ops.boxes import batched_nms, box_area
-
-from mmseg.registry import MODELS, TRANSFORMS
-
-# yapf: enable
-
-model_zoo = {
-    'base':
-    'https://download.openmmlab.com/mmsegmentation/v0.5/sam/sam_vit-base-p16_3rdparty_sa1b-1024x1024_20230413-78a25eed.pth',  # noqa
-    'large':
-    'https://download.openmmlab.com/mmsegmentation/v0.5/sam/sam_vit-large-p16_3rdparty_sa1b-1024x1024_20230413-940520da.pth',  # noqa
-    'huge':
-    'https://download.openmmlab.com/mmsegmentation/v0.5/sam/sam_vit-huge-p16_3rdparty_sa1b-1024x1024_20230413-faaf96f6.pth',  # noqa
-}
-
-
-class SAMInferencer:
-
-    def __init__(self, arch: str = 'base') -> None:
-        assert arch in ['base', 'large', 'huge']
-        self.model = self.init_model(arch)
-        self.transform = TRANSFORMS.build(
-            dict(
-                type='ResizeLongestSide',
-                target_length=max(self.model.image_encoder.img_size)))
-
-    def set_image(
-        self,
-        image: np.ndarray,
-        image_format: str = 'RGB',
-    ) -> None:
-        """Calculates the image embeddings for the provided image, allowing
-        masks to be predicted with the 'predict' method.
-
-        Arguments:
-          image (np.ndarray): The image for calculating masks. Expects an
-            image in HWC uint8 format, with pixel values in [0, 255].
-          image_format (str): The color format of the image, in ['RGB', 'BGR'].
-        """
-        assert image_format in [
-            'RGB',
-            'BGR',
-        ], f"image_format must be in ['RGB', 'BGR'], is {image_format}."
-        if image_format != self.model.image_format:
-            image = image[..., ::-1]
-
-        # Transform the image to the form expected by the model
-        input_image = self.transform.apply_image(image)
-        input_image_torch = torch.as_tensor(input_image, device=self.device)
-        input_image_torch = input_image_torch.permute(
-            2, 0, 1).contiguous()[None, :, :, :]
-
-        self.set_torch_image(input_image_torch, image.shape[:2])
-
-    @torch.no_grad()
-    def set_torch_image(
-        self,
-        transformed_image: torch.Tensor,
-        original_image_size: Tuple[int, ...],
-    ) -> None:
-        """Calculates the image embeddings for the provided image, allowing
-        masks to be predicted with the 'predict' method. Expects the input
-        image to be already transformed to the format expected by the model.
-
-        Arguments:
-          transformed_image (torch.Tensor): The input image, with shape
-            1x3xHxW, which has been transformed with ResizeLongestSide.
-          original_image_size (tuple(int, int)): The size of the image
-            before transformation, in (H, W) format.
-        """
-        assert (len(transformed_image.shape) == 4
-                and transformed_image.shape[1] == 3
-                and max(*transformed_image.shape[2:]) == max(
-                    self.model.image_encoder.img_size)
-                ), 'set_torch_image input must be BCHW with long side'
-        f' {self.model.image_encoder.img_size}.'
-        self.reset_image()
-
-        self.original_size = original_image_size
-        self.input_size = tuple(transformed_image.shape[-2:])
-        input_image = self.model.preprocess(transformed_image)
-        self.features = self.model.image_encoder(input_image)[0]
-        self.is_image_set = True
-
-    def predict(
-        self,
-        point_coords: Optional[np.ndarray] = None,
-        point_labels: Optional[np.ndarray] = None,
-        box: Optional[np.ndarray] = None,
-        mask_input: Optional[np.ndarray] = None,
-        multimask_output: bool = True,
-        return_logits: bool = False,
-    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
-        """Predict masks for the given input prompts, using the currently set
-        image.
-
-        Arguments:
-          point_coords (np.ndarray or None): A Nx2 array of point prompts to the
-            model. Each point is in (X,Y) in pixels.
-          point_labels (np.ndarray or None): A length N array of labels for the
-            point prompts. 1 indicates a foreground point and 0 indicates a
-            background point.
-          box (np.ndarray or None): A length 4 array given a box prompt to the
-            model, in XYXY format.
-          mask_input (np.ndarray): A low resolution mask input to the model, typically
-            coming from a previous prediction iteration. Has form 1xHxW, where
-            for SAM, H=W=256.
-          multimask_output (bool): If true, the model will return three masks.
-            For ambiguous input prompts (such as a single click), this will often
-            produce better masks than a single prediction. If only a single
-            mask is needed, the model's predicted quality score can be used
-            to select the best mask. For non-ambiguous prompts, such as multiple
-            input prompts, multimask_output=False can give better results.
-          return_logits (bool): If true, returns un-thresholded masks logits
-            instead of a binary mask.
-
-        Returns:
-          (np.ndarray): The output masks in CxHxW format, where C is the
-            number of masks, and (H, W) is the original image size.
-          (np.ndarray): An array of length C containing the model's
-            predictions for the quality of each mask.
-          (np.ndarray): An array of shape CxHxW, where C is the number
-            of masks and H=W=256. These low resolution logits can be passed to
-            a subsequent iteration as mask input.
-        """ # noqa
-        if not self.is_image_set:
-            raise RuntimeError(
-                'An image must be set with .set_image(...) before mask'
-                'prediction.')
-
-        # Transform input prompts
-        coords_torch = None
-        labels_torch = None
-        box_torch = None
-        mask_input_torch = None
-
-        if point_coords is not None:
-            assert (
-                point_labels is not None
-            ), 'point_labels must be supplied if point_coords is supplied.'
-            point_coords = self.transform.apply_coords(point_coords,
-                                                       self.original_size)
-            coords_torch = torch.as_tensor(
-                point_coords, dtype=torch.float, device=self.device)
-            labels_torch = torch.as_tensor(
-                point_labels, dtype=torch.int, device=self.device)
-            coords_torch, labels_torch = coords_torch[
-                None, :, :], labels_torch[None, :]
-        if box is not None:
-            box = self.transform.apply_boxes(box, self.original_size)
-            box_torch = torch.as_tensor(
-                box, dtype=torch.float, device=self.device)
-            box_torch = box_torch[None, :]
-        if mask_input is not None:
-            mask_input_torch = torch.as_tensor(
-                mask_input, dtype=torch.float, device=self.device)
-            mask_input_torch = mask_input_torch[None, :, :, :]
-
-        masks, iou_predictions, low_res_masks = self.predict_torch(
-            coords_torch,
-            labels_torch,
-            box_torch,
-            mask_input_torch,
-            multimask_output,
-            return_logits=return_logits,
-        )
-
-        masks = masks[0].detach().cpu().numpy()
-        iou_predictions = iou_predictions[0].detach().cpu().numpy()
-        low_res_masks = low_res_masks[0].detach().cpu().numpy()
-        return masks, iou_predictions, low_res_masks
-
-    @torch.no_grad()
-    def predict_torch(
-        self,
-        point_coords: Optional[torch.Tensor],
-        point_labels: Optional[torch.Tensor],
-        boxes: Optional[torch.Tensor] = None,
-        mask_input: Optional[torch.Tensor] = None,
-        multimask_output: bool = True,
-        return_logits: bool = False,
-    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
-        """Predict masks for the given input prompts, using the currently set
-        image. Input prompts are batched torch tensors and are expected to
-        already be transformed to the input frame using ResizeLongestSide.
-
-        Arguments:
-          point_coords (torch.Tensor or None): A BxNx2 array of point prompts to the
-            model. Each point is in (X,Y) in pixels.
-          point_labels (torch.Tensor or None): A BxN array of labels for the
-            point prompts. 1 indicates a foreground point and 0 indicates a
-            background point.
-          box (np.ndarray or None): A Bx4 array given a box prompt to the
-            model, in XYXY format.
-          mask_input (np.ndarray): A low resolution mask input to the model, typically
-            coming from a previous prediction iteration. Has form Bx1xHxW, where
-            for SAM, H=W=256. Masks returned by a previous iteration of the
-            predict method do not need further transformation.
-          multimask_output (bool): If true, the model will return three masks.
-            For ambiguous input prompts (such as a single click), this will often
-            produce better masks than a single prediction. If only a single
-            mask is needed, the model's predicted quality score can be used
-            to select the best mask. For non-ambiguous prompts, such as multiple
-            input prompts, multimask_output=False can give better results.
-          return_logits (bool): If true, returns un-thresholded masks logits
-            instead of a binary mask.
-
-        Returns:
-          (torch.Tensor): The output masks in BxCxHxW format, where C is the
-            number of masks, and (H, W) is the original image size.
-          (torch.Tensor): An array of shape BxC containing the model's
-            predictions for the quality of each mask.
-          (torch.Tensor): An array of shape BxCxHxW, where C is the number
-            of masks and H=W=256. These low res logits can be passed to
-            a subsequent iteration as mask input.
-        """ # noqa
-        if not self.is_image_set:
-            raise RuntimeError(
-                'An image must be set with .set_image(...) before mask '
-                'prediction.')
-
-        if point_coords is not None:
-            points = (point_coords, point_labels)
-        else:
-            points = None
-
-        # Embed prompts
-        sparse_embeddings, dense_embeddings = self.model.prompt_encoder(
-            points=points,
-            boxes=boxes,
-            masks=mask_input,
-        )
-
-        # Predict masks
-        low_res_masks, iou_predictions = self.model.mask_decoder(
-            image_embeddings=self.features,
-            image_pe=self.model.prompt_encoder.get_dense_pe(),
-            sparse_prompt_embeddings=sparse_embeddings,
-            dense_prompt_embeddings=dense_embeddings,
-            multimask_output=multimask_output,
-        )
-
-        # Upscale the masks to the original image resolution
-        masks = self.model.postprocess_masks(low_res_masks, self.input_size,
-                                             self.original_size)
-
-        if not return_logits:
-            masks = masks > self.model.mask_threshold
-
-        return masks, iou_predictions, low_res_masks
-
-    def get_image_embedding(self) -> torch.Tensor:
-        """Returns the image embeddings for the currently set image, with shape
-        1xCxHxW, where C is the embedding dimension and (H,W) are the embedding
-        spatial dimension of SAM (typically C=256, H=W=64)."""
-        if not self.is_image_set:
-            raise RuntimeError(
-                'An image must be set with .set_image(...) to generate an '
-                'embedding.')
-        assert self.features is not None, 'Features must exist if an image has'
-        ' been set.'
-        return self.features
-
-    @property
-    def device(self) -> torch.device:
-        return self.model.device
-
-    def reset_image(self) -> None:
-        """Resets the currently set image."""
-        self.is_image_set = False
-        self.features = None
-        self.orig_h = None
-        self.orig_w = None
-        self.input_h = None
-        self.input_w = None
-
-    def init_model(self, arch: str):
-        model = MODELS.build(
-            dict(
-                type='SAM',
-                image_encoder_cfg=dict(
-                    type='mmpretrain.ViTSAM',
-                    arch=arch,
-                    img_size=1024,
-                    patch_size=16,
-                    out_channels=256,
-                    use_abs_pos=True,
-                    use_rel_pos=True,
-                    window_size=14,
-                ),
-                prompt_encoder_cfg=dict(
-                    type='PromptEncoder',
-                    embed_dim=256,
-                    image_embedding_size=(64, 64),
-                    input_image_size=(1024, 1024),
-                    mask_in_chans=16,
-                ),
-                mask_decoder_cfg=dict(
-                    type='MaskDecoder',
-                    num_multimask_outputs=3,
-                    transformer=dict(
-                        type='TwoWayTransformer',
-                        depth=2,
-                        embedding_dim=256,
-                        mlp_dim=2048,
-                        num_heads=8,
-                    ),
-                    transformer_dim=256,
-                    iou_head_depth=3,
-                    iou_head_hidden_dim=256,
-                )))
-        load_checkpoint(model, model_zoo.get(arch), strict=True)
-        if torch.cuda.is_available():
-            model = model.cuda()
-        return model
-
-
-class SamAutomaticMaskGenerator:
-
-    def __init__(
-        self,
-        arch: str = 'base',
-        points_per_side: Optional[int] = 32,
-        points_per_batch: int = 64,
-        pred_iou_thresh: float = 0.88,
-        stability_score_thresh: float = 0.95,
-        stability_score_offset: float = 1.0,
-        box_nms_thresh: float = 0.7,
-        crop_n_layers: int = 0,
-        crop_nms_thresh: float = 0.7,
-        crop_overlap_ratio: float = 512 / 1500,
-        crop_n_points_downscale_factor: int = 1,
-        point_grids: Optional[List[np.ndarray]] = None,
-        min_mask_region_area: int = 0,
-        output_mode: str = 'binary_mask',
-    ) -> None:
-        """Using a SAM model, generates masks for the entire image. Generates a
-        grid of point prompts over the image, then filters low quality and
-        duplicate masks. The default settings are chosen for SAM with a ViT-H
-        backbone.
-
-        Arguments:
-          arch (str): The SAM model to use for mask prediction.
-          points_per_side (int or None): The number of points to be sampled
-            along one side of the image. The total number of points is
-            points_per_side**2. If None, 'point_grids' must provide explicit
-            point sampling.
-          points_per_batch (int): Sets the number of points run simultaneously
-            by the model. Higher numbers may be faster but use more GPU memory.
-          pred_iou_thresh (float): A filtering threshold in [0,1], using the
-            model's predicted mask quality.
-          stability_score_thresh (float): A filtering threshold in [0,1], using
-            the stability of the mask under changes to the cutoff used to binarize
-            the model's mask predictions.
-          stability_score_offset (float): The amount to shift the cutoff when
-            calculated the stability score.
-          box_nms_thresh (float): The box IoU cutoff used by non-maximal
-            suppression to filter duplicate masks.
-          crops_n_layers (int): If >0, mask prediction will be run again on
-            crops of the image. Sets the number of layers to run, where each
-            layer has 2**i_layer number of image crops.
-          crops_nms_thresh (float): The box IoU cutoff used by non-maximal
-            suppression to filter duplicate masks between different crops.
-          crop_overlap_ratio (float): Sets the degree to which crops overlap.
-            In the first crop layer, crops will overlap by this fraction of
-            the image length. Later layers with more crops scale down this overlap.
-          crop_n_points_downscale_factor (int): The number of points-per-side
-            sampled in layer n is scaled down by crop_n_points_downscale_factor**n.
-          point_grids (list(np.ndarray) or None): A list over explicit grids
-            of points used for sampling, normalized to [0,1]. The nth grid in the
-            list is used in the nth crop layer. Exclusive with points_per_side.
-          min_mask_region_area (int): If >0, postprocessing will be applied
-            to remove disconnected regions and holes in masks with area smaller
-            than min_mask_region_area. Requires opencv.
-          output_mode (str): The form masks are returned in. Can be 'binary_mask',
-            'uncompressed_rle', or 'coco_rle'. 'coco_rle' requires pycocotools.
-            For large resolutions, 'binary_mask' may consume large amounts of
-            memory.
-        """ # noqa
-
-        assert (points_per_side is None) != (
-            point_grids is None
-        ), 'Exactly one of points_per_side or point_grid must be provided.'
-        if points_per_side is not None:
-            self.point_grids = build_all_layer_point_grids(
-                points_per_side,
-                crop_n_layers,
-                crop_n_points_downscale_factor,
-            )
-        elif point_grids is not None:
-            self.point_grids = point_grids
-        else:
-            raise ValueError(
-                "Can't have both points_per_side and point_grid be None.")
-
-        assert output_mode in [
-            'binary_mask',
-            'uncompressed_rle',
-            'coco_rle',
-        ], f'Unknown output_mode {output_mode}.'
-        if output_mode == 'coco_rle':
-            from pycocotools import \
-                mask as mask_utils  # type: ignore # noqa: F401
-
-        if min_mask_region_area > 0:
-            import cv2  # type: ignore # noqa: F401
-
-        self.predictor = SAMInferencer(arch)
-        self.points_per_batch = points_per_batch
-        self.pred_iou_thresh = pred_iou_thresh
-        self.stability_score_thresh = stability_score_thresh
-        self.stability_score_offset = stability_score_offset
-        self.box_nms_thresh = box_nms_thresh
-        self.crop_n_layers = crop_n_layers
-        self.crop_nms_thresh = crop_nms_thresh
-        self.crop_overlap_ratio = crop_overlap_ratio
-        self.crop_n_points_downscale_factor = crop_n_points_downscale_factor
-        self.min_mask_region_area = min_mask_region_area
-        self.output_mode = output_mode
-
-    @torch.no_grad()
-    def generate(self, image: np.ndarray) -> List[Dict[str, Any]]:
-        """Generates masks for the given image.
-
-        Arguments:
-          image (np.ndarray): The image to generate masks for, in HWC uint8 format.
-
-        Returns:
-           list(dict(str, any)): A list over records for masks. Each record is
-             a dict containing the following keys:
-               segmentation (dict(str, any) or np.ndarray): The mask. If
-                 output_mode='binary_mask', is an array of shape HW. Otherwise,
-                 is a dictionary containing the RLE.
-               bbox (list(float)): The box around the mask, in XYWH format.
-               area (int): The area in pixels of the mask.
-               predicted_iou (float): The model's own prediction of the mask's
-                 quality. This is filtered by the pred_iou_thresh parameter.
-               point_coords (list(list(float))): The point coordinates input
-                 to the model to generate this mask.
-               stability_score (float): A measure of the mask's quality. This
-                 is filtered on using the stability_score_thresh parameter.
-               crop_box (list(float)): The crop of the image used to generate
-                 the mask, given in XYWH format.
-        """ # noqa
-
-        # Generate masks
-        mask_data = self._generate_masks(image)
-
-        # Filter small disconnected regions and holes in masks
-        if self.min_mask_region_area > 0:
-            mask_data = self.postprocess_small_regions(
-                mask_data,
-                self.min_mask_region_area,
-                max(self.box_nms_thresh, self.crop_nms_thresh),
-            )
-
-        # Encode masks
-        if self.output_mode == 'coco_rle':
-            mask_data['segmentations'] = [
-                coco_encode_rle(rle) for rle in mask_data['rles']
-            ]
-        elif self.output_mode == 'binary_mask':
-            mask_data['segmentations'] = [
-                rle_to_mask(rle) for rle in mask_data['rles']
-            ]
-        else:
-            mask_data['segmentations'] = mask_data['rles']
-
-        # Write mask records
-        curr_anns = []
-        for idx in range(len(mask_data['segmentations'])):
-            ann = {
-                'segmentation':
-                mask_data['segmentations'][idx],
-                'area':
-                area_from_rle(mask_data['rles'][idx]),
-                'bbox':
-                box_xyxy_to_xywh(mask_data['boxes'][idx]).tolist(),
-                'predicted_iou':
-                mask_data['iou_preds'][idx].item(),
-                'point_coords': [mask_data['points'][idx].tolist()],
-                'stability_score':
-                mask_data['stability_score'][idx].item(),
-                'crop_box':
-                box_xyxy_to_xywh(mask_data['crop_boxes'][idx]).tolist(),
-            }
-            curr_anns.append(ann)
-
-        return curr_anns
-
-    def _generate_masks(self, image: np.ndarray) -> MaskData:
-        orig_size = image.shape[:2]
-        crop_boxes, layer_idxs = generate_crop_boxes(orig_size,
-                                                     self.crop_n_layers,
-                                                     self.crop_overlap_ratio)
-
-        # Iterate over image crops
-        data = MaskData()
-        for crop_box, layer_idx in zip(crop_boxes, layer_idxs):
-            crop_data = self._process_crop(image, crop_box, layer_idx,
-                                           orig_size)
-            data.cat(crop_data)
-
-        # Remove duplicate masks between crops
-        if len(crop_boxes) > 1:
-            # Prefer masks from smaller crops
-            scores = 1 / box_area(data['crop_boxes'])
-            scores = scores.to(data['boxes'].device)
-            keep_by_nms = batched_nms(
-                data['boxes'].float(),
-                scores,
-                torch.zeros(len(data['boxes'])),  # categories
-                iou_threshold=self.crop_nms_thresh,
-            )
-            data.filter(keep_by_nms)
-
-        data.to_numpy()
-        return data
-
-    def _process_crop(
-        self,
-        image: np.ndarray,
-        crop_box: List[int],
-        crop_layer_idx: int,
-        orig_size: Tuple[int, ...],
-    ) -> MaskData:
-        # Crop the image and calculate embeddings
-        x0, y0, x1, y1 = crop_box
-        cropped_im = image[y0:y1, x0:x1, :]
-        cropped_im_size = cropped_im.shape[:2]
-        self.predictor.set_image(cropped_im)
-
-        # Get points for this crop
-        points_scale = np.array(cropped_im_size)[None, ::-1]
-        points_for_image = self.point_grids[crop_layer_idx] * points_scale
-
-        # Generate masks for this crop in batches
-        data = MaskData()
-        for (points, ) in batch_iterator(self.points_per_batch,
-                                         points_for_image):
-            batch_data = self._process_batch(points, cropped_im_size, crop_box,
-                                             orig_size)
-            data.cat(batch_data)
-            del batch_data
-        self.predictor.reset_image()
-
-        # Remove duplicates within this crop.
-        keep_by_nms = batched_nms(
-            data['boxes'].float(),
-            data['iou_preds'],
-            torch.zeros(len(data['boxes'])),  # categories
-            iou_threshold=self.box_nms_thresh,
-        )
-        data.filter(keep_by_nms)
-
-        # Return to the original image frame
-        data['boxes'] = uncrop_boxes_xyxy(data['boxes'], crop_box)
-        data['points'] = uncrop_points(data['points'], crop_box)
-        data['crop_boxes'] = torch.tensor(
-            [crop_box for _ in range(len(data['rles']))])
-
-        return data
-
-    def _process_batch(
-        self,
-        points: np.ndarray,
-        im_size: Tuple[int, ...],
-        crop_box: List[int],
-        orig_size: Tuple[int, ...],
-    ) -> MaskData:
-        orig_h, orig_w = orig_size
-
-        # Run model on this batch
-        transformed_points = self.predictor.transform.apply_coords(
-            points, im_size)
-        in_points = torch.as_tensor(
-            transformed_points, device=self.predictor.device)
-        in_labels = torch.ones(
-            in_points.shape[0], dtype=torch.int, device=in_points.device)
-        masks, iou_preds, _ = self.predictor.predict_torch(
-            in_points[:, None, :],
-            in_labels[:, None],
-            multimask_output=True,
-            return_logits=True,
-        )
-
-        # Serialize predictions and store in MaskData
-        data = MaskData(
-            masks=masks.flatten(0, 1),
-            iou_preds=iou_preds.flatten(0, 1),
-            points=torch.as_tensor(points.repeat(masks.shape[1], axis=0)),
-        )
-        del masks
-
-        # Filter by predicted IoU
-        if self.pred_iou_thresh > 0.0:
-            keep_mask = data['iou_preds'] > self.pred_iou_thresh
-            data.filter(keep_mask)
-
-        # Calculate stability score
-        data['stability_score'] = calculate_stability_score(
-            data['masks'], self.predictor.model.mask_threshold,
-            self.stability_score_offset)
-        if self.stability_score_thresh > 0.0:
-            keep_mask = data['stability_score'] >= self.stability_score_thresh
-            data.filter(keep_mask)
-
-        # Threshold masks and calculate boxes
-        data['masks'] = data['masks'] > self.predictor.model.mask_threshold
-        data['boxes'] = batched_mask_to_box(data['masks'])
-
-        # Filter boxes that touch crop boundaries
-        keep_mask = ~is_box_near_crop_edge(data['boxes'], crop_box,
-                                           [0, 0, orig_w, orig_h])
-        if not torch.all(keep_mask):
-            data.filter(keep_mask)
-
-        # Compress to RLE
-        data['masks'] = uncrop_masks(data['masks'], crop_box, orig_h, orig_w)
-        data['rles'] = mask_to_rle_pytorch(data['masks'])
-        del data['masks']
-
-        return data
-
-    @staticmethod
-    def postprocess_small_regions(mask_data: MaskData, min_area: int,
-                                  nms_thresh: float) -> MaskData:
-        """Removes small disconnected regions and holes in masks, then reruns
-        box NMS to remove any new duplicates.
-
-        Edits mask_data in place.
-
-        Requires open-cv as a dependency.
-        """
-        if len(mask_data['rles']) == 0:
-            return mask_data
-
-        # Filter small disconnected regions and holes
-        new_masks = []
-        scores = []
-        for rle in mask_data['rles']:
-            mask = rle_to_mask(rle)
-
-            mask, changed = remove_small_regions(mask, min_area, mode='holes')
-            unchanged = not changed
-            mask, changed = remove_small_regions(
-                mask, min_area, mode='islands')
-            unchanged = unchanged and not changed
-
-            new_masks.append(torch.as_tensor(mask).unsqueeze(0))
-            # Give score=0 to changed masks and score=1 to unchanged masks
-            # so NMS will prefer ones that didn't need postprocessing
-            scores.append(float(unchanged))
-
-        # Recalculate boxes and remove any new duplicates
-        masks = torch.cat(new_masks, dim=0)
-        boxes = batched_mask_to_box(masks)
-        keep_by_nms = batched_nms(
-            boxes.float(),
-            torch.as_tensor(scores),
-            torch.zeros(len(boxes)),  # categories
-            iou_threshold=nms_thresh,
-        )
-
-        # Only recalculate RLEs for masks that have changed
-        for i_mask in keep_by_nms:
-            if scores[i_mask] == 0.0:
-                mask_torch = masks[i_mask].unsqueeze(0)
-                mask_data['rles'][i_mask] = mask_to_rle_pytorch(mask_torch)[0]
-                mask_data['boxes'][i_mask] = boxes[
-                    i_mask]  # update res directly
-        mask_data.filter(keep_by_nms)
-
-        return mask_data
diff --git a/mmsegmentation/projects/sam_inference_demo/sam/utils/__init__.py b/mmsegmentation/projects/sam_inference_demo/sam/utils/__init__.py
deleted file mode 100644
index 5d33e33..0000000
--- a/mmsegmentation/projects/sam_inference_demo/sam/utils/__init__.py
+++ /dev/null
@@ -1,2 +0,0 @@
-from .amg import *  # noqa: F403 F401
-from .transforms import ResizeLongestSide  # noqa: F403 F401
diff --git a/mmsegmentation/projects/sam_inference_demo/sam/utils/amg.py b/mmsegmentation/projects/sam_inference_demo/sam/utils/amg.py
deleted file mode 100644
index 3ba3599..0000000
--- a/mmsegmentation/projects/sam_inference_demo/sam/utils/amg.py
+++ /dev/null
@@ -1,355 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-# https://github.com/facebookresearch/segment-anything
-
-import math
-from copy import deepcopy
-from itertools import product
-from typing import Any, Dict, Generator, ItemsView, List, Tuple
-
-import numpy as np
-import torch
-
-
-class MaskData:
-    """A structure for storing masks and their related data in batched format.
-
-    Implements basic filtering and concatenation.
-    """
-
-    def __init__(self, **kwargs) -> None:
-        for v in kwargs.values():
-            assert isinstance(
-                v, (list, np.ndarray, torch.Tensor)
-            ), 'MaskData only supports list, numpy arrays, and torch tensors.'
-        self._stats = dict(**kwargs)
-
-    def __setitem__(self, key: str, item: Any) -> None:
-        assert isinstance(
-            item, (list, np.ndarray, torch.Tensor)
-        ), 'MaskData only supports list, numpy arrays, and torch tensors.'
-        self._stats[key] = item
-
-    def __delitem__(self, key: str) -> None:
-        del self._stats[key]
-
-    def __getitem__(self, key: str) -> Any:
-        return self._stats[key]
-
-    def items(self) -> ItemsView[str, Any]:
-        return self._stats.items()
-
-    def filter(self, keep: torch.Tensor) -> None:
-        for k, v in self._stats.items():
-            if v is None:
-                self._stats[k] = None
-            elif isinstance(v, torch.Tensor):
-                self._stats[k] = v[torch.as_tensor(keep, device=v.device)]
-            elif isinstance(v, np.ndarray):
-                self._stats[k] = v[keep.detach().cpu().numpy()]
-            elif isinstance(v, list) and keep.dtype == torch.bool:
-                self._stats[k] = [a for i, a in enumerate(v) if keep[i]]
-            elif isinstance(v, list):
-                self._stats[k] = [v[i] for i in keep]
-            else:
-                raise TypeError(
-                    f'MaskData key {k} has an unsupported type {type(v)}.')
-
-    def cat(self, new_stats: 'MaskData') -> None:
-        for k, v in new_stats.items():
-            if k not in self._stats or self._stats[k] is None:
-                self._stats[k] = deepcopy(v)
-            elif isinstance(v, torch.Tensor):
-                self._stats[k] = torch.cat([self._stats[k], v], dim=0)
-            elif isinstance(v, np.ndarray):
-                self._stats[k] = np.concatenate([self._stats[k], v], axis=0)
-            elif isinstance(v, list):
-                self._stats[k] = self._stats[k] + deepcopy(v)
-            else:
-                raise TypeError(
-                    f'MaskData key {k} has an unsupported type {type(v)}.')
-
-    def to_numpy(self) -> None:
-        for k, v in self._stats.items():
-            if isinstance(v, torch.Tensor):
-                self._stats[k] = v.detach().cpu().numpy()
-
-
-def is_box_near_crop_edge(boxes: torch.Tensor,
-                          crop_box: List[int],
-                          orig_box: List[int],
-                          atol: float = 20.0) -> torch.Tensor:
-    """Filter masks at the edge of a crop, but not at the edge of the original
-    image."""
-    crop_box_torch = torch.as_tensor(
-        crop_box, dtype=torch.float, device=boxes.device)
-    orig_box_torch = torch.as_tensor(
-        orig_box, dtype=torch.float, device=boxes.device)
-    boxes = uncrop_boxes_xyxy(boxes, crop_box).float()
-    near_crop_edge = torch.isclose(
-        boxes, crop_box_torch[None, :], atol=atol, rtol=0)
-    near_image_edge = torch.isclose(
-        boxes, orig_box_torch[None, :], atol=atol, rtol=0)
-    near_crop_edge = torch.logical_and(near_crop_edge, ~near_image_edge)
-    return torch.any(near_crop_edge, dim=1)
-
-
-def box_xyxy_to_xywh(box_xyxy: torch.Tensor) -> torch.Tensor:
-    box_xywh = deepcopy(box_xyxy)
-    box_xywh[2] = box_xywh[2] - box_xywh[0]
-    box_xywh[3] = box_xywh[3] - box_xywh[1]
-    return box_xywh
-
-
-def batch_iterator(batch_size: int, *args) -> Generator[List[Any], None, None]:
-    assert len(args) > 0 and all(
-        len(a) == len(args[0]) for a in
-        args), 'Batched iteration must have inputs of all the same size.'
-    n_batches = len(args[0]) // batch_size + int(
-        len(args[0]) % batch_size != 0)
-    for b in range(n_batches):
-        yield [arg[b * batch_size:(b + 1) * batch_size] for arg in args]
-
-
-def mask_to_rle_pytorch(tensor: torch.Tensor) -> List[Dict[str, Any]]:
-    """Encodes masks to an uncompressed RLE, in the format expected by pycoco
-    tools."""
-    # Put in fortran order and flatten h,w
-    b, h, w = tensor.shape
-    tensor = tensor.permute(0, 2, 1).flatten(1)
-
-    # Compute change indices
-    diff = tensor[:, 1:] ^ tensor[:, :-1]
-    change_indices = diff.nonzero()
-
-    # Encode run length
-    out = []
-    for i in range(b):
-        cur_idxs = change_indices[change_indices[:, 0] == i, 1]
-        cur_idxs = torch.cat([
-            torch.tensor([0], dtype=cur_idxs.dtype, device=cur_idxs.device),
-            cur_idxs + 1,
-            torch.tensor([h * w], dtype=cur_idxs.dtype,
-                         device=cur_idxs.device),
-        ])
-        btw_idxs = cur_idxs[1:] - cur_idxs[:-1]
-        counts = [] if tensor[i, 0] == 0 else [0]
-        counts.extend(btw_idxs.detach().cpu().tolist())
-        out.append({'size': [h, w], 'counts': counts})
-    return out
-
-
-def rle_to_mask(rle: Dict[str, Any]) -> np.ndarray:
-    """Compute a binary mask from an uncompressed RLE."""
-    h, w = rle['size']
-    mask = np.empty(h * w, dtype=bool)
-    idx = 0
-    parity = False
-    for count in rle['counts']:
-        mask[idx:idx + count] = parity
-        idx += count
-        parity ^= True
-    mask = mask.reshape(w, h)
-    return mask.transpose()  # Put in C order
-
-
-def area_from_rle(rle: Dict[str, Any]) -> int:
-    return sum(rle['counts'][1::2])
-
-
-def calculate_stability_score(masks: torch.Tensor, mask_threshold: float,
-                              threshold_offset: float) -> torch.Tensor:
-    """Computes the stability score for a batch of masks.
-
-    The stability score is the IoU between the binary masks obtained by
-    thresholding the predicted mask logits at high and low values.
-    """
-    # One mask is always contained inside the other.
-    # Save memory by preventing unnecessary cast to torch.int64
-    intersections = ((masks > (mask_threshold + threshold_offset)).sum(
-        -1, dtype=torch.int16).sum(-1, dtype=torch.int32))
-    unions = ((masks > (mask_threshold - threshold_offset)).sum(
-        -1, dtype=torch.int16).sum(-1, dtype=torch.int32))
-    return intersections / unions
-
-
-def build_point_grid(n_per_side: int) -> np.ndarray:
-    """Generates a 2D grid of points evenly spaced in [0,1]x[0,1]."""
-    offset = 1 / (2 * n_per_side)
-    points_one_side = np.linspace(offset, 1 - offset, n_per_side)
-    points_x = np.tile(points_one_side[None, :], (n_per_side, 1))
-    points_y = np.tile(points_one_side[:, None], (1, n_per_side))
-    points = np.stack([points_x, points_y], axis=-1).reshape(-1, 2)
-    return points
-
-
-def build_all_layer_point_grids(n_per_side: int, n_layers: int,
-                                scale_per_layer: int) -> List[np.ndarray]:
-    """Generates point grids for all crop layers."""
-    points_by_layer = []
-    for i in range(n_layers + 1):
-        n_points = int(n_per_side / (scale_per_layer**i))
-        points_by_layer.append(build_point_grid(n_points))
-    return points_by_layer
-
-
-def generate_crop_boxes(
-        im_size: Tuple[int, ...], n_layers: int,
-        overlap_ratio: float) -> Tuple[List[List[int]], List[int]]:
-    """Generates a list of crop boxes of different sizes.
-
-    Each layer has (2**i)**2 boxes for the ith layer.
-    """
-    crop_boxes, layer_idxs = [], []
-    im_h, im_w = im_size
-    short_side = min(im_h, im_w)
-
-    # Original image
-    crop_boxes.append([0, 0, im_w, im_h])
-    layer_idxs.append(0)
-
-    def crop_len(orig_len, n_crops, overlap):
-        return int(math.ceil((overlap * (n_crops - 1) + orig_len) / n_crops))
-
-    for i_layer in range(n_layers):
-        n_crops_per_side = 2**(i_layer + 1)
-        overlap = int(overlap_ratio * short_side * (2 / n_crops_per_side))
-
-        crop_w = crop_len(im_w, n_crops_per_side, overlap)
-        crop_h = crop_len(im_h, n_crops_per_side, overlap)
-
-        crop_box_x0 = [
-            int((crop_w - overlap) * i) for i in range(n_crops_per_side)
-        ]
-        crop_box_y0 = [
-            int((crop_h - overlap) * i) for i in range(n_crops_per_side)
-        ]
-
-        # Crops in XYWH format
-        for x0, y0 in product(crop_box_x0, crop_box_y0):
-            box = [x0, y0, min(x0 + crop_w, im_w), min(y0 + crop_h, im_h)]
-            crop_boxes.append(box)
-            layer_idxs.append(i_layer + 1)
-
-    return crop_boxes, layer_idxs
-
-
-def uncrop_boxes_xyxy(boxes: torch.Tensor,
-                      crop_box: List[int]) -> torch.Tensor:
-    x0, y0, _, _ = crop_box
-    offset = torch.tensor([[x0, y0, x0, y0]], device=boxes.device)
-    # Check if boxes has a channel dimension
-    if len(boxes.shape) == 3:
-        offset = offset.unsqueeze(1)
-    return boxes + offset
-
-
-def uncrop_points(points: torch.Tensor, crop_box: List[int]) -> torch.Tensor:
-    x0, y0, _, _ = crop_box
-    offset = torch.tensor([[x0, y0]], device=points.device)
-    # Check if points has a channel dimension
-    if len(points.shape) == 3:
-        offset = offset.unsqueeze(1)
-    return points + offset
-
-
-def uncrop_masks(masks: torch.Tensor, crop_box: List[int], orig_h: int,
-                 orig_w: int) -> torch.Tensor:
-    x0, y0, x1, y1 = crop_box
-    if x0 == 0 and y0 == 0 and x1 == orig_w and y1 == orig_h:
-        return masks
-    # Coordinate transform masks
-    pad_x, pad_y = orig_w - (x1 - x0), orig_h - (y1 - y0)
-    pad = (x0, pad_x - x0, y0, pad_y - y0)
-    return torch.nn.functional.pad(masks, pad, value=0)
-
-
-def remove_small_regions(mask: np.ndarray, area_thresh: float,
-                         mode: str) -> Tuple[np.ndarray, bool]:
-    """Removes small disconnected regions and holes in a mask.
-
-    Returns the mask and an indicator of if the mask has been modified.
-    """
-    import cv2  # type: ignore
-
-    assert mode in ['holes', 'islands']
-    correct_holes = mode == 'holes'
-    working_mask = (correct_holes ^ mask).astype(np.uint8)
-    n_labels, regions, stats, _ = cv2.connectedComponentsWithStats(
-        working_mask, 8)
-    sizes = stats[:, -1][1:]  # Row 0 is background label
-    small_regions = [i + 1 for i, s in enumerate(sizes) if s < area_thresh]
-    if len(small_regions) == 0:
-        return mask, False
-    fill_labels = [0] + small_regions
-    if not correct_holes:
-        fill_labels = [i for i in range(n_labels) if i not in fill_labels]
-        # If every region is below threshold, keep largest
-        if len(fill_labels) == 0:
-            fill_labels = [int(np.argmax(sizes)) + 1]
-    mask = np.isin(regions, fill_labels)
-    return mask, True
-
-
-def coco_encode_rle(uncompressed_rle: Dict[str, Any]) -> Dict[str, Any]:
-    from pycocotools import mask as mask_utils  # type: ignore
-
-    h, w = uncompressed_rle['size']
-    rle = mask_utils.frPyObjects(uncompressed_rle, h, w)
-    rle['counts'] = rle['counts'].decode(
-        'utf-8')  # Necessary to serialize with json
-    return rle
-
-
-def batched_mask_to_box(masks: torch.Tensor) -> torch.Tensor:
-    """Calculates boxes in XYXY format around masks.
-
-    Return [0,0,0,0] for an empty mask. For input shape C1xC2x...xHxW, the
-    output shape is C1xC2x...x4.
-    """
-    # torch.max below raises an error on empty inputs, just skip in this case
-    if torch.numel(masks) == 0:
-        return torch.zeros(*masks.shape[:-2], 4, device=masks.device)
-
-    # Normalize shape to CxHxW
-    shape = masks.shape
-    h, w = shape[-2:]
-    if len(shape) > 2:
-        masks = masks.flatten(0, -3)
-    else:
-        masks = masks.unsqueeze(0)
-
-    # Get top and bottom edges
-    in_height, _ = torch.max(masks, dim=-1)
-    in_height_coords = in_height * torch.arange(
-        h, device=in_height.device)[None, :]
-    bottom_edges, _ = torch.max(in_height_coords, dim=-1)
-    in_height_coords = in_height_coords + h * (~in_height)
-    top_edges, _ = torch.min(in_height_coords, dim=-1)
-
-    # Get left and right edges
-    in_width, _ = torch.max(masks, dim=-2)
-    in_width_coords = in_width * torch.arange(
-        w, device=in_width.device)[None, :]
-    right_edges, _ = torch.max(in_width_coords, dim=-1)
-    in_width_coords = in_width_coords + w * (~in_width)
-    left_edges, _ = torch.min(in_width_coords, dim=-1)
-
-    # If the mask is empty the right edge will be to the left of the left edge.
-    # Replace these boxes with [0, 0, 0, 0]
-    empty_filter = (right_edges < left_edges) | (bottom_edges < top_edges)
-    out = torch.stack([left_edges, top_edges, right_edges, bottom_edges],
-                      dim=-1)
-    out = out * (~empty_filter).unsqueeze(-1)
-
-    # Return to original shape
-    if len(shape) > 2:
-        out = out.reshape(*shape[:-2], 4)
-    else:
-        out = out[0]
-
-    return out
diff --git a/mmsegmentation/projects/sam_inference_demo/sam/utils/transforms.py b/mmsegmentation/projects/sam_inference_demo/sam/utils/transforms.py
deleted file mode 100644
index 484fd66..0000000
--- a/mmsegmentation/projects/sam_inference_demo/sam/utils/transforms.py
+++ /dev/null
@@ -1,110 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-from copy import deepcopy
-from typing import Tuple
-
-import numpy as np
-import torch
-from torch.nn import functional as F
-from torchvision.transforms.functional import resize  # type: ignore
-from torchvision.transforms.functional import to_pil_image
-
-from mmseg.registry import TRANSFORMS
-
-
-@TRANSFORMS.register_module()
-class ResizeLongestSide:
-    """Resizes images to longest side 'target_length', as well as provides
-    methods for resizing coordinates and boxes.
-
-    Provides methods for transforming both numpy array and batched torch
-    tensors.
-    """
-
-    def __init__(self, target_length: int) -> None:
-        self.target_length = target_length
-
-    def apply_image(self, image: np.ndarray) -> np.ndarray:
-        """Expects a numpy array with shape HxWxC in uint8 format."""
-        target_size = self.get_preprocess_shape(image.shape[0], image.shape[1],
-                                                self.target_length)
-        return np.array(resize(to_pil_image(image), target_size))
-
-    def apply_coords(self, coords: np.ndarray,
-                     original_size: Tuple[int, ...]) -> np.ndarray:
-        """Expects a numpy array of length 2 in the final dimension.
-
-        Requires the original image size in (H, W) format.
-        """
-        old_h, old_w = original_size
-        new_h, new_w = self.get_preprocess_shape(original_size[0],
-                                                 original_size[1],
-                                                 self.target_length)
-        coords = deepcopy(coords).astype(float)
-        coords[..., 0] = coords[..., 0] * (new_w / old_w)
-        coords[..., 1] = coords[..., 1] * (new_h / old_h)
-        return coords
-
-    def apply_boxes(self, boxes: np.ndarray,
-                    original_size: Tuple[int, ...]) -> np.ndarray:
-        """Expects a numpy array shape Bx4.
-
-        Requires the original image size in (H, W) format.
-        """
-        boxes = self.apply_coords(boxes.reshape(-1, 2, 2), original_size)
-        return boxes.reshape(-1, 4)
-
-    def apply_image_torch(self, image: torch.Tensor) -> torch.Tensor:
-        """Expects batched images with shape BxCxHxW and float format.
-
-        This transformation may not exactly match apply_image. apply_image is
-        the transformation expected by the model.
-        """
-        # Expects an image in BCHW format. May not exactly match apply_image.
-        target_size = self.get_preprocess_shape(image.shape[0], image.shape[1],
-                                                self.target_length)
-        return F.interpolate(
-            image,
-            target_size,
-            mode='bilinear',
-            align_corners=False,
-            antialias=True)
-
-    def apply_coords_torch(self, coords: torch.Tensor,
-                           original_size: Tuple[int, ...]) -> torch.Tensor:
-        """Expects a torch tensor with length 2 in the last dimension.
-
-        Requires the original image size in (H, W) format.
-        """
-        old_h, old_w = original_size
-        new_h, new_w = self.get_preprocess_shape(original_size[0],
-                                                 original_size[1],
-                                                 self.target_length)
-        coords = deepcopy(coords).to(torch.float)
-        coords[..., 0] = coords[..., 0] * (new_w / old_w)
-        coords[..., 1] = coords[..., 1] * (new_h / old_h)
-        return coords
-
-    def apply_boxes_torch(self, boxes: torch.Tensor,
-                          original_size: Tuple[int, ...]) -> torch.Tensor:
-        """Expects a torch tensor with shape Bx4.
-
-        Requires the original image size in (H, W) format.
-        """
-        boxes = self.apply_coords_torch(boxes.reshape(-1, 2, 2), original_size)
-        return boxes.reshape(-1, 4)
-
-    @staticmethod
-    def get_preprocess_shape(oldh: int, oldw: int,
-                             long_side_length: int) -> Tuple[int, int]:
-        """Compute the output size given input size and target long side
-        length."""
-        scale = long_side_length * 1.0 / max(oldh, oldw)
-        newh, neww = oldh * scale, oldw * scale
-        neww = int(neww + 0.5)
-        newh = int(newh + 0.5)
-        return (newh, neww)
diff --git a/mmsegmentation/projects/sam_inference_demo/sam_image_demo.ipynb b/mmsegmentation/projects/sam_inference_demo/sam_image_demo.ipynb
deleted file mode 100644
index 1cb433f..0000000
--- a/mmsegmentation/projects/sam_inference_demo/sam_image_demo.ipynb
+++ /dev/null
@@ -1,122 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "import cv2\n",
-    "\n",
-    "import sam # noqa: F401\n",
-    "from sam.sam_inferencer import SAMInferencer\n",
-    "\n",
-    "\n",
-    "def show_mask(mask, ax, random_color=False):\n",
-    "    if random_color:\n",
-    "        color = np.concatenate([np.random.random(3), np.array([0.6])], axis=0)\n",
-    "    else:\n",
-    "        color = np.array([30/255, 144/255, 255/255, 0.6])\n",
-    "    h, w = mask.shape[-2:]\n",
-    "    mask_image = mask.reshape(h, w, 1) * color.reshape(1, 1, -1)\n",
-    "    ax.imshow(mask_image)\n",
-    "    \n",
-    "def show_points(coords, labels, ax, marker_size=375):\n",
-    "    pos_points = coords[labels==1]\n",
-    "    neg_points = coords[labels==0]\n",
-    "    ax.scatter(pos_points[:, 0], pos_points[:, 1], color='green', marker='*', s=marker_size, edgecolor='white', linewidth=1.25)\n",
-    "    ax.scatter(neg_points[:, 0], neg_points[:, 1], color='red', marker='*', s=marker_size, edgecolor='white', linewidth=1.25)   \n",
-    "    \n",
-    "def show_box(box, ax):\n",
-    "    x0, y0 = box[0], box[1]\n",
-    "    w, h = box[2] - box[0], box[3] - box[1]\n",
-    "    ax.add_patch(plt.Rectangle((x0, y0), w, h, edgecolor='green', facecolor=(0,0,0,0), lw=2))\n",
-    "\n",
-    "image = cv2.imread('../../demo/demo.png')\n",
-    "image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
-    "plt.figure(figsize=(10,10))\n",
-    "plt.imshow(image)\n",
-    "plt.axis('on')\n",
-    "plt.show()\n",
-    "print(image.shape)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "inferencer = SAMInferencer(arch='huge')\n",
-    "inferencer.set_image(image)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "input_point = np.array([[280, 230], [500, 300]])\n",
-    "input_label = np.array([1, 1])\n",
-    "plt.figure(figsize=(10,10))\n",
-    "plt.imshow(image)\n",
-    "show_points(input_point, input_label, plt.gca())\n",
-    "plt.axis('on')\n",
-    "plt.show()  "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "masks, scores, logits = inferencer.predict(\n",
-    "    point_coords=input_point,\n",
-    "    point_labels=input_label,\n",
-    "    multimask_output=True,\n",
-    ")\n",
-    "for i, (mask, score) in enumerate(zip(masks, scores)):\n",
-    "    plt.figure(figsize=(10,10))\n",
-    "    plt.imshow(image)\n",
-    "    show_mask(mask, plt.gca(), random_color=True)\n",
-    "    show_points(input_point, input_label, plt.gca())\n",
-    "    plt.title(f\"Mask {i+1}, Score: {score:.3f}\", fontsize=18)\n",
-    "    plt.axis('off')\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "pt1.13",
-   "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.10.9"
-  },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/mmsegmentation/projects/van/README.md b/mmsegmentation/projects/van/README.md
deleted file mode 100644
index be0ba36..0000000
--- a/mmsegmentation/projects/van/README.md
+++ /dev/null
@@ -1,101 +0,0 @@
-# Visual Attention Network (VAN) for Segmentation
-
-This repo is a PyTorch implementation of applying **VAN** (**Visual Attention Network**) to semantic segmentation.
-
-The code is an integration from [VAN-Segmentation](https://github.com/Visual-Attention-Network/VAN-Segmentation/blob/main/README.md?plain=1)
-
-More details can be found in [**Visual Attention Network**](https://arxiv.org/abs/2202.09741).
-
-## Citation
-
-```bib
-@article{guo2022visual,
-  title={Visual Attention Network},
-  author={Guo, Meng-Hao and Lu, Cheng-Ze and Liu, Zheng-Ning and Cheng, Ming-Ming and Hu, Shi-Min},
-  journal={arXiv preprint arXiv:2202.09741},
-  year={2022}
-}
-```
-
-## Results
-
-**Notes**: Pre-trained models can be found in [TsingHua Cloud](https://cloud.tsinghua.edu.cn/d/0100f0cea37d41ba8d08/).
-
-Results can be found in [VAN-Segmentation](https://github.com/Visual-Attention-Network/VAN-Segmentation/blob/main/README.md?plain=1)
-
-We provide evaluation results of the converted weights.
-
-| Method  |   Backbone   | mIoU  |                                                                    Download                                                                    |
-| :-----: | :----------: | :---: | :--------------------------------------------------------------------------------------------------------------------------------------------: |
-| UPerNet |    VAN-B2    | 49.35 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b2-in1kpre_upernet_3rdparty_512x512-ade20k_20230522-19c58aee.pth)  |
-| UPerNet |    VAN-B3    | 49.71 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b3-in1kpre_upernet_3rdparty_512x512-ade20k_20230522-653bd6b7.pth)  |
-| UPerNet |    VAN-B4    | 51.56 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b4-in1kpre_upernet_3rdparty_512x512-ade20k_20230522-653bd6b7.pth)  |
-| UPerNet | VAN-B4-in22k | 52.61 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b4-in22kpre_upernet_3rdparty_512x512-ade20k_20230522-4a4d744a.pth) |
-| UPerNet | VAN-B5-in22k | 53.11 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b5-in22kpre_upernet_3rdparty_512x512-ade20k_20230522-5bb6f2b4.pth) |
-| UPerNet | VAN-B6-in22k | 54.25 | [model](https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b6-in22kpre_upernet_3rdparty_512x512-ade20k_20230522-e226b363.pth) |
-|   FPN   |    VAN-B0    | 38.65 |   [model](https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b0-in1kpre_fpn_3rdparty_512x512-ade20k_20230522-75a76298.pth)    |
-|   FPN   |    VAN-B1    | 43.22 |   [model](https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b1-in1kpre_fpn_3rdparty_512x512-ade20k_20230522-104499ff.pth)    |
-|   FPN   |    VAN-B2    | 46.84 |   [model](https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b2-in1kpre_fpn_3rdparty_512x512-ade20k_20230522-7074e6f8.pth)    |
-|   FPN   |    VAN-B3    | 48.32 |   [model](https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b3-in1kpre_fpn_3rdparty_512x512-ade20k_20230522-2c3b7f5e.pth)    |
-
-## Preparation
-
-Install MMSegmentation and download ADE20K according to the guidelines in MMSegmentation.
-
-## Requirement
-
-**Step 0.** Install [MMCV](https://github.com/open-mmlab/mmcv) using [MIM](https://github.com/open-mmlab/mim).
-
-```shell
-pip install -U openmim
-mim install mmengine
-mim install "mmcv>=2.0.0"
-```
-
-**Step 1.** Install MMSegmentation.
-
-Case a: If you develop and run mmseg directly, install it from source:
-
-```shell
-git clone -b main https://github.com/open-mmlab/mmsegmentation.git
-cd mmsegmentation
-pip install -v -e .
-```
-
-Case b: If you use mmsegmentation as a dependency or third-party package, install it with pip:
-
-```shell
-pip install "mmsegmentation>=1.0.0"
-```
-
-## Training
-
-If you use 4 GPUs for training by default. Run:
-
-```bash
-bash tools/dist_train.sh projects/van/configs/van/van-b2_pre1k_upernet_4xb2-160k_ade20k-512x512.py 4
-```
-
-## Evaluation
-
-To evaluate the model, an example is:
-
-```bash
-bash tools/dist_train.sh projects/van/configs/van/van-b2_pre1k_upernet_4xb2-160k_ade20k-512x512.py work_dirs/van-b2_pre1k_upernet_4xb2-160k_ade20k-512x512/iter_160000.pth 4 --eval mIoU
-```
-
-## FLOPs
-
-To calculate FLOPs for a model, run:
-
-```bash
-bash tools/analysis_tools/get_flops.py projects/van/configs/van/van-b2_pre1k_upernet_4xb2-160k_ade20k-512x512.py --shape 512 512
-```
-
-## Acknowledgment
-
-Our implementation is mainly based on [mmsegmentation](https://github.com/open-mmlab/mmsegmentation/tree/v0.12.0), [Swin-Transformer](https://github.com/SwinTransformer/Swin-Transformer-Semantic-Segmentation), [PoolFormer](https://github.com/sail-sg/poolformer), [Enjoy-Hamburger](https://github.com/Gsunshine/Enjoy-Hamburger) and [VAN-Segmentation](https://github.com/Visual-Attention-Network/VAN-Segmentation/blob/main/README.md?plain=1). Thanks for their authors.
-
-## LICENSE
-
-This repo is under the Apache-2.0 license. For commercial use, please contact the authors.
diff --git a/mmsegmentation/projects/van/backbones/__init__.py b/mmsegmentation/projects/van/backbones/__init__.py
deleted file mode 100644
index 071995d..0000000
--- a/mmsegmentation/projects/van/backbones/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .van import VAN
-
-__all__ = ['VAN']
diff --git a/mmsegmentation/projects/van/backbones/van.py b/mmsegmentation/projects/van/backbones/van.py
deleted file mode 100644
index 301834a..0000000
--- a/mmsegmentation/projects/van/backbones/van.py
+++ /dev/null
@@ -1,124 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import warnings
-
-import torch
-import torch.nn as nn
-from mmengine.model import BaseModule
-
-from mmseg.models.backbones.mscan import (MSCAN, MSCABlock,
-                                          MSCASpatialAttention,
-                                          OverlapPatchEmbed)
-from mmseg.registry import MODELS
-
-
-class VANAttentionModule(BaseModule):
-
-    def __init__(self, in_channels):
-        super().__init__()
-        self.conv0 = nn.Conv2d(
-            in_channels, in_channels, 5, padding=2, groups=in_channels)
-        self.conv_spatial = nn.Conv2d(
-            in_channels,
-            in_channels,
-            7,
-            stride=1,
-            padding=9,
-            groups=in_channels,
-            dilation=3)
-        self.conv1 = nn.Conv2d(in_channels, in_channels, 1)
-
-    def forward(self, x):
-        u = x.clone()
-        attn = self.conv0(x)
-        attn = self.conv_spatial(attn)
-        attn = self.conv1(attn)
-        return u * attn
-
-
-class VANSpatialAttention(MSCASpatialAttention):
-
-    def __init__(self, in_channels, act_cfg=dict(type='GELU')):
-        super().__init__(in_channels, act_cfg=act_cfg)
-        self.spatial_gating_unit = VANAttentionModule(in_channels)
-
-
-class VANBlock(MSCABlock):
-
-    def __init__(self,
-                 channels,
-                 mlp_ratio=4.,
-                 drop=0.,
-                 drop_path=0.,
-                 act_cfg=dict(type='GELU'),
-                 norm_cfg=dict(type='SyncBN', requires_grad=True)):
-        super().__init__(
-            channels,
-            mlp_ratio=mlp_ratio,
-            drop=drop,
-            drop_path=drop_path,
-            act_cfg=act_cfg,
-            norm_cfg=norm_cfg)
-        self.attn = VANSpatialAttention(channels)
-
-
-@MODELS.register_module()
-class VAN(MSCAN):
-
-    def __init__(self,
-                 in_channels=3,
-                 embed_dims=[64, 128, 256, 512],
-                 mlp_ratios=[8, 8, 4, 4],
-                 drop_rate=0.,
-                 drop_path_rate=0.,
-                 depths=[3, 4, 6, 3],
-                 num_stages=4,
-                 act_cfg=dict(type='GELU'),
-                 norm_cfg=dict(type='SyncBN', requires_grad=True),
-                 pretrained=None,
-                 init_cfg=None):
-        super(MSCAN, self).__init__(init_cfg=init_cfg)
-
-        assert not (init_cfg and pretrained), \
-            'init_cfg and pretrained cannot be set at the same time'
-        if isinstance(pretrained, str):
-            warnings.warn('DeprecationWarning: pretrained is deprecated, '
-                          'please use "init_cfg" instead')
-            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
-        elif pretrained is not None:
-            raise TypeError('pretrained must be a str or None')
-
-        self.depths = depths
-        self.num_stages = num_stages
-
-        # stochastic depth decay rule
-        dpr = [
-            x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))
-        ]
-        cur = 0
-
-        for i in range(num_stages):
-            patch_embed = OverlapPatchEmbed(
-                patch_size=7 if i == 0 else 3,
-                stride=4 if i == 0 else 2,
-                in_channels=in_channels if i == 0 else embed_dims[i - 1],
-                embed_dim=embed_dims[i],
-                norm_cfg=norm_cfg)
-
-            block = nn.ModuleList([
-                VANBlock(
-                    channels=embed_dims[i],
-                    mlp_ratio=mlp_ratios[i],
-                    drop=drop_rate,
-                    drop_path=dpr[cur + j],
-                    act_cfg=act_cfg,
-                    norm_cfg=norm_cfg) for j in range(depths[i])
-            ])
-            norm = nn.LayerNorm(embed_dims[i])
-            cur += depths[i]
-
-            setattr(self, f'patch_embed{i + 1}', patch_embed)
-            setattr(self, f'block{i + 1}', block)
-            setattr(self, f'norm{i + 1}', norm)
-
-    def init_weights(self):
-        return super().init_weights()
diff --git a/mmsegmentation/projects/van/configs/_base_/datasets/ade20k.py b/mmsegmentation/projects/van/configs/_base_/datasets/ade20k.py
deleted file mode 100644
index 69b3c2a..0000000
--- a/mmsegmentation/projects/van/configs/_base_/datasets/ade20k.py
+++ /dev/null
@@ -1,14 +0,0 @@
-# dataset settings
-_base_ = '../../../../../configs/_base_/datasets/ade20k.py'
-
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
-    dict(type='ResizeToMultiple', size_divisor=32),
-    # add loading annotation after ``Resize`` because ground truth
-    # does not need to do resize data transform
-    dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='PackSegInputs')
-]
-val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
-test_dataloader = val_dataloader
diff --git a/mmsegmentation/projects/van/configs/_base_/models/van_fpn.py b/mmsegmentation/projects/van/configs/_base_/models/van_fpn.py
deleted file mode 100644
index c7fd739..0000000
--- a/mmsegmentation/projects/van/configs/_base_/models/van_fpn.py
+++ /dev/null
@@ -1,43 +0,0 @@
-# model settings
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    mean=[123.675, 116.28, 103.53],
-    std=[58.395, 57.12, 57.375],
-    bgr_to_rgb=True,
-    pad_val=0,
-    seg_pad_val=255,
-    size=(512, 512))
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        type='VAN',
-        embed_dims=[32, 64, 160, 256],
-        drop_rate=0.0,
-        drop_path_rate=0.1,
-        depths=[3, 3, 5, 2],
-        act_cfg=dict(type='GELU'),
-        norm_cfg=norm_cfg,
-        init_cfg=dict()),
-    neck=dict(
-        type='FPN',
-        in_channels=[32, 64, 160, 256],
-        out_channels=256,
-        num_outs=4),
-    decode_head=dict(
-        type='FPNHead',
-        in_channels=[256, 256, 256, 256],
-        in_index=[0, 1, 2, 3],
-        feature_strides=[4, 8, 16, 32],
-        channels=128,
-        dropout_ratio=0.1,
-        num_classes=150,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/projects/van/configs/_base_/models/van_upernet.py b/mmsegmentation/projects/van/configs/_base_/models/van_upernet.py
deleted file mode 100644
index 8f94c0d..0000000
--- a/mmsegmentation/projects/van/configs/_base_/models/van_upernet.py
+++ /dev/null
@@ -1,51 +0,0 @@
-# model settings
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-
-data_preprocessor = dict(
-    type='SegDataPreProcessor',
-    mean=[123.675, 116.28, 103.53],
-    std=[58.395, 57.12, 57.375],
-    bgr_to_rgb=True,
-    pad_val=0,
-    seg_pad_val=255,
-    size=(512, 512))
-model = dict(
-    type='EncoderDecoder',
-    data_preprocessor=data_preprocessor,
-    backbone=dict(
-        type='VAN',
-        embed_dims=[32, 64, 160, 256],
-        drop_rate=0.0,
-        drop_path_rate=0.1,
-        depths=[3, 3, 5, 2],
-        act_cfg=dict(type='GELU'),
-        norm_cfg=norm_cfg,
-        init_cfg=dict()),
-    decode_head=dict(
-        type='UPerHead',
-        in_channels=[32, 64, 160, 256],
-        in_index=[0, 1, 2, 3],
-        pool_scales=(1, 2, 3, 6),
-        channels=512,
-        dropout_ratio=0.1,
-        num_classes=150,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
-    auxiliary_head=dict(
-        type='FCNHead',
-        in_channels=160,
-        in_index=2,
-        channels=256,
-        num_convs=1,
-        concat_input=False,
-        dropout_ratio=0.1,
-        num_classes=150,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
-    # model training and testing settings
-    train_cfg=dict(),
-    test_cfg=dict(mode='whole'))
diff --git a/mmsegmentation/projects/van/configs/van/van-b0_fpn_8xb4-40k_ade20k-512x512.py b/mmsegmentation/projects/van/configs/van/van-b0_fpn_8xb4-40k_ade20k-512x512.py
deleted file mode 100644
index 2faf378..0000000
--- a/mmsegmentation/projects/van/configs/van/van-b0_fpn_8xb4-40k_ade20k-512x512.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = './van-b2_fpn_8xb4-40k_ade20k-512x512.py'
-ckpt_path = 'https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b0_3rdparty_20230522-956f5e0d.pth'  # noqa
-model = dict(
-    backbone=dict(
-        embed_dims=[32, 64, 160, 256],
-        depths=[3, 3, 5, 2],
-        init_cfg=dict(type='Pretrained', checkpoint=ckpt_path)),
-    neck=dict(in_channels=[32, 64, 160, 256]))
diff --git a/mmsegmentation/projects/van/configs/van/van-b1_fpn_8xb4-40k_ade20k-512x512.py b/mmsegmentation/projects/van/configs/van/van-b1_fpn_8xb4-40k_ade20k-512x512.py
deleted file mode 100644
index cf64a71..0000000
--- a/mmsegmentation/projects/van/configs/van/van-b1_fpn_8xb4-40k_ade20k-512x512.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = './van-b2_fpn_8xb4-40k_ade20k-512x512.py'
-ckpt_path = 'https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b1_3rdparty_20230522-3adb117f.pth'  # noqa
-model = dict(
-    backbone=dict(
-        depths=[2, 2, 4, 2],
-        init_cfg=dict(type='Pretrained', checkpoint=ckpt_path)))
diff --git a/mmsegmentation/projects/van/configs/van/van-b2_fpn_8xb4-40k_ade20k-512x512.py b/mmsegmentation/projects/van/configs/van/van-b2_fpn_8xb4-40k_ade20k-512x512.py
deleted file mode 100644
index 965fa1c..0000000
--- a/mmsegmentation/projects/van/configs/van/van-b2_fpn_8xb4-40k_ade20k-512x512.py
+++ /dev/null
@@ -1,53 +0,0 @@
-_base_ = [
-    '../_base_/models/van_fpn.py',
-    '../_base_/datasets/ade20k.py',
-    '../../../../configs/_base_/default_runtime.py',
-]
-custom_imports = dict(imports=['projects.van.backbones'])
-ckpt_path = 'https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b2_3rdparty_20230522-636fac93.pth'  # noqa
-model = dict(
-    type='EncoderDecoder',
-    backbone=dict(
-        embed_dims=[64, 128, 320, 512],
-        depths=[3, 3, 12, 3],
-        init_cfg=dict(type='Pretrained', checkpoint=ckpt_path),
-        drop_path_rate=0.2),
-    neck=dict(in_channels=[64, 128, 320, 512]),
-    decode_head=dict(num_classes=150))
-
-train_dataloader = dict(batch_size=4)
-
-# we use 8 gpu instead of 4 in mmsegmentation, so lr*2 and max_iters/2
-gpu_multiples = 2
-max_iters = 80000 // gpu_multiples
-interval = 8000 // gpu_multiples
-optim_wrapper = dict(
-    type='OptimWrapper',
-    optimizer=dict(
-        type='AdamW',
-        lr=0.0001 * gpu_multiples,
-        # betas=(0.9, 0.999),
-        weight_decay=0.0001),
-    clip_grad=None)
-# learning policy
-param_scheduler = [
-    dict(
-        type='PolyLR',
-        power=0.9,
-        eta_min=0.0,
-        begin=0,
-        end=max_iters,
-        by_epoch=False,
-    )
-]
-train_cfg = dict(
-    type='IterBasedTrainLoop', max_iters=max_iters, val_interval=interval)
-val_cfg = dict(type='ValLoop')
-test_cfg = dict(type='TestLoop')
-default_hooks = dict(
-    timer=dict(type='IterTimerHook'),
-    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
-    param_scheduler=dict(type='ParamSchedulerHook'),
-    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=interval),
-    sampler_seed=dict(type='DistSamplerSeedHook'),
-    visualization=dict(type='SegVisualizationHook'))
diff --git a/mmsegmentation/projects/van/configs/van/van-b2_upernet_4xb2-160k_ade20k-512x512.py b/mmsegmentation/projects/van/configs/van/van-b2_upernet_4xb2-160k_ade20k-512x512.py
deleted file mode 100644
index c529606..0000000
--- a/mmsegmentation/projects/van/configs/van/van-b2_upernet_4xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,46 +0,0 @@
-_base_ = [
-    '../_base_/models/van_upernet.py', '../_base_/datasets/ade20k.py',
-    '../../../../configs/_base_/default_runtime.py',
-    '../../../../configs/_base_/schedules/schedule_160k.py'
-]
-custom_imports = dict(imports=['projects.van.backbones'])
-ckpt_path = 'https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b2_3rdparty_20230522-636fac93.pth'  # noqa
-model = dict(
-    type='EncoderDecoder',
-    backbone=dict(
-        embed_dims=[64, 128, 320, 512],
-        depths=[3, 3, 12, 3],
-        init_cfg=dict(type='Pretrained', checkpoint=ckpt_path)),
-    decode_head=dict(in_channels=[64, 128, 320, 512], num_classes=150),
-    auxiliary_head=dict(in_channels=320, num_classes=150))
-
-# AdamW optimizer
-# no weight decay for position embedding & layer norm in backbone
-optim_wrapper = dict(
-    _delete_=True,
-    type='OptimWrapper',
-    optimizer=dict(
-        type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01),
-    clip_grad=None,
-    paramwise_cfg=dict(
-        custom_keys={
-            'absolute_pos_embed': dict(decay_mult=0.),
-            'relative_position_bias_table': dict(decay_mult=0.),
-            'norm': dict(decay_mult=0.)
-        }))
-# learning policy
-param_scheduler = [
-    dict(
-        type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500),
-    dict(
-        type='PolyLR',
-        power=1.0,
-        begin=1500,
-        end=_base_.train_cfg.max_iters,
-        eta_min=0.0,
-        by_epoch=False,
-    )
-]
-
-# By default, models are trained on 8 GPUs with 2 images per GPU
-train_dataloader = dict(batch_size=2)
diff --git a/mmsegmentation/projects/van/configs/van/van-b3_fpn_8xb4-40k_ade20k-512x512.py b/mmsegmentation/projects/van/configs/van/van-b3_fpn_8xb4-40k_ade20k-512x512.py
deleted file mode 100644
index b0493fe..0000000
--- a/mmsegmentation/projects/van/configs/van/van-b3_fpn_8xb4-40k_ade20k-512x512.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = './van-b2_fpn_8xb4-40k_ade20k-512x512.py'
-ckpt_path = 'https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b3_3rdparty_20230522-a184e051.pth'  # noqa
-model = dict(
-    type='EncoderDecoder',
-    backbone=dict(
-        embed_dims=[64, 128, 320, 512],
-        depths=[3, 5, 27, 3],
-        init_cfg=dict(type='Pretrained', checkpoint=ckpt_path),
-        drop_path_rate=0.3),
-    neck=dict(in_channels=[64, 128, 320, 512]))
-train_dataloader = dict(batch_size=4)
diff --git a/mmsegmentation/projects/van/configs/van/van-b3_upernet_4xb2-160k_ade20k-512x512.py b/mmsegmentation/projects/van/configs/van/van-b3_upernet_4xb2-160k_ade20k-512x512.py
deleted file mode 100644
index 8201801..0000000
--- a/mmsegmentation/projects/van/configs/van/van-b3_upernet_4xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,8 +0,0 @@
-_base_ = './van-b2_upernet_4xb2-160k_ade20k-512x512.py'
-ckpt_path = 'https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b3_3rdparty_20230522-a184e051.pth'  # noqa
-model = dict(
-    type='EncoderDecoder',
-    backbone=dict(
-        depths=[3, 5, 27, 3],
-        init_cfg=dict(type='Pretrained', checkpoint=ckpt_path),
-        drop_path_rate=0.3))
diff --git a/mmsegmentation/projects/van/configs/van/van-b4-in22kpre_upernet_4xb4-160k_ade20k-512x512.py b/mmsegmentation/projects/van/configs/van/van-b4-in22kpre_upernet_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 15c8f7c..0000000
--- a/mmsegmentation/projects/van/configs/van/van-b4-in22kpre_upernet_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = './van-b2_upernet_4xb2-160k_ade20k-512x512.py'
-ckpt_path = 'https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b4-in22k_3rdparty_20230522-5e31cafb.pth'  # noqa
-model = dict(
-    backbone=dict(
-        depths=[3, 6, 40, 3],
-        init_cfg=dict(type='Pretrained', checkpoint=ckpt_path),
-        drop_path_rate=0.4))
-
-# By default, models are trained on 8 GPUs with 2 images per GPU
-train_dataloader = dict(batch_size=4)
diff --git a/mmsegmentation/projects/van/configs/van/van-b4_upernet_4xb4-160k_ade20k-512x512.py b/mmsegmentation/projects/van/configs/van/van-b4_upernet_4xb4-160k_ade20k-512x512.py
deleted file mode 100644
index 33ae049..0000000
--- a/mmsegmentation/projects/van/configs/van/van-b4_upernet_4xb4-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = './van-b2_upernet_4xb2-160k_ade20k-512x512.py'
-ckpt_path = 'https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b4_3rdparty_20230522-1d71c077.pth'  # noqa
-model = dict(
-    backbone=dict(
-        depths=[3, 6, 40, 3],
-        init_cfg=dict(type='Pretrained', checkpoint=ckpt_path),
-        drop_path_rate=0.4))
-
-# By default, models are trained on 4 GPUs with 4 images per GPU
-train_dataloader = dict(batch_size=4)
diff --git a/mmsegmentation/projects/van/configs/van/van-b5-in22kpre_upernet_4xb2-160k_ade20k-512x512.py b/mmsegmentation/projects/van/configs/van/van-b5-in22kpre_upernet_4xb2-160k_ade20k-512x512.py
deleted file mode 100644
index f36c624..0000000
--- a/mmsegmentation/projects/van/configs/van/van-b5-in22kpre_upernet_4xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = './van-b2_upernet_4xb2-160k_ade20k-512x512.py'
-ckpt_path = 'https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b5-in22k_3rdparty_20230522-b26134d7.pth'  # noqa
-model = dict(
-    backbone=dict(
-        embed_dims=[96, 192, 480, 768],
-        depths=[3, 3, 24, 3],
-        init_cfg=dict(type='Pretrained', checkpoint=ckpt_path),
-        drop_path_rate=0.4),
-    decode_head=dict(in_channels=[96, 192, 480, 768], num_classes=150),
-    auxiliary_head=dict(in_channels=480, num_classes=150))
diff --git a/mmsegmentation/projects/van/configs/van/van-b6-in22kpre_upernet_4xb2-160k_ade20k-512x512.py b/mmsegmentation/projects/van/configs/van/van-b6-in22kpre_upernet_4xb2-160k_ade20k-512x512.py
deleted file mode 100644
index aa529ef..0000000
--- a/mmsegmentation/projects/van/configs/van/van-b6-in22kpre_upernet_4xb2-160k_ade20k-512x512.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = './van-b2_upernet_4xb2-160k_ade20k-512x512.py'
-ckpt_path = 'https://download.openmmlab.com/mmsegmentation/v0.5/van_3rdparty/van-b6-in22k_3rdparty_20230522-5e5172a3.pth'  # noqa
-model = dict(
-    backbone=dict(
-        embed_dims=[96, 192, 384, 768],
-        depths=[6, 6, 90, 6],
-        init_cfg=dict(type='Pretrained', checkpoint=ckpt_path),
-        drop_path_rate=0.5),
-    decode_head=dict(in_channels=[96, 192, 384, 768], num_classes=150),
-    auxiliary_head=dict(in_channels=384, num_classes=150))
diff --git a/mmsegmentation/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py b/mmsegmentation/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
deleted file mode 100644
index 689ac07..0000000
--- a/mmsegmentation/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py
+++ /dev/null
@@ -1,292 +0,0 @@
-crop_size = (
-    512,
-    1024,
-)
-data_preprocessor = dict(
-    bgr_to_rgb=True,
-    mean=[
-        123.675,
-        116.28,
-        103.53,
-    ],
-    pad_val=0,
-    seg_pad_val=255,
-    size=(
-        512,
-        1024,
-    ),
-    std=[
-        58.395,
-        57.12,
-        57.375,
-    ],
-    type='SegDataPreProcessor')
-data_root = 'data/cityscapes/'
-dataset_type = 'CityscapesDataset'
-default_hooks = dict(
-    checkpoint=dict(by_epoch=False, interval=4000, type='CheckpointHook'),
-    logger=dict(interval=50, log_metric_by_epoch=False, type='LoggerHook'),
-    param_scheduler=dict(type='ParamSchedulerHook'),
-    sampler_seed=dict(type='DistSamplerSeedHook'),
-    timer=dict(type='IterTimerHook'),
-    visualization=dict(type='SegVisualizationHook'))
-default_scope = 'mmseg'
-env_cfg = dict(
-    cudnn_benchmark=True,
-    dist_cfg=dict(backend='nccl'),
-    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0))
-img_ratios = [
-    0.5,
-    0.75,
-    1.0,
-    1.25,
-    1.5,
-    1.75,
-]
-load_from = None
-log_level = 'INFO'
-log_processor = dict(by_epoch=False)
-model = dict(
-    auxiliary_head=dict(
-        align_corners=False,
-        channels=256,
-        concat_input=False,
-        dropout_ratio=0.1,
-        in_channels=1024,
-        in_index=2,
-        loss_decode=dict(
-            loss_weight=0.4, type='CrossEntropyLoss', use_sigmoid=False),
-        norm_cfg=dict(requires_grad=True, type='SyncBN'),
-        num_classes=19,
-        num_convs=1,
-        type='FCNHead'),
-    backbone=dict(
-        contract_dilation=True,
-        depth=50,
-        dilations=(
-            1,
-            1,
-            2,
-            4,
-        ),
-        norm_cfg=dict(requires_grad=True, type='SyncBN'),
-        norm_eval=False,
-        num_stages=4,
-        out_indices=(
-            0,
-            1,
-            2,
-            3,
-        ),
-        strides=(
-            1,
-            2,
-            1,
-            1,
-        ),
-        style='pytorch',
-        type='ResNetV1c'),
-    data_preprocessor=dict(
-        bgr_to_rgb=True,
-        mean=[
-            123.675,
-            116.28,
-            103.53,
-        ],
-        pad_val=0,
-        seg_pad_val=255,
-        size=(
-            512,
-            1024,
-        ),
-        std=[
-            58.395,
-            57.12,
-            57.375,
-        ],
-        type='SegDataPreProcessor'),
-    decode_head=dict(
-        align_corners=False,
-        channels=512,
-        dropout_ratio=0.1,
-        in_channels=2048,
-        in_index=3,
-        loss_decode=dict(
-            loss_weight=1.0, type='CrossEntropyLoss', use_sigmoid=False),
-        norm_cfg=dict(requires_grad=True, type='SyncBN'),
-        num_classes=19,
-        pool_scales=(
-            1,
-            2,
-            3,
-            6,
-        ),
-        type='PSPHead'),
-    pretrained='open-mmlab://resnet50_v1c',
-    test_cfg=dict(mode='whole'),
-    train_cfg=dict(),
-    type='EncoderDecoder')
-norm_cfg = dict(requires_grad=True, type='SyncBN')
-optim_wrapper = dict(
-    clip_grad=None,
-    optimizer=dict(lr=0.01, momentum=0.9, type='SGD', weight_decay=0.0005),
-    type='OptimWrapper')
-optimizer = dict(lr=0.01, momentum=0.9, type='SGD', weight_decay=0.0005)
-param_scheduler = [
-    dict(
-        begin=0,
-        by_epoch=False,
-        end=40000,
-        eta_min=0.0001,
-        power=0.9,
-        type='PolyLR'),
-]
-resume = False
-test_cfg = dict(type='TestLoop')
-test_dataloader = dict(
-    batch_size=1,
-    dataset=dict(
-        data_prefix=dict(
-            img_path='leftImg8bit/val', seg_map_path='gtFine/val'),
-        data_root='data/cityscapes/',
-        pipeline=[
-            dict(type='LoadImageFromFile'),
-            dict(keep_ratio=True, scale=(
-                2048,
-                1024,
-            ), type='Resize'),
-            dict(type='LoadAnnotations'),
-            dict(type='PackSegInputs'),
-        ],
-        type='CityscapesDataset'),
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(shuffle=False, type='DefaultSampler'))
-test_evaluator = dict(
-    iou_metrics=[
-        'mIoU',
-    ], type='IoUMetric')
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(keep_ratio=True, scale=(
-        2048,
-        1024,
-    ), type='Resize'),
-    dict(type='LoadAnnotations'),
-    dict(type='PackSegInputs'),
-]
-train_cfg = dict(max_iters=40000, type='IterBasedTrainLoop', val_interval=4000)
-train_dataloader = dict(
-    batch_size=2,
-    dataset=dict(
-        data_prefix=dict(
-            img_path='leftImg8bit/train', seg_map_path='gtFine/train'),
-        data_root='data/cityscapes/',
-        pipeline=[
-            dict(type='LoadImageFromFile'),
-            dict(type='LoadAnnotations'),
-            dict(
-                keep_ratio=True,
-                ratio_range=(
-                    0.5,
-                    2.0,
-                ),
-                scale=(
-                    2048,
-                    1024,
-                ),
-                type='RandomResize'),
-            dict(
-                cat_max_ratio=0.75, crop_size=(
-                    512,
-                    1024,
-                ), type='RandomCrop'),
-            dict(prob=0.5, type='RandomFlip'),
-            dict(type='PhotoMetricDistortion'),
-            dict(type='PackSegInputs'),
-        ],
-        type='CityscapesDataset'),
-    num_workers=2,
-    persistent_workers=True,
-    sampler=dict(shuffle=True, type='InfiniteSampler'))
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations'),
-    dict(
-        keep_ratio=True,
-        ratio_range=(
-            0.5,
-            2.0,
-        ),
-        scale=(
-            2048,
-            1024,
-        ),
-        type='RandomResize'),
-    dict(cat_max_ratio=0.75, crop_size=(
-        512,
-        1024,
-    ), type='RandomCrop'),
-    dict(prob=0.5, type='RandomFlip'),
-    dict(type='PhotoMetricDistortion'),
-    dict(type='PackSegInputs'),
-]
-tta_model = dict(type='SegTTAModel')
-tta_pipeline = [
-    dict(backend_args=None, type='LoadImageFromFile'),
-    dict(
-        transforms=[
-            [
-                dict(keep_ratio=True, scale_factor=0.5, type='Resize'),
-                dict(keep_ratio=True, scale_factor=0.75, type='Resize'),
-                dict(keep_ratio=True, scale_factor=1.0, type='Resize'),
-                dict(keep_ratio=True, scale_factor=1.25, type='Resize'),
-                dict(keep_ratio=True, scale_factor=1.5, type='Resize'),
-                dict(keep_ratio=True, scale_factor=1.75, type='Resize'),
-            ],
-            [
-                dict(direction='horizontal', prob=0.0, type='RandomFlip'),
-                dict(direction='horizontal', prob=1.0, type='RandomFlip'),
-            ],
-            [
-                dict(type='LoadAnnotations'),
-            ],
-            [
-                dict(type='PackSegInputs'),
-            ],
-        ],
-        type='TestTimeAug'),
-]
-val_cfg = dict(type='ValLoop')
-val_dataloader = dict(
-    batch_size=1,
-    dataset=dict(
-        data_prefix=dict(
-            img_path='leftImg8bit/val', seg_map_path='gtFine/val'),
-        data_root='data/cityscapes/',
-        pipeline=[
-            dict(type='LoadImageFromFile'),
-            dict(keep_ratio=True, scale=(
-                2048,
-                1024,
-            ), type='Resize'),
-            dict(type='LoadAnnotations'),
-            dict(type='PackSegInputs'),
-        ],
-        type='CityscapesDataset'),
-    num_workers=4,
-    persistent_workers=True,
-    sampler=dict(shuffle=False, type='DefaultSampler'))
-val_evaluator = dict(
-    iou_metrics=[
-        'mIoU',
-    ], type='IoUMetric')
-vis_backends = [
-    dict(type='LocalVisBackend'),
-]
-visualizer = dict(
-    name='visualizer',
-    type='SegLocalVisualizer',
-    vis_backends=[
-        dict(type='LocalVisBackend'),
-    ])
diff --git a/mmsegmentation/requirements.txt b/mmsegmentation/requirements.txt
deleted file mode 100644
index 501bddc..0000000
--- a/mmsegmentation/requirements.txt
+++ /dev/null
@@ -1,4 +0,0 @@
--r requirements/optional.txt
--r requirements/runtime.txt
--r requirements/tests.txt
--r requirements/multimodal.txt
diff --git a/mmsegmentation/requirements/albu.txt b/mmsegmentation/requirements/albu.txt
deleted file mode 100644
index f421fbb..0000000
--- a/mmsegmentation/requirements/albu.txt
+++ /dev/null
@@ -1 +0,0 @@
-albumentations>=0.3.2 --no-binary qudida,albumentations
diff --git a/mmsegmentation/requirements/docs.txt b/mmsegmentation/requirements/docs.txt
deleted file mode 100644
index 19632d3..0000000
--- a/mmsegmentation/requirements/docs.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-docutils==0.16.0
-myst-parser
--e git+https://github.com/open-mmlab/pytorch_sphinx_theme.git#egg=pytorch_sphinx_theme
-sphinx==4.0.2
-sphinx_copybutton
-sphinx_markdown_tables
-urllib3<2.0.0
diff --git a/mmsegmentation/requirements/mminstall.txt b/mmsegmentation/requirements/mminstall.txt
deleted file mode 100644
index 5732d34..0000000
--- a/mmsegmentation/requirements/mminstall.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-mmcv>=2.0.0rc4,<2.2.0
-mmengine>=0.5.0,<1.0.0
diff --git a/mmsegmentation/requirements/multimodal.txt b/mmsegmentation/requirements/multimodal.txt
deleted file mode 100644
index 2195d0d..0000000
--- a/mmsegmentation/requirements/multimodal.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-ftfy
-regex
diff --git a/mmsegmentation/requirements/optional.txt b/mmsegmentation/requirements/optional.txt
deleted file mode 100644
index b0310f5..0000000
--- a/mmsegmentation/requirements/optional.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-cityscapesscripts
--e git+https://github.com/openai/CLIP.git@main#egg=clip
-
-# for vpd model
-diffusers
-einops==0.3.0
-imageio==2.9.0
-imageio-ffmpeg==0.4.2
-invisible-watermark
-kornia==0.6
--e git+https://github.com/CompVis/stable-diffusion@21f890f#egg=latent-diffusion
-nibabel
-omegaconf==2.1.1
-pudb==2019.2
-pytorch-lightning==1.4.2
-streamlit>=0.73.1
--e git+https://github.com/CompVis/taming-transformers.git@master#egg=taming-transformers
-test-tube>=0.7.5
-timm
-torch-fidelity==0.3.0
-torchmetrics==0.6.0
-transformers==4.19.2
diff --git a/mmsegmentation/requirements/readthedocs.txt b/mmsegmentation/requirements/readthedocs.txt
deleted file mode 100644
index 9627504..0000000
--- a/mmsegmentation/requirements/readthedocs.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-mmcv>=2.0.0rc1,<2.1.0
-mmengine>=0.4.0,<1.0.0
-prettytable
-scipy
-torch
-torchvision
diff --git a/mmsegmentation/requirements/runtime.txt b/mmsegmentation/requirements/runtime.txt
deleted file mode 100644
index 3e24258..0000000
--- a/mmsegmentation/requirements/runtime.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-matplotlib
-numpy
-packaging
-prettytable
-scipy
diff --git a/mmsegmentation/requirements/tests.txt b/mmsegmentation/requirements/tests.txt
deleted file mode 100644
index 3fff252..0000000
--- a/mmsegmentation/requirements/tests.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-codecov
-flake8
-ftfy
-interrogate
-pytest
-regex
-xdoctest>=0.10.0
-yapf
diff --git a/mmsegmentation/resources/seg_demo.gif b/mmsegmentation/resources/seg_demo.gif
deleted file mode 100644
index 2f0760fe7a86912c07f9873eec3909ad41fe2acb..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 951973
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%0AM5-r
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
Ss-vXLE+oo&gwdJ{0suScg1(CY

diff --git a/mmsegmentation/setup.cfg b/mmsegmentation/setup.cfg
deleted file mode 100644
index 2ea0760..0000000
--- a/mmsegmentation/setup.cfg
+++ /dev/null
@@ -1,19 +0,0 @@
-[yapf]
-based_on_style = pep8
-blank_line_before_nested_class_or_def = true
-split_before_expression_after_opening_paren = true
-
-[isort]
-line_length = 79
-multi_line_output = 0
-extra_standard_library = setuptools
-known_first_party = mmseg
-known_third_party = PIL,cityscapesscripts,cv2,detail,matplotlib,mmcv,numpy,onnxruntime,packaging,prettytable,pytest,pytorch_sphinx_theme,requests,scipy,seaborn,torch,ts
-no_lines_before = STDLIB,LOCALFOLDER
-default_section = THIRDPARTY
-
-[codespell]
-skip = *.po,*.ts,*.ipynb
-count =
-quiet-level = 3
-ignore-words-list = formating,sur,hist,dota,warmup,damon
diff --git a/mmsegmentation/setup.py b/mmsegmentation/setup.py
deleted file mode 100755
index 45d923d..0000000
--- a/mmsegmentation/setup.py
+++ /dev/null
@@ -1,200 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import os
-import os.path as osp
-import platform
-import shutil
-import sys
-import warnings
-from setuptools import find_packages, setup
-
-
-def readme():
-    with open('README.md', encoding='utf-8') as f:
-        content = f.read()
-    return content
-
-
-version_file = 'mmseg/version.py'
-
-
-def get_version():
-    with open(version_file) as f:
-        exec(compile(f.read(), version_file, 'exec'))
-    return locals()['__version__']
-
-
-def parse_requirements(fname='requirements.txt', with_version=True):
-    """Parse the package dependencies listed in a requirements file but strips
-    specific versioning information.
-
-    Args:
-        fname (str): path to requirements file
-        with_version (bool, default=False): if True include version specs
-
-    Returns:
-        List[str]: list of requirements items
-
-    CommandLine:
-        python -c "import setup; print(setup.parse_requirements())"
-    """
-    import re
-    import sys
-    from os.path import exists
-    require_fpath = fname
-
-    def parse_line(line):
-        """Parse information from a line in a requirements text file."""
-        if line.startswith('-r '):
-            # Allow specifying requirements in other files
-            target = line.split(' ')[1]
-            for info in parse_require_file(target):
-                yield info
-        else:
-            info = {'line': line}
-            if line.startswith('-e '):
-                info['package'] = line.split('#egg=')[1]
-            else:
-                # Remove versioning from the package
-                pat = '(' + '|'.join(['>=', '==', '>']) + ')'
-                parts = re.split(pat, line, maxsplit=1)
-                parts = [p.strip() for p in parts]
-
-                info['package'] = parts[0]
-                if len(parts) > 1:
-                    op, rest = parts[1:]
-                    if ';' in rest:
-                        # Handle platform specific dependencies
-                        # http://setuptools.readthedocs.io/en/latest/setuptools.html#declaring-platform-specific-dependencies
-                        version, platform_deps = map(str.strip,
-                                                     rest.split(';'))
-                        info['platform_deps'] = platform_deps
-                    else:
-                        version = rest  # NOQA
-                    info['version'] = (op, version)
-            yield info
-
-    def parse_require_file(fpath):
-        with open(fpath) as f:
-            for line in f.readlines():
-                line = line.strip()
-                if line and not line.startswith('#'):
-                    yield from parse_line(line)
-
-    def gen_packages_items():
-        if exists(require_fpath):
-            for info in parse_require_file(require_fpath):
-                parts = [info['package']]
-                if with_version and 'version' in info:
-                    parts.extend(info['version'])
-                if not sys.version.startswith('3.4'):
-                    # apparently package_deps are broken in 3.4
-                    platform_deps = info.get('platform_deps')
-                    if platform_deps is not None:
-                        parts.append(';' + platform_deps)
-                item = ''.join(parts)
-                yield item
-
-    packages = list(gen_packages_items())
-    return packages
-
-
-def add_mim_extension():
-    """Add extra files that are required to support MIM into the package.
-
-    These files will be added by creating a symlink to the originals if the
-    package is installed in `editable` mode (e.g. pip install -e .), or by
-    copying from the originals otherwise.
-    """
-
-    # parse installment mode
-    if 'develop' in sys.argv:
-        # installed by `pip install -e .`
-        if platform.system() == 'Windows':
-            # set `copy` mode here since symlink fails on Windows.
-            mode = 'copy'
-        else:
-            mode = 'symlink'
-    elif 'sdist' in sys.argv or 'bdist_wheel' in sys.argv or \
-            platform.system() == 'Windows':
-        # installed by `pip install .`
-        # or create source distribution by `python setup.py sdist`
-        # set `copy` mode here since symlink fails with WinError on Windows.
-        mode = 'copy'
-    else:
-        return
-
-    filenames = ['tools', 'configs', 'model-index.yml', 'dataset-index.yml']
-    repo_path = osp.dirname(__file__)
-    mim_path = osp.join(repo_path, 'mmseg', '.mim')
-    os.makedirs(mim_path, exist_ok=True)
-
-    for filename in filenames:
-        if osp.exists(filename):
-            src_path = osp.join(repo_path, filename)
-            tar_path = osp.join(mim_path, filename)
-
-            if osp.isfile(tar_path) or osp.islink(tar_path):
-                os.remove(tar_path)
-            elif osp.isdir(tar_path):
-                shutil.rmtree(tar_path)
-
-            if mode == 'symlink':
-                src_relpath = osp.relpath(src_path, osp.dirname(tar_path))
-                try:
-                    os.symlink(src_relpath, tar_path)
-                except OSError:
-                    # Creating a symbolic link on windows may raise an
-                    # `OSError: [WinError 1314]` due to privilege. If
-                    # the error happens, the src file will be copied
-                    mode = 'copy'
-                    warnings.warn(
-                        f'Failed to create a symbolic link for {src_relpath}, '
-                        f'and it will be copied to {tar_path}')
-                else:
-                    continue
-
-            if mode == 'copy':
-                if osp.isfile(src_path):
-                    shutil.copyfile(src_path, tar_path)
-                elif osp.isdir(src_path):
-                    shutil.copytree(src_path, tar_path)
-                else:
-                    warnings.warn(f'Cannot copy file {src_path}.')
-            else:
-                raise ValueError(f'Invalid mode {mode}')
-
-
-if __name__ == '__main__':
-    add_mim_extension()
-    setup(
-        name='mmsegmentation',
-        version=get_version(),
-        description='Open MMLab Semantic Segmentation Toolbox and Benchmark',
-        long_description=readme(),
-        long_description_content_type='text/markdown',
-        author='MMSegmentation Contributors',
-        author_email='openmmlab@gmail.com',
-        keywords='computer vision, semantic segmentation',
-        url='https://github.com/open-mmlab/mmsegmentation',
-        packages=find_packages(exclude=('configs', 'tools', 'demo')),
-        include_package_data=True,
-        classifiers=[
-            'Development Status :: 4 - Beta',
-            'License :: OSI Approved :: Apache Software License',
-            'Operating System :: OS Independent',
-            'Programming Language :: Python :: 3.6',
-            'Programming Language :: Python :: 3.7',
-            'Programming Language :: Python :: 3.8',
-            'Programming Language :: Python :: 3.9',
-        ],
-        license='Apache License 2.0',
-        install_requires=parse_requirements('requirements/runtime.txt'),
-        extras_require={
-            'all': parse_requirements('requirements.txt'),
-            'tests': parse_requirements('requirements/tests.txt'),
-            'optional': parse_requirements('requirements/optional.txt'),
-            'mim': parse_requirements('requirements/mminstall.txt'),
-            'multimodal': parse_requirements('requirements/multimodal.txt'),
-        },
-        ext_modules=[],
-        zip_safe=False)
diff --git a/mmsegmentation/test.ipynb b/mmsegmentation/test.ipynb
deleted file mode 100644
index 6d8c9c5..0000000
--- a/mmsegmentation/test.ipynb
+++ /dev/null
@@ -1,194 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/opt/conda/lib/python3.10/site-packages/albumentations/__init__.py:13: UserWarning: A new version of Albumentations is available: 1.4.21 (you have 1.4.18). Upgrade using: pip install -U albumentations. To disable automatic update checks, set the environment variable NO_ALBUMENTATIONS_UPDATE to 1.\n",
-      "  check_for_updates()\n"
-     ]
-    }
-   ],
-   "source": [
-    "from mmseg.datasets import XRayDataset\n",
-    "from mmengine.registry import init_default_scope\n",
-    "import sys\n",
-    "init_default_scope('mmseg')\n",
-    "sys.path.append(\"/data/ephemeral/home/mmsegmentation/mmseg\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'/data/ephemeral/home/mmsegmentation'"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "import os\n",
-    "os.getcwd()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "crop_size = (1024, 1024)\n",
-    "\n",
-    "data_root = '/data/ephemeral/home/cityscapes_format_xlay/'\n",
-    "data_prefix=dict(img_path='leftImg8bit/train', seg_map_path='gtFine/train')\n",
-    "\n",
-    "train_pipeline = [\n",
-    "    dict(type='LoadImageFromFile'),\n",
-    "    dict(type='LoadAnnotations'),\n",
-    "    dict(\n",
-    "        type='RandomChoiceResize',\n",
-    "        scales=[int(1024 * x * 0.1) for x in range(5, 21)],\n",
-    "        resize_type='ResizeShortestEdge',\n",
-    "        max_size=4096),\n",
-    "    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),\n",
-    "    dict(type='RandomFlip', prob=0.5),\n",
-    "    dict(type='PhotoMetricDistortion'),\n",
-    "    dict(type='PackSegInputs')\n",
-    "]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from mmengine.utils import is_str\n",
-    "\n",
-    "is_str('xray')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['finger-1',\n",
-       " 'finger-2',\n",
-       " 'finger-3',\n",
-       " 'finger-4',\n",
-       " 'finger-5',\n",
-       " 'finger-6',\n",
-       " 'finger-7',\n",
-       " 'finger-8',\n",
-       " 'finger-9',\n",
-       " 'finger-10',\n",
-       " 'finger-11',\n",
-       " 'finger-12',\n",
-       " 'finger-13',\n",
-       " 'finger-14',\n",
-       " 'finger-15',\n",
-       " 'finger-16',\n",
-       " 'finger-17',\n",
-       " 'finger-18',\n",
-       " 'finger-19',\n",
-       " 'Trapezium',\n",
-       " 'Trapezoid',\n",
-       " 'Capitate',\n",
-       " 'Hamate',\n",
-       " 'Scaphoid',\n",
-       " 'Lunate',\n",
-       " 'Triquetrum',\n",
-       " 'Pisiform',\n",
-       " 'Radius',\n",
-       " 'Ulna']"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from utils.class_names import get_classes\n",
-    "get_classes('XRay')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "ValueError",
-     "evalue": "need at least one array to concatenate",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[6], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m dataset \u001b[38;5;241m=\u001b[39m \u001b[43mXRayDataset\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m      2\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdata_root\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdata_root\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m      3\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdata_prefix\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdata_prefix\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m      4\u001b[0m \u001b[43m    \u001b[49m\u001b[43mpipeline\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtrain_pipeline\u001b[49m\n\u001b[1;32m      5\u001b[0m \u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/mmsegmentation/mmseg/datasets/xray.py:28\u001b[0m, in \u001b[0;36mXRayDataset.__init__\u001b[0;34m(self, data_root, data_prefix, pipeline)\u001b[0m\n\u001b[1;32m     27\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, data_root, data_prefix, pipeline):\n\u001b[0;32m---> 28\u001b[0m     \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mXRayDataset\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__init__\u001b[39;49m\u001b[43m(\u001b[49m\n\u001b[1;32m     29\u001b[0m \u001b[43m        \u001b[49m\u001b[43mdata_root\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdata_root\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata_prefix\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdata_prefix\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpipeline\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpipeline\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/mmsegmentation/mmseg/datasets/basesegdataset.py:142\u001b[0m, in \u001b[0;36mBaseSegDataset.__init__\u001b[0;34m(self, ann_file, img_suffix, seg_map_suffix, metainfo, data_root, data_prefix, filter_cfg, indices, serialize_data, pipeline, test_mode, lazy_init, max_refetch, ignore_index, reduce_zero_label, backend_args)\u001b[0m\n\u001b[1;32m    140\u001b[0m \u001b[38;5;66;03m# Full initialize the dataset.\u001b[39;00m\n\u001b[1;32m    141\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m lazy_init:\n\u001b[0;32m--> 142\u001b[0m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfull_init\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    144\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m test_mode:\n\u001b[1;32m    145\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_metainfo\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mclasses\u001b[39m\u001b[38;5;124m'\u001b[39m) \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m, \\\n\u001b[1;32m    146\u001b[0m         \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdataset metainfo `classes` should be specified when testing\u001b[39m\u001b[38;5;124m'\u001b[39m\n",
-      "File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/mmengine/dataset/base_dataset.py:307\u001b[0m, in \u001b[0;36mBaseDataset.full_init\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    305\u001b[0m \u001b[38;5;66;03m# serialize data_list\u001b[39;00m\n\u001b[1;32m    306\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mserialize_data:\n\u001b[0;32m--> 307\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdata_bytes, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdata_address \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_serialize_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    309\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_fully_initialized \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n",
-      "File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/mmengine/dataset/base_dataset.py:767\u001b[0m, in \u001b[0;36mBaseDataset._serialize_data\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    765\u001b[0m data_address: np\u001b[38;5;241m.\u001b[39mndarray \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mcumsum(address_list)\n\u001b[1;32m    766\u001b[0m \u001b[38;5;66;03m# TODO Check if np.concatenate is necessary\u001b[39;00m\n\u001b[0;32m--> 767\u001b[0m data_bytes \u001b[38;5;241m=\u001b[39m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconcatenate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata_list\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    768\u001b[0m \u001b[38;5;66;03m# Empty cache for preventing making multiple copies of\u001b[39;00m\n\u001b[1;32m    769\u001b[0m \u001b[38;5;66;03m# `self.data_info` when loading data multi-processes.\u001b[39;00m\n\u001b[1;32m    770\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdata_list\u001b[38;5;241m.\u001b[39mclear()\n",
-      "\u001b[0;31mValueError\u001b[0m: need at least one array to concatenate"
-     ]
-    }
-   ],
-   "source": [
-    "dataset = XRayDataset(\n",
-    "    data_root=data_root,\n",
-    "    data_prefix=data_prefix,\n",
-    "    pipeline=train_pipeline\n",
-    ")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "base",
-   "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.10.13"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/mmsegmentation/tests/__init__.py b/mmsegmentation/tests/__init__.py
deleted file mode 100644
index ef101fe..0000000
--- a/mmsegmentation/tests/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
diff --git a/mmsegmentation/tests/test_apis/test_inferencer.py b/mmsegmentation/tests/test_apis/test_inferencer.py
deleted file mode 100644
index d8dbce8..0000000
--- a/mmsegmentation/tests/test_apis/test_inferencer.py
+++ /dev/null
@@ -1,60 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import tempfile
-
-import numpy as np
-import torch
-from mmengine import ConfigDict
-from utils import *  # noqa: F401, F403
-
-from mmseg.apis import MMSegInferencer
-from mmseg.registry import MODELS
-from mmseg.utils import register_all_modules
-
-
-def test_inferencer():
-    register_all_modules()
-
-    visualizer = dict(
-        type='SegLocalVisualizer',
-        vis_backends=[dict(type='LocalVisBackend')],
-        name='visualizer')
-
-    cfg_dict = dict(
-        model=dict(
-            type='InferExampleModel',
-            data_preprocessor=dict(type='SegDataPreProcessor'),
-            backbone=dict(type='InferExampleBackbone'),
-            decode_head=dict(type='InferExampleHead'),
-            test_cfg=dict(mode='whole')),
-        visualizer=visualizer,
-        test_dataloader=dict(
-            dataset=dict(
-                type='ExampleDataset',
-                pipeline=[
-                    dict(type='LoadImageFromFile'),
-                    dict(type='LoadAnnotations'),
-                    dict(type='PackSegInputs')
-                ]), ))
-    cfg = ConfigDict(cfg_dict)
-    model = MODELS.build(cfg.model)
-
-    ckpt = model.state_dict()
-    ckpt_filename = tempfile.mktemp()
-    torch.save(ckpt, ckpt_filename)
-
-    # test initialization
-    infer = MMSegInferencer(cfg, ckpt_filename)
-
-    # test forward
-    img = np.random.randint(0, 256, (4, 4, 3))
-    infer(img)
-
-    imgs = [img, img]
-    infer(imgs)
-    results = infer(imgs, out_dir=tempfile.gettempdir())
-
-    # test results
-    assert 'predictions' in results
-    assert 'visualization' in results
-    assert len(results['predictions']) == 2
-    assert results['predictions'][0].shape == (4, 4)
diff --git a/mmsegmentation/tests/test_apis/test_rs_inferencer.py b/mmsegmentation/tests/test_apis/test_rs_inferencer.py
deleted file mode 100644
index 03423d9..0000000
--- a/mmsegmentation/tests/test_apis/test_rs_inferencer.py
+++ /dev/null
@@ -1,73 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import os.path as osp
-from unittest import TestCase
-
-import numpy as np
-from mmengine import ConfigDict, init_default_scope
-from utils import *  # noqa: F401, F403
-
-from mmseg.apis import RSImage, RSInferencer
-from mmseg.registry import MODELS
-
-
-class TestRSImage(TestCase):
-
-    def test_read_whole_image(self):
-        init_default_scope('mmseg')
-        img_path = osp.join(
-            osp.dirname(__file__),
-            '../data/pseudo_loveda_dataset/img_dir/0.png')
-        rs_image = RSImage(img_path)
-        window_size = (16, 16)
-        rs_image.create_grids(window_size)
-        image_data = rs_image.read(rs_image.grids[0])
-        self.assertIsNotNone(image_data)
-
-    def test_write_image_data(self):
-        init_default_scope('mmseg')
-        img_path = osp.join(
-            osp.dirname(__file__),
-            '../data/pseudo_loveda_dataset/img_dir/0.png')
-        rs_image = RSImage(img_path)
-        window_size = (16, 16)
-        rs_image.create_grids(window_size)
-        data = np.random.random((16, 16)).astype(np.int8)
-        rs_image.write(data, rs_image.grids[0])
-
-
-class TestRSInferencer(TestCase):
-
-    def test_read_and_inference(self):
-        init_default_scope('mmseg')
-        cfg_dict = dict(
-            model=dict(
-                type='InferExampleModel',
-                data_preprocessor=dict(type='SegDataPreProcessor'),
-                backbone=dict(type='InferExampleBackbone'),
-                decode_head=dict(type='InferExampleHead'),
-                test_cfg=dict(mode='whole')),
-            test_dataloader=dict(
-                dataset=dict(
-                    type='ExampleDataset',
-                    pipeline=[
-                        dict(type='LoadImageFromFile'),
-                        dict(type='LoadAnnotations'),
-                        dict(type='PackSegInputs')
-                    ])),
-            test_pipeline=[
-                dict(type='LoadImageFromFile'),
-                dict(type='LoadAnnotations'),
-                dict(type='PackSegInputs')
-            ])
-        cfg = ConfigDict(cfg_dict)
-        model = MODELS.build(cfg.model)
-        model.cfg = cfg
-        inferencer = RSInferencer.from_model(model)
-
-        img_path = osp.join(
-            osp.dirname(__file__),
-            '../data/pseudo_loveda_dataset/img_dir/0.png')
-        rs_image = RSImage(img_path)
-        window_size = (16, 16)
-        stride = (16, 16)
-        inferencer.run(rs_image, window_size, stride)
diff --git a/mmsegmentation/tests/test_apis/utils.py b/mmsegmentation/tests/test_apis/utils.py
deleted file mode 100644
index 0a9928f..0000000
--- a/mmsegmentation/tests/test_apis/utils.py
+++ /dev/null
@@ -1,38 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch.nn as nn
-
-from mmseg.models import EncoderDecoder
-from mmseg.models.decode_heads.decode_head import BaseDecodeHead
-from mmseg.registry import MODELS
-
-
-@MODELS.register_module(name='InferExampleHead')
-class ExampleDecodeHead(BaseDecodeHead):
-
-    def __init__(self, num_classes=19, out_channels=None):
-        super().__init__(
-            3, 3, num_classes=num_classes, out_channels=out_channels)
-
-    def forward(self, inputs):
-        return self.cls_seg(inputs[0])
-
-
-@MODELS.register_module(name='InferExampleBackbone')
-class ExampleBackbone(nn.Module):
-
-    def __init__(self):
-        super().__init__()
-        self.conv = nn.Conv2d(3, 3, 3)
-
-    def init_weights(self, pretrained=None):
-        pass
-
-    def forward(self, x):
-        return [self.conv(x)]
-
-
-@MODELS.register_module(name='InferExampleModel')
-class ExampleModel(EncoderDecoder):
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
diff --git a/mmsegmentation/tests/test_config.py b/mmsegmentation/tests/test_config.py
deleted file mode 100644
index cdd85ff..0000000
--- a/mmsegmentation/tests/test_config.py
+++ /dev/null
@@ -1,175 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import glob
-import os
-from os.path import dirname, exists, isdir, join, relpath
-
-import numpy as np
-from mmengine import Config
-from mmengine.dataset import Compose
-from mmengine.registry import init_default_scope
-from torch import nn
-
-from mmseg.models import build_segmentor
-
-
-def _get_config_directory():
-    """Find the predefined segmentor config directory."""
-    try:
-        # Assume we are running in the source mmsegmentation repo
-        repo_dpath = dirname(dirname(__file__))
-    except NameError:
-        # For IPython development when this __file__ is not defined
-        import mmseg
-        repo_dpath = dirname(dirname(mmseg.__file__))
-    config_dpath = join(repo_dpath, 'configs')
-    if not exists(config_dpath):
-        raise Exception('Cannot find config path')
-    return config_dpath
-
-
-def test_config_build_segmentor():
-    """Test that all segmentation models defined in the configs can be
-    initialized."""
-    init_default_scope('mmseg')
-    config_dpath = _get_config_directory()
-    print(f'Found config_dpath = {config_dpath!r}')
-
-    config_fpaths = []
-    # one config each sub folder
-    for sub_folder in os.listdir(config_dpath):
-        if isdir(sub_folder):
-            config_fpaths.append(
-                list(glob.glob(join(config_dpath, sub_folder, '*.py')))[0])
-    config_fpaths = [p for p in config_fpaths if p.find('_base_') == -1]
-    config_names = [relpath(p, config_dpath) for p in config_fpaths]
-
-    print(f'Using {len(config_names)} config files')
-
-    for config_fname in config_names:
-        config_fpath = join(config_dpath, config_fname)
-        config_mod = Config.fromfile(config_fpath)
-
-        config_mod.model
-        print(f'Building segmentor, config_fpath = {config_fpath!r}')
-
-        # Remove pretrained keys to allow for testing in an offline environment
-        if 'pretrained' in config_mod.model:
-            config_mod.model['pretrained'] = None
-
-        print(f'building {config_fname}')
-        segmentor = build_segmentor(config_mod.model)
-        assert segmentor is not None
-
-        head_config = config_mod.model['decode_head']
-        _check_decode_head(head_config, segmentor.decode_head)
-
-
-def test_config_data_pipeline():
-    """Test whether the data pipeline is valid and can process corner cases.
-
-    CommandLine:
-        xdoctest -m tests/test_config.py test_config_build_data_pipeline
-    """
-
-    init_default_scope('mmseg')
-    config_dpath = _get_config_directory()
-    print(f'Found config_dpath = {config_dpath!r}')
-
-    import glob
-    config_fpaths = list(glob.glob(join(config_dpath, '**', '*.py')))
-    config_fpaths = [p for p in config_fpaths if p.find('_base_') == -1]
-    config_names = [relpath(p, config_dpath) for p in config_fpaths]
-
-    print(f'Using {len(config_names)} config files')
-
-    for config_fname in config_names:
-        config_fpath = join(config_dpath, config_fname)
-        print(f'Building data pipeline, config_fpath = {config_fpath!r}')
-        config_mod = Config.fromfile(config_fpath)
-
-        # remove loading pipeline
-        load_img_pipeline = config_mod.train_pipeline.pop(0)
-        to_float32 = load_img_pipeline.get('to_float32', False)
-        del config_mod.train_pipeline[0]
-        del config_mod.test_pipeline[0]
-        # remove loading annotation in test pipeline
-        load_anno_idx = -1
-        for i in range(len(config_mod.test_pipeline)):
-            if config_mod.test_pipeline[i].type in ('LoadAnnotations',
-                                                    'LoadDepthAnnotation'):
-                load_anno_idx = i
-        del config_mod.test_pipeline[load_anno_idx]
-
-        train_pipeline = Compose(config_mod.train_pipeline)
-        test_pipeline = Compose(config_mod.test_pipeline)
-
-        img = np.random.randint(0, 255, size=(1024, 2048, 3), dtype=np.uint8)
-        if to_float32:
-            img = img.astype(np.float32)
-        seg = np.random.randint(0, 255, size=(1024, 2048, 1), dtype=np.uint8)
-        depth = np.random.rand(1024, 2048).astype(np.float32)
-
-        results = dict(
-            filename='test_img.png',
-            ori_filename='test_img.png',
-            img=img,
-            img_shape=img.shape,
-            ori_shape=img.shape,
-            gt_seg_map=seg,
-            gt_depth_map=depth)
-        results['seg_fields'] = ['gt_seg_map']
-        _check_concat_cd_input(config_mod, results)
-        print(f'Test training data pipeline: \n{train_pipeline!r}')
-        output_results = train_pipeline(results)
-        assert output_results is not None
-
-        _check_concat_cd_input(config_mod, results)
-        print(f'Test testing data pipeline: \n{test_pipeline!r}')
-        output_results = test_pipeline(results)
-        assert output_results is not None
-
-
-def _check_concat_cd_input(config_mod: Config, results: dict):
-    keys = []
-    pipeline = config_mod.train_pipeline.copy()
-    pipeline.extend(config_mod.test_pipeline)
-    for t in pipeline:
-        keys.append(t.type)
-    if 'ConcatCDInput' in keys:
-        results.update({'img2': results['img']})
-
-
-def _check_decode_head(decode_head_cfg, decode_head):
-    if isinstance(decode_head_cfg, list):
-        assert isinstance(decode_head, nn.ModuleList)
-        assert len(decode_head_cfg) == len(decode_head)
-        num_heads = len(decode_head)
-        for i in range(num_heads):
-            _check_decode_head(decode_head_cfg[i], decode_head[i])
-        return
-    # check consistency between head_config and roi_head
-    assert decode_head_cfg['type'] == decode_head.__class__.__name__
-
-    assert decode_head_cfg['type'] == decode_head.__class__.__name__
-
-    in_channels = decode_head_cfg.in_channels
-    input_transform = decode_head.input_transform
-    assert input_transform in ['resize_concat', 'multiple_select', None]
-    if input_transform is not None:
-        assert isinstance(in_channels, (list, tuple))
-        assert isinstance(decode_head.in_index, (list, tuple))
-        assert len(in_channels) == len(decode_head.in_index)
-    elif input_transform == 'resize_concat':
-        assert sum(in_channels) == decode_head.in_channels
-    else:
-        assert in_channels == decode_head.in_channels
-
-    if decode_head_cfg['type'] == 'PointHead':
-        assert decode_head_cfg.channels+decode_head_cfg.num_classes == \
-               decode_head.fc_seg.in_channels
-        assert decode_head.fc_seg.out_channels == decode_head_cfg.num_classes
-    elif decode_head_cfg['type'] == 'VPDDepthHead':
-        assert decode_head.out_channels == 1
-    else:
-        assert decode_head_cfg.channels == decode_head.conv_seg.in_channels
-        assert decode_head.conv_seg.out_channels == decode_head_cfg.num_classes
diff --git a/mmsegmentation/tests/test_datasets/test_dataset.py b/mmsegmentation/tests/test_datasets/test_dataset.py
deleted file mode 100644
index 2904e09..0000000
--- a/mmsegmentation/tests/test_datasets/test_dataset.py
+++ /dev/null
@@ -1,475 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import os
-import os.path as osp
-import tempfile
-
-import pytest
-
-from mmseg.datasets import (ADE20KDataset, BaseSegDataset, BDD100KDataset,
-                            CityscapesDataset, COCOStuffDataset,
-                            DecathlonDataset, DSDLSegDataset, ISPRSDataset,
-                            LIPDataset, LoveDADataset, MapillaryDataset_v1,
-                            MapillaryDataset_v2, NYUDataset, PascalVOCDataset,
-                            PotsdamDataset, REFUGEDataset, SynapseDataset,
-                            iSAIDDataset)
-from mmseg.registry import DATASETS
-from mmseg.utils import get_classes, get_palette
-
-try:
-    from dsdl.dataset import DSDLDataset
-except ImportError:
-    DSDLDataset = None
-
-
-def test_classes():
-    assert list(
-        CityscapesDataset.METAINFO['classes']) == get_classes('cityscapes')
-    assert list(PascalVOCDataset.METAINFO['classes']) == get_classes(
-        'voc') == get_classes('pascal_voc')
-    assert list(ADE20KDataset.METAINFO['classes']) == get_classes(
-        'ade') == get_classes('ade20k')
-    assert list(
-        COCOStuffDataset.METAINFO['classes']) == get_classes('cocostuff')
-    assert list(LoveDADataset.METAINFO['classes']) == get_classes('loveda')
-    assert list(PotsdamDataset.METAINFO['classes']) == get_classes('potsdam')
-    assert list(ISPRSDataset.METAINFO['classes']) == get_classes('vaihingen')
-    assert list(iSAIDDataset.METAINFO['classes']) == get_classes('isaid')
-    assert list(
-        MapillaryDataset_v1.METAINFO['classes']) == get_classes('mapillary_v1')
-    assert list(
-        MapillaryDataset_v2.METAINFO['classes']) == get_classes('mapillary_v2')
-    assert list(BDD100KDataset.METAINFO['classes']) == get_classes('bdd100k')
-    with pytest.raises(ValueError):
-        get_classes('unsupported')
-
-
-def test_classes_file_path():
-    tmp_file = tempfile.NamedTemporaryFile()
-    classes_path = f'{tmp_file.name}.txt'
-    train_pipeline = []
-    kwargs = dict(
-        pipeline=train_pipeline,
-        data_prefix=dict(img_path='./', seg_map_path='./'),
-        metainfo=dict(classes=classes_path))
-
-    # classes.txt with full categories
-    categories = get_classes('cityscapes')
-    with open(classes_path, 'w') as f:
-        f.write('\n'.join(categories))
-    dataset = CityscapesDataset(**kwargs)
-    assert list(dataset.metainfo['classes']) == categories
-    assert dataset.label_map is None
-
-    # classes.txt with sub categories
-    categories = ['road', 'sidewalk', 'building']
-    with open(classes_path, 'w') as f:
-        f.write('\n'.join(categories))
-    dataset = CityscapesDataset(**kwargs)
-    assert list(dataset.metainfo['classes']) == categories
-    assert dataset.label_map is not None
-
-    # classes.txt with unknown categories
-    categories = ['road', 'sidewalk', 'unknown']
-    with open(classes_path, 'w') as f:
-        f.write('\n'.join(categories))
-
-    with pytest.raises(ValueError):
-        CityscapesDataset(**kwargs)
-
-    tmp_file.close()
-    os.remove(classes_path)
-    assert not osp.exists(classes_path)
-
-
-def test_palette():
-    assert CityscapesDataset.METAINFO['palette'] == get_palette('cityscapes')
-    assert PascalVOCDataset.METAINFO['palette'] == get_palette(
-        'voc') == get_palette('pascal_voc')
-    assert ADE20KDataset.METAINFO['palette'] == get_palette(
-        'ade') == get_palette('ade20k')
-    assert LoveDADataset.METAINFO['palette'] == get_palette('loveda')
-    assert PotsdamDataset.METAINFO['palette'] == get_palette('potsdam')
-    assert COCOStuffDataset.METAINFO['palette'] == get_palette('cocostuff')
-    assert iSAIDDataset.METAINFO['palette'] == get_palette('isaid')
-    assert list(
-        MapillaryDataset_v1.METAINFO['palette']) == get_palette('mapillary_v1')
-    assert list(
-        MapillaryDataset_v2.METAINFO['palette']) == get_palette('mapillary_v2')
-    assert list(BDD100KDataset.METAINFO['palette']) == get_palette('bdd100k')
-    with pytest.raises(ValueError):
-        get_palette('unsupported')
-
-
-def test_custom_dataset():
-
-    # with 'img_path' and 'seg_map_path' in data_prefix
-    train_dataset = BaseSegDataset(
-        data_root=osp.join(osp.dirname(__file__), '../data/pseudo_dataset'),
-        data_prefix=dict(
-            img_path='imgs/',
-            seg_map_path='gts/',
-        ),
-        img_suffix='img.jpg',
-        seg_map_suffix='gt.png')
-    assert len(train_dataset) == 5
-
-    # with 'img_path' and 'seg_map_path' in data_prefix and ann_file
-    train_dataset = BaseSegDataset(
-        data_root=osp.join(osp.dirname(__file__), '../data/pseudo_dataset'),
-        data_prefix=dict(
-            img_path='imgs/',
-            seg_map_path='gts/',
-        ),
-        img_suffix='img.jpg',
-        seg_map_suffix='gt.png',
-        ann_file='splits/train.txt')
-    assert len(train_dataset) == 4
-
-    # no data_root
-    train_dataset = BaseSegDataset(
-        data_prefix=dict(
-            img_path=osp.join(
-                osp.dirname(__file__), '../data/pseudo_dataset/imgs'),
-            seg_map_path=osp.join(
-                osp.dirname(__file__), '../data/pseudo_dataset/gts')),
-        img_suffix='img.jpg',
-        seg_map_suffix='gt.png')
-    assert len(train_dataset) == 5
-
-    # with data_root but 'img_path' and 'seg_map_path' in data_prefix are
-    # abs path
-    train_dataset = BaseSegDataset(
-        data_root=osp.join(osp.dirname(__file__), '../data/pseudo_dataset'),
-        data_prefix=dict(
-            img_path=osp.join(
-                osp.dirname(__file__), '../data/pseudo_dataset/imgs'),
-            seg_map_path=osp.join(
-                osp.dirname(__file__), '../data/pseudo_dataset/gts')),
-        img_suffix='img.jpg',
-        seg_map_suffix='gt.png')
-    assert len(train_dataset) == 5
-
-    # test_mode=True
-    test_dataset = BaseSegDataset(
-        data_prefix=dict(
-            img_path=osp.join(
-                osp.dirname(__file__), '../data/pseudo_dataset/imgs')),
-        img_suffix='img.jpg',
-        test_mode=True,
-        metainfo=dict(classes=('pseudo_class', )))
-    assert len(test_dataset) == 5
-
-    # training data get
-    train_data = train_dataset[0]
-    assert isinstance(train_data, dict)
-    assert 'img_path' in train_data and osp.isfile(train_data['img_path'])
-    assert 'seg_map_path' in train_data and osp.isfile(
-        train_data['seg_map_path'])
-
-    # test data get
-    test_data = test_dataset[0]
-    assert isinstance(test_data, dict)
-    assert 'img_path' in train_data and osp.isfile(train_data['img_path'])
-    assert 'seg_map_path' in train_data and osp.isfile(
-        train_data['seg_map_path'])
-
-
-def test_ade():
-    test_dataset = ADE20KDataset(
-        pipeline=[],
-        data_prefix=dict(
-            img_path=osp.join(
-                osp.dirname(__file__), '../data/pseudo_dataset/imgs')))
-    assert len(test_dataset) == 5
-
-
-def test_cityscapes():
-    test_dataset = CityscapesDataset(
-        pipeline=[],
-        data_prefix=dict(
-            img_path=osp.join(
-                osp.dirname(__file__),
-                '../data/pseudo_cityscapes_dataset/leftImg8bit/val'),
-            seg_map_path=osp.join(
-                osp.dirname(__file__),
-                '../data/pseudo_cityscapes_dataset/gtFine/val')))
-    assert len(test_dataset) == 1
-
-
-def test_loveda():
-    test_dataset = LoveDADataset(
-        pipeline=[],
-        data_prefix=dict(
-            img_path=osp.join(
-                osp.dirname(__file__),
-                '../data/pseudo_loveda_dataset/img_dir'),
-            seg_map_path=osp.join(
-                osp.dirname(__file__),
-                '../data/pseudo_loveda_dataset/ann_dir')))
-    assert len(test_dataset) == 3
-
-
-def test_potsdam():
-    test_dataset = PotsdamDataset(
-        pipeline=[],
-        data_prefix=dict(
-            img_path=osp.join(
-                osp.dirname(__file__),
-                '../data/pseudo_potsdam_dataset/img_dir'),
-            seg_map_path=osp.join(
-                osp.dirname(__file__),
-                '../data/pseudo_potsdam_dataset/ann_dir')))
-    assert len(test_dataset) == 1
-
-
-def test_vaihingen():
-    test_dataset = ISPRSDataset(
-        pipeline=[],
-        data_prefix=dict(
-            img_path=osp.join(
-                osp.dirname(__file__),
-                '../data/pseudo_vaihingen_dataset/img_dir'),
-            seg_map_path=osp.join(
-                osp.dirname(__file__),
-                '../data/pseudo_vaihingen_dataset/ann_dir')))
-    assert len(test_dataset) == 1
-
-
-def test_synapse():
-    test_dataset = SynapseDataset(
-        pipeline=[],
-        data_prefix=dict(
-            img_path=osp.join(
-                osp.dirname(__file__),
-                '../data/pseudo_synapse_dataset/img_dir'),
-            seg_map_path=osp.join(
-                osp.dirname(__file__),
-                '../data/pseudo_synapse_dataset/ann_dir')))
-    assert len(test_dataset) == 2
-
-
-def test_refuge():
-    test_dataset = REFUGEDataset(
-        pipeline=[],
-        data_prefix=dict(
-            img_path=osp.join(
-                osp.dirname(__file__),
-                '../data/pseudo_refuge_dataset/img_dir'),
-            seg_map_path=osp.join(
-                osp.dirname(__file__),
-                '../data/pseudo_refuge_dataset/ann_dir')))
-    assert len(test_dataset) == 1
-
-
-def test_isaid():
-    test_dataset = iSAIDDataset(
-        pipeline=[],
-        data_prefix=dict(
-            img_path=osp.join(
-                osp.dirname(__file__), '../data/pseudo_isaid_dataset/img_dir'),
-            seg_map_path=osp.join(
-                osp.dirname(__file__),
-                '../data/pseudo_isaid_dataset/ann_dir')))
-    assert len(test_dataset) == 2
-    test_dataset = iSAIDDataset(
-        data_prefix=dict(
-            img_path=osp.join(
-                osp.dirname(__file__), '../data/pseudo_isaid_dataset/img_dir'),
-            seg_map_path=osp.join(
-                osp.dirname(__file__),
-                '../data/pseudo_isaid_dataset/ann_dir')),
-        ann_file=osp.join(
-            osp.dirname(__file__),
-            '../data/pseudo_isaid_dataset/splits/train.txt'))
-    assert len(test_dataset) == 1
-
-
-def test_decathlon():
-    data_root = osp.join(osp.dirname(__file__), '../data')
-    # test load training dataset
-    test_dataset = DecathlonDataset(
-        pipeline=[], data_root=data_root, ann_file='dataset.json')
-    assert len(test_dataset) == 1
-
-    # test load test dataset
-    test_dataset = DecathlonDataset(
-        pipeline=[],
-        data_root=data_root,
-        ann_file='dataset.json',
-        test_mode=True)
-    assert len(test_dataset) == 3
-
-
-def test_lip():
-    data_root = osp.join(osp.dirname(__file__), '../data/pseudo_lip_dataset')
-    # train load training dataset
-    train_dataset = LIPDataset(
-        pipeline=[],
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='train_images', seg_map_path='train_segmentations'))
-    assert len(train_dataset) == 1
-
-    # test load training dataset
-    test_dataset = LIPDataset(
-        pipeline=[],
-        data_root=data_root,
-        data_prefix=dict(
-            img_path='val_images', seg_map_path='val_segmentations'))
-    assert len(test_dataset) == 1
-
-
-def test_mapillary():
-    test_dataset = MapillaryDataset_v1(
-        pipeline=[],
-        data_prefix=dict(
-            img_path=osp.join(
-                osp.dirname(__file__),
-                '../data/pseudo_mapillary_dataset/images'),
-            seg_map_path=osp.join(
-                osp.dirname(__file__),
-                '../data/pseudo_mapillary_dataset/v1.2')))
-    assert len(test_dataset) == 1
-
-
-def test_bdd100k():
-    test_dataset = BDD100KDataset(
-        pipeline=[],
-        data_prefix=dict(
-            img_path=osp.join(
-                osp.dirname(__file__),
-                '../data/pseudo_bdd100k_dataset/images/10k/val'),
-            seg_map_path=osp.join(
-                osp.dirname(__file__),
-                '../data/pseudo_bdd100k_dataset/labels/sem_seg/masks/val')))
-    assert len(test_dataset) == 3
-
-
-@pytest.mark.parametrize('dataset, classes', [
-    ('ADE20KDataset', ('wall', 'building')),
-    ('CityscapesDataset', ('road', 'sidewalk')),
-    ('BaseSegDataset', ('bus', 'car')),
-    ('PascalVOCDataset', ('aeroplane', 'bicycle')),
-])
-def test_custom_classes_override_default(dataset, classes):
-
-    dataset_class = DATASETS.get(dataset)
-    original_classes = dataset_class.METAINFO.get('classes', None)
-
-    tmp_file = tempfile.NamedTemporaryFile()
-    ann_file = tmp_file.name
-    img_path = tempfile.mkdtemp()
-
-    # Test setting classes as a tuple
-    custom_dataset = dataset_class(
-        data_prefix=dict(img_path=img_path),
-        ann_file=ann_file,
-        metainfo=dict(classes=classes),
-        test_mode=True,
-        lazy_init=True)
-
-    assert custom_dataset.metainfo['classes'] != original_classes
-    assert custom_dataset.metainfo['classes'] == classes
-    if not isinstance(custom_dataset, BaseSegDataset):
-        assert isinstance(custom_dataset.label_map, dict)
-
-    # Test setting classes as a list
-    custom_dataset = dataset_class(
-        data_prefix=dict(img_path=img_path),
-        ann_file=ann_file,
-        metainfo=dict(classes=list(classes)),
-        test_mode=True,
-        lazy_init=True)
-
-    assert custom_dataset.metainfo['classes'] != original_classes
-    assert custom_dataset.metainfo['classes'] == list(classes)
-    if not isinstance(custom_dataset, BaseSegDataset):
-        assert isinstance(custom_dataset.label_map, dict)
-
-    # Test overriding not a subset
-    custom_dataset = dataset_class(
-        ann_file=ann_file,
-        data_prefix=dict(img_path=img_path),
-        metainfo=dict(classes=[classes[0]]),
-        test_mode=True,
-        lazy_init=True)
-
-    assert custom_dataset.metainfo['classes'] != original_classes
-    assert custom_dataset.metainfo['classes'] == [classes[0]]
-    if not isinstance(custom_dataset, BaseSegDataset):
-        assert isinstance(custom_dataset.label_map, dict)
-
-    # Test default behavior
-    if dataset_class is BaseSegDataset:
-        with pytest.raises(AssertionError):
-            custom_dataset = dataset_class(
-                ann_file=ann_file,
-                data_prefix=dict(img_path=img_path),
-                metainfo=None,
-                test_mode=True,
-                lazy_init=True)
-    else:
-        custom_dataset = dataset_class(
-            data_prefix=dict(img_path=img_path),
-            ann_file=ann_file,
-            metainfo=None,
-            test_mode=True,
-            lazy_init=True)
-
-        assert custom_dataset.METAINFO['classes'] == original_classes
-        assert custom_dataset.label_map is None
-
-
-def test_custom_dataset_random_palette_is_generated():
-    dataset = BaseSegDataset(
-        pipeline=[],
-        data_prefix=dict(img_path=tempfile.mkdtemp()),
-        ann_file=tempfile.mkdtemp(),
-        metainfo=dict(classes=('bus', 'car')),
-        lazy_init=True,
-        test_mode=True)
-    assert len(dataset.metainfo['palette']) == 2
-    for class_color in dataset.metainfo['palette']:
-        assert len(class_color) == 3
-        assert all(x >= 0 and x <= 255 for x in class_color)
-
-
-def test_custom_dataset_custom_palette():
-    dataset = BaseSegDataset(
-        data_prefix=dict(img_path=tempfile.mkdtemp()),
-        ann_file=tempfile.mkdtemp(),
-        metainfo=dict(
-            classes=('bus', 'car'), palette=[[100, 100, 100], [200, 200,
-                                                               200]]),
-        lazy_init=True,
-        test_mode=True)
-    assert tuple(dataset.metainfo['palette']) == tuple([[100, 100, 100],
-                                                        [200, 200, 200]])
-    # test custom class and palette don't match
-    with pytest.raises(ValueError):
-        dataset = BaseSegDataset(
-            data_prefix=dict(img_path=tempfile.mkdtemp()),
-            ann_file=tempfile.mkdtemp(),
-            metainfo=dict(classes=('bus', 'car'), palette=[[200, 200, 200]]),
-            lazy_init=True)
-
-
-def test_dsdlseg_dataset():
-    if DSDLDataset is not None:
-        dataset = DSDLSegDataset(
-            data_root='tests/data/dsdl_seg', ann_file='set-train/train.yaml')
-        assert len(dataset) == 3
-        assert len(dataset.metainfo['classes']) == 21
-    else:
-        ImportWarning('Package `dsdl` is not installed.')
-
-
-def test_nyu_dataset():
-    dataset = NYUDataset(
-        data_root='tests/data/pseudo_nyu_dataset',
-        data_prefix=dict(img_path='images', depth_map_path='annotations'),
-    )
-    assert len(dataset) == 1
-    data = dataset[0]
-    assert data.get('depth_map_path', None) is not None
-    assert data.get('category_id', -1) == 26
diff --git a/mmsegmentation/tests/test_datasets/test_dataset_builder.py b/mmsegmentation/tests/test_datasets/test_dataset_builder.py
deleted file mode 100644
index b67b1e7..0000000
--- a/mmsegmentation/tests/test_datasets/test_dataset_builder.py
+++ /dev/null
@@ -1,152 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import os.path as osp
-
-from mmengine.dataset import ConcatDataset, RepeatDataset
-from mmengine.registry import init_default_scope
-
-from mmseg.datasets import MultiImageMixDataset
-from mmseg.registry import DATASETS
-
-init_default_scope('mmseg')
-
-
-@DATASETS.register_module()
-class ToyDataset:
-
-    def __init__(self, cnt=0):
-        self.cnt = cnt
-
-    def __item__(self, idx):
-        return idx
-
-    def __len__(self):
-        return 100
-
-
-def test_build_dataset():
-    cfg = dict(type='ToyDataset')
-    dataset = DATASETS.build(cfg)
-    assert isinstance(dataset, ToyDataset)
-    assert dataset.cnt == 0
-    dataset = DATASETS.build(cfg, default_args=dict(cnt=1))
-    assert isinstance(dataset, ToyDataset)
-    assert dataset.cnt == 1
-
-    data_root = osp.join(osp.dirname(__file__), '../data/pseudo_dataset')
-    data_prefix = dict(img_path='imgs/', seg_map_path='gts/')
-
-    # test RepeatDataset
-    cfg = dict(
-        type='BaseSegDataset',
-        pipeline=[],
-        data_root=data_root,
-        data_prefix=data_prefix,
-        serialize_data=False)
-    dataset = DATASETS.build(cfg)
-    dataset_repeat = RepeatDataset(dataset=dataset, times=5)
-    assert isinstance(dataset_repeat, RepeatDataset)
-    assert len(dataset_repeat) == 25
-
-    # test ConcatDataset
-    # We use same dir twice for simplicity
-    # with data_prefix.seg_map_path
-    cfg1 = dict(
-        type='BaseSegDataset',
-        pipeline=[],
-        data_root=data_root,
-        data_prefix=data_prefix,
-        serialize_data=False)
-    cfg2 = dict(
-        type='BaseSegDataset',
-        pipeline=[],
-        data_root=data_root,
-        data_prefix=data_prefix,
-        serialize_data=False)
-    dataset1 = DATASETS.build(cfg1)
-    dataset2 = DATASETS.build(cfg2)
-    dataset_concat = ConcatDataset(datasets=[dataset1, dataset2])
-    assert isinstance(dataset_concat, ConcatDataset)
-    assert len(dataset_concat) == 10
-
-    # test MultiImageMixDataset
-    dataset = MultiImageMixDataset(dataset=dataset_concat, pipeline=[])
-    assert isinstance(dataset, MultiImageMixDataset)
-    assert len(dataset) == 10
-
-    cfg = dict(type='ConcatDataset', datasets=[cfg1, cfg2])
-
-    dataset = MultiImageMixDataset(dataset=cfg, pipeline=[])
-    assert isinstance(dataset, MultiImageMixDataset)
-    assert len(dataset) == 10
-
-    # with data_prefix.seg_map_path, ann_file
-    cfg1 = dict(
-        type='BaseSegDataset',
-        pipeline=[],
-        data_root=data_root,
-        data_prefix=data_prefix,
-        ann_file='splits/train.txt',
-        serialize_data=False)
-    cfg2 = dict(
-        type='BaseSegDataset',
-        pipeline=[],
-        data_root=data_root,
-        data_prefix=data_prefix,
-        ann_file='splits/val.txt',
-        serialize_data=False)
-
-    dataset1 = DATASETS.build(cfg1)
-    dataset2 = DATASETS.build(cfg2)
-    dataset_concat = ConcatDataset(datasets=[dataset1, dataset2])
-    assert isinstance(dataset_concat, ConcatDataset)
-    assert len(dataset_concat) == 5
-
-    # test mode
-    cfg1 = dict(
-        type='BaseSegDataset',
-        pipeline=[],
-        data_root=data_root,
-        data_prefix=dict(img_path='imgs/'),
-        test_mode=True,
-        metainfo=dict(classes=('pseudo_class', )),
-        serialize_data=False)
-    cfg2 = dict(
-        type='BaseSegDataset',
-        pipeline=[],
-        data_root=data_root,
-        data_prefix=dict(img_path='imgs/'),
-        test_mode=True,
-        metainfo=dict(classes=('pseudo_class', )),
-        serialize_data=False)
-
-    dataset1 = DATASETS.build(cfg1)
-    dataset2 = DATASETS.build(cfg2)
-    dataset_concat = ConcatDataset(datasets=[dataset1, dataset2])
-    assert isinstance(dataset_concat, ConcatDataset)
-    assert len(dataset_concat) == 10
-
-    # test mode with ann_files
-    cfg1 = dict(
-        type='BaseSegDataset',
-        pipeline=[],
-        data_root=data_root,
-        data_prefix=dict(img_path='imgs/'),
-        ann_file='splits/val.txt',
-        test_mode=True,
-        metainfo=dict(classes=('pseudo_class', )),
-        serialize_data=False)
-    cfg2 = dict(
-        type='BaseSegDataset',
-        pipeline=[],
-        data_root=data_root,
-        data_prefix=dict(img_path='imgs/'),
-        ann_file='splits/val.txt',
-        test_mode=True,
-        metainfo=dict(classes=('pseudo_class', )),
-        serialize_data=False)
-
-    dataset1 = DATASETS.build(cfg1)
-    dataset2 = DATASETS.build(cfg2)
-    dataset_concat = ConcatDataset(datasets=[dataset1, dataset2])
-    assert isinstance(dataset_concat, ConcatDataset)
-    assert len(dataset_concat) == 2
diff --git a/mmsegmentation/tests/test_datasets/test_formatting.py b/mmsegmentation/tests/test_datasets/test_formatting.py
deleted file mode 100644
index d0e5820..0000000
--- a/mmsegmentation/tests/test_datasets/test_formatting.py
+++ /dev/null
@@ -1,61 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import copy
-import os.path as osp
-import unittest
-
-import numpy as np
-import pytest
-from mmengine.structures import BaseDataElement
-
-from mmseg.datasets.transforms import PackSegInputs
-from mmseg.structures import SegDataSample
-
-
-class TestPackSegInputs(unittest.TestCase):
-
-    def setUp(self):
-        """Setup the model and optimizer which are used in every test method.
-
-        TestCase calls functions in this order: setUp() -> testMethod() ->
-        tearDown() -> cleanUp()
-        """
-        data_prefix = osp.join(osp.dirname(__file__), '../../data')
-        img_path = osp.join(data_prefix, 'color.jpg')
-        rng = np.random.RandomState(0)
-        self.results = {
-            'img_path': img_path,
-            'ori_shape': (300, 400),
-            'pad_shape': (600, 800),
-            'img_shape': (600, 800),
-            'scale_factor': 2.0,
-            'flip': False,
-            'flip_direction': 'horizontal',
-            'img_norm_cfg': None,
-            'img': rng.rand(300, 400),
-            'gt_seg_map': rng.rand(300, 400),
-        }
-        self.meta_keys = ('img_path', 'ori_shape', 'img_shape', 'pad_shape',
-                          'scale_factor', 'flip', 'flip_direction')
-
-    def test_transform(self):
-        transform = PackSegInputs(meta_keys=self.meta_keys)
-        results = transform(copy.deepcopy(self.results))
-        self.assertIn('data_samples', results)
-        self.assertIsInstance(results['data_samples'], SegDataSample)
-        self.assertIsInstance(results['data_samples'].gt_sem_seg,
-                              BaseDataElement)
-        self.assertEqual(results['data_samples'].ori_shape,
-                         results['data_samples'].gt_sem_seg.shape)
-        results = copy.deepcopy(self.results)
-        # test dataset shape is not 2D
-        results['gt_seg_map'] = np.random.rand(3, 300, 400)
-        msg = 'the segmentation map is 2D'
-        with pytest.warns(UserWarning, match=msg):
-            results = transform(results)
-        self.assertEqual(results['data_samples'].ori_shape,
-                         results['data_samples'].gt_sem_seg.shape)
-
-    def test_repr(self):
-        transform = PackSegInputs(meta_keys=self.meta_keys)
-        self.assertEqual(
-            repr(transform), f'PackSegInputs(meta_keys={self.meta_keys})')
diff --git a/mmsegmentation/tests/test_datasets/test_loading.py b/mmsegmentation/tests/test_datasets/test_loading.py
deleted file mode 100644
index 3eea6e3..0000000
--- a/mmsegmentation/tests/test_datasets/test_loading.py
+++ /dev/null
@@ -1,295 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import copy
-import os.path as osp
-import tempfile
-
-import mmcv
-import numpy as np
-from mmcv.transforms import LoadImageFromFile
-
-from mmseg.datasets.transforms import LoadAnnotations  # noqa
-from mmseg.datasets.transforms import (LoadBiomedicalAnnotation,
-                                       LoadBiomedicalData,
-                                       LoadBiomedicalImageFromFile,
-                                       LoadDepthAnnotation,
-                                       LoadImageFromNDArray)
-
-
-class TestLoading:
-
-    @classmethod
-    def setup_class(cls):
-        cls.data_prefix = osp.join(osp.dirname(__file__), '../data')
-
-    def test_load_img(self):
-        results = dict(img_path=osp.join(self.data_prefix, 'color.jpg'))
-        transform = LoadImageFromFile()
-        results = transform(copy.deepcopy(results))
-        assert results['img_path'] == osp.join(self.data_prefix, 'color.jpg')
-        assert results['img'].shape == (288, 512, 3)
-        assert results['img'].dtype == np.uint8
-        assert results['ori_shape'] == results['img'].shape[:2]
-        assert repr(transform) == transform.__class__.__name__ + \
-               "(ignore_empty=False, to_float32=False, color_type='color'," + \
-               " imdecode_backend='cv2', backend_args=None)"
-
-        # to_float32
-        transform = LoadImageFromFile(to_float32=True)
-        results = transform(copy.deepcopy(results))
-        assert results['img'].dtype == np.float32
-
-        # gray image
-        results = dict(img_path=osp.join(self.data_prefix, 'gray.jpg'))
-        transform = LoadImageFromFile()
-        results = transform(copy.deepcopy(results))
-        assert results['img'].shape == (288, 512, 3)
-        assert results['img'].dtype == np.uint8
-
-        transform = LoadImageFromFile(color_type='unchanged')
-        results = transform(copy.deepcopy(results))
-        assert results['img'].shape == (288, 512)
-        assert results['img'].dtype == np.uint8
-
-    def test_load_seg(self):
-        seg_path = osp.join(self.data_prefix, 'seg.png')
-        results = dict(
-            seg_map_path=seg_path, reduce_zero_label=True, seg_fields=[])
-        transform = LoadAnnotations()
-        results = transform(copy.deepcopy(results))
-        assert results['gt_seg_map'].shape == (288, 512)
-        assert results['gt_seg_map'].dtype == np.uint8
-        assert repr(transform) == transform.__class__.__name__ + \
-            "(reduce_zero_label=True, imdecode_backend='pillow', " + \
-            'backend_args=None)'
-
-        # reduce_zero_label
-        transform = LoadAnnotations(reduce_zero_label=True)
-        results = transform(copy.deepcopy(results))
-        assert results['gt_seg_map'].shape == (288, 512)
-        assert results['gt_seg_map'].dtype == np.uint8
-
-    def test_load_seg_custom_classes(self):
-
-        test_img = np.random.rand(10, 10)
-        test_gt = np.zeros_like(test_img)
-        test_gt[2:4, 2:4] = 1
-        test_gt[2:4, 6:8] = 2
-        test_gt[6:8, 2:4] = 3
-        test_gt[6:8, 6:8] = 4
-
-        tmp_dir = tempfile.TemporaryDirectory()
-        img_path = osp.join(tmp_dir.name, 'img.jpg')
-        gt_path = osp.join(tmp_dir.name, 'gt.png')
-
-        mmcv.imwrite(test_img, img_path)
-        mmcv.imwrite(test_gt, gt_path)
-
-        # test only train with label with id 3
-        results = dict(
-            img_path=img_path,
-            seg_map_path=gt_path,
-            label_map={
-                0: 0,
-                1: 0,
-                2: 0,
-                3: 1,
-                4: 0
-            },
-            reduce_zero_label=False,
-            seg_fields=[])
-
-        load_imgs = LoadImageFromFile()
-        results = load_imgs(copy.deepcopy(results))
-
-        load_anns = LoadAnnotations()
-        results = load_anns(copy.deepcopy(results))
-
-        gt_array = results['gt_seg_map']
-
-        true_mask = np.zeros_like(gt_array)
-        true_mask[6:8, 2:4] = 1
-
-        assert results['seg_fields'] == ['gt_seg_map']
-        assert gt_array.shape == (10, 10)
-        assert gt_array.dtype == np.uint8
-        np.testing.assert_array_equal(gt_array, true_mask)
-
-        # test only train with label with id 4 and 3
-        results = dict(
-            img_path=osp.join(self.data_prefix, 'color.jpg'),
-            seg_map_path=gt_path,
-            label_map={
-                0: 0,
-                1: 0,
-                2: 0,
-                3: 2,
-                4: 1
-            },
-            reduce_zero_label=False,
-            seg_fields=[])
-
-        load_imgs = LoadImageFromFile()
-        results = load_imgs(copy.deepcopy(results))
-
-        load_anns = LoadAnnotations()
-        results = load_anns(copy.deepcopy(results))
-
-        gt_array = results['gt_seg_map']
-
-        true_mask = np.zeros_like(gt_array)
-        true_mask[6:8, 2:4] = 2
-        true_mask[6:8, 6:8] = 1
-
-        assert results['seg_fields'] == ['gt_seg_map']
-        assert gt_array.shape == (10, 10)
-        assert gt_array.dtype == np.uint8
-        np.testing.assert_array_equal(gt_array, true_mask)
-
-        # test with removing a class and reducing zero label simultaneously
-        results = dict(
-            img_path=img_path,
-            seg_map_path=gt_path,
-            # since reduce_zero_label is True, there are only 4 real classes.
-            # if the full set of classes is ["A", "B", "C", "D"], the
-            # following label map simulates the dataset option
-            # classes=["A", "C", "D"] which removes class "B".
-            label_map={
-                0: 0,
-                1: 255,  # simulate removing class 1
-                2: 1,
-                3: 2
-            },
-            reduce_zero_label=True,  # reduce zero label
-            seg_fields=[])
-
-        load_imgs = LoadImageFromFile()
-        results = load_imgs(copy.deepcopy(results))
-
-        # reduce zero label
-        load_anns = LoadAnnotations()
-        results = load_anns(copy.deepcopy(results))
-
-        gt_array = results['gt_seg_map']
-
-        true_mask = np.ones_like(gt_array) * 255  # all zeros get mapped to 255
-        true_mask[2:4, 2:4] = 0  # 1s are reduced to class 0 mapped to class 0
-        true_mask[2:4, 6:8] = 255  # 2s are reduced to class 1 which is removed
-        true_mask[6:8, 2:4] = 1  # 3s are reduced to class 2 mapped to class 1
-        true_mask[6:8, 6:8] = 2  # 4s are reduced to class 3 mapped to class 2
-
-        assert results['seg_fields'] == ['gt_seg_map']
-        assert gt_array.shape == (10, 10)
-        assert gt_array.dtype == np.uint8
-        np.testing.assert_array_equal(gt_array, true_mask)
-
-        # test no custom classes
-        results = dict(
-            img_path=img_path,
-            seg_map_path=gt_path,
-            reduce_zero_label=False,
-            seg_fields=[])
-
-        load_imgs = LoadImageFromFile()
-        results = load_imgs(copy.deepcopy(results))
-
-        load_anns = LoadAnnotations()
-        results = load_anns(copy.deepcopy(results))
-
-        gt_array = results['gt_seg_map']
-
-        assert results['seg_fields'] == ['gt_seg_map']
-        assert gt_array.shape == (10, 10)
-        assert gt_array.dtype == np.uint8
-        np.testing.assert_array_equal(gt_array, test_gt)
-
-        tmp_dir.cleanup()
-
-    def test_load_image_from_ndarray(self):
-        results = {'img': np.zeros((256, 256, 3), dtype=np.uint8)}
-        transform = LoadImageFromNDArray()
-        results = transform(results)
-
-        assert results['img'].shape == (256, 256, 3)
-        assert results['img'].dtype == np.uint8
-        assert results['img_shape'] == (256, 256)
-        assert results['ori_shape'] == (256, 256)
-
-        # to_float32
-        transform = LoadImageFromNDArray(to_float32=True)
-        results = transform(copy.deepcopy(results))
-        assert results['img'].dtype == np.float32
-
-        # test repr
-        transform = LoadImageFromNDArray()
-        assert repr(transform) == ('LoadImageFromNDArray('
-                                   'ignore_empty=False, '
-                                   'to_float32=False, '
-                                   "color_type='color', "
-                                   "imdecode_backend='cv2', "
-                                   'backend_args=None)')
-
-    def test_load_biomedical_img(self):
-        results = dict(
-            img_path=osp.join(self.data_prefix, 'biomedical.nii.gz'))
-        transform = LoadBiomedicalImageFromFile()
-        results = transform(copy.deepcopy(results))
-        assert results['img_path'] == osp.join(self.data_prefix,
-                                               'biomedical.nii.gz')
-        assert len(results['img'].shape) == 4
-        assert results['img'].dtype == np.float32
-        assert results['ori_shape'] == results['img'].shape[1:]
-        assert repr(transform) == ('LoadBiomedicalImageFromFile('
-                                   "decode_backend='nifti', "
-                                   'to_xyz=False, '
-                                   'to_float32=True, '
-                                   'backend_args=None)')
-
-    def test_load_biomedical_annotation(self):
-        results = dict(
-            seg_map_path=osp.join(self.data_prefix, 'biomedical_ann.nii.gz'))
-        transform = LoadBiomedicalAnnotation()
-        results = transform(copy.deepcopy(results))
-        assert len(results['gt_seg_map'].shape) == 3
-        assert results['gt_seg_map'].dtype == np.float32
-
-    def test_load_biomedical_data(self):
-        input_results = dict(
-            img_path=osp.join(self.data_prefix, 'biomedical.npy'))
-        transform = LoadBiomedicalData(with_seg=True)
-        results = transform(copy.deepcopy(input_results))
-        assert results['img_path'] == osp.join(self.data_prefix,
-                                               'biomedical.npy')
-        assert results['img'][0].shape == results['gt_seg_map'].shape
-        assert results['img'].dtype == np.float32
-        assert results['ori_shape'] == results['img'].shape[1:]
-        assert repr(transform) == ('LoadBiomedicalData('
-                                   'with_seg=True, '
-                                   "decode_backend='numpy', "
-                                   'to_xyz=False, '
-                                   'backend_args=None)')
-
-        transform = LoadBiomedicalData(with_seg=False)
-        results = transform(copy.deepcopy(input_results))
-        assert len(results['img'].shape) == 4
-        assert results.get('gt_seg_map') is None
-        assert repr(transform) == ('LoadBiomedicalData('
-                                   'with_seg=False, '
-                                   "decode_backend='numpy', "
-                                   'to_xyz=False, '
-                                   'backend_args=None)')
-
-    def test_load_depth_annotation(self):
-        input_results = dict(
-            img_path='tests/data/pseudo_nyu_dataset/images/'
-            'bookstore_0001d_00001.jpg',
-            depth_map_path='tests/data/pseudo_nyu_dataset/'
-            'annotations/bookstore_0001d_00001.png',
-            category_id=-1,
-            seg_fields=[])
-        transform = LoadDepthAnnotation(depth_rescale_factor=0.001)
-        results = transform(input_results)
-        assert 'gt_depth_map' in results
-        assert results['gt_depth_map'].shape[:2] == mmcv.imread(
-            input_results['depth_map_path']).shape[:2]
-        assert results['gt_depth_map'].dtype == np.float32
-        assert 'gt_depth_map' in results['seg_fields']
diff --git a/mmsegmentation/tests/test_datasets/test_transform.py b/mmsegmentation/tests/test_datasets/test_transform.py
deleted file mode 100644
index e73e558..0000000
--- a/mmsegmentation/tests/test_datasets/test_transform.py
+++ /dev/null
@@ -1,1273 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import copy
-import os.path as osp
-from unittest import TestCase
-
-import mmcv
-import numpy as np
-import pytest
-from mmengine.registry import init_default_scope
-from PIL import Image
-
-from mmseg.datasets.transforms import *  # noqa
-from mmseg.datasets.transforms import (LoadBiomedicalData,
-                                       LoadBiomedicalImageFromFile,
-                                       PhotoMetricDistortion, RandomCrop,
-                                       RandomDepthMix)
-from mmseg.registry import TRANSFORMS
-
-init_default_scope('mmseg')
-
-
-def test_resize():
-    # Test `Resize`, `RandomResize` and `RandomChoiceResize` from
-    # MMCV transform. Noted: `RandomResize` has args `scales` but
-    # `Resize` and `RandomResize` has args `scale`.
-    transform = dict(type='Resize', scale=(1333, 800), keep_ratio=True)
-    resize_module = TRANSFORMS.build(transform)
-
-    results = dict()
-    # (288, 512, 3)
-    img = mmcv.imread(
-        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
-    results['img'] = img
-    results['img_shape'] = img.shape
-    results['ori_shape'] = img.shape
-    # Set initial values for default meta_keys
-    results['pad_shape'] = img.shape
-    results['scale_factor'] = 1.0
-
-    resized_results = resize_module(results.copy())
-    # img_shape = results['img'].shape[:2] in ``MMCV resize`` function
-    # so right now it is (750, 1333) rather than (750, 1333, 3)
-    assert resized_results['img_shape'] == (750, 1333)
-
-    # test keep_ratio=False
-    transform = dict(
-        type='RandomResize',
-        scale=(1280, 800),
-        ratio_range=(1.0, 1.0),
-        resize_type='Resize',
-        keep_ratio=False)
-    resize_module = TRANSFORMS.build(transform)
-    resized_results = resize_module(results.copy())
-    assert resized_results['img_shape'] == (800, 1280)
-
-    # test `RandomChoiceResize`, which in older mmsegmentation
-    # `Resize` is multiscale_mode='range'
-    transform = dict(type='RandomResize', scale=[(1333, 400), (1333, 1200)])
-    resize_module = TRANSFORMS.build(transform)
-    resized_results = resize_module(results.copy())
-    assert max(resized_results['img_shape'][:2]) <= 1333
-    assert min(resized_results['img_shape'][:2]) >= 400
-    assert min(resized_results['img_shape'][:2]) <= 1200
-
-    # test RandomChoiceResize, which in older mmsegmentation
-    # `Resize` is multiscale_mode='value'
-    transform = dict(
-        type='RandomChoiceResize',
-        scales=[(1333, 800), (1333, 400)],
-        resize_type='Resize',
-        keep_ratio=False)
-    resize_module = TRANSFORMS.build(transform)
-    resized_results = resize_module(results.copy())
-    assert resized_results['img_shape'] in [(800, 1333), (400, 1333)]
-
-    transform = dict(type='Resize', scale_factor=(0.9, 1.1), keep_ratio=True)
-    resize_module = TRANSFORMS.build(transform)
-    resized_results = resize_module(results.copy())
-    assert max(resized_results['img_shape'][:2]) <= 1333 * 1.1
-
-    # test RandomChoiceResize, which `resize_type` is `ResizeShortestEdge`
-    transform = dict(
-        type='RandomChoiceResize',
-        scales=[128, 256, 512],
-        resize_type='ResizeShortestEdge',
-        max_size=1333)
-    resize_module = TRANSFORMS.build(transform)
-    resized_results = resize_module(results.copy())
-    assert resized_results['img_shape'][0] in [128, 256, 512]
-
-    transform = dict(
-        type='RandomChoiceResize',
-        scales=[512],
-        resize_type='ResizeShortestEdge',
-        max_size=512)
-    resize_module = TRANSFORMS.build(transform)
-    resized_results = resize_module(results.copy())
-    assert resized_results['img_shape'][1] == 512
-
-    transform = dict(
-        type='RandomChoiceResize',
-        scales=[(128, 256), (256, 512), (512, 1024)],
-        resize_type='ResizeShortestEdge',
-        max_size=1333)
-    resize_module = TRANSFORMS.build(transform)
-    resized_results = resize_module(results.copy())
-    assert resized_results['img_shape'][0] in [128, 256, 512]
-
-    # test scale=None and scale_factor is tuple.
-    # img shape: (288, 512, 3)
-    transform = dict(
-        type='Resize', scale=None, scale_factor=(0.5, 2.0), keep_ratio=True)
-    resize_module = TRANSFORMS.build(transform)
-    resized_results = resize_module(results.copy())
-    assert int(288 * 0.5) <= resized_results['img_shape'][0] <= 288 * 2.0
-    assert int(512 * 0.5) <= resized_results['img_shape'][1] <= 512 * 2.0
-
-    # test minimum resized image shape is 640
-    transform = dict(type='Resize', scale=(2560, 640), keep_ratio=True)
-    resize_module = TRANSFORMS.build(transform)
-    resized_results = resize_module(results.copy())
-    assert resized_results['img_shape'] == (640, 1138)
-
-    # test minimum resized image shape is 640 when img_scale=(512, 640)
-    # where should define `scale_factor` in MMCV new ``Resize`` function.
-    min_size_ratio = max(640 / img.shape[0], 640 / img.shape[1])
-    transform = dict(
-        type='Resize', scale_factor=min_size_ratio, keep_ratio=True)
-    resize_module = TRANSFORMS.build(transform)
-    resized_results = resize_module(results.copy())
-    assert resized_results['img_shape'] == (640, 1138)
-
-    # test h > w
-    img = np.random.randn(512, 288, 3)
-    results['img'] = img
-    results['img_shape'] = img.shape
-    results['ori_shape'] = img.shape
-    # Set initial values for default meta_keys
-    results['pad_shape'] = img.shape
-    results['scale_factor'] = 1.0
-    min_size_ratio = max(640 / img.shape[0], 640 / img.shape[1])
-    transform = dict(
-        type='Resize',
-        scale=(2560, 640),
-        scale_factor=min_size_ratio,
-        keep_ratio=True)
-    resize_module = TRANSFORMS.build(transform)
-    resized_results = resize_module(results.copy())
-    assert resized_results['img_shape'] == (1138, 640)
-
-
-def test_flip():
-    # test assertion for invalid prob
-    with pytest.raises(AssertionError):
-        transform = dict(type='RandomFlip', prob=1.5)
-        TRANSFORMS.build(transform)
-
-    # test assertion for invalid direction
-    with pytest.raises(AssertionError):
-        transform = dict(type='RandomFlip', prob=1.0, direction='horizonta')
-        TRANSFORMS.build(transform)
-
-    transform = dict(type='RandomFlip', prob=1.0)
-    flip_module = TRANSFORMS.build(transform)
-
-    results = dict()
-    img = mmcv.imread(
-        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
-    original_img = copy.deepcopy(img)
-    seg = np.array(
-        Image.open(osp.join(osp.dirname(__file__), '../data/seg.png')))
-    original_seg = copy.deepcopy(seg)
-    results['img'] = img
-    results['gt_semantic_seg'] = seg
-    results['seg_fields'] = ['gt_semantic_seg']
-    results['img_shape'] = img.shape
-    results['ori_shape'] = img.shape
-    # Set initial values for default meta_keys
-    results['pad_shape'] = img.shape
-    results['scale_factor'] = 1.0
-
-    results = flip_module(results)
-
-    flip_module = TRANSFORMS.build(transform)
-    results = flip_module(results)
-    assert np.equal(original_img, results['img']).all()
-    assert np.equal(original_seg, results['gt_semantic_seg']).all()
-
-    results['gt_depth_map'] = seg
-    results['seg_fields'] = ['gt_depth_map']
-    results = flip_module(results)
-    flip_module = TRANSFORMS.build(transform)
-    results = flip_module(results)
-    assert np.equal(original_img, results['img']).all()
-    assert np.equal(original_seg, results['gt_depth_map']).all()
-
-
-def test_random_rotate_flip():
-    with pytest.raises(AssertionError):
-        transform = dict(type='RandomRotFlip', flip_prob=1.5)
-        TRANSFORMS.build(transform)
-
-    with pytest.raises(AssertionError):
-        transform = dict(type='RandomRotFlip', rotate_prob=1.5)
-        TRANSFORMS.build(transform)
-
-    with pytest.raises(AssertionError):
-        transform = dict(type='RandomRotFlip', degree=[20, 20, 20])
-        TRANSFORMS.build(transform)
-
-    with pytest.raises(AssertionError):
-        transform = dict(type='RandomRotFlip', degree=-20)
-        TRANSFORMS.build(transform)
-
-    transform = dict(
-        type='RandomRotFlip', flip_prob=1.0, rotate_prob=0, degree=20)
-    rot_flip_module = TRANSFORMS.build(transform)
-
-    results = dict()
-    img = mmcv.imread(
-        osp.join(
-            osp.dirname(__file__),
-            '../data/pseudo_synapse_dataset/img_dir/case0005_slice000.jpg'),
-        'color')
-    original_img = copy.deepcopy(img)
-    seg = np.array(
-        Image.open(
-            osp.join(
-                osp.dirname(__file__),
-                '../data/pseudo_synapse_dataset/ann_dir/case0005_slice000.png')
-        ))
-    original_seg = copy.deepcopy(seg)
-    results['img'] = img
-    results['gt_semantic_seg'] = seg
-    results['seg_fields'] = ['gt_semantic_seg']
-    results['img_shape'] = img.shape
-    results['ori_shape'] = img.shape
-    # Set initial values for default meta_keys
-    results['pad_shape'] = img.shape
-    results['scale_factor'] = 1.0
-
-    result_flip = rot_flip_module(results)
-    assert original_img.shape == result_flip['img'].shape
-    assert original_seg.shape == result_flip['gt_semantic_seg'].shape
-
-    transform = dict(
-        type='RandomRotFlip', flip_prob=0, rotate_prob=1.0, degree=20)
-    rot_flip_module = TRANSFORMS.build(transform)
-
-    result_rotate = rot_flip_module(results)
-    assert original_img.shape == result_rotate['img'].shape
-    assert original_seg.shape == result_rotate['gt_semantic_seg'].shape
-
-    assert str(transform) == "{'type': 'RandomRotFlip'," \
-                             " 'flip_prob': 0," \
-                             " 'rotate_prob': 1.0," \
-                             " 'degree': 20}"
-
-
-def test_pad():
-    # test assertion if both size_divisor and size is None
-    with pytest.raises(AssertionError):
-        transform = dict(type='Pad')
-        TRANSFORMS.build(transform)
-
-    transform = dict(type='Pad', size_divisor=32)
-    transform = TRANSFORMS.build(transform)
-    results = dict()
-    img = mmcv.imread(
-        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
-    original_img = copy.deepcopy(img)
-    results['img'] = img
-    results['img_shape'] = img.shape
-    results['ori_shape'] = img.shape
-    # Set initial values for default meta_keys
-    results['pad_shape'] = img.shape
-    results['scale_factor'] = 1.0
-
-    results = transform(results)
-    # original img already divisible by 32
-    assert np.equal(results['img'], original_img).all()
-    img_shape = results['img'].shape
-    assert img_shape[0] % 32 == 0
-    assert img_shape[1] % 32 == 0
-
-
-def test_normalize():
-    img_norm_cfg = dict(
-        mean=[123.675, 116.28, 103.53],
-        std=[58.395, 57.12, 57.375],
-        to_rgb=True)
-    transform = dict(type='Normalize', **img_norm_cfg)
-    transform = TRANSFORMS.build(transform)
-    results = dict()
-    img = mmcv.imread(
-        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
-    original_img = copy.deepcopy(img)
-    results['img'] = img
-    results['img_shape'] = img.shape
-    results['ori_shape'] = img.shape
-    # Set initial values for default meta_keys
-    results['pad_shape'] = img.shape
-    results['scale_factor'] = 1.0
-
-    results = transform(results)
-
-    mean = np.array(img_norm_cfg['mean'])
-    std = np.array(img_norm_cfg['std'])
-    converted_img = (original_img[..., ::-1] - mean) / std
-    assert np.allclose(results['img'], converted_img)
-
-
-def test_random_crop():
-    # test assertion for invalid random crop
-    with pytest.raises(AssertionError):
-        RandomCrop(crop_size=(-1, 0))
-
-    results = dict()
-    img = mmcv.imread(osp.join('tests/data/color.jpg'), 'color')
-    seg = np.array(Image.open(osp.join('tests/data/seg.png')))
-    results['img'] = img
-    results['gt_semantic_seg'] = seg
-    results['seg_fields'] = ['gt_semantic_seg']
-    results['img_shape'] = img.shape
-    results['ori_shape'] = img.shape
-    # Set initial values for default meta_keys
-    results['pad_shape'] = img.shape
-    results['scale_factor'] = 1.0
-
-    h, w, _ = img.shape
-    pipeline = RandomCrop(crop_size=(h - 20, w - 20))
-
-    results = pipeline(results)
-    assert results['img'].shape[:2] == (h - 20, w - 20)
-    assert results['img_shape'] == (h - 20, w - 20)
-    assert results['gt_semantic_seg'].shape[:2] == (h - 20, w - 20)
-
-
-def test_rgb2gray():
-    # test assertion out_channels should be greater than 0
-    with pytest.raises(AssertionError):
-        transform = dict(type='RGB2Gray', out_channels=-1)
-        TRANSFORMS.build(transform)
-    # test assertion weights should be tuple[float]
-    with pytest.raises(AssertionError):
-        transform = dict(type='RGB2Gray', out_channels=1, weights=1.1)
-        TRANSFORMS.build(transform)
-
-    # test out_channels is None
-    transform = dict(type='RGB2Gray')
-    transform = TRANSFORMS.build(transform)
-
-    assert str(transform) == f'RGB2Gray(' \
-                             f'out_channels={None}, ' \
-                             f'weights={(0.299, 0.587, 0.114)})'
-
-    results = dict()
-    img = mmcv.imread(
-        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
-    h, w, c = img.shape
-    seg = np.array(
-        Image.open(osp.join(osp.dirname(__file__), '../data/seg.png')))
-    results['img'] = img
-    results['gt_semantic_seg'] = seg
-    results['seg_fields'] = ['gt_semantic_seg']
-    results['img_shape'] = img.shape
-    results['ori_shape'] = img.shape
-    # Set initial values for default meta_keys
-    results['pad_shape'] = img.shape
-    results['scale_factor'] = 1.0
-
-    results = transform(results)
-    assert results['img'].shape == (h, w, c)
-    assert results['img_shape'] == (h, w, c)
-    assert results['ori_shape'] == (h, w, c)
-
-    # test out_channels = 2
-    transform = dict(type='RGB2Gray', out_channels=2)
-    transform = TRANSFORMS.build(transform)
-
-    assert str(transform) == f'RGB2Gray(' \
-                             f'out_channels={2}, ' \
-                             f'weights={(0.299, 0.587, 0.114)})'
-
-    results = dict()
-    img = mmcv.imread(
-        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
-    h, w, c = img.shape
-    seg = np.array(
-        Image.open(osp.join(osp.dirname(__file__), '../data/seg.png')))
-    results['img'] = img
-    results['gt_semantic_seg'] = seg
-    results['seg_fields'] = ['gt_semantic_seg']
-    results['img_shape'] = img.shape
-    results['ori_shape'] = img.shape
-    # Set initial values for default meta_keys
-    results['pad_shape'] = img.shape
-    results['scale_factor'] = 1.0
-
-    results = transform(results)
-    assert results['img'].shape == (h, w, 2)
-    assert results['img_shape'] == (h, w, 2)
-
-
-def test_photo_metric_distortion():
-
-    results = dict()
-    img = mmcv.imread(osp.join('tests/data/color.jpg'), 'color')
-    seg = np.array(Image.open(osp.join('tests/data/seg.png')))
-    results['img'] = img
-    results['gt_semantic_seg'] = seg
-    results['seg_fields'] = ['gt_semantic_seg']
-    results['img_shape'] = img.shape
-    results['ori_shape'] = img.shape
-    # Set initial values for default meta_keys
-    results['pad_shape'] = img.shape
-    results['scale_factor'] = 1.0
-
-    pipeline = PhotoMetricDistortion(saturation_range=(1., 1.))
-    results = pipeline(results)
-
-    assert (results['gt_semantic_seg'] == seg).all()
-    assert results['img_shape'] == img.shape
-
-
-def test_rerange():
-    # test assertion if min_value or max_value is illegal
-    with pytest.raises(AssertionError):
-        transform = dict(type='Rerange', min_value=[0], max_value=[255])
-        TRANSFORMS.build(transform)
-
-    # test assertion if min_value >= max_value
-    with pytest.raises(AssertionError):
-        transform = dict(type='Rerange', min_value=1, max_value=1)
-        TRANSFORMS.build(transform)
-
-    # test assertion if img_min_value == img_max_value
-    with pytest.raises(AssertionError):
-        transform = dict(type='Rerange', min_value=0, max_value=1)
-        transform = TRANSFORMS.build(transform)
-        results = dict()
-        results['img'] = np.array([[1, 1], [1, 1]])
-        transform(results)
-
-    img_rerange_cfg = dict()
-    transform = dict(type='Rerange', **img_rerange_cfg)
-    transform = TRANSFORMS.build(transform)
-    results = dict()
-    img = mmcv.imread(
-        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
-    original_img = copy.deepcopy(img)
-    results['img'] = img
-    results['img_shape'] = img.shape
-    results['ori_shape'] = img.shape
-    # Set initial values for default meta_keys
-    results['pad_shape'] = img.shape
-    results['scale_factor'] = 1.0
-
-    results = transform(results)
-
-    min_value = np.min(original_img)
-    max_value = np.max(original_img)
-    converted_img = (original_img - min_value) / (max_value - min_value) * 255
-
-    assert np.allclose(results['img'], converted_img)
-    assert str(transform) == f'Rerange(min_value={0}, max_value={255})'
-
-
-def test_CLAHE():
-    # test assertion if clip_limit is None
-    with pytest.raises(AssertionError):
-        transform = dict(type='CLAHE', clip_limit=None)
-        TRANSFORMS.build(transform)
-
-    # test assertion if tile_grid_size is illegal
-    with pytest.raises(AssertionError):
-        transform = dict(type='CLAHE', tile_grid_size=(8.0, 8.0))
-        TRANSFORMS.build(transform)
-
-    # test assertion if tile_grid_size is illegal
-    with pytest.raises(AssertionError):
-        transform = dict(type='CLAHE', tile_grid_size=(9, 9, 9))
-        TRANSFORMS.build(transform)
-
-    transform = dict(type='CLAHE', clip_limit=2)
-    transform = TRANSFORMS.build(transform)
-    results = dict()
-    img = mmcv.imread(
-        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
-    original_img = copy.deepcopy(img)
-    results['img'] = img
-    results['img_shape'] = img.shape
-    results['ori_shape'] = img.shape
-    # Set initial values for default meta_keys
-    results['pad_shape'] = img.shape
-    results['scale_factor'] = 1.0
-
-    results = transform(results)
-
-    converted_img = np.empty(original_img.shape)
-    for i in range(original_img.shape[2]):
-        converted_img[:, :, i] = mmcv.clahe(
-            np.array(original_img[:, :, i], dtype=np.uint8), 2, (8, 8))
-
-    assert np.allclose(results['img'], converted_img)
-    assert str(transform) == f'CLAHE(clip_limit={2}, tile_grid_size={(8, 8)})'
-
-
-def test_adjust_gamma():
-    # test assertion if gamma <= 0
-    with pytest.raises(AssertionError):
-        transform = dict(type='AdjustGamma', gamma=0)
-        TRANSFORMS.build(transform)
-
-    # test assertion if gamma is list
-    with pytest.raises(AssertionError):
-        transform = dict(type='AdjustGamma', gamma=[1.2])
-        TRANSFORMS.build(transform)
-
-    # test with gamma = 1.2
-    transform = dict(type='AdjustGamma', gamma=1.2)
-    transform = TRANSFORMS.build(transform)
-    results = dict()
-    img = mmcv.imread(
-        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
-    original_img = copy.deepcopy(img)
-    results['img'] = img
-    results['img_shape'] = img.shape
-    results['ori_shape'] = img.shape
-    # Set initial values for default meta_keys
-    results['pad_shape'] = img.shape
-    results['scale_factor'] = 1.0
-
-    results = transform(results)
-
-    inv_gamma = 1.0 / 1.2
-    table = np.array([((i / 255.0)**inv_gamma) * 255
-                      for i in np.arange(0, 256)]).astype('uint8')
-    converted_img = mmcv.lut_transform(
-        np.array(original_img, dtype=np.uint8), table)
-    assert np.allclose(results['img'], converted_img)
-    assert str(transform) == f'AdjustGamma(gamma={1.2})'
-
-
-def test_rotate():
-    # test assertion degree should be tuple[float] or float
-    with pytest.raises(AssertionError):
-        transform = dict(type='RandomRotate', prob=0.5, degree=-10)
-        TRANSFORMS.build(transform)
-    # test assertion degree should be tuple[float] or float
-    with pytest.raises(AssertionError):
-        transform = dict(type='RandomRotate', prob=0.5, degree=(10., 20., 30.))
-        TRANSFORMS.build(transform)
-
-    transform = dict(type='RandomRotate', degree=10., prob=1.)
-    transform = TRANSFORMS.build(transform)
-
-    assert str(transform) == f'RandomRotate(' \
-                             f'prob={1.}, ' \
-                             f'degree=({-10.}, {10.}), ' \
-                             f'pad_val={0}, ' \
-                             f'seg_pad_val={255}, ' \
-                             f'center={None}, ' \
-                             f'auto_bound={False})'
-
-    results = dict()
-    img = mmcv.imread(
-        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
-    h, w, _ = img.shape
-    seg = np.array(
-        Image.open(osp.join(osp.dirname(__file__), '../data/seg.png')))
-    results['img'] = img
-    results['gt_semantic_seg'] = seg
-    results['seg_fields'] = ['gt_semantic_seg']
-    results['img_shape'] = img.shape
-    results['ori_shape'] = img.shape
-    # Set initial values for default meta_keys
-    results['pad_shape'] = img.shape
-    results['scale_factor'] = 1.0
-
-    results = transform(results)
-    assert results['img'].shape[:2] == (h, w)
-
-
-def test_seg_rescale():
-    results = dict()
-    seg = np.array(
-        Image.open(osp.join(osp.dirname(__file__), '../data/seg.png')))
-    results['gt_semantic_seg'] = seg
-    results['seg_fields'] = ['gt_semantic_seg']
-    h, w = seg.shape
-
-    transform = dict(type='SegRescale', scale_factor=1. / 2)
-    rescale_module = TRANSFORMS.build(transform)
-    rescale_results = rescale_module(results.copy())
-    assert rescale_results['gt_semantic_seg'].shape == (h // 2, w // 2)
-
-    transform = dict(type='SegRescale', scale_factor=1)
-    rescale_module = TRANSFORMS.build(transform)
-    rescale_results = rescale_module(results.copy())
-    assert rescale_results['gt_semantic_seg'].shape == (h, w)
-
-
-def test_mosaic():
-    # test prob
-    with pytest.raises(AssertionError):
-        transform = dict(type='RandomMosaic', prob=1.5)
-        TRANSFORMS.build(transform)
-    # test assertion for invalid img_scale
-    with pytest.raises(AssertionError):
-        transform = dict(type='RandomMosaic', prob=1, img_scale=640)
-        TRANSFORMS.build(transform)
-
-    results = dict()
-    img = mmcv.imread(
-        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
-    seg = np.array(
-        Image.open(osp.join(osp.dirname(__file__), '../data/seg.png')))
-
-    results['img'] = img
-    results['gt_semantic_seg'] = seg
-    results['seg_fields'] = ['gt_semantic_seg']
-
-    transform = dict(type='RandomMosaic', prob=1, img_scale=(10, 12))
-    mosaic_module = TRANSFORMS.build(transform)
-    assert 'Mosaic' in repr(mosaic_module)
-
-    # test assertion for invalid mix_results
-    with pytest.raises(AssertionError):
-        mosaic_module(results)
-
-    results['mix_results'] = [copy.deepcopy(results)] * 3
-    results = mosaic_module(results)
-    assert results['img'].shape[:2] == (20, 24)
-
-    results = dict()
-    results['img'] = img[:, :, 0]
-    results['gt_semantic_seg'] = seg
-    results['seg_fields'] = ['gt_semantic_seg']
-
-    transform = dict(type='RandomMosaic', prob=0, img_scale=(10, 12))
-    mosaic_module = TRANSFORMS.build(transform)
-    results['mix_results'] = [copy.deepcopy(results)] * 3
-    results = mosaic_module(results)
-    assert results['img'].shape[:2] == img.shape[:2]
-
-    transform = dict(type='RandomMosaic', prob=1, img_scale=(10, 12))
-    mosaic_module = TRANSFORMS.build(transform)
-    results = mosaic_module(results)
-    assert results['img'].shape[:2] == (20, 24)
-
-    results = dict()
-    results['img'] = np.concatenate((img, img), axis=2)
-    results['gt_semantic_seg'] = seg
-    results['seg_fields'] = ['gt_semantic_seg']
-
-    transform = dict(type='RandomMosaic', prob=1, img_scale=(10, 12))
-    mosaic_module = TRANSFORMS.build(transform)
-    results['mix_results'] = [copy.deepcopy(results)] * 3
-    results = mosaic_module(results)
-    assert results['img'].shape[2] == 6
-
-
-def test_cutout():
-    # test prob
-    with pytest.raises(AssertionError):
-        transform = dict(type='RandomCutOut', prob=1.5, n_holes=1)
-        TRANSFORMS.build(transform)
-    # test n_holes
-    with pytest.raises(AssertionError):
-        transform = dict(
-            type='RandomCutOut', prob=0.5, n_holes=(5, 3), cutout_shape=(8, 8))
-        TRANSFORMS.build(transform)
-    with pytest.raises(AssertionError):
-        transform = dict(
-            type='RandomCutOut',
-            prob=0.5,
-            n_holes=(3, 4, 5),
-            cutout_shape=(8, 8))
-        TRANSFORMS.build(transform)
-    # test cutout_shape and cutout_ratio
-    with pytest.raises(AssertionError):
-        transform = dict(
-            type='RandomCutOut', prob=0.5, n_holes=1, cutout_shape=8)
-        TRANSFORMS.build(transform)
-    with pytest.raises(AssertionError):
-        transform = dict(
-            type='RandomCutOut', prob=0.5, n_holes=1, cutout_ratio=0.2)
-        TRANSFORMS.build(transform)
-    # either of cutout_shape and cutout_ratio should be given
-    with pytest.raises(AssertionError):
-        transform = dict(type='RandomCutOut', prob=0.5, n_holes=1)
-        TRANSFORMS.build(transform)
-    with pytest.raises(AssertionError):
-        transform = dict(
-            type='RandomCutOut',
-            prob=0.5,
-            n_holes=1,
-            cutout_shape=(2, 2),
-            cutout_ratio=(0.4, 0.4))
-        TRANSFORMS.build(transform)
-    # test seg_fill_in
-    with pytest.raises(AssertionError):
-        transform = dict(
-            type='RandomCutOut',
-            prob=0.5,
-            n_holes=1,
-            cutout_shape=(8, 8),
-            seg_fill_in='a')
-        TRANSFORMS.build(transform)
-    with pytest.raises(AssertionError):
-        transform = dict(
-            type='RandomCutOut',
-            prob=0.5,
-            n_holes=1,
-            cutout_shape=(8, 8),
-            seg_fill_in=256)
-        TRANSFORMS.build(transform)
-
-    results = dict()
-    img = mmcv.imread(
-        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
-
-    seg = np.array(
-        Image.open(osp.join(osp.dirname(__file__), '../data/seg.png')))
-
-    results['img'] = img
-    results['gt_semantic_seg'] = seg
-    results['seg_fields'] = ['gt_semantic_seg']
-    results['img_shape'] = img.shape
-    results['ori_shape'] = img.shape
-    results['pad_shape'] = img.shape
-    results['img_fields'] = ['img']
-
-    transform = dict(
-        type='RandomCutOut', prob=1, n_holes=1, cutout_shape=(10, 10))
-    cutout_module = TRANSFORMS.build(transform)
-    assert 'cutout_shape' in repr(cutout_module)
-    cutout_result = cutout_module(copy.deepcopy(results))
-    assert cutout_result['img'].sum() < img.sum()
-
-    transform = dict(
-        type='RandomCutOut', prob=1, n_holes=1, cutout_ratio=(0.8, 0.8))
-    cutout_module = TRANSFORMS.build(transform)
-    assert 'cutout_ratio' in repr(cutout_module)
-    cutout_result = cutout_module(copy.deepcopy(results))
-    assert cutout_result['img'].sum() < img.sum()
-
-    transform = dict(
-        type='RandomCutOut', prob=0, n_holes=1, cutout_ratio=(0.8, 0.8))
-    cutout_module = TRANSFORMS.build(transform)
-    cutout_result = cutout_module(copy.deepcopy(results))
-    assert cutout_result['img'].sum() == img.sum()
-    assert cutout_result['gt_semantic_seg'].sum() == seg.sum()
-
-    transform = dict(
-        type='RandomCutOut',
-        prob=1,
-        n_holes=(2, 4),
-        cutout_shape=[(10, 10), (15, 15)],
-        fill_in=(255, 255, 255),
-        seg_fill_in=None)
-    cutout_module = TRANSFORMS.build(transform)
-    cutout_result = cutout_module(copy.deepcopy(results))
-    assert cutout_result['img'].sum() > img.sum()
-    assert cutout_result['gt_semantic_seg'].sum() == seg.sum()
-
-    transform = dict(
-        type='RandomCutOut',
-        prob=1,
-        n_holes=1,
-        cutout_ratio=(0.8, 0.8),
-        fill_in=(255, 255, 255),
-        seg_fill_in=255)
-    cutout_module = TRANSFORMS.build(transform)
-    cutout_result = cutout_module(copy.deepcopy(results))
-    assert cutout_result['img'].sum() > img.sum()
-    assert cutout_result['gt_semantic_seg'].sum() > seg.sum()
-
-
-def test_resize_to_multiple():
-    transform = dict(type='ResizeToMultiple', size_divisor=32)
-    transform = TRANSFORMS.build(transform)
-
-    img = np.random.randn(213, 232, 3)
-    seg = np.random.randint(0, 19, (213, 232))
-    results = dict()
-    results['img'] = img
-    results['gt_semantic_seg'] = seg
-    results['seg_fields'] = ['gt_semantic_seg']
-    results['img_shape'] = img.shape
-    results['pad_shape'] = img.shape
-
-    results = transform(results)
-    assert results['img'].shape == (224, 256, 3)
-    assert results['gt_semantic_seg'].shape == (224, 256)
-    assert results['img_shape'] == (224, 256)
-
-
-def test_generate_edge():
-    transform = dict(type='GenerateEdge', edge_width=1)
-    transform = TRANSFORMS.build(transform)
-
-    seg_map = np.array([
-        [1, 1, 1, 1, 1],
-        [1, 1, 1, 1, 2],
-        [1, 1, 1, 2, 2],
-        [1, 1, 2, 2, 2],
-        [1, 2, 2, 2, 2],
-        [2, 2, 2, 2, 2],
-    ])
-    results = dict()
-    results['gt_seg_map'] = seg_map
-    results['img_shape'] = seg_map.shape
-
-    results = transform(results)
-    assert np.all(results['gt_edge_map'] == np.array([
-        [0, 0, 0, 1, 0],
-        [0, 0, 1, 1, 1],
-        [0, 1, 1, 1, 0],
-        [1, 1, 1, 0, 0],
-        [1, 1, 0, 0, 0],
-        [1, 0, 0, 0, 0],
-    ]))
-
-
-def test_biomedical3d_random_crop():
-    # test assertion for invalid random crop
-    with pytest.raises(AssertionError):
-        transform = dict(type='BioMedical3DRandomCrop', crop_shape=(-2, -1, 0))
-        transform = TRANSFORMS.build(transform)
-
-    from mmseg.datasets.transforms import (LoadBiomedicalAnnotation,
-                                           LoadBiomedicalImageFromFile)
-    results = dict()
-    results['img_path'] = osp.join(
-        osp.dirname(__file__), '../data', 'biomedical.nii.gz')
-    transform = LoadBiomedicalImageFromFile()
-    results = transform(copy.deepcopy(results))
-
-    results['seg_map_path'] = osp.join(
-        osp.dirname(__file__), '../data', 'biomedical_ann.nii.gz')
-    transform = LoadBiomedicalAnnotation()
-    results = transform(copy.deepcopy(results))
-
-    d, h, w = results['img_shape']
-    transform = dict(
-        type='BioMedical3DRandomCrop',
-        crop_shape=(d - 20, h - 20, w - 20),
-        keep_foreground=True)
-    transform = TRANSFORMS.build(transform)
-    crop_results = transform(results)
-    assert crop_results['img'].shape[1:] == (d - 20, h - 20, w - 20)
-    assert crop_results['img_shape'] == (d - 20, h - 20, w - 20)
-    assert crop_results['gt_seg_map'].shape == (d - 20, h - 20, w - 20)
-
-    transform = dict(
-        type='BioMedical3DRandomCrop',
-        crop_shape=(d - 20, h - 20, w - 20),
-        keep_foreground=False)
-    transform = TRANSFORMS.build(transform)
-    crop_results = transform(results)
-    assert crop_results['img'].shape[1:] == (d - 20, h - 20, w - 20)
-    assert crop_results['img_shape'] == (d - 20, h - 20, w - 20)
-    assert crop_results['gt_seg_map'].shape == (d - 20, h - 20, w - 20)
-
-
-def test_biomedical_gaussian_noise():
-    # test assertion for invalid prob
-    with pytest.raises(AssertionError):
-        transform = dict(type='BioMedicalGaussianNoise', prob=1.5)
-        TRANSFORMS.build(transform)
-
-    # test assertion for invalid std
-    with pytest.raises(AssertionError):
-        transform = dict(
-            type='BioMedicalGaussianNoise', prob=0.2, mean=0.5, std=-0.5)
-        TRANSFORMS.build(transform)
-
-    transform = dict(type='BioMedicalGaussianNoise', prob=1.0)
-    noise_module = TRANSFORMS.build(transform)
-    assert str(noise_module) == 'BioMedicalGaussianNoise'\
-                                '(prob=1.0, ' \
-                                'mean=0.0, ' \
-                                'std=0.1)'
-
-    transform = dict(type='BioMedicalGaussianNoise', prob=1.0)
-    noise_module = TRANSFORMS.build(transform)
-    results = dict(
-        img_path=osp.join(osp.dirname(__file__), '../data/biomedical.nii.gz'))
-    from mmseg.datasets.transforms import LoadBiomedicalImageFromFile
-    transform = LoadBiomedicalImageFromFile()
-    results = transform(copy.deepcopy(results))
-    original_img = copy.deepcopy(results['img'])
-    results = noise_module(results)
-    assert original_img.shape == results['img'].shape
-
-
-def test_biomedical_gaussian_blur():
-    # test assertion for invalid prob
-    with pytest.raises(AssertionError):
-        transform = dict(type='BioMedicalGaussianBlur', prob=-1.5)
-        TRANSFORMS.build(transform)
-    with pytest.raises(AssertionError):
-        transform = dict(
-            type='BioMedicalGaussianBlur', prob=1.0, sigma_range=0.6)
-        smooth_module = TRANSFORMS.build(transform)
-
-    with pytest.raises(AssertionError):
-        transform = dict(
-            type='BioMedicalGaussianBlur', prob=1.0, sigma_range=(0.6))
-        smooth_module = TRANSFORMS.build(transform)
-
-    with pytest.raises(AssertionError):
-        transform = dict(
-            type='BioMedicalGaussianBlur', prob=1.0, sigma_range=(15, 8, 9))
-        TRANSFORMS.build(transform)
-
-    with pytest.raises(AssertionError):
-        transform = dict(
-            type='BioMedicalGaussianBlur', prob=1.0, sigma_range='0.16')
-        TRANSFORMS.build(transform)
-
-    transform = dict(
-        type='BioMedicalGaussianBlur', prob=1.0, sigma_range=(0.7, 0.8))
-    smooth_module = TRANSFORMS.build(transform)
-    assert str(
-        smooth_module
-    ) == 'BioMedicalGaussianBlur(prob=1.0, ' \
-         'prob_per_channel=0.5, '\
-         'sigma_range=(0.7, 0.8), ' \
-         'different_sigma_per_channel=True, '\
-         'different_sigma_per_axis=True)'
-
-    transform = dict(type='BioMedicalGaussianBlur', prob=1.0)
-    smooth_module = TRANSFORMS.build(transform)
-    assert str(
-        smooth_module
-    ) == 'BioMedicalGaussianBlur(prob=1.0, ' \
-         'prob_per_channel=0.5, '\
-         'sigma_range=(0.5, 1.0), ' \
-         'different_sigma_per_channel=True, '\
-         'different_sigma_per_axis=True)'
-
-    results = dict(
-        img_path=osp.join(osp.dirname(__file__), '../data/biomedical.nii.gz'))
-    from mmseg.datasets.transforms import LoadBiomedicalImageFromFile
-    transform = LoadBiomedicalImageFromFile()
-    results = transform(copy.deepcopy(results))
-    original_img = copy.deepcopy(results['img'])
-    results = smooth_module(results)
-    assert original_img.shape == results['img'].shape
-    # the max value in the smoothed image should be less than the original one
-    assert original_img.max() >= results['img'].max()
-    assert original_img.min() <= results['img'].min()
-
-    transform = dict(
-        type='BioMedicalGaussianBlur',
-        prob=1.0,
-        different_sigma_per_axis=False)
-    smooth_module = TRANSFORMS.build(transform)
-
-    results = dict(
-        img_path=osp.join(osp.dirname(__file__), '../data/biomedical.nii.gz'))
-    from mmseg.datasets.transforms import LoadBiomedicalImageFromFile
-    transform = LoadBiomedicalImageFromFile()
-    results = transform(copy.deepcopy(results))
-    original_img = copy.deepcopy(results['img'])
-    results = smooth_module(results)
-    assert original_img.shape == results['img'].shape
-    # the max value in the smoothed image should be less than the original one
-    assert original_img.max() >= results['img'].max()
-    assert original_img.min() <= results['img'].min()
-
-
-def test_BioMedicalRandomGamma():
-
-    with pytest.raises(AssertionError):
-        transform = dict(
-            type='BioMedicalRandomGamma', prob=-1, gamma_range=(0.7, 1.2))
-        TRANSFORMS.build(transform)
-
-    with pytest.raises(AssertionError):
-        transform = dict(
-            type='BioMedicalRandomGamma', prob=1.2, gamma_range=(0.7, 1.2))
-        TRANSFORMS.build(transform)
-
-    with pytest.raises(AssertionError):
-        transform = dict(
-            type='BioMedicalRandomGamma', prob=1.0, gamma_range=(0.7))
-        TRANSFORMS.build(transform)
-
-    with pytest.raises(AssertionError):
-        transform = dict(
-            type='BioMedicalRandomGamma',
-            prob=1.0,
-            gamma_range=(0.7, 0.2, 0.3))
-        TRANSFORMS.build(transform)
-
-    with pytest.raises(AssertionError):
-        transform = dict(
-            type='BioMedicalRandomGamma',
-            prob=1.0,
-            gamma_range=(0.7, 2),
-            invert_image=1)
-        TRANSFORMS.build(transform)
-
-    with pytest.raises(AssertionError):
-        transform = dict(
-            type='BioMedicalRandomGamma',
-            prob=1.0,
-            gamma_range=(0.7, 2),
-            per_channel=1)
-        TRANSFORMS.build(transform)
-
-    with pytest.raises(AssertionError):
-        transform = dict(
-            type='BioMedicalRandomGamma',
-            prob=1.0,
-            gamma_range=(0.7, 2),
-            retain_stats=1)
-        TRANSFORMS.build(transform)
-
-    test_img = 'tests/data/biomedical.nii.gz'
-    results = dict(img_path=test_img)
-    transform = LoadBiomedicalImageFromFile()
-    results = transform(copy.deepcopy(results))
-    origin_img = results['img']
-    transform2 = dict(
-        type='BioMedicalRandomGamma',
-        prob=1.0,
-        gamma_range=(0.7, 2),
-    )
-    transform2 = TRANSFORMS.build(transform2)
-    results = transform2(results)
-    transformed_img = results['img']
-    assert origin_img.shape == transformed_img.shape
-
-
-def test_BioMedical3DPad():
-    # test assertion.
-    with pytest.raises(AssertionError):
-        transform = dict(type='BioMedical3DPad', pad_shape=None)
-        TRANSFORMS.build(transform)
-
-    with pytest.raises(AssertionError):
-        transform = dict(type='BioMedical3DPad', pad_shape=[256, 256])
-        TRANSFORMS.build(transform)
-
-    data_info1 = dict(img=np.random.random((8, 6, 4, 4)))
-
-    transform = dict(type='BioMedical3DPad', pad_shape=(6, 6, 6))
-    transform = TRANSFORMS.build(transform)
-    results = transform(copy.deepcopy(data_info1))
-    assert results['img'].shape[1:] == (6, 6, 6)
-    assert results['pad_shape'] == (6, 6, 6)
-
-    transform = dict(type='BioMedical3DPad', pad_shape=(4, 6, 6))
-    transform = TRANSFORMS.build(transform)
-    results = transform(copy.deepcopy(data_info1))
-    assert results['img'].shape[1:] == (6, 6, 6)
-    assert results['pad_shape'] == (6, 6, 6)
-
-    data_info2 = dict(
-        img=np.random.random((8, 6, 4, 4)),
-        gt_seg_map=np.random.randint(0, 2, (6, 4, 4)))
-
-    transform = dict(type='BioMedical3DPad', pad_shape=(6, 6, 6))
-    transform = TRANSFORMS.build(transform)
-    results = transform(copy.deepcopy(data_info2))
-    assert results['img'].shape[1:] == (6, 6, 6)
-    assert results['gt_seg_map'].shape[1:] == (6, 6, 6)
-    assert results['pad_shape'] == (6, 6, 6)
-
-    transform = dict(type='BioMedical3DPad', pad_shape=(4, 6, 6))
-    transform = TRANSFORMS.build(transform)
-    results = transform(copy.deepcopy(data_info2))
-    assert results['img'].shape[1:] == (6, 6, 6)
-    assert results['gt_seg_map'].shape[1:] == (6, 6, 6)
-    assert results['pad_shape'] == (6, 6, 6)
-
-
-def test_biomedical_3d_flip():
-    # test assertion for invalid prob
-    with pytest.raises(AssertionError):
-        transform = dict(type='BioMedical3DRandomFlip', prob=1.5, axes=(0, 1))
-        transform = TRANSFORMS.build(transform)
-
-    # test assertion for invalid direction
-    with pytest.raises(AssertionError):
-        transform = dict(type='BioMedical3DRandomFlip', prob=1, axes=(0, 1, 3))
-        transform = TRANSFORMS.build(transform)
-
-    # test flip axes are (0, 1, 2)
-    transform = dict(type='BioMedical3DRandomFlip', prob=1, axes=(0, 1, 2))
-    transform = TRANSFORMS.build(transform)
-
-    # test with random 3d data
-    results = dict()
-    results['img_path'] = 'Null'
-    results['img_shape'] = (1, 16, 16, 16)
-    results['img'] = np.random.randn(1, 16, 16, 16)
-    results['gt_seg_map'] = np.random.randint(0, 4, (16, 16, 16))
-
-    original_img = results['img'].copy()
-    original_seg = results['gt_seg_map'].copy()
-
-    # flip first time
-    results = transform(results)
-    with pytest.raises(AssertionError):
-        assert np.equal(original_img, results['img']).all()
-    with pytest.raises(AssertionError):
-        assert np.equal(original_seg, results['gt_seg_map']).all()
-
-    # flip second time
-    results = transform(results)
-    assert np.equal(original_img, results['img']).all()
-    assert np.equal(original_seg, results['gt_seg_map']).all()
-
-    # test with actual data and flip axes are (0, 1)
-    # load biomedical 3d img and seg
-    data_prefix = osp.join(osp.dirname(__file__), '../data')
-    input_results = dict(img_path=osp.join(data_prefix, 'biomedical.npy'))
-    biomedical_loader = LoadBiomedicalData(with_seg=True)
-    data = biomedical_loader(copy.deepcopy(input_results))
-    results = data.copy()
-
-    original_img = data['img'].copy()
-    original_seg = data['gt_seg_map'].copy()
-
-    # test flip axes are (0, 1)
-    transform = dict(type='BioMedical3DRandomFlip', prob=1, axes=(0, 1))
-    transform = TRANSFORMS.build(transform)
-
-    # flip first time
-    results = transform(results)
-    with pytest.raises(AssertionError):
-        assert np.equal(original_img, results['img']).all()
-    with pytest.raises(AssertionError):
-        assert np.equal(original_seg, results['gt_seg_map']).all()
-
-    # flip second time
-    results = transform(results)
-    assert np.equal(original_img, results['img']).all()
-    assert np.equal(original_seg, results['gt_seg_map']).all()
-
-    # test transform with flip axes = (1)
-    transform = dict(type='BioMedical3DRandomFlip', prob=1, axes=(1, ))
-    transform = TRANSFORMS.build(transform)
-    results = data.copy()
-    results = transform(results)
-    results = transform(results)
-    assert np.equal(original_img, results['img']).all()
-    assert np.equal(original_seg, results['gt_seg_map']).all()
-
-    # test transform with swap_label_pairs
-    transform = dict(
-        type='BioMedical3DRandomFlip',
-        prob=1,
-        axes=(1, 2),
-        swap_label_pairs=[(0, 1)])
-    transform = TRANSFORMS.build(transform)
-    results = data.copy()
-    results = transform(results)
-
-    with pytest.raises(AssertionError):
-        assert np.equal(original_seg, results['gt_seg_map']).all()
-
-    # swap twice
-    results = transform(results)
-    assert np.equal(original_img, results['img']).all()
-    assert np.equal(original_seg, results['gt_seg_map']).all()
-
-
-def test_albu_transform():
-    results = dict(
-        img_path=osp.join(osp.dirname(__file__), '../data/color.jpg'))
-
-    # Define simple pipeline
-    load = dict(type='LoadImageFromFile')
-    load = TRANSFORMS.build(load)
-
-    albu_transform = dict(
-        type='Albu', transforms=[dict(type='ChannelShuffle', p=1)])
-    albu_transform = TRANSFORMS.build(albu_transform)
-
-    normalize = dict(type='Normalize', mean=[0] * 3, std=[0] * 3, to_rgb=True)
-    normalize = TRANSFORMS.build(normalize)
-
-    # Execute transforms
-    results = load(results)
-    results = albu_transform(results)
-    results = normalize(results)
-
-    assert results['img'].dtype == np.float32
-
-
-def test_albu_channel_order():
-    results = dict(
-        img_path=osp.join(osp.dirname(__file__), '../data/color.jpg'))
-
-    # Define simple pipeline
-    load = dict(type='LoadImageFromFile')
-    load = TRANSFORMS.build(load)
-
-    # Transform is modifying B channel
-    albu_transform = dict(
-        type='Albu',
-        transforms=[
-            dict(
-                type='RGBShift',
-                r_shift_limit=0,
-                g_shift_limit=0,
-                b_shift_limit=200,
-                p=1)
-        ])
-    albu_transform = TRANSFORMS.build(albu_transform)
-
-    # Execute transforms
-    results_load = load(results)
-    results_albu = albu_transform(results_load)
-
-    # assert only Green and Red channel are not modified
-    np.testing.assert_array_equal(results_albu['img'][..., 1:],
-                                  results_load['img'][..., 1:])
-
-    # assert Blue channel is modified
-    with pytest.raises(AssertionError):
-        np.testing.assert_array_equal(results_albu['img'][..., 0],
-                                      results_load['img'][..., 0])
-
-
-class TestRandomDepthMix(TestCase):
-
-    def setUp(self):
-        self.transform = RandomDepthMix(prob=1.0)
-
-    def test_transform_shape(self):
-        # Create a dummy result dict
-        results = {
-            'img_shape': (10, 10),
-            'img': np.random.rand(10, 10, 3),
-            'gt_depth_map': np.random.rand(10, 10)
-        }
-        transformed = self.transform.transform(results)
-
-        # Check if the shape remains the same
-        self.assertEqual(results['img'].shape, transformed['img'].shape)
-
-    def test_transform_values(self):
-        # Create a dummy result dict
-        results = {
-            'img_shape': (10, 10),
-            'img': np.zeros((10, 10, 3)),
-            'gt_depth_map': np.ones((10, 10))
-        }
-        transformed = self.transform.transform(results)
-
-        # Assuming the transformation modifies a portion of the image,
-        # it shouldn't remain all zeros
-        self.assertFalse(np.all(transformed['img'] == 0))
-
-    def test_invalid_image_dimension(self):
-        # Create a dummy result dict with invalid image dimension
-        results = {
-            'img_shape': (10, 10),
-            'img': np.random.rand(10, 10, 3, 3),
-            'gt_depth_map': np.random.rand(10, 10)
-        }
-
-        # Check if a ValueError is raised for invalid dimension
-        with self.assertRaises(ValueError):
-            self.transform.transform(results)
diff --git a/mmsegmentation/tests/test_datasets/test_tta.py b/mmsegmentation/tests/test_datasets/test_tta.py
deleted file mode 100644
index 25b1ecd..0000000
--- a/mmsegmentation/tests/test_datasets/test_tta.py
+++ /dev/null
@@ -1,131 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import os.path as osp
-
-import mmcv
-import pytest
-
-from mmseg.datasets.transforms import *  # noqa
-from mmseg.registry import TRANSFORMS
-
-
-def test_multi_scale_flip_aug():
-    # test exception
-    with pytest.raises(TypeError):
-        tta_transform = dict(
-            type='TestTimeAug',
-            transforms=[dict(type='Resize', keep_ratio=False)],
-        )
-        TRANSFORMS.build(tta_transform)
-
-    tta_transform = dict(
-        type='TestTimeAug',
-        transforms=[[
-            dict(type='Resize', scale=scale, keep_ratio=False)
-            for scale in [(256, 256), (512, 512), (1024, 1024)]
-        ], [dict(type='mmseg.PackSegInputs')]])
-    tta_module = TRANSFORMS.build(tta_transform)
-
-    results = dict()
-    # (288, 512, 3)
-    img = mmcv.imread(
-        osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
-    results['img'] = img
-    results['ori_shape'] = img.shape
-    results['ori_height'] = img.shape[0]
-    results['ori_width'] = img.shape[1]
-    # Set initial values for default meta_keys
-    results['pad_shape'] = img.shape
-    results['scale_factor'] = 1.0
-
-    tta_results = tta_module(results.copy())
-    assert [img.shape for img in tta_results['inputs']] == [(3, 256, 256),
-                                                            (3, 512, 512),
-                                                            (3, 1024, 1024)]
-
-    tta_transform = dict(
-        type='TestTimeAug',
-        transforms=[
-            [
-                dict(type='Resize', scale=scale, keep_ratio=False)
-                for scale in [(256, 256), (512, 512), (1024, 1024)]
-            ],
-            [
-                dict(type='RandomFlip', prob=0., direction='horizontal'),
-                dict(type='RandomFlip', prob=1., direction='horizontal')
-            ], [dict(type='mmseg.PackSegInputs')]
-        ])
-    tta_module = TRANSFORMS.build(tta_transform)
-    tta_results: dict = tta_module(results.copy())
-    assert [img.shape for img in tta_results['inputs']] == [(3, 256, 256),
-                                                            (3, 256, 256),
-                                                            (3, 512, 512),
-                                                            (3, 512, 512),
-                                                            (3, 1024, 1024),
-                                                            (3, 1024, 1024)]
-    assert [
-        data_sample.metainfo['flip']
-        for data_sample in tta_results['data_samples']
-    ] == [False, True, False, True, False, True]
-
-    tta_transform = dict(
-        type='TestTimeAug',
-        transforms=[[dict(type='Resize', scale=(512, 512), keep_ratio=False)],
-                    [dict(type='mmseg.PackSegInputs')]])
-    tta_module = TRANSFORMS.build(tta_transform)
-    tta_results = tta_module(results.copy())
-    assert [tta_results['inputs'][0].shape] == [(3, 512, 512)]
-
-    tta_transform = dict(
-        type='TestTimeAug',
-        transforms=[
-            [dict(type='Resize', scale=(512, 512), keep_ratio=False)],
-            [
-                dict(type='RandomFlip', prob=0., direction='horizontal'),
-                dict(type='RandomFlip', prob=1., direction='horizontal')
-            ], [dict(type='mmseg.PackSegInputs')]
-        ])
-    tta_module = TRANSFORMS.build(tta_transform)
-    tta_results = tta_module(results.copy())
-    assert [img.shape for img in tta_results['inputs']] == [(3, 512, 512),
-                                                            (3, 512, 512)]
-    assert [
-        data_sample.metainfo['flip']
-        for data_sample in tta_results['data_samples']
-    ] == [False, True]
-
-    tta_transform = dict(
-        type='TestTimeAug',
-        transforms=[[
-            dict(type='Resize', scale_factor=r, keep_ratio=False)
-            for r in [0.5, 1.0, 2.0]
-        ], [dict(type='mmseg.PackSegInputs')]])
-    tta_module = TRANSFORMS.build(tta_transform)
-    tta_results = tta_module(results.copy())
-    assert [img.shape for img in tta_results['inputs']] == [(3, 144, 256),
-                                                            (3, 288, 512),
-                                                            (3, 576, 1024)]
-
-    tta_transform = dict(
-        type='TestTimeAug',
-        transforms=[
-            [
-                dict(type='Resize', scale_factor=r, keep_ratio=True)
-                for r in [0.5, 1.0, 2.0]
-            ],
-            [
-                dict(type='RandomFlip', prob=0., direction='horizontal'),
-                dict(type='RandomFlip', prob=1., direction='horizontal')
-            ], [dict(type='mmseg.PackSegInputs')]
-        ])
-    tta_module = TRANSFORMS.build(tta_transform)
-    tta_results = tta_module(results.copy())
-    assert [img.shape for img in tta_results['inputs']] == [(3, 144, 256),
-                                                            (3, 144, 256),
-                                                            (3, 288, 512),
-                                                            (3, 288, 512),
-                                                            (3, 576, 1024),
-                                                            (3, 576, 1024)]
-    assert [
-        data_sample.metainfo['flip']
-        for data_sample in tta_results['data_samples']
-    ] == [False, True, False, True, False, True]
diff --git a/mmsegmentation/tests/test_digit_version.py b/mmsegmentation/tests/test_digit_version.py
deleted file mode 100644
index 45daf09..0000000
--- a/mmsegmentation/tests/test_digit_version.py
+++ /dev/null
@@ -1,21 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmseg import digit_version
-
-
-def test_digit_version():
-    assert digit_version('0.2.16') == (0, 2, 16, 0, 0, 0)
-    assert digit_version('1.2.3') == (1, 2, 3, 0, 0, 0)
-    assert digit_version('1.2.3rc0') == (1, 2, 3, 0, -1, 0)
-    assert digit_version('1.2.3rc1') == (1, 2, 3, 0, -1, 1)
-    assert digit_version('1.0rc0') == (1, 0, 0, 0, -1, 0)
-    assert digit_version('1.0') == digit_version('1.0.0')
-    assert digit_version('1.5.0+cuda90_cudnn7.6.3_lms') == digit_version('1.5')
-    assert digit_version('1.0.0dev') < digit_version('1.0.0a')
-    assert digit_version('1.0.0a') < digit_version('1.0.0a1')
-    assert digit_version('1.0.0a') < digit_version('1.0.0b')
-    assert digit_version('1.0.0b') < digit_version('1.0.0rc')
-    assert digit_version('1.0.0rc1') < digit_version('1.0.0')
-    assert digit_version('1.0.0') < digit_version('1.0.0post')
-    assert digit_version('1.0.0post') < digit_version('1.0.0post1')
-    assert digit_version('v1') == (1, 0, 0, 0, 0, 0)
-    assert digit_version('v1.1.5') == (1, 1, 5, 0, 0, 0)
diff --git a/mmsegmentation/tests/test_engine/test_layer_decay_optimizer_constructor.py b/mmsegmentation/tests/test_engine/test_layer_decay_optimizer_constructor.py
deleted file mode 100644
index e7d13db..0000000
--- a/mmsegmentation/tests/test_engine/test_layer_decay_optimizer_constructor.py
+++ /dev/null
@@ -1,300 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-# from copyreg import constructor
-import pytest
-import torch
-import torch.nn as nn
-from mmcv.cnn import ConvModule
-from mmengine.optim.optimizer import build_optim_wrapper
-from mmengine.registry import init_default_scope
-
-from mmseg.engine.optimizers.layer_decay_optimizer_constructor import \
-    LearningRateDecayOptimizerConstructor
-
-init_default_scope('mmseg')
-
-base_lr = 1
-decay_rate = 2
-base_wd = 0.05
-weight_decay = 0.05
-
-expected_stage_wise_lr_wd_convnext = [{
-    'weight_decay': 0.0,
-    'lr_scale': 128
-}, {
-    'weight_decay': 0.0,
-    'lr_scale': 1
-}, {
-    'weight_decay': 0.05,
-    'lr_scale': 64
-}, {
-    'weight_decay': 0.0,
-    'lr_scale': 64
-}, {
-    'weight_decay': 0.05,
-    'lr_scale': 32
-}, {
-    'weight_decay': 0.0,
-    'lr_scale': 32
-}, {
-    'weight_decay': 0.05,
-    'lr_scale': 16
-}, {
-    'weight_decay': 0.0,
-    'lr_scale': 16
-}, {
-    'weight_decay': 0.05,
-    'lr_scale': 8
-}, {
-    'weight_decay': 0.0,
-    'lr_scale': 8
-}, {
-    'weight_decay': 0.05,
-    'lr_scale': 128
-}, {
-    'weight_decay': 0.05,
-    'lr_scale': 1
-}]
-
-expected_layer_wise_lr_wd_convnext = [{
-    'weight_decay': 0.0,
-    'lr_scale': 128
-}, {
-    'weight_decay': 0.0,
-    'lr_scale': 1
-}, {
-    'weight_decay': 0.05,
-    'lr_scale': 64
-}, {
-    'weight_decay': 0.0,
-    'lr_scale': 64
-}, {
-    'weight_decay': 0.05,
-    'lr_scale': 32
-}, {
-    'weight_decay': 0.0,
-    'lr_scale': 32
-}, {
-    'weight_decay': 0.05,
-    'lr_scale': 16
-}, {
-    'weight_decay': 0.0,
-    'lr_scale': 16
-}, {
-    'weight_decay': 0.05,
-    'lr_scale': 2
-}, {
-    'weight_decay': 0.0,
-    'lr_scale': 2
-}, {
-    'weight_decay': 0.05,
-    'lr_scale': 128
-}, {
-    'weight_decay': 0.05,
-    'lr_scale': 1
-}]
-
-expected_layer_wise_wd_lr_beit = [{
-    'weight_decay': 0.0,
-    'lr_scale': 16
-}, {
-    'weight_decay': 0.05,
-    'lr_scale': 8
-}, {
-    'weight_decay': 0.0,
-    'lr_scale': 8
-}, {
-    'weight_decay': 0.05,
-    'lr_scale': 4
-}, {
-    'weight_decay': 0.0,
-    'lr_scale': 4
-}, {
-    'weight_decay': 0.05,
-    'lr_scale': 2
-}, {
-    'weight_decay': 0.0,
-    'lr_scale': 2
-}, {
-    'weight_decay': 0.05,
-    'lr_scale': 1
-}, {
-    'weight_decay': 0.0,
-    'lr_scale': 1
-}]
-
-
-class ToyConvNeXt(nn.Module):
-
-    def __init__(self):
-        super().__init__()
-        self.stages = nn.ModuleList()
-        for i in range(4):
-            stage = nn.Sequential(ConvModule(3, 4, kernel_size=1, bias=True))
-            self.stages.append(stage)
-        self.norm0 = nn.BatchNorm2d(2)
-
-        # add some variables to meet unit test coverate rate
-        self.cls_token = nn.Parameter(torch.ones(1))
-        self.mask_token = nn.Parameter(torch.ones(1))
-        self.pos_embed = nn.Parameter(torch.ones(1))
-        self.stem_norm = nn.Parameter(torch.ones(1))
-        self.downsample_norm0 = nn.BatchNorm2d(2)
-        self.downsample_norm1 = nn.BatchNorm2d(2)
-        self.downsample_norm2 = nn.BatchNorm2d(2)
-        self.lin = nn.Parameter(torch.ones(1))
-        self.lin.requires_grad = False
-        self.downsample_layers = nn.ModuleList()
-        for _ in range(4):
-            stage = nn.Sequential(nn.Conv2d(3, 4, kernel_size=1, bias=True))
-            self.downsample_layers.append(stage)
-
-
-class ToyBEiT(nn.Module):
-
-    def __init__(self):
-        super().__init__()
-        # add some variables to meet unit test coverate rate
-        self.cls_token = nn.Parameter(torch.ones(1))
-        self.patch_embed = nn.Parameter(torch.ones(1))
-        self.layers = nn.ModuleList()
-        for _ in range(3):
-            layer = nn.Conv2d(3, 3, 1)
-            self.layers.append(layer)
-
-
-class ToyMAE(nn.Module):
-
-    def __init__(self):
-        super().__init__()
-        # add some variables to meet unit test coverate rate
-        self.cls_token = nn.Parameter(torch.ones(1))
-        self.patch_embed = nn.Parameter(torch.ones(1))
-        self.layers = nn.ModuleList()
-        for _ in range(3):
-            layer = nn.Conv2d(3, 3, 1)
-            self.layers.append(layer)
-
-
-class ToySegmentor(nn.Module):
-
-    def __init__(self, backbone):
-        super().__init__()
-        self.backbone = backbone
-        self.decode_head = nn.Conv2d(2, 2, kernel_size=1, groups=2)
-
-
-class PseudoDataParallel(nn.Module):
-
-    def __init__(self, model):
-        super().__init__()
-        self.module = model
-
-
-class ToyViT(nn.Module):
-
-    def __init__(self):
-        super().__init__()
-
-
-def check_optimizer_lr_wd(optimizer, gt_lr_wd):
-    assert isinstance(optimizer, torch.optim.AdamW)
-    assert optimizer.defaults['lr'] == base_lr
-    assert optimizer.defaults['weight_decay'] == base_wd
-    param_groups = optimizer.param_groups
-    print(param_groups)
-    assert len(param_groups) == len(gt_lr_wd)
-    for i, param_dict in enumerate(param_groups):
-        assert param_dict['weight_decay'] == gt_lr_wd[i]['weight_decay']
-        assert param_dict['lr_scale'] == gt_lr_wd[i]['lr_scale']
-        assert param_dict['lr_scale'] == param_dict['lr']
-
-
-def test_learning_rate_decay_optimizer_constructor():
-
-    # Test lr wd for ConvNeXT
-    backbone = ToyConvNeXt()
-    model = PseudoDataParallel(ToySegmentor(backbone))
-    # stagewise decay
-    stagewise_paramwise_cfg = dict(
-        decay_rate=decay_rate, decay_type='stage_wise', num_layers=6)
-    optimizer_cfg = dict(
-        type='AdamW', lr=base_lr, betas=(0.9, 0.999), weight_decay=0.05)
-    optim_wrapper_cfg = dict(
-        type='OptimWrapper',
-        optimizer=optimizer_cfg,
-        paramwise_cfg=stagewise_paramwise_cfg,
-        constructor='LearningRateDecayOptimizerConstructor')
-    optim_wrapper = build_optim_wrapper(model, optim_wrapper_cfg)
-    check_optimizer_lr_wd(optim_wrapper.optimizer,
-                          expected_stage_wise_lr_wd_convnext)
-    # layerwise decay
-    layerwise_paramwise_cfg = dict(
-        decay_rate=decay_rate, decay_type='layer_wise', num_layers=6)
-    optim_wrapper_cfg = dict(
-        type='OptimWrapper',
-        optimizer=optimizer_cfg,
-        paramwise_cfg=layerwise_paramwise_cfg,
-        constructor='LearningRateDecayOptimizerConstructor')
-    optim_wrapper = build_optim_wrapper(model, optim_wrapper_cfg)
-    check_optimizer_lr_wd(optim_wrapper.optimizer,
-                          expected_layer_wise_lr_wd_convnext)
-
-    # Test lr wd for BEiT
-    backbone = ToyBEiT()
-    model = PseudoDataParallel(ToySegmentor(backbone))
-
-    layerwise_paramwise_cfg = dict(
-        decay_rate=decay_rate, decay_type='layer_wise', num_layers=3)
-    optim_wrapper_cfg = dict(
-        type='OptimWrapper',
-        optimizer=optimizer_cfg,
-        paramwise_cfg=layerwise_paramwise_cfg,
-        constructor='LearningRateDecayOptimizerConstructor')
-    optim_wrapper = build_optim_wrapper(model, optim_wrapper_cfg)
-    check_optimizer_lr_wd(optim_wrapper.optimizer,
-                          expected_layer_wise_wd_lr_beit)
-
-    # Test invalidation of lr wd for Vit
-    backbone = ToyViT()
-    model = PseudoDataParallel(ToySegmentor(backbone))
-    with pytest.raises(NotImplementedError):
-        optim_constructor = LearningRateDecayOptimizerConstructor(
-            optim_wrapper_cfg, layerwise_paramwise_cfg)
-        optim_constructor(model)
-    with pytest.raises(NotImplementedError):
-        optim_constructor = LearningRateDecayOptimizerConstructor(
-            optim_wrapper_cfg, stagewise_paramwise_cfg)
-        optim_constructor(model)
-
-    # Test lr wd for MAE
-    backbone = ToyMAE()
-    model = PseudoDataParallel(ToySegmentor(backbone))
-
-    layerwise_paramwise_cfg = dict(
-        decay_rate=decay_rate, decay_type='layer_wise', num_layers=3)
-    optim_wrapper_cfg = dict(
-        type='OptimWrapper',
-        optimizer=optimizer_cfg,
-        paramwise_cfg=layerwise_paramwise_cfg,
-        constructor='LearningRateDecayOptimizerConstructor')
-    optim_wrapper = build_optim_wrapper(model, optim_wrapper_cfg)
-    check_optimizer_lr_wd(optim_wrapper.optimizer,
-                          expected_layer_wise_wd_lr_beit)
-
-
-def test_beit_layer_decay_optimizer_constructor():
-
-    # paramwise_cfg with BEiTExampleModel
-    backbone = ToyBEiT()
-    model = PseudoDataParallel(ToySegmentor(backbone))
-    paramwise_cfg = dict(layer_decay_rate=2, num_layers=3)
-    optim_wrapper_cfg = dict(
-        type='OptimWrapper',
-        constructor='LayerDecayOptimizerConstructor',
-        paramwise_cfg=paramwise_cfg,
-        optimizer=dict(
-            type='AdamW', lr=1, betas=(0.9, 0.999), weight_decay=0.05))
-    optim_wrapper = build_optim_wrapper(model, optim_wrapper_cfg)
-    # optimizer = optim_wrapper_builder(model)
-    check_optimizer_lr_wd(optim_wrapper.optimizer,
-                          expected_layer_wise_wd_lr_beit)
diff --git a/mmsegmentation/tests/test_engine/test_optimizer.py b/mmsegmentation/tests/test_engine/test_optimizer.py
deleted file mode 100644
index af69f5f..0000000
--- a/mmsegmentation/tests/test_engine/test_optimizer.py
+++ /dev/null
@@ -1,33 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-import torch.nn as nn
-from mmengine.optim import build_optim_wrapper
-
-
-class ExampleModel(nn.Module):
-
-    def __init__(self):
-        super().__init__()
-        self.param1 = nn.Parameter(torch.ones(1))
-        self.conv1 = nn.Conv2d(3, 4, kernel_size=1, bias=False)
-        self.conv2 = nn.Conv2d(4, 2, kernel_size=1)
-        self.bn = nn.BatchNorm2d(2)
-
-    def forward(self, x):
-        return x
-
-
-base_lr = 0.01
-base_wd = 0.0001
-momentum = 0.9
-
-
-def test_build_optimizer():
-    model = ExampleModel()
-    optim_wrapper_cfg = dict(
-        type='OptimWrapper',
-        optimizer=dict(
-            type='SGD', lr=base_lr, weight_decay=base_wd, momentum=momentum))
-    optim_wrapper = build_optim_wrapper(model, optim_wrapper_cfg)
-    # test whether optimizer is successfully built from parent.
-    assert isinstance(optim_wrapper.optimizer, torch.optim.SGD)
diff --git a/mmsegmentation/tests/test_engine/test_visualization_hook.py b/mmsegmentation/tests/test_engine/test_visualization_hook.py
deleted file mode 100644
index 022e27c..0000000
--- a/mmsegmentation/tests/test_engine/test_visualization_hook.py
+++ /dev/null
@@ -1,64 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from unittest import TestCase
-from unittest.mock import Mock
-
-import torch
-from mmengine.structures import PixelData
-
-from mmseg.engine.hooks import SegVisualizationHook
-from mmseg.structures import SegDataSample
-from mmseg.visualization import SegLocalVisualizer
-
-
-class TestVisualizationHook(TestCase):
-
-    def setUp(self) -> None:
-
-        h = 288
-        w = 512
-        num_class = 2
-
-        SegLocalVisualizer.get_instance('visualizer')
-        SegLocalVisualizer.dataset_meta = dict(
-            classes=('background', 'foreground'),
-            palette=[[120, 120, 120], [6, 230, 230]])
-
-        data_sample = SegDataSample()
-        data_sample.set_metainfo({'img_path': 'tests/data/color.jpg'})
-        self.data_batch = [{'data_sample': data_sample}] * 2
-
-        pred_sem_seg_data = dict(data=torch.randint(0, num_class, (1, h, w)))
-        pred_sem_seg = PixelData(**pred_sem_seg_data)
-        pred_seg_data_sample = SegDataSample()
-        pred_seg_data_sample.set_metainfo({'img_path': 'tests/data/color.jpg'})
-        pred_seg_data_sample.pred_sem_seg = pred_sem_seg
-        self.outputs = [pred_seg_data_sample] * 2
-
-    def test_after_iter(self):
-        runner = Mock()
-        runner.iter = 1
-        hook = SegVisualizationHook(draw=True, interval=1)
-        hook._after_iter(
-            runner, 1, self.data_batch, self.outputs, mode='train')
-        hook._after_iter(runner, 1, self.data_batch, self.outputs, mode='val')
-        hook._after_iter(runner, 1, self.data_batch, self.outputs, mode='test')
-
-    def test_after_val_iter(self):
-        runner = Mock()
-        runner.iter = 2
-        hook = SegVisualizationHook(interval=1)
-        hook.after_val_iter(runner, 1, self.data_batch, self.outputs)
-
-        hook = SegVisualizationHook(draw=True, interval=1)
-        hook.after_val_iter(runner, 1, self.data_batch, self.outputs)
-
-        hook = SegVisualizationHook(
-            draw=True, interval=1, show=True, wait_time=1)
-        hook.after_val_iter(runner, 1, self.data_batch, self.outputs)
-
-    def test_after_test_iter(self):
-        runner = Mock()
-        hook = SegVisualizationHook(draw=True, interval=1)
-        assert hook._test_index == 0
-        hook.after_test_iter(runner, 1, self.data_batch, self.outputs)
-        assert hook._test_index == len(self.outputs)
diff --git a/mmsegmentation/tests/test_evaluation/test_metrics/test_citys_metric.py b/mmsegmentation/tests/test_evaluation/test_metrics/test_citys_metric.py
deleted file mode 100644
index 06f956f..0000000
--- a/mmsegmentation/tests/test_evaluation/test_metrics/test_citys_metric.py
+++ /dev/null
@@ -1,119 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import os.path as osp
-import shutil
-from unittest import TestCase
-
-import numpy as np
-import pytest
-import torch
-from mmengine.structures import PixelData
-
-from mmseg.evaluation import CityscapesMetric
-from mmseg.structures import SegDataSample
-
-
-class TestCityscapesMetric(TestCase):
-
-    def _demo_mm_inputs(self,
-                        batch_size=1,
-                        image_shapes=(3, 128, 256),
-                        num_classes=5):
-        """Create a superset of inputs needed to run test or train batches.
-
-        Args:
-            batch_size (int): batch size. Default to 2.
-            image_shapes (List[tuple], Optional): image shape.
-                Default to (3, 64, 64)
-            num_classes (int): number of different classes.
-                Default to 5.
-        """
-        if isinstance(image_shapes, list):
-            assert len(image_shapes) == batch_size
-        else:
-            image_shapes = [image_shapes] * batch_size
-
-        packed_inputs = []
-        for idx in range(batch_size):
-            image_shape = image_shapes[idx]
-            _, h, w = image_shape
-
-            data_sample = SegDataSample()
-            gt_semantic_seg = np.random.randint(
-                0, num_classes, (1, h, w), dtype=np.uint8)
-            gt_semantic_seg = torch.LongTensor(gt_semantic_seg)
-            gt_sem_seg_data = dict(data=gt_semantic_seg)
-            data_sample.gt_sem_seg = PixelData(**gt_sem_seg_data)
-            data_sample = data_sample.to_dict()
-            data_sample[
-                'seg_map_path'] = 'tests/data/pseudo_cityscapes_dataset/gtFine/val/frankfurt/frankfurt_000000_000294_gtFine_labelTrainIds.png'  # noqa
-            packed_inputs.append(data_sample)
-
-        return packed_inputs
-
-    def _demo_mm_model_output(self,
-                              batch_size=1,
-                              image_shapes=(3, 128, 256),
-                              num_classes=5):
-        """Create a superset of inputs needed to run test or train batches.
-
-        Args:
-            batch_size (int): batch size. Default to 2.
-            image_shapes (List[tuple], Optional): image shape.
-                Default to (3, 64, 64)
-            num_classes (int): number of different classes.
-                Default to 5.
-        """
-        results_dict = dict()
-        _, h, w = image_shapes
-        seg_logit = torch.randn(batch_size, num_classes, h, w)
-        results_dict['seg_logits'] = seg_logit
-        seg_pred = np.random.randint(
-            0, num_classes, (batch_size, h, w), dtype=np.uint8)
-        seg_pred = torch.LongTensor(seg_pred)
-        results_dict['pred_sem_seg'] = seg_pred
-
-        batch_datasampes = [
-            SegDataSample()
-            for _ in range(results_dict['pred_sem_seg'].shape[0])
-        ]
-        for key, value in results_dict.items():
-            for i in range(value.shape[0]):
-                setattr(batch_datasampes[i], key, PixelData(data=value[i]))
-
-        _predictions = []
-        for pred in batch_datasampes:
-            test_data = pred.to_dict()
-            test_data[
-                'img_path'] = 'tests/data/pseudo_cityscapes_dataset/leftImg8bit/val/frankfurt/frankfurt_000000_000294_leftImg8bit.png'  # noqa
-            _predictions.append(test_data)
-
-        return _predictions
-
-    def test_evaluate(self):
-        """Test using the metric in the same way as Evalutor."""
-
-        data_batch = self._demo_mm_inputs(2)
-        predictions = self._demo_mm_model_output(2)
-        data_samples = [
-            dict(**data, **result)
-            for data, result in zip(data_batch, predictions)
-        ]
-        # test keep_results should be True when format_only is True
-        with pytest.raises(AssertionError):
-            CityscapesMetric(
-                output_dir='tmp', format_only=True, keep_results=False)
-
-        # test evaluate with cityscape metric
-        metric = CityscapesMetric(output_dir='tmp')
-        metric.process(data_batch, data_samples)
-        res = metric.evaluate(2)
-        self.assertIsInstance(res, dict)
-
-        # test format_only
-        metric = CityscapesMetric(
-            output_dir='tmp', format_only=True, keep_results=True)
-        metric.process(data_batch, data_samples)
-        metric.evaluate(2)
-        assert osp.exists('tmp')
-        assert osp.isfile('tmp/frankfurt_000000_000294_leftImg8bit.png')
-        shutil.rmtree('tmp')
diff --git a/mmsegmentation/tests/test_evaluation/test_metrics/test_depth_metric.py b/mmsegmentation/tests/test_evaluation/test_metrics/test_depth_metric.py
deleted file mode 100644
index a172db8..0000000
--- a/mmsegmentation/tests/test_evaluation/test_metrics/test_depth_metric.py
+++ /dev/null
@@ -1,85 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import os.path as osp
-import shutil
-from unittest import TestCase
-
-import torch
-from mmengine.structures import PixelData
-
-from mmseg.evaluation import DepthMetric
-from mmseg.structures import SegDataSample
-
-
-class TestDepthMetric(TestCase):
-
-    def _demo_mm_inputs(self,
-                        batch_size=2,
-                        image_shapes=(3, 64, 64),
-                        num_classes=5):
-        """Create a superset of inputs needed to run test or train batches.
-
-        Args:
-            batch_size (int): batch size. Default to 2.
-            image_shapes (List[tuple], Optional): image shape.
-                Default to (3, 64, 64)
-            num_classes (int): number of different classes.
-                Default to 5.
-        """
-        if isinstance(image_shapes, list):
-            assert len(image_shapes) == batch_size
-        else:
-            image_shapes = [image_shapes] * batch_size
-
-        data_samples = []
-        for idx in range(batch_size):
-            image_shape = image_shapes[idx]
-            _, h, w = image_shape
-
-            data_sample = SegDataSample()
-            gt_depth_map = torch.rand((1, h, w)) * 10
-            data_sample.gt_depth_map = PixelData(data=gt_depth_map)
-
-            data_samples.append(data_sample.to_dict())
-
-        return data_samples
-
-    def _demo_mm_model_output(self,
-                              data_samples,
-                              batch_size=2,
-                              image_shapes=(3, 64, 64),
-                              num_classes=5):
-
-        _, h, w = image_shapes
-
-        for data_sample in data_samples:
-            data_sample['pred_depth_map'] = dict(data=torch.randn(1, h, w))
-
-            data_sample[
-                'img_path'] = 'tests/data/pseudo_dataset/imgs/00000_img.jpg'
-        return data_samples
-
-    def test_evaluate(self):
-        """Test using the metric in the same way as Evalutor."""
-
-        data_samples = self._demo_mm_inputs()
-        data_samples = self._demo_mm_model_output(data_samples)
-
-        depth_metric = DepthMetric()
-        depth_metric.process([0] * len(data_samples), data_samples)
-        res = depth_metric.compute_metrics(depth_metric.results)
-        self.assertIsInstance(res, dict)
-
-        # test save depth map file in output_dir
-        depth_metric = DepthMetric(output_dir='tmp')
-        depth_metric.process([0] * len(data_samples), data_samples)
-        assert osp.exists('tmp')
-        assert osp.isfile('tmp/00000_img.png')
-        shutil.rmtree('tmp')
-
-        # test format_only
-        depth_metric = DepthMetric(output_dir='tmp', format_only=True)
-        depth_metric.process([0] * len(data_samples), data_samples)
-        assert depth_metric.results == []
-        assert osp.exists('tmp')
-        assert osp.isfile('tmp/00000_img.png')
-        shutil.rmtree('tmp')
diff --git a/mmsegmentation/tests/test_evaluation/test_metrics/test_iou_metric.py b/mmsegmentation/tests/test_evaluation/test_metrics/test_iou_metric.py
deleted file mode 100644
index 7a0e9d5..0000000
--- a/mmsegmentation/tests/test_evaluation/test_metrics/test_iou_metric.py
+++ /dev/null
@@ -1,104 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import os.path as osp
-import shutil
-from unittest import TestCase
-
-import numpy as np
-import torch
-from mmengine.structures import PixelData
-
-from mmseg.evaluation import IoUMetric
-from mmseg.structures import SegDataSample
-
-
-class TestIoUMetric(TestCase):
-
-    def _demo_mm_inputs(self,
-                        batch_size=2,
-                        image_shapes=(3, 64, 64),
-                        num_classes=5):
-        """Create a superset of inputs needed to run test or train batches.
-
-        Args:
-            batch_size (int): batch size. Default to 2.
-            image_shapes (List[tuple], Optional): image shape.
-                Default to (3, 64, 64)
-            num_classes (int): number of different classes.
-                Default to 5.
-        """
-        if isinstance(image_shapes, list):
-            assert len(image_shapes) == batch_size
-        else:
-            image_shapes = [image_shapes] * batch_size
-
-        data_samples = []
-        for idx in range(batch_size):
-            image_shape = image_shapes[idx]
-            _, h, w = image_shape
-
-            data_sample = SegDataSample()
-            gt_semantic_seg = np.random.randint(
-                0, num_classes, (1, h, w), dtype=np.uint8)
-            gt_semantic_seg = torch.LongTensor(gt_semantic_seg)
-            gt_sem_seg_data = dict(data=gt_semantic_seg)
-            data_sample.gt_sem_seg = PixelData(**gt_sem_seg_data)
-
-            data_samples.append(data_sample.to_dict())
-
-        return data_samples
-
-    def _demo_mm_model_output(self,
-                              data_samples,
-                              batch_size=2,
-                              image_shapes=(3, 64, 64),
-                              num_classes=5):
-
-        _, h, w = image_shapes
-
-        for data_sample in data_samples:
-            data_sample['seg_logits'] = dict(
-                data=torch.randn(num_classes, h, w))
-            data_sample['pred_sem_seg'] = dict(
-                data=torch.randint(0, num_classes, (1, h, w)))
-            data_sample[
-                'img_path'] = 'tests/data/pseudo_dataset/imgs/00000_img.jpg'
-        return data_samples
-
-    def test_evaluate(self):
-        """Test using the metric in the same way as Evalutor."""
-
-        data_samples = self._demo_mm_inputs()
-        data_samples = self._demo_mm_model_output(data_samples)
-
-        iou_metric = IoUMetric(iou_metrics=['mIoU'])
-        iou_metric.dataset_meta = dict(
-            classes=['wall', 'building', 'sky', 'floor', 'tree'],
-            label_map=dict(),
-            reduce_zero_label=False)
-        iou_metric.process([0] * len(data_samples), data_samples)
-        res = iou_metric.evaluate(2)
-        self.assertIsInstance(res, dict)
-
-        # test save segment file in output_dir
-        iou_metric = IoUMetric(iou_metrics=['mIoU'], output_dir='tmp')
-        iou_metric.dataset_meta = dict(
-            classes=['wall', 'building', 'sky', 'floor', 'tree'],
-            label_map=dict(),
-            reduce_zero_label=False)
-        iou_metric.process([0] * len(data_samples), data_samples)
-        assert osp.exists('tmp')
-        assert osp.isfile('tmp/00000_img.png')
-        shutil.rmtree('tmp')
-
-        # test format_only
-        iou_metric = IoUMetric(
-            iou_metrics=['mIoU'], output_dir='tmp', format_only=True)
-        iou_metric.dataset_meta = dict(
-            classes=['wall', 'building', 'sky', 'floor', 'tree'],
-            label_map=dict(),
-            reduce_zero_label=False)
-        iou_metric.process([0] * len(data_samples), data_samples)
-        assert iou_metric.results == []
-        assert osp.exists('tmp')
-        assert osp.isfile('tmp/00000_img.png')
-        shutil.rmtree('tmp')
diff --git a/mmsegmentation/tests/test_models/__init__.py b/mmsegmentation/tests/test_models/__init__.py
deleted file mode 100644
index ef101fe..0000000
--- a/mmsegmentation/tests/test_models/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
diff --git a/mmsegmentation/tests/test_models/test_assigners/test_hungarian_assigner.py b/mmsegmentation/tests/test_models/test_assigners/test_hungarian_assigner.py
deleted file mode 100644
index 2cdb1de..0000000
--- a/mmsegmentation/tests/test_models/test_assigners/test_hungarian_assigner.py
+++ /dev/null
@@ -1,77 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from unittest import TestCase
-
-import torch
-from mmengine.structures import InstanceData
-
-from mmseg.models.assigners import HungarianAssigner
-
-
-class TestHungarianAssigner(TestCase):
-
-    def test_init(self):
-        with self.assertRaises(AssertionError):
-            HungarianAssigner([])
-
-    def test_hungarian_match_assigner(self):
-        assigner = HungarianAssigner([
-            dict(type='ClassificationCost', weight=2.0),
-            dict(type='CrossEntropyLossCost', weight=5.0, use_sigmoid=True),
-            dict(type='DiceCost', weight=5.0, pred_act=True, eps=1.0)
-        ])
-        num_classes = 3
-        num_masks = 10
-        num_points = 20
-        gt_instances = InstanceData()
-        gt_instances.labels = torch.randint(0, num_classes, (num_classes, ))
-        gt_instances.masks = torch.randint(0, 2, (num_classes, num_points))
-        pred_instances = InstanceData()
-        pred_instances.scores = torch.rand((num_masks, num_classes))
-        pred_instances.masks = torch.rand((num_masks, num_points))
-
-        matched_quiery_inds, matched_label_inds = \
-            assigner.assign(pred_instances, gt_instances)
-        unique_quiery_inds = torch.unique(matched_quiery_inds)
-        unique_label_inds = torch.unique(matched_label_inds)
-        self.assertTrue(len(unique_quiery_inds) == len(matched_quiery_inds))
-        self.assertTrue(
-            torch.equal(unique_label_inds, torch.arange(0, num_classes)))
-
-    def test_cls_match_cost(self):
-        num_classes = 3
-        num_masks = 10
-        gt_instances = InstanceData()
-        gt_instances.labels = torch.randint(0, num_classes, (num_classes, ))
-        pred_instances = InstanceData()
-        pred_instances.scores = torch.rand((num_masks, num_classes))
-
-        # test ClassificationCost
-        assigner = HungarianAssigner(dict(type='ClassificationCost'))
-        matched_quiery_inds, matched_label_inds = \
-            assigner.assign(pred_instances, gt_instances)
-        unique_quiery_inds = torch.unique(matched_quiery_inds)
-        unique_label_inds = torch.unique(matched_label_inds)
-        self.assertTrue(len(unique_quiery_inds) == len(matched_quiery_inds))
-        self.assertTrue(
-            torch.equal(unique_label_inds, torch.arange(0, num_classes)))
-
-    def test_mask_match_cost(self):
-        num_classes = 3
-        num_masks = 10
-        num_points = 20
-        gt_instances = InstanceData()
-        gt_instances.masks = torch.randint(0, 2, (num_classes, num_points))
-        pred_instances = InstanceData()
-        pred_instances.masks = torch.rand((num_masks, num_points))
-
-        # test DiceCost
-        assigner = HungarianAssigner(
-            dict(type='DiceCost', pred_act=True, eps=1.0))
-        assign_result = assigner.assign(pred_instances, gt_instances)
-        self.assertTrue(len(assign_result[0]) == len(assign_result[1]))
-
-        # test CrossEntropyLossCost
-        assigner = HungarianAssigner(
-            dict(type='CrossEntropyLossCost', use_sigmoid=True))
-        assign_result = assigner.assign(pred_instances, gt_instances)
-        self.assertTrue(len(assign_result[0]) == len(assign_result[1]))
diff --git a/mmsegmentation/tests/test_models/test_backbones/__init__.py b/mmsegmentation/tests/test_models/test_backbones/__init__.py
deleted file mode 100644
index ef101fe..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_beit.py b/mmsegmentation/tests/test_models/test_backbones/test_beit.py
deleted file mode 100644
index 59a12c5..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_beit.py
+++ /dev/null
@@ -1,185 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.backbones.beit import BEiT
-from .utils import check_norm_state
-
-
-def test_beit_backbone():
-    with pytest.raises(TypeError):
-        # pretrained must be a string path
-        model = BEiT()
-        model.init_weights(pretrained=0)
-
-    with pytest.raises(TypeError):
-        # img_size must be int or tuple
-        model = BEiT(img_size=512.0)
-
-    with pytest.raises(TypeError):
-        # out_indices must be int ,list or tuple
-        model = BEiT(out_indices=1.)
-
-    with pytest.raises(AssertionError):
-        # The length of img_size tuple must be lower than 3.
-        BEiT(img_size=(224, 224, 224))
-
-    with pytest.raises(TypeError):
-        # Pretrained must be None or Str.
-        BEiT(pretrained=123)
-
-    # Test img_size isinstance tuple
-    imgs = torch.randn(1, 3, 224, 224)
-    model = BEiT(img_size=(224, ))
-    model.init_weights()
-    model(imgs)
-
-    # Test img_size isinstance tuple
-    imgs = torch.randn(1, 3, 224, 224)
-    model = BEiT(img_size=(224, 224))
-    model(imgs)
-
-    # Test norm_eval = True
-    model = BEiT(norm_eval=True)
-    model.train()
-
-    # Test BEiT backbone with input size of 224 and patch size of 16
-    model = BEiT()
-    model.init_weights()
-    model.train()
-
-    # Test  qv_bias
-    model = BEiT(qv_bias=False)
-    model.train()
-
-    # Test out_indices = list
-    model = BEiT(out_indices=[2, 4, 8, 12])
-    model.train()
-
-    assert check_norm_state(model.modules(), True)
-
-    # Test image size = (224, 224)
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 14, 14)
-
-    # Test BEiT backbone with input size of 256 and patch size of 16
-    model = BEiT(img_size=(256, 256))
-    model.init_weights()
-    model.train()
-    imgs = torch.randn(1, 3, 256, 256)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 16, 16)
-
-    # Test BEiT backbone with input size of 32 and patch size of 16
-    model = BEiT(img_size=(32, 32))
-    model.init_weights()
-    model.train()
-    imgs = torch.randn(1, 3, 32, 32)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 2, 2)
-
-    # Test unbalanced size input image
-    model = BEiT(img_size=(112, 224))
-    model.init_weights()
-    model.train()
-    imgs = torch.randn(1, 3, 112, 224)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 7, 14)
-
-    # Test irregular input image
-    model = BEiT(img_size=(234, 345))
-    model.init_weights()
-    model.train()
-    imgs = torch.randn(1, 3, 234, 345)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 14, 21)
-
-    # Test init_values=0
-    model = BEiT(init_values=0)
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 14, 14)
-
-    # Test final norm
-    model = BEiT(final_norm=True)
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 14, 14)
-
-    # Test patch norm
-    model = BEiT(patch_norm=True)
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 14, 14)
-
-
-def test_beit_init():
-    path = 'PATH_THAT_DO_NOT_EXIST'
-    # Test all combinations of pretrained and init_cfg
-    # pretrained=None, init_cfg=None
-    model = BEiT(pretrained=None, init_cfg=None)
-    assert model.init_cfg is None
-    model.init_weights()
-
-    # pretrained=None
-    # init_cfg loads pretrain from an non-existent file
-    model = BEiT(
-        pretrained=None, init_cfg=dict(type='Pretrained', checkpoint=path))
-    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
-    # Test loading a checkpoint from an non-existent file
-    with pytest.raises(OSError):
-        model.init_weights()
-
-    # test resize_rel_pos_embed
-    value = torch.randn(732, 16)
-    ckpt = {
-        'state_dict': {
-            'layers.0.attn.relative_position_index': 0,
-            'layers.0.attn.relative_position_bias_table': value
-        }
-    }
-    model = BEiT(img_size=(512, 512))
-    # If scipy is installed, this AttributeError would not be raised.
-    from mmengine.utils import is_installed
-    if not is_installed('scipy'):
-        with pytest.raises(AttributeError):
-            model.resize_rel_pos_embed(ckpt)
-
-    # pretrained=None
-    # init_cfg=123, whose type is unsupported
-    model = BEiT(pretrained=None, init_cfg=123)
-    with pytest.raises(TypeError):
-        model.init_weights()
-
-    # pretrained loads pretrain from an non-existent file
-    # init_cfg=None
-    model = BEiT(pretrained=path, init_cfg=None)
-    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
-    # Test loading a checkpoint from an non-existent file
-    with pytest.raises(OSError):
-        model.init_weights()
-
-    # pretrained loads pretrain from an non-existent file
-    # init_cfg loads pretrain from an non-existent file
-    with pytest.raises(AssertionError):
-        model = BEiT(
-            pretrained=path, init_cfg=dict(type='Pretrained', checkpoint=path))
-    with pytest.raises(AssertionError):
-        model = BEiT(pretrained=path, init_cfg=123)
-
-    # pretrain=123, whose type is unsupported
-    # init_cfg=None
-    with pytest.raises(TypeError):
-        model = BEiT(pretrained=123, init_cfg=None)
-
-    # pretrain=123, whose type is unsupported
-    # init_cfg loads pretrain from an non-existent file
-    with pytest.raises(AssertionError):
-        model = BEiT(
-            pretrained=123, init_cfg=dict(type='Pretrained', checkpoint=path))
-
-    # pretrain=123, whose type is unsupported
-    # init_cfg=123, whose type is unsupported
-    with pytest.raises(AssertionError):
-        model = BEiT(pretrained=123, init_cfg=123)
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_bisenetv1.py b/mmsegmentation/tests/test_models/test_backbones/test_bisenetv1.py
deleted file mode 100644
index c067749..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_bisenetv1.py
+++ /dev/null
@@ -1,109 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.backbones import BiSeNetV1
-from mmseg.models.backbones.bisenetv1 import (AttentionRefinementModule,
-                                              ContextPath, FeatureFusionModule,
-                                              SpatialPath)
-
-
-def test_bisenetv1_backbone():
-    # Test BiSeNetV1 Standard Forward
-    backbone_cfg = dict(
-        type='ResNet',
-        in_channels=3,
-        depth=18,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        dilations=(1, 1, 1, 1),
-        strides=(1, 2, 2, 2),
-        norm_eval=False,
-        style='pytorch',
-        contract_dilation=True)
-    model = BiSeNetV1(in_channels=3, backbone_cfg=backbone_cfg)
-    model.init_weights()
-    model.train()
-    batch_size = 2
-    imgs = torch.randn(batch_size, 3, 64, 128)
-    feat = model(imgs)
-
-    assert len(feat) == 3
-    # output for segment Head
-    assert feat[0].shape == torch.Size([batch_size, 256, 8, 16])
-    # for auxiliary head 1
-    assert feat[1].shape == torch.Size([batch_size, 128, 8, 16])
-    # for auxiliary head 2
-    assert feat[2].shape == torch.Size([batch_size, 128, 4, 8])
-
-    # Test input with rare shape
-    batch_size = 2
-    imgs = torch.randn(batch_size, 3, 95, 27)
-    feat = model(imgs)
-    assert len(feat) == 3
-
-    with pytest.raises(AssertionError):
-        # BiSeNetV1 spatial path channel constraints.
-        BiSeNetV1(
-            backbone_cfg=backbone_cfg,
-            in_channels=3,
-            spatial_channels=(16, 16, 16))
-
-    with pytest.raises(AssertionError):
-        # BiSeNetV1 context path constraints.
-        BiSeNetV1(
-            backbone_cfg=backbone_cfg,
-            in_channels=3,
-            context_channels=(16, 32, 64, 128))
-
-
-def test_bisenetv1_spatial_path():
-    with pytest.raises(AssertionError):
-        # BiSeNetV1 spatial path channel constraints.
-        SpatialPath(num_channels=(16, 16, 16), in_channels=3)
-
-
-def test_bisenetv1_context_path():
-    backbone_cfg = dict(
-        type='ResNet',
-        in_channels=3,
-        depth=50,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        dilations=(1, 1, 1, 1),
-        strides=(1, 2, 2, 2),
-        norm_eval=False,
-        style='pytorch',
-        contract_dilation=True)
-
-    with pytest.raises(AssertionError):
-        # BiSeNetV1 context path constraints.
-        ContextPath(
-            backbone_cfg=backbone_cfg, context_channels=(16, 32, 64, 128))
-
-
-def test_bisenetv1_attention_refinement_module():
-    x_arm = AttentionRefinementModule(32, 8)
-    assert x_arm.conv_layer.in_channels == 32
-    assert x_arm.conv_layer.out_channels == 8
-    assert x_arm.conv_layer.kernel_size == (3, 3)
-    x = torch.randn(2, 32, 8, 16)
-    x_out = x_arm(x)
-    assert x_out.shape == torch.Size([2, 8, 8, 16])
-
-
-def test_bisenetv1_feature_fusion_module():
-    ffm = FeatureFusionModule(16, 32)
-    assert ffm.conv1.in_channels == 16
-    assert ffm.conv1.out_channels == 32
-    assert ffm.conv1.kernel_size == (1, 1)
-    assert ffm.gap.output_size == (1, 1)
-    assert ffm.conv_atten[0].in_channels == 32
-    assert ffm.conv_atten[0].out_channels == 32
-    assert ffm.conv_atten[0].kernel_size == (1, 1)
-
-    ffm = FeatureFusionModule(16, 16)
-    x1 = torch.randn(2, 8, 8, 16)
-    x2 = torch.randn(2, 8, 8, 16)
-    x_out = ffm(x1, x2)
-    assert x_out.shape == torch.Size([2, 16, 8, 16])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_bisenetv2.py b/mmsegmentation/tests/test_models/test_backbones/test_bisenetv2.py
deleted file mode 100644
index cf2dfb3..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_bisenetv2.py
+++ /dev/null
@@ -1,57 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-from mmcv.cnn import ConvModule
-
-from mmseg.models.backbones import BiSeNetV2
-from mmseg.models.backbones.bisenetv2 import (BGALayer, DetailBranch,
-                                              SemanticBranch)
-
-
-def test_bisenetv2_backbone():
-    # Test BiSeNetV2 Standard Forward
-    model = BiSeNetV2()
-    model.init_weights()
-    model.train()
-    batch_size = 2
-    imgs = torch.randn(batch_size, 3, 128, 256)
-    feat = model(imgs)
-
-    assert len(feat) == 5
-    # output for segment Head
-    assert feat[0].shape == torch.Size([batch_size, 128, 16, 32])
-    # for auxiliary head 1
-    assert feat[1].shape == torch.Size([batch_size, 16, 32, 64])
-    # for auxiliary head 2
-    assert feat[2].shape == torch.Size([batch_size, 32, 16, 32])
-    # for auxiliary head 3
-    assert feat[3].shape == torch.Size([batch_size, 64, 8, 16])
-    # for auxiliary head 4
-    assert feat[4].shape == torch.Size([batch_size, 128, 4, 8])
-
-    # Test input with rare shape
-    batch_size = 2
-    imgs = torch.randn(batch_size, 3, 95, 27)
-    feat = model(imgs)
-    assert len(feat) == 5
-
-
-def test_bisenetv2_DetailBranch():
-    x = torch.randn(1, 3, 32, 64)
-    detail_branch = DetailBranch(detail_channels=(64, 16, 32))
-    assert isinstance(detail_branch.detail_branch[0][0], ConvModule)
-    x_out = detail_branch(x)
-    assert x_out.shape == torch.Size([1, 32, 4, 8])
-
-
-def test_bisenetv2_SemanticBranch():
-    semantic_branch = SemanticBranch(semantic_channels=(16, 32, 64, 128))
-    assert semantic_branch.stage1.pool.stride == 2
-
-
-def test_bisenetv2_BGALayer():
-    x_a = torch.randn(1, 8, 8, 16)
-    x_b = torch.randn(1, 8, 2, 4)
-    bga = BGALayer(out_channels=8)
-    assert isinstance(bga.conv, ConvModule)
-    x_out = bga(x_a, x_b)
-    assert x_out.shape == torch.Size([1, 8, 8, 16])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_blocks.py b/mmsegmentation/tests/test_models/test_backbones/test_blocks.py
deleted file mode 100644
index 7a65d27..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_blocks.py
+++ /dev/null
@@ -1,187 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import mmcv
-import pytest
-import torch
-from mmengine.utils import digit_version
-from mmengine.utils.dl_utils import TORCH_VERSION
-
-from mmseg.models.utils import (InvertedResidual, InvertedResidualV3, SELayer,
-                                make_divisible)
-
-
-def test_make_divisible():
-    # test with min_value = None
-    assert make_divisible(10, 4) == 12
-    assert make_divisible(9, 4) == 12
-    assert make_divisible(1, 4) == 4
-
-    # test with min_value = 8
-    assert make_divisible(10, 4, 8) == 12
-    assert make_divisible(9, 4, 8) == 12
-    assert make_divisible(1, 4, 8) == 8
-
-
-def test_inv_residual():
-    with pytest.raises(AssertionError):
-        # test stride assertion.
-        InvertedResidual(32, 32, 3, 4)
-
-    # test default config with res connection.
-    # set expand_ratio = 4, stride = 1 and inp=oup.
-    inv_module = InvertedResidual(32, 32, 1, 4)
-    assert inv_module.use_res_connect
-    assert inv_module.conv[0].kernel_size == (1, 1)
-    assert inv_module.conv[0].padding == 0
-    assert inv_module.conv[1].kernel_size == (3, 3)
-    assert inv_module.conv[1].padding == 1
-    assert inv_module.conv[0].with_norm
-    assert inv_module.conv[1].with_norm
-    x = torch.rand(1, 32, 64, 64)
-    output = inv_module(x)
-    assert output.shape == (1, 32, 64, 64)
-
-    # test inv_residual module without res connection.
-    # set expand_ratio = 4, stride = 2.
-    inv_module = InvertedResidual(32, 32, 2, 4)
-    assert not inv_module.use_res_connect
-    assert inv_module.conv[0].kernel_size == (1, 1)
-    x = torch.rand(1, 32, 64, 64)
-    output = inv_module(x)
-    assert output.shape == (1, 32, 32, 32)
-
-    # test expand_ratio == 1
-    inv_module = InvertedResidual(32, 32, 1, 1)
-    assert inv_module.conv[0].kernel_size == (3, 3)
-    x = torch.rand(1, 32, 64, 64)
-    output = inv_module(x)
-    assert output.shape == (1, 32, 64, 64)
-
-    # test with checkpoint forward
-    inv_module = InvertedResidual(32, 32, 1, 1, with_cp=True)
-    assert inv_module.with_cp
-    x = torch.rand(1, 32, 64, 64, requires_grad=True)
-    output = inv_module(x)
-    assert output.shape == (1, 32, 64, 64)
-
-
-def test_inv_residualv3():
-    with pytest.raises(AssertionError):
-        # test stride assertion.
-        InvertedResidualV3(32, 32, 16, stride=3)
-
-    with pytest.raises(AssertionError):
-        # test assertion.
-        InvertedResidualV3(32, 32, 16, with_expand_conv=False)
-
-    # test with se_cfg=None, with_expand_conv=False
-    inv_module = InvertedResidualV3(32, 32, 32, with_expand_conv=False)
-
-    assert inv_module.with_res_shortcut is True
-    assert inv_module.with_se is False
-    assert inv_module.with_expand_conv is False
-    assert not hasattr(inv_module, 'expand_conv')
-    assert isinstance(inv_module.depthwise_conv.conv, torch.nn.Conv2d)
-    assert inv_module.depthwise_conv.conv.kernel_size == (3, 3)
-    assert inv_module.depthwise_conv.conv.stride == (1, 1)
-    assert inv_module.depthwise_conv.conv.padding == (1, 1)
-    assert isinstance(inv_module.depthwise_conv.bn, torch.nn.BatchNorm2d)
-    assert isinstance(inv_module.depthwise_conv.activate, torch.nn.ReLU)
-    assert inv_module.linear_conv.conv.kernel_size == (1, 1)
-    assert inv_module.linear_conv.conv.stride == (1, 1)
-    assert inv_module.linear_conv.conv.padding == (0, 0)
-    assert isinstance(inv_module.linear_conv.bn, torch.nn.BatchNorm2d)
-
-    x = torch.rand(1, 32, 64, 64)
-    output = inv_module(x)
-    assert output.shape == (1, 32, 64, 64)
-
-    # test with se_cfg and with_expand_conv
-    se_cfg = dict(
-        channels=16,
-        ratio=4,
-        act_cfg=(dict(type='ReLU'),
-                 dict(type='HSigmoid', bias=3.0, divisor=6.0)))
-    act_cfg = dict(type='HSwish')
-    inv_module = InvertedResidualV3(
-        32, 40, 16, 3, 2, se_cfg=se_cfg, act_cfg=act_cfg)
-    assert inv_module.with_res_shortcut is False
-    assert inv_module.with_se is True
-    assert inv_module.with_expand_conv is True
-    assert inv_module.expand_conv.conv.kernel_size == (1, 1)
-    assert inv_module.expand_conv.conv.stride == (1, 1)
-    assert inv_module.expand_conv.conv.padding == (0, 0)
-
-    assert isinstance(inv_module.depthwise_conv.conv,
-                      mmcv.cnn.bricks.Conv2dAdaptivePadding)
-    assert inv_module.depthwise_conv.conv.kernel_size == (3, 3)
-    assert inv_module.depthwise_conv.conv.stride == (2, 2)
-    assert inv_module.depthwise_conv.conv.padding == (0, 0)
-    assert isinstance(inv_module.depthwise_conv.bn, torch.nn.BatchNorm2d)
-
-    assert inv_module.linear_conv.conv.kernel_size == (1, 1)
-    assert inv_module.linear_conv.conv.stride == (1, 1)
-    assert inv_module.linear_conv.conv.padding == (0, 0)
-    assert isinstance(inv_module.linear_conv.bn, torch.nn.BatchNorm2d)
-
-    if (TORCH_VERSION == 'parrots'
-            or digit_version(TORCH_VERSION) < digit_version('1.7')):
-        # Note: Use PyTorch official HSwish
-        # when torch>=1.7 after MMCV >= 1.4.5.
-        # Hardswish is not supported when PyTorch version < 1.6.
-        # And Hardswish in PyTorch 1.6 does not support inplace.
-        # More details could be found from:
-        # https://github.com/open-mmlab/mmcv/pull/1709
-        assert isinstance(inv_module.expand_conv.activate, mmcv.cnn.HSwish)
-        assert isinstance(inv_module.depthwise_conv.activate, mmcv.cnn.HSwish)
-    else:
-        assert isinstance(inv_module.expand_conv.activate, torch.nn.Hardswish)
-        assert isinstance(inv_module.depthwise_conv.activate,
-                          torch.nn.Hardswish)
-
-    x = torch.rand(1, 32, 64, 64)
-    output = inv_module(x)
-    assert output.shape == (1, 40, 32, 32)
-
-    # test with checkpoint forward
-    inv_module = InvertedResidualV3(
-        32, 40, 16, 3, 2, se_cfg=se_cfg, act_cfg=act_cfg, with_cp=True)
-    assert inv_module.with_cp
-    x = torch.randn(2, 32, 64, 64, requires_grad=True)
-    output = inv_module(x)
-    assert output.shape == (2, 40, 32, 32)
-
-
-def test_se_layer():
-    with pytest.raises(AssertionError):
-        # test act_cfg assertion.
-        SELayer(32, act_cfg=(dict(type='ReLU'), ))
-
-    # test config with channels = 16.
-    se_layer = SELayer(16)
-    assert se_layer.conv1.conv.kernel_size == (1, 1)
-    assert se_layer.conv1.conv.stride == (1, 1)
-    assert se_layer.conv1.conv.padding == (0, 0)
-    assert isinstance(se_layer.conv1.activate, torch.nn.ReLU)
-    assert se_layer.conv2.conv.kernel_size == (1, 1)
-    assert se_layer.conv2.conv.stride == (1, 1)
-    assert se_layer.conv2.conv.padding == (0, 0)
-    assert isinstance(se_layer.conv2.activate, mmcv.cnn.HSigmoid)
-
-    x = torch.rand(1, 16, 64, 64)
-    output = se_layer(x)
-    assert output.shape == (1, 16, 64, 64)
-
-    # test config with channels = 16, act_cfg = dict(type='ReLU').
-    se_layer = SELayer(16, act_cfg=dict(type='ReLU'))
-    assert se_layer.conv1.conv.kernel_size == (1, 1)
-    assert se_layer.conv1.conv.stride == (1, 1)
-    assert se_layer.conv1.conv.padding == (0, 0)
-    assert isinstance(se_layer.conv1.activate, torch.nn.ReLU)
-    assert se_layer.conv2.conv.kernel_size == (1, 1)
-    assert se_layer.conv2.conv.stride == (1, 1)
-    assert se_layer.conv2.conv.padding == (0, 0)
-    assert isinstance(se_layer.conv2.activate, torch.nn.ReLU)
-
-    x = torch.rand(1, 16, 64, 64)
-    output = se_layer(x)
-    assert output.shape == (1, 16, 64, 64)
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_cgnet.py b/mmsegmentation/tests/test_models/test_backbones/test_cgnet.py
deleted file mode 100644
index f938525..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_cgnet.py
+++ /dev/null
@@ -1,151 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.backbones import CGNet
-from mmseg.models.backbones.cgnet import (ContextGuidedBlock,
-                                          GlobalContextExtractor)
-
-
-def test_cgnet_GlobalContextExtractor():
-    block = GlobalContextExtractor(16, 16, with_cp=True)
-    x = torch.randn(2, 16, 64, 64, requires_grad=True)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([2, 16, 64, 64])
-
-
-def test_cgnet_context_guided_block():
-    with pytest.raises(AssertionError):
-        # cgnet ContextGuidedBlock GlobalContextExtractor channel and reduction
-        # constraints.
-        ContextGuidedBlock(8, 8)
-
-    # test cgnet ContextGuidedBlock with checkpoint forward
-    block = ContextGuidedBlock(
-        16, 16, act_cfg=dict(type='PReLU'), with_cp=True)
-    assert block.with_cp
-    x = torch.randn(2, 16, 64, 64, requires_grad=True)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([2, 16, 64, 64])
-
-    # test cgnet ContextGuidedBlock without checkpoint forward
-    block = ContextGuidedBlock(32, 32)
-    assert not block.with_cp
-    x = torch.randn(3, 32, 32, 32)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([3, 32, 32, 32])
-
-    # test cgnet ContextGuidedBlock with down sampling
-    block = ContextGuidedBlock(32, 32, downsample=True)
-    assert block.conv1x1.conv.in_channels == 32
-    assert block.conv1x1.conv.out_channels == 32
-    assert block.conv1x1.conv.kernel_size == (3, 3)
-    assert block.conv1x1.conv.stride == (2, 2)
-    assert block.conv1x1.conv.padding == (1, 1)
-
-    assert block.f_loc.in_channels == 32
-    assert block.f_loc.out_channels == 32
-    assert block.f_loc.kernel_size == (3, 3)
-    assert block.f_loc.stride == (1, 1)
-    assert block.f_loc.padding == (1, 1)
-    assert block.f_loc.groups == 32
-    assert block.f_loc.dilation == (1, 1)
-    assert block.f_loc.bias is None
-
-    assert block.f_sur.in_channels == 32
-    assert block.f_sur.out_channels == 32
-    assert block.f_sur.kernel_size == (3, 3)
-    assert block.f_sur.stride == (1, 1)
-    assert block.f_sur.padding == (2, 2)
-    assert block.f_sur.groups == 32
-    assert block.f_sur.dilation == (2, 2)
-    assert block.f_sur.bias is None
-
-    assert block.bottleneck.in_channels == 64
-    assert block.bottleneck.out_channels == 32
-    assert block.bottleneck.kernel_size == (1, 1)
-    assert block.bottleneck.stride == (1, 1)
-    assert block.bottleneck.bias is None
-
-    x = torch.randn(1, 32, 32, 32)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([1, 32, 16, 16])
-
-    # test cgnet ContextGuidedBlock without down sampling
-    block = ContextGuidedBlock(32, 32, downsample=False)
-    assert block.conv1x1.conv.in_channels == 32
-    assert block.conv1x1.conv.out_channels == 16
-    assert block.conv1x1.conv.kernel_size == (1, 1)
-    assert block.conv1x1.conv.stride == (1, 1)
-    assert block.conv1x1.conv.padding == (0, 0)
-
-    assert block.f_loc.in_channels == 16
-    assert block.f_loc.out_channels == 16
-    assert block.f_loc.kernel_size == (3, 3)
-    assert block.f_loc.stride == (1, 1)
-    assert block.f_loc.padding == (1, 1)
-    assert block.f_loc.groups == 16
-    assert block.f_loc.dilation == (1, 1)
-    assert block.f_loc.bias is None
-
-    assert block.f_sur.in_channels == 16
-    assert block.f_sur.out_channels == 16
-    assert block.f_sur.kernel_size == (3, 3)
-    assert block.f_sur.stride == (1, 1)
-    assert block.f_sur.padding == (2, 2)
-    assert block.f_sur.groups == 16
-    assert block.f_sur.dilation == (2, 2)
-    assert block.f_sur.bias is None
-
-    x = torch.randn(1, 32, 32, 32)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([1, 32, 32, 32])
-
-
-def test_cgnet_backbone():
-    with pytest.raises(AssertionError):
-        # check invalid num_channels
-        CGNet(num_channels=(32, 64, 128, 256))
-
-    with pytest.raises(AssertionError):
-        # check invalid num_blocks
-        CGNet(num_blocks=(3, 21, 3))
-
-    with pytest.raises(AssertionError):
-        # check invalid dilation
-        CGNet(num_blocks=2)
-
-    with pytest.raises(AssertionError):
-        # check invalid reduction
-        CGNet(reductions=16)
-
-    with pytest.raises(AssertionError):
-        # check invalid num_channels and reduction
-        CGNet(num_channels=(32, 64, 128), reductions=(64, 129))
-
-    # Test CGNet with default settings
-    model = CGNet()
-    model.init_weights()
-    model.train()
-
-    imgs = torch.randn(2, 3, 224, 224)
-    feat = model(imgs)
-    assert len(feat) == 3
-    assert feat[0].shape == torch.Size([2, 35, 112, 112])
-    assert feat[1].shape == torch.Size([2, 131, 56, 56])
-    assert feat[2].shape == torch.Size([2, 256, 28, 28])
-
-    # Test CGNet with norm_eval True and with_cp True
-    model = CGNet(norm_eval=True, with_cp=True)
-    with pytest.raises(TypeError):
-        # check invalid pretrained
-        model.init_weights(pretrained=8)
-    model.init_weights()
-    model.train()
-
-    imgs = torch.randn(2, 3, 224, 224)
-    feat = model(imgs)
-    assert len(feat) == 3
-    assert feat[0].shape == torch.Size([2, 35, 112, 112])
-    assert feat[1].shape == torch.Size([2, 131, 56, 56])
-    assert feat[2].shape == torch.Size([2, 256, 28, 28])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_clip_text_encoder.py b/mmsegmentation/tests/test_models/test_backbones/test_clip_text_encoder.py
deleted file mode 100644
index ea06c5b..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_clip_text_encoder.py
+++ /dev/null
@@ -1,43 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-from mmengine import Config
-from mmengine.registry import init_default_scope
-
-from mmseg.models.text_encoder import CLIPTextEncoder
-from mmseg.utils import get_classes
-
-
-def test_clip_text_encoder():
-    init_default_scope('mmseg')
-    # test vocabulary
-    output_dims = 8
-    embed_dims = 32
-    vocabulary = ['cat', 'dog', 'bird', 'car', 'bike']
-    cfg = dict(
-        vocabulary=vocabulary,
-        templates=['a photo of a {}.'],
-        embed_dims=embed_dims,
-        output_dims=output_dims)
-    cfg = Config(cfg)
-
-    text_encoder = CLIPTextEncoder(**cfg)
-    if torch.cuda.is_available():
-        text_encoder = text_encoder.cuda()
-
-    with torch.no_grad():
-        class_embeds = text_encoder()
-        assert class_embeds.shape == (len(vocabulary) + 1, output_dims)
-
-    # test dataset name
-    cfg = dict(
-        dataset_name='vaihingen',
-        templates=['a photo of a {}.'],
-        embed_dims=embed_dims,
-        output_dims=output_dims)
-    cfg = Config(cfg)
-
-    text_encoder = CLIPTextEncoder(**cfg)
-    with torch.no_grad():
-        class_embeds = text_encoder()
-        class_nums = len(get_classes('vaihingen'))
-        assert class_embeds.shape == (class_nums + 1, output_dims)
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_erfnet.py b/mmsegmentation/tests/test_models/test_backbones/test_erfnet.py
deleted file mode 100644
index 6ae7345..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_erfnet.py
+++ /dev/null
@@ -1,146 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.backbones import ERFNet
-from mmseg.models.backbones.erfnet import (DownsamplerBlock, NonBottleneck1d,
-                                           UpsamplerBlock)
-
-
-def test_erfnet_backbone():
-    # Test ERFNet Standard Forward.
-    model = ERFNet(
-        in_channels=3,
-        enc_downsample_channels=(16, 64, 128),
-        enc_stage_non_bottlenecks=(5, 8),
-        enc_non_bottleneck_dilations=(2, 4, 8, 16),
-        enc_non_bottleneck_channels=(64, 128),
-        dec_upsample_channels=(64, 16),
-        dec_stages_non_bottleneck=(2, 2),
-        dec_non_bottleneck_channels=(64, 16),
-        dropout_ratio=0.1,
-    )
-    model.init_weights()
-    model.train()
-    batch_size = 2
-    imgs = torch.randn(batch_size, 3, 256, 512)
-    output = model(imgs)
-
-    # output for segment Head
-    assert output[0].shape == torch.Size([batch_size, 16, 128, 256])
-
-    # Test input with rare shape
-    batch_size = 2
-    imgs = torch.randn(batch_size, 3, 527, 279)
-    output = model(imgs)
-    assert len(output[0]) == batch_size
-
-    with pytest.raises(AssertionError):
-        # Number of encoder downsample block and decoder upsample block.
-        ERFNet(
-            in_channels=3,
-            enc_downsample_channels=(16, 64, 128),
-            enc_stage_non_bottlenecks=(5, 8),
-            enc_non_bottleneck_dilations=(2, 4, 8, 16),
-            enc_non_bottleneck_channels=(64, 128),
-            dec_upsample_channels=(128, 64, 16),
-            dec_stages_non_bottleneck=(2, 2),
-            dec_non_bottleneck_channels=(64, 16),
-            dropout_ratio=0.1,
-        )
-    with pytest.raises(AssertionError):
-        # Number of encoder downsample block and encoder Non-bottleneck block.
-        ERFNet(
-            in_channels=3,
-            enc_downsample_channels=(16, 64, 128),
-            enc_stage_non_bottlenecks=(5, 8, 10),
-            enc_non_bottleneck_dilations=(2, 4, 8, 16),
-            enc_non_bottleneck_channels=(64, 128),
-            dec_upsample_channels=(64, 16),
-            dec_stages_non_bottleneck=(2, 2),
-            dec_non_bottleneck_channels=(64, 16),
-            dropout_ratio=0.1,
-        )
-    with pytest.raises(AssertionError):
-        # Number of encoder downsample block and
-        # channels of encoder Non-bottleneck block.
-        ERFNet(
-            in_channels=3,
-            enc_downsample_channels=(16, 64, 128),
-            enc_stage_non_bottlenecks=(5, 8),
-            enc_non_bottleneck_dilations=(2, 4, 8, 16),
-            enc_non_bottleneck_channels=(64, 128, 256),
-            dec_upsample_channels=(64, 16),
-            dec_stages_non_bottleneck=(2, 2),
-            dec_non_bottleneck_channels=(64, 16),
-            dropout_ratio=0.1,
-        )
-
-    with pytest.raises(AssertionError):
-        # Number of encoder Non-bottleneck block and number of its channels.
-        ERFNet(
-            in_channels=3,
-            enc_downsample_channels=(16, 64, 128),
-            enc_stage_non_bottlenecks=(5, 8, 3),
-            enc_non_bottleneck_dilations=(2, 4, 8, 16),
-            enc_non_bottleneck_channels=(64, 128),
-            dec_upsample_channels=(64, 16),
-            dec_stages_non_bottleneck=(2, 2),
-            dec_non_bottleneck_channels=(64, 16),
-            dropout_ratio=0.1,
-        )
-    with pytest.raises(AssertionError):
-        # Number of decoder upsample block and decoder Non-bottleneck block.
-        ERFNet(
-            in_channels=3,
-            enc_downsample_channels=(16, 64, 128),
-            enc_stage_non_bottlenecks=(5, 8),
-            enc_non_bottleneck_dilations=(2, 4, 8, 16),
-            enc_non_bottleneck_channels=(64, 128),
-            dec_upsample_channels=(64, 16),
-            dec_stages_non_bottleneck=(2, 2, 3),
-            dec_non_bottleneck_channels=(64, 16),
-            dropout_ratio=0.1,
-        )
-    with pytest.raises(AssertionError):
-        # Number of decoder Non-bottleneck block and number of its channels.
-        ERFNet(
-            in_channels=3,
-            enc_downsample_channels=(16, 64, 128),
-            enc_stage_non_bottlenecks=(5, 8),
-            enc_non_bottleneck_dilations=(2, 4, 8, 16),
-            enc_non_bottleneck_channels=(64, 128),
-            dec_upsample_channels=(64, 16),
-            dec_stages_non_bottleneck=(2, 2),
-            dec_non_bottleneck_channels=(64, 16, 8),
-            dropout_ratio=0.1,
-        )
-
-
-def test_erfnet_downsampler_block():
-    x_db = DownsamplerBlock(16, 64)
-    assert x_db.conv.in_channels == 16
-    assert x_db.conv.out_channels == 48
-    assert len(x_db.bn.weight) == 64
-    assert x_db.pool.kernel_size == 2
-    assert x_db.pool.stride == 2
-
-
-def test_erfnet_non_bottleneck_1d():
-    x_nb1d = NonBottleneck1d(16, 0, 1)
-    assert x_nb1d.convs_layers[0].in_channels == 16
-    assert x_nb1d.convs_layers[0].out_channels == 16
-    assert x_nb1d.convs_layers[2].in_channels == 16
-    assert x_nb1d.convs_layers[2].out_channels == 16
-    assert x_nb1d.convs_layers[5].in_channels == 16
-    assert x_nb1d.convs_layers[5].out_channels == 16
-    assert x_nb1d.convs_layers[7].in_channels == 16
-    assert x_nb1d.convs_layers[7].out_channels == 16
-    assert x_nb1d.convs_layers[9].p == 0
-
-
-def test_erfnet_upsampler_block():
-    x_ub = UpsamplerBlock(64, 16)
-    assert x_ub.conv.in_channels == 64
-    assert x_ub.conv.out_channels == 16
-    assert len(x_ub.bn.weight) == 16
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_fast_scnn.py b/mmsegmentation/tests/test_models/test_backbones/test_fast_scnn.py
deleted file mode 100644
index 7ee638b..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_fast_scnn.py
+++ /dev/null
@@ -1,42 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.backbones import FastSCNN
-
-
-def test_fastscnn_backbone():
-    with pytest.raises(AssertionError):
-        # Fast-SCNN channel constraints.
-        FastSCNN(
-            3, (32, 48),
-            64, (64, 96, 128), (2, 2, 1),
-            global_out_channels=127,
-            higher_in_channels=64,
-            lower_in_channels=128)
-
-    # Test FastSCNN Standard Forward
-    model = FastSCNN(
-        in_channels=3,
-        downsample_dw_channels=(4, 6),
-        global_in_channels=8,
-        global_block_channels=(8, 12, 16),
-        global_block_strides=(2, 2, 1),
-        global_out_channels=16,
-        higher_in_channels=8,
-        lower_in_channels=16,
-        fusion_out_channels=16,
-    )
-    model.init_weights()
-    model.train()
-    batch_size = 4
-    imgs = torch.randn(batch_size, 3, 64, 128)
-    feat = model(imgs)
-
-    assert len(feat) == 3
-    # higher-res
-    assert feat[0].shape == torch.Size([batch_size, 8, 8, 16])
-    # lower-res
-    assert feat[1].shape == torch.Size([batch_size, 16, 2, 4])
-    # FFM output
-    assert feat[2].shape == torch.Size([batch_size, 16, 8, 16])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_hrnet.py b/mmsegmentation/tests/test_models/test_backbones/test_hrnet.py
deleted file mode 100644
index 3e35515..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_hrnet.py
+++ /dev/null
@@ -1,144 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-from mmengine.utils.dl_utils.parrots_wrapper import _BatchNorm
-
-from mmseg.models.backbones.hrnet import HRModule, HRNet
-from mmseg.models.backbones.resnet import BasicBlock, Bottleneck
-
-
-@pytest.mark.parametrize('block', [BasicBlock, Bottleneck])
-def test_hrmodule(block):
-    # Test multiscale forward
-    num_channles = (32, 64)
-    in_channels = [c * block.expansion for c in num_channles]
-    hrmodule = HRModule(
-        num_branches=2,
-        blocks=block,
-        in_channels=in_channels,
-        num_blocks=(4, 4),
-        num_channels=num_channles,
-    )
-
-    feats = [
-        torch.randn(1, in_channels[0], 64, 64),
-        torch.randn(1, in_channels[1], 32, 32)
-    ]
-    feats = hrmodule(feats)
-
-    assert len(feats) == 2
-    assert feats[0].shape == torch.Size([1, in_channels[0], 64, 64])
-    assert feats[1].shape == torch.Size([1, in_channels[1], 32, 32])
-
-    # Test single scale forward
-    num_channles = (32, 64)
-    in_channels = [c * block.expansion for c in num_channles]
-    hrmodule = HRModule(
-        num_branches=2,
-        blocks=block,
-        in_channels=in_channels,
-        num_blocks=(4, 4),
-        num_channels=num_channles,
-        multiscale_output=False,
-    )
-
-    feats = [
-        torch.randn(1, in_channels[0], 64, 64),
-        torch.randn(1, in_channels[1], 32, 32)
-    ]
-    feats = hrmodule(feats)
-
-    assert len(feats) == 1
-    assert feats[0].shape == torch.Size([1, in_channels[0], 64, 64])
-
-
-def test_hrnet_backbone():
-    # only have 3 stages
-    extra = dict(
-        stage1=dict(
-            num_modules=1,
-            num_branches=1,
-            block='BOTTLENECK',
-            num_blocks=(4, ),
-            num_channels=(64, )),
-        stage2=dict(
-            num_modules=1,
-            num_branches=2,
-            block='BASIC',
-            num_blocks=(4, 4),
-            num_channels=(32, 64)),
-        stage3=dict(
-            num_modules=4,
-            num_branches=3,
-            block='BASIC',
-            num_blocks=(4, 4, 4),
-            num_channels=(32, 64, 128)))
-
-    with pytest.raises(AssertionError):
-        # HRNet now only support 4 stages
-        HRNet(extra=extra)
-    extra['stage4'] = dict(
-        num_modules=3,
-        num_branches=3,  # should be 4
-        block='BASIC',
-        num_blocks=(4, 4, 4, 4),
-        num_channels=(32, 64, 128, 256))
-
-    with pytest.raises(AssertionError):
-        # len(num_blocks) should equal num_branches
-        HRNet(extra=extra)
-
-    extra['stage4']['num_branches'] = 4
-
-    # Test hrnetv2p_w32
-    model = HRNet(extra=extra)
-    model.init_weights()
-    model.train()
-
-    imgs = torch.randn(1, 3, 64, 64)
-    feats = model(imgs)
-    assert len(feats) == 4
-    assert feats[0].shape == torch.Size([1, 32, 16, 16])
-    assert feats[3].shape == torch.Size([1, 256, 2, 2])
-
-    # Test single scale output
-    model = HRNet(extra=extra, multiscale_output=False)
-    model.init_weights()
-    model.train()
-
-    imgs = torch.randn(1, 3, 64, 64)
-    feats = model(imgs)
-    assert len(feats) == 1
-    assert feats[0].shape == torch.Size([1, 32, 16, 16])
-
-    # Test HRNET with two stage frozen
-    frozen_stages = 2
-    model = HRNet(extra, frozen_stages=frozen_stages)
-    model.init_weights()
-    model.train()
-    assert model.norm1.training is False
-
-    for layer in [model.conv1, model.norm1]:
-        for param in layer.parameters():
-            assert param.requires_grad is False
-    for i in range(1, frozen_stages + 1):
-        if i == 1:
-            layer = getattr(model, f'layer{i}')
-            transition = getattr(model, f'transition{i}')
-        elif i == 4:
-            layer = getattr(model, f'stage{i}')
-        else:
-            layer = getattr(model, f'stage{i}')
-            transition = getattr(model, f'transition{i}')
-
-        for mod in layer.modules():
-            if isinstance(mod, _BatchNorm):
-                assert mod.training is False
-        for param in layer.parameters():
-            assert param.requires_grad is False
-
-        for mod in transition.modules():
-            if isinstance(mod, _BatchNorm):
-                assert mod.training is False
-        for param in transition.parameters():
-            assert param.requires_grad is False
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_icnet.py b/mmsegmentation/tests/test_models/test_backbones/test_icnet.py
deleted file mode 100644
index a96d8d8..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_icnet.py
+++ /dev/null
@@ -1,50 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.backbones import ICNet
-
-
-def test_icnet_backbone():
-    with pytest.raises(TypeError):
-        # Must give backbone dict in config file.
-        ICNet(
-            in_channels=3,
-            layer_channels=(128, 512),
-            light_branch_middle_channels=8,
-            psp_out_channels=128,
-            out_channels=(16, 128, 128),
-            backbone_cfg=None)
-
-    # Test ICNet Standard Forward
-    model = ICNet(
-        layer_channels=(128, 512),
-        backbone_cfg=dict(
-            type='ResNetV1c',
-            in_channels=3,
-            depth=18,
-            num_stages=4,
-            out_indices=(0, 1, 2, 3),
-            dilations=(1, 1, 2, 4),
-            strides=(1, 2, 1, 1),
-            norm_cfg=dict(type='BN', requires_grad=True),
-            norm_eval=False,
-            style='pytorch',
-            contract_dilation=True),
-    )
-    assert hasattr(model.backbone,
-                   'maxpool') and model.backbone.maxpool.ceil_mode is True
-    model.init_weights()
-    model.train()
-    batch_size = 2
-    imgs = torch.randn(batch_size, 3, 32, 64)
-    feat = model(imgs)
-
-    assert model.psp_modules[0][0].output_size == 1
-    assert model.psp_modules[1][0].output_size == 2
-    assert model.psp_modules[2][0].output_size == 3
-    assert model.psp_bottleneck.padding == 1
-    assert model.conv_sub1[0].padding == 1
-
-    assert len(feat) == 3
-    assert feat[0].shape == torch.Size([batch_size, 64, 4, 8])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_mae.py b/mmsegmentation/tests/test_models/test_backbones/test_mae.py
deleted file mode 100644
index 16f52b5..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_mae.py
+++ /dev/null
@@ -1,186 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.backbones.mae import MAE
-from .utils import check_norm_state
-
-
-def test_mae_backbone():
-    with pytest.raises(TypeError):
-        # pretrained must be a string path
-        model = MAE()
-        model.init_weights(pretrained=0)
-
-    with pytest.raises(TypeError):
-        # img_size must be int or tuple
-        model = MAE(img_size=512.0)
-
-    with pytest.raises(TypeError):
-        # out_indices must be int ,list or tuple
-        model = MAE(out_indices=1.)
-
-    with pytest.raises(AssertionError):
-        # The length of img_size tuple must be lower than 3.
-        MAE(img_size=(224, 224, 224))
-
-    with pytest.raises(TypeError):
-        # Pretrained must be None or Str.
-        MAE(pretrained=123)
-
-    # Test img_size isinstance tuple
-    imgs = torch.randn(1, 3, 224, 224)
-    model = MAE(img_size=(224, ))
-    model.init_weights()
-    model(imgs)
-
-    # Test img_size isinstance tuple
-    imgs = torch.randn(1, 3, 224, 224)
-    model = MAE(img_size=(224, 224))
-    model(imgs)
-
-    # Test norm_eval = True
-    model = MAE(norm_eval=True)
-    model.train()
-
-    # Test BEiT backbone with input size of 224 and patch size of 16
-    model = MAE()
-    model.init_weights()
-    model.train()
-
-    # Test out_indices = list
-    model = MAE(out_indices=[2, 4, 8, 12])
-    model.train()
-
-    assert check_norm_state(model.modules(), True)
-
-    # Test image size = (224, 224)
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 14, 14)
-
-    # Test MAE backbone with input size of 256 and patch size of 16
-    model = MAE(img_size=(256, 256))
-    model.init_weights()
-    model.train()
-    imgs = torch.randn(1, 3, 256, 256)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 16, 16)
-
-    # Test MAE backbone with input size of 32 and patch size of 16
-    model = MAE(img_size=(32, 32))
-    model.init_weights()
-    model.train()
-    imgs = torch.randn(1, 3, 32, 32)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 2, 2)
-
-    # Test unbalanced size input image
-    model = MAE(img_size=(112, 224))
-    model.init_weights()
-    model.train()
-    imgs = torch.randn(1, 3, 112, 224)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 7, 14)
-
-    # Test irregular input image
-    model = MAE(img_size=(234, 345))
-    model.init_weights()
-    model.train()
-    imgs = torch.randn(1, 3, 234, 345)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 14, 21)
-
-    # Test init_values=0
-    model = MAE(init_values=0)
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 14, 14)
-
-    # Test final norm
-    model = MAE(final_norm=True)
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 14, 14)
-
-    # Test patch norm
-    model = MAE(patch_norm=True)
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 14, 14)
-
-
-def test_mae_init():
-    path = 'PATH_THAT_DO_NOT_EXIST'
-    # Test all combinations of pretrained and init_cfg
-    # pretrained=None, init_cfg=None
-    model = MAE(pretrained=None, init_cfg=None)
-    assert model.init_cfg is None
-    model.init_weights()
-
-    # pretrained=None
-    # init_cfg loads pretrain from an non-existent file
-    model = MAE(
-        pretrained=None, init_cfg=dict(type='Pretrained', checkpoint=path))
-    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
-    # Test loading a checkpoint from an non-existent file
-    with pytest.raises(OSError):
-        model.init_weights()
-
-    # test resize_rel_pos_embed
-    value = torch.randn(732, 16)
-    abs_pos_embed_value = torch.rand(1, 17, 768)
-    ckpt = {
-        'state_dict': {
-            'layers.0.attn.relative_position_index': 0,
-            'layers.0.attn.relative_position_bias_table': value,
-            'pos_embed': abs_pos_embed_value
-        }
-    }
-    model = MAE(img_size=(512, 512))
-    # If scipy is installed, this AttributeError would not be raised.
-    from mmengine.utils import is_installed
-    if not is_installed('scipy'):
-        with pytest.raises(AttributeError):
-            model.resize_rel_pos_embed(ckpt)
-
-    # test resize abs pos embed
-    ckpt = model.resize_abs_pos_embed(ckpt['state_dict'])
-
-    # pretrained=None
-    # init_cfg=123, whose type is unsupported
-    model = MAE(pretrained=None, init_cfg=123)
-    with pytest.raises(TypeError):
-        model.init_weights()
-
-    # pretrained loads pretrain from an non-existent file
-    # init_cfg=None
-    model = MAE(pretrained=path, init_cfg=None)
-    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
-    # Test loading a checkpoint from an non-existent file
-    with pytest.raises(OSError):
-        model.init_weights()
-
-    # pretrained loads pretrain from an non-existent file
-    # init_cfg loads pretrain from an non-existent file
-    with pytest.raises(AssertionError):
-        model = MAE(
-            pretrained=path, init_cfg=dict(type='Pretrained', checkpoint=path))
-    with pytest.raises(AssertionError):
-        model = MAE(pretrained=path, init_cfg=123)
-
-    # pretrain=123, whose type is unsupported
-    # init_cfg=None
-    with pytest.raises(TypeError):
-        model = MAE(pretrained=123, init_cfg=None)
-
-    # pretrain=123, whose type is unsupported
-    # init_cfg loads pretrain from an non-existent file
-    with pytest.raises(AssertionError):
-        model = MAE(
-            pretrained=123, init_cfg=dict(type='Pretrained', checkpoint=path))
-
-    # pretrain=123, whose type is unsupported
-    # init_cfg=123, whose type is unsupported
-    with pytest.raises(AssertionError):
-        model = MAE(pretrained=123, init_cfg=123)
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_mit.py b/mmsegmentation/tests/test_models/test_backbones/test_mit.py
deleted file mode 100644
index 72f74fe..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_mit.py
+++ /dev/null
@@ -1,122 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.backbones import MixVisionTransformer
-from mmseg.models.backbones.mit import (EfficientMultiheadAttention, MixFFN,
-                                        TransformerEncoderLayer)
-
-
-def test_mit():
-    with pytest.raises(TypeError):
-        # Pretrained represents pretrain url and must be str or None.
-        MixVisionTransformer(pretrained=123)
-
-    # Test normal input
-    H, W = (224, 224)
-    temp = torch.randn((1, 3, H, W))
-    model = MixVisionTransformer(
-        embed_dims=32, num_heads=[1, 2, 5, 8], out_indices=(0, 1, 2, 3))
-    model.init_weights()
-    outs = model(temp)
-    assert outs[0].shape == (1, 32, H // 4, W // 4)
-    assert outs[1].shape == (1, 64, H // 8, W // 8)
-    assert outs[2].shape == (1, 160, H // 16, W // 16)
-    assert outs[3].shape == (1, 256, H // 32, W // 32)
-
-    # Test non-squared input
-    H, W = (224, 256)
-    temp = torch.randn((1, 3, H, W))
-    outs = model(temp)
-    assert outs[0].shape == (1, 32, H // 4, W // 4)
-    assert outs[1].shape == (1, 64, H // 8, W // 8)
-    assert outs[2].shape == (1, 160, H // 16, W // 16)
-    assert outs[3].shape == (1, 256, H // 32, W // 32)
-
-    # Test MixFFN
-    FFN = MixFFN(64, 128)
-    hw_shape = (32, 32)
-    token_len = 32 * 32
-    temp = torch.randn((1, token_len, 64))
-    # Self identity
-    out = FFN(temp, hw_shape)
-    assert out.shape == (1, token_len, 64)
-    # Out identity
-    outs = FFN(temp, hw_shape, temp)
-    assert out.shape == (1, token_len, 64)
-
-    # Test EfficientMHA
-    MHA = EfficientMultiheadAttention(64, 2)
-    hw_shape = (32, 32)
-    token_len = 32 * 32
-    temp = torch.randn((1, token_len, 64))
-    # Self identity
-    out = MHA(temp, hw_shape)
-    assert out.shape == (1, token_len, 64)
-    # Out identity
-    outs = MHA(temp, hw_shape, temp)
-    assert out.shape == (1, token_len, 64)
-
-    # Test TransformerEncoderLayer with checkpoint forward
-    block = TransformerEncoderLayer(
-        embed_dims=64, num_heads=4, feedforward_channels=256, with_cp=True)
-    assert block.with_cp
-    x = torch.randn(1, 56 * 56, 64)
-    x_out = block(x, (56, 56))
-    assert x_out.shape == torch.Size([1, 56 * 56, 64])
-
-
-def test_mit_init():
-    path = 'PATH_THAT_DO_NOT_EXIST'
-    # Test all combinations of pretrained and init_cfg
-    # pretrained=None, init_cfg=None
-    model = MixVisionTransformer(pretrained=None, init_cfg=None)
-    assert model.init_cfg is None
-    model.init_weights()
-
-    # pretrained=None
-    # init_cfg loads pretrain from an non-existent file
-    model = MixVisionTransformer(
-        pretrained=None, init_cfg=dict(type='Pretrained', checkpoint=path))
-    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
-    # Test loading a checkpoint from an non-existent file
-    with pytest.raises(OSError):
-        model.init_weights()
-
-    # pretrained=None
-    # init_cfg=123, whose type is unsupported
-    model = MixVisionTransformer(pretrained=None, init_cfg=123)
-    with pytest.raises(TypeError):
-        model.init_weights()
-
-    # pretrained loads pretrain from an non-existent file
-    # init_cfg=None
-    model = MixVisionTransformer(pretrained=path, init_cfg=None)
-    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
-    # Test loading a checkpoint from an non-existent file
-    with pytest.raises(OSError):
-        model.init_weights()
-
-    # pretrained loads pretrain from an non-existent file
-    # init_cfg loads pretrain from an non-existent file
-    with pytest.raises(AssertionError):
-        MixVisionTransformer(
-            pretrained=path, init_cfg=dict(type='Pretrained', checkpoint=path))
-    with pytest.raises(AssertionError):
-        MixVisionTransformer(pretrained=path, init_cfg=123)
-
-    # pretrain=123, whose type is unsupported
-    # init_cfg=None
-    with pytest.raises(TypeError):
-        MixVisionTransformer(pretrained=123, init_cfg=None)
-
-    # pretrain=123, whose type is unsupported
-    # init_cfg loads pretrain from an non-existent file
-    with pytest.raises(AssertionError):
-        MixVisionTransformer(
-            pretrained=123, init_cfg=dict(type='Pretrained', checkpoint=path))
-
-    # pretrain=123, whose type is unsupported
-    # init_cfg=123, whose type is unsupported
-    with pytest.raises(AssertionError):
-        MixVisionTransformer(pretrained=123, init_cfg=123)
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_mobilenet_v3.py b/mmsegmentation/tests/test_models/test_backbones/test_mobilenet_v3.py
deleted file mode 100644
index 769ee14..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_mobilenet_v3.py
+++ /dev/null
@@ -1,67 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.backbones import MobileNetV3
-
-
-def test_mobilenet_v3():
-    with pytest.raises(AssertionError):
-        # check invalid arch
-        MobileNetV3('big')
-
-    with pytest.raises(AssertionError):
-        # check invalid reduction_factor
-        MobileNetV3(reduction_factor=0)
-
-    with pytest.raises(ValueError):
-        # check invalid out_indices
-        MobileNetV3(out_indices=(0, 1, 15))
-
-    with pytest.raises(ValueError):
-        # check invalid frozen_stages
-        MobileNetV3(frozen_stages=15)
-
-    with pytest.raises(TypeError):
-        # check invalid pretrained
-        model = MobileNetV3()
-        model.init_weights(pretrained=8)
-
-    # Test MobileNetV3 with default settings
-    model = MobileNetV3()
-    model.init_weights()
-    model.train()
-
-    imgs = torch.randn(2, 3, 56, 56)
-    feat = model(imgs)
-    assert len(feat) == 3
-    assert feat[0].shape == (2, 16, 28, 28)
-    assert feat[1].shape == (2, 16, 14, 14)
-    assert feat[2].shape == (2, 576, 7, 7)
-
-    # Test MobileNetV3 with arch = 'large'
-    model = MobileNetV3(arch='large', out_indices=(1, 3, 16))
-    model.init_weights()
-    model.train()
-
-    imgs = torch.randn(2, 3, 56, 56)
-    feat = model(imgs)
-    assert len(feat) == 3
-    assert feat[0].shape == (2, 16, 28, 28)
-    assert feat[1].shape == (2, 24, 14, 14)
-    assert feat[2].shape == (2, 960, 7, 7)
-
-    # Test MobileNetV3 with norm_eval True, with_cp True and frozen_stages=5
-    model = MobileNetV3(norm_eval=True, with_cp=True, frozen_stages=5)
-    with pytest.raises(TypeError):
-        # check invalid pretrained
-        model.init_weights(pretrained=8)
-    model.init_weights()
-    model.train()
-
-    imgs = torch.randn(2, 3, 56, 56)
-    feat = model(imgs)
-    assert len(feat) == 3
-    assert feat[0].shape == (2, 16, 28, 28)
-    assert feat[1].shape == (2, 16, 14, 14)
-    assert feat[2].shape == (2, 576, 7, 7)
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_mscan.py b/mmsegmentation/tests/test_models/test_backbones/test_mscan.py
deleted file mode 100644
index 84dfb8e..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_mscan.py
+++ /dev/null
@@ -1,69 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-
-from mmseg.models.backbones import MSCAN
-from mmseg.models.backbones.mscan import (MSCAAttention, MSCASpatialAttention,
-                                          OverlapPatchEmbed, StemConv)
-
-
-def test_mscan_backbone():
-    # Test MSCAN Standard Forward
-    model = MSCAN(
-        embed_dims=[8, 16, 32, 64],
-        norm_cfg=dict(type='BN', requires_grad=True))
-    model.init_weights()
-    model.train()
-    batch_size = 2
-    imgs = torch.randn(batch_size, 3, 64, 128)
-    feat = model(imgs)
-
-    assert len(feat) == 4
-    # output for segment Head
-    assert feat[0].shape == torch.Size([batch_size, 8, 16, 32])
-    assert feat[1].shape == torch.Size([batch_size, 16, 8, 16])
-    assert feat[2].shape == torch.Size([batch_size, 32, 4, 8])
-    assert feat[3].shape == torch.Size([batch_size, 64, 2, 4])
-
-    # Test input with rare shape
-    batch_size = 2
-    imgs = torch.randn(batch_size, 3, 95, 27)
-    feat = model(imgs)
-    assert len(feat) == 4
-
-
-def test_mscan_overlap_patch_embed_module():
-    x_overlap_patch_embed = OverlapPatchEmbed(
-        norm_cfg=dict(type='BN', requires_grad=True))
-    assert x_overlap_patch_embed.proj.in_channels == 3
-    assert x_overlap_patch_embed.norm.weight.shape == torch.Size([768])
-    x = torch.randn(2, 3, 16, 32)
-    x_out, H, W = x_overlap_patch_embed(x)
-    assert x_out.shape == torch.Size([2, 32, 768])
-
-
-def test_mscan_spatial_attention_module():
-    x_spatial_attention = MSCASpatialAttention(8)
-    assert x_spatial_attention.proj_1.kernel_size == (1, 1)
-    assert x_spatial_attention.proj_2.stride == (1, 1)
-    x = torch.randn(2, 8, 16, 32)
-    x_out = x_spatial_attention(x)
-    assert x_out.shape == torch.Size([2, 8, 16, 32])
-
-
-def test_mscan_attention_module():
-    x_attention = MSCAAttention(8)
-    assert x_attention.conv0.weight.shape[0] == 8
-    assert x_attention.conv3.kernel_size == (1, 1)
-    x = torch.randn(2, 8, 16, 32)
-    x_out = x_attention(x)
-    assert x_out.shape == torch.Size([2, 8, 16, 32])
-
-
-def test_mscan_stem_module():
-    x_stem = StemConv(8, 8, norm_cfg=dict(type='BN', requires_grad=True))
-    assert x_stem.proj[0].weight.shape[0] == 4
-    assert x_stem.proj[-1].weight.shape[0] == 8
-    x = torch.randn(2, 8, 16, 32)
-    x_out, H, W = x_stem(x)
-    assert x_out.shape == torch.Size([2, 32, 8])
-    assert (H, W) == (4, 8)
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_pidnet.py b/mmsegmentation/tests/test_models/test_backbones/test_pidnet.py
deleted file mode 100644
index 208dfc7..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_pidnet.py
+++ /dev/null
@@ -1,87 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import os
-import tempfile
-
-import torch
-from mmengine.registry import init_default_scope
-
-from mmseg.registry import MODELS
-
-init_default_scope('mmseg')
-
-
-def test_pidnet_backbone():
-    # Test PIDNet Standard Forward
-    norm_cfg = dict(type='BN', requires_grad=True)
-    backbone_cfg = dict(
-        type='PIDNet',
-        in_channels=3,
-        channels=32,
-        ppm_channels=96,
-        num_stem_blocks=2,
-        num_branch_blocks=3,
-        align_corners=False,
-        norm_cfg=norm_cfg,
-        act_cfg=dict(type='ReLU', inplace=True))
-    model = MODELS.build(backbone_cfg)
-    model.init_weights()
-
-    # Test init weights
-    temp_file = tempfile.NamedTemporaryFile()
-    temp_file.close()
-    torch.save(model.state_dict(), temp_file.name)
-    backbone_cfg.update(
-        init_cfg=dict(type='Pretrained', checkpoint=temp_file.name))
-    model = MODELS.build(backbone_cfg)
-    model.init_weights()
-    os.remove(temp_file.name)
-
-    # Test eval mode
-    model.eval()
-    batch_size = 1
-    imgs = torch.randn(batch_size, 3, 64, 128)
-    feats = model(imgs)
-
-    assert type(feats) == torch.Tensor
-    assert feats.shape == torch.Size([batch_size, 128, 8, 16])
-
-    # Test train mode
-    model.train()
-    batch_size = 2
-    imgs = torch.randn(batch_size, 3, 64, 128)
-    feats = model(imgs)
-
-    assert len(feats) == 3
-    # test output for P branch
-    assert feats[0].shape == torch.Size([batch_size, 64, 8, 16])
-    # test output for I branch
-    assert feats[1].shape == torch.Size([batch_size, 128, 8, 16])
-    # test output for D branch
-    assert feats[2].shape == torch.Size([batch_size, 64, 8, 16])
-
-    # Test pidnet-m
-    backbone_cfg.update(channels=64)
-    model = MODELS.build(backbone_cfg)
-    feats = model(imgs)
-
-    assert len(feats) == 3
-    # test output for P branch
-    assert feats[0].shape == torch.Size([batch_size, 128, 8, 16])
-    # test output for I branch
-    assert feats[1].shape == torch.Size([batch_size, 256, 8, 16])
-    # test output for D branch
-    assert feats[2].shape == torch.Size([batch_size, 128, 8, 16])
-
-    # Test pidnet-l
-    backbone_cfg.update(
-        channels=64, ppm_channesl=112, num_stem_blocks=3, num_branch_blocks=4)
-    model = MODELS.build(backbone_cfg)
-    feats = model(imgs)
-
-    assert len(feats) == 3
-    # test output for P branch
-    assert feats[0].shape == torch.Size([batch_size, 128, 8, 16])
-    # test output for I branch
-    assert feats[1].shape == torch.Size([batch_size, 256, 8, 16])
-    # test output for D branch
-    assert feats[2].shape == torch.Size([batch_size, 128, 8, 16])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_resnest.py b/mmsegmentation/tests/test_models/test_backbones/test_resnest.py
deleted file mode 100644
index 3013f34..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_resnest.py
+++ /dev/null
@@ -1,44 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.backbones import ResNeSt
-from mmseg.models.backbones.resnest import Bottleneck as BottleneckS
-
-
-def test_resnest_bottleneck():
-    with pytest.raises(AssertionError):
-        # Style must be in ['pytorch', 'caffe']
-        BottleneckS(64, 64, radix=2, reduction_factor=4, style='tensorflow')
-
-    # Test ResNeSt Bottleneck structure
-    block = BottleneckS(
-        64, 256, radix=2, reduction_factor=4, stride=2, style='pytorch')
-    assert block.avd_layer.stride == 2
-    assert block.conv2.channels == 256
-
-    # Test ResNeSt Bottleneck forward
-    block = BottleneckS(64, 16, radix=2, reduction_factor=4)
-    x = torch.randn(2, 64, 56, 56)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([2, 64, 56, 56])
-
-
-def test_resnest_backbone():
-    with pytest.raises(KeyError):
-        # ResNeSt depth should be in [50, 101, 152, 200]
-        ResNeSt(depth=18)
-
-    # Test ResNeSt with radix 2, reduction_factor 4
-    model = ResNeSt(
-        depth=50, radix=2, reduction_factor=4, out_indices=(0, 1, 2, 3))
-    model.init_weights()
-    model.train()
-
-    imgs = torch.randn(2, 3, 224, 224)
-    feat = model(imgs)
-    assert len(feat) == 4
-    assert feat[0].shape == torch.Size([2, 256, 56, 56])
-    assert feat[1].shape == torch.Size([2, 512, 28, 28])
-    assert feat[2].shape == torch.Size([2, 1024, 14, 14])
-    assert feat[3].shape == torch.Size([2, 2048, 7, 7])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_resnet.py b/mmsegmentation/tests/test_models/test_backbones/test_resnet.py
deleted file mode 100644
index f2f24ba..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_resnet.py
+++ /dev/null
@@ -1,575 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-from mmcv.ops import DeformConv2dPack
-from mmengine.utils.dl_utils.parrots_wrapper import _BatchNorm
-from torch.nn.modules import AvgPool2d, GroupNorm
-
-from mmseg.models.backbones import ResNet, ResNetV1d
-from mmseg.models.backbones.resnet import BasicBlock, Bottleneck
-from mmseg.models.utils import ResLayer
-from .utils import all_zeros, check_norm_state, is_block, is_norm
-
-
-def test_resnet_basic_block():
-    with pytest.raises(AssertionError):
-        # Not implemented yet.
-        dcn = dict(type='DCN', deform_groups=1, fallback_on_stride=False)
-        BasicBlock(64, 64, dcn=dcn)
-
-    with pytest.raises(AssertionError):
-        # Not implemented yet.
-        plugins = [
-            dict(
-                cfg=dict(type='ContextBlock', ratio=1. / 16),
-                position='after_conv3')
-        ]
-        BasicBlock(64, 64, plugins=plugins)
-
-    with pytest.raises(AssertionError):
-        # Not implemented yet
-        plugins = [
-            dict(
-                cfg=dict(
-                    type='GeneralizedAttention',
-                    spatial_range=-1,
-                    num_heads=8,
-                    attention_type='0010',
-                    kv_stride=2),
-                position='after_conv2')
-        ]
-        BasicBlock(64, 64, plugins=plugins)
-
-    # Test BasicBlock with checkpoint forward
-    block = BasicBlock(16, 16, with_cp=True)
-    assert block.with_cp
-    x = torch.randn(1, 16, 28, 28)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([1, 16, 28, 28])
-
-    # test BasicBlock structure and forward
-    block = BasicBlock(32, 32)
-    assert block.conv1.in_channels == 32
-    assert block.conv1.out_channels == 32
-    assert block.conv1.kernel_size == (3, 3)
-    assert block.conv2.in_channels == 32
-    assert block.conv2.out_channels == 32
-    assert block.conv2.kernel_size == (3, 3)
-    x = torch.randn(1, 32, 28, 28)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([1, 32, 28, 28])
-
-
-def test_resnet_bottleneck():
-    with pytest.raises(AssertionError):
-        # Style must be in ['pytorch', 'caffe']
-        Bottleneck(64, 64, style='tensorflow')
-
-    with pytest.raises(AssertionError):
-        # Allowed positions are 'after_conv1', 'after_conv2', 'after_conv3'
-        plugins = [
-            dict(
-                cfg=dict(type='ContextBlock', ratio=1. / 16),
-                position='after_conv4')
-        ]
-        Bottleneck(64, 16, plugins=plugins)
-
-    with pytest.raises(AssertionError):
-        # Need to specify different postfix to avoid duplicate plugin name
-        plugins = [
-            dict(
-                cfg=dict(type='ContextBlock', ratio=1. / 16),
-                position='after_conv3'),
-            dict(
-                cfg=dict(type='ContextBlock', ratio=1. / 16),
-                position='after_conv3')
-        ]
-        Bottleneck(64, 16, plugins=plugins)
-
-    with pytest.raises(KeyError):
-        # Plugin type is not supported
-        plugins = [dict(cfg=dict(type='WrongPlugin'), position='after_conv3')]
-        Bottleneck(64, 16, plugins=plugins)
-
-    # Test Bottleneck with checkpoint forward
-    block = Bottleneck(64, 16, with_cp=True)
-    assert block.with_cp
-    x = torch.randn(1, 64, 56, 56)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([1, 64, 56, 56])
-
-    # Test Bottleneck style
-    block = Bottleneck(64, 64, stride=2, style='pytorch')
-    assert block.conv1.stride == (1, 1)
-    assert block.conv2.stride == (2, 2)
-    block = Bottleneck(64, 64, stride=2, style='caffe')
-    assert block.conv1.stride == (2, 2)
-    assert block.conv2.stride == (1, 1)
-
-    # Test Bottleneck DCN
-    dcn = dict(type='DCN', deform_groups=1, fallback_on_stride=False)
-    with pytest.raises(AssertionError):
-        Bottleneck(64, 64, dcn=dcn, conv_cfg=dict(type='Conv'))
-    block = Bottleneck(64, 64, dcn=dcn)
-    assert isinstance(block.conv2, DeformConv2dPack)
-
-    # Test Bottleneck forward
-    block = Bottleneck(64, 16)
-    x = torch.randn(1, 64, 56, 56)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([1, 64, 56, 56])
-
-    # Test Bottleneck with 1 ContextBlock after conv3
-    plugins = [
-        dict(
-            cfg=dict(type='ContextBlock', ratio=1. / 16),
-            position='after_conv3')
-    ]
-    block = Bottleneck(64, 16, plugins=plugins)
-    assert block.context_block.in_channels == 64
-    x = torch.randn(1, 64, 56, 56)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([1, 64, 56, 56])
-
-    # Test Bottleneck with 1 GeneralizedAttention after conv2
-    plugins = [
-        dict(
-            cfg=dict(
-                type='GeneralizedAttention',
-                spatial_range=-1,
-                num_heads=8,
-                attention_type='0010',
-                kv_stride=2),
-            position='after_conv2')
-    ]
-    block = Bottleneck(64, 16, plugins=plugins)
-    assert block.gen_attention_block.in_channels == 16
-    x = torch.randn(1, 64, 56, 56)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([1, 64, 56, 56])
-
-    # Test Bottleneck with 1 GeneralizedAttention after conv2, 1 NonLocal2d
-    # after conv2, 1 ContextBlock after conv3
-    plugins = [
-        dict(
-            cfg=dict(
-                type='GeneralizedAttention',
-                spatial_range=-1,
-                num_heads=8,
-                attention_type='0010',
-                kv_stride=2),
-            position='after_conv2'),
-        dict(cfg=dict(type='NonLocal2d'), position='after_conv2'),
-        dict(
-            cfg=dict(type='ContextBlock', ratio=1. / 16),
-            position='after_conv3')
-    ]
-    block = Bottleneck(64, 16, plugins=plugins)
-    assert block.gen_attention_block.in_channels == 16
-    assert block.nonlocal_block.in_channels == 16
-    assert block.context_block.in_channels == 64
-    x = torch.randn(1, 64, 56, 56)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([1, 64, 56, 56])
-
-    # Test Bottleneck with 1 ContextBlock after conv2, 2 ContextBlock after
-    # conv3
-    plugins = [
-        dict(
-            cfg=dict(type='ContextBlock', ratio=1. / 16, postfix=1),
-            position='after_conv2'),
-        dict(
-            cfg=dict(type='ContextBlock', ratio=1. / 16, postfix=2),
-            position='after_conv3'),
-        dict(
-            cfg=dict(type='ContextBlock', ratio=1. / 16, postfix=3),
-            position='after_conv3')
-    ]
-    block = Bottleneck(64, 16, plugins=plugins)
-    assert block.context_block1.in_channels == 16
-    assert block.context_block2.in_channels == 64
-    assert block.context_block3.in_channels == 64
-    x = torch.randn(1, 64, 56, 56)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([1, 64, 56, 56])
-
-
-def test_resnet_res_layer():
-    # Test ResLayer of 3 Bottleneck w\o downsample
-    layer = ResLayer(Bottleneck, 64, 16, 3)
-    assert len(layer) == 3
-    assert layer[0].conv1.in_channels == 64
-    assert layer[0].conv1.out_channels == 16
-    for i in range(1, len(layer)):
-        assert layer[i].conv1.in_channels == 64
-        assert layer[i].conv1.out_channels == 16
-    for i in range(len(layer)):
-        assert layer[i].downsample is None
-    x = torch.randn(1, 64, 56, 56)
-    x_out = layer(x)
-    assert x_out.shape == torch.Size([1, 64, 56, 56])
-
-    # Test ResLayer of 3 Bottleneck with downsample
-    layer = ResLayer(Bottleneck, 64, 64, 3)
-    assert layer[0].downsample[0].out_channels == 256
-    for i in range(1, len(layer)):
-        assert layer[i].downsample is None
-    x = torch.randn(1, 64, 56, 56)
-    x_out = layer(x)
-    assert x_out.shape == torch.Size([1, 256, 56, 56])
-
-    # Test ResLayer of 3 Bottleneck with stride=2
-    layer = ResLayer(Bottleneck, 64, 64, 3, stride=2)
-    assert layer[0].downsample[0].out_channels == 256
-    assert layer[0].downsample[0].stride == (2, 2)
-    for i in range(1, len(layer)):
-        assert layer[i].downsample is None
-    x = torch.randn(1, 64, 56, 56)
-    x_out = layer(x)
-    assert x_out.shape == torch.Size([1, 256, 28, 28])
-
-    # Test ResLayer of 3 Bottleneck with stride=2 and average downsample
-    layer = ResLayer(Bottleneck, 64, 64, 3, stride=2, avg_down=True)
-    assert isinstance(layer[0].downsample[0], AvgPool2d)
-    assert layer[0].downsample[1].out_channels == 256
-    assert layer[0].downsample[1].stride == (1, 1)
-    for i in range(1, len(layer)):
-        assert layer[i].downsample is None
-    x = torch.randn(1, 64, 56, 56)
-    x_out = layer(x)
-    assert x_out.shape == torch.Size([1, 256, 28, 28])
-
-    # Test ResLayer of 3 Bottleneck with dilation=2
-    layer = ResLayer(Bottleneck, 64, 16, 3, dilation=2)
-    for i in range(len(layer)):
-        assert layer[i].conv2.dilation == (2, 2)
-    x = torch.randn(1, 64, 56, 56)
-    x_out = layer(x)
-    assert x_out.shape == torch.Size([1, 64, 56, 56])
-
-    # Test ResLayer of 3 Bottleneck with dilation=2, contract_dilation=True
-    layer = ResLayer(Bottleneck, 64, 16, 3, dilation=2, contract_dilation=True)
-    assert layer[0].conv2.dilation == (1, 1)
-    for i in range(1, len(layer)):
-        assert layer[i].conv2.dilation == (2, 2)
-    x = torch.randn(1, 64, 56, 56)
-    x_out = layer(x)
-    assert x_out.shape == torch.Size([1, 64, 56, 56])
-
-    # Test ResLayer of 3 Bottleneck with dilation=2, multi_grid
-    layer = ResLayer(Bottleneck, 64, 16, 3, dilation=2, multi_grid=(1, 2, 4))
-    assert layer[0].conv2.dilation == (1, 1)
-    assert layer[1].conv2.dilation == (2, 2)
-    assert layer[2].conv2.dilation == (4, 4)
-    x = torch.randn(1, 64, 56, 56)
-    x_out = layer(x)
-    assert x_out.shape == torch.Size([1, 64, 56, 56])
-
-
-def test_resnet_backbone():
-    """Test resnet backbone."""
-    with pytest.raises(KeyError):
-        # ResNet depth should be in [18, 34, 50, 101, 152]
-        ResNet(20)
-
-    with pytest.raises(AssertionError):
-        # In ResNet: 1 <= num_stages <= 4
-        ResNet(50, num_stages=0)
-
-    with pytest.raises(AssertionError):
-        # len(stage_with_dcn) == num_stages
-        dcn = dict(type='DCN', deform_groups=1, fallback_on_stride=False)
-        ResNet(50, dcn=dcn, stage_with_dcn=(True, ))
-
-    with pytest.raises(AssertionError):
-        # len(stage_with_plugin) == num_stages
-        plugins = [
-            dict(
-                cfg=dict(type='ContextBlock', ratio=1. / 16),
-                stages=(False, True, True),
-                position='after_conv3')
-        ]
-        ResNet(50, plugins=plugins)
-
-    with pytest.raises(AssertionError):
-        # In ResNet: 1 <= num_stages <= 4
-        ResNet(18, num_stages=5)
-
-    with pytest.raises(AssertionError):
-        # len(strides) == len(dilations) == num_stages
-        ResNet(18, strides=(1, ), dilations=(1, 1), num_stages=3)
-
-    with pytest.raises(TypeError):
-        # pretrained must be a string path
-        model = ResNet(18, pretrained=0)
-        model.init_weights()
-
-    with pytest.raises(AssertionError):
-        # Style must be in ['pytorch', 'caffe']
-        ResNet(50, style='tensorflow')
-
-    # Test ResNet18 norm_eval=True
-    model = ResNet(18, norm_eval=True)
-    model.init_weights()
-    model.train()
-    assert check_norm_state(model.modules(), False)
-
-    # Test ResNet18 with torchvision pretrained weight
-    model = ResNet(
-        depth=18, norm_eval=True, pretrained='torchvision://resnet18')
-    model.init_weights()
-    model.train()
-    assert check_norm_state(model.modules(), False)
-
-    # Test ResNet18 with first stage frozen
-    frozen_stages = 1
-    model = ResNet(18, frozen_stages=frozen_stages)
-    model.init_weights()
-    model.train()
-    assert model.norm1.training is False
-    for layer in [model.conv1, model.norm1]:
-        for param in layer.parameters():
-            assert param.requires_grad is False
-    for i in range(1, frozen_stages + 1):
-        layer = getattr(model, f'layer{i}')
-        for mod in layer.modules():
-            if isinstance(mod, _BatchNorm):
-                assert mod.training is False
-        for param in layer.parameters():
-            assert param.requires_grad is False
-
-    # Test ResNet18V1d with first stage frozen
-    model = ResNetV1d(depth=18, frozen_stages=frozen_stages)
-    assert len(model.stem) == 9
-    model.init_weights()
-    model.train()
-    check_norm_state(model.stem, False)
-    for param in model.stem.parameters():
-        assert param.requires_grad is False
-    for i in range(1, frozen_stages + 1):
-        layer = getattr(model, f'layer{i}')
-        for mod in layer.modules():
-            if isinstance(mod, _BatchNorm):
-                assert mod.training is False
-        for param in layer.parameters():
-            assert param.requires_grad is False
-
-    # Test ResNet18 forward
-    model = ResNet(18)
-    model.init_weights()
-    model.train()
-
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert len(feat) == 4
-    assert feat[0].shape == torch.Size([1, 64, 56, 56])
-    assert feat[1].shape == torch.Size([1, 128, 28, 28])
-    assert feat[2].shape == torch.Size([1, 256, 14, 14])
-    assert feat[3].shape == torch.Size([1, 512, 7, 7])
-
-    # Test ResNet18 with BatchNorm forward
-    model = ResNet(18)
-    for m in model.modules():
-        if is_norm(m):
-            assert isinstance(m, _BatchNorm)
-    model.init_weights()
-    model.train()
-
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert len(feat) == 4
-    assert feat[0].shape == torch.Size([1, 64, 56, 56])
-    assert feat[1].shape == torch.Size([1, 128, 28, 28])
-    assert feat[2].shape == torch.Size([1, 256, 14, 14])
-    assert feat[3].shape == torch.Size([1, 512, 7, 7])
-
-    # Test ResNet18 with layers 1, 2, 3 out forward
-    model = ResNet(18, out_indices=(0, 1, 2))
-    model.init_weights()
-    model.train()
-
-    imgs = torch.randn(1, 3, 112, 112)
-    feat = model(imgs)
-    assert len(feat) == 3
-    assert feat[0].shape == torch.Size([1, 64, 28, 28])
-    assert feat[1].shape == torch.Size([1, 128, 14, 14])
-    assert feat[2].shape == torch.Size([1, 256, 7, 7])
-
-    # Test ResNet18 with checkpoint forward
-    model = ResNet(18, with_cp=True)
-    for m in model.modules():
-        if is_block(m):
-            assert m.with_cp
-    model.init_weights()
-    model.train()
-
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert len(feat) == 4
-    assert feat[0].shape == torch.Size([1, 64, 56, 56])
-    assert feat[1].shape == torch.Size([1, 128, 28, 28])
-    assert feat[2].shape == torch.Size([1, 256, 14, 14])
-    assert feat[3].shape == torch.Size([1, 512, 7, 7])
-
-    # Test ResNet18 with checkpoint forward
-    model = ResNet(18, with_cp=True)
-    for m in model.modules():
-        if is_block(m):
-            assert m.with_cp
-    model.init_weights()
-    model.train()
-
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert len(feat) == 4
-    assert feat[0].shape == torch.Size([1, 64, 56, 56])
-    assert feat[1].shape == torch.Size([1, 128, 28, 28])
-    assert feat[2].shape == torch.Size([1, 256, 14, 14])
-    assert feat[3].shape == torch.Size([1, 512, 7, 7])
-
-    # Test ResNet18 with GroupNorm forward
-    model = ResNet(
-        18, norm_cfg=dict(type='GN', num_groups=32, requires_grad=True))
-    for m in model.modules():
-        if is_norm(m):
-            assert isinstance(m, GroupNorm)
-    model.init_weights()
-    model.train()
-
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert len(feat) == 4
-    assert feat[0].shape == torch.Size([1, 64, 56, 56])
-    assert feat[1].shape == torch.Size([1, 128, 28, 28])
-    assert feat[2].shape == torch.Size([1, 256, 14, 14])
-    assert feat[3].shape == torch.Size([1, 512, 7, 7])
-
-    # Test ResNet50 with 1 GeneralizedAttention after conv2, 1 NonLocal2d
-    # after conv2, 1 ContextBlock after conv3 in layers 2, 3, 4
-    plugins = [
-        dict(
-            cfg=dict(
-                type='GeneralizedAttention',
-                spatial_range=-1,
-                num_heads=8,
-                attention_type='0010',
-                kv_stride=2),
-            stages=(False, True, True, True),
-            position='after_conv2'),
-        dict(cfg=dict(type='NonLocal2d'), position='after_conv2'),
-        dict(
-            cfg=dict(type='ContextBlock', ratio=1. / 16),
-            stages=(False, True, True, False),
-            position='after_conv3')
-    ]
-    model = ResNet(50, plugins=plugins)
-    for m in model.layer1.modules():
-        if is_block(m):
-            assert not hasattr(m, 'context_block')
-            assert not hasattr(m, 'gen_attention_block')
-            assert m.nonlocal_block.in_channels == 64
-    for m in model.layer2.modules():
-        if is_block(m):
-            assert m.nonlocal_block.in_channels == 128
-            assert m.gen_attention_block.in_channels == 128
-            assert m.context_block.in_channels == 512
-
-    for m in model.layer3.modules():
-        if is_block(m):
-            assert m.nonlocal_block.in_channels == 256
-            assert m.gen_attention_block.in_channels == 256
-            assert m.context_block.in_channels == 1024
-
-    for m in model.layer4.modules():
-        if is_block(m):
-            assert m.nonlocal_block.in_channels == 512
-            assert m.gen_attention_block.in_channels == 512
-            assert not hasattr(m, 'context_block')
-    model.init_weights()
-    model.train()
-
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert len(feat) == 4
-    assert feat[0].shape == torch.Size([1, 256, 56, 56])
-    assert feat[1].shape == torch.Size([1, 512, 28, 28])
-    assert feat[2].shape == torch.Size([1, 1024, 14, 14])
-    assert feat[3].shape == torch.Size([1, 2048, 7, 7])
-
-    # Test ResNet50 with 1 ContextBlock after conv2, 1 ContextBlock after
-    # conv3 in layers 2, 3, 4
-    plugins = [
-        dict(
-            cfg=dict(type='ContextBlock', ratio=1. / 16, postfix=1),
-            stages=(False, True, True, False),
-            position='after_conv3'),
-        dict(
-            cfg=dict(type='ContextBlock', ratio=1. / 16, postfix=2),
-            stages=(False, True, True, False),
-            position='after_conv3')
-    ]
-
-    model = ResNet(50, plugins=plugins)
-    for m in model.layer1.modules():
-        if is_block(m):
-            assert not hasattr(m, 'context_block')
-            assert not hasattr(m, 'context_block1')
-            assert not hasattr(m, 'context_block2')
-    for m in model.layer2.modules():
-        if is_block(m):
-            assert not hasattr(m, 'context_block')
-            assert m.context_block1.in_channels == 512
-            assert m.context_block2.in_channels == 512
-
-    for m in model.layer3.modules():
-        if is_block(m):
-            assert not hasattr(m, 'context_block')
-            assert m.context_block1.in_channels == 1024
-            assert m.context_block2.in_channels == 1024
-
-    for m in model.layer4.modules():
-        if is_block(m):
-            assert not hasattr(m, 'context_block')
-            assert not hasattr(m, 'context_block1')
-            assert not hasattr(m, 'context_block2')
-    model.init_weights()
-    model.train()
-
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert len(feat) == 4
-    assert feat[0].shape == torch.Size([1, 256, 56, 56])
-    assert feat[1].shape == torch.Size([1, 512, 28, 28])
-    assert feat[2].shape == torch.Size([1, 1024, 14, 14])
-    assert feat[3].shape == torch.Size([1, 2048, 7, 7])
-
-    # Test ResNet18 zero initialization of residual
-    model = ResNet(18, zero_init_residual=True)
-    model.init_weights()
-    for m in model.modules():
-        if isinstance(m, Bottleneck):
-            assert all_zeros(m.norm3)
-        elif isinstance(m, BasicBlock):
-            assert all_zeros(m.norm2)
-    model.train()
-
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert len(feat) == 4
-    assert feat[0].shape == torch.Size([1, 64, 56, 56])
-    assert feat[1].shape == torch.Size([1, 128, 28, 28])
-    assert feat[2].shape == torch.Size([1, 256, 14, 14])
-    assert feat[3].shape == torch.Size([1, 512, 7, 7])
-
-    # Test ResNetV1d forward
-    model = ResNetV1d(depth=18)
-    model.init_weights()
-    model.train()
-
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert len(feat) == 4
-    assert feat[0].shape == torch.Size([1, 64, 56, 56])
-    assert feat[1].shape == torch.Size([1, 128, 28, 28])
-    assert feat[2].shape == torch.Size([1, 256, 14, 14])
-    assert feat[3].shape == torch.Size([1, 512, 7, 7])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_resnext.py b/mmsegmentation/tests/test_models/test_backbones/test_resnext.py
deleted file mode 100644
index 2aecaf0..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_resnext.py
+++ /dev/null
@@ -1,62 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.backbones import ResNeXt
-from mmseg.models.backbones.resnext import Bottleneck as BottleneckX
-from .utils import is_block
-
-
-def test_renext_bottleneck():
-    with pytest.raises(AssertionError):
-        # Style must be in ['pytorch', 'caffe']
-        BottleneckX(64, 64, groups=32, base_width=4, style='tensorflow')
-
-    # Test ResNeXt Bottleneck structure
-    block = BottleneckX(
-        64, 64, groups=32, base_width=4, stride=2, style='pytorch')
-    assert block.conv2.stride == (2, 2)
-    assert block.conv2.groups == 32
-    assert block.conv2.out_channels == 128
-
-    # Test ResNeXt Bottleneck with DCN
-    dcn = dict(type='DCN', deform_groups=1, fallback_on_stride=False)
-    with pytest.raises(AssertionError):
-        # conv_cfg must be None if dcn is not None
-        BottleneckX(
-            64,
-            64,
-            groups=32,
-            base_width=4,
-            dcn=dcn,
-            conv_cfg=dict(type='Conv'))
-    BottleneckX(64, 64, dcn=dcn)
-
-    # Test ResNeXt Bottleneck forward
-    block = BottleneckX(64, 16, groups=32, base_width=4)
-    x = torch.randn(1, 64, 56, 56)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([1, 64, 56, 56])
-
-
-def test_resnext_backbone():
-    with pytest.raises(KeyError):
-        # ResNeXt depth should be in [50, 101, 152]
-        ResNeXt(depth=18)
-
-    # Test ResNeXt with group 32, base_width 4
-    model = ResNeXt(depth=50, groups=32, base_width=4)
-    print(model)
-    for m in model.modules():
-        if is_block(m):
-            assert m.conv2.groups == 32
-    model.init_weights()
-    model.train()
-
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert len(feat) == 4
-    assert feat[0].shape == torch.Size([1, 256, 56, 56])
-    assert feat[1].shape == torch.Size([1, 512, 28, 28])
-    assert feat[2].shape == torch.Size([1, 1024, 14, 14])
-    assert feat[3].shape == torch.Size([1, 2048, 7, 7])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_stdc.py b/mmsegmentation/tests/test_models/test_backbones/test_stdc.py
deleted file mode 100644
index 1e3862b..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_stdc.py
+++ /dev/null
@@ -1,131 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.backbones import STDCContextPathNet
-from mmseg.models.backbones.stdc import (AttentionRefinementModule,
-                                         FeatureFusionModule, STDCModule,
-                                         STDCNet)
-
-
-def test_stdc_context_path_net():
-    # Test STDCContextPathNet Standard Forward
-    model = STDCContextPathNet(
-        backbone_cfg=dict(
-            type='STDCNet',
-            stdc_type='STDCNet1',
-            in_channels=3,
-            channels=(32, 64, 256, 512, 1024),
-            bottleneck_type='cat',
-            num_convs=4,
-            norm_cfg=dict(type='BN', requires_grad=True),
-            act_cfg=dict(type='ReLU'),
-            with_final_conv=True),
-        last_in_channels=(1024, 512),
-        out_channels=128,
-        ffm_cfg=dict(in_channels=384, out_channels=256, scale_factor=4))
-    model.init_weights()
-    model.train()
-    batch_size = 2
-    imgs = torch.randn(batch_size, 3, 256, 512)
-    feat = model(imgs)
-
-    assert len(feat) == 4
-    # output for segment Head
-    assert feat[0].shape == torch.Size([batch_size, 256, 32, 64])
-    # for auxiliary head 1
-    assert feat[1].shape == torch.Size([batch_size, 128, 16, 32])
-    # for auxiliary head 2
-    assert feat[2].shape == torch.Size([batch_size, 128, 32, 64])
-    # for auxiliary head 3
-    assert feat[3].shape == torch.Size([batch_size, 256, 32, 64])
-
-    # Test input with rare shape
-    batch_size = 2
-    imgs = torch.randn(batch_size, 3, 527, 279)
-    model = STDCContextPathNet(
-        backbone_cfg=dict(
-            type='STDCNet',
-            stdc_type='STDCNet1',
-            in_channels=3,
-            channels=(32, 64, 256, 512, 1024),
-            bottleneck_type='add',
-            num_convs=4,
-            norm_cfg=dict(type='BN', requires_grad=True),
-            act_cfg=dict(type='ReLU'),
-            with_final_conv=False),
-        last_in_channels=(1024, 512),
-        out_channels=128,
-        ffm_cfg=dict(in_channels=384, out_channels=256, scale_factor=4))
-    model.init_weights()
-    model.train()
-    feat = model(imgs)
-    assert len(feat) == 4
-
-
-def test_stdcnet():
-    with pytest.raises(AssertionError):
-        # STDC backbone constraints.
-        STDCNet(
-            stdc_type='STDCNet3',
-            in_channels=3,
-            channels=(32, 64, 256, 512, 1024),
-            bottleneck_type='cat',
-            num_convs=4,
-            norm_cfg=dict(type='BN', requires_grad=True),
-            act_cfg=dict(type='ReLU'),
-            with_final_conv=False)
-
-    with pytest.raises(AssertionError):
-        # STDC bottleneck type constraints.
-        STDCNet(
-            stdc_type='STDCNet1',
-            in_channels=3,
-            channels=(32, 64, 256, 512, 1024),
-            bottleneck_type='dog',
-            num_convs=4,
-            norm_cfg=dict(type='BN', requires_grad=True),
-            act_cfg=dict(type='ReLU'),
-            with_final_conv=False)
-
-    with pytest.raises(AssertionError):
-        # STDC channels length constraints.
-        STDCNet(
-            stdc_type='STDCNet1',
-            in_channels=3,
-            channels=(16, 32, 64, 256, 512, 1024),
-            bottleneck_type='cat',
-            num_convs=4,
-            norm_cfg=dict(type='BN', requires_grad=True),
-            act_cfg=dict(type='ReLU'),
-            with_final_conv=False)
-
-
-def test_feature_fusion_module():
-    x_ffm = FeatureFusionModule(in_channels=64, out_channels=32)
-    assert x_ffm.conv0.in_channels == 64
-    assert x_ffm.attention[1].in_channels == 32
-    assert x_ffm.attention[2].in_channels == 8
-    assert x_ffm.attention[2].out_channels == 32
-    x1 = torch.randn(2, 32, 32, 64)
-    x2 = torch.randn(2, 32, 32, 64)
-    x_out = x_ffm(x1, x2)
-    assert x_out.shape == torch.Size([2, 32, 32, 64])
-
-
-def test_attention_refinement_module():
-    x_arm = AttentionRefinementModule(128, 32)
-    assert x_arm.conv_layer.in_channels == 128
-    assert x_arm.atten_conv_layer[1].conv.out_channels == 32
-    x = torch.randn(2, 128, 32, 64)
-    x_out = x_arm(x)
-    assert x_out.shape == torch.Size([2, 32, 32, 64])
-
-
-def test_stdc_module():
-    x_stdc = STDCModule(in_channels=32, out_channels=32, stride=4)
-    assert x_stdc.layers[0].conv.in_channels == 32
-    assert x_stdc.layers[3].conv.out_channels == 4
-    x = torch.randn(2, 32, 32, 64)
-    x_out = x_stdc(x)
-    assert x_out.shape == torch.Size([2, 32, 32, 64])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_swin.py b/mmsegmentation/tests/test_models/test_backbones/test_swin.py
deleted file mode 100644
index 8d14d47..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_swin.py
+++ /dev/null
@@ -1,100 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.backbones.swin import SwinBlock, SwinTransformer
-
-
-def test_swin_block():
-    # test SwinBlock structure and forward
-    block = SwinBlock(embed_dims=32, num_heads=4, feedforward_channels=128)
-    assert block.ffn.embed_dims == 32
-    assert block.attn.w_msa.num_heads == 4
-    assert block.ffn.feedforward_channels == 128
-    x = torch.randn(1, 56 * 56, 32)
-    x_out = block(x, (56, 56))
-    assert x_out.shape == torch.Size([1, 56 * 56, 32])
-
-    # Test BasicBlock with checkpoint forward
-    block = SwinBlock(
-        embed_dims=64, num_heads=4, feedforward_channels=256, with_cp=True)
-    assert block.with_cp
-    x = torch.randn(1, 56 * 56, 64)
-    x_out = block(x, (56, 56))
-    assert x_out.shape == torch.Size([1, 56 * 56, 64])
-
-
-def test_swin_transformer():
-    """Test Swin Transformer backbone."""
-
-    with pytest.raises(TypeError):
-        # Pretrained arg must be str or None.
-        SwinTransformer(pretrained=123)
-
-    with pytest.raises(AssertionError):
-        # Because swin uses non-overlapping patch embed, so the stride of patch
-        # embed must be equal to patch size.
-        SwinTransformer(strides=(2, 2, 2, 2), patch_size=4)
-
-    # test pretrained image size
-    with pytest.raises(AssertionError):
-        SwinTransformer(pretrain_img_size=(112, 112, 112))
-
-    # Test absolute position embedding
-    temp = torch.randn((1, 3, 112, 112))
-    model = SwinTransformer(pretrain_img_size=112, use_abs_pos_embed=True)
-    model.init_weights()
-    model(temp)
-
-    # Test patch norm
-    model = SwinTransformer(patch_norm=False)
-    model(temp)
-
-    # Test normal inference
-    temp = torch.randn((1, 3, 256, 256))
-    model = SwinTransformer()
-    outs = model(temp)
-    assert outs[0].shape == (1, 96, 64, 64)
-    assert outs[1].shape == (1, 192, 32, 32)
-    assert outs[2].shape == (1, 384, 16, 16)
-    assert outs[3].shape == (1, 768, 8, 8)
-
-    # Test abnormal inference size
-    temp = torch.randn((1, 3, 255, 255))
-    model = SwinTransformer()
-    outs = model(temp)
-    assert outs[0].shape == (1, 96, 64, 64)
-    assert outs[1].shape == (1, 192, 32, 32)
-    assert outs[2].shape == (1, 384, 16, 16)
-    assert outs[3].shape == (1, 768, 8, 8)
-
-    # Test abnormal inference size
-    temp = torch.randn((1, 3, 112, 137))
-    model = SwinTransformer()
-    outs = model(temp)
-    assert outs[0].shape == (1, 96, 28, 35)
-    assert outs[1].shape == (1, 192, 14, 18)
-    assert outs[2].shape == (1, 384, 7, 9)
-    assert outs[3].shape == (1, 768, 4, 5)
-
-    # Test frozen
-    model = SwinTransformer(frozen_stages=4)
-    model.train()
-    for p in model.parameters():
-        assert not p.requires_grad
-
-    # Test absolute position embedding frozen
-    model = SwinTransformer(frozen_stages=4, use_abs_pos_embed=True)
-    model.train()
-    for p in model.parameters():
-        assert not p.requires_grad
-
-    # Test Swin with checkpoint forward
-    temp = torch.randn((1, 3, 56, 56))
-    model = SwinTransformer(with_cp=True)
-    for m in model.modules():
-        if isinstance(m, SwinBlock):
-            assert m.with_cp
-    model.init_weights()
-    model.train()
-    model(temp)
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_timm_backbone.py b/mmsegmentation/tests/test_models/test_backbones/test_timm_backbone.py
deleted file mode 100644
index d9a50cf..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_timm_backbone.py
+++ /dev/null
@@ -1,133 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.backbones import TIMMBackbone
-from .utils import check_norm_state
-
-
-def test_timm_backbone():
-    with pytest.raises(TypeError):
-        # pretrained must be a string path
-        model = TIMMBackbone()
-        model.init_weights(pretrained=0)
-
-    # Test different norm_layer, can be: 'SyncBN', 'BN2d', 'GN', 'LN', 'IN'
-    # Test resnet18 from timm, norm_layer='BN2d'
-    model = TIMMBackbone(
-        model_name='resnet18',
-        features_only=True,
-        pretrained=False,
-        output_stride=32,
-        norm_layer='BN2d')
-
-    # Test resnet18 from timm, norm_layer='SyncBN'
-    model = TIMMBackbone(
-        model_name='resnet18',
-        features_only=True,
-        pretrained=False,
-        output_stride=32,
-        norm_layer='SyncBN2d')
-
-    # Test resnet18 from timm, features_only=True, output_stride=32
-    model = TIMMBackbone(
-        model_name='resnet18',
-        features_only=True,
-        pretrained=False,
-        output_stride=32)
-    model.init_weights()
-    model.train()
-    assert check_norm_state(model.modules(), True)
-
-    imgs = torch.randn(1, 3, 224, 224)
-    feats = model(imgs)
-    feats = [feat.shape for feat in feats]
-    assert len(feats) == 5
-    assert feats[0] == torch.Size((1, 64, 112, 112))
-    assert feats[1] == torch.Size((1, 64, 56, 56))
-    assert feats[2] == torch.Size((1, 128, 28, 28))
-    assert feats[3] == torch.Size((1, 256, 14, 14))
-    assert feats[4] == torch.Size((1, 512, 7, 7))
-
-    # Test resnet18 from timm, features_only=True, output_stride=16
-    model = TIMMBackbone(
-        model_name='resnet18',
-        features_only=True,
-        pretrained=False,
-        output_stride=16)
-    imgs = torch.randn(1, 3, 224, 224)
-    feats = model(imgs)
-    feats = [feat.shape for feat in feats]
-    assert len(feats) == 5
-    assert feats[0] == torch.Size((1, 64, 112, 112))
-    assert feats[1] == torch.Size((1, 64, 56, 56))
-    assert feats[2] == torch.Size((1, 128, 28, 28))
-    assert feats[3] == torch.Size((1, 256, 14, 14))
-    assert feats[4] == torch.Size((1, 512, 14, 14))
-
-    # Test resnet18 from timm, features_only=True, output_stride=8
-    model = TIMMBackbone(
-        model_name='resnet18',
-        features_only=True,
-        pretrained=False,
-        output_stride=8)
-    imgs = torch.randn(1, 3, 224, 224)
-    feats = model(imgs)
-    feats = [feat.shape for feat in feats]
-    assert len(feats) == 5
-    assert feats[0] == torch.Size((1, 64, 112, 112))
-    assert feats[1] == torch.Size((1, 64, 56, 56))
-    assert feats[2] == torch.Size((1, 128, 28, 28))
-    assert feats[3] == torch.Size((1, 256, 28, 28))
-    assert feats[4] == torch.Size((1, 512, 28, 28))
-
-    # Test efficientnet_b1 with pretrained weights
-    model = TIMMBackbone(model_name='efficientnet_b1', pretrained=True)
-
-    # Test resnetv2_50x1_bitm from timm, features_only=True, output_stride=8
-    model = TIMMBackbone(
-        model_name='resnetv2_50x1_bitm',
-        features_only=True,
-        pretrained=False,
-        output_stride=8)
-    imgs = torch.randn(1, 3, 8, 8)
-    feats = model(imgs)
-    feats = [feat.shape for feat in feats]
-    assert len(feats) == 5
-    assert feats[0] == torch.Size((1, 64, 4, 4))
-    assert feats[1] == torch.Size((1, 256, 2, 2))
-    assert feats[2] == torch.Size((1, 512, 1, 1))
-    assert feats[3] == torch.Size((1, 1024, 1, 1))
-    assert feats[4] == torch.Size((1, 2048, 1, 1))
-
-    # Test resnetv2_50x3_bitm from timm, features_only=True, output_stride=8
-    model = TIMMBackbone(
-        model_name='resnetv2_50x3_bitm',
-        features_only=True,
-        pretrained=False,
-        output_stride=8)
-    imgs = torch.randn(1, 3, 8, 8)
-    feats = model(imgs)
-    feats = [feat.shape for feat in feats]
-    assert len(feats) == 5
-    assert feats[0] == torch.Size((1, 192, 4, 4))
-    assert feats[1] == torch.Size((1, 768, 2, 2))
-    assert feats[2] == torch.Size((1, 1536, 1, 1))
-    assert feats[3] == torch.Size((1, 3072, 1, 1))
-    assert feats[4] == torch.Size((1, 6144, 1, 1))
-
-    # Test resnetv2_101x1_bitm from timm, features_only=True, output_stride=8
-    model = TIMMBackbone(
-        model_name='resnetv2_101x1_bitm',
-        features_only=True,
-        pretrained=False,
-        output_stride=8)
-    imgs = torch.randn(1, 3, 8, 8)
-    feats = model(imgs)
-    feats = [feat.shape for feat in feats]
-    assert len(feats) == 5
-    assert feats[0] == torch.Size((1, 64, 4, 4))
-    assert feats[1] == torch.Size((1, 256, 2, 2))
-    assert feats[2] == torch.Size((1, 512, 1, 1))
-    assert feats[3] == torch.Size((1, 1024, 1, 1))
-    assert feats[4] == torch.Size((1, 2048, 1, 1))
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_twins.py b/mmsegmentation/tests/test_models/test_backbones/test_twins.py
deleted file mode 100644
index aa3eaf9..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_twins.py
+++ /dev/null
@@ -1,171 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.backbones.twins import (PCPVT, SVT,
-                                          ConditionalPositionEncoding,
-                                          LocallyGroupedSelfAttention)
-
-
-def test_pcpvt():
-    # Test normal input
-    H, W = (224, 224)
-    temp = torch.randn((1, 3, H, W))
-    model = PCPVT(
-        embed_dims=[32, 64, 160, 256],
-        num_heads=[1, 2, 5, 8],
-        mlp_ratios=[8, 8, 4, 4],
-        qkv_bias=True,
-        depths=[3, 4, 6, 3],
-        sr_ratios=[8, 4, 2, 1],
-        norm_after_stage=False)
-    model.init_weights()
-    outs = model(temp)
-    assert outs[0].shape == (1, 32, H // 4, W // 4)
-    assert outs[1].shape == (1, 64, H // 8, W // 8)
-    assert outs[2].shape == (1, 160, H // 16, W // 16)
-    assert outs[3].shape == (1, 256, H // 32, W // 32)
-
-
-def test_svt():
-    # Test normal input
-    H, W = (224, 224)
-    temp = torch.randn((1, 3, H, W))
-    model = SVT(
-        embed_dims=[32, 64, 128],
-        num_heads=[1, 2, 4],
-        mlp_ratios=[4, 4, 4],
-        qkv_bias=False,
-        depths=[4, 4, 4],
-        windiow_sizes=[7, 7, 7],
-        norm_after_stage=True)
-
-    model.init_weights()
-    outs = model(temp)
-    assert outs[0].shape == (1, 32, H // 4, W // 4)
-    assert outs[1].shape == (1, 64, H // 8, W // 8)
-    assert outs[2].shape == (1, 128, H // 16, W // 16)
-
-
-def test_svt_init():
-    path = 'PATH_THAT_DO_NOT_EXIST'
-    # Test all combinations of pretrained and init_cfg
-    # pretrained=None, init_cfg=None
-    model = SVT(pretrained=None, init_cfg=None)
-    assert model.init_cfg is None
-    model.init_weights()
-
-    # pretrained=None
-    # init_cfg loads pretrain from an non-existent file
-    model = SVT(
-        pretrained=None, init_cfg=dict(type='Pretrained', checkpoint=path))
-    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
-    # Test loading a checkpoint from an non-existent file
-    with pytest.raises(OSError):
-        model.init_weights()
-
-    # pretrained=None
-    # init_cfg=123, whose type is unsupported
-    model = SVT(pretrained=None, init_cfg=123)
-    with pytest.raises(TypeError):
-        model.init_weights()
-
-    # pretrained loads pretrain from an non-existent file
-    # init_cfg=None
-    model = SVT(pretrained=path, init_cfg=None)
-    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
-    # Test loading a checkpoint from an non-existent file
-    with pytest.raises(OSError):
-        model.init_weights()
-
-    # pretrained loads pretrain from an non-existent file
-    # init_cfg loads pretrain from an non-existent file
-    with pytest.raises(AssertionError):
-        model = SVT(
-            pretrained=path, init_cfg=dict(type='Pretrained', checkpoint=path))
-    with pytest.raises(AssertionError):
-        model = SVT(pretrained=path, init_cfg=123)
-
-    # pretrain=123, whose type is unsupported
-    # init_cfg=None
-    with pytest.raises(TypeError):
-        model = SVT(pretrained=123, init_cfg=None)
-
-    # pretrain=123, whose type is unsupported
-    # init_cfg loads pretrain from an non-existent file
-    with pytest.raises(AssertionError):
-        model = SVT(
-            pretrained=123, init_cfg=dict(type='Pretrained', checkpoint=path))
-
-    # pretrain=123, whose type is unsupported
-    # init_cfg=123, whose type is unsupported
-    with pytest.raises(AssertionError):
-        model = SVT(pretrained=123, init_cfg=123)
-
-
-def test_pcpvt_init():
-    path = 'PATH_THAT_DO_NOT_EXIST'
-    # Test all combinations of pretrained and init_cfg
-    # pretrained=None, init_cfg=None
-    model = PCPVT(pretrained=None, init_cfg=None)
-    assert model.init_cfg is None
-    model.init_weights()
-
-    # pretrained=None
-    # init_cfg loads pretrain from an non-existent file
-    model = PCPVT(
-        pretrained=None, init_cfg=dict(type='Pretrained', checkpoint=path))
-    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
-    # Test loading a checkpoint from an non-existent file
-    with pytest.raises(OSError):
-        model.init_weights()
-
-    # pretrained=None
-    # init_cfg=123, whose type is unsupported
-    model = PCPVT(pretrained=None, init_cfg=123)
-    with pytest.raises(TypeError):
-        model.init_weights()
-
-    # pretrained loads pretrain from an non-existent file
-    # init_cfg=None
-    model = PCPVT(pretrained=path, init_cfg=None)
-    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
-    # Test loading a checkpoint from an non-existent file
-    with pytest.raises(OSError):
-        model.init_weights()
-
-    # pretrained loads pretrain from an non-existent file
-    # init_cfg loads pretrain from an non-existent file
-    with pytest.raises(AssertionError):
-        model = PCPVT(
-            pretrained=path, init_cfg=dict(type='Pretrained', checkpoint=path))
-    with pytest.raises(AssertionError):
-        model = PCPVT(pretrained=path, init_cfg=123)
-
-    # pretrain=123, whose type is unsupported
-    # init_cfg=None
-    with pytest.raises(TypeError):
-        model = PCPVT(pretrained=123, init_cfg=None)
-
-    # pretrain=123, whose type is unsupported
-    # init_cfg loads pretrain from an non-existent file
-    with pytest.raises(AssertionError):
-        model = PCPVT(
-            pretrained=123, init_cfg=dict(type='Pretrained', checkpoint=path))
-
-    # pretrain=123, whose type is unsupported
-    # init_cfg=123, whose type is unsupported
-    with pytest.raises(AssertionError):
-        model = PCPVT(pretrained=123, init_cfg=123)
-
-
-def test_locallygrouped_self_attention_module():
-    LSA = LocallyGroupedSelfAttention(embed_dims=32, window_size=3)
-    outs = LSA(torch.randn(1, 3136, 32), (56, 56))
-    assert outs.shape == torch.Size([1, 3136, 32])
-
-
-def test_conditional_position_encoding_module():
-    CPE = ConditionalPositionEncoding(in_channels=32, embed_dims=32, stride=2)
-    outs = CPE(torch.randn(1, 3136, 32), (56, 56))
-    assert outs.shape == torch.Size([1, 784, 32])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_unet.py b/mmsegmentation/tests/test_models/test_backbones/test_unet.py
deleted file mode 100644
index 4d3faf6..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_unet.py
+++ /dev/null
@@ -1,825 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-from mmcv.cnn import ConvModule
-from mmengine.registry import init_default_scope
-
-from mmseg.models.backbones.unet import (BasicConvBlock, DeconvModule,
-                                         InterpConv, UNet, UpConvBlock)
-from mmseg.models.utils import Upsample
-from .utils import check_norm_state
-
-init_default_scope('mmseg')
-
-
-def test_unet_basic_conv_block():
-    with pytest.raises(AssertionError):
-        # Not implemented yet.
-        dcn = dict(type='DCN', deform_groups=1, fallback_on_stride=False)
-        BasicConvBlock(64, 64, dcn=dcn)
-
-    with pytest.raises(AssertionError):
-        # Not implemented yet.
-        plugins = [
-            dict(
-                cfg=dict(type='ContextBlock', ratio=1. / 16),
-                position='after_conv3')
-        ]
-        BasicConvBlock(64, 64, plugins=plugins)
-
-    with pytest.raises(AssertionError):
-        # Not implemented yet
-        plugins = [
-            dict(
-                cfg=dict(
-                    type='GeneralizedAttention',
-                    spatial_range=-1,
-                    num_heads=8,
-                    attention_type='0010',
-                    kv_stride=2),
-                position='after_conv2')
-        ]
-        BasicConvBlock(64, 64, plugins=plugins)
-
-    # test BasicConvBlock with checkpoint forward
-    block = BasicConvBlock(16, 16, with_cp=True)
-    assert block.with_cp
-    x = torch.randn(1, 16, 64, 64, requires_grad=True)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([1, 16, 64, 64])
-
-    block = BasicConvBlock(16, 16, with_cp=False)
-    assert not block.with_cp
-    x = torch.randn(1, 16, 64, 64)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([1, 16, 64, 64])
-
-    # test BasicConvBlock with stride convolution to downsample
-    block = BasicConvBlock(16, 16, stride=2)
-    x = torch.randn(1, 16, 64, 64)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([1, 16, 32, 32])
-
-    # test BasicConvBlock structure and forward
-    block = BasicConvBlock(16, 64, num_convs=3, dilation=3)
-    assert block.convs[0].conv.in_channels == 16
-    assert block.convs[0].conv.out_channels == 64
-    assert block.convs[0].conv.kernel_size == (3, 3)
-    assert block.convs[0].conv.dilation == (1, 1)
-    assert block.convs[0].conv.padding == (1, 1)
-
-    assert block.convs[1].conv.in_channels == 64
-    assert block.convs[1].conv.out_channels == 64
-    assert block.convs[1].conv.kernel_size == (3, 3)
-    assert block.convs[1].conv.dilation == (3, 3)
-    assert block.convs[1].conv.padding == (3, 3)
-
-    assert block.convs[2].conv.in_channels == 64
-    assert block.convs[2].conv.out_channels == 64
-    assert block.convs[2].conv.kernel_size == (3, 3)
-    assert block.convs[2].conv.dilation == (3, 3)
-    assert block.convs[2].conv.padding == (3, 3)
-
-
-def test_deconv_module():
-    with pytest.raises(AssertionError):
-        # kernel_size should be greater than or equal to scale_factor and
-        # (kernel_size - scale_factor) should be even numbers
-        DeconvModule(64, 32, kernel_size=1, scale_factor=2)
-
-    with pytest.raises(AssertionError):
-        # kernel_size should be greater than or equal to scale_factor and
-        # (kernel_size - scale_factor) should be even numbers
-        DeconvModule(64, 32, kernel_size=3, scale_factor=2)
-
-    with pytest.raises(AssertionError):
-        # kernel_size should be greater than or equal to scale_factor and
-        # (kernel_size - scale_factor) should be even numbers
-        DeconvModule(64, 32, kernel_size=5, scale_factor=4)
-
-    # test DeconvModule with checkpoint forward and upsample 2X.
-    block = DeconvModule(64, 32, with_cp=True)
-    assert block.with_cp
-    x = torch.randn(1, 64, 128, 128, requires_grad=True)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([1, 32, 256, 256])
-
-    block = DeconvModule(64, 32, with_cp=False)
-    assert not block.with_cp
-    x = torch.randn(1, 64, 128, 128)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([1, 32, 256, 256])
-
-    # test DeconvModule with different kernel size for upsample 2X.
-    x = torch.randn(1, 64, 64, 64)
-    block = DeconvModule(64, 32, kernel_size=2, scale_factor=2)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([1, 32, 128, 128])
-
-    block = DeconvModule(64, 32, kernel_size=6, scale_factor=2)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([1, 32, 128, 128])
-
-    # test DeconvModule with different kernel size for upsample 4X.
-    x = torch.randn(1, 64, 64, 64)
-    block = DeconvModule(64, 32, kernel_size=4, scale_factor=4)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([1, 32, 256, 256])
-
-    block = DeconvModule(64, 32, kernel_size=6, scale_factor=4)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([1, 32, 256, 256])
-
-
-def test_interp_conv():
-    # test InterpConv with checkpoint forward and upsample 2X.
-    block = InterpConv(64, 32, with_cp=True)
-    assert block.with_cp
-    x = torch.randn(1, 64, 128, 128, requires_grad=True)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([1, 32, 256, 256])
-
-    block = InterpConv(64, 32, with_cp=False)
-    assert not block.with_cp
-    x = torch.randn(1, 64, 128, 128)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([1, 32, 256, 256])
-
-    # test InterpConv with conv_first=False for upsample 2X.
-    block = InterpConv(64, 32, conv_first=False)
-    x = torch.randn(1, 64, 128, 128)
-    x_out = block(x)
-    assert isinstance(block.interp_upsample[0], Upsample)
-    assert isinstance(block.interp_upsample[1], ConvModule)
-    assert x_out.shape == torch.Size([1, 32, 256, 256])
-
-    # test InterpConv with conv_first=True for upsample 2X.
-    block = InterpConv(64, 32, conv_first=True)
-    x = torch.randn(1, 64, 128, 128)
-    x_out = block(x)
-    assert isinstance(block.interp_upsample[0], ConvModule)
-    assert isinstance(block.interp_upsample[1], Upsample)
-    assert x_out.shape == torch.Size([1, 32, 256, 256])
-
-    # test InterpConv with bilinear upsample for upsample 2X.
-    block = InterpConv(
-        64,
-        32,
-        conv_first=False,
-        upsample_cfg=dict(
-            scale_factor=2, mode='bilinear', align_corners=False))
-    x = torch.randn(1, 64, 128, 128)
-    x_out = block(x)
-    assert isinstance(block.interp_upsample[0], Upsample)
-    assert isinstance(block.interp_upsample[1], ConvModule)
-    assert x_out.shape == torch.Size([1, 32, 256, 256])
-    assert block.interp_upsample[0].mode == 'bilinear'
-
-    # test InterpConv with nearest upsample for upsample 2X.
-    block = InterpConv(
-        64,
-        32,
-        conv_first=False,
-        upsample_cfg=dict(scale_factor=2, mode='nearest'))
-    x = torch.randn(1, 64, 128, 128)
-    x_out = block(x)
-    assert isinstance(block.interp_upsample[0], Upsample)
-    assert isinstance(block.interp_upsample[1], ConvModule)
-    assert x_out.shape == torch.Size([1, 32, 256, 256])
-    assert block.interp_upsample[0].mode == 'nearest'
-
-
-def test_up_conv_block():
-    with pytest.raises(AssertionError):
-        # Not implemented yet.
-        dcn = dict(type='DCN', deform_groups=1, fallback_on_stride=False)
-        UpConvBlock(BasicConvBlock, 64, 32, 32, dcn=dcn)
-
-    with pytest.raises(AssertionError):
-        # Not implemented yet.
-        plugins = [
-            dict(
-                cfg=dict(type='ContextBlock', ratio=1. / 16),
-                position='after_conv3')
-        ]
-        UpConvBlock(BasicConvBlock, 64, 32, 32, plugins=plugins)
-
-    with pytest.raises(AssertionError):
-        # Not implemented yet
-        plugins = [
-            dict(
-                cfg=dict(
-                    type='GeneralizedAttention',
-                    spatial_range=-1,
-                    num_heads=8,
-                    attention_type='0010',
-                    kv_stride=2),
-                position='after_conv2')
-        ]
-        UpConvBlock(BasicConvBlock, 64, 32, 32, plugins=plugins)
-
-    # test UpConvBlock with checkpoint forward and upsample 2X.
-    block = UpConvBlock(BasicConvBlock, 64, 32, 32, with_cp=True)
-    skip_x = torch.randn(1, 32, 256, 256, requires_grad=True)
-    x = torch.randn(1, 64, 128, 128, requires_grad=True)
-    x_out = block(skip_x, x)
-    assert x_out.shape == torch.Size([1, 32, 256, 256])
-
-    # test UpConvBlock with upsample=True for upsample 2X. The spatial size of
-    # skip_x is 2X larger than x.
-    block = UpConvBlock(
-        BasicConvBlock, 64, 32, 32, upsample_cfg=dict(type='InterpConv'))
-    skip_x = torch.randn(1, 32, 256, 256)
-    x = torch.randn(1, 64, 128, 128)
-    x_out = block(skip_x, x)
-    assert x_out.shape == torch.Size([1, 32, 256, 256])
-
-    # test UpConvBlock with upsample=False for upsample 2X. The spatial size of
-    # skip_x is the same as that of x.
-    block = UpConvBlock(BasicConvBlock, 64, 32, 32, upsample_cfg=None)
-    skip_x = torch.randn(1, 32, 256, 256)
-    x = torch.randn(1, 64, 256, 256)
-    x_out = block(skip_x, x)
-    assert x_out.shape == torch.Size([1, 32, 256, 256])
-
-    # test UpConvBlock with different upsample method for upsample 2X.
-    # The upsample method is interpolation upsample (bilinear or nearest).
-    block = UpConvBlock(
-        BasicConvBlock,
-        64,
-        32,
-        32,
-        upsample_cfg=dict(
-            type='InterpConv',
-            upsample_cfg=dict(
-                scale_factor=2, mode='bilinear', align_corners=False)))
-    skip_x = torch.randn(1, 32, 256, 256)
-    x = torch.randn(1, 64, 128, 128)
-    x_out = block(skip_x, x)
-    assert x_out.shape == torch.Size([1, 32, 256, 256])
-
-    # test UpConvBlock with different upsample method for upsample 2X.
-    # The upsample method is deconvolution upsample.
-    block = UpConvBlock(
-        BasicConvBlock,
-        64,
-        32,
-        32,
-        upsample_cfg=dict(type='DeconvModule', kernel_size=4, scale_factor=2))
-    skip_x = torch.randn(1, 32, 256, 256)
-    x = torch.randn(1, 64, 128, 128)
-    x_out = block(skip_x, x)
-    assert x_out.shape == torch.Size([1, 32, 256, 256])
-
-    # test BasicConvBlock structure and forward
-    block = UpConvBlock(
-        conv_block=BasicConvBlock,
-        in_channels=64,
-        skip_channels=32,
-        out_channels=32,
-        num_convs=3,
-        dilation=3,
-        upsample_cfg=dict(
-            type='InterpConv',
-            upsample_cfg=dict(
-                scale_factor=2, mode='bilinear', align_corners=False)))
-    skip_x = torch.randn(1, 32, 256, 256)
-    x = torch.randn(1, 64, 128, 128)
-    x_out = block(skip_x, x)
-    assert x_out.shape == torch.Size([1, 32, 256, 256])
-
-    assert block.conv_block.convs[0].conv.in_channels == 64
-    assert block.conv_block.convs[0].conv.out_channels == 32
-    assert block.conv_block.convs[0].conv.kernel_size == (3, 3)
-    assert block.conv_block.convs[0].conv.dilation == (1, 1)
-    assert block.conv_block.convs[0].conv.padding == (1, 1)
-
-    assert block.conv_block.convs[1].conv.in_channels == 32
-    assert block.conv_block.convs[1].conv.out_channels == 32
-    assert block.conv_block.convs[1].conv.kernel_size == (3, 3)
-    assert block.conv_block.convs[1].conv.dilation == (3, 3)
-    assert block.conv_block.convs[1].conv.padding == (3, 3)
-
-    assert block.conv_block.convs[2].conv.in_channels == 32
-    assert block.conv_block.convs[2].conv.out_channels == 32
-    assert block.conv_block.convs[2].conv.kernel_size == (3, 3)
-    assert block.conv_block.convs[2].conv.dilation == (3, 3)
-    assert block.conv_block.convs[2].conv.padding == (3, 3)
-
-    assert block.upsample.interp_upsample[1].conv.in_channels == 64
-    assert block.upsample.interp_upsample[1].conv.out_channels == 32
-    assert block.upsample.interp_upsample[1].conv.kernel_size == (1, 1)
-    assert block.upsample.interp_upsample[1].conv.dilation == (1, 1)
-    assert block.upsample.interp_upsample[1].conv.padding == (0, 0)
-
-
-def test_unet():
-    with pytest.raises(AssertionError):
-        # Not implemented yet.
-        dcn = dict(type='DCN', deform_groups=1, fallback_on_stride=False)
-        UNet(3, 64, 5, dcn=dcn)
-
-    with pytest.raises(AssertionError):
-        # Not implemented yet.
-        plugins = [
-            dict(
-                cfg=dict(type='ContextBlock', ratio=1. / 16),
-                position='after_conv3')
-        ]
-        UNet(3, 64, 5, plugins=plugins)
-
-    with pytest.raises(AssertionError):
-        # Not implemented yet
-        plugins = [
-            dict(
-                cfg=dict(
-                    type='GeneralizedAttention',
-                    spatial_range=-1,
-                    num_heads=8,
-                    attention_type='0010',
-                    kv_stride=2),
-                position='after_conv2')
-        ]
-        UNet(3, 64, 5, plugins=plugins)
-
-    with pytest.raises(AssertionError):
-        # Check whether the input image size can be divisible by the whole
-        # downsample rate of the encoder. The whole downsample rate of this
-        # case is 8.
-        unet = UNet(
-            in_channels=3,
-            base_channels=4,
-            num_stages=4,
-            strides=(1, 1, 1, 1),
-            enc_num_convs=(2, 2, 2, 2),
-            dec_num_convs=(2, 2, 2),
-            downsamples=(True, True, True),
-            enc_dilations=(1, 1, 1, 1),
-            dec_dilations=(1, 1, 1))
-        x = torch.randn(2, 3, 65, 65)
-        unet(x)
-
-    with pytest.raises(AssertionError):
-        # Check whether the input image size can be divisible by the whole
-        # downsample rate of the encoder. The whole downsample rate of this
-        # case is 16.
-        unet = UNet(
-            in_channels=3,
-            base_channels=4,
-            num_stages=5,
-            strides=(1, 1, 1, 1, 1),
-            enc_num_convs=(2, 2, 2, 2, 2),
-            dec_num_convs=(2, 2, 2, 2),
-            downsamples=(True, True, True, True),
-            enc_dilations=(1, 1, 1, 1, 1),
-            dec_dilations=(1, 1, 1, 1))
-        x = torch.randn(2, 3, 65, 65)
-        unet(x)
-
-    with pytest.raises(AssertionError):
-        # Check whether the input image size can be divisible by the whole
-        # downsample rate of the encoder. The whole downsample rate of this
-        # case is 8.
-        unet = UNet(
-            in_channels=3,
-            base_channels=4,
-            num_stages=5,
-            strides=(1, 1, 1, 1, 1),
-            enc_num_convs=(2, 2, 2, 2, 2),
-            dec_num_convs=(2, 2, 2, 2),
-            downsamples=(True, True, True, False),
-            enc_dilations=(1, 1, 1, 1, 1),
-            dec_dilations=(1, 1, 1, 1))
-        x = torch.randn(2, 3, 65, 65)
-        unet(x)
-
-    with pytest.raises(AssertionError):
-        # Check whether the input image size can be divisible by the whole
-        # downsample rate of the encoder. The whole downsample rate of this
-        # case is 8.
-        unet = UNet(
-            in_channels=3,
-            base_channels=4,
-            num_stages=5,
-            strides=(1, 2, 2, 2, 1),
-            enc_num_convs=(2, 2, 2, 2, 2),
-            dec_num_convs=(2, 2, 2, 2),
-            downsamples=(True, True, True, False),
-            enc_dilations=(1, 1, 1, 1, 1),
-            dec_dilations=(1, 1, 1, 1))
-        x = torch.randn(2, 3, 65, 65)
-        unet(x)
-
-    with pytest.raises(AssertionError):
-        # Check whether the input image size can be divisible by the whole
-        # downsample rate of the encoder. The whole downsample rate of this
-        # case is 32.
-        unet = UNet(
-            in_channels=3,
-            base_channels=4,
-            num_stages=6,
-            strides=(1, 1, 1, 1, 1, 1),
-            enc_num_convs=(2, 2, 2, 2, 2, 2),
-            dec_num_convs=(2, 2, 2, 2, 2),
-            downsamples=(True, True, True, True, True),
-            enc_dilations=(1, 1, 1, 1, 1, 1),
-            dec_dilations=(1, 1, 1, 1, 1))
-        x = torch.randn(2, 3, 65, 65)
-        unet(x)
-
-    with pytest.raises(AssertionError):
-        # Check if num_stages matches strides, len(strides)=num_stages
-        unet = UNet(
-            in_channels=3,
-            base_channels=4,
-            num_stages=5,
-            strides=(1, 1, 1, 1),
-            enc_num_convs=(2, 2, 2, 2, 2),
-            dec_num_convs=(2, 2, 2, 2),
-            downsamples=(True, True, True, True),
-            enc_dilations=(1, 1, 1, 1, 1),
-            dec_dilations=(1, 1, 1, 1))
-        x = torch.randn(2, 3, 64, 64)
-        unet(x)
-
-    with pytest.raises(AssertionError):
-        # Check if num_stages matches strides, len(enc_num_convs)=num_stages
-        unet = UNet(
-            in_channels=3,
-            base_channels=4,
-            num_stages=5,
-            strides=(1, 1, 1, 1, 1),
-            enc_num_convs=(2, 2, 2, 2),
-            dec_num_convs=(2, 2, 2, 2),
-            downsamples=(True, True, True, True),
-            enc_dilations=(1, 1, 1, 1, 1),
-            dec_dilations=(1, 1, 1, 1))
-        x = torch.randn(2, 3, 64, 64)
-        unet(x)
-
-    with pytest.raises(AssertionError):
-        # Check if num_stages matches strides, len(dec_num_convs)=num_stages-1
-        unet = UNet(
-            in_channels=3,
-            base_channels=4,
-            num_stages=5,
-            strides=(1, 1, 1, 1, 1),
-            enc_num_convs=(2, 2, 2, 2, 2),
-            dec_num_convs=(2, 2, 2, 2, 2),
-            downsamples=(True, True, True, True),
-            enc_dilations=(1, 1, 1, 1, 1),
-            dec_dilations=(1, 1, 1, 1))
-        x = torch.randn(2, 3, 64, 64)
-        unet(x)
-
-    with pytest.raises(AssertionError):
-        # Check if num_stages matches strides, len(downsamples)=num_stages-1
-        unet = UNet(
-            in_channels=3,
-            base_channels=4,
-            num_stages=5,
-            strides=(1, 1, 1, 1, 1),
-            enc_num_convs=(2, 2, 2, 2, 2),
-            dec_num_convs=(2, 2, 2, 2),
-            downsamples=(True, True, True),
-            enc_dilations=(1, 1, 1, 1, 1),
-            dec_dilations=(1, 1, 1, 1))
-        x = torch.randn(2, 3, 64, 64)
-        unet(x)
-
-    with pytest.raises(AssertionError):
-        # Check if num_stages matches strides, len(enc_dilations)=num_stages
-        unet = UNet(
-            in_channels=3,
-            base_channels=4,
-            num_stages=5,
-            strides=(1, 1, 1, 1, 1),
-            enc_num_convs=(2, 2, 2, 2, 2),
-            dec_num_convs=(2, 2, 2, 2),
-            downsamples=(True, True, True, True),
-            enc_dilations=(1, 1, 1, 1),
-            dec_dilations=(1, 1, 1, 1))
-        x = torch.randn(2, 3, 64, 64)
-        unet(x)
-
-    with pytest.raises(AssertionError):
-        # Check if num_stages matches strides, len(dec_dilations)=num_stages-1
-        unet = UNet(
-            in_channels=3,
-            base_channels=4,
-            num_stages=5,
-            strides=(1, 1, 1, 1, 1),
-            enc_num_convs=(2, 2, 2, 2, 2),
-            dec_num_convs=(2, 2, 2, 2),
-            downsamples=(True, True, True, True),
-            enc_dilations=(1, 1, 1, 1, 1),
-            dec_dilations=(1, 1, 1, 1, 1))
-        x = torch.randn(2, 3, 64, 64)
-        unet(x)
-
-    # test UNet norm_eval=True
-    unet = UNet(
-        in_channels=3,
-        base_channels=4,
-        num_stages=5,
-        strides=(1, 1, 1, 1, 1),
-        enc_num_convs=(2, 2, 2, 2, 2),
-        dec_num_convs=(2, 2, 2, 2),
-        downsamples=(True, True, True, True),
-        enc_dilations=(1, 1, 1, 1, 1),
-        dec_dilations=(1, 1, 1, 1),
-        norm_eval=True)
-    unet.train()
-    assert check_norm_state(unet.modules(), False)
-
-    # test UNet norm_eval=False
-    unet = UNet(
-        in_channels=3,
-        base_channels=4,
-        num_stages=5,
-        strides=(1, 1, 1, 1, 1),
-        enc_num_convs=(2, 2, 2, 2, 2),
-        dec_num_convs=(2, 2, 2, 2),
-        downsamples=(True, True, True, True),
-        enc_dilations=(1, 1, 1, 1, 1),
-        dec_dilations=(1, 1, 1, 1),
-        norm_eval=False)
-    unet.train()
-    assert check_norm_state(unet.modules(), True)
-
-    # test UNet forward and outputs. The whole downsample rate is 16.
-    unet = UNet(
-        in_channels=3,
-        base_channels=4,
-        num_stages=5,
-        strides=(1, 1, 1, 1, 1),
-        enc_num_convs=(2, 2, 2, 2, 2),
-        dec_num_convs=(2, 2, 2, 2),
-        downsamples=(True, True, True, True),
-        enc_dilations=(1, 1, 1, 1, 1),
-        dec_dilations=(1, 1, 1, 1))
-
-    x = torch.randn(2, 3, 128, 128)
-    x_outs = unet(x)
-    assert x_outs[0].shape == torch.Size([2, 64, 8, 8])
-    assert x_outs[1].shape == torch.Size([2, 32, 16, 16])
-    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
-    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
-    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
-
-    # test UNet forward and outputs. The whole downsample rate is 8.
-    unet = UNet(
-        in_channels=3,
-        base_channels=4,
-        num_stages=5,
-        strides=(1, 1, 1, 1, 1),
-        enc_num_convs=(2, 2, 2, 2, 2),
-        dec_num_convs=(2, 2, 2, 2),
-        downsamples=(True, True, True, False),
-        enc_dilations=(1, 1, 1, 1, 1),
-        dec_dilations=(1, 1, 1, 1))
-
-    x = torch.randn(2, 3, 128, 128)
-    x_outs = unet(x)
-    assert x_outs[0].shape == torch.Size([2, 64, 16, 16])
-    assert x_outs[1].shape == torch.Size([2, 32, 16, 16])
-    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
-    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
-    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
-
-    # test UNet forward and outputs. The whole downsample rate is 8.
-    unet = UNet(
-        in_channels=3,
-        base_channels=4,
-        num_stages=5,
-        strides=(1, 2, 2, 2, 1),
-        enc_num_convs=(2, 2, 2, 2, 2),
-        dec_num_convs=(2, 2, 2, 2),
-        downsamples=(True, True, True, False),
-        enc_dilations=(1, 1, 1, 1, 1),
-        dec_dilations=(1, 1, 1, 1))
-
-    x = torch.randn(2, 3, 128, 128)
-    x_outs = unet(x)
-    assert x_outs[0].shape == torch.Size([2, 64, 16, 16])
-    assert x_outs[1].shape == torch.Size([2, 32, 16, 16])
-    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
-    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
-    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
-
-    # test UNet forward and outputs. The whole downsample rate is 4.
-    unet = UNet(
-        in_channels=3,
-        base_channels=4,
-        num_stages=5,
-        strides=(1, 1, 1, 1, 1),
-        enc_num_convs=(2, 2, 2, 2, 2),
-        dec_num_convs=(2, 2, 2, 2),
-        downsamples=(True, True, False, False),
-        enc_dilations=(1, 1, 1, 1, 1),
-        dec_dilations=(1, 1, 1, 1))
-
-    x = torch.randn(2, 3, 128, 128)
-    x_outs = unet(x)
-    assert x_outs[0].shape == torch.Size([2, 64, 32, 32])
-    assert x_outs[1].shape == torch.Size([2, 32, 32, 32])
-    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
-    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
-    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
-
-    # test UNet forward and outputs. The whole downsample rate is 4.
-    unet = UNet(
-        in_channels=3,
-        base_channels=4,
-        num_stages=5,
-        strides=(1, 2, 2, 1, 1),
-        enc_num_convs=(2, 2, 2, 2, 2),
-        dec_num_convs=(2, 2, 2, 2),
-        downsamples=(True, True, False, False),
-        enc_dilations=(1, 1, 1, 1, 1),
-        dec_dilations=(1, 1, 1, 1))
-
-    x = torch.randn(2, 3, 128, 128)
-    x_outs = unet(x)
-    assert x_outs[0].shape == torch.Size([2, 64, 32, 32])
-    assert x_outs[1].shape == torch.Size([2, 32, 32, 32])
-    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
-    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
-    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
-
-    # test UNet forward and outputs. The whole downsample rate is 8.
-    unet = UNet(
-        in_channels=3,
-        base_channels=4,
-        num_stages=5,
-        strides=(1, 1, 1, 1, 1),
-        enc_num_convs=(2, 2, 2, 2, 2),
-        dec_num_convs=(2, 2, 2, 2),
-        downsamples=(True, True, True, False),
-        enc_dilations=(1, 1, 1, 1, 1),
-        dec_dilations=(1, 1, 1, 1))
-
-    x = torch.randn(2, 3, 128, 128)
-    x_outs = unet(x)
-    assert x_outs[0].shape == torch.Size([2, 64, 16, 16])
-    assert x_outs[1].shape == torch.Size([2, 32, 16, 16])
-    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
-    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
-    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
-
-    # test UNet forward and outputs. The whole downsample rate is 4.
-    unet = UNet(
-        in_channels=3,
-        base_channels=4,
-        num_stages=5,
-        strides=(1, 1, 1, 1, 1),
-        enc_num_convs=(2, 2, 2, 2, 2),
-        dec_num_convs=(2, 2, 2, 2),
-        downsamples=(True, True, False, False),
-        enc_dilations=(1, 1, 1, 1, 1),
-        dec_dilations=(1, 1, 1, 1))
-
-    x = torch.randn(2, 3, 128, 128)
-    x_outs = unet(x)
-    assert x_outs[0].shape == torch.Size([2, 64, 32, 32])
-    assert x_outs[1].shape == torch.Size([2, 32, 32, 32])
-    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
-    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
-    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
-
-    # test UNet forward and outputs. The whole downsample rate is 2.
-    unet = UNet(
-        in_channels=3,
-        base_channels=4,
-        num_stages=5,
-        strides=(1, 1, 1, 1, 1),
-        enc_num_convs=(2, 2, 2, 2, 2),
-        dec_num_convs=(2, 2, 2, 2),
-        downsamples=(True, False, False, False),
-        enc_dilations=(1, 1, 1, 1, 1),
-        dec_dilations=(1, 1, 1, 1))
-
-    x = torch.randn(2, 3, 128, 128)
-    x_outs = unet(x)
-    assert x_outs[0].shape == torch.Size([2, 64, 64, 64])
-    assert x_outs[1].shape == torch.Size([2, 32, 64, 64])
-    assert x_outs[2].shape == torch.Size([2, 16, 64, 64])
-    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
-    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
-
-    # test UNet forward and outputs. The whole downsample rate is 1.
-    unet = UNet(
-        in_channels=3,
-        base_channels=4,
-        num_stages=5,
-        strides=(1, 1, 1, 1, 1),
-        enc_num_convs=(2, 2, 2, 2, 2),
-        dec_num_convs=(2, 2, 2, 2),
-        downsamples=(False, False, False, False),
-        enc_dilations=(1, 1, 1, 1, 1),
-        dec_dilations=(1, 1, 1, 1))
-
-    x = torch.randn(2, 3, 128, 128)
-    x_outs = unet(x)
-    assert x_outs[0].shape == torch.Size([2, 64, 128, 128])
-    assert x_outs[1].shape == torch.Size([2, 32, 128, 128])
-    assert x_outs[2].shape == torch.Size([2, 16, 128, 128])
-    assert x_outs[3].shape == torch.Size([2, 8, 128, 128])
-    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
-
-    # test UNet forward and outputs. The whole downsample rate is 16.
-    unet = UNet(
-        in_channels=3,
-        base_channels=4,
-        num_stages=5,
-        strides=(1, 2, 2, 1, 1),
-        enc_num_convs=(2, 2, 2, 2, 2),
-        dec_num_convs=(2, 2, 2, 2),
-        downsamples=(True, True, True, True),
-        enc_dilations=(1, 1, 1, 1, 1),
-        dec_dilations=(1, 1, 1, 1))
-    x = torch.randn(2, 3, 128, 128)
-    x_outs = unet(x)
-    assert x_outs[0].shape == torch.Size([2, 64, 8, 8])
-    assert x_outs[1].shape == torch.Size([2, 32, 16, 16])
-    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
-    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
-    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
-
-    # test UNet forward and outputs. The whole downsample rate is 8.
-    unet = UNet(
-        in_channels=3,
-        base_channels=4,
-        num_stages=5,
-        strides=(1, 2, 2, 1, 1),
-        enc_num_convs=(2, 2, 2, 2, 2),
-        dec_num_convs=(2, 2, 2, 2),
-        downsamples=(True, True, True, False),
-        enc_dilations=(1, 1, 1, 1, 1),
-        dec_dilations=(1, 1, 1, 1))
-    x = torch.randn(2, 3, 128, 128)
-    x_outs = unet(x)
-    assert x_outs[0].shape == torch.Size([2, 64, 16, 16])
-    assert x_outs[1].shape == torch.Size([2, 32, 16, 16])
-    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
-    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
-    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
-
-    # test UNet forward and outputs. The whole downsample rate is 8.
-    unet = UNet(
-        in_channels=3,
-        base_channels=4,
-        num_stages=5,
-        strides=(1, 2, 2, 2, 1),
-        enc_num_convs=(2, 2, 2, 2, 2),
-        dec_num_convs=(2, 2, 2, 2),
-        downsamples=(True, True, True, False),
-        enc_dilations=(1, 1, 1, 1, 1),
-        dec_dilations=(1, 1, 1, 1))
-    x = torch.randn(2, 3, 128, 128)
-    x_outs = unet(x)
-    assert x_outs[0].shape == torch.Size([2, 64, 16, 16])
-    assert x_outs[1].shape == torch.Size([2, 32, 16, 16])
-    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
-    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
-    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
-
-    # test UNet forward and outputs. The whole downsample rate is 4.
-    unet = UNet(
-        in_channels=3,
-        base_channels=4,
-        num_stages=5,
-        strides=(1, 2, 2, 1, 1),
-        enc_num_convs=(2, 2, 2, 2, 2),
-        dec_num_convs=(2, 2, 2, 2),
-        downsamples=(True, True, False, False),
-        enc_dilations=(1, 1, 1, 1, 1),
-        dec_dilations=(1, 1, 1, 1))
-    x = torch.randn(2, 3, 128, 128)
-    x_outs = unet(x)
-    assert x_outs[0].shape == torch.Size([2, 64, 32, 32])
-    assert x_outs[1].shape == torch.Size([2, 32, 32, 32])
-    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
-    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
-    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
-
-    # test UNet init_weights method.
-    unet = UNet(
-        in_channels=3,
-        base_channels=4,
-        num_stages=5,
-        strides=(1, 2, 2, 1, 1),
-        enc_num_convs=(2, 2, 2, 2, 2),
-        dec_num_convs=(2, 2, 2, 2),
-        downsamples=(True, True, False, False),
-        enc_dilations=(1, 1, 1, 1, 1),
-        dec_dilations=(1, 1, 1, 1),
-        pretrained=None)
-    unet.init_weights()
-    x = torch.randn(2, 3, 128, 128)
-    x_outs = unet(x)
-    assert x_outs[0].shape == torch.Size([2, 64, 32, 32])
-    assert x_outs[1].shape == torch.Size([2, 32, 32, 32])
-    assert x_outs[2].shape == torch.Size([2, 16, 32, 32])
-    assert x_outs[3].shape == torch.Size([2, 8, 64, 64])
-    assert x_outs[4].shape == torch.Size([2, 4, 128, 128])
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_vit.py b/mmsegmentation/tests/test_models/test_backbones/test_vit.py
deleted file mode 100644
index 0d1ba70..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_vit.py
+++ /dev/null
@@ -1,185 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.backbones.vit import (TransformerEncoderLayer,
-                                        VisionTransformer)
-from .utils import check_norm_state
-
-
-def test_vit_backbone():
-    with pytest.raises(TypeError):
-        # pretrained must be a string path
-        model = VisionTransformer()
-        model.init_weights(pretrained=0)
-
-    with pytest.raises(TypeError):
-        # img_size must be int or tuple
-        model = VisionTransformer(img_size=512.0)
-
-    with pytest.raises(TypeError):
-        # out_indices must be int ,list or tuple
-        model = VisionTransformer(out_indices=1.)
-
-    with pytest.raises(TypeError):
-        # test upsample_pos_embed function
-        x = torch.randn(1, 196)
-        VisionTransformer.resize_pos_embed(x, 512, 512, 224, 224, 'bilinear')
-
-    with pytest.raises(AssertionError):
-        # The length of img_size tuple must be lower than 3.
-        VisionTransformer(img_size=(224, 224, 224))
-
-    with pytest.raises(TypeError):
-        # Pretrained must be None or Str.
-        VisionTransformer(pretrained=123)
-
-    with pytest.raises(AssertionError):
-        # with_cls_token must be True when output_cls_token == True
-        VisionTransformer(with_cls_token=False, output_cls_token=True)
-
-    # Test img_size isinstance tuple
-    imgs = torch.randn(1, 3, 224, 224)
-    model = VisionTransformer(img_size=(224, ))
-    model.init_weights()
-    model(imgs)
-
-    # Test img_size isinstance tuple
-    imgs = torch.randn(1, 3, 224, 224)
-    model = VisionTransformer(img_size=(224, 224))
-    model(imgs)
-
-    # Test norm_eval = True
-    model = VisionTransformer(norm_eval=True)
-    model.train()
-
-    # Test ViT backbone with input size of 224 and patch size of 16
-    model = VisionTransformer()
-    model.init_weights()
-    model.train()
-
-    assert check_norm_state(model.modules(), True)
-
-    # Test normal size input image
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 14, 14)
-
-    # Test large size input image
-    imgs = torch.randn(1, 3, 256, 256)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 16, 16)
-
-    # Test small size input image
-    imgs = torch.randn(1, 3, 32, 32)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 2, 2)
-
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 14, 14)
-
-    # Test unbalanced size input image
-    imgs = torch.randn(1, 3, 112, 224)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 7, 14)
-
-    # Test irregular input image
-    imgs = torch.randn(1, 3, 234, 345)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 15, 22)
-
-    # Test with_cp=True
-    model = VisionTransformer(with_cp=True)
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 14, 14)
-
-    # Test with_cls_token=False
-    model = VisionTransformer(with_cls_token=False)
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 14, 14)
-
-    # Test final norm
-    model = VisionTransformer(final_norm=True)
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 14, 14)
-
-    # Test patch norm
-    model = VisionTransformer(patch_norm=True)
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert feat[-1].shape == (1, 768, 14, 14)
-
-    # Test output_cls_token
-    model = VisionTransformer(with_cls_token=True, output_cls_token=True)
-    imgs = torch.randn(1, 3, 224, 224)
-    feat = model(imgs)
-    assert feat[0][0].shape == (1, 768, 14, 14)
-    assert feat[0][1].shape == (1, 768)
-
-    # Test TransformerEncoderLayer with checkpoint forward
-    block = TransformerEncoderLayer(
-        embed_dims=64, num_heads=4, feedforward_channels=256, with_cp=True)
-    assert block.with_cp
-    x = torch.randn(1, 56 * 56, 64)
-    x_out = block(x)
-    assert x_out.shape == torch.Size([1, 56 * 56, 64])
-
-
-def test_vit_init():
-    path = 'PATH_THAT_DO_NOT_EXIST'
-    # Test all combinations of pretrained and init_cfg
-    # pretrained=None, init_cfg=None
-    model = VisionTransformer(pretrained=None, init_cfg=None)
-    assert model.init_cfg is None
-    model.init_weights()
-
-    # pretrained=None
-    # init_cfg loads pretrain from an non-existent file
-    model = VisionTransformer(
-        pretrained=None, init_cfg=dict(type='Pretrained', checkpoint=path))
-    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
-    # Test loading a checkpoint from an non-existent file
-    with pytest.raises(OSError):
-        model.init_weights()
-
-    # pretrained=None
-    # init_cfg=123, whose type is unsupported
-    model = VisionTransformer(pretrained=None, init_cfg=123)
-    with pytest.raises(TypeError):
-        model.init_weights()
-
-    # pretrained loads pretrain from an non-existent file
-    # init_cfg=None
-    model = VisionTransformer(pretrained=path, init_cfg=None)
-    assert model.init_cfg == dict(type='Pretrained', checkpoint=path)
-    # Test loading a checkpoint from an non-existent file
-    with pytest.raises(OSError):
-        model.init_weights()
-
-    # pretrained loads pretrain from an non-existent file
-    # init_cfg loads pretrain from an non-existent file
-    with pytest.raises(AssertionError):
-        model = VisionTransformer(
-            pretrained=path, init_cfg=dict(type='Pretrained', checkpoint=path))
-    with pytest.raises(AssertionError):
-        model = VisionTransformer(pretrained=path, init_cfg=123)
-
-    # pretrain=123, whose type is unsupported
-    # init_cfg=None
-    with pytest.raises(TypeError):
-        model = VisionTransformer(pretrained=123, init_cfg=None)
-
-    # pretrain=123, whose type is unsupported
-    # init_cfg loads pretrain from an non-existent file
-    with pytest.raises(AssertionError):
-        model = VisionTransformer(
-            pretrained=123, init_cfg=dict(type='Pretrained', checkpoint=path))
-
-    # pretrain=123, whose type is unsupported
-    # init_cfg=123, whose type is unsupported
-    with pytest.raises(AssertionError):
-        model = VisionTransformer(pretrained=123, init_cfg=123)
diff --git a/mmsegmentation/tests/test_models/test_backbones/test_vpd.py b/mmsegmentation/tests/test_models/test_backbones/test_vpd.py
deleted file mode 100644
index a268159..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/test_vpd.py
+++ /dev/null
@@ -1,51 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from os.path import dirname, join
-from unittest import TestCase
-
-import torch
-from mmengine import Config
-
-import mmseg
-from mmseg.models.backbones import VPD
-
-
-class TestVPD(TestCase):
-
-    def setUp(self) -> None:
-
-        repo_dpath = dirname(dirname(mmseg.__file__))
-        config_dpath = join(repo_dpath, 'configs/_base_/models/vpd_sd.py')
-        vpd_cfg = Config.fromfile(config_dpath).stable_diffusion_cfg
-        vpd_cfg.pop('checkpoint')
-
-        self.vpd_model = VPD(
-            diffusion_cfg=vpd_cfg,
-            class_embed_path='https://download.openmmlab.com/mmsegmentation/'
-            'v0.5/vpd/nyu_class_embeddings.pth',
-            class_embed_select=True,
-            pad_shape=64,
-            unet_cfg=dict(use_attn=False),
-        )
-
-    def test_forward(self):
-        # test forward without class_id
-        x = torch.randn(1, 3, 60, 60)
-        with torch.no_grad():
-            out = self.vpd_model(x)
-
-        self.assertEqual(len(out), 4)
-        self.assertListEqual(list(out[0].shape), [1, 320, 8, 8])
-        self.assertListEqual(list(out[1].shape), [1, 640, 4, 4])
-        self.assertListEqual(list(out[2].shape), [1, 1280, 2, 2])
-        self.assertListEqual(list(out[3].shape), [1, 1280, 1, 1])
-
-        # test forward with class_id
-        x = torch.randn(1, 3, 60, 60)
-        with torch.no_grad():
-            out = self.vpd_model((x, torch.tensor([2])))
-
-        self.assertEqual(len(out), 4)
-        self.assertListEqual(list(out[0].shape), [1, 320, 8, 8])
-        self.assertListEqual(list(out[1].shape), [1, 640, 4, 4])
-        self.assertListEqual(list(out[2].shape), [1, 1280, 2, 2])
-        self.assertListEqual(list(out[3].shape), [1, 1280, 1, 1])
diff --git a/mmsegmentation/tests/test_models/test_backbones/utils.py b/mmsegmentation/tests/test_models/test_backbones/utils.py
deleted file mode 100644
index 54b6404..0000000
--- a/mmsegmentation/tests/test_models/test_backbones/utils.py
+++ /dev/null
@@ -1,43 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-from torch.nn.modules import GroupNorm
-from torch.nn.modules.batchnorm import _BatchNorm
-
-from mmseg.models.backbones.resnet import BasicBlock, Bottleneck
-from mmseg.models.backbones.resnext import Bottleneck as BottleneckX
-
-
-def is_block(modules):
-    """Check if is ResNet building block."""
-    if isinstance(modules, (BasicBlock, Bottleneck, BottleneckX)):
-        return True
-    return False
-
-
-def is_norm(modules):
-    """Check if is one of the norms."""
-    if isinstance(modules, (GroupNorm, _BatchNorm)):
-        return True
-    return False
-
-
-def all_zeros(modules):
-    """Check if the weight(and bias) is all zero."""
-    weight_zero = torch.allclose(modules.weight.data,
-                                 torch.zeros_like(modules.weight.data))
-    if hasattr(modules, 'bias'):
-        bias_zero = torch.allclose(modules.bias.data,
-                                   torch.zeros_like(modules.bias.data))
-    else:
-        bias_zero = True
-
-    return weight_zero and bias_zero
-
-
-def check_norm_state(modules, train_state):
-    """Check if norm layer is in correct train state."""
-    for mod in modules:
-        if isinstance(mod, _BatchNorm):
-            if mod.training != train_state:
-                return False
-    return True
diff --git a/mmsegmentation/tests/test_models/test_data_preprocessor.py b/mmsegmentation/tests/test_models/test_data_preprocessor.py
deleted file mode 100644
index d05eef1..0000000
--- a/mmsegmentation/tests/test_models/test_data_preprocessor.py
+++ /dev/null
@@ -1,64 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from unittest import TestCase
-
-import torch
-from mmengine.structures import PixelData
-
-from mmseg.models import SegDataPreProcessor
-from mmseg.structures import SegDataSample
-
-
-class TestSegDataPreProcessor(TestCase):
-
-    def test_init(self):
-        # test mean is None
-        processor = SegDataPreProcessor()
-        self.assertTrue(not hasattr(processor, 'mean'))
-        self.assertTrue(processor._enable_normalize is False)
-
-        # test mean is not None
-        processor = SegDataPreProcessor(mean=[0, 0, 0], std=[1, 1, 1])
-        self.assertTrue(hasattr(processor, 'mean'))
-        self.assertTrue(hasattr(processor, 'std'))
-        self.assertTrue(processor._enable_normalize)
-
-        # please specify both mean and std
-        with self.assertRaises(AssertionError):
-            SegDataPreProcessor(mean=[0, 0, 0])
-
-        # bgr2rgb and rgb2bgr cannot be set to True at the same time
-        with self.assertRaises(AssertionError):
-            SegDataPreProcessor(bgr_to_rgb=True, rgb_to_bgr=True)
-
-    def test_forward(self):
-        data_sample = SegDataSample()
-        data_sample.gt_sem_seg = PixelData(
-            **{'data': torch.randint(0, 10, (1, 11, 10))})
-        processor = SegDataPreProcessor(
-            mean=[0, 0, 0], std=[1, 1, 1], size=(20, 20))
-        data = {
-            'inputs': [
-                torch.randint(0, 256, (3, 11, 10)),
-                torch.randint(0, 256, (3, 11, 10))
-            ],
-            'data_samples': [data_sample, data_sample]
-        }
-        out = processor(data, training=True)
-        self.assertEqual(out['inputs'].shape, (2, 3, 20, 20))
-        self.assertEqual(len(out['data_samples']), 2)
-
-        # test predict with padding
-        processor = SegDataPreProcessor(
-            mean=[0, 0, 0],
-            std=[1, 1, 1],
-            size=(20, 20),
-            test_cfg=dict(size_divisor=15))
-        data = {
-            'inputs': [
-                torch.randint(0, 256, (3, 11, 10)),
-            ],
-            'data_samples': [data_sample]
-        }
-        out = processor(data, training=False)
-        self.assertEqual(out['inputs'].shape[2] % 15, 0)
-        self.assertEqual(out['inputs'].shape[3] % 15, 0)
diff --git a/mmsegmentation/tests/test_models/test_forward.py b/mmsegmentation/tests/test_models/test_forward.py
deleted file mode 100644
index bb3967f..0000000
--- a/mmsegmentation/tests/test_models/test_forward.py
+++ /dev/null
@@ -1,229 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-"""pytest tests/test_forward.py."""
-import copy
-from os.path import dirname, exists, join
-from unittest.mock import patch
-
-import numpy as np
-import pytest
-import torch
-import torch.nn as nn
-from mmengine.model.utils import revert_sync_batchnorm
-from mmengine.registry import init_default_scope
-from mmengine.structures import PixelData
-from mmengine.utils import is_list_of, is_tuple_of
-from torch import Tensor
-
-from mmseg.structures import SegDataSample
-
-init_default_scope('mmseg')
-
-
-def _demo_mm_inputs(batch_size=2, image_shapes=(3, 32, 32), num_classes=5):
-    """Create a superset of inputs needed to run test or train batches.
-
-    Args:
-        batch_size (int): batch size. Default to 2.
-        image_shapes (List[tuple], Optional): image shape.
-            Default to (3, 128, 128)
-        num_classes (int): number of different labels a
-            box might have. Default to 10.
-    """
-    if isinstance(image_shapes, list):
-        assert len(image_shapes) == batch_size
-    else:
-        image_shapes = [image_shapes] * batch_size
-
-    inputs = []
-    data_samples = []
-    for idx in range(batch_size):
-        image_shape = image_shapes[idx]
-        c, h, w = image_shape
-        image = np.random.randint(0, 255, size=image_shape, dtype=np.uint8)
-
-        mm_input = torch.from_numpy(image)
-
-        img_meta = {
-            'img_id': idx,
-            'img_shape': image_shape[1:],
-            'ori_shape': image_shape[1:],
-            'pad_shape': image_shape[1:],
-            'filename': '<demo>.png',
-            'scale_factor': 1.0,
-            'flip': False,
-            'flip_direction': None,
-        }
-
-        data_sample = SegDataSample()
-        data_sample.set_metainfo(img_meta)
-
-        gt_semantic_seg = np.random.randint(
-            0, num_classes, (1, h, w), dtype=np.uint8)
-        gt_semantic_seg = torch.LongTensor(gt_semantic_seg)
-        gt_sem_seg_data = dict(data=gt_semantic_seg)
-        data_sample.gt_sem_seg = PixelData(**gt_sem_seg_data)
-        inputs.append(mm_input)
-        data_samples.append(data_sample)
-    return dict(inputs=inputs, data_samples=data_samples)
-
-
-def _get_config_directory():
-    """Find the predefined segmentor config directory."""
-    try:
-        # Assume we are running in the source mmsegmentation repo
-        repo_dpath = dirname(dirname(dirname(__file__)))
-    except NameError:
-        # For IPython development when this __file__ is not defined
-        import mmseg
-        repo_dpath = dirname(dirname(dirname(mmseg.__file__)))
-    config_dpath = join(repo_dpath, 'configs')
-    if not exists(config_dpath):
-        raise Exception('Cannot find config path')
-    return config_dpath
-
-
-def _get_config_module(fname):
-    """Load a configuration as a python module."""
-    from mmengine import Config
-    config_dpath = _get_config_directory()
-    config_fpath = join(config_dpath, fname)
-    config_mod = Config.fromfile(config_fpath)
-    return config_mod
-
-
-def _get_segmentor_cfg(fname):
-    """Grab configs necessary to create a segmentor.
-
-    These are deep copied to allow for safe modification of parameters without
-    influencing other tests.
-    """
-    config = _get_config_module(fname)
-    model = copy.deepcopy(config.model)
-    return model
-
-
-def test_pspnet_forward():
-    _test_encoder_decoder_forward(
-        'pspnet/pspnet_r18-d8_4xb2-80k_cityscapes-512x1024.py')
-
-
-def test_fcn_forward():
-    _test_encoder_decoder_forward(
-        'fcn/fcn_r18-d8_4xb2-80k_cityscapes-512x1024.py')
-
-
-def test_deeplabv3_forward():
-    _test_encoder_decoder_forward(
-        'deeplabv3/deeplabv3_r18-d8_4xb2-80k_cityscapes-512x1024.py')
-
-
-def test_deeplabv3plus_forward():
-    _test_encoder_decoder_forward(
-        'deeplabv3plus/deeplabv3plus_r18-d8_4xb2-80k_cityscapes-512x1024.py')
-
-
-def test_gcnet_forward():
-    _test_encoder_decoder_forward(
-        'gcnet/gcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py')
-
-
-def test_ccnet_forward():
-    if not torch.cuda.is_available():
-        pytest.skip('CCNet requires CUDA')
-    _test_encoder_decoder_forward(
-        'ccnet/ccnet_r50-d8_4xb2-40k_cityscapes-512x1024.py')
-
-
-def test_upernet_forward():
-    _test_encoder_decoder_forward(
-        'upernet/upernet_r50_4xb2-40k_cityscapes-512x1024.py')
-
-
-def test_hrnet_forward():
-    _test_encoder_decoder_forward(
-        'hrnet/fcn_hr18s_4xb2-40k_cityscapes-512x1024.py')
-
-
-def test_ocrnet_forward():
-    _test_encoder_decoder_forward(
-        'ocrnet/ocrnet_hr18s_4xb2-40k_cityscapes-512x1024.py')
-
-
-def test_sem_fpn_forward():
-    _test_encoder_decoder_forward(
-        'sem_fpn/fpn_r50_4xb2-80k_cityscapes-512x1024.py')
-
-
-def test_mobilenet_v2_forward():
-    _test_encoder_decoder_forward(
-        'mobilenet_v2/mobilenet-v2-d8_pspnet_4xb2-80k_cityscapes-512x1024.py')
-
-
-def get_world_size(process_group):
-
-    return 1
-
-
-def _check_input_dim(self, inputs):
-    pass
-
-
-@patch('torch.nn.modules.batchnorm._BatchNorm._check_input_dim',
-       _check_input_dim)
-@patch('torch.distributed.get_world_size', get_world_size)
-def _test_encoder_decoder_forward(cfg_file):
-    model = _get_segmentor_cfg(cfg_file)
-    model['pretrained'] = None
-    model['test_cfg']['mode'] = 'whole'
-
-    from mmseg.models import build_segmentor
-    segmentor = build_segmentor(model)
-    segmentor.init_weights()
-
-    if isinstance(segmentor.decode_head, nn.ModuleList):
-        num_classes = segmentor.decode_head[-1].num_classes
-    else:
-        num_classes = segmentor.decode_head.num_classes
-    # batch_size=2 for BatchNorm
-    packed_inputs = _demo_mm_inputs(
-        batch_size=2, image_shapes=(3, 4, 4), num_classes=num_classes)
-    # convert to cuda Tensor if applicable
-    if torch.cuda.is_available():
-        segmentor = segmentor.cuda()
-    else:
-        segmentor = revert_sync_batchnorm(segmentor)
-
-    # Test forward train
-    data = segmentor.data_preprocessor(packed_inputs, True)
-    losses = segmentor.forward(**data, mode='loss')
-    assert isinstance(losses, dict)
-
-    packed_inputs = _demo_mm_inputs(
-        batch_size=1, image_shapes=(3, 32, 32), num_classes=num_classes)
-    data = segmentor.data_preprocessor(packed_inputs, False)
-    with torch.no_grad():
-        segmentor.eval()
-        # Test forward predict
-        batch_results = segmentor.forward(**data, mode='predict')
-        assert len(batch_results) == 1
-        assert is_list_of(batch_results, SegDataSample)
-        assert batch_results[0].pred_sem_seg.shape == (32, 32)
-        assert batch_results[0].seg_logits.data.shape == (num_classes, 32, 32)
-        assert batch_results[0].gt_sem_seg.shape == (32, 32)
-
-        # Test forward tensor
-        batch_results = segmentor.forward(**data, mode='tensor')
-        assert isinstance(batch_results, Tensor) or is_tuple_of(
-            batch_results, Tensor)
-
-        # Test forward predict without ground truth
-        data.pop('data_samples')
-        batch_results = segmentor.forward(**data, mode='predict')
-        assert len(batch_results) == 1
-        assert is_list_of(batch_results, SegDataSample)
-        assert batch_results[0].pred_sem_seg.shape == (32, 32)
-
-        # Test forward tensor without ground truth
-        batch_results = segmentor.forward(**data, mode='tensor')
-        assert isinstance(batch_results, Tensor) or is_tuple_of(
-            batch_results, Tensor)
diff --git a/mmsegmentation/tests/test_models/test_heads/__init__.py b/mmsegmentation/tests/test_models/test_heads/__init__.py
deleted file mode 100644
index ef101fe..0000000
--- a/mmsegmentation/tests/test_models/test_heads/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
diff --git a/mmsegmentation/tests/test_models/test_heads/test_ann_head.py b/mmsegmentation/tests/test_models/test_heads/test_ann_head.py
deleted file mode 100644
index c1e44bc..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_ann_head.py
+++ /dev/null
@@ -1,20 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-
-from mmseg.models.decode_heads import ANNHead
-from .utils import to_cuda
-
-
-def test_ann_head():
-
-    inputs = [torch.randn(1, 4, 45, 45), torch.randn(1, 8, 21, 21)]
-    head = ANNHead(
-        in_channels=[4, 8],
-        channels=2,
-        num_classes=19,
-        in_index=[-2, -1],
-        project_channels=8)
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 21, 21)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_apc_head.py b/mmsegmentation/tests/test_models/test_heads/test_apc_head.py
deleted file mode 100644
index dc55ccc..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_apc_head.py
+++ /dev/null
@@ -1,59 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.decode_heads import APCHead
-from .utils import _conv_has_norm, to_cuda
-
-
-def test_apc_head():
-
-    with pytest.raises(AssertionError):
-        # pool_scales must be list|tuple
-        APCHead(in_channels=8, channels=2, num_classes=19, pool_scales=1)
-
-    # test no norm_cfg
-    head = APCHead(in_channels=8, channels=2, num_classes=19)
-    assert not _conv_has_norm(head, sync_bn=False)
-
-    # test with norm_cfg
-    head = APCHead(
-        in_channels=8,
-        channels=2,
-        num_classes=19,
-        norm_cfg=dict(type='SyncBN'))
-    assert _conv_has_norm(head, sync_bn=True)
-
-    # fusion=True
-    inputs = [torch.randn(1, 8, 45, 45)]
-    head = APCHead(
-        in_channels=8,
-        channels=2,
-        num_classes=19,
-        pool_scales=(1, 2, 3),
-        fusion=True)
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    assert head.fusion is True
-    assert head.acm_modules[0].pool_scale == 1
-    assert head.acm_modules[1].pool_scale == 2
-    assert head.acm_modules[2].pool_scale == 3
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 45, 45)
-
-    # fusion=False
-    inputs = [torch.randn(1, 8, 45, 45)]
-    head = APCHead(
-        in_channels=8,
-        channels=2,
-        num_classes=19,
-        pool_scales=(1, 2, 3),
-        fusion=False)
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    assert head.fusion is False
-    assert head.acm_modules[0].pool_scale == 1
-    assert head.acm_modules[1].pool_scale == 2
-    assert head.acm_modules[2].pool_scale == 3
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 45, 45)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_aspp_head.py b/mmsegmentation/tests/test_models/test_heads/test_aspp_head.py
deleted file mode 100644
index db9e893..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_aspp_head.py
+++ /dev/null
@@ -1,76 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.decode_heads import ASPPHead, DepthwiseSeparableASPPHead
-from .utils import _conv_has_norm, to_cuda
-
-
-def test_aspp_head():
-
-    with pytest.raises(AssertionError):
-        # pool_scales must be list|tuple
-        ASPPHead(in_channels=8, channels=4, num_classes=19, dilations=1)
-
-    # test no norm_cfg
-    head = ASPPHead(in_channels=8, channels=4, num_classes=19)
-    assert not _conv_has_norm(head, sync_bn=False)
-
-    # test with norm_cfg
-    head = ASPPHead(
-        in_channels=8,
-        channels=4,
-        num_classes=19,
-        norm_cfg=dict(type='SyncBN'))
-    assert _conv_has_norm(head, sync_bn=True)
-
-    inputs = [torch.randn(1, 8, 45, 45)]
-    head = ASPPHead(
-        in_channels=8, channels=4, num_classes=19, dilations=(1, 12, 24))
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    assert head.aspp_modules[0].conv.dilation == (1, 1)
-    assert head.aspp_modules[1].conv.dilation == (12, 12)
-    assert head.aspp_modules[2].conv.dilation == (24, 24)
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 45, 45)
-
-
-def test_dw_aspp_head():
-
-    # test w.o. c1
-    inputs = [torch.randn(1, 8, 45, 45)]
-    head = DepthwiseSeparableASPPHead(
-        c1_in_channels=0,
-        c1_channels=0,
-        in_channels=8,
-        channels=4,
-        num_classes=19,
-        dilations=(1, 12, 24))
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    assert head.c1_bottleneck is None
-    assert head.aspp_modules[0].conv.dilation == (1, 1)
-    assert head.aspp_modules[1].depthwise_conv.dilation == (12, 12)
-    assert head.aspp_modules[2].depthwise_conv.dilation == (24, 24)
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 45, 45)
-
-    # test with c1
-    inputs = [torch.randn(1, 4, 45, 45), torch.randn(1, 16, 21, 21)]
-    head = DepthwiseSeparableASPPHead(
-        c1_in_channels=4,
-        c1_channels=2,
-        in_channels=16,
-        channels=8,
-        num_classes=19,
-        dilations=(1, 12, 24))
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    assert head.c1_bottleneck.in_channels == 4
-    assert head.c1_bottleneck.out_channels == 2
-    assert head.aspp_modules[0].conv.dilation == (1, 1)
-    assert head.aspp_modules[1].depthwise_conv.dilation == (12, 12)
-    assert head.aspp_modules[2].depthwise_conv.dilation == (24, 24)
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 45, 45)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_cc_head.py b/mmsegmentation/tests/test_models/test_heads/test_cc_head.py
deleted file mode 100644
index 0630417..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_cc_head.py
+++ /dev/null
@@ -1,18 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.decode_heads import CCHead
-from .utils import to_cuda
-
-
-def test_cc_head():
-    head = CCHead(in_channels=16, channels=8, num_classes=19)
-    assert len(head.convs) == 2
-    assert hasattr(head, 'cca')
-    if not torch.cuda.is_available():
-        pytest.skip('CCHead requires CUDA')
-    inputs = [torch.randn(1, 16, 23, 23)]
-    head, inputs = to_cuda(head, inputs)
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 23, 23)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_decode_head.py b/mmsegmentation/tests/test_models/test_heads/test_decode_head.py
deleted file mode 100644
index 88e6bed..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_decode_head.py
+++ /dev/null
@@ -1,193 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from unittest.mock import patch
-
-import pytest
-import torch
-from mmengine.structures import PixelData
-
-from mmseg.models.decode_heads.decode_head import BaseDecodeHead
-from mmseg.structures import SegDataSample
-from .utils import to_cuda
-
-
-@patch.multiple(BaseDecodeHead, __abstractmethods__=set())
-def test_decode_head():
-
-    with pytest.raises(AssertionError):
-        # default input_transform doesn't accept multiple inputs
-        BaseDecodeHead([32, 16], 16, num_classes=19)
-
-    with pytest.raises(AssertionError):
-        # default input_transform doesn't accept multiple inputs
-        BaseDecodeHead(32, 16, num_classes=19, in_index=[-1, -2])
-
-    with pytest.raises(AssertionError):
-        # supported mode is resize_concat only
-        BaseDecodeHead(32, 16, num_classes=19, input_transform='concat')
-
-    with pytest.raises(AssertionError):
-        # in_channels should be list|tuple
-        BaseDecodeHead(32, 16, num_classes=19, input_transform='resize_concat')
-
-    with pytest.raises(AssertionError):
-        # in_index should be list|tuple
-        BaseDecodeHead([32],
-                       16,
-                       in_index=-1,
-                       num_classes=19,
-                       input_transform='resize_concat')
-
-    with pytest.raises(AssertionError):
-        # len(in_index) should equal len(in_channels)
-        BaseDecodeHead([32, 16],
-                       16,
-                       num_classes=19,
-                       in_index=[-1],
-                       input_transform='resize_concat')
-
-    with pytest.raises(ValueError):
-        # out_channels should be equal to num_classes
-        BaseDecodeHead(32, 16, num_classes=19, out_channels=18)
-
-    # test out_channels
-    head = BaseDecodeHead(32, 16, num_classes=2)
-    assert head.out_channels == 2
-
-    # test out_channels == 1 and num_classes == 2
-    head = BaseDecodeHead(32, 16, num_classes=2, out_channels=1)
-    assert head.out_channels == 1 and head.num_classes == 2
-
-    # test default dropout
-    head = BaseDecodeHead(32, 16, num_classes=19)
-    assert hasattr(head, 'dropout') and head.dropout.p == 0.1
-
-    # test set dropout
-    head = BaseDecodeHead(32, 16, num_classes=19, dropout_ratio=0.2)
-    assert hasattr(head, 'dropout') and head.dropout.p == 0.2
-
-    # test no input_transform
-    inputs = [torch.randn(1, 32, 45, 45)]
-    head = BaseDecodeHead(32, 16, num_classes=19)
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    assert head.in_channels == 32
-    assert head.input_transform is None
-    transformed_inputs = head._transform_inputs(inputs)
-    assert transformed_inputs.shape == (1, 32, 45, 45)
-
-    # test input_transform = resize_concat
-    inputs = [torch.randn(1, 32, 45, 45), torch.randn(1, 16, 21, 21)]
-    head = BaseDecodeHead([32, 16],
-                          16,
-                          num_classes=19,
-                          in_index=[0, 1],
-                          input_transform='resize_concat')
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    assert head.in_channels == 48
-    assert head.input_transform == 'resize_concat'
-    transformed_inputs = head._transform_inputs(inputs)
-    assert transformed_inputs.shape == (1, 48, 45, 45)
-
-    # test multi-loss, loss_decode is dict
-    with pytest.raises(TypeError):
-        # loss_decode must be a dict or sequence of dict.
-        BaseDecodeHead(3, 16, num_classes=19, loss_decode=['CrossEntropyLoss'])
-
-    inputs = torch.randn(2, 19, 8, 8).float()
-    data_samples = [
-        SegDataSample(gt_sem_seg=PixelData(data=torch.ones(64, 64).long()))
-        for _ in range(2)
-    ]
-
-    head = BaseDecodeHead(
-        3,
-        16,
-        num_classes=19,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    loss = head.loss_by_feat(
-        seg_logits=inputs, batch_data_samples=data_samples)
-    assert 'loss_ce' in loss
-
-    # test multi-loss, loss_decode is list of dict
-    inputs = torch.randn(2, 19, 8, 8).float()
-    data_samples = [
-        SegDataSample(gt_sem_seg=PixelData(data=torch.ones(64, 64).long()))
-        for _ in range(2)
-    ]
-    head = BaseDecodeHead(
-        3,
-        16,
-        num_classes=19,
-        loss_decode=[
-            dict(type='CrossEntropyLoss', loss_name='loss_1'),
-            dict(type='CrossEntropyLoss', loss_name='loss_2')
-        ])
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-
-    loss = head.loss_by_feat(
-        seg_logits=inputs, batch_data_samples=data_samples)
-    assert 'loss_1' in loss
-    assert 'loss_2' in loss
-
-    # 'loss_decode' must be a dict or sequence of dict
-    with pytest.raises(TypeError):
-        BaseDecodeHead(3, 16, num_classes=19, loss_decode=['CrossEntropyLoss'])
-    with pytest.raises(TypeError):
-        BaseDecodeHead(3, 16, num_classes=19, loss_decode=0)
-
-    # test multi-loss, loss_decode is list of dict
-    inputs = torch.randn(2, 19, 8, 8).float()
-    data_samples = [
-        SegDataSample(gt_sem_seg=PixelData(data=torch.ones(64, 64).long()))
-        for _ in range(2)
-    ]
-    head = BaseDecodeHead(
-        3,
-        16,
-        num_classes=19,
-        loss_decode=(dict(type='CrossEntropyLoss', loss_name='loss_1'),
-                     dict(type='CrossEntropyLoss', loss_name='loss_2'),
-                     dict(type='CrossEntropyLoss', loss_name='loss_3')))
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    loss = head.loss_by_feat(
-        seg_logits=inputs, batch_data_samples=data_samples)
-    assert 'loss_1' in loss
-    assert 'loss_2' in loss
-    assert 'loss_3' in loss
-
-    # test multi-loss, loss_decode is list of dict, names of them are identical
-    inputs = torch.randn(2, 19, 8, 8).float()
-    data_samples = [
-        SegDataSample(gt_sem_seg=PixelData(data=torch.ones(64, 64).long()))
-        for _ in range(2)
-    ]
-    head = BaseDecodeHead(
-        3,
-        16,
-        num_classes=19,
-        loss_decode=(dict(type='CrossEntropyLoss', loss_name='loss_ce'),
-                     dict(type='CrossEntropyLoss', loss_name='loss_ce'),
-                     dict(type='CrossEntropyLoss', loss_name='loss_ce')))
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    loss_3 = head.loss_by_feat(
-        seg_logits=inputs, batch_data_samples=data_samples)
-
-    head = BaseDecodeHead(
-        3,
-        16,
-        num_classes=19,
-        loss_decode=(dict(type='CrossEntropyLoss', loss_name='loss_ce')))
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    loss = head.loss_by_feat(
-        seg_logits=inputs, batch_data_samples=data_samples)
-    assert 'loss_ce' in loss
-    assert 'loss_ce' in loss_3
-    assert loss_3['loss_ce'] == 3 * loss['loss_ce']
diff --git a/mmsegmentation/tests/test_models/test_heads/test_dm_head.py b/mmsegmentation/tests/test_models/test_heads/test_dm_head.py
deleted file mode 100644
index a922ff7..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_dm_head.py
+++ /dev/null
@@ -1,59 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.decode_heads import DMHead
-from .utils import _conv_has_norm, to_cuda
-
-
-def test_dm_head():
-
-    with pytest.raises(AssertionError):
-        # filter_sizes must be list|tuple
-        DMHead(in_channels=8, channels=4, num_classes=19, filter_sizes=1)
-
-    # test no norm_cfg
-    head = DMHead(in_channels=8, channels=4, num_classes=19)
-    assert not _conv_has_norm(head, sync_bn=False)
-
-    # test with norm_cfg
-    head = DMHead(
-        in_channels=8,
-        channels=4,
-        num_classes=19,
-        norm_cfg=dict(type='SyncBN'))
-    assert _conv_has_norm(head, sync_bn=True)
-
-    # fusion=True
-    inputs = [torch.randn(1, 8, 23, 23)]
-    head = DMHead(
-        in_channels=8,
-        channels=4,
-        num_classes=19,
-        filter_sizes=(1, 3, 5),
-        fusion=True)
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    assert head.fusion is True
-    assert head.dcm_modules[0].filter_size == 1
-    assert head.dcm_modules[1].filter_size == 3
-    assert head.dcm_modules[2].filter_size == 5
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 23, 23)
-
-    # fusion=False
-    inputs = [torch.randn(1, 8, 23, 23)]
-    head = DMHead(
-        in_channels=8,
-        channels=4,
-        num_classes=19,
-        filter_sizes=(1, 3, 5),
-        fusion=False)
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    assert head.fusion is False
-    assert head.dcm_modules[0].filter_size == 1
-    assert head.dcm_modules[1].filter_size == 3
-    assert head.dcm_modules[2].filter_size == 5
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 23, 23)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_dnl_head.py b/mmsegmentation/tests/test_models/test_heads/test_dnl_head.py
deleted file mode 100644
index 720cb07..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_dnl_head.py
+++ /dev/null
@@ -1,44 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-
-from mmseg.models.decode_heads import DNLHead
-from .utils import to_cuda
-
-
-def test_dnl_head():
-    # DNL with 'embedded_gaussian' mode
-    head = DNLHead(in_channels=8, channels=4, num_classes=19)
-    assert len(head.convs) == 2
-    assert hasattr(head, 'dnl_block')
-    assert head.dnl_block.temperature == 0.05
-    inputs = [torch.randn(1, 8, 23, 23)]
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 23, 23)
-
-    # NonLocal2d with 'dot_product' mode
-    head = DNLHead(
-        in_channels=8, channels=4, num_classes=19, mode='dot_product')
-    inputs = [torch.randn(1, 8, 23, 23)]
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 23, 23)
-
-    # NonLocal2d with 'gaussian' mode
-    head = DNLHead(in_channels=8, channels=4, num_classes=19, mode='gaussian')
-    inputs = [torch.randn(1, 8, 23, 23)]
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 23, 23)
-
-    # NonLocal2d with 'concatenation' mode
-    head = DNLHead(
-        in_channels=8, channels=4, num_classes=19, mode='concatenation')
-    inputs = [torch.randn(1, 8, 23, 23)]
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 23, 23)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_dpt_head.py b/mmsegmentation/tests/test_models/test_heads/test_dpt_head.py
deleted file mode 100644
index 0a6af61..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_dpt_head.py
+++ /dev/null
@@ -1,49 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.decode_heads import DPTHead
-
-
-def test_dpt_head():
-
-    with pytest.raises(AssertionError):
-        # input_transform must be 'multiple_select'
-        head = DPTHead(
-            in_channels=[768, 768, 768, 768],
-            channels=4,
-            num_classes=19,
-            in_index=[0, 1, 2, 3])
-
-    head = DPTHead(
-        in_channels=[768, 768, 768, 768],
-        channels=4,
-        num_classes=19,
-        in_index=[0, 1, 2, 3],
-        input_transform='multiple_select')
-
-    inputs = [[torch.randn(4, 768, 2, 2),
-               torch.randn(4, 768)] for _ in range(4)]
-    output = head(inputs)
-    assert output.shape == torch.Size((4, 19, 16, 16))
-
-    # test readout operation
-    head = DPTHead(
-        in_channels=[768, 768, 768, 768],
-        channels=4,
-        num_classes=19,
-        in_index=[0, 1, 2, 3],
-        input_transform='multiple_select',
-        readout_type='add')
-    output = head(inputs)
-    assert output.shape == torch.Size((4, 19, 16, 16))
-
-    head = DPTHead(
-        in_channels=[768, 768, 768, 768],
-        channels=4,
-        num_classes=19,
-        in_index=[0, 1, 2, 3],
-        input_transform='multiple_select',
-        readout_type='project')
-    output = head(inputs)
-    assert output.shape == torch.Size((4, 19, 16, 16))
diff --git a/mmsegmentation/tests/test_models/test_heads/test_ema_head.py b/mmsegmentation/tests/test_models/test_heads/test_ema_head.py
deleted file mode 100644
index 1811cd2..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_ema_head.py
+++ /dev/null
@@ -1,23 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-
-from mmseg.models.decode_heads import EMAHead
-from .utils import to_cuda
-
-
-def test_emanet_head():
-    head = EMAHead(
-        in_channels=4,
-        ema_channels=3,
-        channels=2,
-        num_stages=3,
-        num_bases=2,
-        num_classes=19)
-    for param in head.ema_mid_conv.parameters():
-        assert not param.requires_grad
-    assert hasattr(head, 'ema_module')
-    inputs = [torch.randn(1, 4, 23, 23)]
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 23, 23)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_fcn_head.py b/mmsegmentation/tests/test_models/test_heads/test_fcn_head.py
deleted file mode 100644
index 664b543..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_fcn_head.py
+++ /dev/null
@@ -1,131 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-from mmcv.cnn import ConvModule, DepthwiseSeparableConvModule
-from mmengine.utils.dl_utils.parrots_wrapper import SyncBatchNorm
-
-from mmseg.models.decode_heads import DepthwiseSeparableFCNHead, FCNHead
-from .utils import to_cuda
-
-
-def test_fcn_head():
-
-    with pytest.raises(AssertionError):
-        # num_convs must be not less than 0
-        FCNHead(num_classes=19, num_convs=-1)
-
-    # test no norm_cfg
-    head = FCNHead(in_channels=8, channels=4, num_classes=19)
-    for m in head.modules():
-        if isinstance(m, ConvModule):
-            assert not m.with_norm
-
-    # test with norm_cfg
-    head = FCNHead(
-        in_channels=8,
-        channels=4,
-        num_classes=19,
-        norm_cfg=dict(type='SyncBN'))
-    for m in head.modules():
-        if isinstance(m, ConvModule):
-            assert m.with_norm and isinstance(m.bn, SyncBatchNorm)
-
-    # test concat_input=False
-    inputs = [torch.randn(1, 8, 23, 23)]
-    head = FCNHead(
-        in_channels=8, channels=4, num_classes=19, concat_input=False)
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    assert len(head.convs) == 2
-    assert not head.concat_input and not hasattr(head, 'conv_cat')
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 23, 23)
-
-    # test concat_input=True
-    inputs = [torch.randn(1, 8, 23, 23)]
-    head = FCNHead(
-        in_channels=8, channels=4, num_classes=19, concat_input=True)
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    assert len(head.convs) == 2
-    assert head.concat_input
-    assert head.conv_cat.in_channels == 12
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 23, 23)
-
-    # test kernel_size=3
-    inputs = [torch.randn(1, 8, 23, 23)]
-    head = FCNHead(in_channels=8, channels=4, num_classes=19)
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    for i in range(len(head.convs)):
-        assert head.convs[i].kernel_size == (3, 3)
-        assert head.convs[i].padding == 1
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 23, 23)
-
-    # test kernel_size=1
-    inputs = [torch.randn(1, 8, 23, 23)]
-    head = FCNHead(in_channels=8, channels=4, num_classes=19, kernel_size=1)
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    for i in range(len(head.convs)):
-        assert head.convs[i].kernel_size == (1, 1)
-        assert head.convs[i].padding == 0
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 23, 23)
-
-    # test num_conv
-    inputs = [torch.randn(1, 8, 23, 23)]
-    head = FCNHead(in_channels=8, channels=4, num_classes=19, num_convs=1)
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    assert len(head.convs) == 1
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 23, 23)
-
-    # test num_conv = 0
-    inputs = [torch.randn(1, 8, 23, 23)]
-    head = FCNHead(
-        in_channels=8,
-        channels=8,
-        num_classes=19,
-        num_convs=0,
-        concat_input=False)
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    assert isinstance(head.convs, torch.nn.Identity)
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 23, 23)
-
-
-def test_sep_fcn_head():
-    # test sep_fcn_head with concat_input=False
-    head = DepthwiseSeparableFCNHead(
-        in_channels=128,
-        channels=128,
-        concat_input=False,
-        num_classes=19,
-        in_index=-1,
-        norm_cfg=dict(type='BN', requires_grad=True, momentum=0.01))
-    x = [torch.rand(2, 128, 8, 8)]
-    output = head(x)
-    assert output.shape == (2, head.num_classes, 8, 8)
-    assert not head.concat_input
-    assert isinstance(head.convs[0], DepthwiseSeparableConvModule)
-    assert isinstance(head.convs[1], DepthwiseSeparableConvModule)
-    assert head.conv_seg.kernel_size == (1, 1)
-
-    head = DepthwiseSeparableFCNHead(
-        in_channels=64,
-        channels=64,
-        concat_input=True,
-        num_classes=19,
-        in_index=-1,
-        norm_cfg=dict(type='BN', requires_grad=True, momentum=0.01))
-    x = [torch.rand(3, 64, 8, 8)]
-    output = head(x)
-    assert output.shape == (3, head.num_classes, 8, 8)
-    assert head.concat_input
-    assert isinstance(head.convs[0], DepthwiseSeparableConvModule)
-    assert isinstance(head.convs[1], DepthwiseSeparableConvModule)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_gc_head.py b/mmsegmentation/tests/test_models/test_heads/test_gc_head.py
deleted file mode 100644
index c62ac9a..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_gc_head.py
+++ /dev/null
@@ -1,16 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-
-from mmseg.models.decode_heads import GCHead
-from .utils import to_cuda
-
-
-def test_gc_head():
-    head = GCHead(in_channels=4, channels=4, num_classes=19)
-    assert len(head.convs) == 2
-    assert hasattr(head, 'gc_block')
-    inputs = [torch.randn(1, 4, 23, 23)]
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 23, 23)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_ham_head.py b/mmsegmentation/tests/test_models/test_heads/test_ham_head.py
deleted file mode 100644
index f802d2d..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_ham_head.py
+++ /dev/null
@@ -1,44 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-
-from mmseg.models.decode_heads import LightHamHead
-from .utils import _conv_has_norm, to_cuda
-
-ham_norm_cfg = dict(type='GN', num_groups=32, requires_grad=True)
-
-
-def test_ham_head():
-
-    # test without sync_bn
-    head = LightHamHead(
-        in_channels=[16, 32, 64],
-        in_index=[1, 2, 3],
-        channels=64,
-        ham_channels=64,
-        dropout_ratio=0.1,
-        num_classes=19,
-        norm_cfg=ham_norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
-        ham_kwargs=dict(
-            MD_S=1,
-            MD_R=64,
-            train_steps=6,
-            eval_steps=7,
-            inv_t=100,
-            rand_init=True))
-    assert not _conv_has_norm(head, sync_bn=False)
-
-    inputs = [
-        torch.randn(1, 8, 32, 32),
-        torch.randn(1, 16, 16, 16),
-        torch.randn(1, 32, 8, 8),
-        torch.randn(1, 64, 4, 4)
-    ]
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    assert head.in_channels == [16, 32, 64]
-    assert head.hamburger.ham_in.in_channels == 64
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 16, 16)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_isa_head.py b/mmsegmentation/tests/test_models/test_heads/test_isa_head.py
deleted file mode 100644
index b177f6d..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_isa_head.py
+++ /dev/null
@@ -1,20 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-
-from mmseg.models.decode_heads import ISAHead
-from .utils import to_cuda
-
-
-def test_isa_head():
-
-    inputs = [torch.randn(1, 8, 23, 23)]
-    isa_head = ISAHead(
-        in_channels=8,
-        channels=4,
-        num_classes=19,
-        isa_channels=4,
-        down_factor=(8, 8))
-    if torch.cuda.is_available():
-        isa_head, inputs = to_cuda(isa_head, inputs)
-    output = isa_head(inputs)
-    assert output.shape == (1, isa_head.num_classes, 23, 23)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_lraspp_head.py b/mmsegmentation/tests/test_models/test_heads/test_lraspp_head.py
deleted file mode 100644
index a46e6a1..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_lraspp_head.py
+++ /dev/null
@@ -1,68 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.decode_heads import LRASPPHead
-
-
-def test_lraspp_head():
-    with pytest.raises(ValueError):
-        # check invalid input_transform
-        LRASPPHead(
-            in_channels=(4, 4, 123),
-            in_index=(0, 1, 2),
-            channels=32,
-            input_transform='resize_concat',
-            dropout_ratio=0.1,
-            num_classes=19,
-            norm_cfg=dict(type='BN'),
-            act_cfg=dict(type='ReLU'),
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
-
-    with pytest.raises(AssertionError):
-        # check invalid branch_channels
-        LRASPPHead(
-            in_channels=(4, 4, 123),
-            in_index=(0, 1, 2),
-            channels=32,
-            branch_channels=64,
-            input_transform='multiple_select',
-            dropout_ratio=0.1,
-            num_classes=19,
-            norm_cfg=dict(type='BN'),
-            act_cfg=dict(type='ReLU'),
-            align_corners=False,
-            loss_decode=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
-
-    # test with default settings
-    lraspp_head = LRASPPHead(
-        in_channels=(4, 4, 123),
-        in_index=(0, 1, 2),
-        channels=32,
-        input_transform='multiple_select',
-        dropout_ratio=0.1,
-        num_classes=19,
-        norm_cfg=dict(type='BN'),
-        act_cfg=dict(type='ReLU'),
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0))
-    inputs = [
-        torch.randn(2, 4, 45, 45),
-        torch.randn(2, 4, 28, 28),
-        torch.randn(2, 123, 14, 14)
-    ]
-    with pytest.raises(RuntimeError):
-        # check invalid inputs
-        output = lraspp_head(inputs)
-
-    inputs = [
-        torch.randn(2, 4, 111, 111),
-        torch.randn(2, 4, 77, 77),
-        torch.randn(2, 123, 55, 55)
-    ]
-    output = lraspp_head(inputs)
-    assert output.shape == (2, 19, 111, 111)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_mask2former_head.py b/mmsegmentation/tests/test_models/test_heads/test_mask2former_head.py
deleted file mode 100644
index 45b353d..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_mask2former_head.py
+++ /dev/null
@@ -1,153 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-from mmengine import Config
-from mmengine.structures import PixelData
-
-from mmseg.models.decode_heads import Mask2FormerHead
-from mmseg.structures import SegDataSample
-from mmseg.utils import SampleList
-from .utils import to_cuda
-
-
-def test_mask2former_head():
-    num_classes = 19
-    cfg = dict(
-        in_channels=[96, 192, 384, 768],
-        strides=[4, 8, 16, 32],
-        feat_channels=256,
-        out_channels=256,
-        num_classes=num_classes,
-        num_queries=100,
-        num_transformer_feat_level=3,
-        align_corners=False,
-        pixel_decoder=dict(
-            type='mmdet.MSDeformAttnPixelDecoder',
-            num_outs=3,
-            norm_cfg=dict(type='GN', num_groups=32),
-            act_cfg=dict(type='ReLU'),
-            encoder=dict(  # DeformableDetrTransformerEncoder
-                num_layers=6,
-                layer_cfg=dict(  # DeformableDetrTransformerEncoderLayer
-                    self_attn_cfg=dict(  # MultiScaleDeformableAttention
-                        embed_dims=256,
-                        num_heads=8,
-                        num_levels=3,
-                        num_points=4,
-                        im2col_step=64,
-                        dropout=0.0,
-                        batch_first=True,
-                        norm_cfg=None,
-                        init_cfg=None),
-                    ffn_cfg=dict(
-                        embed_dims=256,
-                        feedforward_channels=1024,
-                        num_fcs=2,
-                        ffn_drop=0.0,
-                        act_cfg=dict(type='ReLU', inplace=True))),
-                init_cfg=None),
-            positional_encoding=dict(  # SinePositionalEncoding
-                num_feats=128, normalize=True),
-            init_cfg=None),
-        enforce_decoder_input_project=False,
-        positional_encoding=dict(  # SinePositionalEncoding
-            num_feats=128, normalize=True),
-        transformer_decoder=dict(  # Mask2FormerTransformerDecoder
-            return_intermediate=True,
-            num_layers=9,
-            layer_cfg=dict(  # Mask2FormerTransformerDecoderLayer
-                self_attn_cfg=dict(  # MultiheadAttention
-                    embed_dims=256,
-                    num_heads=8,
-                    attn_drop=0.0,
-                    proj_drop=0.0,
-                    dropout_layer=None,
-                    batch_first=True),
-                cross_attn_cfg=dict(  # MultiheadAttention
-                    embed_dims=256,
-                    num_heads=8,
-                    attn_drop=0.0,
-                    proj_drop=0.0,
-                    dropout_layer=None,
-                    batch_first=True),
-                ffn_cfg=dict(
-                    embed_dims=256,
-                    feedforward_channels=2048,
-                    num_fcs=2,
-                    act_cfg=dict(type='ReLU', inplace=True),
-                    ffn_drop=0.0,
-                    dropout_layer=None,
-                    add_identity=True)),
-            init_cfg=None),
-        loss_cls=dict(
-            type='mmdet.CrossEntropyLoss',
-            use_sigmoid=False,
-            loss_weight=2.0,
-            reduction='mean',
-            class_weight=[1.0] * num_classes + [0.1]),
-        loss_mask=dict(
-            type='mmdet.CrossEntropyLoss',
-            use_sigmoid=True,
-            reduction='mean',
-            loss_weight=5.0),
-        loss_dice=dict(
-            type='mmdet.DiceLoss',
-            use_sigmoid=True,
-            activate=True,
-            reduction='mean',
-            naive_dice=True,
-            eps=1.0,
-            loss_weight=5.0),
-        train_cfg=dict(
-            num_points=12544,
-            oversample_ratio=3.0,
-            importance_sample_ratio=0.75,
-            assigner=dict(
-                type='mmdet.HungarianAssigner',
-                match_costs=[
-                    dict(type='mmdet.ClassificationCost', weight=2.0),
-                    dict(
-                        type='mmdet.CrossEntropyLossCost',
-                        weight=5.0,
-                        use_sigmoid=True),
-                    dict(
-                        type='mmdet.DiceCost',
-                        weight=5.0,
-                        pred_act=True,
-                        eps=1.0)
-                ]),
-            sampler=dict(type='mmdet.MaskPseudoSampler')))
-    cfg = Config(cfg)
-    head = Mask2FormerHead(**cfg)
-
-    inputs = [
-        torch.rand((2, 96, 8, 8)),
-        torch.rand((2, 192, 4, 4)),
-        torch.rand((2, 384, 2, 2)),
-        torch.rand((2, 768, 1, 1))
-    ]
-
-    data_samples: SampleList = []
-    for i in range(2):
-        data_sample = SegDataSample()
-        img_meta = {}
-        img_meta['img_shape'] = (32, 32)
-        img_meta['ori_shape'] = (32, 32)
-        data_sample.gt_sem_seg = PixelData(
-            data=torch.randint(0, num_classes, (1, 32, 32)))
-        data_sample.set_metainfo(img_meta)
-        data_samples.append(data_sample)
-
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-        for data_sample in data_samples:
-            data_sample.gt_sem_seg.data = data_sample.gt_sem_seg.data.cuda()
-
-    loss_dict = head.loss(inputs, data_samples, None)
-    assert isinstance(loss_dict, dict)
-
-    batch_img_metas = []
-    for data_sample in data_samples:
-        batch_img_metas.append(data_sample.metainfo)
-
-    seg_logits = head.predict(inputs, batch_img_metas, None)
-    assert seg_logits.shape == torch.Size((2, num_classes, 32, 32))
diff --git a/mmsegmentation/tests/test_models/test_heads/test_maskformer_head.py b/mmsegmentation/tests/test_models/test_heads/test_maskformer_head.py
deleted file mode 100644
index 6a47239..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_maskformer_head.py
+++ /dev/null
@@ -1,54 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from os.path import dirname, join
-
-import torch
-from mmengine import Config
-from mmengine.registry import init_default_scope
-from mmengine.structures import PixelData
-
-from mmseg.registry import MODELS
-from mmseg.structures import SegDataSample
-
-
-def test_maskformer_head():
-    init_default_scope('mmseg')
-    repo_dpath = dirname(dirname(__file__))
-    cfg = Config.fromfile(
-        join(
-            repo_dpath,
-            '../../configs/maskformer/maskformer_r50-d32_8xb2-160k_ade20k-512x512.py'  # noqa
-        ))
-    cfg.model.train_cfg = None
-    decode_head = MODELS.build(cfg.model.decode_head)
-    inputs = (torch.randn(1, 256, 32, 32), torch.randn(1, 512, 16, 16),
-              torch.randn(1, 1024, 8, 8), torch.randn(1, 2048, 4, 4))
-    # test inference
-    batch_img_metas = [
-        dict(
-            scale_factor=(1.0, 1.0),
-            img_shape=(512, 683),
-            ori_shape=(512, 683))
-    ]
-    test_cfg = dict(mode='whole')
-    output = decode_head.predict(inputs, batch_img_metas, test_cfg)
-    assert output.shape == (1, 150, 512, 683)
-
-    # test training
-    inputs = (torch.randn(2, 256, 32, 32), torch.randn(2, 512, 16, 16),
-              torch.randn(2, 1024, 8, 8), torch.randn(2, 2048, 4, 4))
-    batch_data_samples = []
-    img_meta = {
-        'img_shape': (512, 512),
-        'ori_shape': (480, 640),
-        'pad_shape': (512, 512),
-        'scale_factor': (1.425, 1.425),
-    }
-    for _ in range(2):
-        data_sample = SegDataSample(
-            gt_sem_seg=PixelData(data=torch.ones(512, 512).long()))
-        data_sample.set_metainfo(img_meta)
-        batch_data_samples.append(data_sample)
-    train_cfg = {}
-    losses = decode_head.loss(inputs, batch_data_samples, train_cfg)
-    assert (loss in losses.keys()
-            for loss in ('loss_cls', 'loss_mask', 'loss_dice'))
diff --git a/mmsegmentation/tests/test_models/test_heads/test_nl_head.py b/mmsegmentation/tests/test_models/test_heads/test_nl_head.py
deleted file mode 100644
index d4ef0b9..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_nl_head.py
+++ /dev/null
@@ -1,16 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-
-from mmseg.models.decode_heads import NLHead
-from .utils import to_cuda
-
-
-def test_nl_head():
-    head = NLHead(in_channels=8, channels=4, num_classes=19)
-    assert len(head.convs) == 2
-    assert hasattr(head, 'nl_block')
-    inputs = [torch.randn(1, 8, 23, 23)]
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 23, 23)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_ocr_head.py b/mmsegmentation/tests/test_models/test_heads/test_ocr_head.py
deleted file mode 100644
index 5e5d669..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_ocr_head.py
+++ /dev/null
@@ -1,19 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-
-from mmseg.models.decode_heads import FCNHead, OCRHead
-from .utils import to_cuda
-
-
-def test_ocr_head():
-
-    inputs = [torch.randn(1, 8, 23, 23)]
-    ocr_head = OCRHead(
-        in_channels=8, channels=4, num_classes=19, ocr_channels=8)
-    fcn_head = FCNHead(in_channels=8, channels=4, num_classes=19)
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(ocr_head, inputs)
-        head, inputs = to_cuda(fcn_head, inputs)
-    prev_output = fcn_head(inputs)
-    output = ocr_head(inputs, prev_output)
-    assert output.shape == (1, ocr_head.num_classes, 23, 23)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_pidnet_head.py b/mmsegmentation/tests/test_models/test_heads/test_pidnet_head.py
deleted file mode 100644
index a624737..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_pidnet_head.py
+++ /dev/null
@@ -1,89 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-from mmengine.registry import init_default_scope
-
-from mmseg.registry import MODELS
-
-
-def test_pidnet_head():
-    init_default_scope('mmseg')
-
-    # Test PIDNet decode head Standard Forward
-    norm_cfg = dict(type='BN', requires_grad=True)
-    backbone_cfg = dict(
-        type='PIDNet',
-        in_channels=3,
-        channels=32,
-        ppm_channels=96,
-        num_stem_blocks=2,
-        num_branch_blocks=3,
-        align_corners=False,
-        norm_cfg=norm_cfg,
-        act_cfg=dict(type='ReLU', inplace=True))
-    decode_head_cfg = dict(
-        type='PIDHead',
-        in_channels=128,
-        channels=128,
-        num_classes=19,
-        norm_cfg=norm_cfg,
-        act_cfg=dict(type='ReLU', inplace=True),
-        align_corners=True,
-        loss_decode=[
-            dict(
-                type='CrossEntropyLoss',
-                use_sigmoid=False,
-                class_weight=[
-                    0.8373, 0.918, 0.866, 1.0345, 1.0166, 0.9969, 0.9754,
-                    1.0489, 0.8786, 1.0023, 0.9539, 0.9843, 1.1116, 0.9037,
-                    1.0865, 1.0955, 1.0865, 1.1529, 1.0507
-                ],
-                loss_weight=0.4),
-            dict(
-                type='OhemCrossEntropy',
-                thres=0.9,
-                min_kept=131072,
-                class_weight=[
-                    0.8373, 0.918, 0.866, 1.0345, 1.0166, 0.9969, 0.9754,
-                    1.0489, 0.8786, 1.0023, 0.9539, 0.9843, 1.1116, 0.9037,
-                    1.0865, 1.0955, 1.0865, 1.1529, 1.0507
-                ],
-                loss_weight=1.0),
-            dict(type='BoundaryLoss', loss_weight=20.0),
-            dict(
-                type='OhemCrossEntropy',
-                thres=0.9,
-                min_kept=131072,
-                class_weight=[
-                    0.8373, 0.918, 0.866, 1.0345, 1.0166, 0.9969, 0.9754,
-                    1.0489, 0.8786, 1.0023, 0.9539, 0.9843, 1.1116, 0.9037,
-                    1.0865, 1.0955, 1.0865, 1.1529, 1.0507
-                ],
-                loss_weight=1.0)
-        ])
-    backbone = MODELS.build(backbone_cfg)
-    head = MODELS.build(decode_head_cfg)
-
-    # Test train mode
-    backbone.train()
-    head.train()
-    batch_size = 2
-    imgs = torch.randn(batch_size, 3, 64, 128)
-    feats = backbone(imgs)
-    seg_logit = head(feats)
-
-    assert isinstance(seg_logit, tuple)
-    assert len(seg_logit) == 3
-
-    p_logits, i_logits, d_logits = seg_logit
-    assert p_logits.shape == (batch_size, 19, 8, 16)
-    assert i_logits.shape == (batch_size, 19, 8, 16)
-    assert d_logits.shape == (batch_size, 1, 8, 16)
-
-    # Test eval mode
-    backbone.eval()
-    head.eval()
-    feats = backbone(imgs)
-    seg_logit = head(feats)
-
-    assert isinstance(seg_logit, torch.Tensor)
-    assert seg_logit.shape == (batch_size, 19, 8, 16)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_psa_head.py b/mmsegmentation/tests/test_models/test_heads/test_psa_head.py
deleted file mode 100644
index 34f592b..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_psa_head.py
+++ /dev/null
@@ -1,122 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.decode_heads import PSAHead
-from .utils import _conv_has_norm, to_cuda
-
-
-def test_psa_head():
-
-    with pytest.raises(AssertionError):
-        # psa_type must be in 'bi-direction', 'collect', 'distribute'
-        PSAHead(
-            in_channels=4,
-            channels=2,
-            num_classes=19,
-            mask_size=(13, 13),
-            psa_type='gather')
-
-    # test no norm_cfg
-    head = PSAHead(
-        in_channels=4, channels=2, num_classes=19, mask_size=(13, 13))
-    assert not _conv_has_norm(head, sync_bn=False)
-
-    # test with norm_cfg
-    head = PSAHead(
-        in_channels=4,
-        channels=2,
-        num_classes=19,
-        mask_size=(13, 13),
-        norm_cfg=dict(type='SyncBN'))
-    assert _conv_has_norm(head, sync_bn=True)
-
-    # test 'bi-direction' psa_type
-    inputs = [torch.randn(1, 4, 13, 13)]
-    head = PSAHead(
-        in_channels=4, channels=2, num_classes=19, mask_size=(13, 13))
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 13, 13)
-
-    # test 'bi-direction' psa_type, shrink_factor=1
-    inputs = [torch.randn(1, 4, 13, 13)]
-    head = PSAHead(
-        in_channels=4,
-        channels=2,
-        num_classes=19,
-        mask_size=(13, 13),
-        shrink_factor=1)
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 13, 13)
-
-    # test 'bi-direction' psa_type with soft_max
-    inputs = [torch.randn(1, 4, 13, 13)]
-    head = PSAHead(
-        in_channels=4,
-        channels=2,
-        num_classes=19,
-        mask_size=(13, 13),
-        psa_softmax=True)
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 13, 13)
-
-    # test 'collect' psa_type
-    inputs = [torch.randn(1, 4, 13, 13)]
-    head = PSAHead(
-        in_channels=4,
-        channels=2,
-        num_classes=19,
-        mask_size=(13, 13),
-        psa_type='collect')
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 13, 13)
-
-    # test 'collect' psa_type, shrink_factor=1
-    inputs = [torch.randn(1, 4, 13, 13)]
-    head = PSAHead(
-        in_channels=4,
-        channels=2,
-        num_classes=19,
-        mask_size=(13, 13),
-        shrink_factor=1,
-        psa_type='collect')
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 13, 13)
-
-    # test 'collect' psa_type, shrink_factor=1, compact=True
-    inputs = [torch.randn(1, 4, 13, 13)]
-    head = PSAHead(
-        in_channels=4,
-        channels=2,
-        num_classes=19,
-        mask_size=(13, 13),
-        psa_type='collect',
-        shrink_factor=1,
-        compact=True)
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 13, 13)
-
-    # test 'distribute' psa_type
-    inputs = [torch.randn(1, 4, 13, 13)]
-    head = PSAHead(
-        in_channels=4,
-        channels=2,
-        num_classes=19,
-        mask_size=(13, 13),
-        psa_type='distribute')
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 13, 13)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_psp_head.py b/mmsegmentation/tests/test_models/test_heads/test_psp_head.py
deleted file mode 100644
index fde4087..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_psp_head.py
+++ /dev/null
@@ -1,36 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.decode_heads import PSPHead
-from .utils import _conv_has_norm, to_cuda
-
-
-def test_psp_head():
-
-    with pytest.raises(AssertionError):
-        # pool_scales must be list|tuple
-        PSPHead(in_channels=4, channels=2, num_classes=19, pool_scales=1)
-
-    # test no norm_cfg
-    head = PSPHead(in_channels=4, channels=2, num_classes=19)
-    assert not _conv_has_norm(head, sync_bn=False)
-
-    # test with norm_cfg
-    head = PSPHead(
-        in_channels=4,
-        channels=2,
-        num_classes=19,
-        norm_cfg=dict(type='SyncBN'))
-    assert _conv_has_norm(head, sync_bn=True)
-
-    inputs = [torch.randn(1, 4, 23, 23)]
-    head = PSPHead(
-        in_channels=4, channels=2, num_classes=19, pool_scales=(1, 2, 3))
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    assert head.psp_modules[0][0].output_size == 1
-    assert head.psp_modules[1][0].output_size == 2
-    assert head.psp_modules[2][0].output_size == 3
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 23, 23)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_san_head.py b/mmsegmentation/tests/test_models/test_heads/test_san_head.py
deleted file mode 100644
index af85a6e..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_san_head.py
+++ /dev/null
@@ -1,126 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-from mmengine import Config
-from mmengine.structures import PixelData
-
-from mmseg.models.decode_heads import SideAdapterCLIPHead
-from mmseg.structures import SegDataSample
-from .utils import list_to_cuda
-
-
-def test_san_head():
-    H, W = (64, 64)
-    clip_channels = 64
-    img_channels = 4
-    num_queries = 40
-    out_dims = 64
-    num_classes = 19
-    cfg = dict(
-        num_classes=num_classes,
-        deep_supervision_idxs=[4],
-        san_cfg=dict(
-            in_channels=img_channels,
-            embed_dims=128,
-            clip_channels=clip_channels,
-            num_queries=num_queries,
-            cfg_encoder=dict(num_encode_layer=4, mlp_ratio=2, num_heads=2),
-            cfg_decoder=dict(
-                num_heads=4,
-                num_layers=1,
-                embed_channels=32,
-                mlp_channels=32,
-                num_mlp=2,
-                rescale=True)),
-        maskgen_cfg=dict(
-            sos_token_num=num_queries,
-            embed_dims=clip_channels,
-            out_dims=out_dims,
-            num_heads=4,
-            mlp_ratio=2),
-        train_cfg=dict(
-            num_points=100,
-            oversample_ratio=3.0,
-            importance_sample_ratio=0.75,
-            assigner=dict(
-                type='HungarianAssigner',
-                match_costs=[
-                    dict(type='ClassificationCost', weight=2.0),
-                    dict(
-                        type='CrossEntropyLossCost',
-                        weight=5.0,
-                        use_sigmoid=True),
-                    dict(type='DiceCost', weight=5.0, pred_act=True, eps=1.0)
-                ])),
-        loss_decode=[
-            dict(
-                type='CrossEntropyLoss',
-                loss_name='loss_cls_ce',
-                loss_weight=2.0,
-                class_weight=[1.0] * num_classes + [0.1]),
-            dict(
-                type='CrossEntropyLoss',
-                use_sigmoid=True,
-                loss_name='loss_mask_ce',
-                loss_weight=5.0),
-            dict(
-                type='DiceLoss',
-                ignore_index=None,
-                naive_dice=True,
-                eps=1,
-                loss_name='loss_mask_dice',
-                loss_weight=5.0)
-        ])
-
-    cfg = Config(cfg)
-    head = SideAdapterCLIPHead(**cfg)
-
-    inputs = torch.rand((2, img_channels, H, W))
-    clip_feature = [[
-        torch.rand((2, clip_channels, H // 2, W // 2)),
-        torch.rand((2, clip_channels))
-    ],
-                    [
-                        torch.rand((2, clip_channels, H // 2, W // 2)),
-                        torch.rand((2, clip_channels))
-                    ],
-                    [
-                        torch.rand((2, clip_channels, H // 2, W // 2)),
-                        torch.rand((2, clip_channels))
-                    ],
-                    [
-                        torch.rand((2, clip_channels, H // 2, W // 2)),
-                        torch.rand((2, clip_channels))
-                    ]]
-    class_embed = torch.rand((num_classes + 1, out_dims))
-
-    data_samples = []
-    for i in range(2):
-        data_sample = SegDataSample()
-        img_meta = {}
-        img_meta['img_shape'] = (H, W)
-        img_meta['ori_shape'] = (H, W)
-        data_sample.gt_sem_seg = PixelData(
-            data=torch.randint(0, num_classes, (1, H, W)))
-        data_sample.set_metainfo(img_meta)
-        data_samples.append(data_sample)
-
-    batch_img_metas = []
-    for data_sample in data_samples:
-        batch_img_metas.append(data_sample.metainfo)
-
-    if torch.cuda.is_available():
-        head = head.cuda()
-        data = list_to_cuda([inputs, clip_feature, class_embed])
-        for data_sample in data_samples:
-            data_sample.gt_sem_seg.data = data_sample.gt_sem_seg.data.cuda()
-    else:
-        data = [inputs, clip_feature, class_embed]
-
-    # loss test
-    loss_dict = head.loss(data, data_samples, None)
-    assert isinstance(loss_dict, dict)
-
-    # prediction test
-    with torch.no_grad():
-        seg_logits = head.predict(data, batch_img_metas, None)
-    assert seg_logits.shape == torch.Size((2, num_classes, H, W))
diff --git a/mmsegmentation/tests/test_models/test_heads/test_segformer_head.py b/mmsegmentation/tests/test_models/test_heads/test_segformer_head.py
deleted file mode 100644
index 73afaba..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_segformer_head.py
+++ /dev/null
@@ -1,40 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.decode_heads import SegformerHead
-
-
-def test_segformer_head():
-    with pytest.raises(AssertionError):
-        # `in_channels` must have same length as `in_index`
-        SegformerHead(
-            in_channels=(1, 2, 3), in_index=(0, 1), channels=5, num_classes=2)
-
-    H, W = (64, 64)
-    in_channels = (32, 64, 160, 256)
-    shapes = [(H // 2**(i + 2), W // 2**(i + 2))
-              for i in range(len(in_channels))]
-    model = SegformerHead(
-        in_channels=in_channels,
-        in_index=[0, 1, 2, 3],
-        channels=256,
-        num_classes=19)
-
-    with pytest.raises(IndexError):
-        # in_index must match the input feature maps.
-        inputs = [
-            torch.randn((1, in_channel, *shape))
-            for in_channel, shape in zip(in_channels, shapes)
-        ][:3]
-        temp = model(inputs)
-
-    # Normal Input
-    # ((1, 32, 16, 16), (1, 64, 8, 8), (1, 160, 4, 4), (1, 256, 2, 2)
-    inputs = [
-        torch.randn((1, in_channel, *shape))
-        for in_channel, shape in zip(in_channels, shapes)
-    ]
-    temp = model(inputs)
-
-    assert temp.shape == (1, 19, H // 4, W // 4)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_segmenter_mask_head.py b/mmsegmentation/tests/test_models/test_heads/test_segmenter_mask_head.py
deleted file mode 100644
index 7b681ac..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_segmenter_mask_head.py
+++ /dev/null
@@ -1,24 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-
-from mmseg.models.decode_heads import SegmenterMaskTransformerHead
-from .utils import _conv_has_norm, to_cuda
-
-
-def test_segmenter_mask_transformer_head():
-    head = SegmenterMaskTransformerHead(
-        in_channels=2,
-        channels=2,
-        num_classes=150,
-        num_layers=2,
-        num_heads=3,
-        embed_dims=192,
-        dropout_ratio=0.0)
-    assert _conv_has_norm(head, sync_bn=True)
-    head.init_weights()
-
-    inputs = [torch.randn(1, 2, 32, 32)]
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 32, 32)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_setr_mla_head.py b/mmsegmentation/tests/test_models/test_heads/test_setr_mla_head.py
deleted file mode 100644
index 301bc0b..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_setr_mla_head.py
+++ /dev/null
@@ -1,63 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.decode_heads import SETRMLAHead
-from .utils import to_cuda
-
-
-def test_setr_mla_head(capsys):
-
-    with pytest.raises(AssertionError):
-        # MLA requires input multiple stage feature information.
-        SETRMLAHead(in_channels=8, channels=4, num_classes=19, in_index=1)
-
-    with pytest.raises(AssertionError):
-        # multiple in_indexs requires multiple in_channels.
-        SETRMLAHead(
-            in_channels=8, channels=4, num_classes=19, in_index=(0, 1, 2, 3))
-
-    with pytest.raises(AssertionError):
-        # channels should be len(in_channels) * mla_channels
-        SETRMLAHead(
-            in_channels=(8, 8, 8, 8),
-            channels=8,
-            mla_channels=4,
-            in_index=(0, 1, 2, 3),
-            num_classes=19)
-
-    # test inference of MLA head
-    img_size = (8, 8)
-    patch_size = 4
-    head = SETRMLAHead(
-        in_channels=(8, 8, 8, 8),
-        channels=16,
-        mla_channels=4,
-        in_index=(0, 1, 2, 3),
-        num_classes=19,
-        norm_cfg=dict(type='BN'))
-
-    h, w = img_size[0] // patch_size, img_size[1] // patch_size
-    # Input square NCHW format feature information
-    x = [
-        torch.randn(1, 8, h, w),
-        torch.randn(1, 8, h, w),
-        torch.randn(1, 8, h, w),
-        torch.randn(1, 8, h, w)
-    ]
-    if torch.cuda.is_available():
-        head, x = to_cuda(head, x)
-    out = head(x)
-    assert out.shape == (1, head.num_classes, h * 4, w * 4)
-
-    # Input non-square NCHW format feature information
-    x = [
-        torch.randn(1, 8, h, w * 2),
-        torch.randn(1, 8, h, w * 2),
-        torch.randn(1, 8, h, w * 2),
-        torch.randn(1, 8, h, w * 2)
-    ]
-    if torch.cuda.is_available():
-        head, x = to_cuda(head, x)
-    out = head(x)
-    assert out.shape == (1, head.num_classes, h * 4, w * 8)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_setr_up_head.py b/mmsegmentation/tests/test_models/test_heads/test_setr_up_head.py
deleted file mode 100644
index a051922..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_setr_up_head.py
+++ /dev/null
@@ -1,56 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.decode_heads import SETRUPHead
-from .utils import to_cuda
-
-
-def test_setr_up_head(capsys):
-
-    with pytest.raises(AssertionError):
-        # kernel_size must be [1/3]
-        SETRUPHead(num_classes=19, kernel_size=2)
-
-    with pytest.raises(AssertionError):
-        # in_channels must be int type and in_channels must be same
-        # as embed_dim.
-        SETRUPHead(in_channels=(4, 4), channels=2, num_classes=19)
-
-    # test init_cfg of head
-    head = SETRUPHead(
-        in_channels=4,
-        channels=2,
-        norm_cfg=dict(type='SyncBN'),
-        num_classes=19,
-        init_cfg=dict(type='Kaiming'))
-    super(SETRUPHead, head).init_weights()
-
-    # test inference of Naive head
-    # the auxiliary head of Naive head is same as Naive head
-    img_size = (4, 4)
-    patch_size = 2
-    head = SETRUPHead(
-        in_channels=4,
-        channels=2,
-        num_classes=19,
-        num_convs=1,
-        up_scale=4,
-        kernel_size=1,
-        norm_cfg=dict(type='BN'))
-
-    h, w = img_size[0] // patch_size, img_size[1] // patch_size
-
-    # Input square NCHW format feature information
-    x = [torch.randn(1, 4, h, w)]
-    if torch.cuda.is_available():
-        head, x = to_cuda(head, x)
-    out = head(x)
-    assert out.shape == (1, head.num_classes, h * 4, w * 4)
-
-    # Input non-square NCHW format feature information
-    x = [torch.randn(1, 4, h, w * 2)]
-    if torch.cuda.is_available():
-        head, x = to_cuda(head, x)
-    out = head(x)
-    assert out.shape == (1, head.num_classes, h * 4, w * 8)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_uper_head.py b/mmsegmentation/tests/test_models/test_heads/test_uper_head.py
deleted file mode 100644
index 09456a8..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_uper_head.py
+++ /dev/null
@@ -1,35 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.decode_heads import UPerHead
-from .utils import _conv_has_norm, to_cuda
-
-
-def test_uper_head():
-
-    with pytest.raises(AssertionError):
-        # fpn_in_channels must be list|tuple
-        UPerHead(in_channels=4, channels=2, num_classes=19)
-
-    # test no norm_cfg
-    head = UPerHead(
-        in_channels=[4, 2], channels=2, num_classes=19, in_index=[-2, -1])
-    assert not _conv_has_norm(head, sync_bn=False)
-
-    # test with norm_cfg
-    head = UPerHead(
-        in_channels=[4, 2],
-        channels=2,
-        num_classes=19,
-        norm_cfg=dict(type='SyncBN'),
-        in_index=[-2, -1])
-    assert _conv_has_norm(head, sync_bn=True)
-
-    inputs = [torch.randn(1, 4, 45, 45), torch.randn(1, 2, 21, 21)]
-    head = UPerHead(
-        in_channels=[4, 2], channels=2, num_classes=19, in_index=[-2, -1])
-    if torch.cuda.is_available():
-        head, inputs = to_cuda(head, inputs)
-    outputs = head(inputs)
-    assert outputs.shape == (1, head.num_classes, 45, 45)
diff --git a/mmsegmentation/tests/test_models/test_heads/test_vpd_depth_head.py b/mmsegmentation/tests/test_models/test_heads/test_vpd_depth_head.py
deleted file mode 100644
index e3a4f75..0000000
--- a/mmsegmentation/tests/test_models/test_heads/test_vpd_depth_head.py
+++ /dev/null
@@ -1,50 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from unittest import TestCase
-
-import torch
-from mmengine.structures import PixelData
-
-from mmseg.models.decode_heads import VPDDepthHead
-from mmseg.structures import SegDataSample
-
-
-class TestVPDDepthHead(TestCase):
-
-    def setUp(self):
-        """Set up common resources."""
-        self.in_channels = [320, 640, 1280, 1280]
-        self.max_depth = 10.0
-        self.loss_decode = dict(
-            type='SiLogLoss'
-        )  # Replace with your actual loss type and parameters
-        self.vpd_depth_head = VPDDepthHead(
-            max_depth=self.max_depth,
-            in_channels=self.in_channels,
-            loss_decode=self.loss_decode)
-
-    def test_forward(self):
-        """Test the forward method."""
-        # Create a mock input tensor. Replace shape as per your needs.
-        x = [
-            torch.randn(1, 320, 32, 32),
-            torch.randn(1, 640, 16, 16),
-            torch.randn(1, 1280, 8, 8),
-            torch.randn(1, 1280, 4, 4)
-        ]
-
-        output = self.vpd_depth_head.forward(x)
-        print(output.shape)
-
-        self.assertEqual(output.shape, (1, 1, 256, 256))
-
-    def test_loss_by_feat(self):
-        """Test the loss_by_feat method."""
-        # Create mock data for `pred_depth_map` and `batch_data_samples`.
-        pred_depth_map = torch.randn(1, 1, 32, 32)
-        gt_depth_map = PixelData(data=torch.rand(1, 32, 32))
-        batch_data_samples = [SegDataSample(gt_depth_map=gt_depth_map)]
-
-        loss = self.vpd_depth_head.loss_by_feat(pred_depth_map,
-                                                batch_data_samples)
-
-        self.assertIsNotNone(loss)
diff --git a/mmsegmentation/tests/test_models/test_heads/utils.py b/mmsegmentation/tests/test_models/test_heads/utils.py
deleted file mode 100644
index 7282340..0000000
--- a/mmsegmentation/tests/test_models/test_heads/utils.py
+++ /dev/null
@@ -1,31 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmcv.cnn import ConvModule
-from mmengine.utils.dl_utils.parrots_wrapper import SyncBatchNorm
-
-
-def _conv_has_norm(module, sync_bn):
-    for m in module.modules():
-        if isinstance(m, ConvModule):
-            if not m.with_norm:
-                return False
-            if sync_bn:
-                if not isinstance(m.bn, SyncBatchNorm):
-                    return False
-    return True
-
-
-def to_cuda(module, data):
-    module = module.cuda()
-    if isinstance(data, list):
-        for i in range(len(data)):
-            data[i] = data[i].cuda()
-    return module, data
-
-
-def list_to_cuda(data):
-    if isinstance(data, list):
-        for i in range(len(data)):
-            data[i] = list_to_cuda(data[i])
-        return data
-    else:
-        return data.cuda()
diff --git a/mmsegmentation/tests/test_models/test_losses/test_cross_entropy_loss.py b/mmsegmentation/tests/test_models/test_losses/test_cross_entropy_loss.py
deleted file mode 100644
index 8c6b86d..0000000
--- a/mmsegmentation/tests/test_models/test_losses/test_cross_entropy_loss.py
+++ /dev/null
@@ -1,28 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-import torch.nn.functional as F
-
-from mmseg.models.losses import CrossEntropyLoss, weight_reduce_loss
-
-
-def test_cross_entropy_loss_class_weights():
-    loss_class = CrossEntropyLoss
-    pred = torch.rand((1, 10, 4, 4))
-    target = torch.randint(0, 10, (1, 4, 4))
-    class_weight = torch.ones(10)
-    avg_factor = target.numel()
-
-    cross_entropy_loss = F.cross_entropy(
-        pred, target, weight=class_weight, reduction='none', ignore_index=-100)
-
-    expected_loss = weight_reduce_loss(
-        cross_entropy_loss,
-        weight=None,
-        reduction='mean',
-        avg_factor=avg_factor)
-
-    # Test loss forward
-    loss = loss_class(class_weight=class_weight.tolist())(pred, target)
-
-    assert isinstance(loss, torch.Tensor)
-    assert expected_loss == loss
diff --git a/mmsegmentation/tests/test_models/test_losses/test_dice_loss.py b/mmsegmentation/tests/test_models/test_losses/test_dice_loss.py
deleted file mode 100644
index 34253da..0000000
--- a/mmsegmentation/tests/test_models/test_losses/test_dice_loss.py
+++ /dev/null
@@ -1,96 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.losses import DiceLoss
-
-
-@pytest.mark.parametrize('naive_dice', [True, False])
-def test_dice_loss(naive_dice):
-    loss_class = DiceLoss
-    pred = torch.rand((1, 10, 4, 4))
-    target = torch.randint(0, 10, (1, 4, 4))
-    weight = torch.rand(1)
-    # Test loss forward
-    loss = loss_class(naive_dice=naive_dice)(pred, target)
-    assert isinstance(loss, torch.Tensor)
-
-    # Test loss forward with weight
-    loss = loss_class(naive_dice=naive_dice)(pred, target, weight)
-    assert isinstance(loss, torch.Tensor)
-
-    # Test loss forward with reduction_override
-    loss = loss_class(naive_dice=naive_dice)(
-        pred, target, reduction_override='mean')
-    assert isinstance(loss, torch.Tensor)
-
-    # Test loss forward with avg_factor
-    loss = loss_class(naive_dice=naive_dice)(pred, target, avg_factor=10)
-    assert isinstance(loss, torch.Tensor)
-
-    with pytest.raises(ValueError):
-        # loss can evaluate with avg_factor only if
-        # reduction is None, 'none' or 'mean'.
-        reduction_override = 'sum'
-        loss_class(naive_dice=naive_dice)(
-            pred, target, avg_factor=10, reduction_override=reduction_override)
-
-    # Test loss forward with avg_factor and reduction
-    for reduction_override in [None, 'none', 'mean']:
-        loss_class(naive_dice=naive_dice)(
-            pred, target, avg_factor=10, reduction_override=reduction_override)
-        assert isinstance(loss, torch.Tensor)
-
-    # Test loss forward with has_acted=False and use_sigmoid=False
-    for use_sigmoid in [True, False]:
-        loss_class(
-            use_sigmoid=use_sigmoid, activate=True,
-            naive_dice=naive_dice)(pred, target)
-        assert isinstance(loss, torch.Tensor)
-
-    # Test loss forward with weight.ndim != loss.ndim
-    with pytest.raises(AssertionError):
-        weight = torch.rand((2, 8))
-        loss_class(naive_dice=naive_dice)(pred, target, weight)
-
-    # Test loss forward with len(weight) != len(pred)
-    with pytest.raises(AssertionError):
-        weight = torch.rand(8)
-        loss_class(naive_dice=naive_dice)(pred, target, weight)
-
-    # Test _expand_onehot_labels_dice
-    pred = torch.tensor([[[[1, 1], [1, 0]], [[0, 1], [1, 1]]]]).float()
-    target = torch.tensor([[[0, 0], [0, 1]]])
-    target_onehot = torch.tensor([[[[1, 1], [1, 0]], [[0, 0], [0, 1]]]])
-    weight = torch.rand(1)
-    loss = loss_class(naive_dice=naive_dice)(pred, target, weight)
-    loss_onehot = loss_class(naive_dice=naive_dice)(pred, target_onehot,
-                                                    weight)
-    assert torch.equal(loss, loss_onehot)
-
-    # Test Whether Loss is 0 when pred == target, eps == 0 and naive_dice=False
-    target = torch.randint(0, 2, (1, 10, 4, 4))
-    pred = target.float()
-    target = target.sigmoid()
-    weight = torch.rand(1)
-    loss = loss_class(
-        naive_dice=False, use_sigmoid=True, eps=0)(pred, target, weight)
-    assert loss.item() == 0
-
-    # Test ignore_index when ignore_index is the only class
-    with pytest.raises(AssertionError):
-        pred = torch.ones((1, 1, 4, 4))
-        target = torch.randint(0, 1, (1, 4, 4))
-        weight = torch.rand(1)
-        loss = loss_class(
-            naive_dice=naive_dice, use_sigmoid=False, ignore_index=0,
-            eps=0)(pred, target, weight)
-
-    # Test ignore_index with naive_dice = False
-    pred = torch.tensor([[[[1, 1], [1, 0]], [[0, 1], [1, 1]]]]).float()
-    target = torch.tensor([[[[1, 1], [1, 0]], [[1, 0], [0, 1]]]]).sigmoid()
-    weight = torch.rand(1)
-    loss = loss_class(
-        naive_dice=False, use_sigmoid=True, ignore_index=1,
-        eps=0)(pred, target, weight)
-    assert loss.item() == 0
diff --git a/mmsegmentation/tests/test_models/test_losses/test_huasdorff_distance_loss.py b/mmsegmentation/tests/test_models/test_losses/test_huasdorff_distance_loss.py
deleted file mode 100644
index 29c2732..0000000
--- a/mmsegmentation/tests/test_models/test_losses/test_huasdorff_distance_loss.py
+++ /dev/null
@@ -1,29 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.losses import HuasdorffDisstanceLoss
-
-
-def test_huasdorff_distance_loss():
-    loss_class = HuasdorffDisstanceLoss
-    pred = torch.rand((10, 8, 6, 6))
-    target = torch.rand((10, 6, 6))
-    class_weight = torch.rand(8)
-
-    # Test loss forward
-    loss = loss_class()(pred, target)
-    assert isinstance(loss, torch.Tensor)
-
-    # Test loss forward with avg_factor
-    loss = loss_class()(pred, target, avg_factor=10)
-    assert isinstance(loss, torch.Tensor)
-
-    # Test loss forward with avg_factor and reduction is None, 'sum' and 'mean'
-    for reduction in [None, 'sum', 'mean']:
-        loss = loss_class()(pred, target, avg_factor=10, reduction=reduction)
-        assert isinstance(loss, torch.Tensor)
-
-    # Test loss forward with class_weight
-    with pytest.raises(AssertionError):
-        loss_class(class_weight=class_weight)(pred, target)
diff --git a/mmsegmentation/tests/test_models/test_losses/test_kldiv_loss.py b/mmsegmentation/tests/test_models/test_losses/test_kldiv_loss.py
deleted file mode 100644
index 48bcc4b..0000000
--- a/mmsegmentation/tests/test_models/test_losses/test_kldiv_loss.py
+++ /dev/null
@@ -1,40 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-
-from mmseg.models.losses.kldiv_loss import KLDivLoss
-
-
-def test_kldiv_loss_with_none_reduction():
-    loss_class = KLDivLoss
-    pred = torch.rand((8, 5, 5))
-    target = torch.rand((8, 5, 5))
-    reduction = 'none'
-
-    # Test loss forward
-    loss = loss_class(reduction=reduction)(pred, target)
-    assert isinstance(loss, torch.Tensor)
-    assert loss.shape == (8, 5, 5), f'{loss.shape}'
-
-
-def test_kldiv_loss_with_mean_reduction():
-    loss_class = KLDivLoss
-    pred = torch.rand((8, 5, 5))
-    target = torch.rand((8, 5, 5))
-    reduction = 'mean'
-
-    # Test loss forward
-    loss = loss_class(reduction=reduction)(pred, target)
-    assert isinstance(loss, torch.Tensor)
-    assert loss.shape == (8, ), f'{loss.shape}'
-
-
-def test_kldiv_loss_with_sum_reduction():
-    loss_class = KLDivLoss
-    pred = torch.rand((8, 5, 5))
-    target = torch.rand((8, 5, 5))
-    reduction = 'sum'
-
-    # Test loss forward
-    loss = loss_class(reduction=reduction)(pred, target)
-    assert isinstance(loss, torch.Tensor)
-    assert loss.shape == (8, ), f'{loss.shape}'
diff --git a/mmsegmentation/tests/test_models/test_losses/test_silog_loss.py b/mmsegmentation/tests/test_models/test_losses/test_silog_loss.py
deleted file mode 100644
index 022434b..0000000
--- a/mmsegmentation/tests/test_models/test_losses/test_silog_loss.py
+++ /dev/null
@@ -1,20 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from unittest import TestCase
-
-import torch
-
-from mmseg.models.losses import SiLogLoss
-
-
-class TestSiLogLoss(TestCase):
-
-    def test_SiLogLoss_forward(self):
-        pred = torch.tensor([[1.0, 2.0], [3.5, 4.0]], dtype=torch.float32)
-        target = torch.tensor([[0.0, 2.0], [3.0, 4.0]], dtype=torch.float32)
-        weight = torch.tensor([1.0, 0.5], dtype=torch.float32)
-
-        loss_module = SiLogLoss()
-        loss = loss_module.forward(pred, target, weight)
-
-        expected_loss = 0.02
-        self.assertAlmostEqual(loss.item(), expected_loss, places=2)
diff --git a/mmsegmentation/tests/test_models/test_losses/test_tversky_loss.py b/mmsegmentation/tests/test_models/test_losses/test_tversky_loss.py
deleted file mode 100644
index c5c581d..0000000
--- a/mmsegmentation/tests/test_models/test_losses/test_tversky_loss.py
+++ /dev/null
@@ -1,77 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-
-def test_tversky_lose():
-    from mmseg.models import build_loss
-
-    # test alpha + beta != 1
-    with pytest.raises(AssertionError):
-        loss_cfg = dict(
-            type='TverskyLoss',
-            class_weight=[1.0, 2.0, 3.0],
-            loss_weight=1.0,
-            alpha=0.4,
-            beta=0.7,
-            loss_name='loss_tversky')
-        tversky_loss = build_loss(loss_cfg)
-        logits = torch.rand(8, 3, 4, 4)
-        labels = (torch.rand(8, 4, 4) * 3).long()
-        tversky_loss(logits, labels, ignore_index=1)
-
-    # test tversky loss
-    loss_cfg = dict(
-        type='TverskyLoss',
-        class_weight=[1.0, 2.0, 3.0],
-        loss_weight=1.0,
-        ignore_index=1,
-        loss_name='loss_tversky')
-    tversky_loss = build_loss(loss_cfg)
-    logits = torch.rand(8, 3, 4, 4)
-    labels = (torch.rand(8, 4, 4) * 3).long()
-    tversky_loss(logits, labels)
-
-    # test loss with class weights from file
-    import os
-    import tempfile
-
-    import mmengine
-    import numpy as np
-    tmp_file = tempfile.NamedTemporaryFile()
-
-    mmengine.dump([1.0, 2.0, 3.0], f'{tmp_file.name}.pkl',
-                  'pkl')  # from pkl file
-    loss_cfg = dict(
-        type='TverskyLoss',
-        class_weight=f'{tmp_file.name}.pkl',
-        loss_weight=1.0,
-        ignore_index=1,
-        loss_name='loss_tversky')
-    tversky_loss = build_loss(loss_cfg)
-    tversky_loss(logits, labels)
-
-    np.save(f'{tmp_file.name}.npy', np.array([1.0, 2.0, 3.0]))  # from npy file
-    loss_cfg = dict(
-        type='TverskyLoss',
-        class_weight=f'{tmp_file.name}.pkl',
-        loss_weight=1.0,
-        ignore_index=1,
-        loss_name='loss_tversky')
-    tversky_loss = build_loss(loss_cfg)
-    tversky_loss(logits, labels)
-    tmp_file.close()
-    os.remove(f'{tmp_file.name}.pkl')
-    os.remove(f'{tmp_file.name}.npy')
-
-    # test tversky loss has name `loss_tversky`
-    loss_cfg = dict(
-        type='TverskyLoss',
-        smooth=2,
-        loss_weight=1.0,
-        ignore_index=1,
-        alpha=0.3,
-        beta=0.7,
-        loss_name='loss_tversky')
-    tversky_loss = build_loss(loss_cfg)
-    assert tversky_loss.loss_name == 'loss_tversky'
diff --git a/mmsegmentation/tests/test_models/test_necks/__init__.py b/mmsegmentation/tests/test_models/test_necks/__init__.py
deleted file mode 100644
index ef101fe..0000000
--- a/mmsegmentation/tests/test_models/test_necks/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
diff --git a/mmsegmentation/tests/test_models/test_necks/test_feature2pyramid.py b/mmsegmentation/tests/test_models/test_necks/test_feature2pyramid.py
deleted file mode 100644
index 44fd02c..0000000
--- a/mmsegmentation/tests/test_models/test_necks/test_feature2pyramid.py
+++ /dev/null
@@ -1,38 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models import Feature2Pyramid
-
-
-def test_feature2pyramid():
-    # test
-    rescales = [4, 2, 1, 0.5]
-    embed_dim = 64
-    inputs = [torch.randn(1, embed_dim, 32, 32) for i in range(len(rescales))]
-
-    fpn = Feature2Pyramid(
-        embed_dim, rescales, norm_cfg=dict(type='BN', requires_grad=True))
-    outputs = fpn(inputs)
-    assert outputs[0].shape == torch.Size([1, 64, 128, 128])
-    assert outputs[1].shape == torch.Size([1, 64, 64, 64])
-    assert outputs[2].shape == torch.Size([1, 64, 32, 32])
-    assert outputs[3].shape == torch.Size([1, 64, 16, 16])
-
-    # test rescales = [2, 1, 0.5, 0.25]
-    rescales = [2, 1, 0.5, 0.25]
-    inputs = [torch.randn(1, embed_dim, 32, 32) for i in range(len(rescales))]
-
-    fpn = Feature2Pyramid(
-        embed_dim, rescales, norm_cfg=dict(type='BN', requires_grad=True))
-    outputs = fpn(inputs)
-    assert outputs[0].shape == torch.Size([1, 64, 64, 64])
-    assert outputs[1].shape == torch.Size([1, 64, 32, 32])
-    assert outputs[2].shape == torch.Size([1, 64, 16, 16])
-    assert outputs[3].shape == torch.Size([1, 64, 8, 8])
-
-    # test rescales = [4, 2, 0.25, 0]
-    rescales = [4, 2, 0.25, 0]
-    with pytest.raises(KeyError):
-        fpn = Feature2Pyramid(
-            embed_dim, rescales, norm_cfg=dict(type='BN', requires_grad=True))
diff --git a/mmsegmentation/tests/test_models/test_necks/test_fpn.py b/mmsegmentation/tests/test_models/test_necks/test_fpn.py
deleted file mode 100644
index c294006..0000000
--- a/mmsegmentation/tests/test_models/test_necks/test_fpn.py
+++ /dev/null
@@ -1,30 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-
-from mmseg.models import FPN
-
-
-def test_fpn():
-    in_channels = [64, 128, 256, 512]
-    inputs = [
-        torch.randn(1, c, 56 // 2**i, 56 // 2**i)
-        for i, c in enumerate(in_channels)
-    ]
-
-    fpn = FPN(in_channels, 64, len(in_channels))
-    outputs = fpn(inputs)
-    assert outputs[0].shape == torch.Size([1, 64, 56, 56])
-    assert outputs[1].shape == torch.Size([1, 64, 28, 28])
-    assert outputs[2].shape == torch.Size([1, 64, 14, 14])
-    assert outputs[3].shape == torch.Size([1, 64, 7, 7])
-
-    fpn = FPN(
-        in_channels,
-        64,
-        len(in_channels),
-        upsample_cfg=dict(mode='nearest', scale_factor=2.0))
-    outputs = fpn(inputs)
-    assert outputs[0].shape == torch.Size([1, 64, 56, 56])
-    assert outputs[1].shape == torch.Size([1, 64, 28, 28])
-    assert outputs[2].shape == torch.Size([1, 64, 14, 14])
-    assert outputs[3].shape == torch.Size([1, 64, 7, 7])
diff --git a/mmsegmentation/tests/test_models/test_necks/test_ic_neck.py b/mmsegmentation/tests/test_models/test_necks/test_ic_neck.py
deleted file mode 100644
index 3d13008..0000000
--- a/mmsegmentation/tests/test_models/test_necks/test_ic_neck.py
+++ /dev/null
@@ -1,53 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.necks import ICNeck
-from mmseg.models.necks.ic_neck import CascadeFeatureFusion
-from ..test_heads.utils import _conv_has_norm, to_cuda
-
-
-def test_ic_neck():
-    # test with norm_cfg
-    neck = ICNeck(
-        in_channels=(4, 16, 16),
-        out_channels=8,
-        norm_cfg=dict(type='SyncBN'),
-        align_corners=False)
-    assert _conv_has_norm(neck, sync_bn=True)
-
-    inputs = [
-        torch.randn(1, 4, 32, 64),
-        torch.randn(1, 16, 16, 32),
-        torch.randn(1, 16, 8, 16)
-    ]
-    neck = ICNeck(
-        in_channels=(4, 16, 16),
-        out_channels=4,
-        norm_cfg=dict(type='BN', requires_grad=True),
-        align_corners=False)
-    if torch.cuda.is_available():
-        neck, inputs = to_cuda(neck, inputs)
-
-    outputs = neck(inputs)
-    assert outputs[0].shape == (1, 4, 16, 32)
-    assert outputs[1].shape == (1, 4, 32, 64)
-    assert outputs[1].shape == (1, 4, 32, 64)
-
-
-def test_ic_neck_cascade_feature_fusion():
-    cff = CascadeFeatureFusion(64, 64, 32)
-    assert cff.conv_low.in_channels == 64
-    assert cff.conv_low.out_channels == 32
-    assert cff.conv_high.in_channels == 64
-    assert cff.conv_high.out_channels == 32
-
-
-def test_ic_neck_input_channels():
-    with pytest.raises(AssertionError):
-        # ICNet Neck input channel constraints.
-        ICNeck(
-            in_channels=(16, 64, 64, 64),
-            out_channels=32,
-            norm_cfg=dict(type='BN', requires_grad=True),
-            align_corners=False)
diff --git a/mmsegmentation/tests/test_models/test_necks/test_jpu.py b/mmsegmentation/tests/test_models/test_necks/test_jpu.py
deleted file mode 100644
index 4c3fa9f..0000000
--- a/mmsegmentation/tests/test_models/test_necks/test_jpu.py
+++ /dev/null
@@ -1,46 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.necks import JPU
-
-
-def test_fastfcn_neck():
-    # Test FastFCN Standard Forward
-    model = JPU(
-        in_channels=(64, 128, 256),
-        mid_channels=64,
-        start_level=0,
-        end_level=-1,
-        dilations=(1, 2, 4, 8),
-    )
-    model.init_weights()
-    model.train()
-    batch_size = 1
-    input = [
-        torch.randn(batch_size, 64, 64, 128),
-        torch.randn(batch_size, 128, 32, 64),
-        torch.randn(batch_size, 256, 16, 32)
-    ]
-    feat = model(input)
-
-    assert len(feat) == 3
-    assert feat[0].shape == torch.Size([batch_size, 64, 64, 128])
-    assert feat[1].shape == torch.Size([batch_size, 128, 32, 64])
-    assert feat[2].shape == torch.Size([batch_size, 256, 64, 128])
-
-    with pytest.raises(AssertionError):
-        # FastFCN input and in_channels constraints.
-        JPU(in_channels=(256, 64, 128), start_level=0, end_level=5)
-
-    # Test not default start_level
-    model = JPU(in_channels=(64, 128, 256), start_level=1, end_level=-1)
-    input = [
-        torch.randn(batch_size, 64, 64, 128),
-        torch.randn(batch_size, 128, 32, 64),
-        torch.randn(batch_size, 256, 16, 32)
-    ]
-    feat = model(input)
-    assert len(feat) == 2
-    assert feat[0].shape == torch.Size([batch_size, 128, 32, 64])
-    assert feat[1].shape == torch.Size([batch_size, 2048, 32, 64])
diff --git a/mmsegmentation/tests/test_models/test_necks/test_mla_neck.py b/mmsegmentation/tests/test_models/test_necks/test_mla_neck.py
deleted file mode 100644
index e385418..0000000
--- a/mmsegmentation/tests/test_models/test_necks/test_mla_neck.py
+++ /dev/null
@@ -1,16 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-
-from mmseg.models import MLANeck
-
-
-def test_mla():
-    in_channels = [4, 4, 4, 4]
-    mla = MLANeck(in_channels, 32)
-
-    inputs = [torch.randn(1, c, 12, 12) for i, c in enumerate(in_channels)]
-    outputs = mla(inputs)
-    assert outputs[0].shape == torch.Size([1, 32, 12, 12])
-    assert outputs[1].shape == torch.Size([1, 32, 12, 12])
-    assert outputs[2].shape == torch.Size([1, 32, 12, 12])
-    assert outputs[3].shape == torch.Size([1, 32, 12, 12])
diff --git a/mmsegmentation/tests/test_models/test_necks/test_multilevel_neck.py b/mmsegmentation/tests/test_models/test_necks/test_multilevel_neck.py
deleted file mode 100644
index 9c71d51..0000000
--- a/mmsegmentation/tests/test_models/test_necks/test_multilevel_neck.py
+++ /dev/null
@@ -1,32 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-
-from mmseg.models import MultiLevelNeck
-
-
-def test_multilevel_neck():
-
-    # Test init_weights
-    MultiLevelNeck([266], 32).init_weights()
-
-    # Test multi feature maps
-    in_channels = [32, 64, 128, 256]
-    inputs = [torch.randn(1, c, 14, 14) for i, c in enumerate(in_channels)]
-
-    neck = MultiLevelNeck(in_channels, 32)
-    outputs = neck(inputs)
-    assert outputs[0].shape == torch.Size([1, 32, 7, 7])
-    assert outputs[1].shape == torch.Size([1, 32, 14, 14])
-    assert outputs[2].shape == torch.Size([1, 32, 28, 28])
-    assert outputs[3].shape == torch.Size([1, 32, 56, 56])
-
-    # Test one feature map
-    in_channels = [768]
-    inputs = [torch.randn(1, 768, 14, 14)]
-
-    neck = MultiLevelNeck(in_channels, 32)
-    outputs = neck(inputs)
-    assert outputs[0].shape == torch.Size([1, 32, 7, 7])
-    assert outputs[1].shape == torch.Size([1, 32, 14, 14])
-    assert outputs[2].shape == torch.Size([1, 32, 28, 28])
-    assert outputs[3].shape == torch.Size([1, 32, 56, 56])
diff --git a/mmsegmentation/tests/test_models/test_segmentors/__init__.py b/mmsegmentation/tests/test_models/test_segmentors/__init__.py
deleted file mode 100644
index ef101fe..0000000
--- a/mmsegmentation/tests/test_models/test_segmentors/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
diff --git a/mmsegmentation/tests/test_models/test_segmentors/test_cascade_encoder_decoder.py b/mmsegmentation/tests/test_models/test_segmentors/test_cascade_encoder_decoder.py
deleted file mode 100644
index 941816d..0000000
--- a/mmsegmentation/tests/test_models/test_segmentors/test_cascade_encoder_decoder.py
+++ /dev/null
@@ -1,57 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmengine import ConfigDict
-
-from mmseg.models import build_segmentor
-from .utils import _segmentor_forward_train_test
-
-
-def test_cascade_encoder_decoder():
-
-    # test 1 decode head, w.o. aux head
-    cfg = ConfigDict(
-        type='CascadeEncoderDecoder',
-        num_stages=2,
-        backbone=dict(type='ExampleBackbone'),
-        decode_head=[
-            dict(type='ExampleDecodeHead'),
-            dict(type='ExampleCascadeDecodeHead')
-        ])
-    cfg.test_cfg = ConfigDict(mode='whole')
-    segmentor = build_segmentor(cfg)
-    _segmentor_forward_train_test(segmentor)
-
-    # test slide mode
-    cfg.test_cfg = ConfigDict(mode='slide', crop_size=(3, 3), stride=(2, 2))
-    segmentor = build_segmentor(cfg)
-    _segmentor_forward_train_test(segmentor)
-
-    # test 1 decode head, 1 aux head
-    cfg = ConfigDict(
-        type='CascadeEncoderDecoder',
-        num_stages=2,
-        backbone=dict(type='ExampleBackbone'),
-        decode_head=[
-            dict(type='ExampleDecodeHead'),
-            dict(type='ExampleCascadeDecodeHead')
-        ],
-        auxiliary_head=dict(type='ExampleDecodeHead'))
-    cfg.test_cfg = ConfigDict(mode='whole')
-    segmentor = build_segmentor(cfg)
-    _segmentor_forward_train_test(segmentor)
-
-    # test 1 decode head, 2 aux head
-    cfg = ConfigDict(
-        type='CascadeEncoderDecoder',
-        num_stages=2,
-        backbone=dict(type='ExampleBackbone'),
-        decode_head=[
-            dict(type='ExampleDecodeHead'),
-            dict(type='ExampleCascadeDecodeHead')
-        ],
-        auxiliary_head=[
-            dict(type='ExampleDecodeHead'),
-            dict(type='ExampleDecodeHead')
-        ])
-    cfg.test_cfg = ConfigDict(mode='whole')
-    segmentor = build_segmentor(cfg)
-    _segmentor_forward_train_test(segmentor)
diff --git a/mmsegmentation/tests/test_models/test_segmentors/test_depth_estimator.py b/mmsegmentation/tests/test_models/test_segmentors/test_depth_estimator.py
deleted file mode 100644
index e819c9e..0000000
--- a/mmsegmentation/tests/test_models/test_segmentors/test_depth_estimator.py
+++ /dev/null
@@ -1,64 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from copy import deepcopy
-from os.path import dirname, join
-from unittest import TestCase
-
-import torch
-from mmengine import Config, ConfigDict
-from mmengine.structures import PixelData
-
-import mmseg
-from mmseg.models.segmentors import DepthEstimator
-from mmseg.structures import SegDataSample
-
-
-class TestDepthEstimator(TestCase):
-
-    def setUp(self) -> None:
-        repo_dpath = dirname(dirname(mmseg.__file__))
-        config_dpath = join(repo_dpath, 'configs/_base_/models/vpd_sd.py')
-        vpd_cfg = Config.fromfile(config_dpath).stable_diffusion_cfg
-        vpd_cfg.pop('checkpoint')
-
-        backbone_cfg = dict(
-            type='VPD',
-            diffusion_cfg=vpd_cfg,
-            class_embed_path='https://download.openmmlab.com/mmsegmentation/'
-            'v0.5/vpd/nyu_class_embeddings.pth',
-            class_embed_select=True,
-            pad_shape=64,
-            unet_cfg=dict(use_attn=False),
-        )
-
-        head_cfg = dict(
-            type='VPDDepthHead',
-            max_depth=10,
-        )
-
-        self.model = DepthEstimator(
-            backbone=backbone_cfg, decode_head=head_cfg)
-
-        inputs = torch.randn(1, 3, 64, 80)
-        data_sample = SegDataSample()
-        data_sample.gt_depth_map = PixelData(data=torch.rand(1, 64, 80))
-        data_sample.set_metainfo(dict(img_shape=(64, 80), ori_shape=(64, 80)))
-        self.data = dict(inputs=inputs, data_samples=[data_sample])
-
-    def test_slide_flip_inference(self):
-
-        self.model.test_cfg = ConfigDict(
-            dict(mode='slide_flip', crop_size=(64, 64), stride=(16, 16)))
-
-        with torch.no_grad():
-            out = self.model.predict(**deepcopy(self.data))
-
-        self.assertEqual(len(out), 1)
-        self.assertIn('pred_depth_map', out[0].keys())
-        self.assertListEqual(list(out[0].pred_depth_map.shape), [64, 80])
-
-    def test__forward(self):
-        data = deepcopy(self.data)
-        data['inputs'] = data['inputs'][:, :, :64, :64]
-        with torch.no_grad():
-            out = self.model._forward(**data)
-        self.assertListEqual(list(out.shape), [1, 1, 64, 64])
diff --git a/mmsegmentation/tests/test_models/test_segmentors/test_encoder_decoder.py b/mmsegmentation/tests/test_models/test_segmentors/test_encoder_decoder.py
deleted file mode 100644
index 5795f51..0000000
--- a/mmsegmentation/tests/test_models/test_segmentors/test_encoder_decoder.py
+++ /dev/null
@@ -1,100 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-from mmengine import ConfigDict
-from mmengine.structures import PixelData
-
-from mmseg.models import build_segmentor
-from mmseg.structures import SegDataSample
-from .utils import _segmentor_forward_train_test
-
-
-def test_encoder_decoder():
-
-    # test 1 decode head, w.o. aux head
-
-    cfg = ConfigDict(
-        type='EncoderDecoder',
-        backbone=dict(type='ExampleBackbone'),
-        decode_head=dict(type='ExampleDecodeHead'),
-        train_cfg=None,
-        test_cfg=dict(mode='whole'))
-    segmentor = build_segmentor(cfg)
-    _segmentor_forward_train_test(segmentor)
-
-    # test out_channels == 1
-    cfg = ConfigDict(
-        type='EncoderDecoder',
-        backbone=dict(type='ExampleBackbone'),
-        decode_head=dict(
-            type='ExampleDecodeHead', num_classes=2, out_channels=1),
-        train_cfg=None,
-        test_cfg=dict(mode='whole'))
-    segmentor = build_segmentor(cfg)
-    _segmentor_forward_train_test(segmentor)
-
-    # test slide mode
-    cfg.test_cfg = ConfigDict(mode='slide', crop_size=(3, 3), stride=(2, 2))
-    segmentor = build_segmentor(cfg)
-    _segmentor_forward_train_test(segmentor)
-
-    # test 1 decode head, 1 aux head
-    cfg = ConfigDict(
-        type='EncoderDecoder',
-        backbone=dict(type='ExampleBackbone'),
-        decode_head=dict(type='ExampleDecodeHead'),
-        auxiliary_head=dict(type='ExampleDecodeHead'))
-    cfg.test_cfg = ConfigDict(mode='whole')
-    segmentor = build_segmentor(cfg)
-    _segmentor_forward_train_test(segmentor)
-
-    # test 1 decode head, 2 aux head
-    cfg = ConfigDict(
-        type='EncoderDecoder',
-        backbone=dict(type='ExampleBackbone'),
-        decode_head=dict(type='ExampleDecodeHead'),
-        auxiliary_head=[
-            dict(type='ExampleDecodeHead'),
-            dict(type='ExampleDecodeHead')
-        ])
-    cfg.test_cfg = ConfigDict(mode='whole')
-    segmentor = build_segmentor(cfg)
-    _segmentor_forward_train_test(segmentor)
-
-
-def test_postprocess_result():
-    cfg = ConfigDict(
-        type='EncoderDecoder',
-        backbone=dict(type='ExampleBackbone'),
-        decode_head=dict(type='ExampleDecodeHead'),
-        train_cfg=None,
-        test_cfg=dict(mode='whole'))
-    model = build_segmentor(cfg)
-
-    # test postprocess
-    data_sample = SegDataSample()
-    data_sample.gt_sem_seg = PixelData(
-        **{'data': torch.randint(0, 10, (1, 8, 8))})
-    data_sample.set_metainfo({
-        'padding_size': (0, 2, 0, 2),
-        'ori_shape': (8, 8)
-    })
-    seg_logits = torch.zeros((1, 2, 10, 10))
-    seg_logits[:, :, :8, :8] = 1
-    data_samples = [data_sample]
-
-    outputs = model.postprocess_result(seg_logits, data_samples)
-    assert outputs[0].seg_logits.data.shape == torch.Size((2, 8, 8))
-    assert torch.allclose(outputs[0].seg_logits.data, torch.ones((2, 8, 8)))
-
-    data_sample = SegDataSample()
-    data_sample.gt_sem_seg = PixelData(
-        **{'data': torch.randint(0, 10, (1, 8, 8))})
-    data_sample.set_metainfo({
-        'img_padding_size': (0, 2, 0, 2),
-        'ori_shape': (8, 8)
-    })
-
-    data_samples = [data_sample]
-    outputs = model.postprocess_result(seg_logits, data_samples)
-    assert outputs[0].seg_logits.data.shape == torch.Size((2, 8, 8))
-    assert torch.allclose(outputs[0].seg_logits.data, torch.ones((2, 8, 8)))
diff --git a/mmsegmentation/tests/test_models/test_segmentors/test_multimodal_encoder_decoder.py b/mmsegmentation/tests/test_models/test_segmentors/test_multimodal_encoder_decoder.py
deleted file mode 100644
index 75258d8..0000000
--- a/mmsegmentation/tests/test_models/test_segmentors/test_multimodal_encoder_decoder.py
+++ /dev/null
@@ -1,24 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmengine import ConfigDict
-
-from mmseg.models import build_segmentor
-from tests.test_models.test_segmentors.utils import \
-    _segmentor_forward_train_test
-
-
-def test_multimodal_encoder_decoder():
-
-    cfg = ConfigDict(
-        type='MultimodalEncoderDecoder',
-        asymetric_input=False,
-        image_encoder=dict(type='ExampleBackbone', out_indices=[1, 2, 3, 4]),
-        text_encoder=dict(
-            type='ExampleTextEncoder',
-            vocabulary=['A', 'B', 'C'],
-            output_dims=3),
-        decode_head=dict(
-            type='ExampleDecodeHead', out_channels=1, num_classes=2),
-        train_cfg=None,
-        test_cfg=dict(mode='whole'))
-    segmentor = build_segmentor(cfg)
-    _segmentor_forward_train_test(segmentor)
diff --git a/mmsegmentation/tests/test_models/test_segmentors/test_seg_tta_model.py b/mmsegmentation/tests/test_models/test_segmentors/test_seg_tta_model.py
deleted file mode 100644
index 1e152ed..0000000
--- a/mmsegmentation/tests/test_models/test_segmentors/test_seg_tta_model.py
+++ /dev/null
@@ -1,63 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import tempfile
-
-import torch
-from mmengine import ConfigDict
-from mmengine.model import BaseTTAModel
-from mmengine.registry import init_default_scope
-from mmengine.structures import PixelData
-
-from mmseg.registry import MODELS
-from mmseg.structures import SegDataSample
-from .utils import *  # noqa: F401,F403
-
-init_default_scope('mmseg')
-
-
-def test_encoder_decoder_tta():
-
-    segmentor_cfg = ConfigDict(
-        type='EncoderDecoder',
-        backbone=dict(type='ExampleBackbone'),
-        decode_head=dict(type='ExampleDecodeHead'),
-        train_cfg=None,
-        test_cfg=dict(mode='whole'))
-
-    cfg = ConfigDict(type='SegTTAModel', module=segmentor_cfg)
-
-    model: BaseTTAModel = MODELS.build(cfg)
-
-    imgs = []
-    data_samples = []
-    directions = ['horizontal', 'vertical']
-    for i in range(12):
-        flip_direction = directions[0] if i % 3 == 0 else directions[1]
-        imgs.append(torch.randn(1, 3, 10 + i, 10 + i))
-        data_samples.append([
-            SegDataSample(
-                metainfo=dict(
-                    ori_shape=(10, 10),
-                    img_shape=(10 + i, 10 + i),
-                    flip=(i % 2 == 0),
-                    flip_direction=flip_direction,
-                    img_path=tempfile.mktemp()),
-                gt_sem_seg=PixelData(data=torch.randint(0, 19, (1, 10, 10))))
-        ])
-
-    model.test_step(dict(inputs=imgs, data_samples=data_samples))
-
-    # test out_channels == 1
-    segmentor_cfg = ConfigDict(
-        type='EncoderDecoder',
-        backbone=dict(type='ExampleBackbone'),
-        decode_head=dict(
-            type='ExampleDecodeHead',
-            num_classes=2,
-            out_channels=1,
-            threshold=0.4),
-        train_cfg=None,
-        test_cfg=dict(mode='whole'))
-    model.module = MODELS.build(segmentor_cfg)
-    for data_sample in data_samples:
-        data_sample[0].gt_sem_seg.data = torch.randint(0, 2, (1, 10, 10))
-    model.test_step(dict(inputs=imgs, data_samples=data_samples))
diff --git a/mmsegmentation/tests/test_models/test_segmentors/utils.py b/mmsegmentation/tests/test_models/test_segmentors/utils.py
deleted file mode 100644
index ac31e2b..0000000
--- a/mmsegmentation/tests/test_models/test_segmentors/utils.py
+++ /dev/null
@@ -1,182 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-from mmengine.optim import OptimWrapper
-from mmengine.structures import PixelData
-from torch import nn
-from torch.optim import SGD
-
-from mmseg.models import SegDataPreProcessor
-from mmseg.models.decode_heads.cascade_decode_head import BaseCascadeDecodeHead
-from mmseg.models.decode_heads.decode_head import BaseDecodeHead
-from mmseg.registry import MODELS
-from mmseg.structures import SegDataSample
-
-
-def _demo_mm_inputs(input_shape=(1, 3, 8, 16), num_classes=10):
-    """Create a superset of inputs needed to run test or train batches.
-
-    Args:
-        input_shape (tuple):
-            input batch dimensions
-
-        num_classes (int):
-            number of semantic classes
-    """
-    (N, C, H, W) = input_shape
-
-    imgs = torch.randn(*input_shape)
-    segs = torch.randint(
-        low=0, high=num_classes - 1, size=(N, H, W), dtype=torch.long)
-
-    img_metas = [{
-        'img_shape': (H, W),
-        'ori_shape': (H, W),
-        'pad_shape': (H, W, C),
-        'filename': '<demo>.png',
-        'scale_factor': 1.0,
-        'flip': False,
-        'flip_direction': 'horizontal'
-    } for _ in range(N)]
-
-    data_samples = [
-        SegDataSample(
-            gt_sem_seg=PixelData(data=segs[i]), metainfo=img_metas[i])
-        for i in range(N)
-    ]
-
-    mm_inputs = {'imgs': torch.FloatTensor(imgs), 'data_samples': data_samples}
-
-    return mm_inputs
-
-
-@MODELS.register_module()
-class ExampleBackbone(nn.Module):
-
-    def __init__(self, out_indices=None):
-        super().__init__()
-        self.conv = nn.Conv2d(3, 3, 3)
-        self.out_indices = out_indices
-
-    def init_weights(self, pretrained=None):
-        pass
-
-    def forward(self, x):
-        if self.out_indices is None:
-            return [self.conv(x)]
-        else:
-            outs = []
-            for i in self.out_indices:
-                outs.append(self.conv(x))
-        return outs
-
-
-@MODELS.register_module()
-class ExampleDecodeHead(BaseDecodeHead):
-
-    def __init__(self, num_classes=19, out_channels=None, **kwargs):
-        super().__init__(
-            3, 3, num_classes=num_classes, out_channels=out_channels, **kwargs)
-
-    def forward(self, inputs):
-        return self.cls_seg(inputs[0])
-
-
-@MODELS.register_module()
-class ExampleTextEncoder(nn.Module):
-
-    def __init__(self, vocabulary=None, output_dims=None):
-        super().__init__()
-        self.vocabulary = vocabulary
-        self.output_dims = output_dims
-
-    def forward(self):
-        return torch.randn((len(self.vocabulary), self.output_dims))
-
-
-@MODELS.register_module()
-class ExampleCascadeDecodeHead(BaseCascadeDecodeHead):
-
-    def __init__(self):
-        super().__init__(3, 3, num_classes=19)
-
-    def forward(self, inputs, prev_out):
-        return self.cls_seg(inputs[0])
-
-
-def _segmentor_forward_train_test(segmentor):
-    if isinstance(segmentor.decode_head, nn.ModuleList):
-        num_classes = segmentor.decode_head[-1].num_classes
-    else:
-        num_classes = segmentor.decode_head.num_classes
-    # batch_size=2 for BatchNorm
-    mm_inputs = _demo_mm_inputs(num_classes=num_classes)
-
-    # convert to cuda Tensor if applicable
-    if torch.cuda.is_available():
-        segmentor = segmentor.cuda()
-
-    # check data preprocessor
-    if not hasattr(segmentor,
-                   'data_preprocessor') or segmentor.data_preprocessor is None:
-        segmentor.data_preprocessor = SegDataPreProcessor()
-
-    mm_inputs = segmentor.data_preprocessor(mm_inputs, True)
-    imgs = mm_inputs.pop('imgs')
-    data_samples = mm_inputs.pop('data_samples')
-
-    # create optimizer wrapper
-    optimizer = SGD(segmentor.parameters(), lr=0.1)
-    optim_wrapper = OptimWrapper(optimizer)
-
-    # Test forward train
-    losses = segmentor.forward(imgs, data_samples, mode='loss')
-    assert isinstance(losses, dict)
-
-    # Test train_step
-    data_batch = dict(inputs=imgs, data_samples=data_samples)
-    outputs = segmentor.train_step(data_batch, optim_wrapper)
-    assert isinstance(outputs, dict)
-    assert 'loss' in outputs
-
-    # Test val_step
-    with torch.no_grad():
-        segmentor.eval()
-        data_batch = dict(inputs=imgs, data_samples=data_samples)
-        outputs = segmentor.val_step(data_batch)
-        assert isinstance(outputs, list)
-
-    # Test forward simple test
-    with torch.no_grad():
-        segmentor.eval()
-        data_batch = dict(inputs=imgs, data_samples=data_samples)
-        results = segmentor.forward(imgs, data_samples, mode='tensor')
-        assert isinstance(results, torch.Tensor)
-
-
-def _segmentor_predict(segmentor):
-    if isinstance(segmentor.decode_head, nn.ModuleList):
-        num_classes = segmentor.decode_head[-1].num_classes
-    else:
-        num_classes = segmentor.decode_head.num_classes
-    # batch_size=2 for BatchNorm
-    mm_inputs = _demo_mm_inputs(num_classes=num_classes)
-
-    # convert to cuda Tensor if applicable
-    if torch.cuda.is_available():
-        segmentor = segmentor.cuda()
-
-    # check data preprocessor
-    if not hasattr(segmentor,
-                   'data_preprocessor') or segmentor.data_preprocessor is None:
-        segmentor.data_preprocessor = SegDataPreProcessor()
-
-    mm_inputs = segmentor.data_preprocessor(mm_inputs, True)
-    imgs = mm_inputs.pop('imgs')
-    data_samples = mm_inputs.pop('data_samples')
-
-    # Test predict
-    with torch.no_grad():
-        segmentor.eval()
-        data_batch = dict(inputs=imgs, data_samples=data_samples)
-        outputs = segmentor.predict(**data_batch)
-        assert isinstance(outputs, list)
diff --git a/mmsegmentation/tests/test_models/test_utils/__init__.py b/mmsegmentation/tests/test_models/test_utils/__init__.py
deleted file mode 100644
index ef101fe..0000000
--- a/mmsegmentation/tests/test_models/test_utils/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
diff --git a/mmsegmentation/tests/test_models/test_utils/test_embed.py b/mmsegmentation/tests/test_models/test_utils/test_embed.py
deleted file mode 100644
index be20c97..0000000
--- a/mmsegmentation/tests/test_models/test_utils/test_embed.py
+++ /dev/null
@@ -1,461 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.utils.embed import AdaptivePadding, PatchEmbed, PatchMerging
-
-
-def test_adaptive_padding():
-
-    for padding in ('same', 'corner'):
-        kernel_size = 16
-        stride = 16
-        dilation = 1
-        input = torch.rand(1, 1, 15, 17)
-        adap_pool = AdaptivePadding(
-            kernel_size=kernel_size,
-            stride=stride,
-            dilation=dilation,
-            padding=padding)
-        out = adap_pool(input)
-        # padding to divisible by 16
-        assert (out.shape[2], out.shape[3]) == (16, 32)
-        input = torch.rand(1, 1, 16, 17)
-        out = adap_pool(input)
-        # padding to divisible by 16
-        assert (out.shape[2], out.shape[3]) == (16, 32)
-
-        kernel_size = (2, 2)
-        stride = (2, 2)
-        dilation = (1, 1)
-
-        adap_pad = AdaptivePadding(
-            kernel_size=kernel_size,
-            stride=stride,
-            dilation=dilation,
-            padding=padding)
-        input = torch.rand(1, 1, 11, 13)
-        out = adap_pad(input)
-        # padding to divisible by 2
-        assert (out.shape[2], out.shape[3]) == (12, 14)
-
-        kernel_size = (2, 2)
-        stride = (10, 10)
-        dilation = (1, 1)
-
-        adap_pad = AdaptivePadding(
-            kernel_size=kernel_size,
-            stride=stride,
-            dilation=dilation,
-            padding=padding)
-        input = torch.rand(1, 1, 10, 13)
-        out = adap_pad(input)
-        #  no padding
-        assert (out.shape[2], out.shape[3]) == (10, 13)
-
-        kernel_size = (11, 11)
-        adap_pad = AdaptivePadding(
-            kernel_size=kernel_size,
-            stride=stride,
-            dilation=dilation,
-            padding=padding)
-        input = torch.rand(1, 1, 11, 13)
-        out = adap_pad(input)
-        #  all padding
-        assert (out.shape[2], out.shape[3]) == (21, 21)
-
-        # test padding as kernel is (7,9)
-        input = torch.rand(1, 1, 11, 13)
-        stride = (3, 4)
-        kernel_size = (4, 5)
-        dilation = (2, 2)
-        # actually (7, 9)
-        adap_pad = AdaptivePadding(
-            kernel_size=kernel_size,
-            stride=stride,
-            dilation=dilation,
-            padding=padding)
-        dilation_out = adap_pad(input)
-        assert (dilation_out.shape[2], dilation_out.shape[3]) == (16, 21)
-        kernel_size = (7, 9)
-        dilation = (1, 1)
-        adap_pad = AdaptivePadding(
-            kernel_size=kernel_size,
-            stride=stride,
-            dilation=dilation,
-            padding=padding)
-        kernel79_out = adap_pad(input)
-        assert (kernel79_out.shape[2], kernel79_out.shape[3]) == (16, 21)
-        assert kernel79_out.shape == dilation_out.shape
-
-    # assert only support "same" "corner"
-    with pytest.raises(AssertionError):
-        AdaptivePadding(
-            kernel_size=kernel_size,
-            stride=stride,
-            dilation=dilation,
-            padding=1)
-
-
-def test_patch_embed():
-    B = 2
-    H = 3
-    W = 4
-    C = 3
-    embed_dims = 10
-    kernel_size = 3
-    stride = 1
-    dummy_input = torch.rand(B, C, H, W)
-    patch_merge_1 = PatchEmbed(
-        in_channels=C,
-        embed_dims=embed_dims,
-        kernel_size=kernel_size,
-        stride=stride,
-        padding=0,
-        dilation=1,
-        norm_cfg=None)
-
-    x1, shape = patch_merge_1(dummy_input)
-    # test out shape
-    assert x1.shape == (2, 2, 10)
-    # test outsize is correct
-    assert shape == (1, 2)
-    # test L = out_h * out_w
-    assert shape[0] * shape[1] == x1.shape[1]
-
-    B = 2
-    H = 10
-    W = 10
-    C = 3
-    embed_dims = 10
-    kernel_size = 5
-    stride = 2
-    dummy_input = torch.rand(B, C, H, W)
-    # test dilation
-    patch_merge_2 = PatchEmbed(
-        in_channels=C,
-        embed_dims=embed_dims,
-        kernel_size=kernel_size,
-        stride=stride,
-        padding=0,
-        dilation=2,
-        norm_cfg=None,
-    )
-
-    x2, shape = patch_merge_2(dummy_input)
-    # test out shape
-    assert x2.shape == (2, 1, 10)
-    # test outsize is correct
-    assert shape == (1, 1)
-    # test L = out_h * out_w
-    assert shape[0] * shape[1] == x2.shape[1]
-
-    stride = 2
-    input_size = (10, 10)
-
-    dummy_input = torch.rand(B, C, H, W)
-    # test stride and norm
-    patch_merge_3 = PatchEmbed(
-        in_channels=C,
-        embed_dims=embed_dims,
-        kernel_size=kernel_size,
-        stride=stride,
-        padding=0,
-        dilation=2,
-        norm_cfg=dict(type='LN'),
-        input_size=input_size)
-
-    x3, shape = patch_merge_3(dummy_input)
-    # test out shape
-    assert x3.shape == (2, 1, 10)
-    # test outsize is correct
-    assert shape == (1, 1)
-    # test L = out_h * out_w
-    assert shape[0] * shape[1] == x3.shape[1]
-
-    # test the init_out_size with nn.Unfold
-    assert patch_merge_3.init_out_size[1] == (input_size[0] - 2 * 4 -
-                                              1) // 2 + 1
-    assert patch_merge_3.init_out_size[0] == (input_size[0] - 2 * 4 -
-                                              1) // 2 + 1
-    H = 11
-    W = 12
-    input_size = (H, W)
-    dummy_input = torch.rand(B, C, H, W)
-    # test stride and norm
-    patch_merge_3 = PatchEmbed(
-        in_channels=C,
-        embed_dims=embed_dims,
-        kernel_size=kernel_size,
-        stride=stride,
-        padding=0,
-        dilation=2,
-        norm_cfg=dict(type='LN'),
-        input_size=input_size)
-
-    _, shape = patch_merge_3(dummy_input)
-    # when input_size equal to real input
-    # the out_size should be equal to `init_out_size`
-    assert shape == patch_merge_3.init_out_size
-
-    input_size = (H, W)
-    dummy_input = torch.rand(B, C, H, W)
-    # test stride and norm
-    patch_merge_3 = PatchEmbed(
-        in_channels=C,
-        embed_dims=embed_dims,
-        kernel_size=kernel_size,
-        stride=stride,
-        padding=0,
-        dilation=2,
-        norm_cfg=dict(type='LN'),
-        input_size=input_size)
-
-    _, shape = patch_merge_3(dummy_input)
-    # when input_size equal to real input
-    # the out_size should be equal to `init_out_size`
-    assert shape == patch_merge_3.init_out_size
-
-    # test adap padding
-    for padding in ('same', 'corner'):
-        in_c = 2
-        embed_dims = 3
-        B = 2
-
-        # test stride is 1
-        input_size = (5, 5)
-        kernel_size = (5, 5)
-        stride = (1, 1)
-        dilation = 1
-        bias = False
-
-        x = torch.rand(B, in_c, *input_size)
-        patch_embed = PatchEmbed(
-            in_channels=in_c,
-            embed_dims=embed_dims,
-            kernel_size=kernel_size,
-            stride=stride,
-            padding=padding,
-            dilation=dilation,
-            bias=bias)
-
-        x_out, out_size = patch_embed(x)
-        assert x_out.size() == (B, 25, 3)
-        assert out_size == (5, 5)
-        assert x_out.size(1) == out_size[0] * out_size[1]
-
-        # test kernel_size == stride
-        input_size = (5, 5)
-        kernel_size = (5, 5)
-        stride = (5, 5)
-        dilation = 1
-        bias = False
-
-        x = torch.rand(B, in_c, *input_size)
-        patch_embed = PatchEmbed(
-            in_channels=in_c,
-            embed_dims=embed_dims,
-            kernel_size=kernel_size,
-            stride=stride,
-            padding=padding,
-            dilation=dilation,
-            bias=bias)
-
-        x_out, out_size = patch_embed(x)
-        assert x_out.size() == (B, 1, 3)
-        assert out_size == (1, 1)
-        assert x_out.size(1) == out_size[0] * out_size[1]
-
-        # test kernel_size == stride
-        input_size = (6, 5)
-        kernel_size = (5, 5)
-        stride = (5, 5)
-        dilation = 1
-        bias = False
-
-        x = torch.rand(B, in_c, *input_size)
-        patch_embed = PatchEmbed(
-            in_channels=in_c,
-            embed_dims=embed_dims,
-            kernel_size=kernel_size,
-            stride=stride,
-            padding=padding,
-            dilation=dilation,
-            bias=bias)
-
-        x_out, out_size = patch_embed(x)
-        assert x_out.size() == (B, 2, 3)
-        assert out_size == (2, 1)
-        assert x_out.size(1) == out_size[0] * out_size[1]
-
-        # test different kernel_size with different stride
-        input_size = (6, 5)
-        kernel_size = (6, 2)
-        stride = (6, 2)
-        dilation = 1
-        bias = False
-
-        x = torch.rand(B, in_c, *input_size)
-        patch_embed = PatchEmbed(
-            in_channels=in_c,
-            embed_dims=embed_dims,
-            kernel_size=kernel_size,
-            stride=stride,
-            padding=padding,
-            dilation=dilation,
-            bias=bias)
-
-        x_out, out_size = patch_embed(x)
-        assert x_out.size() == (B, 3, 3)
-        assert out_size == (1, 3)
-        assert x_out.size(1) == out_size[0] * out_size[1]
-
-
-def test_patch_merging():
-
-    # Test the model with int padding
-    in_c = 3
-    out_c = 4
-    kernel_size = 3
-    stride = 3
-    padding = 1
-    dilation = 1
-    bias = False
-    # test the case `pad_to_stride` is False
-    patch_merge = PatchMerging(
-        in_channels=in_c,
-        out_channels=out_c,
-        kernel_size=kernel_size,
-        stride=stride,
-        padding=padding,
-        dilation=dilation,
-        bias=bias)
-    B, L, C = 1, 100, 3
-    input_size = (10, 10)
-    x = torch.rand(B, L, C)
-    x_out, out_size = patch_merge(x, input_size)
-    assert x_out.size() == (1, 16, 4)
-    assert out_size == (4, 4)
-    # assert out size is consistent with real output
-    assert x_out.size(1) == out_size[0] * out_size[1]
-    in_c = 4
-    out_c = 5
-    kernel_size = 6
-    stride = 3
-    padding = 2
-    dilation = 2
-    bias = False
-    patch_merge = PatchMerging(
-        in_channels=in_c,
-        out_channels=out_c,
-        kernel_size=kernel_size,
-        stride=stride,
-        padding=padding,
-        dilation=dilation,
-        bias=bias)
-    B, L, C = 1, 100, 4
-    input_size = (10, 10)
-    x = torch.rand(B, L, C)
-    x_out, out_size = patch_merge(x, input_size)
-    assert x_out.size() == (1, 4, 5)
-    assert out_size == (2, 2)
-    # assert out size is consistent with real output
-    assert x_out.size(1) == out_size[0] * out_size[1]
-
-    # Test with adaptive padding
-    for padding in ('same', 'corner'):
-        in_c = 2
-        out_c = 3
-        B = 2
-
-        # test stride is 1
-        input_size = (5, 5)
-        kernel_size = (5, 5)
-        stride = (1, 1)
-        dilation = 1
-        bias = False
-        L = input_size[0] * input_size[1]
-
-        x = torch.rand(B, L, in_c)
-        patch_merge = PatchMerging(
-            in_channels=in_c,
-            out_channels=out_c,
-            kernel_size=kernel_size,
-            stride=stride,
-            padding=padding,
-            dilation=dilation,
-            bias=bias)
-
-        x_out, out_size = patch_merge(x, input_size)
-        assert x_out.size() == (B, 25, 3)
-        assert out_size == (5, 5)
-        assert x_out.size(1) == out_size[0] * out_size[1]
-
-        # test kernel_size == stride
-        input_size = (5, 5)
-        kernel_size = (5, 5)
-        stride = (5, 5)
-        dilation = 1
-        bias = False
-        L = input_size[0] * input_size[1]
-
-        x = torch.rand(B, L, in_c)
-        patch_merge = PatchMerging(
-            in_channels=in_c,
-            out_channels=out_c,
-            kernel_size=kernel_size,
-            stride=stride,
-            padding=padding,
-            dilation=dilation,
-            bias=bias)
-
-        x_out, out_size = patch_merge(x, input_size)
-        assert x_out.size() == (B, 1, 3)
-        assert out_size == (1, 1)
-        assert x_out.size(1) == out_size[0] * out_size[1]
-
-        # test kernel_size == stride
-        input_size = (6, 5)
-        kernel_size = (5, 5)
-        stride = (5, 5)
-        dilation = 1
-        bias = False
-        L = input_size[0] * input_size[1]
-
-        x = torch.rand(B, L, in_c)
-        patch_merge = PatchMerging(
-            in_channels=in_c,
-            out_channels=out_c,
-            kernel_size=kernel_size,
-            stride=stride,
-            padding=padding,
-            dilation=dilation,
-            bias=bias)
-
-        x_out, out_size = patch_merge(x, input_size)
-        assert x_out.size() == (B, 2, 3)
-        assert out_size == (2, 1)
-        assert x_out.size(1) == out_size[0] * out_size[1]
-
-        # test different kernel_size with different stride
-        input_size = (6, 5)
-        kernel_size = (6, 2)
-        stride = (6, 2)
-        dilation = 1
-        bias = False
-        L = input_size[0] * input_size[1]
-
-        x = torch.rand(B, L, in_c)
-        patch_merge = PatchMerging(
-            in_channels=in_c,
-            out_channels=out_c,
-            kernel_size=kernel_size,
-            stride=stride,
-            padding=padding,
-            dilation=dilation,
-            bias=bias)
-
-        x_out, out_size = patch_merge(x, input_size)
-        assert x_out.size() == (B, 3, 3)
-        assert out_size == (1, 3)
-        assert x_out.size(1) == out_size[0] * out_size[1]
diff --git a/mmsegmentation/tests/test_models/test_utils/test_shape_convert.py b/mmsegmentation/tests/test_models/test_utils/test_shape_convert.py
deleted file mode 100644
index 60e87f3..0000000
--- a/mmsegmentation/tests/test_models/test_utils/test_shape_convert.py
+++ /dev/null
@@ -1,89 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-
-from mmseg.models.utils import (nchw2nlc2nchw, nchw_to_nlc, nlc2nchw2nlc,
-                                nlc_to_nchw)
-
-
-def test_nchw2nlc2nchw():
-    # Test nchw2nlc2nchw function
-    shape_nchw = (4, 2, 5, 5)
-    shape_nlc = (4, 25, 2)
-
-    def test_func(x):
-        assert x.shape == torch.Size(shape_nlc)
-        return x
-
-    x = torch.rand(*shape_nchw)
-    output = nchw2nlc2nchw(test_func, x)
-    assert output.shape == torch.Size(shape_nchw)
-
-    def test_func2(x, arg):
-        assert x.shape == torch.Size(shape_nlc)
-        assert arg == 100
-        return x
-
-    x = torch.rand(*shape_nchw)
-    output = nchw2nlc2nchw(test_func2, x, arg=100)
-    assert output.shape == torch.Size(shape_nchw)
-
-    def test_func3(x):
-        assert x.is_contiguous()
-        assert x.shape == torch.Size(shape_nlc)
-        return x
-
-    x = torch.rand(*shape_nchw)
-    output = nchw2nlc2nchw(test_func3, x, contiguous=True)
-    assert output.shape == torch.Size(shape_nchw)
-    assert output.is_contiguous()
-
-
-def test_nlc2nchw2nlc():
-    # Test nlc2nchw2nlc function
-    shape_nchw = (4, 2, 5, 5)
-    shape_nlc = (4, 25, 2)
-
-    def test_func(x):
-        assert x.shape == torch.Size(shape_nchw)
-        return x
-
-    x = torch.rand(*shape_nlc)
-    output = nlc2nchw2nlc(test_func, x, shape_nchw[2:])
-    assert output.shape == torch.Size(shape_nlc)
-
-    def test_func2(x, arg):
-        assert x.shape == torch.Size(shape_nchw)
-        assert arg == 100
-        return x
-
-    x = torch.rand(*shape_nlc)
-    output = nlc2nchw2nlc(test_func2, x, shape_nchw[2:], arg=100)
-    assert output.shape == torch.Size(shape_nlc)
-
-    def test_func3(x):
-        assert x.is_contiguous()
-        assert x.shape == torch.Size(shape_nchw)
-        return x
-
-    x = torch.rand(*shape_nlc)
-    output = nlc2nchw2nlc(test_func3, x, shape_nchw[2:], contiguous=True)
-    assert output.shape == torch.Size(shape_nlc)
-    assert output.is_contiguous()
-
-
-def test_nchw_to_nlc():
-    # Test nchw_to_nlc function
-    shape_nchw = (4, 2, 5, 5)
-    shape_nlc = (4, 25, 2)
-    x = torch.rand(*shape_nchw)
-    y = nchw_to_nlc(x)
-    assert y.shape == torch.Size(shape_nlc)
-
-
-def test_nlc_to_nchw():
-    # Test nlc_to_nchw function
-    shape_nchw = (4, 2, 5, 5)
-    shape_nlc = (4, 25, 2)
-    x = torch.rand(*shape_nlc)
-    y = nlc_to_nchw(x, (5, 5))
-    assert y.shape == torch.Size(shape_nchw)
diff --git a/mmsegmentation/tests/test_sampler.py b/mmsegmentation/tests/test_sampler.py
deleted file mode 100644
index 322be95..0000000
--- a/mmsegmentation/tests/test_sampler.py
+++ /dev/null
@@ -1,78 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import pytest
-import torch
-
-from mmseg.models.decode_heads import FCNHead
-from mmseg.structures import OHEMPixelSampler
-
-
-def _context_for_ohem():
-    return FCNHead(in_channels=32, channels=16, num_classes=19)
-
-
-def _context_for_ohem_multiple_loss():
-    return FCNHead(
-        in_channels=32,
-        channels=16,
-        num_classes=19,
-        loss_decode=[
-            dict(type='CrossEntropyLoss', loss_name='loss_1'),
-            dict(type='CrossEntropyLoss', loss_name='loss_2')
-        ])
-
-
-def test_ohem_sampler():
-
-    with pytest.raises(AssertionError):
-        # seg_logit and seg_label must be of the same size
-        sampler = OHEMPixelSampler(context=_context_for_ohem())
-        seg_logit = torch.randn(1, 19, 45, 45)
-        seg_label = torch.randint(0, 19, size=(1, 1, 89, 89))
-        sampler.sample(seg_logit, seg_label)
-
-    # test with thresh
-    sampler = OHEMPixelSampler(
-        context=_context_for_ohem(), thresh=0.7, min_kept=200)
-    seg_logit = torch.randn(1, 19, 45, 45)
-    seg_label = torch.randint(0, 19, size=(1, 1, 45, 45))
-    seg_weight = sampler.sample(seg_logit, seg_label)
-    assert seg_weight.shape[0] == seg_logit.shape[0]
-    assert seg_weight.shape[1:] == seg_logit.shape[2:]
-    assert seg_weight.sum() > 200
-
-    # test w.o thresh
-    sampler = OHEMPixelSampler(context=_context_for_ohem(), min_kept=200)
-    seg_logit = torch.randn(1, 19, 45, 45)
-    seg_label = torch.randint(0, 19, size=(1, 1, 45, 45))
-    seg_weight = sampler.sample(seg_logit, seg_label)
-    assert seg_weight.shape[0] == seg_logit.shape[0]
-    assert seg_weight.shape[1:] == seg_logit.shape[2:]
-    assert seg_weight.sum() == 200
-
-    # test multiple losses case
-    with pytest.raises(AssertionError):
-        # seg_logit and seg_label must be of the same size
-        sampler = OHEMPixelSampler(context=_context_for_ohem_multiple_loss())
-        seg_logit = torch.randn(1, 19, 45, 45)
-        seg_label = torch.randint(0, 19, size=(1, 1, 89, 89))
-        sampler.sample(seg_logit, seg_label)
-
-    # test with thresh in multiple losses case
-    sampler = OHEMPixelSampler(
-        context=_context_for_ohem_multiple_loss(), thresh=0.7, min_kept=200)
-    seg_logit = torch.randn(1, 19, 45, 45)
-    seg_label = torch.randint(0, 19, size=(1, 1, 45, 45))
-    seg_weight = sampler.sample(seg_logit, seg_label)
-    assert seg_weight.shape[0] == seg_logit.shape[0]
-    assert seg_weight.shape[1:] == seg_logit.shape[2:]
-    assert seg_weight.sum() > 200
-
-    # test w.o thresh in multiple losses case
-    sampler = OHEMPixelSampler(
-        context=_context_for_ohem_multiple_loss(), min_kept=200)
-    seg_logit = torch.randn(1, 19, 45, 45)
-    seg_label = torch.randint(0, 19, size=(1, 1, 45, 45))
-    seg_weight = sampler.sample(seg_logit, seg_label)
-    assert seg_weight.shape[0] == seg_logit.shape[0]
-    assert seg_weight.shape[1:] == seg_logit.shape[2:]
-    assert seg_weight.sum() == 200
diff --git a/mmsegmentation/tests/test_structures/test_seg_data_sample.py b/mmsegmentation/tests/test_structures/test_seg_data_sample.py
deleted file mode 100644
index 37796b6..0000000
--- a/mmsegmentation/tests/test_structures/test_seg_data_sample.py
+++ /dev/null
@@ -1,77 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from unittest import TestCase
-
-import numpy as np
-import pytest
-import torch
-from mmengine.structures import PixelData
-
-from mmseg.structures import SegDataSample
-
-
-def _equal(a, b):
-    if isinstance(a, (torch.Tensor, np.ndarray)):
-        return (a == b).all()
-    else:
-        return a == b
-
-
-class TestSegDataSample(TestCase):
-
-    def test_init(self):
-        meta_info = dict(
-            img_size=[256, 256],
-            scale_factor=np.array([1.5, 1.5]),
-            img_shape=torch.rand(4))
-
-        seg_data_sample = SegDataSample(metainfo=meta_info)
-        assert 'img_size' in seg_data_sample
-        assert seg_data_sample.img_size == [256, 256]
-        assert seg_data_sample.get('img_size') == [256, 256]
-
-    def test_setter(self):
-        seg_data_sample = SegDataSample()
-
-        # test gt_sem_seg
-        gt_sem_seg_data = dict(sem_seg=torch.rand(5, 4, 2))
-        gt_sem_seg = PixelData(**gt_sem_seg_data)
-        seg_data_sample.gt_sem_seg = gt_sem_seg
-        assert 'gt_sem_seg' in seg_data_sample
-        assert _equal(seg_data_sample.gt_sem_seg.sem_seg,
-                      gt_sem_seg_data['sem_seg'])
-
-        # test pred_sem_seg
-        pred_sem_seg_data = dict(sem_seg=torch.rand(5, 4, 2))
-        pred_sem_seg = PixelData(**pred_sem_seg_data)
-        seg_data_sample.pred_sem_seg = pred_sem_seg
-        assert 'pred_sem_seg' in seg_data_sample
-        assert _equal(seg_data_sample.pred_sem_seg.sem_seg,
-                      pred_sem_seg_data['sem_seg'])
-
-        # test seg_logits
-        seg_logits_data = dict(sem_seg=torch.rand(5, 4, 2))
-        seg_logits = PixelData(**seg_logits_data)
-        seg_data_sample.seg_logits = seg_logits
-        assert 'seg_logits' in seg_data_sample
-        assert _equal(seg_data_sample.seg_logits.sem_seg,
-                      seg_logits_data['sem_seg'])
-
-        # test type error
-        with pytest.raises(AssertionError):
-            seg_data_sample.gt_sem_seg = torch.rand(2, 4)
-
-        with pytest.raises(AssertionError):
-            seg_data_sample.pred_sem_seg = torch.rand(2, 4)
-
-        with pytest.raises(AssertionError):
-            seg_data_sample.seg_logits = torch.rand(2, 4)
-
-    def test_deleter(self):
-        seg_data_sample = SegDataSample()
-
-        pred_sem_seg_data = dict(sem_seg=torch.rand(5, 4, 2))
-        pred_sem_seg = PixelData(**pred_sem_seg_data)
-        seg_data_sample.pred_sem_seg = pred_sem_seg
-        assert 'pred_sem_seg' in seg_data_sample
-        del seg_data_sample.pred_sem_seg
-        assert 'pred_sem_seg' not in seg_data_sample
diff --git a/mmsegmentation/tests/test_utils/test_io.py b/mmsegmentation/tests/test_utils/test_io.py
deleted file mode 100644
index 05abd27..0000000
--- a/mmsegmentation/tests/test_utils/test_io.py
+++ /dev/null
@@ -1,33 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import os.path as osp
-
-import numpy as np
-import pytest
-from mmengine import FileClient
-
-from mmseg.utils import datafrombytes
-
-
-@pytest.mark.parametrize(
-    ['backend', 'suffix'],
-    [['nifti', '.nii.gz'], ['numpy', '.npy'], ['pickle', '.pkl']])
-def test_datafrombytes(backend, suffix):
-
-    file_client = FileClient('disk')
-    file_path = osp.join(osp.dirname(__file__), '../data/biomedical' + suffix)
-    bytes = file_client.get(file_path)
-    data = datafrombytes(bytes, backend)
-
-    if backend == 'pickle':
-        # test pickle loading
-        assert isinstance(data, dict)
-    else:
-        assert isinstance(data, np.ndarray)
-        if backend == 'nifti':
-            # test nifti file loading
-            assert len(data.shape) == 3
-        else:
-            # test npy file loading
-            # testing data biomedical.npy includes data and label
-            assert len(data.shape) == 4
-            assert data.shape[0] == 2
diff --git a/mmsegmentation/tests/test_utils/test_set_env.py b/mmsegmentation/tests/test_utils/test_set_env.py
deleted file mode 100644
index 86a2d29..0000000
--- a/mmsegmentation/tests/test_utils/test_set_env.py
+++ /dev/null
@@ -1,39 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import datetime
-import sys
-from unittest import TestCase
-
-from mmengine import DefaultScope
-
-from mmseg.utils import register_all_modules
-
-
-class TestSetupEnv(TestCase):
-
-    def test_register_all_modules(self):
-        from mmseg.registry import DATASETS
-
-        # not init default scope
-        sys.modules.pop('mmseg.datasets', None)
-        sys.modules.pop('mmseg.datasets.ade', None)
-        DATASETS._module_dict.pop('ADE20KDataset', None)
-        self.assertFalse('ADE20KDataset' in DATASETS.module_dict)
-        register_all_modules(init_default_scope=False)
-        self.assertTrue('ADE20KDataset' in DATASETS.module_dict)
-
-        # init default scope
-        sys.modules.pop('mmseg.datasets')
-        sys.modules.pop('mmseg.datasets.ade')
-        DATASETS._module_dict.pop('ADE20KDataset', None)
-        self.assertFalse('ADE20KDataset' in DATASETS.module_dict)
-        register_all_modules(init_default_scope=True)
-        self.assertTrue('ADE20KDataset' in DATASETS.module_dict)
-        self.assertEqual(DefaultScope.get_current_instance().scope_name,
-                         'mmseg')
-
-        # init default scope when another scope is init
-        name = f'test-{datetime.datetime.now()}'
-        DefaultScope.get_instance(name, scope_name='test')
-        with self.assertWarnsRegex(
-                Warning, 'The current default scope "test" is not "mmseg"'):
-            register_all_modules(init_default_scope=True)
diff --git a/mmsegmentation/tests/test_visualization/test_local_visualizer.py b/mmsegmentation/tests/test_visualization/test_local_visualizer.py
deleted file mode 100644
index e3b2a88..0000000
--- a/mmsegmentation/tests/test_visualization/test_local_visualizer.py
+++ /dev/null
@@ -1,213 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import os
-import os.path as osp
-import tempfile
-from unittest import TestCase
-
-import cv2
-import mmcv
-import numpy as np
-import torch
-from mmengine.structures import PixelData
-
-from mmseg.structures import SegDataSample
-from mmseg.visualization import SegLocalVisualizer
-
-
-class TestSegLocalVisualizer(TestCase):
-
-    def test_add_datasample(self):
-        h = 10
-        w = 12
-        num_class = 2
-        out_file = 'out_file'
-
-        image = np.random.randint(0, 256, size=(h, w, 3)).astype('uint8')
-
-        # test gt_sem_seg
-        gt_sem_seg_data = dict(data=torch.randint(0, num_class, (1, h, w)))
-        gt_sem_seg = PixelData(**gt_sem_seg_data)
-
-        def test_add_datasample_forward(gt_sem_seg):
-            data_sample = SegDataSample()
-            data_sample.gt_sem_seg = gt_sem_seg
-
-            with tempfile.TemporaryDirectory() as tmp_dir:
-                seg_local_visualizer = SegLocalVisualizer(
-                    vis_backends=[dict(type='LocalVisBackend')],
-                    save_dir=tmp_dir)
-                seg_local_visualizer.dataset_meta = dict(
-                    classes=('background', 'foreground'),
-                    palette=[[120, 120, 120], [6, 230, 230]])
-
-                # test out_file
-                seg_local_visualizer.add_datasample(out_file, image,
-                                                    data_sample)
-
-                assert os.path.exists(
-                    osp.join(tmp_dir, 'vis_data', 'vis_image',
-                             out_file + '_0.png'))
-                drawn_img = cv2.imread(
-                    osp.join(tmp_dir, 'vis_data', 'vis_image',
-                             out_file + '_0.png'))
-                assert drawn_img.shape == (h, w, 3)
-
-                # test gt_instances and pred_instances
-                pred_sem_seg_data = dict(
-                    data=torch.randint(0, num_class, (1, h, w)))
-                pred_sem_seg = PixelData(**pred_sem_seg_data)
-
-                data_sample.pred_sem_seg = pred_sem_seg
-
-                seg_local_visualizer.add_datasample(out_file, image,
-                                                    data_sample)
-                self._assert_image_and_shape(
-                    osp.join(tmp_dir, 'vis_data', 'vis_image',
-                             out_file + '_0.png'), (h, w * 2, 3))
-
-                seg_local_visualizer.add_datasample(
-                    out_file, image, data_sample, draw_gt=False)
-                self._assert_image_and_shape(
-                    osp.join(tmp_dir, 'vis_data', 'vis_image',
-                             out_file + '_0.png'), (h, w, 3))
-
-        if torch.cuda.is_available():
-            test_add_datasample_forward(gt_sem_seg.cuda())
-        test_add_datasample_forward(gt_sem_seg)
-
-    def test_cityscapes_add_datasample(self):
-        h = 128
-        w = 256
-        num_class = 19
-        out_file = 'out_file_cityscapes'
-
-        image = mmcv.imread(
-            osp.join(
-                osp.dirname(__file__),
-                '../data/pseudo_cityscapes_dataset/leftImg8bit/val/frankfurt/frankfurt_000000_000294_leftImg8bit.png'  # noqa
-            ),
-            'color')
-        sem_seg = mmcv.imread(
-            osp.join(
-                osp.dirname(__file__),
-                '../data/pseudo_cityscapes_dataset/gtFine/val/frankfurt/frankfurt_000000_000294_gtFine_labelTrainIds.png'  # noqa
-            ),
-            'unchanged')
-        sem_seg = torch.unsqueeze(torch.from_numpy(sem_seg), 0)
-        gt_sem_seg_data = dict(data=sem_seg)
-        gt_sem_seg = PixelData(**gt_sem_seg_data)
-
-        def test_cityscapes_add_datasample_forward(gt_sem_seg):
-            data_sample = SegDataSample()
-            data_sample.gt_sem_seg = gt_sem_seg
-
-            with tempfile.TemporaryDirectory() as tmp_dir:
-                seg_local_visualizer = SegLocalVisualizer(
-                    vis_backends=[dict(type='LocalVisBackend')],
-                    save_dir=tmp_dir)
-                seg_local_visualizer.dataset_meta = dict(
-                    classes=('road', 'sidewalk', 'building', 'wall', 'fence',
-                             'pole', 'traffic light', 'traffic sign',
-                             'vegetation', 'terrain', 'sky', 'person', 'rider',
-                             'car', 'truck', 'bus', 'train', 'motorcycle',
-                             'bicycle'),
-                    palette=[[128, 64, 128], [244, 35, 232], [70, 70, 70],
-                             [102, 102, 156], [190, 153, 153], [153, 153, 153],
-                             [250, 170, 30], [220, 220, 0], [107, 142, 35],
-                             [152, 251, 152], [70, 130, 180], [220, 20, 60],
-                             [255, 0, 0], [0, 0, 142], [0, 0, 70],
-                             [0, 60, 100], [0, 80, 100], [0, 0, 230],
-                             [119, 11, 32]])
-                # test out_file
-                seg_local_visualizer.add_datasample(
-                    out_file,
-                    image,
-                    data_sample,
-                    out_file=osp.join(tmp_dir, 'test.png'))
-                self._assert_image_and_shape(
-                    osp.join(tmp_dir, 'test.png'), (h, w, 3))
-
-                # test gt_instances and pred_instances
-                pred_sem_seg_data = dict(
-                    data=torch.randint(0, num_class, (1, h, w)))
-                pred_sem_seg = PixelData(**pred_sem_seg_data)
-
-                data_sample.pred_sem_seg = pred_sem_seg
-
-                # test draw prediction with gt
-                seg_local_visualizer.add_datasample(out_file, image,
-                                                    data_sample)
-                self._assert_image_and_shape(
-                    osp.join(tmp_dir, 'vis_data', 'vis_image',
-                             out_file + '_0.png'), (h, w * 2, 3))
-                # test draw prediction without gt
-                seg_local_visualizer.add_datasample(
-                    out_file, image, data_sample, draw_gt=False)
-                self._assert_image_and_shape(
-                    osp.join(tmp_dir, 'vis_data', 'vis_image',
-                             out_file + '_0.png'), (h, w, 3))
-
-        if torch.cuda.is_available():
-            test_cityscapes_add_datasample_forward(gt_sem_seg.cuda())
-        test_cityscapes_add_datasample_forward(gt_sem_seg)
-
-    def _assert_image_and_shape(self, out_file, out_shape):
-        assert os.path.exists(out_file)
-        drawn_img = cv2.imread(out_file)
-        assert drawn_img.shape == out_shape
-
-    def test_add_datasample_depth(self):
-        h = 10
-        w = 12
-        out_file = 'out_file'
-
-        image = np.random.randint(0, 256, size=(h, w, 3)).astype('uint8')
-
-        # test gt_depth_map
-        gt_depth_map = PixelData(data=torch.rand(1, h, w))
-
-        def test_add_datasample_forward_depth(gt_depth_map):
-            data_sample = SegDataSample()
-            data_sample.gt_depth_map = gt_depth_map
-
-            with tempfile.TemporaryDirectory() as tmp_dir:
-                seg_local_visualizer = SegLocalVisualizer(
-                    vis_backends=[dict(type='LocalVisBackend')],
-                    save_dir=tmp_dir)
-                seg_local_visualizer.dataset_meta = dict(
-                    classes=('background', 'foreground'),
-                    palette=[[120, 120, 120], [6, 230, 230]])
-
-                # test out_file
-                seg_local_visualizer.add_datasample(out_file, image,
-                                                    data_sample)
-
-                assert os.path.exists(
-                    osp.join(tmp_dir, 'vis_data', 'vis_image',
-                             out_file + '_0.png'))
-                drawn_img = cv2.imread(
-                    osp.join(tmp_dir, 'vis_data', 'vis_image',
-                             out_file + '_0.png'))
-                assert drawn_img.shape == (h * 2, w, 3)
-
-                # test gt_instances and pred_instances
-
-                pred_depth_map = PixelData(data=torch.rand(1, h, w))
-
-                data_sample.pred_depth_map = pred_depth_map
-
-                seg_local_visualizer.add_datasample(out_file, image,
-                                                    data_sample)
-                self._assert_image_and_shape(
-                    osp.join(tmp_dir, 'vis_data', 'vis_image',
-                             out_file + '_0.png'), (h * 2, w * 2, 3))
-
-                seg_local_visualizer.add_datasample(
-                    out_file, image, data_sample, draw_gt=False)
-                self._assert_image_and_shape(
-                    osp.join(tmp_dir, 'vis_data', 'vis_image',
-                             out_file + '_0.png'), (h * 2, w, 3))
-
-        if torch.cuda.is_available():
-            test_add_datasample_forward_depth(gt_depth_map.cuda())
-        test_add_datasample_forward_depth(gt_depth_map)
diff --git a/mmsegmentation/tools/analysis_tools/analyze_logs.py b/mmsegmentation/tools/analysis_tools/analyze_logs.py
deleted file mode 100644
index 7464d23..0000000
--- a/mmsegmentation/tools/analysis_tools/analyze_logs.py
+++ /dev/null
@@ -1,130 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-"""Modified from https://github.com/open-
-mmlab/mmdetection/blob/master/tools/analysis_tools/analyze_logs.py."""
-import argparse
-import json
-from collections import defaultdict
-
-import matplotlib.pyplot as plt
-import seaborn as sns
-
-
-def plot_curve(log_dicts, args):
-    if args.backend is not None:
-        plt.switch_backend(args.backend)
-    sns.set_style(args.style)
-    # if legend is None, use {filename}_{key} as legend
-    legend = args.legend
-    if legend is None:
-        legend = []
-        for json_log in args.json_logs:
-            for metric in args.keys:
-                legend.append(f'{json_log}_{metric}')
-    assert len(legend) == (len(args.json_logs) * len(args.keys))
-    metrics = args.keys
-
-    num_metrics = len(metrics)
-    for i, log_dict in enumerate(log_dicts):
-        epochs = list(log_dict.keys())
-        for j, metric in enumerate(metrics):
-            print(f'plot curve of {args.json_logs[i]}, metric is {metric}')
-            plot_epochs = []
-            plot_iters = []
-            plot_values = []
-            # In some log files exist lines of validation,
-            # `mode` list is used to only collect iter number
-            # of training line.
-            for epoch in epochs:
-                epoch_logs = log_dict[epoch]
-                if metric not in epoch_logs.keys():
-                    continue
-                if metric in ['mIoU', 'mAcc', 'aAcc']:
-                    plot_epochs.append(epoch)
-                    plot_values.append(epoch_logs[metric][0])
-                else:
-                    for idx in range(len(epoch_logs[metric])):
-                        plot_iters.append(epoch_logs['step'][idx])
-                        plot_values.append(epoch_logs[metric][idx])
-            ax = plt.gca()
-            label = legend[i * num_metrics + j]
-            if metric in ['mIoU', 'mAcc', 'aAcc']:
-                ax.set_xticks(plot_epochs)
-                plt.xlabel('step')
-                plt.plot(plot_epochs, plot_values, label=label, marker='o')
-            else:
-                plt.xlabel('iter')
-                plt.plot(plot_iters, plot_values, label=label, linewidth=0.5)
-        plt.legend()
-        if args.title is not None:
-            plt.title(args.title)
-    if args.out is None:
-        plt.show()
-    else:
-        print(f'save curve to: {args.out}')
-        plt.savefig(args.out)
-        plt.cla()
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(description='Analyze Json Log')
-    parser.add_argument(
-        'json_logs',
-        type=str,
-        nargs='+',
-        help='path of train log in json format')
-    parser.add_argument(
-        '--keys',
-        type=str,
-        nargs='+',
-        default=['mIoU'],
-        help='the metric that you want to plot')
-    parser.add_argument('--title', type=str, help='title of figure')
-    parser.add_argument(
-        '--legend',
-        type=str,
-        nargs='+',
-        default=None,
-        help='legend of each plot')
-    parser.add_argument(
-        '--backend', type=str, default=None, help='backend of plt')
-    parser.add_argument(
-        '--style', type=str, default='dark', help='style of plt')
-    parser.add_argument('--out', type=str, default=None)
-    args = parser.parse_args()
-    return args
-
-
-def load_json_logs(json_logs):
-    # load and convert json_logs to log_dict, key is step, value is a sub dict
-    # keys of sub dict is different metrics
-    # value of sub dict is a list of corresponding values of all iterations
-    log_dicts = [dict() for _ in json_logs]
-    prev_step = 0
-    for json_log, log_dict in zip(json_logs, log_dicts):
-        with open(json_log) as log_file:
-            for line in log_file:
-                log = json.loads(line.strip())
-                # the final step in json file is 0.
-                if 'step' in log and log['step'] != 0:
-                    step = log['step']
-                    prev_step = step
-                else:
-                    step = prev_step
-                if step not in log_dict:
-                    log_dict[step] = defaultdict(list)
-                for k, v in log.items():
-                    log_dict[step][k].append(v)
-    return log_dicts
-
-
-def main():
-    args = parse_args()
-    json_logs = args.json_logs
-    for json_log in json_logs:
-        assert json_log.endswith('.json')
-    log_dicts = load_json_logs(json_logs)
-    plot_curve(log_dicts, args)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/analysis_tools/benchmark.py b/mmsegmentation/tools/analysis_tools/benchmark.py
deleted file mode 100644
index afaeaba..0000000
--- a/mmsegmentation/tools/analysis_tools/benchmark.py
+++ /dev/null
@@ -1,121 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os.path as osp
-import time
-
-import numpy as np
-import torch
-from mmengine import Config
-from mmengine.fileio import dump
-from mmengine.model.utils import revert_sync_batchnorm
-from mmengine.registry import init_default_scope
-from mmengine.runner import Runner, load_checkpoint
-from mmengine.utils import mkdir_or_exist
-
-from mmseg.registry import MODELS
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(description='MMSeg benchmark a model')
-    parser.add_argument('config', help='test config file path')
-    parser.add_argument('checkpoint', help='checkpoint file')
-    parser.add_argument(
-        '--log-interval', type=int, default=50, help='interval of logging')
-    parser.add_argument(
-        '--work-dir',
-        help=('if specified, the results will be dumped '
-              'into the directory as json'))
-    parser.add_argument('--repeat-times', type=int, default=1)
-    args = parser.parse_args()
-    return args
-
-
-def main():
-    args = parse_args()
-    cfg = Config.fromfile(args.config)
-
-    init_default_scope(cfg.get('default_scope', 'mmseg'))
-
-    timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime())
-    if args.work_dir is not None:
-        mkdir_or_exist(osp.abspath(args.work_dir))
-        json_file = osp.join(args.work_dir, f'fps_{timestamp}.json')
-    else:
-        # use config filename as default work_dir if cfg.work_dir is None
-        work_dir = osp.join('./work_dirs',
-                            osp.splitext(osp.basename(args.config))[0])
-        mkdir_or_exist(osp.abspath(work_dir))
-        json_file = osp.join(work_dir, f'fps_{timestamp}.json')
-
-    repeat_times = args.repeat_times
-    # set cudnn_benchmark
-    torch.backends.cudnn.benchmark = False
-    cfg.model.pretrained = None
-
-    benchmark_dict = dict(config=args.config, unit='img / s')
-    overall_fps_list = []
-    cfg.test_dataloader.batch_size = 1
-    for time_index in range(repeat_times):
-        print(f'Run {time_index + 1}:')
-        # build the dataloader
-        data_loader = Runner.build_dataloader(cfg.test_dataloader)
-
-        # build the model and load checkpoint
-        cfg.model.train_cfg = None
-        model = MODELS.build(cfg.model)
-
-        if 'checkpoint' in args and osp.exists(args.checkpoint):
-            load_checkpoint(model, args.checkpoint, map_location='cpu')
-
-        if torch.cuda.is_available():
-            model = model.cuda()
-
-        model = revert_sync_batchnorm(model)
-
-        model.eval()
-
-        # the first several iterations may be very slow so skip them
-        num_warmup = 5
-        pure_inf_time = 0
-        total_iters = 200
-
-        # benchmark with 200 batches and take the average
-        for i, data in enumerate(data_loader):
-            data = model.data_preprocessor(data, True)
-            inputs = data['inputs']
-            data_samples = data['data_samples']
-            if torch.cuda.is_available():
-                torch.cuda.synchronize()
-            start_time = time.perf_counter()
-
-            with torch.no_grad():
-                model(inputs, data_samples, mode='predict')
-
-            if torch.cuda.is_available():
-                torch.cuda.synchronize()
-            elapsed = time.perf_counter() - start_time
-
-            if i >= num_warmup:
-                pure_inf_time += elapsed
-                if (i + 1) % args.log_interval == 0:
-                    fps = (i + 1 - num_warmup) / pure_inf_time
-                    print(f'Done image [{i + 1:<3}/ {total_iters}], '
-                          f'fps: {fps:.2f} img / s')
-
-            if (i + 1) == total_iters:
-                fps = (i + 1 - num_warmup) / pure_inf_time
-                print(f'Overall fps: {fps:.2f} img / s\n')
-                benchmark_dict[f'overall_fps_{time_index + 1}'] = round(fps, 2)
-                overall_fps_list.append(fps)
-                break
-    benchmark_dict['average_fps'] = round(np.mean(overall_fps_list), 2)
-    benchmark_dict['fps_variance'] = round(np.var(overall_fps_list), 4)
-    print(f'Average fps of {repeat_times} evaluations: '
-          f'{benchmark_dict["average_fps"]}')
-    print(f'The variance of {repeat_times} evaluations: '
-          f'{benchmark_dict["fps_variance"]}')
-    dump(benchmark_dict, json_file, indent=4)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/analysis_tools/browse_dataset.py b/mmsegmentation/tools/analysis_tools/browse_dataset.py
deleted file mode 100644
index 925c14a..0000000
--- a/mmsegmentation/tools/analysis_tools/browse_dataset.py
+++ /dev/null
@@ -1,77 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os.path as osp
-
-from mmengine.config import Config, DictAction
-from mmengine.utils import ProgressBar
-
-from mmseg.registry import DATASETS, VISUALIZERS
-from mmseg.utils import register_all_modules
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(description='Browse a dataset')
-    parser.add_argument('config', help='train config file path')
-    parser.add_argument(
-        '--output-dir',
-        default=None,
-        type=str,
-        help='If there is no display interface, you can save it')
-    parser.add_argument('--not-show', default=False, action='store_true')
-    parser.add_argument(
-        '--show-interval',
-        type=float,
-        default=2,
-        help='the interval of show (s)')
-    parser.add_argument(
-        '--cfg-options',
-        nargs='+',
-        action=DictAction,
-        help='override some settings in the used config, the key-value pair '
-        'in xxx=yyy format will be merged into config file. If the value to '
-        'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
-        'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
-        'Note that the quotation marks are necessary and that no white space '
-        'is allowed.')
-    args = parser.parse_args()
-    return args
-
-
-def main():
-    args = parse_args()
-    cfg = Config.fromfile(args.config)
-    if args.cfg_options is not None:
-        cfg.merge_from_dict(args.cfg_options)
-
-    # register all modules in mmdet into the registries
-    register_all_modules()
-
-    dataset = DATASETS.build(cfg.train_dataloader.dataset)
-    visualizer = VISUALIZERS.build(cfg.visualizer)
-    visualizer.dataset_meta = dataset.metainfo
-
-    progress_bar = ProgressBar(len(dataset))
-    for item in dataset:
-        img = item['inputs'].permute(1, 2, 0).numpy()
-        img = img[..., [2, 1, 0]]  # bgr to rgb
-        data_sample = item['data_samples'].numpy()
-        img_path = osp.basename(item['data_samples'].img_path)
-
-        out_file = osp.join(
-            args.output_dir,
-            osp.basename(img_path)) if args.output_dir is not None else None
-
-        visualizer.add_datasample(
-            name=osp.basename(img_path),
-            image=img,
-            data_sample=data_sample,
-            draw_gt=True,
-            draw_pred=False,
-            wait_time=args.show_interval,
-            out_file=out_file,
-            show=not args.not_show)
-        progress_bar.update()
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/analysis_tools/confusion_matrix.py b/mmsegmentation/tools/analysis_tools/confusion_matrix.py
deleted file mode 100644
index 39756cd..0000000
--- a/mmsegmentation/tools/analysis_tools/confusion_matrix.py
+++ /dev/null
@@ -1,197 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os
-
-import matplotlib.pyplot as plt
-import numpy as np
-from matplotlib.ticker import MultipleLocator
-from mmengine.config import Config, DictAction
-from mmengine.registry import init_default_scope
-from mmengine.utils import mkdir_or_exist, progressbar
-from PIL import Image
-
-from mmseg.registry import DATASETS
-
-init_default_scope('mmseg')
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Generate confusion matrix from segmentation results')
-    parser.add_argument('config', help='test config file path')
-    parser.add_argument(
-        'prediction_path', help='prediction path where test folder result')
-    parser.add_argument(
-        'save_dir', help='directory where confusion matrix will be saved')
-    parser.add_argument(
-        '--show', action='store_true', help='show confusion matrix')
-    parser.add_argument(
-        '--color-theme',
-        default='winter',
-        help='theme of the matrix color map')
-    parser.add_argument(
-        '--title',
-        default='Normalized Confusion Matrix',
-        help='title of the matrix color map')
-    parser.add_argument(
-        '--cfg-options',
-        nargs='+',
-        action=DictAction,
-        help='override some settings in the used config, the key-value pair '
-        'in xxx=yyy format will be merged into config file. If the value to '
-        'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
-        'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
-        'Note that the quotation marks are necessary and that no white space '
-        'is allowed.')
-    args = parser.parse_args()
-    return args
-
-
-def calculate_confusion_matrix(dataset, results):
-    """Calculate the confusion matrix.
-
-    Args:
-        dataset (Dataset): Test or val dataset.
-        results (list[ndarray]): A list of segmentation results in each image.
-    """
-    n = len(dataset.METAINFO['classes'])
-    confusion_matrix = np.zeros(shape=[n, n])
-    assert len(dataset) == len(results)
-    ignore_index = dataset.ignore_index
-    reduce_zero_label = dataset.reduce_zero_label
-    prog_bar = progressbar.ProgressBar(len(results))
-    for idx, per_img_res in enumerate(results):
-        res_segm = per_img_res
-        gt_segm = dataset[idx]['data_samples'] \
-            .gt_sem_seg.data.squeeze().numpy().astype(np.uint8)
-        gt_segm, res_segm = gt_segm.flatten(), res_segm.flatten()
-        if reduce_zero_label:
-            gt_segm = gt_segm - 1
-        to_ignore = gt_segm == ignore_index
-
-        gt_segm, res_segm = gt_segm[~to_ignore], res_segm[~to_ignore]
-        inds = n * gt_segm + res_segm
-        mat = np.bincount(inds, minlength=n**2).reshape(n, n)
-        confusion_matrix += mat
-        prog_bar.update()
-    return confusion_matrix
-
-
-def plot_confusion_matrix(confusion_matrix,
-                          labels,
-                          save_dir=None,
-                          show=True,
-                          title='Normalized Confusion Matrix',
-                          color_theme='OrRd'):
-    """Draw confusion matrix with matplotlib.
-
-    Args:
-        confusion_matrix (ndarray): The confusion matrix.
-        labels (list[str]): List of class names.
-        save_dir (str|optional): If set, save the confusion matrix plot to the
-            given path. Default: None.
-        show (bool): Whether to show the plot. Default: True.
-        title (str): Title of the plot. Default: `Normalized Confusion Matrix`.
-        color_theme (str): Theme of the matrix color map. Default: `winter`.
-    """
-    # normalize the confusion matrix
-    per_label_sums = confusion_matrix.sum(axis=1)[:, np.newaxis]
-    confusion_matrix = \
-        confusion_matrix.astype(np.float32) / per_label_sums * 100
-
-    num_classes = len(labels)
-    fig, ax = plt.subplots(
-        figsize=(2 * num_classes, 2 * num_classes * 0.8), dpi=300)
-    cmap = plt.get_cmap(color_theme)
-    im = ax.imshow(confusion_matrix, cmap=cmap)
-    colorbar = plt.colorbar(mappable=im, ax=ax)
-    colorbar.ax.tick_params(labelsize=20)  # 设置 colorbar 标签的字体大小
-
-    title_font = {'weight': 'bold', 'size': 20}
-    ax.set_title(title, fontdict=title_font)
-    label_font = {'size': 40}
-    plt.ylabel('Ground Truth Label', fontdict=label_font)
-    plt.xlabel('Prediction Label', fontdict=label_font)
-
-    # draw locator
-    xmajor_locator = MultipleLocator(1)
-    xminor_locator = MultipleLocator(0.5)
-    ax.xaxis.set_major_locator(xmajor_locator)
-    ax.xaxis.set_minor_locator(xminor_locator)
-    ymajor_locator = MultipleLocator(1)
-    yminor_locator = MultipleLocator(0.5)
-    ax.yaxis.set_major_locator(ymajor_locator)
-    ax.yaxis.set_minor_locator(yminor_locator)
-
-    # draw grid
-    ax.grid(True, which='minor', linestyle='-')
-
-    # draw label
-    ax.set_xticks(np.arange(num_classes))
-    ax.set_yticks(np.arange(num_classes))
-    ax.set_xticklabels(labels, fontsize=20)
-    ax.set_yticklabels(labels, fontsize=20)
-
-    ax.tick_params(
-        axis='x', bottom=False, top=True, labelbottom=False, labeltop=True)
-    plt.setp(
-        ax.get_xticklabels(), rotation=45, ha='left', rotation_mode='anchor')
-
-    # draw confusion matrix value
-    for i in range(num_classes):
-        for j in range(num_classes):
-            ax.text(
-                j,
-                i,
-                '{}%'.format(
-                    round(confusion_matrix[i, j], 2
-                          ) if not np.isnan(confusion_matrix[i, j]) else -1),
-                ha='center',
-                va='center',
-                color='k',
-                size=20)
-
-    ax.set_ylim(len(confusion_matrix) - 0.5, -0.5)  # matplotlib>3.1.1
-
-    fig.tight_layout()
-    if save_dir is not None:
-        mkdir_or_exist(save_dir)
-        plt.savefig(
-            os.path.join(save_dir, 'confusion_matrix.png'), format='png')
-    if show:
-        plt.show()
-
-
-def main():
-    args = parse_args()
-
-    cfg = Config.fromfile(args.config)
-    if args.cfg_options is not None:
-        cfg.merge_from_dict(args.cfg_options)
-
-    results = []
-    for img in sorted(os.listdir(args.prediction_path)):
-        img = os.path.join(args.prediction_path, img)
-        image = Image.open(img)
-        image = np.copy(image)
-        results.append(image)
-
-    assert isinstance(results, list)
-    if isinstance(results[0], np.ndarray):
-        pass
-    else:
-        raise TypeError('invalid type of prediction results')
-
-    dataset = DATASETS.build(cfg.test_dataloader.dataset)
-    confusion_matrix = calculate_confusion_matrix(dataset, results)
-    plot_confusion_matrix(
-        confusion_matrix,
-        dataset.METAINFO['classes'],
-        save_dir=args.save_dir,
-        show=args.show,
-        title=args.title,
-        color_theme=args.color_theme)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/analysis_tools/get_flops.py b/mmsegmentation/tools/analysis_tools/get_flops.py
deleted file mode 100644
index 78a7398..0000000
--- a/mmsegmentation/tools/analysis_tools/get_flops.py
+++ /dev/null
@@ -1,124 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import tempfile
-from pathlib import Path
-
-import torch
-from mmengine import Config, DictAction
-from mmengine.logging import MMLogger
-from mmengine.model import revert_sync_batchnorm
-from mmengine.registry import init_default_scope
-
-from mmseg.models import BaseSegmentor
-from mmseg.registry import MODELS
-from mmseg.structures import SegDataSample
-
-try:
-    from mmengine.analysis import get_model_complexity_info
-    from mmengine.analysis.print_helper import _format_size
-except ImportError:
-    raise ImportError('Please upgrade mmengine >= 0.6.0 to use this script.')
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Get the FLOPs of a segmentor')
-    parser.add_argument('config', help='train config file path')
-    parser.add_argument(
-        '--shape',
-        type=int,
-        nargs='+',
-        default=[2048, 1024],
-        help='input image size')
-    parser.add_argument(
-        '--cfg-options',
-        nargs='+',
-        action=DictAction,
-        help='override some settings in the used config, the key-value pair '
-        'in xxx=yyy format will be merged into config file. If the value to '
-        'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
-        'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
-        'Note that the quotation marks are necessary and that no white space '
-        'is allowed.')
-    args = parser.parse_args()
-    return args
-
-
-def inference(args: argparse.Namespace, logger: MMLogger) -> dict:
-    config_name = Path(args.config)
-
-    if not config_name.exists():
-        logger.error(f'Config file {config_name} does not exist')
-
-    cfg: Config = Config.fromfile(config_name)
-    cfg.work_dir = tempfile.TemporaryDirectory().name
-    cfg.log_level = 'WARN'
-    if args.cfg_options is not None:
-        cfg.merge_from_dict(args.cfg_options)
-
-    init_default_scope(cfg.get('scope', 'mmseg'))
-
-    if len(args.shape) == 1:
-        input_shape = (3, args.shape[0], args.shape[0])
-    elif len(args.shape) == 2:
-        input_shape = (3, ) + tuple(args.shape)
-    else:
-        raise ValueError('invalid input shape')
-    result = {}
-
-    model: BaseSegmentor = MODELS.build(cfg.model)
-    if hasattr(model, 'auxiliary_head'):
-        model.auxiliary_head = None
-    if torch.cuda.is_available():
-        model.cuda()
-    model = revert_sync_batchnorm(model)
-    result['ori_shape'] = input_shape[-2:]
-    result['pad_shape'] = input_shape[-2:]
-    data_batch = {
-        'inputs': [torch.rand(input_shape)],
-        'data_samples': [SegDataSample(metainfo=result)]
-    }
-    data = model.data_preprocessor(data_batch)
-    model.eval()
-    if cfg.model.decode_head.type in ['MaskFormerHead', 'Mask2FormerHead']:
-        # TODO: Support MaskFormer and Mask2Former
-        raise NotImplementedError('MaskFormer and Mask2Former are not '
-                                  'supported yet.')
-    outputs = get_model_complexity_info(
-        model,
-        input_shape=None,
-        inputs=data['inputs'],
-        show_table=False,
-        show_arch=False)
-    result['flops'] = _format_size(outputs['flops'])
-    result['params'] = _format_size(outputs['params'])
-    result['compute_type'] = 'direct: randomly generate a picture'
-    return result
-
-
-def main():
-
-    args = parse_args()
-    logger = MMLogger.get_instance(name='MMLogger')
-
-    result = inference(args, logger)
-    split_line = '=' * 30
-    ori_shape = result['ori_shape']
-    pad_shape = result['pad_shape']
-    flops = result['flops']
-    params = result['params']
-    compute_type = result['compute_type']
-
-    if pad_shape != ori_shape:
-        print(f'{split_line}\nUse size divisor set input shape '
-              f'from {ori_shape} to {pad_shape}')
-    print(f'{split_line}\nCompute type: {compute_type}\n'
-          f'Input shape: {pad_shape}\nFlops: {flops}\n'
-          f'Params: {params}\n{split_line}')
-    print('!!!Please be cautious if you use the results in papers. '
-          'You may need to check if all ops are supported and verify '
-          'that the flops computation is correct.')
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/analysis_tools/visualization_cam.py b/mmsegmentation/tools/analysis_tools/visualization_cam.py
deleted file mode 100644
index 00cdb3e..0000000
--- a/mmsegmentation/tools/analysis_tools/visualization_cam.py
+++ /dev/null
@@ -1,127 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-"""Use the pytorch-grad-cam tool to visualize Class Activation Maps (CAM).
-
-requirement: pip install grad-cam
-"""
-
-from argparse import ArgumentParser
-
-import numpy as np
-import torch
-import torch.nn.functional as F
-from mmengine import Config
-from mmengine.model import revert_sync_batchnorm
-from PIL import Image
-from pytorch_grad_cam import GradCAM
-from pytorch_grad_cam.utils.image import preprocess_image, show_cam_on_image
-
-from mmseg.apis import inference_model, init_model, show_result_pyplot
-from mmseg.utils import register_all_modules
-
-
-class SemanticSegmentationTarget:
-    """wrap the model.
-
-    requirement: pip install grad-cam
-
-    Args:
-        category (int): Visualization class.
-        mask (ndarray): Mask of class.
-        size (tuple): Image size.
-    """
-
-    def __init__(self, category, mask, size):
-        self.category = category
-        self.mask = torch.from_numpy(mask)
-        self.size = size
-        if torch.cuda.is_available():
-            self.mask = self.mask.cuda()
-
-    def __call__(self, model_output):
-        model_output = torch.unsqueeze(model_output, dim=0)
-        model_output = F.interpolate(
-            model_output, size=self.size, mode='bilinear')
-        model_output = torch.squeeze(model_output, dim=0)
-
-        return (model_output[self.category, :, :] * self.mask).sum()
-
-
-def main():
-    parser = ArgumentParser()
-    parser.add_argument('img', help='Image file')
-    parser.add_argument('config', help='Config file')
-    parser.add_argument('checkpoint', help='Checkpoint file')
-    parser.add_argument(
-        '--out-file',
-        default='prediction.png',
-        help='Path to output prediction file')
-    parser.add_argument(
-        '--cam-file', default='vis_cam.png', help='Path to output cam file')
-    parser.add_argument(
-        '--target-layers',
-        default='backbone.layer4[2]',
-        help='Target layers to visualize CAM')
-    parser.add_argument(
-        '--category-index', default='7', help='Category to visualize CAM')
-    parser.add_argument(
-        '--device', default='cuda:0', help='Device used for inference')
-    args = parser.parse_args()
-
-    # build the model from a config file and a checkpoint file
-    register_all_modules()
-    model = init_model(args.config, args.checkpoint, device=args.device)
-    if args.device == 'cpu':
-        model = revert_sync_batchnorm(model)
-
-    # test a single image
-    result = inference_model(model, args.img)
-
-    # show the results
-    show_result_pyplot(
-        model,
-        args.img,
-        result,
-        draw_gt=False,
-        show=False if args.out_file is not None else True,
-        out_file=args.out_file)
-
-    # result data conversion
-    prediction_data = result.pred_sem_seg.data
-    pre_np_data = prediction_data.cpu().numpy().squeeze(0)
-
-    target_layers = args.target_layers
-    target_layers = [eval(f'model.{target_layers}')]
-
-    category = int(args.category_index)
-    mask_float = np.float32(pre_np_data == category)
-
-    # data processing
-    image = np.array(Image.open(args.img).convert('RGB'))
-    height, width = image.shape[0], image.shape[1]
-    rgb_img = np.float32(image) / 255
-    config = Config.fromfile(args.config)
-    image_mean = config.data_preprocessor['mean']
-    image_std = config.data_preprocessor['std']
-    input_tensor = preprocess_image(
-        rgb_img,
-        mean=[x / 255 for x in image_mean],
-        std=[x / 255 for x in image_std])
-
-    # Grad CAM(Class Activation Maps)
-    # Can also be LayerCAM, XGradCAM, GradCAMPlusPlus, EigenCAM, EigenGradCAM
-    targets = [
-        SemanticSegmentationTarget(category, mask_float, (height, width))
-    ]
-    with GradCAM(
-            model=model,
-            target_layers=target_layers,
-            use_cuda=torch.cuda.is_available()) as cam:
-        grayscale_cam = cam(input_tensor=input_tensor, targets=targets)[0, :]
-        cam_image = show_cam_on_image(rgb_img, grayscale_cam, use_rgb=True)
-
-        # save cam file
-        Image.fromarray(cam_image).save(args.cam_file)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/dataset_converters/chase_db1.py b/mmsegmentation/tools/dataset_converters/chase_db1.py
deleted file mode 100644
index f4fefbd..0000000
--- a/mmsegmentation/tools/dataset_converters/chase_db1.py
+++ /dev/null
@@ -1,89 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os
-import os.path as osp
-import tempfile
-import zipfile
-
-import mmcv
-from mmengine.utils import mkdir_or_exist
-
-CHASE_DB1_LEN = 28 * 3
-TRAINING_LEN = 60
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Convert CHASE_DB1 dataset to mmsegmentation format')
-    parser.add_argument('dataset_path', help='path of CHASEDB1.zip')
-    parser.add_argument('--tmp_dir', help='path of the temporary directory')
-    parser.add_argument('-o', '--out_dir', help='output path')
-    args = parser.parse_args()
-    return args
-
-
-def main():
-    args = parse_args()
-    dataset_path = args.dataset_path
-    if args.out_dir is None:
-        out_dir = osp.join('data', 'CHASE_DB1')
-    else:
-        out_dir = args.out_dir
-
-    print('Making directories...')
-    mkdir_or_exist(out_dir)
-    mkdir_or_exist(osp.join(out_dir, 'images'))
-    mkdir_or_exist(osp.join(out_dir, 'images', 'training'))
-    mkdir_or_exist(osp.join(out_dir, 'images', 'validation'))
-    mkdir_or_exist(osp.join(out_dir, 'annotations'))
-    mkdir_or_exist(osp.join(out_dir, 'annotations', 'training'))
-    mkdir_or_exist(osp.join(out_dir, 'annotations', 'validation'))
-
-    with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
-        print('Extracting CHASEDB1.zip...')
-        zip_file = zipfile.ZipFile(dataset_path)
-        zip_file.extractall(tmp_dir)
-
-        print('Generating training dataset...')
-
-        assert len(os.listdir(tmp_dir)) == CHASE_DB1_LEN, \
-            f'len(os.listdir(tmp_dir)) != {CHASE_DB1_LEN}'
-
-        for img_name in sorted(os.listdir(tmp_dir))[:TRAINING_LEN]:
-            img = mmcv.imread(osp.join(tmp_dir, img_name))
-            if osp.splitext(img_name)[1] == '.jpg':
-                mmcv.imwrite(
-                    img,
-                    osp.join(out_dir, 'images', 'training',
-                             osp.splitext(img_name)[0] + '.png'))
-            else:
-                # The annotation img should be divided by 128, because some of
-                # the annotation imgs are not standard. We should set a
-                # threshold to convert the nonstandard annotation imgs. The
-                # value divided by 128 is equivalent to '1 if value >= 128
-                # else 0'
-                mmcv.imwrite(
-                    img[:, :, 0] // 128,
-                    osp.join(out_dir, 'annotations', 'training',
-                             osp.splitext(img_name)[0] + '.png'))
-
-        for img_name in sorted(os.listdir(tmp_dir))[TRAINING_LEN:]:
-            img = mmcv.imread(osp.join(tmp_dir, img_name))
-            if osp.splitext(img_name)[1] == '.jpg':
-                mmcv.imwrite(
-                    img,
-                    osp.join(out_dir, 'images', 'validation',
-                             osp.splitext(img_name)[0] + '.png'))
-            else:
-                mmcv.imwrite(
-                    img[:, :, 0] // 128,
-                    osp.join(out_dir, 'annotations', 'validation',
-                             osp.splitext(img_name)[0] + '.png'))
-
-        print('Removing the temporary files...')
-
-    print('Done!')
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/dataset_converters/cityscapes.py b/mmsegmentation/tools/dataset_converters/cityscapes.py
deleted file mode 100644
index 0d6a801..0000000
--- a/mmsegmentation/tools/dataset_converters/cityscapes.py
+++ /dev/null
@@ -1,56 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os.path as osp
-
-from cityscapesscripts.preparation.json2labelImg import json2labelImg
-from mmengine.utils import (mkdir_or_exist, scandir, track_parallel_progress,
-                            track_progress)
-
-
-def convert_json_to_label(json_file):
-    label_file = json_file.replace('_polygons.json', '_labelTrainIds.png')
-    json2labelImg(json_file, label_file, 'trainIds')
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Convert Cityscapes annotations to TrainIds')
-    parser.add_argument('cityscapes_path', help='cityscapes data path')
-    parser.add_argument('--gt-dir', default='gtFine', type=str)
-    parser.add_argument('-o', '--out-dir', help='output path')
-    parser.add_argument(
-        '--nproc', default=1, type=int, help='number of process')
-    args = parser.parse_args()
-    return args
-
-
-def main():
-    args = parse_args()
-    cityscapes_path = args.cityscapes_path
-    out_dir = args.out_dir if args.out_dir else cityscapes_path
-    mkdir_or_exist(out_dir)
-
-    gt_dir = osp.join(cityscapes_path, args.gt_dir)
-
-    poly_files = []
-    for poly in scandir(gt_dir, '_polygons.json', recursive=True):
-        poly_file = osp.join(gt_dir, poly)
-        poly_files.append(poly_file)
-    if args.nproc > 1:
-        track_parallel_progress(convert_json_to_label, poly_files, args.nproc)
-    else:
-        track_progress(convert_json_to_label, poly_files)
-
-    split_names = ['train', 'val', 'test']
-
-    for split in split_names:
-        filenames = []
-        for poly in scandir(
-                osp.join(gt_dir, split), '_polygons.json', recursive=True):
-            filenames.append(poly.replace('_gtFine_polygons.json', ''))
-        with open(osp.join(out_dir, f'{split}.txt'), 'w') as f:
-            f.writelines(f + '\n' for f in filenames)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/dataset_converters/coco_stuff10k.py b/mmsegmentation/tools/dataset_converters/coco_stuff10k.py
deleted file mode 100644
index 920127e..0000000
--- a/mmsegmentation/tools/dataset_converters/coco_stuff10k.py
+++ /dev/null
@@ -1,308 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os.path as osp
-import shutil
-from functools import partial
-
-import numpy as np
-from mmengine.utils import (mkdir_or_exist, track_parallel_progress,
-                            track_progress)
-from PIL import Image
-from scipy.io import loadmat
-
-COCO_LEN = 10000
-
-clsID_to_trID = {
-    0: 0,
-    1: 1,
-    2: 2,
-    3: 3,
-    4: 4,
-    5: 5,
-    6: 6,
-    7: 7,
-    8: 8,
-    9: 9,
-    10: 10,
-    11: 11,
-    13: 12,
-    14: 13,
-    15: 14,
-    16: 15,
-    17: 16,
-    18: 17,
-    19: 18,
-    20: 19,
-    21: 20,
-    22: 21,
-    23: 22,
-    24: 23,
-    25: 24,
-    27: 25,
-    28: 26,
-    31: 27,
-    32: 28,
-    33: 29,
-    34: 30,
-    35: 31,
-    36: 32,
-    37: 33,
-    38: 34,
-    39: 35,
-    40: 36,
-    41: 37,
-    42: 38,
-    43: 39,
-    44: 40,
-    46: 41,
-    47: 42,
-    48: 43,
-    49: 44,
-    50: 45,
-    51: 46,
-    52: 47,
-    53: 48,
-    54: 49,
-    55: 50,
-    56: 51,
-    57: 52,
-    58: 53,
-    59: 54,
-    60: 55,
-    61: 56,
-    62: 57,
-    63: 58,
-    64: 59,
-    65: 60,
-    67: 61,
-    70: 62,
-    72: 63,
-    73: 64,
-    74: 65,
-    75: 66,
-    76: 67,
-    77: 68,
-    78: 69,
-    79: 70,
-    80: 71,
-    81: 72,
-    82: 73,
-    84: 74,
-    85: 75,
-    86: 76,
-    87: 77,
-    88: 78,
-    89: 79,
-    90: 80,
-    92: 81,
-    93: 82,
-    94: 83,
-    95: 84,
-    96: 85,
-    97: 86,
-    98: 87,
-    99: 88,
-    100: 89,
-    101: 90,
-    102: 91,
-    103: 92,
-    104: 93,
-    105: 94,
-    106: 95,
-    107: 96,
-    108: 97,
-    109: 98,
-    110: 99,
-    111: 100,
-    112: 101,
-    113: 102,
-    114: 103,
-    115: 104,
-    116: 105,
-    117: 106,
-    118: 107,
-    119: 108,
-    120: 109,
-    121: 110,
-    122: 111,
-    123: 112,
-    124: 113,
-    125: 114,
-    126: 115,
-    127: 116,
-    128: 117,
-    129: 118,
-    130: 119,
-    131: 120,
-    132: 121,
-    133: 122,
-    134: 123,
-    135: 124,
-    136: 125,
-    137: 126,
-    138: 127,
-    139: 128,
-    140: 129,
-    141: 130,
-    142: 131,
-    143: 132,
-    144: 133,
-    145: 134,
-    146: 135,
-    147: 136,
-    148: 137,
-    149: 138,
-    150: 139,
-    151: 140,
-    152: 141,
-    153: 142,
-    154: 143,
-    155: 144,
-    156: 145,
-    157: 146,
-    158: 147,
-    159: 148,
-    160: 149,
-    161: 150,
-    162: 151,
-    163: 152,
-    164: 153,
-    165: 154,
-    166: 155,
-    167: 156,
-    168: 157,
-    169: 158,
-    170: 159,
-    171: 160,
-    172: 161,
-    173: 162,
-    174: 163,
-    175: 164,
-    176: 165,
-    177: 166,
-    178: 167,
-    179: 168,
-    180: 169,
-    181: 170,
-    182: 171
-}
-
-
-def convert_to_trainID(tuple_path, in_img_dir, in_ann_dir, out_img_dir,
-                       out_mask_dir, is_train):
-    imgpath, maskpath = tuple_path
-    shutil.copyfile(
-        osp.join(in_img_dir, imgpath),
-        osp.join(out_img_dir, 'train2014', imgpath) if is_train else osp.join(
-            out_img_dir, 'test2014', imgpath))
-    annotate = loadmat(osp.join(in_ann_dir, maskpath))
-    mask = annotate['S'].astype(np.uint8)
-    mask_copy = mask.copy()
-    for clsID, trID in clsID_to_trID.items():
-        mask_copy[mask == clsID] = trID
-    seg_filename = osp.join(out_mask_dir, 'train2014',
-                            maskpath.split('.')[0] +
-                            '_labelTrainIds.png') if is_train else osp.join(
-                                out_mask_dir, 'test2014',
-                                maskpath.split('.')[0] + '_labelTrainIds.png')
-    Image.fromarray(mask_copy).save(seg_filename, 'PNG')
-
-
-def generate_coco_list(folder):
-    train_list = osp.join(folder, 'imageLists', 'train.txt')
-    test_list = osp.join(folder, 'imageLists', 'test.txt')
-    train_paths = []
-    test_paths = []
-
-    with open(train_list) as f:
-        for filename in f:
-            basename = filename.strip()
-            imgpath = basename + '.jpg'
-            maskpath = basename + '.mat'
-            train_paths.append((imgpath, maskpath))
-
-    with open(test_list) as f:
-        for filename in f:
-            basename = filename.strip()
-            imgpath = basename + '.jpg'
-            maskpath = basename + '.mat'
-            test_paths.append((imgpath, maskpath))
-
-    return train_paths, test_paths
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description=\
-        'Convert COCO Stuff 10k annotations to mmsegmentation format')  # noqa
-    parser.add_argument('coco_path', help='coco stuff path')
-    parser.add_argument('-o', '--out_dir', help='output path')
-    parser.add_argument(
-        '--nproc', default=16, type=int, help='number of process')
-    args = parser.parse_args()
-    return args
-
-
-def main():
-    args = parse_args()
-    coco_path = args.coco_path
-    nproc = args.nproc
-
-    out_dir = args.out_dir or coco_path
-    out_img_dir = osp.join(out_dir, 'images')
-    out_mask_dir = osp.join(out_dir, 'annotations')
-
-    mkdir_or_exist(osp.join(out_img_dir, 'train2014'))
-    mkdir_or_exist(osp.join(out_img_dir, 'test2014'))
-    mkdir_or_exist(osp.join(out_mask_dir, 'train2014'))
-    mkdir_or_exist(osp.join(out_mask_dir, 'test2014'))
-
-    train_list, test_list = generate_coco_list(coco_path)
-    assert (len(train_list) +
-            len(test_list)) == COCO_LEN, 'Wrong length of list {} & {}'.format(
-                len(train_list), len(test_list))
-
-    if args.nproc > 1:
-        track_parallel_progress(
-            partial(
-                convert_to_trainID,
-                in_img_dir=osp.join(coco_path, 'images'),
-                in_ann_dir=osp.join(coco_path, 'annotations'),
-                out_img_dir=out_img_dir,
-                out_mask_dir=out_mask_dir,
-                is_train=True),
-            train_list,
-            nproc=nproc)
-        track_parallel_progress(
-            partial(
-                convert_to_trainID,
-                in_img_dir=osp.join(coco_path, 'images'),
-                in_ann_dir=osp.join(coco_path, 'annotations'),
-                out_img_dir=out_img_dir,
-                out_mask_dir=out_mask_dir,
-                is_train=False),
-            test_list,
-            nproc=nproc)
-    else:
-        track_progress(
-            partial(
-                convert_to_trainID,
-                in_img_dir=osp.join(coco_path, 'images'),
-                in_ann_dir=osp.join(coco_path, 'annotations'),
-                out_img_dir=out_img_dir,
-                out_mask_dir=out_mask_dir,
-                is_train=True), train_list)
-        track_progress(
-            partial(
-                convert_to_trainID,
-                in_img_dir=osp.join(coco_path, 'images'),
-                in_ann_dir=osp.join(coco_path, 'annotations'),
-                out_img_dir=out_img_dir,
-                out_mask_dir=out_mask_dir,
-                is_train=False), test_list)
-
-    print('Done!')
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/dataset_converters/coco_stuff164k.py b/mmsegmentation/tools/dataset_converters/coco_stuff164k.py
deleted file mode 100644
index a13114a..0000000
--- a/mmsegmentation/tools/dataset_converters/coco_stuff164k.py
+++ /dev/null
@@ -1,265 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os.path as osp
-import shutil
-from functools import partial
-from glob import glob
-
-import numpy as np
-from mmengine.utils import (mkdir_or_exist, track_parallel_progress,
-                            track_progress)
-from PIL import Image
-
-COCO_LEN = 123287
-
-clsID_to_trID = {
-    0: 0,
-    1: 1,
-    2: 2,
-    3: 3,
-    4: 4,
-    5: 5,
-    6: 6,
-    7: 7,
-    8: 8,
-    9: 9,
-    10: 10,
-    12: 11,
-    13: 12,
-    14: 13,
-    15: 14,
-    16: 15,
-    17: 16,
-    18: 17,
-    19: 18,
-    20: 19,
-    21: 20,
-    22: 21,
-    23: 22,
-    24: 23,
-    26: 24,
-    27: 25,
-    30: 26,
-    31: 27,
-    32: 28,
-    33: 29,
-    34: 30,
-    35: 31,
-    36: 32,
-    37: 33,
-    38: 34,
-    39: 35,
-    40: 36,
-    41: 37,
-    42: 38,
-    43: 39,
-    45: 40,
-    46: 41,
-    47: 42,
-    48: 43,
-    49: 44,
-    50: 45,
-    51: 46,
-    52: 47,
-    53: 48,
-    54: 49,
-    55: 50,
-    56: 51,
-    57: 52,
-    58: 53,
-    59: 54,
-    60: 55,
-    61: 56,
-    62: 57,
-    63: 58,
-    64: 59,
-    66: 60,
-    69: 61,
-    71: 62,
-    72: 63,
-    73: 64,
-    74: 65,
-    75: 66,
-    76: 67,
-    77: 68,
-    78: 69,
-    79: 70,
-    80: 71,
-    81: 72,
-    83: 73,
-    84: 74,
-    85: 75,
-    86: 76,
-    87: 77,
-    88: 78,
-    89: 79,
-    91: 80,
-    92: 81,
-    93: 82,
-    94: 83,
-    95: 84,
-    96: 85,
-    97: 86,
-    98: 87,
-    99: 88,
-    100: 89,
-    101: 90,
-    102: 91,
-    103: 92,
-    104: 93,
-    105: 94,
-    106: 95,
-    107: 96,
-    108: 97,
-    109: 98,
-    110: 99,
-    111: 100,
-    112: 101,
-    113: 102,
-    114: 103,
-    115: 104,
-    116: 105,
-    117: 106,
-    118: 107,
-    119: 108,
-    120: 109,
-    121: 110,
-    122: 111,
-    123: 112,
-    124: 113,
-    125: 114,
-    126: 115,
-    127: 116,
-    128: 117,
-    129: 118,
-    130: 119,
-    131: 120,
-    132: 121,
-    133: 122,
-    134: 123,
-    135: 124,
-    136: 125,
-    137: 126,
-    138: 127,
-    139: 128,
-    140: 129,
-    141: 130,
-    142: 131,
-    143: 132,
-    144: 133,
-    145: 134,
-    146: 135,
-    147: 136,
-    148: 137,
-    149: 138,
-    150: 139,
-    151: 140,
-    152: 141,
-    153: 142,
-    154: 143,
-    155: 144,
-    156: 145,
-    157: 146,
-    158: 147,
-    159: 148,
-    160: 149,
-    161: 150,
-    162: 151,
-    163: 152,
-    164: 153,
-    165: 154,
-    166: 155,
-    167: 156,
-    168: 157,
-    169: 158,
-    170: 159,
-    171: 160,
-    172: 161,
-    173: 162,
-    174: 163,
-    175: 164,
-    176: 165,
-    177: 166,
-    178: 167,
-    179: 168,
-    180: 169,
-    181: 170,
-    255: 255
-}
-
-
-def convert_to_trainID(maskpath, out_mask_dir, is_train):
-    mask = np.array(Image.open(maskpath))
-    mask_copy = mask.copy()
-    for clsID, trID in clsID_to_trID.items():
-        mask_copy[mask == clsID] = trID
-    seg_filename = osp.join(
-        out_mask_dir, 'train2017',
-        osp.basename(maskpath).split('.')[0] +
-        '_labelTrainIds.png') if is_train else osp.join(
-            out_mask_dir, 'val2017',
-            osp.basename(maskpath).split('.')[0] + '_labelTrainIds.png')
-    Image.fromarray(mask_copy).save(seg_filename, 'PNG')
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description=\
-        'Convert COCO Stuff 164k annotations to mmsegmentation format')  # noqa
-    parser.add_argument('coco_path', help='coco stuff path')
-    parser.add_argument('-o', '--out_dir', help='output path')
-    parser.add_argument(
-        '--nproc', default=16, type=int, help='number of process')
-    args = parser.parse_args()
-    return args
-
-
-def main():
-    args = parse_args()
-    coco_path = args.coco_path
-    nproc = args.nproc
-
-    out_dir = args.out_dir or coco_path
-    out_img_dir = osp.join(out_dir, 'images')
-    out_mask_dir = osp.join(out_dir, 'annotations')
-
-    mkdir_or_exist(osp.join(out_mask_dir, 'train2017'))
-    mkdir_or_exist(osp.join(out_mask_dir, 'val2017'))
-
-    if out_dir != coco_path:
-        shutil.copytree(osp.join(coco_path, 'images'), out_img_dir)
-
-    train_list = glob(osp.join(coco_path, 'annotations', 'train2017', '*.png'))
-    train_list = [file for file in train_list if '_labelTrainIds' not in file]
-    test_list = glob(osp.join(coco_path, 'annotations', 'val2017', '*.png'))
-    test_list = [file for file in test_list if '_labelTrainIds' not in file]
-    assert (len(train_list) +
-            len(test_list)) == COCO_LEN, 'Wrong length of list {} & {}'.format(
-                len(train_list), len(test_list))
-
-    if args.nproc > 1:
-        track_parallel_progress(
-            partial(
-                convert_to_trainID, out_mask_dir=out_mask_dir, is_train=True),
-            train_list,
-            nproc=nproc)
-        track_parallel_progress(
-            partial(
-                convert_to_trainID, out_mask_dir=out_mask_dir, is_train=False),
-            test_list,
-            nproc=nproc)
-    else:
-        track_progress(
-            partial(
-                convert_to_trainID, out_mask_dir=out_mask_dir, is_train=True),
-            train_list)
-        track_progress(
-            partial(
-                convert_to_trainID, out_mask_dir=out_mask_dir, is_train=False),
-            test_list)
-
-    print('Done!')
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/dataset_converters/drive.py b/mmsegmentation/tools/dataset_converters/drive.py
deleted file mode 100644
index 076fd05..0000000
--- a/mmsegmentation/tools/dataset_converters/drive.py
+++ /dev/null
@@ -1,114 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os
-import os.path as osp
-import tempfile
-import zipfile
-
-import cv2
-import mmcv
-from mmengine.utils import mkdir_or_exist
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Convert DRIVE dataset to mmsegmentation format')
-    parser.add_argument(
-        'training_path', help='the training part of DRIVE dataset')
-    parser.add_argument(
-        'testing_path', help='the testing part of DRIVE dataset')
-    parser.add_argument('--tmp_dir', help='path of the temporary directory')
-    parser.add_argument('-o', '--out_dir', help='output path')
-    args = parser.parse_args()
-    return args
-
-
-def main():
-    args = parse_args()
-    training_path = args.training_path
-    testing_path = args.testing_path
-    if args.out_dir is None:
-        out_dir = osp.join('data', 'DRIVE')
-    else:
-        out_dir = args.out_dir
-
-    print('Making directories...')
-    mkdir_or_exist(out_dir)
-    mkdir_or_exist(osp.join(out_dir, 'images'))
-    mkdir_or_exist(osp.join(out_dir, 'images', 'training'))
-    mkdir_or_exist(osp.join(out_dir, 'images', 'validation'))
-    mkdir_or_exist(osp.join(out_dir, 'annotations'))
-    mkdir_or_exist(osp.join(out_dir, 'annotations', 'training'))
-    mkdir_or_exist(osp.join(out_dir, 'annotations', 'validation'))
-
-    with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
-        print('Extracting training.zip...')
-        zip_file = zipfile.ZipFile(training_path)
-        zip_file.extractall(tmp_dir)
-
-        print('Generating training dataset...')
-        now_dir = osp.join(tmp_dir, 'training', 'images')
-        for img_name in os.listdir(now_dir):
-            img = mmcv.imread(osp.join(now_dir, img_name))
-            mmcv.imwrite(
-                img,
-                osp.join(
-                    out_dir, 'images', 'training',
-                    osp.splitext(img_name)[0].replace('_training', '') +
-                    '.png'))
-
-        now_dir = osp.join(tmp_dir, 'training', '1st_manual')
-        for img_name in os.listdir(now_dir):
-            cap = cv2.VideoCapture(osp.join(now_dir, img_name))
-            ret, img = cap.read()
-            mmcv.imwrite(
-                img[:, :, 0] // 128,
-                osp.join(out_dir, 'annotations', 'training',
-                         osp.splitext(img_name)[0] + '.png'))
-
-        print('Extracting test.zip...')
-        zip_file = zipfile.ZipFile(testing_path)
-        zip_file.extractall(tmp_dir)
-
-        print('Generating validation dataset...')
-        now_dir = osp.join(tmp_dir, 'test', 'images')
-        for img_name in os.listdir(now_dir):
-            img = mmcv.imread(osp.join(now_dir, img_name))
-            mmcv.imwrite(
-                img,
-                osp.join(
-                    out_dir, 'images', 'validation',
-                    osp.splitext(img_name)[0].replace('_test', '') + '.png'))
-
-        now_dir = osp.join(tmp_dir, 'test', '1st_manual')
-        if osp.exists(now_dir):
-            for img_name in os.listdir(now_dir):
-                cap = cv2.VideoCapture(osp.join(now_dir, img_name))
-                ret, img = cap.read()
-                # The annotation img should be divided by 128, because some of
-                # the annotation imgs are not standard. We should set a
-                # threshold to convert the nonstandard annotation imgs. The
-                # value divided by 128 is equivalent to '1 if value >= 128
-                # else 0'
-                mmcv.imwrite(
-                    img[:, :, 0] // 128,
-                    osp.join(out_dir, 'annotations', 'validation',
-                             osp.splitext(img_name)[0] + '.png'))
-
-        now_dir = osp.join(tmp_dir, 'test', '2nd_manual')
-        if osp.exists(now_dir):
-            for img_name in os.listdir(now_dir):
-                cap = cv2.VideoCapture(osp.join(now_dir, img_name))
-                ret, img = cap.read()
-                mmcv.imwrite(
-                    img[:, :, 0] // 128,
-                    osp.join(out_dir, 'annotations', 'validation',
-                             osp.splitext(img_name)[0] + '.png'))
-
-        print('Removing the temporary files...')
-
-    print('Done!')
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/dataset_converters/hrf.py b/mmsegmentation/tools/dataset_converters/hrf.py
deleted file mode 100644
index 3bfd80c..0000000
--- a/mmsegmentation/tools/dataset_converters/hrf.py
+++ /dev/null
@@ -1,112 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os
-import os.path as osp
-import tempfile
-import zipfile
-
-import mmcv
-from mmengine.utils import mkdir_or_exist
-
-HRF_LEN = 15
-TRAINING_LEN = 5
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Convert HRF dataset to mmsegmentation format')
-    parser.add_argument('healthy_path', help='the path of healthy.zip')
-    parser.add_argument(
-        'healthy_manualsegm_path', help='the path of healthy_manualsegm.zip')
-    parser.add_argument('glaucoma_path', help='the path of glaucoma.zip')
-    parser.add_argument(
-        'glaucoma_manualsegm_path', help='the path of glaucoma_manualsegm.zip')
-    parser.add_argument(
-        'diabetic_retinopathy_path',
-        help='the path of diabetic_retinopathy.zip')
-    parser.add_argument(
-        'diabetic_retinopathy_manualsegm_path',
-        help='the path of diabetic_retinopathy_manualsegm.zip')
-    parser.add_argument('--tmp_dir', help='path of the temporary directory')
-    parser.add_argument('-o', '--out_dir', help='output path')
-    args = parser.parse_args()
-    return args
-
-
-def main():
-    args = parse_args()
-    images_path = [
-        args.healthy_path, args.glaucoma_path, args.diabetic_retinopathy_path
-    ]
-    annotations_path = [
-        args.healthy_manualsegm_path, args.glaucoma_manualsegm_path,
-        args.diabetic_retinopathy_manualsegm_path
-    ]
-    if args.out_dir is None:
-        out_dir = osp.join('data', 'HRF')
-    else:
-        out_dir = args.out_dir
-
-    print('Making directories...')
-    mkdir_or_exist(out_dir)
-    mkdir_or_exist(osp.join(out_dir, 'images'))
-    mkdir_or_exist(osp.join(out_dir, 'images', 'training'))
-    mkdir_or_exist(osp.join(out_dir, 'images', 'validation'))
-    mkdir_or_exist(osp.join(out_dir, 'annotations'))
-    mkdir_or_exist(osp.join(out_dir, 'annotations', 'training'))
-    mkdir_or_exist(osp.join(out_dir, 'annotations', 'validation'))
-
-    print('Generating images...')
-    for now_path in images_path:
-        with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
-            zip_file = zipfile.ZipFile(now_path)
-            zip_file.extractall(tmp_dir)
-
-            assert len(os.listdir(tmp_dir)) == HRF_LEN, \
-                f'len(os.listdir(tmp_dir)) != {HRF_LEN}'
-
-            for filename in sorted(os.listdir(tmp_dir))[:TRAINING_LEN]:
-                img = mmcv.imread(osp.join(tmp_dir, filename))
-                mmcv.imwrite(
-                    img,
-                    osp.join(out_dir, 'images', 'training',
-                             osp.splitext(filename)[0] + '.png'))
-            for filename in sorted(os.listdir(tmp_dir))[TRAINING_LEN:]:
-                img = mmcv.imread(osp.join(tmp_dir, filename))
-                mmcv.imwrite(
-                    img,
-                    osp.join(out_dir, 'images', 'validation',
-                             osp.splitext(filename)[0] + '.png'))
-
-    print('Generating annotations...')
-    for now_path in annotations_path:
-        with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
-            zip_file = zipfile.ZipFile(now_path)
-            zip_file.extractall(tmp_dir)
-
-            assert len(os.listdir(tmp_dir)) == HRF_LEN, \
-                f'len(os.listdir(tmp_dir)) != {HRF_LEN}'
-
-            for filename in sorted(os.listdir(tmp_dir))[:TRAINING_LEN]:
-                img = mmcv.imread(osp.join(tmp_dir, filename))
-                # The annotation img should be divided by 128, because some of
-                # the annotation imgs are not standard. We should set a
-                # threshold to convert the nonstandard annotation imgs. The
-                # value divided by 128 is equivalent to '1 if value >= 128
-                # else 0'
-                mmcv.imwrite(
-                    img[:, :, 0] // 128,
-                    osp.join(out_dir, 'annotations', 'training',
-                             osp.splitext(filename)[0] + '.png'))
-            for filename in sorted(os.listdir(tmp_dir))[TRAINING_LEN:]:
-                img = mmcv.imread(osp.join(tmp_dir, filename))
-                mmcv.imwrite(
-                    img[:, :, 0] // 128,
-                    osp.join(out_dir, 'annotations', 'validation',
-                             osp.splitext(filename)[0] + '.png'))
-
-    print('Done!')
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/dataset_converters/isaid.py b/mmsegmentation/tools/dataset_converters/isaid.py
deleted file mode 100644
index 1d5ccd9..0000000
--- a/mmsegmentation/tools/dataset_converters/isaid.py
+++ /dev/null
@@ -1,246 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import glob
-import os
-import os.path as osp
-import shutil
-import tempfile
-import zipfile
-
-import mmcv
-import numpy as np
-from mmengine.utils import ProgressBar, mkdir_or_exist
-from PIL import Image
-
-iSAID_palette = \
-    {
-        0: (0, 0, 0),
-        1: (0, 0, 63),
-        2: (0, 63, 63),
-        3: (0, 63, 0),
-        4: (0, 63, 127),
-        5: (0, 63, 191),
-        6: (0, 63, 255),
-        7: (0, 127, 63),
-        8: (0, 127, 127),
-        9: (0, 0, 127),
-        10: (0, 0, 191),
-        11: (0, 0, 255),
-        12: (0, 191, 127),
-        13: (0, 127, 191),
-        14: (0, 127, 255),
-        15: (0, 100, 155)
-    }
-
-iSAID_invert_palette = {v: k for k, v in iSAID_palette.items()}
-
-
-def iSAID_convert_from_color(arr_3d, palette=iSAID_invert_palette):
-    """RGB-color encoding to grayscale labels."""
-    arr_2d = np.zeros((arr_3d.shape[0], arr_3d.shape[1]), dtype=np.uint8)
-
-    for c, i in palette.items():
-        m = np.all(arr_3d == np.array(c).reshape(1, 1, 3), axis=2)
-        arr_2d[m] = i
-
-    return arr_2d
-
-
-def slide_crop_image(src_path, out_dir, mode, patch_H, patch_W, overlap):
-    img = np.asarray(Image.open(src_path).convert('RGB'))
-
-    img_H, img_W, _ = img.shape
-
-    if img_H < patch_H and img_W > patch_W:
-
-        img = mmcv.impad(img, shape=(patch_H, img_W), pad_val=0)
-
-        img_H, img_W, _ = img.shape
-
-    elif img_H > patch_H and img_W < patch_W:
-
-        img = mmcv.impad(img, shape=(img_H, patch_W), pad_val=0)
-
-        img_H, img_W, _ = img.shape
-
-    elif img_H < patch_H and img_W < patch_W:
-
-        img = mmcv.impad(img, shape=(patch_H, patch_W), pad_val=0)
-
-        img_H, img_W, _ = img.shape
-
-    for x in range(0, img_W, patch_W - overlap):
-        for y in range(0, img_H, patch_H - overlap):
-            x_str = x
-            x_end = x + patch_W
-            if x_end > img_W:
-                diff_x = x_end - img_W
-                x_str -= diff_x
-                x_end = img_W
-            y_str = y
-            y_end = y + patch_H
-            if y_end > img_H:
-                diff_y = y_end - img_H
-                y_str -= diff_y
-                y_end = img_H
-
-            img_patch = img[y_str:y_end, x_str:x_end, :]
-            img_patch = Image.fromarray(img_patch.astype(np.uint8))
-            image = osp.basename(src_path).split('.')[0] + '_' + str(
-                y_str) + '_' + str(y_end) + '_' + str(x_str) + '_' + str(
-                    x_end) + '.png'
-            # print(image)
-            save_path_image = osp.join(out_dir, 'img_dir', mode, str(image))
-            img_patch.save(save_path_image, format='BMP')
-
-
-def slide_crop_label(src_path, out_dir, mode, patch_H, patch_W, overlap):
-    label = mmcv.imread(src_path, channel_order='rgb')
-    label = iSAID_convert_from_color(label)
-    img_H, img_W = label.shape
-
-    if img_H < patch_H and img_W > patch_W:
-
-        label = mmcv.impad(label, shape=(patch_H, img_W), pad_val=255)
-
-        img_H = patch_H
-
-    elif img_H > patch_H and img_W < patch_W:
-
-        label = mmcv.impad(label, shape=(img_H, patch_W), pad_val=255)
-
-        img_W = patch_W
-
-    elif img_H < patch_H and img_W < patch_W:
-
-        label = mmcv.impad(label, shape=(patch_H, patch_W), pad_val=255)
-
-        img_H = patch_H
-        img_W = patch_W
-
-    for x in range(0, img_W, patch_W - overlap):
-        for y in range(0, img_H, patch_H - overlap):
-            x_str = x
-            x_end = x + patch_W
-            if x_end > img_W:
-                diff_x = x_end - img_W
-                x_str -= diff_x
-                x_end = img_W
-            y_str = y
-            y_end = y + patch_H
-            if y_end > img_H:
-                diff_y = y_end - img_H
-                y_str -= diff_y
-                y_end = img_H
-
-            lab_patch = label[y_str:y_end, x_str:x_end]
-            lab_patch = Image.fromarray(lab_patch.astype(np.uint8), mode='P')
-
-            image = osp.basename(src_path).split('.')[0].split(
-                '_')[0] + '_' + str(y_str) + '_' + str(y_end) + '_' + str(
-                    x_str) + '_' + str(x_end) + '_instance_color_RGB' + '.png'
-            lab_patch.save(osp.join(out_dir, 'ann_dir', mode, str(image)))
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Convert iSAID dataset to mmsegmentation format')
-    parser.add_argument('dataset_path', help='iSAID folder path')
-    parser.add_argument('--tmp_dir', help='path of the temporary directory')
-    parser.add_argument('-o', '--out_dir', help='output path')
-
-    parser.add_argument(
-        '--patch_width',
-        default=896,
-        type=int,
-        help='Width of the cropped image patch')
-    parser.add_argument(
-        '--patch_height',
-        default=896,
-        type=int,
-        help='Height of the cropped image patch')
-    parser.add_argument(
-        '--overlap_area', default=384, type=int, help='Overlap area')
-    args = parser.parse_args()
-    return args
-
-
-def main():
-    args = parse_args()
-    dataset_path = args.dataset_path
-    # image patch width and height
-    patch_H, patch_W = args.patch_width, args.patch_height
-
-    overlap = args.overlap_area  # overlap area
-
-    if args.out_dir is None:
-        out_dir = osp.join('data', 'iSAID')
-    else:
-        out_dir = args.out_dir
-
-    print('Making directories...')
-    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'train'))
-    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'val'))
-    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'test'))
-
-    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'train'))
-    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'val'))
-    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'test'))
-
-    assert os.path.exists(os.path.join(dataset_path, 'train')), \
-        f'train is not in {dataset_path}'
-    assert os.path.exists(os.path.join(dataset_path, 'val')), \
-        f'val is not in {dataset_path}'
-    assert os.path.exists(os.path.join(dataset_path, 'test')), \
-        f'test is not in {dataset_path}'
-
-    with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
-        for dataset_mode in ['train', 'val', 'test']:
-
-            # for dataset_mode in [ 'test']:
-            print(f'Extracting  {dataset_mode}ing.zip...')
-            img_zipp_list = glob.glob(
-                os.path.join(dataset_path, dataset_mode, 'images', '*.zip'))
-            print('Find the data', img_zipp_list)
-            for img_zipp in img_zipp_list:
-                zip_file = zipfile.ZipFile(img_zipp)
-                zip_file.extractall(os.path.join(tmp_dir, dataset_mode, 'img'))
-            src_path_list = glob.glob(
-                os.path.join(tmp_dir, dataset_mode, 'img', 'images', '*.png'))
-
-            src_prog_bar = ProgressBar(len(src_path_list))
-            for i, img_path in enumerate(src_path_list):
-                if dataset_mode != 'test':
-                    slide_crop_image(img_path, out_dir, dataset_mode, patch_H,
-                                     patch_W, overlap)
-
-                else:
-                    shutil.move(img_path,
-                                os.path.join(out_dir, 'img_dir', dataset_mode))
-                src_prog_bar.update()
-
-            if dataset_mode != 'test':
-                label_zipp_list = glob.glob(
-                    os.path.join(dataset_path, dataset_mode, 'Semantic_masks',
-                                 '*.zip'))
-                for label_zipp in label_zipp_list:
-                    zip_file = zipfile.ZipFile(label_zipp)
-                    zip_file.extractall(
-                        os.path.join(tmp_dir, dataset_mode, 'lab'))
-
-                lab_path_list = glob.glob(
-                    os.path.join(tmp_dir, dataset_mode, 'lab', 'images',
-                                 '*.png'))
-                lab_prog_bar = ProgressBar(len(lab_path_list))
-                for i, lab_path in enumerate(lab_path_list):
-                    slide_crop_label(lab_path, out_dir, dataset_mode, patch_H,
-                                     patch_W, overlap)
-                    lab_prog_bar.update()
-
-        print('Removing the temporary files...')
-
-    print('Done!')
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/dataset_converters/levircd.py b/mmsegmentation/tools/dataset_converters/levircd.py
deleted file mode 100644
index 8717f3e..0000000
--- a/mmsegmentation/tools/dataset_converters/levircd.py
+++ /dev/null
@@ -1,99 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import glob
-import math
-import os
-import os.path as osp
-
-import mmcv
-import numpy as np
-from mmengine.utils import ProgressBar
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Convert levir-cd dataset to mmsegmentation format')
-    parser.add_argument('--dataset_path', help='potsdam folder path')
-    parser.add_argument('-o', '--out_dir', help='output path')
-    parser.add_argument(
-        '--clip_size',
-        type=int,
-        help='clipped size of image after preparation',
-        default=256)
-    parser.add_argument(
-        '--stride_size',
-        type=int,
-        help='stride of clipping original images',
-        default=256)
-    args = parser.parse_args()
-    return args
-
-
-def main():
-    args = parse_args()
-    input_folder = args.dataset_path
-    png_files = glob.glob(
-        os.path.join(input_folder, '**/*.png'), recursive=True)
-    output_folder = args.out_dir
-    prog_bar = ProgressBar(len(png_files))
-    for png_file in png_files:
-        new_path = os.path.join(
-            output_folder,
-            os.path.relpath(os.path.dirname(png_file), input_folder))
-        os.makedirs(os.path.dirname(new_path), exist_ok=True)
-        label = False
-        if 'label' in png_file:
-            label = True
-        clip_big_image(png_file, new_path, args, label)
-        prog_bar.update()
-
-
-def clip_big_image(image_path, clip_save_dir, args, to_label=False):
-    image = mmcv.imread(image_path)
-
-    h, w, c = image.shape
-    clip_size = args.clip_size
-    stride_size = args.stride_size
-
-    num_rows = math.ceil((h - clip_size) / stride_size) if math.ceil(
-        (h - clip_size) /
-        stride_size) * stride_size + clip_size >= h else math.ceil(
-            (h - clip_size) / stride_size) + 1
-    num_cols = math.ceil((w - clip_size) / stride_size) if math.ceil(
-        (w - clip_size) /
-        stride_size) * stride_size + clip_size >= w else math.ceil(
-            (w - clip_size) / stride_size) + 1
-
-    x, y = np.meshgrid(np.arange(num_cols + 1), np.arange(num_rows + 1))
-    xmin = x * clip_size
-    ymin = y * clip_size
-
-    xmin = xmin.ravel()
-    ymin = ymin.ravel()
-    xmin_offset = np.where(xmin + clip_size > w, w - xmin - clip_size,
-                           np.zeros_like(xmin))
-    ymin_offset = np.where(ymin + clip_size > h, h - ymin - clip_size,
-                           np.zeros_like(ymin))
-    boxes = np.stack([
-        xmin + xmin_offset, ymin + ymin_offset,
-        np.minimum(xmin + clip_size, w),
-        np.minimum(ymin + clip_size, h)
-    ],
-                     axis=1)
-
-    if to_label:
-        image[image == 255] = 1
-        image = image[:, :, 0]
-    for box in boxes:
-        start_x, start_y, end_x, end_y = box
-        clipped_image = image[start_y:end_y, start_x:end_x] \
-            if to_label else image[start_y:end_y, start_x:end_x, :]
-        idx = osp.basename(image_path).split('.')[0]
-        mmcv.imwrite(
-            clipped_image.astype(np.uint8),
-            osp.join(clip_save_dir,
-                     f'{idx}_{start_x}_{start_y}_{end_x}_{end_y}.png'))
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/dataset_converters/loveda.py b/mmsegmentation/tools/dataset_converters/loveda.py
deleted file mode 100644
index 5b0ef4b..0000000
--- a/mmsegmentation/tools/dataset_converters/loveda.py
+++ /dev/null
@@ -1,73 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os
-import os.path as osp
-import shutil
-import tempfile
-import zipfile
-
-from mmengine.utils import mkdir_or_exist
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Convert LoveDA dataset to mmsegmentation format')
-    parser.add_argument('dataset_path', help='LoveDA folder path')
-    parser.add_argument('--tmp_dir', help='path of the temporary directory')
-    parser.add_argument('-o', '--out_dir', help='output path')
-    args = parser.parse_args()
-    return args
-
-
-def main():
-    args = parse_args()
-    dataset_path = args.dataset_path
-    if args.out_dir is None:
-        out_dir = osp.join('data', 'loveDA')
-    else:
-        out_dir = args.out_dir
-
-    print('Making directories...')
-    mkdir_or_exist(out_dir)
-    mkdir_or_exist(osp.join(out_dir, 'img_dir'))
-    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'train'))
-    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'val'))
-    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'test'))
-    mkdir_or_exist(osp.join(out_dir, 'ann_dir'))
-    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'train'))
-    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'val'))
-
-    assert 'Train.zip' in os.listdir(dataset_path), \
-        f'Train.zip is not in {dataset_path}'
-    assert 'Val.zip' in os.listdir(dataset_path), \
-        f'Val.zip is not in {dataset_path}'
-    assert 'Test.zip' in os.listdir(dataset_path), \
-        f'Test.zip is not in {dataset_path}'
-
-    with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
-        for dataset in ['Train', 'Val', 'Test']:
-            zip_file = zipfile.ZipFile(
-                os.path.join(dataset_path, dataset + '.zip'))
-            zip_file.extractall(tmp_dir)
-            data_type = dataset.lower()
-            for location in ['Rural', 'Urban']:
-                for image_type in ['images_png', 'masks_png']:
-                    if image_type == 'images_png':
-                        dst = osp.join(out_dir, 'img_dir', data_type)
-                    else:
-                        dst = osp.join(out_dir, 'ann_dir', data_type)
-                    if dataset == 'Test' and image_type == 'masks_png':
-                        continue
-                    else:
-                        src_dir = osp.join(tmp_dir, dataset, location,
-                                           image_type)
-                        src_lst = os.listdir(src_dir)
-                        for file in src_lst:
-                            shutil.move(osp.join(src_dir, file), dst)
-        print('Removing the temporary files...')
-
-    print('Done!')
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/dataset_converters/nyu.py b/mmsegmentation/tools/dataset_converters/nyu.py
deleted file mode 100644
index 49e09e7..0000000
--- a/mmsegmentation/tools/dataset_converters/nyu.py
+++ /dev/null
@@ -1,89 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os.path as osp
-import shutil
-import tempfile
-import zipfile
-
-from mmengine.utils import mkdir_or_exist
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Convert NYU Depth dataset to mmsegmentation format')
-    parser.add_argument('raw_data', help='the path of raw data')
-    parser.add_argument(
-        '-o', '--out_dir', help='output path', default='./data/nyu')
-    args = parser.parse_args()
-    return args
-
-
-def reorganize(raw_data_dir: str, out_dir: str):
-    """Reorganize NYU Depth dataset files into the required directory
-    structure.
-
-    Args:
-        raw_data_dir (str): Path to the raw data directory.
-        out_dir (str): Output directory for the organized dataset.
-    """
-
-    def move_data(data_list, dst_prefix, fname_func):
-        """Move data files from source to destination directory.
-
-        Args:
-            data_list (list): List of data file paths.
-            dst_prefix (str): Prefix to be added to destination paths.
-            fname_func (callable): Function to process file names
-        """
-        for data_item in data_list:
-            data_item = data_item.strip().strip('/')
-            new_item = fname_func(data_item)
-            shutil.move(
-                osp.join(raw_data_dir, data_item),
-                osp.join(out_dir, dst_prefix, new_item))
-
-    def process_phase(phase):
-        """Process a dataset phase (e.g., 'train' or 'test')."""
-        with open(osp.join(raw_data_dir, f'nyu_{phase}.txt')) as f:
-            data = filter(lambda x: len(x.strip()) > 0, f.readlines())
-            data = map(lambda x: x.split()[:2], data)
-            images, annos = zip(*data)
-
-            move_data(images, f'images/{phase}',
-                      lambda x: x.replace('/rgb', ''))
-            move_data(annos, f'annotations/{phase}',
-                      lambda x: x.replace('/sync_depth', ''))
-
-    process_phase('train')
-    process_phase('test')
-
-
-def main():
-    args = parse_args()
-
-    print('Making directories...')
-    mkdir_or_exist(args.out_dir)
-    for subdir in [
-            'images/train', 'images/test', 'annotations/train',
-            'annotations/test'
-    ]:
-        mkdir_or_exist(osp.join(args.out_dir, subdir))
-
-    print('Generating images and annotations...')
-
-    if args.raw_data.endswith('.zip'):
-        with tempfile.TemporaryDirectory() as tmp_dir:
-            zip_file = zipfile.ZipFile(args.raw_data)
-            zip_file.extractall(tmp_dir)
-            reorganize(osp.join(tmp_dir, 'nyu'), args.out_dir)
-    else:
-        assert osp.isdir(
-            args.raw_data
-        ), 'the argument --raw-data should be either a zip file or directory.'
-        reorganize(args.raw_data, args.out_dir)
-
-    print('Done!')
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/dataset_converters/pascal_context.py b/mmsegmentation/tools/dataset_converters/pascal_context.py
deleted file mode 100644
index a92d1dc..0000000
--- a/mmsegmentation/tools/dataset_converters/pascal_context.py
+++ /dev/null
@@ -1,87 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os.path as osp
-from functools import partial
-
-import numpy as np
-from detail import Detail
-from mmengine.utils import mkdir_or_exist, track_progress
-from PIL import Image
-
-_mapping = np.sort(
-    np.array([
-        0, 2, 259, 260, 415, 324, 9, 258, 144, 18, 19, 22, 23, 397, 25, 284,
-        158, 159, 416, 33, 162, 420, 454, 295, 296, 427, 44, 45, 46, 308, 59,
-        440, 445, 31, 232, 65, 354, 424, 68, 326, 72, 458, 34, 207, 80, 355,
-        85, 347, 220, 349, 360, 98, 187, 104, 105, 366, 189, 368, 113, 115
-    ]))
-_key = np.array(range(len(_mapping))).astype('uint8')
-
-
-def generate_labels(img_id, detail, out_dir):
-
-    def _class_to_index(mask, _mapping, _key):
-        # assert the values
-        values = np.unique(mask)
-        for i in range(len(values)):
-            assert (values[i] in _mapping)
-        index = np.digitize(mask.ravel(), _mapping, right=True)
-        return _key[index].reshape(mask.shape)
-
-    mask = Image.fromarray(
-        _class_to_index(detail.getMask(img_id), _mapping=_mapping, _key=_key))
-    filename = img_id['file_name']
-    mask.save(osp.join(out_dir, filename.replace('jpg', 'png')))
-    return osp.splitext(osp.basename(filename))[0]
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Convert PASCAL VOC annotations to mmsegmentation format')
-    parser.add_argument('devkit_path', help='pascal voc devkit path')
-    parser.add_argument('json_path', help='annoation json filepath')
-    parser.add_argument('-o', '--out_dir', help='output path')
-    args = parser.parse_args()
-    return args
-
-
-def main():
-    args = parse_args()
-    devkit_path = args.devkit_path
-    if args.out_dir is None:
-        out_dir = osp.join(devkit_path, 'VOC2010', 'SegmentationClassContext')
-    else:
-        out_dir = args.out_dir
-    json_path = args.json_path
-    mkdir_or_exist(out_dir)
-    img_dir = osp.join(devkit_path, 'VOC2010', 'JPEGImages')
-
-    train_detail = Detail(json_path, img_dir, 'train')
-    train_ids = train_detail.getImgs()
-
-    val_detail = Detail(json_path, img_dir, 'val')
-    val_ids = val_detail.getImgs()
-
-    mkdir_or_exist(
-        osp.join(devkit_path, 'VOC2010/ImageSets/SegmentationContext'))
-
-    train_list = track_progress(
-        partial(generate_labels, detail=train_detail, out_dir=out_dir),
-        train_ids)
-    with open(
-            osp.join(devkit_path, 'VOC2010/ImageSets/SegmentationContext',
-                     'train.txt'), 'w') as f:
-        f.writelines(line + '\n' for line in sorted(train_list))
-
-    val_list = track_progress(
-        partial(generate_labels, detail=val_detail, out_dir=out_dir), val_ids)
-    with open(
-            osp.join(devkit_path, 'VOC2010/ImageSets/SegmentationContext',
-                     'val.txt'), 'w') as f:
-        f.writelines(line + '\n' for line in sorted(val_list))
-
-    print('Done!')
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/dataset_converters/potsdam.py b/mmsegmentation/tools/dataset_converters/potsdam.py
deleted file mode 100644
index f3c713e..0000000
--- a/mmsegmentation/tools/dataset_converters/potsdam.py
+++ /dev/null
@@ -1,158 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import glob
-import math
-import os
-import os.path as osp
-import tempfile
-import zipfile
-
-import mmcv
-import numpy as np
-from mmengine.utils import ProgressBar, mkdir_or_exist
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Convert potsdam dataset to mmsegmentation format')
-    parser.add_argument('dataset_path', help='potsdam folder path')
-    parser.add_argument('--tmp_dir', help='path of the temporary directory')
-    parser.add_argument('-o', '--out_dir', help='output path')
-    parser.add_argument(
-        '--clip_size',
-        type=int,
-        help='clipped size of image after preparation',
-        default=512)
-    parser.add_argument(
-        '--stride_size',
-        type=int,
-        help='stride of clipping original images',
-        default=256)
-    args = parser.parse_args()
-    return args
-
-
-def clip_big_image(image_path, clip_save_dir, args, to_label=False):
-    # Original image of Potsdam dataset is very large, thus pre-processing
-    # of them is adopted. Given fixed clip size and stride size to generate
-    # clipped image, the intersection　of width and height is determined.
-    # For example, given one 5120 x 5120 original image, the clip size is
-    # 512 and stride size is 256, thus it would generate 20x20 = 400 images
-    # whose size are all 512x512.
-    image = mmcv.imread(image_path)
-
-    h, w, c = image.shape
-    clip_size = args.clip_size
-    stride_size = args.stride_size
-
-    num_rows = math.ceil((h - clip_size) / stride_size) if math.ceil(
-        (h - clip_size) /
-        stride_size) * stride_size + clip_size >= h else math.ceil(
-            (h - clip_size) / stride_size) + 1
-    num_cols = math.ceil((w - clip_size) / stride_size) if math.ceil(
-        (w - clip_size) /
-        stride_size) * stride_size + clip_size >= w else math.ceil(
-            (w - clip_size) / stride_size) + 1
-
-    x, y = np.meshgrid(np.arange(num_cols + 1), np.arange(num_rows + 1))
-    xmin = x * clip_size
-    ymin = y * clip_size
-
-    xmin = xmin.ravel()
-    ymin = ymin.ravel()
-    xmin_offset = np.where(xmin + clip_size > w, w - xmin - clip_size,
-                           np.zeros_like(xmin))
-    ymin_offset = np.where(ymin + clip_size > h, h - ymin - clip_size,
-                           np.zeros_like(ymin))
-    boxes = np.stack([
-        xmin + xmin_offset, ymin + ymin_offset,
-        np.minimum(xmin + clip_size, w),
-        np.minimum(ymin + clip_size, h)
-    ],
-                     axis=1)
-
-    if to_label:
-        color_map = np.array([[0, 0, 0], [255, 255, 255], [255, 0, 0],
-                              [255, 255, 0], [0, 255, 0], [0, 255, 255],
-                              [0, 0, 255]])
-        flatten_v = np.matmul(
-            image.reshape(-1, c),
-            np.array([2, 3, 4]).reshape(3, 1))
-        out = np.zeros_like(flatten_v)
-        for idx, class_color in enumerate(color_map):
-            value_idx = np.matmul(class_color,
-                                  np.array([2, 3, 4]).reshape(3, 1))
-            out[flatten_v == value_idx] = idx
-        image = out.reshape(h, w)
-
-    for box in boxes:
-        start_x, start_y, end_x, end_y = box
-        clipped_image = image[start_y:end_y,
-                              start_x:end_x] if to_label else image[
-                                  start_y:end_y, start_x:end_x, :]
-        idx_i, idx_j = osp.basename(image_path).split('_')[2:4]
-        mmcv.imwrite(
-            clipped_image.astype(np.uint8),
-            osp.join(
-                clip_save_dir,
-                f'{idx_i}_{idx_j}_{start_x}_{start_y}_{end_x}_{end_y}.png'))
-
-
-def main():
-    args = parse_args()
-    splits = {
-        'train': [
-            '2_10', '2_11', '2_12', '3_10', '3_11', '3_12', '4_10', '4_11',
-            '4_12', '5_10', '5_11', '5_12', '6_10', '6_11', '6_12', '6_7',
-            '6_8', '6_9', '7_10', '7_11', '7_12', '7_7', '7_8', '7_9'
-        ],
-        'val': [
-            '5_15', '6_15', '6_13', '3_13', '4_14', '6_14', '5_14', '2_13',
-            '4_15', '2_14', '5_13', '4_13', '3_14', '7_13'
-        ]
-    }
-
-    dataset_path = args.dataset_path
-    if args.out_dir is None:
-        out_dir = osp.join('data', 'potsdam')
-    else:
-        out_dir = args.out_dir
-
-    print('Making directories...')
-    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'train'))
-    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'val'))
-    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'train'))
-    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'val'))
-
-    zipp_list = glob.glob(os.path.join(dataset_path, '*.zip'))
-    print('Find the data', zipp_list)
-
-    for zipp in zipp_list:
-        with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
-            zip_file = zipfile.ZipFile(zipp)
-            zip_file.extractall(tmp_dir)
-            src_path_list = glob.glob(os.path.join(tmp_dir, '*.tif'))
-            if not len(src_path_list):
-                sub_tmp_dir = os.path.join(tmp_dir, os.listdir(tmp_dir)[0])
-                src_path_list = glob.glob(os.path.join(sub_tmp_dir, '*.tif'))
-
-            prog_bar = ProgressBar(len(src_path_list))
-            for i, src_path in enumerate(src_path_list):
-                idx_i, idx_j = osp.basename(src_path).split('_')[2:4]
-                data_type = 'train' if f'{idx_i}_{idx_j}' in splits[
-                    'train'] else 'val'
-                if 'label' in src_path:
-                    dst_dir = osp.join(out_dir, 'ann_dir', data_type)
-                    clip_big_image(src_path, dst_dir, args, to_label=True)
-                else:
-                    dst_dir = osp.join(out_dir, 'img_dir', data_type)
-                    clip_big_image(src_path, dst_dir, args, to_label=False)
-                prog_bar.update()
-
-    print('Removing the temporary files...')
-
-    print('Done!')
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/dataset_converters/refuge.py b/mmsegmentation/tools/dataset_converters/refuge.py
deleted file mode 100644
index 1186866..0000000
--- a/mmsegmentation/tools/dataset_converters/refuge.py
+++ /dev/null
@@ -1,110 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os
-import os.path as osp
-import tempfile
-import zipfile
-
-import mmcv
-import numpy as np
-from mmengine.utils import mkdir_or_exist
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Convert REFUGE dataset to mmsegmentation format')
-    parser.add_argument('--raw_data_root', help='the root path of raw data')
-
-    parser.add_argument('--tmp_dir', help='path of the temporary directory')
-    parser.add_argument('-o', '--out_dir', help='output path')
-    args = parser.parse_args()
-    return args
-
-
-def extract_img(root: str,
-                cur_dir: str,
-                out_dir: str,
-                mode: str = 'train',
-                file_type: str = 'img') -> None:
-    """_summary_
-
-    Args:
-       Args:
-        root (str): root where the extracted data is saved
-        cur_dir (cur_dir): dir where the zip_file exists
-        out_dir (str): root dir where the data is saved
-
-        mode (str, optional): Defaults to 'train'.
-        file_type (str, optional): Defaults to 'img',else to 'mask'.
-    """
-    zip_file = zipfile.ZipFile(cur_dir)
-    zip_file.extractall(root)
-    for cur_dir, dirs, files in os.walk(root):
-        # filter child dirs and directories with "Illustration" and "MACOSX"
-        if len(dirs) == 0 and \
-                cur_dir.split('\\')[-1].find('Illustration') == -1 and \
-                cur_dir.find('MACOSX') == -1:
-
-            file_names = [
-                file for file in files
-                if file.endswith('.jpg') or file.endswith('.bmp')
-            ]
-            for filename in sorted(file_names):
-                img = mmcv.imread(osp.join(cur_dir, filename))
-
-                if file_type == 'annotations':
-                    img = img[:, :, 0]
-                    img[np.where(img == 0)] = 1
-                    img[np.where(img == 128)] = 2
-                    img[np.where(img == 255)] = 0
-                mmcv.imwrite(
-                    img,
-                    osp.join(out_dir, file_type, mode,
-                             osp.splitext(filename)[0] + '.png'))
-
-
-def main():
-    args = parse_args()
-
-    raw_data_root = args.raw_data_root
-    if args.out_dir is None:
-        out_dir = osp.join('./data', 'REFUGE')
-
-    else:
-        out_dir = args.out_dir
-
-    print('Making directories...')
-    mkdir_or_exist(out_dir)
-    mkdir_or_exist(osp.join(out_dir, 'images'))
-    mkdir_or_exist(osp.join(out_dir, 'images', 'training'))
-    mkdir_or_exist(osp.join(out_dir, 'images', 'validation'))
-    mkdir_or_exist(osp.join(out_dir, 'images', 'test'))
-    mkdir_or_exist(osp.join(out_dir, 'annotations'))
-    mkdir_or_exist(osp.join(out_dir, 'annotations', 'training'))
-    mkdir_or_exist(osp.join(out_dir, 'annotations', 'validation'))
-    mkdir_or_exist(osp.join(out_dir, 'annotations', 'test'))
-
-    print('Generating images and annotations...')
-    # process data from the child dir on the first rank
-    cur_dir, dirs, files = list(os.walk(raw_data_root))[0]
-    print('====================')
-
-    files = list(filter(lambda x: x.endswith('.zip'), files))
-
-    with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
-        for file in files:
-            # search data folders for training,validation,test
-            mode = list(
-                filter(lambda x: file.lower().find(x) != -1,
-                       ['training', 'test', 'validation']))[0]
-            file_root = osp.join(tmp_dir, file[:-4])
-            file_type = 'images' if file.find('Anno') == -1 and file.find(
-                'GT') == -1 else 'annotations'
-            extract_img(file_root, osp.join(cur_dir, file), out_dir, mode,
-                        file_type)
-
-    print('Done!')
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/dataset_converters/stare.py b/mmsegmentation/tools/dataset_converters/stare.py
deleted file mode 100644
index 4a23ba4..0000000
--- a/mmsegmentation/tools/dataset_converters/stare.py
+++ /dev/null
@@ -1,167 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import gzip
-import os
-import os.path as osp
-import tarfile
-import tempfile
-
-import mmcv
-from mmengine.utils import mkdir_or_exist
-
-STARE_LEN = 20
-TRAINING_LEN = 10
-
-
-def un_gz(src, dst):
-    g_file = gzip.GzipFile(src)
-    with open(dst, 'wb+') as f:
-        f.write(g_file.read())
-    g_file.close()
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Convert STARE dataset to mmsegmentation format')
-    parser.add_argument('image_path', help='the path of stare-images.tar')
-    parser.add_argument('labels_ah', help='the path of labels-ah.tar')
-    parser.add_argument('labels_vk', help='the path of labels-vk.tar')
-    parser.add_argument('--tmp_dir', help='path of the temporary directory')
-    parser.add_argument('-o', '--out_dir', help='output path')
-    args = parser.parse_args()
-    return args
-
-
-def main():
-    args = parse_args()
-    image_path = args.image_path
-    labels_ah = args.labels_ah
-    labels_vk = args.labels_vk
-    if args.out_dir is None:
-        out_dir = osp.join('data', 'STARE')
-    else:
-        out_dir = args.out_dir
-
-    print('Making directories...')
-    mkdir_or_exist(out_dir)
-    mkdir_or_exist(osp.join(out_dir, 'images'))
-    mkdir_or_exist(osp.join(out_dir, 'images', 'training'))
-    mkdir_or_exist(osp.join(out_dir, 'images', 'validation'))
-    mkdir_or_exist(osp.join(out_dir, 'annotations'))
-    mkdir_or_exist(osp.join(out_dir, 'annotations', 'training'))
-    mkdir_or_exist(osp.join(out_dir, 'annotations', 'validation'))
-
-    with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
-        mkdir_or_exist(osp.join(tmp_dir, 'gz'))
-        mkdir_or_exist(osp.join(tmp_dir, 'files'))
-
-        print('Extracting stare-images.tar...')
-        with tarfile.open(image_path) as f:
-            f.extractall(osp.join(tmp_dir, 'gz'))
-
-        for filename in os.listdir(osp.join(tmp_dir, 'gz')):
-            un_gz(
-                osp.join(tmp_dir, 'gz', filename),
-                osp.join(tmp_dir, 'files',
-                         osp.splitext(filename)[0]))
-
-        now_dir = osp.join(tmp_dir, 'files')
-
-        assert len(os.listdir(now_dir)) == STARE_LEN, \
-            f'len(os.listdir(now_dir)) != {STARE_LEN}'
-
-        for filename in sorted(os.listdir(now_dir))[:TRAINING_LEN]:
-            img = mmcv.imread(osp.join(now_dir, filename))
-            mmcv.imwrite(
-                img,
-                osp.join(out_dir, 'images', 'training',
-                         osp.splitext(filename)[0] + '.png'))
-
-        for filename in sorted(os.listdir(now_dir))[TRAINING_LEN:]:
-            img = mmcv.imread(osp.join(now_dir, filename))
-            mmcv.imwrite(
-                img,
-                osp.join(out_dir, 'images', 'validation',
-                         osp.splitext(filename)[0] + '.png'))
-
-        print('Removing the temporary files...')
-
-    with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
-        mkdir_or_exist(osp.join(tmp_dir, 'gz'))
-        mkdir_or_exist(osp.join(tmp_dir, 'files'))
-
-        print('Extracting labels-ah.tar...')
-        with tarfile.open(labels_ah) as f:
-            f.extractall(osp.join(tmp_dir, 'gz'))
-
-        for filename in os.listdir(osp.join(tmp_dir, 'gz')):
-            un_gz(
-                osp.join(tmp_dir, 'gz', filename),
-                osp.join(tmp_dir, 'files',
-                         osp.splitext(filename)[0]))
-
-        now_dir = osp.join(tmp_dir, 'files')
-
-        assert len(os.listdir(now_dir)) == STARE_LEN, \
-            f'len(os.listdir(now_dir)) != {STARE_LEN}'
-
-        for filename in sorted(os.listdir(now_dir))[:TRAINING_LEN]:
-            img = mmcv.imread(osp.join(now_dir, filename))
-            # The annotation img should be divided by 128, because some of
-            # the annotation imgs are not standard. We should set a threshold
-            # to convert the nonstandard annotation imgs. The value divided by
-            # 128 equivalent to '1 if value >= 128 else 0'
-            mmcv.imwrite(
-                img[:, :, 0] // 128,
-                osp.join(out_dir, 'annotations', 'training',
-                         osp.splitext(filename)[0] + '.png'))
-
-        for filename in sorted(os.listdir(now_dir))[TRAINING_LEN:]:
-            img = mmcv.imread(osp.join(now_dir, filename))
-            mmcv.imwrite(
-                img[:, :, 0] // 128,
-                osp.join(out_dir, 'annotations', 'validation',
-                         osp.splitext(filename)[0] + '.png'))
-
-        print('Removing the temporary files...')
-
-    with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
-        mkdir_or_exist(osp.join(tmp_dir, 'gz'))
-        mkdir_or_exist(osp.join(tmp_dir, 'files'))
-
-        print('Extracting labels-vk.tar...')
-        with tarfile.open(labels_vk) as f:
-            f.extractall(osp.join(tmp_dir, 'gz'))
-
-        for filename in os.listdir(osp.join(tmp_dir, 'gz')):
-            un_gz(
-                osp.join(tmp_dir, 'gz', filename),
-                osp.join(tmp_dir, 'files',
-                         osp.splitext(filename)[0]))
-
-        now_dir = osp.join(tmp_dir, 'files')
-
-        assert len(os.listdir(now_dir)) == STARE_LEN, \
-            f'len(os.listdir(now_dir)) != {STARE_LEN}'
-
-        for filename in sorted(os.listdir(now_dir))[:TRAINING_LEN]:
-            img = mmcv.imread(osp.join(now_dir, filename))
-            mmcv.imwrite(
-                img[:, :, 0] // 128,
-                osp.join(out_dir, 'annotations', 'training',
-                         osp.splitext(filename)[0] + '.png'))
-
-        for filename in sorted(os.listdir(now_dir))[TRAINING_LEN:]:
-            img = mmcv.imread(osp.join(now_dir, filename))
-            mmcv.imwrite(
-                img[:, :, 0] // 128,
-                osp.join(out_dir, 'annotations', 'validation',
-                         osp.splitext(filename)[0] + '.png'))
-
-        print('Removing the temporary files...')
-
-    print('Done!')
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/dataset_converters/synapse.py b/mmsegmentation/tools/dataset_converters/synapse.py
deleted file mode 100644
index 42dac6b..0000000
--- a/mmsegmentation/tools/dataset_converters/synapse.py
+++ /dev/null
@@ -1,155 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os.path as osp
-
-import nibabel as nib
-import numpy as np
-from mmengine.utils import mkdir_or_exist
-from PIL import Image
-
-
-def read_files_from_txt(txt_path):
-    with open(txt_path) as f:
-        files = f.readlines()
-    files = [file.strip() for file in files]
-    return files
-
-
-def read_nii_file(nii_path):
-    img = nib.load(nii_path).get_fdata()
-    return img
-
-
-def split_3d_image(img):
-    c, _, _ = img.shape
-    res = []
-    for i in range(c):
-        res.append(img[i, :, :])
-    return res
-
-
-def label_mapping(label):
-    """Label mapping from TransUNet paper setting. It only has 9 classes, which
-    are 'background', 'aorta', 'gallbladder', 'left_kidney', 'right_kidney',
-    'liver', 'pancreas', 'spleen', 'stomach', respectively. Other foreground
-    classes in original dataset are all set to background.
-
-    More details could be found here: https://arxiv.org/abs/2102.04306
-    """
-    maped_label = np.zeros_like(label)
-    maped_label[label == 8] = 1
-    maped_label[label == 4] = 2
-    maped_label[label == 3] = 3
-    maped_label[label == 2] = 4
-    maped_label[label == 6] = 5
-    maped_label[label == 11] = 6
-    maped_label[label == 1] = 7
-    maped_label[label == 7] = 8
-    return maped_label
-
-
-def pares_args():
-    parser = argparse.ArgumentParser(
-        description='Convert synapse dataset to mmsegmentation format')
-    parser.add_argument(
-        '--dataset-path', type=str, help='synapse dataset path.')
-    parser.add_argument(
-        '--save-path',
-        default='data/synapse',
-        type=str,
-        help='save path of the dataset.')
-    args = parser.parse_args()
-    return args
-
-
-def main():
-    args = pares_args()
-    dataset_path = args.dataset_path
-    save_path = args.save_path
-
-    if not osp.exists(dataset_path):
-        raise ValueError('The dataset path does not exist. '
-                         'Please enter a correct dataset path.')
-    if not osp.exists(osp.join(dataset_path, 'img')) \
-            or not osp.exists(osp.join(dataset_path, 'label')):
-        raise FileNotFoundError('The dataset structure is incorrect. '
-                                'Please check your dataset.')
-
-    train_id = read_files_from_txt(osp.join(dataset_path, 'train.txt'))
-    train_id = [idx[3:7] for idx in train_id]
-
-    test_id = read_files_from_txt(osp.join(dataset_path, 'val.txt'))
-    test_id = [idx[3:7] for idx in test_id]
-
-    mkdir_or_exist(osp.join(save_path, 'img_dir/train'))
-    mkdir_or_exist(osp.join(save_path, 'img_dir/val'))
-    mkdir_or_exist(osp.join(save_path, 'ann_dir/train'))
-    mkdir_or_exist(osp.join(save_path, 'ann_dir/val'))
-
-    # It follows data preparation pipeline from here:
-    # https://github.com/Beckschen/TransUNet/tree/main/datasets
-    for i, idx in enumerate(train_id):
-        img_3d = read_nii_file(
-            osp.join(dataset_path, 'img', 'img' + idx + '.nii.gz'))
-        label_3d = read_nii_file(
-            osp.join(dataset_path, 'label', 'label' + idx + '.nii.gz'))
-
-        img_3d = np.clip(img_3d, -125, 275)
-        img_3d = (img_3d + 125) / 400
-        img_3d *= 255
-        img_3d = np.transpose(img_3d, [2, 0, 1])
-        img_3d = np.flip(img_3d, 2)
-
-        label_3d = np.transpose(label_3d, [2, 0, 1])
-        label_3d = np.flip(label_3d, 2)
-        label_3d = label_mapping(label_3d)
-
-        for c in range(img_3d.shape[0]):
-            img = img_3d[c]
-            label = label_3d[c]
-
-            img = Image.fromarray(img).convert('RGB')
-            label = Image.fromarray(label).convert('L')
-            img.save(
-                osp.join(
-                    save_path, 'img_dir/train', 'case' + idx.zfill(4) +
-                    '_slice' + str(c).zfill(3) + '.jpg'))
-            label.save(
-                osp.join(
-                    save_path, 'ann_dir/train', 'case' + idx.zfill(4) +
-                    '_slice' + str(c).zfill(3) + '.png'))
-
-    for i, idx in enumerate(test_id):
-        img_3d = read_nii_file(
-            osp.join(dataset_path, 'img', 'img' + idx + '.nii.gz'))
-        label_3d = read_nii_file(
-            osp.join(dataset_path, 'label', 'label' + idx + '.nii.gz'))
-
-        img_3d = np.clip(img_3d, -125, 275)
-        img_3d = (img_3d + 125) / 400
-        img_3d *= 255
-        img_3d = np.transpose(img_3d, [2, 0, 1])
-        img_3d = np.flip(img_3d, 2)
-
-        label_3d = np.transpose(label_3d, [2, 0, 1])
-        label_3d = np.flip(label_3d, 2)
-        label_3d = label_mapping(label_3d)
-
-        for c in range(img_3d.shape[0]):
-            img = img_3d[c]
-            label = label_3d[c]
-
-            img = Image.fromarray(img).convert('RGB')
-            label = Image.fromarray(label).convert('L')
-            img.save(
-                osp.join(
-                    save_path, 'img_dir/val', 'case' + idx.zfill(4) +
-                    '_slice' + str(c).zfill(3) + '.jpg'))
-            label.save(
-                osp.join(
-                    save_path, 'ann_dir/val', 'case' + idx.zfill(4) +
-                    '_slice' + str(c).zfill(3) + '.png'))
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/dataset_converters/vaihingen.py b/mmsegmentation/tools/dataset_converters/vaihingen.py
deleted file mode 100644
index db98014..0000000
--- a/mmsegmentation/tools/dataset_converters/vaihingen.py
+++ /dev/null
@@ -1,156 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import glob
-import math
-import os
-import os.path as osp
-import tempfile
-import zipfile
-
-import mmcv
-import numpy as np
-from mmengine.utils import ProgressBar, mkdir_or_exist
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Convert vaihingen dataset to mmsegmentation format')
-    parser.add_argument('dataset_path', help='vaihingen folder path')
-    parser.add_argument('--tmp_dir', help='path of the temporary directory')
-    parser.add_argument('-o', '--out_dir', help='output path')
-    parser.add_argument(
-        '--clip_size',
-        type=int,
-        help='clipped size of image after preparation',
-        default=512)
-    parser.add_argument(
-        '--stride_size',
-        type=int,
-        help='stride of clipping original images',
-        default=256)
-    args = parser.parse_args()
-    return args
-
-
-def clip_big_image(image_path, clip_save_dir, to_label=False):
-    # Original image of Vaihingen dataset is very large, thus pre-processing
-    # of them is adopted. Given fixed clip size and stride size to generate
-    # clipped image, the intersection　of width and height is determined.
-    # For example, given one 5120 x 5120 original image, the clip size is
-    # 512 and stride size is 256, thus it would generate 20x20 = 400 images
-    # whose size are all 512x512.
-    image = mmcv.imread(image_path)
-
-    h, w, c = image.shape
-    cs = args.clip_size
-    ss = args.stride_size
-
-    num_rows = math.ceil((h - cs) / ss) if math.ceil(
-        (h - cs) / ss) * ss + cs >= h else math.ceil((h - cs) / ss) + 1
-    num_cols = math.ceil((w - cs) / ss) if math.ceil(
-        (w - cs) / ss) * ss + cs >= w else math.ceil((w - cs) / ss) + 1
-
-    x, y = np.meshgrid(np.arange(num_cols + 1), np.arange(num_rows + 1))
-    xmin = x * cs
-    ymin = y * cs
-
-    xmin = xmin.ravel()
-    ymin = ymin.ravel()
-    xmin_offset = np.where(xmin + cs > w, w - xmin - cs, np.zeros_like(xmin))
-    ymin_offset = np.where(ymin + cs > h, h - ymin - cs, np.zeros_like(ymin))
-    boxes = np.stack([
-        xmin + xmin_offset, ymin + ymin_offset,
-        np.minimum(xmin + cs, w),
-        np.minimum(ymin + cs, h)
-    ],
-                     axis=1)
-
-    if to_label:
-        color_map = np.array([[0, 0, 0], [255, 255, 255], [255, 0, 0],
-                              [255, 255, 0], [0, 255, 0], [0, 255, 255],
-                              [0, 0, 255]])
-        flatten_v = np.matmul(
-            image.reshape(-1, c),
-            np.array([2, 3, 4]).reshape(3, 1))
-        out = np.zeros_like(flatten_v)
-        for idx, class_color in enumerate(color_map):
-            value_idx = np.matmul(class_color,
-                                  np.array([2, 3, 4]).reshape(3, 1))
-            out[flatten_v == value_idx] = idx
-        image = out.reshape(h, w)
-
-    for box in boxes:
-        start_x, start_y, end_x, end_y = box
-        clipped_image = image[start_y:end_y,
-                              start_x:end_x] if to_label else image[
-                                  start_y:end_y, start_x:end_x, :]
-        area_idx = osp.basename(image_path).split('_')[3].strip('.tif')
-        mmcv.imwrite(
-            clipped_image.astype(np.uint8),
-            osp.join(clip_save_dir,
-                     f'{area_idx}_{start_x}_{start_y}_{end_x}_{end_y}.png'))
-
-
-def main():
-    splits = {
-        'train': [
-            'area1', 'area11', 'area13', 'area15', 'area17', 'area21',
-            'area23', 'area26', 'area28', 'area3', 'area30', 'area32',
-            'area34', 'area37', 'area5', 'area7'
-        ],
-        'val': [
-            'area6', 'area24', 'area35', 'area16', 'area14', 'area22',
-            'area10', 'area4', 'area2', 'area20', 'area8', 'area31', 'area33',
-            'area27', 'area38', 'area12', 'area29'
-        ],
-    }
-
-    dataset_path = args.dataset_path
-    if args.out_dir is None:
-        out_dir = osp.join('data', 'vaihingen')
-    else:
-        out_dir = args.out_dir
-
-    print('Making directories...')
-    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'train'))
-    mkdir_or_exist(osp.join(out_dir, 'img_dir', 'val'))
-    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'train'))
-    mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'val'))
-
-    zipp_list = glob.glob(os.path.join(dataset_path, '*.zip'))
-    print('Find the data', zipp_list)
-
-    with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
-        for zipp in zipp_list:
-            zip_file = zipfile.ZipFile(zipp)
-            zip_file.extractall(tmp_dir)
-            src_path_list = glob.glob(os.path.join(tmp_dir, '*.tif'))
-            if 'ISPRS_semantic_labeling_Vaihingen' in zipp:
-                src_path_list = glob.glob(
-                    os.path.join(os.path.join(tmp_dir, 'top'), '*.tif'))
-            if 'ISPRS_semantic_labeling_Vaihingen_ground_truth_eroded_COMPLETE' in zipp:  # noqa
-                src_path_list = glob.glob(os.path.join(tmp_dir, '*.tif'))
-                # delete unused area9 ground truth
-                for area_ann in src_path_list:
-                    if 'area9' in area_ann:
-                        src_path_list.remove(area_ann)
-            prog_bar = ProgressBar(len(src_path_list))
-            for i, src_path in enumerate(src_path_list):
-                area_idx = osp.basename(src_path).split('_')[3].strip('.tif')
-                data_type = 'train' if area_idx in splits['train'] else 'val'
-                if 'noBoundary' in src_path:
-                    dst_dir = osp.join(out_dir, 'ann_dir', data_type)
-                    clip_big_image(src_path, dst_dir, to_label=True)
-                else:
-                    dst_dir = osp.join(out_dir, 'img_dir', data_type)
-                    clip_big_image(src_path, dst_dir, to_label=False)
-                prog_bar.update()
-
-        print('Removing the temporary files...')
-
-    print('Done!')
-
-
-if __name__ == '__main__':
-    args = parse_args()
-    main()
diff --git a/mmsegmentation/tools/dataset_converters/voc_aug.py b/mmsegmentation/tools/dataset_converters/voc_aug.py
deleted file mode 100644
index a536f42..0000000
--- a/mmsegmentation/tools/dataset_converters/voc_aug.py
+++ /dev/null
@@ -1,92 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os.path as osp
-from functools import partial
-
-import numpy as np
-from mmengine.utils import mkdir_or_exist, scandir, track_parallel_progress
-from PIL import Image
-from scipy.io import loadmat
-
-AUG_LEN = 10582
-
-
-def convert_mat(mat_file, in_dir, out_dir):
-    data = loadmat(osp.join(in_dir, mat_file))
-    mask = data['GTcls'][0]['Segmentation'][0].astype(np.uint8)
-    seg_filename = osp.join(out_dir, mat_file.replace('.mat', '.png'))
-    Image.fromarray(mask).save(seg_filename, 'PNG')
-
-
-def generate_aug_list(merged_list, excluded_list):
-    return list(set(merged_list) - set(excluded_list))
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Convert PASCAL VOC annotations to mmsegmentation format')
-    parser.add_argument('devkit_path', help='pascal voc devkit path')
-    parser.add_argument('aug_path', help='pascal voc aug path')
-    parser.add_argument('-o', '--out_dir', help='output path')
-    parser.add_argument(
-        '--nproc', default=1, type=int, help='number of process')
-    args = parser.parse_args()
-    return args
-
-
-def main():
-    args = parse_args()
-    devkit_path = args.devkit_path
-    aug_path = args.aug_path
-    nproc = args.nproc
-    if args.out_dir is None:
-        out_dir = osp.join(devkit_path, 'VOC2012', 'SegmentationClassAug')
-    else:
-        out_dir = args.out_dir
-    mkdir_or_exist(out_dir)
-    in_dir = osp.join(aug_path, 'dataset', 'cls')
-
-    track_parallel_progress(
-        partial(convert_mat, in_dir=in_dir, out_dir=out_dir),
-        list(scandir(in_dir, suffix='.mat')),
-        nproc=nproc)
-
-    full_aug_list = []
-    with open(osp.join(aug_path, 'dataset', 'train.txt')) as f:
-        full_aug_list += [line.strip() for line in f]
-    with open(osp.join(aug_path, 'dataset', 'val.txt')) as f:
-        full_aug_list += [line.strip() for line in f]
-
-    with open(
-            osp.join(devkit_path, 'VOC2012/ImageSets/Segmentation',
-                     'train.txt')) as f:
-        ori_train_list = [line.strip() for line in f]
-    with open(
-            osp.join(devkit_path, 'VOC2012/ImageSets/Segmentation',
-                     'val.txt')) as f:
-        val_list = [line.strip() for line in f]
-
-    aug_train_list = generate_aug_list(ori_train_list + full_aug_list,
-                                       val_list)
-    assert len(aug_train_list) == AUG_LEN, 'len(aug_train_list) != {}'.format(
-        AUG_LEN)
-
-    with open(
-            osp.join(devkit_path, 'VOC2012/ImageSets/Segmentation',
-                     'trainaug.txt'), 'w') as f:
-        f.writelines(line + '\n' for line in aug_train_list)
-
-    aug_list = generate_aug_list(full_aug_list, ori_train_list + val_list)
-    assert len(aug_list) == AUG_LEN - len(
-        ori_train_list), 'len(aug_list) != {}'.format(AUG_LEN -
-                                                      len(ori_train_list))
-    with open(
-            osp.join(devkit_path, 'VOC2012/ImageSets/Segmentation', 'aug.txt'),
-            'w') as f:
-        f.writelines(line + '\n' for line in aug_list)
-
-    print('Done!')
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/deployment/pytorch2torchscript.py b/mmsegmentation/tools/deployment/pytorch2torchscript.py
deleted file mode 100644
index e69e705..0000000
--- a/mmsegmentation/tools/deployment/pytorch2torchscript.py
+++ /dev/null
@@ -1,185 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-
-import numpy as np
-import torch
-import torch._C
-import torch.serialization
-from mmengine import Config
-from mmengine.runner import load_checkpoint
-from torch import nn
-
-from mmseg.models import build_segmentor
-
-torch.manual_seed(3)
-
-
-def digit_version(version_str):
-    digit_version = []
-    for x in version_str.split('.'):
-        if x.isdigit():
-            digit_version.append(int(x))
-        elif x.find('rc') != -1:
-            patch_version = x.split('rc')
-            digit_version.append(int(patch_version[0]) - 1)
-            digit_version.append(int(patch_version[1]))
-    return digit_version
-
-
-def check_torch_version():
-    torch_minimum_version = '1.8.0'
-    torch_version = digit_version(torch.__version__)
-
-    assert (torch_version >= digit_version(torch_minimum_version)), \
-        f'Torch=={torch.__version__} is not support for converting to ' \
-        f'torchscript. Please install pytorch>={torch_minimum_version}.'
-
-
-def _convert_batchnorm(module):
-    module_output = module
-    if isinstance(module, torch.nn.SyncBatchNorm):
-        module_output = torch.nn.BatchNorm2d(module.num_features, module.eps,
-                                             module.momentum, module.affine,
-                                             module.track_running_stats)
-        if module.affine:
-            module_output.weight.data = module.weight.data.clone().detach()
-            module_output.bias.data = module.bias.data.clone().detach()
-            # keep requires_grad unchanged
-            module_output.weight.requires_grad = module.weight.requires_grad
-            module_output.bias.requires_grad = module.bias.requires_grad
-        module_output.running_mean = module.running_mean
-        module_output.running_var = module.running_var
-        module_output.num_batches_tracked = module.num_batches_tracked
-    for name, child in module.named_children():
-        module_output.add_module(name, _convert_batchnorm(child))
-    del module
-    return module_output
-
-
-def _demo_mm_inputs(input_shape, num_classes):
-    """Create a superset of inputs needed to run test or train batches.
-
-    Args:
-        input_shape (tuple):
-            input batch dimensions
-        num_classes (int):
-            number of semantic classes
-    """
-    (N, C, H, W) = input_shape
-    rng = np.random.RandomState(0)
-    imgs = rng.rand(*input_shape)
-    segs = rng.randint(
-        low=0, high=num_classes - 1, size=(N, 1, H, W)).astype(np.uint8)
-    img_metas = [{
-        'img_shape': (H, W, C),
-        'ori_shape': (H, W, C),
-        'pad_shape': (H, W, C),
-        'filename': '<demo>.png',
-        'scale_factor': 1.0,
-        'flip': False,
-    } for _ in range(N)]
-    mm_inputs = {
-        'imgs': torch.FloatTensor(imgs).requires_grad_(True),
-        'img_metas': img_metas,
-        'gt_semantic_seg': torch.LongTensor(segs)
-    }
-    return mm_inputs
-
-
-def pytorch2libtorch(model,
-                     input_shape,
-                     show=False,
-                     output_file='tmp.pt',
-                     verify=False):
-    """Export Pytorch model to TorchScript model and verify the outputs are
-    same between Pytorch and TorchScript.
-
-    Args:
-        model (nn.Module): Pytorch model we want to export.
-        input_shape (tuple): Use this input shape to construct
-            the corresponding dummy input and execute the model.
-        show (bool): Whether print the computation graph. Default: False.
-        output_file (string): The path to where we store the
-            output TorchScript model. Default: `tmp.pt`.
-        verify (bool): Whether compare the outputs between
-            Pytorch and TorchScript. Default: False.
-    """
-    if isinstance(model.decode_head, nn.ModuleList):
-        num_classes = model.decode_head[-1].num_classes
-    else:
-        num_classes = model.decode_head.num_classes
-
-    mm_inputs = _demo_mm_inputs(input_shape, num_classes)
-
-    imgs = mm_inputs.pop('imgs')
-
-    # replace the original forword with forward_dummy
-    model.forward = model.forward_dummy
-    model.eval()
-    traced_model = torch.jit.trace(
-        model,
-        example_inputs=imgs,
-        check_trace=verify,
-    )
-
-    if show:
-        print(traced_model.graph)
-
-    traced_model.save(output_file)
-    print(f'Successfully exported TorchScript model: {output_file}')
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Convert MMSeg to TorchScript')
-    parser.add_argument('config', help='test config file path')
-    parser.add_argument('--checkpoint', help='checkpoint file', default=None)
-    parser.add_argument(
-        '--show', action='store_true', help='show TorchScript graph')
-    parser.add_argument(
-        '--verify', action='store_true', help='verify the TorchScript model')
-    parser.add_argument('--output-file', type=str, default='tmp.pt')
-    parser.add_argument(
-        '--shape',
-        type=int,
-        nargs='+',
-        default=[512, 512],
-        help='input image size (height, width)')
-    args = parser.parse_args()
-    return args
-
-
-if __name__ == '__main__':
-    args = parse_args()
-    check_torch_version()
-
-    if len(args.shape) == 1:
-        input_shape = (1, 3, args.shape[0], args.shape[0])
-    elif len(args.shape) == 2:
-        input_shape = (
-            1,
-            3,
-        ) + tuple(args.shape)
-    else:
-        raise ValueError('invalid input shape')
-
-    cfg = Config.fromfile(args.config)
-    cfg.model.pretrained = None
-
-    # build the model and load checkpoint
-    cfg.model.train_cfg = None
-    segmentor = build_segmentor(
-        cfg.model, train_cfg=None, test_cfg=cfg.get('test_cfg'))
-    # convert SyncBN to BN
-    segmentor = _convert_batchnorm(segmentor)
-
-    if args.checkpoint:
-        load_checkpoint(segmentor, args.checkpoint, map_location='cpu')
-
-    # convert the PyTorch model to LibTorch model
-    pytorch2libtorch(
-        segmentor,
-        input_shape,
-        show=args.show,
-        output_file=args.output_file,
-        verify=args.verify)
diff --git a/mmsegmentation/tools/dist_test.sh b/mmsegmentation/tools/dist_test.sh
deleted file mode 100755
index 89711fd..0000000
--- a/mmsegmentation/tools/dist_test.sh
+++ /dev/null
@@ -1,20 +0,0 @@
-CONFIG=$1
-CHECKPOINT=$2
-GPUS=$3
-NNODES=${NNODES:-1}
-NODE_RANK=${NODE_RANK:-0}
-PORT=${PORT:-29500}
-MASTER_ADDR=${MASTER_ADDR:-"127.0.0.1"}
-
-PYTHONPATH="$(dirname $0)/..":$PYTHONPATH \
-python -m torch.distributed.launch \
-    --nnodes=$NNODES \
-    --node_rank=$NODE_RANK \
-    --master_addr=$MASTER_ADDR \
-    --nproc_per_node=$GPUS \
-    --master_port=$PORT \
-    $(dirname "$0")/test.py \
-    $CONFIG \
-    $CHECKPOINT \
-    --launcher pytorch \
-    ${@:4}
diff --git a/mmsegmentation/tools/dist_train.sh b/mmsegmentation/tools/dist_train.sh
deleted file mode 100755
index a857df7..0000000
--- a/mmsegmentation/tools/dist_train.sh
+++ /dev/null
@@ -1,17 +0,0 @@
-CONFIG=$1
-GPUS=$2
-NNODES=${NNODES:-1}
-NODE_RANK=${NODE_RANK:-0}
-PORT=${PORT:-29500}
-MASTER_ADDR=${MASTER_ADDR:-"127.0.0.1"}
-
-PYTHONPATH="$(dirname $0)/..":$PYTHONPATH \
-python -m torch.distributed.launch \
-    --nnodes=$NNODES \
-    --node_rank=$NODE_RANK \
-    --master_addr=$MASTER_ADDR \
-    --nproc_per_node=$GPUS \
-    --master_port=$PORT \
-    $(dirname "$0")/train.py \
-    $CONFIG \
-    --launcher pytorch ${@:3}
diff --git a/mmsegmentation/tools/misc/browse_dataset.py b/mmsegmentation/tools/misc/browse_dataset.py
deleted file mode 100644
index 7863eb7..0000000
--- a/mmsegmentation/tools/misc/browse_dataset.py
+++ /dev/null
@@ -1,73 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os.path as osp
-
-from mmengine import Config, DictAction
-from mmengine.registry import init_default_scope
-from mmengine.utils import ProgressBar
-
-from mmseg.registry import DATASETS, VISUALIZERS
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(description='Browse a dataset')
-    parser.add_argument('config', help='train config file path')
-    parser.add_argument(
-        '--output-dir',
-        default=None,
-        type=str,
-        help='If there is no display interface, you can save it')
-    parser.add_argument('--not-show', default=False, action='store_true')
-    parser.add_argument(
-        '--show-interval',
-        type=float,
-        default=2,
-        help='the interval of show (s)')
-    parser.add_argument(
-        '--cfg-options',
-        nargs='+',
-        action=DictAction,
-        help='override some settings in the used config, the key-value pair '
-        'in xxx=yyy format will be merged into config file. If the value to '
-        'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
-        'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
-        'Note that the quotation marks are necessary and that no white space '
-        'is allowed.')
-    args = parser.parse_args()
-    return args
-
-
-def main():
-    args = parse_args()
-    cfg = Config.fromfile(args.config)
-    if args.cfg_options is not None:
-        cfg.merge_from_dict(args.cfg_options)
-
-    # register all modules in mmseg into the registries
-    init_default_scope('mmseg')
-
-    dataset = DATASETS.build(cfg.train_dataloader.dataset)
-    cfg.visualizer['save_dir'] = args.output_dir
-    visualizer = VISUALIZERS.build(cfg.visualizer)
-    visualizer.dataset_meta = dataset.METAINFO
-
-    progress_bar = ProgressBar(len(dataset))
-    for item in dataset:
-        img = item['inputs'].permute(1, 2, 0).numpy()
-        data_sample = item['data_samples'].numpy()
-        img_path = osp.basename(item['data_samples'].img_path)
-
-        img = img[..., [2, 1, 0]]  # bgr to rgb
-
-        visualizer.add_datasample(
-            osp.basename(img_path),
-            img,
-            data_sample,
-            show=not args.not_show,
-            wait_time=args.show_interval)
-
-        progress_bar.update()
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/misc/print_config.py b/mmsegmentation/tools/misc/print_config.py
deleted file mode 100644
index 2a1c024..0000000
--- a/mmsegmentation/tools/misc/print_config.py
+++ /dev/null
@@ -1,69 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import warnings
-
-from mmengine import Config, DictAction
-
-from mmseg.apis import init_model
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(description='Print the whole config')
-    parser.add_argument('config', help='config file path')
-    parser.add_argument(
-        '--graph', action='store_true', help='print the models graph')
-    parser.add_argument(
-        '--options',
-        nargs='+',
-        action=DictAction,
-        help="--options is deprecated in favor of --cfg_options' and it will "
-        'not be supported in version v0.22.0. Override some settings in the '
-        'used config, the key-value pair in xxx=yyy format will be merged '
-        'into config file. If the value to be overwritten is a list, it '
-        'should be like key="[a,b]" or key=a,b It also allows nested '
-        'list/tuple values, e.g. key="[(a,b),(c,d)]" Note that the quotation '
-        'marks are necessary and that no white space is allowed.')
-    parser.add_argument(
-        '--cfg-options',
-        nargs='+',
-        action=DictAction,
-        help='override some settings in the used config, the key-value pair '
-        'in xxx=yyy format will be merged into config file. If the value to '
-        'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
-        'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
-        'Note that the quotation marks are necessary and that no white space '
-        'is allowed.')
-    args = parser.parse_args()
-
-    if args.options and args.cfg_options:
-        raise ValueError(
-            '--options and --cfg-options cannot be both '
-            'specified, --options is deprecated in favor of --cfg-options. '
-            '--options will not be supported in version v0.22.0.')
-    if args.options:
-        warnings.warn('--options is deprecated in favor of --cfg-options, '
-                      '--options will not be supported in version v0.22.0.')
-        args.cfg_options = args.options
-
-    return args
-
-
-def main():
-    args = parse_args()
-
-    cfg = Config.fromfile(args.config)
-    if args.cfg_options is not None:
-        cfg.merge_from_dict(args.cfg_options)
-    print(f'Config:\n{cfg.pretty_text}')
-    # dump config
-    cfg.dump('example.py')
-    # dump models graph
-    if args.graph:
-        model = init_model(args.config, device='cpu')
-        print(f'Model graph:\n{str(model)}')
-        with open('example-graph.txt', 'w') as f:
-            f.writelines(str(model))
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/misc/publish_model.py b/mmsegmentation/tools/misc/publish_model.py
deleted file mode 100644
index e035ad9..0000000
--- a/mmsegmentation/tools/misc/publish_model.py
+++ /dev/null
@@ -1,50 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import subprocess
-from hashlib import sha256
-
-import torch
-
-BLOCK_SIZE = 128 * 1024
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Process a checkpoint to be published')
-    parser.add_argument('in_file', help='input checkpoint filename')
-    parser.add_argument('out_file', help='output checkpoint filename')
-    args = parser.parse_args()
-    return args
-
-
-def sha256sum(filename: str) -> str:
-    """Compute SHA256 message digest from a file."""
-    hash_func = sha256()
-    byte_array = bytearray(BLOCK_SIZE)
-    memory_view = memoryview(byte_array)
-    with open(filename, 'rb', buffering=0) as file:
-        for block in iter(lambda: file.readinto(memory_view), 0):
-            hash_func.update(memory_view[:block])
-    return hash_func.hexdigest()
-
-
-def process_checkpoint(in_file, out_file):
-    checkpoint = torch.load(in_file, map_location='cpu')
-    # remove optimizer for smaller file size
-    if 'optimizer' in checkpoint:
-        del checkpoint['optimizer']
-    # if it is necessary to remove some sensitive data in checkpoint['meta'],
-    # add the code here.
-    torch.save(checkpoint, out_file)
-    sha = sha256sum(in_file)
-    final_file = out_file.rstrip('.pth') + f'-{sha[:8]}.pth'
-    subprocess.Popen(['mv', out_file, final_file])
-
-
-def main():
-    args = parse_args()
-    process_checkpoint(args.in_file, args.out_file)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/model_converters/beit2mmseg.py b/mmsegmentation/tools/model_converters/beit2mmseg.py
deleted file mode 100644
index 20f8f0f..0000000
--- a/mmsegmentation/tools/model_converters/beit2mmseg.py
+++ /dev/null
@@ -1,56 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os.path as osp
-from collections import OrderedDict
-
-import mmengine
-import torch
-from mmengine.runner import CheckpointLoader
-
-
-def convert_beit(ckpt):
-    new_ckpt = OrderedDict()
-
-    for k, v in ckpt.items():
-        if k.startswith('patch_embed'):
-            new_key = k.replace('patch_embed.proj', 'patch_embed.projection')
-            new_ckpt[new_key] = v
-        if k.startswith('blocks'):
-            new_key = k.replace('blocks', 'layers')
-            if 'norm' in new_key:
-                new_key = new_key.replace('norm', 'ln')
-            elif 'mlp.fc1' in new_key:
-                new_key = new_key.replace('mlp.fc1', 'ffn.layers.0.0')
-            elif 'mlp.fc2' in new_key:
-                new_key = new_key.replace('mlp.fc2', 'ffn.layers.1')
-            new_ckpt[new_key] = v
-        else:
-            new_key = k
-            new_ckpt[new_key] = v
-
-    return new_ckpt
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description='Convert keys in official pretrained beit models to'
-        'MMSegmentation style.')
-    parser.add_argument('src', help='src model path or url')
-    # The dst path must be a full path of the new checkpoint.
-    parser.add_argument('dst', help='save path')
-    args = parser.parse_args()
-
-    checkpoint = CheckpointLoader.load_checkpoint(args.src, map_location='cpu')
-    if 'state_dict' in checkpoint:
-        state_dict = checkpoint['state_dict']
-    elif 'model' in checkpoint:
-        state_dict = checkpoint['model']
-    else:
-        state_dict = checkpoint
-    weight = convert_beit(state_dict)
-    mmengine.mkdir_or_exist(osp.dirname(args.dst))
-    torch.save(weight, args.dst)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/model_converters/clip2mmseg.py b/mmsegmentation/tools/model_converters/clip2mmseg.py
deleted file mode 100644
index 9a97e4b..0000000
--- a/mmsegmentation/tools/model_converters/clip2mmseg.py
+++ /dev/null
@@ -1,163 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os.path as osp
-from collections import OrderedDict
-
-import mmengine
-import torch
-from mmengine.runner import CheckpointLoader
-
-
-def convert_vitlayer(paras):
-    new_para_name = ''
-    if paras[0] == 'ln_1':
-        new_para_name = '.'.join(['ln1'] + paras[1:])
-    elif paras[0] == 'attn':
-        new_para_name = '.'.join(['attn.attn'] + paras[1:])
-    elif paras[0] == 'ln_2':
-        new_para_name = '.'.join(['ln2'] + paras[1:])
-    elif paras[0] == 'mlp':
-        if paras[1] == 'c_fc':
-            new_para_name = '.'.join(['ffn.layers.0.0'] + paras[-1:])
-        else:
-            new_para_name = '.'.join(['ffn.layers.1'] + paras[-1:])
-    else:
-        print(f'Wrong for {paras}')
-    return new_para_name
-
-
-def convert_translayer(paras):
-    new_para_name = ''
-    if paras[0] == 'attn':
-        new_para_name = '.'.join(['attentions.0.attn'] + paras[1:])
-    elif paras[0] == 'ln_1':
-        new_para_name = '.'.join(['norms.0'] + paras[1:])
-    elif paras[0] == 'ln_2':
-        new_para_name = '.'.join(['norms.1'] + paras[1:])
-    elif paras[0] == 'mlp':
-        if paras[1] == 'c_fc':
-            new_para_name = '.'.join(['ffns.0.layers.0.0'] + paras[2:])
-        elif paras[1] == 'c_proj':
-            new_para_name = '.'.join(['ffns.0.layers.1'] + paras[2:])
-        else:
-            print(f'Wrong for {paras}')
-    else:
-        print(f'Wrong for {paras}')
-    return new_para_name
-
-
-def convert_key_name(ckpt, visual_split):
-    new_ckpt = OrderedDict()
-    for k, v in ckpt.items():
-        key_list = k.split('.')
-        if key_list[0] == 'visual':
-            new_transform_name = 'image_encoder'
-            if key_list[1] == 'class_embedding':
-                new_name = '.'.join([new_transform_name, 'cls_token'])
-            elif key_list[1] == 'positional_embedding':
-                new_name = '.'.join([new_transform_name, 'pos_embed'])
-            elif key_list[1] == 'conv1':
-                new_name = '.'.join([
-                    new_transform_name, 'patch_embed.projection', key_list[2]
-                ])
-            elif key_list[1] == 'ln_pre':
-                new_name = '.'.join(
-                    [new_transform_name, key_list[1], key_list[2]])
-            elif key_list[1] == 'transformer':
-                new_layer_name = 'layers'
-                layer_index = key_list[3]
-                paras = key_list[4:]
-                if int(layer_index) < visual_split:
-                    new_para_name = convert_vitlayer(paras)
-                    new_name = '.'.join([
-                        new_transform_name, new_layer_name, layer_index,
-                        new_para_name
-                    ])
-                else:
-                    new_para_name = convert_translayer(paras)
-                    new_transform_name = 'decode_head.rec_with_attnbias'
-                    new_layer_name = 'layers'
-                    layer_index = str(int(layer_index) - visual_split)
-                    new_name = '.'.join([
-                        new_transform_name, new_layer_name, layer_index,
-                        new_para_name
-                    ])
-            elif key_list[1] == 'proj':
-                new_name = 'decode_head.rec_with_attnbias.proj.weight'
-            elif key_list[1] == 'ln_post':
-                new_name = k.replace('visual', 'decode_head.rec_with_attnbias')
-            else:
-                print(f'pop parameter: {k}')
-                continue
-        else:
-            text_encoder_name = 'text_encoder'
-            if key_list[0] == 'transformer':
-                layer_name = 'transformer'
-                layer_index = key_list[2]
-                paras = key_list[3:]
-                new_para_name = convert_translayer(paras)
-                new_name = '.'.join([
-                    text_encoder_name, layer_name, layer_index, new_para_name
-                ])
-            elif key_list[0] in [
-                    'positional_embedding', 'text_projection', 'bg_embed',
-                    'attn_mask', 'logit_scale', 'token_embedding', 'ln_final'
-            ]:
-                new_name = 'text_encoder.' + k
-            else:
-                print(f'pop parameter: {k}')
-                continue
-        new_ckpt[new_name] = v
-
-    return new_ckpt
-
-
-def convert_tensor(ckpt):
-    cls_token = ckpt['image_encoder.cls_token']
-    new_cls_token = cls_token.unsqueeze(0).unsqueeze(0)
-    ckpt['image_encoder.cls_token'] = new_cls_token
-    pos_embed = ckpt['image_encoder.pos_embed']
-    new_pos_embed = pos_embed.unsqueeze(0)
-    ckpt['image_encoder.pos_embed'] = new_pos_embed
-    proj_weight = ckpt['decode_head.rec_with_attnbias.proj.weight']
-    new_proj_weight = proj_weight.transpose(1, 0)
-    ckpt['decode_head.rec_with_attnbias.proj.weight'] = new_proj_weight
-    return ckpt
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description='Convert keys in timm pretrained vit models to '
-        'MMSegmentation style.')
-    parser.add_argument('src', help='src model path or url')
-    # The dst path must be a full path of the new checkpoint.
-    parser.add_argument('dst', help='save path')
-    args = parser.parse_args()
-
-    if any([s in args.src for s in ['B-16', 'b16', 'base_patch16']]):
-        visual_split = 9
-    elif any([s in args.src for s in ['L-14', 'l14', 'large_patch14']]):
-        visual_split = 18
-    else:
-        print('Make sure the clip model is ViT-B/16 or ViT-L/14!')
-        visual_split = -1
-    checkpoint = CheckpointLoader.load_checkpoint(args.src, map_location='cpu')
-    if isinstance(checkpoint, torch.jit.RecursiveScriptModule):
-        state_dict = checkpoint.state_dict()
-    else:
-        if 'state_dict' in checkpoint:
-            # timm checkpoint
-            state_dict = checkpoint['state_dict']
-        elif 'model' in checkpoint:
-            # deit checkpoint
-            state_dict = checkpoint['model']
-        else:
-            state_dict = checkpoint
-    weight = convert_key_name(state_dict, visual_split)
-    weight = convert_tensor(weight)
-    mmengine.mkdir_or_exist(osp.dirname(args.dst))
-    torch.save(weight, args.dst)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/model_converters/mit2mmseg.py b/mmsegmentation/tools/model_converters/mit2mmseg.py
deleted file mode 100644
index f10cbbf..0000000
--- a/mmsegmentation/tools/model_converters/mit2mmseg.py
+++ /dev/null
@@ -1,82 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os.path as osp
-from collections import OrderedDict
-
-import mmengine
-import torch
-from mmengine.runner import CheckpointLoader
-
-
-def convert_mit(ckpt):
-    new_ckpt = OrderedDict()
-    # Process the concat between q linear weights and kv linear weights
-    for k, v in ckpt.items():
-        if k.startswith('head'):
-            continue
-        # patch embedding conversion
-        elif k.startswith('patch_embed'):
-            stage_i = int(k.split('.')[0].replace('patch_embed', ''))
-            new_k = k.replace(f'patch_embed{stage_i}', f'layers.{stage_i-1}.0')
-            new_v = v
-            if 'proj.' in new_k:
-                new_k = new_k.replace('proj.', 'projection.')
-        # transformer encoder layer conversion
-        elif k.startswith('block'):
-            stage_i = int(k.split('.')[0].replace('block', ''))
-            new_k = k.replace(f'block{stage_i}', f'layers.{stage_i-1}.1')
-            new_v = v
-            if 'attn.q.' in new_k:
-                sub_item_k = k.replace('q.', 'kv.')
-                new_k = new_k.replace('q.', 'attn.in_proj_')
-                new_v = torch.cat([v, ckpt[sub_item_k]], dim=0)
-            elif 'attn.kv.' in new_k:
-                continue
-            elif 'attn.proj.' in new_k:
-                new_k = new_k.replace('proj.', 'attn.out_proj.')
-            elif 'attn.sr.' in new_k:
-                new_k = new_k.replace('sr.', 'sr.')
-            elif 'mlp.' in new_k:
-                string = f'{new_k}-'
-                new_k = new_k.replace('mlp.', 'ffn.layers.')
-                if 'fc1.weight' in new_k or 'fc2.weight' in new_k:
-                    new_v = v.reshape((*v.shape, 1, 1))
-                new_k = new_k.replace('fc1.', '0.')
-                new_k = new_k.replace('dwconv.dwconv.', '1.')
-                new_k = new_k.replace('fc2.', '4.')
-                string += f'{new_k} {v.shape}-{new_v.shape}'
-        # norm layer conversion
-        elif k.startswith('norm'):
-            stage_i = int(k.split('.')[0].replace('norm', ''))
-            new_k = k.replace(f'norm{stage_i}', f'layers.{stage_i-1}.2')
-            new_v = v
-        else:
-            new_k = k
-            new_v = v
-        new_ckpt[new_k] = new_v
-    return new_ckpt
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description='Convert keys in official pretrained segformer to '
-        'MMSegmentation style.')
-    parser.add_argument('src', help='src model path or url')
-    # The dst path must be a full path of the new checkpoint.
-    parser.add_argument('dst', help='save path')
-    args = parser.parse_args()
-
-    checkpoint = CheckpointLoader.load_checkpoint(args.src, map_location='cpu')
-    if 'state_dict' in checkpoint:
-        state_dict = checkpoint['state_dict']
-    elif 'model' in checkpoint:
-        state_dict = checkpoint['model']
-    else:
-        state_dict = checkpoint
-    weight = convert_mit(state_dict)
-    mmengine.mkdir_or_exist(osp.dirname(args.dst))
-    torch.save(weight, args.dst)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/model_converters/san2mmseg.py b/mmsegmentation/tools/model_converters/san2mmseg.py
deleted file mode 100644
index 301a466..0000000
--- a/mmsegmentation/tools/model_converters/san2mmseg.py
+++ /dev/null
@@ -1,220 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os.path as osp
-from collections import OrderedDict
-
-import mmengine
-import torch
-from mmengine.runner import CheckpointLoader
-
-
-def convert_key_name(ckpt):
-    new_ckpt = OrderedDict()
-
-    for k, v in ckpt.items():
-        key_list = k.split('.')
-        if key_list[0] == 'clip_visual_extractor':
-            new_transform_name = 'image_encoder'
-            if key_list[1] == 'class_embedding':
-                new_name = '.'.join([new_transform_name, 'cls_token'])
-            elif key_list[1] == 'positional_embedding':
-                new_name = '.'.join([new_transform_name, 'pos_embed'])
-            elif key_list[1] == 'conv1':
-                new_name = '.'.join([
-                    new_transform_name, 'patch_embed.projection', key_list[2]
-                ])
-            elif key_list[1] == 'ln_pre':
-                new_name = '.'.join(
-                    [new_transform_name, key_list[1], key_list[2]])
-            elif key_list[1] == 'resblocks':
-                new_layer_name = 'layers'
-                layer_index = key_list[2]
-                paras = key_list[3:]
-                if paras[0] == 'ln_1':
-                    new_para_name = '.'.join(['ln1'] + key_list[4:])
-                elif paras[0] == 'attn':
-                    new_para_name = '.'.join(['attn.attn'] + key_list[4:])
-                elif paras[0] == 'ln_2':
-                    new_para_name = '.'.join(['ln2'] + key_list[4:])
-                elif paras[0] == 'mlp':
-                    if paras[1] == 'c_fc':
-                        new_para_name = '.'.join(['ffn.layers.0.0'] +
-                                                 key_list[-1:])
-                    else:
-                        new_para_name = '.'.join(['ffn.layers.1'] +
-                                                 key_list[-1:])
-                new_name = '.'.join([
-                    new_transform_name, new_layer_name, layer_index,
-                    new_para_name
-                ])
-        elif key_list[0] == 'side_adapter_network':
-            decode_head_name = 'decode_head'
-            module_name = 'side_adapter_network'
-            if key_list[1] == 'vit_model':
-                if key_list[2] == 'blocks':
-                    layer_name = 'encode_layers'
-                    layer_index = key_list[3]
-                    paras = key_list[4:]
-                    if paras[0] == 'norm1':
-                        new_para_name = '.'.join(['ln1'] + key_list[5:])
-                    elif paras[0] == 'attn':
-                        new_para_name = '.'.join(key_list[4:])
-                        new_para_name = new_para_name.replace(
-                            'attn.qkv.', 'attn.attn.in_proj_')
-                        new_para_name = new_para_name.replace(
-                            'attn.proj', 'attn.attn.out_proj')
-                    elif paras[0] == 'norm2':
-                        new_para_name = '.'.join(['ln2'] + key_list[5:])
-                    elif paras[0] == 'mlp':
-                        new_para_name = '.'.join(['ffn'] + key_list[5:])
-                        new_para_name = new_para_name.replace(
-                            'fc1', 'layers.0.0')
-                        new_para_name = new_para_name.replace(
-                            'fc2', 'layers.1')
-                    else:
-                        print(f'Wrong for {k}')
-                    new_name = '.'.join([
-                        decode_head_name, module_name, layer_name, layer_index,
-                        new_para_name
-                    ])
-                elif key_list[2] == 'pos_embed':
-                    new_name = '.'.join(
-                        [decode_head_name, module_name, 'pos_embed'])
-                elif key_list[2] == 'patch_embed':
-                    new_name = '.'.join([
-                        decode_head_name, module_name, 'patch_embed',
-                        'projection', key_list[4]
-                    ])
-                else:
-                    print(f'Wrong for {k}')
-            elif key_list[1] == 'query_embed' or key_list[
-                    1] == 'query_pos_embed':
-                new_name = '.'.join(
-                    [decode_head_name, module_name, key_list[1]])
-            elif key_list[1] == 'fusion_layers':
-                layer_name = 'conv_clips'
-                layer_index = key_list[2][-1]
-                paras = '.'.join(key_list[3:])
-                new_para_name = paras.replace('input_proj.0', '0')
-                new_para_name = new_para_name.replace('input_proj.1', '1.conv')
-                new_name = '.'.join([
-                    decode_head_name, module_name, layer_name, layer_index,
-                    new_para_name
-                ])
-            elif key_list[1] == 'mask_decoder':
-                new_name = 'decode_head.' + k
-            else:
-                print(f'Wrong for {k}')
-        elif key_list[0] == 'clip_rec_head':
-            module_name = 'rec_with_attnbias'
-            if key_list[1] == 'proj':
-                new_name = '.'.join(
-                    [decode_head_name, module_name, 'proj.weight'])
-            elif key_list[1] == 'ln_post':
-                new_name = '.'.join(
-                    [decode_head_name, module_name, 'ln_post', key_list[2]])
-            elif key_list[1] == 'resblocks':
-                new_layer_name = 'layers'
-                layer_index = key_list[2]
-                paras = key_list[3:]
-                if paras[0] == 'ln_1':
-                    new_para_name = '.'.join(['norms.0'] + paras[1:])
-                elif paras[0] == 'attn':
-                    new_para_name = '.'.join(['attentions.0.attn'] + paras[1:])
-                elif paras[0] == 'ln_2':
-                    new_para_name = '.'.join(['norms.1'] + paras[1:])
-                elif paras[0] == 'mlp':
-                    if paras[1] == 'c_fc':
-                        new_para_name = '.'.join(['ffns.0.layers.0.0'] +
-                                                 paras[2:])
-                    elif paras[1] == 'c_proj':
-                        new_para_name = '.'.join(['ffns.0.layers.1'] +
-                                                 paras[2:])
-                    else:
-                        print(f'Wrong for {k}')
-                new_name = '.'.join([
-                    decode_head_name, module_name, new_layer_name, layer_index,
-                    new_para_name
-                ])
-            else:
-                print(f'Wrong for {k}')
-        elif key_list[0] == 'ov_classifier':
-            text_encoder_name = 'text_encoder'
-            if key_list[1] == 'transformer':
-                layer_name = 'transformer'
-                layer_index = key_list[3]
-                paras = key_list[4:]
-                if paras[0] == 'attn':
-                    new_para_name = '.'.join(['attentions.0.attn'] + paras[1:])
-                elif paras[0] == 'ln_1':
-                    new_para_name = '.'.join(['norms.0'] + paras[1:])
-                elif paras[0] == 'ln_2':
-                    new_para_name = '.'.join(['norms.1'] + paras[1:])
-                elif paras[0] == 'mlp':
-                    if paras[1] == 'c_fc':
-                        new_para_name = '.'.join(['ffns.0.layers.0.0'] +
-                                                 paras[2:])
-                    elif paras[1] == 'c_proj':
-                        new_para_name = '.'.join(['ffns.0.layers.1'] +
-                                                 paras[2:])
-                    else:
-                        print(f'Wrong for {k}')
-                else:
-                    print(f'Wrong for {k}')
-                new_name = '.'.join([
-                    text_encoder_name, layer_name, layer_index, new_para_name
-                ])
-            elif key_list[1] in [
-                    'positional_embedding', 'text_projection', 'bg_embed',
-                    'attn_mask', 'logit_scale', 'token_embedding', 'ln_final'
-            ]:
-                new_name = k.replace('ov_classifier', 'text_encoder')
-            else:
-                print(f'Wrong for {k}')
-        elif key_list[0] == 'criterion':
-            new_name = k
-        else:
-            print(f'Wrong for {k}')
-        new_ckpt[new_name] = v
-    return new_ckpt
-
-
-def convert_tensor(ckpt):
-    cls_token = ckpt['image_encoder.cls_token']
-    new_cls_token = cls_token.unsqueeze(0).unsqueeze(0)
-    ckpt['image_encoder.cls_token'] = new_cls_token
-    pos_embed = ckpt['image_encoder.pos_embed']
-    new_pos_embed = pos_embed.unsqueeze(0)
-    ckpt['image_encoder.pos_embed'] = new_pos_embed
-    proj_weight = ckpt['decode_head.rec_with_attnbias.proj.weight']
-    new_proj_weight = proj_weight.transpose(1, 0)
-    ckpt['decode_head.rec_with_attnbias.proj.weight'] = new_proj_weight
-    return ckpt
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description='Convert keys in timm pretrained vit models to '
-        'MMSegmentation style.')
-    parser.add_argument('src', help='src model path or url')
-    # The dst path must be a full path of the new checkpoint.
-    parser.add_argument('dst', help='save path')
-    args = parser.parse_args()
-
-    checkpoint = CheckpointLoader.load_checkpoint(args.src, map_location='cpu')
-    if 'state_dict' in checkpoint:
-        # timm checkpoint
-        state_dict = checkpoint['state_dict']
-    elif 'model' in checkpoint:
-        # deit checkpoint
-        state_dict = checkpoint['model']
-    else:
-        state_dict = checkpoint
-    weight = convert_key_name(state_dict)
-    weight = convert_tensor(weight)
-    mmengine.mkdir_or_exist(osp.dirname(args.dst))
-    torch.save(weight, args.dst)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/model_converters/stdc2mmseg.py b/mmsegmentation/tools/model_converters/stdc2mmseg.py
deleted file mode 100644
index 6ea3b83..0000000
--- a/mmsegmentation/tools/model_converters/stdc2mmseg.py
+++ /dev/null
@@ -1,71 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os.path as osp
-
-import mmengine
-import torch
-from mmengine.runner import CheckpointLoader
-
-
-def convert_stdc(ckpt, stdc_type):
-    new_state_dict = {}
-    if stdc_type == 'STDC1':
-        stage_lst = ['0', '1', '2.0', '2.1', '3.0', '3.1', '4.0', '4.1']
-    else:
-        stage_lst = [
-            '0', '1', '2.0', '2.1', '2.2', '2.3', '3.0', '3.1', '3.2', '3.3',
-            '3.4', '4.0', '4.1', '4.2'
-        ]
-    for k, v in ckpt.items():
-        ori_k = k
-        flag = False
-        if 'cp.' in k:
-            k = k.replace('cp.', '')
-        if 'features.' in k:
-            num_layer = int(k.split('.')[1])
-            feature_key_lst = 'features.' + str(num_layer) + '.'
-            stages_key_lst = 'stages.' + stage_lst[num_layer] + '.'
-            k = k.replace(feature_key_lst, stages_key_lst)
-            flag = True
-        if 'conv_list' in k:
-            k = k.replace('conv_list', 'layers')
-            flag = True
-        if 'avd_layer.' in k:
-            if 'avd_layer.0' in k:
-                k = k.replace('avd_layer.0', 'downsample.conv')
-            elif 'avd_layer.1' in k:
-                k = k.replace('avd_layer.1', 'downsample.bn')
-            flag = True
-        if flag:
-            new_state_dict[k] = ckpt[ori_k]
-
-    return new_state_dict
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description='Convert keys in official pretrained STDC1/2 to '
-        'MMSegmentation style.')
-    parser.add_argument('src', help='src model path')
-    # The dst path must be a full path of the new checkpoint.
-    parser.add_argument('dst', help='save path')
-    parser.add_argument('type', help='model type: STDC1 or STDC2')
-    args = parser.parse_args()
-
-    checkpoint = CheckpointLoader.load_checkpoint(args.src, map_location='cpu')
-    if 'state_dict' in checkpoint:
-        state_dict = checkpoint['state_dict']
-    elif 'model' in checkpoint:
-        state_dict = checkpoint['model']
-    else:
-        state_dict = checkpoint
-
-    assert args.type in ['STDC1',
-                         'STDC2'], 'STD type should be STDC1 or STDC2!'
-    weight = convert_stdc(state_dict, args.type)
-    mmengine.mkdir_or_exist(osp.dirname(args.dst))
-    torch.save(weight, args.dst)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/model_converters/swin2mmseg.py b/mmsegmentation/tools/model_converters/swin2mmseg.py
deleted file mode 100644
index d434f94..0000000
--- a/mmsegmentation/tools/model_converters/swin2mmseg.py
+++ /dev/null
@@ -1,87 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os.path as osp
-from collections import OrderedDict
-
-import mmengine
-import torch
-from mmengine.runner import CheckpointLoader
-
-
-def convert_swin(ckpt):
-    new_ckpt = OrderedDict()
-
-    def correct_unfold_reduction_order(x):
-        out_channel, in_channel = x.shape
-        x = x.reshape(out_channel, 4, in_channel // 4)
-        x = x[:, [0, 2, 1, 3], :].transpose(1,
-                                            2).reshape(out_channel, in_channel)
-        return x
-
-    def correct_unfold_norm_order(x):
-        in_channel = x.shape[0]
-        x = x.reshape(4, in_channel // 4)
-        x = x[[0, 2, 1, 3], :].transpose(0, 1).reshape(in_channel)
-        return x
-
-    for k, v in ckpt.items():
-        if k.startswith('head'):
-            continue
-        elif k.startswith('layers'):
-            new_v = v
-            if 'attn.' in k:
-                new_k = k.replace('attn.', 'attn.w_msa.')
-            elif 'mlp.' in k:
-                if 'mlp.fc1.' in k:
-                    new_k = k.replace('mlp.fc1.', 'ffn.layers.0.0.')
-                elif 'mlp.fc2.' in k:
-                    new_k = k.replace('mlp.fc2.', 'ffn.layers.1.')
-                else:
-                    new_k = k.replace('mlp.', 'ffn.')
-            elif 'downsample' in k:
-                new_k = k
-                if 'reduction.' in k:
-                    new_v = correct_unfold_reduction_order(v)
-                elif 'norm.' in k:
-                    new_v = correct_unfold_norm_order(v)
-            else:
-                new_k = k
-            new_k = new_k.replace('layers', 'stages', 1)
-        elif k.startswith('patch_embed'):
-            new_v = v
-            if 'proj' in k:
-                new_k = k.replace('proj', 'projection')
-            else:
-                new_k = k
-        else:
-            new_v = v
-            new_k = k
-
-        new_ckpt[new_k] = new_v
-
-    return new_ckpt
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description='Convert keys in official pretrained swin models to'
-        'MMSegmentation style.')
-    parser.add_argument('src', help='src model path or url')
-    # The dst path must be a full path of the new checkpoint.
-    parser.add_argument('dst', help='save path')
-    args = parser.parse_args()
-
-    checkpoint = CheckpointLoader.load_checkpoint(args.src, map_location='cpu')
-    if 'state_dict' in checkpoint:
-        state_dict = checkpoint['state_dict']
-    elif 'model' in checkpoint:
-        state_dict = checkpoint['model']
-    else:
-        state_dict = checkpoint
-    weight = convert_swin(state_dict)
-    mmengine.mkdir_or_exist(osp.dirname(args.dst))
-    torch.save(weight, args.dst)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/model_converters/twins2mmseg.py b/mmsegmentation/tools/model_converters/twins2mmseg.py
deleted file mode 100644
index 647d417..0000000
--- a/mmsegmentation/tools/model_converters/twins2mmseg.py
+++ /dev/null
@@ -1,87 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os.path as osp
-from collections import OrderedDict
-
-import mmengine
-import torch
-from mmengine.runner import CheckpointLoader
-
-
-def convert_twins(args, ckpt):
-
-    new_ckpt = OrderedDict()
-
-    for k, v in list(ckpt.items()):
-        new_v = v
-        if k.startswith('head'):
-            continue
-        elif k.startswith('patch_embeds'):
-            if 'proj.' in k:
-                new_k = k.replace('proj.', 'projection.')
-            else:
-                new_k = k
-        elif k.startswith('blocks'):
-            # Union
-            if 'attn.q.' in k:
-                new_k = k.replace('q.', 'attn.in_proj_')
-                new_v = torch.cat([v, ckpt[k.replace('attn.q.', 'attn.kv.')]],
-                                  dim=0)
-            elif 'mlp.fc1' in k:
-                new_k = k.replace('mlp.fc1', 'ffn.layers.0.0')
-            elif 'mlp.fc2' in k:
-                new_k = k.replace('mlp.fc2', 'ffn.layers.1')
-            # Only pcpvt
-            elif args.model == 'pcpvt':
-                if 'attn.proj.' in k:
-                    new_k = k.replace('proj.', 'attn.out_proj.')
-                else:
-                    new_k = k
-
-            # Only svt
-            else:
-                if 'attn.proj.' in k:
-                    k_lst = k.split('.')
-                    if int(k_lst[2]) % 2 == 1:
-                        new_k = k.replace('proj.', 'attn.out_proj.')
-                    else:
-                        new_k = k
-                else:
-                    new_k = k
-            new_k = new_k.replace('blocks.', 'layers.')
-        elif k.startswith('pos_block'):
-            new_k = k.replace('pos_block', 'position_encodings')
-            if 'proj.0.' in new_k:
-                new_k = new_k.replace('proj.0.', 'proj.')
-        else:
-            new_k = k
-        if 'attn.kv.' not in k:
-            new_ckpt[new_k] = new_v
-    return new_ckpt
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description='Convert keys in timm pretrained vit models to '
-        'MMSegmentation style.')
-    parser.add_argument('src', help='src model path or url')
-    # The dst path must be a full path of the new checkpoint.
-    parser.add_argument('dst', help='save path')
-    parser.add_argument('model', help='model: pcpvt or svt')
-    args = parser.parse_args()
-
-    checkpoint = CheckpointLoader.load_checkpoint(args.src, map_location='cpu')
-
-    if 'state_dict' in checkpoint:
-        # timm checkpoint
-        state_dict = checkpoint['state_dict']
-    else:
-        state_dict = checkpoint
-
-    weight = convert_twins(args, state_dict)
-    mmengine.mkdir_or_exist(osp.dirname(args.dst))
-    torch.save(weight, args.dst)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/model_converters/vit2mmseg.py b/mmsegmentation/tools/model_converters/vit2mmseg.py
deleted file mode 100644
index 1d1f8a4..0000000
--- a/mmsegmentation/tools/model_converters/vit2mmseg.py
+++ /dev/null
@@ -1,70 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os.path as osp
-from collections import OrderedDict
-
-import mmengine
-import torch
-from mmengine.runner import CheckpointLoader
-
-
-def convert_vit(ckpt):
-
-    new_ckpt = OrderedDict()
-
-    for k, v in ckpt.items():
-        if k.startswith('head'):
-            continue
-        if k.startswith('norm'):
-            new_k = k.replace('norm.', 'ln1.')
-        elif k.startswith('patch_embed'):
-            if 'proj' in k:
-                new_k = k.replace('proj', 'projection')
-            else:
-                new_k = k
-        elif k.startswith('blocks'):
-            if 'norm' in k:
-                new_k = k.replace('norm', 'ln')
-            elif 'mlp.fc1' in k:
-                new_k = k.replace('mlp.fc1', 'ffn.layers.0.0')
-            elif 'mlp.fc2' in k:
-                new_k = k.replace('mlp.fc2', 'ffn.layers.1')
-            elif 'attn.qkv' in k:
-                new_k = k.replace('attn.qkv.', 'attn.attn.in_proj_')
-            elif 'attn.proj' in k:
-                new_k = k.replace('attn.proj', 'attn.attn.out_proj')
-            else:
-                new_k = k
-            new_k = new_k.replace('blocks.', 'layers.')
-        else:
-            new_k = k
-        new_ckpt[new_k] = v
-
-    return new_ckpt
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description='Convert keys in timm pretrained vit models to '
-        'MMSegmentation style.')
-    parser.add_argument('src', help='src model path or url')
-    # The dst path must be a full path of the new checkpoint.
-    parser.add_argument('dst', help='save path')
-    args = parser.parse_args()
-
-    checkpoint = CheckpointLoader.load_checkpoint(args.src, map_location='cpu')
-    if 'state_dict' in checkpoint:
-        # timm checkpoint
-        state_dict = checkpoint['state_dict']
-    elif 'model' in checkpoint:
-        # deit checkpoint
-        state_dict = checkpoint['model']
-    else:
-        state_dict = checkpoint
-    weight = convert_vit(state_dict)
-    mmengine.mkdir_or_exist(osp.dirname(args.dst))
-    torch.save(weight, args.dst)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/model_converters/vitjax2mmseg.py b/mmsegmentation/tools/model_converters/vitjax2mmseg.py
deleted file mode 100644
index 81bc2ea..0000000
--- a/mmsegmentation/tools/model_converters/vitjax2mmseg.py
+++ /dev/null
@@ -1,123 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import os.path as osp
-
-import mmengine
-import numpy as np
-import torch
-
-
-def vit_jax_to_torch(jax_weights, num_layer=12):
-    torch_weights = dict()
-
-    # patch embedding
-    conv_filters = jax_weights['embedding/kernel']
-    conv_filters = conv_filters.permute(3, 2, 0, 1)
-    torch_weights['patch_embed.projection.weight'] = conv_filters
-    torch_weights['patch_embed.projection.bias'] = jax_weights[
-        'embedding/bias']
-
-    # pos embedding
-    torch_weights['pos_embed'] = jax_weights[
-        'Transformer/posembed_input/pos_embedding']
-
-    # cls token
-    torch_weights['cls_token'] = jax_weights['cls']
-
-    # head
-    torch_weights['ln1.weight'] = jax_weights['Transformer/encoder_norm/scale']
-    torch_weights['ln1.bias'] = jax_weights['Transformer/encoder_norm/bias']
-
-    # transformer blocks
-    for i in range(num_layer):
-        jax_block = f'Transformer/encoderblock_{i}'
-        torch_block = f'layers.{i}'
-
-        # attention norm
-        torch_weights[f'{torch_block}.ln1.weight'] = jax_weights[
-            f'{jax_block}/LayerNorm_0/scale']
-        torch_weights[f'{torch_block}.ln1.bias'] = jax_weights[
-            f'{jax_block}/LayerNorm_0/bias']
-
-        # attention
-        query_weight = jax_weights[
-            f'{jax_block}/MultiHeadDotProductAttention_1/query/kernel']
-        query_bias = jax_weights[
-            f'{jax_block}/MultiHeadDotProductAttention_1/query/bias']
-        key_weight = jax_weights[
-            f'{jax_block}/MultiHeadDotProductAttention_1/key/kernel']
-        key_bias = jax_weights[
-            f'{jax_block}/MultiHeadDotProductAttention_1/key/bias']
-        value_weight = jax_weights[
-            f'{jax_block}/MultiHeadDotProductAttention_1/value/kernel']
-        value_bias = jax_weights[
-            f'{jax_block}/MultiHeadDotProductAttention_1/value/bias']
-
-        qkv_weight = torch.from_numpy(
-            np.stack((query_weight, key_weight, value_weight), 1))
-        qkv_weight = torch.flatten(qkv_weight, start_dim=1)
-        qkv_bias = torch.from_numpy(
-            np.stack((query_bias, key_bias, value_bias), 0))
-        qkv_bias = torch.flatten(qkv_bias, start_dim=0)
-
-        torch_weights[f'{torch_block}.attn.attn.in_proj_weight'] = qkv_weight
-        torch_weights[f'{torch_block}.attn.attn.in_proj_bias'] = qkv_bias
-        to_out_weight = jax_weights[
-            f'{jax_block}/MultiHeadDotProductAttention_1/out/kernel']
-        to_out_weight = torch.flatten(to_out_weight, start_dim=0, end_dim=1)
-        torch_weights[
-            f'{torch_block}.attn.attn.out_proj.weight'] = to_out_weight
-        torch_weights[f'{torch_block}.attn.attn.out_proj.bias'] = jax_weights[
-            f'{jax_block}/MultiHeadDotProductAttention_1/out/bias']
-
-        # mlp norm
-        torch_weights[f'{torch_block}.ln2.weight'] = jax_weights[
-            f'{jax_block}/LayerNorm_2/scale']
-        torch_weights[f'{torch_block}.ln2.bias'] = jax_weights[
-            f'{jax_block}/LayerNorm_2/bias']
-
-        # mlp
-        torch_weights[f'{torch_block}.ffn.layers.0.0.weight'] = jax_weights[
-            f'{jax_block}/MlpBlock_3/Dense_0/kernel']
-        torch_weights[f'{torch_block}.ffn.layers.0.0.bias'] = jax_weights[
-            f'{jax_block}/MlpBlock_3/Dense_0/bias']
-        torch_weights[f'{torch_block}.ffn.layers.1.weight'] = jax_weights[
-            f'{jax_block}/MlpBlock_3/Dense_1/kernel']
-        torch_weights[f'{torch_block}.ffn.layers.1.bias'] = jax_weights[
-            f'{jax_block}/MlpBlock_3/Dense_1/bias']
-
-    # transpose weights
-    for k, v in torch_weights.items():
-        if 'weight' in k and 'patch_embed' not in k and 'ln' not in k:
-            v = v.permute(1, 0)
-        torch_weights[k] = v
-
-    return torch_weights
-
-
-def main():
-    # stole refactoring code from Robin Strudel, thanks
-    parser = argparse.ArgumentParser(
-        description='Convert keys from jax official pretrained vit models to '
-        'MMSegmentation style.')
-    parser.add_argument('src', help='src model path or url')
-    # The dst path must be a full path of the new checkpoint.
-    parser.add_argument('dst', help='save path')
-    args = parser.parse_args()
-
-    jax_weights = np.load(args.src)
-    jax_weights_tensor = {}
-    for key in jax_weights.files:
-        value = torch.from_numpy(jax_weights[key])
-        jax_weights_tensor[key] = value
-    if 'L_16-i21k' in args.src:
-        num_layer = 24
-    else:
-        num_layer = 12
-    torch_weights = vit_jax_to_torch(jax_weights_tensor, num_layer)
-    mmengine.mkdir_or_exist(osp.dirname(args.dst))
-    torch.save(torch_weights, args.dst)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mmsegmentation/tools/slurm_test.sh b/mmsegmentation/tools/slurm_test.sh
deleted file mode 100755
index 4e6f7bf..0000000
--- a/mmsegmentation/tools/slurm_test.sh
+++ /dev/null
@@ -1,24 +0,0 @@
-#!/usr/bin/env bash
-
-set -x
-
-PARTITION=$1
-JOB_NAME=$2
-CONFIG=$3
-CHECKPOINT=$4
-GPUS=${GPUS:-4}
-GPUS_PER_NODE=${GPUS_PER_NODE:-4}
-CPUS_PER_TASK=${CPUS_PER_TASK:-5}
-PY_ARGS=${@:5}
-SRUN_ARGS=${SRUN_ARGS:-""}
-
-PYTHONPATH="$(dirname $0)/..":$PYTHONPATH \
-srun -p ${PARTITION} \
-    --job-name=${JOB_NAME} \
-    --gres=gpu:${GPUS_PER_NODE} \
-    --ntasks=${GPUS} \
-    --ntasks-per-node=${GPUS_PER_NODE} \
-    --cpus-per-task=${CPUS_PER_TASK} \
-    --kill-on-bad-exit=1 \
-    ${SRUN_ARGS} \
-    python -u tools/test.py ${CONFIG} ${CHECKPOINT} --launcher="slurm" ${PY_ARGS}
diff --git a/mmsegmentation/tools/slurm_train.sh b/mmsegmentation/tools/slurm_train.sh
deleted file mode 100755
index ab23210..0000000
--- a/mmsegmentation/tools/slurm_train.sh
+++ /dev/null
@@ -1,23 +0,0 @@
-#!/usr/bin/env bash
-
-set -x
-
-PARTITION=$1
-JOB_NAME=$2
-CONFIG=$3
-GPUS=${GPUS:-4}
-GPUS_PER_NODE=${GPUS_PER_NODE:-4}
-CPUS_PER_TASK=${CPUS_PER_TASK:-5}
-SRUN_ARGS=${SRUN_ARGS:-""}
-PY_ARGS=${@:4}
-
-PYTHONPATH="$(dirname $0)/..":$PYTHONPATH \
-srun -p ${PARTITION} \
-    --job-name=${JOB_NAME} \
-    --gres=gpu:${GPUS_PER_NODE} \
-    --ntasks=${GPUS} \
-    --ntasks-per-node=${GPUS_PER_NODE} \
-    --cpus-per-task=${CPUS_PER_TASK} \
-    --kill-on-bad-exit=1 \
-    ${SRUN_ARGS} \
-    python -u tools/train.py ${CONFIG} --launcher="slurm" ${PY_ARGS}
diff --git a/mmsegmentation/tools/torchserve/mmseg2torchserve.py b/mmsegmentation/tools/torchserve/mmseg2torchserve.py
deleted file mode 100644
index 23f9963..0000000
--- a/mmsegmentation/tools/torchserve/mmseg2torchserve.py
+++ /dev/null
@@ -1,112 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from argparse import ArgumentParser, Namespace
-from pathlib import Path
-from tempfile import TemporaryDirectory
-
-from mmengine import Config
-from mmengine.utils import mkdir_or_exist
-
-try:
-    from model_archiver.model_packaging import package_model
-    from model_archiver.model_packaging_utils import ModelExportUtils
-except ImportError:
-    package_model = None
-
-
-def mmseg2torchserve(
-    config_file: str,
-    checkpoint_file: str,
-    output_folder: str,
-    model_name: str,
-    model_version: str = '1.0',
-    force: bool = False,
-):
-    """Converts mmsegmentation model (config + checkpoint) to TorchServe
-    `.mar`.
-
-    Args:
-        config_file:
-            In MMSegmentation config format.
-            The contents vary for each task repository.
-        checkpoint_file:
-            In MMSegmentation checkpoint format.
-            The contents vary for each task repository.
-        output_folder:
-            Folder where `{model_name}.mar` will be created.
-            The file created will be in TorchServe archive format.
-        model_name:
-            If not None, used for naming the `{model_name}.mar` file
-            that will be created under `output_folder`.
-            If None, `{Path(checkpoint_file).stem}` will be used.
-        model_version:
-            Model's version.
-        force:
-            If True, if there is an existing `{model_name}.mar`
-            file under `output_folder` it will be overwritten.
-    """
-    mkdir_or_exist(output_folder)
-
-    config = Config.fromfile(config_file)
-
-    with TemporaryDirectory() as tmpdir:
-        config.dump(f'{tmpdir}/config.py')
-
-        args = Namespace(
-            **{
-                'model_file': f'{tmpdir}/config.py',
-                'serialized_file': checkpoint_file,
-                'handler': f'{Path(__file__).parent}/mmseg_handler.py',
-                'model_name': model_name or Path(checkpoint_file).stem,
-                'version': model_version,
-                'export_path': output_folder,
-                'force': force,
-                'requirements_file': None,
-                'extra_files': None,
-                'runtime': 'python',
-                'archive_format': 'default'
-            })
-        manifest = ModelExportUtils.generate_manifest_json(args)
-        package_model(args, manifest)
-
-
-def parse_args():
-    parser = ArgumentParser(
-        description='Convert mmseg models to TorchServe `.mar` format.')
-    parser.add_argument('config', type=str, help='config file path')
-    parser.add_argument('checkpoint', type=str, help='checkpoint file path')
-    parser.add_argument(
-        '--output-folder',
-        type=str,
-        required=True,
-        help='Folder where `{model_name}.mar` will be created.')
-    parser.add_argument(
-        '--model-name',
-        type=str,
-        default=None,
-        help='If not None, used for naming the `{model_name}.mar`'
-        'file that will be created under `output_folder`.'
-        'If None, `{Path(checkpoint_file).stem}` will be used.')
-    parser.add_argument(
-        '--model-version',
-        type=str,
-        default='1.0',
-        help='Number used for versioning.')
-    parser.add_argument(
-        '-f',
-        '--force',
-        action='store_true',
-        help='overwrite the existing `{model_name}.mar`')
-    args = parser.parse_args()
-
-    return args
-
-
-if __name__ == '__main__':
-    args = parse_args()
-
-    if package_model is None:
-        raise ImportError('`torch-model-archiver` is required.'
-                          'Try: pip install torch-model-archiver')
-
-    mmseg2torchserve(args.config, args.checkpoint, args.output_folder,
-                     args.model_name, args.model_version, args.force)
diff --git a/mmsegmentation/tools/torchserve/mmseg_handler.py b/mmsegmentation/tools/torchserve/mmseg_handler.py
deleted file mode 100644
index dbe5ded..0000000
--- a/mmsegmentation/tools/torchserve/mmseg_handler.py
+++ /dev/null
@@ -1,56 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import base64
-import os
-
-import cv2
-import mmcv
-import torch
-from mmengine.model.utils import revert_sync_batchnorm
-from ts.torch_handler.base_handler import BaseHandler
-
-from mmseg.apis import inference_model, init_model
-
-
-class MMsegHandler(BaseHandler):
-
-    def initialize(self, context):
-        properties = context.system_properties
-        self.map_location = 'cuda' if torch.cuda.is_available() else 'cpu'
-        self.device = torch.device(self.map_location + ':' +
-                                   str(properties.get('gpu_id')) if torch.cuda.
-                                   is_available() else self.map_location)
-        self.manifest = context.manifest
-
-        model_dir = properties.get('model_dir')
-        serialized_file = self.manifest['model']['serializedFile']
-        checkpoint = os.path.join(model_dir, serialized_file)
-        self.config_file = os.path.join(model_dir, 'config.py')
-
-        self.model = init_model(self.config_file, checkpoint, self.device)
-        self.model = revert_sync_batchnorm(self.model)
-        self.initialized = True
-
-    def preprocess(self, data):
-        images = []
-
-        for row in data:
-            image = row.get('data') or row.get('body')
-            if isinstance(image, str):
-                image = base64.b64decode(image)
-            image = mmcv.imfrombytes(image)
-            images.append(image)
-
-        return images
-
-    def inference(self, data, *args, **kwargs):
-        results = [inference_model(self.model, img) for img in data]
-        return results
-
-    def postprocess(self, data):
-        output = []
-
-        for image_result in data:
-            _, buffer = cv2.imencode('.png', image_result[0].astype('uint8'))
-            content = buffer.tobytes()
-            output.append(content)
-        return output
diff --git a/mmsegmentation/tools/torchserve/test_torchserve.py b/mmsegmentation/tools/torchserve/test_torchserve.py
deleted file mode 100644
index b015b66..0000000
--- a/mmsegmentation/tools/torchserve/test_torchserve.py
+++ /dev/null
@@ -1,58 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from argparse import ArgumentParser
-from io import BytesIO
-
-import matplotlib.pyplot as plt
-import mmcv
-import requests
-
-from mmseg.apis import inference_model, init_model
-
-
-def parse_args():
-    parser = ArgumentParser(
-        description='Compare result of torchserve and pytorch,'
-        'and visualize them.')
-    parser.add_argument('img', help='Image file')
-    parser.add_argument('config', help='Config file')
-    parser.add_argument('checkpoint', help='Checkpoint file')
-    parser.add_argument('model_name', help='The model name in the server')
-    parser.add_argument(
-        '--inference-addr',
-        default='127.0.0.1:8080',
-        help='Address and port of the inference server')
-    parser.add_argument(
-        '--result-image',
-        type=str,
-        default=None,
-        help='save server output in result-image')
-    parser.add_argument(
-        '--device', default='cuda:0', help='Device used for inference')
-
-    args = parser.parse_args()
-    return args
-
-
-def main(args):
-    url = 'http://' + args.inference_addr + '/predictions/' + args.model_name
-    with open(args.img, 'rb') as image:
-        tmp_res = requests.post(url, image)
-    content = tmp_res.content
-    if args.result_image:
-        with open(args.result_image, 'wb') as out_image:
-            out_image.write(content)
-        plt.imshow(mmcv.imread(args.result_image, 'grayscale'))
-        plt.show()
-    else:
-        plt.imshow(plt.imread(BytesIO(content)))
-        plt.show()
-    model = init_model(args.config, args.checkpoint, args.device)
-    image = mmcv.imread(args.img)
-    result = inference_model(model, image)
-    plt.imshow(result[0])
-    plt.show()
-
-
-if __name__ == '__main__':
-    args = parse_args()
-    main(args)

From 6bd9641e8b13890e73878c89010def6359f27bfd Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Fri, 29 Nov 2024 10:35:31 +0900
Subject: [PATCH 091/106] [Fix]:rename unvalid file name

---
 mmsegmentation/{custom_trian.py => custom_train.py} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename mmsegmentation/{custom_trian.py => custom_train.py} (100%)

diff --git a/mmsegmentation/custom_trian.py b/mmsegmentation/custom_train.py
similarity index 100%
rename from mmsegmentation/custom_trian.py
rename to mmsegmentation/custom_train.py

From adc4dd6551edd97d2e458f0bbbc750dbce6dd8d0 Mon Sep 17 00:00:00 2001
From: yoon0717 <hsy0320@hufs.ac.kr>
Date: Fri, 29 Nov 2024 10:42:38 +0900
Subject: [PATCH 092/106] [#21] Refactor : final code

---
 module_base/config.yaml     | 8 ++++----
 module_base/dataset.py      | 2 +-
 module_base/inference.py    | 6 +++---
 module_base/loss.py         | 2 +-
 module_base/model.py        | 9 ---------
 module_base/optimizer.py    | 6 +++++-
 module_base/scheduler.py    | 2 +-
 module_base/train.py        | 2 +-
 module_base/transform.py    | 4 ----
 module_base/wandb_logger.py | 1 +
 module_base/wandb_train.py  | 2 +-
 11 files changed, 18 insertions(+), 26 deletions(-)

diff --git a/module_base/config.yaml b/module_base/config.yaml
index 54d4407..116bfe7 100644
--- a/module_base/config.yaml
+++ b/module_base/config.yaml
@@ -1,7 +1,7 @@
 # 데이터 및 모델 저장 경로
-image_root: /data/ephemeral/home/data/train/DCM
-label_root: /data/ephemeral/home/data/train/outputs_json
-save_dir: /data/ephemeral/home/data/result
+image_root: 본인 이미지 경로 추가
+label_root: 본인 레이블 경로 추가
+save_dir: 모델 저장 경로 추가
 
 # 모델 라이브러리 및 사용 모델 정의
 model_type: smp
@@ -45,5 +45,5 @@ random_seed: 2024
 size: 1024
 
 # wandb
-wandb_run_name: smp_unet++_hrnet_DiceBCELoss_cosine_flip+rotate+mixup+brightnesscontrast+clahe
+wandb_run_name: smp
 wandb_run_id: None
\ No newline at end of file
diff --git a/module_base/dataset.py b/module_base/dataset.py
index 890613f..87171d3 100644
--- a/module_base/dataset.py
+++ b/module_base/dataset.py
@@ -47,7 +47,7 @@ def __init__(self, fnames, labels, image_root, label_root, kfold=0, transforms=N
         filenames = []
         labelnames = []
         for i, (x, y) in enumerate(gkf.split(fnames, ys, groups)):
-            if self.is_train: # k번 빼고 학습
+            if self.is_train:
                 if i == self.kfold:
                     continue
                 filenames += list(fnames[y])
diff --git a/module_base/inference.py b/module_base/inference.py
index 9cb7523..3f0e978 100644
--- a/module_base/inference.py
+++ b/module_base/inference.py
@@ -14,9 +14,9 @@
 def parse_args():
     parser = ArgumentParser()
     
-    parser.add_argument('--image_root', type=str, default='/data/ephemeral/home/data/test/DCM',
+    parser.add_argument('--image_root', type=str, default='본인 이미지 경로 추가',
                         help='Path to the root directory containing images')
-    parser.add_argument('--save_dir', type=str, default="/data/ephemeral/home/data/result",
+    parser.add_argument('--save_dir', type=str, default="csv 저장 경로 추가",
                         help='Path to the root directory containing save direction')
     parser.add_argument('--random_seed', type=int, default=2024)
     parser.add_argument('--model_type', type=str, default='smp')
@@ -127,7 +127,7 @@ def do_inference(image_root, save_dir, random_seed, model_type):
         "rle": rles,
     })
     
-    df.to_csv("best_hrnet_prepro(BrightnessContrast&CLAHE).csv", index=False)
+    df.to_csv("output.csv", index=False)
 
 def main(args):
     do_inference(**args.__dict__)
diff --git a/module_base/loss.py b/module_base/loss.py
index b9b4716..1ff8757 100644
--- a/module_base/loss.py
+++ b/module_base/loss.py
@@ -34,7 +34,7 @@ def __init__(self, alpha=0.4, gamma=1):
 
     def forward(self, preds, targets):
         # CE() -> -log(pt), FL() -> -a*((1-pt)^r) * log(pt)
-        BCE = F.binary_cross_entropy_with_logits(preds, targets) # CE
+        BCE = F.binary_cross_entropy_with_logits(preds, targets) # 1회성 BCE
         BCE_EXP = torch.exp(-BCE)
         loss = self.alpha * (1-BCE_EXP)**self.gamma * BCE
 
diff --git a/module_base/model.py b/module_base/model.py
index e409ce0..75369d7 100644
--- a/module_base/model.py
+++ b/module_base/model.py
@@ -3,9 +3,6 @@
 import segmentation_models_pytorch as smp
 
 class TorchvisionModel(nn.Module):
-    '''
-    Torchvision에서 제공하는 사전 훈련된 모델을 사용하는 클래스
-    '''
     def __init__(self, model_name, num_classes, pretrained=True):
         super(TorchvisionModel, self).__init__()
         self.model = models.segmentation.__dict__[model_name](pretrained=pretrained)
@@ -15,9 +12,6 @@ def forward(self, x):
         return self.model(x)
 
 class SMP(nn.Module):
-    '''
-    SMP에서 제공하는 사전 훈련된 모델을 사용하는 클래스
-    '''
     def __init__(self, model_name, encoder_name, encoder_weights, num_classes):
         super(SMP, self).__init__()
         self.model = smp.__dict__[model_name](
@@ -31,9 +25,6 @@ def forward(self, x):
         return self.model(x)
 
 class ModelSelector:
-    '''
-    사용할 모델 유형을 선택하는 클래스
-    '''
     def __init__(self, model_type, num_classes, **kwargs):
         
         # 모델 유형에 따라 적절한 모델 객체를 생성
diff --git a/module_base/optimizer.py b/module_base/optimizer.py
index e91ceb9..f68fc2e 100644
--- a/module_base/optimizer.py
+++ b/module_base/optimizer.py
@@ -1,17 +1,21 @@
 import torch.optim as optim
 from lion_pytorch import Lion
+from adamp import AdamP
 
 class OptimizerSelector:
-    def __init__(self, opt, model, lr, weight_decay):
+    def __init__(self, opt, model, lr, weight_decay, betas):
         self.model = model
         self.lr = lr
         self.weight_decay = weight_decay
+        self.betas = betas
         if opt == 'Adam': 
             self.optimizer = optim.Adam(params=self.model.parameters(), lr=self.lr, weight_decay=self.weight_decay)
         elif opt == 'AdamW': 
             self.optimizer = optim.AdamW(params=self.model.parameters(), lr=self.lr, weight_decay=self.weight_decay)
         elif opt == 'Lion': 
             self.optimizer = Lion(params=self.model.parameters(), lr=self.lr, weight_decay=self.weight_decay)
+        elif opt == 'AdamP':
+            optimizer = AdamP(params=self.model.parameters(), lr=self.lr, betas = self.betas, weight_decay=self.weight_decay)
             
     def get_optim(self):
         return self.optimizer
\ No newline at end of file
diff --git a/module_base/scheduler.py b/module_base/scheduler.py
index f8c0e11..1e05ddf 100644
--- a/module_base/scheduler.py
+++ b/module_base/scheduler.py
@@ -8,7 +8,7 @@ def __init__(self, sched, optimizer, epoch):
             self.scheduler = lr_scheduler.StepLR(self.optimizer, step=5, gamma=0.6)
         elif sched == 'cosine': # learing rate가 cos함수를 따라서 감소 및 증가
             self.scheduler = lr_scheduler.CosineAnnealingLR(self.optimizer, T_max=self.epoch, eta_min=1e-6)
-        elif sched == 'exp': # learing rate decay가 exponential함수를 따름
+        elif sched == 'exp': # learing rate decay가 exponential함수를 따라 감소
             self.scheduler = lr_scheduler.ExponentialLR(optimizer, gamma=0.6)
         elif sched == 'plateau': # 성능이 향상이 없을 때 learning rate를 감소
             self.scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, 'min')
diff --git a/module_base/train.py b/module_base/train.py
index bb9eff9..362e782 100644
--- a/module_base/train.py
+++ b/module_base/train.py
@@ -147,7 +147,7 @@ def train(model, train_loader, val_loader, criterion, optimizer, scheduler, cfg)
                     f'Loss: {round(loss.item(),4)}'
                 )
         scheduler.step()
-        # validation 주기에 따라 loss를 출력하고 best model을 저장합니다.
+        # validation 주기에 따라 loss를 출력하고 best model을 저장
         if (epoch + 1) % cfg.val_every == 0:
             dice = validation(epoch + 1, model, val_loader, criterion, cfg.model_type)
             
diff --git a/module_base/transform.py b/module_base/transform.py
index c1e3c85..09339a1 100644
--- a/module_base/transform.py
+++ b/module_base/transform.py
@@ -25,16 +25,12 @@ class TransformSelector:
     이미지 변환 라이브러리를 선택하기 위한 클래스.
     """
     def __init__(self, transform_type):
-
-        # 지원하는 변환 라이브러리인지 확인
         if transform_type in ["albumentation"]:
             self.transform_type = transform_type
         else:
             raise ValueError("Unknown transformation library specified.")
         
     def get_transform(self, is_train, resize):
-        
-        # 선택된 라이브러리에 따라 적절한 변환 객체를 생성
         if self.transform_type == 'albumentation':
             transform = AlbumentationTransform(is_train, resize)
         
diff --git a/module_base/wandb_logger.py b/module_base/wandb_logger.py
index 603ce06..ea26a64 100644
--- a/module_base/wandb_logger.py
+++ b/module_base/wandb_logger.py
@@ -1,5 +1,6 @@
 import wandb
 
+# 원하는 log 추가
 class WandbLogger:
     def __init__(self, project_name="Hand Bone Image Segmentation", name=None):
         """
diff --git a/module_base/wandb_train.py b/module_base/wandb_train.py
index 3dfea10..7858303 100644
--- a/module_base/wandb_train.py
+++ b/module_base/wandb_train.py
@@ -142,7 +142,6 @@ def train(model, train_loader, val_loader, criterion, optimizer, scheduler, cfg)
                 elif cfg.model_type == 'smp':
                     outputs = model(images)
                 loss = criterion(outputs, masks)
-                # 아래 부터는 gradient accumulation
                 # loss = loss / cfg.step
             # 스케일된 loss를 사용해 backward 및 optimizer step
             epoch_loss += loss.item()
@@ -150,6 +149,7 @@ def train(model, train_loader, val_loader, criterion, optimizer, scheduler, cfg)
             scaler.scale(loss).backward()
             scaler.step(optimizer)
             scaler.update()
+            # gradient accumulation 사용 시 변경
             '''
             scaler.scale(loss).backward()
             epoch_loss += loss.item() * cfg.step

From 5618f511df54b9d383f45873abe886632e50f61b Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Fri, 29 Nov 2024 10:49:12 +0900
Subject: [PATCH 093/106] [Feature]:add hard voting ensemble code

---
 utils/ensemble_test.py | 152 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 152 insertions(+)
 create mode 100644 utils/ensemble_test.py

diff --git a/utils/ensemble_test.py b/utils/ensemble_test.py
new file mode 100644
index 0000000..008a00a
--- /dev/null
+++ b/utils/ensemble_test.py
@@ -0,0 +1,152 @@
+import os
+import numpy as np
+import pandas as pd
+import copy
+from tqdm import tqdm
+import argparse
+
+
+# 비교할 파일들의 경로 리스트
+file_paths = [
+    '/data/ephemeral/home/ensemble/0.9729_vgg.csv',
+    '/data/ephemeral/home/ensemble/hrnet_0.9734.csv',
+    '/data/ephemeral/home/ensemble/hrnet_2048_alltrain.csv',
+    '/data/ephemeral/home/ensemble/mmseg_segformer_0.9690.csv',
+    '/data/ephemeral/home/ensemble/sam2unet_0.9749.csv',
+    ]
+
+CLASSES = [
+    'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
+    'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
+    'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
+    'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
+    'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
+    'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
+]
+
+def parse_argument():
+    parser = argparse.ArgumentParser(description="19조가~ 좋아하는~ 앙상블")
+    parser.add_argument('save_root', type=str, help='output.csv를 저장할 위치')
+    parser.add_argument('image_root', type=str, help='image가 위치한 DCM폴더 경로')
+    parser.add_argument('--threshold', type=int, help='동의를 요구하는 모델 갯수', default=2)
+    args = parser.parse_args()
+    return args
+    
+
+def encode_mask_to_rle(mask):
+    pixels = mask.flatten()
+    pixels = np.concatenate([[0], pixels, [0]])
+    runs = np.where(pixels[1:] != pixels[:-1])[0] + 1
+    runs[1::2] -= runs[::2]
+    return ' '.join(str(x) for x in runs)
+
+def decode_rle_to_mask(rle, height, width):
+    s = rle.split()
+    starts, lengths = [np.asarray(x, dtype=int) for x in (s[0:][::2], s[1:][::2])]
+    starts -= 1
+    ends = starts + lengths
+    img = np.zeros(height * width, dtype=np.uint8)
+
+    for lo, hi in zip(starts, ends):
+        img[lo:hi] = 1
+
+
+    return img.reshape(height, width)
+
+
+def main(SAVE_ROOT, IMAGE_ROOT, threshold):
+    # threshold를 초과한 개수의 픽셀을 앙상블
+    print(f'{threshold} 초과를 앙상블합니다.')
+
+    # 파일들을 담을 빈 리스트
+    dfs = []
+
+    # 각 파일을 순회하면서 DataFrame 생성 및 리스트에 추가
+    pbar = tqdm(desc="loading data...")
+    for i, file_path in enumerate(file_paths):
+        pbar.set_postfix({"iteration": i, "status": "in progress"})
+        pbar.update(1)
+        if os.path.exists(file_path):  # 파일이 존재하는지 확인
+            df = pd.read_csv(file_path)
+            dfs.append(df)
+        else:
+            print(f"{file_path} 파일이 존재하지 않습니다.")
+    pbar.set_postfix({"status": "done"})
+    pbar.close()
+
+    pngs = {
+        os.path.relpath(os.path.join(root, fname), start=IMAGE_ROOT)
+        for root, _dirs, files in os.walk(IMAGE_ROOT)
+        for fname in files
+        if os.path.splitext(fname)[1].lower() == ".png"
+    }
+    
+    remove_list = []
+    for k in pngs:
+        if k.startswith('all_pngs'):
+            remove_list.append(k)
+    
+    for k in remove_list:
+        pngs.remove(k)
+
+    ensemble = {}
+    class_dict = {}
+
+    height = 2048
+    width = 2048
+
+    for bone in CLASSES:
+        class_dict[bone] = np.zeros(height * width, dtype=np.uint8).reshape(height, width)
+
+    for png in pngs:
+        ensemble[png[6:]] = copy.deepcopy(class_dict)
+
+    pbar = tqdm(desc="loading rle info...")
+    for fold, df in enumerate(dfs):
+        # 모든 행 순회
+        pbar.set_postfix({"iteration": fold, "status": "in progress"})
+        pbar.update(1)
+        for index, row in df.iterrows():
+            # 각 행에 대해 작업 수행
+            if not pd.isna(row['rle']):
+                mask_img = decode_rle_to_mask(row['rle'], height, width)
+                ensemble[row['image_name']][row['class']] += mask_img
+            else:
+                print(f'{fold}fold의 {index}번에 문제 발생!')
+                print(row)
+    pbar.set_postfix({"status": "done"})
+    pbar.close()
+
+    pbar = tqdm(desc="앙상블을 진행중입니다!")
+    for i, png in enumerate(pngs):
+        pbar.set_postfix({"iteration": i, "status": "in progress"})
+        pbar.update(1)
+        for bone in CLASSES:
+            binary_arr = np.where(ensemble[png[6:]][bone] > threshold, 1, 0)
+            ensemble[png[6:]][bone] = encode_mask_to_rle(binary_arr)
+    pbar.set_postfix({"status": "done"})
+    pbar.close()
+    # encode 과정이 오래걸립니다. (test set 기준 약 10분)
+
+    image_name = []
+    classes = []
+    rles = []
+
+    for png in pngs:
+        for bone in CLASSES:
+            image_name.append(png[6:])
+            classes.append(bone)
+            rles.append(ensemble[png[6:]][bone])
+
+    df = pd.DataFrame({
+        "image_name": image_name,
+        "class": classes,
+        "rle": rles,
+    })
+
+    df.to_csv(os.path.join(SAVE_ROOT, "output.csv"), index=False)
+
+
+if __name__=="__main__":
+    args = parse_argument()
+    main(args.save_root, args.image_root, args.threshold)
\ No newline at end of file

From b39d65a4c31a8fc8150882e683f6ea1a17882d61 Mon Sep 17 00:00:00 2001
From: parkjunil <june21r@gmail.com>
Date: Fri, 29 Nov 2024 10:54:57 +0900
Subject: [PATCH 094/106] [Feature]:add code for morphology post process

---
 utils/post_process_morphology.py | 82 ++++++++++++++++++++++++++++++++
 1 file changed, 82 insertions(+)
 create mode 100644 utils/post_process_morphology.py

diff --git a/utils/post_process_morphology.py b/utils/post_process_morphology.py
new file mode 100644
index 0000000..a36d05e
--- /dev/null
+++ b/utils/post_process_morphology.py
@@ -0,0 +1,82 @@
+import numpy as np
+import os
+import cv2
+import pandas as pd
+from tqdm import tqdm
+
+########################## settings ########################### 
+CSV_PATH = "/data/ephemeral/home/post_process/sam2_double_vote3.csv"
+TARGET_PATH = "/data/ephemeral/home/post_process/new_output.csv"
+CLASSES = [
+    'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
+    'finger-6', 'finger-7', 'finger-8', 'finger-9', 'finger-10',
+    'finger-11', 'finger-12', 'finger-13', 'finger-14', 'finger-15',
+    'finger-16', 'finger-17', 'finger-18', 'finger-19', 'Trapezium',
+    'Trapezoid', 'Capitate', 'Hamate', 'Scaphoid', 'Lunate',
+    'Triquetrum', 'Pisiform', 'Radius', 'Ulna',
+]
+TARGETS = ['finger-8', 'finger-3', 'finger-4', 'finger-16']
+########################################################################################################
+
+
+num_classes = len(CLASSES)
+CLASS2IND = {v: i for i, v in enumerate(CLASSES)}
+IND2CLASS = {v: k for k, v in CLASS2IND.items()}
+
+
+def rle2mask(rle, shape):
+    if pd.isna(rle):
+        return np.zeros(shape, dtype=np.uint8)
+    try:
+        s = np.array(rle.split(), dtype=int)
+        starts, lengths = s[0::2] - 1, s[1::2]
+        ends = starts + lengths
+        img = np.zeros(shape[0]*shape[1], dtype=np.uint8)
+        for lo, hi in zip(starts, ends):
+            img[lo:hi] = 1
+        return img.reshape(shape)
+    except AttributeError:
+        # RLE가 예상치 못한 형식일 경우 빈 마스크 반환
+        return np.zeros(shape, dtype=np.uint8)
+
+def encode_mask_to_rle(mask):
+    '''
+    mask: numpy array binary mask 
+    1 - mask 
+    0 - background
+    Returns encoded run length 
+    '''
+    pixels = mask.flatten()
+    pixels = np.concatenate([[0], pixels, [0]])
+    runs = np.where(pixels[1:] != pixels[:-1])[0] + 1
+    runs[1::2] -= runs[::2]
+    return ' '.join(str(x) for x in runs)
+
+def main():
+    df = pd.read_csv(CSV_PATH)
+    for idx, row in tqdm(df.iterrows()):
+        cls_name = row['class']
+        
+        if cls_name not in TARGETS:
+            continue
+        
+        mask = rle2mask(row['rle'], (2048, 2048))
+        # 구조화 요소 커널, 사각형 (5x5) 생성 ---①
+        
+        if cls_name == 'Ulna':
+            kernel_size = (30, 30)
+        else:
+            kernel_size = (10, 10)
+        k = cv2.getStructuringElement(cv2.MORPH_RECT, kernel_size)
+        # 열림 연산 적용 ---②
+        mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, k)
+        # # 닫힘 연산 적용 ---③
+        mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, k)
+        
+        new_rle = encode_mask_to_rle(mask)
+        df.loc[idx, 'rle'] = new_rle
+    
+    df.to_csv(TARGET_PATH)
+    
+if __name__ == "__main__":
+    main()
\ No newline at end of file

From c8ceb1fcd9f9ec84fb93b986789ad14a59d42cb9 Mon Sep 17 00:00:00 2001
From: sejongmin <jmoh7480@gmail.com>
Date: Fri, 29 Nov 2024 14:59:55 +0900
Subject: [PATCH 095/106] [Refactor] : edit default config

---
 sam2_unet/config.yaml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/sam2_unet/config.yaml b/sam2_unet/config.yaml
index d6559de..be9ab89 100644
--- a/sam2_unet/config.yaml
+++ b/sam2_unet/config.yaml
@@ -4,8 +4,8 @@ test_data_path: /data/ephemeral/home/data/test
 hiera_path: /data/ephemeral/home/sam2_hiera_large.pt
 
 # train
-train_batch_size: 2
-train_num_workers: 2
+train_batch_size: 4
+train_num_workers: 4
 
 # valid
 valid_batch_size: 2
@@ -25,7 +25,7 @@ random_seed: 2024
 lr: 1e-3
 max_epoch: 40
 smooth_factor: 0.1
-scaler: False
+scaler: True
 
 # optimizer
 optimizer: adamw
@@ -58,7 +58,7 @@ save_every: 5
 image_size: 1024
 
 # wandb
-wandb_name: sam2unet_1024_best
+wandb_name: sam2unet_1024
 wandb_id: 
 
 # resume

From 9fb82d0dd83ec856437263d59968e91ca176d6fc Mon Sep 17 00:00:00 2001
From: Soy17 <thdudlee0617@naver.com>
Date: Mon, 2 Dec 2024 12:04:34 +0900
Subject: [PATCH 096/106] [#11] Feature : unet + Read me UPDATE

---
 README.md                                     |   45 +-
 RECcode/._baseline_code.ipynb                 |  Bin 643 -> 0 bytes
 RECcode/._eda.ipynb                           |  Bin 578 -> 0 bytes
 RECcode/baseline_code.ipynb                   | 1252 ----------------
 RECcode/cv/configs/base_train copy.yaml       |   59 -
 RECcode/eda.ipynb                             | 1280 -----------------
 .../cv/configs/base_train.yaml                |    0
 {RECcode => UNet++}/cv/dataset.py             |    0
 {RECcode => UNet++}/cv/inference.py           |    0
 {RECcode => UNet++}/cv/loss/base_loss.py      |    0
 {RECcode => UNet++}/cv/loss/loss_selector.py  |    0
 {RECcode => UNet++}/cv/models/base_model.py   |    0
 .../cv/models/model_selector.py               |    0
 .../cv/scheduler/scheduler_selector.py        |    0
 {RECcode => UNet++}/cv/train.py               |    0
 {RECcode => UNet++}/cv/trainer.py             |    0
 {RECcode => UNet++}/cv/unet.sh                |    0
 {RECcode => UNet++}/cv/utils/wandb.py         |    0
 {RECcode => UNet++}/requirements.txt          |    0
 ...-images-with-pneumothorax-masks-512x512.py |   20 -
 ...-images-with-pneumothorax-masks-512x512.py |   19 -
 ...-images-with-pneumothorax-masks-512x512.py |   19 -
 ...-images-with-pneumothorax-masks-512x512.py |   19 -
 23 files changed, 10 insertions(+), 2703 deletions(-)
 delete mode 100644 RECcode/._baseline_code.ipynb
 delete mode 100644 RECcode/._eda.ipynb
 delete mode 100644 RECcode/baseline_code.ipynb
 delete mode 100644 RECcode/cv/configs/base_train copy.yaml
 delete mode 100644 RECcode/eda.ipynb
 rename {RECcode => UNet++}/cv/configs/base_train.yaml (100%)
 rename {RECcode => UNet++}/cv/dataset.py (100%)
 rename {RECcode => UNet++}/cv/inference.py (100%)
 rename {RECcode => UNet++}/cv/loss/base_loss.py (100%)
 rename {RECcode => UNet++}/cv/loss/loss_selector.py (100%)
 rename {RECcode => UNet++}/cv/models/base_model.py (100%)
 rename {RECcode => UNet++}/cv/models/model_selector.py (100%)
 rename {RECcode => UNet++}/cv/scheduler/scheduler_selector.py (100%)
 rename {RECcode => UNet++}/cv/train.py (100%)
 rename {RECcode => UNet++}/cv/trainer.py (100%)
 rename {RECcode => UNet++}/cv/unet.sh (100%)
 rename {RECcode => UNet++}/cv/utils/wandb.py (100%)
 rename {RECcode => UNet++}/requirements.txt (100%)
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
 delete mode 100644 mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py

diff --git a/README.md b/README.md
index 1571da5..88a2214 100644
--- a/README.md
+++ b/README.md
@@ -72,49 +72,24 @@ hand bone x-ray 객체가 담긴 이미지가 모델의 인풋으로 사용됩
     </tr>
 </table>
 
+<br/>
 <br/>
 
+# 🏆 Project Result
 
-
-## 🔗 Reference
-
-### [📎 Segmentation Notion](https://www.notion.so/Hand-Bone-Image-Segmentation-13bcb8c4237680f0baeef241f0f6856b)
+**_<p align=center>Public Leader Board</p>_**
+<img src="https://github.com/user-attachments/assets/94bd97fc-518d-4c69-b45e-69466d8e3bb1" alt="Public Leader Board" >
 
 <br>
 
-## Commit Convention
-
-1. `Feature` : **새로운 기능 추가**
-2. `Fix` : **버그 수정**
-3. `Docs` : **문서 수정**
-4. `Style` : **코드 포맷팅 → Code Convention**
-5. `Refactor` : **코드 리팩토링**
-6. `Test` : **테스트 코드**
-7. `Comment` : **주석 추가 및 수정**
-
-커밋할 때 헤더에 위 내용을 작성하고 전반적인 내용을 간단하게 작성합니다.
-
-### 예시
-
-- `git commit -m "[#issue] Feature : message content"`
+**_<p align=center>Private Leader Board</p>_**
+<img src="https://github.com/user-attachments/assets/85c200c3-30db-48d1-a2a7-3f5d15eed143" alt="Private Leader Board" >
 
-커밋할 때 상세 내용을 작성해야 한다면 아래와 같이 진행합니다.
-
-### 예시
-
-> `git commit`  
-> 어떠한 에디터로 진입하게 된 후 아래와 같이 작성합니다.  
-> `[header]: 전반적인 내용`  
-> . **(한 줄 비워야 함)**  
-> 상세 내용
-
-<br/>
+<br>
 
-## Branch Naming Convention
+## 🔗 Reference
 
-브랜치를 새롭게 만들 때, 브랜치 이름은 항상 위 `Commit Convention`의 Header와 함께 작성되어야 합니다.
+### [📎 Segmentation Notion](https://typhoon-jackal-68b.notion.site/Hand-Bone-Image-Segmentation-13bcb8c4237680f0baeef241f0f6856b?pvs=4)
 
-### 예시
+<br>
 
-- `Feature/~~~`
-- `Refactor/~~~`
diff --git a/RECcode/._baseline_code.ipynb b/RECcode/._baseline_code.ipynb
deleted file mode 100644
index 145423b9e1121768ed3b32cff894d6956e359d79..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 643
zcmb_ZJxjwt7=9D+3kO{k-HLEHD9v3>lS_+~Hm#^2;s@#$F1ZUWUXz%dsI!x^gQFlF
zo%~Jy3Ma2sP{cvO2k!lR9`5CRVSHf{On_Y$mG%xxr=<@JYcQ=}1;E_bUgzeG_P;>$
z=;+{`Hd4F*7!TiMV>;J$*aDc1(tep`nH1$di{yxCtZ7XH0Db8R#W+)}cDCEzR-%8>
z6}i~V(|(~9=9xB&0P~;x^9z=<MD-E@6R>)RZ(mn-;`^s%)fgNnqfh>9!c6uGh4G_d
z26Kb1Qd!NiWEwHqO$$|{8dltsqOjWOWg=6?3(G$aP^XDn6tytw_^4$gN>QhUsE??w
zw2{};u@$mHNIh&2rCgMI*>w^&f~z8rH!8^Wg-0k^x2rmIY+fbnq)I%S+g|Ka%DESF
z97Z&*2shFc;u06zRhQskj{iKSWTB;UA^vAln1UI2e&45QeC&02;x90k&Mk~7sXLA%
O9GB6$-__R>b$A0GWQLmn

diff --git a/RECcode/._eda.ipynb b/RECcode/._eda.ipynb
deleted file mode 100644
index aef2d5d4f9d0f1d76f48b473c0003d0619e8b518..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 578
zcmbVJ%T6Le6upfxqi%G=WR`5~g%Kzkx|@P@3~G!-!57+$nMew%kPdWL(^UIh`yIwl
za5eK6?p(R_6I>fFKBAe`WKL3b>)w0LN!2Zw{QeCR05#T0ZSAF+sdtQPFpbLqNX%ix
zJh6=NA5dvDcHd~PibnwL=r7p>=2(YyfZ2}pGb{`TBIC2p;FYK?Vt59a|I!nRai&<Q
zUt6sz;k!K%iM2@jBcvu4aQgv}{NxW~7O_Bifxy<npR45M{)YGa`q%yKeDVoP|ABTm
z@J5P|8?7~W*HbDSm9kkLc_$(hk3`gwff9kr97}nOkHM>CxjYR9lJO;vJGp-CeEa9A
zU0APgy1U)LxM&XDtvcP4Et}S@oef=_g)&mkhe&6!>Wz&ZLr3qf7x|9T;~2dNZBv#n
zm}y2hPZtb}rfD8e)S%p?w3s)#L}$vWY#;6i4Y$#6@tyF1gokF;3n~W}ZnIr2<?NhI
qiEUbiV$qzMc^inPy$@#m|6lPi%o0+}l`YFM^Tg_wS9&;nQHB=_dwggB

diff --git a/RECcode/baseline_code.ipynb b/RECcode/baseline_code.ipynb
deleted file mode 100644
index 2af9fc7..0000000
--- a/RECcode/baseline_code.ipynb
+++ /dev/null
@@ -1,1252 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "5af8a2c0-45fe-4d13-bebd-0dca87a7b71f",
-   "metadata": {},
-   "source": [
-    "# Library import"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "a4c611c8-2226-433c-bf5f-343cc0b094af",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 필요 library들을 import합니다.\n",
-    "import os\n",
-    "from typing import Tuple, Any, Callable, List, Optional, Union\n",
-    "\n",
-    "import cv2\n",
-    "import timm\n",
-    "import torch\n",
-    "import numpy as np\n",
-    "import pandas as pd\n",
-    "import albumentations as A\n",
-    "import torch.nn as nn\n",
-    "import torch.nn.functional as F\n",
-    "import torch.optim as optim\n",
-    "from torchvision import models, datasets, transforms\n",
-    "from tqdm.auto import tqdm\n",
-    "from torch.utils.data import DataLoader, Dataset\n",
-    "from sklearn.model_selection import train_test_split\n",
-    "from albumentations.pytorch import ToTensorV2"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a2d69e6a-a719-4a97-92ca-6354c873313f",
-   "metadata": {},
-   "source": [
-    "# Dataset Class"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "56f97229-e29f-479d-abab-0db8219d1803",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class CustomDataset(Dataset):\n",
-    "    def __init__(\n",
-    "        self, \n",
-    "        root_dir: str, \n",
-    "        info_df: pd.DataFrame, \n",
-    "        transform: Callable,\n",
-    "        is_inference: bool = False\n",
-    "    ):\n",
-    "        # 데이터셋의 기본 경로, 이미지 변환 방법, 이미지 경로 및 레이블을 초기화합니다.\n",
-    "        self.root_dir = root_dir  # 이미지 파일들이 저장된 기본 디렉토리\n",
-    "        self.transform = transform  # 이미지에 적용될 변환 처리\n",
-    "        self.is_inference = is_inference # 추론인지 확인\n",
-    "        self.image_paths = info_df['image_path'].tolist()  # 이미지 파일 경로 목록\n",
-    "        \n",
-    "        if not self.is_inference:\n",
-    "            self.targets = info_df['target'].tolist()  # 각 이미지에 대한 레이블 목록\n",
-    "\n",
-    "    def __len__(self) -> int:\n",
-    "        # 데이터셋의 총 이미지 수를 반환합니다.\n",
-    "        return len(self.image_paths)\n",
-    "\n",
-    "    def __getitem__(self, index: int) -> Union[Tuple[torch.Tensor, int], torch.Tensor]:\n",
-    "        # 주어진 인덱스에 해당하는 이미지를 로드하고 변환을 적용한 후, 이미지와 레이블을 반환합니다.\n",
-    "        img_path = os.path.join(self.root_dir, self.image_paths[index])  # 이미지 경로 조합\n",
-    "        image = cv2.imread(img_path, cv2.IMREAD_COLOR)  # 이미지를 BGR 컬러 포맷의 numpy array로 읽어옵니다.\n",
-    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)  # BGR 포맷을 RGB 포맷으로 변환합니다.\n",
-    "        image = self.transform(image)  # 설정된 이미지 변환을 적용합니다.\n",
-    "\n",
-    "        if self.is_inference:\n",
-    "            return image\n",
-    "        else:\n",
-    "            target = self.targets[index]  # 해당 이미지의 레이블\n",
-    "            return image, target  # 변환된 이미지와 레이블을 튜플 형태로 반환합니다. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "6c07d2d0-9585-45ce-8ece-4f69b98f6dd4",
-   "metadata": {},
-   "source": [
-    "# Transform Class"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "9b1855c1-cf13-476d-aabd-d78e9e082ddf",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class TorchvisionTransform:\n",
-    "    def __init__(self, is_train: bool = True):\n",
-    "        # 공통 변환 설정: 이미지 리사이즈, 텐서 변환, 정규화\n",
-    "        common_transforms = [\n",
-    "            transforms.Resize((224, 224)),  # 이미지를 224x224 크기로 리사이즈\n",
-    "            transforms.ToTensor(),  # 이미지를 PyTorch 텐서로 변환\n",
-    "            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # 정규화\n",
-    "        ]\n",
-    "        \n",
-    "        if is_train:\n",
-    "            # 훈련용 변환: 랜덤 수평 뒤집기, 랜덤 회전, 색상 조정 추가\n",
-    "            self.transform = transforms.Compose(\n",
-    "                [\n",
-    "                    transforms.RandomHorizontalFlip(p=0.5),  # 50% 확률로 이미지를 수평 뒤집기\n",
-    "                    transforms.RandomRotation(15),  # 최대 15도 회전\n",
-    "                    transforms.ColorJitter(brightness=0.2, contrast=0.2),  # 밝기 및 대비 조정\n",
-    "                ] + common_transforms\n",
-    "            )\n",
-    "        else:\n",
-    "            # 검증/테스트용 변환: 공통 변환만 적용\n",
-    "            self.transform = transforms.Compose(common_transforms)\n",
-    "\n",
-    "    def __call__(self, image: np.ndarray) -> torch.Tensor:\n",
-    "        image = Image.fromarray(image)  # numpy 배열을 PIL 이미지로 변환\n",
-    "        \n",
-    "        transformed = self.transform(image)  # 설정된 변환을 적용\n",
-    "        \n",
-    "        return transformed  # 변환된 이미지 반환"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "0a683988-0f73-4e43-907b-0d5209550abb",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class AlbumentationsTransform:\n",
-    "    def __init__(self, is_train: bool = True):\n",
-    "        # 공통 변환 설정: 이미지 리사이즈, 정규화, 텐서 변환\n",
-    "        common_transforms = [\n",
-    "            A.Resize(224, 224),  # 이미지를 224x224 크기로 리사이즈\n",
-    "            A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),  # 정규화\n",
-    "            ToTensorV2()  # albumentations에서 제공하는 PyTorch 텐서 변환\n",
-    "        ]\n",
-    "        \n",
-    "        if is_train:\n",
-    "            # 훈련용 변환: 랜덤 수평 뒤집기, 랜덤 회전, 랜덤 밝기 및 대비 조정 추가\n",
-    "            self.transform = A.Compose(\n",
-    "                [\n",
-    "                    A.HorizontalFlip(p=0.5),  # 50% 확률로 이미지를 수평 뒤집기\n",
-    "                    A.Rotate(limit=15),  # 최대 15도 회전\n",
-    "                    A.RandomBrightnessContrast(p=0.2),  # 밝기 및 대비 무작위 조정\n",
-    "                ] + common_transforms\n",
-    "            )\n",
-    "        else:\n",
-    "            # 검증/테스트용 변환: 공통 변환만 적용\n",
-    "            self.transform = A.Compose(common_transforms)\n",
-    "\n",
-    "    def __call__(self, image) -> torch.Tensor:\n",
-    "        # 이미지가 NumPy 배열인지 확인\n",
-    "        if not isinstance(image, np.ndarray):\n",
-    "            raise TypeError(\"Image should be a NumPy array (OpenCV format).\")\n",
-    "        \n",
-    "        # 이미지에 변환 적용 및 결과 반환\n",
-    "        transformed = self.transform(image=image)  # 이미지에 설정된 변환을 적용\n",
-    "        \n",
-    "        return transformed['image']  # 변환된 이미지의 텐서를 반환"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "e82f3416-86f2-430f-9260-d23904e757e4",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class TransformSelector:\n",
-    "    \"\"\"\n",
-    "    이미지 변환 라이브러리를 선택하기 위한 클래스.\n",
-    "    \"\"\"\n",
-    "    def __init__(self, transform_type: str):\n",
-    "\n",
-    "        # 지원하는 변환 라이브러리인지 확인\n",
-    "        if transform_type in [\"torchvision\", \"albumentations\"]:\n",
-    "            self.transform_type = transform_type\n",
-    "        \n",
-    "        else:\n",
-    "            raise ValueError(\"Unknown transformation library specified.\")\n",
-    "\n",
-    "    def get_transform(self, is_train: bool):\n",
-    "        \n",
-    "        # 선택된 라이브러리에 따라 적절한 변환 객체를 생성\n",
-    "        if self.transform_type == 'torchvision':\n",
-    "            transform = TorchvisionTransform(is_train=is_train)\n",
-    "        \n",
-    "        elif self.transform_type == 'albumentations':\n",
-    "            transform = AlbumentationsTransform(is_train=is_train)\n",
-    "        \n",
-    "        return transform"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c938bcb2-9257-49cb-8d05-dd4a7bb25665",
-   "metadata": {},
-   "source": [
-    "# Model Class"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "f16fb24a-8d34-4ed6-8a33-2d153d12d190",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class SimpleCNN(nn.Module):\n",
-    "    \"\"\"\n",
-    "    간단한 CNN 아키텍처를 정의하는 클래스.\n",
-    "    \"\"\"\n",
-    "    def __init__(self, num_classes: int):\n",
-    "        super(SimpleCNN, self).__init__()\n",
-    "        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)\n",
-    "        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)\n",
-    "        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)\n",
-    "        self.pool = nn.MaxPool2d(2, 2)\n",
-    "        self.fc1 = nn.Linear(128 * 4 * 4, 512)\n",
-    "        self.fc2 = nn.Linear(512, num_classes)\n",
-    "        self.relu = nn.ReLU()\n",
-    "\n",
-    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
-    "        \n",
-    "        # 순전파 함수 정의\n",
-    "        x = self.pool(self.relu(self.conv1(x)))\n",
-    "        x = self.pool(self.relu(self.conv2(x)))\n",
-    "        x = self.pool(self.relu(self.conv3(x)))\n",
-    "        x = torch.flatten(x, 1)\n",
-    "        x = self.relu(self.fc1(x))\n",
-    "        x = self.fc2(x)\n",
-    "        \n",
-    "        return x"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "f91493ca-c5c2-4950-916a-cc4304c7ad4a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class TorchvisionModel(nn.Module):\n",
-    "    \"\"\"\n",
-    "    Torchvision에서 제공하는 사전 훈련된 모델을 사용하는 클래스.\n",
-    "    \"\"\"\n",
-    "    def __init__(\n",
-    "        self, \n",
-    "        model_name: str, \n",
-    "        num_classes: int, \n",
-    "        pretrained: bool\n",
-    "    ):\n",
-    "        super(TorchvisionModel, self).__init__()\n",
-    "        self.model = models.__dict__[model_name](pretrained=pretrained)\n",
-    "        \n",
-    "        # 모델의 최종 분류기 부분을 사용자 정의 클래스 수에 맞게 조정\n",
-    "        if 'fc' in dir(self.model):\n",
-    "            num_ftrs = self.model.fc.in_features\n",
-    "            self.model.fc = nn.Linear(num_ftrs, num_classes)\n",
-    "        \n",
-    "        elif 'classifier' in dir(self.model):\n",
-    "            num_ftrs = self.model.classifier[-1].in_features\n",
-    "            self.model.classifier[-1] = nn.Linear(num_ftrs, num_classes)\n",
-    "\n",
-    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
-    "        \n",
-    "        return self.model(x)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "f28c8e4f-a914-4b12-982e-d4a58863c717",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class TimmModel(nn.Module):\n",
-    "    \"\"\"\n",
-    "    Timm 라이브러리를 사용하여 다양한 사전 훈련된 모델을 제공하는 클래스.\n",
-    "    \"\"\"\n",
-    "    def __init__(\n",
-    "        self, \n",
-    "        model_name: str, \n",
-    "        num_classes: int, \n",
-    "        pretrained: bool\n",
-    "    ):\n",
-    "        super(TimmModel, self).__init__()\n",
-    "        self.model = timm.create_model(\n",
-    "            model_name, \n",
-    "            pretrained=pretrained, \n",
-    "            num_classes=num_classes\n",
-    "        )\n",
-    "\n",
-    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
-    "        \n",
-    "        return self.model(x)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "3f2da081-9010-431d-a049-835d7bbea4a5",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class ModelSelector:\n",
-    "    \"\"\"\n",
-    "    사용할 모델 유형을 선택하는 클래스.\n",
-    "    \"\"\"\n",
-    "    def __init__(\n",
-    "        self, \n",
-    "        model_type: str, \n",
-    "        num_classes: int, \n",
-    "        **kwargs\n",
-    "    ):\n",
-    "        \n",
-    "        # 모델 유형에 따라 적절한 모델 객체를 생성\n",
-    "        if model_type == 'simple':\n",
-    "            self.model = SimpleCNN(num_classes=num_classes)\n",
-    "        \n",
-    "        elif model_type == 'torchvision':\n",
-    "            self.model = TorchvisionModel(num_classes=num_classes, **kwargs)\n",
-    "        \n",
-    "        elif model_type == 'timm':\n",
-    "            self.model = TimmModel(num_classes=num_classes, **kwargs)\n",
-    "        \n",
-    "        else:\n",
-    "            raise ValueError(\"Unknown model type specified.\")\n",
-    "\n",
-    "    def get_model(self) -> nn.Module:\n",
-    "\n",
-    "        # 생성된 모델 객체 반환\n",
-    "        return self.model"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c2977c7b-bc39-48f7-8155-ef6b6a03d6f8",
-   "metadata": {},
-   "source": [
-    "# Loss Class"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "97471eb3-a979-4fb3-b976-6c3177c79f76",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class Loss(nn.Module):\n",
-    "    \"\"\"\n",
-    "    모델의 손실함수를 계산하는 클래스.\n",
-    "    \"\"\"\n",
-    "    def __init__(self):\n",
-    "        super(Loss, self).__init__()\n",
-    "        self.loss_fn = nn.CrossEntropyLoss()\n",
-    "\n",
-    "    def forward(\n",
-    "        self, \n",
-    "        outputs: torch.Tensor, \n",
-    "        targets: torch.Tensor\n",
-    "    ) -> torch.Tensor:\n",
-    "    \n",
-    "        return self.loss_fn(outputs, targets)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5f3e3d21-5ab8-41b0-aa5c-e62ace8dc6a6",
-   "metadata": {},
-   "source": [
-    "# Trainer Class"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "6a90c673-6672-4066-a9ec-9975d7842be4",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class Trainer:\n",
-    "    def __init__(\n",
-    "        self, \n",
-    "        model: nn.Module, \n",
-    "        device: torch.device, \n",
-    "        train_loader: DataLoader, \n",
-    "        val_loader: DataLoader, \n",
-    "        optimizer: optim.Optimizer,\n",
-    "        scheduler: optim.lr_scheduler,\n",
-    "        loss_fn: torch.nn.modules.loss._Loss, \n",
-    "        epochs: int,\n",
-    "        result_path: str\n",
-    "    ):\n",
-    "        # 클래스 초기화: 모델, 디바이스, 데이터 로더 등 설정\n",
-    "        self.model = model  # 훈련할 모델\n",
-    "        self.device = device  # 연산을 수행할 디바이스 (CPU or GPU)\n",
-    "        self.train_loader = train_loader  # 훈련 데이터 로더\n",
-    "        self.val_loader = val_loader  # 검증 데이터 로더\n",
-    "        self.optimizer = optimizer  # 최적화 알고리즘\n",
-    "        self.scheduler = scheduler # 학습률 스케줄러\n",
-    "        self.loss_fn = loss_fn  # 손실 함수\n",
-    "        self.epochs = epochs  # 총 훈련 에폭 수\n",
-    "        self.result_path = result_path  # 모델 저장 경로\n",
-    "        self.best_models = [] # 가장 좋은 상위 3개 모델의 정보를 저장할 리스트\n",
-    "        self.lowest_loss = float('inf') # 가장 낮은 Loss를 저장할 변수\n",
-    "\n",
-    "    def save_model(self, epoch, loss):\n",
-    "        # 모델 저장 경로 설정\n",
-    "        os.makedirs(self.result_path, exist_ok=True)\n",
-    "\n",
-    "        # 현재 에폭 모델 저장\n",
-    "        current_model_path = os.path.join(self.result_path, f'model_epoch_{epoch}_loss_{loss:.4f}.pt')\n",
-    "        torch.save(self.model.state_dict(), current_model_path)\n",
-    "\n",
-    "        # 최상위 3개 모델 관리\n",
-    "        self.best_models.append((loss, epoch, current_model_path))\n",
-    "        self.best_models.sort()\n",
-    "        if len(self.best_models) > 3:\n",
-    "            _, _, path_to_remove = self.best_models.pop(-1)  # 가장 높은 손실 모델 삭제\n",
-    "            if os.path.exists(path_to_remove):\n",
-    "                os.remove(path_to_remove)\n",
-    "\n",
-    "        # 가장 낮은 손실의 모델 저장\n",
-    "        if loss < self.lowest_loss:\n",
-    "            self.lowest_loss = loss\n",
-    "            best_model_path = os.path.join(self.result_path, 'best_model.pt')\n",
-    "            torch.save(self.model.state_dict(), best_model_path)\n",
-    "            print(f\"Save {epoch}epoch result. Loss = {loss:.4f}\")\n",
-    "\n",
-    "    def train_epoch(self) -> float:\n",
-    "        # 한 에폭 동안의 훈련을 진행\n",
-    "        self.model.train()\n",
-    "        \n",
-    "        total_loss = 0.0\n",
-    "        progress_bar = tqdm(self.train_loader, desc=\"Training\", leave=False)\n",
-    "        \n",
-    "        for images, targets in progress_bar:\n",
-    "            images, targets = images.to(self.device), targets.to(self.device)\n",
-    "            self.optimizer.zero_grad()\n",
-    "            outputs = self.model(images)\n",
-    "            loss = self.loss_fn(outputs, targets)\n",
-    "            loss.backward()\n",
-    "            self.optimizer.step()\n",
-    "            self.scheduler.step()\n",
-    "            total_loss += loss.item()\n",
-    "            progress_bar.set_postfix(loss=loss.item())\n",
-    "        \n",
-    "        return total_loss / len(self.train_loader)\n",
-    "\n",
-    "    def validate(self) -> float:\n",
-    "        # 모델의 검증을 진행\n",
-    "        self.model.eval()\n",
-    "        \n",
-    "        total_loss = 0.0\n",
-    "        progress_bar = tqdm(self.val_loader, desc=\"Validating\", leave=False)\n",
-    "        \n",
-    "        with torch.no_grad():\n",
-    "            for images, targets in progress_bar:\n",
-    "                images, targets = images.to(self.device), targets.to(self.device)\n",
-    "                outputs = self.model(images)    \n",
-    "                loss = self.loss_fn(outputs, targets)\n",
-    "                total_loss += loss.item()\n",
-    "                progress_bar.set_postfix(loss=loss.item())\n",
-    "        \n",
-    "        return total_loss / len(self.val_loader)\n",
-    "\n",
-    "    def train(self) -> None:\n",
-    "        # 전체 훈련 과정을 관리\n",
-    "        for epoch in range(self.epochs):\n",
-    "            print(f\"Epoch {epoch+1}/{self.epochs}\")\n",
-    "            \n",
-    "            train_loss = self.train_epoch()\n",
-    "            val_loss = self.validate()\n",
-    "            print(f\"Epoch {epoch+1}, Train Loss: {train_loss:.4f}, Validation Loss: {val_loss:.4f}\\n\")\n",
-    "\n",
-    "            self.save_model(epoch, val_loss)\n",
-    "            self.scheduler.step()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "22f41c09-318a-4f2e-bdca-68d8a07e9938",
-   "metadata": {},
-   "source": [
-    "# Model Training"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "698783c4-ac2a-4e66-82aa-637df06ce012",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 학습에 사용할 장비를 선택.\n",
-    "# torch라이브러리에서 gpu를 인식할 경우, cuda로 설정.\n",
-    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "76cfe17e-fb14-42e4-84ae-b6773f0b78fb",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 학습 데이터의 경로와 정보를 가진 파일의 경로를 설정.\n",
-    "traindata_dir = \"./data/train\"\n",
-    "traindata_info_file = \"./data/train.csv\"\n",
-    "save_result_path = \"./train_result\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "42a4778f-bfd0-4638-8972-f366cd6b0a4f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 학습 데이터의 class, image path, target에 대한 정보가 들어있는 csv파일을 읽기.\n",
-    "train_info = pd.read_csv(traindata_info_file)\n",
-    "\n",
-    "# 총 class의 수를 측정.\n",
-    "num_classes = len(train_info['target'].unique())\n",
-    "\n",
-    "# 각 class별로 8:2의 비율이 되도록 학습과 검증 데이터를 분리.\n",
-    "train_df, val_df = train_test_split(\n",
-    "    train_info, \n",
-    "    test_size=0.2,\n",
-    "    stratify=train_info['target']\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "a0889892-5f63-4dcf-bcab-9ff2659ad28d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 학습에 사용할 Transform을 선언.\n",
-    "transform_selector = TransformSelector(\n",
-    "    transform_type = \"albumentations\"\n",
-    ")\n",
-    "train_transform = transform_selector.get_transform(is_train=True)\n",
-    "val_transform = transform_selector.get_transform(is_train=False)\n",
-    "\n",
-    "# 학습에 사용할 Dataset을 선언.\n",
-    "train_dataset = CustomDataset(\n",
-    "    root_dir=traindata_dir,\n",
-    "    info_df=train_df,\n",
-    "    transform=train_transform\n",
-    ")\n",
-    "val_dataset = CustomDataset(\n",
-    "    root_dir=traindata_dir,\n",
-    "    info_df=val_df,\n",
-    "    transform=val_transform\n",
-    ")\n",
-    "\n",
-    "# 학습에 사용할 DataLoader를 선언.\n",
-    "train_loader = DataLoader(\n",
-    "    train_dataset, \n",
-    "    batch_size=64, \n",
-    "    shuffle=True\n",
-    ")\n",
-    "val_loader = DataLoader(\n",
-    "    val_dataset, \n",
-    "    batch_size=64, \n",
-    "    shuffle=False\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "id": "9447ca16-a1ff-4da4-b5a1-4cf239ebcf80",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "TimmModel(\n",
-       "  (model): ResNet(\n",
-       "    (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
-       "    (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "    (act1): ReLU(inplace=True)\n",
-       "    (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
-       "    (layer1): Sequential(\n",
-       "      (0): BasicBlock(\n",
-       "        (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-       "        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (drop_block): Identity()\n",
-       "        (act1): ReLU(inplace=True)\n",
-       "        (aa): Identity()\n",
-       "        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-       "        (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (act2): ReLU(inplace=True)\n",
-       "      )\n",
-       "      (1): BasicBlock(\n",
-       "        (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-       "        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (drop_block): Identity()\n",
-       "        (act1): ReLU(inplace=True)\n",
-       "        (aa): Identity()\n",
-       "        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-       "        (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (act2): ReLU(inplace=True)\n",
-       "      )\n",
-       "    )\n",
-       "    (layer2): Sequential(\n",
-       "      (0): BasicBlock(\n",
-       "        (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
-       "        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (drop_block): Identity()\n",
-       "        (act1): ReLU(inplace=True)\n",
-       "        (aa): Identity()\n",
-       "        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-       "        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (act2): ReLU(inplace=True)\n",
-       "        (downsample): Sequential(\n",
-       "          (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
-       "          (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        )\n",
-       "      )\n",
-       "      (1): BasicBlock(\n",
-       "        (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-       "        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (drop_block): Identity()\n",
-       "        (act1): ReLU(inplace=True)\n",
-       "        (aa): Identity()\n",
-       "        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-       "        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (act2): ReLU(inplace=True)\n",
-       "      )\n",
-       "    )\n",
-       "    (layer3): Sequential(\n",
-       "      (0): BasicBlock(\n",
-       "        (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
-       "        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (drop_block): Identity()\n",
-       "        (act1): ReLU(inplace=True)\n",
-       "        (aa): Identity()\n",
-       "        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-       "        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (act2): ReLU(inplace=True)\n",
-       "        (downsample): Sequential(\n",
-       "          (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
-       "          (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        )\n",
-       "      )\n",
-       "      (1): BasicBlock(\n",
-       "        (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-       "        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (drop_block): Identity()\n",
-       "        (act1): ReLU(inplace=True)\n",
-       "        (aa): Identity()\n",
-       "        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-       "        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (act2): ReLU(inplace=True)\n",
-       "      )\n",
-       "    )\n",
-       "    (layer4): Sequential(\n",
-       "      (0): BasicBlock(\n",
-       "        (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
-       "        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (drop_block): Identity()\n",
-       "        (act1): ReLU(inplace=True)\n",
-       "        (aa): Identity()\n",
-       "        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-       "        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (act2): ReLU(inplace=True)\n",
-       "        (downsample): Sequential(\n",
-       "          (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
-       "          (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        )\n",
-       "      )\n",
-       "      (1): BasicBlock(\n",
-       "        (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-       "        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (drop_block): Identity()\n",
-       "        (act1): ReLU(inplace=True)\n",
-       "        (aa): Identity()\n",
-       "        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-       "        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (act2): ReLU(inplace=True)\n",
-       "      )\n",
-       "    )\n",
-       "    (global_pool): SelectAdaptivePool2d(pool_type=avg, flatten=Flatten(start_dim=1, end_dim=-1))\n",
-       "    (fc): Linear(in_features=512, out_features=500, bias=True)\n",
-       "  )\n",
-       ")"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# 학습에 사용할 Model을 선언.\n",
-    "model_selector = ModelSelector(\n",
-    "    model_type='timm', \n",
-    "    num_classes=num_classes,\n",
-    "    model_name='resnet18', \n",
-    "    pretrained=True\n",
-    ")\n",
-    "model = model_selector.get_model()\n",
-    "\n",
-    "# 선언된 모델을 학습에 사용할 장비로 셋팅.\n",
-    "model.to(device)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "3c32f36d-4031-4cf4-8914-6e01d8861837",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 학습에 사용할 optimizer를 선언하고, learning rate를 지정\n",
-    "optimizer = optim.Adam(\n",
-    "    model.parameters(), \n",
-    "    lr=0.001\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "id": "a2bd831e-39a7-4f10-a3a5-aefde280fa89",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 스케줄러 초기화\n",
-    "scheduler_step_size = 30  # 매 30step마다 학습률 감소\n",
-    "scheduler_gamma = 0.1  # 학습률을 현재의 10%로 감소\n",
-    "\n",
-    "# 한 epoch당 step 수 계산\n",
-    "steps_per_epoch = len(train_loader)\n",
-    "\n",
-    "# 2 epoch마다 학습률을 감소시키는 스케줄러 선언\n",
-    "epochs_per_lr_decay = 2\n",
-    "scheduler_step_size = steps_per_epoch * epochs_per_lr_decay\n",
-    "\n",
-    "scheduler = optim.lr_scheduler.StepLR(\n",
-    "    optimizer, \n",
-    "    step_size=scheduler_step_size, \n",
-    "    gamma=scheduler_gamma\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "32715cca-5a4a-49d5-8fd9-f84da4581523",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 학습에 사용할 Loss를 선언.\n",
-    "loss_fn = Loss()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "d17e2556-efcf-42c6-9d73-dc27813e7dff",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 앞서 선언한 필요 class와 변수들을 조합해, 학습을 진행할 Trainer를 선언. \n",
-    "trainer = Trainer(\n",
-    "    model=model, \n",
-    "    device=device, \n",
-    "    train_loader=train_loader,\n",
-    "    val_loader=val_loader, \n",
-    "    optimizer=optimizer,\n",
-    "    scheduler=scheduler,\n",
-    "    loss_fn=loss_fn, \n",
-    "    epochs=5,\n",
-    "    result_path=save_result_path\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "id": "0ac1110e-558f-4170-ad8d-42ac8eb5c3c4",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Epoch 1/5\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "                                                                      \r"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Epoch 1, Train Loss: 4.7797, Validation Loss: 2.8981\n",
-      "\n",
-      "Save 0epoch result. Loss = 2.8981\n",
-      "Epoch 2/5\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "                                                                      \r"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Epoch 2, Train Loss: 2.0138, Validation Loss: 1.8324\n",
-      "\n",
-      "Save 1epoch result. Loss = 1.8324\n",
-      "Epoch 3/5\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "                                                                       \r"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Epoch 3, Train Loss: 1.0609, Validation Loss: 1.4165\n",
-      "\n",
-      "Save 2epoch result. Loss = 1.4165\n",
-      "Epoch 4/5\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "                                                                       \r"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Epoch 4, Train Loss: 0.8974, Validation Loss: 1.3568\n",
-      "\n",
-      "Save 3epoch result. Loss = 1.3568\n",
-      "Epoch 5/5\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "                                                                       "
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Epoch 5, Train Loss: 0.8140, Validation Loss: 1.3479\n",
-      "\n",
-      "Save 4epoch result. Loss = 1.3479\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\r"
-     ]
-    }
-   ],
-   "source": [
-    "# 모델 학습.\n",
-    "trainer.train()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "11087088-9b1f-4f7d-8eb5-72008cc88a50",
-   "metadata": {},
-   "source": [
-    "# Inference"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "6bf92c3c-7b38-4f89-af2a-5dfbabf51926",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 모델 추론을 위한 함수\n",
-    "def inference(\n",
-    "    model: nn.Module, \n",
-    "    device: torch.device, \n",
-    "    test_loader: DataLoader\n",
-    "):\n",
-    "    # 모델을 평가 모드로 설정\n",
-    "    model.to(device)\n",
-    "    model.eval()\n",
-    "    \n",
-    "    predictions = []\n",
-    "    with torch.no_grad():  # Gradient 계산을 비활성화\n",
-    "        for images in tqdm(test_loader):\n",
-    "            # 데이터를 같은 장치로 이동\n",
-    "            images = images.to(device)\n",
-    "            \n",
-    "            # 모델을 통해 예측 수행\n",
-    "            logits = model(images)\n",
-    "            logits = F.softmax(logits, dim=1)\n",
-    "            preds = logits.argmax(dim=1)\n",
-    "            \n",
-    "            # 예측 결과 저장\n",
-    "            predictions.extend(preds.cpu().detach().numpy())  # 결과를 CPU로 옮기고 리스트에 추가\n",
-    "    \n",
-    "    return predictions"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "b407c24c-785d-4ffc-b17b-84ae7dc4ecae",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 추론 데이터의 경로와 정보를 가진 파일의 경로를 설정.\n",
-    "testdata_dir = \"./data/test\"\n",
-    "testdata_info_file = \"./data/test.csv\"\n",
-    "save_result_path = \"./train_result\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "cbb89c12-3b5d-4647-a8c2-83650dce6281",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 추론 데이터의 class, image path, target에 대한 정보가 들어있는 csv파일을 읽기.\n",
-    "test_info = pd.read_csv(testdata_info_file)\n",
-    "\n",
-    "# 총 class 수.\n",
-    "num_classes = 500"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "ecec8773-6045-401e-b307-0a9758374c4c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 추론에 사용할 Transform을 선언.\n",
-    "transform_selector = TransformSelector(\n",
-    "    transform_type = \"albumentations\"\n",
-    ")\n",
-    "test_transform = transform_selector.get_transform(is_train=False)\n",
-    "\n",
-    "# 추론에 사용할 Dataset을 선언.\n",
-    "test_dataset = CustomDataset(\n",
-    "    root_dir=testdata_dir,\n",
-    "    info_df=test_info,\n",
-    "    transform=test_transform,\n",
-    "    is_inference=True\n",
-    ")\n",
-    "\n",
-    "# 추론에 사용할 DataLoader를 선언.\n",
-    "test_loader = DataLoader(\n",
-    "    test_dataset, \n",
-    "    batch_size=64, \n",
-    "    shuffle=False,\n",
-    "    drop_last=False\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "99cc06c1-ce65-476b-8d5b-b8025fcde443",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 추론에 사용할 장비를 선택.\n",
-    "# torch라이브러리에서 gpu를 인식할 경우, cuda로 설정.\n",
-    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
-    "\n",
-    "# 추론에 사용할 Model을 선언.\n",
-    "model_selector = ModelSelector(\n",
-    "    model_type='timm', \n",
-    "    num_classes=num_classes,\n",
-    "    model_name='resnet18', \n",
-    "    pretrained=False\n",
-    ")\n",
-    "model = model_selector.get_model()\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 52,
-   "id": "317b966a-254c-4ac6-b9b4-1d39f59d524a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<All keys matched successfully>"
-      ]
-     },
-     "execution_count": 52,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# best epoch 모델을 불러오기.\n",
-    "model.load_state_dict(\n",
-    "    torch.load(\n",
-    "        os.path.join(save_result_path, \"best_model.pt\"),\n",
-    "        map_location='cpu'\n",
-    "    )\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "id": "514852af-f338-4b27-a5a5-8b65406a8023",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|█████████████████████████████████████████| 157/157 [04:53<00:00,  1.87s/it]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# predictions를 CSV에 저장할 때 형식을 맞춰서 저장\n",
-    "# 테스트 함수 호출\n",
-    "predictions = inference(\n",
-    "    model=model, \n",
-    "    device=device, \n",
-    "    test_loader=test_loader\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "cc96c889-2423-42b2-8c3c-4b1d364ece71",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>ID</th>\n",
-       "      <th>image_path</th>\n",
-       "      <th>target</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>0</td>\n",
-       "      <td>0.JPEG</td>\n",
-       "      <td>314</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>1</td>\n",
-       "      <td>1.JPEG</td>\n",
-       "      <td>287</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>2</td>\n",
-       "      <td>2.JPEG</td>\n",
-       "      <td>314</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>3</td>\n",
-       "      <td>3.JPEG</td>\n",
-       "      <td>314</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>4</td>\n",
-       "      <td>4.JPEG</td>\n",
-       "      <td>158</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>...</th>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>10009</th>\n",
-       "      <td>10009</td>\n",
-       "      <td>10009.JPEG</td>\n",
-       "      <td>158</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>10010</th>\n",
-       "      <td>10010</td>\n",
-       "      <td>10010.JPEG</td>\n",
-       "      <td>314</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>10011</th>\n",
-       "      <td>10011</td>\n",
-       "      <td>10011.JPEG</td>\n",
-       "      <td>314</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>10012</th>\n",
-       "      <td>10012</td>\n",
-       "      <td>10012.JPEG</td>\n",
-       "      <td>314</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>10013</th>\n",
-       "      <td>10013</td>\n",
-       "      <td>10013.JPEG</td>\n",
-       "      <td>287</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "<p>10014 rows × 3 columns</p>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "          ID  image_path  target\n",
-       "0          0      0.JPEG     314\n",
-       "1          1      1.JPEG     287\n",
-       "2          2      2.JPEG     314\n",
-       "3          3      3.JPEG     314\n",
-       "4          4      4.JPEG     158\n",
-       "...      ...         ...     ...\n",
-       "10009  10009  10009.JPEG     158\n",
-       "10010  10010  10010.JPEG     314\n",
-       "10011  10011  10011.JPEG     314\n",
-       "10012  10012  10012.JPEG     314\n",
-       "10013  10013  10013.JPEG     287\n",
-       "\n",
-       "[10014 rows x 3 columns]"
-      ]
-     },
-     "execution_count": 19,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# 모든 클래스에 대한 예측 결과를 하나의 문자열로 합침\n",
-    "test_info['target'] = predictions\n",
-    "test_info = test_info.reset_index().rename(columns={\"index\": \"ID\"})\n",
-    "test_info"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "c4efd2f6-d74a-491b-a7b1-fd7cf96f45a4",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# DataFrame 저장\n",
-    "test_info.to_csv(\"output.csv\", index=False)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ac79e3df-e5c3-4a49-b37e-0dea1300c317",
-   "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.18"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/RECcode/cv/configs/base_train copy.yaml b/RECcode/cv/configs/base_train copy.yaml
deleted file mode 100644
index c2b4d1b..0000000
--- a/RECcode/cv/configs/base_train copy.yaml	
+++ /dev/null
@@ -1,59 +0,0 @@
-# data 관련 설정
-image_root: /data/ephemeral/home/data/train/DCM
-label_root: /data/ephemeral/home/data/train/outputs_json
-
-# 모델명 및 사전 학습 여부
-model_name: Unet
-model_parameter:
-  encoder_name: efficientnet-b0
-  classes: 29
-
-# batch_size
-train_batch_size: 4
-val_batch_size: 4
-
-# image resize
-image_size: &image_size 512
-
-# transform 관련
-transform:
-  Resize:
-    width: *image_size
-    height: *image_size
-
-# 학습 관련 하이퍼파라미터
-lr: 1e-3
-weight_decay: 1e-6
-
-max_epoch: &max_epoch 40
-
-# loss 관련 설정
-loss_name: BCEWithLogitsLoss
-
-# loss에 필요한 parameter -> dict 형태로 작성
-loss_parameter: {}
-
-# scheduler 관련 설정
-scheduler_name: CosineAnnealingLR
-
-# scheduler 필요한 parameter -> dict 형태로 작성
-scheduler_parameter:
-  T_max: *max_epoch
-  eta_min: 1e-6
-
-# random seed값
-seed: 42
-
-# validation 관련 인자
-val_fold: 0
-val_interval: 2
-threshold: 0.5
-
-# checkpoint 저장 경로
-save_dir: ./checkpoints/Unet
-
-# wandb
-api_key: 7363797140af326caa051190a07bd49ce5341c67
-team_name: cv19-eternalpaperbox
-project_name: UNet
-experiment_detail: base
diff --git a/RECcode/eda.ipynb b/RECcode/eda.ipynb
deleted file mode 100644
index 368f91d..0000000
--- a/RECcode/eda.ipynb
+++ /dev/null
@@ -1,1280 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 356,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "import pandas as pd\n",
-    "import matplotlib.pyplot as plt\n",
-    "import seaborn as sns\n",
-    "\n",
-    "from glob import glob\n",
-    "from collections import defaultdict\n",
-    "from PIL import Image\n",
-    "import numpy as np\n",
-    "import cv2"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# 1. Images Metadata"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 304,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 학습 데이터의 경로와 정보를 가진 파일의 경로를 설정\n",
-    "traindata_dir = \"./data/train\"\n",
-    "traindata_info_file = \"./data/train.csv\"\n",
-    "\n",
-    "# 테스트 데이터의 경로와 정보를 가진 파일의 경로를 설정\n",
-    "testdata_dir = \"./data/test\"\n",
-    "testdata_info_file = \"./data/test.csv\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 315,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 학습 데이터의 class, image path, target에 대한 정보가 들어있는 csv파일을 읽기\n",
-    "train_data = pd.read_csv(traindata_info_file)\n",
-    "\n",
-    "# 테스트 데이터\n",
-    "test_data = pd.read_csv(testdata_info_file)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 316,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "<class 'pandas.core.frame.DataFrame'>\n",
-      "RangeIndex: 15021 entries, 0 to 15020\n",
-      "Data columns (total 3 columns):\n",
-      " #   Column      Non-Null Count  Dtype \n",
-      "---  ------      --------------  ----- \n",
-      " 0   class_name  15021 non-null  object\n",
-      " 1   image_path  15021 non-null  object\n",
-      " 2   target      15021 non-null  int64 \n",
-      "dtypes: int64(1), object(2)\n",
-      "memory usage: 352.2+ KB\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(None,\n",
-       "   class_name                image_path  target\n",
-       " 0  n01872401  n01872401/sketch_50.JPEG      59\n",
-       " 1  n02417914  n02417914/sketch_11.JPEG     202\n",
-       " 2  n02106166   n02106166/sketch_3.JPEG     138\n",
-       " 3  n04235860   n04235860/sketch_2.JPEG     382\n",
-       " 4  n02056570  n02056570/sketch_40.JPEG      80)"
-      ]
-     },
-     "execution_count": 316,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# 학습 데이터의 정보를 출력\n",
-    "train_info = train_data.info()\n",
-    "train_head = train_data.head()\n",
-    "\n",
-    "train_info, train_head\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "주어진 학습 데이터셋은 15021개의 항목과 3개의 컬럼으로 구성되어 있다.\n",
-    "1. class_name: 클래스 이름, string\n",
-    "2. image_path: 이미지 파일의 경로, string\n",
-    "3. target: 클래스를 의미하는 숫자아이디, integer"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 317,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "<class 'pandas.core.frame.DataFrame'>\n",
-      "RangeIndex: 10014 entries, 0 to 10013\n",
-      "Data columns (total 1 columns):\n",
-      " #   Column      Non-Null Count  Dtype \n",
-      "---  ------      --------------  ----- \n",
-      " 0   image_path  10014 non-null  object\n",
-      "dtypes: object(1)\n",
-      "memory usage: 78.4+ KB\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(None,\n",
-       "   image_path\n",
-       " 0     0.JPEG\n",
-       " 1     1.JPEG\n",
-       " 2     2.JPEG\n",
-       " 3     3.JPEG\n",
-       " 4     4.JPEG)"
-      ]
-     },
-     "execution_count": 317,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# 테스트 데이터의 정보를 출력.\n",
-    "test_info = test_data.info()\n",
-    "test_head = test_data.head()\n",
-    "\n",
-    "test_info, test_head"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "주어진 테스트 데이터셋은 10014개의 항목과 1개의 컬럼으로 구성되어 있다.\n",
-    "1. image_path: 이미지 파일의 경로, string"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 326,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(       class_name                image_path        target\n",
-       " count       15021                     15021  15021.000000\n",
-       " unique        500                     15021           NaN\n",
-       " top     n04532106  n01872401/sketch_50.JPEG           NaN\n",
-       " freq           31                         1           NaN\n",
-       " mean          NaN                       NaN    249.989082\n",
-       " std           NaN                       NaN    144.471752\n",
-       " min           NaN                       NaN      0.000000\n",
-       " 25%           NaN                       NaN    125.000000\n",
-       " 50%           NaN                       NaN    250.000000\n",
-       " 75%           NaN                       NaN    375.000000\n",
-       " max           NaN                       NaN    499.000000,\n",
-       " 500,\n",
-       " 500)"
-      ]
-     },
-     "execution_count": 326,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# 데이터의 기본적인 통계 정보를 출력\n",
-    "data_description = train_data.describe(include='all')\n",
-    "\n",
-    "# class_name의 unique한 값의 개수를 출력\n",
-    "unique_classes = train_data['class_name'].nunique()\n",
-    "\n",
-    "# target의 unique한 값의 개수를 출력\n",
-    "unique_targets = train_data['target'].nunique()\n",
-    "\n",
-    "data_description, unique_classes, unique_targets"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "기본 통계\n",
-    "- 데이터셋에는 15,021개의 항목이 있음\n",
-    "- 500개의 고유한 클래스 이름과 15021개의 고유한 이미지 경로가 존재\n",
-    "- Target값은 0에서 499까지 500개의 값을 가지고 있음"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 329,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/var/folders/h6/61flrrfj1l38_nn873r977580000gn/T/ipykernel_38155/2909061321.py:3: FutureWarning: \n",
-      "\n",
-      "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `y` variable to `hue` and set `legend=False` for the same effect.\n",
-      "\n",
-      "  sns.countplot(y=train_data['class_name'], order=train_data['class_name'].value_counts().index, palette='viridis')\n",
-      "/var/folders/h6/61flrrfj1l38_nn873r977580000gn/T/ipykernel_38155/2909061321.py:10: UserWarning: Ignoring `palette` because no `hue` variable has been assigned.\n",
-      "  sns.histplot(train_data['target'], bins=500, kde=False, palette='viridis')\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1600x1000 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1600x1000 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.figure(figsize=(16, 10))\n",
-    "\n",
-    "# class_name별로 샘플의 개수를 출력\n",
-    "sns.countplot(y=train_data['class_name'], order=train_data['class_name'].value_counts().index, palette='viridis')\n",
-    "plt.title('Distribution of Samples per Class')\n",
-    "plt.xlabel('Number of Samples')\n",
-    "plt.ylabel('Class Name')\n",
-    "\n",
-    "# target 값의 분포를 출력\n",
-    "plt.figure(figsize=(16, 10))\n",
-    "sns.histplot(train_data['target'], bins=500, kde=False, palette='viridis')\n",
-    "plt.title('Distribution of Target Values')\n",
-    "plt.xlabel('Target Value')\n",
-    "plt.ylabel('Number of Samples')\n",
-    "\n",
-    "plt.show()\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Class name 분포\n",
-    "- 대부분 29에서 31 사이의 값을 가지고 있음\n",
-    "\n",
-    "Target 분포\n",
-    "- 대부분 29에서 31 사이의 값을 가지고 있음\n",
-    "\n",
-    "데이터 셋 전반적으로 Class name, Target에 대해서 29~31개의 값을 가지고 있음."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# 2. Images - Exploration and processing"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 334,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Number of train images: 15021\n",
-      "Number of test images: 10014\n"
-     ]
-    }
-   ],
-   "source": [
-    "# glob을 이용하여 이미지 파일의 경로를 읽어옴\n",
-    "train_images = glob(traindata_dir + \"/*/*\")\n",
-    "test_images = glob(testdata_dir + \"/*\")\n",
-    "print(f\"Number of train images: {len(train_images)}\")\n",
-    "print(f\"Number of test images: {len(test_images)}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 2.1 Getting Image's statistics"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 339,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "image_prop = defaultdict(list)\n",
-    "\n",
-    "for i, path in enumerate(train_images):\n",
-    "    with Image.open(path) as img:\n",
-    "        image_prop['height'].append(img.height)\n",
-    "        image_prop['width'].append(img.width)\n",
-    "        image_prop['img_aspect_ratio'] = img.width / img.height\n",
-    "        image_prop['mode'].append(img.mode)\n",
-    "        image_prop['format'].append(img.format)\n",
-    "        image_prop['size'].append(round(os.path.getsize(path) / 1e6, 2))\n",
-    "    image_prop['path'].append(path)\n",
-    "    image_prop['image_path'].append(path.split('/')[-2] + \"/\" + path.split('/')[-1])\n",
-    "\n",
-    "image_data = pd.DataFrame(image_prop)\n",
-    "\n",
-    "image_data = image_data.merge(train_data, on='image_path')\n",
-    "#image_data.sort_values(by='target', inplace=True)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 358,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 이미지의 특징을 추출하는 함수\n",
-    "def extract_image_features(image_path):\n",
-    "    \"\"\"\n",
-    "    Extracts features from an image.\n",
-    "    Args:\n",
-    "        image_path (str): Path to the image file.\n",
-    "    Returns:\n",
-    "        width (int): Width of the image.\n",
-    "        height (int): Height of the image.\n",
-    "        mode (str): Mode of the image.\n",
-    "        format (str): Format of the image.\n",
-    "        size (int): Size of the image.\n",
-    "        mean_red (float): Mean of red channel.\n",
-    "        mean_green (float): Mean of green channel.\n",
-    "        mean_blue (float): Mean of blue channel.\n",
-    "    \"\"\"\n",
-    "    try:\n",
-    "        with Image.open(image_path) as img:\n",
-    "            img = img.convert('RGB')\n",
-    "            width, height = img.size\n",
-    "            img_array = np.array(img)\n",
-    "            mean_red = np.mean(img_array[:, :, 0])\n",
-    "            mean_green = np.mean(img_array[:, :, 1])\n",
-    "            mean_blue = np.mean(img_array[:, :, 2])\n",
-    "            format = image_path.split('.')[-1].upper()\n",
-    "            return width, height, img.mode, format, os.path.getsize(image_path), mean_red, mean_green, mean_blue\n",
-    "    except Exception as e:\n",
-    "        return None, None, None, None, None, None, None, None\n",
-    "\n",
-    "image_prop = defaultdict(list)\n",
-    "\n",
-    "for i, path in enumerate(train_images):\n",
-    "    width, height, mode, format, size, mean_red, mean_green, mean_blue = extract_image_features(path)\n",
-    "    image_prop['height'].append(height)\n",
-    "    image_prop['width'].append(width)\n",
-    "    image_prop['mode'].append(mode)\n",
-    "    image_prop['format'].append(format)\n",
-    "    image_prop['size'].append(round(size / 1e6, 2) if size else None)\n",
-    "    image_prop['mean_red'].append(mean_red)\n",
-    "    image_prop['mean_green'].append(mean_green)\n",
-    "    image_prop['mean_blue'].append(mean_blue)\n",
-    "    image_prop['path'].append(path)\n",
-    "    image_prop['image_path'].append(path.split('/')[-2] + \"/\" + path.split('/')[-1])\n",
-    "\n",
-    "image_data = pd.DataFrame(image_prop)\n",
-    "image_data['img_aspect_ratio'] = image_data['width'] / image_data['height']\n",
-    "\n",
-    "image_data = image_data.merge(train_data, on='image_path')\n",
-    "image_data.sort_values(by='target', inplace=True)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 359,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>height</th>\n",
-       "      <th>width</th>\n",
-       "      <th>mode</th>\n",
-       "      <th>format</th>\n",
-       "      <th>size</th>\n",
-       "      <th>mean_red</th>\n",
-       "      <th>mean_green</th>\n",
-       "      <th>mean_blue</th>\n",
-       "      <th>path</th>\n",
-       "      <th>image_path</th>\n",
-       "      <th>img_aspect_ratio</th>\n",
-       "      <th>class_name</th>\n",
-       "      <th>target</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>1803</th>\n",
-       "      <td>356</td>\n",
-       "      <td>450</td>\n",
-       "      <td>RGB</td>\n",
-       "      <td>JPEG</td>\n",
-       "      <td>0.07</td>\n",
-       "      <td>227.089925</td>\n",
-       "      <td>227.089925</td>\n",
-       "      <td>227.089925</td>\n",
-       "      <td>./data/train/n01443537/sketch_27.JPEG</td>\n",
-       "      <td>n01443537/sketch_27.JPEG</td>\n",
-       "      <td>1.264045</td>\n",
-       "      <td>n01443537</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1783</th>\n",
-       "      <td>470</td>\n",
-       "      <td>450</td>\n",
-       "      <td>RGB</td>\n",
-       "      <td>JPEG</td>\n",
-       "      <td>0.05</td>\n",
-       "      <td>234.881868</td>\n",
-       "      <td>234.881868</td>\n",
-       "      <td>234.881868</td>\n",
-       "      <td>./data/train/n01443537/sketch_6.JPEG</td>\n",
-       "      <td>n01443537/sketch_6.JPEG</td>\n",
-       "      <td>0.957447</td>\n",
-       "      <td>n01443537</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1784</th>\n",
-       "      <td>483</td>\n",
-       "      <td>590</td>\n",
-       "      <td>RGB</td>\n",
-       "      <td>JPEG</td>\n",
-       "      <td>0.07</td>\n",
-       "      <td>239.440720</td>\n",
-       "      <td>239.440720</td>\n",
-       "      <td>239.440720</td>\n",
-       "      <td>./data/train/n01443537/sketch_14.JPEG</td>\n",
-       "      <td>n01443537/sketch_14.JPEG</td>\n",
-       "      <td>1.221532</td>\n",
-       "      <td>n01443537</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1785</th>\n",
-       "      <td>800</td>\n",
-       "      <td>800</td>\n",
-       "      <td>RGB</td>\n",
-       "      <td>JPEG</td>\n",
-       "      <td>0.08</td>\n",
-       "      <td>237.483253</td>\n",
-       "      <td>236.771539</td>\n",
-       "      <td>237.349350</td>\n",
-       "      <td>./data/train/n01443537/sketch_34.JPEG</td>\n",
-       "      <td>n01443537/sketch_34.JPEG</td>\n",
-       "      <td>1.000000</td>\n",
-       "      <td>n01443537</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1786</th>\n",
-       "      <td>800</td>\n",
-       "      <td>800</td>\n",
-       "      <td>RGB</td>\n",
-       "      <td>JPEG</td>\n",
-       "      <td>0.05</td>\n",
-       "      <td>245.134653</td>\n",
-       "      <td>245.134653</td>\n",
-       "      <td>245.134653</td>\n",
-       "      <td>./data/train/n01443537/sketch_35.JPEG</td>\n",
-       "      <td>n01443537/sketch_35.JPEG</td>\n",
-       "      <td>1.000000</td>\n",
-       "      <td>n01443537</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "      height  width mode format  size    mean_red  mean_green   mean_blue  \\\n",
-       "1803     356    450  RGB   JPEG  0.07  227.089925  227.089925  227.089925   \n",
-       "1783     470    450  RGB   JPEG  0.05  234.881868  234.881868  234.881868   \n",
-       "1784     483    590  RGB   JPEG  0.07  239.440720  239.440720  239.440720   \n",
-       "1785     800    800  RGB   JPEG  0.08  237.483253  236.771539  237.349350   \n",
-       "1786     800    800  RGB   JPEG  0.05  245.134653  245.134653  245.134653   \n",
-       "\n",
-       "                                       path                image_path  \\\n",
-       "1803  ./data/train/n01443537/sketch_27.JPEG  n01443537/sketch_27.JPEG   \n",
-       "1783   ./data/train/n01443537/sketch_6.JPEG   n01443537/sketch_6.JPEG   \n",
-       "1784  ./data/train/n01443537/sketch_14.JPEG  n01443537/sketch_14.JPEG   \n",
-       "1785  ./data/train/n01443537/sketch_34.JPEG  n01443537/sketch_34.JPEG   \n",
-       "1786  ./data/train/n01443537/sketch_35.JPEG  n01443537/sketch_35.JPEG   \n",
-       "\n",
-       "      img_aspect_ratio class_name  target  \n",
-       "1803          1.264045  n01443537       0  \n",
-       "1783          0.957447  n01443537       0  \n",
-       "1784          1.221532  n01443537       0  \n",
-       "1785          1.000000  n01443537       0  \n",
-       "1786          1.000000  n01443537       0  "
-      ]
-     },
-     "execution_count": 359,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "image_data.head()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 2.1.1 이미지 파일크기 분석"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 346,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1600x1000 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.figure(figsize=(16, 10))\n",
-    "\n",
-    "# 이미지 파일의 크기 분포를 출력\n",
-    "sns.histplot(image_data['size'], bins=30, kde=True, color='green')\n",
-    "plt.title('Distribution of Image File Sizes')\n",
-    "plt.xlabel('Size (MB)')\n",
-    "plt.ylabel('Frequency')\n",
-    "\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "이미지 파일 크기 분포\n",
-    "- 대부분 이미지 파일 크기는 0.05 ~ 0.1 MB 사이에 분포"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 2.1.2 이미지 파일크기 분석"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 345,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1600x1000 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.figure(figsize=(16, 10))\n",
-    "# Image height의 분포를 출력\n",
-    "plt.subplot(1, 2, 1)\n",
-    "sns.histplot(image_data['height'], bins=30, kde=True, color='skyblue')\n",
-    "plt.title('Distribution of Image Height')\n",
-    "plt.xlabel('Height')\n",
-    "plt.ylabel('Frequency')\n",
-    "\n",
-    "# Image width의 분포를 출력\n",
-    "plt.subplot(1, 2, 2)\n",
-    "sns.histplot(image_data['width'], bins=30, kde=True, color='orange')\n",
-    "plt.title('Distribution of Image Width')\n",
-    "plt.xlabel('Width')\n",
-    "plt.ylabel('Frequency')\n",
-    "\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "이미지의 높이와 너비 분포\n",
-    "- 이미지 높이: 대부분 이미지 높이는 400에서 800 픽셀 사이에 분포\n",
-    "- 이미지 너비: 대부분 이미지 너비는 400에서 800 픽셀 사이에 분포"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 347,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1000x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.figure(figsize=(10, 6))\n",
-    "\n",
-    "# 이미지의 가로 세로 비율을 출력\n",
-    "sns.histplot(image_data['img_aspect_ratio'], bins=30, kde=True, color='purple')\n",
-    "plt.title('Distribution of Image Aspect Ratios')\n",
-    "plt.xlabel('Aspect Ratio')\n",
-    "plt.ylabel('Frequency')\n",
-    "\n",
-    "plt.show()\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "가로세로 비율 분포\n",
-    "- 대부분의 이미지 가로세로 비율을 0.8에서 1.2사이에 분포"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 348,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAABSMAAAOLCAYAAACrKZYFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAACbF0lEQVR4nOzde/zXg/3///ur87lEJxQRCzMlkww5V5pt2NCYSszI5vAxZjanoQ37bAxrtim2pTlkGz4OySEMc57THJscSoiSqPR+/v7w8/5666B493zXu+v1cnlfLr2ez+fr+X68Xs93yq3n6/msFEVRBAAAAABgBWtQ1wMAAAAAAKsHMRIAAAAAKIUYCQAAAACUQowEAAAAAEohRgIAAAAApRAjAQAAAIBSiJEAAAAAQCnESAAAAACgFGIkAAAAAFAKMRIAgJXeqaeemkqlUtdj1Bs77rhjdtxxx7oeAwBYDYmRAMBqYezYsalUKqlUKrnrrrsWWV8URbp27ZpKpZKvfvWrdTDhslt//fWrX0ulUknLli2z9dZb57LLLlvic2bMmJEf/ehH2XzzzdOqVas0a9YsPXr0yPDhwxd5Pz7+Xn301bFjx+y000654YYbljrbjBkz0qhRoxx44IFL3Oadd95J8+bNs/feey/fC+dTvfbaaznuuOPSs2fPtGjRIi1btkyfPn1yxhln5O23367r8QAA0qiuBwAAKFOzZs0ybty4bLfddjWW33HHHXn55ZfTtGnTOpps+fTq1Sv/8z//kySZNm1a/vCHP2To0KGZN29eDj300Brb/utf/8rgwYPzzjvvZP/998/3vve9NG3aNFOmTMnf/va3jB07NnfccUd22GGHGs87/fTT07179xRFkddeey1jx47NHnvskWuvvXaJwbZjx47Zbbfd8ve//z1z585NixYtFtlmwoQJef/995caLFl+999/f/bYY4/MmTMnBx54YPr06ZMkeeCBB/Lzn/88kydPzs0331zHUwIAqzsxEgBYreyxxx658sorc/7556dRo//3V6Fx48alT58+eeONN+pwumW3zjrr1Ih5w4YNywYbbJBf/epXNWLkW2+9lW984xtp1KhRHnnkkfTs2bPGfs4444yMHz8+zZs3X+R7DBo0KFtttVX14xEjRqRTp065/PLLl3r26AEHHJAbb7wx//jHP7L//vsvsn7cuHFp27ZtBg8evFyveXX37rvvpmXLlotd9/bbb2evvfZKw4YN8/DDDy9ynM8888z8/ve/L2NMAICl8jFtAGC1MmTIkLz55puZOHFi9bL58+fnqquuyre//e3FPqeqqiq//vWvs9lmm6VZs2bp1KlTDjvssLz11ls1tvv73/+ewYMHZ+21107Tpk2z4YYb5mc/+1kWLlxYY7sdd9wxX/ziF/Pkk09mp512SosWLbLOOuvk7LPP/syvq0OHDunZs2eef/75GstHjx6dadOm5de//vUigSpJKpVKhgwZki9/+cuf+j3atWuX5s2b14i4i7PXXnulZcuWGTdu3CLrZsyYkUmTJuWb3/xmmjZtmjvvvDPf+ta30q1btzRt2jRdu3bNMccck/fee2+p3+O///1vKpVKxo4du9jXdOqpp9ZY9sorr+Tggw9Op06d0rRp02y22Wa55JJLFnnub37zm2y22WZp0aJF1lhjjWy11VaLfR0fd/vtt6dSqeSvf/1rfvzjH6dz585p2bJlvva1r+Wll15aZPv77rsvAwcOTNu2bdOiRYv0798/d999d41tPrpG5pNPPplvf/vbWWONNRY5m/fjfve73+WVV17J//7v/y72OHfq1Ck/+clPlvj8+fPn5+STT06fPn3Stm3btGzZMttvv31uu+22RbYdP358+vTpk9atW6dNmzbZfPPNc95551WvX7BgQU477bRstNFGadasWdZcc81st912NX7PAQCrL2dGAgCrlfXXXz/9+vXL5ZdfnkGDBiVJbrjhhsyaNSv7779/zj///EWec9hhh2Xs2LEZPnx4fvCDH2TKlCm54IIL8vDDD+fuu+9O48aNk3x4rcVWrVrl2GOPTatWrXLrrbfm5JNPzuzZs3POOefU2Odbb72VgQMHZu+9986+++6bq666KieccEI233zz6rmWxwcffJCXX345a6yxRo3l11577We+PuOsWbPyxhtvpCiKzJgxI7/5zW+qPwK8NC1btszXv/71XHXVVZk5c2bat29fve6vf/1rFi5cmAMOOCBJcuWVV2bu3Lk5/PDDs+aaa+Zf//pXfvOb3+Tll1/OlVdeudwzL85rr72WbbbZJpVKJUceeWQ6dOiQG264ISNGjMjs2bNz9NFHJ0l+//vf5wc/+EG++c1v5qijjsr777+ff//737nvvvuWGKo/7swzz0ylUskJJ5yQGTNm5Ne//nV23XXXPPLII9Vnnt56660ZNGhQ+vTpk1NOOSUNGjTImDFjsvPOO+fOO+/M1ltvXWOf3/rWt7LRRhvlrLPOSlEUS/ze//jHP9K8efN885vf/Ezv0ezZs/OHP/whQ4YMyaGHHpp33nknf/zjHzNgwID861//Sq9evZIkEydOzJAhQ7LLLrvkF7/4RZLkqaeeyt13352jjjoqyYchddSoUTnkkEOy9dZbZ/bs2XnggQfy0EMPZbfddvtM8wEA9UgBALAaGDNmTJGkuP/++4sLLrigaN26dTF37tyiKIriW9/6VrHTTjsVRVEU6623XjF48ODq5915551FkuIvf/lLjf3deOONiyz/aH8fd9hhhxUtWrQo3n///epl/fv3L5IUl112WfWyefPmFZ07dy722WefT30t6623XrH77rsXr7/+evH6668Xjz32WPGd73ynSFKMHDmyxrZrrLFG0atXr0X2MXv27Ornv/7668WcOXMWea8++dW0adNi7NixnzpfURTF9ddfXyQpfve739VYvs022xTrrLNOsXDhwqIoFv+ejRo1qqhUKsWLL75YveyUU04pPv5X1ylTphRJijFjxizy/CTFKaecUv14xIgRRZcuXYo33nijxnb7779/0bZt2+oZvv71rxebbbbZMr2+j7vtttuKJMU666xTzJ49u3r5FVdcUSQpzjvvvKIoiqKqqqrYaKONigEDBhRVVVXV282dO7fo3r17sdtuuy3yeocMGbJMM6yxxhrFFltsscwz9+/fv+jfv3/14w8++KCYN29ejW3eeuutolOnTsXBBx9cveyoo44q2rRpU3zwwQdL3PcWW2xR4/cQAMDH+Zg2ALDa2XffffPee+/luuuuyzvvvJPrrrtuiWe+XXnllWnbtm122223vPHGG9Vfffr0SatWrWp8jPXj111855138sYbb2T77bfP3Llz85///KfGflu1alXjDMMmTZpk6623zgsvvLBMr+Hmm29Ohw4d0qFDh2y++eb505/+lOHDhy9yBubs2bPTqlWrRZ7/ne98p/r5HTp0yAknnLDINhdeeGEmTpyYiRMn5s9//nN22mmnHHLIIZkwYcKnzrf77runQ4cONT7iPGXKlNx7770ZMmRIGjT48K+hH3/P3n333bzxxhvZdtttUxRFHn744WV6L5amKIpcffXV2XPPPVMURY1jOGDAgMyaNSsPPfRQkg8/hv7yyy/n/vvv/0zf66CDDkrr1q2rH3/zm99Mly5d8n//939JkkceeSTPPvtsvv3tb+fNN9+snuPdd9/NLrvsksmTJ6eqqqrGPr/3ve8t0/eePXt2je+9vBo2bJgmTZok+fCyBDNnzswHH3yQrbbaqvr9ST58j959992lfuS6Xbt2eeKJJ/Lss89+5nkAgPrLx7QBgNVOhw4dsuuuu2bcuHGZO3duFi5cuMSPtz777LOZNWtWOnbsuNj1M2bMqP71E088kZ/85Ce59dZbM3v27BrbzZo1q8bjddddN5VKpcayNdZYI//+97+X6TX07ds3Z5xxRhYuXJjHH388Z5xxRt56663qoPSR1q1bZ86cOYs8//TTT8+RRx6ZJEv86OzWW29d4wY2Q4YMSe/evXPkkUfmq1/96iLf6+MaNWqU/fbbLxdddFFeeeWVrLPOOtVh8qOPaCfJ1KlTc/LJJ+cf//jHItfg/OR79lm8/vrrefvtt3PxxRfn4osvXuw2Hx3DE044Ibfccku23nrr9OjRI7vvvnu+/e1v5ytf+coyfa+NNtqoxuNKpZIePXrkv//9b5JUx7mhQ4cucR+zZs2q8VH77t27L9P3btOmTd55551l2nZJLr300vzyl7/Mf/7znyxYsGCxMxxxxBG54oorMmjQoKyzzjrZfffds++++2bgwIHV25x++un5+te/no033jhf/OIXM3DgwHznO9/Jl770pc81HwBQP4iRAMBq6dvf/nYOPfTQTJ8+PYMGDUq7du0Wu11VVVU6duyYv/zlL4td36FDhyQf3s24f//+adOmTU4//fRsuOGGadasWR566KGccMIJi5zx1rBhw8Xur1jKdQE/bq211squu+6aJBkwYEB69uyZr371qznvvPNy7LHHVm/Xs2fPPProo1mwYEH1tS2TfKYw1KBBg+y0004577zz8uyzz2azzTZb6vYHHnhgLrjgglx++eU57rjjcvnll2fTTTetvv7gwoULs9tuu2XmzJk54YQT0rNnz7Rs2TKvvPJKhg0btsh79nGfDLkf+eTNgj7ax4EHHrjECPjRe7HJJpvk6aefznXXXZcbb7wxV199dS666KKcfPLJOe2005b6WpfFR7Occ8451e/BJ33yLNbF3eV8cXr27JlHHnkk8+fPX2okXpI///nPGTZsWL7xjW/khz/8YTp27JiGDRtm1KhRNW6K1LFjxzzyyCO56aabcsMNN+SGG27ImDFjctBBB+XSSy9Nkuywww55/vnn8/e//z0333xz/vCHP+RXv/pVRo8enUMOOWS5ZwMA6hcxEgBYLe2111457LDDcu+99+avf/3rErfbcMMNc8stt+QrX/nKUsPQ7bffnjfffDMTJkzIDjvsUL18ypQptTr3kgwePDj9+/fPWWedlcMOOywtW7ZMknz1q1/Nvffem2uuuSb77rvv5/4+H3zwQZIs9mzLT+rbt2823HDDjBs3LrvttlueeOKJnHnmmdXrH3vssTzzzDO59NJLc9BBB1UvX5a7Ln909uDbb79dY/mLL75Y43GHDh3SunXrLFy4sDreLk3Lli2z3377Zb/99sv8+fOz995758wzz8yJJ56YZs2aLfW5n/xYclEUee6556pj54Ybbpjkw7MYl2WW5bHnnnvmnnvuydVXX50hQ4Ys9/OvuuqqbLDBBpkwYUKN0HvKKacssm2TJk2y5557Zs8990xVVVWOOOKI/O53v8tPf/rT9OjRI0nSvn37DB8+PMOHD8+cOXOyww475NRTTxUjAYC4ZiQAsFpq1apVfvvb3+bUU0/NnnvuucTt9t133yxcuDA/+9nPFln3wQcfVMewj850/PiZjfPnz89FF11Uu4MvxQknnJA333wzv//976uXHX744enUqVOOOeaYPPPMM4s8Z1nPxEySBQsW5Oabb06TJk2yySabLNNzDjjggDz88MM55ZRTUqlUalybc3HvWVEUOe+88z51v23atMlaa62VyZMn11j+yfe7YcOG2WeffXL11Vfn8ccfX2Q/r7/+evWv33zzzRrrmjRpkk033TRFUdT42PKSXHbZZTU+Kn3VVVdl2rRp1XdH79OnTzbccMOce+65i425H59leX3ve99Lly5d8j//8z+LPc4zZszIGWecscTnL+5Y3HfffbnnnntqbPfJ96hBgwbVsXXevHmL3aZVq1bp0aNH9XoAYPXmzEgAYLW1tGv3faR///457LDDMmrUqDzyyCPZfffd07hx4zz77LO58sorc9555+Wb3/xmtt1226yxxhoZOnRofvCDH6RSqeRPf/rTcsW+z2vQoEH54he/mP/93//NyJEj07hx47Rv3z7XXHNN9txzz2yxxRbZf//98+UvfzmNGzfOSy+9lCuvvDJJ0q1bt0X2d8MNN1TfeGfGjBkZN25cnn322fzoRz9KmzZtlmmmAw88MKeffnr+/ve/5ytf+UrWX3/96nU9e/bMhhtumOOOOy6vvPJK2rRpk6uvvnqRa0cuySGHHJKf//znOeSQQ7LVVltl8uTJiw1xP//5z3Pbbbelb9++OfTQQ7Pppptm5syZeeihh3LLLbdk5syZST686U7nzp3zla98JZ06dcpTTz2VCy64IIMHD16mm8O0b98+2223XYYPH57XXnstv/71r9OjR48ceuihST4Md3/4wx8yaNCgbLbZZhk+fHjWWWedvPLKK7ntttvSpk2bXHvttcv02j9pjTXWyDXXXJM99tgjvXr1yoEHHpg+ffokSR566KFcfvnl6dev3xKf/9WvfjUTJkzIXnvtlcGDB2fKlCkZPXp0Nt100xrh9JBDDsnMmTOz8847Z911182LL76Y3/zmN+nVq1d1oN50002z4447pk+fPmnfvn0eeOCBXHXVVdXXKAUAVnN1cxNvAIByjRkzpkhS3H///Uvdbr311isGDx68yPKLL7646NOnT9G8efOidevWxeabb14cf/zxxauvvlq9zd13311ss802RfPmzYu11167OP7444ubbrqpSFLcdttt1dv179+/2GyzzRb5HkOHDi3WW2+9T30tS5qxKIpi7NixRZJizJgxNZZPmzat+OEPf1hsuummRfPmzYumTZsWG2ywQXHQQQcVkydPrrHtR+/Vx7+aNWtW9OrVq/jtb39bVFVVfeqMH/flL3+5SFJcdNFFi6x78skni1133bVo1apVsdZaaxWHHnpo8eijjy7yGk455ZTik391nTt3bjFixIiibdu2RevWrYt99923mDFjRpGkOOWUU2ps+9prrxUjR44sunbtWjRu3Ljo3LlzscsuuxQXX3xx9Ta/+93vih122KFYc801i6ZNmxYbbrhh8cMf/rCYNWvWUl/fbbfdViQpLr/88uLEE08sOnbsWDRv3rwYPHhw8eKLLy6y/cMPP1zsvffe1d9nvfXWK/bdd99i0qRJi7ze119/fanf+5NeffXV4phjjik23njjolmzZkWLFi2KPn36FGeeeWaN19G/f/+if//+1Y+rqqqKs846q1hvvfWKpk2bFr179y6uu+66RX4mr7rqqmL33XcvOnbsWDRp0qTo1q1bcdhhhxXTpk2r3uaMM84ott5666Jdu3ZF8+bNi549exZnnnlmMX/+/OV6LQBA/VQpihL/uR4AAOqZ22+/PTvttFOuvPLKJd6VHQCAD7lmJAAAAABQCjESAAAAACiFGAkAAAAAlMI1IwEAAACAUjgzEgAAAAAohRgJAAAAAJSiUV0PsDKoqqrKq6++mtatW6dSqdT1OAAAAACwSimKIu+8807WXnvtNGiw5PMfxcgkr776arp27VrXYwAAAADAKu2ll17Kuuuuu8T1YmSS1q1bJ/nwzWrTpk0dTwMAAAAAq5bZs2ena9eu1Z1tScTIpPqj2W3atBEjAQAAAOAz+rRLILqBDQAAAABQCjESAAAAACiFGAkAAAAAlMI1IwEAAABYRFEU+eCDD7Jw4cK6HoWVQMOGDdOoUaNPvSbkpxEjAQAAAKhh/vz5mTZtWubOnVvXo7ASadGiRbp06ZImTZp85n2IkQAAAABUq6qqypQpU9KwYcOsvfbaadKkyec+G45VW1EUmT9/fl5//fVMmTIlG220URo0+GxXfxQjAQAAAKg2f/78VFVVpWvXrmnRokVdj8NKonnz5mncuHFefPHFzJ8/P82aNftM+3EDGwAAAAAW8VnPfKP+qo2fCT9VAAAAAEApxEgAAAAAoBRiJAAAAADLplIp94vlVqlU8re//a2ux1giMRIAAACAemHYsGGpVCr53ve+t8i6kSNHplKpZNiwYeUP9gljx45NpVJJpVJJgwYN0qVLl+y3336ZOnVqXY+2womRAAAAANQbXbt2zfjx4/Pee+9VL3v//fczbty4dOvWrQ4nq6lNmzaZNm1aXnnllVx99dV5+umn861vfauux1rhxEgAAAAA6o0tt9wyXbt2zYQJE6qXTZgwId26dUvv3r1rbFtVVZVRo0ale/fuad68ebbYYotcddVV1esXLlyYESNGVK//whe+kPPOO6/GPoYNG5ZvfOMbOffcc9OlS5esueaaGTlyZBYsWLDUOSuVSjp37pwuXbpk2223zYgRI/Kvf/0rs2fPrt7m73//e7bccss0a9YsG2ywQU477bR88MEH1eufffbZ7LDDDmnWrFk23XTTTJw48TO9Z2VqVNcDAAAAAEBtOvjggzNmzJgccMABSZJLLrkkw4cPz+23315ju1GjRuXPf/5zRo8enY022iiTJ0/OgQcemA4dOqR///6pqqrKuuuumyuvvDJrrrlm/vnPf+a73/1uunTpkn333bd6P7fddlu6dOmS2267Lc8991z222+/9OrVK4ceeugyzTtjxoxcc801adiwYRo2bJgkufPOO3PQQQfl/PPPz/bbb5/nn38+3/3ud5Mkp5xySqqqqrL33nunU6dOue+++zJr1qwcffTRn//NW8HESAAAAADqlQMPPDAnnnhiXnzxxSTJ3XffnfHjx9eIkfPmzctZZ52VW265Jf369UuSbLDBBrnrrrvyu9/9Lv3790/jxo1z2mmnVT+ne/fuueeee3LFFVfUiJFrrLFGLrjggjRs2DA9e/bM4MGDM2nSpKXGyFmzZqVVq1YpiiJz585NkvzgBz9Iy5YtkySnnXZafvSjH2Xo0KHVs/3sZz/L8ccfn1NOOSW33HJL/vOf/+Smm27K2muvnSQ566yzMmjQoFp4B1ccMRIAAACAeqVDhw4ZPHhwxo4dm6IoMnjw4Ky11lo1tnnuuecyd+7c7LbbbjWWz58/v8bHuS+88MJccsklmTp1at57773Mnz8/vXr1qvGczTbbrPqMxiTp0qVLHnvssaXO2Lp16zz00ENZsGBBbrjhhvzlL3/JmWeeWb3+0Ucfzd13311j2cKFC/P+++9n7ty5eeqpp9K1a9fqEJmkOqquzMRIAAAAAOqdgw8+OEceeWSSD4PiJ82ZMydJcv3112edddapsa5p06ZJkvHjx+e4447LL3/5y/Tr1y+tW7fOOeeck/vuu6/G9o0bN67xuFKppKqqaqnzNWjQID169EiSbLLJJnn++edz+OGH509/+lP1fKeddlr23nvvRZ7brFmzpe57ZSZGAgAAAFDvDBw4MPPnz0+lUsmAAQMWWb/pppumadOmmTp1avr377/Yfdx9993Zdtttc8QRR1Qve/7551fIvD/60Y+y4YYb5phjjsmWW26ZLbfcMk8//XR1sPykTTbZJC+99FKmTZuWLl26JEnuvffeFTJbbRIjAQAAAKh3GjZsmKeeeqr615/UunXrHHfccTnmmGNSVVWV7bbbLrNmzcrdd9+dNm3aZOjQodloo41y2WWX5aabbkr37t3zpz/9Kffff3+6d+9e6/N27do1e+21V04++eRcd911Ofnkk/PVr3413bp1yze/+c00aNAgjz76aB5//PGcccYZ2XXXXbPxxhtn6NChOeecczJ79uycdNJJtT5XbWtQ1wMAAAAAsIooinK/Pqc2bdqkTZs2S1z/s5/9LD/96U8zatSobLLJJhk4cGCuv/766th42GGHZe+9985+++2Xvn375s0336xxlmRtO+aYY3L99dfnX//6VwYMGJDrrrsuN998c7785S9nm222ya9+9aust956ST78mPc111yT9957L1tvvXUOOeSQGteXXFlViqIWjuwqbvbs2Wnbtm1mzZq11B9QAAAAgPru/fffz5QpU9K9e/dV+tqE1L6l/Wwsa19zZiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUIpGdT0AAAAAAKuGymmVUr9fcUpR6vdjxXNmJAAAAAD1wrBhw1KpVPK9731vkXUjR45MpVLJsGHDyh9sMebPn59zzjknW265ZVq2bJm2bdtmiy22yE9+8pO8+uqrdT3eCiNGAqzmKpXa/wIAAKgrXbt2zfjx4/Pee+9VL3v//fczbty4dOvWrQ4n+3/mzZuX3XbbLWeddVaGDRuWyZMn57HHHsv555+fN954I7/5zW+W+Nz58+eXOGntEyMBAAAAqDe23HLLdO3aNRMmTKheNmHChHTr1i29e/eusW1VVVVGjRqV7t27p3nz5tliiy1y1VVXVa9fuHBhRowYUb3+C1/4Qs4777wa+xg2bFi+8Y1v5Nxzz02XLl2y5pprZuTIkVmwYMESZ/zVr36Vu+66K7feemt+8IMfpE+fPunWrVv69++f0aNH56yzzqredscdd8yRRx6Zo48+OmuttVYGDBiQJHn88cczaNCgtGrVKp06dcp3vvOdvPHGG8v82m6//fZUKpVMmjQpW221VVq0aJFtt902Tz/99HK+48tHjAQAAACgXjn44IMzZsyY6seXXHJJhg8fvsh2o0aNymWXXZbRo0fniSeeyDHHHJMDDzwwd9xxR5IPg966666bK6+8Mk8++WROPvnk/PjHP84VV1xRYz+33XZbnn/++dx222259NJLM3bs2IwdO3aJ811++eXZbbfdFomjH6l84iNnl156aZo0aZK77747o0ePzttvv52dd945vXv3zgMPPJAbb7wxr732Wvbdd99lfm0fOemkk/LLX/4yDzzwQBo1apSDDz54iXPXhkpRFKv9lUBnz56dtm3bZtasWWnTpk1djwNQqhXxsWp/sgAAwKrr/fffz5QpU9K9e/c0a9asxrqV/QY2w4YNy9tvv53f//736dq1a/VZfj179sxLL72UQw45JO3atcvYsWMzb968tG/fPrfcckv69etXvY9DDjkkc+fOzbhx4xb7PY488shMnz69+izDYcOG5fbbb8/zzz+fhg0bJkn23XffNGjQIOPHj1/sPpo3b57vfve7Nc6y3GuvvTJx4sQkyZe+9KX885//TPLhmZGzZ8/OQw89VL3tGWeckTvvvDM33XRT9bKXX365+jWvt956n/rabr/99uy000655ZZbsssuuyRJ/u///i+DBw/Oe++9t8ixT5b+s7Gsfc3dtAFWISvmD37lEAAAqF86dOiQwYMHZ+zYsSmKIoMHD85aa61VY5vnnnsuc+fOzW677VZj+fz582ucsXjhhRfmkksuydSpU/Pee+9l/vz56dWrV43nbLbZZtUhMkm6dOmSxx57bLlmvuiii/Luu+/m/PPPz+TJk2us69OnT43Hjz76aG677ba0atVqkf08//zzWbBgwTK9tuTD8PnxuZNkxowZK+z6mmIkAAAAAPXOwQcfnCOPPDLJh0Hxk+bMmZMkuf7667POOuvUWNe0adMkyfjx43Pcccfll7/8Zfr165fWrVvnnHPOyX333Vdj+8aNG9d4XKlUUlVVtcTZNtpoo0WuzfhRCGzfvv0i27ds2XKR2ffcc8/84he/WGTbLl265PHHH//U17a42T/6ePjSZv+8xEgAAAAA6p2BAwdm/vz5qVQq1Td9+bhNN900TZs2zdSpU9O/f//F7uPuu+/OtttumyOOOKJ62fPPP/+5ZxsyZEh+8pOf5OGHH17idSOXZsstt8zVV1+d9ddfP40aLZr3luW11RUxEgAAPk0tX2C3cmqt7u5Dp9b+ZTdcAxiAVVnDhg3z1FNPVf/6k1q3bp3jjjsuxxxzTKqqqrLddttl1qxZufvuu9OmTZsMHTo0G220US677LLcdNNN6d69e/70pz/l/vvvT/fu3T/XbMccc0yuv/767LLLLjnllFOy/fbbZ4011sgzzzyTG264YbHzftzIkSPz+9//PkOGDMnxxx+f9u3b57nnnsv48ePzhz/8YZleW10RIwEAAABYJst7Q5m69mk3Kv7Zz36WDh06ZNSoUXnhhRfSrl27bLnllvnxj3+cJDnssMPy8MMPZ7/99kulUsmQIUNyxBFH5IYbbvhcczVr1iyTJk3Kr3/964wZMyYnnnhiqqqq0r179wwaNCjHHHPMUp+/9tpr5+67784JJ5yQ3XffPfPmzct6662XgQMHpkGDBsv02uqKu2nH3bSBVccKuYGNM2kAPp0zIwFYjSztjsms3mrjbtoNVvSQAAAAAACJGAkAAAAAlESMBAAAAABKIUYCrEiVSu1+AQAAwCpMjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKRrV9QCk9m9KURS1u7+smPtmrIAxAQAAAFiJiZH1UOW0FXHHXeUQAAAAVncr4mSlpVndT2Raf/31c/TRR+foo4+u61FqjRgJAPBZ1PLfxCun1uruPnRq7f/tfXX/HwIAYOU2bNiwXHrppTnssMMyevToGutGjhyZiy66KEOHDs3YsWPrZsD/39ixYzN8+PDqxy1btswXvvCFnHTSSdl7773rcLIVzzUjAQAAAKg3unbtmvHjx+e9996rXvb+++9n3Lhx6datWx1OVlObNm0ybdq0TJs2LQ8//HAGDBiQfffdN08//XRdj7ZCiZEAAAAA1BtbbrllunbtmgkTJlQvmzBhQrp165bevXvX2LaqqiqjRo1K9+7d07x582yxxRa56qqrqtcvXLgwI0aMqF7/hS98Ieedd16NfQwbNizf+MY3cu6556ZLly5Zc801M3LkyCxYsGCpc1YqlXTu3DmdO3fORhttlDPOOCMNGjTIv//978Vu/9///jeVSiWPPPJI9bK33347lUolt99+e/Wyxx9/PIMGDUqrVq3SqVOnfOc738kbb7zxaW9bacRIAAAAAOqVgw8+OGPGjKl+fMkll9T4WPRHRo0alcsuuyyjR4/OE088kWOOOSYHHnhg7rjjjiQfxsp11103V155ZZ588smcfPLJ+fGPf5wrrriixn5uu+22PP/887ntttty6aWXZuzYscv1UfCFCxfm0ksvTfJhTP2s3n777ey8887p3bt3Hnjggdx444157bXXsu+++37mfdY214wEAAAAoF458MADc+KJJ+bFF19Mktx9990ZP358jTMI582bl7POOiu33HJL+vXrlyTZYIMNctddd+V3v/td+vfvn8aNG+e0006rfk737t1zzz335IorrqgR+NZYY41ccMEFadiwYXr27JnBgwdn0qRJOfTQQ5c446xZs9KqVaskyXvvvZfGjRvn4osvzoYbbviZX/cFF1yQ3r1756yzzqpedskll6Rr16555plnsvHGG3/mfdcWMRIAaktt31rQnUIAAOAz6dChQwYPHpyxY8emKIoMHjw4a621Vo1tnnvuucydOze77bZbjeXz58+v8XHuCy+8MJdcckmmTp2a9957L/Pnz0+vXr1qPGezzTZLw4YNqx936dIljz322FJnbN26dR566KEkydy5c3PLLbfke9/7XtZcc83sueeen+Vl59FHH81tt91WHTk/7vnnnxcjAYAlq5xWy3EzSXGKwAkAwOrh4IMPzpFHHpnkw6D4SXPmzEmSXH/99VlnnXVqrGvatGmSZPz48TnuuOPyy1/+Mv369Uvr1q1zzjnn5L777quxfePGjWs8rlQqqaqqWup8DRo0SI8ePaoff+lLX8rNN9+cX/ziF4uNkQ0afHi1xeJjJy188rqUc+bMyZ577plf/OIXizy/S5cuS52nLGIkAAAAAPXOwIEDM3/+/FQqlQwYMGCR9ZtuummaNm2aqVOnpn///ovdx913351tt902RxxxRPWy559/foXN3LBhwxp3Af+4Dh06JEmmTZtWfebmx29mk3x4vcmrr74666+/fho1Wjmz38o5FQCwQtT2J8kTnyYHAGDl1LBhwzz11FPVv/6k1q1b57jjjssxxxyTqqqqbLfddpk1a1buvvvutGnTJkOHDs1GG22Uyy67LDfddFO6d++eP/3pT7n//vvTvXv3zz1fURSZPn16kg+vGTlx4sTcdNNNOfnkkxe7ffPmzbPNNtvk5z//ebp3754ZM2bkJz/5SY1tRo4cmd///vcZMmRIjj/++LRv3z7PPfdcxo8fnz/84Q+LfR/KJkYCAAAAsExWtX+IbtOmzVLX/+xnP0uHDh0yatSovPDCC2nXrl223HLL/PjHP06SHHbYYXn44Yez3377pVKpZMiQITniiCNyww03fO7ZZs+eXf3R6aZNm2a99dbL6aefnhNOOGGJz7nkkksyYsSI9OnTJ1/4whdy9tlnZ/fdd69ev/baa+fuu+/OCSeckN133z3z5s3Leuutl4EDB1Z/zLuuVYpiVfsxqn2zZ89O27ZtM2vWrE/9IV0havk0lcqptbq7D51a+z8mfvJYLfj9vXpxvFcvjvfqxfEGYDXy/vvvZ8qUKenevXuaNWtW1+OwElnaz8ay9rWVI4kCAAAAAPWeGAkAAAAAlEKMBAAAAABKIUYCAAAAAKVwN20AAABg9eCGZMv5PHcyo6ba+JlwZiQAAAAA1Ro3bpwkmTt3bh1Pwsrmo5+Jj35GPgtnRgIAAABQrWHDhmnXrl1mzJiRJGnRokUqtXxWKauWoigyd+7czJgxI+3atUvDhg0/877ESAAAAABq6Ny5c5JUB0lIknbt2lX/bHxWYiQAAAAANVQqlXTp0iUdO3bMggUL6nocVgKNGzf+XGdEfkSMBAAAAGCxGjZsWCsBCj7iBjYAAAAAQCnESAAAAACgFGIkAAAAAFAK14wEAABg9VWp1O7+iqJ29wdQz4iRAAAAUEsqp9Vy3EySU2s/cGqmQF3xMW0AAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABK4W7aAAAAANQ/lVq+u73b0NcKMRIAAAAAPkXltFqOm0mKU1a/wClGAgAAAEAdqO2TN5OV/wRO14wEAAAAAEohRgIAAAAApRAjAQAAAIBSiJEAAAAAQCncwAbKVstXp62cWqu7+9CptX+125X9AroAAADAiidGAgAAfNwq8I/HxSn+pReAVZOPaQMAAAAApXBmJAAAwCqmlk/eTOKyOgCUw5mRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBR1GiNHjRqVL3/5y2ndunU6duyYb3zjG3n66adrbPP+++9n5MiRWXPNNdOqVavss88+ee2112psM3Xq1AwePDgtWrRIx44d88Mf/jAffPBBmS8FAAAAAPgUdRoj77jjjowcOTL33ntvJk6cmAULFmT33XfPu+++W73NMccck2uvvTZXXnll7rjjjrz66qvZe++9q9cvXLgwgwcPzvz58/PPf/4zl156acaOHZuTTz65Ll4SAAAAALAEjerym9944401Ho8dOzYdO3bMgw8+mB122CGzZs3KH//4x4wbNy4777xzkmTMmDHZZJNNcu+992abbbbJzTffnCeffDK33HJLOnXqlF69euVnP/tZTjjhhJx66qlp0qRJXbw0AAAAAOATVqprRs6aNStJ0r59+yTJgw8+mAULFmTXXXet3qZnz57p1q1b7rnnniTJPffck8033zydOnWq3mbAgAGZPXt2nnjiicV+n3nz5mX27Nk1vgAAAACAFWuliZFVVVU5+uij85WvfCVf/OIXkyTTp09PkyZN0q5duxrbdurUKdOnT6/e5uMh8qP1H61bnFGjRqVt27bVX127dq3lVwMAAAAAfNJKEyNHjhyZxx9/POPHj1/h3+vEE0/MrFmzqr9eeumlFf49AQAAAGB1V6fXjPzIkUcemeuuuy6TJ0/OuuuuW728c+fOmT9/ft5+++0aZ0e+9tpr6dy5c/U2//rXv2rs76O7bX+0zSc1bdo0TZs2reVXAQAAAAAsTZ2eGVkURY488shcc801ufXWW9O9e/ca6/v06ZPGjRtn0qRJ1cuefvrpTJ06Nf369UuS9OvXL4899lhmzJhRvc3EiRPTpk2bbLrppuW8EAAAAADgU9XpmZEjR47MuHHj8ve//z2tW7euvsZj27Zt07x587Rt2zYjRozIsccem/bt26dNmzb5/ve/n379+mWbbbZJkuy+++7ZdNNN853vfCdnn312pk+fnp/85CcZOXKksx8BAAAAYCVSpzHyt7/9bZJkxx13rLF8zJgxGTZsWJLkV7/6VRo0aJB99tkn8+bNy4ABA3LRRRdVb9uwYcNcd911Ofzww9OvX7+0bNkyQ4cOzemnn17WywAAAAAAlkGdxsiiKD51m2bNmuXCCy/MhRdeuMRt1ltvvfzf//1fbY4GAAAAANSyleZu2gAAAABA/SZGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAoRZ3GyMmTJ2fPPffM2muvnUqlkr/97W811g8bNiyVSqXG18CBA2tsM3PmzBxwwAFp06ZN2rVrlxEjRmTOnDklvgoAAAAAYFnUaYx89913s8UWW+TCCy9c4jYDBw7MtGnTqr8uv/zyGusPOOCAPPHEE5k4cWKuu+66TJ48Od/97ndX9OgAAAAAwHJqVJfffNCgQRk0aNBSt2natGk6d+682HVPPfVUbrzxxtx///3ZaqutkiS/+c1vsscee+Tcc8/N2muvXeszAwAAAACfzUp/zcjbb789HTt2zBe+8IUcfvjhefPNN6vX3XPPPWnXrl11iEySXXfdNQ0aNMh99923xH3Omzcvs2fPrvEFAAAAAKxYK3WMHDhwYC677LJMmjQpv/jFL3LHHXdk0KBBWbhwYZJk+vTp6dixY43nNGrUKO3bt8/06dOXuN9Ro0albdu21V9du3Zdoa8DAAAAAKjjj2l/mv3337/615tvvnm+9KUvZcMNN8ztt9+eXXbZ5TPv98QTT8yxxx5b/Xj27NmCJAAAAACsYCv1mZGftMEGG2SttdbKc889lyTp3LlzZsyYUWObDz74IDNnzlzidSaTD69D2aZNmxpfAAAAAMCKtUrFyJdffjlvvvlmunTpkiTp169f3n777Tz44IPV29x6662pqqpK375962pMAAAAAGAx6vRj2nPmzKk+yzFJpkyZkkceeSTt27dP+/btc9ppp2WfffZJ586d8/zzz+f4449Pjx49MmDAgCTJJptskoEDB+bQQw/N6NGjs2DBghx55JHZf//93UkbAAAAAFYydXpm5AMPPJDevXund+/eSZJjjz02vXv3zsknn5yGDRvm3//+d772ta9l4403zogRI9KnT5/ceeedadq0afU+/vKXv6Rnz57ZZZddsscee2S77bbLxRdfXFcvCQAAAABYgjo9M3LHHXdMURRLXH/TTTd96j7at2+fcePG1eZYAAAAAMAKsEpdMxIAAAAAWHWJkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAACl+Fwx8v3336+tOQAAAACAem65Y2RVVVV+9rOfZZ111kmrVq3ywgsvJEl++tOf5o9//GOtDwgAAAAA1A/LHSPPOOOMjB07NmeffXaaNGlSvfyLX/xi/vCHP9TqcAAAAABA/bHcMfKyyy7LxRdfnAMOOCANGzasXr7FFlvkP//5T60OBwAAAADUH8sdI1955ZX06NFjkeVVVVVZsGBBrQwFAAAAANQ/yx0jN91009x5552LLL/qqqvSu3fvWhkKAAAAAKh/Gi3vE04++eQMHTo0r7zySqqqqjJhwoQ8/fTTueyyy3LdddetiBkBAAAAgHpguc+M/PrXv55rr702t9xyS1q2bJmTTz45Tz31VK699trstttuK2JGAAAAAKAeWO4zI5Nk++23z8SJE2t7FgAAAACgHlvuMyMBAAAAAD6L5T4zskGDBqlUKktcv3Dhws81EAAAAABQPy13jLzmmmtqPF6wYEEefvjhXHrppTnttNNqbTAAAAAAoH5Z7hj59a9/fZFl3/zmN7PZZpvlr3/9a0aMGFErgwEAAAAA9UutXTNym222yaRJk2prdwAAAABAPVMrMfK9997L+eefn3XWWac2dgcAAAAA1EPL/THtNdZYo8YNbIqiyDvvvJMWLVrkz3/+c60OBwAAAADUH8sdI3/1q1/ViJENGjRIhw4d0rdv36yxxhq1OhwAAAAAUH8sd4wcNmzYChgDAAAAAKjvlilG/vvf/17mHX7pS1/6zMMAAAAAAPXXMsXIXr16pVKppCiKpW5XqVSycOHCWhkMAAAAAKhflilGTpkyZUXPAQAAAADUc8sUI9dbb70VPQcAAAAAUM8t9w1sPvLkk09m6tSpmT9/fo3lX/va1z73UAAAAABA/bPcMfKFF17IXnvtlccee6zGdSQrlUqSuGYkAAAAALBYDZb3CUcddVS6d++eGTNmpEWLFnniiScyefLkbLXVVrn99ttXwIgAAAAAQH2w3GdG3nPPPbn11luz1lprpUGDBmnQoEG22267jBo1Kj/4wQ/y8MMPr4g5AQAAAIBV3HKfGblw4cK0bt06SbLWWmvl1VdfTfLhTW6efvrp2p0OAAAAAKg3lvvMyC9+8Yt59NFH07179/Tt2zdnn312mjRpkosvvjgbbLDBipgRAAAAAKgHljtG/uQnP8m7776bJDn99NPz1a9+Ndtvv33WXHPN/PWvf631AQEAAACA+mGZY+RWW22VQw45JN/+9rfTpk2bJEmPHj3yn//8JzNnzswaa6xRfUdtAAAAAIBPWuZrRm6xxRY5/vjj06VLlxx00EE17pzdvn17IRIAAAAAWKpljpF//OMfM3369Fx44YWZOnVqdtlll/To0SNnnXVWXnnllRU5IwAAAABQDyzX3bRbtGiRYcOG5fbbb88zzzyT/fffP7/73e+y/vrrZ/DgwZkwYcKKmhMAAAAAWMUtV4z8uA033DBnnHFG/vvf/+byyy/Pvffem29961u1ORsAAAAAUI8s9920P+7222/PmDFjcvXVV6dRo0Y59NBDa2suAAAAAKCeWe4Y+fLLL2fs2LEZO3ZsXnjhhWy//fa56KKL8q1vfSvNmzdfETMCAAAAAPXAMsfIK664IpdcckkmTZqUjh07ZujQoTn44IPTo0ePFTkfAAAAAFBPLHOMPPDAAzN48OBcc8012WOPPdKgwWe+3CQAAAAAsBpa5hj58ssvp2PHjityFgAAAACgHlvm0xuFSAAAAADg8/BZawAAAACgFGIkAAAAAFAKMRIAAAAAKMXnjpEvvPBCnnjiiVRVVdXGPAAAAABAPbXMMXLBggU55ZRTsueee+bMM8/MwoULM2TIkGy00Ub50pe+lC9+8Yv573//uwJHBQAAAABWZcscI3/0ox/lt7/9bTp37pxLLrkke++9dx5++OGMGzcu48ePT6NGjXLSSSetyFkBAAAAgFVYo2Xd8KqrrsrYsWOzxx575JlnnknPnj1z/fXXZ9CgQUmSjh075oADDlhhgwIAAAAAq7ZlPjPy1VdfzRZbbJEk2XjjjdO0adP06NGjev3GG2+c6dOn1/6EAAAAAEC9sMwxcuHChWncuHH140aNGqVhw4b/b0cNGqQoitqdDgAAAACoN5b5Y9pJctNNN6Vt27ZJkqqqqkyaNCmPP/54kuTtt9+u9eEAAAAAgPpjuWLk0KFDazw+7LDDajyuVCqffyIAAAAAoF5a5hhZVVW1IucAAAAAAOq5Zb5mJAAAAADA57HMZ0YuXLgwTz75ZDbffPMkyejRozN//vzq9Q0bNszhhx+eBg30TQAAAABgUcscI//6179m9OjRmTx5cpLkhz/8Ydq1a5dGjT7cxRtvvJFmzZplxIgRK2ZSAAAAAGCVtsynMY4ZMyYjR46sseyOO+7IlClTMmXKlJxzzjn585//XOsDAgAAAAD1wzLHyP/85z/Zaqutlri+f//+efTRR2tlKAAAAACg/lnmj2m//vrrNR6/8MILWXPNNasfN27cOO+++27tTQYAAAAA1CvLfGZkp06d8vTTT1c/7tChQ42b1Tz11FPp3Llz7U4HAAAAANQbyxwjd9lll5x55pmLXVcURUaNGpVddtml1gYDAAAAAOqXZf6Y9kknnZQtt9wyffv2zXHHHZeNN944SfL000/n3HPPzdNPP53LLrtshQ0KAAAAAKzaljlGbrjhhpk4cWKGDRuW/fbbL5VKJcmHZ0X27NkzN998c3r06LHCBgUAAAAAVm3LHCOTZOutt86TTz6ZRx55JM8880ySZKONNkrv3r1XyHAAAAAAQP2xXDHyI7169UqvXr0WWf7AAw9kq622+rwzAQAAAAD10DLfwOYjc+bMyXvvvVdj2SOPPJI999wzffv2rbXBAAAAAID6ZZlj5EsvvZR+/fqlbdu2adu2bY499tjMnTs3Bx10UPr27ZuWLVvmn//854qcFQAAAABYhS3zx7R/+MMf5v333895552XCRMm5Lzzzsudd96Zvn375vnnn8+66667IucEAAAAAFZxyxwjJ0+enAkTJmSbbbbJvvvum86dO+eAAw7I0UcfvQLHAwAAAADqi2X+mPZrr72W7t27J0k6duyYFi1aZNCgQStsMAAAAACgflmuG9g0aNCgxq+bNGlS6wMBAAAAAPXTMn9MuyiKbLzxxqlUKkk+vKt27969awTKJJk5c2btTggAAAAA1AvLHCPHjBmzIucAAAAAAOq5ZY6RQ4cOXZFzAAAAAAD13HJdMxIAAAAA4LMSIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQimW+m/ZHFi5cmLFjx2bSpEmZMWNGqqqqaqy/9dZba204AAAAAKD+WO4YedRRR2Xs2LEZPHhwvvjFL6ZSqayIuQAAAACAema5Y+T48eNzxRVXZI899lgR8wAAAAAA9dRyXzOySZMm6dGjx4qYBQAAAACox5Y7Rv7P//xPzjvvvBRFsSLmAQAAAADqqeX+mPZdd92V2267LTfccEM222yzNG7cuMb6CRMm1NpwAAAAAED9sdwxsl27dtlrr71WxCwAAAAAQD223DFyzJgxK2IOAAAAAKCeW+5rRgIAAAAAfBbLfWZkklx11VW54oorMnXq1MyfP7/GuoceeqhWBgMAAAAA6pflPjPy/PPPz/Dhw9OpU6c8/PDD2XrrrbPmmmvmhRdeyKBBg1bEjAAAAABAPbDcMfKiiy7KxRdfnN/85jdp0qRJjj/++EycODE/+MEPMmvWrBUxIwAAAABQDyx3jJw6dWq23XbbJEnz5s3zzjvvJEm+853v5PLLL6/d6QAAAACAemO5Y2Tnzp0zc+bMJEm3bt1y7733JkmmTJmSoihqdzoAAAAAoN5Y7hi588475x//+EeSZPjw4TnmmGOy2267Zb/99stee+1V6wMCAAAAAPXDct9N++KLL05VVVWSZOTIkVlzzTXzz3/+M1/72tdy2GGH1fqAAAAAAED9sNwxskGDBmnQ4P+dULn//vtn//33r9WhAAAAAID6Z7k/pp0kd955Zw488MD069cvr7zySpLkT3/6U+66665aHQ4AAAAAqD+WO0ZeffXVGTBgQJo3b56HH3448+bNS5LMmjUrZ511Vq0PCAAAAADUD8sdI88444yMHj06v//979O4cePq5V/5ylfy0EMP1epwAAAAAED9sdwx8umnn84OO+ywyPK2bdvm7bffro2ZAAAAAIB6aLljZOfOnfPcc88tsvyuu+7KBhtsUCtDAQAAAAD1z3LHyEMPPTRHHXVU7rvvvlQqlbz66qv5y1/+kuOOOy6HH374ipgRAAAAAKgHGi3vE370ox+lqqoqu+yyS+bOnZsddtghTZs2zXHHHZfvf//7K2JGAAAAAKAeWO4YWalUctJJJ+WHP/xhnnvuucyZMyebbrppWrVqtSLmAwAAAADqieWOkR9p0qRJNt1009qcBQAAAACox5Y5Rh588MHLtN0ll1zymYcBAAAAAOqvZY6RY8eOzXrrrZfevXunKIoVORMAAAAAUA8tc4w8/PDDc/nll2fKlCkZPnx4DjzwwLRv335FzgYAAAAA1CMNlnXDCy+8MNOmTcvxxx+fa6+9Nl27ds2+++6bm266yZmSAAAAAMCnWuYYmSRNmzbNkCFDMnHixDz55JPZbLPNcsQRR2T99dfPnDlzVtSMAAAAAEA9sFwxssYTGzRIpVJJURRZuHBhbc4EAAAAANRDyxUj582bl8svvzy77bZbNt544zz22GO54IILMnXq1LRq1WpFzQgAAAAA1APLfAObI444IuPHj0/Xrl1z8MEH5/LLL89aa621ImcDAAAAAOqRZY6Ro0ePTrdu3bLBBhvkjjvuyB133LHY7SZMmFBrwwEAAAAA9ccyx8iDDjoolUplRc4CAAAAANRjyxwjx44duwLHAAAAAADqu898N20AAAAAgOUhRgIAAAAApRAjAQAAAIBSiJEAAAAAQCnESAAAAACgFGIkAAAAAFAKMRIAAAAAKIUYCQAAAACUQowEAAAAAEohRgIAAAAApRAjAQAAAIBSiJEAAAAAQCnESAAAAACgFHUaIydPnpw999wza6+9diqVSv72t7/VWF8URU4++eR06dIlzZs3z6677ppnn322xjYzZ87MAQcckDZt2qRdu3YZMWJE5syZU+KrAAAAAACWRZ3GyHfffTdbbLFFLrzwwsWuP/vss3P++edn9OjRue+++9KyZcsMGDAg77//fvU2BxxwQJ544olMnDgx1113XSZPnpzvfve7Zb0EAAAAAGAZNarLbz5o0KAMGjRoseuKosivf/3r/OQnP8nXv/71JMlll12WTp065W9/+1v233//PPXUU7nxxhtz//33Z6uttkqS/OY3v8kee+yRc889N2uvvXZprwUAAAAAWLqV9pqRU6ZMyfTp07PrrrtWL2vbtm369u2be+65J0lyzz33pF27dtUhMkl23XXXNGjQIPfdd98S9z1v3rzMnj27xhcAAAAAsGKttDFy+vTpSZJOnTrVWN6pU6fqddOnT0/Hjh1rrG/UqFHat29fvc3ijBo1Km3btq3+6tq1ay1PDwAAAAB80kobI1ekE088MbNmzar+eumll+p6JAAAAACo91baGNm5c+ckyWuvvVZj+WuvvVa9rnPnzpkxY0aN9R988EFmzpxZvc3iNG3aNG3atKnxBQAAAACsWCttjOzevXs6d+6cSZMmVS+bPXt27rvvvvTr1y9J0q9fv7z99tt58MEHq7e59dZbU1VVlb59+5Y+MwAAAACwZHV6N+05c+bkueeeq348ZcqUPPLII2nfvn26deuWo48+OmeccUY22mijdO/ePT/96U+z9tpr5xvf+EaSZJNNNsnAgQNz6KGHZvTo0VmwYEGOPPLI7L///u6kDQAAAAArmTqNkQ888EB22mmn6sfHHntskmTo0KEZO3Zsjj/++Lz77rv57ne/m7fffjvbbbddbrzxxjRr1qz6OX/5y19y5JFHZpdddkmDBg2yzz775Pzzzy/9tQAAAAAAS1enMXLHHXdMURRLXF+pVHL66afn9NNPX+I27du3z7hx41bEeAAAAABALVpprxkJAAAAANQvYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxEgAAAAAohRgJAAAAAJRCjAQAAAAASiFGAgAAAAClECMBAAAAgFKs1DHy1FNPTaVSqfHVs2fP6vXvv/9+Ro4cmTXXXDOtWrXKPvvsk9dee60OJwYAAAAAlmSljpFJstlmm2XatGnVX3fddVf1umOOOSbXXnttrrzyytxxxx159dVXs/fee9fhtAAAAADAkjSq6wE+TaNGjdK5c+dFls+aNSt//OMfM27cuOy8885JkjFjxmSTTTbJvffem2222absUQEAAACApVjpz4x89tlns/baa2eDDTbIAQcckKlTpyZJHnzwwSxYsCC77rpr9bY9e/ZMt27dcs899yx1n/Pmzcvs2bNrfAEAAAAAK9ZKHSP79u2bsWPH5sYbb8xvf/vbTJkyJdtvv33eeeedTJ8+PU2aNEm7du1qPKdTp06ZPn36Uvc7atSotG3btvqra9euK/BVAAAAAADJSv4x7UGDBlX/+ktf+lL69u2b9dZbL1dccUWaN2/+mfd74okn5thjj61+PHv2bEESAAAAAFawlfrMyE9q165dNt544zz33HPp3Llz5s+fn7fffrvGNq+99tpirzH5cU2bNk2bNm1qfAEAAAAAK9YqFSPnzJmT559/Pl26dEmfPn3SuHHjTJo0qXr9008/nalTp6Zfv351OCUAAAAAsDgr9ce0jzvuuOy5555Zb7318uqrr+aUU05Jw4YNM2TIkLRt2zYjRozIsccem/bt26dNmzb5/ve/n379+rmTNgAAAACshFbqGPnyyy9nyJAhefPNN9OhQ4dst912uffee9OhQ4ckya9+9as0aNAg++yzT+bNm5cBAwbkoosuquOpAQAAAIDFWalj5Pjx45e6vlmzZrnwwgtz4YUXljQRAAAAAPBZrVLXjAQAAAAAVl1iJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEApxEgAAAAAoBRiJAAAAABQCjESAAAAACiFGAkAAAAAlEKMBAAAAABKIUYCAAAAAKUQIwEAAACAUoiRAAAAAEAp6k2MvPDCC7P++uunWbNm6du3b/71r3/V9UgAAAAAwMfUixj517/+Nccee2xOOeWUPPTQQ9liiy0yYMCAzJgxo65HAwAAAAD+f/UiRv7v//5vDj300AwfPjybbrppRo8enRYtWuSSSy6p69EAAAAAgP9fo7oe4POaP39+HnzwwZx44onVyxo0aJBdd90199xzz2KfM2/evMybN6/68axZs5Iks2fPXrHDluX9FbHT2n9v6svbXecc79WL4716cbxXL4736sXxXr043qsXx3v14nivXhzvT/m+H37joiiWul2l+LQtVnKvvvpq1llnnfzzn/9Mv379qpcff/zxueOOO3Lfffct8pxTTz01p512WpljAgAAAEC999JLL2Xddddd4vpV/szIz+LEE0/MscceW/24qqoqM2fOzJprrplKpVKHk5Vr9uzZ6dq1a1566aW0adOmrsdhBXO8Vy+O9+rF8V69ON6rF8d79eJ4r14c79WL4716WV2Pd1EUeeedd7L22msvdbtVPkautdZaadiwYV577bUay1977bV07tx5sc9p2rRpmjZtWmNZu3btVtSIK702bdqsVr85VneO9+rF8V69ON6rF8d79eJ4r14c79WL4716cbxXL6vj8W7btu2nbrPK38CmSZMm6dOnTyZNmlS9rKqqKpMmTarxsW0AAAAAoG6t8mdGJsmxxx6boUOHZquttsrWW2+dX//613n33XczfPjwuh4NAAAAAPj/1YsYud9+++X111/PySefnOnTp6dXr1658cYb06lTp7oebaXWtGnTnHLKKYt8ZJ36yfFevTjeqxfHe/XieK9eHO/Vi+O9enG8Vy+O9+rF8V66Vf5u2gAAAADAqmGVv2YkAAAAALBqECMBAAAAgFKIkQAAAABAKcRIAAAAAKAUYiQAAAAAUAoxkhWmqqqqrkcAAAAAYCUiRlLrpk2bltmzZ6dBAz9eq5uiKOp6BABqgX9QXL043qsPf1db/SxcuLCuR6BEfo+zqlCLqFVPPfVUtt9++/z2t79N4i+39d3MmTPz1FNP5cUXX8x7772XSqXimNdjDz74YI488si6HoOSfPDBB0n8pXZ1MWXKlPz2t7/Nj370ozz55JNp0KCB/57XY4736uXBBx/MT3/60yRJpVKp42lY0aZOnZpx48bl/PPPz7Rp09KwYUNBsh6bPXt2Xnnllbz11luZP3++/x+r59555528/PLLeeutt1b539diJLXmkUceSZ8+ffLf//43N998c5I4O7Ie+/e//53+/ftn8ODB2XnnnTNo0KA8++yzjnk99eijj+YrX/mK47uaeOaZZ3L44Yfn2WefTaVSESTrucceeyzbb799Lr/88lxzzTXp169fnn76ab/f6ynHe/Xy0Z/f77zzTl2PQgkee+yx7LDDDvnVr36Vc889N717985rr72Whg0b1vVorACPPfZYdttttwwYMCC77rprhgwZkldeecV/z+upJ554Il/72tey6667Zuedd87vf//7VTpI+imlVnz0F52TTjopTz31VB588MFcdtlldT0WK8grr7ySQYMGZY899shVV12V008/Pc2aNctWW21VHaKpPz76/f2DH/wg559//mK38S+w9ccLL7yQnXfeOVdddVVOPfXUPPfcc4JkPfbqq69mr732ymGHHZabbropjzzySDbZZJP861//quvRWAEc79XLo48+mm233Tbf//738+tf/3qx2/jzu/546aWXMnjw4Bx88MGZOHFiJk2alA4dOuTRRx+t69FYAZ5//vnssssu6d+/f8aOHZuRI0dmypQp2XbbbfPwww8n8fu7PnniiSeyww475Etf+lLOP//8bLrppvntb3+b9957r3qbVe3v6mIkn9tjjz2Wvn375uijj85JJ52Utm3bZosttsgdd9yRxH8E66MXX3wxa665Zo466qhsueWWOeCAA/LXv/41e++9d775zW/mnnvuSeLY1wfTp0/PVlttlf333z9nn312FixYkBNOOCHf+MY3svvuu+fnP/95Zs6c6SN+9cTcuXPz05/+tPofl15++eWcdNJJgmQ99uyzz6Zdu3Y5+OCD07x58zRv3jxrrbVWHn/88RxyyCH5xz/+kRkzZtT1mNQSx3v18corr2TrrbfOwQcfnHPOOSfz5s3L6aefnoMOOihDhgzJ+PHj884776RBgwb+215PPPDAA1l//fVz7LHHpl27dtloo43SuXPnPProozn55JNz3333rdJnUVHTNddck1122SVnn312ttpqqxx88MEZNGhQXnrppQwcODDPPPOMv5/XE9OnT88BBxyQ4cOH57zzzsvuu++eM888M507d87UqVMzffr0VfKSaWIkn0tRFBk9enROPPHEnHnmmUmSjh07ZsSIEbnsssty//33O028Hpo5c2aefPLJNG/ePMmH0bFt27b53e9+l8GDB2fvvffOjBkzHPt6YO7cudl2221z11135YUXXsiee+6Zu+66KxtssEHatm2bq6++OoccckhmzZrleNcDLVq0yI477pgBAwbkuOOOy/DhwzN9+vQlBkn/A7vqe/PNN/PQQw/lrbfeSpKce+65ueWWW/LSSy9lxowZ2X///XPppZcmcbzrgzfeeMPxruc+Om7PP/98evbsmX//+9956623stdee+WGG25IVVVVXnrppZx99tk59dRTM3fuXNeRrCfeeOON3HvvvdXXfD7nnHNyxx135NZbb80dd9yRr3zlK7nqqquSOGGgPnjllVcyZcqU6uOdJL169cohhxySzTffPEOGDHFT2XripZdeyl577ZUjjjiietkll1ySf/7znxk0aFAGDx6cIUOGVJ8gssoo4HOaN29e9a8XLlxYFEVRzJw5s9hxxx2Lww8/vJg3b15RVVVVV+NRSz744IPqX8+dO7fYcssti0MOOaSYO3duURT/79g/99xzxZe//OXil7/8ZVEUhWO/ipo1a1ZRFB8evylTphQ777xzUalUiq9+9avFjBkzqrf74x//WPTs2bO47rrr6mpUasnHf69+/NeXXHJJscMOOxT77rtv8dxzzxVFURTvv/9+9c8Iq56P/7ldFEWxxx57FJVKpRg4cGDRqFGj4qabbqr+b/pZZ51VtG3btpg2bVpdjEotmD59evXv3aqqKse7npszZ05RFEWxYMGC4o477ii23nrrxf75/dOf/rT4whe+UDz66KN1NSq14M033yxmz55dFEVRTJs2rdh6662LRo0aFV//+teLhg0bFjfeeGP1f/OPOuqoYt11163enlXTR/9PdsEFFxTbbLNN8fe//7149913i+eee65o3759cc455xQTJ04sevbsWTz22GN1PC21YcGCBdV/jhdFUfzyl78sKpVK8ac//al44okniksvvbTYcsstiwsuuKAOp1x+q1A2ZWUyb968JB/ezalJkyZJPvyX2I9K/BprrJG+ffvm2muvrb6rV+Ff2FdZTzzxRM4999zMmTMnSdKkSZPst99+efzxx3PBBRdk/vz51cd+ww03TLNmzfL0008ncdfGVdETTzyRbt265W9/+1sqlUrWX3/9XHzxxTn++OPzve99Lx06dKj+F/Xhw4fn9ddfzyOPPFK3Q/OZzZ49O2+//XZefvnlJP/vrJqP/qV9+PDhGTp0aKZPn54f//jHeeqpp3LUUUdlm222yQcffOC/7auYp556Kt/5znfy1FNPVS+7/vrrc8stt+S73/1udtppp+ywww7Vf8736dMn66yzjo/2raIef/zxbLbZZhk/fnySD/9MdrzrryeffDIbbrhhJk+enEaNGmW77bbLqFGjcvjhh+fYY49Nhw4dqo/tT3/600yZMiX//Oc/63hqPqsnnngiPXr0yBVXXJHkw0+nXX/99Rk/fnz22GOP7LPPPtl9992r/5zecssts+aaazorchX10d/LPjp+Bx54YNq2bZsTTjghvXv3Tq9evbLvvvvmuOOOy6677ppXX321+tqRrHo+3lsaNWqUDTfcsHrddtttl1tuuSX/X3v3HRbF2bUB/F5AQEAELIAIKghGmggKKBIbGFFREWMDsX5GA7bYiIhGI8ZCNPYWWzTGGHuMEkUsCLGFDqJIFLEg2LBQd/d8f/AykViiQFjXOb/ryvXCzKw5eW9nduaZp/j7+8Pa2hoBAQEoLi7G1atXFVVupXBjJHtnly9fxsiRI9GxY0eMGjVKmB+wvNGp/AsvJCQEqqqqmDdvXoX9TLkkJibCzs4OMpkMOjo6ICKoqqoiMDAQ1tbW2LNnDxYuXFjhxqZRo0bQ19cHEXFDhZJJSEiAu7s7CgoKcODAAaEB2sLCAlOmTIGnpycAQEVFBTKZDA8fPoSNjQ1sbGwUWTarpNTUVPTt2xddu3aFk5MTdu3aBYlEAolEAjU1NeG8HjlyJIYPH468vDx07twZu3btwpYtW6CmpsbXdiWSnJwMNzc3GBgYoKSkBMDfDzVdunRBSUkJMjIyoKmpKUzDERkZibp160JHR0dhdbPKKV98TEdHB1u3bq3wkNKlSxdIpVLO+wNS/v2dm5uL06dPQy6XQ0VFBZ06dcLkyZPh5uYGAFBVVYVMJsOdO3dga2uLjz76SMGVs8pISEgQMt22bRvu3r0LFRUV1K9fH76+vigtLUV6ejokEgk0NDSEzzRo0IBX1lZCV65cweTJk4VpdGJiYlC3bl3s2bMH8+fPR3BwMH788UesXbsWcrkcmZmZsLKyQosWLRRdOquE17W3AGVtLc7OzujSpQuAsvu458+fw9LSEra2tsIxyoAbI9k7SUlJgZubG/T09ODi4oKioiKsWLECxcXFwl/68l6QGhoa6N27N86cOSPMTcSUS3JyMtq3b48ZM2Zg5syZAMryLSoqgra2NpYtWwZXV1ccPHgQrq6uCAsLQ0BAAI4cOYJhw4YJjRpMOZSvujlx4kSsWrUKBw8erHDuNmjQQOgJDZQ90KxcuRK3b9+Go6OjIkpmVZCamooOHTrA0dER06ZNw7BhwzBx4kTk5eUJx5Q3OgNlPSRLSkpQUlKCs2fPwsXFRVGls0rIz8/HqFGj4O/vj7Vr16JVq1Z4/vw5srOzhWM+/vhj1KlTB+7u7li2bBlGjx6NzZs3Y926dahbt64Cq2fvKikpCe3atcP48eOxb98+lJaWCj1kynvXuLq6Qk9Pj/P+ACQmJqJdu3aYMmUKZs+ejTVr1uD58+cAyq7jzZs3f+n7e/PmzSguLoalpaWiymaVVH6/NmHCBGzfvh2pqanC6Iby7+y2bdtCTU0N/v7+2LFjB4KCgrBt2zYsXbqUXzYomZSUFLRv3x5FRUUwNDTEtWvXEBoaihs3bkBHRwe+vr4YMWIEevfuDaCscWrLli3Iz89H48aNFVw9e1dvam+Ry+UvLVKjoqKCRYsWITExER4eHgCUqBOYQgaHM6V0/fp1at68OYWEhAjbli5dSkOGDKHS0tIKc8yVzz106tQpql+/PuXk5CikZlZ5mZmZpK2tTf7+/sK2hQsXUkBAAA0ePJj27t1LRESFhYV0+PBhGjJkCHXu3Jk+/fRTSkpKUlTZrJLi4+NJIpHQzJkzhW22trY0fPjwV877eeLECRo7dizp6elRfHx8DVbKqsPNmzfJ1taWvvzyS2FbbGws9erVi+7cuVNhXhoiopKSEpoyZQppaGjw/GJK6saNG+Tk5CTMBejj40MuLi5Uq1YtGjFiBEVFRRER0ZEjR6h79+7UqlUr8vHx4fmmlFD59XzWrFnCNh8fH7Kzs6twnFQqpUOHDpGXlxfnrcTi4+NJVVVVuJ7fvXuXLC0tafbs2a88/sSJEzRhwgTS1dXl728lVH5+v/g81r59e/L09Kxwv1ZUVEQrVqwgV1dXsrS0JE9PT/7+VkJ37twhR0dHmj59urAtMjKSLCws6OzZs0RUcZ7v5ORk8vPzI319fYqLi6vxelnVvG17S7mTJ0/S5MmTSV9fXymv59wzkr215ORkuLu7IzAwUNh29+5dxMXFoU2bNujatSt27twp9IaTy+Xo2LEjMjIyYGhoqMDKWWXk5uYCAAwMDBAXFwd3d3dEREQgPz8fxcXF6N+/P7755htoamqiZ8+e+PHHHxEZGYmdO3fCzs5OwdWzd1FcXIzNmzcjODgYYWFhICJIpVL06tULiYmJyMnJAVBxLsGUlBQ8evQI0dHRcHBwUGD1rDKePHkCe3t7jBgxQtgWERGBM2fOwNPTE05OTpgwYQLy8/MBALVq1YK5uTn++OMP2NvbK6psVgVFRUV4+vQpnj17hn79+qGoqAhffvkldu7ciaSkJISHh+PKlSvw8vLC0aNHcebMGezcuVMY8sOUR2JiImbMmIGvv/5a6D0xfvx4PH/+HL/88guAst5Tqqqq8Pb2xpEjRzhvJfXs2TOEhYVh+vTpWLBgAQCgbt26cHJywsmTJ186vrS0FKdOnUJ6ejrOnj3L399KRi6XIyIiAsHBwZg/f36F+btv3bqFCxcuACjLWUNDA0FBQTh+/Diio6Oxf/9+/v5WQklJSTAyMsLQoUOF+/CuXbuiXr16SEpKeul4PT092Nvb4+zZs2jdunVNl8uq6G3bW4Cy57eYmBhcv34dZ86cUc7ruYIbQ5kSyc/Pp4yMDOH3JUuWUO3atWn16tW0bds2+vLLL0lVVZViYmIUWCWrTseOHSMzMzOqV68e9e3bl+7cuSPsW7VqFUkkEuGtHFNuL/ZeLn/DevPmTapTpw4tWLDgpX2lpaW8GqOSezHzzZs3U+3atWnHjh2UlJREERERpKqqSlu2bFFcgaxa3bp1i4yNjWnRokU0fPjwCj3gkpOTycTEhBYvXqzACtl/KT8/nxwcHGjIkCHCtlf1emfK58We7OUjk5KTk6lWrVq0adOml44vLi6mhw8f1lh9rHoVFBQIP5efw7m5udSoUSOaOHHiS/uYcouLi6MffvhB+F0qlZJcLicXF5dXfme/OEKRKZ+3bW8pf/4uKSmhx48fK6rcKuOekeyNbt26Jbx10dXVRfPmzQGUvZm7c+cODh06hM8//xwBAQEIDAyEiYkJUlNTFVkyq4KCggLcv38fJSUlkMvl8PT0xObNm9GqVStMmjQJxsbGwrH9+vWDsbEx0tPTFVgxq4pHjx4J8wO+2HtZIpFAJpPB1NQU48aNw4EDB3Dz5k1hHxFBTU0NderUUUjdrHJKS0uFlfmAvzOXy+VQV1dHVFQU/Pz8YGdnh08++QQuLi44f/68osplVZSRkYHt27cLv5uYmGDy5MkIDg7Gjh07hMWp5HI5bG1t4eHhgUuXLimqXFZFT548QVZWFh48eCDMGUf/60Ujl8uhq6uLr776CocPH8bx48cBKNGcUuwlt27dQkJCAgBUWGFVRUUFcrkc5ubm6NevH44ePYqnT58KfxeICOrq6tDX11dE2awKys/r8sWmAAgj0Ro0aICQkBDs27dPmBuWz2/lVVxcjKdPnwIAWrdujaFDhwIou5arqqpCIpGgXr16FT4THh6O6OhoSCQSqKhwE48yefr0qdDL+W3bW9LS0gCUjVxS5jme+W8qe634+HjY2NggMzOzwvby1fmWLl0KDw+PCgvXGBkZwdTUVBHlsipKTU1Fv3790KlTJ3Tr1g0nTpwAUDYUYOvWrXB2dgbw98ONTCaDkZERT4yspK5duwY7OzusWrUKDx48eGl/+UqLnTp1QmpqKi5fvgygLH++wVU+6enpGDFiBDw8PDBgwADhuk5EUFFRgZ+fH1xdXYXjnzx5Ai0tLR7io6SSkpLg7u6OY8eOCS8SAMDf3x9BQUGQyWQ4ceIEiouLhYeWwsJCNGvWTFElsypISUlBz5494eHhgW7dumHLli0VrtXlGdvZ2cHS0hKnT58G8HfjBlMu5ffn169ff+V+FRUVaGlpoUePHjh06BAyMjKEF4n8/a187t69C6lUClVV1QqLVpQrP7/btm0LmUyGuLg4AHjlsez9d/nyZfj5+cHDwwM+Pj64du0agL+fv8upq6sLz2QhISGYMWMG9PT0FFEyq4L09HTY2tpi27ZtFVbALr8//9DbW7gxkr1SYmIiPv74Y4wcORI+Pj4V9pWvrlr+JVd+Y1O+ch/PR6J8Ll++jI8//hjm5uaYPXs2CgoKsHjxYmG/qamp8Cb2xbyLioo4byUVFRWFO3fuIDw8HMuXL6+wajYRCQ+pXl5e8Pb2xsyZM/HkyRN+kFFCycnJ6NChA9TU1NC7d2+cO3cO06dPB/B3T9d/PrQsWbIEf/31F7p166aIklkVZGdnw9vbG/7+/ti+fTvMzMyEfcbGxpg+fTrGjBmD0NBQTJgwAfPmzcPkyZMRGRmJYcOGKbByVhlXrlxBx44d0bZtW6xduxYWFhbYvHkzSktLhWPKz29zc3N8+umnWLhwIXJycoSXTkx5vOn+HCjLuvyhNSAgAJ06dcL8+fNRWFjI399KKD09HSYmJujcuTNkMpnQ8/VV2rZti/79+2PWrFl4+PAh945TQmlpaXB3d4euri78/PwQFxeHWbNmAfi70bn8/vzRo0dQV1fH0qVLsXTpUly8eJHn7FdC+/btQ3Z2NiZMmIBNmzYJ28t7PZfn/aG2t6gpugD2/im/EI4dOxZLliyBTCbD6dOn8fjxY9SuXRteXl4VbmDT0tKwceNGbNu2DVFRUWjUqJECq2fvqqioCLNmzcLgwYOxatUqAEDjxo3x7bff4t69e6hbty5q1aolZH7q1Cns3LkTe/bsQVRUVIWh20x5ODs744svvoCzszMGDRoEmUyGkJAQaGlpoaSkBBoaGsJb2Pbt2yMjI6PCwy1TDjdv3kT//v0xevRoLFy4EADQpEkTHDp0CM+ePYOOjo6w6BgAnDlzBj/99BN2796NyMhING3aVIHVs8q4fPky7OzsEB4ejtLSUsycORN//fUXiAgDBw5E3759sW7dOri5uWHLli1ISUlB/fr1cfLkSbRs2VLR5bN3UFpaioULF8LX1xdLly4FUHZ+T5w4EVlZWdDR0YGBgQE0NDRQWlqKWrVqwdvbG7/99luFKRuYcnib+/N/NkDZ2toiKioKUqlUQVWzyrp37x4+++wzeHh44Nq1a+jatStOnDgh9JB8MevyXq/dunXD+fPn+fxWQs+fP8ekSZPg7++P7777DkDZC8SjR4+ioKAAWlpaAP4euWRgYIA5c+ZALpcjOjoajo6OiiqdVYGDgwM+//xzWFtb47PPPoNMJsNnn30GoKzhuVatWgA+3PYWboxkFcjlcsyaNQtSqRSDBw9GaWkp+vTpg9zcXGRlZaGgoAC9evXC1q1bUbt2baSlpWHXrl24cOECTp069cG00ouJuro6njx5glatWgnb9u/fj5iYGLi4uMDY2BidO3dGaGgopFIprly5goyMDJw+fZrfwCkxbW1t7Nq1C+Hh4Xj8+DHGjh2LOnXqIC0tDfXr18fSpUuFBqqgoCD069fvpflp2Pvv5MmT8PDwwLRp04RtMTExiI2NhYuLC0xNTeHj44MRI0agoKAAmZmZuHnzJk6fPs2r6iqptLQ03Lp1CzKZDF5eXpBKpXBzc0NsbCyWLFmCpKQkhIaGYujQofDx8YGOjg4KCwsrzEPGlEOtWrWQn5+PevXqCY0R27ZtQ0xMDLp27Yr69evDysoKGzduFOb4tba2xsGDB3nOQCXzrvfnUqkUampqWLx4MbKzs3mOZyUUHx+Pxo0bY8yYMdDS0sLAgQNf2yBZfr/Ws2dPtG3bFg0bNlRk6ayS8vPzKzyPRUdH49SpU3B0dETjxo0xaNAgBAQEQF1dHQYGBlBTU8OpU6f4eUyJGRkZISoqCkuWLMGdO3cQGBgIPT09nDt3DiYmJpgyZQquXLnywba3SOjFwemMAcjNzUX//v0hl8vx9OlTNGrUCIsXL4a2trbQy6Zv3774/vvvAZRNkq+vr4/69esruHL2ruRyOUpLS+Hl5QWZTIYBAwYgKysLq1atwqpVq2BjY4NDhw7h+PHjmD9/Prp164YnT54AKJtglymX8odVuVwOuVyOLl26YP369WjZsiV2796NQYMGQUtLC0eOHMHHH38MAMIDDVNOBQUFSE9PF96YL168GMHBwVi0aBFsbGywdetWpKenY/fu3fjoo4/w/PlzyOVyfnBVQuUPphEREfjmm28wefJkrFu3Dlu3boWRkRGAsnmlIiIi8PPPP6N58+bCZ3guOeVTPl3O2LFjceXKFbi6ukIqlWLdunXYsmULWrVqhXPnzmHDhg0YPnw4xo4dC5lMxkOzlVheXh58fX3f+v6c81ZuhYWFiI2NRdeuXQEA58+fx+DBg2FmZobIyEioqalBLpcL126+hiu3oqIi2NnZwcbGBmPGjEFMTAyWLVuGhQsXokWLFti8eTMyMzPxww8/wNraGidPnoSFhUWFqViYcii/5yIi5OXlwcvLC0eOHIGhoSG+/fZbTJs2DVpaWjh//jxsbGwAAFevXoWBgcGH195SU8t2M+Vy7949cnFxIVdXV7px40aFfRs3biQTE5MKy84z5fLkyZMKv9+9e5c6duxIw4YNI0tLS1qzZo2wr6SkhExMTOjLL7+s6TJZNXkxb7lcLvzct29f2r59OxERjRkzhvT19UkikdC8efPo/v37NV4nqx7Z2dmUkJBAhYWFFbY/ffqUli5dSsePHxe2FRUVkbq6Oq1du7amy2TV5J/X8wcPHlCjRo3IxMSEXFxc6Pnz58K+oqIiqlOnDq1fv76my2TVpLi4uML/5ubm0siRIykoKIhcXV0pPDxcOFYqlZKjoyONGzdOIbWy6nfv3j1ydnZ+4/15Zmamgqpj1UUmk71y+4ULF6hZs2bUsWNHkkqlRES0fPlyOnnyZA1Wx/4riYmJZGFhQb6+vmRoaEibN28W9hUVFZG2tjYtXbpUgRWyqigoKBB+fvF5zMPDg86ePUtERAEBAVS3bl1SUVGhbdu21XiNNY1ntmXIysrCjh078PXXX+Pq1asoKSlBw4YNERERgalTp740J6BcLkfdunV5CICSunLlCrp3747169cL24yMjHDs2DFs3boVpqamQuYymQxEBHt7+w9m1S6x+WfeEokEJSUlAAAzMzPk5uZi4sSJ+PXXX5Gamopt27Zhzpw5WL9+Pa/EqISSkpLg7OyMgwcPCr2Y6X8DIHR0dBAYGAgPDw8AZef33bt34eTkxHMFKqlXXc8NDAywa9cuSCQS3Lx5E8nJycI+IoKzszNfz5VUeno6xo0bh+7duyMkJASpqalo0KABNmzYgJUrV6Jhw4ZQV1cXjldVVYW5ubnQM5Z4MJRSycrKwsGDB7Fhwwbcvn0bT548QcOGDXH06FFMmTLltffnH1zPGZEoLCwUfn7d4jNt2rTBzz//jJs3b8LT0xPjxo3DpEmT0Lhx45oqk1WTnJwcREdHY/fu3SgqKgIA2NvbC/fi5ubmwvDrkpISFBYWonXr1py1krpy5Qr8/f1x9OhRAGXPY+Vz8detWxd//fUXJkyYgOPHj+Ps2bMICwvD8OHDsX37dkWW/Z/jsXcil5ycjF69eqFJkyb466+/sGrVKsTGxsLCwgJ6enrw9fV96TNpaWlo0aIFD/1QQkSE7du34/z58zA0NIS6ujpGjBgBoOzGRyqV4tmzZ/j999/h7e2N/Px8rFq1CvHx8Vi5cqWCq2fv6nV5lz+sduzYEf3794eJiQl+/fVXGBsbY+jQoVBRUUHr1q15JUYlk5mZiW7duiEgIAAzZsyAhoYGgIpDt168bquqqmLz5s0oKCiApaVljdfLquZN1/M2bdpgxYoVGDVqFKZOnYoJEyagRYsW+OWXX3D58mVYW1sruHr2rlJSUtCxY0f4+vqiYcOGiI2NRb169YQsy1fcjIyMRO/evaGqqorvv/8ep06dwoIFCwDwME5lkpSUBE9PTxgbG+POnTuYNWsWxowZAz8/P7Rs2RL9+vV76Tua78+VV2pqKoYMGYKwsDD06tXrtcdJJBK0bdsWO3bsQIcOHZCYmIhLly6hefPmNVgtq6rk5GQMHjwYEokE2dnZCA0NFa7p5ffoeXl5iIiIQJs2bVBaWopVq1YhKysLzs7OCq6evSupVIr58+dj//79qFWrFjQ0NNClSxdhcZpOnTph1KhRMDIywuHDh2FrawtbW1uoqqqiTZs2Cq7+P6bAXplMwa5cuUKGhoYUGhpK+fn5RERkZWX12uFbV69epZkzZ5Kenh4lJyfXZKmsGm3atInc3Nyob9++5ObmRt9//32F/UePHiUdHR1q3LgxOTk5UbNmzSguLk5B1bKqelPed+/epalTp1JiYiIRVRwywJTPt99+S3369CGisuGZ69ato0mTJtHy5cspISGhwrGxsbH05Zdfkq6u7kv7mPL4t+v5n3/+SY6OjtS0aVOysLAga2trvp4roUePHpG7uzvNmDFD2DZu3DgKCgoior+HfqWmppKBgQEZGhqSjY0NWVlZcd5K6PHjx+Ti4kLTpk2jhw8fEhHR3LlzydXVlQYMGEBpaWkVjuf7c+WWlZVF1tbWVLduXTIwMKDffvvtjcfLZDIaM2YMaWlpUWpqag1VyarL1atXycjIiGbOnEmZmZmUlZVFLi4u1Lt3byL6e4j+mjVrSF1dnVq2bEkdOnSgxo0b8/VciS1btoz69OlDrVu3pi5dutCxY8eEfUlJSeTn5yfK+3HuGSlSBQUFWLx4MT799FPMnj1beItqbW2N7OxsBAUFoXv37mjdujVMTEyQnJyMb7/9FqdPn8bJkyd5lVUlZmhoiJYtW2LJkiUYOXIkduzYAX19fRw8eBCjR49G9+7dcfHiRezduxdmZmZwd3dH06ZNFV02q6RX5a2np4dDhw5h4sSJWLBggfBmjnvNKLfk5GQ0adIEAODu7g4NDQ2UlpbiwoULWLZsGbZs2YJOnTrh0aNH2LRpE+Lj4xEdHf1BrconNm86v0eOHImOHTvi7NmzuHXrFkpLS9GwYUMewqmECgoKkJOTgw4dOgjb1NTUkJKSgnbt2sHU1BT/93//B09PTyQnJ+Po0aNo0KCBsAIrUy6FhYXIzc2Fm5ubsOr57NmzYWZmhk2bNmHJkiX4+uuv+f78AyCVSnHw4EFYWlpi9+7dWL58OQYOHIjdu3fDy8vrlZ85d+4cEhIScPr0ae7lrmQKCwuxePFi9OrVC3PnzhUWiBw+fDg2bdoE4O8h+sOGDYONjQ327duH5s2bw8vLCxYWFgqrnVUO/W+xGg0NDVhYWOD777+Hh4cHvv32W9SrVw/bt29HYGAgvv/+e2hqaiq63Jqn6NZQpjgHDx6kP/74Q/h93rx5VKtWLRo0aBB17dqVmjZtSnPmzCGisrfyZ8+epaysLAVVy6rLvXv3qEOHDlRSUkL37t2jgQMHUqNGjUgikfAbtw/Q2+T9uonSmXJZsGABeXp60rJly8jT05NycnKIiCg5OZmGDRtGrq6udOfOHSIiun//vrCfKS++notDdnY2ubi4UGBgIMXFxdFXX31Fmpqa9N1331FYWJiw+FxKSoqiS2XVICcnh1q1akXr1q0jIqLS0lJh39q1a6lFixa0c+dOIipbsIrvz5XbmTNnaP/+/cLvo0ePJh0dndf2kCwsLORFBpXYlClTKCwsrMK28+fPk7GxMeXm5gqLk7EPy5UrV8jLy4uIiG7evElOTk5kYmJC2trawne3GEeo8YRgIvPighS9e/eGq6srgLJ5Zg4cOID9+/djx44diIyMxKBBg7Bp0yY8evQIenp6cHNzg5mZmaJKZ9VAKpVCLpcjLy8PN27cQMOGDSGTyfDw4UM4OjoiLS1N0SWyavS2efPckMqN/rcoRYsWLfD48WMcO3YMVlZWMDQ0BADY2tpi8ODBuHnzJvLy8gAA9erVE/Yz5UEvLEBCRHw9F4nGjRujf//+uHTpEmbMmIGVK1fihx9+wMSJEzFz5kwEBgaisLAQGRkZii6VVQNDQ0PY2NggPDwcOTk5UFNTg1QqBQCMHTsWrVu3Rnh4OICyBav4/ly5ubu7o2/fvsLvGzduxKBBgzBw4EBhsQupVIqjR4/izp070NTURL169RRULauqRYsWYebMmQAqfqerq6tDW1tbmDMyKytLOO+ZcqP/9Y5MT09HTk4OTE1N0aRJE+Tl5cHOzg6PHj0CIM4RavwEKiKXL1/GlClTcOfOHQAVGyabNm2KI0eOoGfPnsKF0cHBAQYGBgqplVXdjRs3sHz5cixduhSHDx8GUDasy8jICG5ubpDL5Rg1ahT++OMPHDhwABYWFli8eDF27typ4MpZZeTl5SElJQUJCQl48OABAM77Q/aqvPv164eWLVsiIiICly5dwsOHD4XjbW1tUb9+fb6xVVLFxcUAym5Uy7+jJRIJn98fqPK8AQjn7NSpU3Hw4EGsWbMGdevWRbNmzYRjzMzMoK+vLwz5Y8rl3r17OHXqFE6ePImsrCwAZQ1StWvXRp8+ffDkyZMK2Xbp0gXq6uooKSlRVMmsCl7MOzs7W9j+YsPUxo0bMXjwYAwYMAC//vorgoKCEBgYyC+PlVB53lFRUcjOzhamRpPL5RUan1RUVIRpk6ZNm4b+/fsLq2wz5fHi+X3r1i0AZfdr5ubmcHJygqamJkaPHo0LFy5g7969kMlkmDJlCqKjoxVcuYIorlMmq0klJSXk6upK+vr6NGLECLp9+zYRVRye+c+uwePHj6e+ffsKE6Mz5ZGUlETGxsbUqVMnatmyJbVq1YqioqKE/YMHDyaJREKNGjWiixcvElHZMDB/f3+6ceOGospmlZSYmEjNmjWjdu3aka6uLnl6etLatWuF/QMHDuS8PyCvynvlypXC/oEDB5KqqioFBQVRRkYG5efnU0hICLVs2ZJyc3MVWDmrjMuXL9PYsWMpNjb2lfv9/Pz4/P6AvCrvF4fp3rt3j5ydnenw4cPC/dmsWbPI0tKSbt26VeP1sqpJSkoiKysrcnJyIk1NTRo2bJiQY2JiIrVo0YIcHBwoISGBnj59SkREn332GXXt2pUKCwsVWTqrhFflXT59yqv83//9H0kkEqpTp45wfWfK423zjo+PJyMjIyooKKCZM2eSlpYWnTt3TgEVs6r4t7x79epFampqZGRkJJzP165dI3d3d9FOtcGNkSJRXFxMnTt3Jk9PT+ratSsFBAQIf+n/2Qj59OlTmjVrFtWrV49XaVNCt2/fpmbNmlFwcDAREaWkpJCDgwMdPHhQOObSpUs0aNAgunTpEhH93SgtlUprvmBWJdnZ2WRmZkbTp0+n+/fvU3R0tNDYvHDhQiIqW1F38ODBnPcH4E15vzgH0fjx48nBwYHU1NTI1dWVDA0NeQ5BJZSZmUmNGzcmiURC/v7+FR5Gy8/fCxcukL+/P5/fH4A35f3ivZqPjw+ZmppSp06dqE+fPtSwYUM+v5VQWloaNWjQgGbMmEH37t2j/fv3k7q6Ol24cEE45vr16+Tq6kpmZmbUqlUr8vLyojp16ohy1VVl96q8NTQ0XmpkLL+Gl5aW0meffUYGBgb8PKaE3jZvorLGSBsbG/r8889JXV1d+D5nyuNt8v7ll1+od+/eQr7l92klJSUKqfl9ICF6oU84+6AtWLAAjRo1AhFh3bp1sLW1xbp163DgwAH07t0bGhoaiIqKQnh4ONLT07F37160bt1a0WWzd3T48GHMmzcPUVFR0NHRAVA2fNPCwgJaWlpo2rQpRowYgaKiInGu2vWB2blzJzZs2IDIyEhhGNeePXswcOBAAGXn/YwZM1BQUAAtLS1Flsqqwb/lPWfOHMyePRsAcO3aNaSkpKBOnTqwsrKCqampwupm7664uBjBwcG4e/cufH19ERwcjDZt2mDatGlo06aNcFxpaSlKSkqgra2twGpZVb1N3lKpVDjvv/76a9y+fRsGBgYYMWIELC0tFVk+e0f5+fnw8/ODmZkZ1qxZI2zv2bMn/P39Ubt2bZiYmKBt27YAgM2bN+POnTtQVVWFr68vrKysFFU6q4Q35T106FDUrl0bxsbGcHZ2BlA2hHfXrl0YPnw4/vjjDzg5OSmqdFYJ75p3dHQ0OnbsCH19fURGRvLzt5L5t7w1NTXRrFkztGrVCvn5+ahbt26Fz9P/5pQUI55cRkRKSkpw+vRpbNmyBYWFhfjll19gZWWFu3fvIi8vDxoaGvj444+RkZGBFStWoHnz5ooumVWCmpoaMjIycOLECfTp0wdhYWE4cOAABg4ciKKiIoSFheHatWsICwtTdKmsGhQUFCAnJwf37t2DiYkJAKBhw4bo1q0bWrVqha1bt6Jr164VGi+Y8vq3vHft2oVu3brB1dUVzZs35+u4EpNIJOjSpQvy8/Px6aefwszMDEOGDMGSJUsqNFDVqlVLmGdKLpfznGJK6m3yVlNTQ2lpKWrVqoXQ0FBFl8yqoKioCL6+vkJjBACEhYXh6NGjePbsGfLy8iCRSDB16lSMGDECI0eOVGC1rKreNu/g4GAMHToUKioqsLe3x7Vr13hxIiX0rnk7Ozujf//+mDVrFuzt7RVYOauMf8s7NzcXEokEISEh8PPze+nzYm2IBMBzRn7o5HK5MLTn5MmT1KtXL2Gfs7MzaWlpUa9evSgvL09RJbJqlpGRQQMHDiRdXV3q2bMnSSQSOnDggLB/9erV1KRJE7p69aoCq2TV5dixY9SgQQNasWIF/fnnn5SamkoGBgYUFhZGt2/fpiZNmtDu3bsVXSarJpz3h+/FuZz/OWdzTEwMmZub04ABA4RhPnK5nP78888arZFVn8rkzXPHKa8X83706JHw82+//UYSiYT27dtHxcXFdP36dRowYAANGDCAnj9/LtzL/3NqJfZ+q2zeTDlVJu/yuWB5ahXlU5m8eS2Oivj1+QfoypUr+O233wBUbGk3NTXFjRs3UFxcjBEjRiA7OxtBQUF49uwZxowZg5ycHEWVzKrgxbwBoHnz5liwYAF+++03DBw4EF26dIG3t7ewv379+tDU1ESdOnUUUS6ron/m7enpialTp2LhwoXo27cv3N3d4e/vj5kzZ6JRo0aoV68e4uLiFFgxqwrOW1zi4+Mxd+5cFBYWAgBq164NoGwIj1wuR/v27bF9+3ZcunQJixcvxrlz5zB58mQMHz4cjx8/VmDlrDIqm/fIkSM5byX0z7z19PSEfT169EBKSgp8fHygrq6Opk2bwsjICNnZ2dDU1BTu50Xdg0bJVCVvpnwqm3f5db98lW2mHCqbt4aGhoIqfj9xY+QH5tGjR7C1tYW3tzd27NgBoOzGRSqVQl9fH9ra2ujatSsiIyMRGRmJRYsWoUePHigsLIRcLldw9exdvSpvADA3N0eHDh1gaGiI/Px83Lp1S9iXkJAAIyMjvtlRQq/Le/r06Thw4AB2796NgwcPYvny5QCAhw8fQlNTE3Z2dooqmVUB5y0uiYmJcHJywvPnz4WHk3ISiQQqKioVGqgSEhLg4+ODDRs2YOvWrRVuhNn7j/MWlzflLZPJAADW1tYA/m6MLigoQNu2bUE8vb/S4bzFpSp5M+XD53c1UlifTPafkMvl1KFDBxo2bBjp6enR5s2bK+wPDAykZs2avTSk6+HDhzVZJqsm/5Z3fHw8WVhY0OjRo2nu3Lk0fvx40tPTo8TERAVVzKri3/J+0aNHjyg0NJRMTEzo+vXrNVckqzact3gkJiaStrY2BQcHC9v+ORyzfAhX+XYfHx/S19en5OTkmiuUVQvOW1zeJu/S0lLhZ6lUSqGhoWRsbEyXL1+usTpZ9eC8xYXzFhfOu3rxAjYfGIlEAolEgrZt26Jx48aYMGECNDQ0MGTIEMTGxiI4OBghISEwNjYG8Pdk9/r6+gqunFXGv+Xdvn17zJ07Fz/88APOnz+P5s2b48yZM9xzSkm9Ke+YmBg4ODhAW1sb6enpWLVqFX766SdERkaiadOmii6dVQLnLQ63b9+Gg4MDRo0ahW+++QZEhNmzZyM5ORlqampwdHTEzJkzoaqqCplMBhUVFXz55Zc4cOAA4uPjYWtrq+j/BPYOOG9xedu81dTUIJfLcejQIURERODAgQM4evQoPvroI0X/J7B3wHmLC+ctLpx39ePGyA+IVCqFmpoaWrVqBSMjIwwfPhxyuRzjxo3DkiVLoKenh71798LAwED4DK+6qbzelHd4eDi0tbVx6NAh+Pn5oUePHqhduzbkcjm0tLQUXTqrhH/LW1dXF/v27YO2tjbq16+Pbt26YdKkSbyaspLivMVDTU0NLVq0wNWrV3Ht2jWMHj0aUqkU9vb2ePDgAbZu3Yq4uDjs2bNHmFPK29sbQ4YM4RdLSojzFpd3yVtFRQV6enrQ0dHB6dOn0aJFC0WXz94R5y0unLe4cN7/AUV2y2T/jcWLF9PIkSOJiOjp06dka2tLampqFBoaKhzDq/F9ON4mb16h7cPxNnmzDwfnLQ45OTnUqlUrkkgk5OPjQzk5OURUNtTnxx9/JHNzc9q/fz8R8ff3h4DzFpe3yXvv3r3C8cXFxYoqlVUDzltcOG9x4byrF3eLU3L0iklQGzRogLy8PADAxIkTkZeXB39/f6xevRrr168HwKvxKavK5s0rtCmnyubNlBPnLS4v5m1oaIijR49i1KhRCAgIgKGhIYgIampq6N69O/Lz83H9+nUA/P2trDhvcXnXvLOysoTj1dXVFVEyqwLOW1w4b3HhvP87PExbSWVlZeHZs2ewsbEBEVW4WfX09ERERAS8vLyQkJCAyMhINGzYENra2ggLC8OgQYOgq6vLN7hKhPMWF85bXDhvcXld3sbGxli6dKlw4yqRSIQbYBsbG5ibmyusZlZ5nLe4cN7iwnmLC+ctLpx3DfjvO1+y6paenk4GBgbUrFkzunjxIhFVHMaTlZVFBgYGZGZmRnFxccL227dv071792q8XlY1nLe4cN7iwnmLy7/l/SqzZs0iCwsLunnzZk2UyKoR5y0unLe4cN7iwnmLC+ddMyRErxgXxt5bOTk5GDp0KKRSKXR1dXHr1i2sXbsWzs7OICIQEVRUVJCWlgYigo2NjaJLZlXAeYsL5y0unLe4/Fve/+zdGhMTg61bt2Lfvn04ceIEHBwcFFM4qxTOW1w4b3HhvMWF8xYXzrvm8JyRSubGjRtQVVXFV199hS+++AJNmjTB2LFjceHCBaGLsEwmg7W1NT+4fgA4b3HhvMWF8xaXf8tbLpcLxz59+hQJCQnIz8/H6dOn+cZWCXHe4sJ5iwvnLS6ct7hw3jWHe0YqoT///BNOTk4AgJMnT2LFihXIysrC2rVr4eLiUqFHDVN+nLe4cN7iwnmLy9vkLZfLoaqqiqdPnwIA6tSpo8iSWRVw3uLCeYsL5y0unLe4cN415L8bAc5qysmTJ6lv377UunVrOn/+PBERzZgxg6KjoxVcGfsvcN7iwnmLC+ctLq/Ke/r06XTmzBkFV8b+C5y3uHDe4sJ5iwvnLS6c93+De0a+565du4Y9e/YgPz8f9vb28Pb2ho6ODgBAKpVCTa1sQfRTp05hxYoVyM7ORpMmTbBv3z4kJibCzs5OkeWzd8R5iwvnLS6ct7hw3uLCeYsL5y0unLe4cN7iwnkrkKJbQ9nrpaSkkJ6eHnXs2JE+/vhjUlNTI19fX4qIiBCOKS0tFX4+fvw4NWjQgPT09CghIUERJbMq4LzFhfMWF85bXDhvceG8xYXzFhfOW1w4b3HhvBWLGyPfUwUFBdSrVy8KDAwUtv3555/Upk0b8vDwoH379gnbZTIZERFNmjSJateuTcnJyTVeL6sazltcOG9x4bzFhfMWF85bXDhvceG8xYXzFhfOW/F4Rvz3VO3atfHw4UPUr18fACCXy+Ho6Ijt27dDKpViw4YNSExMBACoqKggISEBUVFROHv2LGxtbRVZOqsEzltcOG9x4bzFhfMWF85bXDhvceG8xYXzFhfOW/G4MfI9RER4/vw5NDQ0kJubK2yTSqX46KOPsHr1aqSkpGDLli3CZxwcHHDmzBk4OjoqqmxWSZy3uHDe4sJ5iwvnLS6ct7hw3uLCeYsL5y0unPd7omY7YrJ38fPPP5NEIqE9e/YQUVn34JKSEiIi2rlzJ+nr61NWVhZJpVJFlsmqCectLpy3uHDe4sJ5iwvnLS6ct7hw3uLCeYsL561YaopuDGV/IyJIJBLcv38fmpqa8PX1xbRp0+Dv7w91dXV4e3tDRaWsM6uenh6MjIygra0NVVVVBVfOKoPzFhfOW1w4b3HhvMWF8xYXzltcOG9x4bzFhfN+v3Bj5HtEIpHgwIEDCA8PR15eHoYOHQpXV1cQEXx9fbFixQr07dsXenp6OHPmDNTV1YWThSkfzltcOG9x4bzFhfMWF85bXDhvceG8xYXzFhfO+/0iISJSdBGsTFxcHLp06YIpU6bg/v37iI2NhYWFBXx9fZGXl4fJkyejUaNG0NXVxd27d/H777+jdevWii6bVRLnLS6ct7hw3uLCeYsL5y0unLe4cN7iwnmLC+f9fuHGyPdEZmYmfvrpJ0gkEoSEhAAAfv31Vyxfvhy6uroICwuDlpYWzp8/D5lMhvbt26NJkyYKrppVFuctLpy3uHDe4sJ5iwvnLS6ct7hw3uLCeYsL5/0eqrnpKdnr5OfnU5s2bahhw4YUHBxcYd+vv/5KHTt2JB8fH4qJiVFQhaw6cd7iwnmLC+ctLpy3uHDe4sJ5iwvnLS6ct7hw3u8nHgD/HtDV1cWGDRugp6eH6OhopKamCvt69eqF6dOn4/r161izZg0KCgpA3JlVqXHe4sJ5iwvnLS6ct7hw3uLCeYsL5y0unLe4cN7vJx6m/R5JSkrCsGHD4OzsjAkTJsDGxkbYd+zYMbRo0YK7Cn9AOG9x4bzFhfMWF85bXDhvceG8xYXzFhfOW1w47/cLN0a+Z+Lj4zF69Gg4Ojpi8uTJsLa2VnRJ7D/EeYsL5y0unLe4cN7iwnmLC+ctLpy3uHDe4sJ5vz+4MfI9FB8fj7Fjx8Lc3Bxz5szBRx99pOiS2H+I8xYXzltcOG9x4bzFhfMWF85bXDhvceG8xYXzfj/wnJHvodatW2PVqlW4e/cu6tatq+hy2H+M8xYXzltcOG9x4bzFhfMWF85bXDhvceG8xYXzfj9wz8j3WFFRETQ1NRVdBqshnLe4cN7iwnmLC+ctLpy3uHDe4sJ5iwvnLS6ct2JxYyRjjDHGGGOMMcYYY6xG8DBtxhhjjDHGGGOMMcZYjeDGSMYYY4wxxhhjjDHGWI3gxkjGGGOMMcYYY4wxxliN4MZIxhhjjDHGGGOMMcZYjeDGSMYYY4wxxhhjjDHGWI3gxkjGGGOMMcYYY4wxxliN4MZIxhhjjDH2TiQSCQ4cOKDoMhhjjDHGmBLixkjGGGOMMSbIycnB+PHjYW5uDg0NDZiamsLb2xsnTpxQdGkAgE6dOkEikWDXrl0Vtn/33Xdo2rSpYopijDHGGGNvjRsjGWOMMcYYAODGjRtwcnJCVFQUlixZguTkZERERKBz584IDAxUdHkCTU1NzJo1C6WlpYouhTHGGGOMvSNujGSMMcYYYwCAzz//HBKJBBcuXICvry+srKxgY2ODL774AufOnXvt52bMmAErKytoaWnB3NwcoaGhFRoKExMT0blzZ9SpUwe6urpwcnLCpUuXAABZWVnw9vaGvr4+tLW1YWNjgyNHjryxzsGDB+Px48fYuHHja4/JzMxEnz59YGhoCB0dHbRt2xaRkZEVjmnatCnmz5+PgIAA6OjooEmTJjh06BDy8vLQp08f6OjowN7eXqi13NmzZ+Hu7o7atWvD1NQUEyZMwPPnz99YM2OMMcYYK8ONkYwxxhhjDA8fPkRERAQCAwOhra390n49Pb3XfrZOnTrYunUr0tLSsHz5cmzcuBHLli0T9vv5+aFx48a4ePEi/vzzTwQHB6NWrVoAgMDAQBQXF+PMmTNITk7GokWLoKOj88ZadXV1ERISgnnz5r22EfDZs2fo0aMHTpw4gfj4eHTv3h3e3t64efNmheOWLVsGNzc3xMfHo2fPnhg6dCgCAgLg7++PuLg4WFhYICAgAEQEoKyRs3v37vD19UVSUhJ+/vlnnD17FkFBQW+smTHGGGOMlZFQ+Z0VY4wxxhgTrQsXLsDFxQX79u2Dj4/PG4+VSCTYv38/+vbt+8r94eHh2LVrl9CjUFdXFytXrsSwYcNeOtbe3h6+vr6YM2fOW9XZqVMnODg4YNGiRWjRogVGjRqF0NBQfPfdd/juu+9w48aN137W1tYWY8eOFRoOmzZtCnd3d2zfvh1A2XyZxsbGCA0Nxbx58wAA586dQ7t27XD37l0YGRlh9OjRUFVVxfr164U/9+zZs+jYsSOeP38OTU3Nt/rvYIwxxhgTK+4ZyRhjjDHGUJX30z///DPc3NxgZGQEHR0dzJo1q0IPxC+++AKjR4+Gh4cHFi5ciMzMTGHfhAkTMH/+fLi5uWHOnDlISkp6q3+nhoYG5s2bh/DwcNy/f/+l/c+ePcPUqVPRsmVL6OnpQUdHB5cvX36pZ6S9vb3ws6GhIQDAzs7upW25ubkAyoacb926FTo6OsI/n3zyCeRyOa5fv/5WtTPGGGOMiRk3RjLGGGOMMVhaWkIikSA9Pf2dPvfHH3/Az88PPXr0wOHDhxEfH4+QkBCUlJQIx3z11VdITU1Fz549ERUVBWtra+zfvx8AMHr0aPz1118YOnQokpOT0aZNG6xcufKt/t3+/v5o0qQJ5s+f/9K+qVOnYv/+/ViwYAGio6ORkJAAOzu7CnUBEIaLA2U9Pl+3TS6XAyhr5Pzss8+QkJAg/JOYmIiMjAxYWFi8Vd2MMcYYY2LGjZGMMcYYYwwGBgb45JNPsHr16lfOw/j48eNXfi42NhZNmjRBSEgI2rRpA0tLS2RlZb10nJWVFSZPnoxjx46hX79+2LJli7DP1NQUY8eOxb59+zBlypQ3LkzzIhUVFXzzzTdYu3btS8OzY2JiMHz4cPj4+MDOzg5GRkZvHML9thwdHZGWlobmzZu/9I+6unqV/3zGGGOMsQ8dN0YyxhhjjDEAwOrVqyGTyeDs7Iy9e/ciIyMDly9fxooVK9CuXbtXfsbS0hI3b97Erl27kJmZiRUrVgi9HgGgsLAQQUFBOHXqFLKyshATE4OLFy+iZcuWAIBJkybh999/x/Xr1xEXF4eTJ08K+95Gz5494eLiUmEOx/K69u3bJ/RcHDJkiNC7sSpmzJiB2NhYBAUFISEhARkZGTh48CAvYMMYY4wx9pa4MZIxxhhjjAEAzM3NERcXh86dO2PKlCmwtbWFp6cnTpw4gbVr177yM71798bkyZMRFBQEBwcHxMbGIjQ0VNivqqqKBw8eICAgAFZWVhgwYAC8vLwwd+5cAIBMJkNgYCBatmyJ7t27w8rKCmvWrHmnuhctWoSioqIK25YuXQp9fX20b98e3t7e+OSTT+Do6PiO/4+8zN7eHqdPn8bVq1fh7u6O1q1bY/bs2WjUqFGV/2zGGGOMMTHg1bQZY4wxxhhjjDHGGGM1gntGMsYYY4wxxhhjjDHGagQ3RjLGGGOMMcYYY4wxxmoEN0YyxhhjjDHGGGOMMcZqBDdGMsYYY4wxxhhjjDHGagQ3RjLGGGOMMcYYY4wxxmoEN0YyxhhjjDHGGGOMMcZqBDdGMsYYY4wxxhhjjDHGagQ3RjLGGGOMMcYYY4wxxmoEN0YyxhhjjDHGGGOMMcZqBDdGMsYYY4wxxhhjjDHGagQ3RjLGGGOMMcYYY4wxxmrE/wNnkIuLx8YozAAAAABJRU5ErkJggg==",
-      "text/plain": [
-       "<Figure size 1600x1000 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# 10개의 샘플 선택\n",
-    "sample_classes = image_data['class_name'].unique()[:10]\n",
-    "\n",
-    "# 각 클래스별로 RGB값의 평균을 계산\n",
-    "mean_rgb_per_class = image_data[image_data['class_name'].isin(sample_classes)].groupby('class_name')[['mean_red', 'mean_green', 'mean_blue']].mean()\n",
-    "\n",
-    "# 클래스별로 RGB값의 평균을 출력\n",
-    "mean_rgb_per_class.plot(kind='bar', figsize=(16, 10), color=['red', 'green', 'blue'])\n",
-    "plt.title('Mean RGB Values per Class')\n",
-    "plt.xlabel('Class Name')\n",
-    "plt.ylabel('Mean RGB Value')\n",
-    "plt.xticks(rotation=45)\n",
-    "plt.legend(['Mean Red', 'Mean Green', 'Mean Blue'])\n",
-    "plt.show()\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 349,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1400x600 with 3 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# RGB값의 평균 분포를 출력\n",
-    "plt.figure(figsize=(14, 6))\n",
-    "\n",
-    "# mean_red 값의 분포를 출력\n",
-    "plt.subplot(1, 3, 1)\n",
-    "sns.histplot(image_data['mean_red'], bins=30, kde=True, color='red')\n",
-    "plt.title('Distribution of Mean Red Values')\n",
-    "plt.xlabel('Mean Red Value')\n",
-    "plt.ylabel('Frequency')\n",
-    "\n",
-    "# mean_green 값의 분포를 출력\n",
-    "plt.subplot(1, 3, 2)\n",
-    "sns.histplot(image_data['mean_green'], bins=30, kde=True, color='green')\n",
-    "plt.title('Distribution of Mean Green Values')\n",
-    "plt.xlabel('Mean Green Value')\n",
-    "plt.ylabel('Frequency')\n",
-    "\n",
-    "# mean_blue 값의 분포를 출력\n",
-    "plt.subplot(1, 3, 3)\n",
-    "sns.histplot(image_data['mean_blue'], bins=30, kde=True, color='blue')\n",
-    "plt.title('Distribution of Mean Blue Values')\n",
-    "plt.xlabel('Mean Blue Value')\n",
-    "plt.ylabel('Frequency')\n",
-    "\n",
-    "plt.tight_layout()\n",
-    "plt.show()\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "색상 분포 분석\n",
-    "- 대부분 RGB, Green, Blue값이 200~250사이에 분포\n",
-    "- 전박적으로 이미지의 밝기와 채도가 높은 편"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 352,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/var/folders/h6/61flrrfj1l38_nn873r977580000gn/T/ipykernel_38155/2640141684.py:9: FutureWarning: \n",
-      "\n",
-      "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `y` variable to `hue` and set `legend=False` for the same effect.\n",
-      "\n",
-      "  sns.barplot(x='height', y='class_name', data=class_size_stats.sort_values(by='height', ascending=False), palette='viridis')\n",
-      "/var/folders/h6/61flrrfj1l38_nn873r977580000gn/T/ipykernel_38155/2640141684.py:16: FutureWarning: \n",
-      "\n",
-      "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `y` variable to `hue` and set `legend=False` for the same effect.\n",
-      "\n",
-      "  sns.barplot(x='width', y='class_name', data=class_size_stats.sort_values(by='width', ascending=False), palette='viridis')\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1600x1000 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# 각 클래스별로 이미지의 평균 높이와 너비를 계산\n",
-    "class_size_stats = image_data.groupby('class_name')[['height', 'width']].mean().reset_index()\n",
-    "\n",
-    "# 각 클래스별로 이미지의 평균 높이와 너비를 출력\n",
-    "plt.figure(figsize=(16, 10))\n",
-    "\n",
-    "# 클래스별 이미지의 평균 높이를 출력\n",
-    "plt.subplot(1, 2, 1)\n",
-    "sns.barplot(x='height', y='class_name', data=class_size_stats.sort_values(by='height', ascending=False), palette='viridis')\n",
-    "plt.title('Mean Image Height by Class')\n",
-    "plt.xlabel('Mean Height')\n",
-    "plt.ylabel('Class Name')\n",
-    "\n",
-    "# 클래스별 이미지의 평균 너비를 출력\n",
-    "plt.subplot(1, 2, 2)\n",
-    "sns.barplot(x='width', y='class_name', data=class_size_stats.sort_values(by='width', ascending=False), palette='viridis')\n",
-    "plt.title('Mean Image Width by Class')\n",
-    "plt.xlabel('Mean Width')\n",
-    "plt.ylabel('Class Name')\n",
-    "\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "클래스별 이미지 크기 분포\n",
-    "- 대부분 클래스는 300에서 800 픽셀 사이의 평균 높이를 가지고 있음\n",
-    "- 대부분 클래스느 300에서 800 픽셀 사이의 평균 너비를 가지고 있음"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 355,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/var/folders/h6/61flrrfj1l38_nn873r977580000gn/T/ipykernel_38155/3931341571.py:5: FutureWarning: \n",
-      "\n",
-      "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n",
-      "\n",
-      "  sns.boxplot(x='target', y='mean_red', data=image_data, palette='Reds')\n",
-      "/var/folders/h6/61flrrfj1l38_nn873r977580000gn/T/ipykernel_38155/3931341571.py:13: FutureWarning: \n",
-      "\n",
-      "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n",
-      "\n",
-      "  sns.boxplot(x='target', y='mean_green', data=image_data, palette='Greens')\n",
-      "/var/folders/h6/61flrrfj1l38_nn873r977580000gn/T/ipykernel_38155/3931341571.py:21: FutureWarning: \n",
-      "\n",
-      "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n",
-      "\n",
-      "  sns.boxplot(x='target', y='mean_blue', data=image_data, palette='Blues')\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1600x1000 with 3 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.figure(figsize=(16, 10))\n",
-    "\n",
-    "# mean_red 값의 분포를 출력\n",
-    "plt.subplot(1, 3, 1)\n",
-    "sns.boxplot(x='target', y='mean_red', data=image_data, palette='Reds')\n",
-    "plt.title('Mean Red Value Distribution by Target')\n",
-    "plt.xlabel('Target')\n",
-    "plt.ylabel('Mean Red Value')\n",
-    "plt.xticks(rotation=90)\n",
-    "\n",
-    "# mean_green 값의 분포를 출력\n",
-    "plt.subplot(1, 3, 2)\n",
-    "sns.boxplot(x='target', y='mean_green', data=image_data, palette='Greens')\n",
-    "plt.title('Mean Green Value Distribution by Target')\n",
-    "plt.xlabel('Target')\n",
-    "plt.ylabel('Mean Green Value')\n",
-    "plt.xticks(rotation=90)\n",
-    "\n",
-    "# mean_blue 값의 분포를 출력\n",
-    "plt.subplot(1, 3, 3)\n",
-    "sns.boxplot(x='target', y='mean_blue', data=image_data, palette='Blues')\n",
-    "plt.title('Mean Blue Value Distribution by Target')\n",
-    "plt.xlabel('Target')\n",
-    "plt.ylabel('Mean Blue Value')\n",
-    "plt.xticks(rotation=90)\n",
-    "\n",
-    "plt.tight_layout()\n",
-    "plt.show()\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "클래스별 이미지 색상의 분포\n",
-    "- 대부분 Red, Green, Blue 값은 200에서 250 사이에 분포"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 2.2 Displaying images"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 360,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1600x1000 with 30 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# 같은 target을 가진 이미지 전체 출력\n",
-    "def display_images(data, target):\n",
-    "    len_data = len(data[data['target'] == target])\n",
-    "    fig, axs = plt.subplots((len_data // 5)+1, 5, figsize=(16, 10))\n",
-    "    images = data[data['target'] == target]['path'].values\n",
-    "    for i, path in enumerate(images):\n",
-    "        img = Image.open(path)\n",
-    "        ax = axs[i // 5, i % 5]  # Use double indexing for 2D subplots\n",
-    "        ax.imshow(img)\n",
-    "        ax.axis('off')\n",
-    "    plt.show()\n",
-    "\n",
-    "# target이 0인 이미지 출력\n",
-    "display_images(image_data, target=1)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 2.2.1 Displying random images using PIL"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 275,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAABR4AAALvCAYAAAADNtl1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3gU5drG79ne03sIJKEKSAmGIwoIgoACIgrKESmKYEERxYJKUZQiSDlY0GOhiEpROfghICpVEZSOEDoJCUlI25TtO/t+fyQzzM7OZjcNgr6/69oruzNved6Z3c3MvU9hCCEEFAqFQqFQKBQKhUKhUCgUCoVSj8iutwEUCoVCoVAoFAqFQqFQKBQK5e8HFR4pFAqFQqFQKBQKhUKhUCgUSr1DhUcKhUKhUCgUCoVCoVAoFAqFUu9Q4ZFCoVAoFAqFQqFQKBQKhUKh1DtUeKRQKBQKhUKhUCgUCoVCoVAo9Q4VHikUCoVCoVAoFAqFQqFQKBRKvUOFRwqFQqFQKBQKhUKhUCgUCoVS71DhkUKhUCgUCoVCoVAoFAqFQqHUO1R4pFAoFAqFQqFQKBQKhUKhUCj1DhUeKRQKhXLNWL58ORiGwZ9//nm9TWlUtlAoFAqFQqFQKBTK3xEqPFIolOsKFX8odWH27NnYsGHD9TYDFRUVmDFjBvr374/w8HAwDIPly5f7bX/y5En0798fBoMB4eHheOSRR1BQUBDUXAzDYOLEifzrixcvgmEY/iGXy5GUlIT77rsPhw8f9unr7/HEE0/4zLV7924MHz4cCQkJUKlUCAkJQdeuXfHmm28iPz8/KHspFAqFQqFQKBTKPxfF9TaAQqFQKJTaMnv2bDzwwAMYMmTIdbWjsLAQb775JpKSktChQwfs2LHDb9vs7Gz06NEDISEhmD17NioqKrBgwQIcO3YM+/fvh0qlqpUNI0aMwN133w2WZXHy5El8+OGH2Lx5M37//Xd07NiRb9e3b1+MGjXKp3/Lli29Xk+fPh2zZs1CSkoKxowZg5SUFNjtdhw4cADvvvsuVqxYgXPnztXKVgqFQqH881i+fDnGjh2LP/74A126dKG2UCgUyj8E6vFIoVAoFEodiYuLQ25uLjIzMzF//vxq286ePRsWiwW//PILnn32Wbz66qtYu3Ytjhw5Uq2XZCA6d+6MkSNHYvTo0Zg7dy6++OILOBwOfPjhh17tWrZsiZEjR/o80tPT+TZr1qzBrFmzMHz4cJw8eRJvv/02HnvsMTz99NP47LPPkJWVhUceeaTWtlIoFApAox4odaOxRD3s2LHDbzTB77//7tP+t99+w+233w6dTofY2Fg8++yzqKioCDgPF+GwYMECv3MrlUqkpKRg1KhROH/+vE9ff4+5c+f6zPf9999j0KBBiImJgUqlQnh4OHr06IF3330XZWVltTxaFArlnwgVHikUSqNjzJgxMBgMyMrKwsCBA2EwGJCQkID3338fAHDs2DH07t0ber0eTZs2xZdffunVv7i4GFOmTEH79u1hMBhgMpkwYMAAHDlyxGeuzMxMDB48GHq9HtHR0Zg8eTK2bt0KhmF8vNb27duH/v37IyQkBDqdDj179sSvv/4acD3cReHatWvx9ttvIzExERqNBnfeeSfOnj3r1Xb37t0YNmwYkpKSoFar0aRJE0yePBk2m61ejxEAmM1mPPfcc2jSpAnUajWaN2+OefPmwePxeLXLzc1FRkYGXC5XwLV+/fXXSEtLg9FohMlkQvv27bFkyZJq+5SUlCA9PR2JiYk4deoUAMDhcGDGjBlo3rw5fxxeeuklOBwOvh/DMLBYLFixYgV/4TxmzBh+f05ODh577DHEx8dDrVYjOTkZTz75JJxOp9f8DocDzz//PKKioqDX63HfffcFHfbMoVarERsbG1Tbb775BgMHDkRSUhK/rU+fPmjZsiXWrl1bo3mro3fv3gCACxcu1Ljv9OnTERkZiU8//VTSAzMkJAQzZ86sq4kUCoVCodSaxiI8cjz77LNYtWqV16N58+ZebQ4fPow777wTVqsVCxcuxLhx4/Dxxx9j2LBh9TL3xx9/jHvuuQdr1qzBLbfcgsuXL3u1GzFihI+Nq1atwqBBg/g2Ho8HY8eOxeDBg5GZmYmnnnoKy5Ytw4wZMxAfH4/XX38d9913X53spVAo/yxoqDWFQmmUsCyLAQMGoEePHnjnnXewevVqTJw4EXq9Hq+99hoefvhhDB06FMuWLcOoUaNw6623Ijk5GQBw/vx5bNiwAcOGDUNycjLy8/Px0UcfoWfPnjhx4gTi4+MBABaLBb1790Zubi4mTZqE2NhYfPnll9i+fbuPPb/88gsGDBiAtLQ0zJgxAzKZDJ9//jl69+6N3bt3e3mL+WPu3LmQyWSYMmUKSktL8c477+Dhhx/Gvn37+Dbr1q2D1WrFk08+iYiICOzfvx9Lly5FdnY21q1bV2/HyGq1omfPnsjJycGECROQlJSE3377DVOnTkVubi4WL17MzzN16lSsWLECFy5cQLNmzfyub9u2bRgxYgTuvPNOzJs3D0BlLsNff/0VkyZNkuxTWFiIvn37ori4GDt37kRqaio8Hg8GDx6MPXv2YPz48WjTpg2OHTuGRYsW4fTp0/xNxqpVqzBu3Dikp6dj/PjxAIDU1FQAwOXLl5Geng6z2Yzx48ejdevWyMnJwfr162G1Wr3EtGeeeQZhYWGYMWMGLl68iMWLF2PixIlYs2ZNwHNaU3JycnDlyhXJsK709HT88MMP9TYXFwYdERHhtd1ut6OwsNCnvclkgkqlwunTp3H69GmMGzcOBoOh3uyhUCgUCuXvTPfu3fHAAw9U2+bVV19FWFgYduzYAZPJBABo1qwZHn/8cfz444+466676jz32LFj0bJlSzz77LNYsWIFpk6dyrfjoiOq45133sHy5csxefJkvPvuu2AYht83adIk5ObmYuXKlbWyk0Kh/EMhFAqFch35/PPPCQDyxx9/8NtGjx5NAJDZs2fz20pKSohWqyUMw5Cvv/6a356RkUEAkBkzZvDb7HY7YVnWa54LFy4QtVpN3nzzTX7bu+++SwCQDRs28NtsNhtp3bo1AUC2b99OCCHE4/GQFi1akH79+hGPx8O3tVqtJDk5mfTt27faNW7fvp0AIG3atCEOh4PfvmTJEgKAHDt2zGtMMXPmzCEMw5DMzMx6O0azZs0ier2enD592muuV155hcjlcpKVleUz14ULF6pd56RJk4jJZCJut9tvG+H5zs3NJW3btiUpKSnk4sWLfJtVq1YRmUxGdu/e7dV32bJlBAD59ddf+W16vZ6MHj3aZ55Ro0YRmUzm9b7i4M4hZ0ufPn28zuvkyZOJXC4nZrO52vX6448//iAAyOeff+5338qVK332vfjiiwQAsdvt1Y4PgDz99NP86wsXLhAA5I033iAFBQUkLy+P7Nixg3Tq1IkAIN98841XX3+Pr776ihBCyP/+9z8CgCxevNhrXo/HQwoKCrweLperJoeGQqFQvPB3DaDX60lmZia55557iF6vJ/Hx8eS9994jhBBy9OhR0qtXL6LT6UhSUhJZvXq115hFRUXkhRdeIO3atSN6vZ4YjUbSv39/cvjwYZ/5L168SAYNGkR0Oh2Jiooizz33HNmyZYvXNQDH77//Tvr160dMJhPRarWkR48eZM+ePQHXyF0DrFmzhrz11lskISGBqNVq0rt3b3LmzBmvtrt27SIPPPAAadKkCVGpVCQxMZE899xzPtcGdT1GhFReM0yaNIkkJiYSlUpFUlNTydy5c32uny5fvkxOnjxJnE5nwLV+9dVXpHPnzsRgMBCj0UjatWvn9b9E6nwXFxeTW265hSQkJJCMjAxCSOV13PTp00lqaip/HF588UWv/49S/8eE1wPZ2dnk0UcfJXFxcUSlUpFmzZqRJ554gr8O42zZs2cPmTx5MomMjCQ6nY4MGTKEXLlyJeBahXDneN26daSsrMzv/8bS0lKiUCjIiy++6LXd4XAQg8FAHnvssWrn4f7fz58/X3JuIcePHycAyOOPP+63rxQWi4WEhoaStm3bVns9R6FQKDWBhlpTrjmNKZ9PY7KF4su4ceP456GhoWjVqhX0ej2GDx/Ob2/VqhVCQ0O98tio1WrIZJVfbyzLoqioCAaDAa1atcLBgwf5dlu2bEFCQgIGDx7Mb9NoNHj88ce97Dh8+DDOnDmDf//73ygqKkJhYSEKCwthsVhw5513YteuXT7hyVKMHTvWy9Oue/fuAOBlu1ar5Z9bLBYUFhaiW7duIITg0KFD9XaM1q1bh+7duyMsLIxfT2FhIfr06QOWZbFr1y6+7fLly0EIqdbbkZvfYrFg27ZtAY9FdnY2evbsCZfLhV27dqFp06ZetrVp0watW7f2so0LHZbySBXi8XiwYcMGDBo0SNKzUPjLPQCMHz/ea1v37t3BsiwyMzMDrqOmcCHzarXaZ59Go/FqU1NmzJiBqKgoxMbG4o477sC5c+cwb948DB061Kvdvffei23btvk8evXqBQB83iaxt2NpaSmioqK8HuKq2RQKhVIfcB79TZo0wTvvvINmzZph4sSJWL58Ofr3748uXbpg3rx5MBqNGDVqlFdKCS7qYeDAgVi4cCFefPFFHDt2DD179vQKO+WiHn766Sc8++yzeO211/Dbb7/h5Zdf9rHnl19+QY8ePVBWVoYZM2Zg9uzZMJvN6N27N/bv3x/UmubOnYvvvvsOU6ZMwdSpU/H777/j4Ycf9mojjHpYunQp+vXrh6VLl0oWBKvLMeKiHr744guMGjUK//nPf3Dbbbdh6tSpeP75573mmTp1Ktq0aYOcnJxq18dFPYSFhWHevHmYO3cu7rjjjmpT0nD/2/Pz87Fz5060atWKj3pYsGABBg0ahKVLl2LIkCFYtGgRHnzwQb7vqlWroFar0b17dz5ceMKECQCuRj18/fXXePDBB/Gf//wHjzzyCHbu3Amr1eplwzPPPIMjR45gxowZePLJJ/H9999j4sSJ1a7VH2PHjoXJZIJGo0GvXr187i+OHTsGt9vtc22iUqnQsWNHyeu82uIv6sFqtXpdW3EPt9sNANizZw/MZjNGjBgBuVxeb/ZQKEDjuvduTLb8I7jeyich0r9+Uf6+1Pf5fvvtt8l333133W05fvw4eeCBB0hycjLRarUkIiKCdO/enWzcuFGyPcuy5IMPPiAdOnQgGo2GhIeHk169ekn+Ii8GfjyeuIdMJiNNmjQhQ4YMIYcOHfLp6+8xYcIEn7l27dpFhg0bRuLj44lSqSQmk4mkp6eTN954g+Tl5dXsIEngz9tBo9H4tO3Zsydp3bq1z/amTZuSgQMH8q9ZliULFy4kzZs3J3K53GuNvXr14tu1bNmS9OjRw2c8zuOL83ZYs2ZNtccNACkuLva7Ru7XaKEXIiFXz9vy5cv5bZmZmWT06NEkLCzMZ44VK1bU2zHSarXVrmfhwoV+1+OP/Px80qZNGwKAJCQkkLFjx5LNmzd7teHOt8FgIKGhoSQ3N9dnHG4Mf49nn32Wbyvl8ZiXl0cAkNdee61aezlbfv/9d6/t3PnasWNHDY9AJdfL43H8+PFk27Zt5OeffyYHDhyQHEfcV4oNGzZIejy6XC6ybds2sm3bNt5W+n+bQqHUBRr1QKMe/g5RD7/++iu5//77yaeffkr+97//kTlz5pCIiAii0WjIwYMH+Xbr1q0jAMiuXbt8xhg2bBiJjY2tdp7qPB4/++wzUlBQQC5fvkw2bdpEmjVrRhiG4Y+B+F5B/Ni7dy8h5Or7Uvi5IIQQt9vtE/UgPG61heoA/yz+rjqAmLfeeosAIG3btvXZ53Q6ycyZM0lycjJRqVQkOTmZzJo1K6goouq+A7iHQqEgycnJ5JFHHiHnzp3z6evvMWfOHJ/5Nm7cSAYOHEiio6OJUqkkYWFhpHv37mTBggWktLS0RseE5nik3PDMnj0bDzzwAIYMGXJd7cjMzER5eTlGjx6N+Ph4WK1WfPPNNxg8eDA++ugjPgcdx6OPPorVq1dj1KhRmDhxIiwWCw4dOoQrV67U2oYRI0bg7rvvBsuyOHnyJD788ENs3rwZv//+Ozp27Mi369u3r+Sv5y1btvR6PX36dMyaNQspKSkYM2YMUlJSYLfbceDAAbz77rtYsWIF/4tqfePvV1Z/2wkh/PPZs2dj2rRpePTRRzFr1iyEh4dDJpPhueeeC8ozUQzXZ/78+V7HUUgwufAC2c6yLJ/v8OWXX0br1q2h1+uRk5ODMWPG+Nhel2Pk8XjQt29fvPTSS5Jtxe+FYIiOjsbhw4exdetWbN68GZs3b8bnn3+OUaNGYcWKFV5thw4dipUrV2LJkiWYM2eO1z6Px4P27dtj4cKFkvM0adKkxrZVRzDHq76Ii4sDUFmwR0xubi7Cw8MlvSGDoUWLFujTp0+d7AOA1q1bAwCOHz/utV2hUPDjZ2dn13keCoVCqQ4pj/6zZ88GFfXAwbIszGZzjaMeXnjhBX4bF/Xw+uuvo6ioyMvGO++8E6tWrYLH4+EjLfxRXdRDu3btAPhGPdhsNq+oB2FRsrocI3HUA0efPn0wd+5c7Nq1i/fGXL58OZYvX17t2rj5uaiH/v37V9s2OzubH3/Xrl1ISEjwsk0Y9cAhjHro1q2b37HrI+ph0aJFyMzMxM0331ztOji6devmZdPgwYPxwAMP4Oabb8bUqVOxZcsWAIGjHmob8QBU3lcIiYqKwooVK3yOwfjx4yUL2dx0000A/Ec9HDt2DJ06dfLaVlBQgMjIyFrbTKHUlcaiAwjJzs7G7NmzodfrJfePHDkS69atw6OPPoouXbrg999/x7Rp05CVlYWPP/641vM+++yzuOWWW+ByuXDw4EF8/PHH2LRpE44dO8bXNwCu6gVihJ9vj8eDxx57DMuXL0f79u3x1FNPoUmTJigvL8fevXvx+uuv44cffsDPP/8ctH1UeKRQ6om7777b50M8ceJEpKWlYeHChV7C49q1a7FixQp8++239VoVTpww+rbbbsPgwYPx4Ycf4qOPPuK3t2zZMmBi6TVr1mDWrFkYPnw4Vq1a5VPZdtGiRVi0aFG92V6frF+/Hr169cKnn37qtd1sNntdIDVt2hQnTpwAIcTrolNcaZorWGIymepF2PHHsWPHcPr0aaxYscJLGA4mdLmmpKamoqKiot7Xo1KpMGjQIAwaNAgejwdPPfUUPvroI0ybNs2rsuMzzzyD5s2bY/r06QgJCcErr7ziZduRI0dw5513+twgiJHaHxUVBZPJ5COcNQYSEhIQFRUlGdaxf/9+v8L2taRVq1Zo0aIFNmzYgMWLF/u9cKJQKJSGQqPRICoqymtbSEgIEhMTfb73Q0JCUFJSwr/2eDxYsmQJPvjgA1y4cAEsy/L7hGGnmZmZSE1N9RlPXIX4zJkzAIDRo0f7tbe0tBRhYWHVrkksGnLthbZnZWVh+vTp2Lhxo9d2bg4hdTlGZ86cwdGjR336c9TmR/CnnnoKa9euxYABA5CQkIC77roLw4cPlxQhH3nkESgUCpw8eRKxsbFe+86cOYOTJ0/W2raCggKUlZXxYm4ggjkvtaF58+a499578e2334JlWcjlcl5YdjgcPu3tdruX8FxTpk+fju7du0MulyMyMhJt2rSBQuF7qx/oR0qj0QgAqKio8FkPdz26cuVKrFq1qta2Uih/Z6ZMmYJ//etfYFnWp5jjH3/8gbVr12LatGl48803AQBPPPEEIiMjsXDhQkycODHoHzzENPYCU402x+OYMWNgMBiQlZWFgQMHwmAwICEhAe+//z6Ayhv03r17Q6/Xo2nTpvjyyy+9+hcXF2PKlClo3749DAYDTCYTBgwYgCNHjvjMlZmZicGDB0Ov1yM6OhqTJ0/G1q1bwTAMduzY4dV237596N+/P0JCQqDT6dCzZ89qc5dw7NixAwzDYO3atXj77beRmJgIjUaDO++800fk2L17N4YNG4akpCSo1Wo0adIEkydP9vkVrK7HCKgUYp577jk0adIEarUazZs3x7x583w8q3Jzc5GRkQGXyxVwrV9//TXS0tJgNBphMpnQvn17LFmypNo+JSUlSE9PR2JiIk6dOgWg8p/yjBkz0Lx5c/44vPTSS17/rBmGgcViwYoVK8AwDBiGwZgxY/j9OTk5eOyxxxAfHw+1Wo3k5GQ8+eSTcDqdXvM7HA48//zziIqKgl6vx3333YeCgoKAaw2EXC5HkyZNYDabvbYvXLgQ6enpuO++++DxeGCxWOo8lxTcr8PCvD7BMn36dERGRuLTTz/1ER2ByovYmTNn1tXEBkEul/t4q61bt84nP1G/fv2Qk5ODjRs38tvsdjv++9//erVLS0tDamoqFixY4HMhBqBe3iuc3YC3px0hJODnpzYMHz4ce/fuxdatW332mc1mPtcPEPznX+wJIpPJ+H+eUhfZ06ZN43Ndffjhh1625eTk+JwHoNJbQPh50ev1Pp8vmUyGIUOG4Pvvv5cU+BrCk7Em3H///fi///s/XLp0id/2888/4/Tp015eCC6XCxkZGZLekQ3NzJkzUVhYiMcff1zyvF/vY0ihUP7e1DXq4fnnn0ePHj3wxRdfYOvWrdi2bRvatm1b56gHqfy427Ztq9eoh02bNuHll1/Ghg0bsG3bNt7bsCGiHvyt5/777w+4HjFc1MPGjRsxePBgbN++HQMGDJAUbIcOHQqz2Sx5fcNFPfiz7amnnqqxbdXRkFEPTZo0gdPp5K9bAkU9CL2Sakr79u3Rp08f9OrVC+3bt5cUHYPBX9SDwWBAnz590KdPH6SkpNTazmCgOgDVAW5UHWDXrl1Yv349Fi9eLLl/9+7dAICHHnrIa/tDDz0EQgjWrFlTq3mlqK0OYLVaMW/ePLRt2xbz58+XdPKIi4uTzIdcHY3a45FLmtyjRw+88847WL16NSZOnAi9Xo/XXnsNDz/8MIYOHYply5Zh1KhRuPXWW5GcnAzgamLpYcOGITk5Gfn5+fjoo4/Qs2dPnDhxgv9i5xJL5+bmYtKkSYiNjcWXX34pWbzgl19+wYABA5CWloYZM2ZAJpPh888/R+/evbF7926kp6cHXNPcuXMhk8kwZcoUlJaW4p133sHDDz+Mffv28W2EiaUjIiKwf/9+LF26FNnZ2Vi3bl29HSMusXROTg4mTJiApKQk/Pbbb5g6dSpyc3O9PjBTp07FihUrcOHChWoLTHCJpe+8807MmzcPAHDy5En8+uuvmDRpkmSfwsJCPrx0586dSE1N5RNL79mzB+PHj0ebNm1w7NgxLFq0CKdPn8aGDRsAVCaWHjduHNLT03mPQs47jUssbTabMX78eLRu3Ro5OTlYv349rFarl5j2zDPPICwsDDNmzMDFixexePFiTJw4sVYffi40prS0FBs3bsTmzZu9kmGXlZVh//79eOqpp/Dqq69i6dKlqKioQHJyMubOnesVHlNX/CWWttvtPr/AAJUefSqVCqdPn8bp06cxbty4oC6mGxsDBw7Em2++ibFjx6Jbt244duwYVq9e7XOhNGHCBLz33nsYMWIEJk2ahLi4OKxevZov8sF90cpkMnzyyScYMGAA2rZti7FjxyIhIQE5OTnYvn07TCYTvv/++zrb3bp1a6SmpmLKlCnIycmByWTCN998U+df3aV48cUXsXHjRgwcOBBjxoxBWloaLBYLjh07hvXr1+PixYu8d2iwn/9x48ahuLgYvXv3RmJiIjIzM7F06VJ07NgRbdq0kewzf/58lJaW4umnn4bRaMTIkSPxyCOPYO3atXjiiSewfft23HbbbWBZFhkZGVi7di22bt3Khw6lpaXhp59+wsKFCxEfH4/k5GR07doVs2fPxo8//oiePXvy3yG5ublYt24d9uzZg9DQ0Po+pHjvvfdgNpv54gXff/89H5L8zDPPICQkBADw6quvYt26dejVqxcmTZqEiooKzJ8/H+3bt8fYsWP58XJyctCmTRuMHj06qDC3YDl9+jS++OILn+0xMTHo27cvAODf//43jh8/jjlz5mD//v146KGHkJycDIvFguPHj+Orr76C0WgM6OFDoVAo1xoa9RAYGvVwbTh//jw0Gg1/Ld2uXTsoFAr8+eefXtf7TqcThw8frtd7gNrSvXt3hISE4Ouvv8bUqVMDphBoKKgOQHWAG00HYFkWzzzzDMaNG4f27dtLtuGEU7F3s06nAwAcOHCgRnNWR6ACU2JCQ0OhUCj4AlNTpkyp3wJTNcoI2UDQxNI0sfTfIbE0x4QJE/gkrTKZjDzwwANehUcOHjxIAJCIiAgSExNDPvjgA7J69WqSnp5OGIbxKcYhBfwUl3jjjTdIQUEBycvLIzt27CCdOnUiAMg333zj1dff46uvviKEXC2uIi4u4fF4fBJLB5MItzr8ff71er1P2549e0om6W3atCm55557+Nd2u5288MILJC4ujmi1WnLbbbeRvXv3kp49e5KePXt69T1//jy55557iFarJVFRUeSFF14g33zzjWTRkUOHDpGhQ4eSiIgIolarSdOmTcnw4cPJzz//XO0auc//unXrvLZz501YhOTEiROkT58+xGAwkMjISPL444+TI0eO+LSr6zEihJDy8nIydepU0rx5c6JSqUhkZCTp1q0bWbBgAXE6nV5zBfP5X79+PbnrrrtIdHQ0UalUJCkpiUyYMMGrgIzU+WZZlowYMYIoFAr+u9jpdJJ58+aRtm3bErVaTcLCwkhaWhp54403vJIZZ2RkkB49evDFcoTfBZmZmWTUqFEkKiqKqNVqkpKSQp5++mn+O9hfUmnufHHf/8HStGlTv58t8bE7fvw4ueuuu4hOpyOhoaHk4Ycf9inWxL0/hGvyeDw+BXakEk37o7rPv/izQQghO3bsIA888ACJi4vji0t16dKFzJgxQ7IwEIVCodSEhrgG6Ny5M7njjju82qxdu9bne27BggVB3QOwLEtSU1NJixYtSHl5uc/8V65cqXaNwV4DHD16lADeBec8Hg+555576v0aYObMmQQA2bJli0/bkpISr2u7y5cvk5MnT3pdF0hRWFjos+39998nAMjx48cJIb7ne8qUKQQA+eCDD/g+y5cvJwDIRx995DOe1WolFRUV/OuYmBhy7733+rSryT1AfVwDSL0HDh8+TJRKJRk8eLDX9v79+5O4uDhSVlbGb/vkk08IAK97AIvFQk6ePEkKCgr4bdUVlhC/v8TU5Frh7bffJgDIiy++KFlAZvr06QSAl221heoAVAf4u+gA7733HgkJCeG/D6S+j7l7zFWrVkmurV27dtXOcSMXmGr0wqP4i7xjx47EYDD4LDI0NJQ88sgjkuO73W5SWFhICgoKyM0330yGDBnC7+vbty9JSEjwGY/7IuK+cDixaMWKFT4HfNy4cUStVvt8wQnh3hDvvPOO13Zu3P/973+S/SoqKkhBQQHZuXOnzxugrsfo5ptvJv379/dZz08//UQAkC+++MLvevwxY8YMIpfLqxXPuPP93XffkZYtW5KWLVuS7OxsrzaDBw8mbdu29bHt9OnTBAB56623+LZSXzgsyxKTySR5MSJly9q1a722f/vttwQAOXLkSHALF3Dy5Emybds2smLFCnLPPfeQ++67z0tQ2LVrF/8BFwpb5eXlJDIyktx2220B5/AnPIofJpOJzJs3z6fvvffey1enFT44O1etWkUAkE8++cSrb0lJic8cf8cqdIsWLSIAfN6XFMr1prS0lAAgr7/++vU2hUKhUOpMQwiPnCgyZswY8vHHH5NnnnmGhIeHk5SUFC/hsby8nDRr1oxotVryyiuvkCVLlpD09HTSsWNHAoDs2LGDb7t9+3ai0WhIUlISmTFjBvn444/JjBkzSI8ePcjAgQOrXWOwwqPT6SSpqakkMjKSvP3222Tp0qXkjjvuIB06dKh34dFisZDOnTsThUJBxo0bRz788EOyYMECflyhoBSs6DBkyBDSo0cPMnPmTPLJJ5+QadOmkdDQUNKxY0f+HknqfD/++OOEYRj+RpxlWXL33XcThmHIQw89RJYuXUoWL15MnnjiCRIeHu7V9+677yZ6vZ68++675KuvvuKvq7Ozs0lsbCzR6XTkueeeIx999BGZOXMmadu2LSkpKfFrCyG1Ex579epF7r77bvLWW2+Rjz/+mDz33HNEp9ORkJAQcuLECa+2Bw4cIGq1mnTq1Il8+OGH5LXXXiMajYbcddddknYIxaL6EB5HjBhBVq1a5fP47bff+LYsy5KRI0cSAKRDhw7kzTffJJ999hl59913ycMPP0xUKhWJjo6WFOJrCtUBqA7wd9ABCgsLSXh4OFmwYAG/Ter72GazkaZNm5KYmBjyzTffkIsXL5I1a9aQiIgIolAoSGpqarXzBFPVmntERUWRlStX+vQdP368pA7AOXbMmjWLACA//fST19yHDh3ymaMmPz406lBrmliaJpa+ERNLt27dms+PMmrUKNx1110YNGgQ9u3bB4ZheNdqLiSUw2AwYNCgQfjiiy/gdrtrlZuFq1Qnk8kQGhqKtm3bSlbOS0xMrFViaYPBwIf8/Pjjj5g/f36NbWxs2Gw2L3d3u92Ojz76CC1atPCqskihNAb++OMPAFerT1IoFArFm1dffRUWiwVffvkl1qxZg86dO2PTpk1e4bxA5TXNL7/8gmeeeQZLliyBwWDAqFGj0K1bN9x///182hUAuOOOO7B3717MmjUL7733HioqKhAbG4uuXbtiwoQJ9WK3UqnE999/j2effRZz5syBRqPBfffdh4kTJ6JDhw71MgeHTqfDzp07MXv2bKxbtw4rV66EyWRCy5Yt8cYbb/CpQWrCyJEj8fHHH+ODDz6A2WxGbGwsHnzwQcycObPacN1ly5ahoqICY8eOhdFoxL333osNGzZg0aJFWLlyJb777jvodDqkpKRg0qRJaNmyJd+XK974+uuvw2azYfTo0ejatSsSEhKwb98+TJs2DatXr0ZZWRkSEhIwYMAAPqSxPhkyZAhWr16NhQsXoqysDFFRURg6dCifo05I586d8dNPP+Hll1/G5MmTYTQa8dhjj2HOnDkB5yFVeSfrEv741Vdf4auvvvLZPnr0aNx6660AKlMMrVq1Cvfffz/++9//YunSpSgpKYHBYEC7du3w9ttv4/HHH2/QdExUB6A6wI2kA7z++usIDw/HM888U207jUaDTZs2Yfjw4XwuXbVajXfeeQdvv/12nT5Tjb3AVKMWHuuaWHratGl49NFHMWvWLISHh0Mmk+G5556rc2Jpf1VH6zOxdHFxMV5++WW0bt0aer0eOTk5GDNmTIMkln7ppZck2wr/sQcLl1h669at2Lx5MzZv3ozPP/8co0aNwooVK7zaDh06FCtXrsSSJUt8/tlyiaUXLlwoOU+TJk1qbFt1NGRi6QceeAATJkzA6dOn0apVKz6vSExMjE/b6OhouFwuWCyWWl30BfoiCRZ/iaUVCgU/Ppe77kZn6NChSEpKQseOHVFaWoovvvgCGRkZWL169fU2jdIIqKiokCwoJCQqKqp+c6BIcPToUT6XZUREBO65554GnY9CoVCuBWPGjPEqBgAAy5cvl8xrKy70wHHx4kWv12q1GgsWLMCCBQsC9k9OTsb//d//eW3jcpslJiZ6be/YsSO++eYbSRuq44477pC8nmzWrJnP9jZt2kjmdBS3q+sxAirvW2bPno3Zs2f7N76aucTcf//9AYvSSJ1vmUyGL7/80qv4hVKpxEsvveT3HoWjVatW2Llzp+S+pKQkn3uPQLYA/s9XdTz77LN49tlng25/++23ByxKImVHeXk5gMp8o9W1k0Lq/RaIIUOGYMiQITXqU19QHYDqADeKDnDmzBl8/PHHWLx4MZ/nHah0ZnG5XLh48SJMJhPCw8MBAG3btsXx48dx4sQJlJSU4KabboJWq8XkyZPRs2fPWq+DKzBVV4Q6wL333stv5wpMAcCePXtqPG6jFh7rAk0sHRiaWPrawFUh436lio+PR2xsrE+FZaAyEa5Go+F/abhetGrVCi1atMCGDRuwePFi6PX662pPQ9KvXz988sknWL16NViWxU033YSvv/7aqyAQ5Z/LggUL8MYbb1TbJlCy7frg22+/xdy5c9GlSxcsWrTI66aDQqFQKLWDRj1QbiRo1ENwUB0gMFQHqD9ycnLg8Xj8/gCRnJyMSZMmeRXsYRgGbdu25V//8MMP8Hg8Dfr+CpaGKjB1fcpUXQPkcrmPSr1u3Tofsadfv37IycnBxo0b+W12ux3//e9/vdqlpaUhNTUVCxYskPR+qW3JdSm7AW+FnRASsAx9bRg+fDj27t2LrVu3+uwzm81wu93869zcXGRkZMDlclU7ZlFRkddrmUyGm2++GcDVKk5Cpk2bhilTpmDq1Kn48MMPvWzLycnxOQ9A5UWixWLhX+v1epjNZp95hwwZgu+//x5//vmnzxj14ckoRsrt2+VyYeXKldBqtV4XCQ8++CAuXbrk9Y+ksLAQ//vf/9C7d2/+A+5yuZCRkYHc3Nx6tzcQM2fORGFhIR5//HHJ817XY/j++++jWbNm0Gg06Nq1K/bv31+n8WrLc889h+PHj6OiogI2mw0HDhygoiOFZ9SoUdi2bVu1D3GISEMwc+ZM2O127NmzB7fcckuDz0ehUCj/BIYOHYoJEybgww8/5H/cycjIwMyZM6+3aZRGQEVFBfLy8qp9CMN4G4q9e/di9uzZeOGFF9CqVSuvVE0UX6gOEBiqA9Qf7dq1w3fffefzaNu2LZKSkvDdd9/hscce89vfZrNh2rRpiIuLw4gRI/jtVqsVGRkZkhWoGxKdToeXXnoJx48fxyuvvCJ5vGpzDP+2Ho8DBw7Em2++ibFjx6Jbt244duwYVq9ejZSUFK92EyZMwHvvvYcRI0Zg0qRJiIuLw+rVq/m8LpyKLpPJ8Mknn2DAgAFo27Ytxo4di4SEBOTk5GD79u0wmUz4/vvv62x369atkZqaiilTpiAnJwcmkwnffPNNrXINBuLFF1/Exo0bMXDgQIwZMwZpaWmwWCw4duwY1q9fj4sXL/K/Ck2dOhUrVqwI6Nkzbtw4FBcXo3fv3khMTERmZiaWLl2Kjh07ok2bNpJ95s+fj9LSUjz99NMwGo0YOXIkHnnkEaxduxZPPPEEtm/fjttuuw0syyIjIwNr167F1q1b0aVLFwCV/wy4EMT4+Hg+d+Ls2bPx448/omfPnhg/fjzatGmD3NxcrFu3Dnv27EFoaGi9Hs8JEyagrKwMPXr0QEJCAvLy8rB69WpkZGTg3Xff9XLBnzp1KtauXYv7778fzz//PEJCQrBs2TK4XC6vkJecnBy0adMGo0ePDirMJVhOnz6NL774wmd7TEwM+vbtCwD497//jePHj2POnDnYv38/HnroISQnJ8NiseD48eP46quvYDQaA+YzkWLNmjV4/vnnsWzZMnTt2hWLFy9Gv379cOrUKURHR9d5fRRKfZGSkuLzf4NCoVAofw9o1AOlOhpL1MNHH32EdevWoXv37li6dGm9eSD9XaE6QGCoDhBab8cyMjJSMiUB5+Eo3jd8+HDEx8fjpptuQllZGT777DOcP38emzZt8op63L9/P3r16oUZM2bU649hBw8elNQBUlNT+Tyvr7zyCk6ePIn58+fjxx9/xP3334/ExESUlJTg4MGDWLduHaKjo71yIQck6DI0DUhDVLSz2+3khRdeIHFxcUSr1ZLbbruN7N27l/Ts2dOroh0hhJw/f57cc889RKvVkqioKPLCCy/wpc6FVYcJqazmM3ToUBIREUHUajVp2rQpGT58OPn555+rXWOwFe0IIeTEiROkT58+xGAwkMjISPL444+TI0eO1HtFO0IqK/pNnTqVNG/enKhUKhIZGUm6detGFixYQJxOp9dcCKKi3fr168ldd91FoqOjiUqlIklJSWTChAkkNzeXbyN1vlmWJSNGjCAKhYKv2OV0Osm8efNI27ZtiVqtJmFhYSQtLY288cYbfNUlQgjJyMggPXr0IFqtlgDwqmyVmZlJRo0aRaKiooharSYpKSnk6aefJg6Hw68thNSuot1XX31F+vTpQ2JiYohCoSBhYWGkT58+fiuVnTt3jtx3333EZDIRrVZLevfuTfbv3+/Vhnt/CNfk8XgIAPLss8/6tBNWuPIHJKpecQ/xZ4MQQnbs2EEeeOABEhcXR5RKJTGZTKRLly5kxowZXue1JqSnp3tV5WZZlsTHx5M5c+bUajwKhUKhUCg3Du+99x5p2rQpUavVJD09nezbt+96m0Sh+HDu3DnJ6q/Ch81mu95m3tBQHYDqAH8HHUAKf+di3rx5pHXr1kSj0ZCwsDAyePBgcujQIZ92UpXtz58/TwCQhQsX+rQLtrK9v4e4OjghhHz33Xfk7rvvJlFRUUShUJDQ0FBy++23k/nz5xOz2Rz0sSCEEIaQBog5/RuwePFiTJ48GdnZ2TTHC6VRUVZWhpCQELz++uuYNWvW9TanxjidTuh0Oqxfv97rF6DRo0fDbDbjf//7n08fh8Ph5aLv8XhQXFyMiIiIgLk/KBRKYAghKC8vR3x8PPWkoFAoDcqaNWswatQor6iHdevW0agHCoXSKKA6AKWxcvToUXTo0AGffPJJteHbjZG/bah1TaCJpSk3Ejd6YunCwkKwLOtT1TsmJgYZGRmSfebMmRMw1IVCodSdS5cu+VRypVAolPpk4cKFePzxxzF27FgAwLJly7Bp0yZ89tlnXgUGKBQKpaGhOgDlRuJG1gGo8IjKxNJJSUno2LEjSktL8cUXXyAjIwOrV6++3qZRGgEVFRWSiYSFREVF8QmBG4qjR4/yOSwiIiJwzz33NOh8jYmpU6fi+eef51+XlpYiKSkJWVlZMJlMXl6PhBAQQuDxeADA67x4PB4+WTLDMHxbzsNLoVDwY9XWk9KfE3ldx+PWxDCMX480bs018Vgjokp+QrhjJLRDeHzq6jDPHX/OBplMBkII3G43v024H6g8R+L1iW0LhvqwXwqWZb3WIrRL+L6UyWQN7q0bzHHhjkNZWRmSkpK8cstQKBRKfeN0OnHgwAFMnTqV3yaTydCnTx/s3bs3qDE8Hg8uX74Mo9FIox4olHrinxr5QHUASnU0Fh1g79692L59O955550btsAUFR5BE0tTqqexJJb+9ttv+YqLixYtgslkatD5GorIyEjI5XLk5+d7bc/Pz/dbHVitVkOtVvtsN5lMfoVHDuE+j8cDlmW9hC5OCBKKjuJ+NaGhhEcOf+JibURHbnzx8ZMSFxtCePRnD8uyvMjKzcWyLJRKpeT6GpPwKHz/id9PQhGVe92QN801ER6FrykUCqWhqE3UgzjdSk5Ozg3p7UGh3Aj80yIfqA5AqY7GogP8HQpMXdccj++//z7mz5+PvLw8dOjQAUuXLkV6evr1ModCkeT8+fM4f/58tW1uv/32mlV1+ofTtWtXpKenY+nSpQAqRbOkpCRMnDgxqDArLs+l2WyWFB6l/gKA2+328j6Ty+X8FzcnBjVmpNYEICgRK1ihTShWVdentvuk5hLCiY6cSCeXy/lfETkvwUBj12cbf3ZWh/AYir1q60tsrK1wKjU35/EYGhqK0tLSG/ZHDQqF0vi5fPkyEhIS8Ntvv/HVMwHgpZdews6dO7Fv3z6fPjNnzpS88bt06RL9vqJQ6omysjI0adIEZrMZISEhDT4f1QEoNwJUB6g/rpvH45o1a/D88897JZbu168fTSxNaXSkpKQgJSXlepvxt+L555/H6NGj0aVLF6Snp2Px4sWwWCx8vqea4s+ziwttFQp2QpGuoT3OGhKPx+MVet0Qv3zV9nepmvQThltz54oLU66tKHy9a6Zx7y3Ou5Zbm9irti5ci3NDoVAo9U1toh7E6VY4gYSLeqBQKPXHtbgupjoA5UaB6gD1x3Xz0RQmlr7pppuwbNky6HQ6fPbZZ9fLJAqFco148MEHsWDBAkyfPh0dO3bE4cOHsWXLFp/Qq7ridrt58QfwDhMWinU3grejEHE4eXVUtzZun7CNv/ZSbWuDeC5OoJOaRy6XQ6lUBm1jMPMG01fcpqbthQhF72sd0ixe8430HqdQKH9PVCoV0tLS8PPPP/PbPB4Pfv75Zy8PSCFqtZoXGanYSKHc+FAdgEL553FdPB5rmlhanNvF4/GguLgYERER9EaKQqknrnVS6YkTJ2LixIn1OqZUCDLnFSgUfjjRMZjvj7p6iNXHd5TQBuFzj8cDuVxe7/koq2tb19yI4rVIhTO7XK56L75Sm7XW1/hSot+18Dyk3o0UCqUxUt9RDxQK5caB6gAUSuPjWugA10V4rGli6Tlz5gRM6kmhUOqHGzWptFgY40KRhXC5AuujiMy1RqpS941iuxgpL0BhcRyhl+ONhHAtnLgt/Od9I4f2UygUSn3x4IMPoqCgANOnT0deXh46duzYIFEPFAql8UF1AAql8dKQOsANUdVanNultLQUSUlJNKn0NUCYf02sfou9lbjKs1x+Nn/FKTgvLfF2liWQy2Xg7suFu1nWA7lcxt/QS+fqu3rjX9/eUv8EuJxJRqPxeptSK7jzLaxczW3n8uspFAqfkNfGKgaJw8O5/IdC0VFYsIT77AUqMCMcW2r/tfKS44rIcHAVxqXyIFYXKu6PhlpHoPeK8LtPbAsnHgdbaKYhz8e1PNcUCoUipiGiHigUyt8PfzrAtt9jEGoEWMLAg8prKRkIPGAgA4GcqbzGYYnvdRa3DwDkIGCr+ku1FY5d3Zji8eW4OgcLxm8fF2SQg0DJePg+DIDaXKExAORV07ASAygZwCOxj4j6csgAyAGwqOxXE8Q+c56qbaqq614nIfAAUFbtZ6vmAgB5gGttlhAoGQZyMGBB+LG5eTichPBjKkVjVreeynVXjs0h594jVfNJ9eHGlYna+6Mmx1RsEze+8N6OBYFdsGYO4fnjzim3ncNpIeh8S0GD6gDXRXisaWJptVoNtVrts53mebk2+Ls5FYodXDirzWaDWq2G2+0GACiVSi+xx+Vy8eKCXC4Hy3qqhEYGAAOZjAHr5sYksNvtIAD0Oi0vqjAyVPWr/KDJ5VeFSJmMAct6IJPRnGa15UY+ZkJPR2E+QKnq1Zzo1diLzAiFUmFYtZQ4x7Isv97GilShHw6lUunVRijSAY3zvSklKvqzk/uuDNSuurka4zGgUCgUCoVCCYb60gGMBgZag7e85amSf2oiPCpB4Gpg4dFJZF7zCvtf3VZ57a5iKlchFqWkgl+l2tRGeOTFsnoUHv3BCY26quMqZxiwhPAimBzVC4/CY6MEAxcIWEK8+nDHykoI/1zFMF7HMJj1yCA4TwGEROF411J4vErlPo1It+GOC0uEQri3DTIADka6UGt9cl2ER2Fi6SFDhgC4mlia/vrZeBEKBFzRDofDwecE0Ov1cDgccLvdsFqtAICwsDC4XC7eA+3ixYsoKiqC2WwGw8hw5UoBXC431Go15DIFZDIZSktLERISAkIILl26BIfDAYVCgZCQEMjlciSnNIVSqYLNZkNEeDhSmzeHTMbAYDBAo1FTwfEfBCfKcaIb5xUoLE4iVZhEKHoJqyj7K6pSU5vqE7GgJZUrULhGzuOzJrkfaxp6XpNjIs5JyRWSEZ4HcUhyTc9RXW2UslVoR6D2YrFbyhahN7Y/8TGYubjxamu/v3NNvzMpFAqFQqE0NPWlA3h8hBdphCIj4C36sYQBC8bbA1LwnGsrC9L/kOsrB5EUD6Xg5hDbGQzVZeKTEiA9fvYJxxHbXVtvR3/CqVD0UjFCYc97XzBwoiMLACLxUYgcVcKbhDgpFgyF24SelJW2E799/L32tSWwIBnovSMHAxnDwFN1je/lmVkl5PKCbtXx8fI4FQi9/Hm5BlFQ1y3UmiaWbpxU593I/S0vL4fZbIZKpQIhBHq9HkDljavVasWlS5cQGhoKl8uF/Px8vjKtTqdDeHg4YmJiUFBQgD///BMXL15EYUExLBYLwsLCUFJihtvtRkREBORyORwOB5xOJwoLC6FSqeB0OhERGY7Q0FAQD4HBYIBOtwdyuRzNmiWhRcsWaNGiOQwGA2QyJqibdcqNj1DQAvxX8xULLZxQJwzhF+6/HoiFOk50C0bU4kQ8lmW9Qq8DhVj7m786ggk5lkqzIEzbwD0Xrk8oJnPbuPUIUzRIzV+dyObPxpoitabqhGEpW7h1cGuqqX1S3qI1tV/cn4ZdUygUCoVCuRbUhw5QGVYtLfN4wMBTJehxIcwsvAVHIdxrDxjIQbzac6JjsN6OlX0EY1czr9gGbg4p0SmQ+Md5LLKk8q+UeMUJjWLPRuF+mWgf5yHpr4+4P9dOOL8/Mc6fF151uLgoMMF1tQfwCi+WmlcsSnJtWInxxH2BSpFTCn/nxZ+wyHp5wnJCte96pOeRHlMsZsqrvDtlDMMfL2GItZxheDGWC3GvqehbG66b8EgTSzc+pG48hYKj2+1GaWkpsrOzwbIsEhISYLfbIZPJUFRUhLKyMuTk5KCkpARGoxEVFRUwGAyw2WwwGAzQ6/UoLS1FZGQkrFYr2re/Gc2bt8TFC1nIy8uD2VwKrVaHgoICsCwLi8UClUoFhmHgdrshk8kQExMNt5uF0+GE3W4Hy7KwWq2IiorCwYOHsf+PP5CamoIePXqgZcvmUCqVPqIAFSD/Png8HrhcLh8xSuhB5090BLwFHLfbXacK0eKx64pYdAwmdyNQuSaFQsF7gErlU61v/I3vdru9xFCxwMvlcxTmgxULqUKhkgsll8o3W1PbgjlPgY6b0BtT/P4K1JdbM/fdFqiCnJSnayCCbcO91ygUCoVCoVAammupA3BejVJwIdFOIuNzQwLSORmDCa+W8l6UgwBMcIJlXZEKr65LO6BKgJMQE+sTVvS8uoRRfNsqrz5ORBMSjJ2c4CgM8UYQ/WqK2DvSI9oXbP1o775V4eUS72uunb91cPtluLr2ayE6Ate5uAxNLH39qU5sFG/LyclBYWEhHA4HdDodsrOzYbFY0LRpU5w7dw4WiwUAoNFo4HQ6odFoUFhYCI1Gg5ycHKhUKshkMpSXl+PKlSuIi4tHfHwCOqd1wrlzZ3H2zDnYbHa43S5cvnwZ0dHR0On0KC8vQ2hoCPR6PXQ6HRiG4UVNu90OAHC5XGAYBiajCcePH0deXh46d+6IXr168UlSqeD494MLbxVWROb+BhtGKvas40K0q/OsawjEno4AapWr8Wru06tedf5CemviCRnIZqltnADncrl89isUioBim5SgXBORrDaCZHXthMdQ6OlYEyFUuJ8TUYVentfa65Z7j3B5eSkUCoVCoVAamrrqAMGGWleHUJRUMt5SjQcMlIzHRzCUCsX2Ceeu8pyUCi+uL6SuoDmPx2CpLh+kv7kaQnwUevwFCvnlvPNcqPR+FOah5MapiX2qGl5rBxNKzUIoCopD/a96JSpx1TtRCn8eo1eFQ1LlkSrydIT0OeKOMZcv0sMI+gZYV31wQ1S1plx7uBtgLsQxLy8P+fn5qKiogNPphM1mg8PhQHZ2NgoLC5GVlQW1Wg2tVgu73Q6LxYKQkBDY7Xb+Br2srAwajYa/yc7Pz0NOTg7atWuHlJQUxMbE4sKFC9DptVAq5XCzLNQaJZwuFWRyBmAIlCoFWLcHJpMJOp0ObrcbGo0GNpsNLpcLSuXVPJE7d+4EAPTq1YsWIfqbIhTZuDyitRFrOAFIGHp9vbxjxeHINUUq9FoqfPlaICyKw3nWAah1WLtwPUJP5mstEotziQrtE4aYB7JHnHdUat+1oLZh2xQKhUKhUCjXC85DkasMLbWf80TkhERA2vtQKCKy5Kr3I+BdYEbcXgjXlyVMpZcjt73K69FVVWSGEzSFOSHrA05AZIlg7iDERWEYdSDRrjpPOmGYthzeIbyBisZcteWqAMlVrhaGOSsFYcKAt6hbKeYJC7D4F/ZkXvklr1bH5tYitT7Ok9B7DpFnLO816ycsWiD+cTZIeS6ygjyhLiIWtjm7vV9zuRuFFbyF+R2Fod2oEh2lKlw3FFR4pHghvKG32+0oLCxEWVkZioqKEBYWBo/Hg9zcXOTn58NutyMkJAR//fUXzGYzYmNj4XK5oFAooFAoUFZWBpvNBq1Wi8LCIqhUSshkMr5YDOe9dPr0KZjNZrRo0RJNkprAzbpBiEdQZMYDpTIBLMsiIiIC+XkFCAsLg9vthl6v5wvbqFQqNGvWDOXHy6o8Iwn+/PNPhIWF4V//+hc0Gs31PryUekYoAHGV0oHgi2ZItZPL5V7jNqQHmjjHHid4Cj0UazqnPwFLShCrjdgVrJgmXhsXAi4lfopDq4M5Z0KRz58AGIhg1i/exgnTUt6otcmPKVwPJ54L0wTURlQNpg/Xpi6CPYVCoVAoFMr1hMvLGGgfn6uxSgTkEOZz5EXDKvx5O/oLw5Yz0pWvuQI2kh6UAs/Iq3YHJlDV65qE8QY7R10IRnT06VNVRAWi6+vK8O/K8VxV4hlXtVpcaCXQ+CyIpEjor4CM+JgG6hsM3h6S3rYBvuvw5xXKeX0Gem9wxXgChbXXN3V9P1JuMITig7+bZJfLgfz8XGTnZKGiogwELNRqJex2OwghUKvVcDhc8HgAjwewWu2Ij09Efv4VOBxOXuBjGAZarRalpaUIDQ1FeHg47HY7GIZBQkICwsLC0KRJE2i1WqhUSuTmXgbDADfd1AY33dQG7du3h0wmQ7t27RAWFobY2FiEhIQgKioKBoMB4eHhUCgU0Gq1MJlMCA0NhUajwc033wy5XA61Wg273Y7du3dj3759fCghdwyoh8/fA6HoWFePPq4/Fz4rDuttqPeMWBSsLxFIPKbQo/Na5H0UClpyuRxyudwrZ2VNbRALdmIPQ+HcDYFUCLw/sbI2grHYo9Pf+PUJNz43H4XS0CxfvhwMw+DPP/+83qY0KlsoFAqFEjyVxWUYr9dS1ac5z0LeG7Eqf6OLyHzyP9amsjQHZ4ucF4uuipAe0Rxi8dEjelxdk/ejMSNeAwtB+HOAvlLrVDIM7xEYqPKy0FtPaINMYhv3kPIyFNukBOPl6djYz4EUctFDXIjnWnIjHj9KnSAQ5xrgbtzdbjccDhuuFOThwsXzKCq6AtbjAMOw0OrUADw4dOgIjhw5jtiYeJSaK/DnH4fAugk8LBAREQWlUgmHw8F7PkZHR6NZs2ZITExAREQEoqOjkZSUBLlcjtLSUhBCkJiYCIZhoFQqwDAAy7oRFxeLFi1SYTDocOLEcZhMBhgMBsjlcoSFh/FFZ+Li4qDT6WC1WuFyuWC12SCTyZCYmMiv7fLly9i4cSNOnTrFF7jg1kxvtm9suHyMDTEucDWnIOcVVl+IfwDg3pNC8bQ+BEgpoU5K2ApmrmDbcGvizo1QyBW3Ef6t7bq488+tpyY/KlR3rMVjSBX7qS/RUdhPeKxq+r7zN6/UdmEYPDfv9YKKP5S6MHv2bGzYsOF6m4GKigrMmDED/fv3R3h4OBiGwfLlyyXbjhkzxuf7h2EYtG7dOqi5GIbxyo128eJFr3HkcjmSkpJw33334fDhwz59/T2eeOIJn7l2796N4cOHIyEhASqVCiEhIejatSvefPNN5OfnB318KBQKpaHgQqrlDPErQMoFHo+c9yEAXoAEqi8AIzWmGH/9A4VoBysu+tsf7BUcF1LtzyMumPmDnasud9hcDsLg21aKkuKQZDn850/05+nI4UFlJWvxOoSeiMHYJvaW9Kq0Xc0aWa/3DPF61IXrKf7RUOt/HNI3oCzLori4GG63EyZjKLJJNoqLSxAeHgYAkMsJTmWchVwuR0W5Bb//vg/l5eUAAKfTBZvNhuTkZjCFGFBUVOjlzRQWFga1Wo0mTZrwFVxtNhuioqLw119/QaVSwW63Q6fT8TfdeXl5aN26NcLDw2Gz2WA0GpGfXwAAUCnV0On0iIqKQnl5OTQaDSoqKhAREQG1WgWnq7L4jdFoBMMwKCystOfrr7/G+PHjeVHSX7gk5cZBqVT65AusL7j3MBd6La4QXZ9eieLiLw2Fv1DrYMPRgx1f6L13LdYl9Nrjjqe/8OGaeloKhcyG/r4Qhl1za5AqDlSXsaXCy7n0GBTKjcjs2bPxwAMPYMiQIdfVjsLCQrz55ptISkpChw4dsGPHjmrbq9VqfPLJJ17bQkJC6mTDiBEjcPfdd4NlWZw8eRIffvghNm/ejN9//x0dO3bk2/Xt2xejRo3y6d+yZUuv19OnT8esWbOQkpKCMWPGICUlBXa7HQcOHMC7776LFStW4Ny5c3WymUKhUOoCX4laIOh5wPAFXrh9XLizj4cjnxfR1/OR28YJm+J2UnY4ibS04y+vpJzxFreEFbW5qtvS810l2CIx/hCLa9w4comlcl5zLJHeL7aP83oUCmbi0GGpys8eEMiIdwhydYVjWFwNt+a8E2UMAxkYeIivyCgeRwkGqBIa/c1R5eIAoDLEWxnEtbkcDDx+wrED3VWIC8eg6nVlnslKAuVmFIZTS1WxvlYVrQEqPP7jEIcmcjnl3G43VCoVLJZylJaWQqPRICwsFGVl5TCZTCCEwGAwICcnHwqFEufP/wWdTofQ0FDIZDJcvnwZsXExcLmdaNKkCT+Hw+GAwWBAbGws77HIVaJu3rw5IiMjcfbsWej1ehQWFkImk/Gh0/n5+TAYDDCZTLDbHVCpVLh06RLiYit/dXc4HIiLi8Ply5dhtVoRHx+PsrJS6PRaeDweOJ12hIaG4sqVK5DJZDh//jx2796NIUOGQKvVUtHxb0RDiVvc50VKBKpLXjx/+QmvVVitUIQSFmmpTfizEG5NUsKfeG3Veef5s8FfTkbhX2G16erGEM4vNZ9YqBN7bPrrV58Iw+PrKlBL5dy8lu89CuXvTlxcHHJzcxEbG4s///wTt9xyS7XtFQoFRo4cWa82dO7c2WvM2267DYMHD8aHH36Ijz76iN/esmXLgHOvWbMGs2bNwvDhw7Fq1SqoVCqv/YsWLcKiRYvq1X4KhUKpCVy4tT8PR/F2YUGXuuBvzmtJZThz1Q/vxDdPpBQuAigr9TUfWAIp/6R6RVwURQoPfIugAFWFUGp4reohBDLmauEYqVyNtQmh9sB//ki/wmiVLeL5q4PLZSn0dGTBVbS+fiHTtYWGWv/DYVmWz33odrugVmvgdDpRXFQCj4fA5XLB4/HAYDDizJmzOHzoMKxWKyIiIvhiM0qlkhchbTYrDAYDIiMjceXKFXg8Hj7smqtwzbIslEolFAoFQkJCEBYWBoZhYDAY4PFUVqyOioqC2+2GwWBAXFwcZDIZNBoNNBoN8vPzoVAoYLFY4HK5EBUVhbCwsMpckWoVZDIZXC4X9Ho99Ho9OnTogJCQECQlJeG3335DVlYW3G43zfNIqRFSYcrBvIeEOUWFD2EBG278hrK7urBgLpxcmPexpqHewnVJiYG18ZqsLULBUOiBKZUHUrxdbGt9e7f6szfQ+eHCoaXeR8EgPg7VHZfGwpgxY2AwGJCVlYWBAwfCYDAgISEB77//PgDg2LFj6N27N/R6PZo2bYovv/zSq39xcTGmTJmC9u3b8z9gDRgwAEeOHPGZKzMzE4MHD4Zer0d0dDQmT56MrVu3gmEYH6+1ffv2oX///ggJCYFOp0PPnj3x66+/BlzPjh07wDAM1q5di7fffhuJiYnQaDS48847cfbsWa+2u3fvxrBhw5CUlMRHC0yePBk2m61ejxEAmM1mPPfcc2jSpAnUajWaN2+OefPm+aQhyc3NRUZGBlwuV8C1fv3110hLS4PRaITJZEL79u2xZMmSavuUlJQgPT0diYmJOHXqFADA4XBgxowZaN68OX8cXnrpJTgcDr4fwzCwWCxYsWIF/zkaM2YMvz8nJwePPfYY4uPjoVarkZycjCeffBJOp9NrfofDgeeffx5RUVHQ6/W47777UFBQEHCtQtRqNWJjY2vUh2VZlJWV1ahPTejduzcA4MKFCzXuO336dERGRuLTTz/1ER2BSu/MmTNn1tVECoVCqRUeMLwAyD0XVp/mi8kwvuKj8HGjUhliTKAEgZKp3vtQ2EcKllz1Yqyt12R1cPkeuSuLYMOFa1OQRownwFxXPTODs4lbgxKMZO7IQH39CZ1c6Df38BeG7e0dG1wOzcYC9Xj8G1PdDSXnvWW1WlFSUoK//voLf/31F9LS0tCiRQvk5uaCYWQIjwgFwODEXydRVFQMQghUKhUiIiJRUlICgKC8vBxhYaG4dOkS0tO7wGaz4fz587Db7ZDL5XyeMqVSCbfbDblcDrfb7XWjrdfrYbFY4HQ6UVhYiJSUFHg8Hr5idVhYGIqLS9CsWTNcyspBUVERjEYjzp8/j7Zt2yIqKgq5ublQqZSIjIqAy+WCTFZ5sd2yZUsYjUbeM3Lnzp0IDw9HdHS05HGinj83HlJecvV1HqXG4QT0mnrNigUfqSrcDYm/eYSFdGpriz/PyZqId/UhgnH5zYRe3bWZn+sn5TlZX3bWZBvDSFe9DhZxGPyNAMuyGDBgAHr06IF33nkHq1evxsSJE6HX6/Haa6/h4YcfxtChQ7Fs2TKMGjUKt956K5KTkwEA58+fx4YNGzBs2DAkJycjPz8fH330EXr27IkTJ04gPj4eAGCxWNC7d2/k5uZi0qRJiI2NxZdffont27f72PPLL79gwIABSEtLw4wZMyCTyfD555+jd+/e2L17N9LT0wOuae7cuZDJZJgyZQpKS0vxzjvv4OGHH8a+ffv4NuvWrYPVasWTTz6JiIgI7N+/H0uXLkV2djbWrVtXb8fIarWiZ8+eyMnJwYQJE/gf56ZOnYrc3FwsXryYn2fq1KlYsWIFLly4gGbNmvld37Zt2zBixAjceeedmDdvHgDg5MmT+PXXXzFp0iTJPoWFhejbty+Ki4uxc+dOpKamwuPxYPDgwdizZw/Gjx+PNm3a4NixY1i0aBFOnz7N53RctWoVxo0bh/T0dIwfPx4AkJqaCgC4fPky0tPTYTabMX78eLRu3Ro5OTlYv349rFarl5j2zDPPICwsDDNmzMDFixexePFiTJw4EWvWrAl4TmuL1WqFyWSC1WpFWFgYRowYgXnz5sFgMNTbHFwYdEREhNd2u92OwsJCn/YmkwkqlQqnT5/G6dOnMW7cuHq1h0KhUOoLqVyOrEB49IdHJOiI2wYKqRb3kWovLCBT3X4u9FsYTi2sui0OsxZ66bmq+nkA3oMxUMi1nPG/T3y1KyVkCoUzznuRC20OBHfHxAt0ohBiwFeQZAnxDg+WCNfmxpW6I+PERM4+qdyWcjBwgUh6VHL2CEOqefFU4txIHQeWq1rOeBfKkRIWuf7ebQjflyXEb4i15PoFXpKNASo8/oMQhlVbrVaUlpYiKysLR48excmTJ1FUVISkpKZISUmBzeYAy7JQq2JACKDV6mA2l8LhcKK4uARhYeEgBHA47DCbzQgJMcHtdkOr1YJhAJvNhoqKClRUVCAtLQ0Mw6CkpATh4eEAAK1WC5fLBblcDovFgtLSUqhUKl7MsdlsSE1NRWlpKQoKCngvRrlcjubNm+PcuXOQyWRwu924dOkSoqKioFAoeE/KkpISZGVdRFhYWNW6klBaWgqtVosTJ04gLS0NYWFhUCqVPsfpRrox/6cTSFwHGkbU4/I+ckJ6sPOIw2Ybwj7xeMGIZEKxLhgBV9iGE8OkRFjhOQjmXFU3Z10Qhl4HWo/UOQrU/lohDPnnvCGDtUHszXojYLfbMXLkSEydOhUA8O9//xvx8fF49NFH8dVXX+HBBx8EUJmvrnXr1lixYgXvgdW+fXucPn3a6xw+8sgjaN26NT799FNMmzYNAPDRRx/xIuW9994LAJgwYQI6derkZQshBE888QR69eqFzZs388dwwoQJaNu2LV5//XX8+OOPQa3p8OHDvOgVFhaGSZMm4fjx42jXrh0AYN68edBqtXyf8ePHo3nz5nj11VeRlZWFpKSkejlGCxcuxLlz53Do0CG0aNGCX098fDzmz5+PF154AU2aNAm4JiGbNm2CyWTC1q1bg/phJi8vD3369IHNZsOuXbvQtGlTAMCXX36Jn376CTt37sTtt9/Ot2/Xrh2eeOIJ/Pbbb+jWrRtGjhyJJ554AikpKT6hw1OnTkVeXh727duHLl268NvffPNNn++ciIgI/Pjjj175Yv/zn/+gtLS0znkXpYiLi8NLL72Ezp07w+PxYMuWLfjggw9w5MgR7Nixo9Y5V61WKwoLC8GyLDIyMjB58mQAwLBhw7zaffrpp/j00099+n/11Vd46KGHkJGRAQD8e5KDEIKioiKvbaGhoTRHLIVCuW5weRo5QZEVCzoBLoOFXpNS+SI56uIdyYmJ4iI2QvGRayerMlooMgLSXnJ2IufzTyqDKn5T/etg+gCodUi2MD+kjBtDeE8hnrvqr1js5PrJGcZvvkhJEVAgZKo4Ma9KdGSr9stRKWoK28pxVaT0VJ0bcV5KuSBHpNAWqfDuq+uTFpbF+/jtghyW1XmNigVH8dXY9RIiaaj1PwyWrXyrWa1WHDx4ECdOnMCOHTtw9uxZyOUK5ObmoaCgCDKZHOXlFXA4XCAe8GHVZWXlcDgcMJvNkMlkcDqdCAsLg0ajgVwmR15ePoxGI+Li4iCXy3kxkKs6nZeXx+d+ZBgGNpsNR48exblz55CUlISkpCQYjUb+piw0NBR6vR5KpQJOpxNFRUXweFgYDAY+DLyoqAinTp1CdnY2SkpKkJ2djYqKCpSXl8PtdiMvLw+nT5+GQqFAq1atUFRUhN9++40/FpzIQCtcU4KBuzHlCiEJw5SrC4Hl3mOcyNdYxB+pEGRhNeXqBEPuM+RvPcGKXA0hhnFjCs9TMCKsuMJ4dWNf63PIzSmu5B0I7jzdiDkdx40bxz8PDQ1Fq1atoNfrMXz4cH57q1atEBoaivPnz/Pb1Gq1V3XwoqIiGAwGtGrVCgcPHuTbbdmyBQkJCRg8eDC/TaPR4PHHH/ey4/Dhwzhz5gz+/e9/o6ioCIWFhSgsLITFYsGdd96JXbt2BXU+xo4d6+Vp1717dwDwsl0oOlosFhQWFqJbt24ghODQoUP1dozWrVuH7t27IywsjF9PYWEh+vTpA5ZlsWvXLr7t8uXLQQip1tuRm99isWDbtm0Bj0V2djZ69uwJl8vlJTpytrVp0watW7f2so0LHZbySBXi8XiwYcMGDBo0yEt05BC//8ePH++1rXv37mBZFpmZmQHXURvmzJmDuXPnYvjw4XjooYewfPlyvP322/j111+xfv36Wo87Y8YMREVFITY2FnfccQfOnTuHefPmYejQoV7t7r33Xmzbts3n0atXLwDgw7/F3o6lpaWIioryeoirZlMoFMq1gAutrq9waU58dBGZj1dkXeG8GrnK2177hKHf1cwrDOe9Gh589Rhci7tYoUelnKmZkMSFW8uqxuFChKVEMLngAa4ProqFQmSiRzCIvS+lPB2lRDuxB2VNEZ5DsegoB+P1qAlCr1AW0gKuv33XEio8/gMQhhy63W7k5+cjOzsbp06dwsaNG1FRUQGWZZGYmACtVovff/8deXl50Gp10On0UKs1yM7OgcPhQnh4OFiWhc1mg1qtRnR0NAoLC6HVatGiRQvYbDYUFxfzYiQhBBkZGWAYhq9eXVZWBrVajYKCAixatAhffvkljh49imPHjvH5Ii0WCxwOB9RqNZRKJQgh0Ol0cLlcOHnyJHQ6HcrLKwvhGI1GmM1mhIaGgvWwOHDgAHJyctCmTRt4PB5kZmbi8OHDsNls0Ol00Gg0OHDgAE6cOMGLRjeSF9D1ZNeuXRg0aBDi4+PBMAwf7sZBCMH06dMRFxcHrVaLPn364MyZM15tiouL8fDDD8NkMiE0NBSPPfYYKioqamWPuHjJtSjOIpyDy79XXQ5B7rn4fdZQ9tYmB6AQYUETToCUygkoDkWuD0/hhjomwvMkFoeEdgfydAyGYI+71HEVnzd/AqfQ29HffJyXqTAEXjx/Y0ej0SAqKsprW0hICBITE33WExISUpX+oxKPx4NFixahRYsWUKvViIyMRFRUFI4ePYrS0lK+XWZmJlJTU33Ga968uddr7nts9OjRPsLLJ598AofD4TWuP4TeikDlj3oAvGzPysrCmDFjEB4eDoPBgKioKPTs2RMAfOaoyzE6c+YMtmzZ4rOePn36AACuXLkScD1innrqKbRs2RIDBgxAYmIiHn30UWzZskWy7SOPPIIrV65g586dSEhI8Np35swZ/PXXXz62cVWXA9lWUFCAsrIyH489fwRzXhqayZMnQyaT4aeffqr1GOPHj8e2bdvw888/48CBA7hy5Qpeeukln3aJiYno06ePzyMmJgYAYDQaAcDnf7PBYOBFyhdffLHWdlIoFEpdEYp0tRUKWVwV+zjPw+rEv1rNQSrFTH/Vrv3ZFYjK/I4eKBkPVIznmok6cgY+Xn3BIPYQrH4OQVi6YJtUv5qKdEIxMxh7OO9HoPaCoxCuUEygsWqyrkoh8+pzoNJuoYAbzKOhobER/yAqb7BlsFqtyMrKQlZWFliWRWhoKEJDwyCTyaHX6cFAhvMXziE8PBxqtRolJcW4kn8F0VHROJB1EIQwSE5ORnl5GSIiwhEeHg632w2TyYTiksqcQREREVCr1Th9+jRatWoFj8fDh+J4PB7I5XJoNBp06NABFy5cgNvtRkZGBuLi4hAaGgqj0QiGYeByuREaGgqg8ibaYrHAbnNAp9MhLi4OFosFMpkMer0eJSUlMJoMaNKkCc6cOQOr1Qqn0wm73Q6VSgWNRouLFy/yN+GrV69GaGgon++KCo+BsVgs6NChAx599FEfDwoAeOedd/Cf//wHK1asQHJyMqZNm4Z+/frhxIkT0Gg0AICHH34Yubm52LZtG1wuF8aOHYvx48dLFj5orIhDh4Willi0khJ/Gut7TWifsICOOGejUHT0F0YdSOgKFH5dF/wViOFC5KWK4HDbghE/r7eIx9nKeXKKkVrTjSA0ivEXqutvu3CNs2fPxrRp0/Doo49i1qxZCA8Ph0wmw3PPPVcr73auz/z589GxY0fJNsHkwgtkO8uyfL7Dl19+Ga1bt4Zer0dOTg7GjBnjY3tdjpHH40Hfvn0lhSkAvMhXE6Kjo3H48GFs3boVmzdvxubNm/H5559j1KhRWLFihVfboUOHYuXKlViyZAnmzJnjtc/j8aB9+/ZYuHCh5Dw1DQEPRDDHq6HRarWIiIhAcXFxrcdo0aIFLxzXhdatWwMAjh8/7rVdoVDw42dnZ9d5HgqFQqkLnFDI5UL0zYkokb+ReFel5kQ+ljBQwgMPGCgZT70XnvGAAQh4r0dufBXjEbXD1dyN1SADoGH8txILa7wHXzV5IAPliBQjDgOXEiRlor/+4IQyoLKqtfC/MvfcRYiP12OgojBC24SCpvjIaRjGy2Y5qipRA5AxDFyC6wGloC3nHeniixldzccIgA+P5kKkuXyRleeZ4e1nQaBkZF7FcIT7hWu5ut/bg1HsJSpjgveErY9CPoGgwuPfhOpypDEMAw8hcLrcKCsrx19/ZWDX7j2wWm2IjolFdHQM4uLi4HK6EB4RDoYphlargVwuh16vh9Vqgd1hQ87lS9BqNcjPv4Ly8jKYTCaEh0cgJiYahBAUFxfDaDJCLq/0LpLJ5bA7HCAAdDo9Nm36AVabDWqVCkaTER7WA5eLhVarR25uLq7kF8BisaF9u3ZITk5GckoKGMhgszngcrFwu1nYrHaUl5ejoKAATZo0gcVigcFgAMuylaHgpWUoMRfDaDTyoeNOFwutVoWycgtCQsIQERkBq9WG02fOYO/evUhKSuJzp3ECUmMVhq43AwYMwIABAyT3EUKwePFivP7663yutJUrVyImJgYbNmzAQw89hJMnT2LLli34448/+PC3pUuX4u6778aCBQv4gg914VoWapHK9ScuACIUf66lfcHgL1ehWLDicgpyr8XiXH0W8mnoG31heLxYlKuLp+O1QnzcOTEVgI+o6q/fP4H169ejV69ePnnszGYzIiMj+ddNmzbFiRMnfI6buNI0V7DEZDLVi7Djj2PHjuH06dNYsWIFRo0axW8PJnS5pqSmpqKioqLe16NSqTBo0CAMGjQIHo8HTz31FD766CNMmzbNy5P0mWeeQfPmzTF9+nSEhITglVde8bLtyJEjuPPOO2v8QwAAREVFwWQy+QhnjZny8nIUFhb6eLBeD1q1aoUWLVpgw4YNWLx4MfR6/fU2iUKhUHyQg0h6B4oLtnj1YYiXUCmrEgBdkPHjyQjjJU7WFLFo6SOAiuwOtkBL4Hm9X1eKW4GRqrTMjSVVZKY+rpYDhfxyFZsrbWC8CrQIqc1xE9ovVXCGQy4QCYWh116iKsPA6SUW+g/VFuOqyhfJeTcGqsAdLEIRsb7eW/VB47/LotQK4c175XMG5eUV2LPnN5zMOIXo6FikNm+B227rgebNW8LlYuHxEOzftx9l5aW45ZYu0Go1fCiz2+2C2+2EUiWHx+NGbu5lKBRyKJUqREZGQqvVIDvnEgip9Ow6e/YsysrKEBkZBZYFcvOu4IfNW/HVV2vw47af8fXX67Dqiy/x+fKV+Ov4CahVWrjdBMeO/YXvv/8BBw8eweYftsJqteJKfiF0Wj2sFhuUShVkMjlKS0tRVlaGpKQkGAyGKq9IwO6wo6i4GARAbl4+CgqLoVJpUFxSiiNHjqLCYgWBDAZjpWfkH3/8gby8PK/w0n/aDXp9ceHCBb5QAEdISAi6du2KvXv3AgD27t2L0NBQr5xbffr0gUwm86rqWlP8hapea7jCTU6nEzabjRezG6qQTF0RCohSx44QArfbDZZl+b9cP+FfMcGcj4Y+R/7C3z0eD2w2G+x2O+x2O9xuNwBvL8FA4zQWhMdXeI6EHpGN7T13rRBWNudYt24dcnJyvLb169cPOTk52LhxI7/Nbrfjv//9r1e7tLQ0pKamYsGCBZKpIQoKCurNbsD3f/iSJUvqZXwhw4cPx969e7F161affWazmf9sAEBubi4yMjLgcrmqHVNceEQmk+Hmm28GADgcDp/206ZNw5QpUzB16lR8+OGHXrbl5OT4nAegsnidxWLhX+v1epjNZp95hwwZgu+//x5//vmnzxjX8zNtt1f+gCpm1qxZIISgf//+/DaXy4WMjAzk5uZeSxMBADNnzkRhYSEef/xxyfPeWL8XKRTKPwN/wmJ1cLkUub5elaZrKTIGgvNwFOZ3rO9w7oaEJb4Prjp2sJ6RdUEYYl0X4YoLcRYKfcGO6QwiNNprHtFrf32lis2IH7woKXhUV1imMUM9Hv/mcBeGLpcLFy5cwK5du5CTk1OV61AFvd6IlJQUyOUKHD50ED/99CMGDboHXbt2RXZ2Nv7880906ZIGnU6PsLAwlJVVIDk5GRaLFVFRUVCr1SgrK0dMTBSKigtRVlYGlUoFi8UCp8sJmUwGo9GIigoLbw/LsnA4HMjNzYVapUKLFi1hsViQkJAAg8EArVaLNWvWwGQyISwsDM2aNYPD4YDL5eKFg4MHD8JoNKJZs2aw2+2IjY2FQqFAQWEBDAYDSkpKcPnyZeTlXUF8fAJOnDgBhUKBpk2TYLVYYDQZoFIpcSnrEvbs2YPhw4fXObfbP528vDwA4HNEccTExPD78vLyEB0d7bVfoVAgPDycbyOFw+HwumnlEt83FjihhwuplsvlcDqdXm2upSemP2pyoyj0bhSHIVdXdCXQHFJtanJspMKoawL3HaJUKnlPaYVCEZRHanXrDmZef31q+97gjqU4dLwmIdY3ahh2IAYOHIg333wTY8eORbdu3XDs2DGsXr0aKSkpXu0mTJiA9957DyNGjMCkSZMQFxeH1atX86khuOMqk8nwySefYMCAAWjbti3Gjh2LhIQE5OTkYPv27TCZTPj+++/rbHfr1q2RmpqKKVOmICcnByaTCd98802D5Bp88cUXsXHjRgwcOBBjxoxBWloaLBYLjh07hvXr1+PixYu8d+jUqVOxYsUKXLhwodoCM+PGjUNxcTF69+6NxMREZGZmYunSpejYsSPatGkj2Wf+/PkoLS3F008/DaPRiJEjR+KRRx7B2rVr8cQTT2D79u247bbb+ErNa9euxdatW/kfsNLS0vDTTz9h4cKFiI+PR3JyMrp27YrZs2fjxx9/RM+ePTF+/Hi0adMGubm5WLduHfbs2cP/YFmfvPfeezCbzbh8+TIA4Pvvv+dDkp955hmEhIQgLy8PnTp1wogRI/iQ5q1bt+KHH35A//79+YgBAHy+6tGjR2P58uX1Zufp06fxxRdf+GyPiYlB3759AVRWSD9+/DjmzJmD/fv346GHHqq6/rPg+PHj+Oqrr2A0Gvl8mBQKhXKtkQk8BzmvQk813o4cbFVBFs7LUVb14OBCsoUIw6OFz6uDExo5D0de8BQJj+L8h/4qWbuCWJsUdfF4E3o8CovKSHks+vOuk/L68woRZhivvkJPx8rXVVFlgorSNfHkq8n6pbw/gavh13KGgRIMXFXh8FwlbH8enNWFMHOh1IHCxaXGFIqP1akXUh6d1Xl5NiRUePybIhYMSkpKsHv3buzbtw+XL1+Gy+VCVGQ4vv9+E7p16waXy4WDBw7A6bAjLCwMCoUCGo0Gubm5OHz4KLKzc+DxeKBWq1BRUQFTVUh1bGw0SktLYbPZkZiQCLO5GLGxsTAajTAaQlBRbkVhYSE0Gi1YloVOp4Pb7caFCxeg1WoRWVV9sbS0FIQQ6PV6GI1GlJWV4cTJE2jRogVCQkIQEhICl8sFlmVht9tRWloKh8OBsrIylJaWQqFQwGAwICYmBjI5g7KyMl5QMBj0MBgMyM/Px8WLFxEbGw2dTofCwkKEhYXh4MGD6NmzJ2JiYmiYdSNlzpw5eOONN2rUR5jbryEQeyQJQ/UBQKlU8iH8QnFHyh5/Ic+1sUVMTcYT2igcM1hBvrYCVk3PVaB5/HlYcueCExoVCgX/PNhzEOx5rAn++gUrCnLvM87DkX6HAa+++iosFgu+/PJLrFmzBp07d8amTZu8wnmByryMv/zyC5555hksWbIEBoMBo0aNQrdu3XD//ffzAiQA3HHHHdi7dy9mzZqF9957DxUVFYiNjUXXrl0xYcKEerFbqVTi+++/x7PPPos5c+ZAo9Hgvvvuw8SJE9GhQ4d6mYNDp9Nh586dmD17NtatW4eVK1fCZDKhZcuWeOONNxASElLjMUeOHImPP/4YH3zwAcxmM2JjY/Hggw9i5syZ1X6PLFu2DBUVFRg7diyMRiPuvfdebNiwAYsWLcLKlSvx3XffQafTISUlBZMmTfLKP7lw4UKMHz8er7/+Omw2G0aPHo2uXbsiISEB+/btw7Rp07B69WqUlZUhISEBAwYMgE6nq9UxC8SCBQu8KmF/++23+Pbbb/ljExISgtDQUAwcOBDbtm3DihUrwLIsmjdvjtmzZ2PKlCkBv2+57wR/eSmDgSsQI6Znz5688AhU5krt168f3nvvPXz22Wd8McGWLVvihRdewBNPPIHY2Nha20GhUCh1wQMGHsIAzFXhkatOLW7H7RdWlZYLxEqurwzeoiK3j6tKLRYfWcL4VKoWIq8Sy7iKzpVilaigjSjfo5cIxwjCnnmhlVQrUHIoGcE+pnoPRQ8AD/Efcs3ZwrUV2uWpaqesweWnUKzzyV0oChVmq0S+mgpkLCHg3EA40bDSa9D3QIjDo4Vh1nJczc0IVJ9XUpxz0Z8dwnH8CanCtXPjcH35XJdVdnPekMqqtv7eG3IwcBHPNcnpKIYhN6CrQ1lZGUJCQlBaWgqTyXS9zWlUCBPUc6F2bpbF8eMnsHDhQvzf//2A9PR0PPvsRJhMRuzYsQvr1q7DxYuZcLvduP32W/Hyyy8iPDycF/gyMzORlZVVVchFjmPHjiEhIRFGowkdbu6E8vLKKtXJyc1QYSmv8mi0488/D+DgoUNITU1FQkITnD9/HhcuXEB4eDhCQ0Mrz6G5FKVmM3Q6HVq1aoWWLVsiOTkZLpcLL774ImQyGfr27YvmzZvj2LFjyMvLg91uR1FREbp374709HTk5ubCarXCaDRCp9ehoPAKcnJyUFhYiMLCIoSGhiEr6xIyMy+iR4/uiI2LAcu6UFZahgvnz6NLly64++67ceutt0KpVP5jb9xr+rliGAbfffcdhgwZAgA4f/48UlNTcejQIa/iCz179kTHjh2xZMkSfPbZZ3jhhRe8vHfcbjc0Gg3WrVuH++67T3IuKY/HJk2awGw2e9laV2+6miAstsKyrNdNoFTYbnUedddKeKyJYMcJWUIxnhPvAt0Y11ZADPbY1ObflrBitXAelmWDCkkWz11b4bEm/aTez8L5udB3qYJGwX6PcXOUlZUhNDSU/l+tYvHixZg8eTKys7N9Ki5TKNcT7n/166+/jlmzZl1vc64L9D6AQql/bpTPFWfnb8fjYDDK4CIyyJjKCs8cQiGREwg9VYVoNEzltRO3TYhUTkeujbJKFBQKjYE8ILl8kjJUeisqq0QkrsK1eBxhdWop4agy12DlOJzwJxQAhe24fuKCMTUtIBMI4XhimzjvSF6A4/rAW6DTCEQ+McLjIX4eyJPRn5hY07YsIV7Co3BeLr8j10cqv6PYG5LbLiw0E6wnp/gOzCOwQcp2qT7CNXD7Sss9aNkmv0E//9Tj8W+C1I0rn7MQDPLz83H69Gm0bNkSb731Fjp2vBkyGYPk5BTYbHb8+eefUClVmD79NYSGmnD58mUoFAo4nU6+gEulx6MaTZsmISmpGeLj46HXaeFw2qBSK3HhwgW0bdcW58+fx/z581FYVITIyEjk5eXDYDChoqICSqUSaWlplX31euzbtw96nQ7NmjXDrbfeiqysLHTq1BF6vRbvvPNOpffEfz/G0089jaSkJJw5cwYFBQVVoeIaJCUlwe12Y/fu3YiNjYWbdUGhUIAQAqPRCIWispr1+fMXIJcrcPHiReh0Gmh1GgAEGo0GFy9exIEDB3DLLbdAqVT6HlxKUCQnJyM2NhY///wzLzyWlZVh3759ePLJJwEAt956K8xmMw4cOIC0tDQAwC+//AKPx4OuXbv6HVutVkOtVge0oaaecNWJcsGINlyREn/ClZRIFYw4VVPvu/pELC5KVXAWFmapybhCahOeXBOEnqbCNYnnvZZidV0RrklY8EfqHF3P99CNhs1mg1ar5V/b7XZ89NFHaNGiBRUdKY2OP/74AwBw0003XWdLKBQKpfEjFBiVAaWqxofYYjnv2QlwuqmcAVx+xEdOAPSH1D5/oqS4rbgd99pnu9gm/+Y0esSCnaqquAwL6dyLrKiPiwAe5qpnohBxLkvvKtuMV85HVvA+UAlCrznRUShgikP5edsIgewa3vNQ4fFvCicaeDweuFxunDlzBi6XC7163QmZTIbDh48gJiYav/yyA7m5ubjpprYoKS5CeXk5dDoNdDodnE4nLly4gIqKCsTHx8NiscBoNCI6OhoGgw7h4WHQanWwWMsREmKCjJGDeAC1SoOszEvwEA8iI6NQVlaOK1euIDQ0FD169EBKSgouXrwIq9WK0NBQ3N1/AOLi4vDjjz8iIyMDnTp1RGpqc+h0OoSHhyMrKwtbtmzB7bffjoqKCly8eBGdO3cGy7I4cOAAkpKSoNFoeAHIQzwwGAzIzs6GxWKF2VwKg8EAlUqFs2fPIjExHnHxsbBZbQgJCUFxcTGysrJgtVobLPzq70JFRYVXtdcLFy7g8OHDCA8PR1JSEp577jm89dZbaNGiBZKTkzFt2jTEx8fzXpFt2rRB//798fjjj2PZsmVwuVyYOHEiHnrooXqpaN3QSIVXC8UsscAorqDc2HOICoVScQ5CYcESf96DjRGhCCe1Ju6cBOv5eD3hbBaK3f5+dAIaPt3A34WhQ4ciKSkJHTt2RGlpKb744gtkZGRg9erV19s0SiOgoqJCsqCQkKioqDqFPgfD0aNH+VyWERERuOeeexp0PgqFQrkRUDIesPBfhVrs/ShEqr3YCzHYytZcmDQrCM2+agOgFLzm2vIwnD2+iEUo+HmtFIiPUiHPYs9IKRGxOoFSaA8XWs2N6S+slyWoCoP3tlvo3acSXaMKw4mvzkX4MGlOYOO9ChnGr1ekGKEwyIc7V4mGwv/gwjG5uYThzgD4CtvV5XjkxuXEycqxr9roEl7Di+b08loVeOZKhXlz1bW5Ajrc3MJ18u348YhklfCGhAqPf3PkcjlcLhdsNhs8Hg/CwyPg8Xiwa9cuFBYW4s8/D8But8PhcCI7+xLS0jqhc+eHkZWVhUuXLsFsNoNhGBQXF0OtVkOlUuFf/+pa5U1JkJAQh8LCKygqKoJGo8Xly7nIzs4BIYBcrkBpaSl0Oh0iIyORkpLCV59MSEjADz/8gKNHj2LEgw9Cp9Ng9+7dKCsrw9y58xAbG4vLly/DYDCgadOmKC4uRkVFBcxmM1iWxeXLl6HT6aBSqXD+/HlYLBYkJiYCYKDRaEAIgcPhgFKpxMWL56BSqaBSqcAwDC7n5sJoMsDpcPLVba9cuYLs7Gw+kT5Fmj///BO9evXiXz///PMAwCe+f+mll2CxWDB+/HiYzWbcfvvt2LJli1eetNWrV2PixIm4885KEfz+++/Hf/7zn2u+FiH+vL785QoUCm9CMVGqvVB8BKSLijSkMORPTBTu455zeSqFSOU/5NbEiXXVCao1zT9Zk3Dl6sKQOY9vfwKpuK9cLvcKXQ7U3l8YvXh7dTaK+wdCLDr66ysWwLnzVJO5/kn069cPn3zyCVavXg2WZXHTTTfh66+/xoMPPni9TaM0AhYsWBAwx3Cgojv1wbfffou5c+eiS5cuWLRoUaMOhaRQKJRribjgirCQi9f2IArC1HZ+7kqYFb0OGA5cZauUeOavLSAtIlaXn1G4zZ/oGGz4NS82CtqzYKBkiOQYUsdACcAFX687cZiwPy9Cvn1wJnv1lcNXwBRXohaLckI7WIDPrRjMfCDeuRy99lURaB1iwVEs9nqJj8KGAiG3ch5vIfJa+gDXu/A4c+ZMnwu0Vq1aISMjA0BlCNMLL7yAr7/+Gg6HA/369cMHH3zgUwmXUjc4oaOyeIISycnJ0Ov1yMg4iX79+qGoqBiZmRerREcHLpy/AJmMQWRkJFiWRUVFBex2O0JCQsAwDCwWC1QqFdxuN0JCQiCTVYoPpaUl6NChAw4ePISioiKAyKDX69G7d2/8uvc3uN0sYmNj0bRpU7Rt2xYajQY5OTkAKr0Izp87hz//PIDBgwfB5XIhPz8fTZs2hdvtRkREBG655RacO3cORUVFiIqKQnx8PGw2G5+DpFmzZigqKkJubi5at24Np9MJU0gEAECj0SAyMgpmcxkqKipgMOhRVMQgPy8Pbdq0Ql5eHiIjIuB0VgqQubm5uPnmmxu9V9r15I477ggoJL355pt48803/bYJDw/Hl19+2RDm1SvicFVOxHI6nXyYq1Kp5POCiisLC+HEOU7Yamzij1Cg4/AnvHGintCrWpzj8nojPHc18WKUy+X8sQDgc15rMn99nmPOHs5ztjY0tnMEAO+//z7mz5+PvLw8dOjQAUuXLkV6evo1t+O5557Dc889d83npdwYjBo1Crfffnu1ba5FgZWZM2di5syZDT4PhUKh3ChIFZK5EZHBt1hLTaiP/I3CEGhxJWt/cEJa5R2BtOjorx/XV84wfBix0BauHe9tGKTQVxt8w9lFIq7Au7E2uFC9JyY/djXX+P76+YRRM4zXsRJ6j8rBQMYw8AiE0GtJg3g8tm3bFj/99NPVSRRXp5k8eTI2bdqEdevWISQkBBMnTsTQoUPx66+/NoQp/1iEN9tlZaUwGo146aWX8dlnn+PixYsghODIkaP4179uRUVFBS5duoSY6GjExsYiIyMDdrsdWq0WISEhsNvtIITgpptuglwur3rtQVxcHMzmUpSVlcHhcEAukyM0NBxyuQL33HMPEpOaQC6Xo1OnjnC73SgpKUFERASOHTuGXbt2IS8vD0aTCd9++y3uuqsvRo8ejYkTJ8LpdOLee+9FcXERHE4nHnxwOCoqLPjrr7/Qtm1blJWVITw8HAaDAS6Xi69Oq9FooFKroNfrERUVhbCwMBQWFiMiIhwRERFwOh04f/4cysrKUVFRgfDwcERFRUMmkyErKwtarRa1/D6hNBKCLRASTBvOu4xlWWRnZ2PHjh347bffkJmZibKyMigUCoSHh6NFixbo0qULOnXqhKSkJD5XnFiEFBZr8Xg81YpAwYpL9VFZWVwhtSbCltCzkPPEC6ZPMPbU9FwJX1eX/zAQwlByYU7F6ykW8/l6q9ZTE3uEfaTykfoL125o1qxZg+effx7Lli1D165dsXjxYvTr1w+nTp1CdHT0NbeHQvFHSkoKUlJSrrcZFAqFQhHh4fPdeXs4Snk78vtEhWD8FYaRQtjO63lVmHewQo4w1BggcKFSDFJWRcBy+MvvGIjaVIB2Ee8wYOH8Ut6Q3Bq4ojnKGnhM+uYZ9G0jdSz9hTRXh7CPsPhLoJ/ihfPbhd6OBNBwuTUBr7GqG1cO7xD16hB6LaoYRrIKN1C9x6Jc1I4THTmEHpO1eb/UhgYRHhUKheSvv6Wlpfj000/x5Zdfonfv3gCAzz//HG3atMHvv/+Of/3rXw1hzj8E7o0k+GBUhde5XG7IZDKEhYQhvcstKLhyBV3SuoB4PIiNicP+/fsQGhKCfv3uQuvWrXD27DmEh4dDqVTyuR71ej2/7fLlywAY2O1uqFRa5OflQ68zwulgYbVaYLFUwGqtQJe0NBw5egRlZWW4cOECmjRpgnPnzuHo0aMwGo0YMGAAkpKaYuWKFfj0s88xcuRIPP/Ci1i27APs278POp0WTZomIj5hNFJSUwAG2L59O27u0AEWiwWm0FCcPXcOHkJgtdmgNxjgdDpRWFgEl8sNt9sFi8WC2NhYXMrKhk5rQHh4FHJzc/DX8Qyk35IOrUaPJk30KCgoxp49e9GmTVvEREeBgMDjIZDJvG/QKY2fYEUUf+eTE2gAwGKxYOXKlViyZAmys7O9xCxCCNxuN7Zu3QqZTIbw8HB07twZw4YNw1133YWoqCgf70BhX6E4Fqxt/tYqVXlavJ9lWa/XCoWCt4UryCTsE6wNnDenx+OB2+0O6FVXXU7CQPMGKtYjFAtrIzpyY0gJqrWpZl3de1HsVVldO3H+yZquSyw+Ct+T16u4zMKFC/H4449j7NixAIBly5Zh06ZN+Oyzz/DKK69cF5soFAqFQqHcOHCCo5foWFVJWljJWizYcWKjOOejUIQUC5JSz3lvy6pchvw+xlsg0zGEF52ECMVHwNtzkSX+xSApoUjo7RhIRKquCrYQsRckl7ORey6usC1ljz/7vRBdi4pDkL3yQBLfqtGBxucEQruH8LkwXbhaJfyy24iDtmb4qyIecZpSAECuPQQeMIhTl4KFDEnqInTXnYESHrhAYGQqQ5hdVTke5VWehpy4CVwVOj24KuwGk0dTOJawsIzU+qTyQioZGezE45OrUnIu+Bc265sGER7PnDmD+Ph4aDQa3HrrrZgzZw6SkpJw4MABuFwu9OnTh2/bunVrJCUlYe/evX6FR4fDAYfDwb8uKytrCLP/FgiruMrlcl5UuJKfD4fdiZvatoFBb0RxcTFiomPw119/Yd++fUhL64zHx41DVFQ0iotLUF5eyntu6fV6AJVhfjabDQqFElqtDm43i/PnLiA1NRUsmwu73YHLly+jvLwcer0eV67kY9++fdi+fQfM5hIolUoQQvDAAw9g0KCBKCoqhtFoxLTp03Hh/EV8991GdE7rjLGPPorTpzOgN+hw663p0GjVsDttsFgroNFqUVBYhJiYGBQXFyMqOhpqtRpnzpyB0WQCwwA5OTkICQkFISxKSswwGkOQkqKCxwNER8Ug82IWMjOzERcbj8SERJSXlyO5WQrOnjmHn3/ajnuHDIZGowLDyG6IghOU4Akkqgk/P2VlZZg5cyaWL18OhmHQs2dP3HXXXWjdujVCQkLgdruRn5+PjIwM/P777zh69Ch+/vln/PLLL0hNTcWDDz6IESNGICkpyUswkvKErItXnTDnpNPpRGlpKTIzM3H27FmcPXsWly9fRlFREUpLS+FyufjvhJCQEISFhSEuLg4pKSlo1aoVmjVrhoiICCiVSp/cjWLbpMLJgashvbX9zAjPAfc6GHGOEwqFttR2fuFzYS7Lunii1gaxl2JdxxXn57xeoddOpxMHDhzA1KlT+W0ymQx9+vTB3r17fdqLrwE8Hg+Ki4sRERFBv5splHqCEILy8nLEx8fTlDMUCuWGQsl4eKHRQxgoGQ8vOnJwxWeEwmJ9IiVMciKoGJdXnj2J3H3E1yMtEIHaSRZb4at9V+chWtVWoom/fsGIa952+CeYK1WPxHM+7FgwTrmHgQcelHuU+MXSBlvzb8K5w4nQXJFBYQMYN6C/wkKb74RHKYNHJUOm2wNLnAqGHCeW9hwEtClHSlQR7ok5hjTNRcTIbZUem5wg6uUd6R0eHmzeT8A71yUnOvoTiF2EQCkQKQPBVuUUveFDrbt27Yrly5ejVatWyM3NxRtvvIHu3bvj+PHjyMvLg0qlQmhoqFefmJgY5OXl+R1zzpw5ARN7U7g3ua/nUEhICOLi4rB582Z0794d5y+cw4E/D0ClUsFkMmDRooXo+q+uMJkMVZWdtbDbrXxxFrlcDq1WC5fLBZlMBo1GgzNnzgAAigpL4PF4YDabYTAYoFAoEBERAZZlYXc40LFjRxw/fhyhoSFITk5GXFwcEhMT4XK5UFBQgLy8PBACFBcXg3V7kHnxIkJCTOjYsRMIYQHIwDAy5OflQ6PRoE2bNrDZbLBarYiIiIDNZsO+fftw6dIl5OfnIyGhUvCuqCiHTqdFZGQUWNYDi9WKEFModDodjEYjPIRFVlYWOnfqhOTkZJw6dQoMw+Cvv/5CYpMEdOnSGWq1hl58N3KqK/ghRTACFudh9umnn+Lzzz+HyWTCrFmzMHToUBgMBp/3hMfjgcPhwKVLl7Bt2zasX78eBw4cwFtvvYXVq1fjsccew8iRI/mqp8KQWW5OYfGPYNYhbGe1WpGRkYEdO3Zg586dOHHiBAoKCuBwOHiPPblczns4cq9ZluWFSJlMBrVajejoaLRp0wa33nor7rjjDrRt2xZGo7FaAVIIJ5DVtIp3IO+/QOdZ7MlXX6HRDMPwP+DUZMzaVJOurggNt6aarkvqeArXVJeckXWhsLAQLMv65HaOiYnh80ELodcAFMq149KlS1XF+igUCqXxcrUoi/9QaTkIHwYtFhrF4db1ib8K28BVD8dAV8icMNQQ4hAXFs3iqocmAHgI4fNNclQXPq1kvMOHXUSY8/HaC1uBkDMEP1S0xaId/ZHwE2A4U4oWMMOeaIQ5RYnwDAeUZQ44Q9VgCCC3s3Dr5NBdcUFR4USTXzxwHNTiSnRTfBDVDNYkN+KbFaJb9AUMC9uPeLnDr4gqZ4I/HlLh7oD/PJBikdKf+OiRuMeSqpLdUNS78DhgwAD++c0334yuXbuiadOmWLt2Le9BV1OmTp3KV88FKj0emzRpUmdb/44ICypwN6lKpQKtW7fGli1bYDabsXPnDmg0GvS/sx9atmyJ1NQUAAwqKirgdDqhVquQkJCA3NxcKBQKOBwOvnq00+mEQlEZgn358mXY7Xb8+uuvfP4jrVYLs9kMk8kEj80DvV6PW2+9FbfddhsiIyNRUVGBzMxM/PnnAURGRqKwsBBWqw0uV2VYtMGoh9FoQHx8PJxOBxwOGyrKLVCp1GBZByIjIxEVFYXS0jKUlZXhzJkzyMjIQH5+Pk6dOoXQ0BC4XC6YTCFwOGzQ6bQwm0thsVjAuj2IjIyEQqGA1eaA1WqD0+mCRqNBbGwscnJykJmZiZkzZmLso2Pw73+PgNvNQqlUXsczSqmO2ogm1fXhPOZOnTqFpUuXQqlU4q233sKIESOgUql8+nOinVarRYsWLZCamoqRI0di586d+Pjjj7Fnzx7MmDED33zzDV5++WX07dsXGo3GKxRYGHodTIVolmXBsiwKCwvx448/4uuvv8bBgwdRUVEBhmFgMBjQvHlzJCcno3nz5mjatCkiIiIQFhZWlce00jOyrKwMhYWFuHTpEu8dmZmZiZ9//hnbtm3DwoUL0aJFCwwcOBCDBw9GixYt+EI61Xn/CYUyschaGwKFOEuFD9cn3LzC3I8N9YOEMFy9Ll6jQgKNwb3nGzPia4DS0lIkJSXh0qVLtLIvhVJPcNfWRqPxeptCoVAoQSNnCFxExgt93F8l44GLVBVCrPKEFO7ntgMAyFXxUegZyW0Th2VLCZ3CtkJkqBTkKsfmQmFFnclVkdFJrl5jyhnCexVK5jwUjFPd1Zyc4So5e2/zEG9B1l9VbH8Vr7m8hQ0B5+koDl0OBk6gsxMC7i7+jNuA0b+MQ/gfSqScckCVXw7G7oQ9ORJOowwhF1xQFdtQ1CEEShuBPtsGRZEFSq0KIASM1QGZQw3CMLiSJgerJjCcVyDPGo1vzkZhvaoLnun2M+41HuWFXXEuSH9r5BBXNvdwa5FYu6yafsLjIBP1Y0XvJ/HfhqRBQq2FhIaGomXLljh79iz69u0Lp9MJs9ns5fWYn59fbUVAtVoNtVrd0Kb+rRCGHHo8nioPRhtyc3MQGRmOO+/sg06dOlbd6FYWaKkML776rZKSkgKGYZCTk4OTJ09Cr9cjOzsbSqUKkZFRkMnkiI+PR1lZGZRKJVQqFYqLi3kPybLycjgcDl4scTqdAFBVaVvBC5sqlRIKhRzh4WGwWi0oKyuFSqWESqUE8QDh4RFgGBkKC4tx8OAhtG9/MzIzM1FUVASz2Qyn04nY2FhUVFTg6NFj0GjUUKlUsNutKCqq9MjU6/XIz7vC39C7XE64XE6Ul5cjNzeXDz2MjY3F4cOH8P57H6BZs2bo2jUdfn5coDQCaiKaVCfACEOdXS4XVq1ahfz8fDz44IO4//77vUQgoReZWISUy+UwmUy45557cMcdd2Dr1q1YtGgRDh8+jMceewzDhg3Diy++iGbNmnnNKRbrpIQtbl9RURG+/vprfP755zhz5gz/vu3Xrx/69euHTp06IT4+HjqdjhfNhZWaAfiIWm63G1arFXl5eTh06BB27NiBXbt24ejRozh06BA+/PBD9O7dG48++ijS09Oh0fh6A4tDlDnPR+G8gcKmxW3F2/z1CRQWLkUwRVXEIfDiPInitsEi5eHJsqxXPklxASLx8ZDKixmMp6z4fcfNdS0FyMjISMjlcuTn53tt93ct4O8awGQyUeGRQqlnaPoCCoVyoyAUGYV5F1VVMgonsnAhxXI/VbClhEkPGD6g0FPlXSmcQ+zRyIdUM+DHEnoTXhUvCTyiPIxyBl7h1cLxq6tmLKy+LJVDUqoPC0bS8004FzcuV41ZOK7wuavqNRceLvTSlEm05xALpv5+zufENl60k/LYI97FYuQMw4c8KwF8UdYBq86mg90XhtByIPwvK5RHzwNKBYiHQFligDrfDeTkAWo1tIkGmFsoUJqih6ZQB3WpB6bTZbC0ioQuqwyqHDOiDkUBABRWFkWsCm4t4Ahn8MHWu7ChXQfMafENWihtYKvyNHJ2QmAnK1yfoB1/bIUh21X9hDkbOa9GNkBRIxc/trcnpFDYDFbQrSsNHkdaUVGBc+fOIS4uDmlpaVAqlfj555/5/adOnUJWVhZuvfXWhjblHwV3U8kVsDh58iRcLhcSExPxxBNPoFWrliCEwGAwgBACl8vF3+i63W4oFAr+JlihUEAmkyE7OxshISGQyWQoLy/nc8Wp1WpcunSJb6/VaitFAAZwuVz8DSbLstBoNLDb7SgvL0dpaSn0ej0/R6UACmg0apSXl0GpVEGr1SE//wpUKhXOnDmDS5ey8ddffwGoFEu4X+YjIyOhVCpRXFyEvLw8nD9/HjKZDE6nE1euXEFebi6Ki4vhcDjQrFkzKJUq2O0OnDx5EgaDAZGRkUhNTQXDMGjatBnOnDmDFStWwGKxXLfiC5TACAvB1Nd4JSUl2Lx5M3Q6HcaMGQO9Xg+FIvBvNJwXoEwm4wXI+++/H99++y1effVVaLVafP755xg2bBh++OEHXpQXeilzopPb7ebXxrIsLwxu2LABQ4YMwSuvvILTp0+jU6dOWLRoEX755Rd89tlneOSRR9CuXTuEhoby3oliYY57LvS45FJgtG7dGiNGjMD777+Pn376CatWrcLQoUPBsizWrVuHYcOGYezYsdizZw/sdrtX9Wepzwm3Hq6wjb921RGo2ExDeTpKzS/09hSvRSqkuboxhcVruO9fwFtMb6jvHnGuUWHxnGuBSqVCWlqa17WAx+PBzz//TK8FKBQKhUKhBIQTEVnC+HgZsmDgJDJJkVGIDARKxsP3AQAV44GqapsHVwvUcAjHZKv2earm89eOb8+LmxC0q/SIvFpBmvCh4cFWsQ4G3nsxwJj+vOf8tRVWwhb2qevdGQvASQicAsGOhaDYjei18LmKYSBnGBxzhmH5l/2g/SYU4adYRB2wQHUuD65OqUBsFIjbDXlxGZgKKxi9HoxWA3WJE5FHHYj5wwGlhcARWrkildmJM6NCYUsJhy7HCn22FepCG2L2WUFkgMdYOXvhnjiM3DEev9uj4KpaA+vnGpsV7OOK0DQEfIEbELgE81Sev8AFaOqLevd4nDJlCgYNGoSmTZvi8uXLmDFjBuRyOUaMGIGQkBA89thjeP755xEeHg6TyYRnnnkGt956K61o3UBwN8gKhRxGowHJyc1QVlYKtVqNqKhIqNVquFyuqhBrNex2G8rLK0M2y8vLecGgsljMFVitVhACnDp1GgqFAnabA3K5HBaLBSdPnkRqairkcjmys7NhsVnBsizKy8uRn5+PuLg46PV6hIWFoaKiAgqFosrzCtBqNbBarbicexnt2raDWq2GXK5AWJgJFy9exKZNH2H//n2IiopGfn4+2rVrB51OB4Zh4HA4UFFRgfLycqjVqiqxszJnXUiICefPn4dSoYLD4YBWq63KY6mD02GH1WrlPcaKiopgMplQVlYGg8GIX3/9DadOnUbXrunX+zRS/MAJTvUR0stx9uxZ5OTkIDk5GR06dPApBiN+LkZYLAYAoqKi8PLLL6NXr16YNWsWdu3ahcceewxPPvkkJk2ahLCwMJ81cYIUN87Zs2fx7rvvYv369bDb7ejUqROeeOIJ3H333QgNDfVZu7DgDDcm55Ep5bkpXBMnVMbFxWHIkCG45557cPz4cXz11VdYv349Nm7ciJ07d2Lo0KGYNGkSmjdv7lUhWarojFB0FAp3NS3WIlXBuiELpPgT4zh7OJEwmHWIPRW5H3yE4jCHOJS9Ou/M2no+irnW+Wyff/55jB49Gl26dEF6ejoWL14Mi8XCV7mmUCgUCoVCCYSU96GdyOEissockFyV6wCejkp4KitZcwVXqrwo5QwBBCHbLiLji9d4SJUoWSVUcmZ4zSXwmpTxdgi92a56Y/J/69kBjRUIm1JVvjnEXor+Qqyrg8v7WB9w4yjhXSE6UBI0JyHIdmsxYfsYJO93QOYmUF0uBRgGtvaJUJodYIrMQFw0LC3CYQ+TQ2klMB3MhTKrEEpC4Ggeg7ADBYBCDqKUIz9dB9NZAk2eBVl3h0GXR2C85ERFggrGLAJVuRKMGyhP8SBytxKT7COxqO+X6KzO81sgxys3Iwmc97M2cHNwhWdkjLdXqrKqYrayvt90EtS78JidnY0RI0agqKgIUVFRuP322/H7778jKqrSJXXRokWQyWS4//774XA40K9fP3zwwQf1bQYF3jekarUKnTt3gsfDQqtVQ6fXQi5nAHgglzNQKGSwWCrgdrthsVigUCjAsiyKi4sBVFYhDQ0NRX5+Pu8ZqVFf9V6UyWS4cuUKTCYToqKiYLPZ+HD6vLw8MAyD0tJKwdNqtcLpdMJisUClUsFsLoHHY4JGq64qKAO0bdsWGo0OJ0+exI4dO/HHH3+gpKQEdrsDYWFhOH36NGw2GwoKCqBQKNCqVSvo9XoolQq4XC7o9Qbk5eWhsLAIMTGxkDFy2O1OREREwGw2w+12QyaTIf9KPl+Ew2AwoLy8HAqFAm3btsWhQ4eQlZWF9PRbaOhRI0bofSasABwsYjErIyMDFosF7du3h9ForPW554p4cON269YNX3zxBZYuXYoPP/wQ7777Lv766y/Mnj0bKSkpXqIgJz46HA5s2bIFM2bMwOnTpxEdHY0XX3wRY8eORUxMjJfgyK2DExyFlZjFORD9iY8cYhEsLS0NHTp0wJgxY/Dpp59i7dq1+Pzzz/HLL7/g2WefxYgRI/giNFKimVCoq49qytwY17P4E3d+3W53QK9LKc9IcQi38BzV9D18I/Lggw+ioKAA06dPR15eHjp27IgtW7b4FJyhUCgUCoVCESMThVGLnwtFR+F+riCNnCF8JWx/cPkPZajMI8mCgaxKnPQIvCw9VSHVwpBvbh7gqvcjJ1a6BPaL8ziyVV6cQhGUG5PzxKy0CXyfyjbSaxAKjsoqm4TCoPjqVVyRuroK1R5RG6mre2FVbOFznzyXEojzFUrNfzX0uDL0W4jughJyhw2KMjuIVgXGxUJR4YL8THblEScEtnAFLAkMiAzIS09A7D4PNIVOKCqccDQJRWmKCqpygvCTLsidHjB2F5I2FcMZqYfcwUJd7kF5ghwggCMMkNsZOMIY6C4pMPdMf6xsuwJgiJf4aydyyEBQ6lGjyKMHAGgYF1xEAZ3MAT3jRKjMiRAZAxchUFWJrsog7g0q5+A+G97h+JXHqVL49gjaykVieENR78Lj119/Xe1+jUaD999/H++//359T00RIM7fxjAMkpOTERERDrlCDr1eB5fbCZfbWek5KFOjuLikKsedE5cuXYJcLkdBQQEvEmq1WigUCuTkZCEsLAy5ublo1rSyqAyX8620tBRutxvh4eHQaLVwOp2w2+2w2WzQaDRwuVx8ri6VSgWbzYaioqLK0FK4ER4ehpBQI2JjY+FwuLBv336c+OsEPB4PlEolLBYLTCYTCgsLUVJSaa9arQbDMAgJCUFeXh7Ky8vhdrvhcjlQUWGFTqdHWFg4OnXqhMuXL8NiscDj8UAhl8FcUgKbzQaTyQSz2Yzw8HDExMQgLCwMZ86cwblz52C326HT1a4wEqVhERdo4QQ3sWdfIIRhs1lZWSCEIDk5OagQaymbxGNzNoaHh+O1115Dhw4dMG3aNGzatAnZ2dn49NNPcdNNN3mJh6WlpViyZAk+/vhjVFRUoHfv3pg+fTo6d+7Mr0/KK47zlhTnPOTWEuh4iD0nudcKhQI33XQT5s6diwcffBALFy7E1q1b8fLLL2Pr1q1444030L59e7/jCb0dhaJoIJv8eTk2hDAnXnt1Xpnc8RZXiA7G85Z7n3KCIwA+RF8cBl2djcGuI5j210PonDhxIiZOnHjN56VQKBQKhXLjI/PjOSgTeA3y4qGEyFjpzXg1pFqsvYjFSSnPSaGnojDkWyhuygS5Jf3mhsRV0RHwLWgjRU28EYXzcPn96gupn97Fcwi9J6sTM6UQFmaRKqrCoWEqC8pccuswZt3TiDrngSNCCUWpDbJSCzyFxVBkywEZAygUcEcaYcx2wBqngcpMoC4BSlrK4RhGIFcwYI6r4TISMB4GMrcCprMASYmCJYFB+AkPtAUExl1nYSQEiAjD2bHR8DS1AYU6RB11obQ0Gv1ynkNCkyK0Cr2CSHUFzC4t3B45yt1qhKmsaKXLR1NVISAD7B4VilgDylkN8l0h6GM8jhSF1atIztVj4j98G1Wh5pzoWOnpWHnQXcRz3aqNN3hxGcq1gnvzVX1ZVd3UMgwDi8WCsLAwGIx6REVFQaNWg5HJYLVaYbVaUFFeDr3eALlCDq1Gi/Lycly8mAePh8BsNkOv1/PCIZeT8erNLIFSqURISAj0eh3OnTsPm80KlVoFp9tV5QVphNlcjJiYaNhsleHNbrcbBoMBbrcbISEhUChl0GpNCA8PR3R0DMAw+N/Gjdi0aXNltV4wcLMsNBoV701ZWlqKvLw8REREgGEY6PV6uN0uREZWhpAXFFwBQHDlSj4cdidSklORn5+PmJgYnD13BlqNGgqFEgcPHkSHDh2g0WrgYVkkpzRDTvZlREZG4uyZ8yguLoFOpw2qEMX/s3fecXLU9f9/Ttver+21XO6SSw8khBYpgoAUUVHUL18RUfRLEVCKDQULiAgIKlhQBJWfomIBxEIVCColhBJCSL/LXa7fbe/Tfn/szWZvs5dGQMq+Ho973O7OzGc+n5nZ2ZnXvN6vVw3/PVgKtHLirVzRNx0ZU+k9aPl6ut3u16SPsixz7LHH8q9//YtbbrmFtWvXsm7dOubNm1fq75YtW/jKV77C3/72N1wuF5deeinnn38+oVBoilqwnMCqXI81vZzMqnYM70m5s6UyPOSQQ7j99tv505/+xHXXXceDDz7Iyy+/zFe/+lU+8pGPlGwQqq3T2gaW+rGSIJ3ue2bt13IV6Z70vxLV1rMnJcrl6y8nfav1ydpPsixPOdbKlZLVFJy70589LauuedbWUEMNNdRQQw1vdqiI5M3iNaFYQdBZhN+rhUU6VitPrlwnVIbCTFVFlvfNant31l++zKvBviYbXw32tl6pPJil8r0VKLNR9XP2fz5O6390Us0SDc8VSUczk0NsqMOYiEJBA1VD3tCPoCi0b3OTnxFE9UiMNciYpkDAkyVwVASHpLFmZSfy7CTCkgJOWeOLnf/khXQHv33uYFoe6MYxoSKnVVr+pZHscdL4dBQhW0DQQzgnJBKtYf45tw4UE5c/y6z6CQ4LbaZJiQPwSq6FDelG+lNB0gUbYU8Sj5zHK+UIedYgCSaO3dxoO/NsNCr8HV9v/Pfq1GrYx6juq5ZMJhkbG6OhoYlQsB63y4ss2xEFGafDTT6nksnkiUYTBPwhcrk8uVweu327gtEiFp1OJzabjba2VhKJGKIo4PE6GR4eIJVOkMtn6ZjZhtfnZmxsmPGxYTLpJHabhCyJjI0O4XE7cDoUFEUknU6QTifxer3k8iqxRJpAsB7VEHhu9Rr+8Od7GRodI5NXyeTzOF0uli5dyjuPPJKuzk5kUSSTTpPNpAn4fAimiSIr5PN5MpksTqcbWS6GyESiE2SyaUwMkqkENsWGqhroBmwbHKK3byuarpLJp7A7FUQZZnV3MTo2QiwWnaIks8I/rNfln9du6v87qBYAsrv7o9wH0VLOCoJALBbbJ/uzkoQaHR3l8ssv55e//CVut5vPfe5zHHvssSUl4MqVK/nEJz7BfffdR3t7Oz/+8Y/58pe/TCgUAqoneVvHoK7rJV9Wa0w7UxbuSqFXPr1yG7vdbj760Y/ypz/9iQ996EOMjY1x6aWX8pWvfIXh4eEd+lnZTnn59XQkYLXE5/Ll90S9uTfYk+XLj7vyMZW/V1UVXddLYTLW55UKztpDjBpqqOGNiBUrVvDe976XlpYWBEHgnnvumTLdNE2+9rWv0dzcjNPp5Nhjj2Xjxo1T5olEIpx++un4fD4CgQCf+tSnSKVSr+MoaqihhrcCrFJq67X1B0xRKepm0ZdRRazq8whTVYjlJF+lQlKcXEcloWipLCtVl4pgIE6+tv4AFCs8ppIwLfu82rRiH3afwJmOZBKZ2s6eKhB3tb5K7KzPUtlftWnTrceomM8ABnUbN/QdT9Nf7dgnCoQfH0eKZUAU0Wa3gD4pEGhvwVzQBUE/pscFwNj+dhIzZAQT9JyEJBq8N7yaKzvu5eSjnyWfsxFZV4ci6UiYeKQ88rhCplEk0WHDkEVs0QKhtVkQBBAEXGsGscd1zEnp4SFzt3BMxwYCtgwrYx1ct+bd3LzxKNYkW/DJeRYGhnl36zo+3bKCr7b+nfd7V+MVDbzC9AE1ldvYUjiWb6diqIxRUklW2xevx71HTfH4lkKZx4U+maw0Po7NZsPtdk+WBBanG4aJKEo4HK7JoBeBTCbD6OgYmUyx9Difz9PW1kYmk6GhoYFIJILD4QDA5/MhSWmi0Shuj4tUKkFjYyMTExN4PG6SyQSyLNPU1EAymcThsDM+Ps6SJUuIx2PE4zF6t25F0ww6OjoYi0zgdblIZ7KMjo6yeUsPAwMDpXEEfD7cLhfNzc24HA4GBgaIRqMwSTZaITZer5dEMjEZgmOydevWyX40MTw8hGkaKIqMLMukUml0Xaevr4+VK1fS1TWTpqZG4vE49Q31pUCdRCI5uW3NHcpE94VfXQ2vDcrLr8tVuuUn1vIyVwudnZ0IgsCGDRtQVRWbzTatcnJnqKaq3LhxI1/60pd46KGHqKur4+tf/zqnnXYadrudQqHAP/7xD770pS/R39/PIYccwg033MCSJUumEG4WWWX1qdwf0CK/NE1DUZTdVgfujhJyOuXinDlz+OEPf8jBBx/Mtddey6233sqmTZu47rrrmD9//hRCrhLlQTrl+6B8fNY+2tPy+f8GKr0eK8N9rD/LQ9c0zVL6uDX/zlSfu4u9OVZrD01qqKGGXSGdTrP//vtz1lln8cEPfnCH6ddddx033XQTv/rVr+js7OSKK67g+OOPZ+3ataXrx9NPP52hoSEeeughVFXlk5/8JGeffTZ33nnn6z2cGmqo4U0MiwSspgYsJwwlwZwSIGNNN8ypoTRiRVuVadbWZxahaPk8isJ2QlHCREUsJW5Xq4adEiJTanfH6VbfdxxbdeyKjJxuuWqk467UkZZfYSmMpnyisBOSsWxdlidj5V10JVlqzSey3bMwZwo4BBOdYiK4JBQ/u6rvvWx6qoNG3SAbtmPKInJaRRqNIWUKmJkMgsuJHnQhZlW0Bh+xuS5i80Dz6kgpEcecON9d+FfqpBQJw8FfEkt4erQD13NORBW2uMN8ftNpfPCgZxEL4BrR8W1IYIoiuseGbcsIZj5PYVEH44sbSczROXDpegZSfp5eOwsxXfSDNBUTV0uKuaExjgxu4CBnDy5BwyYYKJPjUYTi+KzDUDfNIkk7zfW9RThWEozlRK1FTOqT3o4qJsbr4O9Y3p8a3oIYGxsrPVHevHkzjz/+OBs3bmRgYICenh5yuRxerxcoPoHeuHEjIyMjpfRnt9s9STBK5HI5NE1D13WamppobW3loIMOIp/P43K5SjfMTqeTSCSC2+0mEAiQzWZJpVJEo9FiCnYuR2tra+mmOxD0k0onkUSBdDpFKl1Mp37+uefwej14vB4cDgf5fI5QMEhdXR2hujocDkeJsGhsbMTn87Ft27ZSErfH42Hz5s2lklmXy4Wu62zbto1sNoum69jtdtxuNw67nfXr17Np08YSAeT3+1myZAkAd999Nz09PaUE2vLSVat0spoKrYb/Dnbme1hOsFQjHQHmz5+Py+Vi9erVRCKRV0XIlPtO/vvf/+aMM87ggQceoKuri1tvvZUzzjgDh8NBNpvlZz/7Geeddx4DAwOceuqp/OpXv2LJkiWlEtxqykPDMEoeruUkl91uf82DV8r74/V6Offcc7n99tuZP38+jz76KB/72Md4/PHHi/6t0xCbFlFXThKXf5cq1ahvVJSPb7p9VDmPoihTSMdqbdVQQw01vJFw4okn8q1vfYsPfOADO0wzTZPvf//7XH755bz//e9nv/3244477mBwcLCkjHzllVe4//77+fnPf84hhxzC4Ycfzs0338zvfvc7BgcHX+fR1FBDDXuKN5LquVSyvJNwGGPSM7GkVKxCJFZ+Vl5evbcoVzdW4tW0+1pANyfJLYqBL29EcqhIlm2HSzBLn6kIJA2J64ffzdp/d9H1xwS+V2I4xwrYRpJIozHMRAoxlkKbNwOjvRF5qFgKbTgk6l6I4+0B06njHhBIjblpVyZ4KdfORf84gzv+djRjaxtwTJg0vJil+VGR+TdOsOKHh9Dxjwz+FT2wZRtizzZsfePED21n28fnErkkzaL/XUvT7HFWrpmF/MN6Ztwr0PAsuAZF5PosH539LOc3P8K73BtIGg42qvW8VAjzg7EjOWXlOfw5uQiHsF3RuS9hkZRWmrVmvvZcRk3x+BZBuVIml8sxNjaGzWYrEXL9/f0MDw/T19eHx+PBZrPR09PDvHnziMfjJbLQbrezadMmIpEITU1NhEIhhoaGSCaThMNhJEkiHA5TX1+PKIo0NjYyNjZGIpEgkUjQ3t6O2+0uhdLY7XYaGxsZHx9n48aNCIJAR0cHs2fPRtM1TBMM06CQz+H1+XHY7aiFHPlcDrvNhixL2GQFWRJpCjcSDAYJ+HykUymCoWBJ5VhfX09/fz/RaBSbvVhenU6nyWazhMNhABRFYXx8HACbouB2e/B6vQwPD7Jt2zYGh4YwDB1JEvF4PKRTGZqbm/nLfffx5JP/Yf/99+OQQw6hq6uLUChEZ2cndrt9iqLuv5my+3ZGucKrMhDEUtVVevJZ08qXg6Licd68eaxevZonn3ySU045ZQdF3u70xUI+n+fee+/ly1/+MqOjoxx22GF873vfK6kB4/E43/nOd/jZz36GIAhceOGFfP7znycYDO5AuFnknEU2TlcGPZ3nY+XrvcF06xIEgWOPPZaOjg4+//nP88gjj3DWWWdx/fXX8773vW8KyVatjfI07nLl4N709/UgKXemgq0kuqv5i+5pqfjuhsTsLnFZ2f83MrFbQw01vPHR09PD8PAwxx57bOkzv9/PIYccwpNPPslpp53Gk08+SSAQ4MADDyzNc+yxxyKKIk8//XRVQhOKv6P5fL70PpFIvHYDqaGGGqbFG0n1XJ4evStYITIqYlVCsJQ6bQW77ANysFytWOnnWK4WtN7/N1GujHsj3slKZf9VQGF7grVqigzrHh7d3M3MB/NI0TRqkx9b7zhGJIapqgg2G2Y0jpxIYWoahqoieNzYNR1TFAjfO4FrdCa63UB8Xubxd8zjJ48eS/evM4wt8+AaM5lYKOKIKqhugdSCOpwRHcMmkVvcjnP9CACbPt1G/UEjvC+8kRUjs3n+vgUEN+p0xjRs0RyGXWbbMU4+9q7HOdW/iojuYnOhkccLdWzLB3kl1kRBl1B1if2aBznKtZ6c+doRwpbqUUEoEZGvJWrE45sAu3vDCVAoFBgZGUFRFHw+H7Is09jYyKxZs9B1nVgsVkqDXrduHYlEgo6ODhRFIZPJEAqFaGtrIxqNEo1GGR4eplAoEAwGmT9/Ppqm0djYiGmapNNpuru7KRQKJXWjz+fD6/Xy73//m2QyiWmazJo1i3Xr1hGPx1mzZg19fX0sW7aM/Rbvx9DQEBPRIunpdDpQZAm73YEggGloeFxOUskk8/fbj+XLlxMOhxkbGcHtdtNQ30Df1j5UVSUej9PY2Igky2zYuIF8voCmaYiiiM1mw+FwsGnTJkZGRvB6vWjadq9Gk2IZp8NuJ5VK4/X6yOVyiKJIR0cHiUSCyMQ4L7/8Mvl8npdffhmn08myZct45zvficfjmUI+1m7gXz9UI3bKy1bL5ykP/pBledqyXZ/PxymnnMJzzz3HHXfcwXHHHYfb7d7lvi3/nlrrSqVS3HrrrXznO98hk8nwoQ99iKuuuorW1lZM02R4eJjLLruMu+++G7fbzVe/+lXOOussHA5HqUy6Ug1okY7WOsvJ1mpp168XrPV2d3fzs5/9jCuuuIK77rqLz372s8TjcT760Y/icDh2We5drkgt3wZvJliK7mpktSzL05b+19SONdRQw5sVw8PDADQ1NU35vGh1M1yap7Gxccp0WZYJhUKlearhmmuu4Zvf/OY+7nENNdSwpzjxxBM58cQTq06rVD0D3HHHHTQ1NXHPPfdw2mmnlVTPK1euLD2AuPnmmznppJP47ne/S0tLy273pTLIpWoATJVS7Gq+jTukXVchJ6vNV22eynXui5Cb7e1Pxa6IwunSpsshCVNLq3eXfBTZtTdkeTuVJdV62XRJEKZ4GJYvZxGMStl81rIGoAgGMd2NMW5ndJlEva0e20QWU5mkuSQJI59HdDoQXE5wOVDDfpIddqLzBaScgHerSapNwJRA0OAnzx6FoAtIWwZp7pMx0hl8L9SD3YZ9wsnwO1w4R00yjRITB2vM+5GPwaMCHHTMWg7w9XHb+uUYq/00r8zj6I+T7Qyy6X+9HHDoRq5ueI71uWa+3PNBxtIexse8CEkZJS5SqNOZM3eQs7tWsMQ+iGty+yqCMIWc3tX+sUqpdza/Nd0iH6dLyd6XqBGPb0JYfm4w9SbdNE1GR0fxer34/f4SIacoCqFQiPr6om+hYRgMDg4yODjI888/jyAIzJo1i/Xr12Oz2QgEAtjt9hL5ODExQT6fx+v14nA4ME0Tm82Gqqpks1k8Hg8DAwM0Nzezbt06Ojo6Sr50L7/8MsFgkIMPPphVq1YRiUQoFAps3bq19KOk6hqBQIDm5vAkeQFtzWHWrllDfV09TruNgw46kJkzO0gmU+i6zuLFi3nxxRdRVZX+/n6CwSAtLS309ffR1NTE4OAQHo+HWCyGqqo0NTWxdetWDMMolmNrJulUURHp9Xrp6prJsgMPJJPJ0NjYSDabx+/3s3DhQjRNQ1MLDA4OUCgUcLlcFAqF0pM6i5iq4fVHJck2HXFTTeU43XySJHHqqady66238vjjj/Poo49y0kknIcu7Pl2Wfx/Hxsa4+uqr+dWvfoXNZuPzn/88F198cYmoXrduHZdccgkrVqygvb2d73znO5x88skoirJTtV81f8fKEJnKst59gV1t5/LpjY2NXH/99TQ0NPCTn/yEL33pSySTSc4555xSGXg1r02rnfIS7L3Bnnoc7i2qlUlXhsqU76PyZV7LfbU7qNxGbzZyt4bXF68HKV47BmuYDpdddhmXXHJJ6b1VYVNDDTW8cfBaqZ73VPFsEYQWAahgopaFvpSrGauVX+9u2zpFf8edKS53RjruqcrxtVQiVvZld/q2M9KxkrysJB13lY5gUCwBRyjzkxSKHoe2SfIxZ0LOFNmo1vPbkYOpnxVBXd9ALijj6Mki5AoIbhempiEUVIzONvJNLtJNMpH9TJQZaZp8KQbXNDHWYFLXFWWiN4gSF7nxsN/zy8HDyHWEEV7pwdR1zP5B1MMX0XOmiaykSU848K+TaPu7iBp04D1hGLuocfN/jqH1ARFR18jVKUQWNGI7fow5rjSDKT83xo8lr8okRj04+xScJmiLU9TPSXFs83re43uBFimPTRCmEMLKbpCDFokoTm6j6Ujkau3UFI817IBqYRnW/4GBAQRBwGazAZDJZOjt7cUwDBwOB3V1dWzdupVYLIbP5yMYDBKJRBgbGyv5OWqahqZpJeJyxowZFAoFcrkcL730EgceeCAej4dcLgeAqhafQ7jdbhRFKZVuOxwOFEWhqakJn8+Hw+HA5/MxPj5OPp9n3bp1DA0NEQ6HSSQSOGx2DFMnk80gCDqdXTNpbmoikUxQX9fAwvkLwASn3Y4kSRQKBbLZLLIsl0pSM5kM+XwBSZJJpVIlpePIyEiJPFUUpbicpFBfX086nSYSiXD00e9EEAQcDgfpdBqbopDJ5PB4PMyeNYtNmzbS2dlJPp8vkQlz586lt7eXzZs3s//++wO1G6c3AsqVieUqR0sNuDNy0lq2o6ODM888k29/+9t897vf5eCDD6apqWmny5erEjdt2sQXvvAF/vnPfxIKhbjyyiv5yEc+UvImffLJJ7noootYu3YtixYt4vvf/z4HH3xwSQ1X3mY5yh86WCj3gKy2DfYWlcTU7hIPVv/9fj9f/epX8Xg8fPe73+Wqq65C13XOO+88nE7nFCVneX/L/Sz/m9gd8rLaNqlMFa9UblazA5iuvT0pnZ6uPzXU8Fqi8kHI5IfF/xWf1yoC3tqwbG1GRkZobm4ufT4yMlLyzA6Hw4yOjk5ZTtM0IpFIaflqsNvt2O32fd/pGmqoYZ/htVI9747iubJ8uvy9UfG5pYx8teXU21OmiwTnvlQ2vlFRukMpK/3d2zLxcvWiFZpircPynKxGiOZMs+hLicDD6fl8/7l30VifYHzCizDLIB8S8W1xI+kGpteFkFdB1Rhf5gMTdKeA7tSRTdi2rgnTbdAyc5wOb5QDGvt5aOV+/KjvaK7u+jM33nQ8a/+8BF+vTi4gkjguzalzXmJ1tJXNZj1S1olnS4KeUwPMdmRZedd+uOwwcJyGEpUwBZDykH2hnqhcj9CRRk3bQBVRohKF+VlOX/QM+zn7aVcmqBPz+EUBqhybFllYGSCzr/B6XJ+9Ecv4a9gJLALFem0pnaLRKOl0MaV5y5Yt9Pf3I8sydXV1pFIpBgcHGRkZwe/3Y5ommzZtIplMIggCmzZtYsuWLdjtdiKRCNlsFqfTSSAQwOv10t3dTXt7Oxs3biwpdxwOB3a7HVmW8fv9tLS0kEwmGRsbQxRFxsbGiMfjNDc34/F46O7u5qCDDuK9730vJ510EqIosnLlM7S2tlBfX4dp6qTTafK5LGqhwEurX8AwNDxuNwceeADBYABZknA4HMyaNQuPx8OMGTOoq6tjwYIFeL3eSe9KhXg8Vrrht9lsjI+PMzQ0VCIe06kU6mTYg5Va3NraSi6bRRRF4vEYsizjcDhobGzE4/EQDoenKJescem6zvr168lkMv/lI+P1wTXXXMNBBx2E1+ulsbGRU045hfXr10+ZJ5fLcf7551NXV4fH4+HUU09lZGRkyjx9fX285z3vweVy0djYyBe+8AU0TdsnfbROnOVegeWKQGs/WqimOBNFkU9+8pMsWrSIlStX8rOf/YxCobDLECFd13nqqac444wzePjhh5k1axa33347p59+Og6HA1VVueuuuzjzzDN55ZVXeNe73sWvfvUrDj300GnLvy3fQ1VVpxCPVsm4tVzlg4jy5cv/qk3bG1Tzlyz/XBRFXC4XF198MVdccQUA3/72t/nxj39MPp+f0qfyEnFrXwG73N7/TVTblpqmTemzruuIolgih6dL997ddewu9pS4fTXHQQ1vH0xV9Fr8okChoJJOZ4hEooyOjjI8MsLwyAhjY2PEYjHS6TSqWjy/l3ufTndequHNic7OTsLhMI888kjps0QiwdNPP83y5csBWL58ObFYjFWrVpXm+ec//4lhGBxyyCGve59rqKGGNz4uu+wy4vF46a+/v3+HeaTJZOnyMmejRNAUA2YqS653xxuyEjtTR1ZLoN4b7Ck5s/fE365LpafDrvq4O2MomBaRNn2ytaV2hCIZqZqQNkReLIS5YeRYbv/Jewg+5mC4P4SZkTECGgWfSa7Rge53o/udjBzdTGFmA95+FSVr4t+i4n9FxvGEF/96EcewzGBfHasenccT9y7F1SfR+2wbp/3tAp55vpuDPrya4772BMGPbsNu1/jzY4cw9sd2Zt1k0PjXzZiiiLcH8leEsUdNvEeMovjzqOECAIIBYkHANSQgbHRjH1AQHDoL3rGFy5f9jQ/4nuMdjkHapTx2Yer+tBSL1me7UiXurmrRmq887fr1QE3x+CZDuTpIEAQ0TWNsbAxJkpBlmYGBgcnAlGFSqRTBYJBwOMzmzZuZmJigpaWFQCBAb28vhULxC+FwOJiYmKCnpwcoKqg6OztpaGggn88TCoWIRCJ0d3djt9vRdZ1sNosgCBQKRS9FSZKYPXs2//rXv3jllVdobW1lfHwcm81GfX09uVwOWZbp7u5GlmVOPvlknnvuOQYHB2hsbKCvbytNTQ2sX78Oh92F1+Ohvr6OhoZGFixYQC6fw+12E41GCQQCuFwuXC4XiqIQDocxTZOZM2eSL+QZHBrGZrOhKAp2u700PosUFUQRtVAgHo+j6zoOpx1VLQAC4+Nj2O0OZEUhGo0zPDw86QmpkkolCQQC6LpOc3Mz/f39+P1+CoUCY2NjuFyut7ya4/HHH+f888/noIMOQtM0vvKVr/Dud7+btWvXlsrNL774Yv72t7/xhz/8Ab/fzwUXXMAHP/hB/v3vfwNFMuY973kP4XCY//znPwwNDfHxj38cRVH49re/vcd9qnbTWv4dsVCpyrE8QKt5c4qiSDgc5rLLLuPTn/40t9xyC4cddhhHHnlkqa1yFY9FYt9777189atfZWBggMMPP5wbb7yRefPmAUW/xx//+MfceOON5HI5Pvaxj/H1r3+dcDg8hWyrHJPl62gRp7quT6tyLJ/vjQBRFHE6nZx77rmIoshVV13Fd77zHRwOR8nLcrqycosgtsZbOa0ce0pcVFMW7g3K27GSq61+WyRqpVen9fCi8njc05LrPVVDTrd8jfR5e2N39791fkkkEgwMDLJ1ax+9vb2Mj4+TSCTIZrPk83kKhQK6YSAKAoIoYFNs2Gw2XC4nfn+AlpYW5syZTUdHB83NzVOsJXbWlzfKOe3tjlQqxaZNm0rve3p6eOGFFwiFQsyYMYOLLrqIb33rW3R3d5eCJVpaWjjllFMAmD9/PieccAL/93//xy233IKqqlxwwQWcdtppe+TtVkMNNbzx8FqpnnemeC6VPU8mUZe/LoeKiIQOgIKxgyfkrvwbqwXSVH5WqXhUMFGEYrmrpa605iknk6a2ueP78vkkoUi8WSXk1vRKgmqXHoBC0TMRmNwq0xNQurl9GQvW+tQq00rrqGjf+kwv+0wv+6y87YIp4hAMDCBtFukqBYOMKfOn2IH87ZeHo2RM/AMqyXYZ73oF8/AY+byMEZHRbSL9J/jJtuiEXgQpU0D1ubBHdTSXSD4EzhETUxaQ0xB+VMIRURFMSDUrSAUBW0yk4BdYt2IRGwsGrm0Z2pM5hFQfCAJqez1mcz2mIlK/MoowMELDGuCJAIGggSmp5OolNJdINiQgquAZNBk8Tuf9i1/kjNB/aJIKO2wn3TRRBBFREFBNA9Wqoiq7Dqqmfizuv2KptTHN9VRl6bVY1sbrcT9QIx7f6KhyDJQrusbHx8nlcvi8PiRRLB46pkkqmUQSRew2O6ZhEAoGcTgcJJMJdN3A7yuWUqdSKQzDpFDQ0HWDVCpNLpfH4/GyaNHCyR+IYZqbm+jomEksFkPXdUZGRnC5XECxpNvv9yPLcol8c7lcpNNpCgUNpyNDNBpFFEUCAT9+v48FC+YRCPgZHx9j1qxZmKbJ5k1byGULuF1emptbGR2eYPbsbgRBIJGIEwgEECUIBIol24oi0djYQFdXFw6HHU3TCIXqkKTizb6iyAQCQdrb2xgdHWPbtm0UCgUkSSoSknY7yVSSmR0dzJw5k1Qqgc/vxefzoaoqLpeLdevWEW4KoygSTqeTVCpFKBQiGo1SKBQIhUK4XC6effZZ6urq8Hq90+6vtwLuv//+Ke9/+ctf0tjYyKpVqzjyyCOJx+Pcdttt3HnnnbzrXe8C4Be/+AXz58/nqaee4tBDD+XBBx9k7dq1PPzwwzQ1NbFkyRKuuuoqvvSlL/GNb3yjZBWwu6gkYMqJnenmlSRpSml0JfloKYtPOOEEPvaxj/Gzn/2Mr3/96/zmN7+hra2tNA8UT9SpVIpbbrmF66+/nmw2y//8z/9w5ZVXlm6kxsfHufLKK7njjjuQZZkvfvGLXHjhhfh8PqB6uraldLRILKt/siyXFILl45IkqaQmeiMcc+Xb0m63c/bZZ6OqKtdccw1XX301brebj33sY1MI18p9aY3J2gZ7Wva9q77tC1jHUCVxaClRK/dT+TLVyNYaani9UH6uqebhapommUyGTZs28cILL7Bp02by+UJR8d7QRLiphVld3SiKgsPhIBKNcOdvfgOCycfPOgu3283oyMgU+5ZIJMJTTz3D3XffQz6fZ+bMDpYvX87ixYvx+/07eNXWvhNvLDz77LMcffTRpfeW7+KZZ57JL3/5S774xS+STqc5++yzicViHH744dx///2lNFuA3/zmN1xwwQUcc8wxiKLIqaeeyk033fS6j6WGGmrYtyhXPVtEo6V6Pu+884Cpqudly5YB+1b1XEke6qaATTBQMIoko1BMQd7dMutqgTXWesqJx31VZm2RlNIkqSgJYJStXjeLysryPk3Xx13BIv2s9e6qX5XzVlum2L8970d5eyJgEwxyZvH+IGMoiILBw+kF/PC5o5jxW4mGbI50i42CT8IeN8mFBIwXAphzMwi6QMEj4BoxMewSqXZwD7vJ1kvIWRNRM/FvMlAyxdemCEpSR7eLiHkD94iG5pLJNQjoCkh5A3tERfPakAFJ1SCbQzBNxEQGfC4EVUPwezHGJmBwBGFkHEHXcdsUtAUzGTxBQUjKyI1ZPjjnJQ7xbiYgFgVgkiBMUX8qwqSXY5naUxK2E4zVICFgVJCP1mflqBZOBEWiUxZe+0LoGvH4Boc5eeBZ58fyMtFEIoEiyTS0tZLP5RkrqBSyOQqSTGtzC06nk2w2i2ma+Lw+FFlBVQskE1HsNhtet4dsOsfg4BCCKCEgoygKI6MjRGIJ/MEAc2bPKnouzpxRJCrTGbKZPB3tM+jr68PpdmGz2cjlcuTzeVKpJKII2WwWRbaTSmURRQWXy4bLZaevr5euWZ24XC5aW5ux2234/UEWLFjEwMBDSKINSXQwNDhGc0s7Xo+ffL5Ae3s7Ho8LTfORSE6QzacIhvwceNABtLY1Mzo6ijam4/F68Pv9k+qLHM3NYex2Bz09W9E1k1g0gWGY5ClQF6ojl89itym0t7ayta8XRVLIZ/PU1TXw8upniUXjSILEjI52FEUhFiuWYXu9XjKZDNlslo6ODl555RVWr17N8uXLpwRJvNWTruPxOAChUAiAVatWoarqFGPpefPmMWPGDJ588kkOPfRQnnzySRYvXjzFA+b444/nvPPO4+WXX2bp0qU7rGc6Y+lKf8BKggqqK+kqlWbl5GM57HY7X/jCF1i5ciXPPvss1113Hddeey0ul6u03OjoKFdffTV33HFHKUTms5/9bImE7unp4Qtf+AIPPvggdXV1fPOb3+R///d/S09vp7vht8gsq1/lxGPl2Mo9BcvLF6sRmpXbohx7qziqNoZySFKRuP/MZz5DPp/ne9/7Hpdffjk+n4/3ve99U7wtpxtTeen8dH2Zjmyu1q/d8VishvJ5LBWY1S/r+LMUqdWWLZ93V8ndu1I17s15pbIkv1p5fw1vL5QfC6Zpks/n2bBhA/fffz///vd/CASCLFu2jEwmSyqVIpfLUchrvPzyWtatW0c8HueEE07goIMOYtHixRTUPHa7nVQqxQ033sjW3l6OPvpozj33POrqGmhra0eSRNLpNKOjo/zlL3/lpz+7lUULF3Hyye9h3ry5UywkasfmGwdHHXXULs9JV155JVdeeeW084RCIe68887Xons11FDDa4w3k+pZEQx0U5hCMla+fyNiCqlYcbo1KCopoUjwVU7fXehl3MKeoBT6sjfrnPxfTQlZDtWEnCmhI6CaInfHl3HPhv3w3e9mzuoEsflesvUK3m06hiyQnCGieUyMziwuV55ESCHdouDrNQiuM4l3iUTnyNgSJrakTrZexh7XUV0iI4dOboSAxnHz15DW7GyINtDgyBJ0ZIjmXGxe0ACAMGAntMaOLeXGHlVRIllMWcKUhOKm1A0Em60YZmO3gW6gzZtBz/tdNDSNY2vRWd7YQ72SolFKlkhAK83bCpPZvr2s/SzsVMFqKSEVc/t7wzR3UEVO3RdmiZgsKioNtJrisQYABBAQMNleFqfrOpqm4XQ40XUDWVZwTga6FFOYVXRFIRgMIitKKfCgoamB1atXk0ylCNbVMzoWIZlKs23bAC+++BINDY0gmAyNjZDPZ/nwh06hvj6EYegoioLP60Mghd1up629nRdXv0hXVxcAsViMWCzGjBkzSCbTjI9FMQyQJJmCmiOXM2hpbZ6cN0pdXX2JzNM0jVmzulnz0hpyuTzhcPNkaXSxhDybzaBpKrIsodjsjI+P09BQTygUwuFw4HK5mBiPkMvnsdls2O12wuFGFi5cyPr1G8hO+jeqqjrFS89htyMIAiOjI9jtthKpm8vlGBsbY2hoiI4ZM0plAQ0NDei6Tm9vL42NjfT39xMOh3E4HIyNjaFpWokYequXMBqGwUUXXcRhhx3GokWLgKJptJWMXo5KY+lqxtPWtGrYlbF0ZQnrrlB+Q1te0lu5vOXnefXVV/Pxj3+c3/zmNyxfvpz/+Z//QRAENmzYwBe+8AUeeeQRGhoadgiRWblyJZdccgmrVq1i9uzZ3HDDDRxzzDFTjkEL1ndUFMWqSkdFUXZ7bFZJ9nSE6usNq09Op5PPfe5zpbLzL3zhC/j9fo466qgp/axGFlvqR6v0emfE4e4SFXtK6pWvv1zlWE707iz9vJxIrCRUd0aW7+k49tTfsVobNbw9YJ1fTNMkl8uxYsUKfvOb39DX10dzSyuHLn8HbW1tPProo7S0tHDY4Ufwwgsvomkac+bNJV8o4HK7aAw3MTg8hN3hQJJFUqkUXq+Xy7/6Vf7zn/9gGAaRaJRQqI5X1q3nmWee4dlnn+Xd7z6OD3/4Q+Tzeda+vJZrrrmW+vo6PvGJM9l///3eUNYRNdRQQw1vd7zRVM+7KpEGSqXXBVNERcQwt6dRV5ZbT4dKhWM5LG/HctXj3igQi30oX+f0KFcVlq9rdzRrpXb3gHzcWbtT+lLRnl7xf8pyTFU7Kkwtw47oLr6x+X1MPNyCKw2GYrLtOD+GBIYNlLRIqh0KHTmcnjwtgQRNziSxgJPxVjfDC3w41zlwjpik2wQ0twDIGArE5kooSQFPH2RaDGwbHTzWtwTHhIBhg7QE/RKoPhN5ZooD2/oZavIxNsfN6IgHMWsjtNpeVE2qJt6NOkJeBFlGkGWMmWHEdJ6Bo9wcddSLDGT8zPREEAWTJiVOg5RGESb9LQUBTHNKWM905dCVikdLGWm9LicZqyoeLeWkaSIKAnYE1NfR5bFGPL7BsbPSwoGBAfp6txIOh+nomInL7cEXCJLJZEik0pgI+IMhgsEgqqah2GRM0yQWT9Db28/EeAxFsWMYBgVVI5PJYIyO4vN78Qa8rFq1isaGIB/72EfRVbV0o+z1+orl1YEACxYsIJ1O43Q6MQwDVVUZGRnFMEy8Xi/9/QMkkwkcThvRaJR58+bgcDgmiREDn8/H2NgE6XQaQRBYsmQJyWSa3t6tpXLpfC5PPl8gnU4zPj6K2+PC4/GQSmWA4g17IBAgk86STKVIpVLouo6u67S1tdHbu5VsJlNMz3Y4isExdvskUaiSzxfo7+/H6/XgcrmIRmOMjU7Q29tLNBolGo3i9XkYHR3D5/Pi9/vZunVriXTUNI1HHnmE4447jmw2i8vlQpKkHXzp3mo4//zzWbNmDf/6179e83VddtllpYsbKCoe29vbgR19T3cX5d8t69guV6takGWZI488kosuuoivfe1rXHPNNSxZsoRIJMKll17KSy+9xNy5c7n++us58sgjkWUZTdN44IEH+NKXvkRPTw+HHnoo3/ve99h///2rKuFge5BKOQFpKeLKb753d4zWesqVgtZ490QxaC2zO/OVTyv3Dywn3LxeL5dddhmRSIQ777yTiy66iP/3//5faduUz1vuQ2iRj+WE6nT+iHtCQO5MCVrZfrkS1SKsrdJ9YAfVZrX1VBKM1n4uV6jurG/TTa+2rXelmKyRjW83mBR3ubXftyvFV69ezTXXXMMTT/yL7u45LFmyFJfbjcvlZvPmLfT19bNw4WKy2RwHHHAAhqFTX1/P7NmzWLVqFZs3b8Jhd7J27cuMjAwxPDyM3+dD13USySTpVIo7fvUr5s2fT3NzM16vh4ULFjBr1mwwRXLZAk1NYc455xx6enq44cYbmTdvLv/36f+b9P3aMw/UGmqooYYa9j3eSKrnYpAMGNOUOZf7PpYTlOWkYzmqhcMYVRSSOyMoy9uppHPKicnpqJ6dUUDlJc7GHl6+lZdw7ww7UzNWm2YRjdY0RdjuOTk1TbysHaaGyUiT8yZNAYdgkjNFNqt13BdZyljSTa7FQApnMA0RfcKOaTew+fPEnW6EGUUCr8GbJqMqjAtu8rrMu5o3sGx2L6v2m8nv/rUc76ZimbVuE1DSJjPuz5FtshGZK6EkRfIhA8EEIymgukFUIRfWwYB6b4Znt7UT9GZIJx0En5eR8mCKYEvq2MdyIIroQS9iKo3gcTO+xIN/iw05Cy2OGCM57+T20REnt4xDEKaUUlcSjpXbrRJlMakogriDPZ9FUqpW2X6Z96P1WhSEEln5elxa1YjHNxksckXTNDZu3Mg/H/knwWAQwzBpa2tDUWx43G5CoRAjI6MkUinmz1+AYRrY7XZGxkZYu/YVIpEokUiUeDxJ/7YBQEAUZXTDIJPJsXnzFuKxCVqaG/nY6R+dDIGQMAwwdJN0Kk1kYoKW1hb6+vpIJBJkMhkkSSaZjONyeSgUCgQCfrZt20ZdfRBZFoknEtTVB1EUmVw2jylTUgvKsoLX5yMSieF0OlFVlXw+TyDg5x//+DtHHnkEzc1NFAp5PG4PgUCAOXPm8txzL5S2SSwWw+VyEYlEGB8fZ3BwkM7OmTQ3N7N+/UZEUURRFPTJMseGhnq8Xi+BQJBsNk1vby8ej5eNGzeVAkNyuTwzOtpJJhOT6Zwq9fX1DA4O4vP5sNvtDAwMsGHDhlLQjlVGWU3Z9lbABRdcwF//+ldWrFhR8jyEoml0oVAgFotNUT2OjIyUTKPD4TDPPPPMlPas1Ou9MZYuL1/dG5SrCsvLZcv3myRJfPrTn+aJJ57gwQcf5LOf/Sy9vb0MDQ1xxBFHcMMNNzBv3jwkSSKbzXLnnXfyjW98g0QiwQc/+EGuueYa2trapiWjq5GBuyJE92RclW1M5+lWvuzu9HF3YZGqFlno9Xr55je/ycTEBPfffz8XXnghv/rVr+js7Cxt++kIxPJtsqv9vq+JtfJS70qyu7Ivu7vuSvJxX6g1dxe7KpGv4a0IK1VaAExUtcBdd/2BG264kblz5/Hta66ls7ML0zQZGhqkoaGBcDjMhz/8YSRJIp1Oc8UVVzAwsI2zzz6bpUuXsv/++7H6xdXkcwXCTWFcLgc2RWFwcJB4PF4Mz5Iktm7tZWJinNbWVtLpNJqm8Zd77ubpp57kgKUHsKWnl97eXt5x2HI+fsaZPLvqWT551llcd+13WLRo0R4/XKqhhhpqqOGtC2OyFHdnEEvki4iEiYKBys49Hi2CsBoRaZVv7yn2lQfk3kJkKmFqEYblKjvLn3FPSqnL593bhGyrHddkEE/EcPBEci4jOS8Om4rWnEFTJcL1cQo+mSUNA0QLTlbFOyHmALuOEDJxyBqzveO45Tz7ufqZqYwzZvfyzoPWsnpmM+pj9Xj7DWxxDd0uYkvoND2rk22QiSwUMEXIh0yknIDqMzElEzlUIJp0YWzykEh6camQ6jARNJjxcA5lIEahLYigGwiaAUE/kYMaiR2dZWKZDduYyVLXViYKHgwEEpqDcc2HaopkTH2SELS2nzAt8VzN23GKOrastHpXYttKZeTriRrx+CZB+U24RUjMmjWLZ555hocf+Sc9PT2EQnXst99iWlpaUCSZcHMzI2OjjI1P8PDDDzM8MkwmmyUajRGJRJElGUWxkUqmiwnXgkhdQwPpbJax8WEUCVS1QCQSoTkcRtd18nmVRDyJpunYbLZSCXI4HCaXy+H3+1AUiWQyRSyWJuAPlsoJm5ubqKurI5lMoSgyNrsdQy+Se5lMBlGUmDmzi7HRYhr22rVreeKJJwiG/ASDfmKxGCeeeDwjo0OoBQ2v14eqahQKBbZt20Z72wyCwSCJZBKn04nb7eTJJ//DvHkLWLBgAU899UwpadvQdRYsWICiSLjcLtraWolGI8TjMZqbmxkeHmVzpodYLEa+UPQXbGioJxKJkEwmcTgczJ07FwBVVdF1nVAoRCAQmOLb9laDaZpceOGF3H333Tz22GN0dnZOmb5s2TIUReGRRx7h1FNPBWD9+vX09fWxfPlyoGgsffXVVzM6OkpjYyMADz30ED6fjwULFuxRfyrLo3el8JoO5URStZAWQRDw+Xx89atf5YUXXuDJJ59ElmX+93//l29961ulZPV4PM4PfvADbr75ZnRd57zzzuNLX/oSdXV1VRWL5X0tJzzL/Rz3ZkyVxJhF1FVbRzl2RXztDflYXoZsrVsURZqamrj++usZGxtj1apVXHrppfzoRz8qpXzvbHtZbZSXpE83b7Vts7P30y1TrnYsb99SpFYjSXfHV9NCZbJvtX2zs/G8GkLGUojX8HaAQLFSoLjf77jj19x99z1cfPEldHd3Y3c4sduLti2trc1TVL/FhwYevvSlL5LL5WhtbcUwDDZt2oSsyKgFlaeffop0JsXBBx9Md3c3mzZtIhKJkE6nsdntpeO4qamJjRs3MjExhqYX2LhxAzabnYULFvCXe+/h7j//kXnz5vLEisf5+Mc/zm233Vby/62RjzXUUEMNNUBRxadM0jXlJdcWsagIxVAZwyySlNZ71RRLysfSMpPkYKmdissuEbMUUFM+/56gPBhmumTr1wrlpGKJMBSqT9+btl8NHAJkTHgh38JvRw5mWzKAIJhk8zaagwlG4l5iaSfZpIMRr5dmZ5yurhESOQdORcUuaczxjfKvwS7m1I2x1LWVpOFAR6TbNcrhszdydfQkwIFLkckHRUJr86gBGf+mDLriRnMJiJoJpjn5Wka3y8gZk2QnZMMGjlERW0xAd8DAkU6a/zNZ6aQZCAWN1IJ6ku0iB3b08Vx/G5pbomBKGAhsTtTjt2epU9IoQnHP2yquZ3Z1TOys5LqaYrIarECZ8n/Thdbsa9SIxzcZym9K58yZQ11dA4qi0NgUprd3K6lkmhNPOomNGzbgcrkIh8PEEnFeWrOGwYEBbE7H5I26iNPhxOP0EEvEESUZu91BNpslnU3j9XpJxiMsWriIfCFPMpnA5/NPhrQUlwdQBFspGMLn8yFJMolEAk0zcNgny7gLBYaHUxiGxtID9kdVc4iiiKZpGHqRkGhrayObzTExMYHdbicUCrFu3TocDjtDQxkaGxsIBoOTZdVBCgWVZCJFMpnAMAwSiQSpVIpkKo2u66TTaRRFIhAIMTY2xvDwMJIkYbPZ0HUdWZImkzht9G3dSm9v7yRpquD1eqmvqysqI3UdtaBOepMYJUWlVVLtdDrZtm0bixcvRtM0VFXdIZX5rWSOf/7553PnnXdy77334vV6S56Mfr8fp9OJ3+/nU5/6FJdccgmhUAifz8eFF17I8uXLOfTQQwF497vfzYIFCzjjjDO47rrrGB4e5vLLL+f888+fVtU4Habz+ivHnvr+wdSQlnIsWbKECy64gFtuuYUzzjiDz33uc6Vk6tHRUa644gp+97vf4XQ6+cpXvsK5555bSn/fGSxFYLnyslqITOWYdhcWoVrphbknZbh7o44rD1upbEsURWbOnMnNN9/MJz/5SR566CEuv/xybrjhBgKBwBS1Zvn6y8uvLaVg+fTd/b7t7hiqzWd9Vi0UZ2fYWYl7NRJ6Z4nfe9v3SlSWi9fwVkdR6QjwxBP/4okn/sMll3yeUDCI0+1ClovHQbVDp/z8tGXLFlRVpaurC5fLhcvpYr9F+6NqGr29W8jlchiGgcPhKHkxr1v3CqYJ7e1trF37MoahM2/ePLZt20Ymk6axsZGnn3maGTNmMDY2wu9+9zvmzp3L4OAgl156KXfccQft7e07WCvUUEMNNdTw9oNFBE7nv1hSJwrFeS2yB4rl1uWw2iiVY1f4Pups94msXKZSITmd52LJC3InJc/VfP52RU5a81WWPVdCNSklZZcTkNb7nZGH5YnT5ShfZjrSa4dlSssKSEDaMHmp0Mh9kaU4pQLjWQ8jgwFEh057Y5RoxonW44G2LA5Pnols8b5KFEzGR30orgKSZLJxoJFQMM3Lo2HWjp3AgoYRDgtsZn/XVvoLdfz4Hb+hsFziovvPwDkIQ++wo6RhYqEHT79JaoaJoIPuNDF8KkJGwj4ukQmDHlQR7To5/+Ro0jJ1z4oIholtIA6CQGpeiEyDRCFg8mxvB0bURsfcYR6JLWAs52Eo6SWl2qi3byced7aPK1WJKub2bYdQIht10yylXsNURWO1sBoL5QSkVHZt+FqiRjy+yVDuK5ZMJpnd3c23r/kOqVSa3/72t6xbt45INEIilaSvv5+xiXFsdjsOlxPJppDP53G53CTiCQq5AvF4EqfTRbHUWiQSjeJw2CgUCsyYMYOFixbicjopFAqkUimam8OMDBfLoi31ktvtLpJ+ySQjI8Pk83mcTjcOr5tMJkdbWxtbt25hbGyM5597jnnz50zeOAg4HW7S6Swej4dEIoWmpRgeHmHFihXkcjnsdhvBQABd1+jo6CgRe4IgkJVlCgWVSCRCMBjE6XLR09s7qVgcJpFIUF/fiNvtwuF04pwcRyKRwOf1YhgGXq8P0zTYvHkz9fV1zJzZwcDAAPUN9ciyjCRJDA0N4vEcQS6XLREBuVyOvr4+WltbCQQCrFu3jmeffZb+/n66u7v3qjT2zYCf/OQnQNHjpRy/+MUv+MQnPgHA9773vZJZdD6f5/jjj+fHP/5xaV5JkvjrX//Keeedx/Lly3G73Zx55pk79YOZDvvypnM6ZV25qlJRFM4//3xOPfXUorJYUTBNk82bN3PppZfyyCOP0NjYyHe+8x1OOeUU7JPhRbtCZXJ1JeH0asZTeZNeXk5eeYzu7JjdE+KxvBR6OkWeRUjut99+fO973+Oss87iD3/4A6FQiG984xt4PJ4dlqum1LQI1WoE5b5CZSCM9XpX6slqfdidMnZrnFaQTbVl94SInG7eGun4dsP2C8tEIsmvf/0bTvuf/6EpHJ48VwFsPw9Zh0zl8Vm0OZlT8jJuaGggGokSj8c58ogjCAR8RCIRcrkcqVSKaDRKIhFDFIvn0JdfXkM+X0y+fuCBB+js7GTRosVs3LiBcLiRfD5LT08PgUCAgw46iBUrVhCPx7npppu45pprUBSl1Je30oO9GmrYE7xae4za96aGtxIqA2bKiT2rHNsiEY1J4k8vIxmNSWKxGspJzcp5yolK3RSqlmfDNP6ROx3RvkX5uiqJyR1UkNNgV3e1uzOe8kRrBwJbNYlR3cPWQgOaKZLW7Ngljfb2CWb6JrCLOv+Kd6HbTcy8hMuVZ3BbiKFcA3JKxDsmUPArCHkB+9IE6ZyN3Iibpq5xnt/WxkvDzTR407R5YhzRsonbJw7jmIPX8NQf9yfTaCBnRAQNYnNBMIq+jYImIMgGrtYsUruB36YScGQJ2TOsGQuTXRcoekDWCWguB/YWG0rWZPhQkZYVOhMHmyxsHWbjlpnM9EYYyATojwVIxVw4GjQCcgYohulUbtudbUNrHisgBhNU0yiG8ZSRj9XKqCvbLfcLtdp9PSyX3nrMyFseJqJYDGbZsGEjqqrR3NzCwkWL+PTZZ/PuE04gm8tjIuALBNB0AxBQZBtenx81XyARTxQVh7qBaRhkMlkS8Tj5fJ729nZkRSGXzXLMMcdwwNIDkGUZ+2SJlCiK+AN+NE3DBAqFAoJQ9FdMpVKMjo5N+vHZUBQFm00hEolgmAZbtmwhk8mQTCYxTZDEYlBELpdjZGSEQiFPNBJFUWwltZemaWRzWWRZxuPxFL2iRBGbzY6qqjQ0NDB79uwi8ZlIIMsyIyMjtLW10d3dzejoCJFIhJaWFo4//vgpQR0ulwtd15gxYwZOpxOn04HNZiOTyRCPxYGioimXy6NpGslkkmw2i67reDwe/H4/+XyeSCSCrutEo1HWrl1bUmBZ/99KsAieyj+LdISiZ+ePfvSjUnndn//85x28Gzs6Ovj73/9OJpNhbGyM7373uztNA96T/u1LWOXO5WW2TqeTmTNnFkv2DYPnn3+eM888k4ceeoju7m5uv/12PvjBD05JoS4nxsq3G2wnf2RZRlGUHVSclQEi++JmwyIYy4/Ran3dXVSOp5x0rGy3GkF4xBFHcOONN+L3+/n5z3/OTTfdVFJMVVtHtTGVP5Sx5n+1qBwTUCJb9pasq3YslKO8HL28nLxy3j0ZX+U2KSeGreOtdhP69oFhGDz11FO0tLTQ0NRYUpqXP/yoVByXw+Fw0N7eTktLS8k2Yf8l+2MYBj29vSxctAhN0xkYGGRoaIiJiQny+TxutxtZlslms/T397Nx4yY0TWP16pf4xz/+QXNzM5Ik88orr5DNZjnttNNYu/YVDjroIBwOBw8//DCbNm16vTdXDTW8YVH5m2DZZpimSaFQmPLb8XrcVNZQw+uJ8uCYapjO/9EiHPc2eXq6vhgI6JNhNDvzkHytoJvblYuvtvS5HJJQDI3ZmzYrCbWcCerk6y2aTNpUcIt5xjUPSdVOyJbmHfVb2C80yFDGT386QD6rYIuJyCM27IrG/FmDCJqACWiTRWVSAeq9aZr8SaRgnvGoFzWrkBlzE804WTvexDe3nYwsGjw9NIPUgjyeXhFb3ETzmNgnBJyjAnJOwHAZCBEbhiHQ7EtQ0CRsks4zvTNJxZ3oLgMlLaA7IdsISsYkMUMCA1S3iKtHwaPkEXWBvC5jEzXsiobdXWAi6qFeSQGgCJUk9tTXOuaUv9I000Q1DVRMFEHAIQhTFI+wnZysDPn5b2OPiccVK1bw3ve+l5aWFgRB4J577pky3TRNvva1r9Hc3IzT6eTYY49l48aNU+aJRCKcfvrp+Hw+AoEAn/rUp0ilUq9qIG9VmGV/22/gi2q6xsYmnE4XL6x+kZdeWsOWLT38+9//YfOWLcQTCXTDAEEgEo0yPjFOLpdDVpSiw5NQvKlVVRVNVfF4vRx22GEoioKqqrS2tnLCCScgShL2ySToTCaD2+1GFETq6uowJ70M4/E4qVSKvr4+JElEEERyuTzZbBan00UiEWdoaBiPx8PGjRtJJJIAKDYbdrsDv99Pf38/kUiEQMCPx+MuTlcUQqEQhmHg9/sJh8MlBZrlT5VOp5BlmUKhgKZpNDY24nA4cDgc7LfffnR1dVEoFNB1nY6ODnw+Hy6Xi4aGhsl2REZHR1EUBafTRTKZLAXIWEE0Vkp1XV2I+vp6stksNpuNbDZLJBJB0zQCgQAOh4PNmzeTzWarqqFqeHOhfP+V++9Zf5qm8c9//pMzzzyT559/noMOOohf/OIXHHHEESUyxyJ4dF1H04p+pJYnqKqqRbuByRuDctLs9RhbJfn4am9MykugrfZ39R2wCC9JkjjxxBO5+uqrsdlsfPe73+X2228vfa93t1/lwTPWmF4tKhWOO1Nx7mtY7e+rY6P8mKydn96+MAyTf//7PyxcuBBVVUkk4ui6Rm9vD5FIZKelzJXniVwuR39/P48//jgvvPACq198kfvvf4BUKo0sFx8uFgqFyYd2Gvl8DpfLxbJlB9Ld3c3xx5/Ehz70Ebq75zAyMspLL60hEAjx1a9eQSyWoKGhkWw2R3d3Nz09Pdx///21UusaaphE+YO9vr4+/t//+3/cdNNN/OlPf2JgYKD0e1z5u1X73tTwVkM5+VhJRCqCUVI1qog7JFVPp3Tck3WXr9Mqvd5d8nE6MmZPCKNqpKBFQEpCZcn37rdpzatU6eeu2plS5ju5eRwCpA2RbZoTCZMWKYNqyjQqCd7X8AIz7BFGCj62pOqYSLvI6zKmJmKKJobdZCLqoT8WwDMzTt1+YzQeMYhz/yjpRTkOqO/nzPYnWdbRh8uVh7QMskFi1EN6dYjVj8zlvs2LOLJ1C+0tEUQNnBEDbw9IeSgUg6cJvSAi6GAYReKwzp1hIuvC7c5BQsHdJ5GZl8d+YATVX9xLuXoTqQCCYVL/klYstZZMnu1vpzcWIhp3IwgmwrAdj5SbTO82qxKDIjt6PVY7FvaExBPL/va2jX2BPZYYpdNp9t9/f8466yw++MEP7jD9uuuu46abbiollF5xxRUcf/zxrF27dtInD04//XSGhoZ46KGHUFWVT37yk5x99tnceeedr35Eb3kUjeFlWaSltZVINEb/wAD3P3g/Dz7wIH19fciKQltrO5FIFFGSyOVyBIIBYvEEPr+fQr5YNo1hIIoCNkVi4fw5vPOdh7H6xdXEo2N8/IzTmTe3G01V0bQCNpsNxWZD1w0cTgeapuN0OXG53eTzeTKZDLIsk06nqasLUShoJBMTOBxZYrEY8VgCn99Dc3MrimwDRNSCBqaI0+kklUozMRGhtXUGsZEJXlm7DsOAWDSOYpPx+fyYpjmZSK0hiRJut5tXXlnPli09zJw5k3y+gKLIuN1udF2lt7cHWRKZObODvr5+0qkkLpedVEomGPQRCvkRBIFQXQMOR7HMzFJ1mpg4nTYkSQTBJBQKMjIyTCAQoL+/vzRfNBrFbrdz1FFHUSgUg3gGBgaYNWvWW7LU+u2Cakofq6TXIhH/8pe/8IUvfIHR0VFOPvlkrr76apqamhgZGWFiYoLh4WGGh4fp7+9nZKSovM1ms5imidvtpq6ujq6uLhYuXEh3dzcNDQ2lc2R5P2DXwSKV03dGUpWPzSq7tsrJK9vdXVQSWpUlwbvTR1mW+Z//+R+i0ShXXXUV3/zmN3G73Xz0ox/dbRLT+r+nCdHTodxLcmcqsNfyJq68vNvq056ur1JdWyutfntDVVU2bdpIS0sLmzc/QkNjI1s2b2bOnDk89dRT+AMBTjrpPfT0bCGdTnPkkUdO8aqNRKKohTyiKDI+Ps4LL7zAwkWLaAm3sOblNcQTcVLpJPF4jJGRYerq6gmHO4uewEKG/Rbvx+DQEAsWLKK1rY221nZCoSCbt2xmfHycww57By+88AKKonDwIYewYf16BgYG8Xg8PPHEE5x//vklL+VaqXUNb3dYlRdXXXUVzz77bCkgb/78+XznO99hyZIlVSsQoEbc1/DWQDXisNyvUTe3l1FPCYeZhhiUdlJavTNUIx+rLa6bRQLUCrqZOpZiv6yybZ3plZmWX2Op3zvpqiQUy5wry6mn826c2t/iOHYnwbrcK7K8bWv9uck2/GIer2gQMWTSpo1DnZsB2Kw28LfkIjYPN6DFbURNP45hGUQQdBNEk5NmrmVjsoGgLUuzI85Qzo/crKMIOi9nWvHKefzOHNk6Ba0gYxZETAlsMdBf8LFC7gJAOC7KhCahbvFii4Kvx0QwTVzDKqJqI5H20ud1Y3h0fI0pUkkHUkYkNUfFF8iQWROk/T8ayTYZby8IOnh7M4jpPEYkiD0jUOhzE2+WQIDcgAdHXGSoEKDf7qJLzpT8GacjmS0vx/LX0hTSvHzbm9uVjmY5Eb9rvGHDZU488UROPPHEqtNM0+T73/8+l19+Oe9///sBuOOOO2hqauKee+7htNNO45VXXuH+++9n5cqVHHjggQDcfPPNnHTSSXz3u9+lpaXlVQznrQ8BAUGQMEwTp9OBbFOQZJGFixbw3PPPEY1F6Zo1G7vDhWJ3MD42jqLYyWZzyJKMYYIgiiiKjCxL1IdCdHXNZPasWdhkkzmzO7ArcMzRR2JTiofH8PAwqqpSV1eH3Z4rlhkCki4jSQI2m405c+aQz+dZt65YIiXLNpwuB5Ikk8lkMU0Bu81FS0sHuZyOLNmx2YruBul0huHhERKJFIl4knXrNpDJFMhlVRx2J7lcHsMwyGZzuN1ODMMgn8ujqgXa2lrp7d1Kc3MzTz31FOFwGI/bicfTgNNpZ9OmzdhsCq0tTSSTCbxeJ/m8i/32X0hbWxt9fVvJ5/M4HMVSclVV8Xo9RKNRPF43Hq8LSYKJiXH8fj+jo6PIsoyqqng8ntK2WbhwIe9+97t59tlnGRsbY+bMmQC1G/y3CMpJLVVV+fWvf83Xv/51xsfHaWtrIxAIcPnll7Nt2zbGxsaIxWJks1lUVZ2iELKOh/KLf0VRaGxsZMmSJZx88skcddRRtLW17VB6/lr4WVqk2qsl6ipJx71pRxAE7HY755xzDolEghtvvJErrrgCr9fLe9/73lLp+u56ZsJ2os0i7/akX9aYdieI57WENeZKpdmebuPyUvHazebbG7qu0dPTQzqdYenSpfz1vvvo6uriscceo7mlhXC4mb///e8cuOwAent6GBkZoaGhASgeh4ODQ6xatZL+vj4mJiaIRqP87W9/o7GxkZkzZ6JrGps2biw9iNQ0jZUrn6WtrZ0Pf/g0BgcG+OyHP4LH48Xj8ZQsULrnzAGMkhp8zpw5PPfcc5NVBzIul5utW7dO+jfX/7c3Yw01/NdhmiYDAwNcccUVFAoFLr/8chYtWsTAwAC33XYb1157Lbfddhtut7s0f+Xyu/PbWPvNqOGNir1RK1YSefuqLFoSzN1Ouq5UZVZLM96ZZ+T2eSr7sP3z8vbEimn/DaiTffAKBhIwZsgkDRsLlHFGdCe/ix7CS9EWRMHkowtXcsfK5XjW25CzxeXzDSb7tQ6xPtFEf8KPI6QRU1245TzjeQ9ZXUERDBZ6BpnjHiY0I01cd3Hf0GJiDU5iETdLZ/VxdN0G+vIh0rqdlGZjybxtPDYxB4BXBsJEe5w0rjIIP2OQapFJtSnkRgLYNIFcq0rLjAkGB0O4UgKaU8QzoDOxUMYxbpJrdJCp92AqOvk6A+ewSFayY9hNgi8LqF74/cYDmL14hBZpK4pAKc2vslwaphKC1mvr/84UsaV5TRN28/z9epCP+zRcpqenh+HhYY499tjSZ36/n0MOOYQnn3yS0047jSeffJJAIFAiHQGOPfZYRFHk6aef5gMf+MAO7ebzefL5fOl9IpHYl91+U8HEnKy7Lt5AdnV1Mjo2Sk9PD8cc8y6WLFlKY2MTkUiU+/7yNzKZLLIiY7PJeLxe4rEIXq+P4447lrlzupEESMRjqGqBTDpNIODnhBPOxut1l8pABUFgYmKC8fFxGhsbCYfDSFKxvBkMUqk0kiTR3d3NkiVL2LRpI/m8SkdHJ2NjEwwODmIYJq2tLagFFUkSGRkZYcaMdtxuN2NjEwDkslkEQaCuvo5QKIRpmrhcLtKZBEuXLqWlpRlNKyAIkM3lSKcz6LpJMBgkFosRnjTI93g8k/6NKo2NDQwMDNDW1kY8biDL0qSfnkQmkyYYDOJyuYjH4zQ0NDA+Pl4qNc9ms7zyyiuTad0SmUwGSZIIhUJEIhHcbjfpdBq/308ymaS+vp4DDzyQF198kSVLlpQUGbULttcP+1KNVm05wzC4++67ufzyy4nH44iiyMDAAL/+9a+BomrP7XbT2NhIa2srzc3NtLe309TUVAxAcjoRRZFMJsPo6CibNm3ipZdeYuPGjfzjH//g/vvvJxwOc8IJJ/DRj36UAw44AJvNNkXxt6vAkj0Zv7W9LKJO13VgalnxrjCd0nFP+mit0zRNHA4HF110Eclkkp/+9Kd8/vOfx+PxcMwxx0yb9F1tzNa4LM+rSvJxZ2TidErHauveXexu0Ey1vljzWlYT5YTortqoHEu1dde8v95e0HWdfD5PQ0MDGzdu5OCDD2bbtm3U1dWxcMEC/IEgDQ2NbNiwoeitLIhkMrnS8uFwmJNPfu+kj5xKKpVkbGSMoaHBosdyZxsfPPVUenp6ePrpp3G5XFx8ySUMDw/T1dXFu999HIoiUx5gAwKCYBYfUtrtzJkzh3g8ztjYGD1bttDa2kosFmN8fJRcLld1XDXU8HbEP//5T9xuNz/60Y+YOXNm6Tdr4cKFfPrTn+bWW2/l0EMPJRQK0dLSUiIhNU2bEs5mPQi1qgZqVTs1vBUxnR/kq2mrWqp2KcF6J0RkeeL23qJceWh5PE6/vr1ezR73x1qXUmX4qgmGAAFRo0HUyJnwQHIxSdXBgXV95A2Zh4fm4gpmEQ9Lk9ckNE2kJZBiLOum2Z3gsOYewrYEkmCgCDpdzjGWOPpQBA2vWGBQ8wPQrkwwe+YwBiIuIY8kGOimyCGuTSQNB3Vihpjh5JD2TUiYPB6ax6PhOaxvCYMu0DVzALsmM7SxAakuD0mF0dVNOBMCogqpZonGVWnkjIyoQS4gIeomSlSi65A+HJLGixtmAJA5LkMu4sCx2sdj7fNY0rQNr1C87yqqUSsDYswpqlHVNKuSk28m7FPicXh4GICmpqYpnzc1NZWmDQ8P09jYOLUTskwoFCrNU4lrrrmGb37zm/uyq28+mGbptGSRj4JgUhcMMHduN7fc8hOisTjhpiZsikIsFkM3NGRZRJbFYqm0oqDrBkuXLuXrX/86mXSKJx5/jEceeQhFlnnPe95DQ0NDqaQql8vh9XpJJpMMDAwQDAaJx+P4fD5sNjupVBq7XSGVSuNwFIm3/fffn/7+PjKZ3ORFi4ndbsPnK3o0DgwM0NTUgMfjKvl6btmyiYGBflwuD6pWQFULiKKAqhZIpZPkchmksqAFXdfxuN2oBZWRkXHq6+t5/PHH8fl8k2Mshr94PG6i0WKwzJo1a2hra2PGjBlMTEwwMDCAYRjU1dUBEAqFSp81NjYyNDSELMslz0iAeDyOaZpMTEwUk7F9Ptra2shmswwMDDAwMMDMmTPJ5XJMTEzgcrmqkhY1vLGxM+LOMAyee+45EoliQFMoFGLRokUcdNBBzJs3jxkzZhAOhwkEAjidzlKqdfnFfXl7mqaRy+XYtm0bjz76KPfccw/PPfcct99+O3/84x856qijOOecc1i+fHnpONxdAnK68ewMlenau1q2miqwmifc7qC8/Nvn83HFFVeQSCS48847ufjii/n5z3/OIYccMoVw2xVxaLVnhcOU30jtrPS7Whla5Wfl73eH7N2d7bA75wnrWKosm55u25d7fO1pf2p4a8JS97/44oscdthhRKNRBEFg1qxZNDU1EYnEGB8fRxQlBrYN0tbWwcxOz5Q2DKN4XNlsNoLBEKFQHfMWzEfAKvExWbx4fxYv3h8oXud1dnVht9l28IMt/t/xmPT7/cycORNZlln5zDOl3/ba72kNNRSh6zpr167lc5/73BTSURAEFi5cyCWXXMIVV1zBD3/4Q+x2O+3t7SxZsoTu7m5aWlpoaWmhrq6O+vr6mn1BDW967Cx9uvzzHdWG5rTzTzetnHQs/d+Ly6pyVaNeVhoORfJyVwE4lrLRUkxWhrns6vHBvni8UL5Oi3Cs7JP1WjWLZKS1jAqoCLTZIkiCQZstgohBsy3OQD5AUnNgEzUm8m7meEZZ5u7FK2ZRkZAwKZgSrXKMgFgAim0nDYkOOYpNMCiYIjbBwCVsD7VRzeL668Q8BVNkWPPjEFUcgsoiZz/NLVHUZpmefAN5QyahORhr8KCNO3GG02QVB3LKRnqmjuAvkGtwIWXB168TmVuk1mxz48iiwTH161izrYXO8DiH12/mP+NdbMy3opkiA5qPebboVOViSaFo7qBo3BXpaE23yrFVikRlpZpWL7/Wmpz+emGfEo+vFS677DIuueSS0vtEIkF7e/t/sUf/XVgX56ZpIkgCPo+H95x0EjfceCMbN2ygoWEDfr8fXS2Qz2XweurJZrKI7qJaJpfNIAoCK1as4Lprr0VT83zqU59i8eLFRKNR8vk8Ho8Lt9vNyMgI4+PjyLJMLBYjFAohyzLJZBJN03G7nfj9PgRBIJ1O4/V6qaurIxbrIZPJIApF0jMQCJDL5XC7W0imUkhjIk6nA6fTyebNm+np6eE97zmZUDBIPJSgoOaorw9RUHPkCznGJ8aQZQlFUUim4kQmoqRSGZqbmxkbG2dsbIxCoUBrayuhUIhcLoff70WSJDweD6FQiNHRUebOncvatWvJZDKloI9AIIDH40GWZYaGhnA4HPT19dHZ2cnQ0BA+n6+kBFu3bh2CIODxeBgZGcHtduPz+UilUtTX1zM4WFR8PPvss7S1tdUu3l4nvFo12p6s54ILLmDu3LnU1dWxePFimpubS6mwANlslkQiwfDwcCkJXRCKKeoej6d0vDmdztLxOW/ePLq7u/n4xz/O6tWrufPOO7nvvvu49957eeSRRzjuuOO44IILWLZsWYnMfC1uDiyCyjAMNE0rJStXQ3kZ887I0D1Zd/lrn8/Ht771LVKpFPfccw/nnXcet912GwcccMBurad8nvLQmZ35Re5MHfhGI+rKfTUry8GtfWhMBoDVzkM1lEOSJJxOJ4IglmwhOjs7eeWVV3jppZfYb78lmKZJb28PTocLTVNL6ihBKCZJmoJQfB4/ecxZfrZjY6Nks1kCgSBLly4lFAohyTJevxdJFEslRcAO57FqhOTMmTMp5POlc2gmY0w539ZQw9sZuq7j9XpZsGBB1d/h973vffh8PtasWcOWLVvo6+vj0Ucf5Y9//GPpQb3P5+PQQw/llFNO4aijjkKW5dpvRg1vSlSSiuXkYHmSdTmROJ3a0GpLEopin8o2LCiCUSIKpxCUe3DJWKhI365GjlbvY/XXFvRJ1dzOiKVq5deSMDUhu3J6+ftKr0dJKBJ71usSwWhuT8fOmQIOwSSiK6RNhQEtSLsywWJHP/1qHc+ku9icqqfDFeFAXy+zbKM4BBWvmMMrqqV1KZgoAuTN4jbMmxI6AgGxgI5A2pSJGQ7qxCwxQ8IlaOTN4sP6FlkjaZi4RQOXmGdVppOD3ZtpkJJ0yREypsxC+wB9WogV8XnYbDonLV/FK7EwWza1k2/QMV06ZkaGeSmMtV4ic2XSMzUcwzJ6Xiat2ujN1SFKOlsG61kS3EbQkcEWEznA20ejtD1YuZJ81JlKNO5u0FA5+VzcT0Ui0yIbJUFAL2tPN00kdkzYfq2wT4nHcDgMwMjICM3NzaXPR0ZGWLJkSWme0dHRKctpmkYkEiktXwm73f62vdAsv7Cn4nUmk8HldtPY0MAnzvw4mqbyt7/9ndUvrqG+LsTMjhnohsnIyAjhcBPxeAKX28WGjZv4xCc+yZYtm/C63Zx04ql86EMfQpZlvF4vsVgMSSqGt1jqAlEsEoiapqGqKn6/D00rhtM4nc5SQEU6naa7uxtFsZPJ5IhGo4TDzfj9flRVLSoC81nWr38FXdd49NFHeeKJFfh8Xlpamqmvr0MQRBYtWsiKFSvQdZXFixex//77YZoGmqbi8/kZHRljYmKCfF5FFCXe+c53kslkSCQSzJ8/n0Qiwfr161m4cGGJkIzFYmzdWvSDnDdvHrlcjmw2Wzr+bDYbc+fOZWhoqNTfuro6GhoaSKfTeDweDMMgHo9js9lYunQpvb29SFKREM3n8ySTSQzDYHBwEE3TSk+Qa3htUY0U2tsAjp1NFwSB9vZ2PvnJT5bInXg8zvPPP8/KlStZs2YNGzZsYGBggGQyWUpUt75DDocDr9dLQ0MD3d3dHHDAASxbtowFCxbg9/txu90ceuihHHTQQXzmM5/h17/+Nb/97W+5++67eeyxx/jIRz7CBRdcQFdX1w6E4N6SY9UIzHIiq7yMupwQqEbQ7el6y/urqmrphsf6q6+v5/rrryeTyfDggw9y3nnn8ctf/pIFCxbstjeVhelUkuUKxlc7pvKxvdbLlZPElSnV5X6ONdRQCVmWCYfDCIJIX18fs2bNIp/PlyxLNm7YwNDQME1NDbS2tRCNRvB4vaVrNIHtfvnWd8rlctHY2Ijf70ORZRwOJ/l8gYmJCDNmtBePRdPYgRyp/K6Vfx+Lx7dJJpMlEokgCAKzZ8/G5/PVVFk11EDxt3piYoKJiYmSLRBs/15KksSxxx7L8ccfj6qqqKpKOp1mYGCA0dFRhoaGePrpp1m1ahWPPvooX//61/nABz5QKrl+rbCvrlWmQ+3c8PaAjlDVn3F3lI/Vpu9M+WhBKkuwNhAwdtPT8Y2G18rv0WqvGtmZMwViho2k4SAspRAFE8k0SepO6qQU/0rPJak72M/Vz3v8L+AT8tgFHZtg7FCyLQJJQyRpiqimiEPQ6dOCjGk+2pUJHKJKnZilXUoxZtgZ073EdDcRzUODnMAuDDBmuGmVUoTlOK22KA1SEregIQkmAaFIXsaMHIvc26Ad0pqdk8Mv8dM5fo5q38S2TACbpLE5WkekyQmA4NTxHhxlfMyHaQo8sHU+XY0TbBmt4971+9HVNI6hwLjmwSVqpbHsSYL5nkKEks+jCNgEgYJFRL6G662GfUo8dnZ2Eg6HeeSRR0pEYyKR4Omnn+a8884DYPny5cRiMVatWsWyZcuAoj+JYRgccsgh+7I7b1lYpYOFQqFYfikK2BQb7znpRBobGlj17HPY7Q5UVWN0dAyXy0Uul8PpdBDI+wgGg0iiyCkfOIUlixcTbmpg8+bNKIpCIBAgHo9TVxckEomQSqUIBoN0dHQwa9Ys0un0ZCm2gK4bZLNpxsbGcDqdk76KBg6Hg6amJsbGJibLqYsXQOl0ipdeegm7w4bT6SSZTNLf308ymeB973sv8+bNw2ZXaG9v57jjjuXhRx5CliR8Ph+hUAjDMEhnUjgcDlpaWojHk0SjUUCgo6ODsbExhoaGiMViJZ9GKBIabrcbu91eUnQKQnGZTZs2lfwZJUkim80yMTGB2+2moaGBBQsWoOs6qqpis9kmE7N1Nm/eTCgUIhgMomkaHo+HdDpNIBBgYmKCvr4+0ul0jXh8E6Ly4rYa8Z/JZFi1ahX33HMPK1asYPPmzeTzeUzTxGaz4Z28SQ+FQrhcLgzDIJPJEIlEiMfjvPzyy6xatYq77roLp9PJjBkzOPTQQznxxBNZvnw5oVCIuXPn8s1vfpPTTz+dn/70p9x1113ceuutPPzww1xwwQWcdtppeL3e7SqkfXwjXl6eW05AArtUDu4uLNLs6aef5vvf/z4nnXQSp59+OoqiIIoikiTR0tLCD37wA84991weffRRzjnnHG677TZmz55dIl931Y9K9WK1MJ19RTpabe1Ov/YW5fvF2gaVXpBvRJVmDW8MWB6Kd9zx/zjppJMYGhpicHCQd77zndTV1aFrBsceexw9vZvZsmUL8XicWDyG3W4jGAyWRIvlx3cul2N0ZISxsTFSqQSiKNHY1MzcuXPRNA19UjG5+yjSm7lc0d/70EMP5U9/+hOHH374a06K1FDDmwVFr/cubrvtNr74xS+WrglM0+T555/ngQceYMGCBRx88ME0NTWhKAoul4uGhobSb/rpp59Ob28vf/nLX7jppps44IADmD179rQ2Ha8W5Q8dy3+HreuBSq9pwzBQFGXKQ9BKz+bX+je3hjcmykk/S4VYqVLcXYhly0+3XDnpaK0D9i7g5r+JnaVfvxrkTIGI7sAv5nGLkw/AoaSwU02RmO7CIaoogoFqyBSQmGcfJGk4eYdrIw1SFhHITapA3aKxg3elpepLmgoSJiGxQM4UyZkKqinhEFWMyeW3aH4eTS7AIapEVRdDOT9HhdazMjeDiO4hYx/ixewMXGIBt6ChCAYuwZzst0m7HGNC93Cgt4cWOcrz2Zmc0f0MB7q28MXhU/HaCzR7kzTMTeOQNPoTfrIFBYcnT7pgIzPkIe9N0RBIsbRugFXjbehtOfqyIVzBYjn1a0k6SmWEY3F/CBiYpf1SPs/rgT0mHlOpFJs2bSq97+np4YUXXiAUCjFjxgwuuugivvWtb9Hd3U1nZydXXHEFLS0tnHLKKQDMnz+fE044gf/7v//jlltuQVXV0k10LdF617B+XFVVLf0AS6KEaRo0NNQTDjdy4LIDiMUS2Gw2VLXA4NAQgUCYxYsXI4giqVSKcFMjkiwVky1TCZxOJ9u2bSMSiZDJZHj55ZdL4SlLly7Fbrdjs9nI5XIUCgUkSUbXixcBXq+XVCqFoihTyvrWr1/H6OjoZDlXnFwuWwxv0QrMnDkDn88LwIc+9GHa24teiW63G4+3SPp1zJhBJDLBnDmzcbmcZLJFIi+VKqZfF0uq8xgGjI2N0d/fT1tbGx6PpxT+Eo1GsdlsRKNR7HY7gUAAn8+Hqhal2nPnzi0RrIFAoFT6ao3FNE28Xi/xeByXy8Xo6CgDAwOlEtRcLseMGTPYtm0bM2bMIBKJlD6PRCIEAoHahdAbAPsicMYwDFKpFA888AC33XYbTz/9NJlMBpvNRldXF8uWLWPp0qXMmTOHzs5OAoEALperpOKz/BxjsRgDAwOsWbOGVatW8dxzz7FlyxbWrVvHnXfeSVdXFyeffDIf+MAHWLhwIfPmzeO6667jIx/5CDfccAMPP/wwX/rSl3jwwQe5/PLL2X///Uvr2FcX3+Vt5XK50o2CLMs7pEtXlkpWovwGo9o2/fvf/86ll15Kf38/K1aswG6385GPfGQKqdje3s4PfvADzj77bJ555hkuuOACfv7zn9Pe3r5XylbTNEtKVEEQSqm6O2trOmXWGwGWkgWKN6K2SR+9GvlYQzWIosjRRx/Fn//8Z9atewWv18eBBx7Iv//9b9LpNEcfdTTRWIRtAwOYwPve//7JkKvtxOEU0jGbJZmIAyaSVPweJRJxxsbHWbt2DW1t7XzgA6fgD/in+sdO+loVi8HAREAwi4SjIICm6aRSKbLZDOvXr2NoaIATTjjhDfXdq6GG/zZOPfVULr74Yi644AI+8pGPMGvWLFRV5bvf/S49PT3ccccddHV1ce6553LsscficDhKD/ageD7o7u7mwgsvRNM0/vGPf3DhhRe+5rY11n/TNEkmkzz++OM8+OCDRCIRVFXF4XDg8/nweDzMnz+fhQsX0tzcTDAYLD2crAXg1GCYAqJgTlU+llR3k/fMZfo7HWEH38TpFJKWb2PlZyLF9Gqr3UoVZDXYBGNKH3c3/doqw96Z3+OeKOaqkY7l5blWmXW1ectVklaJs0SxjHpEd9KnhaiTUrSI2VJ7OjA+WVK9udCIgUi3bZiMIdOnBfGJOSTBICSlcAsaaVPGO6k6hCKZqWCWiEgDgZwp4RVVAmKBnCkRMWxM6G6eTs7iAM/WIrkpqAxoPtbmW0uk42ODs5lfN4qEwUuZdl5JhNnkbiJvyCz0DKAjoFAcl12wSFOBOilFWErQJKn4xBwhKccf4wdgk3UcsopLLhB2JAgqGUTBIKk66BmuJ7/Ng1BXJCC7AhO45TwLgiMMDwcYTPtJGmKJoK12JtOrXL9LlWXTk2XZtgqCsTzVemrZtomCgDg5voJplsqtXw/sMfH47LPPcvTRR5feW96LZ555Jr/85S/54he/SDqd5uyzzyYWi3H44Ydz//33l4IRAH7zm99wwQUXcMwxxyCKIqeeeio33XTTPhjO2weCAAMD/UjSjGI5tCigyDJaQUVRJGbP7mLduvWEgiHq6kJ0zZpNc3Mzfdv6kSWJiYkJ5s2fx7atvQwMDNLa2kIsFmPNmjV0dnaSzRZL5D0eD6Zp4nQ6Wb9+PbFYjM7OzsmEZwVNKxAMhnA4HBiGgcfjRpZFstk8IyMjRGMxDN0gEAjidDqKaXqCSTqdwePx0NDQgN1uIxD0E4/FiwQKEAoFaW1t5dDlB/PZz16IrEgUCkWloqIoRCIRhodH8Xi85PP5Sb8qAVVVGR8fx+12k88X8Hg8pFKpkjp0wYIFJYWmpmm43e6Sz00iUSRgnU4n8XiciYkJFi9eTC6XKyVfWwojj6dotF9fX08+n5/0tYyVlJ+ZTIatW7fS1dX13z1QapiC3VEFVlM7qqrKypUruf7663nkkUfQNI329nZOPPFE3ve+97H//vuXSObyIBOL0IKiysjtdlNXV8esWbM48sgj0XWdWCzG2rVrefjhh7n//vtZt24d119/PT//+c85+uijOeusszj00ENZvnw5v/zlL/nTn/7EjTfeyAMPPMCLL77I5z//eU4//XS8Xu9OCcA93U7Wf13XSzcolfYBe0tqWYrtu+66i8suu4x4PM6iRYvYsGEDX/7yl/H5fJx44omlGwtJkpg9ezY333wzn/70p/n3v//NZz/7WW6++WZaW1unlJftalyW2tE6FqoFzrya8vHXG9YxB8USWk3TdpheQw2VOPTQQ2lqaiQWizFnzhw2bNhAc3Mzzc3N9PT28J8n/0Nrayvz5s0jFo1imCbPP/8Cxx9/PMFgaAqBKMlyMf1aFPD5vFPOf5IsEwrV4XA4J0PxyiwbJvtSfOYvFHlIAUzDRFU1otEId9/9Z4YGt/H3v/+dz3zmM3R2dpbGUDu2a3i7QxAEGhoauPHGG/ntb3/LD37wAwYGBhAEgfe85z18+9vfZs2aNfz617/mi1/8IieeeGLpe1Tp/ytJEh/60If4xS9+ga7ryHLxFvG1VBOapkkkEuFrX/saa9as4YADDuDEE0+krq4OQRDI5/NEIhF6e3t55plniMfjuN1uOjs7WbZsGZ2dnTQ1NZXuAfZV1UINby5YykdR2L1rsHICcFfhLRaRWE4sqhU0kT5JRu5AWk5CxKxaEr6nqNaGVBFCsqfqOUkAw5yefJx2mcnXMUOmXwuwMR/mUOfmkmLRIrIihsRmtYF+NYRXzNFtH0ZHZFj30SrHcE2SjC6hOI6cKbBerUMRNGbKcaAYPiMJJmsLTYSlOG1ytpiMPTn+pCnzTGYW7Y4IDkHFJuioSGzMh9mQCaObAhvijeRVhfGcm0ci87FLGs3OBC/HwmwbC7ImGOaAub20SqkS6agCbkGjS4ngFYoEXoecJWfCcMFHhy/KBxtW4Rbz/CO6P4O5APv7B+jLhtiUCSOpAnpOJhp3Ew73MMsxSpstylO+DpaF+rAJ1feWXvXT7cnXetn21SkSvzahfD6hRDyWo0g4CpMBgNthTLb3WiovLewx8XjUUUft9OZKEASuvPJKrrzyymnnCYVC3HnnnXu66hrY/sOfzxfo6+ujra0NSRTRzeLh4na7icdipFNJNE0lm03T2FBPNp0mnUoRixYDYhrq64lEIkWV3sQY0Wi0dBEyPj5Oe3srDocDWZbJZDIkk0nWrVuH0+lk7dq1BALBSQ9INxMTEXw+3yQpKJe87EKhOsbHIyQTKWw2BZvNht1uw+sr+kbKsszcuXNwu53FVL26enTdpFAo4PG4OOigZThdDux2O/l8pkRCjIyMYBgG+XyeVCrN2NgE9fX1JZIxnU7T0tKCx1MkAMPhMOPj45hmse26ujrS6TTNzc0MDg5is9kwjKJhvfXf7XZjs9kYHx+nqakJVVWJx+Pk83nq6+uBoo1AOBzG6XSiKEqJuKyvryeTydDb2zvl4q2GNw6qXUhXluxYr5PJJLfeeis/+MEPGBsbo7Ozk7POOotTTz2V9vb2Kcq83blAL1+PJEkEAgHe8Y538I53vIMLL7yQlStX8oc//IGHHnqIe++9lwcffJDDDz+c8847jyOOOILTTz+dd7zjHVx77bXcc889fPnLX+bJJ5/ka1/7Wsn7cWcEa6UKrnK+yvO71R6ww7G8s3Hu7Hcik8nwk5/8hGuvvRZVVTnnnHO48MILueGGG/jlL3/JJZdcgs/n44gjjpiyTRcsWMAtt9zCpz/9aR5++GEuvfRSfvCDHxAOh6f0c2fKy3Lvq2rbZnewKyXhvrrxqbaeypJqayzVysdrqKEaTNMkGAzy+c9/nrPOOov77/8HJ5xwIi0traxZs4ZcLsfBBx+M3+9ndHSU3//+97jdbjpmzmR0dARFseFyuaaU+SeSKbb19zExMU4ulys9oGtobMTpdJJIxHC7PTidju3nTKzje/s5VNcM/vq3v+Hzenj0sUfp27qVtWvXsGjRIs4777xa8EUNNZTBupZubm7m4osv5qyzzmJ4eBhVVZk9ezZOp5OOjg6WL1/OnXfeya9+9StWJtI0owABAABJREFUrVrFxRdfzPvf//5SAJnVVjKZLJF4ryWs3zHDMPjzn/+M3+/n//2//0dLS8uU32ZBEEql17quk8lkmJiYYMOGDTz77LP8/ve/xzAMWltb2X///ZkzZw7Nzc14vd5JlbY4xb+58jrAem316Y1c2VDD7qNSdVhJLlYSeJXzVwuRqaZklMoIxZ2VW+9t4nU1lCslpd0kWqvBSpeG7YrJcoXjdOSj5a34Yr6VsBznuexMWpQo73KvIyBqKJPzZUwY1l0A1EkpxjQvASmDYYoExCwNcga3aEwJn1mv1hHTXaQNO14pS4uULIX6DGte1mTbaPAkyJvbSVKHoPOfTDfPxdppcSYYV7y4xAIp3c6GVCMABUNGN0TScQebcw1M+DKEnBk2bmtEiNowPBp1LRkiuge3UEDCpEkq0sv9mo92OVEiA1WK2+1DoZUMqkGW2Afp13zYRZV2R4SI5sZAoKtzhC0bw6AL2OwqmiHRqkTIGTZcdpXnou1cVC+QNswd/Ct3F5ZS0RAmX09zvtJhMi0bROvcW7FPdaorLPc1aozImxBFv8Q0mUwWp9M1eSyJSKJMa2sb0UiMvr6tzJzZQShUx6bNW7DZ7CQTcfxeL4JhkM9mETBRFJnGxmb6+nrZurWPOXPm4HI5GR8fx+l0Ypom69atIxAIABCPx8lms+i6QTqdIZPJ4HA48Xg8eL1F9aGm6SiKQnt7Kxs3bsDn9+DzF1N8TaNYUJXL5Vi0aCELFy4kk0mjayZ2uw1FkchmcyiKDVUrkB5Pkkqlsdnk4sUDAslkmolIjHxBI5ctko/j4xN0ds7EZrdPKhgNJNGGoogMD42RTmdKF1iapuHzeUmlkthsCoZhTqZ8upAkGUWWcbs9eL0eItEJwKChoZHh4WFsNjsDAwMcsHQZLndxOwWDgVLgTCKRmCRK84yPj5PJZEpG+JWoXdC8/tjdba7rOqZZDGb6xje+wW9/+1tsNhuf+tSn+NznPkdXV9cUtYClOLPI8Wok5nQov8iur6/nhBNO4JhjjmHDhg38/ve/5/e//z0PPvgg//rXv3j3u9/NhRdeyIEHHshNN93EEUccwXe+8x3+8Ic/sGbNGq666iqOPfbYUhjX3hxj1gW5daFunQcsWGqmPUH5TUY8Hufaa6/llltuQZZlvvjFL/LZz34Wl8vFN7/5TdLpNHfddRcXXnghP//5z1m2bFlpm8qyzJIlS/jhD3/Ipz/9af7xj3/gcDi48cYbqa+v3+l4y/dROYG6L9Ucr9d3unwfWSXwlaRwjYSsYTpYN+Ann3wyZ555JrfddhsvvbSaeDxOR0cHwWCQ/v5+XnjhBWw2G93d3cWHnJLEpo0b6e/rY+68BbS3twPQ19fHypUrGRzcRmLyAZ3ly+bz+ZiYmOCYY45BEESymSyKojAwMMCLq18gEAhy9NFH07e1jxeef55DDjmUumCQn/7sFtaseQlNU6mvr+d73/teybe5hhpqqB7QVFdXR11dHTC1cqGuro5zzjmHhQsXcv311/Piiy/y/ve/fwfF/913381+++232/7Jewurb1YQ5EUXXURLS8uUaw9rvnLfYq/Xi8/no7Ozk3e/+91Fb9nRUTZs2MDKlSu5++67yeVy2O12Ojo6WLJkCY2NjcyYMYNQKIQsy9gn7xMqf0crt2sNby5Uqh13pmrclcrRIhQry7LVsvRpUTCnKBnL563mE7k7Sdp7Ct0sKgErr8gtUmlX4yyHWPa/tHyVsusR3UavWo8i6Pw5uox3+tZzgH0QRSiSh5afY6/mZ3OhiYCURsIkrMRpkaPYMAhJKgpFEg+Kpdh3xQ5ihn0CHZG8oeAW87xUaMYt5lHQ+Xt8f7qdIzyX7eQg5xZcokpEd3FfbAn/Huki4MgSU52E7XEmVDfPRYrXJwsDw8RUJ9vifly+HJmok4mCl7THBgIYTh0MgVZXjITuYFjwkdSdxOQ46/LNrE63c1HjI5Qzx0lDpEHM0OpIIQJuoYBd1GhWokQ0N92uUQ709bIx2ERSdfCf/k4O9PYwpvlwCCqHNG0lqyskDbO0vctVolX3dWmfCGCaqGXLWGSvlWBd3ldr/qIysvi5o6xcG6aqJ19r1IjHNziqedNZpQmjo2Nomk42m0BRFDKZDP392wgEgwwMDrJ58xbq6xtoDodRVZVkMkk2ncbh8hOPRmlpaSGbzVIXqqe+vpFkMkEikaSpqRHD0AgGgwSDQZLJJD6fj4ULF7J58+bJH/EOZFmhrq5uiumzoijY7Q62bu0jGo3idDpIpVKMj48yb948dF2npaVYzmX50GwPqsnh8XjQdR1R1OjomMGTTz5JNpvF6Qwh2xTS6RTBUD0DgyNomolugCQrpNIR8gUVTddpbW1FliUQRBTZTjQ6xMR4lLb2VurqQqUAmrq6EIGAn+HhYZxOL35fkGg0xoYNm2hvb8btdtLc3Eg6lSaXz9DQUI/d7iAyEUMQJOrrGxka2kZfXx/BYAC73Tbp71g0wx8fH2d8fByv1ztl39Uual477EzlB7tfCmuRjp/73Of461//SnNzM9/4xjf48Ic/XCL1rPmsNquRcVZpb7Xyn50dB5IkMX/+fK644go+8YlPcMcdd/Cb3/yGe++9l8cee4z//d//5YILLuCMM85gyZIlXHHFFTz22GP83//9HxdffDHnnHMOfr9/2vXsbHuUlyFXm798TLszFmu6tU2/9rWv8bvf/Q6fz8c3vvENPvaxj2G32xEEgWAwyLe//W1isRj3338/559/Pr/4xS+YP39+iVgTBIGDDjqIH/3oR5x77rncfffd2O12rr32WkKhUFUFZ/nNTKW31HTT9ha7UpBON9+etl+5n8o/t0hW62atWjl5ZXu189LbC4IgYLfbOffcc7nrrrt4+eWXiUZjGEbxwaYgCCzZf38kWSaXy7Fq1SokSaK+vp6lS5fS0tLMyMgI27ZtIxaLYLPJeNxuctlMqXLA5XIV/aP7+/npT3+KKIjMmTOXww87jC1bthAM1rFo0SKeeWYlgwMDzJgxgwceuJ8//PEuhoYGMU2DxsZG2tvb6e7urvm51VDDXsA6t9tsNo4++mgikUjpgWL5w9OBgQGefPJJPvnJT05RQr4WKPdC93g8paBGgEKhQDabZWBggJ6eHpLJJC6Xi/32248ZM2YgSVLpesDhcNDe3k5LSwtHH300mqYxNDTE2rVrWblyJbfddhuDg4OIoojX66WlpYXu7m7mzZtHR0cHM2bMwO/3Y7fbcTqdVbdbDW8eWETbvihrLofVniiYJU9JKJKJ5eSeRTjuSZJ2NZS8KU2x9NpSOkqCOeX17qC8jNoiEpUqikZ90u5ELyu9tgjHtCESN+zEDBeqKdGvhvh0/RN4he32PpIA6wpBcmaRCtvP3k9IyqFMloMrwnbF5JjhIiDm6NcC3DrwThb4hsiZCi6xQAYbT6VmUa+ksIsqz8dncGRwAy4xj1ssEDNcTBgCL2Y6SOl23LYCAXuWma4JBvMB8rqM35ZjkX+QsYKHZkccdzjPU4MzmdM5zLaYn0zEBbKBmJUwA0VFomrK6KbIoBrklq3v5PDGzSx0D9CrBpilREmbMhImDkGf9KI02KJ52JgPc7BnC89nOui0jxGSU4yoAd4beJ77YkvprJ9gQzbMWMFLUrOzzL+VTZlGcqaES9CnEMeSIJSpQKeSg4rl4zhJJk7Zd1gBPiZKRTsWoWi9L5hTw2Ws9b4eqBGPbzJYBN/mzZsZHx9HlmVisRgjIyMkk0kkSSqlONfV1TE8PEJnZxeqqrJ+/XpaW1tZvfolGhqKSdYdHR1s27aNuXO70XQNQQC/38/ixQvx+XzY7XbS6XTpKWF3dzeapmG3OzCM7Uohi4iwSpr7+/tLFxQ2m43m5mYAjjnmGNra2kqeibFYDJfLNRmEUwxIkCSJeDyOz+ejpaUFTdOK5KMoIAgiQ4NDKLKNhoYG+vu3EY3GsNnsjI2N0dbWitfjIZ3KYOjFcuwnnliBosh0zerENE1cLheqmqdQKGAYBh0dM8nlVHK5PKIo0rNlC4sXzyebzeL1ubA77PT19WHoRTIxFosTj8dpM1uZM2cOPT1bJsvDPaVk7EKhQDKZZGRkhI6OjpIqqUY8vvbY2yCZchIqkUjw5S9/mb/97W90dHTw4x//mCOPPHKKyrHyyXw1WAn05eTj7hwD5abvXV1dXH755Xz0ox/l5ptv5o9//CO33HILjzzyCJ///Od53/vex+233873v/99br31Vq6++mrWr1/PlVdeSWtr67Qk4nTbbWdjEgShVNZbfECwfUzV2i5XOm7dupVLLrmEBx98kIaGBm644Qbe+973oijKlGUbGxu56aab+NSnPsWKFSv47Gc/y6233kpnZ2epX7Isc8QRR3DzzTdz7rnn8rvf/Q6n08lVV12Fz+fbgWizbqKqjd1Sf1nn1vJyrPJx76kiYlck9976QVb2tRLWPionIHe2rvL9vjtYsWIF119/PatWrWJoaIi77767FB5ntfP1r3+dW2+9lVgsxmGHHcZPfvITuru7S/NEIhEuvPBC7rvvvpLP8w9+8IOSd24Nrx3Kj13TNGlvb6e1tXXyQdkYq1atxOXy0NzcTDjchCiKpFLp0s3/yMgITzzxBC+//DK6rjMyOkpkYoJUKjnpAatgt9tL5zBFUfD7/bhcLnRdZ3R0mNtu/zmmAYv224/BwUFCoRAzO2bw4IMP8MS/VuB2u5k9u5v5C+axeTLMsPa7WUMNe45yL1YoknrPPfccn/nMZ6bYdQDcd999zJo1i3A4XPr+vlbXrKZplkIrJyYm+MQnPlFSNG/bto3e3l6SyWRp/YVCAb/fz7HHHsvHPvYxFi9eXLoWKa80kWWZzs5OZs6cyQknnFCqPnrxxRdZvXo1Gzdu5OGHH+auu+7CNIv+9T6fj46ODi6//HIWLFiww7ar4e2FXSklFcGY4vv4WidaG5WKyr0US5aTjxYsRaM0SQiq5nbSURGKfouYRQ/FjKHQq9bzfKaDg91bONnzEl7RKHkt5k0Y052oSITlOF5BxSEYxVAYoUiiThgyqimRNIok/5jm4++R/ej2jjLLMUpfoQ5JNtmarSetF/3kIwUXpzasIiCl6VfreCS+gE7nGHlDIWcoeKQ8721eDUCXbRSANdl2muwJ+rJBBtIBgvYMne4JZoXGaXCk8NpyPJ9px0grGE6dlnCUhZ5BZtrGSBpOhgp+Tml9gXHVi1vM4xBV+jUfBVNigS3KiG7DIehIQLuUotW1ibQp8zwdpXH5pTTPZWeS1uwsDgwSVNJ8JLCSexNL8Yo5upzjjOluOuRE1X2zt7BIR2ufV6JS3WgRkK9HmTXUiMc3PCpveK2b4o0bNxIIBDAMg4aGBuLxOOvXr0eWZZqamvB6veRyOerq6mhoaAAgmUySTKZxOp3EYjHcbjerVq2ipaWF8YkJcrksLS0tpR/xQqFAOp2mrq4OVVUpFAolgs00DUyT0g2uFZIxPj5OKpWir6+P/8/ee8fJVdff/89779zpbWd732TT+yaBFHoNRakiqB8RBQmh/AD1g9IUPooi4EfpXcCPhS+iFCmBEEogpBdCenY3yfY6vd+59/7+mJ2b2WUTEgQE3fN47GNn5vb+fp97znn5/X6Ki4uZM2cOfr+fpqYmYz0sFotRqCKVSqEoipGNaDKZUBSFTCZDaWkpqqridDnp6e1l7969BAIh4rEE8XiSpsZm2trbKSsrobi4iFAoTDgSwWyyIIoiW7Zsob29nZMXnEQkEkYUsyqPeDxhZEXV14+mvb0bp8PNkiVLCIfDmM0W3G6X8ZZUQKStrYOenh5DSdbd1UVp6RQqKipob2/D4/Gg61BcXExxcTE7d+5k48aNTJ8+3XiTOqLY+Nfi4xqRuRzQe+65h+eff57q6moefPBBjjrqqEHZYsOp5IbOf2gW31Bi62DUmbnr32QyMWbMGO68807OPfdcbr/9dt5//32uvvpqli5dyo9//GOj0fyzn/2Mv/zlL+zdu5c777yTqVOnHlQuWm6b9kfQ5UMURVRVNSpD789enpvnli1buPbaa3n//fepr6/nnnvuYf78+cZ6DVXdVVZWct999/Hd736XlStXcu211/LAAw8Y9yfI3nuOP/54fvvb33LFFVfw1FNPYbfbufHGG41COwe7TbltyBGqufta/jodDD6PTsr+FLS55Q897/Kn+TQQi8WYPn063/ve9zjnnHM+MvyOO+7gnnvu4amnnmLUqFHcfPPNLFiwgK1btxpF5r71rW/R2dnJkiVLUBSF7373u1x66aUj2c+fI/KvU1mWjaxjRVHQtGyWWltbG4qSxmZzYLFYsqS+JJFKJtm0aRP9/f0kk3GSyRSalr1uLBYLFouFSCRKf3+/MZ3D4UCSJMrKyjjzzDNpbGxk06aN7N27l6OOOoq1a1azYsUK6upGATpTp01j06YPMJlldAZbIUcwghEcGnLPht27d6PrOiUl2eyzXLukr6+PZ599lhtuuGFQAbnPcn0Aqqqq+MUvfsGTTz7JkiVLSCaTVFZW8vWvf52xY8dSWVmJKIp0dHTwyiuv8Nprr7F8+XIuu+wyzjrrLGw2GyaTaVhruCRJyLKM0+mkrq6OM888k2QySSwWo7u7m6amJrq6uvD7/SxbtoxwOAyMEI7/6chXTQ5XAftjsxz5bAjJg7FN54gmccj3ocOz8xsMJc9SLQNxXSCumdieLmNvugiPFGdZYBwXlr7PaNmPfUBtmRs/pYMoaIyV+411jegmmpUiNieqkAUVp5SkT3Gh6BKyoBLI2DmpYAt700WoiPSmXXikBC3xAsa7uqmx+DnL20pSl1kbH41HinOEexfdigenlMQpJbFb0kgDW/Zs32zKrWE6k27SmomOqIcSe4QSaxR/2oFJ1OhPOdjSVY7FppDqtyCmBE6eu52vuD5ERqdVVbGIGSrkAFZBMfZPU7qEenMPGhDUbIw2hQzyziJAUBMZZenFn3GyMVKF05SmJ+mkyh7ELqZJaTJFksIxzu2kdYkdqQrCmhUIf+xx3R+GWqNF9qkic9hfwZh8svPzKCqTwwjx+CWDqqpEo1Gampqorq4mk8kgiiK1tbV0dXWxd+9ePB4PqqoalaZzhVE8Hg/t7Z0UFhbS09NDMpnE4XBQXFxMoc+HZJLo7u4iFArQ2dlBNBrB4/EwZswYCgsLDVtEWVkZZWXlOBzOQaSDrut0dHQQCARwuVyG1SqVShkkaTAYRBAEY342m42uri5SqRSVlZVGhWqAZDJpkC6dnV3sbdlLy942ioqKiUR6CQbCtLV1DNgrs+tgt9sRyH5ubW3l6aefJp1O4fcHqKurxucrQNd1mpoaDTtHznYSi0XZu3fvADEZx+12krusZXO28rXdbkfNZAuOjB5dRyQSwWQy4fV6yYXk5ypkO51OQ8Vps9k+1c7/CD595Aj0N998kwceeACLxcLtt9/+EaVjrojHwVZPzI2TrxQ8FGIrd22JoojFYuGYY46hoaGBP/7xj/zv//4vzzzzDOvXr+enP/0p55xzDvX19fzoRz9i+fLlfOtb3+Kuu+7ipJNOMhrnQzvw+XbxfJXD0PUfivx5DVVV5P6rqsqqVau46qqr2LFjBw0NDdx3331MnTrV2H/7I2vr6+u5//77ueiii3jjjTe47rrr+N3vfkdxcbExjSiKnHbaafzmN7/h6quv5qGHHkKWZaPzNDRzc3/IrX+OfMzdVz+JRf+zQr7S8WA7Rfnk61CF6iftWJ166qmceuqp+13H3/3ud9x0002ceeaZAPzhD3+gtLSU559/ngsuuIBt27axePFi1qxZw+zZswG49957Oe2007jrrruoqKj4ROs1gk+GRCJBIpHgsMMOo6/PT3d3F4IgkEjEiUQUw5ItSTaSySSZTAaH00FNTRXl5WWYZJnRo+uZNm0aVqstq/qPx2lv7yASiTB2bD3d3d2sWbWajKZRUlpGWXk5FquVufPm0dfbx4YNG7BYLCy8bBHBYJDS0jK2bdtKdVU1y955m4qKipHiSSMYwSdA/vWiaRqvvPIKc+fOxWw2Dxq2evVqrFYrs2bNGuRigk+fiBv6stbj8XDFFVdwySWXoOs6siwPymAUBIGGhgZOOukkli9fzh133MHPf/5zGhsbue666z5ClB7I1WG1WgeKX/qYOHEiuq6jKAo1NTU4HI4DTj+CLx5EQd9vJev8wi+fJvY3TxF9kA16KGl5KGSkNlAlOzddPvKXkVtOVrGWzXvMr3I9dF0H51Xm1mufyjE7DoQ0iYhm5p3YBHbGShEFnaM8O7im4nUqpBQpfd88pIFsR4sAZVIKRYegZqY140PVRbxSjBpzH9sTFXwYqWS2Zw915j7CqpVT3Z28Hx+Lomf7Hg4pRUS10uBtZaK1g5hmoT1TQG/GhShoVJv7UXWRmGRBQmOCpYNV8TGsD9cAsKa1hroiP6X2MB92lTO2qI8dfSU0S4UUOuIUWmO0hAtw2lLYZIVWj4Xy8gBnujfgEnSSOmi6yDhrJ5ousitRSp21n96Mm5BqJ61LdGRslElRI9MyZ0XvVV2IaMy2N/NhtJK39oylzBtmsruTcnMQTRdQdCiWYgAENTtmYR91KDHYHg0ftT8rQ/oY+eRxbk5DyefcfIYSzfkKR6O4EJ89RliQLziGqodEUaS1tZU9e/bgdrsxmUxkMhlDsVBeXm6oBQGSyRQvvvgiTz75JB988AHmgerLJpMJu91OZWUlpaWlxOJxPB4P1dU1pNNp2tvbCAQCtLW1sXbtWrZs2cLOnTvRNI1wOExfXx+ZTMYgUvJJzBypabPZmDZtGhUVFQSDQWOZuQIv6XSaeDxONBo17NSqqmY7Ng4HVVVVCIJgDA/4g0Sj0awqLZVhw4YPaG/vIBqNoiiZgUrfbbS1t9PV1cXq1avZvn27MT+n00U6ncZiseD1enE6nYwZM4aenl6i0Shtbe10dHTgcrlwOBxEo1EEBBRFIZlIYjabKSoqpqOjA13XKSzMKjQTiQTl5eX09vaiKIph24hGo8ZvQwmZkYbNFxOBQIBf//rXRCIRLrnkEk4//fSP2KsPlfzJR474yWQyh0RS5Wf15Rrql156Kf/v//0/Tj75ZPbu3cvll1/OL3/5S8aMGcMf/vAHvvrVr9LW1sbChQt54okniMfjg0jGHA6UUXkw25ObLmfrzc1TURReffVVvvvd77Jt2zaOO+44nnjiCaZNm4YkSYOm3d+8J0+ezL333ktNTQ0vvPACP/3pTwkEAoMKxUiSxFlnncWvf/1rLBYL9957L//7v/9LKpU6pGOU6+Dk1m24ffWvxIGs4AdCbh/lOnH5x+nTxu7du+nq6uLEE080fvN4PMyZM4cVK1YAsGLFCrxer0E6Apx44omIosiqVauGnW8qlSIcDg/6G8Enw9Dz2u/343A4sNud1NbWct55X6e8vIJgMEQmo+L1epFlC+FwmNbWVtra2ujr7SOdVigpKWXatGwl2cLCYoqKivEVFGKz2rFZbdhtdnq6+4hGY1RUVlJdXY3d7iASibFy5SpCoRCBYICenm7a2tvxegtoaJhJeXkZEyaMZ8+e3ZgkySA8v2jX5AhG8GVA7poJBoNs2bKFI4444iMv/FauXMmECRMGijOqn3sbVZIk7HY7DodjECmar2S0WCwcf/zxPPbYYxx33HE8++yz/O1vfzuke8Jw7Z/+/n5WrFhh5LGP4MsDCd34g30qxY9DbrwD/eXmn7+sA83nn1U4Dl33g5mfqgvGX74l2/jLG56PrDIu+1kSQBkYP0sY2lmeqOfx3qNZF6qhyhbgouJ3OcWxF6+YNkjHlJ6dLqiZ6NUsdKgWtqYLWZ6oY2OyhtZ0IZPMXdSZQtSZ+yiQYxzp3cVcWxOTzN0cZm2hI1NAn+JijKWbOrmXk9ybmefYRb2lm+ZUCbdvOIWYZsEuppljb6JL8ZLUZerkXqyiwmM9x/DErrmsa69mh78EtyNJU1cx7+0cQ4k7SoEljlXOENzjpfnDSja0VaHpAoHtPlp3F/ONGWu4b/xfcIkKezM2krpIhSmCQ0wT0yxsC5dhERVkIYNdTNGV8aAi4BLVgczFLGmb0iGtS3ilOFZBYXNfORUFIQqtMTxSAk0XmGptRRLALqhYBRW3mPzYc3W4HpK6n79954T+sbbp3HBtYFqJfZWtP2uMKB6/BMgnq1RVZfPmzUSjUVpbWwGMHMZEIkFPTw8lJSVYrVbC4TDd3T0sXbqU7u5uurq6GD16DB63h8rKSmRZJhKJEIvF8HjdtLW14fP58Pl8OBw2o3BMPB6nqKiI8vJybDYbVqsVm80+qNgDZBs1TqdzIBMqytixY6mvr0dVs1WuvV4v6XTaqHIpSRKpVAq32008HicSiSDLMolEwiAHu7u7CQQCTJ8xg8rKatat28Datevo7uqhra2daDRGY2MzdXW1BIMBEok4fX29SIJEe3s7qqoyenQ9pSUlhm06nU7j9XqRpOx3STIRiyUxm2UCgQATJk7Abs8qIMORnHIxjd1up7W1BY/Hw6RJkxBEAavViiRliYDi4mJ0HYMY0XWd3t5eenp6BlUZ/DKTjg8++CAPPvgge/bsAWDy5Mn89Kc/NRRQyWSSH/7whzz99NOkUikWLFjAAw88QGlpqTGPlpYWFi1axFtvvYXT6eQ73/kOv/rVrz5SlfeT4J/JzdN1nWeeeYa1a9cybdo0rrjiCiN/MDdOfp4QHJhAHm5Yfn5iTvm4v2n2N32+/bqhoYHf//73PPzww9xzzz3cfffdbN++nTvuuIN7772XX//61/z+97/nJz/5CZ2dnfzgBz/A6XQa81bV7GPmYEjHA2Vn5siwnFIwnU7z9NNPc9NNNxEIBDjvvPP41a9+RVlZ2bBKx+Hmm7NIz5kzh9/97ndcdtll/OlPf8Lj8XDzzTcb6gTIWkXPP/980uk0N954I//7v/+L2Wzmqquuwmq17ndfDrfM3Pd8om44ZeZwSs1Dub6Hm35/6zM00/FAio79LSOfTP2s7kNdXV0Ag6733PfcsK6uLsPml4PJZMLn8xnjDMWvfvUrbr311k99ff/Toes6wWAQvz/A6NFjmDlzFh0dHVx77Q9o72incecuduzcwd49e9E0DZfbRWlpGb4CHxarmUwmQ093N4lEAk2D+vr67Au64mJcHjd7du8h4PdjtzsoLi6huLgYj9dLV1cXmqbzhz/8EbfLybx585gyZQpmi4VgMEg6ncJqsaAoCr19fZjN2WiWL/OzcwQj+Fch9xx79913mTZtGj6fzxiWe9nf19fHihUr6O3t5ZJLLmHOnDlYLJZBqseDxaG+8Pu4aYf+liv2d+21137kWTLcPPc3r0QiwZYtW7j77rspKyujtLR05B7zJYaWR64dqML1Z4n8qtdDC90cbCXrj1vX4QjQnNJxKMH4cRDJ5jgGNTNB1U6v6ublvmloCJxSuJlJlnaKxWzB1IiGQbb5VZmYLhPRbKR1id6Mm4hmJapa2R4to9IWZKKtw6i4XS1FqXN/gEjWwq3oIrKgMV7uocIToFd1UW0KoSHQpBRSaIryu50nUOiNsidZxDR7K37ViSRoBFUHz3QfRr2zj/VdVaSSMrI5Q7/fiZ4WEVIShbUBHHKa3qQTVRMQC9PMqGllUcVbLItOoKvYzekFH1BpCmIXM0Q0maBmp1hKYBFAFjJ4pTh1Tj+Kni064zNFAZAHVIo5kk4WsgRejSlAv2anVSmk2h0gplj4RulqmtPFuKQkPjGJou8jfX1SFEWXBikN91WlPjQMVT5+nHIxV+l66LSfB0aIxy8B8smGTCZDa2srTqeT3bt309raamQw5gq4aJpmvLVct24doVAIi8VCe3s70UiMmppagsEgNTU1qKqaLYQSDmOxWkgmExQXF1NWlq0kabFYDIuexWLJW5d9D3BFUUgmk7S1tRGNRikuzqoC3W638QYxkUgQi8UIhUL4fD5isWzWZCKRMJSQoiih61k1mM1mY8+e3fT09LBy5Ur8gQBudwHJZIquri5a9rYTCAQBgf7+wEAG3mgikTABf4BEPMGmTZvQdZ2qqsp9NmlVxWQy4XI5BzIvI7hcbiRJIhaLEYvFKCosJBKJ4nI5SKZiJJNJPB4voVCEUChEOJwlfR0OG26Pk2QyQSIRp7S0FL8/gMViIRQKAdDd3T1IqfFZB3Z/1qiqquL2229n7Nix6LrOU089xZlnnsmGDRuYPHky1157LS+//DJ//etf8Xg8XHnllZxzzjksX74cyDZyTz/9dMrKynj//ffp7OzkwgsvRJZlfvnLX37u25NP7PT09PD4448jSRJXXXUV5eXlg/IZc8fsn7WqAoMsrzl8kixBSZLw+Xz86Ec/YvLkydxwww28+uqrxGIxHnzwQW655RYqKyv59a9/zV133UVnZye33HILJQNEfG5dPg3kzvF4PM5jjz3GL3/5SxKJBJdccgk333wzBQUFB0XY5m+jIGTD4o8//njuuOMOrr76ah555BG8Xi9XX301VqvVmKfFYuG//uu/SKVS/OxnPzMUkAsXLjQqkX+cUnXosNzLnkOx1n9a13a+XR3++eOUv15fNtvq9ddfzw9+8APjezgcprq6+l+4Rv8e0DSNlpYWgsEgsVgMh8OBxWrD7fEQCoWQzRa++c1vU15eTl9vL+0dHbS3t9PZ2UFra2v2JYxkQhBENmz4AKvVitPpxOVy4fV6qaysZNZhswe9YInFYoiiyJFHHsnpp5+O1WJFzSi0tbeyavVqnE4XDQ0z+L8//IktW7ZSVFREIpngxRdf5Hvf+97nkj83ghH8O0EQBJLJJCtXruTiiy8e9CzJKeKPOOIIVq1axZo1a9i4cSPTpk3juOOOY+7cuYwePdp41h5MVvUnebbkxt9fvEn+/EwmE+l0mrFjx3LccccZw9rb2xFFkaKioo84KnLt8EwmQ0tLC6tXr2bJkiVs2LCB0aNH84tf/GKkqvWXGEPzGLUB23E+csTkUFIyn8gbTumYPyz3e87GvT8793DZkHDwdutc5WxNF0AYso5Dts2ocJ23Ljmr9lBbtjF/QNEFulQHrUohu1PFbI+W4TClOL1oEzMtrXhFDb+279mds+MmB+bXrzoJqnYimo32VAH9ioP+lINI2sokZydzrHuQ0AlpMqKgI+k6/ZoNMypWIUO/ZsMrJolrFhxCml1KEQ4xhV91sjoymsg2H4VTe1nRN4qd1hLSmgmrpLC9rwSrnGFTewWZlAk9I5LptyImBVSHxuzpjQRSdhrfGUWqOo2QkCgZ1c8ZxRtxCGku8q7Cr5lxiQoSOmldJKmbCGtWwz492dxDr2rj9IKNrI2NpswUQtNF9qaL0HSRMlvrRyzNRZKCRwzRIShMcHXzXk89SV3GIyWoNAVIDdjJcwV5zGggZKfPb93nqxUPVGl6aJGYQ4Gq60YV7Px5fR4YIR6/BMh/+LW3t7Nz5048Ho9RDS6TyRAKhQyLQq6D3NPTQ0dHB6NHj+a0005j06ZN9Pb2IwgCLS0tSJJEfX39QBakitPpRNM0zGYzXq8Xq9WKyWRClmXDGp1TWmVJwn25cO3t7axevRpJkqipqaGiooKGhgYKCwt55513iMfjFBcXG0oYi8VCMpk0GjCpVIq9e/dSXV0zoEKUcDgcvPbaYpqb97B9xy4KCgqz6kmThWg0ikkyYTLJKIrC7t27SSRi2OxWPG43fr8fTdNwOrP2sRkNDTQ17aS4uIj+/n6sVqthSc9VHX7zzTfJZDK43W5sNiuBQABvgZtUKkuq6rpAf38/silLxjocTlRVI5lM4Xa7DPVoOp3N1LTZbMTjccP2nivI8XEW0y8yvvrVrw76ftttt/Hggw+ycuVKqqqqePzxx/nzn//M8ccfD8ATTzzBxIkTWblyJXPnzuX1119n69atvPHGG5SWljJjxgx+/vOf8+Mf/5hbbrnlU+1UHmyjMUeYLV26lB07djB16lQWLFjwEYXYwRJPh7pOh2K/z2+U549vsVg4/fTTqaio4IorrmDZsmUsWrSI+++/n8svv5zS0lJuvPFG/vCHP+D3+7nrrruorq4+JCJwOAyNgohEItx111089NBDAPzoRz/i6quvNoq95C/r4xR/+ftFkiS++tWvEolE+MlPfsJvfvMbXC4Xl1xyiVGwJJcNdfHFF5NOp/n5z3/ObbfdhsVi4Xvf+94g9eqhIHceHOjaHUoif1rIL96Tvyw4OAXK0P2Y+5/LG80n0z8NlJWVAdkXLrkXYbnvM2bMMMbp6ekZNF0mkzHyg4dDrmDJCD496LrO9u3bueeee0gk4uze3cwrr77CNy74JlarjQkTJzFu/ATj3udwOqgbPSo3MZquDeShZhVTOYI8d37JsjxsUSun04nT6SSdTtPb28sHH2xky4cf4nA6OPbYY4knEjz00MNYrRbGjBmD2Wxi06ZN/PnPf2bUqFGcfPLJI4TACEZwCNB1nR07duB2u6mrqxv08jT3+Wtf+xqjR49m6dKlrFmzhs2bN7NmzRosFgtz5sxhwYIFzJ8/n+LiYsxmM4qiHFQhuo/DxzkfhtsWTdN44YUXqKqqQpZl4xn3xBNP8PrrrzN9+nRKSkooKytDlmVCoRCdnZ309vbS399vZNFLksTMmTO56aabqK2t/VSfhSP4fLA/W7QoHDjfMZ84zCkRNfYp8ZK6hCxoyGgoA7RQjgTM/68hIAuasR4y2YrX+YRhbr0URGS0QeNBloxUEFF00aianRt3aEVrNS/7UdUFzIJmVIxW0Q1yyyKoaPlELAIOQSOmiYQ0C2HNyuZkNXuShVjEDBYxwzdKVlJnCgxst44CuETVyH+M6SaSukRXxkOrUkgg46A1WUB/yoFLTtESLcAhp6lxBhht6UFDoFe10Z4pwCqmaU0XIgo6G6M1HO3egVeK06oU8pfOw6lxBFB1gcNdu9meKGdXuBg5LNAXcFFd4mf9pnocFRGi3U5M7jSR+IDjSRVA1tFlDdUkcOqsTZgElY2tVZgmh2ko6SaUtvHV8k2YBZUKUwJFB6ugouiisY07FA8dSgGqpd2woJdKCVxiGsXeQmu6EI8UQxQ06uQ+oxK4qoNdFNCAtK4jCVAmxZlsb6fZWYRXiqHqAjHdjJeEQRhrA8fUKqhGRuSw5/d+2vkfyWvM+z1XpZoBcjE37lASMz906fOwWOcwQjx+CZCvLPzggw/QdZ1kMklNTc2A6kMHdCTJRFFREZFIBFEUGT9+PJs2fUhtbS01NTXMmDEDk2Riw4YPeOuttwiFQ/T39+NyuTBbZKPAi8NhJxqNYjabDUuGpmls3ryZzs5OxowZQ21tHVbrviIw6XTWihwIBGhvbzce+Dk1pN/vZ+zYsQapmFORmUwmQqEQ6XSagD846M1qOp3G7w8Qi8UJhyP09vbj9nhIJRTCkSiy2YySziDLZuwOB/5AAK/mRhAEurqyHduamhrq6upIpZL4fD76+/txu13E4zEjvNpms5FKRdi+fQcul4uq6mri8QSCIJBOpwGB0rIytm/bSXl5OYFACFmWcXtc9PR0I4oiHo+Hjo4OioqKWL8+G5QvCCJms4XW1lYaGhoGHc8vk9pof1BVlb/+9a/EYjHmzZvHunXrUBRlUL7bhAkTqKmpYcWKFcydO5cVK1YwderUQVbMBQsWsGjRIrZs2TJoPx0MPq28ulQqxXPPPYeu65x//vl4vd5BpE++YufTPG75isocsTV0GR+3vNxwWZaZOXMmDz/8MJdddhlvv/02ixYt4oEHHuD888+npKSEa665hldffZVgMMjdd9/N+PHjhyUC8/FxBFeOwOrv7+fmm2/m6aefxm63c8stt/Dtb38bm802bIP+QPMdOkySJKxWK9/61rcIh8Pceuut/OIXv6CkpIQzzjjDyITK5TMuXLiQVCrFHXfcwS233ILFYuGb3/zmINX2oWAoWTd02HCfPw4HIpxzL0OGs1f/M3lWQ5ebI1SHWv4/KUaNGkVZWRlLly41iMZwOMyqVatYtGgRAPPmzSMYDLJu3TpmzZoFwJtvvommacyZM+dTWY8RHBiappFKpXj22Weprq5i9+7dgI5sMpFIxHljyevMmDGDktKy4Z9XgoAoSIiihMkkD/yUG64P/AG6gA5GhnMgEKCjvZ0dO3fQ0dGOpulMnTqFs84+i0AgwLJly7A7nJx//gV0d3fhcbtYt24dkyZNJpVK8sILLxh5oCMYwQgODul0mldeeYVTTjkFk8k06HrOOXEkSWLevHnMmTOHVCpFZ2cnbW1trFmzhvfee4+bbrqJ0tJS5s2bx4IFC5g6dSoFBQXDvpT9rNu2PT09LFmyhDvvvNN4dimKwp49e/D7/bz11lvE4/FBzpDcf0HIZkVOmTKFc889l+OPP95wt4zgyw1DIfgx0PLyELOKsyxhlyP3ND1LCKkIKIgfUTXmyD9R0FF0EXFgmKKLBtko5qzPAyRkvhJRFrKEYo6AzMEuZIz1ktAN23ZSlzCjkST7XxOy62keIDyTumQQjLKwb3656XtVBzvTZfQobjZHKiizhplqb8Muppjt3E2ZKUSJFMUjKgPrOPA3YAtWBgjZPYqPuGahVfHRk3bTnXLhNKWptfvZESlld3sRhYVRFhRvoVrup0t18mGyGk0X2RipotictRZv6q/AZUoSyVh5r30UyoYCug9zUWiPYREzrO+rxmeLI2ZATUl0Bd3IfpFkzANulZoSP82txZSVBVE1EZ8tTjIjM83XjkXM0Jn0cMzoRixiVvRTZQ9SZgoxx9pqFNSRBQ1VFwz1YUyzoOmiQQJqZInFoJp94R3XzFgG9o9PShrkpMI+As8sCKT17DEfa+6iyDxmoNCPSFIzExRsFElhw26tIuAVMogMXyRmKA7USs+vUJ0/nxwJqcE+a7UgIAsCqq7/U6rJT4oR4vELhvyOYn713FwWU3t7O7FYjGAwiM1mRRRBR8NskVCUNBarGYu5gPfee4+CAh9HHTmfktJS2ttbyagKDTMbOH/CeXgKXDz88MOklSQOl53CwgJEScdsltA0lVg8hq6ruNwOTCaZVDqB2SITCgfZsXMHXV1djBkzlsrKKmw2W7YydmEhnZ2dmM1mJkyYQFFREbFYjK6uLoKBgFFIxmKxGKRfOp2mt6cXn89LgceFSczewmXJREd7J6FgmKKiEpxONyY5hS5IdPd3UlhQhN/vJ5lKYrM7EDQJUZDp7u0nGAyjaZBKpSkuLqa4uJBEIozL7UAnRTgUpLCwmFgshiBIZBSNPbtbiEYjTJ8+g2gkitvjIqNoqBnQNB2rxYzdbsdutwE6CBqBgJ+iokJEUSCRSOLxFCCKJryeAtoiHaCLmGUboVDUOKafVgf/X4kPP/yQefPmkUwmcTqdPPfcc0yaNImNGzcaatl8DM13Gy7/LTdsf0ilUqRSKeN7fnGJobl8nwRtbW2sXLmSgoICTjnllI8o+XLz/zQxnHoxn+w8FEtwvpV/2rRpPPzwwyxcuJD33nuPyy67jPvvv5/jjjuOJ598kmuuuYZly5Zx4YUXcv/99zNr1qyPdOQ/btlD98/evXu57rrreOWVVygpKeGuu+7izDPPHFS9OzftcOrAg1U/WiwWLr30Ujo6Onj88cf505/+RENDA6NHjx60DVarlauuugpFUbjrrru4/vrrjRzIodm0H4f84zS0sMuhdLYOhTA82EzHT4Kh65wjvg+WxI9GozQ2Nhrfd+/ezcaNG/H5fNTU1HDNNdfwi1/8grFjxzJq1ChuvvlmKioqOOusswCYOHEip5xyCt///vd56KGHUBSFK6+8kgsuuGCkovXnBEEQ2LVrF36/n3g8jqKkKSwsxO128+c//4lRo0ZRW1tDUXEx7e0dRtE0t9uNxZIlGnVdIBKJ0NraSigUIh6Pk0qlSCYSpNPJ7OdkirSSbfxLkojD4aCsrIypU6dy+OGH4ff72bt3L8uXL2fUqFFccME38XoL0NGZNHEiGzaup6WlhWnTprBp0yYURflX7rYRjOBLB13X6evrIxwOM3HiRGDwM23r1q10dXUxf/58zGazUeRlzJgxjBo1iiOPPJJLLrmExsZGlixZwltvvcULL7xAWVkZRx11FGeccQbjxo0zRAWAkYV9sFmLB7MN+Z+XLVtGdXU19fX1xvKamprYs2cPjzzyCG63m0AgQE9PD4FAYKC/ZKO0tJSioiLDlSXLsvGs/XcQA4zg0CAaFaAH27QtgmooB5O6CauQGTRdNvMvOzw3TNP3kZY5NWQ+aakioOgSDkExiMKkbhpYj2zbK0cs5tSaii4hChqKLtGhFpDUZFoVHy4xSUi105r0IQoaBXKceY5GWpRCdsTLCCp2doWK6Q66aKhqo8QSYYqjnQb7Ho52bqdYjGMVNCK6CYeQGSBA91XCjukmg/gM65aB5RbSlvYRzlhJaGZcpiSj7P3sjhfy+u4JSM02LOOjfKNuLWWmEHuUYhqTpTTFi9gZKGGyrwsVkTdbxjGhuJvVfbXUufwktntRi1RMigldF2iOFlHn9hPPyNh6dUpP6mFPVyFmVSBdnKKoOIJFyvCNGWuot2YFRtVyPwoSMiq70mWIgk5GE9kYqKLUFuHismWMl0NENBGzoBHTTchoSMK+bfZKMboVD4qezV+UyVWC1imWwrSKhayL1DLR0Ymii6RQiQ0cPxcqaV3HLAiYBQENnWopxXGebYQ1KxHVhktMktYl/JoJr5hBHjiPcqTjZ0X8SQMEI+QRkXk5kgeTB/lpY4R4/AIj9xDMZDKYTCbWrVtHW1sbXq83a31y2Emlk4RCQQoLC7FaLYBAV2c327ZtZ9euXVx99TXYHXYi0Sh+fz89PT243W58hQUUl2Rtx51d7ZSVFyOZJHp6uiksLMRb4CESjWYLz3g8OJ1OJk+ehMfjYfv2HcTjcdLptGFXLioqYtasWZSWlmKz2SgqKkJVVTo7O7PFVYqKSCQSWK1WEokEDocjq3IMBJBNJoKBIFWVVVjMZuw2O3v3trBq1WpksxW3x0tayaBkNDLpOJoO3b09mM1mLDYrvX09SLKMrmnogM3hJB1PEtE0Zs6aidvjIhbX6O3tRhQFJJOIIIDT6SIeT2I223jmmWfIqCpjx47Nqs8yGn19AUoGLN/RaDbr0Wq1MHbsGAoLC0inU1gsFiRJoqenl/Lycvr7/TidbrzeBIFAiGQyRW9PH/F4Ervd+i89nz4tjB8/no0bNxIKhXj22Wf5zne+wzvvvPOZLnN/xSXyC74cTEj50Glz/9etW0d/fz/HHnssNTU1xu+fV2M0RwDlMpSGqtIO1oadI8emTp3KY489xqJFi1i+fDmXXXYZDz74IA0NDTz22GNce+21LFu2jIsuuojf/e53HHfccR8h5D4ufzK373fs2MGVV17JypUrGTVqFPfccw9HH330IJtlvqru41R4+xuWW97evXtJpVJMnToVm832ERVibl/a7XauvfZakskk99xzDz/5yU+wWCycddZZHylkdCjH+EAVrw+0/geDT9PWf7DIz+s6GKxdu5bjjjvO+J7LXvzOd77Dk08+yXXXXUcsFuPSSy8lGAxy5JFHsnjxYsMSD/CnP/2JK6+8khNOOAFRFDn33HO55557Pt0NG8F+oWkaW7ZsobW1lSlTpjJq1Ggef/xxOjo6OOWUU9F1kRee/weVleuZPXsW0ViU9959h+7ubPtg+vTpTJ06HafdQWV5hVE4TlVVNE1DEvfl2KqqRjKVJBgI0tPbQ3tbG3t2N1NYWEh9fT2nnHIKBV4vgihlX8gLIOiwdetmXn7pJebPn8uWLVsIBoPMnj17hBwYwQgOEe+88w5HHHHERzIMM5kMTz/9NH/961+ZM2cOl156KdOnT8dmsw2KFfF6vcyePZuZM2dyxRVXsGnTJt59912WLl3KM888Q11dHSeddBLHHnssEyZMwGq1oqrqoGzlHPIz6w/mWh76XEokEixZsoRzzjnHcDoIgsDLL7+My+VixowZ2O32g943uXbJiM36y4tcHuLQ32CfCjI3XBR04prMS+EZyIJKOGNlb9xHJG2lM+Ii0u8AUcfuTpJMmJHarChFCkLMhBwR0GTQZB0pKaBLYIoLpEpUdEnH2mlCcWnoZSmcziTJlIymimQSpqwlODNgv45KqN4Moi2DHjKjizpYVVBExJiEKS5gDgiYIzpSCixhDcUuYA2oaLKAHFHRZBFdAP9EmYwN/uQ7CikhICUFbD068TKBWQu2Mc/bTLfiZmu8AuxwuHV3thCNAA4y+ypfD6g7IWtD7si4aM8U0JvJ1mloThSj6SI9KSfxjJlyW5hYxszKjePwrRfpP0zl4vFrsuOmi9kZK2NjbyV9vS6qK/x0JtzMdO/l5eQUdvSVML6oB0WTkEZH0VscRPvtpBxxjineRVS1UGIO83DVWEK9BUyu7mTBzC3Um3tQEWhXfFiFNCWmCF4xTr/mIKLaaE5lC01NtHWwLVFBLG3mhMpt1JlCNCpurIKCKGg4BshiGd2wkRdLET7QZEPJqAKKruMZKKzjM0XpTrg53LUbFYF+zYJfdVImhVF1HUUfsNULArlQp0pTgKBmZ1vGQakcpFUpJKnLzLBkCVMJHYcoDM50zDuH88nI4cjBfFJxUEbkAabJDVN1nU/HL3joGCEev0AYruOXa7yn02mam5vp6OhAlmVKS0twu92YJDOyyWLYntEFWls76O8P0tbexZ13/ZYrr7wSyWSmsMhJSUkJnZ2dA5WdC5BNMpIosWXLVqoqK5EE0aiSXVVVSXPzbsaMGTNQCReqKqspLioZpMrK5SRWVFRQWFhIIpEgHo/T2NjImjVrUBSFiooKbDYbfr+fwsJCzGYz6XQan89HeyxOPJ5AlCQ0XcdiseIPBGhpbUPTdVRNIxAMEI3GiCeTRMNR7A4HkUiEdCqFbDaTSqewWaw47HZUNYOiZOddXlZGIpFA17NVp8PhMIqi4nK7UVUQBJne3l66urpw2B3U1dVhs9mQZRmLxUIqlcI0YD/L5VSmUil8Pp+R2Wi1WikpKSGdTuNwOOnq7DEyMWVZxiSb+Hdqz5jNZsaMGQPArFmzWLNmDXfffbdRVTgYDA5SPXZ3dxvZbWVlZaxevXrQ/Lq7u41h+8P+ikvs69x+MrtojsxqaWlh6tSpnHDCCR9pLH/WKtWhjd188nF/mY4HmleOuJo8eTIPPPAAixYtYu3atVxxxRXcf//9jBs3jkceeYTrrruOl19+mYULF3LnnXdyxhlnGDmI+Z2DociRY5qmsWrVKq6++mo2b97MtGnTuO+++5g5c+ZHlHomk2lQkZRDbeDnrOg7duzgxhtvxO/3o6oq1113HaNGjRr2GOXIxx//+McoisIDDzzAD3/4QyMvMkeMHqryMf/zP6OGHU61OrSC9ufZETrYZR177LEfq2T5n//5H/7nf/5nv+P4fD7+/Oc/H/I6juDTgSAIxONxVq5cyYIFCzjppJOw2Wzcf//9PP/880yZMpVp02ZQV1eD2SLjllwkEgmqqqqYPHkysiwTCUdwOBwEg1lCMRQODygek2QUxbiHSZKEzWajoKCAyZOmUFxaitPpxJTX4c/eUxhQ36qsX7+O9evWMWPGdHp7e0mlUni9Xs4666wRm/UIRnAIiEajrFq1ih/+8IfA4Pt8a2sr//jHP/B4PLz33nusWLGCo48+mv/6r/9i5syZRu577pktiiJOZ7YK/fz58/n+979PY2Mjr7/+Oq+99hpPPfUUY8aM4atf/SrHH388VVVVH3nh+M8+05qamojFYhx22GHGfEOhEC+//DIXXHCBQTqOkIj/GcjZmIdWjM4Rjoou8mGqCn/GiVNKElWtdKY9vPjqXIo2aqgWAV3Ikno+TcdSZsLeo2Jrh2S5iaRPRxdlfB8ESVQ4iZWbsPk1LH1p5K4Q3ceXUbgFnHviSO19aIVe0qUOTBETpr4wukVGCIRBkkAQ0FNpBIcNkimwmNFD4ayn2SxDJoOuaujJFOhZWkhXVRBEBHnfi3wtnVX+C5JE9bYydIsZIZYAQSBwRBWqLKC4Nbb0lhHNWCi3haiwhKiU/VgElYgmkxQ04kYl5wguUUHTdYKahVbNTrvio0dxo+gSSU0mlrFkcyJNaaySgleOZ0m8igie8VGOKWijJ+0ilrHw5pYJCCaN0pIQdncSrzXBN8tWoSIiNtvwzA7z3fL3KJPC/Cx9JtszEt+YuJ56aw/Vcj8RzUa13E/zGWsYbetlrq0JWVBRdAmrkMErxrEKGSKalaSe7bP0q07implRll78GSereuuocgWZam2lSSlgRWwsUdXCXGcTDjGFikCdKYBdUPGIAmldwSUljQI6kM1vNA/kfcY0C1M8HdSZewlqVlqVQrxSbCAPdGB8PprJGNMspDQTmi7Sl3FRZ+4FoFfLKmlzRV7yezD5hOLHIVedOmenzi94k8t0HJT7mH+NDJmGIZ8/K4wQj19A7GuI76u429raSn9/v5HvKMsyu3Y1UVu7PWtV1SUyqsqyd95h48ZNpBUVi9lGd3cvf332b3z7298mFArT09NHdXUlqqoxYfxEGhsbCYUiBEMB1EwGhz1rrQ6FAui6jt1up3FXMyUlxYbyMbt+EApFgCwRpaoq8Xgci8VCf38/q1atIpPJGBUsc9Vu0+k0ZWVlmEwmI+hZ1bRsVgwCqpolGvv9frZv34lkMhEMhVEyKoFQCJMk43A6CYdCRiESXdexWq2kkilEIBqOIEsi06ZnO07JZIJINEhVVSWiKOFyuUml0uh61ib4wvMv0tXVxbhx45gwYcKARSyZtXUJ2UZXKBSir6+PeDxOYWGh0RBLpVJGFfHc/koraTo6OvD7/cZ2ZzKfZ4LC54tcXtisWbOQZZmlS5dy7rnnArBjxw5aWlqYN28ekM13u+222+jp6aGkJPt2asmSJbjdbiZNmrTfZeyvuMRQpWC+PXW4hu5QwiR3Pa1evZry8nLmzJkzaD6fRnj6J0Fue/KJqINtuOdv/6RJk3j44Ye54oorWLFiBQsXLuT+++9n4sSJ3HvvvRQVFfF///d/XHXVVfT19fGd73wHq9V6QOJLVVVUVeWNN97gmmuuoaWlhWOPPZbf/e53jBs3blgyL9+mnOvIfNy25B+rTCbDa6+9xjPPPENraytz5szhmmuuYdSoUQckEAVBwOl0csMNN5DJZHj00Uf5wQ9+gMlk4pRTThl0DzmYfTt03rAvZzTfVn6w8xlqIcs/dsPtw08DwylZ86+bEfz7QxAESktLkWWZzZs3o6oqRx11FC0tLaxZs5ZwOExfXw9ms4nZs2ezc+cOZs2aRa6AU21NHS+88CJNTU0IgsDM2bM46aST2LRpE2ZZZtrUacZyBsXH6Dq6mCPt2fdfEEDTaG9v47333sVms1JWVkp1dRVOp4P+/n6uv/56SkpKRiyRIxjBIeDDD7M57/nFviD7HOjq6iIajXLKKafg9Xrp6Ohg9erVXHrppRx++OGcffbZHH300RQWFhrT5D/nvF4vhx9+OIcddhjhcJjNmzfzyiuv8Nhjj3Hfffcxd+5cvva1rzF9+nQ8Hs+gfMlDvYZzbYclS5Zw2GGHGeskCAIbN24kEAhw7LHHGr+N4D8Hw1WPzqFJKeYX608DQN5uxxzK/u6K6ySKRDJ2gYIdGWydMTJuC96mDIGxVjTZiSWo4GlMEa22kSx3ggjmqI6U1JF7owiqRtnLe9GKPAjxFLrbidDVi6WrFyQJPZGE0qIswRiOoicSCNUVkFHRk0m0QBA0HUES0eNxRKcDNG0w6UiWYETT0fUBEnLgGSpYLaid3YguJ6kptbSeYCHj0tFcCmUVAQA6I25KrRGiqoXmVCm7UmXIQna+oYwdu5TCalUoltL4VTOtSiFlphDjzF2YhQxb4pX40w5iqhmHlMYrxymQ4wBMtbdycfEytqYq6UgXMMbaxXvhcZidaUq9EfoiDs4fu56vuDeyRykiqcn88NwXqJN7qTSF8YgqY1y9RIssXORbMVAgR6BEj6Ii8F+F7+MQMtgHCrDENJG4YQPPUnUx3UxQdSALKqVyNoKrM+2hM+DmjIpNvByewTxHIynNlCVRdRkraRTdhEtUUXRI6joR3Uxfxpkt+qKDKGCoH4OaRKEUJS6baVcKjHPLIaTxiSpxHSx5txwJSOoYRXX2xAuptASoMvtpVQqpNoVpzXiZIPcNa7HOkZEwfHZj/niQl+GYh6FEZjrHJw3M77O0d38cRojHLyCGI0dy9kKr1WrYIHbs2EU8keKEE07gpZdfpb29ncbGZvr6+onFYug6OOwOVq9eh5rRuei7F2GzOnA6XLicbs455xxeeOEFOjs7sdvt7NixC1EQqaqqQtd1TKZ26urqKCvzkq3oHEDTsh3s7u5uLBbLQGGWFGazGU3TCAQCRCIRo5q21+slGAyi6zplA+pDSZJIp9NYLBZWrlyJxWLhmGOOw2a3Y7ZYaW1t5y9/+X8omQyIJlRVIRSOUFpSZqwrgChJJOJxNF3H6rCDrBHw+3G73QhahhkzphOPx3C5i7Hb7MTjcVRVxVdQgCTJBANh3nnnHd5f8T6iKDJlyhRmzmxg585dbN68OUtmppPous7mzVsoLS2moKCAgoKCQcV3dF0nk8lQXl5OR0cnHrebiooK0mmFSCRCeXk5Tqfj36LDdP3113PqqadSU1NDJBLhz3/+M2+//TavvfYaHo+Hiy++mB/84Af4fD7cbjdXXXUV8+bNY+7cuQCcfPLJTJo0iW9/+9vccccddHV1cdNNN3HFFVd84qq1+cRctspq5oCEYf5x0DSNSCSCIAgkk0mqqqoQBGGgcvtH7af7I3+GdrA/jeOcI4Lys16H25YDQRAEJk6cyIMPPsjll1/OqlWruOyyy3j44YeZMGECt912Gz6fj/vuu48bb7yR/v5+rrrqKpxO50eUibmXIbmiFDnl4TnnnMPtt99u7Luhy89fx3zy8ePyEfOXt3jxYp544gmCwSBnnHEG3//+9ykrKztgqH0+2el0Orn55ptJp9NGzuW9997LggULPmK7PhTkk96ZTMawpx0MAZlvIc/vjA29T3xahOMIRpCPmTNnMnXqVKN9sXPnThoaGhAEkffee4+NGzcwduwYOjvbUVWVcDhKbW0txxxzDO+++y4LFpyMzW5DVTXMZgsmk4kpU6YAoJP1TOfiT3KnsyCAMNBJ1Mle24FAgD179tDa2oLNZuPUU0+ltKyEvp4evF4vK1eupLW1ldra2oF5fLmfoSMYwWeFoc8KVVVZvHgxp5xyykfaRIIgMHr0aL7+9a+zePFiEokExx9/PNdffz3xeJznnnuOm2++GZ/Px9e//nVOPvlkRo0aZbysg33uBUEQKCgo4KijjmL+/Pn09PSwYcMGXnzxRf77v/8br9fLV77yFU488UTGjx8/6IXfwV7PmqYRCoV47733+NnPfmY8Z1VV5fXXX2fKlCnGPWIE/zkQBX3YojI5JeQ4uYen5v4eFZFflp3Ozm1VuHZJJAsFCjdniBdLpF0iyQI35qiG+4NuStqFrEJR06C3H89uS/Y8laSsMlHX0RPJ7LPNbEaXJZL1hcihNHIqjW6SEKJxtHQaWjuM8QSrBb29K1t+Tclk2S1Az2TQNR0tkUTIXRuajmCS0TMKuqoi5fqQZnnfA9XnJTi7GP8kAfPkEIKioAWtSFaVSMJKOi2hRM2sSMvU+fxsVKuQRZU6p59icwS7mGaGtQWfFGeX4kEdKEbTnimgW/GQ1GScUoqUyYRFylBhCVIihykxhRkt9yGjsUspQhZUPKY4r/qnsam3nPFlPRxVuIvjHdsA2J4uJ6nJzLXtRhwoipPWRd5PVvKPd2Zz4QnLkNGRBJX0QIGeXBGerH0ZkgPH1yum6VVtWIUMQc1Oa7oQFZEyU4iYYKZTKeCN1vG4HUk2RqqY4Wrjw2QV6/w1OOQU3/StoCNTwGi5j6S+L9syomWjgNSBW2h+URYJnYhmxSooaIiIaGh5dKBFGEzkqWQL0xRKUXpUFxYpg4TGpng1J7i24FetKLoJiwBWQSCZRyDmCMODVR4ORzrmfifveZAjVIGBAkifj7pxOIwQj19g5HdoOzs7SSQSuFwuKioq6OvrB2Dzhx+iaRrbtm/nw81bAAGP24PN7iSdVujq6aO6upqmPS3835/+TGGBh3g8xrhx45AkiR07dlJXN4pEIkldbR2dnd3oOhQUeIlGo2QyGex2O1VVVZhMJpLJJF6vF5fLZdiQczmPVquVdDqNpmnU1NRgMpmw2Wy0t7dTUlKC3W43LMz9/f10dXXh92czETOZDIIgYpJNPPLYY6xcvQZRktFFlVQqhaJkSKRTmG1WgyjSVBVZlpFMJkKBAHabHUEUsFrNmAQLlZUVqJpGMBjAbDHT29tLUVGR0VBat24DG9ZvJKNk8BX6GDduHNFolJaWFvx+P4lEglGja2lra6O0tASXy0lBQQE2m814c5vLzCwqKiIcDmOz2TCbLUYVXl3XiUaixvHM4cvaeerp6eHCCy+ks7MTj8fDtGnTeO211zjppJMA+O1vf2tktqVSKRYsWMADDzxgTC9JEi+99BKLFi1i3rx5OBwOvvOd7xzQlnkwyO3PfKVgPimV3yDP2bJzjd6+vj5WrlzJSSedhNfrNSoj5+b7SQjjf4ZkHo48y6kMD0VVl6/cHDduHA888IBBPi5cuJCHH36Y8ePHc/311+Pz+bj99tu544476Onp4aabbqKwsNCYPkcWxuNxHn30UW677TZSqRQXX3wxP/3pTykoKDjg+T20w5N/nPJt0rlty2XFRaNRHnzwQZYuXcqOHTtYuHAhV1xxhRFkvz9V4HDL83q93HrrraRSKf7yl79w9dVX88gjj3DMMccMS2AeLOEnCIMrXg+nUs1ft/2t7+dlr97fsfmy3pNG8MlQVlbGN77xDZYuXUp1dTWlpaXs3bsXs1nm/PO/Tl9fH83NzUSjUcaPn0AkEiUSifDaa69hMpnYsnUzRUVFOBzO7EtDsxlRlAY5AVRVRVEUkskkiUSCaCRMMOgnHA6TTqcwmy1UVVVhtZg5+6yzsNltuN0eSkqLaGtp4fHHH2fLli243e4RRe4IRnCIaG1tpa+vjylTpgx6zuaeTWVlZfzP//wP3/zmN3n22Wd54YUXWL58Oaeeeio33HAD4XCY559/nqeeeorHHnuM+fPn89WvfpVZs2ZRVFRkvLTLf45JkkR5eTllZWWcdNJJNDc38/rrr/P888/z5JNPMmnSJL72ta8xd+5cSkpKDLfQ/p4/+ZE3q1evRtM0Ro8ebUzT2NjI4sWL+elPfzooR3gE/xkYmuWYD0WXQFCRBZX+jJMLKtawxdtB09Qi2iJeWie6sDriJHrtCPYMBM0kisop2JkkVSCj2ERMqWJcO4IQiqJbzehWC2J/EEEUwWZFD4WRusEWTiDEk2ihMILVCiYpS0pmMgg2a5aoVDJZdaOuZ1WNA0yVrum5jckOF0QEiexnVQRdQ8sV19Q0xOJCdJNE+2mlREar6LKGpIq47NlxLOYMZa4IaU2i2+Qi3ulk+24XmgnEohSpUhOqW+AI9y5aFB/bU+VUyFmFZGOqFFUXsYoKpXIIFZEiOcLGSA1v9YzjlLItTLa0sT5ZQ53ch0NMoSGyIjyGd5vr+fbk1cxxNFFtCrInU8CyyASsosIJri1GJWkVgVXJOm5ddiZ1Uzs527OepC5iFTQ6VBftSgGHWVuwCzopPUs6dqkOKqUoaV3EJyWJaDIfJGpojJcwytaHV8qqMN/pG0siJXN49V4gW436b7tnEG72cumJS+nKeKgwBfCKGVQdo4p1b8ZNjbnfIOMUsgVmIlq23THW3EVMs9CrulF1AbuYwifFDZt1ruh5joC0CgK1pjAtio9Jzg52p4rRdIE9SjETLB1UmAKDbM4KuUrXg0lCSciRn1kMZ6nOt4fnY6iiMbet/+qW1Ajx+AVG7sEaiURobGwkGo3i8XgMBU9lZSV2R/YtSG1dHbLFSkdHBwUFhYRCYZKpZNb229mOx+MhlapC1928/fbbPPnkk8iyGavVSkGBF7PZjMvpRDaZ8PsDTJkyGavVQnd3D42NTbhcboqLi1EUhVAojM/nIxKJGJ3sVCqFqqrYbDYcDgcej4dkMjlgh9hnW500aRKyLJNMJtm7dy/t7e14C5J0dfdQWVXDgw89zDPP/JWx4yegahCJRlFDYRySTFrJLsPusBOLxlA1DbMso5O1cMXjcSRJIpVMUlFbg9vjwmKRicXiyLIJSZJIJlJklBCKorF+3QZ6erN5Cx63B0mS+PDDzQbRU11dTVdX14B6NNvYcTqd9Pf3o2makQGpqiqJRAKLxUJbWzsOpwOfz0dz827i8ezNMLufBhNhX8aO/uOPP37A4Varlfvvv5/7779/v+PU1tbyyiuvfNqrZmCo1TofOXVZJpMxvqdSKerr67Hb7Vit1kOq8PxZI9dBGKoUHI4Yy89lHEq8SpLEhAkTePjhh7nssssGkY/jxo3jsssuw+fzcdNNN/HYY4/R1dXFr3/9a2pqagwrcSQS4c477+T+++9HkiR+9KMfcc011+ByuQ5ICgxH/g4lNIeSxJlMhkgkwjPPPMPLL7+M3W7n5ptv5oILLsDhcByUBT5/fvkh+T//+c/RNI2nn36aK664goceeogjjjhikA3skyB/e/KXfyDsz3b2eZxzX8b7zwg+HeSuxfPOO4+urg7eeusdLr/8cqLRGF5vAVu2bKazs5O5c+fS0DALn6+AyZMnE4/HWLr0zYEM6OzLyL6+fnr7ekmns1WsFSWDqmbylNoSVqsFt9tNYaGPiRPHUVpaSmFhIY2NjYZaqrCwCJvdQVdXF/ff9yBvv/UmM2ZM5/TTT6erq+tfvMdGMIIvHxYvXkxDQwMul2u/LyxNJhOTJ09m3LhxnHfeeTz33HP8/e9/54033uCCCy7g8ssvZ9GiRbz77ru8+uqrXHfddXg8Hk4++WROO+006uvr8Xq9xkvE/OeZLMuMGjWKyy+/nG9961ts2LCBl156iV/96ldIksQRRxzBKaecwuTJkykp2ZcdD3zkhWQmk+Gll17i5JNPxm63G8/al19+GZPJxPz58z+nvTqCLypUhEGfY7qZXsXNE21H0NRVjBozYXIqZOImJHsGk1mlwBnHaUthllRqxgTYO76A7qQFuzlCOG4l4bdhnVaImCpEN4GUBFeLl0SxiCmu420qQO6LQ1/AIBAFpx3V50QM2RACIQSbDUwmRFlGt1sRYwkQRfRoDD2VQk+msvZpUciSj2Y5q4JUNdDy7NaAnkqBkkErcOHeq2LvFjBHdcLVbiw9Kq5ghr5pLprKvaguFUu3CcGt4RoT5NxRG/FICXymKP6Mk53JbPyCVVQIqXaKTBGqzH7Suon2dAGSoLEzUcab7eNwWlJ8p3oFIhoRzcb/tc3l6to3UHQTL/mn059y8L0pKzjfs46YbuK16GTWhmo5oqCRPiVboEZCp1V180z/4SxZMR17VYRb61/AJWSQBLi14xRaYgXUOf1YRYXDLO30qjY2JmuYYOlERcAhaiR1gWeCh/NS82TmV+1hvmMX21Pl/L/22bT1FnDOxI3sCJdiN6VZHagj/mEBDcfsosG2B7eYxCumiWgSdkFFHahi3aEUUGXu58N0GdPNXYhAXIeULmEXM/gEhe1pC9VyP7tSZZSIERRdRBEE7APVsWUGF29J6iJ9GTfVsp8+xUWBKU6l7GdFbCxHOnYggmGB3u85PUCODiUR80nT4XAwasZ8wjLXg5P3M+6niRHi8QuE4eyauq7T0tKCoihUVlaSyWQIh8OoqopoyqpsEKBuVC2SSSIQDBCLx5AtMnaHjWgsQiweI5GIEwrVceQR8/n617/Otm3baWxsJJFIUFJSjNPpoq+3l3Qqjt1uZ/369Xi9BTgcDsxmK7NnH4bP5yMYDBEOhzGbLdjtDsLhkGFNzSn+Kioq0HWdHTt2EIvFKCgoIJNR8fl8JBIJmpub2LZtG6FQiOLiEto7unjhhRf529/+zrp161FUldbWdmSLFbPVSlFJCalkiu7uLjRNw2yzIJs8hIKhbGEbHSRRxOlykk4mSAyoMh0OO6IoEA6HiEbDVNdUEQ5FMJnMvPSPV1m5ciWpVApRFKmurjYqWiuKgiiKxGIxbFZbluy02wiHw1itVux2O6FQCE3TcDgcyLJsqD9NJgk1k0GWzaQG3lDlArZ1/eAJiRF8MnycAi7f1pr7PRKJsHv3bkpLSwcRWl+k4zTUTr6/TL6c9Wg4W5UgCIwZM8awXa9cuZJLL73UsF1/4xvfoKSkhGuvvZZ//OMfhMNh7rnnHkaPHk1fXx+33norf/jDH3C5XNx4441873vfM4ja4fbZgRR++es1dJ01TaOrq4tHH32UZcuWkU6nuemmmzjqqKOwWq0fqb59MMvKJ3BLS0u5/fbbSSQSPP/88yxatIhHHnmEuXPnfiqZnvkWsPxg/aEEbG598vdd/rCh2/hZ4OMUmSP490Q+MdDQMJPi4tKBuJGpPP/8c0Sj0QEVf5TOzk5mz57N5s2bEUWBurraAaeCg0mTJvH3v/+dceMncMQRR+xz9giQi90aXvmbtWJPnTodQRRJp1M0NTWxePFrbN+2jYmTJnHrrbfS1taGx+3hveh7H4lnGMEIRrB/BAIBVq1axfXXX/+xkR+CIGA2m5k4cSJjxozha1/7Gs8++yx//etfefHFF7nwwgs544wzOPfcc9m1axfLly/n1Vdf5emnn6ampoZTTz2VI488kvHjx2O32we1TXK2ao/HwwknnMCRRx7J3r17Wb58OS+99JIRzTN79mxOPvlkJk+eTHFx8UB7el9Bjba2Nj788EMuvfRSY/69vb28/PLLnHrqqUbm4wj+c5FPPAKsjY/mzZ7x9MXtTKnq4ISi7RSbwqR1CQ2Rarkfh5AGwCpkkAUNRRdJ6ibSSHQoBWxOVLHWX8OOnZVYO01Y+3VEVce9J4MlkM4W9nBZwFWGFEkhaBoZjw1dEFArvZiTaVBVUFW0eAJCYQSvB31AlLIv01FCT6ezGXw2a5aQVPfRTVpewRktEERMpXB1SNl56zoOJSumENwurFU1RKelISlhb+hnjK+PCluIKrOfLfFK2tIFJFQZtymJzxTDKSWJa2YcYooN8VqefXsuulmnfkIHjbvKkT0pRnn7eaVvKg5TmoQqE0ubWRcfRVuigHJLiBMLtjLT0kqvauOWPWfgT9j58djX2JEsZ4y1m2IxTkw38fOmrxJ4tYJxX93L/4x6nmIxhYLAk4HDeXvXWMZU9NKfslMn9xHSZN6Pj0VFoNoURgQUHR7uO4q/r5qNoyzGt4pWoCJgFRV0XeDI0U2kNBOT3J10pjysXDueSUfu4bqqVwEoFLO1IIK6CaugIguQ0qEl5QMgqcmUSSE8YgqXqBEBkgNFbapNIfZmsoRsrqiNootogmoQdjnFowqENAuioNGbcSMLKoGMnQ/itfQoLhxOxchbzP//r0KOOP08MEI8foEwtOOXsyJ2dfVgNpuNBnwymcBsthCNhvF43PiDQaLxGC6PmwKfh+7uPsxmK5qu4XI5UVUd2SQRjUYJBgIUFRUzf76POXPmGI0ORVF48803cdrtVFRUoOkqsWicpqYmXvrHy6SSac466yxq62pwu92kUiksFothpQJIJpOoqorH46G8vDxPpell/vzD6O3tZs+ePezduxtRFKmoqKSjo5tEIok/EMBkkqmorCQWT2J3uEimFeKJJMFweKATk7VxKGkFh92BzW4nlUwhCAKqnskW3ZFEEukkTpdzYJ8B6IQjEWLRGCaTiW3btrNhwwZCoRACwkAeFbhcLkpKSozCOPF4nAKfF1VTKSsrIxIJE4vFgGwjKhKJEAgEqKyspK+vj3Q6DQhkMioul5PRo0ejKAolpSWoqobJ9K8WOP/7Ip+oGc6+mhsn3w6by+Pr6OgwMktzpNHH2X6GLne45X8W5FG+UnDoegqCYOQMDreOkCXFxo4dy4MPPshll13GypUrWbhwIQ899BATJ07kpJNO4g9/+ANXXXUV7777LldeeSW33norv/nNb3j11VcpKSnhl7/8JWeffbbRodjfPtnf+uePk7Nm5b7nKozfd999bN68mfHjx3PBBRcYisSDzWM8UBYnZKsq/+Y3vyGTyfDyyy9z2WWX8cgjj3D44Yf/08frQPsj/9wY7vw82O0YwQj+WeRIfpvNjtlsQdcFKirKaWiYye7dzTidDtLpbMzL7t27cTidvPPOWwiiyGGzD6Outo5ly97FYrESDoVpbWmloqKCTR9uwufzUV1dYyxDELLPWZ2Be5ae/b29vZ0PN21i586d2GxW5s2dw4TxY9mzdy8ffLCRl156iWlTp1FSWjLgPPh8CPkR7B+/+tWv+Pvf/8727dux2WzMnz+fX//614wfP94YJ5lM8sMf/pCnn356UORKaWmpMU5LSwuLFi3irbfewul08p3vfIdf/epX/1Tm7r8D9vcc+Di3TO63nOJ+/fr1OBwORo8ePWi6RCJBS0sL1dXVg6zJueWazWbGjx/Pddddx1lnncUf/vAHfv3rX7N8+XJ+8pOfMHPmTKZNm8ZFF13Epk2bWLx4MU8//TSPPPIIY8eOZcGCBRx11FGMHj0am81mzD/3Es5sNjNu3DjGjh3Leeedx6ZNm3j11Vd57733ePnllykqKmLixInMnTuXOXPmUFtbi9VqZdWqVRQVFRnbo2kaa9asoa+vj2984xuf6Lz5Z5+v/4n3oS/L9W9G4zjnVo5xbMcuKkbmo4qAGc2wZouCjoROUpcIazaa0yX4M05Wh+rY0VdCMi2jqgLIGqpVJ1EiIKgiqWqBjM2EmOUt0WQwJZ0IGbD3aih2Ac0ExVEvYjKD4rNj3tOLFgyhh8IDikY1W9GafdWr9XQaTdOz6klBNCy86Fo2s08Q0JUMejCUzYEUBQSTCcFqQZkyio6j7TiO6OWYwi46425qnX4iipXtoVKao0WEU1ZkSeWMsk1Um/tJanKWbNzSQMXfzdjb4tS6FVpOlWlsKaF4hYSj28y2aeMZ/9Wd+OQYb/eO4ezaTeyOFzHTvReHmGKGpY0PUpX8rukEfLY4J1bs4Edvnc+ZszdwtnsDAAu3fYvkP0qxf7Wbm+v+gVdMk9RFng4dxh/fOgrNrrKzpZSLZq7AjMZfgnP4MFjBdTWLkYWsym95oo6/r5mN2S9x/QmLkYUM/Rkv66O1tPd5mVTQhceUQNVF3lkzCVtVhEVVb+EYIJYtArRlbNlq3mJWHNSvWVjTW8PcUU30q84skSlk76OyoCGiZ0lPRPpVJzHNkrWjCwplUhgZ1chnzFHFysCtpSftpsQcZpy1k5Z0ESHVRkSxIguDacZDzVzcn9ox1/sbbl5DGYj86t0awDDKys8C/9lP+C84RFEklUoRjUZwOt0kEnHS6WyBGavNis+XZegzejbAPRwOY5bNmC1mgn6/oT5wu50UeAtoampiCXDUUUfh9XopKioCsg+JXbt24Svw0dvTQ01NDePHTzZIxL/97W/86U9/ZsPGjZx44onU14+mpqZqwFptQRBEMpkMHo8Hb0EB8XiccDhMbW0dJSWlKEqG91eswGG3IQgCbreHTEZFVbPWDJfLhWyxEAmHScRTmAZIViWdJpFIIIgiJklCSafwut2kUklisRjSAMHidrsxW2QS8SjBgB9JFBk3dixOpwNFSSFKEh63B1XTadm7m9dee51djY1ZtaSm4fG4mThxoqForK2tpbuni96uHjRdwWq1omkaVquNVCqNpqn4/X7KysrxegsMq1h7ezsOhxNZNpPJZEin02QyCkVFRYiikFWpDsmSG8Fnh3wyK18tYzKZjMY5YNjlc8TjF+34DCWncuTmUFtvjpQczrqbPy9JkhgzZgwPP/wwixYtYvny5SxcuJBHH32U8ePHM2vWLB5//HEuvvhili9fzjnnnEMgEGD06NHcfffdHHPMMYOUCIdqTx5uewAURWHt2rU8/PDDLF26lMmTJ/P//X//H2PHjsVkMhkdlwN1ug6G9Mx9Lisr43e/+x2qqvLqq6+yaNEiHnvsMWbOnPmx+/HjlpH7rw68sc63oeWGD6d0HMEIPg/k7h/AgG0R0uk0q1atZvv27cybNxen00FJSRnt7W243W4cTgduj5d5c+cSDIVobGyipKQUi8WKZyAbF0Ewch+HfQnDvnNezWRIJZNMmjSJsWPH8sEHG6mqqiatpNnVuIvmxiZqamqIx+NUVlaye/duxo0b94W7P/+n4Z133uGKK67gsMMOI5PJcMMNN3DyySezdetWHA4HANdeey0vv/wyf/3rX/F4PFx55ZWcc845LF++HMjeF08//XTKysp4//336ezs5MILL0SWZX75y1/+KzfvC4uDJd1z/YYXX3yR4447zmjv5F5Ibtq0iSuuuILx48dz5JFHcvzxx1NZWYnNZkNRFKPIn9lsZsKECfzsZz9jzpw5/Pa3v+Waa67htttuY/r06bhcLo444gjmzp3L5ZdfzpYtW3jxxRd54oknePDBB40XmUcccQQ1NTWYzWbjJWPu+ep0Opk/fz6HH344/f39rF27lqVLl7J69WrefvttrFYrlZWVTJgwgcbGRo4++mjsdrvxkvWVV15hxowZBhn5eezzoS+Z/9PuR1/k6z9HKEI2+9GMhpqX/SihG4RPUpdoVQrZlKhmV7SE3WEfoqATTljx2LKFY+yWNF57glJ7hGRGZvrsNmRBJZSxMcHWiYpIS6qQ7ZFS4hkzLYECBEGnJ25Bjchg1vDPy5L7Fkcak8lDKllEJmzG3C8hpgWkFEgJ8G1PY9sdQEil0fxBSCT2bZggoqsgSEKWkBQFQEI0Z1WSYnkpyVFFhEabmXr6dr5d+j7NqVL6bE4Cip20lMFuSmMSNQrdMVa21vG0MosjS5t5qXkyvj86Gb9sF3oyRXrOBPZ+R0NTMogBmaKVveAPoc0cy+6gj91BH8GQg66Uh5RmoiVVyCzHbv636yTeWjOZ4w7bwmRnBw9sOhprp8xcZxO9mp2L3v0eJUvMRE5N8IuxL1MsJZDQeSE6jT+8fwSiDoJF5cbDX2G+rZlXo1NY1lXPf9WuptYURtFhl1LILW+ci7NF4pQLVlAv9xDWrGyI17LJX8nUqnZ2hYtpkQrYuqUGe2WUSSVddCleJsl9yAN5if2ag9Emv5GduDFZi1lS8UlRRpt7BkhKMAtZolpER9EhqFnxSlnxUUS1UixFcInKoKIysC+D0Spk6Ex5mOXYw7ZkBYousaJnFBMLugx1blwXsArZKtY51aM6pDugZg0iw2Yz5tSSB1JM5k+XC7BQ8n7LVe/W2EeYfpY4ZOJx2bJl3Hnnnaxbt47Ozk6ee+45zjrrLGP4RRddxFNPPTVomgULFrB48WLju9/v56qrruIf//iHUYji7rvvxul0fvIt+TeEruuEw2G8XjdWa7Ygy+bN/aTTCoqSxulwommQTGZQ0gqy2UxQDSELJnzuAqKxGLFwFLfDiQQIus7KlSvZtnUrh8+Zw/jx4/F4PPT397Nz505UVSUaj2G124kPhMGbLRZKyspIpVJ8sGkT27dvZ9z4cUyZMoVgMMiUKZOZPHnyQCGIGD5ftuKz3W6npaWF999bTr/fDzpccMEF6LpOPJYmGAoSDodoamwmkUzidLhxOzw0N+8mHAhTVGKhpNBHR2cnyUQCd1ERWsqKpqSRRRFF1UgkUqBDPBLF560CNUME8Ho9jKqvQzRJoEq4PQX4+wN0dfXT1e0nHImhZFQQBMSBqmImWcRmN7OrcQcTJkzghBOO5emn/0hPTydFRaWEQzGcTie6phMOR1m7di1j6sdy3HHHkRhQoJaVldLU1Mi4cRPp6elDG8jm6O/ro76+DlEUEISczWxE/fh5QFGUQRmJ+Z3hoXlEw2Umwv4rLh9ovM9DmZNTb+a2b39viodT4ImiSH19PQ899BALFy5kxYoVRubjxIkTmTBhAg899BAXX3wx27ZtY+rUqdx3333MnDnzI/tt6LwPFZlMBkVRWLduHXfffTc7duzg7LPPZtGiRdTX1w8iHT8t5Dph+eTjkiVLuOyyy3jssceYOnXqP535CAwih/Pt5F+UzsrBELYj+PdEzumwZcsWSkvLaWlpwePx4HA46O3tY8KECaxZsxqXy4XDYaOsrIxvfuNb6LpOLBYjHo+jqirlmYxR0V7XdSorqwDQdY1UKkUqmSKRSJBKp9F1nYKCArq6uox7ciKRGMisrqKwsBCP10symeJN81KaG5sQBIF0Os327ds54YQTkOXPyxA0guGQ35YHePLJJykpKWHdunUcffTRhEIhHn/8cf785z9z/PHHA/DEE08wceJEVq5cydy5c3n99dfZunUrb7zxBqWlpcyYMYOf//zn/PjHP+aWW24ZVDn5Pw37exF1oBd9Q783Njaya9cubrjhhkEZx5qmsXbtWqLRKKtXr2bt2rU8+uijNDQ0cNpppzFv3rxBRWMkScJut3PmmWdSV1fH9ddfz3XXXce9995rvAQQRZGysjLKy8s59thj6ezs5N133+Wll17ivvvu48EHH2Tq1Kkcf/zxzJ8/n6qqKoPczMFkMlFSUsKCBQs46aST6OjoYPPmzbz33nts2LCBpUuXUlVVxVe+8hXjvtHd3c2aNWu47rrrPjK/Q0H+/sx/IT3ccRguxuY/DV+063+ovTofoqAbxUwkBh/LoGpHRWCitYPDHU14y+OG3XpokZp8dZqii8b8ZEHjWPsuIh6ZpG7CNSqNjEZKlwylnIKIoovGPHLrkVXVqai6gIJIV8bF1lQljfFSFu+aiPdNGyXPbs2qG9MKotUyYMsecMtYLWixBILFgm410/x1iR8c9QrrIzXc33o8XREXZa4IACZRY2+ggBJXlPaoBzUjEnynjDVrCqjduActEkU3m1Gnj2HPV2TKinvo8bsp2CSj7WlFGDuK+NgUc4s72Hr3FPRT0xSbIyxrH82K3RP4qzgX3ZnhB8cvxiIq3LHhZNSEiUnHNVNsCnPpHxdRsUkj9K0wt056jUophKKLPBuewZNb5uLYayI2PsX1hy9mrm0361PVPLZ9PuOKeznFsQ0FgY6Mi2vWf52SFQKTr9rEWd51hDUrb0cm8kbHeCRRY8P2OkwBE+agQMlRPUwvaqfYHOUw2x6DDAxqJhxCGqugIQ2QeZouMLWgg2pTiLhuIqlLeFBJ61k1rFnQBohEhQ61AKugoIrZDFEfaZSBvMVcr974L+hMcHRRKEWJqFb2xn1EU2YK5RgOIVvcxp4jyvl4VuDjxslZ0SUha5vOkYtDCUmJf621+5CJx1gsxvTp0/ne977HOeecM+w4p5xyCk888YTxfehD4Vvf+hadnZ0sWbIERVH47ne/y6WXXsqf//znQ12df2tomkZ/fx8dHe2YTGbMZjMVFRUkEnE8Hjf9/QF0AQJ+PxaLFZNJJqNkkAQRk1kiFAySSiRIJhJknE58Ph+KouDv72fp0qWsX78em81GYWEhqqoSi8UIhUJGsRRBELA7HFRXV7Nr1y6sViuZTAZd12lqaqKxsZHdu3ezfPn76LrOuHHjaGtrMzokHR0dRCNRRo8axZFHHklFRQWtrW0EAkHKykuN6tqbNm8mHk+gqtkCLMlkkng0hs1iRRYl+iNRrGYLwkCHx+v1YvaY6c8EUJQMhT4fsUgEAYGMmqGyspLS0hJisTiiKJBIpDCZzKxcuYa9e1vQ9Wy2VXogg9FstpDJKOh6lsjZuXMHhYVexo0fBzq0tHQSiyapqxtFYaGPTR9+gJLOEAqF6e7uwePxIMsSDocDURSJRiPIssmo6hkKBw3S8T/xDennif1lCOarH4eq2XINydy5PVw2YO7zcDiQAu+zwlD79KFWTM8pH3Pk49CCM+PHj2fq1Kk88sgjLF68mPPPP5/6+nqjo/FpbkMqleK1117jt7/9LZIkccwxx3D99ddTWFhoNEA/7esm/9hXVlZy7733csUVV7B06VJjH0ybNm1QdfNPsoz882x/atoR0m8EnzcEIavAf+GFF7Da7JhkmdLSUsaOG0dhYSFjxo6lra2Nzs5O3nvvPVKpFJOnTOX000+ntLQMp9NpqFty8xt6jba3d/DGG0vYtXMnqVSaktJS6uvrmTp1Kl6vl61bt3LY7Nk0NzdTVVVFcXExVls2U7m2tjb7cjMQIBqN0tTUhNvtZuvWrUyfPn3Y+/wI/jUIhUIAhgNn3bp1KIrCiSeeaIwzYcIEampqWLFiBXPnzmXFihVMnTp1kPVywYIFLFq0iC1bttDQ0PD5bsQXCPnntqqqxl/uRWPu2Z37yxFx+dO8+OKLzJw5k8LCwkGEZSQSYf369dx99910dHSwbt06g+B75513qK2t5bzzzuO8886joKBg0DOsoaGB3/72t/zgBz/gtttu4/bbb6e8vNxQMeq6jizL1NTU8M1vfpMzzjiDHTt28Morr/Dmm2/yy1/+EpfLxdSpU1mwYAFz586lsrLScE8IgmAQnjU1NVRXV7NgwQLi8Ti7d+/GbrczZswYIHu9f/DBB6iqyty5cwcpOg8VmqaRTCaJRqP09vbS09NDOp02nDJmc7bvVVhYSHFxMQ6HA4fD8YV6gfivxL/6+pcG8oL3h3xiMkf6SehUmsKU6FHSiGi6iCxkhSIyGoqQJQtz5KKIjoaQrcqMADpYBJWULhkEolVQjfEsgookZO3bEjpS3rAcGSkP0D7aAIlZbQpRbQpxrH0Hi4rf5qWp03hkygmIKYGMSwWbCgkJW4eJ8vdTKC6JRKGEKaHTdYzGsTO2sbRvAomMTKE1hq8oTlvUiyDoTPe1U2qN8MaHE6l9TmDslm603kbQdbR01isuCAK9Mxz4xvXRG3Qib7VT/FozmslEstJJcUmIt1dOoQSw2tM89fbRVL2pYSkUOOKKNRzv3sredDG3rzkFwjJjJnbwq9rnOOO9y6l/LUHrNSqXj1vOVEs7u9Il3LvneDpXlWPrE1CPCfHY9KcpHMiBvLvxeGyWNP9dnc1l7FIdfPf1SyhdLqJc4Gdh6Vt0ZTw82zebD3sqmFzcxeq9taCDlBRwHdVDncdPRpM40bXFOA9kdPyqnQpTlpDNkW8LHDs4xr4Lh6jRmzHjFlIDxwYimpkgAhVSHE0XSeoySV3GKijGOLKQrWKdHLgPi0BEkymVFKrMfroyHlxSknDaituaotISwDKgqEzr+gEzHnOW6uGKyQy1VYv54w+9DvR9FbL/1Thk4vHUU0/l1FNPPeA4FouFsrKyYYdt27aNxYsXs2bNGmbPng3Avffey2mnncZdd91FRUXFoa7SvxXyG++JRIJQKEQikSQW8xv5bZqmYTKZEEWRnt5eSkpKCAbDaJpGRUUFkUgEv9+PpmmUlZUZxK/T6SQQCOAtKCAWi5FMJIyHbK44TDAQYMP69Zx2+umEQiF0XWfSpEn09/fT1NSE3W4nkUjS0NBAWVkZ7e3txONxIpEIiqJQXV3NjBkz6OzsZPLkydRU11BbU4PH4yGTyTBq1Cg0TSWRjOPzFbJyxeqs0lWXaGxsQpIkrFYr6XSa7u5uY3vD4TAeTzaDsb+/H7PZgs1mRdMSBkmqaQroOieffBImk4xJzjbIJEmiq7+LQCBAT08PXV1dqKpKJpPBYjZTWOijra2N/v5+Cgt9A0TrdqxWKx6PF5fLx8YNm4nHYzgcdmbOnEk08h67du2itLSUww47jEgkjNlswuVyZQvUpBU0TSMSibBr1y5OPPE4RDGXzwcj7ZVPF0MJRthnJ8ydA8ORjoDRiIzH44YlVlVV47rINYwPREAOtfF+mhi6TUMrWw+1Mw5H0g0lU3PIKR8ffvhhFi5cOCjzccKECTQ0NNDQ0PAR0mx/88v/LX/dhk6b+4tEIrzwwgs88sgjeDwe5s+fz6JFiwap3z8rsi6fLMmRj5dddhlvv/02l19+OY8++igTJkw4oMU7fz75GM4CP9xyP24/ftz6HwwOtK9GSM//TKiqyuLFi/H7/Zz7tfNYu3Ydo0aPpqjIh89XAAjs3r2bcDhMJpOhoqKCqqoqIzrg41RXuq7jdDmYPHkiHrcLWZY55pjjaGltJRgMUlFRwWGHHYbT6WT6jBnompbNgxsgH8aMGYuiKPT29LLi/fdJJBLMnj2bZ555hokTJxqZ1yP410LTNK655hqOOOIIpkyZAkBXVxdmsxmv1zto3NLSUqM6eVdX1yDSITc8N2w4pFIpo2AfZKOFvgwY7h6bT5TlPyPj8Tjd3d00NjbS1NTE3r172bt3L7FYzIgGkiQJs9mM1WplzJgx1NbWUlNTQ319PaWlpUQiEd555x1uueUW4zmbe9Gwa9cuAI488kjsdjvf/va3CYfDrF+/nmXLlrFkyRLuuusu3n33XX784x8zadIkw3Gg6zoTJ07k9ttv5+qrr+bee+/lpptuMorJDL0nOJ1OZs+ezaxZs4wXm6+//jrLly/nnXfeoaSkhBkzZnDKKacwc+ZMSktLMZvNxv7IuTgkSTIcCDmk02lee+01GhoaKC4uNmKM9re/8/e5ruskk0mam5vZuHEjq1evprGxEb/fbxSNzG835l5I2+12XC4XxcXFTJ06ldmzZzNjxgwqKiqMl9f57pp8pWnu+P674Ytw/asIRn7jUFUjZEnGocNy00DWno2gGYVltAGicmgGH4CqCwNEok5Kl4z558hEwCAYNV3Ikph5GrWcbTcHRR88jYpgWMVPdX3I2WdvJKlLg8bflS6l9QIffYoLq6jwft9opK4iTvVt4qX+6fQmHPREnSTX+0hWKpiCJmJbKvA2Jpj44U60eBwVEAZ4AV3TEWQTVJWRcUBiXRHeZp3iZe1ooTDKnAlEamRCHxZRulFHjmrI77kp2aXQcZSJi057k+n2vSi6id+9fiq6J8PpczZyoncLF374HWr+T2L3mTI3Tv0bkyztvBqZykPvHYe91YQ1BkVfbeNX9X8bqDQt8+PGr9Hb5eHBY/6PYilBUDPznbcvoep1gfB3Qvx+yh/Zni7n3qbj6GkupLAuwKo9dThW2HF0qSSKdHp63XitCWx2haQu4xKyhXci2r5jBnkKQgEcgoZMVglbKGdt7jLQpXoAKJPiBDU7sqDSm3Hhk6IoA8SzHZ20rhuKQ1kAu5ihVbWwN1XEHEcjrYqPzrCbUQX9TLa0o8GAonKfNds4Z4WP2q3zkTuj8jMlc8gpHZVhiMr8aYdWs85f9meNzyTj8e2336akpISCggKOP/54fvGLXxgVx1asWIHX6zVIR4ATTzwRURRZtWoVZ5999kfm92VtcHwS5HdKZVnGbncwatQoUqk0a9aswWq1UlRUhN1ux+lMEdyxi+LiUjweN5lMVrXY39+Pw+GguLiYnp4eqquriUQiqKqK1WolmUzidruNB31/fz/RaNQgXtatX8+JJ51ESUkJO3bsIJVKUVdXZ5CZ0WiU3bt3M3nyZEaPHs3u3bvp7u7OvkFdu5YzzzqL0047DYvFQnFRETZrNmB6165dfPDBpizxmIgzafIk5s2bx3MvvIBJsuD1ekkmk9jtdsLhMLIsk0wm0TSNeDyOIOg4HI6BqtJhEokkHk8BHo+HYDCrjLDabEyaNJmCggIam3bi8/lwOOx0dXXT3t5OMpk0iCZ9gBwoLi5m9OjR6LpOR0cHFRWVVFVV0bx7F50dHdjtHiZNmkRzczNut4u0Ak6ng6KiIvr7++ns7KS0rIj+/l5KS0tJpzO0t3eRSCTo6+vDZrMhSSYEYR9pNILPBlkCel8BmfxGd04hkD+uruu4XC4kSTKuEZPJRH9/Pz/60Y8YM2aMYeX5Vx+33DbtTzmXT3YNxYHyiPLJx/zMx5zt+p9ROA5HgOa2IxQKcffdd/POO+9QWFjI+eefzxlnnIHNZhtErO5vmz4t5DoKNTU13H///SxcuJDly5ezaNEiHn74YcaNG3dIgee58y53ruV3iPJJY/jPzYkawb8GuetpzZo1rFmzhu9973uIokRtbS3/939/YPZhs5g//whkk5l4LMa2bdsBHZPJxJbNm3G53JSVlR+wCJcOqJpOMBgkEU9gsVhQFIVNmzbR0DCTzVs209/fT3V1NTBw3xKy+Y/5iq76+jFoqsr8efP429/+xo4dO9B1nTVr1jB//nzg37Mz/2XCFVdcYSjmPmv86le/4tZbb/3Ml/N5IKdgBIhGo2zdupXly5ezfPly9u7dSzgcJp1OG0RcjmhMpVKYTCajP7Rs2TJD9ejz+SgtLaWqqgpZlpk4ceKg55au6zz33HPMmjXLKPpiMpkoKCjguOOO49hjj+WSSy7h2Wef5U9/+hNXXnklP//5zznqqKOMNoeu60ydOpWf/OQn/OQnP2HSpEl84xvf+Mj2DX3ZVlpayle+8hVOPvlk2tvbefvtt3njjTd49913ee2116iqqmLChAlMnz6dmTNnUl9fT1FREZlMBlmWB1mgIdsH3LZtG9XV1ShKNof9QJE3uSKYbW1tvPXWWyxevJjm5mai0ajhGFFV1SDMzGYziqJgs9lIJrOZ8oqi0NvbS29vL1u3buXpp582+rInnXQSRx99ND6fb1A7bCjB/O92v/qiXP+5ojFDicccIanpIgiDC8rkCL4cciTgUOt2bt65z7lliHnZkVre8KHzkNEMpWOOYByOIB26TAndIDpzxKZVUKmQA6yM1tMcLaIt5EF42YdXhet7voEpLmDrEhAVnfLGFJauGGJ/ELXPD7qGOlDIRpAktEQS0WpB8rjRa8tpPdFLbGoSS5OV4rfb0GUTyuET6J5lJVGq49orIGY0pLSGu0Wl63CZX5zzJ7xinI5MAbe+eRY2v4hYm+CtljG8snIGJasEur8f5c7pT6PqIv/bsYD1746nZAski+Dwb37ANaVvYBVUkrrEoq3fom+Pj1+c+Cxj5X7aVScXvbyQMc+mUW7s49Gxf2VLqoLbPjgNbbcDU22cwHYf1UsySOkkmiyiyQJ6wsRkTyfzXY3UmgIoCKi6QEw3USpFDWWgqmeJO6sAST1L2MU1C3ZBzWYdCqDqIsWmLOdkFRRUPXs+FZqiA8dXRyE7L6swMA89q3jcmqpkun0vEjrrQrUkUjL1zj58UtxQOA7NdMxZto3cyCGnylCycSg9vr/iMEMJRUXfR7p+3vjUicdTTjmFc845h1GjRtHU1MQNN9zAqaeeyooVK7LKs64uSkpKBq+EyYTP59vvm45/pwZHDgdSmuRb87JqPvB6vRQWFtLV1UVBQQG6rmO1ZgvMdHd3DxQwEY03on19fbjdbjKZDF6vN6tAGLBHdXd3G28pc1bDvr4+kskktgHSb8mSJZx99tm43W7SA9lMJSUltLW1YTabSSQSRsOorq6OqqoqGhoaWLJkCX/729/44IMPGDt2LFMmT0YSJbq7u9m1axdOp4tAIMCEiePQdY3CgQI3iqJQXFxgBGOLomjYvh0OB/F4nHQ6jSRJFBQUoCgZBEEyCCWz2YIoSlRUliNJ2YaELMtEo1HWrl3Prl27CAaDxONx4vG4YQvRNY20ohgqt4aGBnp6uqmqKkcUJZxOJ/7+IMXF5ZSUlBCNxnC5HYYdvaenh7a2NnyFHmRZprCwkGQyjccTMEjanG0jlyc5gs8O+Wo6GNz4y38rDdlsQUmSKCwsxGKx0NfXl1XBDnxevHixoQqora015pf//7PcjqHfD0Q6Dp3mQKrM4ZR2giAwevRoHnroIS699NKPZD4OJR8P1s49dL1yx6a9vZ2nnnqKV199lcrKSr75zW9y+umnf6TAz8Fs9/6W/XFqvuH2V11dHffdd59R8fuyyy7j0UcfZezYsYNI6/xORL7SNNfpyLdoH6p1/2C3459VTY6oHf9zYJyjwN49e/jzX/7CV07/Cn6/Hx2RZDJBUXEhbyxZwqYPPuDii7+PP+DHarUybtw4Q/E4dtz4jz0nIfuip6+vj7b2dvz9/ZjNZiwWG7sadzF58iTa2trp7u6mrKwMTRhQXaAj5K2r1WplytRpCOh0dnayatVqjj/+eP7yl6eZPXs2Fovln7JYjuCfw5VXXslLL73EsmXLqKqqMn4vKysjnU4TDAYHqZ5yxzs3zurVqwfNr7u72xg2HK6//np+8IMfGN/D4bBBXn9ZkK/m6+jo4LXXXuOFF16gubmZcDiM0+mkrq6OKVOmMHPmTOx2O3a7ncLCQhRFoaSkxGirm81mWlpaSCQS7Nmzh507dxIKhdiwYQM33HADbrcb2PdMaGlpYdWqVdx7770fUQfmvldVVXH55Zdz2GGHcf3113PzzTfz29/+loaGhkEvzE444QS+/e1vc9999zFp0iQaGho+ovAbipyYoq6ujosvvpizzjqL1tZW3n77bd566y3effddli5dis1mw+fzMW/ePM4++2waGhoGVd+GbJ9RlmVWr17NXXfdxX//938bfZqh8Pv9vPfeezz//PNs2LCBVCpFJpPBbrcb/Zbq6momTJiAxWKhrq4Or9fL9u3bqa+vp6Ojg+bmZjweD2+++SZOp5MVK1bQ0dFBJBJh6dKlvPHGG9TX13PuuedyyimnUF5e/pEInH83fFGv//x8xhyB91naS3P5jTll5VDiUvsUmJ2calJFoFiMc5FvORe2XoS6qoC619vRJZHSxWk0fwDBLKMnsy8mBKsFNRrLPl8lCWGgCauralblOKaGtM9O89lmKEhi3WGl7vl+0nVF9E22kSgFWw8UbgJne4pkoQk0HVtXklLFwu1d30Q4rZ/EqiLGvhmjZ5YJ4Q0PlrBGZoJAyiuQSsr8bveJtHT6sO6yIqtgv7CdS6tWUSkHAOhS7Vy4/GKkViu/PPdpplo6iGgyF726kPGPR9hzppdRcjeP9x7N6x9MQXamGT93D9vayqh7RcHSHQUlA7IJ1eJBsGUYa+tmgrkbq6ChIJDSJcxoOMSBzHV9H/nYoZrpVx0USjHCms0gELtVM9uSFRQ6oiR1iZ3pMtxiAqeUZLTJT69mN+alkSUvcwVscrAKCu9EJ9AVy96PndI+G/cnyVnMLwqT65EMZ8P+OGTPUz1rT/+cqYlPnXi84IILjM9Tp05l2rRp1NfX8/bbb3PCCSd8onn+OzQ4Pg45JUyuM5nJZOjp6cHv70fXNcNObDabCYWCOJ3ZSpR2mw2LxUI6rSCKIn5/trPQ3d1NOp1GEAQsFguyLON0Og0rc06xUFBQQEFBVjWYTCbp7u5GkiTeffddSktLmTVrFjt27DDs3bFYjPRAtemmpiZmzJiBIAg4HA48Hg8XXHABr7/+OsuWLWPt2rU4HQ7MshmPx4Pb7cblcnPCCcczbdpUmpub2Lunhfr6elLJDL29fZhMJtxuN4qiGG8pvV4vxcXFdHd3omkawWAQq9WGyWQmFovT29ubbYiYZSZPnozb7SaRSGC1Wmlubmb1qlVEIjHKyyuIRqN0dXURDocRyJL9dpuNiooKTCYTHR0dOJ0u9ra0EI/HkSQJi9VCKpWtJh6LRYl3R1GUjPH2OR6P09PTg9frRtd1fD4fFnMbNpsNl8tlEFyqqozkwnxGyFfSDVWVybL8keIkOVVNrnK71WolEAgQiURwOBzGNdHW1saqVauoqan53I9bPrk1dJuGQ85Onm+v+jjkk2eSJDFq1Cgj8zGffMxZjj8psZVbH03T2L17Nz/72c/o6upCURSuvfZa5s6diyzLH2mo516mfBLy8ZNAEATGjh3Lgw8+yPe//31Wr17NwoULeeSRRxg7duxHjsFwBORw65lPNubu85+UNMmf1wh5OIKDQe48icVj/O6euznhhBPwegvweHzs2rmTpuZmPC43GSXD6FGj0VSN8877OqNGjaatrY1YPAGCiN1uH3a++d8FAdSMQm9PH52d3fT39yOIYHc6qB9bj6pqA7nIMq+88grHn3ACJimrAdGGmV8mk2HuvCPo6uohmUwZ7pijjz565Fn6L4Cu61x11VU899xzvP3224waNWrQ8FmzZiHLMkuXLuXcc88FYMeOHbS0tDBv3jwA5s2bx2233UZPT48hRFiyZAlut5tJkyYNu1yLxfJPFRH5PHGg+7Lf7+ePf/yjQTgWFBQwY8YMTjvtNCorK5kxYwatra24XC5sNhsffPABM2bMoL+/n9raWlRVZc+ePUycOJG+vj4jh3DlypVYrVb++7//m5NPPhkY/IxYsmQJFRUV1NXVGesynOJelmVmzZrFXXfdxU9+8hNuvPFG7rvvPkaNGjVIyfj973+fDz74gDvvvJN7773XcLUN3QdDo10g255xuVxMnjyZSZMmceGFF9LU1MTbb7/NO++8Q2dnJ3//+9955ZVX+PnPf85ZZ501aD4ul4sf//jH3HHHHSxevBibzcY111xjOFN0PVu0avHixfz+97+nubmZTCaD0+lk3rx5zJs3j7lz5wIwZswYWltb8fl8CILA9u3bqa2tpbKykvb2dmpra2lubqahoYHu7m6OPvpozjzzTDo7OwkGgzz66KP4/X6ampq48847efHFF7ngggs444wzcLlcH9knn5eT47PCF+36zyf2REE3shlFIUuqZO3Ln0+y3XBKxpzK8Z+db34xGlnQuGfq/+PvVbNYMnMCaqOTgq0gJ6rQBbAEMpgDSVB1pK5+9HgCSgrJlHowbdmNFksgFRWSdlvZfYnOkfVb2fr7yZS81Ul4egntp6o4fCHSUQty1IqjS6PjSAulaxRs2zrRnXZ0WaRsaT8s0SDSiGCzUmSRMLcFEVQNT6MbXRQofysJikTNWIneaaCL0LKlnNvXn039YS0cWdTE4+8fTeFaCdf5HTzaehR7ugqpKfVTulyg60gvikuj5bU6ukK12AsEpMOj7Fk8ivp3YshtvejxOILNBqqKzSZTURrnKHsjVkFFEiCuZe87HlExlH450rFXs7AxWYtXiuFXnUhohoJxY7IGj5TAKigouohDTCEKGuPMXaR0CSXPBi8L+whIvyrzfnwscc1MsSnMjmgp3SEXtYUBFF3Ky/ccHvv7PZ8slYT9qxsPBjK6QTh+3oVmPhOrdT5Gjx5NUVERjY2NnHDCCZSVldHT0zNonEwmg9/v3++bji9Tg+NgMbTTmB8QnfsfCoVIJpNIkkgkEsobDrFYnGAwSFNzM+XlFWQymtGxz1kG4vH4/8/eeYfHUd7b/zOzO9uLpFVZ9eIi925s44DBGEMCCT2XhEBCEkIxhEACaYRLKCmEmwIYU5Jw4ebHpd8AAVMNxsYN9yoX9V63952Z3x+rGday3MCEFJ3n2Ufa3ek75X3Pe77n4Ha7iUQilJaWkkgkqKmpoaOjg2QyyZgxY4DMCJMkSUyePJl4PE5PTw+qqlJXV8e0adMoKCggEAhQWFjIli1bCAYCeDx5hMNhgsGg/rslEgmcTieLFy9m5syZbNiwgc6ODlAhHo9TXFzMwoVnUFs7ltbWFtrb23G5XBQXF7NrZx2JRAKz2Ywsy7hcLvLz82ltbcVgMJBKpTCZTFitVpLJZKaU+kADBoNxsEFhBxUmTZpEMpkiEglTWJTPO++8Q1t7O8XeEkpLS2lubsbhcBAKBnUVaM1gcm6m5FZi7NgxtLQ04vP14nbl4HIKdHb0YjabSCaTRGNhvRHT29tLZWUlbrebQCBAOp1CEPrJ83iw2+2EQiGCgSCpVApR/OdsaPwjI1vdKMvyIQ27bBLocEo/l8ulq4l9Ph9erxen00lJSQmNjY289NJLXHDBBZ9J0ma2V9DR1JbZ/kIaUXms4Sja91rgzLJly7j22mtZu3Yt1157LY8++ihjx449bvIv+54myzJbtmxh6dKl1NfXc9ppp3HZZZcxduzYQ0jHoY1zbf6hpfJD1/NJkH18a2trWbZsGd/5zndYt24d1113HY888gjV1dWHkIXZSscjpW8PR0bKsvx3U9GO4N8XWtvg3XffpbS0lNw8Dy63m46OdvbU1TFlymQaG+qpqqrKPDPbOrjsa19j/vz5eilndnn10EGF7L89PT0cOLCfaDRKYWEhOTk5CAKMqx2Hqqo8++yzTJgwgVmzZnHaaadhGBxcGLqcpqYm8vPz6ezspKamhiKvl02bNjFv3jyeeeYZ5syZc4gSagSfPpYsWcJTTz3FSy+9hNPp1CuV3G43VqsVt9vNt771LW6++Wby8vJwuVzccMMNB5E9ixcvZsKECVx++eXce++9dHV1cdttt7FkyZJ/ubY+ZIi2ZDLJmjVr+MMf/kBdXR05OTlceOGFfP3rXyeZTDJ+/Hja29vp6+ujurqa5cuXM2rUKL1a56STTmL//v2MHj2aUChEW1sbXq+XzZs3M378eBRF4c0332T27NlUVFQctG6/389rr73GwMAAL730EmeffTYWiwWDwYDRaDzoeg4Gg/j9fiZPnswvfvELbrnlFn71q1/xi1/8goKCAiDTrnI6ndxyyy1cf/31PProo3z/+9/HarUedB1n92uyn2+aiEJDbm4us2fPZsaMGXz7299mYGCAuro6nn76afr7+2lsbMTr9WKz2fQBuwULFmCxWLjzzjt55ZVXKC8v55JLLsFgyFRY3Xvvvbz11lu6wOKCCy5AEASuvPJKXVSQTCbZvXs3ZWVl7N+/Xy9D37dvH2PGjOG9995jYGCASCRCS0sLp5xyCu+88w7nnXce+/fv54tf/CLRaJTq6mpef/111q9fz/79+7nnnnt47733uPHGGxk3bpw+0K0dl39m/KNd/yIqKdWIOOjRqJc7Dyofs8lAvTRaFQ4ptc6e5nDfHbLuwXJrrUxb+yx7vRrpOJR8zH6v/Z+9reIQElMrvQawCDJFhjDX5q/k2vyVpGaLRBUJUVBQVJEu2c2GcA0vN04mubcGVQQpLFCyKo7gdCJUFBMpc9JxihHUOK0/r6WwuY/eU730z1AQjCoGUWFSZQeNO2sIVhlQTCqmQJJUZQH+sTZSDoE8g4jki2NIpVGNBoS0SmhyAYa4QsphIG0WkKIWkg6RvJ1BKg8MKjHjCWJjComsL+MNtYz8XBExDalHvESKDOSkVXoWO1DGiqgCGGICBVtTKEYB1WDE+r9u3Hv9iMEoij+AaLehxuMoVcU0nu/k8pKNWUFAmYAgjYTUWugSEEdgf9LLKFM3TckCdkTLONO9ExHoVUzsiJYx29GIRUjTP6huHCX1YkClS3aRI0YzpdJZytrmlIugYkES0hRLESRktneXkOi28fkJqyiXBrBkEeFH8nIcDkOn18hOach02aE02e/hUJLx7x0486nrwLXQjuLiYiAz0uH3+9m0aZM+zYoVK1AUhTlz5nzam/MPD61Tm0qlSCaTWK024vE4/f39+kPcbDYRiYSx2+3kuN10dXVhNGYeohr54nQ6cbvdupdMNBrVzZoXLFhAcXEx5eXl1NbWYrPZkGU548lYUIAoipjNZurq6lixYgVOp5OysjLcbjc1NTVEBhV+LS0t9PT00NnZqfvohcNhrFYrlZWVfO1rX+NHP/wR3/72t7nyyiv50pe+REVFBX6/n3giTiQapbW1VSdINDWFy+UiLy9Pb7j4/X4CAT/pdJpUKoXZnFEgaiXfkElbFw0iBQUFqKpCKpXizTffZPPmzdhttkGvGCP5+fm4XC6d0Ekmk8SiMUpLy3A6nQSDQaLRGIWFhXi9xchKxvNv3LhaEomkbvAtCAKJRAJFUfD5BjAajdhsNoxGI6FQiHQ6s53FxcVIJmlwH49PMTaCY4OmitF+F+1vdupjNoaOwDscDioqKkgmkzQ3N6OqKlarlfHjxyMIAu+//z6NjY2f+j4MLRPXiKnsbT5WFaOmTtQIseGWf7h5BUFg9OjRLFu2jHnz5rFx40auueYaXfmcvbyjQSMUUqkU77//Pj//+c/ZvHkzXq+Xq6++mvHjxyNJHz0yh1N1Zv+W2sDK0H06Uci2uRg/fjyPPPII06ZNY/Xq1Vx77bX6+TH0d9LmOZ71fNxSrKOdA8f6Wx/vtCP450YymeSD1R8wdsw4SopLMIgidXV1TJw4kTFjxjJq9Bhqa2v5whfO4dRTT8XtdunlzNprKLTzJjt91263U1ZWzrhxtcyYMYOFC0/n/PMvYMqUaYweNZpvfvObzJs3D4PBcJB/m/b81JZTVlamh7MFAgFmzZqFrCgYBqfZsmXLIdfgCD59LFu2jEAgwGmnnUZxcbH+euaZZ/Rpfve733Huuedy0UUXceqpp+L1ennxxRf17w0GA3/7298wGAzMmzePr33ta1xxxRXceeedn8UufeoIBoP84Q9/4Ac/+AH19fUsWrSI++67j6uuugoAj8fDqlWrKC4uZs+ePUiSxJgxY6irq2P06NG0tLTgdrvp7+/H5/NRU1PD6tWrURSF3Nxc6urqKCkp4Y033uALX/gCFovloDbDmjVr2L9/Pz09Pdx5553ccccd9PT06M/SbCSTSRobG9mzZw+TJk3i5z//OVu3bmXZsmV65ZX2/JowYQLXX389zz//PO+9994hYgoN2jyHe2nTGgwGcnJyqKysZP78+bjdbmbOnElLSwtbtmzRAy+1Nt7kyZO55JJLMJlMLF26lNdeew2fz8ddd93F8uXLyc3N5Tvf+Q4/+9nPmDlzJmVlZWzatIm8vDy2bdtGTk4ObW1tpNNpIpEIPT09jBkzhn379pFOpykrK2P37t0UFxfT1NSkqzoHBgZwOBw0NjZSWVlJe3s7X/3qV/mv//ovrr76alwuF++99x7f+c53eOWVV3S7qn8F/KNd/9kE3lCPRU35OJwSUVGFg17HiqHl1NJgMI1GOA5dljb90NfHQbaXpCGLHDWg4hSTOIUUNjFFeyqXtztqiQxYkcYGmTzvAGmrStdcCweuLide7KD5IpVUfprqPwn0TJfYc1MOXNhP8ehecvLCmKU0Ow6UIZtBkaB4bRpUSLpNJF0ClgGFqFei9yQXPWeU0XO6l8YvWWg/P0XH5Uk6FqcZmAQdp0PcI5ByWwhO9tBzagFynou+KWbaz4CYR0QVIWUD/2hDxu9ZgVing5y9CslcmWRZkpazDLScC56dcSy+NEJKRvUFEAwiaiIJnlwGJjmRq+OcZKvHIqhYhEzgSyad/KPjKAIhVWBzvAy/bBsMDFJwGzPqRgVoSuVTYR6gXOqnS3ZRn8yEHxUYMingEeUjglxCRRpcbp4hiscQpi2ZR1w1sTtRSqTHTmFNP+c5djLB1HVQeMzQMmdZPXYyMjsgRsl6HW66of9r6xr6+rRx3IrHcDjMgQMH9PeNjY1s3bqVvLw88vLy+PnPf85FF12E1+ulvr6eW2+9ldGjR3PWWWcBMH78eM4++2yuuuoqHn74YVKpFNdffz2XXnrpSKJ11sigZmY8MDBAIhHTzaYLCwsxGDKeTLIsU1JaissdJZVK43Q6icVieDweXTXY29tLIpEgmUwyatQoZFnG6/WSn5+P2WzGZrNht9tJp9Ok02nC4TD9/f309/eTTqfp7e3VfTkLCgqYO3cu69evo7OzE0mSeOONNzjzzDOBTIpdJBLB6XSSk5NDKBTCYbdTWFiok4qyrBAI+DFJJjweD+2xDgKBAGazGYvFqo92JZNJ/RgYDAbC4TCQaWyMHTuWjo5ObDYbiURykPRMU1FeQ15eHn5/AL9/gPfee2/QJ1IZTL0z4HK5UBSFlpYWBCDH7cbhsOPz+aisLCc3N4e+vj5MZgMOh52dO3chpwXG1U7KpOcpaYSwSntbB+l0GqPRSENDIw0NDVRVVRCPZ5LIRVHSU5FLSkoGlWL/mgbTnyXS6bROrmc3tA+nEBxOJWc2mxk9ejQrVqxg9+7dnHnmmYiiyKxZs3j88cfp6+vj+eef54c//KGecP1pQxtAyC5vPlbV4nDLOpxScbjPtARLjXy89tpr9bTrRx55hNra2mNSPmqEYzqd5s033+Spp56ivb2dr3zlK1x55ZV4PB7de/NY90cjHzX7giMdm2P5nYZ2BrKJT4PBwKRJk3Tfy1WrVnHdddfx8MMPHxSMMXQfjrYtw32frWw9XhxueUP3Z+h32v/a+ZFOp4973SP454CqqvT29iIImY69w+Fg06aNCAJ4PJlBvvLycvI9eZjNFp5//gU++OADLrr4YhwOx0FBXXCwRYNGSqpqxndaURS8Xu+w17YsfxS8kG2PoQ2KJpOZwT1RFHG73djtdp3sUBSFb3zjG6xdu5ZFixbx9NNP62V9/+zli/9MOBYCxWKxsHTpUpYuXXrYaSorK3nttddO5Kb9w0FVM37G9913H8uXL8fj8fDLX/5SrwiaOHEib775Jqeddho+n49gMEh+fj779+/HaDRSX19PX18foVCIVatWEYvF2L9/P1OnTqWnp4cNGzbg9XppbGzUBQcnnXSSvm7ItKVfeeUVvva1r2G1Wvmf//kfXn31VTo6OvjpT3/KxIkT9es0+zqKxWKk02kWLFjArbfeyu23305ZWRmXX365fs0JgsA555zDtm3buPfeexk/fvywtjRHa/cOrUQxGAzU19frlVJ+v59UKkU4HGbLli10dnZy8cUXA5mququuuooXXniB3/72t+zZs4cVK1Ywfvx4fvzjH9Pe3s6MGTN48sknueCCC3jhhReYOXMmHo+HPXv2UFtby6ZNm5AkibfeeosxY8bQ2dnJO++8QzAYZO/evTidTiRJoq2tjRkzZrBjxw5mz57N2rVrWbhwIevWrWPmzJk0NjZy9dVXM2vWLF566SX+9re/cffdd9PW1saVV16Jw+E4cSfXZ4R/xOtfFBRMKCSHaKk0MjA7CObTwpGStU80dDWn8JEKUhxM2zYgM87cweLSOqprejnFVo9fMfHg6WfwzcLVrAyP4+XWBRStUElbBVquSVCY00WJlMJqTNHkyyXU68DkSiAYFaQgODoVovlG+idKpK2gmFRAJDAhjdFvQDGrUJCgtMBPJClhldJYC1MEii34duQjW6DzZDMFW9Pkbw2jWIzkNKSJlIuYAwqCAqFyA4oRImUq9hYBVAheHOKmcasRBYX/eucLFL8nYoykMOztRY1EobwYIRwlUV1A9ywLiZkR7pv1AmMkn54urSkSxcHzVhKgT5ZoSnvYHi1noq2dukQxjYkCJEHGLiTpSFvZEq1kuq0ZAwrvBCcgCTJfcm8hrgoEVTNxVcIipPWk8hSDJKIK66OjCcsZLqMv5cReGGFRyV5SCNhF5SBPxo9L9A0lLj+Oz+NnheMmHjdu3Mjpp5+uv9e8F7/+9a+zbNkytm/fzhNPPIHf76ekpITFixdz1113HSSf1hLTzjjjDERR5KKLLuL+++8/Abvzr4NUKqWTHH19/XoydcYU2UrGJl7E19RMMpkGBGw2G7m5uXqDAdDVfb29vYweNYqSkhJMkkRZaSmoKoZBk2urxaI38hsbG4mEI0SiUTo7uhAFkXg8TigUxO12MXPmTJ579jkktwmLxUxvbx8FBYWAgNudQzKZpL29I0M2qpBOpenv78dsNlNeXoHD4UA0CNjtNiRJoqevj1A4jNVixWq1IssywWCQSCSCxWLB7/frHfJ4PEFvby85Obn09/swm82Ew2FkOU1enge73UEinmDNmnWoikAwECY/P58xY0ZjMhkGScYBvN4iopEIiqJQVFQEqOzbt4+amlFUVJTT29uF3Z5DTU0NO7bvobOrg6KiIsrLy9i6dQtWm43Ozi7sdjsWi4Wurm4mT55ET08PBQUFGAwSspKms7Od0aNH6R2nkYCZE4uhjdlsku1YS3G1kXNVVdmyZYuuApgxYwYOh4NAIMDTTz/NFVdcQVlZ2SGN5BOFbPXO0PLqj7McbfuO1Ck/UmddFEXGjBnDo48+ylVXXXUI+ZhdOnS45Wo+Sy+88AJ+v5+vfvWrfOMb38Dtdh+k+Due/dSIZe23zi7n+qQYbjmTJ0/Wycf3339fJx8/GlA42CfrWFSGQ/dHU4wPJdCPd5uPREIeDtq96V9FkTGC4dHc3ExJSQn5+R7i8TixWAyTScLtziGdTuN2ucnNyWHduvXYbDYOHDhAfX09kydPHlaFrJ332kCA1WrBIIpEImF8fh95uR5Wr17NhAkTqKio0O9rQ+fNVlJm2xaEw2EEQaCgoIDOzk5Gjx49OEBYSSQSpKenh/379zN27Fh9EGKEdBzBZ4nse6gsy7S2tnLbbbfx4YcfsnjxYi688EK9esjtdtPe3s7YsWPZvXs348aN4+2336auro41a9aQSCTw+/34/X7MZjPPPfecHoxosViQJIm//OUvmfa0mGmjn3baaXo5tLY9ra2t1NXV8b3vfQ+v18v06dO5//772bFjBz/4wQ/4xS9+wfTp0/UBRw3ac9ZoNHLuuefS1tbG0qVLKSkpYdGiRfqzz2q1smTJEnbt2sV//dd/cc899+jq5cMdG+394aoFFEXh7bff1oNlNGW0LMu89957/N///R9Op5NTTz0VRVEoLi7mpz/9KUuXLuWpp55i5syZzJkzB6/Xy4EDB2hqamL06NEcOHCAqVOn8sYbbxCPx3nllVeIRCJ61VYqlfFhD4fDuvo6Eonw2muv4fV6MRqNeL1eHA4HkiTR399PIpGgpKSEvr4+/H4/bW1t1NTUcOuttzJ16lT+8Ic/8NBDDxEOh7npppsOKSUeuWedGGSrCIf1WjyMIlH7brjPteUMVShmf55Jzf5IxXi0Mu1jJSaHJmEP/Vxf3hBFp0ZEnuqoo9wYACBHTHJ10Xu8HZrEh75KjFHw1wpMOn0/acVAa9CNVUqRSBuRZRExbMC010HxrhThMpXu2QJSWCBelKaoagBBUOlqycNeEMVRkcBkkGltySf8Vy/+8Qqu8V2EEmZkRSDtklHKUjg3WBEGU7XFtELbGQJmb4SYx4G9WyFakqkZNiQhckqE06vr+aJnK2/6J7HmyRlUHEhh8icRD7ShGo0INiuyxUi8ystArYR9YQ/fr3mfMVIvBgFSqoAZFb9i0v0xo4pEniHOulgNm0JVnJ27A7uYoDFRwChLDwlFQhJk1kTHUCQF8RjC9MouBpJ2FubuwSKksQgqfjkjpDILmb5iCoGUCgOyhVXRsQBUWfoolQbYFKok3xHhJHs9EuohSdLZ6kftfTY+qQJRI0M1aOrIE72e48FxE4+nnXbaETsob7zxxlGXkZeXx1NPPXW8q/6XwuGOoeZjZjQaicfj5OTk0N3djd/vp7KyEp/PRzQaJZWSiccjhMORQSVkEQcO7CcUCiJJEiaTRDqdpqgoY9wbj8cyvix2OyaTCftgerXVYqFgUHmkwmBZdTmRcIxIJE5f3wDhcJRTTj2VPXt24fMNUFhYyMnzT2bduvWAi31764lGEowfP4G8vLxBv0UxS60YAVQSiQRtbW0UFRUiSUb6+/uRJIl8j4d4PE1HewexWIyysjLKysro6+vDZrPR29uLyWTCZMr4ObW3d1JaKmK32wYbZRLptEB1dTV2m4tV73/Ae++uJpGIYjJLmEwmSkq9FBYW4nS6UFWZ/v5eEvEoDoedqupyKisrqKurw+/3UVCQj8uVQ39/P0bJTO34Wvp6+2nvaCWZSiAYBHbv2YPd7sA6SNZu3rKVefPmMWHCRJqbmzEYBHJzXRiMAsXF3sEOl4iqjjQ0TiSGKruGllYfq0pw0qRJWK1W9uzZQzQaxeVyUV1dTU1NDVu2bKG+vp4XXniBG2644YQmFQ69D2R7BZ6o82Q438ejKRCyv6upqeGhhx7immuuYcOGDVx77bU88sgjjB07Vl/+0H2SZZn+/n7+8pe/8Pjjj+slWYsXL9Yb3p8kqVr7rbNL0T+N60pbz5QpU1i2bBlXX301K1as4Lvf/S4PPPCArtI/EevWgnSGkjOfJrIVZ//KCZz/7hAEgWAwOJh0K+gBa9OnT8VgNJBKpkAQMBolXC4XNTWZUJlVq1YxZswY3Q5hqHJXu9aj0Si7d+3C6XTS2dUJgkpebh5z587FbreTSqX08zr7/NbIhGySQiMk0um0TmzU1NSwZ88e8vPzEUSBgsJCTl+4kJdfeYXv3XgjcGLvmSMYwbFiqIJcu4e3trZy1113sX79ehYuXMjll1/OxIkT+dvf/kZhYSHjxo1j5cqVjB07lueff57e3l7q6up0q6IJEybgcDgwm83k5eVRW1tLOBxm9+7d9PT00NraSm9vL7Isk0gkSCQSfOELX9CvJW273nnnHcrKyujv7ycSieByufjJT37Cn//8Z9asWcNPfvIT7r77bhwOhx4gqZFwLS0tFBUVUVBQwGWXXUZ9fT133nmn7gGp2TN5vV5uv/12brzxRh5++GHOPvtsnE6nXu2UfV1qlVyZaq5MWJTdbic/Px+n04koivT09LBixQq+973v0dHRoU9XX1/PunXrKCws5De/+Q2hUIji4mK933TjjTfy+OOPs3fvXmw2G++88w4LFy7khRde4IILLmDp0qVEIhFWrFihJ4a7XC4WLlyI3W6nqKgIi8Wie74Hg0F6e3vp6enB6XTi9/tpaGigo6ODJUuWYLPZePfdd5k+fTpms5lp06bx4Ycf8oUvfIGuri4uvfRSbDYbDz74IH/84x/xeDxcdtllujJckqRPbSD73wla+AqAooowqIA8mspRRtATqRGOzQNyKLJJRwPqYdOttWkRDiYutemHEpI6kTmEfNSUjTC88hHAawhn1kdGObg76WVlsJa9gSLaA24i82VcdUa2tpQztqQbuylFu89NotWBMSxQskXB5E/QdK6EYpVBBVN1FEJmeuo9GPPjOIvChHocUO+mYFsK5wSJ6OkhTiptZ29fIQG/DcmSRkgLiO0WAhPSgETJ/n765xYhJlScrzowJFWihSKuekieHaDEFWRufiNuQ4z76hcjPpxPTjKFfXcXajgCJgmlpIBUnoVwiYmek2Wumv8OF7s3YxFU4mqGBLQIKntTbt4Pj0MSZByGOBYhxWxrIy0JD+PtnYwx9fD/fHPJl0K4xBjb4/k0SflEFROVpj4iqometItAykJzIp/J5nZCioEB2YEkyCRUA0HFjAmZEmOM7YlyJEEmLFvoSbuwCCnaozkYRIUKow8FSAwqMbXW9tH8FYeWZR+OpDzad9n4e4fJDMWnHi4zgiMje+Rf6+RqidYmk4n8/Hx8Ph87d+7E5/NxyimnUF9fj81mQ5JMVFVV0t3dg9vtJhjcpZN92sPTZrPhdrsxmUyUlWUCZjR1TWFhIY2NjboRtW9gAEVRcDgy5dH9/T6SyST79u3nlFM/lyEJ8/OJxWKccsqpSJKJt99agapmSkFkWcHlcg0mx80hFosQCoUxiIJuZB0KhVBVFZcr46uXiCfZd+AAqWQSq9WKoih0d3dTVlZGbm4uHR0delKdwWAgPz9fbwhIkoTRaMThcJBKpSgpKWHPnj2sWbOWRCKJJGXCaLSRS0FQ6erqJD8/n8LCQhLxOE6nk1AoSDqdZvLkyXR2dtLe3k5ubi7FxcW0trfh9/txuhwkEgl6ertxOOzk53tobW0nHA7j9XqpqCinoKCA/Pw8Ojo6aGtrQ1VVZsyYoTemNFJppHFx4qGpg4eSNcdK3FRXV+s+Ps3NzUyePBmXy8Xpp5/O1q1bSafTPPbYY5x33nnU1NSc8O3PVpwNJeROxPmiEY7Zqd/HotLT5qmtrdWVjxs2bOCaa67h4Ycf1gOqNGj3sqamJn7605/S3d2NoihceumlLF68GIvFMizB9XEJNo181O4PJxLZx0YURaZPn66Tj2+//fYh5OOJWF82+Xik1OsTcU5opNHfi+QcwWcLWZax2qzYbDb279+Pb2AAp9OFJBmx22xIJgmDKFJbO5bu7m7q6uqQJIlkMoHVasFiseqqqFQqpVdWhEJBFFkmJ8dNMBjCW+RlzNjRIAgk4gk97M5qsSAOXqPJZJJYLKb7OWarp7WXpnTSVF61tbWsW7eO+vp6xo0byxmLzuCF51/QCVXtmvi4SvERjOCTQruHh0IhHnvsMdasWcPnP/95fvazn+mepNXV1Xqpbk5ODs888wxvv/02giAwf/58Lr/8cmbMmIHVaqWurm6wwieH6dOnAzBu3DgaGhqIx+N6W/7JJ58kFovpxKFW0hsMBnn55Ze58sor+fDDDxk/fjx+v5/CwkJOO+00rFYr7733HnfccQeXX345ZWVlJJNJ/RoaGBjAYrGQk5NDY2MjX/jCFzhw4AD33XcfN910E+Xl5XR3d1NRUcHkyZO54IIL+OMf/4jL5aK2tpbe3l7GjBkzGDCVITMPHDhAV1eXbiUjyzJ9fX10dHRQVVVFSUkJW7duZWCwP9LZ2YnZbCadTvPqq69iNps5//zzeeqpp7j77ru55pprmDp1Kn19feTk5PDTn/6Um266iT//+c/Mnj2b008/HYvFwu9//3tWr16tDyyfd955nH/++ZSWlhIIBGhra9P3HTL3oqKiIqqrqzGZTMyaNYt4PM7atWvp6+tj586d7N27ly1btrB69Wry8/O5+eabkSQJg8FALBYjHo+zYMEC8vPzueeee1i2bBmlpaUsWrToEEXoCD4eMpKZz/Z+r5GGx0pWngjIqvCREjJrtQelfKMSUMy8GxjPgVA+9V0FONdaMRWrmM/sJc+UpK7Fi9Rqxn0AijpTWDrDhEe7aV9gxuyDeH4SQVRJNTix+QTihQrpPgvmzTY8HSm65kHf1RGiETNeV4T9A/kkUkYqigeYktfOLk8x/pgF43MerP0pANwNMSx+E2JSQQqmSOSb6bkiRpkrxLS8NipM/dz97pcY9WwaU7cPevpRU2kYHFxM5VmIFkmkv9zPj0evZr61nv0pD15DkKZUPuVSPwVigs2xqsHwIQOzrQ2sj46mX7ZTYe7HKwW4t+Ns2iNuLi7djEVMISOyJ15CtbkXSZCJKyZ2RkqZ6OokzxhGQqE17SapGvEaAyQR2RitYaF9D37FSEKRaI3n0Rl3s62rhMq8YjqDLhaV76XEmCaufjzSbyhxOJRk/GfDiMThM8LQDn92YzmdTtPW1gZAKBQilUrhdrsJh8O0tLRQUlKCx+NBkowoiqr7nmlqr9zcXF1l0NvbiyRJlJSUEIvGcDqdJJNJbDYbqVQKRVEIhzPlyMbBB2YoFMJqtQ6WSxjYt2/foNqgAIvFgqoqiCLMm3cys2bNGgyA8bF16xa2bNnC3r172LZtGyaTCUkyEo1GsVgs+Hw+LBYLkUiY/oFMWE5eXh42mw1VzQS9aMegr68PSZKw2Wx4PB5MJpNOWgiCoPsrRiIRfD6fnkzc1NREfX09AEZJ0lPWwuEwiUSCWCyGoiiUl5eTm5uLyWQmJyeHgYEBJEnSk9lisRj9/f0w2DnPpIsbdBKztLQUk8lEOBymtbVVT3dLp2W9zETzp8kuYRnpEJ14ZF87H8dDU1VVcnJymDx5MpFIhA0bNujLXbx4MU6nc9DLs4E//vGPeojTJ8XQ0uqh+3KiVXwaOZetyjhaCbr2VxRFRo8ezcMPP8zs2bNZv3491157LfX19XqJsEasd3Z2ctVVV/Hyyy9jNpt5/PHHdcP74Yi0493HocdFa8APF35xIqAdN4PBoJOPNTU1vPHGG9x44410dnbqJN6JWpd2nD7NEuhs9eundexG8I8B7RxKJZM0NzdR7PWyaNGZmCQzggCCmOm6KYP3z+LiIubNO4m2tmb27a3D5XJhMBiIx+OkUimsVisulxNFTtPd1UkiEcdsNuH1ehkzZgxGowlVgXRaRpKkg+ZPDg4yan7L2R6RkUiE3t5eFEXBaDRiNpv1a8tgMHDaaadRO3Ys69dtoK+nj7lz5uDz+XSP6hHyfASfNRRF4fnnn+fZZ5/l4osv5vTTTyeVSuH1etm5cycTJkygubmZ3bt38+STT/L888+zcOFC/vM//5PLLrtMT1vOVvBqz4NYLMaBAwdIpVJYLBby8/Ox2WzU1dUxd+5c4vE4LS0t+v185cqVdHZ2YrfbycvLw+fzYTKZ9Otp4cKFXHbZZQQCAV544QVSqZTuxw4Z/2uTyYTRaMTtduNyufjxj39MXl4ezz33nH4/aGtrIx6Pc+GFF7Jo0SKef/55QqEQoVCIhoYGXfHc1tampyDbbDZKS0spLi7GYrGQTqc5cOAA3d3dvPzyy8yfP5+SkhJdWBAMBlm1ahVf/OIXmTp1KjfddBMzZszg0UcfZceOHdhsNt1f/pvf/CYFBQV8+OGHbNy4kY0bN/L6669TWFjI5Zdfzh133MG5557LuHHjUBSFjo4O/ZgWFRVRVVWF1+sFPmqfGQwG7HY7xcXFjBo1issuu4xf/epXLFu2TE/T/tnPfsZTTz3FgQMHKCgooKGhQW873X333bhcLu69914aGhp0H28NI32Df06Igqq/4NCy7KHTGgYVjBo+TtCMRjrqpd5Zr2woCGxPlPNe62j27ivFus1KfEEI97Q+InETTfuLKHrDRPVfQ3i2+EnkGmm6MI++SQbSNpVYeQo1ZkCJGJGLEigSVL6aouqlNL4JUPCzRtJjo6S35GBos9A94CItG5CMMiX2ALlSFKOgoLyeDyokXAYEWcG4txVzfwLZItI/2UbL+QpnVtdxcn4DA0k7v3ztfEY9m0YVBQRfEGQZzGbS4ysIzqui+WwTnu8086dJ/8Nptv34FTOtSQ8WQSalGnAKKRrSbsKyhY6EmynWVvplBzICfsVGWzKPl/qno6gCk3M7kASZnbEy+hIOiiU/OYYIBcYgFjHJBFsH/UkHoqCyOVFOayoTMJVUDbwbnsBUazNOMcW6WA1v9Y3Hakix31fAVG8H+ZYwsYTE+TmbiKuZMmuTIBwUBnPEc2uY178C/lX2458Owz1wshNjOzs76enpIRQK0dPTA0BxcbEe+hKLxSgqKtIb8IFAQA+MkWWZVCqFyWTC7Xbj9/vJyclBlmWam5vxer0UFBTo6dHd3d3EYjHy8/P17YrHY5SXl+NwZMoL9u3dOzhS6NRDbGQ5xakLPsfY2jFIkpF4PAYoiAaR/Qf2EQgGCIdCOBwOurq66OzspLm5Gb/fTyQcwTcwQDKZxGQyAYJO5FmtVpLJJGZzhhTUGjdOp5NEIoEkSaRSKaLRqJ7I7XA48Pl8bNiwgXA4jCiKg4pIg068ZnyorHpyXm5eHqNGjSI3NxeDwUAgEKCgoEBXWPh8PuwOBxaLRVdfWCwWTCYTqcGEbS1lu6uri4aGRnp6erDZbHrQjt/vJ5FI6L/zSMfoxMJoNB7k73Ukf7zsabKn1VLcTznlFADeffddvRM7bdo0Ro0apc//xBNPsG7duhP6O2oKxKNt/yfFUEIzW110pOm1/0VRpLa2Vicf161bxzXXXMP+/fsPIq56enrYu3cvqqoyffp0Jk6ciMlkOsjPcej+fpL9gY/KLLXG/NAS/E96PDVixGg0MnPmTB5++GFGjRrFa6+9xk033UR3d/cnWv5QaMcbjj1B/ONAG0zR/o7gXxda2bIgiCiqytatW9m4cSP79x3A7wuQTKZQVfD5/bS1d9DR2YnRKFFTU4OqKgwMDODz+fD5fIPBb2l27tzJ22+/zYsvvsjevXuRJIlgKIRvYGAwEC4TOqeqKgMDA/j9fgYGBohEIkiDA4PZ945oNKoTkZFIRD/3tYFVi8XCpMmTqamp4aWXX6aktJTunu5DrvsRjOCzwp49e3j44YcZPXo03/nOd5g+fTrvvfceVVVVrF+/HlVVsdlsLFmyhG3btnH11Vdz9913c8EFF+BwOEin03qSu4bs51lhYSEOh4MxY8YwadIk4vE46XSaz33uc3o7NpVKEYlEeOqppwgGg9xxxx0IQqaNPXPmTBwOB7m5ufT09PClL32J//iP/6ChoYENGzZQXV0NZNpWtbW1VFZWYjAYqK6uZubMmZx66qnce++9RCIRXn75ZZLJpN4eLy0t5bbbbqOgoIC33noLRVEIBoPE43FkWSYQCCAIAg6Hg6lTpzJ69GjGjRvHmDFjdNXzli1b2LBhA1/+8peZMmUKEyZMwGQysWHDBvLz87nkkkuYOnUqCxYsYPz48QSDQR544AG6u7upqqrSl3/VVVdRXl7OAw88wKpVq1i4cCEPPPAAZ599tt4PEEWRQCCgKx1Hjx7N+PHjqa6uZvz48ZSUlBxEABuNRkaPHs3MmTOZMmUKY8eO5fTTT+fmm2/m1ltv5fTTT6e7u5sf/vCHtLe36yGcgUCAKVOmcOuttzIwMMADDzygl7Rn/8Yj96+Ph5Rq0MucJUHGRCZlemjKdXbYTHZ5szg4b/b3meWKHzuBGj4qvc5+Dx+pErXvh5ZZi6hIg7TUUEIx+//h5tXm115TzK1U5Q3g2mskUiETD5iJriog/3E745cGyN3YS+9MJ/svdxOsEjH3QzJPQXanMdjTSO4EtiaJUX9UKVsZo/kLEtKPu3GO9bFt5Vism2yoRhV7mwCdFoI9DiLRjJ3ShwOV7KsvRkypCKqKrSeFYrMgSBK90+20XSBjv6gLkyNJWjWwyVfBpv+ewtg/DaAYBSyNfaiJJILVysDiUbSdbqftTJXLF6/k11Uv4hZTxFUDuxJlzLA2ISPQm3YRVY3siJezvr8KX9JGldTHiuAEas2dbI9WsHGggpRiIM8UzQTKiAk2+iqZ7WpknLkDu5BkW6ySDZFRbI+UE5FNBGQrsirQlswjIFvZmyimSAowRgogIxCWLUxyddAez0FRIc8UxWpIMa20Ha8hOvjbQVId+ltnFIzaS/tM4tA06mxvxmMNkjkcYflZEpkjxONnjOwHj9bRNJlMOJ1O4vG47ruSCZWx6WErGjlXVVWpe6iIoojH46Gnp4f+/n48ngwzH4lEMJvNlJaWYrfbM96Ogw9ei8VCWVkZfr8fyKgtE4kEdrtdf+A6nS4am5rw+TKlD3l5eXg8HnJzc3G7XZx55iIqKiswmSRS6SSynGJgoI9wOIzL7aa1tRWz2UxxcbHuqaKoCuHBB6/NaiU3L1cvxfD7/TrZmF2G3tfXp3tCmUymQcWmrHeo/H4/dXV1yHI6U55NptPjdDqR5TSKkimZzMnJGfTBzKgotY6R3+8nGo2Sk5MDkCkTlRVKSkpwu92k02kikYhOjmoqC62MRBQzptThcJhoNIrD4dBLvU8UATKCg/FJj2c2GTd//nwcDgfr16/XyX632825556rNwj9fj+/+MUvGBgY0JU4x9tYzG5gZvsufhKPvaORiNnQ1pWtdjuSsi6boDUYDNTW1vLQQw8xY8YM1q1bx3XXXUdDQ4O+nHHjxvH9738fi8XCn/70J5555hk9ffx4tvN4G+JDy8mP97gMt/7sv9ryTSYTJ510EkuXLqWyspJXXnmFm2++WVdqnUiV4sclH490r8n+zbPPvZF70782JEnCKBkJhUIUFRYiiiKbNm0iHI6gnVqZc0BAUWHnzl1YLBa6u7vp6+0jlUrp50k4HCYUCuEeLAEdO3YskyZNoqKi4iACW1MKp1IpkqkUwuA6YrEYkFFUZZ+LiUSC1tZWBgYG2L9//0HqbE0NqaoquXl5zJ03F7PFTCQcIZFIjHTaR/CZIxwO88c//hFBELj11lupq6ujrKwMk8lEXV0dRUVFPP300zz44IOoqsrdd9/N9ddfj8fjwWq1Ultbi81mIx6Pc+DAAaLRwQ7r4PPMZrNRW1vL1KlTKSgoIJVK8fTTTzNlyhTGjx9/kE3H2rVriUajnHXWWQSDQf7whz/wyiuv6CXa6XQai8VCLBbj0ksvpbi4mKeffpr169cfZAukPRcsFove15g6dSo/+MEPWLduHe+8845O3JlMJoqKivjBD37Anj17WLduHQDxeBxVVXUCUuvLaOvIycnR+znvv/8+TqdTD7ATRZFoNMrq1auZM2eOHqbz8ssv87e//Y3x48dz2mmncd999/HXv/6VVCqlH6sbb7yRiRMnkpeXx6233sqoUaP0qhjtWGmVCprQIXuAdGibTCM1NSW2oijE43Gi0SiFhYV8/etf57vf/S6hUIif/vSn9Pb2EggEyM3Npa+vj8WLF3PmmWeyatUqVq1aNVJpcIJhGEIgaqTccOScJCi6AtGQVSI9tFxaUYWDXsAhHo7Z32VDm07fruNIvDYcoWx7qLLxSNO5xQTXl60gXK4w6rkko/6fQuUTDRijMvu+mUv754uI5QuIKYFIVZrkgiCKVca5V8K800rV/QLFa+M0nmem7NcHoCBB/dYyIrtzSbkUhDQ4miFlB9mqQFpAlQUaAh58cStCzIAxDmmrgGoQGJieS8cFNQQmyBAy0ra3EFFUWb5tEn2PVeJ9pwchGsfS7ENx2cCTQ2hOBT2Lk8w6dye/POM5vpazAZsgE1dFNscrmGZpximk+DBWRV/awf8FZvJSx1QAvpC/g9Z0HrnGKAoiGwcq6I/asRpSxGQJlzHOrmgpVY5+CowhaoxRCgwRyk399Cad1AfzSchGLEKaqGLGl7YRlc34UnYmm9uQgC7ZTkOsgP6UnfcPjCbfFmW8vYMDwQJuKH4bKYtQHA7Dfa7VT31cA6mhpdhDPSUNR5j208YI8fgZYajqCD4qE00kEsTjcdrb24nFYqiqit1uzzT03e5MWbTRiCRJiGLG91Arg0gkElRUVCAIgp4c63A4MEkSZrMZj8dDYWGh7gWpqipWq5UpU6boakq3Owez2YLT6Rj0dIziG/AhywqxWByTOVNC7fNlypMLCgo4++yzmDV7JqIoEIlEMBgMtLe3ASqBQICWlhbsdjuCINDU1EQ8HgcyYTaSyUSO262XJRuNRkwmk05EFhUVHdQAMhgMmM3mwXLxNOl0pmS8p6eHYDCIqmaOZXJQkagldrpcThwOB6FQiGQyidPhwGAQcblcmEwmHA4HbW1tusemzWbTyU6NPEwkEgQCAfbW1eFyOTGZTASDQbxe72Cid4Lu7m6MRiPhcBj7YJiP9vv+K3WOfvWrXyEIAt/73vf0z+LxOEuWLMHj8eBwOLjooosOUYO1tLRwzjnnYLPZKCws5JZbbtFT2D8ujkTsHivhO2bMGMaNG0dXVxcbNmzQVTYXXngheXl5eory2rVrWbp0qX5tfhxkl7dmp3B/GuT0UCXl0BJqbXuGzpM9ffYrW/k4bdo0nXzUyq4lSeLqq6/m5ptvJplMctttt+llXB/3eB3P8dG+P16ic7jlZA98ZP9Ooigyb948Hn74YSoqKvjrX//KLbfcohMjQ7flcPtyLNugrfdYCc3hfrOhygrgoA7WCP71YTKZiA0SGQgCfr+fgoICrFZrFvGcOd9sVhvnnHsuObm5DAwM6GmvoijS3NzMCy+8wPYdWxnwDSDLCkVFxeTk5qEKKoLw0TmlEQeynOmmiYODmRrZqLVBtFdhYaHuCVdUVITf72fnzp0kEgmdILDZbMybN0/3W4vFY7S1tY0ks4/gM4WiKGzdupXly5fzne98h7lz59LS0kJLSwtnnHEGO3bsICcnh8cee4xEIsE999zD5z//eb1tCZmBzsLBQYFQKEQsFhv2Ga3N09LSwgcffMCXvvQlLBaLTihqpdNXX301t9xyC9/61rdIJBKsW7eOF198EZfLRXNzM/n5+QQCATweD9/85jepra3lkUce0QcGhu5ff38/jY2NbN26VQ9lefnll9m3b5/uKwkwbdo0rrrqKp599lna2tr0fdBKvCORCC0tLTQ1NdHU1ERrayuyLBMKhfjggw9YsGCBLgAA9GTq+fPnYzQa6erq4uGHHyYnJ4cvfelLnH766Vx00UX86le/4umnnyadTmMwGHC73fz85z9n4sSJPPTQQ4RCIf1YH4vNjDZd9ntZlhkYGKC+vp5t27axefNmuru7dQL1kksu4e6778bv9/PUU0+xZs0acgfvowCXXHIJVVVVLFu2DL/ffwj5+K/WT/h7Qit5PlqojAYtGCZb2Xg4FeHHQfZ2HA/peCLRq9h4qncOeTsEjJsPYAwm2H9jNc7/bMNaE6RwawxjDFJFKVBAWuWi8iUofWOA/J1p2hfYkX/aj7Eiwub/nYyxyQKKgDEsULBBpHh1AFdzkvydKXJ2GpECBkaX9FLlHqCrMxdLr0jfDJVYgcDAOBP27hTxQih5F8z9BmbNOKAdIOJ5IkIkliEcBQHFKtF6YTHdX4nzo5Ne5+clr3GytRWAkGpkfyqftcFR2IVM/3FbpJw9IS8DKTuyIuKQEkiCzIZwxpd/W7QCWRVxWeKkVTFDzBqj5EoR5jrqsYsJ4irEVQPLfZN5Y+94DKJCvjlMuamfTaEqkoqRPGOEkxwNWASZNfESXvFP5/V9E9g5UIzLGePz3p08uu9zfLP8A0oMUSyD94/DDTNkf55dhv2vStD9q+7XPzyGe7hon2mNimQyic/nw+l0YrVaUVVVL1vQiMPS0lJGjx6tm7RbrVZKS0vJz8+nq6sLj8dDTU0Nfn9A/z4ej+uNGgC73Y7NZqOgoIDu7m6cTie9vb2k05m0yYz/iqw3igIBP1abheLiYpxOBx5PHjU11Zx//nlMmDAei8VMbm4uDQ0N1NXtpbi4mEQiQ8ipqpIh9Hr7CAYD7Nu3D4Dy8gpdgakZM0ciEaLRKFarFftgenR2yaO2zyDg9XqJxWIIgqCH0VitFozGjDl9dLABpw6mSg8MDOgltj6fD5vNphOmra2tVFVVZUhbZ6aEWzO7nzp1Kl1dXaTSaQQhM8KrlcMrioyiZLwqOzs7GRgYIC8vD6PRqI+s/qt09j/88EMeeeQRpkyZctDnN910E6+88grPPfccK1eupKOjgwsvvFD/XpZlzjnnHJLJJGvWrOGJJ57gv//7v7n99ts/0fYcrbGW3bkdbjpBELDb7Zx99tnIsszLL7+sl1uPHTuWRYsWAZkQGkmSePTRR3n99dePidwauu7hPB0/CUF2NBytnFpTNmeToUebx2g0MmHCBB555BGmTZvG2rVr+e53v0tLSwuiKGKxWPje977HtddeSygU4pZbbuHVV189SMF0PKXeR8NQotSQRXB8HGSXeA71ENXWI4oiJ598MkuXLqWsrIwXXniBW265Rb9fHG7fPs5vra0v+zc60nYf7nzLJruz5xnBvza0a9Zms1NaWkpqsG2hKEpGvT+oEgJVJzTWr1uHKAiDvswRfVlut5va2lpOPfVUFi5cyEknzWHs2LGYzZqC6aN1Qtb5lXWNalBVlc2bN9PX1wdAa2sry5cvJxKJYDQYsNms5ObkEIvF2LVr12B4nZ2WlhaMBgNWq5XWllb279//KR69EYzg6EgkEjzzzDNMnDiRqqoqUqkUs2fP5s0338TpdFJWVsavfvUrFEXhP//zPznttNMOuQ9HIhF6enoOSnofLpRQe16/8cYbOBwOZs+erU9rNBpZsWIF8Xgck8lET08P3/72t1myZAmSJPHMM8+wceNGwuGwXj0Ui8WYM2cOJ598MoIg8O677+rBY5BptzU2NrJr1y6ampoIhUIkEgkWL17MokWLeOGFF9i3b5++rQaDgTPOOIMZM2bw+OOPZ/zSB7db85Wvr6+nsbGRhoYGmpubSaVSfPjhh/h8Ps444wx93alUilWrVlFWVjZo+6Dy6quv4vf7WbRoEbW1tXR1dXHRRRdx/vnn8+c//5m//OUvulWDx+Phnnvuoaenh/vuu0/v9xxr+yL7+ZlIJNi7dy/bt2+npaWFYDCoWynl5+czevRozGYzp59+OnfccQft7e28/PLL+kBLKBRizJgxXHHFFfT19fHSSy+NPH8/IYaShEPJxOxXNlKqSBKRlJp5HQlDVZBDyclsj8fsabTEbBmB1CekW4YjLsUsFeXhvr+35fOs2jOWgckqHd+cTPlDTVz2+ZXMym3GtNyNkFKw9Si4tpuwtxhxtsmISYXm8/JouUAhNj5Oz7ulmD9wksgDQRHwrldwtqjYetMkcy30TTHTfI5AYKKMUhHHICp82FgJaYHcz3WhONO4GxQKP4xg7gjjXZtkoNbAxDP2EUhYSXTacO4ykVOfIja+mEShHQwi9RfbSM0KcWpVPXOtDShARBGpT+VSlyzCJcYpMIURUWlI59GXcHCWZxdGQUZRBebkNhJXJLYHSpEEGV/axhhXLxNzOulP2JnlasImJgmkbbzlm0hP2smOZCE/b/kSb+6YiCiqTMtpI1eK0pN20RrJocgURBLSiCjUJYv428BUtvtKkUMSiipwSmk9UdnMktqVzLa0DG6zepDiUCMVhwbNZJ8hx6NC1ObLLtk+KNX6KPMfbr5PCyPE42eM4dRIyWSSSCQyGOSS6Wh2dXVlBZik9cATyDwUc3NzCYfDmEwm6uvrmThxIpWVlbqaL53OBNSUlpaiKIrurzQwMMDAwAD79u3TFVxdXZ2Iokg6nUaSJJxOJ5FIhLfffhsAT14eqqqgImMySchyiqKiAux2K/Pnn8yZZ55BeXkpHk8eqVQSRVHo6+ujvb2dgQEf5eXluN1uHA4HBQUFhMNhLFYLpaWljBs3jmg0qpeZ22w2BgYGGD16NCUlJZjNZpLJpF66AZnRX5fLRX9/v64w1Mo+YrEYeXl5uuelosi6T6TL5UKSTLofpFZ+nk6nqauryxhrD36u+bE0NDTg8XiQ02nC4RB2ux2j0ZiZ12jEas2Ubvf39+Pz+TCbzcMmdv4zIxwOc9lll/HYY4+Rm5urfx4IBPjTn/7Eb3/7WxYuXMjMmTN5/PHHWbNmjV5y8+abb7J7927+8pe/MG3aND7/+c9z1113sXTpUpLJ5Ge1S0CGjPn85z+Py+Vi5cqVtLZmRtYkSeLKK6/E4XAQDAb5/Oc/TzAY5Cc/+Qnbt28/LqWNZhWgre8fBdkEqBYWcyRo5N748eN5+OGHmTJlCh988AHXXnstDQ0NQGZA40c/+hFXXXUVPp+PH/zgB7z55pvHFQJxrOrG7P+HKjq1AYrjvfayvTeHW68oihiNRk477TQ93fr555/XfZxO9HWerZJPp9PHTKpmk6jZKtd/9sGPERw7tHOxo6Od/fv2kZZl8vLyqK+vZ8U777B582Y6OzqAzL2gpqYKs9nEpk2biEQiettAI+LNZhOpZCpzXZHdjlH17k/2IIPBYEBVFJTBe4soioiCQCqZZNrUqUQiEdKpFJLRiNFg0KdTBgdLAT73uc9hs9lobW1j5XvvsWXzFgyCSH5+/gjxOILPHE1NTaxevZqLLrqI8vJyNm3aRE1NDYqisHPnTt555x3C4TD33HMPp5xyyiHP/0Qiwb59+3Qrn5KSkoNU9hq053MwGGTFihXMnz+foqIifWCqu7ub5cuX85WvfAWj0agHxlx11VXcfffdSJLE/fffT1FREQ6Hg3HjxtHR0UFRURF2u52zzjqLVatWHeQx6fP59Gogu91OUVER48ePZ86cOfzsZz+joKCAO++8k87OTv3ZpKoqX/7yl5FlmWeffZZUKkV5eTlVVVX6q7q6murqasrLy4nH46xatYri4mImTZqkP+u6u7vZtGkT8+bNw2KxEA6HeeONN1i4cCEnn3yy7hPv8/m4+OKLOf/883nvvff485//rD+HCwoKuPfee2lqauJPf/rTQW3NY2ljaM9Qn8+n2/Dk5ORQVlbGxIkTOemkk5gwYQIul0tvG5199tlceeWV7Ny5kx07dlBSUkJTUxMWi4Vx48axYMECnnvuOfr6+v4l+gWfFbJ9HLPJxuzvtfeaAjFbiTiUkMyeXhQy5OFQaITfsagjs5WUQxOns9enr1P7fBjVZjbJKGaViGeTjtmfA9xW8TdeWvggX1n4Ad+5+hUuy1/L/kghT/7tdAwJSDskfOMFXC0ynp1peqeLNH9DwTDLjxgwYtlrIeaVCU5OYu9QKdgmoxgFbL1pOuYbabxEJDQxiSALoIBRSlNkDTG6uJeFU/bQeaAA104Tskkg7ZSIVTppvUIm75QuFFVgf3sh5j4DZp9KoFpCTKsEK020nlOA6k0wrbSdJYUrcAppkqpIr2JjS6yKcaZudsTLOcmeCZPdFq3k1Nx9SEIas5gmzxrFbYixO1pCWhEJyFYkQWa8rZMaay9T3O20JDxEFRP7woX4klZe75/MT3eez466csSgkaqiTLm1iIovbSeQsOBL25AEmT3xUn6++xxkVeBARwGm3Dhp2UCp2c95rq2cYds3SD5nyLyhZ9HQcBlxyP8aAShnfXakHuPQ74abPpvslDm8AvPTxj9Oz/ffDMOVWkOms+vz+ejv72dgYIBAIIDBYMBkMtHf34/BYKC3N6MO0JSIWll1bm4u5eXl5Ofn09PTQ2FhIeXl5RQWFuL1erFYLLq6MScnB5fLydixY/VSAovFgqJkTOQLCwuIx2MYDAadnBvoHyAUCmMym0mlUkiSRDKZ1BOrM8nSeVRVVTF79mxOOmm2XmZbXV2N0SgBcOBAPRarRVdhmM1mjAYDJSUlemKmIGSCItxuN2azmd7eXtxut17KqfnEuFyuzLEY9FzUEvlsNhs57hxcLhdutxunw6GH6AhCxi+yt6+PZDIzWqntj9lspqysjJ6eHhoaGijyevUSkr6+Pj01r7i4mGAwpHvwdHd3U1Zaqpe3a5414XBY95zRRrD/2Tv8S5Ys4ZxzztFVgBo2bdpEKpU66PNx48ZRUVHB2rVrAVi7di2TJ0+mqKhIn0bzINq1a9dh15lIJAgGgwe9Pgmyr7vs32PcuHHMmTOH7u5u3njjDf3zk046iTPOOIOuri5sNhtnnXUWjY2NfP/736e5ufmwKr7sazu74/5ZkD/DEd9DBz6GI8mHm0eDKIqMHz+eZcuWMWHCBFavXs2SJUtoampCURScTic/+9nPuOKKK+ju7uamm25izZo1+jqG4nDH42gKySM13IdTPx5Jnar9lsfie6gdvzPOOIMHH3yQ4uJinnnmGX784x/j9/uPeBw/DrTf6Gjqx6HrGu5cH+no/HvBZDKRTKYwmc3YbTYURSGdThONRkgk4hQWFtLR3j6ozM+UQHu9XhKJBJ2dnSQSCRRFIRaLMTDgo7evl+6uzPNdK6EWBBGDaNDJSG2Q1GQyIZlMmXNOzYRrqKrKvn37UMmohYySRFFREfNOnkfd3joamxqIJxKkUin27NmDwSjS29dDX18vNpuVVCqpeyx3dHTo7ZgRjODvDVVVWblyJV6vl/z8fL0Cp62tjfnz5/Pggw/y1ltvcdttt7Fw4ULMZvNB86fTaRoaGvD7/UiSRFVVFTU1NTidzkN8fjWv8e3bt7Nr1y7OPPNMTCaT7p/46quvsnDhQiorKw96vkuSxDnnnMP3v/99XZ25e/dufQAtkUgwdepUVFWlqKiIdevW6fNq1khaAEttbS1erxeXy0VBQQG33XYbwWCQu+++m4GBAX1w1W638+1vf5t33nmHF154gZKSEqqqqqioqKC6ulonHysqKmhqatKPl0bgAXp7Ydq0aXrwTktLC5dccgkul4t9+/ZRWFhIf38/bW1tPP/885x11lns2bOH+++/n/r6eoxGI4WFhfziF7+gr6+PZ599Vr9fZD9Dj3b/CIVC+v1szJgxjBkzBq/Xq4sWsiFJEl/72tcYPXo0f/7zn7FarXpwpdPp5MILL6Srq4s1a9aMeD1+AigIiIKCaZBGOZiIzPwmJ7J8Wlunchgl5XEv6zBl4cfi46ilWx/OD9IgqLjFBBZB5orcdSy07eXBjoWs2VSLODqM+4o2fGNNFH0o0zNdpP0rKcSUgOozEe52oHqSxCpT2FsNVD0vYO+SEVMqwUqRpvMETJMCGRZJACEnib0sRKrDzspNE9jX7GXVu5Nx7jeQtoBshv7xJlq+LKPIAu0tHna/OwZhwERiVBx7dxrvB35ihSaSOQKRapma4j6+WbQKt5giNbifrwemMMnaSkgx0ZLIY5TUT0Ax05bIZZy5k760i2n2Fmqd3YRlCwMpOw09HhKKkc64mw+DlURlMwZBoUgK0hTPZ09vEa3BXLZ0lJFKGTA40ggKpBWRhGKgzDTAyr4xuEwJ3MYYkpDmib1zSG3JpSWUh0GSURUBuynJLFsDTlE+iPg7GmEocbAq8UTcDbKJTfkw339WGCEe/4GgNRIcDgcFhYXYHU5UFTo6OjEYJKxWOzabg2QqRTgcRTRI9PR0Z7wZU0ksZglRBKfTjsEgUJDvodhbhN1uJR6PEYmGicUjGI0iFqsJp8uBzW6ltKyY3Fw3qVSSwsJM2nVHZztpOYmqpjEYBWbNnoXBKLJjxzaCgSCWwbKqwoICLBYzDrudVCqJ0+nAZrOSTMTxer1MnDgBo2Rk1KhRtLS2sn7DBrp7eujp7sfvDxEa9EGMxsKYTAYEQSEnx0lpqRen00F/f59uUD/g84EoYLXbESUjRpOE0+XCZDFTXFKMZDERjoYxGA2YzSbdrDs3N4/c3HxycwpIxNMYjRKFhUVIRgmrNePjaLfbB1OwjbS3t2EwGHE6nTQ2NOIbCKAqAvFYCkUGs8lGX19GXQmQTCYwmUx0dnaSTKbo6urSvTY19eVwRNQ/I55++mk2b97ML3/5y0O+6+rqwmQyHeTNA1BUVERXV5c+TTbpqH2vfXc4/PKXv8Ttduuv8vLyT7gnh0Ij37/85S8jCAJPP/20PupvNpu55pprsNvtvPrqq3zlK19h1qxZbNy4ke9///t0dXUN69Uz9P1nRToeDzTC7ViUj1qnZdKkSSxbtoyJEyfy/vvvc8MNN9Da2oqqqrhcLn7+859z8cUX09bWxnXXXcf69et1UuJEYDhSbzhCVSMVhzv22eTg8fgwasdg0aJF3H///RQWFvLUU0/x4x//WC9nPdHIDoQ5HMmo/T9cefUI/r2gqipms1lX6GseaP39/Rw4sJ/29nZ8fj9miwWTyYScTtPR3kEgEGDbtm2UlZWTl5tLXl4eY8eOpaamhh3bd7Fx4yb279/Phx9+yO7du0mnZNzuHGw2m640/qjkMY/cvMzLbDaTSqcpKS0lmUzS1tYGQFqW2bjpQ3z+AWx2G3a7nTyPB0mSiMfimM1mxowdzakLTmXu3LkoikJ3dzfBYHAkIGkEnxlSqRRvvvkmF154ITU1NRw4cIApU6awYcMGnE4nu3bt4vzzz+fzn/88kiQddJ4qikJrayu9vb0IgkBpaamuYDQYDAc9h4PBIFu3bmXbtm08//zzlJSUMG3aND1tvrm5mb6+Ps4999zBCh9F9yzv7+8nEomwcOFCvvnNb7J//362bt3KmjVr9DZacXEx+/fvZ8GCBWzatEmvTjCZTPp2xGIxPVgxlUoRj8fJz8/nu9/9Lh988AG//OUvCYfDurq+vLycq6++mkceeYR169bR0tLCzp079fTteDxOW1sbb731FqqqsmDBAgQh4xXf1tbGiy++yLhx4/SKp5UrVzJp0iQMBgOhUEgXZIRCIe6//36mT5/ORRddxDXXXENXVxc/+9nP2Lx5M7IsYzabueKKK9izZw/PPvvsQWXXRxuMBAZ99cXBAZuo7iGfSqUIhUJ0d3frpdcAubm5XHfddaxevZqNGzdSXl5OQ0MDeXl52Gw2Fi9ezPPPP08ymfyn7xt81hiOABSHUSt+Umil3Nr/nwVSiDoxKaIOq46Ej1ST2eXk15es4LlzH2BeRRO9fy3HPzVF+JsZAlGRBeKVSUw+EUQVqcXMmCdSFGxJIFsE2k8XaTlXRZznwxARiQSsSL1GrPUmhG4z6W05eLYIFH0gMOp/FBAg4VHJ3S/jH6diXtyLYFAhICGGDSSr4yhWmbIXjdg3tyJbJRJOgXCNzNxp+7ioeDO9souGtBtZFehIO2mJ5WEXkjznO4mBpJ39qQKe7J+PUZCpTxYSVUy8MTCRzrgbhyHOOHsXi0ftZZSldzAESKQtkUupyUdUMbGmq5poxEyeNUqOI0rCb0EOSRRN7MFjidATcxJVzDQP5FJm9zPT1shK/zgM612oIrR0eEj3WpHTIj8b9Qo1xgCyemgi9eGgAKnB11AV5NGQrWAcbr7htuMfYYhjpCfyGWG4jnJ26bCqClitNhQVWts6MUomUmkFu8NFJBKnr9+XURcYjPT39dHd3QUoBAM+LGaJosJ87HYLZrMRp8NGSUkReXlu0ukUeZ4camqqsdksWK0mDAaBvv4eXG4HqVSC6upKTCaJRCJOLB4lw5fLjB49ms7OTt566238vgBKWiYY9GMxmzCZjNhtVuw2KzarBbvdhskk4cn3kJuXy649e+jt7aenp59YLInTlYPJbCaRTKAoaURRQVaSFBTmkUwlQFAxGCEnx50p51YUIrEo0XictCJjkIzEk0kSqSQGScIfDDIQ8BNNxEjLaWQlzYSJE5g5cyZ2uxO/P4TN5iQeT9LZ2YXBYMRmt2fKqU0f+Ur29vYQj2fKylIpGbPZRiQSIycnj9LSMlRVRBQkVEUgGokSDAax2+3k52dCezJKUhd2u/0jpcdgYwX+uTv/ra2t3Hjjjfy///f/9ETCvxd+/OMfEwgE9JdWBn2sOBqJlP3dmWeeyejRo9m6dSsrV67Uv583bx7nnXcevb29PPfcc/zyl79k1KhRvP7669xyyy309fUdQqQNV+Y63LYcD9H194C2rdml4Ye7X2nE3tSpU3nooYcYP348K1eu1D0fBUHA4/Hw61//mrPOOouGhgauueYatm/ffshyj6cE+1iOV/b32V6WQwcCsn+nIxEYQ0u7s7dBFEXOPPNMHnzwQQoLC/nLX/7CbbfdRiAQOIjMPB4c6Xhke+hll/tnr2eEdBwBZM6JjMpQobe3l0g0459cUVEBZFKml7/2GqFgkLVr19LX18vo0aMzam5VZeOmTTQ1NyNJ0mClQ4LW1mYaGw6wY/s2Ojvb2bJ5E0/9v7+w4p232L+vjv6+XiKREMGgn9aWJrZu2YzRINDd1cn69WvxDfSTTMRpbmqkof4AGz/cwNtvvUUwEGR87ThUWaGnu5venh4cDgepZIr+vgEYbBvF4wndT1kLvxnBCD4LdHd309vby4IFCygvL+fAgQO43W68Xq+udrvmmmsOUTqqqkpPTw/tg0rj3NxcKisr9YGyoee0Zt3T09PDu+++y+TJk2ltbWXXrl2EQiHeeecdLrnkEjwejx5CKcsyDQ0NbNu2jS1bttDQ0MDXv/51Zs+ezcaNG1m9ejV+v5/du3dTV1eH1+sllUrhcrnYs2cPwKC3qgOj0ci+ffvYvHkzW7ZsYdOmTXz44Yfs2rWL8ePH881vfpM33niDhx9++KCk+dNPP51zzz2Xu+66i/fff59AIMD27dvZtGkTW7duZdOmTezcuZPZs2czbdo0ZFmmvr6el156ia1btzJ//nw9cfqdd95hzJgxNDQ00NPTQ1VVFf39/TQ3N3PgwAEuu+wyTCYT06dP5+tf/zoDAwMsWbKExx57jD179pCfn8+NN97I1q1beeCBB45K+mX/Bnl5eZhMJlKpFHV1dToJvGnTJjZv3szOnTv10mkNc+bMYc6cObz88svk5+fT2dmpq8HPPvts9u7dy549e0buXx8TWplxSjUcRD5mqxyPpErMVkIOl059uHllhIN8HY9XUalklXMfaf7hvBuzt9EgqIcoHocSkdnl4iXGEDYhjS9ho+aS/ZASsD2ZQ82zfvBLuPIiGCMCY55IUbk8Rud8G50nm2k9C8TCOAZnisSuHFQDCD4J1QjJHBVrt0jZ21FsPWnMAZlYvkTBJoXqZ30YowqKScW/PR8lKCHmJVGsCsWvSIz/rwEc+/1EZpTTeqYdz1dbufxzq8k3hxlIO3ipdxq9aRcmQWFf0kuROciOeDmb+8qxGxPsjpXSE3cQk02Zc0AVKTKHSKsiPSkXtZZOZjkb6Us72NnrRVEFTGKaD4PVvNk5nr7GPAAiKROhmAVrq0TVqG4m5HYTlyUm53SwNVRObUEPVkOKhmQh7783GdkEyRwFsV8CZ5on5/+JWimgJ1hrJdaH/p4HvzK/10evoRjqzzh03uPB4eb9uMv7uBjpjfwDQeskmkwm3G436XQaUTRkFIgdnezevZtQKITNZsNoNGK3O3C73bqXoc1mw+l0MmHCBMaMGYMoirpfjNPpHFyegNVqxWg06Co/rfGze/cuZFmmqKiQ3NxcRFHAYMj4H6ZSGY/IkpJS7HY7gUCAcDgMoJcbA/rytIdzX18fJpOJ5uZmOjs7URQVUcyYwufleQiFwgQCfkRRxOl0kJubS1FRIRaLJVOWgEosFiM+GCyTGAzWUVVIp1Iog550oVAIAIPBiNmcScR2Oh0EAoHB0rABQqEQOTk5hEIh9uzZQ1trK4FAgNzcXJLJpJ4KHovFcbtdhEIh0ukM6dLU1ITmpdnc0oTJLFFYVKinhktSxucxFAphtVr1cnG73X6Q2uqfGZs2baKnp4cZM2ZgNBoxGo2sXLmS+++/H6PRSFFREclkEr/ff9B83d3deL1eALxe7yEp19p7bZrhYDabcblcB70+DQiCQH5+Pl/96ldRFIXHHntML+s2m83ceOONlJaW8sYbb9DU1MQf/vAHKioqeOmll7j55pt1Y3jNTDybdPxnaVhmE2nZZcqaTyJwEJGmvQwGAzNmzOCPf/wjtbW1vPPOO9x44406SVxYWMjvfvc7zjzzTPbt28e1117Lrl27dPXEiShDPhqyVYJDS681L7qP+zsJgoAkSZx11lncf//95Ofn8+STT+rko7aPJ9LPKZvM1vZp6Hk3tARsBP+esFqtJBKZ+7NvwEdnZydWq4Vp06ZhsVjwer3U1dVRU13Nq6++yvLly5EVGX8gwMDAAA6Hg1AoRDgcRlFUgoEAdXV1vPnmG7z80kusWvU+27dvY926dbz11lusXr2KjR9+SP2BA9TV1bFmzRoeeOABXn99OU2NjWzfvo0PP9xAa2sLNTXVg+Wl1aiKwvLly9m2bRv9/f2YzWaqq6qQFYVdu3ZRX9/A9u072LOnjt7efgKBAEajUbcgGMEIPm0Mtc/Ys2cPJpNp8NpQ8Hq9dHR0UF5ezvLly7n22mspLCw8ZDmxWEwPVsrNzWXUqFFIkqSvw2KxYLFY9Pak2Wxm3LhxdHZ2Eg6HmTFjhm7n093dTU5ODuedd57e9hw9erRuP6RBURRcLhe33HILsizr5b4Oh4NwOMy0adPo6urii1/8Im+++SaKomSUxmPG6ORjOBwmGo0Si8VIpVLY7XaSySTf+ta3+PKXv8yTTz7J3/72N30/ZFnmW9/6FlVVVbz44ouEQiFdPRmPx9m2bRsAl156KU6nE8jY62hqzFNPPZVRo0bR0NBAMpmkoKAAh8NBX18fkydPRpIk1q1bxxlnnMG0adPIzc3FaDQybtw4vva1r2G1Wrn33nt5++23MRqNzJs3j3vuuYc33niD//mf/zlowHg4exQtINLpzNhTud1uVFUlGo3qfSFNVa5ZUgB60N43vvENNm7ciM/no6ioiPr6ekpKSnC5XIwaNYpVq1aNKB4/JjQCTxIOXz0zHKknk1G/waHhMYesYxhF4XDl29nvD+c1OfTzocvJLuPWIA76Q360r4o+rawOP112qbasCgd5P5oEhQmuTlqeHM34/2zE+doOhLSCud9AwR+sVD5RT6TETO90W6ZMekIYJAXHBza8L5oxBQTMfSKWXhFXPZS9m6Zs+QDGYBzZIiKF07j2BhBUaPtCHt2zJaydBmSrSmlNH4KgUvmKitmXJladS8pjp3eKRHJsjAJrmB2BEvYFC3mlfRJeS5Axpm72pzy82TcBgA/8o7BJSWY4msmXQkTTJsosPjaFqnAbozgMCboiLoolP37ZRki28nZnLWM9vRRaQhwIFRCTJQYiNowhEbMlRVI2EI+ZiBfItPe7aQnn4pASJBQjeaYI45zdzHI28n7/GMQ0pJ0q5n4R2a7woznLKTdGdUWhdJQuxFAmYLhgl+yWzJFa8EdiFQzC8ZN8xxNq83Ex0kr7B0K2GkcQMoSMZsgsyzIul4tAIJNOrUn7tU6lJGU8WrRGQEFBAQaDAbPZjCzL9PX10dzcnCmHGgyN0dKfAZxOJ6lkSm9UeDwerFYrvb29evKl3W6noqIcs9lM52A5cWdnp55wZzQa9cS6VCqFw+7A4/EwMDDApEkTdTJx3759rF27lp6ebhwOu97h7+npoaenB7PZjNls1gNiysrKKK8oR1UzJGRhYSEGg4FgMIh/MMBFe+hbrZYMYSIaCAQCOJ1OBEEgEAiwf/9+nUDp7e3F5/djt9sRRZHYYOq1w+HE6XSRTqcpLi6iu6sDRcmoRLZu3UY6ncLj8ehl1Ioik06nyc/Px+/3YzAYiMfj9PX16cE8Gv7ZO0VnnHEGO3bsYOvWrfpr1qxZXHbZZfr/kiTxzjvv6PPs3buXlpYW5s2bB8C8efPYsWOHbtAN8NZbb+FyuZgwYcKnvg9DybKh0Mpmv/zlL1NeXs7q1at599139e8mTJjAd7/7XdLpNPfeey8FBQV6qvFf//pXvvvd79LQ0EAsFtNH/I+2zk9rP4/ls+zvhqr5NGjlWtkE4ZGO39SpU1m2bBm1tbW8/fbb3HjjjbS1taGqKsXFxfz+97/nc5/7HDt27GDJkiU0NDQcUQE63Oto+3E0r8h4PE48HtfLpbIJvCMdl2M5fqIo6uSjx+PhySef5Pbbb9cHR44Fx3ueaISjVr4+tKz/SNv8z0KIj+DjQxAyA46pVIrc3Bwkk4mpU6fi8/kZN66WK664nJqaaiZPnozH4+HSSy9l7ty57N+3n+bGRpLJzL1MkiQMRgMmk5FoNIrP5xscrCyitraWU045hf/4j//g9NNPx2q1sm3bNt555x26uro46aST+I//+A9mzpxJQUGB7uecn59PPB7HYrFQWFjE1KnT9NLPt99+m/r6egRBwO/zMWXKFEpLS+no6CA+2P7YvXuPfr6PYASfBZqamliwYAFtbW0IgsDYsWPZt28fTU1NFBUVsXDhwmHvs5od0Jw5c5g0adIh7cWamhpmz55NbW2t/nwSRZGtW7dywQUXsHDhQkaPHs3o0aPZt28fl1xyie6fKooiXq+XyZMnM3XqVKZOncrkyZP1MuVx48bxxS9+kba2NlpaWsjPz6eiooKTTz6ZMWPGUFBQwPbt2/WB19zcXCZOnMiUKVMYO3as7tM4adIkpkyZQm1tLXa7nRtuuIHZs2fz6KOP0tbWxvjx4ykqKsLj8XD99dcTiURYuXIlJSUllJWVYTab6enpoaamhtNOOw2j0Ygoitjtdpqbm7n00kuZNWsWDoeD1atXU1NTw5QpU5g2bZq+fyaTiS1btnDxxRdjs9kYNWoUM2fOZNKkSSxatIh77rmH+fPns3z5crZu3YrH42Hq1Kn86le/YseOHfpyNYJRg9frZcqUKYwfP14vkS8oKGDKlClMmTJF96gcO3YsEyZMYOrUqVRUVOj9Mu0ZPHXqVPLy8ti2bRtjx46ltbV1cCAowZlnnqmnkI/g+KGook7eHa/qUCMrFVXAgHpQmMxwQTSHg5Zc/Un9Hj8uNK9HBeGgpOuhkFDxKyYu3vptVvzXyRSu6oVEAgQBFIXqp7owbW9CKczFGFcxBVTi1QnkDhulyw0Uv9ePe3073jVRnK0q1l4VR4eMeSCB6AsiRBNYBpL4R1mo/4mJ3ktihKvTGBIgW1TMfSKGpflUPQRpm0jaYcDSHSWZIxErlVHCEt0xJ91RJ3sbiwnHMwrxftnOXQfOYX9/ATIieaYol5Z8CEB7Mpdyu48dwRLSqkhrPI8iKcBFpVvoTOWwI1LGq92TGOXuwy3F2dxXjsWQoi9uJxY1kfKksVuS9O/14HTEKB7bi92aZCBmwygoxGQTpWYfDkOCDwJjqHtzDGJSwDwgIFtVvjxnA6fZ9h9E2A0lAzUfR4DUMZyiIhmyUQuB+VeD8bPegH9XDPUU0TrzqqoSiUTo7u5GVTMpavF4htTTwl+sVitms3kw+dmGKIp4PPn4fAOYTCYCgQBer1cn6nw+n+7nJAiZ1GzN26S0tJRoNJrxdFMULBYLqVRK92WSJImTTjoJi8WCy+XSRy811aPXW0RbW5ueiKd5/LW1teFy5+B0Omlv34vVamf69Ols3rx1MJk7RU6ui+LiItzuHCwWC5FIBKvVAogEg5kR0VQqTTQSQyWjJkomErS0tGB3OA4iDLRR2Xg8TjwSxe3MhMp0dXWRm5uL2+0mkUgwMDCA3+/PJO/JMna7DbNZwmTKob29nfz8fPr7+wHo7OzEKJkJBHw4HHbi8Tj79u3DaDTicNj1hqHdbqOjowNvURF2u01vOIVCIcrKyvTf9Z+9g+90Opk0adJBn9ntdjwej/75t771LW6++Wby8vJwuVzccMMNzJs3j7lz5wKwePFiJkyYwOWXX869995LV1cXt912G0uWLDmkDOnvjezfqby8nCuuuIK7775bJ8o8Hg8Gg4Gvfe1rvP3227z11lvcfffdLFu2jEceeYTrr7+e119/nUgkwn333Ud5eTkGg0EPFRou4OPTwicdPT+az+HhPtNes2bN4pFHHuHqq6/mjTfe4Hvf+x4PPPAAXq+XiooKHnzwQb71rW/x4YcfcsMNN/DII49QUVFxRAL0WPbzWPZbM+g3m80HpUMfiaw8VmjLMBqNnHPOOQDccMMNPP744wiCwF133YXD4TjqPg63zsOdP9r2a99rnrJHI2JGFBb/PtCe5Yqq4PHk43I6icWiTJ48iZKSEoLBEFXVNbS2tuL3+/F6i8jPz+eWW25h79691I4dw1/+8hdmzZrFggWnUFlZwbXXXqsPSGpextq6AObPn6+fh9p1rSjKYHn3wQNxmXaFQk9PL1arlWnTplFRUUFDQyN2u0P3qasZVD1Nnz6dZDJJR3s7TqdDT74eIdJH8PeGqqrU1dVx6qmn4nQ6aWtro7i4GKvVyquvvsqCBQv0gMKh0FTy2nKGQvM3z0Z7ezsffvghDz30kO51vW/fPtra2pgxY4Z+DWjL07zIh9vuSy65hNdeew2bzcYHH3zA+eefTzKZZNGiRbz66quZCp/mZt23WxMFDPXxzl5mbm4ut99+OzfeeCMPPfQQ06ZNo6CgAMiE911//fX86Ec/oqurC0EQ2L17N+FwmBtuuEFfriAIfPDBBwQCARYtWoQkSSQSCTZu3MjZZ59NSUnJYAhmIfv27UMURcrKypg5c6bedjGZTOTm5pKbm4vX66W8vJyf/OQnPPDAA/h8Pq6//npmz57NT3/6U374wx9it9tZsmSJrhDVVKPDHT+TyUReXh65ubnH1EZxOBwsWrSItWvXsnjxYoqKimhvb0eSJMaNG8ef//xnuru7qa6uPuKyRnAojIKMjOG4ST9FFTEI8kekoWrIEJfCRz6O8iAheSScyNCaT4qhydhD0So7+PG+C3E84ca5sxdUFSQjgihATz+C1QoOO4rJSNIpksgRKHvFiGt9C6rdCkYDsjcX2WJAkFXc9SnMG/eD2QwWM/6ZRXTPhcJxPeQoIn0NeRijIoYYuBtUXLt9KDaJRIEFR2OYlNtC7yw3gbEwZnwrAzEbB/YWY8hJIoaMjK/tJq0aeCs4iWjCxDmVu3AYEuwOF2MRUmyKVOFP2SgyB3EYEkywdSAjcpKlkaa0h5bQGLb6ypiW24bVkOLD/kqsxhR7eoqIhQbtwtICfd0uhPwkFlMKAYjGTUiSjCTKnOLeS32iiP9rnIL6QS75+9L0TTGScqhMOLmBb+V9AHykchxOgZjtrXg0NWS2Z6NGQP6rYWSI+DPCcB1m7YGZKaWWsNlsFBYW6ol3e/fuxe/309PTo5dbS5KJZDJJIBDA5/NhNBrxeDyk02mMxkz5bywWI5lM6mWEO3fu1D/TVJKSJDFv3rzB5MvkILnm0Em7nJwc7IOeiB6PB7fbTTwep7+/H5fLRW9vL11dXXpps7ZPTqeT/HwPiqIwatQorFYrPT09JJNJHA47gUCQdDqlp2OnUimi0SiSJOHxeIiEI4RCITo7O0mnUsiKgtliJhKJ6Ab2NpsNh8NBYWFhxkDaYsHhcOhKxmAwiMlkAiASiejl54KYKSP3+XwUFBRgt9vp7+8nLy8Pp9OZUV0aBPr7++nu7kaSjCiKTCQSxmAQKSzMx+VykpPjpqK8HI/HQ1dX1yBZHKe6ulovr/l36eT/7ne/49xzz+Wiiy7i1FNPxev18uKLL+rfGwwG/va3v2EwGJg3bx5f+9rXuOKKK7jzzjs/w63+CFoj0mAw8PWvf51x48axceNGnnzyycESf5WcnBzuuOMOKisrefXVV3n00UeZM2cOjz32GJMmTWL16tV84xvfYO3atSe0rPaT7NOxNI6Hbmd22a42cn80MktblyiKzJw5kwcffJAxY8awfPlyvvvd7+pl9TU1NTz44INMnjyZ1atX893vfpeOjo6D0sGPdx+PtG9DpzUYDPp+ZSd5D92PjwNt/0VR5Oyzz+a3v/0tubm5PP7449x111268f6JRHa5+3Cfj6gb/72hnRvJRIJoNEIwGCQYDCHLCsuXv85bb79FW1sbvb29vPveezQ3N5NMJkmlUlRUVDBp0iQmjB9Ha0sL765YgSfPw6hRo/B6vXpgzVC1kHZtZSuJtXNQG5zLvsekUulB77dtbNu2jebmZtrb21m5ciXLl79GV1cXqWQSyHitlZaWMra2lsqqKqxW6z/EvXYE/17QwpPq6+ux2+1MnjyZxsZGTCYTdrudNWvWsGjRoqPaXRzrwLQsyzz77LNUVlYyefJk/bOnnnqKL3zhCweVVWvPocOtz2AwUFVVRUFBAVarlZaWFlKpFD09PVRWVuJyuUgmk2zcuPGYbIKyr7+amhp+8pOfkEql+PWvf83AwID+3eLFi7nkkktYuXIlra2tFBcXs3DhQs4//3yMRiOCIJBKpXj33XeZNm0atbW1qKpKX18fLS0tuN1ucnNzaW1tpbKykubmZvbs2cOiRYsOO6gnCALFxcX84he/YNasWfzP//wPd955Jz6fj7lz5/LLX/6SF154gaVLlx6iPDxW/8cjTSMIAqeeeiqbNm0iEAgwduxY9u/fT2lpqe7tqXlej+DEQFMgKqp4SJmzjIAkyEiCgigMr5Y8koIyO2BGW172tMP9n63KHLrcocs6ZBmDSkxNzTiUWFSGzKO91xKvDUKmBHtbrBL5L4W41reCL4gQzZzrQl4uAKnKAsJTiokV21AFyKlPYW8OgyxD7wApj51IuQ1EAc/7bZg3H0Bwu1CLPXSeW07f+TGuPOM9Rrn76d/nAcB9AIrXhJDCMn2zc0k7TRhiCrJVIlIsMTBNwTImwP62Qgb254FJQQ5LmEojKKrA6vZqVnfXYDQodCbcbA6U88HeUTzdlQmXaY3kEJMlcqUokpBmrrUBp5iiRuqj0BTk/OJtWA0puhMuGrrzaejOJxE3IfZLqDED9mYjyALFhX4cpiTtLR6UZjvF7iDj7F2sCtTylxWnYHvejaVPpXeqkdT4KDmzevll5f9hE1Rsgnbcj41UUziYjDwaslWPBv75ycgR4vEfBNlJt5IkkZPjRpIkGhsbcTqdeAaTHVOpFOFwmGAwiKIoRKMRTGYzyWRS93K02WwUFRXppdTJZJLGxka6urqwWq00Njaye/duvTGUm5s76HGiYrPZiMViRKNRTCYTkyZN0r1lTCYTiUQSURSJRqOIokFXgRUWFpJMJunr68NiyYS1hMMRRFGkuLiEkpISYrGYvqx0OtPJyMvLpbCwUC+tLi4uwWazEQ6HEUWRMWNG43Q6cbvdSCaTXp6gEYkZo/skdrsdVc2oHtVBVWhfXx9Op3NQGZpRSCqKohOmqVRK9+Pr6+sjNzeXeDxOOBymoKBgsAGUZGztGPLycvXUblEUiEYz6eCCAMFgAIfLSV7eoEltJKJ7Zmlkr/b3X63z/9577/H73/9ef2+xWFi6dCkDAwNEIhFefPHFQ7wbKysree2114hGo/T29nLffffpqsBPihPZ8SwqKuLWW2/FYrHwu9/9jg8//FDvIEyZMoU77rgDk8nE7373O1599VWmTZvGY489xvz589m5cydXXXUVf/nLX4jFYgclUx6Lz99wPkNHmu5w8x5umuHmzyYBZFnWy3a18zeboDvcdmWr8kRR5KSTTmLZsmWMGjWK5cuXc9NNN+npnRMnTuThhx+mtraWFStW8P3vf5+enp5DlOAnCtr+aUoGzTtrOCP/T+rFqJ0nRqOR8847j9/+9re43W4effRR7rrrLv3+/XHUlNnryC6r1n6jbK+7Yz2PtGmPhl/+8pfMnj0bp9NJYWEh559/Pnv37j1omng8zpIlS/B4PDgcDi666KJDfF1bWlo455xz9MG1W265hXQ6fayHYgTHCe18jMXipNMy0ViM5uYmjEYDZ599FvUH6nnrzTdY88Fqtm/fxu23/4y1a9fw7LPP0Nvby//+7/8iKwqFhQWMGjWKffv2HUSWZKttNbWVZmuSfd8bes5n32fMZokZM6ZxxRVXMGnSJHp7e5HlNCaTRHFxCXPmzKG9vZ2Ghnqi0QgWs4ma6kqMBsNBhMsI+TiCvxe09rUmBHA4Murbrq4uCgoKyMvLo7y8/LBtvqGE/NHQ39/P66+/zle/+lVdRblu3Tr27t3L6aefrhN3w61nOELOZrNx8skns2/fPubMmcO7776L2WwmGAwyf/58urq6qK+vH/baHdqezR5wE0WRefPmcfXVV7N+/XqeeOIJ0uk0BoMBi8XCOeecw3XXXcfTTz/NM888w+9//3uKi4sPum9oStL3339f97DMy8vD5/MRjUYxm816kMuOHTuYNGmSbjcydN+1ypPy8nLuu+8+5syZw0svvcQPf/hD2tvbmTNnDr/4xS/4v//7P37/+98TDocPuncNPW5H+v9wx76iooJIJMLatWtxOp24XBkfeUEQmDBhAnV1dSP3ro8B5TiUjocj9g5a3nEkVQ+nstRISW05n6T8Wtb8HlXhsMnVR4JGUEYVIylV5IEdC/C814ri84Mik6oqxLd4LJHaAuIza4jnm0hbRUz+FBa/jCoKRCodyKX5xGfWECsy4dzRi2VzI6rThu/z4wnNKCE4LgffZBmrNck73bWsXz0ea5dIzYspit7pRAzHUSSBnIY4iiSSthkI1lgJVYrkVPhRNuQAYK8O8OWZGxHDBmoLezCJMpGwhd4BFy5LHF/CRlyW+PK0TVQ5+kmpIuV2P1PtLUy3NTHR3IFTSBNXDexIlOI2xNgb9dISy2XngJep5W0YJRmlz4xalACTQqQmhRg1kEwbaejIR4gZyJ3Yx+kF+wjJFlasmYylVyTpFAjWQKJAJscV5d5xz2MXFRQOJgKPRiZq3x8uTGbo/Ecqtf5nTY0YIR4/Iwz3oNI6i8lkkmQyBaATcGazWSfGfD6f7iEoyzLBweACg8FAOp2mv79/0KOwGJPJhMvlQhRFrFYr8Xgcp9NJY2MjTU1NiKJIU1MTBQUFJBNJPcTDarXgdDrp7e2lvb1dnz83NweDwaCrvwYGBgbToHuRJIl4PI7VasXlcmE2mwZVjw6cTgc2m41AIICiKDidTnJycjAajXoJuCRJmEwmnE4niURCD62xWCzk5uQgCJl0XFlWyMlxY7PbEQSBvp4e+np7CYVCGA1G8jweiooKGRjwoSgKyWSS5uZmSkpKSCQShEIZA/BEIsGePXuIRqOk02m9BNtoNBKJRCgvL0cURCKRMF5vIaqqEgwFKS0txWQ2kkwlsDuszJo9E4vFRDQa1r02bTYbZWVletnjCP65oBE5mnqzr6+P22+/XS8PkiSJCy64gOuuu45IJMJPfvIT1q9fz6hRo3j00Ue57LLL8Pl8/OhHP+JnP/sZXV1dx000HSs+Dkk2lJRMp9P4fD7WrFnDgw8+yK233sq3vvUtvv3tb3PLLbdw//33s2LFCjo6OkgkEoekdw/dFkAn3ubOncuyZcuoqqri5Zdf1kN4ACZPnsyDDz5IRUUFf/vb3/jhD3/IwMCAThJmb+sngba8bPVV9nZqHZ4Tgezt1To8X/ziF/nNb36D0+nkkUce4e6779bDuT4Oso9Pdilr9r59GufbypUrWbJkiR4gkkqlWLx4MZFIRJ/mpptu4pVXXuG5555j5cqVdHR0cOGFF+rfy7LMOeecQzKZZM2aNTzxxBP893//N7fffvsJ3dYRfAS9/BIoKiykqqqKU075HLKcZv369eTm5rBp00bKy8soLyvlpptu4qqrvsOvfvVrmpubcefk0NjYyNatW2hqatKXm30fAQ45J7OvsezzUZZlfVBDVTP+zIqiDIbm2Zk7dy6pVIpEIoHb7aKsvAzJZKJ23DiqKqv478f/TGdnO8lknNrasTgcjpHn7Aj+7hBFUa8QysvLo6urSyeR+vv7qaqqIicn57BK9MP9fzgi8oMPPkCSJBYtWgRAX18fv//977n00kvJy8sbdhBt6P/ZyxZFkfLycjZv3szcuXPZsWMHBoOBjo4OqqurmTVrlk48DueBPNxys5d98cUX8x//8R889dRT7Ny5U79GZ86cyc0330xBQQEWi0Xv+2ge0iaTSa84+fnPf86uXbtoaGjAarVSVVXF7t27qaqqYs+ePXrZspYGPpzKM3u7vF4v99xzD6eeeirvvfced9xxB93d3Zx66qnccccd/PWvf+X3v/89oVDokPvb8fx2Q4+7w+Fg+vTptLS0EI/HmTx5MnV1dRQVFeH1etm6deth21UjOH5oykJRUP5u5dAGMspECQXpGNZ7JBJUIy818nFoYMyxIqWKxFUjX9/2DUqeMKOGwwhGI4LTgSqAvTOJFE5jSMjIJgFbZ4JosRnZLGKMyRjiCmI4gaVpAPfaVoRkisSUKlSTkZxdfhz7/ZgHUojOFPGdOaQe9lLxehJ3g0zaYkCVjAiJFI49/SCrCIpK0ikSKhdI21WC+3OJVqcgIGEQVF7cMw3VrOJPWNneXYLdEaeswEdv2E57yE0sLTGQtLPH76XAFOa0nDqmWdrYGy9heWgKHbKNFZFxdKRy2B4uJ6WKSIKCy5Rgd7cXcbMTMSmgxA2Y2yVMPUYUs0JflwubI4FqUrCbkrzaMZGnVp+Ms0GkaEMCKQyMjVAyppclo99jjDHTfhf51/Rh/DQx4vH4D4LsRnoikRgsRXZQWlpCY2MTgiAQCoXIz88H0MuLBwb6cDid2O120ukUNpuN4uJiBgYGyMnJIRaL0dHRQTgcpr+/n66uLsaPH8+kSZNIJBL4/X6Ki4sJBAJEo1E8Hg9+v5/u7t5BIk2irKwMWZZpbW2lvLyUcDiMyWTCYjYzMDBAQUEBRmOGcBNFkUgkgtfrJZWWaW5uQZYVFEXF4/Fwyimf47XXlgMqqppRx4RCmWTpsWPHEgqF2bBhI4KQMcOX0zIWixl/IIjZbMZms5FMpwkEgh+RBYJAWpZJJlMYjEbisTi7du1m+oypug+k5uVmMpno78+MktqsFnp6evQUOlmWkSQJi8VCf39/pvzakSE3t2zdMuil6aG9ozUz/6CytLi4mLy8PKxWK36/n1gsRigUwuPx/EupG/8RkW1RcKKgXYuiKGKz2fv7TxQAAQAASURBVPjRj37E9u3bWbNmDXfddRe/+c1vsNlsmEwmvve979HW1sbTTz/Nddddx5/+9CdmzZrFfffdx8SJE/nNb37DY489xpYtW7j99tuZP38+JpPpEPIre90fZ3uPZRnDlVKn02laW1t59tlnefHFF9m/f79OLGrHVVEUnUDzer3MmzeP8847j8997nPk5+cfpFYdbt0a+ah5Pv71r39FEAR++9vfUlBQwOzZs1m6dClXX301L774IhaLhV/96lfk5OToZOHhfuNjKbHW7hNDO07Z/4uiqCscjlXJMNw0h9tOk8nExRdfDMDNN9/Mo48+iiiK/PSnP9UDBQ63f0M7Pdnn/NAOTrbyLJuQHq4jeyzbPRSvv/76Qe//+7//m8LCQjZt2sSpp55KIBDgT3/6E0899RQLFy4E4PHHH2f8+PGsW7eOuXPn8uabb7J7927efvttioqKmDZtGnfddRc//OEPdRXxCE48RFFETqfJL8gfVO4bsNvtSJKk+45pyi3tPItEInzuc5/D5c5hypSptLW20N3dxZ49e6iurta9FTVoaiOz2UwqldKXlZ1an7187W86nSaRSOiVARaLhblz57J27VqmT5+O0+Vm586dlJaWYrFamDVrll7iqiiZ+UeetSP4LJBIJHRF2+bNm5k3bx6iKHLgwAFKSkpOyDpUVSWRSPB///d/nH322eTk5JBOp3n88ccxGAz6vTYbR7setGd7WVkZ4XAYi8XCmWeeydq1axkzZgzxeJwFCxbwwQcfEAwGycvLO+6KHbfbzbXXXktjYyMPPPAAf/jDH3A6nQdVUDQ0NLBixQqSySSnnHIKtbW1mEwmFi9ezNy5c/nBD37ACy+8QH5+PrFYDK/Xy9tvv82MGTOIxWJUVFRQXFysl1kPNwCR/XzTfqtf//rX/OY3v9EHPG+//XZOOeUU7rrrLn784x8Tj8e58cYbyc/PPyH3FqPRSGlpKXa7nba2Nqqrq/UBbk29GY1G9UDMERwbxMOUOGe/13wcP/Y6BPW4lJDZBGF28IxhsEz6eAnEbIJSC5A54vYOfp9CxC6kuXjTN6i6Ow1qKOPHCMgFbmJFZsz+NMZQgrTLTMou4qu14GhPk8g1EKwwU7gpBv0+BKsV1WYhXpmLyZ9AMRlQJRPG7gCWpgHKn8rH0hvC0N6HUpBDtCgHa3uIlNeJIZIi4cl4KoZLJBK5AmY/mFqgfypIziSGXAV/jxNkAdGdJBCzkEwamF/VwprmaszmFHnWKAMxG5uiZUwvbGe2oxFRUPifgXlsHijn62Vr2BqvxGmIkUo7OBDKZ7SzjzQGGrrzsWyxEamSkfJjkDaQKBIw+o0gquR7g6RlkZLqPsyGNE31RRSvFjDG0/jGmnGe10mFMU2Ns49p5laiasavMbu8Wvt7LBIGw1FOgWNRBWp+kEf7DD5SZcpDpvss1Icjisd/EGR3EmOxGPF4jM7OTux2O16vF7fbDWSIukgkopctl5SU6L5HDkdGVaj5l2llz6FQSFcXdnR0kE6niUajKIpCXV0dubm5qKpKb18vNpuVmpoaPRxEC1vRykhUddCkXlGw2+0kkymamppxOp34/X6SyST9/f16mE1JSQmynCYajWE2mykq8uL1FtHa2kZra4s+2tnW1obP5xssgTRTWFhILBbDaDRiMBgBAa/Xi9FoxOlwEAoGCQ4mfGdIgzTeoiIcDjuKnNaVk8lkEkEQSCQS7Nixg33792MeLE2PxeOUl5eTSqXo7e0lmUwSj8fp7OwkHo/T3t5OLBrD6y0iNzdH/14URSTJQGVlJVVVVbjdbqqqqigsLMRut1NbW0tpaSnFxcWf4Rk1gk8CreFnMGR+51/84hcUFhbyv//7vyxdupRkMomqqrjdbu68807OOussGhsbWbJkCZs2bcJqtXLdddfxxBNPMHnyZDZu3MjXv/51fvOb39DV1aUTe59UpXO4jsCRyEeNiPP7/fz5z3/mi1/8InfeeSf79++nsrKSL3/5y9xxxx0sW7aMpUuXcscdd/CVr3yFiRMnEggEeP7557nyyis599xzeeihh2hrazvs/mjboXnILl26lMrKSl566SVuueUWXe18yimn8MADD1BQUMD//u//cvfdd+vlyMerRMzeDm27spUQw5UsA8N6PR4vDqdW0dLSzz//fO677z6sVivLli3j17/+9UHKimPdt2yV47HgaOrH4+1QaggEAgC6zcSmTZtIpf4/e+cdH0Wd///n7O5sb+mNdBIIEKrSBFFExYIFznZ28U5RUBQFwYaiImJDBU85z3ZfzxPriZxiQbgDkSZKkRogkF63953fH5sZNyGhiaj3y+vxyCPJ7pTPzM7OfD6vz+v9eoUURQ7EAgVycnL45ptvAPjmm28oLS0lLS1NWebss8/G6XSyZcuWdvcTCARafAl/+unEkUP5DqhVuFyxMsKzz455rf3xj3+kuLg4Zmciiq2+J/Lz3ul0IAgxf+j6+npKSkoIBoMK4RevctJoNMpEnlx2GR/gJD+P5YnKeJsA+X15kmP06NHodDq2bf+R7Tt+5J///Cd79uwhEomSmJiI0Whk9+6yzoF6J0445Gva6/Uq/XG73c7+/fvp1asXX3/9dbtE2LFcq5FIRPF5v+CCCxAEgeXLl7No0SJuvvnmVmTVkW5fJuNSUlLwer3s2LGDU045hbKyMkwmE7t37yY1NZWGhgb8fv8RWbe0h7S0NGbNmkUoFKKsrKxVO/fs2cPEiRN59NFHefrpp5k0aRJvvfWWUu1ks9m45ZZbWLZsGR988AH79+/n6xYP2u+//55QKKSk3tfW1lJRUUFNTQ2VlZXU1dXhdDqVidS2IXJpaWlMnz6d8ePHs3nzZiZNmsT69esZMWIE06dP54MPPmDOnDk4HI6Djv1Ijr89GxpZOCJ7Xnbv3p0DBw6QlJREQ0NDq8qBThw5QtLBrnfxJGRbZaFMBMbUgGqCqFr9xEP2gFQJUqttxSMqxbbVnpdk2+XVwsH+jvHEpExUyurJ9o4nGrdOPImpiiNYowjURUzcf2AMbLEgiWqEqgYEUSTQM5uoRoWhPojoCCAEIngytDgKQYiAJ12DqSpI1tJ6xK37CBd3wXlyFk0npxI2q1E3ulEFI6hd/lg4jceHaeN+1I1uJIsJwRvAvtVBc087nnQdEYOIK0fEmyaiCoOpKoovTaKhN0STQ0SjKkJBDQO670FlCiFqw4iaCKIYYfmOItTqKF0T66lyWfCHNAzLLGOEfRufNfXivvUXsbyqKxohyoFgEt6olrqwhZCkJtfcSCCq4auNPRB/NIIEQlDAsNKMuMOA2KRB2yyANkq2tYn8hAacPj07K1JJ2KhGFZLwJqtpPinI6ek7uDrrGyakfE2aOhR3zo/Or/FYEO8JKROHh/J5jL+Cj4gEjf/7BHSlOhWPvyLaU6rIA0S1So3FbKahoRGNWk3A78dmtSFJUVRqDU6Hgz1le5CiEXbvLiMSCdG9ezdSUpIQBAmtVsTvj2I0GrFabVTX1JCQkITT5aaquob8ggJsdhsIEnX1tYTCQVLTUqhvqMdoiJVGxzwkvQrhGAtsUQMCTqebqspqEpMSqayswecPodPFEqLr6utISU0hEolSVraHlJRUPB4vDoeDLtkZlJR0Z9nXX1G+r5xu3YpJTEzG5XLz7bdrKS0tJTMzE4fD2ZJUrQUBPF4PXq8PrUZDclISbpcLr9tFNAKhoI9tP25mwEknUVJcROWBCgwGLR6Ph9SUVLZs3UJCQgIer5dwJAIqNWaLheqqampq6hCEWDr1nj27QYiiVscGT6FQCBBYt2Y9WVnZuJ0e/F4/KkEgKSGBvPx8UlJSYl470ShJSYns3h0jMJKSktBqtcddjdeJ1jgUYfJzz7s8aFCr1cpM+JQpU3jqqadISEjguuuuQxRFMjIyeO6555g4cSJffPEF48ePZ968eQwfPpwRI0bwz3/+kyeffJK3336bOXPmsHTpUqZPn86IESPQ6/Xttvfntr2jWX+ZyNuxYwf3338/S5cuRa1WM2LECG666SaGDh2qlGy1LZP0eDzs2rWLpUuX8t5777F9+3amT5/OK6+8wvjx47nssstITk5ut9wLYjP+w4cPZ8GCBdxyyy1K6NBTTz1FYmIiZ5xxBs888wwTJ05k4cKFGAwG7rnnng5TOQ93/G195+IRrzhtq3yM94I81OcQrz5su9329gU/KR8lSWLq1Kk8//zzSJLEPffcoygf27YvHjKZc6RKzPg2yqrPjtp5tIhGo0yePJlTTjlFSbWvrq5Gq9UelHqalpZGdXW1skw86Si/L7/XHmbPns1DDz30s9v8/ysEIea/plFraGiox2az4vXoKCws7LA0EcBisVBSUsJrr71O9+49ELUiNquVpqYmJaE6nvTQ6XSKOitedRtPlMv/y9ek/Jrs0yirj81mMyaTCZfLRSQcZsiQoWRmZPL551/Qs0cJTU2NBAJ+xdKk8znbiRMJlUpFOBzG5/ORmpqK2+2mR48efP7554wcOZKMjAzFuzwex9InFASB1atX06NHD/Ly8igrK+ORRx5h+PDhDB48+Gdd+xaLBb1ez4YNG+jWrRt9+/alrKwMs9mM1WpV7Iratv1Ij0NWGPbo0QOdrLaKRFCr1SxZsoTExEQefvhhVCoVy5cv5y9/+QvFxcUMHToUgKKiIrRareL//NRTTxEOh/nXv/6ltCEcDnPTTTcpoVWCEPN1tFgspKenY7fbSUlJITk5WfF1NhqNGAwG+vfvj9fr5d1332Xy5MnMnTuX888/n+3bt/PGG2+QmprKbbfdptzbDhew1xHkiqkDBw5gMBhoaGigS5cubNu2jZKSEtRqtUK4duLIEW0JioHWBKNM3sUIRjWiEEFLVAmcUQuRY1JBKuscw/y0ColIC0kJIArRDtsQH1jTURhNW8SHyohClL/XDaVidhEF63YjhcMIBgOhLkmIriAhqxZJAH+2Cb9dRcgsYD4gkbDdi1jVTNRkQNKo8AzvSvVANfbtEDZAyKRGn25D0+BB0mmQRDVSkp2IRYem2UvEoids1uLJEHHlqDBVSURFFVqnhC9ZRcgMkkrAvj2KK0eFN0kgLSk2gb1+Zx5irUg4249KkAgGRAymAFajn+11qUQiKvKSG2kMmviwth+bKzOQJAGjGCIsqQhIGvro9+GJ6mgMm7GLPt5ZezLGfRoiBgl/ShTbDjVhI4QsUSQ1RJMkklNcNAWMVDVZCQU1WNYaSP7BQ83JJlz9/YzpuYnzrBtJUgUA8Esxci9eNfhb9lts2zY1PxGYvzRp2h6OinicPXs277//Ptu2bcNgMDB06FDmzJlDt27dlGX8fj9Tpkzh7bffJhAIcPbZZ7NgwYJWA43y8nImTJjAsmXLMJvNXHvttcyePfu4BUz8HhFfeiSKovJ6NBolHIpgNBhB8hIMBtHpdVgtVuw2Gz6fj6TEJJwuB36/D1EUUWsE1GoBTViF1+sjP78Qt8dHMBgmIyOT2tpa/vOflVw89kKKuxVz4MB+ItEQBoMes9lCZUV1i/mxjfr6ekaNGsW6deuora2lV69e5OcX8sYbb6BSqbDZE8jM6kJtbR25ubn4/B70BgNle/aQkpyKyWRWyqxjnmYSFquJ3NwcklOS8Xi8mM0WUlJSqKysZMOG78jIyCAQCNDY2NgSDuMjGPRjNhnR6/XU1tWj02jQWMyEwwGQBBrqaiESZuBJJ1GWkEAwGCQ5KYmdO3fQtWtXyvbsobG5mYgUxef3E46EiEoSBw5UYDQacDodaLUaIpEQolZNc5MTvd5Egi2J5kYnm77fgt1uw2I1U1dXg8/nJ+D3o9fpCLUkdDc01CtJ2oMHD1bCfTrx+4X8vdRoNFx66aVUVVUxZ84cHnzwQQwGA5deeqlCPr7wwgtMnjyZTz/9lD/96U888sgjjB07lqysLB5//HFGjRrFI488woYNG7j22mu58MILmTRpEt27d1cUP4cjsY4V8iA/FAqxdOlSZsyYwe7du8nLy+Puu+/m4osvVkqg2tu/Wq3GarXSv39/evfuzQ033MDXX3/NX//6V9asWcP999/PokWLmDp1KqNGjVKu/bZEl1qt5tRTT2X+/PlMmDCB999/H7VazRNPPEFiYiLnnXcefr+fO+64gwULFqDT6bjrrrswGo0dlgzHH6OMtl5zbY/nUIqF+LJreb329nm4kq6Otq3Varn00ksBmDp1KgsWLADgnnvuaZncUR20rXiS5miui/jzHu9z2V77j1bpeeutt7J582b++9//HtV6x4Lp06dz5513Kv87nU6ys7N/8f3+L0EQBEStSCQaxma1sGvXLqXcr6PrW5Ik7HY7o0adQXp6Gsu/bmb9unV4PB5uuummVpMM8qSp7NUIKL7TbYlHOQE7noSU/c3kbcpq5cbGRmpqakhJTQUkcrKzsVqtfLz4X1RVVVFdVc3pp59+1IqvTnTi5yCehJIkSUlDzsrKYufOnRQVFXHgwIHDJlofCfx+P0uXLuX888+noaGBxx9/HEmSuPnmm1tNXh4LtFotRqORpKQkvv/+e4YPH87f/vY3hg0bRl1dHSqVSiknP9bvlkxearVa5f4QDoc5cOAAc+bMIT09HZVKxYUXXsirr77Kjh07GDJkCIIQC6M877zz2L59O3q9Hq1W2+q+094EoPzsjkQiippz5cqVuN1uJcxKnlSWf2Shxe7duzn11FO56aabKCsr46233uLCCy+kqKioFel4uGd9e5UVFosFl8tFbm5uK39HQRBITU3F6/V23r+OElFJhRqptepRaE2lyMRdkNiy8vvxCsijQdsU6yNFqGX/kRZisEMCsaWsWy10nKx9KOwOJfH3miFs/qwbGd4AgZIsKk/Rk7wpjMYTIapTUddbxFAv4ckQSNoSIfk7FyqHh0iyFW9xCp4MkYa+EqY8B6EmI8EqHRqfhLkqjCSqQCUQTjDgTdXSUKoi3NWHVqsjGFSTvEQkYFUhnOzA9YMNjV/El6hCiEiETRAVwVGkwp8VQtBEqaxIBJWEWh9G182L36fF5dOhNwSxGvz4giKpVjcpBjd6dYgt9emoVRIhp46UrGYyTQ4StV5K9JX4o1pWOLqzri6b2t1JqCICUS0EUiNo69RENRC0Smi8AmEDZPauJiIJ1LtNBBx6iII/WWLXZQZySioZaKvjqqRVmIQwKmLl1QChuI/lt0w6QowYjS+1lknH+HAbtfATmfpL46iYPtlY/uSTTyYcDjNjxgzOOusstm7dqqhS7rjjDj755BMWLVqEzWZj4sSJjB07lpUrVwI/Gcunp6ezatUqqqqquOaaaxBFkccee+z4H+HvCPIDp7GxEa/XEyMZdTpUwk8PRTkVDlAe4DabHYfTgdfra3kYqtizZw9GgxmVSsTt8eB0ulrUiiBJcODAAaqqakhNTSEhIZGqqkqam51EIqBWa+jatQiIldCFw2G+/vprSktLGTBgAEajAZvNRk1NDStWrGDUqFGoVGoMBgNNzQ1YLCbFo9LhcOH1egmFQiQmJrJ37158Ph8ZGRk0NDQoJQfRaBSbzUY4HKaqqkpJrZNN6PV6PRp1SwlXOIzNZqOpqaFlmTD1dXX4fD7MFrOSHheNRslIz0CKxpSfLmfMJ1JCQiUImMwmTEYjTqcLi8VCVIq2eFw6sNlsuN0+amvLlZTu+oYG0jPSiEQS0elEbDab0na5Y2Y0mjAYDNjtdmV2t7Mj8ftCewSMPCEwYcIEvF4vzz77LPfccw+SJHHZZZchiiKZmZm8+OKL3Hvvvbz99ttMnjyZ7du3c/vtt2Oz2Tj33HPp378/L7/8Mq+99hpvvfUWX3zxBddccw033HADWVlZR11CG9++tu2PPw7ZwuHVV1/l0Ucfxel0cvbZZ/PII49QXFx8UBJyvPIvEAhQW1ur2BHYbDZSU1O54IILGDVqFEuXLuXZZ59l48aNjB8/ngsvvJC7776bgoKCg8KV5DLKESNGKMrHRYsWoVKpmDNnDomJiYwdOxafz8e0adN45plnMBqNTJw48YiI/HhPw/aUJkeKeLVW2/N7rIgnEdVqNePGjSMajXLPPfcwf/58VCoV06ZNU9JKOyIdj6Yt8cfcVmV2rMoNgIkTJ7J48WJWrFhBly5dlNfT09MJBoM0Nze3Uj3W1NQo6fbp6emsWbOm1fbk1Gt5mbbQ6XTK/bQTxwZ5EO/z+QhHIsrz9lATvqFQiO3btxOORBHFGEHhcrmor6+nrq5OsRNpT80YT3rHLxOPw5UtSpLEgAEDqK2tJRqO4Ha52LVrF9t3bic1LQ2P10ttbZ3im9v5rO3EiUK8LYDT6cRoNOJ2uykpKWHJkiUYjUZ8Pl+rZ9Kxora2lj179hCNRrnvvvtYtWoVc+fOpaio6Lhc86FQiOLiYjZs2ECfPn3Izc0lHA4rqdHtfbeOdr+hUIhgMNhqMtJmsynqaIh5xJaXl3Pqqacq9xJRFLn99tuViYn2yp3jn43yevHWKbLvelNTE5WVlezcuROHw4HT6VTGWRaLhQEDBnDSSScBYLVamTBhAldffTX79u2juLj4oGM60s9VbqtOp2Pr1q1K25qbm8nOzuaHH35Qjj9+crATx4aopEIVRz6KQqQV+RiS1LGa4kNA9nWMSgIIcWQgP5Veh1pIz/bQXqm3vC05eKYt8Rj/v0o4sv6q7OcYkNTohAghScU7dQPZ/WYxifUR9p+lJWyJYtoDfrsaUafCm6oiKoLOIZGyphlVTSNoNPh6ZFA5TMTSv4Er89ewzpHH6r15qOu1RAzgT4GQWcRUpSacp8eTKRDRA91djM7fgTOso8prI3qdQFejkz+krGN65GIcAQvmAxK+VAHRGeN9VSEI6zWE7QKmVA9aTZjmRjOeegsatwpvkogx2UtUEkg1uzGLATZVZRIMaNCILZOULjVGMUSWoRmAL5t7UOZKomxfKiqHBk1AQFKBZZ8EggbLHomwQUIVFlAFIZAc5kB1AqI+TLBZR2KmA7VKwpgfIhBRk2lycEnSGuyqIHpBauXhKBOQ7fk6Hm2p8+E/49bbirT5X0ZEgkNx6JG4dVTEyMaIdGLKq+NxVMRjp7H8iUEs8TXm39jQ0EhDfSwoRpbnh0IhZYCWmJjI5s2bqaqqwmDIoam5GbPFiNFoxOvxEgiE0Wr15Obmsm/fPrxeH06nE7fbzQ/f/0BBQT4JCQmYzVaqq3eh1RpISkyOKSfValJTU9m5cyf79u0jOTkZv9+P1+sjLS0Nh8NBTU0NP/zwA8XFxdTV1Skly7Lnisfja1E8xrwi6+vr40jJWKCNTC5arVa6du1KMBhk8+bNaDQaDhw4gEqlwmqxUlVVQzQapbKyii5dumC1WvH6POh0OtxuN1VVVZx00klkZ2cjSRL79u+HqMT+A/uhZdCl0caOy+FykWizKYnfIBEKhsjPz+eLz7/EaDSTkpKCqNHi8/kpLy8nLz+P6upqJClKRkY+Pp+PpqYm/H4/gUAAu91OVVUlXbp0aaXQ6sSJw/E6320JJ3kG3Ww2c9dddxEKhViwYAFTp07F7/dz9dVXo9PpSE5OZu7cueTm5vL888/z9NNPs2nTJmbOnEmPHj3IyMhg+vTpnH/++cybN4/PP/+cuXPn8t5773Httddy2WWXkZmZeUiVxLEcY1NTE7Nnz2bhwoVAjDiaMmUKiYmJrYgHWXkUiUSoqKjg/fff5+OPP2bnzp24XC4loCk5OZk+ffpw7rnncvrppzNs2DBee+01Fi5cyFtvvcW3337LjBkzuOiii1oRhvFkxGmnncbzzz/PxIkTeeedd1Cr1cyZMwebzcYf//hHPB4PDz74ILNnz8ZsNnP99de3Ip/a8886UlLtcL5b8YMYOYRH9qA73Pf6SAhOlUqFTqfj8ssvJxqNMn36dF544QVUKhV33303JpNJ2dfRlFcfDvK5aat+PFJIksSkSZP44IMP+Prrr8nPz2/1/oABAxBFkS+//JJx48YBsH37dsrLyxkyZAgAQ4YM4dFHH6W2tpbU1FQAPv/8c6xWKz169PjZx9iJg6EMfLVa/D4/LpeL8vJy9u/fz5gxYzoMiGpoaMThcGKz2dCo1ezfvx+dzkAkIlFdXd3KxzienGhrddD2/bbtavt3PNRqNeeddx6SJLFp0yZS01JwOZ0YTSYyMzKoqqj82UR6JzpxrJD7elarldraWhITE8nLy+Pbb7+lvr6ecDjcalxzLPdxt9tNMBhkzpw5RCIRbrrpJs4+++zj8kzw+/2KtUFBQQHr1q1jxIgRLF68mLy8PMWv9Vj6s/GTgDqdjgMHDtC9e3eFHOzbty933XUX5557LklJSXz66afU19czbdq0Vt9n2QtW9pVVLKnifGG1Wq3ynJT7AfJvuaw6PT2d7t27M2LECCKRCH6/H5/PR319PQ0NDbjdbr766iskSSIxMVE57rZVCO31Pdo79raor68nPz+fffv2kZ+fz3fffcewYcOIRCKKv2PnmOHo0Z7HY1RStVI+tg5okZRlVMLhqaH4YJl4v8e2pGNUEjokDNtu41BQxSkdD5V8rWyb2H5dksgXrl40Bw24c6CxrwRChJzFYKhx4coz4k9QoWuKkrrOi+ZAA2jUePtkUzFC5KwzN/B08gosqhB7wzb+uv0UEm0eGiv1RNUCyd9HcWWrqR0IUTGKEBHo2vsAI1J2oleF6KavRC+EMAlBEtV+IpLAn0pW8qG1D/sPJJGwVkTrltA1x855IFFD2A7BHVaiHgFSIqi9KkSXgDooEkmIfe+sWj/b61Mx6gOkWN1U1tuxmH2EC8IMS92NKERwR3R8vbsISRLQVokYqwXC+tglYKwL4coTY0rLYglJG0XSSKj8KsyZPnw+LdY0NyZtCJUgcVb6j2Rqm+iuraKLxkdA+onU66iXIdepHq+E646uyo5ej0gt77VDJLa3jvxa/LInquz6Z9U2H62xvJxS2J6x/IQJE9iyZQv9+vU7aD+yEbmM/2VjednrKBqNKIbO8oNOp9ORkJBARUUFkiQpigW5k19VVUPPnj2oqqqisrISi8VGfV0TP/64jS7ZeQiCChAQRS1ut4ePPvoYq81Kt25dCQQCpKSkYrFYMehNuN1eampqyM/PZ8+ePQpZWV9fT1paGoIgYDab6d27N3v27CEpKQmbzUrXrvn06dOHzZs309jYhEYjolJp8Hq9GI1GUlJSUKlUOBwOTjrpJJqbm0lMTKS5uRmz2UxFRQUul0tJvpSTrD0er+J/YjKZsFot+P0aGpsa0Om0uN1uamtrCQYCmAxGTCYTvkCA2uoa9Ho9NS0lI/LDXa/XkZKSQkJCAt27d8Pn81JX76WyshJ7gh1HsxOt1kAoFGbbtm0MHDiQ2rpa7HY7oVAAh8OB1WqlrKyMrKwsAoEAlZWVNDc3o9PF0rKzsrJ+xSvp/0/8EqXKcidX7kCbTCZmzJiBKIrMmzePGTNmUF9fz6RJkzCZTFgsFu666y5KSkp48MEH+fTTT9m8eTN33XUXl19+OSaTif79+/Piiy+yYsUKXnzxRVauXMkDDzzAa6+9xpVXXskVV1xBdnZ2h6XC7R1v29dl0mzPnj3ce++9LF68GJvNxowZM7j22msxGAzK9yz+ON1utxKis2vXLtRqNYmJieTm5qLVanG5XDQ0NPDRRx/x8ccfk5eXx6WXXsqVV17JyJEjeeyxx1ixYgW33norq1evZtq0aa2UbPL9TK1Wc8YZZ/D8889zyy238Pbbb6NSqZg9ezYWi4Xrr78ev9/PrFmzlNL2K664ot3JqUMpHQ+Hw5Vuy0Sd7Et1NAqH9pZta6txxRVXEIlEuPfee5k3bx5qtVopLz+W8urDQT5Hx1K+feutt/LWW2/x0UcfYbFYFE9Gm82GwRBTwo8fP54777xTCSibNGkSQ4YMYfDgwQCcddZZ9OjRg6uvvponnniC6upq7rvvPm699dZOVeMvBPmaMxgM1NfXo1apcDqdFBUVtQoeansdGAwGVCo1brcHQRAoKelBOLyJzZs3c9ZZow6phuroXhxPTrb3ekfth1h/cu3atWzatEkJoLHZbAd50naiEycKer1eeT7o9Xo8Hg8lJSW8//777NixA4fD0WqC71gIvOLiYqZNm8Zbb73FBRdcwJVXXnncRBoNDQ1KxU6fPn147bXXGDhwYKtwRp1ORzQaPeqycfk4VSoVJSUlvP322wwbNkyp2ho5ciQHDhzgzTffpKmpiZNOOomHHnpICWGB2KTp8uXL2bhxI5s3b8bj8RAOhwEUT0eDwUBmZiaJiYkYDAYMBoNS/u73+wkGgwQCAbze2DiiubkZl8uljC19Pp8yltJoNMrrOp0Om81GWlraMfk7tv2s6+rqyM7OpqysjIKCAjweD7W1tWi1WhoaGpQJx04cH8jEYlt1ofwa8m8OLreOJxHjScP4hOujTbs+FI6lpBp+8nX0RkU+c5Xyz539ETURghkh7Ou1mGoiSBqJun5mQmYBe1kYy7oKUKvwlGay/yw1N5/5OSNNP5KiDtIYEamImFnnLeCSwu/wRrX8a00KWhfUDFSRd9J+hiXHyL5EjZt00YFd5SVF7SEkqbCoQooa0A9cbPkBb4aWVyqGETYJNPWNoK1XY9sJUVHCUKEhaJVQ+0HbpCZkjRK0QSQzgCqsRqeO0BQwEpUEmhosWLPq6ZLSRFQSaPbpWduQS6PPSEOjGetaPSEzaB0gRCW0LvAnCgQtaoQw+JMEdE0CvuwQKmOYqEaNz6fFYAji82nRqCMMzyxjhPlHCjReIsRKqo1Ca7UgHEzQqdu8dyKmQVvtQ6CV72hb38l4pSOcGIKxIxwz8dhpLH98ET9wljsy5eXlGAxGEhISiEQiGI1GNBoNOp0Ov99PcnIygiDQ2NiIVhQRRZFQKEw4EiQjIwOPx0djYz27du0mEIyQm5vbUnbgJxqNYrcnsGH9d9hsVkRRg0ajRSVo2LdvPxqNhrS0NHbu3Kl4o/h8PkKhEPv3lxMKhcjJyWHbtm0IgkBTUxN1dWYaGhqwJ9hISkqibPcedDqw2y2Kz1N9fT2NjY0Eg0ESEhLwer0kJCQoBIjT6aSmpkYZyPp8Ppqbm/F6vQoBIIpaBCFGIiYkJFBXV4sgCOzdu5eamlqyu2Tj9XpjBKXNRiAYpHz/fkRRpKauNpYiG43gdDrRaDQEgyGMRiOhYBCNRkNKSgoatcj+/VU4ml2IothCKOqor6+nqKiQ+vpaAoEAaWlpNDc3k56e3jLbnUwgEODLL7+ka9euWK3WX/vS+p/G8Shjag9tyTiZAJT/NpvNTJ06FYvFwpw5c5g7dy779+/nwQcfJC0tDZ1Ox0UXXUS3bt147LHHWLx4MVOnTuXzzz9n6tSp9O3bF5PJxOjRoznllFP44osvWLhwId9++y2zZs3i1Vdf5aKLLuLyyy+nR48eigL5SGfaJUkiGAzy1Vdfcf/997NlyxZ69erFQw89xBlnnKGk18YfZzQaZefOncycOZMlS5YgSRKnnnoqV199tRI6I/s9HThwgP/85z989NFHbNiwgSeeeIJFixYxYcIEnnvuORYtWsT8+fNZuHAhGzdu5JFHHmHw4MGKtxv85L94xhln8NxzzzFp0iT+7//+D1EUeeihh5RES4/Hw9NPP8306dPRarVccsklB3lRHm358JFcL/HLyB5Q8eTGzyE64skXURS56qqrkCSJhx56iK+++gqj0cgtt9yCTqfr0HfzUGjbto6IoHhS/UiUmi+++CIAp512WqvXX331Va677joAnnnmGVQqFePGjWvl8yxDrVazePFiJkyYwJAhQzCZTFx77bU8/PDDR3RsnTh2WK1W/H4/hYWFRCIRVq5cicPh4LTTTkOv1x90fanVKvx+L3369MFut2G1mnG7XSQk2FsFw7QlH9u7Jx9rqWa8dYTBYOCqq65iyZIlbNy4EZPJhNlsPkiZ1IlO/NKQn7N6vR6Hw0FZWRlFRUV4PB5SUlIYPHgw7777LrW1ta2ItGOBSqVi7NixjB49GovFovSFj+XZ0BZVVVX4fD6+++47LrroIrp27cqmTZsYOHAgb7zxBjqdDr1ef1TfrfaUzb1792bWrFmsWLGCM888E4j5S44fP55x48YpNi7yfUiSJMLhMB988AGzZ88mHA4rz0NBEBSvRvkcbNq0STknKlUsIFKv12M0GsnMzCQnJ4eioiLFX9Lv9+N0Oqmrq6OxsRGfz6esl5eXR2lpKaWlpdjtdrp27XrQBPDR9iFkv9pevXphNBrZtWsXxcXFfPfddxQWFipjnk4cH6g6UDsGUSnhMh2RfUfi4RhBQNWifownHw+leuzo9fb2dag2xBOpEQT2h+187ujFsv1FSJutuG1RDA0qVGGJyhGgr9GQviaI4cdqojYz7r5ZlF8oMX3YJ5xi2K1sxxWNlWvriaU21wStlLmSCBX7GNdzHf2M+ygU6zCqwkSkWKK2ColQC51lVIUJSipURAm1tM8laTjLsgnbIB+fF5Zg1ATZ77LjrktHFQJfQQCCKtx2EBs0RO0htOYgWlUUvTaEw6enJLmGAks9+2yJZJuaCUsqVu/PQyuGcQT01NdZIBhrgzamhyOQIGCol0jeHCYqCviL/UhBFUJAjdYWINHqodFpQqsNU5JSwwDbPmqDVs60biZb4yXETySdTECKQmvCTvZIVAu0Wv54qR/bu+N2RBiqQCmzVsW9drQE42/O4zEencbyxw/xniXyA9dqtREORzCbLTgdLkUh5PP5yMnJITk5WSnzzcjIYOvWLSQk2hBFDRIRwuEwoigiSUKsVMrpQhBU6HQGnE4njmYXFqtEY2MT69auJzMrnYKCQtxuj0LyRSIRtm/frnSc5FnD5OQUJQQhLy+PmpqaFtJYQhTV9OkbU7R63D4qK6swGIyo1RrcbjcZGRn4/X4MBgN6vV7xdElPT8fpdCoP3pqaGoqKinA6nYiiiN1mx++PEYNbtmxVCFq1RkUg4MftduP3+fj2228ZPGgQwVAIvcGAxWymqamJouJidu7ehdvtjqVla3VkZmW1lJmbKS/fi0qlora2Fp1WR2VlJV6vj1Ao5kkTCoXQ6mIeV1VVVaSnx4ygPR4PkiQps8+iKBIIBFi1ahXnnXcePXr06Cy5/gXR1s/weJ7ntqRj2+0bjUYmTZpEeno69913H6+//jr79u3jiSeeoGfPngiCQI8ePXjxxRcZMWIE8+bNY/HixaxZs4arr76am266iaysLKxWK2PHjuWss85i2bJlvPLKK6xcuZLnnnuON954g1NPPZXLLruM4cOHKwOY9gb6MsLhMLt372bBggW88847uFwuTj31VGbPnk3Pnj0PMkiX1/n666+ZOnUq27dvJzs7m6lTpzJ27FhsNlur/QlCzAi9X79+XHfddfznP//hpZdeYsWKFUyfPp3Fixdzzz33cPLJJ/PAAw+wdu1arr76ambMmMEVV1yB0Whs1XaNRsPo0aN59tlnuf3223n99dcRBIGHH34Yi8XCnXfeSSAQ4Pnnn2fq1KkYjUbOPfdcZQASHwLzSyKerDtcOvTRtkUURaVc/4MPPuCrr75CFEVuvPHGFtXZ8e8OyM8UWfkon8dD4UjISb1ez/z585k/f36Hy+Tm5rJkyZKjam8nfj5sNhu7du1CEAQsFouiunnppZe45JJLWqn0ZW+0WDWDDaPRgNVqxel0kJWVpYRVxYfhyfilJoLk535eXh7r169XvCbbTmZ3ohMnAnKJb3JyMhUVFRQXFyMIAqFQiFNOOYX8/HxWrlxJ9+7dj/keHu+5LJOO8JNnr9yOY2m7JEls27aNHj16KFVDQ4cO5R//+Ad9+/bF5/ORkJCAwWD42d/p/Px8zj33XB566CH0ej1Dhw5FFEUEQTiojwGx5+yqVatYuHAhw4cPp0ePHrz//vtkZ2djs9mw2WxYLBaKior45JNPyMnJYezYsRiNRux2O6IootFoUKvV6HQ6pRQ7vr8QDocVpWP8OZEJTtlX8lisTtpO5sn9stNOO438/Hw+//xzxowZw7Zt29i/fz/RaFTJSujE8UG0JT1aHZd6LSsd5XRrWf0Yn4QNMS9IJNAS/SmUBkBqIRAlDql2jG3/J2WkXD4dr6zsiFhUIaFCiqVTE0Xd4icZklSIQlR53yWJbPDlMW/LSCK7zSRulkhoCtHQQ0Qa4qDJqSfrXxoMVR4iRg01o7MJntfMDUVLOdu0VSEOo3EJ4AAmIczF1o1ELALqVAl1odSKxJKXUyGhFiSQYm1UznvcsZmEMHohQpGumt3mFHY4U0kzuqgdZEX/nREkASGgAlsIQ3c3BiA3oQm71oszaMAsBjCoQ7hCerpa6vlqXxGiJoIohumWXEut14JGFyHi1RAyQ1QLqiD4MiIEElW4ctRECvwUpdexY086YrKPorQ6rKKfMVmbydQ2scufhl4Ic2XCamyqGOkql1arW8hGtdCOyjHu4297d2+rkDwWRGlNbh5qufagPsz7vxaOiXjsNJb/ZRDfuQ6FQi0yfysatUgkElFKNmpqapQygLKyMjweD6JWxGq1otfrMZkNNDc3oxU1VFRUUFtbS35BIVI01olxOJx4vT7C4ZivSCwpTiQzI4tgMEQ4HMbn87Fu3TpWr16tlJAAeL1e9Ho9mZmZbN68merqatxuN263i4yMdHw+n2IgnZaehkqlJhAIUl9fz44dO8jKysLn85GcnKwQyBs3biQtLY2kpCQaGhqwWq3YWhK7CwsLaWxsxGy2UHGgkqamJrRaHU1NTUAUnz+olGOHw2HWr1/HmjVrGDBgAG6vl3CLP1piYiLCbiHWgQLCoSCRSIS0tHTUajXJycm43M3U1NSQYE9oSc4LotGINDfXk5qais/nIxoNo1bHlJkmk4mamhrC4TBdunQhKSlJ6ajU1NSwa9cuSkpKOknHXxDxarefe57jO4mHIx3l93Q6HZdddhlZWVlMmTKF5cuXc8UVV/Dwww9zzjnnKKblN954IyNGjODZZ59l0aJFPP3003z88cf86U9/4pJLLiE5ORmz2cz555/PyJEjWb16tRI+869//YtPP/2UwsJCzjjjDEaMGEFJSQkpKSmKf2I4HKapqYnNmzfzySefsGTJEmpqajCbzdx9993cdNNNJCYmHjRQkX2O3n77bWbOnEljYyOnn346jz76KKWlpa0GOe2de7vdznnnncfw4cP5+OOPeeqpp1ixYgU//vgjkyZNYsGCBTz33HO899573HPPPWzfvp1p06aRlJSkbEc+x+eeey7RaJTbb7+d1157DY1Gw4MPPojZbOaee+7B7Xbzt7/9jSlTpmAwGBg5cmSr9p2I71l8mXJbJezR7L+tylDe1rhx45AkiXfeeYf58+fjcDiYMmXKQWTt8TqW+PL0IyEVO/H7RiyUrQmIhT3Iz/rs7GzmzZvHueeey7Bhw9BoYkFu27ZtY926dRQVxcLmfD6fEvayZ88eTj755HaJx+OJtt+vaDSq+EkXFRXhcDiUUtFOdOJEQRAEpW8sByHu37+f3NxcXC4XNpuN008/nWXLlnHVVVcd5KUsb+Nw+wCUSbb2AtOO9rkTD5/Px3/+8x9OPvlksrOzWbFiBZdccgl5eXkcOHAAv99Pdna2QogdqTK+Peh0Om644QbWrVvHpEmTmDhxIqNHjyYjI0NRKcr9Lo/Hw6effsqzzz6L2Wxm2rRpFBQUUFZWximnnMLIkSOVAElZFPHxxx/To0cPjEZjq3PXnvpf/ju+kqS98yirKeU+5tGgrX9tc3MztbW1HDhwgN69e2M0GqmtraVPnz68+eabpKamdnrDH0fIpCMc2idRVj+2RXwJ9kFBMC2baa8Uu73/fy4iUowgFFtUnAFJzZZgJo9tHk14qxXLPtD4JTQ+iX1/iHLXoI/5uLo3rrezUQWjVJxmIuX0Su7I/Q+lugrUSAQktdJ+VUfKyjYKzfYUdJGWY43EJXG3XUeFRDexgW7JX7PWksXC/aciCBKG0+rQRgUag3bSUpwMT99Nc8hIhdeGKERxhXSohCg5hkZ0KgNranMoSG4gHFWhEiRMmiBNXgPhgBp0EcImFbpGAWNNFG9eFMGnImyR0OlCVDqtdM2vwab10cXYzGnWbfTQxrin7toqEtV+RKTDBq0cCRF4vHwejxVyqfeRtiO+/Dp0AoYBR0U8dhrL/zJoS2hEIhHF51Cr1aGyaFpCXWLlw3a7nUgkQiAQoLCwkH379uFodqBSqTGZTESjYex2Oz5fgIyMDAQE/H4/Op0Ol8tFJBJVkvjUGhVNTU0MGNAPiyVmjp2QkIDH42kJo/EqyZc2m41IJEIoFCtNtlgs/Pe//1UezpWVlUhShKTkhFi5eASiUUkpazAajTgcDsLhmG+iXAZRW1tLTk4OoVCIUCiEXq8nLS2N+vp6IpEIwWCQpMRERI2WDRs2IEnRliQ6EZVKwOcLKJ2HYDDI0qVLKSkpobm5mUgozMkDT2bvvn0EQ8GYF08ohFqvIz09jfyCfBwOBz5fLORGp9MRlSQSEhLw+8O4nLFy7pqaGmx2W4vKI4yzJSFbq9USjUapra0lPT0dg8HIrl27aWhooLKy8qDPtxPHF3KH8Vj8hzpCW1JJ3k9H+1er1YwYMYK33nqL++67j88++4w///nP/OlPf+L2228nNTUVlUpFcXExzz77LBdddBFPPfWU4n/4+uuvM378eC644AJSU1MxmUycfvrpDB8+nN27d/Phhx/y0Ucf8eOPP7J582ZefPFFEhISSEpKIikpCY1Go6gVamtrlZKl6667jksvvZSBAwcqyrZ4j0K5M/zUU0/x0ksvEYlEuP7667nvvvtITU1Vzq2siIOfSrLl8y2fc4vFwuWXX86QIUOYO3cu//znP5k5cyYbN25k2rRp9O7dm7lz5/Lyyy9TVlbGnDlzKCgoULYveytdcMEFhMNhJk+ezMKFC1GpVNx///1YLBYeeOABfD4f//jHP5g0aRIvvfQSp5xyyjH7ux3rIKqtKuNYSU/5Xi9vR61Wo9Fo+MMf/oAkSUydOpVnnnkGtVrNHXfc0arc7eeWd8f/ltFZpvq/j5hi0YkkSaSlpdHU1ER1dTUul4v8/Hzef/99Nm/ezOWXX051dTVNTU2kp6fT0NCAWq2mpKSE7777jj179igTn6Wlpb94u+Ovd61WS1FRUWxyVaulqamppbqjkzjvxImFTJh169YNl8tFY2MjWVlZyjNz2LBhvPHGG+zatYvevXu3W4J8NORjR+8dCdp+PyRJ4sCBA+zZs4fbb7+dIUOGMHPmTIYPH87AgQNZt24dVVVVFBYWdhg+dTSQJImioiIeffRRnn/+eR5//HHefPNNBg0aRP/+/ZXJ/a1bt7JhwwY2bNhA//79ufvuuykuLkaSJPLz8/nPf/7DBRdcwO7du8nJyWHr1q306dOHp556SikRj3+WtSUVD7aTOHy/8Vj7lvHnfMOGDSQlJWEwGCgrK+Pkk09m/fr1jBw5km3btjFgwABF4NGJ4wdRiBzk33g4hCS1Uqp9pAE07aEtMamWy7KFo/N0jCIQkmJkmyuq5aplf8a0Q4t1fxRTZQBfqpbqCwJc1nM9uzwpzPt+JOblRkI5ArZRtcwv+pA0tVvZDkLrABulvXLoTgvZGt8jlBOQjwVRfiJ/S7VV3J//MdaCAB5J5LYtl5Oe20CW2cFOVypadRitKkJDwESS3kOyzsN/awsxaEJ0sTQzJLGMQFTk35U9KG9KIOAXEQSQwio0XgFPlyihIR6EKiMan4A/JUQ0KlCQ3ESOqYmBljIG6feiFiT0gkREgjS1T1E1xh/jsR7vbwHHqnI8EQnXR0U8dhrL/zJoq7QKh8OYzSasVhs6nY5g0EVycjKhcIiGhnpFLaTT6xCAtLRUunXv1kKCSThdLjIzM3C7PKSlxcg1QYglwtXW1OHzxlSJoVCYQDBMYWFXhg49hR07tuP3B6ira6CsrIyqqirFRyUUCqHRaKirq6OoqBiv10swGMRisdDc3IzJZMLt9uDxeGloaMRkMtPY0EQwGCAcjijbCAQCBINBpWy7sbERSYolZKakpCh+TY2NjajVakRRJCcnB6/PFyuR1ukwmy2EwyEcDid2uxW7XYtKpSYYCNLk91NRWYHP50OtVmM1WwgFQ4RDIUxGE81NTQgqNUhgtdhwOZ1YrSYaGxtwu2MkYzgcpcnVHEvRCwXR6/SYzWacTiddumTgdDqIRqM0NTURCASUUux9+/ZRWNgVSZLwer3U1dUTjUoIHfh6dBKSxwftBWX8nM5xPJl0uFJamcwD6NatGy+99BIvvPACL774IvPmzWPNmjU88MADDBkyRCn5Oeussxg4cCCLFy/mpZdeYuPGjdx555385S9/4fLLL+fCCy+koKAAURQVU/kJEyawfv16PvvsM9asWcPevXspLy9n165dCklqsVjo1q0bw4cP58ILL+Skk05Cq9W2G7wSjUb58ccfmTlzJp999hkWi4WpU6cyfvx4zGazskwoFKKyslIZCJSVleFwOJTyqKysLLp27UrPnj3Jy8sjMzOTp556ilNOOYVZs2bx3nvvsX37dh577DFefPFF7rvvPpYuXUpVVRVPP/00AwcObDX4UqvVXHTRRUQiEe68805efvllNBoN9957LwkJCTzyyCMEAgE+/PBDbrvtNhYuXEj//v1bDYx+KbQdvMjEZSQSUc7tkVx38cRf/LHL6dVarZYrrrgCv9/Pfffdx5NPPolKpeL2229XSt4ON2A9mnbIy3YSj//bEIRYuquv5Vmq1Woxm82kpqayb98+otEoaWlplJeXc8899zBkyBAaGhoUj2P5WjcajUrYRHsqrhOBwsJCamtrefnll9m0aZMysd2JTpxoRCIRiouLWbFiBQMGDKCiooLc3FyampooKSkhJyeH9957T7E5+S3cZyVJIhQK8dlnn8WsjOx2dDodp556Kh9//DE33HAD4XCYzZs3c8EFFxyXvqr8zBw4cCDPPPMM//73v1mxYgUrVqzgk08+UXxaNRoNhYWF3HHHHYwbN04JswwEAgwZMoQPPvgAh8OB1+vFYDDw/fffc/HFF5OcnMw777yjqAl/K5C9Kr/44guGDBlCr169+Pzzz7n88stJSEhQwkCvuuqqX7up/3OI+TAKhyQP23tdjPN/DAqxcut41aTs69iRsrEjL8d4AvRI0qoPPhaJ6rCdxDUiCTv8BOwi+yeEmdp7CSZVgBmrLyb7XQ3CYDU9rvmRa1JXkqVx4pfUaIUofinm4SgjvtQ6dtxRRV0Zez8OUuv/45WNkUMoPGX1XWw/IAoSKSoveiHKV64SGqtsiJYgVm2AUWk/sseXQkQS8EVE9rsTWL8nh4wUBwZNCJvWz3pHLu6QjnxrI6I9wrqqbAJ7bURFCCRI5JRWUVFvx5TtQpMbJUUfoJu9liuTv8GoCmARQqgFCZEY6SgKP6n8QtJP6r+fQ7TKiL/Tn4hy51bl8C2fl3gEt+744JnfnMdjp7H8Lwv5AeV0OrFaLWg0KjweJ2azEbUmFtKyf/9+8qw5LabWWoLBAEaTAavV1BJqoSfcKNHc5CI3Nw+Px8e1117Nps1b0Bt0eLwugiE/ao0KQRVFL+opKioiJyeXqqoa6uubWLduHdu376CxsQG7PRZsE/D7cTgcNDU109zcTGFhAeXl+ygsLGTVym8QNTEDao/bT31dE19+8TUDB56MIAg0NzfT3NxIOBxTNLpcHkSNFpfLSXNzMzZrAo5mJ3q9QTkPcqmXrBaTJElJMzcaDTidYUKhCA0NDsxmE5GwhMlkwel00tzs4PMvPuf8Mefj8/mwqGPkqN1qRSNo0Gn0GPQ6uhYWxpQTjkaSk1MIBALs2VNOSnIqXq8Po9FAamoyNTW1BPwBbDYbXq8Xs9mM0WggEAig0WgU9Wh2djYGgxGNRkvAH2HHjt1EwpEWouD4KfI6cTDiwz/aCxnoqON8uPLqo4EgCCQkJDB9+nQlnXHlypX88Y9/ZPz48UyYMEHpRNvtdq688krOOeccPvnkE/7617/yww8/MHPmTObPn89pp53GhRdeyJAhQ0hOTsZutzNq1ChGjhyJ3++nvr6empoampubiUajGI1G0tLSSE9PV5Rx8cSWrMyMRqNUV1fz9ttv8+KLL1JZWUnXrl2ZNWsWo0ePRqvVIggCXq+XtWvX8ve//50vvviC6upqhRiLL3mUyV69Xk9KSgqlpaWcfvrpjBkzhn/84x9MmzaNVatWceONN/LQQw/x8ssvc9999/HNN99w3XXXMXv2bM4///xWCZ0ajYZx48YRjUaZMmUKCxYsQKPRMH36dJKSkpg9ezY+n49PPvmEW265hb/+9a/07t37IJXD4XA8iJL489qR+rFtqIus0JVVpG0/I5nEvPbaa4lGozz44IPMnTsXSZIOUj4eKQ53rJ2TIP/7kCQJrU5LOBIhFA6j02oJh8OYTCZsNht1dXUKodilSxfef/99+vXrR11dHUOHDgWgubmZ8vJykpOTycvL69BbMZ4Yjyfa4ydz4onv+KCaYDCo3Ic6KpeUk2zT0tLQaDSEQqFOxWMnTjjkicc+ffrwxhtvYDKZ2LNnD7m5ucok0sUXX8wrr7zCH/7wB3r27NnuNn6N+29NTQ3vvvsuY8eOpbq6mubmZk477TQeeOABqqurEUURv99P3759f3b75O84xL67qampXHnllVx66aVKuIvf70elUmG1WsnIyMBoNCo2DpIUC2GTQ16WL19Oz549qaurw263K96Jb7/9NhdeeCEjRoxote9fC/JnW1ZWxsqVKxk6dChpaWmIosju3bvp2rUry5cvJxAI0K9fv1+tnb93tBfEohKiIKkOKrmW/RxDkrrV6/F/a1uoGHl5ldDiudhCsB2ulDq+NDve5zH+d1QSCKJCS7Rd9aG6xUcSYqSdXohQHTHzZtUQmkqjNA4W+NOArznf+j0hSUVz1MCUkz+Hk+E04w6AmLoR0AsRglLrPqNMNsq/49WOYosHZnz5tPx+bCvSIVWk8eXp6hbCUV5XLYBJiPKxu4SXtgzDmuqmMLGeBK2P2qCVXH0Dy+uLUAkS2eYmirvVEpVU/NiURp3PRIbJSV/7Aco8yex1JZJg9KE+2cPeXWmoPSqqmqyM6rodu8ZLqtZJka6aPE3TT16WQmtSNST91Db59Xjy8aBjk9r/P9Ky/JH0zA9Xrt0e4dneOvFkZkeBMhGp43XicSLTro+61Ppw6DSWP3rEl/zJPiderxeIESqhUIiMjAxsNitmc/eWVMkEgkF/i9ejiMlkIhKJmSQnJaVw4EA5qampZGZmoFKL2Ox2Kiqq4wIEYiRnVlYWRUVF+P0BPB4Pfr8fq9WG0+EABFwuV9xAOWa6vHPnTlJSYonaFouFvLx8ysr2IkkCkiSAJPDddxvR67VEIhHKy8sJBIKoVOqY8bPNhkqlxu12EwqFCQaD2O12QqGQUpINkJmZSWNjI1arVSE3zGYzgUBsYBIrs3IgCGokCUKhMKKoIxQO8u2aNZT06I7NZsNut9Pc3ERTUzN6nRGP24fRaEIURYLBACBRV1eHy+XGbLIonlcbNmwgLS2DUChEfX0DWlHE43Xj9XrIyChR/EzNZjO1tbVkZmaSmZnFrl17CIfD7Nq5G58viEUjEo1KqFQHl/B24vgg3qcuGo22Sjs8EoVY2/LqI/182ivbUavVnHPOOZSWlvLUU0/x1ltv8dRTT/HVV19x9913c8YZZ2AymRAEgZSUFK699louvPBCli1bxltvvcXKlSt59913+eCDD8jJyeGUU05hxIgRDBgwgMzMTMxmMzk5OeTk5Cjtjm+PrMCLH7R7vV527tzJkiVLWLRoEbt27UIURS644AIeeOABioqKUKvV+P1+vvvuOxYsWMCnn36Kx+PBZrNx6qmnMnDgQIqLixWvSKfTSXl5OTt27GDLli3s3buXpUuX8tlnn/HKK68wZcoU/vKXv/DMM8/w97//nSlTpnDbbbfx3HPPMXv2bD766CMmTpxITU0N1157raLmEwQBURS55JJLiEQiTJs2jRdeeAFRFLnrrrtIS0vjqaeewuv1snz5cm6++WZeffVVSkpKjvayOSq0tcSIf/1Qqtt4olEmDGV1R/y12dZrSqfTcf311yMIAvfff7+ifJw0aRJGo/FnK2c6fR3//4IgCOi0OkStGAufa0l9la1T5O9/UlISBw4coH///hw4cIDExEScTqcysXLyySezZs0aqqqqCAQCQPt9w0gkFnIHsHbtWnJychRP8PjvidvtZt26dfTp04edO3dSXl7OmDFjFNLB6/WycuVKioqKyMvLU+55RqOR3NxcnE4nHo+n85naiROG+Pu2JElkZGSg1+vZtGkTubm5VFRUkJGRQVVVFaNHj+add95h4cKFzJ49G51Oh0ajOWHXa3vfzXA4zPvvv4/P5+OSSy4hFAqxatUqRo8ezbnnnsvixYupqqoiPz+/lY//z0Hb45Un7eW+TPzzsb02x8Y2SfTv358PP/yQk08+mbKyMvr168e//vUvRowYwZIlS5g/fz49e/YkKSlJUWm39aH9Jc592wkWeT/RaJR3332Xfv36KZVTw4YNY/ny5VxyySWsWLGCIUOGkJKSctzb9P8LYuTgT6XRMuLVjDIR1hFhFq+KjE+MBlDHkYdH4t/Y0T5akYsCaKWoQkQetI70kyIRYmrEFLWHu7P/jZgTU2QahTABSY1eiJCudpNk2NVKbSmnT8NPBOOJgNhCNrYlU6OAN6rGKEQ4xbCLDbm5lHsS0KiilHsS0KnDbGrOZM+qHPqdvp1zEzdhV3tJUbtoSIr5zO4NpbDWmY8zpMegCdHVUke2vpEvVBGqXBbu7P4lfXX7SVSHlCRqvxQjQIMtAT16IXLMyj5ZCXk4NWQ8gXm8IBOb8rbjScL2CEOZ6P2t4ZevT+tEh2g7ix//wIqlRycTCoUIBoN4PB6FrHC5XKSkpCCKsdCZ2tpaRbkQK/3VYDab2bOnjJSUVPQ6HV27dsVotJCRkcGGDRuwWCxo1GpFWeBvUTRu3bqV/fv3E45EoKWDb7FYcDgc+P0xorOurhadTktSUhJ+vx+NqMHj8bR4JGppbGrCYDCwd+8+bDarQl5UVdUQjUr06zuAAwcO4PV60Wg0qFQqXC4XPp8ar9dDYWEhgUCAiooKJTBHJhv9fj81NbUkJSUTjUZpbnYQCPgRBNDrDYQjYVwuB/X19fzjH//kkkv+gE6nJxKJUF9fj8fjRhQ1pKSkUFJSgtvj4ccft6LVitTW1iq+k06nk6ysLJxON4mJiahUajxuDyaTEbPZRDgc8540m80kJ8fa0tjYSENDA16Pl3AkzM6dO9m5cycDBvRtRYK1/aw7cfwgk0Ay+dhRCezxVDq2B7VaTXZ2NrNnz+bMM89k9uzZbNy4keuvv56zzz6bO+64g759+yrfP7vdzoUXXsg555zDjh07WLx4MUuWLGH79u28+eabvPnmmyQkJFBQUEBJSQk9e/aka9eupKenY7VasVqtrRIbvV4vDQ0NbN26lY0bN7JmzRp27tyJy+VCp9MxaNAgbrnlFkaPHq3YG2zZsoW//OUvvPfeezidTlJTU7nuuuv44x//SLdu3dDr9a3KteXzKAdUVFRU8O233/LWW2+xevVqbr/9dv74xz8yefJk8vPzeeKJJ3jqqaeorq7m/vvvJyMjg5deeklRWEyZMgWLxaIQEhqNhssuu4xwOMz06dN57rnnEASBu+66i8zMTObPn8+NN97IypUrmTBhAq+88goFBQUKoXYiv19tfR/jz5M8OJXPlfx/vC+p7BUmn1N5Ga1Wy3XXXUckEmHmzJk88cQTSJKklF13RD4ei+dlJ/73EQtNixGMokajBMHJ16EoijQ0NJCUlITT6USv15Oeno7H40GSJFJSUqioqGDv3r04nU4aGxtJT09XlIqy76LH4+Gtt94iJyeHMWPGKOqlsrIy9u3bR3l5OSaTiTPOOEOZaN2/fz9erxefz8eLL75Iamoq559/Pk6nk0gkwt69e9m8eTMqlYrS0lLeeusttFotgwYNYtmyZZ0keidOKOLvrVqtliFDhrBkyRIefvhhtmzZQpcuXZRqhCuvvJInn3ySL7/8knPOOee4elIfKWRiT5IkfvjhB958801OP/10unbtSiQSYe3atdTU1DBo0CC++OILvv76a8455xzMZvNxK7U+FOLPR9tJPvl5GolEuPDCC5k0aRJbt27F5XIxfPhw6uvrSUtL49prr2XevHm8+OKLTJkyBa1W2y7x+EsiXkgiCALr1q1jyZIlPPfcc9jtdnbs2MFJJ52ExWJh06ZNfPvtt8ybN++EtvF/CSohiqqDSyuehFS3lE/LadZtVZIRBJCXb0tiCtFWisVDlVjLJdhyEEy0jZqy7fKt29vyvtB6eVGIKqnWFlVQOY5Ai2rT30I+ymXUUQT8klpR+XUUHvNLoqMyY1GIEiVGiva17KfGbyFZ58EZ1NMcNLD3P7l0WR7g+1B3SsZWc7FtA2okisQmGqNaGiNmhtu2k5dST5LKhwoJr6RhUP5uTEIQuyqolE/rBPDK4TcI6IUofkl1kKKxIxKxbe9aPo74MuxDqhZ/ge53/FOjvbAf+XXi2ngi1YxHgk7i8TeA+IeUSqXCZDKh1WoxmUz4/X5SUmJlwIFAAFEUqa6uxmazKV5sWVlZfPrpp1gsFvR6PT5fgKSkBNzuWGmyxWKhuqaOsrIyvF4vOp2OQCBAuEWRUFlZSVFRET6fj8rKSsV30Wg0YjAY0Ov1hMNhqqqqSEtLIycnB61WSyAQIBqNYjaZMRgMSslTU2Mj3Uu6Iwgx8icxMRGdTk9CQgIpKamEwyF27dqlKBt/KlduxudXKYMheWDt8/mor68nFIyQmZmJJMWICVkJGQvUCGG32zBEDEQiEXy+WDjOmjVrW0pIdajVKvR6HeFwmJTUZOx2G6KoJiMjncbGRgoKCjhw4AApKSmsX78em82m+I4mJSahVqlxuhykpaXh83kUdWZ9fb2SxO12u6ipqUGKSop6rG/fPqg1ApFIuFPteAIQT/rElxu3NzBtSzoez89GpVJhNBo577zzGDhwIAsXLuSVV17ho48+YsWKFVx66aWMHz+e4uJihYDX6/X06tWL0tJSJk2axI8//siyZctYsWIFW7duZfPmzfzwww8KgaXVarFYLBQXF5OWlsYPP/xAXl4eLpeLLVu24HK5gNjAKD09ndGjR3PppZcybNgwLBYLkUhEITf/7//+L5bqnpDA9ddfz80330z37t3bVWfEz+iLoogoilitVrp3786FF17Ia6+9xjPPPMPrr7/Otm3bmD17Nunp6dx33328+eab1NfX8/DDD5OamsrcuXN57rnncDgc3HvvvSQlJSmfoU6n44orriAUCnH//ffz7LPPotVqmTx5MtnZ2Qr5uHbtWiZOnMhLL71Ely5dfhVbg/a8EuPPU7w6NX4Z+bNvbx35Mx4/fjySJDFz5kyefPJJ1Go1EydObKUS7UQnDgetTqcQjxazGb/fj8/nIxQKkZyczI4dO7BYLDQ0NBAOhzEajWzatIkePXq0UuYWFxeTn59PQkICzc3NfPjhh1RVVZGRkcHw4cOx2WxcfPHFZGZm4vV6+e677/jHP/6BIAh06dKF/Px8XC4Xr7/+Otu3b8fj8ShVDH379iUrK4tt27YxYcIEvF4vGRkZ9OjRg0GDBlFYWAjEwuwyMjIUuwnonNDrxK+HkSNHKkEyiYmJVFdXk5SUxL59+xgzZgyffPIJTz/9NCUlJco1/EtDfubIfRxJkqisrOSRRx7BaDRSWlpKQ0MDaWlpDBgwgPXr13P++edTWFjIv/71L84999xf3ZOybUVYv379KC4u5oMPPuCiiy5SvDTXrVvH4MGD2b17N2+//Tb9+/fn7LPP/tX6ApFIhLq6Oh5//HF69eqFwWCgS5cubN26lWAwSGlpKXPmzKGkpIQBAwZ03ruOE+JVjiohSkhSK6XVYpy/4UGlzXH/R9uUJcdIyTb/d7AdmXwMtS1tbkNWikJUIQaVEnChDRHa8jvSQjDGlHqtVZNRSUAvRPBLakQhqpCSohAlhAoxjm6St6lCapeMjPd3bAs5ICbSslzb9Oq2yx6K7JLLuEeattHHsA81UewpAZqjOq5OLiZkVZO0JcI/I6dx/viNiEKYKGBXBRlq2N/KizEKaIUgeikSV1IeVUg5OUBGboe+5froiDCUVYLxpJ78dzxBeThFo+yt2LYc+nDkn0wadoSjSqo+wtLvE43fYpv+v8ChZuflZDM5hMXv92M2m5UAk4yMDCWZMhQKkZ2djc1mo7KyElEUsdlseDwedDo9tbW1hEJhmpqalCTsn8qtY0hJSVHKFg8cOKCUXvXo0YMuXbogCIKiviwvL1fIQKPRSGFhYcuMokbZpz8QIC0tja5dizCZTJx99tn079+P0tJSioqKKNuzB6PRqCgea2trY3+3JFNWVFQAKIEZoVCI3bt3U1ZWRjgcJikpkZqaGnw+H6mpqTH1pkaDy+WOhbkgIEVBo4n5qGzduhWNRo3VGgtBMhoNSFKUhoZ6qqqqWsrUY+E3mZmZiKJIdnY2fr+/ZbkGDhw4oPjYeTwefD6/sq7BYFCCc4xGE+kZ6YgtSrbvv/8el9v1P1NiPXPmzFalpIIg0L17d+V9v9/PrbfeSlJSEmazmXHjxlFTU9NqG+Xl5Zx33nkYjUZSU1O5++67lZK8n4O25a3x/8f7P8qQvwdtS1x/7v7b/qhUKlJSUrj77rv56KOPuOqqqwiHw7z44ouce+65TJ8+nR9++AG/39+qPWazmZNPPpkpU6bw/vvv85///IcPPviAxx9/nPHjxzNy5EhKS0s55ZRTSElJQaVSYbPZ2LZtGw6Hg+7duzNu3DhmzpzJokWLWLZsGQsXLuScc85Br9ezZcsWHnzwQc477zyefvppXC4XF154Ie+++y5PP/00PXr0UEjHtj8dnXeVSoXdbueWW27hzTffpHfv3nzzzTdce+21mM1mXn75ZfLy8liyZAm33347Z599NrNnz8ZisfC3v/2Nu+66q9X1Ivu9XnPNNTz00ENotVqeeOIJ5s+fTygUomvXrixYsIBevXqxYsUKJk6cSG1trbLu8UTb66ftZx7/Wlviu73rW55wOdx1F08+PvTQQ6hUKmbPns0LL7yAz+c75uPsVIj9/wVJktCoY3YngUBAsS6JRCK43W6CwSBpaWk0NjYqgYEQm7jcuHEjFRUViKKoeBrv3bsXiN1H5TLoqqoqFixYwOzZs1m7di2VlZWUl5ej0WgYNmwY9913H5deeikNDQ243W66d+/OHXfcwRNPPMHgwYPJy8tj2LBhnHzyyZxxxhlMnz6dl19+mWeeeYZbbrmFk046iYSEBDweD6FQCJ/Ph9lsbgnWi/7un6+d+P0iPz+f0tJSXn/9dTIyMqipqcFkMuH1epEkicmTJ+N0Onn00Uepq6trtW78syWeLDxWdOQrXFdXx2OPPca2bdu44IILGDp0KKtWrUKSJHr06EFzczP19fV8+eWX9OzZU5lw+DURfy7UajUJCQlcd911bNiwgV27dlFVVcXQoUNZu3atMmmal5fHzJkzWbFiRYdl2z/3HHe0Hfl/n8/H008/jcPhYPLkyUofLycnh/Lycqqqqli9ejV//vOflWqS3wNefPFFevfurVTaDBkyhH//+9/K+yd6DBBt8XGUf0KSWvkbWpdhxxOG7ZVmy6+3/YkQ82OUf+SS7bYKxvjAGZUgdRgyoyx/iNLveMi+lLLKMdTSBkDxY4wnHeV1RKKK4jKm9DyyaywiCR0Gxsivy8u0Xa6j9dojm0QhSrraQ6LK31JK7mNw3x0ELGoMNUHSVwe4ffvlynlSESP/2tuWvoVU1rYTFhTvvRivcmxbMq0W2ick45WO8cfTXtm1smw7bWyLwykt2wt7ibb5aQ/x7x1u2fbW+aXRqXj8DSESiaDRaMjMzMRut8dSma1WvF4v6enpeL1eXK6Yoi4vL49du3aRlpaGxWIhKyuLsrIyGhoa6Nq1mP37ndjtNgRBoK6ujkgkgsViUQaqshrL5/OxatWq2EDA5SIUCmG328nKyiI/P5/du3cjCAINDQ0KCVBRUcHQoUMUQ+qCggL27z+ATqfH7XZhsRjYt28fI0eOQKsVKSgooKqqGp3OwIEDFeTm5CBqRPbv348kSQQCAWpqakhKSqTZ0YTP50Oj0ZCcnEx1dTXdunUjKysLl9PDzp07ycrqQmpqKh6Ph6amJmw2m6J8jJVKm1Gr1fj8PhwOJ42NTRiNRoxGAz6fB6PJiEajJikpkaamBgCys7PZsWMHNpuNaDSKw+HA5/Oh0+nRaDREIrGybnuCRVFi5efn43a7lf/9fj+NjQ0gSRj0BgL+AGVle/D5vNhs5l995vh4oWfPnnzxxRfK//HJpnfccQeffPIJixYtwmazMXHiRMaOHcvKlSuB2DV+3nnnkZ6ezqpVq6iqquKaa65BFEUee+yx495WudMdiUQOKr2OD6H5pTp98fvR6XSUlpby/PPPc8011/Diiy+ydOlSFixYwD//+U9Gjx7N1VdfTf/+/VuV0crp7tnZ2WRnZ3Paaacp/mmBQIBwOOaTGt/51ev16HQ6pbRSPgcNDQ2sWrWKd999l+XLl9PUYotwzjnncPPNNzNs2LB2S6qP9Fjl33JC5v/93/8xY8YMFi9ezC233MIDDzzASy+9xJQpU/jvf//Ln//8Z5555hnmz5/PXXfdxSeffEI4HObxxx8nMzNTUVip1Wquv/56otEoDzzwAI899hhqtZoJEybQo0cPFixYwA033MCXX37JnXfeybPPPktycvIJSbtu7zzEe422R0wezfmVl9fr9dx4442K8nHOnDkIgsDEiROVz+z3MnjpxK8Hs9mMz+dVnucykVddXY3BYMBqteJwOIhGo+j1erKysnA4HEDsXt+tWzclUdZoNLJv3z6++eYbxe8xMzMTp9PJhg0b2LBhgzKZV1tby9atWxk3bhxXX321cr3KSh85oFAm43Nzc4HWoTTyPU6j0TBgwADMZjP19fU0NzfHfCtFsfM70IlfBaIocs0113DzzTezevVq8vPzqa+vJy8vj++//56hQ4dy66238tRTTzFr1ixmzZqF1WoFDp6sirfkkd8/ErQlwOCnSdeamhpmzZrF8uXLufHGGykoKMBms1FWVkZ5eTnp6en07NmTd999l3Xr1vHII48oivpfG/FtUKvVjBo1in/961+8++67WCwWxY4kFAoB8OCDD3L77bfz4IMP8vDDDzN8+PBW2zse/YKOSEvZU3vhwoV8/PHHTJ48mdzcXMrLy/nuu+8oLS1lw4YNLFiwQPHuPtTx/tbQpUsXHn/8cYqKipAkiddff50LL7yQ7777jp49e/6qYwCVEO1QTaUSogrJqGoh6WQVH9Kh+2LxqdbAIcnC9oJuOlruUP939J7YhliLJxoPIkLjAmSOlHT8JdD27MaTlxALr4lIAlEEJmcu5fY/JuJ9NQVJBeG309g2I40e2mrENsEw7W37eLU1Xu0YaPGKjFcj/tzE6/+f8b/BhPwO0d6DRfYwsVgsmM1mvF4vgUAAl8tFZWWlkgZXXV1NZWUlWq0WvV6P1+ulsLCQ1NRUIpGoUvrrcDhQqVQ4nQ4EQaC+vl4hItxuNx63G5/Px/fff8/bb7+N0WTCaDRSUlLCaaedRmZmJjpdLK06MTGRnJwcpRxUrVa3lA5kYzabSUpKwmQyxUgWtZqamhoCgQBZWVns2LGD1NSYcXIwGARQ/KIcDgfBYLDF49GHz+cjGAwSCATYvXs35eXluFwuNJqY0sJms7F//wElkEZe1ufzYTAYCIfDLV53EinJqeh1sfTphITE2MBIgPr6erp2LSA3Lwe73UZ9fT3RaJSsrCzC4TA1NTXU1NTgcrkIBkPYbDYi4Qhms4nExCQaGhrw+32YTCZFASlJEunp6Wg0IhWVlS2+kwKBQIBI+LfirHB8oNFoSE9PV36Sk5MBcDgcvPLKKzz99NOMHDmSAQMG8Oqrr7Jq1SpWr14NwNKlS9m6dSt///vf6du3L+eccw6zZs1i/vz5yrXxc9GWgGmrcoxPVzwRZE1bVZxOp2Po0KEsXLiQ9957TzF3//vf/87YsWMZN24cf/3rX9m9ezeBQKDV4COezNJqtZjNZux2OykpKaSlpZGVlUVmZiaJiYkYjUaltOqTTz7hjjvuYNSoUVxzzTW8//77AFxyySUsWrSIN954g5EjRyqJyT+HJI8/3ry8PJ5//nluueUWfD4fM2bM4LPPPuP5559n4MCBbNiwgZtuuomEhAReeuklunXrxqeffsodd9zBnj17Wh27KIpcf/31PPjgg6hUKh555BFeeuklgsEgffr0YcGCBeTn5/PRRx9xzz33KGTJiUY0GiUcDrfy1GqrCj2aBO54uwBRFJWEcEEQmD17Ns899xw+n08ZYMrb/C0PXjpx4iEIAhJgs9rw+XwAJCYmKn7SOp2OpqYmtFqt0hepra2lrq6O1NRUVCoVDodD6ZNEo1GcTifNzc1UV1dz4MABRck1aNAgLrnkEh566CEKCwvxeDxkZ2czduxY8vLyWqn/5d9arVYhDjtSWMcr2Ddt2oTT6VTIkU7FYyd+TQiCQL9+/Rg8eDBPPvkkQEvfN5VQKERVVRWXX345Y8aM4YsvvuD+++9XJvTjifVfQqm/ceNGJk+ezJdffkm/fv247rrrSE9P54cffmDw4MF8+eWXaLVabDYbb7zxBr169eL000//TUyWt3cvMBqN3HrrrUQiEVasWIHX66VPnz7s3bsXQRAoKChgwoQJSJLEAw88wFdffaWQkr8kZNHC/Pnz+etf/8qdd95JaWkp69atY+jQoXz33XeoVCqWLl1KTU0NkyZNUrz744/3t4wxY8Zw7rnnUlRURHFxMY8++ihms5nVq1f/6mOAturH9hBP1LV9raNtdKRylLchqxtVgvSTt6PUMdkX7wXZuv3tryMrHuW2xv8oCsuW9+PVkSFJ1a4y86DtC9IhS6ePFu3t71AhJ/Kx+SU1JiHMxIKvabzEg7E6SOL3Tu76KqZ6bJXW/AuF5aj5iXSUS7T9kjqWDs3BysmOVJKH3Eeb5VW0VjceKjSm7bJHClUHf/8a+LX334kWxM9yympEj8eDRqMhHA4TCoXQ6XRK+bHT6cThcCBJEnq9HpPJRGZmJgcO7Ke2thabLRY2EQ6HEbVaGhsb+fbbb5UBsSAIaHU6RFHE6/XidDqpqKggJydH6ZS43W5MJlOr0k/Z27Gmpqal7MGORqNB3RJUY7FYlVJx2UBer9fjcDixWq3odDpFKRkOhxVTeo1GQ0NDvTKAqKmpUR5Ce/bsIRgMKqSR1WpVyr3kUIaUlBQSEhIIh8O4XG50OgOiqCMQCFJVWYXf7yctLbWFnAzhdDrx+33odDo8Hg/bt2/H7XYjSRJNTU3odDqSk5NRqVQtxGKU1NRUotEoOTm5hEIhIpGI4tvi8/nQ6/UkJyehElQEAgEEQcDhcOD2eJTPuG2Z++8RO3fuJDMzk4KCAq688krKy8sBWL9+PaFQiFGjRinLdu/enZycHL755hsAvvnmG0pLS0lLS1OWOfvss3E6nWzZsqXDfQYCAZxOZ6ufeLRX7nI4/BodPHmf6paSx+HDh/Pyyy/z73//mwkTJpCQkMB///tfpkyZwqhRo/jjH//I888/z+rVq6mqqsLn8xGJRJTvgnxNyfcPn89HdXU133zzDfPmzeOKK67g9NNP54orruDll19m//79lJSUcP/997N06VJefvllRo4cidlsVrwG2xICPwcqlYrk5GTuv/9+HnzwQbRaLfPmzePVV1/lySefZOTIkezYsYObbrqJYDDI008/Tc+ePfn222/585//zM6dO1uRxTqdjj/96U/ce++9SJLErFmz+Nvf/oYkSQwePJjnnnuOzMxMFi1axAMPPNDK/+1YcajBYHulVm0HkTKJ05aAPFK0tRDQ6XRcd911TJ8+nVAoxOOPP86KFSuO/QA78f8NBCDBbsfv8xOVJCLR2DXpcrlITExEFEXcbrcysWiz2WhoaCAUCinPZEEQGD9+PH379iUjI4OcnBx69+5Nbm4uCQkJ1NbWsmfPHmVS8cILL2TGjBlcdtlldOvWTQnUao9QOJyVg/y/1+ulvr6eiooKfD4fLpeLSORI3Y868XPwWyu1/K1A9mf/85//jNPp5Omnn0aSJPbu3Uu/fv34+uuv0Wq13HjjjVx00UV8/fXX3HvvvVRUVBw0afRzEK909Hq9fPTRR0yePJkNGzZwwQUX0LdvX3w+HwUFBS0e5H2prq6mvLycN998E6fTyZ/+9CdlQvm3CJVKRd++fZk2bRrff/898+fPp7S0lKqqKiwWC01NTQwaNIiHHnqIaDTKnXfeyfz585WgquNN8Mr9sH379vHAAw/w2muvMW7cOPr160dJSQnr168nHA7Ts2dP5s6dy6effsqECRMoLi5utZ3fOunYFpFIhLfffhuPx8OQIUN+0THAkUIuj4afyqijkuqg5OsIQis/SOAgclFWRrYHmeBrq0A8lLKwdam31Gr5+PVkAlL+iScZ45f3S2qCLTROQFIrywKIRNEJEcXjURSircJn5J9DQV4mIgkEJVWHZdRttxmRBELEfpRjP8TXTW6zXRVEL0Toqa3kgq6bqOurp7GPldSVarYE0wlKKvxxJfSx/R5cTiz/HV9OLROEh1Mqxk9PyMsbW85biIOJwPjjk0vBDzXiaC9CKr4sO95Lsu0xtF3290rgdZZa/8agVqsJh8OkpqbS1NTUaoZPEAQKCwtZt24dLpeLNWvWUFhYqJBvaWlpuFwu6uvrqaurQ6NRU1dXh9lsUbwfV65cSSgUQq1WK78DgYDiIzlq1Ch69uyJWq3G6XSiUqkUX6fm5mYikQjp6WlKmvPevXvR6/Xk5xfw/ffftygsnXTpkkkoFMLv95OcnExdXT16vQGLxYJarSYzM5Pdu3ej1WqVwbmo1RCNxhSfXq8XvV5PNBolEAig1cZStHft2oVWG1N5yuWzsjdVOBxGq9XhcrkxGAScTheiqKOhsZEtW7YwYEB/unYtpKAgjyv+eHkLSVOF1WolGAxSVVVFMBjEaDSSmJiIx+NREre1Wh3RaJRgKIgkxQJz7HZ7S5J3jBBubm7GbLYpIUBqtYakpCRCwSCyPvu3MIP8czBo0CBee+01unXrRlVVFQ899BDDhw9n8+bNVFdXo9VqsdvtrdZJS0ujuroagOrq6lYdDvl9+b2OMHv2bB566KGjbm88Kdeex+aJ7ui1LS+EGJnWv39/evXqxe23386XX37J+++/z4YNG/j0009ZsmQJBoOB1NRUBg0aRFZWFikpKVitVpqamgiHw7jdbmpraykvL1csF/x+v0LU9+7dm9NPP51Ro0bRt29fbDbbUanujvVYZZhMJiZMmEBaWhrTpk3jjTfeoKmpiZkzZ/L000+zePFiJkyYwNy5c3nmmWe44447+Pbbbxk/frzi4Sh/fjqdTiEq58yZw8yZM9FoNFx//fWceuqpzJs3j4kTJ/Lmm2+i0+l44IEHFDuGtu072sFHW1K2Pc/HeGJYo9EcVNLf3rk+1PZkxHuAyWSRJEnYbDYSExOP+TM8lvPQid8vkpKSWhSyEjabXbk/S5KklH42NjYSCARITU1FEATFf1aj0VBeXs5JJ51EcnIywWCQ8vJydu3apUyUFhQUcMkll1BdXU0gEDjIzuJ4ECt6vZ6kpCSam5uVSonOa/jE4LdcavlrQr7++vbtyxVXXMErr7xCYmIiJ598MmPGjMFms/Hjjz9SXFzMZZddRlZWFgsXLmTChAnccccdnHrqqQop39G2jxShUIhNmzbx0ksv8d///heNRsNpp53G9OnT2bVrF8uWLeOyyy5Dq9VSX1/P0KFDeeKJJ1i+fDnnnHMOp59++m/6+yT3584991w2bdrEP/7xDyRJUqo9vvnmG3r16oXdbue5557j8ccfZ+HChaxdu5bJkyfTv39/tFotcOxex/GWKj6fj6VLl7Jw4ULKy8u58847Fb/sXr160aNHD1auXIlWq+XDDz/k/PPP5+KLL/7dEY0yNm3axJAhQ5Rx4wcffECPHj3YuHHjLzYGkANWZbQVHxwtQi2BLbI68FgVdD9HeRfvAdmWiIxH/GsqQfopiEY6+H1lnbggmSMp/W6L+O3LpdCHWjZ+H6EWovdIoZRet7RZJ0Q4y7qJj4f1wvCBmYQtTl7YM5IXu72lLCe2lMorwS9xJe5HEuJyvKEWaKPI7ChY5/CvHSpt+39herWTePwVET/gi3+IabVaunTpQm1tLVVVldhsNsLhsJKiXFJSwscff0xRURFmswW7PQGXy43JZCYnJ4+amhqcThdWq5lAIIjTWU2zw6mUJAuCoKRV+/1+NBoNoihSVFREnz59CIWCZGSkU1NTTWVlBWazCZVK1eLfaKGsrIzs7FiJtclkwu8LIggSqanJBIN+1BoVZrOZhIREGhsbWwJY9FRVxVL+YjOSzQQCATQaDWazOUayEiOKZHWjTD7KATt6XZCEhAQcDicpKSm4XC78fj+BQIBQKKSUYksSseNUCagEAbVKTUZGBmaziWg0zNixF5OUlEh9XS0ul5vq6hpSUlKor69XSltl8lMQICcnJ6aqcLtQqQREUY3JaAQJItEIFRUVGI1GnE6XYtYfK1dTI4oafD5vSwdDakU4/R5xzjnnKH/37t2bQYMGkZubyzvvvKOEEfwSmD59Onfeeafyv9PpJDs7+6Dl2guPaUs4xpeuHi+VwbEinojUarXk5uZyww03cPnll7Nv3z5WrVrFypUr2bx5M16vlx07dlBRUYFarcbj8bBp0ybl+6JWq5XvU1FREf369ePkk0/mpJNOoqCgALPZfEhl0eFwrOcqvpRy3LhxJCYmcscdd/DRRx/hcDi47777MBqNvPPOO9x2223MmTOH+fPnM3nyZL755htuuukm/vKXv9C7d2+lHXq9nkmTJhEKhXjyySe57777EEWRq666irPOOou5c+cyefJkXn75ZfR6PTNmzFAmbzoi+Q7V/sOpaeXX4hXlsnpbnhiC1inq7a3fHtruOxgM8uqrr/L8889jNBp57LHH6Nu37+/6vtKJEwNBEEhMTGTfvn2Ul5fT0NBIdVUlffr0YePGjYoaKCUlhbq6OiorK8nOzqa5uRkAm81GSUkJgUCAbdu2YbFYiEQiZGRkYLVaKSoqIjExEb/fj06n+8VUbPJEqmxJ879QSfB7wZgxY1r9/+ijj/Liiy+yevVqunTpwiuvvMJbb73FyJEjAXj11VcpKSlh9erVDB48WCm1/OKLL0hLS6Nv377MmjWLadOmMXPmTIUQ+r1Bvufr9XrGjx/Pt99+y6effkptbS3Z2dmccsopfPLJJ3Tt2hWLxcI555xDcXExc+bM4e6772bMmDFcfvnlFBYWotPpWj2rO3r2xiv35PDIHTt28N5777F06VKam5tJSUnh3nvvxel0Ul1dTc+ePfnqq69wOp0MGjSI1atXY7PZWLVqFZmZmUyYMEGxaYk/tt8SZOLRbDYzefJkXC4X77zzDiNGjOAPf/iD8uytrq5m2LBhTJs2jffee4/PPvuMW2+9lVGjRnHppZfSs2dP5XqL7xe0Z5ESfz4ikYgiNti4cSP/93//xzfffEPXrl156aWXlKDPwsJCNm7cyLBhw3j44YdZtWoV3bp1Y9KkSQf1x35P6NatGxs3bsThcPDuu+9y7bXXsnz58l90n8cqPjgUYoSjrKD76RmiqOkkFbQTVhK//jFweq320Wpb/FSG3RGikqCkWXe03bZkqEpRBx7ZdSaXXceXXx+OfGy7v8MlX7eHiCTEwmEEyNM4mNX7Xzy49iq0bjOe9200T9NhEkJKkMyhCMa2qdQnArKyMiKheEEejgSNX7bVax3gf6Gn00k8/kbQ9gFkt1vp1asHjY317N23F5vV1pLcGKF///5s3PgDyclpuNw+JBqw2RKpqa1BbzBhT0iiqakJt8eH1WqnvmEvGzZ8x/ff/4BGo8bjDqJSqUhKSkIURXQ6HTU11VitFhISrAiqCAgBMrOS8Pm70K24G+vWf0dlZQWiqKWpqRG3262QfxJRkpIT8Pk9eLwuqqqqMJvNdO1aRCgUZM+ePSQmJmKz2cjK6sK/l3yKzxdTUEiShNvtRqPR4PF6kaQoHo+HYDCIw+HAaDS2lGsblHJmtVrE5XIBKOSp7I3pDwTQGXR4A16sFhtej5sIEiaLme7di/nh+/V0yUrDZjET8PmwWKw4nS5l9iw5ORmn06mE7MQCbOrp2rWIurp6LBZzbPAf8KM3GPC63Hi9fiwWG5mZ2fj9QaqqavB4YondPp9PGXwJyk34f8d/zW63U1xczK5duzjzzDMJBoM0Nze3mvGsqakhPT0dgPT0dNasWdNqG3IZlrxMe9DpdOh0ukO2Jb5zLg+gOyodlr0Sf62k8UMpLyVJwmw206NHD0pKSrj22mtxuVx4PB4qKyvZs2cP0WiUXbt2ceqppyIIAiaTidTUVLp06UJBQYESOiWbqHd0jO0NZNp7/1BKvMNBkiTUajWSJCGKIqNGjeK1117j1ltvZcWKFUybNo3HH38cu93OK6+8wt13383MmTN5/vnnmTJlCitWrODPf/4zf/nLX+jTp48yGDAYDEyePJlwOMyzzz7LvffeiyiKXHrppVxwwQX4/X6mTJnC/PnzMZvN3H777RiNxiNud/xxdnS88RMJ8vdcPlb4yc8xXuUaT3wfbr/xkL0jP/roIx5++GGi0SgzZ87k4osvRhTFQ7azE52An+4tLpcLUaOhe/duaNQqCgsLSUxM5PPPPycQCNDU1EROTg6VlZWK5YqsXvzxxx+VxPrRo0fj9/u58sor+eabb8jKylIqJLKysn6xgXVTUxMVFRV06dKllQ1NJ04sIpEIixYtOuJSy8GDB3dYajlhwgS2bNlCv3792t3X8VY8HS+09wxNSEhg2rRpzJgxg7Vr1+J2u3nppZdISUnhhx9+oH///ixbtoyTTz6ZyZMn88ILL/Dvf/+bpUuXcuqpp3LBBRfQvXt3JWRSvrbjA/Ki0Sh+v59gMEhNTQ2rV6/m008/ZcuWLQSDQUwmE1dddRWlpaV0794djUbDZ599Rrdu3SgpKWHVqlWMGDGCjz76iP/+97/o9XoeeOAB8vPzj9kW5ERCfpYmJiZy//33o1ar+fe//80LL7zA6NGjqaysxGKxKAq7M888U5mU/Oijj/j888/p168f5513Hv379ycpKUnxuJYnMuIrF2TldyAQYP/+/axdu5Z///vfbN68GZvNxg033EDXrl3p378/TqeTH3/8kd69eyshft9++y1ms5lZs2aRk5PT6jh+b9BqtXTt2hWAAQMGsHbtWubNm8dll132i40BjlR8IKO9Mmr4KeW6rQdkvIdie+u3Xe5IFH3tqRgVslL2CGyHKDwcjqScW15GLbRPOh4qBCeeNDwSAlFeJn5ZZX1iohv57yMhL+Xt9NBWkzN6L46ybOw7g9yw9jreGvhXXFERnRBB25LoHZJU6IUIQUmlpFrLPoiHIuqOxJuxPfVhe16M7R8HrcJoVHGqyI72rZRUH0r12PKaKBxZO9ou82uTl53E46+MjsoqBCEWJJOZmYHD2YQUFUhOTqapqZnq6hpOOukkln21nNS0dHr16oXWqkMUtTgcTtLT06mpqcFsNhMKhenatYj16ze0qCl12BMSCAaDSiK03++nb99+jBs3FqPJSHNzE7W1VeTn5yOKInV1dYiiGqvVgsPhZOjQoSQnJ1NTU4NOpyMUChIKBfF6PaSmpqBWq5TZPNlnMua9YkOtrsZqtVJevh+1Wq34JPr9fkSNpkVVGBuo22w2xdsvMTGJYCBEc3MzxcXd0Wq1BINBPB4PSUlJVFVVKYSTqBVRq9WxdO4uGezauYPvvttAUde8lk5VFEmK4vf7FNVmJBJR2pOamsqePXvIz8/H4/EQDoeJRMLk5eWyb98+RFHE5Xbj9flJSEggPz8fg8FEVlYWbpeHFSuWK0nDfr8flVqFIEA0KqFSCfwO+xkdwu12s3v3bq6++moGDBiAKIp8+eWXjBs3DoDt27dTXl7OkCFDABgyZAiPPvootbW1pKamAvD5559jtVrp0aPHUe8/nsSRv0uy4uxQqjK1Wq10KuOJokPhUCWpx6Pz2B65J3eALRYLVquV9PR0BgwYcBBhGq+Ybk/V2BHRdawqxp9DRAqCoJiOT5w4kbVr1zJx4kTmzJmD2Wxm3rx5zJgxg6lTp/L0009z9913s2zZMv70pz/x8ssvtxqYGo1GpkyZQiQSYd68eUydOhW1Ws0f/vAHLrnkEjweD/feey9z585Fr9dz6623tlLUHGm7D6VylEur5XMsfwbygLEj4lu+Rg+17bavyUSt1+vltttu4/rrrz8sId+JTsRDr9fjdDrZs3cvpRYL+/eXE41GqK+vJzExkWAwiNPpZP/+/aSkpNDU1ITdbm+xHIlZo5hMJnJzc9HpdNTX11NQUEBCQgLbtm3j9NNPVwbqvwQkSaK6uppNmzaxZ88ezjvvvE7i8QTj1yi1/CUUT78UJEmib9++3HPPPdxzzz38+OOPPPzww9x8882sXbuWkpISiouLWb16NQMHDuS0005j5MiR/Otf/+Krr75i8eLFZGRk0K1bN7p3705hYaHitx6JRPD7/VRUVLB582bKysrYs2cPoVAIQRBIT0/n9NNPp1+/fpx55pk0Njby1Vdf8Yc//AGn00l9fT0DBgzggw8+IBqN8tVXXxEIBJg1axZDhw49aBL090CMWa1WZsyYgSAIvPHGG+zfv5++ffsycuRIfvzxR0aNGsXu3bsZM2YMt912G3v37mX58uV8++23LFu2jJSUFAoKCigpKaG0tBSbzaZ41UtSLKW6oqKCnTt3sm3bNnbv3k1zczP5+flcf/315OXlceaZZ/LZZ5+xe/du+vTpw4cffkivXr3Yv38/s2fPJiMjg0ceeYSePXsq7f49nNsjgWyJ9UuOAToSH7T2TWxNKMoejW2XkREj3g6mYWIEmbrVujJhGfsdV1l1hCrA+HLuCAJqSWpJ1j6+10Dbsuz4/cYTjbJyEvipZLtNcE48SXikase2y8sEZFBSEUVQ1JcdISgH+rSQiI/lfcBlfSaT8KNI0vsil/gmgFvDDacuZ5R5C6IQ4QPHAHoZDlCqqyQoqdALUUV5KF8N8QRevNejrFKUlwtJrUm/eIKwPSKzPaJQ2V6bUxZts3z8svGEZEdtbQu51PxwbWuLow3DOd7oJB5/g5DTUCHm6bi7bDfNTQ7q6+ux2ezU1NSg0cQSrdetW0eXLl0UZaDT6WTPnj0YDAZFefDDDz9QW1urlHPK3oiySkan03HRRReRlpaGw9FEIOjH4/Gxd+8+Cgu74vX60ahFCgoK2L27TEm7djqd+Hw+cnJykCSJ/fv3E41GFe8xv9+PViui1+spKSnB6XQTCAQRWky4GxoalMGC3+9HUKEkVftbUqrlNEBBUJGfV0CPHj3YvXsPXbt2pbGxEVEUCQQCOBwObDYbCQkJ7N5ThtFoRK1WYzabsVqtNDc1s3r1avJzc+ha1JWUlBRqa+spK9urBMwAeL1eJSynoaGBLl26YDAYcDpdJCQmoxG1+AN+IGZwD5Cbm4fZbMHj8fDlV18pnpPV1dV4vd64AVE7murfGe666y7GjBlDbm4ulZWVPPjgg6jVaq644gpsNhvjx4/nzjvvJDExEavVyqRJkxgyZAiDBw8G4KyzzqJHjx5cffXVPPHEE1RXV3Pfffdx6623HhcCRSbqOpqtjyfa5Jntw63zS+NQxFPbpFZBEDoc1MeXbbe33s/Fz91GfPkxQI8ePXjllVe4/fbb+eqrr7jtttt48sknmT59Ok888QSzZ8/G7/czZ84cpk6dyooVK5gwYcJBykez2czUqVMJh8MsWLCAqVOnIooiF110Eddeey3BYJAHH3yQRx99FKPRyLXXXtuqlO1I0Zbklo8lHA4rAVzx19KhPEXlZY9EdSurd7///nvuuOMO6urquPLKK7n77rtbJWL+rwxiOvHLwmg04nK5lPCIU045hZUrV5KdnU1SUhJer5eamhr8fr+iGqqrq6OkpIRQKERpaSkDBw5Urvnk5GQMBgN9+vRBq9WiVqsP04KfB3mf+fn5qFQq9Hq9QvR34sTg1yi1PFrF06+F+Pvx8OHDeeSRR5g1axZLly6lurqaM888kx07dtC7d2+2bt1KXV0dubm5+Hw+rrjiCk477TQcDgfLli1j/fr1rFq1SrFIkvuSoVCIcDiMTqdDr9djt9sZPHgw6enpjBgxgtLSUn744Qeqq6vJyckhFApRX19Pjx492LlzJ927d+eHH37g1VdfRafT8eCDDzJ69GjlOxTff/gtk49yu+SKpxkzZmCz2Xj77bfZtGmTcl7VajXJycls2rSJ4uJiAoEAc+fOZcmSJVRXV7NixQq2bt3K+vXrAQ6qUpAtoIxGI0ajkSFDhjBo0CBSU1MZOXIk69atY9u2bQwaNIh33nmHiRMnIooijzzyCJ988gldunRh9uzZlJaW/u4nSKZPn84555xDTk4OLpeLt956i6+//prPPvvsVxsD/BSoIv2USIwALaXSHSVc/7R+jLZpq2aUVYHxxKWsWJS9FuW3jpSA/F9EvNrxUASlioPTsw+1vF9SY1SFuemiz/irfzQ5nzpJeMgFwRAff3s6b3Y/HW1TjLn7v5IAfz31NUxCEK3aR7QD0i3+SognH4+m3PlIIfKTJ2OkzTYPte+O1I7tEpItxKXc+/m11YxHgk7i8TeCg9VYEUAiIyOTQQMH8uWXy3A4HBgMxpbBbgi9Xo/X72PDhg0Eg0HS09NJTIz5KkYiEWpqajAYDKxcuRKXy0UgEECv1ytG7GJLGeY555zDiBEj8Pm8uN1uBEJkZ+dSV1dHbU0DuTn5lO3eh1arJTk5BYfDgSAILaXfUSwWC3a7XSEjZd8UvV5PJBKmoKAAjUbE4/HQ3OwgEo6g1+sVT0CXy4XBYECtUREMBmIhMTodjQ0NGI3GGPHncBAIBNDpdCQkJChJ13a7XQm6qa6uxmQxo2tJ6wbYtWsXkXAYiylWYikn9zY1NdPc3Ex6ejq7du2iqKiInTt3IgixJOqEhAQleTgpORm3x0tVVTXRaBSH04nFZCYtLYFwOEJ2Ti5SNEpdXR0fffghJpNJIYeCwWAc2fX77nAAHDhwgCuuuIKGhgZSUlIYNmwYq1evJiUlBYBnnnkGlUrFuHHjCAQCnH322SxYsEBZX61WK0EiQ4YMwWQyce211/Lwww8fU3viybZj6SDLirNjXf/nIp5gjN9/W0JLLlc+HDkqvxev6Gzb0W1PuXmivC7bEqL5+fksWLCAu+66iyVLlnDbbbcxd+5cHn74YWbNmsWTTz5JU1MTjz32GPfee28r8rF3797K52c0GrnnnnuIRCL85S9/YcqUKYiiyHnnnceNN96Ix+Nh9uzZPPjggxgMBq644grlHtH23BwOMlkYT/DGnz85UKYjdPQZtVWayMsKgsCuXbu47bbbKCsr46yzzuLhhx/GYrH8LLI8/nvTif8/IAgxDzqPx4PFEqtgsNutNDQ0kJ+fz4EDB+jWrRsej4eGhgbcbreSyq7VatFqtS2ezQY2btxIcXExjY2NSJKEwWA4YSS43+8nPT2dnJxcunbtypo1axRbiU788vg1Si2PxG7ltwD5fior3keOHKl48a5evZpdu3bRv39/Hn30UU466SQ++OADTjvtND777DOuvPJKVq9ezXXXXUe/fv1Yu3Ytffv2ZdWqVUqY5MaNGxXiPzExkcGDB7NmzRpOO+00RFHko48+oqSkhC5duvDNN9+QkZFB9+7d2bp1K/369eO1115j4cKFfPvtt2RkZPDAAw9w2mmnteon/N7IMVmdmJiYyPTp0+nVqxdPPvkkd999N/n5+RQXF1NaWsqiRYs45ZRT+Oabb9Dr9SQnJ3P++edz880388MPP9DY2Mj27dupq6uLCRaam0lISCAtLY3GxkZ69+5NaWkpK1eu5OKLL+add97B7XbTo0cPXn31VW688UZMJhNvvfUWixYtYv/+/QwfPpx77rmHgoKCX/ksHR/U1tZyzTXXUFVVhc1mo3fv3nz22WeceeaZwIkfA7QONYnRLyohCi3J1crvdtaJ93iMf+8nZeLBOrK2JcpRSUAlSIf1ZvxfRxQBLbHS57YEZKStkvIoBDgRSeB8yyY+HlGKc2cG6mwTqrCE6I0STJAI2QXsm1RoK7XMO3AmeaYGbkj6LxbVT/nU8YrPKAenSAMgdUz4HQvaK22O8lN5dLya8mjUivDTemLcaQy1v+hvEp09td8QWquxBKJRSSHutm/fyb59+wgEgpjNZvz+IOkZGVTXVNPQ0EB5eTkGgwGr1YrZbGbv3r34fD6SkpJISUmhpqaGSCRCKBS7PI1GI3qDgcLCQsaOHauUbfj9PmpqaigsjKkJpKiAwWAkOzub9es3oNNpqaioUDyfdLpY2rPdbic1NRWn04kkSZSUlGA0GmlsbKC6ulrxnauursFitbBv3z4kSSIrK4uamhoaGxvJTMvA43ErZaVer5e6ujrC4TDegFcp7U5OTsXlchGJRPB4PNjtdkRRjJnMSxK2BHvMD7JF2WkwGPD5fSQlJjJ27FjsdjubN21h06ZNWK02LJZYexISEggEAtjtdkW55AsEaG520NzsoKGhgbS0NERRh6jTk5HVhYqKCjZt2kxlZSWrV39DRWUlBfmF7Nmzh3A43FKmHWn5XAEEYh/zb3cW+VB4++23D/m+Xq9n/vz5zJ8/v8NlcnNzWbJkyXFt189R+LVVCsaXv56oz0i2CZDRXvjNkRCI8uvQmtg6HmrOoz0n7ZGb8nHFH0t2djYvvPAC06ZNY9GiRdxxxx3MnTuXOXPmcN999/Hyyy/j9Xp56KGHuP/++/nPf/7DLbfcwsKFCykpKVF8FK1WK/feey+BQIC//e1v3H777Wg0Gs466ywmTpyI1+vl2WefZcaMGZjNZsaMGaNMRBwJZOWDfJ3If0uSpJAeh0uvbot41W3b8yJvu6qqirvvvpv169czcOBAnnrqKSVt+Ej28VtWrHTixCBevWQwGHC5XASDAb5a9hXXXHU15513Hn//+9/p37+/4g3bvXt3NmzYgMfjQa1WK5UMe/bsYceOHZx11llEo1HKysooLi4mLy+v1X3rl7zmunXrxrnnnU9KSio2qxlRFH93ZMn/Ek5EqeXvDfF9kqFDh/LUU0/xzDPP8MUXX7BixQpuueUWrrrqKtLT0/F4PLjdbiCmZvzuu+8oLS3lww8/5PTTT2fs2LHKpK/ZbGbo0KGUlJTw1VdfYbVaKS0tZdOmTYwcORKdTsf27dtbqoycuN1uCgoKeP311/n6669ZvHgxXq+XQYMGcffddyvVA/D7UM0fqo3yBO2YMWPIz8/nhRdeYNmyZUyYMIFzzz2XSCSC0+mkoKCAiooKevbsybp16zjrrLOwWCwMGDCA0aNHs3z5cs4880wqKirYu3cvw4cPp6qqikWLFnHWWWcRDocpKysjNzeXdevWceqpp5Kdnc3HH3/Mpk2bWL58OQaDgRtvvJHx48crJPzv4fweDq+88soh3/+1xgByKTSgKBzjCcIIKqKSqqVcOhL3fmvKRyVEiSiJ1+3rx2SvwhAgClGFfDxc+w7lCym2tD2elJO3KxOa7XlGHkkadqv07JbybrHFH1HxtGwbdtOybrRF4RlPJmrb8c9UtSEU5eXjCUi1cDDp2FYtqReieCW1cl5lheT0/CVMGDSeqClKSpdmTNogs3NWEJTUPCiMxb5Fw/CknSz811n8p2chL/V+E70QQSSqlHgr+5c92Ft+Qi3vhyRo24uQCcL41Or4kun45doivmxbLaCUtB+O2IxIP+1LFA5+T267jI5Ujr92SXVH6Oyp/YbQeiApKANqpyuWJp2WlobJZMRqtWLQ66GldNrn8wExdV9TUxOhUIjExESFkNy/fz8Oh0Mpo5D3UVJSwoQJE/B6vSxevJh//OMffPrpZy0P23K2b99JIBBi164yunTJQa83tJjOdyEnpwsqVazcePfu3UQiEQoLCzEajWRmZtK9e3dEUUQQBOrq6nA6XT+lDLeoJdVqdUs5dizNV6/Xk5iYSHZ2Nna7ne7du5OdnR3z4CM201ZXV0dVVRV2ux2bzYZaraapqQmDwYBGo8Hr9dLU1KQMnrRaHQ5HM4mJSfTs2Quj0UhVVRVqjUYp5RYEAZfLRW1tLX6/H6/XS7du3ejVqxf1dQ3U1tbh9ngJRSUaHU58gSA6g5F/Lf6Elxe+wqxZj/CPf7xNdXUtuTm55OXlkZycjE6nIxKJKKrHGBHTqS46nognC+NLYI8E8cvHryeXtsrb/3/snXecHHXB/98zs7O9716/y92lJyS0QApBRFRARcTy+OjPxmN7QJCiguYRHoqCgg/Si0i1PYr6oIIKAlIlhE5C+qVdr3vb2+zM/P7Ym2Fus5dGQt0PryV3uzPf+c7s3O7OZz9ld+vsLxuzdR+M+6q1tVYus6s5WUPprWO9UbZyq5p0qrIfURSpq6vjf/7nfzj11FOJx+N861vfQtd1rrnmGhobG/nVr37FT37yEy688EKWLVvGq6++yumnn86GDRsm7ZfX6+WSSy7h1FNPJRaLmTZuh8PBd77zHU477TQSiQTf+ta3eOCBByY917uCda6V6ljjebKqVvfkQq7yOaxGaMZiMVasWMFDDz3EvHnzuP76681g+j0lHfcUNeXjuwMOh4N0Oo2maUQiEVRVxe/3T8pO9Xg8xONxFi1ahCRJZpajoihs377ddAT4/X6OOOIImpubgcktuwcS+XyeaCTCggUHAYLZWF/DgceKFSt44okn2L59O2vWrGHFihU89thjfO5zn5tktTSswv/xH/8xpdXylVde4cEHH9yvcStvFVi/AASYPXs2P/nJT1ixYgWhUIhXXnmFCy+8kDvuuIPf//73LFiwgLVr13LCCSdw7733IooiS5Ys4Z///Ccul4vFixfzz3/+k4985CP8/e9/R9d12tvbeeyxx5gxYwZdXV0kEgmOOOIInnrqKQRBoLOzkwcffJArr7ySX/7yl9xzzz14vV7OPfdcbrzxRhYuXPiO+7sxPkstWLCAq666issvv5z6+nruvPNO7rvvPi655BKGhoYYGhqivb194kuYIoFAgBdffBGXy4UoimzdWo6V6urqIpvN0tDQgMPhoKenhyOPPJJHH32UhQsXsnnzZl544QWeeOIJLr/8ch5++GEOOeQQbrrpJs4+++yd8k5r2L+w5iZqeplctBJqlcsqukQRaVLWYzXVo/VWbZyptmGFpgt7pYKsLIbZU1QW41SOaYw3KeuyYr8qsyY1hKr37apoxiAZrWSjdRxznnr1khlJ0FEmSFGwkLG6QJstAXUFpLSErgv47AXcYgGnqBB+RaLxyRg9+TDzl29FvjfEdQMfREajoEvmfmf0skAgr0uIQFaXJhSQuknSaVVulRZp43frMlMfk+r/WlG5vjVz0gqRyYUyu9v2WxU1xeNbBFOplzKZDENDg7jdbmbOnMnAwCDZbB4dnb6+PsZiYzhdLjNr0cg6CoVCeDweXn31VQYGBojFYrhcbrPsxefzEQgEyrmEjzzCiy++yNjYGD6fD4fDQamkEQxGGBkZw+Vy0t/fT0dHBy6XwyTnyhfAAtu2bWNgYAC3200gEDCD6YPBIJFIhMbGcsPutm070DSNdDqDzWYzLcmGTUK22VBKCh6Ph2w2i6qqTJ8+nXQ6jSTZKCkquVyORGIHnZ2d+P1+isWi2bYZDoeJJxLouo7f76d/YACv1814bJSA38+cObMnFESDDPQP0NjYyJYt2/B4vEQiETNzTZIkAoEA8UQCURTZtKkL2W7H7rATj8fZsaOb3/72dwwPD6MUi9hkG263m5NPPplMOkNsLGZa3n0+n0UFMvn5ruH1Y29VeNa/Myt5ZG0hhtesz7sqqNmb7e4OxvasML54qMwb2h2qjWNV6+0p9kfxjJWImMpObBzncDjM5Zdfjsvl4tZbb+X888/nhz/8Iddddx3f/va3+ctf/kI2m+V73/seP/zhD3nmmWc488wz+dnPfsb06dPNYxUIBLjkkksoFAr87//+L9/85je55ZZbeO9738t//dd/kcvluOuuuzjnnHNwOp0ce+yxpvKx2jG27o+VqDT2RxRFs6Co8nnaU1LTans2lDLZbJYrrriCP/7xj7S0tHDdddexcOHCfXpOqsE6N2vWaQ3vbBhfCCaTCRRF4Xf3/I4vffFLLFu2zMxo9ng8BINBYrEYbW1t5HI5Ojo6UBSFgw8+GIfDQSQSQZZlMzIlkUjg8/mAA//+VigUcLnclB0EGl6vt2qsRA37H281q+VbHdbXd6/Xy6mnnsqxxx7LXXfdxQMPPMDGjRvZtGmT+eXSxz72MYrFIuvWrePQQw/lkUceIZ1Os2TJEq677jpOPPFEfD4fmzZtYu7cuTz22GOMjY0xY8YMVq9ezYwZM9i4cSNXX301jz76KH19fRQKBUKhECeddBKnnnoqM2bM2Ol9650A4zgb781er5dPfepTvOc97+Gvf/0r99xzD//85z955JFHaGtr46WXXqJQKJjqxfvvv99sAX/88ceZPn06TU1NrF+/niOPPJKjjz6aVatW8Z73vIfVq1eTy+X461//yvXXX48gCHR0dHDqqady0kknma+FNbxx2B0RaNh8NV1Em6B21En/li3au8OkzEhBnbjv9f0NWQlC6327K2PZk3El9J1Umfu71GZ/QEInP0EUOgV1UkGNhI7dWSIwL8Xyhq14bQV+uu14hh9vRj0uTXitk789toivnfAID3c1sf6ueTx89jaWuLuIl9xEpAxuoQSUCc2YZicoFoGJ46zrVZu+zVbuN+h7ecN2bVVIvtNQIx7fwtB1HUVRkCSbWXiydu06PB4vsuwof+AXBPOi2eFwUCwWGR0dxeFw0NzczMDAANu3bzc/kGezWQQgFArhdDq55ZZbGB4eJpfLI4kSviY/uVyBwYFhioUSkUiYdLp8ISKKIl6vj2nTpiFJEh6PG4ejbNvK5XLIskxDQwPDw8MMDg7S2NjI8HACSSqTCqFQCEUpkcuvw+v1Mjg4aIZjC4KAz+9FFAXTMp5IJGhoaKCzs5NYbJzRkTFsNhs2m4yu64yPj+N2l8lUu92O1+ulUCwiyTbS6XQ553J4mFQyRS6fw+ksF+50dHQQn8h4LLd0gq5r5HI5PB438+bNY3RsjO7uHhwOJx3TO9m2bTuvrl3L5i1b6OvpQdd1HE4nLo+HgM9HY2Mj2WwWv8+Hz+tFFEXy+Ty6rpn2dl037NY17C9U2lOrEfiVZNfuVGjGB1crCXSgPphb52vNCxRF0bTvvl7bd6Var/KxA7VvVtJxV9uxzs/n83HhhRficDi44YYb+P73v89FF13EDTfcwLe//W0efvhhMpkM5557LldccQWrVq3ijDPO4JZbbmH69Onm8QsGg1x22WUUi0X+8Ic/mMssX76ciy++mHw+b5KSP//5z1m2bNmkC8Rqc63cF8PWtbf26mr7XrnNfD7PLbfcws9//nP8fj9XXnklS5YsqbqNqb60so6/K0xFstfwzoQglHMevV4fRxxxBJs2lDPN8vk8Q0NDZLNZIpEI7e3t3HfffZRKJURRpL6+Hq/Xy8jICM8//zwf+MAHaG5u5vnnnycYDJLJZPB6vW9IyYvf78fhLBOemqYTCAQO+DZrKOOtarV8q2AqtbvxWUXXdWbMmMEll1zC5z73Of72t79x//3309vby3PPPcfzzz8PYNqtu7u7ufvuuzniiCMIBAI8/vjjeDweHnvsMTOL9YYbbqBUKrFq1So0TWN8fNyM+Wlra+PEE0/kpJNOYs6cOdjt9knzeqe97lc6CQCampr4j//4Dz72sY/x+OOP8+CDD7Jq1SpuueUWnE4nf/nLX2hvb6dUKpFOp2lvb+e5554jFAqRy+VYuXIlzz33HENDQzz22GPcfPPNxGIxnnjiCWw2G4sXL+YjH/kIH/jABwiHwzu5yyp/ruHAwCARDYu0lUiS0JAEDdGiJSs/rk1SPFrXqd4GLU5aZl8Jx6ks0iZ5aqjqLGpFg4SsXLfaPCvHNOdbxcq909yqLGu9vxp2VSyzy/UmyGBVF0jpMg+mFjLTOchc+1DZPj/Rrq0ikB91MaNulEM83QSlLIHmHNd31OF5ycvooVD/vMZd7Utp8MnEjihx0+8/wvVzMoib3dgWJGnwp3hf/Sam2Uf5y8ihnNvyD8JiHgURJohOSdCrZi5aG6R3B2t+477YnSeRj5btGupLqyKycl67kw9Y13uzUCMe36LQdZ1SqcRYLEY6nSaTyeJ0OjnssEN54IF/kMlkkW0OfD4fuVyOzZs3EwgEaG9vJxQKkU6nmTFjBtu3bzfHzOfzSJJklsIoisLQ0BCapuFxe8jl8gwMDJZJQWGIbLZcQjNtWivpdIqDDjqIl19+EbvdTiaToVQq4fGopspRkiTa29sJh8M0NDQQDAaJx8epq4tSKBTweDz09r5EKpkkECirIT0ezwTh58Ful7HbZfL5PKlUCpvNRjwep76+HlEQUUvaRBttOW/K7/eb+VOSJCHLMtG6KOPxOA6HA7fbTTI5jiCUiVa3200+n6dYLNDa2kpPTx/JZBqPx00ikSCTyeDxlO3X5TZqCZfLzfP/+hdPP/003Tu6EWUbNruMKNkQBQGf14tNtiNMKEllu0wykUIQBBwOB/39fWZjtq6XRd21zx/7D7tSp72eMa1EkKGCtW5jKkXbnpJAlarAyu1a1Xev9wNrJWFWSTTtj2NWTeU4ldJxVzBUCt/73vdwuVz89Kc/5ZJLLmHFihXcfPPNfPvb3zZbPs8++2yuueYannrqKc4++2xuueUWmpqazO1Fo1GuuOIKSqUSf/rTn/jGN77Bz372M5YuXcpll11GNpvlz3/+M9/85je5/fbbOeywwyapS6vtX+Xjr+eirRqhrOs6qqryu9/9jv/5n//BZrNxySWX8OEPf3i/XSBaz19D5WgUF9XwzofhCHC5XLy69lXGRkfN4gSns+xuGBoaMr/4GxwcRNd1Nm3aREtLC/l8nuXLl9PZ2YnL5WL58uUkk0my2Sw7duwwvwA4kHC73SDkyeXyjI6N4vP53nEESg3vXBjq/Llz5zJr1iw++9nP8sILL/DUU0/x0ksv0d/fT3d3t5ndvnnzZm688UYcDkf5S++JGJ/rr7/eFCUYRKPD4aCxsZGDDz6Y973vfSxevLj8GXov3offaTCcYHV1dXziE5/gQx/6ED09PTz33HOsWrWKTZs28eqrr6IoCuvWrTO/9H3ssceA8mdAo5xT18tfdBx++OEcddRRLF++nFmzZuHxeNA0zSyXe7ce6zcaKiIqInZUMAnHyVSMlZCTUCfZpK05jyripFzHytzIyuxIUdDI6zbkCdWjdcyqbdjWcSvIOLMhWy8vWzSVmJbzSBdN+7G5d1WIS0WXcAqlydZqYWc7ttnMze7JS2uDt0EUVrNdaxPHVtPL+2jsZ9V8R3QLESaQ121kNTsXvHAKXzxoFbOdA2wr1NOTD7M61kz4ZYmjlm8lpnrZUmigSY7zqUXP86expcgpgdQ0kbpfu7DlSnT8UaTkUekPughuAaHLz7bFXpJ5J7mijM+VnyibEV6z1FtszJP2m53vnwp7U1ZT7X7V8rNUZT7Geir7RmoasJKrYsX9Bxo14vFNRLULfmsgdTKZZM3qNWYG2o4dO8hm88ybN4/Nm7vweLwwOko6nWZsbIyuri4AWlpa8Hg8JmFiZJjomk4gFCoXwqCjCwJev594PEGxpGKz28nm8xSKCjbZQTyRYGh4CIfTjsfjYnh4mEAgyODgIAsXLqSrq4tAIIDPG6BYLDDQ309/fy9OpxOPx0V/Xy/TprWZ+XJut0w0GsFut9Hb24PP6yObySDaJOx2GYfDTmtrK4VCgb6+PgYGBgiHwxx22GFs3LgJm81OsVjE4XDidrnJZLOIkkQiHsfj8ZiEjSzL9PX14XCW1ZSyTWTp4sUIQvlLpEQ8RXd3T1k14YhPFNgozJo1i7HRUf71r5WEwxG2bNnKqlXPsnHzJhSlhOywI9vtKKUSTqcL0Elns0ScTlKZNKFQiNmzZrNx4yaSySROp5NkMkkinkDXy89t2dpSUz7uLxyoPDErCWiUtMDekWh7CmMfjJblA5mRZhCOVmvt/lQoVdrY9+VYlZXV5Rwql8vFj370Iy677DK+853vmOTjqlWruOKKK/jP//xPfvazn/HII49w7rnncu2119LU1GSOFY1GueqqqyiVStx3331mKc1hhx3GFVdcQTqd5qGHHuK0007j9ttvZ968eebzYCWXq2VUWrE/zgkj6uHBBx/kwgsvJJ/P873vfY/Pf/7z2O32/XbeWQl1eOcpXmrYPcpkhUhPTw+jwyMsWLAAQRAoFosMDQ0RjUZZu3YtqVSKeDxOXV0do6OjAKY1MRKJkM/nyeVyjI+PM3fuXOrq6g74Bbeu6zzzzDM0NDSCINLb02PavWuo4e0E47U3Go2airlisciOHTvYvn07L7/8Mj09PYyNjRGLxVAUZdJ7uCzLhEIhgsEgbW1tLFy4kDlz5tDS0oLX6zXdUMZ78d5EtrwTYP2S0OqscLvdzJ49mzlz5vCZz3yGRCJBX18fw8PDbN++nf7+fkZHR833fY/HQ1tbG83NzTQ3NzNt2jT8fr953VF5fKFW6vZGQtNFVEGjMquxEpXk2s5EmFZ1uTIppZnlNMY2jRZtdMkkH6uN+1p2o2gSgkoVEnF3UBGQ9lJhaa8gUqca11A/TmVXt5KNUykbd4dqZGxRF7ALGpuVCCvWfhxB0Dm0rZeHB+dCI9z+zHvwdsm4hnTq1qYYL7mRxRJ/6zkI+VdhxFOHEUuQr4OD3r+Jnltn4Xuhn+7PTsPTr6FLOiNHqXjrM7R7M7hsCttXdlBapuAUSsQ1B2Exv8vjszuIWEhCff9Y5PcEMph0u1Vl+VZHjXh8i8BKOBo/p9NZNK38RplKZZg2rYOtW7cC0NzcSCw2js9Xtif39paVdVu3bkWSJHw+H06nk+Hh4bK9WhAQbAKpTAq3z8OSZcuIRCKMjsdBtBEbG8fn9SLbS2RzOYbHRikWC3jcbtauX09zQwOlokI0GkFVS4wMDxHwe3G7HIgihEN+ioUsNpuAopQo5LOk0wkyaTf19fUMDw8zPDSAXZZA10gmxrFJIsVikfbODkRRQFEUent78Xo9SJLIzJnTGR4eZuPGjTQ3NeP3Bdi0aROqUm5QDISCpNJpXC4X8Xgcp9NJoVhERyeeiiPnbeglhWDAR0d7G5FwmP7BASJ1DYyPJ0kmkxSKBTRdp6WpGZso0drSRiqV5c9/uo9XVq+mWCyiATZZxuP3UcjlkQQBNBVRtqFqKk6n02xjTKXT2GwSoijQ0tLMunVrWb36VTRVQxRtE8/nm3SSvQNhtdVMRdjtjd13KlRar/cXWWMlNKeaS6Uizrqf+2rttZJqVkXn/viwXLlPUyn7ppqf8ZjL5eIb3/gGdrudiy++2FQvXnvttXzve9/j0Ucf5eqrr+YrX/kKd999N3//+99xu91cddVVhMNh8/mur6/n6quvplQq8be//Y3TTz+dW2+9lUMPPZRrrrmGb3zjGzzxxBOcfvrp3H777cyaNWsnZWNlmcz+hNVq/+yzz3LeeecxPj7O17/+dc4880xToW6oZCrnY53TrkjrSmUt7F/SuYa3PoznPp1O43S6eO8x76W3p4dt27axePFiOjo6WL16NStXruSDH/wgzz//PAMDA2zZsoVwOIzL5aKzs5OnnnqK/v5+SqUSNpuNnp4eZs2adUBjG6z7MHfuXF59dR2x8XHS6Qwer+eAbLeGGg40jKxFSZJwOp243eUCyUMOOYSPfvSjqKqKoigUi0WKxSKiKKKqqrmew+FAlmWTZDQw1Xv5u9H+W/n+bSVg7XY7dXV1RKNRc/lqecfWrGyrI6Vy2XfLMX2rQKqicpQmKRgrM/tEZEGZnNMIyIJq3ldEmrBgC6CLSJbHrOSjlUgzsiNhohl7QklXSeQVJ+a0tySXOTfhNTLR2ng9FaxW6mqkolXtZ44lVCr9yqod4989gSxoqLpgNkpXg5V8jatuUptCiCUYXlRgR0+UOwaPwtkno0kQ3JRFGkmwJt7M0dEcZ8x8jDtypzD+z0aUNhXvNokX1kzHeXKa8Etesgtz2LIuQAW7hijo5Es2ugfDuEoQ2xzmxrrjOCXyAo1Sds92agpoMOm47CuBubdQeE2hKAv7Zp+utF6/ERbsGgXyJmGqHDrj33Q6zUsvvWRagHO5HDabjY6ODtMyEAoFSSQSNDY2Mm/ePBKJBPl8nlKpZH6DNzg4aG5P1zXQtInl51JfX08iHsftdhGJhMnn8wiigNfrQZZlNE0lm8vQ39dHKp2ku7ubRCIBgoAgiGawfCqVYmxsjPnz59Pc3ExTU6Np+zYs3WXbcT89PT2mPTyfz5vt06FQiFKpRCaTNvfB5/Pi9XrZtGkTY2NjZo5kSS2Ry+XIpDO0tbXhdDrNxk27o9yQbZMkiopCLpfjkIMPZubMGabKK5VK09DYRLGoYJNstLW14fV6UXWdV9eu5/e//yMvvPgCRUXB7nLhdLlwezzY7XY8Hk+ZgNJ1crkcpVJ5LpIk4fV62bF9O06n08zbrK+v5+WXX6a7uxdB2Dljr4a3D6zEz+sp4rASTbu6ODjQ2ZIGgWq1X1vnN9U6U8EgMWHXROqezM0Yw+l08pWvfIUf/OAH2O12rr76av73f/+Xq666ig9/+MP09PRwyy23cPLJJ9PY2Mgf//hHLrroIhKJxCSyrqGhgWuuuYbjjjuOjRs3csYZZ7BhwwZaW1u5/vrrWbZsGS+++CJnnHEG27dvn0TwWsnmA0E6Gq9LmzZt4uyzz6a7u5uPf/zjXHDBBWYBl1EC8HpfP4wLrlqm47sXRoyLKAoUlSJdXV3EJiJdbDYbzc3NdHR04PF4aG5uxuPxmNmPUG68HhwcpK+vj3Q6jSiKzJs3b5LSeH/P1wpVVenr6yOTzSDLMtlcHo/HW7vgr+FtgUqFnCAIZuGTEXlh/df43BkKhWhoaKCuro7Gxkbq6+uJRCJ4vV4cDoe5TuV7+65u7wZMdSwq77OW+ZWz5CffjOWN42z93Vo0924+1m8GDNWhYYWWprBNW2G1TIuCNlG+sjNxaaCSsDPIR2sztpV0LM9jZyu1uAubtKKLaHqlBbz6uoZVXNFfs2MXea3Nu3I71bZXtela0KtmPsJreY/WlmqjnVrVy3Mx7pfRzLlZSUdDNWnAOaESLeoiQSkLoo5zVGBHbxRp3Ibc7cCegMLCLPkGB/HFzRwS6mNHLsJIycfYfBtySoeAgntIo/2vOrPqR+j6Ygipx0k+AraUCJpASRWJp90Ikk62WUNzajy+dSY9xcik/bQ2llfeyvuzM3FWSd4Zv1sbsPcUkrB7i7ZW8fOefJLf3Vgy1fftQGCvtvGjH/2II488Ep/PR319PaeccgobN26ctMyxxx670wvuaaedNmmZ7u5uPvKRj+B2l9Vw5513HqVS6fXvzdsc1gvCTZs2sXr1atP+5PF4GBkZQdM0FixYQENDAy0tLbS2tpJOp/H7/WiaRjQapb6+HkEQ6O7uZnx8fELRJCCJIgsWLuAD7z8On9eL1+MhFAqQSMRxuV24PS4zXzGXzyKKItFolGg0zODgINlshpaWZgShnBcZi8UoFovU1dXhcpWzEf1+P263m1wuRywWo7W1lXw+j9vt5tBDD8Vms03koMhIkmQG1o+OjuL1ehDFsq3VbrcTj5ezIDs7OxiLjZHPl5uuFyw4iPb2aeRyGbxeNz6fh7q6KMlkHJskItlEPF5vWa2oqjidjglSpEQwEEAtlSaITT8+n5+6aB0trdOIxxPceuutrF6zBkkqf9BQSxqhUBiPx4vX6yMajeKbaNOWbTJ+vx9d1xkaGmLr1q0Mjwyzbt06duzYgaqW8y937NjB3//+t0mtmzUCcv/i9Raw7ArWD45WZdneftNttexWs26/ng+plbmKu9sf6/aqnZPWsay26anmZ+yTocLYF7Kx2nEGcDgcfOUrX+Hyyy/Hbrdz4403cvfdd/PjH/+YT3/60wwNDfGrX/2K4447jnA4zC9+8Qt+8pOfkM/nUVXVJEObm5u58cYbOeaYY3j11Vc57bTT6OrqoqOjgxtvvJHDDz/czIvs6emZZEffH+eV9TmyHltd1+nt7eXcc89l3bp1vOc97+Hyyy8nHA5PKq6xqm6nGneq42rASnbXLobenRAEwcwhi8cTzJkzh0WLFpnnTygUorW1lVgsRldXF6VSic7OTrZu3UoulyORSNDZ2UlTUxPpdJqmpibq6uresFb04eFh0uk0B82fb37WcTmdb8i2a6ihhhpqeOtBRUAWXuMRpIlsR6siUaVMThaRJtmfJy8jTFIkTmU9fo3o3LNruZ0sxogmWWjddiWs4xskaTVCzApDEWm0WVsJx2rzrTbGrsaH1whIKxFprKcgIqKX26itisspinQ0BDKaA+ewiCYDJQH/7HEEVSDbqNMYTiLldQaPEvhI4GUKmoRPzCPooHgFGuoSOGMqrr4MhZKNsz7yN8QSNDyv4OkXQID8Dh/FHg/SNhdCpIDgKaEOuegthukp+cnr0qR5VrvtyXEr78+ub7uDlZgzyMtdkZjGuMbjleuo+s5k5U7b2YN57S/sFfH4+OOPc8YZZ/DMM8/w0EMPoSgKxx9/vFmeYeBrX/saAwMD5u3KK680H1NVlY985CMUi0Wefvpp7r77bu666y7++7//e//s0dsEU6mc9AklXVdXF6qqYrfbcTqd5YxGXSeRSGC32wlNZDWGw2G6u7spFossXLgQl8tlkns9PT0TJSnlp7m9vZ1PfOLjzJs3l46OdlpammlqbMTjdpNKJvC43Uyb1kZdNEJrawuhUBCbTUIQBZxOB6IksHrNK/j9PgqFnDlnSZJobGxkYGAASZJoamoyC2+SyaSZBSVJEqqqkkgkiEajRCIRBEGgLhrFbrejqiqRSBifz8fcuXNpamoiFArR2dmJ2+2ic3ongYAfWbZxyKEHEw4H6evrJRQO0tzSiM/nI5VK0dPTUz52sg3ZLjNr1mxsNolCoYDD7sDlchOLxWhoaMDr8yPLdl566SV++tOrGRgawm53oKo6SrGEKEloWvliP5vNmOHdTqcTu91OIBCgri6K0+lkcGiIcDjC+Pg42WyW3t5y3qUsy/zzn49SKORR1TezS6qG/QHjW3GDBNqdUrASBzIvshJ7SkgarxFWos5Yf0+3YSXH9oc6D157fXE4HHzhC1/giiuuwOPxcNNNN3HLLbdw0UUX8R//8R/E43Huv/9+Fi1ahNvt5uabb+aGG24wVcnGPhrk47Jly3jppZc47bTT2Lx5M9OnT+eGG27goIMO4tFHH+Wcc85hcHBwUgTG60G1Y2Eco9HRUc477zyefPJJFi5cyDXXXENra+sk0tH413iPUFV1r54bqJGO72ZU5pSWiUdYcNACWltb8fl8/OQnP2FgYACv18vKlSvp6+tj7ty55heKRx99NIIgMDo6yuDgIKOjo0iSxPj4OM8++yxr1qxhbGwMOLB2w/r6ehYuXEgwGGT27NnIsoxc0dRbQw011FDDuwtlUm5yAQy8RjoqukRRl17LZoRJxN/k5YU9skQbykerAtKa97gnY0xVQrMnsM7VsHtXjmeoGI0MRyPPcX9Zgo0SGREdGQ15gtpSdNEk7KoSdxOEnixoZDQ7mh1y9RqL5m2jWLIh6KBPy2ETNTRZQI8UeT47Hb+twHT7MIFjB1G84LUXkbMlxLEkw2kvDlHBd/gYPZ8pkZyhITlUXEMi0ZcFnKMCWlFCz9rQRZ2+fNA8TnldMudZrTjnnYq9JUZfL/Yq4/GBBx6Y9Ptdd91FfX09L7zwAsccc4x5v9vtprGxseoY//jHP1i3bh0PP/wwDQ0NHHroofzgBz/gu9/9LhdffDH2d/EHSOOicNu2bcRiMTweD4VCwWyqFkWRWCxGNptF1/Uy+eh0k8lkePnlV2hubmF0dJRnn30WWZZZv349o6OjNDTUc+KJJ/De976XppZGEokkifg4jY1NvP+444iNjrFt23ZSyQTTpk2jLhqmuaWZaF0UtVQqt1JnMjQ2NvCvfz3F9u3b+MAHPsDQ0BCSJJmN1f4JJaDT6WTOnDkMDw9TKBSw2+3m3BVFoVQq4ff7JnKmnKgTIdkOh4NAIIDf7yeXy+H1eslms4yOjtLe3k6ppNA2rZUXnn8BQYRAMMDg0CABn5dwOESxWESy2Vi/aWNZlagUETSZlpYWIpEouVyWTCaD1+uluaVlIhNS4be/u4ff3/N7NB1k2UGppOJwuAiEy3mWmUwGl8eFppVbtUdHR8vkkySiKCX8/gDxeJxIKIzNVm727u3tBcpqrWg0ysBAP4ODw3R0tAO1HJgDif11bKcap7J0xlD6TZUBaCWIVFWdpDLcVxvy612+2hytykerOndXsBJbU+3/7nKm9uQxo8nzM5/5DLIsc/7553Prrbeiqirf/e538fv93HTTTTz11FN0dHTQ1dXFlVdeSSAQ4NRTTzXHMOIqbrnlFr72ta/x7LPP8o1vfIPbbruNhQsXctNNN/G1r32Nhx56iPPOO4+rr76aurq6Xc5xb1Sm1uV1XSeTyfCDH/yA+++/n/b2dq677jpmz5496fyozLczzjvjXKqW01g5J6tdvFrWYw3vLjidTjRVQxAFtmzdykHz53PiiSdSKpVIJpM0NTVNlK85OOWUU3jooYeYPn06DoeDRYsWsXr1atavX086ncbtdqOqKvl83ix5ORDFCgbh3tfXRyqVorm5FYRyKVctq7SGGmqo4d2NvC4jC6WJpmsmmq4tzdWW7EJ1Uq/va6iWy1iZB7kraLqIfaJAxiAEd7UsuymY2d0YBqxKSHQJVZiseqzMejyQ5SdGrqOhepyqjMYg91RdIKF6KLl0jlu+hvXjDWRG3IhBjSXtO+hNByl5RHRF5Lc7FrG0YTsRKcOX2p/hJy9/jC2vtjB3JMbQCW18svNRAGaFRngp58A7K8PYqA9BBV0EKadj75cpRlV0j8rqkSYyUTsNpM05GYTo7sjHvSVuq59xO+NAkn9TjW1VSx5ovC47dyKRACAcDk+6/9e//jXRaJQFCxawYsUKMxsIYOXKlSxcuJCGhgbzvhNOOIFkMsnatWurbqdQKJBMJifd3mkwLgILhQKvvvqqeWx1XSeZTOLz+UzFjsvlwuVyUV9fD+gsXryYj3/8E2zcuJFXX32V8fFx1q1bhyRJzJs3l29+80xOO+005s+fh9/ro6mxgaDfR3J8nGg4zAfefxzz5s0hnUqydesWcrkssl0mFApyyCEHM72zg0VHHk5nZzuf//znaGpqolRSmDZtGoJQLoVRVZVgMIimaSQSCbxeL8FgELvdTiwWw+FwMD5eLoAp74uEx+PB4XCQy+Woq6tD13Wy2Sz5fB5FUYhEIsydO5dIJEKhUMDv9+N0OlmyeDFjY6OEwyHq6utIJOL4fD7sdpnh4aFyXg6gaTqtrW10dHZSLBaQJMlUg/r8ATQN7v3Tn/nNb39HtlDA4XSBKOFwuVFUFUmyEQ5HcDid5At5CoUCY2NjeDwenE4noiji9/vw+bw0NTUhAHa7TEtLM3V1ddhsNpxOJ+FwmIHBQZ555hlT7Va74H/jUc3q+nphVT/ubuz9XUwzFXY3j8q5WpczrNLAJFXdVDZhqxV5b4iGanPY1byM8R0OB5/61Ke46qqr8Hq93HrrrVx55ZWcfvrpnHfeeQBs2LABl8tFOp3m4osv5s9//vOkLEVJkpgxYwY333wzhx12GM888wynn346vb29LFq0iJtuuolp06bx5z//mRUrVpBIJKY8nrs7xlNB0zRyuRw//elP+eUvf0koFOKqq67i8MMP3yOrupVwtCpUp5rL6yG7a3hnQdd17HY7JVUlHo+zaeNGfvGLX/CXv/yFp556CpfLRUNDA9FoFJfLxdDQEB6Pxyyp27RpE7Isc/TRR9PRUS68O/7441myZAkez4EpeTH+np566ikuvfRS1qxZQzpTvlAw8vFq76k11FBDDe8uWDMRRUFD0W0mUWhVM5aVhxqyUEIWSlXzH62Zj9b1dwXDcm2sLwvqJAt15fiV1mnDrr1zCY5QkTu5c2bkVMfBmJdxv5EHaeRIGmSkoX7c1bj7AoPUNEi8ynxIreLYKIj8ffggPAeN8/7gOobjXo47ZD1SQ47VQ81lVWRawxvOYpdUlvi20lMK84/R+SCCLSeQbQ8QfTnF/b0L+GdsLumSA5ejiCRqSIN2NBlS7QK6KCCWyk0szS0xsnkH6/Itk+Zr/Gw8L9bnx2pT3psruX296pMtmY+VY+1NhmS17b9Z/st9vgLWNI1zzjmH5cuXs2DBAvP+//f//h+/+tWvePTRR1mxYgW//OUv+fznP28+Pjg4OIl0BMzfjSKUSvzoRz8iEAiYt7a2tn2d9lsKlRfrkiSRzWbJZrOm4shms1FfX8+WLVtMxWAqlSIWi6HrEPAHUBSF5uYmli9fzvTp02lra2Pu3LmcfPLJfPGLX6Surq5cBON2kc1lEAQdj8eF2+1E10o0NzUQDPipr68jX8jR09eDIJTnt3XrFjLZNPH4OIODA7hcDt773veQSqUIBoNIkkQulyOdTqNpGm1tbWSzWYrFIo2NjbjdbuLxOAAOhx1JkohGowQCATweDz6fj2QiQaFQMEtixsfHcbvdKIpCNptl+vTpKIrC+Pg4sdgYdoedjs4OfD4fy5YuJRQKUCop+HxeXC4XhUIBAF2H5cuXM2/evLIaUiwf62KxCMD9f/srv/3db1FVlVKxRGxsHE0Hm2zH7nCQTKUoFBUEQSCTzVKcUGu6XC5kWTbJYKfTRS6XIxwOY7fL2GQbPp+PcDhMPB7H7y9nST766OMkEu880vytgD0lvvYH6ThVeHi17D7jZi1deaMDx/dle0Zg+lRkoEHk7Sqb0cDeHvNdLS8I5SD+j33sY1xzzTWEw2HuuOMOrrjiCr785S9zwQUXmKpkXdcZHx/nu9/9Lg8//LBJwBmW41mzZnHTTTcxf/58nnjiCc466ywGBgZYsmQJ1157LQ0NDdxzzz1mWU01InZfoSgKd999N9deey12u50f//jHvP/979+pIGCq42PAWnZUbT7GeWcdq2a1rsHlclMoFJEkiVQqRT6fp1gsct9993HHHXewfft2nnrqKYLBIKIokslkyuVzgmBmj8bjcUqlEocccgh+v/+An1PJZJL+/n4URWHDhg3m68+72SVTQw011PBuR2Ve41SZhXtjeX6zYZCYBum1u7mZ5SdVFJRTHRODdKzMgdxbTEUoVpKOVku2dRkJnTbPOIubdvBIfD6NoRTb02Fke4moN8NQzE8+JJFJOgm7suQ1GbdQIFV0ojYWkGakETQd4dUuhF9GeW5rO1vHIoTcOTIFO2pTAcWvE1mrYsvrCCUQiyKxlIf8qIuAlDPnAru3WR9Iws5KJlYSjnu6voFK+7R17Dcz9G2vrNZWnHHGGbz66qs89dRTk+7/+te/bv68cOFCmpqaeP/738+WLVuYMWPGPm1rxYoVfOtb3zJ/TyaT7xjy0QqDbAwGg4yMjJgKP6PZtFAomBfeDoeDVCqJY8Kq/I9//IOxsZjZ0Dx79myCweBEEUwOTS+RSmVpaKgnNjaKJIoIAui6isvlpL6uXCLj9nqQJInBwUESiXFaW1t5dc1qDl54EO6J/Ehd16mri9Lb200kUkcwGKRQKFAoFEwLeH9/P6VSiUgkgqqq9Pb2ouvlNs2Ojg6GhoZJJJKMjY3R2NxEJFLORoxGo6aCYXR0lLq6OhRFoampiUKhQENDA8NDQwSDIVKZFIIA73nPe3jllVcoFh1Mm9aGik4ml0eUbPj9AUqlErqmU1QUgsEgJVXnr39/gJ/dfAupVBp0DZvDSSRcB0gUCkVE0QaUVUkOp72cDel24naWrWQ2W3nsOtOOXkfHtHYCwSCZdJr6hjpSqRTpdJpsNksum2NwcBBFUSae7bfOG1wNrx/VyEfj/krF2RsxFyv2lSCz2nIrx5sq+3BX29qbeVhLfKrNy+l0csoppyBJEueccw533303ABdeeCEej4eLLrqI0dFRVFWlv7+fc845h9tuu42lS5dOei4OOuggfvazn/Gf//mfPProo3znO9/hmmuu4X3vex9XXXUVZ599NnfeeScOh8Mce2+Vg1bbqaZplEol7r//fi699FIAvv/97/PJT34Sm23P3o4rt2s0XlceL8M+X2uvrsEK4zPG2OgIXq+PWbNmEQyG6O3tpbm5hXh8nGeffY6DDz6YF154kUQiQXt7O93d3aiqyowZM/D5fGzZsoV//etffOxjH0NRlJ1e4/anAlHTNJ5++mleeOEFFi5cyFFHLcfv85vxCXffdReFfI4PfehDu/w7qhHuNdRQQw3vHFSqE1VdRJpQEiK81kA9VcO1ATMb8nW8b1WqDl8vkVmZ3QggCW9kDcj+gYqAjGaqCIsWhaj1GPlteQqajcOjPbw81kq9P02DO8XB4T688wq8mmxmjm8Ij1hgXaGFc9sfItPm4PcjRzBa6ABRxLc9xzAiLrtC/3gASdKwOUrUHRYn09eIa1Qj116ioWWc0XEfgkulQx6ZpHZUdQH7bizwbwaqzWhfPt2/EXbqXWGfrkjOPPNM7r//fh599FFaW1t3ueySJUsA6OrqAqCxsZGhoaFJyxi/T5UL6XA48Pv9k27vJFg/DI+MjJgZgsVikaamJvL5PH6/H5vNhsPhwOfzEQgE8HrLCr9oNIogCGzfvp3BwUFSqRSqqlIsFtm6dRvBYJl8y2YzKEoRv9+HIEIkHJog0gSmTZtGR3s7siQiSQL19fUopRL9/X3YbDa6d3RjkyWKxbxZquL1elFVFa/XSy6XQ9d1k2yz2WxIksTY2BiRSASfz0c+X5goylFIpcrLuFwuwuEwygQp2NjYaBbqOJ1OXC6X2Q5dX1+P3W6js6MTXdeQZRu9vT3ouobT5URVNZYtXYbb5WJwoJ9sLos6Ya10ucvWS4/Hw+rVq/npT3/KwOAgCAKIErqqY7c7CQSDhMJh3G43wWCwTJYqJURRJByO4PF40HWd1tZWZs2aid/vZ3BokOGhIUpqCbfLjSRJBAMBOjs7Oeqoozj00ENxu92IgoAkGaTFm3SyvUOxK5vugYZVQWaoG623N5J0tM5pf6FQKJDP582WaJis3Nwb7MnzsydjGs28H/3oR7n22msJh8PcddddXHLJJZx88sn85Cc/oaGhwSR+t23bxre+9S02btxoKhcNleDChQu58cYbmT59Ovfffz/f+c53GB0d5cMf/jBXXnklfr+f2267jf/5n/8hn8/vk+rRqnx96qmnOO+880in05x++ul8+ctfxm63myrTfYGqquRyOXK5nFlEtqfHcm9w8803c/DBB5vvw8uWLePvf/+7+Xg+n+eMM84gEong9Xr55Cc/udP7fXd3Nx/5yEdwu93U19dz3nnnmQVANRwYVKqzFyw4iGefXUU4HCQSibJ8+dEsXbqUT33q3/j857/Av//7Z9i2bTtFRWFkdJSXXnoJv99vZq0mEglKpRK9vb2kUimeeeYZM3u68u+i8mfjZkQfGH+H1r+ReDxOb28v/f39xGIx7r33Xh544AFEUWTGjJlEolGUUqkcX6KWUJQi69at469//SuZTOZNey+ooYYaaqjhzYGEjiRoqPrOVmd1F/bnycvtvEylirCyTGZ/YOf5ln9XdGnSY7siM419sc6t0i5szXqs9vOBUH3uZBO3bEsSdBRdZKZ7mFjRQ6rkRBZUgo4cM/2jBOQch3h6cIglFoe2s9S7hTHVS7M8TpstTlehgVVrZtLzQQeC20X/MR6a6hJoOmiaQGbEzeFtvWQLdmxZnbEFZZt1oyeFKGo0NY5Pmpeh0Nwjm/3EcntSylKtSXpfUK1t/M0mEvcWe3UMdF3nzDPP5N577+Wf//wnnZ2du13n5ZdfBqCpqQmAZcuWsWbNGoaHh81lHnroIfx+P/Pnz9+b6bxNoQO6+R+89sG4VFJ59dW1bNy4kXg8gapqxGIx0ulylpHb7SafL1AsFslk0vh8PpRiEV0Dt8tDc1MzDoeDYqHItq1b8HrcuJwy+XwWSRIRENA0FVEUCQVD2B0ORsdGEASNzs5pHH7Yofi9HpRCkURsHAkBt9ON1+3F7fYxPDTG9u29ZDI5Ghqa8PkCFAoFXC4XoVCIsbExZFkmn8/j8XhQVZWxsRh2u4NSSWN8PEFLc8uE1Vk3rVolRcHtcpPNZNE1Ddkmo2s6DfUNZNIZ1JKK0+HA7XLhsDtxu900NzfjcblxO1ysX7eRQq6AbLMxNjZKW2sL8+bOIeB10rNjG1u2dOH2eHC6PPT2DXD55T9ia9dWJEFCRMIuu3A43MRGY6QSKUrFItlMBq2kEgwEkESRSCiMki8giRIuhwNZEomEQvg8bqKREHa7jfHYKNOnt/PBDx5HXX2UYNDPtGltNDY24PG4GRoeIpPJTnlm1LB/8WZcdFovqo3fK1uJ34z5vJ7jYJCnRp5rNZv5nmJP15lqmUrLsEE+XnfdddTV1XH33Xdz0UUX8YEPfIDrr7+ejo4ORFFE0zReeeUVzjnnHPr7+03CwxjjyCOP5LrrrmPatGn86U9/4nvf+x6JRIJTTjmFH/7wh9jtdq6//npuuOEG8vn8lNbmqWCcE2vWrOHss89mcHCQT3/603znO9/B6/XuFeFYjVRRFAVd15EkySTxpjqGr+d8aG1t5cc//jEvvPACzz//PMcddxwf+9jHzHzmc889l/vuu4/f//73PP744/T39/OJT3zCXF9VVT7ykY9QLBZ5+umnufvuu7nrrrv47//+732aTw37hsWLF9PT08PIyAjLly+np6eH7u5unnrqKRobmzj44IP54PEfRCkVmT1nFuFw2PwCwu/3M3PmTOrr6zn88MNJJBKkUilkWa66LeNc0zSNfD7Pjh07eOKJJ/j1r3/N//7v/7JhwwY2bdpk5lP/6le/4tJLL+WXv/wla9as4cEHH+SZZ57hve99L+effz4LFy5g3br1dHfvIJVK4Xa72L59O1u2bKGvr4/+/n4GBwfZunWr+TpcQw011FDDOw9VyURBm7ApG+SbNrGsiKLbTHWjdX0JzbJc9c+nRSSKlFuxDQWilXy0ZgEazdlWkqiSMKrMojTyIitzK6tlPRpzsOZLWv+d6j7DUi1WsRO/Xss1TLZdW63X2kTOZLGi6dpota6zpVgba+RwXzebU/UcE9mMLKqUtPLxVnSJVnuMMdXLDPswhzr6ebnQyqZMA984+hFUpw6hAAefvJ5jGrqYFR5lRv0o9mABn61ANm9HLIEtK9A4LUauJNMYTjIc8+MUFVS9PL8938+J51MXKE7sl3HbU9JyVzfrclC2XRtZncZxsy6j6KBMkKBWGOfcG9lavTvsldX6jDPO4De/+Q1//vOf8fl8ZiZjIBDA5XKxZcsWfvOb3/DhD3+YSCTC6tWrOffccznmmGM4+OCDATj++OOZP38+X/jCF7jyyisZHBzkggsu4IwzzsDhcOz/PXzLQbf8q1O23FobTCGZTCNJMo2NTbjdXpxOJ0NDQ3R0dCKKIiMjQ+i6Ti6XK+cTKjl0Tccu28vkoqqiaRrJZJyOjnY0TaOYL1BfFyWeGCcYDKJqKgMDAwTDQYrFAul0DlkWaWtrQ5JsjA4NM3fuXBRFYdOGLpYvX46uQTqd54UXXiaTyeH3+3C73YyMjGC32/F6vfj9fvL5PE6nk3Q6iyhK6LpAXbSeSHgEn8/Htm07aG1tZfv27Xg8HtKpFLLNhsNuJxgIIggCqqqypauLQCCATZKIRqKk02nUkmq2btplOyMjI6SSaTLpLK0trcTHx2lubKA+GkHQisyc0UFHxzTS6QyiaOOKK37Ciy++hChIiIINv8+LLNvJZHLoOmSSKZwOB36Pl4aGekbHRpAAVBVREokEg4iSgMvpRBYFZLeThrmz8fm8hINB+vq76ehow+/3UCj4cbk8FJUCM2ZO56WXXiKXy70pZ927AZUW52o4UMRfZf6hgbeKzbWSsDOwuwKUSgv57vZnT0oeqi2zL8+LsY4kSXzoQx9C13XOPfdcfvnLXyIIApdeeik333wzZ511Flu2bEFVVZ588klWrFjBddddRyAQMIlhSZJYtmwZN9xwA6effjr33HMPLpeLyy67jM9+9rNks1kuuugirrjiChwOB1//+tdxOBy7nbf1nNi2bRtnnXUWW7du5YQTTuAHP/iBmY23q4zM3R0D43kxyFTj/gNxrn/0ox+d9Ptll13GzTffzDPPPENrayu33347v/nNbzjuuOMAuPPOO5k3bx7PPPMMS5cu5R//+Afr1q3j4YcfpqGhgUMPPZQf/OAHfPe73+Xiiy+u5fW9QfB6vZx55pn89Kc/5aMnf4yZM2dhdzg5fNFMSqqKKAi0trbRtWUzxxxzDI31DWax2sjICNOnd9LW1kYwGKS+vh6Hw2GqoQ3VoiiKZLNZuru7Wb9+PatWreL5558nFosxY8YMPB4P4+PjXH755WiaxrHHHsvJJ59MIpEwSfpt27axYMECPv3pT+NyuXj66ZUsWHgwxx57LNu2bWPmzBls6dqMoijIskwul6Orqwun04mu67jdbrxeL16vd7evTTUbdg011FDD2xdWws4gEQ1i0I5afnzCfq2xpxZsoVyHDBYiUzfHtZKChiV6b5WQla3ZBmmJxVa9p+3WlZCNueg7W8FhZ9Xj6yUed4fKHEinoBLX7DTbxjm5dQ2xkocO7xjdhTBhOYPbUSRW8iILKiMlH7McQ7TbxhlUPfQrQT4WeZGU5kJOiWz9fCO3NP6JVdkZpBUHPfEgR7dv5fnBNpwOhcwpSbJjbmwFO4mMi4ZACrtDwSMUzQzKyvm91bC7pnADGlDUxap5lZVnp8gEsfkG6XT2ini8+eabATj22GMn3X/nnXdy6qmnYrfbefjhh7nmmmvIZDK0tbXxyU9+kgsuuMBcVpIk7r//fk4//XSWLVuGx+PhS1/6kpl39e6Ejq6XL36ND/GiKJJOp4lGI+WMQl0nmUwRiYQJhcLk81kKhWK5lMXhJpfLMTw8jN1uJxKJsHjxYmKxEWTZRmtrK5pWMj9457I5kskUHo8HTStbllPJ1ITtcAGzZs3mX089TTweJxwOo2kaY2Nj+Hw+bDYbuVyOjRs30tnZicMh093dTV1dHblcjkQigcfjwW63o2nlApqhwUFCoQiiKJoN2C6XC03TaG5uRtd1hoeHqa+vZ3R0FEmSCIfDzJgxg7GxMdLpNLFYDLvdTn19Pf39/WZztiAI+P1+0uk0siyb88tmsxOt2Xbq6uqIxcb51Z1383//939oWvmvq9xwXb440XWBdDqNIEgUigXsDplcLkuxUCZRw5EQslxuxPb7A8iyRElRmDV7Jh6PG4dDRlVKTJ8+naGhIerr68lm8ySTaXp7eznkkEPYunUryWQSXa9ZrQ8E9kRFt79QeQFrEHPWRuI3s8RjT6221bIUrWSZIAi4XC6T3DL2s3LfqpGue7PdqYjISrJgquVkWeYjH/kIkiRx1llnmeTjJZdcws9//nPOOOMMNm7ciCAI3HvvvdTX13PppZdOUhvKssyxxx5rko+/+tWvcDqdXHzxxXz5y1+mWCzygx/8gB/+8Ie43W6++MUvIsuyaTuvnJdVlTg4OMi3v/1tXnzxRRYtWsRPf/pTGhsb91j9OdW+G0Sj3W7fa9Ku8hzZ23NVVVV+//vfk8lkWLZsGS+88AKKovCBD3zAXGbu3LlMmzaNlStXsnTpUlauXMnChQsnFcydcMIJnH766axdu5bDDjtsr+ZQw75BEASmT5/O+eefz6WX/oCj33MMy5cfxUD/AM88swqHw0FnZwfHvOcYbr/9dlqbW/B6vWSzWQYGBti8uctUF7a0tNDX10cikWDevHmMjIzw1FNPcdRRR/H888/z5z//mSeffJLt23fgdDqor68nl8uRSqXYunUrPT09NDY28vLLrxCLxZk7dw4f/ODxzJo1m3A4jM0m8eSTT/C3vz1AZ2cnzS2tbNmyhTlz5vD8888zFouRSCTYtm0bw8PDrF27lmAwSCgUoru7m6OOOoqWlhZkWZ6kyrTm79ZQQw011PD2hpEZWCYLba+1RgvaZGWjoJHXZZh4bHeYivST0E3lGxOEo4pQbjzeBxu2sY46QTxqe6ie27OxXyt1sSobDeJR04WqKsgDAes+FXWRuOYiKGV5r3c9/zd+BEd6t7E224JbLBfBBmxZxkseZjmGaLPF2FEKsbnQyHvcmxjTPHTlGzjp5JV8NPgSeU2mJx/GKSlk0w5eHmkmlXEiihrSOi+0FykqNlyOIvOCQyRyTgZVPx228TJJ9xa3LRs5mdbTwmy5tiynGopT/bX1qHgc9k+L+d5ir4jH3V1UtrW18fjjj+92nPb2dv72t7/tzabfoTAUjwKCULZaj46Omu2Rw8PDqGqJhoZ6AoHARLZSHL/fh6LYKJWKhMNhspm8mVumqipOp4NisYjL5SaZTBKPj+N2u0ilUjgcDjRdMy9aFUVBlMpNlbncAIGAl9bWALLNwdq1a1FVlWnTpjE6Oko4HCYajVJSFRSlyOjoKC0tTciyTDqdNpunQ6EQ+Xweu91BMBhkcGCQWCyGy+Wit7eX+vp6EokEc+bMQRAEstmsmVUZi8UoFov09fWxYMECNE0jHo+TSCSIRCJks1mCwSCxWIxkMonX6yUWi1FfX8/w8DAutwtVK2Gz2YhEIsyaNYtsJkcmneH//u//yGbLKky7w0lHewdjY+WLFofDgdfrJZPJAJBOp2lubmLu3LkMDg7icrmw22UkScLhcCBJ4oTatIQgQCQSQUQor6+DLNvxeDxkMjlkWSYajVIsFicKgqiRj28D7E6VV0maGcScVRVoqNAkSZpynAONSoJwqtfxyhIUa4lKtTH2Vc25J6RoNfXq7t5/JEnihBNO4JprruGcc87hF7/4Bbquc+mll3Lbbbdx9tln8+KLL6KqKnfccQeNjY2cc8455dfEif2VJIljjz3WLJa5/fbbcTqdrFixgq9//etks1muvPJKLrzwQjPD0CAzpiJxx8fHueCCC3j44YeZPXu2aQGvdgyqnXOV41m3M9XzUNk4vis18N6SxmvWrGHZsmXk83m8Xi/33nsv8+fP5+WXX8ZutxMMBict39DQYLojBgcHJ5GOxuPGY1PBKC8zkEwm92iuNVSH8Vy3tbXxwx/+gMsuu4yXXnwep9OFx+Nm69at1Dc0cPTRx3DqF/+DG264AdB48cUXOfbYY8nn8yhKiUwmQ3//AIceehjDw0M8+uijrF69mq3btvLb3/2WdCqDqpY49tj3MXvOXAIBP7GxMXbs2M7w8DAnnngic+fO46CD5jNtWgfBYBCbbAMdNF1ncGCAeDzO4iVL8foCPPjgg9x11118/OMfp6enh3nz5rJtaxfxeJyuri4ikchEFnT5C8e6ujpsNht/+MMfaGtrY/ny5djt9gOWgVpDDTXUUMObh2oN0HldnvR4Welo5AyKEzbrqZujjXWKuoyiS2WFnC7upBwzlIuvFdpUH7NS4QiTiUpZUKsuAxY1ZMV4ZoagZbsZ3Y5dV3GLikks7krRWI18tBJTUxGwhlJwkkXcIDmr7L+MZi7vnJivpotsKdbT5oyxoxBlmmOM0ZIPVRdJq07mOfvpsI0xrHrpViIc4tpBEYlXsu0scPUSlDJkNQePJOczxz3I2ngj4VCGkioyo2GUbc+2UfLqeMNZ7LYSHrtCTpWx21RezbXh8+SJiLnJjdu7axKf4liqulC1P9YgBveU7LO2W1vViJOt+5XbKN9XJidfU+hOuQ0E4I0lXPe51bqG1wfB8n+DgBQEAa/Xi6IophKnsbGRXC6L3++fuMDVyefz+HxedD09QXSJlEol+vv7iUajDA4OMjw8TENDmeyKx+MoSpGWlhYKxTzpVBqn00WpVJq42BbQKRMn5e3YmTNnDpqmsW7dOvr6+li0aBH5fJ5IJEKhmGd4eMgsMQgGg8TjcZxOp/lvqVRCkmT6+/vx+wNs37aD+vp6CoWC2coNmOrGfD5vqhgVRSGdTtPX10djY6NZbJHNZnG73eY627dvR5IkisUibre7TJ7mc/h8Prq7uykUCqxatYpp09qJjyco5AsTRTd+FEWdWM9FMllCURQcDieSJEyQsirpdMos2snnc7S1tTI0NDiRK+XE6YxOZLfpbN26lcVHHEkun6VQLBCPx1HVsqWtVCqRSCSQZXki3/Ltjb6+Pr773e/y97//nWw2y8yZM7nzzjs54ogjgPJF7UUXXcTPf/5z4vE4y5cv5+abb2bWrFnmGLFYjG9+85vcd999iKLIJz/5Sa699lq8Xu+btVt7DYO8t5I/lReyxv17YgN/M1FpFa+m4oPXSEhrRmKljftA5WpOlVdovd9ms/HhD38YURQnKR8vvvhibr31Vr75zW/y9NNPUygUuOqqq2hqauJzn/vcJPWTLMt8+MMfplAo8K1vfYubbroJl8vFt7/9bc466yxyuRzXXnst559/Pg6Hg5NOOqkq+ajrOul0miuuuIJ77rmHxsZGrr32WhYuXLjPalgrMVyNdDQet6pTXw9JXA1z5szh5ZdfJpFI8Ic//IEvfelLe/SF4+vBj370Iy655JIDuo13E6zEW2NjI5dddhlXXXUV6XSarq4u6urqaG1pRZZl7HY75557LjfeeCNer4euri4WL17CkUceSVfXFlatepbrr7+B4eFhdF2ns7ODzunTOeGEE5kxYyahUHjCAaHR09PD2NgoHzvl4+Uv6yZeZ4zzdN26tTz66GMEAwE+8clP8uJLL6LrkEgmWLBgIS6Xi/HxcebNm0dfXx+lkkpDYyOBQIBQKITP58Pn8+F0OlEUhZUrV7Jy5UpOPvlkYrEYl19+OcceeyxHH330pMb3t+Jrcg011FBDDXuOakRRZdu1AVkoWZYRUSwW6Ur7taFolNCqEkqTtoMIaGV79n4sn9lbZZqVuDTIRivpaFU6Tl5v18rHauSjgmiuZ5CKu8NrxCR0K2HmOgZwigpuvYiiS/QWw2i6gEMsMdMxxCz7MI9n5pDV7HzAuxYJnWfznUx3DOOcUEa+kpvGe3wbyesyda40ui7glotkFTslt45YFJhXN8TaoUaccgmXpJAryjhEBaegmHPbEyvz7rCr9avZnysx6czRJzIldWGP52YqI3lNEblT/qMxjjCxEd4Y/vGtEUD2LkH5wzUmWVVWKL5WQmHYNI2Leo/Hg9PpnLAKx8jn88iyzMDAgGkllmWZTCaDzWYjEAiQTCZJpVJ0d3ejKCVCoRBtbW2mLdnhcOB0Oc1MxkKhQKlUIp1OUyqV8PsD5sVAKBRClmV6enro7e1ldHSUgYEB3G63SQj29/ejqiqKomC3l1V+yWSSF198kUQiQSwWMy3buVyO6dOnUygUsNvtNDc3UygUzMbuZDKJLMvouo7P50PTNFKpFNFoFIDh4WGz3KJYLOLz+YjFYuRyObZu3YrH40EUBbZu3UqxWCZaXS4Xzz33HAMDAxxx5JEsWLCQpqYmPG43+XyOUkkhGo2g6xqlUhG7XUbTVARBZ2xslFKpRENDA6FwiEQigc/nJxgMMmfOHBRFobe3l3g8PqGkFGmfNg1BEIjH4zgcdgSh3Gicz+fNQP63M8bHx1m+fDmyLPP3v/+ddevWcdVVVxEKhcxlrrzySq677jpuueUWVq1ahcfj4YQTTiCfz5vLfO5zn2Pt2rU89NBD3H///TzxxBN8/etf36c57Y8ClanGqCTkrL8bNlcrqVPtAtZ43JqBdqCLb/a2+MVKaFWzDVeOZxBb6kSe7N6q5vZ22T2BMT+r8rGuro5f/epXXHTRRTQ0NHDrrbdy3HHHIQgCyWSSCy+8kIcffnhSTqJBPp5yyilcfvnlOJ1OrrnmGm666SYkSeK8887jq1/9KuPj45x77rk89NBDKIoyaZ90XadQKHDbbbdx66234vf7+clPfsLy5ctflwXfOObGflZ7boxjYSV1rCUbU50be/p82O12Zs6cyaJFi/jRj37EIYccwrXXXktjY6P5RZcVQ0NDNDY2AtDY2LhTy7Xxu7FMNaxYsYJEImHeenp69miuNVSHQboZ50EgEOB73/se7e3tzJkzB6fTSWdnB3a7jXXr1/PII49w1llnEQqF0RGZM3cumqbjcDo5/PDDOfvssznr7LP40IdOxGaz0dfbT0NDEw0NjdhsNjZs2MDWrVt58skn6erqQpZlYrEYfX19JuFf/hxR4qCD5lNSVZ544gnaWtvYtHEjIyOjZLNZWltbaWlpoauri5aWFurr6xgcGDQ/NyiKgs1mw+/3k0gkGBkZIRaLsWHDBubPn8+0adNoa2vj0UcfJZstF71VfllwIF+Xa6ihhhpqeGOhWki4yrKWPVp/ohFbQseOSpGdVYfwWrZkparSgLWQptKKbRTFWAtjrONO1aRtvd94zFBFOgXFtH/vTr0nCvokMnJfsh5fI7p0s1xGnFA/ihYVpLlNdIq6SEpzYUdjtjzMDPsQcxwDtNpjpFUHUTnFDHmEnlKQ3mKIE7yvIqHzcqGNoJRhrn0Qp6DwYq6DTscwHXKMkZKfNtc4JU3EJmq45SIEFDS3xpbxCHabiltWqLOnUDWRoJTFjmbmYb5e0nF/w7Tz89ab276gRjy+SRCEcre1IAgTLaTCJFumz+fD6/VOZALqEyRhHl3XiEQiCIKI11sunpFlmblz505YlcdQVXVC8Ve2YGezOZqamojFYmiahlpSzRZKI48xEAjg8/kolRRCoZCpvjzqqKNYuHAhGzduZHh4mGw2i81mw+VyIQgC+XyeYrFIJBIhFouZOY7Nzc3kclkkSSKbzZr75vV6qa+vJ5VKARAKhcyGcyOQ3rCVq6pKLBajUCiY6ghJkli9ejUbNmwgm80SDoeJRCLY7XZGR0dxOl0UCgWmTZvG0NAQNpuNHdt38PTTK5k1azZNTU2k02l0dBwOOzabhMvlpLGxAVEUcHtcuD0uvD4v4UiYeHycbDZDNBLB4/EA5Sy4bDaHx+MxScZoNEoul8PlciHLZUt2f38/uVyOWbNmmdmXPp/vzTrl9guuuOIK2trauPPOO1m8eDGdnZ0cf/zxzJgxAyhfvF1zzTVccMEFfOxjH+Pggw/mF7/4Bf39/fzpT38CYP369TzwwAPcdtttLFmyhKOPPprrr7+e3/72t/T39+/1nPaWZNvbsSthkD/ApIv3XcE4d60FIG8lTKXcnEr1CGW1skFA7m3L84GClXw88cQTufrqqwmFQvzyl7/kkksuIRwO87Of/YyPfvSjiKLI0NAQ3/3ud1mzZo1J6BlEiN1u5zOf+QwXXXQRoihy5ZVXctttt2G327ngggv43Oc+x9jYGOeccw5PP/20ScJqmkapVOL3v/89P/7xjxFFkYsuuoiTTjppUgbo3mKqfM09yYi0nrNTPU/7Oi9N0ygUCixatAhZlnnkkUfMxzZu3Eh3dzfLli0DYNmyZaxZs8Z8zQd46KGH8Pv9zJ8/f8ptOBwO/H7/pFsN+4ZKstp43t1uN6eddpr5c2NjIwKw6pmVtE2bxrr16/nil77EJz7xCZxOFzZZpqOjrG70+f1kslmamhr57Gc/w7e//W2mT58OlN/XJUkkGAzi8/k45JBDee6551ixYgU7duxg3bp1/Pa3v+Vf//oXCxYs4PDDF3H08uUE/H4iE++7DzzwAA8++ACKotDW1sbBBy8knU5z6623cvXVPyWdTjM2NkZvby+rV6/mhRdeIJVK0dTUxCGHHEIkEqG/v585c+YgiiIHHXQQXV1d5c8CFsKxRjzWUEMNNbz9YRS9GNAqmqytDdcSGrJQqlo0Y5CNahW6ZKocR2PblerAyjntDao1VFc+Vu3+SbmXVWAlHPcV8gRpZ+YK7iV8Yq6slhQ0fGKeuOomobqpt6c41r2J7lKIf6Vms9y7iSIi20sRVF1khjxCXHPRo0Sos6U4yD7IhmIDPjGHikjYlaXBmSJRcOL0FsCrkEi5ccgl5gUGWZNoRhQ1wlL6Dcu3hN1buCuX3R85n2+lq86a1fpNgj4R72goHVW1xPPPv8C6devQdZ1UKoXNZiOfLzA0NITf70dVNWKxcUKhIJqmkc/ncTgcuNxuYrEYW7duxWaTcbvduFwuJMmGqqrk8zlisRiNjY1s3bYFAYFwOEI+ny+TZyIoxRKBgJ9SSSWXy9Hc3ISqquYH/56eHnbs2EE0GkWyiTgcZTv2li2bAchms9TV1ZHJZAgEAiiKgqZRVixGfAQCAVKpFKlUCqfTSSgUYmBggIaGBjKZDJlMxiRSDTLTUGimUil8Ph92u53BwUFsNhuKopBIJAgGg9jtdvx+P6lUinQmjdvtJpPJYLfb6enpwe8LmCRmW1ubmSFZVoemyWQzuJxOnE4HLrcLt9tJIBAw7e2arhKJRlAUZSJbTCebzTB37lxyuSyFYo6BgQGaGhsZj8dxOpykUxn6+vqQZTu6Dg8//DAdHR3IcvlP7u3q7PrLX/7CCSecwL/927/x+OOP09LSwje+8Q2+9rWvAbBt2zYGBwcnFUwEAgGWLFnCypUr+cxnPsPKlSsJBoOmNRvgAx/4AKIosmrVKj7+8Y/vtN2pMt6qZXUdCCWddWwjD3BvSzkMQszIYz2Q5QZ7cwwM0rByf3ZVamKgUvk4lUV7d9jV87c3eWzWdY22a03TOPfcc7nrrrsQRZGLL76Y6667DpfLxR//+Ec2btzIt7/9bW6//Xba2tom5XHa7XZOPfVU8vk8P/jBD7j00ktxu918/vOf57LLLqNYLHLPPfdw5pln8vOf/5wjjzwSgH/+859ceOGF5PN5zj//fL7whS+Y41ZTlO7J81VJOlotqruC1R5vfLmzr1ixYgUf+tCHmDZtGqlUit/85jc89thjPPjggwQCAb7yla/wrW99i3A4jN/v55vf/CbLli1j6dKlABx//PHMnz+fL3zhC1x55ZUMDg5ywQUXcMYZZ5jxGzW88TDOJaOx/b777uPPf/4zH/3oR2loqGfu3Dm43eUv2iKRyKR1BKFc8Hb08qPRNZVEIkE8nqC+3sGrr77KP/7xDz7xiU/gcrlob29ndHSUZcuWEQqFuPVnP2P1mjW8973vpa4uyuNPPMbXvvY1OjrbEUUIh4P82799iuOOO5ZcPs8Tjz/K0NAQmzZv5vHHHmd4uKymdbvdhEIh/H4/Pp/P/JJPVVWGhoYoFArk83laW1uRJIl4PM7Q0BAtLS1ks1m8Xq/5ZWrNdl1DDTXU8PaDOtFWDSCivZapJ2ig70zemRZqQUPRy9dmlWSiVemoIiALKpIukNdlRDTsqJOIP0OdaBCMVrLRWG5vyEdjvMm5fmXitHLblWOrCNh5bd0ioklGWsc3Htd0AVnQJmzn+qTHdgWDbKxGgFqJSBHdHL+c71hutI6pXjxCiYxuY7AUwCMWGSgGONa/gUHVyz/iCznY20NESrOh0IRTVDjStR1NF9hSrMcjFjjE0ceI5gZgmhzj4eJ8loa28aeeg2n2JvHZC3QV63A4yvbq4UJZBLSgbhBpQp0qW0pb9oey0Nj3SqWnqk8mE63W62rbtT6+p1br4j4S3G8EasTjm4TyRXr5YrJUUnj55Ve4+uprGB4e5rDDDiOXy1EqlZg2bRojI0O0tbURidQxOjpCLpfF6/UwOjqKw+HE7XIRCoVoaWlh/fr19Pb2MmfuLMbGxpg3by7RaITh4SFUVS0Tg/4ATqeTZDJZVjsG/SQTSURRIp1O43K5yeXy5gVtIBBg6dKl/POf/2TDhg0UlQL5fI7FixfT1NREqVSiWJwoupmwL0mSRDDoZ3x8HJfLjdvtplAo4HA4UBSFbDbL8PAwoVBooqylrJ4ych29Xi+5XA5N07DZbJRKJSKRCJs2bWLTpk00NjbicpVzKgcGBpg1axZr1qyhr7+PufPmMD4+jtvjBMDlcjFnzlweeeRRBgeH6OjooFQqIcsy+XweVVUYj2fRdZ1cLDth4SoX4Pj9flwuF16vl2g0yvj4OPH4uGmjjkSjjI+P4XY7KZVUVFVlbGyM4eFhikWFF198ecL2rkyUy5SzKN6u5TJbt27l5ptv5lvf+hb/9V//xXPPPcdZZ52F3W7nS1/6klkQUa1AwlowUWk5t9lshMPhKQsm3goZb4aabU9VjlNBkqRJBOabUXRgEAZWu/i+bt8gVCtJsDfrAt6Yg/GactJJJyGKImeffTZ33nknABdffDFXXXUVTqeT3/zmNzzzzDN8//vf57rrriMajU46Pg6Hg9NOO41sNstVV13FBRdcgMfj4eMf/zg//vGPyWQy3HfffZx22mnceuutJtE5OjrKl7/8Zb75zW/idDr3ifCrtPXvLazksVVxa1ix9xbDw8N88YtfZGBggEAgwMEHH8yDDz7IBz/4QQCuvvpqM7O1UChwwgkncNNNN5nrS5LE/fffz+mnn86yZcvweDx86Utf4tJLL92n/ath/8EgEuvq6nj/+9/P5s2b+cMf/sAJJ5zArT+7hY9/4pPMmjUb2DmCYnx8nOeff55XXn4ZSZI45phjCPj9lEollixZwrRp0xBFEVmWUVWVTZs20dvby399//ts2LCBJ598EqfLyb99+lO4XE42bNjAurVrWbNmDevXr2fr1q0kk0lT8djS0sLixUfidDqRJAmbzYbT6cThcGCz2cy/fUEQJv3ucrnQdZ2XX36Z+vp6xsbGeOqppzjiiCM49NBDD+iXQTXUUEMNNRw4GASj+TOTbdaTlrXkNaqIU6oXDUwiitBRBQ0Ja1u2bhKCTjRkQd1pvf2FMsFnNGhPVlVa98NKtBoEqjypWGdnNd2BmO9UUPUyKTte8pDRbcRUN5Kg8Uy6gxMDaxhTvTyZnI3flmOuo5+ns7PIqg4+FXgBgEHVh6JLzHcMkNAc9CgROuQR+kohjgps4Ynx2XjsRZrdCR7bMRNNESkiUxeNk1YczPENoegSqi6aNuv9hb1Rfu4qu1GyEMB7kg35dkCNeHwDUE2RIggCOuVMon/9ayV33XU3mzZtwm63I0kSDQ0NjIyMEI1GcLvdjI6O4vX6CIVCjI4OmzmJiUQCryfAyMgIiUSCZDKJ3++ju7sHSRIJhYJEImEaGxuJx+O0NDeTzebMTMdQKER/fz922Y7NZkfTdHNubrcLTdcBnZkzZ5DP51i1ahU7duwgHA6xbds2jjpqKV1dW1AUhUAgYNrDy0rLAk1NTWzduoXDDltES0sLw8PDyLJshsHn83mi0ahZCFMsFkkkEmZupM/nMwnAbDbL3LlzEUWRRCJBoVAgHA6zZcsWuru7SafTRKNREokENpuNRDzBzJmzGB4eQVFKHHnkkTzwwIOEw2F8Ph82W1kROjAwQKlUQlVVXC4nbrcLp9OJx+NhbGyMYrHI4OAguq7j8XhwOBwMDQ1QKOSZM2c2pZKCyxUik8mwceMm1q1dRzqdRdehWCgyOjqGKAo0NDTg8bjf+BNwP0LTNI444gguv/xyAA477DBeffVVbrnlFr70pS8dsO2uWLGCb33rW+bvyWSStra2nVR5++OC0TqW9eLaIAp3R9jsag6VYxv2XoOAPNAXvNbtW+3V1VR4uxujElPlRO6rwm93sI5RmcNp3SejLEbTNM466yzuvPNOJEnioosu4sorr8Tv9/Pzn/+c++67j2nTpnHRRRfhdDpNQlXTNOx2O2effTb5fJ7rrruO888/H5fLxYc+9CF++tOfUigUePjhh/nqV7+KKIps376dU045xWy/3hWxu6tjYZx31YjCvTmG1mxOq91/b8nH22+/fZePO51ObrzxRm688cYpl2lvb+dvf/vbXm23hjcOgiDQ0dHBxRdfzM9//nPuv/9+TjnlFJ5//nlmzpxV9W87Ho8jCAKf+MQn6OzsJBaLce2116KUFD796X83z7P58+fxxBNPsHbtWpYsXkxHezttba3MnDmDfz31FD+89AesXbeOgf5+SqUSjY2N+P1+WlpaaG1tJZ/Po2ka4+PjZLNZs8U6HA7T3t7OkiVLaG5u5oEHHmDNmjXmF1lHH300s2fP5t5772Xx4sVEIhF6enpYsmQJX/7ylyepnGukYw011FDD2xeGgm13JJqhYqyE1VZttV8b7cvW+xXdNkH2aRNqwolG6ioZj/uKSoWkKGioEzmOii7BBMlZbXvW/VMRkCyNy5U5jkbr9e7UjrvNi9zD/VYmjnOi5CKvS+R1mVey7cxwDhNX3azOtgGwyLOdrcV6Vsamc2LdWhRdpIjIiOrncNd28rrEmOZhhjxMQCwg2co5j9uSYQ6L9vFk73RySScURVRdpaSJ5EoyadVBnT1Noy1hkn8wQYhO5FO+2ahUR74TUCMeDyCqWQZVrWx10wWBZCLFP/7xML/+9f/S39ePjoA/EGDxkiXYHTK93T2k02kURTEVZG63m2AwRDabxeGQUNQSO3q2o6FSKBYIBAPoQCKZJpnM0NPThw4cccTh+AM+1JKK01nOXfL5fGSzWZSigoCAw+EiHA6Sy+UAjZJaQpZtZZLTYadzehv5Qoann15JsVigqbGZ9es20tDQwNDwMIl4ClESiYTrGBgYZHQ0RkNDA06X2yQTM5kM0WgUp9PJjBkz2LFjh0kwGu3YDQ0NDAwM4PP5zGxH2W7H7nCwbft2srkcQ8PDTGtvZ2R0FLfHQyKZRJQkWlvbGB0bQRRtFIsa69ZuQNM0igWVGTNm0NbWhsPhwG63k8/lkQSRaCRCOp1GkiRmz56D3e4gEo4wPDJMc2MTgUCAXD5Hf18fLS0t5DJZ7LIdpVgsz83moLu7D6fDSaFQpK93AJvNjk2SeXXtRkoljebmRjqnd+L3v70zHpuamnbKYps3bx5//OMfgdcKIoaGhmhqajKXGRoa4tBDDzWXsWa8AZRKJTMOoBocDscbbsWsJB2t5M/rUQcaYxok0Juhfny9SsdqNuzK4hkDB4JQtT43Viuxsf1K2Gw2Tj75ZDRN4+yzz+a2225DFEUuvPBCLrroIrxeL9dddx233norRxxxBJ/85CfN58gYz+12c95555FMJrnjjjs499xzcbvdHHvssVx33XWcfvrpPPbYY2iaxnve8x6uvPJKotHo6yLHK/fp9RxLY/uVpTNTWeprePfBei44nU6++tWvcumll/Kzn/2Mb3/725SUIkpJxeVygaDR29vPH/7wR7q6upg+vZMjFi0im83QtXkzDQ31zJs3j9mzZmLtSnzvMe8hl8vR1dXFz3/+M5599ln6+vro7+9nfHycXC6HIAiEw2EURWF8fNzMulYUxfwbMIr1stms+UXlwMAATqcTv9/PKaecQjabZdWqVbS1tbFlyxYCgQDz589n5cqVtLe343a7a83WNdRQQw3vIKgTxJ9pvdbLZKRVDajoNiRBMYlDa/FLWcloWKXLLdVmWzXspDCslg2p6eKke6u1QRvrV7NeVyufscKqYtQsjdxTbcc6D6uyzrrs3hTKTLWsKOhV1X4GiWds25o9GSu6saMhoiGLJZyiwsZ8E032OAVNJq662Vao45BAH0tdW8nrEusKLUy3D2NHY0xzUyel8AkKWd2GisCqRCdzQ8NsTtaRHncjuxRwgaaVj+M07zhjBQ8He3vLz5Xl/V8S9Kr1zlZVovHz/mjArtyG9ThVe8zA7rY71Vj7e857ixrx+AbB+LAsiiIIAvlsnl/84tc8/vgTKEoJr89vknO6rnHEEYvQVJXBgUE8Hi/FYhGXy0mhkDebGxVFIRQKkstlSSTiuNwu5LSd1ASJFk8kGRkdQ9VKHHLowXg8HlKpNF6vl1gsRqlUQpIkwuEIg4ODuFxuUqkUra2tpjKx3PocpVjMk8lKNLc0EgoF2LB+E7NmzmFsLIbNZscuOxgcHCYSieBy6tjtDiTJxvDQMOFQ2YItSZKZ2RiJRIjH47jdbvL5PMlkkoaGBsbGyuU4xs9G9mMqlSIYCqFqGq+sXo2u6xx2+OFs3ryZoqIwOjbGrFmzcLpcOJ1ubDYbwWCInp4eVFXH7XazcePG8gUTkM/naWiop7enh3Qqjd1uL7dyu934/QGCwQAjI8NIksQRRxzBqlWryGTSjE8U9MiynVmzZiKJEuigFFWUYoZ0OsvYWJLt27sJBkMMDg7j93tJplIEA0GLsmIi5PNthuXLl7Nx48ZJ923atIn29nYAOjs7aWxs5JFHHjGJxmQyyapVqzj99NOBcsFEPB7nhRdeYNGiRUA5E0/TNJYsWbJX89lfZEmlutHaBGxtgDWW3V/bM0gzKwm0v8Y3UEkOVlMF7q/tWf811Jx7a1/c0+WshSnW/MRqiizjtfekk06iWCzyne98h1tvvRVZllmxYgXf+c538Hg83HHHHeaY1jEMMtXr9XLhhReSSqW45557TBLzyCOP5JprrjFVkVdffTUtLS2TlFR7C4OMNvZ1X84N63ld7bhU5nvWUAO8dn44nU6+//3v89xzz/H973+fs88+m64tZdvz4iVH0tLcwv/73P/D7/OhKCX++Ic/8MorrzBvzmyO+8D7aW1tZWRkmIGhQYaGhhgeGqZr82ZeeuklduzYQTqdJhAI0NjYSFNTEzabzVRPtra2Ul9fj8PhmNQ4b5QLeTwevF4vPp+PtrY2lixZQn9/P9lslkAgQHt7O5s2bWLGjBk0NTXR1tbG4YcfTjgc5uijj8Zut7+uvNMaaqihhhreXBhW6kpLtfG7aCELTYJQKCsFi0gTRFzZblu2aovYBRUs5COUiT/JQu4ZsJKOVtKvupJyMuFnJRd3Wt5ChFaiMjOyskF7Vwo5Y47WuVrbrI2fy9mUgvn43pCSldvfFRHqFEr4bQVEQUdBQkJnpOQjbMsQK3lossdJqG6cosLxvjWMqB62FBtokWNExBwZ3UadlEFGQ0PAJyr8PXEwdfY0I0UvDqnEhxa+ygNrD8LmVGitG8chlQjLGfozAWRB3an5eypSrpoqEn3qLMe9QSUZbFr4d2GvrvbYrghFQ8UpTWRZGssaqkpJ0Mnr+37NsqeoEY8HEJWWQuOCP5vN8vDDD/PnP/8Zj8dLNFpHPB6fsPq6efTRR2lta6FUUrDb7ahqCZfLTbFYnCC9ZBwOB/39/UhyuWF6bGyUXC6HzSaRzZYolUqMjIyQy3UwOqryyiuvsPiIRfi8PpLJJJqmkcvlKBaLBINBM6cxl8uh6/qkluZUKkkg4EcQBBrqG5g7dy7btu7gkUceYdasWbjdbmbPno0syySTSSRJQpZlBEHA5XLhdrsZHBwknU7T2dlp5kCqqorX68Vms9HX10d7ezttbW0kk0kzi0lVVWw2G9pEjlRDQwOBQIB4PG5as30+H4VCgXQ6jSiK+Hw+urq6JrWf5nLlgp1AIICu6wSDQXLZLJ2dnaRS5ZIZ45jmcjkkSaRYLNDW1ko8Ps68eXN57LFHAZ2DDlpAU1MTdXVR+vr7WL9+A4Vi+bnq7xtg8+atxGJxOjun43Z7EEWRZDKFP+B/21/onHvuuRx11FFcfvnlfPrTn+bZZ5/l1ltv5dZbbwXK5/w555zDD3/4Q2bNmkVnZycXXnghzc3NnHLKKUBZIXniiSfyta99jVtuuQVFUTjzzDP5zGc+Q3Nz817Nx9r0u6tljLlN9Vjl70YBjAGbbd9fKndVzmIlxgwSyNouXQ17YlWu9rg1l213hNi+jF95vzX30Uo+TjU32LuiFWteYbk5d/eN0bIs88lPfhJRFDn33HNNS/CKFSv45je/yWc/+1nq6uqqlv8YBGQoFOKyyy4jl8tx//33841vfIM77riDhQsX8stf/hKAUCg0Jem3q30yYCWh94QYnGo7uzqWVit5Te1YQyWM887j8bB06VLOPvtsfvzjH/PZz36WUDDIjTfcRCgU4qtf/Rp10TpkWeOkj57EMce8h61buvjd737HSy+9xObNmxmPxxEFgYMOOoi2tjbmzZvHQQcdRKFQoFgsoqrlfOSOjg7sdjsulwubzTZJnQuYj/n9fkKhEI2NjSQSCTPnUdd183MMlF+DvF4vHo+HUChEOBwGyurlGmqooYYa3v4wSEZpL3L6JHQUXdrjApXKdc1tHyABiTnuhJrRICCr2a6rleZUI0CtKsNdkYFWAvJAQkJH4zWFZEp10WofwykoxFU3Wc3OQDGIJGi8z7sOgH8kF/I+33rabHFEdJyCioxmqhRTmoxDVBAFnbTiYJpnnKTiZFbbEON5F0MJH+2RGG3OGI9mZtFXDLHUtXWv574v7d37tA2d/WL7NklHQTdVr5UKTgm9Snf7/keNeHyDYBALgiAyMjLCypUrCYVCuFxlYsput+NwOAiHw7RMNC/OnDmLV15+GYfDQU9PN9FoxCxasdvtNDc3s6lrM0bTpKap5gf58kU/bN++nYaGesbH44yNxZg5cybFYhGHw0E+nzcJDrvdTjKZJBQK0dvbS2trK+Pj4zQ2NpHN5igUCgQCAbKZPMuWLSOVyvLUk0+zdetWU3Fg2JaKxSJerxdZlikUCiSTSQqFAk6n08yVTCQSOJ1Ocrkcbreb8fFx+vv7qa+vR5IkNmzYwIIFC+ju7qZQKCAIAqlUClEUKZVKeDweVq9eTalUzm40tm1kZBoZjU6nk/HxccbGxvB4PABEo1EymQyqqk0QnxLhcBiHw8n69evJZrP09/cTjUbIZNLs2LGDae1t1NWXbZOBQIBkMsno6ChdXV288spqPF4viUSCXK440cDtIJvNThyDPNG6EPX19eZF1NuVgDzyyCO59957WbFiBZdeeimdnZ1cc801fO5znzOXOf/888lkMnz9618nHo9z9NFH88ADD+B0Os1lfv3rX3PmmWfy/ve/3yyjuO666/Z6Plab8v5QbRnNv8bPVjJrf6vCKsczVHXW9uH9uc1KcmpvMwenUlHuCtYsy0pL495kPVrJN2M8K0ksiuIekanGa8THP/5xFEXh/PPP5+abb8Zms3H++eebpGM6naZQKJDJZMhkMiSTSVKpFKOjo8RiMcbHx00l1vr16zn77LP57W9/S3Nz8yRlYiVxWW1Olb9XqlEPpAIWJjeT11BDNTidTubPn8+nPvUpHnjgAQRB4PjjT2T27Nnous5jjz3Gq6++ypNPPsn6devQtBILFy4EIBgMMj4+TjqT4bnnnmPz5s00NzcTiUTwer3m35FxS6fTpNNp8+9IlmWznKlYLJpZy+WCmcU888wzxCacCEceeeSkc/2II46YtB81ZW8NNdRQw7sP1ZSDht0a9py03F+5jcAki3S1bVgfs1rBreSjYem2Lmttsp5qu5KwcyP2rsjGvVU97gmMObrEInHNiYrIfPsA25Uw2wr1hG0ZHKLCLMcgQbHAQ5l5HOzuISylURFwCyp2NIq6iKoLKIg4BZVZjiEA+qQgs92DPJ/oIOLMUOdK80qxmRMb1rI+08R4fwBHR2mCcJva4mzAStSJE4SpNMVxEaluOd+b42Idy0ClunJ3jdiV8zeWq6qWRKCqx3w/o0Y8HkBUyzlLplI888wzCIJAY2MjkmQjny8yNjaG2+0mm80SDASQJIloNEo4HKa7u5vh4WGi0SgzZ85EVVUSiQRtbW0oanEiu8hHXX3ELHUJhyJkc1l6e3uRJImR4VEymeyEPbtM/AHU1dWhKAoej8e0OBkFLzabjVwuN/HYGA6nHYB8vsBRy5bhdnn5xz/+wY4dO4hEIsydOxdgom3bUVYV5nIThTd+crmcabPWdZ1SqWSWxrS0tJgX9y0tLYyPjxOLxVAUBUEQiNbVMR6Pk0ql0HWdkZERYrEYHR0d7Nixw1RWGnOORCKUSiU2btxIU1MTiqIwODhIIBAgEAhgs9lobW1mw/oNBAIBZsyYQTKZZGyszmy9bmpuoq+vF5/Pw7/+9SRLly7F7faAoJFMJena3MXatWuRbXYSiSSJRJKG+kZKJQ1V1RkdHcPn86BpKna7nY72jkkKjrfrRdBJJ53ESSedNOXjgiBw6aWX7rKpNhwO85vf/OZ1z8U4ngZJWI3I2RPCrFQq7bLIY3fr7yuqqSGtKrTKue8NWWeFMZ6VnNtTVePrPU+tVuXdWbwrsxutUJTyB0RryY/xvO8tSWuz2fi3f/s3dF3nvPPO4/rrr+eVV14xi6uSySTpdJpUKkWhUEBRFDNfzmrBN5RW27ZtY3R0lJaWlp32farnrZo6sdJ+v7dKydezzOuxhdfwzoVxDra3t/Of//mf2O12Hnnknzzx+KP8/e9/Bb38nr9p08ZyJEowRF1d1IxSMWzOsiybfy82m8183S6VSiiKYn5h2NHRwaGHHsrSpUv5xS9+QalU4t///d/ZsGEDW7Zs4eijj0ZVVV5++WXmz5/PSSedNOnv5u36vlpDDTXUUMO+o1K9qOg2ZKFMLOU1GWDCRs1EI3T5s5zRQG3gtabq1+zWZTuuiEq5lGbycq+pCw014eT7JgQ+ljIbaz5jpSrRQDVisprisXLexjiioCNN2GgnzU0oz8Pa5Gwcu6nUjoY9t1ohTSUqx5iKBJXRiOlORopeBksB6qQkKc1OTPUStmXwSTmcgkKbLc6GYgNBKctCR59JFOYnjoWh5nMKKqmJTEgJnTneITZlG4k60gCsGm7nsMZeDnV284/h+WAvZ0oax6KyVKaahdpK2Gm6sFdZiXuiXJwqj7GSxNzbsYznutr4k++vEY9vW1Re6JUJwTzPPPMMyWQSWZZxu92oqoYgKKZCr6dnO9u3b+e9xx4zkb8YZseOHfj9fooTZSaGWnF8fAyv14vX6yYcCeH1ehGEYbxeD6qq4nZ5iCdi7Nixg0DARzQSwWaTmDNnDna73cxdNGxOPp8Pt9s9SZFnKPacThfJVBynw40oSmhqgfb2dpqamojH4wwODtLa2mo2W4uiSF9fH9FolEKhYFqbVFVldHR00u8+nw+Hw2EGyWcyGerr6ykUCoyMjJh5Th6Ph3w+b+Zbut1uU+no8XjIZrPouo7L5SKbzaJpGi6XC0VRCAaD2O12MpkMPp+PZDJBLDY+QUT6GB4ZorOzA6fLTiAQIBKOMDI6Qjwew+Wy8973HsMJJxyPLNv5298e4MEHHqBUUolG6xgYGEK22XG7PJRKKpFIlFyuQDZbJl2dLjvBYBBhPyvYamASSWPNFNwTa+pUOXdWVeobScZYVXLW9uGpFHR7CoMoM4jZN/ocrJy/NbuwGnaluDQeM/YJMInHPZmHAUP5+O///u8UCgUuvPBCHnzwQZP4NeIsnE4nwWAQv99vFmCFQiFCoRCRSIS6ujpCoRAtLS07lS5V2+5U+/t6lY77gxyuvTbVsCsIgoDdbucrX/kK73vf+/jTn/7Epk2bJr40dTFjxgwKhYL5ZYChSrbb7bjdbpxOJy6XC6/XSzQaRVVVRkZGGB4eplQqmV/Gfu5zn2PlypWsWrWK448/nnvvvZd77rmHo48+mq9//etm4/yiRYuQ5fLFZGWhlYHdkf011FBDDTW882DNfpQsxOKeWKMNolBicnGMQQROld/4WibknqkndzUXQ9m4J8UzVpilNoJaVgFaMvsMW3aZYBTR0CZlOu4LrC3YxjjVyMhKkhbK5FlQLPD5upVsLdaz0D3AjlKIvCYz3TFESnXRIY+yptBCvxJklmOIzcV65tqHTOKtkpBzCipBKYtPzPNkajbxoosO9xi9+SARV5YPh9fwf+OLUDSJs5c8TKJUJimnIh2nQjXCcVdZj3uqfqwkFHdHbO4u09FApbq1Vi7zDob1orK7u5sXX3yRcCSMw+5AFGwoioqmlR/P5XIcdNACxsfH6e3txeMuk20NDQ1s376deDzO2NgY0WiUQGCCiLSJzJgxg56eXhSlQDAURBRsJOIpJMmGlJIpFvNs3bKV+roo9fVRWies3AapGQgEiEQiDA0NIQgC2Wx2wrqtoSgKqVQaWZZobm4mNhY3lZtGWPuaNWtYt24ddrudpUuXApjKhnw+TzgcNlsnJUky85d0XTft1oba0ul0Mjg4SCgUIpVKmaRjf38/HdOn43A4GBgYwOVyUSqVsywNwikcDpNMJicIWIGxsTEz78ntLjdrNzY2MjY2isfjIZ1K4XI58XjLZOvw8BAej5dMJkMkEsbn8+D3+3A47Bx99FG4XA7y+SIzZswgGAqx9tW1hEIRcrkcPn8AXc+xffsOSiUVr9dnkiPGBZXb5apd+OxnWDMLrRmJ1QhD60VoNduuQfIZF86vJ9dxXzCVBfb1KA+rKR33BZXbrlTw7akN20oU703kQKlUmkQQGyrK3Skdp1KIGmPYbDa+8IUv0NbWRk9Pj0kqBoNBvF4vbrcbl8uFw+EwM+cMtZYVxrmzN8SuVd05lRJ0XxWuu8K+WOZrePeh2nlskI9z5szhO9/5DvF4nHvuuYdnn32WgYEBstmyq6JUKuFwOHC73USjUVpaWmhubqapqYnp06cTCARYs2YNDQ0NzJo1y3zNNbIdp0+fDpQjYBYuXIiu6zgcjkmvYwbpuKv51lBDDTXU8O6AQW4pum2n+81imCpEXiWsSsPXili0qn2g1tZrkyQUJqslq7VeV6Iyk3GqWVYWyVjXMR633ldNlTlpvYqPgPtiqdYqrLu7ml8lVAT6SyF8Up7sxPPWYR8lqTmZbh8mqzkYUgK020fJazKz7EPENQc+sbgTwafqZdKuwzbGC/l2RgtempwJRoo+Nsfr+GrHv9hRjPLiaBsfbVlDWnUStmVMxaNWQT7uNNddkI0HCpVk5j7bty1Zjrt6/I1AjXjcz6j2Dbuu6yiKQiwWY8aM6YyMjmJ32CkUMrhcTlRVIxgMEovF8Pm8gMbIyAizZ81mbGwMv99PS0sLvb29NDY20tDQQKlUzjrMZNJ4PB5TUZDJ5FBLGvl8AZdLLFuDcxrpTJbnn3+egw6ab6oSmpqa8Hq9ZLNZXC4XmqYxNDREJpMBwOfzkU6XFYKKUiCXy00UuyRobmoim81zxBFHEIvF2LZtGxs3lq1WRx55ZFlx6XZTKpUQRRGv12taqQuFgkluGpmJHo+H4eHewBwEAAEAAElEQVRhfL4yYTc6Oko8HjePY11dHfl8nlQqRSwWMwtxRkdH8fl8Zqbk6OgohUIBgGKxiN1uN23lRvD88PAw7e3tOBwOsrkM03wtFAoFYrFx2tra6O/vp7t7Bx0d7YRCQUZGhnj5lZc45OCDcbt91NfXs3z5ctasXsPo6Cget5d8voDT6SIcDiGKIrFYjFhsjIaGOlxuJ0ceeST+gP8NOQffrTBIrF1lJFpJHkNRaPxuJTHfTNvpVFmAe0rUGeSXVem4q7H3Zh5TbWtvYCVUDcKucptWpaeVPLW+vu6PDExDLXnCCSfsluTbHYm5p3mjU8UBHKjjXUMN+wOV553x5eUXv/hFTj75ZIaHhxkZGSGZTJLP5ydlhkqShMPhwOv1EggEsNvtpFIpQqEQfv9rpWvGNlwul7mukQ1sJfb39G+g9rdSQw011PDOhSRoSMJr5FpRl0xLsbiHysPyupNbrCc/9ppK0NimAU0XdyIkq91XWQCzOxhKRcMGbmxbq1BwVtuGgcnN1ZMJy0qC0ry/ovHaOtak5aYgKCtJyGowlIoqAinNzovpdo4LrEdCp902zo5SiA55lLjqZrAU4HDXdgZLATrkUTK6nazmICgWJpFwCiIyGgVdIqPLjJZ8HO7vBmB1vIXjmzcgCyVeSbZyaKQPt1gkoboITDRi5yeKhoy5TZXRaCUCqy3zektgXg+sGZS7Q03x+A6H8W298Y29LMvIskwgEEDTIJcr0NDQgKIo9PcPEImGGR4eRhDKRSh9fX1ks1lWr15NfX0jTU3NOJ2OcpuzkqdQLOD1uslkUthsErqmkUgkUJQSc+bMYcvWLsbGRtA1hZUrVzJv3hzcbjcjIyNEo1FisRj5fB6n00mxWKS+vp7x8XEzN3FkZBSfz0Mul0EUyqRMbCyGw1HOVAyFQgBks1kSiQTr169n5syZ2Gw2PB4PiqKQTCbxeDwkk0nzgiSTyZjt1QZJomkaHo+HYrFINps122FHx8bweL1s2LCBYDCIpmlmiY5hGc/lcmYWZn9/P6IoksvlqKurI5VKEQgEcDgcjIwkWLNmDQsOmo/dLhOLxSYyIRVsNom6uiibN29GFGH27Fm43HZ27NhOKBiko3MGkiQxd+5cotE6SoqK1+unf3Bggvx1TZAlOtlsjnQ6TSQS5qCDDsLhcGB8vVS7INo/qHYRWkleWck6Q+FY2eRrEGFGG7t1nL2dTyV2R2btbhljOSMX1SC2Ki3MVljVtlPN642ClbCrphSsdr+hYrbmHlqJ4UoCdlfHcarHqikUd3ecdqeunCqfcypUEpV7Slju6pjuDfb0/KuhhmowYk68Xi+tra27zGitxGc+8xlgZwXuVK/nlT+/E2H9m57q9WpPcCCU0jXUUEMNbzWUdNtEWYZGUZfQEFF1EVlQdlI52gUVKu4rZz1OhmlzRkQVNOyUi1gUoGgSgiVzWUPRqPFaXqOqSzgFZY9as62qxNeap0UktElWaWMZ6zqV9+80nqBalKDSpDzLavOSdMHMh7QSi8bPlTZqg6Q0xpKnIDSnwuZiI16pgFsoEBAVEpqMWyyg6BKDpQAHOfp5LtfJfGcfSc1JXpeZZhs3VY/OCUu5SrlcRkVgVXYmXimPU1D4Ve8SpvvGOMy9g18NLiWvyiwObuPJ8Zm8N7yJelvKJC0VxKrKwn1RGU61fjVFZbX8xl2N93owFeFokMW7I433B96e1bpvI1g/SAeDQQRBZNq0aUC54MBul3G7XROFJ+WL1kQijsfjwWaTsdlsqKqKJEm0tbXx5JNP0N3dbWYilUoq6XSanp4+stkc2WwWm81GR0c7drud/v5+ZJs8Yc8OsWXLFgYGBikWFcbGxhHFsmrB5XJRV1dnlsAY6sK6ujrc7rL6wO8LUCq91vhbUhVyuXIxTDk3McmO7m76+vvJT7RZl1SVYrGIIAioqkpDQwM+n2+iIXYEURQoKkVEUUDVVEpqCZvNhtvtJhwOARo2WTJznSKRiKl6BEgkEpRKJfr6+uju7iabzZp2L0mSKJVK5HI5NE3D7/dPqELLhKfH40WSbMiynVwuhyRJbNu2DV3XkGWJfD6HTZY49NBDaWhoQJQEbDaRbDZNQ309S5cuI5NNk8lmyeVyuNxuUukUmzdvpr+/FygrLEOhIH6/D5h8oV/tVsPrh5WUq3ZcpzrWlRbaSnLyzUKltdg6/2o/W8tPdne+GctPdYx2dTPmVrl8JXZ1DK0EYiW5WKny3JWa8M1+rqwkcKWadqq/8b2xmlfCmnFZDbt6Pam97tSwP1CNLLe+Vllfh6vdrFEJlV+kvJtR+Zq+q/t39Te+J2PXXgNqqKGGtzMEXiMSFcoknV1QsQuqabkuqyInF6kY902lQBQFzSQVjWIW0TJOuWjmtc9vU6klX3tc2Olf47YrGGSkcdtVvmM1yBP7aKy7u7ZrY0770mC9J2pOldeKUmKqm1jJy5jioV5Kk9JtxDUXfqHAlmI9HfZR1hRame/sI6U5iWtuZshj5HUbI6p/UjajhI6MxnYlilss0GhL8ExyBi2eBF+oe5o7+o9GFHQODfayJtVK1JGhzpYkr8sT58PeWZk1di582VMY676eMSrHeTuhRjzuZ1T7tt6wC9bV1RHw+8mk0gT9ATRVQVMV0FUaG6PMnNFJNBoiHAwyOjxC944daJrG+Pg4hUKBcDjM7Nmz2L59G7oO2WwBQbdhl1xM75jJkYuWICLj9wUQBZHe7h5GhkZIxBN43D5KJR27w0P/wCi6bsPpdDM0MIyqaHjcXiTBRrGgUMwXkSSZRCJFb28fgUAQRVHZunUHsuygVFIpqQotLU34A168XhfHn/ABHE4HiXSK4bEx1m7YwI7eXkbHxojU1RGpq8Nmt4MooOkqskNCsMHw6BCFYo50NoXP5wZURAm8Pg+hcACnS2Z0dAhQ8XrdZgabYefSdd20eLW0tJgKyUAgYOaxGUU+xWIRXddpamqmWFTYvLmLYqGErguUSho2m8zAQD9jY6PIskxTUzMBX4CW5lba2zo4aN4CHLLMju1bEESFgw+ZR0lTSOWS+II+Eqkkkl0mW8iRyWWwO21Mm9bK7Nkz8Xk9MEHyGDdDeVfD60flhavx8/9n787j2yjPvf9/RvtmyZb3PfuekISQEKCkZaf0tCzdaQndeMpJ+pTSlfNroaUtcHqe0xUK9Dk9wNOW0tIWeqDsW6CEhBAI2ReyOol3W5YtW9tofn/IMxnJ8pYoiZ1c79fLr8TSaOYeSXE8X133fVmt1oxwzLyOIxzpTGzujDza6cjDXTSPdpuhHjtYmKjLbkYznKO54DRXIY7GUOdmHov+78J8X/ZrNNg+hzv+aAOOkW6bvY156n6u89RDx6MZS65KKAluxIk0XKh4vL9OZTt37jSWrXnjjTfYuHEjmqbR2dnJE088QUdHB48++ih//etfaW1t5amnnmL16tWoqkp7ezv/8z//w549e3jkkUf4/e9/z759+3j55Zd57bXX6O7u5umnn+a1114jGo3yyiuv8Nprr5FMJk/2aQshxKiZQ0V7eqXFjEDPvKZjrnUPLaYg0dhnf1MZ89qMCc2GlRQuJYFdSfZXQaYyHjPkOPuPZVdU409zoDhw+3RgaFdU4zGDTY8eSiIjTLQMGw4eTZMZFYWEZsk41nAsaIRSHua4GvBZY8RJP95jibE7UUqhtZemZICgtYeUZiGkeplmb6FV9bIzXk6pNQwcqSBMr+OpUWELMcPZyP54CYd6A1xV8jbPhecQSTg4q3AfoUS6se25/l2sj0w0KldV7ejCVn3K9cl2rOGj2t+h+0RMwZbg8TjI/uVYv8i0Wq1UVlYajQrSVXwwadIECnxeCgq8KGBMRd69ezfl5eWcd955BINBgsEgTqeTjo4Ompoa8fkK0DTQNAWPx8fkyVMpKy3DarHS09NDVXU1CxcupLSklK6uLhTFSlt7J6+sepWNGzfhsLvQNAiFQqhJlXA4TIGvgNq6enp6eigrK6OlpYWuri4CgQCRSISDBw8aHStbW1soLAxQUlpMUVERZeVlWG1WurrDHG5qZMu2bax/+21cThexaAKfz4fD4cDtcVNaVorNZqW7J4zDaac30oPNZqW2tgZVTRCLRQmFOrHbbRQU+Ghrb6Wzs4NQKITP5yMej9PW1kZjY2P/dOZiZs6cyaJFiygvL2fKlCmcddZZfPrTn+Z973sfkyZNMqo5p0+fzgc/+EEuu+wyJkyYQF9vX3/nbTezZ8+mrKwMv99PaWkpdrsdLaUxZdIUFE0hEuklEPDj9rg4e+lirr7maiZOnIDH4yHSG6G3rw+n00lJSQnz5s3F5Xb2T/F2ceDAAXbt2kVHR8eoAyIxtKEqN8whr/l5NwdAeuVZPqo/8l1JkqvKMDvEMp/baNY+zP45NdLHHM37drCqP/1PVVUzQkf9WOafn9nHHW7MI6naHMnjR7JdNnOlpv6lG+z5O5YxSuWSEONbc3Mzd999N/feey87duxg586d/POf/0TTNJ544gn+8Ic/cPjwYVatWkUgECAej1NYWMjjjz9OW1sbTzzxBA8//DB2u51p06axceNGdu/ezbp161i9ejVbt26lsLCQv/71r2zevJlVq1axZs0ampubT/apCyHGobvuugtFUbjpppuM26LRKCtWrKC4uBifz8c111wz4GfMgQMHuOKKK/B4PJSVlfHNb37zqD4ASWo2EprNqHbUJTTbkGs86kFgdsCYa7t0AJgcEBSm/54ZXOYKE/UA0UFm1aXOvKZirkYxucaTvZ/BO22nA8dE/9qXgwWDxvqVpv3pX3qgONTzM9h92dsZ62WiMMHWToWtm2pniO6UC7uS4nAyvXSbS0kAUGbtpikZYIajkTgWdsYrqLN3UGCJsytRSijlJEE6UO1N2QhaongsMTZ013BNxdsAvN1ZyyXl2+hVnbitcRb699OtughY++hW0zM6U/0NZgZ7LoeTHT7qgaT5y66kBg0pjyW81B+bHRqOZp9WRTO+jjcJHo8j89Q7vUtuRUUFRUVFRgfHmpoa7Ha7sUZSRUUFDoeD1tZW2tvbSSQSxOPxdBfmnh5UNR0QbtiwAVVVcbmceL0eFEXhwIEDWCwKiUSc3t4IbpeTWbNncvHFFxtTklOpFAcOHGDjxo2oqkphYSGJRIJoNGp0cS3w+dA0jVgsRmFhIXv37uXw4cNUVVURi8WMDtUdHR3EYjGSySTxeIySkhImT56Mpmm0trbS2xth27Zt/L/f/Y5Dhw7R2dnZ36gmAVr6eVFVNd09WEl3oe7pSTfL0adLv/fee+kumH4/mpbucqkoCiUlJaRSKWw2G4FAgNraWt555x2ee+4545fszZs3895777FhwwYOHDhAPB4nHo/z8ssv8+abb7J9+3a2bt1KMqn2T21Pr1dZXFwMQCwWQ1EUtm/fTsPBBg4fPsS+fXs5dOgQq1evJpFM0NHZwerVq2lsbETTUrQ0NWGxWiivKOdw42H27t3D5MmTqKqsoLq6moqKCjo6Ojh48CCJROKkTxE91SUSCSPMSiQSRrWjXg2ZK8zSjdVQWA/j9KBOP7+jbbZyMs9TURTj54m5ItUcounrbo7V1yObeZx66K13Ts++XwghdKqqGh8yV1VVMWvWLCwWC/v27aOxsZH6+nq8Xi/ve9/7eOGFF4hGo0yYkP7gs6mpiZaWFurq6vB6vWiaxpw5c0gkEsyYMYOJEyfS19dHV1cXqVSKQCBAOBzm4MGD/etPCyHEyK1bt47777+fefPmZdz+ta99jSeeeIJHH32UVatWcfjwYa6++mrjflVVueKKK4jH46xevZqHHnqIBx98kFtvvfWYxpMyhX8Z3Zs1S8ZXNpV0MBdN2QesqZi+f+D0aP3rSAiZMqoSj0zTPtLYJTvM0qdu68xdtI3zGUUF4VDMY0lplpxfuc55qGNnVwcOFT4eWbfyyDRuc9XpBd5tFFiihFIuwqqLWns7raqfCfY2DvU3mgHYGqumzBam0NLHvkSQSMqJS69YRMGiaCSwsK5vEgv9B5jvOsDf2+czzd9Cia2bTeEq6pwdlNrCTHU2kUIhaO0xAjq76fUY7LyznxPzdOfBGtKMJszLfn8Nt62lf5q4fuxc07jN61YOts2YrXi89957mTdvHn6/H7/fz9KlS3n66aeN+0/kpxzjiR4SOJ3p6re6ujqKioqoqqpi6dKlBINBotEofr/fCB5tNhtut5sDBw5QWlpKcXExNpuNjo4OHA4H8XicxsZDKAq43S58Pg8XXvgBiouD2O12Jk+eREtrM9u3b2Xi5AkEg0EikQhFwSLcbjddXV3s3LmT3t5eYrE4e/fuJR6PEwqF6OzspLKyEqvVSltbG06nk+7ubvr6+vD7/bS3t2OxWCgsLKSnp8cICdJrVjqIRCK0t7f3d3buYP369Tz66KO89NJLJBIJgsEgLpeLgoICamtr6e3tRetvKtPc3EwikURVVaLRqHGb0+UilVJxu920t7cTjUax2+1YLBZisZgxJSkWi1FTU0MkEqGzs5Ndu3bhdruN92R5eTk2m413332XPXv2EI1Gje7a3d3dtLe30dfXR3d3N+FwmF27dlFQUMD8+WdQV1dHYWEhHo+HTZs2sW/fPspKS3C5nEQiPVhtVhSrQjQaZd++vdjtNs48cyHTpk2lu6eHeDyGy+ViwoQJJJNJmpqajmrKqhgdc+dqfW1UwAgdRxP8jqUpf+Ypz0czTXy4fR5tiDnaqd7mbc1TlCG97qa+3XDHPRmyqwxzVWTmGvuxjDfX85trHCf7/SmEGJ1UKkVxcTEulwuHw8HevXtpbm5m9+7dJJNJdu7cyaZNm6iqqsLpdHL48GHuuusuZs6cyaFDh0gkEuzcuZO9e/fy7rvvMm3aNGpra9m6dSvvvfceiqLgcrlwuVysXr2aGTNmUFNTQ0NDw8k+dSHEONLT08O1117L//2//9doMArpdfd/+9vf8tOf/pQLLriAM888kwceeIDVq1ezZs0aAJ577jm2bt3K73//e+bPn8/ll1/OD3/4Q+655x7i8fioxqGv8ZjRsbl/mnIiHQeOaD+5AsmRMId65inaeiWkHijqIWJ2FWB2QKlPw86nkXTUNh/3WILOVP+UZaMZTXYjlf7bU5piNKrR/2xN+pnmaKZD9VFhS1dBFlt7sCsq2+OVVNk6mWRvo0X10ZQsxKUk2BSrGVCFWmHr4hzPLlZFZuC0qJzhbeCJljOYUdBMqS1Ma9JPd8qNzxqlzNpjdNgeqrIz26gCwv5O3/qf5irIE2G44DNfa06O1Kj+pdXU1HDXXXexfv163nrrLS644AI+8pGPsGXLFuDkfcox1pmnDSqKQmVlJeedd54RQM2dOxe/3084HKasrIyKigrKysqoq6sjmUzi8/morq6mqqqKSZMmAdDe3s57771nrHMYDAbp7u7GYrX0N07xEI32smXLZrpCIZYuXYrT6aSttS39Cfr+/bS2tmCz2SgpKTGaw6RSKXp6eozuuQ6Hg9LSUtxut9HBMhgMkkwmicVixOPx/mk90ykpKaGlpQW3250OdVDo7e0l2tfH1q1b2bBhA5s2bUr/J6WAz+cDMDp9ezye/sdacDqdBINBJk2axP79+/F6vEa1Wk9PT7pqEoy/FxQUGFVs4XCYkpISenp6KCoqwufz0dHRYYQc5lCzqamJnTt39u/DT3d3D6FQiLKyMqJ9fSiKwvTp0wmFQv3VmB7jP1mn08nUaVM559xzCAaLaGpqQk0msVigtzdCW1srU6dOobauBkXR2LdvHwcPHkTTNGpra4lGo0QiEWNqvci/7Cqz7GDLfN94oH+IAWRMER/PcjVNyF77dDy9Rmb6z/yjrUYVQpw+iouL+dCHPsRHPvIRnE4nFouF6dOnM2/ePL71rW/xrW99i6VLlxKJRLjkkkuora1lyZIl2Gw2zjjjDL75zW/y7W9/m9mzZ7NgwQKmTp3KtGnTOOecc3j/+9/PvHnz6Ovr40Mf+hBXX301U6ZMYfHixcyaNetkn7oQYhxZsWIFV1xxBRdddFHG7evXryeRSGTcPmPGDOrq6njjjTcAeOONN5g7dy7l5eXGNpdeeinhcNjIE7LF+huWmr8gvcajPqV6QFXhCMNEKymjIU3u9RZzr8VoDgyzm8AYU4r7x6CHern2b3TRzlqDcbSNZHKf25ExZh9zJI8dvPnOyBvJZK6pqWWEdRY0EpqFqGanwhYiqtnTj+1/3kqtEXbFyym0RqiwddObsnM4WcRkRzNRzU6VrfPIGo/9Y53qaEkHz5qVi4s2sztaxmRfK4u9u2lN+pnhPExI9XCBd7tR5Wg17eNo1nocqeEqCrPfQ0fLHGwmNMuYakAzqqvWf/mXf+GDH/yg8cvMj3/8Y3w+H2vWrDnhn3KMF9nVVXrDk4KCAioqKrDb7RQXF1NTU2NUAS5atAhFUejo6CAYDGK1prtdJ5NJ6uvrSaVSdHR0UF5ebtyXDgntWCxQFAzQFe7E43HT1NTEq6+9SmVVBYHCAhKJuBEqJhLpqrvOzg5sNhuhUIjt27fzxpo1bNiwwZjKHA6H8Xg8aJpGJBLBYrEQDAbx+/00NzcTjUYpKio0AtNAIIDX68XhdFJUVITX6zOCwWeeeZY333wTq9VqTJvWNI1wOIzFkg5Ne3p6iMVi2Gw2CgsLqauro6WlmaKiIux2O6WlpUaXa5fLRTKZZNq0aZSVldHV1QWkK6VisRhWq5WOjg7a29vZt28fTqcTr9dLWVkZFouFeDxOQ0MDu3fvJhLpobm5mR07dmCz2bDZ7UyYMAG7w5Hu2L1vP319UXp6eigvL6e7u5uCggKmTZuGz+fD5/MAegWaQl9vhOnTp1FeVkpBQQF1dXUcPHiQ9vZ2HA4HlZWVhMPhjGBaHDt9ym4ymRyw/qHebMhqHTidYrBqxtGunZfvqkjzeo76v3Xz8g16N+6RTtsfzZiOpoJxqDGY79eniKuqagTC+mvkcDjS66tmVUSO9vk8ltdxpPs1018j/Tj6azTYlP6jqeSUtRyFODW5XC4mTpzI9OnTKSgo4KMf/Sif+MQnKC8vx263s3TpUkpLS7n88ss599xzmThxIp/+9Ke55pprqK6uxm63c/bZZ+N0Opk/fz7BYBCbzcb5559vzK754Ac/yPve9z4KCgr4wAc+wLJly456qvXJXt9NCHHiPfLII7z99tvceeedA+5ramrC4XBQWFiYcXt5eTlNTU3GNubQUb9fvy+XO++8k0AgYHzV1tYC6YDKPMU6HUP2f2/uZJ0jaEtXIaa3NU+RTjeSSQc/cazEsQ4INa1GqGMlpVkymr/o+9PDRvP0bXMIp/9pbnJj3jZ7CnSuICq7ijLX/dlj14+VHT6ap4+nNAt2JYVLUTOmII+GeUq1md5pO6UpxvqMhZYoLiWJioLHEgPSoeP2eDkqFiqsYRKahZ3xcqpsnSQ0Gy4lQYWtO+dxQyk39Y42OpI+YikbSwp205AoptweojXpZ5KjJedzpP+pj300lY16uJddPahXOw42zdn82NGw9k+vzhVm5tpfPqbt54PtaB+oqiqPPvookUiEpUuXDvspx9lnnz3opxw33ngjW7ZsYcGCBcd2NmPUYNPi/H6/ERhMmDDBWNOwuLiYyspKkskkdXV1aJpGRUUF0WiUjo4OFi1aZEx1VhSFUChERUU58+bNobW1hTVr1lJdXc3BgwfpDHXy6qurqK6ppqysjKb+ZjEOm43Vr7/OgvnpT8DTwZkPu92e/g+ipZmOjo7+xihOCgsLiUajlJaWGmGnHvzplXsul4u6unqmTZ/BmjVrSCaSlBQV0d3dg8vpIlDoZ/LkSUaTmgkT0usVJRIJPB4PPT092Gw2iouLcTjSjXdisV48Hg+TJ0/B5fawZ89+4/mLx+MoikIkEqGlpYV58+axZ88eHA6HUQkajUaNQNNisdDY2Iiqptd0tFqtxGIx7HY7zc3NuN0uwuEQ3d1h5s+fT19fHyUlJXg9Hkil6AqF6O3tJZlUUZMqPd09eHwWWlrS63HGY1HsdhugoapJ6ifUseTsxaRSKhYL+HweysvL2Lx5E4WFhbhcLrq7uzOqvSR8PDZ68KOHWZDZ4dpc8Zi9zVh8/s3vDXPTFZ15qvhQU37HGv01goFdns1VnHpoPFYrO83rUZpfB/N4B/v5P1bPaTzQn2u96kGIU8HJ/kChu7t7xOMYan23f/zjHzz66KMEAgFWrlzJ1Vdfzeuvvw4cmflUUVFhrI993XXXYbfbueOOO/J/UkKIvGloaOCrX/0qzz//PC6X64Qd95ZbbuHmm282vg+Hw9TW1qJhGRDmjYQ5YENJVz3qIaTdtG6gHioOxrx2ImRWL1pyVNPlI/jJtV6k+c/BjqOPTZfr73pYmt5WIdrftMfcGCe9fX/Foqny0XxbrqrB3E1tjgR96QCyj1DKjd8SpSFZCMBsx2FUFDbFaii1hamwdbMnUcLU/vAwlXX++nNQa2/nn+FpnOffCUCtvb2/srKLYkvfoGMaSTXnSOhrMObLgGnrIwxCx5pRB4+bNm1i6dKlRjOSxx57jFmzZrFhw4bj8ikHpEusY7GY8f2pcrGhKAo+n88IQ+rr69mxYwdPPvkkBQUFFBcXs2vXLiZOnMi+ffuIx+PGdOiysjI6Otqx220oCun1G4sKOf/897Fjx3a2bNnO9OnT6ewM0dMdYdWqVcyaNQun00lKVbHabASLi7Hb7Rw61MDBgwcpKyujpKSE3t5epk+fzqFDh2hoaEBVVWMBc73DdXV1NXv27CEQCNDd3U1XOExraystLc30RWNcdtllvPziS8TicXp6enA60k1wHA4HL7zwAmXlpQQCfpYtW5buLB3pJZlMkkwm2bFjB263l0ikm1QqyeHDjQSLS3jf+5axc+dudu3aRU9PDwBut5u+vj42bNjA2Wefzfnnn8/GjRsJBAK43W5jHchoNIqiKLS0tBhBqbN/Lc1IJAJKuvmI3W7H6XSmQyjSU9qdTieVFRVUlFfQ1dNFa2srSVXF5yugMxRm86ZNtLS2oKpJLFYrKTUJaFx88cXMmDEdq/VINVcwWMSbb64lGo1SUFCAzWZDVdUhm5yI4ZnDH72iF8gIs7KDSHNAOZafe3Ol41CNcCwWS8Z6lkOdk7mKMtftQz3mWJlDR/NrYx6zHuhZrdaM5jn6v6N8XKCPZD+DPU/mx2eHvyN57gcLVI/2OR5Ng6STHW7kQ3t7O4BR9SCEyJ/u7m4CgcCg95vXd/vRj35k3K7PfHr44Ye54IILAHjggQeYOXMma9as4eyzzzZmPr3wwguUl5czf/58fvjDH/Ltb3+b73//+zgcjuN+fkKIo7N+/XpaWlpYuHChcZuqqrz66qvcfffdPPvss0a/AHMe0NzcTEVFBQAVFRW8+eabGfvVq6L1bbI5nc5BK7P1qkeV1IDKxnT4k/sx6JV/WfdlrImoDF+Jna4kswxYUdIcPqY0C1bT2o35rDwzB4jDTaHODh/N7P1TzeNYaFULqLCmsxYHqaxGOhoo6bAwoVlwKWpG+Hm0YZt+DJeSII6V9qSPyf3h4oZoHYXWXibYOmlSfQSt6QzATiojYNPHVmCJsrp3KosK9hpNahyKilVJUW7tIUH/uE0VpoNVlIr8GnXwOH36dDZs2EBXVxd/+ctfWL58OatWrToeYzPceeed/OAHPziuxzjRzGvO6ReuTqeTs846i0AgwOrVq2lububAgQNMnDiRrVu3snbtWubMmcPOnTuZOnUqkKKpqZFly5ZhsYCigNfr5ZxzzmHbtu3YbFaWLVvG6tVv0NbWSiQSoay0lI6ODhKJRH9TljV0d4eA9GMrKyuJRCJoCgQCAXbv3s0bb7zB+eefT19fH6WlpZSWljJ9+nRisRgbNmyguLiYGTNmoSgKra2t9EXTna9nz57Nc88+S1tLK22tbWzfsY2JEycQi0WxWBR6erp55ZVX+NjHPkZbWxvd3d34fD7i8QShUCOBQAGFhUX4/QFee+11HI70NKSSkhKjUtBqteL1euno6OBvf/sbt9xyCwsXLuTJJ5/EZrMZjXFsNlt/tWKSeDxOd3c3LpeLvr4+Kisr2fXeDjweFz09YSZPnkw8HicWj7Nnzx4URaGivBxFUfD7/RQUFKClNMrKyonFVTxeD8lEHJfHg81mo6ujnaqaKj75yU9gt6UrIM2vscfjMd4Hesgpjk322ofmztWDBUH67eYQaKRVj4O9ZvkK53JVOg4VLpmbzJgfk6uqLh/vt6Pdh97dWR+nPu7s4D07yNMD5VxT5I/HOIfaX3YYaQ69RzI+c0icHT6a1yTN19hPxZ8vwWAQSE/ZHCogGQv0yoyGhgb8fv/JHs6QZKz5N17GCemfFd3d3VRVVQ25nXl9N3PwKDOfhDi1XXjhhWzatCnjts997nPMmDGDb3/729TW1mK323nxxRe55pprANixYwcHDhxg6dKlACxdupQf//jHtLS0UFZWBsDzzz+P3+8/qvVmrUqKwbIuK1rOadaQDh+teoUiFiOUU/u3tyvpGsioZu+viNTDNQuQygiq9MpJO2pG2JhxvFGEWMNNqzZP9VZRsCuqcbzBpoUbssJH8xqVFkXDqmk83zWHamcnF3u3GvvQKwFVFOyk6MVGd8qFaonhIJWekq1ZiGpWXIpKQrOkuy6bKjBDKRd+JXZkP+bXRoOIZqfAEqchWUidvYNCS4zt8XKKbT3U2jqIaOnYqtjSh4pCTLNmVCjqz9HWeDlRzcYS5yFa1QJq7e2EVA8VpsAy0b+m5lCvi/m5O5oQMoUC2rFVH5q7Ug92jFxh72BdtrPvNz/2RDS8GXXw6HA4mDJlCgBnnnkm69at4xe/+AWf+MQnjsunHDB4ifV4Zb5wza7wqaqqoqKigvfee89YB9Dj8XDllVfy/ve/n0gk3bSkoaGBBQvOQFVVEokE5RXlxKIxFEWhpKSEs89eQktLK4cPN1FbW83evfux2axUVVbS3NSEgkZDw36qq8pR1fQaiTU1NcQTcfx+P1a7jebmZqZPn86UKVMoKipi06ZNdHZ2psvbNQ273c5LL71EdXU1xSWlNDU1cejgIULhMJs3bmLmzJm43W4Ki4o42HCI2tpqysrK2bd3L8mkRktLO62t7VRV1XDo4EHcLhd9fb3Mnj0Ht9udDk8sFjrbO6ipraWh4RAF/kJ6Ij14vV6SySQOhwNVVamoqKCpqYn/+q//orq6mlAo1D8NvZN4PEEymUxXi6opurrC9PXGSKUgHk9/mlVUGGTfvgP0RSPMnj3bmIq9Y8cO/H4/naEQPT3dRHp78Hg8dHZ04rDbsVqs0N/cJ55I4PW46e6ysHDBQhbOn98fMKhYTAGXvl6mvp7dWK62G+v0QMpc6QcYa6maDfY860sHZIePJ7NTsv5nrkrHkVYlmh+v33e8QqjBxmSuPjVXLurjs1qtRliXq7owuzGXOYQd7nk4nk2Esl8jc+g4WHid/Rrq77vRVt3muyrVPF18vNDfQ4FAYMyHOTq/3y9jPQ7Gy1jHyziHC/L19d3WrVs34L7jtb4bnLozn4QYTwoKCpgzZ07GbV6vl+LiYuP2L3zhC9x8881GL4CvfOUrLF26lLPPPhuASy65hFmzZvHZz36Wn/zkJzQ1NfHd736XFStWHNV6s3bU9Dp6pmBuuJDIqqTSwWP/9nHNihUFVbMYU63N6y3q9OnY5vDRXBmZHTYONrV5qMrEwR4DkDI91jy1Oj2G1IAqS/NxjqxfeCSgNAdrcSw4tPQ5va9gJ789dB5LPLvpUH3U2jqwoA2oMIxoDpriAaY6momknBkdua1o9KbsuPqfmzgWXu6exTLfdoLW3nTwZZqSraJQaInRqnqxo1Jo6SOi2bAqKWptHbgUlahmpdQa6Z8Gn1npaH7NVSyc5d5LQrNSaOnFQYpCa++Q61UOF9iOZqp89vT3we4fbQOZwR6XPd08+/7humjr61CeCMe8yFQqlSIWi3HmmWcan3Locn3KsWnTJlpajizqOZJPOZxOp/FL23j55W0ksi9EzaGH0+lgwoQ6HA4bbW0teL1uqqsrmTixnjPOmMekSRNwOBzU19ezZ89eeiNR7HYnYGH//gYWLz6buXPn4fcXYLVaKCz0E4v2MX/ePLq7uvD7fcyYOZ1AkZ/3X7CMyuoKyipK6e4J09UdMtZb1Nd8dLvdzJ49G6fTSXFJMQ2HDmKxWZg3/wyKS0toam4kGu3FabdR5C/gvZ07CXeGKfD6cbs8+Hw+entjVFfV4fEEeG/XftpaQrgcPja+u5kdO95j56497Ny1m1BXmMKiIlxuN6qqYbM76Yn00tEVItzTTW80SkoBxWqlNxrF5XKRSqrYLFb2791Hw4ED+P0FKAr905gtbNy4kfb2DjZv3kpbawdutw9Ns2KxOtm5ay8lZZUoFhuR3igHDh5Mr/ZhU1C1JI0tjRxqPERLWysWi4W25hYsGuzfs5eW5mYSsTgelxsrCsFAAKuiceaCM/C6PajJ9CdAiUQKi8VGIqFSXl5pVOclEokhp3OKoSWTyYy1AvU/zWHWSMIYPcjQQ6TsdftOhOx1AkcybTeX7KnleofokZ5L9vmP5HkYalu90Y95HPprlF3tN9Rx9LAu17GyH3ciXjc9dIQjzcNGe1z9ddKD75PxM8BcZSmEEIPR13f7wx/+cELXd4PBm0sIIcaWn/3sZ3zoQx/immuu4fzzz6eiooK//e1vxv1Wq5Unn3wSq9XK0qVL+cxnPsN1113H7bffflTHS+Ro/gJHwpeRdLe26lV/SnqtR/MXHFn7UA/tcjV+sStqRpOafHSlziWlWYymNkfzWMgMHfX96VWNoZSbWns7nVE3m6K1/Nu7V/J09zwOJ9MfSkU1KzsSZWyJpSvj98dLSGhWulNu/m/L+43AEY6EpNvjFbzdN4GJzhbCKVe603JW0GVX0lWIEc1BsTUCwK54BaXWcEb3aXN1Zq71GC396zuWW3sosMQpsKSbF+tVmHpIdyKq+463XI1xdNnNa4ZqbKM/LydiXchRVTzecsstXH755dTV1dHd3c3DDz/MK6+8wrPPPksgEDjhn3KMZ9kXqeYqK03T8Hq9WCwW/H5/euqzqUKutLSUrq4uvF4vra2tnHHGAnw+H4AR6sZiMXp7e9E0jd7eCJFIhI0b32X6tBmcMX8e4XCIOXNmU1QUoKqqitbWVpqbm2ltbWXr1q1Mnz6TmTNn0tLSQiwWIxgM0tHRgd/vJxaL94ek8PGPf5xEIsH2bTsIh8MUFPhIJFTsdgexWIxEIoGqqhQVBWlra2fLlq3Y7Q40DVRVIxQKEe7uAtIBxeHDh9i3b1+6kU1ZKW6XG5vNTmtrO/sbDvQ/VymSqkpfbx/F/V0be6MxozFNSlVRrBbsdrvxy3EwGKS9vYOSkhLa2zuIxaKoqko8nsDpdKGlUkSjMQoDhWzZsoWzz17C7NkzjQY03d099HT3EPAX0BUOU1gYIB6PU1xcTG1NLa2trTQ1NdLW2sqUyVOYPWs2sVjMWK/IarWSTCbp6ekhGo0a55tIJKTJxDEyTzXOVRE30kBFD4D0CrST9bqMZE3HkewDBp7TiQ6XcgVp2VWYo6V/QGM+p5MRmqmqmjGd/WgCPPOSG3qIeSyVqUdb5WleqkAIIXI5Weu7wak380mIU8Urr7yS8b3L5eKee+7hnnvuGfQx9fX1PPXUU8d87LhmxaZldrFWjWAplbXq4uCMztJZwaK527RKuhpSZWAloYoFqzZ0h+l8OtqKObu+HmNWZaSKgguN7pSD7bHKdGdvRaNHdTGjrJlu1cWL4VnM9TTwTPtcJnjaaY75aY4WcGnpVtpTXgotvQCs6ZvM651TWBA4gF1RSWhWmmIBQgkPXypbxfZ4JcXWnv71HDPX0FRRjLUlW1QfFbaQERwaIZtmyWhgkx0+9mo2Ci3RI12mTQGnXUkNOwV5PFCzz63/D/P74WjO80SsaTmqK+uWlhauu+46pk+fzoUXXsi6det49tlnufjii4ET/ynHeDdYt1NN03C5nPT09OByuaivr8/YNhBIh15FRUWUlZVRWFhoXIx3dnZSXV2NzWajurqa8vJyVDWFz+ejtLSUNWvWMG3aNIqLi/F4PHg8HvbvT3eKXr9+Pfv372fJkiWUlZWiaRpFRUUkEumpypqm0dXVhdvjNkIzf0EAj9vLwYMHaW/vpLGxiVCoi1SK/sepdHWFcTjslJaWsmHDBg4cOIDX6yEUChEKhYnHEiiKhWQyfeEbjyfTYWNLG+3tnbjdbpwOB06nky1bthKLJ/q7Udvw9zdo6e3rpbe3F7vdRjQWo7u7G7vdjqIo9PX14ff7cTjsRmDa29tLKBQiFosRifQY03bcbg+hUJh//vN1CguDzJ49h6KiIO3t7RQVFpJMJkHTiMcTaEBzUxNOV3odSbfbTVdXF9OmTWPmzJmEw2EOHDhAT096/9u3b2fjxo14vV78fj89PT2jXrPuZJswYUJGsKd/rVixAoBoNMqKFSsoLi7G5/NxzTXXGBcVugMHDnDFFVfg8XgoKyvjm9/8Zvp5PQrmtQ0tFosxdXek4U2ukFJ/TbIr9MwVdrmeg2MJCYeaXj3UMbKrBLMfA0eq6kZSvTjcfSOtAtW3M09h118Xu92OzWY7pmA3ez3L48W8DqV+XD2kM69NeTTvgeyKd/O+T3Tl43irtnY6ndx2223j4gNLGevxMV7GOl7GORL6+m4bNmwwvhYtWsS1115r/F1mPgkhTiSrciRg1Cv5RhLIWZUU8f7p1Pr06uxAUZ9urQ4Slxw53pGu2LmmN5sDnVyVkObqRXMV22DbZ2+rjzN724RmNdaB1LfPno6dPn/VCFATmo0Cax/fmvwMPmsUi6JRYI2yvzfI6+Gp2Cwq09xNfLZ0NdMLmlFRaE/6sKLRGXfTGC/EbU3QFAuwL1pCLGUnlPDQlXAR0RyU2sIZYzVXLtr7K08TmpUEVootvRnVkUeqNDN/19anXuvdsTMCOEUbcoq1uYpyOOZt7Ax8nYfaPvt2O6lhqy718FBfi3HAFGrTc5cwVbOqI6heNE/P1sdvPqfjZVQVj7/97W+HvP9Efspxqhhsmq3P56OgoIB4PG5cYEM6RNDXftSr+Zqbm/F6vfT09NDZ2Ul9fT21tbWoqkphYSE2m41169YTj8fZu2cfoVCI6uoagsEgkUg3bW1tFBYWEggEWLBgAZWVlYTD3djtDhwOB5FIhM7OTmM9wmhflFRKo7MzRGtrG7FYnIMHD2O1WgkEigCFstIy9u7dh9frpaKikmi0D7vdTjKZpLW1hYKCAgoLC5k4cSLBYCHvvvsORcEi7HYnfX1R+vqidHaGmDw5wKZNm+mLRlFQiPREiPb1YbXZcLpcNLe04HG58Hq9eNweLBYrkEivw9jZQXFxMYqSrn502B1E4n04HA4URcHhsONw2KmtncDSpWezbfsWtm3bisft5a231vPyy6v44Acvo6HhIB3t7XR0dqAoGiWlpTQ0HCQei9HU1MS6detwOp1Eo32kUin8fj/V1dV4vV5aWlro7Oykry993/z586mtrSUcDtPW1kZtbe24muK4bt26jMqozZs3c/HFF/Oxj30MgK997Wv84x//4NFHHyUQCLBy5UquvvpqXn/9dSBdHXHFFVdQUVHB6tWraWxs5LrrrsNut3PHHXeMejzmird8VvTp1ZPHu1Iwu+r5WCsdYfC1Es0VocebObDTj2uxWIwPA452n2bmMDVXh+hjlauCUT9Wdlh9LMGd/nhz1WN21e1g60aORvb5mNemNAfu44HT6eT73//+yR7GiMhYj4/xMtbxMs6RGIvruwkhTm/6VGq9WQykqx2zOfrDNX2tPtUU1NhN21n7u2Prt6lYiKbsOBQVc5ajd7JOP0aDYUKb7DUVh2s+o2+vB4Xm7c3rDeqNZfTp0oAx1Vvv2py93qPOYprCnD5eilJbmEJrL0FrDxW2LiZXthC09vAB31YKLHEj4AK4uugtNkTrqbN3APCZijWUWsNEfE6K+9diBEj50lOovUqcAkvU9JwdoTd7iWq29HRrSyTjOckOGwdjboKT67nNR7VjSlNIKP2VtiNYV/REVVmOZp1Ts5SmpDuVj7Wp1mJww61NNtw22dsGg8V4PG6Ki4uxWCzE43HjYtfpdFJXV0dhYSG9vb00NzdTXV1NJBKhpKSEQCBgNGcpLi5myZIlNDW1EA6H6euNUlJSQiTSzZo1azjnnLM5ePAgHo+HWbNmYbFY6O7uxmq1kUwm6evro6amhsbGRtrb26mqqiIWj7F582ZKS8pYv/5tXC43iUQSq8VGRXkl+/c3sHfvXiA97oqKChwOB3a7nWAwaFQhxuNxJkyoZ9asmRw6dIjGxkPE4ulO2Xa7nT179tDe3o6qquzdt4+ucLg/lElXT3ncHuL9i427XW4cDgddXSGSySRBp5N4PD392uVy47A7CBQW0tcXM0LahoYGLBaF6dOnM3fuXPbu3U0o1EV5eTkHDzbw2//6b3w+H/PnLyDWPz0aTcPjdnP4cCOhrh7mnrGA+rrtvLf7PXq6e7jggg+wYsUKtm3bRn19vbFouqqq2Gw2VFWlra2NpqYmgsEgTqdzXE21Li0tzfj+rrvuYvLkySxbtoyuri5++9vf8vDDD3PBBRcA8MADDzBz5kzWrFnD2WefzXPPPcfWrVt54YUXKC8vZ/78+fzwhz/k29/+Nt///veNqekjpYcneiMZcwh0tI02dPp6gkN1iM6X7NAxH+Fgrp87erg1mgY6o/35lV0VCmR0Fz/aoG6whi16sHk8wsds5unQxyPANVdO6ud0PN4P5srK4/3eFkKcPn72s59hsVi45ppriMViXHrppfz617827tdnPt14440sXboUr9fL8uXLT9uZT0KIE8MIG/sby8CRtR0Bo2pRxZKzKjD3Po80mdGnFeth39FOuzYHR9lh5WDb6tPEB3S+zlqbMtdj9WNZ0XAoCWrt7RmBZ6m1m4Rm7Q8409vF+6s7vUqCs9x7cJDComhMUNqJaHbKrD3EOdK8ByVFsdKbcfzsYExf49GipChQosaajNnM06zT56Zk3DcWmF/DEzX93lzVaRlFI5z0+yT9PJ6IqdYSPB6jkU47HOx7cxVSKpUypqUWFweNaaM9PT3E43E0TSMWi7Fx40ZUVeXcc88llUoxZcoUNE3jvffew2KxUFJSQkFBAXa7nZKSEhTFwqWXXsqrr75KX2+UvXv2UlVdwfbt26ipqSLcH+hZrVbsdjvt7e309PQSDAaJRqMUFxdTVFTEjh07sNlsTJg4CZ83PcW5vLyCu+++m2RSpThYQmNjM83NLVitVmOdyoaGBsrLy5kzZ066YjIapaWlhXfffZdt27YDCqmURjKZIpFI9q8FuYWamhq2bt1KSk3RGQrRF4tSUVFBeXk5naFOOjo7SCVVPC4XLr+TgoKC/ucqXYnY0xPmjTfeYOLESTjsTspKy0nEk3R1pcu8m5qa0DSNp576B//852s4nU5KS8tIpTRKSsrQtBQPPvA73nf+XqZNnYzf56U73EV7SyutrS0c3rSFgsIgkydPxuF04PV6uOGGG1i4cCENDQ1s3bqVzs5OioqKjIv9jo4OEokEVVVVlJSUDJjKOZ7E43F+//vfc/PNN6MoCuvXryeRSHDRRRcZ28yYMYO6ujreeOMNzj77bN544w3mzp2b0dXy0ksv5cYbb2TLli0sWLAg57EG62hps9mw2WxDPocjDSIHqxTU1+cEMqqPj+U1G6zSMZ9yrfenP0968GSucsvHe9A8ZdxcRZfPc8sVXOq3ZVd0DvWeyDVFfTB64JhrbcrRhqjZz1Gu8erPnbnhTD7eb4qiGIGjftuJCGyFEKemk7m+mxDi9JaucMw9W0Offp3CAlq6CQ2Y1m/MmCp7pHrRXDkI6VDPpaQyplMbx++/zYqaniKcta98yw5DVRQs9E8XVlRUzWbcBqapycPs16gCRcGuqMbjEpoV+qsnHaQGBFNxLLj6A8lof+Cqr9uYEYByJFjUHxM3dRVPH8tiTHlW+xue6I83H2ewykc9dMwV9I00/BvpdhZFy3jOcu0jnyGeeUp2ru7a5mNaGPg8DDcWOymjgvN4k+AxD3KtfWa+yM81JU+/6Nebi+i3d3R08Pjjj9PbG6G+vo5PfvKT9Pb2UlhYiN1uZ/PmzWzdupVwOEwymaS+vp5YLEFLSwtvv/02yWSSjo4OzjrrLEpLS3E6nZSXl6EoFjZs2MDBg4dobW2mta2ZM89cyPz585kyZQrvvPOO0Qhm9+7d+P1FTJ8+jalTp9Lb20skEmHnzp20tLTQ2NiM2t+Mpa6unmnTpvPSiy/zzjsbcTnd/QFeOeFwF1ZrOizt6OjghRde4ODBgxmdaTs7O0kmkzQ1NWGz2fBYvDgLnXSFuumNvEcsFsXpdOJ0uCguLUNRNDw+L33RPnp6erDbbMZ6k+lpgxYK/AX09vVRXFyMy+Wmra2Vzo4Q8+alz/W99/ZgsXSRSMSIxxN0dnbS29tLcXExDocDl8tNcbCESG8PHo+bnu4IBw40UFZaTKS7iz3v7aa+fgIlpRW88847+HwFFBQUsHjxYmbPnoWiKNTV1VFZWUlTUxNNTU3Y7XZUVaW0tJTS0lJs/ePWn4vx6PHHHycUCnH99dcD6SDX4XBkLCoPUF5eTlNTk7GNOXTU79fvG8ydd97JD37wgwG3Z09LzsdzmWsdRT0EOtYKtFwfQujTbPU/j2WsI31MduWh+efVcGMeqmIx1zqY+u0jCQRzHW+wczBvm13NN9wxRlvpmb3OY64xjNRIj62/H1RVPapq2FxTxHP9HyWEEEIIMV55lJgRLEI6bNSrzSz9U6ePrGeYzOh0rTcsSfU3jTkyFTszgExXhWVWFToUFSvpqkK9AY05jNSnQeeaYp09fTpjPFmyt7MoKSNwzA6/0o1u0kGkuTpRr2DUg8VcoZm+Xcp0HAY5DoCDVMb6iwktHbkm+h9rDh/NQWJCs+AwxaHpqrsj+zJX76U0JeM4gzHGMUjVox7IZU8nHqpRz1CBnfm+7DDQvM/BplkPNq05ez8jaRhjfkyiv9I0+3xzNeNJaVkdrkc4nf1YSJlDnpgbKehrw+l/N29jvtCLx+O0tbURDoeJxWL09fVRW1vLpEmT8Hg8/c1UttDX10dDQwMNDQ14vV4+9rGP8cUvfpEZM2bw3nvv8c47b+N0OvnMZz7DJZdcQnV1NdFolFAoREtLi9HE5LLLLuPKq67krLMWEwgEiEQiuFwuzjnnHD70oQ/h8XgoLCxk/vz5zJkzh4ICf//UbgeqmuD666/n0ksvY8LESaiqRjjczRNPPEkikaC8vIKy0nLsdgcWS7pS0+crwOVyE4vFiEajpFIpSktLCQQC+Hw+FCXdpXvatGnMnTuXRCJJb28fiYRKcXEJdXX1OBwuIB0m+v1+EgmVzo5OvF4vhYEAGmC324lGo3R2dqJpUFpSalQUulxuCgsLqa6poaenh+LiUhwOh7GGZjpodOFyuejri+L1FhCNxgmFwkT7YrS3txOPJ/D7A9TW1DBz1izmzJlDZWUFc+bOZUJ9Pb29fezevRtN0+jTp2STrsarq6tj3rx5xnTuysrKjCqw49kY43j77W9/y+WXX05VVdVxP9Ytt9xCV1eX8dXQ0HDcj2lmbiQymiYrgzEHQcerM7M5YMwVppqn2I70XIYLDIfqzJzvxjWDjc9c/ZiPYC1XkHos+8o1pqFeK32a+rEcy9woycxut4+rtR1199xzDxMmTMDlcrFkyZIBXXJPhFdffZV/+Zd/oaqqCkVRePzxxzPu1zSNW2+9lcrKStxuNxdddBG7du3K2Kajo4Nrr70Wv99PYWEhX/jCF+jp6cnrOO+8807OOussCgoKKCsr48orr2THjh0Z25zopmCDuffee5k3b57RPGTp0qU8/fTTY26c2e666y4UReGmm24a82MVQohTiUNRjerGjLUP05OmjenUdiWJXUmmpxFnxR9HugRbBgQ/5vv0Y+SSa41Gc2Cor7uo0xvC5HrscFKaxRirfowj48usTExPg8489mDHS2hW4qS/9H1nPyfZ5zhYgDmYXI1cTsQU3xPNagr+hmsicyKYG9GYb7MrqYyv4z6O436E04B+AW+z2bDb7RlfekMW/Uu/gNRDDIvFQjKZzNjHhz70Ic4//3xqa2tJJBJ0d3cblS96WOdwOKioqGDBggUUFPgpLy83QoyZM2f2B2ZxXC4XqZRGa2srra2tnL3kbObMmcPkyZM5dOgQL774ItFolOrqambPns2ZZ57JhAkTKSkppayslN27d+NyuQkEAlgsFioqKigoKKCxsZEDBw5w8OBBGg83UVhYRHV1DQUFfux2B729vaRSKWw2G263G4CioiJqa2txOp2UlJRQVFSE1+vFbrdz9tlL8fnSQWAymSQS6eXAgYOABYvFSigUpqurC6cz3UE6Go0SjcWMaYMOh4O+vj48Hg/hcBinMz31urS0FLfbQ011DW63m4KCAtxuNzab3Zimq6oqyWSC9vZ2mpubiUR6+9eCLKCvL8b+/fvp7Oyk4eBBQqEQRUVFhEJd9PX24vP5KCoqIhaLUVJSSkpNZUzHTCQSwJG1CPXu4OZmQfmYSnmi7d+/nxdeeIEvfvGLxm0VFRXE43FCoVDGts3NzVRUVBjbZF986d/r2+RyLB0tjzUwyhUKmYOyo5lqa3799WPkO4DMHuNgU4vN4eNw5zNYCGeuCsx1HscjWM1Vial/6T9fzeHjaKZX68GleR3EwWS/PwYLEQcbr3ls2a+BubpSPx9zc6fh6FPqzY/LDrzH2zTrP/3pT9x8883cdtttvP3225xxxhlceumlGV1yT4RIJMIZZ5wx6JTSn/zkJ/zyl7/kvvvuY+3atXi9Xi699FKipg+nrr32WrZs2cLzzz/Pk08+yauvvsoNN9yQ13GuWrWKFStWsGbNGp5//nkSiQSXXHIJkUjE2OZrX/saTzzxBI8++iirVq3i8OHDXH311cb9elOweDzO6tWreeihh3jwwQe59dZb8zrWmpoa7rrrLtavX89bb73FBRdcwEc+8hG2bNkypsZptm7dOu6//37mzZuXcftYHKsQQpxq9Pq87KmlKdJVjGpWcBbXcn/YqqLkvE9/vLkzdPbfsysOzfs0d57WO0zrHaRHG9plB4Hm8DG7Oi4dIlqMiseR0Dt0W/vXrcwOLPXQcLBKTX1cerVjeh/maetaxtepGDjC8ZlufSzMnbvNVagnoot1NkUbh3OtwuEwgUCArq6uUQUQx8tQ0w6zLy6z70+lUkbnalVVcTgcJBIJkskEu3fvZvLkydhs6bUXQV8zTUNRLMZFZWNjEz09PbS0tFBSUkI0GkXTNKO6LhaLkUyqRoXf+vVv8+KLLxCJdHPNNVezYMFCFEUxAqNoNEpvb4zCQj9tbW309PQwadIEmptbiUT66O6J8PzzL7Bv3z66QmHUlIa/wI/L5Wbv3r10dnbicDixWi34fD5sNjt79+5m+vTp1NXXs2vnThRFoaKikq6uMPv27aWqqorOzhA2m41EItE/tRX6+iLp50lLoaFRUFBAX18fFqtCdziMoijEozGqqqopKiyiqysEikb9hDq6u7vxer1Eo3EWLljI9u07cDgctLW109cXIR6PEY320d7eTiKZwO3y9IeldoqKinB7XPT2RtC0FIsWLcRf4MXn9TB37jw2b9zE3v0HsNps2O0Oyisq+PznPs+EiXVYh+hKbK6Y0+VaN+5kGM2/q+9///vcf//9NDQ0GI1durq6KC0t5Y9//CPXXHMNADt27GDGjBnGGo9PP/00H/rQh2hsbKSsrAyA3/zmN3zzm9+kpaVlxF0t9bGGQqGMsR7v5zC7ggwy1y8cyVRl/QOEfLzuucKsXPeNJHAbbJr0YNOazbcNNQV9sJ9/w401H6+l/jN2pEGoOaTM1b06l+HGOVR15ki2Md+XveZjdmiYaz/6hx/6/Xowm13pGA6HKSwsHDP/rw5myZIlnHXWWdx9991A+jmpra3lK1/5Ct/5zndOypgUReGxxx7jyiuvBNLPc1VVFV//+tf5xje+AaR/PpaXl/Pggw/yyU9+km3btjFr1izWrVvHokWLAHjmmWf44Ac/yMGDB49bJXlraytlZWWsWrWK888/3/i5/fDDD/PRj34UgO3btzNz5swBP7cPHz5sLI1x33338e1vf5vW1tZRNwUbjWAwyH/8x3/w0Y9+dMyNs6enh4ULF/LrX/+aH/3oR8yfP5+f//znY/45PRWMtesAIU4F4+XflT7ORzbMpKDgSBCX0ZilPxxzKGrGeo56taNeDZlN1SxGB2xzExozc1MX89Tp9H36VOuhQx1zdeZQQdVQU4CPdKPWBqz/mKuLdfb+sqcL57rd3GhnuOnIubpn5wogj2yvDJj6mx577m0Huy/7ePqUZHMYa6461KsQU6awVA/hUhkh8siuQ3K9lubHj6bBTK7XJHvsg43PfO6DTS3XH5eruVBPd4pz5jQe13//46vUYYwarNIle/25XPfbbDY8Hg8ulwuv12tUCHq9Purq6olEenG5PFit6eBRUSwoitX4u81mN6ZnV1ZW4nA4mDZtGgsXLqS6upqKigrq6+uZPHkSxcVBPB439fW1zJw5A7fbw86d76U7UltteDxeYrE4qprC4XAQiaTXlvR4PHR2dlJZWYnFYqEr1EVxcTG1tXXYbHZcThc9kW6isV6CxQG8PjcpLUGB30txcZDi4iIKC/0cOnyQHTu24XTZQUmxb98eDh48QDjcRXd3GIfDTjKZRFVVurq6cLkcVFVV4XQ6cbvc2Cw2ErEEXrcXvzeA3xegvLQcsNLR0UU8oWKxOrDbHcT6YtRU1eJyuCktLsFhd1BWWkpHexvJRJREPEq0r5clS87irLMWECwq4P3vP5f/9b8+xyc/eTVFRV48bju1NZVUV5WzdcsWmpqa6Qx1UVpWTml5BV6fF01LYbdbueTiC6mtrcJqsWRUfOmvs8V0u97IR/86HtVgx1MqleKBBx5g+fLlRugIEAgE+MIXvsDNN9/Myy+/zPr16/nc5z7H0qVLOfvsswG45JJLmDVrFp/97Gd59913efbZZ/nud7/LihUrRhw6DiUf06BHwhz66FVxI6FXnR3PsDnX+Q815To7bMy1RMRQx8hn5+V800M2GHw9yOz3zLGs5TmaStiRbmNm/jmif/CUvR/9Z2gqlTKq6c0V9g6Hw6i0Hm+fO8bjcdavX5/RwMpisXDRRRfxxhtvnMSRZdq7dy9NTU0Z4wwEAixZssQY5xtvvEFhYaEROgJcdNFFWCwW1q5de9zG1tXVBaQDPWDYpmD6WHM1BQuHw0Y1Yr6pqsojjzxCJBJh6dKlY3KcK1as4IorrsgYE4zd51QIIU41RvWhNjCATGEhrllJYDUqIC1GwNRfDdn/ZX7cgGnTWdvpUqZqyOwqQNU0/fvIfi3G7UeqHo/s48j3loz7cp1vrnHCwCndOisaDlJkV73lej71ysrsINFc1ZjrsXZFxUHK+Mq1jblBzPHoQp3diMU4LorxpX+fr4rEXNPzB7vtaKanZ499MINN6c513KMZRz5Ic5kxSlEUAoEABw8eNC6CB5sSp2lautv0hAm0tLQY3aSz6Res1dXVnHnmmVRXV7N161ZisRgejwe3292/1mQUVU3R3R0BNIqKCgmHwzQ3NzN//nwmTZpMPJFuaFM/YQLbt6f3oapJqqurcTgcHD58mO7uMD6fj2CwiLLyMgoKCujs7GTPnj24XC58vgJ6e3upqKigr6+PkpIyvF4LBw4coKampj98dFFWVsbhw4dxOBwZgUgk0ovFovR3/FZob+/AYlGoq6vG5XJSWVnBwYMH8Xg8FBUFsFggmYyjKAq9vRGCwSB19TWce+7ZNDYupqamhtLSUhYsWEAikWDPnj1s27aNd955B1VVqa+vZ+LEiXg8HopLiikpKUFVVerq6ggGg8a0evPUzLEYxhyrF154gQMHDvD5z39+wH0/+9nPsFgsXHPNNcRiMS699FJ+/etfG/dbrVaefPJJbrzxRpYuXYrX62X58uXcfvvteRnb0VbLjXQKbnYFmv7vLHutzuzt4MSEjrqjfR70kEqfmqv/3MlVkWiuCjQ/fiyEWbleJz1QHOznqDl01QO+kcieij3ccz+S91quyujs+/V9ZR9fr543019LvZnVeP251NbWhqqqORtUbd++/SSNaiC9UVaucZobbelV3zqbzUYwGByy0daxSKVS3HTTTZx77rnMmTPHGMfxagp2NDZt2sTSpUuJRqP4fD4ee+wxZs2axYYNG8bUOB955BHefvtt1q1bN+C+sfacCiHE6UYPFlEADaxZlY+5qChYlVRGpeORZjNDr/GYe38WzD2lzVWQKpYjYeUx/kqWsxlOFqsy8mV6zFWUetOYDP1hZO7g0zQGLcdt/U5EI5NcBusIPVyoJ/JDgscxJNdFZlFRkXEhbJ4alz19Ub+Y9Pl8g15c69s4HA6CwSB2u536+nqCwWB/GNdLIBDAbrcTCoUJBPzGelR+f4DDhw/T3NxIbW0d55yzlEgkQltbO93dXbS1tREKdZJIxHG5nJSXl7N582bi8TixWJTa2lo6Ozvx+/1UV1ejaRo11TWUlpTR2tpKKpWipaWZ4uISY71Gp9NJZ2cnTqeToqIiuru701Or4/H+5yA9LdxisRCPxygtLcVut2KzWrHZbHi9HjQtRTgcJhKJUFlZyYwZ06msrGTTpo243S66wl1Gd2m9wqmsrAyr1YrT6eTw4cNMnjyZkpIS/H4/ixYtwmKxMGfOHA4cOGCsqTl9+vQBzUfG68X9cC655JJBAxGXy8U999wz6LpnAPX19Tz11FPHa3gn5HnPPoY56MoOvcwB3clcTy9XKDjY1Gg9bNSn9mZPy9VvH8k5Ha8gcrQhp36u5g7RuaYxZ1eq53tcQ01HH+1xsj/oyK5WNa/faa5OFqenFStWsHnzZv75z3+e7KEMavr06WzYsIGuri7+8pe/sHz5clatWnWyh5WhoaGBr371qzz//PO4XK6TPRwhhDjtWbMq86IpO3ZFTTeVoX+Na1O1YWY1nMUIyaxZaxpCuuLxyGNzV/INGE9/yJjQbKgo2E3Bn5UUDlRUJZURQA42PXo4R9aVHDjN2Vh3cZhuyGb6WM0drkf62IxjjqCiMfu1ON7M07tTmoJVSU9P1rtBjxVjaSz5JFciY5imaUb1YnaYlR1s6BeYPp/PuG2oi9nS0nR3Z70hjh5IAni9PsLhbny+AuLxOOFwNyUlJQQCAcLhMKqqMmFCHUuWnMVbb73Nnj278Xq9qGq6G6PVakVVk0yePInu7h6qq6szKqiKiooIh8N0dHZS4PMb+00mU7S3t2OxWIwKR6/XSygUorS0lGg0aoR7oVCov8rSht/vJxZL4HQ6sNksRGMxHA4b7e1tVFZWsnfvPiZNmkQsFmPy5MnU1dWgWKCqqgKr1UZPT5jOzk7KysooKioC0hVCxcXFzJkzh2Qyicfj4fDhwwBGk5qFCxeyZ88e2traBnQHPlVDx7HuZISOuSpcc/37PB5VsEe77uBQ25vXptWDreypx0OdU3Y13kjGNpL1DnNtm+v5Hoq5etP8b9Vc6ZiPaeMjeXy+toEjFbf6z1jzOaXXBx7d/saqkpISrFZrzgZVQzWnOtH0sTQ3N1NZWWncrs8a0LfJboiTTCbp6Og4LueycuVKo4FNTU1Nxlj1pmDmCr3spmDZncNH0hTsaDgcDqZMmQLAmWeeybp16/jFL37BJz7xiTEzzvXr19PS0sLChQuN21RV5dVXX+Xuu+/m2WefHTNjFUKI04lenaiHeAnN1h8upSdbJ7D2r4V3ZMq1/qeF1IB1HdNVfwrmHMhYF1BRYUAnbIvRnEXvDq03bTGv/RjV7Mb+9bUijzaA1PeZHVZZlBSYu17nCFWPVF0emYZtjFlRjWpH83qW2cfKXnMyoVmwG9WS+jllj63/e234gFIPC82hpnkcGetMZk1xzh5ndrOb7CnRuabbD7e2ZfYaj7n+nj3mXOMb7Fi5DFa5qTOv85h9TnZSJ63CU9Z4HKOyp8UNVYVjrt4ZbC03IGNfVquVQCCAy+UyLlLdbjdWq5VkMkFhYQC320V5eTmxWIyWlhZ8Ph8TJkzA4UwHllOmTCEYLGLSpImcf/55LFgwn4MHG2hsPIzdbqeiogKPx83hw4fo7OykoKCAVCpFX18fdrudaDRKV1cXPp+PWCyG05lurBMMBqmpqSGRSJi6XEeMKdl2ux2Px0NBQQGVlRVUVlZit6eb0kQiEbrDYVwuFy2tzex6byfTpk/hgguWsWTJImprqygKFnLeeecwefJkJk2awNy5czn33HOZMWMGpaWlRrdrm83G3LlzueSSS5gyZQrz5s2joKDAqAqtqqpi0aJFXHLJJUY1kfm5H+8X+eNRdmB2vNd8zJ42q79Xe3t7icViA4Lo4/WeGMl5jvY5MK95mEwmjbUDc1UFmo+dvW6kWa7HjKQKc7QGO1f99r6+Pvr6+ohGoySTRz4wOdqK1MGe++Fej+znbLTvV/0DHfNro+/PXI06VtfgHC2Hw8GZZ57Jiy++aNyWSqV48cUXWbp06UkcWaaJEydSUVGRMc5wOMzatWuNcS5dupRQKMT69euNbV566SVSqRRLlizJ21g0TWPlypU89thjvPTSS0ycODHj/jPPPBO73Z4x1h07dnDgwIGMsW7atCkjKH3++efx+/3MmjUrb2PNJZVKEYvFxtQ4L7zwQjZt2sSGDRuMr0WLFnHttdcafx8rYxVCiNONVUnhMFUY6l2uYehgR18HMuNx5mnX/dOwVXOYN4ioZsdKCpeSwK4kM9ZVtKJhV9K/eyY0q7GW4mDrM+pjGc16fPo0afP+zGs3Djj3Qc7F/PjhAtFczXJyNY/JRV/7Uf86Eozqa2geCc2Geg2PZi3DkT6v2fsxr1c51H7N5zXceIe6f7TrMg4WLmbfPtjakMeDVDyOIbku0kd6ITySbc3hmP69fpteCeR0Oo0Kv56eHux2O+Xl5TgcDoqKinA6nVgUBRSFggIfCxbMp6npMC0tLcTjUebOnUNzczPRaIzu7m5cLheplEZRURGJRIKysjIjhIxEemluasHj8VBeXo7T6WL//gMcOnSIiRMnUl9fj9Vq7d82QlVVFclkku7ublKpFIFAgGAwiNvtRVVV2tpaqa6uoqKilJkzp7N33x6i0T72799HS2sz8+bNQ3+Ks6um9OfOXBGlh1cVFRUsXLiQpqYmnE4nVVVVxONxuru7jSnZ5qrTU+EC/3STr7BLD7HsdjvxeBy73W5MUx4r74uRTlHO/jAj+77R7Ge0xz/ais2RTHHWwzr9Qw1VVTOmIY+V12kkzA1ksitQzY1oBptmPxbW4xytm2++meXLl7No0SIWL17Mz3/+cyKRCJ/73OdO6Dh6enp47733jO/37t3Lhg0b0msH19Vx00038aMf/YipU6cyceJEvve971FVVWV0vp45cyaXXXYZX/rSl7jvvvtIJBKsXLmST37yk3ntaL1ixQoefvhh/v73v1NQUGCsHxgIBHC73RlNwYLBIH6/n6985SuDNgX7yU9+QlNTU16bguluueUWLr/8curq6uju7ubhhx/mlVde4dlnnx1T4ywoKDDWyNR5vV5jlgQwZsYqhBCno3SwZzMqG82Thi2kMrpbp4aowxrQQVpf3zCrgjBbrk7Q6arHgVVu6ZBw8H0dbQMQ4zhZHa+Pp+ypzJCuLMwO3fTv1axqUl0iq7oyjgVVU4xKyhPJHCDqVZLDhahj2XDVnMeTBI+nuewLTz18tFgsuFwukskkFRUV2O124+K8v6YGxQJ1dXVccOEFvPjiC4S7u6guqWTSpIm0traRSCRoampGUay0t7fjdDqZPXs2+/btI5FI4PP5SAST9PT0UFxcTCqlMWnSJEKhEH19fZSXl9PY2IjD4UDTNEKhEFVVVezevZvW1lamT59GYWGAUChMMBhk//79zJkzm4qKUtweNxaLhc9//nN0dnbicjkBjVRKGxA6Zsu1Xl9FRQXl5eXGlEaHw0FtbS2pVMqoGhWnlqEq8QYLbPTGHuZpu9mPOdnvlaEq83JVJGYHj0OFfEcbZI3mcdljPdrHjoV1N81jOhr6c6A3z9Hp69Ye6/7Hok984hO0trZy66230tTUxPz583nmmWcGNOo43t566y0+8IEPGN/ffPPNACxfvpwHH3yQb33rW0QiEW644QZCoRDnnXcezzzzTMaagH/4wx9YuXIlF154odGU65e//GVex3nvvfcC8P73vz/j9gceeIDrr78eOPlNwXQtLS1cd911NDY2EggEmDdvHs8++ywXX3zxmBrnSIynsQohxKnkSMWd6fei/qnU2QGkVUkZwZe563Wu/WVMo80xbdnMgUocK3CkQY25EjChpa+p7YpqTM02y1U9OPh56gHfkYAxpVlQlYHjNu/fHEQe7fqSg9ErFe0j3G/2dOuEZumv2Ozvwp2nX2XNr0X2azLUtOfs588crubqYJ1rH4ONZzRjH4xetTjWm+Qo2ji8KgmHwwQCAbq6uvD7/Sd7OOPaYC+/XkWjqip2uz1zjTfzGm5oaCmNw42HeeaZZ0gkEkydOpX9+xrYtGkTXV1h7HYHXV1hCgsL8fv9pFIp2tra0utFJjUOHDhAdXU1Pl8BGzduoqamhlgsRiqVoqSkhEOHDqFpGn19fUycOJFYLMahQ4dYsGAB0WgvsVgCgI0bN1JbW01NTRVnLVrAR678F+rr641u05A5FVf/frjnRV/jTn8OzFPg9em15sqikx0sHa3x9O9KH2soFMoY61Dh4Ghfl9EEj+bGJObq11yB3vF4f+T7x/hw6zMeyznkq9Iuey3Jof4tm9eqzBU0mqs7xwNN01BVNWPqO2AsozFYpapZ9usQDqd/Ro+Hf/9CiNPbePp9RYjxYrz8u9LH+ciGmXgKrAPuHyygyRkq9lfQxTXrgOBRn1ptNVXZmQPB0YR1VlJG0xZzl2gVCw4GdpwebfCYc31HMkPHXBWP2R2sc43B/NjRnbM24mAtO3g0Vw3mWgNyqOcle5vBtkv1V1Ba0EYU2GW89v0NaUZS3Rg3VdS6FHVA6DmSY5qPC5kBowUNq6KhagqpUU7JN4+hpzvFOXMaj+u/f6l4PM3lCgH0i1Z9zTNz2JZ+kL5dCkVJl5qXlBQzbdpU+vqilJaWUl8/gcLCQjo7O/jnP1czdepUUikVl8tNR0cHpaWlhEJd2GxWSktL2L9/PzNnzsLj8WC32+np6cHr9ZJIJHC5XITDYbxeD++9twuv14fP5yMS6cFms9LX14fP52P27FlopKivr2fmrFlMmTI5PT4GBiZHM5XTPGUxexrqya6aEmn5XONwJI83r8mXa6q9+b6jqdA7UXIFqeb3tHns5vuOJqjL1/mPZD/mdSqzu1mbw0jI7AA9lgNIfXq1zhwwjuR9Npbfh0IIIYQQY4FqCuoGVrxld5DO/F7NMX1bD+/MTWZy7TtzP0f3+6i5aUx2aJhRAdl/X0KzgjIwANXluyLyRDCHe7mCSn3adD47a+cKUAdrMnM6kuBRDJBd1QeDVG6hYEEhpVjwuNwsWbwEVU2haSncLjeTJ06ip6cHl8vNlMlTKCws5I033iDaFyGVSlFdVUGkJ4LNZqGzs52W5kZKioO43U7QAgAcPtRARWUlbW3NoCWxWRUS8V5sHjeHD++nrKyUYNCHx+OlunoadoeNiRMmUFISRE9I9WmIxxKWKIqSsQ6c+TmRtR1PP9lNQQaraDQ3ucm+bywaSWMT87TeoZpejRXZ4W92QyD9Z91YD+L0MZqra/XzMa/nCEfed6qqjrk1RoUQQgghxoMUlgHTfB3906PhSMCYK2jMJU66mYx5qrb+2OzO19mB1XABliVrLcf0+omW/inPatZ6k0fWf0yZmuUMDFQH/m48nkK0hGY5Ml07i53UkapFJT/rHQ7WQEakSfAoBr0gHW56qNWSvqC1Kuk/PW6PUVmkaRo2m5VAwM/HP3YNdru9f121JF6vC7vdTktLK2+//Q4dnW1UV1USifRSVZVuMtPZGaKrqxOHw0bDgX2UlhTT1tZKcXGQyVMm4XI5iEQiKIrCtGnT6eoKMWFCNUuXLqWsrIyWlhZUVc2YAn20z8lgj5UL+pPvZAZG5uA5e2q+mTl8zGdl7PGoXBtsjNlhXfZalmPBUBWpuX4GDPY6jeWmK+bKTZ3NZhswtV+nv04jqcoeq+cshBBCCJHN3GFaZ81RmZdd0aZPoTbfD+mp2A5FTVfBaekVIc3rFOqPiWvWAd2izcfIvs88Lqu+rqTpfr25jDnE1BvRGGPOCg2zK/XSY7Ya91uUlFHNaEVLr/sIxnRv/bFWtHTzGWMcmeHmYGsfHk2YZp5yPJpp2LkMdnxzQxsAu5IatBO0Pl3ZXKU42LTr7OdkqE7Q2c109HPVjzNYhWX2NGpL/9Rqffq0aro9l8GmWY90SveJCEgleBR5pV/gmi9izRfF06dPY+LECfT29rJ//wEikV4qKiroDvewZctWuru7AXC5HEAAu91OQ8MBkskEV155JXPnzaG2tpqOjnZ6enpIJBL93aoVOjo68Pv9lJSUUFxcjN1uHzeVZuLo/O1vf8Pr9Q64fSTdjYeaijrY+o6DrXs4kvUkj6YpykjWIM3Xe/t47PN4yDXOoxl7PqZUD/daDta0J/vxwzFX2GbvI7vqdKjlM4YSiURGNBYhhBBCiLFA70itr8WYDgFTwzZ/0WUHl9ns/esv6gGdHkimcgSXeqCU6z4LloyVHPWGMglju8xxqBkhXf8sI1NAiLmqMYfBOlib13u09oesw3W7zg5A9eAxV4XkUI8dymg7QY90+6hmNQXCg69haWYO+0Yr+xgWJd0YR6+6HG6f1v7Q0hxuWrLWhMwZjGqZYejRjP1EdOOW4FEcF+bpx/pakXo1ldVqxeFwUFZWyvLly3G5XESjUf7+9yf4n7//D319fZSVlRGJRIjFohQVFZFMJvH7/dTV1bJw4XwAtm/fztatWzl06BCXXHKJsW+r1ZrRDEbCx1PXL3/5S6PyNF+GqngzV1gOVUF2rI1thjPcOI72ePpU3rHaKGmw12W0Yx7J6zhcQDhUNWX2PvT7zZ2n9duHWs4i11iyH5td9TuSxjL6OMzbmdeNFEIIcfyN1Urz4/l//1CN68wfrmWPYaT/Nx7N7/xj7XcdMTJ6M5js8NH893RDjpSxPQxcj9HMHNjYlWRGdWGu7cxBXEbX6wFVgrnWgExhV5IjnqZtnPcwQWEuuaowzaGjPi2brOnax7K2Y/Zzlq91FE+G7LGn9CBQGT6wG2yq93ASWLD3v2/spvdPdvCY3WgmRWYl7FgiwaPIu+z/wPU14fRqSLvdjt1uJxaLoapJnE4Hbrebyy+7jP379rN3715isSjBYJD6+jpAo72jjcIiv9Ft22q14vV6KS0txeFwYLFYjO7V5qmI2b+AyC8Xp5bBQpfsv5sNN5V2pBcCo7lgOB4XF/meaj1cdd5YMFQAN9j9w+1nNE1qch17qPuH2/dQF03D7WOwYHQ0z0X2WqVCCCHGlpEEadn/H+RaNmSkH5Dptx3v8HG48eQ6p+xx6tvpv/eP5ANB877lmmD8M8LE/oAsu3N19vcqCvYh9pddAamikNDScYldSaaPox3ZzqqYKiIZePuR/Rz9skR6SKmv15irGjKbxbR2IxyZDm5XVOyKSkKzZoaOmMJH0+OHqmrMdXt2Vd9gjz9RIaSrv6pzNIbrcJ2rs7TxWE0ZUPVozapczN6XeT/qECGm3rk613TwjKn+/R23x2LQK8GjyKvBpp3qVWnmXwjSnakjRCIRfD4fFZXlXH3NVTz65z/j9XopKSmhqrqaYDDIhg3vYLFYmDZtKk6nE0VRcDqdFBcXU1lZmbHOWa4xiVOTueoLjkw7nTBhAmeccQZWq5WtW7eyY8cOI7TO1exlpL/Q69uaf7k13zae32vjYewjWY/2WPaTbyOp2BjtPvIh17jGw+svhBCng+wAzRyu5ZL9O0iu322G+zD2RPwOY/79a6QfDo9kTLnOf7BANfv3RTF+pUPFzFlPCc2GVUlhoX8dx/6X2BwMJvrjD3O1pM6uJI3wMKHZhu14HNesRmWlMY2Z/unepmPaTQ1pdHqAmNCsGdWauY6XwoLavxZkZkdsfT3IzE7ZuaoizVVw5mBysPMzh48GJXPtSQeZayiap3Lr+8iuvhvJlOOMbbXMx2WPN9damHoVYso0Ln2dRSsaUc2K3TQ2GHx9x+zxZNODRn2KtKopGeMwj8Ge4/kY6j1mDhBT2tBrS2Y/p3pjnaGC0hNNgkeRd0N9imn+JcrpdGKz2YhEeonFYni9XmbPnknwyzeQSCRoaWlF0zQqKsp5//uX0d3djcfjNvZTXl5OMBjE6XRm/DJm/rv8UnFqM/+yrE/lv+qqq/j85z9PQUEBqqoSj8d5/PHH+e///m/6+voAKCkpobKyks2bN2fsKxdFUSgrK6O7u5u+vr6MX1pnzZpFa2srra2tGfvQq3v1RkunQjB5OsiuEhlqGvRwa3Zmv+ZDvQ/M+8rebrAqz+zHDHXc7HHKEhRCCDF2xGIxWltbURSF0tJSrFYrhw8fxu12U1RUhKqqHDp0iOLiYrxeL+3t7SQSCUpKSlAUhdbWVsrLy7HZbMTjcZqbm/H5fAQCAcLhMKqqUlRUhKIohMNhOjo6KCsrw+l00tzcTDAYxOVyGeM5nv8vbN++Hb/fT1VV1aDbqKpKKBQiGAyOaDyJRILu7m6CwSAdHR0UFBRgt9sHBLU9PT1s2bKFJUuWHPuJiDFBr2jUG8ZYlNSABjN2VON+lzJ0RaQVzVj7EA1UrEbTGSAjXIQj07EtSvqWdDiWGjKs1ENCBypx9EatR0JHc4Wgvhbk4MHXkW3timpUNmYHkUfCK8uAakggo7HM0Uzl1vd9JOAb2KjmyPkrg96nH9ulJPurTdONfBwMHsqOpLLPvM2RtTgVjjWLy2xapGEnHfjpzKEk/felTMFjSn/OTc1n9O0HWxfS3HQmeywZ56YfV8k875NJgkdxwmRfIOvrMer3gYbVaqGurpZkMklRURGpVAqXy4nb7SaVShnTqQHcbjdut1sunIVh9uzZXH/99ezYsYM1a9awfft2pkyZwsKFC7nooot46qmncDgcTJ8+nbPOOotdu3ahaRrJZBKn04mqqiQSCVwuF6lUimQyicPhYMKECSiKgt/v56WXXsJms5FKpfjABz7Ahg0b6OjoyNjH2Wefjdvt5pVXXsFqtRKNRnG5XCSTSaPyUowtuTp161Um+s8pvUJC7xStM3+gYg7B9ftUVTX+rv/pdDqx2+1GQy39eOY/zXJV65q3M49Z/3v2cXM9TgghxMn17LPPoigKwWCQwsJCAP7f//t/vO997+Occ86hvb2dP/7xj3zwgx/E6/Xy2muvUVRUhNfrZf78+dxzzz1ce+21zJw5k+eee45UKkVraytXXnkl//znP2loaOAzn/kMDoeDxx57jKqqKl577TWuvvpq/uu//ovzzjuPZcuWZQR1vb29aJqW0cAvEonQ3t6O3+8nHA5jtVrx+/04HA6amppwOBwUFxfT0tICQHl5OXZ7emJrOBxG0zQOHz5MMpk0/n8tLS3FbrcbH+AGg0H27NnDqlWr+PSnP017ezsWiwW32008Hsfv92O322lpacHlchEIBNi+fTvr16/noosu4rnnnuOiiy7C5/MRDAbp6uoiEAjQ3NxMW1sbBw4c4IwzzqCxsRG3201FRQWKotDW1kZBQQEtLS1UVFQQDoeN/6vD4TB+v594PI7dbkdVVaxWK4lEArvdjtVqxePxnKB3i9AlNNuR8EXLXMNxQFVZfxiUHSDmone1hiPNZaKa3QgZ6Z9urbMryf7HpUM9vbu0Lnen7fT0aSup/nUCzRWCA6eHZ39/ZO3JIwGjOTDMNQU7ZwXjEMc5GkN1wDb/fdDGLvoanf1VlHromD19Obt7da77ct1vflxKUzLXZxzF6Vv7m8Zkr6+o73tAdWY65hjyOTZP07abnofBDNVMxp5VmQpjY43NcRk86hdN4XD4JI9EjFb2NAtN07Barf1/T/VfIKcv4m02K4piQ1VVent7+9eJ1NC0zCYS5gtxCXSOnv7vaTyFEtmv+bJly2hra+O73/0uZ5xxBmeddRYHDhzgscceo76+nilTpvDpT3+a8vJyEokE3/3ud1EUhddee41zzz2XcDjMm2++yQc+8AHi8TgbN27k/PPPJx6PAzB16lQcDgeLFy8mlUpRWFjIrFmzmDJlCmvXruXjH/843d3dlJSUUFFRwaxZsygpKWHbtm3MmTOH1atX8+STT0q12RijaRoTJkwwXufe3l7jYkIPiwFmzpyJqqrs37+flpYW5s6dS2NjIxMmTMBmS/93GolEUBSFvr4+ysvLsVgsNDQ04HK58Hg8bNq0ib6+PqMZlqZpOBwOAoEAVqvVuKBJpVL09fXhcrmoqKigtbUVi8VCLBbD4XAYF4Rer5e2tjbKy8s5dOgQdrudYDBIW1ubMfZoNGpczKZSKex2O6FQSDpZCyHESaZ/YLV3716mTJmCx+NBVVWCwSBLliwxPnCvr6/njDPOYPfu3casCqfTSTweZ8qUKezdu5fCwkIOHTrE8uXLef3119m9ezcA06ZNY+PGjUbjxjlz5rBz507i8TilpaUkk0n279/PpEmTAIhGo/zqV78ilUrx9a9/3fg/580336Szs5Pu7m5stvTv57W1taiqSjKZpKOjg4ULFxKLxTh48CA+n4/zzz8fRVHo7OzkzTffJJVKUVZWRmtrK4cPH8ZisRAMBmloaEBRFKqrq3E6nSQSCRKJBO3t7WzatIkZM2Zw6NAhnM4jxQjt7e3MnDmTWCxGIpEgGo3S29tLV1cX69at48Mf/jD/8z//w7Jly3jllVcoKSmhu7ubaDRKe3s77777LldeeSVFRUWsXbuWmpoannjiCT784Q+zefNmpk+fTigUYvfu3dTX19PZ2cnChQvZvHkzDoeDw4cPM3HiRCZMmMC0adNO5tvotKL/Dt3Xo2JXNKxKKj0tWkv/3a6oOJUEqpauDYuRDmZsqEQHWa8wO6hMapkBmY0EcdNjVU1Dw4JNUYkr6aAvYTxGHbA/uylQVNFDJvqrHiFluvZKh0YW0/bmQFEDNOP+hKb0h1QpokeeocwpxBmNZczTjgcGlmp/QmY1HpfKqJJMV3amq+0saPT1Hy+pWYGUsZ0+rVjfNqVZsCmpQaf7WvrHrAeCif7GQQDxHNWAquk1y3Wf/lyZKw7NfzcHc4OFmObwUJ+2bOy3/3UAMjpg20llVDSa3wfZVYyDBaTZ1ZnZY7KgpYNPjqwJaT6mnZSxHiRATH9uhklW+yKDFz/ky7gMHtvb2wGora09ySMR4tTT3d1NIBA42cMYNUVRTFWyLqZOncqHP/xhVq9ezX//939TXl7O2WefzZo1a4jFYtx66628/vrrNDQ08L73vY/f//73nHfeedx0003cdtttzJ07l3PPPReXy4XD4WDv3r2EQiFmzJjBc889h8fj4ZZbbuHHP/4xy5Yto7q6mr///e/Mnz+fSZMm8fbbb1NYWMh9993Hd7/7XZLJ5JCdsMXJ5ff7KSoqMoLA8vJympubKSsr49ChQ2zbtg2fz8fhw4fxer1GoDd58mSKi4uNSlZ9utvWrVs5ePAgtbW1WCwW/H4/mqZht9uJRCIZ4bPNZuMDH/gAqqri8XiMf4MbN27E4/FQWVnJrFmzCIfD2Gw2enp6CAaDJBIJVFWltLQUp9NJZWUlfX19+P1+SkpK8Pv9tLe309raSnFxMW63G4/HQyQSoampia1bt0r4LYQQJ5H+4fpVV11FTU0NkP6AKJFIGNtomkYslr587O7uxuVyoWmaMaW6vb2d0tJS1q5dazwulUqhqipNTU3U1NSwZ88eLBYLnZ2drF27ljPPPJOuri4aGxuZNWsWr776KrW1tcaHblOmTCGZTGbMTGptbeX8889n06ZN1NbW0tfXRzgcZvfu3XzqU59i+/bttLS0cM4551BdXc0TTzzBueeei9Vqpbq6mrKyMp588knmzZvHrFmzmDRpEn/+85/p7Oxk2bJlpFIp1qxZw0UXXcSWLVuIx+Ps2rWLoqIiZsyYQXFxMTt37iQajZJIJAiFQrS1tTFnzhz27NnD1KlTeffddykqKiIajRrFDe3t7UydOpUZM2bw4osvEgqF2LVrFzU1Nfh8PiwWCzU1Naxbt44ZM2awbt06JkyYQH19PRs2bMDn89HU1ITdbqeqqorXX38dh8NBYWEhe/fuZfHixSf4XXN602eK3Hj+5mG2FEKM1vHMAcZl8Kiv+XHgwIFxGZAcjXA4TG1tLQ0NDfj9/pM9nBPmdDzvk3XOmqbR3d095Lo7Y9327dupr68nGo3S0tLCM888Q3t7O11dXQBs2bKFj3zkIwA89thjnHXWWXR1dREMBvnEJz6Bw+HgmWee4ZprrsFut7Nr1y6WLFmCoih0dHSwePFi7HY7paWlxONx9u3bR0dHBzt27KCuro4rr7wSm83G+vXrmTt3Ln19fSxfvpz9+/dTWFhIXV2drPc4BimKwq5du4yumHp14pQpU3jttdcIhUL09vayfv16HA6H8X7at28fe/bsMSow4vE4qVSKVKr/U9p43Jiapq/X1d3dPeC17+vr48UXXzSm9uvTtxKJBFarlffeew+r1UpZWRkNDQ3YbDY0TUNVVQKBAHa7nebmZgBcLheJRMLYj6IoxGIxOjs7AYywUqb8CyHEyad/+LRu3Tq2bdvG/Pnz2bFjB21tbWzatInp06fz5ptv0tTUxJ49e9A0zVgSxuVyYbVasdvt1NbWUlxczLZt2/jHP/5BOBzmoosuYvv27SiKwnnnnUdFRQWHDx82/o/TqyZ9Ph/ve9/7jP8T7HY711xzzYDfVfQlj/SKfbvdjs1mY8KECbzwwgt0dXVxzjnnsHbtWlpaWpgyZQp79uwB0v/PhUIhli1bRjwe55133qGxsZEpU6bg9/t5/fXXAZg4caJRUdjR0UE8Hqe6uppEIoHFYsHhcFBfX09rayupVIqKigq2bt1KUVERO3bsMNa0bG9vZ/369Xi9XiwWizHlW1EUmpubcTgceDwewuEwe/bsYfLkyezbt48vfvGLPPDAAyxbtoxAIEBnZyczZ85k8+bNVFZW4vV6cTqdQHoqeVNTEz6f70S+ZU57VVVVbN26lVmzZo2r68PxeE0rYz4xxsKYT0QOoGjjaV5lv3A4TCAQoKura9y8oY7V6XjOcHqe9+l4zqOlP0d652pI/8AsKSnhO9/5Du+++y6aplFeXk5nZycdHR1omsY//vEPSktLsVgsNDc3U15ejqIofPnLX+a5555j586dtLW1UVlZSTQaJRKJGCFjT08PxcXFXH/99bz55pts3rzZuN1qteJwOHC5XEYFQFVVFaFQiKKiIpqamigrK6O9vZ2enh7jPCT4GTtyNXjR133M1VQme9vBmstk36bTF76PxWIZ2+UKpXM1ozE36xrNuHJtA+mqm3fffVd+7gghxrxT6fckTdOIx+O0t7cbv8d0dnbS19eH1+ulsLCQlpYWkskkhYWFRoWjqqoUFxdjsViIRCJGIUYsFqOjowOXy0VRURHd3d04HA4jLNOnGft8Pvx+P52dnUZBx3DC4TBer5doNGosL6KqKna7nfb2dux2O4WFhbS1tQFQXFxMPB5HURTi8Thut9uY/REOh0mlUpSUlGCxWIzHFBUVGePzeDzGsiElJSUARkVnZ2cnHo8Hv99PS0sLhYWF9Pb2YrFYKCgoMD5s04NHAIfDQSQSMfaraRrFxcXG89fR0UEwGKSzs5NAIIDNZqOjo8M4Z7vdbsxK0ANjfSmTU+H3ufH072o8jVUnYz4xZMxjlwSP48TpeM5wep736XjOozVY8KgoCnV1dXz+859n/vz5WK1WduzYwR//+Ec2btxIPB7PCFv0xiGTJk3i4MGDRKNRI8zJbuahP66+vp729nZjLb/shiCDhT6nwi+lIn/G2jqfEjwKIcYL+T1JiPwbT/+uxtNYdTLmE0PGPHaNy6nWQggBmc2K9KBv//793H777QQCASwWC11dXUYHxeyQR59aqy/Abq4ey1WtpigK+/fvH7aaTd+HTKsW2cbhZ31CCDGmSJNJIfJvPDaZFEKMH+MyeHQ6ndx2223GtIHTwel4znB6nvfpeM75YP5FSVVVOjo6jO8H63g+kimp2dvqxxoqTBysWlIIeR8IIcSxkSaTQhw/46HJ5Hi8VpIxnxgy5rFrXE61FkKc3rq6uigsLGT27NnGVGsYfl290cjXfoQYD1RVZfPmzYRCoTF/wSGEOL3p6yePxyaTY6GJwLGQ8Z88x3vs5uYS+rqYQgiRL+Oy4lEIcXrTqx22bNlykkcixKllPFQ6CCFOb3ooEggExl14pPP7/eN27CDjP5mO59jl/38hxPEiwaMQYtzROzCOx2qHkRrPn8qP1Kl+juPp/MyVDkIIIYQQQgiRLxI8CiHGnVOh2mGkxvOn8iN1qp/jeDm/UzXEF0IIIYQQQpw8soCDEEIIIYQQYlwYzwvxj+exg4z/ZBrPYxdCiHEZPN5zzz1MmDABl8vFkiVLePPNN0/2kI7aq6++yr/8y79QVVWFoig8/vjjGfdrmsatt95KZWUlbrebiy66iF27dmVs09HRwbXXXovf76ewsJAvfOEL9PT0nMCzGLk777yTs846i4KCAsrKyrjyyivZsWNHxjbRaJQVK1ZQXFyMz+fjmmuuobm5OWObAwcOcMUVV+DxeCgrK+Ob3/wmyWTyRJ7KqNx7773MmzfPqHxaunQpTz/9tHH/qXjOQgghhBD55nQ6+f73vz8uA5jxPHaQ8Z9M43ns+TSWcoDxeB0/Hq/FT4Xr6LvuugtFUbjpppvG1bjzadwFj3/605+4+eabue2223j77bc544wzuPTSS2lpaTnZQzsqkUiEM844g3vuuSfn/T/5yU/45S9/yX333cfatWvxer1ceumlRKNRY5trr72WLVu28Pzzz/Pkk0/y6quvcsMNN5yoUxiVVatWsWLFCtasWcPzzz9PIpHgkksuIRKJGNt87Wtf44knnuDRRx9l1apVHD58mKuvvtq4X1VVrrjiCuLxOKtXr+ahhx7iwQcf5NZbbz0ZpzQiNTU13HXXXaxfv5633nqLCy64gI985CNGc5RT8ZyPp9PhU185x/HvVD8/IYQQQogTZazlAOPxOn48XouP9+vodevWcf/99zNv3ryM28f6uPNOG2cWL16srVixwvheVVWtqqpKu/POO0/iqPID0B577DHj+1QqpVVUVGj/8R//YdwWCoU0p9Op/fGPf9Q0TdO2bt2qAdq6deuMbZ5++mlNURTt0KFDJ2zsR6ulpUUDtFWrVmmalj4/u92uPfroo8Y227Zt0wDtjTfe0DRN05566inNYrFoTU1Nxjb33nuv5vf7tVgsdmJP4BgUFRVp//Vf/3VanbMQQgghhBBCjNZYzgHG63X8eL0WHy/X0d3d3drUqVO1559/Xlu2bJn21a9+VdO08fM859O4qniMx+OsX7+eiy66yLjNYrFw0UUX8cYbb5zEkR0fe/fupampKeN8A4EAS5YsMc73jTfeoLCwkEWLFhnbXHTRRVgsFtauXXvCxzxaXV1dwJEuxevXryeRSGSc84wZM6irq8s457lz51JeXm5sc+mllxIOh41PPsYyVVV55JFHiEQiLF269LQ4ZyGEEEIIIYQ4GuMtBxgv1/Hj7Vp8vF1Hr1ixgiuuuCJjfDD2n+fjYVwFj21tbaiqmvHkA5SXl9PU1HSSRnX86Oc01Pk2NTVRVlaWcb/NZiMYDI755ySVSnHTTTdx7rnnMmfOHCB9Pg6Hg8LCwoxts88513Oi3zdWbdq0CZ/Ph9Pp5Mtf/jKPPfYYs2bNOqXPWQghhBAiX8bS+m5m43GtN914XPNNdyqs/WYm68ANbrzlAOPhOn48XYuPx+voRx55hLfffps777xzwH1jedzHy7gKHsWpZcWKFWzevJlHHnnkZA/lhJg+fTobNmxg7dq13HjjjSxfvpytW7ee7GEJIYQQQox5Y219N7PxuNabbjyu+aYb72u/mck6cOJEG0/X4uPtOrqhoYGvfvWr/OEPf8Dlcp3s4YwNJ3uu92jEYjHNarVmrJ+gaZp23XXXaR/+8IdPzqDyiKy1IXbv3q0B2jvvvJOx3fnnn6/97//9vzVN07Tf/va3WmFhYcb9iURCs1qt2t/+9rfjPeSjtmLFCq2mpkbbs2dPxu0vvviiBmidnZ0Zt9fV1Wk//elPNU3TtO9973vaGWeckXH/nj17NEB7++23j+ew8+rCCy/UbrjhhtPqnPPh7rvv1urr6zWn06ktXrxYW7t27cke0ojdcccd2qJFizSfz6eVlpZqH/nIR7Tt27dnbNPX16f967/+qxYMBjWv16tdffXVGWt7aJqm7d+/X/vgBz+oud1urbS0VPvGN76hJRKJE3kqI3LnnXdqgLGeiaadGud38OBB7dprr9WCwaDmcrm0OXPmZKzPk0qltO9973taRUWF5nK5tAsvvFDbuXNnxj7a29u1T3/601pBQYEWCAS0z3/+81p3d/eJPhUhhBg3xvL6bmbZv8+Pl7XedON1zTfdeFn7zUzWgRveWM8Bxtt1/Hi/Fh/r19GPPfaYBmhWq9X4AjRFUTSr1aq98MILY3Lcx9O4qnh0OByceeaZvPjii8ZtqVSKF198kaVLl57EkR0fEydOpKKiIuN8w+Ewa9euNc536dKlhEIh1q9fb2zz0ksvkUqlWLJkyQkf83A0TWPlypU89thjvPTSS0ycODHj/jPPPBO73Z5xzjt27ODAgQMZ57xp06aMT7iff/55/H4/s2bNOjEnkgepVIpYLHZanfOxGsvVDiMxnqsKRutU/eS+s7OTc889F7vdztNPP83WrVv5z//8T4qKioxtxnJlixBCjEfjbX03s/Gy1ptuvK35phtva7+ZyTpwwxtvOcBYvY4/Va7Fx/p19IUXXsimTZvYsGGD8bVo0SKuvfZa4+9jcdzH1clOPkfrkUce0ZxOp/bggw9qW7du1W644QatsLBwQMXMeNHd3a2988472jvvvKMB2k9/+lPtnXfe0fbv369pmqbdddddWmFhofb3v/9d27hxo/aRj3xEmzhxotbX12fs47LLLtMWLFigrV27VvvnP/+pTZ06VfvUpz51sk5pSDfeeKMWCAS0V155RWtsbDS+ent7jW2+/OUva3V1ddpLL72kvfXWW9rSpUu1pUuXGvcnk0ltzpw52iWXXKJt2LBBe+aZZ7TS0lLtlltuORmnNCLf+c53tFWrVml79+7VNm7cqH3nO9/RFEXRnnvuOU3TTs1zPh7GS7XDSI33qoLBnMqf3H/729/WzjvvvEHvH2+VLUIIMR4cOnRIA7TVq1dn3P7Nb35TW7x48UkaVW5kVT69/vrrGqAdPnw4Y7uPfexj2sc//nFN0zTtxz/+sTZt2rQB+yotLdV+/etfH9fxmqmqql1xxRXaueeea9z2hz/8QXM4HAO2Peuss7RvfetbmqZp2pe+9CXtkksuybg/EologPbUU08d1zFv3LhR83q9mtVq1QKBgPaPf/xjXIxb98c//lGbM2eOcW1n/r1pvJzDiTLWcoDxeB0/Hq/FT5XraPO/7fE07nwZd8Gjpmnar371K62urk5zOBza4sWLtTVr1pzsIR21l19+WQMGfC1fvlzTtCNT9srLyzWn06ldeOGF2o4dOzL20d7ern3qU5/SfD6f5vf7tc997nNjdspernMFtAceeMDYRp+KWVRUpHk8Hu2qq67SGhsbM/azb98+7fLLL9fcbrdWUlKiff3rXx9TUzGzff7zn9fq6+s1h8OhlZaWahdeeKHxw1LTTs1zzrexPsXiaOzatUsDtE2bNmmaNn6mNwznuuuu02666SZN0zL/kz0Vzm/mzJnaTTfdpH30ox/VSktLtfnz52u/+c1vjPvH+tQaIYQYjyR4PDG+/OUva/X19VpDQ4Nx21gPv2KxmLZr1y7trbfe0r7zne9oJSUl2pYtW8b8uDVN0w4cOKCVlZVp7777rnGbBI9DG0s5wHi8jh+P1+KnynV0dvA4XsadL7bjUUV5vK1cuZKVK1ee7GHkxfvf/340TRv0fkVRuP3227n99tsH3SYYDPLwww8fj+Hl3VDnqnO5XNxzzz2DLtANUF9fz1NPPZXPoR1Xv/3tb4e8/1Q853wbqpvd9u3bT9Kojt546iQ3GnoHt3Xr1g2471Q4vz179nDvvfdy880382//9m+sW7eO//2//zcOh4Ply5ePiy6GQggx3pSUlGC1Wgd0821ubqaiouIkjWpk9PE1NzdTWVlp3N7c3Mz8+fONbbKXjUkmk3R0dJyw81u5cqWx9EdNTY1xe0VFBfF4nFAolPH/t/m5r6ioGNBhXH+tjvf4HQ4HU6ZMAdLTRNetW8cvfvELPvGJT4zpcUN6KnVLSwsLFy40blNVlVdffZW7776bZ599dsyfw4k2lnKA8XgdPx6vxU+V6+hXXnkl4/vxMu58GVdrPAohxKliPHWSG6nToYNbKpVi4cKF3HHHHSxYsIAbbriBL33pS9x3330ne2hCCHHKGm/ru5mN1bXedNopsuabbqyv/WYm68AJIU4X47LiUQhx+hnP1Q7ZxmtVwXBOh0/uKysrB/wiP3PmTP76178C46eyRQghxpubb76Z5cuXs2jRIhYvXszPf/5zIpEIn/vc50720Ojp6eG9994zvt+7dy8bNmwgGAxSV1fHTTfdxI9+9COmTp3KxIkT+d73vkdVVRVXXnklkP5/5LLLLjM+yEokEqxcuZJPfvKTVFVVHdexr1ixgocffpi///3vFBQUGJX3gUAAt9tNIBDgC1/4AjfffDPBYBC/389XvvIVli5dytlnnw3AJZdcwqxZs/jsZz/LT37yE5qamvjud7/LihUrcDqdx23st9xyC5dffjl1dXV0d3fz8MMP88orr/Dss8+O6XHrCgoKjFkvOq/XS3FxsXH7WD8HIYQYkZM60VsIIUZh8eLF2sqVK43vVVXVqqurx01zmVQqpa1YsUKrqqrSdu7cOeB+vfnKX/7yF+O27du352y+0tzcbGxz//33a36/X4tGo8f/JIYQDoe1TZs2ZXwtWrRI+8xnPqNt2rRp3J+fpmnapz71qQHNZW666SZjMWi9ucz/+T//x7i/q6srZ3OZt956y9jm2WefleYyQggxjLG0vpvZeFzrTZdr3IzxNd90p8rab2an+zpwQohTk6JpI5joL4QQY8Cf/vQnli9fzv33329UO/z5z39m+/btA9bUG4v+9V//1agqmD59unG7XlUAcOONN/LUU0/x4IMPGp9sA6xevRpIVxDOnz+fqqoq45Ptz372s3zxi1/kjjvuOPEnNYz3v//9zJ8/n5///OfA+D+/devWcc455/CDH/yAj3/847z55pt86Utf4je/+Q3XXnstAP/+7//OXXfdxUMPPWRUtmzcuJGtW7caU9Avv/xympubjcqWz33ucyxatGjcrNcrhBBCCCGEECMhwaMQYly5++67+Y//+A+ampqYP38+v/zlL4/7+kf5oihKztsfeOABrr/+egCi0Shf//rX+eMf/0gsFuPSSy/l17/+dcYU3P3793PjjTfyyiuv4PV6Wb58OXfddRc229hbPSM7eDwVzu/JJ5/klltuYdeuXUycOJGbb76ZL33pS8b9mqZx22238Zvf/IZQKMR5553Hr3/9a6ZNm2Zs09HRwcqVK3niiSewWCxcc801/PKXv8Tn852MUxJCCCGEEEKI40KCRyGEEEIIIYQQQgghRN5JV2shhBBCCCGEEEIIIUTeSfAohBBCCCGEEEIIIYTIOwkehRBCCCGEEEIIIYQQeSfBoxBCCCGEEEIIIYQQIu8keBRCCCGEEEIIIYQQQuSdBI9CCCGEEEIIIYQQQoi8k+BRCCGEEEIIIYQQQgiRdxI8CiGEEEIIIYQQQggh8k6CRyGEEEIIIYQQQgghRN5J8CiEEEIIIYQQQgghhMg7CR6FEEIIIYQQQgghhBB5J8GjEEIIIYQQQgghhBAi7yR4FEIIIYQQQgghhBBC5J0Ej0IIIYQQQgghhBBCiLyT4FEIIYQQQgghhBBCCJF3EjwKIYQQQgghhBBCCCHyToJHIYQQQgghhBBCCCFE3knwKIQQQgghhBBCCCGEyDsJHoUQQgghhBBCCCGEEHknwaMQQgghhBBCCCGEECLvJHgUQgghhBBCCCGEEELknQSPQgghhBBCCCGEEEKIvJPgUQghhBBCCCGEEEIIkXcSPAohhBBCCCGEEEIIIfJOgkchhBBCCCGEEEIIIUTeSfAohBBCCCGEEEIIIYTIOwkehRBCCCGEEEIIIYQQeSfBoxBCCCGEEEIIIYQQIu8keBRCCCGEEEIIIYQQQuSdBI9CCCGEEEIIIYQQQoi8k+BRCCGEEEIIIYQQQgiRdxI8CiGEEEIIIYQQQggh8k6CRyGEEEIIIYQQQgghRN5J8CiEEEIIIYQQQgghhMg7CR6FEEIIIYQQQgghhBB5J8GjEEIIIYQQQgghhBAi7yR4FEIIIYQQQgghhBBC5J0Ej0IIIYQQQgghhBBCiLyT4FEIIYQQQgghhBBCCJF3EjwKIYQQQgghhBBCCCHyToJHIYQQQgghhBBCCCFE3knwKIQQQgghhBBCCCGEyDsJHoUQQgghhBBCCCGEEHknwaMQQgghhBBCCCGEECLvJHgUQgghhBBCCCGEEELknQSPQgghhBBCCCGEEEKIvJPgUQghhBBCCCGEEEIIkXcSPAohhBBCCCGEEEIIIfJOgkchhBBCCCGEEEIIIUTeSfAohBBCCCGEEEIIIYTIOwkehRBCCCGEEEIIIYQQeSfBoxBCCCGEEEIIIYQQIu8keBRCCCGEEEIIIYQQQuSdBI9CCCGEEEIIIYQQQoi8k+BRCCGEEEIIIYQQQgiRdxI8CiGEEEIIIYQQQggh8k6CRyGEEEIIIYQQQgghRN5J8CiEEEIIIYQQQgghhMg7CR6FEEIIIYQQQgghhBB5J8GjEEIIIYQQQgghhBAi7yR4FEIIIYQQQgghhBBC5J0Ej0IIIYQQQgghhBBCiLyT4FEIIYQQQgghhBBCCJF3EjwKIYQQQgghhBBCCCHyToJHIYQQQgghhBBCCCFE3knwKIQQQgghhBBCCCGEyDsJHoUQQgghhBBCCCGEEHknwaMQQgghhBBCCCGEECLvJHgUQgghhBBCCCGEEELknQSPQgghhBBCCCGEEEKIvJPgUQghhBBCCCGEEEIIkXcSPAohhBBCCCGEEEIIIfJOgkchhBBCCCGEEEIIIUTeSfAohBBCCCGEEEIIIYTIOwkehRBCCCGEEEIIIYQQeSfBoxBCCCGEEEIIIYQQIu8keBRCCCGEEEIIIYQQQuSdBI9CCCGEEEIIIYQQQoi8k+BRCCGEEEIIIYQQQgiRdxI8CiGEEEIIIYQQQggh8k6CRyGEEEIIIYQQQgghRN5J8CiEEEIIIYQQQgghhMg7CR6FEEIIIYQQQgghhBB5J8GjEEIIIYQQQgghhBAi7yR4FEIIIYQQQgghhBBC5J0Ej0IIIYQQQgghhBBCiLyT4FEIIYQQQgghhBBCCJF3EjwKIYQQQgghhBBCCCHyToJHIYQQQgghhBBCCCFE3knwKIQQQgghhBBCCCGEyDsJHoUQQgghhBBCCCGEEHknwaMQQgghhBBCCCGEECLvJHgUQgghhBBCCCGEEELknQSPQgghhBBCCCGEEEKIvJPgUQghhBBCCCGEEEIIkXcSPAohhBBCCCGEEEIIIfJOgkchhBBCCCGEEEIIIUTeSfAohBBCCCGEEEIIIYTIOwkehRBCCCGEEEIIIYQQeSfBoxBCCCGEEEIIIYQQIu8keBRCCCGEEEIIIYQQQuSdBI9CCCGEEEIIIYQQQoi8k+BRCCGEEEIIIYQQQgiRdxI8CiGEEEIIIYQQQggh8k6CRyGEEEIIIYQQQgghRN5J8CiEEEIIIYQQQgghhMg7CR6FEEIIIYQQQgghhBB5J8GjEEIIIYQQQgghhBAi7yR4FEIIIYQQQgghhBBC5J0Ej0IIIYQQQgghhBBCiLyT4FEIIYQQQgghhBBCCJF3EjwKIYQQQgghhBBCCCHyToJHIYQQQghxQjz44IMoisJbb711socypsYihBBCCHGqkuBRCCGEECeNhD/iWNxxxx08/vjjJ3sY9PT0cNttt3HZZZcRDAZRFIUHH3xw0O1TqRT33nsv8+fPx+12U1xczAUXXMC777477LEURWHlypXG9/v27UNRFOPLarVSV1fHVVddxYYNGwY8drCvL3/5ywOO9dprr/Hxj3+c6upqHA4HgUCAJUuWcPvtt9Pc3Dzi50cIIYQQpy/byR6AEEIIIYQQR+OOO+7gox/9KFdeeeVJHUdbWxu33347dXV1nHHGGbzyyitDbv/5z3+eP/zhD1x33XWsXLmSSCTCO++8Q0tLy1GP4VOf+hQf/OAHUVWVbdu2ce+99/L000+zZs0a5s+fb2x38cUXc9111w14/LRp0zK+v/XWW/nhD3/IpEmTuP7665k0aRLRaJT169fzn//5nzz00EPs3r37qMcrhBBCiNODBI9CCCGEEEIcg8rKShobG6moqOCtt97irLPOGnTbP//5zzz00EP87W9/46qrrsrbGBYuXMhnPvMZ4/tzzz2XD3/4w9x7773cf//9xu3Tpk3L2C6XP/3pT/zwhz/k4x//OL/73e9wOBwZ9//sZz/jZz/7Wd7GLoQQQohTl0y1FkIIIcSYcv311+Pz+Thw4AAf+tCH8Pl8VFdXc8899wCwadMmLrjgArxeL/X19Tz88MMZj+/o6OAb3/gGc+fOxefz4ff7ufzyy3NOY92/fz8f/vCH8Xq9lJWV8bWvfY1nn30WRVEGVK2tXbuWyy67jEAggMfjYdmyZbz++uvDns8rr7yCoij8+c9/5sc//jE1NTW4XC4uvPBC3nvvvYxtX3vtNT72sY9RV1eH0+mktraWr33ta/T19eX1OQIIhULcdNNN1NbW4nQ6mTJlCv/+7/9OKpXK2K6xsZHt27eTSCSGPddHHnmEM888k4KCAvx+P3PnzuUXv/jFkI/p7Oxk8eLF1NTUsGPHDgBisRi33XYbU6ZMMZ6Hb33rW8RiMeNxiqIQiUR46KGHjOnC119/vXH/oUOH+MIXvkBVVRVOp5OJEydy4403Eo/HM44fi8W4+eabKS0txev1ctVVV9Ha2jrsuZo5nU4qKipGtO1Pf/pTFi9ezFVXXUUqlSISiYzqWCN1wQUXALB3795RP/bWW2+lpKSE3/72twNCR4BAIMD3v//9Yx2iEEIIIU4DUvEohBBCiDFHVVUuv/xyzj//fH7yk5/whz/8gZUrV+L1evn//r//j2uvvZarr76a++67j+uuu46lS5cyceJEAPbs2cPjjz/Oxz72MSZOnEhzczP3338/y5YtY+vWrVRVVQEQiUS44IILaGxs5Ktf/SoVFRU8/PDDvPzyywPG89JLL3H55Zdz5plnctttt2GxWHjggQe44IILeO2111i8ePGw53TXXXdhsVj4xje+QVdXFz/5yU+49tprWbt2rbHNo48+Sm9vLzfeeCPFxcW8+eab/OpXv+LgwYM8+uijeXuOent7WbZsGYcOHeJ//a//RV1dHatXr+aWW26hsbGRn//858ZxbrnlFh566CH27t3LhAkTBj2/559/nk996lNceOGF/Pu//zsA27Zt4/XXX+erX/1qzse0tbVx8cUX09HRwapVq5g8eTKpVIoPf/jD/POf/+SGG25g5syZbNq0iZ/97Gfs3LnTWNPxd7/7HV/84hdZvHgxN9xwAwCTJ08G4PDhwyxevJhQKMQNN9zAjBkzOHToEH/5y1/o7e3NCNO+8pWvUFRUxG233ca+ffv4+c9/zsqVK/nTn/407Gs6WuFwmDfffJN//dd/5d/+7d/41a9+RU9PDxMnTuSuu+7i4x//eN6OpU+DLi4uzrg9Go3S1tY2YHu/34/D4WDnzp3s3LmTL37xi/h8vryNRwghhBCnKU0IIYQQ4iR54IEHNEBbt26dcdvy5cs1QLvjjjuM2zo7OzW3260piqI98sgjxu3bt2/XAO22224zbotGo5qqqhnH2bt3r+Z0OrXbb7/duO0///M/NUB7/PHHjdv6+vq0GTNmaID28ssva5qmaalUSps6dap26aWXaqlUyti2t7dXmzhxonbxxRcPeY4vv/yyBmgzZ87UYrGYcfsvfvELDdA2bdqUsc9sd955p6YoirZ///68PUc//OEPNa/Xq+3cuTPjWN/5znc0q9WqHThwYMCx9u7dO+R5fvWrX9X8fr+WTCYH3cb8ejc2NmqzZ8/WJk2apO3bt8/Y5ne/+51msVi01157LeOx9913nwZor7/+unGb1+vVli9fPuA41113nWaxWDLeVzr9NdTHctFFF2W8rl/72tc0q9WqhUKhIc93MOvWrdMA7YEHHhhw39tvv60BWnFxsVZeXq79+te/1v7whz9oixcv1hRF0Z5++ulh9w9oK1asML7fu3evBmg/+MEPtNbWVq2pqUl75ZVXtAULFmiA9te//jXjsYN9/fGPf9Q0TdP+/ve/a4D285//POO4qdT/z955h0dVpu//nt5beiYFkhASCAgKEkUBpSyiIAhSVKoF1AWxsK64FJUVRZCi7NpWBQVUsLDydREQESwoUgUJJrRAeplM7+X3B7/n9UwSeiAR38915UrmzJk57ymZc+Y+9/Pc4Uh1dXXUTyAQuKBtxOFwOBwO588DL7XmcDgcDofTIrn//vvZ30ajETk5OdBoNFGusJycHBiNRhw9epRNUygUEItPXeKEQiHU1tZCq9UiJycHu3fvZvN9+eWXSElJwe23386mKZVKPPDAA1Hj2Lt3L4qKinD33XejtrYWNTU1qKmpgcvlQp8+fbBt27YG5cmNMWHChCinXY8ePQAgauwqlYr97XK5UFNTg+7duyMSiWDPnj1Nto3WrFmDHj16wGQysfWpqalB3759EQqFsG3bNjbvsmXLEIlEzuh2pOW7XC5s2rTprNuipKQEvXr1QiAQwLZt29CqVauosbVr1w65ublRY6PS4cYcqULC4TDWrl2LQYMGoWvXrg2eF4lEUY8nTpwYNa1Hjx4IhUIoLi4+63qcL06nEwBQW1uL//73v3jooYdw9913Y/PmzYiNjcU///nPC37v2bNnIz4+HklJSbjppptw5MgRzJs3D0OHDo2ab/Dgwdi0aVODn5tvvhnAKVcmgAZuR5vNhvj4+Kif+qnZHA6Hw+FwOPXhpdYcDofD4XBaHEqlEvHx8VHTDAYDUlNTGwhHBoMBdXV17HE4HMaSJUvw73//G8eOHUMoFGLPCctOi4uLkZWV1eD92rRpE/W4qKgIADBu3LjTjtdms8FkMp1xndLT06Me0/zCsZ84cQKzZs3C559/HjWdliHkYrZRUVERfvnllwavJy4kXfnhhx/G6tWrMWDAAKSkpOAvf/kLRowYgVtuuaXBvGPGjIFUKkVBQUGD3ohFRUUoKCi44LFVV1fDbrejQ4cO5zTuc9kvTQUJyxkZGcjPz2fTtVotBg0ahBUrViAYDEIqPf9L9IkTJ2L48OEQi8UwGo3Iy8uDQqFoMF9qair69u172vfR6XQAfhdJhWMkUXnjxo2YP3/+eY+Rw+FwOBzOnw8uPHI4HA6Hw2lxSCSS85oeiUTY33PnzsXMmTNx7733Ys6cOYiJiYFYLMajjz56Ts7E+tBr5s+fj86dOzc6z7n0wjvb2EOhEOt3+Pe//x25ubnQaDQoLS3F+PHjG4z9YrZROBxGv3798OSTTzY6b9u2bc+6PvVJSEjA3r17sWHDBqxfvx7r16/Hu+++i7Fjx2L58uVR8w4dOhTvvfcelixZghdeeCHquXA4jI4dO2LhwoWNLictLe28x3YmzmV7NRXUXzQxMbHBcwkJCQgEAnC5XDAYDOf93tnZ2WcUFM+V3NxcAMCBAweipkulUvb+JSUlF70cDofD4XA4fw648MjhcDgcDueK4uOPP8bNN9+Mt99+O2q61WpFXFwce9yqVSscPHgQkUgkyiFYP2maAkv0en2TCDunY//+/SgsLMTy5csxduxYNv1cSpfPl6ysLDidziZfH7lcjkGDBmHQoEEIh8N4+OGH8cYbb2DmzJlRTtIpU6agTZs2mDVrFgwGA5566qmose3btw99+vRp4NysT2PPx8fHQ6/XNxDOWgJmsxlJSUkoLS1t8FxZWRmUSiVzHDYXOTk5yM7Oxtq1a7F48WJoNJpmHQ+Hw+FwOJw/NrzHI4fD4XA4nCsKiUTSwK22Zs2aBmJP//79UVpais8//5xN83q9eOutt6Lm69KlC7KysrBgwYIG5afAqdLepho3EO20i0QiWLJkSZO8v5ARI0Zg+/bt2LBhQ4PnrFYrgsEge1xeXo5Dhw4hEAic8T1ra2ujHovFYlx11VUAAJ/P12D+mTNnYtq0aZg+fTpee+21qLGVlpY22A8A4PF44HK52GONRgOr1dpguUOGDMG6deuwc+fOBu9xKZyM58PIkSNx8uTJKEG5pqYG//3vf9G7d2/WnzQQCODQoUMoLy+/7GN85plnUFNTgwceeKDR/d7c25DD4XA4HM4fB+545HA4HA6Hc0UxcOBAPPfcc5gwYQK6d++O/fv3Y+XKlcjMzIyab9KkSVi6dCnuuusuTJ06FcnJyVi5ciWUSiWA3910YrEY//nPfzBgwADk5eVhwoQJSElJQWlpKbZs2QK9Xo9169Zd9Lhzc3ORlZWFadOmobS0FHq9Hp988skl6TX4t7/9DZ9//jkGDhyI8ePHo0uXLnC5XNi/fz8+/vhjHD9+nLlDp0+fjuXLl+PYsWNnDJi5//77YbFY0Lt3b6SmpqK4uBivvvoqOnfujHbt2jX6mvnz58Nms+Gvf/0rdDodRo8ejTFjxmD16tV48MEHsWXLFtxwww0IhUI4dOgQVq9ejQ0bNrDQmC5duuCrr77CwoULYTabWe/EuXPnYuPGjejVqxcmTpyIdu3aoby8HGvWrMF3330Ho9HY1JsUS5cuhdVqRVlZGQBg3bp1rCR5ypQprHx6+vTpWL16NYYNG4bHH38cBoMBr7/+OgKBAObOncver7S0FO3atcO4ceOwbNmyJhtnYWEhVqxY0WB6YmIi+vXrBwC4++67ceDAAbzwwgvYsWMHRo0ahYyMDLhcLhw4cAAffPABdDrdWfuacjgcDofD4XDhkcPhcDgczhXF008/DZfLhVWrVuGjjz7CNddcgy+++CKqnBc41Zfx66+/xpQpU7BkyRJotVqMHTsW3bt3x7Bhw5gACQA33XQTtm/fjjlz5mDp0qVwOp1ISkpCfn4+Jk2a1CTjlslkWLduHR555BG88MILUCqVuOOOOzB58mR06tSpSZZBqNVqbN26FXPnzsWaNWvw3nvvQa/Xo23btnj22WcvqMfg6NGj8eabb+Lf//43rFYrkpKSMHLkSDzzzDPMxdcYr7/+OpxOJyZMmACdTofBgwdj7dq1WLRoEd577z189tlnUKvVyMzMxNSpU6P6Ty5cuBATJ07EjBkz4PF4MG7cOOTn5yMlJQU//fQTZs6ciZUrV8JutyMlJQUDBgyAWq2+oG12NhYsWBCVhP3pp5/i008/ZduGtmliYiK+++47TJs2DYsWLUIgEMD111+PFStWnHU/k9PwdH0pzwVKsa5Pr169mPAInOqV2r9/fyxduhTvvPMOampqoFKp0LZtWzzxxBN48MEHGwQDcTgcDofD4dRHFOG1EhwOh8PhcDiMxYsX47HHHkNJSQlSUlKaezgcDsNut8NgMGDGjBmYM2dOcw+Hw+FwOBwO56zwHo8cDofD4XD+tHg8nqjHXq8Xb7zxBrKzs7noyGlx/PzzzwCA9u3bN/NIOBwOh8PhcM4NXmrN4XA4HA7nT8vQoUORnp6Ozp07w2azYcWKFTh06BBWrlzZ3EPjtACcTmejgUJC4uPjL6r0+Vz45ZdfWC/L2NhY3HbbbZd0eRwOh8PhcDhNBXc8cjgcDofDuez861//QuvWraFUKpGfn48dO3Y0yzj69++P77//Hn/729/w7LPPQqFQ4MMPP8Tdd9/dLOPhtCwWLFiA5OTkM/6cPHnyko/j008/xdNPP43WrVtj/fr10Ov1l3yZHA6Hw+FwOE0B7/HI4XA4HA7nsvLRRx9h7NixeP3115Gfn4/FixdjzZo1+O2335CQkNDcw+NwGEePHsXRo0fPOM+NN94YFUTE4XA4HA6Hw/kdLjxyOBwOh8O5rOTn5+Paa6/F0qVLAQDhcBhpaWmYMmVKg+RpDofD4XA4HA6H88eFl1pzOBwOh8O5bPj9fuzatQt9+/Zl08RiMfr27Yvt27c348g4HA6Hw+FwOBxOU8PDZTgcDofD4Vw2ampqEAqFkJiYGDU9MTERhw4dajC/z+eDz+djj8PhMCwWC2JjYyESiS75eDmcPwORSAQOhwNmsxliMfclcDgcDofDaTq48MjhcDgcDqfF8sILL+DZZ59t7mFwOH8KTp48idTU1OYeBofD4XA4nCsILjxyOBwOh8O5bMTFxUEikaCysjJqemVlJZKSkhrMP336dDz++OPssc1mQ3p6Ok6ePMmTfTmNImxfHolEEA6HEQwGAZxyzEYiEfYTCoUQCoXg8/ngcrmwb98+7NixA3FxccjPz0dsbCxOnDgBkUiEtLQ0iMViKBQKSCQShEIhyGQyqNVqSCQS9v60LLFYDLfbjWAwCLFYjHA4jFAoBADwer2Qy+WQSCQQi8Xwer0QiUSQSCRQKpWQSk9dortcLkQiEcjlcohEIoTDYSgUCkQiEdhsNuh0OshkMkQiEVgsFni9XqjVaojFYpSUlCAcDqN169bIysqCWCw+rUvYbrcjLS0NOp3uku0XDofD4XA4f0648MjhcDgcDueyIZfL0aVLF2zevBlDhgwBcEqs2bx5MyZPntxgfoVCAYVC0WC6Xq/nwiOnUcLhMEQiERMVI5EIgsEgExtFIhETJ0OhEILBIPx+P3777TdUVVXh5ptvRvv27SEWi3Hy5EkYjUbExsayY1EqlUImk0Emk0EsFkOpVLL38/v9bDnhcBg6nQ4ulwsWiwVisRhSqRRisRh6vR5yuRyRSAS1tbWQy+VQqVRMVJRKpXC73VCpVJDL5QiFQhCLxVCr1fB6vQCA+Ph4iEQi+P1+BINByOVyxMTEQKVSobCwEBqNBm3btgUA6HQ6SCSSs7Yn4O0LOBwOh8PhNDVceORwOBwOh3NZefzxxzFu3Dh07doV3bp1w+LFi+FyuTBhwoTmHhrnCoBER5/Ph0AgAKlUygRHiUSCQCAAkUgEr9cLn88Hm82Gr776CikpKbj11luZg/DkyZNQKpWIi4uD3++HVCqFVCpl7kOpVAqJRMKcjHK5HGKxGIFAAF6vlwmQ1KPU4/FAIpFApVKxsYlEIohEIshkMoTDYTgcDiaEGo1GqNXqqPd3u92QSqUIBoOwWCyQSqUQiURQKpVQKpVwOBw4fvw4pFIpzGYzdDod7HZ7M+8RDofD4XA4f2a48MjhcDgcDueyMnLkSFRXV2PWrFmoqKhA586d8eWXXzYInOFwzhVheXUoFGIuQHI8AmDl0cFgEOFwGH6/HydOnMCBAwfQrl07ZGdnQy6Xw+fzoaSkBDKZDAaDAaFQCGq1GkqlEhKJhAmMkUgEfr8f4XCYlUtHIhEEAgH4/X5IJBL4fD5EIhHo9Xq4XC7odDpWdu10OuFyudjY/H4/PB4P9Ho9Ez99Ph+kUilcLhc8Hg9kMhksFguKi4thMplgNBoRDAbhdrtRW1vL1tVkMkGhUMDv98Pv93MnI4fD4XA4nGaDC48cDofD4XAuO5MnT260tJrDuVCoZ2MgEEAoFGKuRCIUCjH3YCQSQXl5OYqKipCVlYW8vDzWf7Gurg4ajQbAKZei2WyGUqmE3+9nic8kXlKpM00nB6REIoHb7YZMJmNjo7F4vV72WolEgtraWng8HlZO7fF4mJNRKpXC4/FE9ar0er0oKSmBTqdDXV0dExwlEgliYmIQHx8Pk8nESsCpzJzD4XA4HA6nOeDCI4fD4XA4HA7nDw85DYU9HCUSCRPtRCIRgsEggsEgKioqcOjQIbRq1QpZWVkAwAJbqAdjZWUlYmNjIZVK4fP5mGswGAxCJBIhEAgwV6VSqUQwGGT9SGlaIBCATqeD0+lEKBSCy+WCzWaDRqOBXC6HTCaDRqOBz+eDQqFgpdehUAher5eJqAaDAS6XCz6fjzkra2tr4fP5EBMTA71eD4PBAJPJBJVKxcq3XS4XZDIZdzxyOBwOh8NpNrjwyOFwOBwO50/N2dxg9UUbmp+LOc0P7QtKpZbJZAiFQlH9F0lsBE7ts0OHDuHkyZNITU1FZmYmC29xOBzweDzQ6XSoqalhZdEulwsqlQpisZglVJMwKJVKWT9JkUgEh8MBn8/HSrmlUimbTyaTwe/3IxAIQCwWw+FwMGemx+OBw+GAUqlEOByGXC5n7019Jb1eL4LBIPbu3QvglKiamZmJ2NhYNj4SPsmBWV1dzUJoOBwOh8PhcJoDLjxyOBwOh8P50yMUE4XJx0L3HKflQPuEeip6vV6IxWKWHC2VSllZNYmP4XAY+/fvR1VVFVJSUpCSksLKs+12OywWC/R6PWpra6HVaqFWqyGTyVgaNPVyDIVC8Hg8zPkok8mgVquZ8AiAhdqQACiVShEIBKBQKKDVahEMBqFUKlFaWsoERrVazXo2er1eKJVKqFQqaLVaVna9c+dOeL1e9O7dG7GxsczNKBKJIBaLIRKJmGhps9ngdruZk5LD4XA4HA6nOeDCI4fD4XA4HM7/JxwOM6EKABOPSNwhMZLT/FC4i9vtZv0SaV+R4Ehl1pFIBAcPHkRpaSnatGkDs9nMRLtwOIy6ujro9Xq43W5oNBrExMQgEomwkBdhf0jqBSmVSqFUKgGAuSqpH2MwGIRUKmUBL16vFyqVirkf3W43K9NWqVSIj4+HTCZjpdUqlQpKpZKVZLtcLhw+fBiHDx9G//79kZGREVVCDoCJjiQ02mw2aLXaqD6XHA6Hw+FwOJcbfiXC4XA4HA7nT8HZnIuhUAhutxulpaVM+KFQELVazcpYyQF3vk5ILlhePMJtTuXVJLiFw+GoeQOBABPyDhw4AIfDgauuuoqVHlMydXV1NSKRCHtvo9EIuVwe5SQkx2QwGIRKpWLCNI3D6XQyxyU5J2m8wWAQGo0Gbrcbfr8fcrkcSqUSDocDGo0GOp0OKpWKCahyuRxqtZoJhk6nE2VlZfj+++9x4403onXr1pBIJEwUDwQC7DiVSqWIRCKw2+1sGh23HA6Hw+FwOM0BFx45HA6Hw+H86RCWVlMSstfrxRdffMHSgY1GI1JSUlgoSDgcZiEgcrmcCZBUTktwgfHS0JjoKJFImEBM5c0k9gWDQfj9fuzbtw92ux15eXkwmUwIBoOQyWQQi8WoqalBXV0dEhMTUV1djcTERLZPhW5CEinJJUnuREqjpt6Sfr8fer2eOTBJFPT7/ZBIJFCr1awnpFwuZ0EwJJDSuvh8PrjdbsTExKC0tBRbt25FmzZtkJeXB51Ox8qzhendlIQdDAYRCARgMBhYqTiHw+FwOBxOc8GFRw6Hw+FwOH8qqGyWxCRyxh06dAiVlZXo2rUrTpw4gYKCAuTk5CA9PR0xMTEIhUKIRCJwOBxMaJJIJAiFQtBoNFAoFA3KWrkI2fT4/X44HA6Ew2GoVCq2X2hbkwDo8/nwyy+/oKysDB06dEBsbCwikQgTFUOhEMrKyqDRaODxeKBSqaBQKNg+VqlUTMSkoBpyVQr7SpI7srq6Gj6fD2KxGBKJBA6Hg4mU5JKkUmyVSsWOHZvNBpVKxQJxfD4fQqEQTCYTLBYLvv/+e3Tp0gVt27aFyWRi4ioJ3sI+j8CpdgFKpRKhUIiJoLxFAIfD4XA4nOaCC48cDofD4XD+dJBYFQ6HmYj0888/Q6/XQyaTITMzEwqFAkVFRSgrK2MOyEAggJqaGgCnevzFx8cjOTkZXq8XMpmMCZCRSARyuZyV3wqpX6J9OkGoKdKz/+gJ3PW3FaVPi0Qi5hYk1x85+6h3YmlpKYqLi5GXl4ekpCQmvlEvyLq6OgCAXq+HxWKByWRi4TFUdk9CMomEdMxQ8rRWq4Xf72fp0yRqk8Co1WpZmrXdbmfhMQDg8XggkUiQkJCAuro65qKl8miHw4Ft27ahXbt2uOaaaxATExPlaqR1pyAdEhhDoRDkcjk8Hg8TJTkcDofD4XCaCy48cjgcDofD+VMhFoshk8mYAEQpxVarFW63G8XFxfD5fEhLS0Pr1q3hdDpRWVmJffv2IS4uDklJSYiJiYHD4UBFRQUKCgrQpk0bZGZmMidkOByG1+uF3++HwWBggR+NiUBn6xXZFKnap3uPP4IoJUwXt9ls8Pv9LNSFgl6o12EwGEQkEoHFYsHOnTvRrl07pKWlMQGOhLpIJILa2lqoVCpYLBZW5kzCJG0XiUTCtp1EIoHH44Hf74dWq2W9H6nsm8Zkt9tZcjUJmX6/P0oYpMdisRg+nw8ikQhKpRISiQR+vx9WqxU7duyA2WxG586dER8fzxK7ab3JtUvrD4AJouTCpWAdEiw5HA6Hw+FwLjfis8/C4TQty5Ytg0gkws6dO5t7KC1qLBwOh8O5tAhLUekxiVpisRj5+flwu90oLCzE999/jx9++AE2mw0mkwlZWVm48cYbkZOTg/j4eKhUKhQVFcHlcsFgMODIkSPYvn077HY7/H4/K992u92sPySJQOeCMOzkQmjstU0hYDYHtN88Hg/cbjcTcYU9GAGw8mqn04kffvgBaWlpSEpKikq7VqlUzO1os9mYGzE5ORkKhYKVTpPzEAATJKn3okqlAnBK/HM6nQDAyq2DwSB0Oh3kcjkLpCHnoVwuh9/vRyQSYcuicnESHe12O6xWK7Zv346EhAR07NgR8fHxkEgkbD3I7Sgs86bHQoetXC5n26Z+8A6Hw+FwOBzO5aJFCI9c/OFcDHPnzsXatWubexj49ddfMXz4cGRmZkKtViMuLg49e/bEunXrGp2/oKAAt9xyC7RaLWJiYjBmzBhUV1ef07JEIhEmT57MHh8/fpx98SC3Rnp6Ou644w7s3bu3wWtP9/Pggw82WNa3336LESNGICUlBXK5HAaDAfn5+XjuuedQWVl57huIw+FwmhkqkyWnI332kSiYkJCAjIwMHD58GCKRCK1atUJhYSGOHz8OiUQCjUYDjUYDtVoNuVyOjIwMJjxRGezXX3+N0tJS1qePwkJOJ/rRc/V/hEIl/T7bT31xkx43No0en+09WwLUZ1HoKhSWHFNZtMvlQiQSwS+//AK1Wo2UlBTIZDImLtP5MRwOw2KxIC4uDi6XC3q9Hmq1GhKJBDKZjLkGyRXr8/mYC1GtVkOj0UClUjGBMhKJwOv1MnHS5XLB6/Wy9xMKgDSOSCQCtVoNo9EIhUIBlUoFh8OBQCCAgwcPQq/XIzs7GwaDgZXs09iFDkxhibnw+K7vcPR6vWyelrRvOX8uWtJ3vpY0Fg6Hw7nSaRHCI4dzMbQU4bG4uBgOhwPjxo3DkiVLMHPmTADA7bffjjfffDNq3pKSEvTs2ROHDx/G3LlzMW3aNHzxxRfo168f/H7/BY/hrrvuwvvvv4933nkHd999N77++mtcd911DcTHfv364f3332/wc++990bNN2vWLPTs2RO7du3C+PHj8dprr2Hu3LnIy8vDyy+/jO7du1/wWDkcDqc5ECYRkwBDASBSqRTZ2dno1q0b3G43PB4POnbsCLvdjhMnTrDAD+rbl5GRgWuuuQYGgwGtW7fGDTfcgMzMTOzYsQM1NTWs7FeYKnw+Ap+wNFsoQNJzwvmE70Up3X6/n62Hx+OBzWaD1WqFy+WC3W6Hw+GAw+GA0+mE1+tlvQ1boihFoqJCoYBMJgPwe3kxpUYrlUqUlZWhqKgISUlJEIlE0Gg0zLlIPRgp7ZpcgsnJyew9hceE3++H3+9nKdF6vR56vR5+vx8ejwd2ux1yuRyBQIAFC7lcrqikabFYzN6H9ksgEABwypFIbkp6vcPhQG1tLTIzM5GYmAitVssERqGoSGXXwpuHANh6CcNwKEWbErZb0v7l4g/nYmgp3wHq8/zzz0MkEqFDhw4Nnps7dy6uu+46xMfHQ6lUIjs7G48++ig3H3A4nCsa3uORw2kibr31Vtx6661R0yZPnowuXbpg4cKFmDhxIps+d+5cuFwu7Nq1C+np6QCAbt26oV+/fli2bFnUvOfDNddcg9GjR7PHN9xwA26//Xa89tpreOONN9j0tm3bRs3XGB999BHmzJmDESNG4P33349ybADAokWLsGjRogsaJ4fD4TQXJDzKZLIox1g4HIZEIoFOp0P79u1RXl6OQ4cOoV27dsjJyWGp15mZmUhNTWW9+4xGI+Lj41kicfv27aFUKnHw4EHIZDLExsYCiC5zFroPKZ34TMnDjU0XCmTCtGUAUWIlCV0ikQher5eV+9K2iEQikMlkTNAjEVYmk7HU78vdG7C+MEZp0PXdi1TKHAqFoFAo4PF4sHv3bmRnZ0Oj0cBoNLL1E4lErPy5vLwcRqMRTqcTSUlJUCqVbJuQKEn9GWUyGTweDyuf9ng88Hq9TMR0uVys3DkcDkOr1TLBk1yPVN4tFovhdrvZ+5LYSME1UqkUhYWFSExMhNlshlqtZscGlVjTYxIdhYE5FCojFB0pPMnn87Fy7vphRxzOH5W5c+fizjvvxJAhQ5p7KIySkhLMnTsXGo2m0ed37dqFzp07Y9SoUdDpdCgoKMBbb72FL774Anv37j3t687GXXfdhVtvvRWhUAgFBQV47bXXsH79evz444/o3Lkzm69fv34YO3Zsg9e3bds26vGsWbMwZ84cZGZmYvz48cjMzITX68WuXbvw8ssvY/ny5Thy5MgFjZXD4fz5aLFXHuPHj4dWq8WJEycwcOBAaLVapKSk4F//+hcAYP/+/ejduzc0Gg1atWqFVatWRb3eYrFg2rRp6NixI7RaLfR6PQYMGIB9+/Y1WFZxcTFuv/12aDQaJCQk4LHHHsOGDRsgEonwzTffRM37008/4ZZbboHBYIBarUavXr3w/fffn3V9vvnmG4hEIqxevRrPP/88UlNToVQq0adPHxw+fDhq3m+//RbDhw9Heno6FAoF0tLS8Nhjj8Hj8TTpNgIAq9WKRx99FGlpaVAoFGjTpg3mzZvXoBcQfQGju/Rn4sMPP0SXLl2g0+mg1+vRsWNHLFmy5IyvqaurQ7du3ZCamorffvsNAODz+TB79my0adOGbYcnn3wSPp+PvU4kEsHlcmH58uXsi8j48ePZ86WlpbjvvvtgNpuhUCiQkZGBhx56qIGr0Ofz4fHHH0d8fDw0Gg3uuOOOc77zeCYkEgnS0tJgtVqjpn/yyScYOHAgEx0BoG/fvmjbti1Wr1590cslevfuDQA4duzYeb921qxZiIuLw9tvv91AdAQAg8GAZ5555mKHyOFwOJccocsrFAox0RAAE64ikQiUSiV0Oh3i4uKQn58PtVqN/fv3QyKRQK/Xo23btrBYLDhx4gT8fj+kUilMJhML83C73QiHwzCbzUhPT8cvv/wCt9sdJZaRWAREuxbrlz6fy/oIy6tJYHI6nbBYLLBYLLDb7XA6nXC5XKitrYXdbofFYoHD4YDdbofNZoPD4WDvRWXLlPLdEpxx4XAYTqeTiWU0RhJsyeEpEomwfft2iMVimM1mVgpNfRRpPrfbjbq6OuZE1el0rCyenI0kFlJJfWxsLMLhMFwuF3ORWq1WlmJOrkcqBddoNCzVXCqVQqVSsb6UCoWCXWtQqAyJhuXl5XA4HGjTpg0MBgOkUikTgOm4pb/rOx0BMIFSeLyR8xU4dW3cEvYph3MlM23aNFx33XXo2rVro89/8skneP311/Hoo4/ivvvuw4IFC/DOO+/g8OHDp23PdC6Q+WDcuHF48cUXsWLFCvh8Prz22mtR85H5oP5Pt27d2DxC80FBQQGef/553HffffjrX/+Kd955BydOnMCYMWMueKwcDufPR4sVHoFTXw4GDBiAtLQ0vPTSS2jdujUmT56MZcuW4ZZbbkHXrl0xb9486HQ6jB07NkpcOXr0KNauXYuBAwdi4cKF+Nvf/ob9+/ejV69eKCsrY/O5XC707t0bX331FR555BH84x//wA8//IC///3vDcbz9ddfo2fPnrDb7Zg9ezbmzp0Lq9WK3r17Y8eOHee0Ti+++CI+++wzTJs2DdOnT8ePP/6Ie+65J2qeNWvWwO1246GHHsKrr76K/v3749VXX2307tTFbCO3241evXphxYoVGDt2LF555RXccMMNmD59Oh5//PGo5UyfPh3t2rVDaWnpGddv06ZNuOuuu2AymTBv3jy8+OKLuOmmm84oztbU1KB3796orKzE1q1bkZOTg3A4jNtvvx0LFizAoEGD8Oqrr2LIkCFYtGgRRo4cyV77/vvvQ6FQoEePHqxceNKkSQCAsrIydOvWDR9++CFGjhyJV155BWPGjMHWrVvhdrujxjBlyhTs27cPs2fPxkMPPYR169ZFlTGcDy6XCzU1NThy5AgWLVqE9evXo0+fPuz50tJSVFVVNXpB0q1bN+zZs+eCltsYdCeSHDeE1+tFTU1Ngx/6clJYWIjCwkIMGTIEWq22ycbD4XA4zQkJdJRuLJwOnCrFpfLX3NxcXH311QiHw6iqqmKutaysLJZYLJVKIZVKYTAYoNfrIZVKmcstOTkZGo0Gv/zyCyu5FoqLQHQpdf2gFILmDQQCbMz1S6qtVitqampgs9lYyXQgEGDiYlVVFUpKSlBXVwer1Yq6ujo4HA64XC6cPHkSP/74I3799VdWck0uSY/H06w9H6mEOhAIsCRqoYBMvRfFYjGOHDmCkydPIi8vDzKZDHq9nrn/ADCHZFlZGWJiYuD1ehEXF8cSpgOBAOvtqNPpoFKp2P4QliqTUKtWq6FUKplgSY5FEjypjyi5TSmBOiYmhqVNq9VqNs/JkyfhcrmQnJwMs9nMSsTrC4skQNLj+uX4wnnJ6Uiicm1tbdRx31Lh5gNuPvijmg+2bduGjz/+GIsXLz6v17Vu3RoAGhgVLgZuPuBwOC2JFl1q7fV6MXr0aEyfPh0AcPfdd8NsNuPee+/FBx98wASofv36ITc3F8uXL2cfgh07dkRhYWFUOcmYMWOQm5uLt99+m/Xfe+ONN5hIOXjwYADApEmTcPXVV0eNJRKJ4MEHH8TNN9+M9evXs4u8SZMmIS8vDzNmzMDGjRvPaZ327t3LPsRNJhOmTp2KAwcOsD4g8+bNY4mJADBx4kS0adMGTz/9NE6cOBHlkruYbbRw4UIcOXIEe/bsQXZ2Nlsfs9mM+fPn44knnkBaWtpZ10nIF198Ab1ejw0bNkT1tDodFRUV6Nu3LzweD7Zt24ZWrVoBAFatWoWvvvoKW7duxY033sjm79ChAx588EH88MMP6N69O0aPHo0HH3wQmZmZDUqHp0+fjoqKCvz0009RIt9zzz3X4MtTbGwsNm7cGPUF8JVXXoHNZoPBYDivbfDEE0+wsmaxWIyhQ4di6dKl7Pny8nIAQHJycoPXJicnw2KxwOfzQaFQnNdygVNick1NDUKhEA4dOoTHHnsMADB8+PCo+d5++228/fbbDV7/wQcfYNSoUTh06BAANOhNE4lEUFtbGzXNaDSy/lkcDofT0iGXoNDxSKIfnQOoBDYvLy+qL6LBYEAkEkFcXBwAsF57lEwsl8vhdDrhdDqhVCrRqlUr/PrrryguLoZWq2Xz1nc9krBWP/RF2MOQfqiHn9vthtfrZaImCYUkKgJgfQClUikUCgWMRiMkEglqampgsVggEomQnJyM5ORkHDt2DMXFxejQoQOSkpIAgKU9N/bF83IQCoVgtVqZ6AhEC3lUah0IBLBnzx6kpaVBq9WyHpzkaqTSZI/HA5fLBZ1Ox7ZLMBhkATFUYk4BM7Ttqb9kKBRiIUMikQglJSWIjY2FXC6PSqn2eDxQqVQs0MXj8bAbgBKJhInDIpEITqcT1dXVEIvFcDgcyMzMZMeZsASf3ptCZmhsBP1N8wWDQXi9XhQWFrLelC2tv+OZoBvrPXv2xEsvvYSVK1di8uTJ0Gg0+Mc//oF77rkHQ4cOxeuvv46xY8fi+uuvR0ZGBoDfzQfDhw9HRkYGKisr8cYbb6BXr144ePAgzGYzgN/NB+Xl5Zg6dSqSkpKwatUqbNmypcF4vv76awwYMABdunTB7NmzIRaL8e6776J379749ttvo9xip+PFF1+EWCzGtGnTYLPZ8NJLL+Gee+7BTz/9xOYRmg9iY2OxY8cOvPrqqygpKcGaNWuabBuR+aC0tBSTJk1Ceno6fvjhB0yfPh3l5eVRwtn06dOxfPlyHDt2jAlkjUHmgz59+mDevHkATgUpfv/995g6dWqjr6mpqUG/fv1gsViwdetWZGVlMfPBd999h4kTJ6Jdu3bYv38/Fi1ahMLCQtbT8f3338f999+Pbt26sRZFWVlZAH43H1itVkycOBG5ubkoLS3Fxx9/DLfbHfWZNmXKFJhMJsyePRvHjx/H4sWLMXnyZHz00Udn3af198eUKVNw//33o2PHjmecl66ng8EgioqK8NRTT0EikeCmm246r2WeibOZD+pDN2vIfHD//fdz8wGHw2kyWrxacP/997O/jUYjcnJycPjwYYwYMYJNz8nJgdFoxNGjR9k0oWhDF65arRY5OTnYvXs3e+7LL79ESkoKbr/9djZNqVTigQcewBNPPMGm7d27F0VFRZgxY0YD4aVPnz54//332QXhmZgwYULUya5Hjx4ATl0kkcgjFB1dLhc8Hg+6d++OSCSCPXv2RAmPF7ON1qxZgx49esBkMkWdgPr27YsXX3wR27ZtY27MZcuWYdmyZWdcN1q+y+XCpk2bcMstt5xx3pKSEvb+27ZtQ0pKStTY2rVrh9zc3Kix0d27LVu2nDHYJBwOY+3atRg0aFCjzsL6rpKJEydGTevRowcWLVqE4uJiXHXVVWdcj/o8+uijuPPOO1FWVobVq1czNwVBd60bExYprdPj8VyQ8Dh79mzMnj2bPdbr9Zg3bx6GDh0aNd/gwYMbdXTShZLdbgeABhccNpsN8fHxUdN+/vnn05aTcDgcTnMjFFr8fj8THSlxmhxk1PswEonAYDDA7/dDrVajc+fO2Lp1K3Q6HZRKJRQKBWw2G2JiYgCAlcpSGSyJRSRU5ubmoqSkBCaTCenp6excI7xeEAabCAUven9hIIrH44kSKD0eD6qrq+FwOFipeEpKCktLDgaDqKurQygUYoJaQkICYmJiYLVaUVBQgNjYWCQlJcFoNGLr1q24+uqrkZ6ejkgkAofDAZPJFCWCEpe69yOFAFEyOJW3A4gqiya3Zvv27dm2ov1AwrJEIoHb7YZMJmPvSf0VSaQUljLT8qnsnAQ9jUbDRF6JRAK/3w+VSoVAIAC32836KFIaNgB2A5NKxMmFSO8dDoehUCgQDoeRmJjIzv/Csmk6Lk7X67P+tGAwiKqqKsTFxUEmk8HpdLLS8z8C3HxwCm4++OOYD15//XUUFxfjq6++Ouu8lZWVUQaE1NRUrFq1Crm5uee8vPpw8wGHw2nJtOhPCqVS2UDkMBgMSE1NbXDhZTAYUFdXxx6Hw2EsWbIE//73v3Hs2LGo0hLhnZ/i4mJkZWU1eL82bdpEPS4qKgIAjBs37rTjtdlsMJlMZ1yn+qIhzS8c+4kTJzBr1ix8/vnnUdNpGUIuZhsVFRXhl19+afB6oqqq6ozr0hgPP/wwVq9ejQEDBiAlJQV/+ctfMGLEiEZFyDFjxkAqlaKgoIC5K4RjKygouOCxVVdXw263N5om1xjnsl/OldzcXHbhMHbsWPzlL3/BoEGD8NNPP0EkErELSmG5CEHuCOFF5/kwceJEDB8+HGKxGEajEXl5eY0KmKmpqejbt+9p30en0wEAnE5n1HStVotNmzYBADZu3Ij58+df0Dg5HA7nckPCFQlM5JajklgSJakMllyPbrcbmZmZOHjwICQSCVq3bg2JRAKXy8XCP4R9BEnIouCWhIQEhEIh7N27F3q9Hmq1mjkkha5G4PfSWaHDMRAIMPdaIBCAWCxmvRxtNhssFgtSU1ORlZUFvV7PglQIcjsKe/75fD5WWmowGHDkyBFYrVYYjUbk5+dj9+7dkMlkSE5OZjfCLrfzhRyG5ASl/SQWi9m2AE6dNw8fPozMzEzWUzEYDEImk7HzrEwmY70ZQ6EQ1Go1DAYDVCoVE31DoVCU85XcpOFwGF6vF3q9HiqVCg6HA+Xl5TAYDGw719TURIl6EokETqeTidfkTiUBMBgMwmg0wuPxoLy8HCaTCb/++itSUlKg0+mYU5XGTsJjYyXVQuGRjp1AIIDCwkLYbDZkZmYysfSPJhBw8wE3H/xRzAe1tbWYNWsWZs6cedrvLkJiYmKwadMmeL1e7NmzB59++mmDa+7zhZsPOBxOS6ZFX4Gc7m7Z6aYLL8Tmzp2LmTNn4t5778WcOXMQExMDsViMRx99tEHvknOBXjN//vyoZDAh53JRfraxh0IhVnLw97//Hbm5udBoNCgtLcX48eMbjP1itlE4HEa/fv3w5JNPNjpv/XSzcyEhIQF79+7Fhg0bsH79eqxfvx7vvvsuxo4di+XLl0fNO3ToULz33ntYsmQJXnjhhajnwuEwOnbsiIULFza6nPO9C3s2zmV7XSh33nknJk2ahMLCQuTk5LA7nFRyLaS8vBwxMTEX5HYEgOzs7DMKiucKCacHDhyImi6VStn7l5SUXPRyOBwO53ISDodZeTQ55shlGAgEoFaroVAoovro6fV6pKSk4OjRozh58iSUSiViYmLg8Xig1WpZ2a3Q5Uav9/v90Gg0yM7ORnV1NQ4ePMh6ENpsNmi1WlbmWz8shcQ2ej8au8ViQWVlJSQSCVJSUtCxY0fmlhP2MxQGxgBgJcckqqpUKiiVSpjNZsjlchQUFMBqtSIpKQm5ubkoKChAeno6AoEAbDYbc/LR+19qhA5H2hYk6FLPRZ1Oh5MnTyIYDEKv10OpVEKpVEImk0GlUiEYDLI063A4zNyJMTExLKWatq3L5YJMJmMJ17TtSIymMnra736/H3q9Hm63m4nNoVAIXq+XuSnJKUpOS+CUKBYTE4NQKITi4mJ2nWG1WtnNQppGyetAtPuRtk/9/o803oKCAng8HiQmJsJut7OeleS0vFz78GLg5gNuPvgjmQ9mzJiBmJgYTJky5Zzml8vl7Hp64MCB6NOnD2644QYkJCRg4MCB57xcIdx8wOFwWjItWni8GD7++GPcfPPNDazkVquV9WYCgFatWuHgwYMNLuDqN3umniF6vb5JhJ3TsX//fhQWFmL58uVRYTL0Qd+UZGVlwel0Nvn6yOVyDBo0CIMGDUI4HMbDDz+MN954AzNnzoy6mJsyZQratGmDWbNmwWAw4Kmnnooa2759+9CnT5+zXhw39nx8fDz0en0D4aw5oNJqumBMSUlBfHw8du7c2WDeHTt2nFbYvpzk5OQgOzsba9euxeLFi6HRaJp7SBwOh3PRhMNhyGQy1tdP2N+PBKtIJML6/1FJbmxsLHJzc7F//35UVFTA5XKxJGO32w2pVMo+JyUSCZRKJeu9SA66jh07YufOnTh27BjMZjMMBkNUQjHwe4AMlYNTSja5+I4ePQqv14vs7GwYjUYmcAmdk/ReVKJNycnkoqNtQO43kUiEmJgYpKam4ujRowiFQoiNjYXT6WSiFbn2NBrNOZVQNgUk3tJ+UCgUbN+RixM4FZyg1+sRHx8PmUwGuVzOfpMLkcTcYDAIrVbLgmOoDLu8vBwVFRVIS0tjwTBWq5UFwIhEIlgslqj+nFqtlu0f+tvtdkOn00EkEjE3bCgUYj0bSZSUyWSorq5mYUZVVVVISEhgoUUUiiPs5VjfTVc/BZ3GZrPZUFRUhOuvvx4+n4+V2RuNxqhjrf51b0uDmw+4+eCPYj4oKirCm2++icWLF0cFmJIz+/jx49Dr9aw9R2N0794dycnJWLly5QULj9x8wOFwWjJXrPBIXySErFmzBqWlpVHiV//+/bFp0yZ8/vnnrL+L1+vFW2+9FfXaLl26ICsrCwsWLMDdd9/d4AKjurr6nKz15zJuoGEZzdkS4S6EESNG4JlnnsGGDRvQv3//qOeoLIW+mJSXl8NmsyErK4vdtW+M2traqLvJYrGYlSk0Vlo8c+ZM2O12TJ8+HQaDAQ899BAb2//+9z+89dZbrGE0Qf2t6EueRqNpkAInFosxZMgQrFixAjt37mxQBnApLrjpi4OQQCCA9957DyqVCu3bt2fThw0bhuXLl+PkyZPsAmrz5s0oLCxkPVno9UeOHIHBYGg0jOZS8swzz+Cee+7BAw88gOXLlzfY73+UBvUcDodDwhM5n0iMIoGP2mBQ2TSlCZPApVarkZycjKNHj6K2thbx8fGw2+0Qi8VQq9WIjY2F1+tl5dnAqZtwPp+P9RrU6XRo06YNjhw5EiX8CcNCaIx+v5+FyCgUCtTV1eG3335DXFwc2rdvz4QzYeoxraMwkIScgvR5TeXgQtcn/ZjNZjidTlRUVESJniqVigWziMVi5vC81NCyaT1pn8nlcng8HkilUhw9ehROpxNms5n1SKZScpfLxdaXyrOpPJ7K6qVSKaqqquByuZCbmwupVMrSwKm8mrZFMBhkrk9ymEqlUvh8PiYIUSI6lVqTQEmOWoPBAJ/Px9LD4+LiUFdXh7KyMuTk5LB1UCqVUX0dhaKjUPyknpHC3qBlZWVISkqCUqmEy+ViYqRarY4K6bmS4eaDs8PNB01HaWkpwuEwHnnkETzyyCMNns/IyMDUqVPPmnTt9XobuFqbA24+4HA4l4IrVngcOHAgnnvuOUyYMAHdu3fH/v37sXLlSmRmZkbNN2nSJCxduhR33XUXpk6dyu420cWfsAn8f/7zHwwYMAB5eXmYMGECUlJSUFpaii1btkCv12PdunUXPe7c3FxkZWVh2rRpKC0thV6vxyeffHJBvQbPxt/+9jd8/vnnGDhwIMaPH48uXbrA5XJh//79+Pjjj3H8+HF2gXauiXb3338/LBYLevfujdTUVBQXF+PVV19F586d0a5du0ZfM3/+fNhsNvz1r3+FTqfD6NGjMWbMGKxevRoPPvggtmzZghtuuIE1S169ejU2bNjAxMQuXbrgq6++wsKFC2E2m5GRkYH8/HzMnTsXGzduRK9evVgqXnl5OdasWYPvvvsORqOxSbfnpEmTYLfb0bNnT6SkpKCiogIrV67EoUOH8PLLL0eJ1U8//TTWrFmDm2++GVOnToXT6cT8+fPRsWNHTJgwgc1XWlqKdu3aYdy4cefUX+dcKSwsxIoVKxpMT0xMRL9+/QCcalJ+4MABvPDCC9ixYwdGjRqFjIwMuFwuHDhwAB988AF0Ot1ZS4s4HA6nuSH3nzD5l6YBp4Qe6r0mDHqh10ilUhiNRrRp0wbbt2+HRCKB2WyGTqeDz+djPRTr6upgNpvZa6j8lQTNVq1aobq6GrW1tax/JDkXSSRzu92sxDgSiaC4uBglJSVo3749kpOT2dhpjEJITCT8fj8LYKHnSLyjABwATHAzGo1wOBxwuVzQ6/VMZHS73awv5OUs1aVl0LYUOkglEgnKy8tRW1uLtm3bwmazweFwwGw2R4my1DMvGAxCrVazHp6lpaVQq9UoLy9HRkYGE6BFIhGUSiVzn3o8HuZCDIVCkMvlbD+R85VEwtraWni9XpZqrdfrmeM0Eomw97LZbBCLxbBYLCgvL2euUyr1JqGRlgv87mwkcZoEVRo3Ca5lZWVo06YNfD4fZDIZ3G53lDB5IY6/PxrcfHB2uPmg6T6/OnTogM8++6zB9BkzZsDhcGDJkiVMvKabAWq1Ompe+q4nHCs3H3A4nCuJK1Z4fPrpp+FyubBq1Sp89NFHuOaaa/DFF19E3VEDTpVGfP3115gyZQqWLFkCrVaLsWPHonv37hg2bBgTIAHgpptuwvbt2zFnzhwsXboUTqcTSUlJyM/Px6RJk5pk3DKZDOvWrcMjjzyCF154AUqlEnfccQcmT56MTp06NckyCLVaja1bt2Lu3LlYs2YN3nvvPej1erRt2xbPPvvseSW5EaNHj8abb76Jf//736xX1MiRI/HMM8+csen266+/DqfTiQkTJkCn02Hw4MFYu3YtFi1ahPfeew+fffYZ1Go1MjMzMXXq1KgSkIULF2LixImYMWMGPB4Pxo0bh/z8fKSkpOCnn37CzJkzsXLlStjtdqSkpGDAgAENTvhNwciRI/H222/jtddeQ21tLXQ6Hbp06YJ58+ZFNS4HTpWJbN26FY8//jieeuopyOVy3HbbbXj55ZfP2t+RTvYXU+62adOmRu+g9+rViwmPwKlypf79+2Pp0qV45513UFNTA5VKhbZt2+KJJ57Agw8+2KA3D4fD4bREqJ+j0CVGog19qRIKevRDIpdcLkdaWhqOHDmCn3/+Gd27d2eCj8PhYMnY5LQjZxz1F5RIJAiHw8jIyEBhYSFqamogkUhQVVUFkUgEjUbDAk0Iu92Ouro6dOrUid3kEQag+P1+5pgkEVWY6CwsVyYxhlyQ5PaUSCTMtafX65GdnY1vv/0WJpOJuTapryGJbpcqGfl0idkk3NFyqfTcarUiGAwiFAqx0BYKjKFSa9o2oVAIgUAAsbGxcDgcLOU6JiaGORrlcjlbTyq7VygUMBqN8Hq9zNUaDAahUCjg8XigVCpRVlYGp9OJcDgMh8MBhUIBr9cb5aZVqVRsnOSWra2thc1mQ2pqKnPcNlYKLez7GQgEotyQtN8dDgeOHDmCpKQkts603SjQqH7w0JUKNx+cHW4+MDbZtoyLi8OQIUMaTCeHo/C5oqIi9O3bFyNHjkRubi7EYjF27tyJFStWoHXr1pg6dSqbl5sPOBzOlUSLEB7Hjx+P8ePHR007XYLaN9980+h7HD9+POqxQqHAggULsGDBgrO+PiMjA//3f/8XNY1OFqmpqVHTO3fujE8++aTRMZyJm266qdG7Q61bt24wvV27do2KQvXnu9htBJwSXufOnYu5c+eefvBnWFZ9hg0bhmHDhp1xnsb2t1gsxqpVq7Bq1So2TSaT4cknnzxt/xkiJycHW7dubfS59PT0Bn1lzjYW4PT760yMGjUKo0aNOuf58/LysGHDhjPO09jx4XA4AJwq+TnTfKfjfNerV69e6NWr13m9hsPhcFoSFFRCohu54YRiHKX+Ut9HEvgorZYCWTIzM/Hll1/i5MmTSExMZInJ4XAYZrMZ1dXV0Ol0LOGahCePx4NIJAKTyYQOHTrgwIEDKCgoQCAQQHx8PFQqFfx+P8rLyyEWi5lbLSUlBW63G3q9nr0fiXAkHlLCM/B7WS454EhsEqZ4U6/EYDDI3JVC8ZVKw4PBIDweDwwGA+tdSNulfthJU+8v4boIxwWAlTiTYKtUKmG1WpGeng61Wh2Vhk0CIgXQ0OPY2FjY7XbIZDJYLBbs2bMHFosFbdu2RZcuXdh7ULm1RCJhidMk/qWlpSEQCKCqqgoajQYajYa5HQOBAEpLS7F//36EQiEkJiaidevWiI2NZcfL8ePHEQwGce211zIBnNaZjjsSHMm9WldXx0KH6Jgkt2dKSgoCgQBcLheUSiVLdCb36rkkL18JcPPB2eHmg+YhNTUVw4YNw9dff43ly5cjEAigVatWmDx5Mv7xj39EOUYbg5sPOBzOHxVRhHul2UUi4fV6cfXVVyMUCqGwsLAZR8bhNGTz5s3o27cvVq1ahbvuuqu5h8PhcDiXFbvdDoPBAJvNFnUD5nSQc7Gmpoa5HYWl1+SQE4vF8Pl8kEgkUKlUrPRZ6I6srq5GdXU1vvjiC0QiEQwZMgRSqZQJSenp6bDb7ayfn0qlYmXXQqehVCpFRUUF7HY7KioqUF1dDbVaDYfDgdjYWMTGxsJqtSIjI4MJRl6vlznjSHgkgVQosJEY6fP54Pf7mesyEAiwvpHU89Dn80Eul0OlUsHhcLAxfPnll8jPz4fJZIoKbRH2WqTy8aYUHoUhG1TqTOspFFtpe6xfvx4VFRW46aabUFxcjJycHMhkMshkMphMJtZz0+Vyobq6GnFxcVAoFKisrIRMJoPD4YBSqYRCoYDb7caxY8cgFotZWjkJlQ6Hg/WbpFJPEoftdjusViuMRiNzhpaUlMBisUAsFkOpVCIxMRFutxtffvklOnXqhISEBBQVFaGkpARmsxm9e/dmJfe0XWk/Op1OlJWVwWq1QqlUQq/XIy4uDlqtlpXo2+12aDQaBINB1NTUMPHaYDDgu+++w0033cQCg9LT05kYLdx35/t/dSWzePFiPPbYYygpKUFKSkpzD4fDYdD/6YwZMzBnzpzmHg6Hw+GcMy3C8djcDB06FOnp6ejcuTNsNhtWrFiBQ4cOYeXKlc09NE4LwOl0wul0nnGe+Pj4S570+csvv7ByktjYWNx2222XdHkcDodzJSB0+wnDZQKBQJQbUCjk+f1+9pku7KNHKcRGoxE1NTXYtWsXrrrqKigUCrhcLtTW1kIikbC+iiRe+v1+lo7s8/ng8/lgMpmYQNaqVSvWh9Hj8TAhqa6uDlKpFHFxcYiNjWX9/mhdyFVJbkVhH0sau3CdSDDz+Xxwu92wWq1Qq9VwOp04cuQIkpOT4fF4oNfrYTKZEBMTw0JJaF1oG9L7N7XrUdiPkARhYXk5OQMpIZrSySORCKqrqxEOh9GhQweWCk0iJr2OhF/ajw6HA3K5HDExMUhMTMTx48ehUChY+jQA5h6kcWm1Wvj9fjidTpZ8rtfrodfr4ff7kZKSgpSUFLbP6fVOpxP/+9//cNttt8FisaB169ZMDKXjjUTxkpISFBUVwev1IiUlBW3btkVsbCxbL5fLxVy6Go0GbrcbDocDNpsNfr+fiaJUak0i5Z+h1Pp8aMx88MYbbyA7O5uLjpwWx88//wwAUYGVHA6H80egWYXHf/3rX5g/fz4qKirQqVMnvPrqq+jWrdtlH0f//v3xn//8BytXrkQoFEL79u3x4YcfYuTIkZd9LJyWx4IFC/Dss8+ecZ6z9b1pCj799FO8+OKL6Nq1KxYtWvSndyRwOBzOuUBCFpX6kRhFomMkEmF/k5suEAiw3ojCEA9yD4pEIiYyUVlrIBBARUUF0tPTIZfLUVdXxwInJBIJvF5vlFMuFApBr9cztyIJYnFxcSzNmnpIUh9GEppICKTAGKVSCa/XG+WUo96HwWAQIpGI9WeMRCKoq6tDeXk5IpEIe53b7UYoFEJRURESExOhVCqjgk7q9xyk/pJNLT7Wd+IJA2WEy5JKpTCZTDh27BikUilSUlJw9OhRdO3aFT6fj4mLtC9pH0qlUtZPUSaToaqqiol3kUgESUlJTGD0eDysF6RGo2GJ2uQmFYp6crmcCX0kZAkF4VAohISEBEilUhw8eBAxMTHIyMiARCKJ2qeRSAS7du3Cvn370KlTJ+Tn50OtVrN1p8Rzt9vNRMiysjI4HA4WCJKQkACn0wmr1QqTycTW7c9QZn2+cPMB50xw8wGHw+E0Dc12BfLRRx/h8ccfx+zZs7F792506tQJ/fv3R1VV1WUfy6OPPooDBw7A6XTC4/Fg165dXHTkMMaOHcv6oZzu53L0OHnmmWfg9Xrx3Xff4dprr73ky+NwOJz6bNu2DYMGDWLJwWvXro16PhKJYNasWUhOToZKpULfvn1RVFQUNY/FYsE999wDvV4Po9GI++6776xf7C4WYUgMuRupJJf6JpI4RS47YbAEhbOQuzA+Pp4JWBaLhQmZPp+PiVsul4sFxQink5gpk8mg1Wqh0+lYeiz1kqQyWoVCAbVazdx5VHJMfSjJHRcMBmG325krj0qUyc0pDJcpKSlhwTb0/G+//Qaj0YhAIIDa2lqYzeYokZWclcJE5EvtnKsfLlM/YIZKiZ1OJ+rq6lj/MZfLBZvNxoQA4XYnByiVYNNjckT6/X54PB6EQiHY7XYAp9yl5Fx0OBzwer1RIT3kQnW5XEyo1Gq1CIfD8Pl8CAaDcLvdqK2txdGjR5GVlYWysjLk5ubCaDQykZf6e65fvx4nT57Ebbfdhs6dOzPRMBKJMBHEYrHA6XTi+PHjKCgoQFlZGUuv9vl88Hq9UKlUOHHiBBITE1nAUUtKtP7Xv/6F1q1bQ6lUIj8/Hzt27GiWcfTv3x/ff/89/va3v+HZZ5+FQqHAhx9+iLvvvrtZxsNpWSxYsADJycln/Dl58uQlH8enn36Kp59+Gq1bt8b69eu5+YDD4fzhaDbH48KFC/HAAw9gwoQJAE41Fv7iiy/wzjvvNGj+zOE0J5mZmQ2SEDkcDufPiMvlQqdOnXDvvfdi6NChDZ5/6aWX8Morr2D58uXIyMjAzJkz0b9/fxw8eJAFNdxzzz0oLy/Hpk2bEAgEMGHCBEycODEqXKypIaGPyoSpTFcYquL1egGAjVPo9CNXGglWcXFxKCgogMFgYOEkOp0O4XCYOQdjYmJQU1OD+Ph45lYLhUKsVyI5LIVuOpfLBbfbzRKyaflUPk2JyiTKkUuSUrOph6Pf72fLIqej0+lEeXk5E0Op9JeEU51Oh/LyctabUqPRAPhd9KPXCV2PwhLoptxXJDCS2ChcpvA3rXNlZSUrZw8EAixBWiiaCkuuhe9jNBrhdrtZWI3L5YpaJ+r7SdtLLpez7UsCo9D9SOnkNTU1TLylXo+0TuS+NBqN0Gg0kEgkOHLkCH744Qd06NABubm5TKB2uVxsHWw2GwKBAAKBAKxWK6qqqqDT6aBUKuF2u6FSqdjxRX0hKayi/rZsTsh88PrrryM/Px+LFy9G//798dtvvyEhIeGyjuXRRx/Fo48+elmXyfnjMHbsWNx4441nnOdymQ+eeeaZS74cDofDuVQ0i/Do9/uxa9cuTJ8+nU0Ti8Xo27cvtm/f3hxD4nA4HA6HcxYGDBiAAQMGNPpcJBLB4sWLMWPGDAwePBgA8N577yExMRFr167FqFGjUFBQgC+//BI///wzunbtCgB49dVXceutt2LBggUwm81NMk5hn0Oh21HYJ5CccCTEUA9A+ru+4EXlvWq1GgaDASKRCE6nEzExMayHpEKhgM/ng06ng16vh9VqZSInuSuFJdw+n4+JhwqFgrkmKZFa6IQUjlMonAlTpoUpyDSNkpBtNhsTIT0eDywWC3Pq5OTkADgVXJCTk8P6T5JrUDhOKvG+VKWFtG7C9RRC5eQAoNfrERMTg6qqKmi1WgQCAeZOlMlkUUEwQhciOUIJ6vMnlUpht9tZwBC5Rb1eL2pra5kzkcrfA4EAwuEw6zUJgDldtVotDAYDE5Tlcjk6duwIlUoFu92OnTt3wu12w2w2Iy4uDjqdDn369GHBRiKRCG63mzl07XY7K2+nkvsOHTowp6vZbGbHNAmlZrMZiYmJbHsK+0g2J9x8wPmjwM0HHA6H0zQ0i/BIyZJ0MUQkJibi0KFDDeanRuxEOByGxWJBbGxss188cThXCpFIBA6HA2azmfeB4nA4582xY8dQUVGBvn37smkGgwH5+fnYvn07Ro0ahe3bt8NoNDLREQD69u0LsViMn376CXfcccclGRuVCQtdjMJU5kAgwNyMQlEvFAoxEYfckhqNBiaTCcnJyaiqqkJycjJCoRATr0j8oj6ATqeTlWiHw2HWJ5DET7VazcZJvQcDgQC8Xm+UY5FKpUOhELxeLyQSCTweD1wuF6RSKZRKJVsmjcXtdqOyshJqtRoKhYKNs7a2FseOHUMkEkFCQgLi4uIgk8lYr0RK0qZtIRQahSXP5E68XGXXtA9IcFWpVEhMTMSxY8eQmpoKvV6P2tpatG/fno2dtrtCoWDjFfbNDIVC8Pv98Hq9UKvVMBqNCAaDTEyORCIsqZy2q0ajYccS9cikPp6RSISJjpQSTvsiFAohLS0NycnJKCoqQk1NDROgATDhmvpFUmK1VCqF0+lk+5iW7/V64XQ6oxKw4+PjoVarceLECaSkpLAyaxqjUMBuDrj5gMPhcDicPx9/iFTrF1544azhHhwOp2k4efIkUlNTm3sYHA7nD0ZFRQUANHpTkZ6rqKhoUEoplUoRExPD5qlP/ZuP1HvvfCHRSSgm+v1+5iok8YaEKirVpTJmErLI4Zaeno7i4mL4fD5W2ksJxx6PB16vF1KpFMFgkDnjaLkAWIm1sFcjOdnoMf0WuvwAsFJb6vVIvQQpNfv//u//0KVLFwBATEwMG5vb7YbFYsGOHTsgk8mQmJiI9PR0KJVKlJSUQCKRsCAT2mbCYBdafxIdaZ5LjXB7CJcpEomg0WhQW1uL2tpa+P1+5ObmstJ4SvIGENXfk/YnBfjQewFgwS06nQ6BQIClf5MIKZPJ2P4kh6nX62Wv12g0bHvb7XYoFAp4vV6WvC2RSGA0GqHVauH1elk4kV6vh8fjAXDqmHc6nSztWljuTqX0TqeTlYZrNBrWAgAAjh49ColEAoPBwER12gb1XbyXm/M1HwDcgMDhXA64AYHD4VxKmkV4jIuLg0QiQWVlZdT0ysrKRvtkTJ8+HY8//jh7bLPZkJ6ejpMnT/LmuhxOE2G325GWlgadTtfcQ+FwOBzGxd58FAosVEJLzjQqaSbhRviaSCTCpgnDTaiXX1paGmJiYmCz2RAbGwu3283KXP1+P5RKJXQ6HROHpFIptFotgsEgczwKBU0Kr/H7/Sxlu/56kBOSxkxlvOFwmIXCiMVi+P1+FBcXo1u3bsyR5/V6YbfbUVBQgKNHjyIvLw+dOnWCTqeDx+NBZWUl2rZtC7VazQQqYQ9HoQgqHFt9YZa214Xsp/oIt7twPionJyjBuq6uDkajkTlXqTSZtis5JanXI4m2kUgEVVVVMJlM8Hq9LGDI6/UycZqSqmlZ5IoUiUTweDyQy+XQ6XSsBLuuro45FMPhMDvmFAoFlEoltFotSxWnMdD2pnTs6upqNs76y5TL5VAoFNDr9XA4HADAjgePx4OkpCQWoEM/QqfmHwluQOBwLh/cgMDhcC4FzSI8yuVydOnSBZs3b8aQIUMAnLpw3bx5MyZPntxgfoVCwe7WCtHr9Vx45HCaGO4e4HA4FwLdOKysrERycjKbXllZic6dO7N5qqqqol4XDAZhsVhO26C//s1HuklyrpBYGIlEIJfLo8JC5HI5C+sg4Y8ELWEpNomX5LqTSCSIj49HRkYGfvvttyih0ePxQKvVMsFLrVajtraWOdjEYjF8Ph8r6ZXJZKx0ORwOM9GLwnCETjyfzwe32w3glADmdruZoCaXy1FdXQ2TyQSj0Qi/3w+LxcIclFVVVSgqKkJSUhK0Wi0AsORsj8cDmUyG1NRUKJXKBv0kaf2FoiONjdyPTXXuEC7rdM/R32KxGMnJyQgGgygpKUF8fDzbbsJScRL9SLijsnFytpLblI4J6sMpk8lQU1MDpVLJppOISOXtVEovTM6mMZITkn6LxWKoVCp2rHm9XibmBoNBOBwOuN1uSCQSOJ1ORCIRmEwmWCwWeDwetg5t27aFXC6HVqtlLQJCoRCsVisqKiogFouRmJjItgeV+guF9ObifM0HADcgcDiXA25A4HA4l5JmK7V+/PHHMW7cOHTt2hXdunXD4sWL4XK5WKNpDofD4XA4fxwyMjKQlJSEzZs3M6HRbrfjp59+wkMPPQQAuP7662G1WrFr1y5WCvz1118jHA4jPz+/0fc93c3Hc0VYEkwuPiqRJecbEC2yUTm2sC8kCZFC913r1q1x4sQJlJeXo0OHDhCLxXC73Swp2Wg0QiQSweFwIDExEVVVVdBoNFFiEQWCAIhyGFIQTSgUQjAYZKXhQsEvGAyypGupVMrCVIxGIw4fPozs7GxIJBJUVFSguLgYBoMBHTt2RElJCRM3xWIxHA4HS4QOBAIsUZucjEIRj4RZ+k3lw00dNiMUGYWuS+H2oRAXjUaDqqoqKBQKOJ3OKMcjlUYDYA5IYfk17WONRsOSrem4oBJfg8HAksGF5egk+FKatLAfqFwuh9vtZqnUYrEYCoUCDocDHo8HDoeDBfaQ47G0tJSV6huNRtazUqPRICYmBiqVioncVHrt8XhQXFyM2tpayGQydOjQAampqZDJZEyEpX3dEm4snq/5AOAGBA7nctISPic4HM6VR7MJjyNHjkR1dTVmzZqFiooKdO7cGV9++WWDni8cDofD4XBaBk6nE4cPH2aPjx07hr179yImJgbp6el49NFH8c9//hPZ2dnIyMjAzJkzYTabmcDQrl073HLLLXjggQfw+uuvIxAIYPLkyRg1alSTJVoLobJa6tsIRKdch0IhVsJMjrDTufeEISAk/iUmJsJsNqOsrAx2u50lIwvLeb1eL1QqFSwWC3PiGY1GVspLAhb9JvFRKEKSA8/n8zGHZCAQYIIjCYRKpRIulwt6vZ4ty263o6qqiqUgG41GxMXFsaRtKgW22WysxyCtI/VIJNFHKL4KRcCm7PMoLOmmZQpdl9RfkfovAqdCeWpqamCxWFBRUcFcfiQgA2D9HUmAI1GXyu+lUilcLhf8fj90Oh0cDge8Xi8SExOZU5YCbZRKJXNOyuVyduyEQiFWVu92u1l/yGAwCI1Gw/4W9v2kfpJUok0uWNr/iYmJTGgkoRI4JaKWlpYywbVdu3Zo1aoVCygiUZncjpcqhfxC4OYDDofD4XD+XDRruMzkyZNPe3eTw+FwOBxOy2Lnzp24+eab2WMqfxw3bhyWLVuGJ598Ei6XCxMnToTVasWNN96IL7/8Ekqlkr1m5cqVmDx5Mvr06QOxWIxhw4bhlVdeadJxCsujSUwkkYkEJxLNVCpVVD9A6ulHTj4SfCj5mFxy5GrLy8uD0+lERUUF4uPj4ff7YbPZIJfLWRm0Wq2G2+1GJBKBXq+HxWJBXFwcxGIx7HY7DAYDWxYJUsLAGRIVyZ1H49BoNHA6nWydKBU5OTmZiYp1dXUwm82IjY1FQkJClMBJqdpKpZKVZIfDYVbWS70LqYRYKAAKxdlLETAjLOmmEmPaHvRD40xJScHJkyfh8XjgdDqZ2EsCLQmNVBItLGsnVCoVK1WnPqAKhQIajYa5QGUyGQuLobL5cDjMhMTS0tKocnqn04na2lpIpVKUl5ezFHRyP5IIHQgEIBaLkZaWBr1ez/aNVquFTqeDy+WCy+Vi28Jut6OiogIajQbdu3dHfHw8O2ZJWKXjtL7o2BLcTNx8wOFwOBzOn4s/RKo1h8PhcDic5uemm246o8gkEonw3HPP4bnnnjvtPDExMVi1atWlGB6DxkhCjTDAhcQochHSb7lczpx2JNSQWBkMBuH3+wGApROTqJmUlISEhAQUFxfj2LFj0Ol0cDqdTKQi0ZVKcFUqFRwOByorKxEbG8tERIPBwJYdDAYBgAmBwKmydeoVSEKY0LlHwSgkYBoMBlRXV0Oj0aBVq1bQ6/VQKBSIRCKIj49HUVERXC4XK8d1uVz47bff4Ha7oVKpoFKposqOqZRY2O+ShFWRSASdTnfRwSXCUncSG6lMmrYhcMrtR25MEmXJlUnBLCTACUvrybEJoIGIS3+TAEv7grYBiYUulwtWq5X1Tzx58iS0Wi0Tlil1ura2lpXJk+MxPj6e9d+kRO1QKASHw4G4uDi43W6Ew2HI5XJoNBrW/9Rut6OmpgYejwexsbFISUlB586dmdMyHA4zsRoAE1Tp+ZYYKMPNBxwOh8Ph/HngwiOHw+FwOJwrFmEZMomHVK5MJa3kMBOJREzAoulUYk0CGAlWQpGnY8eOcLlcOH78OFq1agWNRoNIJAK3281CS0QiEdRqNSwWCxITE3HixAm43W7ExMTA6XTC7/cjLi6OCW9Op5OV1spkMiZYBgIB6HQ6yGQyJkRSP79gMMjSq6VSKZxOJ/Ly8piQSGPv3LkzwuEwvvnmG6SkpKBVq1ZIS0uDXC5HSUkJtFotpFIprFYrIpEIWrVqhbZt27Iy3kAgAIfDEbW9iItx1FFfRbvdzvYbuTOp7ySVEQNg5eQUsiISiZCQkMBeQ45EYcm60A1LfRKpNycFxwj3vUKhYGKwx+NhonRFRQVzJ1qtVtbL0263s2RqsVgMo9HIHLMqlQoejwe1tbXwer1wuVzQ6XTQaDSorKxkzliho9Pj8SAxMRGtWrVCXl4eDAYDdDod6xNK60Ll+iR20vMtweHI4XA4HA7nzw0XHjkcDofD4VyRCEuWScQSllvLZDImRlLpNP1NYk4gEGDpw5FIBCqVirnbKMnYaDTiqquugsPhwIkTJ5Ceng69Xs+SqCUSCXQ6HZRKJQsRCQQCSEhIgMPhYK41ErOoJNhut7NwFJ/PxwJkqCxcGJRCITUkXEqlUmi1WsTGxjK3I62DyWTC9ddfj5ycHBQVFaGsrAzt27eH3W5HTEwMEhISYDAYIJPJYLFYUFZWhiNHjiA3Nxd+v5+VqJOoKixZvhiEydPkRCVRWFgyTW5EciFSabHf74fL5WogwFEPT2HJMW0r6mFJYq9Wq43qq0mlzZRCrdFoEAqFUFFRwcri6X3Ky8tZmbZUKkVsbCwTUmtra9ny1Wo1jEYjWrVqxcJxyFEKgIXV0PFIj8llS0KosP+mUqlk5fAU9iMM5+FwOBwOh8NpLrjwyOFwOBwO54qCSmyF4SLkDCRBCgD7m1yFQkccBZiQiESio9/vZ/3zaDnkqMzIyMDq1avh9/uRk5PDHItqtRo+n48Jj1KpFH6/H263G2q1GpWVlVCpVJDJZKisrGTzWSwWmEwmaDQaVlpMYSRut5sJj1TO7XA4WL/K2NhY2O126PV6yOXyqFAdWk+ZTAatVguXy4WCggIEAgFkZWWhqKiICXoKhQIxMTGQSqWora2FQqGATqdj29rn87F5L1bgql/iDICJsMCpRGQS+8RiMeRyOVwuFytNlsvlqKuriwrBoRJrYRm9sDSZtguVZpPDlY4Jn8/HnI4kXvr9fsjlcpSXl0MsFkOtVkOj0SAlJQUA4HK5UFxcjJKSEhZG07p1a5jNZsjlcphMJiaIq1QqFlJDgTjCcCFaf+FvYTgSCebCMnIOh8PhcFoiy5Ytw4QJE/Dzzz+ja9eufCx/IvgVCofD4XA4nCsKYYmuUCAEfg+eIYFOKpVGuebIMUZ9IaVSKQKBABOsyI1HJbgk/shkMrhcLhgMBpSXl8Nms8Hr9TLxy+fzwev1MsGQSqUBsBATq9UKrVaLcDiM6upq+P1+eDwelpTs8Xjw7bffYu/evfB6vbDZbPD7/axHo9vtZgJncnIyJBIJXC4XcxHS9gDAyrdVKhUSExPRv39/tG7dGr/++iuCwSCKi4tx/PhxlJaWwmKxQK1WQ6/Xs5Jt2s7UR7Ap0q2FvThJHCWhjdyn1LOQRErqA6lUKlmaN+1nKgunMmQS+6hEm1Ks6f2p1ycF2YhEIrhcLiY2er1e1NXVwefzweFwsMAZSqOura3Fjh07sGfPHlRXV6NNmzbIz89Hfn4+2rRpA41Gw8JrSKxUKBQskIb2i7AvI5Vcu91u5s4lR6NarWaCNW0n4Q+Hw+G0dJYtWwaRSISdO3c291A4f0Dmzp2LtWvXNvcwGvD8889DJBKhQ4cOjT7/ww8/4MYbb4RarUZSUhIeeeQROJ3Os77v8ePHIRKJsGDBAjbtm2++iTr3y2QyZGZmYuzYsTh69GiD157u58UXX2ywvHXr1mHQoEFITEyEXC5HTEwMevbsiZdffhl2u/28tgl3PHI4HA6Hw7niILFJGC4jDJYhh5uwVx6530iUIuFLqVRCIpHA4XCwtGFKwKYkaUowzszMxIkTJ3DixAnIZDIWJqJSqdhFJQlr1DNRq9Wy6Wq1mglLJG7W1dVh165dkMvlMJvNOHLkCI4fP4727dsjNjYWHo+HufkCgQCSkpIgl8thtVrx66+/olWrVlAoFKipqUFpaSm8Xi9yc3ORmZnJHHcA0LFjR2RlZWH37t1ITU1FfHw8tFotEhMToVar2bYloTEYDDKhrKmo30OTysNJLCSRUNjfkgRcp9PJxuL1epkgR65UAFH9IT0eDwuDoQRoEhElEglLDAd+d9HSusfExDDHZSgUwu7du1lCuUqlQm5uLlq3bs2WqVQqoVarmdBIorXQlUnLod90/FG4Ebk8FQoFO34JLjReeQg/t+i3cD8LbwCQ4E6/6TOOPgNpWmPwY4fD4fxRmTt3Lu68804MGTKkuYfCKCkpwdy5c6HRaBp9fu/evejTpw/atWuHhQsXoqSkBAsWLEBRURHWr19/wct95JFHcO211yIQCGD37t1488038cUXX2D//v0wm81svrvuugu33nprg9dfffXV7O9wOIz77rsPy5YtQ8eOHfHwww8jLS0NDocD27dvx4wZM/C///0PmzdvPufxceGRw+FwOJeNllTW0JLGwml6hGEbVHJN4hJNU6vVUb0f6XUUNCJMOKaybGF5NfUG9Hg8cDgc8Hg86Nq1K1JTU2G1WmGxWKDT6SASiRAbGwubzYa6ujrU1dUxByE5KKl3IwlMBoOBiWxyuRxZWVmoq6vD4cOHWeLxtm3b0K5dO6Snp7NyagqekcvlSElJwTfffIPq6mqIxWKYzWZkZWVBIpHAYrHg4MGDSE1NhcFggFQqhc/ng1qtRs+ePVlJOXCqxJm2hTCURdhPsKn2GW1jAMxhSgh7WJJjFTglnMTHx8Nut7NekMKejsLjgNaHHLEajYY5G4XuSKHI6fP5mIhz4sQJtp1JsKyurkYkEoFWq0UkEkF6ejoyMzOhVCrh8XhY+A05G0l0JITjITFJGIpD21in0zVID+ei0ZWJUGykzxj6LCCBfMeOHdi5cyd27dqFmpoayGQy5oyVy+VIS0tDmzZt0KZNG+h0OiQkJCA9PR0mk4n1D+XHD4fD4TQt06ZNw3XXXYdQKISampoGzz/99NMwmUz45ptvoNfrAQCtW7fGAw88gI0bN+Ivf/nLBS23R48euPPOOwEAEyZMQNu2bfHII49g+fLlmD59OpvvmmuuwejRo8/4Xi+99BKWLVuGxx57DC+//HLUuWLq1KkoLy/He++9d17j46XWHA6nWeElFpyLoaWUWPz888+YPHky8vLyoNFokJ6ejhEjRqCwsLDR+QsKCnDLLbdAq9UiJiYGY8aMQXV19TktSyQSYfLkyexx/dIJiUSC9PR03HHHHdi7d2+D157u58EHH2ywrG+//RYjRoxASkoK5HI5DAYD8vPz8dxzz6GysvLcN9Blor67UdjDjwQlKmMlxyL1DCSRy+v1RpUlU9m11WplzkWFQsFKjn0+H2pqavDrr78iIyMDer0eZrMZaWlpuPrqq2GxWBAKhWCz2QCcChbxer2sbLeurg5OpxM2mw0+n4+VDpO453K5AAA6nQ4mkwmZmZnIzc1FTEwMDAYD9u3bhx07dqCiooKF3ZB4SvMoFArExsYiNzcXKSkpSE5ORteuXdGhQweWwE3uRbFYDKVSCZ1Ox0qPSTSjHoPkHAV+P6aaYp9RmjPwuzuLHJDCoBmCSq0VCgVLhKb1r196rFaroVQqmcPR4/EwJ6JIJILFYmHuMHInUsk1CdRFRUU4cuQIc7l6PB5YrVY4HA74fD6oVCp07doV3bp1g0ajQTgchk6ng16vh1KpbFAmTs5XOjaFJf7CbUpBNfVFR86VAf0PCMXncDgMp9OJXbt2Yfny5bjrrrvQr18/jBw5EvPnz8crr7yCO++8E//5z3/Qrl07PPbYY3j66afx1FNPYfbs2Xjsscdw1113oWPHjvjuu+/wyiuvYPTo0ejduzdGjRqFd999F4WFhfB4PMxNLPxf5HCak/Hjx0Or1eLEiRMYOHAgtFotUlJS8K9//QsAsH//fvTu3RsajQatWrXCqlWrol5vsVgwbdo0dOzYEVqtFnq9HgMGDMC+ffsaLKu4uBi33347NBoNEhIS8Nhjj2HDhg0QiUT45ptvoub96aefcMstt8BgMECtVqNXr174/vvvz7o+VAq7evVqPP/880hNTYVSqUSfPn1w+PDhqHm//fZbDB8+HOnp6VAoFEhLS8Njjz0Gj8fTpNsIAKxWKx599FGkpaVBoVCgTZs2mDdvHrsBRpSXl+PQoUPs/HwmPvzwQ3Tp0oWd+zp27IglS5ac8TV1dXXo1q0bUlNT8dtvvwE41T969uzZaNOmDdsOTz75JHw+H3sd3TRcvnw5O9ePHz+ePV9aWor77rsPZrMZCoUCGRkZeOihh9hNS8Ln8+Hxxx9HfHw8NBoN7rjjjnO+Jq/Ptm3b8PHHH2Px4sWNPm+327Fp0yaMHj2aiY4AMHbsWGi1WqxevfqCltsYvXv3BgAcO3bsvF7ndrsxb9485OXlYf78+Y1e4yUnJ+Pvf//7eb0vdzxeBPVPzvyuIYfD4VxeWkqJxbx58/D9999j+PDhuOqqq1BRUYGlS5fimmuuwY8//hjV46WkpAQ9e/aEwWDA3Llz4XQ6sWDBAuzfvx87duxgTpTzhUonQqEQCgoK8Nprr2H9+vX48ccf0blzZzZfv379MHbs2Aavb9u2bdTjWbNmYc6cOcjMzMT48eORmZkJr9eLXbt24eWXX8by5ctx5MiRCxrr5YTEWOrTCPzeI4/Sn0ns8/l87FxODj+73Q6v1wuxWAy9Xs9KocmJ5/F4UFlZiVAohKSkJPb+JM6lpaWhqqoK8fHxsNlsUUKT0+lkzjYSACoqKuD3+5kYaLVamWgmHGdSUhISExOxe/duhMNh7N69G0qlErGxscwdJ5PJkJSUhJMnTyI2NpaF1pCoSf0tqY8gOTitViuUSiVziAKIcv3RlxISImk7XwzkLBT25RSKwuRYpWUJ+0oGAgEoFAq4XC7ExMRAoVAwEYVCW4ShNeFwGDabjbkdhetHpeNarRYmkwkOhwNWqxXV1dU4fvw4kpOTmeB85MgR2O12BINB5ObmIisrC0ajkW07k8kUtVxh6FF9QVVYDktuW+o7SeIxT6m+shB+jyDR0ev14sCBA9i2bRu++OILlJSUQCaT4YYbbsCIESPw6aefYuXKlTh27BgGDx6MOXPmoFWrVgCAmpoaFBYW4vrrr4/63OjZsycCgQB+/PFHWK1WrFu3Di+++CKCwSDMZjN69uyJMWPGIDs7mx13/BjjNDehUAgDBgxAz5498dJLL2HlypWYPHkyNBoN/vGPf+Cee+7B0KFD8frrr2Ps2LG4/vrrkZGRAQA4evQo1q5di+HDhyMjIwOVlZV444030KtXLxw8eJCVnbpcLvTu3Rvl5eWYOnUqkpKSsGrVKmzZsqXBeL7++msMGDAAXbp0wezZsyEWi/Huu++id+/e+Pbbb9GtW7ezrtOLL74IsViMadOmwWaz4aWXXsI999yDn376ic2zZs0auN1uPPTQQ4iNjcWOHTvw6quvoqSkBGvWrGmybeR2u9GrVy+UlpZi0qRJSE9Pxw8//IDp06ejvLw8SjibPn06li9fjmPHjrEWIo2xadMm3HXXXejTpw/mzZsH4NSN9u+//x5Tp05t9DU1NTXo168fLBYLtm7diqysLITDYdx+++347rvvMHHiRLRr1w779+/HokWLUFhYyAwH77//Pu6//35069YNEydOBABkZWUBAMrKytCtWzdYrVZMnDgRubm5KC0txccffwy32x11rT1lyhSYTCbMnj0bx48fx+LFizF58mR89NFHZ92n9ffHlClTcP/996Njx46NzrN//34Eg8EGlVZyuRydO3fGnj17zmuZZ4Ku0WNjY6Omu93uRp2YRqMRUqkU3333HaxWK6ZNm9ZkFS0AFx4viPoXCvzk3Hw0dmeW7w8Oh3O5efzxx7Fq1aqoC5mRI0eiY8eOePHFF7FixQo2fe7cuXC5XNi1axfS09MBAN26dUO/fv2wbNkydvF0vtQvnbjhhhtw++2347XXXsMbb7zBprdt2/asJRYfffQR5syZgxEjRuD9999vIIYuWrQIixYtuqBxXiqE5wMSdkiwohJaYVm1UAQCEBUyInwdiW9isRgajYZ9Mac+kGVlZTh69CiuueaaqHAat9uNYDAIp9MJpVIJu90OkUiE8vJyVn5N46LgGKVSiZqaGgSDQSiVStZvMBKJwG63Q6lUQqvVIhAIoLKyEsXFxbjqqquQlZWFPXv24Mcff4TH40FeXh7ryZiWlgatVotWrVqx8nCCwlYCgQDkcjnkcjlzBwrDWXw+H+sZR2nfJJ4K+zFeDB6Ph/VqFLothEIn7WdhEjWNy2q1MkFWKpXCbrczcZnE4kAggFAoBK/Xy0rnyR1KfTwpVAY4JSDTuKxWK1t+bW0tKisrUV1djfT0dLRt2xZxcXFQq9VsO1IfR9pGJDgLtxU9plJwYUAPOU81Gg1kMlmjTkjOH4vGrllJxP7tt9+wbds2fPvttzhx4gTi4uIwcuRI6HQ6Vh6t0+kwdOhQFBcXY8yYMXjmmWeQkZHB3jc2Nhbdu3eHSCTC/v37IRKJ0KNHD+h0OgSDQdx6660QiUQYNmwY9u7di6qqKmzbtg1ffvkl1qxZgxEjRmDKlClISEho4Kzlxx3ncuP1ejF69GhWInr33XfDbDbj3nvvxQcffICRI0cCOHUzNTc3F8uXL8czzzwD4FS/4sLCwqjjeMyYMcjNzcXbb7+NmTNnAgDeeOMNJlIOHjwYADBp0qSoXnfAqf/dBx98EDfffDPWr1/P/h8mTZqEvLw8zJgxAxs3bjynddq7dy+7pjKZTJg6dSoOHDjAblDPmzcPKpWKvWbixIlo06YNnn76aZw4cYJdN17sNlq4cCGOHDmCPXv2IDs7m62P2WzG/Pnz8cQTTyAtLe2s6yTkiy++gF6vx4YNG85JsKqoqEDfvn3h8Xiwbds2dhNl1apV+Oqrr7B161bceOONbP4OHTrgwQcfxA8//IDu3btj9OjRePDBB5GZmdngunb69OmoqKjATz/9FCXyPffccw0+i2NjY7Fx48aoNi+vvPIKbDYbDAbDOa//66+/juLiYnz11Vennae8vBzAKcdgfZKTk/Htt9+e8/Lq43A4UFNTg0AggD179mDq1KnsM1/I7NmzMXv27Aav3759O6677jocOnQIABoE44RCW1YyGgABAABJREFUIdTV1UVNi42NPefzA6/XOAeEX1boQKWSrPpWZM6lof4+qF9OR18yOVcGvMSCl1j80Uosunfv3kCcy87ORl5eHgoKCqKmf/LJJxg4cGDUxWPfvn3Rtm3bFlFiAZxyO8bFxeHtt99u1IFpMBjYxWtLhNyC9EPQ33S8UF9Dt9sdVZIdCARYn0dKsCax0Ofzsfevrq7Gr7/+CrPZzHqveb1elJeXw+12szTqQCAAm82G0tJSFBcXY+/evaipqYHdbofL5WIBJUJhSqvVIi4uDq1bt4Zer4dcLkcgEMDBgwexc+dORCIRDBgwAFdddRV0Oh26d++OXr164ejRo9izZw8qKyvh9/uRmJiIzp07IzY2FlKplAlcJIRRL0fqfUnlwBTgEgqFoFQqmYvQ7/czIfJC+js2dh6nVG4SWuk37Q86z5NQWL+cXiKR4Pjx44iLi2MXwVKpFH6/HxaLhb03rXsgEGCl5OQ8FYvFsNvtzHXmdrthsVhQXV2NkydP4ujRowgGg6irq0NZWRmsVis6deqEvLw8mM1maDQadqxQaBCARoNyyOlILk5huTqVelOZPIXlcOHnj4+wnNrr9WLfvn2YN28ebr/9dgwfPhxFRUW44447sHTpUsyZMwf33Xcfbr31Vtxwww3o0KEDWrVqBbVajePHj7M0evpfFh5TYrEYvXr1Qo8ePVgo1qeffgqbzQapVAqNRoPu3bvjuuuuwxNPPIHnnnsOL774In799VcMHjwYr776KioqKtjxSmPncC43999/P/vbaDQiJycHGo0GI0aMYNNzcnJgNBqj0nupny5w6nO3trYWWq0WOTk52L17N5vvyy+/REpKCm6//XY2TalU4oEHHogax969e1FUVIS7774btbW1qKmpQU1NDVwuF/r06YNt27ad0/fQCRMmRF1T9ejRAwCixi4UHV0uF2pqatC9e3dEIpFG3XAXuo3WrFmDHj16wGQysfWpqalB3759EQqFsG3bNjbvsmXLEIlEzuh2pOW7XC5s2rTprNuipKQEvXr1QiAQiBIdaWzt2rVDbm5u1NjourYxR6qQcDiMtWvXYtCgQY32cK9/Pp04cWLUtB49eiAUCqG4uPis60HU1tZi1qxZmDlzJuLj4087H32fE94EJqgv9IVy7733Ij4+HmazGbfddhv7jlR/G0ycOBGbNm1q8NO+fXsAYGnVFHxI7N+/H/Hx8VE/tbW15zw+7ni8QMgl0ZT2U875Q1/+hM4L7kK9MuAlFrzE4o9WYlGfSCSCyspK5OXlsWmlpaWoqqpq9EKoW7du+N///ndRyxRyuhILr9fbaIkFiVuFhYUoLCzE/fff3+Ci448CnRPI1Uhl1pRo3Vh/Qr/fz8pehSEyCoWChasIQ03q6upw5MgRhMNhdqNAIpHg2LFjcDgciI+PZ65HpVIJl8uF48ePsy//P/30EzQaDUwmExISElj/PirzlUgkcLlcsNlsOHr0KLxeLyKRCHJycpCfnw+9Xg+9Xs9EOZFIhLy8PBgMBvz000/YuXMnOnTogOTkZNb7US6XMzGWwlbq90wEwERUCqkRBvVQmnRTOR0jkQhsNhtL5qZ9QP0bhWOjJGcqTQ4EAmzdbDYbOnTogNjYWFYyT05Hi8WCYDDI1sXv9zNXp8PhYOIrlTNT6XldXR0rPXe5XEhNTUVlZSXUajVuuOEGxMTEwGg0si+cVN5O+0Mul7PtRqXkdN0o7McpLO9XqVTsdfxa5spAaFqw2+34/vvvsXLlSuzbtw/XXHMN+3KcnJwMs9nMPndEIhFMJlOUKB2JRLBhwwbk5eVFCRT1ETq9dDodevToAaPRiEgkgmPHjiExMRGJiYkIh8NQKpWw2WxISUnBoUOHsHHjRqxevRqjRo3CXXfdxcR8ofjIj03OpUapVDYQcAwGA1JTUxscfwaDIcqJFQ6HsWTJEvz73//GsWPHos5zwmui4uJiZGVlNXi/Nm3aRD0uKioCAIwbN+6047XZbDCZTGdcJ+ENZwBsfuHYT5w4gVmzZuHzzz9v4C6jXtHExWyjoqIi/PLLL6cVyaqqqs64Lo3x8MMPY/Xq1RgwYABSUlLwl7/8BSNGjMAtt9zSYN4xY8ZAKpWioKCAtakRjq2goOCCx1ZdXQ273d7AsXc6zmW/nI0ZM2YgJiYGU6ZMOeN89LktNFIQXq/3jJ/rZ2PWrFnshlNcXBzatWvHbl4Kyc7ORt++fU/7PjqdDgDgdDqjprdp04aJyu+99x7ef//98xofFx5Pw+nKqYWJgwCY+MhPwJeO+vsCAPviUX86Fx2vHHiJxSl4icUfp8SiPitXrkRpaSmee+45Nu1sJRYWiwU+n6/RO6Fng3q2hEIhHDp0CI899hgAYPjw4VHzvf3223j77bcbvP6DDz7AqFGjTltiQSWmQqgfTEtA6I4j1xzwe4UChaMAp5yPJDRSeS25z6iaQSaTsfRooVMpEonA4XCguLgYx48fx4033gidToe6ujomLGq1Wtjtdtb/r66ujom9JpMJZrMZV111FaRSKVwuF+rq6uB2u2G326OEK3LQXX311TAYDNBoNDAYDOwzwu/3w+v1QiaTQa1WQywWIy0tDXK5HF9//TV27NiBq6++GmlpaSw4x+fzwev1suXStsnNzYXRaIRarWbvLyxrFpZYU3/Fi735SgEaJDpS70naFyRCAohyYlI5O4XwFBcXs21KPSuFwp5er4fX64Xdbmfb1ul0QiaTsf1C24X6MwrL2x0OB0KhEE6cOIHk5GR07NgRSqWS9YPUaDRRYiEJpkKnJomqBImRNEaVSsXEUH4dc+VAnxvl5eVYv349VqxYAbfbjR49emDgwIEYPHgwnE5no+XNwsAX+lwLh8PYt28fxo0bB4lEgrq6OhYQRd9HhDfjAUAmk0VdO9TU1OCXX37BLbfcAoVCgbi4OJhMJqSkpEAqlaJXr174+eefsWXLFowePRoTJkzAwIED2ecCP0Y5l4PTnV9ON114bTd37lzMnDkT9957L+bMmYOYmBiIxWI8+uijF1QhR6+ZP39+VM9sIedyo/ZsYw+FQuxm/N///nfk5uZCo9GgtLQU48ePbzD2i9lG4XAY/fr1w5NPPtnovPX7fp8LCQkJ2Lt3LzZs2ID169dj/fr1ePfddzF27FgsX748at6hQ4fivffew5IlS/DCCy9EPRcOh9GxY0csXLiw0eWc7/eTs3Eu2+tMFBUV4c0338TixYtRVlbGpnu9XgQCARw/fhx6vR4xMTHs+p++DwgpLy9n5pgLoWPHjmcUFM+V3NxcAMCBAwfY92Pg1DFO7//dd9+d9/u2jG8LLRThSV54F57KYujCuyWdfM/lH6QljfdcIWeD8MJKePdKmBTZ0jjdPmmJY21pNFY+cPjw4XMqsSDIrXK+JRZPPPEEm0YlFjNmzGggvPTp0wfvv/8++5w4E2cqsSCRp36JhcfjiSqxqH9X7kK3Uf0SC6Jv37548cUXsW3bNtxzzz0ATpVYLFu27IzrRsunEovG7m4KKSkpYe+/bds2pKSkRI1NWGJBCEssunfvftr3booSi0WLFrH+eRfCoUOH8Ne//hXXX3991B3ys5VY0DwXIjzW79mi1+sxb948DB06NGq+wYMHR6ViE9QI+3QlFjabrcHd559//rnRbdwcCG9ABYNBlloMnNreVKlA7kUSFAOBAPx+PxOL6ByvUqmYgCmXy5lg5fF4UF5ejl9++QUdO3aE0WhETU0NDh06BJfLhXA4DL/fz4RHqVSKuLg4dO3aFYmJiQDARCqpVBp1p79+JQV9rtC85FqkvofhcBharRZKpZKdE30+HxwOB1q3bo3CwkKsX78e8fHx8Hq9kEqlUKvViI2NRWxsLNLT06HX6xEfH8/6E9IyaTsKty9tP2Fa9Pnsm/qP3W433G43O3+HQqEGPSgBsPJREoYJiUQCq9WKiooK9OvXDzqdDj6fjzkHXS4XxGIxS5wWJl/7/X7U1tbCYrEgMTERkUgEZrM5yhmrVqtRWlqK0tJS2O12ZGdno127dkhKSoJEIoFcLofRaGShPCQwCn+A30N46EsjbV/aFrQP+XXBlUlJSQlGjx6N/fv3Y+TIkawMmm4Y0Get0FVIn0MnT55EXV0d2rRpg7179+Kqq65iNwGAU5/XFRUVKCkpwbXXXovKykokJydHfX7XP666dOmCq6++mt1QKC0tRWpqKlQqFa655hr4/X7cfPPNSEhIgN/vx7vvvovvv/8eU6ZMQevWrVvMzSYO53R8/PHHuPnmmxvcZLVarYiLi2OPW7VqhYMHDzYwrtRvg0TVNHq9vkmEndOxf/9+FBYWYvny5VEhgOdSuny+ZGVlwel0Nvn6yOVyDBo0CIMGDUI4HMbDDz+MN954AzNnzoxykk6ZMgVt2rTBrFmzYDAY8NRTT0WNbd++fejTp89Zz4uNPR8fHw+9Xo8DBw403YqdgdLSUoTDYTzyyCN45JFHGjyfkZGBqVOnYvHixejQoQOkUil27twZ9V3N7/dj7969UdOaix49esBgMODDDz/E9OnTz/r99lzhZ47TIGwwL2z4LfxgIjdCS0Q41ivhQpa+AJHDQnjBLmxu35LWVThGYbN4zrnBSyx4icUfqcRCSEVFBW677TYYDAZ8/PHHUULS2UoshPOcLxMnTsTw4cMhFothNBqRl5fXqICZmpp6QSUWWq2WXfxu3LgR8+fPv6BxXmpInCIhSKVSMeGHzuUkENHNLCrBjUROha+QCEduQgr38Pv9KC8vx65du5CQkIDY2FiUlJSgqKiIJVsHg0Go1WrExcWhQ4cO7H9Sp9MhFAqxHqNC8U7Ym61+ArLwhhu5AamvMZ0TyRlJ5b1yuRyZmZlISUlBKBRCenp6lONOGMwivGkndP0Ke8fRcwqFgpU7C193rtUGwvmcTiccDkeUC5VuIgrFT+G2EPbBDIVC8Pl82L17N7Kzs5nQEg6HmVBM70e9KIPBIDQaDYDfw2xInKbtqFKpWP9Y6gHqdDphNpvRpk0bJCQkMLGRto2wGoMQ/t/T8oXVGsLwGOG8Lek6hnPh0OdJXV0dnnjiCRQXF2Pq1Km46667mCtZ2A7C6/UiGAxCq9WirKwMTqcTmZmZUZ9H1157LY4cOcLc7Rs3bmRu5ZSUFEgkEmg0GtTV1aG4uBitW7dmTmjg988c4WdMKBTCzp07UV5ejk6dOrEbHDExMbj66qtRUlKCZ599Ft988w3Gjh2L3r1745FHHkFcXByv+OK0WITfFYk1a9agtLQ06hq/f//+2LRpEz7//HPm7PJ6vXjrrbeiXtulSxdkZWVhwYIFuPvuuxvcmK2urj5jX7/zGTfQsNrvbL3SL4QRI0bgmWeewYYNG9C/f/+o58iwQefn8vJy2Gw2ZGVlsXNmY9TW1kZ9zxKLxewGfmPXvTNnzoTdbsf06dNhMBjw0EMPsbH973//w1tvvdUgcNHj8SAcDrNzuUajYeFvwuUOGTIEK1aswM6dOxvcIG/qCskOHTrgs88+azB9xowZcDgcWLJkCROvDQYD+vbtixUrVmDmzJnsmvv999+H0+mMqlJyu90sbEwomF9q1Go1nnzySfzjH//AU089hXnz5jXYXhfS95cLj6eBDkgqgQF+t1nTyVp4Im9O6u94YTk4fckSlkQ1doHc0qEvSULHaf0LqJZA/RMFfWmsL1wL3Q4tZewtDV5iwUss/iglFkJsNhsGDBgAq9WKb7/9tkHJxNlKLGJiYi7I7QicvWfLuSIssRAilUrZ+5eUlFz0ci4VwoASCkURCj/Uw08o3lEAjFgsZuX1gUCAiXMkOp44cQKbN2+G0WhEdnY2SktLUVBQgBMnTkAikaB169bo3LkzMjMz2We+wWBgYl0oFIJGo2FJ0hTqAvzu3CeE5w8SJ2heSppWKpVRJcgymQwSiYSJ1yaTiVUL0MU6nU+FoqVQgKQvGvVv6Akv1M/3f0N4LRKJROB0OuF0OqPO5VS2TK5P4U1foZOQ3F6BQADHjh2D1WpFz549odFo4Pf7WS9IobtYKOpSOA69j1qtZtvVYDAwxyM5Io8dO4bU1FR07NiRlaHTdid3MpWFk7hJX3qF02mfikQiKJVKqNVqtq15m5grE5fLheeeew4HDhzAO++8g5ycHOj1evb/GgqFcPjwYaSnp8Pv9+O3335D27ZtYTKZ4PP5MGfOHHz22WeQSCS48847cfDgQfz8888oLy9HZWUl9u3bh61bt0KpVOL+++/HsWPH0L9/f7Rq1QpyuRx1dXWoqKiATqdDXFxc1I0HOkZFIhFuvvlmOJ1OVslVUVGBmJgYaLVaZGVlIRAIIC4uDnPmzMELL7yArVu3YtasWejTpw93P3JaJAMHDsRzzz2HCRMmoHv37ti/fz9WrlyJzMzMqPkmTZqEpUuX4q677sLUqVORnJyMlStXsgoU+lwWi8X4z3/+gwEDBiAvLw8TJkxASkoKSktLsWXLFuj1eqxbt+6ix52bm4usrCxMmzYNpaWl0Ov1+OSTTy74RviZ+Nvf/obPP/8cAwcOxPjx49GlSxe4XC7s378fH3/8MQtsA8691/v9998Pi8WC3r17IzU1FcXFxXj11VfRuXNntGvXrtHXzJ8/HzabDX/961+h0+kwevRojBkzBqtXr8aDDz6ILVu24IYbbmBthFavXo0NGzYwMbFLly746quvsHDhQpjNZmRkZCA/Px9z587Fxo0b0atXL9Yvvry8HGvWrMF3330Ho9HYZNsyLi4OQ4YMaTCd+uXXf+75559ngYATJ05ESUkJXn75ZfzlL3+JMmvs2LEDN998M2bPnt2kgY67d+/GihUrGkzPysrC9ddfDwB46qmnUFBQgPnz52Pjxo0YNmwYUlNTUVdXh927d2PNmjVISEhg/yvnAj9bnAH60kAX30LRqCU614RfUup/kRY212+JYz8XaL2EboHGnBotARJIhceK8EtXKBRqsaXhVwK8xOLs8BKLpsfr9WLQoEEoLCzEV199xdLhhKSkpCA+Ph47d+5s8NyOHTtOK2xfTnJycpCdnY21a9di8eLF7K7yHwESCOl8p9Fo2A1E4U1EcsuRGOXz+VjZo/CmEc1fU1OD3377DYcPH4Zer0eHDh1w5MgR1rrhqquuQteuXZmzUCjsCW8ECpOOG3MO1q+oILe28EYbnV8o+EUoHjZ2zSISieD1elmPS1p2fTFWuPzGED53ru7G+o8jkQgrrxa6JiKRU8ErdrsdWq2WrT8JkPU/o0WiU6Ew27ZtQ6dOnWAymaICYsh5SvtfuHwSJa1WK3OykkuVBGuJRAKlUona2lrY7XbccMMNUKvVMJvNLN2chFyhS5WOHeD3snlhmTiVupOrknPlQceZx+PBSy+9hF9//RWPPfYYsrKykJSUBLFYjCNHjkAmkyE5OZkdo6WlpXj99dexc+dO9O/fHwUFBdi8eTMrxZ8zZw5bhlgsRl1dHfR6PQDg22+/xaZNm+D3+9GhQwc89dRTyMzMRHZ2NsRiMfx+P44ePYrExETo9fqokm7g1LWNwWBgNzgKCwvh8XjQq1cvFnbUs2dPVFVV4eWXX8aHH36Ip556Co8//jhGjRrFk9c5LY6nn34aLpcLq1atwkcffYRrrrkGX3zxRdS1JnDKNPD1119jypQpWLJkCbRaLcaOHYvu3btj2LBhUaLKTTfdhO3bt2POnDlYunQpnE4nkpKSkJ+fj0mTJjXJuGUyGdatW4dHHnkEL7zwApRKJe644w5MnjwZnTp1apJlEGq1Glu3bsXcuXOxZs0avPfee9Dr9Wjbti2effbZC+pxPnr0aLz55pv497//DavViqSkJIwcORLPPPPMGfWH119/HU6nExMmTIBOp8PgwYOxdu1aLFq0CO+99x4+++wzqNVqZGZmYurUqVHmiIULF2LixImYMWMGPB4Pxo0bh/z8fKSkpOCnn37CzJkzsXLlStjtdqSkpGDAgAFQq9UXtM2aimuuuQZfffUV/v73v+Oxxx6DTqfDfffd18CI0Rj02X0xPbY/+OADfPDBBw2mjxs3jgmPYrEY77//PoYNG4a33noLr776Kurq6qDVatGhQwc8//zzeOCBB84rhJILj2eALiDpBF3/7n9LOsE25qyrX45MdzeF87WkdTgT9MVDKOa1tPLq+qXV9KWxvltEWFojLAVoKetxJcBLLM4OL7Fo2v+3UCiEkSNHYvv27fjvf//LTtyNMWzYMCxfvhwnT55k7s3NmzejsLCQBcIAp1xtR44cgcFgaDSM5lLyzDPP4J577sEDDzyA5cuXN9jvF+IGvRzUD0CpL6yRIEUJ0dTjUSaTsVJlYdJzTU0NioqK4HK5YDQaERsbi9TUVOzfvx+HDh1C+/btcfXVV6N169Ys1EQikUR9Ea9fMix0vAv/rt//j84jQuESOPUZRc5JGvPpzjP0WKVSMaGT3lf4npeDSORUWIswSEYo1FHvTRoz9dimbUHCXTAYhNVqxebNm6HT6dCuXTvmYKT1of6eMpksKhxIIpHA6/WitrYWLpcLMpkMRqMRMpkMKpUKTqeTCZdVVVWora2F2WyGyWRCbGwsO6ZoeVSiX7/vJI2V1oduNmo0mgZOGs6VRzgcxqpVq/D1119j6dKlyM7ORlVVFb755hvceOONSE5Oxpo1a7B161a0bt0at956K1544QVs3LgRfr8fBQUFAH7/LKBwI0IikWDHjh3QaDQs9ZraS+zbtw9jxoyBUqlE79698a9//QsJCQkIhUJwOBw4cOAArrnmGtjtdsTExLDrDuFNkR49ekQ5rMPhMGJiYhATE4NAIIA+ffrguuuuw5IlSyCRSDB8+PAGCe0czrkyfvx4jB8/Pmra6XqLf/PNN42+x/Hjx6MeKxQKLFiwAAsWLDjr6zMyMvB///d/UdPIqZaamho1vXPnzvjkk08aHcOZuOmmmxq9bmrdunWD6e3atWvUcFB/vovdRsAp4XXu3LmYO3fu6Qd/hmXVZ9iwYRg2bNgZ52lsf4vFYqxatQqrVq1i02QyGZ588snTVmYROTk52Lp1a6PPpaenN6i4OttYgNPvr/PldPsCAG688UZ8//33Z3x9Y+NwOBwAwG48nW6+xmjseDsbQ4YMadTNeSGct/C4bds2zJ8/H7t27UJ5eTk+++yzqMFEIhHMnj0bb731FqxWK2644Qa89tprLDUVACwWC6ZMmYJ169ZBLBZj2LBh7C5DcyMUj4Qn+fpOx5ZyYhV+YaGLXeEXnPpiJM1zsUmUlwvhFw4ST4GLU/kvJcLtL/wSBPzuWKF1Ef4N8FKrpoSXWJwdXmJhbNLt+cQTT+Dzzz/HoEGDYLFYGpQwCFO3n376aaxZswY333wzpk6dCqfTifnz56Njx46YMGECm6+0tBTt2rXDuHHjzumC71wpLCxstMQiMTER/fr1A3AqIf3AgQN44YUXsGPHDowaNQoZGRlwuVw4cOAAPvjgA+h0urP2Nb3cULBLJBJpkMxMApHH44m6mUilyfT/7vf7UVJSgsLCQohEIiQmJkKr1cJisUCv12Pnzp2oqanB4MGDkZmZCb1ez5KoSewCfr9hBiBKGAR+vzlS/1zdmNORXicMj1EqlcztKCyZrn8OIYdfY27FS32+qX8jlNKrhdciVNpN53lyOBJUkg6c2rcOhwMWiwXbt2+Hx+PB7bffDpVKxcRMtVrNwmWUSiVLvSYB1+fzoaamBl6vF0ajET6fj93EIAHa7/ejtLQUDocDdrsd11xzDUwmE/R6PSvDDgaDbF46j5MIDIAdA9QiJhQKQavVXnAbBU7Lpv4XOb/fjw8//BBDhw6F0WiEx+OBRCJBz549IRKJ8N///hezZs1CdXU1u7lIYrZer4fH44Hf72cuXDqmye0ciURQWlqKlJQUKJVKFBUVoaioCEqlEmKxmLUy+OKLL6BWqzF+/Hikp6cjOTmZXQdVVVUhFArBZrMhJyeHjZ0+T4Qu3sOHDyM2NhYmkwlSqRQ33XQTfvzxR7z88sv45z//CaPRiFtuueUPZ2rgcIBTN6qEvbW9Xi/eeOMNZGdnRwUfcjgtgZ9//hkAGq2qaumct/DocrnQqVMn3HvvvQ2SMgHgpZdewiuvvILly5cjIyMDM2fORP/+/XHw4EH2Zf6ee+5BeXk5Nm3ahEAggAkTJmDixIlRKndzIryAEIpdLdHpCPyeeil0MwodFkC0gEePW9p6CKnvHqSxtvQG7MJ9QQiFRfryIxSEOU0PL7E4O7zEomnZu3cvAGDdunWNitBC4TEtLQ1bt27F448/jqeeegpyuRy33XYbXn755bMKE01RYrFp06ZG76b36tWLCY/AqV6p/fv3x9KlS/HOO++gpqYGKpUKbdu2xRNPPIEHH3ywQTBQc0Nl1sLPXXJABoNBVkorEomi0o/9fj/q6upw8uRJlJaWQq1Wo1WrVqxMkdKqy8vLIZPJcO+99yIuLo4JTNTXT1juLOzjRl/mhe7E+sEkNE14o1A4TS6XA0CUe7H+ebC+wNlSzpN+v5+Jg+Q6FQqC9UVa2mfCfo6hUAjHjh3D3r17IRKJcN1110EmkzFhMhKJwOv1srAgYWk7XfvU1NTAZrOhpqaGCec0H4miFouF7TeNRsMSgil1mpyMJATJ5XIm+NC6kMOR9j31hWwp++NCudLNBxeD8HgtKipCdXU1ysrKYDabYbPZUFtbi//7v/+DXC7Hyy+/jKqqKshkMhYuJBaL4fV6maNZpVKxtgjZ2dkIBoMoLy+Hy+WCRCJBQkICtmzZgoceegjDhw/Hvn37sGvXLthsNjZPMBjE6tWr8dlnn0GlUmHIkCHsPNOuXTtEIr+3pqAwpsZuVEQiERQUFKB79+7sc6x79+7YvXs3Hn/8cfzzn/9EdnY2T7zm/CEZOnQo0tPT0blzZ9hsNqxYsQKHDh3CypUrm3tonBYA3cg5E/Hx8ZfcFLV9+3Zs2bIFL730EnJycpCfn39Jl3cpEEUuQvkQiURRFx2RSARmsxlPPPEEpk2bBuBUo/3ExEQsW7YMo0aNQkFBAdq3b4+ff/6ZOVa+/PJL3HrrrSgpKWnQiL8x7HY7DAYDbDZblM30YhA6B4XiHNCw4XtLQljCI3QJ1Ef4ZURYTiF8riUgPByFd3Zp3C21jwyNm75kCEvj6qdz1i/Bbil9Ki/F/9UflcWLF+Oxxx5DSUkJv9vJaVHQ/+mMGTOien79mTjdZ1UkEoHVaoXVaoVEIoFOp2MONeCUU5BELzpv+v1+VFRUoLKyEpFIBHFxcVAqlXA6nfB6vbDb7fB6vQiHw1Cr1Wjbti1ycnKihC0SmuqHstS/vDqd4NiYeCj8qf/6PxJ0/rbb7czRRedH6q9Ij4XXXnRtU1tbC4/HA5/Ph4MHD+LkyZNIT09HXFwc9Ho9S4WmkmcKiiEXJQk35LikUrPq6mrk5uZCIpFArVbDZrPBZrNBIpHgxIkTMBgM+Pbbb9GpUydkZmYiJiaGrZNarY5yZ1LQDI2deofS/pLL5TAajSy4o6VyLtcA69evx/fff48uXbpg6NChDYTHefPm4YUXXogyH+zfvz/KfDBgwACUl5fjjTfeYOaDa6+99rzMBy3lekX4Px4KhVBdXY2FCxfiiy++gM/ng9vtxuDBg9GvXz9s2bIFn332GXw+H3w+X5QbWCaTISMjA9XV1bDb7WydfD4fTCYTWrVqhbq6OqjVatTU1ECtVsNut+PEiRPo1q0bevfuDafTiT179sDpdOLgwYOsnQT9b/j9figUCvzzn//EhAkTIBKdCjkit/aePXuQkZEBo9HIbnII161+iwb6392zZw++++47bNmyBa+//nrU97iWfLxzGtJS/q8uN4sXL8Z//vMfHD9+HKFQCO3bt8eTTz6JkSNHNvfQOC2AZ555Bs8+++wZ5zlbRVhTMH78eKxZswY9evTAq6++GnVD749CkwqPR48eRVZWFvbs2RPVIL9Xr17o3LkzlixZgnfeeQdPPPFEVOlgMBiEUqnEmjVrcMcddzRYDp2kCbvdjrS0tCYXHsPhcFSfHgBR5QYtkfrCo9BVJ+zpCPwugtXv59KS1k0oANd3QNBFe0saLyEUHoUiMO2L+uXU9cMGuPDYfDRWYnH11VcjFAqhsLCwGUfG4TRk8+bN6Nu3L1atWoW77rqruYfTLJxJeKytrWVfuA0GAwuRCQaD8Pv9kMvl8Pl8sNlsqKqqYv1BtVptlHhlNBpZ2AJw6rNcpVJBpVIxwYnCQ+oLiMLPe+GNM/qsP1uw2Omea4nnvjMhrLSora2NKhcXXp+Q+xE4dQ6lZOrDhw/j22+/hUajQUVFBdxuN9LT0xEbGwuNRsMEExIgRSIRFAoFjEYjC+yg829NTU1UX0cqyzYYDFAoFHC5XHA6naitrYXT6URVVRUCgQC6dOnCSu0pgIacZCQ20nFD53ZheFw4HIbJZGKl/C15H57vNUBzmQ8uZKyXCqFIvmfPHsyYMQOBQADdunVDfn4+jh8/jm+++QbffPMNczEajUZ07twZX3/9NXM8BoNBmEwmHDt2DK1atYLRaMSJEyfgdruRl5eHoqIiAKd6GpvNZgQCAZSXl6O4uBhJSUmIRCK47rrroNVqYbfb4Xa7UV5ejqKiIsTHx8NsNmPPnj1MKM/MzEQkEkFWVhZmz56Njh07wufzoaysDACQlJTEwquExy31kExKSsL/Y+/Nw+Sqyvzxz619X3vfu9Mhnc5GFkgCyBKWiOio4AIzI+gwzIiER8Ht0eGruIyIOm4j4HwVlfkqMuJPXAAZwm72kI0kJJ29u9PdVd217/v9/VF5T06dvre6E5KQkPo8D6Sr6t5zzz333HPe9/Nuzc3NzKO8WCzia1/7GpLJJL7zne8wD+Czeb7XMBln+r166KGH8N3vfhc+nw8LFizAf/7nf+Liiy8+7detoYYTwaFDh3Do0KGqx1x22WUnVN35fMUp9Yf3+XwAynmieDQ2NrLffD4fGhoaKjuh08Hj8bBjRDzwwANTMs0nA55zJeGYz09yrlSAFnOqkJCgphSdjVB6FvQ8+IqRZzP4e+D7yofa0W9KOSBreHtQC7GooRrOlhCLN954g+Wy9Hq9uOGGG07r9c4l8Kk5gHJS+Vwuh2w2W1HhOpPJYGhoCGNjY8jn83C5XGhqaoLRaITVaoXFYoHVaoXZbGaGLwrb5WUB2m8pGoL2LLGqNA8+7Pd8giRJLA8igEmyCu319P6QR+rY2BheffVVRCIRHD58GBdddBHa2tqQSqVgsVhYoRYKn89kMtDpdEin0ygUCojH4yxdRDabRSaTgc1mY3k4C4UCq57N531MpVIoFosIBAJYunQpjEYj8xajENRCocAK0PAFe+j+6B40Gg0jHc8HHD58GD6fD9dccw37zul0YunSpVi/fj1uvvlmrF+/Hi6Xq6Lg1zXXXAONRoONGzcqOh8Ayg4IZwtkWcaWLVuwatUqdHV1IZPJ4KqrrsJFF12E9773vZgzZw76+/vx+uuvY+PGjaivr4ff70dbWxsWLlyIDRs2oLW1FdlsFpIkMZJ8zpw5aGxsxOjoKNra2jA6Ooqmpia43W4MDQ3B7/fD4/HgW9/6FjweD77yla9g5syZ8Hg8OHDgAOLxOGRZxsTEBAKBAPP+TafT2L17NwBgz549SCQS+MUvfoHm5mZ0dHQAKOtqsVgMFosFHR0dFcXFenp6WM5H8i7WaDS49tprcfvtt+PGG2/ElccKHdRk3BrU8D//8z+499578dOf/hRLly7FD3/4Q6xcuRIDAwOTeIIaang70dPTM6lGQA0nh3MiEceXvvQl3HvvvewzeTyeKpDFnf6ulqj9bARPYpECJOYQJCISqAy3PttA3gJAZYW9c+U58Dkp6TnwY60UUlbD24uVK1fi5z//OX7zm9+wEIsnnniiFmJRAwDge9/73lkRYvGHP/wB3/72t7FkyRL84Ac/OK+8kqtBDHWkwh86nQ6JRAKSJCGVSsHv9yMajcJsNjOPIj5XIhVqoXXbaDSyEF1+H+VJM35v4sNoz3bPtjMN8gCkkHe+aAUZFmlPzOfziMfj2Lx5Mw4cOIDZs2fj2muvRWNjI7LZLPR6PZLJJCKRCMxmM5xOJ8uFR8/A6/Wy8G6dTsc8KAEwz1ebzYZSqcQ8XqPRKMv3uX37dtTX18PpdMJut7O8q3q9nlUsJzJSLcJBlsvFjahwzfkwH06X8wFw+hwQThb8ujM4OIhVq1ZBp9Nh+/btuOqqq9DV1cUMFvPmzYNOp8PixYsxODiIXbt2oa6uDtdffz22b9+OlpYW6HQ6LFmyBKOjo0wfmTFjBhoaGpDJZOB2u1FXVwe73Y4jR45g//79uPTSS/HVr34VF198MTQaDebMmYPvfe97GBsbYzrTo48+iqNHjyIejyMej7P8t5IkQa/XI5vNYs2aNfjQhz6ED33oQ5iYmEBzczNuvvlm9PT0IJFIYN26dbj00kvZO2S327Fo0SKWi3Xfvn3405/+hJ///OcIBoPw+/0VUVeE8+EdqGH6+P73v4877riDFdT76U9/imeeeQa/+MUvJuVjr6GGGt4ZOKXEIyWZ9/v9aG5uZt/7/X4Wet3U1ITx8fGK8wqFAkKhkGqSeqPReMorAVbzdjybczoqgfd45ElIcZMXyUg69+2ESLzxxB3lvTmXlDhe8VBK8s+Tk3zo3dsNXrk+UzhbQiw+85nP4DOf+cwZv24N5wZuvfVWXHbZZVWPORMFVu6//37cf//9p/065zJoXS0Wi4jH4wCAVCqFdDoNl8uF9vZ2mM1m6HQ65q3GV4XW6XSTvOv5XItny3p9LoEIOiIf+XQw/H5PnljRaBTxeBwjIyO45JJLMGPGDNjtdqRSKWi1WhiNRpRKJbhcLlgsFuZNSLk8S6USqyQtSRLzdEyn0xgfH4dOp0N9fT3Ll0eVqU0mEywWC9auXQu9Xs/CualSNXm/0n+ZTIbdB3k3Uj/oHJfLdU7JL2czTrcDwsmAnBYefPBBjIyMoKOjA7lcDl1dXWwdobD9ZcuW4dFHH8UVV1yB7du3Y9euXfjjH/+IG264AZFIBH19fQiFQsxLt7W1FYsXL0Y+n0d7ezuOHDmCYDCIJ554Ag0NDfjiF7+IT37yk3A6ncxbuKurC9/73vfw7LPP4uGHH4bT6URvby+6u7uxdu1aOBwO1NXVwefzoVAooK2tDbt27UKhUMCuXbuwa9cu5HI5aLVavPbaa/iv//oveL1eXHjhhRgbG4PH46kokHTgwAF897vfxdatW+F0OvHpT3+aEUcLFixAd3c3Cz2svQM18MjlctiyZQu+9KUvse80Gg2uueYarF+/ftLxosdzqVRCKBSC1+utza0aajhFkGUZ8XgcLS0tp40HO6XEY3d3N5qamvDiiy8yojEWi2Hjxo248847AQDLly9HJBLBli1bsHjxYgDASy+9hFKpdMaq8ygVkiESiP4Gzq2NknJOUfgX3RdwnJjkk62fbffGPwsS1MUKoOcC+LA7McxdyQvyXCK4TyVqIRY1nCuohVicOyCPtWw2C7vdjmKxCIvFAp1Ox3KOmc3mSQW/6D+xeNl09h4xrUYNleDzUFPkBe2B5NlFFaUDgQASiQS2bt2Kvr4+9PT0wGazIRKJwGKxsIrVzc3NzBsVKOdYpOI1TqeTFQMij7NSqYRcLseecbFYhMvlYm0kk0nkcjkcPnwYuVwO7e3t6O/vh81mg16vr/B0JFmFT59CZCSR2UajkZGa5xNOl/MBcHocEN4qZFnG008/jeeffx4XX3wxjhw5gkKhgFgshkgkgvb2dkQiEcRiMWg0GsyaNQvj4+NobW3F4OAggsEg9u3bh+uuuw4LFizA//2//xfvete7YLfbsWzZMgDlsXv66afxyiuvoKOjAw888ADe8573oLW1VXF9MplMeP/734/58+fjm9/8JjKZDObMmYPe3l4kEgn4fD5IkoSBgQHs3LkTJpOJFeEiMqdUKuHZZ5/Fhz/8YSxYsADXXXcd+vv7WbX3lpYWbNy4EXfddRernu33+/HTn/4UJpMJ+/fvx1VXXYX77rsPn/rUp85bObcGdQQCARSLRUXv6L179046/mzzeK6hhncyhoeH0dbWdlraPmHiMZFI4MCBA+zz4cOHsX37dng8HnR0dOAzn/kMvvnNb2LmzJmsol1LSwtLPj179my8+93vxh133IGf/vSnyOfzWLVqFW6++eZpJ5U+GYgKAQmPRASdzQVXqoHvJwkOJBDz3o2kUKmdeyah9izIa4AIx7ORIFUD791IhCOFX9FzoOdCc+1ElNvTibdDWa6FWNRQQw2nAvzaK0kSI4symQzy+Tzy+Twjgvi8jGrrr5ii5ET7UiMfJ4PIRqXxoc+ZTAbpdBrbt2+H2+3GzJkzYTQaWZ65UCgEl8uFuro65lVIHmdU3KJUKiGfz0On07EK5gAYGWQ2m1khGpofwWAQhUIB4+PjCIfDaG1txUUXXQSr1crkEJJLxFyi4jwymUwwGAwshJ++P19y3Z0rzgenCqlUCv/xH/8Bs9mM+vp6HDhwAFqtFjfddBMWLFjAjM2NjY0oFotIJpMAgLGxMeh0Ouh0OqxduxbhcBiRSATNzc1YtGgRAoEA/vznP+OFF15AJpPBggUL8M1vfhPvfe970dHRMYnIE+eWTqfDzJkz8ZOf/ASPP/44Hn/8cVx66aWw2Wzo7u5GOBzG6OgoLr74YtTV1WH79u3w+/0oFArweDyIRqMolUrYvHkz1q1bh1/84he444478MlPfhIAcPToUdx99904cOAA8zxeunQp2tvbmWf5U089he9///t417vehfnz558X87+G0wfR4zkajaKjowOHDx9mXsJK66wYZcZHBIppVMRz1CC2x5/Hf+a/4/cJfi/knVXoGD4Ck9cXSUcmPZLOA1BhSOWvrdR3sV/V6hMotUOGW6X74vvCtyOOOe9UxI+H2jX5tpWehdLYilGgBPG5ie1V6yt/jNrY8uMknitGQorfiTmw+XFVer68I514vHiMWtv8+MViMXR2dsJutyuOz6nACROPr7/+Oq666ir2mRaC2267Db/61a/whS98AclkEv/yL/+CSCSCyy67DM8991xFpZ/f/OY3WLVqFa6++mpoNBrcdNNN+PGPf3wKbmdqENHIFy6hl/tc3hh5y/vJKk1nAvwLwYdaAagoznA29v1EwHvP8HlDzzYoef+ebpxoiAVQC7OooYbTjTMRYnE6wQubFI5LhQ/49ClK64WSsvJW+lHDcUiSxKpP037PK26FQgHpdBqRSATr1q2D3W5Hb28vTCYTkskk7HY7/H4/6uvr4fV6mScjUJk7kvJyUh7IWCyGdevWobW1FQ6HAy6XC4VCAQaDAfl8HplMBna7HWazGSMjI9i/fz+am5tx0UUXVeRPpQrWpMCIUQ10DOUENRqNrH/8GLxTcK46H5wq8DLs5s2b4fP5sHLlSoyNjcFgMOD2229HKBRCKBSC3W7H3r17MX/+fBSLRezduxc7d+5EXV0d/H4/I8b37t2LQqEAp9OJF198ETabDZ2dnbjnnntwySWXYMGCBczbs5rBWlRqrVYr/vmf/xmXX345fvCDH+B///d/cfHFF+OKK65AXV0dJiYmMH/+fFx88cXYt28fXnrpJdTV1cFoNGL79u2IRqOQZRnZbBaPPPII/va3v+GLX/wiDh06hEQigZ/85Ce46qqrYLVaWci3LMvIZDJwOBz4+c9/jsceewzf/e53K8iId9L7UMPJgQxIfr+/4nu/36/o+azm8exwONh6rURWicQRH1lHoHWdIObtFUk0+l5JZxLJITpOiayjftB+Qn3g21UjFEViTOybEglFx0xFiCmRY0pEolhQj29nquKpooFXiUAT26N7E8GPg/gsxXtSujf+mGqkqNqY8vdA+cVFMlnt+iKhSXOEZBuxqCF/Pf66Yj/5caFnJJ4vkpL8tU7nGn3CxOOVxyqVqUGSJHz961/H17/+ddVjPB4PHn/88RO99CkBbyHgCUfxJTwXUU0gOdtAz4F/YWixPNe8TnlMR6k920DP4kwRjycaYgHUwixqqOFMoVqIxQMPPIA//OEP2Lt3L8xmMy655BI8+OCDmDVrFjsmk8ngs5/9LJ544glks1msXLkSDz/8cMX7PjQ0hDvvvBMvv/wybDYbbrvtNjzwwAOKnvknA0mSWO6/U73+Klm1lYTEE72umkBb7fhzBUQw0v5Oih2FQKdSKWzevBlarRb9/f3QaDTI5XKQZRmBQABNTU3weDwVpCXJD5FIhCmJExMTMJlM2Lp1K44cOQIAaG9vZ0K1wWCoeF7pdBqDg4PYsWMHHA4HZs2aBavVyrwmKWyfvE0onJoHVT0nxZg8Hd+pXo7nuvPBqUKpVMKf/vQntLW14eDBg8jlcvD7/XjPe96DtrY21NfXI5fLYd68eTCbzdi0aRMGBwcxb948vPjii8wYbbVakclk8OCDD+Lyyy9HLBaDw+FguWjfikxJ69Hs2bPx4x//GOvXr8ePfvQj/O///i8++tGPspy2yWQSTqcTJpMJY2NjKBQKFQo8Xe+NN97AfffdB4/Hgx//+Me49tprFQ3qJpMJS5YsgcPhwGc+8xl8/OMfx7x5894RelYNpwYGgwGLFy/Giy++yIwSpVIJL774IlatWjXtdngCZSqyC5hMJNJ3PJQIHiX9SCSN6DuebBQhel7y5/EOROTdyO959DvpyiIZJnqwKZFbFBXA78UiuVWNHBP7qkSKis9BPEZsV4nsE8eeJ9DUrj0dHZYnOClKVIkEVSKxp7t2ibzGdHVrWT4eGan0XJT6yBcTJkznPVAifXl+7HTinKhqfaogPjj6t7YRnnmIz0IstFJ7JmcO9BxEhepsglqYxauvvgqbzQYAFYun6GWqZq0SLYf89+JnmqO813T5R0DC5HkrSRJkyIBc+ZlaLRVLkDTHjpdlQJIgyfTx2B+aSqNIxWZRkiFx1yzJxyyCkqbcrozjV5OPjUu5u+X/yZXWX2Yt1WpQ/pN6Kh07/Pi9EDRaLSTpWNul8t1JkgQI7y+vxMjFyo2NH1N+7Cbd7wmQMgQ1AYL+rSZMnMzeIK5ragKS0jmiBZP+BlAxPryRhj+eJ2PE64vtKP2WSCRw+eWXVw2xePXVV3HXXXfhoosuQqFQwJe//GVcd911ePPNN1n13nvuuQfPPPMMnnzySTidTqxatQo33ngj1q5dC6C8ztxwww1oamrCunXrMDY2hltvvRV6vR7f+ta3Tmi8q6Has3ur+wuNcSKRQCaTQSaTgSzLsFgsAMCs3lRtWavVsvVDFKDFuT7da58re6SSQsinuslkMhgdHcXY2BhWrFjBxiqXyyEUCsHtdsPhcDBlyWq1IpvNolQqIZFIIJ1Oo1QqwefzIRaLYWRkhIXWe71eAMernZPXYzQaRSqVwvj4OAYGBtDS0oLZs2ejo6MDer0e+XyeeW/xxlAiTCVJqni+JpMJJpPpHRW1oYZz3fngVCEej+PAgQO48sorcejQIbz44ouYNWsWmpqa2PzctWsXstksenp6kM/nYTKZWGXpZDKJQqGAeDwOg8EAl8sFu90Ou92uqOifCJT2PIPBgCuuuAIXXXQRXn31VTz66KMIhULo7e3FZZddhgULFkCj0SAQCOBvf/sbK7iUzWYRj8chSRLsdjtGR0fxiU98Atdcc42qZ7xGo0F7eztSqRTmzp2Ln/70p/jxj398ygxLNbwzcO+99+K2227DkiVLcPHFF+OHP/whkskkS8E0XajJXEBl3n1RBxCP58kc+l1trSsWi4pV26utjbzXI09AKt2HeCy/H/GF2pR0ZiVdh9qXpOMRIel0GoVCgeXB5vtJ+54SSSheQxxDceynWr94GZbvsxKpyR/HE7P8uIjkp6jnqekE/Gela4vHKt07r3Mq3YMa+HviyVAl/UDpPKXx5IlPpXsR/z0ZHetkcN7sAiLbLssysya+UwXEsx3ii1p7Fm8flBav04UTDbEA1MMsbDYbIzz4BZoWcDXLIL8o8yEV1I6a4K+0jsjClKXriEIJnSOGUSgRn0obifi9GgHBk1KTNvNjzCNPRFEbTFiQNMfYycnu/IpjcqxZ0VImEmV0PfEetJJmEmGmdE1emKHPJ0vaEPgNWen+qimAIpGiRF5PhzCdapx4QYoPN6G2aZ6Jz1ppLT3RexTx3HPPVXz+1a9+hYaGBmzZsgWXX345otEoHn30UTz++ONYsWIFAOCXv/wlZs+ejQ0bNmDZsmV4/vnn8eabb+KFF15AY2MjLrzwQnzjG9/AF7/4Rdx///2TwlRPBKd7/6DxI/IqHA7DZDKxXJKSJLHQYbPZjFwuB51Ox0K+eeFSLGgnElx03FslId5ukFejTqdDoVBgIddELOZyObz66qtobW2FwWBgFakTiQRcLhcaGxsrqpBTQZpUKoVMJsMUDqvViqNHj6KtrQ3BYBAulwtWqxU2mw1msxlmsxmJRALZbBbRaBRHjx6Fz+dDZ2cn5syZwyr2FgoFtt+IRYiAcv48o9HIis3o9XqYzWbVtaGGdx5KpRLWrFmDSCSCaDSKrVu3olQq4Y477sD+/ftZfsvZs2czAjKdTkOr1WJoaAi5XA6NjY0oFArIZDKoq6tDW1vbaZ03tLbYbDbccMMNuOqqq7Bu3Tr8/Oc/x0MPPYTLL78cN9xwA7Zv3868dgcHB7Fx40Z4PB7Y7XbIsoympibMnTsXqVSKvctUvZ1A70tvby/++Z//GXfeeScOHjyICy64oPZu1MDw0Y9+FBMTE/jKV74Cn8+HCy+8EM8999ykaKhqUDLAqh2nRsbxegMdx8uFSoQlUJmLkT+ej6rk/+Xbo7+VajIAqEghwnMW1DbvsUf7q2j4or7wcgUvQ5rNZqTTaVa0jY41Go0V90WyCPWZ/hZlTxH8/sn3S8yLyY+RSHby48+fryZvi+uQ+KzpWKVaC/S3khPUVGSlCCViWCn/Jw8x5Z+SzqokD/LPQQzXVyKQ+bkmzu8zkWbpvCEeCfyDrW2Abx8k6Xj1bV7hquHMg8b+TFXgPFUhFoBySAT/W7XNQRQ4+HZEIaNicyQnReCYh18lESZuFkr5VKjdakKSGgGqRBpWG5fKBo7/yXtgqW04/EasNNbFYpF5N0614asZFpS88Ah8Am22TmiksocopLIvpgRItImWLwZy2NQobLDiPSiNtZIwUo0MVmtDaa8RhVElAUf8m18j+XktEtlK80/ss9q8PxlEo1EAZQ8mANiyZQvy+TyuueYadkxfXx86Ojqwfv16LFu2DOvXr8e8efMqlIuVK1fizjvvxO7du7Fw4cJJ1xFzvMZisbfU7xOBqDRkMhnEYjGkUimkUinIsgyz2cwKlaTTaSQSCSQSCVgsFnR2dsJms7HKx5RvslAoMOKYDCB0LVICeEWCzqfnWy1n8Nkk2+TzeQCoeH65XI7997e//Q0jIyOYM2cOcrkcrFYrgsEgzGYzPB4PCzujCtWyXM5FSoU6nE4nCoUCgsEg3G43EokEtFotnE4nLBYLzGYzDAYDkskkEokEYrEY/H4/UqkU+vv70d3dDY/HA0mSkMvlmOIlyzILd+PXHyIxyWBFXo81nF9Yv349dDodNm3ahFQqhS984Qv44Ac/yObCli1bMHfuXCSTSezfvx/BYBBvvvkmRkZGMDY2xpR+APjgBz+I1tZWAKfn3VVq02Qy4aqrrsKll16KrVu34o9//CO+/OUvQ6PRYO7cuVi0aBFbp2OxGFwuF9auXYvPfe5zeO211xAKhTB//ny0trZO2k+IcKD1rqGhAT/72c/w4IMP1t6VGiqwatWqE5b7eUxHzuehJlPTXkzfieQXQSksWyRvRLJJTbamfTydTkOWyzmK+fQGZKwDyvtnKpWC2Wxmx9IeRbp0qVRi8gX1g/f4FIkpWS5HaZBcI0kSstkscrkcK5BG90epUcT0D6IcK+oTSs+G1yfEsVM6n37ndSmlNY0n4ETZXel5iscoOSLwhKh4P9V0OlEfUCJTRSjpBErjq0aCKr0LYn9FfUX8+0zgvCIeaVDPxiIf5xtEZbqGtwc8sXQm34tTFWIBTF78lTzvxA2IX6jFUIxq+V74JV2GjJIsQyMQE9Qn8Tr0vdqmoQa1jVuJqBI9CpXAHyvmpFMit5T6IN4X/7coGIgbOh3DNnStBhTFfXzcSmVaUSMBpePnEMlJV5UhHyMfOeFQKhOTkkYqk8IkyPDjLpX9NDWSBhKkMolM/T/2Ox2t0WhYmHk5nFwck8kehnRUST5GqkIDDT8uEteGfPx4fuz5cRTn9KSwXf6ZyeV5KbG+lC8naSR2PVEgOpl1uFQq4TOf+QwuvfRSzJ07FwDg8/lY2CCPxsZG+Hw+doxSflf6TQlnQ47XQqHAyEYiqDQaDbLZLGS5XIAhHA5jaGgI4XAY6XQayWQSW7duhdFoRF1dHRoaGuByudDW1gaj0ciUBJ54pOtQLsJ8Pg+NRsOOJa9Ak8kEvV4/KQ/b2UQ6AuWcn6S00DuTy+WQzWbxxhtv4KWXXkJ/fz+sVitMJhMbCyIDaRxonsZiMUSjUWi1WtTV1SGXy6FQKECv1yOXyyEcDqOzsxNOpxOyXA4xNRgMCAaDCIfD8Pl8MJvNWLhwIbxeL2w2G1Pa9Ho9DAYDy3FHiiF5OZKnIymp9Bmobkiq4Z0DekfffPNNuFwu7N69G8ViEe95z3swODiImTNnIpfLob29HVqtFrt27UI0GsXw8DC6u7sxNDQEi8WCYDAIjUYDp9OJ22+//YzrJbRumM1mLF++HEuXLkUkEsHmzZvxhz/8AQ8//DACgQAymQx0Oh0sFguWL1+OXbt2IRgM4pVXXsHVV1/NqsI3NjZCkiREo1Hs378fixYtgiRJ6OjowHve8x786le/wqc+9SnMmDFjkjJdQw0nC1HWVCK16Dgl8qmabKtGDonEIv8bT+zxv5N8RvmD+XP0ej3S6TTC4TAzlNF6QJES9Jn2TooMIXKQogJEookn7EhO0ev1k+R0Ij3J6JnNZlEsFis8KSVJYlELRIyKpJVauDPfJ348+H6K+gRPnCoRyGrksJLhnZ8bSoQg3zdRJxSP48G3q3Q9tT6roVp74lwXHQ3o32ryvHis+NuZwHlFPAI14fDtxomSLjWcGZxJawdwakIsAPWFkl+Q+U1IzUI1LesP91G0gtF3/HlqljOla/N9rnZONTJTyfNNbIO/VxIO6Fw6jgQP2ngBTBKu+OuIf/Nt8sq7eDzfHyLeJI0EjaSBLB8T3uSyh6mkPTbOkrL3JX8t3qghSRLLv8mfw98vI/0kkTw8diyOe1NSWH3lfUjs//z3pVIJMvPmRDlfp5CTht0LG4fJ5DgRU7yHK82dklyCJB2/T558PN5puUy0SlLZC1Qhb6iakF0Nd911F3bt2oU1a9ac0HknAzHHaywWQ3t7+2m/LiGfzyMWizHvAyKf9Ho9stksfD4fjh49isHBQSSTSRZWSWkgRkdHcfDgQZjNZrS2tqK3txd1dXWw2+2wWq2wWq2QJAmJRIKRliT8E5FbKpVgNBphs9mQz+dZSDARkaIgfraASDugPI7pdBrZbBbj4+PYvHkzjEYjOjo6mCKVz+fh9XphsVhYOKdWq0Uul0MkEkEqlYIklXM9JhIJAMeVMZvNBovFgnQ6jXw+D5vNhmKxiIMHDyIcDiMSicBisaC/vx9OpxNWqxUGg4GNl9VqZYocEY5EMNI90FrGK4eEs2ncazh9GB8fx+DgIBYsWIB4PA673c6I62w2i40bN2Lx4sXYsGEDhoeHkUqlMDExgT179iAej2N8fJzNq6uvvhq9vb1n3AjPz1XyuvZ6vXj3u9+Na6+9FrFYDGNjYxgeHsbq1auxbds22Gw2rFmzBtu3b8e8efMwMjKCpqamiirwVquVrc2SJMHr9eLmm2/Gyy+/jF//+tf4P//n/9QcDmo4pVAy9CuRS+L3ajkWxeOVQobF9pT+Jm9/+o48Bslbnie2KLy5VCohGo0yg5lI7pGnI5/7ETi+t1JkBLUnyuhieim6L35fo/MoFYQkSdDr9WxvLJVKjIDUaDTse2pTfDZ0/6JcC6CCLKUoD554U2tXHG8RSuSySFQqzQtZltn4iN+rrVt8H0UHFqU+8nom3TdPOPKyvpirUtRV1cZaaTzENkUv2DOF8454BGrC4dmE2rM4f/FWQywAZdJEtOTx3/O/A5Wu+Up5Btl1hOsqEWgnOpenIgn4/orhEiLJKZJS/DVE6xn/L22UvEWU33SpbdEzUk0YULqH6RKx4rjw1xI33umiGoHL94nusdozVBpbEeJz4MldPi+jUtvUpkbSAFqJCWQ8cStCK1UmsgaOE7NKwlOZoJw8Bnz+yOlg1apVePrpp/Haa69VVMBuampiBBHv9cjnb21qasKmTZsq2qN8ryea4/VMgcaGPBVkuez1lM/nMTw8jE2bNiEYDEKr1cLr9aK9vZ0lba+vr0csFkM+n4ff70c8HseGDRtgNBqZN6PdbkexWEQgEGD3yz8zt9uNCy+8EF6vF7FYDI2NjSiVSkgmk0xBIO9HUlR4vJ37rFarZeFcer0eoVAIsiyzkPT6+nrMmTMH9fX1LF+mwWBAOp2GxWJBsVhEKBRiYdIWi4WRtYVCAbFYDKVSCR6PB+FwmBWRoQrW0WgUY2NjSCQSsNlsaGtrg9PpZEod70UqSVJFTk7yAKHfCHq9flI+phreuRDfp927d6O7uxv79+9HLBbD3Llz0d7eDpPJhHQ6jdmzZyMSieDgwYNIJpMIh8MolUrMaDAxMYFcLof3vve9+M53vvO2rm08aD7rdDq43W64XC709fVh69atWLhwIbLZLPbt24dSqYSDBw/iySefxBe/+EUMDAywvJY6nQ6NjY1szBwOB8LhMN773vfiZz/7GT75yU+esIG5hhrUoEZOKRGB4ndiLkaCKLPSv2L7SoQTUOntSLkaab8Q+0DGzFwuB71ej2KxCJPJNMnrkPYmWT7u3ZjJZJBKpaDX62Gz2SoiBig/JK0toixOMqIoO/LH6XQ62Gw2FAoFSFI5DJuITZI38vk884Dk89qrjalS0RfxmKnO45+B0mfxWFFnomevROjR+eL+rua9yB+jlDNf7X7EfvNkaLXzlfS/6UAkW5WufyI6wFtBzexUQw01vGOgRjoC1a1e/ELOEzHsP7lUcSxrE8eJQf78aou8Wp+pPaUzlPIgsr8lCSWBWKz2Hx2jNFaiMELChHhvZCmd7n1VPAd6BlLZAxBVnhV/LTEMXO3Z0XiJCahJ2OA9I8W2xfusdm9if0XCVGxffG5qQpZ0zDOS/oVEnp/l9rQ6bTkEXZKgOWYdVhoXpfFTm5vTeZ50jVWrVuGpp57CSy+9hO7u7orfFy9eDL1ejxdffJF9NzAwgKGhISxfvhwAsHz5cuzcuRPj4+PsmNWrV8PhcKC/v3/KPrwdoLGiXErFYhGpVArDw8N49dVXkU6n0d7ejjlz5qChoQFdXV1oaGiA0WhEoVCA0+lEa2sry502f/58zJgxAzNmzIDX60U6nUYgEGAKf0dHB3p7e7FgwQLMmTMHBoMB69atQzAYRCaTQSQSYR55mUwGQNlzIJlMIpfLTV6nprkWnQ7w7wJQ9ogi8iWZTKK7u5uFY2ezWRiNRhSLRTidTmi1WkSjUfh8PuzYsQMHDx7E6Ogocrkc8zCjsGgiNiVJgslkgs1mw549e7B3714kk0k0NDRgzpw56Onpgd1uZ4oakZgWiwUmkwlGo5GFfRuNRqZgEQlJhGWNdDw/USwW8ec//xmRSASyLKO9vR2f+tSnMDY2xsgBt9uNZDKJ5uZmRCIRmM1mZDIZXHjhhfD5fCiVSujr68M3vvENNDQ0sLbfzjkl7kv8336/H7lcDlu2bGFrGk9wAMcNmRqNBuPj48hms0x+aG9vx/Lly5FIJLBp06YzpuDWcH6Al3eqkVd07FTyGn8cgAr5kD+/VCoxgo/IR/qbyDo6P5PJsLQs9F6IsjUdS+QihV0Xi0UUCgWWF5r6YTAYWM7HeDyOWCzGvB4pZ38qlWLXBcD2LroGfab2xTEFKvNLZ7NZ5u3IF6oBULEXn8hzo79Folj8m38GqvKzJE16XmSQ5c9VIz3FNZD6IIZdT+VAMB0oOYzwuoJImItOBG9FphOJ2DNJPp6XHo811FDDOwPTWXiViEb6zHuV0XfV2uEJQvpX3IQo/IAwFYFVYTE7/gMAQCtsCjwxSiSlLB/P6adRuZ6SQMZvXCLxVm1cRYFN7b7E34lslIEyoUb3WUWIUOqnkkVV6XsiInghUa1/SmE0U0E8R80KWW2MlAQKoBz+LWk0LN8kI74hQSpxwm9J3duXzzUElOelBGnSMz6R+77rrrvw+OOP409/+hPsdjvLyeh0OmE2m1m+snvvvRcejwcOhwN33303li9fjmXLlgEArrvuOvT39+NjH/sYvvOd78Dn8+G+++7DXXfdddZ4/ojgSWsKFT58+DDWrl0Lh8MBj8eD5uZmRgoWi0W0t7fD5/Ohrq6OVVkmL1Dy3jMYDGhra2MJ3WVZRiqVYp6QFE49b948DAwMYMOGDejv72fCqcPhYAoAEWOyLLMK21qOmH67QPOTlCeHwwGr1Yq9e/fC4XDAbDYjFAohHo9DlmXMnTuXVQQPBoPYv38/9u7dy3JiNjY2YteuXZgzZw70ej0sFgvzbNTpdPB4PDAajQiFQjhw4AD0ej3mz5+Prq4u1NXVwWKxQKMpF5AxmUxsnaDQaTG0jcaaxne6a3sN70ykUils3boVc+fOxdq1a/GP//iPLAdiLpfD2rVrcfHFF8NkMmHbtm0olUowGAywWq14+umnWR63r371q5gxY8akkLyzAeKeEo1G4fV6sXz5cvziF78AUE4fceDAAVgsFubFTNi/fz+8Xi/6+vrYOmS1WtHW1oY//vGPWLlyJUutUEMNbwW8zMXL9vxn8TeRdOGh1AZPRvLXpb2BDJEUdsyHMBMxSbIoeSjyqTqI1MtkMmzvlySJFVQj0oyuQ2HYsiyz/Y9Iv2KxiFgsBqvVygjDQqGAdDpdEUnBG+H5/mYyGdZfABVGNj70m4wOZAAkL0HKf82HTBPUvBYn6QkCqhGR/DF8DkexHZ4kFZ0W+FB6Wq/434HJep0alPQjsU+8zshfR8lgzEe7Ub/E8ZrO3iFeR2n+Kz2f04Ea8VhDDTW8I6BEdolWLCVrTjVLF0EW1mLeM1FcwKdauGkzmeo46i8v4PAEXAlTW97oXCWSifeiVMqfolZBbjr3qiT4SUQ6ClZDSaH/oqDBf0c5KMXf+OvygpTYJ7XrqN1HNZJOHAtRWBHnFi/wTBobhbb5Z8OfoyQIK+WHmfQuyDIAgcBWEdSU8MgjjwAArrzyyorvf/nLX+LjH/84AOAHP/gBNBoNbrrpJmSzWaxcuRIPP/wwO1ar1eLpp5/GnXfeieXLl8NqteK2227D17/+9Smvf6YhPvdkMolsNotAIIB169bBZDLBbrejqakJVqsVRqMRvb29GBwcBAC4XC7k83mmjFAxEr6wTENDA7LZLPL5PFM6DAYDcrkc0uk0YrEYDh8+DLvdjvHxcWzatAnZbBY9PT0wmUyQJAmpVApOp5MpBeI7w5OS1XCqhE7+OqSM8Ennk8kkhoeHcfXVV6Ourg5AuUK6yWSC3++H1+uF0WhENBrFgQMHWJ7IVCqFzZs3o7m5GbFYDHq9HvX19czzhDwg4/E4Nm7cCFmW0dPTg56eHnR2djIFj54Hn9eKPEeoz/x6I3ot13D+4tChQxgdHUVXVxcL3V+0aBHq6uqg0WjQ39+P1atXY3BwkOUaff311xGNRiHLMkwmE+699168973vVc19fDZBlmVEo1F0dHQgEongsssuw+7duzE6OopSqQSTyYT+/n7E43F4PB4AwKWXXlpB2EiSBI/Hgzlz5mDz5s2MPKmhhlMFkmEoxYySERg4HhYtkk/i8bxcJ8rKorxZKpVYWhDyACaPYNrnyfBmMpmg0+lYUTTaX8gQls1mkU6n2fF8mh29Xs+McrxHJR/6XCwWWaEavV7P0ooQCUpVsIlQ5PsrSeVoAcqZTAQkjQ3dC0/WSZKEXC7HxoFPSyLK6bwMrJTHkdeN1M4RZVpeT6Hj+OfFX1+cL3w/1QhRMQcoP1fE+SPmZuT7wKez4sHPRd5ZQCQiRUKSn4tT6THVzuXH42QcME4GNeKxhhpqOKehRC7RBsDn6RA3IlkuVz4GXzVGklA+RIIs04ZT/q6CUEIl8Sgu7Dx4CxPfR6XNouKTsKGIpKm4zSgJWjwRpUR28d+Lm5+SMCZeS21jV7uWRPd17F+lvvCf6W9+HHgPL/HaSgKh2jGiICMKE/y1+bGk43gBlwQ+kawV2xLvSZwX4rHiv4pjTeeWDyzPTeGZis9KnLPTJVWmI5SYTCY89NBDeOihh1SP6ezsxLPPPjtlW28n+HulMOBMJoNkMomdO3cin8+joaEBTU1NsNls8Hg88Hq9SCQSaG9vx4EDB2AwGJBMJlFfX8+Sv9vtdrjdbjidTuzZswcWiwVerxd6vR75fB6ZTAbBYBB//vOf8c///M9obW1FMBhEKpVCJpPB4OAg9uzZg8HBQVx88cXo7Oxk3gs2m42tefx6wYeAVbPaTyXAnihErwoAyGazWL9+PXQ6HRYvXgyHw4HBwUGUSiVYrVZoNBpEo1FoNBq8/vrrCAQCsNvtrDK1w+FgShTlxQLKYV52ux2pVAoHDhxAPB5n4eqdnZ2wWCzsHilkmieB+XeNiEfe26SGGgDg4MGDaG5uhsfjwcjICEwmE/bv34/6+nokk0k8+OCDKJVK6O3tRXNzM8LhMAYGBmCz2RAKhfDpT38an//85xnxdi7MLavVigULFuB3v/sdQqEQ6urqMDY2hiNHjiAajSIYDGLGjBkAJiuw/L6zcOFC/PnPf8bw8HBFDuAaajhZ8DIeL+coGY15WVLNaKsmJym9p/yeSgYt2scLhQJLCUJ7DsmNlPMRAAtvpv1Rq9XCbDYDOC53UGRWLpdjxCUZJwFUeFFKUjkSIp/PIx6PIxgMwmKxsDzG1C7J0FRAje6T2jSbzcjn88xIwEcP0b1SbkfK/ajRaBCPx1nRO3o+/L3Tdai6Nh1DhkCRSCTwMgT/PZ0rkmb8ePLh36JczJOV/FzgrzuV7qZEXotzjSdbRUzSA4U2aP4o5ZBU6ofYlqjPiCSpWj9OF2rEYw011PCOAS2wvMVItApVkELlsyrOlyBBc4yQLLcnV1RGriAf5eOViIFKT7Rqm4AoDLHfhfuRFAihCiJOQbjnNy3+3sU2lEhKvg2eoJiuFayakFbxOyZveOJmLybrBjBJoZkuUaIkTE73vGpzSE3oVRsLUYARN38lEltNwGDHAxV5QSVJgkaBEFYjmmuoDgpTIo/EQCCA/fv3Y+bMmSycvLGxEW63G+l0GrJcTuju9XoxPj4Ot9uNfD4Pk8kEs9mMaDSKdDrNkrbv3r0bS5YsgdVqhU6ng8PhgNFoxPXXXw+DwYB8Pg+32w2LxYKGhgYWOjUxMYG1a9ciFAqhr6+PhXqSMsEbEURBm8g0MReS0nv4VsErEoVCAfv378fOnTtx6aWXor6+HpFIBBqNBl1dXdi7dy/q6uqQTCYBAHPnzoXJZMLQ0BCi0ShcLhdaW1vhdDrZ/WYyGeRyOdhsNqTTaRw+fBgjIyNYsmQJ5s2bB4fDwULEKEen0WhkygpVCRUNEaQIKa2VNZyfkGUZiUQChUIBPp8PyWQS8+bNQ3t7O3bv3o3vf//72L9/P4rFIv7whz9g5syZGBoaQjabRSQSwZ133okvfelLLDzybAe9F0ajESMjI7jggguwadMm+P1+FItFHD58GH/961/xsY99rOKcUqmETCbDCBRZltHQ0MDWOMpLW0MNbxVKxAtPJomyWTXjMN+O2J4a+PbobzJmGQwGZLNZFtFQLBaZd2I2mwVQmXNRluWK9E9UmI28GKmoDLXFh0MTgUl9MRgMcLlcKBQKSCQSLOKAiEtCOp2GRqOB2WxmoeLUD61WC5vNxrwv6Zp8WDL1gS+EQxEOtLdSn3lDHskxJIfQ2CkVqFHSY5SM6uKcoFy04vMRZWq6Pn03SS8T9CG+LTpebT3n+6gkz/Nh3vw5SgSoGimrpn8o3bM4dvw9nyl9oEY81lBDDec01AgZpcWe/70crjyZkOOPE8/hvxMXbzEpMJ2jtIlNdU21Y5Xa5o/l71fpOtUsa7wwUY2Y5D+fCOk31f2I5/CkiThGJCjw4Zsn0hd+7NTIPb5NpQ1arIjOQxRuRYJSTWAS5yk/Nkqeakqh60r3erz9yWNRIyErwY9DsVhkRGEul0MymcSWLVtgMBgwY8YM5HI5lqcwmUwy4jCXy6G+vh7pdBoTExNwuVxoampiyohWq8Xhw4exZ88e5rV38cUXs2tqNBrMnDmTFVuh+ZNKpdDc3Ix8Po9ly5bh4MGDGB8fx8DAAGbPno3m5uaKe8lmszCZTOwzhSQXi8WKd0eW5Yr8TWK4k4gTIeJoXaHiN2vXrkVvby+6urqQzWYRj8fR3NyMaDTKCsvU19cjHo/DYDCgt7cXs2bNQiAQQDabhc1mY56RklQOFaMx2r9/P4LBIGbPno1FixbB6XTC4XCwEDG+GjV5aPDvCf1XC62uQQ3z5s1DPB5HMpnEJz/5SWzYsAGf+9zncODAATQ2NqK/vx8ulwv19fXYsGEDfD4fCoUCLr/8cnzuc5+D2Wxm8+9cAK0HLpcL+/btwyWXXIJnn32W5aTdunUrbrjhBqTTaXR0dAAoK/wvvvgiLrroIlbBWqPRoKOjo8JTq4YaThVIDtNqtYw0I6jJtPQbnc//KxJUIoGkdC4v65HhirzqZVlGNptFLBZjaUKsVit7HyRJYmQdUN7r+X3ZbrdDlmUWZk15HcljkQ/LJtmYJyABVORkJBnAYrGgUCgw+YWuR/ImEYZarZbloCQPSBoL0dOTvs9ms6w4DkUF8eHEvJwhyzLzBKUxIQ9ONSjldKTP/LXEZ0dt0hjRc+P1C3Fuic9XbFdp7vDf89+Jcr1IAirpjaJuxhOK1cZIjfjkf+P7fCZQIx5rqKGGcx7iAix664kLKltsIQFS9VBWHkrEnBIhx4cCVyOaxI3pRO6Xb5v+5jdGnvxSuh7/nZgfUOxTtXtV6pfS3yeyqRFRoSYo0n1SuDMvBNF9VCNRle5BfKY0fiKpSH0joUlJuBEr+ykl8RavrwQl8nOS0EuFhlSEYbVnpDYnazi+ZoTDYSQSCRYm7ff7WQgvEXputxu5XA5GoxEOhwPpdJqFPbe2tuLgwYMIBAJoa2uDw+FgilFnZyc8Hg+2bt2KQ4cOwev14oILLmDeCKSwkKdlNBpFNBpFNpuFTqeDzWbDrFmz0NbWhh07duDQoUOor69nXn28EkLg33Ue5JEgyzKrnEnegHTeVAJqNaMCKTnr169HqVTCnDlzYLFYMDo6ipaWFhQKBYRCIeZBajab4Xa7MTo6ivr6ehQKBWQyGWg0GjgcDpYry+fzMeVk9+7diEQi6Ovrw7x589DS0sJIHj6kjDdUiPuGJEmTwq5rqIFQLBbx+9//HoODg8jlcvjWt76FQCAAvV6Pvr4+2Gw2HD16FD6fD5s3b0ZDQwNuvfVWPPXUU3j99dfx+uuv49prr327b2PaoHeH1rOjR4/i0KFDFaTKkiVLWAEdgk6nw4oVKyaRq+S97ff7z/St1PAOhrgf8blTp7uGKxE0ItEoXk+JzFFqk/Z0g8EAi8WCfD7PvCD9fj/zLCRyTpIkWK1WFuosyzLLIW2z2RgxR96UZMwkvSOdTiOdTjNvfwBsP6fx4Iu/ULGaXC7HiuSYTCZmrOO9JclwWSgUKgx5sixX5LPUarVIJpNIp9Osfd6bkvrKh1+T7EKGCTXCTO2503jz4e38s6TUL0pGH97rUonQE4lDNXlHzTOSPiv9y59fTS7n85NONa+pn9UcONT00dONGvFYQw01vGMgWpTE/GLiwlqSSyyMWqkNJeuQ2IaSxUqJlGLXFIiAauDPF8MmxTZ44pDvg5qFjicgeLJOJEyVcDIblBJ5OV3STfyOb0v0WuLvSfyNv6ZI2tJv/PiK4w5Uhn2I46gkUEw1ptUEq2kTILLMZrEqQSmXg7KVhrxGQJbBP/d4PI5sNotCocCIv6GhIZjNZhgMBsRiMTQ2NqJQKMBsNsNqtbI8kPS8DQYDGhoakEwm8frrr6OzsxMtLS2w2WwAysVnFi1ahN27d2P37t0AgJkzZzLCT5bLVTD37duH0dFRJBIJuFwu9PT0YP/+/chkMiwpvSRJCAaD8Hq9FfOJhHxSDPi1kb4jspGUiEKhwLwq+HeOyAZROK82d+j6o6Oj2L17N5YvXw63243x8XG0tLRAkiQEAgF4PB4WVhYIBCpyN6VSKeRyOdTV1UGr1cLhcCCTycDtdiMcDsPv90Oj0eDKK69Eb28vXC7XpIqgpPyJayr9K3pO196HGnjIsozBwUE89thjAIC77roL8+fPRyAQgMlkgsvlQl1dHdxuN1wuF/NeCgQCcDqd+O///m889thjuPLKK6f05DmbQO/O7t270dzcjFAohLGxMZbHrb29HR6PB8FgsGJPtFqtFe0Q8ZFIJGqh1jWcUkiSVOG9BkydVqfaOk/7Jx/2q2Z8E8kpUcYTZUsi88i732azIRwOI5VKsQJpRPCZzWaYzWYmw5NxkFK36PV6ZDKZCrKQ9mmdTofx8XFIkgSLxQKTycTIRCKwaE8kWYBCxIvFIhKJBCwWC/R6PctVSf0ulUqM9KT9lSpb0/VluVxIy2g0IpPJTCJ0AbDUNGazmZGZvAcnhZfTeqk0rvxnnswUryfqAzwZyRcBIigZaPk2xfBvJZlILbRbbR6Kuhr9K+og4pwW+yAWyxH1YvF+lJ7N6USNeKyhhhreceAXVKWwQSLaJEHZVLMKqSnY/EbAb2y0sStVdatG6IkQNzb+OzXBSbwftU1PySuQJ0v5fvNt839X+10Ef+9qRJt4rEjKKeXs4Tds/jslgZC/d/FZTCreI1XmyFQSQPnzlOYQgQ835dum49WsmPwYKYV/kJAneljy91jRT1kGZHVLaw3HxyIej6NQKCCVSqFQKCASiWBsbAwtLS2MrKNE8ORVQJ4GwPExNhqNzNNgeHgY4XAY3d3drEiKwWDA4sWLceTIEezduxdGoxEej4cJ/KFQCOFwGEeOHGEeAW1tbUzRkGUZLpcLvb29LJzZYrEwApGfe2zdk47nXOT7yq9ZRLhSTieas7y3L38uP3486Dqvv/46Zs2ahYaGBlagQpIk+P1+GAwGOJ1OZDIZBAKBiure8XgckiShqakJer0eFosFR48excTEBAKBAFKpFLxeLy655BJ0dnayyuEiUUqeDqJyQf/VUMNU2LVrF6LRKFpbW1EsFjFv3jxs27YN1113HbRaLXbt2sW8kmRZxqFDh5jX9IwZM/DKK6/g4MGDmD17dlVl9GyD3W6HVquFy+VCd3c3K96USqXw6KOPYv78+Th8+DALq5ZleVKopEajQU9PDyNjz5SSW8M7G7zspBRezf+tZPTm5yd/Lh0jGqJ5+Z5vS0k+V4pu4Yk5Iu2ampqYp182m2UkPhF8Wq0WHo+HhS2n02nEYjFYrVZIksRCqUulEtLpNNvzqKgdkXiUuoX6xZN6ABjBCIBFdBAhSWlaSKagvlM+RyJDSUYgEpAvSkOyKsnBdD+ZTKaiyE02m2V9JA9Lk8lU4cGoRL6Jz5iXgXliWtQpADBZh3/+aqS0qFuI1xf1MzXdTSRGefJUKWek2p4h3pPYNxHVvq8RjzXUUEMNVSAKF/x3tBgreZux8zTHFW4eSsICHcdfU/RCVCtqw19zqs2B31hFLxxx4xHbU8wDyAlNSmOmtDGKXnxqZKkS2aZ2rLgxikKD2H8iOPjfROKED4/gLbkiISd6bvHXpmuSUMO3J/aLF3JFAUJpw1YiIMV7pjaVxkbsM5FHPJlCQhx/PD9e/LXENum6JCjWUGk1poTp6XQa4XCYKd+80kBCciQSQTgcRjabhdlsZvPJbrczbz2r1YqRkRFs27YNzc3N8Hq9TIhva2uDxWLByMgICoUCvF4visUijh49ij179iCdTqOurg5dXV0sFIkqWXo8HgDlUKVYLIZ0Os0EfhLueeLbaDQyYjOfz7P5zs+pTCZT8S6RtyS9lxRuORVkWcbY2Bh8Ph/6+/sRDAbR3t7OSFpScBKJBHw+H5xOJ4xGY4XXZalUQiKRQCwWw8TEBEZGRmCxWGC1WjFr1iwsXboUDoeDjQH1mZQgIk9FiN6bNdSgBlmWsWXLFuh0OgSDQUYIyLLMjBAtLS2w2+0AyusIVb2/9tprEQqFsGfPHrzwwguYNWvWGVPy3gronWhsbGSenclkskLOWbduHSv8RPlqS6US9u3bB4/Hg9bWVtYeT/yf7fdew7kFUYZS+lskENUIHP5vNdJIPE+JjBL7p6av0G/kRUwegPQ+kWxBHoRkcEwkEoxMdDqdkKRyiHYsFmNyPKVsMRgMSKfTLESaCD7Kq0jEH3kjE2lIeSHJw5FkB14OJUMshVWT1yRdj/ZjvtgLkZw2mw2SJFXkh+QNnHQfPHGopA8pkXhKz5//nkg+8iTlC73wz0d0LhCvzc8PXudUmifinFAiTMXjqU01/W46e4k4l/nrn2nUiMcaaqjhnIW42VezhJ0sRPJQ6Xq8hVO0PiltVmL74sZRzaoGVBayEftB39HvYrgIf44InmDlN1G1nInTvUc18CQPT7QqPUPxWkRI8Pk0lUhd8V6rzYdqmzgJJmL4vtI9qQk+SuOuJIiK93wi7Ykko3jvSsIX3VsNZUiSxBKup1Ip+P1+BAIBVpFSr9fDbrcjFovBbrcjEomwcOyJiQl0dXUxrydeaLXb7Whra0MgEIDP58PIyAg6OzthMplYrjiLxYLNmzczQk6j0TAyTqPR4PDhw3A4HMwrkjwqiSikayaTSfb8yStBXKfoX/LcJCWAvBtkuRzqzXsyACf2jpdKJeaZePDgQSxYsAChUAijo6OwWq3o6OjAwYMHkc1m4XA4mKIFAMPDwwgGgyzXlc1mQ0NDA9ra2mAwGNDT04OmpiY2TqRA0Wf+fmkd5O9bSRGsoQYlyLKMiYkJVpV58eLFcDgcuPTSS9mck2UZO3bswOLFi6HRaGCz2TAwMACXy4UVK1Zg06ZNWL16Ne64446Kok9nO3p6evDXv/6VeTzu27cPpVIJoVAIRqOReX2T15AkSZg5c2aFUaxUKrGw0Hw+/zbeTQ3vJIjyqJrBn/6utneJ8jx9xxdCUZN1p6tnqMln/LkkZxgMBpbbMZ1OI5VKIZ1OM7JPoylXo85ms6xADRlH0+k04vE4yyltt9tZRetCoYBsNssMqBSxIcsyC/OmKtZ8GDKFfRM5SekkeJmXyEwAFZ6S+XweOp2OGTD1ej0KhQJyuRzbtxOJBItgED1QqW3KK8kbP+g/+o43jopF9Pjxp98ouqWurm7Ss+CfmdKcEklKUYdS0uPE+SoWilHTf8RrqekHSm2IuhZPqIp9P92oEY811FDDOwJKG7j426RjZQkylMlAakuNvBJ/54/jyQaRSBIXeLUNTO1YpQ1CbENtY5wK4sYpho7z9wEo50Gp1rY4dnQdnnQUj+P7JY6hmLOFB295FEOm1YhkpXESk0MreWxUex5Kn+lvpecpClP8d2KflAQktechSRIgaSDeIo3NuVJl9XSDnguFIOXzeSQSCSSTSSb0ktdBMBjExMQEU6aPHj3Kip9ks1lYrVaWs4mEdZfLBaPRiPr6evj9fuzfvx92ux3d3d2wWCzI5XJoaGjA+Pg44vE4SqUSXC4XZs+eDbPZDIvFAlmWWR5IAIjFYgDAwpIMBgO7D1Ji6F2hZPGRSASxWAzJZBLBYBDpdBp2u50RCHa7HZ2dnWhoaABw3DtQnP9TrS+UuykSiUCj0SCRSGD79u3Q6XR417vehWQyyUjUQqEAv9+PVCqFWCyGgYEB6PV6zJw5Ex0dHfB6vRUVNXO5HMbGxgAALS0t7D6pT+T9yK8XhBrRWMOJoFgsYmxsDBqNhr2vWq0WGzduxOLFi5nHn9VqrfDWyefz6O3txbZt22A0GrFp0yYMDAxg3rx5Z32IP703M2fOhF6vx/XXX4/HHnsMZrMZmUwGsixj7ty5cLvdOHz4MEwmEywWCwAo5rGk1Ac11HCqwRuXgMkGXDV5SU1+5I+Z6j0V5WAlgpP0Apr/SnIwT5aRvE0GDCpKE4vF2D6aSqVgtVrhcrkYYUgh1VSwRqfTIR6PIxQKAQCsViv7DyjLDvF4nOWcJHlBkiSYTCak02nWLk9S8hEP4r3xKVt40o+K6vDrAJGchUIBIyMj0Ov1aGpqqjCU8mNJXqCiTE/Xo7WX914Unwt9R+MsSRImJibg9XonEYBqehk/fyhKhI8a4Z0hxDlWTU7noUQuiuNRTV/iQfdZLUXAWUk8PvDAA/jDH/6AvXv3wmw245JLLsGDDz6IWbNmsWMymQw++9nP4oknnkA2m8XKlSvx8MMPs9wfADA0NIQ777wTL7/8Mmw2G2677TY88MADzGpYQw011HAy4BVMUdhQWuiVSEfRKsW3q3acmmCj1vZ07oP/V404Fb8TNzRe2Z7ORscTimSZnKqKmlpIbzUojSV9x1tZRaKOz2WoJkjSv0pWw+l69YkbvEgSViP3qgk64rFKBKJ4rEgGiwKrJHP3fWw+l1Tmh1RO8TgJPIF7voPGgbx4JEliIUB8VcpoNIrBwUEMDAxAp9Oho6MDQDn82WazwePxMK8mnU4Hu93OErqnUilks1l4PB7U19cjGAxieHgYDocDNpsN/f396O/vx/DwMEu4Ho1GMT4+zt4Pmgtut1uV4KYwKVIe6urqkM/nEQqFmMdDY2MjI/TIkyAej8Pv92P37t1wOp1Yvnw5Zs+eXZGMXsnTWBRi6V+32w2LxQKj0YgdO3Ygm83iAx/4AGS57GHh8XggyzKOHDmCgwcPIhaLwWg0YunSpaivr4fVamXnE+GYSCSg1+vh9XpZpU9R8SFCXQzxrM31k8f5qgfIssy8gGKxGD71qU/hm9/8Ji6++GKMjIzAZrPB4XBg9+7dmDlzJoDyutrZ2YmXXnoJIyMjmDVrFp5//nns2bMH8+bNe5vvaPro6OhgpMfKlSvxs5/9jFXb3bp1KwYGBtDR0YFEIgGgch/kZTEiFpxO59t5OzW8w6Ak9xFhqCY7Kxmf+c+8h78ox4kGYZItRYKSJ3t4Qzkvm/JhxNS2UpogMvzV1dVBo9HA7XYjFovB5/Mxr0G3283CnHnPRLPZDJPJhFKphEKhgGAwiGKxyAyZRDry50lS2cOQ+mQymZBKpZhcnslkWOoFyr9Ihk9+H6Z74GWHaDTKCsbZ7XYYjUYEg0FEIhHMnTuXpZIhA2uxWGTVuzUaTUUOSMrLyEdp8WNLebGVdAGNRsMK6yUSCUW9sdp848lWvpL6dIyzas4J4u/0t6iPKPVJ7XpKpKR4/Jk0gp3QDv/qq6/irrvuwkUXXYRCoYAvf/nLuO666/Dmm28y9vyee+7BM888gyeffBJOpxOrVq3CjTfeiLVr1wIoK5U33HADmpqasG7dOoyNjeHWW2+FXq/Ht771rVN/hzXUUMN5AyXrFIH/LElSmYCRAb6otUhcqgkp/KJOZFY1D0HxnGoQLW5Kv/Pt8v2uRuhVI7f470WFQckdn/5TS4CsdK9inkV+8+evK0nHw0j40E6xgAr/nVJScb5N8R7Ev8UNmz+Gt6JTW0qkdrV5p+QBOx3wAhS1wxfJUJqjssJ9cYMGyJPnznQJ43c6ROFfluWK6siUV3B0dBR79uzB3r170dHRgUsvvZR5Cw4NDSEWi6GhoUExxBcAC5/KZDJobm5GY2MjgsEgjh49imQyCb/fz/I2UU6lhoYGFqoUDAaRSqWQSCRYWDWFOPHXIgGeqlNSSBF5XJLXJLVhMpngdrvh9XrR1taGUCiEYDCINWvWYM+ePVi8eDF6e3srwkRpDorvIAC2DtbV1eHqq6/G+vXrkU6n0dXVhcHBQdhsNpRKJUQiEQQCASQSCZhMJlxwwQUsrNrpdMJqtbKckJlMBl6vl4VFpdPpipyafB+UQqr5/tVw4jhf9QBS/smr8fXXX8d3v/td/OQnP6kguN/1rndVhM9Rflez2QxZlmGz2bBt2zZ86EMfOus9HgkOhwOXXHIJQqEQYrEYVqxYgb/+9a8IBoMYHBzE73//e3zhC1+A0Whk72A8HseRI0ewYMGCinai0SjLSVtDDW8V013LlQy6St+rya9KsrVIcqm1wacr4s8XCUkAFSRktWvqdDq43W6YzWZEo1HE43FMTEwgl8vBaDTC4XAwI2kqlWI5FkmGocrV4+Pj0Ov1cLvdsFqt0Gq1rKAeFX3h0ygQAUiyAxF/5LlI1+HJQz6/YzKZhM/nQyqVQiaTYU4Ger0ec+fOZSQmVbyWJImFnZOxlMLHU6kULBYL88LkvR5pvIiw5eVkKoZD8vTY2BhsNpvivKimvyl52PLPSST36Dde/+HPnUrn4+9R1OfU5BteHlQj6Pn+nYmUSydEPD733HMVn3/1q1+hoaEBW7ZsweWXX45oNIpHH30Ujz/+OFasWAEA+OUvf4nZs2djw4YNWLZsGZ5//nm8+eabeOGFF9DY2IgLL7wQ3/jGN/DFL34R999/P5tANdRQQw1TQdwMaEHlF1OlDQEo842ygszCWxmVfhM3B35BV8rVIfZTzfrE/6YmFIn3rWTZEslBcUyUwJONIimoZL0T/xOvo7gpyjIjxSRJglwqoZAvIF/Is3BMIlkoHBQCISkSfmLYCn8PSp6eIhErbvhKYyQSjTyprPQs1IQHJcFDJEXENsS+i8ewvuGYJ6Msl+e0rCwwSZBQMaslCSg/mhoE8MIyCboUErR//34cOHAAS5YswcKFC6HVamGxWKDRaNDb21tBRBCBTt/xHgyUiymbzaKpqQkNDQ3MszGbzSIcDkOSJOatIEkSUx5kWWb5Hdvb21lS92w2y7yRCoUC81QolUrseCIsKYScvLUAsLArs9mMhoYGNDc3s+ra//u//4vh4WFce+21FeuCGFbEzz3KUblo0SLodDoMDAwgk8nA7/fjyJEjKBaLcLlcaG1thc1mQzabhd1uh81mg9PpZDkiTSYTXC4XG4OxsTEWhs6/m6S40dir5eY6XeTjyZL45woZer7qARqNBs3Nzejp6UEwGITb7UY6nWbV2Mlr5MiRI2htbcXBgwdhMBgwY8YMlEoltLe34+DBg9Dr9XjllVeQy+XOWu9OAk+qLF68GDt37oTJZMLOnTvR3NzMDBnbtm2DTqfD3r17sWTJEphMJuYxTh7bxWIR+/fvZ3lka6jhVKEaiUi/K5EtagQRvcvi72qklNiW2A6vI4iyHy9rkzxHxBlPbKkRYHq9Ho2NjcwDkqIBQqEQy8tosViYwTqbzaJUKrH8kWazGfF4nEUQUJuyfDwPIxGKRGKSVyO937wDARGWtAcnEgkYDAYYDAYkk0mMjIzAbrfD6/UinU4zb80FCxawIja8B2Umk4HP50N7ezuTZYg4lOVy+DafqzoWiyESiaCpqYnlw6T2aLyLxSICgQBGR0dZUZwlS5YoPmOlMaffRd1tKr1NaV4SeMcMJR1qqrZ4KOl9vCOMEvkJTHayOF14S7teNBoFAGa92rJlC/L5PK655hp2TF9fHzo6OrB+/XosW7YM69evx7x58ypCLlauXIk777wTu3fvxsKFCyddh6opESifUQ011FADv/jziqZIBooLuSwBWo1WkXASSSvR+49vi4QENUGFJ4nEfIH8PfDXE++LP0a8F/Fc0YuiGjEp3rtIaimdL44Vr5yI90rCQ5lwkaHVaI+FTeSQTqdZ9T2tVotwOFxRnVer1cLhcBwXGCCX44ql42HHYp/550FEhFL/lYQ/se/8WIv5ZPj5wIe28OEW/FiJc1TpOYrjyfeBBDpJkipCS8oHHA+floV5oHTvMp1zjLCUJA1klIDJXTmvwedEpCqTWq0Wo6OjOHLkCFasWIH58+dDp9MhmUyy3GY0/+g5ie8aP59KpRJMJhMMBgMymQwKhQIaGhrg9XqZgpBMJtmcyeVyLMeR2+1mod8UjpTJZCqqTlIVSj4cmwjLXC4Hj8cDnU6HUCgEWZZhNptZwRpSOiSpXBTHarXC4XBg165d2LFjBy688EJ2f3RvIpFC8y+RSMBoNGL27NlobGxEKBRiCejJU1Oj0cBkMsFutyOdTgMAy/9os9mQz+cRiURQKBRgtVrR0NDAPDn5eU7kLv8MaayV1t7TCf7958PO+Gra5zrOFz1Aq9Vi1qxZWL16NTQaDUKhEG677Tbo9Xq2B2QyGQSDQTQ0NOD73/8+br75ZlZoKpvNIh6PI5vNwufzIRQKMQMCcPYTz+3t7XjsscdYvseJiQn2fnV3dwM4nmdVksppKfr6+ireOTIUnAnltobzA+IaK8rNagZlte9EYlLNA4zfY8RjxH2GP1b8nQ/RVgq75o+n/vE6De0ler0e9fX1LO8jVZUmz0CSS8gISpWu8/k8HA4HisUikskkSy+TSCRgtVohyzI7P5fLwe/3Q5Zllj6FJyhpjyN5hrweC4UCAoEAisUii1TQ6XTI5/Mwm83o6OhANptlBfFIbpFlGel0GuPj42hpaWHel7lcjqVWyWQyzDOTjDmHDx9muS+TySQikQhcLhcsFgsrGjg0NIRSqYRYLIaWlhY4HA5FOV18puJzpXPUyGXxsyQdL36jpPcpkdrUPt8WPx/448R9hA8f58/nZVFePjkTOGnisVQq4TOf+QwuvfRSzJ07FwDg8/lgMBjgcrkqjm1sbITP52PH8MIG/U6/KeGBBx7A1772tZPtag011PAOh5rQrkTWybIMSTN1yHC1a4kbiyjc8MSl+L2SYKSkEIuEmlJ71TYOkWTj+34iSo4aAarUH3Hjqrh3rYZtuuPj4xXEWjQahV6vRyKRYCQPeW65XC5mudVqtcgfE3Ao14zS/agJbkpekEobvfg8ROsh/5kEOTVBgtoRQ3HU+kHHE4kpCjTi8UpWcTUCW5zzvPCqqSX9r4BOp4PNZmMeO5QPaMOGDViyZAl6enrYcydvA5vNxrwjyXKvNEd5opoUByqaQu+xyWRiVSNJ2E6n00gmkxXvOikWNBeJdKRiOPTeUEiTyWRCJBKB0+lkx2q1WkxMTLDq1larFfl8nuVio/AtSZLQ19eHV199FWazGbNnz1ZMMM/fq8ViQSwWY+FbQJnEKBaLsFgsjLTh3yfyyIxGo8x7wu12s3yP9P6L3oy8ME14u0kOUtwikQii0SgLkXO73RWGinMR55MeIMsyent70dHRAZfLhQ0bNiASiaBUKmF4eBiSJKG9vR0XX3wxXnjhBaRSKWzdupUpx6RIF4tFhEIh7Nu3D21tbW/b/ZwoLrjgAuad1NLSwopu7d69GzNmzIBer8fw8DAaGxtZyD1vjKP3sKGhAW63+227jxremZhKfhPlfDUippoMLkY08QZptfP43/nQajHMmu+bUmESJUcAnrikc8xmM4xGIzP4k8ciGfPIiB0IBGC32xlxSMZLWqP279+P/v5+Fn2k1WqxZ88eFItFNDQ0IBKJsIJSOp0OZrMZGo0GFosF4XCY3SPlsq6rq0MoFGLellqtFna7HRaLBclkErJ8PM9ifX0985wcHh5Ge3t7RaE4Kp5HJCeFhxOh5/V6EQwGmcGUwtEpL2UkEmHnut1udHd3M0MoL7+IRKLaPBO/V4K4x/O6mZoew5+rpDeqtaPUR974qkRQ8m2dbpw08XjXXXdh165dWLNmzansjyK+9KUv4d5772WfY7EY2tvbT/t1a6ihhnMPipYiCcyjSyKlVKqev0P8jVdo+eOJ+FEiGasJQ/S32ualRB6JBNJ0x2C64IlRsf9qG674O2+d4y29hXwewVAQ0WgUhUIBDocDQ0NDyOfz8Pv9qKurg8ViYXnc6uvr4XA4mGdFQ0MDDEYDC6FUEi6rQcliKfabfhPJOrXfq/VBnAt8LlDRC1eJMFbyoFW6T6W5x98n/UcWb74NXhApcb/XAEbCxWIxVpmaQgvnzp3Lwpb4cKVcLgen08m8FHnLPSnhPOFI3kGipwaRcUTUybLMEreTdwEJ2fl8Hkajkc2XfD7PitF4vV7miaXX62G325HNZlkRm1gshkQiAZ1Oh4aGBuYNkMlk4HQ6WQJ6m82GaDSKpqYmRpi98MILcLlcjDzh75GfrzqdDh6PB8FgEHq9Hi6Xq8Jrl1e+6FyqpE2ekLyHIM31qcLQlN7h0wWld48I1LGxMVZ522AwwGw2o1QqIRwOw+FwwOv1MgJYCWczKXk+6QGSJKGtrQ0TExPMm+fJJ5/EnXfeiTlz5sDpdEKWZezcuRPj4+NsP2tubmZj5Pf7YbVaEQwGEY/Hz1jfTwVsNhvmzp3Lwhg3b96MRCIBWZbx6KOP4gMf+AC8Xi9T4DOZDLZt24alS5cy8vGaa67Bn//851pxmRpOGdTkI9FIDEz2ThSJSSW5sBoZRP8q7TtKxnDyaOQNhyJRRHtdqVRihB+ve4hEpiin031S1AIAJgNQjuhwOMw8DHlDJ3lv5/N5GAwGbNu2jaVUiMVirPIzFavJ5XKsP9FolHk4kjNBS0sLy+M8PDzM1k0ygCYSCSbjUKG4fD6PXC6HcDgMi8WCuro6uFwuRqASQUrRGESkkqGW0l6Mjo4yT0YyolL6GirSZ7PZmKE1l8tVGPz5eSGSe0rPWiT91OYNr1up6RxK5/MyIj+fq4Hvl5hjX6lNnsA+nTgp4nHVqlV4+umn8dprr1VY7JqampDL5ZhbK8Hv96OpqYkds2nTpor2/H4/+00JlJeohhpqqKEalJQ3tiGAFvPji72YyHmqjUONcFMiKZU2ESV3dvGaIgmlRljyx6u5yfOClpIgpNYuQWmzUmqD/uaP5wW8fD6PYCCAfC7PBKloNIrR0VFI0vEqtSSEkHUznU6zcOtEIgFT0QyLtRxemc/nFa8ljht9VtqwqxHDogDJW6npdzG/p5KAIkkSq5wnei9Wm0+iAK0GpfmkBH6cxGPK16t6mfMONEbk5VMqlatD19XVwWazsdAjWkecTicikQhLdp5IJNgcocISPOkoCrGUT5JPfE4VGUnBoFxF5H0JlMksyuFIbfB5GjOZDBwOB0wmE0sQr9frkcvlUCwWWUJ5Ejrz+TzC4TD8fj+am5uZ8uJ2u5FMJlFXVwen04lAIICdO3fC6/Uyz05qhxfeAcBkMqGxsZEpCzQX9Xq9ojGHf+f491BUFAlKiqPYptLntwolgwFV//X7/SykXKPRIJFIMA+5+vp6eDweJJNJpNNpNDY2MvKY+qmkvJ5NON/0AEmSmPeP0+lEd3c3fD4f26coN2kymWTewy0tLXj22WcRCARw9OhRJBIJdHV1IRQKMTL6XML111+Pz3/+81i5ciUWL16MZ599FhqNBqOjo9i6dSsuv/xylm6B0qzE43EWxnj48GFEo9Ea8VjDKYUox6mt+0qyl7h3iF5holxL54tkDRkClaKnRM9I0YjG95N0En795+U2MaWPWEWa1yH4iACz2czk6rq6OsiyjHg8ztYuAKwojE6nQ1dXFyYmJjA2NsYiLSiE+/DhwyxvJF1jYmKC5WoOh8NMVvH5fBWRIESoUjE7Kt4nSeWULuFwGMFgEKVSCa2trWhtbUU6nUY8HmeOCbIsM9mI9kwykh45cgTDw8NIp9MVxlqSj4aHh2EymVjKls7OzooQd75AFk/CKelL/G8ioX0iRs9qbfNQ0jWnOl90gODnLU9KivrJ6cQJEY+yLOPuu+/GU089hVdeeYXl9SAsXrwYer0eL774Im666SYAwMDAAIaGhrB8+XIAwPLly/Hv//7vGB8fZ1bt1atXw+FwoL+//1TcUw011HAeQ2lhLn81dV4MNRKx2nXETV7sg5I1S61d0Xom9nOq80RBhTYTpePVciTyG5PYV/EexLFUus9CoYBELI5koixo7NmzB+l0mlkbh4aG2DUTiQQLp/T5fMhkMvB4PDAYDOU8NKUSZMiwWCyqfaJ+iPekBPEeRUFQHB/RUikKk/yYKvWp2mcR9IzU7kMc62rtKZHZk/tTtTvnHfjxsVgsKBaLiEaj6OrqYt9TaBI9J4PBAL/fD7fbzXInEXFICdpFBYbaoeNIsaBQYhKySckAyt4BFKJElSFluZyjMZ1OQ6vVMsGf5Cyz2cxIVMonaTabWaVIs9nM2jYYDHA6nYjH4yiVSsxbwGQyIZ1OQ6/XY8mSJXj++ecRCATQ2to6KcQaqFwbKSSKvqdxE63sUxkD+N+qvQNqyujpIPNkWWYeJD6fD4ODg5DlcihXsVjExMQEfD4fgsEg83SlHJWyLCMSiTDPCz436NmI81kPaGpqYvt8T08PAMDlcrF8aCaTCUuXLsWbb76JHTt2IJVKYWRkBH19fejv70cikcDBgwdRKBSYZ+C5hEWLFqGxsRHhcBjRaBRtbW0YGhpiHtOjo6OMhNbr9bj88ssn7T1kSKyhhlMBJblMBC/P0p7BewuKETp0nLhnkHFNNDbz8iAvR6qRlyIxxe/tBJ4MU2pf7KNIaoqyI09CEkHqdDrhcrlYPulIJIJ0Os0K2LW3tzMvRAqjzufzLGw7lUoxY4zD4YDf72dRICTH2O12lheSyEW9Xo9gMMjIT6pYHY/HmWHCaDSyCIxSqcQMcxqNBplMhuWD5NPZ5HI5ZLNZ6PV6RqiSg0KxWMTY2Bgz7DY1NaGjowNA2TEiGo1Co9HAarUq6jH83BHHW+3ZVjtfbX9X01l4vZDS/0yXJBT7zP9NxmolA/DpwgkRj3fddRcef/xx/OlPf4Ldbme5WJxOJ8xmM5xOJ26//Xbce++98Hg8cDgcuPvuu7F8+XIsW7YMAHDdddehv78fH/vYx/Cd73wHPp8P9913H+66666aV2MNNdRwwpiuR5i4afCoRjwqE5nqJKKaVUo8hzYr0euS/uVJRKUNQ+yb0qZXjRjkNzL+eLLcKo0B9Ye/JgluEoBiqSzQ5XM5FApF5hUWiURYaNmhQ4eQzWZZ1VyqBtzc3IxsNgtJkhAKhbB3716YTCbMmjULsnyMbCwWkdFooD3mRQZJquiv2C/xeag9E37cxefHW3X59pSOVQtTEIkVUfDloUQ4T8cSKZ6jNH+UxoWdV/N4nAR6ppQziYjwXC7HBOtUKlVBDMpyOSE6hUvz4dUkpCt5ttH5vPJjMBgYaclXl+RJbsrlZLfbEYlEMDExgZaWFvh8PnR1dSGXy7Gq2BSmBID1hQgyPkSaFAmLxcLCrDKZDCtoo9FoWLL2o0ePoq2tbZIgrDRfec8MAJNIRxoTXpAX1zilNe1E/n4rULqnTCaDVCrFKnb6fD7mOTo+Po5wOIwDBw7AbDbD4XBAr9cz2dnr9aKhoaFCCaCCQTSnplJUzjTOVz1AlmVYrVY0NzfDYrFg7dq1iMfj+MlPfoJ7770Xb7zxBhYtWsQU4IaGBgQCATQ2NsJisSAajaKhoQGxWAzhcJgR/ecKNBoNbDYbFi1ahLGxMXR3d2Pz5s0sjDGXy6G9vR179uzBsmXLJr2rlNuZilfUUMOpAi9PKRm/lORYpXzrU8nPvMzER7/Qufy/4nV5GU5JnucJQv570g/omnzxNKU+KMl6SvfJe7yRgUyr1aKurg6JRAKZTIZFXZCMLkkSdDodIwXpewCMPIzFYvB6vXC5XAgGgyxvY6lUYp7PVByPlwcSiQSSySQrJOdwONDc3MxS1pBXJm9UJZmIUtbk83kUCgV0dHRgYmKCjU2hUEAoFEIsFmOpY5qbmxl5aTAYEIvFWOEr3oNVSXYXn7n4HERUIyPF+aD2G39tytc9HYJUnL+8lyj9zpPSZx3x+MgjjwAArrzyyorvf/nLX+LjH/84AOAHP/gBNBoNbrrpJmSzWaxcuRIPP/wwO1ar1eLpp5/GnXfeieXLl8NqteK2227D17/+9bd2JzXU8DZiupaHqVATyE4cYniDoqJWZVjFMRcFCDF8gVf6xcVabbFX+l6NpGJEniBEiP1T2wCVjqNjxWvywgcv2JDAQ9WlKVSYvLCIDNHpdNBry9XkUqkUszhS23y4lSRJ2LhxI1588UW4XC709vbC6/Uik8ng4MGDLK/ckSNHoNVqMTg4iDlz5jBPq4GBAXR0dMBisSCXzUEuyXC5XMhwxJoofCoJXGqkrpIAqvYbDyUBUvR8FOcLbzUXoTSXlIgYpb7w/eA/03dqQlRt3ZkMXhijJOgGg4HlNgLKAiCFK5Pg63K5mIBLxWFKpRITlsXK56VSCfl8vqIYDYUHUS4juh6FJtN8IiGcnl8mk2EFcShvIJ0vyzIL4TaZTKwdSg5PSgW9v5IkscI0iUQCWq2W5a6j63Z1deHw4cOsujd/T0oe4PzY8qhGvldb7/jvpyIaT+Ucp3eHPC8ikQhGRkZYAR1KI0HFZGbMmAGLxQK32w2Px1NRsTOdTrMqnfX19YjH44hEInC73bDZbKqE69uF81kPMBgMmDt3Ll5//XX09PRg8+bN+N3vfofbbrsNPT09MBgM2L17N3bt2oVbbrkF3d3dSCQS+PWvf81yq/b19eHo0aOor69/u29n2qD5p9Fo8Pd///e46aabMHfuXCxevBjPP/88otEo7rvvPjz11FPo7u5mxajEnK96vR6BQAAmk+ntvqUa3kHgiR81wxSt2WoRQOJ+Q9/zUDOE8fKVmM6GP4eOJVlalO2VZD4lyLLM5PKpchLSXiwa/cR71ul0qKurQzqdhsfjgUajQS6XQyaTwfj4OMvrSDIMyfxOp5OFP1PhGJ1OxwwsPT09rLo06ROZTAb5fB6BQIDpDaQ7mM1mzJo1C62trcjlciyvI8kv6XQadrudpbAhg7DBYKi4L8qFTQ4PPp+PGYQ7OzuZQbBQKMDpdGJ8fBxXXXVVxVonEs1qcotaxMZU301nP1cilikqYjq8g6gziAXteBJaJFZPF0441HoqmEwmPPTQQ3jooYdUj+ns7MSzzz57IpeuoYZzDmpKvRIxMJVyVYMyaOMWPcImWW+kSocu+l4tyS9/jCjQKAkjav3iBY6pjhchCkrkqTSd5L9836uRlnzeQn6TFUNCyYOHilQAZQEmFAgil88jnUrB4XDAYDCwvIwjIyOor6+Hz+djoRxAOX/ja6+9hnw+j+bmZuYxtnPnTuzbtw9msxlXXnklZLkcggiUQ12tViv27t2L/v5+NDc3I5FIMO8rWToezsnnu+TDV/g5IRKDSs+Jfw7TfRfVNm8lwVZJuFTb+E90LRDnqtI8qHhHzoCwcS6CnhElOT948CAkSUI4HK6oRk2h2FQd0uVyIRAIwOFwVBD2pDBQSDV5CRJJSO8YcFxApKrOtM7R9+TJSPkkZVlGOByG2+1GKBRiIUlEbFGVbl5p0el0FQno+fWAjA8Uoi3LMqtMSf3o6enB0NAQotEobDYb8xQQ53u1+Tsdcp//To34r3buqQS9o4lEAul0GqFQCKOjo8jlchgfH0coFMLw8DCy2Sza29vR3NzMEtkTedvS0sJyY5K3qkajYUnvLRYLstksnE4n3G438+g4G3A+6wEajQZz587F6tWr4XK5mFGC/iuVSggGg/jIRz6CN998E08//TSi0ShMJhM6Ojrw5ptv4sCBA7BarfB4PNO+Lr8v8KT+mZwTdK2enh4sX76c5ay0Wq3IZDIYHBxEKpXC8PAw5s6dC1mWsX//fvT29jISkuQZi8Vyxvpdwzsfarn41OSgarKR2A4vG4oGIJ7U4+Vn+m26OoRS4RClvvK/iyQqf76oe0pSZUgt7dH89TUaDZMRqC2SLySp7MWdTqeZQwIZPPn8kLRvFQoFZLNZtLW1wWq1Ih6Po1gssmrUkiTB4/GgsbERuVwOoVAI0WgUZrOZ5ZXOZrMsbQzl0i6VSiydDI0BGVEpfQUdRwVy0uk0hoaGYDQakclkMGPGDGSzWfh8PsRiMZhMJgwODmLhwoVsXeIJWyXZXckZhX++/PNQm5dqOsJ0dBCluVitDZ5M5Z+3Eql5JnDSVa1rqKGG6uBze5HHGE/skDJK/yktXjVUh9LiLS7KkiRBhgwZx8lHSZahmUIZrjif+1sJasRhtd+n0wYvWIghGFO1Ue2a/L3w/aSNloQU/npUqCIajSKVSpVDUPUGmE0mWI5ZQylvFRWRCAaDiMVizBIqSRIikQgKhQJeffVVHDp0CIsWLcLs2bOxe/duVuV13bp1zJPq0ksvRTweRzKZZGQLhWpQ0miD0cCso0q55gi8YMYLDWob7nRIZqX2+fEUr6FGLFYTGqYzf6ZDWvLX4I+VS+cn8VhtDhBBR+Q2FVch70QKh9Xr9ex9IAIyn8/DZrMhFArBYDAwQpzIPBLySRiUZZkJydQf8qYkQdpoNDLBPZfLsSIx9K5KksT6RkJ3JBJBsViE2+2G1Wqt8Gika9L7Tt7J9O6S1yQpFKlUiqVHGB8fh9FohMVigdPphM/nQ0NDA+uHWpGZajiRPU9cu07nfqn0TpGnYjAYhM/nQ7FYhN/vx4EDBzA6OgqHw4Hu7m60t7fDbrezUHbySJUkCbFYDMViEUNDQ7BarXC73SgUCti/fz9mzJiB9vZ25g3i9XpZPsgzff81VBoS3/Wud+E73/kOgsEgU75lWcauXbtgNpvx4osvQqfTYcGCBbBYLNi8eTP+9Kc/IZ1Ow2AwoKmpCQ6HAy0tLazt6SCXy2HXrl3Ys2cP5s+fjzlz5rBCLm8FUymbYv+0Wi3+6Z/+Cffccw/6+vpYNVtaL5csWYINGzbgoosugtVqxdGjRzFjxgzkcjls3boVdXV1NY/HGk4Z1AxSSvIQL9MqyfSirKT0Pf+bSDYSeO84pWNoz1c6jneiUAqLFf9Wuj4vT4oh3qKcKcqE/HhqtVrYbDYWiUHyQSQSYcZXWZaRSqVgNBoRj8fR0NDAIpw8Hg+y2SwymQwj9ZxOJ0tPQuuGw+FghchI9iDZitLcyHLZgEuGHF4n4Z9LoVBg+zP1k1LYdHZ2QpZl+Hw+5HI5dHV1seJ77e3tk3RH3jhMn/l5RNcUI5KUCGf+eHou/G8nQgKqPXslMlIE//uJ6jenCjXiUQUnwvyei0KfWmEJ4Ny8nzMBpTnBe1dRYvlDhw7hwIEDGBoawtjYGCKRCAvBAo57ZlmtVjidTjQ1NaG7uxsLFixAa2srvF4vy3PEL2DnwnO5//778bWvfa3iu1mzZmHv3r0Ayt47n/3sZ/HEE09UhGA1Njae9DV5AUMp15+kOebuyD+/KRZrJfJItERWW8DpO3EDqibA8P3hwW92aoIODzWLm1L/xLaz2SxyuRwj+lwuF+x2O8uxks1m4XK5YLPZkM1mYTAYEA6HodfrWVimwWBAoVBgIaeyLGN0dBQNDQ1Ip9OYPXs2qzrn9/vx0ksvYcOGDejp6YHNZsPhw4eZN5FGo8Hu3buh1WrhcDgwe/Zs5PN5DA0NwWKxsOqhFpuV5dADUFHpT2mMpzOO/BgqkYJqY8vPCbXQd4KSxVqNfBTvhZ+H4nPlzxHvo4bqoOdGFR+JoPN6vaivr2chSJQknQhIEsyJJKScQYFAgCVGlySJhVhRdUcyTBkMhopq7Xq9npGB5PVIZCSR+KTsk1cAvXtk3Xc4HEzQpxBxIhSJHASOW/CJEKWQKH5+0fkWi4URkR6PB3V1dRgdHcW8efMq3hUiWKfzjk3nmSgdfyb3RFkuh8CTBykVjMnn8xgZGcGOHTsQDofR3NyMlpYWOJ1OpjhZrVaYzWZIkoTR0VGWB0ur1bI1kgjkcDiMLVu2IB6Po62tDfX19QgGg8jlcsxrsoa3D+3t7ejo6GAVySnM+PLLL8eaNWvwd3/3dzh48CB+8YtfYHR0FDqdDosXL0ZTUxN0Oh0GBwcxNDTEnruSDE6geZ/P5/Gtb30LO3fuxJw5c/CLX/wC//Zv/4YVK1aoyhZKUJNhKR1DPp9n7zkZOsR2NRoNlixZgve9730YGxtDXV0dxsfHsWDBAjQ1NUGSJDQ1NcHn86Gnp4etIZQrt7GxcVpRGzXUcCIQZSL6zKcdqUYKqcn/9Juariy2S59FElEktfg2xH5MJVtON+pJJKjUCEdqU7w/PqULHafT6dDc3Ay3281SjRSLRQQCASar+P1+zJ49mznY2O12tm+FQiFmNJWkssdkKBRixCTpEPF4HB6PB7Jczu+eSCSYnlEsFllRPOovOfrQuDudTkY8WiwW5hjh8/lQKpVgtVpZJEhHRweTyUTikYy8onxO15muDKL0DJQI42rPU+08JfJYra0TIThPF2rE4xRQWgymwyqf7aAJSi+aGPdfgzJ4SxQlj9+9ezc2bNiAjRs3YmhoiCmrJpMJNpsNdrudJbQtFoussiEV0gDKSeb7+vowPDyM9vZ2XHTRRVi8eDH6+/srkvCeC89nzpw5eOGFF9hn3ip/zz334JlnnsGTTz4Jp9OJVatW4cYbb8TatWtP+npKhCB9L8syUAJkqTLUGrIMcO+xuJFXy8FX0TbUn4maIFNNwVAiHUXBpFpuSH4znDQOwKTv+A02kUiwPHONjY0olUoIBAIYHR1FoVBAY2MjnE4nNBoNq0gXi8VYsulcLscS0CcSCRiNRrb5t7a2AgDa2tpQKBTQ29uLN954g+V6SaVSLOxBp9Mxq+WePXuwYMEC7Nu3D263m3lvdXV1oVgsIhKJwG63I54sJ7B2OByw2Wxs7PgxrybMqRF9JLhOd82fypIozjd+PeGPE8ELRLxwpXZONcGWv2cmoJyAAPVOB+URogrQ/Brd2dmJaDSKxsZGZDIZtrZR6BFVNna5XKyQC5FNra2tLFcRgcgsKsJEJCdwvNI1MFnwJ4KRL1oTi8VgNBoRjUYhSRK8Xi/Gx8dht9shy+V8hOR9RwQoFcChtumaRG6SwE2J5kmBczqdGBkZYdXljx49yt4TpfXnrc6tt3tuEqlM3qQjIyMIh8NIp9M4dOgQdu7cyd7HwcFBxGIxvOtd76owgNDa2NLSgkOHDrFcWrNnz8a+ffsgSRJaW1vR3d0NvV6PQ4cOYWJiAgsWLIDL5WJrIhVxebvH5HyFyWTC1Vdfjb/85S9ob2/H2NgYfv3rX2NsbAxLlizBF77wBej1erzvfe/DHXfcgb6+vopiMwaDAcPDw/iP//gP3Hbbbbjqqquqei6WSiVs2rQJO3fuxDe/+U1WLfp73/seurq60N3dfUJEHr2X6XQamzZtwlNPPYWBgQGMj48jm83C6/UiFAqhsbERnZ2daG5uRkNDA6tWO2vWLMydOxe33HILbrvtNixYsAC7d+9mBeRcLhcmJibQ0NDAjO06nY7t53V1dbW5W8MphZrBVilclr4XyRk1QlAs7iheV6kPYl/Ez7zcJ8qWSrJ6teuqEUlKfeDJNV5fUiPElAguAMxQSgY1l8uFdDrNIqLo3HA4zIyyOp2OGUAzmQwymQysVisbh3g8ziKj6uvrWaSUxWJhEYNjY2OM6ATAzgeO59tOpVKw2+1sv6ZIAipyyRfE8Xg8aGhogNlsZvtrLpeD2+2uiEqhKBGSzfix4Z03lFIniRAJanF81XQVpWeupNuJuobS9cU5wl+X15tOF2rEowD+4RaLRQwODmLNmjXsRSMyiXLvOBwOmM1mJqATiUfeBPwLPBX5MJ3fTuY+6LPSC8ErvDUrZPVFXpbLyeAHBwexceNGvPrqq9i1axdCoRDzUHQ6nbj44otxwQUXoKWlBR6PpyKRfz6fx4EDB/Db3/4Wo6OjAMC8S8h1fePGjVi7di30ej36+vrwla98BUuWLKlKNJxN0Ol0aGpqmvR9NBrFo48+iscffxwrVqwAUE5IP3v2bGzYsIFVvDxRTBIeNBLzaCw7OpYgSRpoAJSETfZk3kOR6FQ7b6pqy0rniUJENVKTF4j40I1qmx3/WQMKQZeRTqURCYfR2tpWtjYm4iyk2myxwOlwQKfVoVQsIpfNoUSVcXXldS+VSrENXa/XI5FIsITN4+PjLPS0s7MTfr+fFajgBRkiIKmARrFYxOjoKEKhEMxmM0qlEl5//XVce+210Ol0CIVC8Pv90Gg0qG9oQCIex7jfj3G/H0ajCR6PGyajiasCXDw2TmDEHW984ceJf+eVEkpPNXfEnKN0nijwAZWCi9i+0pwQ5xRfFZ2/B14wUpp7lUIHUK0A0zsNSs8GOF6hmDfGkYei1WpFXV0dS2RuMBiY8ExjbTKZmFec2WxGNBqF0+lEKpXC0aNHUVdXB6vVClmWWft8MSeaj0QI8hUt6dnTe8OnRSBrfyKRYOsOhTJRUnfysHK5XCyMiV8z8vl8RSVHfp0jpYFkG0ogTwnhQ6EQ4vE47HZ7xZiqKWFnO0QlkcLFKKR6YmIC2WwWBw4cwL59+zBjxgykUilEo1H09/ezqIeFCxeyfZ+S3BsMBjZOhUIBDocDixYtgtVqxdDQEFwuF9xuN9xuN4aGhrBz507MnTuXvccUom21Wmsy2xkGvYeLFi3Cb3/7WyxatAj79u1jivP27dvx+c9/HvPmzUNLSwveeOMNFkIoy3LFM7799tvxwAMPoL29HX19farGx2KxiOeffx7d3d04ePAgrr76arS3t2PHjh349re/je9///vMuKB0vhIKhQIefPBB/PjHP0ZLSwtWrFiBm266CfX19Uin0wgEAhgcHGTGPFobMpkMHnvsMYTDYfT19cHpdLL9eePGjfjhD3+Ir3zlK+waExMTWLduHVasWMHys9XX158Ta0AN5wbEAoGi8V2JVBP1clGeU8oZLxqHedmR8jYr6fti4UulY5RyrZPRipf1xRBf/l6qkZH8OWI/1AqmkLzBR0fy40ue0nyua4fDgWKxCJfLhcbGRhSLRUxMTDBjLhkgJElixfpkuZw7mqJF6HpOpxPhcBgAYDabMT4+jng8ziIDisUiYrEYS1FDe6zL5UI8Hkc4HIbJZEKhUEAsFmN5ePP5PDweD5qbm1k170QiAbPZzFLiRKNRWK1WpouQoTefz1dErPBGRXG8RTmeH/tq+kO188RnraTXiW2Jz1mNqDyTqBGPCqAHPz4+jlWrVmHnzp2TFEESvq1WK4xGI4xGIyOQTCYT7HY7C3PyeDyor6+H1+tFXV0d6uvr4XA4YLVaWe4fUfk8lZOBvBio37wnBe9eXRMGKsErcwMDA1izZg3WrFmDffv2MauLJEkslGrWrFmwWCyor69nREk2m2U5v8LhMFNaaO64XC7U19cjEokgFAohk8kwK3E+n8fOnTvxb//2b/jNb35zzghs+/fvR0tLC0wmE5YvX44HHngAHR0d2LJlC/L5PK655hp2bF9fHzo6OrB+/fqTJh4nkSmo5FAk3gAgyyCORebOEcGTOdMhKZUg5u1Uuxb9riY4KHnDETlAAomax5ySwMTu6Zg1OJ/PI5VMwmqxQgIw7vcjnc2wKndGsxl6jRbFQgGQgUI+D5OxnHQ6lUohn8/DbDYjm83CZrMhFovB4XDg6NGjCAQCCIVC6O7uhtfrxdq1a7Fnzx6EQiFmTSRrJo0DeU4Bx3Op5fN5JBIJ6HQ6hMNhDA8Po7+/H6FQCIlEginyGqkcBqvV5DExPgGHw8HCMzQaDTSSBsXS8WdLggOFt4qhEyTg8OM31TyYyugjQon0FNtQEi6Vjp3uPJ3UjsJ371Qo3SdZu3nvVhKwSTg1GAysgAoRd1qtluVu02q1LO9hMplk4TyJRNkbN51O48iRI+jq6qqo9MorFIVCgc032gf4+cGTyUQWUs4lv98PnU6HhoYGyLLMisDE43G43W7mDanX62Gz2ZiHJXk4UpoCoPw+UJ/IqEpFZrRaLXvX0+k0EokESqUSKypF75FYqOZk1tC3C9RX2sNpjQqHw5iYmEAqlcLOnTtx9OhRLFq0CJIkYffu3Zg3bx7sdjsuvPBCvPLKK2hsbMS8efNgs9mYJ3coFGLEM+WykiSJGV4aGhqg0+nQ0tKChoYGrF69GtFoFJlMBi6XC6VSCbFYDLlcDi6XqxZ6/TaAnumhQ4dgt9txxRVXwGQyoa+vjxnW+vr6cMUVV1S8V6VSCc3NzXj++eexYMECLFu2DPfeey++973vYdasWYrPMhKJYO3atSyP2mWXXQa9Xo8VK1Zg27ZtuP/++/GNb3yDGbinC5PJhObmZsyZMweyLGNgYAB2ux0f+MAHWA7GeDyOI0eOoLm5GcPDw0gkEujv70ehUMDIyAjWrFkDm82G+vp6VhxClss51AqFAhoaGljVcr/fj6GhIVxwwQVv/QHUUMMxKMnNouFYlJF42VnNCKkmx4nkYTVyiL+GSFAq7f88+LWA9lSRqKTf+P1KydlBvHdev1FyPiLik78mbwQlDoFkECogaTAYkEwm0dbWxjwb3W43yzldKBQQDAZRKBRY2hAytPLjRvKHy+ViDgbBYBD19fUst3smk2H9JRmNdPZAIMDODwQCcDqdsNlsMBqNLJ8k6eXE2ciyzGQ6+o2IRr4In5qOxfdfSWbjj3+roGsoze1qOqYoi6kR76cbNeLxGJQWmT/96U948803AVQK/7zAT+w9AKaQiN6O5LlA1gEKQfR6vejo6MCMGTMwY8YMdHd3s9xA000aPZ3JQhZ3Pp8TnStJUsW1zgbFYDoK8Knqp9K1iPw4cOAAXnrpJTz33HMYGBhgBQRImejv70d/fz9mzJiBhoYGFsZGiyh5vkQiEUxMTGBiYgKtra3IZrNYtGhRRd4uqo65b98+vPHGGyx/hSyXKwOuXr0aN998s2LYwNmEpUuX4le/+hVmzZqFsbExfO1rX8O73vUu7Nq1Cz6fDwaDgXkAEBobG+Hz+aq2S/kFCbFYDICCZU/YTMUNXYnAqUYKTkXKV/te6bdqc1sUWniBRqnP/DFqXm3UFyWCCsfmeTAYRLFYRHNzM/x+PwqFAsxWC/PkKp9bQiqVYgQFkQ9EMFB+lmw2C6PRiHQ6jcbGRrZGOhwOxGIxZDIZBAIBjI2NMSWFCBaC6OovSRLzQjObzfD5fFi6dCkTGPbv388qapMwYrfbKwSkTCYDWZZht9thNBoZGU3XoiI1otCp9hwmkd3cHFIirNUIQ74t6gtvYZ4KapZRvi9Kc17smyRJkM5T76lcLleRg5cs+PSvTqdDKpWC1WplXr20z/P/kQcAACYYU+qA0dFRxONx1NfXY2hoCC0tLYw04g2BZMgi7zrqj0jkkUFsfHwcwWCQeWDSO2W1WhmRZbVaEYlE0NTUhFwuB5/PB1mW4fF4GPnPV+XklRcysJGSQO88VVwOhUKs8jUJ8fyaBCjnjjrbQWsHhVbLsszG+4033sDAwABkWcasWbPg8Xhw6NAhdHR0sJQSZrMZra2tTMmiXI80JvF4nMld5PVx6NAhRhCTx2osFmPFOOLxOCuuRc/sXBrTdwokSUJDQwNWrVqFL33pS8jn8xgbG0MwGEQmk8Ell1wyyROGN3RJkoRrr70Ww8PDMJvNWLRoET7/+c/jv/7rv9DW1jbpekajEeFwGENDQ8hkMpg3bx4+/OEPw2az4fbbb8e//uu/YtasWfjHf/zHaVeL1mq1+OxnP4tPfOITCIfDyOfz+PWvf417770XCxcuxKxZsyBJ5YrdVKHa7XZDkiQkk0lMTEzA7Xbjrrvuwo9+9CMsXrwYg4OD6O7uRqlUQldXF/7yl78gk8ngiiuuQKlUgs1mQ6lUgsfjqc3bGk4ZlLwARTKPvNP4PU6Ut8V2+L95QyRPwCl5C4ryNulstH/zudrpfNrr1WR5MRcz/x2/ZyvlgVeST5VIMvHeeXmY9yDlC6XSHhkMBllYdLFYhNPpBAAmMxUKBUSjUchy2buRUsuQTk3pX4hXsdlsLMKCdGbKGU953Sl6hAhSSoETjUaRz+fR2dnJUpMYjUY0NTXBbrcjnU4zkpTCsalgJY0HFa0h3iSZTEKj0cBsNjP9nuYCyWfifFLDdOR6tWPVdNXpXFdsQ0kfUCPBTzVqxCMHfkHy+Xz485//XKGQ8sK0y+XC1VdfjcWLFzMPN/rPaDRWJG4vFApIpVIYHx/H0NAQBgcHMTg4iLGxMaxbtw7PPfccEyhbW1txwQUXoK+vDxdeeCF6e3tRV1fHKmsSqi0cInglip9sFLZ1NkFp0aum2J+qa5KlJJ1OY/v27XjyySexceNGVhhGo9Ggp6cHt956K9797neXPcGOhVcTqJ+UeP7AgQMYGxtjC7XRaGTVKcnDKhwOI5lMYmRkBGNjYywRLl9dtFQq4fHHH8e73/1ueDyeszq86vrrr2d/z58/H0uXLkVnZyd+97vfwWw2n3S7DzzwwKSiNYByKCy4+SJaAJXOV4Kasiwu1lO1W438qezy5OPETUZ8H0ThRqlN8W/WxrFzCoUCAoEAOjo6MD4+zsg5vdHAqq4HQyEY9QZW7MVmsyGfzyOXy0GSJJbnzel0YmJiAk6nk5EhoVAIsViMeYY3NDSwd408rao9A56MM5lM8Hq9cLlczFu8u7sbw8PDCAQCaGxshCRJGB8fRyQSQVdXF2w2GwufCIfDLL2Bx+OB0Wxi66ro1UhjRQKrSEqqCRn832o5JvlrTOUVNhVhc6KEuHhMxXp7BnK7vF1QmmMkNFNuUhJ+xdAoCtehROR6vZ6RfPl8HkajEalUqsLbDwBSqRRrI51OY2JiAn19fSgUChgeHkY0GmX5zkiYleXKkGdeYQGOzxfyAojH44wEpKrHFBJEwn+hUIDT6UQgEEBDQwMMBgOi0ShKpRKrRE33xodPUQJ4Cj8nMjSXy7H3Wa/XsyqTfC4nXjma7pp5toDe+1wux4rxUML8rVu3Ytu2bXC73ejv74fD4YDb7UY6nUZ/fz/zcDWbzZgzZw6OHDmCcDjMvBjp/SZDCCkuoVAIWq2WhWtnMhnmKdvW1gan0wmTycSUZ5vNxuZbDWceOp0ON954I1555RX87W9/YylB+vr6GDG3c+dOzJgxg3m78jKFwWBAS0sLkyM9Hg9++ctf4stf/vIk2UOn08HhcOCyyy7D3r178be//Q3Lly9HY2MjGhsb8ZGPfAT33Xcf/H4/7r77bjgcjkme+wT+O4PBwNqQZRnvf//78eijj2JiYgIXXHAB25f4d5jIhc7OTrS0tMDr9UKn06GrqwsajQbf/e53WeX29vZ2zJ07F48++iiefvppxGIxjI6O4qMf/ei09JYazl689tpr+O53v4stW7ZgbGwMTz31FD7wgQ+w32VZxle/+lX87Gc/QyQSwaWXXopHHnkEM2fOZMeEQiHcfffd+Mtf/gKNRoObbroJP/rRj1iO7umC5qjSPimSb/y8U4suJBmAJ5OoLXIiIv1e9F7kw2/56/J943+jf2nPpX7xv/Hvn1LBRDpG1ItFHUEkl5RkWPpM90EkKy8f88fIcjl3NMkgkUgEnZ2dk4y3Wq2W5Y1Pp9OIxWKsGGUikWApYqxWK9sPSZ7J5/PQ6/UsYpS4FJJZSHaz2+0sCoBkGZJLmpubGYFIshwZ+Kj2QqlUYtEd1G/KyU05IKnwJvE8fAG9EyH/+GfHQ01fVVor+WfLH1dNb+SPUeNVToQYPVmc18SjqDDSSybLMrZv347u7m40NTXB7/dj//790Ol0mDFjBhYuXIgPfOAD6O/vZ54PfHtKlgb6vVAowO/3s5c/lUohGAxieHgYBw4cwPDwMPbu3YtXXnmFKQz9/f246KKLsHz5cvT29jLBQozZVwNvBZnOwvt2QUmxF8eSFm8S4um36bSr9luxWEQoFMKrr76K//mf/8Ebb7zBnk82m0Vvby/e//7348Ybb0RLSwsbe6UXlRaturo6RoTQxqBEYFPoFYXYZTIZjI+PY8eOHfjjH/+IQ4cOQZIkvPnmm3jqqafwT//0T+yaZ8tzqwaXy4ULLrgABw4cwLXXXssS/PJej36/XzEnJI8vfelLuPfee9nnWCyG9vb2imOOk2qVIQPi4ip6/IqoRvaoWZqU+kF/86RSNYjkk0hEVbN2VVMy1BR/IjgaGhpQLBYRjUZhs9nK4aRaLbK5cohhOpVCTpOF7thmnE6nUSwWYTQaWX65UCgEk8kEq9WKaDTKvA9pA9fr9QgEAqirq0NraytGR0erko70HvHPjzyrLrjgAkSjUYTDYWbsIY+suro6Fh5JiaLJw5wEn3g8jng8jlA4DIvFDJfLXfYUw+TwA+B4ygVgcvi82tiqWSrpb7VNXmk8pnrXxbnFW6fFtVSpLXb+ObCenCpQ9UUiynhBTEm4NpvNCIVCbD4R+UjCOeVkpKrPFNkQiURYNUU+xMhut7MwRgBwu92MoIjH48yzkveEoKJl8Xgcfr8fkiTB4XDAaDSyVB5er5elT6CK2JIkob6+HrIsM68Ai8WCSCSCo0ePMi87um+eaNdqtRXew9lslhniACCRSECWZbS0tDADBJ+binAu7Ff8+87nzcxkMvD5fNi0aRO2bdsGm82GJUuWoFgswmQywe/3o76+Hh0dHSzfFBXoOnLkCMbHx9HX18fSqFDuTZvNxsLkdTodXC4XkskkrFYrbDYbq5YukkhmsxlOp/OsH893OorFInbu3IlDhw6xuZNIJLB161Y0NDTA5/OhWCyisbERra2trDABPTciHPfv34+ZM2fimWeewcc//nG0trZOIgivueYa7NmzBw6HA3v27MHWrVuxbNkypNNp3HLLLXjppZcwMDCAT3/607j//vuZ8q8EJbkaKBfPMplMiEQiCAaD8Hg8Ff0tlUrw+/04fPgwFi5cCKPRiLa2NhiNRphMJjQ0NODQoUPYt28f3vve9yIcDuOmm25CNpvF3//93+O///u/ce211+Kyyy47DU+jhjOJZDKJBQsW4J/+6Z9w4403Tvr9O9/5Dn784x/jscceQ3d3N/7P//k/WLlyJd58800Wxv8P//APGBsbw+rVq5HP5/GJT3wC//Iv/4LHH3/8hPoihjOr5UMUCUCe1FPzmqTj6Hug0vtQJPX4a/Hn0HlimjOgMhe8UnsE6oeY01vpvvhzlOQ93mtT6T7F0GGScXinAX5vpHRGqVSKVaIm2Yj6RqSaxWJhTjuRSIR5FyaTSWSzWZYrWqvVMq9DSm1HOgVdI5lMQpLKHoqUiolSLxGRSMVj6HMul2OGY7ovSZKQy+WQSCRYBAIZZOk+KJUF8QKJRIIRm9Mh8cRnJspEou7BE948+aw2L5Q+V9NP30757LwmHgmilWRoaAiPPvooEokEPB4POjs7MXPmTFxyySXMA9HlcrHEo6KlgYfSxMpkMhgYGGB5ERwOB+bPn4+LLrqIJYJPJBIYGhrCjh07sH37dvz85z/HQw89hNbWVlx88cW44oorsGjRIni93kkVj8UJxS8idJ9qFtG3C7zQDxwnS3kymDw0+UXsZEAbRrFYxPDwMP7yl7/gz3/+Mw4fPsxeervdjgsuuAAf+tCHsGLFCjbO07FGUE4IAr/ZkCdFLBZDMplEKBTCa6+9htWrV2NiYoK1RwoKPw7/7//9P7zvfe9jXirnAqiC98c+9jEsXrwYer0eL774Im666SYAwMDAAIaGhrB8+fKq7VAeVSVMssaVZEAztaeh2qbM/0tQI2zEv0VBg98sqs1bUViaiqzkNyOeyBYFIDqOPrP2jl2LCMNgMMhC+AqFAlAoQJZLjETIZ3MwHvN0pLwnlDCaCmzx7YdCISSTyYqct4lEAmvWrEEsFoPX62WVcpXuU7wnEpYSiQQikQiam5thsVgQi8UQiUTgdpfJQ1LaE4kExsbGWJgiACZEUJEwXaGATDqDsdRouWiY3Q6T2VThsaU01vzzpWeqRFYpGVD4+1P6LBLlaoKL2pzgx0vpOqqk4zTxyCOP4JFHHmGE2Zw5c/CVr3yFeTpnMhl89rOfxRNPPIFsNouVK1fi4YcfRmNjI2tjaGgId955J15++WXYbDbcdttteOCBB6adXuStQJaPW+iB4+8ovz4TGcn/TkJgOp2G3W5nIUWU94cSp/MCPc1Vg8HACsuYTCYEAgHk83k0NzdDksqhi7FYDIlEghkDTCYTm1uUkD2TyTDLv8fjQSKRgNVqZZZ+ykVIAnY6nWaelbNmzUJ9fT3C4TDGx8dZziMqPhMMBmGz2Zhck8vlKhKpE3hPj/HxcUxMTLBQYiIeeflCJHTPdgKS5gLtuVQc48CBA9i7dy8AYPbs2cwblMKhZ8yYMSn83mazobGxEYcPH2bPamJiAkeOHGEFhhKJREUV9IaGBlasjshFfryMRiNcLpeqsamGMwedTge73V5BBAwNDWHhwoUsf6fJZMLBgwfR3Nw8af8AyoZZj8fDDGOPP/44M7DyHlA333wzPvKRj+DDH/4w9u7di29/+9u46KKLcM8992DWrFm444478Nxzz+H666/Hfffdhw9+8IN43/veN4nsVJszkiQxr+m1a9fiwIEDWLVq1STyMp/P4/nnn8fg4CDe8573wGaz4eqrr8bLL7+Mj370o/jpT3+KFStW4KWXXsIjjzyCyy+/HC6XC88//zza2trw7W9/+5zJVV6DOq6//vqK6CYesizjhz/8Ie677z68//3vBwD893//NxobG/HHP/4RN998M/bs2YPnnnsOmzdvxpIlSwAA//mf/4n3vOc9+N73voeWlpYT6o9S6LT4vvFyFb/fi4ZmOob/lz+PP59vQ2xHJJD4NnhHFKAyl7gok4gh46JuIMqM9K+aEZs/Thwzalvcq3m+gO9fIpFAKBSC1+tFOp1GXV1dRfEVktv5a/IyksPhYKlsXC4Xi/SLx+MIBALM6GswGFjxVa1WW5Fjm4yyJIPZ7XYWmk2ejul0mvWH0p6QnEdpzcxmMwsLpyhFyh3Jjwvt/RSmHQqFYLVaYTKZVMdVnEuijqZ2nDiflZ5VNSjJ//RsxblfIx7PIOgB0EJQKBTw3HPPsZxzfr8f3d3dWLZsGUZGRjA8PAyv14tLLrkEPT09k6wlU11Lp9Ohp6cHM2bMAFBJSk1MTGDHjh3YuXMnJiYmYLPZ0NPTg9tvvx0mkwmjo6PYvHkznn/+eTz55JNoamrCsmXLcN1112HRokXweDwVggJPdvCLhkhUni3gXxIKM+YXUN4L42RfFlkuh0Lv2rULv//97xnhxxcGuOiii/CRj3wEixcvhs1mY+N4ouNG/U4kEti8eTMMBgOampqQz+dx8OBBjI2NYWxsDAMDAxgZGUEsFqsoNCRJEstDUSqVMDw8jHXr1lWENJxt+NznPof3ve996OzsxOjoKL761a9Cq9XilltugdPpxO233457770XHo8HDocDd999N5YvX37ShWWUNmdZlqGFBhKOLaoohxbTfOE9lHkBYjrhB+L3IoEvbhR0Hk8CivNWbQ3h+0abn5IVl67LCzgURk0ESqlUAkrHr5PL5xGJRGCxWJgnlsViYQqxLMsoysdDoWkuEsHBh83rdDrm1TUxMYFoNIqxsTFMTEwwr0igbN3U6/VYsGAB1qxZA7vdjlQqxaq9Vnu2kiQxpZuMNTabDW+88QbWr1+PsbExzJs3jxGPlCKBUhOkUikWSsvnqbRYLGXvx1AIR48ehdfrhcPhYESkpDm+ufM59/jxF0MtRCFSnE/8c+OrFopWaF7IVCISeUKW/0xjR/uamvevUj+mAimPM2fOhCzLeOyxx/D+978f27Ztw5w5c3DPPffgmWeewZNPPgmn04lVq1bhxhtvxNq1a9kY3nDDDWhqasK6deswNjaGW2+9FXq9Ht/61remvP5UqEai0tpPgqaaIkFjSs+RPpPAS2HGJHiSByRVWMxms5AkCfv27cP4+DgymQwcDgfa29tx+PBhBINBzJ49m5GKDoeDpdjIZDJMwCaZhPIsEhmp0WgqwpTI0GW321kuQCpg1tnZiUOHDmHr1q2wWCyoq6uDRqNBLBaDzWZjBWMojJfyMFE+R4fDAYvFAr1ez/ZkIiYDgQAjURsbG9k84/dJfr07G0lHfr6USuVc2Pzfq1evxqFDhzAyMoLu7m709vYyz89SqQSj0Yi5c+cyLw6j0cjyQOn1erS2tuLQoUPIZDJIp9PYtWsXbDYbZs6cCYfDweZdMBhkJDTloaIQM5IJKD/yuWJ0fKeC5jKF8PEyxdGjR5mhbdGiRczrmIxeNP/T6TSOHj3K9p1AIIAVK1bgqaeewkc+8hF0dXWxa2m1WnR1dWHFihVYs2YNPv3pT+OJJ55AIpHAb3/7W3ziE5/AokWL8Pvf/x6hUAgPPPAAfv/73+PLX/4y7rrrLnR0dEy5vvNrYzwex8GDB3HLLbegvr6e9UOj0aCjowOf/OQn8fjjj+OXv/wl/vVf/xW33XYb/vjHP2JgYADvec97sHnzZvzoRz+Cw+HAG2+8Ab1ej66uLsycOZPliTzb1oEaTh0OHz4Mn89XUUTS6XRi6dKlWL9+PW6++WasX78eLpeLkY4AcM0110Cj0WDjxo344Ac/OKldtTzvACbtLyR38YZ+kYyj/Z30SRGijC6mYOH3NZHgpP/4kG2+D/z54h5J+y99FokvuoZSf8X3Sum6/DWB4+G9oqGfN7aLZK0slx0UxsbGmPwfj8fR1tZW8SzE8RXHkNZN8iYkwo+8+oPBIGKxGKLRKNsHE4kEbDYbC8smBx5JkljOR7vdjra2NraeUUE9KvZKThYajYZ5W7pcLmYAJG9Lcv6h42hfp/EhnUiSJKZv8fK2OC/F5yE+J/E7peepRiorzYepflPSV88EznviUczlEI/H4fP5sGjRIrhcLlx++eXo6OhAXV0dHA4HAFRMrhPdQEXigzwmZFlGa2sr/v7v/56FTQ0MDGDHjh14+umn4fP5oNVqWZW4devWYXR0FE8++SSeeuoptLe346qrrsK73/1uzJ49m4UeApNzRpxNUHv5aHxpQeS9i/jPokVWfHlo8SeryObNm/HEE09g7dq1iMVisFgs6OnpgcFgwOWXX44bbrgBfX19rGLvpk2bsGHDBlx22WVYuHDhSQn9NpsNl156KYDjHiMXXHDBcRIol8PBgwexYcMGbNmyBQcOHIDf74fJZMK73/1uFItF/PWvf8XExARWr16N9773vaoVtt5uHD16FLfccgurQHbZZZdhw4YNTID9wQ9+AI1Gw0JwyCPqZFEtvwa/mMqQWRVrkbxR+lepLf6aSseKQghvlRJJKjpf3FyUri8KHUoQyRNSVEulcu4+CYB07J1JJBIs3M9gMKC+vp5ZGnU6HfO61mg0yOdykFDO45hKpVj+UbIaUmXcSCSCQqGAZDKJcDgMAKw4DVX+JUtoMBiERqNh4Z18CIf4/hLxzls4/X4/UqkUdDodAoEAenp64PF44Ha70d7ejlwuh+eeew52u515DTU1NSGVSjHLqkajQSKRYKRofX09kskkI35sNhtkoEy6GPRsPHmij58LSoKp0rMRn7lIZovkOH0nziVxfojX5M/l5w3vtc0bpaYreLzvfe+r+Pzv//7veOSRR7Bhwwa0tbXh0UcfxeOPP44VK1YAAH75y19i9uzZ2LBhA5YtW4bnn38eb775Jl544QU0NjbiwgsvxDe+8Q188YtfxP333888dE4l6L7IgMMLuMlkkhWII0KP5hl5HwJgORopL5AsyxVea+ThNjw8DIvFgnA4jK1bt8Jms7G2BwcHodfr0d/fz54JVWl3uVxIp9Pwer2QpHJUBAnRJOhSWFEsFmNz22w2s9QBVquVeVk1NjYin88jFArB5XLB6XQimUxiz549MBqNcLvdiEQizHuTwoacTiez8geDwYq8jWTE0Ov1iMfjzHNUo9EwzwIlQZtXwM62/YpAVSxprhQKBRw6dAgHDx5EsVjEhRdeiLa2NnR0dCAej0OWZaRSKTQ2NqKurg6FQoEpKCaTCalUioXOOxwO7Nu3D3q9HnV1dVixYgVMJhNTpE0mEysOJEnHU1nQPCsUCox0PBNewTVMDxqNBrNmzQJw3Chls9lw5MgR9PX1IZ/P43e/+x0aGxuRSCSYc0BdXR127tyJZ555BrlcDnv37kVjYyP0ej1mzJiBF198EbfffnvFeqzVavGZz3wGN998M77//e/jjjvuwL59+/Db3/4WRqMRH//4x3H//ffjrrvuQjabxRVXXIFIJIIvfelL+Md//EesXLmShRCqgfYc8pgeGhpichtBksqFdW699Va8+eab0Ov1aGtrw/33349bb70Vdrud5SeNRqNwOBzweDz429/+hoULF561738Npw7ktMNHOdBn+s3n86GhoaHid51OB4/Ho1poUi3PO+05os4IoIL04mUnNblfSTfg5S0xMokMxrz8T5EPYsFCAp/KhL8G7SFqxBIvB4r94wlW0cAsjhWAimvRObwXJunWSnIhfRePx1kl+0wmw9Ie8ccTacrLxmJfeHmaZFwKhbZYLEgmk4hGoxgdHWU5tSnfYjqdRiAQgCRJzKu8p6eHEYu0/5ZK5Rzv9GzIyYzG02AwMCMuEY8mk4mlYaOoKZL/Kc2OLMsVBmGaEyL5yN+fkl7I37vSc69GQE5lUOLHWuyD0vNVelanGjUphkOhUMC2bduwf/9+DAwMQKPRYHh4GE1NTRgbG8MHPvABXH/99UwROBnSUe0zvwBQOODSpUtx6aWXsjxAY2Nj2L17NzZv3gyv18sSvut0Ohw+fBhHjhzBE088gdmzZ+OWW27BlVdeWWFhPJst5fxCzFtlaFGnl1nMpzmdNmOxGF599VX85je/wbZt22A2m7FgwQIUCgXMmjULV199NRYsWMC8G2OxGFavXo21a9eiqakJ73//+9He3n5S40cb0/DwMA4fPgyTyYRwOMxyOtICKEnlCoLXXnst3v3udzMSPBAIYN++fUwp2bJlCyYmJk44FOFM4Yknnqj6u8lkwkMPPYSHHnrolFyP3yjFBRXgF20JkqRuxRTfRaVnXW2RVyIu+Q1IDNWtRiCJ1+Q3Kv47/hgCL9Sw72Uw4iKTySAUCrH+jY6Oor29HQ6HA/l8ninV1GfIgNlkYmHRJGCQFZHfQCnhs9VqxejoKFKpFFO2m5ubEQ6HmQXUYrFg165djNhQEtBIYCEyqre3F729vViwYAFaWlowODiIUqmEpqYmlEol1NfXQ6fTob6+HitXrsSRI0eYxdLv97MQa8oZYzab2ZiazWYWLkJ58ZKJBFLJJKw2G6w2K3tPibhSe/bixl3NiinOQXpu4nFiODd/PbX8L0rH831UIshPBMViEU8++SSSySSWL1+OLVu2IJ/PV3g69PX1oaOjA+vXr8eyZcuwfv16zJs3r0IpWblyJe68807s3r0bCxcuVLxWNW+HapBlmSWE59eIYDCIPXv2YHh4GMVikQmhOp0ObrcbTU1NMBgMjDyikFgqukIhzWazmYX5xONxGI1G7N27F0eOHEFbWxszAiYSCbS2tjKyl8h4SlJORW7IE5E88K1WK8LhMPOqpMIl0WgUoVCIpTmwWq1IJpNIJpMYHx+HxWKByWRiOdvI47e3t5cZHNLpNEZHRyFJ5ZAnq9WKVCoFk8lUUb2RKlJ6PB6W7iIejyOVSiEcDmP+/PkIBALMMEoQ5/l09uy3A/x6yd79ZBLPPfccgDLR2tjYyArHkEFFp9OxXJx8ZXN6PvReeb1eDA0NYe7cuViyZAk0mnKSe9r7AbD2dDodW+9kWWbeuTXS8ewCze3LLruMFZcCyl79kiTh5ZdfxujoKFtryKN41qxZ8Pv9ePXVV/HGG29gx44dKBQKGBwcRCgUwrXXXotNmzZhwYIFcDqdaG9vZ0p0U1MTHn74Yfzrv/4rvvGNb+Cee+7B/Pnz8dxzz2Hp0qVYvnw5Pvaxj+HRRx/Frl278Hd/93f44he/iP/v//v/sH37dnziE59gHpoAWL55Sh+RTqfh8Xhw9OjRinsR71mr1aK+vh5XXHEFgPL7c/XVV+Pf/u3f8IMf/AD5fJ4ZLwCgvb0dN910E/7whz/gU5/61CTCqYYapgO1PO98ZAxv4FeTtwm8IwCfZ5H/neSzQqHADEIkw/LGJnIEyeVy7Hyj0ahYaI1/j4DKitZKOoYo94selGrGPiXiVCS9eJmT/14pagEAM85ls1mEw2GUSuUCLtFoFH19fRVjTvsqVYYmYpN0et6Bg4/oEu/NbrfDbrfD7XYzEjIYDCIajSKVSrF0MxqNBi0tLSiVSiy3Nj1fyvXIP0eTycQKZhLJSPt/JpOBRqNhaTCoiB/t/XRPFLKt0RzPqy0Wo1QyyCo9XzVUI8fpsxIxOR1SUkkHPhMFh2uSDI4ruKlUChs3bsSuXbvYJhyNRnH11VfjiiuuwIwZM84IeSfLMmPU6aUcHBxEc3Mz5s+fj+bmZnz4wx9GLpfDjh07sGbNGuzduxexWAzpdBrj4+N45pln8Jvf/Abve9/7WG5KfhFUsv683eCtLCIByVthxOS6wOSQKVocX375Zfz85z/HG2+8gfr6evzDP/wD5s2bh6amJrhcLnR0dDDPq2w2i9WrV2Pbtm3o7+/H3XffjcbGxkmu+NMdN1J6AaChoYElzKXFmxTedDrNFtOxsTH4fD74/X5Eo1G20dEYBAIBbN26tUKAPJ+hNgaTLU2AqPbSxjbdcRTJP5qbaqRZNUOD+L2aUq5mAVU6ntYKAkvsLJeQTWdZYZ9cLodisYh0Og2gHBrjcDhY3kWXywVZlllOORIaRGGuWCwyD0gKcaZNu6WlhSk2FouFFZPp7+/H4OAgIwJTqZRikRkaW1K6urq60NXVhSVLlqCvrw+jo6N44YUX2PtrMBhY2CcJELSGl0olFm5G1WNzuRwjTinEzGAwsHQLGo2GeZzFkwmEI2FYrVY4nU4mmPECHR/WrFQFW3x2/Dos/q02FmIoTDUhptr8E4WiE8XOnTuxfPlyVr30qaeeQn9/P7Zv3848s3iIng5KnhD0mxrUvB14iEQq5eoBju/xsixj586d2LRpE5qbmzFr1ixmpS8UChgZGUEikcDAwAAAIBAIIJlMwmg0ore3FzNmzGDKBb0flOdteHgYwWAQR44cwezZs9He3s48KKkPer0eoVCI5Vek3IhUKKlQKCCRSMDtdiMUCkGj0bD8qLIsw+l0IhaLsT2LckPq9XqWIoDet4GBATbHAbD5S/0plUrsfsPhMPPSq6+vh9PpRKFQYGQvGR1I0I5EIgiHw5AkCTNnzoTL5cKuXbuQy+XQ0dExyZuC37/PRvAKpkajwYEDB+Dz+WC321nYF1Ama1paWhAMBjE+Po6WlpZJ5Ixer0cymWRe4jQvZ8+ezYwWFK5ObdL7yhtXgeO5jUl2q+35ZxfmzJmDCy64ANu3bwdQnkdU8OmNN95gHn/5fB4WiwUT/z97Vx4eVXm93zv7PpPJTPYVAoEAAQLIJiLRoljcihZREcWlWrXuWqxaq1baWmutVevSTa1a5SdqxaVugLLKTtiy75PMTGbfk5n7+yOcj2+uExQV1Op5njxJZu7ce+fe737fOe95z3tcLvT09GDnzp2or69nQTKV6Dc3NyMajWL58uXweDzIzc3FxRdfjFmzZrFO6f/+979x55134tFHH8VPf/pTPP7442yuWLx4MdauXYumpiZ88MEH8Hq9uPDCC+F0OvH73/8eY8eOxVlnnQWDwYBf//rXWLFiBWw2G3JycqDX6xEIBNDQ0IDTTz8da9aswYknnvip6ppM64parcZ1112H008/HfX19ejr60NZWRlycnJQWlqKYDCIV155BXV1dYwN/739bxo1iuzt7UV+fj57vbe3FxMmTGDbOJ3OtM9Ro82hGk0OpfNOVRxSIE1qQ/nZPFDG+1a8v7Rjxw44HA62DhLwFIlEoNVqYbfbYTKZmO+nVCphsVjY+kGxvCAIjEQiPa9MMS1PXuBf50FTXp5Lmnjmfb1MiXF+X5muhTSpTX5VJBKBx+NhQCKRCfjPUoUJxSSkC08VTFRxSN+DfHDyo/m4l8qaSV6GqlQsFgtL1GVnZzOJFJKKoWPpdDpEo1Ho9XqmmQ2kV8wRKSGVSrEmmS6XC2azGdnZ2QCQ1n08kUgwH5MSw6SZTQlrit+lupeZbKgYMNO44AlYX9QnkPoTh3t2vmr7zgOP/EO1c+dOdHd3Q6lUYt68eTjjjDOYhs+xLG3lH2JgkI0zadIkNuB6enqwbt06JBIJnHrqqTjttNPg8XhYN+xzzjkHVVVVeP/99/HKK68wkefzzz8fVVVVrBMTfw2+boc204QPpCP30rJaqdG2AwMDOHDgAP785z/jgw8+gNFoxOWXX465c+di/fr1CIVCqK6uhk6nQyKRQFdXFxP4HzNmDGpra9OE8gEwJhQtLoezTCClTqcb7BYsk6UtJHTOtF19fT02b96MyZMnswA+EAjg9ddfR2dnJwYGBvDuu+9i3rx532gG67Ey6ZgZ6n9RADDEhCoFguj3UAAQnx3MlIU6XHZLejzpZzMdj7YZ6jzpN+9QkKMTj8cR8PuRSqbYAlhWVsbYUhQM9ff3Y8eOHcjJyWFgHx2fdM+AQ0AVlZnSQt/f349AIMDkKAAwwIYYYZSZNBgM0Gg0KCwsxO7duzN+b3LQdDoddDodTCYTYzx6vV6sX78e0WgUBQUFrEQ1mUwiLy8vrWSW2Bft7e1p+yNGBpVNpA6WxhDQCoD9r9KoGeu8t7eXafwR+41PjBxuDGX6W1p+OtSYynTPpeNC6jzyf2cai9JM7OedTyorK7Fjxw74/X6sWLECS5YswZo1az7XZ7+ofVZXe+nzx4OOAJjEwMaNGxEKhTBv3jwYDAbGhCSHMDc3F6I4WEZLIEB/fz9KSkpYZ2i6VnTfqVy7t7cX+/btw4wZM5CVlcUcZ2IHO51O5Ofnw2w2M7CBGIzUZdpisTCQ3mq1IhAIsG7xHR0dDBwUhEHJAp1Ox8ady+VioODAwAD0ej17Fij4IXYkMChjQCwAn8+HYDAIp9OJrq4uBINBGAwGxoairL9Wq4VMJmOsyezsbBiNRsZc/uSTT1jXbP5+fFONB0VpDCQSCezbt4/JO9jtdhiNRrhcLowfP56BRLFYLI2dSAESBaR6vR52ux3d3d3Iy8tjuqB8ybpCoWAMV5K3+H5d//aYxWLBaaedhrq6OgBg4D+tD+FwGIlEAnl5eeju7kYgEMDAwAA2bNgAg8GAq666CgUFBRg+fDgDLAAw/eP9+/fjvvvuw+TJk3HfffdBr9ejsLAQf/zjH7Fs2TL861//wq233opXX30Vcrkcc+bMwW233Yb77rsPW7Zsgd1ux9/+9jccf/zxuPnmm7F69WrccMMNmDFjBtavX4/f/va3mDZtGgMA7rrrLjz22GOQy+V48803cfrpp2PKlCkAPr1WkQmCwMb0qFGjWPk5v+3AwAC0Wi06OjqO6v343r5+Ky8vR15eHt5//30GNAYCAWzatAlXXXUVAGD69Onw+XzYunUrJk2aBAD44IMPkEqlMHXq1CM6Hu+PA+kAinS88glcHqgcas6lmLuiooJp8hMoRmuq2+1mlQPhcBgajQaJRAJqtRrZ2dnIz89HTk4O8vLyYDabkUql0hJJ0vPn5d/4dYU/b56kQ9+L/84UD/BVHvx3HqqUWqr3yH+OT85R9ZLJZEIymWQsZpJeEkUxjf1JIB0wWL1C84XT6WQVngQqkowTJfHodzKZRHd3d5p/RH6HXq9HMBhk15XYjgTKBgIB9p0UCgWr6KBmMqTTSNcgFouxhHIoFGKEBKVSya4DSfIQGQoAI0EQOYrX6uTvC8/2PNxYHoq0wPv1Q8Wg0s/R65kIEZ8nHv0q7TsPPAKHymGfe+45uFwu1i2anHwSExeEQa2zY5G15zUq+N95eXnIzc3FnDlzGHNp//792L17NxYsWICFCxcy5/Wiiy7C/Pnz8dprr+Hf//433n33XcyaNQsXXnghJk6cyEoNpQMZ+Pysvi9rnxf9zxSE8+dKk0E4HMbLL7+Mxx9/HMFgEPPnz8cVV1zBylnOPfdcWCwWpFIpbN68Ga+//jqGDx+Os846C6NGjUrbZywWw+7du+Hz+VBaWsr0t4Yy6QTO64FImQz8dm63G16vFzk5OXA4HHjuuecYYNLZ2clYkjRpbdq0CS6Xi2lafJMDu6NtmTI0aZMoRAgQIBMEYIjyaf5zUmdAuj9pyevhSmD5c8sEVvLbf55sF7+PobaXCYOsx5QgQEyl4Pf5oFap0RcYbF5gs9kQi8WQlZUFmUwGhULBsobl5eVwOp2sRNpgMDBgjQC6cDgMlUoFj8fDgHhysrRaLcLhMIDBkvqGhgbo9Xro9XqkUinWyEYul0Ov1zOngxg/9KyQY1BUVISCggJ0dXWhuroa48aNQyAQwOOPP46uri6ceeaZbP8WiwXDhw/H5s2bWbOmgoICpqWWl5eH/Px85vTFYjHm8CiVSsRjMaQOOku8MyGTySCTDzIv8/PzEYlEEA6HEQwEkDro8Oi0OggCIEicRSBdAzJTRpF3MqXjQbqtNPDLlM2WjlN+/EmdU35bIF1r53BGJbsAMGnSJNZMYOHChYxVy7Mee3t7GYshLy8PmzdvTttfb28ve28oO1xXe95EUWRAOD0riUQCTqcTGzduhFqtxuzZs5njm0wm09iv5DSq1WrY7XbE43GMHj0acrmcyRE4nU6myRaPxxGLxVjjOZIAiMViyM3NZdpAXq+XyaJkZ2czUXKlUsn0HNVqNQKBACwWC9NI02q1cDqd0Gg0yMrKQiKRQG9vL2smQ/pGVqsVTqcTHR0drOM7dcwlbTdiZ5LMB61JlBRLpVIoLi5GJBKB0+lEZ2cnY2uZzWYmzE7NMmgsNTU1oaioiOmtkkPOJ0O+yWsUH9wRW7Gjo4MlL8rKyhCLxVBRUcE6b5rNZhbUULBD1ycajbIunFqtFgaDAT09PQiHw0z6hgewqQyXt2/y9freDpkgCFiwYAGefPJJpn0ciUQQj8dhtVrh8/kQCoVgsVjw4YcfMtmmadOm4b777sOECRPYWkRJEGLauN1u2O123HPPPXjhhRfwzjvv4Oyzz4YgDEoj/Pa3v8Xtt9+Oxx9/HCeffDJWrVoFvV6PSZMm4aqrrsKvf/1r9Pb2YvLkyXjppZfQ09ODOXPmoLi4GIsXL8att96Kt99+Gy6XC1VVVZg8eTLOOuss/P3vf0dzczO0Wi0DOKuqqoYEZzL5M2TSAHmoRnLf27fLQqEQGhsb2f8tLS3YsWMHrFYrSkpKcP311+O+++7DiBEjUF5ejjvvvBMFBQWsMebo0aNx6qmn4vLLL8df/vIX9Pf345prrsF55533pWWkpL64VMbrcInZTP6RIAwy60499VQ0NjZi+/bt6OvrY+uq1Wod9AmDQQZ40XMcCATQ0tKCgYEBmM1mjB07FlOmTGEEFimZAcjMvORjSQBpDDr+M/z34tc13vhrwB+f3uOPL4qHmtsAYGxHt9uNeDzOZGTMZjOi0WgaiEesQzoHQThUUk3VIpSMo+oK+k582TL5LoFAAH19fYjH4wwUFAQBI0eOhCgOak729fWx70Wl1NRpO5FIMDkbkrEhfWVizdIaTvMxXz1FydxYLMbiIVEUWQxBmAHtixK0PJkhU3xJ1/1w4B99ho8XMmE1mfytTDFCps8fS/vOA480Sbjdbng8HqYzFY1G8d5778FqtbKywWnTpmHkyJHHDIyTTn7SSYTQ/pqaGowbNy5toqIAPjc3F5dddhnOOOMMvPHGG3jmmWdw+eWX48QTT8RFF12E8ePHp9Gbv45BSEb3gs+4AOkMMn4y5R8cKnX77W9/i3fffRelpaW4++67UVtby4K74cOHs4nulVdegcPhwMUXX4zhw4ezCS6VSsHlcmHbtm2w2+3weDwMiOabCklNmhniu9oOxWKg72Gz2Vignp2djbPOOgsejwexWAyFhYVobW1lTKtwOIyenh588sknmD9//neeHUFj/dALgCiAayUDpCBCEAHpUysdU1Lg8XAZ0UwTdyYmK51jpkn+cGAkGc/akh5X6mwIIgBBgEqpYuX7yWQSnj4PBgYGkJOTwxZQWswpc0egC3XYJVYVsSRJfHlgYAA9PT0wm80MVCGnwGAwMIfC5XIxEKW0tBQejwfxeBzDhg2Dw+HArl270Nvbm7ZI852DCwsLMXz4cIwbNw4NDQ2orq6GXq/Hk08+ifb2dhx//PEoKytjXYa1Wi0ikQjKyspgtVrx4Ycfwu12Y+bMmaxpBrHDQqEQA3vI6aH7R6XaPCtJhkOJBKVSyUCYgUQ/ErE4kBIZmwwAa+KTCUyUji/e0aP7mxIPjl5BgEDlNJzjMdS44bXqMo0pfl7iu5zy4O8XsVQqhXg8jkmTJkGpVOL999/HggULAAAHDhxAe3s7pk+fDmCQ6fDrX/8aTqeTZcnfffddmEwmVFVVfaHj89+ZgETgUMOQ1tZW7Nu3D2PGjEFJSQn7znTd1Wo1K/enJA+NRwKs3W43K5vq6+tDJBJBKpWCx+NBV1cX9uzZg5EjR6KwsBAGgwHd3d1obW2FTCZDWVkZBEFAb28vnE4n278gDDKFyFknrUfSUwyFQqxjdG9vL/r6+mCxWFi5NgUzXV1drMx9xIgRKCgoYIGNVqtlGXy+bImcYl7bkoB4EmT3+Xxwu92sLMlisbCgIhKJMBBTLpejpaUFyWSS+Ud8o5ZM/szXadI5mJ4bGhOtra0IBAKw2+2sCzjpfRKDm9ie9DyFQiFWKiYeTEiEw2GI4qA+Y0dHBzweD0v4kL9Bvs5nNckbyqRJqG/KNf5fM2kCURQHmc4HDhzA//3f/wEAqyDIysqCyWRCY2Mjazy1Zs0aZGVlobm5GbNmzcIDDzyA7OxsyGQyxg6m/er1esaQevXVVxGNRrF48WL885//xHHHHYfi4mIIwqD22b333oubbroJW7duxfz58/HII4/g+uuvx5w5c2C1WnH++edj7969uPDCC9HS0oJwOIyWlhYYjUbo9Xo0NDTAZrMhHo9j3LhxqK6uxoQJE7Br1y6cf/75+POf/4yJEyfCbDazuZO3zzveXC4XXC4XsrKyvqI78r19nbZlyxbMmTOH/U/VCEuWLME//vEP3HrrrQiHw7jiiivg8/lw/PHH4+2332Y+IwD861//wjXXXIOTTjoJMtlgw8k//elPX/rcMiX8pe9JASDpfJvp80qlEqNGjYLNZsO+ffvQ1NSEWCzG9JHlcjn8fj9LnPPyHMFgEKFQCOvXr8e+fftw/PHHY9SoUaxEl48zCEDKlJCWfg9pPEAxCCUW+f3SvqTrDR1PSmqQvpZKpZBIJOD1epnutCAITPcwFotBFA8l70kHWyaTsbiAl0qj8yZfm/wS8ifpmouiyKQkSAaK/LXhw4ez0nXy8wmAJJ1samxJbEQqgSb/hxjqwCBhQuoTUTMbkkmhipF4PM46bNN6TudC90GlUrFEL11DqpIgH4mOI72fmcalFDz/rPV/qLjz68R5gO+BRxZg1NXVoaCgAFqtFm63G1u2bEF2djamT5+O2bNnp2kRHAvjJxP+f+n7tI2UYSAtS87NzcUll1yCefPm4ZVXXsGLL76I1atXo7a2FpdccgkrJ/8sIORomvT8pZkfenCBQwsCBZfr16/Hvffei9bWVvzwhz/ETTfdhKKiInZdCEihSfjEE09EdnZ2Wldxv9+P//znP9i/fz9mz56N6upqNpHw1+Rw10bKGqLMj9T4SYbAl1QqhTFjxmD48OFYsWIF9u/fj+LiYhx33HHQ6XTo7e3Fc889B6/Xi3Xr1mHevHlf2736ptinwRUAyNxJLBM7caj90GvSe89P2NKxOBSFXgpAShd0qSOUyTI5SPz/vMORTCbh8/lYx1wqCY7H40ilUqzphCAITFw5FosxrRKFQsG6RhMTivRLkskk066RyWSIRqOQy+WwWq1scaVuujabDVlZWfD7/Wz+TCQS+Pjjj+FwOFBZWYlEIoHm5mYIggCtVsvK0hYvXoxQKMQabD377LPYvn07A+NHjx7NABCTycTOJzc3F6WlpUgkEmhpaUFfXx+ysrJYKQZlOHnHQBAEBlaR08B3+BST6eCJTDYoKq2UKxAMBlk38EgkAo1WgxQ3B0jL3+keScHBoe691BnJ5CBLx/rh5gN+LsqkC/RZtmzZMsybN491933++eexevVqvPPOOzCbzbj00ktx4403wmq1wmQy4dprr8X06dMxbdo0AMDcuXNRVVWFxYsX43e/+x16enpwxx134Oqrr/5cjMahjF8vCUyORqPo6OiAz+fD7NmzYTKZ2L0mII50gGgOJgdWqVSivLwcwGAjFZ7xp1Kp4HK5AACRSARdXV0ABpsfUekyMXYPHDjAtNpIH5HKq9VqNRwOB8uYU3ORWCwGt9vNOjqGQiF2LI/Hw8Atkt7Iz8/HpEmTkJubC4PBwMqhgUOaRFqtlkkmkONLY4GXCqBnlPQ7e3p64PF4EAgEoFAoUFJSgmHDhrGuj8QQ3bVrF0455RT2HXmAO5MEwDfF6Pmh9XdgYAANDQ2stIuawVVXV7PEhE6nY/eqs7MTpaWlUKvVsFgs7LuSjujIkSNRVlaG3NxcNDQ0IDs7G1lZWey+iOKgFjWfCOAtU/IgUwB6uM98b1+N0bju7OzEa6+9hpUrV7KmQcuXL0dtbS3UajXTZF25ciXuuusuxpL3+XwYO3Ys7r33Xuh0OjidTtbwjAcfg8EgotEo1q1bh/LycqxZswZr165FZWUlnnnmGdx+++3smTWZTHjggQdw880344knnsD555+PXbt2IT8/HxMmTMDPf/5z3HzzzfjVr36FRYsWwWKxYN++fQgEAojFYsjLy0M8Hkc0GkV9fT3Gjh2LK664ApdddhlSqRRMJhM++OADKBQKXHLJJUxW4Uiv2759+yCXy4+4jPZ7+2baiSeeeNj5XBAE3HPPPbjnnnuG3MZqteL555//Ss+L96v4WJL3n6W+FP8/fVbKAiSTyWRMrz8nJwe7du1CX18fsrOzWYMSAuP6+/uZXAlVGfX19cHr9WLVqlVoaWnBmDFjUFRUxKS96NnKBCzyaxWQ7lvyhB1pvHI4MCtTQoWPl3i98lgshnA4zLpDm0wmVhVKkhJ84xi+qoQHF3l5IjJq2EdkCJLKCQQCsFqtrKydCBMDAwMs5ojH42y9lsvlbI0VRZE1chXFQfkcqlglyROKa0KhEFvXpV2rqaqB77lBFWFUqk2v0znQZ3iCB4GpxAIFBkvQ+SaXQ92noZiM/P2SAsyZ8IpMsab0mTkWftoRrSCPP/44Hn/8cbS2tgIYFFa+6667MG/ePACDYus33XQTXnzxRcTjcZxyyil47LHH0sTk29vbcdVVV+HDDz+EwWDAkiVLsHz58q+tYx8Fyi+++CK6u7uRn5+PcePGYezYsRg/fjxzKsnBjsViLIg+2tbX14edO3dCJpPBYDDAbDYjKyuLZd5pouEHGgXN/GDjmQ6FhYW48sorceaZZ+L//u//8O9//xtr1qzBKaecgosvvhiVlZXsXvCD82g7s3z2Q0orBw49HHxmgNhLL774Ih599FGIoohbb70VF1xwAcvCSO+TIAwyu0gUXhRFxuJavXo1hg0bhrPPPpvpYx3ue0sncCrZp+Pyx5c+/MlkEk6nEwcOHGAsEhqLFIgYjUasXLkSTqeTaUxQGeyePXsQDodhMpk+FYx8b4eMrot0Qj4c0CcdZ0BmJ4VsKLbKUNko6W9pWezhvgf/mxa7Q+eUYtlVo9GIzs5OBINBJrpMmmT0OQCszI869tICGwwG2aKqUCiYYDJlaKk0gs6dGFYmkwlOpxOTJ09GLBZDIpGA3+9noODevXthsVhQXl4Os9mMnp4etj9iZ02ePBlTp07FqlWr8Oyzz2Lr1q3o7OxETk4Opk6dCpVKhZ6eHhgMBhQWFqKoqIixLmUyGbZu3YqBgQFYLBbWDVav10On07FGIgSQxGKxNM1bQRDSMp4ymWywTF8UMXAwi6xQKKCQyyEKg/MybR8Oh6HWqJESxU91txtq/PH3l3cgQGNBED7F1OXHGJ+M+SzQUToHZdKk/CxzOp246KKL4HA4YDabUV1djXfeeQc/+MEPAAAPPfQQYy/wPgCZXC7HG2+8gauuugrTp0+HXq/HkiVLDhugHImR00rMwf7+fkyYMAEajeZT8he8QxmLxRj4Tll5Whv8fj9zigGwzu2ki6hSqVBWVobCwkIYjUa2jcPhQH5+fpo+KD8GdToda2BH2W96NiORCOvcHQ6HWRmmy+ViHRtHjhyJ8vJyyOVylnXny3bFg+OQX4/oHvDzDY3TWCzGGpw5HA709/ezkiaz2QytVssqC4qKiuB0OmG1WrF9+3bWCZyOwx/jm7w+8c+kXC5HX18fent7GXuNumHSWCFgu7u7m2l1Wq1WlqChcVNTU4Pc3Fx8/PHHcLlcGD58OHp7e9HQ0IARI0bAaDSmNf6RBpzSoDJTuSCv4aVWq1ly9Wjb/2IcILVMCZ7u7m489thjePHFF6HT6XDRRRdh2rRpqK6uxubNm2E2m9HW1gar1Yp77rkHLpeLzSmU3PjZz34GlUqFAwcOMJaUQqGAzWZDIBBATk4Ompqa4Ha7sWvXLgQCAbZtbW0tNmzYwNg3NGatViv++Mc/4o477sBjjz2Ga6+9Fh9++CGUSiXGjRuH22+/HQ899BDWrFmDdevW4YILLoDRaMRDDz2Ea6+9FrFYDKtXr2bnU1tbi7Fjx+Ljjz/GjBkz8N5778Hv96OgoADjx49nOrV0XaRjLpOv+/bbbyMvLw85OTmfSrZ+b9/bl7VMoOLhwDf+M0NtL/XXeH9Jq9Vi5MiRyM/Px65du+BwOOB2u5GTk4P+/n6Ew2FotVrE43FoNBomeUIJfZJnaW1tRU5ODiZNmoRhw4alxb38caXnzJON+CQWrVO88fEJH5fyawy/5vDgJUnWUANGp9PJEvgkK0E+FOnS0vnQusRvA4D9LQVJ6X2K0YkEQfujOEGn08FsNkOlUrF4mS971mq1jFxgt9uZPyWTyRgDnSSYKJFI6zc1l6HrTgxJGg8Up9C8xo8Riq14IJKf3+iY9FkivUUiEYbnECtUCip+HrBcOtal43eo+FK672OBbR3RKl9UVITf/OY3GDFiBERRxD//+U+ceeaZ2L59O8aMGYMbbrgBq1atwssvvwyz2YxrrrkGP/rRj7Bu3ToAg8j3D3/4Q+Tl5WH9+vVwOBy46KKLoFQqcf/99x+VL/h5zOFwYOvWrfD5fGhqasK4ceMQDAaxfft2ZGdn44QTTsDxxx9/2FLbr9oEQWCBTltbG8tQ0mCmyayyshJVVVXMic3U/ZAGIu8YFxUV4Wc/+xnOPvtsPPvss1i5ciXee+89nHPOOVi6dClyc3OHLBE+mt+ZD9KlmSZ+8k2lUujt7cUf/vAHrFy5EqWlpbjzzjsxc+ZMdg0O5+DwDxsBB+eee25a6Se9n+nzdG78ZC3NFvHaDlKTyWSwWq0YP3582j6pK1YwGERBQQFKSkrQ2dmJ1tZWtLa2oqurC8lkEvX19WhubsbEiRO/zCX/1pt0UhWEwVLXz2uZgEEgPZsofU/6WqYM0+FAe35MZFo0Mr2e6fx4JyKZTCIUDCF+sISYWIykl0Mi0JRJJBFn0kGhbtY0P0h/aBGm5AsBEsChDF48Hmd/kz6VTDbYaEGlUiEej8PtdkMURcyZMwcff/wxGhoakEqlkJOTgzFjxmD37t0wm80QBIE1uSAGo0ajQUVFBaqrq2EymdDQ0ID169dj3LhxUKvV2LdvH0uuEECqVqsZMACAAYKkJ0POVSqVYmBALBZjAFYqlUIqGoVao4FSpWQORXIgCcXBuYIcokEtmBgUykPZXR7E5kEvupc0n6c5BaLIwEYB6To8mRyIoQDtocasdG6l8+CZmkPZX//618O+r9Fo8Oijj+LRRx8dcpvS0lK8+eabn3msIzU+OSUIApPXoIw26TEGg0EEAgHGlid2JGXOKXnHr6WUzSbWG91TKuOpqamB2WxmTj9ppmZnZ8PpdLIOjl6vlx3f7/fDZDKxMiBRHMzKk0YlbRuLxdj3ysrKQlVVFSuVpKQoOdPkoxAoBYBl6KXBSzweh8/nQ1dXF7q7u+H1emEymVBYWIiamhpWSk1lwn19fRgzZgxyc3MRjUbhdrtRV1eHqVOnIicnh/kr/L3gHedvOsggiiJ6e3tZGRlJR5AuIwAGLBUVFSEQCEAul8PlcqUxLui65+Tk4Mc//jEOHDiAtWvXslKtoqIiAGBsNyph4+dyvlSOb4DEl8mRPyeTyeDxeFBSUsKCIrKjcc3/V+MA3vg5MhAI4OWXX8Yf//hHeDwenHfeebj00ktRXFwMt9sNvV6PGTNmQKPRoLq6Gq2traivr0ckEsH555+P3t5evP322yguLkZtbS0OHDiAYDDIyqndbjeCwSAaGhpQXl6O7u5urF69mjW7HDduHKLRKHp6ephunM1mY+cqCINl17/85S8RCoXwhz/8Affddx/27duHgoICXHXVVWhubkYgEMCkSZPw8ssvo7a2FuXl5XjmmWdw4403oqysDAcOHIBCocCpp56KSy65BLfeeituuOEGiKKIxsZGfPjhh2hvb0dxcTFOOOEEWK1WNl9mAnPote7ubrz77rs49dRT06Qsvikg8/f27TZpApePxXgWIL+NlDQiXasy+dxSf1wUBxnHxx13HIvPQqEQQqEQsrKyoNVq0dXVxeS0aH2ldSIajbIqn7Vr16KjowMVFRUoKChgskB0LjyZiK+YyUSsoXPj1wq6LkPFNfz35dcgkoEhgKyvrw8Gg4El5g0GA4xGIztHo9HIqofo/Inxx5OKyCehXgZ0XDoW+e70/eg3AZ6UqKX1LxQKMYA0Go0yZiMlD61Wa5qGJPn4KtWgLBU1fqXrTfvnJXH4hpQkjSOXy5l2JMVTdK94EJJMrVansVPpPAcGBtKa1UnHHn+PyKSs0UzbHg734EHtTHHn0TRBHOrMP6dZrVY88MADOOecc2C32/H888/jnHPOAQDs378fo0ePxoYNGzBt2jS89dZbmD9/Prq7u1n28y9/+Qtuu+02uFyutIt+OAsEAjCbzcxx/6JGzsWKFStw8803s5tgt9uxePFiTJ06FePGjWOCsdJJ6GjcIH5SkzJSeNQ9Ho8jHA6jr68PBQUFaUEP/xl+v/TAkDir3+9Hd3c30xF8/PHHsXr1aowYMQK33HILYxdlYv4d7cF5uAcqmUyioaEBd9xxB7Zt24ZZs2bhjjvuQFlZGQAwqrTUIcpkUhYMPYz9/f3o7e2FxWJhJXpSMJcHLYFDGhX8vjIdl7/H0nNLpVLo7u7Gxx9/jPr6eoRCIWg0GthsNphMJuzZswcvv/wyRFHEHXfcgUsvvTQjq/KL2Ff1XB0Lo3Pdvn07YxkBB6+B7NPZH/rJxA47ElBRmuHn98nvl17nx2AmwEe678/KUvHH5p2qcDiMaCQCuWxQp83n80Emk8FoNMLpdDLWIjWY0Gg0jLVmMpkQj8ehVqvh8/mQSCRYmUhWVhba2tqgVquZ09Te3o68vDwGdOh0OkSjUbYAezwehMNh5OXlwev1Ih6Ps1IyYhN5PB7ccsstCAQCjPV26qmn4t1330UoFMK1116LF198EcXFxSgrK0NHRweeeeYZ1NbWYuLEiSgrK2PNblKpFDo6OlBXV8eCt8LCQrYNZUGtVitzkKLRKGuUo9FoEIvFGFhJWcd4PM6eb16TjZdGSCQSrEwmEosyEJdYKQBYKR3NSQRo8k4hGY2BTOA071Tz20u34//PNH6koDIwOO+EQyHUTKz5Vj3/fr+fPf8EpgUCAXR2drK52O12o6GhgWXPac4nsMxms7HyZNLjISCZHGFyVin5l0qlWOnO6NGjkZ2dzVi//DMsiiJLJMViMZZ5j8fjTAeVxgs5w+TEUoMYKp/OysqC0Whk44Yca/qbjkkOPs0NpLkUiUQQi8XgcrnQ3d2NaDTKHP7CwkLk5uayuQFAWuaeEgoEcgYCAXR1dcFkMjEfSTqe6VrwARKBuV+nSX0seg7i8TjWrVuHzZs3M5BXr9dj1qxZcLvdcDgcMJlMqK6uTist47uV0z3ny9QAsA6ue/fuhdlsxsiRI2Gz2dK6ZfJMB2KaAOkdSwcGBtg8QveYAjaTyYT8/PxPMWaOxL6oD/BtjwOklkoNdkL96KOP8Ic//AFdXV04/fTTsWjRIlYqX1FRkXGu3rBhA0455RTU1tbib3/7G1auXIlly5Zh4sSJePLJJ7F+/XrodDoYjUYIggCXy8XYzAaDAR9++CFaW1uxf/9+1uAtGAyirKwMkUgE//znP1npP/8dRFFEX18fFi1ahEQigeXLl2Pfvn2YO3cuXC4XHnroIeTm5uKCCy7AY489xgL0nTt34he/+AU++OADqNVqnHLKKRg9ejROP/10AIONQF5++WVUVVVh2LBhSCaTWLx4MZqbm1FbW4v8/HxkZWUhmUwy/TPep/nrX/+Ka6+9FjNmzMDAwADKy8txyimnsEaY/Pbf29dv35Y4gM7T4/GkMXCHStCS8QAjrZE86CQFKqWJPJqPycej5HEkEkFnZyc6OjoQDAZZIpOSoATiRaNRBriFQiFWtUbrxciRIzF69GgW0xPIR8lH4FAykZc0oe/Gr/38HMGXQdO6QZ/hE+Dk+9C6T9qNPp+PNWYhhiA1jiS5GErKks9BiVo+bpKWitP3oHtAwKVKpWJ+OR+3EY5BayydLwGcgjDISCUNbPKT6L5RNQxVbFGMwCcP6VwoMUhMR/L/6VqS5Ar5gwCY7BOAtCaHPCBJ34eut/T9THGndAyTSWPSTONdatJnhMaDKIqsvP1oPv9fOOWUTCbx8ssvIxwOY/r06di6dSv6+/tx8skns21GjRqFkpIS5nBs2LAB48aNSyu5OOWUU3DVVVexpi6ZjJg0ZFSC9FVYMpnEpk2b0gAKr9eLp59+Gv/6179w3333oba2lgmREnPmWFgmwI8fkFqtlomfS8Vih9of6buJosjE7BsbG2EymbB8+XKsW7cOf/7zn3H11Vfj3HPPxcUXX4yioiJ2bY4l45OMD5L7+/vx0Ucf4Ve/+hXLlF933XXQ6/Xo6uqCKIrMof88zgw/mQNggURTUxPrCsqDBNLPZlrgMm07lPl8Pvj9/jR6tyiKmDx5MsaOHYtQKAS3280AIbPZDJvNht7eXmzcuBEXXXTRl9JG+7abFKyTmhSI4ctfM20rBQ3IDpcp5LeVgp1DmfS8MnUUlj4D0uORsxCPxwcBjYNzQiAQQDweh16vZ3Ol3W4HABbkhEIhGI1GBIPBtDIGYkJSw41EIoEdO3awbrXEkurv74fVamXlWcR8iEQi6OnpgcvlYuXNpLfidrthNptRVFTEspxKpZI18JDJZJg8eTK8Xi9CoRCKiorg8/lQUVHBMsYbNmzA2LFjWclFKBRiQEpxcTEDTaicxW63M50dYhWRnp7BYEgrOScnLxaLsevPl+TSfaJ7nBJFqNQqpMQU+hMDrNMwHY9YdMFgELGDQZ5aPZixVSqUB5/3JCAOMnVFEYN/49NMMR7Elr6eCYjkxx/vMA81tv5XAr9UarCbZF9fH7vHxcXFKC4uZv/TdSThcn795Jll9D8xYslppXsg7YbN3w9yXkVxUOOHAnN6b2BgAMXFxYxBTA47JRWVSiUrH+JZAbQ/cpaBdIYrseB4gFkQBPj9fmzduhXJZBJ2ux0VFRVMwoXYR4Pjc3AtoUCAPh+JRFiH3nA4jGg0Co/HgylTpqSBL9IxxwdM38Qxxs/j0WgULpcLfr8fubm5cLvdsFgsiMViCIVCiEajyMvLQyAQQCQSYQ2ASCcvEolAr9dDFEUGhhOQbTKZMHXqVAwbNox1PXc4HCzoSKUGNaC0Wi0UCgU8Hg+A9KZWGo2G6esaDIY0HSpgsMGNz+dLY2gebTuWccDRMCkITRqfr7zyCt555x243W6ceeaZeOKJJxCNRpGTk4OcnJy0JDUANs9TR+qCggIsX74cZrMZU6dOxcknn4xt27bh2WefxaZNm1BZWYlRo0bB4XCwRgi0/rpcLnR0dDBQIycnB2eccQbsdjvcbjf++Mc/YsqUKViwYAFycnLSElPZ2dl46KGHsGTJEjzzzDNMF/Kqq67Cb37zG1x++eV4++238eCDD2LNmjV47rnnEI/HWdk1SRYZjUYsX74cF110EXJycvCDH/wAGzZsgFwuZ1IMGo2GBamjR49GJBJBMBhEOBzG8OHDUVtbC7/fj2effRYzZ87E3LlzoVar8fDDD2P9+vUoKirCtGnTvhHJiO/t22v8WvdZ2wwFwmRK+ksBSFrnaFvpmqbX61FZWYmcnBzU19endYCmJGdbW1tatYTBYGBVDpT43r17N9ra2jBy5EiUlpbCbDanlVbTOfLgFc+2zwSq8qAjfQZI70lAydX+/n7EYjHmM/OAIDVHI/9JurbziXM6PiX2efkVavLKVwOREWhI4Cr5J5RgE0WRkcHIHyP2Ie+v0ZxM35+kSNRqNXJzc5FKDTYV9vv9CIVCsFgszKci8gUP+vJyVBRnxONxdo2ouSRVrNA58clbvo8GcEjzUjp+pWOVZzdKY0H+tc+KOz8vaeFo2xEDj7t378b06dOZ+PjKlStRVVXFuipSd16y3Nxc9PT0AAB6enrSnA16n94bypYvX45f/epXR3qqQxp/wcPhMHbt2gXg0OTU39/PAvB9+/Zh9uzZaUyJYwW+ZQJU+GCYBwP5CWkok+5Hp9Nh4sSJ6O/vh9vtxs6dO9HX14ff/e53eP311/Haa69hzZo1uPzyyzF//nxWxiNldRwtkwI/8XgcK1aswAMPPIBUKoXbb78dP/7xj9Hf34+9e/dCFEVUVlayCeDznJ90wqSSy0mTJqUxNj7r80dyH/jvR5MjTV6Ujenr62NCxKRDQRO62WyG0+nE/v374ff7WXfY/yUA4UjsUxnODP4Hz2o93Of5DBCATwUYwGeXQdP/vJMiXTR40Jp/lvlxSMeXnqv0fJl4tcWC3t5eFsz29/ejq6uLdVg1mUzMeXA6nWlgi8FgQDweR3Z2NtMYJS2XyZMns+SP2WyGwWBguo3EAqMuuHq9Hvn5+WhsbITT6cRxxx0Hr9eL7u5uGAwGOJ1O9v1nzZqFjRs3siZOdA4jRowAAIwYMQIrVqxgWnLHH388Y4gFAgHU19ejrq6OsRkjkQjKy8sRiUSQn5/PSs4JTKR7QgAjORG0DWUnKQCl608ZXAIsU6kUEv0JpA7eB6VSCZVaxe6PTCZjHcKpZDYWicLT52FltQT00DnxWVYcdOb4jua848w7IdI5PdNYGcohl4KTRyJR8E0zkbsXubm5sNls7N7ywuBA5iyy9NknpqsgCAxMoteoPJtn95DjT88u/0zz440veQbAymuIucgfnxjENE5pbFFJ81BBkfT1eDyOtWvXwmazoaqqKs2RpxIi2v/AwADC4TB7xkhMnhJgWq0W+fn5KCoqQnV1NdOuAg7NVTzwymfxv6lGgVs0GkUwGIRCoYDdbkdLSwtycnLQ29sLt9vNGB3hcBh2u53df2KHE7vbZrOlBXbxeJwFLyaTCWPGjGHBET3jxIYNBoOIRCKMVUvPPXUWd7lccDgcjLFL15+YFw6HA2q1mp3b0fLTvo444KsiIEjnQ0oi1NXV4dFHH8Vbb70FQRBw1lln4ac//SljGxOjVco0DIfD2LFjBzZs2IDOzk709/fjhBNOYGPfYDDg+OOPx6pVq7By5Urm6+3cuRN6vR7Z2dmIRCLYv38/tFot9uzZg1QqheOOOw4XXHABSktL2XpcVFSEzs5O+Hw+3HXXXZg7dy5OP/30tORzVVUVHnvsMVx66aWw2Wyw2+3Ytm0bpk6dijvvvBO33XYbtFotrrzySqbP+dprr+Gvf/0rfvKTn+C1117DRx99hIsvvhg33HAD7r//fixYsAC33347HnnkEQiCgO3bt0OpVLK5Ydq0adi8eTOqqqpQV1eHs846CzU1Nbjnnnvg8Xhw/PHH44ILLkA4HMYHH3yACRMm4Pbbb8cTTzyB0aNHH5N44nv73zVpDMCDblLSAG/StZIHzXifnU/2kvFxOAF4Mtlg5+Wamhq43W60trbCarWira0NwWAQubm58Pl8cLvdDHwDDmn8UhVFIpHAli1b0NDQgMrKSpSVlbFk1lDJaB585H0c8lukcQUfe9D3JT3q/v5+BoiSLjWxHMmvpTWKPyeq+uNZjeQHkB9Dax/5ZdToheIWYv/zjEbyTygZSz4GNcmk/dH9o2NSE0H6vpSwJb8sOzubVX8SMYHvNB4KhVgTGr1ez9iVZHSvyG8gIDaZTDIMKSsrK03+Tco2lY5DfmzRGBwqbuXHsbRCdqjxzj8raXHzMbQjBh4rKyuxY8cO+P1+rFixAkuWLMGaNWuOxrkxW7ZsGW688Ub2fyAQQHFx8ZferygOavp0dXWxAKO0tBQ1NTWYNm0axo4di7y8PBZw8k7H0VwgU6kUotEompqaoFKpUFJSwoJUerD40r/DZXPIpBMsvUaIfl5eHqxWKwRBwLZt23DhhRdi2rRpePjhh3HnnXdi7dq1uPnmm1FaWnpMroE0Ex0KhfDEE0/g6aefRlZWFn75y1/ihBNOQEtLC3w+H/Lz81kZSDgcZhmRIz0mXROv14vNmzfDYDDghBNOGLL8h6etH+nxBEFAbm7up5xwsoGBAbS0tKCurg5qtRoDAwPo7e1lwKrT6URLSwtjs30XnTYpEEMmdRZ4YDgTQMPvL9N15J8xKdgzlNOcCfThAcPDnbM0M8n/Tc89da8moJBKN8xmM/r6+liJhEajYXopJGRcUFCAffv2IT8/H729vWwbvV7PFmK5fLAbbigUQnFxMWPdEFNQFEXs2bOHsYQdDgdqa2sRj8cxevRoVFVVsa68ubm5adpU27dvx6xZsxCLxTBlyhRUVlYilUqhs7MTI0aMgN/vh1qtRllZGf773//ixz/+MeLxOKZMmYJgMIh169axMm3aPzXg0uv10Gq1yM7Ohl6vRzweZ2W05MSQtgt13KPsJHDIWSInhUqzKWMJAKlkCkkxlVZ2QT+0De07JycHyf7BshwCFmSywY7gpO3HOyCpVArJVDLjmOLPkR/bQ427bzro81UZfUcqlf+yRveF9i0NQsjp5nUi+deA9BJZ3iHn5xK5XA69Xs/WF3L+yVEnoJECE2kJLwU9xHLkgy2ZTIZwOIzNmzez9Z262JP/QCAIABYQUFk2lX5S05hRo0YhNzcXZrOZOeY8W5S+Nz1fQ82T3yTjn5VwOAy/389kEUhHc//+/WyNpntJHTDNZjO6urqYvpVMJoPP50N2djaUSiXC4TBLGkYiEaRSKWg0GtZIi8BO8nOysrJYd2ySgqAy/GAwiFAoBLVajezsbHi9XuzYsQOiKMJqtSI3Nxd5eXnweDwsuXG0nv2vIw74KgkIPEDR2dmJP/3pT3juuefQ39+P2tpa3HnnnRgYGEBeXh6ys7MBfFo/rbe3F+FwGA0NDThw4ADq6uqwYMECPPvss5g4cSI2bNiAoqIiFBcXo7KyErNmzcIHH3zA5n4AKCkpYeuty+VisiTXXHMNLrzwQpZ4JpkFURSh1WqZZuLKlStRX1+PG2+8MU0TbfLkybj//vtx9dVX47e//S327duH3bt348orr8Sf//xnLF26FDabDYsWLcJf/vIXjB8/Hg8++CBkMhnOPfdc7NixA4888giWLl2KZDKJP//5z3C73bj44ouZZikxopLJJFatWoXS0lLo9Xrcf//9sFqtuPDCC/HRRx9h+PDhKC8vh9frRVFRESorK2EwGHDhhRfiuuuuw9///vdPSQR8b9/b5zXp2iz1yaSWaS3iE3dAOqj4qQRthpiDfx8YLBMmCYLe3l4IwmC3eofDAZlMhuHDh7PqIKrmoQQWrRNGoxHd3d0IBoPYvXs3Ro0ahXHjxrGSXzoPfu3nwUXyJTORJqRxBTH8gsEgAxUFQWAlyJTw4Zu9AGBgJ192Tu/xcyz531L/ldh+BDbyvhNf7kxgHwGD5FtTc0hev5HKo8l/onJxSi7yiTlgkGFJIDBJMMnlciYvRU0y6Xzpu1FymBKKtA+6BiqVCqlUivkA9L34cUJ+IO0nE86QaT7MFBcOFQvw65b0bz7mPBxJ4au2IwYeVSoVKioqAACTJk3CJ598gocffhgLFy5EIpGAz+dLy3b29vYiLy8PAJCXl4fNmzen7a+3t5e9N5Sp1eqjVk7a1NSEUCiEsrIy3HbbbVAoFGhtbcW2bduwfv16KBQKFBUVYfLkyaiurj4mJUPEUnA4HFCpVMjJyWEDlwbIkZTzSo0fZOTQZmVlQaVS4YQTTsCMGTOwbds2bNiwAcuWLcMbb7yBV155hekqzpgxIy1Qku77y5j0gSJw5fe//z1efvlljBw5Evfccw/kcjm2bNkCQRAwZcoUlgnh2Rz8/j7rvOh6uFwu/P3vf8e0adMwZ86cITuY8/s70kD3814juVwOu92OrKws7NixA/v370dXVxd6e3sZ7Xznzp2YMmXKd9pZSxszAGRCegnqUEAevce/zgNAmSZhfqKW7kP6tzQbKHVOMp2DdBEY6rxpgZPJZGwRDQaDUCqVaGpqwsDAAOuU6fV6GUCQlZXFzoG6spIuI+nkGI1GqFQq9Pb2oqCgAEqlEi6XC2azGe3t7cjOzoYgDJZ1FRYWsk52fX192LlzJ0aMGIGKigp4PB5W+uf3+1kgVlpairy8PLY4W61Wlrmsr69HcXExCgsLkUwmMXLkSLz99ts4cOAAY280NDRg3759sNlsKCoqQlFREcxmM3smqJENDwhRCaMoikyTkvRqyAh8JOeKWO7kUBFDie6lSqnKWKZL94UvswA3b5OzRfsiUImfZ5QqJQQIBz+XQlKSWefH6FBAOe2Tz3ZnSkDxY+/baEdr7sv0XNM1kq6/UkCSv+b0GZ4hQI49ldHSfSTwj/+hNY1Kj3jgUaVSpTUmobEqk8kY4zkWiyEej6O7uxvAYKMpEmknXTbS8qFnIBqNwmQysTlBEAQ2LxDDjsBLHiSl35nuyzd1jRKEQRF4Ym9RQy6+YR8ld4BBlgOxNERRhN1uR2dnJ6xWK4xGI3i9J0rs7tmzB5FIBHa7nXXWpOQHPaNms5mBl4IgsNIw0t81Go3o7+9HIBBAT08PSktLkZ+fj6amJsjlcjQ2NrL9+v1+BpjReXyV1//riAO+agJCMpnEBx98gFtuuQXt7e046aSTcO2116K/vx+jRo1Km8PJRHFQ66y7uxtbtmyB2+1Gd3c3RFHEmWeeiRdffBHr1q3DxIkT0dzczNbwqqoqnH766QywoyRWX18fAoEAUqkUvF4vysvLcd9990Gr1cJoNKKwsPCNo2EAAQAASURBVDCNySyTyZCVlYXp06dDp9PhlFNOwVNPPYXjjjsOtbW1acmHU045BYsXL8by5cvx2GOPYcWKFXj33Xcxe/ZsLF68GL/5zW9QUVGB4447Dtdddx1GjBiBW2+9FfX19aiursa7776LV199FRdffDFKS0vxi1/8Ah9//DHGjBmD8847DzU1NRgxYgTcbje6urpQV1cHhUKBv/3tb9i1axeGDRuG/Px85OXloa6uDueccw4SiQSMRiP+85//4KmnnkJDQwOeeOIJ/PKXv/zC9/F7+26blGQgrSCibfjfmZJiUp9byjo7HGGB99N5P0utVqO0tBTZ2dms6iccDqOpqQk2mw2jRo1CS0sLW2ddLheAQf/C4/FAp9NBr9fD7/fjo48+wieffILTTjuNNVCkcmDSN+Q7LZOfIJVNkZ4jsfOIdU/AG50/HYMIL6KYXh1EyXm6RtTRm/eH+Ioe+ozU5yQAkY7Bnz8xI+kYdDzyRfiSazou3ROSlqN7SY0FqdKE1mjSgicAtq+vj63vxJ4MBoOs6R5PSPP7/ejv74dWq2UAKukx072he8KPO/qu5IPQPqQ+1FAAOr3H+/mHM6nPzz8v0v0eTfvSbcWoBHbSpElQKpV4//33sWDBAgDAgQMH0N7ejunTpwMApk+fjl//+tdwOp2sPPTdd9+FyWRCVVXVlz2VIzZRFHHgwAEkk0m0tbVh2bJlCIfDAICCggJMnDgRM2fORE1NDQoKCo5ZFzaia5NOjhT4OhzL6khNoVDA6/UikUhAq9UyLYSJEyciLy8PXV1dWLhwIUaNGoUHH3wQP/vZz3DJJZfg4osvZpn5r9r4QM3pdOK+++7DO++8g6lTp+K2227D2rVr0djYiOuuuw4FBQXw+/0QRREGgwF6vZ7pLxyJkbNmMBhw5ZVXwmAwpAVRR8OkCyPPoKFJQaPRYNq0aZg5cyZbIFwuFx5//HG89tpr+OSTT7BkyZLPLcj+v24CDi1MvDMCHJ5RONRzlCmrKX1tqOwTnxWVLgqZnBjeMciUmZQe0+/3AwDTau3u6oKnzwOHw4Hhw4fD5/PB4/EgLy8P7e3tMJlMyM3NTQMmqBSBmk719/dDr9dDqVSisbERqVQKY8eOhd/vZ1plTU1N7FyMRiNycnIQDoeRn58Pn8+H3bt3s47WpHfocrmYBmssFkNhYSGi0SiKioqYDuTOnTuhVCrR3NzMwBFKvLS1tSGRSMBms8HlckGhULCGGMQgsVgsrCyEnBu6tgQikvYrAT8EeNL1JxaHQqFgzhMBkcChkpj+gX7IBcWnFn96nwBPAhpTyRRkgsDmJ8oyk5YbjVli7NF8QGUePOONjkUg02eBj9/b0Te61nSfPms+IUeUNKP5Tsb0NzF1aa4isI8vweWDCto3lQT39/cjJyeHddYOhUKMyUv7o7HEH5/KyIkxTIEFJfQogKDzOdrr5NE2ehZdLhcGBgZgMpkQiUQYY4G0ZA0GAxQKBQPUKPhIJpNs7hsYGEB2djYsFgsikQii0SgcDgd0Oh1yc3PZNackBpVhk/Y26TzK5XKEQiEAh5rl8fdepVLB4XCgtLQU1dXV2LdvH1QqFfbu3cuaHGm1WlYpc7TtWMQBXyUBIRaL4W9/+xvuv/9+mEwm/O1vf0NRURHGjBnDxjq/BouiiFAoBKfTib1792L37t1wOBwoKirC7Nmz0dDQgPvuuw9z5sxBeXk5otEoS8gJgoCcnBxMnjwZ06dPxwcffACv1wtRFJGVlYVAIIC+vj6MHDkSf/vb31BeXs7WTj4RCoBpKNbU1CCZTMJsNuOpp57Cf/7zH8yePTtte6VSiZtuugm7du3CHXfcgWuuuQaPPfYYBEHAueeeC6fTiZtvvhnPP/88ioqKMH/+fOTn5+Pmm2+GwWDArFmzsG7dOlgsFowfPx6vv/46/vWvf2HdunV46qmnIJfLWXM6Sm4QUHvZZZdh8+bNmDNnDv79738jKyuLNcKcPXs2XnvtNaxevRo333wz7rzzTuzYsQOTJk36Su5tJuP9sCMJsg8HWPH2/Vr79RmtYTyLjAfC+CoBqQ8/lO/Eg5dDHVNKUuB9dUoQ83FlRUUF+vr6WLPH9vZ2eL1eWCwW5OTkoLu7G0ajEbFYjAFgPp8P4XAYer0eNpsNsVgMb775JiZMmIDRo0ezOFUKgtI6zpeCS3/Ts0q+v9PpZPM4+cUkCTQwMIBoNMoaYvFJeGI7UmUiyRHxTVN4vUadTsfWNDpfHgCjhA/dz1QqxXQfab3ltxdFka0LUjCPQFk+0U/gI73ONycVxcFy7OzsbJjNZni9XqZnazaboVKp0NnZiby8PEZwkMlkaR2uATCfncgPdD35eyIlLEmT0vw4lcrbZYplM41N6WtS9iv/m9/30bYjQtKWLVuGefPmoaSkBMFgEM8//zxWr16Nd955B2azGZdeeiluvPFGWK1WmEwmXHvttZg+fTqmTZsGAJg7dy6qqqqwePFi/O53v0NPTw/uuOMOXH311ce0QQZdXBKSBsAczHnz5qG0tBTDhg3DrFmzWAfBY+lYZ5rwjhZ7QC6Xs8x1b28v/vKXv6C9vR0jRozAD3/4Q9TU1KCvrw/t7e0QBAE+nw9/+tOfsGnTJixbtgxjxoxJC0a+CiPHvK2tDXfddRfWrVuHefPm4cc//jEeffRRjBkzBnfffTcEQcBLL73EMr/ECuWDO5rwPs+5Easj04N7tB2OZDKJvr4+1NfXo7u7G6FQCB6PhzHJqIsXZZDq6uogCAIOHDiAUCh0TAXlv2mWNoFmAOX5LKYUCPws54Lfj/S9oSbuw+2L307qsPAAwuEYKiQnQOAhaYwEAkEGJO7atQsKhQJjxoxBRUUFotEo9u/fz7qohkIhFvgQICGXy2GxWFgwPGHCBPT29qKhoQE5OTlwOp0Ih8MYO3Ystm7dij179qC6uhqiKDKwsqCgAJWVlUgkEvD7/axsRBRFlJaWQqlUYvPmzSgqKkJubi7Gjh3LOub29/dj8uTJqK+vx7vvvova2lqo1WpUVVUxsWvqDqhUKmEwGFhXQCppsFqtzHETxUH9LbqWBArRdyfNLl6/l/RdEokEIpHIpyQtkskk5DIZVMpDGVsCJcnBIgCSnteBgQEIEJBMpViARuXdJSUl7FhU5kGOMnUgJyCJ9ssnKYYaj9Ksdqb3M43H7+3w9nky0J/n8xQYSZmTfIduGpPSv4mNS+MuE5NBJpMx4AkY1NCjpCoB9RSgUTMpMnqd1hq+syYvrj4U4PhtGUf8HEzzqFKphN1uR2NjI2QyGUvuCILAkjjEVuODXUp4hMNh9Pb2Moai2WxGT08P6/5JrHQqASN2CN1f0qWlsmqDwcDuTSwWg0KhgMlkYk29nE4nCgsLMWzYMOzYsQOBQABtbW2MpU6M9a/ynnzb44BUKoUnn3wS9957L5YsWYKlS5dCFEWMHDmS3Rt6lmgdI6Bx7969jAHzk5/8BLt27cITTzwBpVKJBx98ENOnT8eSJUtw4MABFBQUsISYIAxqqk+bNg2rV6+G3W5nTWQCgQAmTZqExx57DJWVlWmNpERRRHd3N7Kzs6FSqdDa2oqcnBwMDAygp6cHGzduhMViwbp167B161bo9XqUlZWxcWS1WvG73/0OZ511Fv71r3+huroaO3bswLRp03DZZZdhzZo1uOWWW/DEE0/AbDZj8uTJ+Mc//oG7774bixYtQlNTE9avX4+uri5cdNFFuO++++BwOHDDDTegvr4eGo0GBw4cQGlpKc455xzMnTsXra2teOmll7Bv3z5MnDgRBoMBBoMBHo+Hfa+pU6fivffeQ01NDX7605/innvuwRNPPIGcnJzD+j5fhR1JspkHN6T2bZnn/teNT9bzvj4PtEnvHz8GaA6XJvB4QDOTfyQlC0jHFX2WB7ysVissFgt8Ph/sdjtaW1vR29uLlpYWFBQUIC8vDy0tLWhvb4der2eN5Xw+H4LBIEwmE1QqFTZu3IjOzk5UVlYiLy+PdW/mmY/8OfLxOV0XOl/ScSYNXZqv6LPENCTwjF83ee1CAt1oLRsYGGCMSZpXeakZadl6NBpNS7rz15svpeZfp3tNSUK637x/xVegAIOl1fF4nOlZEyuR1kk+XsjJyUFWVhZcLhecTicsFgvKysoQi8Xg9XrZ3EZNAhOJBCM3UDxB0jXUwDKZTCIYDDJJF6pioc/Qfuj68ut3pmsw1HzJj00yKlGXAu+Ztj2adkTAo9PpxEUXXQSHwwGz2Yzq6mq88847+MEPfgAAeOihhyCTybBgwQLE43GccsopeOyxx9jn5XI53njjDVx11VWYPn069Ho9lixZgnvuueer/VafYXzA2NHRwW6aRqNBc3MzjEYjTjjhBPT39zOx7sLCwv+5hUYQBJZVsdvtyMvLw89//nNs374d//73v/GTn/wEM2fOxIUXXojFixfD4/HgjTfeQCKRwPr163HZZZfhZz/7Gc4+++xPlSQf6bWSAkL19fX4+c9/jj179qCsrAx2ux2/+93vcPnll2PmzJmsc+/06dOZ/hxwSB+ThPkpcP881yKTQ3Ks7rlcLofNZmOOFwDm+Ho8HnR2dsLr9aKvrw8dHR3YtGkTgMFnsru7G1ar9Zic5zfOBAHiwVskQgREEXxzGVokafGh+0n/84G/1HmQOiD8NlKwUKrdwS/OvNMizaDTtp/+Wumfp33TQu3p88BiMUOpUECr1aG3pwddnZ2Ix+NIpVLYtm0bJkyYAI1Gg66uLpSVlTH9GCpbiMViyM/Ph8vlYqWDVKoXi8VYd3gq/8jNzUVbWxt27NiByspKtLW14cCBAxg3bhySySR6e3uh1+uhUChYhtbpdKKtrQ12ux1qtZppUtbX12PWrFkoLy9HQ0MD/H4/NBoNcnNzkUgk8NZbb8FkMuG4447DpEmT0Nrayrq9qlQqVFZWQqfTsQ6agiCgt7d3sMnOwXJyYnLR34IgsHMgB4VnSPKO5sDAAGOj8Q0+ACA1kEQqmYRCqUgrx+FFsOm+8WUWKYhQadRQqlRI9CcQS8QRjcegUqqgPdhRmD5LoAQxImVy+aCjolRCoVRAIVcAlMUUD4pVpw6NrWQqCdlBNhrvhPJjiB+HmTKn39vQdrQDY3Keh5JU4ecPuq88QMmX/fOgJSUYKKHKl0jzzieBa3wgo1armR7SUOvlt8H4oIp+eEZ3dnY2Dhw4wAI+Sqx4PIPNoaLRKHw+H4qLi9Pmc2KAGQwGBAIBOBwONq/SXMI3pKFGWcQYE0WRaVHJ5XLk5OTAYDCwuUWpVDImtUKhgNFoZAFpVlYWKisr8fHHH6O9vR1WqxVKpRIej4d1Pv6q7NseB4iiiMbGRhiNRlxyySWoqKhgADu9n0qlsH//fuzdu5c1fKEmZ9OnT0dfXx+WLVsGl8uFyy+/HAsXLmTgMukV9vf3M3YMgQJVVVXQarWsCVx/fz8qKytx2223oaioCB999BFKSkpYwxmdTsc6refl5TFmriiK+Oc//4lgMIj29nY0NjbirLPOgtFoxPDhw7Fw4UL86Ec/gsFgwMiRI/HTn/4Uv/jFL5Cbm4vW1lY89dRTuOKKK/CHP/wBF154If7whz/gjjvugEKhQHl5OX7961/jzjvvREVFBf773/8iFAph+fLlOOecc1BUVISLL74YN998M4YPH45hw4YhHo9j3bp16OzsxEUXXYTbbrsNjz32GFKpFE444QSo1Wps2rQJM2fORGVlJSZOnIg777wTM2fOxFVXXYWamhr8/ve/x7333vsp3eMvcn+l/8diMbS2tsLj8TCJGHq2eN+M/qfmWg6HA83NzQzkz8vLQ2FhIQOQKOEqBQN4+7bNj9824/1kHnTkfXE+puL9cX473vhqJdou03F5P50/XqbtaJ9KpRLZ2dnIyspCQUEB3G432tvb0dnZiUgkAovFgmnTpqGrq4s1KCkpKYHX62X+M5Vsb926FWazGYWFhRg+fDhLwvPgZ6a4hmc++nw+9PX1sQRkLBZjerG8H0sAKlUEEQuf/gfAfAMCGan5GB2flyih86FkPX8c3qi/Ac+C5JP8wKfjMjLef+LZh1Ql1t/fD7/fz9ZlKgGnc1MqlVCpVCgoKGCNgXp7e5ksSjweh8vlYjIr1CiW4goiDITDYfbdqboBGGSwe71e5jtQE5tUarA7dzweRyQSSUsi8+CjdOwebq6Rgo2ZAMdjNVcdEfD417/+9bDvazQaPProo3j00UeH3Ka0tBRvvvnmkRz2qJggCIhGoyywKy4uxplnnomamhoEAgG8/fbbiMfjGD58OGbOnHlMz+tYHoeEymkC6OnpwfDhw7F8+XJs2rSJOSi1tbVYtGgRxo4di0cffRR9fX3o7e3Fr371K2zbtg3XXXcdioqKPhXEHIlRuVddXR2WLVuGffv24eSTT4bD4cCrr76K5cuXo6qqCi+++CJOOeUUDBs2jH2XgYEBuFwurF69GkqlErW1tazc8/Oex9fhIPDH5MsD6IcyJt3d3WhoaEBnZye6urrYBBmLxdDV1YWqqqovpfv5rbUMt0yageRf5x0OafAuXaBp7Ei3lY4TnhHNa8IMdU6fBfDwzhM9l/x7wUAACrkcbpcbRqMRalUSsehgwOr3+zEwMIBRo0axxc/pdKK5uRkjRozAzp07EY1GMXLkSIjiYMmByWRiga3X62UNWogdmZubC7/fj6ysLBgMBjQ1NWHNmjXIz8+HUqnE1q1bUVBQgOzsbCQSCWzbtg0jRoxgjJi+vj4YDAZkZ2cz/ZT29naW8Ojo6GBMIK1WC5VKhRkzZmDnzp2Qy+WYO3cu5HI58vLy2HccMWJEWrlGJBJBaWkpW9CpuRTJR/ClYGTUIIJYojqdjpVoC4KAQCAAjUYDk8nEAJxEIgGIItQaDSATPqWhQ2xFum88Y4KNP+FQ9pg0/FKpFBvKcvlgtz6LxQJRHGRt+nw+BPx+5hwScEQOIHAQeKfxKJdDJpd9KgvMO+BSx/xYZTu/t0P2Ra+5dA7KJAOTKQCnHx6o5F+j8ULPEY0vCjI+Kxg7ku90uAz70QZ26TclGYhpXF5ezhx86lC9Z88ejBs3jj3TvJh/f38/C9L4uZ8kFfx+P+LxOAKBACtVp+CNrrtGo2HAriiKrKSY1gGaX3gZhng8zmQoPB4PsrKyYLfbMX78eOzatQt9fX2wWCwsqKJKjq/i2v4vxAHHHXcc/vWvf2Hx4sVYtmwZ5syZwxLU1NixsbERra2tKCoqQkVFBYqLi9HV1YVHH30ULS0tOOuss3DeeechLy8v7fmrrq7Gq6++ih/84AfYv38/Jk2aBEEQUFZWBqfTiZEjR2L79u0AAIvFgtNOOw2CIODNN99EJBLB5s2bMXbsWNTU1GDjxo2sVFOlUsFgMGD37t2Ix+N47bXX4PV6kUwmcdpppzEdeo/Hg1deeQUbN27EsmXLUFhYiPPOOw8vvPAC3nrrLcyfPx9bt27Fhg0bMH78eNx999246667UFRUhEsuuYTp2l9//fX4wx/+gPPOOw8vvvgiRFFEcXExDAYDCgoKcN111+Hee+9FeXk5gMFGOUVFRXj++efh9/tRVlaGjRs34pRTTsHu3bsxY8YMdn3HjRuHsrIyNDQ0oLm5GVdddRWuueYabN68GdOnT//Ssla0Vm/ZsgUbN25Ed3c33G43azwJDDZIikaj0Gg08Hq9rEu6TqfDgQMHWOWRXC5HYWEhmy8osQoANpsNU6ZMwYwZM1gy9Kus/vrePp9JgUK+7Jp+8+xF6Vwo/XwmsI72If2bPk/H5RPe0oQunRdVxMjlctZgihiQgUAAnZ2d0Ov1GDNmDFpbWxGNRmEwGBj7jprREIMuEAigu7sbJSUl0Gg0rLqBgE4C81QqFdRqdVo1oNfrZYy87OxsiKLItBP5NYgAQ41GwxJg9J14eTDSWSf/NhQKMX+c1lA+QU9rG10T2gcPKvINg+i6CoLAmq9JrzddW9onHSMej7PEHvnp1FCHvzdSLcZUarBpjd1uZ9r4xOSk0vFwOMwa19B9of0Q25GP7YDBChetVotoNMqqUMjXogY3BJDSXMXHsfzY48fuUEA5LwXEg5b8tT4Wc9exES38hlooFEIwGGQD+OOPP8bmzZsxY8YMzJ07F+Xl5cwB/F9dSAjVBw5NUu+//z5qamowadIk1NTUYO3atfj73/+OK6+8EnPnzsX111+PF154Afv27UN/fz9effVV7N27F7fffjtmzJiRlt35vEaL+rZt23DbbbehubkZALB69Wr09/djxowZeP/99+F2u7FkyRK2wJMOpM/ng9vtRnV1NUaMGMHoy98WG2p8Ee169OjRrGSWuqP95je/QTAYRGtr6//s+PwsywQu8r+lr/OOgvQ16ef4CV664PGvS7NOvP4eD2DyzDPe+ckEEPBZVF6LRS6XIxKNshIH0mYl4eO+vj7IZDLWCMLv9zP2RSAQgE6nQ319PbKyslBUVITu7m5W4heLxdDf34/6+npUVVXBZDIxoWm5XA632w2tVovRo0fDbrdDEAYbIPh8Ptb0KCcnB8OHD0dfXx9bUMPhMPbv34/x48ejrKwMoVAIfr8fjY2NsFgssNls8Pv9bHEn3ZqGhgZs2LABo0ePRjQahVarRWtrKxN6LioqQktLC8sidnZ2slJEtVoNs9nMFmqr1YpIJMLASrp/1Kmbyrg1Gg0ikQgru+Q7+sViMeYMJJNJKOTpnX2p4Q+f3RVFMc2h4sHGNN1GjpHLa9uQo5ednY1UKsUyoIFAgOm4ERjBO8symQwqjZrpZPLjTOpcfFfnjq/bpPdDOh9IHUzePk+Weqg58POcF809UpmZr3KsfJ1AN30/SkpQh8rS0lKm7xoOh2EymSCTDXaqFgSBSTuoVKq0YIuAff7ZJd+KnlEK0Ki5CM0BPp+PBWK0HZXZUZBGbBO6H0qlkgWjVBWRl5eH/Px8tLe3s4oPlUoFt9sNAEwz8FgFF980o/HW3NyMhx56CNOnT4fBYMCyZcuQnZ2NRYsWYeHChWhvb8fAwABKSkogk8lQVlaGd955BytWrIBGo8FFF12E3//+97DZbBmZUSNHjsSuXbtw1llnobOzk70nk8kwZswY1NbWYvv27RAEAfPnz0dvby/+7//+D8lkEqWlpXC73XC5XDAajdi/fz8aGxuxePFibN++HWq1Gh0dHWhoaEBrayvmzp2Ln/70p6ivr0dBQQG0Wi0mTpyIiooK1NXVYenSpbjllltQW1uLZcuWYenSpWhtbcWIESPw/vvvY8KECTj33HPR3d2Ne++9Fzk5OZg/fz7kcjmqq6uxaNEifPDBB7jooovw2muvYe3atcjJycHIkSMxdepUnHrqqcjJyUFNTQ2ee+45NDY2oqamBn6/Hzt37sTevXtx6qmnIhKJwOv1orm5GcXFxdizZw9qa2vxwQcf4B//+Aeuvvpq/OpXv8Kf//xnVFdXw2w2HzFQzt+HhoYGPP3001Cr1bjgggtQXFzMkvUOhwOxWAxr167F73//ewb8arValJSUwGKxYOLEiYwVKZPJUF5eji1btkCv16OiogJtbW0oLS1Fa2srnnnmGTz88MMoLCzE+eefjx//+MdpFUjHmk30XTMpYEi/peuq9H1a34DMayXv1w9FGOCPwfvs0u35Y/E+PR3LbDbDbDYjOzsbzc3NcDgcaGtrQywWgyAMNi+h5FF2djY02kE/NRKOIBQKwW63IxaLwe12s8Yz5K/S+qRUqjDQP4B4LI6B5ABrgEad6RUKBdxuN2w2G6LRKOQHq2wo1qbzBsAkiWiNIgxBLpdDr9czKShiPRJwSKXDvDwRz8Cka0gxBw+QSgFd8sOBQ3rV9Hnall/rqKyZGq/RtkqlErFYjN0bg8HAEgy830771Wq10Gg0SCQSCAQCrGs1aTrG43HWtIb2w8drPKuSvqter2fHIMCStiGGJvkbQ/mHn2d+kfqZmWLgY2HfWeBRFEXWyYkC9fPPPx9TpkyBzWZLC06PluP9TTPKvixatAjxeBx+vx/bt2+HTqfDI488go8++gj/+Mc/8N5776GsrIyVZKZSKezbtw/XXHMNfvKTn2Dx4sVsweYfJqI6A2COOmUBkskkPv74Y9x5553o7Oxk15k6dtbV1eGEE07AqaeeyhzxvXv3YtOmTbBarZg9ezaqqqq+1ZpTUhNFEV6vF3V1dQiFQgwc8Xq9rENaMBhER0fH132q30jjQcKhwD3+f+n70jJd4FBAKd2WX6B4gIl3LqTOEP8abZPpO5B4s1qtRiKRGAQXIbCyPxKyp4W4v78foVCIfS47O5s5EPF4HHq9Hu3t7VAoFCgoKEAqlWLMCeqEum3bNpSXl7PnmADBQCAA/0HmXWdnJ/x+PwMCCwsLWaMY6myaSCRYCZlKpcKcOXMgiiIKCgowMDCAPXv2ID8/H8OGDWOl2+FwGBUVFRg5ciQ8Hg/27duHkSNHoqmpiemzeL1elJSUoLi4GA6HI+066XQ6xiIKBoOszA0YZFvQPaVmTUajkTV8iUQikMlksNls6Ovrg9frZaAfZVap/EIUDjlttH+az1KpQ92KCZjMtMiTI5cCAPEQaEH7onmSHBGVSsUcUGJx0vfhRbRTosgADhpHOp0uTbNSymD73r4e48cF3xWbHHdpkCL93NE6nyNJ3B1uHGWaW/n593AA69E0nu2oUCiQSCRgNpsZy7O7uzuNpaBQKJhmLfkgPDBL908aPPDfXyaTQa/XM4ajzWZjSQTqUM7rUmWqgqAfYlFYrVZ0dXWxkqzi4mJ0d3cjEonAYDCgv78fPT09sFgssFgsbJ4g+7b6R1/UGhoaMGXKFFx44YX4xS9+gZNPPhmrVq3CHXfcgRdeeAFLly7F8OHDoVarsW7dOixfvhz5+fm4/fbbcdJJJzEwmkx6/SoqKmA2m7Fx40bodDpWVQAAdXV1mDVrFh5//HGYTCbYbDY0NTVhz549yM7OxsDAANra2lBVVYX169dj//79aG1txbZt21BfXw8AaG1txZYtW3DDDTdg5syZ8Hq9mDJlCgMbSb9s7NixOP/887F8+XI4HA4sWLAAixcvxrPPPou5c+fi3//+N5577jlcccUVmDhxImbPno1bb70VhYWFmDx5MmQyGebOnYvt27dDo9HgxBNPxJtvvomtW7di6tSp0Gg0mDt3Lh5++GFcfvnlOPXUU7F+/Xr897//hdfrRWlpKRobG7F582YUFBSwyohhw4bhhBNOQDKZxMqVK1FXV4eXX34ZS5cuxdixY/HCCy/g8ssv/0KED1EcrBD45S9/idraWpSWlqKiooJJSoiiiJycHAQCAcycORMdHR3w+Xy4//770dvbi0AgALvdju3btzONVnrWxo8fj7a2NiSTSdhsNjQ3N6O0tBRLly7FBRdcgBdeeAF33XUXXn75ZSxfvhw1NTVsnHwvY3L0bKg1MVNyjve9eTYc/ea3o/mbf086nwNIm+/pf9q3FJDk4wge2KTXLRYLqqqqUFBQAJVKhaamJjgcDrZGpVIpCDJApVIilVRDpVTB6/WyBqvk25PcA/m5yWQSEAWolWrEYwmoNErk5OSw3gHEHKRYgJiPFE8Q+EXrGw+qGY1GlnjnJZvoO1KjNCJxkY/Dy1RJ2aM8Y5A00Qkv4D/Ps1hlMhkryebBR76xEMVQxPCke0XkDIoX+O7UvAQHH9dRdVY0GkVfXx8jRxBIKAgCk06h40j7UPDfn66ndKyQEWDJj8MjYSpKt+HnJKlPdrTtOws8CoLAaPc6nQ4//OEPsXv3bjQ3N2PRokWM0UMB5f+qc5YJRKEHT61WY9q0aXjrrbfw1ltvoaamBvfffz9WrFiBFStWMDFZ2k8gEMBDDz2EnTt3YsmSJcjOzkZ7ezvq6urQ0NAAh8PBaM2UTbFYLCgoKEAoFMInn3zC9OT4DIMoijCZTNi4cSOmTJmCnp4efPjhhygsLMQZZ5yBsrKyb73QPW/8BJyfn4+8vDwIwqC4fV1dHURRZGWjr7zyCsvQf9c7W2fKWg4F5gGH11uUlqFmCvzpfx4Y4I9Ljghfsp1pf4c7TwK1qHSoqakJLc3NUMgVTBNUEAabIpWWliI3Nxe7du1CMBhksgUWiwWVlZWQy+UoKytj3aWbmpqYyDEFo3K5HAUFBayjG3XaSyQSrPyaspYejwfNzc2s/JcWTo1Gg/z8fKZrQsd3Op1wOp3QarVMg6y7uxtdXV3Izs5GcXExtmzZgkgkgsLCQlRUVDBmx9ixYxEKhRhQSGAgzQ3EmKTFnjRTiWHk8/mYADexl7RaLYBBcW3qJkvXIRqNwmQyMZ0WlUoFi8WCcDjMssFy5eDyGYvFWOMHclh4FiLdR+n44bPqAgTIDo4jKYDBA5s8w4oAYT5LDACpg9v0D/SzbGsikWCOJQ84ZgLAv7djawQW0z2gH54xSz/fFuPLjjNpTvHyBEB6qfixWLPpmpMmLgG8ZrMZfX197LkbGBiA0Whk3YdJPzqVGmwUQ9qNgiCwci16pmjepwQCbUevUQdtaq4V5Zjs/PrDs2X4ffB/E2vbYDCgpKQEnZ2djC1DwVgwGEQ0GmU6lN+mipCvykRRRH5+Pvx+PyZNmoTf/va3eOedd3D77bfDZDIhFArhww8/xJ///GcIgoArrrgCl1xyCcrLyz/VXCHTvgHAbrdj3Lhx+OSTT1BTU4P33nsPZ511FmQyGUpKSuD3+5mcyc6dO1mCrrOzE3K5HAaDga2VGzZsgM1mw/79+9HS0oJAIIC9e/fipptuwo033ohPPvkEJ5xwAksQTpgwgc3nfr8fzc3NWLZsGf74xz+ip6cHP/nJT/Dqq6/ijTfeQEVFBT7++GNMmDAB5eXlWLx4MTZv3owbb7wRr7zyCmuic/nll+PnP/85zjzzTHzyySd47733cPLJJ2Ps2LGorKzEnDlz8MADD+Dhhx/G3LlzcdJJJ2H79u34z3/+g4kTJ2Lv3r046aSTsGPHDtZQoa6ujkmjzJkzB5FIBDt27MCZZ56JW265BaeddhqKi4u/0P0l/8fj8SCZTGLy5MlpzRdJt1qn02HmzJlYvHgxamtrcfrppyMWi0GpVGLOnDkMBKCkntFoRH5+PoDBajmKb8xmM/r7+3HzzTdj8uTJePDBB/GjH/0IP/3pT3HNNdewOeJwCebv7cub1HcH0v0lKTkgk9QMHxtI2W70Or9vHvgCMmsq0m+p70+f5X0yURTZXB4IBBAIBNg2bW1tDLhSqpSw2+zQqNUoyC9AMplCMjmArq4uyGRyKOQKyOWDa+qg3yuDIAByhRwQBn0KSlDw2o3UKCUcDiM3NxcqlYqthTKZjBGyyJektYX3Lcm3JnkRAvBID5LIR8RipGNI4yi+qR35t3xiHwADJvnyZFq36TqS/01Ao0ajQTAYhFarZUAmNXChsnX6n9d258cWf98p3iG9R4rNqSSdjkENJLOysljzSwBpvhAf+/O+ID8G+fGeKXbNNJ75MSsdw2THMjny7fFkj4JRIKvVarFt2zacdtppkMlkeP755zFt2jRMnTr16z7Fr8XIKZfJZDCZTJg/fz4mT56MFStW4KmnnkIymWTsKenAHhgYwIcffohNmzYx2rG0xBRID0ZosiBNOWIV8A8SdZO84447cPzxx+OKK65ARUXFp1B7Err9tjvVlLl1OByMPTUwMMAYkHv37sXWrVshiiKcTiejcH9vny635p0A3gHgx9hQYKA0oyTNotICNNTn+QVA+iM9x6HAH34xcjgc6OjoRJbFAqPRyNgzDocDPT098Pv9+OCDDxizkcCLwsJCOBwOaLVajBkzBvv27YPT6UQ8HkdFRQV7bjo7O5nuSEVFBcukCoIAvV6fFhxPnDgRxcXF6O3tRXd3N4LBIOrr62E2m5GbmwuDwYB4PI7u7m5MmjQJXq8X+/fvx8iRI2EwGKDRaFBQUICuri7U19dj7ty5sFgsqKurg9VqxZw5c6BWqxlrR6VSob6+HkVFRSgpKWHMA3o2YrEYc8yam5sRCAQY+OjxeFgTBqvVimAwCLfbDbvdDq1Wy0otKcNJeipKpZKVpFA5hlKpRF9fH/RGAwNjE4kE4vE4gsEggMHOeXT/+eQVAUqCIDBnienspQ6NgUQiwRoAUcbZYDCkARPklIXDYaaJI5fLoVAqoNXpICQFBqwQWMyPMelz8T0r4+jY4QBdcpJ5gXXK3PMZdqng+tEsgf68lul7SXWfeMaElB1I2/FjktgXX8V3O5yjToESVVTEYjE2X/IBhdvtZmyPrKws9Pf3IxwOw2azMd+RgFTgEJOaDzKlrEX6vtT1ky/tJuYFAJagpcAFAAvOKACiuSUrKwtutxvJZBJ6vZ5pP+bn5zPAjL63z+djACQFY98VMEQQBFRUVMDn86GxsRErV65ETk4ORo0ahcLCQiQSCRx33HF488038cYbb2Dp0qVMz+/zmlwux4wZM7Bp0ybYbLa0bvLZ2dmorKxEfn4+Ojs70dPTA5fLxYJSYkhSooHK/latWgUA8Pl8uOKKK3DttddCEATMmDEjrZySl9XIyspicinnnXcefvOb32Dr1q0Ih8PYuXMnJk+ejN27d+OVV17B5ZdfjtLSUjzwwAO49NJL8eijj+IXv/gFFAoF7HY7TjvtNLz//vv42c9+hjvuuANr165FLBbD+PHjceWVV+Kss87Cxx9/jNraWqhUKkyZMgU1NTVYv349li9fDgA46aST0NXVBa/Xi5EjRyKRSKCkpAR/+tOfcOGFF6KtrQ1+vx+nn346XnvtNVx11VWfAiM+z/11Op0oLS1lRIXGxkZMmTKFbSOTyTBixAisWrUK+fn5qKiowDPPPINTTz0VWq2WAY20P37fdG2p86/NZmNz9Z49e3DSSSfhuOOOw913343f/va38Pl8+OUvfwmdTvedecaOtfHsL17DkZ9r6YeXw5CW40r9dNr3UPECHRM4lCDi1zH+vUzxAA98SoGnkpISmEwmKJVKJo0kk8ngdrsH40CPF35vAEqFElarFVqtFlqdFqUlgzqyzl4Xa6za6mlFcXExbDYdIIiIJ+KIxqJs7VOr1YjH4ohEomlNY8gvUalUaesEfS8qtSb/m2+ARiXJgiCkAYM8FkDXib92FMfyJdTUXIb/nFKpZOssGa2dPMORfCk+3qKqKYqrab80HhKJBPx+P0wmE6uc4vfJa7iT0XytVqvZXM4nKQEw4sPAwAC6u7uh0WhgNBrTmLfSsSYFE6VxYyZQXLoNP44/y47VHPWdBh4pqJPJZAgEAnjkkUcwZswYnHXWWRg/fvy3Hrz6MkaTR1NTE/7v//4PZWVlqKmpQWVlJV566SV0dXUB+LTGBU1clKnhHwxiblHnrUAgkJaJoklHp9MxoVWy/fv3I5lM4rLLLsO5556LwsJCFjg4nU6YzWZYLJav41IdFeMDlra2NnR0dKCnpwfBYDBNCNjhcKCvrw/hcJhlVr9rJnUGaMGRgoz8Qi8FEenz0m2kiy2/LW3PT/y0IEmzrvR/psypNMjmSy3pHCjrONj5LoyiwkKUlpbCaDSiqakJdXV16OnpYV04w+Ewa8ACAC+//DJqamoQj8dhNBoxYsQI1jTCZDKlJRL6+/uRSCRYubbL5WIix2azmTU8GhgYgN1uR1FREUaPHg2Px4Pe3l7s3LkTM2fOhMViQUlJCTweD1paWnDSSScxHRkSax8+fDiUSiWcTieamppQU1ODnp4e1uGPwE+v14usrCy0tLRg1KhRsNvt8Hq9EEWRNXLw+XzsGSCQoLu7GxaLhXWLJ0BPr9dDJpOhs7MTZrMZOp2OBfzkjIniIAtJJpOxEm3K6iqVyrTElVarhclkYsAiOUXk2ISCQUTCEVbK6fP6mJYb7W8gNThu5LJD3QDJMSYtGY1WM8iqPOjo+AKDTE9LlmVQYyaRQDAUgggw9inv8PLjNJND/L0dfSPQSeqES4MdvnSLwEc+YOHB5G9CUMvLEZDGIK95SALyNK/xFRN0DSKRCPr7+xlz+Kv8Xvw6QNpRqVQKvb29CAaDrJNwIpFAcXExEokEGhoaYLFY4PV6mX8Ri8XYfED6kLyzT/eVByCl5WQajYYxs4l9qNfr0dfXB1EcrGjweDzQ6XQwGo1poLT0mpC8BAU9FosFhYWF2LNnD0ugSINg0o7WaDSwWq3fKjbtFzW6bnq9HiNGjMDbb7+NgoICvP766+js7ERJSQl++MMfwuVyMYYjDxofyTGOP/54/OEPf0BJSQnzhUVRhE6nQzgcxrhx49DQ0IDGxkYm3aFWq9Hd3c3mB5PJxMqCFQoFOjo6MHfuXNx2220IBAIsQcgfm5/jSRv92WefRTQaRWVlJT744ANMnToV+/fvx44dO2A0GuF2u3H33Xfj1ltvxciRI3HGGWfgySefRG1tLY4//ngIgoBTTz0VL7/8MpqamjBhwgRs3boVWq0WP/zhD+H3+7F06VI89NBDmDp1KmNfymQyzJo1C1qtFsuXL2eJ0sbGRpSXl6OtrQ2jR4/GggUL8Pzzz2Pfvn2YMWMGTj/9dDz99NPwer2w2WxHfJ+9Xi8mTJiASCSCNWvW4Oyzz/7U/VEoBitGioqKUFhYiM7OTrjdbhQVFSEajTJyRabnTQp20Bo/btw4bN++HXa7HY899hgefvhhPPnkk8jLy8N11133nY4nj6Zl8v+lP1IgJxORgPe3h9o/b/x8ngkYyjRnEPhGfiStEfx6RGw5m82GE088ERaLBe3t7QgGg6zCKZFIIBqJwdPnQSgUgsvlYvMIrbF9fX3weDxM8zzRnwAEEUrFoWZxapUackEOn88PAenduQkDIFCRB1vJh+bZjASg8QQYSoarVKq02IriBz7RRs8HrVlUvs2Dlrx0Ae2DflNfBx5cJoCS2JWUuDcajcy350vICUz1er3s/tG44JN+UqCav78mkwl6vZ6RETQaDVKpFCKRCARhUBef4q3u7m7W4JcA10zxJj+mpIQB3vgxerg1K9P4P5b2v+9tHMb4AZSXl4cLLrgA/f39yMvLYw9PpoHwTXDyv2qTAiJUOkmgx8svv4y6ujrYbDbMnDkTNpsNb7/9dlqwTrTpcDicNpitViui0Sh+9rOfoaGhASNHjoTf78fGjRsxdepUPPnkk+xeUHaEgA46p2AwyLradnZ2YuvWrZDL5Zg4cSJisRjTtOC1Ob+NxgMAKpUKw4cPx7BhwyCKg3qPH3/8MaxWK3w+HzZs2IDXXnsNoVAIPp8Pubm5nwpi/+dtCGcDyKzHeOhjh29KM9SEzgOK0sXhcMfiz1EKbtJ+yZEhAJ8+y2fDRo8ejaLCIhQVFsJsNiMSiWDv3r2oqKhAT08P01Pp7e1Fa2srFi9ejPz8fDz99NNYv349/H4/DAYD8vLyUFNTA6VSyeQNCBzQ6/Xo7e0FMPjskl4jaQuazWbWYZOcJY1Gg7y8PNhsNvT09GD//v2YMmUKEokExowZg5aWFtTX12PChAlYsWIFPB4PRo0aBb1ej2HDhkGj0aCnpwcmkwnTpk3DO++8g87OTtjtdkSjUezZs4dlIambvclkYuzBcDjMQNREIgGr1YpAIMB0WPR6fVoZdSqVgsVigV6vh8/nY6UYwODcR/eGElMDyQGkUgfLXwGIAlg3u2QyyYIVcvpoH4lEAuFwGAP9AyyTSjIWAwMDCIVCrMxbq9ex5AxpzVCHW51OB7lCjoFkEilRhHgQ7BBFMQ1YUB68BryjmOm54Mf094DjsTECFEgLCTjUQVGaAOETHpmy3wTu0T6+TuODFdKXpTIuXlsNODTHSOdKYhxTqSOBeV9FsE5Ao5T9QgBhX18fgsEgY6eRTENLSwva2trgdrsRCoVQXV0NmUzGQEGSXsjKykpjSPHMzkxBJn2ngYEBBhgSgJmbm4uOjg50dXWxUlQpaMgHymTEmiTGJp0TMRuBQ2xJHvilecJisUCtVn/pa/1tMEEQUFtbi0ceeQSXXXYZTCYT2tvbMX36dNbggZqhUBB8pPsnxpJer8eHH36IM844AyUlJRBFEUajEZMnT8Zzzz0HQRBQU1ODW2+9FSNGjMCuXbvwk5/8hMlA0ToWjUZRWFiIX//616xxiVR3juYJmmO2bt2KoqIi7NixA0qlEi0tLXjkkUcwduxYNDU14b777oMoimwO2rJlCy677DL85je/QWNjI+6//3689NJLDDD82c9+hhtuuAFLly5lwKXT6YRcLseECRPw2muv4e2338aPfvSjtLE2YcIEmEwmtLW1obGxET/84Q9Z0lyhUGDcuHF49tlnsXz5crz66qsoKirC9OnT8dZbb2Hx4sWfmv8OZ/Rcm81muFwujB07Fm63G06nE3l5eWw7Avx9Ph/i8ThisRi2b9/OOgqnUilMmzYNFoslDVDKtFbSPVAoFJg0aRJ2794NpVKJ6667Di6XC//4xz9w4YUXwm63Z/zs9/blTerrkEnBIwLOhvJ5+P1keo0+z++bB6F4cI58fWlVHq+BKPX/6ZkRxUE976ysLMyYMQPZ2dnYsmULQqEQmw9s2XakkoPkm6ysLFZl4HK5WOJPoVCgqakJPp8PeXl5sGZboVFr2PGMBiOCchlCwRAS/Qno9TokFIMNK8nHIPCRfw5pjebLoFOpFCMv8NvSesgnEqU6jNLvzidX6RrT8QCkfYYavUlBZto3lZXTOfJ6yvyzS8QEqmIgpjofD9A+6J7y95GP4SgprFKpWNUnsSLJh5DJZMjNzUUkEmFyK3RtMwGP0nFH40k6BjNZpmci0/vHKhb4TtdWEcpNJYzPPPMMPB4PYxGtXr0aBw4cgM/n+7pP9ZiYlPUiCAIqKytx22234YEHHsDVV18NnU6HV155Be+88w4LnuizqVQK4XA4bdJQq9VYvnw5amtrMWvWLIwdOxajR4/GiBEjMHfuXJxxxhmwWq3Iyclhn6MAhDdBGCx9evfdd3HppZeyMori4mKMHj2aOYdSPb1vq7ndbjgcDrjdbvh8PsbE8Pv92LFjB1atWoXVq1czfTq32/2dBBAErnRPyuri/+cDrk/tQ/h0hpQ3fl+ZtpGCAtJ90z74/6WLB4Fc5HDwiy9l/vr6+lBcXIyJNRMZyLx582ZG2Q8Ggxg3bhy8Xi8uu+wyXH/99SgrK0N/fz/mzZsHk8mEjo4O9Pb24sCBA1i1ahVef/11vPrqq1ixYgU2bdrEmhhlZWVBrVYzFmF2djaMRiMDDoj1SHqwBoOBlaSVlZUhLy8PDQ0NLFtJpdHhcBg1NTVoaWnBRx99hEQiAaPRyEBEAlomTZoEh8PBuk5v2bIF//nPf1BZWcm6XFOmNRaLsfIJn88Hl8sFQRCQm5vLdBqDwSB8Ph9EUWRgJAXplI1VKBQMoCTwly+90ul1MJlNMFvMMBqNUKvVsFgsyM7OhtlsZg6DTCZjjp9cLkdWVhb0B8uktVotdDodtFotLBYLTCYTsrOzodaomfNCwAc5Z3Re9GM0GmE0GmEwGGAymdDT08O+C4EppKXFl2ZTWe9Q7N/v7csZDwDwcwYx84PBIAKBAHM6pXNDpgRFpuQJv308HmfMQumcd7S/K/2mAMXj8bC1ipxwcpb5qgZay0hKgBgbVEZGQUqmaznUuQz1Qw3tiIlJQGAkEoHH48GWLVvgdrtZcEBzhyAI6OnpYc1bSECfSt48Hg/bN+/z0PnQd+c7ePLnRcEP6cUCgN/vh8/nY5IWoVAIfr8f0WiUPbc8IE3BGO2T5q1EIsE06UgqgwBguh/Ehqbz6+7u/lTC+H/VBEHA1KlT4ff7YbFYUFZWhkgkgk8++QRyuRwHDhxAQ0PDYNfYgzIbn3e/9GM0GjF69Gh88MEHUCgUjMkoiiLzd7VaLS688EK89NJLOPnkk/H2229j9erVrPtqb28v9u3bx4Lgm266CZWVlez5AA49h52dnawqpqOjA3v27MH777+P9evXw+fzYdOmTfjNb36D3NxcuFwuqFQq3HvvvYhEIujo6MDAwAAOHDiA9957D4IgYNmyZWhra8OKFSvYMWpqajBixAjs2LEDJ554IpLJJP7973/D5/OhsLAQ119/PR555BHWRZ1MqVRi4cKFEMVB5n5dXR1isRiMRiNyc3Oxbds2ZGVl4e6772aNd/Lz87Fjxw709PQc8f0lJig9q1u2bEEwGEybJwlUKCsrg06ng8lkwv79+7F582Z0dnYiHo+jtbWVNWmiZ727uxuhUIjNJXwSgICJ8ePHIxQKob+/H5dddhm8Xi9uuOEGvP/++yzp+V14zo6V8WAg/S9df+n1TP65FIwkHzTT/nj/nd+vNDaQngN/PGlZNT3LfJ8CHohTqVQYM2YMZs+ejby8POTk5MBut6OnxwGZTMaqeZLJJPLz81FeXo7CwkLW3dput0OpVKKjowMN9Q3YvXs39u7Zi9amVjQcaEB7Szu6OrvQ3d2Nzq4utvYEAgG2RpNeMCVN6brSekpNZejc+etCICatQ7TuUPxAvjZfukzfh29GSwlX/vrwIC9/7/jEB++DUFUGfYbiGL5UmtZShULBnmNpqbcUbCSTSsmQ7056kvF4HJFIBH6/Hy6XCx6PB0qlkjEtqVEoreuZxvNQzwB/nYaKT+n/r9u+04xHGsT0UE2dOhUNDQ3YunUrbDYbpkyZgvz8fJYx/rpsqMH2VQwg6aRIv0VRRHd3N5555hl4vV6o1Wrk5OTgoosuwtatW/Hf//73U/uQBk2LFi1Ce3s7Jk2ahLq6OvYAElOAuuDOnDkTRqMRK1asSGM58udGzSwMBgNOPfVUXH311cjNzR0yKOPP56u6VsfKRFGEx+NBW1sbfD4f6/ZLgtjZ2dmw2WyorKxEV1cXkskkPB7P133aX4tJnw2eEcK/RtseLtvzeV8bav/S88o02Q/lJAFgABixfmQyGXw+3yBj7iAjSKvVIhQMQibI0NHRgb6+PowfPx7//e9/MXHiRDgcDsyZMwdz585lUgaJRAK9vb2QyWTIy8tDcXExrFYr+vr6YLPZWIdppVKJiooKWCyDZbsejweBQICdp81mY1lB0n6Rlk2SFisABAIB9Pb2Mh3F8vJyhEIhlJWVYdq0afjwww+xf/9+TJ8+HalUCgUFBfD5fIjFYrDb7YhEInA4HMzRUavVGD9+PJRKJfx+PxN6F4RDui2UoaWyBZrbacH3eDwMtCXHhBfHJhCTAnKlUgmF6lDjHb5JDDlLfKkJDywAh5wdlUoFs9nMwBCe0d3f3z+oy3iwvFRMiVApVWmdc/v7+5Hkssg8EGGxWBhwSk2mwuFwWvda6fl81jPxvX1x40FDSqKRg85n4/mxQveBfvMlynxgQ4417wDT/5SZP9rGO8HxeJwlRUjviTL4xAim8yQWAIHhoiiio6MD27dvh9frxYknnojy8nLGbKDSLbqmQ82zmc5Nyurl50GdTodEIoGWlhZ0dnYiNzeXic2Hw2EYjUZWUVFYWMiSK319fUyniYBkvV7POnZSkoLuCc2NvDg/WSqVgtFohNfrZQmCoqIi+P1+OBwOxmojBolGo4Fer0/7PnwDKn5eIGH9rKwseDweBojQuKJ1hK5PIBCASqVCJBL52tmzx8rsdjuqqqqwb98+uFwudHZ24uSTT4YoihgxYgQEQcDvf/97dHR0oLCw8Ij3r1AoMHPmTDz55JP40Y9+hP379+O4446Dz+fDX/7yF7z55pt4+OGHUVNTA5PJhFgshpdeegk+nw+33XYbBgYG8Itf/ALBYBBerxfTpk3DwoUL0d3djZKSErbWkDkcDuj1egQCAYRCIbS3t6O7uxsvvPACUqkU/vjHP2Ls2LFob29HdXU11q9fj1gshl/96le4+uqrYTAYsG/fPrz77rsoLS3F3Xffjfnz5+OJJ57AaaedhtzcXGg0Gtx4441YvHgx7rrrLrz33ntoaGjAnj17YLVaMX78eIwdOxYvvfQSrr766jQwZ9asWXjxxRdRU1ODTZs2oaioCGVlZTCZTNixYwdEcVAy5fbbb8c999yDN998E8OGDcNLL72Ea665ZsikcSbT6XTw+/3o7+/Hxo0bcdppp6GhoQElJSVsHwQwOJ1OtLS0IBaLwe/3w+l0IhAIYPLkyXA4HBg+fDj6+vpQU1MDlUqFVatWYfz48SgsLIRCoWBjQzoP1dTUwOfz4Z133kFxcTH6+/uxdOlSzJs3D8uWLWPn8nl8ye/t8CZly0n97qF8HH5NpW3pdR6MlMaR/D4PByDzvj6/fvH7k/qL/DPD+24ymQzl5eVQq9XYt3cfHI4emIxmePr64HK5mD6t3++HwWiAWq1m7G1KbsWiscFYIjHoO/b19UGtVg9qQaqUiEVj6OrsQiIRR1lZGfOH+xPpBCNi4VNVAuk/UkzAJw3p+1C5Ma1F1NOBWJk86Msny3n/hnwI/lrS/nnmJF/2zetQ8lWVJMnEr9N8MykATAeSZFZoH8Ra5H01vjlQJlKJTCaDwWBgTXdkskE5JaoyIMYmHYPv5E3jJxMLUjrOhxqH37R55bvhZQxhFAwIgoD29naMGjUKZ599NiorK2E0Gr8xbBDekQZwRIvwkRo/qSoUCrz11lvo6elBXl4evF5vWqdEaXaHH/wKhQLHH388NmzYAL1eD7vdzpxno9GYFogTK+u6667Ds88+C4fDkTYx63Q6TJs2DbW1tZg9ezbsdjtSqRTLRoTDYcbUKikpYToYNCF8m4wmmMrKSowcOZJNvB6PBytXrsRTTz3FApa+vj4Ag9fou8LK/ZRxgZjU6DVphjmTY8K//nme+aGARXqP/80/J0OVDVE2USYbFGWOxWJwOp1s0bbb7YjH44jH4wgEAmhurEdvby8KCwsPdrIbBNv8fj/mzp2LgYEBVgrd2dmJuro65Ofno7S0FAaDAfn5+aisrGTdqrOzs5nzQEwQYvERaBeNRmG1WlmpQDKZZGwh6uzm9/tZubbRaERzczO8Xi9jH6pUKoRCIQwbNgwulwt1dXUYOXIk9Ho96yhLrKnc3Fx4vV709vbC7/dDEATk5OSwssaBgQEEg0FYrVYkk0lYrVZWpkylDSSZQYF3U1MTIpEIbDYbcwQAsPmeri8xnRKJBGSCDKKQ3k2a7q+03E06Rtj9B1g3PcoCh0IhZGVlwWg0DgI0MgHRaBR+vx8qxaHSTaaLJ5elZVgJsCCBaho/pIvDJ4F4sFHqwBzOef7ejszoGaeGPzQuyNegMUPrJx9cSOcp+hwFJsQsoCw+fz+JdThUmc5X+f1EUWQAVyKRYMwI6ppMMi2hUAhOpxMej4cB5Ha7HclkEu3t7WhubmYaTJ988gkUCgWKi4tZh3j6bqIofi5AjGdgSKsnKAlCwAyVVJeVlaWBgsOGDYMgCOjq6kJ1dTVisRj27t2LSCQCpVKJ7u5u5Ofns66j9HxSIxce+KQgi+YrCrjofbomgUAAGo2GzUt+v5/px5rNZpZkCIVCTMaB9kljggDFnp4eFBQUMGF/YFA3MxaLscQL6dpSOTAFVdR587tgcrkcJ510ElatWoWKigpEo1Ho9Xps2rQJ3d3dmDp1KmSyQY3zadOmHfH+icjw29/+Fnl5eejs7ITD4cAtt9yCcDiMP/3pT8jKyoLNZhvU6vX50NHRgREjRmDp0qWIRqN466238PHHH0Oj0WDJkiUsESmXy2G329Hc3Ayr1Yrs7GxW+aLX6/Haa68hEokwRs29997LmqFMmTIFMpkMY8eOhcPhgMvlQkVFBXbt2gWj0YiioiIkk0lceeWVuOCCC1BdXY2nnnoKt99+OxQKBaqrq3H88cfjzTffxGmnnYb+/n7s2LEDs2fPRldXF6688kpcd911WLBgAfLz89kYNBgMmDlzJj788EO0tLRg0aJFsNvtB5lbPcxX1+v1+MUvfoF77rkH0WgUO3bsQDAY/NzkD0EQkJWVhdbWVqYTT9UgBEAAYM0duru70dTUBJPJhN7eXmzduhVz586F2+1m85PVasXWrVsxMDCA3t5eNDY2MmkX6k5O+6Zkik6nwwsvvIBVq1bhsssuw4QJE/DKK6/A7/fjiiuuwMknn4xFixYhLy8vrTnQ93bkxs+nmfxqmoulACIPdgHp0kyH+82v0dKybRrHvJ8/FBglBSKlx88U8+fl5UGr1aG9dXD9FCDAYhlMMOn1emRZLXD3uaGQHWryUlhYiEgkAp1GB6PeyBiN5B/rdDokxSTUmkH5H2evC6mUiNKyEuh0Oui0ekTCUZbUJtCQBxHpe9L1SCaTaZ2b6ZpQUpGvNqL1nb8ftIbzbFDyO+gz/HWla8fvm2Iqft0FwCoDSItWEASm98g3rSFiAa0NdF+kuAcPQkpjPjo//hm3WCzsvEhSg74TMU2pGRWvF09a0JnG6Wf58J/Hxz+WAOV3GnikGv/Ro0fj+uuvRyw2mBGgm8478MfqhhxugHR2dgIAioqK0nShvuy5iaLImpbI5XJWRpiVlYUHH3wQa9euxebNm1FUVIRdu3YhGAyy4ILYNdKJWalUIicnBzk5OWyfGo0G5eXlsFqtCIVCrBkDAQdTp07Fm2++CYfDkTZJZGdno7S0FHV1dfjkk08QCATg9/sBDGrQjRw5EhUVFSguLv6UsO230fgJLJlMwul0QqfTYdGiRTjuuOPw3//+F7t370ZnZydaWlogiuIxCxjWrl2LBx54AFu3boXD4cDKlStx1llnsfdFUcQvf/lLPPXUU/D5fJg5cyYef/xxjBgxgm3j8Xhw7bXX4j//+Q9kMhkWLFiAhx9++As1xxFkh0T7pZM+Gc9+kWZFMz1DPNB/uGcr07OaCeCUOhn8+/yCLQCIHwweQwc7MIsiEI1EIJfJoFAoEQoG0eNwIJFIoLy8HHa7HcFgEBMnTkRXVxcrq9iyZQvKysrQ1tbGGEglJSUYPnw4ent70dzcDFEcZDGqVCoEg0Hk5uayhjPkXJhMJpbJbG5uRk9PD2MqhEIhBs41NDTA6XSioqIC8Xgc4XAYWq2WsRjdbjfkcjkikQisVitMJhNmzpwJs9mMlpYWlJeXIysrC4lEAmazGU6nk+k/Unnq3LlzkZWVhb6+PtZEobOzE9FoFKWlpQAGn3mj0Yh4PM7YVQSSms1mmM1muN1uVjopCIPlFjKZDLF4HGq1CmaNGeFIBKFwGErlQXZW6tNl/IJMBuEg6COm0jVt2Lg56CxFIlEYD5asezweBpRSWYVSqYQgDoLOWo0WIud4DQwMQJDJoFQp05w8cvDIQSIWJZWRp5V90LkfPCdBEAByjiAgJX5f/vVFTAoUEgBHDra0HIucZ3KuKSMvBYbpcwQ6kaNK20jHAQHO1EF6KKDui/gK0sCKOlVTQsLr9cLpdDLGdnNzM3p7e9HZ2YlEIgGbzQaNRsOkF2KxGLKzs1FVVQWr1QqPx4PW1laUlZVh3bp1mDx5MpNO4UumPiuJSOVJqdRg47qOjg50dHSkdZck9mJJSQlsNhtjIJCutNlsRnNzM1KpFPLy8hgg4XK5YLVa4Xa7kZOTwyQZHA4HADCtWGpAwwPEfNdKURSZTAQ9s8TgBoDgwXmfdCeTySQMBgMikQjTqAuFQmmNTwjITqVScLlcMBgMMBqNAAZZ5+vWrWO+rs1mQ15eHgu6Ojs74XK5YLfbYbFY0hr+/K/brFmz8Ne//hXnnnsutm3bBo/HgxkzZrAusdnZ2WlyQkdqI0eOxIgRI6BUKpGVlYXLL78cJSUlWLBgAUsAkr/a19eHUCiEE044AVqtFm63G7/85S9xwQUXoLi4GDKZDG+99RYAMF3zDRs2oKqqCj6fDw6HA6FQCKNHj8auXbvQ0dEBjUaDn//85yguLobFYkFBQQGLGwoKCljn80svvRT33nsvzjnnHCxYsABKpRIbN27En/70Jxx33HF4+eWXcf7552P48OFQqVS4+uqrccEFF2DJkiXYtGkTXC4X1q5di/nz50OlUmHkyJF49tlncdNNN6XNWZMmTcKKFSswbNgwxuIifWd+7jOZTLj++utx8803w2Qy4a233sLChQs/93XX6/VwuVywWCxIJpPwer1sTY7FYmxuUSqV6OzsRCwWw/HHH489e/YgEAjg9ddfh1KpRCAQQEtLCyZMmIDe3l6YzYMSK8OHD8fu3btRXFyMLVu2YPz48fjoo49YiTWVxz/99NO47LLLGGh6+umno7W1FeXl5YjFYrjyyisxefJkXHrppYxZ/VXFdN8l4xOs0uuWCfTjP5fp9UwJZNp/ppiSn9ulQGOmhLSUOMSPfd7H5Fl8ZINNkbKhkMshVwxWPbV3dECj0yCZGpQTMZlMECBDODQYlzscjkGJH60OeoMehgEDDCYDnE7noEwIUtAb9CgsLGSSBIFAAHt270FObi6GDxsOhUKOAbmQ1syFfGeq+OFxE/K79Xp9WsKV/BJiLvKgIM/uo4oH/lry8kj0P8+6jMViDMSkJCwPavLPFg9g0vnwYCZVcxEAStUNfCMavlKF7l8m4/00uj607pN8Fd17k8kEo9GISCTCpE+InU1rOBERpGXdmUBu6fuZxje/nRRYP1r2nQYeid7a3NyMRx99FKeffjqmTJkC4BBY8XWBV/wgIMrze++9h5KSElZiSOf3ZRcpctS7u7uRTCbZMeLxOFpaWlBZWYmamhpWmvnWW29BEAZpwQQ6Sge8Xq+HzWaD3W5naD2VSgqCAKvVClEU4XK5MGHCBNjtdsbcAcD2r1Ao0NnZieeffx5yuRzxeByzZs3CwoULUVNTg4KCApaNkIJK3/bFWxAGy6laWlqYBpbb7Ybf74fNZkN/fz86OjrSungdbQuHwxg/fjyWLl2KH/3oR596/3e/+x3+9Kc/4Z///CfKy8tx55134pRTTsHevXuZw3fBBRfA4XDg3XffRX9/Py655BJcccUVeP7554/4fDIlB6TZMH5cDJUp4oEB6fuZstHSyZ4s07zBgwN8qWSas5JKwdM3yEaRyWTsGVeplNAf7ITZ6mhlXU9Jd4wCYNJIJWeipaUFHR0drASK9AbJGbDb7TCbzawMw263Iycnh+m50Jii7CAFFG63GwcOHEBFRQUDvARBwJgxY7B3716sWbMGo0ePRlZWFhwOB4xGI3Q6HVpaWmAwGNKYDdnZ2ZgwYQL27NmDxsZGaLVa2Gw2ptUYiUQQCAQgiiKys7MxZcoUiKKI/fv3Izs7m2ketra2Qq1Wo6ysjAGniUQiTU+Jsq+jRo2Cy+ViJYy8cyMIAhL9/YgeLLcWBAEigCSnt5J2zwAkDwIxcu7eMh2ag10CI+EIK62gMm7an9FoZN3v+DITfv6Xy+VIQcwYBPOMMLq2dD5iSkwba4IgHAQgB8HGwS45IlJiCoLse8bFFzE+KCG2LD37FDTQ/7xWH41P0g+KRCLYv39/mlQBSZFQcyFpiRPvqNO5iKLIGIP081V9TwK6BwYGEI/HmWYlySG0t7ejvr4egiCgsLAQ1dXVzLneuXMnPB4PYrEYdDoda+xADVFGjBiBoqIiNDY2Yu/evbDZbAxs/Dw+GI3zeDwOr9eLhoYG1pE6KyuLdQkl1jUBtVQSTmXM0WgU9fX10Gq1yMvLg1KpxJQpU/DRRx/B6/UiLy+PdfYlfdpgMAidTgfgEAs5FAqlPec0LwiCwJpZAGDsBpvNBp/Px0Bri8XCGm61tbWhpKQEwWAQJpMJJpOJscz5wI0YkcRSl8vl8Pl8CIVCKC4uhs1mg8ViYaAjzYvEHJcGuf/LJpPJUFJSgry8PLS2tkIURezevRvz5s2DRqPBwMAAhg0bxhhyX8QMBgPOP/987Nu3D3v37kVRUREuuOACVFZWwmQysTk7kUigubkZ8XgcNTU1AAbJBWazGddddx0ef/xxrFmzBiqVCkVFRcjLy2MahQMDA3j11VfTmi3E43H09fVh3rx5OOOMM5BMJtl6zRtVJvT39+OMM87AFVdcgfb2dpSXl6O6uhoLFy7EP//5T5jNZjz44IOMuVdVVYVzzz0XL7zwAmbNmoW2tja0tbWho6MD1dXVWLRoEW688UacccYZGD16NDve8OHDGUD/zjvvwGKxoK6ujpEYALB5rbCwEDfddBNuvvlmjB079nNfc4otEokEdDod2trasHLlSlx22WXYunUrxo0bxxIMPp8PO3fuxMknn4wJEybg6aefZsmAcDgMn8+HjRs3Yvv27SgqKsLs2bPhcrlQX1+PSCSCZDKJ9957D4lEAk6nE0899RQ0Gg2GDRuGX//615g5cyYcDgdUKhUqKytRUVGBsrIyvPLKK1i6dClOO+00vPrqqzj//POxYMECnHvuuSgoKPjUOvz9unx4OxxYy/v3h/t8pu2G+puPy6UAEJ805Mtvpcc/3D3NdP950EoURViyLBAhQpAJCEfCTBswGhhk+fYnBn0Ek8mEQCDAdIhlMhmsVivUGjXMFjOCwSBcLhfC4TD8fj/sdjsKCwvh9Xrh9XoRjyfg6RtkU9pzbVCr1UxbnOYaAsao6oqXh6F1iF+n+OQ4VQRIm/jS2k+l2Lz+PW1L+A2ANGkWilnIdyYsgWSY+HvF3xeqFOJLuqmqg+ZUu93+KVCUj/mksSAvrUOv8Y11KOnCxyCpVIrpwPNMTT4O5dfqzzvupdjI15nk+E4Dj3RTs7OzsXDhQmi1WmzduhVjxoxBUVHR19rlj0qGlEolYrEYvF4vW/QHBgbg9XpZ4P1lBxDRsQsKCgAcGqD0sP7tb39jgAg91DKZDNFolO1Deuz8/HxYLBYMHz4cCoWCNYCRgjh2ux02mw3AIAOVOvtREE7lEpTB0Gg0aGlpwbvvvovm5maUl5ejoKAA2dnZrGlEbm4uu3ff1kWbJiCVSoUZM2YAONT5k5xVj8eDRx99FG+99dYxYyrMmzcP8+bNy/ieKIr44x//iDvuuANnnnkmAOCZZ55Bbm4uXn31VZx33nnYt28f3n77bXzyySeYPHkyAOCRRx7Baaedht///vdsDH5ZkwKMQ2VyPo+Tx49Z3okgRz/TAkPb8vvgs5iUyaIyeq/HC+1BRjAJGZtMJoTDYfT29sLpdLJOxwSiUdlyLBZLAyCJYSGXyzFs2DBYLBaceOKJOHDgAGtQQwAYnZfT6YTT6WTb8yLOtFgSi7CgoAButxsKhYKVcEWjUZSXl0OpVGL9+vUYM2YMhg0bxjo3FxQUsC6qVL5AWisTJ07E2rVrsXfvXhx33HGDzVgOBijRaBTr1q1DVVUV02ILBoOorq5GKpViWci+vj4oFArk5eVBrVazIIvmDb1ez5hmNpsN0WgUgjDYDdtsNjOnqX+gnzlCBHrw2XTWoEUUoTh4/ZRKJVIHWWBp4+YgMESgRCKRQCgUYuAQ6d7wx6Fxw8acAEAQGIiZaZxmcm5FHAriDje+2WeTIlIDSXxvR2Y0NqjzO83ZfOk0Oc2CICAQCMDlcjFw0OVyoaGhAX6/nyXjgEHmG2mP0Vig9bS0tJRJAygUCuh0ujQfgBiSxKQ9EgBvKBNFkYGm8Xgc0WgU0WgUvb29cDgcaGhogMlkwuzZs2EymWA2m6FQKBCLxbBx40YolUrMnz8fb775JrRaLdNZjcfjKC4uxqhRo1hiavPmzaisrERRURGbU+l5HMoIvG1ra0NPTw+8Xi9OOOEE5OTksGoA0k+i8iXgUHBA13Pfvn1IJpMwGo0sqUp6V3V1dQws3bJlCyorK5kkhMvlQk5ODtxuN8xmM9NLpGMCh/Qa6d7IZDLo9XoWyFBTjGAwCLfbjcbGRvT09CAWi2Hz5s3Q6XQoLS3FsGHDUFxcnDZvJJNJhEIhyOVyuN1uZGVlQRAE2O12jBo1CsXFxYwJSwFfMBhEKBRCJBJhwSOB3v/LRnOgUqlEdXU19u7dy1gmnZ2dqKiogCAITAroyxxnzJgxuOuuu7BgwQLccsstUKlUyM7OZmPa7XZjw4YNcDqdsNvtmDBhAnuvr68PZ599Nj788ENs374dFRUVSCaTKCgogE6nw8qVK/GjH/0IjY2NMJvNLLBuamrCqaeeimuvvRaCIKCioiLjs+N2u/Gf//wH//3vf3H33XcjGo1i1qxZ0Gg0yMnJQVZWFtrb27Fq1So8//zzEEURjz76KORyORYvXoyFCxfi8ssvx44dO7Bz505s2LABsVgMc+fORW5uLv7yl7/gwQcfZGuxwWBAZWUlOjs7WfJz1KhReP3115nsCJ8snjJlCp599tkjlktSq9VwuVwoKyvDm2++yaSdrFYrq6ohmYTW1lbWBfjHP/4xXnrpJYTDYRQUFKCjo4MBgVarFZs3b8awYcPwwgsvsIRQb28vurq64HQ68cYbb2DWrFlYvXo1a0xUVFTEfJb9+/dj2LBhOP/889HV1cVIFKeddhpWrFiB888/H0uWLMHChQu/UPXPd90yEQ+kAEsm/54nbRyOuEL/S7fn35dWOEhJBsDhyUyZEty0X/69VCoFk8mEwsJCxGIx7N+/Hzk5OWzsp5JJxOOD80FWVhaTIyPAjGIPURRZki8SiSAUCuHAgQMwmUwoKipCf38/PB4P+jx9iMQGq0HlcjlMJhNsNhsj/RBDWK/Xs/PVaDRIJpPMn+b/BpDWUIZvpEiVG/zaz/xsjh3IV7rR9sTIlHaypgQSXTv6LF+iT2spJQyJcEH4A81RpKXOn5OUyMKPCekYlG4jZepKwWsetKTz4pNItM+h4lvp+B9qTTvcfr5q+84Cj/xD7XA48PTTT+Pcc89FbW0tiouLj7pW0mcZAUx0jtnZ2VCr1WhqasK+ffswYcIEGAyGtImS//uLmJS6q9FocP7552P+/Pms6c6OHTvQ1NTESnyHsoqKChgMBkyaNAkymYyVi/AmXQhUKhV++tOfYu3ataz0m7ajUhECJfR6PeLxOHp6ehhDivTS7Hb7l74W3wQjBobb7YbJZEJbWxtefPFFxpbxer2or69PA4C/TmtpaUFPTw9OPvlk9prZbMbUqVOxYcMGnHfeediwYQMsFgsDHQHg5JNPhkwmw6ZNm3D22Wdn3DfpG5JR0xNpSTSf6eEzSfw2Q40L/nXpBM1P3tJOwZmciqHYIxRwki5Yj6MHSqUCWVlW6A82YyBmk9PpZGV/WVlZKCoqYuwUkkMgzUD68Xq9jA04fPhwiOKg5lBeXh4EQcBHH32EmTNnYtSoUVCpVDCZTAAGO6pSJ2b6PqFQCN3d3ejq6mKlZ8RUpCCXnAUKfikJ0NjYyBhcWVlZjBVE4MD48eORSqUQjUZhNBoZq6iurg7l5eUskKqvr0cymcRJJ52ErKwsdHZ2QqPRwGw2M10ltVqdprtGzhA1ayGgk7EYDzJ9AKQxR2RyGbv2Ui02ur9U5pBMpRA/CParVCoIBx0hcnTkcjlkgoBEPMHGIDl7giAgEolAo9GwhAE/F5IDRKNPmlgi5hmdF88STzOJ8304VjRlpb+3w5t0zaPr6vf7mUNLWkY09qiTc0tLC3OCfT4fent7EYvFMGrUKOTn57PuhjT+PB4PPB4P0ycLhUJYs2YNFAoFSkpKUF1dzZJ2NNb5cwAOMe2USiXrljtUcmWo70vjjX5IkqajowMNDQ1oaWnBpEmTUF5enlZm1draip07d0IURfz4xz+GSqWCzWaDTqdjZb0+nw8qlQpZWVlMl3ZgYICx+inrf7ixSfNIU1MTWltbIZPJMHPmTKRSKTgcDsYgoFKlWCyGYDA4mPDxehnLyeFwwOl0YurUqXA6nSzpKQiDDM5kMonGxkZ0dXWhvLwcfX19jLGYl5eHnp4edv7/z953x7dZXm1fGpZkDVvDkuW9EzuJkzjTGZBJEggESJillFDKpozyFsoLtGVvSktbCi0UWsoHJbysMJJAyJ62M+3E8d62bO29vz/EuXPriRxCy2hLz++X2H706Jn3OPd1rnMduVzOQGNK/eL7H4HFJDBP7aivrw+Dg4Po6+uD2+2GwWBgIFAsFkNbWxv6+/sZk5QWTNTWtFotHA4HbDYbNBoN088lSZyRkRH09/fD6XSyKt0FBQXQ6XTIzMxk4+F3xUh38LzzzsMbb7yBLVu2IDs7Gx6PBzk5OUyShOxkPqXQXxgYGMCzzz6L8847D6tWrYJUKmWAezgcxp49e7Bv3z40NjaiqqoKkyZNgsvlgtFohEQiQUlJCZqbm3Hbbbfh+9//PjQaDQO+y8rKWDsmVisVoqmpqcGDDz4Im80GrVabVAGb7yv79u3Dq6++ittvvx3jx49HPH68MnosFsPOnTvR3t6OZ599FkeOHMHmzZuZHml+fj7GjRuHnTt3IicnByqVCnv27MH111+PoaEhnH766fjjH/+I6667DpWVlSwINmnSJLz33nvw+XyYPHkylEolTCYTWltbWbYZPWeRSISSkpIvfIc80AQk5mjKztJoNCwTor+/nxXoMJvNMBgMsFqtmD9/Pj7++GPU1NRg0aJFUKlUaGlpYQWlSkpK0N/fzyQP6uvrUVRUhA0bNsDpdMJqteLo0aOswN2hQ4dQW1uL/fv3w+VyYfXq1di3bx+Ki4thNptRUlLC+m5LSwu6urpw2WWX4ZJLLsG9996LDz/8EPfeey+qq6v/m359CpZqDSzMLCJ/SeiTp1rD8vvRcVP586MBSjwBgQdzhL8LSRH8PgS2AcdTucmImCCRSKDValFaWopYLIaWlhYACdKPx+VFf38/4vGEjFpaWhqTZeKza+RyOQsiajQaGAwGjIyMwO/z41jzMchkMuTl50EsFsHmsDFpH5vNBp/Ph/T0dOj1epjNZoTDYbhcLubDkB/L/yRfhMkLiY5nHdE4RX+TbAy9E3q+5NMIWYcEZJL/wfvTPJGA/HM+C4HPHhG+U5KHIZyBsJgTgv2C9sW/N9qXB01TvXsyHlSl7bwPJCQenKxd0j789pNhN9/EOPOdBR4BMIFUsVjM9NB27tzJHGjg2xns4/E4S/c4ePAgYwzKZDLk5uaytAl+QfmPgqTUACmNl9Ko+IUGkHgOU6ZMQXV1NaxWKw4dOoTXXnttVEd13LhxrKOnGsiFz5X20Wq10Gg0sFgsSZ/TAEesSWKVXHDBBcjPz0/qqKnuj7d/pwmc2A4tLS1wOBxM+0ksFsPtdsNqtX4l6fZfhQ0ODgIAsrOzk7ZnZ2ezzwYHB2EymZI+p0IetE8qe+SRR3DfffedsH00x4EHHVNFPIXRSyFIyS8S6XvCz0aLJAkdiyTwE4mfFosFdpsdRpMRSkU6AyuIkWOxWNDc3MyKAFBFaWIdUj8Qi8UYHByESCRi6RFms5kxH0n3zG63Iz8/HzU1Ndi/fz9jARYVFSE3Nxdms5mlH/p8PsbS0mg00Ov16OnpQWdnJ2QyGSorK5n+mdPpZOmfcrmcVXgl5sbIyAh6enpYmjVV3qyrq8OECROYXAPpvzY1NTHmosPhwODgIEuPtFqtiEajqKioYAAeOVS0oAPA0jMopZscBtomEomSNNKIsabSqJnTQgBjOBw+QasPAKQSCdLUasbijH3uDJJ2i0gkQiySAJ3C4XACaADYAkgkEiWix1IpYtEoYyjyY3pclFrMmm9fo7XxeCyOOJJlBITGO2bE/PqvndxSBSQoPZZ0HSORCGOVhcNhDAwMYHBwEGKxGB0dHbBYLDCZTCgtLYXZbIZGo2Gp+PQONBoNtFotSkpKGKDgcrkYqNTe3o7W1lZUVFSgtraW6Sjy7YSPlpMjT4zML/IXhPdI7YzYjp2dnaivr0cgEMCcOXNQUFBwvAq8VIqGhgY0Njaiuroa1dXVLAW5sLAQ6enpjNlATAJKwaY+TqwD0pNMNb/RNYbDYYyMjLCq0zk5OSwgo1KpGAuwr68PQ0NDjNlBfo5CoWDgYXZ2NmKxGMaMGcPGSCDRb8vKythce/ToUZSVlcFoNKK3txc+nw+5ubkIBoMYHh5mYxavNUUaVPT8A4EAk8CwWCzo6upCS0sLPB4P8vLyUFtby/QG6RglJSXsXo8cOYKCggKW9kZVtQGgtbUV48aNY0yUgYEBllJcUFCAmTNnwmg0siJUAEYFpf+TbcqUKayACM29hw4dwrJly9Db24s1a9YgFAqdcvYTtcmBgQHccMMNmDx5Mi6++GKWAUT9s7GxEY2NjVizZg2mTJmC3t5exGIxvPzyy/jxj3+MnJwclmFUXV2Ns846C2vXrmUSO52dndBoNNi6dSsaGhqg1+vh9XpRXFyMp556CoODg5g4ceIJurAdHR2sne3cuRO33347y5agBXpfXx8++eQTPP/887j99ttZX9iwYQPOOeccqNVq/M///A8WL16Ml19+Gbfddhs++eQTAEBzczNKSkpQVVUFs9mMv//977j33nsBJMbOmpoalJWVoampCdFoFNOmTUN7ezu6u7sxY8YMtt8XtUN+fOKBCJrbgQS4X1xcDJvNhqNHjzIZFpFIhI6ODphMJiiVSvzwhz/E4sWLmSblJZdcgvLycixbtgyvvvoq0tLSmATDwMAAcnJyWNCI/FapVIpJkyZh48aNMJvNOHToEIAEsL127VrMmDEDcrkcEomEacpSf7Pb7aioqMCxY8fwzDPP4Nlnn8UVV1yBhx56CEuXLmX39V9LbULCgNCXT7VPKrCS96sIzBIaD3Txawl+3hWej75HP1lgOYXvxoNTAJjvya/x+arRCc3HxNwvl8uxfft2aDQaqD/XE/d6vcwfoWJl5AOQ5Edubi6TNLPZbAmpg9w8eNyJQietra2II1FsRiQSwWq1QqlUMp8mEAjA4XAwFiSBjqRFTCxHav/8M+TXrgQOU78ggJXuWSQSJcnX0HfJ16LnxRfppGAjj0Hw/gzPXqTgO63DaB/SgxSLxawGCJ/9mapNkQnZjKnA79Hai7CN8d8fzZ8XtqVUQGOq60x1DV+nfeeBR4lEApPJhKlTp2Lp0qXIz89nFF0Sfv42Bn0CFXJzc5GZmckKtABgTizR+dVqNXQ63SmDj6kaLVW3IsDB7/fD4XCgvr4eH330EUtlpCg+gFHTe6VSKcaOHfuln1s8HmepaMJrHBgYYAv2eDxBFU9PT0dXVxdKSkqQn5/P9JxKSkqQnZ3NJmwaoP7dJm+RKJHisWrVKoTDYTgcDmzbtg1OpxM+nw/9/f3o6OiA2+1OKqrzn2h33XUXfvKTn7C/XS4XY9HSJCZkP5Kd7L0LnQf6PRXwyLdJ4b785Dma4yIWiyESi+B2uRCLRGHOzoZIJGJsGJpUaEzSarVs4UyaQsTwo3PKZDIUFRWxfhmPx9Hd3Y1JkyZBqVRCJpNh27ZtLI2ptrYWBQUF0Ov1zKEeGhpCLJbQkS0tLYVOp2OFSuLxRNX5nJwcxuLxer2swBNV2yYWJqWskU4kVbZ0uVwIBALIyMhAdXU1hoeHceTIkSRNo+LiYgSDQTQ2NgIAS5kuLCyEWCzGwMAAFAoFdDodY1xGIhEGDtD4SPcSDoeh1WoZo8rv95+gqaJSqeDz+RCPx+H1eKBUqViFWXJufD4fi5ISsCISiRAJh5EmkUAqFkPERUB5EFmeroBCmWBtQQTEEIfTnWBJBULBBPNSnNBejIs+d4oQx+f49AlgOP3Nj2kUIOK3x+Nx8K0+FXiZqj3/107N6PmRCDj1FZLDIAe6s7MTfX19aGtrg9PpZKAP9Ud6XxEOuCZGOzESDAYDsrKyMDw8DKVSicLCQoyMjGBwcJAVRJg2bRoKCgpYJXoyOge1G5IKIGD9VO+Tgh5+vx/9/f04ePAgAoEASkpKIBIdZ/BSCq/b7ca8efNQWlrKHHZKBePbLknJdHV1sYAUpYQREMsHCVJdXzgchtVqhUKhgFqtZu3c5XKhsbERQ0NDLFhDizQaT3NycqDX65NSssRiMUsVpwUJkBjby8rK2Px79OhR6HQ6xnbs6elBYWEh068EwN6hRCJhLAkgwbSmwKHb7UZfXx8DLydNmsTGeWpPPNs0Go2ywj5bt25FaWkpcnJymG4W6duFQiF4vV4cOHAAXq8X5eXlqKioQF5eXpKuHpAI7KanpzPtye+KZWRk4OKLL0Zvby+qq6vxf//3f5g1axbMZjPy8vLQ0tKCkZGRlNp7ZEJfdWRkhIGHS5cuxZgxY5IWjrFYDI2NjdizZw+mT5+O6dOn44UXXoBanQh87dmzB2eeeSbkcjlKS0sRDAZx9dVXY8OGDfB4POjq6oJGo2FM/qysLLS3t0OlUuF///d/odFokhao1B/sdjt27dqFw4cPw2KxYOLEiaiurkb2534I2bvvvou//e1vWL16NebMmQOz2Yzu7m4YDAb09fXBZrPhhRdewA9/+EPs27cP+/fvx+TJk3Hw4EE8+uijmD17NubNm4cf/OAHWLNmDbxeL0sdJimd7Oxs9Pf3o7m5mWmRjrYgTvWs6afFYsEHH3yALVu24NJLL8XkyZPZeGE0GlnKtcPhgFwuh8PhgF6vRyAQYIFuqVSK+fPn480338T999+PRx99FHl5eTjrrLNwyy23wO12o6WlBZ999hkqKythtVoxfvx42Gw2ZGRkoLCwEHq9Hr/5zW8QDAZRXFwMtVqNBQsWoK+vD1qtFh6PB1qtFocOHWIgzPTp01FaWgq5XA6TyYTm5mZ0d3fjBz/4AaqqqnDTTTfhnnvuwQ9+8IOkQhj/nauTLRWoIgQWU4E1p+IL8eDYycBMIZhGn/P6f3S8L2rn/HXzABTN36nWHkqlEmPGjIHP68P+/QeQ8blsB8mVuVwuyOUyeH0eSCXHAbO0tDT09PSw1GqbzQaLxYLe/l5k6bOQoc2AKlOFeDzGisXl5+cnEQY6OjqgVCqh0WhYxlVBQQFCwRDCoQSeQGnXvL4hn+7MZ3rx5Aq6P9qPf0b0zni9SAq40t+8zqaQBUvZZ2TC90bPiNbWBGjSXExZBvx3he1PSAjg33+qdWoqEJ0/Lv0ubHejmZCkwLcvfj2Q6thfp31ngUeRKBEZS09PZ9GC9957D1lZWTjttNOQnZ39rUSA+UYilUqRk5PDOiZp8hw9epSBEkVFRUki5qdqQqYXdUpytKmqdW1tLSwWC9atW8dYBPy1pjKZTMaqO55sv1TW2toKj8dz0n0IjDnrrLNw0UUXMTCBX5z4fD4MDg7CYrGgpKSEVb39dzJaVFE0V6vVQiqVoq+vD0eOHGFp5gBY6ui3aVR1c2hoKKkA0tDQECZPnsz2EbJZI5EIbDYb+34qk8vlKVkHqZwHHpwBkDRxp/qecLAfzUEh46N0/GTIa5ewiKREAsQ/j8SFwujq7gbiCSah3++HUqlkoCnp/lE0jUBIWmxStJ5YMiSCLhYntMKIaUpFh2ghLpFIUF9fj5kzZ7I0I0qTIG1UtVoNl8uFrq4uWCwWlvpJz5CO4/V6kZaWxr7f398Po9HIUjbC4TDU6kTFPI1GwxbOVqsV4XAYGRkZkMvlKCsrg8/nQ1NTE2w2G7KyspCdnY28vDw0NTWhr68PRUVFiEQiaGxshF6vh9FoRGlpKUQiEXsmHo8HJpOJpUFR6jhV0jYYDCzdlSrIkSC2WCJGPA7IFXKIJRLY7bbEu4vFIBVLIJaIEQqFIRaJIBJLgHgcwUAQEUkYMpk8UQmai0bzkzfpzPDjKkV0KW2Tdwp4DR9hOxayLVO1ST4KDiRwy1jsi8dq3in7ppyOfzcb7bkQU4/GDBqrCdw7dOgQ6urqEA6HUVRUhJqaGsjlchY9pzZDRYfI0SaZAZr3JRIJFAoFiouLYTQa0dzcjJycHOTl5aGkpAT79u3Dzp07EY1GWZEoHuSieyBHm2cWCOVVRou8U4pmT08PSyGUSqWMqWcymWAymVBYWAiHw4Hq6mqUlZXB7/cz9gGld9HCgBZRPT096O/vx+LFixm4Gg6HEQgE2LMSAo90vbFYjAU6iHXqcDg+F8YPIhaLoaSkBAaDgQVbqPomr/NI/gP1WyFbFDheibOoqIjdU3d3N/x+P/PBjh07xvxKXqieUqtpLiemJ0lcUMqcWq1OYoTa7XZWdIbSvSjoyheV8Xq90Ov1GB4eZqBpKBTCrl27YDAYMH/+fKYNTO+U7kGhULDF1XdB45E3kUiEM844Az/+8Y9Z4RbSQi4vL0cgEEBdXR3OPvvsL0z3BxJjwn333QePx4NnnnmGzc+8fElLSwu2bNkCiUSCmTNn4qGHHsL48eOZPmhTUxPMZjNmzpwJkUjE9F8vu+wy/O53v4PJZIJIJEJvby8D+qPRKG644QamB04La/q9p6cHO3bswLp167B582YsXLgQK1euZOwn6ketra145ZVXcMkll+DCCy9ELBbD9u3b8fLLL6OwsBC/+93vsGnTJjzyyCNYunQpJBIJXnjhBUyYMAFNTU1wuVxMWuX8889HT08PGhsb2b2oVCqUlJRg7969OHToEGpqamAymbB3795Tnn9oPGpvb8e1114Li8WCSZMm4Uc/+hF0Oh0MBgOT/IlEInC5XPD7/Th69CimTZsGkUjEtLQpwCEWi1FWVoYXXngBGzduxJ///Gf83//9H/x+PyZNmoTi4mKsWrUKPp8P06ZNY+BKf38/mpqa8Nxzz6G6uhqdnZ1QKpVobW1FY2MjRkZGkJaWhmuuuYYxxDUaDaqrq5nMQ2lpKWOeicViDA8PY+nSpWhubsY999wDlUqFCy644J/W6f1PNd4XovkrlT/DAy3C7UKyAK8DyANVvGwBfZf3z/g1R6osP2FmHg9QCdfWQt9MuF7h1zgiUYLxPmnSZAT8QdTV1UGj0TCJlYyMDPT190KaJoVYdLzIJGVriMVidHd3IxqNsgKPNoctcS4xoNGoWaq2zWZDMBiEVqtl1+d2uzE4OMgCkW63B6YsE1Tq4xInJOXEB//p3ngMgwcI+cKpPHBJ9y4kffDvhY5LkkyEqdBcT+AkD0Ly4yb5TEqlkv2kQjOk2y5sR6nam7C9CNehqdoxPQchWUAIGqYCv4XHTgUwjnbd3xTe9Z0FHoEEQEaC0vX19bjoooswY8YMJpCaCm3+uizVpBuPJxgVfX19cLlcrOJ0bW0t03QSouepBtVU1tnZCa/Xi6qqKkaLbmhoQDyeYAp0d3czAIDYSnTsVFWUhR2LWBen6kzQwm3Dhg2M+pzKxGIxJk6cyET2CbCgQYNfRGi1WqYv8+8YJRSJRLBYLHjvvffg9XqRnZ39+eQyCaWlpdi3bx+6urogFotTDoTftJWUlMBsNuPTTz9lQKPL5cLu3btx/fXXAwBmzZrFmLRTp04FAGzcuBGxWAwzZ878h85LE1iqCBPZaH2Zn7iFkSH+e8Lz8f/oGJRaR4vaNKkUfn8AiMdxYPcB+P1+5lyGw2FWUZRYxgqFAsFgEKFQCEajMUnqgNKmaRFLrCoAjBU0duxYNDc3M70yjUaDQCAArVbLtFtycnLYcTs6OhAKhZCVlQW9Xo+xY8dCp9MxplEkEmHsoKGhoSRHQyqVYmBggEVJqZIkLcJJ0Hp4eBhpaWnQarU4cuQIVCoVK9aQnp6O6upqbNy4EXa7HT6fDzNmzMCYMWPQ19fHCtCQTptKpYJWq4Xdbmdp3VKpFOnp6YwprdVq4ff7IZPJMDIywphYxBIi8DYWi0EkFiMei0AmlyMciUAiliDgD0AsOs5Co3ciEifrBsVjMUikkqSAh7Dt8akxxM6k6DQVt6FUbv57QqdU6DiMto3awuctN+W4dzKA6b/2xUbP3O12M1CB2kQwGITT6YTD4cCxY8fQ0tKC/Px8VlGY0v4pu0AqlbKCH5SizzNrvV4vA6vIQVcqlaiurkZ7ezvE4kShpJqaGuzduxddXV0AEu/WaDSeUHRGOO7x7Gz+/sj46DxVi+7q6mLsqvT0dMbUaW5uRldXF1v4U4o43YtGo0lKmSZmXltbGw4ePAi1Ws0W6qTjTACbMNWQv0YaO8PhMNMo5BmLmZmZUKlULJ2dB/hpTKVCfrRY5IXtaTv1NxoXqd/m5eXB5XKxrAORKMH+pPGZ3htlh/ApYJT6rtPpkJ2dzeYPYmNSaj0xtouKipCXl8eK/lF7E4vFjCmbmZnJ2IsERFOqdlpaGgNWCeDkAybUTr5LFo/HYTKZkJmZifHjx0MikcBut2Pnzp1YvHgxKisrsW3bNixfvvykx0kstt34xS9+gaamJvz85z+HWCxGRUUFawN+vx87duzAnj17kJmZiWuvvRY33HADpkyZgsLCQkSjUfT29qKrqwvZ2dmorKxERkYGTCYTIpEIFixYgLfffhs2mw1qtZoxaX0+H77//e/jpptuSmL4NDc3IxqNoqSkBA0NDdi5cyc2bNgAlUqFG264gfkidG2bN2/G008/jUmTJuHaa6+FXC7Hxo0b8ac//Qkmkwm/+MUvIBYnquKaTCY89dRTmDFjBrq7u9He3o5bb70VVqsVvb296O/vxx133MECjmRisRj5+fmoq6tDd3c3q3hvtVqTgJ1U74m3gwcP4s4778Tpp5+OlStXAkgEsFetWgWHw4E333wTYrEYlZWV2LBhA84//3zU1tYiMzMTANDf349IJIKpU6cydjKQ8OGWLVuGM844A8PDwzh69CiOHDmCtrY2fPrpp4yhWVBQAK/Xi1AohLlz52Ls2LEoLi6GyWTC9u3bEQ6HsX//fmRmZmLevHk4evQoioqKEIvFkJWVhcLCQuzfvx+zZs1iclUTJ05Ea2sr8vPz8emnn+Kuu+6CRCLB3XffDaVSieXLl3+n++poJvThhSCLENDhAS4hMETGAztCAIc/Dw8m8nMEDxCnAh6F5xFuEwKfo52LjPq9Il2OKVNrEI1H0HKsBdI0GaLRCPx+PyorK9E/0A+fJ8GS9ng8zA8nPz0rKwvd3d1sDtHr9bAMW2AbsSNNloZgIASpRIJskxlOhwN2qx0yWYKZL5FK0NHeie6uHhQWFCIUCEEiFSMnN4cFQykYSOnKdJ/EHqT5lipakyQBzaU0N/PvgIK0NH9SthGNJYRX0Hd4/ILATXqmdD1yuTyJ4cjr2VNgmdYVRDQRth86lxBApvPyIDlvqcBx/p3z7Ul4LOHfJ9uHb3/ftH1ngcd4PM4ifRkZGRgzZgw8Hg9jIFEEndKcvynjBy0CHqmwBJ+mRJ/Tzy87CZGjQ9/Lzs5mlYipAwYCAaYl9Oc//xm7du1iCyHajyxVoxYOwKmM9o1Gozh69Cg2bNhw0v2j0Sh27twJq9WK2tpaVoSmr68PkUgEubm5GD9+/H9MZNBsNuOHP/whrFYrhoaGYLPZ4PF4EAqFYLfbGfuN0ky/bvN4PGhtbWV/d3R0YP/+/dDr9SgsLMStt96KBx98EBUVFSgpKcG9996L3NxcnHfeeQCAqqoqLFu2DFdffTX+8Ic/IBwO46abbsIll1zyD1W0JpYLr9eXanIXOiH8tn8WmKbJiyYoAggHBwZx6NAhNsGPGTOGAeSk4UopmjTpklYKXZdwEqWJjpcRoIU3aSMCYALSlHpJzEO73c4E6aVSKSorK1mksK+vj4H4tLCJx+PQarUwGo3o6elBPB5nDgkFbohJCIAVkNFoNMjOzoZSqWTasVVVVWhra2NVIwm4mDp1Ko4cOcICHDU1NXA6nejr60MsFoPJZEJRUREMBgOTmKCU7tzcXEgkEng8HlgsFhQWFrLULoPBAJ/Px5hddrsdRqMRinQFglzxLnpfos+jnfQ+CETgK8ilmguE4yBN5vz4yjPcSAuP2s5obfAL/+ba32iBq1RtnT9vquP+11IbPTOPx8OKW1FAzuVysfTn+vp69Pb2IisrKwlsViqVUH2eyk+ap6RVTGm0fJEfcmyJjSSXy9kYU1RUhKGhIQSDQWRnZ2Pu3LloaGhgbDu1Ws2OLTS+DfCaSaMtvmi70+lEW1sbq9Sq0Wiwfft2eDweVqmaAgtUuVmr1bJz0P3Q31arFXv27EFeXh4yMjIwPDyMvr4+zJkzhwFjpO2Uaj6nRV48HkdFRQVEIhHTlKKCa6T3RosDfuHGBynpOfP7kJ/Dny8ejyMnJwfZ2dnw+XxMJ4tAwmAwCI/Hw5gTVNmaZCMoMEXsQ5lMhvT0dHg8HjgcDhYEpusqLCxkDEzSaxSJRIwpGQ6H4XQ6mYxERUUFE78HEtkh9H7JT+C1IL/rfZ8WmZMmTcKWLVswceJEJo8Qj8dxzTXX4Omnn2bFF0azSCSC559/Hm+99RYefPBBzJ49m6XH+v1+dHd3o7m5GZs3b4bX68Wtt96KJ554Am1tbfif//kfFoTasmULrrrqKrzxxhvIy8vDwoULIZPJmPTKNddcg1/84hew2+0oLCxkwcXrrrsODQ0NmDVrFmw2G1pbW9n65o033sDRo0dZIODpp59O0hfUaDRoamrCpk2bIJPJcO2110IkEsHhcODJJ5+E1+vF3//+dwwODkKr1cJqtSIUCuG8887DnXfeiY6ODlx44YWoq6vDwMAAY0NnZ2dDrVbjwQcfxKuvvgqDwQCRSISpU6fivffeQ1dXF2QyGcxmMyt6MZqWJvW9aDSK/fv348c//jEuvfRSzJ8/H2KxGEajEdXV1Xj77bdx7rnnYty4cbBarUxTXK1W4/Dhw9BoNKipqUE8HkdZWRk0Gg1GRkaSxkFqF7m5ucjNzcWCBQtYsKmrqwsDAwOQSqVQqVQwm83Izc1FU1MTLrvsMlx00UWIRCLo7OxEe3s7G/9aW1sxPDzMKlbv2LED06ZNw/bt25GXl4dgMIjKykom5XDRRRehubkZl112GbKzs/Gzn/0MOp0Oc+bMSTmff9dN6N+nCrDy4J1Qlmk08EU4VwjHzdGAS/4aUmXE8CYEGPnz8vsI74XWBbT+oeuTK+QoKCiASCRCa2trQvJHIUdXdxcyM7VQyNIZu1osFsNms8FoNCIQCLDCZeFwGF6vl/kdOp0ukWHk9iAajcHpcEIuV0Amk7N1BfkeAX+AFUfLyTWjv78fPp+PEWd4TUW+8Br5N/Q8iJVIsiDCFGchGAsc98/58UL43IXvkZ/3aRv/j9LVgePVu0kXWggwp2oHqWw0EJDv16P59alwlZOdl783/vzCc32T9k8Bj48++ijuuusu3HLLLXjmmWcAJBzx22+/Ha+//jqCwSCWLl2K3//+90kFJ7q7u3H99dfjs88+g1qtxhVXXIFHHnkkaYH3dRs5qVKpFHa7Hc8++yyys7NRV1eH6dOnQ6vVsgIK35TxHYX+GQyGlPv6/X7WMcl5StXBRgMlCbzgFx+xWAyHDh1i6Y8WiyVRBMNuR3d396joufAeAoEAPvnkE5SUlDD9NaHx0SG/34+GhgY8+uijsNlsKY/JX3dJSQnmzp2LGTNmwGAwQCqVoqKiImkgSnW+fzejQY+08nJycmC1WvHnP/8Z7e3taG9vZwP4N9VO6+rqsGDBAvY36S5eccUVePnll3HHHXfA6/XimmuugcPhwNy5c/Hxxx+zBSAA/O1vf8NNN92ERYsWQSwWY9WqVfjNb37zD19TqkgicGLkh59kUjkUX3YApn0JSOLZMceOHcOx5mMIfK7VlpWVhZGRERQXF0Ov1zNmY2dnJwoKCgAgqZAJVVQl/RK+EALdE03CIlEiXZMilqQhRBVXifHidDqRl5cHt9sNnU6Hjo4O5jzH44m0Akr79Hq9iMViLEVZKpWitLQUQIItQI4GkBCUN5lMbIwn4ep4PMHiLCgogNVqZWBbU1MTW8BHo1EUFRVBIpHg8OHDLD26oqICa9euRVtbG8aOHQu/34/MzEw4nU4GdNKCnhb74XAYNpuNsX/VajWCwSBLoxgYGIBerwdwPBWN0sbJeQt/7txQJUC+iA8fuRSJRYidxKkgZhQPRPJjEC1KKa1DqAUkbGMpGl/iXBAlFZFJGufiyU4UXZvQMafr/Ufs39kH+DJGz8ztdsPlcrHnFQgEYLfbYbFYcODAARw7dgwikQgzZszAuHHjGAhEKb7CyDn/vvmIPgGQxGiiNGypVAqXywWJRILs7GwMDw8zmYpJkyYxVjExFlLpVNO1k5POpxkJ96V7D4VC6OnpgdPpxOzZszE0NMRkGaZNm4be3l6YTCaml5iWlsaqcavV6hMAcJvNhi1btkCv12P27NmwWq2MyaXX6xmbixZXfDCWjAA8fkwko4IrtF+qfsRvFzrqwrmC34+20yIqFosxoJU+47/Ljx307KmdU/EcqVTKtCjz8/MZCyU9PR1OpxMul4steKhQj1wuZ5qfpDNHOoHCdiUcB74q+3fu/7w/u2TJErzyyis488wz8cEHH6CoqAgOhwO1tbUs2EqAFX2XbzMbN27Er371K1x11VU444wzWN8KhUJobW3F1q1b0dvbi0AggPPOOw8vvPAC3nrrLUyfPh333HMPZs2aBa1Wi8LCQhw+fBhmsxlHjhzBnDlzWFGUzs5OzJ8/HxMnTsTu3bshl8vR39+Pyy+/HFarFfv27UN/fz8kEgmsVivTX/7ggw9YQZO7774bZ555JmuXPT090Ol0+Pvf/46Wlhbmh1FhndbWVjzzzDNIT09Hbm4u3njjDbzyyiu48MILccsttyA9PR3jxo3DnDlzsHPnTjidTtx6663o7+/H9u3bcd5552Hz5s349a9/jXvuuSdRJfdz1u7w8DA+++wzzJo1C0NDQ+jt7cW4ceNGDaJFo1Hs2LEDd955J84//3zMmzcP+fn5iMUS+nNpaWlYu3Ytk/JxuVyora3F3//+d1gsFmRnZzMN08LCQhw7dgxZWVloaWnB4sWLTwA9+XlbJBIxfeqJEyeeMB6MHz8et9xyC5566in89Kc/xQcffACbzQaDwYCWlhbY7XYUFxdj9+7dMJlMSE9Px9GjR1m/d7vdTJ6ImN7V1dX45JNPsGjRIgwNDeEnP/kJXnjhBVY0iM7Pt+XvugmDrXwqbqpnNFpwVzhuC9NeU50z1TF4HcCTZRiMBjoKPydflPf96dr4uYW0jnNzc9Hd3c2KP9psVqiVGigUCjgcDkSjUWRnZ7P1BfnLkUgEGo2GbacgIgHjNNc5nU4WGCEAMSMjA2KxOBEkEwNKVSJDy2KxMLkYKpBKvjoRaMjH4VPWqe+TH8CzFSl4m4phyoOz/HYCa3l/hwc86b3R+6ZgoVgsZlkDPp8PWq02KcuSbx+j9cdUvlUqQPpkPgv/udCPT9VehG1ZiON80TV/HfYPz/J79+7F888/j4kTJyZtv+222/DBBx/gzTffRGZmJm666SasXLkS27dvB5DofMuXL4fZbMaOHTswMDCAH/zgB0hLS8PDDz/8z93Nl7B4PJ7EICwqKkJtbS37p9frRwWxvi4TiY6nKNPfAFhlTAAsdYYaGq/tF48nmE/9/f3Q6/XQaDRf2JhisRg8Hg80Gg0kEglyc3OZEDQ/gNtsNnz00Ud45ZVXklKweOMd9t/+9rdoaGjA2WefjaqqKuakE0MgGAzCarWiu7sbO3bswKFDh1hqWarJgAd5Wlpa0NnZiS1btmDWrFmYNm0axo4dy659tElAeMx/FxsZGcH777+PtLQ0GAwGzJ07F4sWLUJDQwMee+wxSCQSZGZmfiP3NH/+/JOCcyKRCPfffz/uv//+UffR6/V47bXXvpLrkQgWzCdbZH0RYP5ljdolRQiJfr99+3a0trYi22hCAAnWqtfrRV9fX0L4XCwGRCL4/X4MDAygqKgImZmZrAqcRCKB0+mESqWC1+tlGm+phKVpggyFQnC5XMjKyoLL5WKFlkgbsqqqCtFoFHV1dUw7raKiAiMjI6zqslicEHamaqfRaJSBfOFwmGmiZGdns2JHcrkcxcXFGBwchMfjQVZWFkwmE0sXFIlEjOHocDhQVlYGt9uN999/H+eeey6MRiPEYjHTbmxvb4fL5YLJZIJCoYDT6UQ0GkVjYyMqKirg9XqRmZkJmy2hx+jxeNi15uTkMACRUgtp0RYIBBiTKBKNQPo5C5SAILvdDoNeD//nEV4Caok5SkEqBiBEE1Wn+bZA7YgHGchRIccJOK4VRw7NaG0z5WfxOCBoqsIFEgDEYzFglLGPPzZZAkz9cnPdv7sP8GVMJBKxYiDkqEYiEVgsFjidTsZoKi0txYwZM5geLzFjCASkOZremd/vZ2mxvN4aATB8cRJKU9JqtUxvOTc3l6VlE3Oou7ubpXOTP0EBLCB5XufZfaOl/ESjUTidTrS3t6O4uJgtSAYGBlhxmMzMTDaOUUCC/Agaj2jB5PV6sWPHDng8HsyaNYs57yMjI5gzZw4rDEcLCl6Lkq5L+FMYdBQuNk91IcBbKrboaKBIqm3Cf/y+qRafkyZNOiEQwPs+9A758/H3y7/XU+nz/6z9J/X/8vJyTJ48GQ0NDTCbzWhqakIkEoHRaERhYSE2b96MyZMnp/QpBgcHcdddd6GmpgYLFixga4doNIrBwUHs2rUL69atQ35+Pm6++WY89thj6OjogEQiwb59+6BQKOB2uxk7tb6+HtXV1fD7/XjxxRdxySWXIDs7G6WlpYjH47jjjjtw5ZVXYnBwEJFIBDk5Ofj0008xMDCAAwcOQKPRwGg0YuvWrcjMzMSBAwfgcDhw8cUXY/Xq1SxNPxAIoKWlBevWrcOePXvwzDPPsHM899xzeOutt3DFFVegtLQUdrsdR44cwUsvvYQpU6bgxz/+MRQKBVukU2Ges88+GxUVFZg6dSoikQg+/PBDzJ8/H/X19XjnnXewcuVKttYoLy/Hn/70J6xduxZ5eXlobGxEWloa063nn3EsFsN7772Hu+66C6tXr8Y555yDrKws2Gw2HDhwAG63GxaLhfkEsVgMfX190Ol0cDgcOHz4MObNm8f6hd/vx+DgIPLy8nDvvfciFArhyiuvRFZWFgCcMI4I52d+XKHfL7roIvy///f/mIamRqNhwQMKKrW2tiI9PR0ZGRmIxWKMCbl48WLs2LEDs2fPxsjICNN7nTt3Lnbv3o3a2loYjUZcd911eOmll1BVVfWNZuL9Oxk/r5EJwRd+u/C90ud8MFYI8vDbhEG9JD8snpzKy59TCJIKx23+OPz+QmCVL9hC+5nNZtYHYrEYBgcHWXFHvzfAgpnxeJxldpJGO10DabKLRAmSlt/vZz6tTCaD1+uFSqVimpAUFKN1gsfjAURxOJ1OeDweZGRkQCaTwWazoaCggK2b6Ht0XrofAmyJXEVkAR4UJN+B/BCqoA0kF3whQgedg46XionKz78SiYRdGy+fQlrIqeb2VHPvaISC0UBHHjAX+gKnuoYV3ttoa1xhu/wmMK9/CHj0eDy47LLL8Mc//hEPPvgg2+50OvHiiy/itddew8KFCwEAf/7zn1FVVYVdu3ahtrYW69evR1NTEz755BNkZ2dj8uTJeOCBB3DnnXfil7/85TdWnZc6Ez3oMWPGsAqnFC34Ji2VQ0NG7CFiT1BEwmazsd/tdjsmTpyIcDiMQ4cOYfLkyV+YfksNjQcojUYjsrKyWKXII0eOYPfu3aivr8exY8eSwI9UJpPJkJmZCZ/Phy1btmDLli0M4OUjEHxKEYnfSiQSuFyuEzoX/T1+/HiUlZWxFAqbzYbXX38df/vb31hEduLEiTjttNMwfvx45OTkMJZJKqfh38X0ej3OOussHDt2DIcOHUJjYyN6enrQ29vLGCV8eu53ycQp2DCp2o9wwuEnudH2S2WpJinqE3K5HAcOHEBHRwcUCgW8Xi+0Wi2TLDAYDBCLxIjH4oiLEg7J+PHjWTo06UtRQSmbzQa5XM7E5bVaLUsFpslQJDqeju3xeJieIgUlQqEQdDpdUro1VWkmlnQgEIBSqWSVqoeGhmA0GlnBGrVazfornZdYN+QM6PV6tLS04OjRo5g7dy5zMsRiMUKhEANSxWIxxo0bh56eHqxbtw7nnHMOlEolu29KV1SpVDAYDFAoFOjp6UFJSQlLdyOQhIThSfyZqmrb7XbG3CTWYl9fH5u4ZTIZHE4nY4USY9jt9jCHJxqNQq/XM804Su2gsSQWi0EkSd1GaH8h64lSZmkM5CPUqZwM3hE9/vuJ4KRInAqoEOFkQ8EJwIc4cZxTtf8EH+DLWCQSYSB4PJ5g9ROjb2BgAHv37sWMGTNQWVkJlUrFZAtobqV/5ACHw2EmAxAKhRgwTn2fBNHJqSYwMhQKsfRd0k4jvUibzYaioiKMjIxgZGQEWq0WGo2GgZl0TGFqF7+I4cdSar/EdnS5XKisrGSp3GPGjMHBgwfh9/sxd+5cVFVVJfkSJFNDWoY0Vhw4cAChUAgTJ06ESqVCKBRCX18fq/zKaw/SuMgvvPgFoXCxdjLH/KuwVIBhKnDiy1zDaEFRfoHKmxCETXXOr9sP+E/r/zKZDLfccgvuvvtuTJ06FVu3bsW6deuwfPlyVFdXY8+ePUzmRGh9fX3o7OzEOeeck8RG8/l82Lx5M/r7+1FZWYkVK1bgwQcfxPvvv49rrrkG48aNw9q1axEMBtHT04NAIIC2tjaEw2Hs3r0bjz32GF555RUsXboUJpMJEomEFSG55JJL8Kc//QlqtRotLS0sO0kkEmHRokXo6+vD8PAw7HY7gASwescdd0Aul2P79u0Qi8Xo7+/HRx99hM2bN+OnP/0pcnJyEAgE0NDQgDVr1kCv1+Pqq69GNBpFW1sbnn32WeTn5+ORRx5hOtODg4NwOp3o7e1FeXk5fvSjH+Hdd9+Fy+XCihUrkJeXhzVr1mDlypV44oknMHnyZPT19aG/v58VkAoEAgiHw7jzzjshEolw55134rLLLmMEi1gsUeDmiSeewA9/+ENcc801OHDgAFpaWuB0OjE8PIz169czn6etrQ1lZWXo7+9HdnY2K4jX398PnU6HYDAItVqNiooKBAIBzJ49G9nZ2fj5z3+Oq666ChMnTmQyM6fSn/nx7pFHHsHFF1+MiooKppcnEiWCzEVFReju7kZOTg6cn/sfQ0NDWLBgAQMXaV2Tnp6OnJwciMVilJSUwG63Y8GCBbDb7bjzzjvx8ssvw2g0ftXd4N/eRgve8uOocFwVBrBSHVMIDAHHU16FgBYdSxjUO9nclGr7ib5fsi5lKsCSfIxoNAqz2YxAIJH2rFKp2NxJAcnMzEw2N1MKsUQiQXp6OvMb4vE4WydkZGTAYrFALBbDZDIxRjWQWEdRITlaizidToilYkQiYZaxQQX5KGBCLGTeNxeyOXk/he6N7pu0IHmJGqF/Q74E+dw0jvPPj8gBwhRsKvLG+/10LaFQKKm2gjAYMRrQx+872j7CNkr7CxmfXzTPp2q3qa5BCJ5/3fYPAY833ngjli9fjsWLFyc5HfX19QiHw1i8eDHbVllZicLCQuzcuRO1tbXYuXMnqqurk9Iuli5diuuvvx6NjY2oqak54XzBYDCp2h7pK/0zRo1cIpFAqVRi0qRJWLZsGbRaLSwWCzIzM0dNXx3NUfyqjR8oSBOovb0d69atQ2dnJ4qKijBv3jyUlpYiOzsb8XgitZFEiE8GZvIdEwCrPHvs2DHs37+fsbZoscV/fzSAZ8KECbjlllswfvx4WK1W1NfX48iRI0kVJikdVCQSsSqYpaWlTKT9L3/5C6smxz/feDyOtrY2iEQizJs3D7W1tSx99fDhw2hoaEBzczM+/PBDbNq0CUqlErW1tSgvL8ecOXMwbty4lMy4f2WjaBQAmEwmGAwGmM1mRCIRFBQUYOvWrbBarVCr1f8SxWW+DUs1SPJtX/g5H0miffnJZLRFpLDN84u/tM81QORpMrS1tsGg07MFPgH4CoUC+fn56O3thSZDg/z8fMY8oAU5VZam4ActwNLS0piem06nS0odoEgfMRLdbjfTaUxLS2MTLIEOhYWFqKurw6FDh2AwGDB16lQmdWA0GlFRUQGFQsGAla6uLgZmkgNCWiwEmFDKX1VVFZqbm9HS0oKKigrk5ORAIpFAp9Ohs7OTsbWNRiPOOOMMbN++HYcPH4Zer4dSqUQgEEBeXh5L89br9UkMbrqftLQ0ZGdnY3BwkL0HqvoOJBg1pKUXiUYRCAURCAWh1mjgDwQgV8ghigOxSBRiiBD0BxLPVSRmaVoEqtK4S++eHBmpVIpo/Hh0m3eWeJ1RPgUfACtAIUztP1k0kj8vtWFK8xYhcR/8vrFYDCIAIlFqXTz+2Mc7Rhzx6Kk7HP8JPsAXGf+sKEhG1dtJKsFut6O+vh5Tpkxh+nqkVUaRej7dmYqMkFQKLUqJEUBtIxQKsf5G6bg0FzidziQtQ2IYlpaWoq2tDZWVlWhqaoJWq4VarWYMZr6CK2m80XURWC502uPxBENzaGiIAfTUp5VKJebMmYPS0lJUVFQwlieZ0ImPxWLo7OxER0cHamtr2dhBUi7UN/gFBx2HPwaN18IUKgBM3kCYGpdKiuMfAQlPZqmAv5MtPlJ9L9X2UwE9vmn7pvs/8PWOASKRCNXV1aiqqmLyI0NDQxgcHMSZZ56J2267jUmU8BaNRtHV1YWpU6fiN7/5DT777DMsXLgQ559/PoBEtkp5eTkyMjLw9NNP46KLLmLVky+55BI89dRT+Pvf/45du3YxeQ6n04m0tDQ88cQTKC4uxp49e5Cfn88KLlVXV+P000/Hjh07GIDncDjg8/kwMjICl8uFrq4upufs8/nw1FNPoaCgABaLBYODg1Cr1airq0NPTw8WLVrEKlDv2bMHf/jDH2CxWPDXv/4V+/fvR09PDzZs2AC/349XX30V2dnZ8Pv9aGxshN/vx3vvvYfPPvsMTz75JGw2Gzo6OhCPx/HCCy/gtttug0gkYgGKK6+8EgMDA5gwYQKKi4shl8uZPAPplz7zzDPYvHkznnjiCZhMJrz00kv44x//iCuvvBLV1dUIhUIsbb2npwcdHR1obGzE0qVLIRaLkZ2djYqKCvzf//0famtrsW3bNiiVStTV1WHSpEmor6/H9OnT0d3djfz8fDQ2NmLChAlYvXo1PvjgA9TV1WH16tWMMMG3kS9qQ9OnT8e9996Lhx56CI888gg0Gg327duHhoYG9PX1Yfr06RgZGcHAwADC4TBmzpyJhoYGVFdX49ChQwCA9PR0JnVVUFCAyspKRCIRNDQ0YNmyZTh06BCefPJJPPDAA0nj+DdljzzyCP7v//4PR48eRXp6OmbPno3HHnsMY8eOZft8W3ILPGAj9HWE4B3v4wuDcKmCcrRdqAfKf4efZ3gZJ54JKQSUhOngQn9ztPfL3yu/juG1i/Py8uBwOHDkyBGkK9LhcDihVqmTsn0CgQCcLgdUaiUyMjJY9enh4WF4PB6WsUUMSCo4W1xcDIfNwUgGNDf7/X7YHXYEAv7Px2sRAvIEy7KwsBDKdCXiMTD/3WQyMQBUCN4RICh8T0Bi7OWrYdO985qaFNild0A/+crVBDDSNgIoyXen7/N+PhWl49vByeb6VO1SOL8LwcrRfHXhez9VG23/VO3+67Yv3cNff/11NDQ0YO/evSd8Njg4CJlMxhaAZLRIpH34wYc+p89S2SOPPIL77rvvy17qSY0aZVpaGtMc+e1vf4umpiYYDAb88pe/PGXG4Ndp0WgUw8PDaG5uZvpsixYtgtlsZlGMnp4eHD16FHq9HjNmzDiBgp8qokMsyebmZjQ0NODQoUNobm5GX19fUocTRlf445HJZDKsWrUKN998M0wmE6RSKfLz85kWCq99ByRrDtGxASAnJwc///nPMXv2bDzzzDNMGJf2DQQCOHToEA4fPoyXXnoJEyZMwOLFi7Fw4UJcfvnl8Pv96OzsRENDAw4ePIiSkhKceeaZLHLqcrlgsViQk5PzjWp3/jNGDDexWIympiZkZWVh0aJFqKurYyCUXq9PSrn/rpmwH44WtSQTMmaEIKVw8hMeRzg5iCCCVJIAqtQqFfr7+yGVSjF37lxIpVLs2bMHarWapSrodDqEQiGo1WoWaSSgUq/Xo7Ozk1UnDQaD0Gg0yMrKgtVqRU9PDzIyMpCbm8sW7b29vQxgzMjIYBWzJRIJ0y3iUzkLCgpgMBjQ39+PkZERJlI/MjKCpqYmGI1G5oCQHhExlyglOxQKscqQOp2ORUmnTZuGY8eOoaOjAyKRiAVNsrOz0draitLSUmg0GuTk5OCss87CwMAAhoeHWXoVBU9kMhmys7PZGOTz+Rh7mXTPFAoFDAYDhoeHWZ8eGBhgDOpgMAhpWoJhZrVaoVKpEI1FIZWmsedPjPFgMMgqYlMEFQADfyg1jVJfRWIxJOLjFetIH4cAS0qL5J1AYPRKiqkcq9HaurA9C9upWCwGBA5OKsdltDb9Rfaf4gOcqoXDYebkElPR5/NBIpGgra0NGo0GJSUlyMzMZG2NUqspBYl3lglo9Pl8jJVA/Z8CEbFYorgb+SDCyo6BQIBlZvAOf2FhIXp6emAwGBJBDo0GKpWKAY90HGEgJdUCjK4XOD42UpXpcDgMlUqFuXPnMgYkzyKgxQLf/r1eL5qbmzF58mT2bCiNm8YK4PicR8BsKoedPza/Dy0iCNgFkLR4ETLZ/xn/7VS++20Bg1+nfRv9H/j6x4C0tDR8//vfx1133cXSx6lKu1wuR3NzM2bMmJHUhlwuF/785z/j2muvZYvonTt34rXXXsPUqVNx2mmnYe/evTh48CB+9rOfYcGCBYhGoygvL8fzzz+Puro6nHHGGZg5cyb27NmDjIwMaDQa5geMHz8eoVAIn376Kc444ww2B06ePBk/+clPcN9996Gurg6RSAQjIyMwm83o6upCNBplRVC+973voba2Fj09PWhubobD4YDX68XRo0ehVqvxy1/+EgaDAVarFX/961+xceNG3HvvvWx94XK50NHRgeeffx55eXkYGhpCJBJBd3c3Dhw4gPfffx+/+MUvUFpaikOHDmH58uXYu3cvMjIymA7srbfeCpFIhJaWFqxZswY9PT1oaGgAAKYpHY8nCr7odDps2rQJ999/P1asWIEnnngCP/3pTzF9+nSkp6fjpZdegk6nQ319Pfbs2QOn04mMjAyUlpZiy5YtGB4exuHDh+FwONDa2gqdToeBgQGkp6dj+/btmD9/PmKxGDQaDQMm3nvvPXi9XqxYsQJbtmzBE088gWuvvRZGozGlHziaSSQSXH755ejt7cXDDz+MJ554AocOHYJSqYTf70dfXx8cDgfT4Ozs7MSxY8fQ1tbGpGKAhDwPnyViNBoRjUYxMjKCO+64A7/85S+xbt06nHnmmd+4LvLmzZtx4403Yvr06YhEIvjf//1fLFmyBE1NTUzT/9uWW0gF4KTye072PX5dwIOJfAYdzz5LJQciXFPQZ0JQU0iEEYKi/PxGx+OvQej/0f7p6emYNGkSxGIxjh5phjHLCJvNBr1eh8GhIXR3dcNgMMDpdgLxONIVSgwNDSEej0OlUiESiWBgYAAZGRlsjMnPz8fg4CA62jtQkF8Au9MOg8EAmUwGi8UCpVKJkpISOF0OWEdscLvcEEGMSDiKvr4+5OflIxgIIdtswrFjx2Cz2TBhwgS2xqB5mrJDUoGqwPF5nWRohP42EXeEKfb0bMhfEaZmS6VSBIPBJKCRBzR5X56uVei3C4FG4ZpytPbJE1tS+fp8Vkoqv42/v5OBjHy7SbXG/brtS41YPT09uOWWW7Bhw4akYhFft911112siAWQmOypIMM/Y6T/dfDgQXR0dMDr9UIul+Pee+9FUVHRScEMouxS2vBX9bKEDZIGGpp0eZpxV1cXgsEg9u/fj8zMzBOeCX+saDTKIqF1dXXYtWsXmpqaYLFYWCcMBAIsGkAODk2EvPGdKDs7G7fddhvOP/98BnIIB0FhOqtwQOWPq1AocOaZZ2LixIlMZ4ao2LRPPJ7Qxtq7dy/27t2LV155BfPnz8fMmTMxa9YsJgJOGhQEBnwbKfT/jNHzABLvLz8/H/39/XjvvfegUChw1llnYf/+/YzR8p00bjLi/x3/eHSqOYDjFY257xL752Rge9IlcGmEZrMZGzduxLZt27B+/XpcddVVyM/Ph0KhwPDwMCssQxopfr8fbrcbWq0WGRkZLJ3SarUiJycHIpGIAYlmsxl+vx8Oh4Npw1HfouNR9DEtLQ0ej4dVjiOwMBAIQKFQwOVywWg0QqfTwWazwWq1orS0lFVfraqqQjAYxODgII4cOQKRSISJEycyrVa5XI7S0lJWEIa05gKBAHJychAMBuF2uyESidh4kp+fj0OHDqG6uhoqlQoqlQrl5eUYHh5mjoLP52PgBo1/BLRQ2rlUKoXD4UBeXh7EYjEDZu12OwNfqRqf3enA0NAQA2sTqdoRpgNF2o1UiTYjIyOhTQMwIAkAA0OpkixEgPTzwBUBj9RXvV4vFAoFA4l4vaoTm2/qaCMfRU0FVPJtOlW7FolE4LUghc6u8BpO1f7TfIDRjF84kNQJAFaASSRKaJeOjIywitVqtRq9vb3se3zVd5EowXaMRBJtz263Q6/XM6Cb122mtKFIJMKYAMDxyswajQZut5uNXeR/kOxGRUUFotEo9uzZA7vdzpiUWVlZzF/hgTjekecXUsRqporNPCuSdGeBxNhD4CrflvgFWzweR2dnJ/Lz81FUVAS/388A2OHhYRiNRlgsFrZQoGwU4YILODHtiD6jPkOMaboG+keam18GSPivJdu31f+Br3cMoPYwbtw4Jn0iFouxYcMGXHHFFZgxYwY2b96MGTNmJH0vGAxiaGgIhYWFOO200/DOO+8wRnRvby/uu+8+XHfddXjllVfYfC4Wi3HppZfizDPPxMcff4wXXngBIyMjuOSSS1BVVYXt27ejv78fRqMRb7zxBi655BLE43H88Y9/xNVXX4309HSUl5cz2ZKNGzcygMzpdGJwcJDJtmRnZ+P73/8+hoaGUFdXh2AwiP7+fnR3d6OzsxNPPvkk06p988038frrr2PFihVYvXo1tm7dirq6Onz88cf42c9+xjQu29raoFQqcfjwYbz44otYuHAhzjnnHASDQcybNw9SqRTjxo1DTU0NhoeHUVNTg71792Ls2LGorKzE1VdfjUgkgoqKCuzcuRMKhYIV0BOLxRgZGcHBgwfR1NSE/fv3IxAI4A9/+AP279+PaDSKzZs3Y+XKlYyFXlRUhLPOOgtbtmzBH/7wB0ycOBGHDx/GI488gnXr1iEQCEClUqGjowNZWVlMmqK4uBhisRhZWVnIz8+HTqfDO++8gylTpkAqleLOO+/EddddhxkzZpwAFpxs/JDJZLjjjjvg8/nw85//HFdccQXa2trgcDjQ3t4OjUYDj8fDtEMLCwtZ4RzK5nC5XEy70+v1wmg0YsaMGSgtLYVer8cNN9yAX/3qV6isrGSFNb/our4q+/jjj5P+fvnll2EymVBfX4/TTz/9G5dbGM23SfXOTgVs5H0wOi7Nx/ycRPvwc41wbStMjeXnsVRMx9F8Mdou1PgVpnmnSuuWyWSYPHky9Ho9du3chZw8MwYHhxCJhiGSAK3tLTCbzRgeHgZidhaAJz+HCp1pNBqmu56Xl4eenh4MWgYTwVFRHL6AF1mmLPi8XvT39UGeLkdFeTncbg96enoAAAFfAIODQ9Dr9HA6nVCqlHA6nWhpaUFpaSmTVuH1z3lJJ+GzoyAlgZNAMhOSD4DyEkiUPcV/R/jueP+IzsenY9O7oHdA/hldH70T/n3wbYW288ClkD0pxEtSAZJfRFY4mX0RSefrsi8FPNbX18NisWDKlClsWzQaxZYtW/Db3/4W69atQygUgsPhSIp4Dg0NwWw2A0hEcvbs2ZN03KGhIfZZKpPL5SdUHPsqTCaTMTp9RUUFDh48iEgkgg8++ABlZWWsylgqS9Vgv+oXRgNeVlYWIpEIhoaGGOuG9BHEYjGKiorQ29vLqm0WFBQgHo8zuvSBAwewdetW1NfXsxQFvmHznZo6HKU6j3ZPaWlpmDdvHn7yk59g7NixSQsYHnHnB+nRkHXhPsSY/MUvfoE5c+bgySefZOkbqYAltVqNgwcP4p133kF2djaWLFmCs846C2PHjk1amEml0lMquPOvZPwiS6vVIh6PY+XKldi2bRsee+wx5sAImRzfVaOJgE/DOxl4yE8wwm3C/YQODttHdHyCKy0tRVFREerq6nDgwAH88pe/xJVXXona2lp8+OGHmDdvHkQiEfLy8pg4usVigUKhgFKpZIUkqNqkSqWCy+ViAAQxi6xWa0Io+nMHgVhH1NZ9Ph9EouMaaaQXaTQa4fF4YDAYcPDgQdbX0tPTGegXDAZRX1+PvLw8lJaWoqysDBaLBb29vfD5fCyFGgBjRdjtdmg0GsakzMzMhFgsZmCox+OBWq2GyWTCrl27MGfOHAaCqFQqdHd3o6ysLJGm8fmxhoeHEQgEWPEkh8PBoqIU9KFxyuPxMCeEUsF7e3sRioRZARtifVFFbr/fz7QvRSIRi5rSO/Z4PFAqlUx3BkiwM8LhMLw+L8IcM4tvb/Q3OVB8YRm+nQqdCvpHjgzvsJwKAM631QTo+MX7fhGwKbT/NB9AaMJnQGAhzZEkQaBSqeB0OuF2u1FeXg6dTsfaAjFuqf1T/6S+6nQ6odVqWQDAYDCwfspnB0SjUfh8PpZiSSnXVDDK7/dDrVazKvbEulWr1SxwsH//flbpPiMjg7E2hcxHamM8w8Dn88HlcuHgwYMYHBzE2LFjmawDATPk5AOpF1L0k4IPubm5zEGnIEs8HkdxcTF6e3uTJFaA42CiUH+JjK6bgAt6ZsSCoOcolUoZWzvVmJ/K/p38hG/Kvq3+D3x9YwDvf8rlcnzve9/D66+/jjPOOAOxWAxDQ0P4wQ9+gMceewzhcDjpGrRaLdLS0vD222/Dbrfjf//3f5GWlgaz2QytVovzzz8ftbW1yM/PP6E96fV6XHLJJVi2bBnWrFmDl156Ca+//jqWLl2K888/H8FgEJ999hnWrFmDu+++G8FgEGvXrsXKlSshlUrh9Xpx8803Y/fu3WxecjgcUCqVbP5YsmQJMjIysHfvXvT09KCnpwdHjhxBU1MT7r//fpx22mmw2+3YsWMHXn31VRQVFeGGG27AoUOH0N3djbVr1+Kcc87BihUr0NXVBZPJhJGREcRiMezatQsqlQrXX3899u3bh7S0NJSXlyMtLQ2zZ89mMlaFhYWYMGFCUgCUsic0Gg3MZjP6+vqQmZmJPXv24NJLL4XFYoFEIsHg4CBrX7t370Z/fz9CoRDef/99AIlU9tNOOw0fffQRMjIymBTVp59+ipkzZ+J73/se1Go1PvzwQxw5cgR79uxBSUkJpk+fjp6eHlYJPjMzEx9++CEmTJiAQCCAcePGYfXq1bj33ntx6623YsmSJUkM7C9qTwqFAvfccw8CgQDeeecdPPbYY3jjjTewdetWuN1uxGIxNDQ0QCaTwWg0wul0wmw2o7+/n/lyDocDu3fvZoFUk8mE3Nxc7N27F4sWLUJXVxeeeOIJPP3002xs+zbM6XQCSLRn4JuXWxECRqnAH6EJ15xCVtpoJgQzhZ8RoCRM7U3SBhf4cwSgfdF10v50b6naovDcNMdLJBIUFxcjLS0NW7ZsgUajBhBHYWEh0tLSMDg4CL1OD+uIDfF4nI0h8XicZV35/X7IZLJE5lA0iuLiYvT09ECpUsLrSxR9HBkZgVwuR1FJESwWC1rb2pBlyMK4cePgdrsxMjICj9uDSDgCiVSMSDQClUqFQCCArq4ulJaWMl+bzyDi2YxkPJsxlX8szLLkgUECJekZU2CYLwZJ741IHgDYuorOL3w3QpCQ3y70+fnr5d8zD1IKMRShCQOyJwtACM/7bfo3Xwp4XLRoEdOhILvyyitRWVmJO++8k1Uq+vTTT7Fq1SoAQHNzM7q7uzFr1iwAwKxZs/DQQw/BYrHAZDIBADZs2ICMjAyMGzfuq7inUzZyRuPxOA4cOIDy8nKce+65WL58OUwmE3uRQq0GfoH4dQz2/CLUYrGwhYtSqYTBYEAsFkNvby+2bNkCv9+P+fPns8idXC5HY2Mj9uzZgy1btuDQoUPMURht0hTSwVMh6mRisRgFBQW47rrrsGLFCqhUqqTjphq8R/udN2GnIEbFsmXLUFlZiV/96lf45JNPEI/HWSRGoVAgIyODVfM1m81oa2vDc889h7/97W+YMWMGVq5cidmzZ7OCG6OxL79OEw4awoHki54JDZLxeBw2mw2vvfYaenp62CRsNpu/04skfnCm/slHq0abvIHj0TT+M5p0hH17tME/Go0wIEChUGDx4sXo6+vDtm3bYLVa8eqrr+LDDz+E2+3G6aefDplMxirDElBA6ZA9PT1JBaQ8Hg9CoRDTWDMajQiHwxgZGYHNZoNGo2ECzQqFgumRUFolkAgS0OROGqtWqxUlJSU4fPgw4vFEipPBYGATvNvtZgxJkqNQKpVwu93o7+9Hbm4utFotuy6FQoGRkRGo1WoUFBQwFiUxwjIyMuB0OhmQc/DgQUybNg1AojhGf38/gMRCbmBgALFYosqt3+/HjBkzkJ+fz8CTzs5OVil4cHCQLXCpejXpZIXDYRiyEpp7xEpzOBwYGR6GSqliFfwIAHW73cjMzGTPnweCCKD0er2JAIZag2A4xNhwVEiHb5NisTgpzZZvR3RcYQSbvitMqRktRVvo1NB3EI8jHjtRhFzYllM5Qyez/zQfgDfheyAgj7IAKDhHzGSHw4GsrCwUFxcjHk9Ut6U05FgshoyMDOa4U+o0Oe86nQ5ut5uBggTOUcAQACuaxL8jAvvoWjweDxQKBSQSCWujVJxp6tSpiMViOHLkCCZPngyXy8UCArzjnWqcGxoawsDAAFpaWphupNfrRTAYZPdAFSRJloVYKsRSJpkCsVjMFs7k4FNBLJvNBo/HA6lUygIpdE38Ioo3IRuYBxGDwSBjQtE+YrGYgUWUukhsB77/pVqMkn2X51fe/lP7P99eTj/9dPz617+G1WplmUDFxcXweDxMd49MKpWioqICDocD6enpWLt2LW644QaMGzcOra2tMBqNSczQVAFNnU6Hq666Cueddx7++te/Mp3z2tpazJw5EzKZDA888ADuvvtuWK1WbN++HXPnzsWECRPQ39+PG264AU8//TQrNjU4OAiv1wuZTIYzzzwT4XAYBw8exMGDB9Hc3AyLxYIVK1Zg1apVcDqd2Lt3L9auXQu3243nnnsOubm5eO6551BfXw+1Wo3rr78efr8fVqsVnZ2d2Lt3L3p7e3H48GH8/ve/R09PD3bv3o0xY8agubkZ+fn5mD17NpRKJZt3eLCWxg6xWIy8vDzE43H2TGtrayGXyxkL0GQywePxYMyYMVi8eDEyMjJw7NgxVj1337596OrqwoEDB1BcXIxNmzaxwhbvv/8+GhoaoNVqcdppp7Gg8BtvvMEqg3u9XphMJhbEf/PNN/Haa69h9uzZWL16NR5//HE88MADcDgcuOiii04oVDlaGxKJRFCr1bjvvvtw991346mnnsLq1auhUCjYmozazKFDhzB27FjGVG1sbGRFvHw+H9MIf/3113HDDTfA6/Vix44dGDt2LNavX48//vGP+PGPf/ytAI+xWAy33nor5syZgwkTJgD49uRWUo3f/BwhHM+F74sHe8iE30nFvE/l36UCH1Otr3nwS3juVNc5GuZA+xEBQnhP5M/m5eVhyZIl2LRpE7suqggfjiSKqJBf4vf7mY9vMBhgMplY0Ty5XA6DwQCHw4HhYQtycnMwNDTEsgoT6dx6qJQq2Kx2eL1eFBUVITMzEx0dHYwpXjWuKkkfcmhoiBVVIh+HBwGFvguvVUmsVPqc95sJdOSfHZ/iLixoAxxPpZbJZOw8UqmUVQQXAtb8e+D98S/ql0IfRvhehfsK25Bw/5P586kAzm/DvhTwqNFo2OBCRtVHaftVV12Fn/zkJ9Dr9cjIyMCPf/xjzJo1C7W1tQCAJUuWYNy4cbj88svx+OOPY3BwEPfccw9uvPHGb4TRwBsVJJDJZLjuuuuQn5+P1tZWdHV1obCwkFH/KdpOjj0ZObCnEgX7MkYaYyKRCJmZmazKtM1mw9DQEHp7e1FQUICZM2eyojJHjx7Fu+++ix07duDYsWPwer1JLIFUOgRkqZDyVAvSjIwMrFq1CqtXr2ap6F/1vQuvSyKRoLS0FI8++ijWr1+PNWvW4PDhwwiHwxgzZkyicpZYjGPHjjHHSyRKsJU+/fRTbN68GSUlJVi2bBmWL1+OioqKpCqy/Lm+ajsVBtGpft/v9+P9999Hf38/S5mrr68HkIg0ftsRjG/LhI+Y2gw9Cz7qKWzb9Lsw8jXas0wF3sTjcYglEgRDIUikUoQjYeTk5OCcc85hWktdXV0IhUJYuXIlmxBJg8lutzPwIBgMwmazQSQSIScnB1arlaUvOxwOpoemUqnYAjsQCKCoqIilbxP7CUgswknDSCaTwePxYP/+/SgtLUU8ntBSnD59Otrb21kKRUFBAXJzcxEMBjEwMACLxQK5XI7c3FzGDIhEImhra0NhYSHKy8vxl7/8BePHjwcAJkZtNpsRDodhsVgwNDSE4uJiZGRkYGhoCBqNBu3t7TCbzcjOzoZEImFBg3HjxqGrqwtqtRo2mw2xWAyTJk1CMBiE1+uF2+1GPB5HUVERPB4PrFYrK07jcDjgdruh0WgQi8UYyJAmTUssVEJhiEViNB87hpKiYmh1OubsUcqH3W6H2WyGWCyG3+9nAAXPQotGo/AHAvAH/KzYBu/cEeBLejX0blKxrVIBjIjHEQcgggix+PFUUWHQhL6HOBi5kW1P/i/lWMQ75idbUPH2n+YDjGaxWAxer5cxVj0eD6LRKAsCulwuDA8Po6CggOkFkwNMeq4GgwGBQIA51tR+zGYzgsEgqypJKcCkAUva02Qej4dJhtCCGziuRURFWYjZR8xIkUiEmpoaWK1WdHV1MWkZ6hc0VgqB7GAwiG3btqGvr48VyvF4PMjMzGSLDZIeIGYvOfZ0bmrv1C/o+VBghJ4pFdVSqVQwmUwMkCTwkmcSpwLeaWFF/ZIAUyrGRZadnY0xY8awIAGBIiebo0/GHviu2n96/yef+6qrrsLHH3+MOXPm4PXXX8ftt9+OadOmoaWlJYm9KJFIcOmll+Kpp57CihUr8Kc//Qn79+9HQUEBKxBFgYRUxvvn2dnZuOWWW/C9730PH3/8Md5//338+te/htPphM/nw7333otnnnkGu3fvhsPhwPLly6FSqXDttdeivr6epcC63W52XJPJhK6uLjgcDjQ2NmJoaAj5+fm4++67MTg4iB07duCTTz7BoUOHsHLlSlRWVmLt2rVMD/K5555DZmYmNm7cCKlUis7OTrS1tWHTpk24+OKLIZPJmA8TiUSQmZmJvr4+rF+/nmUc5eTkMP1Wfu6jAg38gp+CNbS2AsDYRllZWQDAMnyOHDkCtVqNoqIiVFdX49VXX8Xll1/OCuQdPXoUDzzwAJqamuDxeFBRUQG3241LLrkEPT09uOqqq1BaWoqf/vSnUKlUUCqVuOGGG7Bo0SI88sgj+NWvfoU777wTTz31FK699lrk5+fjtNNOO+V2RG3p4YcfxuWXX46HHnoIP/vZz5CZmYn9+/djYGCAaVunp6ejpaUFp512GpqamuB0Opn0lVgsxt69ezF9+nT2XGtqavD2229j3rx5eP755zF79mzMnDnzS7X1r8JuvPFGHD58GNu2bfvazzWa1IKQOCDMFBlt3Uv78wE9od4i/zNVamwqMJH/m34X7s+nXwuDynx6rvC4wp/0Ow9c8udJBVzq9XrU1tYymaT8/HzI5XJ0dXWhoKAAw8PDsNlsyMzMRG9vLwwGA0ZGRpCVlQWj0cikV8gnVSpV8Pl8yM3NZfN7QUFBArOw2jF+fC7cLjc62juQY85Bbm4u3G43nG4HOjo6UFxczHx2kShRi4EKpvLF4nj9RlqzESgIgAVw+dRn4XqNZ5YKA5r0rHmdSSI5UZYHjVfk150MO+GJavy7SIWZCNeco4GDp7LOP9n+qdrUt2FfuSrtr371K4jFYqxatSqpmhWZRCLB2rVrcf3112PWrFlQqVS44oorcP/993/Vl/KFRil8aWlpeP311zFhwgRce+21UKlUaG9vBwAUFBQkpR/Rz68LdATAGjhVlW1tbUU0GkVFRQWqqqpQVFTEUqhfeeUV7N69m6VQCwck4NQcaH7A4gfNWCwGuVyOOXPm4IYbbsDkyZNZ4QTheb4q46+bBmClUsnSpx9//HH09/fDbrdDLpczsWvhRCASJSjsra2t+O1vf4tXX30VtbW1WLVqFWbMmMEWjEKm0ldpwgnnixY7o31fpVJh0aJFePfdd/HGG2+gvb2d6VbpdLrvbKq1CABicUAEiESASDBpjxaVpIlFODkAyWkMwu+nWvzSeWKxWKLQjFSK6upqnH/++XjttdeQlpaG8847D3K5HA6HA2q1GtnZ2UzqwWQyQSKRwGKxwO/3IzMzE0CC8eTz+ZjWoNvtRnd3N7KyspCVlcVAEK/Xm6RpQsxL6qfEysvKykJmZia2bduGSZMm4ejRo3A4HJgwYQKrsN3Z2Qm32w21Ws2q11KBK2qHpE03MDAAs9kMo9GI3bt3o6qqCkajkYlTm0wmFBcXw263o6uri+kqEehYV1eHyZMno7CwkDkjPT090Gg0OHDgANxuN0sho2uyWq2YMGECIpEISyuj6KjT6WRacWlpadBoNPB5vEhPT0csknAqB/r70dvTA6PRiOwcMwOC02QyGLIMGBocSnJGCdCx2WxsASQSiSCTShGNRVnxEAIoeaeR+iQV6wJOjH4KWbmJNpQAHePx479HUzgwwOf6ohIJxKLP2zyfXi0CMMqx6Th8G/6q7N/JBxjNCMji3x0Be5TWG4/HodPpmPC6wWCAy+ViadjRaJRJF1Catl6vh91uh0qlQlpaGgtu0vHS0tIgl8vZd0QiEWMzU1/2er0sBUir1TJwkPo/HYfaImlqkZQDn3bEFyagdu/3+1nKMskjhMNhlJeXM4BUJpOxNpNqwcYv5EKhEDsP9WW+WE9VVRVjZVMwRVghXriIFC7iYrEYHA4HNm/ezD7T6/VQqVRs7Ny0aRPy8/NRWVkJnU4HuVzOwFPeUs3RQrDzvza6/Tv3f3rPixcvxrPPPosVK1agu7sbTqcTU6dOxdq1a3H66acntfPp06dDKpXCYrFApVLhnXfegdlsRm5uLnJycnDs2DEsWbLkhHOl8k1isRi2bNmCHTt2oKSkBAsXLoTVasWbb76J1tZW3HnnnbjnnnvQ3NwMg8HAqsNfeumlGBoawoEDB5J8Ybvdjl27dmHXrl2sSAQVTfn973+PlpYWbN26FWVlZbjyyiuxY8cO7NixAx9//DFuuukmlJeXo7u7G3V1dZgwYQIOHjyIuro6nH322fjZz37GNJ+rqqpQV1fH2NjhcBiHDx+GWq3GyMgIxo0bh8HBQZSVlbE5cPfu3ZBIJCgsLGQSMvQvlVG/JAZpZWUlgsEgjEYjmpqaMHPmTFZdedmyZZg6dSpee+01PP744zhw4ABqampYoOWWW25hciwE2NH7GDt2LJ5++mk89thjuOuuu3D//ffj1ltvxV/+8hfMnj37lCUa6B1oNBo8/vjjuOiii3D77bdj+fLlqKmpwZIlS5Cbm8u0o6dOnYqxY8eipaUFXV1d2L17N2pqatDb2wuv14stW7agoKAA2dnZ2Lt3L4xGIyZMmIC2tjY8/vjjePXVV5lW8DdhN910E9auXYstW7YgPz+fbTebzd+o3AoPuAEnprwCx9sOzUtAMuhP+wnfLc1B9Dt/Pv57/P7C8/Ksfd63HA1E4oGr0dYdqcaO0QBImj8pyCkSiVhl+kAggJaWFigUClRUjEHrsVYWMPV6vTCbzRgZGYFKpWJa9JTlSOCbWqNGUXERxGIRDAYD/H4/dDod7HY7dFodcsy5iIajyDXnon+gHx5vQnYpNz9BrmhpaUEgEEB2djbDPigYThIypCsfDocZeMgzSnnmI/Unele8n0L+PPl1wnTsSCTCAEXez+b35zMmRutro+EpfHvi36MQMB7tHfNt6N/Z/mngcdOmTUl/KxQK/O53v8Pvfve7Ub9TVFSEDz/88J899T9tYnGiMEE4HEZ1dTVmz56N119/HbW1tTj33HOTnHneCaYo/1fx8oUABqV3DQ4OYs+ePdBqtZg+fToyMzMxMDCAN998E5s2bWJ0fRpE+XtSKpVMu0QkSui9jYyMwOPxpARk+EZPWmoikYiJRF999dVYuHAh0tPTWYf/Joy/LmISVVRUsEl248aN6OjoOEGzkv8ubzabDR999BE+/fRTjB07Fueeey6WLl2KnJwcpKWlpYwWfVkTOpGpgCogmYF3smNROigAOBwOjBkzBr///e/xwQcf4IUXXkA0GoVWq/3a0v7/rSz+eVQPx9Ot+clDGPmj/sa+zrU14f6pAGT6yYNKcRyfnObMmYPm5mZ0dXWhvLwcDQ0NqKmpgVQqZRXWASAvLw92ux0ul4tpCspkMqad4/P5ACTYCz6fDwMDAygoKIDZbGasLJ/Ph0AggKysLMRiMTidTqjVasRiiWq34XAYoVAIY8aMQXp6OoaGhpjDHo/HMW7cODbOUZVZSl1WKBQsBZnGxOzsbPT09CAQCGD69Ok4cuQIurq6IJFIUFBQgMOHD7O0qaysLDgcDpaempGRwVKWu7q6kJ6ejry8PIwdOxatra0s6llXVweDwYCOjg6YzWZ0dnayfuPxeDA4OIi8vDxIJBLGDo3FYsjMzGTMT9JtJP23Y8eOobOzCxOqqxmoSWkTGZoMuJwuFrUl8CYcDsPpdMLlcrF0oHg8zqpikxA2OcWpIpx8GyNLlTIqkUgS7Vjg7EogRpwbLljbFIkQi6aQ0aCxTHAd8VgMQulHCtAII8Cnav/OPsBoxqfaA8eDlARwERtPp9Ox/kptjQrKUAEjcpzFYjHS09NhtVpRVFTE5AyoHRAriGfqEYg4MjLCFnGUUkSpeDTHk2wMAaTkmKvVakybNg0bN25kfUIkErHiVPziBEgwjObOncsKVSgUCsybNw+5ublob29n54vH4wx0pWPSP74gD50jEonA5/OxRUQwGITZbGZ+RWZmJux2O4BkcF24sBT2J1pMkGZtRUUF/H4/+vv7sWfPHshkMmRlZWHs2LEIh8PYtm0bK3JDCynSduJNOP4Lzy20f/fFwD9q/0n9n8Zgk8mEs846Cy+//DLOPvtsRKNRTJkyBY8++iiOHTuGqqoq9r51Oh3mzZuHaDSKadOmYfPmzdizZw8uu+wyVFZWoq+v7wsXi+ST7N27F1u3bsXq1atRX1+Pxx9/HFOnTmV+YH9/P37+85/j5ptvxpYtW6DX6zF27FgsWrQIHo8HTz75JAtKR6NRbN26FYcOHUJRURE6Ojogk8lw3nnnYfv27XjvvffgdrvhcDhwwQUXMH+jo6MDCxYswLXXXos333wTer0ePp8Pn332GdatW4dp06bhV7/6FRtvALCCUXq9ns3JAJiOrUqlwpgxY5J81MrKSoTDYQwODsJqtcJisaC2thbhcJgVoqK0bH69Reekcbe8vBydnZ2YM2cOKyYTiyU0aufOnYsHH3wQPp8PWq2WAU8SiQTLly/HbbfdxqQp6P0DgMFgwP3334/nn38e//M//4OHH34Yb731FqxW60l1SEdrTxUVFfjDH/6Au+66Cx988AHLWiJ2POlXl5SUIDMzk/lVlM3S2NiIqqoqyOVy7N69G6FQCOPGjUMwGMRFF12Ee+65B2vWrMFll112SmuLf8bi8Th+/OMf4+2338amTZtQUlKS9PnUqVO/UbmF0dhhX7QPbeMBqFTfH22bEETijyk8RyrJEDo3fU5/C8/Hr0v5AFwq5t5o6x3+71gsUfguPz8fQ0NDEIlEsA5bEYlGUVpamtBtVCrhcrkQjUYZRkJrZI1Gw/TgM7UZKCgoZAHwWCyGurq6BP6g0uDA/gOssKMxy4j8wnxWXM/vS2gnlpaWwuFwoLm5GWazGcXFxUmV7mksEaZc8wAkABaoFbYDyvzk18g8eEz7iEQiBnzSOMFnjfLPUDgeCVm3ZEIfn/om+Wn856neN782EPpA/LqUP+7J7FQIBl8lCWE0+8oZj/8uRi+LKrDu2rULWq0WV111FcrKypIaIJD8ok9VZPhUroF/yT6fD42NjcjPz4fJZMLy5cvR2dmJtWvXYtOmTSxlQAiC0LGUSiXGjBmDnJwclnIFJFKyIpEIOjs70dLSwlK1+IiIQqFgqYwikQiFhYW48sorcd555yEzMzOpo32TDjb/3IFER9br9Sz14ZFHHoHX68WSJUs+BxU6R71OepehUAgHDx7E4cOH8cc//hGLFy/GqlWrMGHCBBbtOFlE6ouMnEhiJNI2/pqEDJHRjuPxePDGG2/AaDRi2rRpcDgceOeddxgdPD09nYk6fxeN74fxODEfxUnbyUEQDubCyYf/e7QI1Ghti/VjUYJTRoAwOalUlIGidg6HgxVRsVgsSfIKoVCIpVfG43EGCjkcDpSWlsJqteLw4cOsrxMDyufzMc1Fl8uFjo4OeDwelJWVQS6Xo7u7G9FolC20/X4/5s6di9bWVrS1taG4uJilzfGsKLvdzthJxMBUKBQMCNXpdKisrER3dze6urqQlZUFr9eLxsZGpt2kVCqRlZWFgYEBuFwuyOVyqFQqZGZmwufzoa+vD3l5eTAYDFi3bh2reCkWi2EwGGCz2QAk2AixWAzDw8PYtWsXLrjgAoyMjDBHwWg0wuv1AjguPk1ORUtLC/bv3w+P242ysjJIJBKkp6czoCb2+Tvzer0sqhuPJ1hhxGZzuVxQKBRQqdXsM9ovHA6f4Eikai+pgIykbQAD0ZPanSg1cxecU510DO58x89zHNTkz/9NBpT+1Y2ANHqWFAUnhzctLY2x7ZVKJUs1pjRoYjSS856eng6HwwG9Xg+bzYbCwkIGwmk0GkQiEQZ+U1sk8I6KydCYQcUsALAFNDmxBIbS/A4cH/tycnJQU1ODbdu2scIPer0+qfgatR9KnxwZGcHVV1/N0h/pmiiFlIIZVBCLWJB8sSViL8TjcZZKToAppX3L5XLEYjHodDp0dXWxaxZeF90Pjd1AcrDW6XRCoVCgra0NnZ2daG5uZoEFn8+HmTNnwmQywev1Ynh4GJs3b4bZbMaECROQkZEBpVKZlOIuHPvJUjnm31XQ8T/N+PHwqquuwu7du5k0yJQpU1BSUoJNmzahsrKS7S8Wi3HeeefhgQcewPnnn8+kjuLxOKqrq/GnP/2JjSGjGc2zTz/9NO666y5MnDgROTk5eOaZZ3DxxRdj3LhxePfddzEwMIDu7m68/fbbmDx5Mt58802sWLECEydOxIUXXgiz2Yyf/vSnLEDgdDrh8Xig1+sRDocxY8YMtLe349NPP2WBtbPOOgt6vR5tbW2wWCyIRqP46U9/inXr1qGzsxP19fWQSCRoaWnB2LFj8cgjjzBgIBQKQa1Ww2AwYM6cOUngCD3LrKyslGCIwWAAkABuac1BMhY6nQ4NDQ1MioWqeAPHgRYaY9LS0jBjxgxs2rQJWq0WBw8ehNlsxnvvvYedO3di/vz5yM7OxqxZs9g4RD4IZZvw10bvn1Kvf/Ob3+C+++6DSqViWR5fpi3RmFhbW4v3338fHR0daGhowFtvvcW02u12O6RSKRoaGjB9+nRoNBq89957KC0tBZBg4JaVlWHXrl3w+/347LPPkJ6ejoULF8LpdOKcc87Bk08+idNPPx2FhYVf63h044034rXXXsO7774LjUbDNBkzMzMTYNTnUgXflNyCsL0BJ/pOvP+far9U4BG/XkiVRSVkMaYCfkabv3gAiz9PqnWF8P749Qt/j6MFx+gYxNIjP0GtVqO2thatra3olvfA4/FAlpaGzMwMDA+PwO12w+v1Qi6XJfwTsYhl2CkUCqSlpSEnNwdZWQYcPHAIHR0d0Ol1GB4ewUD/AJTpifWL1WpFJBLB4OAgI15oNBrEEYPD6QAA5OTksKDj8PAwfD4fm5P1en0S25XWQyKRiN0LyeBRwIV8KFqD07Oivyl4yxecIX+Dz2zlAULyZchSZX3y7yiV/8CTkfjsqFTf4b872npztH4+Gr4wWjv9pu07CzySw5Cbm8vQ8Gg0yoRxFQoFqzxJDTwSibAFKfCPawDxL50WxSJRIjJGEdIPP/wQ69evR2Nj46jVu/jjyeVy1NTUICsrC4ODg+js7GQLcJVKheLiYpSXlzPx4lgsxtK0aIEDJDR8Vq1ahcsvvxz5+fksyvFtOtbCQRZIRFLPO+88ZGRk4Oc//zn279+PyspKDA0Nwe/3jzqQk9H2oaEhvPbaa3jvvfcwZ84cXHzxxZg5c2bSexZ+Z7RrFP5OUZlUx+Ejr/x24YCg0WhwwQUX4MMPP8Sjjz6KSZMm4eqrr8bGjRuxfv16ZGVlsZTx76IJn1c8FkdMdGIUkp8Y6J8whY/2TeU8jOawAIBIIgHicYgIyBeJEft8f5rYent7WfEnh8PBWLbkBAeDQRgMBmi1Wmg0GvT09LCUxIyMDGi1WlitVrhcLiZ439LSgvLyckSjUYyMjCQBFzSeud1u9PX1oaysDKWlpYxNTWme2dnZqKmpwfDwMJxOJ9Ms1Gg0LFXUaDSyhRPpPGVlZaG/vx86nQ5KpZJpUhqNRvj9fojFYjidTkilUuj1eiZpQUAjkGB6EvhCenIymQyZmZk4duwYIpEIcnNzWdpqZWUlY08eOHAAXq+XMRlIk0YsThSyoEqRVBTE7/fD7/fj2LFjmPf5QoTSWQmskaWlQSqVMsYkAUl+v585ajQehsMJTU+RSMT2IwflZI4g/7swpZ+CFYgDYsH4lQDVT2R68e2Tb7txxBnrkXdsgRP1fv8Lmhw3WphSIEAYQKIg3tDQEBQKBTQaDUs3lMlkMBgMrFIzbaP2I5VK4XQ6IZfLGUgWCoVYX6WgA6Uq0vwgFouZfisJm9NxCQCMRqNMjxJI6LzRooa01EjmYO/evZg3bx5zzglwoznJ7/djw4YNqK6uRlZWFrufeDwOrVYLp9MJh8OBvLy8JGYoaS3xGo80d1M/pLErGo1CoVCwQk50/lRpYvzzEfYrYiQTO6GtrQ39/f1QqVRYunQpC+YUFhaipKSE9VexOFFwZmRkBJ988glKSkpQXl7OFjt8KpVwTvgi5/1kQQf+81Sf/df+dSw3N5el2j744INobW3F0qVLsWbNGvzwhz9kQWoAKCsrYyxmk8nE5iyNRsPmVqPReNLz1dfXY/r06UzP3Wq1QqfTYf369ZgzZw7OPfdcFBQU4OjRoygvL8ff/vY39PT04K677sL48eOxYsUKaDQaPProo7j22mvh8/ng9XrR3NzMKsbLZDKsX78eDocDfX19KCgowEUXXYStW7fC6/Wivr4eF154IUwmE5599lk4nU60tbVBo9FApVLh+eefh9FoRCgUwuHDh1FVVYXGxkZUV1efwBhO5RMLt1F/JGZ2PB6HRqNBRkYGjEYjm1P5OSsUCqG+vh5Tp05l70Cj0cDhcMBisSAWi2HDhg2Qy+UoKChAf38/xowZg9LSUhw5cgRHjx5FaWkptm3bhrPOOislIEz9WyaT4cYbb8Q999yDt99+G8uXL/+H2hKNVRqNBpMnT8akSZOwfPly3HDDDWhubsY555yD7du3M0LB2LFjIRaL4fF4cPfdd+Phhx+G0WiEWq1msjhDQ0M4dOgQMjMzUVxcDLlcjk8++QQ//OEP/6FrPFV77rnnAADz589P2v7nP/8Zq1evBvDNyi3w80WqNif0k3iG4GhgJL9GoDk11XryZPMAz14UgkvCeYwHOIUAl/D30e6VB7eE6xyeRMX3U4VCgTFjxsBkNOFw42FAHMfw8DCM2VnQZKrR3t4Or98LnU4Ho9GESCQMsVQEoykLmgxNIijT0YHOzk6mSyqKJ56xxWJhfvbw8DA7f3V1NQwGA4ZHLMx/IfIErZdJQomCmHwWEr/OIZ9JmDZPmA2ApEJy5FPx7Ed67nRc8pf4wqO0XSQSsSrXqfxuIXP2ZD6CEKMQAtvUNlK1G2EbGM3XGO3c37Z9J4FH/oUVFhYysdBNmzbh2LFj0Gq1+M1vfoP09HT4/X5WjbWoqAhAMjjxz7BEaAAMh8MYGhrCjh07sH79ejQ0NDDx1lQNKlXjKisrg9FoREdHB44ePYrs7GwUFxdDJpMxhpTb7UZpaSmGhoZgsVhYJbXu7m6IxWIsW7YM1113Haqrq782/cpTtRMApXhyiXlayJ1xxhnIyMjAvffei+3bt7NqwV+kv8AfE0gI+K9btw6fffYZJk+ejIsuuggLFy5k+olfBGSS8ZG1VPR9HkTlox1CQCIcDqO9vR0mkwmZmZnIz8/Heeedh5GREfz+97+HWq2GTCZDbm4uMjIyvvMLGPZOkczkBZByohYucgGkjHzT94XnSXqnSLDIjk9gxx3NgoICvPPOO5g9ezYqKiqQnp4OlUrFCpdQYCM3NxcKhYKl9Wq1WkilUgwPD8PhcMDhcCS1K7/fD41GA7vdjoyMDPh8PgaWBYNBtmjJzs6GSCTC0aNHoVQqoVIlhKBDoRAyMzMxODjIxNi7u7vhcDhgMpkY48toNDJnn4DIgoICNDY2MqAhHk/oOZImZWdnJ9LS0pgINb2HQCAAk8kEs9mMrVu3ori4GFVVVfB6vSw9Oz8/HwqFAs3NzXC5XNBoNOjv70dBQQFEIhEcDgdkMhk6OzsxZcoUaLVa+P1+uN1ujB07Fj6fD3q9noG0Go0GYrGYPZPh4WGcfvpp7J0ScEJtQiqVQi6Xs9R1injS4oQAE5FYxIBAAkXod549mCpIRO2HgCEaM+if+AvG3VRj4wnORBzJeo/gIqejAB//Cg7Jt20EvBF4TsAfLZADgQBrG5mZmawaPa+xSkzlcDjMKtAbjUYm5E5OMDnCfDVqAiJpfhOJREyX0ev1MlYtsQwp1ZrS/YHkgBelKZLW4pw5c1BXV8f0wyQSCTyehOaSXC5HWloa8z+mTp2axAoIBALQaDQIBAJQKpWswiU54XK5nOmv8aLs/HVRyij1M7oXcvb5dKlU4zcfyOPZniRfMTg4CI1Gg/nz56OyspL1R5JhIGYqVSbX6XQYGRlBd3c3Kxwybdo0KBQKlvpO56IFHDGp+blAuICgMeGLMkX+C0L+65pIJMLUqVOhUqmwZcsWzJ49GwsWLMAf//hHtLW1oaqqiu0rkUiwatUqvPjii5g/fz5ee+01NDU1YdKkSYzpfzLgMRQKYc2aNVi1ahVaW1sxbdo0dHZ2oqysDJ2dnXj//fdZgbeioiKo1WpcfPHFjFH92muv4cknn4TP58OyZctw/fXX491338XOnTtht9tZEK6/vx+hUIgVjps4cSL6+voQCoXQ1dUFp9OJCy64AK2trVCpVBgeHmYBkwceeAAqlYppshUUFMBisSArKwtDQ0PMr9FqtYydREGDnp4e5oukp6czYFar1TJ/hFK6gUQhy7TPA4H83BiPx+H1ehmjuaCgALNnz2aZP2azGWeddRbWrl3LMkkuvfRSRCIR/P73v4fZbEZhYSF27twJn8+HVatWjbrOoW3p6el44IEHcPnll6O4uPgfakf8T7KsrCw8+eSTWL16NVpaWlBTU4N9+/ahr6+PpYFfdtlliMfj+MUvfoHbb78dixYtwg9+8AM8+eSTLCNk/vz5yMjIwJIlS/DOO+/ge9/7XtLY9VXbqfgJ/wpyC/x4LFynnwwIpP2FQBA/L53KuM2fk5dtEfpcvF/PzyvMHxwlUCy8Nv6++HPQXESfERBHx0xLS4PRZESNrAZHjx5lwcFIJILx48eju7sbXq8XIlGizVL6PxW9DAaCrNI1+UeyNDmi8hiTm6Fn7HA4sG/fPuh0Ohiy9GydRNfrdrsZ6YekouiaSbeR76+0nfwUkUjEfAkCGXngWOhTUICZ1gD87xR05t81+QGpWLmpMBoh+CzMpCRfj28PqTCDVCAz316F/ge1t9GOdSog5tdp30ngkbe8vDwolUoWxddoNAiFQnjxxRdRUlICq9WKs88+GwUFBexlut1ujIyMoKys7JTAqFQDNWmQ7N+/H2+99Ra2bdvGonXChjFao6BtMpmMpVy2tLSguLgYY8aMYYypkpISZGdnY8+ePcjMzERhYSEsFgt2794NsViM8ePH48Ybb8SCBQvYgoY/17fpEAs7nTAVSiqVYubMmUw/pb6+/oRJRfh7qnPQZ6FQCLt370Z9fT3GjBmDCy+8EGeddRZMJlMSLZs3IWjID3Y0sKaaRHjwK9U1dXV14U9/+hMmT56M2tpaOJ1ONDU14eyzz8bLL78Ml8uFkpKSUcW4v0vG2kn8ODNstEGc/8n/LoyACfcT7g8cT3WNx+PH01tFIog+n0wrKiowffp0pqHo9/sRDAaRkZGBrKwsKJVK2Gw2KBSKJPYdsZCJ4dTX1weNRoPOzk42MRODgRx+n88HiUSCoqIilk4dCoWg0WiY/MKmTZswMDCA8ePHo6qqigEPJpMJZWVlSYxh0l8iFnU0GmXjYGFhIaxWK5xOJ9xuN/R6PQoLC1khLJrU7XY79u/fj8mTJ8Nms8Hn8yEnJweZmZnYt28f4vE4xowZA5lMBrPZDJfLxRZKCoUCQ0NDrICU0+lETk4OA03z8/NZCkdeXh6bcAcHBzEwMIDMzEyIRCIoFArE43Hs27cPYrEY2dlm5lSQ/qNSqWSp8FQNnHTsALACGXSOSCQCSdpxHT2aGwg4FH/eBsiiXFoOtRv6x4/5EomEFZZJ6AYcb1N8+jVvsThFbz8frwFALErSiWROsBCfTNFHvsvGg1OUSkyFXYhVSHqh6enprOAQgc0EUFPwiKRLQqEQA+EozZgAM74YBB9JJyOGHp3X6/UyR5vmGblcDq/Xy0BHAul4CYd4PFEcqqamBgMDAzhy5AikUimKiorYfcViMezYsQOLFy9mlZ8BsHRwIJEaGQwGodPpYLVakZ6ezrRPAST1Ez5jgo5P10FFcagyJV07X9mad575+ZPXdaJxNRwOY/z48TAajcjNzWXPko7HO+NAoipqLBZDeXk5CgoKMDAwgObmZthsNlRVVbFgChW+4ecJAheFiwb6yc//wvlCmGJF2/9r/1pG/ZHSQWfNmoWMjAycc845eP/991m6Ne07fvx4qNVqaLVa5Ofnw+FwIBAIoKqqCg0NDZg4cWLS+M+//0OHDkGlUiEcDjNtNbPZzHQXt23bhvLycvj9fpSUlDCQvKenB+PHj8e5556LK6+8Ehs3bkR3dzdLNx4ZGWEBQSChH9vb24uuri6oVCqMHz8ea9asgVQqhVarxbRp0yASibBmzRq0tLSgv78fNpsN119/PWpra3HgwAHI5XL09vYiLS0NLS0trO9kZWWx+dBut7MxwG63w+12Y3h4mBWoaGxsRE1NDXbs2IGcnByEw2E2NhC4QWNrJBJBb28v4vE4CgoKoNPpMH36dLz11ltIS0tDV1cX8vPzUV9fj4ULF+Kyyy7D1KlT8frrr6OrqwsffvghNmzYgB/96EeYMGEC/vSnP2HMmDH45S9/mTTGnawdKJVKTJo06SvtpyKRCEVFRXjxxRdx/fXXQyKRYPr06di1axf27t0Lk8mE22+/HQ8++CB+85vf4Cc/+QmeeOIJLF68GHfccQf+8pe/4ODBgygoKMCkSZMwbtw4rF+/Hnv27MG8efOSzvOfbEKfXrheTgUyCoG6VAHiVLr5/DxE8xP9zqfq8ufiA9P88Xnghw9W89t546UG6Hz8nMSTcvjj8jgC/eOZnDQ3ZmZmYuLEicjNzcXBgweZvzNmzBjYbDa2xujr64NarWbp1lFlFPGYjfnmNpsNLpcLIyMjCIVC0Gq10Ol0rNib1+uF3+/HiNUK4Dj4KRKJmOxCAuhMBDOJYUi+Eq2T6HPex6B7ooAj+er0jGh9Rc+Df7/0fTo+PUf6jA9Aq1Qq9rkwXXq0diec8/l3mgpU5n/y7Ya/Xv7dptpfOM+civ0XePyaLR5PVKWk1Ih4PCHeXFZWhi1btiAQCOC6666DwWBALBZjdGKxWIyioqKUAxhZqoGGBjO/3489e/bg1VdfxY4dOxhrgf/eyV4+MSTonLQAIuCypKQEvb29OHz4MGKxGKZOnYrLL78cg4OD6O3txdixYyGTyaDT6XD55Zfj4osvZk7Dv4LOF90XicnStlSaBcRSKi8vx29/+1s8/PDD+OCDD5K0pKRSKcaMGYMjR46wY33RYjsSiaCpqQkPPfQQXnrpJZxzzjk4//zzUVpa+qX0LmkxlYq9wUed+OPQPS1atAg1NTV499138cgjj2Dp0qU488wz0dfXB5vNBrFYzMCj76oJn79IdJyJBqROSeWNfy+jgcrCyJLws3gsdoKmHj5nPep0OpSWlmJ4eBharRZarRZut5sJPHu9XgQCAfj9fqSlpcHhcLBFvkwmQ09PDyucQjpNXV1dLCWQ2hcBb0ajkTEn8/PzWVo1pWkuXLgQe/fuRX19PVwuFwMpCWwzmUxwu91sgrdYLPB4PBCLxfjggw8wY8YMTJkyhRWmyMjIQDAYhMvlQlZWFjo6OlgBmqysLASDQXR3d8NqtUIqlaK1tRXxeKIwS0lJCd5//32cccYZGD9+PEpKSnDgwAHGMg8EAgz4HBoaQmVlJWw2G5qbmzFjxgzGdqT+QsUwCJgkAEkqlWJkZAQHDx7EpEmToM3MhD94nJHFAAkcZymHQiGkpaXB7XYzDTpyHqiStUgiPsE5FX8OEEYjx4sWxWKxJIYk2yY6zohKmktA4HmCs0jMRZFIBBGSBcbj8XgC5KZ2HIsjFo9DFD/eRpPmqHicHYOu47923MhhJb1CqkZNTjYPIvLAH3Cc5UcOqUajQVdXFysWQNIlKpWKFT+Kx+NM7iSVg0q/U9oQMSqJIUlAKQUdqDANr//Iv2u6XtJC3blzJ3p6ejBu3DjIZDLs3LkTWVlZKCkpSWL50eIkFAqhoKCAVbXPyclBPB5HT08P0tPTodPpkJ6ezhigdB8E/lEghfpRRkYGZDIZPB5P0lgbCoVYCiYdi0wI2PNab2azGRkZGVCpVBCLxexdbd26FUuWLGH9lRhSFosFfX19KCoqQkVFBSugQ0VpioqKkJOTA61Wyxjj/HWMNrfzizrhwk8YKBzNh0xl/+kgwr+aiUQizJs3D48//jiOHTuGoqIinHfeebj++utx9dVXM51CCnDNmzcPBw4cQE5ODjo7O7FixQpMnz4da9aswfe///0T3j2BCB9++CHmzZuHjz76CEuWLIFUKkVOTg7y8vLwySefYM6cOfjoo4/Q09ODqqoq+Hw+LF26FF1dXYhEIpg2bRqkUikWLlwIjUaDhoYGmEwm1NfX48knn0RTUxNEIhH6+vpQWlqKyspK7N69G6WlpdiyZQvsdjuOHj2KH/3oR3j33XfR1dWFoaEhFnw5//zz0dDQgCNHjqCtrQ0mk4lJGnzyyScsSLhgwQI8/fTTOPvsszEwMMACOJWVlThy5AgMBgMrmtnX14eOjg7YbDaWtaNWqzE8PIz29nZWFIrGAL/fz9Zdubm5yM/Ph9/vR1NTE4aGhrBlyxb8+te/hsFgQHV1NXJzc3HTTTdh/fr1uOqqqxCLxfDyyy9jxYoVOPvss0+JFcj3t68yQMeDHqWlpXjuuedw7bXXQqfT4corr8S6deuQlZWF++67j+lW0vt++OGH4fP5cP3112Pjxo2wWCwsJX7mzJnYuHEj5syZ850hJKQK7gjZhfw6Szgep/LrU71rPuAF4ATfjx//T3YsHqgUHpuOwfubdDwebBReO8/MS3Xt/P68zycEI5VKJfLy8qBSqdDQ0IDBwUFIJBKMHz8enZ2dCIVCGBwchMlkQktLy+d+jAJmkxkSsQRpkjTEIjEoFApMmDCBFb2TyWRwu92w2+3Izs5OsJ8lgN/vZxqQVGgJAGMUkrTA4OAgm4OBBOZB904+NPluVOSPf//836kA6FRgJJ+VwgO1pPct9K35955qXS/8nL++VEDjF2FLqUBv/vipxqrR2ujJzvd12HdjZBrFRCIRVCoVKioqWDXV8vJylJSU4Nxzz8WsWbMYA3LNmjUYHBzE6tWrodfrU1ZZGy2aSZ3d7XZj27ZteO2111BXV8eYRbQP3wCEDZMfZPjS7sBxtgWlYYlEIgwNDUEqlaK0tBStra345JNPYDKZYLFYkJ6ejgsuuACrV69GSUkJ01cSTrLfpAnvV0hz5ju5sIPR/efk5ODhhx9GQUEBXnrpJTaIkfYTLSip6l1WVhYTtE11Hlp49vT04Pnnn8cbb7yB0047DStXrsSUKVOgVqtPuJ4vukf+3Z4sHZwGFIPBgCuuuAKLFi3CH/7wBxa5NRgMkMvlX7oC3H+yiUSiE9JLv8j4CV/IrknVH/lzkaVKmae/iQFx+PBhVsyB0o+JTQWAAV0ZGRmMKWWz2aDT6RCPx7F37174fD6o1Wp4PB6mJUfAmV6vT2JJqtVq7N69G3l5eYy5SDpTEyZMQF5eHqtol5mZib6+PnR1dUEsFsNoNEIkEiEQCEAmk+Ho0aMIBAIoKirC7t274fP5mP4baTEePXoUKpUKGRkZSWmhSqUSBQUFqKurg0gkwumnn46enh5WQGvHjh347LPP4Pf7sWjRImRkZEChUMBqtTKwZXh4GBqNBkajER999BHMZjMyMzPh9XphsVig0+kYAywWi7G/Q6EQu54tW7agp6cHt9xyCyLRCItCh8NhpKenJyZviJjeHKVpE5BE71SpVLIKvsRq4z+XiE+sXpgAjo6z2iiNloAhmkv4SPZo7TvVeMFHZvn07VRzC/09Wlv/Lppw/qZnmJaWxljD8XicAYu8phAx7uj57d+/HxUVFWyeAcCARqqKTenVSqUyqZoize8ENFKkntqTXC5nbELyAahIDaV1x2IxFsjgwUx63wQiUoqSSCRiFUfz8vLQ19fHtBHp+MQEJsYAMe21Wi0rLGAymSCTyaBUKiGXy9m56PrJgSf2JgVbyaGnPgGAFaGhsTlVW+YZhQBYYMXn8yE7OztJ8kChUDAdThpvgUTBq+zsbDidTgwNDSEjIwNyuRwVFRUoLS1lzLC2tjZWmdNgMEClUkGhUCQdi0Bpel6pmAz0jumayefitWH57/wrBIG/6xaPJ3RNL7roInzwwQdYuHAh8vLyoNfrsWfPHixbtixp7JwzZw7+8pe/YPHixairq0Nvby/GjRuHo0ePYmhoCHl5eSecw2KxwG63o729HU1NTTjnnHNYWxozZgxef/11ZGRkYPny5bBarWhoaMDQ0BBisRiampowe/ZsDA8PQ6fTIRAIYOLEiaioqIDBYEB6ejomTJiATz75BC+//DI6OzsxMjKCzMxMlhpJ7Mfh4WHIZDJYLBaoVCoUFRVh//79mDRpEkpKSvDss88iEolAr9cjEAigu7sbSqUSPT09rLr0hg0b0NfXh/b2dtjtdrhcLhQWFmLfvn1MX9Hr9WL8+PGsWIpOp4PP50NZWRlcLhdmzZqFnTt3Ys6cOThy5AjKyspY8DAcDmPq1KlQKpUoKytDX18fzGYzNm3axAKbN998M44ePYobb7yRVRlvbGzEihUr8JOf/ARqtTrlWuJk9nXMj7xfWVpaipdffhm33norBgcHWZGiDRs2YMqUKdi8eTMWLFiAm2++GVdddRWuv/56WCwWBINBHDp0CNnZ2Vi2bBmkUin+8Ic/4Pbbb//Oab/zvjyQIugq+DkayJNKA1Lo//MgJM+mp7lKqCnIz2VAMuFB6Jvx10/f4dOlhet0fr5IdXzhvQi3C89PuuynnXYaenp6UF9fj66uLiYp43a74XA44Pf7MTgwCJFIjKGBIZhNZui0OshlcnS3daOzsxNqtRqlpaVQKpUIhULo6emBw+FI6NnrtdDrdaiqqmJyUjqdjvk5pNlOYCMVsovH42y9RIAhPXuah3lQjt4RYSTkOwl9CmJU0veFwUP+naR6R3ybS9VmeEvFfkz1nk7FUoHMqYBMft/RvvNNrQW+88CjVCpFTU0NPv74Y4jFYlRXV+PSSy+Fx+PByy+/DLlcDoPBgFmzZiE3N5el+vIAGQC2MKH0ANoGJHQLPvnkE7z66qs4cOAAW1B8UePkr5NSAAGwtAkazAhwIN0ij8eD7OxsxGIxFBcXw2q1oqenB1qtFhMmTMDVV1+NyspK5jj/Ky06+cUXDSikU5XKhANvRkYGbr75ZuTn5+OJJ55gWpmhUAgTJkxAdXU1/t//+38Qi8UsHWS06+DPEYvFYLPZ8O677+Ljjz/GhAkTcOGFF2LhwoUwGAxJQDRv/EQ02vsWfo9YsR6PhxX7yMnJwZ133olXX30V119/PTweD2OmfJeNHyzZZCA+NQBdGDHjvyMchFNFhegfn84gPH4kEkFVVRUOHz6cEG02Gpm2IqVB0oK8q6sLRqORAW5erxeDg4MYM2YMzjjjDJa6RWMQVZPMyclBf38/YrEYhoaG0Nvby1jaAwMDTHtNKpXC7/dDoVAwXcjBwUGWBhEMBtHf34/GxkYYjUbGhgyHw9i9ezeys7NRUFCArq4upKWlYcyYMQxoyMrKQnt7O8xmMzweD1pbW1mfo6rag4OD2LFjB2pqajA0NMSuzWaz4eDBg9Dr9dDr9cjOzmaAgcfjQSQSgUajwYYNG9Dd3Y3TTz8dFosFYnGigE15eTnUajW8Xi9kMhlkMhmGhoYYi7u/vx8HDhyAVCpFbm4uA1JIZ4ocBYlYAhFXHTgWi0GlUiUVACEgSv65ziP/7qVSKSRiMaKRaFL0VCqVQhKPJY1pBBQRmEPthf85Wrujv3mnlBwrIYPyZI5qqmN+l42eIWkF8RqL1Abi8XjS8yYgmZxUKnCQl5cHh8MBpVIJv9/PpA8IKCQQito5gYBUnRo4rtVDDjOxpMl/oMCD3W7H4OAgrFYrSwEXgpTkbPMLJqlUyoB+KtiwbNky5ObmshREctTJz4jFYpDL5fB4PJDL5SgrK4Pf74fdbk9iVpMwO7U/6nOkS0ksCOB45WsAjCHFp50JHX9q8wRU8uO/WCxGd3c3RkZGoFKpGMti6tSpyMjIYECxx+Nh74RSsh0OB4AE8GkymVBYWIj8/HxEo1EMDQ2xFFatVguDwcB0rSQSCXve9G7ouog5npaWxsBKAkTpGVFbOlXWwn/tmzFqyyqVChdffDH+/ve/w2q1oqCgAD/60Y/w17/+FfPnz2egPJAoBlheXo7h4WEAQHNzM8444wwYjUZs3boVF198MYDksbaxsRFVVVVwuVzIycnB9OnTGfBYWloKvV6PN998E+effz6uvPJK1NXV4ciRI5DJZCguLmZZU1VVVSyLQi6XY8mSJSxQec0112D69OlwOBxYs2YN1q1bB7FYDKvVygKh8XiisnYoFILP50MwGITf78f48eMhlUpx+PBheL1elgZtt9tZajgFMYuLi+F2u3Ho0CFIJJJExdzuboTDYTQ0NKC3txdFRUXIyMhAY2MjAzn1ej3KysrQ3NyM+vp6jIyMwGAwoLe3F01NTYjHE0W/zjrrLJSUlDBtc7lcjo6ODjz11FMIBoPYvXs39Ho9FixYgBdeeAFmsxk33ngj7rjjjqRiQP9KRm0nPz8fv/71r3HxxRdDJEqkm65fvx7XXHMNPv74Y9x333145JFHmP+2Y8cOrFy5Ei+++CK8Xi+2b9+OiRMnIhQKoaGhAaeffvp3MnjBg0CjAWypyAWpWIajtReefciDfDxbjge9+GATGb/GoPMLr5sHM4VrHX79QSYEHIWAJ3/f9Dufms1fr1wuR2lpKXQ6HY4cOYLu7m7Y7XaoVCpYLBaoVWrk5eVjcGAQXq8XQ8NDCEfDKMgvSJCchi3wer3o7u5m2QjxeBzt7W2w2a2QpIkRiSQKyygUChiNRrhcrqRUauoHtIYh8JF8Lrp+4LjeY3p6OtODJGCSMsPovdB2PvhPz4h8Ll5vmw94kvQO3w74diVkII42j6cCyfn3ytvJxq2Tgcknw5dSAZSnikn9s/adBR55R3XatGmYMGEC4vE4Kisr8eKLL0KhUODIkSOYN28eLrjgAqhUKuzevRtOpxNLly5NEjJ1u92swiQ5lsRw3Lp1K1588UXs37//pBGZVEbMAUrFEtLHqXEHAgHY7Xbk5OTgoosuwtq1a3HhhRfi2LFj6OjogNvtRklJCZYuXYqpU6dCq9WyyAB/vH8F4wdaWtR90XUKO4tcLsfFF1+M4uJi/OIXv0BLSwtEIhEaGxtZkQ1+IZlqYEh1LjpHIBBAfX099u3bh+LiYqxcuRIrVqxATk7OqAwN4XGFiynhuanaV2NjI6LRKPLz89Hd3Y0JEyagvLwce/fuxZgxY6DVav+l3t+3YUnPUXTidmD0AZiAIL4vChlrwgE6FbDDbz9+cLCq1KTBGovFMDIyAqvVCpPJhKysLOzevZtFGTs7Oxm4QPpibrebARVyuRwmkwkGgwFjx45lk2g0GsXGjRvR1taGnp4eGI1GZGVlYfz48QxsNBqNMBgM6Ovrg9frhVKpRHp6Onbs2IHc3FyYTCbMnDkTsVgMjY2NGBgYgEqlQnp6OioqKrBt2zZMmzYN0WgUu3btYhM2LcY8Hg+rbE3sA9KCIVF8i8WCPXv2MLkHlUrFmBFvvPEGFi5cyPQmDx8+jLS0NFZ91mazsUWLRCLBsWPHUFpailgsIWIdDAahUqkwMjICsViMrKwsVqQpEonAaDRCq9UmAMbPHRqKmhIoFI1E4PF4mMajUqlk4wSlWDNABSK2mKFxJBKJIB477sARsBlDPAlwoLaUSjCbb1vC9jsakMgDoLzjkuoYwjZNn30TDse/mqV6BjTvAMfTaalPUoVqqohO75gi5UajEV1dXdDr9XA4HFCpVHA6nSgsLGTf51N1CFSkNkFthAeU+eukAjSkSU2BNY1Gg8LCQqjV6iSGBQHcSqUSCoWCjRd0zIGBARw7dgwejwfjxo1DTk4Ok1HgA3oUvKMgw+DgIAwGA9LS0hgL0OPxIB6PM1ajUG+JZ/YpFAoG/PMpgXq9PmkRJnxPws/4OZxAl9zcXBaMJbkGCg7KZDL09vbirbfewmWXXZYkEh+Pxxl7lHR3JRIJA5OKiorgcrnQ2dmJrq4uNDU1QalUwmw2s+PTP57xwi/wwuEw1Go1dDodS9tOS0tjqf30/vn7IxuNJfFdn/+/LhOLxazScnZ2NhYsWIBXXnkFEyZMwJw5c/Dee+/h448/xjnnnJMElM+cORMffvghxo8fj927d2PixImYNWsW1q9fj5UrVyZVUY7HE9kMNTU1eOihh2AwGNDW1oapU6ciPT0d48ePR2lpKW6++WbU1dXhjjvuQHV1NSZNmgSNRoOsrCxs3ryZ6alZrVbY7XZWwMXtdiMnJ4cVliSf4Oqrr8YDDzyAF154AcFgEIODg4jH44wB2dvbC5fLlTSnUAbOzp07odfr4fF4IJVK0dfXh6lTp8JisUCpVEKr1WJ4eJgVmjly5Aja29uRmZmJrKwsTJo0CTabjWnWulwuKJVKDAwMsHlcqVRi165dCIVC6Ovrg8vlglarhV6vx6JFiyAWi1FZWYk9e/bg7rvvhlarxYIFC7B582Y89NBDOPvss3HxxRdj3759WLJkCQue/KuZ0EfNzc3FT3/6U9x2221YuXIl4vE43n77bdx888247LLLsGvXLpx22mm47bbbmPbj1KlTGevR6/WiuLgYH3zwAebOnfsvec9ftQl9oi8aJ0dbf6caR3nfPlWKMg8K0tzGg1H8epCAK5r3+evlQS8ATEqNBxZ5XyAVMCrMoOOvUbi/8CcPUFJfp/vW6/WYMWMGKioqUFdXh56eHqjV6oQ/XlgMl8sFt8uNYCgIl8uJgUEpxlSOQSSW0F8PBoPo6+tlWYkerweDQwOspgZlVkkkEkaGCgaDjBiUkZHBpFiIdMEDvxSUpXmUPuO1HSngq9FokgKw9FzC4TAbl/kxj/wT8tFCoRDUanVSlXDe1xYCwanaUSrfO9V2/rujbftHAcPR9v+m1gHfWeCRbyzl5eXIzc3F7t278Ze//AU9PT3IzMzEqlWrcN1118FqteJXv/oV3G43brvtNsYeCAaDqKurQzAYRG1tLcRiMdME27dvH37/+99jx44drNGmp6ezdC3+GkZrWOS48gMZdVCKokejUSiVSlaZkhZJr776Kqu8+aMf/QiXXXYZq9A8Gjvv27BUCz9+cP6y+oX0PbFYjJkzZ+J3v/sd7rjjDuzbt4+dY/78+di3bx+sVitbsJhMJvT19aXsyKOBkNFoFO3t7XjiiSfw6quv4txzz8VFF12EwsLCpMUUD07x9yw8Lt0/MWJUKhXMZjNuvvlmFBcX4wc/+AF27dqFxsZGxONxzJo16yvTcfmPAR7iSAIfgS8elIWRTiFtfjTQJ9U2frKnoh9KpRLTpk3DunXr0N3dzZjRCoUCcrkc5eXl6O3tRXp6OjIzMxEMBllaJrGcRCIRDAYDwuEwzGYzS3vQ6/Voa2vDs88+i/3798Pn8zEB9sLCQqSnpyMnJwfZ2dnweDzo7+9nLEOv1wuNRoP8/HyMjIzAbDajr6+PsQ+OHDmCwcFBNnbp9Xps3LgRZWVliMViaG5uRlVVFdra2uD3+zFlyhRs27YNwWAQWVlZaGpqQk9PD/Ly8tiiv7CwkDE5SS5Ap9MhLe3/s/fdYXZVVfvvub23uXPv9N7Te0ISCCEh0pEgCtIUC1UF/FD8LCAKClgR8JMfShHFgqCEEkoSQkmAhIT0ZDKZTC93bu/1/P64WTv7npw7SRSQMut55pmZe8/ZZ5999tl7rXet9S41PB4PHnnkESxevBiTJ09GT08Pc7jQWtDY2AilUomDBw9CEASYzWbm9FEoFAiFQqxapyAICIVCGBoagiDkyf+tVisUSgWLGueVtWw2y6LKKVqMFBoCmcgYJeELjQBANBoDDgHEvCdZEFCg1NE8oSIjgHx6jFT4vYNXdKSgebH1PZc7XDWbVy4/6ULAGi98MRJ+Dad0H/pN/KxEL3Dw4EFUVlYiHA6z1Hyq3ExV16VKM88nRNciCoBwOMz4JKPRKHw+HzKZDPR6PcrKylgqN6Vn8++MSqVCMplkegntF6Ojo+ju7mYFHwi4zBwC3omigHQMcn7QfkwRxpS2aDKZCqplktJPxgClnAnCYY5MAtv4iN9UKsU4ZSnygJ+nvBFFv+PxOEQxnxJLlbcpstJms+GEE05AJBJBKpWC0WiE0WjE3LlzEQ6HUVFRwZ6FUqlkRPZjY2NsfaYUbSoIZrfbMWPGjDxB/qGK2Nu3b4ff72fALkWGknOFnlc8Hkc2m2WgLVFxlJeXw263s6wVPgKDv3c5Z/XEO/z+CG+cKxQKfPGLX8TnP/957N69G1OmTMF1112Hm2++GYsXL4bT6WTHLliwAPfccw+rUN3Z2YmTTjoJ1157LUZHR1FVVcWukclkcPDgQcyYMYM5lql4nEKhQF9fHxoaGmC1WnH77bdjdHQU77zzDtasWYNXX30VlZWVWLp0KVpaWlixmWAwiP3792Pz5s3MaI5GowgGg8jlcgz8e/DBB7Fq1Sr85je/QWdnJxQKBfbt28f0DaJV2LdvH9LpNCKRCNatWweDwYADBw7A6XSiuroalZWVcLvd2LlzJzweD0ZGRqDX66FQKLBlyxb09vYy54zNZoPZbEZ3dzcDHPv7+xGNRjEwMID6+nrmMCH93Gg0sgI27e3tLDvj73//O773ve/B4/HgN7/5DT7zmc9gdHQUNTU1EAQBZ511Fj7/+c9j5syZHwkAjubbmWeeCVEUccstt2D58uVIJBJYvXo1zj77bHzrW9/CF77wBXzhC1/A7bffjqVLl6KhoQGvvfYaOjo6kMlksGTJEvzhD39AKBSCw+H4L9/V+y886E9SLJBEzhbg10/e+SgVOYev1EaQ/i8NQuGpcKT94c/lHcn82l+sT7xTT2pfSsEw6TVIpJGZPIWMUqmE0+nEokWLMDIygo0bN0KlUsEf8KGtvRV79+6FRqNBMplELBFF98EDqK6pglKlyO95uSx8AS+S6QRKXU6kMykWMEEc6uTwD4fDTJ+g/pMeAuCIwnx81gBljtD9UJYSOVt5PY8HW8nBTPfOH0OfiaLIskl4ZyL1hbehpQFmvP4o9zzk5mEx4c+XtstfS9q+9BpSkYLR76d8IoFHflEgo5G4EClaaNKkSXj11VdRXV2NtWvX4uSTT8ZZZ50Fm82GbDaL7u5urFmzBmeddRYsFgtLD5g0aRIee+wxPPnkkwiFQgDyk5BAR4qMOBaQhzgKBUFgkTY//vGPsWvXLjz00EMoLS1FX18fRFFkRSAaGhowbdo0pNNpNDU14fTTT0dTUxNL6+EV1w+TsipNFwRwRH/HE7lNQaVSobm5Gb/85S/xgx/8AOvXr4dCocDGjRtRV1cHhUIBj8fDDCur1YqSkhJYrVZW1Qso9Ejwwi8sw8PD+N3vfocnnngCZ599Ns4//3w0NTUx44nuh9riw/T5xSaXy2Hr1q1Ip9OYM2cOSktLce655+LOO+/Ejh07sGjRIsbPs2jRov984D8GIl1M5YBeqWJBf0vbAY7cKOiz8TxZcm3Q8dlsDm3t7VAoldi1axcrZBUKhVBRUYHy8nIAeQoFmoeUvldeXg6NRoNgMAiDwQCn08m4ILVaLfr6+vDXv/4VGzZsQF1dHWbOnAmLxYKamho0NzdjaGgIDocDoVAIwWAQQ0ND8Pl8sNls0Ov1rGDC8PAwPB4P4y4lHpatW7fC7XZDp9OhrKwM4XCY8cdms1kMDw9j2rRp2LhxI1wuF+bPn4/du3fD5XIhEAjA7/ejr68P06ZNY+BDbW0t9u3bB5VKBZfLxXhWOzo68MYbb+DVV18tiIwiMEahyHO0vvrqq1Cr1WhsbGRpkKQ0bNu2DY2NjQw02bRpE3K5PO/dvHnzWBoGccpRRGX+mDhy2cMgBzmYSOlRa9TI5LLQKrUgdFutVCEcCsFoMCKTTkOn0yIeTyASjbD0SoVCCUEhFIBKpEwWM4ikc1NOMZb7m44VBKFg3Nh7oBDyLKgiAIUABQQIwpG8lJ80kTr4pOsJAGYQk/FgtVrZ59FolOkSZrMZXV1drKgMP4fJmZDNZpFIJKBSqdjezHMKUYo2ORbj8Tjbq1wuF0vhTSaTrPo6gXwGg4EBjvxcD4fDrJhKNpuF3W6H2WyGxWLBtGnTYLfbYbPZ2PtCbZDOwlePJDCNHx9KSafIBVLI+eI0fJYG7fVUwILAQZ7bkpyI/F5Mc5p+U+XLmpoa7N69G4FAAIIgsLQwtVrNxpneeeK2pnsjh67dbmep43xaFoGl6XQapaWlMJlMsFgscLlcaG5uZlkpfr8f8Xi84FrkKKY+UcqXQqHA8PAw9u/fj927d0OhUMDlcqGjowNut5s9N9JlaOz5cZQaMRPy3oicrtfY2IivfOUruOuuu3Dfffehvr4eCxYswBtvvMF4GYF81O7ChQvxwgsvMAB88eLFMBgM2LRpEyorKwuMY0EQGEgdDAYL9F+iKRkYGGCUO6eddhpWrFiBoaEhrFmzBlu2bMHf//539PX1oaamhkUnEei0bds2GAwGbNmyBTabDW63G8PD+fTIL3zhCzjzzDPx2GOP4de//jV6e3vR0dHBqsRXVFRgcHAQ0WgUFouFFcOrra1FOBxGd3d3HoDw++Hz+RAIBBCNRjFt2jSsW7eOOVko1VKv12Pnzp3I5XKwWCwIBAJobGyExWJhRROpOERraytsNhtmzpyJk08+GaOjo5g7dy78fj9++MMf4vHHH0dzczPMZjNOO+00GAwGNDQ0sHH98pe/fEQE8YdZ6P0WBAFnnnkmduzYgcceewzXXHMNtm7ditNOOw333nsvrrnmGlRXV2PJkiVoaGjAww8/jLa2Nrz77rs477zzkEwm4fP50N/f/4kAHscLDOCPOZodKQVupLaC1MaUgofSY4vZJFIgknc8Uxs877e0XSmwyIu0/+PZJ/w59FsaoSlt22g0or6+HuFwGK+88goAwOv1YurUqRgbG0MgEEB1dTWzJ8jOiEQiAMAyPmpqahCJRGC321mUM+kYWq0WsViM8bhTkAXdCwUNkI5CDlZybtBzoQwPcmgqlUrWD7ofKphHICfpCrlcrkA3o+tZrdYC/YP0ufHkePdoubl2NFuV/h4PWyo2l/8bjstPFPDIPxCaMDQxZ8yYgQceeIBVco3FYshms9i6dSu+853vAMhzNXq9XlaB7oILLoAgCHj44YexatUqzJgxA/fccw8OHjxYYKwYDAaWZikIAjMkrFYrM7r5PkonASmg6XSaGdnNzc340Y9+hKuuugrZbBYejwdPPfUUDAYDFi9ejEsvvRQzZsxg6PyHaQOWe4noJabFGHhvyNUVinwF8p/97Gf4+c9/jmeffRbBYBCjo6OsuA8pQffeey/+9a9/YfLkybj33ntZBV65vvMvOa9Ejo2N4fe//z2eeuopnHnmmbj44otZhVAedJQzbOn3zJkzMTIygm3btqGmpgbLly9Hf38/Nm3ahAceeAAGgwHt7e2orq7+j8dHblP6qEkBKINCRUAKtEsVfn7TkIJCctFj/DM/mueIvJBKpRLpTBqNTY2oratFLpNFb28vNm7ciBdffBH19fVwOp0oLS1lKZ1kTAOA1WpFa2srRFEsUFK8Xi/6+/tRU1ODK664AtOnT4co5tPCwuEwnE4nLBYLqyJJGyelM8TjcYyMjLBqrk888QT27NkDm82GFStWYPLkyfB6vXjttdcwNjaGadOmYWxsDENDQ/D7/Wwd27JlC5qamvDkk0/izDPPZEowRScODw8zuoc9e/awoi1USZsqVtbV1cHpdMLj8SAWi6G0tBSDg4MM4Mlms3j33XcxefJkOBwOuFwulu7l8/nQ3d0NQRBQVVUFvV6P/fv3I51Os+il2bNnM1CDyLGNRiMDRcjrqVKpmPKTSqXyVaOVCugORTVmslmolCoW2agQFMgcinJSKBTQaDUwmvKpp8FQqIADjk/HoTkqpyBKhf+O90rza0cxj6lcu6wIk3CInkDAcZZl+mgLPyYULcgr3jxPDymoFMnGg18EGgQCAWSzWQYM7tmzBxaLBfF4HHa7HUqlkjkVSLkWxcK0ZEE4zKnIA5lEpWKxWKBWqxEMBll1aIPBwKIT6fqkOANg0Y5jY2MYGRkBAEZX0N/fzyrnGgwGBqxRhABlTyiVSgZm8mnafIVnWk/JAOCLxZBhQDoIXcfpdEIUxYIiLXwEMLXDjw/Pj039IB1Ho9HAZrNh7969KC0txcjICNxuN3tWAwMDMJlMsFqtjDu2r68PmUyG8dgRKEgVNAn8FQSBOS3GxsZYFU6KTtTpdOyYbDaLeDyOcDiMRCIBUcxXOKdrGwwGhEIhFvlIjiYCPF9++WVoNBpMnjwZ9fX1MBgMbAxp7aBUcsqMkHvHP0yO5Y+DKBQKXHDBBXj55Zfx0EMP4ZprrsEZZ5yBn/zkJ1i6dCmL/lUoFLjiiitw+eWXY/78+di3bx/OPfdczJkzh6Vm07OhSCKPx4NIJIJoNIru7m40NzcDyO/RS5YsKYjGpvWosrISl1xyCS6++GJEIhG8+uqrePzxx/Gvf/0Lo6NyMOn7AAEAAElEQVSjaGtrw6mnnoqWlhbodDoEAgFGvzR58mTU1NRg+/btqKysxJlnnoklS5bgzjvvxIYNG1BbW4uuri7kcjl4vV50dXVh+vTpWLt2LQQhX7ySeKR1Oh26u7tZYIVKpcLOnTthNBrR3t4Og8HA5nkkEkE8Hsc555yDuro6pFIpbN++HfF4HKeddhpEUURNTQ0mTZqEqqoq5lAZHR3F2NgYfvrTn+L555/HgQMHWLTphRdeiD//+c+47rrrCnS9D1Nm1/GKSqXCV7/6Vbzyyivo6elBe3s7Nm3ahGuuuQYdHR2MBuf73/8+vvCFL+Dcc89lFGFz585FTU0NOjs7MXXq1P/2rfxXpViwiNx3/Nzhj5d+LrUbeJGLZKT/pUAifx0+3VpqX/CgplR4nIGuz1+LvuNtIjqHwDW+f9L75G1WHiidOnUqfD4fNm/eDJ1Oh6GhIVRVVSGRSCCdTqO+vh6dnZ3I5XKw2WysqKbNZmOR1yaTidHAkN6iVCoZ/dLg4CCLMDSbzfD7/QX2M/1Ney/pAOQkNJvNrM/kPATA9nhyntKYUDE+AkFpj8/lcgwrIACU17PkAOViz2s8u5F/9kf7Xjq3+GhVvh9ydkWxeS+dH++nfKKAR+DIdDfyak+bNg01NTXo6uoCkCdu/8pXvoKLLrqIKQNjY2NYt24dvvjFL6KmpgarV6+GVqvFrFmz8Prrr+PPf/7zEeHKRqORVWkkoclOL5JU6METn8GnPvUp9Pb2Ys+ePXjwwQfh8/mgVqvxne98Bx6Phx1fXl6Oiy66CJ/97GfhdDrH3Xg/DBuy1MAg7z5wmOvi3+0nf55SqURpaSm+//3vo6GhAffccw+r7j1p0iT09fUhFArhd7/7Hd555x08+uijMBqNaGtrw+7duwEc6Skaz3MkiiJ8Ph/++Mc/4rnnnsN5552HCy+8EJWVlewe5TZEUtz0ej1qamrgdDrx4IMPwmQy4ZJLLmG8dolEAvPnzy8w/P5ToTn5URM5oIX/X+q9lAN8x/Mc8oC9nEIgdy3eCKdCCXw12RwENDc3o7KyEuvXr8df/vIXVFRUoL29HZWVlfB4PHC5XNDpdGwj7OrqglarZaCcyWRCOBxGWVkZM0woLZCKTezevRsVFRXweDysMnUikYDJZEJrayuampowNJTnWnE4HNDpdOjv70ckEsGOHTtQX1/PKnLu3bsX6XQa7e3t8Pl8SKVSKCkpYZs/kcFv2LABp512GiorK9HX18cMjlAohFAoxEDE2tpaKBT5lOe2tjbGz1hXV8cM/FAohHg8DrPZjFAoBJVKBbPZDIPBAKvVWvAuhcNh9Pb2YtGiRQzAMRqNh/hl8pV6a2trkUqlkEof5lWkNFWlUgmTyYxMOsOUFAIMdXodi1Ijr6pSoYCYExEOhwv48NLpNIRDc4YMUQK2+Pkj9VRK553cfOSVSh78kqMGKObckVt3DvfjiMt+LEXqgKSq1XLKOa9UEghFoCTPK6rX6xn4CByOXo5GoyytVqPRFHAKktJPc4uAK3I4kGI7NjYGh8PBAMSKigpUVlay950HHEUxn+acSCQQiUQwPDyMkZERFqlAekFnZyfKysrQ0NDAlPd0Oo1wOAy73c4MfgI/+aJ6FPVJhoJ0zvLRiHQOraP0ThHwCoBFKRgMhgKjiOY2Tyci1QuoTaqwbTabkUql2P1Tpd5sNovBwUEAwNy5cxmHbjAYRCqVYgW+yClis9kgiiL7jt5hWldoneXv3+fzYWRkBD09PVAoFKiurmbH+nw+HDhwAHq9Hh0dHdDpdPD5fDCbzSybxev1Qq1Ww2w2I5lMYteuXdi2bRvq6+vR2NgIh8PBxpyiMRKJhCxvGM3zD4Oe93ERQRBgsVhYuuusWbMwe/ZsWCwWbNu2jdEtCYKAiooKnH766RgeHsakSZMgCAKWLFmCu+66i0UP8vOLdFRBEBCLxTA0NITy8nJYrVakUimMjo6yPvD9IbFarTjzzDOxYsUK/O1vf8PNN98Mu92O//u//4PVasXy5ctRWVmJ2bNnY/fu3fjHP/6BmTNnoqamBqFQCG1tbWhubsZ1112Hr3/963j00UfR1dWFYDAIAFizZg0uu+wyVFVV4bHHHmP6RG1tLfr6+jBlyhR0dnYyLufq6moYDAZMmTIFRqORFT3p6+tjEZFUpOaMM85g99Hf3w+TyYTu7m6888472LdvHzZt2oSdO3dieHgYmUwGHR0dOPXUU3HBBRdg/fr1aGhowOLFizE4OIhMJoOKioojCmd+1HRbQcjzBf/qV7/Ctddei8rKSkSjUWzatAknnXQSHnnkEZx++ukoLy9HaWkp7rrrLsyYMQMbNmzAjBkzMHPmTGa7fNyF18nHi9aTficH4EhFupfxjkdpG3K2AYnc8XI6GbXBV8Pm2+DvUy5rTno9/n+p/snfEz9GPD7CZ+lJ72/u3LlIJpPYt28fjEYj+vv7UVpayvSX5uZmjI6OwufzwWq1orS0FApFPvU6lUoxhxrtf1Qvo6ysjOkZlAVBgVvE1Up7HkUxarVahEIh5uAnfmcq6EZ95mldCPuhbATSQyjTiepAkJ5ltVplQWleFz/ac5azReXmQDEAW+5Zy80POnc8KWZrfBDyiQAepS8v71kgj3ppaSlWrFiB++67D0Ae7KutrcXvf/97rFixAuvXr0c6ncbNN98Mn8+H22+/HfX19Zg8eTJ+9KMfYceOHUcsYlKPOY+sS41POoeEDOzR0VG8+eabrBjEzJkz8cILLyCRSGDPnj0QRRF2ux3nnHMOLr30UlRVVbGXU4qAf9hE7lkA711/pZuATqfDpZdeira2NvzkJz/Brl27sHv3bmYsrlq1Ck1NTbDZbIjFYigvL8e+ffsA5BfR7u7uI3jA5AxUum42m8Xo6Ch++9vfYtWqVbjooouwcuVKuFyuAiOB90yFQiF4vV7G47d06VLccMMNeP7553HJJZegtrYWO3fuxOzZs9+zcaJ7oHH4KIlUCRCKRG4VA2eKKSnSDVcKLsr1g//NX4s2yGw2i0Q8DoVwuKDEKaecAofDgVtvvRX79+/HvHnzYLPZ4PV6WaS0VqtFTU0NS2Uk8JA8ehTp4/F4EAwGGe8JFbYgsCEQCMBqtaK8vJxVrJwyZQoCgQAr5EKGLFFHlJeXo7GxEQCwZ88exh8ZDofZpm61WjE2Nga73Y5MJsOiEsnzWFVVhVQqxVK8KULHZDKhv78f2WwWFRUVCAaDbN3r7e1FKpVCVVUVq7TpdDpRVlaGkZERTJ8+nXG4pdNp7NmzB3a7nVXOi8ViyGQyjOR+8eLFrCJ4Oppma0+Bc+bQWJLyRdFleqOBAS/kPaXzKeKDeP5EUYTmEGBDewulmtH7NZ7zgv4vBj5KFR/eoSVVDOVAdun1Ct6dD0lE/AclFJkGHFbo+IgE4PCYEj8jKao2mw0HDx6EVquF0WiEQqGA2WxmXIgEIFKUGv/siY+Uf848cJhOp6HX65FOp1mq88jICOx2OyZPnszmFAGTxJVEbY2MjMDr9SKVSiEej7NCU8QBPTo6CqvVyrjmtFotK0qTSqWQSqWY8s2nMBGoSXytfFSjdB7y6ycP5vKAIgF6FPVJn9G7x89NPuWYvxb9rdFo4HQ6GTDc1dWF2bNnsxToVCqFyspKVukeyL/LJSUljC+b1gIe/KUiOPF4nHE9UqoX3ScZP0NDQ0gmk5g7dy4bP5PJxN79aDSKXbt2MW5cp9PJ+pdIJBgYm06nUVJSwu7Z5/Ph2WefRXl5OTo6OmCxWFgkCB1P+8B4hsmE/OciCAImT56MpUuX4tvf/jYeffRR1NfX48CBA1iwYAE7RhAEXHzxxbj++uvR0dGBnp4eTJo0CaOjo9i2bRsWLlwIQchTDiSTSZjNZsyYMQOCIGBsbIxxDUejUWac832QE3o/Tj/9dDz55JPYuXMnqqurYTKZ0NXVhXXr1kGj0WDx4sUoLy9ndC1btmzB4OAgampqMH36dIyNjeHXv/41Lr30UvzjH//A448/jnvuuQfBYBCXXXYZfvnLX+L5559HT08PSktLceDAAWi1Wlx55ZVwu92Ix+OYNm3aIWeeiQEKwWAQdrsdyWQSb7/9Nv75z39idHQUqVSKZVHE43FGB0PrGi9qtRrLli1jdtSDDz4IURRx5513Mq7Ixx9/HO3t7cdlhH8YRRAEtLW14c4778SNN96IZcuWwePx4Oyzz0YgEMCdd96Ju+++G48//jg+85nPYMaMGXj66adRWVmJqVOnMttlPAf7x0H4/UWqW/Ggodz3cm3JtSEdQ97e4+Vo4KN0X5S7rhQclX4vpYOR6nNSgBJAAbfkeJRR0nGT6kJ8341GI5YsWQKPx4P+/n6YzWYAef7nwcFBuN1uNDU1IR6Po7u7G0ajEVqtFlarlVHNUJ/4tOj+/n7odLoCRyrdAx99yEccUuFH4mimwpykq1CWgEajYU5WcjiTaDQaVsQmlUqx7IxUKsX6I31uZEPwYy0d32L24nj6unS8i51bDMQcD9gcbz2Qs4ffD/lEAI8kfGq1FMFXKpWM6yQYDOKNN95ALpfD/Pnzccstt+CMM87A8uXL8Ze//AW9vb247LLLMDAwgP/93/8tKEoCHE6vpgg2QN5TaTQaGdcRVVGll+szn/kMzGYz1q9fjy9/+cv40Y9+hLGxMaxdu7aAw2DZsmX4yle+gvb29iMAR+l1P0wil8rKbxLvtdCz1ul0WLhwIf7v//4P999/P5544gnEYjEGDg0ODjKunVgshhtvvBH33XcfysrKWIUu/qWXLthy1wXynty7774bTz31FK688kqceuqpMBgMzCgNBoMwGo2syvHu3bsxa9YsZLNZmEwm9Pb24lvf+hYzJNvb24+78E4xkQPNPkoi9frlxJzsoi7d0I/lfvn1gqRYu1JFgoiNM5kMFyWkhkI47F0D8tFRfX19uPDCC7Fs2TKWeqzVamGz2ZBKpTA4OIje3l5oNBq0t7cjHo/D6XRCo9HA6/XC5/OxDfPgwYMMyAgEAhgcHITdbkdVVRUOHDiAZDKJhoYGDA4OYu/evWhsbGQFjdLpNIaHh1FVVYVwOIwDBw6gpqaG8bbs3r2bpXiaTCYW0U1FEWgdCwQCKC0tRSQSQSKRgN1uZwoHgZU0ZnQNSt+m4jqlpaXQarWYOnUqdu/ejWAwWJCiGQ6HGX+Mz+dDe3s7IpEIcrk8gf7IyAhGRkbQ2tqKioqKw8UsuOp0/FxIpdPQarWIRqMsZSyVSrHiGwBYqgVEEblsjqVlMyBSPDKFmi+swa8VfDqvnIInnW/FFBM5XkKpEssrrdJ19uNumJDwY5pOp1lREgIceR49Op72qVAoxKLoyBO+c+dOKBQK2O12BtyVlJSwlJ3R0VFUV1ez95kKvBCIQA4C2nsAsAhKAhw9Hg9CoRCqqqrgdrtZ/wnMEgSBKdixWIxlQ9BnVqsVDoeDHR+Px1l6NlXspXul91cQBFZghlKHySFBhaZo/vD3wBPcA4fnGg86UgEno9HInCpUWCeTyTDgk96XYsq51CiiqMdUKoWpU6fiH//4BzweD1QqFfr6+tDW1sbuhdJHKS2LnIl89HD60Fqg0+kYOMQDpXQcRaxFIhG2xgNgYC1FcgCAzWbDvHnzsGXLFuzbtw/t7e2wWCyMWoOKcsViMeYkyeVycLvdMJvN2LdvH3bt2oXq6mrMmjWLRZDQWPA0EXJ70sf9/X4/hR9LtVqN73//+7jnnntw/fXXIxAI4HOf+9wRx5eWlmL58uXo6enBzJkzGQfz+vXrccIJJwAAIpEIKx717rvv4sQTT2ScrbSGhEIhhMPhY+ojkJ9nd999N772ta9h0qRJ2LRpE6qrq7F8+XJEo1GsWbMGb7/9NioqKlg6uNfrxfPPP4+9e/fCZDKx6MIrrrgCZ5xxBm699Vbcc889eOihhzB79mxcdtllmDFjBgPy+UJM4XAYL7zwAvr7+9HT04Pt27djcHAQ4XC4wOCXS1eVzlupXeV2uxnPqtFoxAMPPACv1wuTyYSnnnoKmUwGdXV1/9Yz/jCKUqnE7Nmzcf311+O3v/0tzGYzhoaGsHjxYqxatYrZAy6XC0ajESaTCZ2dnWhoaCjIsvgkiFS35/cdchKNp/fz+rwUJ6DvpVGCctenY+WAR7nzeB1kPDCI1xuLAVJy5/FRmnI6pDRNtxhgxdu8tOcYjUYsXboUzz77LPx+P9xuN3PM9g/2IRQOobysHE1NTcxOSSaSMJss0Om1UCgVzN5Op9NsvyXdnpyABoMBmUyGBS3o9Xq251EWRTabhdPpZKAhjRXp30QnQ/qZKOZpWgg3IT2AzqG2CYwURZE5ZaXFZKRzTDpeUjCa19nlgGjpmPP/y80fOZB4PJF7Vz5I+UQBj8CRodG8NDU1YenSpXjqqadYhcqf/OQnLFrnqquuwsyZM/HNb34Tf/rTn/DHP/4RQF4Roc1UqVQWVC+UXhs4PPkImKyvr2eeQLvdjn379mFwcBAbNmxgRPUEXgD5CIXZs2fjiiuuwAknnACNRsOMJum1PqxCLynvJeCN4fey/3IvfUVFBb73ve9h8eLF+PnPf469e/cywyyRSLBKw8888wzi8TjWrl3LFkJ6FoJwmFOi2KLB/y2KIjo7O5mnfNmyZTj99NNRW1vLwMXe3l7MnTsX8XgcP//5z9HR0YGvfvWr+O53v4toNApRFDFv3jxmhP6n4yTdoD9qwiuocoAg3ZtcJIh0XkifF79pH01pKSZ8pTRRFCFChCge7mMmk8Gjjz4KrVaLyy+/HEB+XXA4HAyA2LJlCwPKTCYTi1AShHx0BEUNvvTSS8hkMigtLUUmk0FrayuLBAqFQujq6kJbWxui0ShSqRSqq6sRjUYZjYPFYsHQ0BDMZjM8Hg8qKiqYwmC1WlFTU4MdO3YUGORGoxG1tbUYGBhAe3s79Ho9+vv7EQwGGYm+RqOBXq9nnGsE4PAcdqFQCKWlpSytVKvVIp1Ow+PxAAAqKysRCoVYpKfP52NRP4ODg6wfBw4cQGNjI0vNiMViWLRoEYuMzANMeWXC7XYXzJFMJg2lRlugsJMXlaqMZ7NZBlaI2Rzj16N1IBFPIHEIOA0Gg9BoNCzqgweYjuZkKQYyShUXqdLBnyflKZQCkCQEkn8U3/9jFSnoSIY8jYm0ojS9+6SQ8mm0vb29GBoaYsA+RcfRGkpzNx6Po7W1FWazmQGbsVgMGo2G7dl8JCSB8jTP+vr6EI/H0djYyEBC2jdJSSYwfWRkBOl0GhaLBaOjozCbzUin03C5XOz5Em+p2WyGXq9n16c5QlFWVBQpEomwCrfkRKH1kByk0jakgAGdS/OOJ2une+F5NUUxz/nIRyJLjSYpBzS1T0ZEWVkZ6uvrsX//fgaMEGhI1AjBYBBWq5VFbhOfJRXs0el0DMClZ0Uk9BRpbTKZEAqFWLq71+tFKBTCwMAAXC4XrFYrzGYzzGYzGzudTodJkyZheHgYY2NjqKmpYXxUdrud3ZdKpUIoFEI0GoXdboder0dzczNisRh2797Nor6rq6uRSqVYtCPNYwKHP+x64EdJaCxzufy6f9NNN2HVqlXYvn07Pv3pTx9xbC6Xw6mnnorrr78ey5cvRywWw/nnn48nnniCRdmKYp5ix+PxwGg04rnnnsMdd9yBQCCAXC7HInIrKyuPq4+VlZW4/fbbcdNNNyGZTDLwcmhoCP39/VAqlejr68Ntt92Gk08+GV//+texcOFCBAIB7Nq1C729vQAAg8GAU089FY888gjOOuss7N27Fy+++CLWrl3LnI80HoKQj+CMRqMIBAJM9+HHYzz9SaFQsHeY9ll+XxJFEZWVlfD7/di9ezcmT56MsbExaDQa9PT0wOPx4Ic//GEBNcNHUeT00tNPPx1btmzB3r17YbPZcOqpp8LpdGLVqlX4zGc+g+rqajzwwANYsmQJEolEAY+s1Db8OIqcbl4MpJGTYkD3eOfLOXfk+iTdF+VAIl43o8/4dGp+LkgxDH5vlMM36DPaZ/n/pfdG7dN1pRyG/PUpA8vtdmP+/Pl45ZVX0N3djYqKinxRN00Fdu3cDe+YD9XV1Sh15gFyv88Pn9ePkZERaHVa9Pf3s72P9mOTycTARsoyUigUSCaTTJ8mIUcb2SXUd9JLRFFEJBJhGWRUfZtoUEg/4IvKAGAZLolEgjmDeL2bxoZ3APN7hByAy9ujxead3HOTzjGpbj+eyM3TYn9/UPLRXqGPU3gll/4nEcV8qsqFF16I1atXIxaLYfXq1TAajUin03jggQcwZ84cnH/++bjtttuwbt061g5xE2WzWRYBxKc+8dfgJwEpH2q1Gu+++y5T6BsbG/HpT38aBw4cQGdnJ+655x4WwdDa2oqvfvWrWLZsWUHEzkdNyNijZ/B+RTqOd229Xo8VK1Zg6tSpePDBB/HXv/4VoVAIuVwO3d3dqK+vR09PD5YvX46tW7dieHgYBoOBpaTRcy/2nItJKpXCli1bsHXrVvzxj3/EF7/4RZx//vmorq7G9u3bceedd+KKK65AfX09fvrTn6KpqQkajQZA3tA8++yz37NoR/45UDrpR0l4w52APX7TlPKcHoviIOft5Hm06G/adGgDkNvIjwBBcyJyYo4Z8nv37sWWLVtwzjnnMCOXKrHG43Fs2LABPp8PGo0GJSUlLJ2ZQLREIgGfzwen04mWlhbs2rULY2NjUCqVjIMsEokww+Wtt95CR0cH+vv74fV64Xa7UV5ejr179yIWi2HGjBl45513mHFOHLY+nw9arRZ1dXUMJCA+lIaGBrjdbgwMDGDypEkoORRhlcvlYLfbkUqlYDQaGRhnNBrhcDhQVVWFjRs3osTugOIQQKnRaJjirFQq0dLSwjgry8vLYTaZoNPk01ubm5tZBFVdXR08Hg+riJlIJLBv3z60tbdh0pTJyOSySKZSsNlt6NzXyaoF07Ok9A1RFJnnlaKeROFwKiwBF1qtFrlsDh7vGERRzEdnKnVQqlUsxdVkMrEqtnabHYl4HF6vF1qtFqWlpXmjCkem/BdzjEmVBTmlQ9qGFLSRKjr0m6LOPs5CawKl4ZM+QM+dN4zpfU4kEjhw4AA2btwIv98PnU4Hs9mM9vZ27NmzBw6HA319fWhpaWHcigQyBwIBZvRRJXqj0cjAQoqiIz2AvPbxeBw9PT2Ix+OsUBL//AjAoihBKjhntVoxMDDAeJYIPCOPPQAGsvHKOfWXSNoJeKM1gIDKXC5XkLYknbOCIDDnmMViYeMuZ/zyayalr9OayBdiI6HI8fGie8lAEQQB7e3teOmll9DX14fm5mYWjRgOh6HRaFBdXQ2bzYY9e/awKuEUAUsGBM0Hqk4eCoWgpwJThyLW+YjDnp4ebNu2jRUMSaVSmDt3Lk455RQYDAYYjUYIgsAoMgKBAEKhUIHzggDDaDSKqqoq9Pf3s+dmt9uh0+kwdepUhEIh7Ny5Ezt27EB7ezvq6+tZ+6R70v8T8t4KjalWq8XKlSuxcuVK2eOoCvXZZ5+NZ599Fp/+9Kdx4okn4v7770dfXx97Znq9HpWVlYjH41AqlXjzzTdhMBgYp2smk0FLS8tx9VGlUqGjowO///3v8dOf/hTr1q3Dli1bIIp5brbPf/7zeOedd3D33XfjhRdewGuvvQaXy4UFCxbAZrPBbDbD4XDgpZdeglarxZIlS1BRUYE9e/Yw/rN0Oo1AIAAAjD/1eIQyw0488UTMnTsXJpMJkyZNQklJCUZGRlga9j/+8Q90d3fD6/ViYGAAZWVlqKysxO7du2G1WvHcc89h+vTp+PGPf8wA0I+baDQaXHfddbj44ouZ8/a73/0uvv71r2PFihW4/fbb8etf/xpdXV0spfXgwYMYHh5GRUXFJ8oJIQfiSAEfuf2DP06uLfq/mJ4mBzRJz5MDeeQiDmn/kbuu3GfS+5Gml0vHhPQI/ppHu2+p84/GU6VSoaGhAT6fD/v27cPQ0BBKSkpQX18PndaAndt3YteOXTCZTHCXuVlVa4VKAYVCgMfjYcX0tFotLBYLiyzkIxdJRyG9BzicpUAZSaIoMsCS2VyHfqhYpCjmi73FYjHGuU1/82ndVGyO9DLS06hdnoNTChZK5wgvxZ4H/xzk9HppRKycDXA0sJ2fD3Lz9oOSTwTwKH1YxSLrBEHAtGnTsGTJEjzzzDMwGAw488wz8cQTTyCXy2FkZARf//rXMTQ0VPCQqDqqWq1GOBxmk17uGtQH/qWg/pjNZkSjUezduxfXXHNNQfGVtrY2XHzxxTjllFNgt9uPSAv7KIncYvlBXlf6mdvtxk033YSTTjoJ99xzDzZv3sxSNsLhMNatWwedTge9Xg+XywWDwYDBwUEoFAoEg8GCZ8lfZ9KkSejq6mKghrQfoihiaGgId9xxB1577TV8+9vfxmmnnYZYLIarr74abW1tqKiowNatW9mcmTlzJubPn/++jMmxAA/r16/HXXfdhc2bN2NoaAhPPvkkzj33XPb95ZdfjocffrjgnBUrVuD5559n//t8Plx33XV4+umnoVAosHLlSvzqV79iQPrxCB9BAwAKQQFRKExrkHqXjlWkHj454RU66TFy5ykU+QrIer0e4XAY9913H+rq6nDJJZcUpA1s374dPT09SKfTqKiogFqthsFgQCAQwNjYGIDDBYFMJhN6enpQUlKCBQsWIBQKwWazMQCB+mK1WjF37lxs2bIFKpUK8XicVbuuq6tDT08PwuEwKioqoFKpUF5eDrVaDb/fzwifCTQhDia73Q61Wg2Hw3EocmMMZrMFWp0OBw8exKRJk9gYaLVaDA8PI5vNorKyEm63G0qlEs3NzRgaGoJWp0NVVRUGBgaQTqcZj9y0adMwOjqaB+pEEdlcvhCF2WzGjh07YDQaYTAYMDY2hsmTJ0Or1cLv9yOZTGL5qafCarUyvr1IJILO/Z0MjKANXaPRQMyJGDtUjIKPptJqtWzTp/kmiiL0Bj3CkXBBRJcgCDCZTEzJKSkpQSQSgXdsDGazGaWlpaxin81mg86gP8J7LSdyioJUqQYKU4D46Er+t3Qd5D3rHzeRKl2xWIxxhxFIQ0LjkslkWJrzW2+9haGhIbS2tmLevHkQhHyBCY/HA7/fj+nTpyObzSIUCsHhcECj0WDNmjWswjpFJ6pUKgYskbJLfK2JRIL1haKS0uk0qzZNkWzA4YJzPN8RAFRUVGDv3r2wWq0MwKd7NxgMDCwkgItoFejZExhL5Oz0TgBgfeQrwFPKJDms6Bxaw/nUIwAs5ZjWrGg0yo6jftC9EAWJ1KMvNQp5I4iuRwZIbW0tmpqasH//fqjVarjdbiSTSRgMBrY2plIp7NixA/Pnz2dgHRX0IqOCwFmtVstStShKm6JO/X4/Ojs70d/fD4PBAKfTiRNPPBFKpRLPPvssHA4HZsyYwbg9yUFNTk6+OBA5sqjiJxXwoggwSmtVqVSM/mXTpk2s8q3L5WJRYmRgjWcQT8jxy7Ho3fS9QqHAKaecgkcffZRFqFJ16Pr6evbuETUJVbiuq6uD2WzGvHnz8Le//Q0XXHDBv9VHl8uFO++8k1GeKJVKRoty0kkn4e2338azzz4LAAgGg3j22WeZE6O8vBxtbW3o7OxEJBLB1q1bj7gOH8hxvCIIAs455xy0tLRg0aJFePHFF/Hss89i+vTpTJ85+eSTce655yKRSGDr1q14/vnn8fTTT6OxsRE9PT2w2Wy44oorcOqpp36kbSI5keqVJSUl+PrXv45bbrkFkydPRkNDA4B8ur7T6cSKFStw+eWX48tf/jL6+/sRi8Xg8XiOOVr24yhH02mkIJF0zHnb4YggAhmgrhjwU4xbUe4a/N/F+i8Fuvjz5PAG/jxeV5TWVZCCW1JQjP+O9kxyIMydOxepVAq7du1COBzG3r170dzYjDlz5uDdd99Ff38/i1C22WxwupxwOkvgcrkYRQztvbyjkXQBCgrg06ZJVx8ZGYEgCIw7n/ZpWusAMNvKYDAUOGPj8XiBfUDBY4IgMF7naDTK7CmeN5MfF358eMcl79ym/6VA7njPi3+u461tcqCk3Pz5MOgBxxVmdssttxwxyG1tbez7RCKBa665BiUlJTCZTFi5ciVGRkYK2ujt7cUZZ5wBg8EAl8uF//mf/ykIm/1vCiHqX/7yl5mx+tRTTwEAampq0NPTw0BHfhLwfEf8izyel8lms0GhyBe1ofQYAi1FUWQvXVtbG374wx/i4Ycfxmc+85mjVquekOMTQRAYAS1xP954440oKyvDSy+9hJGRESSTSaxYsQJXX301lEol45Dhq5UTgMlvLn6/n/0t3aT4lz+Xy2H9+vW48sorsXbtWpSUlMDj8eCVV15BSUkJW8A0Gg0uv/zy97Sa9fEKVSS89957ix7zqU99CkNDQ+znz3/+c8H3n//857Fz5068+OKLWLVqFdavX4+vfOUr/1Z/+IgT6eZLiz9wfCC33Lt7LF4hUjCoL/Q3n0aYE/ObfTKZxEMPPYS9e/ey9SYajaKvrw9PPvkkVq9eDbVajZaWFjQ3N6OsrAy5XA5WqxVlZWWw2+1QKBSsqAlFT/T39yMUCmFsbAzd3d2Ix+MoKyvDnDlzUFdXB7VajcbGRpSVlTEj3Gazoa6uDrW1tchkMjCZTHC5XAgEAlAoFIybxWKxMN64lpYW1NbWMoM+mUyirKwMao0aRpORpRoeOHAAZrOZcaMZDAZ4PB6YTCakUikIgsAiIGOxGEpKSlBRUQGtVltAbeB2u2GxWPIgQpkbtbW1SCaTiEajsNlsbA1VqVTwer3Yv38/3G43DMZ8ga90Os1Ir0VRZCmYBATki/KkWRoaAVNUPZZPMeXPowrctMmTIabX6xkgYrfbGdhBqfB2ux3RaBTDw8OMxy+ZTB6RoiGdc8fi0ZQeJ+fooXWP7u/jZLCRSN9VKZ8f/aZnS2Da6Ogonn/+eTzxxBMwmUz41Kc+hdmzZ8PtdqO6upoptG1tbSya2G63szTbgYEBzJ49m0UK8oozzR1SrlUqFZvXoiiir6+PRcFRsScCSikCQPq8KioqAOQ5o81mM0sNpnumiEJ61gRM0jUpSoA+pxRhImKnOU9VJkOhEIuQjcViDDiTOlT5itsE4AWDQTbWlCJFx1ABF7PZfEQmBL9X8umX/NymsTSZTCgtLUVVVRVsNhu6u7vR09MDl8uFmpoaxGIxJJNJpNNpNDc3s/WZIhzIwQKAcULpdDqWdk4ArlKpRDQaRSgUYlHOOp0Obrcbzc3NLEW+s7OTceZRP6PRKJsDlNJF95JMJtn6IYoimycOhwM2mw1arZalZldVVWH69OkIh8NYu3Ytdu7cyfj04vE4a/u9dCp83O2A91qocOXq1auRSqVw+umn44UXXmBZMxQZSfQGbW1t6OrqQjgcxubNmxkA/e8IrfM2mw1utxtOp5O995QxoVar8bWvfQ2vvPIK/vWvf+Ff//oX7rrrLlx99dWoqKhAMpnE8PAwli9fjtmzZ8Nutxc456R0HscjmzdvxlNPPYVrrrkGf/nLX/D000/jmWeewZQpUzB9+nSUlZWhq6uLARs/+clPcOONN2Lv3r1obW1l1Z35/nwchfaQk046CY2Njfjb3/4Gp9OJ6upqdHd3A8g7WxwOBwwGAxoaGvKprIecXB93GW99o7GTZjhK9yv6nNfh5ZzCcr/ljpU6NaXAlBQo4m0OqbNNDvDk90DexuDP4/szngO6GFAl7a+UkocHBo1GI2bNmoWysjIA+X2sc/9+AMCsWbOwaNEitLa2Mt7lnTt2YM+ePdi+fTvLFkkkEox/mSgXSI8m+4P2Ra1Wi0AgwLIRPR4P44kWBAGhUAh+v5854MimoDao8jVROkSjUQiCgGAwCK/Xy5zUpO8QRRVhNPS3dH/lx1HOjpTiR3Jzd7x1VIofyAHUcvOIf45y5/Fz7P2W4454nDRpEl566aXDDXB8Gtdffz2eeeYZ/O1vf4PVasW1116L8847D6+//jqAPEJ+xhlnoKysDG+88QaGhoZw6aWXQq1W4/bbb38Pbuc/Exr4qVOn4txzz8Wjjz6KeDyOZcuWIZlMoq+vjx1HD54qtxGnGKXiUCqSVOg8v98PQRDg8/kQiUQKjlGr1WhtbcXnP/95xuUht6l+3AzF/5bQc1co8oUCvvzlL+Pkk0/Gb3/7W6xevRrxeByrVq2C2WxmVfdOOOEEdHd3s8gmr9dbEEEFAAMDAwXXKHZtWgB6enpw4403YtasWYhGo4jH49i0aROMRiNisRgWLlyIxYsXvy8gwbG2edppp+G0004b9xitVss2H6ns3r0bzz//PN5++23Mnj0bAHDPPffg9NNPx913382M6OMR6WacQ+EmPp43spgcy6ZAxqLcxi4dT/4YpUKJgYEBDA4O4oYbbkB5eTmefvppjIyMwGq1sqgZlUqF4eFh5r0jw9fn8yEYDCIcDsNisSAcDjPjftq0aTAYDPB6vchms9i9ezcaGhoQCATgdDqRSCTQ3d2NxYsXw+FwsFScsrIyliZpNBpRV1eHWCzGjHmDwcAKQbhcLgBAWVkZq2zNpyJaLBak02nU1tZi9+7dAPKOluHhYbS2tmLz5s3QaDTIZrOwWq0wmUwoLy/Hzp07AYDRW1Al75qaGkQiESgUCnR25qMVXS4XhoeHUVJSArfbjc2bN6OlpQWjo6OoqqpCNpuF3W7H4OAg6urqUFpaiv7+fuzbt4+llLJK44kEVCoVkskUA28AMO40Su3glUn6jCLEotEo44whEIMK5RDoQ6ndxCdXWlqKrJg7QnHhU/mPxZMtN1dpHZI6x+RASr6Nj5vQuFFKPu+koOdJhngqlcLWrVuxZs0auFwuVhCCgG3iNIpEIjCbzbDZbEw51mq1jPvRYrGgqakJPT09UKvVSCaTLFKRf1bkVScAmDgaiRcQOMz3BxwG3fgq0BQdqFKpUFlZyZRuKpjGV6fmo1rJeUntUEEn3itPkb4mk4nxP1J/aW2gtEs+PZpfF8lQoTlOHJcUBUoAJUV/xmIxVgSGHzPqK0X+SXke6RiDwcCK9JnNZhYZ1dXVBY1Gg2nTpkGlUmHz5s2YPn06SktLGTBLfaR0Koo+pPRn6nMwGGRALfUlFAqx+/H7/XjrrbcYcOzz+RgQaDQa2ZpD1dBpDOle6PkqFArmsCAQmNYqosGge04mk/B6vdiyZQsGBgbQ0dEBl8vFItVJL32v5ONsB7zXolAocNFFF+GCCy7A66+/juXLl+NnP/sZenp6UF9fzyhXqNp8b28vzjrrLPbMCGz+d0QKdtD77fF48NxzzyEcDmPSpEl44okncNppp6GjowMqlQrvvPMO5s6di9dffx3Tp0/H0NAQA9tHR0fh8XiwceNGvPTSS4wDNxgMMkeHnN4kBX4UCgV6e3vZPpzJZHDGGWfglltugdvtRl9fH1KpFGbPng2VSsUoji655BJUV1fju9/9LnPSfFz3L6BwbzYYDLjjjjtw0UUXYcuWLZg8eTJeeOEFnHTSSXA4HPjiF7+IdevWYcqUKQxw/iTLePNCCsIczanL759SQK4YWMPbg3L6WzEASQpQyfVNGnAhvYbcPfE0VPz90bHSaDz+neWBVLlxoeJ606dPx8svv4xUKoVoNIJt27bBarWiqqoKZWVlKC8vx+joKJQqBdSaPMUMRWMTLZMgCKxCNd2/UqlkDsBAIMAK3hHXLGUiUNSjQqFAKBRiEZlUkIYce7FYjBX2Iqcnr6MQ9Uo2m2Uck0Qhwz8X0u+lz5SfF1JbUE7k7Eb+HCngy59zrOCl9Dh+jkh/v59y3MAjpXhIJRgM4sEHH8Sf/vQnLF26FADwhz/8Ae3t7di4cSPmz5+PF154Abt27cJLL70Et9uN6dOn47bbbsO3vvUt3HLLLczL/H7KeAAQAPYCffGLX8SaNWvQ29uLDRs2sNLv/LGE8pNXmfijCCSg6Aqp8JOFooWovfb2dlxyySX41Kc+xQhX3w+gaULyIud1UqvVaG9vx5133onTTz8d9913H7Zv345sNovq6mr09PSgoqICXq8Xw8PDLHKBojn4TeNYrsl/plAo8Pbbb0Ov10OtViMUCgHIR7Vcd911BbxNH9Y5sW7dOrhcLtjtdixduhQ/+tGPmMd+w4YNsNlsDHQEgGXLlkGhUODNN988gqSdhH9PALBxkW68+b+PrGRHIjf2cnI0z9/RPIjSc+k7JWcoT5kyBQCwfft2mM1mVuyktLQUg4ODBcVkyEAPBAKMksFms8HlcqG+vp61bzAYWBRkJpNBY2MjAwcjkQhsNhsmT57MvHwWiwV9fX2ora1Fa2srTCYTxsbG0Nvbi8mTJyMQCDBwZWxsDIFAAPPmzcPAwACr8Esbu8/nY+0qlUq43W5EIhF0d3djxowZCAQCcLlcaGxsZN5Ni8XCDP+SkhLEYjEGplC/KdKHjPF4PI5IJILm5mY2L9LpNCsKQwpLNBpFjaEWBoMBAFjEltvtLuBqJd6X4cEhlJeXQxTzEVmBYACGQ9yUvBeclACaW1SUgtJF6XlRWmsmk0HiUDQUH02ZTqehVB9J/C5VhuXmqVTxk34u14ZU0ZamyH0Qns7/hoiieMT+zSvYBHq9/PLL6OzsxOTJk1FXVweHwwGr1QqVSgWdTodkMon+/n72jEtLS9nc8ng8yGaz8Pl8DKwkbsBgMMg87cDh9GJByBdjoKhequRIzkziU6SIQ1L8KTVZFEUW/UjrA80vAvZJOadxAA574QnYMxqNCIfDLL2a57Ol8dLr9QWp2Xq9HsFgEDqdjoGBBLzR2kvvFwDGCZdKpWA2mxGJRJj+Q8p7OBxmSj8flQUcpg1IpVIsMpiir+neeI5Hei9LSkrQ39+PKVOm4ODBg0gmk5g3bx5aW1uZzsan3tP5BLzSdWls6f0hDleKoqCUZlo7Nm3aVMBJSZGRTqcTBoMBZWVlzOjhwWACoxUKBYsUp89FMR+ZOjo6ytoEAL1ej7q6OiSTSTQ0NGBwcBCvvPIKpk2bxowwioL9d5xwcvJRtwM+aCktLcVVV12Fp556CqeffjpaWlrwxBNP4KabbkJrayv2H4oM2r59O6qqqrBmzRosXrwYq1evxrJly95T/t1sNouf/exnWL9+PSoqKjA8PAyNRoNvfvObeOihhzAyMoKqqiqMjIxg2rRpMJvNMJlMLDrIYrGgoaEBM2fOxPXXX4+DBw9Cq9VizZo1ePnll/Hqq68ygJycijabDRUVFXA4HIy2iKLynE4ndu7ciX379iEWi2Hjxo04//zzMWXKlIJINVrvbDYblixZgpkzZ/5b9DwfZRFFEdXV1fjlL3+Ju+66CyMjI5g1axZzLp133nl47bXX8JOf/AQ33HADK0L5cRapjjTe2ianB40H2kjBI96uk1LZAEfyNQLjF6mRs+2lfaTrSoHPY8nm4tuSS/GVAzd5nZGn4SHdgoT+552OSqUSTU1NMJlMePmllzEyMgKf349gMMhoQuwOe55XOZuGiHw0ImUMUDQ/6eS0z5tMJpYCPTo6img0Cr1eD6vVyvSnSCSCTCbDbKA816kGfr+PZV+QHpNOp5HJZBg/PtlL5PSLRCJQqVUQcyIDM2lvFwQBEIFsLsvoU+T4OMezNaXPQKrD0/nS8S32fIvNL6kUAzU/aDlu4LGzsxMVFRXQ6XRYsGAB7rjjDtTU1LCUgGXLlrFj29raUFNTgw0bNmD+/PnYsGEDpkyZUrAYrlixAldddRV27tyJGTNmvDd39R+KQqFATU0NvvrVr+KWW25hSh8POFBxEko14kUKPgpCPiKhsbERnZ2drFIqr3AShyMBjuOlaU/I+yP8Ag/kFfrly5djzpw5+Oc//4k//elP6OzshCiKePTRR2G329HY2Iju7m5ce+21+Mtf/sJIto8GPkpFFEUWMcWnBAJ5o2flypWYPHnyh35efOpTn8J5552H+vp6dHV14Tvf+Q5OO+00bNiwAUqlEsPDwyxijoTSyIaHh4u2e8cdd+DWW2894nPZjRSHo1UgM15Heza88cynEtC57DocCCmnqFDfpACSAoDJbEZ5eTmyuSwqq6qQiMeRzWURjydYJJ/FYoHBaEQiEUcinvcI1tXXwWwyo2PSJBgNBmRzOUAUoVAqkctmkT0ESDgcDlRWVaK7uxvZTBZ6gwF2ux2d+zvhdrtZVNG+ffvYvGtqakIqlUJtbS0SiQSGhvJAXDQahclkgs1mg8fjwcGDB9Ha2opdu3ahqqqK8U/abDZWlS6Xy0GhVBzmX1MIDMCrrKyECBGRSBRarZYZ+FVVVdi+fTuL+qS0T4VCAYfDAY/Hg5qaGmg0GrhcLnZd4sDt7e1FdXU1+vr68qBjTQ2qDlXWHvN40HOwBxq1GiUOBzPmqVpdV1cXPKMetLS05Dd7lZJV1yNghE+TpUguAmVJKeJTYQns0mg0UKvUSKWoIMfhKnqZbBZijlNCFQIgihC5uSj1dsrN12JAo/Q94RUcXuEkb+/HTUh5o/WUNzQo9TUUCuGZZ55BMBjE/PnzYbfbYbfbmZEcDofR1dWF4eFhWCwW2O12Fo0biUTQ398Pv9/PKrJWVFQwWoSxsTHo9Xokk0kG/NCY0zOlKtsOhwOhUIiBWXQ88TXSM6L1KZ1Os/ugeyKeQIogEkWRAeFUmZkHoSj92mq1IhKJFFAE8MYG6TA0VyitmCIOCOCk6xOoSYozAfNknFDxJooKDIfDLKKAiq3Q86LfFPVEkd9S44uuQVGmNTU12L17N4xGI3Ng+Hw+vPHGG5g5cyYymQz0ej0CgUDBmPFrPp/iTu+TxWJhZPjUn/LyctTW1mJwcJCNYyKRYN9Rf+meiWuKIjKYQYNCPUQQBGZEUdQFgd1kpPl8PlitVrhcLoyNjaGpqQm7du1CT08P9Ho9o2ZxuVzvme7w37ADijkfP+xCc/ncc8/FmjVr8M9//hNLly7F7bffji996UuYOnUqnnzySZx66qn4/e9/D0EQEIlEsHnzZvh8PixatOg91fkGBwexatUqXHjhhZg1axYWL16MdDqN++67D3feeSerHN3U1ASHw4G6ujo0NjayiGiKMNy/fz/WrVuHtWvXYmBgAAcOHEAymcTMmTMxd+5cLFiwAM3NzWwMamtr0dXVhY6ODrz11luYP38+urq6UF5ejh07drBqtf/zP/+DhoYGLFmypGC/ojXpnXfegVqtZjyYnySh8ZgzZw4efPBBBAIBOBwOFuFltVrx61//GpdeeilmzJjxsS8YB4zvoAWOHVjh9xqpPsXrX3L6FR9ByAOOvL7B2wt8W8X6LmdT0DV4fkbeoch/JwVVeUee1HaROrKlfSQnHTn35KhQ+PuuqKjA2Wedg5deegk2qx+xWAx79+5lwKNSdZiqiAryRSIRxrFMehsFH1DRyWQyyQBAorfhHXzEjQzkK2QbDHpksxnEYlFGi8Tb2FarHUqligUO9fb2HnKGAiaLCWJWRDicz7aioAydVgetRodMLu/UMxqNLBKSd5pJbVP+c35+FRN+7vFtFNiSMplMctfhP+PbkAPePwh84biAx3nz5uGhhx5Ca2srhoaGcOutt2Lx4sXYsWMH85pJQ7vdbjcDFIaHh4/wwND/44EO/w2FQ6VS4dxzz8WLL76I9evXs89JISVUXcrjQA8xHo8zBZGigHp7e9lLA+QBx/b2dlx88cU49VARBL666IcZYPq4inRBoHSFiy++GMuWLcMjjzyCv//97/D7/VCr1Zg0aRJ2796NRx99NA/2VFYW8IDybRXznvGgI5/SRt93dHTgkksuOaIy6IdRPve5z7G/p0yZgqlTp6KxsRHr1q3DKaec8m+3e/PNN+OGG25g/4dCIVRXVwPAEaCMKIpQCAoIEICcCFHMQVAo8qAOdzy/eUoVBF5hk27Y1IZUKeYXc97LSELnZjIZlDhL0NTSjN7eXpjMJiRTSSgEwGjKF3DQGw2wOexIp9NwlpYyzjWmjCgVSGXSrH/IZVk/VCoVnK5SOHIlcLnd6OrqQl9fH2pqalBZVZVPu3aVIhqNYs6cOfD7/dBoNPD5fCxihkAQv98Pt9vNuB/dbjfzTjY1NRVEWVmtVsZVqFSroFAqoTPoUVLqhKBQQKVRI53NwGHKR1h5fV5WnIYAO7vdDkEQ0NLSgmQyiZKSEqbIhMNh1NbWMiCBUjs6OzsZGT4AeL1e6PV61NbWIhjIp0UODQ5haHAQdrsdVosV8Wg+HTOXySIRi+PA/i5UVlXCZDFjbGwMI55RVFRUFChwfEqFUpGfXwoIUCmUELM5FuFFgASBGVqtFplsBqpDYEx+ngnIijkoIEBQ5pWw7CEgTKlSQRAKFeHxInilc1f6P/2WW4/of6mH9uMkFKnHr7/0/kajUfzrX/9COp3GzJkzWZqzzWZDLpfD7t27WUSP0+mE0WhkxZ7C4TAOHjyIAwcO4ODBg8jlcliwYAHKysoQCARgMpkQCATQ2NjIoupEUWSpwACYEzKdTqO0tBQjIyPMkCRFn54LAZC8cUGRhDRPqYCLIAjMG09C84dX1CkK0WQysTb4NGYCwHhORlEUC1KDKdqRB89ojAkwTCaTjMCdziVjJpPJIBaLIRqNwu12HwHQklA2Ah99SO1QgR6tVguNRoNkMsnWlsbGRgQCAQQCAVRUVMDn8+Htt9/G3LlzmTFCERnEv0sGBB9xSkArABZpRUUFI5EIZs6cCZvNhq6uLnYeVem02WzMmULfkWOFAGI6nn/mFK1I907RrE6nk1FamM1mJBIJZnSJoojm5maMjY2xZ0eUMO8F59t/yw4o5nz8MAu/xmo0GnzjG9/AjTfeiDvvvBMWiwUvvfQSZs6cie7ubixcuBA33ngjampqUFtbi4cffhgLFiyAwWA4Lie2nPDGpcfjgdvtxujoKNLpNMuiufLKK3HRRRchmUxi3759OHjwIFpaWjA4OIju7m4YjUZGqfLaa69h69atiEajmD17Ni699FJMnjwZiUQCNTU1jO7F5XIhEokgEolArVajrKwMKpUKc+bMgUKhQFNTEwRBYBkwoiji85//PJ544gmceOKJBQBJKpVCd3c3MpkM3n77bSxevFg2muzjLPwcoL1KOjcMBgMWL178b/Gbf5RlvECC8YA9qT7EfyYF5Hjnn9w1ST8b73rSdvl9jP9eCipJnycdIxfoMN54kI0gvX9ez+T3X/6HnO8EiEmvDxwqgCcCzlInli1fhs2bN2N4eAjlFWU4cOAAQqEgSpwlBfoJBUKQ7kIUL5S1QRkQWq0WsViM6WjkcKSK07RX0z6uUChhNlsQiUQxMDCAXO6wXa/T6WA2WxGPxxAOh/JZToEA43ik/T6XPTymW97ZAgDQanTIiVlEY1GoVCqUlpbiggsuQG1t7RE6C/9M5fRwfh7IBQxI25EeL21f7nlLdf1ixxZ7V95rOS7gked2mzp1KubNm4fa2lr89a9/fc85ZHj5oBUO3rN94403YteuXfB4PGzS6PX6I0BHuTYobZAMAopyVCgUmDt3Lj772c/ipJNOYsb1hHx4hH85KSqkpqYGN910E84++2w8+OCDWL16NR5//HGIoojS0lL88pe/hNlsxm9+8xv2ObUFyHvmeNBRLjXfYDDg+uuvf0+jFT5IaWhogNPpxP79+3HKKaegrKyMpYqRUMh7MV5IACwyTk6KgS0AV11VACAWvmP84nu0seU3jWIL83jGgXTBFwQB5eXlcDqdjEONONzIWOeJlKXKRbFrkAIjCALbiKurqxEIBFh6giAIaGxoRCSUr6Db0dEBrVbLOJpUKhXC4TAaGhpY6h9xsCgUClRVVbE0UoPBAIvVmgfWNGq43G5EYnkAQRRFlJeXw2QysehEAhg1Gg1isRjq6+uh0+uROwQOu8vc8Hp9zCAnxcZkMqG6uhpZujdtHoSpratjkeeRSASxWAw6nQ6VlZUsPdzhcKC/vx+9vb2YMWMGi8oijrxt27bl3/FDwKDf70c4HIbZbEY4HGZgAEVJEgig1+oKquiZzWZk0hmmGFFEEw9SS0HsTDrDgG4GLEFELnc42oyAKooio3aOR6RznVdS5ZTsj5NQxB5/v0SL8uyzzyKZTKK9vZ2l7trtdgwNDWHXrl1Ip9Nwu91wOBywWCxwuVxQKpXw+/3Ys2cPent7AeTBmKamJla1PJfLobS0FLt372aVEQnkI/CalHge1KNoX5qfvFEiZygRPyStKQT20Zyj6D/gcKEZWkeJBoCUe0EQWDQDKfp0PUEQGGBI36fTaUbhQDyIFHFIgCJdl0BetVrN3iESSn0KBoNobW09wvHKr7v0HtJ48MVg6P7584mj1eFwQK1WY+vWraitrYXP58Nrr72GxYsXMxAxFouxyAbeOKP2TCYTgsEgALAoDIPBwNLHs9ksZs2ahba2NsbZp1ar4XA42BwEwBwYBNRS9gxvNNGYE7ctgbH0nclkYuspVSQn4JUib0OhEPr6+thaROP/n+qa/y07YDzn40dBiErp7LPPxrPPPotvfvObePzxx3HWWWdhypQpuO6662C32+H1elFTU4OSkhL4/X6sXLmS7dv/idD7vGbNGtTU1DDaEwBs7SHdtqWlBW+++Sa8Xi9UKhWmTp0KhUKBXbt2YcuWLWhqasKXv/xltLS0oKGhAclkElVVVQxgNZvNcDgcAMDoEAAwHY+isKlPNL9FUcT06dPxwAMPsIJ26XQa+/btw9atWzFjxgy0tbXhkUcewYUXXvgfjcdHXYrprnJO70+CjAf4SfUfnod0vPdKOsZSx6/ULpDumfy5Ul5F2kv5vYFvTwrsSfs03r3yIKK0v7SH0PH8uEnTsXlKIekY0P5O91Hg/IYIhUKAo8SOExYuwFtvvZUvnNXehp6eHiSTSbZXkaPe5XJBFEWmV6hU+UhEcorG43F2PYvFgrGxMaYnkX6VSCTYfev1eqbr6PU5CEJ+H1epVIcobnSM3iUcDrH70+l0qKmpOUTrkoJaeXjPJGcpBV+QjlFZWYnS0tIjniP9zc8LqTP4WPRu6byi82jc5eZwsc/4ax4NbH+/5LhTrXmx2WxoaWnB/v37sXz5cqRSKQQCgQJv58jICNtsysrK8NZbbxW0QdXuxgMdPkiFQzpxJk2ahKuvvhq33347RFGUBR35hyddFEiZVavVqKysxIknnojTTz8dU6ZMYVxm0jTOCflwiNzzUKvVmDx5Mu644w58+tOfxgMPPIBNmzahs7MTX/va19Dc3Mwq59IcUqvVMBqNrMo1/+LLRTqSKJVKXHzxxQUFZT5qc6S/vx9er5dFoy1YsACBQACbN2/GrFmzAOQV4Vwuh3nz5h13+9INlBc5xUwKUNJ7TO8htSOtsEnPjH/vpR5I6eZcrK+UekhRNMlkkhnUZOySQkIbP59GwfeHvz4pFdRHMkZtNhsrdkERN5lMGu3t7QgEAhgeHkZ5eTlKSkqQzWYxMDCA4eFh2Gw21NTUYHR0lKUcqtVqlg5BIIZSpQSEfD9sdhurDE19pOrUFRUV7J0wm82orq7Oz/9sfiySqSQ0Wi1KnCUQczlEwhGWQkRpRDlRRImzhPGjJZIJWG02lq5PfC+VlZXYu3cv2traMDY2hv7+fpbyJwj59EWz2YwDBw6gu7sbpaWlcJaUsEr15eXlDBCh1FRByKflajQaCBCgsisLgJy8Ya9CNBiF3W5nqZwU/c7PQ3pGikOADhlsKpUKgkIBiIe5XfiCItK5JJ3f44nU8cG/CzTGH1eRevWz2Sxef/11DAwMoK2tDeFwmBV62Lp1K/r6+uByudDe3s6icMn4P3jwIN555x2YzWYsWbKEpZySok7vidFoRDQaZVWUgbzuYrVaGeCUzWYRiUTgdDoRCoUKopsINOPXfuo/D0ryz44voMNXk+YLvPDpz9L0LOoXzQ1qm4AyAr8pso6iD2OxGCwWS0EVSgJUiU+J+BxjsRgzJihik9osKysrMIyAwvWVpzHQarUs0kG6P5Jzwe12o7e3FwaDAS0tLejr60N3dzfLTHj77bcxa9YsiKIIm82GeDzOshloreX5H0nIGUlrdllZGXuWJpMJp5xyClu7aTyUSiW8Xi/jDaX1GQB71nyaHD03igyh+UVp7vzYEKBIkeAWiwXV1dXYsGEDqqqq4HQ62Zr3Xr/nH5QdMJ7z8aMgND8/97nP4corr8TSpUuh0+mwY8cOBAIBzJo1C729vfjc5z6Hq6++Gt3d3fj+97+PF154Aeecc85/fH0y6l999VVUVlayNH96/4PBIKqqquDz+eBwODB79mz4fD5MnToVTz31FMLhMOOCXLJkCVpbW9m7TdQT4zlf5fqTTCYZ3UkwGGRz3+PxMDojWvfmz5+PxsZG/OIXv8CcOXPYd59E+aTe93jynwAmUrufB95on5VmNdF5vA5FbchFmUnblztWDigkJ9ix6Hw8nsCDXFJ7QQpO0vG8044HTEVRZFkYJLSH8X2j6/E80Xq9HgsXLsSePXvQ09PD7Aze2RYOhxmtUTweZ3YKPYNsNotAIICSkhJWJJNsA4p4JJ2Ez2QjqrtsNgePZxTBYBAmk4kFTuTByjiCwUA+Ddxuh16vRyQSwdDQENLJFDwBD8uaocwIu90Oiy3vXJk7dy5mzZrF9EPpHJIDlfk5VEzGW0uPFSQshhlI+8bLB2EH/EfAYyQSQVdXFy655BLMmjULarUaL7/8MlauXAkA2Lt3L3p7e7FgwQIAedDhxz/+MUZHRxnP24svvgiLxYKOjo6i1/lvKRyk/F944YU4cOAAnn76aUQikSMiHfmJRhOf0mjq6uowe/ZsLFy4EB0dHWyznAAbP5pCL6tOp8OJJ56IuXPnYuvWrXj66aexbt06PPvss1CpVIy7gowzqlzOLyZU4ZKnEeAX8NNPPx1XXnllgWH135ZIJMKI0AGgu7sbW7duhcPhgMPhwK233oqVK1eirKwMXV1duOmmm9DU1IQVK1YAANrb2/GpT30KX/7yl/Hb3/4W6XQa1157LT73uc/9WxWteZECcQUGO45MI+CP5c+XeqV4EFm6ectdq1i79DcZ9wAYwCjdlOgzvi2+0IJcBBR/DN8fhUIBl8vFiOFjsRh0ej2y6QymTp2KPXv2QBAENkeNRiNKSkoKqkxT5VTiy3O5XDAajVBp1AWeW7loKYrmEgSBARGCIDCQQavVMvCVL4yhVquZcU9tZzNp9jcpJ9lsFsKhe/R4PIw3TqvV4sCBA1AqlbDb7aioqGCgBQGU27ZtQyQSQVNTE0vRNBqNUKlUiMVi7F4oSo2qyxLXDYlSma9sa3fYWfosgQmkAPEgKolKkQd7kskki0hTa9QFwAOBHPyc4ueidL7JzbliisqHYU15v4VXlgkQ27VrF7Zu3YqKigqWLggAr7zyCiwWC+bPn884HuPxOEvd2bhxI7xeL6ZNm4b29nY2F3jwzmg0Mi7FXC6HwcFBOJ1OFtEajUYZmEe8hER14HK5WBV7mnNS0BE4DKwRGMdHDAGHnQ7kQKHK63waL4GR9DcfYU2gGU9Lwb8LoigyviQyFkwmE7snug61S5HD1BeK7icwf2xsDAaDgXG60jXluE11Oh0zNGht4UUQBJhMJvj9frhcLgwODrI9e8mSJXj99dcxPDyMuro67Nmzhzm9iLtOpVIhEAigtLQU4XAYgiCwe6cxonuj95nSvg4ePIhIJMKiqWl+UJq0wWBgoCb1m09xp2vRPKV5QM8xm80iHo+zSut8xIPdboff7y9oS6VSwefzoaSkhOkkfOT0eyEflB3wURZ+vbZarbjiiivws5/9DE1NTXjrrbdgMBjw6U9/mnGEp9NpLFiwAAsWLMDvfvc7LF++/D8upCIIAoLBIDo7OxklwdjYGJqbm9mc12q1WLJkCVKpFHbs2IFUKsWyCZYsWYIVK1bgzDPPZNXSpdFTJNL9h37HYjEEg0HYbDak02ns3bsXO3bsQF1dHQYHBxEMBjFlyhRotVpEo1E4nU44HA689tpraGlpwYEDB/DOO+/gd7/7nayuNSETAsjTW8npS/SZlIpFqt8fC+jH2w3SQl5y7fL7LACm10oBJ7m/pc5jKcDF96kY6CntMz8OtPfyur2cfUU6Db/X8wAmjYVCocCkSZPgcDiwZ88eVlyup6cHDoeD6RMGgwEWi4WBgoFAoICqhJwnRE9DGRr8fUSjUZZVRfrDwYMHMTIyipKSEoRCIYTDYQA4ZA9FC2zwcDjMCmmRaDQaVlCw9BD1lb3EjjlzZjM7hsYAkE+x5v8v9iykcizgtZxIbUbpNeQA7mMFM98LOS7g8Zvf/CbOOussRqL9gx/8AEqlEhdeeCHbTG+44QaWlnTddddhwYIFmD9/PgDg1FNPZXx1d955J4aHh/Hd734X11xzzYfOk8m/XHq9Ht/61rcwadIkPPfcc/D5fOx7hULByODtdjvKyspQU1ODhoYGli7BR6sU82xMyIdfeAOQnqfBYMC8efMwZ84ceDwevPrqq1i1ahV27NjBDDJaLKWgI6VXSxcRpVKJs846C//7v/9bkKbyYZBNmzbh5JNPZv9TJPJll12G+++/H9u2bcPDDz/M+LROPfVU3HbbbQXv92OPPYZrr70Wp5xyChQKBVauXIlf//rX/3afpBuv3OYsKAqBODquGEDDpynQOVJDnBQF8gjKGcD83/yGwbclVUR4XjH6jN+s5IxxAAVRNHy0DoF/1dXVzPBUqVRQCgo4nU44nU4Wded2u1FaWoq+vj6Mjo5iy5YtqKurY5GPtOnzPGx0Tdp8+UgEivghHjoCMPi0cr7qriAIrEgFRTTxIK1Go2HeR4rAEgQBFosFSoUCfr8f8XgcfX19SCQSjJPS6XSiurqa9YOK53R1daGurg6TJk3CmHcMo6OjKC0tZe1SVBaBJTzgodNo4ff7oVDkK9B6vV4Ah4ERmvNUfIOfa1Jl02g0MuUrmUxBUByusMvzzUnnrZyyWUyk4PYnQfh3iuZcKBTCli1bGAg+d+5cBAIB7Ny5E7W1tQxQJDA+lUqhv78f+/fvR0tLCxYuXMjoA6RKL3A4XUmlUsFgMMDj8bC5ms1m4XA4mFJL7zqlPEudCDxXqBSUomdJlAoE2vPgoSiKLIqX7pdfq3gQkEB3aWQHXYeiHgk05R0garWaOTYopZwcCMlkEn6/n1WUJFCfvieOR6fTySL5+GtLhaqMU+oVbyDx40Z9LC0tRTAYRHl5OXQ6HebNm4e1a9didHQUjY2N6O/vx8aNG1FRUQGDwcBAGFprKO2L1iFaZ3kjUaPRwGKxoLm5GZ2dnYyz0mKxQKvVwmQyMV2ReCoJWOajRqQAMzkuCWhOpVLs3mgPoqhR6gdFbAaDQVRUVDBSfkoPkwJYx6uHfpLsgPdSeP3kpJNOwttvv40333wTF1xwAWbPno3nnnsOLpcLTz75JIxGI6666iosXrwYN998M9avX4/TTz/9P74+rTNEeQCA0T3YbPlshVmzZuGrX/0q/H4/Hn30Ufz85z/HD37wAyxdupRFJUudIrzQu5tKpRi9C3Hcer1eJJNJ7Nq1i53b1dWFdDoNv9+PtWvXoqmpCfF4HAcPHsS6desQDAaRyWQwZ84c/PGPf8Sll17KijlM2FATcrQ5MB44VwxclH433md8H6Q2hDRTiafR4CP65FK4i90f3x5vn0ivLd1DpW0Wo2/h+85Tl8jduzQziz9OGuihUqlQXV0Np9OJvXv3YtOmTWx/JGoW0puCwSD8fj9GRkZQWVnJKlYTLV0oFGLOeFpb6If2WerT6OjoIb06iTVr1rB9sqKiAiaTCT6fF0plXn+or69HeXk506fSqTSikbyzhKpoq9VqNDU1obm1CQaDocCZKzeHis0VueOKtVPMtjwWXZ70U35+SFP4P2h74LiAx/7+flx44YXwer0oLS3FokWLsHHjRpSWlgIAfvGLXzAgIZlMYsWKFbjvvvvY+UqlEqtWrcJVV12FBQsWwGg04rLLLsMPf/jD9/au3mOh1JULL7wQn/nMZ5jxSkIvP3nD5WRig/x4Cf886blXVFTgs5/9LM4++2x0d3fj9ddfx5o1a7B9+3bm4RFFkQETVKGLBwM0Gg0uvfRSfO1rX4PZbC46n/5bsmTJknEXqdWrVx+1DYfDgT/96U/vWZ8K3i1BQI76JwACM+YAAYXgixTA4duRKgLA4c08m8sBFPUsCPkfADlRhMC1VczzKG2Tj/DhNwi6Hm9UF9vI5DYmAv0oFYEicUVRhFqlQjydgE6vQ1t7G/yBAFLJPMBSU12N6upqFinp8/kQi8UQCoXgcDiQy+WQTCah0+sK0tPpb+Ieo/7ykVm8EkJpqaIoMlCGV3xU6ryxDQFQKBVQH4quVB9y5PBpISJEhA8pJ7lcnr+P+kLvJilC8XgcPp8P27dvZ5GQBoMBpqQZPr8PAFhUUC6Xg1KhhEJQQKVUQqVUQavRAjlRVslJJpNQH0qZJvCF7o+fE6Iogk3KQ3M2e6gAjU6lRIbj+KP7lPISyc0zKdgt/ft4FJaPixDgSAD3rl27GPdnY2MjRkZGcPDgQUyZMgUtLS3MQE8mkxgbG8PGjRthsViwaNEiVlWdgB/gyLElgJ3en97eXmg0GgYgE1Cv0+mQSCSg0+kKCq7wFaAJKCRnAW90EIgnjaIVBIGB9pR6TXOH1gPiVuKL0ZABQfOaFHuph50nck8mk4zvkHhR6RjiRqXqzsTTRIAlAXxAHoAvKytjwCO/JsqtmwRQ8aAj79Th1xRKKwXyJPY6nQ6zZ8/Gu+++i3A4zKKtXn75ZXzqU59iUdjkVKDoMDKKyJHI8yrStcm4Iq4pvsK3yWRiYCaNEfWXp/yglHRqk9ogo5V4FKkPmUyGcVwmk0lkMhl4vV4YjUa4XC7s2rULkUgEiUSCRZLw1TePVz6pdsB7JTSnbrzxRjzxxBNYunQpBEHAn//8Z1RVVaGxsREvvvgiVqxYgbPOOgurV6/GL37xCyxatIgB2P+OPSGKIsvYamhoYFHIgiAgGo1idHQUgUAAlZWVUKvV6Orqwp/+9Cfcc889KCsrY/yrvNHK/6b5nk6nkUwmGQCfSCRQWVmJsbExhEIhuFwuvPnmm1Cr1di1axcMBgPWrVvHCiDt378fIyMjWLVqFcrKyrB48WIsXboU77zzDsrKynDqqad+IOmAE/LRFd5xBshnQ9HnR9OD5PRrOpfXw4DDWQRy9gWdw+v40nk8HhAqvSdpuzzQCcgXuil238XGQLqnSu1VufHj+8Bfj/5Wq9WYMmUKLBYLnn/+eQBge6zH44FOp4NarUZJSQkSiQTGxsYYtZJer4fRaGSF00pKSpiTOBqNQqPRMG7HSCSCZDKJYDCIAwcOYNOmzQWO3LGxMXR0tAMQYTAYUFFRAbfbnW8PAjKKLDLpDDSafFGs/v5+VFZWYt68uXCWlgKCfLCJ3HOXjkWxceafh/RZHo++Ph6Qeaxg6PspxwU8Pv744+N+r9PpcO+99+Lee+8tekxtbS2effbZ47nsh0JogSCl9D+RCRDyoy1He34GgwHt7e1oa2vDRRddhIMHD2L79u1455130NnZiaGhIbZw8guEy+XC1Vdfjc9+9rMsrPxYrvdJliO9mIfAnMMHAMKR0ZB0vBSIGS/Shl3n0P8KhYKBjqxNHAY4x9vM2fko5IYppuBI07GL3Y/UKOC9oYxXUKFAThSh1eUBM4PRCM2hNa2vrw9erxdNTU0sSstoNDIAwWg0srRRiIfB0oL0YdXhbYXvJ+9hJeBBqpDxG3cul4NSpYJI44k8uMunHdL52VwWGo0aXq8XVVVV6OvrY8VdHA4HS4H1er0sOqivrw9z5sxBWVnZIcdAroC/lyKbsrkMMkRcnc0inUohfShKjEAoAmPSmQzUh0AWHniUi4wVD12DAYyCigHbcoDjeAqwdC7wn0s/kx53PEbcLbfcckSht9bWVuzZswcAkEgkcOONN+Lxxx8vAB34Kra9vb246qqrsHbtWphMJlx22WW44447CubNeyksHV8QEAgEsGPHDgaWBQIBljrd1NTE5l0sFsP+/fuxdetWzJ07Fx0dHTAYDKxN6XsIFBoiarUaGo0GtbW16OzsRDAYZFG8BCyp1Wr4/f58UaJDIBRFsFHkIQFoBNbR9wQSErjGR0nzfKwEXPK0ATy4RcAV3RO98zyoyjsVRFEsSCMnMMxgMLAiJ/y4U7QzgfM0J2mMAcDn80GhUKC8vJwBaMWEB0IpypIHHoHD81mv1yMQCECv16O8vJwVMIvFYqisrIQgCNi4cSNEMV8Fev/+/Xj11VdZ4Q0ABdQ6lPZMEdk0zvR+UwSn0+lkHFEUKUnzgfpOXJgE8CoUhyumkmOGB4L5qA66DpBPK9Pp8g4gGk8ArNiHRqNBPB5HKpVikY80F/5dveKTbAe8F0LvlF6vx8UXXwwg/z7cdNNN+N73vocbb7wR3/72t7F69WrU1NTga1/7Gq6//nr8+c9/xhe/+MX/CHQjznnibQ4EAshmszCbzUilUhgYGMCiRYuwefNmXHXVVbj88stRV1fHUqulAARF2wYCAXR3d6OsrAwej4dVsg6F8tVix8bGMDg4iLVr12LGjBl45ZVXUFJSgvXr1zPO6EmTJmHhwoXYtGkTBEHAl770JZx44omw2Wz42c9+hubmZnzjG9+QpVeYkE+uFHPwSx29ck406XHH0iYvUhCO1wukuq00wwkoLHzHty8HDNIex2c88fq0nM0hB17Kfc4fT9eiqP7xQC/emSm9hnQ/pn7SfVRVVWH27NnYu3cvWwNIZycOSJ1Oh1AoxIDFzs5OiKLI9rVIJMIct+ToJC7GaDSK4eFhJBIpHDjQzRx2tAamUkkAIqxWK5qbm1FWVgaFIs9J6fP5kYgl0LlvP2praxGJRNDY2Air1QqNVgsROQgo5NPkI0Olerb0GR/NNuTnKt+m3PiP147csVIn9X9D3h9N/2Mm43kgJmRC5Ax+ermNRiM6OjowadIkXHDBBUgmk/D5fBgYGEBXVxe6u7sRjUZRV1eHpUuXora2tqBKabFrTMiRIghCHvgTjvQ0yYE2vCEMHN0rROAXb4yzz4soDnLHjQdqSv+W28yk/CFSJYrvA+99pc+k1yJlQKvVYtLkSRgaGGRpxUajEVVVVSzFkwq4HDEuEu+nnKJWzGsqp0jR8UcbH/pfo9EgFA7DarXCaDRiaGgIPp8PDQ0NUCjy5NVjY2Ow2WwoKSnBpk2bMDg4iNraWmSzWYTDYbjL3AhHIgyYpJRWnUYLr9eLUCjEqvdSVJHNZmPRXHmQIR/paDKZGFjAp9fwz0iqBPMKrNz40pjI7UfjgY5y30n7Ih3v8WTSpEl46aWX2P88YHj99dfjmWeewd/+9jdYrVZce+21OO+88/D6668DyCvaZ5xxBsrKyvDGG29gaGgIl156KdRqNW6//fZjuv7xCq3H6XQavb29LHU+k8lgbGwM06ZNQ2NjIwNootEo4zc9++yzUVZWBqPRyNqiOSuNPOJTrI1GI4xGI8LhMERRRHd3N8xmM9LpNIxGI6vqyBcSISOerqHRaFg1ef66xOlI85M3SPh0Y+oLVYek4wigoui9SCTC3hWeQ1LaFg9AJhIJAGCAIl+pnqplq9VqRKNRRo2QTCbZXKGCNKlUCuFwGNlsloF9NM5H2/PICcwDpwAKnDRU8MLpdMLr9bLKziqVClarFR0dHdi6dSvq6+tRX1+P7u5u9PT0oLa2FjNmzGDp5bFYjK0LRqORRTdT1ChFuigUeSoJs9kMo9GIRCIBhSJf0TsajRak6PPjKQV1KCWW7icajSKbzRZEXxJ9A388pVPb7XaWQi+Kh6le4vE46wefIjYhH7xI1/ETTzwR11xzDf74xz/i8ssvx3PPPYf29nYsW7YMV199NX7+85+jqakJJ5988hHR1scqAwMDSCaT8Hg8mDlzJqqrqxGLxaBUKjE4OAiPx4NQKIQf/OAHmDJlCq688kqED+2r5Ezz+/2IxWIwGAwIh8OIRCLYsGEDcrkcent7kU6ncfDgQVgsFgwNDQHIRzm9/vrriEQi2LFjB/bs2YP29nbU19fjpJNOQmtrK+rq6vDWW29h/fr1OPfcc7Fz50489dRTsFgs+NKXvoQLL7yQRURPyIQci/C6lVRv5p1pvBNNKlJgkT7jQT85e2M820IQDheXk2uf2qF+Sa/B7xX0I9d//v6l/ZWCsbwOwdtMxewWaZAD7e3FAC7p+RqNBpMmTUIwGMTOnTthMplYOrPX62X6tcfjKSjAuXfvXlitVlRWVjJeZsrSIN3E5/PB7/ezIplWqxkOhx1VVVWIRqPI5XLo7u5m6dYGgwE2mw0HDhxgjt8D3V3I5jIwmAzwB3yIRMOoq6+D3qAvsNH5SNNiALUcTZL0fzkb7WiYE///eKAz9ZWntZJm0X2QusAE8HgcMqGkTcixiHQBof+VSiV0Oh0qKytRUVHBChrw50mN/4k5d2xSsLEf+i31tEk3PznQjn7L8SgKggCIIhR5ZBPggTY65hA4Se1LgcjxNhLpZiMFDMczxo9l85ADs/nPUqkUSp2lUCmUGBsby/MY6nTQ6/WIRqNwuVwoKSlhaZSxWAxqraZg3Pj+SDdZufvgPYXF7pMHxop5/hKJBFRKJdxuNzQaDSOYznO4+NDY2IiqqipotVp4PB4cPHgQDQ0NsNlsyGQy8Pv9SCaSUCmU7CebzUKtUiOTzSCeSCCTyyKTzSIeDDIAiSpW85xX8UScAQzS+cWDRHIgLA9AyI0bDyZLn+mxrBXSNenfWV+oiq9UgsEgHnzwQfzpT3/C0qVLAQB/+MMf0N7ejo0bN2L+/Pl44YUXsGvXLrz00ktwu92YPn06brvtNnzrW9/CLbfc8h+lgBYTPn14586dDAjLZrOYO3cuamtrmfc8FAqhu7sbVVVVmDlzJgMHeeVfynnEK9+8EUCRwmazGcFgED09PWzcCNDijQBeeSVwm0A16bzn+8K/S0SpQG0RIE4RihTBQLyPBD4SUMhH4EmNEynvIEVi0nwyGo0YGRlBSUkJSxkPBoMsMpHI44mHEACLbigpKYHZbGYgLG/8SEVqgPHRgdJ5TRETZrMZdXV12L9/P6qqqpBIJGC1WpFKpVgaqNPpRG1tLfbt24c9e/YgmUxizpw5LGqT+HEpepHunU+TpsgWyoohYJaiZSkCUm5dp+fJk+an02kMDg4ywJFoWuj5ZjIZ6HQ6RuWSTqcZRUswGGTPnJws8XicgY8fNv7oT7LQe3n++edjYGAAu3fvxkknnYT9+/ejqakJ06dPx7XXXotvfOMbuO+++zBv3rzjjlqluZpKpVBeXg5BEDAyMoLa2lp4vV6MjY2hs7MTX/rSlxCJRBAMBvHII49gyZIlMJvNCIVC8Hq9ePvttzE8PAyTyYSKigoMDAxgx44dzMkRi8XwzjvvIJFIoLy8HHa7HaOjo+jv72fv+U033YTFixdjz549CAQCeOKJJ7B161Y4nU789Kc/xVlnnQUgD5QaDAa43e4CapUJmRCSYo5YObBHqnvy+0Ux3fxYnGBy5/H/8/sov5fz3/HXoswFOcoRORBT2n8+wlIKbo13r7zQtcl5Tp/J6fbFnoG0r3LXra+vP1T8ZQQulwu5XA41NTUse6CmpgbJZBIHDhxgTjzigCQ9my9oFwqFmNMzk8kgkUigqakJO3bsQCQShl6vx7Zt2zBv3jx2L6SP0RonCAKCoeCheZSFZ8wDhVKBEqcDWq1mXEBbOhb8Z7xzWCpHs+/k5pHcs5MDMo8HXPwg1tcJ4HFCJuR9ErkFYTxP9X/D8/BxkCM2YhkOpGIb69E2RqmwdjgFQgrgiRLwUZpOwbfD90vK4cfuRyhMd+TvWfpb2maxzYd++EidXC4HAXkOTkpvoEgvKhoRiUQY0Gaz2ZAVCysGF1OopMrPsQBp0u/Hez8EQUBdXT3EXA7r169HaWkpBEHAwMAA6urqUFVVBb/fj2g0CiBfafVrX/saAwd1Oh1isRiLoCIuOlEUkcqkkRPzEVsajQYarQYGgwFpCS+fVquFQqlENBYt8KDTPUhBPwAFIIs0FVvuufGA5XjKqNz4yP2m449nzens7ERFRQV0Oh0WLFiAO+64AzU1Ndi8eTPS6TSWLVvGjm1ra0NNTQ02bNiA+fPnY8OGDZgyZUpB6vWKFStw1VVXYefOnZgxY4bsNZPJZEHlQeLsOxYhxdLj8WBoaIil58yaNQsulwt+vx+ZTAbDw8PIZrNYunQp7HZ7AQAHoMDwHS9ajMA+8qS7XC6MjY3B5/PBYDDAaDTCZrMhGAxCFA+nDQmCwFKGBOFwcSF+DlA0H4GKfCVqAquI15GOJXAxHo+zKD2KnuNBTmnldP4d5b3jNOf5StqUfhwOh2GxWJiBQGCjIOSjktVqNasUzXMwTZ06VXYd5Z9hMZFGf/CfKxQKVtzJZrPB5XJhdHQUDocDQD4jYdKkSXjllVcQj8dRUlKCGTNmYPfu3di2bRv0ej1Lwdfr9chkMsypQXND6mDgKRIAFDgl5Ijo+UqgjEeYK7y1a9cuaDQazJ07lxmBfIo5RVYnEglmgFGEZiKRgF6vx+DgIPx+P6smnEgkWLTIhPx3hZ8PKpUKV199NX784x9j586daG1txQMPPIBvf/vbWLBgAXbu3Imvf/3r+H//7/9h+vTpx/yOUPsEXI+MjBRwpWWzWezfvx/Dw8O4+OKLcc455+D111/H448/jttuuw3nnnsuGhsb0dPTA7vdjs7OThgMBjgcDni9Xhw4cAB2u5058fbu3QutVgu73Y5AIICSkhJceeWVcLvdiEaj2L9/P37+859jw4YNSKfTaGxsxJe+9CVcfvnlaG1tZetNQ0MDu7eJuToh4wnpMbQXyenm/HHSv+UASun+KydyQJ6cMB2buza9e9QOr5fz7RfTeXkbBDiSM74YyHm0a9JxpMfKgaZ0Pl3raOMjp8frdDqUl5dj2rRpeOuttzAwMMD2vZKSElaMT61Wo6KiAtlslmVoUOG+sbExpq/TfQWDQRYUQDU5qqqqIAh5jvcTTzwRZrMZ4XAYwWAQNTU1GBsbQzabhc/nQy6Xg8lkgsPhKODDJgcir38XA1vH07GlQKLc+ErtOOn8lLYltbmkx8nNU7l2PgiZAB4nZEI+IJEzqOS+n5DjE+lGrpAYd3Jkz/Qd/1vaHr9hAkeSNfObdrFnJ6dAyCkCcsqNdGPiRe4+5Ix2uc1IOl78/UEQkMlmoNfrWeROIpGAVqtl6alGoxE5MYdsNndEv+QALqmSx/MdShUWaaTp0cBa+pt4zyIcYT6BpKWlpYhEIixSacuWLTCZTKz6NkVBUrVcqjZPqbEEClitVlYgIpNOQ30o0oq/r0wmzVLR+TQZvnIxARAKhQKBQABqtRp6vb7gmGJpM3QduWd/NJHOhWNVmHmZN28eHnroIbS2tmJoaAi33norFi9ejB07dmB4eBgajQY2m63gHLfbjeHhYQDA8PBwAehI39N3xeSOO+44glvyWIXG9d1334Xdboff78eMGTNgt9sZoBkIBGC329HR0QGdTldQRIHmMA9Cyq0nvFCUodlsRk1NDbq6ulBaWopYLIZYLIaysjLmjacUZZJgMAgABQVpgMKo7VQqhVwuV/A9D5BSlXoC/Pj3PBaLIRKJQK/X5yOFuYhIirjj0+d5YJyfy/w48PyDdEwsFmPrSCwWg9lsRjweRyAQYOlUVLiqtbWVjXGxdfloz5gH7PjnpFKpEI/HoVar4XK5EI/H2ZpGVSpnzJiBrVu3wmw2w+l0orW1FRqNBtu2bYPBYEBVVRWrUi6KIrs3GlseCOT7xP+mMZQaxPz6TwAwHUeVPLu6uli6Gc0vQRBgNpvh9XqRSqUQiUSYwa3RaBg4X1pair6+PgwMDMDlchUAo1IaiAn57wnNf6PRiO985zv4whe+gLfeegtTp07FG2+8gUWLFuHb3/42EokEvvrVr+KBBx7AlClTjtgTiokoiigpKYEgCAx8JIfc/fffjyeffJJdl6rAX3LJJXjmmWfw8MMPY8+ePRgaGmLckBaLBfX19SzqNhjMRwhRdOLChQsxMjKCz3zmM3A6nejs7MRtt92Gd999F7FYDDU1Nbjmmmtw9tlno6GhoaAoHT8mEzIhxyL8XOH3yvHmkFR/KqZLS2mCxru2HIjH2xFy7RRrV2oXFAOK6H75vXo8m6HYPisHtkrtFGmb/PV44LMY4MiDdgqFAjqdDi0tLUgkEti6dSuSyST6+vowMjICs9mMkpISBkIaDAbmDMzlcigvL0c0GkU8Hme2CulTgiAwWrNgMIiKigq0trYilUrBYrGwTIhgMAifz4dwOAyfz8ecwKIoorS0FMFgEGazGeXl5axQHIlcJh1/73JjJSfj6Txy9k4xW7aYyAXZ8O2MZ4e+HzIBPE7IhHzAMqFMvfdCi2VOFAGJ0iGXNsgv4NlMFuC9RjkRORzeHMcr8iFVMo6mlMgt6sXARbnr8V6x8VKP5Yxa/nwCC6T3IggC0tksFColdBo9RAGAAOQgAgoBOr0OmWwGAudVlbs3foyP5mUbL2JJDmyk//lzRFGE6lD0V1VVFUZHRxGNRhlQQCmIyWQSTz/9NBYtWgSLxYJEIoFsNsuUC5vNxqrZEucfFHlDzel0MtCFFA4CAAiUGPOOwWyxFHiU+WNzuRxLd6Q+ZbNZ5p0l8IbGRqpQ8uPGg7fS+UPfE4DGj5ucHKuycdppp7G/p06dinnz5qG2thZ//etfj+D+fC/l5ptvxg033MD+D4VCqK6uPup5bE6n0+jv74fX68WUKVNgs9lgNBqZojl58mSUlpay8ZICMjTHyPtfTMHnQXVKt3Y6nbDZbEgkEojH4xgbG2PVGFOpFARBYByq4XAYQ0NDaGlpQSAQgNPpZOnEfH9Y4aND0R0ACuYm/x3dj0qlYtGQVMSF7tdgMMDv9zP+Qz7FW5rSSfdGADkPPmq1WsTjcYhinjvS6XQiFAqxNZSKoQSDQSgU+SIXbrcbJSUlR9zj8QrdD81lHqTT6/VIpVLQ6/WoqKhgILdCkSeTb25uRiAQwMDAAKscXF9fD4PBgG3btsFqtTK+SCrmQkAnz7tJ15YaX/w98TxLNIcoXZyXRCKBWCyGvr4+OJ1O9PX1oaGhgRWroXc8l8sxflCz2YxoNMqizYaGhqBWq9HS0oKBgQFMnTqVzQ8qFkZ9mZD/vtA8MRgM+M53voOrrrqKFcTas2cPvvSlL+H666/H3XffjauuugqPPfYY6urqjrltmmf19fXYtm0b1q9fj1AohMcffxxf+cpXcNlll0EQ8lFB//znP3HWWWfh05/+NJYuXYpXX30V99xzD/bs2YN0Oo2Kigq88847OO200zBnzhwWSUucsoODg+jp6cGtt96K7u5uxiU5Y8YMXHTRRTjzzDNZZsKx7FETMiHHInLpwEcDhsZzIvI6gJyeXky/LQYOSSMfpXuE1Ckv1aOLcQrKAVTFgFS+H/z3vJ1An8mlBxezpaR6An99aSYA3QPtnbW1tejr68P+/fvZvhqLxRAOhzEyMgJRzGcduFyufHYRp8cQ36zVaoVOp2P6XSKRwLRp01jRPNJtiAams7MTZWVl8Pv9iMfjLAuF6FGqqqrQ29sLAKivr2c6Lk+9I2ffHQ1klAMQi80r6TjL2VnS68mBxR8mB+ME8DghEzIhH2nhN00B8jwaxTZKMScCEKUNHpFKzV9H2q7c/+MBZUe7F2m7cqCh3LXljpduPPxvOdCQNlOq4CqKIpRc9JPqkMdPLs1Aev/SMZCLyjiassfft/RZSNvOZLLMKCdPJaWemkwmZDIZbN68GdFoFLNnz2ZcaeQx5YtrKBQK+P1+eL1emCxmxrFGkojHATEflZZMJqHX65mnlOfS48ecQAJKOaXISr1ez1I5+HMIkCKAgweTeWNNLkqUV1yLja1U8f53lBKbzYaWlhbs378fy5cvRyqVQiAQKIh6HBkZYdyGZWVleOuttwraGBkZYd8VE61Wy3jzjkdo7GKxGIsYs9vtMJlMGB0dhdFoxNSpU1nEqRzAyyvhlBrPA8LSOcynIpvNZphMJlbdmpThAwcOoL29nXGiUWQtnb9//344HA4cPHgQzc3NBaAcTwAvjcQgo4XmGh+5qFarodVqEQqF2OdarZalPFP6kslkQi6XY3NPFEVWcZnngKToQoqSFIR89DBVlDSbzUgkEiyyIBKJsKiEUCjEKoovXLiQRQ4Ch9PJx6MlIZH7jk9ZpjElrkUAsNvtSKfT8Pl8BQ6BOXPmIJVKYWhoiAGhJSUlrFCVwWBgqVsExtJcp2vS86P+E5jIp6rzjh96Vvz90DF+vx+7d+9GMBhEY2Mjent7YbPZUFVVxWgfiDuTithQuj2B6hTtabPZ0NXVhdHRURbJTWnYxxItNyEfrCgUCkybNg33338/vvKVrzD6gueeew7nnHMO/vd//xeXXXYZLrnkEjz00ENobGxk541n8JaXl8PtdsPn8yESiWDdunXYtm0b7rzzTqxcuZIZ1lVVVVi5ciX6+vqwd+9eKJVKnHDCCaiqqsLNN9+MrVu3ory8HBdccAH8fj9+/etfw+fzsfXAYrGgubmZ8USfcsopmD59OpqamtDY2AiTyfShMYIn5OMjcs7A8YAXqd4rBxYebZ4eyzm8Ls5HxvPnyfWbf595u0YKPvIgoRwIWUz354+VS4WWA2flriMHfvHX4QFOuUAOvV6P8vJyLF26FDqdDrt374bP54PFYoEoiohGo2zc+vv7mY5Ceh057R0OBwQhTxEliiJsNhtz7vv9fuj1eoRCIQSDQdZOKpViDtl0Og2r1QpBEOB0OgGABSOYTCam+8hFlErnXjHwW+48/pkX+07uecp9Vqw9vl//7T1/QuOYkAmZkI+8kBEuHNqcjhkkFEUIkFQXFeS5uGQVkCI4IhmUPGg2Hignt5Hw1ycPoNx1xvufb4+AFf5epZsUXYMKTfDpIXwbfB+lCkgxRY3AEF4JKRbtyB8/HmDLnruQJ4EGwHjvqHiHKIrQarUIh8N4+eWXcdJJJ8HhcEAURYRCIVb0g1In1Wo14vE4fD4f+vv7WfolRY4plUroDgGzREpNz0ipVLLqvTzowI8tgTekxFBEFvWdB5ZI6LnJAWP0uxiQWIxfUjqORwPF5SQSiaCrqwvl5eWYNWsW1Go1Xn75Zfb93r170dvbiwULFgAAFixYgO3bt2N0dJQd8+KLL8JisaCjo+O4r380oXsaHBzEyMgIGhsb4Xa74fV6UVpaikmTJsFisTBgk8BlaaqUdNwJOCJAmBdeuabUc7fbDVHMVyKmyMaRkRGmJBOwxxdaoqIiOp2OXYvmRy6XK+B7BHAEyKXT6dj7oVAoEIlE2DFU5ITA3GQyCVEUGR8SP1cogonmLLVJkQPpdJr9VqlUCIVCrKIyEb2TYq9Q5CvMZzIZDA0NwWazFXC68fP03626zIP+PNBnNBpZ2263G3a7nUULUlr8kiVLUF9fz+aASqVCdXU1Dh48iEgkwtK0KbWLjBZ+beNBamnVaymQTesG/+xo7nk8HsaPFwgEMHnyZLz77rvwer2Ma3JsbIyBjwqFgqWQU0o7Ae0WiwUNDQ3o6elBIpFgYCUPeE/Ih0sUCgWmT5+O+++/H93d3ZgyZQr6+vrw6quvwu124/vf/z56e3tx0003we/3H5NT02q1oqmpCaOjo1i2bBneffddfP3rX0dZWRkGBwfZvCROtZaWFixevBhNTU3Yvn07hoaGcO+99+Lkk0/G4OAg+vv78c477+Db3/42HnvsMbz44ot48cUX8corr+Cpp57C3//+d/zlL3/BrbfeipUrV2LatGkwm81H6CBy+siEfDjl/vvvx9SpU2GxWGCxWLBgwQI899xz7PtEIoFrrrkGJSUlMJlMWLlyJXMukvT29uKMM85gHMj/8z//w6Ls/xMZD1yUE97RI3cO/71chpGcfj/edUikgFyxgnU8oEfnSJ3+xa7L7zNygQJS+0Z633LHjKc/Stsg4Z+r9F7oPLIrXC4XpkyZgtraWub8oyhqAhepsGU0GoUoikxfD4VCbE87cOAAtm3bhq1bt2L79u3YtWsX+vr60N3djYMHD6K7uxtGoxF2ux1GoxEVFRVQKBQoLS2Fy+WCy+VCfX09hoeHEQqF4HA4WHS2NDNBOj5SUFZuzOXOlYLI0rlZzI6Uu9bRntd/WyaAxwmZkAn5SEvBYiz5rJhiwCsTfKTTeEoFMxyzOYjZHJDLA5cKCFBAgCAi/3PofOnGIAcc8SI1TospFuPd19FEuklJzyUgjDf+5UAvaV/lQFa5sTwakEh9lOvzeJsoRWgJQp73zOfzIRqNIp1OQ6fTwefz4cCBA3A4HFi8eDHzboZCIcRiMVRWVrICDZFIBLt370Y4HEZ1dTWsVisDZXhAikBKnU4HURRZ5FQikYAo5ot58IACgTfUX0HIpwAHAgGmQEmjyQiYoHGQG18pmHy0eSanzNDfR5NvfvObeOWVV3Dw4EG88cYb+PSnPw2lUokLL7wQVqsVV1xxBW644QasXbsWmzdvxhe+8AUsWLAA8+fPBwCceuqp6OjowCWXXIJ3330Xq1evxne/+11cc801/1ZE49FEEARW8MDhcKCqqgrhcBiTJk1CR0cHS58FDgO0/G9+TKVp61JjgVcW6ThSmMvKylgFdfLGU8GPZDLJuEVpHh84cICl95LTgdKn+eefyWQKAHyeU5T4Fgkg9Hg87P0mXlHe8KEoVR78pEhLKS0DCYGpfFXpcDgMs9kMAOw73mBIJpNIpVLweDwoLy9noKc08o/vx/EK/77xUakajQaJRAIA4HK5WBRjLBZjz2bu3Lmor6+H3+9n1aIHBwexb98+VoU7nU4jlUoVVOymsaHx5kFZuj/+O34u0b0TNydxNiYSCcYv2dPTg6qqKrz66qvs+jR2lMpPBXA8Hg8AsGgQIvH3+/0IhUJsLtFYTMiHUwRBwMyZM/HLX/4Sq1atwu7du/HEE09g+/btWLBgAf7f//t/2LFjB+644w6279D6JScajQYXXXQR9uzZgzfffBOLFy/GzJkz0dXVBafTWXCeUqlESUkJjEYj6urqcMIJJzCes9/85jewWq3Ytm0bHn74YXzpS19iKdczZsxATU0NDAYDtFotKy71YTWCJ+T4pKqqCj/5yU+wefNmbNq0CUuXLsU555yDnTt3AgCuv/56PP300/jb3/6GV155BYODgzjvvPPY+dlsFmeccQZSqRTeeOMNPPzww3jooYfw/e9//9/qD+/IlhM5kE7q/B5vbsoBQXI6bDGgSQoUSf+X9ocH5ngglY9ILKZDSwFDHrjkIyZpTy+mj5MDrFgkaDEwU9oXPjKTHxspIEr7tUKhQE1NDebOnYvy8nLEYjHE43HkcjlEIhEYjUbodDpYrVaYzWa4XC7YbDYYDAaUl5ezgAK73Y7W1lZ2LdLvqeCdzWaDWq1GOp1GNBpFOBxmVBDRaJRxwHd3d8Pn86GlpYU5TKTjK3VISwFDfl7wgRfj2UlHE/6a/HPidVJejha0cjw25HshE8DjhEzIhHzkhS3iOH5yXNoopJs/XzVWTjkZD6TkN3a5yL1iwCj1g4+CIZGmZ0g3qWIRcXyb4xkldO/jjZF0M+W/H8+bR8dI00yK9Ufu2PFAzfy95X+r1WpEo/nK0sSn6Pf78eabb2L+/Pksqo0il9ra2gDkjf5oNMruta6uDm1tbcgeAgoIsCFuGeoHAYWU7kgeXoUizxPJ95F/rnzEGSkONAf5QjT0uXQOSUFiqTIkB9gWUzZ4BXc86e/vx4UXXojW1lZccMEFKCkpwcaNG1FaWgoA+MUvfoEzzzwTK1euxIknnoiysjL84x//YOcrlUqsWrUKSqUSCxYswMUXX4xLL70UP/zhD4967X9HRFGEz+eD1+tFXV0dIpEIWlpaUF5ezt5tEv4dAY4kYOd/+LHmlUle6DuKpquqqkIikUAwGGQpsKFQCF1dXUgkEkwBtlgsGBkZwb59+9Db24tkMoloNMqAdLo2/37wBgJfMIYvusKn8ttstoJjeHqAdDrN+s+Dm3LvPB/NBxwGGpVKJRKJBIs8poJPXq8XuVwOo6OjEEWRgWLSsT0WZ4OcFHP28JydlHatVCpRWloKhUIBu93OOF01Gg3a2tqwaNEiVjmzqqoKqVQKXq+XrSl8BClxLNJ7m81mGRhJfJjSgjz0nU6nYxHSBDpSZCXxdNbV1aGurg6BQADRaBSDg4NQqVSM04oI81OpFEZHRxGLxZDNZmGz2SAI+UJb9By9Xi+rhE3rE/VrQj4cws99hUKBxsZG3HfffXA4HNizZw+2bt2Knp4enHLKKfi///s/rFq1CrfddhtisVhRUIR0g9NOOw01NTXYsmULzj//fKxevRrTp0/H/v37C/Zj3uGiVCrhcrlQUlKCrVu3IhAI4O6770YsFsNPf/pTJBIJWWclz5l7LCDPhHz45ayzzsLpp5+O5uZmtLS04Mc//jFMJhM2btyIYDCIBx98ED//+c+xdOlSzJo1C3/4wx/wxhtvYOPGjQCAF154Abt27cIf//hHTJ8+Haeddhpuu+023HvvvSxS/njkWHRWuf17vPP4c3ngSC7zgT+nWH+kQKBUL5b2ma4nbYPXTXjdpRiQyPddClbxoCR/b7xeK+0TL9LryP0vNx7F9H06TqPRoLy8HLNnz0Z7eztKS0sRjUah1+sZLRJxc1OWBTmQ4/E4TCYTGhsbodVqGTAZCASg1WpRWlrKCmUCYPugIAhwuVywWCxoaWlBVVUV9u3bBwCora1Fa2trga5dbByKzS05UPpo4yA3dsU+k34vfRbF2iz2jN5vmQAeJ2RCJuQjK3ILJq/08umBcpKVA+QUR1YfpWsVAyALgcPDhSh4xZ1XwOW8ZHLpR3KbR7ENSwrKFQOexjPq6XtKxaTxBA4DM/SZnGInvadiYBj/jIopNtK07PEACZVKheyhVGsCWBQKBWKxGMbGxrBz504MDw+jpqYGTqezoDKn1WpFLpdjqYuBQAA6nQ4OhyOfSn2oaqder4co5iMbtRoN40ejNMdsNsuKNWSzWeh0OgYA8GAhVcajCBWqyM1z5lG7BOJIo07HmwvFnsN4Sg+vaI4njz/+OAYHB5FMJtHf34/HH3+c8YsB+fTee++9l0Wc/uMf/ziCu7G2thbPPvssYrEYPB4P7r777gIuwvdalEolQqEQ0uk0mpub4XK5jqALIBC8WFo675knA0AOAJeeA+RpC6xWKxobG6FUKjE2NoZkMslAu+HhYeZlpwIxFosFnZ2dqKqqwrvvvovOzk4Ah9OpeaCQwEECrSi6EAADyImHlKLujEZjQfo0FTWi+SmtfMzPDRovPmKO5i/xJqbTaQwMDDDgTBAEjI6OIhwOIxqNYmhoCEqlEk1NTSySQPrzXgitZfy7o9FoWHSyVqtlhX4sFgsCgQB8Ph+0Wi0qKiowa9YsNDc3s/sYGBjA7t27EQgEEAgECvg5qdI4XVcadUngKxUSorHl5w5xL2o0Guh0uoK5V1JSgurqathsNgbcZrNZluodj8fh9XoRi8UY4K3ValmEpdFoRElJCbq7uxEOhxEOh5nhRX2YkA+X8OuQ2+3GXXfdhc997nN444038Mgjj6CrqwsLFy7EPffcg7///e+49dZbEY1GAchH1ACA1WrFDTfcgBkzZrCUfFEUmfOj2DwQBAGtra3Q6XSw2+3IZrO45ZZb8NRTT2HVqlUT8+cTKNlsFo8//jii0SgWLFiAzZs3I51OY9myZeyYtrY21NTUYMOGDQCADRs2YMqUKXC73eyYFStWIBQKsajJ/0TofeH38vGi54u9J3J6UzEQbTynPH1fDHSk73gnu5RmZLx3UqoPSnXDYvcgPYe3gXiAkx9Hab/5v6UOWbm+kr4i56il6wlCvlhMY2MjWlpa0NraioqKCuj1enYtctrbbDbo9XqYzWbodDp4PB5WwI8csLRHEmUNOV1pXigUCpY5kM1mUVVVxbJkysrK0NbWBoPBwPpeTD+Rs72kc0uqR8m1cTQpNk/57+Tsy2J9LdaX91MmgMcJmZAJ+cjKkeDUYUCMjGEpX1vB5qAQAIUAQZnnhxRxKNpMFI9om65HxytUSghKBaAQIApgPwrl4QIM/IYgjYySghS8ssFvFnzEDu+ZJGBVLoJQurFIoyHlQE4pqHLEfQMFQCGvMPFRofw9y4EzcoAiD0RKuSiLbZL8/dLnOoMePr8fPp8PSqUSVqsVQ0NDePvtt9Hc3AyLxYJkMol0Oo2ysjJYrVZks1kMDg5CrdEgFAlDq9ehoqoSOYhIpJKwWCxQqVQsgimXy0EEoNKokUO+ArpGp80D1qIIh8OBVCoFpVLJCjnwIC6BPFSohLy1/H1RCjdQCDbJRYgWA5H5746mWPBpOB83yWazmDt3LhYtWoTKysqCd1M6V6UGACBfFEkKRPIGCP3mwU0CuKqrqxGJRBgQStGYO3fuxODgIAMRrVYrjEYjRkZG8O6776KqqorNPWoTyD83ilAURRGxWIxRDtDxBGJTVWtaNygake7HZDKxCEgS6b1R5B6lG/OGSjgchijmqz6PjIwwTqZMJoM9e/ZgaGiIpVj7/X7MnDkTkydPPmKt5OW9ADN48JGErwyt1+thMpmg1WphNBqRzWbh9XqhVqtRXl6ORYsWobGxkRHSB4NBDAwMIBAIIBQKIRQKsShISrumlGkaG77atpQDigeNKWqaXyMo1SybzaKkpISBPrFYjEVAEtdsJpOBXq+HTqdj60UikYDBYEAymURZWRk8Hg+CwSCLqozFYv/xGE/I+y/0jn7jG9/A5z73OaxduxZ333033njjDUydOhUPPPAA1qxZgxtuuIGB/sUisROJBBobG7Fnzx4Eg0E8//zzbM8aT7RaLc444wwIgoDt27dj6dKluOKKK/DAAw8URM9OyMdbtm/fztbMK6+8Ek8++SQ6OjowPDzMeI15cbvdGB4eBgAMDw8XgI70PX1XTJLJJFtv6QcoDgbyQJdcEIGcI3s8PWk8IFCqJ/PH8ToG7yzkz5Xq+/xv/hhp29J7o7alx/LXkOomciAi3QvfllzWFi+0dsiNMen0vI5VDCwj55xOp0NraytcLhejgSBuY9JriAc5FotBoVDA6XSyjKZkMol4PA6VSoX6+nqWEcDT0+RyOZSWljKOdSrYRvzTixYtQl1dnawOyOuKcvqknBNbTp85lrnHixTklQsikJurHzS4OJ58PC2NCZmQCflECBmV40XOFRMpIAYBEA9Vi1EU2UT4/ymS5GjXlG7WvOFJfZYD4wAUpErS/+OlKsspU9Lv5I7lPys2TjzYUixlWm7zlUaSSc+V9o1XqI54RpL74RUYtVoNjUaDSDgMo9HIUhzXrl2LRCIBp9MJrVYLpVLJUjw1Gg3GxsZgMBgQDAVht9tht9tZNCOBfySkXBHwEo/HodPpoNVqWeoztZvL5aDT6VgUGw/qiqLIPLJS8JgAcx7QlaZay/1In+GxHMuP43tB7v5hFK1Wi6amJlRWVrJoPilgCKBAQaaxlkbm8somUFzpo2dNkXUajQZWqxVtbW0QBAHDw8PI5XKsEJFSqWTAFinLgUAAL774IhYvXlzAL0pgFIF6lH5NijnNOTpeo9EwUICi/Lq6ulikXCKRgNlsZtF56XSagYrS9Yk+I2BNrVazd4Eip3ggS6FQsII6gpDnf/R6vTCZTDjhhBMKKlDT+MkZTv+OSNc3Pvpd6jDR6/WwWCxwuVyMJ4qiN8vKyrBw4UK0tbWxtPBwOIze3l5EIhFEo1EkEokCvkTaH5LJ5BGGLaVQE9hIxxJNBAAGINvtdgwODrK9JhqNwmq1Ml5Kuqbf70cul4Ner4fVaoVKpYLFYkEkEoFOp2MpaTabDSaTCb29vezaNA8m5MMrUmBiyZIleOihh6DRaHDXXXfh/vvvR3t7Ox555BHs2bMH55xzDtauXVs0mnVkZIRVnqbUaYvFUlD0S+76gpCvQBsMBnH++efj1VdfxaWXXopQKIRt27axa70XDoMJ+fBKa2srtm7dijfffBNXXXUVLrvsMuzatet9veYdd9wBq9XKfqqrq2WPkwNapMCaVA+nz+QKh0jblgJv4wGXck53+s0fL6dH8N9LI+mpz/z5cuBiMYCUP1+qe0vHTc6+kBO5PlHfqR0p4ChHw0D6Fe1hkydPxuTJk6HT6WAwGBh1DWU2UVCA3++HwWBgNC9lZWUoKSlhjkCVSgWXy8W4HSmLgeiViPs4GAxCq9Wira0NZWVlLBtHCi5KQVvpHsofz4+LnN4pffbHs4Yez3HSvstd94OQCeBxQiZkQj6ywm/M2WwWIgd0SUEvOZHztgmCwIBH3kiV/k/Refxn0sjCYiKntMj9LwX16F7ptzTij+/HeErCeB5O6fjKAaRSIEwaySlNm5S2U8xzKgfCyrUl/ZvGJxwOszRFjUaDnTt3oq+vD5MmTWKVhcPhMANPRkdHoVQqodfr4fF4WNql3W6HVqtlRRwIlKIoEoVCwbyser0eiUQCFoulIEVFEAQGdvD3SOAlcbvJ3RsBVwRQEDglNxbjPa+jgY78eR9XY9FqtbIoQKBQeZf+8CnvvBLMg37S+SpV1nmAgL+mVqtFWVkZmpubodPpMDo6ytJv4/E4RDFfwKinp4cVQ2poaEBlZSVL2ad3jhwePPVBLBZj84T/jt4nKmBDQKEgCKwipN1uhyjmORcJnOQpKvh3PR6Ps8hJIM+TNDo6ykBWAsDo+5GRESiVSvj9fkSjUQSDQZx99tmMF5RP65abg8eriI8n0srcfMQCgXYWi4VVu6Rq51SUqqmpCdlsFna7HWazmUVOEscjgYpkFJEhE4vFCjhk+VRrilSk++ejMauqqqDRaLB3715s27YNHo+HPTeaE2RA0X0QT5pWq2VgMq1PJpMJLS0trMqsIAgMvJ6Qj4aQsd3Y2Ii7774b5513Hp555hn89re/hc1mw/3334/Kykpcf/312Lx5M1sr+P3W4/Gwyu5erxerV69mVAhHA6EVCgWmTZsGlUoFv98PpVKJc889F4899tgxOWIn5KMvGo0GTU1NmDVrFu644w5MmzYNv/rVr1BWVoZUKoVAIFBw/MjICKNcKSsrO6LKNf0vpWXh5eabb0YwGGQ/fX194/ZRDkSTfs+Db8BhR79cG/w7VKxd6ed8ZCEvxQDHox1bzCknByJKdTo++pMXft+VBgTw7cide7R9Wc6ekPZDCs7xnxMHcnV1NZYsWYKqqioWvU9RilTwTa/Xw+v1wu/3M8chpVCTY5QCBah6tVqthtFohEajYcXmstks5s+fj/b2dkZZI2eT0T7O3ydvD0kB7qONk3TeFRtf6dyRmw9y8+to6/LRbNb3UiaAxwmZkAn5yApvxBXblAH5hb3Ygg4UGtrSDVIOHJQq9vyGJNcOvzlJU4ql4B7fNx6MOpZ+0HHS9GVqS9pPOeNfeh5/HT4iTC49utjYyEU5SZ+X3LMp1iZFFWazWQaejI6OYmBgAE6nE3a7nYEOVL2O7t3tdsPn88F8qJIdgUGCkI9O0ul0DJSicaMquJRuRN/z90YpkwAKvLpAHqwxGAys/3JeVHrW0hR96bjI/fBjxh8rB1aOp9B+1IUAJSnQxH/Pg5CkJPKFZ/jnARyZls07H+TmvkqlQiaTgVKphMViQUdHB5xOJ1KpFMLhMKv8SkAUVVzU6XSYPHkyq1DNp9wS0ESfUcospe1TxGwkEkF/fz+7p3g8zsZEoVCw9DUCM/m5DxxOSSaDLJlMIplMsnGgqpNAnrPU4/Gw6Ml0Oo2hoSGo1WqEw2EoFAoEg0G43W60trYeMVfl1qX3WmgcqEgUD/bTM9fpdDAajTCbzayglEajgcPhwMKFC1FRUYGRkRFkMpkCwJFAvlwuxyJC6Z5onCgiWqFQsMhSfs0koJPmil6vR2NjI0s18/l8jKuK59ekiEa6F71ez4yoYDDI0s8UCgVKS0tZpCZF935co50/bkLvCc1drVaLL3zhC7j77ruxZcsW/OQnP4FGo8EjjzyCH/7wh/je976H3t7eI9Z2s9kMo9GIgYEBVul97dq1qKioYNzD4/WB0r6nTZuGTf+fvT8Ps6sq877xzz7zfGquSqoqlco8QMgAJCGKIAgydIPggA+Xou2j/pDggK00tgPigM3Tb4vaCI82onbDi6/d4oAyiyAQIcyQhMykKknNVaeqzjzt3x+VtVi1svepCmSoCvt7XVXnnD2saa+91r2+6x6efZYLLriALVu20N/ff6SbwMEUhNCcXrVqFV6vl0ceeUSe27p1Kx0dHaxduxaAtWvX8sorr4zTrn3ooYfk3GgHv99PLBYb96fDagNQl5Gt5mrVBFo3cZ4sYaPL4yI/AVXOsJPD1DLqeagyr5BT9DzUtPR1i7oprhOLQobRra7UTVS9jnr+OklrVWerMunWUGrdxXMRxOC8efNoamrC6/WSy+UYHR2lWCzKQG/CPYmoTygUwuv1kkgk5Hnhq71QKEj/7i6Xi4GBAVpaWli0aBEzZsyQvqD1Z6iX0U5urvScrdaR+r0TXWMHnby1I6qPpcx/5Dy6O5jymMxui4Ojg0okmAN7iMFz3K6d+8Bgr04OgGke+KLcK88rk6k6kdpdV0lI0NPXCUd9p0o/L76rmnzAOMJRXCPuUdO2IiPViV4/ppZF/67C6ridAKSnq9ZNJ3/sBDu9LnbtJ8ohgrsY5hgJsmXLFgBOO+00fD4fXq+X7u5uaXI9MjJCU1MTo6OjlEologd8OYq2FruowkxaDfqSyWSoq6vD7XZLMw61jLpGnai3asqj91tBbqkajWpb6Fql6rNXr6skKB+vBKMVVDJH1cSxE/gN4w1fgFbvpvpb7csT9V+h1VYul/F6vbS0tDBv3jyy2Sz79+8/SCNTaIzMmDGD+vp6SaYPDAzIwEgiTdGn0uk0hmFIgkmQX4IgE/6NDMNgeHiY5uZmTNOko6ODWCwmyTU9yrdKBgqCS43kXCwW6e3tpVwuS+3gxsZGcrmcjDzpOuCy4JVXXiGdTnPxxRdLbUErn3L64upw9FerhZwgU1UNctEHhB9M1Vzd4/FQX1/PunXreOaZZ0gkEtJMubq6Wj6DUCgkCVxhzixIwUQiQTAYlK4gxDMpFApEIhH5PE3TpLq6mmQySU9PD+FwGNM0pUaRCFAjSGa/3y+1OVTNbBgjj8X9gvycPXs2nZ2dtLW14ff7yeVyMjCWg+kDMUe8853v5OSTT+bZZ5/lZz/7Gel0mtbWVkZHR3n22WcP8lOWTqeprq5m06ZNmOaYBuRLL71EKpVi586dnHrqqbYEiJp3MplkaGiIQCDASSedxG9/+1uuuOKKg1yUWEGXZRxMD1x33XUyMvro6Ch33XUXf/nLX3jggQeIx+N84hOf4JprrqGmpoZYLMbVV1/N2rVrWbNmDQDnnHMOS5Ys4SMf+Qg33XQT3d3dfPWrX+Wqq66SGmaHAp3wspozKhGSdv3Qrv9PJCvrMrkddG05qzqoc6CVLCy+q5qKajrqGkJNT1d6UMuhyjRiY0rNQ1eG0Ots14b6+kBvOyH7inzVOggLpvnz59PU1MSePXukf+OhoSEpgw8PD+NyuchkMgSDQQYHBzHNMb/rhmFI2UlYJQg/7KVSiTPPPJPm5mYZfEZsRqprTF0m1+utK0RYPSt1/WUnk6qYiDi06sd2bVwpnYnKcTjhEI9vQ+gLXXVQcXB0oT4LdafGweQgBk51AWkYY8FeDNPEEP3aFORjZeJPfNpNIvrgbrf7ZUVgCqgTmF5uq3SsCDe7HStVSJlsHfQ81ba1g1X6eh3VNFXSTNXwsdJssmtfu0laCAVisT86OsqWLVvYsmUL559/PosXL2bv3r34fD5JDBQKBerr62V010AgQO0BIlEIJMlkkmg0KkmKcrkso37W1tZKkkCQAIA0QdXrZprmuAAz4l4r0lB9Tmqd7caFyfQLPQ+9r00UVGC6QhBJgUBgXPADnbQWUKMMq0Sweo9oPythX89bEHbCpFloqTU3N0vz2n379rFixQpGRkYwDINwOEwqlaK+vl5GuxYEldq/RPRjNaiIyM8wDAYGBiThGg6HGRwcJBgM0t/fz8yZM3n99dfp6+ujra2NYrEoo1qrY5dKMgozTNHf8/k8g4ODUmNKBDkRkSUTiYRMc+vWrfT19XHJJZewcOHCcZoDKsGp9mF1DFGfi91zfjMQz1FNV3xXTcdFmYRp1sqVK9m4cSPDw8MyoEKxWCSdTlNfXy99Qfr9funj0u12S5P2XC4nNU5N06S+vl6WJZPJSI1Xn8/HwMAApVKJpqYmSRL6fD4ZqVO0k9/vl24fhGaqy+UiFotRU1NDMpmUfWHlypU8/vjjpFIpAoEA6XSaeDxeccx3MLWgEwzhcJjTTz+d0047jZ6eHjZv3kwgEOCMM8446L6Wlhb27dvHe9/7Xnp7e3nwwQd59tln+cpXvsL69evHaVVXwsqVK0mlUiQSCdasWcP69et58sknueqqq5g/fz6hUGicmxArIsKRd6cXent7+ehHP0pXVxfxeJxly5bxwAMP8J73vAeA73//+7hcLi699FJyuRznnnsuP/7xj+X9brebe++9lyuvvJK1a9cSDoe54ooruOGGG95SuazIHF2+tCPv1DlIvc6K1JxMOaygklR6/jqpJ2C1LtfnS7s8dHlSnet0wkq/R62HOK5rLFqtm+zqr64X1LqpZbQi8XSZ1ufzEYlEpEm+y+VidHRUWnwIWWtkZISOjg5CoRBVVVWMjIwQiUQIBoN4PB4ikYh0e1JfX08sFqO1tVW6J1Gfh924pa/j1Lqq0GULO5JWPa/3lYlgJ3/arUErPaujAYd4PE6hvwh6BxOCvdWL5eDIwepFV58FINW7necxOYhJUZ0EzLIJhoHrQBMaBxa50ocbB0eL1gdj+axM651O3XG7Plna7UZVIvlVYUmddFVTEN0EW+8r6maClTChl0tgXPtZTFSq4KILeVYEmU6qqfXTJ2O9XFb3VhLohINpr9fLtm3bGBkZYeXKlZx++ul0dXXJ5xwMBkkmk9IfjDAxFEJNPp+XxI1wVC36jDDlFmSKlTm93burEo261qlaX5VgsROS7YSINytMmObYpke5dPwGmBBaj4Lo0c2p1PdFQH2/9XdWbXP9HdevV98nYfYaj8elFtLmzZvp6OiQ5FMmk6G+vl6Se52dnYRCIUmYqxHRVaJRjEmmaUpH6YA0qxamvX6/n6GhIfbv3y/NepubmwmFQgcJvqLfC1NiwzBkRORcLifPiQijqVRKBr8RhIRpmuzfv593vetdrFu3TqZjRfYJklF9p9Rxz8p06a1C1NeqTCrpaRhjfjrL5TLRaJTW1lZp+rx9+3bmzZsHQDKZJJPJjIvsKvqS6GelUklqGYqFjtp/1IjjNTU10uej0BIVz9nlco0LCpTP50kmk9I8LRgMSkLa6/XKxZe4VwQVEc/awfSDPu57PB6am5uZOXMmZ599tuU9brebDRs2cMIJJ8ho9oODgzz44IMsXLiQFStWTEoO9Xq9tLe386c//Un6fSyVSlx11VUUi0Wqq6tpaWlh9erVzJ8/n8bGRkZHR6Wv1xNPPJHFixcfNB47mLq4/fbbK54PBALccsst3HLLLbbXtLW18ac//elwF82W5FFhdUy/X5c/rciwSnnY5WVFdloRTVayoV6/SsSV+F5JPtevt0rfam1kla+AuvawWifYXa/mp9dbl708Hg8zZsygsbGRVCpFc3Mzw8PDDAwMsHv3bjm3tbS04HK5ZBBHEUgyGAwSiUSYMWMGdXV1NDc3Sw1HnYBW62vXB6xkB73NKx2bDKzWp3Zk40TpWLXx4bQumQwc4vFtAKvBQ/wJEkM19XJwZKBPVuK7SmCIBaWjgTo56IOwPiEIHDRBl03KlOWuvvpsTNPEOATuxkpAUCdtMRHqpKL4tCKf7Ig80XdUjSGr91u813q91fTs/LlY7ahaCShqoA2rNlCvtfpuVSY9Db297CZOsSgXgR5mzpyJ3+8nEAjQ3d1Nc3MzDQ0NMrCM3+8nkUhIP2jlchkMJIEiHE6L/ASZEggECAaD5PP5g3ZsK8GKNKw03toJa1Z52RE4h+Inz2248E5Cw2U6QrSl3++Xvvd06GOzLjjr6en3qsKoOqaLvl0uj0W2rqqqktqJ1dXVeL1evF4vL774otyVF9e98sorGIYh+2koFMLlco0jwHO5nCTcRZlzuZz0TVoqlYhGo3KxLzZbXnvtNQKBANFoVGrKqX1d1KFUKkkyvlwuMzw8LN8F8S5ls1ncbrfMN5lMSn+Swkx47dq1nH/++TL6eyU/Wnr7w/iAWvp49Wb6w0RQ32s1P5fLJX2zVlVVMWPGDGliLfwpCjMvw3jD7NrlcpFKpWQUcNM08fl844L4iPQFMSzOFQoFYrEYxWJRPsdsNitJSzH2iX4RCARkYCy/34/P5yOVShEOh4lEIpRKJfr6+giHwwwMDDBz5sxDtrTYt28f1157Lffddx/pdJp58+Zxxx13cPLJJ8v2+8Y3vsFPf/pTEokE69at49Zbb2X+/PkyjcHBQa6++mr+8Ic/SA2pH/zgB0QikUN8og7AWvvJ6hrTNJk3bx6dnZ1UVVXhdrtpbGwkkUiQzWbZvn277BcTzVEA1dXVwBjh1NjYyAc/+EFOO+00HnjgAf7f//f/5ZVXXuGJJ56QbhdCoRCLFy9m5syZ/Nd//Re33XYbLS0th7ElHLwdoRNX6nGr75VIPCv5W0+70hxkRzZalVeV4/W8VJNoq3vtZBk1PVUWtCJR1bR0rUb1sxI5pdZDzVP9rtbPinTV213/rcpmYo0UiUTkhmwymWTu3LmkUikGBgZIpVLSZ3I8HpfWCC0tLXJOFhrZokxCO3sic3IYb7mlP3erNc1EpK2exkTHrchIqz5q9U68mXIdThzySsMROKYXxELCaicCrJ2lOjhyEL6+hOmJHkHVIR0PDVYkgHpctK2qzeF2uXG5xnxBWk3eBgaGAajnTDBdlRetlQg2dZK1I+nsCDWdFNUXw5VILSuhxUqwsJvAKhFqOuEClYUTPQ+rMqnfrfypqEKSLsgIkrGqqkr6kNu1axe5XE76bfF4PASDQRlQA5CCS+qAppBpmlLbSJQhl8tJMwzhT0YlmOxIKrXuVn2iUrvqx/TnrdZdXGNF1FrlZ1XWIxXQY6pAJaZ1qMKkekyMy1BZg0JtSyuhWrSt0D4rFosEAgFmzpxJIBAgm82ybds2KfjCmOZcV1eXdMEhTHZjB3yRisAwIiq7EPCFwC3K5vF4GB0dldqSiUSCQCAgo6oHg0EZmEbtSyJoigigIlAsFqU2pfD7ODw8LM2KRYCbnp4eDMNg7dq1nHXWWVLzUrSH3TxnNw6qixnxrA73XGm1SNWJR9McM7murq6Wplujo6OSHBTPKJvNSpI5k8lQKBRwu93E43Hpt0rVnBbygMfjkdqSQkO2VCqRSqWkSbwIeGUYxjgtbdMci0wuiGdhUiZMxHO5nAx0U1tbS29vrwxMM9HmicDQ0BDr1q3jzDPP5L777qO+vp7t27dLAgrgpptu4oc//CG/+MUvaG9v52tf+xrnnnuuNP8FuPzyy+nq6uKhhx6iUCjw8Y9/nE996lPcddddh+NRvi0x2UXt4sWLCYfDdHV1YRgGtbW1hMNhqR3k9XonnafQHtqwYQOzZs3ivvvuo7W1lfPOO0+acheLRVKpFPv27aO5uZlEIsGTTz5JPp+flD9IBw4mAyuScKJxrZKsKqDLp3bkm36vlVwNb5gZ63K+Oufo8q2VDKjLylbyuy6fVGoPXaYUUOdZfVNVLb9VXfQ2sTpmJdfaEb3q/G+appTrA4EAtbW1AHIzVKx/hEwl5ldxr8p96HVXza1VKwy1Ha3WOnq5K/WXw8m7vNn09DodjXXAIRGPx7PAMVmhC6afKYBY6IhdbaFVZ5pvmO5MFRzPzwHeeBYC6oJKj6TqYGLYTap2pJnVxH0wOXPAVFu/1wQO4bHoeanlU7/rAsVEwpNKZtgJIXbCj56Onr7ul9DqWj0v9ZguOOll0L9P5n3XiVaVfBTpCQ2rZDJJQ2MDXo+XwcFBduzYwcyZMyVZEgwGZSS8YrFIKBRidHR0LGBMLsusWbPI5/Pk83lJ3ojgDeriXGzmqMKLlb8XtQ6THdvs6qinLdpFdYA92TbV21UE0zieYRjGOK1HXZBVr1NJLvVdsyLCVG0xlZwSv/VnKBb1+Xwet9tNbW0tK1eupFQqsXv3bhl4JBKJ0NfXRzAYZO/evTQ2NhKJRKQPP7VOoq8WCgXp929kZESSfclkklAoJH2Uiv7s9Xqllp5hGFKbL5/Pk8vlpKm1IMWEtqOI6CyCmghfSwB9fX1S42Dt2rWceeaZ0m2BaLuJ+quuoaF/F++fWEQcDuj9QA+0oz5XYbYsyLu6ujpSqRS1tbWStPX5fJTLZRmARtwrCEgRHEj0H9M0pS9PsSEp/EIODQ2RTqfls1P9ysIbgX5E/wsGg8TjcbnBIjRpk8mkHAeFP8hMJnNIm/7/8i//QmtrK3fccYc81t7eLr+bpsnNN9/MV7/6VS666CIAfvnLX9LY2Mhvf/tbLrvsMrZs2cL999/Pxo0bpdLCj370I84//3z+9V//lZkzZ066PA4OHdXV1Zxyyils376dUqlEbW0tS5cuZcuWLfT09Ehtf5hYFhWm3X19fcyaNYtf/epXvPrqq9TX17N8+XKi0SjFYpHdu3eTTCaJxWK0t7fz7ne/m1NPPZVoNHo0quzgOIVd/6xExBwKSWO34WhVDis5XaShllWXO6x8UdqtG9R01LJVIsKsLDj09Yeel1WZreSaStYLh0L6qm2g109dG6nchZBNVBnN7XYftJkhLE6ErC7clVgRrWobqnK9+lttI9WN0pvpJ3btcaRgRYrqa7cjjUNaaRzvAofovGqnUDvddNRE0xem4kUBpNbdVISdJpHdYnG6QF2kqnVUHdpO17odC9hNjqomibhuHKFzgFw8SBvwwLWmxURkuAyspguriV58VjLHtdspU/uHHYFnZWZdiaRU0xeo5GNGXK+mpWvW2RFkE/Vfq3awm4jVvFQBw+r60dFRMpkMjfUNkkz0+Xw0NDQQCoWkKagIQqOSN8PDwzQ0NUqNs2w2i2EY0qRaNX/XtZR0QcSOeKz0jPRrKwkvuvAnhB4rZ9369VbtD0hy5HiHeL7qRpza9/XnqL9fan+E8b774OD3Upi/CpJSPC8RjESQj/F4nJNPPhmv10tnZ6ckhvbt28dJJ51ETU2N1HgUY5bw6Sf8m6rjjdfrJRaLSQ1IQQz29/dTVVUlfV6OjIxIMiAej8t2UUl1lYTo7u4mHA5TKBQwDIPBwUEAMpkMg4OD9Pf3k0gkiEQiRKNR1qxZIwV+tZ3E5qeA1cLHiuS1+n4kZBi9PPo7D2Oa0oFAAK/XS1VVFV1dXeTzecLhsCR/hXZtJBKR5l2lUkmapAsSUe13gvAUmyOFQoFcLkcwGJSbIGJhJfxJRqNRTPMNH7PRaFSObyJqejqdHhcJvbq6mhkzZhCJRCYcc1T8/ve/59xzz+UDH/gAjz32GM3NzXzmM5/hk5/8JAC7d++mu7t7nH/BeDzO6tWr2bBhA5dddhkbNmygqqpKrgEAzj77bFwuF08//TTve9/7Dv2hOZg03G43Z599Nn/+85+ZO3cu+/btY+fOnYyOjrJx40a2bds2oZ9H9f1ctmwZDz30EMFgEJ/PRyaT4eGHH+Yvf/kLwWCQWbNm8eEPf5hzzjlHRlK30jZy4ODNQpdBJ5LF3mwedvK+yFtfr+r36H2+kuyrXqfKmVZl0Qk4O5nGrux6mnYEor5msCKvdLlJlSfs2lBf4wu3Mmo76msWde5X19aqXC5cyeltKNLXN47Fp50Shn5c51as5BH9Wer1tlvH6rJ+JYJQJz7t+r6qyWlV3ylHPB4rgUNE6BMQfrjeKvTOpHZIGP+w9cWHOD9doAvxgpCcShDtqjpO119i4btOLftUfw468aPvPjnm1W8eov3U97KMSdksSxIRzAOKigZls0zZNME0xwLOHDiOaWKWymOEpPlG2uLTSnCwMmG2I5SsFsl2hJMafMTKN4s+uevjkzgn8rATOOzeG6vxTZ/4xPtnRVbpC3QrwctqUtTNSVRSRxcE9Mk3k8lILbFoLMrg0CCBUJCGhgYZwTcej1MoFKTpYyQSkaaHoVCI2ppauYMqtJXUeqrta0fQVpobrPx82pGoej2thFtdMKxkZq3eq89hhmGA24WMxHScQrSZMF0Vx+CNvqeSkeqz0p+x+j6rWo86EamTVmrfFhqmgjysqalh1apVuN1utm3bRiAQoKuri/b2dkqlEvF4XMpBgpQSm4eFQkGWy+VySY240dFRdu/eTV9fH/F4XDpZHx0dpbu7WxJZNTU1BAIBWY9CoSCjQ/p8PtLptAzGJOarRCIhNSj7+/vZt28f5XKZhoYGotEopVKJOi1SvBgTRJuI8lqNlTrZC0hNBaHtKM5VGlcPF1TXKCIf4WdRJf/K5bL0x1koFKTWqCD3w+Gw1MAIhUJyPBV1FHmIwD/FYpGqqiqZv3AZYBhjGyP19fVyQ0VogArCMxqNyv6m3i98QcbjcUZHRwmHw5Nut127dnHrrbdyzTXX8JWvfIWNGzfy2c9+Fp/PxxVXXEF3dzcAjY2N4+5rbGyU57q7u2loaBh3XrwD4hodR2od8HaDeK9mzZrF5s2bmT9/PnPmzGHz5s0ywNTWrVuZM2eONF2cCMPDw+zYsYP3vve93HnnnVxwwQVccsklzJ8/n4ULF9LW1ibdB0x1ed3B8QErOdNKPrOSrdTfdmnr9+r32xGOVvdYkXhW11iVXZfp1HOqDK6Wy85SSXxX51Srsti1j74egYPXA1b3qXVU5QK1DFZrZH1NZFVOO4Ue9V5V1lMJOX0dZZVGpbWUXZnsoJO4dmseO9leT0snq9U8juU4fEjE47ESOG688Ua++c1vHkpRDwmqxoggtlSoC8apRtZNBHWXQGCqk47qs1DLL57DdH0Wet9yfDq+dRxEwqEO0GBgMUmK68a+jn2Ka4R/R22QH/s7cJMGncTRJ1D1OnHcTnjQ07PyOQfWflb09rCaVK0mJx06ESCu04U2OwFN9GnRdupGgjqp6vfrwpDdBKneqwopgpDI5fNU19Tg9/upisWlLzwYW4hHIhEMwyAejxMIBPD5fNLUuGyWqTT5W7WXKmzZta1499WyW9VXJ6grtZfa3mpbiPTs0tfT0YmP4xWirl6vV2q06oKdFbGuE+hW5G2l/qofF9qzIm2hfSh8A5500kmUy2V2797Nzp07SSaT0peial4stOTVsoq0k8kkqVSKzs5O+vv7GRoaIp/PU1VVxbZt2+jq6iIYDNLU1ERjYyOxWGycH1zh3zGVSjE4OCgJR0FSjo6OMjw8TCqVIpVKkUwmZYTIbDZLOp1mwYIF0veklXaT2q66JoOAerxcLkstT9WnpWrmdKQhovaKZx+Px4lGowwODtLc3IzL5SKTyYwjgIVGoyAEhWm6z+eTZtdqX1LdrYh+IcYon883rm2CwSCpVArDMMb56BM+RIvFoiTbRX9TNTxaW1tlmnYLGh3lcpmTTz6Z7373uwCsWLGCV199ldtuu40rrrji8DW2hiO9Dng7QH1H5s2bh2mOaUe73W4WLFhAqVRiy5YtPPvssyxdupRwOEwwGJwwzXA4zCWXXEJNTQ3RaJSPfvSjzJ0711Y+ceDgcEOX26zO2Y1xdqSSel4/psOO/LMrq1V6dr/1tK3kcXVtodbVSlapVG71nVXTqUSwieuEuw+rPMX8Y5WG1drHqowqmaavt3RyVR93dLlbJ1yt1mpwsBm2mo6QmXSCz2qNZLVG0K9XIeqqyvV2z0+9pxL09aFev6OFQ2I8yuUyK1eu5Lvf/S4rVqzgU5/6FJ/85Ce57bbbjlT5ALjuuusYHh6Wf52dnYctbfWh6g9YfWGsFqFTHaZpSsFVrZcaRVH/O1blhPGmnEK4118QdXE01Z+FPhDqC3+VdDzWz2CyuPHGGznllFOIRqM0NDRw8cUXs3Xr1nHXZLNZrrrqKmpra4lEIlx66aX09PSMu6ajo4MLLriAUChEQ0MDX/rSl8b5vnzzOHhCUokw0Mg6bQK3mszGLjtYq+2gnG2u1Qkoq+NWE786mYo/q40Ru75jN9Hp/VBPX/hyU/90Uksth1W5xH1i8lTJEXVMtXofrJ5ZpfILMikUClFTU4NhGDJadTAYpK+vT2ogxeNxYrGYNDn0er0Eg8EDGj9vtGel56q21WTa2EpQ0Pum+mc3BtiRhlbtaSXwqFpjep5W/ep4hW6yP1Fb2Y0n+nttJzuIPK18+Ir5TWiwCY24VatWUVdXR0NDA6ZpHkQ6ivR9Pp8MECMIAmHenc1m6erqkubQwWCQTZs2sWXLFurr61m2bBmzZs2SgWZcrrHIy7lcjkwmIyNX53I5DMOQEZJ37NjBs88+y969exkcHCQajXLiiScyZ84cvF4vPp+PkZER2traxi0SrPqnOrfrfVCVuQxjTLsvnU7Ltjpa0J+/eH9Mc0wrMRQKyWjVPp9PRr0XCy3Rtl6vVwZ8aWpqIhqNSnPsdDpNIpGQ5tDCvFqMU6IdRH8Uz9jlGovMWV1dLcnhXC4nSUdhgp/L5SgWi5KsLhQKhMNh4vH4OP+bk8GMGTNYsmTJuGOLFy+mo6MDgKamJoCD5vyenh55rqmpid7e3nHni8Uig4OD8hodR3Id8HZELBZjxYoV9Pb20tvby+zZsxkYGCCRSPC73/2ODRs2yH5cSTPfNMcCGkUiERKJBIZhsHfv3ikvyzo4vlCJ0BKwmuvt1l2HQhJZpa3fY0euVSKk1PvVuVMlFSuRgbq8aJePKneqa+5K61J9Phf3WVmMqvVV71e5Fbs20QlE/bdeFjFHi+O6co+V5qUot1oWtX3t3ELoz1SXdezIUf3Z2a3d7J6xVZ+xO1YJVuuJo4FDIh6PlcDh9/uJxWLj/g4XTNM8KHy6utjQoxlN9CCPNewGAiEsT1VhwG5AFYOG7hvRSoV4qkInV9TFI0yvXeDHHnuMq666ir/97W8yONQ555xDKpWS13zhC1/gD3/4A7/+9a957LHH2L9/P5dccok8XyqVuOCCC8jn8zz11FP84he/4Oc//zlf//rXD7k8BwvE1gtcsCb77N5t/fjYd/sJVL9WJeWsoE9YVrCa2K3IJ71M6nXqgl7/OxSoiw9VIFDzsWpfQUCKDRC13PqELAhO9bxVm+jpiPHB7/cTDocBpJaRSCefz1NXV0dtbS3ZbBav1zvOXNUwjHGbHWp+6qdaBrtnod+nflfbX5AHOmllla9V37RaEFoRYzqpadfPDyWS6XSGLhzrx9VjExHCdgtyVX4Q/Usn9YFxz8jr9UrzYRHZuLW1lerqamlG6/F4ZHAZkYYIBCOiG4tje/bskS4IRkdHefbZZ6mqquL000/nxBNPZMaMGcRiMemTTUReFr4g1YjKuVyOnp4eXnrpJbZs2cLIyAh+v5958+ZRU1NDLBYb0zCuqpJmviKAivq+iDYTdVfndHGdeCfEZz6fp6enh9HRUdlGxxJq//F4PPj9flpaWshkMqTTaflei2eZy+WkRnUgEMDv9xMMBgkEArLdAoEAdXV1RKNRAoEAoVBIanUKYjkQCFAqlWQAGnFfJBIhFosRjUYl8SvK6PF4ZKAbYeqdz+elpqbon4dCPq5bt+6gzcZt27bR1tYGjPl9b2pq4pFHHpHnR0ZGePrpp1m7di0Aa9euJZFI8Nxzz8lr/vznP1Mul1m9erVlvkdyHfB2hMvl4tJLL2Xfvn285z3vIRwOU19fTygUor+/n76+PmneXklOEX2tUCjId2Hv3r2WC28HDo4GdBlHlZPtSC0r4ka9vxKJqac12TJWSkOXUVTZTbfEUOdXXZlFJffUuUtXJlDbaTJm1lb3Cahmy/o4YJWOmpa6Ga6WQ3e9pK+HrEhPtX1UclFNR+Uc1LpY1U2XY1QrTD1PtV76uqYS0Wgl+1daa6jXqPlNlh85FuPyIUlwhyJwLF++HHhD4LjyyiuB8QLHqlWrgIkFjiOBSg9F1aoTgp9YlOqdcypCvKR6eY+GH6S3AjHoCIhBU32hBUmsLvynYl0E1EFAkBsTaTZNZdx///3jfv/85z+noaGB5557jtNPP53h4WFuv/127rrrLt797ncDcMcdd7B48WL+9re/sWbNGh588EE2b97Mww8/TGNjI8uXL+db3/oW1157Lddff/04c7LJwGpQLiu/RR86iNSyETImGuArPTd1UrFKx+p+u2N25w5lB8yufPrYoBNSdlDfOeErTK+fTixY+ZlRIYQBVfBQ71fJCTUvPU2VOFLLEA6HmTFjBtFYjFQ6TTgcot5Tjz8QoFweGyfLpglKn9DHUF1gBcbtqtppP6rCoB25qNdJzUt9LrrptF376W2rX2+Vr0qGHY9Q29EwxjQMc7ncuHFY/w7jhUsVop+KICtWwr4Yd0Q6uu9ilTRX30VhVmuaYxYL4XCYmpoaKYd4PB5pfpvP5/F6vSSTSXw+H4lEgtHRUVKpFIlEgt7eXhKJBKFQiLVr19LQ0CDdCwiNOhgzrc5kMtIkW/gtzOfzjIyMMDQ0xODgILlcjvr6etra2mR7lkolUqkUCxYsYNOmTYyMjFBVVYVhGLKNhbam3obCFFhdHJRKJblxkMvl6O/vp1gs0tDQII8LOeBYzaXC7Nw0x7S9kskk1dXVss7ifVLNrdW+JDQZC4UC6XRaap2qbSM0tkUUceHfMBgMSs1FdcxTTcAF4SvKkM1mpUVBOBzG5/PJ6Ommacro55Npxy984QucdtppfPe73+WDH/wgzzzzDD/5yU/4yU9+Aoy9A5///Of59re/zfz582lvb+drX/saM2fO5OKLLwbGFBbe+973SoupQqHA+vXrueyyy5yI1kcJhmEwf/58du7cKYnCmpoa5syZw86dO9m4cSOvvfYazc3NMoioFWEjjsfjcbLZLHPmzCGbzR71+jh4e8JuzLKSeazkLLv7dTlTl+Gt5Dgxp+mB6yqtBfQy2JFqVuUX6ajX6STUZNbIVqSZvi7Qv+tlEFDlSF1m1cuvy7pWbS2utdo4t0tDbxvd4sqqXvpaQw3Kq5ZLJUTVDVNdBrRqy4megdpWk4V+baW87MZvtd2Ohix1SMTj8SZw6C8ovLGIU7UgVfJrqhKPaufTF8Hqyz+VoQ9+4iUQx8VgIM4fyst5rCAWVsC4ReZU6z9vFsPDwwDU1NQA8Nxzz1EoFMYFmFq0aBGzZs1iw4YNrFmzhg0bNnDiiSeO8wV77rnncuWVV7Jp0yZWrFgx6fx1YgvAZbgwOdi/onqPYRhQNhE+G/VxwHJy4o2dLisBQJwT0H136VCFC1XbxEposBIC1Gv0slgJIlZlthN4dKgTrdUkqwsE6mRsJ1Tox1TtcitfNVaTuD7JC2JHjBVF06RxRhN+v38siEw4hAm4vZ6xQEKA2+Me9yz056O3qVX72JGJVs99IjLQDlbEqziu9xOr52FVJvFd+D08nqE+I6/XK0lDlQC0Eqz1/qqmo5I1qpygfheEkBrJWRBmYn5QyyFIJOErsLGxkUgkQqFQkOa0QkNN+PIT2nbpdJpcLsfAwAAvv/wy6XSaRYsW0dzcTDAYZGhoSJoHu91uSWqJMgoicmRkhEQiQaFQYHBwkFAoRDQaZd68eTQ1NeF2uxkYGJDaw83NzfT29pLNZslkMixYsIDR0VGy2SyxWEy2uYgCrf6p9TYMQ5oIC9Kzp6cH0zTZtm0ba9askVG1RbRsVZvhSM+ravpCyzoajTI6Oorf7yeZTI6TH1VNxWKxKM2whQa4qEckEpFpir4FYySh3++nXC7LYDNWWrgifUEi+v1+BgYGcLlchMNhUqkUVVVVUkvQ7/fj9/sxDEMGHNLrZ4dTTjmFe+65h+uuu44bbriB9vZ2br75Zi6//HJ5zZe//GVSqRSf+tSnSCQSvOMd7+D+++8fR67eeeedrF+/nrPOOktq3/3whz98K4/HwSGitraWdevW8atf/YrTTjuNTCYj36X+/n7++7//mwsvvJC2tjZLmUHAMAyWLl1KT08Pra2tpNPpo10VB29TWBEv6nErQkedc3U5ya5/62nYjZVCi9xKZp2ITJyofqqMq9fDDnrZxT3qZrjVusKqjOrax2pNUYlzsLIysSufmp44b2cOrqavlk9dG6p1Ur+r+akKKmoa6npHbxPd+lLnifS+qadlB71fWq337Oo/ET9V6dzR4lQOiXg8ngUOVWsE3ghyoi5kBaY6aaSTjlaLp6kIO1JCJSFUTEUCz4oAFtAXR1Ot7IeKcrnM5z//edatW8cJJ5wAjAWP8vl8MoKhgB5gyioAlThnBbuIlqJ/iO9woF+IZjeRWmyGYYzxjKYJ5niiTSd1hFaRSkgZroP9fegmy/qEoU8ylUg0HapwoJNg6vikCyLqvWpadu+UPplbvWdqukJzSS+TWh7TNKVLAat3WBUS9LZXhTR9IlUndbW+KgkkCBTTHPOBJ0gm4YtNaBvpG0tqW1cyRbd7ZpVIR10YEfmJcoo20e+3IzvVewQZZSXc6vfqgqPI61BMM44HVBLc9fFAEElWz0Btc0EYivTVviSuU12eqL/VfMvlMqlUioGBAWKxGDU1NUQiEVKplDwnzGlFmUTwkFAoxK5du3j11VclARiNRmXAF5/PRyqVIp1O4/F4pO9TQF4jgpWIfNra2kin00SjURobG/F4PDJISiAQIBqNSv+EMDaGh0IhRkdHSafT8l1TtRsNw5AEaCQSoaqqiqqqKkzTZHR0VI5vuVyOjo4ORkZGKJVK0i+daZqSkFPb8GjD7XYTDofHRbEOBoMUi0U5h6iatW63W2qUijYQpLe6MFP7iHCBICJSWy34xLjsdruJxWJkMhlqa2tJJpPAGIFZW1srfYIKYlQskg+1/S688EIuvPBC2/OGYXDDDTdwww032F5TU1PDXXfddUj5Oji8cLvdfOxjH+N//+//TalUorGxkWQySUNDAwMDA/ztb39j3bp1DAwMSPN/4UIAxsuwoVCITZs2UVtbe0hR0h04OByYDKFiJyNVukd8rySr63KoTkRZyYZ2hKn6u9I1ViSiFamoXq8rAliZXYt8VKsNK3nSri2sZCurdZKelp6euq6xag8rvsBOLtfJRJ1QrET02aWtr7FUGV9fE1VK1+q8VVvp9+vnrOQCcdyqr1v1rcm8F4cDh+ws53gSOPRFQ6UXyqpTTQWoA55ufjydTHrtXhj1BZ7K5K++uNfJFP1ZTLXyvxlcddVVvPrqqzzxxBNHPC+7iJYq8XbQIM8bWooHLgbDOBC5evxz0HfjrHwNmowfxO0EkUqLOLsJQ4XVolI/ZzVZ6SbNussINR29vlYTjl1eVu+nFXQfMuo9E022ejuJ52E3nqnvHLwRQEUs2gUJqmur6lDb0kpg1K+1axurfiSuFaRKpfvUcdyqv+mCrshLFYb0virqpZ6zKt/bAWI8BnuSXm93tQ+qQrUa6EMQ7gLq81H9FKt5qdfC2CZLOp1mZGSEBQsWSC01QS4ZhkEwGKRUKskNXdG39+zZw7PPPksqlZIkQrlcllp3gUCAYDAote0GBgYoFAoEAgFqa2ulKbbH42Hz5s3s2bOHdDpNdXU1jY2NkrDq7++nXC4TiUTwer10dnYyc+ZMcrkcNTU1rFmzhra2NpLJpCyb8E8oomWXy2WGhoZIJBLSL7iou2GMRZ2vrq6mtbWV3t5eSqUSVVVVpFIp4vH4QaTjsZhTBTFYW1tLIpGQZRGRpUOhkOw7ImiM2+0mm81K7U8xNumLQtHW+mJZX7SIsU9EJhe+MQVBHAwGiUQikhwVWpW6qfbxIJM4ODQYhsHs2bOZO3cur732Gk1NTQwMDNDd3c3g4CCDg4P8x3/8B6+99hqXXnoppVKJE0444aB5WPTdlpYWGczKgYNjBav1up0sp68zJ5KF7M5byep25I6et5UcUEn2V9OxkqkrEUhWsiZYb3zrZbKzYNJlTStlkInIWKtr1d86eaivLfRzYv2h10tPB+ytiaw4Ij1Nq3WQXqZK/UnvA1ZrxEpyoxXszk+VOf7Yeuk+hhCdSAjFduZv+gum/k0lqH4PhTCpmm9OtfKqUF9ssZhQ/avBwc9iKhOq+iB5rBdHRwLr16/n3nvv5fHHH6elpUUeb2pqIp/Pk0gkxmk96gGmnnnmmXHpiYVnpYiW11xzjfw9MjJCa2vrQRMIWA/yVkSNFVRCRhdG7CYHnSyymvD0clgRfpUIOLvf+gRciSizEnJ0VBJ29AnWStgRx/UdVytyzS4d/RqdBJ6IIFM1iMSYIsZ5O7MJnYibDHSXFlYCnSoEqVCfmW5eaVdHQViqf6pGqZ6GnTCl1tdOyD3eodfXamdfP69rJqrHdWJc7Wvqs7J6B9S8s9nsuOjNTU1N+Hw+CoWCND8W2nLCb6CIqCz8PjY0NLBs2TKSySR79uwZF9gkGAwSi8Wor6+nurqaSCQiTW5VLcq+vj76+/tJJpPMmDGDhoYGXC4XyWRSmuXX1NTg8/mkNuTQ0BDJZJJIJIJhvBH8xDAMSaIJv5LpdJrh4WEZECWdTsvgOKVSiXA4TDAYJJ1O09nZSWNjI/Pnz6e6unqc9cyxlsfEOB8Oh6U2tdB6zGazB80PIkK4Pg7l8/lxUc/VjTT1TyUo4Y2xQgTyMQxDRrIOhUI0NTVJIhmQ2mqiv3q93oPGHwdvD6jy6cc+9jGuvPJK/v7v/54lS5bgdrvp7Oxk586d7N69m97eXsLhMCeddJK0WNGDERmGQUdHB/v27Rsnmx1Kv3o7zUEODh+sZCadUJyI/LHiACrBjjjTf9vJX5XKpI/xutKNlZWOmpdV+lZr6YnqVOl6fd1hJePb8Sl2z8uuDdQ09fN27SjKo8tmleR0K1lCnYdFOnZ4M9aZOpmrt8VE5O1knmUlVErjSOFtSzwKiA6hmrHoL5K6gDhWJj0CVh1PN+8Sgr64brpAEI52RLD4Lep+rJ+FKI/6XX0W4vN4Ih1N0+Tqq6/mnnvu4S9/+Yt0Oi6watUqvF4vjzzyCJdeeikAW7dupaOjY1xEy+985zv09vbS0NAAwEMPPUQsFmPJkiWW+QqfVDr0Bf1kdpasJjN9crGanFwuA0Nzu6BPvlaTsVU51O+Tuc6ORBTnrIQE/R3Sy6iaTFnloZOM6uQ8UZmtyqO3r5qWVbuLcVkdd+2er0ruCJJDJRPVsV0vv9o+Vunawa69rAhXq7rrc42d0Cc+BZkq6iS07Kz6qroJVUmAVbXwjofx6VCgt5fuZ1W0lxr1HCr7L9IFVKt3UxcwxV86nZbk0a5du6ipqSEcDmOapvSlmEwmZeR2Yb4cCAQol8syqMwZZ5xBQ0MDHo+Hd7zjHVLDUZCBqva9OjepWnmhUIhAIIDL5aKqqopsNsvo6CjLli1j06ZN8j0zTZNIJEJnZycAmUxGBg/s7+/nhBNOkKRXoVCQviOF/0ix0ZTJZCiVSsTjcYaHh+no6CCbzdLQ0MApp5zCjBkz8Pv9UkNwqvhKFvmLMglflyLwjBhjQ6GQDAYk/CmKd7FYLB6k+aiPj2p+Vgsw9Vl6PB68Xi/5fF5GQ7daWIso6ce6DR0cWxiGwSmnnMI73/lORkdHaWtrw+Vy0draysDAgIzK/uMf/5iVK1fyoQ99iJNOOolyucz8+fPluFkqlTjppJPYsmXLuPnpUMpxLBbBDqY/7ORCK3nc6lrdamQiVCLO1HPqnG9FwtnJfXo+dqSYnrdeZ7XuVso6VvWwIwfFd1VW0tchVvWwWuPo8rdqHaWuX/S1lm7GbQVd5hVpibJbtZdedrt1nLpJbPX89LqrqNRW+jObzNqqUvl1WK3HjiXe9sQjHMyMi2MC+s7esYIVYSEmeHXhPRUIuTcLlTQQUF9MsfCeimSe0NYQ5TseF/VXXXUVd911F7/73e+IRqPSJ2M8HicYDBKPx/nEJz7BNddcQ01NDbFYjKuvvpq1a9eyZs0aAM455xyWLFnCRz7yEW666Sa6u7v56le/ylVXXWVJLlaCutAH651Hu/v0a3Ry7eB7wNQIHZWQUPO3ewf1yUr8rjRZ6N/tyg7jA9qIT6vANXZls4O6s1pp0hXQBQY7kk9/fnYkqXrOqm2tSD/xWyWAJhrL7drZCmo7qIKJVf+xukbvR1ZClToviU0ZVZiyMh+3Isb172q57drueIYuTIpjOlTB32pRor4Hoq/pmqlW5rLiXtEXhLafiLa9b98+5s+fj9/vHzenqPcVCgVJxu3du5f+/n7cbjfLli2TxJfen9V3QSfnhTaeCAJz4YUX8tBDD7F3715qa2tpbW0lkUhIn5GGMRadWZhXDw8PYxgG0WiUQqHAvn375PsmiLVcLkcwGGTOnDkUCgW6u7vp7e2lq6sLj8dDPB4nEokwd+5cWlpaiEajMqiKMB/WCbpjBau5JhAI0NraOm4cEM8/FAqN6xv6hraVrCCejf6sxKeqYatqeQu/kn6/f5yWrMhftOnxIpc4eGvw+/187nOf49Of/jTnnnsue/bsweUaCzCzY8cOuru7KRaL3H///cyaNYtEIsHs2bOZN2+e7Oder5fZs2djGGNat6+99hrPPPMMpmnKgFGRSET6iZw9ezb19fU0NDQcUnAjBw6sMJH8Yidji7FUTcdOJtfJHyvZyYpo08+peVulq8vak53rdB5DHNOJJz1fqzJYpW23flHT1r/DeA1+NT14w2rEiphT6y/W1/rGnM4X6JvuVmnr7SDKqK871LLp8pcOnZRUy6K6TbHK22otVUkur2TNJO6ZzDpYnDva4+7bmnhUO4FVuPXJEALHArpQq75YdgLsVIf6kqm7E1bkybGunz5YC+LJihSYTs9gMrj11lsBOOOMM8Ydv+OOO/jYxz4GwPe//31crrGgUblcjnPPPZcf//jH8lq32829997LlVdeydq1awmHw1xxxRUV/cLaQSdxKpFh6sJfnXjFfbrfDnGP+CyVy5TNN7RxK/nG0icXfRLWJwY1T7WsVuVX09MFAJ3MAsYRo+q1dm2kl9fq92Sg56MLdFZkjAoxYYO1r0S9bOJdVMdBq0neLj/1vPppl5deH7t+qAubYG1GopIUVv1FPW4l5Oh1tDuu5qfm/3YiHsX4LMxSVeFWnIc32lEN5qTOS2r/Uvueep3ah/X+UiqVZDRxn8+HaZrs27ePbDZLKBTC4/FIwlkQg/l8XqYRCAQYHBykq6uL7du3c8kll0hSCQ4W4NV+I/J3uVyS0ANkEJiqqir+/u//np6eHnbu3MnevXvx+/00NDQQjUbp7e0lGo0SCoUYGBigVCrh9/tZtGgRo6Oj1NbW4vV6JREp8u/o6OD111+XAVhqa2tZsGAB9fX10mekMA8X5tqi/MIsXB+vjxWsxkl90aX6/BQ+ZyeTrtovwXpTRl8EiWO5XA6fzycteWC8C4rp4obHwdGBaZosXLiQD3/4w/zsZz/jE5/4BJs2bWL37t2sWrWKZ555hoULF9Ld3c2dd95JTU0Nra2tdHR0cPHFF1NTUwOMjXFbtmzh+eef5+6772bRokU0NTUxNDQk84Ex7eddu3aRTCaZOXMmH/vYxzjjjDMIhUKyTE6/dPBmMJEsI+Zz3ZwZJraYmkze6qe4T5fP7dKzOl+JxNTztbrWLj87OVqcE9yCPv/YrbP0fK3kHav81XWy7hLJrl6q3GUlh1vNw5XWheK8TlDaralUWcqqTSqtcazWhPpv0f5qOpXWh1brG70NrfLU7z9aY+7bmniEg1/KSppKUwW6WrK60BaYSuV9s5gKC4uJoD6LibQXjgdMZvINBALccsst3HLLLbbXtLW18ac//ektl0c1P9UnILW8dkSPuogTpLeuwSjSMQwDt2u8iZ+Vhpvabyfy+SEmCP24mrfVez3RxKMfm0w/VMcUvUzFYnHcdZUmWKt0rYQOfaK2ItdUXzaV8hff9TFD/a2bw9r1B1UIgvGahnp/sCLw1Px0QVJ/Nrp7DzUNu+enklsqsWXV1moZBdGkH7fyMXM8Q7SF1+sdF2lZf1b6u6iSdqoWmhpp2G7jUncfIv4ymYw0tc3n8+RyOZ566ilmzJhBqVSSkZFFQBKXayyKeS6Xkxp0e/bsYc+ePTQ3N9PU1HRQ/1HLICDIJ5UIE31DEKBCw6C5uZlZs2aRSqXYu3cvO3fupKenh1gsRjweZ2RkRGojLly4kP379+P1ejFNk5GREbq7u+WcWFNTw5IlS6ipqaGqqkpq3QlzYLUv+3w+SUAC4zT6pnpffTPlm+geuzlG1+IWfVsfU6d6mzk4NjAMQ45hl112GY888gi7du2ivb2de+65h3POOYfNmzezcOFCGhsb6ezsJJVK0d/fLzeiTzrpJOrq6iiXxwJcffrTn2bVqlXMnj2bmpoaurq6GBwcpFwu09jYSKFQIJvN4vF4ePDBB/nBD37Af//3f7N+/XpOPPFEqQHpwMFkYSd/qucFKhEtVnKA1Tk1Hav7dRlXvV5XPqiUj508b0c8quftSD/1fp0YFcf09YCVDGPXFlbta9UeVvlbyaJ6vdT5z6oM+vV2dVfrZ7WWUWVj3S+zVZ11mVGVF1WNSbv2sYLdmm+i+dzKBZlVux4LueBtTzwKTDehTH3Bjieia7qV32pnwhHyjx6sJkgrUqwSIQPWvl0OEhps8lU1nICDTOz1SbWSYKPmXQlWZKXdPSrpqhPlVrAiCsVxq+9214iy2V1j9ZxEGa2OW90zEXTS71DJWHGd3lYTCbl6WXUtOasyqr/1/gIHP69KfdcqH1UwUgVIYcqra8Yer7Dqd6pgLdpTkJJi118XkK2ik6t56ESk2s7FYlGS+YZhkEwmGRoaYteuXXR1dTEyMsLmzZupqanB4/HQ2NjIrFmz8Pl8hEIhqUHY09NDZ2cn+/fv54ILLrD0Nak+c/GpEuk6WaqaFrlcLjKZDOVyGb/fz4IFC2hrayOdTtPb20sikZC+BHO5HPv37yeTyTBjxgxyuRzRaJSFCxdSV1eHz+eT2oviu7qhAQf7RhakyHRyITOZxcRk07G6324hop6frHsgR05xoCISifD1r3+dq666iuuvv56LLrqIYDBIKBRi586dVFVVEY1GSafT+P1+5syZQ0dHB1u3bsU0TXbv3s3mzZv51re+hWEYNDQ0cPLJJ/NP//RPnHTSSQwODpJIJOju7mZgYAC32815553HpZdeyvPPP8+3v/1tzjzzTD7xiU9IX7YCTl91cCioRKpYWaNNJFvakVjqvfq1dqSjPobbrQGsyEYrCxg76DJAJUJOv0cPOman3KSuaSrVR8/DjuhU1yt6+eHgtY9ebpGW2k5Wz1bPX3+WKsFZ6bnraz29POKclVskK0ym7fQ2tiIYJzNe2r0DRxoO8TjNoA84jp+eow99IBN/zrM4tphoMtYnGhgzK7RyVWAlULhcLlzuN3xq6Yt7XSvParK0I93U+/QyT2ZyqOSnzoqAqHTtZPNUr5+oXhMJOlaT9pt5lybTnhP9tiII9Ul+IuLRjhBQBSJgHHml9xc9DSvyUhX07NprsuV8O41d4jl4PB4KhYLlpgC80b6CmBQQ5KFuilQoFMZp6eq+jcS1xWKR4eFh+vr62LFjB7t27ZJEXm1tLUNDQ3g8Hnp7ezEMg927d/Piiy+yYMECTjzxROnnsLOzkz179tDe3k5NTc24spqmSTAYPMjUW9RLHNO1wdV6G8aYNqKIti1MsquqqojH48BYRGZhLp7NZtmxYwfV1dVUVVURi8WIRqPAmJmxyEtoMqo+aUX7qP1ZH7OmWx99q+V9q4sUBw4OBR6Ph6VLl/LFL36RH/3oR/zzP/8zL730EkNDQyxatIhMJsPIyAgej4eRkRF27dpFKpWiubmZQCDA4sWLede73kVbWxumaVJXV0c+n6elpQWv10tjY6M001Y1J6PRKHPmzOF73/se/8//8//w+c9/nuuuu462trZx44ADB5PBRDLPRHLgRMf1c3abvHYEkfpbJ+7U63Q5U8zvleplRQjq19mds6uLWpZKbXco7W5FVlrVX4dVUEydOLS6XycZ9XZX07GSSaygaq7aXWfFF1jJ3epzsWsDu2dwKFA3nSf77A43HOJxGkJXM54umgDHE8QLa7VQcnBsoZOGVhMyMI4gUAd8gUrEk5quOGY14dsJFmpaViSnVT0mqqfd+cmScXbkw5uZkKwmcLtyWJGVdgKR1aSsCx3qeSuyxa5udgKa1fFKz82qnHZ56KbWVk6jdYFMT1/XGtP7pFoHodWol+9QNMr27dvHtddey3333Uc6nWbevHnccccdnHzyyTLtb3zjG/z0pz8lkUiwbt06br31VubPny/TGBwc5Oqrr+YPf/iD9Af7gx/8gEgkMqkyvFUYxhubB0KzUdX8UwlE1dxX+IYSZsjimDDHV30ZimcpCEoYI+ZGRkbo7e1l27ZtdHZ2UigUaGhoYN26dSQSCUKhEH6/n0KhQFdXF52dnQwPD9Pb20u5XMbr9bJo0SL27dsng8qsW7eOoaEhSe6JKMriuVr5SBX11V1DqP4sTdOUPhdDoRD5fF7ep/ouFJqMsViMxsZGOa76fD7LyMmiXdVAKaK/qoFSxLXqpwMHDo4cDMPg/PPPJ5vN8p3vfIdvfOMbnHDCCXzjG9+gurqagYEBIpEI6XSampoaqqurbYMCqotyAbfbjdvtlvOB2LBJpVI8/fTT3HjjjfzP//wPn/3sZ/nmN7/JSSeddNAGhTMWOKgEXfa0Om9F6qnn9eOV1nc6aWVFNFWS1+1kTLsy6zKhXUBB/bcul1dqJ/Wc1frFSr6380s4Uf2trrdrF/EpxhU7GXsy6wk9b/1e/Vnq6zq79PQ6W52fDOlnRTSqaxuobLlmVW+7vl2pHIcbDvE4zSA6yFSJtP12h2EY4xZgDo4NJjPAW5nwqualKgFkRx6pC2XVea/VhGlFRlbSNlSvEwv3yRBwuiBh1SaThb57Z0WiqmnbkZX6MTV9HZX8xljV2S7dyU6ydsetSM1KaVuVy04osSqXaZrjiMBK9QdrLUhV+LITXnWBShWOBQFk1b5WGBoaYt26dZx55pncd9991NfXs337dqqrq+U1N910Ez/84Q/5xS9+QXt7O1/72tc499xz2bx5M4FAAIDLL7+crq4uHnroIQqFAh//+Mf51Kc+xV133TVhGQ4XXC4XwWAQeCOgitBkFASb8LGYzWYpFApy0az6dxQkpbhfHEun0/T395PJZMhkMiQSCXp7e8nn84TDYYLBICtXriQYDBIMBiWZJ4g6v9/P7NmzmTVrFsVikUwmQzqd5uWXX6a7u5umpiZ6enpoamqiqakJt9tNJBLB4/GM8/GnB5SB8ZsvQltRJ6FFPdX7hdxRKpWkBqSIUlsulykWi+Oc0qvkof7Oqf1NWAuI/jgRYe/AgYMjAyHTXnzxxbz++ut88YtfZHBwkKGhIR5//HEGBgb41Kc+RX19PcFgUG5sDA0NySAzqrsG/d21Wii73W4CgQBnn302mzZt4kMf+hDRaJRrrrmG66+/nnXr1slx0RkLHFihkvw0GaJoImJJvUYnoyqRiXYkmlXZJiq/3SacFdmn56+vGSYTGdmqLodKUtkRkhMRsZXk+cmQdlaEnU7SViJ8rdrYiqxUr7VbY1iVxwoTPYtK/Vhfb+rlqZTHRH30cMNhTBw4OMxwBKOjB0MItgYYjCcY4eCdK7uJSxU4dEJSvcZlWPtT1SdSMcHp/kp0B8VWwo9KOtoRW2r+doKSWg47IvSg9tRIKas8K+3s2ZGDlSZAO0fbdpOh1QRrJyzYwapcdkJDJYLTTuixejZCk0zV3lCFP7vno5I+lfqODtX8Xu8DdvWeCP/yL/9Ca2srd9xxhzzW3t4+Lq2bb76Zr371q1x00UUA/PKXv6SxsZHf/va3XHbZZWzZsoX777+fjRs3Si3JH/3oR5x//vn867/+KzNnzpx0ed4M9D7i8XhIp9PyXent7SWTyZDP5+V5odUo2i6TyUhzZ7U9k8kkqVSK4eFhUqmUbJ94PE44HGbWrFmS0BMbVpFIhFAohGmaMuCCYYxFr04kEpRKJXw+H16vV2pU7t27l4GBAXK5HO985zvx+/1EIhHLKPCqZqYeDV2QA3rbCBJR5KdeK8ottCPVTRg9arOalx4ETJy3++7AgYOjB31O9Hg8fO5zn6O9vZ1vfvObpFIpdu/ezXPPPcfw8DArVqxg7dq1dHZ2snLlSnbs2MHSpUvp7OyUptbRaHTS77JpjmlXz549m/3797N69WpisRjXX389n/70p3nf+94nN64cONBRidgTmEg+1eemyZJa6vWVyCMrMmoiQtQqDyvZuBKRqh5Tr61EmIn5Xg+MYldWu/WVTiIKmURsMFrVx2odYrcOspLJRdlV2VdVcLCqh9WGyEREpd5elcY6tfxvxme8noZdXjqhfChk/NGCQzxOIzjC+NSD80yOLUxMTEOZqMoTa75ZRSJXiUdx/KBdJnO8Oaaejz7RWU2cdkKDmq5VgAgdVg6YLdtHI1St0rXaTatELqqwEr4mur+S8DWZ98nqmkOZtHWyyE6A1MstztkJb5XKqEdLt7vXSnhUTWWtgidZuQoQ96mfenn0fCbT9r///e8599xz+cAHPsBjjz1Gc3Mzn/nMZ/jkJz8JwO7du+nu7ubss8+W98TjcVavXs2GDRu47LLL2LBhA1VVVZJ0BDj77LNxuVw8/fTTvO9975uwHIcTXq8Xv98vtRoDgQD5fJ5kMim1GQFJNAqfh6Jts9ksbrebdDotCcpoNCq1EEX0ZnFO+DYUaYn0BKEpiOlCoSA1DwOBgIzyHAwGSaVS0mxbmFWL4DW6lqHah3WzatFvRB1FGoZhSM1JlfBWNRf0fqePmQI62T0Rwfh2nVMnuwh4u7aPg6ML8d5fcskl7N69m//8z//k3HPP5a9//Stbtmxh8+bNjI6OkkgkmDlzJnv37iUYDFIul+nq6iIcDhMKheSYVywWx7ldsJpzDMOgqqqKSCTC4OAgc+bM4Zvf/Ca///3vefHFF/nsZz8rN6YqpePg7YtKcjNUJusmIqcmIiVVospOTtXv1QkidZPYLh278lfKq5LcrLfJZPO3aksrwkslA/U1jp6eXbtaraesCEhVXlbLZOduplJsBrt1z2QIXfV52rXLZKHXX02/Uju/mbyOBhzi0YEDB9MWZnm8FqHhMsBiLhbnxcIaDt4RrETIuVwuOJC0ncA8rlwWE5Ou8aOabVtNKFYTvxUxONHEYlU/laDQ0zzUyarSbprqh8ROSDrUXbe3OpnqWoZqOdXy6O1RSWC1gl5GoSmm9gGdAFTJaZU0tHOtMVE76G1V6RlPpk137drFrbfeyjXXXMNXvvIVNm7cyGc/+1l8Ph9XXHEF3d3dADQ2No67r7GxUZ7r7u6moaFh3HmPx0NNTY28RkculyOXy8nfIyMjE5Z1MhB1FibKo6OjhEIhAoEA1dXVFAoFstks/f397N+/n3Q6LcsbiUQIBALy+nA4LMnJQqEgNSUzmYwkNEX7F4tFfD4fhUKBQqFAJpPB6/VimuN9JwaDQfx+P8FgkGKxSC6X4/XXX6e3t5etW7dSU1NDY2Mj8XhcEpaqsCv6jdWGhqrFCUifjLq/T1UzQWhriuvVPqO6DbDq26Ick13IHM+YaCy0I3DtzjlwcLigv6Nut5vLLruMO++8k7POOosPfvCDvPzyyzz++OPU1tYya9Ys/vM//5P+/n5yuRzZbJZTTjkF0zQJhUK8+uqrrFmzhg0bNrBmzRo5vulzmpqnx+Ohrq6OcDiMYRhceeWVvPLKK3zlK19h7dq1XHjhhXJjx6r8Dt5+mMy4qMvUE8lxVsSdLk9Ptr9NlKfVhp7VBv5EZVDJS/Va9f7Jlt2KKNXztyIt9TQEGVhps7/SGsEOIh1dmURs9Osyj56HnX/EiYi+SuRopbJOpr0mSkevu116h9I/dVL9SMMhHh04cDBt4XK/MbG43W4MDMoWfhutogfb7QaqmkAH7cxV2LVSCSx9AtCvE/noviIr7Urq5ZzsBGG1mK2kVTkROfBmYVf2iSZxq/OTOVapDlbCWiWBUO8fldK3E07043r/qyQ4W5GfennEvXaEstV3tY/aRUvU8zr55JP57ne/C8CKFSt49dVXue2227jiiismvP/N4sYbb+Sb3/zmEUsf3giQks/nKRQK+Hw+isUiXq+XSCRCc3MzyWSSwcFBEomE1IrMZrMkk0m8Xq8k7mCMNIzFYlIbsVAoSM1KgHA4LLWKQqGQ/C6ibJfLZRkxOpfLMTo6SjqdZmhoiO3btzMyMsLf/d3fEY/HLc2YYYzgNIyDAxCJMopgNIK01HfKVcFcDaRmBb0M+hgL9hrSb2eIPqf6xszlctJfpt/vJxAIWJrEO3BwNNDS0sJll13G7bffzk9+8hO2b99OKpXitddeY2RkRPbH++67jxkzZtDY2IjH4+FPf/oTzc3NlEolkskkzz//PDU1NcyYMUNGu7cj2YUP3vnz5/PCCy9w+umnM2vWLH7zm9/w8Y9/nJUrV3LxxRezbNky6WuyEkni4PhFJTJoomOV5jRdPrOSYfU+92YINKsy6qSXnq9KtFnJdXbvgtXapBKJNZFsrF+rpqtfW4lkUy3FrMqkEqpWhKjdmkY1F7dqOztT6kryvX5eV1xQ62rXRnbtpLeLep1+rxUxakea6rAisSuV6XDCIR4dOHAwbaH7HDNNE7dxsBaZ+FR3yNQ01GvsfESWy+aYRqVyTpy3WvhbEVTiGnGdVWCiyRBmVsKT3b062WV1XIVu6jFRmazy0++bzE6fVV5Wz86O9K1UDqs6VCJEJipPJegCg/hTfTtWiiCtCxKHUh79meltppOSh/qMZ8yYwZIlS8YdW7x4Mf/zP/8DQFNTEwA9PT3MmDFDXtPT08Py5cvlNb29vePSKBaLDA4Oyvt1XHfddVxzzTXy98jICK2trROWdyLo7RAMBqWGn9CODoVC5HI5GVgmHo9L34aCGCwWixSLRUqlErlcjkQiwfDwMIODg1JLMp1O4/f7peZidXU1Ho8Hv98vTa7FRkQ2m5U+IsX7ODo6yujoKB6Ph7lz53LmmWdSXV2NaZqSYNR9MoqI3KrmrCAYVaJR1YxU+4xVH1QFavWc3RiovgPwRlRbtf3VdI9XWL1zIhK6qi2az+cZGRnhN7/5Dblcjkgkwrvf/W5mzZolgwY5cHC0IMaHq6++mkwmw913381FF13E7t272b17N36/n5aWFjZv3kwkEgHgr3/9K7FYjJ07d5LJZHj44Yfp7Oxk48aNnHHGGeRyOebNmyddULjdbnw+30HzkRgnVq1aRalUorGxkSuuuIL3vOc9PPHEE9xyyy0kk0lOOeUULrnkElpbWwmHwzINO/cPDo4fWM0hdnKT3ZymzonqscnKhZXIzInIcL1Mb3ZOnMy1E8mvurwt1kNWdbFba+jtos77qixg5TdSz1/8qVZh6j12BK3Vb6tnb7WeEvmp96lrokprGbs1VaU20iHqajd2Wa3nrNpdhR35aPcMjzQc4tGBAwfTGjr5Z/DGRKI6FrbaCbLT8lL9NUq/JIYByjit7y6pEwZYaxpa7UBZRRW2myhEehMRkHZtZCd4TZRnJej36PUFDhIcxHV6nnYkbaU6TaZcVgKpet6OCNTLoPalShqC6rO3IiLF/VZCj95v7DSdrAQuq7IKMkto1Fm1+2QEJoB169axdevWcce2bdtGW1sbMBZIpampiUceeUQSjSMjIzz99NNceeWVAKxdu5ZEIsFzzz3HqlWrAPjzn/9MuVxm9erVlvn6/X78fv+E5XurMIyxaNKmaZJMJikWi1IjUPh7FObRwty6qqpKPqNCoQCM9fdcLidNtZPJpCQOxe98Pk8qlWJgYED6PhNBXUQapVIJr9dLOBxm8eLFLFmyhIaGBul/UWjIiWA1auRXlWwW5KOA2kcqEeKV+qe+UFIXKIVCQRKx4py41uPx4PP55KZLJRL+eIYgGUUbGYYho5c/+uijlEol/H4/mzdvJpVK8c53vpNFixZJcseBgyMN9R0PhUJcc801XHXVVZx44on88z//M+vXr+cjH/kIa9eu5ZprrqGmpoaenh4CgQAtLS0MDQ3x6quvAnDqqacSjUYZGBgYF5gqEokQiUSYMWPGOPlJL4fb7WbmzJkUi0UikQitra20tLSwZcsWHnjgAa666irK5TJr165l1apVtLS0MHfuXNxuN7FYTG4ovRUCcjKbgQ6mHyZDrFnJTDo5NpGcaZWuCjtZWJ3PK8lqE5HsdpuIOkGnl0WXGd/MO2BFmOn5wMHywGTqZEVY2t2jy9/qMbWclYg8u/zVa1WCdSKyUU/vUDERAVmpvxyLscshHh04cDDtIAbS0dHRccfkhHPgWKn4RrAEkwOkJAd2tUwTDDDLihm1za6Y+HS5XJhjnh4ZN1y7jAPpjEW+RtxvHKzWL9IulUq4DAO38P1XNsfSNKBcKo+lYSi79mUTDHUH0UVZKa8+eapkqyBQdZMA3ZRS99+mCx92k6haBt2sQW3DiYQuldTTJ25xv74jaUW+6RHFrcpzKESviol2N3XhRze/H/f8Jwh0o5dRbRs9grF6vWg3XYgb52vHNDFNMA/8Th3QzKtEQH7hC1/gtNNO47vf/S4f/OAHeeaZZ/jJT37CT37yE1nGz3/+83z7299m/vz5tLe387WvfY2ZM2dy8cUXA2Maku9973v55Cc/yW233UahUGD9+vVcdtllRzyitQ47ATgQCODxeBgZGaGvr49kMolhGITDYeLx+Lh7BLErzKmF9qN4BsFgEK/XS11dndRIzOfz40g4r9c7LiK0MNsWmkBC003vzyrxaJpvBKQRJKSdC4dKiyF9LNGvser/og1EJGxBqm3bto3Ozs5xvjPb29uZNWuW/K366H07QLRbLpeT/UA8p2w2yzPPPEMmk+GMM87A6/XS3NzMzp07SaVSsp9Zaco7cHAk4Xa7qa6u5tprr+Xqq6/mq1/9Kv/wD//A/v37ueeee+Q4OTg4yNatW+nq6pIuK/bv308ul6Onp4dyuczrr78uN528Xq90X5FIJDjhhBMYGRnB5XLR0NCAy+WSG0Dlcpne3l6pTe9yuYjH4/zDP/wDH/jAB9i2bRt//OMf+bd/+zfy+TyGYZDJZGhra2Px4sUsW7aMJUuWsGDBAjn2Wsk6uVyOTCbD8PAwpmnS1dXFyy+/zPbt25k7dy5XXHGFNBV3cGwxEclkd736206Oq3S93RpB3/jTy2F1XCc+7QgjlRSzIggrEXpWdbNrA7Ucqrxtd49deupxXSa3glX97dq0Uh2t2k18Wq0ZxDm7Tf6JCF+9DlbfK5XRjrxUr7Uixyula5e3vg45FnCkFwcOHEw7DAwMAPCO09Yd45I4cHB8YXR0dBy5puKUU07hnnvu4brrruOGG26gvb2dm2++mcsvv1xe8+Uvf5lUKsWnPvUpEokE73jHO7j//vsJBALymjvvvJP169dz1lln4XK5uPTSS/nhD394xOs2GbxB7I9FpI7FYpIkEj4Y0+k05XIZn88nzbOTyaQ0pxYLWkEmlkol6etR3W1XNVFVbUWv1yt/C0FRNYcW5RTEJzBuIX0oRN5ktBcqCd3C76TwU5hMJtm7dy+7d+8mmUwSi8VoaGigrq6OfD7P9u3b2b17NytWrKChoUH6L5zM5sR0g14n0Y7JZFL2BdMc80GcTqd57bXX6O3tZd26dcRiMVKpFC+99BLhcJi6urpJ+WF14OBwQ+2/S5cu5bzzzuOLX/wiv/jFL3jiiSf45S9/SX9/v9TQ7u3tZcOGDaxYsYJ8Ps+rr75Kd3c3o6OjVFdX09/fz8DAAA0NDZx99tn09/eTzWYZHR1leHiYzs5Oqdm4c+dOPB6PfHdefvll1q5dSyqVYvHixbS0tJDNZvH5fCxdupT58+ezZ88eli5dyubNmymXy2zZsoUNGzbw3//93+RyOebMmYPb7aatrY1YLEYkEqG+vp5SqURnZyfbtm1jYGAAn8/HggULCAaDzJw5k8WLF/Nv//ZvRCIRrrjiiuNqrJrOsCKRDuW+yZKRVuffTL5W6VXCZDTT7MhMO1LQqs76Jrj4s4tCXamcej5WPhbV68TxQ5ED1Gv1Oql56cdFncQ5VTnAigCspGCgYqLNWiuC8c2MIZVIRT2fiQjLN9tn3woOiXicPXs2e/bsOej4Zz7zGW655Ray2Sxf/OIXufvuu8nlcpx77rn8+Mc/HhfhsqOjgyuvvJJHH31UDt433nijs4PrwIGDSaOmpgYYG0/sSJK3K4T/u87OTmKx2LEuzpSD0z7WME2T0dHRCbUOL7zwQi688ELb84ZhcMMNN3DDDTfYXlNTU8Ndd931pst6JKELqYIUDIfDkuiLRCJSC0dc7/f7qaqqktp/+k69IBgNw5BmyLqzdEEaqmbTcLDfH918erLC60TajFaw0h4ol8uk02kGBgYYGRmhWCwyPDzM9u3bKZVKzJo1i1WrVhGJRKR2HyCD7RSLRf7617+ybNkyZs2aJaNyT6Y80xGqZujQ0BDZbFY+y2w2y/DwMPv27SOTyXDaaafR2NhIoVDgySefxO12UywWZTCiY00+OuuAtzdcLhef/vSneeWVV/jWt77FTTfdxP79+9m2bRtbt24lFotx0kkn4Xa72bRpE4VCgf7+fk488UQymQwNDQ309fXx1FNPyQBKMKZlWFNTQ39/P6lUio6ODkZHR9m4cSN1dXUMDAyQy+XYsWMHQ0NDdHV1cfHFF7Nz504WLVrErFmzaGhowO1209LSgsfjob6+njlz5hCNRvnYxz7GU089xcjICIFAgGw2S2dnp3w3m5qacLlcrFq1Cq/XK117LF++HK/XSzKZ5KWXXpIBnypp2jk4+rDTSpsMSaMem6wWnZq+btUyWfKsEhlkZ4Wg1vPN9D0r7Uu97VTLLKvy6hqEh5K3rgUp0rQLDlOJ/LMjF/X6qdeKfK20IFXolhhWmpbqc7F6JlbPd7Kai28Gehn18k3m3qMxnh3SLL9x40bpjwbg1Vdf5T3veQ8f+MAHgDEzrD/+8Y/8+te/Jh6Ps379ei655BKefPJJYGzX/4ILLqCpqYmnnnqKrq4uPvrRj+L1emWUTAcOHDiYCGJCiMfjDnlkg1gs5rRNBTjtczDeziT+ZAUuNTiKiskIdoeiiXEoOJTr36pgmclkeP3118lkMtJn2/PPP08gEGDhwoXMmDFDajFGo1FcLpcM1CPIWq/Xy8yZM3nxxRdJJBKsWbMGONglwvGEUqnE4OCg1HY0TZP9+/fz4osvUigUaGpqoqWlherqatxuN9u2bSOVSuHxeGhrayMUCr3pxebhhLMOeHvDMAyqqqr4xje+wRVXXMFPf/pT1q9fzzPPPMMvf/lL+vr6+MEPfsBrr73GVVddhdfrxTRNduzYgdfrZcOGDXi9Xrq6uqivr+eee+4hlUpx+eWXYxgGDz/8MMlkkl27drF582Z6e3uJxWJ0dnZSU1NDd3c327dvZ/78+Xzuc58jEAiwatUqXn/9dRYtWsR73vMeFixYgM/no7q6muHhYWbNmoXH42Hp0qXk83nq6+vx+XwMDQ2RTCbx+/00NTWxZ88eGhoapBuUQqEgA+QMDAzwpS99iXe/+9383d/9nWwLB8cGYi4dGRk56Fgl2GkGimN2hJOdJqFOxqkEmhUxpn+3KoNOmOkbmXb3WpGekzXLVfMVlhh2841qNm23manWVSc4BcR7prpnsiuTSk7a5WOVvp2spl6n+20X3yd6locK/T6rvjDZe62gtp1dUCA9Pb2/CPdlR1IT8pCIx/r6+nG/v/e97zF37lze9a53MTw8zO23385dd93Fu9/9bgDuuOMOFi9ezN/+9jfWrFnDgw8+yObNm3n44YdpbGxk+fLlfOtb3+Laa6/l+uuvx+fzHb6aOXDgwIEDBw4cHAVMJBgebtLoaC56hW/B/v5+du7cSTQaxe1289e//pVEIsGSJUuYN2+e9EXp8/lktG+/34/X65Xaeq2trezevZs5c+Zw8skn8+STTxKLxVi0aBF+v/+48/coFrNDQ0OSSCwWi+zZs4dHH32UoaEh1q5dyzvf+U5cLhevv/46DQ0N7Nq1i+XLl/O3v/2NtrY2qWV1rDUenXXA2xti3Jk/fz7/8R//wSc+8QkikQjr16+nsbGR22+/nbvvvps//OEPDA4OUl1dTbFYJBgM8s53vpOzzz6bn//85+zcuZNEIsHcuXMJBAIsX76cvr4+nnzySU455RT6+vpIp9OsWrWKjo4OmpqaeOGFF4jH4zIAWH9/PzNmzODZZ59l7969PPPMMzz55JPjtGvb2toYGBhgzpw5UnN47dq1lMtl9u3bRzAYZMWKFZLg9Hg8jI6Osm/fPvbt20d/fz8dHR08+OCDXHDBBXz5y18eFznbwbGBIEhmzZp1jEviwMHxh0oul94q3rRdQz6f57/+67+45pprMAyD5557jkKhwNlnny2vEervGzZsYM2aNWzYsIETTzxx3KRw7rnncuWVV7Jp0yZWrFjx1mrjwIEDBw4cOHBwlGBlgjPRdZWusfLTY/X7SEI3hxJBI7Zt20YwGOS1115j586dzJ49m+XLl1NfXy+jfwuCUfhlE74xhQZBPp8nEokwNDREXV0dK1eu5LHHHqO+vp6GhgapuaBqd0wnzSL9GZVKJUZGRhgdHcXr9VIsFqXZZjKZJBwOM3fuXBlgKBqN8thjjzFv3jxJsrS2tgIcsv/OI42juQ7I5XLSZB/Gazo5ODrQtbAWLVrE97//fT7+8Y/z5JNPcuONN3L99dfzn//5n7S1tdHd3c3cuXPJZDLEYjF6enrYv38/HR0d5HI5qQU9PDzMDTfcwJw5cyiVSgwNDbFkyRL6+vpwu92Ew2HWrVvHwoULOeWUU4hGoyxYsIDu7m5M0+TVV1+ltraWVCrF7Nmzef3118lms+zcuZOmpiaGh4cpl8t0dXVRVVXFLbfcwujoKIsWLZLalRs3bmT58uW0tLTQ3d3NkiVL8Pv9zJkzh5/97Gf88z//M+eee+44M2sHxw4zZ85k8+bNLFmyZMq7zZlO7n2csh4ZTJeyTtbl0lvBmyYef/vb35JIJPjYxz4GQHd3Nz6fj6qqqnHXNTY20t3dLa9RhQ1xXpyzgyNwOHDgQIXf7+cb3/iG9MPj4A04bVMZTvs4eLOYjM+mShAmPnYOz/U0DsUX45GAaZqMjIzw+uuv09PTQzqdloTZypUraWlpwe/3S5Mmr9crzYiFzCYCp8CYmXomkyGdThMOhwmHw8ycOZO2tjb+/Oc/8/73v1/6+TseFvemaZJOp8lkMhiGQalUkpGrPR4PjY2N1NXV0dzcLH1+dnZ2ksvlqK2t5bXXXqO9vV2arFv5ojqWOJrrgBtvvJFvfvObh6/wDt4yXC4Xp5xyCv/8z//MP/7jP/KhD32If/zHf+QjH/kI2WyWe+65B8MwOP300xkdHeW5557j7rvvlgR6KBSiWCwC8NJLL/H666/T3NxMb28v7e3tlEolLrnkEhYuXMjevXtJpVLEYjFefvllCoUCxWKRnp4ezjnnHBYuXEgul+OFF17gwgsvpLm5mT179hAOh/nDH/7A7t27ueaaa+jq6uLxxx8nmUxy1lln8eSTT7Jv3z4aGhp4xzvewaZNm3j00Uf5zW9+w6pVq+js7ORzn/sc559/vqXZpoNjA5fLRXNzMzB93OZMl3KCU9YjhelQ1iPtculNE4+3334755133hFlRQUcgcOBAwcq/H4/119//bEuxpSE0zaV4bSPg2OFcrlMf3+/jIgdCATw+/1TdkFbKBQYHR1lYGCATZs2kclk8Hq9LF++nPb2dqqqqjBNE6/XSywWkxqOAwMDpFIpBgYGcLvdRCIRqQ0ZCARIp9NSEzAQCLB48WLuvfdeXnnlFU4++eQpRa69GQhiOZPJkMvlpL+sQqHArl276Ovr46yzziIQCEifji6Xi4GBAalt0NfXx+uvv875558/ZYOuHM11wHXXXcc111wjfwsNEgfHBqpW8mWXXUZ1dTXf/OY3+cd//Ed+/OMf8973vpf3v//91NXVkU6nef7555k1a5YMKjM6Oip9xAKccsopFItFGYSmpaWFJUuWMGvWLG677TYSiQSxWIz/+Z//4Z3vfCf5fJ7Ozk5WrlzJAw88QFNTE+l0mv7+fgDa29vZsGEDjY2N7N69m/nz5/Pggw+SSqVob29ndHSUJ554Ar/fz4c+9CG2bt3KZz7zGVwuF5/97Gcl6ej3+3nXu941Zd9BBw4cOJhOeFMj6Z49e3j44Yf5zW9+I481NTWRz+dJJBLjdjt7enpoamqS1zzzzDPj0urp6ZHn7OAIHA4cOHDgwIGD6QZVy7G/v5++vj6y2SxDQ0M0NDRQU1NDLBaTBKTb7bZ12H6kCTnVTLhYLJJKpRgdHWX37t10dXUxc+ZM5s+fz8KFC4nH4wQCAantWC6XpdlkLpcjn8/LxXo+n8fr9cpo3S6Xi/7+foLBILlcjkgkwsqVK3n66adZuHAhsVjM1uH8dIAwRc1ms7jdbqnNODo6yqZNm1iyZAktLS2YpkkgEMA0TVKpFPv372fhwoXs2bOH5557jtbWViKRiDRVn0o42usAv9/vaKlPIajvosfj4fzzz+fkk0/mN7/5Df/3//5ffvjDH3L33Xfz0Y9+lP/1v/4X73//+8nlcrS2tspo1n6/n40bNxIIBDjhhBNwuVzMmDGDUCjEH/7wB371q18xNDTEBz7wAU4++WRCoRB1dXW89NJL/P/+f/8/TjjhBJqbm0kmk+zcuZNCocCiRYvYv38/GzduZNmyZZx11ll4vV7a2tp4+eWX6e/v55xzziGTyTA8PEx9fT3RaJRiscj27dsJBoO0trbicrk44YQTZF2ny9jjwIEDB1MZb4p4vOOOO2hoaOCCCy6Qx1atWoXX6+WRRx7h0ksvBWDr1q10dHSwdu1aANauXct3vvMdent7aWhoAOChhx4iFouxZMkS2/wcgcOBAwcOHDhwMN0gSMeRkREGBwd57rnn2L9/P6FQiM7OTmbOnElTU5MMwhKLxYhEIvh8voN8HR7pcqrfU6kUmUyGrq4uUqkU8+bNY8mSJYTDYaqrqwkGg5RKJYLBoKxjd3c3fr+fbDZLVVUVkUiEXC4nr8lms4RCIemPrb6+nnw+TyaTobGxkZkzZ/L888/zzne+U/qIFLDyeTmVkclkxpGnpVKJzs5OisUiJ5xwAoFAgGw2i8fjoVQqMTw8TGNjI263m66uLtLptPQzZxiGNE+dKvU+2usAB1MXwu/ojBkzuPLKK3nf+97Hn//8Z+666y7uuOMOfvGLX3DJJZdw6qmn0traSltbG+FwmEgkwtlnn43f7yeVStHT08NLL73EzTffzEsvvcSpp57K1VdfzWmnnSbfiw984APMnz+fn//855RKJVpbWznzzDM5//zzyWazuFwulixZwpIlS8ZFGhYm3yLaazgcpq6uDhgb79xuN4sWLRoXTTebzeLz+RxtxymK6eI2Z7qUE5yyHilMp7IeaRjmIXorL5fLtLe38+EPf5jvfe97485deeWV/OlPf+LnP/85sViMq6++GoCnnnoKGPP1s3z5cmbOnMlNN91Ed3c3H/nIR/jf//t/893vfnfSZRgZGSEejzM8PDzlbeUdOJgucN4rBw4cTAdMp7FKBGfp6uri/vvvp6urSxJ4+Xyejo4OUqkUS5cuZe7cuYRCIUqlEqFQiHg8TlVVlTTFPpKkkxAFhV/CkZERhoeH+eMf/0gkEmHOnDk0NjYSDAaZMWOGjFgttPEGBgakaXE0GqWqqopsNku5XCYYDOL1ekmn06RSKUzTpLOzkxUrVpDNZgkEAqRSKTo6OnjxxRd53/veRzwel9qfet2nsgaSCJjR19cniUdBLD7xxBPEYjHOPvtsvF4vmUyGYrEoNUSDwSBdXV3ce++9nHbaaaxdu5ZAIAC8QZ6ICOFHov6Tfa+cdYADK4gxRGjn5nI59u7dyz333MMTTzwhf6fTaYLBIM3NzcybNw+/38/OnTvZtWsXXV1deL1eRkdHmT9/PsuXL2fdunUsWbKE6upqcrkc8+bNo1Qqce+999Ld3c3//M//sHjxYl599VXi8Tjf+c53WLx4sQxqEwwGZRkLhQKZTIZAIIDX6x2nje5yudi0aRM+n4/f//73PP/883zpS1/i7LPPnlJBnY4knPfKgQMHRxKHvI3z8MMP09HRwT/8wz8cdO773/8+LpeLSy+9lFwux7nnnsuPf/xjed7tdnPvvfdy5ZVXsnbtWsLhMFdccQU33HDDW6uFAwcOHDhw4MDBFIBK4o2OjrJ//342bNjAjh07eMc73kEsFqO1tRWfz8fs2bMZGRlh165d7N+/n8WLF9PQ0EAmkyGVSlEoFKipqZEmygJHgngSpFk2m6VYLPLCCy+QSqVobW2VBGhNTQ35fF5qZArtyHQ6jcvlwufz4fP5yOfz0oy4VCrh8/kIhUL09/fj9/spFouYpinrFIlEiEQizJo1i71790qfkarJuV1k72NNQuraoslkUrahy+WSGq/C1FT4eyyVSuRyOUqlEl6vl6GhIfr6+hgeHmbevHl4vV7gDY0yYcJ9rH2COusAB1YQ76for8FgkPnz5/OlL32Ja665RhJ8f/zjH/nRj37Ek08+SSgUIplMyo0GQQbOmDGD4eFhXn75ZdxuN319faxevZr29nY6OztpamqiubmZ973vfZxzzjls2bKF97///fzud7/jYx/7GDU1NSQSCZYsWcLatWsxDIOamhpeeuklnnjiCdra2vjwhz9MbW0tL7zwAv/xH/9BJBJh165dlMtlVq9ezeLFi3n00UfHRWl34MCBAwdvHoes8TgV4OzIOHBw+DGd3qtbbrmF//N//g/d3d2cdNJJ/OhHP+LUU0891sU6onj88cf5P//n//Dcc8/R1dXFPffcw8UXXyzPm6bJN77xDX7605+SSCRYt24dt956K/Pnz5fXDA4OcvXVV/OHP/xBLg5/8IMfEIlEjkGNDg9uvPFGfvOb3/Daa68RDAY57bTT+Jd/+RcWLlwor8lms3zxi1/k7rvvHrcYVqOrdnR0cOWVV/Loo48SiUS44ooruPHGGx0zqymIqT5WCcIsk8mwf/9+tm3bxqOPPso555xDKBTC5/PR0NBAMBikWCySTCYZHBwkmUzyxBNPsHDhQubPn08wGCQQCFAul6XvsyNlfi1MC0dHRymVSvT09PD73/+e1tZWWlpaiMVihEIh3G43jY2NhEIhYEyDrbe3VxKQIqpxIBCQ5tLZbFaaDPf09Mh8Fi5cSKFQIBAIYBgGnZ2dpFIpent7OfPMM2VQFtVkWdTb5XJNmQjYqhhdKBTYv38/pVKJfD4vz23fvp0tW7Zw+umn09raKqPywhuRv1OpFHv27OGll17ii1/8IqFQSNZRaDmKeh9LjcepgOlUVgdjUP3ddnV18V//9V/ceeedrFy5kssvv5zf/e53dHR0kMlk2L59OyMjI4RCIU4++WR27tzJ0qVLecc73oHP56Ouro7Zs2fL92LmzJl0dHSwePFitmzZwrZt26iqqiIcDvPiiy/S09PDo48+SmtrKxdddBGvvvoqL7/8Mi+++CL/63/9L1KpFFu2bOHaa6+VgW9uuukmvva1r3H66ac7Go8OHDhwcBjgrKgcOHAwrfCrX/2Ka665httuu43Vq1dz8803c+6557J161bpM+p4RCqV4qSTTuIf/uEfuOSSSw46f9NNN/HDH/6QX/ziF7S3t/O1r32Nc889l82bN0tzvcsvv5yuri4eeughCoUCH//4x/nUpz7FXXfddbSrc9jw2GOPcdVVV8momF/5ylc455xz2Lx5M+FwGIAvfOEL/PGPf+TXv/418Xic9evXc8kll/Dkk08CYwv/Cy64gKamJp566im6urr46Ec/itfrPSTzPwcOBLLZLL29vXR2dvLwww+zcOFCqS04OjpKPp+nvb0dr9eL3++Xvg+ffvpptm/fTjqdZunSpVIrLpPJ0NDQQF1d3REhw4WJtSD6+vv7MQyDWCxGOp0mk8kQDoepr6/H5XJRKBSk5t7Q0BB+v59CoUBjY6MsnxoQpVwuS+3HVCol/T+KBf3o6CjDw8Ps3LmTE088UQZnSSaTmKZJMBjE4/EQCATG+To81qSjjmw2i9frlQRhoVAgm82yd+9empub8fv9jIyMyGsMw6BQKJBIJDBNk8HBQXw+H8VicZwGmSAdHTiY7hBE4Re/+EUuuugifvSjH/H1r3+dU089lfPOO4+uri4aGxt56aWX6OjoYNeuXfT397NhwwZyuRwtLS34/X62bt1KVVUVxWKRFStW0NDQQDKZpLa2lvnz5zM0NMSKFSuIx+PMmjWLa665hqGhIZqamqirq+PLX/4yr7/+OvPmzSOVSjE0NESpVOLll1/mhhtu4Oqrr2bdunVTboxx4MCBg+kKR+PRgQMHwPR5r1avXs0pp5zCv//7vwNjC9rW1lauvvpq/umf/ukYl+7owDCMcRqPpmlKQf4f//EfAWSwgp///OdcdtllbNmyhSVLlrBx40ZOPvlkAO6//37OP/989u7dy8yZM49VdQ4r+vr6aGho4LHHHuP000+XkSvvuusu3v/+9wPw2muvsXjxYjZs2MCaNWu47777uPDCC9m/f7/Ugrztttu49tpr6evrw+fzHcsqOdAwFccqVZTK5XLs3r2bgYEB/vrXvzI4OMiJJ55Ia2srpVKJYrFIQ0MDjY2NUlOwVCrh9/u56667qKur45VXXmHlypW0trZSXV0tiap4PE5ra+thMbdVyyz8EGYyGdLpNI899himaUqyrLu7m1KpxIknnigjMmezWTKZjHzncrkcTU1NeL1eqZ2YyWQwTROfz0e5XKanpwfTNIlGo7hcLiKRCB6PR5oZj46O0tLSwp49e+jp6ZERcCORCAsWLGDWrFlSm1JoOx1rYkC0Y6lUYmBggEKhIElC0zQZHh7mnnvuYfXq1cydO5eBgQGKxSKFQgG/38++ffvweDyUy2X27t1LNpvlgx/8ILFYTAaVEXVVI58fbkzF98oO06msDuxRLpcpFAps27aNn/70p/zlL3/h5JNPZvXq1QQCAZ588kmeeuopotEor7zyCn6/n1NPPZXu7m6qqqpIJpP4/X7a2tqYPXs2hmHQ3t7O7Nmz2bFjB36/nyVLlpBKpaiurmbXrl00NDSwefNmVqxYQTqdZnh4mFwux44d1wd02AAAYWdJREFUO3j22Wfx+/1ce+21nHjiiW87st95rxw4cHAk8fYaUR04cDCtkc/nee6558b53HG5XJx99tls2LDhGJbs2GL37t10d3ePa5d4PM7q1atlu2zYsIGqqipJOgLSafrTTz991Mt8pDA8PAxATU0NAM899xyFQmFc2yxatIhZs2aNa5sTTzxxnOn1ueeey8jICJs2bTqKpXcw3SFMrPv7+3nhhRfo6OjghBNOYHR0lEQiQVdXl9RiGxgYYGRkhGQyKc2SzzjjDPL5PHPnziWbzbJlyxbpD1EQbkcCpVJJaujt37+fgYEBqqurqaurw+VyEQqFCAaDJBIJkskkhmEQCASIxWJ0dHTw2muvjdNqLJVK0kQaxgiGkZERSTiGw2Hpv1FEthbE49NPP02hUKC9vV1GwDVNk3379rFnzx6Zh6pReawhCORCoYDb7cbv948LvmMYhjT9rKurIxwOSw3OcDhMLBajvr6euro62Y7iuZfL5XFt6sDB8QLTNPF4PCxdupR//dd/5f/7//4/5s6dyy9+8Qtuv/12otEoV199Nddeey3XXnst7373u+nr6yOVSpFIJOjp6eG1117jT3/6E08//TTPPPMMd911FzfffDN33nknd955Jz/72c/44Q9/yD333MNPf/pTfv/73/PAAw/wm9/8Rmog/+pXv+LXv/41Z555Jv/+7//OkiVLjvmGhgN73HLLLcyePZtAIMDq1at55plnjnoZHn/8cf7u7/6OmTNnYhgGv/3tb8edN02Tr3/968yYMYNgMMjZZ5/N9u3bx10zODjI5ZdfTiwWo6qqik984hMkk8nDWs4bb7yRU045hWg0SkNDAxdffDFbt24dd002m+Wqq66itraWSCTCpZdeSk9Pz7hrOjo6uOCCCwiFQjQ0NPClL31Jugs5XLj11ltZtmwZsViMWCzG2rVrue+++6ZcOXV873vfwzAMPv/5z0/5sh5rTGtT6zFfIWCYYBplMDSBzLSYNAwDJTbigT8H0x7mgX+GOfZpKs/WMJW+YDiPfBqjv7+fUqk0jiACaGxs5LXXXjtGpTr26O7uBrBsF3Guu7v7IFN0j8dDTU2NvGa6o1wu8/nPf55169ZxwgknAGP1Fn7nVOhtY9V24pwDB5OBIMSGh4fp7u5m586dUrMxl8uxZ88e4vE4xWKR/fv3A2M+AQ3DoLa2lkAggM/nY82aNXJhvWvXLvr6+liwYIEMLHIk/DuWSiVM0yQSiZDNZqmtrSUYDOJ2u0kkEpI4nDt3riTEcrkcGzZsIB6Ps2PHDurq6qQJttDgFKRbNpuV/t0CgQDFYlFqEqdSKXp6eujp6WHJkiXMnDmToaEhEokEbrebeDwu08xms3R1dUnNSjX4zLGEIAeFv0rhn9LtdpNKpfD7/dTV1REIBHC73TJ6ucfjkURkJpNh7ty5bN68WfqAVDUeYbyWqgMH0x2qRqHX62XhwoX80z/9E5/+9Kd5/vnn+ctf/sIDDzxAuVymtraWNWvWsHr1ajwejwy41dHRwY4dO+jv78fn81EoFNi+fTunnHIKkUiE7u5u2traaGlpkWOLYRjs2LGDb3/728ybN4/LLruMU089lZkzZx7z4E0OKmOquFuaLu6PppM7opaWFr73ve8xf/58TNPkF7/4BRdddBEvvPACS5cunTLlVLFx40b+7//9vyxbtmzc8alY1qmA6U08ApjlA98MC6LRQhgVBJUkoEzr6xxMU5TBNAH3G7/lM1bIRwcOHBx3uOqqq3j11Vd54oknjnVRHLxNMTo6Snd3N5s3byabzbJ06VKCwSCzZs1i+/btcqEtCKqRkRH27dtHb28vsViMUqlEf38/xWKRffv2kUgkaG9vx+fzEQwGj5jZvyC00uk0fX19BINBotEoHR0dPPPMM1Ij4+mnn5YbFjNmzJC+LHt6eujv75fkmtCeFERpLpfD5/MxOjpKfX09yWSSaDRKPp+np6eHF154QZqV5/N5stmsNP1uaGiQwXVisZgkNNUIuscawiejz+eTBKvQ+Ewmk4TDYRnhGiAUClFdXY3L5WJ0dBSA5uZmMpkMhmFIP5jiemFSPlXq68DB4YC+aSDe6ZqaGs4++2zOOussCoUCw8PDvPbaa2zZsoVNmzaxefNmQqEQLS0t1NbWcuqpp5LP54nFYni9Xnp6eqiqqmLbtm309fXR39/PSy+9RCaTYfny5axevZqLLrqIRYsWSS3sSuVyMHXwb//2b3zyk5/k4x//ODDmFuePf/wjP/vZz46qu6XzzjuP8847z/KcaZrcfPPNfPWrX+Wiiy4C4Je//CWNjY389re/le6P7r///nHuj370ox9x/vnn86//+q+Hzf3R/fffP+73z3/+cxoaGnjuueekO6Lbb7+du+66i3e/+90A3HHHHSxevJi//e1vrFmzhgcffJDNmzfz8MMP09jYyPLly/nWt77Ftddey/XXX3/Y5JK/+7u/G/f7O9/5Drfeeit/+9vfaGlpmTLlFEgmk1x++eX89Kc/5dvf/rY8PpXadKphWhOPUMY0iowRSS4OsIoVMEY+mYJ4Mss4JNRxBtPFG8/0wPMtuw5oQpYB9wFi0oGO6aBJUVdXh9vtPkhdvaenh6ampmNUqmMPUfeenh5mzJghj/f09LB8+XJ5TW9v77j7isUig4ODx0XbrV+/nnvvvZfHH3+clpYWebypqYl8Pk8ikRin9aj2maampoNMdUQfOx7axsHRQalUoq+vj/3799Pf309LSwvxeJxMJoPX62XmzJk0NzeTzWZlxOKXXnpJRnpOp9PSP+Lw8DCFQoGqqipOOOEEqqurZWTow7koViPNFotF+vr6SCaT1NXVEYlEePbZZymXywQCAbq7uwkEAkQiEfr6+ti9eze1tbVUV1fz6quv8vzzz9PW1kY8Hpdafy6Xi1KpBIyNN0LbUSz0+/v7ef755ymVSsyaNQuPx8PevXvp7OykpqaGZcuWEQ6HiUQiknibKr4dAUkwCu1GAVFnl8vF4OCg9JdWKpWk+bX4dLvd0qQ9EonQ0NBAKpWiXC5TLBbxer0yLwcO3g5Qg0f5/X4aGhpoaGjg9NNPl4GnhoeHpan1zp07SSaTDA4O4vF4pEbxSSedxJlnnklzczMzZ84kFosRj8cdAn+aQrhbuu666+SxqehuaSL3R5dddtmE7o/e9773HZGyHao7ojVr1ti6I7ryyivZtGkTK1asOOzlLJVK/PrXvyaVSrF27dopWc6rrrqKCy64gLPPPnsc8TgVyzpVMK2Jx2Qqg+HxAUUwihhGSbvigBakYnHrMj2YZQ+G4QKjdEAB0pDRAwFpuqOb8KjHZQ4W5+1+28EuP/0aeMMsQSwUKt0njqnn9bLrdZ5MXeyOTyQUW7XdZPOfqPxv3AdjJtclDNyAiUkRl+EGPAddb5WGXX52UDUS7OqintfvFQuoyS4qKuWnpmOVnzB7s0orlUpNKv9jCZ/Px6pVq3jkkUdkYJVyucwjjzzC+vXrj23hjiHa29tpamrikUcekUTjyMgITz/9NFdeeSUAa9euJZFI8Nxzz7Fq1SoA/vznP1Mul1m9evWxKvpbhmmaXH311dxzzz385S9/ob29fdz5VatW4fV6eeSRR7j00ksB2Lp1Kx0dHaxduxYYa5vvfOc79Pb2SlOdhx56iFgsxpIlS45uhRxMWySTSfr7+3nllVeYO3cu5XIZn88no0AL/36CSMpms9TV1XHqqafS2NiI1+slkUgwMjLCgw8+iGmarFq1ahxZFwwGD6t5sWEYlMtlcrmcNBH3er1UVVWRz+cZHByU48v+/fuJx+PS9Blg7969dHd3U11dTaFQkIFyhKwiojYLv0Uul4tsNks4HGZoaIgXXniBQqEgfTpt2rSJnp4eFi5cSHt7u6yzMKsGJMk3VchHQTyqc7n4XigU6O/vp7a2dly0b4/Hg9frlSbnqkZjNBrl9ddfZ/bs2TIYkdvtlvP3kfLz6cDBscZk3mfhqiAUCtHU1MSyZcukpqQ6RlilJyLEO5iemC7ulqaq+6Pp4I7olVdeYe3atWSzWSKRCPfccw9LlizhxRdfnFLlvPvuu3n++efZuHHjQeemWptOJUxr6WX7tl34wiZ9qacpuPZiGrrZ9Hji0V2KUu06kerYbDKpIqGwj9Fkklg0Lk1hhPmPcIIujqdSKaLRKKOjo+POj46OEovF5HG782r64XCYdDpNKBQinU7L9IPBINlslmAwSCaTwe/3k8/n8fv95HI5vF4vpVIJr9dLoVDA4/FIAV/VIIDxRKVO7okddj2tfD5PIBAgl8vJPAOBANlsFp/PRyaTIRKJkEqlxtUlk8kQCoVIJpNEIpGD2kwcV9tIpKP+HhkZkW0l0hH3iTYT6YZCIfk5pj0SJJ1OEwyGSaUHcXvzFAtlTGOEfT2v0tq8GLfZjM8TIV8o4PV4KBYLeL0+isXxGggqAWhHiJbLZblo8Hq949rM5/PJ5zb2PAOkUmnluYdJp1OEIxFSSluJNhRtFovFGB4elr/VttJ/q/1QbTv1WUWj0XFtp+abTqenjTbFNddcwxVXXMHJJ5/Mqaeeys0330wqlZJmF8crkskkO3bskL93797Niy++SE1NDbNmzeLzn/883/72t5k/f770JzNz5kxJ0C5evJj3vve9fPKTn+S2226jUCiwfv16Lrvssmkd0fqqq67irrvu4ne/+x3RaFRO2PF4nGAwSDwe5xOf+ATXXHMNNTU1xGIxrr76atauXcuaNWsAOOecc1iyZAkf+chHuOmmm+ju7uarX/0qV111FX6//1hWz8EUhjpmFotFEokEvb29eDweGhoa6OrqIhKJ4Ha7yefz1NfXy6jE+XxeRlOtqqrC7/dLQq1YLJLL5WhoaGDFihWYpkmhUJDzvSAuDxcKhQK5XI5EIiGD3IiI24lEAtM02bRpEx6Ph9raWmKxGK2trTQ3NzN79mz279/P73//ewC2b99OPB4nGo3KuoyMjABjG0elUolgMEhfXx/btm2jVCoxc+ZMlixZwtatW9m1axfr1q1j5syZcl7V30FB0h1LAkE8+3K5LAO+qNGtBQGZz+dJpVIsXrxYktDiOYu2FteK7y0tLbz44osUCoVxhOuhbFA6cHA8Qyf41eMOHDiwxnRwR7Rw4UJefPFFhoeH+e///m+uuOIKHnvssWNdrHHo7Ozkc5/7HA899JD01+lgcpjWxONJy5YSjOV4Yc9j9Oa3UCaPBwOXGaREEcwiZcNNyXBhmOA3q1k662JqggspFz3gKgMuXJq2mPpppSGmRim0EgKFYCnO67/tPnXo+Vtpqk0GlbT3DMM4SDvBrmxWWhYT1cWqLe3aRK/rROmNPy+ucVM2MwwmdvHanseIxExaqwyGEy9x8tIlREOzyGYHyBdGCAdqCPobwAwDYhfUuo2t2lDkb98fDKCMYZQpm2DgwTDLlAwDE3C5TDCLGKYX0zRwuYuYZeE2YAwqGapqPAjyWF3w2LWdVVuKa9X0xeJwquNDH/oQfX19fP3rX6e7u5vly5dz//33H7RzdLzh2Wef5cwzz5S/r7nmGgCuuOIKfv7zn/PlL3+ZVCrFpz71KRKJBO94xzu4//77x02Kd955J+vXr+ess87C5XJx6aWX8sMf/vCo1+Vw4tZbbwXgjDPOGHf8jjvu4GMf+xgA3//+92V9c7kc5557Lj/+8Y/ltW63m3vvvZcrr7yStWvXEg6HueKKK7jhhhuOVjUcTHOkUin6+/vZtm0bJ510EqZpkk6n8fv9eL1euUFXLpdJJBJ4vV62bt1KbW2t1HjzeDy43W4KhQLBYJCLL76YxsZGMpmM1EoUviEPJ/L5PMViUZJkXq9XalbW19czMDBAJBKhvr4ev99PNBolFAqRSCTI5XIsWLCASy65hD/96U9kMhl2797NCSecIE0iR0dHJdno8/mIxWIUCgVqampoa2ujurqaTZs24Xa7qampYf/+/RSLRfx+P+FwGK/XK6NAizlrqphKFovFcfOwkKfEhnAymcQ0Taqrq2X5vV6vvCeXy42TvwxjLNBQIpEgn89L03LhQ3Kq1NuBg2MNh2R8+2G6uFuaiu6Ppos7Ip/Px7x584Axi6WNGzfygx/8gA996ENTppzPPfccvb29rFy5Uh4rlUo8/vjj/Pu//zsPPPDAlCnrVMO0Jh7dbnC7XGSyKdL5EUzThbcYx23G8PrCYJbJFYcouBO4jBwlE8pGGUzY+MxGTFeJ9vZ5xGNRKSiqvo6KxSJDQ0M0NDRIzUChKbh3715mz57N9u3bqaqqoqamRppVCefgHo8Hv98/jmSrBKtr7ITMw21qpZtsW+0kvtX8JxKY34oGg0kZ40A0axcBGupm4w+b7N67hXSyh2xpF8+89n1qY4sxiwFm1M2lr79I6wwv0XD4APms+oc8hLwPEKl62U0TDGOsbG7TwDQNzHKBodQOcqUkLsMg7IsTCczGZQQwcGGarrG4R0JL90BkTEE2ir4k8rOKvifOTwZqm0+nBc369evfdqbVZ5xxRsUNB8MwuOGGGyqSZTU1NYc1Wt5UwGQ2YQKBALfccgu33HKL7TVtbW386U9/OpxFc/A2QalUore3l46ODqktODw8TF1dndRkNAyDYrFIJpMhk8ngcrnYs2cPJ5xwgiT9hG8yr9fLBRdcwIwZM8Zt1Hm93iOigVsqlcjn87jdbvr6+mhtbcXtdhMMBlm1apU0wRZzkNikikQiVFdXk81mmTNnDh/60IcolUqk02kSiQR+v5/u7m727dsnAzy0tbWxbNkyotEoc+bMYXh4mCeffJI5c+ZQX19PW1sbbreb/v5+EokEoVCIwcFBampqaGlpkZFspwLpICJZwxvjkP7Z29srF8ulUkmSzGqfEDKnmI9FkKFkMilJSse82oEDB293TBd3S1PJ/dF0d0ckNl2nUjnPOussXnnllXHHPv7xj7No0SKuvfZaWltbp0xZpxqmuSQjgsSYmOUiRqmK+shKZtYtJpvz4Xa5Kbm72bH3UfJmFyZFDHNMN65cLjN/4XyeevJv1FRXST87QkNBmDYXCgU6OjpwuVzkcjmpiTA0NERrayv79+/n9ddfJxAIEAgEyGQylEolyuUysViMdevWjZV0EkLyoQjSh1PottKonCj9Q/VLeCjleHP3KWU3XUCYWHAuJ86bS6l0LpnCPrr6n6M/+Sp1VQsoFg3cLi8ul6Hc/1bytzp+4FMyiSbpQgcv7/g5pjeDWXIRdrdx8uKPMziUolQq4HL5cLvBNMcGWrHoLJVKhEIhaW7X3Nx8yOWZ6NqpsJBz4MCBg+kE0zTJZrMkk0m2bNnC0qVLCQQCDA4OSq30wcFB7rvvPhYuXMiJJ55IsViUxBq8EXRFaLbNmTMHv98vtf78fr800T7ckQ7L5bL0yyhIrubmZpnnsmXLeOaZZ/jABz5AKpXi9ddfZ2RkhEKhgGEY7N27l9raWurr62lsbJQuYhKJBHv27GHXrl1ks1nmzZtHe3s7e/bsob+/H9M02bx5Mzt37mTRokUUi0X27NlDNpulVCqxYMEC2tvbKRQK7Nu3j2KxyN69e2lrazuo/Q/H3GVlzlxJxhF+HcWf6udRWCZks1leeeUVampqZFRrofUoSFyRh5BBAWlenUgkiMfj4ywdSqWSpTWGAwcOHLwdMFXcLU0X90fTyR3Rddddx3nnncesWbMYHR3lrrvu4i9/+QsPPPDAlCpnNBqVPjIFwuEwtbW18vhUKetUw/QmHlV5q+wj6pvL7KbV7Ni5mVCkhnLRg1k2md+0ls0dD2J6i5iMmeVms1l27dpFNBaVWmOJRALDMIhGozQ2NjI0NESpVMLj8ZBMJslms+RyOUKhkFwkNDQ0SN+D6XSaQqFAW1sbhUKBbDZrSeodT5gq9TLUzmCAiYHLDGFQxu0O4nW7KVT1k8nncRt1zKifi88Tw2NED9xkH5DlzUMsDsa0HTENyiUfhuGnuWkuhXyB0cEcplmit3cQj2eMBM3l8iQSQzQ1NTE0NES5XJZkeFVVFeFweEKN1DeDqfIsHThw4GA6QBBAyWSSjo4OPB4PM2bMoFwuMzQ0RCgUwjRNHnnkEdra2njllVcoFossW7aMnTt3EgwGCYfDhEIh6bJDEH7CxFbkEQgE8Hg8R2ScFtGyd+/ejWEY0m9wPB6XxGc+n6elpYWWlhZpESIIt56eHvbv309tbS1VVVWMjo6ybds2uru7WbhwIbNnz8bj8VAoFAiFQuzatYuuri6CwSDvec97pJZkLpeTPrL37NlDoVAgnU5TV1fH6Ogo8+fPt3QhcqSgu1YRvhtV8k+UQxCxQnt069atjI6OsnPnTubMmUMoFAKQ5tPCYkHIn6oWpzBHHxwcZPbs2TJ93U2NAwcOHLzdMFXcLU0X90fTyR1Rb28vH/3oR+nq6iIej7Ns2TIeeOAB3vOe90ypck4G06msRxOGOQ09VY+MjBCPx0kMDxGM5Pnr5u/TldrAvKYL8eZm4Q30MZwexE2EiKcWj9dkZ9/DpEpdvGvx96gLLiExlME0ikQjcUZGhuUCQfjSE/55DMMgk8lIbUaxEDBNk5qaGqmV5na7GRkZIRgMjlssBINBWxNWR3A8nBDduAyYY0QfLqAIpgvThLzZy57up4mEIxSzQVoaVuJy+Q/cM3b94SceTaCMaY4tXEazL/PESz8jEIpgGHmMfITTTvoco8MeEoleqqrjmGWXXMS4XC6Gh4dxuVzE43FKpRLRaJRgMHjYiUfxXg0PDxOLxQ5bug4cOHBwODFVxqpyuUyxWGTnzp389re/Zf78+bS0tFAoFNi5cyf19fWEQiF+97vf8d73vpcXX3yR3bt3c9555/HKK6/g8/lYt24d7e3tUgYRhKPP5zsocvPh1lAXxGEymSSZTEqtggULFlBVVYXL5WJ0dJTHH3+cv//7vycWi0kCTpWVhFmw8Eu4f/9+Ojs7Wbt2LXV1dcAYmSaC5uzZs4eqqirq6uqkablK6Ilo2oFAgGAwKMlYEYxFmFsf7rZQITQYBQTRKghi0XaGYZDP5+WxdDrNU089RTKZZPfu3YRCIS688EIaGxslySiC7BiGQSKRkIH2qqurpTbknXfeSXV1NatXryYajUoNCJfLRSQSGecX8nBhqrxXk8F0KqsDB9MFznvlwIGDI4nprfFognnAL17JLOFylymXCrgoMjy8l6i3mUBjM6OZYcouF0bRhedA4OtsLkuxlCMSjlFTUzNu91rsYIvIkWJ3QkR4zufzhMNhYExTQDgJr62tlcKzSEcP/mHnD9DBW8WYKbMIzPJG63rGApsb4DWraaqZT2J4gEiw+oD5swEc7Cfx8JUJmb5JEY+7gaaqd5Av7QFKVNctwmX4qK6KUl0TAXM8mWiapuxXqoaH038cOHDg4OjCipzK5XLs2rVLajsahiE1GYWPZ5/PR1VVFYsXL2Z0dJQXXniBqqoqQqEQsVhMblgK2UFoQNrhcI//QqMuk8nQ3t4uNRwLhQIvvfQSCxcutPVXLfwPxuNxQqEQPT09BINBTj/9dMLhMOVymWAwKLU1i8Uis2bNGhetWvjYVjX+QqEQ6XQat9st/WQCkoydTJ0OBYLwU300qq5O8vk8Xq9XutKBsWjg+XyeXC5HqVSiv7+fjRs3MjQ0hGEY1NXV0d7eTiwWk8SpIKuFWbV4zoJ0Fb+j0ag0gRd+JAUp7cz/Dhw4cODAgYPphulNPB6IGlw28xhmjsTwfubVLmX3nh1UR6opJgOYZRdFI8NoLoFhHHACXja570/3UV0bw+cNUFdXSzAYJJPJ0NzczJ49e2hoaKCvr0/uLgvB74UXXmDGjBlS29Hj8dDQ0MDQ0BCxWIw5c+awa9cuRkZGqKuro6uri4aGBvbv34/H46G6upqFCxdaBgVx8FZhWH5FkMp4iARmEwm0gOHGxRixfGSFeMVflOki4K7hpIVnAmUMogcUNX1jHiYN14Fy22u1HBzA5q0rLDuLGAcOHDg4dJTLZUZGRnjttddoaGiQpJEgkATBtGjRIgYGBiiXy8ydO5dXXnkFl8tFbW0tkUhEygNWvpOP9PhcKpUoFAokk0l8Ph/19fXkcjkymQxDQ2MuP0444QS5AasTZepGmMfjobGxkaqqKunvWtVOFCSsIPlKpZL0gylITQGXy0U0OuYKRdf8fCvtom4yqz4TBSEoTKBFeVTtTkE6jo6OSj+WfX19DA0NMTg4SCaTYXBwkDlz5jBr1iw2bdpEfX29JFVLpZLU3iwUCni9XqnFKfw6wli/CoVC9PX1yTZStV6dzUcHDhw4cODAwXTD9CYezbF/plmmZGbpSbxKfWguLTPnM5zqJT4TOvr+SrLcTd7sxmeM7TCbpjm2GFi4iL/+9UmGhgalQ/POzk56enrw+XxUV1dTKBTGmdi4XC4SiQSdnZ3U1NQA8Oqrr5JKpairqyMWi/H0008zd+5cHnvsMerr63n11Vepq6sjm83S0dHBggULjl2bvY1hGG4MM6TFkDl6wrthQLE4wr6ep8kWMpQNF7FQE01VJ2PgBbN0YNH5ht8oVVN2LI2DNSLH53GwM3zdF9bR8I3lwIEDB8cb1PHVNE0ZbEW1gkin0zJycbFYpLa2Fq/Xy759+6iursbn8zE4OMiePXtYtGjROAJPkHRq4JEjjXK5TDabJZvNEgwGZUCboaEhWlpamDNnjiTihKafIOBUn4OCXBSWIh6PR2rriToKks3n85HL5cYFW4HxBKMdwXYoc5euvSgIT3iDQFXNpsW1orxq+YVJ+v79+9m9ezcDAwMYhkEgECCZTErz8VNPPZVYLMb27dtpbW2lqqqKdDpNuVwmHo8fFFBGfKrPQ7jy2blzJ4B0uyI+HThw4MCBAwcOphumN/FojJnWmmUPJdNDydXPK3v/P6LeZlxuP5lEF7niIBhF3LhwF6KUy2PhZRoaG9ixYztnnnkmudxYEJiuri6qqqoIBALE43FqamooFovk83my2awUyHO5HM3NzdTU1GAYBul0muHhYeLxOPv27WPBggUkk0mWL19OV1cXJ598MoFAQKYlYEUQHSoORxrHO2SbmOaBPjNOHZKjQz6O9btMcZQd+54hVB0iV0rSOxKhoWoh+/d2EwgG8HoCeL1eBgb6pYbJ4OCgXGyJKGSpVIpkMkl9ff04EzZh9pbL5cjlcgSDQbkQDIVCZDKZA00xtqiKRCIEAgGn3zhw4MDBISCfz1Mqldi+fTs1NTXSNLmurk6OwclkksbGRqqrq6mpqeH111/H6/USjUZlABphxiv8QatakyqhB0dmfs9ms6TTafL5vCwHwOzZs2lraxtH/gmzY1EWj2dMhBSEnuqmRmh8ChJPpGsYhvRf6Xa7CYVC4zQMJ6pjpY03Ncq0kLeExqBoW91Poyi/CJgjNCEzmQyZTIZyuUx3dzc9PT0y4M7MmTNZsGABfr+f4eFhnn/+eebPn8+pp56Ky+WSFjBtbW3jfFL29PRIv5+C7BTaj6oWKLwR8EdoYKqkoxPV2oEDBw4cOHAw3TC9iUcMjHKAxuiJDCU7SJV3UPDso7/cg1muwnBlcHlyuEoBPIUZ1IRXEPDW4PEYvOuMd2Dgwu324HKNCW6LFy8eF2BGQJA0ImiMEABVbTR1F10VnpcuXSoFWSFAijSBcf4g7fz3qdpuVscF2VTpWgccTeVGBeYbf0YZTAPTyOMLhCkVvBTyBYqlDB0dHaQzaYKBMMFgiEwmjcvlIhaLMTo6itfrZWRkRD7fbDZLoVBg+/btpFIp6QNLOPAXCyjhxL5QKDBnzhwGBwcpFArkcjn8fj+zZs2iqanpWDSMAwcOphlmz57Nnj17Djr+mc98hltuuYVsNssXv/hF7r777nFR/NRokx0dHVx55ZU8+uijRCIRrrjiCm688UY5h01lqBp0glQbHh6mvr6eYDBIPB6X5rPC3DiTyUgLilwux+uvv87ixYsZGRlhy5YtLFu2jKqqKklCgTW5diTmdCFz5HI5YMyPdU1NDZ2dndJfpXqtkIWEybSahkpICjlImCd7PB7p4zAQCEjtPd10eqI66lGmAZmvIA8F2Si0FNV0VVJU1V4tFotks1nK5TLpdJpsNivNpkdGRvD5fMybN494PC7rl8vlGBkZYd++fTQ0NDB//nw8Hg+ZTIZcLseyZcvw+XwyKJzQeOzq6qKuro5gMDjOqkHUQXyKNvR6vXLzUMiajsWCAwcOHDhw4GC6YepL+hPA4/Jx4pz30Nq0lF09z9HR/xjDxe2UjRxGMYKPNhpjJzJ/5hk0xpfgd1dhmgYjwwnS6TylUpFwOCTJmkwmIwVT1ZdRsViUPnii0ah0Ji6Ev3A4zMjIiBTAhUlROBwmlUpJITccDkuH5OVyGa/XSz6fH6dR4HK5CIfDJJPJcedVolGUQWi51dXVUVVV5QijE8LQPo8GxiJbg4mBi0K2xMjQMJl8EZ9ZhYGXFctX0TfQM+b/yeWVizSXyyUXUh6PB5/PRzablc8/EAjIyOqGYUjn96Jv+nw+GSU0EAgQDoelg3qRhwMHDhxMBhs3bpRED4y5GXnPe97DBz7wAQC+8IUv8Mc//pFf//rXxONx1q9fzyWXXMKTTz4JjM2lF1xwAU1NTTz11FN0dXXx0Y9+FK/Xy3e/+91jUqc3C0E+ir9YLCYJtnQ6DSBJvPb2dtxuN83NzYyOjhIKhTjllFNwu93cf//9fPjDH5aB6lQNxyO9kWgYBuFwmNraWtxuN+3t7fT390sTaN20vFAoyA1UsRGrkmdq+QVhppoJizzfim9iVQ4SZKMg7FKpFL29vezbt4+RkRHy+TyxWIzq6moCgQDRaFSaN7vdbrxeLz6fj0KhQKlUIpVKSTJxYGCA5uZmVq5cSSAQkMRwuVwmn8+TTqcpFou0traOi0Ydi8VoaGiQFgswRuiapkk2m6W+vp69e/dSXV1NPB6X6enao8IHpJjTAcc3uAMHDhw4cOBg2mKasw4lMExcZjXVwVpWzF7EgpnvYk/vU+zre45oqIV5ze+gJrwQjxE9IPiWwYB4vIpweMycxu12EQwGyefzMpqky+XC6/WSyWSkIF0sFnG5XAQCASkAer1eUqkUgUBACuqpVIpsNkssFpO7+z6fT6Y/OjpKMBgcZ2aj+u8ZHh7GNE1CoZA0Z1K1CGAs6qMgprLZ7LF6ANMMx5KUHcvb76tj6bwLyZXSlE2DaKganzeGzx2hLeI/ENV6vLat+BQLN9FHI5EIgPQtpmt2qBCaH5FIxImM7cCBgzeF+vr6cb+/973vMXfuXN71rncxPDzM7bffzl133cW73/1uAO644w4WL17M3/72N9asWcODDz7I5s2befjhh2lsbGT58uV861vf4tprr+X666+XWnRTFbq/3VQqJbXsRPRlEXQunU4TCoUYGhqScoLL5aKpqYlSqURVVRUul4vdu3fz8MMPc8EFF0h/kAKVCLrDNX6LMlVXVzM0NMSWLVtYsmSJlEt0k2TVf6VaFrGhZeeDcDLmwRMRkqrfRTUYTDqd5umnn2bz5s0A5HK5cabce/fulZu9otzlcplwOEw0GpWm8TBGjtfW1nLKKacQj8dlvkIzNJ/P43K5qKmpGRflulAoEAqFSKVSZDIZKcMJuc3j8eD3+8lkMtTX19Pb28v/v707D5K7rvM//uz77p6r58ocyZCbhEzILRjBZBPYsOURF61CCSyFVakExbiuRyHs8lNRrNUUCxh0XWDLRS1rRSUraIgYc0FiIDK5A+SYyUzP3fd9/P6Inw/dk3DJHJnJ+1GVSuju6f5+vj3JfHn1+/155/P5kmnhKtwNBoPEYjEdQhYP55E9HoUQQggxHo3z4NFwfiiHwYjBkMFAHq99Clc2NDGz/iMYTQbMBhcUTGDIAVnOTxA24HBYAAMej/ttqwrUhefbKSsrK/lv9em3ukD0er0l9xeHPxdrmVF7R77dY4pJ282lzsD5akcDVrOXptoPAjnAyPnp1pbzk2cMxr/e9v7/x2Lo94P8z4oQYjil02l+8pOfsGnTJgwGAwcOHCCTybBy5Ur9mJkzZ9LU1MTevXtZunQpe/fuZe7cuSWt16tXr2b9+vUcPnyY+fPnj8VS3rPi/fbcbrduvVVVf1arFYfDgdPpJBwO09vbqz+cVPtBGgwGqqqqaGho4PTp0/z2t79lxYoVNDY26kpBpfgDqOH8t7z4Ayi1t7XFYtHhXCaTKZnmrH4v/qC0+Dne7jrkb7lGUYFeccVk8XVRNpulp6eHPXv2UF5ezk033YTJZCKRSBCJRPT2IwaDAYfDQTKZJBaL0dvbq9dms9lwuVwkEgkcDgeNjY06MCyu7izeJkd9oKyqJ6PRqK6YVB8yDwwMEAqFqKiooLKyUnckGAwGBgYG9PYog4OD+liK16aOXR2/uj2Xy+num8v5uk/9nQiHw2N8JEJMHOrv0/upShdCiLcyLoNH9Q9iJBzFgJECeSBPHiMGMlDIF12gRylg0CNEDKSKn+mvv1948fZ2G5hf7DFv9dj321b0Tq8rw2UudWqPxzyFQv6vf7YAOQwFIwWMwF8HDhmyf612fPv/sRyp91wuOIQQ79avfvUrgsEgt912GwCBQACr1XrBB3E1NTUEAgH9mOLQUd2v7nsraliWcimEDWrf52QyqT9MzOfzpFIp8vk8DocDm82G1Wqlr6+PxsZGbDabrpKzWCyUlZXhdDopLy/H6XSydetWPvKRj1BfX6+vHVQAVjy8ZSR+zqtgbM6cORw+fJjm5ma9TlXNqIbCXOz1388xFf/MUeGmCjrVNiHFgatqdT5y5AhHjx5lzpw52O12vd+xandWlZnxeJxIJEImk6GsrExXnKrAMZFI0NzcjNPp1K+ltjYZ2kau9l3MZrM6lFWD3NRWOjabDbfbjdVqJRgM0tHRQX19PRbL+W1UXC4XoVCISCSC1+slFAoB5zto1DY+aiCP6my52Lm6nPX39wPQ2Ng4xkcixMSjBmkJIcRwGpfBo77gaGoa4yMRYuKRCw4hxDv58Y9/zI033kh9ff2Iv9YDDzzAv/3bv43467yT4tBHBVOxWIyysjK9F6+a/Kzadz0eDz09PbrVV32tagNWVXBTp04lHo/zy1/+kptvvrlk6NfQar+R+oDRZDLh9XpZsGCBnrRcvN/wSFPBrdo3U61XVT0WCgUSiQTpdJqjR4/S1tbG4sWLdduzCkVVW3QqldLb5vj9ftLpNJFIhJaWFk6fPo3L5dL7NNpsNh30qXNRfFzFVa7qfTYYDESjUbxeLyaTiVgsxsDAAMlkkkKhQGVlJTU1NQwMDNDR0UFDQ4P+vlH7fxe3j2cyGQqFAqlUing8TllZmd4vHEorVId+T1xuKioqgPPDqibq9Uo4HKaxsZH29vYLOqcmgom+Phh/aywUCkQikVH5uS6EuPyMy+BRLjgmjsthneNljXLBIYR4N86cOcPzzz/PL3/5S31bbW0t6XSaYDBYUvXY3d2tQ7Ta2lr27dtX8lzd3d36vrfy1a9+lU2bNun/Vv+mjiW1/3JVVRXRaJSysjJCoRBOpxOTyaT3cvZ4PLrt1ufz6RBNDQBTYZnT6WTu3LkYjUZ+//vfs2bNmpJtV4rDp5EKAYunag+tbhypcKt4/0g1eE9VEbpcLtLptD5ng4ODtLW1kUgkGBwc5EMf+hB1dXU4HA69/6IKLNU+yMUTuMvKyshkMrotPhgM4vf7cbvdJcFl8V6KKixW+1eq51aVmel0Grfbrasi3W43Ho+HQqHA2bNniUaj+n0MBoP4fD69ByVAMBjEbreTSCQwm816WE4wGGTSpEl6n83iVm+penxz+xifz3dJX1cNB6/XO6HXONHXB+NrjRP1/6uFEGNvXAaPcsEx8VwO6xwPa5QLDiHEO3n88ceprq5mzZo1+rYFCxZgsVjYvn07a9euBeD48eOcPXuWZcuWAbBs2TK++c1v0tPTQ3V1NQDbtm3D6/Uye/bst3w9m82GzWYbwRW9d6r9eNKkSezZswe/36+r2RwOB93d3TgcDjKZDHV1dZw7d454PK5bdVXVo6piU+HjlVdeST6f55lnnmHt2rX4fL6SEEwFYSNpLKYnqyBPVQCqIC8ajZLNZjlz5gzHjh0jm83idru54YYbcLvdekAfgMPh0NWDdrtdV0uqNRmN5wcJDg4O6qCzsrISm81Wsmel2j9SKd5jsfhx8XhcD41RwWcul8PhcGAymaivryedTtPX10ddXR1dXV2YzWZyuRzJZJJsNks0GqWyspJ0Oq1fN5lMEg6HmTdvnn7t4lb74n02hRBCCCHGg3EZPAohhBBi9OXzeR5//HHWrVun21Lh/IcWd9xxB5s2baKiogKv18tdd93FsmXLWLp0KQCrVq1i9uzZfOYzn+HBBx8kEAhwzz33sGHDhksuWHwnak/E5uZmnn/+eZLJJH19fXi9XnK5HG63m3g8jtvtxuv1UlFRQU9PD3V1dbpaUgWKxWGW3W7niiuuYHBwkBdeeIHVq1djt9uBN4PHocNnhms9SnF15UhU1w19ThUWFrccA/T09BAMBjl69Cj9/f0UCgU8Hg9/93d/R0VFhQ7jVJhXKBRIJpM6+CsUCnowjAoaVfVkJpOhoaEBk8mExWLRYZ4Kdg0Ggw5Ah+63WczhcBCLxQiFQnridVdXF+l0GqvVSnV1NSaTif7+ftxuNz09Pdjtdux2O6lUSlc6qmOPx+N0d3eTy+X01xYHnlLtKIQQQojxSEbdCiGEEOJdef755zl79iz/9E//dMF93//+97nppptYu3Yty5cvp7a2tqQd22QysXXrVkwmE8uWLePTn/40t956K/fff/9oLmFYGI1GbDYbFRUVVFRUEIlESCaT5HI54M0KOzXtuKamhmw2y+DgINlslnT6/FAxVcEGbwaQPp+Pq666inQ6zcmTJ3UlXT6f163Exb+G29C9BEeysk5VOCoqXA0Gg3R2dnLkyBHC4TCVlZUYjUY+9KEP4XK5dOBosVh09Wk+n9fVseq8qJZx1T5dHEB6vV4d6ha3WV+svXzoZGkVBqr9KA0GA36/n7KyMmpqaqivr8dqtdLR0aG/ByKRiN7H0uFwkM1msVqt2Gw2jEYj6XSa/v5+uru7qampwel0lhxbcWv+5V7taLPZuO+++8bdBxbvxURf40RfH1weaxRCiHdrXFY8Xg7/kF8Oa4TLY52XwxqFEJeHVatWvWXYZbfbeeSRR3jkkUfe8uubm5v57W9/O1KHN6KKKwBV+GO1Wpk8eTLt7e268q2+vl5PvFZfk0qlqK2t5fTp0xiNRioqKjCbzTgcDoCSVloVqC1dupRnn32WsrIy6urqdIXkOwWOl3ooVbxvpdrTsLjNuKenhzNnzuj9Qpuamjh9+jRXXXUVyWSSdDqNy+XSz5XL5fTzWK1WHQwODRFVNWVPTw+1tbVYLBaAkvZlRQWUan/I4uBSPT6fzxMOh/F6vXpfx+KJ1ADJZJJAIEBDQwN9fX2k02nKy8vJ5/PEYjEddqqvO3fuHIODgyxcuFAHkqrS8VJ/X0eTzWbjX//1X8f6MEbURF/jRF8fXB5rFEKId2tcVjyqf8gncpBzOawRLo91Xg5rFEKIy4kKHo1GI5MmTSKZTJJIJBgYGNCVaRaLRe/nmM/nqa2tpampie7ubgYGBojFYiQSiZI2YxVqmc1m7HY7ra2t7Nixg3A4TDab1Y9RYVvx3ogqjBxaEXkpDSQpPha1BvUrHo/T1dXFoUOHyGQyTJ48mcmTJ/PGG29gt9uJRqM4HA7dlqy+Xj1ncVWiOo/FE7J7enqIx+M4nU78fj8Wi6VkP8ni83ix51HhsNo7sre3V08sD4fDRCIRgsGgXpvdbsdms2G1WgmFQhiNRlKpFGVlZSQSCSKRiD4n2WyWc+fO0dnZid/vp7GxsaS1uniKtRBCCCHEeDMuKx6FEEIIIUZbcdWjyWTC4XBQXl6ugyiPx0M0GsXpdOpgy+l0kkqlCIVC1NXVAZBIJEgmk1itVgqFAlarVQdcquKvp6eHSCRCIBDghRdeYNasWQwODhKJRPSkbIPBgNvtZvLkyVRXV9PQ0KCHrgzdk3Csq+aKQ7N8Pl8SosZiMU6ePElnZyc1NTXU1NTgcDgwGAx4PB4ikQjz588nHo8TiURob2+nvLyclpYWPB4P2WwWu92uA0QVKBYKBeLxOMFgkHA4TDKZpKysDLvdrvd/VK3a2WxW77d4sX04VVVkOp0mkUhw8uRJYrEYlZWVOjgNh8O89tprVFVV0dLSotdnMpmIRqP4/X6sVit9fX3YbDbsdrsOUE+dOkU4HGbx4sVYrVYdPKpWdBV8FpMqSCGEEEKMBxI8CiGEEEK8S8Vhj8lkwuv14vP5dBtvJBLBZrNhsVhIp9NEIhGcTifxeJxMJkNtbS09PT0YDAai0ShWq5VUKoXBYKC7u5t8Po/f78dgMOiQcdu2bezatQubzYbZbMZgMJBKpfRzPv/88xQKBcrLy5k7dy7Lly+nubkZp9OpA8hLIXRUVYSpVIpcLkcqlaKrq4u+vj7MZjMzZ87UYWAqlWL//v2kUim9t2MmkyEYDNLf3w/AK6+8Qm1tLT6fj/Ly8pKW7Wg0qtur1TRxh8OB0WjUbdbFx6b22lRt2ir4K27BzuVyxONxrFYrJ06coKWlhUQiQWVlJW63m0mTJtHf38/Ro0dJJBI6PA0Gg+TzeSorK4lGo0QiER1cRyIROjo66O3tJZlM4vV6dfCojudi+04KIYQQQowXEjwKIYQQQvwNVMWhw+GgpaWFnTt3Mm3aNMrLyzGbzXrissVioaqqilgsxsDAAGVlZcRiMcxmM+l0WrcR19fX09/fz4kTJ+jp6aGhoYHp06cTDAaxWq2Ul5eTy+VIp9O61VsFZGpK8qlTp3jsscdoampixYoVtLS04HQ69X6F77SekaICvmQySSQS0cN2otEokydPxmq16snOqVSKtrY2vF4vs2fPpqysDDhfKRqLxXRIWF9fj9lspq2tDZfLRXNzMxaLhVgspisFPR6PPs9Op5NQKITVatVVjCrYM5lMALrqsVAo6OnUah/GdDpNOp3GbDbjdrsxm83E43E98MbhcOB0Olm4cCFHjhxhcHAQl8ulp1Srqdc2m023gSeTSY4ePYrNZqO8vJyysjIsFos+hkshOBZCCCGEeD/G5R6PQgghhBBjrVAo4HK5cDgceL1e4vE47e3tBINBUqkUdrtd7/EI6DbfZDKJy+WiUChgt9txOBzEYjH6+/vJ5XJMnz6dOXPmMGXKFD1B22KxEIlEsFgsNDc3M23aNFpaWmhqaqK+vp6ZM2cyf/58Pvaxj3HrrbdisVj46U9/yq9//Ws6Ojr0HofZbFYf+2jvGajaqs1mMy6Xi8rKSqZPn47P58NqtZLJZDh37hwHDhygtraWuXPn6nbjaDRKIpHAaDSyaNEiFi9eTF1dHTabjUmTJtHZ2cmxY8d06OhyuWhoaKCurg6/34/ZbMZms+lAUg2cKd5bc+i+kCaTSVdnqvvU3o4VFRUMDg6SyWR0m7aSSqWoqqqio6NDB4vd3d10dXXpqkwVLh45coR8Ps+UKVPw+Xw4nU79vqhgWR1v8X9frh555BEmT56M3W5nyZIl7Nu3b6wP6V154IEHWLRoER6Ph+rqaj760Y9y/Pjxksckk0k2bNigK2jXrl1Ld3d3yWPOnj3LmjVrcDqdVFdX86UvfUn/nb7UfPvb38ZgMHD33Xfr2ybCGs+dO8enP/1pKisrcTgczJ07lz//+c/6/kKhwL333ktdXR0Oh4OVK1dy8uTJkucYGBjglltuwev1UlZWxh133EE0Gh3tpQghxKgZl1cvctFxaf9ALjZRLzpALjyEEOJypqrQzGYz1dXV2Gw2FixYwKuvvkomk9EDRYrbZNPpNHa7Xe/7aLFYdMilfg44HA59ezwex+Px6CEllZWVWK1WBgYGCAaDhEIhQqEQqVSKVCpFPp/HbrfT1NTExz72MRYuXEh/fz/bt2+nq6uLUChEMBgkEomQyWRG/ZwlEgmy2SypVIp0Oq1bntPpNJ2dnezbt49jx44xdepUampq9L6MAwMDHD9+HLPZzIwZMygrK9N7NFZWVlJeXs6UKVPo6+sjEAjg8XhwOBy6SlFNqFb7LaoAVk2qVuGiqsRUrdrxeJxkMkkoFCIajWIwGKitrdVVq5lMRoeT6nmi0aj+OV5eXk5bWxuFQgGPx0MymcRsNmMymXC73bz22mt0d3fT2tpKoVCgpaVFH6cKGotd7qHjz3/+czZt2sR9993Hyy+/zLx581i9ejU9PT1jfWjvaMeOHWzYsIEXX3yRbdu2kclkWLVqFbFYTD/mC1/4As888wy/+MUv2LFjB52dnXz84x/X9+dyOdasWUM6nWbPnj08+eSTPPHEE9x7771jsaS3tX//fh577DGuuuqqktvH+xoHBwe55pprsFgsPPvssxw5coR///d/p7y8XD/mwQcf5KGHHmLLli289NJLuFwuVq9eTTKZ1I+55ZZbOHz4MNu2bWPr1q386U9/4rOf/exYLEkIIUaFoTDORuT9/Oc/59Zbb2XLli0sWbKEzZs384tf/ILjx49TXV091of3tm644QY+9alPsWjRIrLZLF/72tc4dOgQR44cweVyAbB+/Xr+7//+jyeeeAKfz8fGjRsxGo3s3r0bOP8DubW1ldraWr773e/S1dXFrbfeyp133sm3vvWtsVzeBfbv38/NN9+M1+vl+uuvZ/PmzcDEWOPg4CDz58/n+uuvZ/369fj9fk6ePMkVV1zBFVdcAcB3vvMdHnjgAZ588kmmTJnC17/+ddra2jhy5Ah2ux2AG2+8ka6uLh577DEymQy33347ixYt4qmnnhrL5QkhxCUrHA7j8/kIhUJ4vd5Re92hl0v5fF5X4O3fv59sNsukSZP46U9/SktLCzNnzsTj8VBRUaHbrVV7rwrNBgcHddWkCjEzmQydnZ309fUxadIkMpkM5eXl2O123f6rWoNzuZwOxqxWK3a7HavVqvcWTCaTvPTSS1RWVnLo0CGuueYaqqqqdPhltVqx2WzYbDbdaqwMR2tv8TlTLdSqJVydh0QiwRtvvEF7eztNTU24XC6SyaTew9JgMGCz2Whubsbv9+vAVK0Tzn+g2dPTw2uvvaarERsaGvSQmuJ9HI1GI8FgUIfFquJRTQkvriy02Wy6MjKZTFIoFLDZbJw5c4ZwOMzRo0eZPXs2TqcTn8+nq1nz+Tx9fX0cO3aMw4cPs3LlSlwuF/l8HofDgdvtprOzkz179jBv3jymTp3KCy+8wIc+9CGam5v1ZHNAf9+oCkz13g3Xe6SM1d+r92LJkiUsWrSIhx9+GDj/fjY2NnLXXXfxla98ZYyP7r3p7e2lurqaHTt2sHz5ckKhEH6/n6eeeopPfOITABw7doxZs2axd+9eli5dyrPPPstNN92khzABbNmyhS9/+cv09va+q+0URkM0GuXqq6/m0Ucf5Rvf+Aatra1s3rx5QqzxK1/5Crt372bnzp0Xvb9QKFBfX88Xv/hF/vmf/xmAUChETU0NTzzxBJ/61Kf0vxv79+9n4cKFADz33HP8/d//PR0dHdTX14/aeoQQYrSMu49Ov/e973HnnXdy++23M3v2bLZs2YLT6eS//uu/xvrQ3tFzzz3HbbfdxpVXXsm8efN44oknOHv2LAcOHADO/2D68Y9/zPe+9z0+/OEPs2DBAh5//HH27NnDiy++CMDvf/97jhw5wk9+8hNaW1u58cYb+X//7//xyCOPkE6nx3J5JaLRKLfccgs/+tGPSj4FnChr/M53vkNjYyOPP/44ixcvZsqUKaxatUqHjoVCgc2bN3PPPffwkY98hKuuuor//u//prOzk1/96lcAHD16lOeee47//M//ZMmSJVx77bX8x3/8Bz/72c/o7Owcw9UJIcTlS7UgD/1VLJvNkslk9KRht9tNLBbD7XbzwQ9+kIMHD9LX10c4HCYUClEoFIjFYiQSCR28RSIRHXrFYjGSySSZTEZX7VksFh1OeL1eHTZZLBYsFotu5a6urmbGjBnU1taSTqd5/fXX6e7u1s8/Y8YMqqurqa+vZ8+ePZw7d05X+KnQMhwOk06nR6z1OpvNEolESKVSmM1mPXjn5MmT7N27l3w+z4c//GGqqqp44403OHToECdPnqS9vZ3q6mrmz59PXV0dFosFk8lEOp3WlaJGoxG3201LSwsrV67kH/7hH2hpaSESifDKK6+wb98+Dh8+TFdXl37fvF4vkUiESCQCoCdMq8nYuVxOh47qnKhBPWoATDAYLAk0zWYzTqcTm81GPB7n7NmztLe309zcjNvt1t8nTqeTQCDAwYMHaW1tZdq0aXq4kN1uJ5PJ6Gpa9frF7eCqVfxyk06nOXDgACtXrtS3GY1GVq5cyd69e8fwyP42oVAIgIqKCgAOHDhAJpMpWd/MmTNpamrS69u7dy9z587VgRzA6tWrCYfDHD58eBSP/u1t2LCBNWvWlKwFJsYaf/Ob37Bw4UL+8R//Uf/b9KMf/Ujff+rUKQKBQMkafT4fS5YsKVljWVmZDh0BVq5cidFo5KWXXhq9xQghxCgaV8GjXHRc+j+QlYl80QFy4SGEEBNdceA4dA/AXC6ng69sNovL5dIDSJqamigvL+ePf/yjDh5Vy68K3zKZDEajEZPJpMNLNbG5u7sbl8tFX18ffr8fi8WiK/FUxWQkEtGDazKZDLlcDrvdzuTJk5k+fTqZTIZ0Oq0rIU0mEzNnzsRms7F3717a2tp44403CAaDJBIJ4vE4PT09w9p+XXzuksmkPvZcLkcwGOTAgQPEYjFmzZqF3+/nyJEj7N+/n1OnThEKhSgvL2fFihXMnDkTp9NZsoeimnqdTqcxGo06zLTZbPh8PmbMmMGiRYu4/vrrWbp0KQ0NDcTjcU6cOMFrr73G8ePH6ezsZGBggK6uLjo6OnT7ejabJZ1O09vbSzgc1q+j2iRV5eEVV1xBWVkZ4XCYWCxGOp1mcHCQgYEBIpEIfX19ZLNZpk+fTjab1QN+Ojs7OXz4MHPnzmXatGmYzWa6urpIp9O8+uqrtLW1cezYMY4fP87rr7/O0aNHdRAbDof1fqGX27CZvr4+crlcybUhQE1NDYFAYIyO6m+Tz+e5++67ueaaa5gzZw4AgUAAq9WqBykpxesLBAIXXb+671Lws5/9jJdffpkHHnjggvsmwhrfeOMNfvCDHzBt2jR+97vfsX79ej73uc/x5JNPAm8e49t9nwYCgQu69MxmMxUVFZfEGoUQYiSMq6nWb3fRcezYsTE6qr/N5XDRsX///gvumyhrVBcemzZt4mtf+xr79+/nc5/7HFarlXXr1smFhxBCXOLeqrpPhYzF1W4qdCwO01TlmWq3VhWN0WgUv9/P66+/zsGDB1m2bBl9fX14vd6SSclqwIjazzGTyeh9BNUAFrvdTjab1e2/aj9B1R6tjiWVSgFgMplwOp1MmjSJaDSKz+cjEAjQ3d2N3+9n/vz5vPzyywwMDJDJZDh9+jTTpk3D4/FgtVqJRqM4nU7d1q2815Cr+GtVdaLZbCaVSnHs2DEikYiuGlRDY8LhMGazmalTp9LU1KT3blSBq8lkwmg06udS+zWq90kdo9lsLglpLRYLdrud2tpa/V6Gw2EGBgbo6OggGo3q86kGBRkMBpxOp76vuP26uNXb6/XS09OjK1LT6TTxeJzOzk7C4TCzZs2ivLxct9a/9tprvPrqq1x//fXU1NRgsVjIZDJEIhGmTp1KIpHA7/czMDDAoUOHiEQiGI1GpkyZwsKFC7HZbKM+EEgMvw0bNnDo0CF27do11ocyrNrb2/n85z/Ptm3b9JZCE00+n2fhwoV666f58+dz6NAhtmzZwrp168b46IQQ4tI1roLHiUQuOsY3ufAQQoiJQ1UuAjp0zOVyGI1G4vE4vb299Pf3k06nMZlMOqSy2WwkEgm6u7tpb29nxowZpNNp3G43TU1NnDt3jjNnzlBbW0sikaC2tlYHlqlUCqvVisFgwGKxYLVaCQaDmEwmwuEwLpcLk8lEoVDQFZK5XE635RaHYcX/XSgUMJvNuN1u4vE4fr8fq9XKiRMnaGho4Nprr2XXrl2cO3cOv9/P0aNHmTp1Kh6PR7caqyE16nn/VsUVoplMhldffZWenh4cDgfxeJxYLIbD4cDn83HFFVdQU1OD1+vVbd82m01XOqo9LW02m95fMx6P64pOtXZFDa5RbcoqLDabzZSXl1NZWUlLS4seBBSJRAiFQgwODpJIJPB6vTgcDh3CGgwG4vE4AwMDdHd360DVaDRSX19PMBgknU7rqdqqKtJsNhOPxzl9+jTZbFbvK6neO6PRyJVXXonP5yMcDgPg8XiYPn26rrpU7eRms/myHTBTVVWFyWS6YBhhd3e3DpXHg40bN+phIg0NDfp2tVVCMBgs+XC+eH21tbUXDNRU5+NSOAcHDhygp6eHq6++Wt+Wy+X405/+xMMPP8zvfve7cb/Guro6Zs+eXXLbrFmz+N///V/gzWPs7u6mrq5OP0YNkVKPGToQKZvNMjAwcEmsUQghRsK4unqZaBcdL7zwwltedBQb+gP5YutX94214osOs9mM2Wxmx44dPPTQQ5jNZmpqasb9GuGtLzzOnj0LlF54FBu6TrnwEEKIsaWCvVQqRTab1e3A2WyWQCDA7t27aWtro76+npkzZ9Lc3ExZWRkDAwMcPHiQnTt3snPnTjo6OgiHw5hMJmKxGMuXL6e+vp6jR4/S1dVFLpdjcHAQq9VaMs1ahWaJREJX6RkMBnw+nw7e1EAR9QvQx5nJZPSvdDpNLpcraQXP5XK43W6uuOIKzp07h8ViYfny5TgcDgYGBjCbzezbt0+3DMdiMSKRCPF4/H2fV7VvpcFgIJvNMmPGDK688krq6+tpbW3lpptuYsWKFSxdupQZM2bg9/t1hSGgw2AVwKpQVA1ZUVWoxVWOqjK0eFiOqowsbsk2Go1YLBYcDgdVVVU0NTUxZ84cFixYwLx587BYLHR2dhKJRAgEAuzcuZPdu3dz6NAhenp66Onp0cN8+vv79aCgQqFAR0cHkydPJhaL0dvbSywWo7GxkaVLlzJ79mxdERmNRjEajXg8Hh2IqoFEavJ5IBC4YOjN5chqtbJgwQK2b9+ub8vn82zfvp1ly5aN4ZG9O4VCgY0bN/L000/zhz/8gSlTppTcv2DBAiwWS8n6jh8/ztmzZ/X6li1bRltbW8m147Zt2/B6vRdck46FFStW0NbWxsGDB/WvhQsXcsstt+g/j/c1XnPNNRw/frzkthMnTtDc3AzAlClTqK2tLVljOBzmpZdeKlmj2m5C+cMf/kA+n2fJkiWjsAohhBh946risfii46Mf/Sjw5kXHxo0bx/bg3oVCocBdd93F008/zR//+Me3vehYu3YtcPEfyN/85jfp6enRbbqX0g9kddFR7Pbbb2fmzJl8+ctfprGxcdyvEd7bhYf6hFNdeKxfvx4ovfBYsGABIBceQggxmlSYFQ6HdYWcCo9Onz7N66+/TnNzMw0NDbq9V7Xlut1uGhsbiUajpFIpIpEIsVhMB1put5trr72W3/zmN3R2dpLJZGhoaCCXy9HS0oLZbNZt2oAOINUAE5/PpwfYqGAN0MehAkpFtRyrsDGdTmOz2XQgmU6nqaur49y5c0ybNo1rrrmGrq4uDAYDZ86c4fTp03i9Xux2ux5c836psA/O78vodDrxer0YjUby+bzeo1GtqzhUVGtX4WPxdGc1wVs9Rj2PqngsbpNXtxdXb6pzXXwOVWAJ4HA4qKioIJvNkkwm2b17N83NzUybNo1QKEQqlSIWi1FfX084HMZms2G1Wsnlcpw7dw6z2az3b7RarSXBcUtLC3v27OG3v/0tAwMDOvx0OBx670pVcdrQ0MCHP/xhZsyYoatj1fkqXuvlYtOmTaxbt46FCxeyePFiNm/eTCwW4/bbbx/rQ3tHGzZs4KmnnuLXv/41Ho9Hb6nj8/l01e8dd9zBpk2bqKiowOv1ctddd7Fs2TKWLl0KwKpVq5g9ezaf+cxnePDBBwkEAtxzzz1s2LBBb70wljwej94+SnG5XFRWVurbx/sav/CFL/CBD3yAb33rW9x8883s27ePH/7wh/zwhz8Ezv99vPvuu/nGN77BtGnTmDJlCl//+tepr6/X/+86a9YsbrjhBu688062bNlCJpNh48aNfOpTn5KJ1kKICWtcBY8gFx2X+g/ky+GiA+TCQwghJopQKER/f79un47H4xw9epSBgQHmzp2L2Wzm9OnTOpz0eDzk83kymQzxeFxXTFZXV2OxWPD7/QQCAfL5PPX19Vx33XW88MILZLNZ3WKcz+epra3Vw2VUO7DJZCKRSGC1WvXEZkBXvKkATbXcqvZr9VjVjqwCVdVdoCoty8rKOHbsWMlQl2g0Cpxv/XY4HJjNZn0u3k+opaY0qypFdazFFZvFFYwqGMxkMiXVjWptKiRUQaZqgVb7OKqqSFXpCW8Gy6oKdOi+leqcqz0yiwfYFAoFBgcHOXDgAJWVlcycOROHw0FdXR1nz56lubkZq9WK2+3W709fXx/t7e2sXr2a8vJyjEYjdru95LUrKyu54YYbiEQiRKNRXWVrNpv1XpFGo1FP2lZ7bqpzeDn75Cc/SW9vL/feey+BQIDW1laee+65C/bTvhT94Ac/AOC6664ruf3xxx/ntttuA+D73/8+RqORtWvXkkqlWL16NY8++qh+rMlkYuvWraxfv55ly5bhcrlYt24d999//2gt430b72tctGgRTz/9NF/96le5//77mTJlCps3b+aWW27Rj/mXf/kXYrEYn/3sZwkGg1x77bU899xzJR/m/M///A8bN25kxYoV+nw89NBDY7EkIYQYFYbCONyl+uGHH+a73/2uvuh46KGHxkWF2FtdwBdfdCSTSb74xS/y05/+tOQHcnHr7ZkzZ1i/fj1//OMf9Q/kb3/72yUXzJeS6667jtbWVjZv3gxMnDVu3bqVr371q5w8eZIpU6awadMm7rzzTn1/oVDgvvvu44c//KG+8Hj00UeZPn26fszAwAAbN27kmWeeKbnwcLvdY7EkIYS45IXDYXw+H6FQCK/X+zc/jwqpzpw5QywW0wNeTp48STab1ROLo9EomUxGVzqaTCY9SRrQIaEK1NTej/PmzdMtz6+88gq7du1i/vz5+P1+QqEQdruduro6PdCkUCgQCATo6uqitrYWs9nMpEmTSlqPgZKpxipoLA7oUqmUnpydzWY5d+4cyWSS6upqKioq6OjoYNu2bdTV1enQLxgMsnDhQubMmYPFYtEtv8rfEkAOvbxUlZjqnKhqxeKAUb0nKtR1u93Y7XYsFosOWlUAmc/nSSaTZLNZqqqqdEXgxaaRqz8XDwVSg2pUcKweoypEX3vtNTo7O7n66qt1SKxePxKJ4HK5CIfDesJ4KBTi4MGD+P1+Wltb9fdKcThsNpt10FgcsppMJux2u56Onk6nsVgsutK1uCp26L6bw1XxOFx/r4QQQgghhhqXwaMQQgghLk/vJyAZeskTCoXo6Ojg9ddfp6enh8HBQQwGA9XV1bjdbmbMmKErHItbcVWlo8lkKplI7XQ6AaioqNCtt2rvyBdffJE///nPzJkzhyuvvJL+/n7C4bBuxXW5XPT39+P3+/X6LBYLkyZN0q9bvM9j8eRtFT6qwC6VStHf38/Zs2cZGBigpqaGqqoqysrK8Hg87Ny5k7a2Nm688UY9ddnn8+l9JSsrK0s+6BuO4LFY8f6U6rhTqVTJIJ1kMonVatVt1WqIjgoQ1WMjkQjl5eV6argK5oofVxxuqrWo8BLOfyCqjikSiXDixAkKhYIOENVrq+dIpVI6QO3r62NgYIA33nhDt9dbrVYAHRiq96r4tQ0Gg16z2vdTfeioqjgtFktJ5evFSPAohBBCiEvdpVM+JoQQQggxwlT4pMJCq9VKeXk5FRUVuqJNhXSqYk1VmhmNRsxmM1VVVTqEUqFZVVWVDohUUKVCwmQyydKlS3G5XOzatYvOzk7mzp1Lc3MzyWSScDhMPB6noaGBbDZLT08PVVVVDA4O0tHRQUtLS8lgkeIW7OKBOOr3QCDAX/7yF2KxGE1NTTQ0NOhjicVizJw5k2w2y+DgINOmTcPpdOrndzgcJYNZ/lbF+ywOpV5LBWu5XA6LxUIsFtPnTYV3mUwGk8mkKwCNRqMeWKMmWqtwV71P6vVVsFjcjl58/tR7l0ql6OvrIxaL4fP5mD17Nl6vVz9XcXCYSCQIh8PkcjlisRjBYJDTp09js9mYP3++XndxWKi2iRm6L6PFYtEVmCrILh6Uox77VufyctrfUQghhBDjlwSPQgghhLhsqEAqHo+Ty+UwGo1UVVXpluZcLofT6dSt1SpwVI9Vw0pUYFa8v6LZbNaTpdV+XipIMpvNzJ07l7KyMl588UV27dqFy+Vi5syZ1NfX43a7deVbKBQik8lQX19Pb28vBw8epKKiAp/Pp1uPiwMpNewkHA7T1dXFwYMHgfP7kfn9fl09l0ql6O7u1lOujx07RiqVwmaz6apOh8NRcq7e77l+O8V7VrrdbpxOJ+l0WgeCqjVbnXs1gEZReyGqqdkqMB3abq3OU3GbtnqNU6dOcfjwYWpqaliwYMEF61ct2er8qhZ21Rp/6tQpKioqmDNnDm63W3+vGAwGHawWfw+plmu1ZrWu4pbqi50/CRmFEEIIMV5Jq7UQQgghxo3haLVWoaGqFixu/QV0ey28OQF56MRk9UtNIVYVfMUBkaqgNJlMugU6HA4TCoU4fvw4HR0dBAIB7HY7LS0t1NfX670K1WMtFgvZbJZgMEg6ncbn8+FyuXS1ZTgcJhaLEY1G6e7uZnBwkA984APMmDGD8vJyPXglm83S2dmpw7cDBw6wZMkSPSTFZDJRXl6Oz+crqbYbSe/Ujp3NZnUQmc1m9fuiqiANBoOukvT5fCWTr1X4p15HhZcqpEwmk7zyyiukUinmzJlDRUVFSTipviaRSBCJRHQQmk6n6enpobe3l9raWurr66mqqtLPr6gKU4PBgM1m09WaqnqzeDp18eCgYqMZNkqrtRBCCCFGigSPQgghhBg3hnOPR7h4S3Bxxdx7DX+GPl4NTFGDUFRrtfr95MmTnDhxQlf2xWIxCoWCrpjMZrO6Ws5isZDP53U1psPhwGKxYLVaOXr0KBaLhQ9+8IM0NjbqPQ9VqKr2jAwGg+zevZtFixZx1VVX6ao8r9er283fai3D7a0uQYsDw+JzmM1mAfQ+kCoYVNWDxYGeCpTV+5tOp/W+lfF4nBMnTlBRUUFNTY1uvVcVr+l0mlQqRTKZJJ1Ok06nCQQCtLe343Q6mTVrFo2NjRQKBR12qsepwFFVmdrtdh3svtM63+r+0SDBoxBCCCFGirRaCyGEEOKy8FZBTvHtxQNKiu9/L5/TFgdKqpXY4XDocMrpdOowavHixSxZsoRsNksikSCRSJDNZkvac9WfHQ4H+Xweu91OOp2mUCgwODjIzp07mTx5Mq2trbplWX1NIpEgmUxSKBRob2/n8OHDLF26lBkzZugW37KyMnw+36iGju/mNYorAc1mMxaLBUAP7onFYhiNRj2gB0pDvKGDZvL5PGazmUwmQygU0pWlNpuNdDqtqyFV63ooFKK/v19P+l6+fDl+v1+3X6swUb2Gx+PRobA61uLvnXfz/SeEEEIIMdFIxaMQQgghxo2RrswaziEeQysniydPx+NxvR+kasmNx+O6MlINWFHDR1T4Fo/H9fN0d3eze/duysrKcLlcOsgsLy8nHo/T0dFBd3c3XV1dpFIpGhoaWLJkCZWVlbrCr7KyEq/Xe0FF3qUShr3dZWpxa/RbfY2qYkwmkzq8VBWQg4ODnD59mt7eXh34Wq1WPB4PXq8Xj8ej/wxvDqVR74+atq3a44snb1/s/F0q5/RipOJRCCGEECNFKh6FEEIIIf5quMOhoXs+2mw2rFYrNpuNcDisQyz1y+l06q9LJBJ62rHaT1LtS6lapisrK4lGozQ2NlJfX8+pU6f43e9+RyqVwuFwUFtby+LFi5k8eTJOpxOTyUQul8NsNus9HUf6HIwUNQF7qIsNl1EVkWoauclkwu/3U15eTjQa1YNfHA6HHiKkwmK1R2Zx5aXa+/PdBIzj5XwKIYQQQowECR6FEEIIIUbAWwVOKuCy2+0kk0lSqZSegqx+V4NpBgcH9QAZFXYNDAywfft2APr6+qivrycQCHD69Gn8fj+tra1MnjwZn8+H1WrVr6laj61WKz6fT4ec73S8Y+lvPaah+yeqwBbeHBikhgJVVlYCkMvldDCpBgqpsPHtKhovxfMmhBBCCHGpkOBRCCGEEGIUFYdXTqcTh8NRcpsKy1QbsQom8/k8FouFv/zlL0SjUaLRKFOmTKGyspKpU6dSU1OD3W7HbDbr9l9Vqacq+kwmE16vF4fDMcZnYXSoUNBqtepBPcUTy5XisFF93dC9Poc+pxBCCCGEeGcSPAohhBBCjLKLVcwN/d1oNFJeXq6nLANEo1ECgQDV1dXcdNNNTJs2DY/Hg9Vq1aHa0EErKsC0WCy43W7sdnvJa0207b6HDguCN9vci29Tj73YnowXOy/vNIVaCCGEEEJcSIJHIYQQQohR9G4q5lS4Zbfb8Xg85PN58vk8DoeDm2++merqarxerw4aVXhW3A6sqvjU/S6XS09bfq/HM169nz0YZQq1EEIIIcT7J8GjEEIIIcQlSAVcLpeLSCSC3W6nrKyMmpoafZ/af1DtTzi0Us9kMmGxWLDZbLrFWIIzIYQQQggxWiR4FEIIIYS4RBkMBux2Oz6fj2w2C5xvG1b7E6ohKWr/RlX1CG8OUbFarXoy9tB2biGEEEIIIUaSBI9CCCGEEJeYocGg0+kkGo3qKctms1kPQykUClitVr23Y3H4CFxQ6SihoxBCCCGEGC0SPAohhBBi3FBtxOFweIyPZPSocFG1VRcKBV39WDyFOZPJvOXXX2yYjRCK+vskg3OEEEIIMdwkeBRCCCHEuNHf3w9AY2PjGB+JEBNPJBLB5/ON9WEIIYQQYgKR4FEIIYQQ40ZFRQUAZ8+elYDkXQiHwzQ2NtLe3o7X6x3rw7nkXa7nq1AoEIlEqK+vH+tDEUIIIcQEI8GjEEIIIcYNtV+hz+e7rIKh98vr9cr5eg8ux/MlQb4QQgghRoLxnR8ihBBCCCGEEEIIIYQQ740Ej0IIIYQQQgghhBBCiGEnwaMQQgghxg2bzcZ9992HzWYb60MZF+R8vTdyvoQQQgghhpehUCgUxvoghBBCCCGEEEIIIYQQE4tUPAohhBBCCCGEEEIIIYadBI9CCCGEEEIIIYQQQohhJ8GjEEIIIYQQQgghhBBi2EnwKIQQQgghhBBCCCGEGHYSPAohhBBi3HjkkUeYPHkydrudJUuWsG/fvrE+pFH3wAMPsGjRIjweD9XV1Xz0ox/l+PHjJY9JJpNs2LCByspK3G43a9eupbu7u+QxZ8+eZc2aNTidTqqrq/nSl75ENpsdzaWMum9/+9sYDAbuvvtufZucKyGEEEKIkSPBoxBCCCHGhZ///Ods2rSJ++67j5dffpl58+axevVqenp6xvrQRtWOHTvYsGEDL774Itu2bSOTybBq1SpisZh+zBe+8AWeeeYZfvGLX7Bjxw46Ozv5+Mc/ru/P5XKsWbOGdDrNnj17ePLJJ3niiSe49957x2JJo2L//v089thjXHXVVSW3y7kSQgghhBg5hkKhUBjrgxBCCCGEeCdLlixh0aJFPPzwwwDk83kaGxu56667+MpXvjLGRzd2ent7qa6uZseOHSxfvpxQKITf7+epp57iE5/4BADHjh1j1qxZ7N27l6VLl/Lss89y00030dnZSU1NDQBbtmzhy1/+Mr29vVit1rFc0rCLRqNcffXVPProo3zjG9+gtbWVzZs3y7kSQgghhBhhUvEohBBCiEteOp3mwIEDrFy5Ut9mNBpZuXIle/fuHcMjG3uhUAiAiooKAA4cOEAmkyk5VzNnzqSpqUmfq7179zJ37lwdpAGsXr2acDjM4cOHR/HoR8eGDRtYs2ZNyTkBOVdCCCGEECPNPNYHIIQQQgjxTvr6+sjlciXhD0BNTQ3Hjh0bo6Mae/l8nrvvvptrrrmGOXPmABAIBLBarZSVlZU8tqamhkAgoB9zsXOp7ptIfvazn/Hyyy+zf//+C+6TcyWEEEIIMbIkeBRCCCGEGKc2bNjAoUOH2LVr11gfyiWpvb2dz3/+82zbtg273T7WhyOEEEIIcdmRVmshhBBCXPKqqqowmUwXTBvu7u6mtrZ2jI5qbG3cuJGtW7fywgsv0NDQoG+vra0lnU4TDAZLHl98rmpray96LtV9E8WBAwfo6enh6quvxmw2Yzab2bFjBw899BBms5mamho5V0IIIYQQI0iCRyGEEEJc8qxWKwsWLGD79u36tnw+z/bt21m2bNkYHtnoKxQKbNy4kaeffpo//OEPTJkypeT+BQsWYLFYSs7V8ePHOXv2rD5Xy5Yto62trWQi+LZt2/B6vcyePXt0FjIKVqxYQVtbGwcPHtS/Fi5cyC233KL/LOdKCCGEEGLkSKu1EEIIIcaFTZs2sW7dOhYuXMjixYvZvHkzsViM22+/fawPbVRt2LCBp556il//+td4PB69z6DP58PhcODz+bjjjjvYtGkTFRUVeL1e7rrrLpYtW8bSpUsBWLVqFbNnz+Yzn/kMDz74IIFAgHvuuYcNGzZgs9nGcnnDyuPx6L0vFZfLRWVlpb5dzpUQQgghxMiR4FEIIYQQ48InP/lJent7uffeewkEArS2tvLcc89dMPhjovvBD34AwHXXXVdy++OPP85tt90GwPe//32MRiNr164llUqxevVqHn30Uf1Yk8nE1q1bWb9+PcuWLcPlcrFu3Truv//+0VrGJUPOlRBCCCHEyDEUCoXCWB+EEEIIIYQQQgghhBBiYpE9HoUQQgghhBBCCCGEEMNOgkchhBBCCCGEEEIIIcSwk+BRCCGEEEIIIYQQQggx7CR4FEIIIYQQQgghhBBCDDsJHoUQQgghhBBCCCGEEMNOgkchhBBCCCGEEEIIIcSwk+BRCCGEEEIIIYQQQggx7CR4FEIIIYQQQgghhBBCDDsJHoUQQgghhBBCCCGEEMNOgkchhBBCCCGEEEIIIcSwk+BRCCGEEEIIIYQQQggx7CR4FEIIIYQQQgghhBBCDLv/DwWc1mdgJWCJAAAAAElFTkSuQmCC",
-      "text/plain": [
-       "<Figure size 1600x1000 with 10 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# 이미지를 랜덤으로 5개 출력\n",
-    "plt.style.use('default')\n",
-    "fig, axex = plt.subplots(2, 5, figsize=(16, 10))\n",
-    "for ax in axex.reshape(-1):\n",
-    "    img_path = np.random.choice(train_images)\n",
-    "    img = Image.open(img_path)\n",
-    "    ax.imshow(img)\n",
-    "    ax.set_title(f\"Image name: {img_path.split('/')[-1]}\")\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 276,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAU4AAAGzCAYAAABAX/6uAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9d4AkZ3Xu/atcnXty3tnVaoN2FVkFsBAgCUQSRhbJgG0E2MbXBq7BGIz9XaJtfPG9BINJti9yAGOCwQEjogRYQiCU02pzmBx6pnNXV3i/P6remprZWWklrdgV9GMvmu6u7q56u+rUCc95jiKEEHTQQQcddHDCUE/1DnTQQQcdPNnQMZwddNBBB48SHcPZQQcddPAo0TGcHXTQQQePEh3D2UEHHXTwKNExnB100EEHjxIdw9lBBx108CjRMZwddNBBB48SHcPZQQcddPAo0TGcjwKKovCe97znVO/GE4brrruOjRs3nurdOC1x0003oSgKX/7yl0/1rpxW+/KLil9ow3n99dejKMqqf/39/Vx++eV84xvfONW797hxyy238J73vIfl5eVTvSsdrMEnPvEJrr/++lO9G8fgc5/7HIqikM1mT2j797znPSiKwsLCQvzcddddt+qayufznHfeefzf//t/cRznmPce79/MzMyq76pUKvzZn/0ZF154IYVCAcuyGB8f5xWveAVf//rXT84CnCD0n+m3naZ43/vex6ZNmxBCMDs7y/XXX88LXvAC/uM//oOrr7463q7ZbKLrT54lu+WWW3jve9/LddddR7FYfMTt/+Zv/oYgCJ74HeuAT3ziE/T29nLddded6l2JUavVePvb304mk3ncn2VZFn/7t38LwPLyMl/5yld429vexm233cYXvvCFVdt+8pOfXNdQJ8/Zffv28dznPpfDhw/zK7/yK/zGb/wG2WyWo0eP8l//9V9cffXV/MM//AO//uu//rj3/UTw5LECTyCe//znc+GFF8aPX//61zMwMMA///M/rzKctm2fit37mcEwjFO9Cx2cQvzpn/4puVyOyy+/nK997WuP67N0XefXfu3X4se/+7u/yyWXXMK//Mu/8KEPfYjh4eH4tZe+9KX09vYe97M8z+NXfuVXmJ2d5fvf/z6XXnrpqtff/e53861vfQvf9x/XPj8a/EKH6sdDsVgklUod412ul+O86aabuPDCC7Ftm82bN/PpT386DkGSaDabvPnNb6a3t5dcLscv//IvMzk5ue5nTk5O8rrXvY6BgQEsy2Lnzp38v//3/47Zz4997GPs3LmTdDpNV1cXF154IZ///OeBMAz6wz/8QwA2bdoUhz+HDh067nGvzXEeOnQIRVH4P//n//DXf/3XnHHGGaTTaa666iqOHj2KEIL3v//9jI6OkkqlePGLX0ypVFr1mf/2b//GC1/4QoaHh7Esi82bN/P+979/3ZNcfkcqleLiiy/mhz/8Ic961rN41rOetWo7x3F497vfzZlnnollWYyNjfH2t799VRgIsLCwwO7du2k0Gsc9Zolvf/vbPP3pT6dYLJLNZtm2bRt//Md//LDvcRyHq6++mkKhwC233AJAEAR85CMfYefOndi2zcDAAG94wxtYWlqK37dx40buv/9+vv/978e/S/IYl5eXectb3sLGjRuxLIvR0VF+4zd+Y1U4LL/rz/7szxgdHcW2ba688kr27dv3iMe6Hvbu3cuHP/xhPvShDz0hUZWqqvExPtw5uB6+9KUvcd999/G//tf/OsZoSlx11VU8//nPf5x7eeLoeJxAuVxmYWEBIQRzc3N87GMfo1arrbpjroc777yT5z3veQwNDfHe974X3/d53/veR19f3zHbXnfddXzxi1/k13/913nqU5/K97//fV74whces93s7CxPfepTURSFN77xjfT19fGNb3yD17/+9VQqFX7/938fCMPqN7/5zbz0pS/lf/7P/0mr1eKee+7hxz/+Ma961au49tpr2bNnD//8z//Mhz/84fiOvt6+PRI+97nP0W63edOb3kSpVOKDH/wgL3/5y7niiiu46aabeMc73sG+ffv42Mc+xtve9rZVRv76668nm83y1re+lWw2y/e+9z3e9a53UalU+Mu//Mt4u09+8pO88Y1v5LLLLuMtb3kLhw4d4pprrqGrq4vR0dF4uyAI+OVf/mX++7//m9/+7d/mrLPO4t577+XDH/4we/bsWeUpffzjH+e9730vN9544zHGN4n777+fq6++mnPPPZf3ve99WJbFvn37uPnmm4/7nmazyYtf/GJ++tOf8p3vfIeLLroIgDe84Q1cf/31vPa1r+XNb34zBw8e5OMf/zh33nknN998M4Zh8JGPfIQ3velNZLNZ/uRP/gSAgYEBIAyXL7vsMh588EFe97rX8ZSnPIWFhQX+/d//nYmJiVWe2V/8xV+gqipve9vbKJfLfPCDH+TVr341P/7xj0/sh03g93//97n88st5wQtewBe/+MVH/f4Twf79+wHo6elZ9fzamy2EHqsM1f/jP/4D4BGvx58pxC8wPvvZzwrgmH+WZYnrr7/+mO0B8e53vzt+/KIXvUik02kxOTkZP7d3716h67pILu3tt98uAPH7v//7qz7vuuuuO+YzX//614uhoSGxsLCwattf/dVfFYVCQTQaDSGEEC9+8YvFzp07H/b4/vIv/1IA4uDBg4+0FEIIIV7zmteI8fHx+PHBgwcFIPr6+sTy8nL8/Dvf+U4BiPPOO0+4rhs//8pXvlKYpilarVb8nNzfJN7whjeIdDodb+c4jujp6REXXXTRqs+7/vrrBSCe+cxnxs/94z/+o1BVVfzwhz9c9Zmf+tSnBCBuvvnm+Ll3v/vdAhA33njjwx73hz/8YQGI+fn5425z4403CkB86UtfEtVqVTzzmc8Uvb294s4774y3+eEPfygA8bnPfW7Ve2+44YZjnt+5c+eq45J417veJQDxr//6r8e8FgTBqn0566yzhOM48esf/ehHBSDuvffehz3etfjP//xPoeu6uP/++4UQ4XmQyWRO6L1yjZNrJ98/Pz8v5ufnxb59+8Sf//mfC0VRxLnnnnvMe9f7t23btni7Cy64QBSLxWO+u1arxd8xPz8vyuXyozrux4NOqE4YIn7729/m29/+Nv/0T//E5Zdfzm/+5m/yr//6r8d9j+/7fOc73+Gaa65Zla8588wzjwkZbrjhBiDM8yTxpje9adVjIQRf+cpXeNGLXoQQgoWFhfjfc5/7XMrlMnfccQcQphMmJia47bbbHtexnwhe9rKXUSgU4seXXHIJEHoAybDukksuod1uMzk5GT+XSqXiv6vVKgsLC1x22WU0Gg12794NwE9/+lMWFxf5rd/6rVWf9+pXv5qurq5V+/KlL32Js846i+3bt69anyuuuAKAG2+8Md72Pe95D0KIh/U2YaUI8W//9m+PWBwrl8tcddVV7N69m5tuuonzzz9/1b4VCgWe85znrNq3Xbt2kc1mV+3b8fCVr3yF8847j1/5lV855rW16Z/Xvva1mKYZP77ssssAOHDgwCN+j0S73eYtb3kLv/M7v8OOHTtO+H2PhHq9Tl9fH319fZx55pn88R//MU972tP46le/esy2X/nKV+LrT/777Gc/G79eqVTWLR79yZ/8SfwdfX19vOpVrzpp+/9I6ITqwMUXX7yqOPTKV76SCy64gDe+8Y1cffXVq05Oibm5OZrNJmeeeeYxr6197vDhw6iqyqZNmx52u/n5eZaXl/nMZz7DZz7zmXX3dW5uDoB3vOMdfOc73+Hiiy/mzDPP5KqrruJVr3rVcXNAjwcbNmxY9Vga0bGxsXWfT+bz7r//fv6//+//43vf+x6VSmXV9uVyGQjXB45dD13Xj+GV7t27lwcffPC4KQe5Po8Gr3jFK/jbv/1bfvM3f5M/+qM/4sorr+Taa6/lpS99Kaq62rf4/d//fVqtFnfeeSc7d+48Zt/K5TL9/f2Ped/279/PS17ykhPa77W/i7zJJNf/kfDhD3+YhYUF3vve957we04Etm3HIbZlWWzatGlVyiWJZzzjGQ9bHMrlciwuLh7z/O/+7u/GxdufdRjfMZzrQFVVLr/8cj760Y+yd+/eYy6QJwrS2/m1X/s1XvOa16y7zbnnngvAWWedxUMPPcR//ud/csMNN/CVr3yFT3ziE7zrXe866ReBpmmP6nkRTWNZXl7mmc98Jvl8nve9731s3rwZ27a54447eMc73vGYqE9BEHDOOefwoQ99aN3X1xrzE0EqleIHP/gBN954I1//+te54YYb+Jd/+ReuuOIKvvWtb606zhe/+MV84Qtf4C/+4i/4h3/4h1WGNQgC+vv7+dznPrfu9zyW/PLD4ZHW/5FQLpf50z/9U373d3+XSqUS39hqtRpCCA4dOkQ6nT7ujeCR9u3Zz372o37feti+fTt33XUXk5OTjIyMxM9v3bqVrVu3Aj97xkvHcB4HnucB4Um0Hvr7+7Fte90q5trnxsfHCYKAgwcPsmXLluNu19fXRy6Xw/f9EzrpMpkMr3jFK3jFK15Bu93m2muv5c/+7M945zvfiW3bx4R2P2vcdNNNLC4u8q//+q884xnPiJ8/ePDgqu3Gx8eBcD0uv/zy+HnP8zh06FB8swDYvHkzd999N1deeeVJPT5VVbnyyiu58sor+dCHPsSf//mf8yd/8ifceOONq36La665hquuuorrrruOXC7HJz/5yVX79p3vfIdLL710VYpiPRxv3zdv3sx99913cg7qEbC0tEStVuODH/wgH/zgB495fdOmTbz4xS9+3NSkx4urr76aL3zhC3zuc5/j7W9/+yndF4lOjnMduK7Lt771LUzT5Kyzzlp3G3lH/drXvsbU1FT8/L59+47pOnruc58LhKTnJD72sY8d85kveclL+MpXvrLuxTM/Px//vTZ0MU2THTt2IITAdV2AmMh8qjqHpEeU9IDa7fYx63DhhRfS09PD3/zN38Q3LAir+WvDzpe//OVMTk7yN3/zN8d8X7PZpF6vx49PlI60XlVX5i7XUpwAfuM3foO/+qu/4lOf+hTveMc7Vu2b7/u8//3vP+Y9nuet+h0ymcy6v8tLXvIS7r777nVzgSfqSZ4o+vv7+epXv3rMv8svvxzbtvnqV7/KO9/5znj76elpdu/eHZ9fPyu8/OUvZ8eOHbz//e/n1ltvXXebk702j4SOxwl84xvfiAsVc3NzfP7zn2fv3r380R/9Efl8/rjve8973sO3vvUtLr30Uv7H//gf+L7Pxz/+cc4++2zuuuuueLtdu3bxkpe8hI985CMsLi7GdKQ9e/YAq72Pv/iLv+DGG2/kkksu4bd+67fYsWMHpVKJO+64g+985zvxRX7VVVcxODjIpZdeysDAAA8++CAf//jHeeELX0gul4u/F8Ik+q/+6q9iGAYvetGLTkpnyIngl37pl+jq6uI1r3kNb37zm1EUhX/8x3885iQ3TZP3vOc9vOlNb+KKK67g5S9/OYcOHeL6669n8+bNq9bn13/91/niF7/I7/zO73DjjTdy6aWX4vs+u3fv5otf/CLf/OY343z1idKR3ve+9/GDH/yAF77whYyPjzM3N8cnPvEJRkdHefrTn77ue974xjdSqVT4kz/5EwqFAn/8x3/MM5/5TN7whjfwgQ98gLvuuourrroKwzDYu3cvX/rSl/joRz/KS1/6UiD8bT75yU/yp3/6p5x55pn09/dzxRVX8Id/+Id8+ctf5mUvexmve93r2LVrF6VSiX//93/nU5/6FOedd97j/FVWkE6nueaaa455/mtf+xo/+clPjnntne98J3//93/PwYMHT6qmwZe//OV1iz/Pec5zGBgYwDAMvvrVr/Lc5z6Xpz/96Vx77bVcdtllZDIZJicn+fd//3eOHDmyLr3vCcPPrH5/GmI9OpJt2+L8888Xn/zkJ2P6hwRrqENCCPHd735XXHDBBcI0TbF582bxt3/7t+IP/uAPhG3bq7ar1+vi937v90R3d7fIZrPimmuuEQ899JAAxF/8xV+s2nZ2dlb83u/9nhgbGxOGYYjBwUFx5ZVXis985jPxNp/+9KfFM57xDNHT0yMsyxKbN28Wf/iHf3gMJeP973+/GBkZEaqqPiI16Xh0pL/8y79ctV2SmrPeet52223xczfffLN46lOfKlKplBgeHhZvf/vbxTe/+c11aUJ/9Vd/JcbHx4VlWeLiiy8WN998s9i1a5d43vOet2q7drst/vf//t9i586dwrIs0dXVJXbt2iXe+973rjr+E6Ujffe73xUvfvGLxfDwsDBNUwwPD4tXvvKVYs+ePY94zG9/+9sFID7+8Y/Hz33mM58Ru3btEqlUSuRyOXHOOeeIt7/97WJqaireZmZmRrzwhS8UuVzuGMrV4uKieOMb3yhGRkaEaZpidHRUvOY1r4kpasfbF/l7ffazn33Y430kHI+O9JrXvOaYc0jSp0ql0iO+fy0ejo603u+2vLws3ve+94kLLrhAZLNZYZqmGBsbEy996UvFf/zHfzzm430sUITozFU/2bjmmmu4//772bt378Nud9ddd3HBBRfwT//0T7z61a/+Ge3dkwdBENDX18e11167bmjewanHW9/6Vj760Y/SarV+oVp2OznOx4lms7nq8d69e/mv//qvY0LDtdsBfOQjH0FV1VWFk19UtFqtY0L4f/iHf6BUKj0iD7ODU4fbbruNM8888xfKaEInx/m4ccYZZ3DddddxxhlncPjwYT75yU9imuYx1b8PfvCD3H777Vx++eXous43vvENvvGNb/Dbv/3bj4lC8/OGW2+9lbe85S287GUvo6enhzvuuIO/+7u/4+yzz+ZlL3vZqd69Jx2azWbMkz0euru71+Uonwg++9nP8r3vfY///u//5s/+7M8e02c8qfEzTQz8HOK6666L83L5fF4897nPFbfffvsx233rW98Sl156qejq6hKGYYjNmzeL97znPataDH+RcfDgQfGiF71IDAwMCMMwxMDAgHjta18rZmdnT/WuPSlxvHZiHiaH+GigKIoYGhoSb3/724XneSdvx58kOKU5zr/+67/mL//yL5mZmeG8887jYx/7GBdffPGp2p0OOvi5wfT0NPfff//DbrNr165jWlo7ODGcMsP5L//yL/zGb/wGn/rUp7jkkkv4yEc+wpe+9CUeeuihx9Sp0EEHHXTws8IpM5yXXHIJF110ER//+MeBsII6NjbGm970Jv7oj/7oVOxSBx100MEJ4ZQUh9rtNrfffvuqrgRVVXn2s5/Nj370o2O2dxxnVQdHEASUSiV6enpOeVthBx108PMDIQTVapXh4eFjBF6SOCWGc2FhAd/3Y/FWiYGBgbiDJ4kPfOADJ124ooMOOujgeDh69Ohx1ZzgSUJHeuc738lb3/rW+HG5XGbDhg0cPXr0YVsiO+iggw4eDSqVCmNjY3Hb8vFwSgxnb28vmqYxOzu76vnZ2VkGBweP2d6yLCzLOub5fD7fMZwddNDBSccjpQBPSeeQaZrs2rWL7373u/FzQRDw3e9+l6c97WmnYpc66KCDDk4YpyxUf+tb38prXvMaLrzwQi6++GI+8pGPUK/Xee1rX3uqdqmDDjro4IRwygznK17xCubn53nXu97FzMwM559/PjfccMMxBaMOOuigg9MNT0p1pEqlQqFQoFwud3KcHXTQwUnDidqWjjpSBx100MGjxJOCjtTBzzfWBj2/aE0NQRDg+z66riOEQFEUFEUhCIJVj090XYQQ8ftc10XTtJjMHQTBcYe8dXDi6HicHZwyyAv8eM8n//28Qx6jNJbycfLYT2Qd1r4vOUlUCPGYJot2cCw6hrODUwp5ga/1qn5RDCaExy6FgKX3KT1G6R0+GoMnhIg/wzTN2NuU6/uLtLZPFDqGs4NThvUu4F/kizoIAlRVPanGbe1ndcL0k4OO4ezglOJ4ebtHk9P7eUAQBHieh6ZpaJq2KqxWFOVhBSfWIumpCiGo1Wrrjm7p4LGjYzg7OGVYG5oniyG/SAiCAMdxqFQqxxhMiUfrfaqqiu/7LC0tUSqVaDQav9De/MlGx3B2cNpg7UXt+/4qOcGfZ3ieR6VSwXVdgiCIvUxpPB9tjhNC+UZpNOX75Wf/ot2cTjY6hrOD0wLJIhGEF7jrujQajVO5Wz8TSC9THmuSjuQ4Dp7nPWpDJ4Sg3W5TrVYRQjyqUL+DR0ZnNTs4ZThe6Jg0GvV6/RTs2c8WQgg8z8NxHFRVRVVVRBDQarWoVCo0G81j2AYra7f2Xwi5fs1mE9M0sSzrF5Kx8EShQ4Dv4FHh8VxwyQs3+XmhhwXyaUmncRwn9sKENArxWwXwOMNNJfl5j3KT9TzA9TZUxCN+h+/7NBqN2HAGQUCz3qBcKVOtVsnn8qTTaVRVQR6zAghF/iVzois74vsu7XYLz3OxbRvTNDvG8iSiYzg7eNSQxi4IgrgTxfM8giDAsqxVBZ61IXjyM4QIABHTcITwEYSGpOk0aLTqCCUgwEeJ/s9pO7ScFoHnY9s2tm2H+0JoeGXYa+gGgQhQFZVABHG4qqBQb9RJpVKoioof+PH2rueiqxqKAp7bxvd9UqkUCIHruuiGgUw1avqxl87xzFIgvPD7CfOWzWaTVCqF67q4rkutVmNxYY5CPovnOhw5coTJoxOkUil27NxJNpMBRaVereJ6AbquYVkmqqbRchpomoJl2yiKShD4tJwWtVqNeqOKaRpksxkMw8DzfEBB037xurNONjqGs4NHDWk0k8RqwzBWtfodz2AmP0NRVERk1DzPQ9d1XM9D1UKvq9Vq0d3dTbvdxjRN2m6bltOi1QoNZ1dXF+12G8MwUJQo66SAHhm1RqOBrusYhoGmavhB6Nlls1mUyHOLWxFFaDwjc8/i4iJzc3Ok02lGRkZIpdMAuK5DaHy09b1OVoJmlYibqaiRRx0Z9WitZC7T9zyazSbDw8Ps3f0Q+/fvZ2BggI3j42TSadx2m+npaaYm5zBNk56ebnr7e8jksmSMLG2nie+5BIoS+uEKOE6LcrlM/0A/gnB9TdMM909EXmvHdj5mdAxnB48K0mjKC1E+lsZSPr/WsK6l2cjnlChGr9frFAoFRBCgqCq+6+G0WhTyBTRNRUVBEaBrGpqiUq1XAOKOG4XQU22322iahmVZpFPpsDotSeB+QCadRkXB87xV+6JA6Fl6HnpkuD3Piw06gO95GIaBqj4yiVzaJM910VWVMHz2MS0rDMejzp624+D7PoVCgTvvvJPDhw+z6ylPYXzjRnLZHJValUMHD+E4LSDsPS9XKqBBQEA6k8EwTRQEgRC0Gg1Ky0s0Gg3a7Tb9/X2oStgD73s+bccllU6dpLPhFxcdw9nB44I0nHD8/Kf0RJNUmGRxQwhBuVwmm82iqSpuu02r1UIEAjPRiqiqKpZp4bkebrtNo14nnckgggBBgKqCYeiR9ynQFAU/8PGEQEEJc4S+QChBaEwRKEjDHsTbCFb3iuu6TqvZpF6vk8nmME11tQe3dk0S/1WEwHFaOI5Du92mt7eXZquFbVnhsbous7Oz7N+/n0ajwQUXXMDGM85AVVVm52ZZXFyk3W6TzWYpL1VQ0HB9j2q1SrPVDL9dESAEvu/RbLWo1WsA2HaK8nKFYrEbTdNQFAXd0B9vZrgDOoazg8cA2ZmSzGV6nhcbGbnNWnK7fD5+zveRZZ9apYo/6GPoOo1Gk1arhaGvXOR+ZDhVRUHXNFRFobRYCtME8jtVFcPQIQDPa6OrBoHvE/g+iqJiWAa+7wNEuU8BBAReQKvdxDJsdFNHRN6m4zikUimUKC9Zr9exLBtdN/B9DzAfca1kTnN5aQnHcbAti5mZGTZt2oSu6zRbLaanpzl46BDnnXceuy68kEqlwuzMDKVSiabjoACmZeEHAZZlouvhzcFptXHaTdpuKx6h3Wo2aTkO6Uya7duGqFarqKpONiuwLRtNVR93Ta2DjuHs4DFgrfhEEAQ0m02CIKCrqwvf91f1RK8V8oAwrPY8DwWBqmq0Gg0818XQDSqVMk6zSS6fjw2dCCs/BCL0Em3TYmFuDq/dpr+/H9/3UTWVdDaN8AWu66DZGkHg0Xac0MBaYeGn2Wxg6xaCcL/L5Qq1Ro3RoVE0PQuE+dFarUZvby8AjuOg6zqqqqAoYtXxKcf8sQJd12jWGywtlnAcB1M32P3Ag2wY20BgBFTKZZaWlsjn81x11VUEQcC+fftYLJVIpWx6+3rZv3cfS0tLjA6PkctlSaVS2LaNZugI4VOuLLGwsEAgBI7jIAKBIhSGBoepVqsszM1Tq9To7ekhZdvYmQwooaPaSXQ+NnQMZwePEtIIho8kST30bFSKxeKqIhEQVcxF/B7P83BaDl7bQVVYKZYEAnyfRrVG4IfFHyDODfrtNs1GM/YES6USU1NTpNNpms0GigIKvaSzWVJ6GrfVYmpigmq1im3bjCqjLCws8NOf/pQrr7wSXdf50S238B//8R9s27aN33vzm/Ech3qzRbvdJpfLMT4+TuD71Ot1BgcHw3yiomAYGsevoydeEmEHj+xDL5VKlMtlUFXK5TLT09M0Gg22bNmCqqrs37+fWr3Ozp076e/vp9FsMDw8jK7rFHJFhB8QiAAUJUwhtBrMzc3RbLbQNI2RkVHSqRS7d+8ml8tRKBQwDIulUomZmRmGh4cxLCs0/GrHaD5WdAxnB48BKwZDU2FxYQ7HcchkMtSqZXK5HM1mHdM04+qzgkAEYcjebDTC4oXjoAQCXdNRBKgoVKtV2u02lmWRy2RRICzG+AHVao1qpYLjOGiKyvDgEJVKhcpymWq1jJ2yKRaLoCgsLyxwxx13UK1WKRSLbBgbQwF+etttjIyMcGD/fm677TaOHDnC1i1beMNv/zYEAbVajd179hIIweDgIIqiMDExge/7GKaJvkpd6OF4kZFREgKCAEMLq/sTExOhMXZd7r7rbiYnJykUi4yOjlIulyktL7Fl6xa6urpQdY1MLhfegCJCu2EY6LpOEPjU61Wmp6dZXFykWOhifHycnp4eGo0Gi4tL/Nu//RvPec5z6O/rZaC/D8/zaDVa61KpOnh06KxgB48aMmyWIfnS0hKKopBKpSiXy+Ty+Zi4btk2WkSTkd0srVYrJHw3WwSut0rtvF6vh7lSw4gr7oqqUq/VWF5aotls4rRaNBtNLnnqU+np7+feu+7innvvJQh8Np95Jl3FIgcOHGBxcZELLriA8U2bALjrrru4//77CYKAbDaL74dcUF3XOXToEIcPH8aybVothw0bNzI4OMj8/DzNZpONGzeGnnGUmlCFiA3QetQrkejk8TyPdruN4zgcPnyYZzzrmSwsLHDPPXejqCoXbtvG5s2bcV2Xc889F0M3QFUQCjF/1VdANwzUqKDUbIY3n97eXkZHR+OOI9/3MQ2Diy6+mP/6+tf57//+by7cdSE93d0QhPqcstNARPT+Dqfz0aNjOE8zJKu5P+v+4mQBRwrqyjB6RSsSRNRHbpgm83NzuK5LPh92tzQaDXY/+CDtdjsMPxNGM1mJnp2dpbpcxjYtBgYGMAyDUqnE0ckJCoVCmCv1PDTDAEWJDe7k5CSB73PuOefSaDTwfZ8NGzag6yrTM9PMTE9zYP9+CoUCF154IRs2biSXy+G5LiMjI5x//vls3ryZfD5PV1cXe/bsYWZmhgcffJCuri4MwyCbDb280tISCtDf348pWxZVNbwRCEGtWkXTdTRNC7mlvo9uGGQyGfyI7qQpKroe3gTq9TpHjhwhnU4zOztLNptldGyM7du2rdCqtKjlMjJqgQh/E1VR0VRQlPC8kAZf07S4WIRkp6oq6ZTJ+eefzwMPPMAPvv99dE0jk8kwODjEjnN2oig6TlvmbdX4t9c0bRX7oWNU10fHcJ5iJCk8yZP0VJ6wyfENUmxDejSe69Fs1mk2mxSKRSYnJ8OwOpdDVVXq9XqsyNPd3U0+n8eybczIW9J0HZPwuKu1Gq7psmnTJtQo5+e0HNJDabKZTGisIw/PtG0ymQyO47Awv8DQ4BDLy8txocppt0O6ja6Tz+cZHh6mt7cXJ+JJGppGV1cXFzzlKXR1dWGnUnGXk2ma9Pf3Mzg4yOzcHPlCIerECb3okDAPRLxLmdMtl8sUi0XS6fQqrqfjtOJKP5GRbbValEol2u123O101o4djIyMUIjywpqmRW2UoMhcsiTqo8TNAkpE8tcTHq8QxG2rIhAI32NsbIx6vc49d97FkSNHaLfbbNy4kZ7+Xgb6h46RrXukpoUOVtAxnKcQ66mfw6k3mtLj0DQN13Wp1+vk8/nIADRjwwgwPT3Fli1byedzNBrNmHfoOE5UtGiQy+cpFrviYWSyUBLyDoO4N325vIxpmqRSKQzTCA1A5Klmshk0VaWnt5fFxUUeeughenp70TQtrMI7LeyUzdiGDQwNDmLbdshpXF5G13UymQzZbJaR0VFEEKDqOvlikY0bN9LV1cXAwACqqrKwuEgmmw35oVGBq9UKWxhle2SpVKJUKuFFhHhFUejt6UE3dDzPw3XaWKaBbOMRCCqVSljIyqRDcn46zeiGMbK5XGy0YvX32GiCpmpRaC3C56NTZsUbVKKim+TGBnG0YKdstm/fTq1aY3Z2lkOHD1Or1egfGmTXUy6i2N21ij4GYbHPsixgpbW2g2PRMZynAKer2ILv+7EepOy+cRwnFJrI5/E8j3q9TqVSwfdd5udnqdWqFIp58vkclUqZqakJLMvi/PPPR4jQYFQqZaqVMoVCAcuyogvbJZPJoGs6tUYYwh46fJjxDRtQNA014U1ZpoHbbmOn01x44YVs3bKFmZkZ2u12OAe7WGRoaJC+vt6wk8ayIAggTnUoiMDHdRzajkMQBNiqipVKkSsWabZa7D9wgFQqxebNm8kWiriuS6VSoVarUa1WOXr0KEtLSwghwnA+k2F8bJStW8N0hOs4EARYpollmhAZfVTIZrMIBY5MHGVoaCjmdqIoaNHNRN6sILKNkYaJEp0rgRBoauhShqkPyY1Vo2ggMqSKiqoE6IaB53pYVprzL7iAbC7L4PAQ+/bu4Stf+QqTE1M88/LLGRoawrZtVFWNik5BnLvuGM3jo2M4TyGSPd2nA6TnJ0fKWpYVE8GFEFSrFZbLy3ieR6GQ5+DBg/T29sZhaRAEoSErFPA8j02bNmFaFvV6nempKW677Taq1SojIyPkcjlS6RSu4zIzMwPAps1nsHHDOLlcNt4fEfE2gyBAINAtk+7eHorF4qqUgm6aqFrU2tj2cDwHXdHRTR1V00FRQVOxTDs0SIGIi0PjGzexacuW2EN0Ix3LcrmM53l0d3fHffEyLWFZFlNHj3Bw3z42bNjAj370IxRFYWRkBNu2GRkdBVVlYX4egEKhQHd3N9u2bWNmZoaurq6wNdUPRUaSlW5l1SkRepmaotKoV8MQ3TATPNqV3w3C/LMQIcXLT+RczzvvXDZv3sTdd9zJJz/zaX58249JZdL09vaRz+cZGBhgy5YtmKZJqVQim83G+egOjkXHcJ4CPFIIdKpCJMMwVsmbGYZBu93GdV0cx6FcXqZaraIpCinLYmlhkbN2nEW72aIqQBWwcWwDhmFgajql+YW4KKQK2Lr5zPB7TIO208bVDHw7DFHH+zfR09ODGiktuVE4r0QcUMmfdCKPMZVKocrEHsQGSFU1NNMmbZkQKAT4Uf5PwzBtatUG2XwGVA1VUWUUTOD7uG0fK2VimCY9vb0htQni4kk4n1zB9z0W5he4+eab8TwPO2VhWRaHDh6i7Ti87GUvg8BHUTV6+gc4cGA/y9UK+a4ifQP9eCJgoK839vBWqUlJz1NZCb0RoGga6XQ61rkTgRc61Yoe984LQST0IfD8ACtlA+C6HkHgoZsG55x/Hq973ev4wr98kcHBIc477zxM02R2dpb777+frVu3UigUOkPdHgEdw3kKcDzJtVPtfSqKQq1Wo9VqxRzMWq1GuVxmYmKCSqWM77mkMtnQ8Lku6VQ6KhqFuo9nn312XABptVqh0YyqwNlsNlQq0rRYBs4PAlzPi1sbXdeN832SOC8fJ1s6RfQ+CA2+qmnR5wmCwA1bL1UFFZ2wHz70ztKZNO22CyhxRVkIgQhUFC3WNArzjYaBGhmxZlTB1/XQeHb3dPP8F76Q5VKJI0cPk8lk6O/rp7y8zG233cbExAQ7zj6bTK5AtVoFwup8tVaju6cnHtsrmRMiCpFVVUVR1bAkpCgoSpjjbLdbzExOYacs0pkMtp1aJTaiJH5DVVmZOaSqYfcSqCACDE3joosvJpcvoutGmLawbTZs2BBHGp0Q/ZHRMZynCEkV7yT1IymA8bM+gWVOUggR5yI9z6NcLlMul1FVhXwui2WZtFotANLp9KrqdLG7G891UVQVp9mMq8VGpEIuYWoaqGpsPGO1JFVBJTQegQjwvMiYyJLJioUACHuvwyfC9VNjdmJiDZXw/yMhYBUdIQI830MJ1MiTVBGRwpCqrLSEqqqKaZoYhoHrurTb7dALhFAnMwjwPBff96mLWvxZuq5z//334fqCVCrN+MaN2LbN/Pw86XQ6DM0jo5xUilIUFeEHtNvt0IPWNDzXZXLyKDd+73sMDg5wxubNjI1toFAsAkrcix8WiML1BNmx5Sek88JsRDabZcuWLUxNzcTaoDL9IPObyQJhB8eiYzhPAZIya77vxyfo6XCS1uv1WCDYNE1UJaQYLZWW6O4u0lXIoxsmtXotDJnTaVJ2KjQmioJpWdiWBYqKFXlVRGYvDHl9hB8aQdkrLUNWAE1bKQp5vp8QIz72RiPpTeEagqJqKKoSVqKJBpOhoCpqZDvVFV6kpuF70ecTGnAlYTzjG1t08whirzfA9wW+56GgYJomfb19lEol6oBpmnR3d6MbBvVWk0azTf/AIBs3biSdTmOaJrl8/hiOriT7IwStRrjejuPEXv9tt/2Yu++6i9qWzWSzWXp6eskXCtHNYEUPP1R7kukelSBYUaEKgjB/rUZhfzabodkMaVJCiFDWL0FL6uD46BjOkwrBI59z4SkeGs7Qq/F9n3Q6ffyT9uFGPMTjE+AEvvzh90wI2m0nvKgyGRRVJZsJBXyXl0oUCrmw7dDUEYqCadpY6RSGbsXTqwIvQDU0EApqRMz2fT/UstQMVMMgdI4UAhEQBAJVTRL+FQIhCPwwt5csUEgPUIu2kzca3/dBEWgoUYEoOp5AoGhy1ETodWqo1NsNUnYq1g31Az8sFJkWvggQQZgSCF8XNOo1nHabTCaDbacJhI/rtgl8SFtGOOKj2aTfHKRvABbm55mZnWXXRReSL3RhpVLhPgvB5s2bESJUlJdaoWGlXBD4Lq7TYnFhnsnJCRYXF2k1Q0HiG2+8kcGhQQoRL1YKIGuGGjIQolytoiqx/qbkfQoRoETSc17EybWsNP39fUwenWRpcZF2uxWnUsJ8rhpxSOU51Qnfk+gYzpOI0G4dO8Y1SSaXCuChkQ3wXIf5+XnO3LIF3wtDQQDDNNF0A1BAgB/4sbelqRqBiLo7xMrJLYTA9VxMw4y0JhV830eIcNyCH/joqoYfFVKA2PioqkqtWqHZqNPdVcTz2kxNTbFl85mMjQ5Tmpult6ebvr4++vr66OnpY/u2nWFoKEKDpCihsRTCR0GNZ+TouoYujwURiUsoqKoWTwtMOmCqAqjHnpqaufo5qfpuWesL80otzzVvIpvOrHymNMR6uK2uaATI8Dn0BNOZHKblRaMuWvF6G4aJousYikrvwGD8+/QNDNLV28c99z7I+KaN9PX3h40AhokX+Ajfi/KrRMWf0KgZlsXu+36KYeh05TIcPbiPG264gbGRUc7aeiaKqjMyNML4hnEGBwdBVWk2W6TS6bjBU7ZoIqJIRgXXbaNqUUpCCG679VZ+6ZeejqGrjG8YpdHsplqr4XttdF3FdR2MqCtptbpoBxIdw/kzQDK0BOLwXCbws9ksbcfBNE1qtRqKotBtWXH81Ww1sUxrxcOKQi5JKE/O39YT1KCVHJVKEF1IklwdtumtaGkGQcDBgwdpNBo06nXKpSWqy2XuuP12vvlf3+BVr3oVYxvHMU2LwBf4amKOj6qGdB8gniKW9IRJ/K0oD6+NcRpgbUcNELMMfN+PqT+KotBoOlERRkPXtSjP6tPbN0C2UGRmepbZ2XnabZeuYiEsgilROsLz8CLerK6p3HfffQTtNmdsHOeHP/g+9993Lz3dRbqLeeYXl7jsGZezY8dOenv7wp3zPFKpNAhBrdbAsqzIY4zU7QnTF2Z0/wiCAM/1UARMT00xMDCApmlkMxny+Xwo+uw6IQ+1g4dFx3A+wVivpVLTNHwv9GB836dardJoNOjp6aHdbqPrOr4foEeas7ZpRcULQAhURQnDSt8PlYXWVuUl99HzIVIPE340VM0NjaQ0nJ7nsVQKBYH37t3L4OAgmq5z4PAh9u3dy2D/ANdddx2Dw8MIwhDTNG0UsUKjiSvDK0cqD3j9RTnNnZdkgS728qOiTzwnKCoeJVkAye1UVcVK2XQVu8OcaRRhLC0t4TqtkMdqW+iGQbVS4aGDB8hkMmCZ/PjHP+bwocNh6I3KQ3v38ru/+0YGBofI5guYRpjXrVcrzMzNs1wpU+zqpr9/kHw+H1biE5GP/F1UVSWTzTG2YZzdu3eTLxTI5fPx+ZPsWZfvO81/qlOGjuE8iVDWeFlJwY6VbZQoJ6dgGgauabK8vMzY2BilSDMxk8mQiWbJhN6Diu97KEp04Uaf5bptwIgvXOmRCkEoriELDtEFLb9b/i1EKHxbq9Viekwul6NUKrG0tMSOHTsYGRpmYGgIp9UK85vGsQrv8vHPW1Fh7fEkbxJALIIiea5SxER24njNJkHIDQpnJanRaA7fi1s5K+UyC9GIjOWlJcbHRtF0nYWFRaanZ+jv7+falzwHXdeZmZ3GWl6m7XrUag0836O3vx8CgdNyCAI/MUJYjTmggVBkdgTdNOkfGGDfvn1MTkwwODREPp+P6Fwi/m+HkvTw6BjOk4gwVRUcc9LJx/F/kU0qSsyXzGazcYW5Wq1y5MgRenp76enuQtMMBHKuj0Lge/h+SJuZn58LZdIymYieIqvJ0gsC6XPIWeWZTCb2NtvRLBxd17FtOxb06OrqYuOmTfT19KLqOq7joKorhmPtMcqL7efholsreJH8/ZJep3ws5fJku6rUzNR1nbbrQxCgoKOrOpqmJ7x9n1arSaPRQAhBKp0mX8hTLpeZnZulWqsxOjaKoqg8+OCD+EEQjSgOi5CZbI6hkRHSEZ3IiF4LfyJlJeeprqRRBALTshkZGWFmZia+6eaLBUQgIjWriCZ1Slb/yYGO4TzJWGs41lOgUTUtVO3xQs+jq6sLRVHo7+sDIZicnIx7sQ1dJZvJoekaCJ8gEHi+i+8FpNIpDu7fj+e7jIyMUigWAEHbaeH7Lql0Bk2VxPBQ5ajVapGJlIc8z8OLpi1KIvTi4iJ9fX0MDg6Sy+WiSo0glU6FBQixouT+SMf+ZMXaaZwSSWOapI9JD162p+q6TjqdxrZthHBou27IbVVWwn7535SdIp8vYJomA/39eJ7Hg7t3s7i0RCqdJpPNcucdd1Gr1SgUCtgpm2w2R1dX2HaqR/tRKBQwDSPimGoR5zWSmpMp5yi9EgjByOgohw8fZmZmBt0wQgUry4ymjEY5WDqh+vHQMZxPEJJ5MgnP82i1WqRSqXCmTTXsPe7p6WF6ejqWQpOCwLqucu8993LGxo30DvSH3kAQoJsmtqUjEBzYt5dGq4mu6yHVJfCplZdZXF5iw+gYWiYDiS4cORZXFjlk0UN2C01NTcUSa0meaTy3HFZdTWtD9J8H47lWi3JtyiV5fNLDzOVysWZopVLB8zyKxSKWbSEAzw/X3TJNTD0kmKOFnl42n8PQDY4cPMAPbvo+d9xxB9lMlq1btzA6Okq1XKHZbGJbFhvHN9LX10cqHdLFVAiNn24yNDKCZUcMg4RikiIiLzJiOqiqSr3ZYHRsjOmpKQ4fOoQQgq3bt4XHKM/bNTeODlbQMZwnGcfTOBRC4LRaVCsVlkolil1d5PJ5Hrj/fu677z6GhoYYHhlBi0L1+fl5du16Cl2FInfdcQf79u3jjDPOYHx8PCRJ1+touk69VmN2bo7hoeHwhPcDGvU6k0eO0tfVTcq2UQnzbEakiakoYbeJoetY+TwiCDhw4AD79+/n3HPPZWxsLJRMM000EWpJWrZ9DE/05/WierjjShpT6ZnKsFyG6LVaDcdxWF5eJpvPoekKgQgHvjWbjXBqpWGE/0yL0uICt/34J6AITNviKRdeRC6TxjAM9uzbz52338ElF13I5jPOwPddFubnMCybQChUdu9hdmGB4eGR2OO1LBvZdOAHcYMSqqJEAiKCqakphgcGqddqTEXGs2+gPyLB+0AnVH84dAznSYYUg5BYG+4FQcAdd9zBwsIC+Xyec845h+c///nccMMNfPITn+DKK69k48aN2JbF8uIixWKRi5/6VA4fOsTU5CSHDx1iYGCAjRs3ht6nrtOo12nUaogo9NeiVID0/tpum2qtjgDK5TKWZeG222EXSy6HruvMz89TLBYZGhqKh6Q5kcG0U6mo4hSGfvK4jofTQVf08SBpHNfLdSa3S1LMAFKpFKlUKpbjazYa2KkU6VQa13NZXl5GU8BIp+N2ykwmx5VXXsnc3Byf/tSn2LZtK/v2PkR5eZnR0VGuePaVmLrB5OQU7XbY6hoIqNTrLJbKTM3PsnHTGXT39pE3dNpuO2rpjOTmov11PQ+n2cB1WvT1DXD48GF83w85ocDExASZTAbTtI/PiOgA6BjOkw55cUm1HkVRUDWNIPLcpGq567pMTk7SbDY599xzecYznsGBAwfYs2cP999/P5qqkk3ZXHDBBdi2TX9fH+lUitnZWSYmJtB1naGhITzPo1KpcPToUQ4ePMjI6CiKEs4ed10Xp9XC9YNYmX3v3r1s3ryZTDZLLhvKt01MTHD06FGuuuoqMpkMgjBvZ64Jw38RL6X18tXyhpRUNlo7DtkwDAqFAuVqBQiV5HVVI2XZuG44A52I1eB5Lvg+//iP/8jC4gLD9WG2bN1OPpej2FWkUq7w0AP306xVGR4apFAooBsmPYHPyKjgfMvgjDPOIJ1JoyjqmuGVCq7noSoKgedRXl7G91yq0TmTy+Xo7e0lm8sxMDS4ImwcHvATvr5PVnQM50mGHKYlVXVc143H2JZKJYC4+AIrA8x834+LNrJCW1pa4uabb6a7u5udO3fGnDvXdZmfn4/FGCzLolwu88ADDzA8PEw+n8c0TZrNJm3XDYd8RX3VEBoAN5KLk2Mfurq66Ovrw7KsMKQLD2bdnOUjPf55wfGOS+Z1k40Ha1+XxaN0Oo3vh9VzXdNDOTwVqtVqHDEEfsDEkSPUajXO2LyZrVu3Mtg/QDabRdM0Jicn2afrLC8vk8umsVMpUpksA729WHYGxdDp7u6OzwdNC4tDbddDN8JZ8EIEOG2HSrVKMZ/Dddssl8sxdUohvFmqUbeQ5Az/vP62jxcdw3mSISkpfhDEaunLy8ssLi6iKAqFQoG+vj7yURW01Wpx5MiR2BB2d3eTSoUJ/oWZaY4ePYplWeGMn64uunp6QFGYOHqUUqlEIESszr5//3527NjBxo0b0XSdZrOJ63kYpoWua/R0d9PTE1Zj6/V6XEnv7e1l+/btq2bnxEToBBXn542n+XiwXrVdPp98LZNO02g0cdttEGEoL4SP63qIwMc0zXASqG5w7nnnMTw0xLbt28IUiqbheSHRvn9wgJmpSVpOqHqvagZdPX1h00QQ0Gy28AWkMplw2FwkSCKCABKCzwpEpP0wGpIFraRWgqKwks/uGM510TGcJxFChIWZVDrNcqXC/n37KJVKWJbFli1bGNuwIaxsR3N8lmqhwlB/fz+qqrK8vIxt2wwNDdHX10fzjDPYvryEFhV2JO+zb2CAVCrNgQP70XWdYqROXqs3uOn73+fXN2wgCAJajoPTamEaJoEfUMjm6CoWyefzsSycZdv0mSaFYhHdMEAI/DVzh9ZWlzvX0upKe3Iq5NrXlKjRQVWSkoEKtp1CBCGrIZVO85SLLmLLti2okfGTob8hBMMjo5y5ZRu1cgXfc/E8n9LSEoY1RV//AL6icPToUXTTpLe/D9OyMUwD2zRxvZCCZhgG2VSanu5uDhzYjyICent7WSqVmJ6epq+/j3Q6TeD7qJraCdUfAR3DeRKhKCqFQoEf//jHzM7OMjg4yEUXX0x/fz9uu81UlNPcsGEDxa4u8vl8HB4NDw+HF15U8Q6CgEy+QCafo9100PWwo6PVdPB9l3yxi3PPPZelpTL1eg3Lsmi3XW699Raq1TqZTIZ6vUG5XCUIYHFxMZxJHoXo8cUdeZaWZdGOUgZB9FqSq7hK27IDgHXFUpJIVt3l+N9QzzOUcHNdh1azSa1axbYs8oUuGpUyTrMZd4JpmoZl2wwMDPC85z2P++67B8MwGRwcRlE16q0W4xs3omg6AZBOZzANg+VyOSTF6wbCContuqaSz+dIp1JMHD7ExvFxlqI00qZNm0KJvqgpwjDNhNZpB2vRMZwnEUHgMz83y/DwMFu2bCGby2FG4yfmo9kzGzZswDTN+KJb28InuZPy7/CxQLdCtRqhenitcEiXohs868rn4LpO1E4p2L5jB919AxS6u/jvH95Cy3XJqWGr5ezsbNjp4noUCwVMy4qNqKIoNBqN0MuM6DXJ8bPw85vLfKyQ6yJ/p2SfOrAytTJBXTJNM7wBtlrhSIuIprZnzx6GhobCDqJUCsOIxJY9D8UXZPM5CtkMmWyGB+5/kHvvuY++gX72HjjAR//qr/jVV/8aT9m1i56eXoSA7mIXfuCB8LEMeZkLUimL887eyX1338Xw8DCFQoF6vc6ePXvYtuMsUuk0rVYj/O1PA33Y0xUdw3kSoaoavb29AKECuuMws7jI/Pw8CwsL2LaN7/v09/dj2zaGYSAAt92O+57DYVyRnI1Q8T0Py9RoRmrquq6TSedAUWg12tipFIZuhgYwCBjfuCnsK49GVJSXyxi6QX9/PzMzM+Tz+bCrJZ2O+84l/0+JWj4NwwgLSlK8Y1UO72e6pKc1dF2Pc9pCiFgHQNO0VepT61GZ5DA8w9BjIed6vR5yZi2LVMpGUULup+M4tBoN1EDQarlsGB9neGSUxaUlFkslzj73HMY3bgSgVFoEVHK5DKZp4vnheeG2w/+mbJu249Df30+z2YwFX4IgwE6lwmmith0ej+etGiLXwQo6q/IEQJLYpyYnmZ2dpVarkUql6O3tpaurK8xXqmrYmSEEmq6jahoKhC2QQTgyolyuhp1G6RStZhMIxx709vbiROGUIBw3oelaKNSr66Guh6YyPDIS05+y2SypVIpMJhN6QkIQeKFX60WCypZth4Y7oQQUG82EGlzHdq4Uy7RIFEPyOKVnKavuSU8UiPRRwxugpoUFHMMw0LXw5ijnIOm6gWWZGIaF65ZQUEhlc2H04elouk6uWOTpT7+MielpDh44yNLSMr29vfT29jA5OUkmnaaru4imqCxVK5QWF8lls+iaTqEQSty1Wi2CIAgHwcXGPxSO6ZQCj4+O4TzJEEKwvFRicmKC6ZkZms2wYjk8PMzAwACpVGpV3lAIEeeSarUatVoNz/MQAtptD1VTEfLii7wZ3/fwfBfLDos+sfFUos8lDL2zuSztdjh+wU6lyOZyIcUlEjVWgiDuP9c0LVZIirmoiZ5tEX0uouN1JpGUkpOepwzd5evJcR9KokgUprTVOJ8pFe5XPiP8XVRFxbJtXM9H1TUg1DuwLYuzztpBvquLQEAmkyGbzcSznZaWSuhaeNP03Db1eg3fDefZu67L8OgI2VyWbDZLpVqlVFoin8/jum00TQ8pdR2si5Oe/X3Pe95zzEmyffv2+PVWq8Xv/d7v0dPTQzab5SUveQmzs7MnezeeEMgTOhm6JsM0x2nhuS5TR4+yb88e6rUaxUKBTRs3sumMTWRzueiiCcc6yJk2TrtNtRa2WS4uLlJeXsZptcik0wwODpDP5ejt6aW/t498Lkfge+iaggh8IAARACIcd6DIfQoNqmYYmJaFZuiks1nsVArNMBAo+EIg1JCgL71NVdVW9lHIMF2J/6/jb65Adg7J9IZMjySNH4SpkHaiKCdHZ7TbLr4fAKGqv67r2KlQTKXZbFKvN3A9D90wsVJpKssVPM8HTSMQ0GyFY07OO+88Ltz1FHactZ3BgQEsw6C3pwdFgeWlJarlcthTr4djPur1Os1Wk3yxyKYzNrPpjDNIZTJMTc0gUOMpoGvnInWwgifE49y5cyff+c53Vr4kkSd5y1vewte//nW+9KUvUSgUeOMb38i1117LzTff/ETsykmFLNwkQ692u42qqrQdh4WFWXRFYX5ullq1wtlnn8PGMzaRzebQTINGvRmOORChpxGOumgzOTnJ7MwUABtGx+jt7cW0LBRU0FSarotpGShCgPDRVQVFt2g3m+hyIJoKECACMM1wJC4Q5VJ1Gk0HTTdw2h6mZcajNLzoeFaPn1Di/mZWP/uEr/GTGbIwJCvoEOYoJYIgoNVqxWF96KWKSApORTesyBi3qTfruF6AnUrT1z/A4sIcdd8lQGCrVtxW22qVyRWLBJ6HqkWFKM8jm80wPjrG4uIiszOzKIqCbdksNZpMTc8wPDYKqAQo9PQPcE46w/33P8j8/AL9/f3oUf6985uvjyfEcOq6HnfGJFEul/m7v/s7Pv/5z3PFFVcA8NnPfpazzjqLW2+9lac+9alPxO6cNCQrpjKZn06nmZubo1ar0l0scOTgfvbt28OuXReSy+fCHFfEwUxnMjSbTRQlDMuWlpaYmAg7Ri644DwK+Ty+6zE/N8fc3DzFYig3l8lkaDWbLJUWaTTqdHd3UyjkSaVSTE4cIZfLkc3nQ8PotFBUPR5p245U5mXBQlXVWKw2HEx5rGeRVAFP6m92CPCPDTJ0FyIcoSzJ5q1Wi0ajgeeFM4i8SGug0WjEI1TkOaeoepyfliMyTNuiUavTrNUwDA0FLRzcpussLy5yYP/+WHdA5rq3bN1KtVbjvHPPB1Wl3Y5Um6wUGzdujDvfYDUdrYPVeEIM5969exkeHsa2bZ72tKfxgQ98gA0bNnD77bfjui7Pfvaz4223b9/Ohg0b+NGPfnRcwykrixKVSuWJ2O2HRZKzJw1QOp1GVVX6+/vJZjNMT02y78B+LrjgAr7+9a9z+RVXMDA0SBD4tBqhQZNjMWZmZqhUyoyOjDAwMECjVuXOn94ejpft6qK/v49bb/0Ji8tL4AfRBVWn1Wxgmia7dj2FzZs3UyqVyKTTqCg06nWOHDnKGZvP5MiRIzRbDt09PXQVi6FIbXQRruUfyosjpDT5q3qwk0a1Q0t69JBtrq1WCycSjbajtIhsaJBhfvIGJ/U9NU3DMAy6u7s5sH8fur6SH/c8Dx+BG/gYis7c3FxsIAuFAsVikVKpxP79+1lYWIiVm7p7elCi39w0DeRkgcHBQRqNRty51vmdj4+TbjgvueQSrr/+erZt28b09DTvfe97ueyyy7jvvvuYmZnBNE2KkVK5xMDAADMzM8f9zA984AO8973vPdm7+qiRPJHkSd5qtRBCUCqV2LPnIQYGBrjjrjvJ5HJ4QUCptETW9cgXCiwtlenu7qZWa8RCwhMTE5SXlrEsg3QqRbvd5v7772dqeppMJkexWGRxfoFqpUImnSKfz7O0tBTO8a7XAcLcmm6gGSZLSyXuuOMOcrkcA4NDZCIhD9kBJL832RkkUymSnC2P9RelJ/2JRHLYm7xpSe1TwzCi3vWVinuSP9tqtWJtAkVRKBYLAHEuVaaOyuUyrmMxNTUV1wuy2Sx33H47tm0zOzuLEIKenh4azSYjqVQ8CkXT9FVUqvVmLXVwLE664Xz+858f/33uuedyySWXMD4+zhe/+MX4TvZo8c53vpO3vvWt8eNKpcLY2Njj3tdHgyQnL1kg0nWdyclJDh06FI5qtS2qtTrj45uw02k838fzAqrVOul0hkajSeD76JpGJp3B1DVEEOB7HinLZu+ePZSXl+nv6WV4bAOaaeBsaBIIgW2ZzM/N8oMf/IAHH3yQXbt2MTMzQyqVIpfPk8nlWVpeJpcrRCFhyOVDrAzi8jwvFjPWoxGwMgx3HCeu8K4VsOiE6Y8Nku6jKAq2ba/y5tf2uCdzpLZtAyvi17IpQg6Ik1GPrMbLz3Ach3K5zOLiIrZtMzw8DISe78DAQFR5z8bvl9V7+f5ki23nRnl8POF0pGKxyNatW9m3bx/Pec5zaLfbLC8vr/I6ZXvi8WBZVkyxOJVI0nTk37IraHFxETuVotFsksnlGR4ZIZfLY1jhJEPP80ins9TrdXw/rHBaBZNiIU9pYQG37XDk8CFmpqbo7u7m3HPPoauvH0XT0BUV07ZB+Bw5dIj9+/dz9913sWXLFur1OlNTU6QzGYaGgUBg23Y0y0g9xuBLb3OtcZSvydA9GaY/nBfawcOj3W4DK22X8neQKZF2ux03HsDKuSVD9+RvJg2nNLryxmfbNiIQcfSTzWZpNpsMDg5yzjnn0NPbS7MRjg/O5/PkC4WwKJgo2krPUu5Hp6L+8HjCV6dWq7F//36GhobYtWsXhmHw3e9+N379oYce4siRIzztaU97onflcUGerPJklmHN9PQ0tVoN27bDaYGqSk9vD9l8jlw+RzqdJpVK0d3dTaVSwTRNAt/HNA2yuSyKqtJo1BC+z7e++U1s0+LsnTsZHh4hX8iHxPV0GhEEiEAwPDzMC69+IYZhcNNNN8W6nnv27KG0uEgxnyeISNZEdCchglX7npQ9k3nNkDu6wjfsXDgnB0nhj2Q1Xa57qArfjPOfUlIQWBW2CxHeEAuFQiwbKEP4QqFArV7j0KFDtFotLr74Ys455xw0TaOnr4/t27dj2zYzMzOhE2LbzM7M4LbbcQ5Vep8yv7p27EsHq3HSPc63ve1tvOhFL2J8fJypqSne/e53o2kar3zlKykUCrz+9a/nrW99K93d3eTzed70pjfxtKc97bSvqEskwyzHcZiamopEG4q4rkMml2Xh8CKpVCqUaTN0XN8Db2WCZa6QRVUUlpeWmZ6cZNPGDXz+H/+JXCZLf18f+WIXum3RajYJpAiuZULgoxs63b19bNq0iVtvvRXHcdiwYQP5XA5VVTl8+Aibt24NKU2mFfMJvWBlBrisysoCRLvdDjuHLGtV+N6ppD9+SD3O5L9kL7v0LFutVpwDlQ0J8uYsPdLAd+PfxPM8qtVqOPAtlaJaqeI4DoVCgeHh4Vg0ZveDDzIyPMz27ds544wzaDQa3PS972HYKSzbpqdHwzDMOAXwWNNpv2g46YZzYmKCV77ylfG0xKc//enceuut9PX1AfDhD38YVVV5yUteguM4PPe5z+UTn/jEyd6Nkw4ZUoUjWMOKtG3bXHzxxUxNTdFuO+TzOf7pn/6JF179fHp6e2NytK6bNBoNqtUavu9TLORxnBbttkM6ZbG0tITrOAwMDOAHHo1qBSUQ2HYqFFqI+oZVNQzzAs/jpS99KY7j8O1vfxvDMNi+/axIW7MHU9PjvKmu66CqkaiEG++TvEjb7TbNZhPf98lHQslr0QnPHzuSXiOsNEwkhZB9348FVqTHuUo3IBrd3GjUKC0uUq/Xo/OpysTEBI7jUKuUyWWzdHV1MTc3F4/EMAyD3Q8+yOTkJI7j0NPTw/DICONnbCaXyyFQ44FzhmEcMy6kg/Vx0g3nF77whYd93bZt/vqv/5q//uu/Ptlf/YRivXyf9BJGRkaoViscOLCf7u5uNm7cSK3exLIsFEXH83yaTQfP8xgZGUFTYWmpQaVSRngetm2HqjROk9tuu41qpcrA0DD57q5w7EakoqQQeiLZfB7T0GPmwsLCAgsL8xTyeXp6emIvxND1cGRHs8VyeZl8Ph9zAdvtNo1Gg1arhaaF4iTJC+V4BYKHu6jWeqe/KBfe2iJPEmu1OpNFOsdxVhlSy7LCnnFWuJ++78djnX2vHecxC4UCvb29tNvtMARP2diZNEIJOZs9PT189atfxXVdDD3k9Q4ND/OMZz4T3TBQVA0UBVVR1/3dO5HGw6PTq36CSNIyPM+LKSFaNNunUqkyMzPLeeedh2mapDwBqhKd9GGlc2xkNPIyBJlMBk0bRFMUZqen0Q2dpaVFpiNKSalS4YXXvJihkTFs2w5DNN+HwEdRwLRtNm/ezN133x2rL01MTKCqKuObNqFreuS5qHHvhwzxZIguPWdZnU2OyVhrIJP917KlMPn62gr8z5PRPJ4ROZFjXFtQW1ugSxbiknzaJFVM5kebzSD0EhPrK1W2JK+4uztU+F9aWgJgx44ddHd1kclmyeZyqIqCoWmgG+uyJjoFwBNDx3A+DshEujzx0+kMmzdvpt0ODZbrerScFo7TJpvNkslkQupIFPIrioIiAo4ePcL+/fupVssUigV0w6BarTA9M8Pw6IZQNcnzUBCx8EIQhPJ0vb29HD58ODbO/f0DZDOZsKtcUWi7Lu12O74AZRgYD5JLzFyXWC+3GQRBHOpLDmFy++O97+cND+ddrn197TZxvjkqxMl8cpJjm/RQk0ZM5ji1KLxXojZf3/fp7u6mXq+hqiqmaWBZFrVajfPOO4/NZ55JNpvFNM2QE9puh6pcK3t4spfoFwIdw3mCWO+ElheCpml0dXWxefMZFPJ5KtUqmmZQr9Wp1+tomsb42IYEjSm8uNqOw3JpkYf27GFicgLT1Nl+/nmMjY1hp0Piuh3NM/c9L1RR0sOcp+e6ZLNZNmzYwL59+wARSc0ZOK0WqVQKRVHDpL/nxheO7/urPJpkri058kFChpGysCGRrLyux0k8WXgkQ3S8104V1rtxrPU45bol2RnJbi55I5PbyCKSaZph5dswsCKFds/z6Ovro1xewvd9KpUKKTuFbYcTUlUtDMlDVkaAYZq02m1sWwXC6CfUJli9rj9vUcPJRsdwniCSXpUMqaTija7rZLOhPFerWSedSqFrJocOHqTZaoUkZCFoNpvYto3jOHHX0U9+8hPmF+a59qXXgvApLS4iFIXNW7bQNzgUXjiKgmXbBJ6LH3kMduRVnnnmmTzwwAMsLCxw5MgRBgYG8FwXzzBoNluYlk0m3U2r7Rzjaa4Ns6UBXHsRua67iq4kt03ePJKf82SnMq29CazNAT6cwV5rbOTNRn5OMvQGYvK6lJST3rwbRQqr2A5RPzuAZZrxeee6Ltu2bWNqaooDBw6yuLDI817wAoTn4QsBvo9CpK9Qq3H4yBHOOvscVI1w7vrDeM4d47k+OobzBLHeCbSWmC/8gHazTbqY5siRI1TLFbq6uxkaGKTVbJHJZKjValSrFXRdY2FxkcmZaS644AIqtQpu2+GXnn4pmzZtQjdMdDMNihpX0lVVRbcsCALwwwmJRw8fJmVaDA0M0t3dzejoKKXFEj2qSjafB0WNW/nWu+iTXiQc61m7rkszElGWF7BcD/lZkkIDrFKOeqLxZEgNrF0LKdIhjaf07qTqurxRyep6klsLxM0UtVoNTdPYuXMnX/va13jh1S8I1yMQpCyLhx54gHq9juu6nLVzJ8WuLqaOHOGr//qvPOMZz5CagdHvfewN4sl+83ui0TGcjwJJqkbSaMQdHm2Xo0ePUl5eZm52jg1jY/T19aEpCnYqRa1Ww3Ecent7qDdqpDMpLrxwF/c/cC/C87n00qfR29uDoiropgmKQrlcDlvkDAPhewg/AFWlWW/w3e98h9npGZ773OeSSqc5OjkZFqFGx8OL0w9ouw5+EM5eV6KK7nrHJZEsDsVCEomxHskimQz9f1ah3fGoUk+08ZSfnwyz5eO1+7bWI0+G3cnnpfcpPz/Jz5TGVQqEqBGdzLZDL1NENzfLslBVlcHBQR584EFSKRvbtpiemmZwcJBWq8Xy8jK333YbrVaLdrvN0y+9lB07dmDEN/xQY3Vtj3qnSPTw6BjOE8RaQrjjOFSr1fiuLoRAeD4PPbibvr4+Nm/eTFexK/QQgoDlUolUJk0+n6fZDPOe+XyOaV3H9TzO3LyZ8TM2YVsmStQqKYB0NgOEBlolzIvOzc+z96HdTE5OcuFTnkI6naa0tESlUqG3tzeeIaOZBmqk8q6qaqz2Lo9nveNKivDKED3ZXSKRpMvI90lDcbLXHVYKK/Lv5L4ntzuZ35lE0rCs7apZr8tGfobU5kwaJblWydTIWtpScjup42lZRlwYkv91HIezzz6b2277Cblclq6uMMIZGxujWCyimya3/eQn7N+/n3a7jWEYbNm6lZbnxyM6dN1YdUN8ovLVP0/oGM5HgbXE5bWFE78dhrWFXDYKt1rRDV3BNHQMXUfXtUhazMQPAhYWFujt7aO/vx9N09ENEwWFttNGMxR0VSOyeDTqdWZnZti7dw+TR48y0NfHwvwCRw4fQQDF7m4ymQyCgMAH4YYiy5oeih37YoVSJEPqtZJySb6q9DZlp1HyuGWbJqwo/6wtMp3sItFao7U2V3syv0tirSFb65klt384z1e+N2kc175PviaFWBRFidc9/F0UNC0a4eu6IEJ9z0Ihz+DgIM1Gg1azQcqySKXTOI7Dg7t302w02HTGGeTzBQzTZN+BgyjRsLhMJkculyOTycRMj+Rxd7A+OobzUSB5YUiSuaaFhtD3fdoth0wmTX9/H+VqDaUsyPhZ0pkM2UwKVI3A99CUcAyFCESok6loNOpNpqdnGR0ZwbZtPNdFVX1arTpu28N12yzMzXP0yBEOHzzA/NwchqYzcXQCgJHRUYaHh7Btm7brYBo2QvioihKLfQSuTxD4UeeQQmhDV6q3K0YhiI1mGFJqaNqKgHNSmDdJaVpLa1q7ZmsvxuOlCNbbfu0+rvVuT2aq4Hgc1bXMg+RN5njGU96MVFUaXlgZeydTjfKGJqIWWAfX9dB1LUqRrIwzUTUNTddR3JBAb6dS6IHGxvFx5ufmqFWrNJsNXNelVCpxz913M75xIzt2ns3g0DClUonDhw9jmKGnGQT+qor+2nXvYH10DOcJIuktyL/T6TTZSO9SBAGtZpNidxHDNkn7NrVaFc1Q6entDhPwCJpOk7RtIRRIp1Js27qVG264gWqlxuLiEoZu0d/XR+C5OM0mk4ePsBSF4fNzcywvLeM4DhNHj7Dnod2cf/75XHTJJWzdto18IRSurTfqZPqzqKqG5/v4voumG7TbDkIIDMOOu4dctx2JO4QeiGzDDD0egWkakXhuOK4t7GTxVrVurlehl2v2cOuZNFDrbZt8TqYF5No/kUWoh/vc9Y7z4fKBjtNcpb4Pqwtw8iblum7MtGi35ahmE9s2I55ngOt7qEJD103SGY1Ws0HbcbBNk65CgWwqRbVaYXl5mVqlzL59+8hkMmw/awfDo2PoukH/wBCFYlfcVNHBY0PHcD4KrPWwpFZiqO7dol6tsLi4GJGQiyyXl1iMlLdlONRuOfE0SVM3GB4e5tWvfjWVSo3Dhw9z1133UKtWqZWXqJQWwXPj+TL1eoPZ2TmOTExwwQUX8Ju/+ZsMDQ3RMziAYVk4jbAdLwy/BUIFTdEIotBaXryyWi73HVbEcWGlk2ht3i2ZBz0ZYfLxvMykIU1KsCXzqU+WPFw6nV7VOgkraZJkykNW0xVFiTi4StyVBoQsjNmlMHzXNXRdBQT4AagKuqbiqwq5XCh+3Ww2uf/++3n6M59Bd08vatSQIVBIRaOAkzhe4a2D9dExnI8Sa0NCSddpNhs47Tbbt28nk82GA9Bsm0qlwtTUFAsLC3R3dzM0NEShUFjJG+oa3T099Pa26enpCvvHG03mZma46TvfIvAFd959F7OzswwNDXH22Wfz4l/5Fc4//ynMLywwMz2H6/qkslk0Xae7uwc7laLZaOIFAS0nNKa5fDEWjQBWheLSYErF8WTVN0ljCotgoGn6qu0e7wW2Xk5UhubJgpB8/YnIaz6RkGssCz3tdjse8ic991QqRaPRAIgpbu12m2q1Ghd1env72b37IeZmZzAMja1bt5DvH0B4beq1WridaYbnQtQ9VCwWsWKVLB8UDSHkELbTm8p1OqNjOE8Qa6u7SeOSTqcjrzJLMV9AVUHRtNjbkPkmXdc59/zzcdtheGxaJrpq4EVhWiaTiRWKxkZG2Dg2yj9//nMMDw/z4l+5hmK+QMtpsVypcOddd5HN5dh14S5yhTyu69FoNkPjBjieSzaTIZ1ZUaGXBR9pkJLh49rOFT0ShpAV+pUKu75uaL6e97je+p0I1nqYSXUhuX/rpQROR2O6tlNLepFJBSRFUWi3VwQ85FgNaWhlsUiKd6hqOEn1x7feSjGX56lPvZh0Lkfp6FEa8/P0OQ5dvb1s2bIlvEEGPgZhyK/pBr4foGvHv+Gdjut4uqFjOE8QawsD8mIIldZDFW5VBVM3CLxQ9dtNVEfT6XT4GUGAGc/f1kBSS1BwnTaB1MIE+oeG2bHzbEZHxhgcGqLZbCJQGRoaZnR0jO7BAVKZDIEALwhAUdFMC9MyCRyFtuvTbIZSdrl8PjaAaw2/9JplL/161XV5HMlJn8m1kduu9/yJrG1yjdcOjFuvY2m9FMLpiHAM9Go2g2VZq8avSG9epkiSnrX0+l3XpVyuYFkWPd3dFAs5KpUyU0eOcsstt9Df34+qhCkXQbhO559/Pj29vWGUETmYQkQ5Vv3YS79jME8cHcN5gliPfpIsUoQXMiC7aKI8YrvdxjTNML/ZbrMwP09vby9GRHAXQRAS030fTVVjEQ8iKsrZZ59DvVZnenaGluOQSqfZsHEjIyOjmJk0KmG6wPcDBEqYzwwEmhZ6in7E4zSijpO1AhMQXkiO48SjZJMen6QprRe6J9fmkdbuRNZV7staek4yt5l8/skARVlJJ8rjkjdaaUxlQS7paSaFj+V6p9Op2GtNpSxy2SyKH3D06GHKy8sEQbhtpVqlGQ2EA2g0GpimjWmZKMrqdezgsaFjOB8l1l60q0NGQFnJHMVqN6pKOpNhemqK6Wi4mhb1HiMECuC7oRCHGhkzOfJiw/g41UqFI5MTKJpGoVgkk8uBpuK0WmQzWdrtNoEIZeySI2gVRY4w1mIB5qQ3s5bQLvuow2MRMU8TiCvDmqau2mY9LzN5g0n+vdYgrkfdWdvbnfTG5H4/Vs/2VCC8hx5biU9OF3VdNzJuYfQiC0nJaaS6rtPd00O77VGv13BaDbKZNOPj42QyKeq1KkeOhAwMwzColMvYqTSoCprmkC8UsFI2INC003e9nizoGM5HieNRZ6SnpOsqQdTGphkmhp0inc2hGSbTszOgKiyWSnheODI4WeFcXl6O84oAehS2uUFAV3c3Rq1Go9Xiwd27GR/fxPYdO1AAp1Kl7XmYphmOYXBcBGqcLzPNlQFc8rOT84ZgxSNNjnOQYbO8oFd4iCszdNYaw7VGUxrMZKEnOVkzuaaOI+lSK+Nvk8b7eMWo0znHGaobKcfcpJI3HzlrCFaGu0ljmRyh0Wo5cZdPo+6y7JXJpdIUi0V6e7oxTZNKpRJ5rSqBEJiWha5ZGFFjheOEXW7p1KkffvhkRsdwPkYkCyky9yefM6MwvNVqUalUYoqJ53nhia1qOK0WjUaDDRs2oBsGhmly7733UiwW2TA+Tm9/PwQBTqtF23W5YNcu2u02tWoVIQS9vf1hHAjUG3WazSa5XA7btulKZ8nlctRqNYC4yCCpSvKilV6NpCrVarVwvlEUjkujlazEg4KuG6sMovyOtbnPtcZzLUk82Yklw1VYKQZJo2JZVmxAnmxzvmNqWGKt5DE0m01qtVqsqSnHm+i6HveqJ7mflWoTXY8k5YpFCvkcCjA3O81yaZGJiQlyhQJnnXMOB/bsQSE0vj09PZimHRpS0yRsQjr9bjJPJnQkUB4jkqFusmoKKrV6AyEEo2NjZLJZSqUSY2NjNBot+voGWFhYYGpqimq1Aoqg0ahRq1bYv28v5eUlgsAj8D3Ky8vs2b+Pm37wfR58aHfYzlko0N3dQ8sNyevVWjikS+YvJSm/VqslZslEvFHTpB1NNpQDwur1Oq1WqNyUSqXiEF0IEas/SY9I5j2T/E9Jq1o7o13+V+6XnG2UNN5yDeWUx1Qq1JF0XZdarUaz2cQwjFUtn0nPVSLp+Z5uEGLlxiKr5+VymaWlpXjOkK7rOI6DZVl0dXVRKBSiYuPK5akoSvxbSEWj0lIJFIXeaFxKq9XCiXKbW7ZvXylaKiqu26bddkKjmcwndfCY0PE4TxDHy2uufS4Mj8MwyLZtuopF1MjjsyyLw4cPY5sG9957L3fffTfdPd0Mj46yb/dDsXybgkK9VuWee+6hd6Cfrdu24TgOR44cRgSCRqNBs+3yS7/0S1QqFYQQ5PN5+vr6CIKAaqWKqqmJHFobIVboRzKHlpyvLqcxrvWkj61cr4TLx+uwkeK7yZD0eGu4tgiSNLzJIspaEQpZ+X8yFIrWetrJ9lTpico1WNuhJt8nhCCVsmk0mqtuOkTvz+XypFIpWs0mk0eORMP9VJaXl/E8QTabw7JthAjX3NDD3vcOHhs6hvMkQghBIEKFbt/3MAyTru5uLNtG1TQGBgY4evQoPV1FNE2jVCrx3e98l/POP5+5mRl0XadUKrFv3x7sVJq222ZgYIC9e/dw9OhRRCDQVBXX8xgZGaXttKhVKuF3all0TSdQA9rtJo1G6EUiAgKxomSU7GKRXowM1WUhIhlaH5ufXC0tl+RbJscKJ2e4w4qxSBpiuR/JLiFpkKUnpqpq3I64Xth/uhtPuV/J/v6kQZTHbNv2qjbStcZWURTUaCKlCHxUPTKc0U0qk0nHFXnbsqhHUUOo22mSSqVBUfD9MOfaweNDx3CeZAQiNG6+H0Sk+HycNxwfH+fIkSNhYSifZ3FxgVt/9CNMw2B5eRnXdTl48ABHJw6TLxTYsGEjfuAzNTVFrVYLQ2c7Q1dPD5vGxwk8j+WlEtlsFk1RCHwPAbhthyDw8TwXz3NDby7yNGXuMggCTNPEsqyYeH3MsSS6dlbykSuhdrJlMOmFJnOq6/EuJSRdS4b5SdrT2uLV2v1br0p/OmI9z1GuazLvvF7v/Xq/iRABgRAEgUBEvFzDCnPQSaObzWbx/Aq+COI0hwhE/H0dPD50DOcTAEFoQIEoxxgu8+jYWJioj0jQqqrFea75+XlUVWV+bpZ6o06xWCSbzXPnHbczNzfLxvGN5PJ5isUi4+Pj+G2Per3O3NwcqVQK0zQRgWB5aYlavc74po2UKxUajTDfaqdSx3iWsjuo1WrFRitZ5ILVRZ+kB5nMYUqPMClRtzZEX2vckt1Itm1jmmacqpCGc0WH0jrGCz6eMT7dkLR9yf1NFtWCIKBarca/R2zo1hyvpmvx7xN6623wA4pWkXKlAoRts3v27OGcc84hnU7Tle4hlyuiajpBIFbk7cIv/xmvxs8POobzZEJR0NSwF9gwww4OPwhQCC8O27YZGh4mZRqcddZ2Nm8+g29985sYhsFrXvPrlEolysvL1Go1XM8jk8/htFuMjQxz+09/gqIoceHgl37p6czNzeG5bZxWE9d1sFM2pdJCqDqvqVSWlxAI0plsbCht247DaJkDlRex5HEmL+pkvk16f2tVimROM2lMpbGVxjQZjktPS1KfpHcp85lJMWXpISXTBcnGg9Mdsji0NlUhc7Ty2GXRp9ls0mg0Vq2TYRjYto2l6HieHw7u08LuMsdxEL7P7Mxs3MCwe/duenp6GBkdI1PIowgtbIQQAl3XCALQTv+lO63RMZxPAIIguthFECfvJTaMjeG1Q0Ly2IYNbN+2jf/8z//ks5/9LC960YuwLQvP88gaBhs2bWTT5s3sfeghent7cZxQbiydTpPL5XAch/LyMoZhUFpcZHpqmoGBAXoHB3nogQcQQtDV1UU2k8H1A9KZTNxNIjmTyfAYjqUKrc0t+n5AEHhx6+DavnVZdU+n0/Fz8r9rQ0+pAiSNhDQuUt9UFq3ke5PbnO6eZhJrie9SWUuuqVTP8jxv1awh+V6pwC8E8W9i2yaqmqK2XGZxcZHFxQXO3LqVkbExMpkMt99+O3YqTSqXxWt7BIKw4YKOo3ky0DGcJxNC4HmhzBdEF4yihMn46ELo7e3FbbWisEuh0N3N85//fP7z3x02nXkmKdOkUi7TdFoMj42yf89u+np7GOjvBRTabZfFxUV+/KNb0A2DpVKJMzZtxPNcJicnKBYLLC8u4Hsuw8PD6HpIbLfsMJyX+chkxVt6mslCkHxdVrRlaC0E6LqxKnxfb2zwWoO5Nuxca3DXK0TJ7dYK7Uqs9YxPRxzvxpGkfbmuS71ejyOCTCYT34SSBtZptfA8D10LK+KKokSk9zKZTAZNUbBMk6GhIX70ox+xf/9+soU8+VwXhm4gFPA8/xjRlA4ePToreJKhqgqKGhkC1qqSCzRdR02lCHyfwA9QdZ1cPs/Yho1oioZpWnT19JL1fTzXxfV9Mrk85aUlFhYWqVar+L7PyMgI8/PzWJZFvV7HcRxqtRqqqjI9NcXQ0FBoeHQVy7LRtLCAUKvVYkOZbGOUvdJraTJJb8/3fTRNj6u3ya4XyRNN9rM//Dqpq0J2IMFRVFblOZOpgbXjO1b4sycbYs3fCo+VvrM2LyvbX+WxJz1+edxJz1++r9WqE/geim5FVKQA0zRQFMjm8iyXyyiqSndXN9u2bWd6Zgb1nvs448wt9HSH+giBgI7dfPzoLOFJRehdKkAouaHEl1sUeIX/q+nhc4GP5/soqo6ZSuMHggAVw7JQfJ+lpQVSmRyO6zG/UKJWraEoKoVCjpRlsbi4SFd3F+XyMrVaHRC4bhvLtrBsC8/z0aKCgxAKzWaTVrMZd+KIyPME8KKOlfhIlFCAxE3kHKVRVNUVEQogHs0hRBDzRSU8z014WiKiwkT5Tt8PJc+iziTf98L8sMx7ouB5LoHkbEbjRrzAByEQgrDvWraBHofVnTTia6vxSawQ98MxFgqhuhGKNJyJ3nwhEjHvao93vb1YG66Hv8mKUUwaS9nNlbxxKYqC8H08r41haIjAD/PaponruliWheu5tF2XZrNFJpdnzDTxUaKOsDR5w0BVOsnNk4GO4TyJUJQVn0Rbc4KuvXhVTccHXMdB03S8QCAUFUU3QNXxXY9W20PTDEqlZar1Orl8gaGBATLZDNMTE/i+TzpjMzMzQ9tp09PTh+97DI2M4rTbpNNpNF3H8z18H8rLy3EVW16oXmJ2d5CcsS5W5N0s00REXUiqpuH7XpwjDb1MK8ET9SMh3vCil6M5Qi81XCOp4uMHXkjUloJQhPOXdFVDjUbW+l7kbaoKiJCHmNTpVBVtxSFMrO/aNU9iPVL+ilcY7R8i+sxIi00aTxGZZxE+Dt//8J7oeqmE5PTL+JxYk/5IPuf7PrqmRCOiPQLfpdVooKtqWJE3DNKZDKqqMTM3z9TMDFdeeSXVWoNms5nomVfo0DgfPzqG85RBQVE0NN1EURS6unsxTBtV1cPXVA07leb++++np6ubsQ3jdBWLYc97xH8MgoAHH9xNEPh0d/cwMDDAxo0bKVdrFAoFtIhq1Gw0I1WdOqZphhVay6LtutQihfF0Oo0ehZBupFDu+348kK7RaMTVcsGKdyaJ9LCi+COfl9SntaTvpICIhBQgURQNJWFAktV44BgvLTTGyipvM5lXlO9ZtfKJ15MeXfh8xHOMvGc/8OM55qqqokijnjCEyjpGWygr3/Vwdmq9oplUgG82m/i+T6FQoFqtoimQti0s08CI1rrRaDA/P49mmGRzOUzTZHl5mXvuuYezzzmP8fHxWHNA5lWTtLEOHhs6hvMUQua2hBAMDw/HVWYICzC9vX0865nPolGvk0pZ+J5LI8pxqqrKzMwM9VqD8fFxhoaGyGQyNJtNUqkUqqrSajRiUdt6vR5xSo1VBkWKa2Sz2TDFEBUkZEumYRi02+34/bZtY0RqSUC8nax2y+dlESp5rGspTZqc2KiqKKqKHvX6Q0jj8gKfABEba0SA9PJC3qgaW631vMgk1iOTHw8iCOIwXVOBZDfPqhD9ON91wt90nO+PcsqtVotms0lPT0/Y899qxjxPmU8ul8soihL3uSuKwtLSEkNDQyxHjIuBgYFw+mm7TaVSIZ1Oh11lHTxmdAznKYT0coIgoKura1X4pkQVUCncAaCpAi2l4Qc+jUaLI0eOcO6557JhwwZSqRT1ep0DBw5w3gVPCTuRPA/dMOOQT7ZXLi8vY9v2KoqPbdvU6/XYAEqDqapqLASSSqViLVFZ3Gm32/HnrzWm0kuTRmttkUfOQFrt8a1Uk2WHU6wTGlkkVVVRE0bTCwKCwAdWuKXreXJr116uddIjhgAlCMN0SRJfVSYSIuZmKutogz5WJJkFlUolFkaR65tOp5mvlDFNM/Kww+9fXl6mXq8jFDUWYmm1Wlx00UVs2bo9/p0nJyeZnZ3Ftm127NhxUvb5Fxkdw3maQBrNpMiGpoGmapER9fBdl4W5OX56x0/53re/w3XXXUer1Yw6ayTjKSRTK0o4zbDdDqdZqqoaTeN0SKfTseamJFtLQ5isaIe5WC02XqZpokeGThrN9cQ2ZEi/Xm86EHtLyTERK/8VKIqINSyT4XRcaYsUfnwhIAhbEJMqROshuR8Pxy1VFAVFk7lMEed9k4YdHsEoJ/73RPzPJHNBRgfyRqTrOvV6fZUIS9ivHkBkOMPcc2jEDcOgv7+frVu3hYVHRaFUKjE3N0e73WbLli3U6/WOx/k40TGcpxgPF2JKT65SqTA9Pc305FEmjx5lcnKC/v5+hoaGmJ2dJpfL4fsB7baLqoajhO1UKm6zC6vUBuVyOS4OSQ9V5tFkaJ0srCT3ba2hkx4hrJC6YcXwJzuG1uYnZXtm8jvWrkPoka7mmxIVl2ROUwSJLieU+LW1xji5nsczmitdSAHCD6v28vNI5CmTHqq2TudS7DnGdKMV07ne/kgkearyRiX795vNJtlsFhEEsRcu39lsNunr60M1zLj1Np1OY6dsXNdn//79LC4uYlkWo6OjcftqB48PHcN5CrCe97P2ZA6CgFazxXJ5mf379rG4MM/czDS1SoV8vsCup1xAs9lE03TyhSKO41AqLYVG0PXI5HIEAZimhabp+H7A0lI4lzuTyWBZFo1GI+4Xl0ZQ5h7l39JIxLnRBGXG87xVBjUeFZLgVkraknycFLRIVrKTXlxoOBVQQq/P94N4O1VRw+I2kiwv4u3lP2mfhAgSVis0rgkLSFgxT6QsRahuRRBEVfVjO5RE1L1zPMpRspgVagOs9prXpgjk38lGA6lvKr3/eIBeovVUida2Xq8zNjaG6wexh5qKeMLlcpmpqSkURWFoaIjh4eH4N+vg8aGzgqcIaykz8oSWj13XZXFxiVt/fAv33H0PoyPDbBjbwGB/H93d3YyPb+C+e+8NjaCdouW0Y+9RUVTcVhuhqui6gWnZOK3WKhV1eWHL/KZsA3RdF1XTIoUnP6YryVbNIAqN2+02XjSuQ+YgpaFNktflKFxpeKWABYAgQBCElCKUhCFVIuZPQCD8uM865J6Ghi6seHsgIsOUMJwybA/WjPaQXNDwu4lvAgpKZKC9SIU+zHsIGRIDiqahG3o8ukLmGeXHJO1rEHmG4aykFRX34xWtVoxsKGgsfw/ZeqnrOs1mE9uy4u2FEHjtNktLS2QyGcq1GtVqNc6XCyG4++67GRgYYHx8nFwuF+eVpWh0B48dHcN5miB5gYf5Q5dyuUx3Vy9/9I4/otlskE7ZZDMZAt9lcX6esbGx8KKq1yktLOC6bszRXFpaoqe/H0VRcCLFdnnBVyqVuKc8k8nEIzfk8wor2pqS9iQr8kEQUG80KJfLAKuKTNIQS49GVuxlkSnZVeT7fmQ0pTcWr0RsQOX7hVh/uJuIvEZVC7tcQ4OaINcnWjXj8N8w1koWxUZUKuLff889zM3N0mg0cBwnrEwPD7FhwwYGBgYpFIrYqwxPyOmU+500nIaxcjNcewzJ7eXzzWYzzmeG00t9stkszWYTXdfjYhEQj3XO5XK0XJdqtYbjOHHq5ZJLLok1DTzPi7UFbNt+PKdqB3QM52kDWRyCMN+WzWY455ydnH32DgLfJ5NJI3wPz22jaSqpVIparRblNUPVpLBzKSzyVCoVCl3d6MZKd5DMl0puZrFYjAtFjcgYisiblD3icviXbOdUE+GkNNRSz1MaRsdx4jEd+Xw+Dj1hZfRwuJ+hV0c0l8dzHQzTQFEi7U8UMqk0XtxdFHqMrudSrVZD71VX0DU9InWH73PbbarVKqlUKuZEyv2D0DjZqRQiWFFed12XT3/609x1113k0mkKhTy5XI50Os2tt96Kaug885nPJJ8vMD6+kac85Smxm+n7ARCsEnJOGqhGoxELlkh2AqzwVOVaN5vN+Aajqmq83ezsbDheutnASBzD8vIymUyGPXv2kCsUGR0dxXVdDh8+zMjICPlCV8zbfDIoST2Z0DGcpwhrOY5rEQQC1/NQlJDfGBo/BVVREQFkcjlS2SxTE0epVirYts3GTZswbZt7776bbdu2YRgGTsLjkxMri8UinufFEmaSFN9qtVAUhWKxSCaTodVqkc1mkSMYKpUK2WyWVCrF4uIiPT09x8wRkhXgZGUYVvrQkzm88D0KfiRkIaczel4oyKxpoYdl2XZMcHfaDp4bUrRM0wwr6sDExAT1eo1cLsfw0BDFYnEVUyDZz27bduhJRhzS0vw8X/7yl9m9ezfXXnst5557DsVCAaJUwyt/7df40If+L0eOHGFwcAjLsnnggQfYsXNnVERaye9KI7XCbV3h6krdUiAe4pecXZX0PmV+U3r6mqYxOzvL6MgItVqN2dlZZqKpAUePHmV7Lh/PZpK/d/LYk3SnDh4/Oreh0xSKAqq6UsWW1B+Z/1M0DUUI9KjvWfY+lxYXKZWWue++Bzh46BBLS0txeJfkBkpytTR8tm3HeUhN11E1DTea9Z6cty67elzXBUJ5OnmByxB87Twjmetcq3AUeD6+G1bzvbaLEtGLVEVBU1VUFXRDC71SIcJMpO8TBF48zjjMtYaUq3bbARFQb9SYmpoMUwFRzjPsgw9oNmooqoJh6AgClpYWeeih3TzwwP2cccYmdu26gLHRUbKZDHYqRd/AAN3FIq942cvJpNIYkYKR9F4lG8FfkxpI8lilB5kszDQajTgnLI3u2vlLhmGQSqXCKrltx967LOqdeeaZsaGs1WtxOF4sFjFNaxU/Vp5H66lMdfDo0fE4T2NIOkyz2WB2dhYNyGZCLU5V12g2GpRKpYRRDbma1WoVz/Mo9nTHXUQyJPQ8L35deqCS1C67S1Ql7Ft3HIdcLhd7MGbUs16LQkpZLU9qecoqcLIIJSv3Mse2EjaGoXqr6bI4N4fnhyG5H4RzkjRNp9BdJG1n0HQ9ylt6sZcnvVhdVYnuJ7TbDjPT00xOTtLV3UU6lQIkRzJaz0Yo4aaoKs1Gg7m5WYQIOPvsnQwMDGDoGu12EN8kFOD888/n4IEDLJcruK5LT08PEA2m01YEmqWnKP+WHp/M2cb53UQjgFw7mRuNu6oiHU5588pGcnPyuPv6+vCDgMmJCebn5snnC6GhzWTQVBXBai9zbUGyg8eOjuE8TSFEmDszjHDs6+LiIu1Wi1wmTX9/P6Ztsry4yOTkJIqi0NXVha4bMUVlZGSE7q6uaLJhePFICTop+mDbNoVCgUw2ixdVvtfr8pFht2EYEe2pRDqdjvNwqqrGBQip+Smr8LKqDsQ5UMlz9P2AWq3G9MQEBw8eZKlcjlMGMk+6fccOtm0/i1w+H88d1zQN4Ufix4qCpirYlkm9VmF2ZoZ6vUGzFSpBheNxVzq0giCgvFwmnQ4NjKEb5LJZdu7cyVlnnRXdBJR43Zxmk1Q6DarK5s2b+e+bb2F5eZne3t5VlKSkWn34+602UtLzlIUbWcSTXrn0VmVIL0PrJD9WT3SWSdHjneecg+e67DtwkJmZGdLpND29vWEbKyuCyRIdo3ly0DGcTwJ0dXWxY8cO5mdnmZma5LbbbqNaWSaVStHT0013dzf9AwOYhsnNN98MEHP2msvLaJpGoVAIB3hFRi0IAtLpNOl0OgzxS6X4gpUE7O7ublLpNLUjR+LCRq1ep16v09/fTz6fR1XVqEjVBkKDKyvt0mjKz0vScvwgYGZ6mnvvupMf3HRTWKWPBHrr9Xpc4d+6bRu/+quv4twLzqdRr4fGxLbxvDa5TDr+zHQmzdEjDR647z66urq49NJL6S52RbzP0B1tNRrcfffdobcYBBiaTl9PD8++4kpe8MKrQ+5svY5p22gAkSH0XBfdsujr6yNfyIfGP/ptDMM4piVTpilkp5EQK738MszOZDKrpoPKnK+cEZVMzcjOr1QqFd4oIk++VqsBsGnTJqr1BjMzM7iuy7mWRS6Xi1tCk1oCch87BvTxoWM4T1MoChiGRrVax/fa5HI5Mpk0lmWhKAo9PT1ceOGFeJ5LoauLQAgO7tvPnXfeyaVPf0ZYcc3nyGQypNPpeJqlDA9ly2Sj0cCyrGMKCZqmhZ4WKx1MrVYLXdMYHh6OPSXHcWi32zH3cGlpKfY6ZcguixtJalC5ssxtt/2YG7/zXWanp3n605/Ojh07aDSaGJZJs9Xi8OHD3Hvvvfzrl79CyrYZHBoik82gahrtiO+oKArVSoWjh44wOz0d5wZLpRIAXT09uK7L1MQEd911F5OTk+RyOcbGxti8eTO9vb2hytDiIvfee2/cC57P5+nq6gpzhj09iCjVcNZZO0hnMhDdGAzTxPdWNEuTrATP80LtzAQ/Va6XvInJ9ZDiHdKTT3qscq3r9RqF6GYlowwvWof+/n6qtRr1ep2lpSV0XSedya2rhCQNewePHR3DeZpCCGi7HrlcBkTo7RmGwfj4OJs2bcJphfnNDZs2Yuo6U5NTLC4uctVVV+F60ZCvKDSUhGfpBSbn+siikuu6qy5mIUKtzmazGdOWZAU+XyiEositVvycNJbJnuskgiDAcRwymQyVSoV777mX/Xv3kbJsXvj8F/CiX/5lcr09BC0HJTKyM5EhLJVKLJeX2DC+YZXoiKzil8tlarUazWaT2dlZlpaWYgWge+66i7m5ORqNBqlUKqYYKYrCkSNHmJycJJvNsmXLFi666CIqlQpBEA5NO3r0KEePHsXzPJ73vOfR3d1NJpcnEIJGo0Gj0aC3rw+v7aIqKoqqEIjwhiRvVLYdGmIZWkvPT64zEPM1U6lUfJNZOxBPPnfLLWGqIJfLhZSzQoH77ruPrp5eisVinJJREwYz+Vt0quonBx3DeZpCepxChG2GiqJgp1JhtVlRYkqN8AMaToNWqxlf8F3dvaiqSrlcxkpUgOUcdckZlbQg13WZm5uLDaf0OmXVuqenZ1Uniwy95baWZcUVejnqVxLspQGAMCTNZDIsLy9z7733slxe5oxNG7nssssodnWhCIGnqtSqVVRVZXBwgOc//wUsLy1j2jbttstypcJSlH7wfZ/5+XkqlQqqAt29PRi2RVdUVa41GuiWycZNm0inM1i2hYKK67VJWXao0h+xCFrtNornESCwomOQXU779+/n05/+NAMDA6TSGXL5PH39/fT19EIf+J6LYYYGz/UCfM9FS6XxI/V7mcOUDQeyQJRsBmg2m7G3CyvdRxAyFzRVJZvNUsjnmZ+b48CBAziOw/iG8Gbykx/fSr5QZOOmTRQKBawox5xs8VyrI9DBY0fHcJ6uUBRUiJR/RKR2rqBGoyJ0BNlCEc/zo+KHSqPZZGF+Ht0wyWaz+IGP74WivDIXKYnzciiYqqrMzc3F1VvpGfq+Tz6fj0ncknakKiqBH4SFB7eNaRpoaqjErusGmUw67MJpNnFaLZSIyylEQK1WJZNOkU7bdHUVUQKfkdERunu7Uc2wA6rZbIVq74pK2/UZGhoin+9isbTIkSNHcdptdNOgv7+IqmkoKhhm2Appp9MUu3sYHh5meWkJw7IodnWBiPK2hkkhX8QPXEzDCjmhnoeiqpiWhev6uK6H025jRymRw4cP02g0WFxc5PDhw5x55hZGR0dRFejv7gYEjXoVrRXOiwIF12ni6iZW1DWkhM31iAB0VUez9Dj1EeY3DXwtoFFvRhQwA1XVCPyAcrmC73sUC3k0IUiZFqPDI2RSKfbu3s031DCH24w8f/mbyJZVeS6FMnSREU207Hfw2NAxnKcr4j5q1qnWhs3RmWyWerWGZZmokfdimCbNZgNNCz0UFWg77bh9UVbGc5FauOM4NBqNVY+bzWacQzNMk3qtFo/81TUjGhHso6CgawbNRhOATDqDYehxi2eY4zMwosJQo14jCHwy6TSjo6Pksxl6uoqgCjzfxfU83Eh/VFE0HKeN5/tUqlWCQDA3v0AQBHT39sQUqmwuSyACTNPGNC0sy6K/fwBN19E1g0IhT7VSZWlpGT8IyKRz1BoNVKUV0npEgGnZdHcX0fRQ07PttFZpCBSLRbZv387+/fuxLBPf96gsLzM5OYGVTtF2Qs86ncqEHE9VxXVaGLYVTtwAFFQ0VQtvdKqKYZk06g0CP0DXdGzLjtMEmqqhW0Y8FkRTNarlCrauYxkG46OjDA0OMDM1zY3f/S7DY6OMjo2BCHBazbChKWE0QYmMZsdcnix0CPCnMZIFG8kD9Dwf31/pLHF9j1qjQdv16O3r44orriCdTtNsNhOE6Xr8uFQqxQUUz/Oo1WoRlUmPu4nkPCE5h1t6oKqqoqkqgefRajRib3RmZibMdRomnuvG7ZlJ4rxtW2SzWexUKgpLDXK5LJlsFkVTqCwvoygKlm3hRiGqnc4wPT3Dfffdh+u6YbEq6rWfX1gAiHUlU6kUXd1ddHWHxr6nt5fu7m4Mw8IwLVLpNLph4gUehw8f4cHdD3J0YoJKtYYf+NFgu7ANdWBgEMu2KRSLvPRlL+PKK6/kqquu4rrrrmN4aIjlpSUWFxf55je/yS0//GFcEdc0lXTKpqvYhaZCs1EjcH1gpcBTrVZZXFzEj9gNkj6mRumRXC4Xt4mmUinGxsbo6enlzjvvZHFhgWxU7Ovp6uZFV4dMgMOHD2MaBrl8DjtldyrmPwM8asP5gx/8gBe96EUMDw+jKApf+9rXVr0uhOBd73oXQ0NDpFIpnv3sZ7N3795V25RKJV796leTz+cpFou8/vWvj6kVHRwLmSeTHTp61NmjqCrd3d3Mzs5ydOIotUadg4cP8eCDD7J161by+bANL51Ox2M5pMFdXFxkamqKVqvFhvFxVFVlcXExrihnMhnqtRqLkYHK5XIAtNoOru+jR6Ts6enp2HA4Tis2umEnTzs2FLOzc5RKJcrLy8zOzkZUqh66urvI5HLMzc1Rr9eZnJwCwhTF1OQkvu9zxRVXoGlarCdqGAaVcpkf3XILk5OTnL3zbLaceSYDff0U84VwKmY0cRQCMpkUQ4P99Pf38tDuB1EVwcaN4+zceRbbtm5hsH8Ay7TiAXsCsNNp0rksjtsmk88xNDpCKpthfNMmtm7bFnMlb7zpJjzPY2B4GDuTplyt0Gg2QAsLcK7nhp1PkTGTnNxarRb/Fu12m/m5uVASLmIyyLHLsqikaRrNVhM7KtLt3r2bhx56CMuyqFQqbN68madfdhlnn3NueNIonXj8icSjDtXr9TrnnXcer3vd67j22muPef2DH/wgf/VXf8Xf//3fs2nTJv7X//pfPPe5z+WBBx6IPZRXv/rVTE9P8+1vfxvXdXnta1/Lb//2b/P5z3/+8R/RzxFWa1auVlhvtRpx5Tfwffr7+0mlbHzfp6+vD8dxmJ6eplQqYdk2qUwW0zQZGRlhYmIi1m3UNI2jR44AUC6X6evrCwe5tdvMzMxQqVQYHh7GNE3q9Tpu20PXw/7piYkJqtUqQ0NDCCEoVyqk03Zc7e7t7aW/vz/upHGcZjz/PWWZFPI5ctksTsMhlcowPz+PooY92a7r0WyGs96/9a1vMTQ0RF9fH+lMikJBUoUMrOic8gNZpQ6VloSIpOGkPBxhUWTXrgsBEXcFCSHwvTaqpqGi4nsuqrrSWgoRfUfX6erqoq+nB00LL5tfvuYavv3Nb/K+972PZ11+ORdccAFDg4Mx0V0QTswMAp96rcZ0xBKQDQGyuJbNZnHdUA1LpknkjVJGBT09PfHok2azyeLiIkcmjgKwfft2pmemQVUYGBxicGgoXIeO5XzCoIjHwU9QFIWvfvWrXHPNNUB4Eg4PD/MHf/AHvO1tbwPCi3FgYIDrr7+eX/3VX+XBBx9kx44d3HbbbVx44YUA3HDDDbzgBS9gYmKC4eHhY77HcRwcx4kfVyoVxsbGKJfL5PP5x7r7pz2SfcwyVJc5yEYj7E3OROpGQgS02w5tx2FpsUQ2m2VqaopKpRJ5rDoHDhzg6quvRtVUnFbYmZPL50M1oVotbumTxHVZlLIsi1w+h+t6iECgqCGPcmJykr6+PoTwSdkpMplwHPH8/BxOy2FwcJBMLoPnedSrVRRVZWZmmuXlMrZtomsabtthaWkZ207R3d3NkaMTOI7DwOAQZ2zeSqVSiRWFVE0hlUqRzYa5RM8LDWvYj76iWKwEgiDq9QdCRXfC/n5QaDebCASGaaJqGsL3cX0PU7dAi3Q8ozyyoijxLPJAhBNAFaFgWiYoCrVqlf179nLLzTczNT3N4OAg11xzDUtLS7iuy+joBgrFIqXFEg89tJtMpOR+7rnnxg0HpmWBqnLk0CGKhQKarlOLUgipVIpWs8X+vXt5ygXnMTs9TbPZYrG0yK23/oirr34R2UKevsHBmLCfzuYS3mZkQNeE71Hm8wk/h59skBSvR7ItJzXHefBg2Pb17Gc/O36uUChwySWX8KMf/QiAH/3oRxSLxdhoAjz72c9GVVV+/OMfr/u5H/jABygUCvG/sbGxk7nbpzWSpHRZ4JE3kXQ6HQ95k/qPmq4zMjLCUJRKmZqaYt++/SwsLHDgwAH27NnD8tJyTFCvR/zHvt5eCoVC1BvfpF6voygK/f39YR5RhNMfXdelFXE4U7ZNq9kk8ANMy8S0LFrNJiIQkQecgkDgRIIioSsII8PDDA4OYllmrFkJMDc3x6FDhwCFrq5uCoUCg4OD9PT00NPTQ29vL8VigVQ6jaZH4zfUlQk/CgIlGuuryiKa74eK7kEQioh4LroWzRYPfITvgQjQVQ2UcM49rAisCBGpwkfQdR092l8/KmRt2bqVZ11+Oeeccw6t1v/P3p/HSHaf973w5+xL7Vuv090zPQs53IarJEoUtZDWYr9JHCsBdGMgToLYL4w4eAMDMWD/Z8eIETgwEOfeGycXQeyb1w7i9yZOnNiWbEuRbcmiKFLiNhwOZ5/p6b32qlNnP+8fv3NOVzdnKNKhYg6nH6HF6a7q6qpTdZ7zLN/F5Y//+I+5evUq169fTy8iLrIiuP6qoogWPk2aqqpCkuCMRlQrFWGDEoaEYSC4+WFIp9NmPB7T3t0VbCNJKDyduvdejiwvs7i4iKHrmJaFmTul7i2DDmee7328p1v1zc1NAGZnZ/f9fHZ2Nr9tc3OTmZmZ/U8ipfdl9zkYP/uzP8tP//RP599nFecHOQ5ynTMQtKgAdWTZyL3QkyTB89xcmk2RlZzBIuaCEXNzc+n9vJx5kiViVVVzUHiGXczUegqFwj63xSAM8H1hxlatVul2O1SqZayUuplBbGzbSrGfHlEYoioKsiSsN6pVkaDjKMq9ecIw5ty5cyRxTK1ep15v5LhTSZZSxhTCGkOWIM58gSSIYkiE3UWSJEJ1KYoI45jA8wl8nziKiIFhr48XCOV0z/dQVY1KtcKRpSVacwsiuZLZY6Q2IVGErspTIxNhVxwnCYosYdkWp+69F9O2sGyL8+ffZDgasbK8zHA4ZDAQFr62baVwsCHD4YByuYyiCIynlxINwsBnNBoiAbqhE4YBN9du4HkuSkr13NzcZHNrE900MS0T3TSJohhZEXqpSPtryUPI+3sfdwQcyTCMfNN4t8V0As2k2wQ4W8jJea6LbhjYcYEwFAIY7d02mqbR6/VQVZXZ2TlOnDiRL2Tq9Tqu6xLHca68k3HNp7U5MwB7lkTFPDDCT7nWhYLFxDWpplWvMxrlyxtICEM/rUDjXHlpOBwSpYZjsiRa7zCM8LwRQRCwsLjI7NysoDWmr99ORwhJItTpSSCJYohFBRt4HoHvEoUBYRgwcVw63Y4Q+3AcnPEY1/UIw4Cd7R36gz5XLl+hN+hjGAYrKyt8/OMf56NPfxLLNEnimBiBd9RUjTBt9dM/TZKkknGpRXEcx0iKzNLKCpZtEwPf+ta3OPPQQ4RhwO6OwMmqikzBttA1lUG/R7lcgiQm8D0xV5USer0uE2cs4GGaym6/x40b15mdnWVufp5zr7/OG+ff4Pz5Nzm6ekywkwoF1JQBliTTO6FpCNJh+nwv4z1NnHNzc4BQrJ6fn89/vrW1xcMPP5zfZ3t7e9/vhWFIp9PJf/8w9mwWsoQ17RcklIdE+2iYJs54jIQQIN7Z2aHX67G4uMjGxgbLy8ucPn0f6zdvMh6PqVarufamSJIGGxubDFO2jmVZqKqAzriTCcPhkH6/jySJpCrJe4ryw9GIE6dOISfCCzyjX4ZhiG4YokV3XZKUaXTt2jUuXbpEpVJGkiS2tjbZ3t7CdT1eeeVV/upf+2HsYgm7UBSao7JMFIb4fpCiAmQyPyBJktBMndj32bi5xs0b19nd2abf67K+vsErr75Me7dLGAX4nkcQhOi6RqPWIIgDet0+k4m4MFy5eJG1a1dxRyMefuIJZhYXMSw7nYmCrgkWTrasy0DtURIhSzIRMWGq2jQ3P8+zzz7LN7/5TS5dusSJ48fZ3d0V/PRCgWq1Srlcxvc8ojjGmUxwUvHnDCqWCU2vr69z5coVer0ejzzyCDGwtn6T3mBApVblxIkTXL12jdO2jVkoIMm3ZwRlvkqH8d7Ee5o4jx07xtzcHF/5ylfyRDkYDPjWt77FT/7kTwLw5JNP0uv1ePHFF3nssccA+OpXv0ocx3z4wx9+L5/OByJu5Ui4N8MSIUDtLsPhAIAPf/jD/PZv/zZxHAtLWF3j+eef4/jqUeq1Co16VWzch32KxSK1apn19XVOnTpFv99HVWQW5mfTqjBhZ3uT2dlZHGeM6/lous7KsWVuXLkKaQs8GAwYjYYsLswLRR/H4aWXXqKc0gQHwyFvnD1Ls9mkYFo899xzTDyXaq1GszlDvdFifn6ewdjJXiRxEhMlcW4hEYWhaNfTKs+fuLz04nf40pd+n62NNba3NllfW2MycalUyhw9eoxut4uhqjQaDU6dOkm/2xe40cFQaFwWi2iaxne/+11+7V/9H/x08WeoNpoYlp3rYgrNT2UfbVFVVJR0LqqoSr5My1hIn/vc5/jKH/4RtmVy6sQJJs6EK1eucM/Jk8y1Wrz55pvcuHxZoBg0jQtvvMHly5d59tln+dKXvsSNG2JjXq/Xuf/ee9EVhX//G7/Od777XWrVOg88+BCN5gylUoVut8+MaUEk0AOCwcS+z8i+z8//7IfyMN594hyNRly8eDH//sqVK7z00kvU63WWl5f5R//oH/GLv/iLnDx5MocjLSws5Jv306dP87nPfY4f//Ef59d+7dcIgoCf+qmf4otf/OItN+p3c9x+qC/MwQAC30dR1VTE1iQMQzY3N/mDP/gDnnnmGSRJ4uLFiwyHQ/7m3/ybufhEJv9WKBTY3d3lnnvuYWtrC8MQQPUoilhbW2Nzc5Pl5WU8z+PipUtUKlUee/xxAt+nVqsRBEHOeMlk5i5cuJCLTWQz00qlwsMPP8xgMODcuXO0Wi1Wjh6l2WrS6XZRNZ25xUV8X+iCqqnHUCZCksndyRKgyERRyAsvvMC//41/x/k3ztHe3sLQVE4cP86zzz5Lv9/nwoULWPNzHD16lOPHj1MoFLh58yYAjUYD27YZDAa8/vrrdNqiKnz+W9/knofOUKrXcx9zTdXo9XsUi0WxkEqPfRQLT6bqAfM2WZJ44okn6He6bK2v02l3KJVKAjVw/TqPPfkkyfnzefcwGo144YUX+MxnPgPAa6+9xng8ZmVlhVarxdWrV/k3/+bfcPzUKarVKo8+9igPnXmYzc1NXnnlFVZPnkC3TMqVSk77vOXn6TBlvmfxrhPnCy+8wKc+9an8+2xp82M/9mP8+q//Oj/zMz/DeDzmJ37iJ+j1ejz11FN86Utf2ues95u/+Zv81E/9FM888wyyLPOFL3yBX/3VX30PXs7dF4qq5gsWRVFQNY1rl6/wiU98gjNnzhCGIYPhMJeOCwJhdJbZxQZBgGEYKIqS+wV5nke73WZjY4NKuuldW1ujVCpRq9XwXI/uYJuiZRPHMZ1OmziOMXQdZzyi3W7TTC+kINR/nLHDaDDkuW9+E9MwefqTn6BWrQreuyQzMzeXjiLEPDVOxGZbUdV8jhgnwk9cSiTiJGF7c5ON9XWIExYXFliYm+HE6ipJFFIuFvj4xz5KpVLBtmxUTdA+Fx9/nCQRMLkgCJiMx7R3dknCiKWFRb71/PM89MRHsIol6o1G7vqZiXMMB8Oc4aPICqViidDziaIQWc7U8BN0VWV2dpYrFy+yfvMmMzMtdE1lOOzjj4b4novv6WxvbzIej5mfm0WW4PwbrzMc9Dh16h4eefQRTMPg1Vdeolgs8r998YtMPI9atSYwsnNz3LhxnVdfew3X9Th+/ATNVhNFOSQEfr/jXSfOT37yk28rTSVJEr/wC7/AL/zCL9z2PvV6/RDs/h6FLMtikRGLTXIShpRKJT70oQ+xuLjISy+/zO7uLqurq0iSRLvdzmmKmUqSaZqMRqO8+sk28oZhUCgU6Ha7ADQbDcGPT2XdVEnOVXxkWSKOBTi70WjQrNcplctcvXqVne1tAt9ne2ub18++ztNPP40qCyZQFEdopomm6zjOOEUsSchygqrJKJAq1kdoqoIsK2KjHUWMhiNIQFNV5ufmOLI4j2kY7Gxv84M/+IOoqprPbovFIpVKFcuyGQ6HBL7P1a0trl29xvbWFrWaSEZ9Z8yg32cydpCbLWIpFphPVWPiTtjZ2WY4GGIXCqyurqZCxyGyoqKkaAUkGQWJY8eO8cK3nsOZjBkOjXzJKWsqc/MCdynLMrZlsbi4QBxHXL58mdFoxGDQp9/rEdg2W1tbPPsDz3D6vvtwJhNUVaNYLqGoKnPz80RxTKVSS6FIh0nzf0XcEVv1w7h9THvbZOLErVaLRrPJZDJhd3eXwPc5deoUxUJBVFqaxijV4iwUCqiqys72dmp8JrbiuqbRqNeRgK3NTaF+Xi4hyyqe76OlrBahTr4nxKsoiuCNVyr4vs/W5iY3btzA93y2tzZx3QmVSpnxeITne2iGzmylQhzFTCYuhmGmLpehWH9JEqPxCElK0EtlscmOY6IUt2qaJkksJNomrkuQiggXikW6nS7b2zv4gU+lXEFRNLa3d+j3++zutnnj/HkuXLxIt9ejWqlgmhalWp1SsZSqpSc5+D1jILkTl2tXr9Lt9vBdl5MnTyIl5EQD0zSxU3X3mdkZKpUS7d1dAt+jWCxy9OhRkGBmpoU7cVNaKKiqws7ODtevXxMiIoM+6+vrgvo6HvHpT3+KQrmIZhjIioqmG8SxULCamZ1NxUP2bIAP10Df3zhMnHd4ZLYIqqJA6mVuFUVF+fzz38IZjzl67BgL83MULJtKqUSv38cZjXBlmSSVj7t25UpOr7TqdUxdJ9E0kXg9j1KhgCzJhFGAJCXYtkUchNy4cY1Go4FpmhSLRWzLYmdnh0iS2N7aIo5iFEmm3+ty9cplThxfxZ04dDtdmjMtqtUa5XIF33GRZQXLLLDT3mU0HqMbOqVKJdWulPe0JaeseFVVpVatsr29w/VrVykWizz66KP8h//427TbbcrlMrs7Owx6fRYXj4hlkWGwlaIPsgvFxPOZeB7VmVlWVlaoVatEYaqZiUQUhdiWTa1SJfB8nn/uOa5ducLf//t/n2IqmOy6LnNzc/lMuFqtUK1WuXD+PP1+j6WlJR544H4G7V2R3AtiLioIByOef/45bt5co1qtsLi4QKFgMRz2abWaLC0toagqkesR+B5xkuqGpsurzKzvdrYYh9PN9zYOE+cdHkpq4ytJ5FvirHI8+9pZ7r33Xj7+1FO44zGbm5ucOn0ax3G40W7T7XYpFoucOXOGTqfD9vY2DzzwAJZl5cyhOI5ZXV0VbpdhQOD6TDwfWwJdUdna2qJer+eeQkEY8uUvfxkFePrpp9M2XmZmZpbLly5Sr9d58MEHac20sO0iqm4QRTGe62OVi4RxxLXr19ne3aFaq3HSNFP1JhlFkomjkCTFnzYbNXzXpTk3izMaMnHEqGg8crixdp3trR0cx6FWq1Gr1bm+tsbm+jq6aTI7OyvmlIrC7Ows9Xqds2fP0piZxTCMlMopI8kycRTls+TMJ6iaLru+9rWvcf9991EsFhkOh3znO9/hpZdeolarIScJb54/h2ka1GpHKZfLvP7661SrVVZWVoSlx/o6r732Gl//+tdpt9uUSiXuu+8+FhcX85FJJnISeB7OeMzN9Q3GY4cTJ06gpnYblmVD6mr59kvF6ThMp3/ROEycH4BQU+vczLfbdV1+67d+i6PHjnLy5EkMy0JSVXpvvMHX/+RPKJVKXLx4kSAIOH36NOvr60RRxOzsLKqq5kkjjmM2NjaYn59H0zS6/T6dXlcAwmWJrjNhZmZG0ASjiGvXrnH1ymU2NtZ5+mNPMTs3x/Vr1wV7KQhYWVnhzJkz1Go1bNsW4sFhRLu9i6Fb+P2Iza0ddnd3kGWZWq1GpVIRos7p80miGEiEsvvRo6iqwpUrVzBNgxMnT9FqtdjdbfPqa2dZXFzClhWiBHqDgUjiika13mC306XT6RDHMY7rUW+2+If/n3/EfQ88hFksAggxjygmcIVP0NWrV3n5pZe4fv06rVaLDz3xBOVyGatYREoSJqMxvW6XnZ0drl27xvbONvPz89y8eUNU7qkXepIkvP7667iuy2AwQFEUPv/5z/Pd736X73znOxw9ejRXjF9ZWaHRaCDJMqoks7W1xfb2Nkki8NGWbVOv1xmPx+i6kbuL3j72OP2H8RePw8T5AQhJkoSjYZwQJwkXL15GkiQeePAMCwsLQsSj30c1dNY3N+j1eszMzDA7O8vCwgIvv/wyL7zwApqmsbq6Sq1aRQI2ttZpNBr4vsvGxoYQ4FVUJo5DHAacf+MNzpx5CFmSaO/u8trZ1/jzb3yDj3/84zz62GNICLhUt9tlOBpy+vQ9LC0vUa5WUt+dgPHIYXtjE7tUpN3pceX6NWr1BqvHVzm2vIShqYRRjOtMBOMoDFFkwdM/df+DPP2JT/LcN58DIIxha6eNomn8v/7ajzAcDvMZcFa9ZUr2x0/dw+LiIrOzs8w0WywtH2H+6FHUBGTTEpVmGArqo2XlSlGO46AoCrVajW63S6VSYdDroaRqRo2ZFuVqlaPHV3EchyjwGQz63Lx5g2tXrzEYjZl4HnaxxGA4YuRMMA2D+x54kEqtzsOPPMrm5ia7u7vYhQJzCwssHFniG3/+HH7qtlkqFjENwQLb2d1lOBhg2wUkGaIoRFVUhIKyxDR07XDy+d7FYeK8YyOTmItQFBlJEtjGXq8Hksxjjz1BszWDZhjEUUShXOLY8eMUCkX+8Mtf5p5Tp6jV6nQ7XTbXN5ibmeXG2nU2N9ZRZQnf99ja2cK2ioxsg/m5RXq9HmNHtPDd9i5zMzOUigU2bq5x/s03uXLlMrVahY8+9VEMQ2N7e5ubG2sEkc/RYyu0Zlq4vodhmQRBwOb6Jjvbu4LGGMds3ryJqapUiwWSwOfS+Tfo9vo8/MijSKTmcymbR1ZUdFXjc3/lr3H6gYeQpNRLR0q1NE0Lx52kCkmCNZMkCXEkAOy2beWiwKZpYmoKm1sbVMsVpMBnMBwzcSaiMjYNXM8lCANMy6QuN2i1WlQqFUbjMd1OlzhOcshTGIQUS0Vm5ubY2dyi3pihWm+ytHKcnZ0dnEnIzFydQqlGYXOD7e0d3rx4hWq1yn0PrqAab1JvzVEul1leWaFQqlKvN9nZ3aFgWrnx3vraGvV6jU6njaFpaLqgusYRwmJFmK9kzFQkSRxnSZJBUg4KJh3Gu4jDxHlHxhQbObNGSMUn4hjK5QrVagXTskGSkVUJU7ExLYs4ThiMRnS6XQp2Ac/zcprk/Nwc3U6bbqeN57pouoq5aJLEGr7voigSlmkSRiE7O10WFha5fvUKm5vbbNy8SRQG3Hf6NLZl0e122NnZJk5iKtUKlWqFTq/H1vY2R1ZWCHyfwXCIHwTMz8+z296lvbNNqVRi8+ZNbt64juf5Qlbt1ClKxSKapiNLYS4MHIURK8dWWThyJPVdEsIbsqqkfuoyUgZfSjnccio3lyRRXlHKikzoTbhx7TqjehXTKiBJivh5GNDf6jFyxjRbTSRJwhk7VCoVavW6gEoh4YcBfhgSJ2Lz7ochtWYL3bRQVRXTNGnNLlCtt+h2uxRKFSzLRjNMokTm5s2bFIoVytUGx0/eKzj+QJRI9AZjZubnSQDXneSjlMuXL1OtlImTmDDwCcOAKGU52aUCkpSQJHFac0ppvXlYdb4XcZg47/CYtqfQNI1qtbYP1J5Fkm6GHXeCputsbm0hyzKNWp1yucy3vvUtfuAHniHwfS5duki/3+fUqZNUqxV0Xafd3qVer2MYBru7bcFjH/Q5d+4cpmWhKjL1Wo0Tx49z9dIlDMOg0+lQrVYxDINut8vG1haO4/DUJz7BxHEErCnVxHzj9XP0ez16vR79fh/P96lUKjz++OO0d3ewU1ZUHAphYN/1cztiwzKzmhIpiXFdD9000DWxeIrSiiuJE1RZKKMnMYSxALdrMkQkOK7HeH2dYrFMa2aWaq1G6AW5HuwDDz7ITGuGdltwyi3LQjcMYknCdb3U2iQU6vyKjOtOqDUaRKHQG1A1nbmFRSpVYVUiqxrVepOjkkKMhKQoBGHE7Nw84/GYTqfDbltgaFePH6VarXHtao+wEFIsFpmkWgK1Wo0oioRl8cRBUzUs2xLaoinqAhKSOEkXXv/rP6cftDhMnB+AyDa9siznUmyZQIiUatgmSUK316XX61GwbZaWljh14gQyEv+/P/9zyuUyqqLwyIc+hG3bnD17Fk0z8gXGxHNZ39xg4kxwJ8Kn/ZVXXuHMmTMUSkVeeeWVXMxiNBpx/ORJoiShNxiwvr5Ov9+n0WjwxBNP0Gw2OX/+PFvbW1y7co1XX32Nfr/PmYfP0N5tC7GMuTkWFhfp9HtsfOMbPPjgg5RKJaFPKivYdpFSqYTneQSBJ1SjTAPTtoSlcopnFPApGU3VkFXxM9dzMTQVwzCJo5AoDNBNk9XVVUajATdurPH62XPEccLx48d57LHHKOdSeDGFQhG7WMTzXEzLol5vvGWWmsQSxdRuJI4TyCBUsiywp4nQZ1dVlWarRb3RYO3GDba2tpibm6NYKlGt1fA9jytXrnD58mVa9QaFougSxuOx8IBSlJwJFoYh47FDEIUsrx4TwsaZ1kGqhh8nCXJedL7dBv4w3i4OE+cHJDKleC3V55xmd2U4v1azxf/4ylf59A88iyJJXLtylWtXr/KpT32KdruNqoiW/9FHH6Ver/PCd17E933evHiByWTC1tYWiqJy8vhJPvaxj7GxscHJe07xG7/xG2xvb3Pfffdx3333sbW1xcWLF9na2uLs2bOYpskTTzyBLMucOHGC3/vv/x3TtEmQKZTLHD91kh/94v/G0uoxJsMRY8dBM3Rs22ZzYwNN09jY2ODixYtEkVCbNwyLcrlMHMdUKiVK5RKKqqSGb2aaKGKBb01LrCgWm2pNkQl8V3glqQqSpDEe9Nna2sI0TR5++FEuXrzEuXPnWFtbo9VqcV/5fjRdp1AoEkcRvuviTJzUb0nLNU5J5f+iUBz/wPeFUVv6vviel7uRgmBAZT71yysrwi8pFTv2fR9V01hYWCBOZlCQ0HWNXq+bWz2//PLLfOYzn6HTEar/pmmyuy74+Jl9iJSqOmVOArKusH9pdBjvNv6nrDP+suKdytvfLZElyoNvZdaigUgio/GQfrdHs9nkysVLXL50icD3eeojT+I4DjfX1tB0nTgRAsOSLHH9+nWur90gSRIefOghyuUKzshhYWEh57R/85t/TnNmhqPHjuF7Hq2ZFteuXafb7ZJI4DhO/p5Zlsnjjz/ByXvuwTZt3InLoD9gptkikSV0VQNFJk4SfNdld3eHXreTiy5n7KjxcMTRlRWq1SpBHAl5tsmEmIT5hQXqtRqyouUaplEUpZ7lOv1+nyQOU2+kEb1OB11V0DWNYqlEkkiYtk0QhZw/d45r165RsAs88wOfoVQqkkQxURwTRHFuriZC+B1FUSiqTMj/fvY+wZ5kYFalZtVx5mmfVaTZeyjul6RW0THD4ZBut0O73eY//6f/zDPPPiNsSlJm2MbGBo8++iilUombN2/SbDZzeFMmK4ik7fOxOgwR7zS3HFacd3hkAPNp2iXsV1bKqlHbsjF1IfaxtLLC7NycsKmVRYWjqALQHscRSIlwVTRNRuMxp0+fpt5oICHheR6vv/46i4uLuL7HbqdLDBSKRWRZ5sMf+QjHjq3y1f/xVXZ2dykWi6yurrK0tCTooI0GdqGYUwetQgEpToQ3fFodyYCm6xSLJSxTPOfRaESn02HQ7+OnS61arcZgNGQwGNAf9AnCkJmZGQzTxPfDfS10lqQUReLi5asM+n1IIkxdJzIMrl6+LHzdC0VMWyzTMuvkF1/8Dmdfe417Tp2iWCzieR6GXRB2IOKA58dblhUUZc+2Ijv+sCcTmM1nM+vnLKkLpfu9xJpVo5Bw/dpVLMskIckhUY89/hhvvPFGjo3VNI1yuUy/36dSqbCxsZGb7w2HQ2y7gK6bKOphwvyficPEeYfHwSrmYAWxV7mIpYimpELDmk6pWCSOYyaDAWoKZ+l0uyl/OmFt/Sb3nj7N/Q8+BCRcvXadKAwhkZhptbBsm+H161i2xezcPEeWlojjmFJqS3zP6ftYcsapEVuNarVGtVZFlgXbKYwCJFlGVlSiWOAPo2iv2lVUhUKpSBKGSIqCaVmEYUiv26Xf7/Pcc88xOzuDaduouo5t2WiGnsvbJXGEO/GJs5ZVEpbBlmFStAskofAbMk0D27JIUm1R3w+QZQVN1bAtwcp5/IkPUSmViJOEKEnQDDNPggkgJUmqDs++9yP7d/Y1XUlmt01/n4klT99G+pzsQgFZFh5Uhi6S4X333U+32+PChYuUSiVKpRLFYhHXFeLNcZzgOBOCIMD3fJzxmHK58pbHP4x3F4eJ8w6P6TbwYBLddx9JIokjMfdTBSMmyU92gUG0CwUUVWhEarpOeTSmlXKvn3/+eTrtNhISjXqDxaUlbNvGDwKWV45y/wMPsHr8OIN+H1XTiRM4eepU7rmegfRlWSGMIqI4Ft4UidhoK7JCgpS2uAJahSyhaJpQG9L1VMk9yH2Stre36fW6lKoV5ubnmV9cZHZuDtu2hYlcHBEE/t5sTxIzQk1RKdgWmqqgKjK6LrzqA98niCKxXFJUNFWDVFl/YfEIYRDkECc9rQyzTDk9JLnV9CufgULOs5++f/b99KIvGzFkP280GrnJmyRJqJ6HaVqcPn1fqrk6otHwsSybIHDp9wUwfjJx08pbYdAbsLB45L346N3VcZg47/DI4EhZW5er4ySZHztkM045taKQJSFDJ6Xc5sxgrVAocPToUexCgWazyZNPfYzW3Cy+6+UsI9suoCli0dFsNmnNzHCqVufY6jFKpbJwrTQNfM+nVCrnJ76qpokxCpk4DnahiKJoRJGYWaqmLhTeZbE1l2WJOInwXBcrVTTf3NzgwoULDPp97jl1Dx958km2tza5fnONQX9ApVbDMAxGoxGj0YhatYquaTnAPomF3fGo32d7cxNJkqjVa1imSbvT4bnnnmO302F2dp5yuUKhWGRufo6jq6tsbWxQrVbRLRskiTAI0FKRZfJZ4a1dJW9VQR7sDqZb+umZZxAEOQ40joUgybSRXuD7PPnRj7J45AiXL11iPB4zGo1Sa5Kt3E5FkiRMw6DX6+0l+e+x3jisSG8fh8uhOzwy+Etm5pYlQtM0ER7pPnEcomoKURSiq5rQ3AyFrJyq6fR2dlEUhW9+85s0m01Wjh2lNTNDFMf0+33WtzapVqs0Wy3GwzHrazeZmZlhZmYGWdPECZgC0LMkJU1VWLd97vvMxPZC5HrBSc8/nVHEcDig2+3Q6/UYpvTHwWDAcDhk7DgUSyVWjh3lyJEjYuMeBkwmk9zwrTUzy7VLl7h+9TIrKyuEYUi322Vra4vzqSL7p599FlXVsewCpXIJ3TSRZRnTFPPDFNslKti8atz/Or5/Uhrx97xH4Pt58lxbW+OBBx7gpZdeYjweC/Uq2+aBBx4gjESVG4ahQCKkQteKohBFEbIs5wn8borD5dBdEpklcPbvJEmwLCvnlpdKRWzbJE6ilJIoceP6dbq7bZrNJieOH0eWZV599VUh1kHC5StXuH7jBpVqlVK1wvLRFSzTYuJO8EOfcrWKbdt54kjSFPjuUsT3um/Gs07wJy66LiTmSpUyS6ke53g8ZmN9na3tbW7cXGNre5ud9i62bQvBYMBOKYqyLLF5/Spr169iWRa///u/T61Wo16vA8JJ9dlnn0XRDAzTolQqUSgWUXUtX8CRjkAyxX1Zub052l9WqJpGuVLBtm1mZmbQdJ3V48e5fu0a3W4XTdMYDoes3dxgZmaGcrksTPjSxVkYhkRRlH+mDuPWcZg47/DIDMWAvVleumDY2dkRVabeJEkidnd2sC1L/I6q4HkeV69d58qVKyiyzBtvnKfVaglB31KZ2XmbarWGbghuebfTJ45i6rUGhmWBrKZe5lllIr2lbf0ezeDb35TIYqFl6KAoaaUHSLIQu9ANDMOi3prh2ImTrK2tceHCm1y9dJnz585h6jpPPf00hYINSYKxsIihG5x/43U+/tRTdDtdLl2+xOXLVygWC3z3Oy/z2R/8PEEYkqRK7pKkAFGeMDNGgRA4PtCS/0XewHcV7+zCJEzjVFRVIQwjqpUag8qAQX/ExPG4dvUG9WYjdwIYj8dEUUSxWNw3kz6M28dh4rzDI/uAZxVDnLbXhUKBdrvNcDjEMDSKBZswDLFMkygMWVu7iaaqzMzMMBgMWFtbY3l5Wcw47QKmZdNoNtEN0aqqmka1VoUEClYhT9Z7g56pdjU/6f5nTj4pTZ7J3tY6A3EDSiJer24aFEhQNY2jR49SqZR59aWXGA6GbE8cvvPt51lcmMcyTSauy2Q8ZjKZsLPT5rnnnqPdbrO4uEir2eKxxx5DlmSCIAQ5JIwilDgWdh4Hlm0HnUb/18T3/nuZt7pow0XLbRgmzWYr3bA7tNttTt5zKse0ZmZ7mqbto/DC4ZzzdnGYOO/weOsySGI4HGJZVspnduh2uyipH3o21+p2OvniJo5jFhYWuOfUPczOzWFaFoqqoeoakiQThhFIksBeIqHKajaIBECSRRJJDpxj37sCu909Dp6s0t4wQJL3/SxGQpKVvNpWFKFQ1Ov1kEi4cvkyw34P0zDY3tpka2sLXdfodHq8+eYFCoUCrVaLY8eOceLkSbr9HlEUo03BijIBFSThp35QVuj9tiSYxvRmkKlSuYysKLTbu6ytreVge8dxctHqLN5eDPkw4DBx3vExDZbO2vQwDNnZ2aHVaqVScx2SWMjPZQwcZ+Lksmmzs3N8+pln8F2Bq9R0HUUTmEpZEpWLlPKiZVlOlXbSSlCW9j2PvFqR3okZbXKL+9zitzKlI+mt90gy6JIkMxwO2VhfR9d1er0ei/NzOI7DVhigygrbW5tcvHgBP/CII2jUayyvrDAzM8PJU6dyNX051dbM2lbxFFTuBCO0aTbQ9Hui6RolpUQYhURJTLvdRpZlXNcFRIVqGEZ+MT2Mt4/DxPkBiixxlstlLly4wMzMDLqu4zgOuzvb3HvvPaiaRr/f5+rVa6iKwkMPPcSTTz6Jahj4XsjYGWORUFCVfLOqm0ZaaQl5MtG7SnuJ7F1WJxny8fa/tV+lXJbldE0EcbLHwpFkGUUVvkOmZVIpl5iZmWHz5hrtzi6WqnPujdfxNZWjy8vcf9+9/JW/+kPcuH6DS5cuC8hRoYimaSwsLuYGcLIiWlY5XaZlghx3UmTVZib2kgmClEolGo0G/X4fIDfZkyQJVVVzi2g4rDzfLg4T5wcgsvlmthQqlUqUy2UuX75MGAZsb2/z6isvY1kmWxsbXLt2jeXlZU7fey9PP/0JrFIJdzRCkRWqlQqKpoOsIicJfiCYN5qm5Y6P4o++7RN62+f79uYN042vuMfEc6eWFrJwukTk7xjRtMuI51iv1SjZFuVKiYJh8fgTj7GztYlMwun77sVQNYhi4hjW1tYwTJMjR47w33/3d9ENi8c//CFkRRPiH0jEYUIYxMhJuI93/n6P6eeZExBS2NE999zDcDhMfeyV/P6e5x0uht5hHCbO921kNVYWt8E8SlLOJpElGc91CSOfkydW+a3f+g8kSUS1WmFubo7xeEzBsvjMZz5DFEYYuk4Q+MiOg2GarN/coDk7C3FMEvloho6KSiLtAbRJ2PMPz57pu1wmSGmb/07DNAQ/O4nToyJlbKi9I5PdJiUSsqazsLhEEoXstrdZWFxAV1UuXrjAkYVFbm6s0+11kVNJtu9+97vopsFHPvogcZxgFgyhMapp4nGnRFTe70kle57ZyGZaRETIDErMzs6yvb3NzMxMDrWybZvr169z8sQqE2eErhuoqlDP34u/jIXY+zMOE+f7MvYUjZI4Tm0fxBJEWEGI+yQA8R5dL4kj4ijAMk12Ntfpbm9SLpepFApYhoFtWpw6eQ+GbUGS4Hs+vucRT1yGYwEgV1RFmJSlIaWzSukWy593/7LSGagE8tSSReTdhDhOUrSPtG8+l1FGJflAtZo9nyR9bokECsiJRhJFhIHLxPEoFsSyy3UDgjBmfuEIG5vbjMYjrEKB5YV5PvSRJ6nUG1y9cgVUDd2w0tecECNER8Rz3a9ClYPEM2D83gvKj9/0Im3vUOz//nYJOTs28M42+dMzzulqcvp78UMZ3w/xfJcwCMSCiITQ99A1DUVKNUSTGN/zMGybOM6gbtnfktNjc/epLB0mzvdtJHtf0t73Qow2Rso+rJIkmDrpzFDTVCbDAdubG8zPtlBVDVWWqc/O4jip7QISqq6jKKrQq5RVpMDH0I1UIXwKhzktVJHNOd/pSXI7UloqBZnE+yvPvcfN/v5ehbc3Y71FSBAnewkqjgT3fTR2BBxL10hMGAyGjMZjVEXML6NY2P7WGw3mFhbYaXeQFDE3RZKI06St67pww3ScHJmQgcazxD69kNk/qkjedUX+1oM1ddC+Rxykcd7yEZME07To9nq4E4ckibAti+WlJWRJQlZlkjCiP+gxGAyAhNn5BcEGU1P2VG7FcXfGYeJ8n4c4D2WS1LVwWsdRkcQ8Kowi4ihETnfd25ubSCSsHjtGt9slikKajQavbpwVcmiAoqoosgy6jqxq6IaeAqffujmervze9SLobRi9023lrR73LZzvt/tDUnp7klI+FYXReIzjOAQloQIVhhFxFAliQBilowfxHDY2N3AnQqpOTy8gWWsL5NCdbE6Ybd2nX+PBbfbbPeuDQiwHj8vtjsF7FaqqCmO/JMYwNGRFplqr0e+2QYLQ9+m023S7XWzbptWaQUnN4PYl8LtUD/kwcb5PIz930oVMBu7J1Iym7xiGIa4zJvA8JCmh0+lw/wMPcOnCRdqdNm4qjjsej8WiJ62WPNdlMplgWHa+Sc1phQdO6tud5LdKpgd//1byatn30/+dfsx32sru3Z6IpCkJ87Ug8PA9l4QEPwgIw4CZmSa1apWvfPWreJ5H6AfCvrjd5k++8hWe/cxn6Q9H5JV9HKV2FOPUt1ynUChgmuY+qNLB15d9v3exufVxmb7P9OMcnKd+P5Kn7/sANJtNikWbMAzwPY+zr72WY36zatu2bSHYLEsk2bxGEhVnHIP8/mOeft/jMHG+jyOJ87yZYikFP1qVBMwkCAM0RcWyTHzXodttEwYBDz/yCKppMjc/z5tvvsnGxgabm5vMz89TrdeRJInxcMhwMMDzPEqSjGVZ+TwzTsS8MUmEmlC2rZ8W352uEm+VVDNc6fTtGSTmVonmVhXtrVSFbhdSAkkSQxwjywo31zYgSajVKvi+S7/fY3l5mcl4TK1SQdGE2MnRo8c488gj/P6X/oBXXnqZlaMrJFGcehmFhGEo/NGjCMuyKBQKuZhKVpFOP++3Vou3vohM/zurug8eu9tV4u9FnDhxglarhW2ZjMdDLl68wNbNdTY2Nji+ukqrJVTjPc+jUCxC6iYQRiGypCIp37+kfifEYeJ8H4cky0jp+F1oTEj59A9JRlFlSCJc18NxxpAkzM/Po2oa3Z0dXn35Fa5cvcJwOOLmzZt87KmPI0kSvXabTqcDQK1ep1av5xUGkI8DppkncRznYOlMeWn6pJlWOc+SShZZYsyScLahz34/CIL8b2V/791GNi2VFQmSmPF4iBRFFApFBr0OW1tbdNsdSgUL13UoaSVkOSGMfGQSnvrok/yX//K7LCwskCQxvufi+T66rjM/P4vjOLjuhDAM84pzNBphGAaWZeWv7S8SBy8W2bH7i45H3knEcZwqxitUtSqn772XQbdLs1lHImE4HGKaplDrt22ykUMcxaDEKIlgUt2FAkrAYeJ8H4dMkkT4oY8ia3nV5zou4/EYRdGoVEokcUzkB7jOBNfzqNRqOKMRO9vbfPkPv0y/P2BpeVlsQOOY61ev5m6YpmkKoYdbnJgHoTdhKKqvg9Um7JnBTVeZGR5wmtV0MAlkj5lVspIk7d/8HojbpY8EkCHd+idEYYBtGmxtrBOHginV7XT5zosvsr52na2tLX74h3+YZrPJsNfnD7/0JcrVKpVyhY21m8Kuo1TCNE0MQ2iBuq7LcDhEVcUsOBttHKw4p1+reM/2pOAOvv5b0Rynj9fBUYDYrN/28Lyr0DSB4YzCAEgwLYut9Q22t7exbQs1XYBlEXg+qqGjKNNYVuGxdDcWnYeJ830ZUxvlZG+TnZ1UvueT4KHIYFsWuqELtSPXxRmPsQyDl19+GSmRqFaq1Gp16vW6WAYArdT2QtO0vHXOZNOmK0dFUXJztAwrOg2ahr1K82BynF6cHKwws+/DlKmTbapvxbt/Z7jQmFhKSJJIeJsHPkmSsLO7izMaISUJY2eM53l5ZXjp4kUmE0E5lWUZ3dCZazUZj4ZMJhPMQgFFUUWrPh4zcZz0OSUpgiHBtsyUGABxHCImBQJGJkmCkCArb6VBZsdteuZ5cGzx/caOZkr7AuifEIbi/VhbW+OeUyexLAsQ+pTCK16lOTsjSBB3Y6Y8EIeJ830eiqIip9UikNMLJ44Q7zA1jXhqjtbtdOjGMRcvXqQ1M4NpWszMzDA7O0sQhlQqFUzTxDSMfXqS2XI0imPiKIL0xM9gOEmS5PS8/HfStjKKon1V1nRFenBZkiX/LGlmAOwsIWdJdbq9fychkRDFImlmjo7dTof2zg6KLKOrKqvHjhEeWcgN2EzDoFwui025rhEEPoauQxIThRFR7OWVdPa6JRBmdiR5NRqGIvnHUYZFTStnRUE+wMTJXld23LILyrSt8/TX9zOSJEFJq+IwNYvr9Xr7FJKy1+15Xv6zOEklqO/i/HmYON/HIdo14XCYJRhN0yimlgntdpuiZeK5Lq7jYOg649GIN994g8lkwtLJUxSKBWr1Os1mk7Hj0Gw28xMjSU9akQxikGWSOE5PDJEAMo8fSZKwLCuvUG+VNLOEkY0VpKkKNksQ2e8EQZDP8hRF2beEmq60ptkvB7fte3AmEC16hO97yEj4vkcYhvT7fQxdp35kkYcefJAkCtne2WY8HLGwsIBh6HR7PTRN49q18zzw8KMYupHOOQOSJKZQKCBJMo7j5EK/2d/3fZ8wDFM8bUISZxWillbm++fGQH4MssSZiYpkCXZ66ZRFdr93mkzftkqVJBRFIgwjEoSdse/76etM4W2TCfX0cxOGIYPhSPzt7P2RhMXJ3Zo8DxPn+zUkCVCIc2C7RpK2zaPhEHc8omiZvPLyy2iaRsG2KVgWtm0zmbgcPXqMYup6WKvVsSyL1uws21tblEqlHE4jTpwol5sTiRGiOMHzPLrdbr60yVr7rH13HAdFUXJbWmDfguhWs88sYYZhmFdypVIpf9nTm3sQraKqqhSLxfxxs6Tqui5BEFAs2kRxgO+7BL6HJElUKmUWFxfZ3d5m9dgxPvTE40LhPgg5dvwEnVSrtNvpMBiMxG1RyMryEUrlIoZdQEvxmkmScOnSlfyikOlW9no9hsMhmqbRmplBVYQ4tO/7hFFA0Symr538eGmaJnyZ0uM1fUyzcF03v0hlxy4IAkxTIYrE/Q5eSKbb/He6pFJVIQ4dIRaRlmXRarW4cvkKZ848RHNmBklVGfV6+UVMU1VkKR1W7Alh3XVxmDjvgMgrunQWV5ZLFCxT6GjOz/Pqq68SR1FaQRmsr68TxzG1Wo1jq6scPb6KrGlEqR+NYRhoug6yLBSGUsWjTFJNUTXiJKLX6+XtaKlUEjCmsZgV2rad2/BOzyazChTIk+M0tGb6PoZhYJrmvpNf0zQ8z2MymeTVXa1Ww3VdMU9MOdij0QhFUSgWi8RxRJyC28MwRJVklpeX+c1///+l3+/z8OOP01pYZGf9Joqi4YzHyIrCxuYm586dY3d7mxOnTvLJT36SarVKqVIhkeS82h4MBpRKJSzLotfr4ftihup5HvPz88KzfDBA0zRs26ZYKhEGAXEUMRyN8uRommIm6vt+XkFm8+CsmvQ8L2/bR6MRritsQ4TFx1tnpbfDyL6biOO0e0jbdXcyEYyhtTXkNKE2mk00w4BE8F6l783+/EDHYeK8A0Ii8+AGEHqZmqZDFDIeDDi6tITjOFy7do1+v0+SJNTrdRaXlihVyunm3c+Tj67rhEFAGARIkkwE+6qg6RmkYNLouVZltsjJqq+sBT/YqmcLpemkmd0f2Kd5CeQ40WzOmeEnpxNE1uqHYYiqqhiGwWQyQddVnIlD4E9IwpC1jS0uXrhAt9tlcXGReqWCnCSUqzXau12O3nMvxDGtuXkM0+IrX/kjhuMx585foDMYYxVLGJadVus1dre3Ob56nH6/jzdxsC0LmQRDU5FJGA+HxFGMUdHRFBV3NGZ7e5tyrSowkOnxzY5fkiQUi8V9C6Gs6s/0UrPEaprm1HZ7P641+72DFebtkud0mx+l4iVSSuWVJYlYkqjX6+zubDOZTKhUKjQaDQzTRDNNoW/g+4CEpAh9VN/3sS2Duy2LHibO920cBFLHYhOaJOLfYUjgeWiajqr6TCYTLl++zKuvvsqZMw8zPz/PyuoxYZc7HgOiBcyqNc/zAITFrSQEbefn55EkCd/z8IMQ27bzdjpbDkzbKziOAwhc5zT8KGsts1ldtvwB9iXe7HGyBJJVW9NJNvu9LMFmCyXDMNB1nW63S7FoE4chUpoINjY20DQtrWYhRsIPY25ubFIwbeIgQtNUCsUi95y+F2TY3NzEDwOq9RqGZRPFCdvb27zyyiviNRom8wsLFIpFFFkWS5XUNC4KhVWvaRii9U3nl4VikcD3RfueHg9d1/MZ6fTMN4oiVFXNK20QWpnFYjGvsvdDgfZX+O/UlXJvZJLOjtOHUxSFWJYol8tsb20yHA5pzcxQKJXyJWJGUZXTpRcIn/q7MQ4T5/s1kkzWQ8rQSXuD+SQmSisYy9AZjQTz49y5c8zOzlIoFVk4ski5UsX3PNyJQxgJ6uBkMslPTsMwKKsqEcJSWJZFe+q6LlEsqqIsAfq+n7ecIBKY53l5NZRVjJ7n5W3n9LY8435nldT0Y03PRadno5IkeOHZYiyJY8IgJI7SLXeS0O/1iaOQ0J9AEiKRUC6XMQyDer1OtVpDlhUmroeq6lQbDWFpLEnECRTLFY4dP8nE84QzqKLg+z79wYh2u83Ozg6e54nKtdHATG10+/0+juNQKpXQNGGM5nkurjtJuewKge/heT5RCu7PLjCTySQfR/i+jyzLFItFHMfB87wcUJ9x4qe91mF/xXmQuDB9+76P01S1Oe3fniEypJQZpGka47F4Ht1Oh26thmlZ2HZBCKAockrMyCiXCRxSLg/j/RDpx3/v++kpfLoNz1q+8XjE9RvXuHb9Gr7vc+bhh3FcF7tQIAwiHMdlPHKYeE5ecWZJybZtTNPEj/YqO9d18X1feA6lC6TJZEIURfm8M0ua0yIYGT1vMpnkNgzZ79/KhTP7ypJylkwlScrbfADLsvIEEUcREghFp0RAZKIwpN/v4Qz7SETYtoVpmlSrNWy7SKVSTQ3YAqq1GsVKRfzdICCKEyRFpVgqMzu/yMbWFoPRkEKxnI8qKpUKly9fZjQaMej38QwDz/MYpbNLMZd0CQI/nxEvLS1hGDrD4QBZFks1wzRzxpWfjk22t0VLbKVLPd/3URSFQqGwD50wvfA5mDQPQr2AWybZ6ftkv6so8p7VcXo/WZYZjYboup4vzwzDwC/5yLqGjIqiqqiajqzsN3a7m+Iwcb5PI5EgTj+TcRIjSYgPtySlXHKR7C5cfJOzZ8+iaRqf/OQnqVWrSKm69+7uDuPRmLEzZjDsY5omxWIR27ZRVZVSqUSxVGLkTCiVSvi+aPmRxPwxiiJs26bb7Qqf8rR9dl0333xPt+We5+XUyaylz07+bDYJvGW2lymPF4tFIVjiurium1dpgIAC+WLmquk6Qbq0KRaLdHZ3WLtxA4mYVrPB5uYWxfvLeJ4QsiBdwBQKonWWZVkkXUBSFXTL5IEzZ+gPemzv7PCRE/fQaLQolUooikKn0yFINSu73S79fp8gCDh+XMw9r127lr8f9VQLQFEUuoM+pVJl3+vN7uf7PsPhMKexZom4Xq/n3j9ZG66qajqDNvZ/Rg4krdxS5BYLpOmEmSdcCeIkIoljlHTmrKTIAMuy8sp3MBiwtb1DLIGuWRTLZSqVKuVKFcPQuRvjMHG+X+MAXlHOKzvRcjuDAZKU8NprrzE3N8epk6dYWlqh3W7nmMA4iXF9j0l6clqWxezsLNVqNWW1KMSIAX+xVEq1F8U8z0hb0mnzsmk8ZtZCj8fjvCXPEl1WmWaVT/Y42bx0GlTtuu4+gHlWbWbb3CiKcobP7mBIu93GMAxmZ2dxXZfLly9zbGUJ311gd3uT3d02lXINbzLBGY9ZXFxkeXmFQqEonqNpsLmxQRRFjJwRtmWyuLCArCh85GMf5ctf/jLPf+s5ZlqzlMtlPM/jc5/7HK+//jpRFOVb9WKxyMWLFymVSoRhSKPR4MjSEs1UVX19fZ3uoE+xOMKyLIx0yaOqKpZloet6jiqwbZutrS1mZ2exLAs/RT9kM9FSqcRkMkFV9bckQ9jPRsqO+61ER6YTJ1KMLEsEaSWvpu9fdsGsVCrYtp2PV0zTxCzYmEYByy5gFwp37XwTDhPn+zpyi4kpkLrnuvTaHXa2t4CYcqnK/Nw8pVKFyWTC+vo6XhjSbrcZ9HvIMszMNLFte4/5kVaFkiQRBqLKLBSLjMdj6vU6lm2jKCJR7u7uUi6Xc9B6dnJm4r5Ze2kYBsViMa9Cp8Hevu/nMmbZhh4QFwDHoVar5UlSWNVCsVigWCwxmYwplUpcuXwZx3FoNhoULJsL58+xu7vLI2ceYmtrg7Ovv8Z4NOLoylF6wwGXrl7hxMmTtGZmSJKEyWRCqVzm2tWrVKtVRuMxC/Pz2AUbJAln4lCp1vnkJz6NMxpTLpVJkoSXX36ZyWTCPffcw+XLl7EsK0+ohUKBlZWVPejQZMLmzZucf/NNrl29SrPZxDSFJFuj0diHVx2NBKA8S5zdToednR2KqfqSqigEKczJ0HUs07zt8ud2HPf9STYmSTKoWIwiSaiyhBvHhGGAqkj5+ymStEpzZobFI0viMaKIzZ1ddnd36Q36VCpVmq0WlmW/h5/4OycOE+f7NZKEOArRVIUwCkkUReACU6UjCbAsE8uyqVZrGIbBeDwmDENs02QycVAUWVQ6mo4zHjMcjJmdn2M0cihXNeI4pD8YEcUxN9fXMTQNSRGiyWEc4Hs+pqkTBB62ZeF6HrIMhmkiKdAf9ikUbQqFAqqmiRGsWDcQJSHO2EnZQxExEaViCUkR9+l0O3iui2FomKaBJJFqQoqTViIhDDwKtsmg38MZDmg0G0SBx9ruNt1OlyQJuXH9Kq+fe51mq4VdKPDmpUssLi7yxIc+jGWalCsVFF0lCiO2d7cwDA3fdykULEzDQJHFcfVdn0FvQBTFaeVn43key0tLAioky2xvbbG+sYGqqqwsL/Poo49y6eJFoijCmUy4efMm/X6fleVlHnv0Ubq9HsNhnyD0GfS7FItFSqUylUoZ09CYaTXp9bpsb25Qsi02d7Zp1WvUajU21m7geh7LS8toiugOhM4ggEQQ+Ozu7qTttVhOZa12FKUeVLJoo+M4JIpCEgQTTZJVXGdC4LvIUoKuKqksX8LO9jYgWEVRlLKV4gRJVpmZnaVer+OnMLMkjkjiKF0sHcKRDuMvOcS5IaHIMm66mLFsmzAISeKEWq1Oq9XEdSdCyKNeR1Zk+v0+7XabBx54gGKphOOK7W3gBxTsIppqMBqNME2TMIpwPU8oLakqw/GImZkWcYrVUxQFRVUwNEu0/4pgmYhlTwbcVigUC4LtQ5JXsYqspLMyN69uDcNAVuR8+eSkFFGBZwRIiKKQOI4wTBtZlhgO+5RKJQLfxfc9rl29TBzFuO6Ezm4bRVWR4giShPF4TAIcWV7mvvvuo9VqCfRAHCFFwg7DUkUbbKaLGoCJ4+Qz2kw1Kgwjtre2mDgOlmWhaRpbW1s0m6JyzyBR58+fZ25uDtd12draQlNVjq+usrq6Sr/fp1gsstxq5vjMyWTC2bOv0el0mJubQ0pg7eYazmjMmTNnKBWLXL92TXj+yDKGpiHLApoV+D7IYjYqttkiqWUjk2m0gjQ11gnDkDAKkaRU1k8RCku6pqTGfgIGpeka3mTC9evXGQwGAoMbxySxgHfEKQU3I0+IjkLA5ODu05Y7TJzv20hSMYl0VpjOOW3LQp+bo2BbTByHWr2GmuIsvTQRihY8yNlASQLFgoxhqIyccSonFhGlPPA4EQsLy7ZzvGbGaNF1fR/sRU6hKEEKT9JU8bdJQFX2sJZxCh1KkhhN1XKvIxLwPV9AilQNXdeIwgBZN/DcCYqSOTKGwufc97l+7Rqu5+YXkfF4xPbODuVyCTnl0E9cF1lRmZmb5djxVcIgYDQe7cOLgqA4Zouu7JhlwPts/OB5Hr4nqJvFYpE4Sdjc2kKWZWZnZ4miiMFgkOMZNU2jUChQrlRoNZuUSiV2d3dZWFxE0zQmkwnD4ZBer8fu7m6uOKTIsqjKU3TB4pEjXL1yhc3NTfSUqDAejShXKqnSf0CcV3jZ5yPB0LWUKx8RhoEgR6Tvw2QyEe+BrqGpwgk1IU5n6AlqCmQfjYasb2ykF0Ho9wcMByOiMELRNEiNA2NJQk6REhkETZbvvjRy973iOySyD6WZwnGSJBEffq1CFAZsbQpV99XVVSHS4E5SeJKwefB8H00XSSKJk/QE2lMwiqIQOYW+dPu9HPZj6AYJe/fLGEU5Oyids7kTF10V/Hk1VVKSEJt/ZzIhCkNkSUKShSGcjBAM0VQVTVWJNQ1VkSERM7aEhE6nTblcxve8dNMrMej3OHv2LEePHqXRbOI4DqPxmChO0AyLIIqpFC0KRQHULhaLmKZJZzwmSRLsQgEJsZXP4EX7xDlgnw1GxpWvVKu55ub169fZ3NwUtEvbxi4UKJZKNJtNNjY2MAyDpeXlvBJtdzoUikV0Xefq1au0221GoxFRFNFoNDh27BidTofJZMLi0hGKxSJJktCamSEMAi5cuEC1UsGyLEajEc2ZGRRVJfC9FDMqtuy+56IpMvVGAyCnw5qWgC9l6ARx8dCQJAFaT+IE3w9EpWkYjEcjrl+7xvVrN6g3GhSLZXr9Ads7OyyNRhTLZVRN3bedn0ZFaHfhjugwcb5PQ5JkTMMgmdpIq6po4XzfZ3NzM1cg11N4znA05NVXX+XTn/40x06exPc94ihiMnHZ2W4LELuhi9YOwQDRVBUZUbWNx2IpoqipgG4Us727k6sc6bqet+xZNeZ5HoZhEKTVoWGahGGIZZqoUUTg++K5RRGj4ZBCsYgsSSnUR8CbNF3n0sWLnD9/no9+9KP5ksKdOHz7299GVVXm5uYEmDwSLJ0zjzyMbdvMNGfY2t5GVhWqtRqNZpN+r0e73RZq7nFMfzAgiiKOHDnCZDLJIUDTFXWWSGVZFgD61Jep3+/z4osvUiqVOH78OJZlUalWKVcrvPLdlzh69Gi+LNre3s5FUVqtFi989zsUCgVqtRpHjhzJWUCKorCysoLneWxubrK5uUno+SwtLTE3N0en02Frc5MkSWg0Gmyur1Or11FVFXcyQZbEqMQ0TWxTXPC0VAhlNBrT3t0VjLDsgptW2XsSfTKyJON7PrKi0Ov3uXz5Cs1mi9FwSJLENJtNgiDgzfPnxfNaXEBRVVGpTmE+/6KK/Xd6vOtX/ad/+qf88i//Mi+++CIbGxv8zu/8Dj/8wz+c3/53/s7f4Td+4zf2/c5nP/tZvvSlL+Xfdzod/uE//If8t//235BlmS984Qv8i3/xL3IFnMNIQxItsZ7Ce6IgIAoC7EKBBx58kJdeeombN29y5coVNjc3GI1GLC4v0ZydSdtehfFkwmTiMjMzI6TTblzH8zwkRWYyGuH7Po1mM5/95ba9acImEeZvMzMzYs4aRWJEUKsjAbqmsbu9LVplWca2bAzLJPID2t0OgedRLBapN5soCYRJTOD5GEUVQ1XwA5/19XW+8kd/yGc/+1kq1Qrra2u8ce4ca2trzM3NYRWKXLh0Occ1lstlTt9/P81Wi9ANOLKywnA0FDM402Ttxg1arRaFQoHt7W0URaFWqwGi8szU7zPZvIzBY6T6nKqqCl3SOKbSqPPxT36CarWKZdsMh0NGwyHdbpcPf/RJ0WaHIbplougahbLAwy4fPcrSUZEcPd8nTuJ8zCGnY5BisUi5XKbZaHDxzQv87u/+Lk8//TTNZjNv6RuShJbqBQyGfYGxNC0Ktk2pYGNoGooEcRgxcScMBn16vZ6ovK0ChYL4EuMK4V0ly3vsIWc0ptfu4ns+H33qKf7Pf/kvse0CTz31FKqqsr6+ns+A1VTsehoGJSrZv6wT5C8v3nXiHI/FIPvv/b2/x4/8yI/c8j6f+9zn+Hf/7t/l32e4vix+9Ed/lI2NDf7oj/6IIAj4u3/37/ITP/ET/NZv/da7fTof7EiSPGlmghyqrhIGAVevXuXrX/8683NzHD16lEKhwPXr13J4S7/fF216CqDOONLVspiXKZKMnjJfMvyeZZqpEC+4nsf6+jrVtLXN1JECzxcKEVOVsOd6QghX01FkGU1WUCwd2zGZpMuF0BMzUUNRcJngOGOuXd3mzTfPc/bsa9x33/0kScL/8x//I2EYUiqVWF1dRVYUHn3s8ZzJomkadqGIoqgEQUQQhVi6RqlcpdPe5caNG8zOzorN9MZGDvgPo4i1tTUqlQqFQiEfa2Re6cVicT+cagp8Pjc/L1hLkkSxUKBg24J2KMt0Ox2q1SphCljXdZ1Go4GiqmxvbWGYJpa9B7UKgoDFhUUmk0muVDU7O0voB7z44ov8/u//Pvfff3+O+Tx79iyXL1/m3nvvJQxShahmE8s0CP0A4gRbUZi4EzY3Nhk7YwoFkZALhRJaCv/KiAWTiYdp6qiyjKqpbG5u4fs+p06dYpIuDs+ceYRGq4WdqiLpxh6E7CBjSfz87tPlfNeJ8/Of/zyf//zn3/Y+hmEwNzd3y9vOnTvHl770Jb797W/z+OOPA/Av/+W/5Ad/8Af55//8n7OwsPCW38mG+FlkQO0PeuQg55RyNxqNuH79Oi+/9BK9TpvZ2VlOnz6NqqpsbIiKE+D8+fM4jkO9XqdYLGLoBqHvMxyPsW0bL7WWMHQ9T8ylUinnwwe+ALYPh0O0NOnKkkzo+ciSRLFUIgoCJMB3PZIoRopF61solgh9j/buLrKsUE+hUrKiEIUh3Xabm2s3Wbt5nd2dHTrtXfr9HltbG+zsiMo1DELau21KpRKPPPIoIBMEIaqqo2oaSQK+H6AbBhIyCRJOOte17SLlSpX+YChU7BWV0XhCEPhUaw0sy0RRVaHlGcZIkoJpmRSLYkQRBmJRpGp6qhcgkSQRiqoTxwlBmOJYFRmQKZUqxAk4zgRJUigWLWRFYTQa53/fGU+I4xjLtKlWDCRJIQpjZFnF90MCKaTWaPL0Jz/FubNnWVwUbX2v18f3A1599VV0TaNUtBiPR+zubDE/N0+lWqNYLDIcDgjDCE0TM2vLsiiWSuiaQZjibzOyQRhG6LpKEIXs7u6yfnMdTdNYWVlha2uLVqvF/OICqqaiaCq2rueqXKJLF3z1PWD9XZYx0/i+DCi+9rWvMTMzQ61W49Of/jS/+Iu/SCMdYH/zm9+kWq3mSRPg2WefRZZlvvWtb/HX//pff8vj/dIv/RI///M///14qu/vSIHvURShqML/ZjKZ4AcB5XJZgNqB4WjE2BnnNhfXrl3LbRBmZ2eZm53D1AVu0XNdEgmi9HFlVcmrm6yayCqxTLZNCD+MUKRU0k7VCNKLWZIIFSGAhizjuS5+mvzC0MVPt9bZ0qrdbovvnTGqotBoNKjVRRschiGWVcP1PCYTlzCKQZZyEL1dKKBpusAWAp7vp2rtEZ7voygq1VqB8dghiuIUiymA94YhKvE9jyVFLMQyj/R0Viel7agkCXEVkSCkfaiC9M0RYPOUkhjHYpaYAMOhEEY2DFNspRUVXVdSVk6aeA0DTdOEoEmqsnT8xAmKxRKzMzOAaKsbjSa1Wl3MknWF0XBA6HsospD5C4MAwzSRZRVZVpAlsTHXFAUJCTf9vIjFVYQiC3bXG2dfw0lxv6qqMhwO8TyParUqLpT5cRDJEuSUjnF32wJn8Z4nzs997nP8yI/8CMeOHePSpUv83M/9HJ///Of55je/iaIobG5uMpN+MPInoarU63U2Nzdv+Zg/+7M/y0//9E/n3w8GA5aWlt7rp/6+i/zDmf5X1TQajQYP3H8/hq6xs7Odi/9WKhVc16Xf7+cqPFevXkXTNGZnZpGkBEPT6PV7KKqaS4VpiYaRLhLEzM/HnYgKTVPVVPChgus4FIvFNMHGBIEvbCpkmfbuLlEcpapNvpjpxTGj4Ugke3fCaDjC9VyGgyG1eo1qpYqha2iaiqaruCnPPVMWD4KAOBGJLDuJdV0swpBAjsGZOOnMTcwMs+p4a2sL27YxDCO/AGSLGSBvwacxj1lMW4OQJk9JlkWrLqcmdKnYSpzEhGEklN11LV+iBWGApmuEWcJPsaDZBcSyrJzSmsQxfhDguS7lcplWawZvMhHH3dBzqb+N9TU818U0hIB1p9MmCkOGwxFLS0vYhVK+uFMVBd/1kKQgX86FUYgkK1iWiTMec3PtJpZlkiDGMrvtNnNz8xQcB3cKkpYkwlJdpMxbO3TejfGeJ84vfvGL+b8ffPBBHnroIY4fP87XvvY1nnnmmb/QYxqG8ZY56d0Q0340mfhtMaX5TSZj6s0GzXodQzdwJg5Xr16h0+3wxBNPcOXKFW7cuJEvIJyRqPjCKGAw7FOuVCgUi6lMWogUierJnTjIMmiqwvb2NoHrMdtsousaummgqgKMPR6mAhudDqahMRy6bG9usLu9Rbfb3eeRZFkWlXKRhcJsDtY2DANV11A1FU1TMD2f4XCAYVopJKYISAzTRGPbtlDjQRILFhkKhaKAXysKlUpFPK/xOBeq0DSNarW6z88nN1J7m0j25QRRdSkHsIrCciRm4k6QFJkojgnjCNM0adotJq6LM3HEPFUCP/BJYkGxzIQ+MsxotuUXM+kYRVNRNI1CqUSzNcPc3ByXLr5JFCocW1lmd2eH9fV1VFnh5voGrVYL2xJ6oFqxhG7q7LbbkAj0QqLIJIlwtNR1lee+8S10XaNYLHL1+jWCMOT+VosjKyt0+2K5NDMzQ0FW0mrzbm3Ibx/fdyzB6uoqzWaTixcv8swzzzA3N5e3dlmEYZizKQ5jf0wLa8jpQiIMAgaDATdv3sQdO8zMzOQngqIo/LN/9s+wLIuPf/zjmKbJ1tYWi/MLjMdj3LFDf9BncXmZmVYLZzzm+vXrnDh5EmCfRmS1WmUyGufsH1mWRXWU6lB6qYbliRMnaLRa9Pp9/uxrX2MwGOTCxkBeYWUYS13XUXWNsTPGcVK8pV2gUhWK6aVyGcMUs8KZKM5VorIKEMhY/HkkSMiKuk9UOYPgSCmBIK8i34OQJAlNFcB3wzD23p906ywoi2K+qKoCy6rpGqqqkZnvZRCoTMiDFBepqip2oYDnuozHI7yJS7VW4xNPPcn6zTVeP/s6Fy5cYne3wwMPPcjRo0eJI8F/9yIXSZYI/YDlY6tcfPNNCrZNpVbDDwKe+/qf8eaFC6ysrPCHf/iHjB2H0/ffx5Eji/TThNnr9aYM9zhwpG9zPN6To3rnxPc9ca6trdFut5mfnwfgySefpNfr8eKLL/LYY48B8NWvfpU4jvnwhz/8/X46d1RMazBO+5armsbCwgKlUolCoYCsKKxdv87zzz/PK6+8wqOPPspHP/pRWg3haBlHMZ1OBxBq7UmvR2dnBzWFuhiGwcb6eq6sNK0bGYYhtVoNu1TCGY1w0y10qGncuHGdeqvJ1u4O33rh2/T7fWZnZlg+dpS1tTUAGo0GCwsLzM/PUygUQFWRkgTXcYRmaBSCBIYu1HcUVRW6zUlKzZYVpEys9xZJb9r6RpYVdNNCN619bSVMCUK/o3ind0xQFR1V2S+tFsURui7sJCzLRJIEO0eSFRIkAl9AoAA0zUixpBJBEEIMiSyhSCoSCnEsUSxX+dSnnqFsi5npZz77eZ7+xKdZX19nY2ODf/2v/y+cscPi4mKK5RRLwuh/fE1QaZstBsMBV65cYWdrmw89+WS+/Dt17z08/vjj1OsNJFlU4nPzi3d9K/69QkrepRLpaDTi4sWLADzyyCP8yq/8Cp/61Keo1+vU63V+/ud/ni984Quivbh0iZ/5mZ9hOBTA7Kzd/vznP8/W1ha/9mu/lsORHn/88XcMRxoMBlQqFfr9PuVy+V2+5DsjMhWbLKZteIUXttCxfO2117h69SpxFNGo16hWq9Trdebm5pg4DiSgqxoKMjfX15m4E6rVKrVmQwDng4AgDNlKBSNKpVJOR+x0OmzeXGc8HotkCnnbu7W1lYOwO50OkiTRaDRYWlpiNBrlTKVWq8Xi4iKtVkvoeSYJge/TTasawzSRVQVDN9HN6QS0lxKz1w3ygTb6nR7HKY3K96g2StIZpyzJ+/NsklbDqWiGJEupWnqSs8G8iZsybg4C04E4ydWkMsdMXdcpF216nTaDQQ/bLlCwbNptoVZ07tw5XnvttZwm6zhObo8yOztLtVKlULCZm5vliSc+RCJJbG5v40wmnDh1kvmFBUDCtgvp6xL41oyGejdVnO80t7zrivOFF17gU5/6VP59trT5sR/7Mf7Vv/pXvPLKK/zGb/wGvV6PhYUFPvOZz/BP/sk/2Tej/M3f/E1+6qd+imeeeSYHwP/qr/7qu30qd0UcVPWOooix49Bu77C9s02n02FlZYVqtYKmqqIdT4U0ut0eE8dB1zSqxTL9Xo9CqUAQ+EIRyBfcdlXTsC0TVdOwLBPP9fAmE+IopFGvE4UBzngk2EyWiW7oGKaBoiiUK2UqtUoOHq/X6tT8GlIq1WZbNqquMvEmuBM3FWWWcN0JplVA1XWxrFI1sQyCveoyQXi850uyJDso+fGR8kpSWDnkiWsqsmT5jpPmO6wlhEZqIqrEqd+bpqaGUSiYPrJ4PVEUkZDRZ/cWSpkMnzuZ4DgTkiltTd/3mXgqkqygaDpBGDEaOyDLLK2s0Jybo95osLO9Ta/Xo727Q7/XxXUdNjfXKReLLC0ucO/pe5mbnaXT6zIzM0OlVqNSq6JpQtgkR3GEUa7cf3fqu3/veNeJ85Of/CRvV6R++ctf/p6PUa/XD8Hu3yPSxe3U93vVl+97DIYD2u02M61WTufzPBfX8wh9H0mWcd0J3W6XKAjZVbZZW1vjzMMP0+l00E0TwzSEEpImvLKzhY4kCZGNwPcp2gWxXHIcwjDA80DVVI6fOJ6LWwC5ZW4UR8RJTKVcEQlMIq+cMpfNQqGAXSximBaabqRSZ4oQnxCvNn/dSboO2mvT32Iskq58pfz++47jVIueP9Z78f6k/5+fCwfPiYzXHcckioSUSHuCzolAOKiqKsgBqU1HFEW575AiK+jpfYSws4JVKKBoggARhzGWqlCwC9RbLRREtbS9vcWlC2/ieS61WpXxaIQii/dzNOhz+dIF4iShUK1RrlbQND0lPaSKSmnCzqw7DuPWcXcSTe+AyM7D6VnT3qJImHu1Wi1On76P8XjMYCgEb5vNJsN+H8u2SRLhIdTrduntdrh69SpLK8s4jiNOGl1DSzF7o5HQ5SymfjeqqhL4PqN4z7UxE3WI45jFxcVcQKPf79Pv93NmT7bgyEgLWdsnSRKWbVOpVJBVTcwdkUEWMJoEOU17t7swJ/sTZh57G4yDs7msTX73b8D3ujkVuyCzApH33xon6YVDtOpxEhNGIkHu2SgrueeP53lTmgQqiqzkavkZPTMhxooswjAijoUM3ng4wk8haK3ZWeYXF9BVsbFXJJnt7U0URWZj/Sb9ThvDNJlfXGRGE/oGiiIUOvbcLwMB/pcyCNJh3CoOE+f7OKY9yzOv8ziOsSyTSmWFoytH8QOf/qCPruvMzszg+z6XLlwQtMtej16vR6/bYzQSro1f/eOv8PFPPC3sbE0zr3IGg0GuRG5mauOSxM2bN3EcB0VRWF5e5sjSErqh852XXqJer6MoSm5/EQOu73PvvfdSqVTy5wvk5myqqpJIElEcIckqSHLeojPVdmd9tywppGkKKUuc0t4ckfT3hICylP8PUuZVnlHf/fF/219JSAV+5f0ZJpmqiCUJNYUxTTt3ZhtrSPZBtjJL4yiKCIMw1z/NKj9ZVun0BkLoQ5YplsQYZNAfMRz0kSQoFYucOXOGI0eO8NWv/DG9Xo+TJ06wuDBP0RZq92ahKLRFCwVUzcjZaZkpnIBKJSTEKNJdaGH5DuIwcb6P46DLYWbFC2n1mUR02j3m5+ZTQdsIVdWYnV9g4riomk4QCmqdMxzxV//KD/Erv/IrBKHHn/7Z17Asm7m5BeYW5jl9+jSzs7OcP3+eC+ff5Pr161y+fBnbtnn22WcxDJOJO+Hc+TfwgwDLspibm6Nerwv6YlpJGYaRKi05OTQHQNNkYbMgTdeMcj6XFEnzrRVlsq/KlNjLljJieSZN3Xt/5FWhtJdM38vILi7ij72Vw53PL9MkbxgGlmntVcXpgilzHM0WQXsbdw3TsgAIwkBIB5JgFwvIssxwMMIumMwuLOaeTRPPQ5Fkjh1f5XP6D7K70+aFF7/Da6/pnDi+ymOPPcrq6iqtxSOMJhPW1taRZZn5+XnB3LJtoZqkKodJ823iMHG+T0PMOOV9CJyp8y2tQmQMw8TzQqJIsGEMVWVp+ShhEFCu1ak1GrQaTc6/9gqvvfoyp06ssrOxTrvbZTAYEoQRpmXy4EMPkSQSu7u76IbB3Nw899//APPz88RxwrGjq+KEVWViBORGSbfkMRBEkRAPdhyinR0WFpZQUkM4UcXIkLezSS4mIkt78MyEzK0b9kq4gwnv4O3y1P/vv7+8bzZ6q8d6uzfge90+nc4lEknAoQ6GLMu31kefAuRn2/ZMiCUTZRHUUnGbpmnIqoIkS0xcF9/zsQo25UqFKApQDVOwvsKQOIzY7QhlqlK1xuz8oqCtxjKdvsM3nnue0eRPabZamJZFq9Uimmli2RbOZIRtCZWyzAZFykYqWewfvr+z4/kBi8PE+b4N6bafSfHzBJDRND3lcoe4ric2sgkosowkK9h2gWq1SqVSpd/dRVdV/MBnYW6OpSNHkFWVudl5NENnOBAGZpVqjfn5eZZXVtjY3GJxcSk15ZJwXQ8/FMsnTdPwfZ/RaJTPMYuFUkrN1NK2VEkXTvJU4k+QpLS/laQDKVLK2/G3PzpMJeK3PVDvPt7B7x28x1+oop36O7IsrE8URXDopxczqqoydpyUNinnIH9FVoiSmMFoxMT1gBhN0TA0g/HYYWn1OKe3t5l4HrphsHr0KJVyhddffx3V0InCkIWFBRaPHEFPKaGmYeY2IpK8v9bPYl91vzeMf/ev/w6Ow8R5x4b4oGac5zAMc/XyJElQNU1QC+OYSqVCo9kAAiaOQ7W+xOrqceqNJoZpUiyUOHvudVaPnUBSBGOoVCrjeh6zs3OUiiX8wEdDQ5EVVEUlTiuhjD6YLTwURRXyd5lohpQlzVuA16W/SLr5YJ6gmcBKhmyYdgMNwxA/8PPjLKfLO1kSUKUoTE3cEglFVbFNC8tykBWZpeVlbty4kbsCWJbFqVOnsEtFqtUqc3NzFAsFIYwVhekCMCUcJFKKCtsbl7xL2PcHNg4T5x0eGSA922aD+HBnODwpibELNuVqBcvS2Nne4b4H7ueB+x9kZnYOSZbpdXpcunqF1eOr9Pp9DNOEFGu5vHwUTdPwAqEWruoqumoQxWLTrihKzr8WVbKUqhxls7xpbs9eHDJT9iK72GVOpY7j5N9nDK7s+yAMxfucCpVknuiJphOGQa7QXi6XGfR61Ot1VldXOX/+PDfX12nWG5w5cwazYItxgKKIcUuatHd3dwnCWPDfC6LLOIy3xiFQ6w6PDB6UJU8tNfnKqpUojokRNE0kiaWVZVaOHqWWiu0OBn3OnX8DwzToDwbIqsrIcfDDgAceeFDwyItiAx9EIeOJg+u5eUuppWLIYXpCy7Kc+4eLhDClK5pG7l90mDzzEHx9oegUBAGO4+RkhjAM0RRVVPqprUiGjY3jON3GG+iahh8E9Ad94R0/GqHrOo8//jgnT57EGTucP38+59RPJhMhqDwc0tndZWNjgxdeeIFvPfcc3W73sLp8mzisOO/wyNq3rNWD/WwjwWKRMCyLj3zsSbbWbhLGEbKmMxiP2Wl3OHZ8lfX1dV595VUePHOG06dPY1kW7U6bhYUjOJ5LfzigUChQtAsoqoCsOI5Dv9/PTcIkScYriM3wXsV5iAb8XpFd9Hzfp1AooGka/X4/9y8ql8tIksRgOGDaQ0iWJMajcbpQkvd0NAFUYRdy48YNllZWOLq6yu7uLt/85jf5P//1r3H8+HEajQZBELC1vc3Va9dIJCEL+dhjT4AkEccJt9h3HQaHifOOj2m5tOy/mRzd1L1QFBnHGROTCP+fdI42v7CAoev8+v/9f/P005/kxKmT6LqO406QNZWLVy4TxzHHT5xgPBqxu7OT9ymj0SivlIR8m4am6rk75GG885gWcbEsK/8+s3tutVpIkcDCaqqYX0fxHi40YxmBYGpdvXKFgmVSKBSIg4BysciTTz7JU089xdbWFr1ej6WlJW7cuEGz2eSRRx7hvoceFO6iqRLWYb15+zhMnHd4ZKDqLKZVyjPldN/3CcKY3XaXXqdDdzhkcXEJwzBY39zkv/zOf+GhMw/zyONPYFomk8mEMG3/G406iqqwubkhXDZVFUkWVhvVajVXgc/sGZL44DM8bMm/V2SMrMzXXZAcrPy9zFpy0zDTpU1CFIZEqf4ngKpIuXyeLAv3UFVRmFtYIPA8bl6/Trvd5ujKCnNzcwRBwMWLF6nVaqyeOEGj1RTz0jRphmEIkpQ7nh7G/jhMnHd4TKuaT3tew55YhqQoaCkwnVqdbq/Lq6++wm67TafdYXnlKE985COUyiXG43E+NwvDEC/w8Mc+gR9RqZgUCnaq2q4xmUzyrbo46ROUqd7uMGG+s5gWV55+P3VdFwLN6czTTBJ0Q/g/ZffbM5cLkYlzDVDbtrEsiyj1jjdNkyRJOHfuHPfccw+bm5tCBT+1fI7DCM3SkGU5JzPI8uH7d7s4TJx3eOzR924NFckcLP0gEJ7bnQ4729tsbGzQ6XbRNI0HHzpDa2YGSRZtvh8EuK6L44wplcuiPdRlDNPAtExUVfjZTDNcBBwqQFPlfcn7ML53TNMwp8VcMs2AzOFTXKii1N9e3ScWPU3LDcNQ6LTKMq7rClO79N/tTofhcJijHwaDQd7iG5aZzjbjFK1xuDu+XRwmzg9IHLSEyBZGuq6jazrD4YjhcMilS5fyE6fRbDE/P0+CRL/Xp1av561hry/47fMLC5imyWA4xDQNVFXJpdsmkwmlUimnCTqOg55ynw8T5zuPt2iGStK+GbWUwot2dnaYRBFxJFr5zFJFSlvqwI9yLK+maYSBv2/xNB6PKRaLbG1vMzs7y40bN+j3ekJEpFQiDEMUVd23cDx8H28dh4nzAx7ZiVOulAmDgOXl5Vx4uF6v02g02N1tc+XKlbyykWWJlZUVKpVKDnXSdV1UpKkgBOyNBzLsYZSCtw/lyN67mO4iMgGQOI5FJanrORwsjoKckBBFEaPRiFqlnIpeJzTqdU6dOkWv1+N3fud3+NxnP8vRo0dppW60lm0L/ivkPuySLL3Fa+kwRBwelQ9wZFjJUrnEqXvu4exrZ6lUqtx33/2MRiMsy2JmZoZ+vy9MvVI8pqIoguedytLFcZx6WQh9ySiKcF0Xz/MolUq5xcZBIZLDeG+jWCwSBAG+5xEFIUGq7g+CXQTkizpd11F0cVuv0yEiYXF5iZOnTtFutxmPx5w8eZJGs4lhWUCS6n7KKKqePtZfysu8I+IwcX6AI9OJlCQFXTN47LHH2N7awvM8hsMhIGakM7OzhEHAxsYGuq5TLBaFp7rjYNkWu7u7OcA9q3B6vV5uRJZtYWVZyf2KDuOdx+3oqAdn15kEXRzFQu8zrfg9zxOUWE3Ftu0cDjZJrZElSaLf79Pe3WU0HLG7u4uh63S7Xfz0PdQ0LWcTFYqiXT+E394+DnuqD0AchCMdnJUpioKu6WiaQb3epFqt0e8PuHlzg35/gCxJjEaj3KZWqMyLmdh4OGI8GhOHEUkUEwZhbs1hmmbumSMEd5X89w9ZJ+88MvJCht08eOzy9zdOkJFQMzptSsecTCZ4npuryAPChC+lznqex2AwoNPt4kwmHD9+PF8mZbPxjLSQPe4eXfYwbhWHFecHJN6uypMkGYmYwPcxDIMoijAMkzAUikoZNa9UKiGlJ1omOhwEAZZp5ssIPxB0P0VRKJVKqKqat4nTG+HDqvPdxe2O1/RFMEnFNxRVRUeotWedQBzvMcdkRck9iyDJ/eXjOKbf7zMYDhmNRuLiZxiUKhU0XUc39FzpP45jgeM8pA7dMg4T5wcsDnLC05+SJOJE03SdJEkEoyQFSY9H4xw0HaRga13XqVZreL6HbduYhkkYhaltQ5wn2uzEkmVZOD4exruO6QtOFtOV577bJUmYxClKvggSgi7Snsp+ttyRxMxaVVWazSbVapWt7W1ee/XVtEr19i6YikKSsRfSxCkrh+/n7eIwcd7hcfDkOnhbPitLcYHZSQFiS1uuVBgPhnzjG99A11UajQaFQoHEtgksD0WSCD2fwcRlPHGISdANI23TBWtFlpWUJ60cVpt/gTiYMKeV5GEqccYxUnp8p+9jWRaywj6tAkVRkGTEHDPlwNfrDWr1Ooau8yf9vmjz07GLJMsEYYBdKAAyejrjPBy43DoOE+cHJA6Cp2F6wSDoeIZp4k4mmKbJ6uqqUIzXdXYch9dfP0u1WuX48eMsLS0B0Ol0qFardLtdCoUCrWYLFAk/FS1OYoSAiG5iGtZbANNpgbTvOR2MD3qSfet7cevIZpxZFTmdGPdZbURx/rMsURqGgayKEYufqibZto2MTIJMqVzFMk0kWUFKEo4cOcJk4vLqq6+yublJo9nEsizMgs2pU6cwTAvTtN5mQXTAKO8ujMPE+UGPJLPPTfAnDqZhgCzT3tlmc3OT4WCA53ns7Gzzoz/6t2g2m0SJYA/plslgPKJYKVMul0V75/hIsoJRtJBllSSJUtjKtNhIkibNW59Ub1clf9DiYAWezSWzGXK2iMlGJdnMEvYD4cXjgKrJkNrWyYhFThhH4APIaLrQRh07Ai4WJaDpJokk4/kBhm4QJxL3P3A/Vy9fRjd1CgWb+fkF5hYX0HUTSVaRJIVsd7z/XTqY/O9O9avDxHmHx3Qlk1UrmfCHKivIskSSxITp7HJ7e5tXX3kF0zSp1+tYpslzzz3Hs88+S7lcFvx03yeMIwzDAITazmg0EidilKBqMp4XIMueoF+mCu97Fe+ez/r0F+xRQO8WkPx0FzCtgDT9+qd/pqXK/W/RHABkKYMnQZzsXYCmK9koivA8T7CFgjC1VolRUoqm5wWYps3CwjyB59KaaVGt1YnjhPHYoViqMBo5+bz0oEb/3jUgYS+J3n0LpMPEeYdHHO+XI9oHJ4kTwijEdSd0d3dpt3dRFIWlpSWKpRJJmkgVReH06dO4risSsUSuIJ8lYkhbQllF1Yy8VYwiCUlK8sSQtZkHedTTVVeWQDKo1N0QB0VYDh6T7HhkF8KDyyGhihSnmUtCYT+MKTvuQA4rsqMIQzfQdOH/FEURzmSCYZQxDBNJFtZ4cRzjOBP6wzHjsUMQRCweOUKxVLoLa8l3FoeJ8wMWWaUgoEYTJs6Y4WjIsNcTJ1OhQKNeZzKZ0O31mEwmnDp1CsuyCIIA0zTRDB0l5UEHQZCfxLIsIytyrqCTqShNW+FO2+NmiWA6stsPyuF9UONWifB73X+6Sp1OtElya4m+7LhnFyxN04RCUgohkxWFMIwIgpA4FnCjycQR7pxxLNhIgc9wNGE0GlEqV/f5SR3GW+Mwcd7hMX1iwt7JFgQBg8GAbrfDxBGzzXvuOcnEddnc2GBjfR3HcahUKjz00ENsb29j27ZgDZkmMYKDnrlXZpYNihKhG9IeFZO96jRrwW+l9DP93DLg9d0QB6vG7NgcTIpAflxuV6kfTKjToPms9c9mpaPRiHq9vk81KUotiJMkEewhQ8e0LAxDCLOEkZjBNhqN/D0/TJy3jsPEeYfHrU6+bMFgGAbVSpVGo0GjXmd97TovvPACjuPwyCOPcOLECdrtNq+88goPPfRQrtkYJzFh2qIbhoFt21OzM4NyuZwD6U3TzFV6Dm6Cs59NLzyyBDvdyt8NcVBgevqiMz2nzirx3PZk6sKYtdtRFO07ppn0XDYbzebLmVhHdpHLKJlxFBCEIUXLpNVs0mzNAOAFacJttMRzvYven3cbh4nzDo9bbaizE6lQKBBHEf1ehxe//W1effVlHnroIU6cOIFt22xtbdFut3NhjqxSQZbQdD3nPWd6jdVqlSCI6PV6ZJJ1WUWSUfey5+M4zlue63TVdTfG9PY8+5qed74dBjZToZpeJGUXoOwLyJNqZpgH5EpKtm2nwHYFVVFodzrMzM7lYtemqiDJMqPhELtQEAZ/h3HLOEycd3hkrV9GlZvW5RyPxgz6PXq9Lrqu86N/+28z6HYZDoe5wVqxWETXdQaDATNzcwJMraqoukYSxziOk0NoDMNAUbXc1iGrND3Py10XBWNFolAo7DupD1aYdxskCfZfOLLqfLpqvNUSbRopkSlXZVV79jvZ40RRhO95eN4Eu1DAc4XNcLFgkSQJnfYOm5ubHD9+DEmSKBYK6LpOFIZ44zGJJHQ5VVUjjpOclXQYb43DxHmHR5aopqu4zKxN1zSKxSKmmSqGS2I2WSqVcF2XQqFAo9FAlmW2t7eZmZsTRl0p13kymeTVSqaopCgaplXIoTMg5mLTAhOZdfDB5dCtIDZ3U0xf2LIRRs4vP6BjOp0ss7a8WCzuO27TUnLZfxVVwZIt5DShTiYTCoUC29vbvPzyy7z66qt88umPk8QJuqbhui4T18UuFEgSGXcywTBtkiQ61JV7mzhMnHd4HFwmTCcnVVWF70ysQcpDt207P6EMQ8wrkWUuXryI57oYuo4sS4TZttX32dnZyeedli2Spe/7+XZdVdV8Pur7/j6VnbeLWy1IbqcMdFvFoPd5HFzeTX8/nUCTJMmN1+L02GeJMWvLs4vkwccXFygQxngJMSk0LAxQJIkkFpVo4HmEvs8f/eEfMjc7w8c//jE0XcP3POzUakO8F29dTB3G/rg7h00foMg22Qc3sZIkaJaKqhBHEbs7u6ytrVEsFvOFgdi6d3PvmTCFHmWRJEl+Gwhuu5VS8bJqKWsfdV3PW3dVVfOK6XZyaQc37XdDTC+AsuOUtcJZZZlV71nizBKsruv57QcrVUVRUGRJCLin71kYBsRhiKYqEMfIEpSKBY4sLnDt+jVefPFFXNdFlgR0zRmJ+amm64B0SyjZYezFYeL8AMRtP+BpUpq4LteuXeNrX/savRTPqWkaOzs7fPvb32Z9bY1er5dDVaIo3mcze99993Hf/ffTbDaRJCl3t8wYKlEUMRwO6fV6uT5kVq36vp//+yCdMGtbD26OD7b3d2q1Cfvnm9OteJaYsmpSVVUcx6Hf7wsbknS7niQJrusyHA4xLUsoVZlmbpuRzTnDMMxnzeLfbm43rKbvq+cJpatPPP00Gxs3+eM//mM2NjYAoUuQHf/8fbhLl3jvJA5b9Q9I3CqZJElCEidUKhU+9OST1GoV/vf//X/n3nvvpVarpfNPk9/+7d9mdnYWFIUgDEmCgDAW8KMjR46gqiqe56Xb+gQ/iLBtO5ck832fwWAgFg7ForAhTmN6g5w9z+mF0X4u9v5Rw60WSHda6367JViW8HJV93QR53kepmnmMC9JknISgu+HIlkqSm7dm1WncRQAEEcRYZo0VUVBFg7RyLJEHIXs7myzsLDAzMwMX/rSl6g3miwtLzMzM0On00FRFGq1BlKqpHUISbp1SMkd2CcNBgMqlQr9fl/M6A7jlhGFIXEUEcchSRSjGxpvnDvHt771LTY3N0mShFqtxtLSEqurq1y+fJn5+XmWV1awCjY7OzusrKwgyTK9bpfJZIIsqximnQsZA7lZG0CpVMIwjLzNnKYDZtVmVm0ZhpFXuQepiNMg8YOOj3DnJM6DYP9sA55BvKZjMpng+36uqD99YZEkCWfiilxGgizvgemDICAKA8EKiiIkxPsahSGKIudaAxcvXuS//tf/yng85m/+zS8wHo/5s69/A90w+Ft/60c5fvIeJpMJll1M32sZM70ITu36s1fCfq76+/P4v9t4p7nlsOK8CyJr99588w08z+Opp57i+eef58033+TGjRuEYUi9Xsc0TdbX15FVhaOrqywsLhLHMZ3dXZIkoVypIEkKruvnWMFuCm+SZVn4FKVt/EEWzPTMLNsgT3vC3yoOLr6mX8/0f9+vSRP2nmPWSuckgwNkgczobhrkPn0bgGkauK6P7wdEkRAoNg09XRyJkYgEFGwLFAWFhCgMicKAQsFmZm6Wgm1y8cJ5JpMJDz30EHaxyHjsoKgKrutiWRZxKvBy2KrfPg4T5wc4JMSGNNt2Zwshx3E4evQox44dyyugwWDAzs4Ovu+j6TqWbdNstaiUyxQKBTzPI/B9EiSiKMmXFMPhMMeDZva101XSbRdXU1/Zbfue+4HKcrqVvx1l8f0a2YWr3+/TbDaRZTlfEMHepv1gZT6tIhWGIVGckCRxelwVkoR8ppnE6ZJO0wSrKwhQVAXP94VifBIjJzH1Wo1mo8HXv/51Wq0Wy0tLRHGCIitourDOiBOB0ZXf58f1LzMOE+cHJG7Zukrsm1FZloXv+7TbbVZXV5mbm0PTNMIw5Ny5c/lmV1EUBoMBsixTLBTyKkicxHtVopCZi3KjL9M0c6uGg633reaUt/r+durnB19rlnjuBIB2ljh7vR71ej1XnYL91NSDVMyD2FzX9XPiQcZBnzjCZM/Q1fw9kFUFfzJBksS4RtVVJo5Dv9fD0DWOHTvG5atXefnll/nwR56k0WwyGo3F46SumO/3i9Ffdhwmzg9A3K7dlZCQJQFXyTCbmaCDLMtMJhOiSCx6lpeX8025HwREqahH4PuMHYc4joU3jayQuD6yrOdb9UKhgG3baJqWg+Lf7jm+XXt+q0VS9u/sd28lbvF+DfG8RcXf7/fz55yJGWe3Z2Zr2ZZd07R9DCORWIVIh66LBVEQhoyGkegS1JRNpKkkaasfOWJhJMsyw+GQjfV1JpMJJ0+eIIgiLl26xOzcPJqu4/k+uzs7HD12jEyp8O6UKH5ncZg4P8AhSUIpXFV1CmWFwXjAtTffZGVlJZ9phkHAjevXKZdL/N7v/z6zMzMcP3GcI0eOYNkWJGDbNoViEd/zCMMIw9CRJYXhaIRlWcK0bYqnPr0QES11TBy/VV9yGpKU/d40ZClLitntB9v0g9Xp9yv+Z/6GOA5io+1NJpBEKKnAtKoo+ShFkQR43dBMJFkkrTAIcT2XOIyRZIlKuZRu08UIRlVk4aGeRKiqwNb6roeMwIju7u7QqNdBkhg7Du1Oh26vzxMf+jBhnGAXS0wmLmfPnmNuYR7TKgJi2WdZ1vfgqkvczWn1MHF+kEMS1sAAUixhmDY7nS4f/shHMXQVKYGCaWEf1fm9//67PP/1b/C5z38WW9eRw4juzg4zc/Osrd/EGQu5OVXVSeKY/ki08rZVSJXJY3EaSRKylOB5LoZpksQRQYrlnFZRsiwLRdbyUUKSJLll7TSgfnr7nFXEcRzni6hMoOR/RUwn66y1nm5tM41SXddxHAfbtgl8F0WRsS2DcqnAa6+9woc//FEMQ2PUH6JqCqZlEXoBN29e59ixE0hA6AdAgm0ZDLp9FF2j120TBAG6ZqDrBkHoiS24LroIfzJh1O8xHo+FQVvRxg8DbKNAbzhic3uX1tw8C8srzC6tUK1WGY8d+v0BQRjSaM4Acmq8d7tK/u5NltNxmDg/wJGQzgPjmIk74er1G3z605+m3+/jexOKlk25UODCm2/yX/7Tf+b06dPM1BuYqkbge+xsbeEHPt1BH8uy0FQVJHBdL68qs7ZZmZIhy7Q7p2d2uq7nZnEZMF7TQErthTOsYpYsMzhOFgdb+Pw1fh8qzrfb1k/PVw8Kc2RkgCxpShJoiookC5jW7OwM3/zzP+fDH/4Iu1vblMplFEVh2OvRbrcZDQZ859vPYxdsyqVSDmD3PA/TsigWSlSKpdSUTQh5EMVUahWRuH0fz9XwPI8/+7M/49PPfApN01i7cYONjQ0My+TBBx8iiiKq9RbFUhHTKlIsVgijiEKhAOxV+iS3Ums6TJxwmDg/cHGrkz1OtTTjOKbeaOCOHaLQRpMlhsMh3/3udzl58iRPPvkkw+GQb7/wbSRZRjdN+oMhZ988z+c/36BSrebJcboqnG7LozDMFZWyBJhF5tmuaRpaaiccRXHOKgJyNszBiifDhcKeItT3C5b0vfjy02pEmqaxtbVFtVrNZ5emaaZjBx9d1QQaIY6pVIU26qsvv8zxEyeIwhBSmqNorXf57ne/y8LCAsvLy1QqFWRZplQqEQYBN9fW8kSaJBHVao3F5WVcx0FRFIIgYHt7i0sXL7KwMI8qKzjjMRcvXGDYH9CoCY+p2bk5JFlLbZ1VVFXLLwTZDPZwOfT2cZg4PwBxuw95llw8z6Pb7dJsNlEVBVVVMHQNKY5pT3ZYW1vj2LFjAFy6fIkgijiytMSJe05h2EW+/dJ36Xa7NJpNVE3Pq8lMj1OYeu2ZxWXtrKIoqJpGHEU5fCn7maqq+UIk+50saU7TMLPXllV5B/Gffxn8jQxmJcsyvu/nre14PKbf72PbNo1GI6dCDvp9JFmiVCqxvLzM+fPnWV5eJkkSIdWXvt5MyCO7KEmShOM4Obso8ANu3LiO57nIisy1a9eIkhhT1+j3hdp/v98niiLuuecekdh1nUq5Qnu3LZK6JSTmVEVOkRJ7FifTC7fDxPn2cZg4P+CRMUtGoxGnTp0CIAhCVMskSWLcict4PEbTdHZ2d2l3u5TKJRrNBsdPHMcsViiXy4xGIxxngm4k+TZe07R8FBAfkECb1oqcbrOzFlxUbHvbcUmS9nGvD2I1p5XRs8rufzVsZhqMnm2/J5MJ5XI5T5Lj8Zh2u43v+8zOtgg9H89zSZIE0zCYn5/n3LlztHd3KZfLaGmydF2XcrnM/Pw81Wo110l1XZdut4skSQwHI9bXbwplKkUmDAKU9Hns7GznI4LFI4tAgjuZoCgS1WoFTVMZj0boqvhvvWkRhsLaWVH2RizZ6zyMt4/DxPkBjywhVStVIUBMkqrrRIR+wNgRYrfrW1scP7HKvffei6YLL5rReIwsaxi6jq4ZjEYjVE9Um5lwR2bL4Lpu/m9FUZidnc1xntlzMAwDWVEExGk8RpJkFFXLq61pa9zp9nv6hM6+pkV23+sEejvM6UFAPwjEQTYGyRLod7/7Xb797W/zN/7Gj2DpBuVyhdFoyPr6OkePHeP48ePcvHkzV6rqdrv0ej1M02RmZibXPq3X65TLZa5fv861a9d44dvf5tSJk8jpMTl9+l62trb40z/9U2zb4oEHH2ButgVxxFf+6A85c+YMceRx7doNRoM+hq7S73Wo1mpCVUmVSBJ537E+TJrvLA4T5wcgbgcYzyq3QqGQ88qTOBLzOAniMEQ3DSzb5iMf+QiPfexJ/ut/+n9wRiM0Q6cxO8e1y1fY2txiYX6R1uyswHJKos0rlUpYtk2QanNmbbZhGBimyWA4JEhb2cyjaDweA4IVEyfkCfDgJnc6QU0LJE9rWAq74vcex7k/dxyYd6Z3yEDtlmXllWG/38fzPO6//3663S5f+oM/4KknP8rMTBNVVRmPx1y5fJlms8lLL72MrutUKmKxUyqV+M53vsOpU6e47/77URWF8XjM7u4uruty+fJlfvIn/t85h9yyTBzH4ezZs/zQD/0Qne4uZ8+e5c///BuUy2Wq1SqXL19kfX2dT37yk9x///0MhyP+7b/9t/wf//r/StWvlBR1sZ+9dfDCdRhvjXf1qfulX/olnnjiCUqlEjMzM/zwD/8w58+f33cf13X5B//gH9BoNCgWi3zhC19ga2tr332uX7/OD/3QD2HbNjMzM/zjf/yP8+XAYby3kVVsmQhHFCYEfkCv2yWKYpaPHeNjH/sYjzz6KN3NbTbWNiCRIJL45p/8Gb/1W/+BlZWjNFstquUyk7HDm2++yc7OjlCIn0zwPA9JEnYZlUoFy7bxXBcJcvkz3/fpdDqMRiMURaGQ2jZk87vpDfq00EdW3Wa6k9nPb6V8/95F8jZfMSQRJBGmoTFxRkjEWJZBq9WgUimxsb5GuVTg9OnT7Ozucu7ceQaDIUeOLNPrDej3h7z2S4xuVQAAkKpJREFU2mtcvHgJx3HRdRPfD7n33vs48+jjBH7ISy+9wiuvvEaSSNx77325R1QUhbRaTRYWFoiikGarDlLMmTNn+Bt/42/wAz/wLJZl0O22OfvqaywtHuEjH/4Iy0eW0BSFo8tLfONP/gee75Mk8dscg8N4u3hX6kif+9zn+OIXv8gTTzxBGIb83M/9HK+99hqvv/56DmX4yZ/8SX7v936PX//1X6dSqfBTP/VTyLLMN77xDUBUDw8//DBzc3P88i//MhsbG/ztv/23+fEf/3H+6T/9p+/oeRyqI+2PW72FWYLJbo/jWFD+anXiOCDwPEiXBK7rMu71KRaLvHnxAi+99BKD/oAHHnwAzTTxPI8nPvxhwjBke3uHbr/P4uIiS8vLyLIskmTabsuyjOt59Hu9fcIVmU5npVKhWBTqO3ECqqrl2/lpcd7sOWd6noIxo+cLmX6/T6VSyXGc721ldJuEMjWvnUwmXL58mQcffFAgCFJpON/zcByHS5cuceHCBT7+0Y/lNNc4jnn40UfZ2tjg/PnzeXExPXoIwhA5rUDLlQqmZTEZj7l27SpRGLC8skKxUCD0PMbjMWa5wKDdZmdnB8dx6HTaXPv/s/dnQZLc930v+sl9qb2r92V69sEyA4AgQALgIpqUSJp0yHbQ94SOj7Z7HXZYASlCVoRDIYceHHLIitCL/WLLcc+D/GLax/a1jnwYFC2S4gYQFEgsBGYAzNr7Xl17ZeWe9+GfmV3dmAExJGhL6P4hGtNdXZ2VmVX5y9//9/suK8u0Wi00ReXMmTOYpsn09DSlUonl5RWeeuYZ6jOzSLJKkhzI+mXn/m4/H5d4t7nlJ5KV29vbY3Jykm9961t8/OMfp9PpMDExwRe/+EX+3t/7ewC89dZbPPjgg7zwwgs89dRT/Nmf/Rl/62/9LTY3N4UGJPDv/t2/47d/+7fZ29u7K6A5E2gdPbiFhYWTxJnGvRJn9rskXRIHgY9lWkSRT5hCZBRZEso4A4dOq813nvsOy8vLVCoVPv6Jn+HGzVtcvHiR02fPcfv2bfr9PuOTk0xMTIhlqmEw6PdzuqAsy3Q6nXz5CeTJzzRNTMsSeEPPQ9N0jFRRPptKZ6DybMLseV6+JM8Tc8r7rtfrOUD+nbCdozcROPBkGp0kH2YnRSRxLMD8skwcRciKgsTBMtZxHF5//XUMw2B6epr6+DhKKt6BJLG9tcVrr73G7MwMExOTRFFEp9Pm3PkLkMRcu3oNRVWo1+vYtk2j0UBTNVRNpVgsUkxxnEmSCBhXFOI6Tk6ZjSOhzSlrKv/9T/6EjfU1PM+jXC6xsLBApVIh8DySJGFra4vFxcV8ov+pn/s0ql0kQWgP3Oumcxx7nu82cf5Et5NOpwPA2NgYAC+99BJBEPCzP/uz+XMeeOABTp06xQsvvADACy+8wJUrV/KkCfCZz3yGbrfLtWvX7vo6f/AHf0ClUsm/FhYWfpLdft/FvRSHst9l/x4IDEvIipoPYvq9Pp1elzffepNer0elUmFiaooohQqpqsrmxibtVhuQck+hVqtFK11+Z4OgDDY0aiuc6ToWi8Uch6ioKloKZ8r2MZvKH7XbuJc9yOgg6X7u/1nPNIvR10qSBJK0Sh9RMCJJSNK/zQZh1WqVra0t7ty5w+3bt9nZ2cn5+8VikcnJSTY2N2l32iBLyIpCs7mfu4hKsoxhmpQrFcqVCsVyifr4OPXxcezUJRRA03WK5Qp2oUAcR0RxJCTfJAlv6OL5AaVyJU2q4v0tFIrMzs5RqVSEoj+k4tOCcUXew7x7gjxuCfN+48ceDsVxzG/+5m/ykY98hMuXLwOwvb2NrutUq9VDz52ammJ7ezt/zmjSzH6f/e5u8Tu/8zv81m/9Vv5zVnGexLsLSQJFOWCDkKT86VSWbHt7m9XVFZaXlrj88MPESUK722FlZZWZmVm2trYYOENKpTKmadLv9zEMg263m+M5y+VyDqAul8vYhQL9Xo8kBXhnoPBBvy+omraNoqhkg4ls+m4YBpqm5fCe0X7naHI8Cnf6UdjDe8nUjf7uIEQ/M0kS4jBE0TSSOCKOk9wiZDgcMlarYZomS0tL3Lp5k/r4OKdPn2ZxcTEXJHYch+3tbRxHqBXJshieFQrFXFVK03RmZmbzfZJlQVaXJBlV1SDt9fYHAyQJIfIhK/kq7KmnnmJycpLG3i5Ld+6wviGsUK48fDm1cpZBkrHtAlNT06ysrvJQrZ7CkA6Lp5xgON9d/NiJ89lnn+Xq1as899xz7+X+3DUMw8AwjJ/667xfQyzVY1RVVCmDwYBWc59up8VgkPLDNZ3//f/4+8iyzJ//+Ve5ceMGTz/9NHu7DdrtNh/56EfpD/rsN5vI3Q7z8/OMT0zgpsLFGaaz2+0K++GRx1VFwU8hNrIsUygWBUVzJDLXTNM0c5xm1vc7qhKUXeD3fx6St/17dMAkSeC6vmhhKDK+66KkVVm32WR5eZl2u00cx7x59XUURWFmcoKVlRVe/v6LvPz9F3nyySe5cOECm2vrPP6BD1CtjmGaVn6OFEWhPjaBMsK6OrSfcSwKQkkiiRMcZ0ivL4Dtvu8hOxKGpqEbBnEUcWd5CS/wGa/XufLoY0zNzLK0tMTVa28yPTNJqVKlWCqjGSZnzp7nP////iuL5y9iF4ooinaolXGSNN9d/FiJ89d//df50pe+xLe//W3m5+fzx6enp/F9n3a7fajq3NnZYXp6On/Oiy++eGh72dQ9e85JvLeRVZxxlEASCxk4y2RudgYyGwZN44cvv8QPX30V1/WoVCq8+OKLjNcn+bmf+zkmp6fo9/uM1eskEhQKBaIwZHl5Gdd1qdfrVKvV/MJzHCevQjNPojAMmZycRFFVfM87hOPMJudZ0sy466PDnwzM7/v+oYv9fjQ5wzDM/149krhEYg4xTAMpEefKtKwcn1StVvPP+9raGu12m1OnTrG4uMjDDz8sqsJ+n1arxd7eHufPn2V2dh5dFzf9o/YhQC6AkiEL8mXzCKrA933coU+haFEslVBSO2BJAlXVsYsl+r0Bum5QrVaZmZ3DcRxM0+RjH/0Y//E//keW7iyzMH+KQqHAww9fptcbIMkqliWjqm+vMrMVwF8HvdP/FXFfiTNJEn7jN36DP/mTP+Gb3/xmTtPL4oMf/CCapvH1r3+dL3zhCwBcv36d1dVVnn76aQCefvppfv/3f5/d3V0mJycB+OpXv0q5XOahhx56L47pJI5GAkkkEmSULje7vQ7dTodWu8X+/h6tVgtT07n0wIPUalWGQ5e11TWmp2ZQVZXAC4kj4YDpBcLDplgqUSgUcuB7dqFl4G1ZUXCHQ1zXRdM08Zgs43teKll2QKvMgPMZ1GiUephVo6NUy6OePfcCrcPBQCfrr3qed8hlMvsbQQv1keIETdeEVJvvE4Qhlm2zvLJCq9kE4MEHH8yl+VqtVp6oZmdnWVxcPCRwkqSkg0H6HNsS9hmSLInX0UeqvrSTkh2CrCoUSkUMy0RTVRJJVMKyJBPHIaqq8/gHn4AEWq0mXhBQr0/wgSef5L/+X/+Zbz//PFaxSBDHvHXzJs888wwLCwskkpT3OY/GSdX5o+O+Euezzz7LF7/4Rf70T/+UUqmU9yQrlQqWZVGpVPgH/+Af8Fu/9Vs56+E3fuM3ePrpp3nqqacA+PSnP81DDz3EL/3SL/GHf/iHbG9v87u/+7s8++yzJ8vxn1ZI5K6IvV6PlZUVdna2cIZO6mpY49SpU0zWx3NFnlKpzPTMDPu7+2LJrGvoJKjOgOFQDE2SOMZL8ZlxHGPbNtVqVfCdFSUX/HBd4bqYVZq9Xk9oeKoieWYxqsuZVYRAPnDJeqhADnN6J876IfGRkcFVlqyPDtOyKb5tmBDHhEGMomnIqsrW5ibX33oLWZbz1ZTruhSLRcYnJ4mThCSKcktmy7JodTvIsbDZDdPXl2VZ/JyKRWc3hNH36uhNIBeITmFdYRShqmLAJ56jkpBgmBa9XpeVlRWmpqa4cOEiYRjQ6/VwXZfhcIjjOCiqimEXUrTCYa3T7PvjBkO637ivxPlHf/RHAHziE5849Pgf//Ef86u/+qsA/Kt/9a+QZZkvfOELeJ7HZz7zGf7tv/23+XMVReFLX/oSv/Zrv8bTTz9NoVDgV37lV/i93/u9n+xITuKeISbE4iLVdJ1arYaqKYRhgK5rlMslSuUypUKBQX9AFIXIkizEdMOQZrNJpTaGm154vu/h+z6NRoN2q4Xruniel0+bgyBAS2mIruvmCStK+5ZBEKRiuTa6Yeb7OFpRZtVrNmXPkk5WyY0uIUcHPUd7daN90Wwb2ddo4kwSodLuOA6WaYrEHx0YrJmGkbKmpJwptLy8zM/8zM8gyTL9bpc4itA1gUvN1JyCMCBOhM3uqL7o0cHUvRSZ8mMkIQhDkGVBuUwgjCJ0TRAIwigSA7n+gJ2dXSRZpjo2xubGBrph0u8PaLba+H5AoVhCMwwUVc1vqKMDuOMIQ7rfuO+l+o8K0zT5N//m3/Bv/s2/uedzFhcX+fKXv3w/L30SP0kkEMcJUtqbLBQKkMQgpe+nNFJpqAqarkECnbYQxVVVlTAIcF1XJM5A4AO7nS6+7+eT8KzHNxwO82V3XjGllSyIm6fruiiqhm6Yhy7YLLKKx/O8PElm/clsOxkd8l7J524ycBmIfnR6nA2ePFeAyg1NxzR0oijEGQyYnpmhVqtx/vz5/AaR8cszw7pWq4VpmujVKglJ6kOv4QY+ftqqKBaLqKqaD72Oiplk+3Q0gSVJQhhFBFEsoFmKnD4Wo2kSmm4gRQESGqZlkwAbGxucPXMGPwyRFRU/COkPHLq9PuNT00dkNZMclnQS7y5O6vFjELIsoetpdZHiE6M4GpGAk0gQYsK6YYjvQ6Gn2e/3KZdLqLpGqVjAMgziOKZerzM5Ps7U5CSz0zNUK5Ucb2nbtjAHSyXObNumUqmgpcvrXAAY0cvLEhtk1aPY76xi1dIqLVtK586OScRRLrlIloeXnVm1mSek0eenv3OHQ3rdDk5/wMrSbe7cusnG6ir7jQZREBClg616vZ4D3T/ykY+wtydk+QzDEPjLUgk3H/joqLqWJ8VCis3MKKrZMY6SBzIYVoYqGE2epmmQxDFhKgdnGgbE4ngVRYEEKuUSp0+fYW1tjSRJmJmZSYdtQjz66tWr+GlPOopj4jiCRKj3Zzerw5Ykh+1Kji7p7xdD+36JE5GPYxTiWk0npZJKQkySJx4JXTe5fv06G5vr9Htd4iimsbNLs9Wg3+2wMH8K27RwHIdeu0McRjj9AU5alVJNqM3MUCgWkRPRT9VkhcD16LXalGtV/FQZaWxsDNOy0konwfddwtBPl7IJvufS7YhlP4lIqsPhMBdI9r0humZzmB6ZEMdRKlsnko+u6wwGwsJ4amqK5v4+xWJR2H0kIjFFoc/t2zf54cuv8OCDDzJeG8M0DCzLpFytQhzTaOxjFQu89tprdLtdZmZm2NzcpF6v8+gHHsdLk6Xn+YzVJ+j3ejT297Es0fc1TdGSiOM4/x4O6KWjPcWj7DlJkjBTewxUWZjwkYAEQeCj6DpJnLDf2MPzXGrVMp/+uZ/jP//H/8Qv/ML/Rn+izqDfZW1tja997c+pVEp87GMfQ9G1FNebkEgJIBOFQS4ZKClKDqhPksNiK8e9Oj1JnMc6sg+/SJ67jT2WV1fY2dkmiUIKthDi6Ha7fPf57zIzfYcECc/3qdfr7O3tsb+/z+zsLEEQ4KYeQBvr6wRBQBAEjE9OUiwUcN0h29vbWJbF7NycYBul6kIgoD6qqrK7u5srKNmWRa1Wy+2Ksx6lZZkUi3ZaroIfuKiKhiQd9C2HwyGWZTEYDFAU5WBolbJ1xGEn+J7HoNvD0g2BEBgO2PE9oiAgTCFSSZKwvLrKxsYGQRQyMTmJZVk88OCDVCoVgW3NKkpVZX19nVarxalTpzBN+23KT0dbE+82CSVJgsxB/zFOE5zrunTaTSRJolar5WpYCwtzfP3rX+f8+fN86md/FtOyeOuNN/je977H0tISly5dYnZ2lnK5LAZGlpn6Som0kMQxCaQqSm93HIUD+upxi5PEeRJ5/qxUKjz55JOiaksvjsb2DqsrK6zeXmJubg5ZUWjsN6iUimysrTA3M4UfeGxubuL5PpomtDh7vZAw8Oh1WnhDYR5mmCah75GkVaTr+nS7HdptIdRbr48ThT7Fgj2iBi/lylmlUimVrDMAmaHj4KcJ2jBMdEMXNETfI0ritAL08h6s67pEufdt1t+VUA2dhTOnMSyTcrGIpiggSURhiDcYMBgMCOOY7e1t3FQmr1wus7Ozg23byCmsyQ8ConQYNjs7m0vwiZc7LP13v0lz9G+z/c8k9jKMbLFYxDCM/Hx9+MMf5utf/zq7u7v0ej2MVEj5F37hF/jOd77D3t5ejgwwTAMphX9VKiL5qimDS2BMtbdhXo/jEj2Lk8R5EnlkE2NVkUVfMUkwVI1yqUR7v4lhmkSpf9He3i7Ly8ucOXOGuVMLSLLEzZs3+drXvsZnP/vZAxB7Ci2SJIkkjtnY3KTVbOKnVhp+4OP5PnMzM6iq8M0BAdgPwwTfFy2EUR+iwA/oeynjSRWeOaSwRFkWFbFt23hDNxdIzqbm2TaiVLE+c6aUJIlypUKpWEQGpLQXrEoSb7zxBt/+9reZnZ3l/IULFMslHMdhrF7HsCwkVcNxHIa9HlHqclmpVNIKTToEl/xJeOGZihIcLPEHgwFBEGDbNmaqIRAEAZ7rMjY2RrFYzMVW+v0+m5ubNJtNbNtOlf81yuUytdoYMYL51Wjs0el0coUm0X89bEx3dJh33OIkcR6DeFtdIN3dq1CSJOS0QoqTGCkBuyAGQnqqWCSlwOlWs4nnujQae5y7cJ6F+QU67TY/fPVVXv7BD9BNE01T84tP0zWGzpBer4ckCe/uwUBAm2RVJZ6YTMHyQ3RNQ9PUXIgkjqO8Z5kNTMTUWsUwTFRVVIhy7lMu5Oqc2MHQDRRFJQwjgiBMWwMimYWR4J/LsoIzcEjiJD05Ekkc4vR63Lp9m1dffZUkSTh79izVsRqyoqCoKvV6HU3XCUIh/BGGIVrKP8/YQKQe6Fl1Nirbdr/JJyMKZNvI+sWqqgoBjxTZEAQBCWCYJpWKsD7JNFGzr/n5ebrdLqZpMj4+zsTEBHE6ZPL9kITDEKX8s/QjYFPHJU4S53GJo59vibdl1Ew/UwjcxvlFIaA8gsljWxZjtRqqojA1OUmn28Xp95mZmeHi+fOsrazwyssvI6fyaJZlYRds7GKRKAwoFmwmJybYDAJazSYDZ4Bl2/T7PfxAyN1ZpkG5VIZU0q3RaIhJtKyg60YObxJLU+uAfZTiJhVFxfcDEiQkRSGKEzzPJwwjTNNKeeBCUk1RZVRZodlsCoB9HBMmMW6/z/LSEl/76ldptVr877/4ixQLBfb2G2i6zvlz57BS2ulgMMDzPCzLolqr5Y6Vtm2/zfbjnQD7PypGE23mIxUEAbVaTQxzZJkwleyzbRtF0/LecbVapVAo5EQFVVVxXTd/zw3LAlkoX0myGAoFQXAIOjW638c1YWZxkjhPIk+gQRDQbreRJTGYsW2bJI5RNY0ojGi324zXx5idnWViYoJms0k5ta7104HRZz/7WS5evMjXv/kN1tbW2N7eZvb73+fSpUtcuHAhlyAMw4DhcEAchcxOTzE3N4MsC3sJWZLodbsMBg59Z0C/36dQKFCtjlEslTDTAYa4eFNPIknCD/x8+bm9vU2pJJbUSRwT+EHOh8+qwzAUmpZqysypVCrIqsLandu8/uqr3LxxA03TePbZZ5laXORbX/sahmFQqVYFVlVV2d/fR9H0vP+a9WZt2yZJEjqdbt4CyVxB4e36oe8mEWWIgswULmNgWZZFpiGaKeW7rosURywsLOA4Dp7nMRwOCcOQhx9+mGazmVuaaJommFJRerNMIAoP1KqUfLp+l4/OMV2ynyTOk8jD0A02Nja4+vprNBp7jNfrPPrwFR59/HEmJicIwoBmu025WKRULmDZBiurS2zvbPLII49w5dFHKdar7Hxvi3NnFjl9ap6t7W063S4vvvg9nnvu27iuy+LiIg888ADj9TqWaVC0Ta6+9ioxspjyVkroKQA9CDwoFoXzY6mErhuHsI5ZFeoMnbzfN6qslAHfJUkSgxxZFnJsscgEcRgxTA3rPM/jtR++wfdfeIHFhXl++Zd/mWKxiOu6vPjcc5AknDl/jpn5eYIgYCtFD8wvTqIbwsyu0Wigqiq6rnP9+nVUVadQKOQWIT9pohk1xtN1kbBlWRbCy4CmqrkJnJTEVKvCpM9PK9HhcJhL3sVxnPeUR1lNSIqQ/EsZT1mcVJsHcZI4j3mMXgJREnP58mUeeOASQ2fA3t4eb752la3tbV5/5VWKBZtatUqlXMEPXJ577jlWV1d55JFHeOutt1hdXeXchfM88MADOI5Dt9vF9Ty8lMoYhiEXLlzg1KlThGHIzs42pWKBen1MDDdMk3KphOu6NJstWu02QRCwsHhaTIuDEEVR096hSCKdbhdN18XkO60gHccRtFJVxTCMVEE9plgs5jApyxDQmyQD2Wsa7Xabb3/rW3z06adYXFjA8zyWlpawLIsf/OAHPPbYY7iOw+bqKlEUYVkWY2NjBKnaUgYi7/f7qQ6mhGmaWJaFaZr5fuec9ZEe4rtRIdI0jf39fVxXDL2yhCxJEpKs5G+mlvo8kcRCyzP1nOp2u3S7XQAWFhbQNC131IzjmGK1InRTR8gIWa8z48ocpake1zhJnMc0Dj70B81OWRLLPE1VsAyDgm1TK1XY2d7mtZdfYW9vj0F/QMNo8NLL32fouUxOTXHh4kXh250uH8+ePcvO3h5vvPkmyysr9Ho9JiYm+PznP8/c3FwuhtzttPE9l16vx1s3rqPrOrNdYeamajrFUonp6WkCXwyCTFMl8F0G/R5BFAo73tQAwtA1FFksM23LREoSLENHkmWSKCSMY2QZ+r0+pqGjyCCTECURUeDjBz5vXH2dSqmc+zMNHYdWq8WlS5dy/6ONjQ3iJMEuFLhy5QqaYRBGMY1GAyelmpbL5ZwammnJ3isx3g8vPEmEY6llWYesRLK3Mbf2SLcbBaHQ/OSAndXv93nzzTf58Ic/DJC3FSqVCnrqmyT2S4iRHHxG7g6fOq7V50niPMZxt6ohiiKQJVRFESIc4yqaqvLwww/T2NsliYU8nRcM+dBHnsFzHFzPpVSeYGZujkSSaOzvs7KywsrqqgDBj49z7tw5Ll++TLFcRgKiOMb3BX1ybWOdsfo4qqLmfTxJIue8j4+PIysyYRggmE8ykqIxHAqZtjAU4hpJFDEYOozVauiGIS71VMUpisJU+9Knku5DEkeEQSBwq7KMbVs8/sHHGRurEaYiJZZl5ZXvYDDAcYdYtk2pVEJPVfCRhdhy5o2USeNl4P7DFMa7y969mwQ0qk86up1RmiqSJLRE4WD5rutYto2ZEgsy36KM/pp5QcmKknotiaQppdsT8XaQ+3FNmnCSOE9iJBJS+l0ivpcSwQ+v1mo8+aEn2d7aptftEoQ+cwtzXHn8cXY3N3nxL/+SSqXKqcXThHHM89/5NktLy6iaxsVLl5ienmZ2ZgZV0xim7pqtVoter0en12Nnd48nnvgQcRyzt7dHHCe4rke7s4ssi76nJEm4no+ma5imSZJAp9tBtWSx/PbFwKTf7zMzNYWqqQQj8JsoiuhFIRISge+jyIKWmSk72bbNmTOnqY/VCMOIna1N4jhmfHyc9bU1dE0TUCpFxrJtqpUKYRTR7XQwC0XK5TJxkuTybXGctQbCXP/zbhqgB4IlPzrulqgOPSZKyzzZZa+j6zq2bWPbgljwyCOPCEFpRUHTdQxdR0t7nqLlkN5Q0/bDSbw9ThLnSeQhI6HICkiZGIa4bBRVZWpOKJnvbm/TajfRTZOvfuV/CBGJOCGIYgYDJ4XJOFRrY3z04x9nYXERgGajQWO/ieu6Ytrc7QklJdfHsgusb2wyGAzY39/PBTkkSaJYLLKxscH4+Liw0QC84ZDBYECpUqG138C0bLY3N9jf38ewLAxDp9VuIQPra+vouhjQ9Pt9Jicn2dpYx7Jt1HT6LCb5CbZlsr+7x+b6Opubm8iyzBNPPMFwOOTipUup95KDrCjs7++jpQlpbHycBMHNdxyHKIpyC5AgcA9VlNnyelQ96t3GOyfOkZVDmvRkVUVKEhLpsO5o5hGWSELcJY4iPN8njKOcJZRpqp4owN89ThLnMYnRBbl0twc5WDLGSUwcJyiKimGauI6DrqjUqlUMw2DgOvyf/+f/yWOPPUa/38e2ba5evcrKygof+tCHuHDpInNzc/mAxHVdDMuiUiqxt7+PJEk8MDWFknqyNxoNXvju97hw8TyPP/44t27dYmtrC03TOHXqFI7jcPXqVaIoolarMTY2RhLFrK0s89xz3+XBBx+ksd9AUVUeuPQA/W6XTquJ7wXcWbpDrVplfm4eCcEGOn16EUUzCAOf4WCAJiv0Ox32PR/D0Ll+4zrtVpvx8XF2dnZQFIVCocDY2Bgzc7PYhUKucDQ2MUEcJ4KO6XkUCgWmpqYYDAYsLS0xNjZ+yEcpM6A7apXxbhLU/fRCiWMkRNIkjolTplQGZQIh2dfv93M0glmwGR8fp1QSSlcHPc6TOBonifMk8sinvcmIrUK6tJTS3trq2hrf/8FLPHz5Cr/0y78iem6Kwg9feYWlO3fo9gdcuHSRQrHIzs6OwDAauoDrOEMSQNU0mu02w4GTYws/+XOfZnJyHFmWKVUqTK6vs7qywsbGBh/7yEd45SUx1T57ehHP8/jmX/wFL7/8A37pl3+V27duQRIzMz3FmdOn6LRbGJrK8p0lapUSMtDrtDl3/iyFco2lm28x6Dp0eh02NzdZXV4lTkImxqfodDqsr6/nEnA/+MEPKJfLXH3jDZ555hke+cAHGBsbY9DrMRwOkZtNugOhcl8qlxkbGxPT/pSyWK/Xc1X9jOYZx/EhFpTyXld2krABkeIIzTSFOn2S5Jqgt27dYjAY5ILQViqmMj41SaFYBORcNYlj3Md8pzhJnMch7rKau1sc2DgkueRcHIZopkkShty6dYv1jXXm5uY4d+5cfuGvLC1hGAaPPv4Bxut1gXHc2hLMIdsmQfT+kCUmp6ZQFIVOp4Om6uiGie/5VCoV7txZot8fMDk5wdzcPLVqlWazyfe+9wK+77O7s8PG+hq7O9s0my0mxyfotlrcunGds+fOMT05QZIkVKtlmo0GeztbXLlyRVTJgwF3bt3G83x63Q6rq6s5tvPipfP0ej02NzYZukPOnj2Drhs5l31iYoLJiQnOnTtHtVQmTnVBO50Ow+GQRFawbZuCbROlTKdms8np06dzq+PMrTMTfH6nYdGPHZnWaDr0kWKx3W63izscEkUR4+PjOI7DAw88kL9/qipWFqqupSZ6yknF+SPiJHGexKEQQwHyAYHrugw9D3cwYHd3FwmJ6WnR1zTsAmsb62zt7FIoFqiYNq7n0+l0qY3VkBWVXq+P5wvF+GKpRBBG9Hp9MbG2C+iGRbfTod3pUiyVqVZrFIsFZBlSVwe+990dkiSh1Woy6PfotNsYmkalUubmjbeQpIQoConjCF1T6HbaXH/rTeZmZrAtk16vx97OLkmS5K6SvW4X0zQwdI0A0TcNQ5+iXaBWq+V2vuOpV/rWzg7r6+sMhg61sTHBwS+X6Xa7SIpKpOsMXTcXL8nENjLM5WhVmfU3s/hJEueo4PAoHEmWZfE+ptJ5nuflmFHf97lz506u8lSr1YQospLZMKcmeicV5z3jJHGexNsiGwoliQBOLy0t4bkumq4zXhLajW46Ke73B8KOwy4C4DhDZEVJK7YI1/UIggBFVYjjRHwlCAEPVUWWEwqFYjqFtjHSlkAYiMl3qVRicnKKIPBx+n2cgYNt2SwuLiJL0G63eOihh5FkhV63x/bWNjs7O0KlfrzOoN+n2+ngOAP6vT6Dfp9Siv8sFArUqlVkRSEIA2zLZnJyCj3FXtbrdc6fP0+1VmNxcVFUyYMBlWoV27YxLIter4eaGtN1u918+ZtRLr0U1pRVnhkELJ9g3weO834jTkCWEjRNF+6kvke3283l8DIbjzAMGQ6HSJqKaRiYpn0sNTbvJ04S53GJrDIRDrTiApayn8U3kiSTJAcXdBzH9Pt91tfXkYGHH3kE0zTZ2tyERMIfDqmUykxMjOMHAd00iYyPj+P5PpnbY7FYFH23MKBYLFIsFHE9L2UTRZTKZUzDwHEc+v0BEqAoEroutDc//OGnuHPnNm9eu4YkKczOzvPoY4+xu7PLxQceYG52nus3b7K6vs7G1jZJHPPkE0/Q7w/Y22ugqQqVSoXNzU1u3brF6dOnMVJVoFOLpyiVymxsbBKGMTPzcwycIZpuYhWL6JZFEEU8+NBDbO1sUy6XBaddljEsSwDILRMvCBn0eziOwHmeWlgQFiJDLx8IgagEM1znKDTpqPncveJHJtkUQpSb02lqbs4Wdzt0ewNWVlf52U99ijAUcKzt7W0cx0FWFWZnZ5lfWBT0y0xq6i5436MY4OOG6TxJnMchEsSENUlIksMVTso+JmMQhWGELEuo6bKt2WzykWeeJvA8lpeW6fV6JAmsra1x5crD1KplVE1lMOgT+j6FYlHoZKaK6LphIssKSWrSISExcAa0223hr66oBJrPoNujWCxiGhayIqXSchokEbWxOst/8Q2iROLRxx7n4oULtFotEhTOXHyYTrvF1k6DZqfP7OwcT37wcRqNBlECZ8+dxzCEK2UM3Lpzm+88/xz/71/9/1Aql3FcD1X3CMIYo1hk6IdceOgy1doYuqajGBoSEoYtlOtlCTzPpdvtMHvqlDivcYTnDDBUFb1cpN3t5hRSWVZwHAGfyiiYekqJzJbsPwl18eC9TBNvLlenoKhiue76wtJD0w0uPvAg+60mnU6Hc+fOUSwW2dra4qWXXsJxHOZn57BS3/coFMyjrDc+aiqX7fOJAvxJHIN4p6WheEzXDSAhiUPiMKRWrfLHf/zH/I2f+Rgzs1NU+iXu3F5mf69Bc6/B9MICS7dvEYQhpmEydIRlRbFcFt7n6UUWxzHIUq64Uy6XIUlQFRVVUZEKRYbDIZqmpQwciSjwcV2Xft/hyQ89xXA4YH1tjW899xyPPvooH3jiCf7yhRd4/fXXqdbrTE3PgCyzvLaO6zqMV6sMhi7tTgd36OA4QwzD4GMf+xiarhNGERXLZuH0Wc499LCwL5IVoigmCGNAwjQ0kiRCtyyuvfBdbt28weTkBE8++STPf+PrWJZFpVanWCywtr7O1tY209PTuZe5bli5mHKWMDMhkqzifK+rtVF1+SiKcm3OTFXqg088Qeh6rK2t0Ww26Xa76LrOE088wcKpU+ztNykUCmiaRuz7AjYlH3jaj+JPj2PShJPEeUxiVDQ3vUglKa8CxZr9YPgeBgFRFBDHCe12m09+8pO0mw3q9TpRHLOzu0OUxJRKJdbu3MFJ+371+jiyomLYNrJy5IIaSQ6qIgQqBCWSXOSi2+uJpWySEAYhg34fxxlg6gbnz59nefkO9fFxAt+n3+/z4osv8sMf/pDLV64wMzeP47psbW3lGpO7u7tCjb1cIgoDXnvtNcIwZH9/n16vxwc+8AGq1RqdTocJy2Q4cLAKRTEBT9WB4tQJMgkjbt++zcAZ0O0avPnGG/lwxbIsDMOg1+uxvb3NQrpMt22bOJFyr/msOjuQxEvfnR/Tg+hukS2hwzDMXUodxxEapqnIyMTEBMHQ5c03d9A0jfPnzzM+Pp57weu6zs7ODoVCgYnJyUOfm9EK+bgtz0fjJHEekxh1UhQQvThfOme2E0EghCkUWSIIQra2NlBVlfMXzvO1P/8KX/3qVwmCkGKhzOc//3m++93vMjk5ydziIuVqBVmS8VwPI45BEVjArBWgyPIBGkoCGQF7yvYNEH7uQBSGRHFIFEcoqkq5WkWVZSYmJnNFH13T2NjY4IknnmDx9Gn8IKQ3GGDoOkkSEYdhLt5broh2ghDyDTl9+rQwmms2KVdrGIZOu9mkVKkSRhGKlPq4RzG+52LbJutr62LQE4mBWavd4uzpRSqVCpVaPQfnz83NCQdP0xSYzYSc9qmknj6GYYjTkFaEGX52tPq8W3WX/c39xKjFcBRF+L6Hqio0Gg1M02JsrJYb2Q2HQ5r7+zRabSzLygkMo699VIz5uCbPk8R5DENAVlKoSTogkqRRqwQxrDBNk83VNfab+8K5sdmkWCwzNl7HtCw2tjY5f/EClYoY7gSBAHcPHYdCuXRYliwVn0jS15cyL540oUdRhGEYRCm3O4rC1NHSYug4yKkYcKVSwRkMRD9ufh7btnEchzgRnOxisUjBtkkMk2LBznUmMwxlr9dnenqGGzdvcev2HVTN4PTZs/Q7Har1CaJI+JzHiejfZRqVz3/3u+i6hqYe2FYUi8XUFkRnb2MD3/cpl8sUi6JqTQB/6I74KB1AkrKpOnDP5fpRtfj7SVLZTTI7/uwcZDqljiNsSzJNzuFwSLfbFTeHBNFvTmX3MojaKMf+OCdNOEmcxybetjQkFwojW8pnSSIKA5IkxrYLbG1tcf36W0yMj3H27FlKpQrFUolGc59CscjM7Cy6rgusoO+Lv0/7aqINkAmG5BOGNGmTPSOf4Ou6jhtFgu8dR9i2iWEYNPcaqf2u0LWMooher8f8/Dye57G8skK5UkUzDBLDoFwspSpCQhkpG5jouo4kyXiej20X6XZ7bG1vMzE5hSQrhKHQoQzD1HYjnSrv7u5y7epVPvGJn8Fzh+zt7dJud4SuZ6FAFCXsNRo4jkOpVMayC0RxnE624xwAb6S+TXCQOLNKczQR/STDoqPeRpmk3eggStNULMui02nR7/fzarPf7yPLMrXxCQzTzPvTYptvbyecJM6TeJ/H3ZwVyZNXkoDvhyiyUFZ3BgN6vQ77qdfP1NQUv/C//b+wbYvbd5a4fkNAei5fvoxhGMTAfqvFoN9nfHyScq0qqJqSRByL9DjqvSNLcg6yPyq/E8fiIg6jAF0XvcBSqYTrufnfFwoFTMNge3uber2OYRj4nofv+ySIKtGyTXrdnrAaNnQcd0i9Xuf06dN8//vf56HLVxgfn0CSZJaWlnjkA4/RabdBUoiiBLtgo6oKOzs7vPzyDzhz5gxXrlzm2tWrbG9v02o1WZib4fS5cyi6jqqqlIolxicmKFXKDAZCkb5YquRJa3SQMurjkx1XFu8VzCeKorzSzLYjBm+wePo0nicGebqu5+Z309PT1CYm6bTbhEFAqVQSVbKkHAz57rJfxy2JniTOYxF3GT7kWM0E3xfGX9ffekMMTrodZFliamoCRVH4xV/8RWQpyX246/U6dqHAxQcfJAlDbty4kQriFmjs71MZq6WvClIqLnwoGWS/zPZupNpNSNBNAzmQ0sFMTKFcQg9Mbt+4gaoqVKtVQEyKh66b62CWy2WqqR/Q1tYW9doYmmnSbOyxsbJMuVzkYx/7OPV6nb988Qd4nk+pXAYk1tbWAJlCsYyq6gRBmONQL126RGuszo0bN1heWUZRFE6fPi0ETAYDzGKZJEkwDINCoZAdYbrcNXBdkdSHw2E+CMsGRKMQn6zfCeQKSvertD5atY4m6yiK0taDAgnopsnlRx8lSGXwMpZUfXwcgEajQSZ+XCqV0HQl75OOVpvHdcl+kjiPQSTJYbydlMqJid/F+UVtGGJ6PTExTq1aJgh83iyWeO2115ibnUbXdeoTExTLomc36HbZ2toSLJrUQrgyNgaSRJwOPDiypMu+zxIEkDNrQCSMarVKGAaEgfDGkRWFjeXl1OgtyWXbTNNkbW0N0zSZmBBJvtVqMXQdapUqcRgQuUNcZ0AQ+JimycbGBg8//DC1sXG++70XeOmVlzFMC820eOYjH8u520himWroGuVyke+ub3Dx4nmWlu5QKpV44okn2N3e5OrVq1x68GEUWWZsbIypqSkCd5gPfDqdbn6sqqrmgsiSJOXTeGGBLHqNfmrDkTGNRu2E7zdBHa1yxfmXSZIICdhYW2PoONi2TbVaZXNzU1BjK1UajQbdbpdWq8X8wgJzcwv5+zOaOIMgOCSufFziJHEeg7ibbFna2USSJWxbaFiO12tp4lBQFQlZljh16hSvv/4auiamwbamE4Yxb7z1FoksYZqGoE/qGoZlCfvdOEbO3ByRRnxrDiLvuQGKLBMlMYok5zxvTdVyymdF16nVamI4owma4KDbo9vtUq1W8TwPz3ORJAk/EELJvV6PKPQZq9VwBgNc16VSqdDtdnPb4g996EM8fOUKQRiRJBK7u7tMzUyn4hYZm0qcuw899WEMQ5ij7e3ucvPGDXRN4ctf/jJhDLVaDUM3GDoOfhAQRMKGt91u50LCGX898ysSep3BgSe7pmFZ1iG5udH38H4jo1Rmf58ZtIVhgK4KVIKcHl8GWxKK/JtCGMR12d/fT3GnQtQ5Ox9ZC+B+hJjfT3GSOI9BiGvu8EWYzmuRUisKRVGQEM6SUtr3BHLzs8Ggj2GZOQ1T1QSoW1YUdEM/GHxIB6rheWvgHjriB2AlKU+iWZKVZQk5kvF9n1ZTALIVVSZI3Rqz3qdl27jDIbqhs7/fYHVllYIt+pPzszO5HfBgMEiXwwkTk5OUqmMUKxWiWJiZhWGEqh1Y4SZJnC+rQcIyLRRFYm5uDkPXmZ6eplwts76+ThD4acUt5OOcwQBZ04WbpKLkLCE4sNHI+oUHAxstFwP5SfqHo5jQ0dbM6JI9CAIG3R5JnGAWrDxZDwYDOp0Odkm0PLIbTBAEeJ7H1tZWbidSLpcpl8v5SuG4xUniPIlDkU1QQQDhM8V2x3GwhkOiOKHZah8kuFTPMeszZgOJHzckSRJ+N9JBwvB8n2KpRBILZZ8gCDANA8uyUDUNVVEYDPrsNxrs7u6yuDCPpAoQfBiG4m/8gDgSAs2SLGOYBoqsCq1KxGuKAQgpZErsT5ZwwiQAFCYnJymXSkxOTmJYRt7bLRSLKKpK4Ad5UhSMHDOvrke9h7L+bVbB6br+tmV1lgDvd1h0r+l3tg+ZJqhtW4RhSLPZRJZlhsMhAJVyOefy18bGcAYD+oNh/lk4us3jGCeJ8yTyCAI/xfnJSEmCm06qNU2j0+kQRhHICgPXY+i5DIYOxXIJMxW7iOKYKIjuWjXdPVIQKVkVLFoHSGKolEF1isUijuOQxBFJIpwjrVTdJ4lFz3Nne5vdnV0kEnRNRde0tP9qQhKja5qoRPW0qoxioTmaQJQkEJPCb2IkST6kTRrHMaoiqmm7UEBVFOI4Yndzk6WlJX7205+hkHqZ+74voD59Ub2NT0zlosVZkjmq/H5UyHgUt3m/YPOjiewo9jIT/6jUagz6PVZXV2i32/l5XlhYoFqvs7/fxA8CFFmmVCpRKleBAxhVtr1sGn/c4vgd8UncM9bXhT+PZZnomoIEzMzM8M1vfoM3rr7OxUsXOXfhInapzGAohgrFYjF1oAzzybLv++9uYCAdLOPzf/NJs5QvA3Vd5+bNmxSLNvWxMexCgTAdpISez97eHrZtC93MzU1efvlldnZ2ME2dT33qU1QqVcIgpNvrMT1TYjAYoKo6VrGIppsokpp3MhIEzjNJZBRZXB5BEGDoBnHgo8oyUsr8uXr1KpVKBc/zae3vY9sFyuUyQRiyurpKvV5nOHRwnIMeo23b6Cl8KVueZ9PqLHmOimjA2ymZ9xN3+xtFUdjf22N8fJzJyYm8z5pJ4g1dL2VJRblCUtbLHJ3WZwOu4xgnifMk8nBdl52dHVRFRpZh6AyIfDFB/9CHnuTJp5+mUC6zu9dganaG2dlZANqdDnEUYRommma864FBVm/GHJjPZmB4SQI9TSrLy8tIkkStWsWyLMIgoNfrYVkWEeIiNtKEn0QBP3z1ZZ5//nnKxQJSApcuXaJQKNDtdCgUS3hBQBBEmM4Q3bQwDZtCqYgkywyGPqahIQFBGCFLos9Lusyu1mpIssxeo8HLL7/MhQsX0FSVcrlMAmxtbbGyskKpWsM0TYZDlyhlIGVLctu2877jvZa82VIe7s0suus5fYfnHUzrEyrlCt5wQJxWwoKOKdAVA9djbm6OQqGAMxhgGAZSehMZnfJnrYfjKPRxkjhPIo9z587R7/eFbe7QYWd7Cz9OuHLlCqauEochruMwNjbG2FgdWZJpd9oYup5jEIMgyLnYPzrS5WNyAJVSFEVAckiI06mtJEnMzMxgmhau6+L7fg5H2tnZoVavkUQxnjskCAKazSbnz5/n3NkznFpYoFgUQsleaqYWpbhRy7Iw7QKqZoAsBmampUOc5BW0ZuhAjO8M0QwdSYLG3i6vvfIK3W6XMAyZnpnGsiyWlpa5s7SEaVmcPXuW5eVldMPCSJWRRi16j4LJcxxrkuST96zK1DTtvpLT0Yn8aFIWbQFDqBwnoBkGummiaVouRuK6HTHYSifnlmUhpWZzR3unxzFpwkniPImRkGUZ27bZ32/QajWRJIkHL1+mvd+gsbtDpVoV/uGSTBiFDLoDAV7XNEDCj/y8J/qOkV3HOXPp4MLOqqsojvHTaa6AIumEYZCyg8BMKYH9fp+ibaHrGjJJOqjSqNUqzM/NMTU1JSTsEPCcnZ0dFE2jWCwLj3bLBEngKKNYQlbkHKJzwBJNByJJQqOxx9Lt22xtbXLq1CnGxsbo9wdsbgrr4OnpaeYWFvKkWioLNXnRArHyc3NUMCOrtLOkmT32XiYmkfRyJWs0XdwIMhX4bHruDAa5YV3GWbdShf/s/TnuCknH83ZxEneN3d1dtre36fV6aJrO9MwM5VIJEM6UkqKgKGpuOAZSOk1XiNML6f4GBQf89YxdlCWKOI7xA5+BM8jxjkhiUm7o4jVFSAxdjzgWkJ5CocDMzAydTgdZlnOvnUKhIBhHkkSpWKRUrmAYJgBheFDdJbm5o4QsH/T0FEWm3++xs7WF53nMzc4BMHRddna28TyPSrXK/MIpSuUKnU4HCTnXF82S5+iwZnS5nknBHZWfy6q+dzu9Hk3Id4MmJanif0KCrCpIsoQkSygp5rPX62HoOqVSEdMwkHK67sF2jvtEHU4qzmMR7/bjnanjWJbJWL1OrVZjOOgBMpouKrMgjMQyD7DtAqoiCyxkJDqVhmEcSkJwIMV5mHYpkQE35fRCBlHRZFPrMIzz5WEUxWiqjqxIqWIPhGGILKtEcTqwUFUKxSJnzpzhhRdeYG1tLRfprVQqWJZFKRUmGRuvo6oaQRgRhBGGaSLLkljBxjEiUaRTZBLiOGJzc4Nms4WuqVTKZbq9Hlpjn+mZOeYXTlGfmMA0LfoDB98PkFMgv6Hr4saTHXO63SAI8uSZeZ7HiZjg57RMkb0PqSn95CEJ3Koqk0gSsqKim2Lbw+EQ0zSZmpzA0IXiVZY4k2S0G32SOE/ifR8jAsaHHk2hP+nPp06dyimAURgyGAwYDBwq1Rorq2uMTUwRJxLNvSalUpFioUIUBYR+QBKBoqgkiUhysiylWMx32KVUJEmR5VTaTlQzpmEKIZAYbLNApVLLp86ZjmiCRKfTxQ9CZipVTF1FAsxikVOnTnHmzBm+89x3OHvmLJVKhenpaTHkkCSBBEj7p3HqsURKCpAlCJMIJQXyB4GPbmi0O23euHaNWqWKGwS8ce0NDNNGkmROnVpkYnoaCYlup0u706NgF/FSYHzBLgBCii6JYxKEmEqj0UDTNGzbxvM8MTwyjbynKUlyriQlHRWG/lHv+D1OfA4j8gMkWZyPJFVxyqiv+/v7TE1PUpiaRtNU+p02hj5BHIUkSsqqyvbpmC7VTxLnSeSRaVtmS+NWu83iqUXc4ZDZ+VMEQUSvOxAeQolEp9OhXC4jSWHeuxNQH/W++Mt3W/5lMmxy2scsFApIkkQQiOmvSKRaLsIbhCFxym+fn5/n0qVLGLrOrZu3+LM/+zN++MMf8tDDD/PAgw8RhiGDbo8oiYmRUTUD3YA4EQwiQ1NzLyFZlum02+zu7tJo7DMcOJw/d47PfvazvH7tKpcvX+bmzVts7+xQrdYolSoUCgUGKc3TtqxDoPNer8fQc3N7YWEN0qdarYpkqcgosmAr5QXde52bJKEw1eq0sUwDVVEYpoOhM2fO0NxvsLm+wc3rN0iShMnJKeoTE+iGJqrfSCR/UpzrcUyeJ4nzJPLwPC+fVG9sbOC6Lt12hzAMWVpa4syZM4zV60LBSNdJUk54Vqmoqpoze95N4rzbUm+0L5dtM5s+DwaDfOmeJWfTNOn3OhRLBSzbJvIVOq0WSSIxPj7B9NQ0S0tLrK+vE4Yh3V6fiw88wOTkDKZtoxpGKiUXIqs6hi4ThSEkEXK6D9VqlSSM+KVf/VWkKKLZaLC9vc2Fc+cplUp85St/xtz8PM888xGmZ2bYbTSo1sqUykWQYlRNI06g2+viOA5nzp6l1WrR7w+w7QJjY2P5jed/yuI3SQR5oVhEloTifhxFdDodDMNgYmKSqampA9ZVENDa30c1dCzLRlE1ZEkWlXMcocrKsUueJ4nzJPLQdZ3hcEihUODChQtiWNDpsre3x0MPPSSm0xIEYZjzm1dXVw+J5Zqmied5P/Y+HIXSwAFEZzgc5jCiLKHqui6U1l2X2PeIwgBN01hcXOSHr7zM+MwM586do1wuY9s2ExMTTE5OMjk5gW5ZyIqKJAsFJlJOv6IqSMnBMjQMQsrVKooss7O5Sa/Xo1qtMjY2xr/7t3/EpQsXUVSVTrvNzvYWCTD0PfwoZmysljOHTNMkTpKDatQWU2tVVQ8D3CVSzqdosfw0UpJlWnS7XVRVRknbFu12m9nZWVqtJsVikVKpRLFYpNFoMBgMGLOtXLwlTmKSREqr4+MXJ4nzJPLwPE+ICIcBsiSsbMcn6ti2iWXbkMDQHQp+d3qhZ/CjoxPXdxNHKYVHI8M6uq5QPtJUFS1l3ciSTBD66IaBaRgMB318b0jg+0RhgG3bXLp0iaWlJdbW1tA0jSeffJLJ6RkmZmaw7IKYzMsKSDJxmp7CKBTsoLTvmgHRNUXm9q1bdNttCpZFuVzizp3bDAd9Hv3UJ3nrxnUC38M2TQrlMt1OGy1O8H0PTVPRNHGp+W2XXk/KtTs1TSWOIyQp7WFKICXST7fyTHUATNNEkhLRZ04r+GazSalYyPVABWjfEPClvNI8yOvHFY50kjiPcdztI7+1tUVzv4Fh6HmlVioLFfAgDFFUBTUWHOUwDHP6YAaryfQk3/U+3AUTOMqpDgIhslwsFjF0Iaohpe5yUvqfoiiEYYg79PB9l16viyJJIMk0Gvu0Wi2q1WpuqFYoFJDSPqIkAZJEFEbIaposE4gjYfchSUme1IbDIZquUyiVUGQF33P54JNPMFar4g2HhL6HaRiUSkVkBLwrDHxM00DTNTzXZTh0UFUNu1JB17VDUB/xnuTaUum5OPJ+vYd5Sjd0SIRH1KDfZ2xsjLW1NQb9Hp1Oh6mpKer1OrqukaQqWvHoeyVJwlBPOn5DopPEeezj4Mo0dJ3VlRWWl5col0tMTEzk4rs5zIgD/UZJkiiXy3l1klWH75Y5lNKgxV6kS79RILjQ2fQIAj/vNyYkRGGIpqlCxi1NroqiYpgGUSSwkLutFkt37uAHPnPz8+iaxquvvsrM3DxWoYCq6iiaioRIBoHvYakamqoQpsIhEgmGpoHIsZw6tYhpmSRRRL/T5tIDD/B4pcJfPvccuzs7lIpF4tAn9gNM02B/fw+7UECRFZKUuSRJUuqvrqaCIkoq+nGEnx4n+TuTjJjpvZcRRwJq1e/32djYYHF+jrW1Ne7cuUMURSwuLnLx4kVs20bVdJAk4ihEkhWBekAijEIU9fjBwU8S5zGMt19+4hIdDHpcufIwDz54iW63y+uvv87P//zPs7e3h6Hp9Po9gnSaLYzJSrleY1YlZkOddxMHEnZJmkRjoXYUhoSBT+C7hIFPuVRE0xSQ4pxbraYWvu1OE8/zKBULhIZGf9Cn1xMK62EYUhurM14fw9D13Pe8OjZGsaiiSBJJWm32+300w0SWVBRZygU+4jgT+VAplYpIcYwky5gTE8SKzPL16/yPr/wZt+/cplIpEZMg6yo3rl5lZmqSYtGm120TxTF2ocjFixfZ2tpiMOhTKlXEjSKKch/6jLoqcmgKklcUZPm9r+jCKMyN7OI45saNG8iyzOf/1t8ijiK2t7e5desW9Xqd2lid+qRQ2Y+iiCgBRZNP9DhP4iSKpVKqexmzurpKp9PhjTfeoNFocHbxNBNTk8QJNJttJEliamqKfr+f0wQNw6BUKr1rmmCWOEf5z8ldNCozUYxR+bUkSXAGA3Z3d5mYmMB1XRqNPba3tlEUhWazyRMffILp6SkmxscJfI9XXnkFSZLwXBfP8zEtC920xFQ9DCFOCBIPTRPA+CiKsE3htOkOB5iGLiA4SQzExEHAf/pP/4mV5WVOn1pkZnqGKPAJnT5TU1NEccza6hqVapWxeh0rhVQVCgWhQjR00A0TwzDz5OX7fsqTB0mSRe9R+ekMYAzdIIkjJifFFD3yXFTDYGt9jSiKOHfhAg9ducLKnTvcvn2bcq1KbayOoqpkt9/jtUA/iPuqsf/gD/6AJ598klIq5Pp3/s7f4fr164ee84lPfOLQoECSJP7xP/7Hh56zurrK5z//eWzbZnJykn/6T/8pYRj+5EdzEnePJBGVWhxDEuP7LmHoE8eRSAIpz1C0+ySiMMQbOnTbLa699kPOnzlNp9PmlVde5qWXXmJ9fR3Hcdje3iaO41xwIxPsffeDohGe+siQKJvOl0olKpUKqqahqCq9Xo+trS22Njfxh2IqPTUxgaFq7Df2cYcuMzMzWAWbK48+wvmLFymVy/Qdh97AYXp2ju3tbXzPw7ZtfD9gkLYcxsfH2d/fzwcgotGZ5IlBVVWGgwHrKytcf+MN3rp6jddffoVup83c3BwPPfQQuqaxub6BrmpUa1Wu37hOp9NGM3Qs2yIKAzqtFlIChqaTxBH9Xoe93W12d7bZb+zieR66rlMo2BQKFpapo8jSe9vfTDILZyHqnOmOqrpO4Lp4qQ5rFIZYhsHZs2eZn59Pjeg4RA2NMhvTYxb3VXF+61vf4tlnn+XJJ58kDEP+2T/7Z3z605/mjTfeyE8qwD/8h/+Q3/u938t/tm07/z6KIj7/+c8zPT3Nd7/7Xba2tvjlX/5lNE3jX/7Lf/keHNJJ3C0O5NqSXKRXkiBOEuSRBDfo9+m0WrRbLSzTpN1uoygK1WoFwzIZOA6O49Lr9QiCgEqlQrVazVV/MkbO3aTQ3v6zTBKH+J6HnvZFc7/39LkZY2gwGLC5uSlEeCsVNFUl9H1sy+bq1avYtkWlUiEIAhZPnaY+OU6/02HoDDB0HU1V2d/fZ3d3l+985zs8fOURNN2gUChimhadToexsQmcwQDTFCLJSkqFjKMQTZUZBgH7jT3WVlfYbzRo7e+zvbWFYRgsLS2xublJrVajXClTKBZptVpUamO4wyG9bhcQ4iSKrKTJJ0RWZDRNxXGGqKr2tmFbFlEUo7yHTB1ZltPRWnrzEh7OYuWg65AkBL4vlP8LBcbHx4U+QUJqFywdIAGOYdxX4vzKV75y6Od//+//PZOTk7z00kt8/OMfzx+3bZvp6em7buPP//zPeeONN/ja177G1NQUjz32GP/iX/wLfvu3f5t//s//+V2B09mQIItu+iE8ifuJjGt8sCSOkgO/GxIBndnb3cFJgebZsth1XUrlEqZtYVoWpjkkCKNDy+fRZfS7N/DK+OmSGJQgKI8A3nDIcDgU9r1JwsryMmEYUC5XKNi2oC8mMTdu3KTVahJGZZyhg+e5VCtVpKZMc3ePvb1ddE1FloQFcBRFrK6uYhdKlMplLMtib2+PVrfLRz/6M0RRSBSFaLKKJIvzJEsQBQGaplIsFkiSmK3NTTx3yOnTp/NKOI5jxicmuHX7DrZtE8cxg/6ARqORIxBKpZg4SvLELCEq/ByWFUcEvicGMOnQ7X70ON9tZDe3JF1xjAqDZEWQoijIUqYNkKR94wBZyXCvqTr+McRy/kS3jE6nA5Dath7Ef/gP/4Hx8XEuX77M7/zO7+A4Tv67F154gStXrjA1NZU/9pnPfIZut8u1a9fu+jp/8Ad/QKVSyb8WFhZ+kt0+diH6ZxFwUG0mo8t3BI/a6fXotttICDB8v98HSCXSAhRFoVQsMjk5wfT0NDMzM4yNjeVg+PvcK5JULETVVJI4SvGMEEUhrdY+G+trJHFEt9Nmb3eHgmUxMV7Hti3a7SbLy0u8+urLBIHP1vYWt5eW2NrZYXV1lZvXb7DfbLK5ucWNGzd588032d7ezsU+GvsNNjc3ubO0xLVr11hdWWYw6KFrKpKUaWUmuUpRFEWYhsFYrUapWMr1Ms+ePcvY2BjD4ZBWu02z1WZzc4vV1TXiOKbZarK9tcX29rawLh4O6Q8Gwj5YkoSvU+q3LgSFQ2GNHAa5FzqQcv/fu+SZbTdOBVIkRHWftQrgQG4uDsNcB9V1vXyZPqopetzixx4OxXHMb/7mb/KRj3yEy5cv54///b//91lcXGR2dpbXXnuN3/7t3+b69ev8t//23wDY3t4+lDSB/Oft7e27vtbv/M7v8Fu/9Vv5z91u9yR53le8XV7sUIUYRXS7XfyhQ6VSoVwus76xwcrKClNTU/R6PVRVoVwuY9kFNMPENixM0zx4hZGp+rtLosmhnp2cCoskSUKz2WRrc4tWs8lYrcadO3eYm51lamoKI03oa2tr/Mmf/AkXL15kMBiwvbsLkszszEyOJT29eEq0G1pNPHfI7OwstVqN+fl5Vtc3abVayIpCfXyChfkFDFXDsu106Zrkq+IoCkGScF2HZnMfx3FQNZVbN28AgkklJNqEjF2n18O2LBzfw/MCgjAkjESFfu7cOQqlCsPBgE67nUOpVEPNe7tCJ/NgCJazijJc0nsQwtU0qzJFte+6Lp1Oh6RUpNfr0Wq10DSNy5cvo2kau7u7jI3V0VMNgQNfpuMXP3bifPbZZ7l69SrPPffcocf/0T/6R/n3V65cYWZmhk996lPcvn2bc+fO/VivlekZnsSPF5IkoaZ9qTitIrIPvOd5NJuCUlcqFBkfH2dnZ4drV6/iDodcOH+OZz76EXa3tvB9kQR0U86xltlSMqti70dqTJYk4kQidD00w0BRVDqtFjubWwS+T6VS4dVXX0VRFBbPnCGJY27evMmrr77K9evXeeSRRxgfH0fTNEqVKsVSifn5OcYqFUrlMoHncv78eaIoxPNEX3Z3e5soirh8+WGSBMbGxzl95iyh79Pp9CCMkFVVLEPDgH6nw5vXrvGDH/yAne1NfM9HkSUsy+SjH/0o9XqdlbU1XM/Hsopoqs7G+ibr6+uMTYwzMzPDxMQEpm7Q63S5ffMWVx55FKtQyFdiSvp6QeDheWoqJ3cwhMlYPomk/NSm2LIs52ymSkXApBzHYWNjg063y6VLD3Dm9GkGjrBaDsKIUkkIRB/H0fqPlTh//dd/nS996Ut8+9vfZn5+/h2f++EPfxiAW7duce7cOaanp3nxxRcPPWdnZwfgnn3Rk/hJ40DfLfedSROdFsfYtk29XscyLZqNBteuXePGjRtMz8zw0EMPcefmTeI4plQqUy6VsUsl3qnLM2o89qP3TEJNBUOcfp+11VVqNeHXs7S0hCzLfPKTn0QGXvzBD3j11Vfpdrs8+uijXLhwgQcefJBWs4kfhli2ECuWJJl2s8H3X/xLFEVJ6Y6C7VQtl9nb20NShIBIt9tlY20d27bpD0RVGschmxvrLN25w872NnEcUrBEJarrGo9cucwnP/lJhsMhy8vLjI1P8OEPP4Ukyai6wdh4Hdu209fWWF5eZmlpKVd5+vKXv8ze3h6KqlIqFikWiySyoGHW6xPU6/WUDnlg4iZJEoZp8V5mqThDVECuCG/bNpKmUa3XOZNiNr/zne+wtLTMZz73NykWy+nKJVOTCjE0/dglz/tKnEmS8Bu/8Rv8yZ/8Cd/85jc5c+bMj/ybV199FRBuiQBPP/00v//7v8/u7i6Tk5MAfPWrX6VcLvPQQw/d5+6fxLuLlMIYhmhp/6rb6dBut2m3W7T2G/S6PZZXVvA9j1KpyGMfeIwzp0+zsLDAiy++yNjYGBOTFrqhEwQBsqzm8KPR5WQ20LivfYtElbezsyN6iZZFfzCg2WzyoQ99CEVRWF9f5/bt21QqFR5//HHOnz+PZVm5zYUUxRm9hsGgz+r6Gp7vk5CguBKqqmCZJr7vc+rUKaIUJ+n7AWEYMjs7x9LyCt/73vfYWF9DVWQqpRIzU9NsbK6zubHJ7Mw0586d5dSpUwwGA1qtFoVCAcOyhc1EuYJVEP7qzmAgrIR1nckpN30tUUV3uj3m5+cZGxvLxTVa+02mpqawbYtisYBpGuLmFsd4nk+/30c3zPeM2SinE/EkY2r5PqHn0mw28be3MA0jV7l6/PHHef3qNf7Lf/kvfO5zn2d+fgHDtMSNVz0BwP/IePbZZ/niF7/In/7pn1IqlfKeZNZwv337Nl/84hf53Oc+R71e57XXXuOf/JN/wsc//nEeeeQRAD796U/z0EMP8Uu/9Ev84R/+Idvb2/zu7/4uzz777Mly/KcWmShvgKbrRGFIY3+f/UaDOAopFUs4AycV5UmYmZnhyiNXqFYqrKyuMj0zQ6FQOLB+kEQ/L9/6fYp7ZPsUxRGB5+G6Dpqq0+l2mRifYL/ZpNVqMTc3z/TsDJKiEpNw+vQZisUis/Nz1OrjkMRIsqBIxokYNiWxkLyr1saE82SSQCKgPLpuQJJgmaawj0hpkN1uj6WlO3S6XXzPpWBbApIDrK2t0u/3ePDBB5idnaFcrojk7DhIikKlXKGSVsi6JXzbhTCIsOTwfCEdV6+Ps9do0Gy1kGUFRVVxPZ8kSTAti3O1MSanJ6mN1XPBZQkJRRV+Tp7nv1cfBmDEu12WUTIxa11HkiR6vT5JkmDoOvX6OJOTUximxUuvvMzKyipRnDAxMUGlWoX7FFh+v8R9Jc4/+qM/AgTIfTT++I//mF/91V9F13W+9rWv8a//9b9mMBiwsLDAF77wBX73d383f66iKHzpS1/i137t13j66acpFAr8yq/8yiHc50m815EQJwg1oPSC6bbbtJr7AmJjF0b8tYfMzc1TqVQZDAbs7e3xgcefIAgCYZfrB5i2fjCNPZI0R+XRRu0ejpqSCbxngjN0aTQaVEtVWp0O8/OnWN/aJIhizp07j10oAgqlcoUHHiyjGzpmKgcXxyFIcu6HJGBVAhEwMTmFZRnicDMrDFlIx0W+n6rVx/S6XXZ3d3npB9+nUCigKgqWaRCGIf1+n25fJPOHL1+mWCwQBCFxnBAnErppYRUKFEolJEkhTu08AGLEsQVBgGWZmLaNbReJ4piJySkUTYFEVMu2bVEfG6dYLqBqek49TdIWiyQpKWbyvVwPi5uNhPhciPdJwi4UKYeh2GfDEIQAReGCoeN4gnG1tbmB6w6J44jx8UmQDogP9+pxv99UlO57qf5OsbCwwLe+9a0fuZ3FxUW+/OUv389Ln8RPEHHqCaQbJnGc9h+TmND3CTyPfqfLAw9col8uMT01SaFQYHdnl83NTcbHx7EKBYatFsPBACuK0QwrTxAZdGV0MJRdJBkW9AB8f/C4MHyLGThDdnYbFAsVnKFLs90hSWRqtTEmp2dI0mq5Xp8gt2xAWGdIskIcJhSKpQO4jiTQoZZliaRDQpJa/2bVpx9F6LKYKvcHA5aW7nDj+pucOXOGcrnE2to67U4HTdc5e+4cT3zwg9RqNaIwxFB1ZCklEKgKsSTjByFh5JEkAh2g6hpREuH7AZIk4/piyTszN8esPA+JhKSApghGlKzIJDHESUQUCQiUJIujDMMIzxNGde9lyJIsrDCAWEKA6xOJUqVKbXycOI6Iw5AwCHF9lxgx7N3b22N7e5ud7S2xWimVMAz7kKHc0c/C+y1pwglX/VhENvXu9XrYloCSXLh4kZnpaaIoYmpygqtXr3Ljxg0+//M/T7fT5errr+N6Hs987OOpnYaKaRVAkuh2uzl05p1i9OIZBdNnF1K3200ZO3UqtSpPPvlhtra20A2DSrWW92NFjFx8uaySDHKMjJK1N8W200QpPJVkkAS8KE5iBr0BlUqFQbdDFAX4rotlmJw9e5YPPfFBvvP8c9y5cxtZUbl85Qqf+tmf5cKlS1x77SrNZpNqtUq1VsXQDTTdoN/vM3CGgGBhBVGYy+EJ+FYJRVEPwXeyPvBoUpEUkNOBWxAEufJ6HMe5jch7FaPaAMAh501V0YEEd+jiOA5RFFEsFomiCFVVmZubE+dvMMDzPF5/7YdceeTxQ46co+/9+zVOEucxCVVVhQCHlDAcDlFkmXq9znA45Dvf+Q7r6+t84QtfYHd3lzfffItOp8OZs2dpt9tMTExQlMXwxnXdvN+pqurbLsLROMp4ieOYzc3NXFl8e3ubRqPB5cuXsSwL27Zz+4ZqtToC/r53tXXwGinu8h7FjYSEKitUKpWDalnTqdfrPP6Bx/nkp/4G/98/+rc09/fpdLqcPXeOBx54gFq1yo0332RjY4PZ2VkWTi1QLJUENMsPcnV6RVFSu3IxILMsi7GxMXTDJoqE3F6WiDKP9VGWXHasWdKNUtxnZi98Px5O7zbupSnguS77+/v4vk+hUMC2bVzXIY5jypUK5UolZZr5rK+v57jZ0aHgKBPppOI8ib+WEadDkDiOURVxMSoSLN25wyuvvIKmKvztv/23uXPnDq+++iqqpvHwww/z0MMP0+n1CcOQdruJYRhYqflYxkvPtn+3CzCrquDA/qLX6+Vg+X5fDCHq9bpQLfI8Tp06dYhmeEg56YhafPbYwfPS3x85/szNM2NLBYGYpGumQbFUJA5DvvT//D/Ecczk1BTPfOSjmJaN5/s8//zzjI2NcfnyZbGfipyLYPiesOnI/JeQJVRNwzRNZFlG102QZGRZcNT1dPiS3XAyZk7GEMr+zWBMWRU3epzvRRxtqeTnScoGZi5hao9Sq9Ugff3hcIiWHp+qquiGweLiIq4Xve0m+V7v81+1OEmcxyBGL1ZZhqHj8NYbb9DcbzA9Pc3c7Az9fp833ngD27aZX1hgcXER0zTpDZxcGyATM3YcZ4SyF+cX4igIPksAo1WHqqq5A2RmvJZZ9WY6lFnSObqddzo2EelwgnceociyLJwlOx0UdYwgCFhdXeX27dtcunCedrfD6dOnGThD+tvbWJbFxYsXqdUnhGKQ7xNHEVF0wJKSVZU4TlLBDgNdN1L6ZJT2Kg/aJSASV+ajnrlfZoknS5qaph268fyo8/Djxuj7I0mSgCWFYe4w2ul2CXwf33dz6UBd1/P3S9w4lLfdRLNjHn2d91MSPUmcxyCypCWGIxG3bt3Cdd3cuKxaKdNsNrEsi6mpKebm5igUCinVUiUMQwrFEiA47ZlmZLbtoxfFaH8rS6xZ4qhUKuzs7DAYDHLgfRaapuXPPzqNv9dxHcS9n5fklahQ/AFSFXiVdrPJ7s4uU1NTJEnC+Pg4g4FDEEWMjY0xNTVFrVbD84TcmiwJv/PRhBZFQtw4U3EPgjDvCSbR28/FKL97tO85ioMdreB+GknnXuc1CAJ8z0dOlaGGvR6O41AoWIBoJcRJgpIeD+ln6+g2R1cLo8n0/RLHE4R1TCOjSTabTWZnZ3nggQdyewxFUZibm2NmZoZKpUKSJLTb7dzBUkLK7SyyJeUo6P3oMm20uhqtakqlEt1ul3a7jWmaTExM5BqcYtKeKaAn98WDFvTyuxi+MTrpjXPf97GxuvBR8n00TeXChQvs7Oxg6AbtTgdZllk4tcD8wgKe59Hv90UCSI3cJEkiThLCKCIaaVVkbRGh3pQQBsGhYc/RoU9mcazrel7NZZXmUWLBe5187tZeySyBs/c3iiJc10VV1Rxfmv5xruUpy9LbEv37PU4qzmMSoxfCz/zMzyBJEHgenu9hWxatVitlBMkCqpIkKLKcV55r6+ti2KHrb6sg7nbBjPYmR5OKpmn4vo9lWVSrVUql0qF9PDqwGE2e90ochy7UuwhhZL+PY9GnsyyLOArpdTrYts1jjz3Gy6+8RKvVYm9vl/OXHmBqehrTshk4Q3zfp1aroes6ru+LijKOcD0/n3hrmpb3ApMkQVUUZEUhDg6GPFnP8t3EIf+hEYzke9nnPJQ4E/G/0ZZCNsRzXbFML6RVenqXQpFHfZLevm/36qW+H+IkcR6DyHpniiyjqQWCwCfwXBRFwSoUaO/vc+PGDR5//HGmp6dJgCAImZiYYH19HYAwCOh2uxQKhVxG7ignfTRZZsOObNmZDYdkWcY0Tc6cOZNrE2QJ03GcfNtZH/Dde9q8c5WTXcS2bRNFEU5vROB4d49vffObSCScPXeOSrnCcDhk4DjYtuCSD4dDgiBATRNgGEYMh0NmZmYoVyq5LFucJPk+ix5u4dDSfnR/RvGOmQD06M+5/F96Lt9t0n1XZ+tIyyBJEhRZET3n9C3VdZ1eqkTl+y4f+MAHmJ6eztWRIEMDRDmI/p1A8O+nOEmcxyiiOEaWEjRd2DFEQUCn2eLmzZt4nsfU7Cx7u7vigi+VKVcFe0gI9E5i24XUoVE7tJyEw1VFNuwYvfBlWc4FL8bHx5mYmDjkJQRQLBbzbWR92XcfB1P1o5FV2mEY4jgOiqJQtEwsy6TTbnPjptDufPTKZc6dO0e3N0A3TUrlSr68npiaFu2LVodeardx/vz5POFF6cAoSSAM47TCfGcI0dGl8r1aEz8N+bZsIDe6D2EQoKpCjd4wxL5neN2//MsXWFxcpFqtCuptCpwV+3UiZHwS78MYrW6SJEmFcwFZptvt8O1vf5sPfvCD7Gxu0ut20TQdXdPY29lBkiQWFhYoFkuoqpobimUX3ehgY3TJnlVPo9NxIPXTKeRJcXRpfrevdxPiuSPHm/539DmZdJqmaZiGAO/7nsegP8BxHD73uc8RBgHtTocgENWurCjUJyaQFYWtrS0836NYLFKtVgFRVQoL4+CQHukoqPxux/GjjvturY73csk7OrAbfQ+z19RSnydFEVVokiRsbm4iK4Jnn60IsnN/tHXz476Xf13iJHEegxit+jJxjiSO2d7a4q233mJxcZFyucz+/n4KBxKYSsuyUpm1OFX/dnMtz3slSeBtF+Hoz5neYy4Y8tM87vTf7MJVFCWlCBrIquhBJghywOOPP874+DhLy8tomuDDJ0hYlg1I7O3t4XkeiqpiFwrYhYIYDqXeQVGqzpQlFkmWU+Pjv5rL1rshF7LqOTtzge8TpP3dM2fO0Gg02NrcpNvpEEYCuxnnVsbHK04S5zGJrMcYxzGqqtJqNdnZ3iYIQi5fvkyr1RJiuUlCq9Wi2WxiW5awC04SXDcVsE2Xc3ebmo8OHO71Zds25XJZaIL+FKqQu4HfJQ4q44yJAwfVoqzIPPXUUwLf2e9TrlaEcIcio+k6g8GAbqdzCMSeV9J51pAEh12Rc4/0hOSvtANkdhyjCIlRML6bOl4WCgUuXbqE53ksLS2xvb2N67r5cv84xkniPAaRVX2O4xAGAVEcc+vWLfr9PleuCEbM+vo6U1NT7O7ucuf2HXZ3dwmjiH6vh23bqXKSmw8p7lUtHp0GH/1dtlQfFYV4b2Nk6JKI5DWauH3fF3jRMKTb6dBpt0hi4R3UarWYmpzMXTtVRcHzfbrdrpCqq1ZzVMAw9QmSZeF9nlkY/3Wxkhgd7owOiTzPy5XnM1ZTkiScOXMG27bZ2tpid3eXoePkvePjGCfDoWMSkiQJ+hwx165eFX5Ck5OMj4/z+muvMTc3x3e/+910eKJSjCJhaasc0ANt286tnkfxhaMxyvbJen5ZkhxVM78XTfO9jCTXViL318mA+wPHYWdnm8FA+Cy1222IY7E0TxKSOMZxhqyurmKaJguLp/B9P5etk2UF3xcoAVVTcw8nKZVn+qu6RM9itGqGlPUVxfkwMBvOqarKYNCnULCZm5vD8zzK5XIOSzIt63/xkfyviZPEeQwiA74bhkG30+HmzZs89cwzlItF3nzjTW7fvk0URaysrHD69GlOnznD7OycGBDoBqurq8zMzlGpVN/mgJgloozxkoHps8fezdT4f1bIkpSLi6gSKVDdQ1c12u02SRSi6gZRFHHt2jWu37iBbRd44oknclUn07TQVMFwcpxhjjDIzc8YQRn81c6db7uxeZ6H4zjYBWHb0Wg02N/fZ2JinDAMKZfL6LqeKtWLVYjxU6CB/nWIk8R5DEIITui59atpmty6eROn32djYx1NVXnmmWe4dOkSr7zyCp7nUyqVcJwhg2aLxcVFisUyXsp6yexys8QZpYOCTAAiS653m7SO7tNPIzJBj+ynLJLUV94Z9AmCgEKpiIREq9Wm3+1SKhWYHK/zgSuPsLyyyiuvvEqr3eYTn/gE4xMTNJvtfJLe6/VwhkMsu4CiieV5/rrJoZ05tA9/1WIUd+l5Hs5gAIiKutvtsr6+TrfbZXFxEU0TK4hGowGSlEsKJnEsHAH+6h7mTyX+ejRkTuInjiQFZmuawaVLlwBh/1Aqljh9+jSnTp1ibW2NYrFIpSzcC+MkZmZmhmKpRLvTodls0m636fV6OTjdtu1cIm20bzna+7ob2Pqn0d+UUmzhwX8cqgKTJGEwGFCv10mAMIoxDINSucTW1hZJIpTxr129ShRFPPzwwywuLoqbgqrmfb8kSZAlCcs0BWTpLiLDB33Wv5pl5+ggLwxCnP5AUCsVGUWSaTf3cfo9ZAk8zyVJEqampvA8D88VPyNJxH81D++nHieJ87iEJJSDZEVhanoaTddRNZ3J6WkWTi1i2Tbb2ztUUpvdDLpTLpfpdbvs7zfyajOTUtM0LU+AGdd8tLf5zrvzXpcob99ejLCwSEiIiYlJCNKEH0YhhYJNpVrDtgvUqmMsL69y860btJotatUq586exTItho6TVpWpNUaSpMMjVVgcZ4yfhDxhp1iknCNPWvEmSUwcR2977F5f+YY4jF7IbkZH8bLv9oaUqTt5rku/32M4dIijEENXCTwXz3WRAUPTiMIg10vNRE3iOJWKlk6W6ifxPowE0ioMgihEVzVMU1wE1VqVqalJJiYmGA5dhsMhpVIpFyq2LDsXBfF9n3K5kkOJMsql53kAubDxO1Ex38aPfk/j7SrGo6pIpOlTVmThfplAvT5OHMX0ez3On7/AX3zt6wwdD9O2mJ2eYaxaIwoCYbWRmbClx2aZFhISURgRxdGIqpHCwZp9NJFlfPk4PSeHrSbuekRH6ItJcphkcJS1dT/c8CQRyfOggoyQAFWR6fd6xFGIpipouoaqyNgFmyizQpFlUreiQ6Z9xymO51Ef00iQieKIRJKYnJrmzJmzzM7OY9s2GxsbQj6uUKBYLKJpGkN3SKPRwDRNZmfncqGLDNfpOA7AwXAkvWDvljTzfbjPyug9DUnCsiz8wMcu2NTH65iGgTMYMDExyblz59ndFRJzU9PTefVcrVaxCwX29vYAsGw7rQYhCkOC1GJ4tB2RsWmyAdlRnOvRxHf06yhOdnTb2d/8uFRMCQldU/F9D8PQqddr1CpVNFVYGA/6fULfA2I0TaFUEEiDbreLqmpomi7IA5KU35SOW5xUnMcopNSqR5YlZmamkSQJXdMIw4CVlRUkSRLSZmlFCeTiwhkExff93G8GBBMoUwSHt2tH3i1BjrKKfqrHO9LfzF6vWCyiKiokEXEQplbCNRzH4dOf/jT/5b/+F6bmZjn/wCWK5TJREBD5Pl4YMTExIaBZqT99FAgJtiAK0SU9PQdHp0OHbxL3kts7GkeTrIBwvf359/r+R0VCgqkbYqgjgaKoNPf30DSNbr/HxNQ0juOk3klViOOUJGEJdlmqoPV+o1K+2zhJnMcoJEnObbA1XU97cWKAsb+/T6FYpFarYaUKQlnSLKU9T9d16fV6DAaDnAVkGMYh76HRyiirwrIEkcGVxL78z7/gJCQURSUKQ2RJJLHZuTkM3eC//9//N5/6G5/k9JkzXLt2lepYjVKphG1ZDAYDZE2nVqvlyk2B7+MOhagz8mF+ukhwIO49cTpxvvvxZufn3QiavFdGaAkJcRgJ2bswwPdcHGeAYQjzuTA8LP4h6xrEMZIkM1Yfw7KsFKXw/pSMezdxslQ/RiFJ+egCkhH/nVTVfbxexywUSCTBVe/1+jlFMUmElqWbTlQty6JUKuXUyVHPnEwMN8MFDgZiYpspx2dg+KPLz/f8eNMvOfsaQSplgsRJkmCaBj/32c/Q7fdSOwidpaUlvv/976ObJq1Wi4x5HqUQLNGucEiSCEPT0VQNRVbSYwuF5/uRiFMao59W63nSuUciTOKYJI7z48j3/S7CGferfSmrEt5wgOsO6ff7tFotJEmi2WxiGDorKyts7+ygqApSkoCsUi6XqY/Vf6S76XGIk4rz2MSogtDIRSYJuwSAWq1Gr9MhTkHtqiYELTzfx/OE+ruUYvhs2877nUEQHLpwRy0ijvbyRlWD3ss4VIVlrYCRYx8NgTsV+xBGIV4qZLG9sYmsKszMzghFoDgmShWAdE1DliSGqemdoihEcXRItT3bj+yGIPZJVPRRHBOmcKYMgZCdjzg9h3IqEiKlw7zkyDnyfC/PsaN95bsNit7hTCGlHHrf9wUFN4oggbW1NTzPo1Ip0+l0UDVhyBbHMZKqpL1vQwyEkuzMnlScJ/E+jSRV905GlG9EIpWQJDEQMAyDYrHI5sYGm5ubuTWsruv0ul36eTWmHbK2DVJriGxZnlWcGY9bVdUcupRN3Y/KmP1UDjhLJDmeUxx6BpXKEr7refhBgKKqGKZJFMeYpsn09DT1ep3G3i7lchnDNMVxxVFaqQtLXE3TUDUVSUr9h8KDSnr0fAQjlhmj4hqkSc9zXXEDyqpw6SAlZYlxOBziOAPxXN/PB1QkowOa5Ed8iaV6GAREYYDnuvi+RxRHrK6uivMShriuB4hhWgarMgwDObtBpHbMcRz9lcWq/jTjJHEek0gSIWQ8KnqBJJEkQjKuVCphmiarq6s09vaQZBm7WEytgdvEcXIoCSZJkhu3jfLOMz54ljgzD/Es2f6v6ollCTRL/hJSmoiG6XLdpDpWI4oiOp02uq5RKZdYXVulPj6Goqr4nocqy+iqQuT76LougP+KRJJERFFAmCa/vB0Rxfl5yl47M6XLbjqZl1N23rI3LEEs1zOWlu+5BL5HGPpEUUASR2RoVZIYicO4z7t+pdsfOgN838N1Hfq9Lp12S8jmKQqNxj7dXg9FUSkVy0iyQhSG+eclr6RJiO7SkjgOcbJUPyZxtChIkoQ4CvE9P/fUUVUVz/PQNI1SqUQUBGxubSNJEtNTU/gjzBnXdfOEmWE4ZVnOl+1BEOSPjw4+DkN27p1Ej2IT7/bYvf7+0OQ5+/v0x0zdSFUOfM1J9Ua3d3Z46qmnWF5e4sUXX2R9fZ2nnnmaJEnotFqUq1XcVBWoVC7jh2EudhEEAYEfEsdJ2j8VFaXEQeJTVVVUcJKEOxwyHA5HcJ2HB0wJAuqUmbuNWmcc1QTIj/tubzRvx4OSgDMY0Go1iaKIvb091tbWuHLlCq1Wi9u3bnH9xg0qlQrFUgkUmTgUN4QgjFAUVfRz7/nuvf/jJHEek5Bl0GTlbR0pWZYpl8ucOnWKzY0NDMOgNjaGbds0Gg36/T6XLl1iZ7dxSOG8UChQLpeRJFG5DQYDoihC13XK5fJde36juMMgCA5hEY8+7yepTN/JnydO93FtdZkkSSgWCpSKRRzHYTgcMjs3x8LCPF/5ylf4xje+wWOPPQZxQrVSptftkCBhmCaSLDPodpHiGD+Khdd4HObJsFgsYpomrVYnN6aTZVloe3a7uVzbcDgkSq2Iy+UykiwThSGDwQDf93MF9uxGld2I1NQczk8rVSDvtSZJgqyIKlFJz0OUtlJUVaW932A4HOA6Do29PRzHYbJeR9d1nnvuObZ3djh79iwXLl3CSm2hdcNKX+PweVXl45lCjudRH7MQ+E3pwFIiEUpBmX6kpogl9euvvSagR7JMp93GGQxEQt3cxPUCyuVyrqAu1IEcvHRYklWemZ2w67qCx50mxlGWUXbxH8UgHk2Y2bL/br7dozEqxJsldhDJQmzz4LmyLLO6soJlWRQKQnPTHbo0m00WFxcZDAaQxJw6dYr9/X2+8j/+B48/+ST9TofNzU3q4+OYpskwTWymaeL2+jl8K0tOtm0LiFeKcw2CgFarRbfbpVaroWlaipEs5x7mqqbhpsgF0zQppq0SARESQyXbttFSp1FRNbby14MULZCet73dXUB4OZmWhapp+KkYcWN7m5nZaSzLzG2Kn3/+eTzPY3Jykmc++hEuXrr0zlU9/FXWMPmpxkniPGYhGMbifxISpEK8WhznDpMZTEdRFJ5//nnOnj2LXSjmjKJs6ZjBizKL3AzTCeRJE8j7nZn7Y3YxjvqL34ttNMqMOcq0Ofp4ksKNctB4eqwH/caI0PchTigWhZjyMFW2NyyT2tgYK8vLSEnC3Pwcg4HwUn/h+eeYm53DNE3iKGIw6OeQrN3dXRRVwzZNkhGTul6vRzkVS2m1WjjDIXEU5VW67/v50l1RVbqdDo29vZy9BeRQrgwzq6sKxDFOv4c7dHFdF5IY2yxg6hoyCU6vx2DQp1qtEvo+siyhKDKh79Pc22N7ewt3OGRqapJiwcJzh/T6PZrNJp1Oh62tLf6PX/xlzp07j20X85M6Qvw8rrnyUJwkzmMWmWKQGD6IYUE2/a1Wq9y8efOQ0vnrr7/OzMwME5OCaZSpwGfc7EzwNhsaAbkv0SgNMXt+PDLsyBSUMmWlo5x2eDsz5p787gyAT4LMyN8mEEUhQeATBiFREFCpVPIWg+M4xElMtVZDNwxUTaNgWVQqFWq1Koqi8MrLL2EaJqcWFwl8n6HjoBsGYRikOpwJsizlSToDtAdBkLcAJEmiUCgIZk63mw/MZEXJh0ej58LzvLyaLxaLub9PELj5IElVZEzTxjQMkjjGTbcjAZ7rUrDFjXA4GIh2Sr+PlCSUyyXGqxWGzoD9RoOdvT2iKGF3d5dLly5x6cEHqFRq6c1MOtLLvD+86Ps1TqbqxyAOQRxH9SqzpJkmsnq9TrPZpLG/j+d5RFFEryeqkazSzHp4qqpimmZeZY7a5GYXffaVDThGQfGO4+QT+bsNe+722GileZSymCXJQ9tDDIB8z8MdCtgNQKlczvuycVpp27ZNf9DHMHQq1QpGyqwqFYt02m22tjbRDF30FoE4inGGjqjCdZ0kjvF9j8D3kSUJVVFoNZt0Ox1kWaZSqVCtVvPzY9s2Zgpx6nY6DAYDCoUCpdTjKTv/umFgpEt913UP2ZcUi0UKhUL+/GwqLrRUnVwbdb/RoJHy7Gfn5qin/cxer8fO9g77ew18X2z7M3/zb1KpVkVvVJJI7pIfjyc7/XCcJM5jEsmRfzMOdTIiTTYxMcHExAT7+/u88cYbDF2XyclJVlZWGA6FoEc26LBtG03T8iV7ZuyVJcpsuJEltgy+lDGPTNPEsqzcrvduYhV3E7cY/d3h5JoQJ4d7ndn03x26REGAIsnYto03HOZMmVqtxli9juu5bG9vUygWkRGJT5Yk2q0WDz34INeuXaXV2KNSKVOpVnHdIYWCTRSHFMslPN+n1+3iDR0MTWV7cwOn36NYLDIxMUG5UiGO41yBKvOAcofDnGll2/Yh73fDMIjCkP1GQyzLAcMwKBQKeU+z2+3SarWIoigXaMlICPv7+ywvL9PpiAHV9MwMlVpN/G5vl/1UwKVQLOL5Pk8++SRXHn1UnFsERfck7h4nS/VjFdLb+n5hEBCkyc6qVPjMZz7DD37wA3Z2d5mdm2N6epo333wTgEqlApA7IGbDIVVVD3HWFUXJq6lRvc4MRpMt77PkN5o0R+E5d1MJupc4hoSUUx7zJO0MxWRalnK/pOFwyPb2NoZl5Lx8P/DZ3NzMX2d/v0GxKJwdl5eXOXv2LH/5/e/z3HPP8fTTH2FychLDNEWFWKnQ2NnLl9uu67KxsUGhUMAwDOr1OsOU468oChMTEwRBwObmZt7PLJVKhGGYK1QZhoHv+3mPs1gsMj8/T+R7+etkVXzmGmpZFpIk0W632UjREdkxXb58mfr4OH3H4eprrxGFAUocUqtVKJaK7O7u0Wi3+cVf+iW84RBDt1J5vJO4V5wkzmMSP6ojJUkSvV6PYqXCw1euUN/aotvp8PTTT3P9+nU2N4VCegbeHgV0j4p9HBX5yPqdQN4DHYXW6OmEWJKk/PlZ8j0qHpJNrUdhTNJIbzMDlQ8HIuGospIC8E0MXcvB/JZlUZ+sI0kS/X6PXq8PQLVWw3VdLNtCV2UC36VQKNBqtTh37hzXrl1jOPT44Ac/yIULF2juN/PX2NraYjAYUCqVOHXqFL1ej2q1ys7eLkFwoJY/HA7zfciW2dnUPGt/9Pt9er0eAPV6ndnZWTqdDns724RBkN+YKtUq9VSxqbW/z+7OTm6Psr29zdTUFHNzc9iFgnjd/X2xMnCHqHFIpVri1q3bRAl8/KMfIxgOMSyLKDmuRMp3HyeJ8xiElMnJHZFYU1IQtW4YJFEIkkIcheiajiyrrK5vcO7iJU6fPs3XvvZVPvaxj3Pp0iV0XUNVZaRERjNSfUY5ZZXEMbIMrf02SAm6boheqGkgITOMHDRFRdIk1JRFc6++ZZYoM3HkbAqfTeizv4uiiF6/h+t5AqTtCxB+sVzBNE0khGVGo9FA0zSmpifRVI2h49Dv9OgP+rlwRWaJ4SUJYRjT6/VYW1tDVXWKxRJSkrCfbkdOSKFWMaZhUK0IoWclHeSomgZxgpHSU5uNfbzAZ3piklK1gpKKGcdRxN72DlSr9NodBu5QeNoXiuimwf5eg729XRRZysVVSqUSmmEQeB7bW1t0Op1cS0CWZarVKqdPn0Y3TTzXpdVqsbe3R6vVIokjPvDIZV78yxeRFI1zZ88wd/o0qmaApKCkQsU5AuMk3hYnifN9HpkW+dv10WUkKUGSU6yJIkMiE5KgmxaV2hjTs3PYdpEPPvEkX//6X9DpdBgM+oyPjxPHIYaqgyISchLFRFFIFMaESYAsgVWwUGUVVZWRJYjCgDgKUGQFVdeQsqU1EnEU4/kBICpReYRFk/VR41RpXVUVAbEJBVUxCAIGjkOUJlk5xaWatonvefR7PZx+n4SEaq2Kpuu4wyG7O9sMBgN0w8A2TVzXpVKpMhw4ab/SQ5EE7bBULOO5PsPBkP29fYqFEoHnsbG5ydjYGHNz88IvXpEJ/QBTN/CHLnEYCTYRoEgS5WIJy7QIfZ8w5YATJxQLRVxniKELPrgiy5AkhJ5Pv9fD93wmJsaxbQs7xYYmScLW9jY7OzuoqkqhUMgHdWP1OoZhICkK7Xabvd1dHMdhfFwMhu4sr9LpO5w+e4ZTZ86hGVaqWaALWwwpQRKNzrt8ok7iJHEeg5AO/+/og4grRIZEQlZUNEmhXKmwsHAKwzQ5d+48KyurKIqC4zgkUUgU+KiGhRd4SEpCHEdpTxMgxtA1bNuCREqrQI8oECIZsqoipxpvUSaCkSo0qaoigPmKnCvviOl3hKoqaJqKqiqCY++5DNOEmSRJLkZRLJaQJPB9j36/R7vVIgx8JienxCBnOKS5t8eg10eSwNIN5AQMTScJQ/rdHpvrm2xtbuEMhpw9e4bx8QlUVWV9fZ1Oq82mukG1UqHdaiNLMtNT00RBSODFaJrQ/Oy223hDF1XTMEwTu2Rhl4poikq/3yOOYqJYVNXlcomh6woVprRiDf1A+CT5AdUUHqXrOpIs47oug34/n8YbhqjsM9pmbWyMJI4Z9Hr5cMm2bQqFAmvr69y+fYfZuXlOnT5HdWyCOBEkCQHwPRiwvT1NniROOEmcJwFk9WgiJUiSgkSMklYwWS/xwoUL9HodpCTBdz1xUSdRzt0GsWw1DANZ1oikCJCQZYkgjBg6Tj4UkiShaykpKnGUMBiIHl+lUsU0dSRZyiFSSBKDQR/btjB0HUVViVNIz9BxSOJYODPKCl4KzLcsk26nS7PXRWiZSCkaoCy42Ts77O/uUq1Wc0B64PvUJie59eab9Ht9rl+/wY0bN6hVq3z84x/n1OIi1WoVy7J48403uXbtGh/76EeZqI/jeR57O7sMi0VBBDBNWs0miqbi+QGmZVEulbALNrKmkwR+yvsWEK0kTsSQqFBk6A6JwghNUwGZKK0CFxdPE0sCCOQMBjSbTVqtFhMTE8wtLOD0+zkzyzRN0e/1fW7fukWr1WJsbIx6vc7W1hZ/9j++wunF8zzxoQ8zPj6eDgoTTMt+m1/USdw9ThLnSeSRwZLcVOLMsqx8KDM/P8/2toKqKNilEqoq09zfp9lssrm5SblcZm5uDsuy6Pf76LpOkNIuw1QBqFarIWsarUYDq1jEGwxwhq4Ydhg6spSyfRKIw4jBoEev12Ph1KlcNzIIfCGHNhRTfVVVsQoFgijCtgRu8fpbb9JutajX61RKJSZmZygUC8RJQmNnhzt3bnPx/AUKtk0UhfiBS7lcZvnWdW7fvsU3vvEttre3GRsb4/EPPs7M3CySLFGpVbl46RKGafLmm2/yre98mytXrjA/P4/re5ixhUbCjZs3ADh79iyTM2LindtqxAH9QY92p5UD5SVZottrCwaTYTA3N5fTNIfDoZiY6wqby8tiENRq0e/3mZ6eZn5hAVL5viAI8ptXu9nkzp07fOUrX+GDH/wgp0+fpt/v841vfIPHH3+cD3/oGWq1GnAgMAJCo1PX9ZzkkA30TuJwSMlPqsP/vyC63S6VSoVOp5PT2k7iJ4/so9DtdglShk2mmKTrOsOhw2DQx3Uc4jDg1KlT3L59G9M02draYm9vj/HxcT701FO5YlC/d6Dj2ev1aLVaAr9pmSDJyLKCaYnKViiqSxiGli9ZwzBM+dkqge/T7XRw+gNUVWVychJF1wl9n63tHba2Rc9ydnaWaqmccsFLaJoqgObdLoN+TwyMktRoLQxwnD63bt3iK1/5Cs8//zxXLj/KJz/1s3z8E5/ggQcfxBn02d/dQzOEgIlt2XiBz7XXr/IX3/wGm2vrnD57hoX5Ber1OnaxgCrJGLYlknelgmlZwksjSVLq4/Yh6b1CoZCTA0qlUg7Kt2ybJI557vnnmZ2bo1qpUCgWIUnY3t6mmNqddLtd4QUky+zt7fGtb32LO3fu8MlPfpLz589z48YNXnrpJer1Or/4q79CHAtaaLbEB0HxzKyfszhuDKF3m1tOEudJ5JF9FDJ8ZnYRZY+rquittZpN+v0uly5exPU8vve973H71i22d3bodrs88cQTfO5zn+PNN97EGTpUq1VmZmYIgoCJiQl836ff72MYJrZdIEi9yiUpwXV9vOGQKApRFQXLsuh2u3i+h6IqFG0B8jYsC384ZGNzk/3mPrZVoJh6BBUKBSQEWDyKIvr9Pq7rIisyS3fuMDU1xWDQZ3l5idu3b7N05w53lpYYGxvjIx/5CJ/4G59ibn5BgNT7fbHfk5NIiuCKkyQgScRhyNDz+NY3v8nXv/51LMvizJkzyIpCuVSiVC7TbO3nwHRFFT7smSBKrVbDsixMw6RYKtLr9djd3WVmWlTIg/6Ajc0N4Y00O0e5WsNxBjT393E9j+mpaUrlEqqq0W63uH79Om+++Sabm5ssLCzw2GOPMTY2xrVr11haWqJQKPB3/+7fFVWkpOU3tAy1kE3kXdfNJQGPW7zb3HL8zsxJ3DMyGbPsazgc5srfInlKaKpGuVyiUimxs7tLrVajWq3ip8vxRx99lNXVVb7//e9j2za9Xi9nwkxOTuL7fq4iD1LeFoiikCSJCf3gQCpNAtcdAkJpXEsUIMkTb6fdRpZlzpw9SxIlyKkie7vVwvd97ty5w97eHpVKhZmZ6Xz5e+PGDV5//TW2tjbp9XrEccyZM2f47Gc/yyMfeJxysSyUmSLhZmkWbBRFIUxiYfKmKEiygqJpRBI89cwzzMzPcfvWLTrtDrPzc5w+tcjNmzeRJIlGo8Hm5iayLLO4uMiZM2cEYycd6gD00wQ9GAx448038t6ypmlMTU1RqZTp9XrsN/cBYXOiGzp7e3usr6+zvr5Oq9VC0zSeeOKJfMkfBAGLi4ssLCyIatm2SZDwvDDX9MwYWhnEa9Tq+STuHieJ8yTeFhmrJwOvZxeXJMkoiopliaWz63rIssLs7BwLC6fw/YA4TrBtmzfffIsPfehDjI3V6fV6rK9vABJBCuCu1+toaUUjyzISCb7nE4Uhqqqg6xqyJIMkEnecJBBFQqsyFb/Q0yV4Y3cXZ+AgIYZPO9vbbKVL4Wq1SsG28FyXvZ1dlleXWV5eptVqCmGTWpWFhVM8+NBDPHLlCsVyhSAQoiCKIuTa1GzpGqc0REkiSmLiOEFWVOoTE5SqVSrVGqsrK3i+T2O/iWGa6KaO4zg0GkL3Ute1VERFpdfr5tbKcRzT6XRSSw7QNDGcK5XLaJrG0tISg6FLFMUCZiQJyubeXiOVltOYnp6hWq0yPT2NLMvifdJCCoViTjZAkonCKL85ZuyurMeZ4WZHbYlP4u1xkjhPIo/sYsqGFrZtH6JRJkmCpMjIskoUJVSrtbTXOMWVK4+gKCp37tyhXC6ztLTEcOimgw6LlZUVev0BnXab4XBIEITYlomWilKYpkkSxfixUExKIfEkcUIURiALu4dup5MvJUulEo29Pe7cuUPgh6iqsPTY3Nyk3W7z9NNP8+CDDxIEARsbG6yurHDr9k12d3dZXFwUzJr5ec5dOM+FS5eIfJ/+wEHVdFRVQ1E1dEOIFgOocuZvHhMGcc65D4MAVVE5feYslWqNV155hZW1NebmZ5AByzZRVQXf99je3kJR5Fxb07btnLO/v79PrVbL+6J2oYAky2xtbHDjxi0UTadaHSOKYjqdbn5zq9fHGRsbo1Ao5O9TuVxGVhRMUwgQCwWsBBJhGmdaQrpuVKEqo+EexyX6/cZJj/Mk8sgmqRlDJwNZZ9qRogIBSBg6Tj6kyCqT4XDIysoK//2//3d83+f06dNcuXKFUqlEEARcvHgxBdEPWFlZod1qIgOTk5MsLi5SKBRo7O2ysbHB3t5erkUpep+uMBZLAe9ZNZwlnmqlxnDoiu222/z8z/88Z86c4dVXX2V1dVWoBVkWxXKB+fkF6vUx5hcWqNSqBEHAzvY21WqVGJlCsYSiqIJtlYowj0J0jnLssyo6QyUI354GL738fYaDAaahI0mid9zv9fA8D8uyGBsTHuVBEIiWQrXK7MwMqqoJgWFVxXOF+Ihp2sRIGIaVV4G2bXP69GmAfJlumqZoLxjCjTJMJ+2yLBOl4selcpkoSvLqMqOuZipLWfuA/3975xobRdXG8f/M7Mx227K71F62BQotFrDcoghlMX6i9hI0KJAgIVINkViLiYDGkCioHyxColGD5ZvgB0AxQSMKpBZaAiwVa3nlouXyFivQbW1r2aXt3mae98Nc2m0LdO11ec8v3aQ75+zMeWan/57Lc54HbHHobjDhZETI/YOKERGuXL6MM2fO4NKlSwCA7OxsFBQUICkpyfA3/KetFR5tnjIUCsHr9aLjjtcIEmy1WmG325GYmICbN2/i/H/+g5s3b8LnU/eQL1q0CBaLBS0tLbh54xb+/LMB7e3tmD9/vhq13udDUlISJqZPwuQpUzBp0iRwJhOUYBBdfp/xDwIcB1FLKqeGjeudyXww96lnrh91Uel6fT1u3LgBjuNgs9mQmJgIu92Ojo4OXLhwAbIsIysrC2lpaeB5LQtpTIy6u8ofgN/fnYcIgLF3XY+JKgyoxzhY+x5MmHAyhomBCWfHnTtqigdZRlNTE+rq6nDt2jVMmzYNixYtUt2bOjvRpe0K6urqQltbG1pbWuD1eowgvmqenjtoa2uFEgrBYrFAFEUjPN3EiRMxefJkNDX9jfr/1qOtrQ2zZs3C+PHjMWXKFCSlJCNWG8IGAgF0+XzgeC3ykiCo2xu1POfhogkMibCQ6nuqJ7GLi4sDQR06Nzc1oaWlxUipIUkSOjo6YLfbkZmZCYfDYcRB5TgeTU3NkGXFaK+e011PRWLkZB9QL5EJZ38Mi3CWlZWhrKwM169fBwDMnDkTW7ZsQWFhIQA16s2mTZuwf/9++P1+5Ofn4/PPP0dKSopxjoaGBhQXF+P48eOIj49HUVERSktLI5pXYcI5mtz/cSGCtq9cMHwl/T4/2v75B5cv14HneUydmonEhx7SgnCo9YOhIAJd6pDcHwggFAoiGArict1l3Gq8hYDmUD9u3DgkJCRg/PjxyJiSgXE2K/w+PzweL/w+H5IdDjXSkCTB51dzhsuyAr/fh9hYdT+3KJogiKKxJ15Nlwwoih7KbnDCok9phLTFHiPSCqDlKjIjEAhqkfBDkGVF3UrZ1aVGUoqLhdms+lfqGwhaWv8Bx/GQRAnmGDNiYvSUy/qQmuu7tfzerfzX9j2oDIs70sSJE7Ft2zZkZWWBiLBnzx4sXboUtbW1mDlzJjZs2IAffvgBBw4cgM1mw/r167Fs2TKcOnUKgDqHtmTJEjgcDpw+fRqNjY1Ys2YNRFHEBx98MDiLGSPEQP7YSF2IUJehIUlmmM0xMGt7qT0eD0IhGYFA0IgjKZoESGYJsbFxUPTEZ3IIckiGJJmROTUTCqlpMURRxDirFRYttFooGERMTCys9vHG3KwuVEFFAU8mmHleXeWWJPAmAQIvaGl8OXAcr4o9KWqEJ+LVvfSDHqpz4HlBE04YaTzUAMHqfZEkM9Sg0upnLDEWTQh5KLICjgMEkwgiwGaza54NWg9ZC+gB6D64ZMzLMoaXQQ/VExISsGPHDqxYsQJJSUnYu3cvVqxYAQD4448/8Mgjj8DlcmHhwoU4fPgwnn76ady6dcvohe7atQtvvfUW/v7777AdC/eC9TjHNnpe9Z4xM/Vj+jDb4/HALEmIi4vtznDJa+4+mgiA1Jea/pYgiCaQoqg+myYBSigEQZTg7+yESZIgaNsDDWduQUDA5wPPCzCJJiikQNDciaCFdFPRYnqSAlJIc8cZGvFRFBl6flH1RwEpHASTKp7qgpKiBTTpFlC9aRzPQRBEdW8/H57Qrnc4Pv04E85/z0C15V/fYVmWsX//fnR0dMDpdKKmpgbBYBC5ublGnRkzZiA9PR0ulwsA4HK5MHv27LChe35+PjweDy5evHjXa/n9fng8nrAXY2zTuzfUM8laTEwMkpOTYbPbVdcfUQIvmIyen1qVA3gBnGCCaI4BeMHYtAOoe9kDgSCgKJBiYsALghZDklP9MENqkBGTqAYGIXCQZQJxWqxJ6jWXyaluVoJJBIYwZYQWNQ5qemb1GrxgAhEHRSGEQjKCQVm9JsdDMEkQTBJMolm9L7yeMK07eHN/97W/9MqM4SNih63z58/D6XTC5/MhPj4eBw8eRHZ2Ns6dOwdJkmC328Pqp6SkwO12A4ARlbp3uV52N0pLS/Hee+9F2lTGKKLnBtcDEOsr5QCMnUS6K0z3HzyvDZXVQB88TyBtyM3zPbYFCuoQOFYb5nZ1dQIcD5NJDYwcY7F0Cwqv9jA5QMuRpIdMI2NeEByHnuOu3hH4BkNvkZNl0nZJkbalVXX9kWVZmxsOdYd0M+6Jan/vtCL9JbdjjAwRC+f06dNx7tw53L59G9988w2KiopQVVU1HG0z2Lx5MzZu3Gi893g8mDRp0rBekzE4LBZLWNIxPQumvrIMaCNxIDxMKM/3WZYJhoIQRXUFHICaUTIYhNksAeBhiY3XzkcIyqEe/pTqPmwQENLiXoom6Z4LKJrH0JCiKKSdl4cgQPP5VFfW1WkIaBsNugVQUchY9OlOF3LvFXNdWFlYuOEnYuGUJAkPP/wwAGDevHk4e/YsPvnkE6xcuRKBQADt7e1hvc6mpiY4HA4AgMPhwM8//xx2vqamJqPsbpjN5jCnXMbYR0+7q6fA0CMs9RRQjue14TlBVrSeIK8LF2c414uiqOUjCoQtjBDUIMnQel+KpsSSKIFA2tCeunMYCSYYe5IIan1oU556TOchH+lyYdcIBlXfS1FUe9tE+vQEGcLIcYDmogm1w8r3aVfPNMi6ULK5zZFj0HdaURT4/WoCK1EUUVFRYZTV1dWhoaEBTqcTAOB0OnH+/Hk0NzcbdcrLy2G1WpGdnT3YpjDGEPrwW59765kjyJir04bQPAcIPAeeVx/Inhqhf0YVTDNMJhEAD15QA/1yvL6Qo4aoM2lzpbyWO4fnePDgtGt1Z/nkOVWUeF793XB5Hwb3Rv06HKdGmDKZeMM29f6gh2iqDRAE9aUHg9YFtef97Tnf2fN8jOEnoh7n5s2bUVhYaGTx27t3LyorK3H06FHYbDasXbsWGzduREJCAqxWK1577TU4nU4sXLgQAJCXl4fs7Gy88MIL2L59O9xuN95++22UlJSwHuUDRO8/3v56QuF17uJ/2ONg39Xivk7qHLjwYX/vk/Z5O/wiY/Se79Imvbyv/f3ekF6fZSI5WkQknM3NzVizZg0aGxths9kwZ84cHD16FE899RQA4OOPPwbP81i+fHmYA7yOIAg4dOgQiouL4XQ6ERcXh6KiIrz//vtDaxWDwWAMI2zLJYPBYGgMux8ng8Fg/L/ChJPBYDAihAkng8FgRAgTTgaDwYgQJpwMBoMRIUw4GQwGI0KiMiuT7kHFoiQxGIyhRNeU+3lpRqVwer1eAGCBPhgMxrDg9Xphs9nuWh6VDvCKoqCurg7Z2dn466+/HngneD0aFLP1wYLZOvYgIni9XiNR3t2Iyh4nz/OYMGECAMBqtY7pL2IoYbY+mDBbxxb36mnqsMUhBoPBiBAmnAwGgxEhUSucZrMZW7du/b8IR8dsfTBhtkYvUbk4xGAwGKNJ1PY4GQwGY7RgwslgMBgRwoSTwWAwIoQJJ4PBYEQIE04Gg8GIkKgUzp07d2LKlCmIiYlBTk5On1zt0ci7775rpHfVXzNmzDDKfT4fSkpK8NBDDyE+Ph7Lly83ctKPdU6cOIFnnnkGaWlp4DgO3377bVg5EWHLli1ITU2FxWJBbm4urly5Elanra0Nq1evhtVqhd1ux9q1a3Hnzp0RtGJg3M/WF198sc/3XFBQEFYnWmwtLS3F/PnzMW7cOCQnJ+PZZ59FXV1dWJ2BPLcNDQ1YsmQJYmNjkZycjDfffBOhUGgkTYmYqBPOr776Chs3bsTWrVvx66+/Yu7cucjPzw/L1R6tzJw5E42Njcbr5MmTRtmGDRvw/fff48CBA6iqqsKtW7ewbNmyUWztwOno6MDcuXOxc+fOfsu3b9+OTz/9FLt27UJ1dTXi4uKQn58Pn89n1Fm9ejUuXryI8vJyHDp0CCdOnMC6detGyoQBcz9bAaCgoCDse963b19YebTYWlVVhZKSEpw5cwbl5eUIBoPIy8tDR0eHUed+z60sy1iyZAkCgQBOnz6NPXv2YPfu3diyZctomDRwKMpYsGABlZSUGO9lWaa0tDQqLS0dxVYNnq1bt9LcuXP7LWtvbydRFOnAgQPGsd9//50AkMvlGqEWDg0A6ODBg8Z7RVHI4XDQjh07jGPt7e1kNptp3759RER06dIlAkBnz5416hw+fJg4jqObN2+OWNsjpbetRERFRUW0dOnSu34mWm0lImpubiYAVFVVRUQDe25//PFH4nme3G63UaesrIysViv5/f6RNSACoqrHGQgEUFNTg9zcXOMYz/PIzc2Fy+UaxZYNDVeuXEFaWhoyMzOxevVqNDQ0AABqamoQDAbD7J4xYwbS09Oj3u76+nq43e4w22w2G3JycgzbXC4X7HY7Hn/8caNObm4ueJ5HdXX1iLd5sFRWViI5ORnTp09HcXExWltbjbJotvX27dsAgISEBAADe25dLhdmz56NlJQUo05+fj48Hg8uXrw4gq2PjKgSzpaWFsiyHHaTASAlJQVut3uUWjU05OTkYPfu3Thy5AjKyspQX1+PJ598El6vF263G5IkwW63h33mQbBbb/+9vlO3243k5OSwcpPJhISEhKizv6CgAF9++SUqKirw4YcfoqqqCoWFhZBlGUD02qooCl5//XU88cQTmDVrFgAM6Ll1u939fvd62VglKsPKPYgUFhYav8+ZMwc5OTmYPHkyvv76a1gsllFsGWMoef75543fZ8+ejTlz5mDq1KmorKzE4sWLR7Flg6OkpAQXLlwIm5d/kImqHmdiYiIEQeizKtfU1ASHwzFKrRoe7HY7pk2bhqtXr8LhcCAQCKC9vT2szoNgt97+e32nDoejz+JfKBRCW1tb1NufmZmJxMREXL16FUB02rp+/XocOnQIx48fx8SJE43jA3luHQ5Hv9+9XjZWiSrhlCQJ8+bNQ0VFhXFMURRUVFTA6XSOYsuGnjt37uDatWtITU3FvHnzIIpimN11dXVoaGiIerszMjLgcDjCbPN4PKiurjZsczqdaG9vR01NjVHn2LFjUBQFOTk5I97moeTGjRtobW1FamoqgOiylYiwfv16HDx4EMeOHUNGRkZY+UCeW6fTifPnz4f9sygvL4fVakV2dvbIGPJvGO3VqUjZv38/mc1m2r17N126dInWrVtHdrs9bFUuGtm0aRNVVlZSfX09nTp1inJzcykxMZGam5uJiOiVV16h9PR0OnbsGP3yyy/kdDrJ6XSOcqsHhtfrpdraWqqtrSUA9NFHH1FtbS39+eefRES0bds2stvt9N1339Fvv/1GS5cupYyMDOrq6jLOUVBQQI8++ihVV1fTyZMnKSsri1atWjVaJt2Ve9nq9XrpjTfeIJfLRfX19fTTTz/RY489RllZWeTz+YxzRIutxcXFZLPZqLKykhobG41XZ2enUed+z20oFKJZs2ZRXl4enTt3jo4cOUJJSUm0efPm0TBpwESdcBIRffbZZ5Senk6SJNGCBQvozJkzo92kQbNy5UpKTU0lSZJowoQJtHLlSrp69apR3tXVRa+++iqNHz+eYmNj6bnnnqPGxsZRbPHAOX78OAHo8yoqKiIi1SXpnXfeoZSUFDKbzbR48WKqq6sLO0drayutWrWK4uPjyWq10ksvvURer3cUrLk397K1s7OT8vLyKCkpiURRpMmTJ9PLL7/c559+tNjan50A6IsvvjDqDOS5vX79OhUWFpLFYqHExETatGkTBYPBEbYmMlg8TgaDwYiQqJrjZDAYjLEAE04Gg8GIECacDAaDESFMOBkMBiNCmHAyGAxGhDDhZDAYjAhhwslgMBgRwoSTwWAwIoQJJ4PBYEQIE04Gg8GIECacDAaDESH/AzuuW0PfFFltAAAAAElFTkSuQmCC",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# 가장 큰 이미지를 출력\n",
-    "biggest_img_path = image_data.iloc[image_data['size'].idxmax(),:]['path']\n",
-    "\n",
-    "img = Image.open(biggest_img_path)\n",
-    "plt.title(f\"Biggest image: {biggest_img_path.split('/')[-1]}\")\n",
-    "plt.imshow(img)\n",
-    "del img"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 277,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array(['./data/train/n04127249/sketch_9.JPEG',\n",
-       "       './data/train/n01484850/sketch_34.JPEG',\n",
-       "       './data/train/n01484850/sketch_0.JPEG',\n",
-       "       './data/train/n01494475/sketch_33.JPEG'], dtype=object)"
-      ]
-     },
-     "execution_count": 277,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# 4개의 작은 이미지를 출력\n",
-    "smallest_img_paths = image_data.nsmallest(4, 'size')['path']\n",
-    "smallest_img_paths.values"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 278,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1600x1000 with 4 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import matplotlib.image as mpimg\n",
-    "\n",
-    "# 4개의 작은 이미지를 출력\n",
-    "fig, axes = plt.subplots(1, 4, figsize=(16, 10))\n",
-    "for i, ax in enumerate(axes.reshape(-1)):\n",
-    "    img = mpimg.imread(smallest_img_paths.values[i])\n",
-    "    ax.title.set_text(f\"Smallest image: {smallest_img_paths.values[i].split('/')[-1]}\")\n",
-    "    ax.imshow(img)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 279,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.image.AxesImage at 0x3076219d0>"
-      ]
-     },
-     "execution_count": 279,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1600x1000 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# 이미지의 종횡비가 가장 큰 이미지를 출력\n",
-    "biggest_aspect_ratio_img_path = image_data.iloc[image_data['img_aspect_ratio'].idxmax(),:]['path']\n",
-    "\n",
-    "fig, ax = plt.subplots(1, 1, figsize=(16, 10))\n",
-    "img = Image.open(biggest_aspect_ratio_img_path)\n",
-    "plt.title(f\"Biggest aspect ratio image: {biggest_aspect_ratio_img_path.split('/')[-1]}\")\n",
-    "plt.imshow(img)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 2.2.2 Diplaying, resizing and manipulation using CV2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 280,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>height</th>\n",
-       "      <th>width</th>\n",
-       "      <th>mode</th>\n",
-       "      <th>format</th>\n",
-       "      <th>size</th>\n",
-       "      <th>class_name_x</th>\n",
-       "      <th>path</th>\n",
-       "      <th>image_path</th>\n",
-       "      <th>img_aspect_ratio</th>\n",
-       "      <th>class_name_y</th>\n",
-       "      <th>target</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>10</th>\n",
-       "      <td>800</td>\n",
-       "      <td>752</td>\n",
-       "      <td>RGB</td>\n",
-       "      <td>JPEG</td>\n",
-       "      <td>0.1</td>\n",
-       "      <td>n02795169</td>\n",
-       "      <td>./data/train/n02795169/sketch_12.JPEG</td>\n",
-       "      <td>n02795169/sketch_12.JPEG</td>\n",
-       "      <td>0.94</td>\n",
-       "      <td>n02795169</td>\n",
-       "      <td>237</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "    height  width mode format  size class_name_x  \\\n",
-       "10     800    752  RGB   JPEG   0.1    n02795169   \n",
-       "\n",
-       "                                     path                image_path  \\\n",
-       "10  ./data/train/n02795169/sketch_12.JPEG  n02795169/sketch_12.JPEG   \n",
-       "\n",
-       "    img_aspect_ratio class_name_y  target  \n",
-       "10              0.94    n02795169     237  "
-      ]
-     },
-     "execution_count": 280,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "img_path = train_images[10]\n",
-    "selected_img = image_data[image_data['path'] == img_path]\n",
-    "selected_img"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 281,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "img = mpimg.imread(img_path)\n",
-    "plt.imshow(img)\n",
-    "plt.axis('off')\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 282,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1600x1000 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "img = cv2.imread(img_path, cv2.IMREAD_COLOR)\n",
-    "resized_img = cv2.resize(img, (0,0), fx=0.5, fy=0.5)\n",
-    "\n",
-    "fig, ax = plt.subplots(1, 2, figsize=(16, 10))\n",
-    "ax[0].imshow(img)\n",
-    "ax[0].set_title(\"Original image\")\n",
-    "ax[1].imshow(resized_img)\n",
-    "ax[1].set_title(\"Resized image\")\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "venv",
-   "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.11.7"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/RECcode/cv/configs/base_train.yaml b/UNet++/cv/configs/base_train.yaml
similarity index 100%
rename from RECcode/cv/configs/base_train.yaml
rename to UNet++/cv/configs/base_train.yaml
diff --git a/RECcode/cv/dataset.py b/UNet++/cv/dataset.py
similarity index 100%
rename from RECcode/cv/dataset.py
rename to UNet++/cv/dataset.py
diff --git a/RECcode/cv/inference.py b/UNet++/cv/inference.py
similarity index 100%
rename from RECcode/cv/inference.py
rename to UNet++/cv/inference.py
diff --git a/RECcode/cv/loss/base_loss.py b/UNet++/cv/loss/base_loss.py
similarity index 100%
rename from RECcode/cv/loss/base_loss.py
rename to UNet++/cv/loss/base_loss.py
diff --git a/RECcode/cv/loss/loss_selector.py b/UNet++/cv/loss/loss_selector.py
similarity index 100%
rename from RECcode/cv/loss/loss_selector.py
rename to UNet++/cv/loss/loss_selector.py
diff --git a/RECcode/cv/models/base_model.py b/UNet++/cv/models/base_model.py
similarity index 100%
rename from RECcode/cv/models/base_model.py
rename to UNet++/cv/models/base_model.py
diff --git a/RECcode/cv/models/model_selector.py b/UNet++/cv/models/model_selector.py
similarity index 100%
rename from RECcode/cv/models/model_selector.py
rename to UNet++/cv/models/model_selector.py
diff --git a/RECcode/cv/scheduler/scheduler_selector.py b/UNet++/cv/scheduler/scheduler_selector.py
similarity index 100%
rename from RECcode/cv/scheduler/scheduler_selector.py
rename to UNet++/cv/scheduler/scheduler_selector.py
diff --git a/RECcode/cv/train.py b/UNet++/cv/train.py
similarity index 100%
rename from RECcode/cv/train.py
rename to UNet++/cv/train.py
diff --git a/RECcode/cv/trainer.py b/UNet++/cv/trainer.py
similarity index 100%
rename from RECcode/cv/trainer.py
rename to UNet++/cv/trainer.py
diff --git a/RECcode/cv/unet.sh b/UNet++/cv/unet.sh
similarity index 100%
rename from RECcode/cv/unet.sh
rename to UNet++/cv/unet.sh
diff --git a/RECcode/cv/utils/wandb.py b/UNet++/cv/utils/wandb.py
similarity index 100%
rename from RECcode/cv/utils/wandb.py
rename to UNet++/cv/utils/wandb.py
diff --git a/RECcode/requirements.txt b/UNet++/requirements.txt
similarity index 100%
rename from RECcode/requirements.txt
rename to UNet++/requirements.txt
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
deleted file mode 100644
index 76c214d..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet-{use-sigmoid}_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
+++ /dev/null
@@ -1,20 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    './chest-x-ray-images-with-pneumothorax-masks_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(
-    imports='datasets.chest-x-ray-images-with-pneumothorax-masks_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(
-        num_classes=2, loss_decode=dict(use_sigmoid=True), out_channels=1),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
deleted file mode 100644
index 066996d..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.0001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
+++ /dev/null
@@ -1,19 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    './chest-x-ray-images-with-pneumothorax-masks_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(
-    imports='datasets.chest-x-ray-images-with-pneumothorax-masks_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.0001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
deleted file mode 100644
index a7065b8..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.001-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
+++ /dev/null
@@ -1,19 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    './chest-x-ray-images-with-pneumothorax-masks_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(
-    imports='datasets.chest-x-ray-images-with-pneumothorax-masks_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.001)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)
diff --git a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py b/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
deleted file mode 100644
index e5682ee..0000000
--- a/mmsegmentation/projects/medical/2d_image/x_ray/chest_x_ray_images_with_pneumothorax_masks/configs/fcn-unet-s5-d16_unet_1xb16-0.01-20k_chest-x-ray-images-with-pneumothorax-masks-512x512.py
+++ /dev/null
@@ -1,19 +0,0 @@
-_base_ = [
-    'mmseg::_base_/models/fcn_unet_s5-d16.py',
-    './chest-x-ray-images-with-pneumothorax-masks_512x512.py',
-    'mmseg::_base_/default_runtime.py',
-    'mmseg::_base_/schedules/schedule_20k.py'
-]
-custom_imports = dict(
-    imports='datasets.chest-x-ray-images-with-pneumothorax-masks_dataset')
-img_scale = (512, 512)
-data_preprocessor = dict(size=img_scale)
-optimizer = dict(lr=0.01)
-optim_wrapper = dict(optimizer=optimizer)
-model = dict(
-    data_preprocessor=data_preprocessor,
-    decode_head=dict(num_classes=2),
-    auxiliary_head=None,
-    test_cfg=dict(mode='whole', _delete_=True))
-vis_backends = None
-visualizer = dict(vis_backends=vis_backends)

From 9e000e659ed8159f8ec1c7792d477cdbf1bc5ea9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=EB=B0=95=EC=A4=80=EC=9D=BC=5FT7154?=
 <116266030+june21a@users.noreply.github.com>
Date: Mon, 2 Dec 2024 12:07:41 +0900
Subject: [PATCH 097/106] [Docs] Update README.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 대회 정책에 위반되지 않도록 X-ray image 제거
- 프로젝트 구조 추가
- train, inference 사용 방법 추가
---
 README.md | 75 ++++++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 71 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 1571da5..5093acf 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,6 @@
 # 📋 Project Overview
 
 
-![project_image](https://github.com/user-attachments/assets/15a67fec-8077-492e-a517-f4a0cee5acbf)
-
 뼈는 우리 몸의 구조와 기능에 중요한 영향을 미치기 때문에, 정확한 뼈 분할은 의료 진단 및 치료 계획을 개발하는 데 필수적입니다.
 
 Bone Segmentation은 인공지능 분야에서 중요한 응용 분야 중 하나로, 특히, 딥러닝 기술을 이용한 뼈 Segmentation은 많은 연구가 이루어지고 있으며, 다양한 목적으로 도움을 줄 수 있습니다.
@@ -36,13 +34,81 @@ hand bone x-ray 객체가 담긴 이미지가 모델의 인풋으로 사용됩
 ![image](https://github.com/user-attachments/assets/7a596f2c-e7e2-415f-872a-d812a7b47825)
 
 -  image, target 시각화 및 pixel 별로 예측해야할 29개의 classes
-  
-![image](https://github.com/user-attachments/assets/3474aac7-4542-4437-ad49-514a9dd72212)
 
 <br/>
 <br/>
 <br/>
 
+# 📁 Project Structure
+```plaintext
+.
+├── .github/
+├── augmentation/
+│   ├── copy_data.py
+│   ├── hflip.py
+│   ├── outlier.py
+│   ├── psnr.py
+├── mmsegmentation/
+│   ├── configs/
+│   ├── mmseg/
+│   ├── tools/
+│   ├── baseline.py
+│   ├── custom_inference.py
+│   ├── custom_train.py
+├── module_base/
+│   ├── config.yaml
+│   ├── dataset.py
+│   ├── inference.py
+│   ├── loss.py
+│   ├── model.py
+│   ├── optimizer.py
+│   ├── scheduler.py
+│   ├── train.py
+│   ├── transform.py
+│   ├── wandb_logger.py
+│   ├── wandb_train.py
+├── sam2_unet/
+│   ├── sam2/
+│   ├── sam2_configs/
+│   ├── utils/
+│   ├── SAM2UNet.py
+│   ├── config.yaml
+│   ├── test.py
+│   ├── train.py
+│   ├── trainer.py
+├── streamlit/
+│   ├── compare.py
+│   ├── load.py
+│   ├── main.py
+│   ├── visualize.py
+│   ├── visualize_rle.py
+├── utils/
+│   ├── .gitignore
+│   ├── README.md
+│   ├── meta_data_set.py
+│   ├── pseudo_labeling.py
+```
+
+# How To Use
+
+## MMSegmentation
+- MMSegmentation Install 후 본 Project 폴더를 그대로 Copy & Paste하여 활용
+```plaintext
+# train
+python custom_train.py --config_path {path_to_your_config} --work_dir {path_to_your_save_dir_for_logging}
+
+# inference
+python custom_inference.py --config_path {path_to_your_config} --checkpoint_path {path_to_your_weights} --work_dir {path_to_your_save_dir_for_logging} --submission_path {where_to_save_your_submission_csv} --tta
+```
+
+## SAM2Unet
+```plaintext
+```
+
+## Module_base
+```plaintext
+```
+
 # 😄 Team Member
 
 <table align="center">
@@ -79,6 +145,7 @@ hand bone x-ray 객체가 담긴 이미지가 모델의 인풋으로 사용됩
 ## 🔗 Reference
 
 ### [📎 Segmentation Notion](https://www.notion.so/Hand-Bone-Image-Segmentation-13bcb8c4237680f0baeef241f0f6856b)
+### [📎 Wrapup Report]
 
 <br>
 

From 5ccfede66aa75144b4d2ebe0d6a35ec45320d88c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=EB=B0=95=EC=A4=80=EC=9D=BC=5FT7154?=
 <116266030+june21a@users.noreply.github.com>
Date: Mon, 2 Dec 2024 12:12:12 +0900
Subject: [PATCH 098/106] [docs] Update README.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

project structure 수정
---
 README.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/README.md b/README.md
index 7669733..b469d78 100644
--- a/README.md
+++ b/README.md
@@ -48,6 +48,9 @@ hand bone x-ray 객체가 담긴 이미지가 모델의 인풋으로 사용됩
 │   ├── hflip.py
 │   ├── outlier.py
 │   ├── psnr.py
+├── UNet++/
+│   ├── cv/
+│   ├── requirements.txt
 ├── mmsegmentation/
 │   ├── configs/
 │   ├── mmseg/

From e0e848408aa0e5a32c2091cb05ed6d77763ebcaf Mon Sep 17 00:00:00 2001
From: sejongmin <113002267+sejongmin@users.noreply.github.com>
Date: Wed, 4 Dec 2024 22:48:42 +0900
Subject: [PATCH 099/106] [Docs] : Update README.md

---
 README.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/README.md b/README.md
index b469d78..c9cde37 100644
--- a/README.md
+++ b/README.md
@@ -106,6 +106,11 @@ python custom_inference.py --config_path {path_to_your_config} --checkpoint_path
 
 ## SAM2Unet
 ```plaintext
+# train
+python train.py --config {path_to_your_config}
+
+# inference
+python test.py --config {path_to_your_config} --checkpoint {path_to_your_checkpoint}
 ```
 
 ## Module_base

From 3be090b00bf4db3c5085741c1efbba96c063988b Mon Sep 17 00:00:00 2001
From: minrongtic <81347544+minrongtic@users.noreply.github.com>
Date: Thu, 5 Dec 2024 16:33:27 +0900
Subject: [PATCH 100/106] Update README.md

---
 README.md | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index c9cde37..2d02b56 100644
--- a/README.md
+++ b/README.md
@@ -15,14 +15,13 @@ Bone Segmentation은 인공지능 분야에서 중요한 응용 분야 중 하
 <br/>
 
 
-- Input :
-
-hand bone x-ray 객체가 담긴 이미지가 모델의 인풋으로 사용됩니다. segmentation annotation은 json file로 제공됩니다.
+- Input : 
+    - hand bone x-ray 객체가 담긴 이미지가 모델의 인풋으로 사용됩니다. segmentation annotation은 json file로 제공됩니다.
 
 - Output :
 
-모델은 각 클래스(29개)에 대한 확률 맵을 갖는 멀티채널 예측을 수행하고, 이를 기반으로 각 픽셀을 해당 클래스에 할당합니다.
-최종적으로 예측된 결과를 Run-Length Encoding(RLE) 형식으로 변환하여 csv 파일로 제출합니다.
+    - 모델은 각 클래스(29개)에 대한 확률 맵을 갖는 멀티채널 예측을 수행하고, 이를 기반으로 각 픽셀을 해당 클래스에 할당합니다.
+    - 최종적으로 예측된 결과를 Run-Length Encoding(RLE) 형식으로 변환하여 csv 파일로 제출합니다.
 
 <br/>
 <br/>

From 820e53a3030ed25da3c4e873793642ba40188737 Mon Sep 17 00:00:00 2001
From: minrongtic <81347544+minrongtic@users.noreply.github.com>
Date: Thu, 5 Dec 2024 16:34:08 +0900
Subject: [PATCH 101/106] Update README.md

---
 README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 2d02b56..79b01f5 100644
--- a/README.md
+++ b/README.md
@@ -16,7 +16,8 @@ Bone Segmentation은 인공지능 분야에서 중요한 응용 분야 중 하
 
 
 - Input : 
-    - hand bone x-ray 객체가 담긴 이미지가 모델의 인풋으로 사용됩니다. segmentation annotation은 json file로 제공됩니다.
+    - hand bone x-ray 객체가 담긴 이미지가 모델의 인풋으로 사용됩니다.
+    - segmentation annotation은 json file로 제공됩니다.
 
 - Output :
 

From be31eb85666fde6a9caffabf8c88d3370bbab8b7 Mon Sep 17 00:00:00 2001
From: cv3 <hsy0320@hufs.ac.kr>
Date: Wed, 18 Dec 2024 11:28:27 +0900
Subject: [PATCH 102/106] refine

---
 module_base/train.py       |  73 ++++++++---
 module_base/wandb_train.py | 253 -------------------------------------
 2 files changed, 52 insertions(+), 274 deletions(-)
 delete mode 100644 module_base/wandb_train.py

diff --git a/module_base/train.py b/module_base/train.py
index 362e782..7858303 100644
--- a/module_base/train.py
+++ b/module_base/train.py
@@ -5,30 +5,30 @@
 
 import numpy as np
 from tqdm.auto import tqdm
-import albumentations as A
 
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-import torch.optim as optim
 from torch.utils.data import DataLoader
 
-from dataset import XRayDataset
+from dataset import XRayDataset, XRayDatasetWithMixup
 from model import ModelSelector
 from transform import TransformSelector
 from loss import LossSelector
 from scheduler import SchedulerSelector
+from optimizer import OptimizerSelector
 
 import warnings
 warnings.filterwarnings('ignore')
 
 from omegaconf import OmegaConf
 from argparse import ArgumentParser
+from wandb_logger import WandbLogger
 
 def set_seed(random_seed):
     torch.manual_seed(random_seed)
     torch.cuda.manual_seed(random_seed)
-    torch.cuda.manual_seed_all(random_seed) # if use multi-GPU
+    torch.cuda.manual_seed_all(random_seed)
     torch.backends.cudnn.deterministic = True
     torch.backends.cudnn.benchmark = False
     np.random.seed(random_seed)
@@ -60,6 +60,7 @@ def set_data(cfg):
 def save_model(model, save_dir, file_name='best_model.pt'):
     output_path = os.path.join(save_dir, file_name)
     torch.save(model, output_path)
+    return output_path
 
 def validation(epoch, model, val_loader, criterion, model_type, thr=0.5):
     print(f'Start validation #{epoch:2d}')
@@ -91,11 +92,8 @@ def validation(epoch, model, val_loader, criterion, model_type, thr=0.5):
             cnt += 1
             
             outputs = torch.sigmoid(outputs)
-            # outputs = (outputs > thr).detach().cpu()
-            # masks = masks.detach().cpu()
             outputs = (outputs > thr)
             dice = dice_coef(outputs, masks)
-            # dices.append(dice)
             dices.append(dice.detach().cpu())
                 
     dices = torch.cat(dices, 0)
@@ -108,17 +106,29 @@ def validation(epoch, model, val_loader, criterion, model_type, thr=0.5):
     print(dice_str)
     
     avg_dice = torch.mean(dices_per_class).item()
+    val_loss = total_loss / len(val_loader.dataset)
     
-    return avg_dice
+    return avg_dice, val_loss
 
 def train(model, train_loader, val_loader, criterion, optimizer, scheduler, cfg):
     print(f'Start training..')
+    logger = WandbLogger(name=cfg.wandb_run_name)
+    
+    wandb_config = {
+        "model_name": cfg.model_name,
+        "model_backbone": cfg.encoder_name,
+        "learning_rate": cfg.lr,
+        "max_epoch": cfg.max_epoch,
+        "optimizer": cfg.optim,
+        "criterion": cfg.loss.name
+    }
     best_dice = 0.
-
     scaler = torch.cuda.amp.GradScaler()
     model = model.cuda()
+    logger.initialize(wandb_config)
     
     for epoch in range(cfg.max_epoch):
+        epoch_loss = 0
         torch.cuda.empty_cache() # 학습 시작 전 캐시 삭제
         model.train()
         for step, (images, masks) in enumerate(train_loader):
@@ -132,12 +142,24 @@ def train(model, train_loader, val_loader, criterion, optimizer, scheduler, cfg)
                 elif cfg.model_type == 'smp':
                     outputs = model(images)
                 loss = criterion(outputs, masks)
+                # loss = loss / cfg.step
             # 스케일된 loss를 사용해 backward 및 optimizer step
+            epoch_loss += loss.item()
             optimizer.zero_grad()
             scaler.scale(loss).backward()
             scaler.step(optimizer)
             scaler.update()
-            
+            # gradient accumulation 사용 시 변경
+            '''
+            scaler.scale(loss).backward()
+            epoch_loss += loss.item() * cfg.step
+
+            # gradient accumulation
+            if (step + 1) % cfg.step == 0:
+                scaler.step(optimizer)
+                scaler.update()
+                optimizer.zero_grad()
+            '''
             # step 주기에 따라 loss를 출력합니다.
             if (step + 1) % 80 == 0:
                 print(
@@ -147,15 +169,24 @@ def train(model, train_loader, val_loader, criterion, optimizer, scheduler, cfg)
                     f'Loss: {round(loss.item(),4)}'
                 )
         scheduler.step()
-        # validation 주기에 따라 loss를 출력하고 best model을 저장
+        # validation 주기에 따라 loss를 출력하고 best model을 저장합니다.
         if (epoch + 1) % cfg.val_every == 0:
-            dice = validation(epoch + 1, model, val_loader, criterion, cfg.model_type)
-            
+            dice, val_loss = validation(epoch + 1, model, val_loader, criterion, cfg.model_type)
             if best_dice < dice:
                 print(f"Best performance at epoch: {epoch + 1}, {best_dice:.4f} -> {dice:.4f}")
-                print(f"Save model in {cfg.save_dir}")
                 best_dice = dice
-                save_model(model, cfg.save_dir)
+                ckpt_path = save_model(model, cfg.save_dir)
+                print(f"Save model in {cfg.save_dir}")
+            logger.log_model(ckpt_path, f'model-epoch-{epoch+1}')
+            logger.log_epoch_metrics(
+                {
+                    "epoch": epoch,
+                    "loss": epoch_loss / len(train_loader.dataset),
+                    "dice": dice,
+                    "val_loss": val_loss
+                }
+            )
+    logger.finish()
 
 def main(cfg):
     set_seed(cfg.random_seed)
@@ -169,7 +200,7 @@ def main(cfg):
     val_trans = TransformSelector('albumentation')
     val_tf = val_trans.get_transform(False, cfg.size)
 
-    train_dataset = XRayDataset(fnames, labels, cfg.image_root, cfg.label_root, cfg.kfold, train_tf, is_train=True)
+    train_dataset = XRayDatasetWithMixup(fnames, labels, cfg.image_root, cfg.label_root, cfg.kfold, train_tf, is_train=True)
     valid_dataset = XRayDataset(fnames, labels, cfg.image_root, cfg.label_root, cfg.kfold, val_tf, is_train=False)
     
     train_loader = DataLoader(
@@ -198,19 +229,19 @@ def main(cfg):
     )
     model = model_selector.get_model()
     
-    # criterion = nn.BCEWithLogitsLoss()
     if cfg.loss.params:
         loss = LossSelector(cfg.loss.name, **cfg.loss.params)
     else:
         loss = LossSelector(cfg.loss.name)
     criterion = loss.get_loss()
 
-    optimizer = optim.Adam(params=model.parameters(), lr=cfg.lr, weight_decay=cfg.weight_decay)
-    
-    train(model, train_loader, valid_loader, criterion, optimizer, scheduler, cfg)
-    
+    optim = OptimizerSelector(cfg.optim, model, cfg.lr, cfg.weight_decay)
+    optimizer = optim.get_optim()
+
     sched = SchedulerSelector(cfg.scheduler, optimizer, cfg.max_epoch)
     scheduler = sched.get_sched()
+    
+    train(model, train_loader, valid_loader, criterion, optimizer, scheduler, cfg)
 
 if __name__ == '__main__':
     parser = ArgumentParser()
diff --git a/module_base/wandb_train.py b/module_base/wandb_train.py
deleted file mode 100644
index 7858303..0000000
--- a/module_base/wandb_train.py
+++ /dev/null
@@ -1,253 +0,0 @@
-# python native
-import os
-import random
-import datetime
-
-import numpy as np
-from tqdm.auto import tqdm
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch.utils.data import DataLoader
-
-from dataset import XRayDataset, XRayDatasetWithMixup
-from model import ModelSelector
-from transform import TransformSelector
-from loss import LossSelector
-from scheduler import SchedulerSelector
-from optimizer import OptimizerSelector
-
-import warnings
-warnings.filterwarnings('ignore')
-
-from omegaconf import OmegaConf
-from argparse import ArgumentParser
-from wandb_logger import WandbLogger
-
-def set_seed(random_seed):
-    torch.manual_seed(random_seed)
-    torch.cuda.manual_seed(random_seed)
-    torch.cuda.manual_seed_all(random_seed)
-    torch.backends.cudnn.deterministic = True
-    torch.backends.cudnn.benchmark = False
-    np.random.seed(random_seed)
-    random.seed(random_seed)
-
-def dice_coef(y_true, y_pred):
-    y_true_f = y_true.flatten(2)
-    y_pred_f = y_pred.flatten(2)
-    intersection = torch.sum(y_true_f * y_pred_f, -1)
-    eps = 0.0001
-    return (2. * intersection + eps) / (torch.sum(y_true_f, -1) + torch.sum(y_pred_f, -1) + eps)
-
-def set_data(cfg):
-    pngs = {
-        os.path.relpath(os.path.join(root, fname), start=cfg.image_root)
-        for root, _dirs, files in os.walk(cfg.image_root)
-        for fname in files
-        if os.path.splitext(fname)[1].lower() == ".png"
-    }
-
-    jsons = {
-        os.path.relpath(os.path.join(root, fname), start=cfg.label_root)
-        for root, _dirs, files in os.walk(cfg.label_root)
-        for fname in files
-        if os.path.splitext(fname)[1].lower() == ".json"
-    }
-    return np.array(sorted(pngs)), np.array(sorted(jsons))
-
-def save_model(model, save_dir, file_name='best_model.pt'):
-    output_path = os.path.join(save_dir, file_name)
-    torch.save(model, output_path)
-    return output_path
-
-def validation(epoch, model, val_loader, criterion, model_type, thr=0.5):
-    print(f'Start validation #{epoch:2d}')
-    model.eval()
-
-    dices = []
-    with torch.no_grad():
-        total_loss = 0
-        cnt = 0
-
-        for step, (images, masks) in tqdm(enumerate(val_loader), total=len(val_loader)):
-            images, masks = images.cuda(), masks.cuda()         
-            model = model.cuda()
-            
-            if model_type == 'torchvision':
-                outputs = model(images)['out']
-            elif model_type == 'smp':
-                outputs = model(images)
-            
-            output_h, output_w = outputs.size(-2), outputs.size(-1)
-            mask_h, mask_w = masks.size(-2), masks.size(-1)
-            
-            # gt와 prediction의 크기가 다른 경우 prediction을 gt에 맞춰 interpolation 합니다.
-            if output_h != mask_h or output_w != mask_w:
-                outputs = F.interpolate(outputs, size=(mask_h, mask_w), mode="bilinear")
-            
-            loss = criterion(outputs, masks)
-            total_loss += loss
-            cnt += 1
-            
-            outputs = torch.sigmoid(outputs)
-            outputs = (outputs > thr)
-            dice = dice_coef(outputs, masks)
-            dices.append(dice.detach().cpu())
-                
-    dices = torch.cat(dices, 0)
-    dices_per_class = torch.mean(dices, 0)
-    dice_str = [
-        f"{c:<12}: {d.item():.4f}"
-        for c, d in zip(val_loader.dataset.classes, dices_per_class)
-    ]
-    dice_str = "\n".join(dice_str) 
-    print(dice_str)
-    
-    avg_dice = torch.mean(dices_per_class).item()
-    val_loss = total_loss / len(val_loader.dataset)
-    
-    return avg_dice, val_loss
-
-def train(model, train_loader, val_loader, criterion, optimizer, scheduler, cfg):
-    print(f'Start training..')
-    logger = WandbLogger(name=cfg.wandb_run_name)
-    
-    wandb_config = {
-        "model_name": cfg.model_name,
-        "model_backbone": cfg.encoder_name,
-        "learning_rate": cfg.lr,
-        "max_epoch": cfg.max_epoch,
-        "optimizer": cfg.optim,
-        "criterion": cfg.loss.name
-    }
-    best_dice = 0.
-    scaler = torch.cuda.amp.GradScaler()
-    model = model.cuda()
-    logger.initialize(wandb_config)
-    
-    for epoch in range(cfg.max_epoch):
-        epoch_loss = 0
-        torch.cuda.empty_cache() # 학습 시작 전 캐시 삭제
-        model.train()
-        for step, (images, masks) in enumerate(train_loader):
-            # gpu 연산을 위해 device 할당합니다.
-            images, masks = images.cuda(), masks.cuda()
-            
-            # Mixed Precision Training으로 loss 계산에서만 FP32 사용
-            with torch.cuda.amp.autocast():
-                if cfg.model_type == 'torchvision':
-                    outputs = model(images)['out']
-                elif cfg.model_type == 'smp':
-                    outputs = model(images)
-                loss = criterion(outputs, masks)
-                # loss = loss / cfg.step
-            # 스케일된 loss를 사용해 backward 및 optimizer step
-            epoch_loss += loss.item()
-            optimizer.zero_grad()
-            scaler.scale(loss).backward()
-            scaler.step(optimizer)
-            scaler.update()
-            # gradient accumulation 사용 시 변경
-            '''
-            scaler.scale(loss).backward()
-            epoch_loss += loss.item() * cfg.step
-
-            # gradient accumulation
-            if (step + 1) % cfg.step == 0:
-                scaler.step(optimizer)
-                scaler.update()
-                optimizer.zero_grad()
-            '''
-            # step 주기에 따라 loss를 출력합니다.
-            if (step + 1) % 80 == 0:
-                print(
-                    f'{datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")} | '
-                    f'Epoch [{epoch+1}/{cfg.max_epoch}], '
-                    f'Step [{step+1}/{len(train_loader)}], '
-                    f'Loss: {round(loss.item(),4)}'
-                )
-        scheduler.step()
-        # validation 주기에 따라 loss를 출력하고 best model을 저장합니다.
-        if (epoch + 1) % cfg.val_every == 0:
-            dice, val_loss = validation(epoch + 1, model, val_loader, criterion, cfg.model_type)
-            if best_dice < dice:
-                print(f"Best performance at epoch: {epoch + 1}, {best_dice:.4f} -> {dice:.4f}")
-                best_dice = dice
-                ckpt_path = save_model(model, cfg.save_dir)
-                print(f"Save model in {cfg.save_dir}")
-            logger.log_model(ckpt_path, f'model-epoch-{epoch+1}')
-            logger.log_epoch_metrics(
-                {
-                    "epoch": epoch,
-                    "loss": epoch_loss / len(train_loader.dataset),
-                    "dice": dice,
-                    "val_loss": val_loss
-                }
-            )
-    logger.finish()
-
-def main(cfg):
-    set_seed(cfg.random_seed)
-    fnames, labels = set_data(cfg)
-
-    if not os.path.exists(cfg.save_dir):
-        os.makedirs(cfg.save_dir)
-    
-    train_trans = TransformSelector('albumentation')
-    train_tf = train_trans.get_transform(True, cfg.size)
-    val_trans = TransformSelector('albumentation')
-    val_tf = val_trans.get_transform(False, cfg.size)
-
-    train_dataset = XRayDatasetWithMixup(fnames, labels, cfg.image_root, cfg.label_root, cfg.kfold, train_tf, is_train=True)
-    valid_dataset = XRayDataset(fnames, labels, cfg.image_root, cfg.label_root, cfg.kfold, val_tf, is_train=False)
-    
-    train_loader = DataLoader(
-        dataset=train_dataset, 
-        batch_size=cfg.train_batch_size,
-        shuffle=True,
-        num_workers=cfg.train_num_workers,
-        drop_last=True,
-    )
-    
-    valid_loader = DataLoader(
-        dataset=valid_dataset, 
-        batch_size=cfg.valid_batch_size,
-        shuffle=False,
-        num_workers=cfg.valid_num_workers,
-        drop_last=False
-    )
-    
-    model_selector = ModelSelector(
-        model_type=cfg.model_type,
-        num_classes=len(valid_loader.dataset.classes),
-        model_name=cfg.model_name,
-        encoder_name=cfg.encoder_name,
-        encoder_weights=cfg.encoder_weights
-        # pretrained=cfg.pretrained
-    )
-    model = model_selector.get_model()
-    
-    if cfg.loss.params:
-        loss = LossSelector(cfg.loss.name, **cfg.loss.params)
-    else:
-        loss = LossSelector(cfg.loss.name)
-    criterion = loss.get_loss()
-
-    optim = OptimizerSelector(cfg.optim, model, cfg.lr, cfg.weight_decay)
-    optimizer = optim.get_optim()
-
-    sched = SchedulerSelector(cfg.scheduler, optimizer, cfg.max_epoch)
-    scheduler = sched.get_sched()
-    
-    train(model, train_loader, valid_loader, criterion, optimizer, scheduler, cfg)
-
-if __name__ == '__main__':
-    parser = ArgumentParser()
-    parser.add_argument('--config', type=str, default='config.yaml')
-    args = parser.parse_args()
-
-    with open(args.config, 'r') as f:
-        cfg = OmegaConf.load(f)
-    main(cfg)
\ No newline at end of file

From 26a3a95d45d151067d5e6ce5ef4e86172162b5ad Mon Sep 17 00:00:00 2001
From: june21a <june21r@gmail.com>
Date: Thu, 19 Dec 2024 14:44:36 +0900
Subject: [PATCH 103/106] [Comment]: add function and class descriptions

---
 mmsegmentation/mmseg/datasets/xray.py         |   6 +
 mmsegmentation/mmseg/datasets/xray2.py        |  13 ++
 .../evaluation/metrics/submission_metric.py   |  51 +++++++-
 .../mmseg/models/decode_heads/custom.py       |   7 ++
 .../mmseg/models/segmentors/custom.py         | 119 ++++--------------
 5 files changed, 93 insertions(+), 103 deletions(-)

diff --git a/mmsegmentation/mmseg/datasets/xray.py b/mmsegmentation/mmseg/datasets/xray.py
index 458e2c2..e9f7d14 100644
--- a/mmsegmentation/mmseg/datasets/xray.py
+++ b/mmsegmentation/mmseg/datasets/xray.py
@@ -5,6 +5,12 @@
 
 @DATASETS.register_module()
 class XRayDataset(BaseSegDataset):
+    """ cityscapes format으로 변환된 XRay Segmentation dataset을 불러오기 위한 Dataset Class
+        Args:
+            data_root (str) : cityscapes format 데이터셋이 위치한 root directory
+            data_prefix (str) : 사용할 이미지, mask json prefix
+            pipeline (List[:obj:`mmseg.registry.TRANSFORMS`]) : raw image, mask로부터 torch tensor로 로드하기까지의 pipeline list
+    """
     METAINFO = dict(
             classes = [
                 'finger-1', 'finger-2', 'finger-3', 'finger-4', 'finger-5',
diff --git a/mmsegmentation/mmseg/datasets/xray2.py b/mmsegmentation/mmseg/datasets/xray2.py
index a4a2e85..8abba67 100644
--- a/mmsegmentation/mmseg/datasets/xray2.py
+++ b/mmsegmentation/mmseg/datasets/xray2.py
@@ -28,6 +28,12 @@
 
 @DATASETS.register_module()
 class XRayDataset2(BaseSegDataset):
+    """ Multi Label Segmentation task를 위해 Xray Dataset을 불러오기 위한 Dataset Class
+        Args:
+            is_train (bool) : train mode와 val mode일 때 group fold의  fold_num을 다르게 가져가기 위한 설정값
+            image_root (str) : 환자별 DCM이미지가 들어있는 directory
+            label_root (str) : 환자별 Segmentation mask json 파일이 들어있는 directory
+    """
     def __init__(self, 
                  is_train, 
                  image_root='/data/ephemeral/home/data/train/DCM',
@@ -107,6 +113,9 @@ def load_data_list(self):
 
 @TRANSFORMS.register_module()
 class LoadXRayAnnotations(BaseTransform):
+    """ 
+    label json file path로부터 mask를 load해오기 위한 Transform Class
+    """
     def transform(self, result):
         label_path = result["seg_map_path"]
 
@@ -139,6 +148,10 @@ def transform(self, result):
     
 @TRANSFORMS.register_module()
 class TransposeAnnotations(BaseTransform):
+    """ 
+    segmentation map은 image가 tensor로 변환될 때 채널이 앞에 오도록 자동으로 바뀌지 않으므로, 
+    이를 적용해주기 위한 Transform Class 정의
+    """
     def transform(self, result):
         result["gt_seg_map"] = np.transpose(result["gt_seg_map"], (2, 0, 1))
         
diff --git a/mmsegmentation/mmseg/evaluation/metrics/submission_metric.py b/mmsegmentation/mmseg/evaluation/metrics/submission_metric.py
index 2185e15..864f015 100644
--- a/mmsegmentation/mmseg/evaluation/metrics/submission_metric.py
+++ b/mmsegmentation/mmseg/evaluation/metrics/submission_metric.py
@@ -40,6 +40,19 @@
 
 @METRICS.register_module()
 class SubmissionMetric(BaseMetric):
+    """ 따로 test code를 작성하지 않고 runner.test()만으로 제출파일을 생성하기 위한 Metric Class
+        Args:
+        collect_device (str): Device name used for collecting results from
+            different ranks during distributed training. Must be 'cpu' or
+            'gpu'. Defaults to 'cpu'.
+        prefix (str, optional): The prefix that will be added in the metric
+            names to disambiguate homonymous metrics of different evaluators.
+            If prefix is not provided in the argument, self.default_prefix
+            will be used instead. Default: None
+        save_path (str) : submission.csv와 시각화 결과를 저장할 경로
+        max_vis_cnt (int) : 최대 몇개의 test image를 시각화할 것인지
+        multi_label (bool) : 시각화 시 Multi label을 고려하는 경우와 아닌 경우 처리가 달라지기 때문에 정의
+    """
     def __init__(self,
                  collect_device='cpu',
                  prefix=None,
@@ -49,7 +62,7 @@ def __init__(self,
                  **kwargs):
         super().__init__(collect_device=collect_device, prefix=prefix)
         self.save_path = save_path
-        if self.save_path == '':
+        if not self.save_path:
             self.save_path = '/data/ephemeral/home/submission'
         
         os.makedirs(self.save_path, exist_ok=True)
@@ -58,10 +71,12 @@ def __init__(self,
         self.max_vis_cnt = max_vis_cnt
         self.multi_label=multi_label
         
-        # self.rles = []
-        # self.filename_and_class = []
         
     def label2rgb(self, label):
+        '''
+        label: numpy array mask (C, H, W)
+        Returns mask image
+        '''
         label = np.array(label)
         image_size = label.shape[1:] + (3, )
         image = np.zeros(image_size, dtype=np.uint8)
@@ -110,6 +125,17 @@ def convert_to_class_masks(self, mask):
     
 
     def decode_rle_to_mask(self, rle, height, width):
+        """
+        make mask image from rle string
+        
+        Parameters :
+        - rle : string which contains rle info of mask
+        - height : image height
+        - width : image width
+        
+        Returns :
+        - img : numpy array of shape (height, width) where each pixel contains class number
+        """
         s = rle.split()
         starts, lengths = [np.asarray(x, dtype=int) for x in (s[0:][::2], s[1:][::2])]
         starts -= 1
@@ -123,6 +149,12 @@ def decode_rle_to_mask(self, rle, height, width):
     
     
     def process(self, data_batch, data_samples):
+        """
+        process model outputs and save to self.results
+        Parameters :
+        - data_batch
+        - data_samples : batched model outputs. list of dictionary
+        """
         for data_sample in data_samples:
             img_path = data_sample['img_path']
             img_name = os.path.basename(img_path).split('_')[1]
@@ -144,7 +176,7 @@ def process(self, data_batch, data_samples):
                 preds.append(pred)
                 self.results.append((rle, f"{CLASSES[i]}_{img_name}"))
             
-            
+            # 정해진 갯수까지 시각화
             if self.cnt < self.max_vis_cnt:
                 self.cnt += 1
                 fig, ax = plt.subplots(1, 2, figsize=(24, 12))
@@ -155,8 +187,17 @@ def process(self, data_batch, data_samples):
                 plt.close()
             
         
-            
+    
     def compute_metrics(self, results):
+        """
+        make submission.csv from self.results
+        
+        Parameters :
+        - results : list(rles(str))
+        
+        Returns :
+        - dictionary which contains status 1
+        """
         classes, filename = zip(*[x[1].split("_") for x in self.results])
         image_name = [f for f in filename]
         
diff --git a/mmsegmentation/mmseg/models/decode_heads/custom.py b/mmsegmentation/mmseg/models/decode_heads/custom.py
index 396ff82..3b427f4 100644
--- a/mmsegmentation/mmseg/models/decode_heads/custom.py
+++ b/mmsegmentation/mmseg/models/decode_heads/custom.py
@@ -6,6 +6,13 @@
 
 
 class LossByFeatMixIn:
+    """
+    기존 BaseDecoderHead에서 Accuracy를 계산하여 return하는 부분을 제거하기 위해
+    loss_by_feat method를 오버라이딩.
+    accuracy function이 single class만 고려하기 때문에 오류를 피하기 위해 오버라이딩.
+    """
+    
+    
     def loss_by_feat(self, seg_logits, batch_data_samples) -> dict:
         """Compute segmentation loss.
 
diff --git a/mmsegmentation/mmseg/models/segmentors/custom.py b/mmsegmentation/mmseg/models/segmentors/custom.py
index a53b4a0..ed9246d 100644
--- a/mmsegmentation/mmseg/models/segmentors/custom.py
+++ b/mmsegmentation/mmseg/models/segmentors/custom.py
@@ -9,6 +9,15 @@
 
 
 class PostProcessResultMixin:
+    """
+    기존 모델 output이 (B, C, H, W)일 때 픽셀별 argmax 적용 -> single label을 고려
+    하지만 Bone Segmentation은 Multi Label Segmentation Task이므로 변경 필요.
+    
+    이 점을 고려하여 해당 부분을 픽셀별 각 클래스에 대해 sigmoid 적용 후 threshold를 활용하여
+    픽셀별 각 클래스에 대한 이진분류를 수행하도록 post process를 변경
+    """
+    
+    
     def postprocess_result(self,
                            seg_logits,
                            data_samples):
@@ -69,14 +78,22 @@ def postprocess_result(self,
             else:
                 i_seg_logits = seg_logits[i]
 
-            # if self.module.decode_head.threshold:
-            #     threshold = self.module.decode_head.threshold
+            
+            threshold = 0.5
+            
+            #############################################################
+            # 기존 코드
+            # if C > 1:
+            #     i_seg_pred = i_seg_logits.argmax(dim=0, keepdim=True)
             # else:
-            #     threshold = 0.5
-            threshold = 0.45
+            #     i_seg_logits = i_seg_logits.sigmoid()
+            #     i_seg_pred = (i_seg_logits >
+            #                   self.decode_head.threshold).to(i_seg_logits)
             
+            # 수정된 코드 : 픽셀별 multi label을 고려하여 sigmoid 적용
             i_seg_logits = i_seg_logits.sigmoid()
             i_seg_pred = (i_seg_logits > threshold).to(i_seg_logits)
+            #############################################################
             
             data_samples[i].set_data({
                 'seg_logits':
@@ -87,100 +104,6 @@ def postprocess_result(self,
 
         return data_samples
 
-# class PostProcessResultMixin:
-#     def postprocess_result(self, seg_logits, data_samples):
-#         """Convert results list to `SegDataSample`.
-#         Args:
-#             seg_logits (Tensor): The segmentation results, seg_logits from
-#                 model of each input image.
-#             data_samples (list[:obj:`SegDataSample`]): The seg data samples.
-#                 It usually includes information such as `metainfo` and
-#                 `gt_sem_seg`. Default to None.
-#         Returns:
-#             list[:obj:`SegDataSample`]: Segmentation results of the
-#             input images. Each SegDataSample usually contain:
-
-#             - ``pred_sem_seg``(PixelData): Prediction of semantic segmentation.
-#             - ``seg_logits``(PixelData): Predicted logits of semantic
-#                 segmentation before normalization.
-#         """
-#         batch_size, C, H, W = seg_logits.shape
-
-#         if data_samples is None:
-#             data_samples = [SegDataSample() for _ in range(batch_size)]
-#             only_prediction = True
-#         else:
-#             only_prediction = False
-
-#         for i in range(batch_size):
-#             if not only_prediction:
-#                 img_meta = data_samples[i].metainfo
-#                 # remove padding area
-#                 if "img_padding_size" not in img_meta:
-#                     padding_size = img_meta.get("padding_size", [0] * 4)
-#                 else:
-#                     padding_size = img_meta["img_padding_size"]
-#                 padding_left, padding_right, padding_top, padding_bottom = padding_size
-#                 # i_seg_logits shape is 1, C, H, W after remove padding
-#                 i_seg_logits = seg_logits[
-#                     i : i + 1,
-#                     :,
-#                     padding_top : H - padding_bottom,
-#                     padding_left : W - padding_right,
-#                 ]
-
-#                 flip = img_meta.get("flip", None)
-#                 if flip:
-#                     flip_direction = img_meta.get("flip_direction", None)
-#                     assert flip_direction in ["horizontal", "vertical"]
-#                     if flip_direction == "horizontal":
-#                         i_seg_logits = i_seg_logits.flip(dims=(3,))
-#                     else:
-#                         i_seg_logits = i_seg_logits.flip(dims=(2,))
-
-#                 # resize as original shape
-#                 i_seg_logits = resize(
-#                     i_seg_logits,
-#                     size=img_meta["ori_shape"],
-#                     mode="bilinear",
-#                     align_corners=self.align_corners,
-#                     warning=False,
-#                 ).squeeze(0)
-#             else:
-#                 i_seg_logits = seg_logits[i]
-
-#             # i_seg_logits = i_seg_logits.sigmoid()
-#             # i_seg_pred = (i_seg_logits > self.decode_head.threshold).to(i_seg_logits)
-#             # Sigmoid로 변환하여 confidence 계산
-#             i_seg_logits = i_seg_logits.sigmoid()  # [C, H, W]
-
-#             # 각 픽셀별로 상위 2개의 클래스의 confidence 값과 인덱스 추출
-#             topk_values, topk_indices = i_seg_logits.topk(2, dim=0)  # topk_values, topk_indices: [2, H, W]
-
-#             # Threshold 기준을 적용하여 confidence 값이 threshold 이상인 경우만 남김
-#             threshold_mask = topk_values > self.decode_head.threshold  # [2, H, W]
-
-#             # i_seg_pred 초기화
-#             i_seg_pred = torch.zeros_like(i_seg_logits)  # [C, H, W]
-
-#             # threshold를 만족하는 상위 2개 클래스만 유지하고, 나머지는 0으로 처리
-#             for j in range(2):  # 최대 2개의 클래스만 선택
-#                 # topk_indices는 [2, H, W]에서 i번째 인덱스 추출, 이를 [1, H, W]로 유지
-#                 class_indices = topk_indices[j:j+1, :, :]  # [1, H, W]
-#                 class_mask = threshold_mask[j:j+1, :, :].to(i_seg_logits.dtype)  # [1, H, W]
-                
-#                 # 선택된 클래스 위치에 값을 설정
-#                 i_seg_pred.scatter_(0, class_indices, class_mask)
-                
-#             data_samples[i].set_data(
-#                 {
-#                     "seg_logits": PixelData(**{"data": i_seg_logits}),
-#                     "pred_sem_seg": PixelData(**{"data": i_seg_pred}),
-#                 }
-#             )
-
-#         return data_samples
-
 
 @MODELS.register_module()
 class EncoderDecoderWithoutArgmax(PostProcessResultMixin, EncoderDecoder):

From 1782f453e26fc232b6b85a3441afcc21e74405b4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=EB=B0=95=EC=A4=80=EC=9D=BC=5FT7154?=
 <116266030+june21a@users.noreply.github.com>
Date: Thu, 19 Dec 2024 16:23:03 +0900
Subject: [PATCH 104/106] Update README.md

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 79b01f5..2520695 100644
--- a/README.md
+++ b/README.md
@@ -165,6 +165,7 @@ python test.py --config {path_to_your_config} --checkpoint {path_to_your_checkpo
 ## 🔗 Reference
 
 ### [📎 Segmentation Notion](https://typhoon-jackal-68b.notion.site/Hand-Bone-Image-Segmentation-13bcb8c4237680f0baeef241f0f6856b?pvs=4)
+### [📎 Wrapup Report](https://drive.google.com/file/d/16JiuSqBly_KZjU3llmOk3-TqeC8OdEIU/view?usp=sharing)
 
 <br>
 

From 210a89641845382109799562b1cee7583114fb89 Mon Sep 17 00:00:00 2001
From: HanSeungYoon <104001741+Yoon0717@users.noreply.github.com>
Date: Fri, 20 Dec 2024 16:42:24 +0900
Subject: [PATCH 105/106] Update README.md

---
 README.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/README.md b/README.md
index 2520695..1b80e19 100644
--- a/README.md
+++ b/README.md
@@ -114,7 +114,13 @@ python test.py --config {path_to_your_config} --checkpoint {path_to_your_checkpo
 ```
 
 ## Module_base
+- yaml 파일로 hyperparameter 관리
 ```plaintext
+# train
+python train.py
+
+# inference
+python inference.py
 ```
 
 # 😄 Team Member

From dd5c932adb10abacfce1d325305ab79f8947cb20 Mon Sep 17 00:00:00 2001
From: minrongtic <81347544+minrongtic@users.noreply.github.com>
Date: Mon, 23 Dec 2024 10:26:25 +0900
Subject: [PATCH 106/106] Update README_WrapupReport.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 1b80e19..d51f93c 100644
--- a/README.md
+++ b/README.md
@@ -171,7 +171,7 @@ python inference.py
 ## 🔗 Reference
 
 ### [📎 Segmentation Notion](https://typhoon-jackal-68b.notion.site/Hand-Bone-Image-Segmentation-13bcb8c4237680f0baeef241f0f6856b?pvs=4)
-### [📎 Wrapup Report](https://drive.google.com/file/d/16JiuSqBly_KZjU3llmOk3-TqeC8OdEIU/view?usp=sharing)
+### [📎 Wrapup Report](https://drive.google.com/file/d/1CRU9BKnrnQbjTWOvkJIf7IOSXEsdBYrO/view?usp=sharing)
 
 <br>